diff --git a/compiler-rt/.arcconfig b/compiler-rt/.arcconfig
new file mode 100644
index 0000000..ef3e327
--- /dev/null
+++ b/compiler-rt/.arcconfig
@@ -0,0 +1,4 @@
+{
+  "project_id" : "compiler-rt",
+  "conduit_uri" : "http://reviews.llvm.org/"
+}
diff --git a/compiler-rt/Android.bp b/compiler-rt/Android.bp
new file mode 100644
index 0000000..b057c23
--- /dev/null
+++ b/compiler-rt/Android.bp
@@ -0,0 +1,441 @@
+//
+// Copyright (C) 2012 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+//=====================================================================
+// Static Library: libcompiler_rt-extras
+//=====================================================================
+
+cc_library_static {
+    name: "libcompiler_rt-extras",
+    host_supported: true,
+    clang: true,
+    sdk_version: "19",
+    // The following list contains functions that are not available in libgcc.a, so
+    // we potentially need them when using a Clang-built component (e.g., -ftrapv
+    // with 64-bit integer multiplies. See http://llvm.org/bugs/show_bug.cgi?id=14469.)
+    srcs: ["lib/builtins/mulodi4.c"],
+    sanitize: {
+        never: true,
+    },
+    stl: "none",
+
+    cflags: [
+        "-Wno-unused-parameter",
+        "-Werror",
+    ],
+
+    arch: {
+        mips: {
+            srcs: ["lib/builtins/clear_cache.c"],
+        },
+        mips64: {
+            srcs: ["lib/builtins/clear_cache.c"],
+        },
+        // Clang generates call to __unorddf2 builtin when compiling s_fmal.c
+        // in bionic.  Generate this builtin from compiler-rt for arm64 and
+        // x86_64 (where the corresponding libgcc does not have this builtin.
+        arm64: {
+            srcs: ["lib/builtins/comparedf2.c"],
+        },
+        x86_64: {
+            srcs: ["lib/builtins/comparedf2.c"],
+        },
+    },
+
+    target: {
+        windows: {
+            enabled: true,
+        },
+    },
+}
+
+//=====================================================================
+// Device and Host Static Library: libcompiler_rt
+//=====================================================================
+
+cc_library {
+    name: "libcompiler_rt",
+    host_supported: true,
+    // The following list contains platform-independent functionalities.
+    //
+    // Skip apple_versioning.c since it is unused.
+    // Skip atomic.c since it needs to be built separately according to the docs.
+    srcs: [
+        "lib/builtins/enable_execute_stack.c",
+        "lib/builtins/absvdi2.c",
+        "lib/builtins/absvsi2.c",
+        "lib/builtins/absvti2.c",
+        "lib/builtins/adddf3.c",
+        "lib/builtins/addsf3.c",
+        "lib/builtins/addtf3.c",
+        "lib/builtins/addvdi3.c",
+        "lib/builtins/addvsi3.c",
+        "lib/builtins/addvti3.c",
+        "lib/builtins/ashldi3.c",
+        "lib/builtins/ashlti3.c",
+        "lib/builtins/ashrdi3.c",
+        "lib/builtins/ashrti3.c",
+        "lib/builtins/clear_cache.c",
+        "lib/builtins/clzdi2.c",
+        "lib/builtins/clzsi2.c",
+        "lib/builtins/clzti2.c",
+        "lib/builtins/cmpdi2.c",
+        "lib/builtins/cmpti2.c",
+        "lib/builtins/comparedf2.c",
+        "lib/builtins/comparesf2.c",
+        "lib/builtins/comparetf2.c",
+        "lib/builtins/ctzdi2.c",
+        "lib/builtins/ctzsi2.c",
+        "lib/builtins/ctzti2.c",
+        "lib/builtins/divdc3.c",
+        "lib/builtins/divdf3.c",
+        "lib/builtins/divdi3.c",
+        "lib/builtins/divmoddi4.c",
+        "lib/builtins/divmodsi4.c",
+        "lib/builtins/divsc3.c",
+        "lib/builtins/divsf3.c",
+        "lib/builtins/divsi3.c",
+        "lib/builtins/divtf3.c",
+        "lib/builtins/divti3.c",
+        "lib/builtins/divxc3.c",
+        "lib/builtins/eprintf.c",
+        "lib/builtins/extenddftf2.c",
+        "lib/builtins/extendhfsf2.c",
+        "lib/builtins/extendsfdf2.c",
+        "lib/builtins/extendsftf2.c",
+        "lib/builtins/ffsdi2.c",
+        "lib/builtins/ffsti2.c",
+        "lib/builtins/fixdfdi.c",
+        "lib/builtins/fixdfsi.c",
+        "lib/builtins/fixdfti.c",
+        "lib/builtins/fixsfdi.c",
+        "lib/builtins/fixsfsi.c",
+        "lib/builtins/fixsfti.c",
+        "lib/builtins/fixtfdi.c",
+        "lib/builtins/fixtfsi.c",
+        "lib/builtins/fixtfti.c",
+        "lib/builtins/fixunsdfdi.c",
+        "lib/builtins/fixunsdfsi.c",
+        "lib/builtins/fixunsdfti.c",
+        "lib/builtins/fixunssfdi.c",
+        "lib/builtins/fixunssfsi.c",
+        "lib/builtins/fixunssfti.c",
+        "lib/builtins/fixunstfdi.c",
+        "lib/builtins/fixunstfsi.c",
+        "lib/builtins/fixunstfti.c",
+        "lib/builtins/fixunsxfdi.c",
+        "lib/builtins/fixunsxfsi.c",
+        "lib/builtins/fixunsxfti.c",
+        "lib/builtins/fixxfdi.c",
+        "lib/builtins/fixxfti.c",
+        "lib/builtins/floatdidf.c",
+        "lib/builtins/floatdisf.c",
+        "lib/builtins/floatdixf.c",
+        "lib/builtins/floatsidf.c",
+        "lib/builtins/floatsisf.c",
+        "lib/builtins/floatsitf.c",
+        "lib/builtins/floattidf.c",
+        "lib/builtins/floattisf.c",
+        "lib/builtins/floattixf.c",
+        "lib/builtins/floatundidf.c",
+        "lib/builtins/floatundisf.c",
+        "lib/builtins/floatundixf.c",
+        "lib/builtins/floatunsidf.c",
+        "lib/builtins/floatunsisf.c",
+        "lib/builtins/floatunsitf.c",
+        "lib/builtins/floatuntidf.c",
+        "lib/builtins/floatuntisf.c",
+        "lib/builtins/floatuntixf.c",
+        "lib/builtins/gcc_personality_v0.c",
+        "lib/builtins/int_util.c",
+        "lib/builtins/lshrdi3.c",
+        "lib/builtins/lshrti3.c",
+        "lib/builtins/moddi3.c",
+        "lib/builtins/modsi3.c",
+        "lib/builtins/modti3.c",
+        "lib/builtins/muldc3.c",
+        "lib/builtins/muldf3.c",
+        "lib/builtins/muldi3.c",
+        "lib/builtins/mulodi4.c",
+        "lib/builtins/mulosi4.c",
+        "lib/builtins/muloti4.c",
+        "lib/builtins/mulsc3.c",
+        "lib/builtins/mulsf3.c",
+        "lib/builtins/multf3.c",
+        "lib/builtins/multi3.c",
+        "lib/builtins/mulvdi3.c",
+        "lib/builtins/mulvsi3.c",
+        "lib/builtins/mulvti3.c",
+        "lib/builtins/mulxc3.c",
+        "lib/builtins/negdf2.c",
+        "lib/builtins/negdi2.c",
+        "lib/builtins/negsf2.c",
+        "lib/builtins/negti2.c",
+        "lib/builtins/negvdi2.c",
+        "lib/builtins/negvsi2.c",
+        "lib/builtins/negvti2.c",
+        "lib/builtins/paritydi2.c",
+        "lib/builtins/paritysi2.c",
+        "lib/builtins/parityti2.c",
+        "lib/builtins/popcountdi2.c",
+        "lib/builtins/popcountsi2.c",
+        "lib/builtins/popcountti2.c",
+        "lib/builtins/powidf2.c",
+        "lib/builtins/powisf2.c",
+        "lib/builtins/powitf2.c",
+        "lib/builtins/powixf2.c",
+        "lib/builtins/subdf3.c",
+        "lib/builtins/subsf3.c",
+        "lib/builtins/subtf3.c",
+        "lib/builtins/subvdi3.c",
+        "lib/builtins/subvsi3.c",
+        "lib/builtins/subvti3.c",
+        "lib/builtins/trampoline_setup.c",
+        "lib/builtins/truncdfhf2.c",
+        "lib/builtins/truncdfsf2.c",
+        "lib/builtins/truncsfhf2.c",
+        "lib/builtins/trunctfdf2.c",
+        "lib/builtins/trunctfsf2.c",
+        "lib/builtins/ucmpdi2.c",
+        "lib/builtins/ucmpti2.c",
+        "lib/builtins/udivdi3.c",
+        "lib/builtins/udivmoddi4.c",
+        "lib/builtins/udivmodsi4.c",
+        "lib/builtins/udivmodti4.c",
+        "lib/builtins/udivsi3.c",
+        "lib/builtins/udivti3.c",
+        "lib/builtins/umoddi3.c",
+        "lib/builtins/umodsi3.c",
+        "lib/builtins/umodti3.c",
+    ],
+
+    cflags: [
+        "-Wno-unused-parameter",
+        "-Werror",
+    ],
+
+    arch: {
+        arm: {
+            cflags: ["-D__ARM_EABI__"],
+            srcs: [
+                "lib/builtins/arm/aeabi_dcmp.S",
+                "lib/builtins/arm/aeabi_div0.c",
+                "lib/builtins/arm/aeabi_fcmp.S",
+                "lib/builtins/arm/aeabi_idivmod.S",
+                "lib/builtins/arm/aeabi_ldivmod.S",
+                "lib/builtins/arm/aeabi_memcmp.S",
+                "lib/builtins/arm/aeabi_memcpy.S",
+                "lib/builtins/arm/aeabi_memmove.S",
+                "lib/builtins/arm/aeabi_memset.S",
+                "lib/builtins/arm/aeabi_uidivmod.S",
+                "lib/builtins/arm/aeabi_uldivmod.S",
+                "lib/builtins/arm/comparesf2.S",
+                "lib/builtins/arm/divmodsi4.S",
+                "lib/builtins/arm/divsi3.S",
+                "lib/builtins/arm/modsi3.S",
+                "lib/builtins/arm/udivmodsi4.S",
+                "lib/builtins/arm/udivsi3.S",
+                "lib/builtins/arm/umodsi3.S",
+                "lib/builtins/arm/adddf3vfp.S",
+                "lib/builtins/arm/addsf3vfp.S",
+                "lib/builtins/arm/divdf3vfp.S",
+                "lib/builtins/arm/divsf3vfp.S",
+                "lib/builtins/arm/eqdf2vfp.S",
+                "lib/builtins/arm/eqsf2vfp.S",
+                "lib/builtins/arm/extendsfdf2vfp.S",
+                "lib/builtins/arm/fixdfsivfp.S",
+                "lib/builtins/arm/fixsfsivfp.S",
+                "lib/builtins/arm/fixunsdfsivfp.S",
+                "lib/builtins/arm/fixunssfsivfp.S",
+                "lib/builtins/arm/floatsidfvfp.S",
+                "lib/builtins/arm/floatsisfvfp.S",
+                "lib/builtins/arm/floatunssidfvfp.S",
+                "lib/builtins/arm/floatunssisfvfp.S",
+                "lib/builtins/arm/gedf2vfp.S",
+                "lib/builtins/arm/gesf2vfp.S",
+                "lib/builtins/arm/gtdf2vfp.S",
+                "lib/builtins/arm/gtsf2vfp.S",
+                "lib/builtins/arm/ledf2vfp.S",
+                "lib/builtins/arm/lesf2vfp.S",
+                "lib/builtins/arm/ltdf2vfp.S",
+                "lib/builtins/arm/ltsf2vfp.S",
+                "lib/builtins/arm/muldf3vfp.S",
+                "lib/builtins/arm/mulsf3vfp.S",
+                "lib/builtins/arm/nedf2vfp.S",
+                "lib/builtins/arm/negdf2vfp.S",
+                "lib/builtins/arm/negsf2vfp.S",
+                "lib/builtins/arm/nesf2vfp.S",
+                "lib/builtins/arm/subdf3vfp.S",
+                "lib/builtins/arm/subsf3vfp.S",
+                "lib/builtins/arm/truncdfsf2vfp.S",
+                "lib/builtins/arm/unorddf2vfp.S",
+                "lib/builtins/arm/unordsf2vfp.S",
+            ],
+            exclude_srcs: [
+                "lib/builtins/comparesf2.c",
+                "lib/builtins/divmodsi4.c",
+                "lib/builtins/divsi3.c",
+                "lib/builtins/modsi3.c",
+                "lib/builtins/udivmodsi4.c",
+                "lib/builtins/udivsi3.c",
+                "lib/builtins/umodsi3.c",
+            ],
+        },
+        mips64: {
+            cflags: [
+                "-DCRT_HAS_128BIT",
+            ],
+        },
+        x86: {
+            srcs: [
+                "lib/builtins/i386/ashldi3.S",
+                "lib/builtins/i386/ashrdi3.S",
+                "lib/builtins/i386/divdi3.S",
+                "lib/builtins/i386/floatdidf.S",
+                "lib/builtins/i386/floatdisf.S",
+                "lib/builtins/i386/floatdixf.S",
+                "lib/builtins/i386/floatundidf.S",
+                "lib/builtins/i386/floatundisf.S",
+                "lib/builtins/i386/floatundixf.S",
+                "lib/builtins/i386/lshrdi3.S",
+                "lib/builtins/i386/moddi3.S",
+                "lib/builtins/i386/muldi3.S",
+                "lib/builtins/i386/udivdi3.S",
+                "lib/builtins/i386/umoddi3.S",
+            ],
+            exclude_srcs: [
+                "lib/builtins/ashldi3.c",
+                "lib/builtins/ashrdi3.c",
+                "lib/builtins/divdi3.c",
+                "lib/builtins/floatdidf.c",
+                "lib/builtins/floatdisf.c",
+                "lib/builtins/floatdixf.c",
+                "lib/builtins/floatundidf.c",
+                "lib/builtins/floatundisf.c",
+                "lib/builtins/floatundixf.c",
+                "lib/builtins/lshrdi3.c",
+                "lib/builtins/moddi3.c",
+                "lib/builtins/muldi3.c",
+                "lib/builtins/udivdi3.c",
+                "lib/builtins/umoddi3.c",
+            ],
+        },
+        x86_64: {
+            srcs: [
+                "lib/builtins/x86_64/floatundixf.S",
+                "lib/builtins/x86_64/floatdisf.c",
+                "lib/builtins/x86_64/floatdidf.c",
+                "lib/builtins/x86_64/floatdixf.c",
+                "lib/builtins/x86_64/floatundisf.S",
+                "lib/builtins/x86_64/floatundidf.S",
+            ],
+            exclude_srcs: [
+                "lib/builtins/floatundixf.c",
+                "lib/builtins/floatdisf.c",
+                "lib/builtins/floatdidf.c",
+                "lib/builtins/floatdixf.c",
+                "lib/builtins/floatundisf.c",
+                "lib/builtins/floatundidf.c",
+            ],
+        },
+    },
+
+    sdk_version: "21",
+    target: {
+        not_windows: {
+            host_ldlibs: [
+                "-lpthread",
+                "-lc",
+                "-lm",
+            ],
+        },
+        android: {
+            shared_libs: ["libdl", "liblog"],
+            static_libs: ["liblzma"],
+        },
+        android_arm: {
+            static_libs: ["libunwind_llvm"],
+            ldflags: ["-Wl,--exclude-libs,libunwind_llvm.a"],
+        },
+        android_arm64: {
+            static_libs: ["libunwindbacktrace"],
+            ldflags: ["-Wl,--exclude-libs,libunwindbacktrace.a"],
+        },
+        android_mips: {
+            static_libs: ["libunwindbacktrace"],
+            ldflags: ["-Wl,--exclude-libs,libunwindbacktrace.a"],
+        },
+        android_mips64: {
+            static_libs: ["libunwindbacktrace"],
+            ldflags: ["-Wl,--exclude-libs,libunwindbacktrace.a"],
+        },
+        android_x86: {
+            static_libs: ["libunwindbacktrace"],
+            ldflags: ["-Wl,--exclude-libs,libunwindbacktrace.a"],
+        },
+        android_x86_64: {
+            srcs: ["lib/builtins/ppc/floatditf.c"],
+            static_libs: ["libunwindbacktrace"],
+            ldflags: ["-Wl,--exclude-libs,libunwindbacktrace.a"],
+        },
+        linux: {
+            static_libs: ["libunwindbacktrace"],
+        },
+        windows: {
+            static_libs: ["libunwindbacktrace"],
+            // Only build enable_execute_stack.c on non-Windows hosts.
+            exclude_srcs: ["lib/builtins/enable_execute_stack.c"],
+        },
+    },
+
+    asflags: ["-integrated-as"],
+    clang: true,
+    no_libgcc: true,
+
+    sanitize: {
+        never: true,
+    },
+    stl: "none",
+}
+
+cc_defaults {
+    name: "asan_arch_defaults",
+
+    enabled: false,
+    target: {
+        android_arm: {
+            enabled: true,
+        },
+        android_arm64: {
+            enabled: true,
+        },
+        android_mips: {
+            enabled: true,
+        },
+        android_mips64: {
+            enabled: true,
+        },
+        android_x86: {
+            enabled: true,
+        },
+        linux: {
+            enabled: true,
+        },
+    },
+}
+
+subdirs=["lib/*"]
diff --git a/compiler-rt/CMakeLists.txt b/compiler-rt/CMakeLists.txt
new file mode 100644
index 0000000..5f8b4d1
--- /dev/null
+++ b/compiler-rt/CMakeLists.txt
@@ -0,0 +1,323 @@
+# CMake build for CompilerRT.
+#
+# This build assumes that CompilerRT is checked out into the
+# 'projects/compiler-rt' inside of an LLVM tree.
+# Standalone build system for CompilerRT is not yet ready.
+#
+# An important constraint of the build is that it only produces libraries
+# based on the ability of the host toolchain to target various platforms.
+
+# Check if compiler-rt is built as a standalone project.
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  project(CompilerRT C CXX ASM)
+  set(COMPILER_RT_STANDALONE_BUILD TRUE)
+else()
+  set(COMPILER_RT_STANDALONE_BUILD FALSE)
+endif()
+
+# The CompilerRT build system requires CMake version 2.8.8 or higher in order
+# to use its support for building convenience "libraries" as a collection of
+# .o files. This is particularly useful in producing larger, more complex
+# runtime libraries.
+if (NOT MSVC)
+  cmake_minimum_required(VERSION 2.8.8)
+else()
+  # Version 2.8.12.1 is required to build with Visual Studio 2013.
+  cmake_minimum_required(VERSION 2.8.12.1)
+endif()
+
+# FIXME: It may be removed when we use 2.8.12.
+if(CMAKE_VERSION VERSION_LESS 2.8.12)
+  # Invalidate a couple of keywords.
+  set(cmake_2_8_12_INTERFACE)
+  set(cmake_2_8_12_PRIVATE)
+else()
+  # Use ${cmake_2_8_12_KEYWORD} intead of KEYWORD in target_link_libraries().
+  set(cmake_2_8_12_INTERFACE INTERFACE)
+  set(cmake_2_8_12_PRIVATE PRIVATE)
+  if(POLICY CMP0022)
+    cmake_policy(SET CMP0022 NEW) # automatic when 2.8.12 is required
+  endif()
+endif()
+
+# Top level target used to build all compiler-rt libraries.
+add_custom_target(compiler-rt ALL)
+
+option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON)
+mark_as_advanced(COMPILER_RT_BUILD_BUILTINS)
+option(COMPILER_RT_BUILD_SANITIZERS "Build sanitizers" ON)
+mark_as_advanced(COMPILER_RT_BUILD_SANITIZERS)
+
+if (NOT COMPILER_RT_STANDALONE_BUILD)
+  # Compute the Clang version from the LLVM version.
+  # FIXME: We should be able to reuse CLANG_VERSION variable calculated
+  #        in Clang cmake files, instead of copying the rules here.
+  string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
+         ${PACKAGE_VERSION})
+  # Setup the paths where compiler-rt runtimes and headers should be stored.
+  set(COMPILER_RT_OUTPUT_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION})
+  set(COMPILER_RT_EXEC_OUTPUT_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
+  set(COMPILER_RT_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
+  option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests."
+         ${LLVM_INCLUDE_TESTS})
+ option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered"
+        ${LLVM_ENABLE_WERROR})
+  # Use just-built Clang to compile/link tests on all platforms, except for
+  # Windows where we need to use clang-cl instead.
+  if(NOT MSVC)
+    set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang)
+  else()
+    set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang.exe)
+  endif()
+else()
+  # Take output dir and install path from the user.
+  set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH
+    "Path where built compiler-rt libraries should be stored.")
+  set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH
+    "Path where built compiler-rt executables should be stored.")
+  set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH
+    "Path where built compiler-rt libraries should be installed.")
+  option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." OFF)
+  option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" OFF)
+  # Use a host compiler to compile/link tests.
+  set(COMPILER_RT_TEST_COMPILER ${CMAKE_C_COMPILER} CACHE PATH "Compiler to use for testing")
+
+  if (NOT LLVM_CONFIG_PATH)
+    find_program(LLVM_CONFIG_PATH "llvm-config"
+                 DOC "Path to llvm-config binary")
+    if (NOT LLVM_CONFIG_PATH)
+      message(FATAL_ERROR "llvm-config not found: specify LLVM_CONFIG_PATH")
+    endif()
+  endif()
+  execute_process(
+    COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root"
+    RESULT_VARIABLE HAD_ERROR
+    OUTPUT_VARIABLE CONFIG_OUTPUT)
+  if (HAD_ERROR)
+    message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
+  endif()
+  string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT})
+  list(GET CONFIG_OUTPUT 0 LLVM_BINARY_DIR)
+  list(GET CONFIG_OUTPUT 1 LLVM_TOOLS_BINARY_DIR)
+  list(GET CONFIG_OUTPUT 2 LLVM_LIBRARY_DIR)
+  list(GET CONFIG_OUTPUT 3 LLVM_MAIN_SRC_DIR)
+
+  # Make use of LLVM CMake modules.
+  file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE)
+  set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR_CMAKE_STYLE}/share/llvm/cmake")
+  list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
+  # Get some LLVM variables from LLVMConfig.
+  include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake")
+
+  set(LLVM_LIBRARY_OUTPUT_INTDIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
+
+  # Find Python interpreter.
+  set(Python_ADDITIONAL_VERSIONS 2.7 2.6 2.5)
+  include(FindPythonInterp)
+  if(NOT PYTHONINTERP_FOUND)
+    message(FATAL_ERROR "
+      Unable to find Python interpreter required testing. Please install Python
+      or specify the PYTHON_EXECUTABLE CMake variable.")
+  endif()
+
+  # Define default arguments to lit.
+  set(LIT_ARGS_DEFAULT "-sv")
+  if (MSVC OR XCODE)
+    set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
+  endif()
+  set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
+endif()
+
+if("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang[+]*$")
+  set(COMPILER_RT_TEST_COMPILER_ID Clang)
+elseif("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang.*.exe$")
+  set(COMPILER_RT_TEST_COMPILER_ID Clang)
+else()
+  set(COMPILER_RT_TEST_COMPILER_ID GNU)
+endif()
+
+set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING
+    "Default triple for which compiler-rt runtimes will be built.")
+if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE)
+  # Backwards compatibility: this variable used to be called
+  # COMPILER_RT_TEST_TARGET_TRIPLE.
+  set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${COMPILER_RT_TEST_TARGET_TRIPLE})
+endif()
+
+string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE})
+list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH)
+list(GET TARGET_TRIPLE_LIST 1 COMPILER_RT_DEFAULT_TARGET_OS)
+list(GET TARGET_TRIPLE_LIST 2 COMPILER_RT_DEFAULT_TARGET_ABI)
+# Determine if test target triple is specified explicitly, and doesn't match the
+# default.
+if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL TARGET_TRIPLE)
+  set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE)
+else()
+  set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE)
+endif()
+
+if ("${COMPILER_RT_DEFAULT_TARGET_ABI}" STREQUAL "androideabi")
+  set(ANDROID 1)
+endif()
+
+string(TOLOWER ${CMAKE_SYSTEM_NAME} COMPILER_RT_OS_DIR)
+set(COMPILER_RT_LIBRARY_OUTPUT_DIR
+  ${COMPILER_RT_OUTPUT_DIR}/lib/${COMPILER_RT_OS_DIR})
+set(COMPILER_RT_LIBRARY_INSTALL_DIR
+  ${COMPILER_RT_INSTALL_PATH}/lib/${COMPILER_RT_OS_DIR})
+
+# Add path for custom compiler-rt modules.
+set(CMAKE_MODULE_PATH
+  "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
+  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
+  ${CMAKE_MODULE_PATH}
+  )
+include(CompilerRTUtils)
+
+set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+# We support running instrumented tests when we're not cross compiling
+# and target a UNIX-like system or Windows.
+# We can run tests on Android even when we are cross-compiling.
+if(("${CMAKE_HOST_SYSTEM}" STREQUAL "${CMAKE_SYSTEM}" AND (UNIX OR WIN32)) OR ANDROID
+   OR COMPILER_RT_EMULATOR)
+  option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" ON)
+else()
+  option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" OFF)
+endif()
+
+option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF)
+option(COMPILER_RT_EXTERNALIZE_DEBUGINFO
+  "Generate dSYM files and strip executables and libraries (Darwin Only)" OFF)
+# COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
+pythonize_bool(COMPILER_RT_DEBUG)
+
+#================================
+# Setup Compiler Flags
+#================================
+include(CheckIncludeFile)
+check_include_file(unwind.h HAVE_UNWIND_H)
+
+include(config-ix)
+
+if(MSVC)
+  append_string_if(COMPILER_RT_HAS_W3_FLAG /W3 CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+else()
+  append_string_if(COMPILER_RT_HAS_WALL_FLAG -Wall CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+endif()
+if(COMPILER_RT_ENABLE_WERROR)
+  append_string_if(COMPILER_RT_HAS_WERROR_FLAG -Werror CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+  append_string_if(COMPILER_RT_HAS_WX_FLAG /WX CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+endif()
+
+append_string_if(COMPILER_RT_HAS_STD_CXX11_FLAG -std=c++11 CMAKE_CXX_FLAGS)
+
+# Emulate C99 and C++11's __func__ for MSVC prior to 2013 CTP.
+if(NOT COMPILER_RT_HAS_FUNC_SYMBOL)
+  add_definitions(-D__func__=__FUNCTION__)
+endif()
+
+# Provide some common commmandline flags for Sanitizer runtimes.
+append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_BUILTIN_FLAG -fno-builtin SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG -fomit-frame-pointer SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FUNWIND_TABLES_FLAG -funwind-tables SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG -fno-stack-protector SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG -fno-sanitize=safe-stack SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG -fvisibility-inlines-hidden SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG -fno-function-sections SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto SANITIZER_COMMON_CFLAGS)
+
+if(MSVC)
+  # Replace the /M[DT][d] flags with /MT, and strip any definitions of _DEBUG,
+  # which cause definition mismatches at link time.
+  # FIXME: In fact, sanitizers should support both /MT and /MD, see PR20214.
+  if(COMPILER_RT_HAS_MT_FLAG)
+    foreach(flag_var
+      CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+      CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      string(REGEX REPLACE "/M[DT]d" "/MT" ${flag_var} "${${flag_var}}")
+      string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+      string(REGEX REPLACE "/D_DEBUG" "" ${flag_var} "${${flag_var}}")
+    endforeach()
+  endif()
+  append_list_if(COMPILER_RT_HAS_Oy_FLAG /Oy- SANITIZER_COMMON_CFLAGS)
+  append_list_if(COMPILER_RT_HAS_GS_FLAG /GS- SANITIZER_COMMON_CFLAGS)
+endif()
+
+append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 SANITIZER_COMMON_CFLAGS)
+
+# Build with optimization, unless we're in debug mode. If we're using MSVC,
+# always respect the optimization flags set by CMAKE_BUILD_TYPE instead.
+if(NOT COMPILER_RT_DEBUG AND NOT MSVC)
+  list(APPEND SANITIZER_COMMON_CFLAGS -O3)
+endif()
+
+# Determine if we should restrict stack frame sizes.
+# Stack frames on PowerPC and Mips and in debug biuld can be much larger than
+# anticipated.
+# FIXME: Fix all sanitizers and add -Wframe-larger-than to
+# SANITIZER_COMMON_FLAGS
+if(COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG AND NOT COMPILER_RT_DEBUG
+   AND NOT ${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "powerpc|mips")
+  set(SANITIZER_LIMIT_FRAME_SIZE TRUE)
+else()
+  set(SANITIZER_LIMIT_FRAME_SIZE FALSE)
+endif()
+
+# Build sanitizer runtimes with debug info.
+if(COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG AND NOT COMPILER_RT_DEBUG)
+  list(APPEND SANITIZER_COMMON_CFLAGS -gline-tables-only)
+elseif(COMPILER_RT_HAS_G_FLAG)
+  list(APPEND SANITIZER_COMMON_CFLAGS -g)
+elseif(COMPILER_RT_HAS_Zi_FLAG)
+  list(APPEND SANITIZER_COMMON_CFLAGS /Zi)
+endif()
+
+# Turn off several warnings.
+append_list_if(COMPILER_RT_HAS_WGNU_FLAG -Wno-gnu SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG -Wno-variadic-macros SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG -Wno-c99-extensions SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG -Wno-non-virtual-dtor SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WD4146_FLAG /wd4146 SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WD4291_FLAG /wd4291 SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WD4391_FLAG /wd4391 SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WD4722_FLAG /wd4722 SANITIZER_COMMON_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WD4800_FLAG /wd4800 SANITIZER_COMMON_CFLAGS)
+
+if(APPLE AND SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.9")
+  # Mac OS X prior to 10.9 had problems with exporting symbols from
+  # libc++/libc++abi.
+  set(SANITIZER_CAN_USE_CXXABI FALSE)
+else()
+  set(SANITIZER_CAN_USE_CXXABI TRUE)
+endif()
+pythonize_bool(SANITIZER_CAN_USE_CXXABI)
+
+add_subdirectory(include)
+
+set(COMPILER_RT_LIBCXX_PATH ${LLVM_MAIN_SRC_DIR}/projects/libcxx)
+if(EXISTS ${COMPILER_RT_LIBCXX_PATH}/)
+  set(COMPILER_RT_HAS_LIBCXX_SOURCES TRUE)
+else()
+  set(COMPILER_RT_HAS_LIBCXX_SOURCES FALSE)
+endif()
+
+set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/tools/lld)
+if(EXISTS ${COMPILER_RT_LLD_PATH}/)
+  set(COMPILER_RT_HAS_LLD_SOURCES TRUE)
+else()
+  set(COMPILER_RT_HAS_LLD_SOURCES FALSE)
+endif()
+pythonize_bool(COMPILER_RT_HAS_LLD_SOURCES)
+
+add_subdirectory(lib)
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(unittests)
+  add_subdirectory(test)
+endif()
diff --git a/compiler-rt/CODE_OWNERS.TXT b/compiler-rt/CODE_OWNERS.TXT
new file mode 100644
index 0000000..2159ad7
--- /dev/null
+++ b/compiler-rt/CODE_OWNERS.TXT
@@ -0,0 +1,57 @@
+This file is a list of the people responsible for ensuring that patches for a
+particular part of compiler-rt are reviewed, either by themself or by
+someone else. They are also the gatekeepers for their part of compiler-rt, with
+the final word on what goes in or not.
+
+The list is sorted by surname and formatted to allow easy grepping and
+beautification by scripts. The fields are: name (N), email (E), web-address
+(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
+(S).
+
+N: Peter Collingbourne
+E: peter@pcc.me.uk
+D: DataFlowSanitizer
+
+N: Daniel Dunbar
+E: daniel@zuster.org
+D: Makefile build
+
+N: Timur Iskhodzhanov
+E: timurrrr@google.com
+D: AddressSanitizer for Windows
+
+N: Howard Hinnant
+E: howard.hinnant@gmail.com
+D: builtins library
+
+N: Sergey Matveev
+E: earthdok@google.com
+D: LeakSanitizer
+
+N: Alexander Potapenko
+E: glider@google.com
+D: MacOS/iOS port of sanitizers
+
+N: Alexey Samsonov
+E: samsonov@google.com
+D: CMake build, test suite
+
+N: Kostya Serebryany
+E: kcc@google.com
+D: AddressSanitizer, sanitizer_common, porting sanitizers to another platforms
+
+N: Richard Smith
+E: richard-llvm@metafoo.co.uk
+D: UndefinedBehaviorSanitizer
+
+N: Evgeniy Stepanov
+E: eugenis@google.com
+D: MemorySanitizer, Android port of sanitizers
+
+N: Dmitry Vyukov
+E: dvyukov@google.com
+D: ThreadSanitizer
+
+N: Bill Wendling
+E: isanbard@gmail.com
+D: Profile runtime library
diff --git a/compiler-rt/CREDITS.TXT b/compiler-rt/CREDITS.TXT
new file mode 100644
index 0000000..6964eba
--- /dev/null
+++ b/compiler-rt/CREDITS.TXT
@@ -0,0 +1,36 @@
+This file is a partial list of people who have contributed to the LLVM/CompilerRT
+project.  If you have contributed a patch or made some other contribution to
+LLVM/CompilerRT, please submit a patch to this file to add yourself, and it will be
+done!
+
+The list is sorted by surname and formatted to allow easy grepping and
+beautification by scripts.  The fields are: name (N), email (E), web-address
+(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
+(S).
+
+N: Craig van Vliet
+E: cvanvliet@auroraux.org
+W: http://www.auroraux.org
+D: Code style and Readability fixes.
+
+N: Edward O'Callaghan
+E: eocallaghan@auroraux.org
+W: http://www.auroraux.org
+D: CMake'ify Compiler-RT build system
+D: Maintain Solaris & AuroraUX ports of Compiler-RT
+
+N: Howard Hinnant
+E: hhinnant@apple.com
+D: Architect and primary author of compiler-rt
+
+N: Guan-Hong Liu
+E: koviankevin@hotmail.com
+D: IEEE Quad-precision functions
+
+N: Joerg Sonnenberger
+E: joerg@NetBSD.org
+D: Maintains NetBSD port.
+
+N: Matt Thomas
+E: matt@NetBSD.org
+D: ARM improvements.
diff --git a/compiler-rt/LICENSE.TXT b/compiler-rt/LICENSE.TXT
new file mode 100644
index 0000000..aa4115e
--- /dev/null
+++ b/compiler-rt/LICENSE.TXT
@@ -0,0 +1,91 @@
+==============================================================================
+compiler_rt License
+==============================================================================
+
+The compiler_rt library is dual licensed under both the University of Illinois
+"BSD-Like" license and the MIT license.  As a user of this code you may choose
+to use it under either license.  As a contributor, you agree to allow your code
+to be used under both.
+
+Full text of the relevant licenses is included below.
+
+==============================================================================
+
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT
+
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+Copyrights and Licenses for Third Party Software Distributed with LLVM:
+==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
+
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
+
diff --git a/compiler-rt/MODULE_LICENSE_MIT b/compiler-rt/MODULE_LICENSE_MIT
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/MODULE_LICENSE_MIT
diff --git a/compiler-rt/Makefile b/compiler-rt/Makefile
new file mode 100644
index 0000000..ac3daac
--- /dev/null
+++ b/compiler-rt/Makefile
@@ -0,0 +1,275 @@
+SubDirs := lib
+
+# Set default rule before anything else.
+all: help
+
+include make/config.mk
+include make/util.mk
+# If SRCROOT is defined, assume we are doing an Apple style build. We should be
+# able to use RC_XBS for this but that is unused during "make installsrc".
+ifdef SRCROOT
+  include make/AppleBI.mk
+endif
+
+# Make sure we don't build with a missing ProjObjRoot.
+ifeq ($(ProjObjRoot),)
+$(error Refusing to build with empty ProjObjRoot variable)
+endif
+
+##############
+
+###
+# Rules
+
+###
+# Top level targets
+
+# FIXME: Document the available subtargets.
+help:
+	@echo "usage: make [{VARIABLE=VALUE}*] target"
+	@echo
+	@echo "User variables:"
+	@echo "  VERBOSE=1: Use to show all commands [default=0]"
+	@echo
+	@echo "Available targets:"
+	@echo "  <platform name>: build the libraries for 'platform'"
+	@echo "  clean:           clean all configurations"
+	@echo "  test:            run unit tests"
+	@echo
+	@echo "  info-platforms:  list available platforms"
+	@echo "  help-devel:      print additional help for developers"
+	@echo
+
+help-devel: help
+	@echo "Development targets:"
+	@echo "  <platform name>-<config name>:"
+	@echo "    build the libraries for a single platform config"
+	@echo "  <platform name>-<config name>-<arch name>:"
+	@echo "    build the libraries for a single config and arch"
+	@echo "  info-functions: list available compiler-rt functions"
+	@echo "  help-hidden: print help for Makefile debugging"
+	@echo
+
+help-hidden: help-devel
+	@echo "Debugging variables:"
+	@echo "  DEBUGMAKE=1: enable some Makefile logging [default=]"
+	@echo "           =2: enable more Makefile logging"
+	@echo
+	@echo "Debugging targets:"
+	@echo "  make-print-FOO: print information on the variable 'FOO'"
+	@echo
+
+info-functions:
+	@echo "compiler-rt Available Functions"
+	@echo
+	@echo "All Functions: $(AvailableFunctions)"
+	@$(foreach fn,$(AvailableFunctions),\
+	  printf "  %-20s - available in (%s)\n" $(fn)\
+	    "$(foreach key,$(AvailableIn.$(fn)),$($(key).Dir))";)
+
+info-platforms:
+	@echo "compiler-rt Available Platforms"
+	@echo
+	@echo "Platforms:"
+	@$(foreach key,$(PlatformKeys),\
+	  printf "  %s - from '%s'\n" $($(key).Name) $($(key).Path);\
+	  printf "    %s\n" "$($(key).Description)";\
+	  printf "    Configurations: %s\n\n" "$($(key).Configs)";)
+
+# Provide default clean target which is extended by other templates.
+.PHONY: clean
+clean::
+
+# Test
+.PHONY: test
+test:
+	cd test/Unit && ./test
+
+###
+# Directory handling magic.
+
+# Create directories as needed, and timestamp their creation.
+%/.dir:
+	$(Summary) "  MKDIR:     $*"
+	$(Verb) $(MKDIR) $* > /dev/null
+	$(Verb) echo 'Created.' > $@
+
+# Remove directories
+%/.remove:
+	$(Verb) $(RM) -r $*
+
+###
+# Include child makefile fragments
+
+Dir := .
+include make/subdir.mk
+include make/lib_info.mk
+include make/lib_util.mk
+include make/lib_platforms.mk
+
+###
+# Define Platform Rules
+
+define PerPlatform_template
+$(call Set,Tmp.Key,$(1))
+$(call Set,Tmp.Name,$($(Tmp.Key).Name))
+$(call Set,Tmp.Configs,$($(Tmp.Key).Configs))
+$(call Set,Tmp.ObjPath,$(ProjObjRoot)/$(Tmp.Name))
+
+# Top-Level Platform Target
+$(Tmp.Name):: $(Tmp.Configs:%=$(Tmp.Name)-%)
+.PHONY: $(Tmp.Name)
+
+clean::
+	$(Verb) rm -rf $(Tmp.ObjPath)
+
+# Per-Config Libraries
+$(foreach config,$(Tmp.Configs),\
+  $(call PerPlatformConfig_template,$(config)))
+endef
+
+define PerPlatformConfig_template
+$(call Set,Tmp.Config,$(1))
+$(call Set,Tmp.ObjPath,$(ProjObjRoot)/$(Tmp.Name)/$(Tmp.Config))
+$(call Set,Tmp.SHARED_LIBRARY,$(strip \
+  $(call GetCNAVar,SHARED_LIBRARY,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.SHARED_LIBRARY_SUFFIX,$(strip \
+  $(call GetCNAVar,SHARED_LIBRARY_SUFFIX,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+
+# Compute the library suffix.
+$(if $(call streq,1,$(Tmp.SHARED_LIBRARY)),
+  $(call Set,Tmp.LibrarySuffix,$(Tmp.SHARED_LIBRARY_SUFFIX)),
+  $(call Set,Tmp.LibrarySuffix,a))
+
+# Compute the archs to build, depending on whether this is a universal build or
+# not.
+$(call Set,Tmp.ArchsToBuild,\
+  $(if $(call IsDefined,$(Tmp.Key).UniversalArchs),\
+       $(strip \
+         $(or $($(Tmp.Key).UniversalArchs.$(Tmp.Config)),\
+              $($(Tmp.Key).UniversalArchs))),\
+       $(call VarOrDefault,$(Tmp.Key).Arch.$(Tmp.Config),$($(Tmp.Key).Arch))))
+
+# Copy or lipo to create the per-config library.
+$(call Set,Tmp.Inputs,$(Tmp.ArchsToBuild:%=$(Tmp.ObjPath)/%/libcompiler_rt.$(Tmp.LibrarySuffix)))
+$(Tmp.ObjPath)/libcompiler_rt.$(Tmp.LibrarySuffix): $(Tmp.Inputs) $(Tmp.ObjPath)/.dir
+	$(Summary) "  FINAL-ARCHIVE: $(Tmp.Name)/$(Tmp.Config): $$@"
+	-$(Verb) $(RM) $$@
+	$(if $(call streq,1,$(words $(Tmp.ArchsToBuild))), \
+	  $(Verb) $(CP) $(Tmp.Inputs) $$@, \
+	  $(Verb) $(LIPO) -create -output $$@ $(Tmp.Inputs))
+.PRECIOUS: $(Tmp.ObjPath)/.dir
+
+# Per-Config Targets
+$(Tmp.Name)-$(Tmp.Config):: $(Tmp.ObjPath)/libcompiler_rt.$(Tmp.LibrarySuffix)
+.PHONY: $(Tmp.Name)-$(Tmp.Config)
+
+# Per-Config-Arch Libraries
+$(foreach arch,$(Tmp.ArchsToBuild),\
+  $(call PerPlatformConfigArch_template,$(arch)))
+endef
+
+define PerPlatformConfigArch_template
+$(call Set,Tmp.Arch,$(1))
+$(call Set,Tmp.ObjPath,$(ProjObjRoot)/$(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch))
+$(call Set,Tmp.Functions,$(strip \
+  $(AlwaysRequiredModules) \
+  $(call GetCNAVar,FUNCTIONS,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.Optimized,$(strip \
+  $(call GetCNAVar,OPTIMIZED,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.AR,$(strip \
+  $(call GetCNAVar,AR,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.ARFLAGS,$(strip \
+  $(call GetCNAVar,ARFLAGS,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.CC,$(strip \
+  $(call GetCNAVar,CC,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.LDFLAGS,$(strip \
+  $(call GetCNAVar,LDFLAGS,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.RANLIB,$(strip \
+  $(call GetCNAVar,RANLIB,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.RANLIBFLAGS,$(strip \
+  $(call GetCNAVar,RANLIBFLAGS,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.SHARED_LIBRARY,$(strip \
+  $(call GetCNAVar,SHARED_LIBRARY,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+
+# Compute the library suffix.
+$(if $(call streq,1,$(Tmp.SHARED_LIBRARY)),
+  $(call Set,Tmp.LibrarySuffix,$(Tmp.SHARED_LIBRARY_SUFFIX)),
+  $(call Set,Tmp.LibrarySuffix,a))
+
+# Compute the object inputs for this library.
+$(call Set,Tmp.Inputs,\
+  $(foreach fn,$(sort $(Tmp.Functions)),\
+    $(call Set,Tmp.FnDir,\
+      $(call SelectFunctionDir,$(Tmp.Config),$(Tmp.Arch),$(fn),$(Tmp.Optimized)))\
+    $(Tmp.ObjPath)/$(Tmp.FnDir)/$(fn).o))
+$(Tmp.ObjPath)/libcompiler_rt.a: $(Tmp.Inputs) $(Tmp.ObjPath)/.dir
+	$(Summary) "  ARCHIVE:   $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$@"
+	-$(Verb) $(RM) $$@
+	$(Verb) $(Tmp.AR) $(Tmp.ARFLAGS) $$@ $(Tmp.Inputs)
+	$(Verb) $(Tmp.RANLIB) $(Tmp.RANLIBFLAGS) $$@
+$(Tmp.ObjPath)/libcompiler_rt.dylib: $(Tmp.Inputs) $(Tmp.ObjPath)/.dir
+	$(Summary) "  DYLIB:   $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$@"
+	$(Verb) $(Tmp.CC) -arch $(Tmp.Arch) -dynamiclib -o $$@ \
+	  $(Tmp.Inputs) $(Tmp.LDFLAGS)
+$(Tmp.ObjPath)/libcompiler_rt.so: $(Tmp.Inputs) $(Tmp.ObjPath)/.dir
+	$(Summary) "  SO:   $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$@"
+	$(Verb) $(Tmp.CC) -shared -o $$@ \
+	  $(Tmp.Inputs) $(Tmp.LDFLAGS)
+.PRECIOUS: $(Tmp.ObjPath)/.dir
+
+# Per-Config-Arch Targets
+$(Tmp.Name)-$(Tmp.Config)-$(Tmp.Arch):: $(Tmp.ObjPath)/libcompiler_rt.$(Tmp.LibrarySuffix)
+.PHONY: $(Tmp.Name)-$(Tmp.Config)-$(Tmp.Arch)
+
+# Per-Config-Arch-SubDir Objects
+$(foreach key,$(SubDirKeys),\
+  $(call PerPlatformConfigArchSubDir_template,$(key)))
+endef
+
+define PerPlatformConfigArchSubDir_template
+$(call Set,Tmp.SubDirKey,$(1))
+$(call Set,Tmp.SubDir,$($(Tmp.SubDirKey).Dir))
+$(call Set,Tmp.SrcPath,$(ProjSrcRoot)/$(Tmp.SubDir))
+$(call Set,Tmp.ObjPath,$(ProjObjRoot)/$(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch)/$(Tmp.SubDirKey))
+$(call Set,Tmp.Dependencies,$($(Tmp.SubDirKey).Dependencies))
+$(call Set,Tmp.CC,$(strip \
+  $(call GetCNAVar,CC,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.KERNEL_USE,$(strip \
+  $(call GetCNAVar,KERNEL_USE,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.VISIBILITY_HIDDEN,$(strip \
+  $(call GetCNAVar,VISIBILITY_HIDDEN,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+$(call Set,Tmp.CFLAGS,$(strip \
+  $(if $(call IsDefined,$(Tmp.Key).UniversalArchs),-arch $(Tmp.Arch),)\
+  $(if $(call streq,$(Tmp.VISIBILITY_HIDDEN),1),\
+       -fvisibility=hidden -DVISIBILITY_HIDDEN,)\
+  $(if $(call streq,$(Tmp.KERNEL_USE),1),\
+       -mkernel -DKERNEL_USE,)\
+  $(call GetCNAVar,CFLAGS,$(Tmp.Key),$(Tmp.Config),$(Tmp.Arch))))
+
+$(Tmp.ObjPath)/%.o: $(Tmp.SrcPath)/%.s $(Tmp.Dependencies) $(Tmp.ObjPath)/.dir
+	$(Summary) "  ASSEMBLE:  $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$<"
+	$(Verb) $(Tmp.CC) $(COMMON_ASMFLAGS) $(Tmp.CFLAGS)  -c -o $$@ $$<
+$(Tmp.ObjPath)/%.o: $(Tmp.SrcPath)/%.S $(Tmp.Dependencies) $(Tmp.ObjPath)/.dir
+	$(Summary) "  ASSEMBLE:  $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$<"
+	$(Verb) $(Tmp.CC) $(COMMON_ASMFLAGS) $(Tmp.CFLAGS) -c -o $$@ $$<
+$(Tmp.ObjPath)/%.o: $(Tmp.SrcPath)/%.c $(Tmp.Dependencies) $(Tmp.ObjPath)/.dir
+	$(Summary) "  COMPILE:   $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$<"
+	$(Verb) $(Tmp.CC) $(COMMON_CFLAGS) $(Tmp.CFLAGS) -c -o $$@ $$<
+$(Tmp.ObjPath)/%.o: $(Tmp.SrcPath)/%.cc $(Tmp.Dependencies) $(Tmp.ObjPath)/.dir
+	$(Summary) "  COMPILE:   $(Tmp.Name)/$(Tmp.Config)/$(Tmp.Arch): $$<"
+	$(Verb) $(Tmp.CC) $(COMMON_CXXFLAGS) $(Tmp.CFLAGS) -c -o $$@ $$<
+.PRECIOUS: $(Tmp.ObjPath)/.dir
+
+endef
+
+# Run templates.
+$(foreach key,$(PlatformKeys),\
+  $(eval $(call PerPlatform_template,$(key))))
+
+###
+
+ifneq ($(DEBUGMAKE),)
+  $(info MAKE: Done processing Makefile)
+  $(info  )
+endif
diff --git a/compiler-rt/NOTICE b/compiler-rt/NOTICE
new file mode 100644
index 0000000..aee8347
--- /dev/null
+++ b/compiler-rt/NOTICE
@@ -0,0 +1,91 @@
+==============================================================================
+compiler_rt License
+==============================================================================
+
+The compiler_rt library is dual licensed under both the University of Illinois
+"BSD-Like" license and the MIT license.  As a user of this code you may choose
+to use it under either license.  As a contributor, you agree to allow your code
+to be used under both.
+
+Full text of the relevant licenses is included below.
+
+==============================================================================
+
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
+
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+Copyrights and Licenses for Third Party Software Distributed with LLVM:
+==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
+
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
+
diff --git a/compiler-rt/README.android b/compiler-rt/README.android
new file mode 100644
index 0000000..587a6c6
--- /dev/null
+++ b/compiler-rt/README.android
@@ -0,0 +1,40 @@
+/*
+ * README.android describes in high-level the compiler-rt changes that we
+ * cannot push upstream to the llvm.org repository:
+ *  - Changes due to Android's build system.
+ *  - Changes due to Android's toolchain.
+ *  - Changes due to the limitations in Android-based consumer electronics.
+ *
+ * Some of them are to-dos. If and when they are done, there will no longer be
+ * merge conflicts with upstream on those parts.
+ *
+ * The file contains useful hints when we try to resolve future 3-way merge
+ * conflicts.
+ */
+
+* For JellyBean: Synced to upstream r155350
+* For JellyBean MR1: Synced to upstream r162279
+* For Jellybean MR2: Synced to upstream r177337
+* For Key Lime Pie: Synced to upstream r187889
+* For FUTURE: Synced to LLVM 3.4 r197381
+
+* Cherry-pick on 2014/2/11: https://llvm.org/svn/llvm-project/compiler-rt/trunk@201068 and https://llvm.org/svn/llvm-project/compiler-rt/trunk@201070
+* Recent downstreaming on 2013/2/11: Synced to r197381 (Contact srhines for merge questions.)
+* Recent downstreaming on 2013/8/8: Synced to r187889 (Contact srhines for merge questions.)
+* Recent downstreaming on 2013/6/13: Synced to r183849 (Contact srhines for merge questions.)
+* Recent downstreaming on 2013/5/3: Synced to r180792 (Contact srhines for merge questions.)
+* Recent downstreaming on 2013/3/18: Synced to r177337 (Contact srhines for merge questions.)
+* Recent downstreaming on 2013/3/5: Synced to r176091 (Contact srhines for merge questions.)
+* Recent downstreaming on 2013/1/8: Synced to r171802 (Contact srhines for merge questions.)
+* Recent downstreaming on 2012/08/23: Synced to r162279 (Contact srhines for merge questions.)
+* Recent downstreaming on 2012/08/15: Synced to r159129 (Contact sliao for merge questions.)
+* Cherry-pick on 2012/07/27: https://llvm.org/svn/llvm-project/compiler-rt/trunk@160853 for ASan (Contact srhines for merge questions.)
+* Cherry-pick on 2012/05/23: https://llvm.org/svn/llvm-project/compiler-rt/trunk@157318 for ASan (Contact srhines for merge questions.)
+* Recent downstreaming on 2012/04/25: Synced to r155350 (Contact sliao for merge questions.)
+* Recent downstreaming on 2012/03/08: Synced to r152058 (Contact srhines for merge questions.)
+
+TODO: This is still not building by default (no Android.mk files are present
+yet). Look at frameworks/compile/libbcc/runtime for potential starting points.
+
+TODO: Switch libbcc to use this version of compiler-rt instead of its own
+tweaked version.
diff --git a/compiler-rt/README.txt b/compiler-rt/README.txt
new file mode 100644
index 0000000..fc88432
--- /dev/null
+++ b/compiler-rt/README.txt
@@ -0,0 +1,11 @@
+Compiler-RT
+================================
+
+This directory and its subdirectories contain source code for the compiler
+support routines.
+
+Compiler-RT is open source software. You may freely distribute it under the
+terms of the license agreement found in LICENSE.txt.
+
+================================
+
diff --git a/compiler-rt/README.version b/compiler-rt/README.version
new file mode 100644
index 0000000..c9d92df
--- /dev/null
+++ b/compiler-rt/README.version
@@ -0,0 +1,4 @@
+URL: http://llvm.org/git/compiler-rt.git
+Version: Rolling from upstream + cherry-picks
+BugComponent: 117395
+Owners: srhines, android-llvm
diff --git a/compiler-rt/cmake/Modules/AddCompilerRT.cmake b/compiler-rt/cmake/Modules/AddCompilerRT.cmake
new file mode 100644
index 0000000..6f401b1
--- /dev/null
+++ b/compiler-rt/cmake/Modules/AddCompilerRT.cmake
@@ -0,0 +1,337 @@
+include(AddLLVM)
+include(ExternalProject)
+include(CompilerRTUtils)
+
+# Tries to add an "object library" target for a given list of OSs and/or
+# architectures with name "<name>.<arch>" for non-Darwin platforms if
+# architecture can be targeted, and "<name>.<os>" for Darwin platforms.
+# add_compiler_rt_object_libraries(<name>
+#                                  OS <os names>
+#                                  ARCHS <architectures>
+#                                  SOURCES <source files>
+#                                  CFLAGS <compile flags>
+#                                  DEFS <compile definitions>)
+function(add_compiler_rt_object_libraries name)
+  cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS" ${ARGN})
+  set(libnames)
+  if(APPLE)
+    foreach(os ${LIB_OS})
+      set(libname "${name}.${os}")
+      set(libnames ${libnames} ${libname})
+      set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS})
+      list_union(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
+    endforeach()
+  else()
+    foreach(arch ${LIB_ARCHS})
+      set(libname "${name}.${arch}")
+      set(libnames ${libnames} ${libname})
+      set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS})
+      if(NOT CAN_TARGET_${arch})
+        message(FATAL_ERROR "Architecture ${arch} can't be targeted")
+        return()
+      endif()
+    endforeach()
+  endif()
+  
+  foreach(libname ${libnames})
+    add_library(${libname} OBJECT ${LIB_SOURCES})
+    set_target_compile_flags(${libname}
+      ${CMAKE_CXX_FLAGS} ${extra_cflags_${libname}} ${LIB_CFLAGS})
+    set_property(TARGET ${libname} APPEND PROPERTY
+      COMPILE_DEFINITIONS ${LIB_DEFS})
+    if(APPLE)
+      set_target_properties(${libname} PROPERTIES
+        OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
+    endif()
+  endforeach()
+endfunction()
+
+# Takes a list of object library targets, and a suffix and appends the proper
+# TARGET_OBJECTS string to the output variable.
+# format_object_libs(<output> <suffix> ...)
+macro(format_object_libs output suffix)
+  foreach(lib ${ARGN})
+    list(APPEND ${output} $<TARGET_OBJECTS:${lib}.${suffix}>)
+  endforeach()
+endmacro()
+
+# Adds static or shared runtime for a list of architectures and operating
+# systems and puts it in the proper directory in the build and install trees.
+# add_compiler_rt_runtime(<name>
+#                         {STATIC|SHARED}
+#                         ARCHS <architectures>
+#                         OS <os list>
+#                         SOURCES <source files>
+#                         CFLAGS <compile flags>
+#                         LINKFLAGS <linker flags>
+#                         DEFS <compile definitions>
+#                         LINK_LIBS <linked libraries> (only for shared library)
+#                         OBJECT_LIBS <object libraries to use as sources>
+#                         PARENT_TARGET <convenience parent target>)
+function(add_compiler_rt_runtime name type)
+  if(NOT type MATCHES "^(STATIC|SHARED)$")
+    message(FATAL_ERROR "type argument must be STATIC or SHARED")
+    return()
+  endif()
+  cmake_parse_arguments(LIB
+    ""
+    "PARENT_TARGET"
+    "OS;ARCHS;SOURCES;CFLAGS;LINKFLAGS;DEFS;LINK_LIBS;OBJECT_LIBS"
+    ${ARGN})
+  set(libnames)
+  if(APPLE)
+    foreach(os ${LIB_OS})
+      if(type STREQUAL "STATIC")
+        set(libname "${name}_${os}")
+      else()
+        set(libname "${name}_${os}_dynamic")
+        set(extra_linkflags_${libname} ${DARWIN_${os}_LINKFLAGS} ${LIB_LINKFLAGS})
+      endif()
+      list_union(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
+      if(LIB_ARCHS_${libname})
+        list(APPEND libnames ${libname})
+        set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS} ${LIB_CFLAGS})
+        set(output_name_${libname} ${libname}${COMPILER_RT_OS_SUFFIX})
+        set(sources_${libname} ${LIB_SOURCES})
+        format_object_libs(sources_${libname} ${os} ${LIB_OBJECT_LIBS})
+      endif()
+    endforeach()
+  else()
+    foreach(arch ${LIB_ARCHS})
+      if(NOT CAN_TARGET_${arch})
+        message(FATAL_ERROR "Architecture ${arch} can't be targeted")
+        return()
+      endif()
+      if(type STREQUAL "STATIC")
+        set(libname "${name}-${arch}")
+        set(output_name_${libname} ${libname}${COMPILER_RT_OS_SUFFIX})
+      else()
+        set(libname "${name}-dynamic-${arch}")
+        set(extra_linkflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS} ${LIB_LINKFLAGS})
+        if(WIN32)
+          set(output_name_${libname} ${name}_dynamic-${arch}${COMPILER_RT_OS_SUFFIX})
+        else()
+          set(output_name_${libname} ${name}-${arch}${COMPILER_RT_OS_SUFFIX})
+        endif()
+      endif()
+      set(sources_${libname} ${LIB_SOURCES})
+      format_object_libs(sources_${libname} ${arch} ${LIB_OBJECT_LIBS})
+      set(libnames ${libnames} ${libname})
+      set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
+    endforeach()
+  endif()
+
+  if(NOT libnames)
+    return()
+  endif()
+
+  if(LIB_PARENT_TARGET)
+    set(COMPONENT_OPTION COMPONENT ${LIB_PARENT_TARGET})
+  endif()
+
+  foreach(libname ${libnames})
+    add_library(${libname} ${type} ${sources_${libname}})
+    set_target_compile_flags(${libname} ${extra_cflags_${libname}})
+    set_target_link_flags(${libname} ${extra_linkflags_${libname}})
+    set_property(TARGET ${libname} APPEND PROPERTY 
+                COMPILE_DEFINITIONS ${LIB_DEFS})
+    set_target_properties(${libname} PROPERTIES
+        ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
+        LIBRARY_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
+        RUNTIME_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
+    set_target_properties(${libname} PROPERTIES
+        OUTPUT_NAME ${output_name_${libname}})
+    if(LIB_LINK_LIBS AND ${type} STREQUAL "SHARED")
+      target_link_libraries(${libname} ${LIB_LINK_LIBS})
+    endif()
+    install(TARGETS ${libname}
+      ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMPONENT_OPTION}
+      LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMPONENT_OPTION}
+      RUNTIME DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMPONENT_OPTION})
+    if(APPLE)
+      set_target_properties(${libname} PROPERTIES
+      OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
+    endif()
+
+    if(type STREQUAL "SHARED")
+      rt_externalize_debuginfo(${libname})
+    endif()
+  endforeach()
+  if(LIB_PARENT_TARGET)
+    add_dependencies(${LIB_PARENT_TARGET} ${libnames})
+  endif()
+endfunction()
+
+set(COMPILER_RT_TEST_CFLAGS)
+
+# Unittests support.
+set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest)
+set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc)
+set(COMPILER_RT_GTEST_CFLAGS
+  -DGTEST_NO_LLVM_RAW_OSTREAM=1
+  -DGTEST_HAS_RTTI=0
+  -I${COMPILER_RT_GTEST_PATH}/include
+  -I${COMPILER_RT_GTEST_PATH}
+)
+
+append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 COMPILER_RT_TEST_CFLAGS)
+
+if(MSVC)
+  # clang doesn't support exceptions on Windows yet.
+  list(APPEND COMPILER_RT_TEST_CFLAGS -D_HAS_EXCEPTIONS=0)
+
+  # We should teach clang to understand "#pragma intrinsic", see PR19898.
+  list(APPEND COMPILER_RT_TEST_CFLAGS -Wno-undefined-inline)
+
+  # Clang doesn't support SEH on Windows yet.
+  list(APPEND COMPILER_RT_GTEST_CFLAGS -DGTEST_HAS_SEH=0)
+
+  # gtest use a lot of stuff marked as deprecated on Windows.
+  list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations)
+
+  # Visual Studio 2012 only supports up to 8 template parameters in
+  # std::tr1::tuple by default, but gtest requires 10
+  if(MSVC_VERSION EQUAL 1700)
+    list(APPEND COMPILER_RT_GTEST_CFLAGS -D_VARIADIC_MAX=10)
+  endif()
+endif()
+
+# Link objects into a single executable with COMPILER_RT_TEST_COMPILER,
+# using specified link flags. Make executable a part of provided
+# test_suite.
+# add_compiler_rt_test(<test_suite> <test_name>
+#                      SUBDIR <subdirectory for binary>
+#                      OBJECTS <object files>
+#                      DEPS <deps (e.g. runtime libs)>
+#                      LINK_FLAGS <link flags>)
+macro(add_compiler_rt_test test_suite test_name)
+  cmake_parse_arguments(TEST "" "SUBDIR" "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN})
+  if(TEST_SUBDIR)
+    set(output_bin "${CMAKE_CURRENT_BINARY_DIR}/${TEST_SUBDIR}/${test_name}")
+  else()
+    set(output_bin "${CMAKE_CURRENT_BINARY_DIR}/${test_name}")
+  endif()
+  if(MSVC)
+    set(output_bin "${output_bin}.exe")
+  endif()
+  # Use host compiler in a standalone build, and just-built Clang otherwise.
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND TEST_DEPS clang)
+  endif()
+  # If we're not on MSVC, include the linker flags from CMAKE but override them
+  # with the provided link flags. This ensures that flags which are required to
+  # link programs at all are included, but the changes needed for the test
+  # trump. With MSVC we can't do that because CMake is set up to run link.exe
+  # when linking, not the compiler. Here, we hack it to use the compiler
+  # because we want to use -fsanitize flags.
+  if(NOT MSVC)
+    set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}")
+    separate_arguments(TEST_LINK_FLAGS)
+  endif()
+  add_custom_target(${test_name}
+    COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS}
+            -o "${output_bin}"
+            ${TEST_LINK_FLAGS}
+    DEPENDS ${TEST_DEPS})
+  # Make the test suite depend on the binary.
+  add_dependencies(${test_suite} ${test_name})
+endmacro()
+
+macro(add_compiler_rt_resource_file target_name file_name)
+  set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}")
+  set(dst_file "${COMPILER_RT_OUTPUT_DIR}/${file_name}")
+  add_custom_command(OUTPUT ${dst_file}
+    DEPENDS ${src_file}
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src_file} ${dst_file}
+    COMMENT "Copying ${file_name}...")
+  add_custom_target(${target_name} DEPENDS ${dst_file})
+  # Install in Clang resource directory.
+  install(FILES ${file_name} DESTINATION ${COMPILER_RT_INSTALL_PATH})
+endmacro()
+
+macro(add_compiler_rt_script name)
+  set(dst ${COMPILER_RT_EXEC_OUTPUT_DIR}/${name})
+  set(src ${CMAKE_CURRENT_SOURCE_DIR}/${name})
+  add_custom_command(OUTPUT ${dst}
+    DEPENDS ${src}
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+    COMMENT "Copying ${name}...")
+  add_custom_target(${name} DEPENDS ${dst})
+  install(FILES ${dst}
+    PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
+    DESTINATION ${COMPILER_RT_INSTALL_PATH}/bin)
+endmacro(add_compiler_rt_script src name)
+
+# Builds custom version of libc++ and installs it in <prefix>.
+# Can be used to build sanitized versions of libc++ for running unit tests.
+# add_custom_libcxx(<name> <prefix>
+#                   DEPS <list of build deps>
+#                   CFLAGS <list of compile flags>)
+macro(add_custom_libcxx name prefix)
+  if(NOT COMPILER_RT_HAS_LIBCXX_SOURCES)
+    message(FATAL_ERROR "libcxx not found!")
+  endif()
+
+  cmake_parse_arguments(LIBCXX "" "" "DEPS;CFLAGS" ${ARGN})
+  foreach(flag ${LIBCXX_CFLAGS})
+    set(flagstr "${flagstr} ${flag}")
+  endforeach()
+  set(LIBCXX_CFLAGS ${flagstr})
+
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND LIBCXX_DEPS clang)
+  endif()
+
+  ExternalProject_Add(${name}
+    PREFIX ${prefix}
+    SOURCE_DIR ${COMPILER_RT_LIBCXX_PATH}
+    CMAKE_ARGS -DCMAKE_MAKE_PROGRAM:STRING=${CMAKE_MAKE_PROGRAM}
+               -DCMAKE_C_COMPILER=${COMPILER_RT_TEST_COMPILER}
+               -DCMAKE_CXX_COMPILER=${COMPILER_RT_TEST_COMPILER}
+               -DCMAKE_C_FLAGS=${LIBCXX_CFLAGS}
+               -DCMAKE_CXX_FLAGS=${LIBCXX_CFLAGS}
+               -DCMAKE_BUILD_TYPE=Release
+               -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
+    LOG_BUILD 1
+    LOG_CONFIGURE 1
+    LOG_INSTALL 1
+    )
+  set_target_properties(${name} PROPERTIES EXCLUDE_FROM_ALL TRUE)
+
+  ExternalProject_Add_Step(${name} force-reconfigure
+    DEPENDERS configure
+    ALWAYS 1
+    )
+
+  ExternalProject_Add_Step(${name} clobber
+    COMMAND ${CMAKE_COMMAND} -E remove_directory <BINARY_DIR>
+    COMMAND ${CMAKE_COMMAND} -E make_directory <BINARY_DIR>
+    COMMENT "Clobberring ${name} build directory..."
+    DEPENDERS configure
+    DEPENDS ${LIBCXX_DEPS}
+    )
+endmacro()
+
+function(rt_externalize_debuginfo name)
+  if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO)
+    return()
+  endif()
+
+  if(APPLE)
+    if(CMAKE_CXX_FLAGS MATCHES "-flto"
+      OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
+
+      set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o)
+      set_property(TARGET ${name} APPEND_STRING PROPERTY
+        LINK_FLAGS " -Wl,-object_path_lto -Wl,${lto_object}")
+    endif()
+    add_custom_command(TARGET ${name} POST_BUILD
+      COMMAND xcrun dsymutil $<TARGET_FILE:${name}>
+      COMMAND xcrun strip -Sl $<TARGET_FILE:${name}>)
+  else()
+    message(FATAL_ERROR "COMPILER_RT_EXTERNALIZE_DEBUGINFO isn't implemented for non-darwin platforms!")
+  endif()
+endfunction()
diff --git a/compiler-rt/cmake/Modules/CompilerRTCompile.cmake b/compiler-rt/cmake/Modules/CompilerRTCompile.cmake
new file mode 100644
index 0000000..48f40bf
--- /dev/null
+++ b/compiler-rt/cmake/Modules/CompilerRTCompile.cmake
@@ -0,0 +1,107 @@
+# On Windows, CMAKE_*_FLAGS are built for MSVC but we use the GCC clang.exe,
+# which uses completely different flags. Translate some common flag types, and
+# drop the rest.
+function(translate_msvc_cflags out_flags msvc_flags)
+  # Insert an empty string in the list to simplify processing.
+  set(msvc_flags ";${msvc_flags}")
+
+  # Canonicalize /flag to -flag.
+  string(REPLACE ";/" ";-" msvc_flags "${msvc_flags}")
+
+  # Make space separated -D and -U flags into joined flags.
+  string(REGEX REPLACE ";-\([DU]\);" ";-\\1" msvc_flags "${msvc_flags}")
+
+  set(clang_flags "")
+  foreach(flag ${msvc_flags})
+    if ("${flag}" MATCHES "^-[DU]")
+      # Pass through basic command line macro definitions (-DNDEBUG).
+      list(APPEND clang_flags "${flag}")
+    elseif ("${flag}" MATCHES "^-O[2x]")
+      # Canonicalize normal optimization flags to -O2.
+      list(APPEND clang_flags "-O2")
+    endif()
+  endforeach()
+  set(${out_flags} "${clang_flags}" PARENT_SCOPE)
+endfunction()
+
+# Compile a source into an object file with COMPILER_RT_TEST_COMPILER using
+# a provided compile flags and dependenices.
+# clang_compile(<object> <source>
+#               CFLAGS <list of compile flags>
+#               DEPS <list of dependencies>)
+macro(clang_compile object_file source)
+  cmake_parse_arguments(SOURCE "" "" "CFLAGS;DEPS" ${ARGN})
+  get_filename_component(source_rpath ${source} REALPATH)
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND SOURCE_DEPS clang compiler-rt-headers)
+  endif()
+  if (TARGET CompilerRTUnitTestCheckCxx)
+    list(APPEND SOURCE_DEPS CompilerRTUnitTestCheckCxx)
+  endif()
+  string(REGEX MATCH "[.](cc|cpp)$" is_cxx ${source_rpath})
+  if(is_cxx)
+    string(REPLACE " " ";" global_flags "${CMAKE_CXX_FLAGS}")
+  else()
+    string(REPLACE " " ";" global_flags "${CMAKE_C_FLAGS}")
+  endif()
+
+  if (MSVC)
+    translate_msvc_cflags(global_flags "${global_flags}")
+  endif()
+
+  if (APPLE)
+    set(global_flags ${OSX_SYSROOT_FLAG} ${global_flags})
+  endif()
+
+  # Ignore unknown warnings. CMAKE_CXX_FLAGS may contain GCC-specific options
+  # which are not supported by Clang.
+  list(APPEND global_flags -Wno-unknown-warning-option)
+  set(compile_flags ${global_flags} ${SOURCE_CFLAGS})
+  add_custom_command(
+    OUTPUT ${object_file}
+    COMMAND ${COMPILER_RT_TEST_COMPILER} ${compile_flags} -c
+            -o "${object_file}"
+            ${source_rpath}
+    MAIN_DEPENDENCY ${source}
+    DEPENDS ${SOURCE_DEPS})
+endmacro()
+
+# On Darwin, there are no system-wide C++ headers and the just-built clang is
+# therefore not able to compile C++ files unless they are copied/symlinked into
+# ${LLVM_BINARY_DIR}/include/c++
+# The just-built clang is used to build compiler-rt unit tests. Let's detect
+# this before we try to build the tests and print out a suggestion how to fix
+# it.
+# On other platforms, this is currently not an issue.
+macro(clang_compiler_add_cxx_check)
+  if (APPLE)
+    set(CMD
+      "echo '#include <iostream>' | ${COMPILER_RT_TEST_COMPILER} ${OSX_SYSROOT_FLAG} -E -x c++ - > /dev/null"
+      "if [ $? != 0 ] "
+      "  then echo"
+      "  echo 'Your just-built clang cannot find C++ headers, which are needed to build and run compiler-rt tests.'"
+      "  echo 'You should copy or symlink your system C++ headers into ${LLVM_BINARY_DIR}/include/c++'"
+      "  if [ -d $(dirname $(dirname $(xcrun -f clang)))/include/c++ ]"
+      "    then echo 'e.g. with:'"
+      "    echo '  cp -r' $(dirname $(dirname $(xcrun -f clang)))/include/c++ '${LLVM_BINARY_DIR}/include/'"
+      "  elif [ -d $(dirname $(dirname $(xcrun -f clang)))/lib/c++ ]"
+      "    then echo 'e.g. with:'"
+      "    echo '  cp -r' $(dirname $(dirname $(xcrun -f clang)))/lib/c++ '${LLVM_BINARY_DIR}/include/'"
+      "  fi"
+      "  echo 'This can also be fixed by checking out the libcxx project from llvm.org and installing the headers'"
+      "  echo 'into your build directory:'"
+      "  echo '  cd ${LLVM_SOURCE_DIR}/projects && svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx'"
+      "  echo '  cd ${LLVM_BINARY_DIR} && make -C ${LLVM_SOURCE_DIR}/projects/libcxx installheaders HEADER_DIR=${LLVM_BINARY_DIR}/include'"
+      "  echo"
+      "  false"
+      "fi"
+      )
+    add_custom_target(CompilerRTUnitTestCheckCxx
+      COMMAND bash -c "${CMD}"
+      COMMENT "Checking that just-built clang can find C++ headers..."
+      VERBATIM)
+    if (TARGET clang)
+      ADD_DEPENDENCIES(CompilerRTUnitTestCheckCxx clang)
+    endif()
+  endif()
+endmacro()
diff --git a/compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake b/compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake
new file mode 100644
index 0000000..511361b
--- /dev/null
+++ b/compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake
@@ -0,0 +1,453 @@
+# On OS X SDKs can be installed anywhere on the base system and xcode-select can
+# set the default Xcode to use. This function finds the SDKs that are present in
+# the current Xcode.
+function(find_darwin_sdk_dir var sdk_name)
+  # Let's first try the internal SDK, otherwise use the public SDK.
+  execute_process(
+    COMMAND xcodebuild -version -sdk ${sdk_name}.internal Path
+    OUTPUT_VARIABLE var_internal
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_FILE /dev/null
+  )
+  if("" STREQUAL "${var_internal}")
+    execute_process(
+      COMMAND xcodebuild -version -sdk ${sdk_name} Path
+      OUTPUT_VARIABLE var_internal
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_FILE /dev/null
+    )
+  endif()
+  set(${var} ${var_internal} PARENT_SCOPE)
+endfunction()
+
+# There isn't a clear mapping of what architectures are supported with a given
+# target platform, but ld's version output does list the architectures it can
+# link for.
+function(darwin_get_toolchain_supported_archs output_var)
+  execute_process(
+    COMMAND ld -v
+    ERROR_VARIABLE LINKER_VERSION)
+
+  string(REGEX MATCH "configured to support archs: ([^\n]+)"
+         ARCHES_MATCHED "${LINKER_VERSION}")
+  if(ARCHES_MATCHED)
+    set(ARCHES "${CMAKE_MATCH_1}")
+    message(STATUS "Got ld supported ARCHES: ${ARCHES}")
+    string(REPLACE " " ";" ARCHES ${ARCHES})
+  else()
+    # If auto-detecting fails, fall back to a default set
+    message(WARNING "Detecting supported architectures from 'ld -v' failed. Returning default set.")
+    set(ARCHES "i386;x86_64;armv7;armv7s;arm64")
+  endif()
+  
+  set(${output_var} ${ARCHES} PARENT_SCOPE)
+endfunction()
+
+# This function takes an OS and a list of architectures and identifies the
+# subset of the architectures list that the installed toolchain can target.
+function(darwin_test_archs os valid_archs)
+  if(${valid_archs})
+    message(STATUS "Using cached valid architectures for ${os}.")
+    return()
+  endif()
+
+  set(archs ${ARGN})
+  message(STATUS "Finding valid architectures for ${os}...")
+  set(SIMPLE_CPP ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.cpp)
+  file(WRITE ${SIMPLE_CPP} "#include <iostream>\nint main() { std::cout << std::endl; return 0; }\n")
+
+  set(os_linker_flags)
+  foreach(flag ${DARWIN_${os}_LINKFLAGS})
+    set(os_linker_flags "${os_linker_flags} ${flag}")
+  endforeach()
+
+  # The simple program will build for x86_64h on the simulator because it is 
+  # compatible with x86_64 libraries (mostly), but since x86_64h isn't actually
+  # a valid or useful architecture for the iOS simulator we should drop it.
+  if(${os} STREQUAL "iossim")
+    list(REMOVE_ITEM archs "x86_64h")
+  endif()
+
+  set(working_archs)
+  foreach(arch ${archs})
+    
+    set(arch_linker_flags "-arch ${arch} ${os_linker_flags}")
+    try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_CPP}
+                COMPILE_DEFINITIONS "-v -arch ${arch}" ${DARWIN_${os}_CFLAGS}
+                CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${arch_linker_flags}"
+                OUTPUT_VARIABLE TEST_OUTPUT)
+    if(${CAN_TARGET_${os}_${arch}})
+      list(APPEND working_archs ${arch})
+    else()
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Testing compiler for supporting ${os}-${arch}:\n"
+        "${TEST_OUTPUT}\n")
+    endif()
+  endforeach()
+  set(${valid_archs} ${working_archs}
+    CACHE STRING "List of valid architectures for platform ${os}.")
+endfunction()
+
+# This function checks the host cpusubtype to see if it is post-haswell. Haswell
+# and later machines can run x86_64h binaries. Haswell is cpusubtype 8.
+function(darwin_filter_host_archs input output)
+  list_union(tmp_var DARWIN_osx_ARCHS ${input})
+  execute_process(
+    COMMAND sysctl hw.cpusubtype
+    OUTPUT_VARIABLE SUBTYPE)
+
+  string(REGEX MATCH "hw.cpusubtype: ([0-9]*)"
+         SUBTYPE_MATCHED "${SUBTYPE}")
+  set(HASWELL_SUPPORTED Off)
+  if(SUBTYPE_MATCHED)
+    if(${CMAKE_MATCH_1} GREATER 7)
+      set(HASWELL_SUPPORTED On)
+    endif()
+  endif()
+  if(NOT HASWELL_SUPPORTED)
+    list(REMOVE_ITEM tmp_var x86_64h)
+  endif()
+  set(${output} ${tmp_var} PARENT_SCOPE)
+endfunction()
+
+# Read and process the exclude file into a list of symbols
+function(darwin_read_list_from_file output_var file)
+  if(EXISTS ${file})
+    file(READ ${file} EXCLUDES)
+    string(REPLACE "\n" ";" EXCLUDES ${EXCLUDES})
+    set(${output_var} ${EXCLUDES} PARENT_SCOPE)
+  endif()
+endfunction()
+
+# this function takes an OS, architecture and minimum version and provides a
+# list of builtin functions to exclude
+function(darwin_find_excluded_builtins_list output_var)
+  cmake_parse_arguments(LIB
+    ""
+    "OS;ARCH;MIN_VERSION"
+    ""
+    ${ARGN})
+
+  if(NOT LIB_OS OR NOT LIB_ARCH)
+    message(FATAL_ERROR "Must specify OS and ARCH to darwin_find_excluded_builtins_list!")
+  endif()
+
+  darwin_read_list_from_file(${LIB_OS}_BUILTINS
+    ${DARWIN_EXCLUDE_DIR}/${LIB_OS}.txt)
+  darwin_read_list_from_file(${LIB_OS}_${LIB_ARCH}_BASE_BUILTINS
+    ${DARWIN_EXCLUDE_DIR}/${LIB_OS}-${LIB_ARCH}.txt)
+
+  if(LIB_MIN_VERSION)
+    file(GLOB builtin_lists ${DARWIN_EXCLUDE_DIR}/${LIB_OS}*-${LIB_ARCH}.txt)
+    foreach(builtin_list ${builtin_lists})
+      string(REGEX MATCH "${LIB_OS}([0-9\\.]*)-${LIB_ARCH}.txt" VERSION_MATCHED "${builtin_list}")
+      if (VERSION_MATCHED AND NOT CMAKE_MATCH_1 VERSION_LESS LIB_MIN_VERSION)
+        if(NOT smallest_version)
+          set(smallest_version ${CMAKE_MATCH_1})
+        elseif(CMAKE_MATCH_1 VERSION_LESS smallest_version)
+          set(smallest_version ${CMAKE_MATCH_1})
+        endif()
+      endif()
+    endforeach()
+
+    if(smallest_version)
+      darwin_read_list_from_file(${LIB_ARCH}_${LIB_OS}_BUILTINS
+        ${DARWIN_EXCLUDE_DIR}/${LIB_OS}${smallest_version}-${LIB_ARCH}.txt)
+    endif()
+  endif()
+  
+  set(${output_var}
+      ${${LIB_ARCH}_${LIB_OS}_BUILTINS}
+      ${${LIB_OS}_${LIB_ARCH}_BASE_BUILTINS}
+      ${${LIB_OS}_BUILTINS} PARENT_SCOPE)
+endfunction()
+
+# adds a single builtin library for a single OS & ARCH
+macro(darwin_add_builtin_library name suffix)
+  cmake_parse_arguments(LIB
+    ""
+    "PARENT_TARGET;OS;ARCH"
+    "SOURCES;CFLAGS;DEFS"
+    ${ARGN})
+  set(libname "${name}.${suffix}_${LIB_ARCH}_${LIB_OS}")
+  add_library(${libname} STATIC ${LIB_SOURCES})
+  if(DARWIN_${LIB_OS}_SYSROOT)
+    set(sysroot_flag -isysroot ${DARWIN_${LIB_OS}_SYSROOT})
+  endif()
+  set_target_compile_flags(${libname}
+    ${sysroot_flag}
+    ${DARWIN_${LIB_OS}_BUILTIN_MIN_VER_FLAG}
+    ${LIB_CFLAGS})
+  set_property(TARGET ${libname} APPEND PROPERTY
+      COMPILE_DEFINITIONS ${LIB_DEFS})
+  set_target_properties(${libname} PROPERTIES
+      OUTPUT_NAME ${libname}${COMPILER_RT_OS_SUFFIX})
+  set_target_properties(${libname} PROPERTIES
+    OSX_ARCHITECTURES ${LIB_ARCH})
+
+  if(LIB_PARENT_TARGET)
+    add_dependencies(${LIB_PARENT_TARGET} ${libname})
+  endif()
+
+  list(APPEND ${LIB_OS}_${suffix}_libs ${libname})
+  list(APPEND ${LIB_OS}_${suffix}_lipo_flags -arch ${arch} $<TARGET_FILE:${libname}>)
+endmacro()
+
+function(darwin_lipo_libs name)
+  cmake_parse_arguments(LIB
+    ""
+    "PARENT_TARGET;OUTPUT_DIR;INSTALL_DIR"
+    "LIPO_FLAGS;DEPENDS"
+    ${ARGN})
+  if(LIB_DEPENDS AND LIB_LIPO_FLAGS)
+    add_custom_command(OUTPUT ${LIB_OUTPUT_DIR}/lib${name}.a
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${LIB_OUTPUT_DIR}
+      COMMAND lipo -output
+              ${LIB_OUTPUT_DIR}/lib${name}.a
+              -create ${LIB_LIPO_FLAGS}
+      DEPENDS ${LIB_DEPENDS}
+      )
+    add_custom_target(${name}
+      DEPENDS ${LIB_OUTPUT_DIR}/lib${name}.a)
+    add_dependencies(${LIB_PARENT_TARGET} ${name})
+    install(FILES ${LIB_OUTPUT_DIR}/lib${name}.a
+      DESTINATION ${LIB_INSTALL_DIR})
+  else()
+    message(WARNING "Not generating lipo target for ${name} because no input libraries exist.")
+  endif()
+endfunction()
+
+# Filter out generic versions of routines that are re-implemented in
+# architecture specific manner.  This prevents multiple definitions of the
+# same symbols, making the symbol selection non-deterministic.
+function(darwin_filter_builtin_sources output_var exclude_or_include excluded_list)
+  if(exclude_or_include STREQUAL "EXCLUDE")
+    set(filter_action GREATER)
+    set(filter_value -1)
+  elseif(exclude_or_include STREQUAL "INCLUDE")
+    set(filter_action LESS)
+    set(filter_value 0)
+  else()
+    message(FATAL_ERROR "darwin_filter_builtin_sources called without EXCLUDE|INCLUDE")
+  endif()
+
+  set(intermediate ${ARGN})
+  foreach (_file ${intermediate})
+    get_filename_component(_name_we ${_file} NAME_WE)
+    list(FIND ${excluded_list} ${_name_we} _found)
+    if(_found ${filter_action} ${filter_value})
+      list(REMOVE_ITEM intermediate ${_file})
+    elseif(${_file} MATCHES ".*/.*\\.S" OR ${_file} MATCHES ".*/.*\\.c")
+      get_filename_component(_name ${_file} NAME)
+      string(REPLACE ".S" ".c" _cname "${_name}")
+      list(REMOVE_ITEM intermediate ${_cname})
+    endif ()
+  endforeach ()
+  set(${output_var} ${intermediate} PARENT_SCOPE)
+endfunction()
+
+function(darwin_add_eprintf_library)
+  cmake_parse_arguments(LIB
+    ""
+    ""
+    "CFLAGS"
+    ${ARGN})
+
+  add_library(clang_rt.eprintf STATIC eprintf.c)
+  set_target_compile_flags(clang_rt.eprintf
+    -isysroot ${DARWIN_osx_SYSROOT}
+    ${DARWIN_osx_BUILTIN_MIN_VER_FLAG}
+    -arch i386
+    ${LIB_CFLAGS})
+  set_target_properties(clang_rt.eprintf PROPERTIES
+      OUTPUT_NAME clang_rt.eprintf${COMPILER_RT_OS_SUFFIX})
+  set_target_properties(clang_rt.eprintf PROPERTIES
+    OSX_ARCHITECTURES i386)
+  add_dependencies(builtins clang_rt.eprintf)
+  set_target_properties(clang_rt.eprintf PROPERTIES
+        ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
+  install(TARGETS clang_rt.eprintf
+      ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+endfunction()
+
+# Generates builtin libraries for all operating systems specified in ARGN. Each
+# OS library is constructed by lipo-ing together single-architecture libraries.
+macro(darwin_add_builtin_libraries)
+  set(DARWIN_EXCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Darwin-excludes)
+
+  set(CFLAGS "-fPIC -O3 -fvisibility=hidden -DVISIBILITY_HIDDEN -Wall -fomit-frame-pointer")
+  set(CMAKE_C_FLAGS "")
+  set(CMAKE_CXX_FLAGS "")
+  set(CMAKE_ASM_FLAGS "")
+
+  set(PROFILE_SOURCES ../profile/InstrProfiling 
+                      ../profile/InstrProfilingBuffer
+                      ../profile/InstrProfilingPlatformDarwin)
+  foreach (os ${ARGN})
+    list_union(DARWIN_BUILTIN_ARCHS DARWIN_${os}_ARCHS BUILTIN_SUPPORTED_ARCH)
+    foreach (arch ${DARWIN_BUILTIN_ARCHS})
+      darwin_find_excluded_builtins_list(${arch}_${os}_EXCLUDED_BUILTINS
+                              OS ${os}
+                              ARCH ${arch}
+                              MIN_VERSION ${DARWIN_${os}_BUILTIN_MIN_VER})
+
+      darwin_filter_builtin_sources(filtered_sources
+        EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS
+        ${${arch}_SOURCES})
+
+      darwin_add_builtin_library(clang_rt builtins
+                              OS ${os}
+                              ARCH ${arch}
+                              SOURCES ${filtered_sources}
+                              CFLAGS ${CFLAGS} -arch ${arch}
+                              PARENT_TARGET builtins)
+    endforeach()
+
+    # Don't build cc_kext libraries for simulator platforms
+    if(NOT DARWIN_${os}_SKIP_CC_KEXT)
+      foreach (arch ${DARWIN_BUILTIN_ARCHS})
+        # By not specifying MIN_VERSION this only reads the OS and OS-arch lists.
+        # We don't want to filter out the builtins that are present in libSystem
+        # because kexts can't link libSystem.
+        darwin_find_excluded_builtins_list(${arch}_${os}_EXCLUDED_BUILTINS
+                              OS ${os}
+                              ARCH ${arch})
+
+        darwin_filter_builtin_sources(filtered_sources
+          EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS
+          ${${arch}_SOURCES})
+
+        # In addition to the builtins cc_kext includes some profile sources
+        darwin_add_builtin_library(clang_rt cc_kext
+                                OS ${os}
+                                ARCH ${arch}
+                                SOURCES ${filtered_sources} ${PROFILE_SOURCES}
+                                CFLAGS ${CFLAGS} -arch ${arch} -mkernel
+                                DEFS KERNEL_USE
+                                PARENT_TARGET builtins)
+      endforeach()
+      set(archive_name clang_rt.cc_kext_${os})
+      if(${os} STREQUAL "osx")
+        set(archive_name clang_rt.cc_kext)
+      endif()
+      darwin_lipo_libs(${archive_name}
+                      PARENT_TARGET builtins
+                      LIPO_FLAGS ${${os}_cc_kext_lipo_flags}
+                      DEPENDS ${${os}_cc_kext_libs}
+                      OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
+                      INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+    endif()
+  endforeach()
+
+  darwin_add_eprintf_library(CFLAGS ${CFLAGS})
+
+  # We put the x86 sim slices into the archives for their base OS
+  foreach (os ${ARGN})
+    if(NOT ${os} MATCHES ".*sim$")
+      darwin_lipo_libs(clang_rt.${os}
+                        PARENT_TARGET builtins
+                        LIPO_FLAGS ${${os}_builtins_lipo_flags} ${${os}sim_builtins_lipo_flags}
+                        DEPENDS ${${os}_builtins_libs} ${${os}sim_builtins_libs}
+                        OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
+                        INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+    endif()
+  endforeach()
+  darwin_add_embedded_builtin_libraries()
+endmacro()
+
+macro(darwin_add_embedded_builtin_libraries)
+  # this is a hacky opt-out. If you can't target both intel and arm
+  # architectures we bail here.
+  set(DARWIN_SOFT_FLOAT_ARCHS armv6m armv7m armv7em armv7)
+  set(DARWIN_HARD_FLOAT_ARCHS armv7em armv7)
+  if(COMPILER_RT_SUPPORTED_ARCH MATCHES ".*armv.*")
+    list(FIND COMPILER_RT_SUPPORTED_ARCH i386 i386_idx)
+    if(i386_idx GREATER -1)
+      list(APPEND DARWIN_HARD_FLOAT_ARCHS i386)
+    endif()
+
+    list(FIND COMPILER_RT_SUPPORTED_ARCH x86_64 x86_64_idx)
+    if(x86_64_idx GREATER -1)
+      list(APPEND DARWIN_HARD_FLOAT_ARCHS x86_64)
+    endif()
+
+    set(MACHO_SYM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/macho_embedded)
+
+    set(CFLAGS "-Oz -Wall -fomit-frame-pointer -ffreestanding")
+    set(CMAKE_C_FLAGS "")
+    set(CMAKE_CXX_FLAGS "")
+    set(CMAKE_ASM_FLAGS "")
+
+    set(SOFT_FLOAT_FLAG -mfloat-abi=soft)
+    set(HARD_FLOAT_FLAG -mfloat-abi=hard)
+
+    set(ENABLE_PIC Off)
+    set(PIC_FLAG -fPIC)
+    set(STATIC_FLAG -static)
+
+    set(DARWIN_macho_embedded_ARCHS armv6m armv7m armv7em armv7 i386 x86_64)
+
+    set(DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR
+      ${COMPILER_RT_OUTPUT_DIR}/lib/macho_embedded)
+    set(DARWIN_macho_embedded_LIBRARY_INSTALL_DIR
+      ${COMPILER_RT_INSTALL_PATH}/lib/macho_embedded)
+      
+    set(CFLAGS_armv7 "-target thumbv7-apple-darwin-eabi")
+    set(CFLAGS_i386 "-march=pentium")
+
+    darwin_read_list_from_file(common_FUNCTIONS ${MACHO_SYM_DIR}/common.txt)
+    darwin_read_list_from_file(thumb2_FUNCTIONS ${MACHO_SYM_DIR}/thumb2.txt)
+    darwin_read_list_from_file(thumb2_64_FUNCTIONS ${MACHO_SYM_DIR}/thumb2-64.txt)
+    darwin_read_list_from_file(arm_FUNCTIONS ${MACHO_SYM_DIR}/arm.txt)
+    darwin_read_list_from_file(i386_FUNCTIONS ${MACHO_SYM_DIR}/i386.txt)
+
+
+    set(armv6m_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS})
+    set(armv7m_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS})
+    set(armv7em_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS})
+    set(armv7_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS} ${thumb2_64_FUNCTIONS})
+    set(i386_FUNCTIONS ${common_FUNCTIONS} ${i386_FUNCTIONS})
+    set(x86_64_FUNCTIONS ${common_FUNCTIONS})
+
+    foreach(arch ${DARWIN_macho_embedded_ARCHS})
+      darwin_filter_builtin_sources(${arch}_filtered_sources
+        INCLUDE ${arch}_FUNCTIONS
+        ${${arch}_SOURCES})
+      if(NOT ${arch}_filtered_sources)
+        message("${arch}_SOURCES: ${${arch}_SOURCES}")
+        message("${arch}_FUNCTIONS: ${${arch}_FUNCTIONS}")
+        message(FATAL_ERROR "Empty filtered sources!")
+      endif()
+    endforeach()
+
+    foreach(float_type SOFT HARD)
+      foreach(type PIC STATIC)
+        string(TOLOWER "${float_type}_${type}" lib_suffix)
+        foreach(arch ${DARWIN_${float_type}_FLOAT_ARCHS})
+          set(DARWIN_macho_embedded_SYSROOT ${DARWIN_osx_SYSROOT})
+          set(float_flag)
+          if(${arch} MATCHES "^arm")
+            # x86 targets are hard float by default, but the complain about the
+            # float ABI flag, so don't pass it unless we're targeting arm.
+            set(float_flag ${${float_type}_FLOAT_FLAG})
+          endif()
+          darwin_add_builtin_library(clang_rt ${lib_suffix}
+                                OS macho_embedded
+                                ARCH ${arch}
+                                SOURCES ${${arch}_filtered_sources}
+                                CFLAGS ${CFLAGS} -arch ${arch} ${${type}_FLAG} ${float_flag} ${CFLAGS_${arch}}
+                                PARENT_TARGET builtins)
+        endforeach()
+        foreach(lib ${macho_embedded_${lib_suffix}_libs})
+          set_target_properties(${lib} PROPERTIES LINKER_LANGUAGE C)
+        endforeach()
+        darwin_lipo_libs(clang_rt.${lib_suffix}
+                      PARENT_TARGET builtins
+                      LIPO_FLAGS ${macho_embedded_${lib_suffix}_lipo_flags}
+                      DEPENDS ${macho_embedded_${lib_suffix}_libs}
+                      OUTPUT_DIR ${DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR}
+                      INSTALL_DIR ${DARWIN_macho_embedded_LIBRARY_INSTALL_DIR})
+      endforeach()
+    endforeach()
+  endif()
+endmacro()
diff --git a/compiler-rt/cmake/Modules/CompilerRTLink.cmake b/compiler-rt/cmake/Modules/CompilerRTLink.cmake
new file mode 100644
index 0000000..bb96869
--- /dev/null
+++ b/compiler-rt/cmake/Modules/CompilerRTLink.cmake
@@ -0,0 +1,16 @@
+# Link a shared library with COMPILER_RT_TEST_COMPILER.
+# clang_link_shared(<output.so>
+#                   OBJECTS <list of input objects>
+#                   LINKFLAGS <list of link flags>
+#                   DEPS <list of dependencies>)
+macro(clang_link_shared so_file)
+  cmake_parse_arguments(SOURCE "" "" "OBJECTS;LINKFLAGS;DEPS" ${ARGN})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND SOURCE_DEPS clang)
+  endif()
+  add_custom_command(
+    OUTPUT ${so_file}
+    COMMAND ${COMPILER_RT_TEST_COMPILER} -o "${so_file}" -shared
+            ${SOURCE_LINKFLAGS} ${SOURCE_OBJECTS}
+    DEPENDS ${SOURCE_DEPS})
+endmacro()
diff --git a/compiler-rt/cmake/Modules/CompilerRTUtils.cmake b/compiler-rt/cmake/Modules/CompilerRTUtils.cmake
new file mode 100644
index 0000000..cf690f4
--- /dev/null
+++ b/compiler-rt/cmake/Modules/CompilerRTUtils.cmake
@@ -0,0 +1,69 @@
+# Because compiler-rt spends a lot of time setting up custom compile flags,
+# define a handy helper function for it. The compile flags setting in CMake
+# has serious issues that make its syntax challenging at best.
+function(set_target_compile_flags target)
+  set(argstring "")
+  foreach(arg ${ARGN})
+    set(argstring "${argstring} ${arg}")
+  endforeach()
+  set_property(TARGET ${target} PROPERTY COMPILE_FLAGS "${argstring}")
+endfunction()
+
+function(set_target_link_flags target)
+  set(argstring "")
+  foreach(arg ${ARGN})
+    set(argstring "${argstring} ${arg}")
+  endforeach()
+  set_property(TARGET ${target} PROPERTY LINK_FLAGS "${argstring}")
+endfunction()
+
+# Set the variable var_PYBOOL to True if var holds a true-ish string,
+# otherwise set it to False.
+macro(pythonize_bool var)
+  if (${var})
+    set(${var}_PYBOOL True)
+  else()
+    set(${var}_PYBOOL False)
+  endif()
+endmacro()
+
+# Appends value to all lists in ARGN, if the condition is true.
+macro(append_list_if condition value)
+  if(${condition})
+    foreach(list ${ARGN})
+      list(APPEND ${list} ${value})
+    endforeach()
+  endif()
+endmacro()
+
+# Appends value to all strings in ARGN, if the condition is true.
+macro(append_string_if condition value)
+  if(${condition})
+    foreach(str ${ARGN})
+      set(${str} "${${str}} ${value}")
+    endforeach()
+  endif()
+endmacro()
+
+macro(append_no_rtti_flag list)
+  append_list_if(COMPILER_RT_HAS_FNO_RTTI_FLAG -fno-rtti ${list})
+  append_list_if(COMPILER_RT_HAS_GR_FLAG /GR- ${list})
+endmacro()
+
+macro(append_have_file_definition filename varname list)
+  check_include_file("${filename}" "${varname}")
+  if (NOT ${varname})
+    set("${varname}" 0)
+  endif()
+  list(APPEND ${list} "${varname}=${${varname}}")
+endmacro()
+
+macro(list_union output input1 input2)
+  set(${output})
+  foreach(it ${${input1}})
+    list(FIND ${input2} ${it} index)
+    if( NOT (index EQUAL -1))
+      list(APPEND ${output} ${it})
+    endif()
+  endforeach()
+endmacro()
diff --git a/compiler-rt/cmake/Modules/SanitizerUtils.cmake b/compiler-rt/cmake/Modules/SanitizerUtils.cmake
new file mode 100644
index 0000000..3eb49c8
--- /dev/null
+++ b/compiler-rt/cmake/Modules/SanitizerUtils.cmake
@@ -0,0 +1,97 @@
+set(SANITIZER_GEN_DYNAMIC_LIST
+  ${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/scripts/gen_dynamic_list.py)
+
+set(SANITIZER_LINT_SCRIPT
+  ${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/scripts/check_lint.sh)
+
+# Create a target "<name>-<arch>-symbols" that would generate the list of
+# symbols that need to be exported from sanitizer runtime "<name>". Function
+# interceptors are exported automatically, user can also provide files with
+# symbol names that should be exported as well.
+#   add_sanitizer_rt_symbols(<name>
+#                            ARCHS <architectures>
+#                            PARENT_TARGET <convenience parent target>
+#                            EXTRA <files with extra symbols to export>)
+macro(add_sanitizer_rt_symbols name)
+  cmake_parse_arguments(ARG
+    ""
+    "PARENT_TARGET"
+    "ARCHS;EXTRA"
+    ${ARGN})
+  foreach(arch ${ARG_ARCHS})
+    set(target_name ${name}-${arch})
+    set(stamp ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.syms-stamp)
+    set(extra_args)
+    foreach(arg ${ARG_EXTRA})
+      list(APPEND extra_args "--extra" ${arg})
+    endforeach()
+    add_custom_command(OUTPUT ${stamp}
+      COMMAND ${PYTHON_EXECUTABLE}
+        ${SANITIZER_GEN_DYNAMIC_LIST} ${extra_args} $<TARGET_FILE:${target_name}>
+        > $<TARGET_FILE:${target_name}>.syms
+      COMMAND ${CMAKE_COMMAND} -E touch ${stamp}
+      DEPENDS ${target_name} ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      COMMENT "Generating exported symbols for ${target_name}"
+      VERBATIM)
+    add_custom_target(${target_name}-symbols ALL
+      DEPENDS ${stamp}
+      SOURCES ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA})
+
+    if(NOT CMAKE_VERSION VERSION_LESS 3.0)
+      install(FILES $<TARGET_FILE:${target_name}>.syms
+              DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+    else()
+      # Per-config install location.
+      if(CMAKE_CONFIGURATION_TYPES)
+        foreach(c ${CMAKE_CONFIGURATION_TYPES})
+          get_target_property(libfile ${target_name} LOCATION_${c})
+          install(FILES ${libfile}.syms CONFIGURATIONS ${c}
+            DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+        endforeach()
+      else()
+        get_target_property(libfile ${target_name} LOCATION_${CMAKE_BUILD_TYPE})
+        install(FILES ${libfile}.syms DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+      endif()
+    endif()
+    if(ARG_PARENT_TARGET)
+      add_dependencies(${ARG_PARENT_TARGET} ${target_name}-symbols)
+    endif()
+  endforeach()
+endmacro()
+
+macro(add_sanitizer_rt_version_list name)
+  set(vers ${CMAKE_CURRENT_BINARY_DIR}/${name}.vers)
+  cmake_parse_arguments(ARG "" "" "LIBS;EXTRA" ${ARGN})
+  set(args)
+  foreach(arg ${ARG_EXTRA})
+    list(APPEND args "--extra" ${arg})
+  endforeach()
+  foreach(arg ${ARG_LIBS})
+    list(APPEND args "$<TARGET_FILE:${arg}>")
+  endforeach()
+  add_custom_command(OUTPUT ${vers}
+    COMMAND ${PYTHON_EXECUTABLE}
+      ${SANITIZER_GEN_DYNAMIC_LIST} --version-list ${args}
+      > ${vers}
+    DEPENDS ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA} ${ARG_LIBS}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Generating version list for ${name}"
+    VERBATIM)
+
+  add_custom_target(${name}-version-list ALL
+    DEPENDS ${vers})
+endmacro()
+
+# Add target to check code style for sanitizer runtimes.
+if(UNIX)
+  add_custom_target(SanitizerLintCheck
+    COMMAND LLVM_CHECKOUT=${LLVM_MAIN_SRC_DIR} SILENT=1 TMPDIR=
+      PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
+      COMPILER_RT=${COMPILER_RT_SOURCE_DIR}
+      ${SANITIZER_LINT_SCRIPT}
+    DEPENDS ${SANITIZER_LINT_SCRIPT}
+    COMMENT "Running lint check for sanitizer sources..."
+    VERBATIM)
+endif()
+
diff --git a/compiler-rt/cmake/config-ix.cmake b/compiler-rt/cmake/config-ix.cmake
new file mode 100644
index 0000000..f91530b
--- /dev/null
+++ b/compiler-rt/cmake/config-ix.cmake
@@ -0,0 +1,594 @@
+include(CMakePushCheckState)
+include(CheckCXXCompilerFlag)
+include(CheckLibraryExists)
+include(CheckSymbolExists)
+include(TestBigEndian)
+
+function(check_linker_flag flag out_var)
+  cmake_push_check_state()
+  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag}")
+  check_cxx_compiler_flag("" ${out_var})
+  cmake_pop_check_state()
+endfunction()
+
+# CodeGen options.
+check_cxx_compiler_flag(-fPIC                COMPILER_RT_HAS_FPIC_FLAG)
+check_cxx_compiler_flag(-fPIE                COMPILER_RT_HAS_FPIE_FLAG)
+check_cxx_compiler_flag(-fno-builtin         COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
+check_cxx_compiler_flag(-fno-exceptions      COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
+check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)
+check_cxx_compiler_flag(-funwind-tables      COMPILER_RT_HAS_FUNWIND_TABLES_FLAG)
+check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG)
+check_cxx_compiler_flag(-fno-sanitize=safe-stack COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG)
+check_cxx_compiler_flag(-fvisibility=hidden  COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
+check_cxx_compiler_flag(-fno-rtti            COMPILER_RT_HAS_FNO_RTTI_FLAG)
+check_cxx_compiler_flag(-ffreestanding       COMPILER_RT_HAS_FFREESTANDING_FLAG)
+check_cxx_compiler_flag("-Werror -fno-function-sections" COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG)
+check_cxx_compiler_flag(-std=c++11           COMPILER_RT_HAS_STD_CXX11_FLAG)
+check_cxx_compiler_flag(-ftls-model=initial-exec COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC)
+check_cxx_compiler_flag(-fno-lto             COMPILER_RT_HAS_FNO_LTO_FLAG)
+check_cxx_compiler_flag("-Werror -msse3" COMPILER_RT_HAS_MSSE3_FLAG)
+check_cxx_compiler_flag(-std=c99             COMPILER_RT_HAS_STD_C99_FLAG)
+check_cxx_compiler_flag(--sysroot=.          COMPILER_RT_HAS_SYSROOT_FLAG)
+
+if(NOT WIN32 AND NOT CYGWIN)
+  # MinGW warns if -fvisibility-inlines-hidden is used.
+  check_cxx_compiler_flag("-fvisibility-inlines-hidden" COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG)
+endif()
+
+check_cxx_compiler_flag(/GR COMPILER_RT_HAS_GR_FLAG)
+check_cxx_compiler_flag(/GS COMPILER_RT_HAS_GS_FLAG)
+check_cxx_compiler_flag(/MT COMPILER_RT_HAS_MT_FLAG)
+check_cxx_compiler_flag(/Oy COMPILER_RT_HAS_Oy_FLAG)
+
+# Debug info flags.
+check_cxx_compiler_flag(-gline-tables-only COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG)
+check_cxx_compiler_flag(-g COMPILER_RT_HAS_G_FLAG)
+check_cxx_compiler_flag(/Zi COMPILER_RT_HAS_Zi_FLAG)
+
+# Warnings.
+check_cxx_compiler_flag(-Wall COMPILER_RT_HAS_WALL_FLAG)
+check_cxx_compiler_flag(-Werror COMPILER_RT_HAS_WERROR_FLAG)
+check_cxx_compiler_flag("-Werror -Wframe-larger-than=512" COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG)
+check_cxx_compiler_flag("-Werror -Wglobal-constructors"   COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG)
+check_cxx_compiler_flag("-Werror -Wc99-extensions"     COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG)
+check_cxx_compiler_flag("-Werror -Wgnu"                COMPILER_RT_HAS_WGNU_FLAG)
+check_cxx_compiler_flag("-Werror -Wnon-virtual-dtor"   COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG)
+check_cxx_compiler_flag("-Werror -Wvariadic-macros"    COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG)
+
+check_cxx_compiler_flag(/W3 COMPILER_RT_HAS_W3_FLAG)
+check_cxx_compiler_flag(/WX COMPILER_RT_HAS_WX_FLAG)
+check_cxx_compiler_flag(/wd4146 COMPILER_RT_HAS_WD4146_FLAG)
+check_cxx_compiler_flag(/wd4291 COMPILER_RT_HAS_WD4291_FLAG)
+check_cxx_compiler_flag(/wd4391 COMPILER_RT_HAS_WD4391_FLAG)
+check_cxx_compiler_flag(/wd4722 COMPILER_RT_HAS_WD4722_FLAG)
+check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG)
+
+# Symbols.
+check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL)
+
+# Libraries.
+check_library_exists(c fopen "" COMPILER_RT_HAS_LIBC)
+check_library_exists(dl dlopen "" COMPILER_RT_HAS_LIBDL)
+check_library_exists(rt shm_open "" COMPILER_RT_HAS_LIBRT)
+check_library_exists(m pow "" COMPILER_RT_HAS_LIBM)
+check_library_exists(pthread pthread_create "" COMPILER_RT_HAS_LIBPTHREAD)
+check_library_exists(stdc++ __cxa_throw "" COMPILER_RT_HAS_LIBSTDCXX)
+
+# Linker flags.
+if(ANDROID)
+  check_linker_flag("-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
+  check_library_exists(log __android_log_write "" COMPILER_RT_HAS_LIBLOG)
+endif()
+
+# Architectures.
+
+# List of all architectures we can target.
+set(COMPILER_RT_SUPPORTED_ARCH)
+
+# Try to compile a very simple source file to ensure we can target the given
+# platform. We use the results of these tests to build only the various target
+# runtime libraries supported by our current compilers cross-compiling
+# abilities.
+set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc)
+file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <limits>\nint main() {}\n")
+
+function(check_compile_definition def argstring out_var)
+  if("${def}" STREQUAL "")
+    set(${out_var} TRUE PARENT_SCOPE)
+    return()
+  endif()
+  cmake_push_check_state()
+  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}")
+  check_symbol_exists(${def} "" ${out_var})
+  cmake_pop_check_state()
+endfunction()
+
+# test_target_arch(<arch> <def> <target flags...>)
+# Checks if architecture is supported: runs host compiler with provided
+# flags to verify that:
+#   1) <def> is defined (if non-empty)
+#   2) simple file can be successfully built.
+# If successful, saves target flags for this architecture.
+macro(test_target_arch arch def)
+  set(TARGET_${arch}_CFLAGS ${ARGN})
+  set(argstring "")
+  foreach(arg ${ARGN})
+    set(argstring "${argstring} ${arg}")
+  endforeach()
+  check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF)
+  if(NOT HAS_${arch}_DEF)
+    set(CAN_TARGET_${arch} FALSE)
+  else()
+    set(argstring "${CMAKE_EXE_LINKER_FLAGS} ${argstring}")
+    try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE}
+                COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS}"
+                OUTPUT_VARIABLE TARGET_${arch}_OUTPUT
+                CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${argstring}")
+  endif()
+  if(${CAN_TARGET_${arch}})
+    list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "${arch}" AND
+         COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE)
+    # Bail out if we cannot target the architecture we plan to test.
+    message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}")
+  endif()
+endmacro()
+
+# Add $arch as supported with no additional flags.
+macro(add_default_target_arch arch)
+  set(TARGET_${arch}_CFLAGS "")
+  set(CAN_TARGET_${arch} 1)
+  list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+endmacro()
+
+macro(detect_target_arch)
+  check_symbol_exists(__arm__ "" __ARM)
+  check_symbol_exists(__aarch64__ "" __AARCH64)
+  check_symbol_exists(__x86_64__ "" __X86_64)
+  check_symbol_exists(__i686__ "" __I686)
+  check_symbol_exists(__i386__ "" __I386)
+  check_symbol_exists(__mips__ "" __MIPS)
+  check_symbol_exists(__mips64__ "" __MIPS64)
+  if(__ARM)
+    add_default_target_arch(arm)
+  elseif(__AARCH64)
+    add_default_target_arch(aarch64)
+  elseif(__X86_64)
+    add_default_target_arch(x86_64)
+  elseif(__I686)
+    add_default_target_arch(i686)
+  elseif(__I386)
+    add_default_target_arch(i386)
+  elseif(__MIPS64) # must be checked before __MIPS
+    add_default_target_arch(mips64)
+  elseif(__MIPS)
+    add_default_target_arch(mips)
+  endif()
+endmacro()
+
+# Detect whether the current target platform is 32-bit or 64-bit, and setup
+# the correct commandline flags needed to attempt to target 32-bit and 64-bit.
+if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
+    NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
+endif()
+
+# Generate the COMPILER_RT_SUPPORTED_ARCH list.
+if(ANDROID)
+  # Examine compiler output to determine target architecture.
+  detect_target_arch()
+  set(COMPILER_RT_OS_SUFFIX "-android")
+elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
+  if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64")
+    if(NOT MSVC)
+      test_target_arch(x86_64 "" "-m64")
+      # FIXME: We build runtimes for both i686 and i386, as "clang -m32" may
+      # target different variant than "$CMAKE_C_COMPILER -m32". This part should
+      # be gone after we resolve PR14109.
+      test_target_arch(i686 __i686__ "-m32")
+      test_target_arch(i386 __i386__ "-m32")
+    else()
+      if (CMAKE_SIZEOF_VOID_P EQUAL 4)
+        test_target_arch(i386 "" "")
+      else()
+        test_target_arch(x86_64 "" "")
+      endif()
+    endif()
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "powerpc")
+    TEST_BIG_ENDIAN(HOST_IS_BIG_ENDIAN)
+    if(HOST_IS_BIG_ENDIAN)
+      test_target_arch(powerpc64 "" "-m64")
+    else()
+      test_target_arch(powerpc64le "" "-m64")
+    endif()
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mipsel|mips64el")
+    # Gcc doesn't accept -m32/-m64 so we do the next best thing and use
+    # -mips32r2/-mips64r2. We don't use -mips1/-mips3 because we want to match
+    # clang's default CPU's. In the 64-bit case, we must also specify the ABI
+    # since the default ABI differs between gcc and clang.
+    # FIXME: Ideally, we would build the N32 library too.
+    test_target_arch(mipsel "" "-mips32r2" "--target=mipsel-linux-gnu")
+    test_target_arch(mips64el "" "-mips64r2" "--target=mips64el-linux-gnu" "-mabi=n64")
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mips")
+    test_target_arch(mips "" "-mips32r2" "--target=mips-linux-gnu")
+    test_target_arch(mips64 "" "-mips64r2" "--target=mips64-linux-gnu" "-mabi=n64")
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "arm")
+    test_target_arch(arm "" "-march=armv7-a" "-mfloat-abi=soft")
+    test_target_arch(armhf "" "-march=armv7-a" "-mfloat-abi=hard")
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "aarch32")
+    test_target_arch(aarch32 "" "-march=armv8-a")
+  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "aarch64")
+    test_target_arch(aarch64 "" "-march=armv8-a")
+  endif()
+  set(COMPILER_RT_OS_SUFFIX "")
+endif()
+
+# Takes ${ARGN} and puts only supported architectures in @out_var list.
+function(filter_available_targets out_var)
+  set(archs ${${out_var}})
+  foreach(arch ${ARGN})
+    list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
+    if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch})
+      list(APPEND archs ${arch})
+    endif()
+  endforeach()
+  set(${out_var} ${archs} PARENT_SCOPE)
+endfunction()
+
+# Returns a list of architecture specific target cflags in @out_var list.
+function(get_target_flags_for_arch arch out_var)
+  list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
+  if(ARCH_INDEX EQUAL -1)
+    message(FATAL_ERROR "Unsupported architecture: ${arch}")
+  else()
+    if (NOT APPLE)
+      set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
+    else()
+      # This is only called in constructing cflags for tests executing on the
+      # host. This will need to all be cleaned up to support building tests
+      # for cross-targeted hardware (i.e. iOS).
+      set(${out_var} -arch ${arch} PARENT_SCOPE)
+    endif()
+  endif()
+endfunction()
+
+set(ARM64 aarch64)
+set(ARM32 arm armhf)
+set(X86 i386 i686)
+set(X86_64 x86_64)
+set(MIPS32 mips mipsel)
+set(MIPS64 mips64 mips64el)
+set(PPC64 powerpc64 powerpc64le)
+
+if(APPLE)
+  set(ARM64 arm64)
+  set(ARM32 armv7 armv7s)
+  set(X86_64 x86_64 x86_64h)
+endif()
+
+set(ALL_BUILTIN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
+    ${MIPS32} ${MIPS64})
+set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
+    ${ARM32} ${ARM64} ${MIPS32} ${MIPS64})
+set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
+    ${MIPS32} ${MIPS64} ${PPC64})
+set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
+set(ALL_LSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
+set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
+set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
+    ${MIPS32} ${MIPS64})
+set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
+set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
+    ${MIPS32} ${MIPS64} ${PPC64})
+set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64})
+set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64})
+
+if(APPLE)
+  include(CompilerRTDarwinUtils)
+
+  # On Darwin if /usr/include doesn't exist, the user probably has Xcode but not
+  # the command line tools. If this is the case, we need to find the OS X
+  # sysroot to pass to clang.
+  if(NOT EXISTS /usr/include)
+    execute_process(COMMAND xcodebuild -version -sdk macosx Path
+       OUTPUT_VARIABLE OSX_SYSROOT
+       ERROR_QUIET
+       OUTPUT_STRIP_TRAILING_WHITESPACE)
+    set(OSX_SYSROOT_FLAG "-isysroot${OSX_SYSROOT}")
+  endif()
+
+  option(COMPILER_RT_ENABLE_IOS "Enable building for iOS - Experimental" Off)
+
+  find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
+  find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
+  find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos)
+
+  # Note: In order to target x86_64h on OS X the minimum deployment target must
+  # be 10.8 or higher.
+  set(SANITIZER_COMMON_SUPPORTED_OS osx)
+  set(BUILTIN_SUPPORTED_OS osx)
+  set(PROFILE_SUPPORTED_OS osx)
+  set(TSAN_SUPPORTED_OS osx)
+  if(NOT SANITIZER_MIN_OSX_VERSION)
+    string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)"
+           MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
+    if(MACOSX_VERSION_MIN_FLAG)
+      set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}")
+    elseif(CMAKE_OSX_DEPLOYMENT_TARGET)
+      set(SANITIZER_MIN_OSX_VERSION ${CMAKE_OSX_DEPLOYMENT_TARGET})
+    else()
+      set(SANITIZER_MIN_OSX_VERSION 10.9)
+    endif()
+    if(SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.7")
+      message(FATAL_ERROR "Too old OS X version: ${SANITIZER_MIN_OSX_VERSION}")
+    endif()
+  endif()
+
+  # We're setting the flag manually for each target OS
+  set(CMAKE_OSX_DEPLOYMENT_TARGET "")
+  
+  set(DARWIN_COMMON_CFLAGS -stdlib=libc++)
+  set(DARWIN_COMMON_LINKFLAGS
+    -stdlib=libc++
+    -lc++
+    -lc++abi)
+  
+  set(DARWIN_osx_CFLAGS
+    ${DARWIN_COMMON_CFLAGS}
+    -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
+  set(DARWIN_osx_LINKFLAGS
+    ${DARWIN_COMMON_LINKFLAGS}
+    -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
+  set(DARWIN_osx_BUILTIN_MIN_VER 10.5)
+  set(DARWIN_osx_BUILTIN_MIN_VER_FLAG
+      -mmacosx-version-min=${DARWIN_osx_BUILTIN_MIN_VER})
+
+  if(DARWIN_osx_SYSROOT)
+    list(APPEND DARWIN_osx_CFLAGS -isysroot ${DARWIN_osx_SYSROOT})
+    list(APPEND DARWIN_osx_LINKFLAGS -isysroot ${DARWIN_osx_SYSROOT})
+  endif()
+
+  # Figure out which arches to use for each OS
+  darwin_get_toolchain_supported_archs(toolchain_arches)
+  message(STATUS "Toolchain supported arches: ${toolchain_arches}")
+  
+  if(NOT MACOSX_VERSION_MIN_FLAG)
+    darwin_test_archs(osx
+      DARWIN_osx_ARCHS
+      ${toolchain_arches})
+    message(STATUS "OSX supported arches: ${DARWIN_osx_ARCHS}")
+    foreach(arch ${DARWIN_osx_ARCHS})
+      list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+      set(CAN_TARGET_${arch} 1)
+    endforeach()
+
+    # Need to build a 10.4 compatible libclang_rt
+    set(DARWIN_10.4_SYSROOT ${DARWIN_osx_SYSROOT})
+    set(DARWIN_10.4_BUILTIN_MIN_VER 10.4)
+    set(DARWIN_10.4_BUILTIN_MIN_VER_FLAG
+        -mmacosx-version-min=${DARWIN_10.4_BUILTIN_MIN_VER})
+    set(DARWIN_10.4_SKIP_CC_KEXT On)
+    darwin_test_archs(10.4
+      DARWIN_10.4_ARCHS
+      ${toolchain_arches})
+    message(STATUS "OSX 10.4 supported arches: ${DARWIN_10.4_ARCHS}")
+    if(DARWIN_10.4_ARCHS)
+      # don't include the Haswell slice in the 10.4 compatibility library
+      list(REMOVE_ITEM DARWIN_10.4_ARCHS x86_64h)
+      list(APPEND BUILTIN_SUPPORTED_OS 10.4)
+    endif()
+
+    if(DARWIN_iossim_SYSROOT)
+      set(DARWIN_iossim_CFLAGS
+        ${DARWIN_COMMON_CFLAGS}
+        -mios-simulator-version-min=7.0
+        -isysroot ${DARWIN_iossim_SYSROOT})
+      set(DARWIN_iossim_LINKFLAGS
+        ${DARWIN_COMMON_LINKFLAGS}
+        -mios-simulator-version-min=7.0
+        -isysroot ${DARWIN_iossim_SYSROOT})
+      set(DARWIN_iossim_BUILTIN_MIN_VER 6.0)
+      set(DARWIN_iossim_BUILTIN_MIN_VER_FLAG
+        -mios-simulator-version-min=${DARWIN_iossim_BUILTIN_MIN_VER})
+
+      set(DARWIN_iossim_SKIP_CC_KEXT On)
+      darwin_test_archs(iossim
+        DARWIN_iossim_ARCHS
+        ${toolchain_arches})
+      message(STATUS "iOS Simulator supported arches: ${DARWIN_iossim_ARCHS}")
+      if(DARWIN_iossim_ARCHS)
+        list(APPEND SANITIZER_COMMON_SUPPORTED_OS iossim)
+        list(APPEND BUILTIN_SUPPORTED_OS iossim)
+        list(APPEND PROFILE_SUPPORTED_OS iossim)
+      endif()
+      foreach(arch ${DARWIN_iossim_ARCHS})
+        list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+        set(CAN_TARGET_${arch} 1)
+      endforeach()
+    endif()
+
+    if(DARWIN_ios_SYSROOT AND COMPILER_RT_ENABLE_IOS)
+      set(DARWIN_ios_CFLAGS
+        ${DARWIN_COMMON_CFLAGS}
+        -miphoneos-version-min=7.0
+        -isysroot ${DARWIN_ios_SYSROOT})
+      set(DARWIN_ios_LINKFLAGS
+        ${DARWIN_COMMON_LINKFLAGS}
+        -miphoneos-version-min=7.0
+        -isysroot ${DARWIN_ios_SYSROOT})
+      set(DARWIN_ios_BUILTIN_MIN_VER 6.0)
+      set(DARWIN_ios_BUILTIN_MIN_VER_FLAG
+        -miphoneos-version-min=${DARWIN_ios_BUILTIN_MIN_VER})
+
+      darwin_test_archs(ios
+        DARWIN_ios_ARCHS
+        ${toolchain_arches})
+      message(STATUS "iOS supported arches: ${DARWIN_ios_ARCHS}")
+      if(DARWIN_ios_ARCHS)
+        list(APPEND SANITIZER_COMMON_SUPPORTED_OS ios)
+        list(APPEND BUILTIN_SUPPORTED_OS ios)
+        list(APPEND PROFILE_SUPPORTED_OS ios)
+      endif()
+      foreach(arch ${DARWIN_ios_ARCHS})
+        list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+        set(CAN_TARGET_${arch} 1)
+      endforeach()
+    endif()
+  endif()
+
+  # for list_union
+  include(CompilerRTUtils)
+
+  list_union(BUILTIN_SUPPORTED_ARCH ALL_BUILTIN_SUPPORTED_ARCH toolchain_arches)
+
+  list_union(SANITIZER_COMMON_SUPPORTED_ARCH
+    ALL_SANITIZER_COMMON_SUPPORTED_ARCH
+    COMPILER_RT_SUPPORTED_ARCH
+    )
+  set(LSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
+  set(UBSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
+  list_union(ASAN_SUPPORTED_ARCH
+    ALL_ASAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(DFSAN_SUPPORTED_ARCH
+    ALL_DFSAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(LSAN_SUPPORTED_ARCH
+    ALL_LSAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(MSAN_SUPPORTED_ARCH
+    ALL_MSAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(PROFILE_SUPPORTED_ARCH
+    ALL_PROFILE_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(TSAN_SUPPORTED_ARCH
+    ALL_TSAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(UBSAN_SUPPORTED_ARCH
+    ALL_UBSAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(SAFESTACK_SUPPORTED_ARCH
+    ALL_SAFESTACK_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_union(CFI_SUPPORTED_ARCH
+    ALL_CFI_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
+else()
+  # Architectures supported by compiler-rt libraries.
+  filter_available_targets(BUILTIN_SUPPORTED_ARCH
+    ${ALL_BUILTIN_SUPPORTED_ARCH})
+  filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
+    ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
+  # LSan and UBSan common files should be available on all architectures
+  # supported by other sanitizers (even if they build into dummy object files).
+  filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
+    ${SANITIZER_COMMON_SUPPORTED_ARCH})
+  filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
+    ${SANITIZER_COMMON_SUPPORTED_ARCH})
+  filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
+  filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
+  filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
+  filter_available_targets(MSAN_SUPPORTED_ARCH ${ALL_MSAN_SUPPORTED_ARCH})
+  filter_available_targets(PROFILE_SUPPORTED_ARCH ${ALL_PROFILE_SUPPORTED_ARCH})
+  filter_available_targets(TSAN_SUPPORTED_ARCH ${ALL_TSAN_SUPPORTED_ARCH})
+  filter_available_targets(UBSAN_SUPPORTED_ARCH ${ALL_UBSAN_SUPPORTED_ARCH})
+  filter_available_targets(SAFESTACK_SUPPORTED_ARCH
+    ${ALL_SAFESTACK_SUPPORTED_ARCH})
+  filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH})
+endif()
+
+message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
+
+if(ANDROID)
+  set(OS_NAME "Android")
+else()
+  set(OS_NAME "${CMAKE_SYSTEM_NAME}")
+endif()
+
+if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
+    (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD" OR
+    (OS_NAME MATCHES "Windows" AND MSVC)))
+  set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
+else()
+  set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND
+    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
+  set(COMPILER_RT_HAS_INTERCEPTION TRUE)
+else()
+  set(COMPILER_RT_HAS_INTERCEPTION FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND
+    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
+  set(COMPILER_RT_HAS_ASAN TRUE)
+else()
+  set(COMPILER_RT_HAS_ASAN FALSE)
+endif()
+
+if (OS_NAME MATCHES "Linux|FreeBSD|Windows")
+  set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
+else()
+  set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
+endif()
+
+# TODO: Add builtins support.
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Linux")
+  set(COMPILER_RT_HAS_DFSAN TRUE)
+else()
+  set(COMPILER_RT_HAS_DFSAN FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Linux|FreeBSD")
+  set(COMPILER_RT_HAS_LSAN TRUE)
+else()
+  set(COMPILER_RT_HAS_LSAN FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Linux")
+  set(COMPILER_RT_HAS_MSAN TRUE)
+else()
+  set(COMPILER_RT_HAS_MSAN FALSE)
+endif()
+
+if (PROFILE_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD")
+  set(COMPILER_RT_HAS_PROFILE TRUE)
+else()
+  set(COMPILER_RT_HAS_PROFILE FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD")
+  set(COMPILER_RT_HAS_TSAN TRUE)
+else()
+  set(COMPILER_RT_HAS_TSAN FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
+  set(COMPILER_RT_HAS_UBSAN TRUE)
+else()
+  set(COMPILER_RT_HAS_UBSAN FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD")
+  set(COMPILER_RT_HAS_SAFESTACK TRUE)
+else()
+  set(COMPILER_RT_HAS_SAFESTACK FALSE)
+endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Linux")
+  set(COMPILER_RT_HAS_CFI TRUE)
+else()
+  set(COMPILER_RT_HAS_CFI FALSE)
+endif()
diff --git a/compiler-rt/include/CMakeLists.txt b/compiler-rt/include/CMakeLists.txt
new file mode 100644
index 0000000..ad1437e
--- /dev/null
+++ b/compiler-rt/include/CMakeLists.txt
@@ -0,0 +1,32 @@
+set(SANITIZER_HEADERS
+  sanitizer/allocator_interface.h
+  sanitizer/asan_interface.h
+  sanitizer/common_interface_defs.h
+  sanitizer/coverage_interface.h
+  sanitizer/dfsan_interface.h
+  sanitizer/linux_syscall_hooks.h
+  sanitizer/lsan_interface.h
+  sanitizer/msan_interface.h
+  sanitizer/tsan_interface_atomic.h)
+
+set(output_dir ${COMPILER_RT_OUTPUT_DIR}/include)
+
+# Copy compiler-rt headers to the build tree.
+set(out_files)
+foreach( f ${SANITIZER_HEADERS} )
+  set( src ${CMAKE_CURRENT_SOURCE_DIR}/${f} )
+  set( dst ${output_dir}/${f} )
+  add_custom_command(OUTPUT ${dst}
+    DEPENDS ${src}
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+    COMMENT "Copying compiler-rt's ${f}...")
+  list(APPEND out_files ${dst})
+endforeach( f )
+
+add_custom_target(compiler-rt-headers ALL DEPENDS ${out_files})
+add_dependencies(compiler-rt compiler-rt-headers)
+
+# Install sanitizer headers.
+install(FILES ${SANITIZER_HEADERS}
+  PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+  DESTINATION ${COMPILER_RT_INSTALL_PATH}/include/sanitizer)
diff --git a/compiler-rt/include/sanitizer/allocator_interface.h b/compiler-rt/include/sanitizer/allocator_interface.h
new file mode 100644
index 0000000..ab251f8
--- /dev/null
+++ b/compiler-rt/include/sanitizer/allocator_interface.h
@@ -0,0 +1,66 @@
+//===-- allocator_interface.h ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Public interface header for allocator used in sanitizers (ASan/TSan/MSan).
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_ALLOCATOR_INTERFACE_H
+#define SANITIZER_ALLOCATOR_INTERFACE_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  /* Returns the estimated number of bytes that will be reserved by allocator
+     for request of "size" bytes. If allocator can't allocate that much
+     memory, returns the maximal possible allocation size, otherwise returns
+     "size". */
+  size_t __sanitizer_get_estimated_allocated_size(size_t size);
+
+  /* Returns true if p was returned by the allocator and
+     is not yet freed. */
+  int __sanitizer_get_ownership(const volatile void *p);
+
+  /* Returns the number of bytes reserved for the pointer p.
+     Requires (get_ownership(p) == true) or (p == 0). */
+  size_t __sanitizer_get_allocated_size(const volatile void *p);
+
+  /* Number of bytes, allocated and not yet freed by the application. */
+  size_t __sanitizer_get_current_allocated_bytes();
+
+  /* Number of bytes, mmaped by the allocator to fulfill allocation requests.
+     Generally, for request of X bytes, allocator can reserve and add to free
+     lists a large number of chunks of size X to use them for future requests.
+     All these chunks count toward the heap size. Currently, allocator never
+     releases memory to OS (instead, it just puts freed chunks to free
+     lists). */
+  size_t __sanitizer_get_heap_size();
+
+  /* Number of bytes, mmaped by the allocator, which can be used to fulfill
+     allocation requests. When a user program frees memory chunk, it can first
+     fall into quarantine and will count toward __sanitizer_get_free_bytes()
+     later. */
+  size_t __sanitizer_get_free_bytes();
+
+  /* Number of bytes in unmapped pages, that are released to OS. Currently,
+     always returns 0. */
+  size_t __sanitizer_get_unmapped_bytes();
+
+  /* Malloc hooks that may be optionally provided by user.
+     __sanitizer_malloc_hook(ptr, size) is called immediately after
+       allocation of "size" bytes, which returned "ptr".
+     __sanitizer_free_hook(ptr) is called immediately before
+       deallocation of "ptr". */
+  void __sanitizer_malloc_hook(const volatile void *ptr, size_t size);
+  void __sanitizer_free_hook(const volatile void *ptr);
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif
diff --git a/compiler-rt/include/sanitizer/asan_interface.h b/compiler-rt/include/sanitizer/asan_interface.h
new file mode 100644
index 0000000..97ba0ce
--- /dev/null
+++ b/compiler-rt/include/sanitizer/asan_interface.h
@@ -0,0 +1,151 @@
+//===-- sanitizer/asan_interface.h ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer.
+//
+// Public interface header.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_ASAN_INTERFACE_H
+#define SANITIZER_ASAN_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  // Marks memory region [addr, addr+size) as unaddressable.
+  // This memory must be previously allocated by the user program. Accessing
+  // addresses in this region from instrumented code is forbidden until
+  // this region is unpoisoned. This function is not guaranteed to poison
+  // the whole region - it may poison only subregion of [addr, addr+size) due
+  // to ASan alignment restrictions.
+  // Method is NOT thread-safe in the sense that no two threads can
+  // (un)poison memory in the same memory region simultaneously.
+  void __asan_poison_memory_region(void const volatile *addr, size_t size);
+  // Marks memory region [addr, addr+size) as addressable.
+  // This memory must be previously allocated by the user program. Accessing
+  // addresses in this region is allowed until this region is poisoned again.
+  // This function may unpoison a superregion of [addr, addr+size) due to
+  // ASan alignment restrictions.
+  // Method is NOT thread-safe in the sense that no two threads can
+  // (un)poison memory in the same memory region simultaneously.
+  void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+
+// User code should use macros instead of functions.
+#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+#define ASAN_POISON_MEMORY_REGION(addr, size) \
+  __asan_poison_memory_region((addr), (size))
+#define ASAN_UNPOISON_MEMORY_REGION(addr, size) \
+  __asan_unpoison_memory_region((addr), (size))
+#else
+#define ASAN_POISON_MEMORY_REGION(addr, size) \
+  ((void)(addr), (void)(size))
+#define ASAN_UNPOISON_MEMORY_REGION(addr, size) \
+  ((void)(addr), (void)(size))
+#endif
+
+  // Returns 1 if addr is poisoned (i.e. 1-byte read/write access to this
+  // address will result in error report from AddressSanitizer).
+  // Otherwise returns 0.
+  int __asan_address_is_poisoned(void const volatile *addr);
+
+  // If at least one byte in [beg, beg+size) is poisoned, return the address
+  // of the first such byte. Otherwise return 0.
+  void *__asan_region_is_poisoned(void *beg, size_t size);
+
+  // Print the description of addr (useful when debugging in gdb).
+  void __asan_describe_address(void *addr);
+
+  // Useful for calling from a debugger to get information about an ASan error.
+  // Returns 1 if an error has been (or is being) reported, otherwise returns 0.
+  int __asan_report_present();
+
+  // Useful for calling from a debugger to get information about an ASan error.
+  // If an error has been (or is being) reported, the following functions return
+  // the pc, bp, sp, address, access type (0 = read, 1 = write), access size and
+  // bug description (e.g. "heap-use-after-free"). Otherwise they return 0.
+  void *__asan_get_report_pc();
+  void *__asan_get_report_bp();
+  void *__asan_get_report_sp();
+  void *__asan_get_report_address();
+  int __asan_get_report_access_type();
+  size_t __asan_get_report_access_size();
+  const char *__asan_get_report_description();
+
+  // Useful for calling from the debugger to get information about a pointer.
+  // Returns the category of the given pointer as a constant string.
+  // Possible return values are "global", "stack", "stack-fake", "heap",
+  // "heap-invalid", "shadow-low", "shadow-gap", "shadow-high", "unknown".
+  // If global or stack, tries to also return the variable name, address and
+  // size. If heap, tries to return the chunk address and size. 'name' should
+  // point to an allocated buffer of size 'name_size'.
+  const char *__asan_locate_address(void *addr, char *name, size_t name_size,
+                                    void **region_address, size_t *region_size);
+
+  // Useful for calling from the debugger to get the allocation stack trace
+  // and thread ID for a heap address. Stores up to 'size' frames into 'trace',
+  // returns the number of stored frames or 0 on error.
+  size_t __asan_get_alloc_stack(void *addr, void **trace, size_t size,
+                                int *thread_id);
+
+  // Useful for calling from the debugger to get the free stack trace
+  // and thread ID for a heap address. Stores up to 'size' frames into 'trace',
+  // returns the number of stored frames or 0 on error.
+  size_t __asan_get_free_stack(void *addr, void **trace, size_t size,
+                               int *thread_id);
+
+  // Useful for calling from the debugger to get the current shadow memory
+  // mapping.
+  void __asan_get_shadow_mapping(size_t *shadow_scale, size_t *shadow_offset);
+
+  // This is an internal function that is called to report an error.
+  // However it is still a part of the interface because users may want to
+  // set a breakpoint on this function in a debugger.
+  void __asan_report_error(void *pc, void *bp, void *sp,
+                           void *addr, int is_write, size_t access_size);
+
+  // Deprecated. Call __sanitizer_set_death_callback instead.
+  void __asan_set_death_callback(void (*callback)(void));
+
+  void __asan_set_error_report_callback(void (*callback)(const char*));
+
+  // User may provide function that would be called right when ASan detects
+  // an error. This can be used to notice cases when ASan detects an error, but
+  // the program crashes before ASan report is printed.
+  void __asan_on_error();
+
+  // Prints accumulated stats to stderr. Used for debugging.
+  void __asan_print_accumulated_stats();
+
+  // This function may be optionally provided by user and should return
+  // a string containing ASan runtime options. See asan_flags.h for details.
+  const char* __asan_default_options();
+
+  // The following 2 functions facilitate garbage collection in presence of
+  // asan's fake stack.
+
+  // Returns an opaque handler to be used later in __asan_addr_is_in_fake_stack.
+  // Returns NULL if the current thread does not have a fake stack.
+  void *__asan_get_current_fake_stack();
+
+  // If fake_stack is non-NULL and addr belongs to a fake frame in
+  // fake_stack, returns the address on real stack that corresponds to
+  // the fake frame and sets beg/end to the boundaries of this fake frame.
+  // Otherwise returns NULL and does not touch beg/end.
+  // If beg/end are NULL, they are not touched.
+  // This function may be called from a thread other than the owner of
+  // fake_stack, but the owner thread need to be alive.
+  void *__asan_addr_is_in_fake_stack(void *fake_stack, void *addr, void **beg,
+                                     void **end);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // SANITIZER_ASAN_INTERFACE_H
diff --git a/compiler-rt/include/sanitizer/common_interface_defs.h b/compiler-rt/include/sanitizer/common_interface_defs.h
new file mode 100644
index 0000000..b736ed9
--- /dev/null
+++ b/compiler-rt/include/sanitizer/common_interface_defs.h
@@ -0,0 +1,135 @@
+//===-- sanitizer/common_interface_defs.h -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Common part of the public sanitizer interface.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_COMMON_INTERFACE_DEFS_H
+#define SANITIZER_COMMON_INTERFACE_DEFS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+// GCC does not understand __has_feature.
+#if !defined(__has_feature)
+# define __has_feature(x) 0
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  // Arguments for __sanitizer_sandbox_on_notify() below.
+  typedef struct {
+    // Enable sandbox support in sanitizer coverage.
+    int coverage_sandboxed;
+    // File descriptor to write coverage data to. If -1 is passed, a file will
+    // be pre-opened by __sanitizer_sandobx_on_notify(). This field has no
+    // effect if coverage_sandboxed == 0.
+    intptr_t coverage_fd;
+    // If non-zero, split the coverage data into well-formed blocks. This is
+    // useful when coverage_fd is a socket descriptor. Each block will contain
+    // a header, allowing data from multiple processes to be sent over the same
+    // socket.
+    unsigned int coverage_max_block_size;
+  } __sanitizer_sandbox_arguments;
+
+  // Tell the tools to write their reports to "path.<pid>" instead of stderr.
+  void __sanitizer_set_report_path(const char *path);
+
+  // Notify the tools that the sandbox is going to be turned on. The reserved
+  // parameter will be used in the future to hold a structure with functions
+  // that the tools may call to bypass the sandbox.
+  void __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args);
+
+  // This function is called by the tool when it has just finished reporting
+  // an error. 'error_summary' is a one-line string that summarizes
+  // the error message. This function can be overridden by the client.
+  void __sanitizer_report_error_summary(const char *error_summary);
+
+  // Some of the sanitizers (e.g. asan/tsan) may miss bugs that happen
+  // in unaligned loads/stores. In order to find such bugs reliably one needs
+  // to replace plain unaligned loads/stores with these calls.
+  uint16_t __sanitizer_unaligned_load16(const void *p);
+  uint32_t __sanitizer_unaligned_load32(const void *p);
+  uint64_t __sanitizer_unaligned_load64(const void *p);
+  void __sanitizer_unaligned_store16(void *p, uint16_t x);
+  void __sanitizer_unaligned_store32(void *p, uint32_t x);
+  void __sanitizer_unaligned_store64(void *p, uint64_t x);
+
+  // Annotate the current state of a contiguous container, such as
+  // std::vector, std::string or similar.
+  // A contiguous container is a container that keeps all of its elements
+  // in a contiguous region of memory. The container owns the region of memory
+  // [beg, end); the memory [beg, mid) is used to store the current elements
+  // and the memory [mid, end) is reserved for future elements;
+  // beg <= mid <= end. For example, in "std::vector<> v"
+  //   beg = &v[0];
+  //   end = beg + v.capacity() * sizeof(v[0]);
+  //   mid = beg + v.size()     * sizeof(v[0]);
+  //
+  // This annotation tells the Sanitizer tool about the current state of the
+  // container so that the tool can report errors when memory from [mid, end)
+  // is accessed. Insert this annotation into methods like push_back/pop_back.
+  // Supply the old and the new values of mid (old_mid/new_mid).
+  // In the initial state mid == end and so should be the final
+  // state when the container is destroyed or when it reallocates the storage.
+  //
+  // Use with caution and don't use for anything other than vector-like classes.
+  //
+  // For AddressSanitizer, 'beg' should be 8-aligned and 'end' should
+  // be either 8-aligned or it should point to the end of a separate heap-,
+  // stack-, or global- allocated buffer. I.e. the following will not work:
+  //   int64_t x[2];  // 16 bytes, 8-aligned.
+  //   char *beg = (char *)&x[0];
+  //   char *end = beg + 12;  // Not 8 aligned, not the end of the buffer.
+  // This however will work fine:
+  //   int32_t x[3];  // 12 bytes, but 8-aligned under AddressSanitizer.
+  //   char *beg = (char*)&x[0];
+  //   char *end = beg + 12;  // Not 8-aligned, but is the end of the buffer.
+  void __sanitizer_annotate_contiguous_container(const void *beg,
+                                                 const void *end,
+                                                 const void *old_mid,
+                                                 const void *new_mid);
+  // Returns true if the contiguous container [beg, end) is properly poisoned
+  // (e.g. with __sanitizer_annotate_contiguous_container), i.e. if
+  //  - [beg, mid) is addressable,
+  //  - [mid, end) is unaddressable.
+  // Full verification requires O(end-beg) time; this function tries to avoid
+  // such complexity by touching only parts of the container around beg/mid/end.
+  int __sanitizer_verify_contiguous_container(const void *beg, const void *mid,
+                                              const void *end);
+
+  // Similar to __sanitizer_verify_contiguous_container but returns the address
+  // of the first improperly poisoned byte otherwise. Returns null if the area
+  // is poisoned properly.
+  const void *__sanitizer_contiguous_container_find_bad_address(
+      const void *beg, const void *mid, const void *end);
+
+  // Print the stack trace leading to this call. Useful for debugging user code.
+  void __sanitizer_print_stack_trace();
+
+  // Sets the callback to be called right before death on error.
+  // Passing 0 will unset the callback.
+  void __sanitizer_set_death_callback(void (*callback)(void));
+
+  // Interceptor hooks.
+  // Whenever a libc function interceptor is called it checks if the
+  // corresponding weak hook is defined, and it so -- calls it.
+  // The primary use case is data-flow-guided fuzzing, where the fuzzer needs
+  // to know what is being passed to libc functions, e.g. memcmp.
+  // FIXME: implement more hooks.
+  void __sanitizer_weak_hook_memcmp(void *called_pc, const void *s1,
+                                    const void *s2, size_t n);
+  void __sanitizer_weak_hook_strncmp(void *called_pc, const char *s1,
+                                    const char *s2, size_t n);
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // SANITIZER_COMMON_INTERFACE_DEFS_H
diff --git a/compiler-rt/include/sanitizer/coverage_interface.h b/compiler-rt/include/sanitizer/coverage_interface.h
new file mode 100644
index 0000000..b93111b
--- /dev/null
+++ b/compiler-rt/include/sanitizer/coverage_interface.h
@@ -0,0 +1,65 @@
+//===-- sanitizer/coverage_interface.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Public interface for sanitizer coverage.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_COVERAG_INTERFACE_H
+#define SANITIZER_COVERAG_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // Initialize coverage.
+  void __sanitizer_cov_init();
+  // Record and dump coverage info.
+  void __sanitizer_cov_dump();
+  // Open <name>.sancov.packed in the coverage directory and return the file
+  // descriptor. Returns -1 on failure, or if coverage dumping is disabled.
+  // This is intended for use by sandboxing code.
+  intptr_t __sanitizer_maybe_open_cov_file(const char *name);
+  // Get the number of unique covered blocks (or edges).
+  // This can be useful for coverage-directed in-process fuzzers.
+  uintptr_t __sanitizer_get_total_unique_coverage();
+  // Get the number of unique indirect caller-callee pairs.
+  uintptr_t __sanitizer_get_total_unique_caller_callee_pairs();
+
+  // Reset the basic-block (edge) coverage to the initial state.
+  // Useful for in-process fuzzing to start collecting coverage from scratch.
+  // Experimental, will likely not work for multi-threaded process.
+  void __sanitizer_reset_coverage();
+  // Set *data to the array of covered PCs and return the size of that array.
+  // Some of the entries in *data will be zero.
+  uintptr_t __sanitizer_get_coverage_guards(uintptr_t **data);
+
+  // The coverage instrumentation may optionally provide imprecise counters.
+  // Rather than exposing the counter values to the user we instead map
+  // the counters to a bitset.
+  // Every counter is associated with 8 bits in the bitset.
+  // We define 8 value ranges: 1, 2, 3, 4-7, 8-15, 16-31, 32-127, 128+
+  // The i-th bit is set to 1 if the counter value is in the i-th range.
+  // This counter-based coverage implementation is *not* thread-safe.
+
+  // Returns the number of registered coverage counters.
+  uintptr_t __sanitizer_get_number_of_counters();
+  // Updates the counter 'bitset', clears the counters and returns the number of
+  // new bits in 'bitset'.
+  // If 'bitset' is nullptr, only clears the counters.
+  // Otherwise 'bitset' should be at least
+  // __sanitizer_get_number_of_counters bytes long and 8-aligned.
+  uintptr_t
+  __sanitizer_update_counter_bitset_and_clear_counters(uint8_t *bitset);
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // SANITIZER_COVERAG_INTERFACE_H
diff --git a/compiler-rt/include/sanitizer/dfsan_interface.h b/compiler-rt/include/sanitizer/dfsan_interface.h
new file mode 100644
index 0000000..05666f7
--- /dev/null
+++ b/compiler-rt/include/sanitizer/dfsan_interface.h
@@ -0,0 +1,116 @@
+//===-- dfsan_interface.h -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of DataFlowSanitizer.
+//
+// Public interface header.
+//===----------------------------------------------------------------------===//
+#ifndef DFSAN_INTERFACE_H
+#define DFSAN_INTERFACE_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uint16_t dfsan_label;
+
+/// Stores information associated with a specific label identifier.  A label
+/// may be a base label created using dfsan_create_label, with associated
+/// text description and user data, or an automatically created union label,
+/// which represents the union of two label identifiers (which may themselves
+/// be base or union labels).
+struct dfsan_label_info {
+  // Fields for union labels, set to 0 for base labels.
+  dfsan_label l1;
+  dfsan_label l2;
+
+  // Fields for base labels.
+  const char *desc;
+  void *userdata;
+};
+
+/// Signature of the callback argument to dfsan_set_write_callback().
+typedef void (*dfsan_write_callback_t)(int fd, const void *buf, size_t count);
+
+/// Computes the union of \c l1 and \c l2, possibly creating a union label in
+/// the process.
+dfsan_label dfsan_union(dfsan_label l1, dfsan_label l2);
+
+/// Creates and returns a base label with the given description and user data.
+dfsan_label dfsan_create_label(const char *desc, void *userdata);
+
+/// Sets the label for each address in [addr,addr+size) to \c label.
+void dfsan_set_label(dfsan_label label, void *addr, size_t size);
+
+/// Sets the label for each address in [addr,addr+size) to the union of the
+/// current label for that address and \c label.
+void dfsan_add_label(dfsan_label label, void *addr, size_t size);
+
+/// Retrieves the label associated with the given data.
+///
+/// The type of 'data' is arbitrary.  The function accepts a value of any type,
+/// which can be truncated or extended (implicitly or explicitly) as necessary.
+/// The truncation/extension operations will preserve the label of the original
+/// value.
+dfsan_label dfsan_get_label(long data);
+
+/// Retrieves the label associated with the data at the given address.
+dfsan_label dfsan_read_label(const void *addr, size_t size);
+
+/// Retrieves a pointer to the dfsan_label_info struct for the given label.
+const struct dfsan_label_info *dfsan_get_label_info(dfsan_label label);
+
+/// Returns whether the given label label contains the label elem.
+int dfsan_has_label(dfsan_label label, dfsan_label elem);
+
+/// If the given label label contains a label with the description desc, returns
+/// that label, else returns 0.
+dfsan_label dfsan_has_label_with_desc(dfsan_label label, const char *desc);
+
+/// Returns the number of labels allocated.
+size_t dfsan_get_label_count(void);
+
+/// Sets a callback to be invoked on calls to write().  The callback is invoked
+/// before the write is done.  The write is not guaranteed to succeed when the
+/// callback executes.  Pass in NULL to remove any callback.
+void dfsan_set_write_callback(dfsan_write_callback_t labeled_write_callback);
+
+/// Writes the labels currently used by the program to the given file
+/// descriptor. The lines of the output have the following format:
+///
+/// <label> <parent label 1> <parent label 2> <label description if any>
+void dfsan_dump_labels(int fd);
+
+/// Interceptor hooks.
+/// Whenever a dfsan's custom function is called the corresponding
+/// hook is called it non-zero. The hooks should be defined by the user.
+/// The primary use case is taint-guided fuzzing, where the fuzzer
+/// needs to see the parameters of the function and the labels.
+/// FIXME: implement more hooks.
+void dfsan_weak_hook_memcmp(void *caller_pc, const void *s1, const void *s2,
+                            size_t n, dfsan_label s1_label,
+                            dfsan_label s2_label, dfsan_label n_label);
+void dfsan_weak_hook_strncmp(void *caller_pc, const char *s1, const char *s2,
+                             size_t n, dfsan_label s1_label,
+                             dfsan_label s2_label, dfsan_label n_label);
+#ifdef __cplusplus
+}  // extern "C"
+
+template <typename T>
+void dfsan_set_label(dfsan_label label, T &data) {  // NOLINT
+  dfsan_set_label(label, (void *)&data, sizeof(T));
+}
+
+#endif
+
+#endif  // DFSAN_INTERFACE_H
diff --git a/compiler-rt/include/sanitizer/linux_syscall_hooks.h b/compiler-rt/include/sanitizer/linux_syscall_hooks.h
new file mode 100644
index 0000000..89867c1
--- /dev/null
+++ b/compiler-rt/include/sanitizer/linux_syscall_hooks.h
@@ -0,0 +1,3070 @@
+//===-- linux_syscall_hooks.h ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of public sanitizer interface.
+//
+// System call handlers.
+//
+// Interface methods declared in this header implement pre- and post- syscall
+// actions for the active sanitizer.
+// Usage:
+//   __sanitizer_syscall_pre_getfoo(...args...);
+//   long res = syscall(__NR_getfoo, ...args...);
+//   __sanitizer_syscall_post_getfoo(res, ...args...);
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_LINUX_SYSCALL_HOOKS_H
+#define SANITIZER_LINUX_SYSCALL_HOOKS_H
+
+#define __sanitizer_syscall_pre_time(tloc) \
+  __sanitizer_syscall_pre_impl_time((long)(tloc))
+#define __sanitizer_syscall_post_time(res, tloc) \
+  __sanitizer_syscall_post_impl_time(res, (long)(tloc))
+#define __sanitizer_syscall_pre_stime(tptr) \
+  __sanitizer_syscall_pre_impl_stime((long)(tptr))
+#define __sanitizer_syscall_post_stime(res, tptr) \
+  __sanitizer_syscall_post_impl_stime(res, (long)(tptr))
+#define __sanitizer_syscall_pre_gettimeofday(tv, tz) \
+  __sanitizer_syscall_pre_impl_gettimeofday((long)(tv), (long)(tz))
+#define __sanitizer_syscall_post_gettimeofday(res, tv, tz) \
+  __sanitizer_syscall_post_impl_gettimeofday(res, (long)(tv), (long)(tz))
+#define __sanitizer_syscall_pre_settimeofday(tv, tz) \
+  __sanitizer_syscall_pre_impl_settimeofday((long)(tv), (long)(tz))
+#define __sanitizer_syscall_post_settimeofday(res, tv, tz) \
+  __sanitizer_syscall_post_impl_settimeofday(res, (long)(tv), (long)(tz))
+#define __sanitizer_syscall_pre_adjtimex(txc_p) \
+  __sanitizer_syscall_pre_impl_adjtimex((long)(txc_p))
+#define __sanitizer_syscall_post_adjtimex(res, txc_p) \
+  __sanitizer_syscall_post_impl_adjtimex(res, (long)(txc_p))
+#define __sanitizer_syscall_pre_times(tbuf) \
+  __sanitizer_syscall_pre_impl_times((long)(tbuf))
+#define __sanitizer_syscall_post_times(res, tbuf) \
+  __sanitizer_syscall_post_impl_times(res, (long)(tbuf))
+#define __sanitizer_syscall_pre_gettid() __sanitizer_syscall_pre_impl_gettid()
+#define __sanitizer_syscall_post_gettid(res) \
+  __sanitizer_syscall_post_impl_gettid(res)
+#define __sanitizer_syscall_pre_nanosleep(rqtp, rmtp) \
+  __sanitizer_syscall_pre_impl_nanosleep((long)(rqtp), (long)(rmtp))
+#define __sanitizer_syscall_post_nanosleep(res, rqtp, rmtp) \
+  __sanitizer_syscall_post_impl_nanosleep(res, (long)(rqtp), (long)(rmtp))
+#define __sanitizer_syscall_pre_alarm(seconds) \
+  __sanitizer_syscall_pre_impl_alarm((long)(seconds))
+#define __sanitizer_syscall_post_alarm(res, seconds) \
+  __sanitizer_syscall_post_impl_alarm(res, (long)(seconds))
+#define __sanitizer_syscall_pre_getpid() __sanitizer_syscall_pre_impl_getpid()
+#define __sanitizer_syscall_post_getpid(res) \
+  __sanitizer_syscall_post_impl_getpid(res)
+#define __sanitizer_syscall_pre_getppid() __sanitizer_syscall_pre_impl_getppid()
+#define __sanitizer_syscall_post_getppid(res) \
+  __sanitizer_syscall_post_impl_getppid(res)
+#define __sanitizer_syscall_pre_getuid() __sanitizer_syscall_pre_impl_getuid()
+#define __sanitizer_syscall_post_getuid(res) \
+  __sanitizer_syscall_post_impl_getuid(res)
+#define __sanitizer_syscall_pre_geteuid() __sanitizer_syscall_pre_impl_geteuid()
+#define __sanitizer_syscall_post_geteuid(res) \
+  __sanitizer_syscall_post_impl_geteuid(res)
+#define __sanitizer_syscall_pre_getgid() __sanitizer_syscall_pre_impl_getgid()
+#define __sanitizer_syscall_post_getgid(res) \
+  __sanitizer_syscall_post_impl_getgid(res)
+#define __sanitizer_syscall_pre_getegid() __sanitizer_syscall_pre_impl_getegid()
+#define __sanitizer_syscall_post_getegid(res) \
+  __sanitizer_syscall_post_impl_getegid(res)
+#define __sanitizer_syscall_pre_getresuid(ruid, euid, suid)          \
+  __sanitizer_syscall_pre_impl_getresuid((long)(ruid), (long)(euid), \
+                                         (long)(suid))
+#define __sanitizer_syscall_post_getresuid(res, ruid, euid, suid)          \
+  __sanitizer_syscall_post_impl_getresuid(res, (long)(ruid), (long)(euid), \
+                                          (long)(suid))
+#define __sanitizer_syscall_pre_getresgid(rgid, egid, sgid)          \
+  __sanitizer_syscall_pre_impl_getresgid((long)(rgid), (long)(egid), \
+                                         (long)(sgid))
+#define __sanitizer_syscall_post_getresgid(res, rgid, egid, sgid)          \
+  __sanitizer_syscall_post_impl_getresgid(res, (long)(rgid), (long)(egid), \
+                                          (long)(sgid))
+#define __sanitizer_syscall_pre_getpgid(pid) \
+  __sanitizer_syscall_pre_impl_getpgid((long)(pid))
+#define __sanitizer_syscall_post_getpgid(res, pid) \
+  __sanitizer_syscall_post_impl_getpgid(res, (long)(pid))
+#define __sanitizer_syscall_pre_getpgrp() __sanitizer_syscall_pre_impl_getpgrp()
+#define __sanitizer_syscall_post_getpgrp(res) \
+  __sanitizer_syscall_post_impl_getpgrp(res)
+#define __sanitizer_syscall_pre_getsid(pid) \
+  __sanitizer_syscall_pre_impl_getsid((long)(pid))
+#define __sanitizer_syscall_post_getsid(res, pid) \
+  __sanitizer_syscall_post_impl_getsid(res, (long)(pid))
+#define __sanitizer_syscall_pre_getgroups(gidsetsize, grouplist) \
+  __sanitizer_syscall_pre_impl_getgroups((long)(gidsetsize), (long)(grouplist))
+#define __sanitizer_syscall_post_getgroups(res, gidsetsize, grouplist) \
+  __sanitizer_syscall_post_impl_getgroups(res, (long)(gidsetsize),     \
+                                          (long)(grouplist))
+#define __sanitizer_syscall_pre_setregid(rgid, egid) \
+  __sanitizer_syscall_pre_impl_setregid((long)(rgid), (long)(egid))
+#define __sanitizer_syscall_post_setregid(res, rgid, egid) \
+  __sanitizer_syscall_post_impl_setregid(res, (long)(rgid), (long)(egid))
+#define __sanitizer_syscall_pre_setgid(gid) \
+  __sanitizer_syscall_pre_impl_setgid((long)(gid))
+#define __sanitizer_syscall_post_setgid(res, gid) \
+  __sanitizer_syscall_post_impl_setgid(res, (long)(gid))
+#define __sanitizer_syscall_pre_setreuid(ruid, euid) \
+  __sanitizer_syscall_pre_impl_setreuid((long)(ruid), (long)(euid))
+#define __sanitizer_syscall_post_setreuid(res, ruid, euid) \
+  __sanitizer_syscall_post_impl_setreuid(res, (long)(ruid), (long)(euid))
+#define __sanitizer_syscall_pre_setuid(uid) \
+  __sanitizer_syscall_pre_impl_setuid((long)(uid))
+#define __sanitizer_syscall_post_setuid(res, uid) \
+  __sanitizer_syscall_post_impl_setuid(res, (long)(uid))
+#define __sanitizer_syscall_pre_setresuid(ruid, euid, suid)          \
+  __sanitizer_syscall_pre_impl_setresuid((long)(ruid), (long)(euid), \
+                                         (long)(suid))
+#define __sanitizer_syscall_post_setresuid(res, ruid, euid, suid)          \
+  __sanitizer_syscall_post_impl_setresuid(res, (long)(ruid), (long)(euid), \
+                                          (long)(suid))
+#define __sanitizer_syscall_pre_setresgid(rgid, egid, sgid)          \
+  __sanitizer_syscall_pre_impl_setresgid((long)(rgid), (long)(egid), \
+                                         (long)(sgid))
+#define __sanitizer_syscall_post_setresgid(res, rgid, egid, sgid)          \
+  __sanitizer_syscall_post_impl_setresgid(res, (long)(rgid), (long)(egid), \
+                                          (long)(sgid))
+#define __sanitizer_syscall_pre_setfsuid(uid) \
+  __sanitizer_syscall_pre_impl_setfsuid((long)(uid))
+#define __sanitizer_syscall_post_setfsuid(res, uid) \
+  __sanitizer_syscall_post_impl_setfsuid(res, (long)(uid))
+#define __sanitizer_syscall_pre_setfsgid(gid) \
+  __sanitizer_syscall_pre_impl_setfsgid((long)(gid))
+#define __sanitizer_syscall_post_setfsgid(res, gid) \
+  __sanitizer_syscall_post_impl_setfsgid(res, (long)(gid))
+#define __sanitizer_syscall_pre_setpgid(pid, pgid) \
+  __sanitizer_syscall_pre_impl_setpgid((long)(pid), (long)(pgid))
+#define __sanitizer_syscall_post_setpgid(res, pid, pgid) \
+  __sanitizer_syscall_post_impl_setpgid(res, (long)(pid), (long)(pgid))
+#define __sanitizer_syscall_pre_setsid() __sanitizer_syscall_pre_impl_setsid()
+#define __sanitizer_syscall_post_setsid(res) \
+  __sanitizer_syscall_post_impl_setsid(res)
+#define __sanitizer_syscall_pre_setgroups(gidsetsize, grouplist) \
+  __sanitizer_syscall_pre_impl_setgroups((long)(gidsetsize), (long)(grouplist))
+#define __sanitizer_syscall_post_setgroups(res, gidsetsize, grouplist) \
+  __sanitizer_syscall_post_impl_setgroups(res, (long)(gidsetsize),     \
+                                          (long)(grouplist))
+#define __sanitizer_syscall_pre_acct(name) \
+  __sanitizer_syscall_pre_impl_acct((long)(name))
+#define __sanitizer_syscall_post_acct(res, name) \
+  __sanitizer_syscall_post_impl_acct(res, (long)(name))
+#define __sanitizer_syscall_pre_capget(header, dataptr) \
+  __sanitizer_syscall_pre_impl_capget((long)(header), (long)(dataptr))
+#define __sanitizer_syscall_post_capget(res, header, dataptr) \
+  __sanitizer_syscall_post_impl_capget(res, (long)(header), (long)(dataptr))
+#define __sanitizer_syscall_pre_capset(header, data) \
+  __sanitizer_syscall_pre_impl_capset((long)(header), (long)(data))
+#define __sanitizer_syscall_post_capset(res, header, data) \
+  __sanitizer_syscall_post_impl_capset(res, (long)(header), (long)(data))
+#define __sanitizer_syscall_pre_personality(personality) \
+  __sanitizer_syscall_pre_impl_personality((long)(personality))
+#define __sanitizer_syscall_post_personality(res, personality) \
+  __sanitizer_syscall_post_impl_personality(res, (long)(personality))
+#define __sanitizer_syscall_pre_sigpending(set) \
+  __sanitizer_syscall_pre_impl_sigpending((long)(set))
+#define __sanitizer_syscall_post_sigpending(res, set) \
+  __sanitizer_syscall_post_impl_sigpending(res, (long)(set))
+#define __sanitizer_syscall_pre_sigprocmask(how, set, oset)          \
+  __sanitizer_syscall_pre_impl_sigprocmask((long)(how), (long)(set), \
+                                           (long)(oset))
+#define __sanitizer_syscall_post_sigprocmask(res, how, set, oset)          \
+  __sanitizer_syscall_post_impl_sigprocmask(res, (long)(how), (long)(set), \
+                                            (long)(oset))
+#define __sanitizer_syscall_pre_getitimer(which, value) \
+  __sanitizer_syscall_pre_impl_getitimer((long)(which), (long)(value))
+#define __sanitizer_syscall_post_getitimer(res, which, value) \
+  __sanitizer_syscall_post_impl_getitimer(res, (long)(which), (long)(value))
+#define __sanitizer_syscall_pre_setitimer(which, value, ovalue)        \
+  __sanitizer_syscall_pre_impl_setitimer((long)(which), (long)(value), \
+                                         (long)(ovalue))
+#define __sanitizer_syscall_post_setitimer(res, which, value, ovalue)        \
+  __sanitizer_syscall_post_impl_setitimer(res, (long)(which), (long)(value), \
+                                          (long)(ovalue))
+#define __sanitizer_syscall_pre_timer_create(which_clock, timer_event_spec, \
+                                             created_timer_id)              \
+  __sanitizer_syscall_pre_impl_timer_create(                                \
+      (long)(which_clock), (long)(timer_event_spec), (long)(created_timer_id))
+#define __sanitizer_syscall_post_timer_create(                         \
+    res, which_clock, timer_event_spec, created_timer_id)              \
+  __sanitizer_syscall_post_impl_timer_create(res, (long)(which_clock), \
+                                             (long)(timer_event_spec), \
+                                             (long)(created_timer_id))
+#define __sanitizer_syscall_pre_timer_gettime(timer_id, setting) \
+  __sanitizer_syscall_pre_impl_timer_gettime((long)(timer_id), (long)(setting))
+#define __sanitizer_syscall_post_timer_gettime(res, timer_id, setting) \
+  __sanitizer_syscall_post_impl_timer_gettime(res, (long)(timer_id),   \
+                                              (long)(setting))
+#define __sanitizer_syscall_pre_timer_getoverrun(timer_id) \
+  __sanitizer_syscall_pre_impl_timer_getoverrun((long)(timer_id))
+#define __sanitizer_syscall_post_timer_getoverrun(res, timer_id) \
+  __sanitizer_syscall_post_impl_timer_getoverrun(res, (long)(timer_id))
+#define __sanitizer_syscall_pre_timer_settime(timer_id, flags, new_setting,   \
+                                              old_setting)                    \
+  __sanitizer_syscall_pre_impl_timer_settime((long)(timer_id), (long)(flags), \
+                                             (long)(new_setting),             \
+                                             (long)(old_setting))
+#define __sanitizer_syscall_post_timer_settime(res, timer_id, flags,     \
+                                               new_setting, old_setting) \
+  __sanitizer_syscall_post_impl_timer_settime(                           \
+      res, (long)(timer_id), (long)(flags), (long)(new_setting),         \
+      (long)(old_setting))
+#define __sanitizer_syscall_pre_timer_delete(timer_id) \
+  __sanitizer_syscall_pre_impl_timer_delete((long)(timer_id))
+#define __sanitizer_syscall_post_timer_delete(res, timer_id) \
+  __sanitizer_syscall_post_impl_timer_delete(res, (long)(timer_id))
+#define __sanitizer_syscall_pre_clock_settime(which_clock, tp) \
+  __sanitizer_syscall_pre_impl_clock_settime((long)(which_clock), (long)(tp))
+#define __sanitizer_syscall_post_clock_settime(res, which_clock, tp)    \
+  __sanitizer_syscall_post_impl_clock_settime(res, (long)(which_clock), \
+                                              (long)(tp))
+#define __sanitizer_syscall_pre_clock_gettime(which_clock, tp) \
+  __sanitizer_syscall_pre_impl_clock_gettime((long)(which_clock), (long)(tp))
+#define __sanitizer_syscall_post_clock_gettime(res, which_clock, tp)    \
+  __sanitizer_syscall_post_impl_clock_gettime(res, (long)(which_clock), \
+                                              (long)(tp))
+#define __sanitizer_syscall_pre_clock_adjtime(which_clock, tx) \
+  __sanitizer_syscall_pre_impl_clock_adjtime((long)(which_clock), (long)(tx))
+#define __sanitizer_syscall_post_clock_adjtime(res, which_clock, tx)    \
+  __sanitizer_syscall_post_impl_clock_adjtime(res, (long)(which_clock), \
+                                              (long)(tx))
+#define __sanitizer_syscall_pre_clock_getres(which_clock, tp) \
+  __sanitizer_syscall_pre_impl_clock_getres((long)(which_clock), (long)(tp))
+#define __sanitizer_syscall_post_clock_getres(res, which_clock, tp)    \
+  __sanitizer_syscall_post_impl_clock_getres(res, (long)(which_clock), \
+                                             (long)(tp))
+#define __sanitizer_syscall_pre_clock_nanosleep(which_clock, flags, rqtp, \
+                                                rmtp)                     \
+  __sanitizer_syscall_pre_impl_clock_nanosleep(                           \
+      (long)(which_clock), (long)(flags), (long)(rqtp), (long)(rmtp))
+#define __sanitizer_syscall_post_clock_nanosleep(res, which_clock, flags, \
+                                                 rqtp, rmtp)              \
+  __sanitizer_syscall_post_impl_clock_nanosleep(                          \
+      res, (long)(which_clock), (long)(flags), (long)(rqtp), (long)(rmtp))
+#define __sanitizer_syscall_pre_nice(increment) \
+  __sanitizer_syscall_pre_impl_nice((long)(increment))
+#define __sanitizer_syscall_post_nice(res, increment) \
+  __sanitizer_syscall_post_impl_nice(res, (long)(increment))
+#define __sanitizer_syscall_pre_sched_setscheduler(pid, policy, param)         \
+  __sanitizer_syscall_pre_impl_sched_setscheduler((long)(pid), (long)(policy), \
+                                                  (long)(param))
+#define __sanitizer_syscall_post_sched_setscheduler(res, pid, policy, param) \
+  __sanitizer_syscall_post_impl_sched_setscheduler(                          \
+      res, (long)(pid), (long)(policy), (long)(param))
+#define __sanitizer_syscall_pre_sched_setparam(pid, param) \
+  __sanitizer_syscall_pre_impl_sched_setparam((long)(pid), (long)(param))
+#define __sanitizer_syscall_post_sched_setparam(res, pid, param) \
+  __sanitizer_syscall_post_impl_sched_setparam(res, (long)(pid), (long)(param))
+#define __sanitizer_syscall_pre_sched_getscheduler(pid) \
+  __sanitizer_syscall_pre_impl_sched_getscheduler((long)(pid))
+#define __sanitizer_syscall_post_sched_getscheduler(res, pid) \
+  __sanitizer_syscall_post_impl_sched_getscheduler(res, (long)(pid))
+#define __sanitizer_syscall_pre_sched_getparam(pid, param) \
+  __sanitizer_syscall_pre_impl_sched_getparam((long)(pid), (long)(param))
+#define __sanitizer_syscall_post_sched_getparam(res, pid, param) \
+  __sanitizer_syscall_post_impl_sched_getparam(res, (long)(pid), (long)(param))
+#define __sanitizer_syscall_pre_sched_setaffinity(pid, len, user_mask_ptr) \
+  __sanitizer_syscall_pre_impl_sched_setaffinity((long)(pid), (long)(len), \
+                                                 (long)(user_mask_ptr))
+#define __sanitizer_syscall_post_sched_setaffinity(res, pid, len, \
+                                                   user_mask_ptr) \
+  __sanitizer_syscall_post_impl_sched_setaffinity(                \
+      res, (long)(pid), (long)(len), (long)(user_mask_ptr))
+#define __sanitizer_syscall_pre_sched_getaffinity(pid, len, user_mask_ptr) \
+  __sanitizer_syscall_pre_impl_sched_getaffinity((long)(pid), (long)(len), \
+                                                 (long)(user_mask_ptr))
+#define __sanitizer_syscall_post_sched_getaffinity(res, pid, len, \
+                                                   user_mask_ptr) \
+  __sanitizer_syscall_post_impl_sched_getaffinity(                \
+      res, (long)(pid), (long)(len), (long)(user_mask_ptr))
+#define __sanitizer_syscall_pre_sched_yield() \
+  __sanitizer_syscall_pre_impl_sched_yield()
+#define __sanitizer_syscall_post_sched_yield(res) \
+  __sanitizer_syscall_post_impl_sched_yield(res)
+#define __sanitizer_syscall_pre_sched_get_priority_max(policy) \
+  __sanitizer_syscall_pre_impl_sched_get_priority_max((long)(policy))
+#define __sanitizer_syscall_post_sched_get_priority_max(res, policy) \
+  __sanitizer_syscall_post_impl_sched_get_priority_max(res, (long)(policy))
+#define __sanitizer_syscall_pre_sched_get_priority_min(policy) \
+  __sanitizer_syscall_pre_impl_sched_get_priority_min((long)(policy))
+#define __sanitizer_syscall_post_sched_get_priority_min(res, policy) \
+  __sanitizer_syscall_post_impl_sched_get_priority_min(res, (long)(policy))
+#define __sanitizer_syscall_pre_sched_rr_get_interval(pid, interval) \
+  __sanitizer_syscall_pre_impl_sched_rr_get_interval((long)(pid),    \
+                                                     (long)(interval))
+#define __sanitizer_syscall_post_sched_rr_get_interval(res, pid, interval) \
+  __sanitizer_syscall_post_impl_sched_rr_get_interval(res, (long)(pid),    \
+                                                      (long)(interval))
+#define __sanitizer_syscall_pre_setpriority(which, who, niceval)       \
+  __sanitizer_syscall_pre_impl_setpriority((long)(which), (long)(who), \
+                                           (long)(niceval))
+#define __sanitizer_syscall_post_setpriority(res, which, who, niceval)       \
+  __sanitizer_syscall_post_impl_setpriority(res, (long)(which), (long)(who), \
+                                            (long)(niceval))
+#define __sanitizer_syscall_pre_getpriority(which, who) \
+  __sanitizer_syscall_pre_impl_getpriority((long)(which), (long)(who))
+#define __sanitizer_syscall_post_getpriority(res, which, who) \
+  __sanitizer_syscall_post_impl_getpriority(res, (long)(which), (long)(who))
+#define __sanitizer_syscall_pre_shutdown(arg0, arg1) \
+  __sanitizer_syscall_pre_impl_shutdown((long)(arg0), (long)(arg1))
+#define __sanitizer_syscall_post_shutdown(res, arg0, arg1) \
+  __sanitizer_syscall_post_impl_shutdown(res, (long)(arg0), (long)(arg1))
+#define __sanitizer_syscall_pre_reboot(magic1, magic2, cmd, arg)      \
+  __sanitizer_syscall_pre_impl_reboot((long)(magic1), (long)(magic2), \
+                                      (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_post_reboot(res, magic1, magic2, cmd, arg)      \
+  __sanitizer_syscall_post_impl_reboot(res, (long)(magic1), (long)(magic2), \
+                                       (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_pre_restart_syscall() \
+  __sanitizer_syscall_pre_impl_restart_syscall()
+#define __sanitizer_syscall_post_restart_syscall(res) \
+  __sanitizer_syscall_post_impl_restart_syscall(res)
+#define __sanitizer_syscall_pre_kexec_load(entry, nr_segments, segments,      \
+                                           flags)                             \
+  __sanitizer_syscall_pre_impl_kexec_load((long)(entry), (long)(nr_segments), \
+                                          (long)(segments), (long)(flags))
+#define __sanitizer_syscall_post_kexec_load(res, entry, nr_segments, segments, \
+                                            flags)                             \
+  __sanitizer_syscall_post_impl_kexec_load(res, (long)(entry),                 \
+                                           (long)(nr_segments),                \
+                                           (long)(segments), (long)(flags))
+#define __sanitizer_syscall_pre_exit(error_code) \
+  __sanitizer_syscall_pre_impl_exit((long)(error_code))
+#define __sanitizer_syscall_post_exit(res, error_code) \
+  __sanitizer_syscall_post_impl_exit(res, (long)(error_code))
+#define __sanitizer_syscall_pre_exit_group(error_code) \
+  __sanitizer_syscall_pre_impl_exit_group((long)(error_code))
+#define __sanitizer_syscall_post_exit_group(res, error_code) \
+  __sanitizer_syscall_post_impl_exit_group(res, (long)(error_code))
+#define __sanitizer_syscall_pre_wait4(pid, stat_addr, options, ru)   \
+  __sanitizer_syscall_pre_impl_wait4((long)(pid), (long)(stat_addr), \
+                                     (long)(options), (long)(ru))
+#define __sanitizer_syscall_post_wait4(res, pid, stat_addr, options, ru)   \
+  __sanitizer_syscall_post_impl_wait4(res, (long)(pid), (long)(stat_addr), \
+                                      (long)(options), (long)(ru))
+#define __sanitizer_syscall_pre_waitid(which, pid, infop, options, ru) \
+  __sanitizer_syscall_pre_impl_waitid(                                 \
+      (long)(which), (long)(pid), (long)(infop), (long)(options), (long)(ru))
+#define __sanitizer_syscall_post_waitid(res, which, pid, infop, options, ru) \
+  __sanitizer_syscall_post_impl_waitid(res, (long)(which), (long)(pid),      \
+                                       (long)(infop), (long)(options),       \
+                                       (long)(ru))
+#define __sanitizer_syscall_pre_waitpid(pid, stat_addr, options)       \
+  __sanitizer_syscall_pre_impl_waitpid((long)(pid), (long)(stat_addr), \
+                                       (long)(options))
+#define __sanitizer_syscall_post_waitpid(res, pid, stat_addr, options)       \
+  __sanitizer_syscall_post_impl_waitpid(res, (long)(pid), (long)(stat_addr), \
+                                        (long)(options))
+#define __sanitizer_syscall_pre_set_tid_address(tidptr) \
+  __sanitizer_syscall_pre_impl_set_tid_address((long)(tidptr))
+#define __sanitizer_syscall_post_set_tid_address(res, tidptr) \
+  __sanitizer_syscall_post_impl_set_tid_address(res, (long)(tidptr))
+#define __sanitizer_syscall_pre_init_module(umod, len, uargs)         \
+  __sanitizer_syscall_pre_impl_init_module((long)(umod), (long)(len), \
+                                           (long)(uargs))
+#define __sanitizer_syscall_post_init_module(res, umod, len, uargs)         \
+  __sanitizer_syscall_post_impl_init_module(res, (long)(umod), (long)(len), \
+                                            (long)(uargs))
+#define __sanitizer_syscall_pre_delete_module(name_user, flags) \
+  __sanitizer_syscall_pre_impl_delete_module((long)(name_user), (long)(flags))
+#define __sanitizer_syscall_post_delete_module(res, name_user, flags) \
+  __sanitizer_syscall_post_impl_delete_module(res, (long)(name_user), \
+                                              (long)(flags))
+#define __sanitizer_syscall_pre_rt_sigprocmask(how, set, oset, sigsetsize) \
+  __sanitizer_syscall_pre_impl_rt_sigprocmask(                             \
+      (long)(how), (long)(set), (long)(oset), (long)(sigsetsize))
+#define __sanitizer_syscall_post_rt_sigprocmask(res, how, set, oset, \
+                                                sigsetsize)          \
+  __sanitizer_syscall_post_impl_rt_sigprocmask(                      \
+      res, (long)(how), (long)(set), (long)(oset), (long)(sigsetsize))
+#define __sanitizer_syscall_pre_rt_sigpending(set, sigsetsize) \
+  __sanitizer_syscall_pre_impl_rt_sigpending((long)(set), (long)(sigsetsize))
+#define __sanitizer_syscall_post_rt_sigpending(res, set, sigsetsize) \
+  __sanitizer_syscall_post_impl_rt_sigpending(res, (long)(set),      \
+                                              (long)(sigsetsize))
+#define __sanitizer_syscall_pre_rt_sigtimedwait(uthese, uinfo, uts, \
+                                                sigsetsize)         \
+  __sanitizer_syscall_pre_impl_rt_sigtimedwait(                     \
+      (long)(uthese), (long)(uinfo), (long)(uts), (long)(sigsetsize))
+#define __sanitizer_syscall_post_rt_sigtimedwait(res, uthese, uinfo, uts, \
+                                                 sigsetsize)              \
+  __sanitizer_syscall_post_impl_rt_sigtimedwait(                          \
+      res, (long)(uthese), (long)(uinfo), (long)(uts), (long)(sigsetsize))
+#define __sanitizer_syscall_pre_rt_tgsigqueueinfo(tgid, pid, sig, uinfo)    \
+  __sanitizer_syscall_pre_impl_rt_tgsigqueueinfo((long)(tgid), (long)(pid), \
+                                                 (long)(sig), (long)(uinfo))
+#define __sanitizer_syscall_post_rt_tgsigqueueinfo(res, tgid, pid, sig, uinfo) \
+  __sanitizer_syscall_post_impl_rt_tgsigqueueinfo(                             \
+      res, (long)(tgid), (long)(pid), (long)(sig), (long)(uinfo))
+#define __sanitizer_syscall_pre_kill(pid, sig) \
+  __sanitizer_syscall_pre_impl_kill((long)(pid), (long)(sig))
+#define __sanitizer_syscall_post_kill(res, pid, sig) \
+  __sanitizer_syscall_post_impl_kill(res, (long)(pid), (long)(sig))
+#define __sanitizer_syscall_pre_tgkill(tgid, pid, sig) \
+  __sanitizer_syscall_pre_impl_tgkill((long)(tgid), (long)(pid), (long)(sig))
+#define __sanitizer_syscall_post_tgkill(res, tgid, pid, sig)           \
+  __sanitizer_syscall_post_impl_tgkill(res, (long)(tgid), (long)(pid), \
+                                       (long)(sig))
+#define __sanitizer_syscall_pre_tkill(pid, sig) \
+  __sanitizer_syscall_pre_impl_tkill((long)(pid), (long)(sig))
+#define __sanitizer_syscall_post_tkill(res, pid, sig) \
+  __sanitizer_syscall_post_impl_tkill(res, (long)(pid), (long)(sig))
+#define __sanitizer_syscall_pre_rt_sigqueueinfo(pid, sig, uinfo)         \
+  __sanitizer_syscall_pre_impl_rt_sigqueueinfo((long)(pid), (long)(sig), \
+                                               (long)(uinfo))
+#define __sanitizer_syscall_post_rt_sigqueueinfo(res, pid, sig, uinfo)         \
+  __sanitizer_syscall_post_impl_rt_sigqueueinfo(res, (long)(pid), (long)(sig), \
+                                                (long)(uinfo))
+#define __sanitizer_syscall_pre_sgetmask() \
+  __sanitizer_syscall_pre_impl_sgetmask()
+#define __sanitizer_syscall_post_sgetmask(res) \
+  __sanitizer_syscall_post_impl_sgetmask(res)
+#define __sanitizer_syscall_pre_ssetmask(newmask) \
+  __sanitizer_syscall_pre_impl_ssetmask((long)(newmask))
+#define __sanitizer_syscall_post_ssetmask(res, newmask) \
+  __sanitizer_syscall_post_impl_ssetmask(res, (long)(newmask))
+#define __sanitizer_syscall_pre_signal(sig, handler) \
+  __sanitizer_syscall_pre_impl_signal((long)(sig), (long)(handler))
+#define __sanitizer_syscall_post_signal(res, sig, handler) \
+  __sanitizer_syscall_post_impl_signal(res, (long)(sig), (long)(handler))
+#define __sanitizer_syscall_pre_pause() __sanitizer_syscall_pre_impl_pause()
+#define __sanitizer_syscall_post_pause(res) \
+  __sanitizer_syscall_post_impl_pause(res)
+#define __sanitizer_syscall_pre_sync() __sanitizer_syscall_pre_impl_sync()
+#define __sanitizer_syscall_post_sync(res) \
+  __sanitizer_syscall_post_impl_sync(res)
+#define __sanitizer_syscall_pre_fsync(fd) \
+  __sanitizer_syscall_pre_impl_fsync((long)(fd))
+#define __sanitizer_syscall_post_fsync(res, fd) \
+  __sanitizer_syscall_post_impl_fsync(res, (long)(fd))
+#define __sanitizer_syscall_pre_fdatasync(fd) \
+  __sanitizer_syscall_pre_impl_fdatasync((long)(fd))
+#define __sanitizer_syscall_post_fdatasync(res, fd) \
+  __sanitizer_syscall_post_impl_fdatasync(res, (long)(fd))
+#define __sanitizer_syscall_pre_bdflush(func, data) \
+  __sanitizer_syscall_pre_impl_bdflush((long)(func), (long)(data))
+#define __sanitizer_syscall_post_bdflush(res, func, data) \
+  __sanitizer_syscall_post_impl_bdflush(res, (long)(func), (long)(data))
+#define __sanitizer_syscall_pre_mount(dev_name, dir_name, type, flags, data) \
+  __sanitizer_syscall_pre_impl_mount((long)(dev_name), (long)(dir_name),     \
+                                     (long)(type), (long)(flags),            \
+                                     (long)(data))
+#define __sanitizer_syscall_post_mount(res, dev_name, dir_name, type, flags,   \
+                                       data)                                   \
+  __sanitizer_syscall_post_impl_mount(res, (long)(dev_name), (long)(dir_name), \
+                                      (long)(type), (long)(flags),             \
+                                      (long)(data))
+#define __sanitizer_syscall_pre_umount(name, flags) \
+  __sanitizer_syscall_pre_impl_umount((long)(name), (long)(flags))
+#define __sanitizer_syscall_post_umount(res, name, flags) \
+  __sanitizer_syscall_post_impl_umount(res, (long)(name), (long)(flags))
+#define __sanitizer_syscall_pre_oldumount(name) \
+  __sanitizer_syscall_pre_impl_oldumount((long)(name))
+#define __sanitizer_syscall_post_oldumount(res, name) \
+  __sanitizer_syscall_post_impl_oldumount(res, (long)(name))
+#define __sanitizer_syscall_pre_truncate(path, length) \
+  __sanitizer_syscall_pre_impl_truncate((long)(path), (long)(length))
+#define __sanitizer_syscall_post_truncate(res, path, length) \
+  __sanitizer_syscall_post_impl_truncate(res, (long)(path), (long)(length))
+#define __sanitizer_syscall_pre_ftruncate(fd, length) \
+  __sanitizer_syscall_pre_impl_ftruncate((long)(fd), (long)(length))
+#define __sanitizer_syscall_post_ftruncate(res, fd, length) \
+  __sanitizer_syscall_post_impl_ftruncate(res, (long)(fd), (long)(length))
+#define __sanitizer_syscall_pre_stat(filename, statbuf) \
+  __sanitizer_syscall_pre_impl_stat((long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_post_stat(res, filename, statbuf) \
+  __sanitizer_syscall_post_impl_stat(res, (long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_pre_statfs(path, buf) \
+  __sanitizer_syscall_pre_impl_statfs((long)(path), (long)(buf))
+#define __sanitizer_syscall_post_statfs(res, path, buf) \
+  __sanitizer_syscall_post_impl_statfs(res, (long)(path), (long)(buf))
+#define __sanitizer_syscall_pre_statfs64(path, sz, buf) \
+  __sanitizer_syscall_pre_impl_statfs64((long)(path), (long)(sz), (long)(buf))
+#define __sanitizer_syscall_post_statfs64(res, path, sz, buf)           \
+  __sanitizer_syscall_post_impl_statfs64(res, (long)(path), (long)(sz), \
+                                         (long)(buf))
+#define __sanitizer_syscall_pre_fstatfs(fd, buf) \
+  __sanitizer_syscall_pre_impl_fstatfs((long)(fd), (long)(buf))
+#define __sanitizer_syscall_post_fstatfs(res, fd, buf) \
+  __sanitizer_syscall_post_impl_fstatfs(res, (long)(fd), (long)(buf))
+#define __sanitizer_syscall_pre_fstatfs64(fd, sz, buf) \
+  __sanitizer_syscall_pre_impl_fstatfs64((long)(fd), (long)(sz), (long)(buf))
+#define __sanitizer_syscall_post_fstatfs64(res, fd, sz, buf)           \
+  __sanitizer_syscall_post_impl_fstatfs64(res, (long)(fd), (long)(sz), \
+                                          (long)(buf))
+#define __sanitizer_syscall_pre_lstat(filename, statbuf) \
+  __sanitizer_syscall_pre_impl_lstat((long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_post_lstat(res, filename, statbuf) \
+  __sanitizer_syscall_post_impl_lstat(res, (long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_pre_fstat(fd, statbuf) \
+  __sanitizer_syscall_pre_impl_fstat((long)(fd), (long)(statbuf))
+#define __sanitizer_syscall_post_fstat(res, fd, statbuf) \
+  __sanitizer_syscall_post_impl_fstat(res, (long)(fd), (long)(statbuf))
+#define __sanitizer_syscall_pre_newstat(filename, statbuf) \
+  __sanitizer_syscall_pre_impl_newstat((long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_post_newstat(res, filename, statbuf) \
+  __sanitizer_syscall_post_impl_newstat(res, (long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_pre_newlstat(filename, statbuf) \
+  __sanitizer_syscall_pre_impl_newlstat((long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_post_newlstat(res, filename, statbuf) \
+  __sanitizer_syscall_post_impl_newlstat(res, (long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_pre_newfstat(fd, statbuf) \
+  __sanitizer_syscall_pre_impl_newfstat((long)(fd), (long)(statbuf))
+#define __sanitizer_syscall_post_newfstat(res, fd, statbuf) \
+  __sanitizer_syscall_post_impl_newfstat(res, (long)(fd), (long)(statbuf))
+#define __sanitizer_syscall_pre_ustat(dev, ubuf) \
+  __sanitizer_syscall_pre_impl_ustat((long)(dev), (long)(ubuf))
+#define __sanitizer_syscall_post_ustat(res, dev, ubuf) \
+  __sanitizer_syscall_post_impl_ustat(res, (long)(dev), (long)(ubuf))
+#define __sanitizer_syscall_pre_stat64(filename, statbuf) \
+  __sanitizer_syscall_pre_impl_stat64((long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_post_stat64(res, filename, statbuf) \
+  __sanitizer_syscall_post_impl_stat64(res, (long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_pre_fstat64(fd, statbuf) \
+  __sanitizer_syscall_pre_impl_fstat64((long)(fd), (long)(statbuf))
+#define __sanitizer_syscall_post_fstat64(res, fd, statbuf) \
+  __sanitizer_syscall_post_impl_fstat64(res, (long)(fd), (long)(statbuf))
+#define __sanitizer_syscall_pre_lstat64(filename, statbuf) \
+  __sanitizer_syscall_pre_impl_lstat64((long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_post_lstat64(res, filename, statbuf) \
+  __sanitizer_syscall_post_impl_lstat64(res, (long)(filename), (long)(statbuf))
+#define __sanitizer_syscall_pre_setxattr(path, name, value, size, flags) \
+  __sanitizer_syscall_pre_impl_setxattr(                                 \
+      (long)(path), (long)(name), (long)(value), (long)(size), (long)(flags))
+#define __sanitizer_syscall_post_setxattr(res, path, name, value, size, flags) \
+  __sanitizer_syscall_post_impl_setxattr(res, (long)(path), (long)(name),      \
+                                         (long)(value), (long)(size),          \
+                                         (long)(flags))
+#define __sanitizer_syscall_pre_lsetxattr(path, name, value, size, flags) \
+  __sanitizer_syscall_pre_impl_lsetxattr(                                 \
+      (long)(path), (long)(name), (long)(value), (long)(size), (long)(flags))
+#define __sanitizer_syscall_post_lsetxattr(res, path, name, value, size,   \
+                                           flags)                          \
+  __sanitizer_syscall_post_impl_lsetxattr(res, (long)(path), (long)(name), \
+                                          (long)(value), (long)(size),     \
+                                          (long)(flags))
+#define __sanitizer_syscall_pre_fsetxattr(fd, name, value, size, flags) \
+  __sanitizer_syscall_pre_impl_fsetxattr(                               \
+      (long)(fd), (long)(name), (long)(value), (long)(size), (long)(flags))
+#define __sanitizer_syscall_post_fsetxattr(res, fd, name, value, size, flags) \
+  __sanitizer_syscall_post_impl_fsetxattr(res, (long)(fd), (long)(name),      \
+                                          (long)(value), (long)(size),        \
+                                          (long)(flags))
+#define __sanitizer_syscall_pre_getxattr(path, name, value, size)   \
+  __sanitizer_syscall_pre_impl_getxattr((long)(path), (long)(name), \
+                                        (long)(value), (long)(size))
+#define __sanitizer_syscall_post_getxattr(res, path, name, value, size)   \
+  __sanitizer_syscall_post_impl_getxattr(res, (long)(path), (long)(name), \
+                                         (long)(value), (long)(size))
+#define __sanitizer_syscall_pre_lgetxattr(path, name, value, size)   \
+  __sanitizer_syscall_pre_impl_lgetxattr((long)(path), (long)(name), \
+                                         (long)(value), (long)(size))
+#define __sanitizer_syscall_post_lgetxattr(res, path, name, value, size)   \
+  __sanitizer_syscall_post_impl_lgetxattr(res, (long)(path), (long)(name), \
+                                          (long)(value), (long)(size))
+#define __sanitizer_syscall_pre_fgetxattr(fd, name, value, size)   \
+  __sanitizer_syscall_pre_impl_fgetxattr((long)(fd), (long)(name), \
+                                         (long)(value), (long)(size))
+#define __sanitizer_syscall_post_fgetxattr(res, fd, name, value, size)   \
+  __sanitizer_syscall_post_impl_fgetxattr(res, (long)(fd), (long)(name), \
+                                          (long)(value), (long)(size))
+#define __sanitizer_syscall_pre_listxattr(path, list, size)          \
+  __sanitizer_syscall_pre_impl_listxattr((long)(path), (long)(list), \
+                                         (long)(size))
+#define __sanitizer_syscall_post_listxattr(res, path, list, size)          \
+  __sanitizer_syscall_post_impl_listxattr(res, (long)(path), (long)(list), \
+                                          (long)(size))
+#define __sanitizer_syscall_pre_llistxattr(path, list, size)          \
+  __sanitizer_syscall_pre_impl_llistxattr((long)(path), (long)(list), \
+                                          (long)(size))
+#define __sanitizer_syscall_post_llistxattr(res, path, list, size)          \
+  __sanitizer_syscall_post_impl_llistxattr(res, (long)(path), (long)(list), \
+                                           (long)(size))
+#define __sanitizer_syscall_pre_flistxattr(fd, list, size)          \
+  __sanitizer_syscall_pre_impl_flistxattr((long)(fd), (long)(list), \
+                                          (long)(size))
+#define __sanitizer_syscall_post_flistxattr(res, fd, list, size)          \
+  __sanitizer_syscall_post_impl_flistxattr(res, (long)(fd), (long)(list), \
+                                           (long)(size))
+#define __sanitizer_syscall_pre_removexattr(path, name) \
+  __sanitizer_syscall_pre_impl_removexattr((long)(path), (long)(name))
+#define __sanitizer_syscall_post_removexattr(res, path, name) \
+  __sanitizer_syscall_post_impl_removexattr(res, (long)(path), (long)(name))
+#define __sanitizer_syscall_pre_lremovexattr(path, name) \
+  __sanitizer_syscall_pre_impl_lremovexattr((long)(path), (long)(name))
+#define __sanitizer_syscall_post_lremovexattr(res, path, name) \
+  __sanitizer_syscall_post_impl_lremovexattr(res, (long)(path), (long)(name))
+#define __sanitizer_syscall_pre_fremovexattr(fd, name) \
+  __sanitizer_syscall_pre_impl_fremovexattr((long)(fd), (long)(name))
+#define __sanitizer_syscall_post_fremovexattr(res, fd, name) \
+  __sanitizer_syscall_post_impl_fremovexattr(res, (long)(fd), (long)(name))
+#define __sanitizer_syscall_pre_brk(brk) \
+  __sanitizer_syscall_pre_impl_brk((long)(brk))
+#define __sanitizer_syscall_post_brk(res, brk) \
+  __sanitizer_syscall_post_impl_brk(res, (long)(brk))
+#define __sanitizer_syscall_pre_mprotect(start, len, prot)          \
+  __sanitizer_syscall_pre_impl_mprotect((long)(start), (long)(len), \
+                                        (long)(prot))
+#define __sanitizer_syscall_post_mprotect(res, start, len, prot)          \
+  __sanitizer_syscall_post_impl_mprotect(res, (long)(start), (long)(len), \
+                                         (long)(prot))
+#define __sanitizer_syscall_pre_mremap(addr, old_len, new_len, flags, \
+                                       new_addr)                      \
+  __sanitizer_syscall_pre_impl_mremap((long)(addr), (long)(old_len),  \
+                                      (long)(new_len), (long)(flags), \
+                                      (long)(new_addr))
+#define __sanitizer_syscall_post_mremap(res, addr, old_len, new_len, flags, \
+                                        new_addr)                           \
+  __sanitizer_syscall_post_impl_mremap(res, (long)(addr), (long)(old_len),  \
+                                       (long)(new_len), (long)(flags),      \
+                                       (long)(new_addr))
+#define __sanitizer_syscall_pre_remap_file_pages(start, size, prot, pgoff, \
+                                                 flags)                    \
+  __sanitizer_syscall_pre_impl_remap_file_pages(                           \
+      (long)(start), (long)(size), (long)(prot), (long)(pgoff), (long)(flags))
+#define __sanitizer_syscall_post_remap_file_pages(res, start, size, prot,    \
+                                                  pgoff, flags)              \
+  __sanitizer_syscall_post_impl_remap_file_pages(res, (long)(start),         \
+                                                 (long)(size), (long)(prot), \
+                                                 (long)(pgoff), (long)(flags))
+#define __sanitizer_syscall_pre_msync(start, len, flags) \
+  __sanitizer_syscall_pre_impl_msync((long)(start), (long)(len), (long)(flags))
+#define __sanitizer_syscall_post_msync(res, start, len, flags)         \
+  __sanitizer_syscall_post_impl_msync(res, (long)(start), (long)(len), \
+                                      (long)(flags))
+#define __sanitizer_syscall_pre_munmap(addr, len) \
+  __sanitizer_syscall_pre_impl_munmap((long)(addr), (long)(len))
+#define __sanitizer_syscall_post_munmap(res, addr, len) \
+  __sanitizer_syscall_post_impl_munmap(res, (long)(addr), (long)(len))
+#define __sanitizer_syscall_pre_mlock(start, len) \
+  __sanitizer_syscall_pre_impl_mlock((long)(start), (long)(len))
+#define __sanitizer_syscall_post_mlock(res, start, len) \
+  __sanitizer_syscall_post_impl_mlock(res, (long)(start), (long)(len))
+#define __sanitizer_syscall_pre_munlock(start, len) \
+  __sanitizer_syscall_pre_impl_munlock((long)(start), (long)(len))
+#define __sanitizer_syscall_post_munlock(res, start, len) \
+  __sanitizer_syscall_post_impl_munlock(res, (long)(start), (long)(len))
+#define __sanitizer_syscall_pre_mlockall(flags) \
+  __sanitizer_syscall_pre_impl_mlockall((long)(flags))
+#define __sanitizer_syscall_post_mlockall(res, flags) \
+  __sanitizer_syscall_post_impl_mlockall(res, (long)(flags))
+#define __sanitizer_syscall_pre_munlockall() \
+  __sanitizer_syscall_pre_impl_munlockall()
+#define __sanitizer_syscall_post_munlockall(res) \
+  __sanitizer_syscall_post_impl_munlockall(res)
+#define __sanitizer_syscall_pre_madvise(start, len, behavior)      \
+  __sanitizer_syscall_pre_impl_madvise((long)(start), (long)(len), \
+                                       (long)(behavior))
+#define __sanitizer_syscall_post_madvise(res, start, len, behavior)      \
+  __sanitizer_syscall_post_impl_madvise(res, (long)(start), (long)(len), \
+                                        (long)(behavior))
+#define __sanitizer_syscall_pre_mincore(start, len, vec) \
+  __sanitizer_syscall_pre_impl_mincore((long)(start), (long)(len), (long)(vec))
+#define __sanitizer_syscall_post_mincore(res, start, len, vec)           \
+  __sanitizer_syscall_post_impl_mincore(res, (long)(start), (long)(len), \
+                                        (long)(vec))
+#define __sanitizer_syscall_pre_pivot_root(new_root, put_old) \
+  __sanitizer_syscall_pre_impl_pivot_root((long)(new_root), (long)(put_old))
+#define __sanitizer_syscall_post_pivot_root(res, new_root, put_old) \
+  __sanitizer_syscall_post_impl_pivot_root(res, (long)(new_root),   \
+                                           (long)(put_old))
+#define __sanitizer_syscall_pre_chroot(filename) \
+  __sanitizer_syscall_pre_impl_chroot((long)(filename))
+#define __sanitizer_syscall_post_chroot(res, filename) \
+  __sanitizer_syscall_post_impl_chroot(res, (long)(filename))
+#define __sanitizer_syscall_pre_mknod(filename, mode, dev)           \
+  __sanitizer_syscall_pre_impl_mknod((long)(filename), (long)(mode), \
+                                     (long)(dev))
+#define __sanitizer_syscall_post_mknod(res, filename, mode, dev)           \
+  __sanitizer_syscall_post_impl_mknod(res, (long)(filename), (long)(mode), \
+                                      (long)(dev))
+#define __sanitizer_syscall_pre_link(oldname, newname) \
+  __sanitizer_syscall_pre_impl_link((long)(oldname), (long)(newname))
+#define __sanitizer_syscall_post_link(res, oldname, newname) \
+  __sanitizer_syscall_post_impl_link(res, (long)(oldname), (long)(newname))
+#define __sanitizer_syscall_pre_symlink(old, new_) \
+  __sanitizer_syscall_pre_impl_symlink((long)(old), (long)(new_))
+#define __sanitizer_syscall_post_symlink(res, old, new_) \
+  __sanitizer_syscall_post_impl_symlink(res, (long)(old), (long)(new_))
+#define __sanitizer_syscall_pre_unlink(pathname) \
+  __sanitizer_syscall_pre_impl_unlink((long)(pathname))
+#define __sanitizer_syscall_post_unlink(res, pathname) \
+  __sanitizer_syscall_post_impl_unlink(res, (long)(pathname))
+#define __sanitizer_syscall_pre_rename(oldname, newname) \
+  __sanitizer_syscall_pre_impl_rename((long)(oldname), (long)(newname))
+#define __sanitizer_syscall_post_rename(res, oldname, newname) \
+  __sanitizer_syscall_post_impl_rename(res, (long)(oldname), (long)(newname))
+#define __sanitizer_syscall_pre_chmod(filename, mode) \
+  __sanitizer_syscall_pre_impl_chmod((long)(filename), (long)(mode))
+#define __sanitizer_syscall_post_chmod(res, filename, mode) \
+  __sanitizer_syscall_post_impl_chmod(res, (long)(filename), (long)(mode))
+#define __sanitizer_syscall_pre_fchmod(fd, mode) \
+  __sanitizer_syscall_pre_impl_fchmod((long)(fd), (long)(mode))
+#define __sanitizer_syscall_post_fchmod(res, fd, mode) \
+  __sanitizer_syscall_post_impl_fchmod(res, (long)(fd), (long)(mode))
+#define __sanitizer_syscall_pre_fcntl(fd, cmd, arg) \
+  __sanitizer_syscall_pre_impl_fcntl((long)(fd), (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_post_fcntl(res, fd, cmd, arg) \
+  __sanitizer_syscall_post_impl_fcntl(res, (long)(fd), (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_pre_fcntl64(fd, cmd, arg) \
+  __sanitizer_syscall_pre_impl_fcntl64((long)(fd), (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_post_fcntl64(res, fd, cmd, arg)           \
+  __sanitizer_syscall_post_impl_fcntl64(res, (long)(fd), (long)(cmd), \
+                                        (long)(arg))
+#define __sanitizer_syscall_pre_pipe(fildes) \
+  __sanitizer_syscall_pre_impl_pipe((long)(fildes))
+#define __sanitizer_syscall_post_pipe(res, fildes) \
+  __sanitizer_syscall_post_impl_pipe(res, (long)(fildes))
+#define __sanitizer_syscall_pre_pipe2(fildes, flags) \
+  __sanitizer_syscall_pre_impl_pipe2((long)(fildes), (long)(flags))
+#define __sanitizer_syscall_post_pipe2(res, fildes, flags) \
+  __sanitizer_syscall_post_impl_pipe2(res, (long)(fildes), (long)(flags))
+#define __sanitizer_syscall_pre_dup(fildes) \
+  __sanitizer_syscall_pre_impl_dup((long)(fildes))
+#define __sanitizer_syscall_post_dup(res, fildes) \
+  __sanitizer_syscall_post_impl_dup(res, (long)(fildes))
+#define __sanitizer_syscall_pre_dup2(oldfd, newfd) \
+  __sanitizer_syscall_pre_impl_dup2((long)(oldfd), (long)(newfd))
+#define __sanitizer_syscall_post_dup2(res, oldfd, newfd) \
+  __sanitizer_syscall_post_impl_dup2(res, (long)(oldfd), (long)(newfd))
+#define __sanitizer_syscall_pre_dup3(oldfd, newfd, flags) \
+  __sanitizer_syscall_pre_impl_dup3((long)(oldfd), (long)(newfd), (long)(flags))
+#define __sanitizer_syscall_post_dup3(res, oldfd, newfd, flags)         \
+  __sanitizer_syscall_post_impl_dup3(res, (long)(oldfd), (long)(newfd), \
+                                     (long)(flags))
+#define __sanitizer_syscall_pre_ioperm(from, num, on) \
+  __sanitizer_syscall_pre_impl_ioperm((long)(from), (long)(num), (long)(on))
+#define __sanitizer_syscall_post_ioperm(res, from, num, on)            \
+  __sanitizer_syscall_post_impl_ioperm(res, (long)(from), (long)(num), \
+                                       (long)(on))
+#define __sanitizer_syscall_pre_ioctl(fd, cmd, arg) \
+  __sanitizer_syscall_pre_impl_ioctl((long)(fd), (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_post_ioctl(res, fd, cmd, arg) \
+  __sanitizer_syscall_post_impl_ioctl(res, (long)(fd), (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_pre_flock(fd, cmd) \
+  __sanitizer_syscall_pre_impl_flock((long)(fd), (long)(cmd))
+#define __sanitizer_syscall_post_flock(res, fd, cmd) \
+  __sanitizer_syscall_post_impl_flock(res, (long)(fd), (long)(cmd))
+#define __sanitizer_syscall_pre_io_setup(nr_reqs, ctx) \
+  __sanitizer_syscall_pre_impl_io_setup((long)(nr_reqs), (long)(ctx))
+#define __sanitizer_syscall_post_io_setup(res, nr_reqs, ctx) \
+  __sanitizer_syscall_post_impl_io_setup(res, (long)(nr_reqs), (long)(ctx))
+#define __sanitizer_syscall_pre_io_destroy(ctx) \
+  __sanitizer_syscall_pre_impl_io_destroy((long)(ctx))
+#define __sanitizer_syscall_post_io_destroy(res, ctx) \
+  __sanitizer_syscall_post_impl_io_destroy(res, (long)(ctx))
+#define __sanitizer_syscall_pre_io_getevents(ctx_id, min_nr, nr, events,    \
+                                             timeout)                       \
+  __sanitizer_syscall_pre_impl_io_getevents((long)(ctx_id), (long)(min_nr), \
+                                            (long)(nr), (long)(events),     \
+                                            (long)(timeout))
+#define __sanitizer_syscall_post_io_getevents(res, ctx_id, min_nr, nr, events, \
+                                              timeout)                         \
+  __sanitizer_syscall_post_impl_io_getevents(res, (long)(ctx_id),              \
+                                             (long)(min_nr), (long)(nr),       \
+                                             (long)(events), (long)(timeout))
+#define __sanitizer_syscall_pre_io_submit(ctx_id, arg1, arg2)          \
+  __sanitizer_syscall_pre_impl_io_submit((long)(ctx_id), (long)(arg1), \
+                                         (long)(arg2))
+#define __sanitizer_syscall_post_io_submit(res, ctx_id, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_io_submit(res, (long)(ctx_id), (long)(arg1), \
+                                          (long)(arg2))
+#define __sanitizer_syscall_pre_io_cancel(ctx_id, iocb, result)        \
+  __sanitizer_syscall_pre_impl_io_cancel((long)(ctx_id), (long)(iocb), \
+                                         (long)(result))
+#define __sanitizer_syscall_post_io_cancel(res, ctx_id, iocb, result)        \
+  __sanitizer_syscall_post_impl_io_cancel(res, (long)(ctx_id), (long)(iocb), \
+                                          (long)(result))
+#define __sanitizer_syscall_pre_sendfile(out_fd, in_fd, offset, count) \
+  __sanitizer_syscall_pre_impl_sendfile((long)(out_fd), (long)(in_fd), \
+                                        (long)(offset), (long)(count))
+#define __sanitizer_syscall_post_sendfile(res, out_fd, in_fd, offset, count) \
+  __sanitizer_syscall_post_impl_sendfile(res, (long)(out_fd), (long)(in_fd), \
+                                         (long)(offset), (long)(count))
+#define __sanitizer_syscall_pre_sendfile64(out_fd, in_fd, offset, count) \
+  __sanitizer_syscall_pre_impl_sendfile64((long)(out_fd), (long)(in_fd), \
+                                          (long)(offset), (long)(count))
+#define __sanitizer_syscall_post_sendfile64(res, out_fd, in_fd, offset, count) \
+  __sanitizer_syscall_post_impl_sendfile64(res, (long)(out_fd), (long)(in_fd), \
+                                           (long)(offset), (long)(count))
+#define __sanitizer_syscall_pre_readlink(path, buf, bufsiz)        \
+  __sanitizer_syscall_pre_impl_readlink((long)(path), (long)(buf), \
+                                        (long)(bufsiz))
+#define __sanitizer_syscall_post_readlink(res, path, buf, bufsiz)        \
+  __sanitizer_syscall_post_impl_readlink(res, (long)(path), (long)(buf), \
+                                         (long)(bufsiz))
+#define __sanitizer_syscall_pre_creat(pathname, mode) \
+  __sanitizer_syscall_pre_impl_creat((long)(pathname), (long)(mode))
+#define __sanitizer_syscall_post_creat(res, pathname, mode) \
+  __sanitizer_syscall_post_impl_creat(res, (long)(pathname), (long)(mode))
+#define __sanitizer_syscall_pre_open(filename, flags, mode)          \
+  __sanitizer_syscall_pre_impl_open((long)(filename), (long)(flags), \
+                                    (long)(mode))
+#define __sanitizer_syscall_post_open(res, filename, flags, mode)          \
+  __sanitizer_syscall_post_impl_open(res, (long)(filename), (long)(flags), \
+                                     (long)(mode))
+#define __sanitizer_syscall_pre_close(fd) \
+  __sanitizer_syscall_pre_impl_close((long)(fd))
+#define __sanitizer_syscall_post_close(res, fd) \
+  __sanitizer_syscall_post_impl_close(res, (long)(fd))
+#define __sanitizer_syscall_pre_access(filename, mode) \
+  __sanitizer_syscall_pre_impl_access((long)(filename), (long)(mode))
+#define __sanitizer_syscall_post_access(res, filename, mode) \
+  __sanitizer_syscall_post_impl_access(res, (long)(filename), (long)(mode))
+#define __sanitizer_syscall_pre_vhangup() __sanitizer_syscall_pre_impl_vhangup()
+#define __sanitizer_syscall_post_vhangup(res) \
+  __sanitizer_syscall_post_impl_vhangup(res)
+#define __sanitizer_syscall_pre_chown(filename, user, group)         \
+  __sanitizer_syscall_pre_impl_chown((long)(filename), (long)(user), \
+                                     (long)(group))
+#define __sanitizer_syscall_post_chown(res, filename, user, group)         \
+  __sanitizer_syscall_post_impl_chown(res, (long)(filename), (long)(user), \
+                                      (long)(group))
+#define __sanitizer_syscall_pre_lchown(filename, user, group)         \
+  __sanitizer_syscall_pre_impl_lchown((long)(filename), (long)(user), \
+                                      (long)(group))
+#define __sanitizer_syscall_post_lchown(res, filename, user, group)         \
+  __sanitizer_syscall_post_impl_lchown(res, (long)(filename), (long)(user), \
+                                       (long)(group))
+#define __sanitizer_syscall_pre_fchown(fd, user, group) \
+  __sanitizer_syscall_pre_impl_fchown((long)(fd), (long)(user), (long)(group))
+#define __sanitizer_syscall_post_fchown(res, fd, user, group)         \
+  __sanitizer_syscall_post_impl_fchown(res, (long)(fd), (long)(user), \
+                                       (long)(group))
+#define __sanitizer_syscall_pre_chown16(filename, user, group)       \
+  __sanitizer_syscall_pre_impl_chown16((long)(filename), (long)user, \
+                                       (long)group)
+#define __sanitizer_syscall_post_chown16(res, filename, user, group)       \
+  __sanitizer_syscall_post_impl_chown16(res, (long)(filename), (long)user, \
+                                        (long)group)
+#define __sanitizer_syscall_pre_lchown16(filename, user, group)       \
+  __sanitizer_syscall_pre_impl_lchown16((long)(filename), (long)user, \
+                                        (long)group)
+#define __sanitizer_syscall_post_lchown16(res, filename, user, group)       \
+  __sanitizer_syscall_post_impl_lchown16(res, (long)(filename), (long)user, \
+                                         (long)group)
+#define __sanitizer_syscall_pre_fchown16(fd, user, group) \
+  __sanitizer_syscall_pre_impl_fchown16((long)(fd), (long)user, (long)group)
+#define __sanitizer_syscall_post_fchown16(res, fd, user, group)       \
+  __sanitizer_syscall_post_impl_fchown16(res, (long)(fd), (long)user, \
+                                         (long)group)
+#define __sanitizer_syscall_pre_setregid16(rgid, egid) \
+  __sanitizer_syscall_pre_impl_setregid16((long)rgid, (long)egid)
+#define __sanitizer_syscall_post_setregid16(res, rgid, egid) \
+  __sanitizer_syscall_post_impl_setregid16(res, (long)rgid, (long)egid)
+#define __sanitizer_syscall_pre_setgid16(gid) \
+  __sanitizer_syscall_pre_impl_setgid16((long)gid)
+#define __sanitizer_syscall_post_setgid16(res, gid) \
+  __sanitizer_syscall_post_impl_setgid16(res, (long)gid)
+#define __sanitizer_syscall_pre_setreuid16(ruid, euid) \
+  __sanitizer_syscall_pre_impl_setreuid16((long)ruid, (long)euid)
+#define __sanitizer_syscall_post_setreuid16(res, ruid, euid) \
+  __sanitizer_syscall_post_impl_setreuid16(res, (long)ruid, (long)euid)
+#define __sanitizer_syscall_pre_setuid16(uid) \
+  __sanitizer_syscall_pre_impl_setuid16((long)uid)
+#define __sanitizer_syscall_post_setuid16(res, uid) \
+  __sanitizer_syscall_post_impl_setuid16(res, (long)uid)
+#define __sanitizer_syscall_pre_setresuid16(ruid, euid, suid) \
+  __sanitizer_syscall_pre_impl_setresuid16((long)ruid, (long)euid, (long)suid)
+#define __sanitizer_syscall_post_setresuid16(res, ruid, euid, suid)      \
+  __sanitizer_syscall_post_impl_setresuid16(res, (long)ruid, (long)euid, \
+                                            (long)suid)
+#define __sanitizer_syscall_pre_getresuid16(ruid, euid, suid)          \
+  __sanitizer_syscall_pre_impl_getresuid16((long)(ruid), (long)(euid), \
+                                           (long)(suid))
+#define __sanitizer_syscall_post_getresuid16(res, ruid, euid, suid)          \
+  __sanitizer_syscall_post_impl_getresuid16(res, (long)(ruid), (long)(euid), \
+                                            (long)(suid))
+#define __sanitizer_syscall_pre_setresgid16(rgid, egid, sgid) \
+  __sanitizer_syscall_pre_impl_setresgid16((long)rgid, (long)egid, (long)sgid)
+#define __sanitizer_syscall_post_setresgid16(res, rgid, egid, sgid)      \
+  __sanitizer_syscall_post_impl_setresgid16(res, (long)rgid, (long)egid, \
+                                            (long)sgid)
+#define __sanitizer_syscall_pre_getresgid16(rgid, egid, sgid)          \
+  __sanitizer_syscall_pre_impl_getresgid16((long)(rgid), (long)(egid), \
+                                           (long)(sgid))
+#define __sanitizer_syscall_post_getresgid16(res, rgid, egid, sgid)          \
+  __sanitizer_syscall_post_impl_getresgid16(res, (long)(rgid), (long)(egid), \
+                                            (long)(sgid))
+#define __sanitizer_syscall_pre_setfsuid16(uid) \
+  __sanitizer_syscall_pre_impl_setfsuid16((long)uid)
+#define __sanitizer_syscall_post_setfsuid16(res, uid) \
+  __sanitizer_syscall_post_impl_setfsuid16(res, (long)uid)
+#define __sanitizer_syscall_pre_setfsgid16(gid) \
+  __sanitizer_syscall_pre_impl_setfsgid16((long)gid)
+#define __sanitizer_syscall_post_setfsgid16(res, gid) \
+  __sanitizer_syscall_post_impl_setfsgid16(res, (long)gid)
+#define __sanitizer_syscall_pre_getgroups16(gidsetsize, grouplist) \
+  __sanitizer_syscall_pre_impl_getgroups16((long)(gidsetsize),     \
+                                           (long)(grouplist))
+#define __sanitizer_syscall_post_getgroups16(res, gidsetsize, grouplist) \
+  __sanitizer_syscall_post_impl_getgroups16(res, (long)(gidsetsize),     \
+                                            (long)(grouplist))
+#define __sanitizer_syscall_pre_setgroups16(gidsetsize, grouplist) \
+  __sanitizer_syscall_pre_impl_setgroups16((long)(gidsetsize),     \
+                                           (long)(grouplist))
+#define __sanitizer_syscall_post_setgroups16(res, gidsetsize, grouplist) \
+  __sanitizer_syscall_post_impl_setgroups16(res, (long)(gidsetsize),     \
+                                            (long)(grouplist))
+#define __sanitizer_syscall_pre_getuid16() \
+  __sanitizer_syscall_pre_impl_getuid16()
+#define __sanitizer_syscall_post_getuid16(res) \
+  __sanitizer_syscall_post_impl_getuid16(res)
+#define __sanitizer_syscall_pre_geteuid16() \
+  __sanitizer_syscall_pre_impl_geteuid16()
+#define __sanitizer_syscall_post_geteuid16(res) \
+  __sanitizer_syscall_post_impl_geteuid16(res)
+#define __sanitizer_syscall_pre_getgid16() \
+  __sanitizer_syscall_pre_impl_getgid16()
+#define __sanitizer_syscall_post_getgid16(res) \
+  __sanitizer_syscall_post_impl_getgid16(res)
+#define __sanitizer_syscall_pre_getegid16() \
+  __sanitizer_syscall_pre_impl_getegid16()
+#define __sanitizer_syscall_post_getegid16(res) \
+  __sanitizer_syscall_post_impl_getegid16(res)
+#define __sanitizer_syscall_pre_utime(filename, times) \
+  __sanitizer_syscall_pre_impl_utime((long)(filename), (long)(times))
+#define __sanitizer_syscall_post_utime(res, filename, times) \
+  __sanitizer_syscall_post_impl_utime(res, (long)(filename), (long)(times))
+#define __sanitizer_syscall_pre_utimes(filename, utimes) \
+  __sanitizer_syscall_pre_impl_utimes((long)(filename), (long)(utimes))
+#define __sanitizer_syscall_post_utimes(res, filename, utimes) \
+  __sanitizer_syscall_post_impl_utimes(res, (long)(filename), (long)(utimes))
+#define __sanitizer_syscall_pre_lseek(fd, offset, origin) \
+  __sanitizer_syscall_pre_impl_lseek((long)(fd), (long)(offset), (long)(origin))
+#define __sanitizer_syscall_post_lseek(res, fd, offset, origin)        \
+  __sanitizer_syscall_post_impl_lseek(res, (long)(fd), (long)(offset), \
+                                      (long)(origin))
+#define __sanitizer_syscall_pre_llseek(fd, offset_high, offset_low, result, \
+                                       origin)                              \
+  __sanitizer_syscall_pre_impl_llseek((long)(fd), (long)(offset_high),      \
+                                      (long)(offset_low), (long)(result),   \
+                                      (long)(origin))
+#define __sanitizer_syscall_post_llseek(res, fd, offset_high, offset_low,    \
+                                        result, origin)                      \
+  __sanitizer_syscall_post_impl_llseek(res, (long)(fd), (long)(offset_high), \
+                                       (long)(offset_low), (long)(result),   \
+                                       (long)(origin))
+#define __sanitizer_syscall_pre_read(fd, buf, count) \
+  __sanitizer_syscall_pre_impl_read((long)(fd), (long)(buf), (long)(count))
+#define __sanitizer_syscall_post_read(res, fd, buf, count)         \
+  __sanitizer_syscall_post_impl_read(res, (long)(fd), (long)(buf), \
+                                     (long)(count))
+#define __sanitizer_syscall_pre_readv(fd, vec, vlen) \
+  __sanitizer_syscall_pre_impl_readv((long)(fd), (long)(vec), (long)(vlen))
+#define __sanitizer_syscall_post_readv(res, fd, vec, vlen)          \
+  __sanitizer_syscall_post_impl_readv(res, (long)(fd), (long)(vec), \
+                                      (long)(vlen))
+#define __sanitizer_syscall_pre_write(fd, buf, count) \
+  __sanitizer_syscall_pre_impl_write((long)(fd), (long)(buf), (long)(count))
+#define __sanitizer_syscall_post_write(res, fd, buf, count)         \
+  __sanitizer_syscall_post_impl_write(res, (long)(fd), (long)(buf), \
+                                      (long)(count))
+#define __sanitizer_syscall_pre_writev(fd, vec, vlen) \
+  __sanitizer_syscall_pre_impl_writev((long)(fd), (long)(vec), (long)(vlen))
+#define __sanitizer_syscall_post_writev(res, fd, vec, vlen)          \
+  __sanitizer_syscall_post_impl_writev(res, (long)(fd), (long)(vec), \
+                                       (long)(vlen))
+
+#ifdef _LP64
+#define __sanitizer_syscall_pre_pread64(fd, buf, count, pos)                   \
+  __sanitizer_syscall_pre_impl_pread64((long)(fd), (long)(buf), (long)(count), \
+                                       (long)(pos))
+#define __sanitizer_syscall_post_pread64(res, fd, buf, count, pos)    \
+  __sanitizer_syscall_post_impl_pread64(res, (long)(fd), (long)(buf), \
+                                        (long)(count), (long)(pos))
+#define __sanitizer_syscall_pre_pwrite64(fd, buf, count, pos)    \
+  __sanitizer_syscall_pre_impl_pwrite64((long)(fd), (long)(buf), \
+                                        (long)(count), (long)(pos))
+#define __sanitizer_syscall_post_pwrite64(res, fd, buf, count, pos)    \
+  __sanitizer_syscall_post_impl_pwrite64(res, (long)(fd), (long)(buf), \
+                                         (long)(count), (long)(pos))
+#else
+#define __sanitizer_syscall_pre_pread64(fd, buf, count, pos0, pos1)            \
+  __sanitizer_syscall_pre_impl_pread64((long)(fd), (long)(buf), (long)(count), \
+                                       (long)(pos0), (long)(pos1))
+#define __sanitizer_syscall_post_pread64(res, fd, buf, count, pos0, pos1) \
+  __sanitizer_syscall_post_impl_pread64(res, (long)(fd), (long)(buf),     \
+                                        (long)(count), (long)(pos0), \
+                                        (long)(pos1))
+#define __sanitizer_syscall_pre_pwrite64(fd, buf, count, pos0, pos1) \
+  __sanitizer_syscall_pre_impl_pwrite64(                             \
+      (long)(fd), (long)(buf), (long)(count), (long)(pos0), (long)(pos1))
+#define __sanitizer_syscall_post_pwrite64(res, fd, buf, count, pos0, pos1) \
+  __sanitizer_syscall_post_impl_pwrite64(                                  \
+      res, (long)(fd), (long)(buf), (long)(count), (long)(pos0), (long)(pos1))
+#endif
+
+#define __sanitizer_syscall_pre_preadv(fd, vec, vlen, pos_l, pos_h)          \
+  __sanitizer_syscall_pre_impl_preadv((long)(fd), (long)(vec), (long)(vlen), \
+                                      (long)(pos_l), (long)(pos_h))
+#define __sanitizer_syscall_post_preadv(res, fd, vec, vlen, pos_l, pos_h) \
+  __sanitizer_syscall_post_impl_preadv(res, (long)(fd), (long)(vec),      \
+                                       (long)(vlen), (long)(pos_l),       \
+                                       (long)(pos_h))
+#define __sanitizer_syscall_pre_pwritev(fd, vec, vlen, pos_l, pos_h)          \
+  __sanitizer_syscall_pre_impl_pwritev((long)(fd), (long)(vec), (long)(vlen), \
+                                       (long)(pos_l), (long)(pos_h))
+#define __sanitizer_syscall_post_pwritev(res, fd, vec, vlen, pos_l, pos_h) \
+  __sanitizer_syscall_post_impl_pwritev(res, (long)(fd), (long)(vec),      \
+                                        (long)(vlen), (long)(pos_l),       \
+                                        (long)(pos_h))
+#define __sanitizer_syscall_pre_getcwd(buf, size) \
+  __sanitizer_syscall_pre_impl_getcwd((long)(buf), (long)(size))
+#define __sanitizer_syscall_post_getcwd(res, buf, size) \
+  __sanitizer_syscall_post_impl_getcwd(res, (long)(buf), (long)(size))
+#define __sanitizer_syscall_pre_mkdir(pathname, mode) \
+  __sanitizer_syscall_pre_impl_mkdir((long)(pathname), (long)(mode))
+#define __sanitizer_syscall_post_mkdir(res, pathname, mode) \
+  __sanitizer_syscall_post_impl_mkdir(res, (long)(pathname), (long)(mode))
+#define __sanitizer_syscall_pre_chdir(filename) \
+  __sanitizer_syscall_pre_impl_chdir((long)(filename))
+#define __sanitizer_syscall_post_chdir(res, filename) \
+  __sanitizer_syscall_post_impl_chdir(res, (long)(filename))
+#define __sanitizer_syscall_pre_fchdir(fd) \
+  __sanitizer_syscall_pre_impl_fchdir((long)(fd))
+#define __sanitizer_syscall_post_fchdir(res, fd) \
+  __sanitizer_syscall_post_impl_fchdir(res, (long)(fd))
+#define __sanitizer_syscall_pre_rmdir(pathname) \
+  __sanitizer_syscall_pre_impl_rmdir((long)(pathname))
+#define __sanitizer_syscall_post_rmdir(res, pathname) \
+  __sanitizer_syscall_post_impl_rmdir(res, (long)(pathname))
+#define __sanitizer_syscall_pre_lookup_dcookie(cookie64, buf, len)           \
+  __sanitizer_syscall_pre_impl_lookup_dcookie((long)(cookie64), (long)(buf), \
+                                              (long)(len))
+#define __sanitizer_syscall_post_lookup_dcookie(res, cookie64, buf, len) \
+  __sanitizer_syscall_post_impl_lookup_dcookie(res, (long)(cookie64),    \
+                                               (long)(buf), (long)(len))
+#define __sanitizer_syscall_pre_quotactl(cmd, special, id, addr)      \
+  __sanitizer_syscall_pre_impl_quotactl((long)(cmd), (long)(special), \
+                                        (long)(id), (long)(addr))
+#define __sanitizer_syscall_post_quotactl(res, cmd, special, id, addr)      \
+  __sanitizer_syscall_post_impl_quotactl(res, (long)(cmd), (long)(special), \
+                                         (long)(id), (long)(addr))
+#define __sanitizer_syscall_pre_getdents(fd, dirent, count)         \
+  __sanitizer_syscall_pre_impl_getdents((long)(fd), (long)(dirent), \
+                                        (long)(count))
+#define __sanitizer_syscall_post_getdents(res, fd, dirent, count)         \
+  __sanitizer_syscall_post_impl_getdents(res, (long)(fd), (long)(dirent), \
+                                         (long)(count))
+#define __sanitizer_syscall_pre_getdents64(fd, dirent, count)         \
+  __sanitizer_syscall_pre_impl_getdents64((long)(fd), (long)(dirent), \
+                                          (long)(count))
+#define __sanitizer_syscall_post_getdents64(res, fd, dirent, count)         \
+  __sanitizer_syscall_post_impl_getdents64(res, (long)(fd), (long)(dirent), \
+                                           (long)(count))
+#define __sanitizer_syscall_pre_setsockopt(fd, level, optname, optval, optlen) \
+  __sanitizer_syscall_pre_impl_setsockopt((long)(fd), (long)(level),           \
+                                          (long)(optname), (long)(optval),     \
+                                          (long)(optlen))
+#define __sanitizer_syscall_post_setsockopt(res, fd, level, optname, optval, \
+                                            optlen)                          \
+  __sanitizer_syscall_post_impl_setsockopt(res, (long)(fd), (long)(level),   \
+                                           (long)(optname), (long)(optval),  \
+                                           (long)(optlen))
+#define __sanitizer_syscall_pre_getsockopt(fd, level, optname, optval, optlen) \
+  __sanitizer_syscall_pre_impl_getsockopt((long)(fd), (long)(level),           \
+                                          (long)(optname), (long)(optval),     \
+                                          (long)(optlen))
+#define __sanitizer_syscall_post_getsockopt(res, fd, level, optname, optval, \
+                                            optlen)                          \
+  __sanitizer_syscall_post_impl_getsockopt(res, (long)(fd), (long)(level),   \
+                                           (long)(optname), (long)(optval),  \
+                                           (long)(optlen))
+#define __sanitizer_syscall_pre_bind(arg0, arg1, arg2) \
+  __sanitizer_syscall_pre_impl_bind((long)(arg0), (long)(arg1), (long)(arg2))
+#define __sanitizer_syscall_post_bind(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_bind(res, (long)(arg0), (long)(arg1), \
+                                     (long)(arg2))
+#define __sanitizer_syscall_pre_connect(arg0, arg1, arg2) \
+  __sanitizer_syscall_pre_impl_connect((long)(arg0), (long)(arg1), (long)(arg2))
+#define __sanitizer_syscall_post_connect(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_connect(res, (long)(arg0), (long)(arg1), \
+                                        (long)(arg2))
+#define __sanitizer_syscall_pre_accept(arg0, arg1, arg2) \
+  __sanitizer_syscall_pre_impl_accept((long)(arg0), (long)(arg1), (long)(arg2))
+#define __sanitizer_syscall_post_accept(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_accept(res, (long)(arg0), (long)(arg1), \
+                                       (long)(arg2))
+#define __sanitizer_syscall_pre_accept4(arg0, arg1, arg2, arg3)    \
+  __sanitizer_syscall_pre_impl_accept4((long)(arg0), (long)(arg1), \
+                                       (long)(arg2), (long)(arg3))
+#define __sanitizer_syscall_post_accept4(res, arg0, arg1, arg2, arg3)    \
+  __sanitizer_syscall_post_impl_accept4(res, (long)(arg0), (long)(arg1), \
+                                        (long)(arg2), (long)(arg3))
+#define __sanitizer_syscall_pre_getsockname(arg0, arg1, arg2)          \
+  __sanitizer_syscall_pre_impl_getsockname((long)(arg0), (long)(arg1), \
+                                           (long)(arg2))
+#define __sanitizer_syscall_post_getsockname(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_getsockname(res, (long)(arg0), (long)(arg1), \
+                                            (long)(arg2))
+#define __sanitizer_syscall_pre_getpeername(arg0, arg1, arg2)          \
+  __sanitizer_syscall_pre_impl_getpeername((long)(arg0), (long)(arg1), \
+                                           (long)(arg2))
+#define __sanitizer_syscall_post_getpeername(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_getpeername(res, (long)(arg0), (long)(arg1), \
+                                            (long)(arg2))
+#define __sanitizer_syscall_pre_send(arg0, arg1, arg2, arg3)                  \
+  __sanitizer_syscall_pre_impl_send((long)(arg0), (long)(arg1), (long)(arg2), \
+                                    (long)(arg3))
+#define __sanitizer_syscall_post_send(res, arg0, arg1, arg2, arg3)    \
+  __sanitizer_syscall_post_impl_send(res, (long)(arg0), (long)(arg1), \
+                                     (long)(arg2), (long)(arg3))
+#define __sanitizer_syscall_pre_sendto(arg0, arg1, arg2, arg3, arg4, arg5) \
+  __sanitizer_syscall_pre_impl_sendto((long)(arg0), (long)(arg1),          \
+                                      (long)(arg2), (long)(arg3),          \
+                                      (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_post_sendto(res, arg0, arg1, arg2, arg3, arg4, \
+                                        arg5)                              \
+  __sanitizer_syscall_post_impl_sendto(res, (long)(arg0), (long)(arg1),    \
+                                       (long)(arg2), (long)(arg3),         \
+                                       (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_pre_sendmsg(fd, msg, flags) \
+  __sanitizer_syscall_pre_impl_sendmsg((long)(fd), (long)(msg), (long)(flags))
+#define __sanitizer_syscall_post_sendmsg(res, fd, msg, flags)         \
+  __sanitizer_syscall_post_impl_sendmsg(res, (long)(fd), (long)(msg), \
+                                        (long)(flags))
+#define __sanitizer_syscall_pre_sendmmsg(fd, msg, vlen, flags)                 \
+  __sanitizer_syscall_pre_impl_sendmmsg((long)(fd), (long)(msg), (long)(vlen), \
+                                        (long)(flags))
+#define __sanitizer_syscall_post_sendmmsg(res, fd, msg, vlen, flags)   \
+  __sanitizer_syscall_post_impl_sendmmsg(res, (long)(fd), (long)(msg), \
+                                         (long)(vlen), (long)(flags))
+#define __sanitizer_syscall_pre_recv(arg0, arg1, arg2, arg3)                  \
+  __sanitizer_syscall_pre_impl_recv((long)(arg0), (long)(arg1), (long)(arg2), \
+                                    (long)(arg3))
+#define __sanitizer_syscall_post_recv(res, arg0, arg1, arg2, arg3)    \
+  __sanitizer_syscall_post_impl_recv(res, (long)(arg0), (long)(arg1), \
+                                     (long)(arg2), (long)(arg3))
+#define __sanitizer_syscall_pre_recvfrom(arg0, arg1, arg2, arg3, arg4, arg5) \
+  __sanitizer_syscall_pre_impl_recvfrom((long)(arg0), (long)(arg1),          \
+                                        (long)(arg2), (long)(arg3),          \
+                                        (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_post_recvfrom(res, arg0, arg1, arg2, arg3, arg4, \
+                                          arg5)                              \
+  __sanitizer_syscall_post_impl_recvfrom(res, (long)(arg0), (long)(arg1),    \
+                                         (long)(arg2), (long)(arg3),         \
+                                         (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_pre_recvmsg(fd, msg, flags) \
+  __sanitizer_syscall_pre_impl_recvmsg((long)(fd), (long)(msg), (long)(flags))
+#define __sanitizer_syscall_post_recvmsg(res, fd, msg, flags)         \
+  __sanitizer_syscall_post_impl_recvmsg(res, (long)(fd), (long)(msg), \
+                                        (long)(flags))
+#define __sanitizer_syscall_pre_recvmmsg(fd, msg, vlen, flags, timeout)        \
+  __sanitizer_syscall_pre_impl_recvmmsg((long)(fd), (long)(msg), (long)(vlen), \
+                                        (long)(flags), (long)(timeout))
+#define __sanitizer_syscall_post_recvmmsg(res, fd, msg, vlen, flags, timeout) \
+  __sanitizer_syscall_post_impl_recvmmsg(res, (long)(fd), (long)(msg),        \
+                                         (long)(vlen), (long)(flags),         \
+                                         (long)(timeout))
+#define __sanitizer_syscall_pre_socket(arg0, arg1, arg2) \
+  __sanitizer_syscall_pre_impl_socket((long)(arg0), (long)(arg1), (long)(arg2))
+#define __sanitizer_syscall_post_socket(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_socket(res, (long)(arg0), (long)(arg1), \
+                                       (long)(arg2))
+#define __sanitizer_syscall_pre_socketpair(arg0, arg1, arg2, arg3)    \
+  __sanitizer_syscall_pre_impl_socketpair((long)(arg0), (long)(arg1), \
+                                          (long)(arg2), (long)(arg3))
+#define __sanitizer_syscall_post_socketpair(res, arg0, arg1, arg2, arg3)    \
+  __sanitizer_syscall_post_impl_socketpair(res, (long)(arg0), (long)(arg1), \
+                                           (long)(arg2), (long)(arg3))
+#define __sanitizer_syscall_pre_socketcall(call, args) \
+  __sanitizer_syscall_pre_impl_socketcall((long)(call), (long)(args))
+#define __sanitizer_syscall_post_socketcall(res, call, args) \
+  __sanitizer_syscall_post_impl_socketcall(res, (long)(call), (long)(args))
+#define __sanitizer_syscall_pre_listen(arg0, arg1) \
+  __sanitizer_syscall_pre_impl_listen((long)(arg0), (long)(arg1))
+#define __sanitizer_syscall_post_listen(res, arg0, arg1) \
+  __sanitizer_syscall_post_impl_listen(res, (long)(arg0), (long)(arg1))
+#define __sanitizer_syscall_pre_poll(ufds, nfds, timeout) \
+  __sanitizer_syscall_pre_impl_poll((long)(ufds), (long)(nfds), (long)(timeout))
+#define __sanitizer_syscall_post_poll(res, ufds, nfds, timeout)       \
+  __sanitizer_syscall_post_impl_poll(res, (long)(ufds), (long)(nfds), \
+                                     (long)(timeout))
+#define __sanitizer_syscall_pre_select(n, inp, outp, exp, tvp)              \
+  __sanitizer_syscall_pre_impl_select((long)(n), (long)(inp), (long)(outp), \
+                                      (long)(exp), (long)(tvp))
+#define __sanitizer_syscall_post_select(res, n, inp, outp, exp, tvp) \
+  __sanitizer_syscall_post_impl_select(res, (long)(n), (long)(inp),  \
+                                       (long)(outp), (long)(exp), (long)(tvp))
+#define __sanitizer_syscall_pre_old_select(arg) \
+  __sanitizer_syscall_pre_impl_old_select((long)(arg))
+#define __sanitizer_syscall_post_old_select(res, arg) \
+  __sanitizer_syscall_post_impl_old_select(res, (long)(arg))
+#define __sanitizer_syscall_pre_epoll_create(size) \
+  __sanitizer_syscall_pre_impl_epoll_create((long)(size))
+#define __sanitizer_syscall_post_epoll_create(res, size) \
+  __sanitizer_syscall_post_impl_epoll_create(res, (long)(size))
+#define __sanitizer_syscall_pre_epoll_create1(flags) \
+  __sanitizer_syscall_pre_impl_epoll_create1((long)(flags))
+#define __sanitizer_syscall_post_epoll_create1(res, flags) \
+  __sanitizer_syscall_post_impl_epoll_create1(res, (long)(flags))
+#define __sanitizer_syscall_pre_epoll_ctl(epfd, op, fd, event)                 \
+  __sanitizer_syscall_pre_impl_epoll_ctl((long)(epfd), (long)(op), (long)(fd), \
+                                         (long)(event))
+#define __sanitizer_syscall_post_epoll_ctl(res, epfd, op, fd, event)     \
+  __sanitizer_syscall_post_impl_epoll_ctl(res, (long)(epfd), (long)(op), \
+                                          (long)(fd), (long)(event))
+#define __sanitizer_syscall_pre_epoll_wait(epfd, events, maxevents, timeout) \
+  __sanitizer_syscall_pre_impl_epoll_wait((long)(epfd), (long)(events),      \
+                                          (long)(maxevents), (long)(timeout))
+#define __sanitizer_syscall_post_epoll_wait(res, epfd, events, maxevents,     \
+                                            timeout)                          \
+  __sanitizer_syscall_post_impl_epoll_wait(res, (long)(epfd), (long)(events), \
+                                           (long)(maxevents), (long)(timeout))
+#define __sanitizer_syscall_pre_epoll_pwait(epfd, events, maxevents, timeout, \
+                                            sigmask, sigsetsize)              \
+  __sanitizer_syscall_pre_impl_epoll_pwait(                                   \
+      (long)(epfd), (long)(events), (long)(maxevents), (long)(timeout),       \
+      (long)(sigmask), (long)(sigsetsize))
+#define __sanitizer_syscall_post_epoll_pwait(res, epfd, events, maxevents,   \
+                                             timeout, sigmask, sigsetsize)   \
+  __sanitizer_syscall_post_impl_epoll_pwait(                                 \
+      res, (long)(epfd), (long)(events), (long)(maxevents), (long)(timeout), \
+      (long)(sigmask), (long)(sigsetsize))
+#define __sanitizer_syscall_pre_gethostname(name, len) \
+  __sanitizer_syscall_pre_impl_gethostname((long)(name), (long)(len))
+#define __sanitizer_syscall_post_gethostname(res, name, len) \
+  __sanitizer_syscall_post_impl_gethostname(res, (long)(name), (long)(len))
+#define __sanitizer_syscall_pre_sethostname(name, len) \
+  __sanitizer_syscall_pre_impl_sethostname((long)(name), (long)(len))
+#define __sanitizer_syscall_post_sethostname(res, name, len) \
+  __sanitizer_syscall_post_impl_sethostname(res, (long)(name), (long)(len))
+#define __sanitizer_syscall_pre_setdomainname(name, len) \
+  __sanitizer_syscall_pre_impl_setdomainname((long)(name), (long)(len))
+#define __sanitizer_syscall_post_setdomainname(res, name, len) \
+  __sanitizer_syscall_post_impl_setdomainname(res, (long)(name), (long)(len))
+#define __sanitizer_syscall_pre_newuname(name) \
+  __sanitizer_syscall_pre_impl_newuname((long)(name))
+#define __sanitizer_syscall_post_newuname(res, name) \
+  __sanitizer_syscall_post_impl_newuname(res, (long)(name))
+#define __sanitizer_syscall_pre_uname(arg0) \
+  __sanitizer_syscall_pre_impl_uname((long)(arg0))
+#define __sanitizer_syscall_post_uname(res, arg0) \
+  __sanitizer_syscall_post_impl_uname(res, (long)(arg0))
+#define __sanitizer_syscall_pre_olduname(arg0) \
+  __sanitizer_syscall_pre_impl_olduname((long)(arg0))
+#define __sanitizer_syscall_post_olduname(res, arg0) \
+  __sanitizer_syscall_post_impl_olduname(res, (long)(arg0))
+#define __sanitizer_syscall_pre_getrlimit(resource, rlim) \
+  __sanitizer_syscall_pre_impl_getrlimit((long)(resource), (long)(rlim))
+#define __sanitizer_syscall_post_getrlimit(res, resource, rlim) \
+  __sanitizer_syscall_post_impl_getrlimit(res, (long)(resource), (long)(rlim))
+#define __sanitizer_syscall_pre_old_getrlimit(resource, rlim) \
+  __sanitizer_syscall_pre_impl_old_getrlimit((long)(resource), (long)(rlim))
+#define __sanitizer_syscall_post_old_getrlimit(res, resource, rlim)  \
+  __sanitizer_syscall_post_impl_old_getrlimit(res, (long)(resource), \
+                                              (long)(rlim))
+#define __sanitizer_syscall_pre_setrlimit(resource, rlim) \
+  __sanitizer_syscall_pre_impl_setrlimit((long)(resource), (long)(rlim))
+#define __sanitizer_syscall_post_setrlimit(res, resource, rlim) \
+  __sanitizer_syscall_post_impl_setrlimit(res, (long)(resource), (long)(rlim))
+#define __sanitizer_syscall_pre_prlimit64(pid, resource, new_rlim, old_rlim) \
+  __sanitizer_syscall_pre_impl_prlimit64((long)(pid), (long)(resource),      \
+                                         (long)(new_rlim), (long)(old_rlim))
+#define __sanitizer_syscall_post_prlimit64(res, pid, resource, new_rlim,      \
+                                           old_rlim)                          \
+  __sanitizer_syscall_post_impl_prlimit64(res, (long)(pid), (long)(resource), \
+                                          (long)(new_rlim), (long)(old_rlim))
+#define __sanitizer_syscall_pre_getrusage(who, ru) \
+  __sanitizer_syscall_pre_impl_getrusage((long)(who), (long)(ru))
+#define __sanitizer_syscall_post_getrusage(res, who, ru) \
+  __sanitizer_syscall_post_impl_getrusage(res, (long)(who), (long)(ru))
+#define __sanitizer_syscall_pre_umask(mask) \
+  __sanitizer_syscall_pre_impl_umask((long)(mask))
+#define __sanitizer_syscall_post_umask(res, mask) \
+  __sanitizer_syscall_post_impl_umask(res, (long)(mask))
+#define __sanitizer_syscall_pre_msgget(key, msgflg) \
+  __sanitizer_syscall_pre_impl_msgget((long)(key), (long)(msgflg))
+#define __sanitizer_syscall_post_msgget(res, key, msgflg) \
+  __sanitizer_syscall_post_impl_msgget(res, (long)(key), (long)(msgflg))
+#define __sanitizer_syscall_pre_msgsnd(msqid, msgp, msgsz, msgflg) \
+  __sanitizer_syscall_pre_impl_msgsnd((long)(msqid), (long)(msgp), \
+                                      (long)(msgsz), (long)(msgflg))
+#define __sanitizer_syscall_post_msgsnd(res, msqid, msgp, msgsz, msgflg) \
+  __sanitizer_syscall_post_impl_msgsnd(res, (long)(msqid), (long)(msgp), \
+                                       (long)(msgsz), (long)(msgflg))
+#define __sanitizer_syscall_pre_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg) \
+  __sanitizer_syscall_pre_impl_msgrcv((long)(msqid), (long)(msgp),         \
+                                      (long)(msgsz), (long)(msgtyp),       \
+                                      (long)(msgflg))
+#define __sanitizer_syscall_post_msgrcv(res, msqid, msgp, msgsz, msgtyp, \
+                                        msgflg)                          \
+  __sanitizer_syscall_post_impl_msgrcv(res, (long)(msqid), (long)(msgp), \
+                                       (long)(msgsz), (long)(msgtyp),    \
+                                       (long)(msgflg))
+#define __sanitizer_syscall_pre_msgctl(msqid, cmd, buf) \
+  __sanitizer_syscall_pre_impl_msgctl((long)(msqid), (long)(cmd), (long)(buf))
+#define __sanitizer_syscall_post_msgctl(res, msqid, cmd, buf)           \
+  __sanitizer_syscall_post_impl_msgctl(res, (long)(msqid), (long)(cmd), \
+                                       (long)(buf))
+#define __sanitizer_syscall_pre_semget(key, nsems, semflg)        \
+  __sanitizer_syscall_pre_impl_semget((long)(key), (long)(nsems), \
+                                      (long)(semflg))
+#define __sanitizer_syscall_post_semget(res, key, nsems, semflg)        \
+  __sanitizer_syscall_post_impl_semget(res, (long)(key), (long)(nsems), \
+                                       (long)(semflg))
+#define __sanitizer_syscall_pre_semop(semid, sops, nsops) \
+  __sanitizer_syscall_pre_impl_semop((long)(semid), (long)(sops), (long)(nsops))
+#define __sanitizer_syscall_post_semop(res, semid, sops, nsops)         \
+  __sanitizer_syscall_post_impl_semop(res, (long)(semid), (long)(sops), \
+                                      (long)(nsops))
+#define __sanitizer_syscall_pre_semctl(semid, semnum, cmd, arg)      \
+  __sanitizer_syscall_pre_impl_semctl((long)(semid), (long)(semnum), \
+                                      (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_post_semctl(res, semid, semnum, cmd, arg)      \
+  __sanitizer_syscall_post_impl_semctl(res, (long)(semid), (long)(semnum), \
+                                       (long)(cmd), (long)(arg))
+#define __sanitizer_syscall_pre_semtimedop(semid, sops, nsops, timeout) \
+  __sanitizer_syscall_pre_impl_semtimedop((long)(semid), (long)(sops),  \
+                                          (long)(nsops), (long)(timeout))
+#define __sanitizer_syscall_post_semtimedop(res, semid, sops, nsops, timeout) \
+  __sanitizer_syscall_post_impl_semtimedop(res, (long)(semid), (long)(sops),  \
+                                           (long)(nsops), (long)(timeout))
+#define __sanitizer_syscall_pre_shmat(shmid, shmaddr, shmflg)        \
+  __sanitizer_syscall_pre_impl_shmat((long)(shmid), (long)(shmaddr), \
+                                     (long)(shmflg))
+#define __sanitizer_syscall_post_shmat(res, shmid, shmaddr, shmflg)        \
+  __sanitizer_syscall_post_impl_shmat(res, (long)(shmid), (long)(shmaddr), \
+                                      (long)(shmflg))
+#define __sanitizer_syscall_pre_shmget(key, size, flag) \
+  __sanitizer_syscall_pre_impl_shmget((long)(key), (long)(size), (long)(flag))
+#define __sanitizer_syscall_post_shmget(res, key, size, flag)          \
+  __sanitizer_syscall_post_impl_shmget(res, (long)(key), (long)(size), \
+                                       (long)(flag))
+#define __sanitizer_syscall_pre_shmdt(shmaddr) \
+  __sanitizer_syscall_pre_impl_shmdt((long)(shmaddr))
+#define __sanitizer_syscall_post_shmdt(res, shmaddr) \
+  __sanitizer_syscall_post_impl_shmdt(res, (long)(shmaddr))
+#define __sanitizer_syscall_pre_shmctl(shmid, cmd, buf) \
+  __sanitizer_syscall_pre_impl_shmctl((long)(shmid), (long)(cmd), (long)(buf))
+#define __sanitizer_syscall_post_shmctl(res, shmid, cmd, buf)           \
+  __sanitizer_syscall_post_impl_shmctl(res, (long)(shmid), (long)(cmd), \
+                                       (long)(buf))
+#define __sanitizer_syscall_pre_ipc(call, first, second, third, ptr, fifth)    \
+  __sanitizer_syscall_pre_impl_ipc((long)(call), (long)(first),                \
+                                   (long)(second), (long)(third), (long)(ptr), \
+                                   (long)(fifth))
+#define __sanitizer_syscall_post_ipc(res, call, first, second, third, ptr, \
+                                     fifth)                                \
+  __sanitizer_syscall_post_impl_ipc(res, (long)(call), (long)(first),      \
+                                    (long)(second), (long)(third),         \
+                                    (long)(ptr), (long)(fifth))
+#define __sanitizer_syscall_pre_mq_open(name, oflag, mode, attr)    \
+  __sanitizer_syscall_pre_impl_mq_open((long)(name), (long)(oflag), \
+                                       (long)(mode), (long)(attr))
+#define __sanitizer_syscall_post_mq_open(res, name, oflag, mode, attr)    \
+  __sanitizer_syscall_post_impl_mq_open(res, (long)(name), (long)(oflag), \
+                                        (long)(mode), (long)(attr))
+#define __sanitizer_syscall_pre_mq_unlink(name) \
+  __sanitizer_syscall_pre_impl_mq_unlink((long)(name))
+#define __sanitizer_syscall_post_mq_unlink(res, name) \
+  __sanitizer_syscall_post_impl_mq_unlink(res, (long)(name))
+#define __sanitizer_syscall_pre_mq_timedsend(mqdes, msg_ptr, msg_len,          \
+                                             msg_prio, abs_timeout)            \
+  __sanitizer_syscall_pre_impl_mq_timedsend((long)(mqdes), (long)(msg_ptr),    \
+                                            (long)(msg_len), (long)(msg_prio), \
+                                            (long)(abs_timeout))
+#define __sanitizer_syscall_post_mq_timedsend(res, mqdes, msg_ptr, msg_len,   \
+                                              msg_prio, abs_timeout)          \
+  __sanitizer_syscall_post_impl_mq_timedsend(                                 \
+      res, (long)(mqdes), (long)(msg_ptr), (long)(msg_len), (long)(msg_prio), \
+      (long)(abs_timeout))
+#define __sanitizer_syscall_pre_mq_timedreceive(mqdes, msg_ptr, msg_len, \
+                                                msg_prio, abs_timeout)   \
+  __sanitizer_syscall_pre_impl_mq_timedreceive(                          \
+      (long)(mqdes), (long)(msg_ptr), (long)(msg_len), (long)(msg_prio), \
+      (long)(abs_timeout))
+#define __sanitizer_syscall_post_mq_timedreceive(res, mqdes, msg_ptr, msg_len, \
+                                                 msg_prio, abs_timeout)        \
+  __sanitizer_syscall_post_impl_mq_timedreceive(                               \
+      res, (long)(mqdes), (long)(msg_ptr), (long)(msg_len), (long)(msg_prio),  \
+      (long)(abs_timeout))
+#define __sanitizer_syscall_pre_mq_notify(mqdes, notification) \
+  __sanitizer_syscall_pre_impl_mq_notify((long)(mqdes), (long)(notification))
+#define __sanitizer_syscall_post_mq_notify(res, mqdes, notification) \
+  __sanitizer_syscall_post_impl_mq_notify(res, (long)(mqdes),        \
+                                          (long)(notification))
+#define __sanitizer_syscall_pre_mq_getsetattr(mqdes, mqstat, omqstat)       \
+  __sanitizer_syscall_pre_impl_mq_getsetattr((long)(mqdes), (long)(mqstat), \
+                                             (long)(omqstat))
+#define __sanitizer_syscall_post_mq_getsetattr(res, mqdes, mqstat, omqstat) \
+  __sanitizer_syscall_post_impl_mq_getsetattr(res, (long)(mqdes),           \
+                                              (long)(mqstat), (long)(omqstat))
+#define __sanitizer_syscall_pre_pciconfig_iobase(which, bus, devfn)         \
+  __sanitizer_syscall_pre_impl_pciconfig_iobase((long)(which), (long)(bus), \
+                                                (long)(devfn))
+#define __sanitizer_syscall_post_pciconfig_iobase(res, which, bus, devfn) \
+  __sanitizer_syscall_post_impl_pciconfig_iobase(res, (long)(which),      \
+                                                 (long)(bus), (long)(devfn))
+#define __sanitizer_syscall_pre_pciconfig_read(bus, dfn, off, len, buf) \
+  __sanitizer_syscall_pre_impl_pciconfig_read(                          \
+      (long)(bus), (long)(dfn), (long)(off), (long)(len), (long)(buf))
+#define __sanitizer_syscall_post_pciconfig_read(res, bus, dfn, off, len, buf) \
+  __sanitizer_syscall_post_impl_pciconfig_read(                               \
+      res, (long)(bus), (long)(dfn), (long)(off), (long)(len), (long)(buf))
+#define __sanitizer_syscall_pre_pciconfig_write(bus, dfn, off, len, buf) \
+  __sanitizer_syscall_pre_impl_pciconfig_write(                          \
+      (long)(bus), (long)(dfn), (long)(off), (long)(len), (long)(buf))
+#define __sanitizer_syscall_post_pciconfig_write(res, bus, dfn, off, len, buf) \
+  __sanitizer_syscall_post_impl_pciconfig_write(                               \
+      res, (long)(bus), (long)(dfn), (long)(off), (long)(len), (long)(buf))
+#define __sanitizer_syscall_pre_swapon(specialfile, swap_flags) \
+  __sanitizer_syscall_pre_impl_swapon((long)(specialfile), (long)(swap_flags))
+#define __sanitizer_syscall_post_swapon(res, specialfile, swap_flags) \
+  __sanitizer_syscall_post_impl_swapon(res, (long)(specialfile),      \
+                                       (long)(swap_flags))
+#define __sanitizer_syscall_pre_swapoff(specialfile) \
+  __sanitizer_syscall_pre_impl_swapoff((long)(specialfile))
+#define __sanitizer_syscall_post_swapoff(res, specialfile) \
+  __sanitizer_syscall_post_impl_swapoff(res, (long)(specialfile))
+#define __sanitizer_syscall_pre_sysctl(args) \
+  __sanitizer_syscall_pre_impl_sysctl((long)(args))
+#define __sanitizer_syscall_post_sysctl(res, args) \
+  __sanitizer_syscall_post_impl_sysctl(res, (long)(args))
+#define __sanitizer_syscall_pre_sysinfo(info) \
+  __sanitizer_syscall_pre_impl_sysinfo((long)(info))
+#define __sanitizer_syscall_post_sysinfo(res, info) \
+  __sanitizer_syscall_post_impl_sysinfo(res, (long)(info))
+#define __sanitizer_syscall_pre_sysfs(option, arg1, arg2) \
+  __sanitizer_syscall_pre_impl_sysfs((long)(option), (long)(arg1), (long)(arg2))
+#define __sanitizer_syscall_post_sysfs(res, option, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_sysfs(res, (long)(option), (long)(arg1), \
+                                      (long)(arg2))
+#define __sanitizer_syscall_pre_syslog(type, buf, len) \
+  __sanitizer_syscall_pre_impl_syslog((long)(type), (long)(buf), (long)(len))
+#define __sanitizer_syscall_post_syslog(res, type, buf, len)           \
+  __sanitizer_syscall_post_impl_syslog(res, (long)(type), (long)(buf), \
+                                       (long)(len))
+#define __sanitizer_syscall_pre_uselib(library) \
+  __sanitizer_syscall_pre_impl_uselib((long)(library))
+#define __sanitizer_syscall_post_uselib(res, library) \
+  __sanitizer_syscall_post_impl_uselib(res, (long)(library))
+#define __sanitizer_syscall_pre_ni_syscall() \
+  __sanitizer_syscall_pre_impl_ni_syscall()
+#define __sanitizer_syscall_post_ni_syscall(res) \
+  __sanitizer_syscall_post_impl_ni_syscall(res)
+#define __sanitizer_syscall_pre_ptrace(request, pid, addr, data)    \
+  __sanitizer_syscall_pre_impl_ptrace((long)(request), (long)(pid), \
+                                      (long)(addr), (long)(data))
+#define __sanitizer_syscall_post_ptrace(res, request, pid, addr, data)    \
+  __sanitizer_syscall_post_impl_ptrace(res, (long)(request), (long)(pid), \
+                                       (long)(addr), (long)(data))
+#define __sanitizer_syscall_pre_add_key(_type, _description, _payload, plen, \
+                                        destringid)                          \
+  __sanitizer_syscall_pre_impl_add_key((long)(_type), (long)(_description),  \
+                                       (long)(_payload), (long)(plen),       \
+                                       (long)(destringid))
+#define __sanitizer_syscall_post_add_key(res, _type, _description, _payload, \
+                                         plen, destringid)                   \
+  __sanitizer_syscall_post_impl_add_key(                                     \
+      res, (long)(_type), (long)(_description), (long)(_payload),            \
+      (long)(plen), (long)(destringid))
+#define __sanitizer_syscall_pre_request_key(_type, _description,       \
+                                            _callout_info, destringid) \
+  __sanitizer_syscall_pre_impl_request_key(                            \
+      (long)(_type), (long)(_description), (long)(_callout_info),      \
+      (long)(destringid))
+#define __sanitizer_syscall_post_request_key(res, _type, _description,  \
+                                             _callout_info, destringid) \
+  __sanitizer_syscall_post_impl_request_key(                            \
+      res, (long)(_type), (long)(_description), (long)(_callout_info),  \
+      (long)(destringid))
+#define __sanitizer_syscall_pre_keyctl(cmd, arg2, arg3, arg4, arg5)            \
+  __sanitizer_syscall_pre_impl_keyctl((long)(cmd), (long)(arg2), (long)(arg3), \
+                                      (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_post_keyctl(res, cmd, arg2, arg3, arg4, arg5) \
+  __sanitizer_syscall_post_impl_keyctl(res, (long)(cmd), (long)(arg2),    \
+                                       (long)(arg3), (long)(arg4),        \
+                                       (long)(arg5))
+#define __sanitizer_syscall_pre_ioprio_set(which, who, ioprio)        \
+  __sanitizer_syscall_pre_impl_ioprio_set((long)(which), (long)(who), \
+                                          (long)(ioprio))
+#define __sanitizer_syscall_post_ioprio_set(res, which, who, ioprio)        \
+  __sanitizer_syscall_post_impl_ioprio_set(res, (long)(which), (long)(who), \
+                                           (long)(ioprio))
+#define __sanitizer_syscall_pre_ioprio_get(which, who) \
+  __sanitizer_syscall_pre_impl_ioprio_get((long)(which), (long)(who))
+#define __sanitizer_syscall_post_ioprio_get(res, which, who) \
+  __sanitizer_syscall_post_impl_ioprio_get(res, (long)(which), (long)(who))
+#define __sanitizer_syscall_pre_set_mempolicy(mode, nmask, maxnode)       \
+  __sanitizer_syscall_pre_impl_set_mempolicy((long)(mode), (long)(nmask), \
+                                             (long)(maxnode))
+#define __sanitizer_syscall_post_set_mempolicy(res, mode, nmask, maxnode) \
+  __sanitizer_syscall_post_impl_set_mempolicy(res, (long)(mode),          \
+                                              (long)(nmask), (long)(maxnode))
+#define __sanitizer_syscall_pre_migrate_pages(pid, maxnode, from, to)      \
+  __sanitizer_syscall_pre_impl_migrate_pages((long)(pid), (long)(maxnode), \
+                                             (long)(from), (long)(to))
+#define __sanitizer_syscall_post_migrate_pages(res, pid, maxnode, from, to) \
+  __sanitizer_syscall_post_impl_migrate_pages(                              \
+      res, (long)(pid), (long)(maxnode), (long)(from), (long)(to))
+#define __sanitizer_syscall_pre_move_pages(pid, nr_pages, pages, nodes,  \
+                                           status, flags)                \
+  __sanitizer_syscall_pre_impl_move_pages((long)(pid), (long)(nr_pages), \
+                                          (long)(pages), (long)(nodes),  \
+                                          (long)(status), (long)(flags))
+#define __sanitizer_syscall_post_move_pages(res, pid, nr_pages, pages, nodes,  \
+                                            status, flags)                     \
+  __sanitizer_syscall_post_impl_move_pages(res, (long)(pid), (long)(nr_pages), \
+                                           (long)(pages), (long)(nodes),       \
+                                           (long)(status), (long)(flags))
+#define __sanitizer_syscall_pre_mbind(start, len, mode, nmask, maxnode, flags) \
+  __sanitizer_syscall_pre_impl_mbind((long)(start), (long)(len), (long)(mode), \
+                                     (long)(nmask), (long)(maxnode),           \
+                                     (long)(flags))
+#define __sanitizer_syscall_post_mbind(res, start, len, mode, nmask, maxnode, \
+                                       flags)                                 \
+  __sanitizer_syscall_post_impl_mbind(res, (long)(start), (long)(len),        \
+                                      (long)(mode), (long)(nmask),            \
+                                      (long)(maxnode), (long)(flags))
+#define __sanitizer_syscall_pre_get_mempolicy(policy, nmask, maxnode, addr, \
+                                              flags)                        \
+  __sanitizer_syscall_pre_impl_get_mempolicy((long)(policy), (long)(nmask), \
+                                             (long)(maxnode), (long)(addr), \
+                                             (long)(flags))
+#define __sanitizer_syscall_post_get_mempolicy(res, policy, nmask, maxnode,   \
+                                               addr, flags)                   \
+  __sanitizer_syscall_post_impl_get_mempolicy(res, (long)(policy),            \
+                                              (long)(nmask), (long)(maxnode), \
+                                              (long)(addr), (long)(flags))
+#define __sanitizer_syscall_pre_inotify_init() \
+  __sanitizer_syscall_pre_impl_inotify_init()
+#define __sanitizer_syscall_post_inotify_init(res) \
+  __sanitizer_syscall_post_impl_inotify_init(res)
+#define __sanitizer_syscall_pre_inotify_init1(flags) \
+  __sanitizer_syscall_pre_impl_inotify_init1((long)(flags))
+#define __sanitizer_syscall_post_inotify_init1(res, flags) \
+  __sanitizer_syscall_post_impl_inotify_init1(res, (long)(flags))
+#define __sanitizer_syscall_pre_inotify_add_watch(fd, path, mask)          \
+  __sanitizer_syscall_pre_impl_inotify_add_watch((long)(fd), (long)(path), \
+                                                 (long)(mask))
+#define __sanitizer_syscall_post_inotify_add_watch(res, fd, path, mask) \
+  __sanitizer_syscall_post_impl_inotify_add_watch(res, (long)(fd),      \
+                                                  (long)(path), (long)(mask))
+#define __sanitizer_syscall_pre_inotify_rm_watch(fd, wd) \
+  __sanitizer_syscall_pre_impl_inotify_rm_watch((long)(fd), (long)(wd))
+#define __sanitizer_syscall_post_inotify_rm_watch(res, fd, wd) \
+  __sanitizer_syscall_post_impl_inotify_rm_watch(res, (long)(fd), (long)(wd))
+#define __sanitizer_syscall_pre_spu_run(fd, unpc, ustatus)       \
+  __sanitizer_syscall_pre_impl_spu_run((long)(fd), (long)(unpc), \
+                                       (long)(ustatus))
+#define __sanitizer_syscall_post_spu_run(res, fd, unpc, ustatus)       \
+  __sanitizer_syscall_post_impl_spu_run(res, (long)(fd), (long)(unpc), \
+                                        (long)(ustatus))
+#define __sanitizer_syscall_pre_spu_create(name, flags, mode, fd)      \
+  __sanitizer_syscall_pre_impl_spu_create((long)(name), (long)(flags), \
+                                          (long)(mode), (long)(fd))
+#define __sanitizer_syscall_post_spu_create(res, name, flags, mode, fd)      \
+  __sanitizer_syscall_post_impl_spu_create(res, (long)(name), (long)(flags), \
+                                           (long)(mode), (long)(fd))
+#define __sanitizer_syscall_pre_mknodat(dfd, filename, mode, dev)     \
+  __sanitizer_syscall_pre_impl_mknodat((long)(dfd), (long)(filename), \
+                                       (long)(mode), (long)(dev))
+#define __sanitizer_syscall_post_mknodat(res, dfd, filename, mode, dev)     \
+  __sanitizer_syscall_post_impl_mknodat(res, (long)(dfd), (long)(filename), \
+                                        (long)(mode), (long)(dev))
+#define __sanitizer_syscall_pre_mkdirat(dfd, pathname, mode)          \
+  __sanitizer_syscall_pre_impl_mkdirat((long)(dfd), (long)(pathname), \
+                                       (long)(mode))
+#define __sanitizer_syscall_post_mkdirat(res, dfd, pathname, mode)          \
+  __sanitizer_syscall_post_impl_mkdirat(res, (long)(dfd), (long)(pathname), \
+                                        (long)(mode))
+#define __sanitizer_syscall_pre_unlinkat(dfd, pathname, flag)          \
+  __sanitizer_syscall_pre_impl_unlinkat((long)(dfd), (long)(pathname), \
+                                        (long)(flag))
+#define __sanitizer_syscall_post_unlinkat(res, dfd, pathname, flag)          \
+  __sanitizer_syscall_post_impl_unlinkat(res, (long)(dfd), (long)(pathname), \
+                                         (long)(flag))
+#define __sanitizer_syscall_pre_symlinkat(oldname, newdfd, newname)       \
+  __sanitizer_syscall_pre_impl_symlinkat((long)(oldname), (long)(newdfd), \
+                                         (long)(newname))
+#define __sanitizer_syscall_post_symlinkat(res, oldname, newdfd, newname) \
+  __sanitizer_syscall_post_impl_symlinkat(res, (long)(oldname),           \
+                                          (long)(newdfd), (long)(newname))
+#define __sanitizer_syscall_pre_linkat(olddfd, oldname, newdfd, newname, \
+                                       flags)                            \
+  __sanitizer_syscall_pre_impl_linkat((long)(olddfd), (long)(oldname),   \
+                                      (long)(newdfd), (long)(newname),   \
+                                      (long)(flags))
+#define __sanitizer_syscall_post_linkat(res, olddfd, oldname, newdfd, newname, \
+                                        flags)                                 \
+  __sanitizer_syscall_post_impl_linkat(res, (long)(olddfd), (long)(oldname),   \
+                                       (long)(newdfd), (long)(newname),        \
+                                       (long)(flags))
+#define __sanitizer_syscall_pre_renameat(olddfd, oldname, newdfd, newname) \
+  __sanitizer_syscall_pre_impl_renameat((long)(olddfd), (long)(oldname),   \
+                                        (long)(newdfd), (long)(newname))
+#define __sanitizer_syscall_post_renameat(res, olddfd, oldname, newdfd,        \
+                                          newname)                             \
+  __sanitizer_syscall_post_impl_renameat(res, (long)(olddfd), (long)(oldname), \
+                                         (long)(newdfd), (long)(newname))
+#define __sanitizer_syscall_pre_futimesat(dfd, filename, utimes)        \
+  __sanitizer_syscall_pre_impl_futimesat((long)(dfd), (long)(filename), \
+                                         (long)(utimes))
+#define __sanitizer_syscall_post_futimesat(res, dfd, filename, utimes)        \
+  __sanitizer_syscall_post_impl_futimesat(res, (long)(dfd), (long)(filename), \
+                                          (long)(utimes))
+#define __sanitizer_syscall_pre_faccessat(dfd, filename, mode)          \
+  __sanitizer_syscall_pre_impl_faccessat((long)(dfd), (long)(filename), \
+                                         (long)(mode))
+#define __sanitizer_syscall_post_faccessat(res, dfd, filename, mode)          \
+  __sanitizer_syscall_post_impl_faccessat(res, (long)(dfd), (long)(filename), \
+                                          (long)(mode))
+#define __sanitizer_syscall_pre_fchmodat(dfd, filename, mode)          \
+  __sanitizer_syscall_pre_impl_fchmodat((long)(dfd), (long)(filename), \
+                                        (long)(mode))
+#define __sanitizer_syscall_post_fchmodat(res, dfd, filename, mode)          \
+  __sanitizer_syscall_post_impl_fchmodat(res, (long)(dfd), (long)(filename), \
+                                         (long)(mode))
+#define __sanitizer_syscall_pre_fchownat(dfd, filename, user, group, flag) \
+  __sanitizer_syscall_pre_impl_fchownat((long)(dfd), (long)(filename),     \
+                                        (long)(user), (long)(group),       \
+                                        (long)(flag))
+#define __sanitizer_syscall_post_fchownat(res, dfd, filename, user, group,   \
+                                          flag)                              \
+  __sanitizer_syscall_post_impl_fchownat(res, (long)(dfd), (long)(filename), \
+                                         (long)(user), (long)(group),        \
+                                         (long)(flag))
+#define __sanitizer_syscall_pre_openat(dfd, filename, flags, mode)   \
+  __sanitizer_syscall_pre_impl_openat((long)(dfd), (long)(filename), \
+                                      (long)(flags), (long)(mode))
+#define __sanitizer_syscall_post_openat(res, dfd, filename, flags, mode)   \
+  __sanitizer_syscall_post_impl_openat(res, (long)(dfd), (long)(filename), \
+                                       (long)(flags), (long)(mode))
+#define __sanitizer_syscall_pre_newfstatat(dfd, filename, statbuf, flag) \
+  __sanitizer_syscall_pre_impl_newfstatat((long)(dfd), (long)(filename), \
+                                          (long)(statbuf), (long)(flag))
+#define __sanitizer_syscall_post_newfstatat(res, dfd, filename, statbuf, flag) \
+  __sanitizer_syscall_post_impl_newfstatat(res, (long)(dfd), (long)(filename), \
+                                           (long)(statbuf), (long)(flag))
+#define __sanitizer_syscall_pre_fstatat64(dfd, filename, statbuf, flag) \
+  __sanitizer_syscall_pre_impl_fstatat64((long)(dfd), (long)(filename), \
+                                         (long)(statbuf), (long)(flag))
+#define __sanitizer_syscall_post_fstatat64(res, dfd, filename, statbuf, flag) \
+  __sanitizer_syscall_post_impl_fstatat64(res, (long)(dfd), (long)(filename), \
+                                          (long)(statbuf), (long)(flag))
+#define __sanitizer_syscall_pre_readlinkat(dfd, path, buf, bufsiz)   \
+  __sanitizer_syscall_pre_impl_readlinkat((long)(dfd), (long)(path), \
+                                          (long)(buf), (long)(bufsiz))
+#define __sanitizer_syscall_post_readlinkat(res, dfd, path, buf, bufsiz)   \
+  __sanitizer_syscall_post_impl_readlinkat(res, (long)(dfd), (long)(path), \
+                                           (long)(buf), (long)(bufsiz))
+#define __sanitizer_syscall_pre_utimensat(dfd, filename, utimes, flags) \
+  __sanitizer_syscall_pre_impl_utimensat((long)(dfd), (long)(filename), \
+                                         (long)(utimes), (long)(flags))
+#define __sanitizer_syscall_post_utimensat(res, dfd, filename, utimes, flags) \
+  __sanitizer_syscall_post_impl_utimensat(res, (long)(dfd), (long)(filename), \
+                                          (long)(utimes), (long)(flags))
+#define __sanitizer_syscall_pre_unshare(unshare_flags) \
+  __sanitizer_syscall_pre_impl_unshare((long)(unshare_flags))
+#define __sanitizer_syscall_post_unshare(res, unshare_flags) \
+  __sanitizer_syscall_post_impl_unshare(res, (long)(unshare_flags))
+#define __sanitizer_syscall_pre_splice(fd_in, off_in, fd_out, off_out, len, \
+                                       flags)                               \
+  __sanitizer_syscall_pre_impl_splice((long)(fd_in), (long)(off_in),        \
+                                      (long)(fd_out), (long)(off_out),      \
+                                      (long)(len), (long)(flags))
+#define __sanitizer_syscall_post_splice(res, fd_in, off_in, fd_out, off_out, \
+                                        len, flags)                          \
+  __sanitizer_syscall_post_impl_splice(res, (long)(fd_in), (long)(off_in),   \
+                                       (long)(fd_out), (long)(off_out),      \
+                                       (long)(len), (long)(flags))
+#define __sanitizer_syscall_pre_vmsplice(fd, iov, nr_segs, flags) \
+  __sanitizer_syscall_pre_impl_vmsplice((long)(fd), (long)(iov),  \
+                                        (long)(nr_segs), (long)(flags))
+#define __sanitizer_syscall_post_vmsplice(res, fd, iov, nr_segs, flags) \
+  __sanitizer_syscall_post_impl_vmsplice(res, (long)(fd), (long)(iov),  \
+                                         (long)(nr_segs), (long)(flags))
+#define __sanitizer_syscall_pre_tee(fdin, fdout, len, flags)                 \
+  __sanitizer_syscall_pre_impl_tee((long)(fdin), (long)(fdout), (long)(len), \
+                                   (long)(flags))
+#define __sanitizer_syscall_post_tee(res, fdin, fdout, len, flags)    \
+  __sanitizer_syscall_post_impl_tee(res, (long)(fdin), (long)(fdout), \
+                                    (long)(len), (long)(flags))
+#define __sanitizer_syscall_pre_get_robust_list(pid, head_ptr, len_ptr)       \
+  __sanitizer_syscall_pre_impl_get_robust_list((long)(pid), (long)(head_ptr), \
+                                               (long)(len_ptr))
+#define __sanitizer_syscall_post_get_robust_list(res, pid, head_ptr, len_ptr) \
+  __sanitizer_syscall_post_impl_get_robust_list(                              \
+      res, (long)(pid), (long)(head_ptr), (long)(len_ptr))
+#define __sanitizer_syscall_pre_set_robust_list(head, len) \
+  __sanitizer_syscall_pre_impl_set_robust_list((long)(head), (long)(len))
+#define __sanitizer_syscall_post_set_robust_list(res, head, len) \
+  __sanitizer_syscall_post_impl_set_robust_list(res, (long)(head), (long)(len))
+#define __sanitizer_syscall_pre_getcpu(cpu, node, cache) \
+  __sanitizer_syscall_pre_impl_getcpu((long)(cpu), (long)(node), (long)(cache))
+#define __sanitizer_syscall_post_getcpu(res, cpu, node, cache)         \
+  __sanitizer_syscall_post_impl_getcpu(res, (long)(cpu), (long)(node), \
+                                       (long)(cache))
+#define __sanitizer_syscall_pre_signalfd(ufd, user_mask, sizemask)      \
+  __sanitizer_syscall_pre_impl_signalfd((long)(ufd), (long)(user_mask), \
+                                        (long)(sizemask))
+#define __sanitizer_syscall_post_signalfd(res, ufd, user_mask, sizemask)      \
+  __sanitizer_syscall_post_impl_signalfd(res, (long)(ufd), (long)(user_mask), \
+                                         (long)(sizemask))
+#define __sanitizer_syscall_pre_signalfd4(ufd, user_mask, sizemask, flags) \
+  __sanitizer_syscall_pre_impl_signalfd4((long)(ufd), (long)(user_mask),   \
+                                         (long)(sizemask), (long)(flags))
+#define __sanitizer_syscall_post_signalfd4(res, ufd, user_mask, sizemask,      \
+                                           flags)                              \
+  __sanitizer_syscall_post_impl_signalfd4(res, (long)(ufd), (long)(user_mask), \
+                                          (long)(sizemask), (long)(flags))
+#define __sanitizer_syscall_pre_timerfd_create(clockid, flags) \
+  __sanitizer_syscall_pre_impl_timerfd_create((long)(clockid), (long)(flags))
+#define __sanitizer_syscall_post_timerfd_create(res, clockid, flags) \
+  __sanitizer_syscall_post_impl_timerfd_create(res, (long)(clockid), \
+                                               (long)(flags))
+#define __sanitizer_syscall_pre_timerfd_settime(ufd, flags, utmr, otmr)    \
+  __sanitizer_syscall_pre_impl_timerfd_settime((long)(ufd), (long)(flags), \
+                                               (long)(utmr), (long)(otmr))
+#define __sanitizer_syscall_post_timerfd_settime(res, ufd, flags, utmr, otmr) \
+  __sanitizer_syscall_post_impl_timerfd_settime(                              \
+      res, (long)(ufd), (long)(flags), (long)(utmr), (long)(otmr))
+#define __sanitizer_syscall_pre_timerfd_gettime(ufd, otmr) \
+  __sanitizer_syscall_pre_impl_timerfd_gettime((long)(ufd), (long)(otmr))
+#define __sanitizer_syscall_post_timerfd_gettime(res, ufd, otmr) \
+  __sanitizer_syscall_post_impl_timerfd_gettime(res, (long)(ufd), (long)(otmr))
+#define __sanitizer_syscall_pre_eventfd(count) \
+  __sanitizer_syscall_pre_impl_eventfd((long)(count))
+#define __sanitizer_syscall_post_eventfd(res, count) \
+  __sanitizer_syscall_post_impl_eventfd(res, (long)(count))
+#define __sanitizer_syscall_pre_eventfd2(count, flags) \
+  __sanitizer_syscall_pre_impl_eventfd2((long)(count), (long)(flags))
+#define __sanitizer_syscall_post_eventfd2(res, count, flags) \
+  __sanitizer_syscall_post_impl_eventfd2(res, (long)(count), (long)(flags))
+#define __sanitizer_syscall_pre_old_readdir(arg0, arg1, arg2)          \
+  __sanitizer_syscall_pre_impl_old_readdir((long)(arg0), (long)(arg1), \
+                                           (long)(arg2))
+#define __sanitizer_syscall_post_old_readdir(res, arg0, arg1, arg2)          \
+  __sanitizer_syscall_post_impl_old_readdir(res, (long)(arg0), (long)(arg1), \
+                                            (long)(arg2))
+#define __sanitizer_syscall_pre_pselect6(arg0, arg1, arg2, arg3, arg4, arg5) \
+  __sanitizer_syscall_pre_impl_pselect6((long)(arg0), (long)(arg1),          \
+                                        (long)(arg2), (long)(arg3),          \
+                                        (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_post_pselect6(res, arg0, arg1, arg2, arg3, arg4, \
+                                          arg5)                              \
+  __sanitizer_syscall_post_impl_pselect6(res, (long)(arg0), (long)(arg1),    \
+                                         (long)(arg2), (long)(arg3),         \
+                                         (long)(arg4), (long)(arg5))
+#define __sanitizer_syscall_pre_ppoll(arg0, arg1, arg2, arg3, arg4)            \
+  __sanitizer_syscall_pre_impl_ppoll((long)(arg0), (long)(arg1), (long)(arg2), \
+                                     (long)(arg3), (long)(arg4))
+#define __sanitizer_syscall_post_ppoll(res, arg0, arg1, arg2, arg3, arg4) \
+  __sanitizer_syscall_post_impl_ppoll(res, (long)(arg0), (long)(arg1),    \
+                                      (long)(arg2), (long)(arg3),         \
+                                      (long)(arg4))
+#define __sanitizer_syscall_pre_syncfs(fd) \
+  __sanitizer_syscall_pre_impl_syncfs((long)(fd))
+#define __sanitizer_syscall_post_syncfs(res, fd) \
+  __sanitizer_syscall_post_impl_syncfs(res, (long)(fd))
+#define __sanitizer_syscall_pre_perf_event_open(attr_uptr, pid, cpu, group_fd, \
+                                                flags)                         \
+  __sanitizer_syscall_pre_impl_perf_event_open((long)(attr_uptr), (long)(pid), \
+                                               (long)(cpu), (long)(group_fd),  \
+                                               (long)(flags))
+#define __sanitizer_syscall_post_perf_event_open(res, attr_uptr, pid, cpu, \
+                                                 group_fd, flags)          \
+  __sanitizer_syscall_post_impl_perf_event_open(                           \
+      res, (long)(attr_uptr), (long)(pid), (long)(cpu), (long)(group_fd),  \
+      (long)(flags))
+#define __sanitizer_syscall_pre_mmap_pgoff(addr, len, prot, flags, fd, pgoff) \
+  __sanitizer_syscall_pre_impl_mmap_pgoff((long)(addr), (long)(len),          \
+                                          (long)(prot), (long)(flags),        \
+                                          (long)(fd), (long)(pgoff))
+#define __sanitizer_syscall_post_mmap_pgoff(res, addr, len, prot, flags, fd, \
+                                            pgoff)                           \
+  __sanitizer_syscall_post_impl_mmap_pgoff(res, (long)(addr), (long)(len),   \
+                                           (long)(prot), (long)(flags),      \
+                                           (long)(fd), (long)(pgoff))
+#define __sanitizer_syscall_pre_old_mmap(arg) \
+  __sanitizer_syscall_pre_impl_old_mmap((long)(arg))
+#define __sanitizer_syscall_post_old_mmap(res, arg) \
+  __sanitizer_syscall_post_impl_old_mmap(res, (long)(arg))
+#define __sanitizer_syscall_pre_name_to_handle_at(dfd, name, handle, mnt_id, \
+                                                  flag)                      \
+  __sanitizer_syscall_pre_impl_name_to_handle_at(                            \
+      (long)(dfd), (long)(name), (long)(handle), (long)(mnt_id), (long)(flag))
+#define __sanitizer_syscall_post_name_to_handle_at(res, dfd, name, handle, \
+                                                   mnt_id, flag)           \
+  __sanitizer_syscall_post_impl_name_to_handle_at(                         \
+      res, (long)(dfd), (long)(name), (long)(handle), (long)(mnt_id),      \
+      (long)(flag))
+#define __sanitizer_syscall_pre_open_by_handle_at(mountdirfd, handle, flags) \
+  __sanitizer_syscall_pre_impl_open_by_handle_at(                            \
+      (long)(mountdirfd), (long)(handle), (long)(flags))
+#define __sanitizer_syscall_post_open_by_handle_at(res, mountdirfd, handle, \
+                                                   flags)                   \
+  __sanitizer_syscall_post_impl_open_by_handle_at(                          \
+      res, (long)(mountdirfd), (long)(handle), (long)(flags))
+#define __sanitizer_syscall_pre_setns(fd, nstype) \
+  __sanitizer_syscall_pre_impl_setns((long)(fd), (long)(nstype))
+#define __sanitizer_syscall_post_setns(res, fd, nstype) \
+  __sanitizer_syscall_post_impl_setns(res, (long)(fd), (long)(nstype))
+#define __sanitizer_syscall_pre_process_vm_readv(pid, lvec, liovcnt, rvec, \
+                                                 riovcnt, flags)           \
+  __sanitizer_syscall_pre_impl_process_vm_readv(                           \
+      (long)(pid), (long)(lvec), (long)(liovcnt), (long)(rvec),            \
+      (long)(riovcnt), (long)(flags))
+#define __sanitizer_syscall_post_process_vm_readv(res, pid, lvec, liovcnt, \
+                                                  rvec, riovcnt, flags)    \
+  __sanitizer_syscall_post_impl_process_vm_readv(                          \
+      res, (long)(pid), (long)(lvec), (long)(liovcnt), (long)(rvec),       \
+      (long)(riovcnt), (long)(flags))
+#define __sanitizer_syscall_pre_process_vm_writev(pid, lvec, liovcnt, rvec, \
+                                                  riovcnt, flags)           \
+  __sanitizer_syscall_pre_impl_process_vm_writev(                           \
+      (long)(pid), (long)(lvec), (long)(liovcnt), (long)(rvec),             \
+      (long)(riovcnt), (long)(flags))
+#define __sanitizer_syscall_post_process_vm_writev(res, pid, lvec, liovcnt, \
+                                                   rvec, riovcnt, flags)    \
+  __sanitizer_syscall_post_impl_process_vm_writev(                          \
+      res, (long)(pid), (long)(lvec), (long)(liovcnt), (long)(rvec),        \
+      (long)(riovcnt), (long)(flags))
+#define __sanitizer_syscall_pre_fork() \
+  __sanitizer_syscall_pre_impl_fork()
+#define __sanitizer_syscall_post_fork(res) \
+  __sanitizer_syscall_post_impl_fork(res)
+#define __sanitizer_syscall_pre_vfork() \
+  __sanitizer_syscall_pre_impl_vfork()
+#define __sanitizer_syscall_post_vfork(res) \
+  __sanitizer_syscall_post_impl_vfork(res)
+
+// And now a few syscalls we don't handle yet.
+#define __sanitizer_syscall_pre_afs_syscall(...)
+#define __sanitizer_syscall_pre_arch_prctl(...)
+#define __sanitizer_syscall_pre_break(...)
+#define __sanitizer_syscall_pre_chown32(...)
+#define __sanitizer_syscall_pre_clone(...)
+#define __sanitizer_syscall_pre_create_module(...)
+#define __sanitizer_syscall_pre_epoll_ctl_old(...)
+#define __sanitizer_syscall_pre_epoll_wait_old(...)
+#define __sanitizer_syscall_pre_execve(...)
+#define __sanitizer_syscall_pre_fadvise64(...)
+#define __sanitizer_syscall_pre_fadvise64_64(...)
+#define __sanitizer_syscall_pre_fallocate(...)
+#define __sanitizer_syscall_pre_fanotify_init(...)
+#define __sanitizer_syscall_pre_fanotify_mark(...)
+#define __sanitizer_syscall_pre_fchown32(...)
+#define __sanitizer_syscall_pre_ftime(...)
+#define __sanitizer_syscall_pre_ftruncate64(...)
+#define __sanitizer_syscall_pre_futex(...)
+#define __sanitizer_syscall_pre_getegid32(...)
+#define __sanitizer_syscall_pre_geteuid32(...)
+#define __sanitizer_syscall_pre_getgid32(...)
+#define __sanitizer_syscall_pre_getgroups32(...)
+#define __sanitizer_syscall_pre_get_kernel_syms(...)
+#define __sanitizer_syscall_pre_getpmsg(...)
+#define __sanitizer_syscall_pre_getresgid32(...)
+#define __sanitizer_syscall_pre_getresuid32(...)
+#define __sanitizer_syscall_pre_get_thread_area(...)
+#define __sanitizer_syscall_pre_getuid32(...)
+#define __sanitizer_syscall_pre_gtty(...)
+#define __sanitizer_syscall_pre_idle(...)
+#define __sanitizer_syscall_pre_iopl(...)
+#define __sanitizer_syscall_pre_lchown32(...)
+#define __sanitizer_syscall_pre__llseek(...)
+#define __sanitizer_syscall_pre_lock(...)
+#define __sanitizer_syscall_pre_madvise1(...)
+#define __sanitizer_syscall_pre_mmap(...)
+#define __sanitizer_syscall_pre_mmap2(...)
+#define __sanitizer_syscall_pre_modify_ldt(...)
+#define __sanitizer_syscall_pre_mpx(...)
+#define __sanitizer_syscall_pre__newselect(...)
+#define __sanitizer_syscall_pre_nfsservctl(...)
+#define __sanitizer_syscall_pre_oldfstat(...)
+#define __sanitizer_syscall_pre_oldlstat(...)
+#define __sanitizer_syscall_pre_oldolduname(...)
+#define __sanitizer_syscall_pre_oldstat(...)
+#define __sanitizer_syscall_pre_prctl(...)
+#define __sanitizer_syscall_pre_prof(...)
+#define __sanitizer_syscall_pre_profil(...)
+#define __sanitizer_syscall_pre_putpmsg(...)
+#define __sanitizer_syscall_pre_query_module(...)
+#define __sanitizer_syscall_pre_readahead(...)
+#define __sanitizer_syscall_pre_readdir(...)
+#define __sanitizer_syscall_pre_rt_sigaction(...)
+#define __sanitizer_syscall_pre_rt_sigreturn(...)
+#define __sanitizer_syscall_pre_rt_sigsuspend(...)
+#define __sanitizer_syscall_pre_security(...)
+#define __sanitizer_syscall_pre_setfsgid32(...)
+#define __sanitizer_syscall_pre_setfsuid32(...)
+#define __sanitizer_syscall_pre_setgid32(...)
+#define __sanitizer_syscall_pre_setgroups32(...)
+#define __sanitizer_syscall_pre_setregid32(...)
+#define __sanitizer_syscall_pre_setresgid32(...)
+#define __sanitizer_syscall_pre_setresuid32(...)
+#define __sanitizer_syscall_pre_setreuid32(...)
+#define __sanitizer_syscall_pre_set_thread_area(...)
+#define __sanitizer_syscall_pre_setuid32(...)
+#define __sanitizer_syscall_pre_sigaction(...)
+#define __sanitizer_syscall_pre_sigaltstack(...)
+#define __sanitizer_syscall_pre_sigreturn(...)
+#define __sanitizer_syscall_pre_sigsuspend(...)
+#define __sanitizer_syscall_pre_stty(...)
+#define __sanitizer_syscall_pre_sync_file_range(...)
+#define __sanitizer_syscall_pre__sysctl(...)
+#define __sanitizer_syscall_pre_truncate64(...)
+#define __sanitizer_syscall_pre_tuxcall(...)
+#define __sanitizer_syscall_pre_ugetrlimit(...)
+#define __sanitizer_syscall_pre_ulimit(...)
+#define __sanitizer_syscall_pre_umount2(...)
+#define __sanitizer_syscall_pre_vm86(...)
+#define __sanitizer_syscall_pre_vm86old(...)
+#define __sanitizer_syscall_pre_vserver(...)
+
+#define __sanitizer_syscall_post_afs_syscall(res, ...)
+#define __sanitizer_syscall_post_arch_prctl(res, ...)
+#define __sanitizer_syscall_post_break(res, ...)
+#define __sanitizer_syscall_post_chown32(res, ...)
+#define __sanitizer_syscall_post_clone(res, ...)
+#define __sanitizer_syscall_post_create_module(res, ...)
+#define __sanitizer_syscall_post_epoll_ctl_old(res, ...)
+#define __sanitizer_syscall_post_epoll_wait_old(res, ...)
+#define __sanitizer_syscall_post_execve(res, ...)
+#define __sanitizer_syscall_post_fadvise64(res, ...)
+#define __sanitizer_syscall_post_fadvise64_64(res, ...)
+#define __sanitizer_syscall_post_fallocate(res, ...)
+#define __sanitizer_syscall_post_fanotify_init(res, ...)
+#define __sanitizer_syscall_post_fanotify_mark(res, ...)
+#define __sanitizer_syscall_post_fchown32(res, ...)
+#define __sanitizer_syscall_post_ftime(res, ...)
+#define __sanitizer_syscall_post_ftruncate64(res, ...)
+#define __sanitizer_syscall_post_futex(res, ...)
+#define __sanitizer_syscall_post_getegid32(res, ...)
+#define __sanitizer_syscall_post_geteuid32(res, ...)
+#define __sanitizer_syscall_post_getgid32(res, ...)
+#define __sanitizer_syscall_post_getgroups32(res, ...)
+#define __sanitizer_syscall_post_get_kernel_syms(res, ...)
+#define __sanitizer_syscall_post_getpmsg(res, ...)
+#define __sanitizer_syscall_post_getresgid32(res, ...)
+#define __sanitizer_syscall_post_getresuid32(res, ...)
+#define __sanitizer_syscall_post_get_thread_area(res, ...)
+#define __sanitizer_syscall_post_getuid32(res, ...)
+#define __sanitizer_syscall_post_gtty(res, ...)
+#define __sanitizer_syscall_post_idle(res, ...)
+#define __sanitizer_syscall_post_iopl(res, ...)
+#define __sanitizer_syscall_post_lchown32(res, ...)
+#define __sanitizer_syscall_post__llseek(res, ...)
+#define __sanitizer_syscall_post_lock(res, ...)
+#define __sanitizer_syscall_post_madvise1(res, ...)
+#define __sanitizer_syscall_post_mmap2(res, ...)
+#define __sanitizer_syscall_post_mmap(res, ...)
+#define __sanitizer_syscall_post_modify_ldt(res, ...)
+#define __sanitizer_syscall_post_mpx(res, ...)
+#define __sanitizer_syscall_post__newselect(res, ...)
+#define __sanitizer_syscall_post_nfsservctl(res, ...)
+#define __sanitizer_syscall_post_oldfstat(res, ...)
+#define __sanitizer_syscall_post_oldlstat(res, ...)
+#define __sanitizer_syscall_post_oldolduname(res, ...)
+#define __sanitizer_syscall_post_oldstat(res, ...)
+#define __sanitizer_syscall_post_prctl(res, ...)
+#define __sanitizer_syscall_post_profil(res, ...)
+#define __sanitizer_syscall_post_prof(res, ...)
+#define __sanitizer_syscall_post_putpmsg(res, ...)
+#define __sanitizer_syscall_post_query_module(res, ...)
+#define __sanitizer_syscall_post_readahead(res, ...)
+#define __sanitizer_syscall_post_readdir(res, ...)
+#define __sanitizer_syscall_post_rt_sigaction(res, ...)
+#define __sanitizer_syscall_post_rt_sigreturn(res, ...)
+#define __sanitizer_syscall_post_rt_sigsuspend(res, ...)
+#define __sanitizer_syscall_post_security(res, ...)
+#define __sanitizer_syscall_post_setfsgid32(res, ...)
+#define __sanitizer_syscall_post_setfsuid32(res, ...)
+#define __sanitizer_syscall_post_setgid32(res, ...)
+#define __sanitizer_syscall_post_setgroups32(res, ...)
+#define __sanitizer_syscall_post_setregid32(res, ...)
+#define __sanitizer_syscall_post_setresgid32(res, ...)
+#define __sanitizer_syscall_post_setresuid32(res, ...)
+#define __sanitizer_syscall_post_setreuid32(res, ...)
+#define __sanitizer_syscall_post_set_thread_area(res, ...)
+#define __sanitizer_syscall_post_setuid32(res, ...)
+#define __sanitizer_syscall_post_sigaction(res, ...)
+#define __sanitizer_syscall_post_sigaltstack(res, ...)
+#define __sanitizer_syscall_post_sigreturn(res, ...)
+#define __sanitizer_syscall_post_sigsuspend(res, ...)
+#define __sanitizer_syscall_post_stty(res, ...)
+#define __sanitizer_syscall_post_sync_file_range(res, ...)
+#define __sanitizer_syscall_post__sysctl(res, ...)
+#define __sanitizer_syscall_post_truncate64(res, ...)
+#define __sanitizer_syscall_post_tuxcall(res, ...)
+#define __sanitizer_syscall_post_ugetrlimit(res, ...)
+#define __sanitizer_syscall_post_ulimit(res, ...)
+#define __sanitizer_syscall_post_umount2(res, ...)
+#define __sanitizer_syscall_post_vm86old(res, ...)
+#define __sanitizer_syscall_post_vm86(res, ...)
+#define __sanitizer_syscall_post_vserver(res, ...)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Private declarations. Do not call directly from user code. Use macros above.
+void __sanitizer_syscall_pre_impl_time(long tloc);
+void __sanitizer_syscall_post_impl_time(long res, long tloc);
+void __sanitizer_syscall_pre_impl_stime(long tptr);
+void __sanitizer_syscall_post_impl_stime(long res, long tptr);
+void __sanitizer_syscall_pre_impl_gettimeofday(long tv, long tz);
+void __sanitizer_syscall_post_impl_gettimeofday(long res, long tv, long tz);
+void __sanitizer_syscall_pre_impl_settimeofday(long tv, long tz);
+void __sanitizer_syscall_post_impl_settimeofday(long res, long tv, long tz);
+void __sanitizer_syscall_pre_impl_adjtimex(long txc_p);
+void __sanitizer_syscall_post_impl_adjtimex(long res, long txc_p);
+void __sanitizer_syscall_pre_impl_times(long tbuf);
+void __sanitizer_syscall_post_impl_times(long res, long tbuf);
+void __sanitizer_syscall_pre_impl_gettid();
+void __sanitizer_syscall_post_impl_gettid(long res);
+void __sanitizer_syscall_pre_impl_nanosleep(long rqtp, long rmtp);
+void __sanitizer_syscall_post_impl_nanosleep(long res, long rqtp, long rmtp);
+void __sanitizer_syscall_pre_impl_alarm(long seconds);
+void __sanitizer_syscall_post_impl_alarm(long res, long seconds);
+void __sanitizer_syscall_pre_impl_getpid();
+void __sanitizer_syscall_post_impl_getpid(long res);
+void __sanitizer_syscall_pre_impl_getppid();
+void __sanitizer_syscall_post_impl_getppid(long res);
+void __sanitizer_syscall_pre_impl_getuid();
+void __sanitizer_syscall_post_impl_getuid(long res);
+void __sanitizer_syscall_pre_impl_geteuid();
+void __sanitizer_syscall_post_impl_geteuid(long res);
+void __sanitizer_syscall_pre_impl_getgid();
+void __sanitizer_syscall_post_impl_getgid(long res);
+void __sanitizer_syscall_pre_impl_getegid();
+void __sanitizer_syscall_post_impl_getegid(long res);
+void __sanitizer_syscall_pre_impl_getresuid(long ruid, long euid, long suid);
+void __sanitizer_syscall_post_impl_getresuid(long res, long ruid, long euid,
+                                             long suid);
+void __sanitizer_syscall_pre_impl_getresgid(long rgid, long egid, long sgid);
+void __sanitizer_syscall_post_impl_getresgid(long res, long rgid, long egid,
+                                             long sgid);
+void __sanitizer_syscall_pre_impl_getpgid(long pid);
+void __sanitizer_syscall_post_impl_getpgid(long res, long pid);
+void __sanitizer_syscall_pre_impl_getpgrp();
+void __sanitizer_syscall_post_impl_getpgrp(long res);
+void __sanitizer_syscall_pre_impl_getsid(long pid);
+void __sanitizer_syscall_post_impl_getsid(long res, long pid);
+void __sanitizer_syscall_pre_impl_getgroups(long gidsetsize, long grouplist);
+void __sanitizer_syscall_post_impl_getgroups(long res, long gidsetsize,
+                                             long grouplist);
+void __sanitizer_syscall_pre_impl_setregid(long rgid, long egid);
+void __sanitizer_syscall_post_impl_setregid(long res, long rgid, long egid);
+void __sanitizer_syscall_pre_impl_setgid(long gid);
+void __sanitizer_syscall_post_impl_setgid(long res, long gid);
+void __sanitizer_syscall_pre_impl_setreuid(long ruid, long euid);
+void __sanitizer_syscall_post_impl_setreuid(long res, long ruid, long euid);
+void __sanitizer_syscall_pre_impl_setuid(long uid);
+void __sanitizer_syscall_post_impl_setuid(long res, long uid);
+void __sanitizer_syscall_pre_impl_setresuid(long ruid, long euid, long suid);
+void __sanitizer_syscall_post_impl_setresuid(long res, long ruid, long euid,
+                                             long suid);
+void __sanitizer_syscall_pre_impl_setresgid(long rgid, long egid, long sgid);
+void __sanitizer_syscall_post_impl_setresgid(long res, long rgid, long egid,
+                                             long sgid);
+void __sanitizer_syscall_pre_impl_setfsuid(long uid);
+void __sanitizer_syscall_post_impl_setfsuid(long res, long uid);
+void __sanitizer_syscall_pre_impl_setfsgid(long gid);
+void __sanitizer_syscall_post_impl_setfsgid(long res, long gid);
+void __sanitizer_syscall_pre_impl_setpgid(long pid, long pgid);
+void __sanitizer_syscall_post_impl_setpgid(long res, long pid, long pgid);
+void __sanitizer_syscall_pre_impl_setsid();
+void __sanitizer_syscall_post_impl_setsid(long res);
+void __sanitizer_syscall_pre_impl_setgroups(long gidsetsize, long grouplist);
+void __sanitizer_syscall_post_impl_setgroups(long res, long gidsetsize,
+                                             long grouplist);
+void __sanitizer_syscall_pre_impl_acct(long name);
+void __sanitizer_syscall_post_impl_acct(long res, long name);
+void __sanitizer_syscall_pre_impl_capget(long header, long dataptr);
+void __sanitizer_syscall_post_impl_capget(long res, long header, long dataptr);
+void __sanitizer_syscall_pre_impl_capset(long header, long data);
+void __sanitizer_syscall_post_impl_capset(long res, long header, long data);
+void __sanitizer_syscall_pre_impl_personality(long personality);
+void __sanitizer_syscall_post_impl_personality(long res, long personality);
+void __sanitizer_syscall_pre_impl_sigpending(long set);
+void __sanitizer_syscall_post_impl_sigpending(long res, long set);
+void __sanitizer_syscall_pre_impl_sigprocmask(long how, long set, long oset);
+void __sanitizer_syscall_post_impl_sigprocmask(long res, long how, long set,
+                                               long oset);
+void __sanitizer_syscall_pre_impl_getitimer(long which, long value);
+void __sanitizer_syscall_post_impl_getitimer(long res, long which, long value);
+void __sanitizer_syscall_pre_impl_setitimer(long which, long value,
+                                            long ovalue);
+void __sanitizer_syscall_post_impl_setitimer(long res, long which, long value,
+                                             long ovalue);
+void __sanitizer_syscall_pre_impl_timer_create(long which_clock,
+                                               long timer_event_spec,
+                                               long created_timer_id);
+void __sanitizer_syscall_post_impl_timer_create(long res, long which_clock,
+                                                long timer_event_spec,
+                                                long created_timer_id);
+void __sanitizer_syscall_pre_impl_timer_gettime(long timer_id, long setting);
+void __sanitizer_syscall_post_impl_timer_gettime(long res, long timer_id,
+                                                 long setting);
+void __sanitizer_syscall_pre_impl_timer_getoverrun(long timer_id);
+void __sanitizer_syscall_post_impl_timer_getoverrun(long res, long timer_id);
+void __sanitizer_syscall_pre_impl_timer_settime(long timer_id, long flags,
+                                                long new_setting,
+                                                long old_setting);
+void __sanitizer_syscall_post_impl_timer_settime(long res, long timer_id,
+                                                 long flags, long new_setting,
+                                                 long old_setting);
+void __sanitizer_syscall_pre_impl_timer_delete(long timer_id);
+void __sanitizer_syscall_post_impl_timer_delete(long res, long timer_id);
+void __sanitizer_syscall_pre_impl_clock_settime(long which_clock, long tp);
+void __sanitizer_syscall_post_impl_clock_settime(long res, long which_clock,
+                                                 long tp);
+void __sanitizer_syscall_pre_impl_clock_gettime(long which_clock, long tp);
+void __sanitizer_syscall_post_impl_clock_gettime(long res, long which_clock,
+                                                 long tp);
+void __sanitizer_syscall_pre_impl_clock_adjtime(long which_clock, long tx);
+void __sanitizer_syscall_post_impl_clock_adjtime(long res, long which_clock,
+                                                 long tx);
+void __sanitizer_syscall_pre_impl_clock_getres(long which_clock, long tp);
+void __sanitizer_syscall_post_impl_clock_getres(long res, long which_clock,
+                                                long tp);
+void __sanitizer_syscall_pre_impl_clock_nanosleep(long which_clock, long flags,
+                                                  long rqtp, long rmtp);
+void __sanitizer_syscall_post_impl_clock_nanosleep(long res, long which_clock,
+                                                   long flags, long rqtp,
+                                                   long rmtp);
+void __sanitizer_syscall_pre_impl_nice(long increment);
+void __sanitizer_syscall_post_impl_nice(long res, long increment);
+void __sanitizer_syscall_pre_impl_sched_setscheduler(long pid, long policy,
+                                                     long param);
+void __sanitizer_syscall_post_impl_sched_setscheduler(long res, long pid,
+                                                      long policy, long param);
+void __sanitizer_syscall_pre_impl_sched_setparam(long pid, long param);
+void __sanitizer_syscall_post_impl_sched_setparam(long res, long pid,
+                                                  long param);
+void __sanitizer_syscall_pre_impl_sched_getscheduler(long pid);
+void __sanitizer_syscall_post_impl_sched_getscheduler(long res, long pid);
+void __sanitizer_syscall_pre_impl_sched_getparam(long pid, long param);
+void __sanitizer_syscall_post_impl_sched_getparam(long res, long pid,
+                                                  long param);
+void __sanitizer_syscall_pre_impl_sched_setaffinity(long pid, long len,
+                                                    long user_mask_ptr);
+void __sanitizer_syscall_post_impl_sched_setaffinity(long res, long pid,
+                                                     long len,
+                                                     long user_mask_ptr);
+void __sanitizer_syscall_pre_impl_sched_getaffinity(long pid, long len,
+                                                    long user_mask_ptr);
+void __sanitizer_syscall_post_impl_sched_getaffinity(long res, long pid,
+                                                     long len,
+                                                     long user_mask_ptr);
+void __sanitizer_syscall_pre_impl_sched_yield();
+void __sanitizer_syscall_post_impl_sched_yield(long res);
+void __sanitizer_syscall_pre_impl_sched_get_priority_max(long policy);
+void __sanitizer_syscall_post_impl_sched_get_priority_max(long res,
+                                                          long policy);
+void __sanitizer_syscall_pre_impl_sched_get_priority_min(long policy);
+void __sanitizer_syscall_post_impl_sched_get_priority_min(long res,
+                                                          long policy);
+void __sanitizer_syscall_pre_impl_sched_rr_get_interval(long pid,
+                                                        long interval);
+void __sanitizer_syscall_post_impl_sched_rr_get_interval(long res, long pid,
+                                                         long interval);
+void __sanitizer_syscall_pre_impl_setpriority(long which, long who,
+                                              long niceval);
+void __sanitizer_syscall_post_impl_setpriority(long res, long which, long who,
+                                               long niceval);
+void __sanitizer_syscall_pre_impl_getpriority(long which, long who);
+void __sanitizer_syscall_post_impl_getpriority(long res, long which, long who);
+void __sanitizer_syscall_pre_impl_shutdown(long arg0, long arg1);
+void __sanitizer_syscall_post_impl_shutdown(long res, long arg0, long arg1);
+void __sanitizer_syscall_pre_impl_reboot(long magic1, long magic2, long cmd,
+                                         long arg);
+void __sanitizer_syscall_post_impl_reboot(long res, long magic1, long magic2,
+                                          long cmd, long arg);
+void __sanitizer_syscall_pre_impl_restart_syscall();
+void __sanitizer_syscall_post_impl_restart_syscall(long res);
+void __sanitizer_syscall_pre_impl_kexec_load(long entry, long nr_segments,
+                                             long segments, long flags);
+void __sanitizer_syscall_post_impl_kexec_load(long res, long entry,
+                                              long nr_segments, long segments,
+                                              long flags);
+void __sanitizer_syscall_pre_impl_exit(long error_code);
+void __sanitizer_syscall_post_impl_exit(long res, long error_code);
+void __sanitizer_syscall_pre_impl_exit_group(long error_code);
+void __sanitizer_syscall_post_impl_exit_group(long res, long error_code);
+void __sanitizer_syscall_pre_impl_wait4(long pid, long stat_addr, long options,
+                                        long ru);
+void __sanitizer_syscall_post_impl_wait4(long res, long pid, long stat_addr,
+                                         long options, long ru);
+void __sanitizer_syscall_pre_impl_waitid(long which, long pid, long infop,
+                                         long options, long ru);
+void __sanitizer_syscall_post_impl_waitid(long res, long which, long pid,
+                                          long infop, long options, long ru);
+void __sanitizer_syscall_pre_impl_waitpid(long pid, long stat_addr,
+                                          long options);
+void __sanitizer_syscall_post_impl_waitpid(long res, long pid, long stat_addr,
+                                           long options);
+void __sanitizer_syscall_pre_impl_set_tid_address(long tidptr);
+void __sanitizer_syscall_post_impl_set_tid_address(long res, long tidptr);
+void __sanitizer_syscall_pre_impl_init_module(long umod, long len, long uargs);
+void __sanitizer_syscall_post_impl_init_module(long res, long umod, long len,
+                                               long uargs);
+void __sanitizer_syscall_pre_impl_delete_module(long name_user, long flags);
+void __sanitizer_syscall_post_impl_delete_module(long res, long name_user,
+                                                 long flags);
+void __sanitizer_syscall_pre_impl_rt_sigprocmask(long how, long set, long oset,
+                                                 long sigsetsize);
+void __sanitizer_syscall_post_impl_rt_sigprocmask(long res, long how, long set,
+                                                  long oset, long sigsetsize);
+void __sanitizer_syscall_pre_impl_rt_sigpending(long set, long sigsetsize);
+void __sanitizer_syscall_post_impl_rt_sigpending(long res, long set,
+                                                 long sigsetsize);
+void __sanitizer_syscall_pre_impl_rt_sigtimedwait(long uthese, long uinfo,
+                                                  long uts, long sigsetsize);
+void __sanitizer_syscall_post_impl_rt_sigtimedwait(long res, long uthese,
+                                                   long uinfo, long uts,
+                                                   long sigsetsize);
+void __sanitizer_syscall_pre_impl_rt_tgsigqueueinfo(long tgid, long pid,
+                                                    long sig, long uinfo);
+void __sanitizer_syscall_post_impl_rt_tgsigqueueinfo(long res, long tgid,
+                                                     long pid, long sig,
+                                                     long uinfo);
+void __sanitizer_syscall_pre_impl_kill(long pid, long sig);
+void __sanitizer_syscall_post_impl_kill(long res, long pid, long sig);
+void __sanitizer_syscall_pre_impl_tgkill(long tgid, long pid, long sig);
+void __sanitizer_syscall_post_impl_tgkill(long res, long tgid, long pid,
+                                          long sig);
+void __sanitizer_syscall_pre_impl_tkill(long pid, long sig);
+void __sanitizer_syscall_post_impl_tkill(long res, long pid, long sig);
+void __sanitizer_syscall_pre_impl_rt_sigqueueinfo(long pid, long sig,
+                                                  long uinfo);
+void __sanitizer_syscall_post_impl_rt_sigqueueinfo(long res, long pid, long sig,
+                                                   long uinfo);
+void __sanitizer_syscall_pre_impl_sgetmask();
+void __sanitizer_syscall_post_impl_sgetmask(long res);
+void __sanitizer_syscall_pre_impl_ssetmask(long newmask);
+void __sanitizer_syscall_post_impl_ssetmask(long res, long newmask);
+void __sanitizer_syscall_pre_impl_signal(long sig, long handler);
+void __sanitizer_syscall_post_impl_signal(long res, long sig, long handler);
+void __sanitizer_syscall_pre_impl_pause();
+void __sanitizer_syscall_post_impl_pause(long res);
+void __sanitizer_syscall_pre_impl_sync();
+void __sanitizer_syscall_post_impl_sync(long res);
+void __sanitizer_syscall_pre_impl_fsync(long fd);
+void __sanitizer_syscall_post_impl_fsync(long res, long fd);
+void __sanitizer_syscall_pre_impl_fdatasync(long fd);
+void __sanitizer_syscall_post_impl_fdatasync(long res, long fd);
+void __sanitizer_syscall_pre_impl_bdflush(long func, long data);
+void __sanitizer_syscall_post_impl_bdflush(long res, long func, long data);
+void __sanitizer_syscall_pre_impl_mount(long dev_name, long dir_name, long type,
+                                        long flags, long data);
+void __sanitizer_syscall_post_impl_mount(long res, long dev_name, long dir_name,
+                                         long type, long flags, long data);
+void __sanitizer_syscall_pre_impl_umount(long name, long flags);
+void __sanitizer_syscall_post_impl_umount(long res, long name, long flags);
+void __sanitizer_syscall_pre_impl_oldumount(long name);
+void __sanitizer_syscall_post_impl_oldumount(long res, long name);
+void __sanitizer_syscall_pre_impl_truncate(long path, long length);
+void __sanitizer_syscall_post_impl_truncate(long res, long path, long length);
+void __sanitizer_syscall_pre_impl_ftruncate(long fd, long length);
+void __sanitizer_syscall_post_impl_ftruncate(long res, long fd, long length);
+void __sanitizer_syscall_pre_impl_stat(long filename, long statbuf);
+void __sanitizer_syscall_post_impl_stat(long res, long filename, long statbuf);
+void __sanitizer_syscall_pre_impl_statfs(long path, long buf);
+void __sanitizer_syscall_post_impl_statfs(long res, long path, long buf);
+void __sanitizer_syscall_pre_impl_statfs64(long path, long sz, long buf);
+void __sanitizer_syscall_post_impl_statfs64(long res, long path, long sz,
+                                            long buf);
+void __sanitizer_syscall_pre_impl_fstatfs(long fd, long buf);
+void __sanitizer_syscall_post_impl_fstatfs(long res, long fd, long buf);
+void __sanitizer_syscall_pre_impl_fstatfs64(long fd, long sz, long buf);
+void __sanitizer_syscall_post_impl_fstatfs64(long res, long fd, long sz,
+                                             long buf);
+void __sanitizer_syscall_pre_impl_lstat(long filename, long statbuf);
+void __sanitizer_syscall_post_impl_lstat(long res, long filename, long statbuf);
+void __sanitizer_syscall_pre_impl_fstat(long fd, long statbuf);
+void __sanitizer_syscall_post_impl_fstat(long res, long fd, long statbuf);
+void __sanitizer_syscall_pre_impl_newstat(long filename, long statbuf);
+void __sanitizer_syscall_post_impl_newstat(long res, long filename,
+                                           long statbuf);
+void __sanitizer_syscall_pre_impl_newlstat(long filename, long statbuf);
+void __sanitizer_syscall_post_impl_newlstat(long res, long filename,
+                                            long statbuf);
+void __sanitizer_syscall_pre_impl_newfstat(long fd, long statbuf);
+void __sanitizer_syscall_post_impl_newfstat(long res, long fd, long statbuf);
+void __sanitizer_syscall_pre_impl_ustat(long dev, long ubuf);
+void __sanitizer_syscall_post_impl_ustat(long res, long dev, long ubuf);
+void __sanitizer_syscall_pre_impl_stat64(long filename, long statbuf);
+void __sanitizer_syscall_post_impl_stat64(long res, long filename,
+                                          long statbuf);
+void __sanitizer_syscall_pre_impl_fstat64(long fd, long statbuf);
+void __sanitizer_syscall_post_impl_fstat64(long res, long fd, long statbuf);
+void __sanitizer_syscall_pre_impl_lstat64(long filename, long statbuf);
+void __sanitizer_syscall_post_impl_lstat64(long res, long filename,
+                                           long statbuf);
+void __sanitizer_syscall_pre_impl_setxattr(long path, long name, long value,
+                                           long size, long flags);
+void __sanitizer_syscall_post_impl_setxattr(long res, long path, long name,
+                                            long value, long size, long flags);
+void __sanitizer_syscall_pre_impl_lsetxattr(long path, long name, long value,
+                                            long size, long flags);
+void __sanitizer_syscall_post_impl_lsetxattr(long res, long path, long name,
+                                             long value, long size, long flags);
+void __sanitizer_syscall_pre_impl_fsetxattr(long fd, long name, long value,
+                                            long size, long flags);
+void __sanitizer_syscall_post_impl_fsetxattr(long res, long fd, long name,
+                                             long value, long size, long flags);
+void __sanitizer_syscall_pre_impl_getxattr(long path, long name, long value,
+                                           long size);
+void __sanitizer_syscall_post_impl_getxattr(long res, long path, long name,
+                                            long value, long size);
+void __sanitizer_syscall_pre_impl_lgetxattr(long path, long name, long value,
+                                            long size);
+void __sanitizer_syscall_post_impl_lgetxattr(long res, long path, long name,
+                                             long value, long size);
+void __sanitizer_syscall_pre_impl_fgetxattr(long fd, long name, long value,
+                                            long size);
+void __sanitizer_syscall_post_impl_fgetxattr(long res, long fd, long name,
+                                             long value, long size);
+void __sanitizer_syscall_pre_impl_listxattr(long path, long list, long size);
+void __sanitizer_syscall_post_impl_listxattr(long res, long path, long list,
+                                             long size);
+void __sanitizer_syscall_pre_impl_llistxattr(long path, long list, long size);
+void __sanitizer_syscall_post_impl_llistxattr(long res, long path, long list,
+                                              long size);
+void __sanitizer_syscall_pre_impl_flistxattr(long fd, long list, long size);
+void __sanitizer_syscall_post_impl_flistxattr(long res, long fd, long list,
+                                              long size);
+void __sanitizer_syscall_pre_impl_removexattr(long path, long name);
+void __sanitizer_syscall_post_impl_removexattr(long res, long path, long name);
+void __sanitizer_syscall_pre_impl_lremovexattr(long path, long name);
+void __sanitizer_syscall_post_impl_lremovexattr(long res, long path, long name);
+void __sanitizer_syscall_pre_impl_fremovexattr(long fd, long name);
+void __sanitizer_syscall_post_impl_fremovexattr(long res, long fd, long name);
+void __sanitizer_syscall_pre_impl_brk(long brk);
+void __sanitizer_syscall_post_impl_brk(long res, long brk);
+void __sanitizer_syscall_pre_impl_mprotect(long start, long len, long prot);
+void __sanitizer_syscall_post_impl_mprotect(long res, long start, long len,
+                                            long prot);
+void __sanitizer_syscall_pre_impl_mremap(long addr, long old_len, long new_len,
+                                         long flags, long new_addr);
+void __sanitizer_syscall_post_impl_mremap(long res, long addr, long old_len,
+                                          long new_len, long flags,
+                                          long new_addr);
+void __sanitizer_syscall_pre_impl_remap_file_pages(long start, long size,
+                                                   long prot, long pgoff,
+                                                   long flags);
+void __sanitizer_syscall_post_impl_remap_file_pages(long res, long start,
+                                                    long size, long prot,
+                                                    long pgoff, long flags);
+void __sanitizer_syscall_pre_impl_msync(long start, long len, long flags);
+void __sanitizer_syscall_post_impl_msync(long res, long start, long len,
+                                         long flags);
+void __sanitizer_syscall_pre_impl_munmap(long addr, long len);
+void __sanitizer_syscall_post_impl_munmap(long res, long addr, long len);
+void __sanitizer_syscall_pre_impl_mlock(long start, long len);
+void __sanitizer_syscall_post_impl_mlock(long res, long start, long len);
+void __sanitizer_syscall_pre_impl_munlock(long start, long len);
+void __sanitizer_syscall_post_impl_munlock(long res, long start, long len);
+void __sanitizer_syscall_pre_impl_mlockall(long flags);
+void __sanitizer_syscall_post_impl_mlockall(long res, long flags);
+void __sanitizer_syscall_pre_impl_munlockall();
+void __sanitizer_syscall_post_impl_munlockall(long res);
+void __sanitizer_syscall_pre_impl_madvise(long start, long len, long behavior);
+void __sanitizer_syscall_post_impl_madvise(long res, long start, long len,
+                                           long behavior);
+void __sanitizer_syscall_pre_impl_mincore(long start, long len, long vec);
+void __sanitizer_syscall_post_impl_mincore(long res, long start, long len,
+                                           long vec);
+void __sanitizer_syscall_pre_impl_pivot_root(long new_root, long put_old);
+void __sanitizer_syscall_post_impl_pivot_root(long res, long new_root,
+                                              long put_old);
+void __sanitizer_syscall_pre_impl_chroot(long filename);
+void __sanitizer_syscall_post_impl_chroot(long res, long filename);
+void __sanitizer_syscall_pre_impl_mknod(long filename, long mode, long dev);
+void __sanitizer_syscall_post_impl_mknod(long res, long filename, long mode,
+                                         long dev);
+void __sanitizer_syscall_pre_impl_link(long oldname, long newname);
+void __sanitizer_syscall_post_impl_link(long res, long oldname, long newname);
+void __sanitizer_syscall_pre_impl_symlink(long old, long new_);
+void __sanitizer_syscall_post_impl_symlink(long res, long old, long new_);
+void __sanitizer_syscall_pre_impl_unlink(long pathname);
+void __sanitizer_syscall_post_impl_unlink(long res, long pathname);
+void __sanitizer_syscall_pre_impl_rename(long oldname, long newname);
+void __sanitizer_syscall_post_impl_rename(long res, long oldname, long newname);
+void __sanitizer_syscall_pre_impl_chmod(long filename, long mode);
+void __sanitizer_syscall_post_impl_chmod(long res, long filename, long mode);
+void __sanitizer_syscall_pre_impl_fchmod(long fd, long mode);
+void __sanitizer_syscall_post_impl_fchmod(long res, long fd, long mode);
+void __sanitizer_syscall_pre_impl_fcntl(long fd, long cmd, long arg);
+void __sanitizer_syscall_post_impl_fcntl(long res, long fd, long cmd, long arg);
+void __sanitizer_syscall_pre_impl_fcntl64(long fd, long cmd, long arg);
+void __sanitizer_syscall_post_impl_fcntl64(long res, long fd, long cmd,
+                                           long arg);
+void __sanitizer_syscall_pre_impl_pipe(long fildes);
+void __sanitizer_syscall_post_impl_pipe(long res, long fildes);
+void __sanitizer_syscall_pre_impl_pipe2(long fildes, long flags);
+void __sanitizer_syscall_post_impl_pipe2(long res, long fildes, long flags);
+void __sanitizer_syscall_pre_impl_dup(long fildes);
+void __sanitizer_syscall_post_impl_dup(long res, long fildes);
+void __sanitizer_syscall_pre_impl_dup2(long oldfd, long newfd);
+void __sanitizer_syscall_post_impl_dup2(long res, long oldfd, long newfd);
+void __sanitizer_syscall_pre_impl_dup3(long oldfd, long newfd, long flags);
+void __sanitizer_syscall_post_impl_dup3(long res, long oldfd, long newfd,
+                                        long flags);
+void __sanitizer_syscall_pre_impl_ioperm(long from, long num, long on);
+void __sanitizer_syscall_post_impl_ioperm(long res, long from, long num,
+                                          long on);
+void __sanitizer_syscall_pre_impl_ioctl(long fd, long cmd, long arg);
+void __sanitizer_syscall_post_impl_ioctl(long res, long fd, long cmd, long arg);
+void __sanitizer_syscall_pre_impl_flock(long fd, long cmd);
+void __sanitizer_syscall_post_impl_flock(long res, long fd, long cmd);
+void __sanitizer_syscall_pre_impl_io_setup(long nr_reqs, long ctx);
+void __sanitizer_syscall_post_impl_io_setup(long res, long nr_reqs, long ctx);
+void __sanitizer_syscall_pre_impl_io_destroy(long ctx);
+void __sanitizer_syscall_post_impl_io_destroy(long res, long ctx);
+void __sanitizer_syscall_pre_impl_io_getevents(long ctx_id, long min_nr,
+                                               long nr, long events,
+                                               long timeout);
+void __sanitizer_syscall_post_impl_io_getevents(long res, long ctx_id,
+                                                long min_nr, long nr,
+                                                long events, long timeout);
+void __sanitizer_syscall_pre_impl_io_submit(long ctx_id, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_io_submit(long res, long ctx_id, long arg1,
+                                             long arg2);
+void __sanitizer_syscall_pre_impl_io_cancel(long ctx_id, long iocb,
+                                            long result);
+void __sanitizer_syscall_post_impl_io_cancel(long res, long ctx_id, long iocb,
+                                             long result);
+void __sanitizer_syscall_pre_impl_sendfile(long out_fd, long in_fd, long offset,
+                                           long count);
+void __sanitizer_syscall_post_impl_sendfile(long res, long out_fd, long in_fd,
+                                            long offset, long count);
+void __sanitizer_syscall_pre_impl_sendfile64(long out_fd, long in_fd,
+                                             long offset, long count);
+void __sanitizer_syscall_post_impl_sendfile64(long res, long out_fd, long in_fd,
+                                              long offset, long count);
+void __sanitizer_syscall_pre_impl_readlink(long path, long buf, long bufsiz);
+void __sanitizer_syscall_post_impl_readlink(long res, long path, long buf,
+                                            long bufsiz);
+void __sanitizer_syscall_pre_impl_creat(long pathname, long mode);
+void __sanitizer_syscall_post_impl_creat(long res, long pathname, long mode);
+void __sanitizer_syscall_pre_impl_open(long filename, long flags, long mode);
+void __sanitizer_syscall_post_impl_open(long res, long filename, long flags,
+                                        long mode);
+void __sanitizer_syscall_pre_impl_close(long fd);
+void __sanitizer_syscall_post_impl_close(long res, long fd);
+void __sanitizer_syscall_pre_impl_access(long filename, long mode);
+void __sanitizer_syscall_post_impl_access(long res, long filename, long mode);
+void __sanitizer_syscall_pre_impl_vhangup();
+void __sanitizer_syscall_post_impl_vhangup(long res);
+void __sanitizer_syscall_pre_impl_chown(long filename, long user, long group);
+void __sanitizer_syscall_post_impl_chown(long res, long filename, long user,
+                                         long group);
+void __sanitizer_syscall_pre_impl_lchown(long filename, long user, long group);
+void __sanitizer_syscall_post_impl_lchown(long res, long filename, long user,
+                                          long group);
+void __sanitizer_syscall_pre_impl_fchown(long fd, long user, long group);
+void __sanitizer_syscall_post_impl_fchown(long res, long fd, long user,
+                                          long group);
+void __sanitizer_syscall_pre_impl_chown16(long filename, long user, long group);
+void __sanitizer_syscall_post_impl_chown16(long res, long filename, long user,
+                                           long group);
+void __sanitizer_syscall_pre_impl_lchown16(long filename, long user,
+                                           long group);
+void __sanitizer_syscall_post_impl_lchown16(long res, long filename, long user,
+                                            long group);
+void __sanitizer_syscall_pre_impl_fchown16(long fd, long user, long group);
+void __sanitizer_syscall_post_impl_fchown16(long res, long fd, long user,
+                                            long group);
+void __sanitizer_syscall_pre_impl_setregid16(long rgid, long egid);
+void __sanitizer_syscall_post_impl_setregid16(long res, long rgid, long egid);
+void __sanitizer_syscall_pre_impl_setgid16(long gid);
+void __sanitizer_syscall_post_impl_setgid16(long res, long gid);
+void __sanitizer_syscall_pre_impl_setreuid16(long ruid, long euid);
+void __sanitizer_syscall_post_impl_setreuid16(long res, long ruid, long euid);
+void __sanitizer_syscall_pre_impl_setuid16(long uid);
+void __sanitizer_syscall_post_impl_setuid16(long res, long uid);
+void __sanitizer_syscall_pre_impl_setresuid16(long ruid, long euid, long suid);
+void __sanitizer_syscall_post_impl_setresuid16(long res, long ruid, long euid,
+                                               long suid);
+void __sanitizer_syscall_pre_impl_getresuid16(long ruid, long euid, long suid);
+void __sanitizer_syscall_post_impl_getresuid16(long res, long ruid, long euid,
+                                               long suid);
+void __sanitizer_syscall_pre_impl_setresgid16(long rgid, long egid, long sgid);
+void __sanitizer_syscall_post_impl_setresgid16(long res, long rgid, long egid,
+                                               long sgid);
+void __sanitizer_syscall_pre_impl_getresgid16(long rgid, long egid, long sgid);
+void __sanitizer_syscall_post_impl_getresgid16(long res, long rgid, long egid,
+                                               long sgid);
+void __sanitizer_syscall_pre_impl_setfsuid16(long uid);
+void __sanitizer_syscall_post_impl_setfsuid16(long res, long uid);
+void __sanitizer_syscall_pre_impl_setfsgid16(long gid);
+void __sanitizer_syscall_post_impl_setfsgid16(long res, long gid);
+void __sanitizer_syscall_pre_impl_getgroups16(long gidsetsize, long grouplist);
+void __sanitizer_syscall_post_impl_getgroups16(long res, long gidsetsize,
+                                               long grouplist);
+void __sanitizer_syscall_pre_impl_setgroups16(long gidsetsize, long grouplist);
+void __sanitizer_syscall_post_impl_setgroups16(long res, long gidsetsize,
+                                               long grouplist);
+void __sanitizer_syscall_pre_impl_getuid16();
+void __sanitizer_syscall_post_impl_getuid16(long res);
+void __sanitizer_syscall_pre_impl_geteuid16();
+void __sanitizer_syscall_post_impl_geteuid16(long res);
+void __sanitizer_syscall_pre_impl_getgid16();
+void __sanitizer_syscall_post_impl_getgid16(long res);
+void __sanitizer_syscall_pre_impl_getegid16();
+void __sanitizer_syscall_post_impl_getegid16(long res);
+void __sanitizer_syscall_pre_impl_utime(long filename, long times);
+void __sanitizer_syscall_post_impl_utime(long res, long filename, long times);
+void __sanitizer_syscall_pre_impl_utimes(long filename, long utimes);
+void __sanitizer_syscall_post_impl_utimes(long res, long filename, long utimes);
+void __sanitizer_syscall_pre_impl_lseek(long fd, long offset, long origin);
+void __sanitizer_syscall_post_impl_lseek(long res, long fd, long offset,
+                                         long origin);
+void __sanitizer_syscall_pre_impl_llseek(long fd, long offset_high,
+                                         long offset_low, long result,
+                                         long origin);
+void __sanitizer_syscall_post_impl_llseek(long res, long fd, long offset_high,
+                                          long offset_low, long result,
+                                          long origin);
+void __sanitizer_syscall_pre_impl_read(long fd, long buf, long count);
+void __sanitizer_syscall_post_impl_read(long res, long fd, long buf,
+                                        long count);
+void __sanitizer_syscall_pre_impl_readv(long fd, long vec, long vlen);
+void __sanitizer_syscall_post_impl_readv(long res, long fd, long vec,
+                                         long vlen);
+void __sanitizer_syscall_pre_impl_write(long fd, long buf, long count);
+void __sanitizer_syscall_post_impl_write(long res, long fd, long buf,
+                                         long count);
+void __sanitizer_syscall_pre_impl_writev(long fd, long vec, long vlen);
+void __sanitizer_syscall_post_impl_writev(long res, long fd, long vec,
+                                          long vlen);
+
+#ifdef _LP64
+void __sanitizer_syscall_pre_impl_pread64(long fd, long buf, long count,
+                                          long pos);
+void __sanitizer_syscall_post_impl_pread64(long res, long fd, long buf,
+                                           long count, long pos);
+void __sanitizer_syscall_pre_impl_pwrite64(long fd, long buf, long count,
+                                           long pos);
+void __sanitizer_syscall_post_impl_pwrite64(long res, long fd, long buf,
+                                            long count, long pos);
+#else
+void __sanitizer_syscall_pre_impl_pread64(long fd, long buf, long count,
+                                          long pos0, long pos1);
+void __sanitizer_syscall_post_impl_pread64(long res, long fd, long buf,
+                                           long count, long pos0, long pos1);
+void __sanitizer_syscall_pre_impl_pwrite64(long fd, long buf, long count,
+                                           long pos0, long pos1);
+void __sanitizer_syscall_post_impl_pwrite64(long res, long fd, long buf,
+                                            long count, long pos0, long pos1);
+#endif
+
+void __sanitizer_syscall_pre_impl_preadv(long fd, long vec, long vlen,
+                                         long pos_l, long pos_h);
+void __sanitizer_syscall_post_impl_preadv(long res, long fd, long vec,
+                                          long vlen, long pos_l, long pos_h);
+void __sanitizer_syscall_pre_impl_pwritev(long fd, long vec, long vlen,
+                                          long pos_l, long pos_h);
+void __sanitizer_syscall_post_impl_pwritev(long res, long fd, long vec,
+                                           long vlen, long pos_l, long pos_h);
+void __sanitizer_syscall_pre_impl_getcwd(long buf, long size);
+void __sanitizer_syscall_post_impl_getcwd(long res, long buf, long size);
+void __sanitizer_syscall_pre_impl_mkdir(long pathname, long mode);
+void __sanitizer_syscall_post_impl_mkdir(long res, long pathname, long mode);
+void __sanitizer_syscall_pre_impl_chdir(long filename);
+void __sanitizer_syscall_post_impl_chdir(long res, long filename);
+void __sanitizer_syscall_pre_impl_fchdir(long fd);
+void __sanitizer_syscall_post_impl_fchdir(long res, long fd);
+void __sanitizer_syscall_pre_impl_rmdir(long pathname);
+void __sanitizer_syscall_post_impl_rmdir(long res, long pathname);
+void __sanitizer_syscall_pre_impl_lookup_dcookie(long cookie64, long buf,
+                                                 long len);
+void __sanitizer_syscall_post_impl_lookup_dcookie(long res, long cookie64,
+                                                  long buf, long len);
+void __sanitizer_syscall_pre_impl_quotactl(long cmd, long special, long id,
+                                           long addr);
+void __sanitizer_syscall_post_impl_quotactl(long res, long cmd, long special,
+                                            long id, long addr);
+void __sanitizer_syscall_pre_impl_getdents(long fd, long dirent, long count);
+void __sanitizer_syscall_post_impl_getdents(long res, long fd, long dirent,
+                                            long count);
+void __sanitizer_syscall_pre_impl_getdents64(long fd, long dirent, long count);
+void __sanitizer_syscall_post_impl_getdents64(long res, long fd, long dirent,
+                                              long count);
+void __sanitizer_syscall_pre_impl_setsockopt(long fd, long level, long optname,
+                                             long optval, long optlen);
+void __sanitizer_syscall_post_impl_setsockopt(long res, long fd, long level,
+                                              long optname, long optval,
+                                              long optlen);
+void __sanitizer_syscall_pre_impl_getsockopt(long fd, long level, long optname,
+                                             long optval, long optlen);
+void __sanitizer_syscall_post_impl_getsockopt(long res, long fd, long level,
+                                              long optname, long optval,
+                                              long optlen);
+void __sanitizer_syscall_pre_impl_bind(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_bind(long res, long arg0, long arg1,
+                                        long arg2);
+void __sanitizer_syscall_pre_impl_connect(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_connect(long res, long arg0, long arg1,
+                                           long arg2);
+void __sanitizer_syscall_pre_impl_accept(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_accept(long res, long arg0, long arg1,
+                                          long arg2);
+void __sanitizer_syscall_pre_impl_accept4(long arg0, long arg1, long arg2,
+                                          long arg3);
+void __sanitizer_syscall_post_impl_accept4(long res, long arg0, long arg1,
+                                           long arg2, long arg3);
+void __sanitizer_syscall_pre_impl_getsockname(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_getsockname(long res, long arg0, long arg1,
+                                               long arg2);
+void __sanitizer_syscall_pre_impl_getpeername(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_getpeername(long res, long arg0, long arg1,
+                                               long arg2);
+void __sanitizer_syscall_pre_impl_send(long arg0, long arg1, long arg2,
+                                       long arg3);
+void __sanitizer_syscall_post_impl_send(long res, long arg0, long arg1,
+                                        long arg2, long arg3);
+void __sanitizer_syscall_pre_impl_sendto(long arg0, long arg1, long arg2,
+                                         long arg3, long arg4, long arg5);
+void __sanitizer_syscall_post_impl_sendto(long res, long arg0, long arg1,
+                                          long arg2, long arg3, long arg4,
+                                          long arg5);
+void __sanitizer_syscall_pre_impl_sendmsg(long fd, long msg, long flags);
+void __sanitizer_syscall_post_impl_sendmsg(long res, long fd, long msg,
+                                           long flags);
+void __sanitizer_syscall_pre_impl_sendmmsg(long fd, long msg, long vlen,
+                                           long flags);
+void __sanitizer_syscall_post_impl_sendmmsg(long res, long fd, long msg,
+                                            long vlen, long flags);
+void __sanitizer_syscall_pre_impl_recv(long arg0, long arg1, long arg2,
+                                       long arg3);
+void __sanitizer_syscall_post_impl_recv(long res, long arg0, long arg1,
+                                        long arg2, long arg3);
+void __sanitizer_syscall_pre_impl_recvfrom(long arg0, long arg1, long arg2,
+                                           long arg3, long arg4, long arg5);
+void __sanitizer_syscall_post_impl_recvfrom(long res, long arg0, long arg1,
+                                            long arg2, long arg3, long arg4,
+                                            long arg5);
+void __sanitizer_syscall_pre_impl_recvmsg(long fd, long msg, long flags);
+void __sanitizer_syscall_post_impl_recvmsg(long res, long fd, long msg,
+                                           long flags);
+void __sanitizer_syscall_pre_impl_recvmmsg(long fd, long msg, long vlen,
+                                           long flags, long timeout);
+void __sanitizer_syscall_post_impl_recvmmsg(long res, long fd, long msg,
+                                            long vlen, long flags,
+                                            long timeout);
+void __sanitizer_syscall_pre_impl_socket(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_socket(long res, long arg0, long arg1,
+                                          long arg2);
+void __sanitizer_syscall_pre_impl_socketpair(long arg0, long arg1, long arg2,
+                                             long arg3);
+void __sanitizer_syscall_post_impl_socketpair(long res, long arg0, long arg1,
+                                              long arg2, long arg3);
+void __sanitizer_syscall_pre_impl_socketcall(long call, long args);
+void __sanitizer_syscall_post_impl_socketcall(long res, long call, long args);
+void __sanitizer_syscall_pre_impl_listen(long arg0, long arg1);
+void __sanitizer_syscall_post_impl_listen(long res, long arg0, long arg1);
+void __sanitizer_syscall_pre_impl_poll(long ufds, long nfds, long timeout);
+void __sanitizer_syscall_post_impl_poll(long res, long ufds, long nfds,
+                                        long timeout);
+void __sanitizer_syscall_pre_impl_select(long n, long inp, long outp, long exp,
+                                         long tvp);
+void __sanitizer_syscall_post_impl_select(long res, long n, long inp, long outp,
+                                          long exp, long tvp);
+void __sanitizer_syscall_pre_impl_old_select(long arg);
+void __sanitizer_syscall_post_impl_old_select(long res, long arg);
+void __sanitizer_syscall_pre_impl_epoll_create(long size);
+void __sanitizer_syscall_post_impl_epoll_create(long res, long size);
+void __sanitizer_syscall_pre_impl_epoll_create1(long flags);
+void __sanitizer_syscall_post_impl_epoll_create1(long res, long flags);
+void __sanitizer_syscall_pre_impl_epoll_ctl(long epfd, long op, long fd,
+                                            long event);
+void __sanitizer_syscall_post_impl_epoll_ctl(long res, long epfd, long op,
+                                             long fd, long event);
+void __sanitizer_syscall_pre_impl_epoll_wait(long epfd, long events,
+                                             long maxevents, long timeout);
+void __sanitizer_syscall_post_impl_epoll_wait(long res, long epfd, long events,
+                                              long maxevents, long timeout);
+void __sanitizer_syscall_pre_impl_epoll_pwait(long epfd, long events,
+                                              long maxevents, long timeout,
+                                              long sigmask, long sigsetsize);
+void __sanitizer_syscall_post_impl_epoll_pwait(long res, long epfd, long events,
+                                               long maxevents, long timeout,
+                                               long sigmask, long sigsetsize);
+void __sanitizer_syscall_pre_impl_gethostname(long name, long len);
+void __sanitizer_syscall_post_impl_gethostname(long res, long name, long len);
+void __sanitizer_syscall_pre_impl_sethostname(long name, long len);
+void __sanitizer_syscall_post_impl_sethostname(long res, long name, long len);
+void __sanitizer_syscall_pre_impl_setdomainname(long name, long len);
+void __sanitizer_syscall_post_impl_setdomainname(long res, long name, long len);
+void __sanitizer_syscall_pre_impl_newuname(long name);
+void __sanitizer_syscall_post_impl_newuname(long res, long name);
+void __sanitizer_syscall_pre_impl_uname(long arg0);
+void __sanitizer_syscall_post_impl_uname(long res, long arg0);
+void __sanitizer_syscall_pre_impl_olduname(long arg0);
+void __sanitizer_syscall_post_impl_olduname(long res, long arg0);
+void __sanitizer_syscall_pre_impl_getrlimit(long resource, long rlim);
+void __sanitizer_syscall_post_impl_getrlimit(long res, long resource,
+                                             long rlim);
+void __sanitizer_syscall_pre_impl_old_getrlimit(long resource, long rlim);
+void __sanitizer_syscall_post_impl_old_getrlimit(long res, long resource,
+                                                 long rlim);
+void __sanitizer_syscall_pre_impl_setrlimit(long resource, long rlim);
+void __sanitizer_syscall_post_impl_setrlimit(long res, long resource,
+                                             long rlim);
+void __sanitizer_syscall_pre_impl_prlimit64(long pid, long resource,
+                                            long new_rlim, long old_rlim);
+void __sanitizer_syscall_post_impl_prlimit64(long res, long pid, long resource,
+                                             long new_rlim, long old_rlim);
+void __sanitizer_syscall_pre_impl_getrusage(long who, long ru);
+void __sanitizer_syscall_post_impl_getrusage(long res, long who, long ru);
+void __sanitizer_syscall_pre_impl_umask(long mask);
+void __sanitizer_syscall_post_impl_umask(long res, long mask);
+void __sanitizer_syscall_pre_impl_msgget(long key, long msgflg);
+void __sanitizer_syscall_post_impl_msgget(long res, long key, long msgflg);
+void __sanitizer_syscall_pre_impl_msgsnd(long msqid, long msgp, long msgsz,
+                                         long msgflg);
+void __sanitizer_syscall_post_impl_msgsnd(long res, long msqid, long msgp,
+                                          long msgsz, long msgflg);
+void __sanitizer_syscall_pre_impl_msgrcv(long msqid, long msgp, long msgsz,
+                                         long msgtyp, long msgflg);
+void __sanitizer_syscall_post_impl_msgrcv(long res, long msqid, long msgp,
+                                          long msgsz, long msgtyp, long msgflg);
+void __sanitizer_syscall_pre_impl_msgctl(long msqid, long cmd, long buf);
+void __sanitizer_syscall_post_impl_msgctl(long res, long msqid, long cmd,
+                                          long buf);
+void __sanitizer_syscall_pre_impl_semget(long key, long nsems, long semflg);
+void __sanitizer_syscall_post_impl_semget(long res, long key, long nsems,
+                                          long semflg);
+void __sanitizer_syscall_pre_impl_semop(long semid, long sops, long nsops);
+void __sanitizer_syscall_post_impl_semop(long res, long semid, long sops,
+                                         long nsops);
+void __sanitizer_syscall_pre_impl_semctl(long semid, long semnum, long cmd,
+                                         long arg);
+void __sanitizer_syscall_post_impl_semctl(long res, long semid, long semnum,
+                                          long cmd, long arg);
+void __sanitizer_syscall_pre_impl_semtimedop(long semid, long sops, long nsops,
+                                             long timeout);
+void __sanitizer_syscall_post_impl_semtimedop(long res, long semid, long sops,
+                                              long nsops, long timeout);
+void __sanitizer_syscall_pre_impl_shmat(long shmid, long shmaddr, long shmflg);
+void __sanitizer_syscall_post_impl_shmat(long res, long shmid, long shmaddr,
+                                         long shmflg);
+void __sanitizer_syscall_pre_impl_shmget(long key, long size, long flag);
+void __sanitizer_syscall_post_impl_shmget(long res, long key, long size,
+                                          long flag);
+void __sanitizer_syscall_pre_impl_shmdt(long shmaddr);
+void __sanitizer_syscall_post_impl_shmdt(long res, long shmaddr);
+void __sanitizer_syscall_pre_impl_shmctl(long shmid, long cmd, long buf);
+void __sanitizer_syscall_post_impl_shmctl(long res, long shmid, long cmd,
+                                          long buf);
+void __sanitizer_syscall_pre_impl_ipc(long call, long first, long second,
+                                      long third, long ptr, long fifth);
+void __sanitizer_syscall_post_impl_ipc(long res, long call, long first,
+                                       long second, long third, long ptr,
+                                       long fifth);
+void __sanitizer_syscall_pre_impl_mq_open(long name, long oflag, long mode,
+                                          long attr);
+void __sanitizer_syscall_post_impl_mq_open(long res, long name, long oflag,
+                                           long mode, long attr);
+void __sanitizer_syscall_pre_impl_mq_unlink(long name);
+void __sanitizer_syscall_post_impl_mq_unlink(long res, long name);
+void __sanitizer_syscall_pre_impl_mq_timedsend(long mqdes, long msg_ptr,
+                                               long msg_len, long msg_prio,
+                                               long abs_timeout);
+void __sanitizer_syscall_post_impl_mq_timedsend(long res, long mqdes,
+                                                long msg_ptr, long msg_len,
+                                                long msg_prio,
+                                                long abs_timeout);
+void __sanitizer_syscall_pre_impl_mq_timedreceive(long mqdes, long msg_ptr,
+                                                  long msg_len, long msg_prio,
+                                                  long abs_timeout);
+void __sanitizer_syscall_post_impl_mq_timedreceive(long res, long mqdes,
+                                                   long msg_ptr, long msg_len,
+                                                   long msg_prio,
+                                                   long abs_timeout);
+void __sanitizer_syscall_pre_impl_mq_notify(long mqdes, long notification);
+void __sanitizer_syscall_post_impl_mq_notify(long res, long mqdes,
+                                             long notification);
+void __sanitizer_syscall_pre_impl_mq_getsetattr(long mqdes, long mqstat,
+                                                long omqstat);
+void __sanitizer_syscall_post_impl_mq_getsetattr(long res, long mqdes,
+                                                 long mqstat, long omqstat);
+void __sanitizer_syscall_pre_impl_pciconfig_iobase(long which, long bus,
+                                                   long devfn);
+void __sanitizer_syscall_post_impl_pciconfig_iobase(long res, long which,
+                                                    long bus, long devfn);
+void __sanitizer_syscall_pre_impl_pciconfig_read(long bus, long dfn, long off,
+                                                 long len, long buf);
+void __sanitizer_syscall_post_impl_pciconfig_read(long res, long bus, long dfn,
+                                                  long off, long len, long buf);
+void __sanitizer_syscall_pre_impl_pciconfig_write(long bus, long dfn, long off,
+                                                  long len, long buf);
+void __sanitizer_syscall_post_impl_pciconfig_write(long res, long bus, long dfn,
+                                                   long off, long len,
+                                                   long buf);
+void __sanitizer_syscall_pre_impl_swapon(long specialfile, long swap_flags);
+void __sanitizer_syscall_post_impl_swapon(long res, long specialfile,
+                                          long swap_flags);
+void __sanitizer_syscall_pre_impl_swapoff(long specialfile);
+void __sanitizer_syscall_post_impl_swapoff(long res, long specialfile);
+void __sanitizer_syscall_pre_impl_sysctl(long args);
+void __sanitizer_syscall_post_impl_sysctl(long res, long args);
+void __sanitizer_syscall_pre_impl_sysinfo(long info);
+void __sanitizer_syscall_post_impl_sysinfo(long res, long info);
+void __sanitizer_syscall_pre_impl_sysfs(long option, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_sysfs(long res, long option, long arg1,
+                                         long arg2);
+void __sanitizer_syscall_pre_impl_syslog(long type, long buf, long len);
+void __sanitizer_syscall_post_impl_syslog(long res, long type, long buf,
+                                          long len);
+void __sanitizer_syscall_pre_impl_uselib(long library);
+void __sanitizer_syscall_post_impl_uselib(long res, long library);
+void __sanitizer_syscall_pre_impl_ni_syscall();
+void __sanitizer_syscall_post_impl_ni_syscall(long res);
+void __sanitizer_syscall_pre_impl_ptrace(long request, long pid, long addr,
+                                         long data);
+void __sanitizer_syscall_post_impl_ptrace(long res, long request, long pid,
+                                          long addr, long data);
+void __sanitizer_syscall_pre_impl_add_key(long _type, long _description,
+                                          long _payload, long plen,
+                                          long destringid);
+void __sanitizer_syscall_post_impl_add_key(long res, long _type,
+                                           long _description, long _payload,
+                                           long plen, long destringid);
+void __sanitizer_syscall_pre_impl_request_key(long _type, long _description,
+                                              long _callout_info,
+                                              long destringid);
+void __sanitizer_syscall_post_impl_request_key(long res, long _type,
+                                               long _description,
+                                               long _callout_info,
+                                               long destringid);
+void __sanitizer_syscall_pre_impl_keyctl(long cmd, long arg2, long arg3,
+                                         long arg4, long arg5);
+void __sanitizer_syscall_post_impl_keyctl(long res, long cmd, long arg2,
+                                          long arg3, long arg4, long arg5);
+void __sanitizer_syscall_pre_impl_ioprio_set(long which, long who, long ioprio);
+void __sanitizer_syscall_post_impl_ioprio_set(long res, long which, long who,
+                                              long ioprio);
+void __sanitizer_syscall_pre_impl_ioprio_get(long which, long who);
+void __sanitizer_syscall_post_impl_ioprio_get(long res, long which, long who);
+void __sanitizer_syscall_pre_impl_set_mempolicy(long mode, long nmask,
+                                                long maxnode);
+void __sanitizer_syscall_post_impl_set_mempolicy(long res, long mode,
+                                                 long nmask, long maxnode);
+void __sanitizer_syscall_pre_impl_migrate_pages(long pid, long maxnode,
+                                                long from, long to);
+void __sanitizer_syscall_post_impl_migrate_pages(long res, long pid,
+                                                 long maxnode, long from,
+                                                 long to);
+void __sanitizer_syscall_pre_impl_move_pages(long pid, long nr_pages,
+                                             long pages, long nodes,
+                                             long status, long flags);
+void __sanitizer_syscall_post_impl_move_pages(long res, long pid, long nr_pages,
+                                              long pages, long nodes,
+                                              long status, long flags);
+void __sanitizer_syscall_pre_impl_mbind(long start, long len, long mode,
+                                        long nmask, long maxnode, long flags);
+void __sanitizer_syscall_post_impl_mbind(long res, long start, long len,
+                                         long mode, long nmask, long maxnode,
+                                         long flags);
+void __sanitizer_syscall_pre_impl_get_mempolicy(long policy, long nmask,
+                                                long maxnode, long addr,
+                                                long flags);
+void __sanitizer_syscall_post_impl_get_mempolicy(long res, long policy,
+                                                 long nmask, long maxnode,
+                                                 long addr, long flags);
+void __sanitizer_syscall_pre_impl_inotify_init();
+void __sanitizer_syscall_post_impl_inotify_init(long res);
+void __sanitizer_syscall_pre_impl_inotify_init1(long flags);
+void __sanitizer_syscall_post_impl_inotify_init1(long res, long flags);
+void __sanitizer_syscall_pre_impl_inotify_add_watch(long fd, long path,
+                                                    long mask);
+void __sanitizer_syscall_post_impl_inotify_add_watch(long res, long fd,
+                                                     long path, long mask);
+void __sanitizer_syscall_pre_impl_inotify_rm_watch(long fd, long wd);
+void __sanitizer_syscall_post_impl_inotify_rm_watch(long res, long fd, long wd);
+void __sanitizer_syscall_pre_impl_spu_run(long fd, long unpc, long ustatus);
+void __sanitizer_syscall_post_impl_spu_run(long res, long fd, long unpc,
+                                           long ustatus);
+void __sanitizer_syscall_pre_impl_spu_create(long name, long flags, long mode,
+                                             long fd);
+void __sanitizer_syscall_post_impl_spu_create(long res, long name, long flags,
+                                              long mode, long fd);
+void __sanitizer_syscall_pre_impl_mknodat(long dfd, long filename, long mode,
+                                          long dev);
+void __sanitizer_syscall_post_impl_mknodat(long res, long dfd, long filename,
+                                           long mode, long dev);
+void __sanitizer_syscall_pre_impl_mkdirat(long dfd, long pathname, long mode);
+void __sanitizer_syscall_post_impl_mkdirat(long res, long dfd, long pathname,
+                                           long mode);
+void __sanitizer_syscall_pre_impl_unlinkat(long dfd, long pathname, long flag);
+void __sanitizer_syscall_post_impl_unlinkat(long res, long dfd, long pathname,
+                                            long flag);
+void __sanitizer_syscall_pre_impl_symlinkat(long oldname, long newdfd,
+                                            long newname);
+void __sanitizer_syscall_post_impl_symlinkat(long res, long oldname,
+                                             long newdfd, long newname);
+void __sanitizer_syscall_pre_impl_linkat(long olddfd, long oldname, long newdfd,
+                                         long newname, long flags);
+void __sanitizer_syscall_post_impl_linkat(long res, long olddfd, long oldname,
+                                          long newdfd, long newname,
+                                          long flags);
+void __sanitizer_syscall_pre_impl_renameat(long olddfd, long oldname,
+                                           long newdfd, long newname);
+void __sanitizer_syscall_post_impl_renameat(long res, long olddfd, long oldname,
+                                            long newdfd, long newname);
+void __sanitizer_syscall_pre_impl_futimesat(long dfd, long filename,
+                                            long utimes);
+void __sanitizer_syscall_post_impl_futimesat(long res, long dfd, long filename,
+                                             long utimes);
+void __sanitizer_syscall_pre_impl_faccessat(long dfd, long filename, long mode);
+void __sanitizer_syscall_post_impl_faccessat(long res, long dfd, long filename,
+                                             long mode);
+void __sanitizer_syscall_pre_impl_fchmodat(long dfd, long filename, long mode);
+void __sanitizer_syscall_post_impl_fchmodat(long res, long dfd, long filename,
+                                            long mode);
+void __sanitizer_syscall_pre_impl_fchownat(long dfd, long filename, long user,
+                                           long group, long flag);
+void __sanitizer_syscall_post_impl_fchownat(long res, long dfd, long filename,
+                                            long user, long group, long flag);
+void __sanitizer_syscall_pre_impl_openat(long dfd, long filename, long flags,
+                                         long mode);
+void __sanitizer_syscall_post_impl_openat(long res, long dfd, long filename,
+                                          long flags, long mode);
+void __sanitizer_syscall_pre_impl_newfstatat(long dfd, long filename,
+                                             long statbuf, long flag);
+void __sanitizer_syscall_post_impl_newfstatat(long res, long dfd, long filename,
+                                              long statbuf, long flag);
+void __sanitizer_syscall_pre_impl_fstatat64(long dfd, long filename,
+                                            long statbuf, long flag);
+void __sanitizer_syscall_post_impl_fstatat64(long res, long dfd, long filename,
+                                             long statbuf, long flag);
+void __sanitizer_syscall_pre_impl_readlinkat(long dfd, long path, long buf,
+                                             long bufsiz);
+void __sanitizer_syscall_post_impl_readlinkat(long res, long dfd, long path,
+                                              long buf, long bufsiz);
+void __sanitizer_syscall_pre_impl_utimensat(long dfd, long filename,
+                                            long utimes, long flags);
+void __sanitizer_syscall_post_impl_utimensat(long res, long dfd, long filename,
+                                             long utimes, long flags);
+void __sanitizer_syscall_pre_impl_unshare(long unshare_flags);
+void __sanitizer_syscall_post_impl_unshare(long res, long unshare_flags);
+void __sanitizer_syscall_pre_impl_splice(long fd_in, long off_in, long fd_out,
+                                         long off_out, long len, long flags);
+void __sanitizer_syscall_post_impl_splice(long res, long fd_in, long off_in,
+                                          long fd_out, long off_out, long len,
+                                          long flags);
+void __sanitizer_syscall_pre_impl_vmsplice(long fd, long iov, long nr_segs,
+                                           long flags);
+void __sanitizer_syscall_post_impl_vmsplice(long res, long fd, long iov,
+                                            long nr_segs, long flags);
+void __sanitizer_syscall_pre_impl_tee(long fdin, long fdout, long len,
+                                      long flags);
+void __sanitizer_syscall_post_impl_tee(long res, long fdin, long fdout,
+                                       long len, long flags);
+void __sanitizer_syscall_pre_impl_get_robust_list(long pid, long head_ptr,
+                                                  long len_ptr);
+void __sanitizer_syscall_post_impl_get_robust_list(long res, long pid,
+                                                   long head_ptr, long len_ptr);
+void __sanitizer_syscall_pre_impl_set_robust_list(long head, long len);
+void __sanitizer_syscall_post_impl_set_robust_list(long res, long head,
+                                                   long len);
+void __sanitizer_syscall_pre_impl_getcpu(long cpu, long node, long cache);
+void __sanitizer_syscall_post_impl_getcpu(long res, long cpu, long node,
+                                          long cache);
+void __sanitizer_syscall_pre_impl_signalfd(long ufd, long user_mask,
+                                           long sizemask);
+void __sanitizer_syscall_post_impl_signalfd(long res, long ufd, long user_mask,
+                                            long sizemask);
+void __sanitizer_syscall_pre_impl_signalfd4(long ufd, long user_mask,
+                                            long sizemask, long flags);
+void __sanitizer_syscall_post_impl_signalfd4(long res, long ufd, long user_mask,
+                                             long sizemask, long flags);
+void __sanitizer_syscall_pre_impl_timerfd_create(long clockid, long flags);
+void __sanitizer_syscall_post_impl_timerfd_create(long res, long clockid,
+                                                  long flags);
+void __sanitizer_syscall_pre_impl_timerfd_settime(long ufd, long flags,
+                                                  long utmr, long otmr);
+void __sanitizer_syscall_post_impl_timerfd_settime(long res, long ufd,
+                                                   long flags, long utmr,
+                                                   long otmr);
+void __sanitizer_syscall_pre_impl_timerfd_gettime(long ufd, long otmr);
+void __sanitizer_syscall_post_impl_timerfd_gettime(long res, long ufd,
+                                                   long otmr);
+void __sanitizer_syscall_pre_impl_eventfd(long count);
+void __sanitizer_syscall_post_impl_eventfd(long res, long count);
+void __sanitizer_syscall_pre_impl_eventfd2(long count, long flags);
+void __sanitizer_syscall_post_impl_eventfd2(long res, long count, long flags);
+void __sanitizer_syscall_pre_impl_old_readdir(long arg0, long arg1, long arg2);
+void __sanitizer_syscall_post_impl_old_readdir(long res, long arg0, long arg1,
+                                               long arg2);
+void __sanitizer_syscall_pre_impl_pselect6(long arg0, long arg1, long arg2,
+                                           long arg3, long arg4, long arg5);
+void __sanitizer_syscall_post_impl_pselect6(long res, long arg0, long arg1,
+                                            long arg2, long arg3, long arg4,
+                                            long arg5);
+void __sanitizer_syscall_pre_impl_ppoll(long arg0, long arg1, long arg2,
+                                        long arg3, long arg4);
+void __sanitizer_syscall_post_impl_ppoll(long res, long arg0, long arg1,
+                                         long arg2, long arg3, long arg4);
+void __sanitizer_syscall_pre_impl_fanotify_init(long flags, long event_f_flags);
+void __sanitizer_syscall_post_impl_fanotify_init(long res, long flags,
+                                                 long event_f_flags);
+void __sanitizer_syscall_pre_impl_fanotify_mark(long fanotify_fd, long flags,
+                                                long mask, long fd,
+                                                long pathname);
+void __sanitizer_syscall_post_impl_fanotify_mark(long res, long fanotify_fd,
+                                                 long flags, long mask, long fd,
+                                                 long pathname);
+void __sanitizer_syscall_pre_impl_syncfs(long fd);
+void __sanitizer_syscall_post_impl_syncfs(long res, long fd);
+void __sanitizer_syscall_pre_impl_perf_event_open(long attr_uptr, long pid,
+                                                  long cpu, long group_fd,
+                                                  long flags);
+void __sanitizer_syscall_post_impl_perf_event_open(long res, long attr_uptr,
+                                                   long pid, long cpu,
+                                                   long group_fd, long flags);
+void __sanitizer_syscall_pre_impl_mmap_pgoff(long addr, long len, long prot,
+                                             long flags, long fd, long pgoff);
+void __sanitizer_syscall_post_impl_mmap_pgoff(long res, long addr, long len,
+                                              long prot, long flags, long fd,
+                                              long pgoff);
+void __sanitizer_syscall_pre_impl_old_mmap(long arg);
+void __sanitizer_syscall_post_impl_old_mmap(long res, long arg);
+void __sanitizer_syscall_pre_impl_name_to_handle_at(long dfd, long name,
+                                                    long handle, long mnt_id,
+                                                    long flag);
+void __sanitizer_syscall_post_impl_name_to_handle_at(long res, long dfd,
+                                                     long name, long handle,
+                                                     long mnt_id, long flag);
+void __sanitizer_syscall_pre_impl_open_by_handle_at(long mountdirfd,
+                                                    long handle, long flags);
+void __sanitizer_syscall_post_impl_open_by_handle_at(long res, long mountdirfd,
+                                                     long handle, long flags);
+void __sanitizer_syscall_pre_impl_setns(long fd, long nstype);
+void __sanitizer_syscall_post_impl_setns(long res, long fd, long nstype);
+void __sanitizer_syscall_pre_impl_process_vm_readv(long pid, long lvec,
+                                                   long liovcnt, long rvec,
+                                                   long riovcnt, long flags);
+void __sanitizer_syscall_post_impl_process_vm_readv(long res, long pid,
+                                                    long lvec, long liovcnt,
+                                                    long rvec, long riovcnt,
+                                                    long flags);
+void __sanitizer_syscall_pre_impl_process_vm_writev(long pid, long lvec,
+                                                    long liovcnt, long rvec,
+                                                    long riovcnt, long flags);
+void __sanitizer_syscall_post_impl_process_vm_writev(long res, long pid,
+                                                     long lvec, long liovcnt,
+                                                     long rvec, long riovcnt,
+                                                     long flags);
+void __sanitizer_syscall_pre_impl_fork();
+void __sanitizer_syscall_post_impl_fork(long res);
+void __sanitizer_syscall_pre_impl_vfork();
+void __sanitizer_syscall_post_impl_vfork(long res);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // SANITIZER_LINUX_SYSCALL_HOOKS_H
diff --git a/compiler-rt/include/sanitizer/lsan_interface.h b/compiler-rt/include/sanitizer/lsan_interface.h
new file mode 100644
index 0000000..8fb8e75
--- /dev/null
+++ b/compiler-rt/include/sanitizer/lsan_interface.h
@@ -0,0 +1,84 @@
+//===-- sanitizer/lsan_interface.h ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+//
+// Public interface header.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_LSAN_INTERFACE_H
+#define SANITIZER_LSAN_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  // Allocations made between calls to __lsan_disable() and __lsan_enable() will
+  // be treated as non-leaks. Disable/enable pairs may be nested.
+  void __lsan_disable();
+  void __lsan_enable();
+
+  // The heap object into which p points will be treated as a non-leak.
+  void __lsan_ignore_object(const void *p);
+
+  // Memory regions registered through this interface will be treated as sources
+  // of live pointers during leak checking. Useful if you store pointers in
+  // mapped memory.
+  // Points of note:
+  // - __lsan_unregister_root_region() must be called with the same pointer and
+  // size that have earlier been passed to __lsan_register_root_region()
+  // - LSan will skip any inaccessible memory when scanning a root region. E.g.,
+  // if you map memory within a larger region that you have mprotect'ed, you can
+  // register the entire large region.
+  // - the implementation is not optimized for performance. This interface is
+  // intended to be used for a small number of relatively static regions.
+  void __lsan_register_root_region(const void *p, size_t size);
+  void __lsan_unregister_root_region(const void *p, size_t size);
+
+  // Check for leaks now. This function behaves identically to the default
+  // end-of-process leak check. In particular, it will terminate the process if
+  // leaks are found and the exitcode runtime flag is non-zero.
+  // Subsequent calls to this function will have no effect and end-of-process
+  // leak check will not run. Effectively, end-of-process leak check is moved to
+  // the time of first invocation of this function.
+  // By calling this function early during process shutdown, you can instruct
+  // LSan to ignore shutdown-only leaks which happen later on.
+  void __lsan_do_leak_check();
+
+  // Check for leaks now. Returns zero if no leaks have been found or if leak
+  // detection is disabled, non-zero otherwise.
+  // This function may be called repeatedly, e.g. to periodically check a
+  // long-running process. It prints a leak report if appropriate, but does not
+  // terminate the process. It does not affect the behavior of
+  // __lsan_do_leak_check() or the end-of-process leak check, and is not
+  // affected by them.
+  int __lsan_do_recoverable_leak_check();
+
+  // The user may optionally provide this function to disallow leak checking
+  // for the program it is linked into (if the return value is non-zero). This
+  // function must be defined as returning a constant value; any behavior beyond
+  // that is unsupported.
+  int __lsan_is_turned_off();
+
+  // This function may be optionally provided by the user and should return
+  // a string containing LSan suppressions.
+  const char *__lsan_default_suppressions();
+#ifdef __cplusplus
+}  // extern "C"
+
+namespace __lsan {
+class ScopedDisabler {
+ public:
+  ScopedDisabler() { __lsan_disable(); }
+  ~ScopedDisabler() { __lsan_enable(); }
+};
+}  // namespace __lsan
+#endif
+
+#endif  // SANITIZER_LSAN_INTERFACE_H
diff --git a/compiler-rt/include/sanitizer/msan_interface.h b/compiler-rt/include/sanitizer/msan_interface.h
new file mode 100644
index 0000000..6d6a376
--- /dev/null
+++ b/compiler-rt/include/sanitizer/msan_interface.h
@@ -0,0 +1,111 @@
+//===-- msan_interface.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Public interface header.
+//===----------------------------------------------------------------------===//
+#ifndef MSAN_INTERFACE_H
+#define MSAN_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  /* Set raw origin for the memory range. */
+  void __msan_set_origin(const volatile void *a, size_t size, uint32_t origin);
+
+  /* Get raw origin for an address. */
+  uint32_t __msan_get_origin(const volatile void *a);
+
+  /* Test that this_id is a descendant of prev_id (or they are simply equal).
+   * "descendant" here means they are part of the same chain, created with
+   * __msan_chain_origin. */
+  int __msan_origin_is_descendant_or_same(uint32_t this_id, uint32_t prev_id);
+
+  /* Returns non-zero if tracking origins. */
+  int __msan_get_track_origins();
+
+  /* Returns the origin id of the latest UMR in the calling thread. */
+  uint32_t __msan_get_umr_origin();
+
+  /* Make memory region fully initialized (without changing its contents). */
+  void __msan_unpoison(const volatile void *a, size_t size);
+
+  /* Make a null-terminated string fully initialized (without changing its
+     contents). */
+  void __msan_unpoison_string(const volatile char *a);
+
+  /* Make memory region fully uninitialized (without changing its contents).
+     This is a legacy interface that does not update origin information. Use
+     __msan_allocated_memory() instead. */
+  void __msan_poison(const volatile void *a, size_t size);
+
+  /* Make memory region partially uninitialized (without changing its contents).
+   */
+  void __msan_partial_poison(const volatile void *data, void *shadow,
+                             size_t size);
+
+  /* Returns the offset of the first (at least partially) poisoned byte in the
+     memory range, or -1 if the whole range is good. */
+  intptr_t __msan_test_shadow(const volatile void *x, size_t size);
+
+  /* Checks that memory range is fully initialized, and reports an error if it
+   * is not. */
+  void __msan_check_mem_is_initialized(const volatile void *x, size_t size);
+
+  /* For testing:
+     __msan_set_expect_umr(1);
+     ... some buggy code ...
+     __msan_set_expect_umr(0);
+     The last line will verify that a UMR happened. */
+  void __msan_set_expect_umr(int expect_umr);
+
+  /* Change the value of keep_going flag. Non-zero value means don't terminate
+     program execution when an error is detected. This will not affect error in
+     modules that were compiled without the corresponding compiler flag. */
+  void __msan_set_keep_going(int keep_going);
+
+  /* Print shadow and origin for the memory range to stderr in a human-readable
+     format. */
+  void __msan_print_shadow(const volatile void *x, size_t size);
+
+  /* Print shadow for the memory range to stderr in a minimalistic
+     human-readable format. */
+  void __msan_dump_shadow(const volatile void *x, size_t size);
+
+  /* Returns true if running under a dynamic tool (DynamoRio-based). */
+  int  __msan_has_dynamic_component();
+
+  /* Tell MSan about newly allocated memory (ex.: custom allocator).
+     Memory will be marked uninitialized, with origin at the call site. */
+  void __msan_allocated_memory(const volatile void* data, size_t size);
+
+  /* Tell MSan about newly destroyed memory. Mark memory as uninitialized. */
+  void __sanitizer_dtor_callback(const volatile void* data, size_t size);
+
+  /* This function may be optionally provided by user and should return
+     a string containing Msan runtime options. See msan_flags.h for details. */
+  const char* __msan_default_options();
+
+  /* Deprecated. Call __sanitizer_set_death_callback instead. */
+  void __msan_set_death_callback(void (*callback)(void));
+
+  /* Update shadow for the application copy of size bytes from src to dst.
+     Src and dst are application addresses. This function does not copy the
+     actual application memory, it only updates shadow and origin for such
+     copy. Source and destination regions can overlap. */
+  void __msan_copy_shadow(const volatile void *dst, const volatile void *src,
+                          size_t size);
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif
diff --git a/compiler-rt/include/sanitizer/tsan_interface_atomic.h b/compiler-rt/include/sanitizer/tsan_interface_atomic.h
new file mode 100644
index 0000000..4ea77d2
--- /dev/null
+++ b/compiler-rt/include/sanitizer/tsan_interface_atomic.h
@@ -0,0 +1,222 @@
+//===-- tsan_interface_atomic.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Public interface header for TSan atomics.
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_INTERFACE_ATOMIC_H
+#define TSAN_INTERFACE_ATOMIC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef char     __tsan_atomic8;
+typedef short    __tsan_atomic16;  // NOLINT
+typedef int      __tsan_atomic32;
+typedef long     __tsan_atomic64;  // NOLINT
+#if defined(__SIZEOF_INT128__) \
+    || (__clang_major__ * 100 + __clang_minor__ >= 302)
+__extension__ typedef __int128 __tsan_atomic128;
+# define __TSAN_HAS_INT128 1
+#else
+# define __TSAN_HAS_INT128 0
+#endif
+
+// Part of ABI, do not change.
+// http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?view=markup
+typedef enum {
+  __tsan_memory_order_relaxed,
+  __tsan_memory_order_consume,
+  __tsan_memory_order_acquire,
+  __tsan_memory_order_release,
+  __tsan_memory_order_acq_rel,
+  __tsan_memory_order_seq_cst
+} __tsan_memory_order;
+
+__tsan_atomic8 __tsan_atomic8_load(const volatile __tsan_atomic8 *a,
+    __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_load(const volatile __tsan_atomic16 *a,
+    __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_load(const volatile __tsan_atomic32 *a,
+    __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_load(const volatile __tsan_atomic64 *a,
+    __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_load(const volatile __tsan_atomic128 *a,
+    __tsan_memory_order mo);
+#endif
+
+void __tsan_atomic8_store(volatile __tsan_atomic8 *a, __tsan_atomic8 v,
+    __tsan_memory_order mo);
+void __tsan_atomic16_store(volatile __tsan_atomic16 *a, __tsan_atomic16 v,
+    __tsan_memory_order mo);
+void __tsan_atomic32_store(volatile __tsan_atomic32 *a, __tsan_atomic32 v,
+    __tsan_memory_order mo);
+void __tsan_atomic64_store(volatile __tsan_atomic64 *a, __tsan_atomic64 v,
+    __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+void __tsan_atomic128_store(volatile __tsan_atomic128 *a, __tsan_atomic128 v,
+    __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_exchange(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_exchange(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_exchange(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_exchange(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_exchange(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_fetch_add(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_fetch_add(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_fetch_add(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_fetch_add(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_fetch_add(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_fetch_sub(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_fetch_sub(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_fetch_sub(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_fetch_sub(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_fetch_sub(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_fetch_and(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_fetch_and(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_fetch_and(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_fetch_and(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_fetch_and(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_fetch_or(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_fetch_or(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_fetch_or(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_fetch_or(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_fetch_or(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_fetch_xor(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_fetch_xor(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_fetch_xor(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_fetch_xor(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_fetch_xor(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_fetch_nand(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 v, __tsan_memory_order mo);
+__tsan_atomic16 __tsan_atomic16_fetch_nand(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 v, __tsan_memory_order mo);
+__tsan_atomic32 __tsan_atomic32_fetch_nand(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 v, __tsan_memory_order mo);
+__tsan_atomic64 __tsan_atomic64_fetch_nand(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 v, __tsan_memory_order mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_fetch_nand(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 v, __tsan_memory_order mo);
+#endif
+
+int __tsan_atomic8_compare_exchange_weak(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 *c, __tsan_atomic8 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+int __tsan_atomic16_compare_exchange_weak(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 *c, __tsan_atomic16 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+int __tsan_atomic32_compare_exchange_weak(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 *c, __tsan_atomic32 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+int __tsan_atomic64_compare_exchange_weak(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 *c, __tsan_atomic64 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+#if __TSAN_HAS_INT128
+int __tsan_atomic128_compare_exchange_weak(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 *c, __tsan_atomic128 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+#endif
+
+int __tsan_atomic8_compare_exchange_strong(volatile __tsan_atomic8 *a,
+    __tsan_atomic8 *c, __tsan_atomic8 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+int __tsan_atomic16_compare_exchange_strong(volatile __tsan_atomic16 *a,
+    __tsan_atomic16 *c, __tsan_atomic16 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+int __tsan_atomic32_compare_exchange_strong(volatile __tsan_atomic32 *a,
+    __tsan_atomic32 *c, __tsan_atomic32 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+int __tsan_atomic64_compare_exchange_strong(volatile __tsan_atomic64 *a,
+    __tsan_atomic64 *c, __tsan_atomic64 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+#if __TSAN_HAS_INT128
+int __tsan_atomic128_compare_exchange_strong(volatile __tsan_atomic128 *a,
+    __tsan_atomic128 *c, __tsan_atomic128 v, __tsan_memory_order mo,
+    __tsan_memory_order fail_mo);
+#endif
+
+__tsan_atomic8 __tsan_atomic8_compare_exchange_val(
+    volatile __tsan_atomic8 *a, __tsan_atomic8 c, __tsan_atomic8 v,
+    __tsan_memory_order mo, __tsan_memory_order fail_mo);
+__tsan_atomic16 __tsan_atomic16_compare_exchange_val(
+    volatile __tsan_atomic16 *a, __tsan_atomic16 c, __tsan_atomic16 v,
+    __tsan_memory_order mo, __tsan_memory_order fail_mo);
+__tsan_atomic32 __tsan_atomic32_compare_exchange_val(
+    volatile __tsan_atomic32 *a, __tsan_atomic32 c, __tsan_atomic32 v,
+    __tsan_memory_order mo, __tsan_memory_order fail_mo);
+__tsan_atomic64 __tsan_atomic64_compare_exchange_val(
+    volatile __tsan_atomic64 *a, __tsan_atomic64 c, __tsan_atomic64 v,
+    __tsan_memory_order mo, __tsan_memory_order fail_mo);
+#if __TSAN_HAS_INT128
+__tsan_atomic128 __tsan_atomic128_compare_exchange_val(
+    volatile __tsan_atomic128 *a, __tsan_atomic128 c, __tsan_atomic128 v,
+    __tsan_memory_order mo, __tsan_memory_order fail_mo);
+#endif
+
+void __tsan_atomic_thread_fence(__tsan_memory_order mo);
+void __tsan_atomic_signal_fence(__tsan_memory_order mo);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // TSAN_INTERFACE_ATOMIC_H
diff --git a/compiler-rt/lib/BlocksRuntime/Block.h b/compiler-rt/lib/BlocksRuntime/Block.h
new file mode 100644
index 0000000..55cdd01
--- /dev/null
+++ b/compiler-rt/lib/BlocksRuntime/Block.h
@@ -0,0 +1,59 @@
+/*
+ * Block.h
+ *
+ * Copyright 2008-2010 Apple, Inc. Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef _BLOCK_H_
+#define _BLOCK_H_
+
+#if !defined(BLOCK_EXPORT)
+#   if defined(__cplusplus)
+#       define BLOCK_EXPORT extern "C" 
+#   else
+#       define BLOCK_EXPORT extern
+#   endif
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Create a heap based copy of a Block or simply add a reference to an existing one.
+ * This must be paired with Block_release to recover memory, even when running
+ * under Objective-C Garbage Collection.
+ */
+BLOCK_EXPORT void *_Block_copy(const void *aBlock);
+
+/* Lose the reference, and if heap based and last reference, recover the memory. */
+BLOCK_EXPORT void _Block_release(const void *aBlock);
+
+#if defined(__cplusplus)
+}
+#endif
+
+/* Type correct macros. */
+
+#define Block_copy(...) ((__typeof(__VA_ARGS__))_Block_copy((const void *)(__VA_ARGS__)))
+#define Block_release(...) _Block_release((const void *)(__VA_ARGS__))
+
+
+#endif
diff --git a/compiler-rt/lib/BlocksRuntime/Block_private.h b/compiler-rt/lib/BlocksRuntime/Block_private.h
new file mode 100644
index 0000000..8ae8218
--- /dev/null
+++ b/compiler-rt/lib/BlocksRuntime/Block_private.h
@@ -0,0 +1,179 @@
+/*
+ * Block_private.h
+ *
+ * Copyright 2008-2010 Apple, Inc. Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef _BLOCK_PRIVATE_H_
+#define _BLOCK_PRIVATE_H_
+
+#if !defined(BLOCK_EXPORT)
+#   if defined(__cplusplus)
+#       define BLOCK_EXPORT extern "C" 
+#   else
+#       define BLOCK_EXPORT extern
+#   endif
+#endif
+
+#ifndef _MSC_VER
+#include <stdbool.h>
+#else
+/* MSVC doesn't have <stdbool.h>. Compensate. */
+typedef char bool;
+#define true (bool)1
+#define false (bool)0
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+enum {
+    BLOCK_REFCOUNT_MASK =     (0xffff),
+    BLOCK_NEEDS_FREE =        (1 << 24),
+    BLOCK_HAS_COPY_DISPOSE =  (1 << 25),
+    BLOCK_HAS_CTOR =          (1 << 26), /* Helpers have C++ code. */
+    BLOCK_IS_GC =             (1 << 27),
+    BLOCK_IS_GLOBAL =         (1 << 28),
+    BLOCK_HAS_DESCRIPTOR =    (1 << 29)
+};
+
+
+/* Revised new layout. */
+struct Block_descriptor {
+    unsigned long int reserved;
+    unsigned long int size;
+    void (*copy)(void *dst, void *src);
+    void (*dispose)(void *);
+};
+
+
+struct Block_layout {
+    void *isa;
+    int flags;
+    int reserved; 
+    void (*invoke)(void *, ...);
+    struct Block_descriptor *descriptor;
+    /* Imported variables. */
+};
+
+
+struct Block_byref {
+    void *isa;
+    struct Block_byref *forwarding;
+    int flags; /* refcount; */
+    int size;
+    void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src);
+    void (*byref_destroy)(struct Block_byref *);
+    /* long shared[0]; */
+};
+
+
+struct Block_byref_header {
+    void *isa;
+    struct Block_byref *forwarding;
+    int flags;
+    int size;
+};
+
+
+/* Runtime support functions used by compiler when generating copy/dispose helpers. */
+
+enum {
+    /* See function implementation for a more complete description of these fields and combinations */
+    BLOCK_FIELD_IS_OBJECT   =  3,  /* id, NSObject, __attribute__((NSObject)), block, ... */
+    BLOCK_FIELD_IS_BLOCK    =  7,  /* a block variable */
+    BLOCK_FIELD_IS_BYREF    =  8,  /* the on stack structure holding the __block variable */
+    BLOCK_FIELD_IS_WEAK     = 16,  /* declared __weak, only used in byref copy helpers */
+    BLOCK_BYREF_CALLER      = 128  /* called from __block (byref) copy/dispose support routines. */
+};
+
+/* Runtime entry point called by compiler when assigning objects inside copy helper routines */
+BLOCK_EXPORT void _Block_object_assign(void *destAddr, const void *object, const int flags);
+    /* BLOCK_FIELD_IS_BYREF is only used from within block copy helpers */
+
+
+/* runtime entry point called by the compiler when disposing of objects inside dispose helper routine */
+BLOCK_EXPORT void _Block_object_dispose(const void *object, const int flags);
+
+
+
+/* Other support functions */
+
+/* Runtime entry to get total size of a closure */
+BLOCK_EXPORT unsigned long int Block_size(void *block_basic);
+
+
+
+/* the raw data space for runtime classes for blocks */
+/* class+meta used for stack, malloc, and collectable based blocks */
+BLOCK_EXPORT void * _NSConcreteStackBlock[32];
+BLOCK_EXPORT void * _NSConcreteMallocBlock[32];
+BLOCK_EXPORT void * _NSConcreteAutoBlock[32];
+BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32];
+BLOCK_EXPORT void * _NSConcreteGlobalBlock[32];
+BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32];
+
+
+/* the intercept routines that must be used under GC */
+BLOCK_EXPORT void _Block_use_GC( void *(*alloc)(const unsigned long, const bool isOne, const bool isObject),
+                                  void (*setHasRefcount)(const void *, const bool),
+                                  void (*gc_assign_strong)(void *, void **),
+                                  void (*gc_assign_weak)(const void *, void *),
+                                  void (*gc_memmove)(void *, void *, unsigned long));
+
+/* earlier version, now simply transitional */
+BLOCK_EXPORT void _Block_use_GC5( void *(*alloc)(const unsigned long, const bool isOne, const bool isObject),
+                                  void (*setHasRefcount)(const void *, const bool),
+                                  void (*gc_assign_strong)(void *, void **),
+                                  void (*gc_assign_weak)(const void *, void *));
+
+BLOCK_EXPORT void _Block_use_RR( void (*retain)(const void *),
+                                 void (*release)(const void *));
+
+/* make a collectable GC heap based Block.  Not useful under non-GC. */
+BLOCK_EXPORT void *_Block_copy_collectable(const void *aBlock);
+
+/* thread-unsafe diagnostic */
+BLOCK_EXPORT const char *_Block_dump(const void *block);
+
+
+/* Obsolete */
+
+/* first layout */
+struct Block_basic {
+    void *isa;
+    int Block_flags;  /* int32_t */
+    int Block_size;  /* XXX should be packed into Block_flags */
+    void (*Block_invoke)(void *);
+    void (*Block_copy)(void *dst, void *src);  /* iff BLOCK_HAS_COPY_DISPOSE */
+    void (*Block_dispose)(void *);             /* iff BLOCK_HAS_COPY_DISPOSE */
+    /* long params[0];  // where const imports, __block storage references, etc. get laid down */
+};
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+
+#endif /* _BLOCK_PRIVATE_H_ */
diff --git a/compiler-rt/lib/BlocksRuntime/data.c b/compiler-rt/lib/BlocksRuntime/data.c
new file mode 100644
index 0000000..b4eb02e
--- /dev/null
+++ b/compiler-rt/lib/BlocksRuntime/data.c
@@ -0,0 +1,41 @@
+/*
+ * data.c
+ *
+ * Copyright 2008-2010 Apple, Inc. Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+/********************
+NSBlock support
+
+We allocate space and export a symbol to be used as the Class for the on-stack and malloc'ed copies until ObjC arrives on the scene.  These data areas are set up by Foundation to link in as real classes post facto.
+
+We keep these in a separate file so that we can include the runtime code in test subprojects but not include the data so that compiled code that sees the data in libSystem doesn't get confused by a second copy.  Somehow these don't get unified in a common block.
+**********************/
+
+void * _NSConcreteStackBlock[32] = { 0 };
+void * _NSConcreteMallocBlock[32] = { 0 };
+void * _NSConcreteAutoBlock[32] = { 0 };
+void * _NSConcreteFinalizingBlock[32] = { 0 };
+void * _NSConcreteGlobalBlock[32] = { 0 };
+void * _NSConcreteWeakBlockVariable[32] = { 0 };
+
+void _Block_copy_error(void) {
+}
diff --git a/compiler-rt/lib/BlocksRuntime/runtime.c b/compiler-rt/lib/BlocksRuntime/runtime.c
new file mode 100644
index 0000000..a059c22
--- /dev/null
+++ b/compiler-rt/lib/BlocksRuntime/runtime.c
@@ -0,0 +1,700 @@
+/*
+ * runtime.c
+ *
+ * Copyright 2008-2010 Apple, Inc. Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "Block_private.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "config.h"
+
+#ifdef HAVE_AVAILABILITY_MACROS_H
+#include <AvailabilityMacros.h>
+#endif /* HAVE_AVAILABILITY_MACROS_H */
+
+#ifdef HAVE_TARGET_CONDITIONALS_H
+#include <TargetConditionals.h>
+#endif /* HAVE_TARGET_CONDITIONALS_H */
+
+#if defined(HAVE_OSATOMIC_COMPARE_AND_SWAP_INT) && defined(HAVE_OSATOMIC_COMPARE_AND_SWAP_LONG)
+
+#ifdef HAVE_LIBKERN_OSATOMIC_H
+#include <libkern/OSAtomic.h>
+#endif /* HAVE_LIBKERN_OSATOMIC_H */
+
+#elif defined(__WIN32__) || defined(_WIN32)
+#define _CRT_SECURE_NO_WARNINGS 1
+#include <windows.h>
+
+static __inline bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst) {
+    /* fixme barrier is overkill -- see objc-os.h */
+    long original = InterlockedCompareExchange(dst, newl, oldl);
+    return (original == oldl);
+}
+
+static __inline bool OSAtomicCompareAndSwapInt(int oldi, int newi, int volatile *dst) {
+    /* fixme barrier is overkill -- see objc-os.h */
+    int original = InterlockedCompareExchange(dst, newi, oldi);
+    return (original == oldi);
+}
+
+/*
+ * Check to see if the GCC atomic built-ins are available.  If we're on
+ * a 64-bit system, make sure we have an 8-byte atomic function
+ * available.
+ *
+ */
+
+#elif defined(HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT) && defined(HAVE_SYNC_BOOL_COMPARE_AND_SWAP_LONG)
+
+static __inline bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst) {
+  return __sync_bool_compare_and_swap(dst, oldl, newl);
+}
+
+static __inline bool OSAtomicCompareAndSwapInt(int oldi, int newi, int volatile *dst) {
+  return __sync_bool_compare_and_swap(dst, oldi, newi);
+}
+
+#else
+#error unknown atomic compare-and-swap primitive
+#endif /* HAVE_OSATOMIC_COMPARE_AND_SWAP_INT && HAVE_OSATOMIC_COMPARE_AND_SWAP_LONG */
+
+
+/*
+ * Globals:
+ */
+
+static void *_Block_copy_class = _NSConcreteMallocBlock;
+static void *_Block_copy_finalizing_class = _NSConcreteMallocBlock;
+static int _Block_copy_flag = BLOCK_NEEDS_FREE;
+static int _Byref_flag_initial_value = BLOCK_NEEDS_FREE | 2;
+
+static const int WANTS_ONE = (1 << 16);
+
+static bool isGC = false;
+
+/*
+ * Internal Utilities:
+ */
+
+#if 0
+static unsigned long int latching_incr_long(unsigned long int *where) {
+    while (1) {
+        unsigned long int old_value = *(volatile unsigned long int *)where;
+        if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
+            return BLOCK_REFCOUNT_MASK;
+        }
+        if (OSAtomicCompareAndSwapLong(old_value, old_value+1, (volatile long int *)where)) {
+            return old_value+1;
+        }
+    }
+}
+#endif /* if 0 */
+
+static int latching_incr_int(int *where) {
+    while (1) {
+        int old_value = *(volatile int *)where;
+        if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
+            return BLOCK_REFCOUNT_MASK;
+        }
+        if (OSAtomicCompareAndSwapInt(old_value, old_value+1, (volatile int *)where)) {
+            return old_value+1;
+        }
+    }
+}
+
+#if 0
+static int latching_decr_long(unsigned long int *where) {
+    while (1) {
+        unsigned long int old_value = *(volatile int *)where;
+        if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
+            return BLOCK_REFCOUNT_MASK;
+        }
+        if ((old_value & BLOCK_REFCOUNT_MASK) == 0) {
+            return 0;
+        }
+        if (OSAtomicCompareAndSwapLong(old_value, old_value-1, (volatile long int *)where)) {
+            return old_value-1;
+        }
+    }
+}
+#endif /* if 0 */
+
+static int latching_decr_int(int *where) {
+    while (1) {
+        int old_value = *(volatile int *)where;
+        if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
+            return BLOCK_REFCOUNT_MASK;
+        }
+        if ((old_value & BLOCK_REFCOUNT_MASK) == 0) {
+            return 0;
+        }
+        if (OSAtomicCompareAndSwapInt(old_value, old_value-1, (volatile int *)where)) {
+            return old_value-1;
+        }
+    }
+}
+
+
+/*
+ * GC support stub routines:
+ */
+#if 0
+#pragma mark GC Support Routines
+#endif /* if 0 */
+
+
+static void *_Block_alloc_default(const unsigned long size, const bool initialCountIsOne, const bool isObject) {
+    return malloc(size);
+}
+
+static void _Block_assign_default(void *value, void **destptr) {
+    *destptr = value;
+}
+
+static void _Block_setHasRefcount_default(const void *ptr, const bool hasRefcount) {
+}
+
+static void _Block_do_nothing(const void *aBlock) { }
+
+static void _Block_retain_object_default(const void *ptr) {
+    if (!ptr) return;
+}
+
+static void _Block_release_object_default(const void *ptr) {
+    if (!ptr) return;
+}
+
+static void _Block_assign_weak_default(const void *ptr, void *dest) {
+    *(void **)dest = (void *)ptr;
+}
+
+static void _Block_memmove_default(void *dst, void *src, unsigned long size) {
+    memmove(dst, src, (size_t)size);
+}
+
+static void _Block_memmove_gc_broken(void *dest, void *src, unsigned long size) {
+    void **destp = (void **)dest;
+    void **srcp = (void **)src;
+    while (size) {
+        _Block_assign_default(*srcp, destp);
+        destp++;
+        srcp++;
+        size -= sizeof(void *);
+    }
+}
+
+/*
+ * GC support callout functions - initially set to stub routines:
+ */
+
+static void *(*_Block_allocator)(const unsigned long, const bool isOne, const bool isObject) = _Block_alloc_default;
+static void (*_Block_deallocator)(const void *) = (void (*)(const void *))free;
+static void (*_Block_assign)(void *value, void **destptr) = _Block_assign_default;
+static void (*_Block_setHasRefcount)(const void *ptr, const bool hasRefcount) = _Block_setHasRefcount_default;
+static void (*_Block_retain_object)(const void *ptr) = _Block_retain_object_default;
+static void (*_Block_release_object)(const void *ptr) = _Block_release_object_default;
+static void (*_Block_assign_weak)(const void *dest, void *ptr) = _Block_assign_weak_default;
+static void (*_Block_memmove)(void *dest, void *src, unsigned long size) = _Block_memmove_default;
+
+
+/*
+ * GC support SPI functions - called from ObjC runtime and CoreFoundation:
+ */
+
+/* Public SPI
+ * Called from objc-auto to turn on GC.
+ * version 3, 4 arg, but changed 1st arg
+ */
+void _Block_use_GC( void *(*alloc)(const unsigned long, const bool isOne, const bool isObject),
+                    void (*setHasRefcount)(const void *, const bool),
+                    void (*gc_assign)(void *, void **),
+                    void (*gc_assign_weak)(const void *, void *),
+                    void (*gc_memmove)(void *, void *, unsigned long)) {
+
+    isGC = true;
+    _Block_allocator = alloc;
+    _Block_deallocator = _Block_do_nothing;
+    _Block_assign = gc_assign;
+    _Block_copy_flag = BLOCK_IS_GC;
+    _Block_copy_class = _NSConcreteAutoBlock;
+    /* blocks with ctors & dtors need to have the dtor run from a class with a finalizer */
+    _Block_copy_finalizing_class = _NSConcreteFinalizingBlock;
+    _Block_setHasRefcount = setHasRefcount;
+    _Byref_flag_initial_value = BLOCK_IS_GC;   // no refcount
+    _Block_retain_object = _Block_do_nothing;
+    _Block_release_object = _Block_do_nothing;
+    _Block_assign_weak = gc_assign_weak;
+    _Block_memmove = gc_memmove;
+}
+
+/* transitional */
+void _Block_use_GC5( void *(*alloc)(const unsigned long, const bool isOne, const bool isObject),
+                    void (*setHasRefcount)(const void *, const bool),
+                    void (*gc_assign)(void *, void **),
+                    void (*gc_assign_weak)(const void *, void *)) {
+    /* until objc calls _Block_use_GC it will call us; supply a broken internal memmove implementation until then */
+    _Block_use_GC(alloc, setHasRefcount, gc_assign, gc_assign_weak, _Block_memmove_gc_broken);
+}
+
+ 
+/*
+ * Called from objc-auto to alternatively turn on retain/release.
+ * Prior to this the only "object" support we can provide is for those
+ * super special objects that live in libSystem, namely dispatch queues.
+ * Blocks and Block_byrefs have their own special entry points.
+ *
+ */
+void _Block_use_RR( void (*retain)(const void *),
+                    void (*release)(const void *)) {
+    _Block_retain_object = retain;
+    _Block_release_object = release;
+}
+
+/*
+ * Internal Support routines for copying:
+ */
+
+#if 0
+#pragma mark Copy/Release support
+#endif /* if 0 */
+
+/* Copy, or bump refcount, of a block.  If really copying, call the copy helper if present. */
+static void *_Block_copy_internal(const void *arg, const int flags) {
+    struct Block_layout *aBlock;
+    const bool wantsOne = (WANTS_ONE & flags) == WANTS_ONE;
+
+    //printf("_Block_copy_internal(%p, %x)\n", arg, flags);	
+    if (!arg) return NULL;
+    
+    
+    // The following would be better done as a switch statement
+    aBlock = (struct Block_layout *)arg;
+    if (aBlock->flags & BLOCK_NEEDS_FREE) {
+        // latches on high
+        latching_incr_int(&aBlock->flags);
+        return aBlock;
+    }
+    else if (aBlock->flags & BLOCK_IS_GC) {
+        // GC refcounting is expensive so do most refcounting here.
+        if (wantsOne && ((latching_incr_int(&aBlock->flags) & BLOCK_REFCOUNT_MASK) == 1)) {
+            // Tell collector to hang on this - it will bump the GC refcount version
+            _Block_setHasRefcount(aBlock, true);
+        }
+        return aBlock;
+    }
+    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
+        return aBlock;
+    }
+
+    // Its a stack block.  Make a copy.
+    if (!isGC) {
+        struct Block_layout *result = malloc(aBlock->descriptor->size);
+        if (!result) return (void *)0;
+        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
+        // reset refcount
+        result->flags &= ~(BLOCK_REFCOUNT_MASK);    // XXX not needed
+        result->flags |= BLOCK_NEEDS_FREE | 1;
+        result->isa = _NSConcreteMallocBlock;
+        if (result->flags & BLOCK_HAS_COPY_DISPOSE) {
+            //printf("calling block copy helper %p(%p, %p)...\n", aBlock->descriptor->copy, result, aBlock);
+            (*aBlock->descriptor->copy)(result, aBlock); // do fixup
+        }
+        return result;
+    }
+    else {
+        // Under GC want allocation with refcount 1 so we ask for "true" if wantsOne
+        // This allows the copy helper routines to make non-refcounted block copies under GC
+        unsigned long int flags = aBlock->flags;
+        bool hasCTOR = (flags & BLOCK_HAS_CTOR) != 0;
+        struct Block_layout *result = _Block_allocator(aBlock->descriptor->size, wantsOne, hasCTOR);
+        if (!result) return (void *)0;
+        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
+        // reset refcount
+        // if we copy a malloc block to a GC block then we need to clear NEEDS_FREE.
+        flags &= ~(BLOCK_NEEDS_FREE|BLOCK_REFCOUNT_MASK);   // XXX not needed
+        if (wantsOne)
+            flags |= BLOCK_IS_GC | 1;
+        else
+            flags |= BLOCK_IS_GC;
+        result->flags = flags;
+        if (flags & BLOCK_HAS_COPY_DISPOSE) {
+            //printf("calling block copy helper...\n");
+            (*aBlock->descriptor->copy)(result, aBlock); // do fixup
+        }
+        if (hasCTOR) {
+            result->isa = _NSConcreteFinalizingBlock;
+        }
+        else {
+            result->isa = _NSConcreteAutoBlock;
+        }
+        return result;
+    }
+}
+
+
+/*
+ * Runtime entry points for maintaining the sharing knowledge of byref data blocks.
+ *
+ * A closure has been copied and its fixup routine is asking us to fix up the reference to the shared byref data
+ * Closures that aren't copied must still work, so everyone always accesses variables after dereferencing the forwarding ptr.
+ * We ask if the byref pointer that we know about has already been copied to the heap, and if so, increment it.
+ * Otherwise we need to copy it and update the stack forwarding pointer
+ * XXX We need to account for weak/nonretained read-write barriers.
+ */
+
+static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
+    struct Block_byref **destp = (struct Block_byref **)dest;
+    struct Block_byref *src = (struct Block_byref *)arg;
+        
+    //printf("_Block_byref_assign_copy called, byref destp %p, src %p, flags %x\n", destp, src, flags);
+    //printf("src dump: %s\n", _Block_byref_dump(src));
+    if (src->forwarding->flags & BLOCK_IS_GC) {
+        ;   // don't need to do any more work
+    }
+    else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
+        //printf("making copy\n");
+        // src points to stack
+        bool isWeak = ((flags & (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK)) == (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK));
+        // if its weak ask for an object (only matters under GC)
+        struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
+        copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack
+        copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
+        src->forwarding = copy;  // patch stack to point to heap copy
+        copy->size = src->size;
+        if (isWeak) {
+            copy->isa = &_NSConcreteWeakBlockVariable;  // mark isa field so it gets weak scanning
+        }
+        if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
+            // Trust copy helper to copy everything of interest
+            // If more than one field shows up in a byref block this is wrong XXX
+            copy->byref_keep = src->byref_keep;
+            copy->byref_destroy = src->byref_destroy;
+            (*src->byref_keep)(copy, src);
+        }
+        else {
+            // just bits.  Blast 'em using _Block_memmove in case they're __strong
+            _Block_memmove(
+                (void *)&copy->byref_keep,
+                (void *)&src->byref_keep,
+                src->size - sizeof(struct Block_byref_header));
+        }
+    }
+    // already copied to heap
+    else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {
+        latching_incr_int(&src->forwarding->flags);
+    }
+    // assign byref data block pointer into new Block
+    _Block_assign(src->forwarding, (void **)destp);
+}
+
+// Old compiler SPI
+static void _Block_byref_release(const void *arg) {
+    struct Block_byref *shared_struct = (struct Block_byref *)arg;
+    int refcount;
+
+    // dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
+    shared_struct = shared_struct->forwarding;
+    
+    //printf("_Block_byref_release %p called, flags are %x\n", shared_struct, shared_struct->flags);
+    // To support C++ destructors under GC we arrange for there to be a finalizer for this
+    // by using an isa that directs the code to a finalizer that calls the byref_destroy method.
+    if ((shared_struct->flags & BLOCK_NEEDS_FREE) == 0) {
+        return; // stack or GC or global
+    }
+    refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
+    if (refcount <= 0) {
+        printf("_Block_byref_release: Block byref data structure at %p underflowed\n", arg);
+    }
+    else if ((latching_decr_int(&shared_struct->flags) & BLOCK_REFCOUNT_MASK) == 0) {
+        //printf("disposing of heap based byref block\n");
+        if (shared_struct->flags & BLOCK_HAS_COPY_DISPOSE) {
+            //printf("calling out to helper\n");
+            (*shared_struct->byref_destroy)(shared_struct);
+        }
+        _Block_deallocator((struct Block_layout *)shared_struct);
+    }
+}
+
+
+/*
+ *
+ * API supporting SPI
+ * _Block_copy, _Block_release, and (old) _Block_destroy
+ *
+ */
+
+#if 0
+#pragma mark SPI/API
+#endif /* if 0 */
+
+void *_Block_copy(const void *arg) {
+    return _Block_copy_internal(arg, WANTS_ONE);
+}
+
+
+// API entry point to release a copied Block
+void _Block_release(void *arg) {
+    struct Block_layout *aBlock = (struct Block_layout *)arg;
+    int32_t newCount;
+    if (!aBlock) return;
+    newCount = latching_decr_int(&aBlock->flags) & BLOCK_REFCOUNT_MASK;
+    if (newCount > 0) return;
+    // Hit zero
+    if (aBlock->flags & BLOCK_IS_GC) {
+        // Tell GC we no longer have our own refcounts.  GC will decr its refcount
+        // and unless someone has done a CFRetain or marked it uncollectable it will
+        // now be subject to GC reclamation.
+        _Block_setHasRefcount(aBlock, false);
+    }
+    else if (aBlock->flags & BLOCK_NEEDS_FREE) {
+        if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE)(*aBlock->descriptor->dispose)(aBlock);
+        _Block_deallocator(aBlock);
+    }
+    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
+        ;
+    }
+    else {
+        printf("Block_release called upon a stack Block: %p, ignored\n", (void *)aBlock);
+    }
+}
+
+
+
+// Old Compiler SPI point to release a copied Block used by the compiler in dispose helpers
+static void _Block_destroy(const void *arg) {
+    struct Block_layout *aBlock;
+    if (!arg) return;
+    aBlock = (struct Block_layout *)arg;
+    if (aBlock->flags & BLOCK_IS_GC) {
+        // assert(aBlock->Block_flags & BLOCK_HAS_CTOR);
+        return; // ignore, we are being called because of a DTOR
+    }
+    _Block_release(aBlock);
+}
+
+
+
+/*
+ *
+ * SPI used by other layers
+ *
+ */
+
+// SPI, also internal.  Called from NSAutoBlock only under GC
+void *_Block_copy_collectable(const void *aBlock) {
+    return _Block_copy_internal(aBlock, 0);
+}
+
+
+// SPI
+unsigned long int Block_size(void *arg) {
+    return ((struct Block_layout *)arg)->descriptor->size;
+}
+
+
+#if 0
+#pragma mark Compiler SPI entry points
+#endif /* if 0 */
+
+    
+/*******************************************************
+
+Entry points used by the compiler - the real API!
+
+
+A Block can reference four different kinds of things that require help when the Block is copied to the heap.
+1) C++ stack based objects
+2) References to Objective-C objects
+3) Other Blocks
+4) __block variables
+
+In these cases helper functions are synthesized by the compiler for use in Block_copy and Block_release, called the copy and dispose helpers.  The copy helper emits a call to the C++ const copy constructor for C++ stack based objects and for the rest calls into the runtime support function _Block_object_assign.  The dispose helper has a call to the C++ destructor for case 1 and a call into _Block_object_dispose for the rest.
+
+The flags parameter of _Block_object_assign and _Block_object_dispose is set to
+	* BLOCK_FIELD_IS_OBJECT (3), for the case of an Objective-C Object,
+	* BLOCK_FIELD_IS_BLOCK (7), for the case of another Block, and
+	* BLOCK_FIELD_IS_BYREF (8), for the case of a __block variable.
+If the __block variable is marked weak the compiler also or's in BLOCK_FIELD_IS_WEAK (16).
+
+So the Block copy/dispose helpers should only ever generate the four flag values of 3, 7, 8, and 24.
+
+When  a __block variable is either a C++ object, an Objective-C object, or another Block then the compiler also generates copy/dispose helper functions.  Similarly to the Block copy helper, the "__block" copy helper (formerly and still a.k.a. "byref" copy helper) will do a C++ copy constructor (not a const one though!) and the dispose helper will do the destructor.  And similarly the helpers will call into the same two support functions with the same values for objects and Blocks with the additional BLOCK_BYREF_CALLER (128) bit of information supplied.
+
+So the __block copy/dispose helpers will generate flag values of 3 or 7 for objects and Blocks respectively, with BLOCK_FIELD_IS_WEAK (16) or'ed as appropriate and always 128 or'd in, for the following set of possibilities:
+	__block id                   128+3
+        __weak block id              128+3+16
+	__block (^Block)             128+7
+	__weak __block (^Block)      128+7+16
+        
+The implementation of the two routines would be improved by switch statements enumerating the eight cases.
+
+********************************************************/
+
+/*
+ * When Blocks or Block_byrefs hold objects then their copy routine helpers use this entry point
+ * to do the assignment.
+ */
+void _Block_object_assign(void *destAddr, const void *object, const int flags) {
+    //printf("_Block_object_assign(*%p, %p, %x)\n", destAddr, object, flags);
+    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
+        if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
+            _Block_assign_weak(object, destAddr);
+        }
+        else {
+            // do *not* retain or *copy* __block variables whatever they are
+            _Block_assign((void *)object, destAddr);
+        }
+    }
+    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  {
+        // copying a __block reference from the stack Block to the heap
+        // flags will indicate if it holds a __weak reference and needs a special isa
+        _Block_byref_assign_copy(destAddr, object, flags);
+    }
+    // (this test must be before next one)
+    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) {
+        // copying a Block declared variable from the stack Block to the heap
+        _Block_assign(_Block_copy_internal(object, flags), destAddr);
+    }
+    // (this test must be after previous one)
+    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
+        //printf("retaining object at %p\n", object);
+        _Block_retain_object(object);
+        //printf("done retaining object at %p\n", object);
+        _Block_assign((void *)object, destAddr);
+    }
+}
+
+// When Blocks or Block_byrefs hold objects their destroy helper routines call this entry point
+// to help dispose of the contents
+// Used initially only for __attribute__((NSObject)) marked pointers.
+void _Block_object_dispose(const void *object, const int flags) {
+    //printf("_Block_object_dispose(%p, %x)\n", object, flags);
+    if (flags & BLOCK_FIELD_IS_BYREF)  {
+        // get rid of the __block data structure held in a Block
+        _Block_byref_release(object);
+    }
+    else if ((flags & (BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_BLOCK) {
+        // get rid of a referenced Block held by this Block
+        // (ignore __block Block variables, compiler doesn't need to call us)
+        _Block_destroy(object);
+    }
+    else if ((flags & (BLOCK_FIELD_IS_WEAK|BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_OBJECT) {
+        // get rid of a referenced object held by this Block
+        // (ignore __block object variables, compiler doesn't need to call us)
+        _Block_release_object(object);
+    }
+}
+
+
+/*
+ * Debugging support:
+ */
+#if 0
+#pragma mark Debugging
+#endif /* if 0 */
+
+
+const char *_Block_dump(const void *block) {
+    struct Block_layout *closure = (struct Block_layout *)block;
+    static char buffer[512];
+    char *cp = buffer;
+    if (closure == NULL) {
+        sprintf(cp, "NULL passed to _Block_dump\n");
+        return buffer;
+    }
+    if (! (closure->flags & BLOCK_HAS_DESCRIPTOR)) {
+        printf("Block compiled by obsolete compiler, please recompile source for this Block\n");
+        exit(1);
+    }
+    cp += sprintf(cp, "^%p (new layout) =\n", (void *)closure);
+    if (closure->isa == NULL) {
+        cp += sprintf(cp, "isa: NULL\n");
+    }
+    else if (closure->isa == _NSConcreteStackBlock) {
+        cp += sprintf(cp, "isa: stack Block\n");
+    }
+    else if (closure->isa == _NSConcreteMallocBlock) {
+        cp += sprintf(cp, "isa: malloc heap Block\n");
+    }
+    else if (closure->isa == _NSConcreteAutoBlock) {
+        cp += sprintf(cp, "isa: GC heap Block\n");
+    }
+    else if (closure->isa == _NSConcreteGlobalBlock) {
+        cp += sprintf(cp, "isa: global Block\n");
+    }
+    else if (closure->isa == _NSConcreteFinalizingBlock) {
+        cp += sprintf(cp, "isa: finalizing Block\n");
+    }
+    else {
+        cp += sprintf(cp, "isa?: %p\n", (void *)closure->isa);
+    }
+    cp += sprintf(cp, "flags:");
+    if (closure->flags & BLOCK_HAS_DESCRIPTOR) {
+        cp += sprintf(cp, " HASDESCRIPTOR");
+    }
+    if (closure->flags & BLOCK_NEEDS_FREE) {
+        cp += sprintf(cp, " FREEME");
+    }
+    if (closure->flags & BLOCK_IS_GC) {
+        cp += sprintf(cp, " ISGC");
+    }
+    if (closure->flags & BLOCK_HAS_COPY_DISPOSE) {
+        cp += sprintf(cp, " HASHELP");
+    }
+    if (closure->flags & BLOCK_HAS_CTOR) {
+        cp += sprintf(cp, " HASCTOR");
+    }
+    cp += sprintf(cp, "\nrefcount: %u\n", closure->flags & BLOCK_REFCOUNT_MASK);
+    cp += sprintf(cp, "invoke: %p\n", (void *)(uintptr_t)closure->invoke);
+    {
+        struct Block_descriptor *dp = closure->descriptor;
+        cp += sprintf(cp, "descriptor: %p\n", (void *)dp);
+        cp += sprintf(cp, "descriptor->reserved: %lu\n", dp->reserved);
+        cp += sprintf(cp, "descriptor->size: %lu\n", dp->size);
+
+        if (closure->flags & BLOCK_HAS_COPY_DISPOSE) {
+            cp += sprintf(cp, "descriptor->copy helper: %p\n", (void *)(uintptr_t)dp->copy);
+            cp += sprintf(cp, "descriptor->dispose helper: %p\n", (void *)(uintptr_t)dp->dispose);
+        }
+    }
+    return buffer;
+}
+
+
+const char *_Block_byref_dump(struct Block_byref *src) {
+    static char buffer[256];
+    char *cp = buffer;
+    cp += sprintf(cp, "byref data block %p contents:\n", (void *)src);
+    cp += sprintf(cp, "  forwarding: %p\n", (void *)src->forwarding);
+    cp += sprintf(cp, "  flags: 0x%x\n", src->flags);
+    cp += sprintf(cp, "  size: %d\n", src->size);
+    if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
+        cp += sprintf(cp, "  copy helper: %p\n", (void *)(uintptr_t)src->byref_keep);
+        cp += sprintf(cp, "  dispose helper: %p\n", (void *)(uintptr_t)src->byref_destroy);
+    }
+    return buffer;
+}
+
diff --git a/compiler-rt/lib/CMakeLists.txt b/compiler-rt/lib/CMakeLists.txt
new file mode 100644
index 0000000..4bc6f7a
--- /dev/null
+++ b/compiler-rt/lib/CMakeLists.txt
@@ -0,0 +1,50 @@
+# First, add the subdirectories which contain feature-based runtime libraries
+# and several convenience helper libraries.
+
+include(AddCompilerRT)
+include(SanitizerUtils)
+
+if(COMPILER_RT_BUILD_BUILTINS)
+  add_subdirectory(builtins)
+endif()
+
+if(COMPILER_RT_BUILD_SANITIZERS)
+  if(COMPILER_RT_HAS_INTERCEPTION)
+    add_subdirectory(interception)
+  endif()
+
+  if(COMPILER_RT_HAS_SANITIZER_COMMON)
+    add_subdirectory(sanitizer_common)
+    add_subdirectory(lsan)
+    add_subdirectory(ubsan)
+  endif()
+
+  if(COMPILER_RT_HAS_ASAN)
+    add_subdirectory(asan)
+  endif()
+
+  if(COMPILER_RT_HAS_DFSAN)
+    add_subdirectory(dfsan)
+  endif()
+
+  if(COMPILER_RT_HAS_MSAN)
+    add_subdirectory(msan)
+  endif()
+
+  if(COMPILER_RT_HAS_PROFILE)
+    add_subdirectory(profile)
+  endif()
+
+  if(COMPILER_RT_HAS_TSAN)
+    add_subdirectory(tsan)
+    add_subdirectory(tsan/dd)
+  endif()
+
+  if(COMPILER_RT_HAS_SAFESTACK)
+    add_subdirectory(safestack)
+  endif()
+
+  if(COMPILER_RT_HAS_CFI)
+    add_subdirectory(cfi)
+  endif()
+endif()
diff --git a/compiler-rt/lib/Makefile.mk b/compiler-rt/lib/Makefile.mk
new file mode 100644
index 0000000..7eb6489
--- /dev/null
+++ b/compiler-rt/lib/Makefile.mk
@@ -0,0 +1,19 @@
+#===- lib/Makefile.mk --------------------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+SubDirs :=
+
+# Add submodules.
+SubDirs += asan
+SubDirs += builtins
+SubDirs += interception
+SubDirs += lsan
+SubDirs += profile
+SubDirs += sanitizer_common
+SubDirs += ubsan
diff --git a/compiler-rt/lib/asan/.clang-format b/compiler-rt/lib/asan/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/asan/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/asan/Android.bp b/compiler-rt/lib/asan/Android.bp
new file mode 100644
index 0000000..3e20843
--- /dev/null
+++ b/compiler-rt/lib/asan/Android.bp
@@ -0,0 +1,218 @@
+//
+// Copyright (C) 2012 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+ASAN_NEEDS_SEGV = "0"
+ASAN_HAS_EXCEPTIONS = "1"
+ASAN_FLEXIBLE_MAPPING_AND_OFFSET = "0"
+
+asan_rtl_files = [
+    "asan_activation.cc",
+    "asan_allocator.cc",
+    "asan_fake_stack.cc",
+    "asan_flags.cc",
+    "asan_globals.cc",
+    "asan_interceptors.cc",
+    "asan_linux.cc",
+    "asan_mac.cc",
+    "asan_malloc_linux.cc",
+    "asan_malloc_mac.cc",
+    "asan_malloc_win.cc",
+    "asan_poisoning.cc",
+    "asan_posix.cc",
+    "asan_report.cc",
+    "asan_rtl.cc",
+    "asan_stack.cc",
+    "asan_stats.cc",
+    "asan_suppressions.cc",
+    "asan_thread.cc",
+    "asan_win.cc",
+]
+
+asan_rtl_cxx_files = ["asan_new_delete.cc"]
+
+asan_rtl_cflags = [
+    "-fvisibility=hidden",
+    "-fno-exceptions",
+    "-DASAN_LOW_MEMORY=1",
+    "-DASAN_NEEDS_SEGV=" + ASAN_NEEDS_SEGV,
+    "-DASAN_HAS_EXCEPTIONS=" + ASAN_HAS_EXCEPTIONS,
+    "-DASAN_FLEXIBLE_MAPPING_AND_OFFSET=" + ASAN_FLEXIBLE_MAPPING_AND_OFFSET,
+    "-Wno-covered-switch-default",
+    "-Wno-non-virtual-dtor",
+    "-Wno-sign-compare",
+    "-Wno-unused-parameter",
+    "-std=c++11",
+    "-fno-rtti",
+    "-fno-builtin",
+]
+
+cc_library_static {
+    name: "libasan",
+    host_supported: true,
+    defaults: ["asan_arch_defaults"],
+    include_dirs: [
+        "external/compiler-rt/lib",
+        "external/compiler-rt/include",
+    ],
+    cflags: asan_rtl_cflags,
+    target: {
+        android: {
+            srcs: ["asan_preinit.cc"],
+        },
+        host: {
+            srcs: asan_rtl_files,
+            whole_static_libs: ["libubsan"],
+            static_libs: [
+                "libinterception",
+                "liblsan",
+                "libsan",
+            ],
+        },
+    },
+
+    clang: true,
+    sdk_version: "19",
+    stl: "none",
+
+    sanitize: {
+        never: true,
+    },
+}
+
+cc_library_host_static {
+    name: "libasan_cxx",
+    include_dirs: [
+        "external/compiler-rt/lib",
+        "external/compiler-rt/include",
+    ],
+    cflags: asan_rtl_cflags,
+    srcs: asan_rtl_cxx_files,
+
+    clang: true,
+    compile_multilib: "both",
+
+    sanitize: {
+        never: true,
+    },
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_binary {
+    name: "asanwrapper",
+    defaults: ["asan_arch_defaults"],
+
+    srcs: ["asanwrapper.cc"],
+
+    cppflags: ["-std=c++11"],
+    sanitize: {
+        never: true,
+    },
+
+    stl: "libc++",
+}
+
+// ANDROIDMK TRANSLATION ERROR: unsupported conditional
+// ifneq (true,$(SKIP_LLVM_TESTS))
+cc_library_static {
+    name: "libasan_noinst_test",
+    host_supported: true,
+    defaults: ["asan_arch_defaults"],
+
+    tags: ["tests"],
+    include_dirs: [
+        "external/gtest/include",
+        "external/compiler-rt/include",
+        "external/compiler-rt/lib",
+        "external/compiler-rt/lib/asan/tests",
+        "external/compiler-rt/lib/sanitizer_common/tests",
+    ],
+    cflags: [
+        "-Wno-non-virtual-dtor",
+        "-Wno-unused-parameter",
+        "-Wno-sign-compare",
+        "-DASAN_UAR=0",
+        "-DASAN_HAS_BLACKLIST=1",
+        "-DASAN_HAS_EXCEPTIONS=" + ASAN_HAS_EXCEPTIONS,
+        "-DASAN_NEEDS_SEGV=" + ASAN_NEEDS_SEGV,
+        "-std=c++11",
+    ],
+    srcs: [
+        "tests/asan_noinst_test.cc",
+        "tests/asan_test_main.cc",
+    ],
+
+    clang: true,
+    sanitize: {
+        never: true,
+    },
+
+    stl: "libc++",
+}
+
+cc_test {
+    name: "asan_test",
+    host_supported: true,
+    defaults: ["asan_arch_defaults"],
+
+    tags: ["tests"],
+    include_dirs: [
+        "external/compiler-rt/lib",
+        "external/compiler-rt/lib/asan/tests",
+        "external/compiler-rt/lib/sanitizer_common/tests",
+    ],
+    cflags: [
+        "-DASAN_LOW_MEMORY=1",
+        "-DASAN_UAR=0",
+        "-DASAN_NEEDS_SEGV=" + ASAN_NEEDS_SEGV,
+        "-DASAN_HAS_EXCEPTIONS=" + ASAN_HAS_EXCEPTIONS,
+        "-DASAN_HAS_BLACKLIST=1",
+        "-Wno-covered-switch-default",
+        "-Wno-non-virtual-dtor",
+        "-Wno-sign-compare",
+        "-Wno-unused-parameter",
+        "-std=c++11",
+    ],
+
+    srcs: [
+        "tests/asan_globals_test.cc",
+        "tests/asan_test.cc",
+        //"tests/asan_noinst_test.cc",
+        //"tests/asan_test_main.cc",
+    ],
+
+    static_libs: ["libasan_noinst_test"],
+    sanitize: {
+        address: true,
+        blacklist: "tests/asan_test.ignore",
+    },
+    clang: true,
+
+    stl: "libc++",
+    target: {
+        host: {
+            host_ldlibs: ["-lrt"],
+        },
+    },
+}
+
+// ANDROIDMK TRANSLATION ERROR: endif from unsupported contitional
+// endif
+// SKIP_LLVM_TESTS
diff --git a/compiler-rt/lib/asan/CMakeLists.txt b/compiler-rt/lib/asan/CMakeLists.txt
new file mode 100644
index 0000000..6716f48
--- /dev/null
+++ b/compiler-rt/lib/asan/CMakeLists.txt
@@ -0,0 +1,230 @@
+# Build for the AddressSanitizer runtime support library.
+
+set(ASAN_SOURCES
+  asan_allocator.cc
+  asan_activation.cc
+  asan_debugging.cc
+  asan_fake_stack.cc
+  asan_flags.cc
+  asan_globals.cc
+  asan_interceptors.cc
+  asan_linux.cc
+  asan_mac.cc
+  asan_malloc_linux.cc
+  asan_malloc_mac.cc
+  asan_malloc_win.cc
+  asan_poisoning.cc
+  asan_posix.cc
+  asan_report.cc
+  asan_rtl.cc
+  asan_stack.cc
+  asan_stats.cc
+  asan_suppressions.cc
+  asan_thread.cc
+  asan_win.cc)
+
+set(ASAN_CXX_SOURCES
+  asan_new_delete.cc)
+
+set(ASAN_PREINIT_SOURCES
+  asan_preinit.cc)
+
+include_directories(..)
+
+set(ASAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(ASAN_CFLAGS)
+
+set(ASAN_COMMON_DEFINITIONS
+  ASAN_HAS_EXCEPTIONS=1)
+
+set(ASAN_DYNAMIC_LINK_FLAGS)
+
+if(ANDROID)
+  list(APPEND ASAN_COMMON_DEFINITIONS
+    ASAN_LOW_MEMORY=1)
+# On Android, -z global does not do what it is documented to do.
+# On Android, -z global moves the library ahead in the lookup order,
+# placing it right after the LD_PRELOADs. This is used to compensate for the fact
+# that Android linker does not look at the dependencies of the main executable
+# that aren't dependencies of the current DSO when resolving symbols from said DSO.
+# As a net result, this allows running ASan executables without LD_PRELOAD-ing the
+# ASan runtime library.
+# The above is applicable to L MR1 or newer.
+  if (COMPILER_RT_HAS_Z_GLOBAL)
+    list(APPEND ASAN_DYNAMIC_LINK_FLAGS -Wl,-z,global)
+  endif()
+endif()
+
+set(ASAN_DYNAMIC_DEFINITIONS
+  ${ASAN_COMMON_DEFINITIONS} ASAN_DYNAMIC=1)
+append_list_if(WIN32 INTERCEPTION_DYNAMIC_CRT ASAN_DYNAMIC_DEFINITIONS)
+
+set(ASAN_DYNAMIC_CFLAGS ${ASAN_CFLAGS})
+append_list_if(COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC
+  -ftls-model=initial-exec ASAN_DYNAMIC_CFLAGS)
+append_list_if(MSVC /DEBUG ASAN_DYNAMIC_CFLAGS)
+
+append_list_if(COMPILER_RT_HAS_LIBC c ASAN_DYNAMIC_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBDL dl ASAN_DYNAMIC_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBRT rt ASAN_DYNAMIC_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBM m ASAN_DYNAMIC_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread ASAN_DYNAMIC_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ ASAN_DYNAMIC_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBLOG log ASAN_DYNAMIC_LIBS)
+
+# Compile ASan sources into an object library.
+
+add_compiler_rt_object_libraries(RTAsan_dynamic 
+  OS ${SANITIZER_COMMON_SUPPORTED_OS}
+  ARCHS ${ASAN_SUPPORTED_ARCH}
+  SOURCES ${ASAN_SOURCES} ${ASAN_CXX_SOURCES}
+  CFLAGS ${ASAN_DYNAMIC_CFLAGS}
+  DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+
+if(NOT APPLE)
+  add_compiler_rt_object_libraries(RTAsan 
+    ARCHS ${ASAN_SUPPORTED_ARCH}
+    SOURCES ${ASAN_SOURCES} CFLAGS ${ASAN_CFLAGS}
+    DEFS ${ASAN_COMMON_DEFINITIONS})
+  add_compiler_rt_object_libraries(RTAsan_cxx 
+    ARCHS ${ASAN_SUPPORTED_ARCH}
+    SOURCES ${ASAN_CXX_SOURCES} CFLAGS ${ASAN_CFLAGS}
+    DEFS ${ASAN_COMMON_DEFINITIONS})
+  add_compiler_rt_object_libraries(RTAsan_preinit 
+    ARCHS ${ASAN_SUPPORTED_ARCH}
+    SOURCES ${ASAN_PREINIT_SOURCES} CFLAGS ${ASAN_CFLAGS}
+    DEFS ${ASAN_COMMON_DEFINITIONS})
+
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc "")
+  add_compiler_rt_object_libraries(RTAsan_dynamic_version_script_dummy
+    ARCHS ${ASAN_SUPPORTED_ARCH}
+    SOURCES ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc
+    CFLAGS ${ASAN_DYNAMIC_CFLAGS}
+    DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+endif()
+
+# Build ASan runtimes shipped with Clang.
+add_custom_target(asan)
+if(APPLE)
+  add_compiler_rt_runtime(clang_rt.asan
+    SHARED
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${ASAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTAsan_dynamic
+                RTInterception
+                RTSanitizerCommon
+                RTSanitizerCommonLibc
+                RTLSanCommon
+                RTUbsan
+    CFLAGS ${ASAN_DYNAMIC_CFLAGS}
+    DEFS ${ASAN_DYNAMIC_DEFINITIONS}
+    PARENT_TARGET asan)
+else()
+  # Build separate libraries for each target.
+  
+    set(ASAN_COMMON_RUNTIME_OBJECT_LIBS
+      RTInterception
+      RTSanitizerCommon
+      RTSanitizerCommonLibc
+      RTLSanCommon
+      RTUbsan)
+
+    add_compiler_rt_runtime(clang_rt.asan
+      STATIC
+      ARCHS ${ASAN_SUPPORTED_ARCH}
+      OBJECT_LIBS RTAsan_preinit
+                  RTAsan
+                  ${ASAN_COMMON_RUNTIME_OBJECT_LIBS}
+      CFLAGS ${ASAN_CFLAGS}
+      DEFS ${ASAN_COMMON_DEFINITIONS}
+      PARENT_TARGET asan)
+
+    add_compiler_rt_runtime(clang_rt.asan_cxx
+      STATIC
+      ARCHS ${ASAN_SUPPORTED_ARCH}
+      OBJECT_LIBS RTAsan_cxx
+                  RTUbsan_cxx
+      CFLAGS ${ASAN_CFLAGS}
+      DEFS ${ASAN_COMMON_DEFINITIONS}
+      PARENT_TARGET asan)
+
+    add_compiler_rt_runtime(clang_rt.asan-preinit
+      STATIC
+      ARCHS ${ASAN_SUPPORTED_ARCH}
+      OBJECT_LIBS RTAsan_preinit
+      CFLAGS ${ASAN_CFLAGS}
+      DEFS ${ASAN_COMMON_DEFINITIONS}
+      PARENT_TARGET asan)
+
+  foreach(arch ${ASAN_SUPPORTED_ARCH})
+    if (UNIX AND NOT ${arch} MATCHES "i386|i686")
+      add_sanitizer_rt_version_list(clang_rt.asan-dynamic-${arch}
+                                    LIBS clang_rt.asan-${arch} clang_rt.asan_cxx-${arch}
+                                    EXTRA asan.syms.extra)
+      set(VERSION_SCRIPT_FLAG
+           -Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/clang_rt.asan-dynamic-${arch}.vers)
+      set_source_files_properties(
+        ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc
+	PROPERTIES
+	OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/clang_rt.asan-dynamic-${arch}.vers)
+    else()
+      set(VERSION_SCRIPT_FLAG)
+    endif()
+
+    add_compiler_rt_runtime(clang_rt.asan
+      SHARED
+      ARCHS ${arch}
+      OBJECT_LIBS ${ASAN_COMMON_RUNTIME_OBJECT_LIBS}
+              RTAsan_dynamic
+              # The only purpose of RTAsan_dynamic_version_script_dummy is to carry
+              # a dependency of the shared runtime on the version script. With CMake
+              # 3.1 or later it can be replaced with a straightforward
+              # add_dependencies(clang_rt.asan-dynamic-${arch} clang_rt.asan-dynamic-${arch}-version-list)
+              RTAsan_dynamic_version_script_dummy
+              RTUbsan_cxx
+      CFLAGS ${ASAN_DYNAMIC_CFLAGS}
+      LINKFLAGS ${ASAN_DYNAMIC_LINK_FLAGS}
+                ${VERSION_SCRIPT_FLAG}
+      LINK_LIBS ${ASAN_DYNAMIC_LIBS}
+      DEFS ${ASAN_DYNAMIC_DEFINITIONS}
+      PARENT_TARGET asan)
+
+    if (UNIX AND NOT ${arch} MATCHES "i386|i686")
+      add_sanitizer_rt_symbols(clang_rt.asan_cxx
+        ARCHS ${arch})
+      add_dependencies(asan clang_rt.asan_cxx-${arch}-symbols)
+      add_sanitizer_rt_symbols(clang_rt.asan
+        ARCHS ${arch} 
+        EXTRA asan.syms.extra)
+      add_dependencies(asan clang_rt.asan-${arch}-symbols)
+    endif()
+
+    if (WIN32)
+      add_compiler_rt_runtime(clang_rt.asan_dll_thunk
+        STATIC
+        ARCHS ${arch}
+        SOURCES asan_win_dll_thunk.cc
+                $<TARGET_OBJECTS:RTInterception.${arch}>
+        CFLAGS ${ASAN_CFLAGS} -DASAN_DLL_THUNK
+        DEFS ${ASAN_COMMON_DEFINITIONS}
+        PARENT_TARGET asan)
+      add_compiler_rt_runtime(clang_rt.asan_dynamic_runtime_thunk
+        STATIC
+        ARCHS ${arch}
+        SOURCES asan_win_dynamic_runtime_thunk.cc
+        CFLAGS ${ASAN_CFLAGS} -DASAN_DYNAMIC_RUNTIME_THUNK -Zl
+        DEFS ${ASAN_COMMON_DEFINITIONS}
+        PARENT_TARGET asan)
+    endif()
+  endforeach()
+endif()
+
+add_compiler_rt_resource_file(asan_blacklist asan_blacklist.txt)
+add_dependencies(asan asan_blacklist)
+add_dependencies(compiler-rt asan)
+
+add_subdirectory(scripts)
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(tests)
+endif()
diff --git a/compiler-rt/lib/asan/Makefile.mk b/compiler-rt/lib/asan/Makefile.mk
new file mode 100644
index 0000000..0dafefc
--- /dev/null
+++ b/compiler-rt/lib/asan/Makefile.mk
@@ -0,0 +1,29 @@
+#===- lib/asan/Makefile.mk ---------------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := asan
+SubDirs := 
+
+CCSources := $(foreach file,$(wildcard $(Dir)/*.cc),$(notdir $(file)))
+CXXOnlySources := asan_new_delete.cc
+COnlySources := $(filter-out $(CXXOnlySources),$(CCSources))
+SSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(CCSources) $(SSources)
+ObjNames := $(CCSources:%.cc=%.o) $(SSources:%.S=%.o)
+
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
+Dependencies += $(wildcard $(Dir)/../interception/*.h)
+Dependencies += $(wildcard $(Dir)/../sanitizer_common/*.h)
+
+# Define a convenience variable for all the asan functions.
+AsanFunctions := $(COnlySources:%.cc=%) $(SSources:%.S=%)
+AsanCXXFunctions := $(CXXOnlySources:%.cc=%)
diff --git a/compiler-rt/lib/asan/README.txt b/compiler-rt/lib/asan/README.txt
new file mode 100644
index 0000000..bb6ff42
--- /dev/null
+++ b/compiler-rt/lib/asan/README.txt
@@ -0,0 +1,26 @@
+AddressSanitizer RT
+================================
+This directory contains sources of the AddressSanitizer (ASan) runtime library.
+
+Directory structure:
+README.txt       : This file.
+Makefile.mk      : File for make-based build.
+CMakeLists.txt   : File for cmake-based build.
+asan_*.{cc,h}    : Sources of the asan runtime library.
+scripts/*        : Helper scripts.
+tests/*          : ASan unit tests.
+
+Also ASan runtime needs the following libraries:
+lib/interception/      : Machinery used to intercept function calls.
+lib/sanitizer_common/  : Code shared between various sanitizers.
+
+ASan runtime currently also embeds part of LeakSanitizer runtime for
+leak detection (lib/lsan/lsan_common.{cc,h}).
+
+ASan runtime can only be built by CMake. You can run ASan tests
+from the root of your CMake build tree:
+
+make check-asan
+
+For more instructions see:
+https://github.com/google/sanitizers/wiki/AddressSanitizerHowToBuild
diff --git a/compiler-rt/lib/asan/asan.syms.extra b/compiler-rt/lib/asan/asan.syms.extra
new file mode 100644
index 0000000..007aafe
--- /dev/null
+++ b/compiler-rt/lib/asan/asan.syms.extra
@@ -0,0 +1,3 @@
+__asan_*
+__lsan_*
+__ubsan_*
diff --git a/compiler-rt/lib/asan/asan_activation.cc b/compiler-rt/lib/asan/asan_activation.cc
new file mode 100644
index 0000000..9df3b97
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_activation.cc
@@ -0,0 +1,139 @@
+//===-- asan_activation.cc --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan activation/deactivation logic.
+//===----------------------------------------------------------------------===//
+
+#include "asan_activation.h"
+#include "asan_allocator.h"
+#include "asan_flags.h"
+#include "asan_internal.h"
+#include "asan_poisoning.h"
+#include "asan_stack.h"
+#include "sanitizer_common/sanitizer_flags.h"
+
+namespace __asan {
+
+static struct AsanDeactivatedFlags {
+  AllocatorOptions allocator_options;
+  int malloc_context_size;
+  bool poison_heap;
+  bool coverage;
+  const char *coverage_dir;
+
+  void RegisterActivationFlags(FlagParser *parser, Flags *f, CommonFlags *cf) {
+#define ASAN_ACTIVATION_FLAG(Type, Name) \
+  RegisterFlag(parser, #Name, "", &f->Name);
+#define COMMON_ACTIVATION_FLAG(Type, Name) \
+  RegisterFlag(parser, #Name, "", &cf->Name);
+#include "asan_activation_flags.inc"
+#undef ASAN_ACTIVATION_FLAG
+#undef COMMON_ACTIVATION_FLAG
+
+    RegisterIncludeFlags(parser, cf);
+  }
+
+  void OverrideFromActivationFlags() {
+    Flags f;
+    CommonFlags cf;
+    FlagParser parser;
+    RegisterActivationFlags(&parser, &f, &cf);
+
+    // Copy the current activation flags.
+    allocator_options.CopyTo(&f, &cf);
+    cf.malloc_context_size = malloc_context_size;
+    f.poison_heap = poison_heap;
+    cf.coverage = coverage;
+    cf.coverage_dir = coverage_dir;
+    cf.verbosity = Verbosity();
+    cf.help = false; // this is activation-specific help
+
+    // Check if activation flags need to be overriden.
+    if (const char *env = GetEnv("ASAN_ACTIVATION_OPTIONS")) {
+      parser.ParseString(env);
+    }
+
+    SetVerbosity(cf.verbosity);
+
+    if (Verbosity()) ReportUnrecognizedFlags();
+
+    if (cf.help) parser.PrintFlagDescriptions();
+
+    allocator_options.SetFrom(&f, &cf);
+    malloc_context_size = cf.malloc_context_size;
+    poison_heap = f.poison_heap;
+    coverage = cf.coverage;
+    coverage_dir = cf.coverage_dir;
+  }
+
+  void Print() {
+    Report(
+        "quarantine_size_mb %d, max_redzone %d, poison_heap %d, "
+        "malloc_context_size %d, alloc_dealloc_mismatch %d, "
+        "allocator_may_return_null %d, coverage %d, coverage_dir %s\n",
+        allocator_options.quarantine_size_mb, allocator_options.max_redzone,
+        poison_heap, malloc_context_size,
+        allocator_options.alloc_dealloc_mismatch,
+        allocator_options.may_return_null, coverage, coverage_dir);
+  }
+} asan_deactivated_flags;
+
+static bool asan_is_deactivated;
+
+void AsanDeactivate() {
+  CHECK(!asan_is_deactivated);
+  VReport(1, "Deactivating ASan\n");
+
+  // Stash runtime state.
+  GetAllocatorOptions(&asan_deactivated_flags.allocator_options);
+  asan_deactivated_flags.malloc_context_size = GetMallocContextSize();
+  asan_deactivated_flags.poison_heap = CanPoisonMemory();
+  asan_deactivated_flags.coverage = common_flags()->coverage;
+  asan_deactivated_flags.coverage_dir = common_flags()->coverage_dir;
+
+  // Deactivate the runtime.
+  SetCanPoisonMemory(false);
+  SetMallocContextSize(1);
+  ReInitializeCoverage(false, nullptr);
+
+  AllocatorOptions disabled = asan_deactivated_flags.allocator_options;
+  disabled.quarantine_size_mb = 0;
+  disabled.min_redzone = 16;  // Redzone must be at least 16 bytes long.
+  disabled.max_redzone = 16;
+  disabled.alloc_dealloc_mismatch = false;
+  disabled.may_return_null = true;
+  ReInitializeAllocator(disabled);
+
+  asan_is_deactivated = true;
+}
+
+void AsanActivate() {
+  if (!asan_is_deactivated) return;
+  VReport(1, "Activating ASan\n");
+
+  UpdateProcessName();
+
+  asan_deactivated_flags.OverrideFromActivationFlags();
+
+  SetCanPoisonMemory(asan_deactivated_flags.poison_heap);
+  SetMallocContextSize(asan_deactivated_flags.malloc_context_size);
+  ReInitializeCoverage(asan_deactivated_flags.coverage,
+                       asan_deactivated_flags.coverage_dir);
+  ReInitializeAllocator(asan_deactivated_flags.allocator_options);
+
+  asan_is_deactivated = false;
+  if (Verbosity()) {
+    Report("Activated with flags:\n");
+    asan_deactivated_flags.Print();
+  }
+}
+
+}  // namespace __asan
diff --git a/compiler-rt/lib/asan/asan_activation.h b/compiler-rt/lib/asan/asan_activation.h
new file mode 100644
index 0000000..d5e1ce4
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_activation.h
@@ -0,0 +1,23 @@
+//===-- asan_activation.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan activation/deactivation logic.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_ACTIVATION_H
+#define ASAN_ACTIVATION_H
+
+namespace __asan {
+void AsanDeactivate();
+void AsanActivate();
+}  // namespace __asan
+
+#endif  // ASAN_ACTIVATION_H
diff --git a/compiler-rt/lib/asan/asan_activation_flags.inc b/compiler-rt/lib/asan/asan_activation_flags.inc
new file mode 100644
index 0000000..d4c089e
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_activation_flags.inc
@@ -0,0 +1,35 @@
+//===-- asan_activation_flags.inc -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// A subset of ASan (and common) runtime flags supported at activation time.
+//
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_ACTIVATION_FLAG
+# error "Define ASAN_ACTIVATION_FLAG prior to including this file!"
+#endif
+
+#ifndef COMMON_ACTIVATION_FLAG
+# error "Define COMMON_ACTIVATION_FLAG prior to including this file!"
+#endif
+
+// ASAN_ACTIVATION_FLAG(Type, Name)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+ASAN_ACTIVATION_FLAG(int, redzone)
+ASAN_ACTIVATION_FLAG(int, max_redzone)
+ASAN_ACTIVATION_FLAG(int, quarantine_size_mb)
+ASAN_ACTIVATION_FLAG(bool, alloc_dealloc_mismatch)
+ASAN_ACTIVATION_FLAG(bool, poison_heap)
+
+COMMON_ACTIVATION_FLAG(bool, allocator_may_return_null)
+COMMON_ACTIVATION_FLAG(int, malloc_context_size)
+COMMON_ACTIVATION_FLAG(bool, coverage)
+COMMON_ACTIVATION_FLAG(const char *, coverage_dir)
+COMMON_ACTIVATION_FLAG(int, verbosity)
+COMMON_ACTIVATION_FLAG(bool, help)
diff --git a/compiler-rt/lib/asan/asan_allocator.cc b/compiler-rt/lib/asan/asan_allocator.cc
new file mode 100644
index 0000000..56f184a
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_allocator.cc
@@ -0,0 +1,908 @@
+//===-- asan_allocator.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Implementation of ASan's memory allocator, 2-nd version.
+// This variant uses the allocator from sanitizer_common, i.e. the one shared
+// with ThreadSanitizer and MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+
+#include "asan_allocator.h"
+#include "asan_mapping.h"
+#include "asan_poisoning.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_allocator_interface.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_list.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_quarantine.h"
+#include "lsan/lsan_common.h"
+
+namespace __asan {
+
+// Valid redzone sizes are 16, 32, 64, ... 2048, so we encode them in 3 bits.
+// We use adaptive redzones: for larger allocation larger redzones are used.
+static u32 RZLog2Size(u32 rz_log) {
+  CHECK_LT(rz_log, 8);
+  return 16 << rz_log;
+}
+
+static u32 RZSize2Log(u32 rz_size) {
+  CHECK_GE(rz_size, 16);
+  CHECK_LE(rz_size, 2048);
+  CHECK(IsPowerOfTwo(rz_size));
+  u32 res = Log2(rz_size) - 4;
+  CHECK_EQ(rz_size, RZLog2Size(res));
+  return res;
+}
+
+static AsanAllocator &get_allocator();
+
+// The memory chunk allocated from the underlying allocator looks like this:
+// L L L L L L H H U U U U U U R R
+//   L -- left redzone words (0 or more bytes)
+//   H -- ChunkHeader (16 bytes), which is also a part of the left redzone.
+//   U -- user memory.
+//   R -- right redzone (0 or more bytes)
+// ChunkBase consists of ChunkHeader and other bytes that overlap with user
+// memory.
+
+// If the left redzone is greater than the ChunkHeader size we store a magic
+// value in the first uptr word of the memory block and store the address of
+// ChunkBase in the next uptr.
+// M B L L L L L L L L L  H H U U U U U U
+//   |                    ^
+//   ---------------------|
+//   M -- magic value kAllocBegMagic
+//   B -- address of ChunkHeader pointing to the first 'H'
+static const uptr kAllocBegMagic = 0xCC6E96B9;
+
+struct ChunkHeader {
+  // 1-st 8 bytes.
+  u32 chunk_state       : 8;  // Must be first.
+  u32 alloc_tid         : 24;
+
+  u32 free_tid          : 24;
+  u32 from_memalign     : 1;
+  u32 alloc_type        : 2;
+  u32 rz_log            : 3;
+  u32 lsan_tag          : 2;
+  // 2-nd 8 bytes
+  // This field is used for small sizes. For large sizes it is equal to
+  // SizeClassMap::kMaxSize and the actual size is stored in the
+  // SecondaryAllocator's metadata.
+  u32 user_requested_size;
+  u32 alloc_context_id;
+};
+
+struct ChunkBase : ChunkHeader {
+  // Header2, intersects with user memory.
+  u32 free_context_id;
+};
+
+static const uptr kChunkHeaderSize = sizeof(ChunkHeader);
+static const uptr kChunkHeader2Size = sizeof(ChunkBase) - kChunkHeaderSize;
+COMPILER_CHECK(kChunkHeaderSize == 16);
+COMPILER_CHECK(kChunkHeader2Size <= 16);
+
+// Every chunk of memory allocated by this allocator can be in one of 3 states:
+// CHUNK_AVAILABLE: the chunk is in the free list and ready to be allocated.
+// CHUNK_ALLOCATED: the chunk is allocated and not yet freed.
+// CHUNK_QUARANTINE: the chunk was freed and put into quarantine zone.
+enum {
+  CHUNK_AVAILABLE  = 0,  // 0 is the default value even if we didn't set it.
+  CHUNK_ALLOCATED  = 2,
+  CHUNK_QUARANTINE = 3
+};
+
+struct AsanChunk: ChunkBase {
+  uptr Beg() { return reinterpret_cast<uptr>(this) + kChunkHeaderSize; }
+  uptr UsedSize(bool locked_version = false) {
+    if (user_requested_size != SizeClassMap::kMaxSize)
+      return user_requested_size;
+    return *reinterpret_cast<uptr *>(
+               get_allocator().GetMetaData(AllocBeg(locked_version)));
+  }
+  void *AllocBeg(bool locked_version = false) {
+    if (from_memalign) {
+      if (locked_version)
+        return get_allocator().GetBlockBeginFastLocked(
+            reinterpret_cast<void *>(this));
+      return get_allocator().GetBlockBegin(reinterpret_cast<void *>(this));
+    }
+    return reinterpret_cast<void*>(Beg() - RZLog2Size(rz_log));
+  }
+  bool AddrIsInside(uptr addr, bool locked_version = false) {
+    return (addr >= Beg()) && (addr < Beg() + UsedSize(locked_version));
+  }
+};
+
+struct QuarantineCallback {
+  explicit QuarantineCallback(AllocatorCache *cache)
+      : cache_(cache) {
+  }
+
+  void Recycle(AsanChunk *m) {
+    CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
+    atomic_store((atomic_uint8_t*)m, CHUNK_AVAILABLE, memory_order_relaxed);
+    CHECK_NE(m->alloc_tid, kInvalidTid);
+    CHECK_NE(m->free_tid, kInvalidTid);
+    PoisonShadow(m->Beg(),
+                 RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
+                 kAsanHeapLeftRedzoneMagic);
+    void *p = reinterpret_cast<void *>(m->AllocBeg());
+    if (p != m) {
+      uptr *alloc_magic = reinterpret_cast<uptr *>(p);
+      CHECK_EQ(alloc_magic[0], kAllocBegMagic);
+      // Clear the magic value, as allocator internals may overwrite the
+      // contents of deallocated chunk, confusing GetAsanChunk lookup.
+      alloc_magic[0] = 0;
+      CHECK_EQ(alloc_magic[1], reinterpret_cast<uptr>(m));
+    }
+
+    // Statistics.
+    AsanStats &thread_stats = GetCurrentThreadStats();
+    thread_stats.real_frees++;
+    thread_stats.really_freed += m->UsedSize();
+
+    get_allocator().Deallocate(cache_, p);
+  }
+
+  void *Allocate(uptr size) {
+    return get_allocator().Allocate(cache_, size, 1, false);
+  }
+
+  void Deallocate(void *p) {
+    get_allocator().Deallocate(cache_, p);
+  }
+
+  AllocatorCache *cache_;
+};
+
+typedef Quarantine<QuarantineCallback, AsanChunk> AsanQuarantine;
+typedef AsanQuarantine::Cache QuarantineCache;
+
+void AsanMapUnmapCallback::OnMap(uptr p, uptr size) const {
+  PoisonShadow(p, size, kAsanHeapLeftRedzoneMagic);
+  // Statistics.
+  AsanStats &thread_stats = GetCurrentThreadStats();
+  thread_stats.mmaps++;
+  thread_stats.mmaped += size;
+}
+void AsanMapUnmapCallback::OnUnmap(uptr p, uptr size) const {
+  PoisonShadow(p, size, 0);
+  // We are about to unmap a chunk of user memory.
+  // Mark the corresponding shadow memory as not needed.
+  FlushUnneededASanShadowMemory(p, size);
+  // Statistics.
+  AsanStats &thread_stats = GetCurrentThreadStats();
+  thread_stats.munmaps++;
+  thread_stats.munmaped += size;
+}
+
+// We can not use THREADLOCAL because it is not supported on some of the
+// platforms we care about (OSX 10.6, Android).
+// static THREADLOCAL AllocatorCache cache;
+AllocatorCache *GetAllocatorCache(AsanThreadLocalMallocStorage *ms) {
+  CHECK(ms);
+  return &ms->allocator_cache;
+}
+
+QuarantineCache *GetQuarantineCache(AsanThreadLocalMallocStorage *ms) {
+  CHECK(ms);
+  CHECK_LE(sizeof(QuarantineCache), sizeof(ms->quarantine_cache));
+  return reinterpret_cast<QuarantineCache *>(ms->quarantine_cache);
+}
+
+void AllocatorOptions::SetFrom(const Flags *f, const CommonFlags *cf) {
+  quarantine_size_mb = f->quarantine_size_mb;
+  min_redzone = f->redzone;
+  max_redzone = f->max_redzone;
+  may_return_null = cf->allocator_may_return_null;
+  alloc_dealloc_mismatch = f->alloc_dealloc_mismatch;
+}
+
+void AllocatorOptions::CopyTo(Flags *f, CommonFlags *cf) {
+  f->quarantine_size_mb = quarantine_size_mb;
+  f->redzone = min_redzone;
+  f->max_redzone = max_redzone;
+  cf->allocator_may_return_null = may_return_null;
+  f->alloc_dealloc_mismatch = alloc_dealloc_mismatch;
+}
+
+struct Allocator {
+  static const uptr kMaxAllowedMallocSize =
+      FIRST_32_SECOND_64(3UL << 30, 1UL << 40);
+  static const uptr kMaxThreadLocalQuarantine =
+      FIRST_32_SECOND_64(1 << 18, 1 << 20);
+
+  AsanAllocator allocator;
+  AsanQuarantine quarantine;
+  StaticSpinMutex fallback_mutex;
+  AllocatorCache fallback_allocator_cache;
+  QuarantineCache fallback_quarantine_cache;
+
+  // ------------------- Options --------------------------
+  atomic_uint16_t min_redzone;
+  atomic_uint16_t max_redzone;
+  atomic_uint8_t alloc_dealloc_mismatch;
+
+  // ------------------- Initialization ------------------------
+  explicit Allocator(LinkerInitialized)
+      : quarantine(LINKER_INITIALIZED),
+        fallback_quarantine_cache(LINKER_INITIALIZED) {}
+
+  void CheckOptions(const AllocatorOptions &options) const {
+    CHECK_GE(options.min_redzone, 16);
+    CHECK_GE(options.max_redzone, options.min_redzone);
+    CHECK_LE(options.max_redzone, 2048);
+    CHECK(IsPowerOfTwo(options.min_redzone));
+    CHECK(IsPowerOfTwo(options.max_redzone));
+  }
+
+  void SharedInitCode(const AllocatorOptions &options) {
+    CheckOptions(options);
+    quarantine.Init((uptr)options.quarantine_size_mb << 20,
+                    kMaxThreadLocalQuarantine);
+    atomic_store(&alloc_dealloc_mismatch, options.alloc_dealloc_mismatch,
+                 memory_order_release);
+    atomic_store(&min_redzone, options.min_redzone, memory_order_release);
+    atomic_store(&max_redzone, options.max_redzone, memory_order_release);
+  }
+
+  void Initialize(const AllocatorOptions &options) {
+    allocator.Init(options.may_return_null);
+    SharedInitCode(options);
+  }
+
+  void ReInitialize(const AllocatorOptions &options) {
+    allocator.SetMayReturnNull(options.may_return_null);
+    SharedInitCode(options);
+  }
+
+  void GetOptions(AllocatorOptions *options) const {
+    options->quarantine_size_mb = quarantine.GetSize() >> 20;
+    options->min_redzone = atomic_load(&min_redzone, memory_order_acquire);
+    options->max_redzone = atomic_load(&max_redzone, memory_order_acquire);
+    options->may_return_null = allocator.MayReturnNull();
+    options->alloc_dealloc_mismatch =
+        atomic_load(&alloc_dealloc_mismatch, memory_order_acquire);
+  }
+
+  // -------------------- Helper methods. -------------------------
+  uptr ComputeRZLog(uptr user_requested_size) {
+    u32 rz_log =
+      user_requested_size <= 64        - 16   ? 0 :
+      user_requested_size <= 128       - 32   ? 1 :
+      user_requested_size <= 512       - 64   ? 2 :
+      user_requested_size <= 4096      - 128  ? 3 :
+      user_requested_size <= (1 << 14) - 256  ? 4 :
+      user_requested_size <= (1 << 15) - 512  ? 5 :
+      user_requested_size <= (1 << 16) - 1024 ? 6 : 7;
+    u32 min_rz = atomic_load(&min_redzone, memory_order_acquire);
+    u32 max_rz = atomic_load(&max_redzone, memory_order_acquire);
+    return Min(Max(rz_log, RZSize2Log(min_rz)), RZSize2Log(max_rz));
+  }
+
+  // We have an address between two chunks, and we want to report just one.
+  AsanChunk *ChooseChunk(uptr addr, AsanChunk *left_chunk,
+                         AsanChunk *right_chunk) {
+    // Prefer an allocated chunk over freed chunk and freed chunk
+    // over available chunk.
+    if (left_chunk->chunk_state != right_chunk->chunk_state) {
+      if (left_chunk->chunk_state == CHUNK_ALLOCATED)
+        return left_chunk;
+      if (right_chunk->chunk_state == CHUNK_ALLOCATED)
+        return right_chunk;
+      if (left_chunk->chunk_state == CHUNK_QUARANTINE)
+        return left_chunk;
+      if (right_chunk->chunk_state == CHUNK_QUARANTINE)
+        return right_chunk;
+    }
+    // Same chunk_state: choose based on offset.
+    sptr l_offset = 0, r_offset = 0;
+    CHECK(AsanChunkView(left_chunk).AddrIsAtRight(addr, 1, &l_offset));
+    CHECK(AsanChunkView(right_chunk).AddrIsAtLeft(addr, 1, &r_offset));
+    if (l_offset < r_offset)
+      return left_chunk;
+    return right_chunk;
+  }
+
+  // -------------------- Allocation/Deallocation routines ---------------
+  void *Allocate(uptr size, uptr alignment, BufferedStackTrace *stack,
+                 AllocType alloc_type, bool can_fill) {
+    if (UNLIKELY(!asan_inited))
+      AsanInitFromRtl();
+    Flags &fl = *flags();
+    CHECK(stack);
+    const uptr min_alignment = SHADOW_GRANULARITY;
+    if (alignment < min_alignment)
+      alignment = min_alignment;
+    if (size == 0) {
+      // We'd be happy to avoid allocating memory for zero-size requests, but
+      // some programs/tests depend on this behavior and assume that malloc
+      // would not return NULL even for zero-size allocations. Moreover, it
+      // looks like operator new should never return NULL, and results of
+      // consecutive "new" calls must be different even if the allocated size
+      // is zero.
+      size = 1;
+    }
+    CHECK(IsPowerOfTwo(alignment));
+    uptr rz_log = ComputeRZLog(size);
+    uptr rz_size = RZLog2Size(rz_log);
+    uptr rounded_size = RoundUpTo(Max(size, kChunkHeader2Size), alignment);
+    uptr needed_size = rounded_size + rz_size;
+    if (alignment > min_alignment)
+      needed_size += alignment;
+    bool using_primary_allocator = true;
+    // If we are allocating from the secondary allocator, there will be no
+    // automatic right redzone, so add the right redzone manually.
+    if (!PrimaryAllocator::CanAllocate(needed_size, alignment)) {
+      needed_size += rz_size;
+      using_primary_allocator = false;
+    }
+    CHECK(IsAligned(needed_size, min_alignment));
+    if (size > kMaxAllowedMallocSize || needed_size > kMaxAllowedMallocSize) {
+      Report("WARNING: AddressSanitizer failed to allocate 0x%zx bytes\n",
+             (void*)size);
+      return allocator.ReturnNullOrDie();
+    }
+
+    AsanThread *t = GetCurrentThread();
+    void *allocated;
+    bool check_rss_limit = true;
+    if (t) {
+      AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
+      allocated =
+          allocator.Allocate(cache, needed_size, 8, false, check_rss_limit);
+    } else {
+      SpinMutexLock l(&fallback_mutex);
+      AllocatorCache *cache = &fallback_allocator_cache;
+      allocated =
+          allocator.Allocate(cache, needed_size, 8, false, check_rss_limit);
+    }
+
+    if (!allocated)
+      return allocator.ReturnNullOrDie();
+
+    if (*(u8 *)MEM_TO_SHADOW((uptr)allocated) == 0 && CanPoisonMemory()) {
+      // Heap poisoning is enabled, but the allocator provides an unpoisoned
+      // chunk. This is possible if CanPoisonMemory() was false for some
+      // time, for example, due to flags()->start_disabled.
+      // Anyway, poison the block before using it for anything else.
+      uptr allocated_size = allocator.GetActuallyAllocatedSize(allocated);
+      PoisonShadow((uptr)allocated, allocated_size, kAsanHeapLeftRedzoneMagic);
+    }
+
+    uptr alloc_beg = reinterpret_cast<uptr>(allocated);
+    uptr alloc_end = alloc_beg + needed_size;
+    uptr beg_plus_redzone = alloc_beg + rz_size;
+    uptr user_beg = beg_plus_redzone;
+    if (!IsAligned(user_beg, alignment))
+      user_beg = RoundUpTo(user_beg, alignment);
+    uptr user_end = user_beg + size;
+    CHECK_LE(user_end, alloc_end);
+    uptr chunk_beg = user_beg - kChunkHeaderSize;
+    AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
+    m->alloc_type = alloc_type;
+    m->rz_log = rz_log;
+    u32 alloc_tid = t ? t->tid() : 0;
+    m->alloc_tid = alloc_tid;
+    CHECK_EQ(alloc_tid, m->alloc_tid);  // Does alloc_tid fit into the bitfield?
+    m->free_tid = kInvalidTid;
+    m->from_memalign = user_beg != beg_plus_redzone;
+    if (alloc_beg != chunk_beg) {
+      CHECK_LE(alloc_beg+ 2 * sizeof(uptr), chunk_beg);
+      reinterpret_cast<uptr *>(alloc_beg)[0] = kAllocBegMagic;
+      reinterpret_cast<uptr *>(alloc_beg)[1] = chunk_beg;
+    }
+    if (using_primary_allocator) {
+      CHECK(size);
+      m->user_requested_size = size;
+      CHECK(allocator.FromPrimary(allocated));
+    } else {
+      CHECK(!allocator.FromPrimary(allocated));
+      m->user_requested_size = SizeClassMap::kMaxSize;
+      uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(allocated));
+      meta[0] = size;
+      meta[1] = chunk_beg;
+    }
+
+    m->alloc_context_id = StackDepotPut(*stack);
+
+    uptr size_rounded_down_to_granularity =
+        RoundDownTo(size, SHADOW_GRANULARITY);
+    // Unpoison the bulk of the memory region.
+    if (size_rounded_down_to_granularity)
+      PoisonShadow(user_beg, size_rounded_down_to_granularity, 0);
+    // Deal with the end of the region if size is not aligned to granularity.
+    if (size != size_rounded_down_to_granularity && CanPoisonMemory()) {
+      u8 *shadow =
+          (u8 *)MemToShadow(user_beg + size_rounded_down_to_granularity);
+      *shadow = fl.poison_partial ? (size & (SHADOW_GRANULARITY - 1)) : 0;
+    }
+
+    AsanStats &thread_stats = GetCurrentThreadStats();
+    thread_stats.mallocs++;
+    thread_stats.malloced += size;
+    thread_stats.malloced_redzones += needed_size - size;
+    if (needed_size > SizeClassMap::kMaxSize)
+      thread_stats.malloc_large++;
+    else
+      thread_stats.malloced_by_size[SizeClassMap::ClassID(needed_size)]++;
+
+    void *res = reinterpret_cast<void *>(user_beg);
+    if (can_fill && fl.max_malloc_fill_size) {
+      uptr fill_size = Min(size, (uptr)fl.max_malloc_fill_size);
+      REAL(memset)(res, fl.malloc_fill_byte, fill_size);
+    }
+#if CAN_SANITIZE_LEAKS
+    m->lsan_tag = __lsan::DisabledInThisThread() ? __lsan::kIgnored
+                                                 : __lsan::kDirectlyLeaked;
+#endif
+    // Must be the last mutation of metadata in this function.
+    atomic_store((atomic_uint8_t *)m, CHUNK_ALLOCATED, memory_order_release);
+    ASAN_MALLOC_HOOK(res, size);
+    return res;
+  }
+
+  void AtomicallySetQuarantineFlag(AsanChunk *m, void *ptr,
+                                   BufferedStackTrace *stack) {
+    u8 old_chunk_state = CHUNK_ALLOCATED;
+    // Flip the chunk_state atomically to avoid race on double-free.
+    if (!atomic_compare_exchange_strong((atomic_uint8_t*)m, &old_chunk_state,
+                                        CHUNK_QUARANTINE, memory_order_acquire))
+      ReportInvalidFree(ptr, old_chunk_state, stack);
+    CHECK_EQ(CHUNK_ALLOCATED, old_chunk_state);
+  }
+
+  // Expects the chunk to already be marked as quarantined by using
+  // AtomicallySetQuarantineFlag.
+  void QuarantineChunk(AsanChunk *m, void *ptr, BufferedStackTrace *stack,
+                       AllocType alloc_type) {
+    CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
+
+    if (m->alloc_type != alloc_type) {
+      if (atomic_load(&alloc_dealloc_mismatch, memory_order_acquire)) {
+        ReportAllocTypeMismatch((uptr)ptr, stack, (AllocType)m->alloc_type,
+                                (AllocType)alloc_type);
+      }
+    }
+
+    CHECK_GE(m->alloc_tid, 0);
+    if (SANITIZER_WORDSIZE == 64)  // On 32-bits this resides in user area.
+      CHECK_EQ(m->free_tid, kInvalidTid);
+    AsanThread *t = GetCurrentThread();
+    m->free_tid = t ? t->tid() : 0;
+    m->free_context_id = StackDepotPut(*stack);
+    // Poison the region.
+    PoisonShadow(m->Beg(),
+                 RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
+                 kAsanHeapFreeMagic);
+
+    AsanStats &thread_stats = GetCurrentThreadStats();
+    thread_stats.frees++;
+    thread_stats.freed += m->UsedSize();
+
+    // Push into quarantine.
+    if (t) {
+      AsanThreadLocalMallocStorage *ms = &t->malloc_storage();
+      AllocatorCache *ac = GetAllocatorCache(ms);
+      quarantine.Put(GetQuarantineCache(ms), QuarantineCallback(ac), m,
+                           m->UsedSize());
+    } else {
+      SpinMutexLock l(&fallback_mutex);
+      AllocatorCache *ac = &fallback_allocator_cache;
+      quarantine.Put(&fallback_quarantine_cache, QuarantineCallback(ac), m,
+                           m->UsedSize());
+    }
+  }
+
+  void Deallocate(void *ptr, uptr delete_size, BufferedStackTrace *stack,
+                  AllocType alloc_type) {
+    uptr p = reinterpret_cast<uptr>(ptr);
+    if (p == 0) return;
+
+    uptr chunk_beg = p - kChunkHeaderSize;
+    AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
+    if (delete_size && flags()->new_delete_type_mismatch &&
+        delete_size != m->UsedSize()) {
+      ReportNewDeleteSizeMismatch(p, delete_size, stack);
+    }
+    ASAN_FREE_HOOK(ptr);
+    // Must mark the chunk as quarantined before any changes to its metadata.
+    AtomicallySetQuarantineFlag(m, ptr, stack);
+    QuarantineChunk(m, ptr, stack, alloc_type);
+  }
+
+  void *Reallocate(void *old_ptr, uptr new_size, BufferedStackTrace *stack) {
+    CHECK(old_ptr && new_size);
+    uptr p = reinterpret_cast<uptr>(old_ptr);
+    uptr chunk_beg = p - kChunkHeaderSize;
+    AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
+
+    AsanStats &thread_stats = GetCurrentThreadStats();
+    thread_stats.reallocs++;
+    thread_stats.realloced += new_size;
+
+    void *new_ptr = Allocate(new_size, 8, stack, FROM_MALLOC, true);
+    if (new_ptr) {
+      u8 chunk_state = m->chunk_state;
+      if (chunk_state != CHUNK_ALLOCATED)
+        ReportInvalidFree(old_ptr, chunk_state, stack);
+      CHECK_NE(REAL(memcpy), nullptr);
+      uptr memcpy_size = Min(new_size, m->UsedSize());
+      // If realloc() races with free(), we may start copying freed memory.
+      // However, we will report racy double-free later anyway.
+      REAL(memcpy)(new_ptr, old_ptr, memcpy_size);
+      Deallocate(old_ptr, 0, stack, FROM_MALLOC);
+    }
+    return new_ptr;
+  }
+
+  void *Calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
+    if (CallocShouldReturnNullDueToOverflow(size, nmemb))
+      return allocator.ReturnNullOrDie();
+    void *ptr = Allocate(nmemb * size, 8, stack, FROM_MALLOC, false);
+    // If the memory comes from the secondary allocator no need to clear it
+    // as it comes directly from mmap.
+    if (ptr && allocator.FromPrimary(ptr))
+      REAL(memset)(ptr, 0, nmemb * size);
+    return ptr;
+  }
+
+  void ReportInvalidFree(void *ptr, u8 chunk_state, BufferedStackTrace *stack) {
+    if (chunk_state == CHUNK_QUARANTINE)
+      ReportDoubleFree((uptr)ptr, stack);
+    else
+      ReportFreeNotMalloced((uptr)ptr, stack);
+  }
+
+  void CommitBack(AsanThreadLocalMallocStorage *ms) {
+    AllocatorCache *ac = GetAllocatorCache(ms);
+    quarantine.Drain(GetQuarantineCache(ms), QuarantineCallback(ac));
+    allocator.SwallowCache(ac);
+  }
+
+  // -------------------------- Chunk lookup ----------------------
+
+  // Assumes alloc_beg == allocator.GetBlockBegin(alloc_beg).
+  AsanChunk *GetAsanChunk(void *alloc_beg) {
+    if (!alloc_beg) return nullptr;
+    if (!allocator.FromPrimary(alloc_beg)) {
+      uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(alloc_beg));
+      AsanChunk *m = reinterpret_cast<AsanChunk *>(meta[1]);
+      return m;
+    }
+    uptr *alloc_magic = reinterpret_cast<uptr *>(alloc_beg);
+    if (alloc_magic[0] == kAllocBegMagic)
+      return reinterpret_cast<AsanChunk *>(alloc_magic[1]);
+    return reinterpret_cast<AsanChunk *>(alloc_beg);
+  }
+
+  AsanChunk *GetAsanChunkByAddr(uptr p) {
+    void *alloc_beg = allocator.GetBlockBegin(reinterpret_cast<void *>(p));
+    return GetAsanChunk(alloc_beg);
+  }
+
+  // Allocator must be locked when this function is called.
+  AsanChunk *GetAsanChunkByAddrFastLocked(uptr p) {
+    void *alloc_beg =
+        allocator.GetBlockBeginFastLocked(reinterpret_cast<void *>(p));
+    return GetAsanChunk(alloc_beg);
+  }
+
+  uptr AllocationSize(uptr p) {
+    AsanChunk *m = GetAsanChunkByAddr(p);
+    if (!m) return 0;
+    if (m->chunk_state != CHUNK_ALLOCATED) return 0;
+    if (m->Beg() != p) return 0;
+    return m->UsedSize();
+  }
+
+  AsanChunkView FindHeapChunkByAddress(uptr addr) {
+    AsanChunk *m1 = GetAsanChunkByAddr(addr);
+    if (!m1) return AsanChunkView(m1);
+    sptr offset = 0;
+    if (AsanChunkView(m1).AddrIsAtLeft(addr, 1, &offset)) {
+      // The address is in the chunk's left redzone, so maybe it is actually
+      // a right buffer overflow from the other chunk to the left.
+      // Search a bit to the left to see if there is another chunk.
+      AsanChunk *m2 = nullptr;
+      for (uptr l = 1; l < GetPageSizeCached(); l++) {
+        m2 = GetAsanChunkByAddr(addr - l);
+        if (m2 == m1) continue;  // Still the same chunk.
+        break;
+      }
+      if (m2 && AsanChunkView(m2).AddrIsAtRight(addr, 1, &offset))
+        m1 = ChooseChunk(addr, m2, m1);
+    }
+    return AsanChunkView(m1);
+  }
+
+  void PrintStats() {
+    allocator.PrintStats();
+  }
+
+  void ForceLock() {
+    allocator.ForceLock();
+    fallback_mutex.Lock();
+  }
+
+  void ForceUnlock() {
+    fallback_mutex.Unlock();
+    allocator.ForceUnlock();
+  }
+};
+
+static Allocator instance(LINKER_INITIALIZED);
+
+static AsanAllocator &get_allocator() {
+  return instance.allocator;
+}
+
+bool AsanChunkView::IsValid() {
+  return chunk_ && chunk_->chunk_state != CHUNK_AVAILABLE;
+}
+uptr AsanChunkView::Beg() { return chunk_->Beg(); }
+uptr AsanChunkView::End() { return Beg() + UsedSize(); }
+uptr AsanChunkView::UsedSize() { return chunk_->UsedSize(); }
+uptr AsanChunkView::AllocTid() { return chunk_->alloc_tid; }
+uptr AsanChunkView::FreeTid() { return chunk_->free_tid; }
+
+static StackTrace GetStackTraceFromId(u32 id) {
+  CHECK(id);
+  StackTrace res = StackDepotGet(id);
+  CHECK(res.trace);
+  return res;
+}
+
+StackTrace AsanChunkView::GetAllocStack() {
+  return GetStackTraceFromId(chunk_->alloc_context_id);
+}
+
+StackTrace AsanChunkView::GetFreeStack() {
+  return GetStackTraceFromId(chunk_->free_context_id);
+}
+
+void InitializeAllocator(const AllocatorOptions &options) {
+  instance.Initialize(options);
+}
+
+void ReInitializeAllocator(const AllocatorOptions &options) {
+  instance.ReInitialize(options);
+}
+
+void GetAllocatorOptions(AllocatorOptions *options) {
+  instance.GetOptions(options);
+}
+
+AsanChunkView FindHeapChunkByAddress(uptr addr) {
+  return instance.FindHeapChunkByAddress(addr);
+}
+
+void AsanThreadLocalMallocStorage::CommitBack() {
+  instance.CommitBack(this);
+}
+
+void PrintInternalAllocatorStats() {
+  instance.PrintStats();
+}
+
+void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
+                    AllocType alloc_type) {
+  return instance.Allocate(size, alignment, stack, alloc_type, true);
+}
+
+void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type) {
+  instance.Deallocate(ptr, 0, stack, alloc_type);
+}
+
+void asan_sized_free(void *ptr, uptr size, BufferedStackTrace *stack,
+                     AllocType alloc_type) {
+  instance.Deallocate(ptr, size, stack, alloc_type);
+}
+
+void *asan_malloc(uptr size, BufferedStackTrace *stack) {
+  return instance.Allocate(size, 8, stack, FROM_MALLOC, true);
+}
+
+void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
+  return instance.Calloc(nmemb, size, stack);
+}
+
+void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack) {
+  if (!p)
+    return instance.Allocate(size, 8, stack, FROM_MALLOC, true);
+  if (size == 0) {
+    instance.Deallocate(p, 0, stack, FROM_MALLOC);
+    return nullptr;
+  }
+  return instance.Reallocate(p, size, stack);
+}
+
+void *asan_valloc(uptr size, BufferedStackTrace *stack) {
+  return instance.Allocate(size, GetPageSizeCached(), stack, FROM_MALLOC, true);
+}
+
+void *asan_pvalloc(uptr size, BufferedStackTrace *stack) {
+  uptr PageSize = GetPageSizeCached();
+  size = RoundUpTo(size, PageSize);
+  if (size == 0) {
+    // pvalloc(0) should allocate one page.
+    size = PageSize;
+  }
+  return instance.Allocate(size, PageSize, stack, FROM_MALLOC, true);
+}
+
+int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
+                        BufferedStackTrace *stack) {
+  void *ptr = instance.Allocate(size, alignment, stack, FROM_MALLOC, true);
+  CHECK(IsAligned((uptr)ptr, alignment));
+  *memptr = ptr;
+  return 0;
+}
+
+uptr asan_malloc_usable_size(void *ptr, uptr pc, uptr bp) {
+  if (!ptr) return 0;
+  uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
+  if (flags()->check_malloc_usable_size && (usable_size == 0)) {
+    GET_STACK_TRACE_FATAL(pc, bp);
+    ReportMallocUsableSizeNotOwned((uptr)ptr, &stack);
+  }
+  return usable_size;
+}
+
+uptr asan_mz_size(const void *ptr) {
+  return instance.AllocationSize(reinterpret_cast<uptr>(ptr));
+}
+
+void asan_mz_force_lock() {
+  instance.ForceLock();
+}
+
+void asan_mz_force_unlock() {
+  instance.ForceUnlock();
+}
+
+void AsanSoftRssLimitExceededCallback(bool exceeded) {
+  instance.allocator.SetRssLimitIsExceeded(exceeded);
+}
+
+} // namespace __asan
+
+// --- Implementation of LSan-specific functions --- {{{1
+namespace __lsan {
+void LockAllocator() {
+  __asan::get_allocator().ForceLock();
+}
+
+void UnlockAllocator() {
+  __asan::get_allocator().ForceUnlock();
+}
+
+void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
+  *begin = (uptr)&__asan::get_allocator();
+  *end = *begin + sizeof(__asan::get_allocator());
+}
+
+uptr PointsIntoChunk(void* p) {
+  uptr addr = reinterpret_cast<uptr>(p);
+  __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddrFastLocked(addr);
+  if (!m) return 0;
+  uptr chunk = m->Beg();
+  if (m->chunk_state != __asan::CHUNK_ALLOCATED)
+    return 0;
+  if (m->AddrIsInside(addr, /*locked_version=*/true))
+    return chunk;
+  if (IsSpecialCaseOfOperatorNew0(chunk, m->UsedSize(/*locked_version*/ true),
+                                  addr))
+    return chunk;
+  return 0;
+}
+
+uptr GetUserBegin(uptr chunk) {
+  __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddrFastLocked(chunk);
+  CHECK(m);
+  return m->Beg();
+}
+
+LsanMetadata::LsanMetadata(uptr chunk) {
+  metadata_ = reinterpret_cast<void *>(chunk - __asan::kChunkHeaderSize);
+}
+
+bool LsanMetadata::allocated() const {
+  __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  return m->chunk_state == __asan::CHUNK_ALLOCATED;
+}
+
+ChunkTag LsanMetadata::tag() const {
+  __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  return static_cast<ChunkTag>(m->lsan_tag);
+}
+
+void LsanMetadata::set_tag(ChunkTag value) {
+  __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  m->lsan_tag = value;
+}
+
+uptr LsanMetadata::requested_size() const {
+  __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  return m->UsedSize(/*locked_version=*/true);
+}
+
+u32 LsanMetadata::stack_trace_id() const {
+  __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  return m->alloc_context_id;
+}
+
+void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+  __asan::get_allocator().ForEachChunk(callback, arg);
+}
+
+IgnoreObjectResult IgnoreObjectLocked(const void *p) {
+  uptr addr = reinterpret_cast<uptr>(p);
+  __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddr(addr);
+  if (!m) return kIgnoreObjectInvalid;
+  if ((m->chunk_state == __asan::CHUNK_ALLOCATED) && m->AddrIsInside(addr)) {
+    if (m->lsan_tag == kIgnored)
+      return kIgnoreObjectAlreadyIgnored;
+    m->lsan_tag = __lsan::kIgnored;
+    return kIgnoreObjectSuccess;
+  } else {
+    return kIgnoreObjectInvalid;
+  }
+}
+}  // namespace __lsan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+// ASan allocator doesn't reserve extra bytes, so normally we would
+// just return "size". We don't want to expose our redzone sizes, etc here.
+uptr __sanitizer_get_estimated_allocated_size(uptr size) {
+  return size;
+}
+
+int __sanitizer_get_ownership(const void *p) {
+  uptr ptr = reinterpret_cast<uptr>(p);
+  return instance.AllocationSize(ptr) > 0;
+}
+
+uptr __sanitizer_get_allocated_size(const void *p) {
+  if (!p) return 0;
+  uptr ptr = reinterpret_cast<uptr>(p);
+  uptr allocated_size = instance.AllocationSize(ptr);
+  // Die if p is not malloced or if it is already freed.
+  if (allocated_size == 0) {
+    GET_STACK_TRACE_FATAL_HERE;
+    ReportSanitizerGetAllocatedSizeNotOwned(ptr, &stack);
+  }
+  return allocated_size;
+}
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
+// Provide default (no-op) implementation of malloc hooks.
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+void __sanitizer_malloc_hook(void *ptr, uptr size) {
+  (void)ptr;
+  (void)size;
+}
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+void __sanitizer_free_hook(void *ptr) {
+  (void)ptr;
+}
+} // extern "C"
+#endif
diff --git a/compiler-rt/lib/asan/asan_allocator.h b/compiler-rt/lib/asan/asan_allocator.h
new file mode 100644
index 0000000..e3d5333
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_allocator.h
@@ -0,0 +1,184 @@
+//===-- asan_allocator.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_allocator.cc.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_ALLOCATOR_H
+#define ASAN_ALLOCATOR_H
+
+#include "asan_flags.h"
+#include "asan_internal.h"
+#include "asan_interceptors.h"
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_list.h"
+
+namespace __asan {
+
+enum AllocType {
+  FROM_MALLOC = 1,  // Memory block came from malloc, calloc, realloc, etc.
+  FROM_NEW = 2,     // Memory block came from operator new.
+  FROM_NEW_BR = 3   // Memory block came from operator new [ ]
+};
+
+struct AsanChunk;
+
+struct AllocatorOptions {
+  u32 quarantine_size_mb;
+  u16 min_redzone;
+  u16 max_redzone;
+  u8 may_return_null;
+  u8 alloc_dealloc_mismatch;
+
+  void SetFrom(const Flags *f, const CommonFlags *cf);
+  void CopyTo(Flags *f, CommonFlags *cf);
+};
+
+void InitializeAllocator(const AllocatorOptions &options);
+void ReInitializeAllocator(const AllocatorOptions &options);
+void GetAllocatorOptions(AllocatorOptions *options);
+
+class AsanChunkView {
+ public:
+  explicit AsanChunkView(AsanChunk *chunk) : chunk_(chunk) {}
+  bool IsValid();   // Checks if AsanChunkView points to a valid allocated
+                    // or quarantined chunk.
+  uptr Beg();       // First byte of user memory.
+  uptr End();       // Last byte of user memory.
+  uptr UsedSize();  // Size requested by the user.
+  uptr AllocTid();
+  uptr FreeTid();
+  bool Eq(const AsanChunkView &c) const { return chunk_ == c.chunk_; }
+  StackTrace GetAllocStack();
+  StackTrace GetFreeStack();
+  bool AddrIsInside(uptr addr, uptr access_size, sptr *offset) {
+    if (addr >= Beg() && (addr + access_size) <= End()) {
+      *offset = addr - Beg();
+      return true;
+    }
+    return false;
+  }
+  bool AddrIsAtLeft(uptr addr, uptr access_size, sptr *offset) {
+    (void)access_size;
+    if (addr < Beg()) {
+      *offset = Beg() - addr;
+      return true;
+    }
+    return false;
+  }
+  bool AddrIsAtRight(uptr addr, uptr access_size, sptr *offset) {
+    if (addr + access_size > End()) {
+      *offset = addr - End();
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  AsanChunk *const chunk_;
+};
+
+AsanChunkView FindHeapChunkByAddress(uptr address);
+
+// List of AsanChunks with total size.
+class AsanChunkFifoList: public IntrusiveList<AsanChunk> {
+ public:
+  explicit AsanChunkFifoList(LinkerInitialized) { }
+  AsanChunkFifoList() { clear(); }
+  void Push(AsanChunk *n);
+  void PushList(AsanChunkFifoList *q);
+  AsanChunk *Pop();
+  uptr size() { return size_; }
+  void clear() {
+    IntrusiveList<AsanChunk>::clear();
+    size_ = 0;
+  }
+ private:
+  uptr size_;
+};
+
+struct AsanMapUnmapCallback {
+  void OnMap(uptr p, uptr size) const;
+  void OnUnmap(uptr p, uptr size) const;
+};
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+# if defined(__powerpc64__)
+const uptr kAllocatorSpace =  0xa0000000000ULL;
+const uptr kAllocatorSize  =  0x20000000000ULL;  // 2T.
+# elif defined(__aarch64__)
+// AArch64/SANITIZIER_CAN_USER_ALLOCATOR64 is only for 42-bit VMA
+// so no need to different values for different VMA.
+const uptr kAllocatorSpace =  0x10000000000ULL;
+const uptr kAllocatorSize  =  0x10000000000ULL;  // 3T.
+# else
+const uptr kAllocatorSpace = 0x600000000000ULL;
+const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
+# endif
+typedef DefaultSizeClassMap SizeClassMap;
+typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, 0 /*metadata*/,
+    SizeClassMap, AsanMapUnmapCallback> PrimaryAllocator;
+#else  // Fallback to SizeClassAllocator32.
+static const uptr kRegionSizeLog = 20;
+static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+# if SANITIZER_WORDSIZE == 32
+typedef FlatByteMap<kNumRegions> ByteMap;
+# elif SANITIZER_WORDSIZE == 64
+typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+# endif
+typedef CompactSizeClassMap SizeClassMap;
+typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, 16,
+  SizeClassMap, kRegionSizeLog,
+  ByteMap,
+  AsanMapUnmapCallback> PrimaryAllocator;
+#endif  // SANITIZER_CAN_USE_ALLOCATOR64
+
+static const uptr kNumberOfSizeClasses = SizeClassMap::kNumClasses;
+typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef LargeMmapAllocator<AsanMapUnmapCallback> SecondaryAllocator;
+typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
+    SecondaryAllocator> AsanAllocator;
+
+
+struct AsanThreadLocalMallocStorage {
+  uptr quarantine_cache[16];
+  AllocatorCache allocator_cache;
+  void CommitBack();
+ private:
+  // These objects are allocated via mmap() and are zero-initialized.
+  AsanThreadLocalMallocStorage() {}
+};
+
+void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
+                    AllocType alloc_type);
+void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type);
+void asan_sized_free(void *ptr, uptr size, BufferedStackTrace *stack,
+                     AllocType alloc_type);
+
+void *asan_malloc(uptr size, BufferedStackTrace *stack);
+void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack);
+void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack);
+void *asan_valloc(uptr size, BufferedStackTrace *stack);
+void *asan_pvalloc(uptr size, BufferedStackTrace *stack);
+
+int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
+                        BufferedStackTrace *stack);
+uptr asan_malloc_usable_size(void *ptr, uptr pc, uptr bp);
+
+uptr asan_mz_size(const void *ptr);
+void asan_mz_force_lock();
+void asan_mz_force_unlock();
+
+void PrintInternalAllocatorStats();
+void AsanSoftRssLimitExceededCallback(bool exceeded);
+
+}  // namespace __asan
+#endif  // ASAN_ALLOCATOR_H
diff --git a/compiler-rt/lib/asan/asan_android_stub.cc b/compiler-rt/lib/asan/asan_android_stub.cc
new file mode 100644
index 0000000..cf68f58
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_android_stub.cc
@@ -0,0 +1,4 @@
+#include "sanitizer/asan_interface.h"
+
+__attribute__((section(".preinit_array")))
+  typeof(__asan_init) *__asan_preinit =__asan_init;
diff --git a/compiler-rt/lib/asan/asan_blacklist.txt b/compiler-rt/lib/asan/asan_blacklist.txt
new file mode 100644
index 0000000..c25921f
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_blacklist.txt
@@ -0,0 +1,13 @@
+# Blacklist for AddressSanitizer. Turns off instrumentation of particular
+# functions or sources. Use with care. You may set location of blacklist
+# at compile-time using -fsanitize-blacklist=<path> flag.
+
+# Example usage:
+# fun:*bad_function_name*
+# src:file_with_tricky_code.cc
+# global:*global_with_bad_access_or_initialization*
+# global:*global_with_initialization_issues*=init
+# type:*Namespace::ClassName*=init
+
+# Stack buffer overflow in VC/INCLUDE/xlocnum, see http://goo.gl/L4qqUG
+fun:*_Find_elem@*@std*
diff --git a/compiler-rt/lib/asan/asan_debugging.cc b/compiler-rt/lib/asan/asan_debugging.cc
new file mode 100644
index 0000000..7c3a8a7
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_debugging.cc
@@ -0,0 +1,141 @@
+//===-- asan_debugging.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This file contains various functions that are generally useful to call when
+// using a debugger (LLDB, GDB).
+//===----------------------------------------------------------------------===//
+
+#include "asan_allocator.h"
+#include "asan_flags.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_report.h"
+#include "asan_thread.h"
+
+namespace __asan {
+
+void GetInfoForStackVar(uptr addr, AddressDescription *descr, AsanThread *t) {
+  descr->name[0] = 0;
+  descr->region_address = 0;
+  descr->region_size = 0;
+  descr->region_kind = "stack";
+
+  AsanThread::StackFrameAccess access;
+  if (!t->GetStackFrameAccessByAddr(addr, &access))
+    return;
+  InternalMmapVector<StackVarDescr> vars(16);
+  if (!ParseFrameDescription(access.frame_descr, &vars)) {
+    return;
+  }
+
+  for (uptr i = 0; i < vars.size(); i++) {
+    if (access.offset <= vars[i].beg + vars[i].size) {
+      internal_strncat(descr->name, vars[i].name_pos,
+                       Min(descr->name_size, vars[i].name_len));
+      descr->region_address = addr - (access.offset - vars[i].beg);
+      descr->region_size = vars[i].size;
+      return;
+    }
+  }
+}
+
+void GetInfoForHeapAddress(uptr addr, AddressDescription *descr) {
+  AsanChunkView chunk = FindHeapChunkByAddress(addr);
+
+  descr->name[0] = 0;
+  descr->region_address = 0;
+  descr->region_size = 0;
+
+  if (!chunk.IsValid()) {
+    descr->region_kind = "heap-invalid";
+    return;
+  }
+
+  descr->region_address = chunk.Beg();
+  descr->region_size = chunk.UsedSize();
+  descr->region_kind = "heap";
+}
+
+void AsanLocateAddress(uptr addr, AddressDescription *descr) {
+  if (DescribeAddressIfShadow(addr, descr, /* print */ false)) {
+    return;
+  }
+  if (GetInfoForAddressIfGlobal(addr, descr)) {
+    return;
+  }
+  asanThreadRegistry().Lock();
+  AsanThread *thread = FindThreadByStackAddress(addr);
+  asanThreadRegistry().Unlock();
+  if (thread) {
+    GetInfoForStackVar(addr, descr, thread);
+    return;
+  }
+  GetInfoForHeapAddress(addr, descr);
+}
+
+static uptr AsanGetStack(uptr addr, uptr *trace, u32 size, u32 *thread_id,
+                         bool alloc_stack) {
+  AsanChunkView chunk = FindHeapChunkByAddress(addr);
+  if (!chunk.IsValid()) return 0;
+
+  StackTrace stack(nullptr, 0);
+  if (alloc_stack) {
+    if (chunk.AllocTid() == kInvalidTid) return 0;
+    stack = chunk.GetAllocStack();
+    if (thread_id) *thread_id = chunk.AllocTid();
+  } else {
+    if (chunk.FreeTid() == kInvalidTid) return 0;
+    stack = chunk.GetFreeStack();
+    if (thread_id) *thread_id = chunk.FreeTid();
+  }
+
+  if (trace && size) {
+    size = Min(size, Min(stack.size, kStackTraceMax));
+    for (uptr i = 0; i < size; i++)
+      trace[i] = StackTrace::GetPreviousInstructionPc(stack.trace[i]);
+
+    return size;
+  }
+
+  return 0;
+}
+
+} // namespace __asan
+
+using namespace __asan;
+
+SANITIZER_INTERFACE_ATTRIBUTE
+const char *__asan_locate_address(uptr addr, char *name, uptr name_size,
+                                  uptr *region_address, uptr *region_size) {
+  AddressDescription descr = { name, name_size, 0, 0, nullptr };
+  AsanLocateAddress(addr, &descr);
+  if (region_address) *region_address = descr.region_address;
+  if (region_size) *region_size = descr.region_size;
+  return descr.region_kind;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __asan_get_alloc_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {
+  return AsanGetStack(addr, trace, size, thread_id, /* alloc_stack */ true);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __asan_get_free_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {
+  return AsanGetStack(addr, trace, size, thread_id, /* alloc_stack */ false);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __asan_get_shadow_mapping(uptr *shadow_scale, uptr *shadow_offset) {
+  if (shadow_scale)
+    *shadow_scale = SHADOW_SCALE;
+  if (shadow_offset)
+    *shadow_offset = SHADOW_OFFSET;
+}
diff --git a/compiler-rt/lib/asan/asan_fake_stack.cc b/compiler-rt/lib/asan/asan_fake_stack.cc
new file mode 100644
index 0000000..91fdf0a
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_fake_stack.cc
@@ -0,0 +1,283 @@
+//===-- asan_fake_stack.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// FakeStack is used to detect use-after-return bugs.
+//===----------------------------------------------------------------------===//
+
+#include "asan_allocator.h"
+#include "asan_poisoning.h"
+#include "asan_thread.h"
+
+namespace __asan {
+
+static const u64 kMagic1 = kAsanStackAfterReturnMagic;
+static const u64 kMagic2 = (kMagic1 << 8) | kMagic1;
+static const u64 kMagic4 = (kMagic2 << 16) | kMagic2;
+static const u64 kMagic8 = (kMagic4 << 32) | kMagic4;
+
+static const u64 kAllocaRedzoneSize = 32UL;
+static const u64 kAllocaRedzoneMask = 31UL;
+
+// For small size classes inline PoisonShadow for better performance.
+ALWAYS_INLINE void SetShadow(uptr ptr, uptr size, uptr class_id, u64 magic) {
+  CHECK_EQ(SHADOW_SCALE, 3);  // This code expects SHADOW_SCALE=3.
+  u64 *shadow = reinterpret_cast<u64*>(MemToShadow(ptr));
+  if (class_id <= 6) {
+    for (uptr i = 0; i < (1U << class_id); i++) {
+      shadow[i] = magic;
+      // Make sure this does not become memset.
+      SanitizerBreakOptimization(nullptr);
+    }
+  } else {
+    // The size class is too big, it's cheaper to poison only size bytes.
+    PoisonShadow(ptr, size, static_cast<u8>(magic));
+  }
+}
+
+FakeStack *FakeStack::Create(uptr stack_size_log) {
+  static uptr kMinStackSizeLog = 16;
+  static uptr kMaxStackSizeLog = FIRST_32_SECOND_64(24, 28);
+  if (stack_size_log < kMinStackSizeLog)
+    stack_size_log = kMinStackSizeLog;
+  if (stack_size_log > kMaxStackSizeLog)
+    stack_size_log = kMaxStackSizeLog;
+  uptr size = RequiredSize(stack_size_log);
+  FakeStack *res = reinterpret_cast<FakeStack *>(
+      flags()->uar_noreserve ? MmapNoReserveOrDie(size, "FakeStack")
+                             : MmapOrDie(size, "FakeStack"));
+  res->stack_size_log_ = stack_size_log;
+  u8 *p = reinterpret_cast<u8 *>(res);
+  VReport(1, "T%d: FakeStack created: %p -- %p stack_size_log: %zd; "
+          "mmapped %zdK, noreserve=%d \n",
+          GetCurrentTidOrInvalid(), p,
+          p + FakeStack::RequiredSize(stack_size_log), stack_size_log,
+          size >> 10, flags()->uar_noreserve);
+  return res;
+}
+
+void FakeStack::Destroy(int tid) {
+  PoisonAll(0);
+  if (Verbosity() >= 2) {
+    InternalScopedString str(kNumberOfSizeClasses * 50);
+    for (uptr class_id = 0; class_id < kNumberOfSizeClasses; class_id++)
+      str.append("%zd: %zd/%zd; ", class_id, hint_position_[class_id],
+                 NumberOfFrames(stack_size_log(), class_id));
+    Report("T%d: FakeStack destroyed: %s\n", tid, str.data());
+  }
+  uptr size = RequiredSize(stack_size_log_);
+  FlushUnneededASanShadowMemory(reinterpret_cast<uptr>(this), size);
+  UnmapOrDie(this, size);
+}
+
+void FakeStack::PoisonAll(u8 magic) {
+  PoisonShadow(reinterpret_cast<uptr>(this), RequiredSize(stack_size_log()),
+               magic);
+}
+
+#if !defined(_MSC_VER) || defined(__clang__)
+ALWAYS_INLINE USED
+#endif
+FakeFrame *FakeStack::Allocate(uptr stack_size_log, uptr class_id,
+                               uptr real_stack) {
+  CHECK_LT(class_id, kNumberOfSizeClasses);
+  if (needs_gc_)
+    GC(real_stack);
+  uptr &hint_position = hint_position_[class_id];
+  const int num_iter = NumberOfFrames(stack_size_log, class_id);
+  u8 *flags = GetFlags(stack_size_log, class_id);
+  for (int i = 0; i < num_iter; i++) {
+    uptr pos = ModuloNumberOfFrames(stack_size_log, class_id, hint_position++);
+    // This part is tricky. On one hand, checking and setting flags[pos]
+    // should be atomic to ensure async-signal safety. But on the other hand,
+    // if the signal arrives between checking and setting flags[pos], the
+    // signal handler's fake stack will start from a different hint_position
+    // and so will not touch this particular byte. So, it is safe to do this
+    // with regular non-atimic load and store (at least I was not able to make
+    // this code crash).
+    if (flags[pos]) continue;
+    flags[pos] = 1;
+    FakeFrame *res = reinterpret_cast<FakeFrame *>(
+        GetFrame(stack_size_log, class_id, pos));
+    res->real_stack = real_stack;
+    *SavedFlagPtr(reinterpret_cast<uptr>(res), class_id) = &flags[pos];
+    return res;
+  }
+  return nullptr; // We are out of fake stack.
+}
+
+uptr FakeStack::AddrIsInFakeStack(uptr ptr, uptr *frame_beg, uptr *frame_end) {
+  uptr stack_size_log = this->stack_size_log();
+  uptr beg = reinterpret_cast<uptr>(GetFrame(stack_size_log, 0, 0));
+  uptr end = reinterpret_cast<uptr>(this) + RequiredSize(stack_size_log);
+  if (ptr < beg || ptr >= end) return 0;
+  uptr class_id = (ptr - beg) >> stack_size_log;
+  uptr base = beg + (class_id << stack_size_log);
+  CHECK_LE(base, ptr);
+  CHECK_LT(ptr, base + (1UL << stack_size_log));
+  uptr pos = (ptr - base) >> (kMinStackFrameSizeLog + class_id);
+  uptr res = base + pos * BytesInSizeClass(class_id);
+  *frame_end = res + BytesInSizeClass(class_id);
+  *frame_beg = res + sizeof(FakeFrame);
+  return res;
+}
+
+void FakeStack::HandleNoReturn() {
+  needs_gc_ = true;
+}
+
+// When throw, longjmp or some such happens we don't call OnFree() and
+// as the result may leak one or more fake frames, but the good news is that
+// we are notified about all such events by HandleNoReturn().
+// If we recently had such no-return event we need to collect garbage frames.
+// We do it based on their 'real_stack' values -- everything that is lower
+// than the current real_stack is garbage.
+NOINLINE void FakeStack::GC(uptr real_stack) {
+  uptr collected = 0;
+  for (uptr class_id = 0; class_id < kNumberOfSizeClasses; class_id++) {
+    u8 *flags = GetFlags(stack_size_log(), class_id);
+    for (uptr i = 0, n = NumberOfFrames(stack_size_log(), class_id); i < n;
+         i++) {
+      if (flags[i] == 0) continue;  // not allocated.
+      FakeFrame *ff = reinterpret_cast<FakeFrame *>(
+          GetFrame(stack_size_log(), class_id, i));
+      if (ff->real_stack < real_stack) {
+        flags[i] = 0;
+        collected++;
+      }
+    }
+  }
+  needs_gc_ = false;
+}
+
+void FakeStack::ForEachFakeFrame(RangeIteratorCallback callback, void *arg) {
+  for (uptr class_id = 0; class_id < kNumberOfSizeClasses; class_id++) {
+    u8 *flags = GetFlags(stack_size_log(), class_id);
+    for (uptr i = 0, n = NumberOfFrames(stack_size_log(), class_id); i < n;
+         i++) {
+      if (flags[i] == 0) continue;  // not allocated.
+      FakeFrame *ff = reinterpret_cast<FakeFrame *>(
+          GetFrame(stack_size_log(), class_id, i));
+      uptr begin = reinterpret_cast<uptr>(ff);
+      callback(begin, begin + FakeStack::BytesInSizeClass(class_id), arg);
+    }
+  }
+}
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+static THREADLOCAL FakeStack *fake_stack_tls;
+
+FakeStack *GetTLSFakeStack() {
+  return fake_stack_tls;
+}
+void SetTLSFakeStack(FakeStack *fs) {
+  fake_stack_tls = fs;
+}
+#else
+FakeStack *GetTLSFakeStack() { return 0; }
+void SetTLSFakeStack(FakeStack *fs) { }
+#endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+static FakeStack *GetFakeStack() {
+  AsanThread *t = GetCurrentThread();
+  if (!t) return nullptr;
+  return t->fake_stack();
+}
+
+static FakeStack *GetFakeStackFast() {
+  if (FakeStack *fs = GetTLSFakeStack())
+    return fs;
+  if (!__asan_option_detect_stack_use_after_return)
+    return nullptr;
+  return GetFakeStack();
+}
+
+ALWAYS_INLINE uptr OnMalloc(uptr class_id, uptr size) {
+  FakeStack *fs = GetFakeStackFast();
+  if (!fs) return 0;
+  uptr local_stack;
+  uptr real_stack = reinterpret_cast<uptr>(&local_stack);
+  FakeFrame *ff = fs->Allocate(fs->stack_size_log(), class_id, real_stack);
+  if (!ff) return 0;  // Out of fake stack.
+  uptr ptr = reinterpret_cast<uptr>(ff);
+  SetShadow(ptr, size, class_id, 0);
+  return ptr;
+}
+
+ALWAYS_INLINE void OnFree(uptr ptr, uptr class_id, uptr size) {
+  FakeStack::Deallocate(ptr, class_id);
+  SetShadow(ptr, size, class_id, kMagic8);
+}
+
+} // namespace __asan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;
+#define DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(class_id)                       \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr                                \
+      __asan_stack_malloc_##class_id(uptr size) {                              \
+    return OnMalloc(class_id, size);                                           \
+  }                                                                            \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __asan_stack_free_##class_id(  \
+      uptr ptr, uptr size) {                                                   \
+    OnFree(ptr, class_id, size);                                               \
+  }
+
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(0)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(1)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(2)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(3)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(4)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(5)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(6)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(7)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(8)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(9)
+DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(10)
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__asan_get_current_fake_stack() { return GetFakeStackFast(); }
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__asan_addr_is_in_fake_stack(void *fake_stack, void *addr, void **beg,
+                                   void **end) {
+  FakeStack *fs = reinterpret_cast<FakeStack*>(fake_stack);
+  if (!fs) return nullptr;
+  uptr frame_beg, frame_end;
+  FakeFrame *frame = reinterpret_cast<FakeFrame *>(fs->AddrIsInFakeStack(
+      reinterpret_cast<uptr>(addr), &frame_beg, &frame_end));
+  if (!frame) return nullptr;
+  if (frame->magic != kCurrentStackFrameMagic)
+    return nullptr;
+  if (beg) *beg = reinterpret_cast<void*>(frame_beg);
+  if (end) *end = reinterpret_cast<void*>(frame_end);
+  return reinterpret_cast<void*>(frame->real_stack);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __asan_alloca_poison(uptr addr, uptr size) {
+  uptr LeftRedzoneAddr = addr - kAllocaRedzoneSize;
+  uptr PartialRzAddr = addr + size;
+  uptr RightRzAddr = (PartialRzAddr + kAllocaRedzoneMask) & ~kAllocaRedzoneMask;
+  uptr PartialRzAligned = PartialRzAddr & ~(SHADOW_GRANULARITY - 1);
+  FastPoisonShadow(LeftRedzoneAddr, kAllocaRedzoneSize, kAsanAllocaLeftMagic);
+  FastPoisonShadowPartialRightRedzone(
+      PartialRzAligned, PartialRzAddr % SHADOW_GRANULARITY,
+      RightRzAddr - PartialRzAligned, kAsanAllocaRightMagic);
+  FastPoisonShadow(RightRzAddr, kAllocaRedzoneSize, kAsanAllocaRightMagic);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __asan_allocas_unpoison(uptr top, uptr bottom) {
+  if ((!top) || (top > bottom)) return;
+  REAL(memset)(reinterpret_cast<void*>(MemToShadow(top)), 0,
+               (bottom - top) / SHADOW_GRANULARITY);
+}
+} // extern "C"
diff --git a/compiler-rt/lib/asan/asan_fake_stack.h b/compiler-rt/lib/asan/asan_fake_stack.h
new file mode 100644
index 0000000..3b1d9eb
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_fake_stack.h
@@ -0,0 +1,175 @@
+//===-- asan_fake_stack.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_fake_stack.cc, implements FakeStack.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_FAKE_STACK_H
+#define ASAN_FAKE_STACK_H
+
+#include "sanitizer_common/sanitizer_common.h"
+
+namespace __asan {
+
+// Fake stack frame contains local variables of one function.
+struct FakeFrame {
+  uptr magic;  // Modified by the instrumented code.
+  uptr descr;  // Modified by the instrumented code.
+  uptr pc;     // Modified by the instrumented code.
+  uptr real_stack;
+};
+
+// For each thread we create a fake stack and place stack objects on this fake
+// stack instead of the real stack. The fake stack is not really a stack but
+// a fast malloc-like allocator so that when a function exits the fake stack
+// is not popped but remains there for quite some time until gets used again.
+// So, we poison the objects on the fake stack when function returns.
+// It helps us find use-after-return bugs.
+//
+// The FakeStack objects is allocated by a single mmap call and has no other
+// pointers. The size of the fake stack depends on the actual thread stack size
+// and thus can not be a constant.
+// stack_size is a power of two greater or equal to the thread's stack size;
+// we store it as its logarithm (stack_size_log).
+// FakeStack has kNumberOfSizeClasses (11) size classes, each size class
+// is a power of two, starting from 64 bytes. Each size class occupies
+// stack_size bytes and thus can allocate
+// NumberOfFrames=(stack_size/BytesInSizeClass) fake frames (also a power of 2).
+// For each size class we have NumberOfFrames allocation flags,
+// each flag indicates whether the given frame is currently allocated.
+// All flags for size classes 0 .. 10 are stored in a single contiguous region
+// followed by another contiguous region which contains the actual memory for
+// size classes. The addresses are computed by GetFlags and GetFrame without
+// any memory accesses solely based on 'this' and stack_size_log.
+// Allocate() flips the appropriate allocation flag atomically, thus achieving
+// async-signal safety.
+// This allocator does not have quarantine per se, but it tries to allocate the
+// frames in round robin fasion to maximize the delay between a deallocation
+// and the next allocation.
+class FakeStack {
+  static const uptr kMinStackFrameSizeLog = 6;  // Min frame is 64B.
+  static const uptr kMaxStackFrameSizeLog = 16;  // Max stack frame is 64K.
+
+ public:
+  static const uptr kNumberOfSizeClasses =
+       kMaxStackFrameSizeLog - kMinStackFrameSizeLog + 1;
+
+  // CTOR: create the FakeStack as a single mmap-ed object.
+  static FakeStack *Create(uptr stack_size_log);
+
+  void Destroy(int tid);
+
+  // stack_size_log is at least 15 (stack_size >= 32K).
+  static uptr SizeRequiredForFlags(uptr stack_size_log) {
+    return 1UL << (stack_size_log + 1 - kMinStackFrameSizeLog);
+  }
+
+  // Each size class occupies stack_size bytes.
+  static uptr SizeRequiredForFrames(uptr stack_size_log) {
+    return (1ULL << stack_size_log) * kNumberOfSizeClasses;
+  }
+
+  // Number of bytes requires for the whole object.
+  static uptr RequiredSize(uptr stack_size_log) {
+    return kFlagsOffset + SizeRequiredForFlags(stack_size_log) +
+           SizeRequiredForFrames(stack_size_log);
+  }
+
+  // Offset of the given flag from the first flag.
+  // The flags for class 0 begin at offset  000000000
+  // The flags for class 1 begin at offset  100000000
+  // ....................2................  110000000
+  // ....................3................  111000000
+  // and so on.
+  static uptr FlagsOffset(uptr stack_size_log, uptr class_id) {
+    uptr t = kNumberOfSizeClasses - 1 - class_id;
+    const uptr all_ones = (1 << (kNumberOfSizeClasses - 1)) - 1;
+    return ((all_ones >> t) << t) << (stack_size_log - 15);
+  }
+
+  static uptr NumberOfFrames(uptr stack_size_log, uptr class_id) {
+    return 1UL << (stack_size_log - kMinStackFrameSizeLog - class_id);
+  }
+
+  // Divide n by the numbe of frames in size class.
+  static uptr ModuloNumberOfFrames(uptr stack_size_log, uptr class_id, uptr n) {
+    return n & (NumberOfFrames(stack_size_log, class_id) - 1);
+  }
+
+  // The the pointer to the flags of the given class_id.
+  u8 *GetFlags(uptr stack_size_log, uptr class_id) {
+    return reinterpret_cast<u8 *>(this) + kFlagsOffset +
+           FlagsOffset(stack_size_log, class_id);
+  }
+
+  // Get frame by class_id and pos.
+  u8 *GetFrame(uptr stack_size_log, uptr class_id, uptr pos) {
+    return reinterpret_cast<u8 *>(this) + kFlagsOffset +
+           SizeRequiredForFlags(stack_size_log) +
+           (1 << stack_size_log) * class_id + BytesInSizeClass(class_id) * pos;
+  }
+
+  // Allocate the fake frame.
+  FakeFrame *Allocate(uptr stack_size_log, uptr class_id, uptr real_stack);
+
+  // Deallocate the fake frame: read the saved flag address and write 0 there.
+  static void Deallocate(uptr x, uptr class_id) {
+    **SavedFlagPtr(x, class_id) = 0;
+  }
+
+  // Poison the entire FakeStack's shadow with the magic value.
+  void PoisonAll(u8 magic);
+
+  // Return the beginning of the FakeFrame or 0 if the address is not ours.
+  uptr AddrIsInFakeStack(uptr addr, uptr *frame_beg, uptr *frame_end);
+  USED uptr AddrIsInFakeStack(uptr addr) {
+    uptr t1, t2;
+    return AddrIsInFakeStack(addr, &t1, &t2);
+  }
+
+  // Number of bytes in a fake frame of this size class.
+  static uptr BytesInSizeClass(uptr class_id) {
+    return 1UL << (class_id + kMinStackFrameSizeLog);
+  }
+
+  // The fake frame is guaranteed to have a right redzone.
+  // We use the last word of that redzone to store the address of the flag
+  // that corresponds to the current frame to make faster deallocation.
+  static u8 **SavedFlagPtr(uptr x, uptr class_id) {
+    return reinterpret_cast<u8 **>(x + BytesInSizeClass(class_id) - sizeof(x));
+  }
+
+  uptr stack_size_log() const { return stack_size_log_; }
+
+  void HandleNoReturn();
+  void GC(uptr real_stack);
+
+  void ForEachFakeFrame(RangeIteratorCallback callback, void *arg);
+
+ private:
+  FakeStack() { }
+  static const uptr kFlagsOffset = 4096;  // This is were the flags begin.
+  // Must match the number of uses of DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID
+  COMPILER_CHECK(kNumberOfSizeClasses == 11);
+  static const uptr kMaxStackMallocSize = 1 << kMaxStackFrameSizeLog;
+
+  uptr hint_position_[kNumberOfSizeClasses];
+  uptr stack_size_log_;
+  // a bit is set if something was allocated from the corresponding size class.
+  bool needs_gc_;
+};
+
+FakeStack *GetTLSFakeStack();
+void SetTLSFakeStack(FakeStack *fs);
+
+}  // namespace __asan
+
+#endif  // ASAN_FAKE_STACK_H
diff --git a/compiler-rt/lib/asan/asan_flags.cc b/compiler-rt/lib/asan/asan_flags.cc
new file mode 100644
index 0000000..363ee67
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_flags.cc
@@ -0,0 +1,171 @@
+//===-- asan_flags.cc -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan flag parsing logic.
+//===----------------------------------------------------------------------===//
+
+#include "asan_activation.h"
+#include "asan_flags.h"
+#include "asan_interface_internal.h"
+#include "asan_stack.h"
+#include "lsan/lsan_common.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "ubsan/ubsan_flags.h"
+#include "ubsan/ubsan_platform.h"
+
+namespace __asan {
+
+Flags asan_flags_dont_use_directly;  // use via flags().
+
+static const char *MaybeCallAsanDefaultOptions() {
+  return (&__asan_default_options) ? __asan_default_options() : "";
+}
+
+static const char *MaybeUseAsanDefaultOptionsCompileDefinition() {
+#ifdef ASAN_DEFAULT_OPTIONS
+// Stringize the macro value.
+# define ASAN_STRINGIZE(x) #x
+# define ASAN_STRINGIZE_OPTIONS(options) ASAN_STRINGIZE(options)
+  return ASAN_STRINGIZE_OPTIONS(ASAN_DEFAULT_OPTIONS);
+#else
+  return "";
+#endif
+}
+
+void Flags::SetDefaults() {
+#define ASAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "asan_flags.inc"
+#undef ASAN_FLAG
+}
+
+static void RegisterAsanFlags(FlagParser *parser, Flags *f) {
+#define ASAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "asan_flags.inc"
+#undef ASAN_FLAG
+}
+
+void InitializeFlags() {
+  // Set the default values and prepare for parsing ASan and common flags.
+  SetCommonFlagsDefaults();
+  {
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.detect_leaks = CAN_SANITIZE_LEAKS;
+    cf.external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
+    cf.malloc_context_size = kDefaultMallocContextSize;
+    cf.intercept_tls_get_addr = true;
+    cf.exitcode = 1;
+    OverrideCommonFlags(cf);
+  }
+  Flags *f = flags();
+  f->SetDefaults();
+
+  FlagParser asan_parser;
+  RegisterAsanFlags(&asan_parser, f);
+  RegisterCommonFlags(&asan_parser);
+
+  // Set the default values and prepare for parsing LSan and UBSan flags
+  // (which can also overwrite common flags).
+#if CAN_SANITIZE_LEAKS
+  __lsan::Flags *lf = __lsan::flags();
+  lf->SetDefaults();
+
+  FlagParser lsan_parser;
+  __lsan::RegisterLsanFlags(&lsan_parser, lf);
+  RegisterCommonFlags(&lsan_parser);
+#endif
+
+#if CAN_SANITIZE_UB
+  __ubsan::Flags *uf = __ubsan::flags();
+  uf->SetDefaults();
+
+  FlagParser ubsan_parser;
+  __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
+  RegisterCommonFlags(&ubsan_parser);
+#endif
+
+  // Override from ASan compile definition.
+  const char *asan_compile_def = MaybeUseAsanDefaultOptionsCompileDefinition();
+  asan_parser.ParseString(asan_compile_def);
+
+  // Override from user-specified string.
+  const char *asan_default_options = MaybeCallAsanDefaultOptions();
+  asan_parser.ParseString(asan_default_options);
+#if CAN_SANITIZE_UB
+  const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
+  ubsan_parser.ParseString(ubsan_default_options);
+#endif
+
+  // Override from command line.
+  asan_parser.ParseString(GetEnv("ASAN_OPTIONS"));
+#if CAN_SANITIZE_LEAKS
+  lsan_parser.ParseString(GetEnv("LSAN_OPTIONS"));
+#endif
+#if CAN_SANITIZE_UB
+  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+#endif
+
+  SetVerbosity(common_flags()->verbosity);
+
+  // TODO(eugenis): dump all flags at verbosity>=2?
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) {
+    // TODO(samsonov): print all of the flags (ASan, LSan, common).
+    asan_parser.PrintFlagDescriptions();
+  }
+
+  // Flag validation:
+  if (!CAN_SANITIZE_LEAKS && common_flags()->detect_leaks) {
+    Report("%s: detect_leaks is not supported on this platform.\n",
+           SanitizerToolName);
+    Die();
+  }
+  // Make "strict_init_order" imply "check_initialization_order".
+  // TODO(samsonov): Use a single runtime flag for an init-order checker.
+  if (f->strict_init_order) {
+    f->check_initialization_order = true;
+  }
+  CHECK_LE((uptr)common_flags()->malloc_context_size, kStackTraceMax);
+  CHECK_LE(f->min_uar_stack_size_log, f->max_uar_stack_size_log);
+  CHECK_GE(f->redzone, 16);
+  CHECK_GE(f->max_redzone, f->redzone);
+  CHECK_LE(f->max_redzone, 2048);
+  CHECK(IsPowerOfTwo(f->redzone));
+  CHECK(IsPowerOfTwo(f->max_redzone));
+
+  // quarantine_size is deprecated but we still honor it.
+  // quarantine_size can not be used together with quarantine_size_mb.
+  if (f->quarantine_size >= 0 && f->quarantine_size_mb >= 0) {
+    Report("%s: please use either 'quarantine_size' (deprecated) or "
+           "quarantine_size_mb, but not both\n", SanitizerToolName);
+    Die();
+  }
+  if (f->quarantine_size >= 0)
+    f->quarantine_size_mb = f->quarantine_size >> 20;
+  if (f->quarantine_size_mb < 0) {
+    const int kDefaultQuarantineSizeMb =
+        (ASAN_LOW_MEMORY) ? 1UL << 6 : 1UL << 8;
+    f->quarantine_size_mb = kDefaultQuarantineSizeMb;
+  }
+}
+
+}  // namespace __asan
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+const char* __asan_default_options() { return ""; }
+}  // extern "C"
+#endif
diff --git a/compiler-rt/lib/asan/asan_flags.h b/compiler-rt/lib/asan/asan_flags.h
new file mode 100644
index 0000000..4935161
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_flags.h
@@ -0,0 +1,49 @@
+//===-- asan_flags.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan runtime flags.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_FLAGS_H
+#define ASAN_FLAGS_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+
+// ASan flag values can be defined in four ways:
+// 1) initialized with default values at startup.
+// 2) overriden during compilation of ASan runtime by providing
+//    compile definition ASAN_DEFAULT_OPTIONS.
+// 3) overriden from string returned by user-specified function
+//    __asan_default_options().
+// 4) overriden from env variable ASAN_OPTIONS.
+// 5) overriden during ASan activation (for now used on Android only).
+
+namespace __asan {
+
+struct Flags {
+#define ASAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "asan_flags.inc"
+#undef ASAN_FLAG
+
+  void SetDefaults();
+};
+
+extern Flags asan_flags_dont_use_directly;
+inline Flags *flags() {
+  return &asan_flags_dont_use_directly;
+}
+
+void InitializeFlags();
+
+}  // namespace __asan
+
+#endif  // ASAN_FLAGS_H
diff --git a/compiler-rt/lib/asan/asan_flags.inc b/compiler-rt/lib/asan/asan_flags.inc
new file mode 100644
index 0000000..5e69242
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_flags.inc
@@ -0,0 +1,137 @@
+//===-- asan_flags.inc ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// ASan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_FLAG
+# error "Define ASAN_FLAG prior to including this file!"
+#endif
+
+// ASAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+ASAN_FLAG(int, quarantine_size, -1,
+            "Deprecated, please use quarantine_size_mb.")
+ASAN_FLAG(int, quarantine_size_mb, -1,
+          "Size (in Mb) of quarantine used to detect use-after-free "
+          "errors. Lower value may reduce memory usage but increase the "
+          "chance of false negatives.")
+ASAN_FLAG(int, redzone, 16,
+          "Minimal size (in bytes) of redzones around heap objects. "
+          "Requirement: redzone >= 16, is a power of two.")
+ASAN_FLAG(int, max_redzone, 2048,
+          "Maximal size (in bytes) of redzones around heap objects.")
+ASAN_FLAG(
+    bool, debug, false,
+    "If set, prints some debugging information and does additional checks.")
+ASAN_FLAG(
+    int, report_globals, 1,
+    "Controls the way to handle globals (0 - don't detect buffer overflow on "
+    "globals, 1 - detect buffer overflow, 2 - print data about registered "
+    "globals).")
+ASAN_FLAG(bool, check_initialization_order, false,
+          "If set, attempts to catch initialization order issues.")
+ASAN_FLAG(
+    bool, replace_str, true,
+    "If set, uses custom wrappers and replacements for libc string functions "
+    "to find more errors.")
+ASAN_FLAG(bool, replace_intrin, true,
+          "If set, uses custom wrappers for memset/memcpy/memmove intinsics.")
+ASAN_FLAG(bool, detect_stack_use_after_return, false,
+          "Enables stack-use-after-return checking at run-time.")
+ASAN_FLAG(int, min_uar_stack_size_log, 16, // We can't do smaller anyway.
+          "Minimum fake stack size log.")
+ASAN_FLAG(int, max_uar_stack_size_log,
+          20, // 1Mb per size class, i.e. ~11Mb per thread
+          "Maximum fake stack size log.")
+ASAN_FLAG(bool, uar_noreserve, false,
+          "Use mmap with 'noreserve' flag to allocate fake stack.")
+ASAN_FLAG(
+    int, max_malloc_fill_size, 0x1000,  // By default, fill only the first 4K.
+    "ASan allocator flag. max_malloc_fill_size is the maximal amount of "
+    "bytes that will be filled with malloc_fill_byte on malloc.")
+ASAN_FLAG(int, malloc_fill_byte, 0xbe,
+          "Value used to fill the newly allocated memory.")
+ASAN_FLAG(bool, allow_user_poisoning, true,
+          "If set, user may manually mark memory regions as poisoned or "
+          "unpoisoned.")
+ASAN_FLAG(
+    int, sleep_before_dying, 0,
+    "Number of seconds to sleep between printing an error report and "
+    "terminating the program. Useful for debugging purposes (e.g. when one "
+    "needs to attach gdb).")
+ASAN_FLAG(bool, check_malloc_usable_size, true,
+          "Allows the users to work around the bug in Nvidia drivers prior to "
+          "295.*.")
+ASAN_FLAG(bool, unmap_shadow_on_exit, false,
+          "If set, explicitly unmaps the (huge) shadow at exit.")
+ASAN_FLAG(bool, protect_shadow_gap, true, "If set, mprotect the shadow gap")
+ASAN_FLAG(bool, print_stats, false,
+          "Print various statistics after printing an error message or if "
+          "atexit=1.")
+ASAN_FLAG(bool, print_legend, true, "Print the legend for the shadow bytes.")
+ASAN_FLAG(bool, atexit, false,
+          "If set, prints ASan exit stats even after program terminates "
+          "successfully.")
+ASAN_FLAG(
+    bool, print_full_thread_history, true,
+    "If set, prints thread creation stacks for the threads involved in the "
+    "report and their ancestors up to the main thread.")
+ASAN_FLAG(
+    bool, poison_heap, true,
+    "Poison (or not) the heap memory on [de]allocation. Zero value is useful "
+    "for benchmarking the allocator or instrumentator.")
+ASAN_FLAG(bool, poison_partial, true,
+          "If true, poison partially addressable 8-byte aligned words "
+          "(default=true). This flag affects heap and global buffers, but not "
+          "stack buffers.")
+ASAN_FLAG(bool, poison_array_cookie, true,
+          "Poison (or not) the array cookie after operator new[].")
+
+// Turn off alloc/dealloc mismatch checker on Mac and Windows for now.
+// https://github.com/google/sanitizers/issues/131
+// https://github.com/google/sanitizers/issues/309
+// TODO(glider,timurrrr): Fix known issues and enable this back.
+ASAN_FLAG(bool, alloc_dealloc_mismatch,
+          (SANITIZER_MAC == 0) && (SANITIZER_WINDOWS == 0),
+          "Report errors on malloc/delete, new/free, new/delete[], etc.")
+
+ASAN_FLAG(bool, new_delete_type_mismatch, true,
+          "Report errors on mismatch betwen size of new and delete.")
+ASAN_FLAG(
+    bool, strict_init_order, false,
+    "If true, assume that dynamic initializers can never access globals from "
+    "other modules, even if the latter are already initialized.")
+ASAN_FLAG(
+    bool, start_deactivated, false,
+    "If true, ASan tweaks a bunch of other flags (quarantine, redzone, heap "
+    "poisoning) to reduce memory consumption as much as possible, and "
+    "restores them to original values when the first instrumented module is "
+    "loaded into the process. This is mainly intended to be used on "
+    "Android. ")
+ASAN_FLAG(
+    int, detect_invalid_pointer_pairs, 0,
+    "If non-zero, try to detect operations like <, <=, >, >= and - on "
+    "invalid pointer pairs (e.g. when pointers belong to different objects). "
+    "The bigger the value the harder we try.")
+ASAN_FLAG(
+    bool, detect_container_overflow, true,
+    "If true, honor the container overflow annotations. See "
+    "https://github.com/google/sanitizers/wiki/AddressSanitizerContainerOverflow")
+ASAN_FLAG(int, detect_odr_violation, 2,
+          "If >=2, detect violation of One-Definition-Rule (ODR); "
+          "If ==1, detect ODR-violation only if the two variables "
+          "have different sizes")
+ASAN_FLAG(bool, dump_instruction_bytes, false,
+          "If true, dump 16 bytes starting at the instruction that caused SEGV")
+ASAN_FLAG(const char *, suppressions, "", "Suppressions file name.")
+ASAN_FLAG(bool, halt_on_error, true,
+          "Crash the program after printing the first error report "
+          "(WARNING: USE AT YOUR OWN RISK!)")
diff --git a/compiler-rt/lib/asan/asan_globals.cc b/compiler-rt/lib/asan/asan_globals.cc
new file mode 100644
index 0000000..eb9f1bf
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_globals.cc
@@ -0,0 +1,292 @@
+//===-- asan_globals.cc ---------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Handle globals.
+//===----------------------------------------------------------------------===//
+
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_poisoning.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_stats.h"
+#include "asan_suppressions.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+
+namespace __asan {
+
+typedef __asan_global Global;
+
+struct ListOfGlobals {
+  const Global *g;
+  ListOfGlobals *next;
+};
+
+static BlockingMutex mu_for_globals(LINKER_INITIALIZED);
+static LowLevelAllocator allocator_for_globals;
+static ListOfGlobals *list_of_all_globals;
+
+static const int kDynamicInitGlobalsInitialCapacity = 512;
+struct DynInitGlobal {
+  Global g;
+  bool initialized;
+};
+typedef InternalMmapVector<DynInitGlobal> VectorOfGlobals;
+// Lazy-initialized and never deleted.
+static VectorOfGlobals *dynamic_init_globals;
+
+// We want to remember where a certain range of globals was registered.
+struct GlobalRegistrationSite {
+  u32 stack_id;
+  Global *g_first, *g_last;
+};
+typedef InternalMmapVector<GlobalRegistrationSite> GlobalRegistrationSiteVector;
+static GlobalRegistrationSiteVector *global_registration_site_vector;
+
+ALWAYS_INLINE void PoisonShadowForGlobal(const Global *g, u8 value) {
+  FastPoisonShadow(g->beg, g->size_with_redzone, value);
+}
+
+ALWAYS_INLINE void PoisonRedZones(const Global &g) {
+  uptr aligned_size = RoundUpTo(g.size, SHADOW_GRANULARITY);
+  FastPoisonShadow(g.beg + aligned_size, g.size_with_redzone - aligned_size,
+                   kAsanGlobalRedzoneMagic);
+  if (g.size != aligned_size) {
+    FastPoisonShadowPartialRightRedzone(
+        g.beg + RoundDownTo(g.size, SHADOW_GRANULARITY),
+        g.size % SHADOW_GRANULARITY,
+        SHADOW_GRANULARITY,
+        kAsanGlobalRedzoneMagic);
+  }
+}
+
+const uptr kMinimalDistanceFromAnotherGlobal = 64;
+
+static bool IsAddressNearGlobal(uptr addr, const __asan_global &g) {
+  if (addr <= g.beg - kMinimalDistanceFromAnotherGlobal) return false;
+  if (addr >= g.beg + g.size_with_redzone) return false;
+  return true;
+}
+
+static void ReportGlobal(const Global &g, const char *prefix) {
+  Report("%s Global[%p]: beg=%p size=%zu/%zu name=%s module=%s dyn_init=%zu\n",
+         prefix, &g, (void *)g.beg, g.size, g.size_with_redzone, g.name,
+         g.module_name, g.has_dynamic_init);
+  if (g.location) {
+    Report("  location (%p): name=%s[%p], %d %d\n", g.location,
+           g.location->filename, g.location->filename, g.location->line_no,
+           g.location->column_no);
+  }
+}
+
+static u32 FindRegistrationSite(const Global *g) {
+  mu_for_globals.CheckLocked();
+  CHECK(global_registration_site_vector);
+  for (uptr i = 0, n = global_registration_site_vector->size(); i < n; i++) {
+    GlobalRegistrationSite &grs = (*global_registration_site_vector)[i];
+    if (g >= grs.g_first && g <= grs.g_last)
+      return grs.stack_id;
+  }
+  return 0;
+}
+
+int GetGlobalsForAddress(uptr addr, Global *globals, u32 *reg_sites,
+                         int max_globals) {
+  if (!flags()->report_globals) return 0;
+  BlockingMutexLock lock(&mu_for_globals);
+  int res = 0;
+  for (ListOfGlobals *l = list_of_all_globals; l; l = l->next) {
+    const Global &g = *l->g;
+    if (flags()->report_globals >= 2)
+      ReportGlobal(g, "Search");
+    if (IsAddressNearGlobal(addr, g)) {
+      globals[res] = g;
+      if (reg_sites)
+        reg_sites[res] = FindRegistrationSite(&g);
+      res++;
+      if (res == max_globals) break;
+    }
+  }
+  return res;
+}
+
+bool GetInfoForAddressIfGlobal(uptr addr, AddressDescription *descr) {
+  Global g = {};
+  if (GetGlobalsForAddress(addr, &g, nullptr, 1)) {
+    internal_strncpy(descr->name, g.name, descr->name_size);
+    descr->region_address = g.beg;
+    descr->region_size = g.size;
+    descr->region_kind = "global";
+    return true;
+  }
+  return false;
+}
+
+// Register a global variable.
+// This function may be called more than once for every global
+// so we store the globals in a map.
+static void RegisterGlobal(const Global *g) {
+  CHECK(asan_inited);
+  if (flags()->report_globals >= 2)
+    ReportGlobal(*g, "Added");
+  CHECK(flags()->report_globals);
+  CHECK(AddrIsInMem(g->beg));
+  CHECK(AddrIsAlignedByGranularity(g->beg));
+  CHECK(AddrIsAlignedByGranularity(g->size_with_redzone));
+  if (flags()->detect_odr_violation) {
+    // Try detecting ODR (One Definition Rule) violation, i.e. the situation
+    // where two globals with the same name are defined in different modules.
+    if (__asan_region_is_poisoned(g->beg, g->size_with_redzone)) {
+      // This check may not be enough: if the first global is much larger
+      // the entire redzone of the second global may be within the first global.
+      for (ListOfGlobals *l = list_of_all_globals; l; l = l->next) {
+        if (g->beg == l->g->beg &&
+            (flags()->detect_odr_violation >= 2 || g->size != l->g->size) &&
+            !IsODRViolationSuppressed(g->name))
+          ReportODRViolation(g, FindRegistrationSite(g),
+                             l->g, FindRegistrationSite(l->g));
+      }
+    }
+  }
+  if (CanPoisonMemory())
+    PoisonRedZones(*g);
+  ListOfGlobals *l = new(allocator_for_globals) ListOfGlobals;
+  l->g = g;
+  l->next = list_of_all_globals;
+  list_of_all_globals = l;
+  if (g->has_dynamic_init) {
+    if (!dynamic_init_globals) {
+      dynamic_init_globals = new(allocator_for_globals)
+          VectorOfGlobals(kDynamicInitGlobalsInitialCapacity);
+    }
+    DynInitGlobal dyn_global = { *g, false };
+    dynamic_init_globals->push_back(dyn_global);
+  }
+}
+
+static void UnregisterGlobal(const Global *g) {
+  CHECK(asan_inited);
+  if (flags()->report_globals >= 2)
+    ReportGlobal(*g, "Removed");
+  CHECK(flags()->report_globals);
+  CHECK(AddrIsInMem(g->beg));
+  CHECK(AddrIsAlignedByGranularity(g->beg));
+  CHECK(AddrIsAlignedByGranularity(g->size_with_redzone));
+  if (CanPoisonMemory())
+    PoisonShadowForGlobal(g, 0);
+  // We unpoison the shadow memory for the global but we do not remove it from
+  // the list because that would require O(n^2) time with the current list
+  // implementation. It might not be worth doing anyway.
+}
+
+void StopInitOrderChecking() {
+  BlockingMutexLock lock(&mu_for_globals);
+  if (!flags()->check_initialization_order || !dynamic_init_globals)
+    return;
+  flags()->check_initialization_order = false;
+  for (uptr i = 0, n = dynamic_init_globals->size(); i < n; ++i) {
+    DynInitGlobal &dyn_g = (*dynamic_init_globals)[i];
+    const Global *g = &dyn_g.g;
+    // Unpoison the whole global.
+    PoisonShadowForGlobal(g, 0);
+    // Poison redzones back.
+    PoisonRedZones(*g);
+  }
+}
+
+} // namespace __asan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+// Register an array of globals.
+void __asan_register_globals(__asan_global *globals, uptr n) {
+  if (!flags()->report_globals) return;
+  GET_STACK_TRACE_MALLOC;
+  u32 stack_id = StackDepotPut(stack);
+  BlockingMutexLock lock(&mu_for_globals);
+  if (!global_registration_site_vector)
+    global_registration_site_vector =
+        new(allocator_for_globals) GlobalRegistrationSiteVector(128);
+  GlobalRegistrationSite site = {stack_id, &globals[0], &globals[n - 1]};
+  global_registration_site_vector->push_back(site);
+  if (flags()->report_globals >= 2) {
+    PRINT_CURRENT_STACK();
+    Printf("=== ID %d; %p %p\n", stack_id, &globals[0], &globals[n - 1]);
+  }
+  for (uptr i = 0; i < n; i++) {
+    RegisterGlobal(&globals[i]);
+  }
+}
+
+// Unregister an array of globals.
+// We must do this when a shared objects gets dlclosed.
+void __asan_unregister_globals(__asan_global *globals, uptr n) {
+  if (!flags()->report_globals) return;
+  BlockingMutexLock lock(&mu_for_globals);
+  for (uptr i = 0; i < n; i++) {
+    UnregisterGlobal(&globals[i]);
+  }
+}
+
+// This method runs immediately prior to dynamic initialization in each TU,
+// when all dynamically initialized globals are unpoisoned.  This method
+// poisons all global variables not defined in this TU, so that a dynamic
+// initializer can only touch global variables in the same TU.
+void __asan_before_dynamic_init(const char *module_name) {
+  if (!flags()->check_initialization_order ||
+      !CanPoisonMemory())
+    return;
+  bool strict_init_order = flags()->strict_init_order;
+  CHECK(dynamic_init_globals);
+  CHECK(module_name);
+  CHECK(asan_inited);
+  BlockingMutexLock lock(&mu_for_globals);
+  if (flags()->report_globals >= 3)
+    Printf("DynInitPoison module: %s\n", module_name);
+  for (uptr i = 0, n = dynamic_init_globals->size(); i < n; ++i) {
+    DynInitGlobal &dyn_g = (*dynamic_init_globals)[i];
+    const Global *g = &dyn_g.g;
+    if (dyn_g.initialized)
+      continue;
+    if (g->module_name != module_name)
+      PoisonShadowForGlobal(g, kAsanInitializationOrderMagic);
+    else if (!strict_init_order)
+      dyn_g.initialized = true;
+  }
+}
+
+// This method runs immediately after dynamic initialization in each TU, when
+// all dynamically initialized globals except for those defined in the current
+// TU are poisoned.  It simply unpoisons all dynamically initialized globals.
+void __asan_after_dynamic_init() {
+  if (!flags()->check_initialization_order ||
+      !CanPoisonMemory())
+    return;
+  CHECK(asan_inited);
+  BlockingMutexLock lock(&mu_for_globals);
+  // FIXME: Optionally report that we're unpoisoning globals from a module.
+  for (uptr i = 0, n = dynamic_init_globals->size(); i < n; ++i) {
+    DynInitGlobal &dyn_g = (*dynamic_init_globals)[i];
+    const Global *g = &dyn_g.g;
+    if (!dyn_g.initialized) {
+      // Unpoison the whole global.
+      PoisonShadowForGlobal(g, 0);
+      // Poison redzones back.
+      PoisonRedZones(*g);
+    }
+  }
+}
diff --git a/compiler-rt/lib/asan/asan_init_version.h b/compiler-rt/lib/asan/asan_init_version.h
new file mode 100644
index 0000000..bc8a622
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_init_version.h
@@ -0,0 +1,34 @@
+//===-- asan_init_version.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This header defines a versioned __asan_init function to be called at the
+// startup of the instrumented program.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_INIT_VERSION_H
+#define ASAN_INIT_VERSION_H
+
+extern "C" {
+  // Every time the ASan ABI changes we also change the version number in the
+  // __asan_init function name.  Objects built with incompatible ASan ABI
+  // versions will not link with run-time.
+  // Changes between ABI versions:
+  // v1=>v2: added 'module_name' to __asan_global
+  // v2=>v3: stack frame description (created by the compiler)
+  //         contains the function PC as the 3-rd field (see
+  //         DescribeAddressIfStack).
+  // v3=>v4: added '__asan_global_source_location' to __asan_global.
+  // v4=>v5: changed the semantics and format of __asan_stack_malloc_ and
+  //         __asan_stack_free_ functions.
+  // v5=>v6: changed the name of the version check symbol
+  #define __asan_version_mismatch_check __asan_version_mismatch_check_v6
+}
+
+#endif  // ASAN_INIT_VERSION_H
diff --git a/compiler-rt/lib/asan/asan_interceptors.cc b/compiler-rt/lib/asan/asan_interceptors.cc
new file mode 100644
index 0000000..d9a0c71
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_interceptors.cc
@@ -0,0 +1,822 @@
+//===-- asan_interceptors.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Intercept various libc functions.
+//===----------------------------------------------------------------------===//
+
+#include "asan_interceptors.h"
+#include "asan_allocator.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_poisoning.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_stats.h"
+#include "asan_suppressions.h"
+#include "sanitizer_common/sanitizer_libc.h"
+
+#if SANITIZER_POSIX
+#include "sanitizer_common/sanitizer_posix.h"
+#endif
+
+#if defined(__i386) && SANITIZER_LINUX
+#define ASAN_PTHREAD_CREATE_VERSION "GLIBC_2.1"
+#elif defined(__mips__) && SANITIZER_LINUX
+#define ASAN_PTHREAD_CREATE_VERSION "GLIBC_2.2"
+#endif
+
+namespace __asan {
+
+// Return true if we can quickly decide that the region is unpoisoned.
+static inline bool QuickCheckForUnpoisonedRegion(uptr beg, uptr size) {
+  if (size == 0) return true;
+  if (size <= 32)
+    return !AddressIsPoisoned(beg) &&
+           !AddressIsPoisoned(beg + size - 1) &&
+           !AddressIsPoisoned(beg + size / 2);
+  return false;
+}
+
+struct AsanInterceptorContext {
+  const char *interceptor_name;
+};
+
+// We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE,
+// and ASAN_WRITE_RANGE as macro instead of function so
+// that no extra frames are created, and stack trace contains
+// relevant information only.
+// We check all shadow bytes.
+#define ACCESS_MEMORY_RANGE(ctx, offset, size, isWrite) do {            \
+    uptr __offset = (uptr)(offset);                                     \
+    uptr __size = (uptr)(size);                                         \
+    uptr __bad = 0;                                                     \
+    if (__offset > __offset + __size) {                                 \
+      GET_STACK_TRACE_FATAL_HERE;                                       \
+      ReportStringFunctionSizeOverflow(__offset, __size, &stack);       \
+    }                                                                   \
+    if (!QuickCheckForUnpoisonedRegion(__offset, __size) &&             \
+        (__bad = __asan_region_is_poisoned(__offset, __size))) {        \
+      AsanInterceptorContext *_ctx = (AsanInterceptorContext *)ctx;     \
+      bool suppressed = false;                                          \
+      if (_ctx) {                                                       \
+        suppressed = IsInterceptorSuppressed(_ctx->interceptor_name);   \
+        if (!suppressed && HaveStackTraceBasedSuppressions()) {         \
+          GET_STACK_TRACE_FATAL_HERE;                                   \
+          suppressed = IsStackTraceSuppressed(&stack);                  \
+        }                                                               \
+      }                                                                 \
+      if (!suppressed) {                                                \
+        GET_CURRENT_PC_BP_SP;                                           \
+        ReportGenericError(pc, bp, sp, __bad, isWrite, __size, 0, false);\
+      }                                                                 \
+    }                                                                   \
+  } while (0)
+
+#define ASAN_READ_RANGE(ctx, offset, size) \
+  ACCESS_MEMORY_RANGE(ctx, offset, size, false)
+#define ASAN_WRITE_RANGE(ctx, offset, size) \
+  ACCESS_MEMORY_RANGE(ctx, offset, size, true)
+
+#define ASAN_READ_STRING_OF_LEN(ctx, s, len, n)                 \
+  ASAN_READ_RANGE((ctx), (s),                                   \
+    common_flags()->strict_string_checks ? (len) + 1 : (n))
+
+#define ASAN_READ_STRING(ctx, s, n)                             \
+  ASAN_READ_STRING_OF_LEN((ctx), (s), REAL(strlen)(s), (n))
+
+// Behavior of functions like "memcpy" or "strcpy" is undefined
+// if memory intervals overlap. We report error in this case.
+// Macro is used to avoid creation of new frames.
+static inline bool RangesOverlap(const char *offset1, uptr length1,
+                                 const char *offset2, uptr length2) {
+  return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1));
+}
+#define CHECK_RANGES_OVERLAP(name, _offset1, length1, _offset2, length2) do { \
+  const char *offset1 = (const char*)_offset1; \
+  const char *offset2 = (const char*)_offset2; \
+  if (RangesOverlap(offset1, length1, offset2, length2)) { \
+    GET_STACK_TRACE_FATAL_HERE; \
+    ReportStringFunctionMemoryRangesOverlap(name, offset1, length1, \
+                                            offset2, length2, &stack); \
+  } \
+} while (0)
+
+static inline uptr MaybeRealStrnlen(const char *s, uptr maxlen) {
+#if ASAN_INTERCEPT_STRNLEN
+  if (REAL(strnlen)) {
+    return REAL(strnlen)(s, maxlen);
+  }
+#endif
+  return internal_strnlen(s, maxlen);
+}
+
+void SetThreadName(const char *name) {
+  AsanThread *t = GetCurrentThread();
+  if (t)
+    asanThreadRegistry().SetThreadName(t->tid(), name);
+}
+
+int OnExit() {
+  // FIXME: ask frontend whether we need to return failure.
+  return 0;
+}
+
+} // namespace __asan
+
+// ---------------------- Wrappers ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr)
+DECLARE_REAL_AND_INTERCEPTOR(void, free, void *)
+
+#define ASAN_INTERCEPTOR_ENTER(ctx, func)                                      \
+  AsanInterceptorContext _ctx = {#func};                                       \
+  ctx = (void *)&_ctx;                                                         \
+  (void) ctx;                                                                  \
+
+#define COMMON_INTERCEPT_FUNCTION(name) ASAN_INTERCEPT_FUNC(name)
+#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
+  ASAN_WRITE_RANGE(ctx, ptr, size)
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
+  ASAN_READ_RANGE(ctx, ptr, size)
+#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)                               \
+  ASAN_INTERCEPTOR_ENTER(ctx, func);                                           \
+  do {                                                                         \
+    if (asan_init_is_running)                                                  \
+      return REAL(func)(__VA_ARGS__);                                          \
+    if (SANITIZER_MAC && UNLIKELY(!asan_inited))                               \
+      return REAL(func)(__VA_ARGS__);                                          \
+    ENSURE_ASAN_INITED();                                                      \
+  } while (false)
+#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
+  do {                                            \
+  } while (false)
+#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
+  do {                                         \
+  } while (false)
+#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
+  do {                                         \
+  } while (false)
+#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
+  do {                                                      \
+  } while (false)
+#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) SetThreadName(name)
+// Should be asanThreadRegistry().SetThreadNameByUserId(thread, name)
+// But asan does not remember UserId's for threads (pthread_t);
+// and remembers all ever existed threads, so the linear search by UserId
+// can be slow.
+#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
+  do {                                                         \
+  } while (false)
+#define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
+// Strict init-order checking is dlopen-hostile:
+// https://github.com/google/sanitizers/issues/178
+#define COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag)                           \
+  if (flags()->strict_init_order) {                                            \
+    StopInitOrderChecking();                                                   \
+  }
+#define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit()
+#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) \
+  CoverageUpdateMapping()
+#define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() CoverageUpdateMapping()
+#define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!asan_inited)
+#define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end)                           \
+  if (AsanThread *t = GetCurrentThread()) {                                    \
+    *begin = t->tls_begin();                                                   \
+    *end = t->tls_end();                                                       \
+  } else {                                                                     \
+    *begin = *end = 0;                                                         \
+  }
+#include "sanitizer_common/sanitizer_common_interceptors.inc"
+
+// Syscall interceptors don't have contexts, we don't support suppressions
+// for them.
+#define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(nullptr, p, s)
+#define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(nullptr, p, s)
+#define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
+  do {                                       \
+    (void)(p);                               \
+    (void)(s);                               \
+  } while (false)
+#define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
+  do {                                        \
+    (void)(p);                                \
+    (void)(s);                                \
+  } while (false)
+#include "sanitizer_common/sanitizer_common_syscalls.inc"
+
+struct ThreadStartParam {
+  atomic_uintptr_t t;
+  atomic_uintptr_t is_registered;
+};
+
+static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
+  ThreadStartParam *param = reinterpret_cast<ThreadStartParam *>(arg);
+  AsanThread *t = nullptr;
+  while ((t = reinterpret_cast<AsanThread *>(
+              atomic_load(&param->t, memory_order_acquire))) == nullptr)
+    internal_sched_yield();
+  SetCurrentThread(t);
+  return t->ThreadStart(GetTid(), &param->is_registered);
+}
+
+#if ASAN_INTERCEPT_PTHREAD_CREATE
+INTERCEPTOR(int, pthread_create, void *thread,
+    void *attr, void *(*start_routine)(void*), void *arg) {
+  EnsureMainThreadIDIsCorrect();
+  // Strict init-order checking is thread-hostile.
+  if (flags()->strict_init_order)
+    StopInitOrderChecking();
+  GET_STACK_TRACE_THREAD;
+  int detached = 0;
+  if (attr)
+    REAL(pthread_attr_getdetachstate)(attr, &detached);
+  ThreadStartParam param;
+  atomic_store(&param.t, 0, memory_order_relaxed);
+  atomic_store(&param.is_registered, 0, memory_order_relaxed);
+  int result = REAL(pthread_create)(thread, attr, asan_thread_start, &param);
+  if (result == 0) {
+    u32 current_tid = GetCurrentTidOrInvalid();
+    AsanThread *t =
+        AsanThread::Create(start_routine, arg, current_tid, &stack, detached);
+    atomic_store(&param.t, reinterpret_cast<uptr>(t), memory_order_release);
+    // Wait until the AsanThread object is initialized and the ThreadRegistry
+    // entry is in "started" state. One reason for this is that after this
+    // interceptor exits, the child thread's stack may be the only thing holding
+    // the |arg| pointer. This may cause LSan to report a leak if leak checking
+    // happens at a point when the interceptor has already exited, but the stack
+    // range for the child thread is not yet known.
+    while (atomic_load(&param.is_registered, memory_order_acquire) == 0)
+      internal_sched_yield();
+  }
+  return result;
+}
+
+INTERCEPTOR(int, pthread_join, void *t, void **arg) {
+  return real_pthread_join(t, arg);
+}
+
+DEFINE_REAL_PTHREAD_FUNCTIONS
+#endif  // ASAN_INTERCEPT_PTHREAD_CREATE
+
+#if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
+
+#if SANITIZER_ANDROID
+INTERCEPTOR(void*, bsd_signal, int signum, void *handler) {
+  if (!IsDeadlySignal(signum) || common_flags()->allow_user_segv_handler) {
+    return REAL(bsd_signal)(signum, handler);
+  }
+  return 0;
+}
+#endif
+
+INTERCEPTOR(void*, signal, int signum, void *handler) {
+  if (!IsDeadlySignal(signum) || common_flags()->allow_user_segv_handler) {
+    return REAL(signal)(signum, handler);
+  }
+  return nullptr;
+}
+
+INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
+                            struct sigaction *oldact) {
+  if (!IsDeadlySignal(signum) || common_flags()->allow_user_segv_handler) {
+    return REAL(sigaction)(signum, act, oldact);
+  }
+  return 0;
+}
+
+namespace __sanitizer {
+int real_sigaction(int signum, const void *act, void *oldact) {
+  return REAL(sigaction)(signum, (const struct sigaction *)act,
+                         (struct sigaction *)oldact);
+}
+} // namespace __sanitizer
+
+#elif SANITIZER_POSIX
+// We need to have defined REAL(sigaction) on posix systems.
+DEFINE_REAL(int, sigaction, int signum, const struct sigaction *act,
+    struct sigaction *oldact)
+#endif  // ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
+
+#if ASAN_INTERCEPT_SWAPCONTEXT
+static void ClearShadowMemoryForContextStack(uptr stack, uptr ssize) {
+  // Align to page size.
+  uptr PageSize = GetPageSizeCached();
+  uptr bottom = stack & ~(PageSize - 1);
+  ssize += stack - bottom;
+  ssize = RoundUpTo(ssize, PageSize);
+  static const uptr kMaxSaneContextStackSize = 1 << 22;  // 4 Mb
+  if (AddrIsInMem(bottom) && ssize && ssize <= kMaxSaneContextStackSize) {
+    PoisonShadow(bottom, ssize, 0);
+  }
+}
+
+INTERCEPTOR(int, swapcontext, struct ucontext_t *oucp,
+            struct ucontext_t *ucp) {
+  static bool reported_warning = false;
+  if (!reported_warning) {
+    Report("WARNING: ASan doesn't fully support makecontext/swapcontext "
+           "functions and may produce false positives in some cases!\n");
+    reported_warning = true;
+  }
+  // Clear shadow memory for new context (it may share stack
+  // with current context).
+  uptr stack, ssize;
+  ReadContextStack(ucp, &stack, &ssize);
+  ClearShadowMemoryForContextStack(stack, ssize);
+  int res = REAL(swapcontext)(oucp, ucp);
+  // swapcontext technically does not return, but program may swap context to
+  // "oucp" later, that would look as if swapcontext() returned 0.
+  // We need to clear shadow for ucp once again, as it may be in arbitrary
+  // state.
+  ClearShadowMemoryForContextStack(stack, ssize);
+  return res;
+}
+#endif  // ASAN_INTERCEPT_SWAPCONTEXT
+
+INTERCEPTOR(void, longjmp, void *env, int val) {
+  __asan_handle_no_return();
+  REAL(longjmp)(env, val);
+}
+
+#if ASAN_INTERCEPT__LONGJMP
+INTERCEPTOR(void, _longjmp, void *env, int val) {
+  __asan_handle_no_return();
+  REAL(_longjmp)(env, val);
+}
+#endif
+
+#if ASAN_INTERCEPT_SIGLONGJMP
+INTERCEPTOR(void, siglongjmp, void *env, int val) {
+  __asan_handle_no_return();
+  REAL(siglongjmp)(env, val);
+}
+#endif
+
+#if ASAN_INTERCEPT___CXA_THROW
+INTERCEPTOR(void, __cxa_throw, void *a, void *b, void *c) {
+  CHECK(REAL(__cxa_throw));
+  __asan_handle_no_return();
+  REAL(__cxa_throw)(a, b, c);
+}
+#endif
+
+// memcpy is called during __asan_init() from the internals of printf(...).
+// We do not treat memcpy with to==from as a bug.
+// See http://llvm.org/bugs/show_bug.cgi?id=11763.
+#define ASAN_MEMCPY_IMPL(ctx, to, from, size) do {                             \
+    if (UNLIKELY(!asan_inited)) return internal_memcpy(to, from, size);        \
+    if (asan_init_is_running) {                                                \
+      return REAL(memcpy)(to, from, size);                                     \
+    }                                                                          \
+    ENSURE_ASAN_INITED();                                                      \
+    if (flags()->replace_intrin) {                                             \
+      if (to != from) {                                                        \
+        CHECK_RANGES_OVERLAP("memcpy", to, size, from, size);                  \
+      }                                                                        \
+      ASAN_READ_RANGE(ctx, from, size);                                        \
+      ASAN_WRITE_RANGE(ctx, to, size);                                         \
+    }                                                                          \
+    return REAL(memcpy)(to, from, size);                                       \
+  } while (0)
+
+
+void *__asan_memcpy(void *to, const void *from, uptr size) {
+  ASAN_MEMCPY_IMPL(nullptr, to, from, size);
+}
+
+// memset is called inside Printf.
+#define ASAN_MEMSET_IMPL(ctx, block, c, size) do {                             \
+    if (UNLIKELY(!asan_inited)) return internal_memset(block, c, size);        \
+    if (asan_init_is_running) {                                                \
+      return REAL(memset)(block, c, size);                                     \
+    }                                                                          \
+    ENSURE_ASAN_INITED();                                                      \
+    if (flags()->replace_intrin) {                                             \
+      ASAN_WRITE_RANGE(ctx, block, size);                                      \
+    }                                                                          \
+    return REAL(memset)(block, c, size);                                       \
+  } while (0)
+
+void *__asan_memset(void *block, int c, uptr size) {
+  ASAN_MEMSET_IMPL(nullptr, block, c, size);
+}
+
+#define ASAN_MEMMOVE_IMPL(ctx, to, from, size) do {                            \
+    if (UNLIKELY(!asan_inited))                                                \
+      return internal_memmove(to, from, size);                                 \
+    ENSURE_ASAN_INITED();                                                      \
+    if (flags()->replace_intrin) {                                             \
+      ASAN_READ_RANGE(ctx, from, size);                                        \
+      ASAN_WRITE_RANGE(ctx, to, size);                                         \
+    }                                                                          \
+    return internal_memmove(to, from, size);                                   \
+  } while (0)
+
+void *__asan_memmove(void *to, const void *from, uptr size) {
+  ASAN_MEMMOVE_IMPL(nullptr, to, from, size);
+}
+
+INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memmove);
+  ASAN_MEMMOVE_IMPL(ctx, to, from, size);
+}
+
+INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memcpy);
+#if !SANITIZER_MAC
+  ASAN_MEMCPY_IMPL(ctx, to, from, size);
+#else
+  // At least on 10.7 and 10.8 both memcpy() and memmove() are being replaced
+  // with WRAP(memcpy). As a result, false positives are reported for memmove()
+  // calls. If we just disable error reporting with
+  // ASAN_OPTIONS=replace_intrin=0, memmove() is still replaced with
+  // internal_memcpy(), which may lead to crashes, see
+  // http://llvm.org/bugs/show_bug.cgi?id=16362.
+  ASAN_MEMMOVE_IMPL(ctx, to, from, size);
+#endif  // !SANITIZER_MAC
+}
+
+INTERCEPTOR(void*, memset, void *block, int c, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memset);
+  ASAN_MEMSET_IMPL(ctx, block, c, size);
+}
+
+INTERCEPTOR(char*, strchr, const char *str, int c) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strchr);
+  if (UNLIKELY(!asan_inited)) return internal_strchr(str, c);
+  // strchr is called inside create_purgeable_zone() when MallocGuardEdges=1 is
+  // used.
+  if (asan_init_is_running) {
+    return REAL(strchr)(str, c);
+  }
+  ENSURE_ASAN_INITED();
+  char *result = REAL(strchr)(str, c);
+  if (flags()->replace_str) {
+    uptr len = REAL(strlen)(str);
+    uptr bytes_read = (result ? result - str : len) + 1;
+    ASAN_READ_STRING_OF_LEN(ctx, str, len, bytes_read);
+  }
+  return result;
+}
+
+#if ASAN_INTERCEPT_INDEX
+# if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
+INTERCEPTOR(char*, index, const char *string, int c)
+  ALIAS(WRAPPER_NAME(strchr));
+# else
+#  if SANITIZER_MAC
+DECLARE_REAL(char*, index, const char *string, int c)
+OVERRIDE_FUNCTION(index, strchr);
+#  else
+DEFINE_REAL(char*, index, const char *string, int c)
+#  endif
+# endif
+#endif  // ASAN_INTERCEPT_INDEX
+
+// For both strcat() and strncat() we need to check the validity of |to|
+// argument irrespective of the |from| length.
+INTERCEPTOR(char*, strcat, char *to, const char *from) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strcat);  // NOLINT
+  ENSURE_ASAN_INITED();
+  if (flags()->replace_str) {
+    uptr from_length = REAL(strlen)(from);
+    ASAN_READ_RANGE(ctx, from, from_length + 1);
+    uptr to_length = REAL(strlen)(to);
+    ASAN_READ_STRING_OF_LEN(ctx, to, to_length, to_length);
+    ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1);
+    // If the copying actually happens, the |from| string should not overlap
+    // with the resulting string starting at |to|, which has a length of
+    // to_length + from_length + 1.
+    if (from_length > 0) {
+      CHECK_RANGES_OVERLAP("strcat", to, from_length + to_length + 1,
+                           from, from_length + 1);
+    }
+  }
+  return REAL(strcat)(to, from);  // NOLINT
+}
+
+INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strncat);
+  ENSURE_ASAN_INITED();
+  if (flags()->replace_str) {
+    uptr from_length = MaybeRealStrnlen(from, size);
+    uptr copy_length = Min(size, from_length + 1);
+    ASAN_READ_RANGE(ctx, from, copy_length);
+    uptr to_length = REAL(strlen)(to);
+    ASAN_READ_STRING_OF_LEN(ctx, to, to_length, to_length);
+    ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1);
+    if (from_length > 0) {
+      CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1,
+                           from, copy_length);
+    }
+  }
+  return REAL(strncat)(to, from, size);
+}
+
+INTERCEPTOR(char*, strcpy, char *to, const char *from) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strcpy);  // NOLINT
+#if SANITIZER_MAC
+  if (UNLIKELY(!asan_inited)) return REAL(strcpy)(to, from);  // NOLINT
+#endif
+  // strcpy is called from malloc_default_purgeable_zone()
+  // in __asan::ReplaceSystemAlloc() on Mac.
+  if (asan_init_is_running) {
+    return REAL(strcpy)(to, from);  // NOLINT
+  }
+  ENSURE_ASAN_INITED();
+  if (flags()->replace_str) {
+    uptr from_size = REAL(strlen)(from) + 1;
+    CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size);
+    ASAN_READ_RANGE(ctx, from, from_size);
+    ASAN_WRITE_RANGE(ctx, to, from_size);
+  }
+  return REAL(strcpy)(to, from);  // NOLINT
+}
+
+#if ASAN_INTERCEPT_STRDUP
+INTERCEPTOR(char*, strdup, const char *s) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strdup);
+  if (UNLIKELY(!asan_inited)) return internal_strdup(s);
+  ENSURE_ASAN_INITED();
+  uptr length = REAL(strlen)(s);
+  if (flags()->replace_str) {
+    ASAN_READ_RANGE(ctx, s, length + 1);
+  }
+  GET_STACK_TRACE_MALLOC;
+  void *new_mem = asan_malloc(length + 1, &stack);
+  REAL(memcpy)(new_mem, s, length + 1);
+  return reinterpret_cast<char*>(new_mem);
+}
+#endif
+
+INTERCEPTOR(SIZE_T, strlen, const char *s) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strlen);
+  if (UNLIKELY(!asan_inited)) return internal_strlen(s);
+  // strlen is called from malloc_default_purgeable_zone()
+  // in __asan::ReplaceSystemAlloc() on Mac.
+  if (asan_init_is_running) {
+    return REAL(strlen)(s);
+  }
+  ENSURE_ASAN_INITED();
+  SIZE_T length = REAL(strlen)(s);
+  if (flags()->replace_str) {
+    ASAN_READ_RANGE(ctx, s, length + 1);
+  }
+  return length;
+}
+
+INTERCEPTOR(SIZE_T, wcslen, const wchar_t *s) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, wcslen);
+  SIZE_T length = REAL(wcslen)(s);
+  if (!asan_init_is_running) {
+    ENSURE_ASAN_INITED();
+    ASAN_READ_RANGE(ctx, s, (length + 1) * sizeof(wchar_t));
+  }
+  return length;
+}
+
+INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strncpy);
+  ENSURE_ASAN_INITED();
+  if (flags()->replace_str) {
+    uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1);
+    CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size);
+    ASAN_READ_RANGE(ctx, from, from_size);
+    ASAN_WRITE_RANGE(ctx, to, size);
+  }
+  return REAL(strncpy)(to, from, size);
+}
+
+#if ASAN_INTERCEPT_STRNLEN
+INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strnlen);
+  ENSURE_ASAN_INITED();
+  uptr length = REAL(strnlen)(s, maxlen);
+  if (flags()->replace_str) {
+    ASAN_READ_RANGE(ctx, s, Min(length + 1, maxlen));
+  }
+  return length;
+}
+#endif  // ASAN_INTERCEPT_STRNLEN
+
+INTERCEPTOR(long, strtol, const char *nptr,  // NOLINT
+            char **endptr, int base) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strtol);
+  ENSURE_ASAN_INITED();
+  if (!flags()->replace_str) {
+    return REAL(strtol)(nptr, endptr, base);
+  }
+  char *real_endptr;
+  long result = REAL(strtol)(nptr, &real_endptr, base);  // NOLINT
+  StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base);
+  return result;
+}
+
+INTERCEPTOR(int, atoi, const char *nptr) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, atoi);
+#if SANITIZER_MAC
+  if (UNLIKELY(!asan_inited)) return REAL(atoi)(nptr);
+#endif
+  ENSURE_ASAN_INITED();
+  if (!flags()->replace_str) {
+    return REAL(atoi)(nptr);
+  }
+  char *real_endptr;
+  // "man atoi" tells that behavior of atoi(nptr) is the same as
+  // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
+  // parsed integer can't be stored in *long* type (even if it's
+  // different from int). So, we just imitate this behavior.
+  int result = REAL(strtol)(nptr, &real_endptr, 10);
+  FixRealStrtolEndptr(nptr, &real_endptr);
+  ASAN_READ_STRING(ctx, nptr, (real_endptr - nptr) + 1);
+  return result;
+}
+
+INTERCEPTOR(long, atol, const char *nptr) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, atol);
+#if SANITIZER_MAC
+  if (UNLIKELY(!asan_inited)) return REAL(atol)(nptr);
+#endif
+  ENSURE_ASAN_INITED();
+  if (!flags()->replace_str) {
+    return REAL(atol)(nptr);
+  }
+  char *real_endptr;
+  long result = REAL(strtol)(nptr, &real_endptr, 10);  // NOLINT
+  FixRealStrtolEndptr(nptr, &real_endptr);
+  ASAN_READ_STRING(ctx, nptr, (real_endptr - nptr) + 1);
+  return result;
+}
+
+#if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
+INTERCEPTOR(long long, strtoll, const char *nptr,  // NOLINT
+            char **endptr, int base) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strtoll);
+  ENSURE_ASAN_INITED();
+  if (!flags()->replace_str) {
+    return REAL(strtoll)(nptr, endptr, base);
+  }
+  char *real_endptr;
+  long long result = REAL(strtoll)(nptr, &real_endptr, base);  // NOLINT
+  StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base);
+  return result;
+}
+
+INTERCEPTOR(long long, atoll, const char *nptr) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, atoll);
+  ENSURE_ASAN_INITED();
+  if (!flags()->replace_str) {
+    return REAL(atoll)(nptr);
+  }
+  char *real_endptr;
+  long long result = REAL(strtoll)(nptr, &real_endptr, 10);  // NOLINT
+  FixRealStrtolEndptr(nptr, &real_endptr);
+  ASAN_READ_STRING(ctx, nptr, (real_endptr - nptr) + 1);
+  return result;
+}
+#endif  // ASAN_INTERCEPT_ATOLL_AND_STRTOLL
+
+static void AtCxaAtexit(void *unused) {
+  (void)unused;
+  StopInitOrderChecking();
+}
+
+#if ASAN_INTERCEPT___CXA_ATEXIT
+INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
+            void *dso_handle) {
+#if SANITIZER_MAC
+  if (UNLIKELY(!asan_inited)) return REAL(__cxa_atexit)(func, arg, dso_handle);
+#endif
+  ENSURE_ASAN_INITED();
+  int res = REAL(__cxa_atexit)(func, arg, dso_handle);
+  REAL(__cxa_atexit)(AtCxaAtexit, nullptr, nullptr);
+  return res;
+}
+#endif  // ASAN_INTERCEPT___CXA_ATEXIT
+
+#if ASAN_INTERCEPT_FORK
+INTERCEPTOR(int, fork, void) {
+  ENSURE_ASAN_INITED();
+  if (common_flags()->coverage) CovBeforeFork();
+  int pid = REAL(fork)();
+  if (common_flags()->coverage) CovAfterFork(pid);
+  return pid;
+}
+#endif  // ASAN_INTERCEPT_FORK
+
+// ---------------------- InitializeAsanInterceptors ---------------- {{{1
+namespace __asan {
+void InitializeAsanInterceptors() {
+  static bool was_called_once;
+  CHECK(was_called_once == false);
+  was_called_once = true;
+  InitializeCommonInterceptors();
+
+  // Intercept mem* functions.
+  ASAN_INTERCEPT_FUNC(memmove);
+  ASAN_INTERCEPT_FUNC(memset);
+  if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {
+    ASAN_INTERCEPT_FUNC(memcpy);
+  }
+
+  // Intercept str* functions.
+  ASAN_INTERCEPT_FUNC(strcat);  // NOLINT
+  ASAN_INTERCEPT_FUNC(strchr);
+  ASAN_INTERCEPT_FUNC(strcpy);  // NOLINT
+  ASAN_INTERCEPT_FUNC(strlen);
+  ASAN_INTERCEPT_FUNC(wcslen);
+  ASAN_INTERCEPT_FUNC(strncat);
+  ASAN_INTERCEPT_FUNC(strncpy);
+#if ASAN_INTERCEPT_STRDUP
+  ASAN_INTERCEPT_FUNC(strdup);
+#endif
+#if ASAN_INTERCEPT_STRNLEN
+  ASAN_INTERCEPT_FUNC(strnlen);
+#endif
+#if ASAN_INTERCEPT_INDEX && ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
+  ASAN_INTERCEPT_FUNC(index);
+#endif
+
+  ASAN_INTERCEPT_FUNC(atoi);
+  ASAN_INTERCEPT_FUNC(atol);
+  ASAN_INTERCEPT_FUNC(strtol);
+#if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
+  ASAN_INTERCEPT_FUNC(atoll);
+  ASAN_INTERCEPT_FUNC(strtoll);
+#endif
+
+  // Intecept signal- and jump-related functions.
+  ASAN_INTERCEPT_FUNC(longjmp);
+#if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
+  ASAN_INTERCEPT_FUNC(sigaction);
+#if SANITIZER_ANDROID
+  ASAN_INTERCEPT_FUNC(bsd_signal);
+#endif
+  ASAN_INTERCEPT_FUNC(signal);
+#endif
+#if ASAN_INTERCEPT_SWAPCONTEXT
+  ASAN_INTERCEPT_FUNC(swapcontext);
+#endif
+#if ASAN_INTERCEPT__LONGJMP
+  ASAN_INTERCEPT_FUNC(_longjmp);
+#endif
+#if ASAN_INTERCEPT_SIGLONGJMP
+  ASAN_INTERCEPT_FUNC(siglongjmp);
+#endif
+
+  // Intercept exception handling functions.
+#if ASAN_INTERCEPT___CXA_THROW
+  ASAN_INTERCEPT_FUNC(__cxa_throw);
+#endif
+
+  // Intercept threading-related functions
+#if ASAN_INTERCEPT_PTHREAD_CREATE
+#if defined(ASAN_PTHREAD_CREATE_VERSION)
+  ASAN_INTERCEPT_FUNC_VER(pthread_create, ASAN_PTHREAD_CREATE_VERSION);
+#else
+  ASAN_INTERCEPT_FUNC(pthread_create);
+#endif
+  ASAN_INTERCEPT_FUNC(pthread_join);
+#endif
+
+  // Intercept atexit function.
+#if ASAN_INTERCEPT___CXA_ATEXIT
+  ASAN_INTERCEPT_FUNC(__cxa_atexit);
+#endif
+
+#if ASAN_INTERCEPT_FORK
+  ASAN_INTERCEPT_FUNC(fork);
+#endif
+
+  InitializePlatformInterceptors();
+
+  VReport(1, "AddressSanitizer: libc interceptors initialized\n");
+}
+
+} // namespace __asan
diff --git a/compiler-rt/lib/asan/asan_interceptors.h b/compiler-rt/lib/asan/asan_interceptors.h
new file mode 100644
index 0000000..279c5f3
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_interceptors.h
@@ -0,0 +1,126 @@
+//===-- asan_interceptors.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_interceptors.cc
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_INTERCEPTORS_H
+#define ASAN_INTERCEPTORS_H
+
+#include "asan_internal.h"
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_platform_interceptors.h"
+
+// Use macro to describe if specific function should be
+// intercepted on a given platform.
+#if !SANITIZER_WINDOWS
+# define ASAN_INTERCEPT_ATOLL_AND_STRTOLL 1
+# define ASAN_INTERCEPT__LONGJMP 1
+# define ASAN_INTERCEPT_STRDUP 1
+# define ASAN_INTERCEPT_INDEX 1
+# define ASAN_INTERCEPT_PTHREAD_CREATE 1
+# define ASAN_INTERCEPT_FORK 1
+#else
+# define ASAN_INTERCEPT_ATOLL_AND_STRTOLL 0
+# define ASAN_INTERCEPT__LONGJMP 0
+# define ASAN_INTERCEPT_STRDUP 0
+# define ASAN_INTERCEPT_INDEX 0
+# define ASAN_INTERCEPT_PTHREAD_CREATE 0
+# define ASAN_INTERCEPT_FORK 0
+#endif
+
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+# define ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 1
+#else
+# define ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 0
+#endif
+
+#if !SANITIZER_MAC
+# define ASAN_INTERCEPT_STRNLEN 1
+#else
+# define ASAN_INTERCEPT_STRNLEN 0
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+# define ASAN_INTERCEPT_SWAPCONTEXT 1
+#else
+# define ASAN_INTERCEPT_SWAPCONTEXT 0
+#endif
+
+#if !SANITIZER_WINDOWS
+# define ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 1
+#else
+# define ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 0
+#endif
+
+#if !SANITIZER_WINDOWS
+# define ASAN_INTERCEPT_SIGLONGJMP 1
+#else
+# define ASAN_INTERCEPT_SIGLONGJMP 0
+#endif
+
+// Android bug: https://code.google.com/p/android/issues/detail?id=61799
+#if ASAN_HAS_EXCEPTIONS && !SANITIZER_WINDOWS && \
+    !(SANITIZER_ANDROID && defined(__i386))
+# define ASAN_INTERCEPT___CXA_THROW 1
+#else
+# define ASAN_INTERCEPT___CXA_THROW 0
+#endif
+
+#if !SANITIZER_WINDOWS
+# define ASAN_INTERCEPT___CXA_ATEXIT 1
+#else
+# define ASAN_INTERCEPT___CXA_ATEXIT 0
+#endif
+
+DECLARE_REAL(int, memcmp, const void *a1, const void *a2, uptr size)
+DECLARE_REAL(void*, memcpy, void *to, const void *from, uptr size)
+DECLARE_REAL(void*, memset, void *block, int c, uptr size)
+DECLARE_REAL(char*, strchr, const char *str, int c)
+DECLARE_REAL(SIZE_T, strlen, const char *s)
+DECLARE_REAL(char*, strncpy, char *to, const char *from, uptr size)
+DECLARE_REAL(uptr, strnlen, const char *s, uptr maxlen)
+DECLARE_REAL(char*, strstr, const char *s1, const char *s2)
+struct sigaction;
+DECLARE_REAL(int, sigaction, int signum, const struct sigaction *act,
+                             struct sigaction *oldact)
+
+#if !SANITIZER_MAC
+#define ASAN_INTERCEPT_FUNC(name)                                        \
+  do {                                                                   \
+    if ((!INTERCEPT_FUNCTION(name) || !REAL(name)))                      \
+      VReport(1, "AddressSanitizer: failed to intercept '" #name "'\n"); \
+  } while (0)
+#define ASAN_INTERCEPT_FUNC_VER(name, ver)                                     \
+  do {                                                                         \
+    if ((!INTERCEPT_FUNCTION_VER(name, ver) || !REAL(name)))                   \
+      VReport(                                                                 \
+          1, "AddressSanitizer: failed to intercept '" #name "@@" #ver "'\n"); \
+  } while (0)
+#else
+// OS X interceptors don't need to be initialized with INTERCEPT_FUNCTION.
+#define ASAN_INTERCEPT_FUNC(name)
+#endif  // SANITIZER_MAC
+
+namespace __asan {
+
+void InitializeAsanInterceptors();
+void InitializePlatformInterceptors();
+
+#define ENSURE_ASAN_INITED() do { \
+  CHECK(!asan_init_is_running); \
+  if (UNLIKELY(!asan_inited)) { \
+    AsanInitFromRtl(); \
+  } \
+} while (0)
+
+}  // namespace __asan
+
+#endif  // ASAN_INTERCEPTORS_H
diff --git a/compiler-rt/lib/asan/asan_interface_internal.h b/compiler-rt/lib/asan/asan_interface_internal.h
new file mode 100644
index 0000000..9efddcb
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_interface_internal.h
@@ -0,0 +1,219 @@
+//===-- asan_interface_internal.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This header declares the AddressSanitizer runtime interface functions.
+// The runtime library has to define these functions so the instrumented program
+// could call them.
+//
+// See also include/sanitizer/asan_interface.h
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_INTERFACE_INTERNAL_H
+#define ASAN_INTERFACE_INTERNAL_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+#include "asan_init_version.h"
+
+using __sanitizer::uptr;
+
+extern "C" {
+  // This function should be called at the very beginning of the process,
+  // before any instrumented code is executed and before any call to malloc.
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_init();
+
+  // This function exists purely to get a linker/loader error when using
+  // incompatible versions of instrumentation and runtime library. Please note
+  // that __asan_version_mismatch_check is a macro that is replaced with
+  // __asan_version_mismatch_check_vXXX at compile-time.
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_version_mismatch_check();
+
+  // This structure is used to describe the source location of a place where
+  // global was defined.
+  struct __asan_global_source_location {
+    const char *filename;
+    int line_no;
+    int column_no;
+  };
+
+  // This structure describes an instrumented global variable.
+  struct __asan_global {
+    uptr beg;                // The address of the global.
+    uptr size;               // The original size of the global.
+    uptr size_with_redzone;  // The size with the redzone.
+    const char *name;        // Name as a C string.
+    const char *module_name; // Module name as a C string. This pointer is a
+                             // unique identifier of a module.
+    uptr has_dynamic_init;   // Non-zero if the global has dynamic initializer.
+    __asan_global_source_location *location;  // Source location of a global,
+                                              // or NULL if it is unknown.
+  };
+
+  // These two functions should be called by the instrumented code.
+  // 'globals' is an array of structures describing 'n' globals.
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_register_globals(__asan_global *globals, uptr n);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_unregister_globals(__asan_global *globals, uptr n);
+
+  // These two functions should be called before and after dynamic initializers
+  // of a single module run, respectively.
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_before_dynamic_init(const char *module_name);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_after_dynamic_init();
+
+  // These two functions are used by instrumented code in the
+  // use-after-scope mode. They mark memory for local variables as
+  // unaddressable when they leave scope and addressable before the
+  // function exits.
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_poison_stack_memory(uptr addr, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_unpoison_stack_memory(uptr addr, uptr size);
+
+  // Performs cleanup before a NoReturn function. Must be called before things
+  // like _exit and execl to avoid false positives on stack.
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_handle_no_return();
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_poison_memory_region(void const volatile *addr, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_unpoison_memory_region(void const volatile *addr, uptr size);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  int __asan_address_is_poisoned(void const volatile *addr);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_region_is_poisoned(uptr beg, uptr size);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_describe_address(uptr addr);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  int __asan_report_present();
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_report_pc();
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_report_bp();
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_report_sp();
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_report_address();
+  SANITIZER_INTERFACE_ATTRIBUTE
+  int __asan_get_report_access_type();
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_report_access_size();
+  SANITIZER_INTERFACE_ATTRIBUTE
+  const char * __asan_get_report_description();
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  const char * __asan_locate_address(uptr addr, char *name, uptr name_size,
+                                     uptr *region_address, uptr *region_size);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_alloc_stack(uptr addr, uptr *trace, uptr size,
+                              u32 *thread_id);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_get_free_stack(uptr addr, uptr *trace, uptr size,
+                             u32 *thread_id);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_get_shadow_mapping(uptr *shadow_scale, uptr *shadow_offset);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_report_error(uptr pc, uptr bp, uptr sp,
+                           uptr addr, int is_write, uptr access_size, u32 exp);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_set_death_callback(void (*callback)(void));
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_set_error_report_callback(void (*callback)(const char*));
+
+  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+  /* OPTIONAL */ void __asan_on_error();
+
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_print_accumulated_stats();
+
+  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+  /* OPTIONAL */ const char* __asan_default_options();
+
+  // Global flag, copy of ASAN_OPTIONS=detect_stack_use_after_return
+  SANITIZER_INTERFACE_ATTRIBUTE
+  extern int __asan_option_detect_stack_use_after_return;
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  extern uptr *__asan_test_only_reported_buggy_pointer;
+
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load1(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load2(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load4(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load8(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load16(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store1(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store2(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store4(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store8(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store16(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_loadN(uptr p, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_storeN(uptr p, uptr size);
+
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load1_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load2_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load4_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load8_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_load16_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store1_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store2_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store4_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store8_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_store16_noabort(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_loadN_noabort(uptr p, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_storeN_noabort(uptr p, uptr size);
+
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load1(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load2(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load4(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load8(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load16(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store1(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store2(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store4(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store8(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store16(uptr p, u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_loadN(uptr p, uptr size,
+                                                      u32 exp);
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_storeN(uptr p, uptr size,
+                                                       u32 exp);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+      void* __asan_memcpy(void *dst, const void *src, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE
+      void* __asan_memset(void *s, int c, uptr n);
+  SANITIZER_INTERFACE_ATTRIBUTE
+      void* __asan_memmove(void* dest, const void* src, uptr n);
+
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_poison_cxx_array_cookie(uptr p);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  uptr __asan_load_cxx_array_cookie(uptr *p);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_poison_intra_object_redzone(uptr p, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_unpoison_intra_object_redzone(uptr p, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_alloca_poison(uptr addr, uptr size);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_allocas_unpoison(uptr top, uptr bottom);
+}  // extern "C"
+
+#endif  // ASAN_INTERFACE_INTERNAL_H
diff --git a/compiler-rt/lib/asan/asan_internal.h b/compiler-rt/lib/asan/asan_internal.h
new file mode 100644
index 0000000..0ef0d0e
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_internal.h
@@ -0,0 +1,141 @@
+//===-- asan_internal.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header which defines various general utilities.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_INTERNAL_H
+#define ASAN_INTERNAL_H
+
+#include "asan_flags.h"
+#include "asan_interface_internal.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_libc.h"
+
+#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+# error "The AddressSanitizer run-time should not be"
+        " instrumented by AddressSanitizer"
+#endif
+
+// Build-time configuration options.
+
+// If set, asan will intercept C++ exception api call(s).
+#ifndef ASAN_HAS_EXCEPTIONS
+# define ASAN_HAS_EXCEPTIONS 1
+#endif
+
+// If set, values like allocator chunk size, as well as defaults for some flags
+// will be changed towards less memory overhead.
+#ifndef ASAN_LOW_MEMORY
+#if SANITIZER_WORDSIZE == 32
+#  define ASAN_LOW_MEMORY 1
+#else
+#  define ASAN_LOW_MEMORY 0
+# endif
+#endif
+
+#ifndef ASAN_DYNAMIC
+# ifdef PIC
+#  define ASAN_DYNAMIC 1
+# else
+#  define ASAN_DYNAMIC 0
+# endif
+#endif
+
+// All internal functions in asan reside inside the __asan namespace
+// to avoid namespace collisions with the user programs.
+// Separate namespace also makes it simpler to distinguish the asan run-time
+// functions from the instrumented user code in a profile.
+namespace __asan {
+
+class AsanThread;
+using __sanitizer::StackTrace;
+
+void AsanInitFromRtl();
+
+// asan_rtl.cc
+void NORETURN ShowStatsAndAbort();
+
+// asan_malloc_linux.cc / asan_malloc_mac.cc
+void ReplaceSystemMalloc();
+
+// asan_linux.cc / asan_mac.cc / asan_win.cc
+void *AsanDoesNotSupportStaticLinkage();
+void AsanCheckDynamicRTPrereqs();
+void AsanCheckIncompatibleRT();
+
+void AsanOnDeadlySignal(int, void *siginfo, void *context);
+
+void ReadContextStack(void *context, uptr *stack, uptr *ssize);
+void StopInitOrderChecking();
+
+// Wrapper for TLS/TSD.
+void AsanTSDInit(void (*destructor)(void *tsd));
+void *AsanTSDGet();
+void AsanTSDSet(void *tsd);
+void PlatformTSDDtor(void *tsd);
+
+void AppendToErrorMessageBuffer(const char *buffer);
+
+void *AsanDlSymNext(const char *sym);
+
+void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name);
+
+// Platform-specific options.
+#if SANITIZER_MAC
+bool PlatformHasDifferentMemcpyAndMemmove();
+# define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE \
+    (PlatformHasDifferentMemcpyAndMemmove())
+#else
+# define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE true
+#endif  // SANITIZER_MAC
+
+// Add convenient macro for interface functions that may be represented as
+// weak hooks.
+#define ASAN_MALLOC_HOOK(ptr, size) \
+  if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(ptr, size)
+#define ASAN_FREE_HOOK(ptr) \
+  if (&__sanitizer_free_hook) __sanitizer_free_hook(ptr)
+#define ASAN_ON_ERROR() \
+  if (&__asan_on_error) __asan_on_error()
+
+extern int asan_inited;
+// Used to avoid infinite recursion in __asan_init().
+extern bool asan_init_is_running;
+extern void (*death_callback)(void);
+
+// These magic values are written to shadow for better error reporting.
+const int kAsanHeapLeftRedzoneMagic = 0xfa;
+const int kAsanHeapRightRedzoneMagic = 0xfb;
+const int kAsanHeapFreeMagic = 0xfd;
+const int kAsanStackLeftRedzoneMagic = 0xf1;
+const int kAsanStackMidRedzoneMagic = 0xf2;
+const int kAsanStackRightRedzoneMagic = 0xf3;
+const int kAsanStackPartialRedzoneMagic = 0xf4;
+const int kAsanStackAfterReturnMagic = 0xf5;
+const int kAsanInitializationOrderMagic = 0xf6;
+const int kAsanUserPoisonedMemoryMagic = 0xf7;
+const int kAsanContiguousContainerOOBMagic = 0xfc;
+const int kAsanStackUseAfterScopeMagic = 0xf8;
+const int kAsanGlobalRedzoneMagic = 0xf9;
+const int kAsanInternalHeapMagic = 0xfe;
+const int kAsanArrayCookieMagic = 0xac;
+const int kAsanIntraObjectRedzone = 0xbb;
+const int kAsanAllocaLeftMagic = 0xca;
+const int kAsanAllocaRightMagic = 0xcb;
+
+static const uptr kCurrentStackFrameMagic = 0x41B58AB3;
+static const uptr kRetiredStackFrameMagic = 0x45E0360E;
+
+}  // namespace __asan
+
+#endif  // ASAN_INTERNAL_H
diff --git a/compiler-rt/lib/asan/asan_linux.cc b/compiler-rt/lib/asan/asan_linux.cc
new file mode 100644
index 0000000..e26b400
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_linux.cc
@@ -0,0 +1,171 @@
+//===-- asan_linux.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Linux-specific details.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_freebsd.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <unwind.h>
+
+#if SANITIZER_FREEBSD
+#include <sys/link_elf.h>
+#endif
+
+#if SANITIZER_ANDROID || SANITIZER_FREEBSD
+#include <ucontext.h>
+extern "C" void* _DYNAMIC;
+#else
+#include <sys/ucontext.h>
+#include <link.h>
+#endif
+
+// x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in
+// 32-bit mode.
+#if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \
+  __FreeBSD_version <= 902001  // v9.2
+#define ucontext_t xucontext_t
+#endif
+
+typedef enum {
+  ASAN_RT_VERSION_UNDEFINED = 0,
+  ASAN_RT_VERSION_DYNAMIC,
+  ASAN_RT_VERSION_STATIC,
+} asan_rt_version_t;
+
+// FIXME: perhaps also store abi version here?
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+asan_rt_version_t  __asan_rt_version;
+}
+
+namespace __asan {
+
+void InitializePlatformInterceptors() {}
+
+void *AsanDoesNotSupportStaticLinkage() {
+  // This will fail to link with -static.
+  return &_DYNAMIC;  // defined in link.h
+}
+
+#if SANITIZER_ANDROID
+// FIXME: should we do anything for Android?
+void AsanCheckDynamicRTPrereqs() {}
+void AsanCheckIncompatibleRT() {}
+#else
+static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size,
+                                void *data) {
+  // Continue until the first dynamic library is found
+  if (!info->dlpi_name || info->dlpi_name[0] == 0)
+    return 0;
+
+  // Ignore vDSO
+  if (internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0)
+    return 0;
+
+  *(const char **)data = info->dlpi_name;
+  return 1;
+}
+
+static bool IsDynamicRTName(const char *libname) {
+  return internal_strstr(libname, "libclang_rt.asan") ||
+    internal_strstr(libname, "libasan.so");
+}
+
+static void ReportIncompatibleRT() {
+  Report("Your application is linked against incompatible ASan runtimes.\n");
+  Die();
+}
+
+void AsanCheckDynamicRTPrereqs() {
+  if (!ASAN_DYNAMIC)
+    return;
+
+  // Ensure that dynamic RT is the first DSO in the list
+  const char *first_dso_name = nullptr;
+  dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name);
+  if (first_dso_name && !IsDynamicRTName(first_dso_name)) {
+    Report("ASan runtime does not come first in initial library list; "
+           "you should either link runtime to your application or "
+           "manually preload it with LD_PRELOAD.\n");
+    Die();
+  }
+}
+
+void AsanCheckIncompatibleRT() {
+  if (ASAN_DYNAMIC) {
+    if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
+      __asan_rt_version = ASAN_RT_VERSION_DYNAMIC;
+    } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) {
+      ReportIncompatibleRT();
+    }
+  } else {
+    if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
+      // Ensure that dynamic runtime is not present. We should detect it
+      // as early as possible, otherwise ASan interceptors could bind to
+      // the functions in dynamic ASan runtime instead of the functions in
+      // system libraries, causing crashes later in ASan initialization.
+      MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+      char filename[128];
+      while (proc_maps.Next(nullptr, nullptr, nullptr, filename,
+                            sizeof(filename), nullptr)) {
+        if (IsDynamicRTName(filename)) {
+          Report("Your application is linked against "
+                 "incompatible ASan runtimes.\n");
+          Die();
+        }
+      }
+      __asan_rt_version = ASAN_RT_VERSION_STATIC;
+    } else if (__asan_rt_version != ASAN_RT_VERSION_STATIC) {
+      ReportIncompatibleRT();
+    }
+  }
+}
+#endif // SANITIZER_ANDROID
+
+#if !SANITIZER_ANDROID
+void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
+  ucontext_t *ucp = (ucontext_t*)context;
+  *stack = (uptr)ucp->uc_stack.ss_sp;
+  *ssize = ucp->uc_stack.ss_size;
+}
+#else
+void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
+  UNIMPLEMENTED();
+}
+#endif
+
+void *AsanDlSymNext(const char *sym) {
+  return dlsym(RTLD_NEXT, sym);
+}
+
+} // namespace __asan
+
+#endif // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/asan/asan_lock.h b/compiler-rt/lib/asan/asan_lock.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_lock.h
diff --git a/compiler-rt/lib/asan/asan_mac.cc b/compiler-rt/lib/asan/asan_mac.cc
new file mode 100644
index 0000000..f00d98f
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_mac.cc
@@ -0,0 +1,263 @@
+//===-- asan_mac.cc -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Mac-specific details.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_stack.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_mac.h"
+
+#include <fcntl.h>
+#include <libkern/OSAtomic.h>
+#include <mach-o/dyld.h>
+#include <mach-o/loader.h>
+#include <pthread.h>
+#include <stdlib.h>  // for free()
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/ucontext.h>
+#include <unistd.h>
+
+namespace __asan {
+
+void InitializePlatformInterceptors() {}
+
+bool PlatformHasDifferentMemcpyAndMemmove() {
+  // On OS X 10.7 memcpy() and memmove() are both resolved
+  // into memmove$VARIANT$sse42.
+  // See also https://github.com/google/sanitizers/issues/34.
+  // TODO(glider): need to check dynamically that memcpy() and memmove() are
+  // actually the same function.
+  return GetMacosVersion() == MACOS_VERSION_SNOW_LEOPARD;
+}
+
+// No-op. Mac does not support static linkage anyway.
+void *AsanDoesNotSupportStaticLinkage() {
+  return 0;
+}
+
+// No-op. Mac does not support static linkage anyway.
+void AsanCheckDynamicRTPrereqs() {}
+
+// No-op. Mac does not support static linkage anyway.
+void AsanCheckIncompatibleRT() {}
+
+void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
+  UNIMPLEMENTED();
+}
+
+// Support for the following functions from libdispatch on Mac OS:
+//   dispatch_async_f()
+//   dispatch_async()
+//   dispatch_sync_f()
+//   dispatch_sync()
+//   dispatch_after_f()
+//   dispatch_after()
+//   dispatch_group_async_f()
+//   dispatch_group_async()
+// TODO(glider): libdispatch API contains other functions that we don't support
+// yet.
+//
+// dispatch_sync() and dispatch_sync_f() are synchronous, although chances are
+// they can cause jobs to run on a thread different from the current one.
+// TODO(glider): if so, we need a test for this (otherwise we should remove
+// them).
+//
+// The following functions use dispatch_barrier_async_f() (which isn't a library
+// function but is exported) and are thus supported:
+//   dispatch_source_set_cancel_handler_f()
+//   dispatch_source_set_cancel_handler()
+//   dispatch_source_set_event_handler_f()
+//   dispatch_source_set_event_handler()
+//
+// The reference manual for Grand Central Dispatch is available at
+//   http://developer.apple.com/library/mac/#documentation/Performance/Reference/GCD_libdispatch_Ref/Reference/reference.html
+// The implementation details are at
+//   http://libdispatch.macosforge.org/trac/browser/trunk/src/queue.c
+
+typedef void* dispatch_group_t;
+typedef void* dispatch_queue_t;
+typedef void* dispatch_source_t;
+typedef u64 dispatch_time_t;
+typedef void (*dispatch_function_t)(void *block);
+typedef void* (*worker_t)(void *block);
+
+// A wrapper for the ObjC blocks used to support libdispatch.
+typedef struct {
+  void *block;
+  dispatch_function_t func;
+  u32 parent_tid;
+} asan_block_context_t;
+
+ALWAYS_INLINE
+void asan_register_worker_thread(int parent_tid, StackTrace *stack) {
+  AsanThread *t = GetCurrentThread();
+  if (!t) {
+    t = AsanThread::Create(/* start_routine */ nullptr, /* arg */ nullptr,
+                           parent_tid, stack, /* detached */ true);
+    t->Init();
+    asanThreadRegistry().StartThread(t->tid(), 0, 0);
+    SetCurrentThread(t);
+  }
+}
+
+// For use by only those functions that allocated the context via
+// alloc_asan_context().
+extern "C"
+void asan_dispatch_call_block_and_release(void *block) {
+  GET_STACK_TRACE_THREAD;
+  asan_block_context_t *context = (asan_block_context_t*)block;
+  VReport(2,
+          "asan_dispatch_call_block_and_release(): "
+          "context: %p, pthread_self: %p\n",
+          block, pthread_self());
+  asan_register_worker_thread(context->parent_tid, &stack);
+  // Call the original dispatcher for the block.
+  context->func(context->block);
+  asan_free(context, &stack, FROM_MALLOC);
+}
+
+}  // namespace __asan
+
+using namespace __asan;  // NOLINT
+
+// Wrap |ctxt| and |func| into an asan_block_context_t.
+// The caller retains control of the allocated context.
+extern "C"
+asan_block_context_t *alloc_asan_context(void *ctxt, dispatch_function_t func,
+                                         BufferedStackTrace *stack) {
+  asan_block_context_t *asan_ctxt =
+      (asan_block_context_t*) asan_malloc(sizeof(asan_block_context_t), stack);
+  asan_ctxt->block = ctxt;
+  asan_ctxt->func = func;
+  asan_ctxt->parent_tid = GetCurrentTidOrInvalid();
+  return asan_ctxt;
+}
+
+// Define interceptor for dispatch_*_f function with the three most common
+// parameters: dispatch_queue_t, context, dispatch_function_t.
+#define INTERCEPT_DISPATCH_X_F_3(dispatch_x_f)                                \
+  INTERCEPTOR(void, dispatch_x_f, dispatch_queue_t dq, void *ctxt,            \
+                                  dispatch_function_t func) {                 \
+    GET_STACK_TRACE_THREAD;                                                   \
+    asan_block_context_t *asan_ctxt = alloc_asan_context(ctxt, func, &stack); \
+    if (Verbosity() >= 2) {                                     \
+      Report(#dispatch_x_f "(): context: %p, pthread_self: %p\n",             \
+             asan_ctxt, pthread_self());                                      \
+      PRINT_CURRENT_STACK();                                                  \
+    }                                                                         \
+    return REAL(dispatch_x_f)(dq, (void*)asan_ctxt,                           \
+                              asan_dispatch_call_block_and_release);          \
+  }
+
+INTERCEPT_DISPATCH_X_F_3(dispatch_async_f)
+INTERCEPT_DISPATCH_X_F_3(dispatch_sync_f)
+INTERCEPT_DISPATCH_X_F_3(dispatch_barrier_async_f)
+
+INTERCEPTOR(void, dispatch_after_f, dispatch_time_t when,
+                                    dispatch_queue_t dq, void *ctxt,
+                                    dispatch_function_t func) {
+  GET_STACK_TRACE_THREAD;
+  asan_block_context_t *asan_ctxt = alloc_asan_context(ctxt, func, &stack);
+  if (Verbosity() >= 2) {
+    Report("dispatch_after_f: %p\n", asan_ctxt);
+    PRINT_CURRENT_STACK();
+  }
+  return REAL(dispatch_after_f)(when, dq, (void*)asan_ctxt,
+                                asan_dispatch_call_block_and_release);
+}
+
+INTERCEPTOR(void, dispatch_group_async_f, dispatch_group_t group,
+                                          dispatch_queue_t dq, void *ctxt,
+                                          dispatch_function_t func) {
+  GET_STACK_TRACE_THREAD;
+  asan_block_context_t *asan_ctxt = alloc_asan_context(ctxt, func, &stack);
+  if (Verbosity() >= 2) {
+    Report("dispatch_group_async_f(): context: %p, pthread_self: %p\n",
+           asan_ctxt, pthread_self());
+    PRINT_CURRENT_STACK();
+  }
+  REAL(dispatch_group_async_f)(group, dq, (void*)asan_ctxt,
+                               asan_dispatch_call_block_and_release);
+}
+
+#if !defined(MISSING_BLOCKS_SUPPORT)
+extern "C" {
+void dispatch_async(dispatch_queue_t dq, void(^work)(void));
+void dispatch_group_async(dispatch_group_t dg, dispatch_queue_t dq,
+                          void(^work)(void));
+void dispatch_after(dispatch_time_t when, dispatch_queue_t queue,
+                    void(^work)(void));
+void dispatch_source_set_cancel_handler(dispatch_source_t ds,
+                                        void(^work)(void));
+void dispatch_source_set_event_handler(dispatch_source_t ds, void(^work)(void));
+}
+
+#define GET_ASAN_BLOCK(work) \
+  void (^asan_block)(void);  \
+  int parent_tid = GetCurrentTidOrInvalid(); \
+  asan_block = ^(void) { \
+    GET_STACK_TRACE_THREAD; \
+    asan_register_worker_thread(parent_tid, &stack); \
+    work(); \
+  }
+
+INTERCEPTOR(void, dispatch_async,
+            dispatch_queue_t dq, void(^work)(void)) {
+  ENABLE_FRAME_POINTER;
+  GET_ASAN_BLOCK(work);
+  REAL(dispatch_async)(dq, asan_block);
+}
+
+INTERCEPTOR(void, dispatch_group_async,
+            dispatch_group_t dg, dispatch_queue_t dq, void(^work)(void)) {
+  ENABLE_FRAME_POINTER;
+  GET_ASAN_BLOCK(work);
+  REAL(dispatch_group_async)(dg, dq, asan_block);
+}
+
+INTERCEPTOR(void, dispatch_after,
+            dispatch_time_t when, dispatch_queue_t queue, void(^work)(void)) {
+  ENABLE_FRAME_POINTER;
+  GET_ASAN_BLOCK(work);
+  REAL(dispatch_after)(when, queue, asan_block);
+}
+
+INTERCEPTOR(void, dispatch_source_set_cancel_handler,
+            dispatch_source_t ds, void(^work)(void)) {
+  if (!work) {
+    REAL(dispatch_source_set_cancel_handler)(ds, work);
+    return;
+  }
+  ENABLE_FRAME_POINTER;
+  GET_ASAN_BLOCK(work);
+  REAL(dispatch_source_set_cancel_handler)(ds, asan_block);
+}
+
+INTERCEPTOR(void, dispatch_source_set_event_handler,
+            dispatch_source_t ds, void(^work)(void)) {
+  ENABLE_FRAME_POINTER;
+  GET_ASAN_BLOCK(work);
+  REAL(dispatch_source_set_event_handler)(ds, asan_block);
+}
+#endif
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/asan/asan_malloc_linux.cc b/compiler-rt/lib/asan/asan_malloc_linux.cc
new file mode 100644
index 0000000..d5089f9
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_malloc_linux.cc
@@ -0,0 +1,203 @@
+//===-- asan_malloc_linux.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Linux-specific malloc interception.
+// We simply define functions like malloc, free, realloc, etc.
+// They will replace the corresponding libc functions automagically.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+
+#include "sanitizer_common/sanitizer_tls_get_addr.h"
+#include "asan_allocator.h"
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_stack.h"
+
+// ---------------------- Replacement functions ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+static const uptr kCallocPoolSize = 1024;
+static uptr calloc_memory_for_dlsym[kCallocPoolSize];
+
+static bool IsInCallocPool(const void *ptr) {
+  sptr off = (sptr)ptr - (sptr)calloc_memory_for_dlsym;
+  return 0 <= off && off < (sptr)kCallocPoolSize;
+}
+
+INTERCEPTOR(void, free, void *ptr) {
+  GET_STACK_TRACE_FREE;
+  if (UNLIKELY(IsInCallocPool(ptr)))
+    return;
+  asan_free(ptr, &stack, FROM_MALLOC);
+}
+
+INTERCEPTOR(void, cfree, void *ptr) {
+  GET_STACK_TRACE_FREE;
+  if (UNLIKELY(IsInCallocPool(ptr)))
+    return;
+  asan_free(ptr, &stack, FROM_MALLOC);
+}
+
+INTERCEPTOR(void*, malloc, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_malloc(size, &stack);
+}
+
+INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
+  if (UNLIKELY(!asan_inited)) {
+    // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
+    static uptr allocated;
+    uptr size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
+    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
+    allocated += size_in_words;
+    CHECK(allocated < kCallocPoolSize);
+    return mem;
+  }
+  GET_STACK_TRACE_MALLOC;
+  return asan_calloc(nmemb, size, &stack);
+}
+
+INTERCEPTOR(void*, realloc, void *ptr, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  if (UNLIKELY(IsInCallocPool(ptr))) {
+    uptr offset = (uptr)ptr - (uptr)calloc_memory_for_dlsym;
+    uptr copy_size = Min(size, kCallocPoolSize - offset);
+    void *new_ptr = asan_malloc(size, &stack);
+    internal_memcpy(new_ptr, ptr, copy_size);
+    return new_ptr;
+  }
+  return asan_realloc(ptr, size, &stack);
+}
+
+INTERCEPTOR(void*, memalign, uptr boundary, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_memalign(boundary, size, &stack, FROM_MALLOC);
+}
+
+INTERCEPTOR(void*, aligned_alloc, uptr boundary, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_memalign(boundary, size, &stack, FROM_MALLOC);
+}
+
+INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  void *res = asan_memalign(boundary, size, &stack, FROM_MALLOC);
+  DTLS_on_libc_memalign(res, size * boundary);
+  return res;
+}
+
+INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
+  GET_CURRENT_PC_BP_SP;
+  (void)sp;
+  return asan_malloc_usable_size(ptr, pc, bp);
+}
+
+// We avoid including malloc.h for portability reasons.
+// man mallinfo says the fields are "long", but the implementation uses int.
+// It doesn't matter much -- we just need to make sure that the libc's mallinfo
+// is not called.
+struct fake_mallinfo {
+  int x[10];
+};
+
+INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
+  struct fake_mallinfo res;
+  REAL(memset)(&res, 0, sizeof(res));
+  return res;
+}
+
+INTERCEPTOR(int, mallopt, int cmd, int value) {
+  return -1;
+}
+
+INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  // Printf("posix_memalign: %zx %zu\n", alignment, size);
+  return asan_posix_memalign(memptr, alignment, size, &stack);
+}
+
+INTERCEPTOR(void*, valloc, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_valloc(size, &stack);
+}
+
+INTERCEPTOR(void*, pvalloc, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_pvalloc(size, &stack);
+}
+
+INTERCEPTOR(void, malloc_stats, void) {
+  __asan_print_accumulated_stats();
+}
+
+#if SANITIZER_ANDROID
+// Format of __libc_malloc_dispatch has changed in Android L.
+// While we are moving towards a solution that does not depend on bionic
+// internals, here is something to support both K* and L releases.
+struct MallocDebugK {
+  void *(*malloc)(uptr bytes);
+  void (*free)(void *mem);
+  void *(*calloc)(uptr n_elements, uptr elem_size);
+  void *(*realloc)(void *oldMem, uptr bytes);
+  void *(*memalign)(uptr alignment, uptr bytes);
+  uptr (*malloc_usable_size)(void *mem);
+};
+
+struct MallocDebugL {
+  void *(*calloc)(uptr n_elements, uptr elem_size);
+  void (*free)(void *mem);
+  fake_mallinfo (*mallinfo)(void);
+  void *(*malloc)(uptr bytes);
+  uptr (*malloc_usable_size)(void *mem);
+  void *(*memalign)(uptr alignment, uptr bytes);
+  int (*posix_memalign)(void **memptr, uptr alignment, uptr size);
+  void* (*pvalloc)(uptr size);
+  void *(*realloc)(void *oldMem, uptr bytes);
+  void* (*valloc)(uptr size);
+};
+
+ALIGNED(32) const MallocDebugK asan_malloc_dispatch_k = {
+    WRAP(malloc),  WRAP(free),     WRAP(calloc),
+    WRAP(realloc), WRAP(memalign), WRAP(malloc_usable_size)};
+
+ALIGNED(32) const MallocDebugL asan_malloc_dispatch_l = {
+    WRAP(calloc),         WRAP(free),               WRAP(mallinfo),
+    WRAP(malloc),         WRAP(malloc_usable_size), WRAP(memalign),
+    WRAP(posix_memalign), WRAP(pvalloc),            WRAP(realloc),
+    WRAP(valloc)};
+
+namespace __asan {
+void ReplaceSystemMalloc() {
+  void **__libc_malloc_dispatch_p =
+      (void **)AsanDlSymNext("__libc_malloc_dispatch");
+  if (__libc_malloc_dispatch_p) {
+    // Decide on K vs L dispatch format by the presence of
+    // __libc_malloc_default_dispatch export in libc.
+    void *default_dispatch_p = AsanDlSymNext("__libc_malloc_default_dispatch");
+    if (default_dispatch_p)
+      *__libc_malloc_dispatch_p = (void *)&asan_malloc_dispatch_k;
+    else
+      *__libc_malloc_dispatch_p = (void *)&asan_malloc_dispatch_l;
+  }
+}
+}  // namespace __asan
+
+#else  // SANITIZER_ANDROID
+
+namespace __asan {
+void ReplaceSystemMalloc() {
+}
+}  // namespace __asan
+#endif  // SANITIZER_ANDROID
+
+#endif  // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/asan/asan_malloc_mac.cc b/compiler-rt/lib/asan/asan_malloc_mac.cc
new file mode 100644
index 0000000..744728d
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_malloc_mac.cc
@@ -0,0 +1,61 @@
+//===-- asan_malloc_mac.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Mac-specific malloc interception.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "asan_interceptors.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_stats.h"
+
+using namespace __asan;
+#define COMMON_MALLOC_ZONE_NAME "asan"
+#define COMMON_MALLOC_ENTER() ENSURE_ASAN_INITED()
+#define COMMON_MALLOC_SANITIZER_INITIALIZED asan_inited
+#define COMMON_MALLOC_FORCE_LOCK() asan_mz_force_lock()
+#define COMMON_MALLOC_FORCE_UNLOCK() asan_mz_force_unlock()
+#define COMMON_MALLOC_MEMALIGN(alignment, size) \
+  GET_STACK_TRACE_MALLOC; \
+  void *p = asan_memalign(alignment, size, &stack, FROM_MALLOC)
+#define COMMON_MALLOC_MALLOC(size) \
+  GET_STACK_TRACE_MALLOC; \
+  void *p = asan_malloc(size, &stack)
+#define COMMON_MALLOC_REALLOC(ptr, size) \
+  GET_STACK_TRACE_MALLOC; \
+  void *p = asan_realloc(ptr, size, &stack);
+#define COMMON_MALLOC_CALLOC(count, size) \
+  GET_STACK_TRACE_MALLOC; \
+  void *p = asan_calloc(count, size, &stack);
+#define COMMON_MALLOC_VALLOC(size) \
+  GET_STACK_TRACE_MALLOC; \
+  void *p = asan_memalign(GetPageSizeCached(), size, &stack, FROM_MALLOC);
+#define COMMON_MALLOC_FREE(ptr) \
+  GET_STACK_TRACE_FREE; \
+  asan_free(ptr, &stack, FROM_MALLOC);
+#define COMMON_MALLOC_SIZE(ptr) \
+  uptr size = asan_mz_size(ptr);
+#define COMMON_MALLOC_FILL_STATS(zone, stats) \
+  AsanMallocStats malloc_stats; \
+  FillMallocStatistics(&malloc_stats); \
+  CHECK(sizeof(malloc_statistics_t) == sizeof(AsanMallocStats)); \
+  internal_memcpy(stats, &malloc_stats, sizeof(malloc_statistics_t));
+#define COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name) \
+  GET_STACK_TRACE_FREE; \
+  ReportMacMzReallocUnknown((uptr)ptr, (uptr)zone_ptr, zone_name, &stack);
+#define COMMON_MALLOC_NAMESPACE __asan
+
+#include "sanitizer_common/sanitizer_malloc_mac.inc"
+
+#endif
diff --git a/compiler-rt/lib/asan/asan_malloc_win.cc b/compiler-rt/lib/asan/asan_malloc_win.cc
new file mode 100644
index 0000000..c99e312
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_malloc_win.cc
@@ -0,0 +1,178 @@
+//===-- asan_malloc_win.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Windows-specific malloc interception.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_WINDOWS
+
+#include "asan_allocator.h"
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_stack.h"
+#include "interception/interception.h"
+
+#include <stddef.h>
+
+using namespace __asan;  // NOLINT
+
+// MT: Simply defining functions with the same signature in *.obj
+// files overrides the standard functions in the CRT.
+// MD: Memory allocation functions are defined in the CRT .dll,
+// so we have to intercept them before they are called for the first time.
+
+#if ASAN_DYNAMIC
+# define ALLOCATION_FUNCTION_ATTRIBUTE
+#else
+# define ALLOCATION_FUNCTION_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
+#endif
+
+extern "C" {
+ALLOCATION_FUNCTION_ATTRIBUTE
+void free(void *ptr) {
+  GET_STACK_TRACE_FREE;
+  return asan_free(ptr, &stack, FROM_MALLOC);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void _free_dbg(void *ptr, int) {
+  free(ptr);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void cfree(void *ptr) {
+  CHECK(!"cfree() should not be used on Windows");
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *malloc(size_t size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_malloc(size, &stack);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_malloc_dbg(size_t size, int, const char *, int) {
+  return malloc(size);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *calloc(size_t nmemb, size_t size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_calloc(nmemb, size, &stack);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_calloc_dbg(size_t nmemb, size_t size, int, const char *, int) {
+  return calloc(nmemb, size);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_calloc_impl(size_t nmemb, size_t size, int *errno_tmp) {
+  return calloc(nmemb, size);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *realloc(void *ptr, size_t size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_realloc(ptr, size, &stack);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_realloc_dbg(void *ptr, size_t size, int) {
+  CHECK(!"_realloc_dbg should not exist!");
+  return 0;
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_recalloc(void *p, size_t n, size_t elem_size) {
+  if (!p)
+    return calloc(n, elem_size);
+  const size_t size = n * elem_size;
+  if (elem_size != 0 && size / elem_size != n)
+    return 0;
+  return realloc(p, size);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+size_t _msize(void *ptr) {
+  GET_CURRENT_PC_BP_SP;
+  (void)sp;
+  return asan_malloc_usable_size(ptr, pc, bp);
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_expand(void *memblock, size_t size) {
+  // _expand is used in realloc-like functions to resize the buffer if possible.
+  // We don't want memory to stand still while resizing buffers, so return 0.
+  return 0;
+}
+
+ALLOCATION_FUNCTION_ATTRIBUTE
+void *_expand_dbg(void *memblock, size_t size) {
+  return _expand(memblock, size);
+}
+
+// TODO(timurrrr): Might want to add support for _aligned_* allocation
+// functions to detect a bit more bugs.  Those functions seem to wrap malloc().
+
+int _CrtDbgReport(int, const char*, int,
+                  const char*, const char*, ...) {
+  ShowStatsAndAbort();
+}
+
+int _CrtDbgReportW(int reportType, const wchar_t*, int,
+                   const wchar_t*, const wchar_t*, ...) {
+  ShowStatsAndAbort();
+}
+
+int _CrtSetReportMode(int, int) {
+  return 0;
+}
+}  // extern "C"
+
+namespace __asan {
+void ReplaceSystemMalloc() {
+#if defined(ASAN_DYNAMIC)
+  // We don't check the result because CRT might not be used in the process.
+  __interception::OverrideFunction("free", (uptr)free);
+  __interception::OverrideFunction("malloc", (uptr)malloc);
+  __interception::OverrideFunction("_malloc_crt", (uptr)malloc);
+  __interception::OverrideFunction("calloc", (uptr)calloc);
+  __interception::OverrideFunction("_calloc_crt", (uptr)calloc);
+  __interception::OverrideFunction("realloc", (uptr)realloc);
+  __interception::OverrideFunction("_realloc_crt", (uptr)realloc);
+  __interception::OverrideFunction("_recalloc", (uptr)_recalloc);
+  __interception::OverrideFunction("_recalloc_crt", (uptr)_recalloc);
+  __interception::OverrideFunction("_msize", (uptr)_msize);
+  __interception::OverrideFunction("_expand", (uptr)_expand);
+
+  // Override different versions of 'operator new' and 'operator delete'.
+  // No need to override the nothrow versions as they just wrap the throw
+  // versions.
+  // FIXME: Unfortunately, MSVC miscompiles the statements that take the
+  // addresses of the array versions of these operators,
+  // see https://connect.microsoft.com/VisualStudio/feedbackdetail/view/946992
+  // We might want to try to work around this by [inline] assembly or compiling
+  // parts of the RTL with Clang.
+  void *(*op_new)(size_t sz) = operator new;
+  void (*op_delete)(void *p) = operator delete;
+  void *(*op_array_new)(size_t sz) = operator new[];
+  void (*op_array_delete)(void *p) = operator delete[];
+  __interception::OverrideFunction("??2@YAPAXI@Z", (uptr)op_new);
+  __interception::OverrideFunction("??3@YAXPAX@Z", (uptr)op_delete);
+  __interception::OverrideFunction("??_U@YAPAXI@Z", (uptr)op_array_new);
+  __interception::OverrideFunction("??_V@YAXPAX@Z", (uptr)op_array_delete);
+#endif
+}
+}  // namespace __asan
+
+#endif  // _WIN32
diff --git a/compiler-rt/lib/asan/asan_mapping.h b/compiler-rt/lib/asan/asan_mapping.h
new file mode 100644
index 0000000..8fe347c
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_mapping.h
@@ -0,0 +1,312 @@
+//===-- asan_mapping.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Defines ASan memory mapping.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_MAPPING_H
+#define ASAN_MAPPING_H
+
+#include "asan_internal.h"
+
+// The full explanation of the memory mapping could be found here:
+// https://github.com/google/sanitizers/wiki/AddressSanitizerAlgorithm
+//
+// Typical shadow mapping on Linux/x86_64 with SHADOW_OFFSET == 0x00007fff8000:
+// || `[0x10007fff8000, 0x7fffffffffff]` || HighMem    ||
+// || `[0x02008fff7000, 0x10007fff7fff]` || HighShadow ||
+// || `[0x00008fff7000, 0x02008fff6fff]` || ShadowGap  ||
+// || `[0x00007fff8000, 0x00008fff6fff]` || LowShadow  ||
+// || `[0x000000000000, 0x00007fff7fff]` || LowMem     ||
+//
+// When SHADOW_OFFSET is zero (-pie):
+// || `[0x100000000000, 0x7fffffffffff]` || HighMem    ||
+// || `[0x020000000000, 0x0fffffffffff]` || HighShadow ||
+// || `[0x000000040000, 0x01ffffffffff]` || ShadowGap  ||
+//
+// Special case when something is already mapped between
+// 0x003000000000 and 0x005000000000 (e.g. when prelink is installed):
+// || `[0x10007fff8000, 0x7fffffffffff]` || HighMem    ||
+// || `[0x02008fff7000, 0x10007fff7fff]` || HighShadow ||
+// || `[0x005000000000, 0x02008fff6fff]` || ShadowGap3 ||
+// || `[0x003000000000, 0x004fffffffff]` || MidMem     ||
+// || `[0x000a7fff8000, 0x002fffffffff]` || ShadowGap2 ||
+// || `[0x00067fff8000, 0x000a7fff7fff]` || MidShadow  ||
+// || `[0x00008fff7000, 0x00067fff7fff]` || ShadowGap  ||
+// || `[0x00007fff8000, 0x00008fff6fff]` || LowShadow  ||
+// || `[0x000000000000, 0x00007fff7fff]` || LowMem     ||
+//
+// Default Linux/i386 mapping on x86_64 machine:
+// || `[0x40000000, 0xffffffff]` || HighMem    ||
+// || `[0x28000000, 0x3fffffff]` || HighShadow ||
+// || `[0x24000000, 0x27ffffff]` || ShadowGap  ||
+// || `[0x20000000, 0x23ffffff]` || LowShadow  ||
+// || `[0x00000000, 0x1fffffff]` || LowMem     ||
+//
+// Default Linux/i386 mapping on i386 machine
+// (addresses starting with 0xc0000000 are reserved
+// for kernel and thus not sanitized):
+// || `[0x38000000, 0xbfffffff]` || HighMem    ||
+// || `[0x27000000, 0x37ffffff]` || HighShadow ||
+// || `[0x24000000, 0x26ffffff]` || ShadowGap  ||
+// || `[0x20000000, 0x23ffffff]` || LowShadow  ||
+// || `[0x00000000, 0x1fffffff]` || LowMem     ||
+//
+// Default Linux/MIPS32 mapping:
+// || `[0x2aaa0000, 0xffffffff]` || HighMem    ||
+// || `[0x0fff4000, 0x2aa9ffff]` || HighShadow ||
+// || `[0x0bff4000, 0x0fff3fff]` || ShadowGap  ||
+// || `[0x0aaa0000, 0x0bff3fff]` || LowShadow  ||
+// || `[0x00000000, 0x0aa9ffff]` || LowMem     ||
+//
+// Default Linux/MIPS64 mapping:
+// || `[0x4000000000, 0xffffffffff]` || HighMem    ||
+// || `[0x2800000000, 0x3fffffffff]` || HighShadow ||
+// || `[0x2400000000, 0x27ffffffff]` || ShadowGap  ||
+// || `[0x2000000000, 0x23ffffffff]` || LowShadow  ||
+// || `[0x0000000000, 0x1fffffffff]` || LowMem     ||
+//
+// Default Linux/AArch64 (39-bit VMA) mapping:
+// || `[0x2000000000, 0x7fffffffff]` || highmem    ||
+// || `[0x1400000000, 0x1fffffffff]` || highshadow ||
+// || `[0x1200000000, 0x13ffffffff]` || shadowgap  ||
+// || `[0x1000000000, 0x11ffffffff]` || lowshadow  ||
+// || `[0x0000000000, 0x0fffffffff]` || lowmem     ||
+//
+// Default Linux/AArch64 (42-bit VMA) mapping:
+// || `[0x10000000000, 0x3ffffffffff]` || highmem    ||
+// || `[0x0a000000000, 0x0ffffffffff]` || highshadow ||
+// || `[0x09000000000, 0x09fffffffff]` || shadowgap  ||
+// || `[0x08000000000, 0x08fffffffff]` || lowshadow  ||
+// || `[0x00000000000, 0x07fffffffff]` || lowmem     ||
+//
+// Shadow mapping on FreeBSD/x86-64 with SHADOW_OFFSET == 0x400000000000:
+// || `[0x500000000000, 0x7fffffffffff]` || HighMem    ||
+// || `[0x4a0000000000, 0x4fffffffffff]` || HighShadow ||
+// || `[0x480000000000, 0x49ffffffffff]` || ShadowGap  ||
+// || `[0x400000000000, 0x47ffffffffff]` || LowShadow  ||
+// || `[0x000000000000, 0x3fffffffffff]` || LowMem     ||
+//
+// Shadow mapping on FreeBSD/i386 with SHADOW_OFFSET == 0x40000000:
+// || `[0x60000000, 0xffffffff]` || HighMem    ||
+// || `[0x4c000000, 0x5fffffff]` || HighShadow ||
+// || `[0x48000000, 0x4bffffff]` || ShadowGap  ||
+// || `[0x40000000, 0x47ffffff]` || LowShadow  ||
+// || `[0x00000000, 0x3fffffff]` || LowMem     ||
+//
+// Default Windows/i386 mapping:
+// (the exact location of HighShadow/HighMem may vary depending
+//  on WoW64, /LARGEADDRESSAWARE, etc).
+// || `[0x50000000, 0xffffffff]` || HighMem    ||
+// || `[0x3a000000, 0x4fffffff]` || HighShadow ||
+// || `[0x36000000, 0x39ffffff]` || ShadowGap  ||
+// || `[0x30000000, 0x35ffffff]` || LowShadow  ||
+// || `[0x00000000, 0x2fffffff]` || LowMem     ||
+
+static const u64 kDefaultShadowScale = 3;
+static const u64 kDefaultShadowOffset32 = 1ULL << 29;  // 0x20000000
+static const u64 kDefaultShadowOffset64 = 1ULL << 44;
+static const u64 kDefaultShort64bitShadowOffset = 0x7FFF8000;  // < 2G.
+static const u64 kIosShadowOffset32 = 1ULL << 30;  // 0x40000000
+static const u64 kIosShadowOffset64 = 0x130000000;
+static const u64 kIosSimShadowOffset32 = 1ULL << 30;
+static const u64 kIosSimShadowOffset64 = kDefaultShadowOffset64;
+static const u64 kAArch64_ShadowOffset64 = 1ULL << 36;
+static const u64 kMIPS32_ShadowOffset32 = 0x0aaa0000;
+static const u64 kMIPS64_ShadowOffset64 = 1ULL << 37;
+static const u64 kPPC64_ShadowOffset64 = 1ULL << 41;
+static const u64 kFreeBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
+static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000
+static const u64 kWindowsShadowOffset32 = 3ULL << 28;  // 0x30000000
+
+#define SHADOW_SCALE kDefaultShadowScale
+
+
+#if SANITIZER_WORDSIZE == 32
+#  if SANITIZER_ANDROID
+#    define SHADOW_OFFSET (0)
+#  elif defined(__mips__)
+#    define SHADOW_OFFSET kMIPS32_ShadowOffset32
+#  elif SANITIZER_FREEBSD
+#    define SHADOW_OFFSET kFreeBSD_ShadowOffset32
+#  elif SANITIZER_WINDOWS
+#    define SHADOW_OFFSET kWindowsShadowOffset32
+#  elif SANITIZER_IOSSIM
+#    define SHADOW_OFFSET kIosSimShadowOffset32
+#  elif SANITIZER_IOS
+#    define SHADOW_OFFSET kIosShadowOffset32
+#  else
+#    define SHADOW_OFFSET kDefaultShadowOffset32
+#  endif
+#else
+#  if defined(__aarch64__)
+#    define SHADOW_OFFSET kAArch64_ShadowOffset64
+#  elif defined(__powerpc64__)
+#    define SHADOW_OFFSET kPPC64_ShadowOffset64
+#  elif SANITIZER_FREEBSD
+#    define SHADOW_OFFSET kFreeBSD_ShadowOffset64
+#  elif SANITIZER_MAC
+#   define SHADOW_OFFSET kDefaultShadowOffset64
+#  elif defined(__mips64)
+#   define SHADOW_OFFSET kMIPS64_ShadowOffset64
+#  elif SANITIZER_IOSSIM
+#    define SHADOW_OFFSET kIosSimShadowOffset64
+#  elif SANITIZER_IOS
+#    define SHADOW_OFFSET kIosShadowOffset64
+#  else
+#   define SHADOW_OFFSET kDefaultShort64bitShadowOffset
+#  endif
+#endif
+
+#define SHADOW_GRANULARITY (1ULL << SHADOW_SCALE)
+#define MEM_TO_SHADOW(mem) (((mem) >> SHADOW_SCALE) + (SHADOW_OFFSET))
+#define SHADOW_TO_MEM(shadow) (((shadow) - SHADOW_OFFSET) << SHADOW_SCALE)
+
+#define kLowMemBeg      0
+#define kLowMemEnd      (SHADOW_OFFSET ? SHADOW_OFFSET - 1 : 0)
+
+#define kLowShadowBeg   SHADOW_OFFSET
+#define kLowShadowEnd   MEM_TO_SHADOW(kLowMemEnd)
+
+#define kHighMemBeg     (MEM_TO_SHADOW(kHighMemEnd) + 1)
+
+#define kHighShadowBeg  MEM_TO_SHADOW(kHighMemBeg)
+#define kHighShadowEnd  MEM_TO_SHADOW(kHighMemEnd)
+
+# define kMidShadowBeg MEM_TO_SHADOW(kMidMemBeg)
+# define kMidShadowEnd MEM_TO_SHADOW(kMidMemEnd)
+
+// With the zero shadow base we can not actually map pages starting from 0.
+// This constant is somewhat arbitrary.
+#define kZeroBaseShadowStart 0
+#define kZeroBaseMaxShadowStart (1 << 18)
+
+#define kShadowGapBeg   (kLowShadowEnd ? kLowShadowEnd + 1 \
+                                       : kZeroBaseShadowStart)
+#define kShadowGapEnd   ((kMidMemBeg ? kMidShadowBeg : kHighShadowBeg) - 1)
+
+#define kShadowGap2Beg (kMidMemBeg ? kMidShadowEnd + 1 : 0)
+#define kShadowGap2End (kMidMemBeg ? kMidMemBeg - 1 : 0)
+
+#define kShadowGap3Beg (kMidMemBeg ? kMidMemEnd + 1 : 0)
+#define kShadowGap3End (kMidMemBeg ? kHighShadowBeg - 1 : 0)
+
+#define DO_ASAN_MAPPING_PROFILE 0  // Set to 1 to profile the functions below.
+
+#if DO_ASAN_MAPPING_PROFILE
+# define PROFILE_ASAN_MAPPING() AsanMappingProfile[__LINE__]++;
+#else
+# define PROFILE_ASAN_MAPPING()
+#endif
+
+// If 1, all shadow boundaries are constants.
+// Don't set to 1 other than for testing.
+#define ASAN_FIXED_MAPPING 0
+
+namespace __asan {
+
+extern uptr AsanMappingProfile[];
+
+#if ASAN_FIXED_MAPPING
+// Fixed mapping for 64-bit Linux. Mostly used for performance comparison
+// with non-fixed mapping. As of r175253 (Feb 2013) the performance
+// difference between fixed and non-fixed mapping is below the noise level.
+static uptr kHighMemEnd = 0x7fffffffffffULL;
+static uptr kMidMemBeg =    0x3000000000ULL;
+static uptr kMidMemEnd =    0x4fffffffffULL;
+#else
+extern uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;  // Initialized in __asan_init.
+#endif
+
+static inline bool AddrIsInLowMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a < kLowMemEnd;
+}
+
+static inline bool AddrIsInLowShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kLowShadowBeg && a <= kLowShadowEnd;
+}
+
+static inline bool AddrIsInHighMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kHighMemBeg && a <= kHighMemEnd;
+}
+
+static inline bool AddrIsInMidMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return kMidMemBeg && a >= kMidMemBeg && a <= kMidMemEnd;
+}
+
+static inline bool AddrIsInMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return AddrIsInLowMem(a) || AddrIsInMidMem(a) || AddrIsInHighMem(a);
+}
+
+static inline uptr MemToShadow(uptr p) {
+  PROFILE_ASAN_MAPPING();
+  CHECK(AddrIsInMem(p));
+  return MEM_TO_SHADOW(p);
+}
+
+static inline bool AddrIsInHighShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kHighShadowBeg && a <= kHighMemEnd;
+}
+
+static inline bool AddrIsInMidShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return kMidMemBeg && a >= kMidShadowBeg && a <= kMidMemEnd;
+}
+
+static inline bool AddrIsInShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return AddrIsInLowShadow(a) || AddrIsInMidShadow(a) || AddrIsInHighShadow(a);
+}
+
+static inline bool AddrIsInShadowGap(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  if (kMidMemBeg) {
+    if (a <= kShadowGapEnd)
+      return SHADOW_OFFSET == 0 || a >= kShadowGapBeg;
+    return (a >= kShadowGap2Beg && a <= kShadowGap2End) ||
+           (a >= kShadowGap3Beg && a <= kShadowGap3End);
+  }
+  // In zero-based shadow mode we treat addresses near zero as addresses
+  // in shadow gap as well.
+  if (SHADOW_OFFSET == 0)
+    return a <= kShadowGapEnd;
+  return a >= kShadowGapBeg && a <= kShadowGapEnd;
+}
+
+static inline bool AddrIsAlignedByGranularity(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return (a & (SHADOW_GRANULARITY - 1)) == 0;
+}
+
+static inline bool AddressIsPoisoned(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  const uptr kAccessSize = 1;
+  u8 *shadow_address = (u8*)MEM_TO_SHADOW(a);
+  s8 shadow_value = *shadow_address;
+  if (shadow_value) {
+    u8 last_accessed_byte = (a & (SHADOW_GRANULARITY - 1))
+                                 + kAccessSize - 1;
+    return (last_accessed_byte >= shadow_value);
+  }
+  return false;
+}
+
+// Must be after all calls to PROFILE_ASAN_MAPPING().
+static const uptr kAsanMappingProfileSize = __LINE__;
+
+}  // namespace __asan
+
+#endif  // ASAN_MAPPING_H
diff --git a/compiler-rt/lib/asan/asan_new_delete.cc b/compiler-rt/lib/asan/asan_new_delete.cc
new file mode 100644
index 0000000..b5ba13e
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_new_delete.cc
@@ -0,0 +1,132 @@
+//===-- asan_interceptors.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Interceptors for operators new and delete.
+//===----------------------------------------------------------------------===//
+
+#include "asan_allocator.h"
+#include "asan_internal.h"
+#include "asan_stack.h"
+
+#include "interception/interception.h"
+
+#include <stddef.h>
+
+// C++ operators can't have visibility attributes on Windows.
+#if SANITIZER_WINDOWS
+# define CXX_OPERATOR_ATTRIBUTE
+#else
+# define CXX_OPERATOR_ATTRIBUTE INTERCEPTOR_ATTRIBUTE
+#endif
+
+using namespace __asan;  // NOLINT
+
+// This code has issues on OSX.
+// See https://github.com/google/sanitizers/issues/131.
+
+// Fake std::nothrow_t to avoid including <new>.
+namespace std {
+struct nothrow_t {};
+}  // namespace std
+
+#define OPERATOR_NEW_BODY(type) \
+  GET_STACK_TRACE_MALLOC;\
+  return asan_memalign(0, size, &stack, type);
+
+// On OS X it's not enough to just provide our own 'operator new' and
+// 'operator delete' implementations, because they're going to be in the
+// runtime dylib, and the main executable will depend on both the runtime
+// dylib and libstdc++, each of those'll have its implementation of new and
+// delete.
+// To make sure that C++ allocation/deallocation operators are overridden on
+// OS X we need to intercept them using their mangled names.
+#if !SANITIZER_MAC
+// FreeBSD prior v9.2 have wrong definition of 'size_t'.
+// http://svnweb.freebsd.org/base?view=revision&revision=232261
+#if SANITIZER_FREEBSD && SANITIZER_WORDSIZE == 32
+#include <sys/param.h>
+#if __FreeBSD_version <= 902001  // v9.2
+#define size_t unsigned
+#endif  // __FreeBSD_version
+#endif  // SANITIZER_FREEBSD && SANITIZER_WORDSIZE == 32
+
+CXX_OPERATOR_ATTRIBUTE
+void *operator new(size_t size) { OPERATOR_NEW_BODY(FROM_NEW); }
+CXX_OPERATOR_ATTRIBUTE
+void *operator new[](size_t size) { OPERATOR_NEW_BODY(FROM_NEW_BR); }
+CXX_OPERATOR_ATTRIBUTE
+void *operator new(size_t size, std::nothrow_t const&)
+{ OPERATOR_NEW_BODY(FROM_NEW); }
+CXX_OPERATOR_ATTRIBUTE
+void *operator new[](size_t size, std::nothrow_t const&)
+{ OPERATOR_NEW_BODY(FROM_NEW_BR); }
+
+#else  // SANITIZER_MAC
+INTERCEPTOR(void *, _Znwm, size_t size) {
+  OPERATOR_NEW_BODY(FROM_NEW);
+}
+INTERCEPTOR(void *, _Znam, size_t size) {
+  OPERATOR_NEW_BODY(FROM_NEW_BR);
+}
+INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
+  OPERATOR_NEW_BODY(FROM_NEW);
+}
+INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
+  OPERATOR_NEW_BODY(FROM_NEW_BR);
+}
+#endif
+
+#define OPERATOR_DELETE_BODY(type) \
+  GET_STACK_TRACE_FREE;\
+  asan_free(ptr, &stack, type);
+
+#if !SANITIZER_MAC
+CXX_OPERATOR_ATTRIBUTE
+void operator delete(void *ptr) NOEXCEPT {
+  OPERATOR_DELETE_BODY(FROM_NEW);
+}
+CXX_OPERATOR_ATTRIBUTE
+void operator delete[](void *ptr) NOEXCEPT {
+  OPERATOR_DELETE_BODY(FROM_NEW_BR);
+}
+CXX_OPERATOR_ATTRIBUTE
+void operator delete(void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY(FROM_NEW);
+}
+CXX_OPERATOR_ATTRIBUTE
+void operator delete[](void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY(FROM_NEW_BR);
+}
+CXX_OPERATOR_ATTRIBUTE
+void operator delete(void *ptr, size_t size) NOEXCEPT {
+  GET_STACK_TRACE_FREE;
+  asan_sized_free(ptr, size, &stack, FROM_NEW);
+}
+CXX_OPERATOR_ATTRIBUTE
+void operator delete[](void *ptr, size_t size) NOEXCEPT {
+  GET_STACK_TRACE_FREE;
+  asan_sized_free(ptr, size, &stack, FROM_NEW_BR);
+}
+
+#else  // SANITIZER_MAC
+INTERCEPTOR(void, _ZdlPv, void *ptr) {
+  OPERATOR_DELETE_BODY(FROM_NEW);
+}
+INTERCEPTOR(void, _ZdaPv, void *ptr) {
+  OPERATOR_DELETE_BODY(FROM_NEW_BR);
+}
+INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY(FROM_NEW);
+}
+INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY(FROM_NEW_BR);
+}
+#endif
diff --git a/compiler-rt/lib/asan/asan_poisoning.cc b/compiler-rt/lib/asan/asan_poisoning.cc
new file mode 100644
index 0000000..f77ab87
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_poisoning.cc
@@ -0,0 +1,434 @@
+//===-- asan_poisoning.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Shadow memory poisoning by ASan RTL and by user application.
+//===----------------------------------------------------------------------===//
+
+#include "asan_poisoning.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_flags.h"
+
+namespace __asan {
+
+static atomic_uint8_t can_poison_memory;
+
+void SetCanPoisonMemory(bool value) {
+  atomic_store(&can_poison_memory, value, memory_order_release);
+}
+
+bool CanPoisonMemory() {
+  return atomic_load(&can_poison_memory, memory_order_acquire);
+}
+
+void PoisonShadow(uptr addr, uptr size, u8 value) {
+  if (!CanPoisonMemory()) return;
+  CHECK(AddrIsAlignedByGranularity(addr));
+  CHECK(AddrIsInMem(addr));
+  CHECK(AddrIsAlignedByGranularity(addr + size));
+  CHECK(AddrIsInMem(addr + size - SHADOW_GRANULARITY));
+  CHECK(REAL(memset));
+  FastPoisonShadow(addr, size, value);
+}
+
+void PoisonShadowPartialRightRedzone(uptr addr,
+                                     uptr size,
+                                     uptr redzone_size,
+                                     u8 value) {
+  if (!CanPoisonMemory()) return;
+  CHECK(AddrIsAlignedByGranularity(addr));
+  CHECK(AddrIsInMem(addr));
+  FastPoisonShadowPartialRightRedzone(addr, size, redzone_size, value);
+}
+
+struct ShadowSegmentEndpoint {
+  u8 *chunk;
+  s8 offset;  // in [0, SHADOW_GRANULARITY)
+  s8 value;  // = *chunk;
+
+  explicit ShadowSegmentEndpoint(uptr address) {
+    chunk = (u8*)MemToShadow(address);
+    offset = address & (SHADOW_GRANULARITY - 1);
+    value = *chunk;
+  }
+};
+
+void FlushUnneededASanShadowMemory(uptr p, uptr size) {
+    // Since asan's mapping is compacting, the shadow chunk may be
+    // not page-aligned, so we only flush the page-aligned portion.
+    uptr page_size = GetPageSizeCached();
+    uptr shadow_beg = RoundUpTo(MemToShadow(p), page_size);
+    uptr shadow_end = RoundDownTo(MemToShadow(p + size), page_size);
+    FlushUnneededShadowMemory(shadow_beg, shadow_end - shadow_beg);
+}
+
+void AsanPoisonOrUnpoisonIntraObjectRedzone(uptr ptr, uptr size, bool poison) {
+  uptr end = ptr + size;
+  if (Verbosity()) {
+    Printf("__asan_%spoison_intra_object_redzone [%p,%p) %zd\n",
+           poison ? "" : "un", ptr, end, size);
+    if (Verbosity() >= 2)
+      PRINT_CURRENT_STACK();
+  }
+  CHECK(size);
+  CHECK_LE(size, 4096);
+  CHECK(IsAligned(end, SHADOW_GRANULARITY));
+  if (!IsAligned(ptr, SHADOW_GRANULARITY)) {
+    *(u8 *)MemToShadow(ptr) =
+        poison ? static_cast<u8>(ptr % SHADOW_GRANULARITY) : 0;
+    ptr |= SHADOW_GRANULARITY - 1;
+    ptr++;
+  }
+  for (; ptr < end; ptr += SHADOW_GRANULARITY)
+    *(u8*)MemToShadow(ptr) = poison ? kAsanIntraObjectRedzone : 0;
+}
+
+}  // namespace __asan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+// Current implementation of __asan_(un)poison_memory_region doesn't check
+// that user program (un)poisons the memory it owns. It poisons memory
+// conservatively, and unpoisons progressively to make sure asan shadow
+// mapping invariant is preserved (see detailed mapping description here:
+// https://github.com/google/sanitizers/wiki/AddressSanitizerAlgorithm).
+//
+// * if user asks to poison region [left, right), the program poisons
+// at least [left, AlignDown(right)).
+// * if user asks to unpoison region [left, right), the program unpoisons
+// at most [AlignDown(left), right).
+void __asan_poison_memory_region(void const volatile *addr, uptr size) {
+  if (!flags()->allow_user_poisoning || size == 0) return;
+  uptr beg_addr = (uptr)addr;
+  uptr end_addr = beg_addr + size;
+  VPrintf(3, "Trying to poison memory region [%p, %p)\n", (void *)beg_addr,
+          (void *)end_addr);
+  ShadowSegmentEndpoint beg(beg_addr);
+  ShadowSegmentEndpoint end(end_addr);
+  if (beg.chunk == end.chunk) {
+    CHECK(beg.offset < end.offset);
+    s8 value = beg.value;
+    CHECK(value == end.value);
+    // We can only poison memory if the byte in end.offset is unaddressable.
+    // No need to re-poison memory if it is poisoned already.
+    if (value > 0 && value <= end.offset) {
+      if (beg.offset > 0) {
+        *beg.chunk = Min(value, beg.offset);
+      } else {
+        *beg.chunk = kAsanUserPoisonedMemoryMagic;
+      }
+    }
+    return;
+  }
+  CHECK(beg.chunk < end.chunk);
+  if (beg.offset > 0) {
+    // Mark bytes from beg.offset as unaddressable.
+    if (beg.value == 0) {
+      *beg.chunk = beg.offset;
+    } else {
+      *beg.chunk = Min(beg.value, beg.offset);
+    }
+    beg.chunk++;
+  }
+  REAL(memset)(beg.chunk, kAsanUserPoisonedMemoryMagic, end.chunk - beg.chunk);
+  // Poison if byte in end.offset is unaddressable.
+  if (end.value > 0 && end.value <= end.offset) {
+    *end.chunk = kAsanUserPoisonedMemoryMagic;
+  }
+}
+
+void __asan_unpoison_memory_region(void const volatile *addr, uptr size) {
+  if (!flags()->allow_user_poisoning || size == 0) return;
+  uptr beg_addr = (uptr)addr;
+  uptr end_addr = beg_addr + size;
+  VPrintf(3, "Trying to unpoison memory region [%p, %p)\n", (void *)beg_addr,
+          (void *)end_addr);
+  ShadowSegmentEndpoint beg(beg_addr);
+  ShadowSegmentEndpoint end(end_addr);
+  if (beg.chunk == end.chunk) {
+    CHECK(beg.offset < end.offset);
+    s8 value = beg.value;
+    CHECK(value == end.value);
+    // We unpoison memory bytes up to enbytes up to end.offset if it is not
+    // unpoisoned already.
+    if (value != 0) {
+      *beg.chunk = Max(value, end.offset);
+    }
+    return;
+  }
+  CHECK(beg.chunk < end.chunk);
+  if (beg.offset > 0) {
+    *beg.chunk = 0;
+    beg.chunk++;
+  }
+  REAL(memset)(beg.chunk, 0, end.chunk - beg.chunk);
+  if (end.offset > 0 && end.value != 0) {
+    *end.chunk = Max(end.value, end.offset);
+  }
+}
+
+int __asan_address_is_poisoned(void const volatile *addr) {
+  return __asan::AddressIsPoisoned((uptr)addr);
+}
+
+uptr __asan_region_is_poisoned(uptr beg, uptr size) {
+  if (!size) return 0;
+  uptr end = beg + size;
+  if (!AddrIsInMem(beg)) return beg;
+  if (!AddrIsInMem(end)) return end;
+  CHECK_LT(beg, end);
+  uptr aligned_b = RoundUpTo(beg, SHADOW_GRANULARITY);
+  uptr aligned_e = RoundDownTo(end, SHADOW_GRANULARITY);
+  uptr shadow_beg = MemToShadow(aligned_b);
+  uptr shadow_end = MemToShadow(aligned_e);
+  // First check the first and the last application bytes,
+  // then check the SHADOW_GRANULARITY-aligned region by calling
+  // mem_is_zero on the corresponding shadow.
+  if (!__asan::AddressIsPoisoned(beg) &&
+      !__asan::AddressIsPoisoned(end - 1) &&
+      (shadow_end <= shadow_beg ||
+       __sanitizer::mem_is_zero((const char *)shadow_beg,
+                                shadow_end - shadow_beg)))
+    return 0;
+  // The fast check failed, so we have a poisoned byte somewhere.
+  // Find it slowly.
+  for (; beg < end; beg++)
+    if (__asan::AddressIsPoisoned(beg))
+      return beg;
+  UNREACHABLE("mem_is_zero returned false, but poisoned byte was not found");
+  return 0;
+}
+
+#define CHECK_SMALL_REGION(p, size, isWrite)                  \
+  do {                                                        \
+    uptr __p = reinterpret_cast<uptr>(p);                     \
+    uptr __size = size;                                       \
+    if (UNLIKELY(__asan::AddressIsPoisoned(__p) ||            \
+        __asan::AddressIsPoisoned(__p + __size - 1))) {       \
+      GET_CURRENT_PC_BP_SP;                                   \
+      uptr __bad = __asan_region_is_poisoned(__p, __size);    \
+      __asan_report_error(pc, bp, sp, __bad, isWrite, __size, 0);\
+    }                                                         \
+  } while (false);                                            \
+
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+u16 __sanitizer_unaligned_load16(const uu16 *p) {
+  CHECK_SMALL_REGION(p, sizeof(*p), false);
+  return *p;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+u32 __sanitizer_unaligned_load32(const uu32 *p) {
+  CHECK_SMALL_REGION(p, sizeof(*p), false);
+  return *p;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+u64 __sanitizer_unaligned_load64(const uu64 *p) {
+  CHECK_SMALL_REGION(p, sizeof(*p), false);
+  return *p;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store16(uu16 *p, u16 x) {
+  CHECK_SMALL_REGION(p, sizeof(*p), true);
+  *p = x;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store32(uu32 *p, u32 x) {
+  CHECK_SMALL_REGION(p, sizeof(*p), true);
+  *p = x;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store64(uu64 *p, u64 x) {
+  CHECK_SMALL_REGION(p, sizeof(*p), true);
+  *p = x;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __asan_poison_cxx_array_cookie(uptr p) {
+  if (SANITIZER_WORDSIZE != 64) return;
+  if (!flags()->poison_array_cookie) return;
+  uptr s = MEM_TO_SHADOW(p);
+  *reinterpret_cast<u8*>(s) = kAsanArrayCookieMagic;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+uptr __asan_load_cxx_array_cookie(uptr *p) {
+  if (SANITIZER_WORDSIZE != 64) return *p;
+  if (!flags()->poison_array_cookie) return *p;
+  uptr s = MEM_TO_SHADOW(reinterpret_cast<uptr>(p));
+  u8 sval = *reinterpret_cast<u8*>(s);
+  if (sval == kAsanArrayCookieMagic) return *p;
+  // If sval is not kAsanArrayCookieMagic it can only be freed memory,
+  // which means that we are going to get double-free. So, return 0 to avoid
+  // infinite loop of destructors. We don't want to report a double-free here
+  // though, so print a warning just in case.
+  // CHECK_EQ(sval, kAsanHeapFreeMagic);
+  if (sval == kAsanHeapFreeMagic) {
+    Report("AddressSanitizer: loaded array cookie from free-d memory; "
+           "expect a double-free report\n");
+    return 0;
+  }
+  // The cookie may remain unpoisoned if e.g. it comes from a custom
+  // operator new defined inside a class.
+  return *p;
+}
+
+// This is a simplified version of __asan_(un)poison_memory_region, which
+// assumes that left border of region to be poisoned is properly aligned.
+static void PoisonAlignedStackMemory(uptr addr, uptr size, bool do_poison) {
+  if (size == 0) return;
+  uptr aligned_size = size & ~(SHADOW_GRANULARITY - 1);
+  PoisonShadow(addr, aligned_size,
+               do_poison ? kAsanStackUseAfterScopeMagic : 0);
+  if (size == aligned_size)
+    return;
+  s8 end_offset = (s8)(size - aligned_size);
+  s8* shadow_end = (s8*)MemToShadow(addr + aligned_size);
+  s8 end_value = *shadow_end;
+  if (do_poison) {
+    // If possible, mark all the bytes mapping to last shadow byte as
+    // unaddressable.
+    if (end_value > 0 && end_value <= end_offset)
+      *shadow_end = (s8)kAsanStackUseAfterScopeMagic;
+  } else {
+    // If necessary, mark few first bytes mapping to last shadow byte
+    // as addressable
+    if (end_value != 0)
+      *shadow_end = Max(end_value, end_offset);
+  }
+}
+
+void __asan_poison_stack_memory(uptr addr, uptr size) {
+  VReport(1, "poisoning: %p %zx\n", (void *)addr, size);
+  PoisonAlignedStackMemory(addr, size, true);
+}
+
+void __asan_unpoison_stack_memory(uptr addr, uptr size) {
+  VReport(1, "unpoisoning: %p %zx\n", (void *)addr, size);
+  PoisonAlignedStackMemory(addr, size, false);
+}
+
+void __sanitizer_annotate_contiguous_container(const void *beg_p,
+                                               const void *end_p,
+                                               const void *old_mid_p,
+                                               const void *new_mid_p) {
+  if (!flags()->detect_container_overflow) return;
+  VPrintf(2, "contiguous_container: %p %p %p %p\n", beg_p, end_p, old_mid_p,
+          new_mid_p);
+  uptr beg = reinterpret_cast<uptr>(beg_p);
+  uptr end = reinterpret_cast<uptr>(end_p);
+  uptr old_mid = reinterpret_cast<uptr>(old_mid_p);
+  uptr new_mid = reinterpret_cast<uptr>(new_mid_p);
+  uptr granularity = SHADOW_GRANULARITY;
+  if (!(beg <= old_mid && beg <= new_mid && old_mid <= end && new_mid <= end &&
+        IsAligned(beg, granularity))) {
+    GET_STACK_TRACE_FATAL_HERE;
+    ReportBadParamsToAnnotateContiguousContainer(beg, end, old_mid, new_mid,
+                                                 &stack);
+  }
+  CHECK_LE(end - beg,
+           FIRST_32_SECOND_64(1UL << 30, 1UL << 34)); // Sanity check.
+
+  uptr a = RoundDownTo(Min(old_mid, new_mid), granularity);
+  uptr c = RoundUpTo(Max(old_mid, new_mid), granularity);
+  uptr d1 = RoundDownTo(old_mid, granularity);
+  // uptr d2 = RoundUpTo(old_mid, granularity);
+  // Currently we should be in this state:
+  // [a, d1) is good, [d2, c) is bad, [d1, d2) is partially good.
+  // Make a quick sanity check that we are indeed in this state.
+  //
+  // FIXME: Two of these three checks are disabled until we fix
+  // https://github.com/google/sanitizers/issues/258.
+  // if (d1 != d2)
+  //  CHECK_EQ(*(u8*)MemToShadow(d1), old_mid - d1);
+  if (a + granularity <= d1)
+    CHECK_EQ(*(u8*)MemToShadow(a), 0);
+  // if (d2 + granularity <= c && c <= end)
+  //   CHECK_EQ(*(u8 *)MemToShadow(c - granularity),
+  //            kAsanContiguousContainerOOBMagic);
+
+  uptr b1 = RoundDownTo(new_mid, granularity);
+  uptr b2 = RoundUpTo(new_mid, granularity);
+  // New state:
+  // [a, b1) is good, [b2, c) is bad, [b1, b2) is partially good.
+  PoisonShadow(a, b1 - a, 0);
+  PoisonShadow(b2, c - b2, kAsanContiguousContainerOOBMagic);
+  if (b1 != b2) {
+    CHECK_EQ(b2 - b1, granularity);
+    *(u8*)MemToShadow(b1) = static_cast<u8>(new_mid - b1);
+  }
+}
+
+const void *__sanitizer_contiguous_container_find_bad_address(
+    const void *beg_p, const void *mid_p, const void *end_p) {
+  if (!flags()->detect_container_overflow)
+    return nullptr;
+  uptr beg = reinterpret_cast<uptr>(beg_p);
+  uptr end = reinterpret_cast<uptr>(end_p);
+  uptr mid = reinterpret_cast<uptr>(mid_p);
+  CHECK_LE(beg, mid);
+  CHECK_LE(mid, end);
+  // Check some bytes starting from beg, some bytes around mid, and some bytes
+  // ending with end.
+  uptr kMaxRangeToCheck = 32;
+  uptr r1_beg = beg;
+  uptr r1_end = Min(end + kMaxRangeToCheck, mid);
+  uptr r2_beg = Max(beg, mid - kMaxRangeToCheck);
+  uptr r2_end = Min(end, mid + kMaxRangeToCheck);
+  uptr r3_beg = Max(end - kMaxRangeToCheck, mid);
+  uptr r3_end = end;
+  for (uptr i = r1_beg; i < r1_end; i++)
+    if (AddressIsPoisoned(i))
+      return reinterpret_cast<const void *>(i);
+  for (uptr i = r2_beg; i < mid; i++)
+    if (AddressIsPoisoned(i))
+      return reinterpret_cast<const void *>(i);
+  for (uptr i = mid; i < r2_end; i++)
+    if (!AddressIsPoisoned(i))
+      return reinterpret_cast<const void *>(i);
+  for (uptr i = r3_beg; i < r3_end; i++)
+    if (!AddressIsPoisoned(i))
+      return reinterpret_cast<const void *>(i);
+  return nullptr;
+}
+
+int __sanitizer_verify_contiguous_container(const void *beg_p,
+                                            const void *mid_p,
+                                            const void *end_p) {
+  return __sanitizer_contiguous_container_find_bad_address(beg_p, mid_p,
+                                                           end_p) == nullptr;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __asan_poison_intra_object_redzone(uptr ptr, uptr size) {
+  AsanPoisonOrUnpoisonIntraObjectRedzone(ptr, size, true);
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __asan_unpoison_intra_object_redzone(uptr ptr, uptr size) {
+  AsanPoisonOrUnpoisonIntraObjectRedzone(ptr, size, false);
+}
+
+// --- Implementation of LSan-specific functions --- {{{1
+namespace __lsan {
+bool WordIsPoisoned(uptr addr) {
+  return (__asan_region_is_poisoned(addr, sizeof(uptr)) != 0);
+}
+}
+
diff --git a/compiler-rt/lib/asan/asan_poisoning.h b/compiler-rt/lib/asan/asan_poisoning.h
new file mode 100644
index 0000000..6344225
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_poisoning.h
@@ -0,0 +1,93 @@
+//===-- asan_poisoning.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Shadow memory poisoning by ASan RTL and by user application.
+//===----------------------------------------------------------------------===//
+
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "sanitizer_common/sanitizer_flags.h"
+
+namespace __asan {
+
+// Enable/disable memory poisoning.
+void SetCanPoisonMemory(bool value);
+bool CanPoisonMemory();
+
+// Poisons the shadow memory for "size" bytes starting from "addr".
+void PoisonShadow(uptr addr, uptr size, u8 value);
+
+// Poisons the shadow memory for "redzone_size" bytes starting from
+// "addr + size".
+void PoisonShadowPartialRightRedzone(uptr addr,
+                                     uptr size,
+                                     uptr redzone_size,
+                                     u8 value);
+
+// Fast versions of PoisonShadow and PoisonShadowPartialRightRedzone that
+// assume that memory addresses are properly aligned. Use in
+// performance-critical code with care.
+ALWAYS_INLINE void FastPoisonShadow(uptr aligned_beg, uptr aligned_size,
+                                    u8 value) {
+  DCHECK(CanPoisonMemory());
+  uptr shadow_beg = MEM_TO_SHADOW(aligned_beg);
+  uptr shadow_end = MEM_TO_SHADOW(
+      aligned_beg + aligned_size - SHADOW_GRANULARITY) + 1;
+  // FIXME: Page states are different on Windows, so using the same interface
+  // for mapping shadow and zeroing out pages doesn't "just work", so we should
+  // probably provide higher-level interface for these operations.
+  // For now, just memset on Windows.
+  if (value ||
+      SANITIZER_WINDOWS == 1 ||
+      shadow_end - shadow_beg < common_flags()->clear_shadow_mmap_threshold) {
+    REAL(memset)((void*)shadow_beg, value, shadow_end - shadow_beg);
+  } else {
+    uptr page_size = GetPageSizeCached();
+    uptr page_beg = RoundUpTo(shadow_beg, page_size);
+    uptr page_end = RoundDownTo(shadow_end, page_size);
+
+    if (page_beg >= page_end) {
+      REAL(memset)((void *)shadow_beg, 0, shadow_end - shadow_beg);
+    } else {
+      if (page_beg != shadow_beg) {
+        REAL(memset)((void *)shadow_beg, 0, page_beg - shadow_beg);
+      }
+      if (page_end != shadow_end) {
+        REAL(memset)((void *)page_end, 0, shadow_end - page_end);
+      }
+      ReserveShadowMemoryRange(page_beg, page_end - 1, nullptr);
+    }
+  }
+}
+
+ALWAYS_INLINE void FastPoisonShadowPartialRightRedzone(
+    uptr aligned_addr, uptr size, uptr redzone_size, u8 value) {
+  DCHECK(CanPoisonMemory());
+  bool poison_partial = flags()->poison_partial;
+  u8 *shadow = (u8*)MEM_TO_SHADOW(aligned_addr);
+  for (uptr i = 0; i < redzone_size; i += SHADOW_GRANULARITY, shadow++) {
+    if (i + SHADOW_GRANULARITY <= size) {
+      *shadow = 0;  // fully addressable
+    } else if (i >= size) {
+      *shadow = (SHADOW_GRANULARITY == 128) ? 0xff : value;  // unaddressable
+    } else {
+      // first size-i bytes are addressable
+      *shadow = poison_partial ? static_cast<u8>(size - i) : 0;
+    }
+  }
+}
+
+// Calls __sanitizer::FlushUnneededShadowMemory() on
+// [MemToShadow(p), MemToShadow(p+size)] with proper rounding.
+void FlushUnneededASanShadowMemory(uptr p, uptr size);
+
+}  // namespace __asan
diff --git a/compiler-rt/lib/asan/asan_posix.cc b/compiler-rt/lib/asan/asan_posix.cc
new file mode 100644
index 0000000..9e01bcd
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_posix.cc
@@ -0,0 +1,117 @@
+//===-- asan_posix.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Posix-specific details.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_POSIX
+
+#include "asan_internal.h"
+#include "asan_interceptors.h"
+#include "asan_mapping.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_posix.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+
+#include <pthread.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+namespace __asan {
+
+void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
+  ScopedDeadlySignal signal_scope(GetCurrentThread());
+  int code = (int)((siginfo_t*)siginfo)->si_code;
+  // Write the first message using the bullet-proof write.
+  if (18 != internal_write(2, "ASAN:DEADLYSIGNAL\n", 18)) Die();
+  SignalContext sig = SignalContext::Create(siginfo, context);
+
+  // Access at a reasonable offset above SP, or slightly below it (to account
+  // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is
+  // probably a stack overflow.
+  bool IsStackAccess = sig.addr + 512 > sig.sp && sig.addr < sig.sp + 0xFFFF;
+
+#if __powerpc__
+  // Large stack frames can be allocated with e.g.
+  //   lis r0,-10000
+  //   stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000
+  // If the store faults then sp will not have been updated, so test above
+  // will not work, becase the fault address will be more than just "slightly"
+  // below sp.
+  if (!IsStackAccess && IsAccessibleMemoryRange(sig.pc, 4)) {
+    u32 inst = *(unsigned *)sig.pc;
+    u32 ra = (inst >> 16) & 0x1F;
+    u32 opcd = inst >> 26;
+    u32 xo = (inst >> 1) & 0x3FF;
+    // Check for store-with-update to sp. The instructions we accept are:
+    //   stbu rs,d(ra)          stbux rs,ra,rb
+    //   sthu rs,d(ra)          sthux rs,ra,rb
+    //   stwu rs,d(ra)          stwux rs,ra,rb
+    //   stdu rs,ds(ra)         stdux rs,ra,rb
+    // where ra is r1 (the stack pointer).
+    if (ra == 1 &&
+        (opcd == 39 || opcd == 45 || opcd == 37 || opcd == 62 ||
+         (opcd == 31 && (xo == 247 || xo == 439 || xo == 183 || xo == 181))))
+      IsStackAccess = true;
+  }
+#endif // __powerpc__
+
+  // We also check si_code to filter out SEGV caused by something else other
+  // then hitting the guard page or unmapped memory, like, for example,
+  // unaligned memory access.
+  if (IsStackAccess && (code == si_SEGV_MAPERR || code == si_SEGV_ACCERR))
+    ReportStackOverflow(sig);
+  else if (signo == SIGFPE)
+    ReportDeadlySignal("FPE", sig);
+  else if (signo == SIGILL)
+    ReportDeadlySignal("ILL", sig);
+  else
+    ReportDeadlySignal("SEGV", sig);
+}
+
+// ---------------------- TSD ---------------- {{{1
+
+static pthread_key_t tsd_key;
+static bool tsd_key_inited = false;
+void AsanTSDInit(void (*destructor)(void *tsd)) {
+  CHECK(!tsd_key_inited);
+  tsd_key_inited = true;
+  CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
+}
+
+void *AsanTSDGet() {
+  CHECK(tsd_key_inited);
+  return pthread_getspecific(tsd_key);
+}
+
+void AsanTSDSet(void *tsd) {
+  CHECK(tsd_key_inited);
+  pthread_setspecific(tsd_key, tsd);
+}
+
+void PlatformTSDDtor(void *tsd) {
+  AsanThreadContext *context = (AsanThreadContext*)tsd;
+  if (context->destructor_iterations > 1) {
+    context->destructor_iterations--;
+    CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));
+    return;
+  }
+  AsanThread::TSDDtor(tsd);
+}
+}  // namespace __asan
+
+#endif  // SANITIZER_POSIX
diff --git a/compiler-rt/lib/asan/asan_preinit.cc b/compiler-rt/lib/asan/asan_preinit.cc
new file mode 100644
index 0000000..a3986d2
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_preinit.cc
@@ -0,0 +1,25 @@
+//===-- asan_preinit.cc ---------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Call __asan_init at the very early stage of process startup.
+//===----------------------------------------------------------------------===//
+#include "asan_internal.h"
+
+using namespace __asan;
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+  // The symbol is called __local_asan_preinit, because it's not intended to be
+  // exported.
+  // This code linked into the main executable when -fsanitize=address is in
+  // the link flags. It can only use exported interface functions.
+  __attribute__((section(".preinit_array"), used))
+  void (*__local_asan_preinit)(void) = __asan_init;
+#endif
diff --git a/compiler-rt/lib/asan/asan_report.cc b/compiler-rt/lib/asan/asan_report.cc
new file mode 100644
index 0000000..0fb6084
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_report.cc
@@ -0,0 +1,1188 @@
+//===-- asan_report.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This file contains error reporting code.
+//===----------------------------------------------------------------------===//
+
+#include "asan_flags.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_report_decorator.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+namespace __asan {
+
+// -------------------- User-specified callbacks ----------------- {{{1
+static void (*error_report_callback)(const char*);
+static char *error_message_buffer = nullptr;
+static uptr error_message_buffer_pos = 0;
+static BlockingMutex error_message_buf_mutex(LINKER_INITIALIZED);
+static const unsigned kAsanBuggyPcPoolSize = 25;
+static __sanitizer::atomic_uintptr_t AsanBuggyPcPool[kAsanBuggyPcPoolSize];
+
+struct ReportData {
+  uptr pc;
+  uptr sp;
+  uptr bp;
+  uptr addr;
+  bool is_write;
+  uptr access_size;
+  const char *description;
+};
+
+static bool report_happened = false;
+static ReportData report_data = {};
+
+void AppendToErrorMessageBuffer(const char *buffer) {
+  BlockingMutexLock l(&error_message_buf_mutex);
+  if (!error_message_buffer) {
+    error_message_buffer =
+      (char*)MmapOrDieQuietly(kErrorMessageBufferSize, __func__);
+    error_message_buffer_pos = 0;
+  }
+  uptr length = internal_strlen(buffer);
+  RAW_CHECK(kErrorMessageBufferSize >= error_message_buffer_pos);
+  uptr remaining = kErrorMessageBufferSize - error_message_buffer_pos;
+  internal_strncpy(error_message_buffer + error_message_buffer_pos,
+                   buffer, remaining);
+  error_message_buffer[kErrorMessageBufferSize - 1] = '\0';
+  // FIXME: reallocate the buffer instead of truncating the message.
+  error_message_buffer_pos += Min(remaining, length);
+}
+
+// ---------------------- Decorator ------------------------------ {{{1
+class Decorator: public __sanitizer::SanitizerCommonDecorator {
+ public:
+  Decorator() : SanitizerCommonDecorator() { }
+  const char *Access()     { return Blue(); }
+  const char *EndAccess()  { return Default(); }
+  const char *Location()   { return Green(); }
+  const char *EndLocation() { return Default(); }
+  const char *Allocation()  { return Magenta(); }
+  const char *EndAllocation()  { return Default(); }
+
+  const char *ShadowByte(u8 byte) {
+    switch (byte) {
+      case kAsanHeapLeftRedzoneMagic:
+      case kAsanHeapRightRedzoneMagic:
+      case kAsanArrayCookieMagic:
+        return Red();
+      case kAsanHeapFreeMagic:
+        return Magenta();
+      case kAsanStackLeftRedzoneMagic:
+      case kAsanStackMidRedzoneMagic:
+      case kAsanStackRightRedzoneMagic:
+      case kAsanStackPartialRedzoneMagic:
+        return Red();
+      case kAsanStackAfterReturnMagic:
+        return Magenta();
+      case kAsanInitializationOrderMagic:
+        return Cyan();
+      case kAsanUserPoisonedMemoryMagic:
+      case kAsanContiguousContainerOOBMagic:
+      case kAsanAllocaLeftMagic:
+      case kAsanAllocaRightMagic:
+        return Blue();
+      case kAsanStackUseAfterScopeMagic:
+        return Magenta();
+      case kAsanGlobalRedzoneMagic:
+        return Red();
+      case kAsanInternalHeapMagic:
+        return Yellow();
+      case kAsanIntraObjectRedzone:
+        return Yellow();
+      default:
+        return Default();
+    }
+  }
+  const char *EndShadowByte() { return Default(); }
+  const char *MemoryByte() { return Magenta(); }
+  const char *EndMemoryByte() { return Default(); }
+};
+
+// ---------------------- Helper functions ----------------------- {{{1
+
+static void PrintMemoryByte(InternalScopedString *str, const char *before,
+    u8 byte, bool in_shadow, const char *after = "\n") {
+  Decorator d;
+  str->append("%s%s%x%x%s%s", before,
+              in_shadow ? d.ShadowByte(byte) : d.MemoryByte(),
+              byte >> 4, byte & 15,
+              in_shadow ? d.EndShadowByte() : d.EndMemoryByte(), after);
+}
+
+static void PrintShadowByte(InternalScopedString *str, const char *before,
+    u8 byte, const char *after = "\n") {
+  PrintMemoryByte(str, before, byte, /*in_shadow*/true, after);
+}
+
+static void PrintShadowBytes(InternalScopedString *str, const char *before,
+                             u8 *bytes, u8 *guilty, uptr n) {
+  Decorator d;
+  if (before) str->append("%s%p:", before, bytes);
+  for (uptr i = 0; i < n; i++) {
+    u8 *p = bytes + i;
+    const char *before =
+        p == guilty ? "[" : (p - 1 == guilty && i != 0) ? "" : " ";
+    const char *after = p == guilty ? "]" : "";
+    PrintShadowByte(str, before, *p, after);
+  }
+  str->append("\n");
+}
+
+static void PrintLegend(InternalScopedString *str) {
+  str->append(
+      "Shadow byte legend (one shadow byte represents %d "
+      "application bytes):\n",
+      (int)SHADOW_GRANULARITY);
+  PrintShadowByte(str, "  Addressable:           ", 0);
+  str->append("  Partially addressable: ");
+  for (u8 i = 1; i < SHADOW_GRANULARITY; i++) PrintShadowByte(str, "", i, " ");
+  str->append("\n");
+  PrintShadowByte(str, "  Heap left redzone:       ",
+                  kAsanHeapLeftRedzoneMagic);
+  PrintShadowByte(str, "  Heap right redzone:      ",
+                  kAsanHeapRightRedzoneMagic);
+  PrintShadowByte(str, "  Freed heap region:       ", kAsanHeapFreeMagic);
+  PrintShadowByte(str, "  Stack left redzone:      ",
+                  kAsanStackLeftRedzoneMagic);
+  PrintShadowByte(str, "  Stack mid redzone:       ",
+                  kAsanStackMidRedzoneMagic);
+  PrintShadowByte(str, "  Stack right redzone:     ",
+                  kAsanStackRightRedzoneMagic);
+  PrintShadowByte(str, "  Stack partial redzone:   ",
+                  kAsanStackPartialRedzoneMagic);
+  PrintShadowByte(str, "  Stack after return:      ",
+                  kAsanStackAfterReturnMagic);
+  PrintShadowByte(str, "  Stack use after scope:   ",
+                  kAsanStackUseAfterScopeMagic);
+  PrintShadowByte(str, "  Global redzone:          ", kAsanGlobalRedzoneMagic);
+  PrintShadowByte(str, "  Global init order:       ",
+                  kAsanInitializationOrderMagic);
+  PrintShadowByte(str, "  Poisoned by user:        ",
+                  kAsanUserPoisonedMemoryMagic);
+  PrintShadowByte(str, "  Container overflow:      ",
+                  kAsanContiguousContainerOOBMagic);
+  PrintShadowByte(str, "  Array cookie:            ",
+                  kAsanArrayCookieMagic);
+  PrintShadowByte(str, "  Intra object redzone:    ",
+                  kAsanIntraObjectRedzone);
+  PrintShadowByte(str, "  ASan internal:           ", kAsanInternalHeapMagic);
+  PrintShadowByte(str, "  Left alloca redzone:     ", kAsanAllocaLeftMagic);
+  PrintShadowByte(str, "  Right alloca redzone:    ", kAsanAllocaRightMagic);
+}
+
+void MaybeDumpInstructionBytes(uptr pc) {
+  if (!flags()->dump_instruction_bytes || (pc < GetPageSizeCached()))
+    return;
+  InternalScopedString str(1024);
+  str.append("First 16 instruction bytes at pc: ");
+  if (IsAccessibleMemoryRange(pc, 16)) {
+    for (int i = 0; i < 16; ++i) {
+      PrintMemoryByte(&str, "", ((u8 *)pc)[i], /*in_shadow*/false, " ");
+    }
+    str.append("\n");
+  } else {
+    str.append("unaccessible\n");
+  }
+  Report("%s", str.data());
+}
+
+static void PrintShadowMemoryForAddress(uptr addr) {
+  if (!AddrIsInMem(addr)) return;
+  uptr shadow_addr = MemToShadow(addr);
+  const uptr n_bytes_per_row = 16;
+  uptr aligned_shadow = shadow_addr & ~(n_bytes_per_row - 1);
+  InternalScopedString str(4096 * 8);
+  str.append("Shadow bytes around the buggy address:\n");
+  for (int i = -5; i <= 5; i++) {
+    const char *prefix = (i == 0) ? "=>" : "  ";
+    PrintShadowBytes(&str, prefix, (u8 *)(aligned_shadow + i * n_bytes_per_row),
+                     (u8 *)shadow_addr, n_bytes_per_row);
+  }
+  if (flags()->print_legend) PrintLegend(&str);
+  Printf("%s", str.data());
+}
+
+static void PrintZoneForPointer(uptr ptr, uptr zone_ptr,
+                                const char *zone_name) {
+  if (zone_ptr) {
+    if (zone_name) {
+      Printf("malloc_zone_from_ptr(%p) = %p, which is %s\n",
+                 ptr, zone_ptr, zone_name);
+    } else {
+      Printf("malloc_zone_from_ptr(%p) = %p, which doesn't have a name\n",
+                 ptr, zone_ptr);
+    }
+  } else {
+    Printf("malloc_zone_from_ptr(%p) = 0\n", ptr);
+  }
+}
+
+static void DescribeThread(AsanThread *t) {
+  if (t)
+    DescribeThread(t->context());
+}
+
+// ---------------------- Address Descriptions ------------------- {{{1
+
+static bool IsASCII(unsigned char c) {
+  return /*0x00 <= c &&*/ c <= 0x7F;
+}
+
+static const char *MaybeDemangleGlobalName(const char *name) {
+  // We can spoil names of globals with C linkage, so use an heuristic
+  // approach to check if the name should be demangled.
+  bool should_demangle = false;
+  if (name[0] == '_' && name[1] == 'Z')
+    should_demangle = true;
+  else if (SANITIZER_WINDOWS && name[0] == '\01' && name[1] == '?')
+    should_demangle = true;
+
+  return should_demangle ? Symbolizer::GetOrInit()->Demangle(name) : name;
+}
+
+// Check if the global is a zero-terminated ASCII string. If so, print it.
+static void PrintGlobalNameIfASCII(InternalScopedString *str,
+                                   const __asan_global &g) {
+  for (uptr p = g.beg; p < g.beg + g.size - 1; p++) {
+    unsigned char c = *(unsigned char*)p;
+    if (c == '\0' || !IsASCII(c)) return;
+  }
+  if (*(char*)(g.beg + g.size - 1) != '\0') return;
+  str->append("  '%s' is ascii string '%s'\n", MaybeDemangleGlobalName(g.name),
+              (char *)g.beg);
+}
+
+static const char *GlobalFilename(const __asan_global &g) {
+  const char *res = g.module_name;
+  // Prefer the filename from source location, if is available.
+  if (g.location)
+    res = g.location->filename;
+  CHECK(res);
+  return res;
+}
+
+static void PrintGlobalLocation(InternalScopedString *str,
+                                const __asan_global &g) {
+  str->append("%s", GlobalFilename(g));
+  if (!g.location)
+    return;
+  if (g.location->line_no)
+    str->append(":%d", g.location->line_no);
+  if (g.location->column_no)
+    str->append(":%d", g.location->column_no);
+}
+
+static void DescribeAddressRelativeToGlobal(uptr addr, uptr size,
+                                            const __asan_global &g) {
+  InternalScopedString str(4096);
+  Decorator d;
+  str.append("%s", d.Location());
+  if (addr < g.beg) {
+    str.append("%p is located %zd bytes to the left", (void *)addr,
+               g.beg - addr);
+  } else if (addr + size > g.beg + g.size) {
+    if (addr < g.beg + g.size)
+      addr = g.beg + g.size;
+    str.append("%p is located %zd bytes to the right", (void *)addr,
+               addr - (g.beg + g.size));
+  } else {
+    // Can it happen?
+    str.append("%p is located %zd bytes inside", (void *)addr, addr - g.beg);
+  }
+  str.append(" of global variable '%s' defined in '",
+             MaybeDemangleGlobalName(g.name));
+  PrintGlobalLocation(&str, g);
+  str.append("' (0x%zx) of size %zu\n", g.beg, g.size);
+  str.append("%s", d.EndLocation());
+  PrintGlobalNameIfASCII(&str, g);
+  Printf("%s", str.data());
+}
+
+static bool DescribeAddressIfGlobal(uptr addr, uptr size,
+                                    const char *bug_type) {
+  // Assume address is close to at most four globals.
+  const int kMaxGlobalsInReport = 4;
+  __asan_global globals[kMaxGlobalsInReport];
+  u32 reg_sites[kMaxGlobalsInReport];
+  int globals_num =
+      GetGlobalsForAddress(addr, globals, reg_sites, ARRAY_SIZE(globals));
+  if (globals_num == 0)
+    return false;
+  for (int i = 0; i < globals_num; i++) {
+    DescribeAddressRelativeToGlobal(addr, size, globals[i]);
+    if (0 == internal_strcmp(bug_type, "initialization-order-fiasco") &&
+        reg_sites[i]) {
+      Printf("  registered at:\n");
+      StackDepotGet(reg_sites[i]).Print();
+    }
+  }
+  return true;
+}
+
+bool DescribeAddressIfShadow(uptr addr, AddressDescription *descr, bool print) {
+  if (AddrIsInMem(addr))
+    return false;
+  const char *area_type = nullptr;
+  if (AddrIsInShadowGap(addr)) area_type = "shadow gap";
+  else if (AddrIsInHighShadow(addr)) area_type = "high shadow";
+  else if (AddrIsInLowShadow(addr)) area_type = "low shadow";
+  if (area_type != nullptr) {
+    if (print) {
+      Printf("Address %p is located in the %s area.\n", addr, area_type);
+    } else {
+      CHECK(descr);
+      descr->region_kind = area_type;
+    }
+    return true;
+  }
+  CHECK(0 && "Address is not in memory and not in shadow?");
+  return false;
+}
+
+// Return " (thread_name) " or an empty string if the name is empty.
+const char *ThreadNameWithParenthesis(AsanThreadContext *t, char buff[],
+                                      uptr buff_len) {
+  const char *name = t->name;
+  if (name[0] == '\0') return "";
+  buff[0] = 0;
+  internal_strncat(buff, " (", 3);
+  internal_strncat(buff, name, buff_len - 4);
+  internal_strncat(buff, ")", 2);
+  return buff;
+}
+
+const char *ThreadNameWithParenthesis(u32 tid, char buff[],
+                                      uptr buff_len) {
+  if (tid == kInvalidTid) return "";
+  asanThreadRegistry().CheckLocked();
+  AsanThreadContext *t = GetThreadContextByTidLocked(tid);
+  return ThreadNameWithParenthesis(t, buff, buff_len);
+}
+
+static void PrintAccessAndVarIntersection(const StackVarDescr &var, uptr addr,
+                                          uptr access_size, uptr prev_var_end,
+                                          uptr next_var_beg) {
+  uptr var_end = var.beg + var.size;
+  uptr addr_end = addr + access_size;
+  const char *pos_descr = nullptr;
+  // If the variable [var.beg, var_end) is the nearest variable to the
+  // current memory access, indicate it in the log.
+  if (addr >= var.beg) {
+    if (addr_end <= var_end)
+      pos_descr = "is inside";  // May happen if this is a use-after-return.
+    else if (addr < var_end)
+      pos_descr = "partially overflows";
+    else if (addr_end <= next_var_beg &&
+             next_var_beg - addr_end >= addr - var_end)
+      pos_descr = "overflows";
+  } else {
+    if (addr_end > var.beg)
+      pos_descr = "partially underflows";
+    else if (addr >= prev_var_end &&
+             addr - prev_var_end >= var.beg - addr_end)
+      pos_descr = "underflows";
+  }
+  InternalScopedString str(1024);
+  str.append("    [%zd, %zd)", var.beg, var_end);
+  // Render variable name.
+  str.append(" '");
+  for (uptr i = 0; i < var.name_len; ++i) {
+    str.append("%c", var.name_pos[i]);
+  }
+  str.append("'");
+  if (pos_descr) {
+    Decorator d;
+    // FIXME: we may want to also print the size of the access here,
+    // but in case of accesses generated by memset it may be confusing.
+    str.append("%s <== Memory access at offset %zd %s this variable%s\n",
+               d.Location(), addr, pos_descr, d.EndLocation());
+  } else {
+    str.append("\n");
+  }
+  Printf("%s", str.data());
+}
+
+bool ParseFrameDescription(const char *frame_descr,
+                           InternalMmapVector<StackVarDescr> *vars) {
+  CHECK(frame_descr);
+  char *p;
+  // This string is created by the compiler and has the following form:
+  // "n alloc_1 alloc_2 ... alloc_n"
+  // where alloc_i looks like "offset size len ObjectName".
+  uptr n_objects = (uptr)internal_simple_strtoll(frame_descr, &p, 10);
+  if (n_objects == 0)
+    return false;
+
+  for (uptr i = 0; i < n_objects; i++) {
+    uptr beg  = (uptr)internal_simple_strtoll(p, &p, 10);
+    uptr size = (uptr)internal_simple_strtoll(p, &p, 10);
+    uptr len  = (uptr)internal_simple_strtoll(p, &p, 10);
+    if (beg == 0 || size == 0 || *p != ' ') {
+      return false;
+    }
+    p++;
+    StackVarDescr var = {beg, size, p, len};
+    vars->push_back(var);
+    p += len;
+  }
+
+  return true;
+}
+
+bool DescribeAddressIfStack(uptr addr, uptr access_size) {
+  AsanThread *t = FindThreadByStackAddress(addr);
+  if (!t) return false;
+
+  Decorator d;
+  char tname[128];
+  Printf("%s", d.Location());
+  Printf("Address %p is located in stack of thread T%d%s", addr, t->tid(),
+         ThreadNameWithParenthesis(t->tid(), tname, sizeof(tname)));
+
+  // Try to fetch precise stack frame for this access.
+  AsanThread::StackFrameAccess access;
+  if (!t->GetStackFrameAccessByAddr(addr, &access)) {
+    Printf("%s\n", d.EndLocation());
+    return true;
+  }
+  Printf(" at offset %zu in frame%s\n", access.offset, d.EndLocation());
+
+  // Now we print the frame where the alloca has happened.
+  // We print this frame as a stack trace with one element.
+  // The symbolizer may print more than one frame if inlining was involved.
+  // The frame numbers may be different than those in the stack trace printed
+  // previously. That's unfortunate, but I have no better solution,
+  // especially given that the alloca may be from entirely different place
+  // (e.g. use-after-scope, or different thread's stack).
+#if defined(__powerpc64__) && defined(__BIG_ENDIAN__)
+  // On PowerPC64 ELFv1, the address of a function actually points to a
+  // three-doubleword data structure with the first field containing
+  // the address of the function's code.
+  access.frame_pc = *reinterpret_cast<uptr *>(access.frame_pc);
+#endif
+  access.frame_pc += 16;
+  Printf("%s", d.EndLocation());
+  StackTrace alloca_stack(&access.frame_pc, 1);
+  alloca_stack.Print();
+
+  InternalMmapVector<StackVarDescr> vars(16);
+  if (!ParseFrameDescription(access.frame_descr, &vars)) {
+    Printf("AddressSanitizer can't parse the stack frame "
+           "descriptor: |%s|\n", access.frame_descr);
+    // 'addr' is a stack address, so return true even if we can't parse frame
+    return true;
+  }
+  uptr n_objects = vars.size();
+  // Report the number of stack objects.
+  Printf("  This frame has %zu object(s):\n", n_objects);
+
+  // Report all objects in this frame.
+  for (uptr i = 0; i < n_objects; i++) {
+    uptr prev_var_end = i ? vars[i - 1].beg + vars[i - 1].size : 0;
+    uptr next_var_beg = i + 1 < n_objects ? vars[i + 1].beg : ~(0UL);
+    PrintAccessAndVarIntersection(vars[i], access.offset, access_size,
+                                  prev_var_end, next_var_beg);
+  }
+  Printf("HINT: this may be a false positive if your program uses "
+         "some custom stack unwind mechanism or swapcontext\n");
+  if (SANITIZER_WINDOWS)
+    Printf("      (longjmp, SEH and C++ exceptions *are* supported)\n");
+  else
+    Printf("      (longjmp and C++ exceptions *are* supported)\n");
+
+  DescribeThread(t);
+  return true;
+}
+
+static void DescribeAccessToHeapChunk(AsanChunkView chunk, uptr addr,
+                                      uptr access_size) {
+  sptr offset;
+  Decorator d;
+  InternalScopedString str(4096);
+  str.append("%s", d.Location());
+  if (chunk.AddrIsAtLeft(addr, access_size, &offset)) {
+    str.append("%p is located %zd bytes to the left of", (void *)addr, offset);
+  } else if (chunk.AddrIsAtRight(addr, access_size, &offset)) {
+    if (offset < 0) {
+      addr -= offset;
+      offset = 0;
+    }
+    str.append("%p is located %zd bytes to the right of", (void *)addr, offset);
+  } else if (chunk.AddrIsInside(addr, access_size, &offset)) {
+    str.append("%p is located %zd bytes inside of", (void*)addr, offset);
+  } else {
+    str.append("%p is located somewhere around (this is AddressSanitizer bug!)",
+               (void *)addr);
+  }
+  str.append(" %zu-byte region [%p,%p)\n", chunk.UsedSize(),
+             (void *)(chunk.Beg()), (void *)(chunk.End()));
+  str.append("%s", d.EndLocation());
+  Printf("%s", str.data());
+}
+
+void DescribeHeapAddress(uptr addr, uptr access_size) {
+  AsanChunkView chunk = FindHeapChunkByAddress(addr);
+  if (!chunk.IsValid()) {
+    Printf("AddressSanitizer can not describe address in more detail "
+           "(wild memory access suspected).\n");
+    return;
+  }
+  DescribeAccessToHeapChunk(chunk, addr, access_size);
+  CHECK(chunk.AllocTid() != kInvalidTid);
+  asanThreadRegistry().CheckLocked();
+  AsanThreadContext *alloc_thread =
+      GetThreadContextByTidLocked(chunk.AllocTid());
+  StackTrace alloc_stack = chunk.GetAllocStack();
+  char tname[128];
+  Decorator d;
+  AsanThreadContext *free_thread = nullptr;
+  if (chunk.FreeTid() != kInvalidTid) {
+    free_thread = GetThreadContextByTidLocked(chunk.FreeTid());
+    Printf("%sfreed by thread T%d%s here:%s\n", d.Allocation(),
+           free_thread->tid,
+           ThreadNameWithParenthesis(free_thread, tname, sizeof(tname)),
+           d.EndAllocation());
+    StackTrace free_stack = chunk.GetFreeStack();
+    free_stack.Print();
+    Printf("%spreviously allocated by thread T%d%s here:%s\n",
+           d.Allocation(), alloc_thread->tid,
+           ThreadNameWithParenthesis(alloc_thread, tname, sizeof(tname)),
+           d.EndAllocation());
+  } else {
+    Printf("%sallocated by thread T%d%s here:%s\n", d.Allocation(),
+           alloc_thread->tid,
+           ThreadNameWithParenthesis(alloc_thread, tname, sizeof(tname)),
+           d.EndAllocation());
+  }
+  alloc_stack.Print();
+  DescribeThread(GetCurrentThread());
+  if (free_thread)
+    DescribeThread(free_thread);
+  DescribeThread(alloc_thread);
+}
+
+static void DescribeAddress(uptr addr, uptr access_size, const char *bug_type) {
+  // Check if this is shadow or shadow gap.
+  if (DescribeAddressIfShadow(addr))
+    return;
+  CHECK(AddrIsInMem(addr));
+  if (DescribeAddressIfGlobal(addr, access_size, bug_type))
+    return;
+  if (DescribeAddressIfStack(addr, access_size))
+    return;
+  // Assume it is a heap address.
+  DescribeHeapAddress(addr, access_size);
+}
+
+// ------------------- Thread description -------------------- {{{1
+
+void DescribeThread(AsanThreadContext *context) {
+  CHECK(context);
+  asanThreadRegistry().CheckLocked();
+  // No need to announce the main thread.
+  if (context->tid == 0 || context->announced) {
+    return;
+  }
+  context->announced = true;
+  char tname[128];
+  InternalScopedString str(1024);
+  str.append("Thread T%d%s", context->tid,
+             ThreadNameWithParenthesis(context->tid, tname, sizeof(tname)));
+  if (context->parent_tid == kInvalidTid) {
+    str.append(" created by unknown thread\n");
+    Printf("%s", str.data());
+    return;
+  }
+  str.append(
+      " created by T%d%s here:\n", context->parent_tid,
+      ThreadNameWithParenthesis(context->parent_tid, tname, sizeof(tname)));
+  Printf("%s", str.data());
+  StackDepotGet(context->stack_id).Print();
+  // Recursively described parent thread if needed.
+  if (flags()->print_full_thread_history) {
+    AsanThreadContext *parent_context =
+        GetThreadContextByTidLocked(context->parent_tid);
+    DescribeThread(parent_context);
+  }
+}
+
+// -------------------- Different kinds of reports ----------------- {{{1
+
+// Use ScopedInErrorReport to run common actions just before and
+// immediately after printing error report.
+class ScopedInErrorReport {
+ public:
+  explicit ScopedInErrorReport(ReportData *report = nullptr,
+                               bool fatal = false) {
+    halt_on_error_ = fatal || flags()->halt_on_error;
+
+    if (lock_.TryLock()) {
+      StartReporting(report);
+      return;
+    }
+
+    // ASan found two bugs in different threads simultaneously.
+
+    u32 current_tid = GetCurrentTidOrInvalid();
+    if (reporting_thread_tid_ == current_tid ||
+        reporting_thread_tid_ == kInvalidTid) {
+      // This is either asynch signal or nested error during error reporting.
+      // Fail simple to avoid deadlocks in Report().
+
+      // Can't use Report() here because of potential deadlocks
+      // in nested signal handlers.
+      const char msg[] = "AddressSanitizer: nested bug in the same thread, "
+                         "aborting.\n";
+      WriteToFile(kStderrFd, msg, sizeof(msg));
+
+      internal__exit(common_flags()->exitcode);
+    }
+
+    if (halt_on_error_) {
+      // Do not print more than one report, otherwise they will mix up.
+      // Error reporting functions shouldn't return at this situation, as
+      // they are effectively no-returns.
+
+      Report("AddressSanitizer: while reporting a bug found another one. "
+             "Ignoring.\n");
+
+      // Sleep long enough to make sure that the thread which started
+      // to print an error report will finish doing it.
+      SleepForSeconds(Max(100, flags()->sleep_before_dying + 1));
+
+      // If we're still not dead for some reason, use raw _exit() instead of
+      // Die() to bypass any additional checks.
+      internal__exit(common_flags()->exitcode);
+    } else {
+      // The other thread will eventually finish reporting
+      // so it's safe to wait
+      lock_.Lock();
+    }
+
+    StartReporting(report);
+  }
+
+  ~ScopedInErrorReport() {
+    // Make sure the current thread is announced.
+    DescribeThread(GetCurrentThread());
+    // We may want to grab this lock again when printing stats.
+    asanThreadRegistry().Unlock();
+    // Print memory stats.
+    if (flags()->print_stats)
+      __asan_print_accumulated_stats();
+
+    // Copy the message buffer so that we could start logging without holding a
+    // lock that gets aquired during printing.
+    InternalScopedBuffer<char> buffer_copy(kErrorMessageBufferSize);
+    {
+      BlockingMutexLock l(&error_message_buf_mutex);
+      internal_memcpy(buffer_copy.data(),
+                      error_message_buffer, kErrorMessageBufferSize);
+    }
+
+    // Remove color sequences since logs cannot print them.
+    RemoveANSIEscapeSequencesFromString(buffer_copy.data());
+
+    LogFullErrorReport(buffer_copy.data());
+
+    if (error_report_callback) {
+      error_report_callback(buffer_copy.data());
+    }
+    CommonSanitizerReportMutex.Unlock();
+    reporting_thread_tid_ = kInvalidTid;
+    lock_.Unlock();
+    if (halt_on_error_) {
+      Report("ABORTING\n");
+      Die();
+    }
+  }
+
+ private:
+  void StartReporting(ReportData *report) {
+    if (report) report_data = *report;
+    report_happened = true;
+    ASAN_ON_ERROR();
+    // Make sure the registry and sanitizer report mutexes are locked while
+    // we're printing an error report.
+    // We can lock them only here to avoid self-deadlock in case of
+    // recursive reports.
+    asanThreadRegistry().Lock();
+    CommonSanitizerReportMutex.Lock();
+    reporting_thread_tid_ = GetCurrentTidOrInvalid();
+    Printf("===================================================="
+           "=============\n");
+  }
+
+  static StaticSpinMutex lock_;
+  static u32 reporting_thread_tid_;
+  bool halt_on_error_;
+};
+
+StaticSpinMutex ScopedInErrorReport::lock_;
+u32 ScopedInErrorReport::reporting_thread_tid_;
+
+void ReportStackOverflow(const SignalContext &sig) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report(
+      "ERROR: AddressSanitizer: stack-overflow on address %p"
+      " (pc %p bp %p sp %p T%d)\n",
+      (void *)sig.addr, (void *)sig.pc, (void *)sig.bp, (void *)sig.sp,
+      GetCurrentTidOrInvalid());
+  Printf("%s", d.EndWarning());
+  GET_STACK_TRACE_SIGNAL(sig);
+  stack.Print();
+  ReportErrorSummary("stack-overflow", &stack);
+}
+
+void ReportDeadlySignal(const char *description, const SignalContext &sig) {
+  ScopedInErrorReport in_report(/*report*/nullptr, /*fatal*/true);
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report(
+      "ERROR: AddressSanitizer: %s on unknown address %p"
+      " (pc %p bp %p sp %p T%d)\n",
+      description, (void *)sig.addr, (void *)sig.pc, (void *)sig.bp,
+      (void *)sig.sp, GetCurrentTidOrInvalid());
+  if (sig.pc < GetPageSizeCached()) {
+    Report("Hint: pc points to the zero page.\n");
+  }
+  Printf("%s", d.EndWarning());
+  GET_STACK_TRACE_SIGNAL(sig);
+  stack.Print();
+  MaybeDumpInstructionBytes(sig.pc);
+  Printf("AddressSanitizer can not provide additional info.\n");
+  ReportErrorSummary(description, &stack);
+}
+
+void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  char tname[128];
+  u32 curr_tid = GetCurrentTidOrInvalid();
+  Report("ERROR: AddressSanitizer: attempting double-free on %p in "
+         "thread T%d%s:\n",
+         addr, curr_tid,
+         ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)));
+  Printf("%s", d.EndWarning());
+  CHECK_GT(free_stack->size, 0);
+  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
+  stack.Print();
+  DescribeHeapAddress(addr, 1);
+  ReportErrorSummary("double-free", &stack);
+}
+
+void ReportNewDeleteSizeMismatch(uptr addr, uptr delete_size,
+                                 BufferedStackTrace *free_stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  char tname[128];
+  u32 curr_tid = GetCurrentTidOrInvalid();
+  Report("ERROR: AddressSanitizer: new-delete-type-mismatch on %p in "
+         "thread T%d%s:\n",
+         addr, curr_tid,
+         ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)));
+  Printf("%s  object passed to delete has wrong type:\n", d.EndWarning());
+  Printf("  size of the allocated type:   %zd bytes;\n"
+         "  size of the deallocated type: %zd bytes.\n",
+         asan_mz_size(reinterpret_cast<void*>(addr)), delete_size);
+  CHECK_GT(free_stack->size, 0);
+  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
+  stack.Print();
+  DescribeHeapAddress(addr, 1);
+  ReportErrorSummary("new-delete-type-mismatch", &stack);
+  Report("HINT: if you don't care about these errors you may set "
+         "ASAN_OPTIONS=new_delete_type_mismatch=0\n");
+}
+
+void ReportFreeNotMalloced(uptr addr, BufferedStackTrace *free_stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  char tname[128];
+  u32 curr_tid = GetCurrentTidOrInvalid();
+  Report("ERROR: AddressSanitizer: attempting free on address "
+             "which was not malloc()-ed: %p in thread T%d%s\n", addr,
+         curr_tid, ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)));
+  Printf("%s", d.EndWarning());
+  CHECK_GT(free_stack->size, 0);
+  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
+  stack.Print();
+  DescribeHeapAddress(addr, 1);
+  ReportErrorSummary("bad-free", &stack);
+}
+
+void ReportAllocTypeMismatch(uptr addr, BufferedStackTrace *free_stack,
+                             AllocType alloc_type,
+                             AllocType dealloc_type) {
+  static const char *alloc_names[] =
+    {"INVALID", "malloc", "operator new", "operator new []"};
+  static const char *dealloc_names[] =
+    {"INVALID", "free", "operator delete", "operator delete []"};
+  CHECK_NE(alloc_type, dealloc_type);
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: alloc-dealloc-mismatch (%s vs %s) on %p\n",
+        alloc_names[alloc_type], dealloc_names[dealloc_type], addr);
+  Printf("%s", d.EndWarning());
+  CHECK_GT(free_stack->size, 0);
+  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
+  stack.Print();
+  DescribeHeapAddress(addr, 1);
+  ReportErrorSummary("alloc-dealloc-mismatch", &stack);
+  Report("HINT: if you don't care about these errors you may set "
+         "ASAN_OPTIONS=alloc_dealloc_mismatch=0\n");
+}
+
+void ReportMallocUsableSizeNotOwned(uptr addr, BufferedStackTrace *stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: attempting to call "
+             "malloc_usable_size() for pointer which is "
+             "not owned: %p\n", addr);
+  Printf("%s", d.EndWarning());
+  stack->Print();
+  DescribeHeapAddress(addr, 1);
+  ReportErrorSummary("bad-malloc_usable_size", stack);
+}
+
+void ReportSanitizerGetAllocatedSizeNotOwned(uptr addr,
+                                             BufferedStackTrace *stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: attempting to call "
+             "__sanitizer_get_allocated_size() for pointer which is "
+             "not owned: %p\n", addr);
+  Printf("%s", d.EndWarning());
+  stack->Print();
+  DescribeHeapAddress(addr, 1);
+  ReportErrorSummary("bad-__sanitizer_get_allocated_size", stack);
+}
+
+void ReportStringFunctionMemoryRangesOverlap(const char *function,
+                                             const char *offset1, uptr length1,
+                                             const char *offset2, uptr length2,
+                                             BufferedStackTrace *stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  char bug_type[100];
+  internal_snprintf(bug_type, sizeof(bug_type), "%s-param-overlap", function);
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: %s: "
+             "memory ranges [%p,%p) and [%p, %p) overlap\n", \
+             bug_type, offset1, offset1 + length1, offset2, offset2 + length2);
+  Printf("%s", d.EndWarning());
+  stack->Print();
+  DescribeAddress((uptr)offset1, length1, bug_type);
+  DescribeAddress((uptr)offset2, length2, bug_type);
+  ReportErrorSummary(bug_type, stack);
+}
+
+void ReportStringFunctionSizeOverflow(uptr offset, uptr size,
+                                      BufferedStackTrace *stack) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  const char *bug_type = "negative-size-param";
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: %s: (size=%zd)\n", bug_type, size);
+  Printf("%s", d.EndWarning());
+  stack->Print();
+  DescribeAddress(offset, size, bug_type);
+  ReportErrorSummary(bug_type, stack);
+}
+
+void ReportBadParamsToAnnotateContiguousContainer(uptr beg, uptr end,
+                                                  uptr old_mid, uptr new_mid,
+                                                  BufferedStackTrace *stack) {
+  ScopedInErrorReport in_report;
+  Report("ERROR: AddressSanitizer: bad parameters to "
+         "__sanitizer_annotate_contiguous_container:\n"
+         "      beg     : %p\n"
+         "      end     : %p\n"
+         "      old_mid : %p\n"
+         "      new_mid : %p\n",
+         beg, end, old_mid, new_mid);
+  uptr granularity = SHADOW_GRANULARITY;
+  if (!IsAligned(beg, granularity))
+    Report("ERROR: beg is not aligned by %d\n", granularity);
+  stack->Print();
+  ReportErrorSummary("bad-__sanitizer_annotate_contiguous_container", stack);
+}
+
+void ReportODRViolation(const __asan_global *g1, u32 stack_id1,
+                        const __asan_global *g2, u32 stack_id2) {
+  ScopedInErrorReport in_report;
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: odr-violation (%p):\n", g1->beg);
+  Printf("%s", d.EndWarning());
+  InternalScopedString g1_loc(256), g2_loc(256);
+  PrintGlobalLocation(&g1_loc, *g1);
+  PrintGlobalLocation(&g2_loc, *g2);
+  Printf("  [1] size=%zd '%s' %s\n", g1->size,
+         MaybeDemangleGlobalName(g1->name), g1_loc.data());
+  Printf("  [2] size=%zd '%s' %s\n", g2->size,
+         MaybeDemangleGlobalName(g2->name), g2_loc.data());
+  if (stack_id1 && stack_id2) {
+    Printf("These globals were registered at these points:\n");
+    Printf("  [1]:\n");
+    StackDepotGet(stack_id1).Print();
+    Printf("  [2]:\n");
+    StackDepotGet(stack_id2).Print();
+  }
+  Report("HINT: if you don't care about these errors you may set "
+         "ASAN_OPTIONS=detect_odr_violation=0\n");
+  InternalScopedString error_msg(256);
+  error_msg.append("odr-violation: global '%s' at %s",
+                   MaybeDemangleGlobalName(g1->name), g1_loc.data());
+  ReportErrorSummary(error_msg.data());
+}
+
+// ----------------------- CheckForInvalidPointerPair ----------- {{{1
+static NOINLINE void
+ReportInvalidPointerPair(uptr pc, uptr bp, uptr sp, uptr a1, uptr a2) {
+  ScopedInErrorReport in_report;
+  const char *bug_type = "invalid-pointer-pair";
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: invalid-pointer-pair: %p %p\n", a1, a2);
+  Printf("%s", d.EndWarning());
+  GET_STACK_TRACE_FATAL(pc, bp);
+  stack.Print();
+  DescribeAddress(a1, 1, bug_type);
+  DescribeAddress(a2, 1, bug_type);
+  ReportErrorSummary(bug_type, &stack);
+}
+
+static INLINE void CheckForInvalidPointerPair(void *p1, void *p2) {
+  if (!flags()->detect_invalid_pointer_pairs) return;
+  uptr a1 = reinterpret_cast<uptr>(p1);
+  uptr a2 = reinterpret_cast<uptr>(p2);
+  AsanChunkView chunk1 = FindHeapChunkByAddress(a1);
+  AsanChunkView chunk2 = FindHeapChunkByAddress(a2);
+  bool valid1 = chunk1.IsValid();
+  bool valid2 = chunk2.IsValid();
+  if ((valid1 != valid2) || (valid1 && valid2 && !chunk1.Eq(chunk2))) {
+    GET_CALLER_PC_BP_SP;                                              \
+    return ReportInvalidPointerPair(pc, bp, sp, a1, a2);
+  }
+}
+// ----------------------- Mac-specific reports ----------------- {{{1
+
+void ReportMacMzReallocUnknown(uptr addr, uptr zone_ptr, const char *zone_name,
+                               BufferedStackTrace *stack) {
+  ScopedInErrorReport in_report;
+  Printf("mz_realloc(%p) -- attempting to realloc unallocated memory.\n"
+             "This is an unrecoverable problem, exiting now.\n",
+             addr);
+  PrintZoneForPointer(addr, zone_ptr, zone_name);
+  stack->Print();
+  DescribeHeapAddress(addr, 1);
+}
+
+// -------------- SuppressErrorReport -------------- {{{1
+// Avoid error reports duplicating for ASan recover mode.
+static bool SuppressErrorReport(uptr pc) {
+  if (!common_flags()->suppress_equal_pcs) return false;
+  for (unsigned i = 0; i < kAsanBuggyPcPoolSize; i++) {
+    uptr cmp = atomic_load_relaxed(&AsanBuggyPcPool[i]);
+    if (cmp == 0 && atomic_compare_exchange_strong(&AsanBuggyPcPool[i], &cmp,
+                                                   pc, memory_order_relaxed))
+      return false;
+    if (cmp == pc) return true;
+  }
+  Die();
+}
+
+void ReportGenericError(uptr pc, uptr bp, uptr sp, uptr addr, bool is_write,
+                        uptr access_size, u32 exp, bool fatal) {
+  if (!fatal && SuppressErrorReport(pc)) return;
+  ENABLE_FRAME_POINTER;
+
+  // Optimization experiments.
+  // The experiments can be used to evaluate potential optimizations that remove
+  // instrumentation (assess false negatives). Instead of completely removing
+  // some instrumentation, compiler can emit special calls into runtime
+  // (e.g. __asan_report_exp_load1 instead of __asan_report_load1) and pass
+  // mask of experiments (exp).
+  // The reaction to a non-zero value of exp is to be defined.
+  (void)exp;
+
+  // Determine the error type.
+  const char *bug_descr = "unknown-crash";
+  if (AddrIsInMem(addr)) {
+    u8 *shadow_addr = (u8*)MemToShadow(addr);
+    // If we are accessing 16 bytes, look at the second shadow byte.
+    if (*shadow_addr == 0 && access_size > SHADOW_GRANULARITY)
+      shadow_addr++;
+    // If we are in the partial right redzone, look at the next shadow byte.
+    if (*shadow_addr > 0 && *shadow_addr < 128)
+      shadow_addr++;
+    switch (*shadow_addr) {
+      case kAsanHeapLeftRedzoneMagic:
+      case kAsanHeapRightRedzoneMagic:
+      case kAsanArrayCookieMagic:
+        bug_descr = "heap-buffer-overflow";
+        break;
+      case kAsanHeapFreeMagic:
+        bug_descr = "heap-use-after-free";
+        break;
+      case kAsanStackLeftRedzoneMagic:
+        bug_descr = "stack-buffer-underflow";
+        break;
+      case kAsanInitializationOrderMagic:
+        bug_descr = "initialization-order-fiasco";
+        break;
+      case kAsanStackMidRedzoneMagic:
+      case kAsanStackRightRedzoneMagic:
+      case kAsanStackPartialRedzoneMagic:
+        bug_descr = "stack-buffer-overflow";
+        break;
+      case kAsanStackAfterReturnMagic:
+        bug_descr = "stack-use-after-return";
+        break;
+      case kAsanUserPoisonedMemoryMagic:
+        bug_descr = "use-after-poison";
+        break;
+      case kAsanContiguousContainerOOBMagic:
+        bug_descr = "container-overflow";
+        break;
+      case kAsanStackUseAfterScopeMagic:
+        bug_descr = "stack-use-after-scope";
+        break;
+      case kAsanGlobalRedzoneMagic:
+        bug_descr = "global-buffer-overflow";
+        break;
+      case kAsanIntraObjectRedzone:
+        bug_descr = "intra-object-overflow";
+        break;
+      case kAsanAllocaLeftMagic:
+      case kAsanAllocaRightMagic:
+        bug_descr = "dynamic-stack-buffer-overflow";
+        break;
+    }
+  }
+
+  ReportData report = { pc, sp, bp, addr, (bool)is_write, access_size,
+                        bug_descr };
+  ScopedInErrorReport in_report(&report, fatal);
+
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("ERROR: AddressSanitizer: %s on address "
+             "%p at pc %p bp %p sp %p\n",
+             bug_descr, (void*)addr, pc, bp, sp);
+  Printf("%s", d.EndWarning());
+
+  u32 curr_tid = GetCurrentTidOrInvalid();
+  char tname[128];
+  Printf("%s%s of size %zu at %p thread T%d%s%s\n",
+         d.Access(),
+         access_size ? (is_write ? "WRITE" : "READ") : "ACCESS",
+         access_size, (void*)addr, curr_tid,
+         ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)),
+         d.EndAccess());
+
+  GET_STACK_TRACE_FATAL(pc, bp);
+  stack.Print();
+
+  DescribeAddress(addr, access_size, bug_descr);
+  ReportErrorSummary(bug_descr, &stack);
+  PrintShadowMemoryForAddress(addr);
+}
+
+}  // namespace __asan
+
+// --------------------------- Interface --------------------- {{{1
+using namespace __asan;  // NOLINT
+
+void __asan_report_error(uptr pc, uptr bp, uptr sp, uptr addr, int is_write,
+                         uptr access_size, u32 exp) {
+  ENABLE_FRAME_POINTER;
+  bool fatal = flags()->halt_on_error;
+  ReportGenericError(pc, bp, sp, addr, is_write, access_size, exp, fatal);
+}
+
+void NOINLINE __asan_set_error_report_callback(void (*callback)(const char*)) {
+  BlockingMutexLock l(&error_message_buf_mutex);
+  error_report_callback = callback;
+}
+
+void __asan_describe_address(uptr addr) {
+  // Thread registry must be locked while we're describing an address.
+  asanThreadRegistry().Lock();
+  DescribeAddress(addr, 1, "");
+  asanThreadRegistry().Unlock();
+}
+
+int __asan_report_present() {
+  return report_happened ? 1 : 0;
+}
+
+uptr __asan_get_report_pc() {
+  return report_data.pc;
+}
+
+uptr __asan_get_report_bp() {
+  return report_data.bp;
+}
+
+uptr __asan_get_report_sp() {
+  return report_data.sp;
+}
+
+uptr __asan_get_report_address() {
+  return report_data.addr;
+}
+
+int __asan_get_report_access_type() {
+  return report_data.is_write ? 1 : 0;
+}
+
+uptr __asan_get_report_access_size() {
+  return report_data.access_size;
+}
+
+const char *__asan_get_report_description() {
+  return report_data.description;
+}
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_ptr_sub(void *a, void *b) {
+  CheckForInvalidPointerPair(a, b);
+}
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_ptr_cmp(void *a, void *b) {
+  CheckForInvalidPointerPair(a, b);
+}
+} // extern "C"
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
+// Provide default implementation of __asan_on_error that does nothing
+// and may be overriden by user.
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE
+void __asan_on_error() {}
+#endif
diff --git a/compiler-rt/lib/asan/asan_report.h b/compiler-rt/lib/asan/asan_report.h
new file mode 100644
index 0000000..559b8ad
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_report.h
@@ -0,0 +1,87 @@
+//===-- asan_report.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for error reporting functions.
+//===----------------------------------------------------------------------===//
+
+#include "asan_allocator.h"
+#include "asan_internal.h"
+#include "asan_thread.h"
+
+namespace __asan {
+
+struct StackVarDescr {
+  uptr beg;
+  uptr size;
+  const char *name_pos;
+  uptr name_len;
+};
+
+struct AddressDescription {
+  char *name;
+  uptr name_size;
+  uptr region_address;
+  uptr region_size;
+  const char *region_kind;
+};
+
+// Returns the number of globals close to the provided address and copies
+// them to "globals" array.
+int GetGlobalsForAddress(uptr addr, __asan_global *globals, u32 *reg_sites,
+                         int max_globals);
+bool GetInfoForAddressIfGlobal(uptr addr, AddressDescription *descr);
+// The following functions prints address description depending
+// on the memory type (shadow/heap/stack/global).
+void DescribeHeapAddress(uptr addr, uptr access_size);
+bool DescribeAddressIfShadow(uptr addr, AddressDescription *descr = nullptr,
+                             bool print = true);
+bool ParseFrameDescription(const char *frame_descr,
+                           InternalMmapVector<StackVarDescr> *vars);
+bool DescribeAddressIfStack(uptr addr, uptr access_size);
+void DescribeThread(AsanThreadContext *context);
+
+// Different kinds of error reports.
+void ReportGenericError(uptr pc, uptr bp, uptr sp, uptr addr, bool is_write,
+                        uptr access_size, u32 exp, bool fatal);
+void ReportStackOverflow(const SignalContext &sig);
+void ReportDeadlySignal(const char *description, const SignalContext &sig);
+void ReportNewDeleteSizeMismatch(uptr addr, uptr delete_size,
+                                 BufferedStackTrace *free_stack);
+void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack);
+void ReportFreeNotMalloced(uptr addr, BufferedStackTrace *free_stack);
+void ReportAllocTypeMismatch(uptr addr, BufferedStackTrace *free_stack,
+                             AllocType alloc_type,
+                             AllocType dealloc_type);
+void ReportMallocUsableSizeNotOwned(uptr addr, BufferedStackTrace *stack);
+void ReportSanitizerGetAllocatedSizeNotOwned(uptr addr,
+                                             BufferedStackTrace *stack);
+void ReportStringFunctionMemoryRangesOverlap(const char *function,
+                                             const char *offset1, uptr length1,
+                                             const char *offset2, uptr length2,
+                                             BufferedStackTrace *stack);
+void ReportStringFunctionSizeOverflow(uptr offset, uptr size,
+                                      BufferedStackTrace *stack);
+void ReportBadParamsToAnnotateContiguousContainer(uptr beg, uptr end,
+                                                  uptr old_mid, uptr new_mid,
+                                                  BufferedStackTrace *stack);
+
+void ReportODRViolation(const __asan_global *g1, u32 stack_id1,
+                        const __asan_global *g2, u32 stack_id2);
+
+// Mac-specific errors and warnings.
+void ReportMacMzReallocUnknown(uptr addr, uptr zone_ptr,
+                               const char *zone_name,
+                               BufferedStackTrace *stack);
+void ReportMacCfReallocUnknown(uptr addr, uptr zone_ptr,
+                               const char *zone_name,
+                               BufferedStackTrace *stack);
+
+}  // namespace __asan
diff --git a/compiler-rt/lib/asan/asan_rtl.cc b/compiler-rt/lib/asan/asan_rtl.cc
new file mode 100644
index 0000000..7b8b5dd
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_rtl.cc
@@ -0,0 +1,630 @@
+//===-- asan_rtl.cc -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Main file of the ASan run-time library.
+//===----------------------------------------------------------------------===//
+
+#include "asan_activation.h"
+#include "asan_allocator.h"
+#include "asan_interceptors.h"
+#include "asan_interface_internal.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_poisoning.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_stats.h"
+#include "asan_suppressions.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+#include "lsan/lsan_common.h"
+#include "ubsan/ubsan_init.h"
+#include "ubsan/ubsan_platform.h"
+
+int __asan_option_detect_stack_use_after_return;  // Global interface symbol.
+uptr *__asan_test_only_reported_buggy_pointer;  // Used only for testing asan.
+
+namespace __asan {
+
+uptr AsanMappingProfile[kAsanMappingProfileSize];
+
+static void AsanDie() {
+  static atomic_uint32_t num_calls;
+  if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) != 0) {
+    // Don't die twice - run a busy loop.
+    while (1) { }
+  }
+  if (flags()->sleep_before_dying) {
+    Report("Sleeping for %d second(s)\n", flags()->sleep_before_dying);
+    SleepForSeconds(flags()->sleep_before_dying);
+  }
+  if (flags()->unmap_shadow_on_exit) {
+    if (kMidMemBeg) {
+      UnmapOrDie((void*)kLowShadowBeg, kMidMemBeg - kLowShadowBeg);
+      UnmapOrDie((void*)kMidMemEnd, kHighShadowEnd - kMidMemEnd);
+    } else {
+      UnmapOrDie((void*)kLowShadowBeg, kHighShadowEnd - kLowShadowBeg);
+    }
+  }
+}
+
+static void AsanCheckFailed(const char *file, int line, const char *cond,
+                            u64 v1, u64 v2) {
+  Report("AddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
+         line, cond, (uptr)v1, (uptr)v2);
+  // FIXME: check for infinite recursion without a thread-local counter here.
+  PRINT_CURRENT_STACK_CHECK();
+  Die();
+}
+
+// -------------------------- Globals --------------------- {{{1
+int asan_inited;
+bool asan_init_is_running;
+
+#if !ASAN_FIXED_MAPPING
+uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;
+#endif
+
+// -------------------------- Misc ---------------- {{{1
+void ShowStatsAndAbort() {
+  __asan_print_accumulated_stats();
+  Die();
+}
+
+// ---------------------- mmap -------------------- {{{1
+// Reserve memory range [beg, end].
+// We need to use inclusive range because end+1 may not be representable.
+void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name) {
+  CHECK_EQ((beg % GetPageSizeCached()), 0);
+  CHECK_EQ(((end + 1) % GetPageSizeCached()), 0);
+  uptr size = end - beg + 1;
+  DecreaseTotalMmap(size);  // Don't count the shadow against mmap_limit_mb.
+  void *res = MmapFixedNoReserve(beg, size, name);
+  if (res != (void*)beg) {
+    Report("ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. "
+           "Perhaps you're using ulimit -v\n", size);
+    Abort();
+  }
+  if (common_flags()->no_huge_pages_for_shadow)
+    NoHugePagesInRegion(beg, size);
+  if (common_flags()->use_madv_dontdump)
+    DontDumpShadowMemory(beg, size);
+}
+
+// --------------- LowLevelAllocateCallbac ---------- {{{1
+static void OnLowLevelAllocate(uptr ptr, uptr size) {
+  PoisonShadow(ptr, size, kAsanInternalHeapMagic);
+}
+
+// -------------------------- Run-time entry ------------------- {{{1
+// exported functions
+#define ASAN_REPORT_ERROR(type, is_write, size)                     \
+extern "C" NOINLINE INTERFACE_ATTRIBUTE                             \
+void __asan_report_ ## type ## size(uptr addr) {                    \
+  GET_CALLER_PC_BP_SP;                                              \
+  ReportGenericError(pc, bp, sp, addr, is_write, size, 0, true);    \
+}                                                                   \
+extern "C" NOINLINE INTERFACE_ATTRIBUTE                             \
+void __asan_report_exp_ ## type ## size(uptr addr, u32 exp) {       \
+  GET_CALLER_PC_BP_SP;                                              \
+  ReportGenericError(pc, bp, sp, addr, is_write, size, exp, true);  \
+}                                                                   \
+extern "C" NOINLINE INTERFACE_ATTRIBUTE                             \
+void __asan_report_ ## type ## size ## _noabort(uptr addr) {        \
+  GET_CALLER_PC_BP_SP;                                              \
+  ReportGenericError(pc, bp, sp, addr, is_write, size, 0, false);   \
+}                                                                   \
+
+ASAN_REPORT_ERROR(load, false, 1)
+ASAN_REPORT_ERROR(load, false, 2)
+ASAN_REPORT_ERROR(load, false, 4)
+ASAN_REPORT_ERROR(load, false, 8)
+ASAN_REPORT_ERROR(load, false, 16)
+ASAN_REPORT_ERROR(store, true, 1)
+ASAN_REPORT_ERROR(store, true, 2)
+ASAN_REPORT_ERROR(store, true, 4)
+ASAN_REPORT_ERROR(store, true, 8)
+ASAN_REPORT_ERROR(store, true, 16)
+
+#define ASAN_REPORT_ERROR_N(type, is_write)                                 \
+extern "C" NOINLINE INTERFACE_ATTRIBUTE                                     \
+void __asan_report_ ## type ## _n(uptr addr, uptr size) {                   \
+  GET_CALLER_PC_BP_SP;                                                      \
+  ReportGenericError(pc, bp, sp, addr, is_write, size, 0, true);            \
+}                                                                           \
+extern "C" NOINLINE INTERFACE_ATTRIBUTE                                     \
+void __asan_report_exp_ ## type ## _n(uptr addr, uptr size, u32 exp) {      \
+  GET_CALLER_PC_BP_SP;                                                      \
+  ReportGenericError(pc, bp, sp, addr, is_write, size, exp, true);          \
+}                                                                           \
+extern "C" NOINLINE INTERFACE_ATTRIBUTE                                     \
+void __asan_report_ ## type ## _n_noabort(uptr addr, uptr size) {           \
+  GET_CALLER_PC_BP_SP;                                                      \
+  ReportGenericError(pc, bp, sp, addr, is_write, size, 0, false);           \
+}                                                                           \
+
+ASAN_REPORT_ERROR_N(load, false)
+ASAN_REPORT_ERROR_N(store, true)
+
+#define ASAN_MEMORY_ACCESS_CALLBACK_BODY(type, is_write, size, exp_arg, fatal) \
+    uptr sp = MEM_TO_SHADOW(addr);                                             \
+    uptr s = size <= SHADOW_GRANULARITY ? *reinterpret_cast<u8 *>(sp)          \
+                                        : *reinterpret_cast<u16 *>(sp);        \
+    if (UNLIKELY(s)) {                                                         \
+      if (UNLIKELY(size >= SHADOW_GRANULARITY ||                               \
+                   ((s8)((addr & (SHADOW_GRANULARITY - 1)) + size - 1)) >=     \
+                       (s8)s)) {                                               \
+        if (__asan_test_only_reported_buggy_pointer) {                         \
+          *__asan_test_only_reported_buggy_pointer = addr;                     \
+        } else {                                                               \
+          GET_CALLER_PC_BP_SP;                                                 \
+          ReportGenericError(pc, bp, sp, addr, is_write, size, exp_arg,        \
+                              fatal);                                          \
+        }                                                                      \
+      }                                                                        \
+    }
+
+#define ASAN_MEMORY_ACCESS_CALLBACK(type, is_write, size)                      \
+  extern "C" NOINLINE INTERFACE_ATTRIBUTE                                      \
+  void __asan_##type##size(uptr addr) {                                        \
+    ASAN_MEMORY_ACCESS_CALLBACK_BODY(type, is_write, size, 0, true)            \
+  }                                                                            \
+  extern "C" NOINLINE INTERFACE_ATTRIBUTE                                      \
+  void __asan_exp_##type##size(uptr addr, u32 exp) {                           \
+    ASAN_MEMORY_ACCESS_CALLBACK_BODY(type, is_write, size, exp, true)          \
+  }                                                                            \
+  extern "C" NOINLINE INTERFACE_ATTRIBUTE                                      \
+  void __asan_##type##size ## _noabort(uptr addr) {                            \
+    ASAN_MEMORY_ACCESS_CALLBACK_BODY(type, is_write, size, 0, false)           \
+  }                                                                            \
+
+ASAN_MEMORY_ACCESS_CALLBACK(load, false, 1)
+ASAN_MEMORY_ACCESS_CALLBACK(load, false, 2)
+ASAN_MEMORY_ACCESS_CALLBACK(load, false, 4)
+ASAN_MEMORY_ACCESS_CALLBACK(load, false, 8)
+ASAN_MEMORY_ACCESS_CALLBACK(load, false, 16)
+ASAN_MEMORY_ACCESS_CALLBACK(store, true, 1)
+ASAN_MEMORY_ACCESS_CALLBACK(store, true, 2)
+ASAN_MEMORY_ACCESS_CALLBACK(store, true, 4)
+ASAN_MEMORY_ACCESS_CALLBACK(store, true, 8)
+ASAN_MEMORY_ACCESS_CALLBACK(store, true, 16)
+
+extern "C"
+NOINLINE INTERFACE_ATTRIBUTE
+void __asan_loadN(uptr addr, uptr size) {
+  if (__asan_region_is_poisoned(addr, size)) {
+    GET_CALLER_PC_BP_SP;
+    ReportGenericError(pc, bp, sp, addr, false, size, 0, true);
+  }
+}
+
+extern "C"
+NOINLINE INTERFACE_ATTRIBUTE
+void __asan_exp_loadN(uptr addr, uptr size, u32 exp) {
+  if (__asan_region_is_poisoned(addr, size)) {
+    GET_CALLER_PC_BP_SP;
+    ReportGenericError(pc, bp, sp, addr, false, size, exp, true);
+  }
+}
+
+extern "C"
+NOINLINE INTERFACE_ATTRIBUTE
+void __asan_loadN_noabort(uptr addr, uptr size) {
+  if (__asan_region_is_poisoned(addr, size)) {
+    GET_CALLER_PC_BP_SP;
+    ReportGenericError(pc, bp, sp, addr, false, size, 0, false);
+  }
+}
+
+extern "C"
+NOINLINE INTERFACE_ATTRIBUTE
+void __asan_storeN(uptr addr, uptr size) {
+  if (__asan_region_is_poisoned(addr, size)) {
+    GET_CALLER_PC_BP_SP;
+    ReportGenericError(pc, bp, sp, addr, true, size, 0, true);
+  }
+}
+
+extern "C"
+NOINLINE INTERFACE_ATTRIBUTE
+void __asan_exp_storeN(uptr addr, uptr size, u32 exp) {
+  if (__asan_region_is_poisoned(addr, size)) {
+    GET_CALLER_PC_BP_SP;
+    ReportGenericError(pc, bp, sp, addr, true, size, exp, true);
+  }
+}
+
+extern "C"
+NOINLINE INTERFACE_ATTRIBUTE
+void __asan_storeN_noabort(uptr addr, uptr size) {
+  if (__asan_region_is_poisoned(addr, size)) {
+    GET_CALLER_PC_BP_SP;
+    ReportGenericError(pc, bp, sp, addr, true, size, 0, false);
+  }
+}
+
+// Force the linker to keep the symbols for various ASan interface functions.
+// We want to keep those in the executable in order to let the instrumented
+// dynamic libraries access the symbol even if it is not used by the executable
+// itself. This should help if the build system is removing dead code at link
+// time.
+static NOINLINE void force_interface_symbols() {
+  volatile int fake_condition = 0;  // prevent dead condition elimination.
+  // __asan_report_* functions are noreturn, so we need a switch to prevent
+  // the compiler from removing any of them.
+  switch (fake_condition) {
+    case 1: __asan_report_load1(0); break;
+    case 2: __asan_report_load2(0); break;
+    case 3: __asan_report_load4(0); break;
+    case 4: __asan_report_load8(0); break;
+    case 5: __asan_report_load16(0); break;
+    case 6: __asan_report_load_n(0, 0); break;
+    case 7: __asan_report_store1(0); break;
+    case 8: __asan_report_store2(0); break;
+    case 9: __asan_report_store4(0); break;
+    case 10: __asan_report_store8(0); break;
+    case 11: __asan_report_store16(0); break;
+    case 12: __asan_report_store_n(0, 0); break;
+    case 13: __asan_report_exp_load1(0, 0); break;
+    case 14: __asan_report_exp_load2(0, 0); break;
+    case 15: __asan_report_exp_load4(0, 0); break;
+    case 16: __asan_report_exp_load8(0, 0); break;
+    case 17: __asan_report_exp_load16(0, 0); break;
+    case 18: __asan_report_exp_load_n(0, 0, 0); break;
+    case 19: __asan_report_exp_store1(0, 0); break;
+    case 20: __asan_report_exp_store2(0, 0); break;
+    case 21: __asan_report_exp_store4(0, 0); break;
+    case 22: __asan_report_exp_store8(0, 0); break;
+    case 23: __asan_report_exp_store16(0, 0); break;
+    case 24: __asan_report_exp_store_n(0, 0, 0); break;
+    case 25: __asan_register_globals(nullptr, 0); break;
+    case 26: __asan_unregister_globals(nullptr, 0); break;
+    case 27: __asan_set_death_callback(nullptr); break;
+    case 28: __asan_set_error_report_callback(nullptr); break;
+    case 29: __asan_handle_no_return(); break;
+    case 30: __asan_address_is_poisoned(nullptr); break;
+    case 31: __asan_poison_memory_region(nullptr, 0); break;
+    case 32: __asan_unpoison_memory_region(nullptr, 0); break;
+    case 34: __asan_before_dynamic_init(nullptr); break;
+    case 35: __asan_after_dynamic_init(); break;
+    case 36: __asan_poison_stack_memory(0, 0); break;
+    case 37: __asan_unpoison_stack_memory(0, 0); break;
+    case 38: __asan_region_is_poisoned(0, 0); break;
+    case 39: __asan_describe_address(0); break;
+  }
+}
+
+static void asan_atexit() {
+  Printf("AddressSanitizer exit stats:\n");
+  __asan_print_accumulated_stats();
+  // Print AsanMappingProfile.
+  for (uptr i = 0; i < kAsanMappingProfileSize; i++) {
+    if (AsanMappingProfile[i] == 0) continue;
+    Printf("asan_mapping.h:%zd -- %zd\n", i, AsanMappingProfile[i]);
+  }
+}
+
+static void InitializeHighMemEnd() {
+#if !ASAN_FIXED_MAPPING
+  kHighMemEnd = GetMaxVirtualAddress();
+  // Increase kHighMemEnd to make sure it's properly
+  // aligned together with kHighMemBeg:
+  kHighMemEnd |= SHADOW_GRANULARITY * GetPageSizeCached() - 1;
+#endif  // !ASAN_FIXED_MAPPING
+  CHECK_EQ((kHighMemBeg % GetPageSizeCached()), 0);
+}
+
+static void ProtectGap(uptr addr, uptr size) {
+  if (!flags()->protect_shadow_gap)
+    return;
+  void *res = MmapNoAccess(addr, size, "shadow gap");
+  if (addr == (uptr)res)
+    return;
+  // A few pages at the start of the address space can not be protected.
+  // But we really want to protect as much as possible, to prevent this memory
+  // being returned as a result of a non-FIXED mmap().
+  if (addr == kZeroBaseShadowStart) {
+    uptr step = GetPageSizeCached();
+    while (size > step && addr < kZeroBaseMaxShadowStart) {
+      addr += step;
+      size -= step;
+      void *res = MmapNoAccess(addr, size, "shadow gap");
+      if (addr == (uptr)res)
+        return;
+    }
+  }
+
+  Report("ERROR: Failed to protect the shadow gap. "
+         "ASan cannot proceed correctly. ABORTING.\n");
+  DumpProcessMap();
+  Die();
+}
+
+static void PrintAddressSpaceLayout() {
+  Printf("|| `[%p, %p]` || HighMem    ||\n",
+         (void*)kHighMemBeg, (void*)kHighMemEnd);
+  Printf("|| `[%p, %p]` || HighShadow ||\n",
+         (void*)kHighShadowBeg, (void*)kHighShadowEnd);
+  if (kMidMemBeg) {
+    Printf("|| `[%p, %p]` || ShadowGap3 ||\n",
+           (void*)kShadowGap3Beg, (void*)kShadowGap3End);
+    Printf("|| `[%p, %p]` || MidMem     ||\n",
+           (void*)kMidMemBeg, (void*)kMidMemEnd);
+    Printf("|| `[%p, %p]` || ShadowGap2 ||\n",
+           (void*)kShadowGap2Beg, (void*)kShadowGap2End);
+    Printf("|| `[%p, %p]` || MidShadow  ||\n",
+           (void*)kMidShadowBeg, (void*)kMidShadowEnd);
+  }
+  Printf("|| `[%p, %p]` || ShadowGap  ||\n",
+         (void*)kShadowGapBeg, (void*)kShadowGapEnd);
+  if (kLowShadowBeg) {
+    Printf("|| `[%p, %p]` || LowShadow  ||\n",
+           (void*)kLowShadowBeg, (void*)kLowShadowEnd);
+    Printf("|| `[%p, %p]` || LowMem     ||\n",
+           (void*)kLowMemBeg, (void*)kLowMemEnd);
+  }
+  Printf("MemToShadow(shadow): %p %p %p %p",
+         (void*)MEM_TO_SHADOW(kLowShadowBeg),
+         (void*)MEM_TO_SHADOW(kLowShadowEnd),
+         (void*)MEM_TO_SHADOW(kHighShadowBeg),
+         (void*)MEM_TO_SHADOW(kHighShadowEnd));
+  if (kMidMemBeg) {
+    Printf(" %p %p",
+           (void*)MEM_TO_SHADOW(kMidShadowBeg),
+           (void*)MEM_TO_SHADOW(kMidShadowEnd));
+  }
+  Printf("\n");
+  Printf("redzone=%zu\n", (uptr)flags()->redzone);
+  Printf("max_redzone=%zu\n", (uptr)flags()->max_redzone);
+  Printf("quarantine_size_mb=%zuM\n", (uptr)flags()->quarantine_size_mb);
+  Printf("malloc_context_size=%zu\n",
+         (uptr)common_flags()->malloc_context_size);
+
+  Printf("SHADOW_SCALE: %d\n", (int)SHADOW_SCALE);
+  Printf("SHADOW_GRANULARITY: %d\n", (int)SHADOW_GRANULARITY);
+  Printf("SHADOW_OFFSET: 0x%zx\n", (uptr)SHADOW_OFFSET);
+  CHECK(SHADOW_SCALE >= 3 && SHADOW_SCALE <= 7);
+  if (kMidMemBeg)
+    CHECK(kMidShadowBeg > kLowShadowEnd &&
+          kMidMemBeg > kMidShadowEnd &&
+          kHighShadowBeg > kMidMemEnd);
+}
+
+static void AsanInitInternal() {
+  if (LIKELY(asan_inited)) return;
+  SanitizerToolName = "AddressSanitizer";
+  CHECK(!asan_init_is_running && "ASan init calls itself!");
+  asan_init_is_running = true;
+
+  CacheBinaryName();
+
+  // Initialize flags. This must be done early, because most of the
+  // initialization steps look at flags().
+  InitializeFlags();
+
+  AsanCheckIncompatibleRT();
+  AsanCheckDynamicRTPrereqs();
+
+  SetCanPoisonMemory(flags()->poison_heap);
+  SetMallocContextSize(common_flags()->malloc_context_size);
+
+  InitializeHighMemEnd();
+
+  // Make sure we are not statically linked.
+  AsanDoesNotSupportStaticLinkage();
+
+  // Install tool-specific callbacks in sanitizer_common.
+  AddDieCallback(AsanDie);
+  SetCheckFailedCallback(AsanCheckFailed);
+  SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
+
+  __sanitizer_set_report_path(common_flags()->log_path);
+
+  // Enable UAR detection, if required.
+  __asan_option_detect_stack_use_after_return =
+      flags()->detect_stack_use_after_return;
+
+  // Re-exec ourselves if we need to set additional env or command line args.
+  MaybeReexec();
+
+  // Setup internal allocator callback.
+  SetLowLevelAllocateCallback(OnLowLevelAllocate);
+
+  InitializeAsanInterceptors();
+
+  // Enable system log ("adb logcat") on Android.
+  // Doing this before interceptors are initialized crashes in:
+  // AsanInitInternal -> android_log_write -> __interceptor_strcmp
+  AndroidLogInit();
+
+  ReplaceSystemMalloc();
+
+  uptr shadow_start = kLowShadowBeg;
+  if (kLowShadowBeg)
+    shadow_start -= GetMmapGranularity();
+  bool full_shadow_is_available =
+      MemoryRangeIsAvailable(shadow_start, kHighShadowEnd);
+
+#if SANITIZER_LINUX && defined(__x86_64__) && defined(_LP64) &&                \
+    !ASAN_FIXED_MAPPING
+  if (!full_shadow_is_available) {
+    kMidMemBeg = kLowMemEnd < 0x3000000000ULL ? 0x3000000000ULL : 0;
+    kMidMemEnd = kLowMemEnd < 0x3000000000ULL ? 0x4fffffffffULL : 0;
+  }
+#endif
+
+  if (Verbosity()) PrintAddressSpaceLayout();
+
+  DisableCoreDumperIfNecessary();
+
+  if (full_shadow_is_available) {
+    // mmap the low shadow plus at least one page at the left.
+    if (kLowShadowBeg)
+      ReserveShadowMemoryRange(shadow_start, kLowShadowEnd, "low shadow");
+    // mmap the high shadow.
+    ReserveShadowMemoryRange(kHighShadowBeg, kHighShadowEnd, "high shadow");
+    // protect the gap.
+    ProtectGap(kShadowGapBeg, kShadowGapEnd - kShadowGapBeg + 1);
+    CHECK_EQ(kShadowGapEnd, kHighShadowBeg - 1);
+  } else if (kMidMemBeg &&
+      MemoryRangeIsAvailable(shadow_start, kMidMemBeg - 1) &&
+      MemoryRangeIsAvailable(kMidMemEnd + 1, kHighShadowEnd)) {
+    CHECK(kLowShadowBeg != kLowShadowEnd);
+    // mmap the low shadow plus at least one page at the left.
+    ReserveShadowMemoryRange(shadow_start, kLowShadowEnd, "low shadow");
+    // mmap the mid shadow.
+    ReserveShadowMemoryRange(kMidShadowBeg, kMidShadowEnd, "mid shadow");
+    // mmap the high shadow.
+    ReserveShadowMemoryRange(kHighShadowBeg, kHighShadowEnd, "high shadow");
+    // protect the gaps.
+    ProtectGap(kShadowGapBeg, kShadowGapEnd - kShadowGapBeg + 1);
+    ProtectGap(kShadowGap2Beg, kShadowGap2End - kShadowGap2Beg + 1);
+    ProtectGap(kShadowGap3Beg, kShadowGap3End - kShadowGap3Beg + 1);
+  } else {
+    Report("Shadow memory range interleaves with an existing memory mapping. "
+           "ASan cannot proceed correctly. ABORTING.\n");
+    Report("ASan shadow was supposed to be located in the [%p-%p] range.\n",
+           shadow_start, kHighShadowEnd);
+    DumpProcessMap();
+    Die();
+  }
+
+  AsanTSDInit(PlatformTSDDtor);
+  InstallDeadlySignalHandlers(AsanOnDeadlySignal);
+
+  AllocatorOptions allocator_options;
+  allocator_options.SetFrom(flags(), common_flags());
+  InitializeAllocator(allocator_options);
+
+  MaybeStartBackgroudThread();
+  SetSoftRssLimitExceededCallback(AsanSoftRssLimitExceededCallback);
+
+  // On Linux AsanThread::ThreadStart() calls malloc() that's why asan_inited
+  // should be set to 1 prior to initializing the threads.
+  asan_inited = 1;
+  asan_init_is_running = false;
+
+  if (flags()->atexit)
+    Atexit(asan_atexit);
+
+  InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
+
+  // Now that ASan runtime is (mostly) initialized, deactivate it if
+  // necessary, so that it can be re-activated when requested.
+  if (flags()->start_deactivated)
+    AsanDeactivate();
+
+  // interceptors
+  InitTlsSize();
+
+  // Create main thread.
+  AsanThread *main_thread = AsanThread::Create(
+      /* start_routine */ nullptr, /* arg */ nullptr, /* parent_tid */ 0,
+      /* stack */ nullptr, /* detached */ true);
+  CHECK_EQ(0, main_thread->tid());
+  SetCurrentThread(main_thread);
+  main_thread->ThreadStart(internal_getpid(),
+                           /* signal_thread_is_registered */ nullptr);
+  force_interface_symbols();  // no-op.
+  SanitizerInitializeUnwinder();
+
+#if CAN_SANITIZE_LEAKS
+  __lsan::InitCommonLsan();
+  if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit) {
+    Atexit(__lsan::DoLeakCheck);
+  }
+#endif  // CAN_SANITIZE_LEAKS
+
+#if CAN_SANITIZE_UB
+  __ubsan::InitAsPlugin();
+#endif
+
+  InitializeSuppressions();
+
+  VReport(1, "AddressSanitizer Init done\n");
+}
+
+// Initialize as requested from some part of ASan runtime library (interceptors,
+// allocator, etc).
+void AsanInitFromRtl() {
+  AsanInitInternal();
+}
+
+#if ASAN_DYNAMIC
+// Initialize runtime in case it's LD_PRELOAD-ed into unsanitized executable
+// (and thus normal initializers from .preinit_array or modules haven't run).
+
+class AsanInitializer {
+public:  // NOLINT
+  AsanInitializer() {
+    AsanInitFromRtl();
+  }
+};
+
+static AsanInitializer asan_initializer;
+#endif  // ASAN_DYNAMIC
+
+} // namespace __asan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+void NOINLINE __asan_handle_no_return() {
+  int local_stack;
+  AsanThread *curr_thread = GetCurrentThread();
+  uptr PageSize = GetPageSizeCached();
+  uptr top, bottom;
+  if (curr_thread) {
+    top = curr_thread->stack_top();
+    bottom = ((uptr)&local_stack - PageSize) & ~(PageSize - 1);
+  } else {
+    // If we haven't seen this thread, try asking the OS for stack bounds.
+    uptr tls_addr, tls_size, stack_size;
+    GetThreadStackAndTls(/*main=*/false, &bottom, &stack_size, &tls_addr,
+                         &tls_size);
+    top = bottom + stack_size;
+  }
+  static const uptr kMaxExpectedCleanupSize = 64 << 20;  // 64M
+  if (top - bottom > kMaxExpectedCleanupSize) {
+    static bool reported_warning = false;
+    if (reported_warning)
+      return;
+    reported_warning = true;
+    Report("WARNING: ASan is ignoring requested __asan_handle_no_return: "
+           "stack top: %p; bottom %p; size: %p (%zd)\n"
+           "False positive error reports may follow\n"
+           "For details see "
+           "https://github.com/google/sanitizers/issues/189\n",
+           top, bottom, top - bottom, top - bottom);
+    return;
+  }
+  PoisonShadow(bottom, top - bottom, 0);
+  if (curr_thread && curr_thread->has_fake_stack())
+    curr_thread->fake_stack()->HandleNoReturn();
+}
+
+void NOINLINE __asan_set_death_callback(void (*callback)(void)) {
+  SetUserDieCallback(callback);
+}
+
+// Initialize as requested from instrumented application code.
+// We use this call as a trigger to wake up ASan from deactivated state.
+void __asan_init() {
+  AsanActivate();
+  AsanInitInternal();
+}
+
+void __asan_version_mismatch_check() {
+  // Do nothing.
+}
diff --git a/compiler-rt/lib/asan/asan_stack.cc b/compiler-rt/lib/asan/asan_stack.cc
new file mode 100644
index 0000000..cf7a587
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_stack.cc
@@ -0,0 +1,40 @@
+//===-- asan_stack.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Code for ASan stack trace.
+//===----------------------------------------------------------------------===//
+#include "asan_internal.h"
+#include "asan_stack.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+
+namespace __asan {
+
+static atomic_uint32_t malloc_context_size;
+
+void SetMallocContextSize(u32 size) {
+  atomic_store(&malloc_context_size, size, memory_order_release);
+}
+
+u32 GetMallocContextSize() {
+  return atomic_load(&malloc_context_size, memory_order_acquire);
+}
+
+}  // namespace __asan
+
+// ------------------ Interface -------------- {{{1
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_print_stack_trace() {
+  using namespace __asan;
+  PRINT_CURRENT_STACK();
+}
+}  // extern "C"
diff --git a/compiler-rt/lib/asan/asan_stack.h b/compiler-rt/lib/asan/asan_stack.h
new file mode 100644
index 0000000..5c51815
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_stack.h
@@ -0,0 +1,119 @@
+//===-- asan_stack.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_stack.cc.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_STACK_H
+#define ASAN_STACK_H
+
+#include "asan_flags.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+
+namespace __asan {
+
+static const u32 kDefaultMallocContextSize = 30;
+
+void SetMallocContextSize(u32 size);
+u32 GetMallocContextSize();
+
+// Get the stack trace with the given pc and bp.
+// The pc will be in the position 0 of the resulting stack trace.
+// The bp may refer to the current frame or to the caller's frame.
+ALWAYS_INLINE
+void GetStackTraceWithPcBpAndContext(BufferedStackTrace *stack, uptr max_depth,
+                                     uptr pc, uptr bp, void *context,
+                                     bool fast) {
+#if SANITIZER_WINDOWS
+  stack->Unwind(max_depth, pc, bp, context, 0, 0, fast);
+#else
+  AsanThread *t;
+  stack->size = 0;
+  if (LIKELY(asan_inited)) {
+    if ((t = GetCurrentThread()) && !t->isUnwinding()) {
+      // On FreeBSD the slow unwinding that leverages _Unwind_Backtrace()
+      // yields the call stack of the signal's handler and not of the code
+      // that raised the signal (as it does on Linux).
+      if (SANITIZER_FREEBSD && t->isInDeadlySignal()) fast = true;
+      uptr stack_top = t->stack_top();
+      uptr stack_bottom = t->stack_bottom();
+      ScopedUnwinding unwind_scope(t);
+      stack->Unwind(max_depth, pc, bp, context, stack_top, stack_bottom, fast);
+    } else if (!t && !fast) {
+      /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
+      stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
+    }
+  }
+#endif // SANITIZER_WINDOWS
+}
+
+} // namespace __asan
+
+// NOTE: A Rule of thumb is to retrieve stack trace in the interceptors
+// as early as possible (in functions exposed to the user), as we generally
+// don't want stack trace to contain functions from ASan internals.
+
+#define GET_STACK_TRACE(max_size, fast)                                        \
+  BufferedStackTrace stack;                                                    \
+  if (max_size <= 2) {                                                         \
+    stack.size = max_size;                                                     \
+    if (max_size > 0) {                                                        \
+      stack.top_frame_bp = GET_CURRENT_FRAME();                                \
+      stack.trace_buffer[0] = StackTrace::GetCurrentPc();                      \
+      if (max_size > 1)                                                        \
+        stack.trace_buffer[1] = GET_CALLER_PC();                               \
+    }                                                                          \
+  } else {                                                                     \
+    GetStackTraceWithPcBpAndContext(&stack, max_size,                          \
+                                    StackTrace::GetCurrentPc(),                \
+                                    GET_CURRENT_FRAME(), 0, fast);             \
+  }
+
+#define GET_STACK_TRACE_FATAL(pc, bp)                                          \
+  BufferedStackTrace stack;                                                    \
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, 0,           \
+                                  common_flags()->fast_unwind_on_fatal)
+
+#define GET_STACK_TRACE_SIGNAL(sig)                                            \
+  BufferedStackTrace stack;                                                    \
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax,                      \
+                                  (sig).pc, (sig).bp, (sig).context,           \
+                                  common_flags()->fast_unwind_on_fatal)
+
+#define GET_STACK_TRACE_FATAL_HERE                                \
+  GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
+
+#define GET_STACK_TRACE_CHECK_HERE                                \
+  GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_check)
+
+#define GET_STACK_TRACE_THREAD                                    \
+  GET_STACK_TRACE(kStackTraceMax, true)
+
+#define GET_STACK_TRACE_MALLOC                                                 \
+  GET_STACK_TRACE(GetMallocContextSize(), common_flags()->fast_unwind_on_malloc)
+
+#define GET_STACK_TRACE_FREE GET_STACK_TRACE_MALLOC
+
+#define PRINT_CURRENT_STACK()   \
+  {                             \
+    GET_STACK_TRACE_FATAL_HERE; \
+    stack.Print();              \
+  }
+
+#define PRINT_CURRENT_STACK_CHECK() \
+  {                                 \
+    GET_STACK_TRACE_CHECK_HERE;     \
+    stack.Print();                  \
+  }
+
+#endif // ASAN_STACK_H
diff --git a/compiler-rt/lib/asan/asan_stats.cc b/compiler-rt/lib/asan/asan_stats.cc
new file mode 100644
index 0000000..b8c68c3
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_stats.cc
@@ -0,0 +1,174 @@
+//===-- asan_stats.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Code related to statistics collected by AddressSanitizer.
+//===----------------------------------------------------------------------===//
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_stats.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_allocator_interface.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+
+namespace __asan {
+
+AsanStats::AsanStats() {
+  Clear();
+}
+
+void AsanStats::Clear() {
+  CHECK(REAL(memset));
+  REAL(memset)(this, 0, sizeof(AsanStats));
+}
+
+static void PrintMallocStatsArray(const char *prefix,
+                                  uptr (&array)[kNumberOfSizeClasses]) {
+  Printf("%s", prefix);
+  for (uptr i = 0; i < kNumberOfSizeClasses; i++) {
+    if (!array[i]) continue;
+    Printf("%zu:%zu; ", i, array[i]);
+  }
+  Printf("\n");
+}
+
+void AsanStats::Print() {
+  Printf("Stats: %zuM malloced (%zuM for red zones) by %zu calls\n",
+             malloced>>20, malloced_redzones>>20, mallocs);
+  Printf("Stats: %zuM realloced by %zu calls\n", realloced>>20, reallocs);
+  Printf("Stats: %zuM freed by %zu calls\n", freed>>20, frees);
+  Printf("Stats: %zuM really freed by %zu calls\n",
+             really_freed>>20, real_frees);
+  Printf("Stats: %zuM (%zuM-%zuM) mmaped; %zu maps, %zu unmaps\n",
+             (mmaped-munmaped)>>20, mmaped>>20, munmaped>>20,
+             mmaps, munmaps);
+
+  PrintMallocStatsArray("  mallocs by size class: ", malloced_by_size);
+  Printf("Stats: malloc large: %zu\n", malloc_large);
+}
+
+void AsanStats::MergeFrom(const AsanStats *stats) {
+  uptr *dst_ptr = reinterpret_cast<uptr*>(this);
+  const uptr *src_ptr = reinterpret_cast<const uptr*>(stats);
+  uptr num_fields = sizeof(*this) / sizeof(uptr);
+  for (uptr i = 0; i < num_fields; i++)
+    dst_ptr[i] += src_ptr[i];
+}
+
+static BlockingMutex print_lock(LINKER_INITIALIZED);
+
+static AsanStats unknown_thread_stats(LINKER_INITIALIZED);
+static AsanStats dead_threads_stats(LINKER_INITIALIZED);
+static BlockingMutex dead_threads_stats_lock(LINKER_INITIALIZED);
+// Required for malloc_zone_statistics() on OS X. This can't be stored in
+// per-thread AsanStats.
+static uptr max_malloced_memory;
+
+static void MergeThreadStats(ThreadContextBase *tctx_base, void *arg) {
+  AsanStats *accumulated_stats = reinterpret_cast<AsanStats*>(arg);
+  AsanThreadContext *tctx = static_cast<AsanThreadContext*>(tctx_base);
+  if (AsanThread *t = tctx->thread)
+    accumulated_stats->MergeFrom(&t->stats());
+}
+
+static void GetAccumulatedStats(AsanStats *stats) {
+  stats->Clear();
+  {
+    ThreadRegistryLock l(&asanThreadRegistry());
+    asanThreadRegistry()
+        .RunCallbackForEachThreadLocked(MergeThreadStats, stats);
+  }
+  stats->MergeFrom(&unknown_thread_stats);
+  {
+    BlockingMutexLock lock(&dead_threads_stats_lock);
+    stats->MergeFrom(&dead_threads_stats);
+  }
+  // This is not very accurate: we may miss allocation peaks that happen
+  // between two updates of accumulated_stats_. For more accurate bookkeeping
+  // the maximum should be updated on every malloc(), which is unacceptable.
+  if (max_malloced_memory < stats->malloced) {
+    max_malloced_memory = stats->malloced;
+  }
+}
+
+void FlushToDeadThreadStats(AsanStats *stats) {
+  BlockingMutexLock lock(&dead_threads_stats_lock);
+  dead_threads_stats.MergeFrom(stats);
+  stats->Clear();
+}
+
+void FillMallocStatistics(AsanMallocStats *malloc_stats) {
+  AsanStats stats;
+  GetAccumulatedStats(&stats);
+  malloc_stats->blocks_in_use = stats.mallocs;
+  malloc_stats->size_in_use = stats.malloced;
+  malloc_stats->max_size_in_use = max_malloced_memory;
+  malloc_stats->size_allocated = stats.mmaped;
+}
+
+AsanStats &GetCurrentThreadStats() {
+  AsanThread *t = GetCurrentThread();
+  return (t) ? t->stats() : unknown_thread_stats;
+}
+
+static void PrintAccumulatedStats() {
+  AsanStats stats;
+  GetAccumulatedStats(&stats);
+  // Use lock to keep reports from mixing up.
+  BlockingMutexLock lock(&print_lock);
+  stats.Print();
+  StackDepotStats *stack_depot_stats = StackDepotGetStats();
+  Printf("Stats: StackDepot: %zd ids; %zdM allocated\n",
+         stack_depot_stats->n_uniq_ids, stack_depot_stats->allocated >> 20);
+  PrintInternalAllocatorStats();
+}
+
+}  // namespace __asan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;  // NOLINT
+
+uptr __sanitizer_get_current_allocated_bytes() {
+  AsanStats stats;
+  GetAccumulatedStats(&stats);
+  uptr malloced = stats.malloced;
+  uptr freed = stats.freed;
+  // Return sane value if malloced < freed due to racy
+  // way we update accumulated stats.
+  return (malloced > freed) ? malloced - freed : 1;
+}
+
+uptr __sanitizer_get_heap_size() {
+  AsanStats stats;
+  GetAccumulatedStats(&stats);
+  return stats.mmaped - stats.munmaped;
+}
+
+uptr __sanitizer_get_free_bytes() {
+  AsanStats stats;
+  GetAccumulatedStats(&stats);
+  uptr total_free = stats.mmaped
+                  - stats.munmaped
+                  + stats.really_freed;
+  uptr total_used = stats.malloced
+                  + stats.malloced_redzones;
+  // Return sane value if total_free < total_used due to racy
+  // way we update accumulated stats.
+  return (total_free > total_used) ? total_free - total_used : 1;
+}
+
+uptr __sanitizer_get_unmapped_bytes() {
+  return 0;
+}
+
+void __asan_print_accumulated_stats() {
+  PrintAccumulatedStats();
+}
diff --git a/compiler-rt/lib/asan/asan_stats.h b/compiler-rt/lib/asan/asan_stats.h
new file mode 100644
index 0000000..4605135
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_stats.h
@@ -0,0 +1,72 @@
+//===-- asan_stats.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for statistics.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_STATS_H
+#define ASAN_STATS_H
+
+#include "asan_allocator.h"
+#include "asan_internal.h"
+
+namespace __asan {
+
+// AsanStats struct is NOT thread-safe.
+// Each AsanThread has its own AsanStats, which are sometimes flushed
+// to the accumulated AsanStats.
+struct AsanStats {
+  // AsanStats must be a struct consisting of uptr fields only.
+  // When merging two AsanStats structs, we treat them as arrays of uptr.
+  uptr mallocs;
+  uptr malloced;
+  uptr malloced_redzones;
+  uptr frees;
+  uptr freed;
+  uptr real_frees;
+  uptr really_freed;
+  uptr reallocs;
+  uptr realloced;
+  uptr mmaps;
+  uptr mmaped;
+  uptr munmaps;
+  uptr munmaped;
+  uptr malloc_large;
+  uptr malloced_by_size[kNumberOfSizeClasses];
+
+  // Ctor for global AsanStats (accumulated stats for dead threads).
+  explicit AsanStats(LinkerInitialized) { }
+  // Creates empty stats.
+  AsanStats();
+
+  void Print();  // Prints formatted stats to stderr.
+  void Clear();
+  void MergeFrom(const AsanStats *stats);
+};
+
+// Returns stats for GetCurrentThread(), or stats for fake "unknown thread"
+// if GetCurrentThread() returns 0.
+AsanStats &GetCurrentThreadStats();
+// Flushes a given stats into accumulated stats of dead threads.
+void FlushToDeadThreadStats(AsanStats *stats);
+
+// A cross-platform equivalent of malloc_statistics_t on Mac OS.
+struct AsanMallocStats {
+  uptr blocks_in_use;
+  uptr size_in_use;
+  uptr max_size_in_use;
+  uptr size_allocated;
+};
+
+void FillMallocStatistics(AsanMallocStats *malloc_stats);
+
+}  // namespace __asan
+
+#endif  // ASAN_STATS_H
diff --git a/compiler-rt/lib/asan/asan_suppressions.cc b/compiler-rt/lib/asan/asan_suppressions.cc
new file mode 100644
index 0000000..41887b5
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_suppressions.cc
@@ -0,0 +1,110 @@
+//===-- asan_suppressions.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Issue suppression and suppression-related functions.
+//===----------------------------------------------------------------------===//
+
+#include "asan_suppressions.h"
+
+#include "asan_stack.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+namespace __asan {
+
+ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
+static SuppressionContext *suppression_ctx = nullptr;
+static const char kInterceptorName[] = "interceptor_name";
+static const char kInterceptorViaFunction[] = "interceptor_via_fun";
+static const char kInterceptorViaLibrary[] = "interceptor_via_lib";
+static const char kODRViolation[] = "odr_violation";
+static const char *kSuppressionTypes[] = {
+    kInterceptorName, kInterceptorViaFunction, kInterceptorViaLibrary,
+    kODRViolation};
+
+extern "C" {
+#if SANITIZER_SUPPORTS_WEAK_HOOKS
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+const char *__asan_default_suppressions();
+#else
+// No week hooks, provide empty implementation.
+const char *__asan_default_suppressions() { return ""; }
+#endif  // SANITIZER_SUPPORTS_WEAK_HOOKS
+}  // extern "C"
+
+void InitializeSuppressions() {
+  CHECK_EQ(nullptr, suppression_ctx);
+  suppression_ctx = new (suppression_placeholder)  // NOLINT
+      SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
+  suppression_ctx->ParseFromFile(flags()->suppressions);
+  if (&__asan_default_suppressions)
+    suppression_ctx->Parse(__asan_default_suppressions());
+}
+
+bool IsInterceptorSuppressed(const char *interceptor_name) {
+  CHECK(suppression_ctx);
+  Suppression *s;
+  // Match "interceptor_name" suppressions.
+  return suppression_ctx->Match(interceptor_name, kInterceptorName, &s);
+}
+
+bool HaveStackTraceBasedSuppressions() {
+  CHECK(suppression_ctx);
+  return suppression_ctx->HasSuppressionType(kInterceptorViaFunction) ||
+         suppression_ctx->HasSuppressionType(kInterceptorViaLibrary);
+}
+
+bool IsODRViolationSuppressed(const char *global_var_name) {
+  CHECK(suppression_ctx);
+  Suppression *s;
+  // Match "odr_violation" suppressions.
+  return suppression_ctx->Match(global_var_name, kODRViolation, &s);
+}
+
+bool IsStackTraceSuppressed(const StackTrace *stack) {
+  if (!HaveStackTraceBasedSuppressions())
+    return false;
+
+  CHECK(suppression_ctx);
+  Symbolizer *symbolizer = Symbolizer::GetOrInit();
+  Suppression *s;
+  for (uptr i = 0; i < stack->size && stack->trace[i]; i++) {
+    uptr addr = stack->trace[i];
+
+    if (suppression_ctx->HasSuppressionType(kInterceptorViaLibrary)) {
+      // Match "interceptor_via_lib" suppressions.
+      if (const char *module_name = symbolizer->GetModuleNameForPc(addr))
+        if (suppression_ctx->Match(module_name, kInterceptorViaLibrary, &s))
+          return true;
+    }
+
+    if (suppression_ctx->HasSuppressionType(kInterceptorViaFunction)) {
+      SymbolizedStack *frames = symbolizer->SymbolizePC(addr);
+      for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+        const char *function_name = cur->info.function;
+        if (!function_name) {
+          continue;
+        }
+        // Match "interceptor_via_fun" suppressions.
+        if (suppression_ctx->Match(function_name, kInterceptorViaFunction,
+                                   &s)) {
+          frames->ClearAll();
+          return true;
+        }
+      }
+      frames->ClearAll();
+    }
+  }
+  return false;
+}
+
+} // namespace __asan
diff --git a/compiler-rt/lib/asan/asan_suppressions.h b/compiler-rt/lib/asan/asan_suppressions.h
new file mode 100644
index 0000000..5246b4b
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_suppressions.h
@@ -0,0 +1,30 @@
+//===-- asan_suppressions.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_suppressions.cc.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_SUPPRESSIONS_H
+#define ASAN_SUPPRESSIONS_H
+
+#include "asan_internal.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+
+namespace __asan {
+
+void InitializeSuppressions();
+bool IsInterceptorSuppressed(const char *interceptor_name);
+bool HaveStackTraceBasedSuppressions();
+bool IsStackTraceSuppressed(const StackTrace *stack);
+bool IsODRViolationSuppressed(const char *global_var_name);
+
+} // namespace __asan
+
+#endif // ASAN_SUPPRESSIONS_H
diff --git a/compiler-rt/lib/asan/asan_thread.cc b/compiler-rt/lib/asan/asan_thread.cc
new file mode 100644
index 0000000..6981354
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_thread.cc
@@ -0,0 +1,357 @@
+//===-- asan_thread.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Thread-related code.
+//===----------------------------------------------------------------------===//
+#include "asan_allocator.h"
+#include "asan_interceptors.h"
+#include "asan_poisoning.h"
+#include "asan_stack.h"
+#include "asan_thread.h"
+#include "asan_mapping.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_tls_get_addr.h"
+#include "lsan/lsan_common.h"
+
+namespace __asan {
+
+// AsanThreadContext implementation.
+
+struct CreateThreadContextArgs {
+  AsanThread *thread;
+  StackTrace *stack;
+};
+
+void AsanThreadContext::OnCreated(void *arg) {
+  CreateThreadContextArgs *args = static_cast<CreateThreadContextArgs*>(arg);
+  if (args->stack)
+    stack_id = StackDepotPut(*args->stack);
+  thread = args->thread;
+  thread->set_context(this);
+}
+
+void AsanThreadContext::OnFinished() {
+  // Drop the link to the AsanThread object.
+  thread = nullptr;
+}
+
+// MIPS requires aligned address
+static ALIGNED(16) char thread_registry_placeholder[sizeof(ThreadRegistry)];
+static ThreadRegistry *asan_thread_registry;
+
+static BlockingMutex mu_for_thread_context(LINKER_INITIALIZED);
+static LowLevelAllocator allocator_for_thread_context;
+
+static ThreadContextBase *GetAsanThreadContext(u32 tid) {
+  BlockingMutexLock lock(&mu_for_thread_context);
+  return new(allocator_for_thread_context) AsanThreadContext(tid);
+}
+
+ThreadRegistry &asanThreadRegistry() {
+  static bool initialized;
+  // Don't worry about thread_safety - this should be called when there is
+  // a single thread.
+  if (!initialized) {
+    // Never reuse ASan threads: we store pointer to AsanThreadContext
+    // in TSD and can't reliably tell when no more TSD destructors will
+    // be called. It would be wrong to reuse AsanThreadContext for another
+    // thread before all TSD destructors will be called for it.
+    asan_thread_registry = new(thread_registry_placeholder) ThreadRegistry(
+        GetAsanThreadContext, kMaxNumberOfThreads, kMaxNumberOfThreads);
+    initialized = true;
+  }
+  return *asan_thread_registry;
+}
+
+AsanThreadContext *GetThreadContextByTidLocked(u32 tid) {
+  return static_cast<AsanThreadContext *>(
+      asanThreadRegistry().GetThreadLocked(tid));
+}
+
+// AsanThread implementation.
+
+AsanThread *AsanThread::Create(thread_callback_t start_routine, void *arg,
+                               u32 parent_tid, StackTrace *stack,
+                               bool detached) {
+  uptr PageSize = GetPageSizeCached();
+  uptr size = RoundUpTo(sizeof(AsanThread), PageSize);
+  AsanThread *thread = (AsanThread*)MmapOrDie(size, __func__);
+  thread->start_routine_ = start_routine;
+  thread->arg_ = arg;
+  CreateThreadContextArgs args = { thread, stack };
+  asanThreadRegistry().CreateThread(*reinterpret_cast<uptr *>(thread), detached,
+                                    parent_tid, &args);
+
+  return thread;
+}
+
+void AsanThread::TSDDtor(void *tsd) {
+  AsanThreadContext *context = (AsanThreadContext*)tsd;
+  VReport(1, "T%d TSDDtor\n", context->tid);
+  if (context->thread)
+    context->thread->Destroy();
+}
+
+void AsanThread::Destroy() {
+  int tid = this->tid();
+  VReport(1, "T%d exited\n", tid);
+
+  malloc_storage().CommitBack();
+  if (common_flags()->use_sigaltstack) UnsetAlternateSignalStack();
+  asanThreadRegistry().FinishThread(tid);
+  FlushToDeadThreadStats(&stats_);
+  // We also clear the shadow on thread destruction because
+  // some code may still be executing in later TSD destructors
+  // and we don't want it to have any poisoned stack.
+  ClearShadowForThreadStackAndTLS();
+  DeleteFakeStack(tid);
+  uptr size = RoundUpTo(sizeof(AsanThread), GetPageSizeCached());
+  UnmapOrDie(this, size);
+  DTLS_Destroy();
+}
+
+// We want to create the FakeStack lazyly on the first use, but not eralier
+// than the stack size is known and the procedure has to be async-signal safe.
+FakeStack *AsanThread::AsyncSignalSafeLazyInitFakeStack() {
+  uptr stack_size = this->stack_size();
+  if (stack_size == 0)  // stack_size is not yet available, don't use FakeStack.
+    return nullptr;
+  uptr old_val = 0;
+  // fake_stack_ has 3 states:
+  // 0   -- not initialized
+  // 1   -- being initialized
+  // ptr -- initialized
+  // This CAS checks if the state was 0 and if so changes it to state 1,
+  // if that was successful, it initializes the pointer.
+  if (atomic_compare_exchange_strong(
+      reinterpret_cast<atomic_uintptr_t *>(&fake_stack_), &old_val, 1UL,
+      memory_order_relaxed)) {
+    uptr stack_size_log = Log2(RoundUpToPowerOfTwo(stack_size));
+    CHECK_LE(flags()->min_uar_stack_size_log, flags()->max_uar_stack_size_log);
+    stack_size_log =
+        Min(stack_size_log, static_cast<uptr>(flags()->max_uar_stack_size_log));
+    stack_size_log =
+        Max(stack_size_log, static_cast<uptr>(flags()->min_uar_stack_size_log));
+    fake_stack_ = FakeStack::Create(stack_size_log);
+    SetTLSFakeStack(fake_stack_);
+    return fake_stack_;
+  }
+  return nullptr;
+}
+
+void AsanThread::Init() {
+  fake_stack_ = nullptr;  // Will be initialized lazily if needed.
+  CHECK_EQ(this->stack_size(), 0U);
+  SetThreadStackAndTls();
+  CHECK_GT(this->stack_size(), 0U);
+  CHECK(AddrIsInMem(stack_bottom_));
+  CHECK(AddrIsInMem(stack_top_ - 1));
+  ClearShadowForThreadStackAndTLS();
+  int local = 0;
+  VReport(1, "T%d: stack [%p,%p) size 0x%zx; local=%p\n", tid(),
+          (void *)stack_bottom_, (void *)stack_top_, stack_top_ - stack_bottom_,
+          &local);
+}
+
+thread_return_t AsanThread::ThreadStart(
+    uptr os_id, atomic_uintptr_t *signal_thread_is_registered) {
+  Init();
+  asanThreadRegistry().StartThread(tid(), os_id, nullptr);
+  if (signal_thread_is_registered)
+    atomic_store(signal_thread_is_registered, 1, memory_order_release);
+
+  if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
+
+  if (!start_routine_) {
+    // start_routine_ == 0 if we're on the main thread or on one of the
+    // OS X libdispatch worker threads. But nobody is supposed to call
+    // ThreadStart() for the worker threads.
+    CHECK_EQ(tid(), 0);
+    return 0;
+  }
+
+  thread_return_t res = start_routine_(arg_);
+
+  // On POSIX systems we defer this to the TSD destructor. LSan will consider
+  // the thread's memory as non-live from the moment we call Destroy(), even
+  // though that memory might contain pointers to heap objects which will be
+  // cleaned up by a user-defined TSD destructor. Thus, calling Destroy() before
+  // the TSD destructors have run might cause false positives in LSan.
+  if (!SANITIZER_POSIX)
+    this->Destroy();
+
+  return res;
+}
+
+void AsanThread::SetThreadStackAndTls() {
+  uptr tls_size = 0;
+  GetThreadStackAndTls(tid() == 0, &stack_bottom_, &stack_size_, &tls_begin_,
+                       &tls_size);
+  stack_top_ = stack_bottom_ + stack_size_;
+  tls_end_ = tls_begin_ + tls_size;
+
+  int local;
+  CHECK(AddrIsInStack((uptr)&local));
+}
+
+void AsanThread::ClearShadowForThreadStackAndTLS() {
+  PoisonShadow(stack_bottom_, stack_top_ - stack_bottom_, 0);
+  if (tls_begin_ != tls_end_)
+    PoisonShadow(tls_begin_, tls_end_ - tls_begin_, 0);
+}
+
+bool AsanThread::GetStackFrameAccessByAddr(uptr addr,
+                                           StackFrameAccess *access) {
+  uptr bottom = 0;
+  if (AddrIsInStack(addr)) {
+    bottom = stack_bottom();
+  } else if (has_fake_stack()) {
+    bottom = fake_stack()->AddrIsInFakeStack(addr);
+    CHECK(bottom);
+    access->offset = addr - bottom;
+    access->frame_pc = ((uptr*)bottom)[2];
+    access->frame_descr = (const char *)((uptr*)bottom)[1];
+    return true;
+  }
+  uptr aligned_addr = addr & ~(SANITIZER_WORDSIZE/8 - 1);  // align addr.
+  u8 *shadow_ptr = (u8*)MemToShadow(aligned_addr);
+  u8 *shadow_bottom = (u8*)MemToShadow(bottom);
+
+  while (shadow_ptr >= shadow_bottom &&
+         *shadow_ptr != kAsanStackLeftRedzoneMagic) {
+    shadow_ptr--;
+  }
+
+  while (shadow_ptr >= shadow_bottom &&
+         *shadow_ptr == kAsanStackLeftRedzoneMagic) {
+    shadow_ptr--;
+  }
+
+  if (shadow_ptr < shadow_bottom) {
+    return false;
+  }
+
+  uptr* ptr = (uptr*)SHADOW_TO_MEM((uptr)(shadow_ptr + 1));
+  CHECK(ptr[0] == kCurrentStackFrameMagic);
+  access->offset = addr - (uptr)ptr;
+  access->frame_pc = ptr[2];
+  access->frame_descr = (const char*)ptr[1];
+  return true;
+}
+
+static bool ThreadStackContainsAddress(ThreadContextBase *tctx_base,
+                                       void *addr) {
+  AsanThreadContext *tctx = static_cast<AsanThreadContext*>(tctx_base);
+  AsanThread *t = tctx->thread;
+  if (!t) return false;
+  if (t->AddrIsInStack((uptr)addr)) return true;
+  if (t->has_fake_stack() && t->fake_stack()->AddrIsInFakeStack((uptr)addr))
+    return true;
+  return false;
+}
+
+AsanThread *GetCurrentThread() {
+  AsanThreadContext *context =
+      reinterpret_cast<AsanThreadContext *>(AsanTSDGet());
+  if (!context) {
+    if (SANITIZER_ANDROID) {
+      // On Android, libc constructor is called _after_ asan_init, and cleans up
+      // TSD. Try to figure out if this is still the main thread by the stack
+      // address. We are not entirely sure that we have correct main thread
+      // limits, so only do this magic on Android, and only if the found thread
+      // is the main thread.
+      AsanThreadContext *tctx = GetThreadContextByTidLocked(0);
+      if (ThreadStackContainsAddress(tctx, &context)) {
+        SetCurrentThread(tctx->thread);
+        return tctx->thread;
+      }
+    }
+    return nullptr;
+  }
+  return context->thread;
+}
+
+void SetCurrentThread(AsanThread *t) {
+  CHECK(t->context());
+  VReport(2, "SetCurrentThread: %p for thread %p\n", t->context(),
+          (void *)GetThreadSelf());
+  // Make sure we do not reset the current AsanThread.
+  CHECK_EQ(0, AsanTSDGet());
+  AsanTSDSet(t->context());
+  CHECK_EQ(t->context(), AsanTSDGet());
+}
+
+u32 GetCurrentTidOrInvalid() {
+  AsanThread *t = GetCurrentThread();
+  return t ? t->tid() : kInvalidTid;
+}
+
+AsanThread *FindThreadByStackAddress(uptr addr) {
+  asanThreadRegistry().CheckLocked();
+  AsanThreadContext *tctx = static_cast<AsanThreadContext *>(
+      asanThreadRegistry().FindThreadContextLocked(ThreadStackContainsAddress,
+                                                   (void *)addr));
+  return tctx ? tctx->thread : nullptr;
+}
+
+void EnsureMainThreadIDIsCorrect() {
+  AsanThreadContext *context =
+      reinterpret_cast<AsanThreadContext *>(AsanTSDGet());
+  if (context && (context->tid == 0))
+    context->os_id = GetTid();
+}
+
+__asan::AsanThread *GetAsanThreadByOsIDLocked(uptr os_id) {
+  __asan::AsanThreadContext *context = static_cast<__asan::AsanThreadContext *>(
+      __asan::asanThreadRegistry().FindThreadContextByOsIDLocked(os_id));
+  if (!context) return nullptr;
+  return context->thread;
+}
+} // namespace __asan
+
+// --- Implementation of LSan-specific functions --- {{{1
+namespace __lsan {
+bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
+                           uptr *tls_begin, uptr *tls_end,
+                           uptr *cache_begin, uptr *cache_end) {
+  __asan::AsanThread *t = __asan::GetAsanThreadByOsIDLocked(os_id);
+  if (!t) return false;
+  *stack_begin = t->stack_bottom();
+  *stack_end = t->stack_top();
+  *tls_begin = t->tls_begin();
+  *tls_end = t->tls_end();
+  // ASan doesn't keep allocator caches in TLS, so these are unused.
+  *cache_begin = 0;
+  *cache_end = 0;
+  return true;
+}
+
+void ForEachExtraStackRange(uptr os_id, RangeIteratorCallback callback,
+                            void *arg) {
+  __asan::AsanThread *t = __asan::GetAsanThreadByOsIDLocked(os_id);
+  if (t && t->has_fake_stack())
+    t->fake_stack()->ForEachFakeFrame(callback, arg);
+}
+
+void LockThreadRegistry() {
+  __asan::asanThreadRegistry().Lock();
+}
+
+void UnlockThreadRegistry() {
+  __asan::asanThreadRegistry().Unlock();
+}
+
+void EnsureMainThreadIDIsCorrect() {
+  __asan::EnsureMainThreadIDIsCorrect();
+}
+} // namespace __lsan
diff --git a/compiler-rt/lib/asan/asan_thread.h b/compiler-rt/lib/asan/asan_thread.h
new file mode 100644
index 0000000..ac35711
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_thread.h
@@ -0,0 +1,185 @@
+//===-- asan_thread.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_thread.cc.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_THREAD_H
+#define ASAN_THREAD_H
+
+#include "asan_allocator.h"
+#include "asan_internal.h"
+#include "asan_fake_stack.h"
+#include "asan_stats.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_thread_registry.h"
+
+namespace __asan {
+
+const u32 kInvalidTid = 0xffffff;  // Must fit into 24 bits.
+const u32 kMaxNumberOfThreads = (1 << 22);  // 4M
+
+class AsanThread;
+
+// These objects are created for every thread and are never deleted,
+// so we can find them by tid even if the thread is long dead.
+class AsanThreadContext : public ThreadContextBase {
+ public:
+  explicit AsanThreadContext(int tid)
+      : ThreadContextBase(tid), announced(false),
+        destructor_iterations(GetPthreadDestructorIterations()), stack_id(0),
+        thread(nullptr) {}
+  bool announced;
+  u8 destructor_iterations;
+  u32 stack_id;
+  AsanThread *thread;
+
+  void OnCreated(void *arg) override;
+  void OnFinished() override;
+};
+
+// AsanThreadContext objects are never freed, so we need many of them.
+COMPILER_CHECK(sizeof(AsanThreadContext) <= 256);
+
+// AsanThread are stored in TSD and destroyed when the thread dies.
+class AsanThread {
+ public:
+  static AsanThread *Create(thread_callback_t start_routine, void *arg,
+                            u32 parent_tid, StackTrace *stack, bool detached);
+  static void TSDDtor(void *tsd);
+  void Destroy();
+
+  void Init();  // Should be called from the thread itself.
+  thread_return_t ThreadStart(uptr os_id,
+                              atomic_uintptr_t *signal_thread_is_registered);
+
+  uptr stack_top() { return stack_top_; }
+  uptr stack_bottom() { return stack_bottom_; }
+  uptr stack_size() { return stack_size_; }
+  uptr tls_begin() { return tls_begin_; }
+  uptr tls_end() { return tls_end_; }
+  u32 tid() { return context_->tid; }
+  AsanThreadContext *context() { return context_; }
+  void set_context(AsanThreadContext *context) { context_ = context; }
+
+  struct StackFrameAccess {
+    uptr offset;
+    uptr frame_pc;
+    const char *frame_descr;
+  };
+  bool GetStackFrameAccessByAddr(uptr addr, StackFrameAccess *access);
+
+  bool AddrIsInStack(uptr addr) {
+    return addr >= stack_bottom_ && addr < stack_top_;
+  }
+
+  void DeleteFakeStack(int tid) {
+    if (!fake_stack_) return;
+    FakeStack *t = fake_stack_;
+    fake_stack_ = nullptr;
+    SetTLSFakeStack(nullptr);
+    t->Destroy(tid);
+  }
+
+  bool has_fake_stack() {
+    return (reinterpret_cast<uptr>(fake_stack_) > 1);
+  }
+
+  FakeStack *fake_stack() {
+    if (!__asan_option_detect_stack_use_after_return)
+      return nullptr;
+    if (!has_fake_stack())
+      return AsyncSignalSafeLazyInitFakeStack();
+    return fake_stack_;
+  }
+
+  // True is this thread is currently unwinding stack (i.e. collecting a stack
+  // trace). Used to prevent deadlocks on platforms where libc unwinder calls
+  // malloc internally. See PR17116 for more details.
+  bool isUnwinding() const { return unwinding_; }
+  void setUnwinding(bool b) { unwinding_ = b; }
+
+  // True if we are in a deadly signal handler.
+  bool isInDeadlySignal() const { return in_deadly_signal_; }
+  void setInDeadlySignal(bool b) { in_deadly_signal_ = b; }
+
+  AsanThreadLocalMallocStorage &malloc_storage() { return malloc_storage_; }
+  AsanStats &stats() { return stats_; }
+
+ private:
+  // NOTE: There is no AsanThread constructor. It is allocated
+  // via mmap() and *must* be valid in zero-initialized state.
+  void SetThreadStackAndTls();
+  void ClearShadowForThreadStackAndTLS();
+  FakeStack *AsyncSignalSafeLazyInitFakeStack();
+
+  AsanThreadContext *context_;
+  thread_callback_t start_routine_;
+  void *arg_;
+  uptr stack_top_;
+  uptr stack_bottom_;
+  // stack_size_ == stack_top_ - stack_bottom_;
+  // It needs to be set in a async-signal-safe manner.
+  uptr stack_size_;
+  uptr tls_begin_;
+  uptr tls_end_;
+
+  FakeStack *fake_stack_;
+  AsanThreadLocalMallocStorage malloc_storage_;
+  AsanStats stats_;
+  bool unwinding_;
+  bool in_deadly_signal_;
+};
+
+// ScopedUnwinding is a scope for stacktracing member of a context
+class ScopedUnwinding {
+ public:
+  explicit ScopedUnwinding(AsanThread *t) : thread(t) {
+    t->setUnwinding(true);
+  }
+  ~ScopedUnwinding() { thread->setUnwinding(false); }
+
+ private:
+  AsanThread *thread;
+};
+
+// ScopedDeadlySignal is a scope for handling deadly signals.
+class ScopedDeadlySignal {
+ public:
+  explicit ScopedDeadlySignal(AsanThread *t) : thread(t) {
+    if (thread) thread->setInDeadlySignal(true);
+  }
+  ~ScopedDeadlySignal() {
+    if (thread) thread->setInDeadlySignal(false);
+  }
+
+ private:
+  AsanThread *thread;
+};
+
+// Returns a single instance of registry.
+ThreadRegistry &asanThreadRegistry();
+
+// Must be called under ThreadRegistryLock.
+AsanThreadContext *GetThreadContextByTidLocked(u32 tid);
+
+// Get the current thread. May return 0.
+AsanThread *GetCurrentThread();
+void SetCurrentThread(AsanThread *t);
+u32 GetCurrentTidOrInvalid();
+AsanThread *FindThreadByStackAddress(uptr addr);
+
+// Used to handle fork().
+void EnsureMainThreadIDIsCorrect();
+} // namespace __asan
+
+#endif // ASAN_THREAD_H
diff --git a/compiler-rt/lib/asan/asan_win.cc b/compiler-rt/lib/asan/asan_win.cc
new file mode 100644
index 0000000..92bd893
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_win.cc
@@ -0,0 +1,254 @@
+//===-- asan_win.cc -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Windows-specific details.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_WINDOWS
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#include <stdlib.h>
+
+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_report.h"
+#include "asan_stack.h"
+#include "asan_thread.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+
+using namespace __asan;  // NOLINT
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+int __asan_should_detect_stack_use_after_return() {
+  __asan_init();
+  return __asan_option_detect_stack_use_after_return;
+}
+
+// -------------------- A workaround for the abscence of weak symbols ----- {{{
+// We don't have a direct equivalent of weak symbols when using MSVC, but we can
+// use the /alternatename directive to tell the linker to default a specific
+// symbol to a specific value, which works nicely for allocator hooks and
+// __asan_default_options().
+void __sanitizer_default_malloc_hook(void *ptr, uptr size) { }
+void __sanitizer_default_free_hook(void *ptr) { }
+const char* __asan_default_default_options() { return ""; }
+const char* __asan_default_default_suppressions() { return ""; }
+void __asan_default_on_error() {}
+#pragma comment(linker, "/alternatename:___sanitizer_malloc_hook=___sanitizer_default_malloc_hook")  // NOLINT
+#pragma comment(linker, "/alternatename:___sanitizer_free_hook=___sanitizer_default_free_hook")      // NOLINT
+#pragma comment(linker, "/alternatename:___asan_default_options=___asan_default_default_options")    // NOLINT
+#pragma comment(linker, "/alternatename:___asan_default_suppressions=___asan_default_default_suppressions")    // NOLINT
+#pragma comment(linker, "/alternatename:___asan_on_error=___asan_default_on_error")                  // NOLINT
+// }}}
+}  // extern "C"
+
+// ---------------------- Windows-specific inteceptors ---------------- {{{
+INTERCEPTOR_WINAPI(void, RaiseException, void *a, void *b, void *c, void *d) {
+  CHECK(REAL(RaiseException));
+  __asan_handle_no_return();
+  REAL(RaiseException)(a, b, c, d);
+}
+
+INTERCEPTOR(int, _except_handler3, void *a, void *b, void *c, void *d) {
+  CHECK(REAL(_except_handler3));
+  __asan_handle_no_return();
+  return REAL(_except_handler3)(a, b, c, d);
+}
+
+#if ASAN_DYNAMIC
+// This handler is named differently in -MT and -MD CRTs.
+#define _except_handler4 _except_handler4_common
+#endif
+INTERCEPTOR(int, _except_handler4, void *a, void *b, void *c, void *d) {
+  CHECK(REAL(_except_handler4));
+  __asan_handle_no_return();
+  return REAL(_except_handler4)(a, b, c, d);
+}
+
+static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
+  AsanThread *t = (AsanThread*)arg;
+  SetCurrentThread(t);
+  return t->ThreadStart(GetTid(), /* signal_thread_is_registered */ nullptr);
+}
+
+INTERCEPTOR_WINAPI(DWORD, CreateThread,
+                   void* security, uptr stack_size,
+                   DWORD (__stdcall *start_routine)(void*), void* arg,
+                   DWORD thr_flags, void* tid) {
+  // Strict init-order checking is thread-hostile.
+  if (flags()->strict_init_order)
+    StopInitOrderChecking();
+  GET_STACK_TRACE_THREAD;
+  // FIXME: The CreateThread interceptor is not the same as a pthread_create
+  // one.  This is a bandaid fix for PR22025.
+  bool detached = false;  // FIXME: how can we determine it on Windows?
+  u32 current_tid = GetCurrentTidOrInvalid();
+  AsanThread *t =
+        AsanThread::Create(start_routine, arg, current_tid, &stack, detached);
+  return REAL(CreateThread)(security, stack_size,
+                            asan_thread_start, t, thr_flags, tid);
+}
+
+namespace {
+BlockingMutex mu_for_thread_tracking(LINKER_INITIALIZED);
+
+void EnsureWorkerThreadRegistered() {
+  // FIXME: GetCurrentThread relies on TSD, which might not play well with
+  // system thread pools.  We might want to use something like reference
+  // counting to zero out GetCurrentThread() underlying storage when the last
+  // work item finishes?  Or can we disable reclaiming of threads in the pool?
+  BlockingMutexLock l(&mu_for_thread_tracking);
+  if (__asan::GetCurrentThread())
+    return;
+
+  AsanThread *t = AsanThread::Create(
+      /* start_routine */ nullptr, /* arg */ nullptr,
+      /* parent_tid */ -1, /* stack */ nullptr, /* detached */ true);
+  t->Init();
+  asanThreadRegistry().StartThread(t->tid(), 0, 0);
+  SetCurrentThread(t);
+}
+}  // namespace
+
+INTERCEPTOR_WINAPI(DWORD, NtWaitForWorkViaWorkerFactory, DWORD a, DWORD b) {
+  // NtWaitForWorkViaWorkerFactory is called from system worker pool threads to
+  // query work scheduled by BindIoCompletionCallback, QueueUserWorkItem, etc.
+  // System worker pool threads are created at arbitraty point in time and
+  // without using CreateThread, so we wrap NtWaitForWorkViaWorkerFactory
+  // instead and don't register a specific parent_tid/stack.
+  EnsureWorkerThreadRegistered();
+  return REAL(NtWaitForWorkViaWorkerFactory)(a, b);
+}
+
+// }}}
+
+namespace __asan {
+
+void InitializePlatformInterceptors() {
+  ASAN_INTERCEPT_FUNC(CreateThread);
+  ASAN_INTERCEPT_FUNC(RaiseException);
+  ASAN_INTERCEPT_FUNC(_except_handler3);
+  ASAN_INTERCEPT_FUNC(_except_handler4);
+
+  // NtWaitForWorkViaWorkerFactory is always linked dynamically.
+  CHECK(::__interception::OverrideFunction(
+      "NtWaitForWorkViaWorkerFactory",
+      (uptr)WRAP(NtWaitForWorkViaWorkerFactory),
+      (uptr *)&REAL(NtWaitForWorkViaWorkerFactory)));
+}
+
+// ---------------------- TSD ---------------- {{{
+static bool tsd_key_inited = false;
+
+static __declspec(thread) void *fake_tsd = 0;
+
+void AsanTSDInit(void (*destructor)(void *tsd)) {
+  // FIXME: we're ignoring the destructor for now.
+  tsd_key_inited = true;
+}
+
+void *AsanTSDGet() {
+  CHECK(tsd_key_inited);
+  return fake_tsd;
+}
+
+void AsanTSDSet(void *tsd) {
+  CHECK(tsd_key_inited);
+  fake_tsd = tsd;
+}
+
+void PlatformTSDDtor(void *tsd) {
+  AsanThread::TSDDtor(tsd);
+}
+// }}}
+
+// ---------------------- Various stuff ---------------- {{{
+void *AsanDoesNotSupportStaticLinkage() {
+#if defined(_DEBUG)
+#error Please build the runtime with a non-debug CRT: /MD or /MT
+#endif
+  return 0;
+}
+
+void AsanCheckDynamicRTPrereqs() {}
+
+void AsanCheckIncompatibleRT() {}
+
+void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
+  UNIMPLEMENTED();
+}
+
+void AsanOnDeadlySignal(int, void *siginfo, void *context) {
+  UNIMPLEMENTED();
+}
+
+static LPTOP_LEVEL_EXCEPTION_FILTER default_seh_handler;
+
+static long WINAPI SEHHandler(EXCEPTION_POINTERS *info) {
+  EXCEPTION_RECORD *exception_record = info->ExceptionRecord;
+  CONTEXT *context = info->ContextRecord;
+
+  if (exception_record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
+      exception_record->ExceptionCode == EXCEPTION_IN_PAGE_ERROR) {
+    const char *description =
+        (exception_record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
+            ? "access-violation"
+            : "in-page-error";
+    SignalContext sig = SignalContext::Create(exception_record, context);
+    ReportDeadlySignal(description, sig);
+  }
+
+  // FIXME: Handle EXCEPTION_STACK_OVERFLOW here.
+
+  return default_seh_handler(info);
+}
+
+// We want to install our own exception handler (EH) to print helpful reports
+// on access violations and whatnot.  Unfortunately, the CRT initializers assume
+// they are run before any user code and drop any previously-installed EHs on
+// the floor, so we can't install our handler inside __asan_init.
+// (See crt0dat.c in the CRT sources for the details)
+//
+// Things get even more complicated with the dynamic runtime, as it finishes its
+// initialization before the .exe module CRT begins to initialize.
+//
+// For the static runtime (-MT), it's enough to put a callback to
+// __asan_set_seh_filter in the last section for C initializers.
+//
+// For the dynamic runtime (-MD), we want link the same
+// asan_dynamic_runtime_thunk.lib to all the modules, thus __asan_set_seh_filter
+// will be called for each instrumented module.  This ensures that at least one
+// __asan_set_seh_filter call happens after the .exe module CRT is initialized.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+int __asan_set_seh_filter() {
+  // We should only store the previous handler if it's not our own handler in
+  // order to avoid loops in the EH chain.
+  auto prev_seh_handler = SetUnhandledExceptionFilter(SEHHandler);
+  if (prev_seh_handler != &SEHHandler)
+    default_seh_handler = prev_seh_handler;
+  return 0;
+}
+
+#if !ASAN_DYNAMIC
+// Put a pointer to __asan_set_seh_filter at the end of the global list
+// of C initializers, after the default EH is set by the CRT.
+#pragma section(".CRT$XIZ", long, read)  // NOLINT
+__declspec(allocate(".CRT$XIZ"))
+    int (*__intercept_seh)() = __asan_set_seh_filter;
+#endif
+// }}}
+}  // namespace __asan
+
+#endif  // _WIN32
diff --git a/compiler-rt/lib/asan/asan_win_dll_thunk.cc b/compiler-rt/lib/asan/asan_win_dll_thunk.cc
new file mode 100644
index 0000000..308196d
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_win_dll_thunk.cc
@@ -0,0 +1,426 @@
+//===-- asan_win_dll_thunk.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This file defines a family of thunks that should be statically linked into
+// the DLLs that have ASan instrumentation in order to delegate the calls to the
+// shared runtime that lives in the main binary.
+// See https://github.com/google/sanitizers/issues/209 for the details.
+//===----------------------------------------------------------------------===//
+
+// Only compile this code when buidling asan_dll_thunk.lib
+// Using #ifdef rather than relying on Makefiles etc.
+// simplifies the build procedure.
+#ifdef ASAN_DLL_THUNK
+#include "asan_init_version.h"
+#include "interception/interception.h"
+
+// ---------- Function interception helper functions and macros ----------- {{{1
+extern "C" {
+void *__stdcall GetModuleHandleA(const char *module_name);
+void *__stdcall GetProcAddress(void *module, const char *proc_name);
+void abort();
+}
+
+static uptr getRealProcAddressOrDie(const char *name) {
+  uptr ret =
+      __interception::InternalGetProcAddress((void *)GetModuleHandleA(0), name);
+  if (!ret)
+    abort();
+  return ret;
+}
+
+// We need to intercept some functions (e.g. ASan interface, memory allocator --
+// let's call them "hooks") exported by the DLL thunk and forward the hooks to
+// the runtime in the main module.
+// However, we don't want to keep two lists of these hooks.
+// To avoid that, the list of hooks should be defined using the
+// INTERCEPT_WHEN_POSSIBLE macro. Then, all these hooks can be intercepted
+// at once by calling INTERCEPT_HOOKS().
+
+// Use macro+template magic to automatically generate the list of hooks.
+// Each hook at line LINE defines a template class with a static
+// FunctionInterceptor<LINE>::Execute() method intercepting the hook.
+// The default implementation of FunctionInterceptor<LINE> is to call
+// the Execute() method corresponding to the previous line.
+template<int LINE>
+struct FunctionInterceptor {
+  static void Execute() { FunctionInterceptor<LINE-1>::Execute(); }
+};
+
+// There shouldn't be any hooks with negative definition line number.
+template<>
+struct FunctionInterceptor<0> {
+  static void Execute() {}
+};
+
+#define INTERCEPT_WHEN_POSSIBLE(main_function, dll_function)                   \
+  template <> struct FunctionInterceptor<__LINE__> {                           \
+    static void Execute() {                                                    \
+      uptr wrapper = getRealProcAddressOrDie(main_function);                   \
+      if (!__interception::OverrideFunction((uptr)dll_function, wrapper, 0))   \
+        abort();                                                               \
+      FunctionInterceptor<__LINE__ - 1>::Execute();                            \
+    }                                                                          \
+  };
+
+// Special case of hooks -- ASan own interface functions.  Those are only called
+// after __asan_init, thus an empty implementation is sufficient.
+#define INTERFACE_FUNCTION(name)                                               \
+  extern "C" __declspec(noinline) void name() {                                \
+    volatile int prevent_icf = (__LINE__ << 8); (void)prevent_icf;             \
+    __debugbreak();                                                            \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name)
+
+// INTERCEPT_HOOKS must be used after the last INTERCEPT_WHEN_POSSIBLE.
+#define INTERCEPT_HOOKS FunctionInterceptor<__LINE__>::Execute
+
+// We can't define our own version of strlen etc. because that would lead to
+// link-time or even type mismatch errors.  Instead, we can declare a function
+// just to be able to get its address.  Me may miss the first few calls to the
+// functions since it can be called before __asan_init, but that would lead to
+// false negatives in the startup code before user's global initializers, which
+// isn't a big deal.
+#define INTERCEPT_LIBRARY_FUNCTION(name)                                       \
+  extern "C" void name();                                                      \
+  INTERCEPT_WHEN_POSSIBLE(WRAPPER_NAME(name), name)
+
+// Disable compiler warnings that show up if we declare our own version
+// of a compiler intrinsic (e.g. strlen).
+#pragma warning(disable: 4391)
+#pragma warning(disable: 4392)
+
+static void InterceptHooks();
+// }}}
+
+// ---------- Function wrapping helpers ----------------------------------- {{{1
+#define WRAP_V_V(name)                                                         \
+  extern "C" void name() {                                                     \
+    typedef void (*fntype)();                                                  \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    fn();                                                                      \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_V_W(name)                                                         \
+  extern "C" void name(void *arg) {                                            \
+    typedef void (*fntype)(void *arg);                                         \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    fn(arg);                                                                   \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_V_WW(name)                                                        \
+  extern "C" void name(void *arg1, void *arg2) {                               \
+    typedef void (*fntype)(void *, void *);                                    \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    fn(arg1, arg2);                                                            \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_V_WWW(name)                                                       \
+  extern "C" void name(void *arg1, void *arg2, void *arg3) {                   \
+    typedef void *(*fntype)(void *, void *, void *);                           \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    fn(arg1, arg2, arg3);                                                      \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_V(name)                                                         \
+  extern "C" void *name() {                                                    \
+    typedef void *(*fntype)();                                                 \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn();                                                               \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_W(name)                                                         \
+  extern "C" void *name(void *arg) {                                           \
+    typedef void *(*fntype)(void *arg);                                        \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn(arg);                                                            \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_WW(name)                                                        \
+  extern "C" void *name(void *arg1, void *arg2) {                              \
+    typedef void *(*fntype)(void *, void *);                                   \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn(arg1, arg2);                                                     \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_WWW(name)                                                       \
+  extern "C" void *name(void *arg1, void *arg2, void *arg3) {                  \
+    typedef void *(*fntype)(void *, void *, void *);                           \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn(arg1, arg2, arg3);                                               \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_WWWW(name)                                                      \
+  extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4) {      \
+    typedef void *(*fntype)(void *, void *, void *, void *);                   \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn(arg1, arg2, arg3, arg4);                                         \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_WWWWW(name)                                                     \
+  extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4,        \
+                        void *arg5) {                                          \
+    typedef void *(*fntype)(void *, void *, void *, void *, void *);           \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn(arg1, arg2, arg3, arg4, arg5);                                   \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+
+#define WRAP_W_WWWWWW(name)                                                    \
+  extern "C" void *name(void *arg1, void *arg2, void *arg3, void *arg4,        \
+                        void *arg5, void *arg6) {                              \
+    typedef void *(*fntype)(void *, void *, void *, void *, void *, void *);   \
+    static fntype fn = (fntype)getRealProcAddressOrDie(#name);                 \
+    return fn(arg1, arg2, arg3, arg4, arg5, arg6);                             \
+  }                                                                            \
+  INTERCEPT_WHEN_POSSIBLE(#name, name);
+// }}}
+
+// ----------------- ASan own interface functions --------------------
+// Don't use the INTERFACE_FUNCTION machinery for this function as we actually
+// want to call it in the __asan_init interceptor.
+WRAP_W_V(__asan_should_detect_stack_use_after_return)
+
+extern "C" {
+  int __asan_option_detect_stack_use_after_return;
+
+  // Manually wrap __asan_init as we need to initialize
+  // __asan_option_detect_stack_use_after_return afterwards.
+  void __asan_init() {
+    typedef void (*fntype)();
+    static fntype fn = 0;
+    // __asan_init is expected to be called by only one thread.
+    if (fn) return;
+
+    fn = (fntype)getRealProcAddressOrDie("__asan_init");
+    fn();
+    __asan_option_detect_stack_use_after_return =
+        (__asan_should_detect_stack_use_after_return() != 0);
+
+    InterceptHooks();
+  }
+}
+
+extern "C" void __asan_version_mismatch_check() {
+  // Do nothing.
+}
+
+INTERFACE_FUNCTION(__asan_handle_no_return)
+
+INTERFACE_FUNCTION(__asan_report_store1)
+INTERFACE_FUNCTION(__asan_report_store2)
+INTERFACE_FUNCTION(__asan_report_store4)
+INTERFACE_FUNCTION(__asan_report_store8)
+INTERFACE_FUNCTION(__asan_report_store16)
+INTERFACE_FUNCTION(__asan_report_store_n)
+
+INTERFACE_FUNCTION(__asan_report_load1)
+INTERFACE_FUNCTION(__asan_report_load2)
+INTERFACE_FUNCTION(__asan_report_load4)
+INTERFACE_FUNCTION(__asan_report_load8)
+INTERFACE_FUNCTION(__asan_report_load16)
+INTERFACE_FUNCTION(__asan_report_load_n)
+
+INTERFACE_FUNCTION(__asan_store1)
+INTERFACE_FUNCTION(__asan_store2)
+INTERFACE_FUNCTION(__asan_store4)
+INTERFACE_FUNCTION(__asan_store8)
+INTERFACE_FUNCTION(__asan_store16)
+INTERFACE_FUNCTION(__asan_storeN)
+
+INTERFACE_FUNCTION(__asan_load1)
+INTERFACE_FUNCTION(__asan_load2)
+INTERFACE_FUNCTION(__asan_load4)
+INTERFACE_FUNCTION(__asan_load8)
+INTERFACE_FUNCTION(__asan_load16)
+INTERFACE_FUNCTION(__asan_loadN)
+
+INTERFACE_FUNCTION(__asan_memcpy);
+INTERFACE_FUNCTION(__asan_memset);
+INTERFACE_FUNCTION(__asan_memmove);
+
+INTERFACE_FUNCTION(__asan_alloca_poison);
+INTERFACE_FUNCTION(__asan_allocas_unpoison);
+
+INTERFACE_FUNCTION(__asan_register_globals)
+INTERFACE_FUNCTION(__asan_unregister_globals)
+
+INTERFACE_FUNCTION(__asan_before_dynamic_init)
+INTERFACE_FUNCTION(__asan_after_dynamic_init)
+
+INTERFACE_FUNCTION(__asan_poison_stack_memory)
+INTERFACE_FUNCTION(__asan_unpoison_stack_memory)
+
+INTERFACE_FUNCTION(__asan_poison_memory_region)
+INTERFACE_FUNCTION(__asan_unpoison_memory_region)
+
+INTERFACE_FUNCTION(__asan_address_is_poisoned)
+INTERFACE_FUNCTION(__asan_region_is_poisoned)
+
+INTERFACE_FUNCTION(__asan_get_current_fake_stack)
+INTERFACE_FUNCTION(__asan_addr_is_in_fake_stack)
+
+INTERFACE_FUNCTION(__asan_stack_malloc_0)
+INTERFACE_FUNCTION(__asan_stack_malloc_1)
+INTERFACE_FUNCTION(__asan_stack_malloc_2)
+INTERFACE_FUNCTION(__asan_stack_malloc_3)
+INTERFACE_FUNCTION(__asan_stack_malloc_4)
+INTERFACE_FUNCTION(__asan_stack_malloc_5)
+INTERFACE_FUNCTION(__asan_stack_malloc_6)
+INTERFACE_FUNCTION(__asan_stack_malloc_7)
+INTERFACE_FUNCTION(__asan_stack_malloc_8)
+INTERFACE_FUNCTION(__asan_stack_malloc_9)
+INTERFACE_FUNCTION(__asan_stack_malloc_10)
+
+INTERFACE_FUNCTION(__asan_stack_free_0)
+INTERFACE_FUNCTION(__asan_stack_free_1)
+INTERFACE_FUNCTION(__asan_stack_free_2)
+INTERFACE_FUNCTION(__asan_stack_free_4)
+INTERFACE_FUNCTION(__asan_stack_free_5)
+INTERFACE_FUNCTION(__asan_stack_free_6)
+INTERFACE_FUNCTION(__asan_stack_free_7)
+INTERFACE_FUNCTION(__asan_stack_free_8)
+INTERFACE_FUNCTION(__asan_stack_free_9)
+INTERFACE_FUNCTION(__asan_stack_free_10)
+
+// FIXME: we might want to have a sanitizer_win_dll_thunk?
+INTERFACE_FUNCTION(__sanitizer_annotate_contiguous_container)
+INTERFACE_FUNCTION(__sanitizer_contiguous_container_find_bad_address)
+INTERFACE_FUNCTION(__sanitizer_cov)
+INTERFACE_FUNCTION(__sanitizer_cov_dump)
+INTERFACE_FUNCTION(__sanitizer_cov_indir_call16)
+INTERFACE_FUNCTION(__sanitizer_cov_init)
+INTERFACE_FUNCTION(__sanitizer_cov_module_init)
+INTERFACE_FUNCTION(__sanitizer_cov_trace_basic_block)
+INTERFACE_FUNCTION(__sanitizer_cov_trace_func_enter)
+INTERFACE_FUNCTION(__sanitizer_cov_trace_cmp)
+INTERFACE_FUNCTION(__sanitizer_cov_trace_switch)
+INTERFACE_FUNCTION(__sanitizer_cov_with_check)
+INTERFACE_FUNCTION(__sanitizer_get_allocated_size)
+INTERFACE_FUNCTION(__sanitizer_get_coverage_guards)
+INTERFACE_FUNCTION(__sanitizer_get_current_allocated_bytes)
+INTERFACE_FUNCTION(__sanitizer_get_estimated_allocated_size)
+INTERFACE_FUNCTION(__sanitizer_get_free_bytes)
+INTERFACE_FUNCTION(__sanitizer_get_heap_size)
+INTERFACE_FUNCTION(__sanitizer_get_ownership)
+INTERFACE_FUNCTION(__sanitizer_get_total_unique_caller_callee_pairs)
+INTERFACE_FUNCTION(__sanitizer_get_total_unique_coverage)
+INTERFACE_FUNCTION(__sanitizer_get_unmapped_bytes)
+INTERFACE_FUNCTION(__sanitizer_maybe_open_cov_file)
+INTERFACE_FUNCTION(__sanitizer_print_stack_trace)
+INTERFACE_FUNCTION(__sanitizer_ptr_cmp)
+INTERFACE_FUNCTION(__sanitizer_ptr_sub)
+INTERFACE_FUNCTION(__sanitizer_report_error_summary)
+INTERFACE_FUNCTION(__sanitizer_reset_coverage)
+INTERFACE_FUNCTION(__sanitizer_get_number_of_counters)
+INTERFACE_FUNCTION(__sanitizer_update_counter_bitset_and_clear_counters)
+INTERFACE_FUNCTION(__sanitizer_sandbox_on_notify)
+INTERFACE_FUNCTION(__sanitizer_set_death_callback)
+INTERFACE_FUNCTION(__sanitizer_set_report_path)
+INTERFACE_FUNCTION(__sanitizer_unaligned_load16)
+INTERFACE_FUNCTION(__sanitizer_unaligned_load32)
+INTERFACE_FUNCTION(__sanitizer_unaligned_load64)
+INTERFACE_FUNCTION(__sanitizer_unaligned_store16)
+INTERFACE_FUNCTION(__sanitizer_unaligned_store32)
+INTERFACE_FUNCTION(__sanitizer_unaligned_store64)
+INTERFACE_FUNCTION(__sanitizer_verify_contiguous_container)
+
+// TODO(timurrrr): Add more interface functions on the as-needed basis.
+
+// ----------------- Memory allocation functions ---------------------
+WRAP_V_W(free)
+WRAP_V_WW(_free_dbg)
+
+WRAP_W_W(malloc)
+WRAP_W_WWWW(_malloc_dbg)
+
+WRAP_W_WW(calloc)
+WRAP_W_WWWWW(_calloc_dbg)
+WRAP_W_WWW(_calloc_impl)
+
+WRAP_W_WW(realloc)
+WRAP_W_WWW(_realloc_dbg)
+WRAP_W_WWW(_recalloc)
+
+WRAP_W_W(_msize)
+WRAP_W_W(_expand)
+WRAP_W_W(_expand_dbg)
+
+// TODO(timurrrr): Might want to add support for _aligned_* allocation
+// functions to detect a bit more bugs.  Those functions seem to wrap malloc().
+
+// TODO(timurrrr): Do we need to add _Crt* stuff here? (see asan_malloc_win.cc).
+
+INTERCEPT_LIBRARY_FUNCTION(atoi);
+INTERCEPT_LIBRARY_FUNCTION(atol);
+INTERCEPT_LIBRARY_FUNCTION(_except_handler3);
+
+// _except_handler4 checks -GS cookie which is different for each module, so we
+// can't use INTERCEPT_LIBRARY_FUNCTION(_except_handler4).
+INTERCEPTOR(int, _except_handler4, void *a, void *b, void *c, void *d) {
+  __asan_handle_no_return();
+  return REAL(_except_handler4)(a, b, c, d);
+}
+
+INTERCEPT_LIBRARY_FUNCTION(frexp);
+INTERCEPT_LIBRARY_FUNCTION(longjmp);
+INTERCEPT_LIBRARY_FUNCTION(memchr);
+INTERCEPT_LIBRARY_FUNCTION(memcmp);
+INTERCEPT_LIBRARY_FUNCTION(memcpy);
+INTERCEPT_LIBRARY_FUNCTION(memmove);
+INTERCEPT_LIBRARY_FUNCTION(memset);
+INTERCEPT_LIBRARY_FUNCTION(strcat);  // NOLINT
+INTERCEPT_LIBRARY_FUNCTION(strchr);
+INTERCEPT_LIBRARY_FUNCTION(strcmp);
+INTERCEPT_LIBRARY_FUNCTION(strcpy);  // NOLINT
+INTERCEPT_LIBRARY_FUNCTION(strcspn);
+INTERCEPT_LIBRARY_FUNCTION(strlen);
+INTERCEPT_LIBRARY_FUNCTION(strncat);
+INTERCEPT_LIBRARY_FUNCTION(strncmp);
+INTERCEPT_LIBRARY_FUNCTION(strncpy);
+INTERCEPT_LIBRARY_FUNCTION(strnlen);
+INTERCEPT_LIBRARY_FUNCTION(strpbrk);
+INTERCEPT_LIBRARY_FUNCTION(strspn);
+INTERCEPT_LIBRARY_FUNCTION(strstr);
+INTERCEPT_LIBRARY_FUNCTION(strtol);
+INTERCEPT_LIBRARY_FUNCTION(wcslen);
+
+// Must be after all the interceptor declarations due to the way INTERCEPT_HOOKS
+// is defined.
+void InterceptHooks() {
+  INTERCEPT_HOOKS();
+  INTERCEPT_FUNCTION(_except_handler4);
+}
+
+// We want to call __asan_init before C/C++ initializers/constructors are
+// executed, otherwise functions like memset might be invoked.
+// For some strange reason, merely linking in asan_preinit.cc doesn't work
+// as the callback is never called...  Is link.exe doing something too smart?
+
+// In DLLs, the callbacks are expected to return 0,
+// otherwise CRT initialization fails.
+static int call_asan_init() {
+  __asan_init();
+  return 0;
+}
+#pragma section(".CRT$XIB", long, read)  // NOLINT
+__declspec(allocate(".CRT$XIB")) int (*__asan_preinit)() = call_asan_init;
+
+#endif // ASAN_DLL_THUNK
diff --git a/compiler-rt/lib/asan/asan_win_dynamic_runtime_thunk.cc b/compiler-rt/lib/asan/asan_win_dynamic_runtime_thunk.cc
new file mode 100644
index 0000000..73e5207
--- /dev/null
+++ b/compiler-rt/lib/asan/asan_win_dynamic_runtime_thunk.cc
@@ -0,0 +1,99 @@
+//===-- asan_win_uar_thunk.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This file defines things that need to be present in the application modules
+// to interact with the ASan DLL runtime correctly and can't be implemented
+// using the default "import library" generated when linking the DLL RTL.
+//
+// This includes:
+//  - forwarding the detect_stack_use_after_return runtime option
+//  - working around deficiencies of the MD runtime
+//  - installing a custom SEH handlerx
+//
+//===----------------------------------------------------------------------===//
+
+// Only compile this code when buidling asan_dynamic_runtime_thunk.lib
+// Using #ifdef rather than relying on Makefiles etc.
+// simplifies the build procedure.
+#ifdef ASAN_DYNAMIC_RUNTIME_THUNK
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+// First, declare CRT sections we'll be using in this file
+#pragma section(".CRT$XID", long, read)  // NOLINT
+#pragma section(".CRT$XIZ", long, read)  // NOLINT
+#pragma section(".CRT$XTW", long, read)  // NOLINT
+#pragma section(".CRT$XTY", long, read)  // NOLINT
+
+////////////////////////////////////////////////////////////////////////////////
+// Define a copy of __asan_option_detect_stack_use_after_return that should be
+// used when linking an MD runtime with a set of object files on Windows.
+//
+// The ASan MD runtime dllexports '__asan_option_detect_stack_use_after_return',
+// so normally we would just dllimport it.  Unfortunately, the dllimport
+// attribute adds __imp_ prefix to the symbol name of a variable.
+// Since in general we don't know if a given TU is going to be used
+// with a MT or MD runtime and we don't want to use ugly __imp_ names on Windows
+// just to work around this issue, let's clone the a variable that is
+// constant after initialization anyways.
+extern "C" {
+__declspec(dllimport) int __asan_should_detect_stack_use_after_return();
+int __asan_option_detect_stack_use_after_return =
+    __asan_should_detect_stack_use_after_return();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// For some reason, the MD CRT doesn't call the C/C++ terminators during on DLL
+// unload or on exit.  ASan relies on LLVM global_dtors to call
+// __asan_unregister_globals on these events, which unfortunately doesn't work
+// with the MD runtime, see PR22545 for the details.
+// To work around this, for each DLL we schedule a call to UnregisterGlobals
+// using atexit() that calls a small subset of C terminators
+// where LLVM global_dtors is placed.  Fingers crossed, no other C terminators
+// are there.
+extern "C" int __cdecl atexit(void (__cdecl *f)(void));
+extern "C" void __cdecl _initterm(void *a, void *b);
+
+namespace {
+__declspec(allocate(".CRT$XTW")) void* before_global_dtors = 0;
+__declspec(allocate(".CRT$XTY")) void* after_global_dtors = 0;
+
+void UnregisterGlobals() {
+  _initterm(&before_global_dtors, &after_global_dtors);
+}
+
+int ScheduleUnregisterGlobals() {
+  return atexit(UnregisterGlobals);
+}
+
+// We need to call 'atexit(UnregisterGlobals);' as early as possible, but after
+// atexit() is initialized (.CRT$XIC).  As this is executed before C++
+// initializers (think ctors for globals), UnregisterGlobals gets executed after
+// dtors for C++ globals.
+__declspec(allocate(".CRT$XID"))
+int (*__asan_schedule_unregister_globals)() = ScheduleUnregisterGlobals;
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// ASan SEH handling.
+// We need to set the ASan-specific SEH handler at the end of CRT initialization
+// of each module (see also asan_win.cc).
+extern "C" {
+__declspec(dllimport) int __asan_set_seh_filter();
+static int SetSEHFilter() { return __asan_set_seh_filter(); }
+
+// Unfortunately, putting a pointer to __asan_set_seh_filter into
+// __asan_intercept_seh gets optimized out, so we have to use an extra function.
+__declspec(allocate(".CRT$XIZ")) int (*__asan_seh_interceptor)() = SetSEHFilter;
+}
+
+#endif // ASAN_DYNAMIC_RUNTIME_THUNK
diff --git a/compiler-rt/lib/asan/asanwrapper.cc b/compiler-rt/lib/asan/asanwrapper.cc
new file mode 100644
index 0000000..f4da969
--- /dev/null
+++ b/compiler-rt/lib/asan/asanwrapper.cc
@@ -0,0 +1,85 @@
+#include <elf.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+
+void usage(const char* me) {
+  static const char* usage_s = "Usage:\n"
+    "  %s /system/bin/app_process <args>\n"
+    "or, better:\n"
+    "  setprop wrap.<nicename> %s\n";
+  fprintf(stderr, usage_s, me, me);
+  exit(1);
+}
+
+void env_prepend(const char* name, const char* value, const char* delim) {
+  const char* value_old = getenv(name);
+  std::string value_new = value;
+  if (value_old) {
+    value_new += delim;
+    value_new += value_old;
+  }
+  setenv(name, value_new.c_str(), 1);
+}
+
+bool elf_is_64bit(const char* path) {
+  int fd = open(path, O_RDONLY);
+  if (fd == -1) return false;
+
+  const size_t kBufSize = EI_CLASS + 1;
+  char buf[kBufSize];
+  ssize_t sz = read(fd, buf, kBufSize);
+  if (sz != kBufSize) {
+    close(fd);
+    return false;
+  }
+
+  if (buf[EI_MAG0] != ELFMAG0 || buf[EI_MAG1] != ELFMAG1 ||
+      buf[EI_MAG2] != ELFMAG2 || buf[EI_MAG3] != ELFMAG3)
+    return false;
+
+  bool is_64bit = buf[EI_CLASS] == ELFCLASS64;
+  close(fd);
+  return is_64bit;
+}
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    usage(argv[0]);
+  }
+  char** args = new char*[argc];
+  // If we are wrapping app_process, replace it with app_process_asan.
+  // TODO(eugenis): rewrite to <dirname>/asan/<basename>, if exists?
+  if (strcmp(argv[1], "/system/bin/app_process") == 0) {
+    args[0] = (char*)"/system/bin/asan/app_process";
+  } else if (strcmp(argv[1], "/system/bin/app_process32") == 0) {
+    args[0] = (char*)"/system/bin/asan/app_process32";
+  } else if (strcmp(argv[1], "/system/bin/app_process64") == 0) {
+    args[0] = (char*)"/system/bin/asan/app_process64";
+  } else {
+    args[0] = argv[1];
+  }
+
+  for (int i = 1; i < argc - 1; ++i)
+    args[i] = argv[i + 1];
+  args[argc - 1] = 0;
+
+  if (elf_is_64bit(args[0])) {
+    env_prepend("LD_LIBRARY_PATH", "/system/lib64/asan:/system/lib64", ":");
+  } else {
+    env_prepend("LD_LIBRARY_PATH", "/system/lib/asan:/system/lib", ":");
+  }
+  env_prepend("ASAN_OPTIONS", "allow_user_segv_handler=1", ",");
+
+  printf("ASAN_OPTIONS: %s\n", getenv("ASAN_OPTIONS"));
+  printf("LD_LIBRARY_PATH: %s\n", getenv("LD_LIBRARY_PATH"));
+  for (int i = 0; i < argc - 1; ++i)
+    printf("argv[%d] = %s\n", i, args[i]);
+
+  execv(args[0], args);
+}
diff --git a/compiler-rt/lib/asan/scripts/CMakeLists.txt b/compiler-rt/lib/asan/scripts/CMakeLists.txt
new file mode 100644
index 0000000..e5ab8eb
--- /dev/null
+++ b/compiler-rt/lib/asan/scripts/CMakeLists.txt
@@ -0,0 +1,4 @@
+if(ANDROID)
+  add_compiler_rt_script(asan_device_setup)
+  add_dependencies(asan asan_device_setup)
+endif()
diff --git a/compiler-rt/lib/asan/scripts/asan_device_setup b/compiler-rt/lib/asan/scripts/asan_device_setup
new file mode 100755
index 0000000..6cb7b94
--- /dev/null
+++ b/compiler-rt/lib/asan/scripts/asan_device_setup
@@ -0,0 +1,434 @@
+#!/bin/bash
+#===- lib/asan/scripts/asan_device_setup -----------------------------------===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+# Prepare Android device to run ASan applications.
+#
+#===------------------------------------------------------------------------===#
+
+set -e
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+
+revert=no
+extra_options=
+device=
+lib=
+use_su=0
+
+function usage {
+    echo "usage: $0 [--revert] [--device device-id] [--lib path] [--extra-options options]"
+    echo "  --revert: Uninstall ASan from the device."
+    echo "  --lib: Path to ASan runtime library."
+    echo "  --extra-options: Extra ASAN_OPTIONS."
+    echo "  --device: Install to the given device. Use 'adb devices' to find"
+    echo "            device-id."
+    echo "  --use-su: Use 'su -c' prefix for every adb command instead of using"
+    echo "            'adb root' once."
+    echo
+    exit 1
+}
+
+function adb_push {
+  if [ $use_su -eq 0 ]; then
+    $ADB push "$1" "$2"
+  else
+    local FILENAME=$(basename $1)
+    $ADB push "$1" "/data/local/tmp/$FILENAME"
+    $ADB shell su -c "rm \\\"$2/$FILENAME\\\"" >&/dev/null
+    $ADB shell su -c "cat \\\"/data/local/tmp/$FILENAME\\\" > \\\"$2/$FILENAME\\\""
+    $ADB shell su -c "rm \\\"/data/local/tmp/$FILENAME\\\""
+  fi
+}
+
+function adb_remount {
+  if [ $use_su -eq 0 ]; then
+    $ADB remount
+  else
+    local STORAGE=`$ADB shell mount | grep /system | cut -d ' ' -f1`
+    if [ "$STORAGE" != "" ]; then
+      echo Remounting $STORAGE at /system
+      $ADB shell su -c "mount -o remount,rw $STORAGE /system"
+    else
+      echo Failed to get storage device name for "/system" mount point
+    fi
+  fi
+}
+
+function adb_shell {
+  if [ $use_su -eq 0 ]; then
+    $ADB shell $@
+  else
+    $ADB shell su -c "$*"
+  fi
+}
+
+function adb_root {
+  if [ $use_su -eq 0 ]; then
+    $ADB root
+  fi
+}
+
+function adb_wait_for_device {
+  $ADB wait-for-device
+}
+
+function adb_pull {
+  if [ $use_su -eq 0 ]; then
+    $ADB pull "$1" "$2"
+  else
+    local FILENAME=$(basename $1)
+    $ADB shell rm "/data/local/tmp/$FILENAME" >&/dev/null
+    $ADB shell su -c "[ -f \\\"$1\\\" ] && cat \\\"$1\\\" > \\\"/data/local/tmp/$FILENAME\\\" && chown root.shell \\\"/data/local/tmp/$FILENAME\\\" && chmod 755 \\\"/data/local/tmp/$FILENAME\\\"" &&
+    $ADB pull "/data/local/tmp/$FILENAME" "$2" >&/dev/null && $ADB shell "rm \"/data/local/tmp/$FILENAME\""
+  fi
+}
+
+function get_device_arch { # OUT OUT64
+    local _outvar=$1
+    local _outvar64=$2
+    local _ABI=$(adb_shell getprop ro.product.cpu.abi)
+    local _ARCH=
+    local _ARCH64=
+    if [[ $_ABI == x86* ]]; then
+        _ARCH=i686
+    elif [[ $_ABI == armeabi* ]]; then
+        _ARCH=arm
+    elif [[ $_ABI == arm64-v8a* ]]; then
+        _ARCH=arm
+        _ARCH64=aarch64
+    else
+        echo "Unrecognized device ABI: $_ABI"
+        exit 1
+    fi
+    eval $_outvar=\$_ARCH
+    eval $_outvar64=\$_ARCH64
+}
+
+while [[ $# > 0 ]]; do
+  case $1 in
+    --revert)
+      revert=yes
+      ;;
+    --extra-options)
+      shift
+      if [[ $# == 0 ]]; then
+        echo "--extra-options requires an argument."
+        exit 1
+      fi
+      extra_options="$1"
+      ;;
+    --lib)
+      shift
+      if [[ $# == 0 ]]; then
+        echo "--lib requires an argument."
+        exit 1
+      fi
+      lib="$1"
+      ;;
+    --device)
+      shift
+      if [[ $# == 0 ]]; then
+        echo "--device requires an argument."
+        exit 1
+      fi
+      device="$1"
+      ;;
+    --use-su)
+      use_su=1
+      ;;
+    *)
+      usage
+      ;;
+  esac
+  shift
+done
+
+ADB=${ADB:-adb}
+if [[ x$device != x ]]; then
+    ADB="$ADB -s $device"
+fi
+
+if [ $use_su -eq 1 ]; then
+  # Test if 'su' is present on the device
+  SU_TEST_OUT=`$ADB shell su -c "echo foo" 2>&1 | sed 's/\r$//'`
+  if [ $? != 0 -o "$SU_TEST_OUT" != "foo" ]; then
+    echo "ERROR: Cannot use 'su -c':"
+    echo "$ adb shell su -c \"echo foo\""
+    echo $SU_TEST_OUT
+    echo "Check that 'su' binary is correctly installed on the device or omit"
+    echo "            --use-su flag"
+    exit 1
+  fi
+fi
+
+echo '>> Remounting /system rw'
+adb_wait_for_device
+adb_root
+adb_wait_for_device
+adb_remount
+adb_wait_for_device
+
+get_device_arch ARCH ARCH64
+echo "Target architecture: $ARCH"
+ASAN_RT="libclang_rt.asan-$ARCH-android.so"
+if [[ -n $ARCH64 ]]; then
+  echo "Target architecture: $ARCH64"
+  ASAN_RT64="libclang_rt.asan-$ARCH64-android.so"
+fi
+
+if [[ x$revert == xyes ]]; then
+    echo '>> Uninstalling ASan'
+
+    if ! adb_shell ls -l /system/bin/app_process | grep -o '\->.*app_process' >&/dev/null; then
+      echo '>> Pre-L device detected.'
+      adb_shell mv /system/bin/app_process.real /system/bin/app_process
+      adb_shell rm /system/bin/asanwrapper
+    elif ! adb_shell ls -l /system/bin/app_process64.real | grep -o 'No such file or directory' >&/dev/null; then
+      # 64-bit installation.
+      adb_shell mv /system/bin/app_process32.real /system/bin/app_process32
+      adb_shell mv /system/bin/app_process64.real /system/bin/app_process64
+      adb_shell rm /system/bin/asanwrapper
+      adb_shell rm /system/bin/asanwrapper64
+    else
+      # 32-bit installation.
+      adb_shell rm /system/bin/app_process.wrap
+      adb_shell rm /system/bin/asanwrapper
+      adb_shell rm /system/bin/app_process
+      adb_shell ln -s /system/bin/app_process32 /system/bin/app_process
+    fi
+
+    echo '>> Restarting shell'
+    adb_shell stop
+    adb_shell start
+
+    # Remove the library on the last step to give a chance to the 'su' binary to
+    # be executed without problem.
+    adb_shell rm /system/lib/$ASAN_RT
+
+    echo '>> Done'
+    exit 0
+fi
+
+if [[ -d "$lib" ]]; then
+    ASAN_RT_PATH="$lib"
+elif [[ -f "$lib" && "$lib" == *"$ASAN_RT" ]]; then
+    ASAN_RT_PATH=$(dirname "$lib")
+elif [[ -f "$HERE/$ASAN_RT" ]]; then
+    ASAN_RT_PATH="$HERE"
+elif [[ $(basename "$HERE") == "bin" ]]; then
+    # We could be in the toolchain's base directory.
+    # Consider ../lib, ../lib/asan, ../lib/linux,
+    # ../lib/clang/$VERSION/lib/linux, and ../lib64/clang/$VERSION/lib/linux.
+    P=$(ls "$HERE"/../lib/"$ASAN_RT" \
+           "$HERE"/../lib/asan/"$ASAN_RT" \
+           "$HERE"/../lib/linux/"$ASAN_RT" \
+           "$HERE"/../lib/clang/*/lib/linux/"$ASAN_RT" \
+           "$HERE"/../lib64/clang/*/lib/linux/"$ASAN_RT" 2>/dev/null | sort | tail -1)
+    if [[ -n "$P" ]]; then
+        ASAN_RT_PATH="$(dirname "$P")"
+    fi
+fi
+
+if [[ -z "$ASAN_RT_PATH" || ! -f "$ASAN_RT_PATH/$ASAN_RT" ]]; then
+    echo ">> ASan runtime library not found"
+    exit 1
+fi
+
+if [[ -n "$ASAN_RT64" ]]; then
+  if [[ -z "$ASAN_RT_PATH" || ! -f "$ASAN_RT_PATH/$ASAN_RT64" ]]; then
+    echo ">> ASan runtime library not found"
+    exit 1
+  fi
+fi
+
+TMPDIRBASE=$(mktemp -d)
+TMPDIROLD="$TMPDIRBASE/old"
+TMPDIR="$TMPDIRBASE/new"
+mkdir "$TMPDIROLD"
+
+RELEASE=$(adb_shell getprop ro.build.version.release)
+PRE_L=0
+if echo "$RELEASE" | grep '^4\.' >&/dev/null; then
+    PRE_L=1
+fi
+
+if ! adb_shell ls -l /system/bin/app_process | grep -o '\->.*app_process' >&/dev/null; then
+
+    if adb_pull /system/bin/app_process.real /dev/null >&/dev/null; then
+        echo '>> Old-style ASan installation detected. Reverting.'
+        adb_shell mv /system/bin/app_process.real /system/bin/app_process
+    fi
+
+    echo '>> Pre-L device detected. Setting up app_process symlink.'
+    adb_shell mv /system/bin/app_process /system/bin/app_process32
+    adb_shell ln -s /system/bin/app_process32 /system/bin/app_process
+fi
+
+echo '>> Copying files from the device'
+if [[ -n "$ASAN_RT64" ]]; then
+  adb_pull /system/lib/"$ASAN_RT" "$TMPDIROLD" || true
+  adb_pull /system/lib64/"$ASAN_RT64" "$TMPDIROLD" || true
+  adb_pull /system/bin/app_process32 "$TMPDIROLD" || true
+  adb_pull /system/bin/app_process32.real "$TMPDIROLD" || true
+  adb_pull /system/bin/app_process64 "$TMPDIROLD" || true
+  adb_pull /system/bin/app_process64.real "$TMPDIROLD" || true
+  adb_pull /system/bin/asanwrapper "$TMPDIROLD" || true
+  adb_pull /system/bin/asanwrapper64 "$TMPDIROLD" || true
+else
+  adb_pull /system/lib/"$ASAN_RT" "$TMPDIROLD" || true
+  adb_pull /system/bin/app_process32 "$TMPDIROLD" || true
+  adb_pull /system/bin/app_process.wrap "$TMPDIROLD" || true
+  adb_pull /system/bin/asanwrapper "$TMPDIROLD" || true
+fi
+cp -r "$TMPDIROLD" "$TMPDIR"
+
+if [[ -f "$TMPDIR/app_process.wrap" || -f "$TMPDIR/app_process64.real" ]]; then
+    echo ">> Previous installation detected"
+else
+    echo ">> New installation"
+fi
+
+echo '>> Generating wrappers'
+
+cp "$ASAN_RT_PATH/$ASAN_RT" "$TMPDIR/"
+if [[ -n "$ASAN_RT64" ]]; then
+  cp "$ASAN_RT_PATH/$ASAN_RT64" "$TMPDIR/"
+fi
+
+# FIXME: alloc_dealloc_mismatch=0 prevents a failure in libdvm startup,
+# which may or may not be a real bug (probably not).
+ASAN_OPTIONS=start_deactivated=1,alloc_dealloc_mismatch=0,malloc_context_size=0
+
+function generate_zygote_wrapper { # from, to, asan_rt
+  local _from=$1
+  local _to=$2
+  local _asan_rt=$3
+  cat <<EOF >"$TMPDIR/$_from"
+#!/system/bin/sh-from-zygote
+ASAN_OPTIONS=$ASAN_OPTIONS \\
+ASAN_ACTIVATION_OPTIONS=include_if_exists=/data/local/tmp/asan.options.%b \\
+LD_PRELOAD=\$LD_PRELOAD:$_asan_rt \\
+exec $_to \$@
+
+EOF
+}
+
+# On Android-L not allowing user segv handler breaks some applications.
+if [[ PRE_L -eq 0 ]]; then
+    ASAN_OPTIONS="$ASAN_OPTIONS,allow_user_segv_handler=1"
+fi
+
+if [[ x$extra_options != x ]] ; then
+    ASAN_OPTIONS="$ASAN_OPTIONS,$extra_options"
+fi
+
+# Zygote wrapper.
+if [[ -f "$TMPDIR/app_process64" ]]; then
+  # A 64-bit device.
+  if [[ ! -f "$TMPDIR/app_process64.real" ]]; then
+    # New installation.
+    mv "$TMPDIR/app_process32" "$TMPDIR/app_process32.real"
+    mv "$TMPDIR/app_process64" "$TMPDIR/app_process64.real"
+  fi
+  generate_zygote_wrapper "app_process32" "/system/bin/app_process32.real" "$ASAN_RT"
+  generate_zygote_wrapper "app_process64" "/system/bin/app_process64.real" "$ASAN_RT64"
+else
+  # A 32-bit device.
+  generate_zygote_wrapper "app_process.wrap" "/system/bin/app_process32" "$ASAN_RT"
+fi
+
+# General command-line tool wrapper (use for anything that's not started as
+# zygote).
+cat <<EOF >"$TMPDIR/asanwrapper"
+#!/system/bin/sh
+LD_PRELOAD=$ASAN_RT \\
+exec \$@
+
+EOF
+
+if [[ -n "$ASAN_RT64" ]]; then
+  cat <<EOF >"$TMPDIR/asanwrapper64"
+#!/system/bin/sh
+LD_PRELOAD=$ASAN_RT64 \\
+exec \$@
+
+EOF
+fi
+
+function install { # from, to, chmod, chcon
+  local _from=$1
+  local _to=$2
+  local _mode=$3
+  local _context=$4
+  local _basename="$(basename "$_from")"
+  echo "Installing $_to/$_basename $_mode $_context"
+  adb_push "$_from" "$_to/$_basename"
+  adb_shell chown root.shell "$_to/$_basename"
+  if [[ -n "$_mode" ]]; then
+    adb_shell chmod "$_mode" "$_to/$_basename"
+  fi
+  if [[ -n "$_context" ]]; then
+    adb_shell chcon "$_context" "$_to/$_basename"
+  fi
+}
+
+if ! ( cd "$TMPDIRBASE" && diff -qr old/ new/ ) ; then
+    # Make SELinux happy by keeping app_process wrapper and the shell
+    # it runs on in zygote domain.
+    ENFORCING=0
+    if adb_shell getenforce | grep Enforcing >/dev/null; then
+        # Sometimes shell is not allowed to change file contexts.
+        # Temporarily switch to permissive.
+        ENFORCING=1
+        adb_shell setenforce 0
+    fi
+
+    if [[ PRE_L -eq 1 ]]; then
+        CTX=u:object_r:system_file:s0
+    else
+        CTX=u:object_r:zygote_exec:s0
+    fi
+
+    echo '>> Pushing files to the device'
+
+    if [[ -n "$ASAN_RT64" ]]; then
+      install "$TMPDIR/$ASAN_RT" /system/lib 644
+      install "$TMPDIR/$ASAN_RT64" /system/lib64 644
+      install "$TMPDIR/app_process32" /system/bin 755 $CTX
+      install "$TMPDIR/app_process32.real" /system/bin 755 $CTX
+      install "$TMPDIR/app_process64" /system/bin 755 $CTX
+      install "$TMPDIR/app_process64.real" /system/bin 755 $CTX
+      install "$TMPDIR/asanwrapper" /system/bin 755
+      install "$TMPDIR/asanwrapper64" /system/bin 755
+    else
+      install "$TMPDIR/$ASAN_RT" /system/lib 644
+      install "$TMPDIR/app_process32" /system/bin 755 $CTX
+      install "$TMPDIR/app_process.wrap" /system/bin 755 $CTX
+      install "$TMPDIR/asanwrapper" /system/bin 755 $CTX
+
+      adb_shell rm /system/bin/app_process
+      adb_shell ln -s /system/bin/app_process.wrap /system/bin/app_process
+    fi
+
+    adb_shell cp /system/bin/sh /system/bin/sh-from-zygote
+    adb_shell chcon $CTX /system/bin/sh-from-zygote
+
+    if [ $ENFORCING == 1 ]; then
+        adb_shell setenforce 1
+    fi
+
+    echo '>> Restarting shell (asynchronous)'
+    adb_shell stop
+    adb_shell start
+
+    echo '>> Please wait until the device restarts'
+else
+    echo '>> Device is up to date'
+fi
+
+rm -r "$TMPDIRBASE"
diff --git a/compiler-rt/lib/asan/scripts/asan_symbolize.py b/compiler-rt/lib/asan/scripts/asan_symbolize.py
new file mode 100755
index 0000000..e6d43cd
--- /dev/null
+++ b/compiler-rt/lib/asan/scripts/asan_symbolize.py
@@ -0,0 +1,490 @@
+#!/usr/bin/env python
+#===- lib/asan/scripts/asan_symbolize.py -----------------------------------===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+import argparse
+import bisect
+import getopt
+import os
+import re
+import subprocess
+import sys
+
+symbolizers = {}
+DEBUG = False
+demangle = False
+binutils_prefix = None
+sysroot_path = None
+binary_name_filter = None
+fix_filename_patterns = None
+logfile = sys.stdin
+allow_system_symbolizer = True
+
+# FIXME: merge the code that calls fix_filename().
+def fix_filename(file_name):
+  if fix_filename_patterns:
+    for path_to_cut in fix_filename_patterns:
+      file_name = re.sub('.*' + path_to_cut, '', file_name)
+  file_name = re.sub('.*asan_[a-z_]*.cc:[0-9]*', '_asan_rtl_', file_name)
+  file_name = re.sub('.*crtstuff.c:0', '???:0', file_name)
+  return file_name
+
+def sysroot_path_filter(binary_name):
+  return sysroot_path + binary_name
+
+def guess_arch(addr):
+  # Guess which arch we're running. 10 = len('0x') + 8 hex digits.
+  if len(addr) > 10:
+    return 'x86_64'
+  else:
+    return 'i386'
+
+class Symbolizer(object):
+  def __init__(self):
+    pass
+
+  def symbolize(self, addr, binary, offset):
+    """Symbolize the given address (pair of binary and offset).
+
+    Overriden in subclasses.
+    Args:
+        addr: virtual address of an instruction.
+        binary: path to executable/shared object containing this instruction.
+        offset: instruction offset in the @binary.
+    Returns:
+        list of strings (one string for each inlined frame) describing
+        the code locations for this instruction (that is, function name, file
+        name, line and column numbers).
+    """
+    return None
+
+
+class LLVMSymbolizer(Symbolizer):
+  def __init__(self, symbolizer_path, default_arch, system, dsym_hints=[]):
+    super(LLVMSymbolizer, self).__init__()
+    self.symbolizer_path = symbolizer_path
+    self.default_arch = default_arch
+    self.system = system
+    self.dsym_hints = dsym_hints
+    self.pipe = self.open_llvm_symbolizer()
+
+  def open_llvm_symbolizer(self):
+    cmd = [self.symbolizer_path,
+           '--use-symbol-table=true',
+           '--demangle=%s' % demangle,
+           '--functions=linkage',
+           '--inlining=true',
+           '--default-arch=%s' % self.default_arch]
+    if self.system == 'Darwin':
+      for hint in self.dsym_hints:
+        cmd.append('--dsym-hint=%s' % hint)
+    if DEBUG:
+      print ' '.join(cmd)
+    try:
+      result = subprocess.Popen(cmd, stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE)
+    except OSError:
+      result = None
+    return result
+
+  def symbolize(self, addr, binary, offset):
+    """Overrides Symbolizer.symbolize."""
+    if not self.pipe:
+      return None
+    result = []
+    try:
+      symbolizer_input = '"%s" %s' % (binary, offset)
+      if DEBUG:
+        print symbolizer_input
+      print >> self.pipe.stdin, symbolizer_input
+      while True:
+        function_name = self.pipe.stdout.readline().rstrip()
+        if not function_name:
+          break
+        file_name = self.pipe.stdout.readline().rstrip()
+        file_name = fix_filename(file_name)
+        if (not function_name.startswith('??') or
+            not file_name.startswith('??')):
+          # Append only non-trivial frames.
+          result.append('%s in %s %s' % (addr, function_name,
+                                         file_name))
+    except Exception:
+      result = []
+    if not result:
+      result = None
+    return result
+
+
+def LLVMSymbolizerFactory(system, default_arch, dsym_hints=[]):
+  symbolizer_path = os.getenv('LLVM_SYMBOLIZER_PATH')
+  if not symbolizer_path:
+    symbolizer_path = os.getenv('ASAN_SYMBOLIZER_PATH')
+    if not symbolizer_path:
+      # Assume llvm-symbolizer is in PATH.
+      symbolizer_path = 'llvm-symbolizer'
+  return LLVMSymbolizer(symbolizer_path, default_arch, system, dsym_hints)
+
+
+class Addr2LineSymbolizer(Symbolizer):
+  def __init__(self, binary):
+    super(Addr2LineSymbolizer, self).__init__()
+    self.binary = binary
+    self.pipe = self.open_addr2line()
+    self.output_terminator = -1
+
+  def open_addr2line(self):
+    addr2line_tool = 'addr2line'
+    if binutils_prefix:
+      addr2line_tool = binutils_prefix + addr2line_tool
+    cmd = [addr2line_tool, '-fi']
+    if demangle:
+      cmd += ['--demangle']
+    cmd += ['-e', self.binary]
+    if DEBUG:
+      print ' '.join(cmd)
+    return subprocess.Popen(cmd,
+                            stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+
+  def symbolize(self, addr, binary, offset):
+    """Overrides Symbolizer.symbolize."""
+    if self.binary != binary:
+      return None
+    lines = []
+    try:
+      print >> self.pipe.stdin, offset
+      print >> self.pipe.stdin, self.output_terminator
+      is_first_frame = True
+      while True:
+        function_name = self.pipe.stdout.readline().rstrip()
+        file_name = self.pipe.stdout.readline().rstrip()
+        if is_first_frame:
+          is_first_frame = False
+        elif function_name in ['', '??']:
+          assert file_name == function_name
+          break
+        lines.append((function_name, file_name));
+    except Exception:
+      lines.append(('??', '??:0'))
+    return ['%s in %s %s' % (addr, function, fix_filename(file)) for (function, file) in lines]
+
+class UnbufferedLineConverter(object):
+  """
+  Wrap a child process that responds to each line of input with one line of
+  output.  Uses pty to trick the child into providing unbuffered output.
+  """
+  def __init__(self, args, close_stderr=False):
+    # Local imports so that the script can start on Windows.
+    import pty
+    import termios
+    pid, fd = pty.fork()
+    if pid == 0:
+      # We're the child. Transfer control to command.
+      if close_stderr:
+        dev_null = os.open('/dev/null', 0)
+        os.dup2(dev_null, 2)
+      os.execvp(args[0], args)
+    else:
+      # Disable echoing.
+      attr = termios.tcgetattr(fd)
+      attr[3] = attr[3] & ~termios.ECHO
+      termios.tcsetattr(fd, termios.TCSANOW, attr)
+      # Set up a file()-like interface to the child process
+      self.r = os.fdopen(fd, "r", 1)
+      self.w = os.fdopen(os.dup(fd), "w", 1)
+
+  def convert(self, line):
+    self.w.write(line + "\n")
+    return self.readline()
+
+  def readline(self):
+    return self.r.readline().rstrip()
+
+
+class DarwinSymbolizer(Symbolizer):
+  def __init__(self, addr, binary):
+    super(DarwinSymbolizer, self).__init__()
+    self.binary = binary
+    self.arch = guess_arch(addr)
+    self.open_atos()
+
+  def open_atos(self):
+    if DEBUG:
+      print 'atos -o %s -arch %s' % (self.binary, self.arch)
+    cmdline = ['atos', '-o', self.binary, '-arch', self.arch]
+    self.atos = UnbufferedLineConverter(cmdline, close_stderr=True)
+
+  def symbolize(self, addr, binary, offset):
+    """Overrides Symbolizer.symbolize."""
+    if self.binary != binary:
+      return None
+    atos_line = self.atos.convert('0x%x' % int(offset, 16))
+    while "got symbolicator for" in atos_line:
+      atos_line = self.atos.readline()
+    # A well-formed atos response looks like this:
+    #   foo(type1, type2) (in object.name) (filename.cc:80)
+    match = re.match('^(.*) \(in (.*)\) \((.*:\d*)\)$', atos_line)
+    if DEBUG:
+      print 'atos_line: ', atos_line
+    if match:
+      function_name = match.group(1)
+      function_name = re.sub('\(.*?\)', '', function_name)
+      file_name = fix_filename(match.group(3))
+      return ['%s in %s %s' % (addr, function_name, file_name)]
+    else:
+      return ['%s in %s' % (addr, atos_line)]
+
+
+# Chain several symbolizers so that if one symbolizer fails, we fall back
+# to the next symbolizer in chain.
+class ChainSymbolizer(Symbolizer):
+  def __init__(self, symbolizer_list):
+    super(ChainSymbolizer, self).__init__()
+    self.symbolizer_list = symbolizer_list
+
+  def symbolize(self, addr, binary, offset):
+    """Overrides Symbolizer.symbolize."""
+    for symbolizer in self.symbolizer_list:
+      if symbolizer:
+        result = symbolizer.symbolize(addr, binary, offset)
+        if result:
+          return result
+    return None
+
+  def append_symbolizer(self, symbolizer):
+    self.symbolizer_list.append(symbolizer)
+
+
+def BreakpadSymbolizerFactory(binary):
+  suffix = os.getenv('BREAKPAD_SUFFIX')
+  if suffix:
+    filename = binary + suffix
+    if os.access(filename, os.F_OK):
+      return BreakpadSymbolizer(filename)
+  return None
+
+
+def SystemSymbolizerFactory(system, addr, binary):
+  if system == 'Darwin':
+    return DarwinSymbolizer(addr, binary)
+  elif system == 'Linux':
+    return Addr2LineSymbolizer(binary)
+
+
+class BreakpadSymbolizer(Symbolizer):
+  def __init__(self, filename):
+    super(BreakpadSymbolizer, self).__init__()
+    self.filename = filename
+    lines = file(filename).readlines()
+    self.files = []
+    self.symbols = {}
+    self.address_list = []
+    self.addresses = {}
+    # MODULE mac x86_64 A7001116478B33F18FF9BEDE9F615F190 t
+    fragments = lines[0].rstrip().split()
+    self.arch = fragments[2]
+    self.debug_id = fragments[3]
+    self.binary = ' '.join(fragments[4:])
+    self.parse_lines(lines[1:])
+
+  def parse_lines(self, lines):
+    cur_function_addr = ''
+    for line in lines:
+      fragments = line.split()
+      if fragments[0] == 'FILE':
+        assert int(fragments[1]) == len(self.files)
+        self.files.append(' '.join(fragments[2:]))
+      elif fragments[0] == 'PUBLIC':
+        self.symbols[int(fragments[1], 16)] = ' '.join(fragments[3:])
+      elif fragments[0] in ['CFI', 'STACK']:
+        pass
+      elif fragments[0] == 'FUNC':
+        cur_function_addr = int(fragments[1], 16)
+        if not cur_function_addr in self.symbols.keys():
+          self.symbols[cur_function_addr] = ' '.join(fragments[4:])
+      else:
+        # Line starting with an address.
+        addr = int(fragments[0], 16)
+        self.address_list.append(addr)
+        # Tuple of symbol address, size, line, file number.
+        self.addresses[addr] = (cur_function_addr,
+                                int(fragments[1], 16),
+                                int(fragments[2]),
+                                int(fragments[3]))
+    self.address_list.sort()
+
+  def get_sym_file_line(self, addr):
+    key = None
+    if addr in self.addresses.keys():
+      key = addr
+    else:
+      index = bisect.bisect_left(self.address_list, addr)
+      if index == 0:
+        return None
+      else:
+        key = self.address_list[index - 1]
+    sym_id, size, line_no, file_no = self.addresses[key]
+    symbol = self.symbols[sym_id]
+    filename = self.files[file_no]
+    if addr < key + size:
+      return symbol, filename, line_no
+    else:
+      return None
+
+  def symbolize(self, addr, binary, offset):
+    if self.binary != binary:
+      return None
+    res = self.get_sym_file_line(int(offset, 16))
+    if res:
+      function_name, file_name, line_no = res
+      result = ['%s in %s %s:%d' % (
+          addr, function_name, file_name, line_no)]
+      print result
+      return result
+    else:
+      return None
+
+
+class SymbolizationLoop(object):
+  def __init__(self, binary_name_filter=None, dsym_hint_producer=None):
+    if sys.platform == 'win32':
+      # ASan on Windows uses dbghelp.dll to symbolize in-process, which works
+      # even in sandboxed processes.  Nothing needs to be done here.
+      self.process_line = self.process_line_echo
+    else:
+      # Used by clients who may want to supply a different binary name.
+      # E.g. in Chrome several binaries may share a single .dSYM.
+      self.binary_name_filter = binary_name_filter
+      self.dsym_hint_producer = dsym_hint_producer
+      self.system = os.uname()[0]
+      if self.system not in ['Linux', 'Darwin', 'FreeBSD']:
+        raise Exception('Unknown system')
+      self.llvm_symbolizers = {}
+      self.last_llvm_symbolizer = None
+      self.dsym_hints = set([])
+      self.frame_no = 0
+      self.process_line = self.process_line_posix
+
+  def symbolize_address(self, addr, binary, offset):
+    # On non-Darwin (i.e. on platforms without .dSYM debug info) always use
+    # a single symbolizer binary.
+    # On Darwin, if the dsym hint producer is present:
+    #  1. check whether we've seen this binary already; if so,
+    #     use |llvm_symbolizers[binary]|, which has already loaded the debug
+    #     info for this binary (might not be the case for
+    #     |last_llvm_symbolizer|);
+    #  2. otherwise check if we've seen all the hints for this binary already;
+    #     if so, reuse |last_llvm_symbolizer| which has the full set of hints;
+    #  3. otherwise create a new symbolizer and pass all currently known
+    #     .dSYM hints to it.
+    if not binary in self.llvm_symbolizers:
+      use_new_symbolizer = True
+      if self.system == 'Darwin' and self.dsym_hint_producer:
+        dsym_hints_for_binary = set(self.dsym_hint_producer(binary))
+        use_new_symbolizer = bool(dsym_hints_for_binary - self.dsym_hints)
+        self.dsym_hints |= dsym_hints_for_binary
+      if self.last_llvm_symbolizer and not use_new_symbolizer:
+          self.llvm_symbolizers[binary] = self.last_llvm_symbolizer
+      else:
+        self.last_llvm_symbolizer = LLVMSymbolizerFactory(
+            self.system, guess_arch(addr), self.dsym_hints)
+        self.llvm_symbolizers[binary] = self.last_llvm_symbolizer
+    # Use the chain of symbolizers:
+    # Breakpad symbolizer -> LLVM symbolizer -> addr2line/atos
+    # (fall back to next symbolizer if the previous one fails).
+    if not binary in symbolizers:
+      symbolizers[binary] = ChainSymbolizer(
+          [BreakpadSymbolizerFactory(binary), self.llvm_symbolizers[binary]])
+    result = symbolizers[binary].symbolize(addr, binary, offset)
+    if result is None:
+      if not allow_system_symbolizer:
+        raise Exception('Failed to launch or use llvm-symbolizer.')
+      # Initialize system symbolizer only if other symbolizers failed.
+      symbolizers[binary].append_symbolizer(
+          SystemSymbolizerFactory(self.system, addr, binary))
+      result = symbolizers[binary].symbolize(addr, binary, offset)
+    # The system symbolizer must produce some result.
+    assert result
+    return result
+
+  def get_symbolized_lines(self, symbolized_lines):
+    if not symbolized_lines:
+      return [self.current_line]
+    else:
+      result = []
+      for symbolized_frame in symbolized_lines:
+        result.append('    #%s %s' % (str(self.frame_no), symbolized_frame.rstrip()))
+        self.frame_no += 1
+      return result
+
+  def process_logfile(self):
+    self.frame_no = 0
+    for line in logfile:
+      processed = self.process_line(line)
+      print '\n'.join(processed)
+
+  def process_line_echo(self, line):
+    return [line.rstrip()]
+
+  def process_line_posix(self, line):
+    self.current_line = line.rstrip()
+    #0 0x7f6e35cf2e45  (/blah/foo.so+0x11fe45)
+    stack_trace_line_format = (
+        '^( *#([0-9]+) *)(0x[0-9a-f]+) *\((.*)\+(0x[0-9a-f]+)\)')
+    match = re.match(stack_trace_line_format, line)
+    if not match:
+      return [self.current_line]
+    if DEBUG:
+      print line
+    _, frameno_str, addr, binary, offset = match.groups()
+    if frameno_str == '0':
+      # Assume that frame #0 is the first frame of new stack trace.
+      self.frame_no = 0
+    original_binary = binary
+    if self.binary_name_filter:
+      binary = self.binary_name_filter(binary)
+    symbolized_line = self.symbolize_address(addr, binary, offset)
+    if not symbolized_line:
+      if original_binary != binary:
+        symbolized_line = self.symbolize_address(addr, binary, offset)
+    return self.get_symbolized_lines(symbolized_line)
+
+
+if __name__ == '__main__':
+  parser = argparse.ArgumentParser(
+      formatter_class=argparse.RawDescriptionHelpFormatter,
+      description='ASan symbolization script',
+      epilog='Example of use:\n'
+             'asan_symbolize.py -c "$HOME/opt/cross/bin/arm-linux-gnueabi-" '
+             '-s "$HOME/SymbolFiles" < asan.log')
+  parser.add_argument('path_to_cut', nargs='*',
+                      help='pattern to be cut from the result file path ')
+  parser.add_argument('-d','--demangle', action='store_true',
+                      help='demangle function names')
+  parser.add_argument('-s', metavar='SYSROOT',
+                      help='set path to sysroot for sanitized binaries')
+  parser.add_argument('-c', metavar='CROSS_COMPILE',
+                      help='set prefix for binutils')
+  parser.add_argument('-l','--logfile', default=sys.stdin,
+                      type=argparse.FileType('r'),
+                      help='set log file name to parse, default is stdin')
+  args = parser.parse_args()
+  if args.path_to_cut:
+    fix_filename_patterns = args.path_to_cut
+  if args.demangle:
+    demangle = True
+  if args.s:
+    binary_name_filter = sysroot_path_filter
+    sysroot_path = args.s
+  if args.c:
+    binutils_prefix = args.c
+  if args.logfile:
+    logfile = args.logfile
+  else:
+    logfile = sys.stdin
+  loop = SymbolizationLoop(binary_name_filter)
+  loop.process_logfile()
diff --git a/compiler-rt/lib/asan/scripts/symbolize.py b/compiler-rt/lib/asan/scripts/symbolize.py
new file mode 100755
index 0000000..2182fd4
--- /dev/null
+++ b/compiler-rt/lib/asan/scripts/symbolize.py
@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+#===- lib/asan/scripts/asan_symbolize.py -----------------------------------===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+import glob
+import os
+import re
+import sys
+import string
+import subprocess
+
+pipes = {}
+load_addresses = {}
+next_inline_frameno = 0
+
+def patch_address(frameno, addr_s):
+  ''' Subtracts 1 or 2 from the top frame's address.
+  Top frame is normally the return address from asan_report*
+  call, which is not expected to return at all. Because of that, this
+  address often belongs to the next source code line, or even to a different
+  function. '''
+  if frameno == '0':
+    addr = int(addr_s, 16)
+    if os.uname()[4].startswith('arm'):
+      # Cancel the Thumb bit
+      addr = addr & (~1)
+    addr -= 1
+    return hex(addr)
+  return addr_s
+
+def android_get_load_address(path):
+  if load_addresses.has_key(path):
+    return load_addresses[path]
+  readelf_glob = os.path.join(os.environ['ANDROID_TOOLCHAIN'], '*-readelf')
+  readelf = glob.glob(readelf_glob)[0]
+  readelf_pipe = subprocess.Popen([readelf, "-W", "-l", path], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+  for line in readelf_pipe.stdout:
+      if ('LOAD' in line) and (' E ' in line):
+          match = re.match(r'\s*LOAD\s+0x[01-9a-zA-Z]+\s+(0x[01-9a-zA-Z]+)', line, re.UNICODE)
+          if match:
+              load_addr = int(match.group(1), 16)
+              load_addresses[path] = load_addr
+              return load_addr
+          else: break
+  print 'Could not make sense of readelf output!'
+  sys.exit(1)
+
+def postprocess_file_name(file_name, paths_to_cut):
+  for path_to_cut in paths_to_cut:
+    file_name = re.sub(".*" + path_to_cut, "", file_name)
+  file_name = re.sub(".*asan_[a-z_]*.(cc|h):[0-9]*", "[asan_rtl]", file_name)
+  file_name = re.sub(".*crtstuff.c:0", "???:0", file_name)
+  return file_name
+
+# TODO(glider): need some refactoring here
+def symbolize_addr2line(line, binary_prefix, paths_to_cut):
+  global next_inline_frameno
+  # Strip the log prefix ("I/asanwrapper( 1196): ").
+  line = re.sub(r'^.*?: ', '', line)
+  #0 0x7f6e35cf2e45  (/blah/foo.so+0x11fe45)
+  match = re.match(r'^(\s*#)([0-9]+) *(0x[0-9a-f]+) *\((.*)\+(0x[0-9a-f]+)\)', line, re.UNICODE)
+  if match:
+    frameno = match.group(2)
+    binary = match.group(4)
+    addr = match.group(5)
+    addr = patch_address(frameno, addr)
+
+    if binary.startswith('/'):
+      binary = binary[1:]
+    binary = os.path.join(binary_prefix, binary)
+
+    if not os.path.exists(binary):
+      print line.rstrip().encode('utf-8')
+      return
+
+    load_addr = android_get_load_address(binary)
+    addr = hex(int(addr, 16) + load_addr)
+
+    if not pipes.has_key(binary):
+      pipes[binary] = subprocess.Popen(["addr2line", "-i", "-f", "-e", binary],
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    p = pipes[binary]
+    frames = []
+    try:
+      print >>p.stdin, addr
+      # This will trigger a "??" response from addr2line so we know when to stop
+      print >>p.stdin
+      while True:
+        function_name = p.stdout.readline().rstrip()
+        file_name     = p.stdout.readline().rstrip()
+        if function_name in ['??', '']:
+          break
+        file_name = postprocess_file_name(file_name, paths_to_cut)
+        frames.append((function_name, file_name))
+    except:
+      pass
+    if not frames:
+      frames.append(('', ''))
+      # Consume another pair of "??" lines
+      try:
+        p.stdout.readline()
+        p.stdout.readline()
+      except:
+        pass
+    for frame in frames:
+      inline_frameno = next_inline_frameno
+      next_inline_frameno += 1
+      print "%s%d" % (match.group(1).encode('utf-8'), inline_frameno), \
+          match.group(3).encode('utf-8'), "in", frame[0], frame[1]
+  else:
+    print line.rstrip().encode('utf-8')
+
+
+binary_prefix = os.path.join(os.environ['ANDROID_PRODUCT_OUT'], 'symbols')
+paths_to_cut = [os.getcwd() + '/', os.environ['ANDROID_BUILD_TOP'] + '/'] + sys.argv[1:]
+
+for line in sys.stdin:
+  line = line.decode('utf-8')
+  symbolize_addr2line(line, binary_prefix, paths_to_cut)
diff --git a/compiler-rt/lib/asan/tests/CMakeLists.txt b/compiler-rt/lib/asan/tests/CMakeLists.txt
new file mode 100644
index 0000000..7a8d8f7
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/CMakeLists.txt
@@ -0,0 +1,306 @@
+# Testing rules for AddressSanitizer.
+#
+# These are broken into two buckets. One set of tests directly interacts with
+# the runtime library and checks its functionality. These are the
+# no-instrumentation tests.
+#
+# Another group of tests relies upon the ability to compile the test with
+# address sanitizer instrumentation pass. These tests form "integration" tests
+# and have some elements of version skew -- they test the *host* compiler's
+# instrumentation against the just-built runtime library.
+
+include(CheckCXXCompilerFlag)
+include(CompilerRTCompile)
+
+include_directories(..)
+include_directories(../..)
+
+set(ASAN_UNITTEST_HEADERS
+  asan_mac_test.h
+  asan_test_config.h
+  asan_test_utils.h)
+
+set(ASAN_UNITTEST_COMMON_CFLAGS
+  ${COMPILER_RT_TEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/include
+  -I${COMPILER_RT_SOURCE_DIR}/lib
+  -I${COMPILER_RT_SOURCE_DIR}/lib/asan
+  -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests
+  -fno-rtti
+  -O2
+  -Wno-format
+  -Werror=sign-compare
+  -Wno-non-virtual-dtor)
+append_list_if(COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG -Wno-variadic-macros ASAN_UNITTEST_COMMON_CFLAGS)
+
+# -gline-tables-only must be enough for ASan, so use it if possible.
+if(COMPILER_RT_TEST_COMPILER_ID MATCHES "Clang")
+  list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -gline-tables-only)
+else()
+  list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -g)
+endif()
+
+# Use -D instead of definitions to please custom compile command.
+list(APPEND ASAN_UNITTEST_COMMON_CFLAGS
+  -DASAN_HAS_BLACKLIST=1
+  -DASAN_HAS_EXCEPTIONS=1
+  -DASAN_UAR=0)
+
+if(APPLE)
+  list(APPEND ASAN_UNITTEST_COMMON_CFLAGS ${DARWIN_osx_CFLAGS})
+  list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS ${DARWIN_osx_LINKFLAGS})
+endif()
+
+if(MSVC)
+  # Disable exceptions on Windows until they work reliably.
+  list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -fno-exceptions -DGTEST_HAS_SEH=0)
+endif()
+
+set(ASAN_BLACKLIST_FILE "${CMAKE_CURRENT_SOURCE_DIR}/asan_test.ignore")
+set(ASAN_UNITTEST_INSTRUMENTED_CFLAGS
+  ${ASAN_UNITTEST_COMMON_CFLAGS}
+  -fsanitize=address
+  "-fsanitize-blacklist=${ASAN_BLACKLIST_FILE}"
+)
+if(CAN_TARGET_x86_64 OR CAN_TARGET_i386)
+  list(APPEND ASAN_UNITTEST_INSTRUMENTED_CFLAGS -mllvm -asan-instrument-assembly)
+endif()
+
+if(NOT MSVC)
+  list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS --driver-mode=g++)
+endif()
+
+# x86_64 FreeBSD 9.2 additionally requires libc++ to build the tests.
+if(CMAKE_SYSTEM MATCHES "FreeBSD-9.2-RELEASE")
+  list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS "-lc++")
+endif()
+
+# Unit tests on Mac depend on Foundation.
+if(APPLE)
+  list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS -framework Foundation)
+endif()
+if(ANDROID)
+  list(APPEND ASAN_UNITTEST_COMMON_LINKFLAGS -pie)
+endif()
+
+set(ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS
+  ${ASAN_UNITTEST_COMMON_LINKFLAGS})
+list(APPEND ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS -fsanitize=address)
+
+set(ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS
+  ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS}
+  -shared-libasan)
+
+set(ASAN_UNITTEST_INSTRUMENTED_LIBS)
+# NDK r10 requires -latomic almost always.
+append_list_if(ANDROID atomic ASAN_UNITTEST_INSTRUMENTED_LIBS)
+
+set(ASAN_UNITTEST_NOINST_LINKFLAGS ${ASAN_UNITTEST_COMMON_LINKFLAGS})
+append_list_if(COMPILER_RT_HAS_LIBM -lm ASAN_UNITTEST_NOINST_LINKFLAGS)
+append_list_if(COMPILER_RT_HAS_LIBDL -ldl ASAN_UNITTEST_NOINST_LINKFLAGS)
+append_list_if(COMPILER_RT_HAS_LIBRT -lrt ASAN_UNITTEST_NOINST_LINKFLAGS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread ASAN_UNITTEST_NOINST_LINKFLAGS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread
+          ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS)
+
+# TODO(eugenis): move all -l flags above to _LIBS?
+set(ASAN_UNITTEST_NOINST_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBLOG log ASAN_UNITTEST_NOINST_LIBS)
+# NDK r10 requires -latomic almost always.
+append_list_if(ANDROID atomic ASAN_UNITTEST_NOINST_LIBS)
+
+# Compile source for the given architecture, using compiler
+# options in ${ARGN}, and add it to the object list.
+macro(asan_compile obj_list source arch kind)
+  get_filename_component(basename ${source} NAME)
+  set(output_obj "${obj_list}.${basename}.${arch}${kind}.o")
+  get_target_flags_for_arch(${arch} TARGET_CFLAGS)
+  set(COMPILE_DEPS ${ASAN_UNITTEST_HEADERS} ${ASAN_BLACKLIST_FILE})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND COMPILE_DEPS gtest asan)
+  endif()
+  clang_compile(${output_obj} ${source}
+                CFLAGS ${ARGN} ${TARGET_CFLAGS}
+                DEPS ${COMPILE_DEPS})
+  list(APPEND ${obj_list} ${output_obj})
+endmacro()
+
+# Link ASan unit test for a given architecture from a set
+# of objects in with given linker flags.
+macro(add_asan_test test_suite test_name arch kind)
+  cmake_parse_arguments(TEST "WITH_TEST_RUNTIME" "" "OBJECTS;LINKFLAGS;SUBDIR" ${ARGN})
+  get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
+  set(TEST_DEPS ${TEST_OBJECTS})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND TEST_DEPS asan)
+  endif()
+  if(TEST_WITH_TEST_RUNTIME)
+    list(APPEND TEST_DEPS ${ASAN_TEST_RUNTIME})
+    if(NOT MSVC)
+      list(APPEND TEST_OBJECTS lib${ASAN_TEST_RUNTIME}.a)
+    else()
+      list(APPEND TEST_OBJECTS ${ASAN_TEST_RUNTIME}.lib)
+    endif()
+  endif()
+  add_compiler_rt_test(${test_suite} ${test_name}
+                       SUBDIR ${TEST_SUBDIR}
+                       OBJECTS ${TEST_OBJECTS}
+                       DEPS ${TEST_DEPS}
+                       LINK_FLAGS ${TEST_LINKFLAGS}
+                                  ${TARGET_LINK_FLAGS})
+endmacro()
+
+# Main AddressSanitizer unit tests.
+add_custom_target(AsanUnitTests)
+set_target_properties(AsanUnitTests PROPERTIES FOLDER "ASan unit tests")
+# AddressSanitizer unit tests with dynamic runtime (on platforms where it's
+# not the default).
+add_custom_target(AsanDynamicUnitTests)
+set_target_properties(AsanDynamicUnitTests
+  PROPERTIES FOLDER "ASan unit tests with dynamic runtime")
+# ASan benchmarks (not actively used now).
+add_custom_target(AsanBenchmarks)
+set_target_properties(AsanBenchmarks PROPERTIES FOLDER "Asan benchmarks")
+
+set(ASAN_NOINST_TEST_SOURCES
+  ${COMPILER_RT_GTEST_SOURCE}
+  asan_fake_stack_test.cc
+  asan_noinst_test.cc
+  asan_test_main.cc)
+
+set(ASAN_INST_TEST_SOURCES
+  ${COMPILER_RT_GTEST_SOURCE}
+  asan_asm_test.cc
+  asan_globals_test.cc
+  asan_interface_test.cc
+  asan_test.cc
+  asan_oob_test.cc
+  asan_mem_test.cc
+  asan_str_test.cc
+  asan_test_main.cc)
+if(APPLE)
+  list(APPEND ASAN_INST_TEST_SOURCES asan_mac_test.cc)
+endif()
+
+set(ASAN_BENCHMARKS_SOURCES
+  ${COMPILER_RT_GTEST_SOURCE}
+  asan_benchmarks_test.cc)
+
+# Adds ASan unit tests and benchmarks for architecture.
+macro(add_asan_tests_for_arch_and_kind arch kind)
+  # Instrumented tests.
+  set(ASAN_INST_TEST_OBJECTS)
+  foreach(src ${ASAN_INST_TEST_SOURCES})
+    asan_compile(ASAN_INST_TEST_OBJECTS ${src} ${arch} ${kind}
+      ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} ${ARGN})
+  endforeach()
+  if (APPLE)
+    # Add Mac-specific helper.
+    asan_compile(ASAN_INST_TEST_OBJECTS asan_mac_test_helpers.mm ${arch} ${kind}
+                 ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} -ObjC ${ARGN})
+  endif()
+  file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/default")
+  add_asan_test(AsanUnitTests "Asan-${arch}${kind}-Test"
+                ${arch} ${kind} SUBDIR "default"
+                OBJECTS ${ASAN_INST_TEST_OBJECTS}
+                LINKFLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
+  if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
+    file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/dynamic")
+    add_asan_test(AsanDynamicUnitTests "Asan-${arch}${kind}-Dynamic-Test"
+                  ${arch} ${kind} SUBDIR "dynamic"
+                  OBJECTS ${ASAN_INST_TEST_OBJECTS}
+                  LINKFLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS})
+  endif()
+
+  # Add static ASan runtime that will be linked with uninstrumented tests.
+  set(ASAN_TEST_RUNTIME RTAsanTest.${arch}${kind})
+  if(APPLE)
+    set(ASAN_TEST_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTAsan_dynamic.osx>
+      $<TARGET_OBJECTS:RTInterception.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+      $<TARGET_OBJECTS:RTLSanCommon.osx>
+      $<TARGET_OBJECTS:RTUbsan.osx>)
+  else()
+    set(ASAN_TEST_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTAsan.${arch}>
+      $<TARGET_OBJECTS:RTAsan_cxx.${arch}>
+      $<TARGET_OBJECTS:RTInterception.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTLSanCommon.${arch}>
+      $<TARGET_OBJECTS:RTUbsan.${arch}>
+      $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>)
+  endif()
+  add_library(${ASAN_TEST_RUNTIME} STATIC ${ASAN_TEST_RUNTIME_OBJECTS})
+  set_target_properties(${ASAN_TEST_RUNTIME} PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+  # Uninstrumented tests.
+  set(ASAN_NOINST_TEST_OBJECTS)
+  foreach(src ${ASAN_NOINST_TEST_SOURCES})
+    asan_compile(ASAN_NOINST_TEST_OBJECTS ${src} ${arch} ${kind}
+                 ${ASAN_UNITTEST_COMMON_CFLAGS} ${ARGN})
+  endforeach()
+  add_asan_test(AsanUnitTests "Asan-${arch}${kind}-Noinst-Test"
+                ${arch} ${kind} SUBDIR "default"
+                OBJECTS ${ASAN_NOINST_TEST_OBJECTS}
+                LINKFLAGS ${ASAN_UNITTEST_NOINST_LINKFLAGS}
+                WITH_TEST_RUNTIME)
+
+  # Benchmarks.
+  set(ASAN_BENCHMARKS_OBJECTS)
+  foreach(src ${ASAN_BENCHMARKS_SOURCES})
+    asan_compile(ASAN_BENCHMARKS_OBJECTS ${src} ${arch} ${kind}
+                 ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} ${ARGN})
+  endforeach()
+  add_asan_test(AsanBenchmarks "Asan-${arch}${kind}-Benchmark"
+                ${arch} ${kind} SUBDIR "default"
+                OBJECTS ${ASAN_BENCHMARKS_OBJECTS}
+                LINKFLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
+endmacro()
+
+if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
+  set(ASAN_TEST_ARCH ${ASAN_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(ASAN_SUPPORTED_ARCH ASAN_TEST_ARCH)
+  endif()
+  foreach(arch ${ASAN_TEST_ARCH})
+    add_asan_tests_for_arch_and_kind(${arch} "-inline")
+    add_asan_tests_for_arch_and_kind(${arch} "-with-calls"
+      -mllvm -asan-instrumentation-with-call-threshold=0)
+  endforeach()
+endif()
+
+if(ANDROID)
+  foreach(arch ${ASAN_SUPPORTED_ARCH})
+    # Test w/o ASan instrumentation. Link it with ASan statically.
+    add_executable(AsanNoinstTest # FIXME: .arch?
+      $<TARGET_OBJECTS:RTAsan.${arch}>
+      $<TARGET_OBJECTS:RTInterception.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTUbsan.${arch}>
+      $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
+      ${COMPILER_RT_GTEST_SOURCE}
+      ${ASAN_NOINST_TEST_SOURCES})
+    set_target_compile_flags(AsanNoinstTest ${ASAN_UNITTEST_COMMON_CFLAGS})
+    set_target_link_flags(AsanNoinstTest ${ASAN_UNITTEST_NOINST_LINKFLAGS})
+    target_link_libraries(AsanNoinstTest ${ASAN_UNITTEST_NOINST_LIBS})
+
+    # Test with ASan instrumentation. Link with ASan dynamic runtime.
+    add_executable(AsanTest
+      ${COMPILER_RT_GTEST_SOURCE}
+      ${ASAN_INST_TEST_SOURCES})
+    set_target_compile_flags(AsanTest ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS})
+    set_target_link_flags(AsanTest ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
+    target_link_libraries(AsanTest ${ASAN_UNITTEST_INSTRUMENTED_LIBS})
+
+    # Setup correct output directory and link flags.
+    set_target_properties(AsanNoinstTest AsanTest PROPERTIES
+      RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    # Add unit tests to the test suite.
+    add_dependencies(AsanUnitTests AsanNoinstTest AsanTest)
+  endforeach()
+endif()
diff --git a/compiler-rt/lib/asan/tests/asan_asm_test.cc b/compiler-rt/lib/asan/tests/asan_asm_test.cc
new file mode 100644
index 0000000..09af5c3
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_asm_test.cc
@@ -0,0 +1,271 @@
+//===-- asan_asm_test.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+
+#if defined(__linux__)
+
+// Assembly instrumentation is broken on x86 Android (x86 + PIC + shared runtime
+// library). See https://github.com/google/sanitizers/issues/353
+#if defined(__x86_64__) ||                                                     \
+    (defined(__i386__) && defined(__SSE2__) && !defined(__ANDROID__))
+
+#include <emmintrin.h>
+
+namespace {
+
+template<typename T> void asm_write(T *ptr, T val);
+template<typename T> T asm_read(T *ptr);
+template<typename T> void asm_rep_movs(T *dst, T *src, size_t n);
+
+} // End of anonymous namespace
+
+#endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
+
+#if defined(__x86_64__)
+
+namespace {
+
+#define DECLARE_ASM_WRITE(Type, Size, Mov, Reg)        \
+template<> void asm_write<Type>(Type *ptr, Type val) { \
+  __asm__(                                             \
+    Mov " %[val], (%[ptr])  \n\t"                      \
+    :                                                  \
+    : [ptr] "r" (ptr), [val] Reg (val)                 \
+    : "memory"                                         \
+  );                                                   \
+}
+
+#define DECLARE_ASM_READ(Type, Size, Mov, Reg)     \
+template<> Type asm_read<Type>(Type *ptr) {        \
+  Type res;                                        \
+  __asm__(                                         \
+    Mov " (%[ptr]), %[res]  \n\t"                  \
+    : [res] Reg (res)                              \
+    : [ptr] "r" (ptr)                              \
+    : "memory"                                     \
+  );                                               \
+  return res;                                      \
+}
+
+#define DECLARE_ASM_REP_MOVS(Type, Movs)                                       \
+  template <> void asm_rep_movs<Type>(Type * dst, Type * src, size_t size) {   \
+    __asm__("rep " Movs " \n\t"                                                \
+            :                                                                  \
+            : "D"(dst), "S"(src), "c"(size)                                    \
+            : "rsi", "rdi", "rcx", "memory");                                  \
+  }
+
+DECLARE_ASM_WRITE(U8, "8", "movq", "r");
+DECLARE_ASM_READ(U8, "8", "movq", "=r");
+DECLARE_ASM_REP_MOVS(U8, "movsq");
+
+} // End of anonymous namespace
+
+#endif // defined(__x86_64__)
+
+#if defined(__i386__) && defined(__SSE2__) && !defined(__ANDROID__)
+
+namespace {
+
+#define DECLARE_ASM_WRITE(Type, Size, Mov, Reg)        \
+template<> void asm_write<Type>(Type *ptr, Type val) { \
+  __asm__(                                             \
+    Mov " %[val], (%[ptr])  \n\t"                      \
+    :                                                  \
+    : [ptr] "r" (ptr), [val] Reg (val)                 \
+    : "memory"                                         \
+  );                                                   \
+}
+
+#define DECLARE_ASM_READ(Type, Size, Mov, Reg)     \
+template<> Type asm_read<Type>(Type *ptr) {        \
+  Type res;                                        \
+  __asm__(                                         \
+    Mov " (%[ptr]), %[res]  \n\t"                  \
+    : [res] Reg (res)                              \
+    : [ptr] "r" (ptr)                              \
+    : "memory"                                     \
+  );                                               \
+  return res;                                      \
+}
+
+#define DECLARE_ASM_REP_MOVS(Type, Movs)                                       \
+  template <> void asm_rep_movs<Type>(Type * dst, Type * src, size_t size) {   \
+    __asm__("rep " Movs " \n\t"                                                \
+            :                                                                  \
+            : "D"(dst), "S"(src), "c"(size)                                    \
+            : "esi", "edi", "ecx", "memory");                                  \
+  }
+
+} // End of anonymous namespace
+
+#endif  // defined(__i386__) && defined(__SSE2__)
+
+#if defined(__x86_64__) ||                                                     \
+    (defined(__i386__) && defined(__SSE2__) && !defined(__ANDROID__))
+
+namespace {
+
+DECLARE_ASM_WRITE(U1, "1", "movb", "r");
+DECLARE_ASM_WRITE(U2, "2", "movw", "r");
+DECLARE_ASM_WRITE(U4, "4", "movl", "r");
+DECLARE_ASM_WRITE(__m128i, "16", "movaps", "x");
+
+DECLARE_ASM_READ(U1, "1", "movb", "=r");
+DECLARE_ASM_READ(U2, "2", "movw", "=r");
+DECLARE_ASM_READ(U4, "4", "movl", "=r");
+DECLARE_ASM_READ(__m128i, "16", "movaps", "=x");
+
+DECLARE_ASM_REP_MOVS(U1, "movsb");
+DECLARE_ASM_REP_MOVS(U2, "movsw");
+DECLARE_ASM_REP_MOVS(U4, "movsl");
+
+template<typename T> void TestAsmWrite(const char *DeathPattern) {
+  T *buf = new T;
+  EXPECT_DEATH(asm_write(&buf[1], static_cast<T>(0)), DeathPattern);
+  T var = 0x12;
+  asm_write(&var, static_cast<T>(0x21));
+  ASSERT_EQ(static_cast<T>(0x21), var);
+  delete buf;
+}
+
+template<> void TestAsmWrite<__m128i>(const char *DeathPattern) {
+  char *buf = new char[16];
+  char *p = buf + 16;
+  if (((uintptr_t) p % 16) != 0)
+    p = buf + 8;
+  assert(((uintptr_t) p % 16) == 0);
+  __m128i val = _mm_set1_epi16(0x1234);
+  EXPECT_DEATH(asm_write<__m128i>((__m128i*) p, val), DeathPattern);
+  __m128i var = _mm_set1_epi16(0x4321);
+  asm_write(&var, val);
+  ASSERT_EQ(0x1234, _mm_extract_epi16(var, 0));
+  delete [] buf;
+}
+
+template<typename T> void TestAsmRead(const char *DeathPattern) {
+  T *buf = new T;
+  EXPECT_DEATH(asm_read(&buf[1]), DeathPattern);
+  T var = 0x12;
+  ASSERT_EQ(static_cast<T>(0x12), asm_read(&var));
+  delete buf;
+}
+
+template<> void TestAsmRead<__m128i>(const char *DeathPattern) {
+  char *buf = new char[16];
+  char *p = buf + 16;
+  if (((uintptr_t) p % 16) != 0)
+    p = buf + 8;
+  assert(((uintptr_t) p % 16) == 0);
+  EXPECT_DEATH(asm_read<__m128i>((__m128i*) p), DeathPattern);
+  __m128i val = _mm_set1_epi16(0x1234);
+  ASSERT_EQ(0x1234, _mm_extract_epi16(asm_read(&val), 0));
+  delete [] buf;
+}
+
+U4 AsmLoad(U4 *a) {
+  U4 r;
+  __asm__("movl (%[a]), %[r]  \n\t" : [r] "=r" (r) : [a] "r" (a) : "memory");
+  return r;
+}
+
+void AsmStore(U4 r, U4 *a) {
+  __asm__("movl %[r], (%[a])  \n\t" : : [a] "r" (a), [r] "r" (r) : "memory");
+}
+
+template <typename T>
+void TestAsmRepMovs(const char *DeathPatternRead,
+                    const char *DeathPatternWrite) {
+  T src_good[4] = { 0x0, 0x1, 0x2, 0x3 };
+  T dst_good[4] = {};
+  asm_rep_movs(dst_good, src_good, 4);
+  ASSERT_EQ(static_cast<T>(0x0), dst_good[0]);
+  ASSERT_EQ(static_cast<T>(0x1), dst_good[1]);
+  ASSERT_EQ(static_cast<T>(0x2), dst_good[2]);
+  ASSERT_EQ(static_cast<T>(0x3), dst_good[3]);
+
+  T dst_bad[3];
+  EXPECT_DEATH(asm_rep_movs(dst_bad, src_good, 4), DeathPatternWrite);
+
+  T src_bad[3] = { 0x0, 0x1, 0x2 };
+  EXPECT_DEATH(asm_rep_movs(dst_good, src_bad, 4), DeathPatternRead);
+
+  T* dp = dst_bad + 4;
+  T* sp = src_bad + 4;
+  asm_rep_movs(dp, sp, 0);
+}
+
+} // End of anonymous namespace
+
+TEST(AddressSanitizer, asm_load_store) {
+  U4* buf = new U4[2];
+  EXPECT_DEATH(AsmLoad(&buf[3]), "READ of size 4");
+  EXPECT_DEATH(AsmStore(0x1234, &buf[3]), "WRITE of size 4");
+  delete [] buf;
+}
+
+TEST(AddressSanitizer, asm_rw) {
+  TestAsmWrite<U1>("WRITE of size 1");
+  TestAsmWrite<U2>("WRITE of size 2");
+  TestAsmWrite<U4>("WRITE of size 4");
+#if defined(__x86_64__)
+  TestAsmWrite<U8>("WRITE of size 8");
+#endif // defined(__x86_64__)
+  TestAsmWrite<__m128i>("WRITE of size 16");
+
+  TestAsmRead<U1>("READ of size 1");
+  TestAsmRead<U2>("READ of size 2");
+  TestAsmRead<U4>("READ of size 4");
+#if defined(__x86_64__)
+  TestAsmRead<U8>("READ of size 8");
+#endif // defined(__x86_64__)
+  TestAsmRead<__m128i>("READ of size 16");
+}
+
+TEST(AddressSanitizer, asm_flags) {
+  long magic = 0x1234;
+  long r = 0x0;
+
+#if defined(__x86_64__) && !defined(__ILP32__)
+  __asm__("xorq %%rax, %%rax  \n\t"
+          "movq (%[p]), %%rax \n\t"
+          "sete %%al          \n\t"
+          "movzbq %%al, %[r]  \n\t"
+          : [r] "=r"(r)
+          : [p] "r"(&magic)
+          : "rax", "memory");
+#else
+  __asm__("xorl %%eax, %%eax  \n\t"
+          "movl (%[p]), %%eax \n\t"
+          "sete %%al          \n\t"
+          "movzbl %%al, %[r]  \n\t"
+          : [r] "=r"(r)
+          : [p] "r"(&magic)
+          : "eax", "memory");
+#endif // defined(__x86_64__) && !defined(__ILP32__)
+
+  ASSERT_EQ(0x1, r);
+}
+
+TEST(AddressSanitizer, asm_rep_movs) {
+  TestAsmRepMovs<U1>("READ of size 1", "WRITE of size 1");
+  TestAsmRepMovs<U2>("READ of size 2", "WRITE of size 2");
+  TestAsmRepMovs<U4>("READ of size 4", "WRITE of size 4");
+#if defined(__x86_64__)
+  TestAsmRepMovs<U8>("READ of size 8", "WRITE of size 8");
+#endif  // defined(__x86_64__)
+}
+
+#endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
+
+#endif // defined(__linux__)
diff --git a/compiler-rt/lib/asan/tests/asan_benchmarks_test.cc b/compiler-rt/lib/asan/tests/asan_benchmarks_test.cc
new file mode 100644
index 0000000..fc522de
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_benchmarks_test.cc
@@ -0,0 +1,85 @@
+//===-- asan_benchmarks_test.cc ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Some benchmarks for the instrumented code.
+//===----------------------------------------------------------------------===//
+
+#include "asan_test_utils.h"
+
+template<class T>
+__attribute__((noinline))
+static void ManyAccessFunc(T *x, size_t n_elements, size_t n_iter) {
+  for (size_t iter = 0; iter < n_iter; iter++) {
+    break_optimization(0);
+    // hand unroll the loop to stress the reg alloc.
+    for (size_t i = 0; i <= n_elements - 16; i += 16) {
+      x[i + 0] = i;
+      x[i + 1] = i;
+      x[i + 2] = i;
+      x[i + 3] = i;
+      x[i + 4] = i;
+      x[i + 5] = i;
+      x[i + 6] = i;
+      x[i + 7] = i;
+      x[i + 8] = i;
+      x[i + 9] = i;
+      x[i + 10] = i;
+      x[i + 11] = i;
+      x[i + 12] = i;
+      x[i + 13] = i;
+      x[i + 14] = i;
+      x[i + 15] = i;
+    }
+  }
+}
+
+TEST(AddressSanitizer, ManyAccessBenchmark) {
+  size_t kLen = 1024;
+  int *int_array = new int[kLen];
+  ManyAccessFunc(int_array, kLen, 1 << 24);
+  delete [] int_array;
+}
+
+// access 7 char elements in a 7 byte array (i.e. on the border).
+__attribute__((noinline))
+static void BorderAccessFunc(char *x, size_t n_iter) {
+  for (size_t iter = 0; iter < n_iter; iter++) {
+    break_optimization(x);
+    x[0] = 0;
+    x[1] = 0;
+    x[2] = 0;
+    x[3] = 0;
+    x[4] = 0;
+    x[5] = 0;
+    x[6] = 0;
+  }
+}
+
+TEST(AddressSanitizer, BorderAccessBenchmark) {
+  char *char_7_array = new char[7];
+  BorderAccessFunc(char_7_array, 1 << 30);
+  delete [] char_7_array;
+}
+
+static void FunctionWithLargeStack() {
+  int stack[1000];
+  Ident(stack);
+}
+
+TEST(AddressSanitizer, FakeStackBenchmark) {
+  for (int i = 0; i < 10000000; i++)
+    Ident(&FunctionWithLargeStack)();
+}
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/compiler-rt/lib/asan/tests/asan_exceptions_test.cc b/compiler-rt/lib/asan/tests/asan_exceptions_test.cc
new file mode 100644
index 0000000..ecd406d
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_exceptions_test.cc
@@ -0,0 +1,27 @@
+// See http://llvm.org/bugs/show_bug.cgi?id=11468
+#include <stdio.h>
+#include <string>
+
+class Action {
+ public:
+  Action() {}
+  void PrintString(const std::string& msg) const {
+    fprintf(stderr, "%s\n", msg.c_str());
+  }
+  void Throw(const char& arg) const {
+    PrintString("PrintString called!");  // this line is important
+    throw arg;
+  }
+};
+
+int main() {
+  const Action a;
+  fprintf(stderr, "&a before = %p\n", &a);
+  try {
+    a.Throw('c');
+  } catch(const char&) {
+    fprintf(stderr, "&a in catch = %p\n", &a);
+  }
+  fprintf(stderr, "&a final = %p\n", &a);
+  return 0;
+}
diff --git a/compiler-rt/lib/asan/tests/asan_fake_stack_test.cc b/compiler-rt/lib/asan/tests/asan_fake_stack_test.cc
new file mode 100644
index 0000000..516142f
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_fake_stack_test.cc
@@ -0,0 +1,152 @@
+//===-- asan_fake_stack_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Tests for FakeStack.
+// This test file should be compiled w/o asan instrumentation.
+//===----------------------------------------------------------------------===//
+
+#include "asan_fake_stack.h"
+#include "asan_test_utils.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <map>
+
+namespace __asan {
+
+TEST(FakeStack, FlagsSize) {
+  EXPECT_EQ(FakeStack::SizeRequiredForFlags(10), 1U << 5);
+  EXPECT_EQ(FakeStack::SizeRequiredForFlags(11), 1U << 6);
+  EXPECT_EQ(FakeStack::SizeRequiredForFlags(20), 1U << 15);
+}
+
+TEST(FakeStack, RequiredSize) {
+  // for (int i = 15; i < 20; i++) {
+  //  uptr alloc_size = FakeStack::RequiredSize(i);
+  //  printf("%zdK ==> %zd\n", 1 << (i - 10), alloc_size);
+  // }
+  EXPECT_EQ(FakeStack::RequiredSize(15), 365568U);
+  EXPECT_EQ(FakeStack::RequiredSize(16), 727040U);
+  EXPECT_EQ(FakeStack::RequiredSize(17), 1449984U);
+  EXPECT_EQ(FakeStack::RequiredSize(18), 2895872U);
+  EXPECT_EQ(FakeStack::RequiredSize(19), 5787648U);
+}
+
+TEST(FakeStack, FlagsOffset) {
+  for (uptr stack_size_log = 15; stack_size_log <= 20; stack_size_log++) {
+    uptr stack_size = 1UL << stack_size_log;
+    uptr offset = 0;
+    for (uptr class_id = 0; class_id < FakeStack::kNumberOfSizeClasses;
+         class_id++) {
+      uptr frame_size = FakeStack::BytesInSizeClass(class_id);
+      uptr num_flags = stack_size / frame_size;
+      EXPECT_EQ(offset, FakeStack::FlagsOffset(stack_size_log, class_id));
+      // printf("%zd: %zd => %zd %zd\n", stack_size_log, class_id, offset,
+      //        FakeStack::FlagsOffset(stack_size_log, class_id));
+      offset += num_flags;
+    }
+  }
+}
+
+#if !defined(_WIN32)  // FIXME: Fails due to OOM on Windows.
+TEST(FakeStack, CreateDestroy) {
+  for (int i = 0; i < 1000; i++) {
+    for (uptr stack_size_log = 20; stack_size_log <= 22; stack_size_log++) {
+      FakeStack *fake_stack = FakeStack::Create(stack_size_log);
+      fake_stack->Destroy(0);
+    }
+  }
+}
+#endif
+
+TEST(FakeStack, ModuloNumberOfFrames) {
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, 0), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<15)), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<10)), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<9)), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<8)), 1U<<8);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<15) + 1), 1U);
+
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 0), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 1<<9), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 1<<8), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 1<<7), 1U<<7);
+
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 0), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 1), 1U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 15), 15U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 16), 0U);
+  EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 17), 1U);
+}
+
+TEST(FakeStack, GetFrame) {
+  const uptr stack_size_log = 20;
+  const uptr stack_size = 1 << stack_size_log;
+  FakeStack *fs = FakeStack::Create(stack_size_log);
+  u8 *base = fs->GetFrame(stack_size_log, 0, 0);
+  EXPECT_EQ(base, reinterpret_cast<u8 *>(fs) +
+                      fs->SizeRequiredForFlags(stack_size_log) + 4096);
+  EXPECT_EQ(base + 0*stack_size + 64 * 7, fs->GetFrame(stack_size_log, 0, 7U));
+  EXPECT_EQ(base + 1*stack_size + 128 * 3, fs->GetFrame(stack_size_log, 1, 3U));
+  EXPECT_EQ(base + 2*stack_size + 256 * 5, fs->GetFrame(stack_size_log, 2, 5U));
+  fs->Destroy(0);
+}
+
+TEST(FakeStack, Allocate) {
+  const uptr stack_size_log = 19;
+  FakeStack *fs = FakeStack::Create(stack_size_log);
+  std::map<FakeFrame *, uptr> s;
+  for (int iter = 0; iter < 2; iter++) {
+    s.clear();
+    for (uptr cid = 0; cid < FakeStack::kNumberOfSizeClasses; cid++) {
+      uptr n = FakeStack::NumberOfFrames(stack_size_log, cid);
+      uptr bytes_in_class = FakeStack::BytesInSizeClass(cid);
+      for (uptr j = 0; j < n; j++) {
+        FakeFrame *ff = fs->Allocate(stack_size_log, cid, 0);
+        uptr x = reinterpret_cast<uptr>(ff);
+        EXPECT_TRUE(s.insert(std::make_pair(ff, cid)).second);
+        EXPECT_EQ(x, fs->AddrIsInFakeStack(x));
+        EXPECT_EQ(x, fs->AddrIsInFakeStack(x + 1));
+        EXPECT_EQ(x, fs->AddrIsInFakeStack(x + bytes_in_class - 1));
+        EXPECT_NE(x, fs->AddrIsInFakeStack(x + bytes_in_class));
+      }
+      // We are out of fake stack, so Allocate should return 0.
+      EXPECT_EQ(0UL, fs->Allocate(stack_size_log, cid, 0));
+    }
+    for (std::map<FakeFrame *, uptr>::iterator it = s.begin(); it != s.end();
+         ++it) {
+      fs->Deallocate(reinterpret_cast<uptr>(it->first), it->second);
+    }
+  }
+  fs->Destroy(0);
+}
+
+static void RecursiveFunction(FakeStack *fs, int depth) {
+  uptr class_id = depth / 3;
+  FakeFrame *ff = fs->Allocate(fs->stack_size_log(), class_id, 0);
+  if (depth) {
+    RecursiveFunction(fs, depth - 1);
+    RecursiveFunction(fs, depth - 1);
+  }
+  fs->Deallocate(reinterpret_cast<uptr>(ff), class_id);
+}
+
+TEST(FakeStack, RecursiveStressTest) {
+  const uptr stack_size_log = 16;
+  FakeStack *fs = FakeStack::Create(stack_size_log);
+  RecursiveFunction(fs, 22);  // with 26 runs for 2-3 seconds.
+  fs->Destroy(0);
+}
+
+}  // namespace __asan
diff --git a/compiler-rt/lib/asan/tests/asan_globals_test.cc b/compiler-rt/lib/asan/tests/asan_globals_test.cc
new file mode 100644
index 0000000..5042ef0
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_globals_test.cc
@@ -0,0 +1,45 @@
+//===-- asan_globals_test.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Some globals in a separate file.
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+
+char glob1[1];
+char glob2[2];
+char glob3[3];
+char glob4[4];
+char glob5[5];
+char glob6[6];
+char glob7[7];
+char glob8[8];
+char glob9[9];
+char glob10[10];
+char glob11[11];
+char glob12[12];
+char glob13[13];
+char glob14[14];
+char glob15[15];
+char glob16[16];
+char glob17[17];
+char glob1000[1000];
+char glob10000[10000];
+char glob100000[100000];
+
+static char static10[10];
+
+int GlobalsTest(int zero) {
+  static char func_static15[15];
+  glob5[zero] = 0;
+  static10[zero] = 0;
+  func_static15[zero] = 0;
+  return glob5[1] + func_static15[2];
+}
diff --git a/compiler-rt/lib/asan/tests/asan_interface_test.cc b/compiler-rt/lib/asan/tests/asan_interface_test.cc
new file mode 100644
index 0000000..f5bfb80
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_interface_test.cc
@@ -0,0 +1,423 @@
+//===-- asan_interface_test.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+#include <sanitizer/allocator_interface.h>
+#include <sanitizer/asan_interface.h>
+
+TEST(AddressSanitizerInterface, GetEstimatedAllocatedSize) {
+  EXPECT_EQ(0U, __sanitizer_get_estimated_allocated_size(0));
+  const size_t sizes[] = { 1, 30, 1<<30 };
+  for (size_t i = 0; i < 3; i++) {
+    EXPECT_EQ(sizes[i], __sanitizer_get_estimated_allocated_size(sizes[i]));
+  }
+}
+
+static const char* kGetAllocatedSizeErrorMsg =
+  "attempting to call __sanitizer_get_allocated_size";
+
+TEST(AddressSanitizerInterface, GetAllocatedSizeAndOwnershipTest) {
+  const size_t kArraySize = 100;
+  char *array = Ident((char*)malloc(kArraySize));
+  int *int_ptr = Ident(new int);
+
+  // Allocated memory is owned by allocator. Allocated size should be
+  // equal to requested size.
+  EXPECT_EQ(true, __sanitizer_get_ownership(array));
+  EXPECT_EQ(kArraySize, __sanitizer_get_allocated_size(array));
+  EXPECT_EQ(true, __sanitizer_get_ownership(int_ptr));
+  EXPECT_EQ(sizeof(int), __sanitizer_get_allocated_size(int_ptr));
+
+  // We cannot call GetAllocatedSize from the memory we didn't map,
+  // and from the interior pointers (not returned by previous malloc).
+  void *wild_addr = (void*)0x1;
+  EXPECT_FALSE(__sanitizer_get_ownership(wild_addr));
+  EXPECT_DEATH(__sanitizer_get_allocated_size(wild_addr),
+               kGetAllocatedSizeErrorMsg);
+  EXPECT_FALSE(__sanitizer_get_ownership(array + kArraySize / 2));
+  EXPECT_DEATH(__sanitizer_get_allocated_size(array + kArraySize / 2),
+               kGetAllocatedSizeErrorMsg);
+
+  // NULL is not owned, but is a valid argument for
+  // __sanitizer_get_allocated_size().
+  EXPECT_FALSE(__sanitizer_get_ownership(NULL));
+  EXPECT_EQ(0U, __sanitizer_get_allocated_size(NULL));
+
+  // When memory is freed, it's not owned, and call to GetAllocatedSize
+  // is forbidden.
+  free(array);
+  EXPECT_FALSE(__sanitizer_get_ownership(array));
+  EXPECT_DEATH(__sanitizer_get_allocated_size(array),
+               kGetAllocatedSizeErrorMsg);
+  delete int_ptr;
+
+  void *zero_alloc = Ident(malloc(0));
+  if (zero_alloc != 0) {
+    // If malloc(0) is not null, this pointer is owned and should have valid
+    // allocated size.
+    EXPECT_TRUE(__sanitizer_get_ownership(zero_alloc));
+    // Allocated size is 0 or 1 depending on the allocator used.
+    EXPECT_LT(__sanitizer_get_allocated_size(zero_alloc), 2U);
+  }
+  free(zero_alloc);
+}
+
+TEST(AddressSanitizerInterface, GetCurrentAllocatedBytesTest) {
+  size_t before_malloc, after_malloc, after_free;
+  char *array;
+  const size_t kMallocSize = 100;
+  before_malloc = __sanitizer_get_current_allocated_bytes();
+
+  array = Ident((char*)malloc(kMallocSize));
+  after_malloc = __sanitizer_get_current_allocated_bytes();
+  EXPECT_EQ(before_malloc + kMallocSize, after_malloc);
+
+  free(array);
+  after_free = __sanitizer_get_current_allocated_bytes();
+  EXPECT_EQ(before_malloc, after_free);
+}
+
+TEST(AddressSanitizerInterface, GetHeapSizeTest) {
+  // ASan allocator does not keep huge chunks in free list, but unmaps them.
+  // The chunk should be greater than the quarantine size,
+  // otherwise it will be stuck in quarantine instead of being unmaped.
+  static const size_t kLargeMallocSize = (1 << 28) + 1;  // 256M
+  free(Ident(malloc(kLargeMallocSize)));  // Drain quarantine.
+  size_t old_heap_size = __sanitizer_get_heap_size();
+  for (int i = 0; i < 3; i++) {
+    // fprintf(stderr, "allocating %zu bytes:\n", kLargeMallocSize);
+    free(Ident(malloc(kLargeMallocSize)));
+    EXPECT_EQ(old_heap_size, __sanitizer_get_heap_size());
+  }
+}
+
+static const size_t kManyThreadsMallocSizes[] = {5, 1UL<<10, 1UL<<14, 357};
+static const size_t kManyThreadsIterations = 250;
+static const size_t kManyThreadsNumThreads =
+  (SANITIZER_WORDSIZE == 32) ? 40 : 200;
+
+static void *ManyThreadsWithStatsWorker(void *arg) {
+  (void)arg;
+  for (size_t iter = 0; iter < kManyThreadsIterations; iter++) {
+    for (size_t size_index = 0; size_index < 4; size_index++) {
+      free(Ident(malloc(kManyThreadsMallocSizes[size_index])));
+    }
+  }
+  // Just one large allocation.
+  free(Ident(malloc(1 << 20)));
+  return 0;
+}
+
+TEST(AddressSanitizerInterface, ManyThreadsWithStatsStressTest) {
+  size_t before_test, after_test, i;
+  pthread_t threads[kManyThreadsNumThreads];
+  before_test = __sanitizer_get_current_allocated_bytes();
+  for (i = 0; i < kManyThreadsNumThreads; i++) {
+    PTHREAD_CREATE(&threads[i], 0,
+                   (void* (*)(void *x))ManyThreadsWithStatsWorker, (void*)i);
+  }
+  for (i = 0; i < kManyThreadsNumThreads; i++) {
+    PTHREAD_JOIN(threads[i], 0);
+  }
+  after_test = __sanitizer_get_current_allocated_bytes();
+  // ASan stats also reflect memory usage of internal ASan RTL structs,
+  // so we can't check for equality here.
+  EXPECT_LT(after_test, before_test + (1UL<<20));
+}
+
+static void DoDoubleFree() {
+  int *x = Ident(new int);
+  delete Ident(x);
+  delete Ident(x);
+}
+
+static void MyDeathCallback() {
+  fprintf(stderr, "MyDeathCallback\n");
+  fflush(0);  // On Windows, stderr doesn't flush on crash.
+}
+
+TEST(AddressSanitizerInterface, DeathCallbackTest) {
+  __asan_set_death_callback(MyDeathCallback);
+  EXPECT_DEATH(DoDoubleFree(), "MyDeathCallback");
+  __asan_set_death_callback(NULL);
+}
+
+static const char* kUseAfterPoisonErrorMessage = "use-after-poison";
+
+#define GOOD_ACCESS(ptr, offset)  \
+    EXPECT_FALSE(__asan_address_is_poisoned(ptr + offset))
+
+#define BAD_ACCESS(ptr, offset) \
+    EXPECT_TRUE(__asan_address_is_poisoned(ptr + offset))
+
+TEST(AddressSanitizerInterface, SimplePoisonMemoryRegionTest) {
+  char *array = Ident((char*)malloc(120));
+  // poison array[40..80)
+  __asan_poison_memory_region(array + 40, 40);
+  GOOD_ACCESS(array, 39);
+  GOOD_ACCESS(array, 80);
+  BAD_ACCESS(array, 40);
+  BAD_ACCESS(array, 60);
+  BAD_ACCESS(array, 79);
+  char value;
+  EXPECT_DEATH(value = Ident(array[40]), kUseAfterPoisonErrorMessage);
+  __asan_unpoison_memory_region(array + 40, 40);
+  // access previously poisoned memory.
+  GOOD_ACCESS(array, 40);
+  GOOD_ACCESS(array, 79);
+  free(array);
+}
+
+TEST(AddressSanitizerInterface, OverlappingPoisonMemoryRegionTest) {
+  char *array = Ident((char*)malloc(120));
+  // Poison [0..40) and [80..120)
+  __asan_poison_memory_region(array, 40);
+  __asan_poison_memory_region(array + 80, 40);
+  BAD_ACCESS(array, 20);
+  GOOD_ACCESS(array, 60);
+  BAD_ACCESS(array, 100);
+  // Poison whole array - [0..120)
+  __asan_poison_memory_region(array, 120);
+  BAD_ACCESS(array, 60);
+  // Unpoison [24..96)
+  __asan_unpoison_memory_region(array + 24, 72);
+  BAD_ACCESS(array, 23);
+  GOOD_ACCESS(array, 24);
+  GOOD_ACCESS(array, 60);
+  GOOD_ACCESS(array, 95);
+  BAD_ACCESS(array, 96);
+  free(array);
+}
+
+TEST(AddressSanitizerInterface, PushAndPopWithPoisoningTest) {
+  // Vector of capacity 20
+  char *vec = Ident((char*)malloc(20));
+  __asan_poison_memory_region(vec, 20);
+  for (size_t i = 0; i < 7; i++) {
+    // Simulate push_back.
+    __asan_unpoison_memory_region(vec + i, 1);
+    GOOD_ACCESS(vec, i);
+    BAD_ACCESS(vec, i + 1);
+  }
+  for (size_t i = 7; i > 0; i--) {
+    // Simulate pop_back.
+    __asan_poison_memory_region(vec + i - 1, 1);
+    BAD_ACCESS(vec, i - 1);
+    if (i > 1) GOOD_ACCESS(vec, i - 2);
+  }
+  free(vec);
+}
+
+// Make sure that each aligned block of size "2^granularity" doesn't have
+// "true" value before "false" value.
+static void MakeShadowValid(bool *shadow, int length, int granularity) {
+  bool can_be_poisoned = true;
+  for (int i = length - 1; i >= 0; i--) {
+    if (!shadow[i])
+      can_be_poisoned = false;
+    if (!can_be_poisoned)
+      shadow[i] = false;
+    if (i % (1 << granularity) == 0) {
+      can_be_poisoned = true;
+    }
+  }
+}
+
+TEST(AddressSanitizerInterface, PoisoningStressTest) {
+  const size_t kSize = 24;
+  bool expected[kSize];
+  char *arr = Ident((char*)malloc(kSize));
+  for (size_t l1 = 0; l1 < kSize; l1++) {
+    for (size_t s1 = 1; l1 + s1 <= kSize; s1++) {
+      for (size_t l2 = 0; l2 < kSize; l2++) {
+        for (size_t s2 = 1; l2 + s2 <= kSize; s2++) {
+          // Poison [l1, l1+s1), [l2, l2+s2) and check result.
+          __asan_unpoison_memory_region(arr, kSize);
+          __asan_poison_memory_region(arr + l1, s1);
+          __asan_poison_memory_region(arr + l2, s2);
+          memset(expected, false, kSize);
+          memset(expected + l1, true, s1);
+          MakeShadowValid(expected, kSize, /*granularity*/ 3);
+          memset(expected + l2, true, s2);
+          MakeShadowValid(expected, kSize, /*granularity*/ 3);
+          for (size_t i = 0; i < kSize; i++) {
+            ASSERT_EQ(expected[i], __asan_address_is_poisoned(arr + i));
+          }
+          // Unpoison [l1, l1+s1) and [l2, l2+s2) and check result.
+          __asan_poison_memory_region(arr, kSize);
+          __asan_unpoison_memory_region(arr + l1, s1);
+          __asan_unpoison_memory_region(arr + l2, s2);
+          memset(expected, true, kSize);
+          memset(expected + l1, false, s1);
+          MakeShadowValid(expected, kSize, /*granularity*/ 3);
+          memset(expected + l2, false, s2);
+          MakeShadowValid(expected, kSize, /*granularity*/ 3);
+          for (size_t i = 0; i < kSize; i++) {
+            ASSERT_EQ(expected[i], __asan_address_is_poisoned(arr + i));
+          }
+        }
+      }
+    }
+  }
+  free(arr);
+}
+
+TEST(AddressSanitizerInterface, GlobalRedzones) {
+  GOOD_ACCESS(glob1, 1 - 1);
+  GOOD_ACCESS(glob2, 2 - 1);
+  GOOD_ACCESS(glob3, 3 - 1);
+  GOOD_ACCESS(glob4, 4 - 1);
+  GOOD_ACCESS(glob5, 5 - 1);
+  GOOD_ACCESS(glob6, 6 - 1);
+  GOOD_ACCESS(glob7, 7 - 1);
+  GOOD_ACCESS(glob8, 8 - 1);
+  GOOD_ACCESS(glob9, 9 - 1);
+  GOOD_ACCESS(glob10, 10 - 1);
+  GOOD_ACCESS(glob11, 11 - 1);
+  GOOD_ACCESS(glob12, 12 - 1);
+  GOOD_ACCESS(glob13, 13 - 1);
+  GOOD_ACCESS(glob14, 14 - 1);
+  GOOD_ACCESS(glob15, 15 - 1);
+  GOOD_ACCESS(glob16, 16 - 1);
+  GOOD_ACCESS(glob17, 17 - 1);
+  GOOD_ACCESS(glob1000, 1000 - 1);
+  GOOD_ACCESS(glob10000, 10000 - 1);
+  GOOD_ACCESS(glob100000, 100000 - 1);
+
+  BAD_ACCESS(glob1, 1);
+  BAD_ACCESS(glob2, 2);
+  BAD_ACCESS(glob3, 3);
+  BAD_ACCESS(glob4, 4);
+  BAD_ACCESS(glob5, 5);
+  BAD_ACCESS(glob6, 6);
+  BAD_ACCESS(glob7, 7);
+  BAD_ACCESS(glob8, 8);
+  BAD_ACCESS(glob9, 9);
+  BAD_ACCESS(glob10, 10);
+  BAD_ACCESS(glob11, 11);
+  BAD_ACCESS(glob12, 12);
+  BAD_ACCESS(glob13, 13);
+  BAD_ACCESS(glob14, 14);
+  BAD_ACCESS(glob15, 15);
+  BAD_ACCESS(glob16, 16);
+  BAD_ACCESS(glob17, 17);
+  BAD_ACCESS(glob1000, 1000);
+  BAD_ACCESS(glob1000, 1100);  // Redzone is at least 101 bytes.
+  BAD_ACCESS(glob10000, 10000);
+  BAD_ACCESS(glob10000, 11000);  // Redzone is at least 1001 bytes.
+  BAD_ACCESS(glob100000, 100000);
+  BAD_ACCESS(glob100000, 110000);  // Redzone is at least 10001 bytes.
+}
+
+TEST(AddressSanitizerInterface, PoisonedRegion) {
+  size_t rz = 16;
+  for (size_t size = 1; size <= 64; size++) {
+    char *p = new char[size];
+    for (size_t beg = 0; beg < size + rz; beg++) {
+      for (size_t end = beg; end < size + rz; end++) {
+        void *first_poisoned = __asan_region_is_poisoned(p + beg, end - beg);
+        if (beg == end) {
+          EXPECT_FALSE(first_poisoned);
+        } else if (beg < size && end <= size) {
+          EXPECT_FALSE(first_poisoned);
+        } else if (beg >= size) {
+          EXPECT_EQ(p + beg, first_poisoned);
+        } else {
+          EXPECT_GT(end, size);
+          EXPECT_EQ(p + size, first_poisoned);
+        }
+      }
+    }
+    delete [] p;
+  }
+}
+
+// This is a performance benchmark for manual runs.
+// asan's memset interceptor calls mem_is_zero for the entire shadow region.
+// the profile should look like this:
+//     89.10%   [.] __memset_sse2
+//     10.50%   [.] __sanitizer::mem_is_zero
+// I.e. mem_is_zero should consume ~ SHADOW_GRANULARITY less CPU cycles
+// than memset itself.
+TEST(AddressSanitizerInterface, DISABLED_StressLargeMemset) {
+  size_t size = 1 << 20;
+  char *x = new char[size];
+  for (int i = 0; i < 100000; i++)
+    Ident(memset)(x, 0, size);
+  delete [] x;
+}
+
+// Same here, but we run memset with small sizes.
+TEST(AddressSanitizerInterface, DISABLED_StressSmallMemset) {
+  size_t size = 32;
+  char *x = new char[size];
+  for (int i = 0; i < 100000000; i++)
+    Ident(memset)(x, 0, size);
+  delete [] x;
+}
+static const char *kInvalidPoisonMessage = "invalid-poison-memory-range";
+static const char *kInvalidUnpoisonMessage = "invalid-unpoison-memory-range";
+
+TEST(AddressSanitizerInterface, DISABLED_InvalidPoisonAndUnpoisonCallsTest) {
+  char *array = Ident((char*)malloc(120));
+  __asan_unpoison_memory_region(array, 120);
+  // Try to unpoison not owned memory
+  EXPECT_DEATH(__asan_unpoison_memory_region(array, 121),
+               kInvalidUnpoisonMessage);
+  EXPECT_DEATH(__asan_unpoison_memory_region(array - 1, 120),
+               kInvalidUnpoisonMessage);
+
+  __asan_poison_memory_region(array, 120);
+  // Try to poison not owned memory.
+  EXPECT_DEATH(__asan_poison_memory_region(array, 121), kInvalidPoisonMessage);
+  EXPECT_DEATH(__asan_poison_memory_region(array - 1, 120),
+               kInvalidPoisonMessage);
+  free(array);
+}
+
+#if !defined(_WIN32)  // FIXME: This should really be a lit test.
+static void ErrorReportCallbackOneToZ(const char *report) {
+  int report_len = strlen(report);
+  ASSERT_EQ(6, write(2, "ABCDEF", 6));
+  ASSERT_EQ(report_len, write(2, report, report_len));
+  ASSERT_EQ(6, write(2, "ABCDEF", 6));
+  _exit(1);
+}
+
+TEST(AddressSanitizerInterface, SetErrorReportCallbackTest) {
+  __asan_set_error_report_callback(ErrorReportCallbackOneToZ);
+  EXPECT_DEATH(__asan_report_error(0, 0, 0, 0, true, 1),
+               ASAN_PCRE_DOTALL "ABCDEF.*AddressSanitizer.*WRITE.*ABCDEF");
+  __asan_set_error_report_callback(NULL);
+}
+#endif
+
+TEST(AddressSanitizerInterface, GetOwnershipStressTest) {
+  std::vector<char *> pointers;
+  std::vector<size_t> sizes;
+  const size_t kNumMallocs = 1 << 9;
+  for (size_t i = 0; i < kNumMallocs; i++) {
+    size_t size = i * 100 + 1;
+    pointers.push_back((char*)malloc(size));
+    sizes.push_back(size);
+  }
+  for (size_t i = 0; i < 4000000; i++) {
+    EXPECT_FALSE(__sanitizer_get_ownership(&pointers));
+    EXPECT_FALSE(__sanitizer_get_ownership((void*)0x1234));
+    size_t idx = i % kNumMallocs;
+    EXPECT_TRUE(__sanitizer_get_ownership(pointers[idx]));
+    EXPECT_EQ(sizes[idx], __sanitizer_get_allocated_size(pointers[idx]));
+  }
+  for (size_t i = 0, n = pointers.size(); i < n; i++)
+    free(pointers[i]);
+}
+
diff --git a/compiler-rt/lib/asan/tests/asan_mac_test.cc b/compiler-rt/lib/asan/tests/asan_mac_test.cc
new file mode 100644
index 0000000..dfa6d75
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_mac_test.cc
@@ -0,0 +1,236 @@
+//===-- asan_test_mac.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+
+#include "asan_test_utils.h"
+
+#include "asan_mac_test.h"
+
+#include <malloc/malloc.h>
+#include <AvailabilityMacros.h>  // For MAC_OS_X_VERSION_*
+#include <CoreFoundation/CFString.h>
+
+TEST(AddressSanitizerMac, CFAllocatorDefaultDoubleFree) {
+  EXPECT_DEATH(
+      CFAllocatorDefaultDoubleFree(NULL),
+      "attempting double-free");
+}
+
+void CFAllocator_DoubleFreeOnPthread() {
+  pthread_t child;
+  PTHREAD_CREATE(&child, NULL, CFAllocatorDefaultDoubleFree, NULL);
+  PTHREAD_JOIN(child, NULL);  // Shouldn't be reached.
+}
+
+TEST(AddressSanitizerMac, CFAllocatorDefaultDoubleFree_ChildPhread) {
+  EXPECT_DEATH(CFAllocator_DoubleFreeOnPthread(), "attempting double-free");
+}
+
+namespace {
+
+void *GLOB;
+
+void *CFAllocatorAllocateToGlob(void *unused) {
+  GLOB = CFAllocatorAllocate(NULL, 100, /*hint*/0);
+  return NULL;
+}
+
+void *CFAllocatorDeallocateFromGlob(void *unused) {
+  char *p = (char*)GLOB;
+  p[100] = 'A';  // ASan should report an error here.
+  CFAllocatorDeallocate(NULL, GLOB);
+  return NULL;
+}
+
+void CFAllocator_PassMemoryToAnotherThread() {
+  pthread_t th1, th2;
+  PTHREAD_CREATE(&th1, NULL, CFAllocatorAllocateToGlob, NULL);
+  PTHREAD_JOIN(th1, NULL);
+  PTHREAD_CREATE(&th2, NULL, CFAllocatorDeallocateFromGlob, NULL);
+  PTHREAD_JOIN(th2, NULL);
+}
+
+TEST(AddressSanitizerMac, CFAllocator_PassMemoryToAnotherThread) {
+  EXPECT_DEATH(CFAllocator_PassMemoryToAnotherThread(),
+               "heap-buffer-overflow");
+}
+
+}  // namespace
+
+// TODO(glider): figure out whether we still need these tests. Is it correct
+// to intercept the non-default CFAllocators?
+TEST(AddressSanitizerMac, DISABLED_CFAllocatorSystemDefaultDoubleFree) {
+  EXPECT_DEATH(
+      CFAllocatorSystemDefaultDoubleFree(),
+      "attempting double-free");
+}
+
+// We're intercepting malloc, so kCFAllocatorMalloc is routed to ASan.
+TEST(AddressSanitizerMac, CFAllocatorMallocDoubleFree) {
+  EXPECT_DEATH(CFAllocatorMallocDoubleFree(), "attempting double-free");
+}
+
+TEST(AddressSanitizerMac, DISABLED_CFAllocatorMallocZoneDoubleFree) {
+  EXPECT_DEATH(CFAllocatorMallocZoneDoubleFree(), "attempting double-free");
+}
+
+// For libdispatch tests below we check that ASan got to the shadow byte
+// legend, i.e. managed to print the thread stacks (this almost certainly
+// means that the libdispatch task creation has been intercepted correctly).
+TEST(AddressSanitizerMac, GCDDispatchAsync) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDDispatchAsync(), "Shadow byte legend");
+}
+
+TEST(AddressSanitizerMac, GCDDispatchSync) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDDispatchSync(), "Shadow byte legend");
+}
+
+
+TEST(AddressSanitizerMac, GCDReuseWqthreadsAsync) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDReuseWqthreadsAsync(), "Shadow byte legend");
+}
+
+TEST(AddressSanitizerMac, GCDReuseWqthreadsSync) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDReuseWqthreadsSync(), "Shadow byte legend");
+}
+
+TEST(AddressSanitizerMac, GCDDispatchAfter) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDDispatchAfter(), "Shadow byte legend");
+}
+
+TEST(AddressSanitizerMac, GCDSourceEvent) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDSourceEvent(), "Shadow byte legend");
+}
+
+TEST(AddressSanitizerMac, GCDSourceCancel) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDSourceCancel(), "Shadow byte legend");
+}
+
+TEST(AddressSanitizerMac, GCDGroupAsync) {
+  // Make sure the whole ASan report is printed, i.e. that we don't die
+  // on a CHECK.
+  EXPECT_DEATH(TestGCDGroupAsync(), "Shadow byte legend");
+}
+
+void *MallocIntrospectionLockWorker(void *_) {
+  const int kNumPointers = 100;
+  int i;
+  void *pointers[kNumPointers];
+  for (i = 0; i < kNumPointers; i++) {
+    pointers[i] = malloc(i + 1);
+  }
+  for (i = 0; i < kNumPointers; i++) {
+    free(pointers[i]);
+  }
+
+  return NULL;
+}
+
+void *MallocIntrospectionLockForker(void *_) {
+  pid_t result = fork();
+  if (result == -1) {
+    perror("fork");
+  }
+  assert(result != -1);
+  if (result == 0) {
+    // Call malloc in the child process to make sure we won't deadlock.
+    void *ptr = malloc(42);
+    free(ptr);
+    exit(0);
+  } else {
+    // Return in the parent process.
+    return NULL;
+  }
+}
+
+TEST(AddressSanitizerMac, MallocIntrospectionLock) {
+  // Incorrect implementation of force_lock and force_unlock in our malloc zone
+  // will cause forked processes to deadlock.
+  // TODO(glider): need to detect that none of the child processes deadlocked.
+  const int kNumWorkers = 5, kNumIterations = 100;
+  int i, iter;
+  for (iter = 0; iter < kNumIterations; iter++) {
+    pthread_t workers[kNumWorkers], forker;
+    for (i = 0; i < kNumWorkers; i++) {
+      PTHREAD_CREATE(&workers[i], 0, MallocIntrospectionLockWorker, 0);
+    }
+    PTHREAD_CREATE(&forker, 0, MallocIntrospectionLockForker, 0);
+    for (i = 0; i < kNumWorkers; i++) {
+      PTHREAD_JOIN(workers[i], 0);
+    }
+    PTHREAD_JOIN(forker, 0);
+  }
+}
+
+void *TSDAllocWorker(void *test_key) {
+  if (test_key) {
+    void *mem = malloc(10);
+    pthread_setspecific(*(pthread_key_t*)test_key, mem);
+  }
+  return NULL;
+}
+
+TEST(AddressSanitizerMac, DISABLED_TSDWorkqueueTest) {
+  pthread_t th;
+  pthread_key_t test_key;
+  pthread_key_create(&test_key, CallFreeOnWorkqueue);
+  PTHREAD_CREATE(&th, NULL, TSDAllocWorker, &test_key);
+  PTHREAD_JOIN(th, NULL);
+  pthread_key_delete(test_key);
+}
+
+// Test that CFStringCreateCopy does not copy constant strings.
+TEST(AddressSanitizerMac, CFStringCreateCopy) {
+  CFStringRef str = CFSTR("Hello world!\n");
+  CFStringRef str2 = CFStringCreateCopy(0, str);
+  EXPECT_EQ(str, str2);
+}
+
+TEST(AddressSanitizerMac, NSObjectOOB) {
+  // Make sure that our allocators are used for NSObjects.
+  EXPECT_DEATH(TestOOBNSObjects(), "heap-buffer-overflow");
+}
+
+// Make sure that correct pointer is passed to free() when deallocating a
+// NSURL object.
+// See https://github.com/google/sanitizers/issues/70.
+TEST(AddressSanitizerMac, NSURLDeallocation) {
+  TestNSURLDeallocation();
+}
+
+// See https://github.com/google/sanitizers/issues/109.
+TEST(AddressSanitizerMac, Mstats) {
+  malloc_statistics_t stats1, stats2;
+  malloc_zone_statistics(/*all zones*/NULL, &stats1);
+  const size_t kMallocSize = 100000;
+  void *alloc = Ident(malloc(kMallocSize));
+  malloc_zone_statistics(/*all zones*/NULL, &stats2);
+  EXPECT_GT(stats2.blocks_in_use, stats1.blocks_in_use);
+  EXPECT_GE(stats2.size_in_use - stats1.size_in_use, kMallocSize);
+  free(alloc);
+  // Even the default OSX allocator may not change the stats after free().
+}
+
diff --git a/compiler-rt/lib/asan/tests/asan_mac_test.h b/compiler-rt/lib/asan/tests/asan_mac_test.h
new file mode 100644
index 0000000..441547a
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_mac_test.h
@@ -0,0 +1,19 @@
+extern "C" {
+  void *CFAllocatorDefaultDoubleFree(void *unused);
+  void CFAllocatorSystemDefaultDoubleFree();
+  void CFAllocatorMallocDoubleFree();
+  void CFAllocatorMallocZoneDoubleFree();
+  void CallFreeOnWorkqueue(void *mem);
+  void TestGCDDispatchAsync();
+  void TestGCDDispatchSync();
+  void TestGCDReuseWqthreadsAsync();
+  void TestGCDReuseWqthreadsSync();
+  void TestGCDDispatchAfter();
+  void TestGCDInTSDDestructor();
+  void TestGCDSourceEvent();
+  void TestGCDSourceCancel();
+  void TestGCDGroupAsync();
+  void TestOOBNSObjects();
+  void TestNSURLDeallocation();
+  void TestPassCFMemoryToAnotherThread();
+}
diff --git a/compiler-rt/lib/asan/tests/asan_mac_test_helpers.mm b/compiler-rt/lib/asan/tests/asan_mac_test_helpers.mm
new file mode 100644
index 0000000..a7e4b9d
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_mac_test_helpers.mm
@@ -0,0 +1,240 @@
+// Mac OS X 10.6 or higher only.
+#include <dispatch/dispatch.h>
+#include <pthread.h>  // for pthread_yield_np()
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#import <CoreFoundation/CFBase.h>
+#import <Foundation/NSObject.h>
+#import <Foundation/NSURL.h>
+
+// This is a (void*)(void*) function so it can be passed to pthread_create.
+void *CFAllocatorDefaultDoubleFree(void *unused) {
+  void *mem = CFAllocatorAllocate(kCFAllocatorDefault, 5, 0);
+  CFAllocatorDeallocate(kCFAllocatorDefault, mem);
+  CFAllocatorDeallocate(kCFAllocatorDefault, mem);
+  return 0;
+}
+
+void CFAllocatorSystemDefaultDoubleFree() {
+  void *mem = CFAllocatorAllocate(kCFAllocatorSystemDefault, 5, 0);
+  CFAllocatorDeallocate(kCFAllocatorSystemDefault, mem);
+  CFAllocatorDeallocate(kCFAllocatorSystemDefault, mem);
+}
+
+void CFAllocatorMallocDoubleFree() {
+  void *mem = CFAllocatorAllocate(kCFAllocatorMalloc, 5, 0);
+  CFAllocatorDeallocate(kCFAllocatorMalloc, mem);
+  CFAllocatorDeallocate(kCFAllocatorMalloc, mem);
+}
+
+void CFAllocatorMallocZoneDoubleFree() {
+  void *mem = CFAllocatorAllocate(kCFAllocatorMallocZone, 5, 0);
+  CFAllocatorDeallocate(kCFAllocatorMallocZone, mem);
+  CFAllocatorDeallocate(kCFAllocatorMallocZone, mem);
+}
+
+__attribute__((noinline))
+void access_memory(char *a) {
+  *a = 0;
+}
+
+// Test the +load instrumentation.
+// Because the +load methods are invoked before anything else is initialized,
+// it makes little sense to wrap the code below into a gTest test case.
+// If AddressSanitizer doesn't instrument the +load method below correctly,
+// everything will just crash.
+
+char kStartupStr[] =
+    "If your test didn't crash, AddressSanitizer is instrumenting "
+    "the +load methods correctly.";
+
+@interface LoadSomething : NSObject {
+}
+@end
+
+@implementation LoadSomething
+
++(void) load {
+  for (size_t i = 0; i < strlen(kStartupStr); i++) {
+    access_memory(&kStartupStr[i]);  // make sure no optimizations occur.
+  }
+  // Don't print anything here not to interfere with the death tests.
+}
+
+@end
+
+void worker_do_alloc(int size) {
+  char * volatile mem = (char * volatile)malloc(size);
+  mem[0] = 0; // Ok
+  free(mem);
+}
+
+void worker_do_crash(int size) {
+  char * volatile mem = (char * volatile)malloc(size);
+  access_memory(&mem[size]);  // BOOM
+  free(mem);
+}
+
+// Used by the GCD tests to avoid a race between the worker thread reporting a
+// memory error and the main thread which may exit with exit code 0 before
+// that.
+void wait_forever() {
+  volatile bool infinite = true;
+  while (infinite) pthread_yield_np();
+}
+
+// Tests for the Grand Central Dispatch. See
+// http://developer.apple.com/library/mac/#documentation/Performance/Reference/GCD_libdispatch_Ref/Reference/reference.html
+// for the reference.
+void TestGCDDispatchAsync() {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_block_t block = ^{ worker_do_crash(1024); };
+  // dispatch_async() runs the task on a worker thread that does not go through
+  // pthread_create(). We need to verify that AddressSanitizer notices that the
+  // thread has started.
+  dispatch_async(queue, block);
+  wait_forever();
+}
+
+void TestGCDDispatchSync() {
+  dispatch_queue_t queue = dispatch_get_global_queue(2, 0);
+  dispatch_block_t block = ^{ worker_do_crash(1024); };
+  // dispatch_sync() runs the task on a worker thread that does not go through
+  // pthread_create(). We need to verify that AddressSanitizer notices that the
+  // thread has started.
+  dispatch_sync(queue, block);
+  wait_forever();
+}
+
+// libdispatch spawns a rather small number of threads and reuses them. We need
+// to make sure AddressSanitizer handles the reusing correctly.
+void TestGCDReuseWqthreadsAsync() {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_block_t block_alloc = ^{ worker_do_alloc(1024); };
+  dispatch_block_t block_crash = ^{ worker_do_crash(1024); };
+  for (int i = 0; i < 100; i++) {
+    dispatch_async(queue, block_alloc);
+  }
+  dispatch_async(queue, block_crash);
+  wait_forever();
+}
+
+// Try to trigger abnormal behaviour of dispatch_sync() being unhandled by us.
+void TestGCDReuseWqthreadsSync() {
+  dispatch_queue_t queue[4];
+  queue[0] = dispatch_get_global_queue(2, 0);
+  queue[1] = dispatch_get_global_queue(0, 0);
+  queue[2] = dispatch_get_global_queue(-2, 0);
+  queue[3] = dispatch_queue_create("my_queue", NULL);
+  dispatch_block_t block_alloc = ^{ worker_do_alloc(1024); };
+  dispatch_block_t block_crash = ^{ worker_do_crash(1024); };
+  for (int i = 0; i < 1000; i++) {
+    dispatch_sync(queue[i % 4], block_alloc);
+  }
+  dispatch_sync(queue[3], block_crash);
+  wait_forever();
+}
+
+void TestGCDDispatchAfter() {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_block_t block_crash = ^{ worker_do_crash(1024); };
+  // Schedule the event one second from the current time.
+  dispatch_time_t milestone =
+      dispatch_time(DISPATCH_TIME_NOW, 1LL * NSEC_PER_SEC);
+  dispatch_after(milestone, queue, block_crash);
+  wait_forever();
+}
+
+void worker_do_deallocate(void *ptr) {
+  free(ptr);
+}
+
+void CallFreeOnWorkqueue(void *tsd) {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_block_t block_dealloc = ^{ worker_do_deallocate(tsd); };
+  dispatch_async(queue, block_dealloc);
+  // Do not wait for the worker to free the memory -- nobody is going to touch
+  // it.
+}
+
+void TestGCDSourceEvent() {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_source_t timer =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+  // Schedule the timer one second from the current time.
+  dispatch_time_t milestone =
+      dispatch_time(DISPATCH_TIME_NOW, 1LL * NSEC_PER_SEC);
+
+  dispatch_source_set_timer(timer, milestone, DISPATCH_TIME_FOREVER, 0);
+  char * volatile mem = (char * volatile)malloc(10);
+  dispatch_source_set_event_handler(timer, ^{
+    access_memory(&mem[10]);
+  });
+  dispatch_resume(timer);
+  wait_forever();
+}
+
+void TestGCDSourceCancel() {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_source_t timer =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+  // Schedule the timer one second from the current time.
+  dispatch_time_t milestone =
+      dispatch_time(DISPATCH_TIME_NOW, 1LL * NSEC_PER_SEC);
+
+  dispatch_source_set_timer(timer, milestone, DISPATCH_TIME_FOREVER, 0);
+  char * volatile mem = (char * volatile)malloc(10);
+  // Both dispatch_source_set_cancel_handler() and
+  // dispatch_source_set_event_handler() use dispatch_barrier_async_f().
+  // It's tricky to test dispatch_source_set_cancel_handler() separately,
+  // so we test both here.
+  dispatch_source_set_event_handler(timer, ^{
+    dispatch_source_cancel(timer);
+  });
+  dispatch_source_set_cancel_handler(timer, ^{
+    access_memory(&mem[10]);
+  });
+  dispatch_resume(timer);
+  wait_forever();
+}
+
+void TestGCDGroupAsync() {
+  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
+  dispatch_group_t group = dispatch_group_create(); 
+  char * volatile mem = (char * volatile)malloc(10);
+  dispatch_group_async(group, queue, ^{
+    access_memory(&mem[10]);
+  });
+  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+  wait_forever();
+}
+
+@interface FixedArray : NSObject {
+  int items[10];
+}
+@end
+
+@implementation FixedArray
+-(int) access: (int)index {
+  return items[index];
+}
+@end
+
+void TestOOBNSObjects() {
+  id anObject = [FixedArray new];
+  [anObject access:1];
+  [anObject access:11];
+  [anObject release];
+}
+
+void TestNSURLDeallocation() {
+  NSURL *base =
+      [[NSURL alloc] initWithString:@"file://localhost/Users/glider/Library/"];
+  volatile NSURL *u =
+      [[NSURL alloc] initWithString:@"Saved Application State"
+                     relativeToURL:base];
+  [u release];
+}
diff --git a/compiler-rt/lib/asan/tests/asan_mem_test.cc b/compiler-rt/lib/asan/tests/asan_mem_test.cc
new file mode 100644
index 0000000..4a941fa
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_mem_test.cc
@@ -0,0 +1,241 @@
+//===-- asan_mem_test.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+
+template<typename T>
+void MemSetOOBTestTemplate(size_t length) {
+  if (length == 0) return;
+  size_t size = Ident(sizeof(T) * length);
+  T *array = Ident((T*)malloc(size));
+  int element = Ident(42);
+  int zero = Ident(0);
+  void *(*MEMSET)(void *s, int c, size_t n) = Ident(memset);
+  // memset interval inside array
+  MEMSET(array, element, size);
+  MEMSET(array, element, size - 1);
+  MEMSET(array + length - 1, element, sizeof(T));
+  MEMSET(array, element, 1);
+
+  // memset 0 bytes
+  MEMSET(array - 10, element, zero);
+  MEMSET(array - 1, element, zero);
+  MEMSET(array, element, zero);
+  MEMSET(array + length, 0, zero);
+  MEMSET(array + length + 1, 0, zero);
+
+  // try to memset bytes to the right of array
+  EXPECT_DEATH(MEMSET(array, 0, size + 1),
+               RightOOBWriteMessage(0));
+  EXPECT_DEATH(MEMSET((char*)(array + length) - 1, element, 6),
+               RightOOBWriteMessage(0));
+  EXPECT_DEATH(MEMSET(array + 1, element, size + sizeof(T)),
+               RightOOBWriteMessage(0));
+  // whole interval is to the right
+  EXPECT_DEATH(MEMSET(array + length + 1, 0, 10),
+               RightOOBWriteMessage(sizeof(T)));
+
+  // try to memset bytes to the left of array
+  EXPECT_DEATH(MEMSET((char*)array - 1, element, size),
+               LeftOOBWriteMessage(1));
+  EXPECT_DEATH(MEMSET((char*)array - 5, 0, 6),
+               LeftOOBWriteMessage(5));
+  if (length >= 100) {
+    // Large OOB, we find it only if the redzone is large enough.
+    EXPECT_DEATH(memset(array - 5, element, size + 5 * sizeof(T)),
+                 LeftOOBWriteMessage(5 * sizeof(T)));
+  }
+  // whole interval is to the left
+  EXPECT_DEATH(MEMSET(array - 2, 0, sizeof(T)),
+               LeftOOBWriteMessage(2 * sizeof(T)));
+
+  // try to memset bytes both to the left & to the right
+  EXPECT_DEATH(MEMSET((char*)array - 2, element, size + 4),
+               LeftOOBWriteMessage(2));
+
+  free(array);
+}
+
+TEST(AddressSanitizer, MemSetOOBTest) {
+  MemSetOOBTestTemplate<char>(100);
+  MemSetOOBTestTemplate<int>(5);
+  MemSetOOBTestTemplate<double>(256);
+  // We can test arrays of structres/classes here, but what for?
+}
+
+// Try to allocate two arrays of 'size' bytes that are near each other.
+// Strictly speaking we are not guaranteed to find such two pointers,
+// but given the structure of asan's allocator we will.
+static bool AllocateTwoAdjacentArrays(char **x1, char **x2, size_t size) {
+  vector<uintptr_t> v;
+  bool res = false;
+  for (size_t i = 0; i < 1000U && !res; i++) {
+    v.push_back(reinterpret_cast<uintptr_t>(new char[size]));
+    if (i == 0) continue;
+    sort(v.begin(), v.end());
+    for (size_t j = 1; j < v.size(); j++) {
+      assert(v[j] > v[j-1]);
+      if ((size_t)(v[j] - v[j-1]) < size * 2) {
+        *x2 = reinterpret_cast<char*>(v[j]);
+        *x1 = reinterpret_cast<char*>(v[j-1]);
+        res = true;
+        break;
+      }
+    }
+  }
+
+  for (size_t i = 0; i < v.size(); i++) {
+    char *p = reinterpret_cast<char *>(v[i]);
+    if (res && p == *x1) continue;
+    if (res && p == *x2) continue;
+    delete [] p;
+  }
+  return res;
+}
+
+TEST(AddressSanitizer, LargeOOBInMemset) {
+  for (size_t size = 200; size < 100000; size += size / 2) {
+    char *x1, *x2;
+    if (!Ident(AllocateTwoAdjacentArrays)(&x1, &x2, size))
+      continue;
+    // fprintf(stderr, "  large oob memset: %p %p %zd\n", x1, x2, size);
+    // Do a memset on x1 with huge out-of-bound access that will end up in x2.
+    EXPECT_DEATH(Ident(memset)(x1, 0, size * 2),
+                 "is located 0 bytes to the right");
+    delete [] x1;
+    delete [] x2;
+    return;
+  }
+  assert(0 && "Did not find two adjacent malloc-ed pointers");
+}
+
+// Same test for memcpy and memmove functions
+template <typename T, class M>
+void MemTransferOOBTestTemplate(size_t length) {
+  if (length == 0) return;
+  size_t size = Ident(sizeof(T) * length);
+  T *src = Ident((T*)malloc(size));
+  T *dest = Ident((T*)malloc(size));
+  int zero = Ident(0);
+
+  // valid transfer of bytes between arrays
+  M::transfer(dest, src, size);
+  M::transfer(dest + 1, src, size - sizeof(T));
+  M::transfer(dest, src + length - 1, sizeof(T));
+  M::transfer(dest, src, 1);
+
+  // transfer zero bytes
+  M::transfer(dest - 1, src, 0);
+  M::transfer(dest + length, src, zero);
+  M::transfer(dest, src - 1, zero);
+  M::transfer(dest, src, zero);
+
+  // try to change mem to the right of dest
+  EXPECT_DEATH(M::transfer(dest + 1, src, size),
+               RightOOBWriteMessage(0));
+  EXPECT_DEATH(M::transfer((char*)(dest + length) - 1, src, 5),
+               RightOOBWriteMessage(0));
+
+  // try to change mem to the left of dest
+  EXPECT_DEATH(M::transfer(dest - 2, src, size),
+               LeftOOBWriteMessage(2 * sizeof(T)));
+  EXPECT_DEATH(M::transfer((char*)dest - 3, src, 4),
+               LeftOOBWriteMessage(3));
+
+  // try to access mem to the right of src
+  EXPECT_DEATH(M::transfer(dest, src + 2, size),
+               RightOOBReadMessage(0));
+  EXPECT_DEATH(M::transfer(dest, (char*)(src + length) - 3, 6),
+               RightOOBReadMessage(0));
+
+  // try to access mem to the left of src
+  EXPECT_DEATH(M::transfer(dest, src - 1, size),
+               LeftOOBReadMessage(sizeof(T)));
+  EXPECT_DEATH(M::transfer(dest, (char*)src - 6, 7),
+               LeftOOBReadMessage(6));
+
+  // Generally we don't need to test cases where both accessing src and writing
+  // to dest address to poisoned memory.
+
+  T *big_src = Ident((T*)malloc(size * 2));
+  T *big_dest = Ident((T*)malloc(size * 2));
+  // try to change mem to both sides of dest
+  EXPECT_DEATH(M::transfer(dest - 1, big_src, size * 2),
+               LeftOOBWriteMessage(sizeof(T)));
+  // try to access mem to both sides of src
+  EXPECT_DEATH(M::transfer(big_dest, src - 2, size * 2),
+               LeftOOBReadMessage(2 * sizeof(T)));
+
+  free(src);
+  free(dest);
+  free(big_src);
+  free(big_dest);
+}
+
+class MemCpyWrapper {
+ public:
+  static void* transfer(void *to, const void *from, size_t size) {
+    return Ident(memcpy)(to, from, size);
+  }
+};
+
+TEST(AddressSanitizer, MemCpyOOBTest) {
+  MemTransferOOBTestTemplate<char, MemCpyWrapper>(100);
+  MemTransferOOBTestTemplate<int, MemCpyWrapper>(1024);
+}
+
+class MemMoveWrapper {
+ public:
+  static void* transfer(void *to, const void *from, size_t size) {
+    return Ident(memmove)(to, from, size);
+  }
+};
+
+TEST(AddressSanitizer, MemMoveOOBTest) {
+  MemTransferOOBTestTemplate<char, MemMoveWrapper>(100);
+  MemTransferOOBTestTemplate<int, MemMoveWrapper>(1024);
+}
+
+
+TEST(AddressSanitizer, MemCmpOOBTest) {
+  size_t size = Ident(100);
+  char *s1 = MallocAndMemsetString(size);
+  char *s2 = MallocAndMemsetString(size);
+  // Normal memcmp calls.
+  Ident(memcmp(s1, s2, size));
+  Ident(memcmp(s1 + size - 1, s2 + size - 1, 1));
+  Ident(memcmp(s1 - 1, s2 - 1, 0));
+  // One of arguments points to not allocated memory.
+  EXPECT_DEATH(Ident(memcmp)(s1 - 1, s2, 1), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(memcmp)(s1, s2 - 1, 1), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(memcmp)(s1 + size, s2, 1), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(memcmp)(s1, s2 + size, 1), RightOOBReadMessage(0));
+  // Hit unallocated memory and die.
+  EXPECT_DEATH(Ident(memcmp)(s1 + 1, s2 + 1, size), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(memcmp)(s1 + size - 1, s2, 2), RightOOBReadMessage(0));
+  // Zero bytes are not terminators and don't prevent from OOB.
+  s1[size - 1] = '\0';
+  s2[size - 1] = '\0';
+  EXPECT_DEATH(Ident(memcmp)(s1, s2, size + 1), RightOOBReadMessage(0));
+
+  // Even if the buffers differ in the first byte, we still assume that
+  // memcmp may access the whole buffer and thus reporting the overflow here:
+  s1[0] = 1;
+  s2[0] = 123;
+  EXPECT_DEATH(Ident(memcmp)(s1, s2, size + 1), RightOOBReadMessage(0));
+
+  free(s1);
+  free(s2);
+}
+
+
+
diff --git a/compiler-rt/lib/asan/tests/asan_noinst_test.cc b/compiler-rt/lib/asan/tests/asan_noinst_test.cc
new file mode 100644
index 0000000..5f5354f
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_noinst_test.cc
@@ -0,0 +1,263 @@
+//===-- asan_noinst_test.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// This test file should be compiled w/o asan instrumentation.
+//===----------------------------------------------------------------------===//
+
+#include "asan_allocator.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_test_utils.h"
+#include <sanitizer/allocator_interface.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>  // for memset()
+#include <algorithm>
+#include <vector>
+#include <limits>
+
+// ATTENTION!
+// Please don't call intercepted functions (including malloc() and friends)
+// in this test. The static runtime library is linked explicitly (without
+// -fsanitize=address), thus the interceptors do not work correctly on OS X.
+
+// Make sure __asan_init is called before any test case is run.
+struct AsanInitCaller {
+  AsanInitCaller() {
+    DisableReexec();
+    __asan_init();
+  }
+};
+static AsanInitCaller asan_init_caller;
+
+TEST(AddressSanitizer, InternalSimpleDeathTest) {
+  EXPECT_DEATH(exit(1), "");
+}
+
+static void MallocStress(size_t n) {
+  u32 seed = my_rand();
+  BufferedStackTrace stack1;
+  stack1.trace_buffer[0] = 0xa123;
+  stack1.trace_buffer[1] = 0xa456;
+  stack1.size = 2;
+
+  BufferedStackTrace stack2;
+  stack2.trace_buffer[0] = 0xb123;
+  stack2.trace_buffer[1] = 0xb456;
+  stack2.size = 2;
+
+  BufferedStackTrace stack3;
+  stack3.trace_buffer[0] = 0xc123;
+  stack3.trace_buffer[1] = 0xc456;
+  stack3.size = 2;
+
+  std::vector<void *> vec;
+  for (size_t i = 0; i < n; i++) {
+    if ((i % 3) == 0) {
+      if (vec.empty()) continue;
+      size_t idx = my_rand_r(&seed) % vec.size();
+      void *ptr = vec[idx];
+      vec[idx] = vec.back();
+      vec.pop_back();
+      __asan::asan_free(ptr, &stack1, __asan::FROM_MALLOC);
+    } else {
+      size_t size = my_rand_r(&seed) % 1000 + 1;
+      switch ((my_rand_r(&seed) % 128)) {
+        case 0: size += 1024; break;
+        case 1: size += 2048; break;
+        case 2: size += 4096; break;
+      }
+      size_t alignment = 1 << (my_rand_r(&seed) % 10 + 1);
+      char *ptr = (char*)__asan::asan_memalign(alignment, size,
+                                               &stack2, __asan::FROM_MALLOC);
+      EXPECT_EQ(size, __asan::asan_malloc_usable_size(ptr, 0, 0));
+      vec.push_back(ptr);
+      ptr[0] = 0;
+      ptr[size-1] = 0;
+      ptr[size/2] = 0;
+    }
+  }
+  for (size_t i = 0; i < vec.size(); i++)
+    __asan::asan_free(vec[i], &stack3, __asan::FROM_MALLOC);
+}
+
+
+TEST(AddressSanitizer, NoInstMallocTest) {
+  MallocStress(ASAN_LOW_MEMORY ? 300000 : 1000000);
+}
+
+TEST(AddressSanitizer, ThreadedMallocStressTest) {
+  const int kNumThreads = 4;
+  const int kNumIterations = (ASAN_LOW_MEMORY) ? 10000 : 100000;
+  pthread_t t[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_CREATE(&t[i], 0, (void* (*)(void *x))MallocStress,
+        (void*)kNumIterations);
+  }
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_JOIN(t[i], 0);
+  }
+}
+
+static void PrintShadow(const char *tag, uptr ptr, size_t size) {
+  fprintf(stderr, "%s shadow: %lx size % 3ld: ", tag, (long)ptr, (long)size);
+  uptr prev_shadow = 0;
+  for (sptr i = -32; i < (sptr)size + 32; i++) {
+    uptr shadow = __asan::MemToShadow(ptr + i);
+    if (i == 0 || i == (sptr)size)
+      fprintf(stderr, ".");
+    if (shadow != prev_shadow) {
+      prev_shadow = shadow;
+      fprintf(stderr, "%02x", (int)*(u8*)shadow);
+    }
+  }
+  fprintf(stderr, "\n");
+}
+
+TEST(AddressSanitizer, DISABLED_InternalPrintShadow) {
+  for (size_t size = 1; size <= 513; size++) {
+    char *ptr = new char[size];
+    PrintShadow("m", (uptr)ptr, size);
+    delete [] ptr;
+    PrintShadow("f", (uptr)ptr, size);
+  }
+}
+
+TEST(AddressSanitizer, QuarantineTest) {
+  BufferedStackTrace stack;
+  stack.trace_buffer[0] = 0x890;
+  stack.size = 1;
+
+  const int size = 1024;
+  void *p = __asan::asan_malloc(size, &stack);
+  __asan::asan_free(p, &stack, __asan::FROM_MALLOC);
+  size_t i;
+  size_t max_i = 1 << 30;
+  for (i = 0; i < max_i; i++) {
+    void *p1 = __asan::asan_malloc(size, &stack);
+    __asan::asan_free(p1, &stack, __asan::FROM_MALLOC);
+    if (p1 == p) break;
+  }
+  EXPECT_GE(i, 10000U);
+  EXPECT_LT(i, max_i);
+}
+
+void *ThreadedQuarantineTestWorker(void *unused) {
+  (void)unused;
+  u32 seed = my_rand();
+  BufferedStackTrace stack;
+  stack.trace_buffer[0] = 0x890;
+  stack.size = 1;
+
+  for (size_t i = 0; i < 1000; i++) {
+    void *p = __asan::asan_malloc(1 + (my_rand_r(&seed) % 4000), &stack);
+    __asan::asan_free(p, &stack, __asan::FROM_MALLOC);
+  }
+  return NULL;
+}
+
+// Check that the thread local allocators are flushed when threads are
+// destroyed.
+TEST(AddressSanitizer, ThreadedQuarantineTest) {
+  const int n_threads = 3000;
+  size_t mmaped1 = __sanitizer_get_heap_size();
+  for (int i = 0; i < n_threads; i++) {
+    pthread_t t;
+    PTHREAD_CREATE(&t, NULL, ThreadedQuarantineTestWorker, 0);
+    PTHREAD_JOIN(t, 0);
+    size_t mmaped2 = __sanitizer_get_heap_size();
+    EXPECT_LT(mmaped2 - mmaped1, 320U * (1 << 20));
+  }
+}
+
+void *ThreadedOneSizeMallocStress(void *unused) {
+  (void)unused;
+  BufferedStackTrace stack;
+  stack.trace_buffer[0] = 0x890;
+  stack.size = 1;
+  const size_t kNumMallocs = 1000;
+  for (int iter = 0; iter < 1000; iter++) {
+    void *p[kNumMallocs];
+    for (size_t i = 0; i < kNumMallocs; i++) {
+      p[i] = __asan::asan_malloc(32, &stack);
+    }
+    for (size_t i = 0; i < kNumMallocs; i++) {
+      __asan::asan_free(p[i], &stack, __asan::FROM_MALLOC);
+    }
+  }
+  return NULL;
+}
+
+TEST(AddressSanitizer, ThreadedOneSizeMallocStressTest) {
+  const int kNumThreads = 4;
+  pthread_t t[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_CREATE(&t[i], 0, ThreadedOneSizeMallocStress, 0);
+  }
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_JOIN(t[i], 0);
+  }
+}
+
+TEST(AddressSanitizer, ShadowRegionIsPoisonedTest) {
+  using __asan::kHighMemEnd;
+  // Check that __asan_region_is_poisoned works for shadow regions.
+  uptr ptr = kLowShadowBeg + 200;
+  EXPECT_EQ(ptr, __asan_region_is_poisoned(ptr, 100));
+  ptr = kShadowGapBeg + 200;
+  EXPECT_EQ(ptr, __asan_region_is_poisoned(ptr, 100));
+  ptr = kHighShadowBeg + 200;
+  EXPECT_EQ(ptr, __asan_region_is_poisoned(ptr, 100));
+}
+
+// Test __asan_load1 & friends.
+TEST(AddressSanitizer, LoadStoreCallbacks) {
+  typedef void (*CB)(uptr p);
+  CB cb[2][5] = {
+      {
+        __asan_load1, __asan_load2, __asan_load4, __asan_load8, __asan_load16,
+      }, {
+        __asan_store1, __asan_store2, __asan_store4, __asan_store8,
+        __asan_store16,
+      }
+  };
+
+  uptr buggy_ptr;
+
+  __asan_test_only_reported_buggy_pointer = &buggy_ptr;
+  BufferedStackTrace stack;
+  stack.trace_buffer[0] = 0x890;
+  stack.size = 1;
+
+  for (uptr len = 16; len <= 32; len++) {
+    char *ptr = (char*) __asan::asan_malloc(len, &stack);
+    uptr p = reinterpret_cast<uptr>(ptr);
+    for (uptr is_write = 0; is_write <= 1; is_write++) {
+      for (uptr size_log = 0; size_log <= 4; size_log++) {
+        uptr size = 1 << size_log;
+        CB call = cb[is_write][size_log];
+        // Iterate only size-aligned offsets.
+        for (uptr offset = 0; offset <= len; offset += size) {
+          buggy_ptr = 0;
+          call(p + offset);
+          if (offset + size <= len)
+            EXPECT_EQ(buggy_ptr, 0U);
+          else
+            EXPECT_EQ(buggy_ptr, p + offset);
+        }
+      }
+    }
+    __asan::asan_free(ptr, &stack, __asan::FROM_MALLOC);
+  }
+  __asan_test_only_reported_buggy_pointer = 0;
+}
diff --git a/compiler-rt/lib/asan/tests/asan_oob_test.cc b/compiler-rt/lib/asan/tests/asan_oob_test.cc
new file mode 100644
index 0000000..0c6bea2
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_oob_test.cc
@@ -0,0 +1,128 @@
+//===-- asan_oob_test.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+
+NOINLINE void asan_write_sized_aligned(uint8_t *p, size_t size) {
+  EXPECT_EQ(0U, ((uintptr_t)p % size));
+  if      (size == 1) asan_write((uint8_t*)p);
+  else if (size == 2) asan_write((uint16_t*)p);
+  else if (size == 4) asan_write((uint32_t*)p);
+  else if (size == 8) asan_write((uint64_t*)p);
+}
+
+template<typename T>
+NOINLINE void oob_test(int size, int off) {
+  char *p = (char*)malloc_aaa(size);
+  // fprintf(stderr, "writing %d byte(s) into [%p,%p) with offset %d\n",
+  //        sizeof(T), p, p + size, off);
+  asan_write((T*)(p + off));
+  free_aaa(p);
+}
+
+template<typename T>
+void OOBTest() {
+  char expected_str[100];
+  for (int size = sizeof(T); size < 20; size += 5) {
+    for (int i = -5; i < 0; i++) {
+      const char *str =
+          "is located.*%d byte.*to the left";
+      sprintf(expected_str, str, abs(i));
+      EXPECT_DEATH(oob_test<T>(size, i), expected_str);
+    }
+
+    for (int i = 0; i < (int)(size - sizeof(T) + 1); i++)
+      oob_test<T>(size, i);
+
+    for (int i = size - sizeof(T) + 1; i <= (int)(size + 2 * sizeof(T)); i++) {
+      const char *str =
+          "is located.*%d byte.*to the right";
+      int off = i >= size ? (i - size) : 0;
+      // we don't catch unaligned partially OOB accesses.
+      if (i % sizeof(T)) continue;
+      sprintf(expected_str, str, off);
+      EXPECT_DEATH(oob_test<T>(size, i), expected_str);
+    }
+  }
+
+  EXPECT_DEATH(oob_test<T>(kLargeMalloc, -1),
+          "is located.*1 byte.*to the left");
+  EXPECT_DEATH(oob_test<T>(kLargeMalloc, kLargeMalloc),
+          "is located.*0 byte.*to the right");
+}
+
+// TODO(glider): the following tests are EXTREMELY slow on Darwin:
+//   AddressSanitizer.OOB_char (125503 ms)
+//   AddressSanitizer.OOB_int (126890 ms)
+//   AddressSanitizer.OOBRightTest (315605 ms)
+//   AddressSanitizer.SimpleStackTest (366559 ms)
+
+TEST(AddressSanitizer, OOB_char) {
+  OOBTest<U1>();
+}
+
+TEST(AddressSanitizer, OOB_int) {
+  OOBTest<U4>();
+}
+
+TEST(AddressSanitizer, OOBRightTest) {
+  size_t max_access_size = SANITIZER_WORDSIZE == 64 ? 8 : 4;
+  for (size_t access_size = 1; access_size <= max_access_size;
+       access_size *= 2) {
+    for (size_t alloc_size = 1; alloc_size <= 8; alloc_size++) {
+      for (size_t offset = 0; offset <= 8; offset += access_size) {
+        void *p = malloc(alloc_size);
+        // allocated: [p, p + alloc_size)
+        // accessed:  [p + offset, p + offset + access_size)
+        uint8_t *addr = (uint8_t*)p + offset;
+        if (offset + access_size <= alloc_size) {
+          asan_write_sized_aligned(addr, access_size);
+        } else {
+          int outside_bytes = offset > alloc_size ? (offset - alloc_size) : 0;
+          const char *str =
+              "is located.%d *byte.*to the right";
+          char expected_str[100];
+          sprintf(expected_str, str, outside_bytes);
+          EXPECT_DEATH(asan_write_sized_aligned(addr, access_size),
+                       expected_str);
+        }
+        free(p);
+      }
+    }
+  }
+}
+
+TEST(AddressSanitizer, LargeOOBRightTest) {
+  size_t large_power_of_two = 1 << 19;
+  for (size_t i = 16; i <= 256; i *= 2) {
+    size_t size = large_power_of_two - i;
+    char *p = Ident(new char[size]);
+    EXPECT_DEATH(p[size] = 0, "is located 0 bytes to the right");
+    delete [] p;
+  }
+}
+
+TEST(AddressSanitizer, DISABLED_DemoOOBLeftLow) {
+  oob_test<U1>(10, -1);
+}
+
+TEST(AddressSanitizer, DISABLED_DemoOOBLeftHigh) {
+  oob_test<U1>(kLargeMalloc, -1);
+}
+
+TEST(AddressSanitizer, DISABLED_DemoOOBRightLow) {
+  oob_test<U1>(10, 10);
+}
+
+TEST(AddressSanitizer, DISABLED_DemoOOBRightHigh) {
+  oob_test<U1>(kLargeMalloc, kLargeMalloc);
+}
diff --git a/compiler-rt/lib/asan/tests/asan_racy_double_free_test.cc b/compiler-rt/lib/asan/tests/asan_racy_double_free_test.cc
new file mode 100644
index 0000000..23240e7
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_racy_double_free_test.cc
@@ -0,0 +1,32 @@
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+const int N = 1000;
+void *x[N];
+
+void *Thread1(void *unused) {
+  for (int i = 0; i < N; i++) {
+    fprintf(stderr, "%s %d\n", __func__, i);
+    free(x[i]);
+  }
+  return NULL;
+}
+
+void *Thread2(void *unused) {
+  for (int i = 0; i < N; i++) {
+    fprintf(stderr, "%s %d\n", __func__, i);
+    free(x[i]);
+  }
+  return NULL;
+}
+
+int main() {
+  for (int i = 0; i < N; i++)
+    x[i] = malloc(128);
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  pthread_create(&t[1], 0, Thread2, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+}
diff --git a/compiler-rt/lib/asan/tests/asan_str_test.cc b/compiler-rt/lib/asan/tests/asan_str_test.cc
new file mode 100644
index 0000000..89b0d3d
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_str_test.cc
@@ -0,0 +1,573 @@
+//=-- asan_str_test.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+
+#if defined(__APPLE__)
+#include <AvailabilityMacros.h>  // For MAC_OS_X_VERSION_*
+#endif
+
+// Used for string functions tests
+static char global_string[] = "global";
+static size_t global_string_length = 6;
+
+// Input to a test is a zero-terminated string str with given length
+// Accesses to the bytes to the left and to the right of str
+// are presumed to produce OOB errors
+void StrLenOOBTestTemplate(char *str, size_t length, bool is_global) {
+  // Normal strlen calls
+  EXPECT_EQ(strlen(str), length);
+  if (length > 0) {
+    EXPECT_EQ(length - 1, strlen(str + 1));
+    EXPECT_EQ(0U, strlen(str + length));
+  }
+  // Arg of strlen is not malloced, OOB access
+  if (!is_global) {
+    // We don't insert RedZones to the left of global variables
+    EXPECT_DEATH(Ident(strlen(str - 1)), LeftOOBReadMessage(1));
+    EXPECT_DEATH(Ident(strlen(str - 5)), LeftOOBReadMessage(5));
+  }
+  EXPECT_DEATH(Ident(strlen(str + length + 1)), RightOOBReadMessage(0));
+  // Overwrite terminator
+  str[length] = 'a';
+  // String is not zero-terminated, strlen will lead to OOB access
+  EXPECT_DEATH(Ident(strlen(str)), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(strlen(str + length)), RightOOBReadMessage(0));
+  // Restore terminator
+  str[length] = 0;
+}
+TEST(AddressSanitizer, StrLenOOBTest) {
+  // Check heap-allocated string
+  size_t length = Ident(10);
+  char *heap_string = Ident((char*)malloc(length + 1));
+  char stack_string[10 + 1];
+  break_optimization(&stack_string);
+  for (size_t i = 0; i < length; i++) {
+    heap_string[i] = 'a';
+    stack_string[i] = 'b';
+  }
+  heap_string[length] = 0;
+  stack_string[length] = 0;
+  StrLenOOBTestTemplate(heap_string, length, false);
+  // TODO(samsonov): Fix expected messages in StrLenOOBTestTemplate to
+  //      make test for stack_string work. Or move it to output tests.
+  // StrLenOOBTestTemplate(stack_string, length, false);
+  StrLenOOBTestTemplate(global_string, global_string_length, true);
+  free(heap_string);
+}
+
+TEST(AddressSanitizer, WcsLenTest) {
+  EXPECT_EQ(0U, wcslen(Ident(L"")));
+  size_t hello_len = 13;
+  size_t hello_size = (hello_len + 1) * sizeof(wchar_t);
+  EXPECT_EQ(hello_len, wcslen(Ident(L"Hello, World!")));
+  wchar_t *heap_string = Ident((wchar_t*)malloc(hello_size));
+  memcpy(heap_string, L"Hello, World!", hello_size);
+  EXPECT_EQ(hello_len, Ident(wcslen(heap_string)));
+  EXPECT_DEATH(Ident(wcslen(heap_string + 14)), RightOOBReadMessage(0));
+  free(heap_string);
+}
+
+#if SANITIZER_TEST_HAS_STRNLEN
+TEST(AddressSanitizer, StrNLenOOBTest) {
+  size_t size = Ident(123);
+  char *str = MallocAndMemsetString(size);
+  // Normal strnlen calls.
+  Ident(strnlen(str - 1, 0));
+  Ident(strnlen(str, size));
+  Ident(strnlen(str + size - 1, 1));
+  str[size - 1] = '\0';
+  Ident(strnlen(str, 2 * size));
+  // Argument points to not allocated memory.
+  EXPECT_DEATH(Ident(strnlen(str - 1, 1)), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(strnlen(str + size, 1)), RightOOBReadMessage(0));
+  // Overwrite the terminating '\0' and hit unallocated memory.
+  str[size - 1] = 'z';
+  EXPECT_DEATH(Ident(strnlen(str, size + 1)), RightOOBReadMessage(0));
+  free(str);
+}
+#endif  // SANITIZER_TEST_HAS_STRNLEN
+
+TEST(AddressSanitizer, StrDupOOBTest) {
+  size_t size = Ident(42);
+  char *str = MallocAndMemsetString(size);
+  char *new_str;
+  // Normal strdup calls.
+  str[size - 1] = '\0';
+  new_str = strdup(str);
+  free(new_str);
+  new_str = strdup(str + size - 1);
+  free(new_str);
+  // Argument points to not allocated memory.
+  EXPECT_DEATH(Ident(strdup(str - 1)), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(strdup(str + size)), RightOOBReadMessage(0));
+  // Overwrite the terminating '\0' and hit unallocated memory.
+  str[size - 1] = 'z';
+  EXPECT_DEATH(Ident(strdup(str)), RightOOBReadMessage(0));
+  free(str);
+}
+
+TEST(AddressSanitizer, StrCpyOOBTest) {
+  size_t to_size = Ident(30);
+  size_t from_size = Ident(6);  // less than to_size
+  char *to = Ident((char*)malloc(to_size));
+  char *from = Ident((char*)malloc(from_size));
+  // Normal strcpy calls.
+  strcpy(from, "hello");
+  strcpy(to, from);
+  strcpy(to + to_size - from_size, from);
+  // Length of "from" is too small.
+  EXPECT_DEATH(Ident(strcpy(from, "hello2")), RightOOBWriteMessage(0));
+  // "to" or "from" points to not allocated memory.
+  EXPECT_DEATH(Ident(strcpy(to - 1, from)), LeftOOBWriteMessage(1));
+  EXPECT_DEATH(Ident(strcpy(to, from - 1)), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(strcpy(to, from + from_size)), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(strcpy(to + to_size, from)), RightOOBWriteMessage(0));
+  // Overwrite the terminating '\0' character and hit unallocated memory.
+  from[from_size - 1] = '!';
+  EXPECT_DEATH(Ident(strcpy(to, from)), RightOOBReadMessage(0));
+  free(to);
+  free(from);
+}
+
+TEST(AddressSanitizer, StrNCpyOOBTest) {
+  size_t to_size = Ident(20);
+  size_t from_size = Ident(6);  // less than to_size
+  char *to = Ident((char*)malloc(to_size));
+  // From is a zero-terminated string "hello\0" of length 6
+  char *from = Ident((char*)malloc(from_size));
+  strcpy(from, "hello");
+  // copy 0 bytes
+  strncpy(to, from, 0);
+  strncpy(to - 1, from - 1, 0);
+  // normal strncpy calls
+  strncpy(to, from, from_size);
+  strncpy(to, from, to_size);
+  strncpy(to, from + from_size - 1, to_size);
+  strncpy(to + to_size - 1, from, 1);
+  // One of {to, from} points to not allocated memory
+  EXPECT_DEATH(Ident(strncpy(to, from - 1, from_size)),
+               LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(strncpy(to - 1, from, from_size)),
+               LeftOOBWriteMessage(1));
+  EXPECT_DEATH(Ident(strncpy(to, from + from_size, 1)),
+               RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(strncpy(to + to_size, from, 1)),
+               RightOOBWriteMessage(0));
+  // Length of "to" is too small
+  EXPECT_DEATH(Ident(strncpy(to + to_size - from_size + 1, from, from_size)),
+               RightOOBWriteMessage(0));
+  EXPECT_DEATH(Ident(strncpy(to + 1, from, to_size)),
+               RightOOBWriteMessage(0));
+  // Overwrite terminator in from
+  from[from_size - 1] = '!';
+  // normal strncpy call
+  strncpy(to, from, from_size);
+  // Length of "from" is too small
+  EXPECT_DEATH(Ident(strncpy(to, from, to_size)),
+               RightOOBReadMessage(0));
+  free(to);
+  free(from);
+}
+
+// Users may have different definitions of "strchr" and "index", so provide
+// function pointer typedefs and overload RunStrChrTest implementation.
+// We can't use macro for RunStrChrTest body here, as this macro would
+// confuse EXPECT_DEATH gtest macro.
+typedef char*(*PointerToStrChr1)(const char*, int);
+typedef char*(*PointerToStrChr2)(char*, int);
+
+UNUSED static void RunStrChrTest(PointerToStrChr1 StrChr) {
+  size_t size = Ident(100);
+  char *str = MallocAndMemsetString(size);
+  str[10] = 'q';
+  str[11] = '\0';
+  EXPECT_EQ(str, StrChr(str, 'z'));
+  EXPECT_EQ(str + 10, StrChr(str, 'q'));
+  EXPECT_EQ(NULL, StrChr(str, 'a'));
+  // StrChr argument points to not allocated memory.
+  EXPECT_DEATH(Ident(StrChr(str - 1, 'z')), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(StrChr(str + size, 'z')), RightOOBReadMessage(0));
+  // Overwrite the terminator and hit not allocated memory.
+  str[11] = 'z';
+  EXPECT_DEATH(Ident(StrChr(str, 'a')), RightOOBReadMessage(0));
+  free(str);
+}
+UNUSED static void RunStrChrTest(PointerToStrChr2 StrChr) {
+  size_t size = Ident(100);
+  char *str = MallocAndMemsetString(size);
+  str[10] = 'q';
+  str[11] = '\0';
+  EXPECT_EQ(str, StrChr(str, 'z'));
+  EXPECT_EQ(str + 10, StrChr(str, 'q'));
+  EXPECT_EQ(NULL, StrChr(str, 'a'));
+  // StrChr argument points to not allocated memory.
+  EXPECT_DEATH(Ident(StrChr(str - 1, 'z')), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(StrChr(str + size, 'z')), RightOOBReadMessage(0));
+  // Overwrite the terminator and hit not allocated memory.
+  str[11] = 'z';
+  EXPECT_DEATH(Ident(StrChr(str, 'a')), RightOOBReadMessage(0));
+  free(str);
+}
+
+TEST(AddressSanitizer, StrChrAndIndexOOBTest) {
+  RunStrChrTest(&strchr);
+// No index() on Windows and on Android L.
+#if !defined(_WIN32) && !defined(__ANDROID__)
+  RunStrChrTest(&index);
+#endif
+}
+
+TEST(AddressSanitizer, StrCmpAndFriendsLogicTest) {
+  // strcmp
+  EXPECT_EQ(0, strcmp("", ""));
+  EXPECT_EQ(0, strcmp("abcd", "abcd"));
+  EXPECT_GT(0, strcmp("ab", "ac"));
+  EXPECT_GT(0, strcmp("abc", "abcd"));
+  EXPECT_LT(0, strcmp("acc", "abc"));
+  EXPECT_LT(0, strcmp("abcd", "abc"));
+
+  // strncmp
+  EXPECT_EQ(0, strncmp("a", "b", 0));
+  EXPECT_EQ(0, strncmp("abcd", "abcd", 10));
+  EXPECT_EQ(0, strncmp("abcd", "abcef", 3));
+  EXPECT_GT(0, strncmp("abcde", "abcfa", 4));
+  EXPECT_GT(0, strncmp("a", "b", 5));
+  EXPECT_GT(0, strncmp("bc", "bcde", 4));
+  EXPECT_LT(0, strncmp("xyz", "xyy", 10));
+  EXPECT_LT(0, strncmp("baa", "aaa", 1));
+  EXPECT_LT(0, strncmp("zyx", "", 2));
+
+#if !defined(_WIN32)  // no str[n]casecmp on Windows.
+  // strcasecmp
+  EXPECT_EQ(0, strcasecmp("", ""));
+  EXPECT_EQ(0, strcasecmp("zzz", "zzz"));
+  EXPECT_EQ(0, strcasecmp("abCD", "ABcd"));
+  EXPECT_GT(0, strcasecmp("aB", "Ac"));
+  EXPECT_GT(0, strcasecmp("ABC", "ABCd"));
+  EXPECT_LT(0, strcasecmp("acc", "abc"));
+  EXPECT_LT(0, strcasecmp("ABCd", "abc"));
+
+  // strncasecmp
+  EXPECT_EQ(0, strncasecmp("a", "b", 0));
+  EXPECT_EQ(0, strncasecmp("abCD", "ABcd", 10));
+  EXPECT_EQ(0, strncasecmp("abCd", "ABcef", 3));
+  EXPECT_GT(0, strncasecmp("abcde", "ABCfa", 4));
+  EXPECT_GT(0, strncasecmp("a", "B", 5));
+  EXPECT_GT(0, strncasecmp("bc", "BCde", 4));
+  EXPECT_LT(0, strncasecmp("xyz", "xyy", 10));
+  EXPECT_LT(0, strncasecmp("Baa", "aaa", 1));
+  EXPECT_LT(0, strncasecmp("zyx", "", 2));
+#endif
+
+  // memcmp
+  EXPECT_EQ(0, memcmp("a", "b", 0));
+  EXPECT_EQ(0, memcmp("ab\0c", "ab\0c", 4));
+  EXPECT_GT(0, memcmp("\0ab", "\0ac", 3));
+  EXPECT_GT(0, memcmp("abb\0", "abba", 4));
+  EXPECT_LT(0, memcmp("ab\0cd", "ab\0c\0", 5));
+  EXPECT_LT(0, memcmp("zza", "zyx", 3));
+}
+
+typedef int(*PointerToStrCmp)(const char*, const char*);
+void RunStrCmpTest(PointerToStrCmp StrCmp) {
+  size_t size = Ident(100);
+  int fill = 'o';
+  char *s1 = MallocAndMemsetString(size, fill);
+  char *s2 = MallocAndMemsetString(size, fill);
+  s1[size - 1] = '\0';
+  s2[size - 1] = '\0';
+  // Normal StrCmp calls
+  Ident(StrCmp(s1, s2));
+  Ident(StrCmp(s1, s2 + size - 1));
+  Ident(StrCmp(s1 + size - 1, s2 + size - 1));
+  // One of arguments points to not allocated memory.
+  EXPECT_DEATH(Ident(StrCmp)(s1 - 1, s2), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(StrCmp)(s1, s2 - 1), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(StrCmp)(s1 + size, s2), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(StrCmp)(s1, s2 + size), RightOOBReadMessage(0));
+  // Hit unallocated memory and die.
+  s1[size - 1] = fill;
+  EXPECT_DEATH(Ident(StrCmp)(s1, s1), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(StrCmp)(s1 + size - 1, s2), RightOOBReadMessage(0));
+  free(s1);
+  free(s2);
+}
+
+TEST(AddressSanitizer, StrCmpOOBTest) {
+  RunStrCmpTest(&strcmp);
+}
+
+#if !defined(_WIN32)  // no str[n]casecmp on Windows.
+TEST(AddressSanitizer, StrCaseCmpOOBTest) {
+  RunStrCmpTest(&strcasecmp);
+}
+#endif
+
+typedef int(*PointerToStrNCmp)(const char*, const char*, size_t);
+void RunStrNCmpTest(PointerToStrNCmp StrNCmp) {
+  size_t size = Ident(100);
+  char *s1 = MallocAndMemsetString(size);
+  char *s2 = MallocAndMemsetString(size);
+  s1[size - 1] = '\0';
+  s2[size - 1] = '\0';
+  // Normal StrNCmp calls
+  Ident(StrNCmp(s1, s2, size + 2));
+  s1[size - 1] = 'z';
+  s2[size - 1] = 'x';
+  Ident(StrNCmp(s1 + size - 2, s2 + size - 2, size));
+  s2[size - 1] = 'z';
+  Ident(StrNCmp(s1 - 1, s2 - 1, 0));
+  Ident(StrNCmp(s1 + size - 1, s2 + size - 1, 1));
+  // One of arguments points to not allocated memory.
+  EXPECT_DEATH(Ident(StrNCmp)(s1 - 1, s2, 1), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(StrNCmp)(s1, s2 - 1, 1), LeftOOBReadMessage(1));
+  EXPECT_DEATH(Ident(StrNCmp)(s1 + size, s2, 1), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(StrNCmp)(s1, s2 + size, 1), RightOOBReadMessage(0));
+  // Hit unallocated memory and die.
+  EXPECT_DEATH(Ident(StrNCmp)(s1 + 1, s2 + 1, size), RightOOBReadMessage(0));
+  EXPECT_DEATH(Ident(StrNCmp)(s1 + size - 1, s2, 2), RightOOBReadMessage(0));
+  free(s1);
+  free(s2);
+}
+
+TEST(AddressSanitizer, StrNCmpOOBTest) {
+  RunStrNCmpTest(&strncmp);
+}
+
+#if !defined(_WIN32)  // no str[n]casecmp on Windows.
+TEST(AddressSanitizer, StrNCaseCmpOOBTest) {
+  RunStrNCmpTest(&strncasecmp);
+}
+#endif
+
+TEST(AddressSanitizer, StrCatOOBTest) {
+  // strcat() reads strlen(to) bytes from |to| before concatenating.
+  size_t to_size = Ident(100);
+  char *to = MallocAndMemsetString(to_size);
+  to[0] = '\0';
+  size_t from_size = Ident(20);
+  char *from = MallocAndMemsetString(from_size);
+  from[from_size - 1] = '\0';
+  // Normal strcat calls.
+  strcat(to, from);
+  strcat(to, from);
+  strcat(to + from_size, from + from_size - 2);
+  // Passing an invalid pointer is an error even when concatenating an empty
+  // string.
+  EXPECT_DEATH(strcat(to - 1, from + from_size - 1), LeftOOBAccessMessage(1));
+  // One of arguments points to not allocated memory.
+  EXPECT_DEATH(strcat(to - 1, from), LeftOOBAccessMessage(1));
+  EXPECT_DEATH(strcat(to, from - 1), LeftOOBReadMessage(1));
+  EXPECT_DEATH(strcat(to, from + from_size), RightOOBReadMessage(0));
+
+  // "from" is not zero-terminated.
+  from[from_size - 1] = 'z';
+  EXPECT_DEATH(strcat(to, from), RightOOBReadMessage(0));
+  from[from_size - 1] = '\0';
+  // "to" is too short to fit "from".
+  memset(to, 'z', to_size);
+  to[to_size - from_size + 1] = '\0';
+  EXPECT_DEATH(strcat(to, from), RightOOBWriteMessage(0));
+  // length of "to" is just enough.
+  strcat(to, from + 1);
+
+  free(to);
+  free(from);
+}
+
+TEST(AddressSanitizer, StrNCatOOBTest) {
+  // strncat() reads strlen(to) bytes from |to| before concatenating.
+  size_t to_size = Ident(100);
+  char *to = MallocAndMemsetString(to_size);
+  to[0] = '\0';
+  size_t from_size = Ident(20);
+  char *from = MallocAndMemsetString(from_size);
+  // Normal strncat calls.
+  strncat(to, from, 0);
+  strncat(to, from, from_size);
+  from[from_size - 1] = '\0';
+  strncat(to, from, 2 * from_size);
+  // Catenating empty string with an invalid string is still an error.
+  EXPECT_DEATH(strncat(to - 1, from, 0), LeftOOBAccessMessage(1));
+  strncat(to, from + from_size - 1, 10);
+  // One of arguments points to not allocated memory.
+  EXPECT_DEATH(strncat(to - 1, from, 2), LeftOOBAccessMessage(1));
+  EXPECT_DEATH(strncat(to, from - 1, 2), LeftOOBReadMessage(1));
+  EXPECT_DEATH(strncat(to, from + from_size, 2), RightOOBReadMessage(0));
+
+  memset(from, 'z', from_size);
+  memset(to, 'z', to_size);
+  to[0] = '\0';
+  // "from" is too short.
+  EXPECT_DEATH(strncat(to, from, from_size + 1), RightOOBReadMessage(0));
+  // "to" is too short to fit "from".
+  to[0] = 'z';
+  to[to_size - from_size + 1] = '\0';
+  EXPECT_DEATH(strncat(to, from, from_size - 1), RightOOBWriteMessage(0));
+  // "to" is just enough.
+  strncat(to, from, from_size - 2);
+
+  free(to);
+  free(from);
+}
+
+static string OverlapErrorMessage(const string &func) {
+  return func + "-param-overlap";
+}
+
+TEST(AddressSanitizer, StrArgsOverlapTest) {
+  size_t size = Ident(100);
+  char *str = Ident((char*)malloc(size));
+
+// Do not check memcpy() on OS X 10.7 and later, where it actually aliases
+// memmove().
+#if !defined(__APPLE__) || !defined(MAC_OS_X_VERSION_10_7) || \
+    (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7)
+  // Check "memcpy". Use Ident() to avoid inlining.
+  memset(str, 'z', size);
+  Ident(memcpy)(str + 1, str + 11, 10);
+  Ident(memcpy)(str, str, 0);
+  EXPECT_DEATH(Ident(memcpy)(str, str + 14, 15), OverlapErrorMessage("memcpy"));
+  EXPECT_DEATH(Ident(memcpy)(str + 14, str, 15), OverlapErrorMessage("memcpy"));
+#endif
+
+  // We do not treat memcpy with to==from as a bug.
+  // See http://llvm.org/bugs/show_bug.cgi?id=11763.
+  // EXPECT_DEATH(Ident(memcpy)(str + 20, str + 20, 1),
+  //              OverlapErrorMessage("memcpy"));
+
+  // Check "strcpy".
+  memset(str, 'z', size);
+  str[9] = '\0';
+  strcpy(str + 10, str);
+  EXPECT_DEATH(strcpy(str + 9, str), OverlapErrorMessage("strcpy"));
+  EXPECT_DEATH(strcpy(str, str + 4), OverlapErrorMessage("strcpy"));
+  strcpy(str, str + 5);
+
+  // Check "strncpy".
+  memset(str, 'z', size);
+  strncpy(str, str + 10, 10);
+  EXPECT_DEATH(strncpy(str, str + 9, 10), OverlapErrorMessage("strncpy"));
+  EXPECT_DEATH(strncpy(str + 9, str, 10), OverlapErrorMessage("strncpy"));
+  str[10] = '\0';
+  strncpy(str + 11, str, 20);
+  EXPECT_DEATH(strncpy(str + 10, str, 20), OverlapErrorMessage("strncpy"));
+
+  // Check "strcat".
+  memset(str, 'z', size);
+  str[10] = '\0';
+  str[20] = '\0';
+  strcat(str, str + 10);
+  EXPECT_DEATH(strcat(str, str + 11), OverlapErrorMessage("strcat"));
+  str[10] = '\0';
+  strcat(str + 11, str);
+  EXPECT_DEATH(strcat(str, str + 9), OverlapErrorMessage("strcat"));
+  EXPECT_DEATH(strcat(str + 9, str), OverlapErrorMessage("strcat"));
+  EXPECT_DEATH(strcat(str + 10, str), OverlapErrorMessage("strcat"));
+
+  // Check "strncat".
+  memset(str, 'z', size);
+  str[10] = '\0';
+  strncat(str, str + 10, 10);  // from is empty
+  EXPECT_DEATH(strncat(str, str + 11, 10), OverlapErrorMessage("strncat"));
+  str[10] = '\0';
+  str[20] = '\0';
+  strncat(str + 5, str, 5);
+  str[10] = '\0';
+  EXPECT_DEATH(strncat(str + 5, str, 6), OverlapErrorMessage("strncat"));
+  EXPECT_DEATH(strncat(str, str + 9, 10), OverlapErrorMessage("strncat"));
+
+  free(str);
+}
+
+typedef void(*PointerToCallAtoi)(const char*);
+
+void RunAtoiOOBTest(PointerToCallAtoi Atoi) {
+  char *array = MallocAndMemsetString(10, '1');
+  // Invalid pointer to the string.
+  EXPECT_DEATH(Atoi(array + 11), RightOOBReadMessage(1));
+  EXPECT_DEATH(Atoi(array - 1), LeftOOBReadMessage(1));
+  // Die if a buffer doesn't have terminating NULL.
+  EXPECT_DEATH(Atoi(array), RightOOBReadMessage(0));
+  // Make last symbol a terminating NULL
+  array[9] = '\0';
+  Atoi(array);
+  // Sometimes we need to detect overflow if no digits are found.
+  memset(array, ' ', 10);
+  EXPECT_DEATH(Atoi(array), RightOOBReadMessage(0));
+  array[9] = '-';
+  EXPECT_DEATH(Atoi(array), RightOOBReadMessage(0));
+  EXPECT_DEATH(Atoi(array + 9), RightOOBReadMessage(0));
+  free(array);
+}
+
+#if !defined(_WIN32)  // FIXME: Fix and enable on Windows.
+void CallAtoi(const char *nptr) {
+  Ident(atoi(nptr));
+}
+void CallAtol(const char *nptr) {
+  Ident(atol(nptr));
+}
+void CallAtoll(const char *nptr) {
+  Ident(atoll(nptr));
+}
+TEST(AddressSanitizer, AtoiAndFriendsOOBTest) {
+  RunAtoiOOBTest(&CallAtoi);
+  RunAtoiOOBTest(&CallAtol);
+  RunAtoiOOBTest(&CallAtoll);
+}
+#endif
+
+typedef void(*PointerToCallStrtol)(const char*, char**, int);
+
+void RunStrtolOOBTest(PointerToCallStrtol Strtol) {
+  char *array = MallocAndMemsetString(3);
+  array[0] = '1';
+  array[1] = '2';
+  array[2] = '3';
+  // Invalid pointer to the string.
+  EXPECT_DEATH(Strtol(array + 3, NULL, 0), RightOOBReadMessage(0));
+  EXPECT_DEATH(Strtol(array - 1, NULL, 0), LeftOOBReadMessage(1));
+  // Buffer overflow if there is no terminating null (depends on base).
+  EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));
+  array[2] = 'z';
+  EXPECT_DEATH(Strtol(array, NULL, 36), RightOOBReadMessage(0));
+  // Add terminating zero to get rid of overflow.
+  array[2] = '\0';
+  Strtol(array, NULL, 36);
+  // Sometimes we need to detect overflow if no digits are found.
+  array[0] = array[1] = array[2] = ' ';
+  EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));
+  array[2] = '+';
+  EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));
+  array[2] = '-';
+  EXPECT_DEATH(Strtol(array, NULL, 0), RightOOBReadMessage(0));
+  free(array);
+}
+
+#if !defined(_WIN32)  // FIXME: Fix and enable on Windows.
+void CallStrtol(const char *nptr, char **endptr, int base) {
+  Ident(strtol(nptr, endptr, base));
+}
+void CallStrtoll(const char *nptr, char **endptr, int base) {
+  Ident(strtoll(nptr, endptr, base));
+}
+TEST(AddressSanitizer, StrtollOOBTest) {
+  RunStrtolOOBTest(&CallStrtoll);
+}
+TEST(AddressSanitizer, StrtolOOBTest) {
+  RunStrtolOOBTest(&CallStrtol);
+}
+#endif
+
+
diff --git a/compiler-rt/lib/asan/tests/asan_test.cc b/compiler-rt/lib/asan/tests/asan_test.cc
new file mode 100644
index 0000000..71fb27a
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_test.cc
@@ -0,0 +1,1322 @@
+//===-- asan_test.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+
+NOINLINE void *malloc_fff(size_t size) {
+  void *res = malloc/**/(size); break_optimization(0); return res;}
+NOINLINE void *malloc_eee(size_t size) {
+  void *res = malloc_fff(size); break_optimization(0); return res;}
+NOINLINE void *malloc_ddd(size_t size) {
+  void *res = malloc_eee(size); break_optimization(0); return res;}
+NOINLINE void *malloc_ccc(size_t size) {
+  void *res = malloc_ddd(size); break_optimization(0); return res;}
+NOINLINE void *malloc_bbb(size_t size) {
+  void *res = malloc_ccc(size); break_optimization(0); return res;}
+NOINLINE void *malloc_aaa(size_t size) {
+  void *res = malloc_bbb(size); break_optimization(0); return res;}
+
+NOINLINE void free_ccc(void *p) { free(p); break_optimization(0);}
+NOINLINE void free_bbb(void *p) { free_ccc(p); break_optimization(0);}
+NOINLINE void free_aaa(void *p) { free_bbb(p); break_optimization(0);}
+
+template<typename T>
+NOINLINE void uaf_test(int size, int off) {
+  void *p = malloc_aaa(size);
+  free_aaa(p);
+  for (int i = 1; i < 100; i++)
+    free_aaa(malloc_aaa(i));
+  fprintf(stderr, "writing %ld byte(s) at %p with offset %d\n",
+          (long)sizeof(T), p, off);
+  asan_write((T *)((char *)p + off));
+}
+
+TEST(AddressSanitizer, HasFeatureAddressSanitizerTest) {
+#if defined(__has_feature) && __has_feature(address_sanitizer)
+  bool asan = 1;
+#elif defined(__SANITIZE_ADDRESS__)
+  bool asan = 1;
+#else
+  bool asan = 0;
+#endif
+  EXPECT_EQ(true, asan);
+}
+
+TEST(AddressSanitizer, SimpleDeathTest) {
+  EXPECT_DEATH(exit(1), "");
+}
+
+TEST(AddressSanitizer, VariousMallocsTest) {
+  int *a = (int*)malloc(100 * sizeof(int));
+  a[50] = 0;
+  free(a);
+
+  int *r = (int*)malloc(10);
+  r = (int*)realloc(r, 2000 * sizeof(int));
+  r[1000] = 0;
+  free(r);
+
+  int *b = new int[100];
+  b[50] = 0;
+  delete [] b;
+
+  int *c = new int;
+  *c = 0;
+  delete c;
+
+#if SANITIZER_TEST_HAS_POSIX_MEMALIGN
+  int *pm;
+  int pm_res = posix_memalign((void**)&pm, kPageSize, kPageSize);
+  EXPECT_EQ(0, pm_res);
+  free(pm);
+#endif  // SANITIZER_TEST_HAS_POSIX_MEMALIGN
+
+#if SANITIZER_TEST_HAS_MEMALIGN
+  int *ma = (int*)memalign(kPageSize, kPageSize);
+  EXPECT_EQ(0U, (uintptr_t)ma % kPageSize);
+  ma[123] = 0;
+  free(ma);
+#endif  // SANITIZER_TEST_HAS_MEMALIGN
+}
+
+TEST(AddressSanitizer, CallocTest) {
+  int *a = (int*)calloc(100, sizeof(int));
+  EXPECT_EQ(0, a[10]);
+  free(a);
+}
+
+TEST(AddressSanitizer, CallocReturnsZeroMem) {
+  size_t sizes[] = {16, 1000, 10000, 100000, 2100000};
+  for (size_t s = 0; s < sizeof(sizes)/sizeof(sizes[0]); s++) {
+    size_t size = sizes[s];
+    for (size_t iter = 0; iter < 5; iter++) {
+      char *x = Ident((char*)calloc(1, size));
+      EXPECT_EQ(x[0], 0);
+      EXPECT_EQ(x[size - 1], 0);
+      EXPECT_EQ(x[size / 2], 0);
+      EXPECT_EQ(x[size / 3], 0);
+      EXPECT_EQ(x[size / 4], 0);
+      memset(x, 0x42, size);
+      free(Ident(x));
+#if !defined(_WIN32)
+      // FIXME: OOM on Windows. We should just make this a lit test
+      // with quarantine size set to 1.
+      free(Ident(malloc(Ident(1 << 27))));  // Try to drain the quarantine.
+#endif
+    }
+  }
+}
+
+// No valloc on Windows or Android.
+#if !defined(_WIN32) && !defined(__ANDROID__)
+TEST(AddressSanitizer, VallocTest) {
+  void *a = valloc(100);
+  EXPECT_EQ(0U, (uintptr_t)a % kPageSize);
+  free(a);
+}
+#endif
+
+#if SANITIZER_TEST_HAS_PVALLOC
+TEST(AddressSanitizer, PvallocTest) {
+  char *a = (char*)pvalloc(kPageSize + 100);
+  EXPECT_EQ(0U, (uintptr_t)a % kPageSize);
+  a[kPageSize + 101] = 1;  // we should not report an error here.
+  free(a);
+
+  a = (char*)pvalloc(0);  // pvalloc(0) should allocate at least one page.
+  EXPECT_EQ(0U, (uintptr_t)a % kPageSize);
+  a[101] = 1;  // we should not report an error here.
+  free(a);
+}
+#endif  // SANITIZER_TEST_HAS_PVALLOC
+
+#if !defined(_WIN32)
+// FIXME: Use an equivalent of pthread_setspecific on Windows.
+void *TSDWorker(void *test_key) {
+  if (test_key) {
+    pthread_setspecific(*(pthread_key_t*)test_key, (void*)0xfeedface);
+  }
+  return NULL;
+}
+
+void TSDDestructor(void *tsd) {
+  // Spawning a thread will check that the current thread id is not -1.
+  pthread_t th;
+  PTHREAD_CREATE(&th, NULL, TSDWorker, NULL);
+  PTHREAD_JOIN(th, NULL);
+}
+
+// This tests triggers the thread-specific data destruction fiasco which occurs
+// if we don't manage the TSD destructors ourselves. We create a new pthread
+// key with a non-NULL destructor which is likely to be put after the destructor
+// of AsanThread in the list of destructors.
+// In this case the TSD for AsanThread will be destroyed before TSDDestructor
+// is called for the child thread, and a CHECK will fail when we call
+// pthread_create() to spawn the grandchild.
+TEST(AddressSanitizer, DISABLED_TSDTest) {
+  pthread_t th;
+  pthread_key_t test_key;
+  pthread_key_create(&test_key, TSDDestructor);
+  PTHREAD_CREATE(&th, NULL, TSDWorker, &test_key);
+  PTHREAD_JOIN(th, NULL);
+  pthread_key_delete(test_key);
+}
+#endif
+
+TEST(AddressSanitizer, UAF_char) {
+  const char *uaf_string = "AddressSanitizer:.*heap-use-after-free";
+  EXPECT_DEATH(uaf_test<U1>(1, 0), uaf_string);
+  EXPECT_DEATH(uaf_test<U1>(10, 0), uaf_string);
+  EXPECT_DEATH(uaf_test<U1>(10, 10), uaf_string);
+  EXPECT_DEATH(uaf_test<U1>(kLargeMalloc, 0), uaf_string);
+  EXPECT_DEATH(uaf_test<U1>(kLargeMalloc, kLargeMalloc / 2), uaf_string);
+}
+
+TEST(AddressSanitizer, UAF_long_double) {
+  if (sizeof(long double) == sizeof(double)) return;
+  long double *p = Ident(new long double[10]);
+  EXPECT_DEATH(Ident(p)[12] = 0, "WRITE of size 1[026]");
+  EXPECT_DEATH(Ident(p)[0] = Ident(p)[12], "READ of size 1[026]");
+  delete [] Ident(p);
+}
+
+#if !defined(_WIN32)
+struct Packed5 {
+  int x;
+  char c;
+} __attribute__((packed));
+#else
+# pragma pack(push, 1)
+struct Packed5 {
+  int x;
+  char c;
+};
+# pragma pack(pop)
+#endif
+
+TEST(AddressSanitizer, UAF_Packed5) {
+  static_assert(sizeof(Packed5) == 5, "Please check the keywords used");
+  Packed5 *p = Ident(new Packed5[2]);
+  EXPECT_DEATH(p[0] = p[3], "READ of size 5");
+  EXPECT_DEATH(p[3] = p[0], "WRITE of size 5");
+  delete [] Ident(p);
+}
+
+#if ASAN_HAS_BLACKLIST
+TEST(AddressSanitizer, IgnoreTest) {
+  int *x = Ident(new int);
+  delete Ident(x);
+  *x = 0;
+}
+#endif  // ASAN_HAS_BLACKLIST
+
+struct StructWithBitField {
+  int bf1:1;
+  int bf2:1;
+  int bf3:1;
+  int bf4:29;
+};
+
+TEST(AddressSanitizer, BitFieldPositiveTest) {
+  StructWithBitField *x = new StructWithBitField;
+  delete Ident(x);
+  EXPECT_DEATH(x->bf1 = 0, "use-after-free");
+  EXPECT_DEATH(x->bf2 = 0, "use-after-free");
+  EXPECT_DEATH(x->bf3 = 0, "use-after-free");
+  EXPECT_DEATH(x->bf4 = 0, "use-after-free");
+}
+
+struct StructWithBitFields_8_24 {
+  int a:8;
+  int b:24;
+};
+
+TEST(AddressSanitizer, BitFieldNegativeTest) {
+  StructWithBitFields_8_24 *x = Ident(new StructWithBitFields_8_24);
+  x->a = 0;
+  x->b = 0;
+  delete Ident(x);
+}
+
+#if ASAN_NEEDS_SEGV
+namespace {
+
+const char kSEGVCrash[] = "AddressSanitizer: SEGV on unknown address";
+const char kOverriddenHandler[] = "ASan signal handler has been overridden\n";
+
+TEST(AddressSanitizer, WildAddressTest) {
+  char *c = (char*)0x123;
+  EXPECT_DEATH(*c = 0, kSEGVCrash);
+}
+
+void my_sigaction_sighandler(int, siginfo_t*, void*) {
+  fprintf(stderr, kOverriddenHandler);
+  exit(1);
+}
+
+void my_signal_sighandler(int signum) {
+  fprintf(stderr, kOverriddenHandler);
+  exit(1);
+}
+
+TEST(AddressSanitizer, SignalTest) {
+  struct sigaction sigact;
+  memset(&sigact, 0, sizeof(sigact));
+  sigact.sa_sigaction = my_sigaction_sighandler;
+  sigact.sa_flags = SA_SIGINFO;
+  // ASan should silently ignore sigaction()...
+  EXPECT_EQ(0, sigaction(SIGSEGV, &sigact, 0));
+#ifdef __APPLE__
+  EXPECT_EQ(0, sigaction(SIGBUS, &sigact, 0));
+#endif
+  char *c = (char*)0x123;
+  EXPECT_DEATH(*c = 0, kSEGVCrash);
+  // ... and signal().
+  EXPECT_EQ(0, signal(SIGSEGV, my_signal_sighandler));
+  EXPECT_DEATH(*c = 0, kSEGVCrash);
+}
+}  // namespace
+#endif
+
+static void TestLargeMalloc(size_t size) {
+  char buff[1024];
+  sprintf(buff, "is located 1 bytes to the left of %lu-byte", (long)size);
+  EXPECT_DEATH(Ident((char*)malloc(size))[-1] = 0, buff);
+}
+
+TEST(AddressSanitizer, LargeMallocTest) {
+  const int max_size = (SANITIZER_WORDSIZE == 32) ? 1 << 26 : 1 << 28;
+  for (int i = 113; i < max_size; i = i * 2 + 13) {
+    TestLargeMalloc(i);
+  }
+}
+
+TEST(AddressSanitizer, HugeMallocTest) {
+  if (SANITIZER_WORDSIZE != 64 || ASAN_AVOID_EXPENSIVE_TESTS) return;
+  size_t n_megs = 4100;
+  EXPECT_DEATH(Ident((char*)malloc(n_megs << 20))[-1] = 0,
+               "is located 1 bytes to the left|"
+               "AddressSanitizer failed to allocate");
+}
+
+#if SANITIZER_TEST_HAS_MEMALIGN
+void MemalignRun(size_t align, size_t size, int idx) {
+  char *p = (char *)memalign(align, size);
+  Ident(p)[idx] = 0;
+  free(p);
+}
+
+TEST(AddressSanitizer, memalign) {
+  for (int align = 16; align <= (1 << 23); align *= 2) {
+    size_t size = align * 5;
+    EXPECT_DEATH(MemalignRun(align, size, -1),
+                 "is located 1 bytes to the left");
+    EXPECT_DEATH(MemalignRun(align, size, size + 1),
+                 "is located 1 bytes to the right");
+  }
+}
+#endif  // SANITIZER_TEST_HAS_MEMALIGN
+
+void *ManyThreadsWorker(void *a) {
+  for (int iter = 0; iter < 100; iter++) {
+    for (size_t size = 100; size < 2000; size *= 2) {
+      free(Ident(malloc(size)));
+    }
+  }
+  return 0;
+}
+
+#if !defined(__aarch64__)
+// FIXME: Infinite loop in AArch64 (PR24389).
+TEST(AddressSanitizer, ManyThreadsTest) {
+  const size_t kNumThreads =
+      (SANITIZER_WORDSIZE == 32 || ASAN_AVOID_EXPENSIVE_TESTS) ? 30 : 1000;
+  pthread_t t[kNumThreads];
+  for (size_t i = 0; i < kNumThreads; i++) {
+    PTHREAD_CREATE(&t[i], 0, ManyThreadsWorker, (void*)i);
+  }
+  for (size_t i = 0; i < kNumThreads; i++) {
+    PTHREAD_JOIN(t[i], 0);
+  }
+}
+#endif
+
+TEST(AddressSanitizer, ReallocTest) {
+  const int kMinElem = 5;
+  int *ptr = (int*)malloc(sizeof(int) * kMinElem);
+  ptr[3] = 3;
+  for (int i = 0; i < 10000; i++) {
+    ptr = (int*)realloc(ptr,
+        (my_rand() % 1000 + kMinElem) * sizeof(int));
+    EXPECT_EQ(3, ptr[3]);
+  }
+  free(ptr);
+  // Realloc pointer returned by malloc(0).
+  int *ptr2 = Ident((int*)malloc(0));
+  ptr2 = Ident((int*)realloc(ptr2, sizeof(*ptr2)));
+  *ptr2 = 42;
+  EXPECT_EQ(42, *ptr2);
+  free(ptr2);
+}
+
+TEST(AddressSanitizer, ReallocFreedPointerTest) {
+  void *ptr = Ident(malloc(42));
+  ASSERT_TRUE(NULL != ptr);
+  free(ptr);
+  EXPECT_DEATH(ptr = realloc(ptr, 77), "attempting double-free");
+}
+
+TEST(AddressSanitizer, ReallocInvalidPointerTest) {
+  void *ptr = Ident(malloc(42));
+  EXPECT_DEATH(ptr = realloc((int*)ptr + 1, 77), "attempting free.*not malloc");
+  free(ptr);
+}
+
+TEST(AddressSanitizer, ZeroSizeMallocTest) {
+  // Test that malloc(0) and similar functions don't return NULL.
+  void *ptr = Ident(malloc(0));
+  EXPECT_TRUE(NULL != ptr);
+  free(ptr);
+#if SANITIZER_TEST_HAS_POSIX_MEMALIGN
+  int pm_res = posix_memalign(&ptr, 1<<20, 0);
+  EXPECT_EQ(0, pm_res);
+  EXPECT_TRUE(NULL != ptr);
+  free(ptr);
+#endif  // SANITIZER_TEST_HAS_POSIX_MEMALIGN
+  int *int_ptr = new int[0];
+  int *int_ptr2 = new int[0];
+  EXPECT_TRUE(NULL != int_ptr);
+  EXPECT_TRUE(NULL != int_ptr2);
+  EXPECT_NE(int_ptr, int_ptr2);
+  delete[] int_ptr;
+  delete[] int_ptr2;
+}
+
+#if SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE
+static const char *kMallocUsableSizeErrorMsg =
+  "AddressSanitizer: attempting to call malloc_usable_size()";
+
+TEST(AddressSanitizer, MallocUsableSizeTest) {
+  const size_t kArraySize = 100;
+  char *array = Ident((char*)malloc(kArraySize));
+  int *int_ptr = Ident(new int);
+  EXPECT_EQ(0U, malloc_usable_size(NULL));
+  EXPECT_EQ(kArraySize, malloc_usable_size(array));
+  EXPECT_EQ(sizeof(int), malloc_usable_size(int_ptr));
+  EXPECT_DEATH(malloc_usable_size((void*)0x123), kMallocUsableSizeErrorMsg);
+  EXPECT_DEATH(malloc_usable_size(array + kArraySize / 2),
+               kMallocUsableSizeErrorMsg);
+  free(array);
+  EXPECT_DEATH(malloc_usable_size(array), kMallocUsableSizeErrorMsg);
+  delete int_ptr;
+}
+#endif  // SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE
+
+void WrongFree() {
+  int *x = (int*)malloc(100 * sizeof(int));
+  // Use the allocated memory, otherwise Clang will optimize it out.
+  Ident(x);
+  free(x + 1);
+}
+
+#if !defined(_WIN32)  // FIXME: This should be a lit test.
+TEST(AddressSanitizer, WrongFreeTest) {
+  EXPECT_DEATH(WrongFree(), ASAN_PCRE_DOTALL
+               "ERROR: AddressSanitizer: attempting free.*not malloc"
+               ".*is located 4 bytes inside of 400-byte region"
+               ".*allocated by thread");
+}
+#endif
+
+void DoubleFree() {
+  int *x = (int*)malloc(100 * sizeof(int));
+  fprintf(stderr, "DoubleFree: x=%p\n", (void *)x);
+  free(x);
+  free(x);
+  fprintf(stderr, "should have failed in the second free(%p)\n", (void *)x);
+  abort();
+}
+
+#if !defined(_WIN32)  // FIXME: This should be a lit test.
+TEST(AddressSanitizer, DoubleFreeTest) {
+  EXPECT_DEATH(DoubleFree(), ASAN_PCRE_DOTALL
+               "ERROR: AddressSanitizer: attempting double-free"
+               ".*is located 0 bytes inside of 400-byte region"
+               ".*freed by thread T0 here"
+               ".*previously allocated by thread T0 here");
+}
+#endif
+
+template<int kSize>
+NOINLINE void SizedStackTest() {
+  char a[kSize];
+  char  *A = Ident((char*)&a);
+  const char *expected_death = "AddressSanitizer: stack-buffer-";
+  for (size_t i = 0; i < kSize; i++)
+    A[i] = i;
+  EXPECT_DEATH(A[-1] = 0, expected_death);
+  EXPECT_DEATH(A[-5] = 0, expected_death);
+  EXPECT_DEATH(A[kSize] = 0, expected_death);
+  EXPECT_DEATH(A[kSize + 1] = 0, expected_death);
+  EXPECT_DEATH(A[kSize + 5] = 0, expected_death);
+  if (kSize > 16)
+    EXPECT_DEATH(A[kSize + 31] = 0, expected_death);
+}
+
+TEST(AddressSanitizer, SimpleStackTest) {
+  SizedStackTest<1>();
+  SizedStackTest<2>();
+  SizedStackTest<3>();
+  SizedStackTest<4>();
+  SizedStackTest<5>();
+  SizedStackTest<6>();
+  SizedStackTest<7>();
+  SizedStackTest<16>();
+  SizedStackTest<25>();
+  SizedStackTest<34>();
+  SizedStackTest<43>();
+  SizedStackTest<51>();
+  SizedStackTest<62>();
+  SizedStackTest<64>();
+  SizedStackTest<128>();
+}
+
+#if !defined(_WIN32)
+// FIXME: It's a bit hard to write multi-line death test expectations
+// in a portable way.  Anyways, this should just be turned into a lit test.
+TEST(AddressSanitizer, ManyStackObjectsTest) {
+  char XXX[10];
+  char YYY[20];
+  char ZZZ[30];
+  Ident(XXX);
+  Ident(YYY);
+  EXPECT_DEATH(Ident(ZZZ)[-1] = 0, ASAN_PCRE_DOTALL "XXX.*YYY.*ZZZ");
+}
+#endif
+
+#if 0  // This test requires online symbolizer.
+// Moved to lit_tests/stack-oob-frames.cc.
+// Reenable here once we have online symbolizer by default.
+NOINLINE static void Frame0(int frame, char *a, char *b, char *c) {
+  char d[4] = {0};
+  char *D = Ident(d);
+  switch (frame) {
+    case 3: a[5]++; break;
+    case 2: b[5]++; break;
+    case 1: c[5]++; break;
+    case 0: D[5]++; break;
+  }
+}
+NOINLINE static void Frame1(int frame, char *a, char *b) {
+  char c[4] = {0}; Frame0(frame, a, b, c);
+  break_optimization(0);
+}
+NOINLINE static void Frame2(int frame, char *a) {
+  char b[4] = {0}; Frame1(frame, a, b);
+  break_optimization(0);
+}
+NOINLINE static void Frame3(int frame) {
+  char a[4] = {0}; Frame2(frame, a);
+  break_optimization(0);
+}
+
+TEST(AddressSanitizer, GuiltyStackFrame0Test) {
+  EXPECT_DEATH(Frame3(0), "located .*in frame <.*Frame0");
+}
+TEST(AddressSanitizer, GuiltyStackFrame1Test) {
+  EXPECT_DEATH(Frame3(1), "located .*in frame <.*Frame1");
+}
+TEST(AddressSanitizer, GuiltyStackFrame2Test) {
+  EXPECT_DEATH(Frame3(2), "located .*in frame <.*Frame2");
+}
+TEST(AddressSanitizer, GuiltyStackFrame3Test) {
+  EXPECT_DEATH(Frame3(3), "located .*in frame <.*Frame3");
+}
+#endif
+
+NOINLINE void LongJmpFunc1(jmp_buf buf) {
+  // create three red zones for these two stack objects.
+  int a;
+  int b;
+
+  int *A = Ident(&a);
+  int *B = Ident(&b);
+  *A = *B;
+  longjmp(buf, 1);
+}
+
+NOINLINE void TouchStackFunc() {
+  int a[100];  // long array will intersect with redzones from LongJmpFunc1.
+  int *A = Ident(a);
+  for (int i = 0; i < 100; i++)
+    A[i] = i*i;
+}
+
+// Test that we handle longjmp and do not report false positives on stack.
+TEST(AddressSanitizer, LongJmpTest) {
+  static jmp_buf buf;
+  if (!setjmp(buf)) {
+    LongJmpFunc1(buf);
+  } else {
+    TouchStackFunc();
+  }
+}
+
+#if !defined(_WIN32)  // Only basic longjmp is available on Windows.
+NOINLINE void UnderscopeLongJmpFunc1(jmp_buf buf) {
+  // create three red zones for these two stack objects.
+  int a;
+  int b;
+
+  int *A = Ident(&a);
+  int *B = Ident(&b);
+  *A = *B;
+  _longjmp(buf, 1);
+}
+
+NOINLINE void SigLongJmpFunc1(sigjmp_buf buf) {
+  // create three red zones for these two stack objects.
+  int a;
+  int b;
+
+  int *A = Ident(&a);
+  int *B = Ident(&b);
+  *A = *B;
+  siglongjmp(buf, 1);
+}
+
+#if !defined(__ANDROID__) && !defined(__arm__) && \
+    !defined(__powerpc64__) && !defined(__powerpc__) && \
+    !defined(__aarch64__) && !defined(__mips__) && \
+    !defined(__mips64)
+NOINLINE void BuiltinLongJmpFunc1(jmp_buf buf) {
+  // create three red zones for these two stack objects.
+  int a;
+  int b;
+
+  int *A = Ident(&a);
+  int *B = Ident(&b);
+  *A = *B;
+  __builtin_longjmp((void**)buf, 1);
+}
+
+// Does not work on Power and ARM:
+// https://github.com/google/sanitizers/issues/185
+TEST(AddressSanitizer, BuiltinLongJmpTest) {
+  static jmp_buf buf;
+  if (!__builtin_setjmp((void**)buf)) {
+    BuiltinLongJmpFunc1(buf);
+  } else {
+    TouchStackFunc();
+  }
+}
+#endif  // !defined(__ANDROID__) && !defined(__powerpc64__) &&
+        // !defined(__powerpc__) && !defined(__arm__) &&
+        // !defined(__mips__) && !defined(__mips64)
+
+TEST(AddressSanitizer, UnderscopeLongJmpTest) {
+  static jmp_buf buf;
+  if (!_setjmp(buf)) {
+    UnderscopeLongJmpFunc1(buf);
+  } else {
+    TouchStackFunc();
+  }
+}
+
+TEST(AddressSanitizer, SigLongJmpTest) {
+  static sigjmp_buf buf;
+  if (!sigsetjmp(buf, 1)) {
+    SigLongJmpFunc1(buf);
+  } else {
+    TouchStackFunc();
+  }
+}
+#endif
+
+// FIXME: Why does clang-cl define __EXCEPTIONS?
+#if defined(__EXCEPTIONS) && !defined(_WIN32)
+NOINLINE void ThrowFunc() {
+  // create three red zones for these two stack objects.
+  int a;
+  int b;
+
+  int *A = Ident(&a);
+  int *B = Ident(&b);
+  *A = *B;
+  ASAN_THROW(1);
+}
+
+TEST(AddressSanitizer, CxxExceptionTest) {
+  if (ASAN_UAR) return;
+  // TODO(kcc): this test crashes on 32-bit for some reason...
+  if (SANITIZER_WORDSIZE == 32) return;
+  try {
+    ThrowFunc();
+  } catch(...) {}
+  TouchStackFunc();
+}
+#endif
+
+void *ThreadStackReuseFunc1(void *unused) {
+  // create three red zones for these two stack objects.
+  int a;
+  int b;
+
+  int *A = Ident(&a);
+  int *B = Ident(&b);
+  *A = *B;
+  pthread_exit(0);
+  return 0;
+}
+
+void *ThreadStackReuseFunc2(void *unused) {
+  TouchStackFunc();
+  return 0;
+}
+
+TEST(AddressSanitizer, ThreadStackReuseTest) {
+  pthread_t t;
+  PTHREAD_CREATE(&t, 0, ThreadStackReuseFunc1, 0);
+  PTHREAD_JOIN(t, 0);
+  PTHREAD_CREATE(&t, 0, ThreadStackReuseFunc2, 0);
+  PTHREAD_JOIN(t, 0);
+}
+
+#if defined(__i686__) || defined(__x86_64__)
+#include <emmintrin.h>
+TEST(AddressSanitizer, Store128Test) {
+  char *a = Ident((char*)malloc(Ident(12)));
+  char *p = a;
+  if (((uintptr_t)a % 16) != 0)
+    p = a + 8;
+  assert(((uintptr_t)p % 16) == 0);
+  __m128i value_wide = _mm_set1_epi16(0x1234);
+  EXPECT_DEATH(_mm_store_si128((__m128i*)p, value_wide),
+               "AddressSanitizer: heap-buffer-overflow");
+  EXPECT_DEATH(_mm_store_si128((__m128i*)p, value_wide),
+               "WRITE of size 16");
+  EXPECT_DEATH(_mm_store_si128((__m128i*)p, value_wide),
+               "located 0 bytes to the right of 12-byte");
+  free(a);
+}
+#endif
+
+// FIXME: All tests that use this function should be turned into lit tests.
+string RightOOBErrorMessage(int oob_distance, bool is_write) {
+  assert(oob_distance >= 0);
+  char expected_str[100];
+  sprintf(expected_str, ASAN_PCRE_DOTALL
+#if !GTEST_USES_SIMPLE_RE
+          "buffer-overflow.*%s.*"
+#endif
+          "located %d bytes to the right",
+#if !GTEST_USES_SIMPLE_RE
+          is_write ? "WRITE" : "READ",
+#endif
+          oob_distance);
+  return string(expected_str);
+}
+
+string RightOOBWriteMessage(int oob_distance) {
+  return RightOOBErrorMessage(oob_distance, /*is_write*/true);
+}
+
+string RightOOBReadMessage(int oob_distance) {
+  return RightOOBErrorMessage(oob_distance, /*is_write*/false);
+}
+
+// FIXME: All tests that use this function should be turned into lit tests.
+string LeftOOBErrorMessage(int oob_distance, bool is_write) {
+  assert(oob_distance > 0);
+  char expected_str[100];
+  sprintf(expected_str,
+#if !GTEST_USES_SIMPLE_RE
+          ASAN_PCRE_DOTALL "%s.*"
+#endif
+          "located %d bytes to the left",
+#if !GTEST_USES_SIMPLE_RE
+          is_write ? "WRITE" : "READ",
+#endif
+          oob_distance);
+  return string(expected_str);
+}
+
+string LeftOOBWriteMessage(int oob_distance) {
+  return LeftOOBErrorMessage(oob_distance, /*is_write*/true);
+}
+
+string LeftOOBReadMessage(int oob_distance) {
+  return LeftOOBErrorMessage(oob_distance, /*is_write*/false);
+}
+
+string LeftOOBAccessMessage(int oob_distance) {
+  assert(oob_distance > 0);
+  char expected_str[100];
+  sprintf(expected_str, "located %d bytes to the left", oob_distance);
+  return string(expected_str);
+}
+
+char* MallocAndMemsetString(size_t size, char ch) {
+  char *s = Ident((char*)malloc(size));
+  memset(s, ch, size);
+  return s;
+}
+
+char* MallocAndMemsetString(size_t size) {
+  return MallocAndMemsetString(size, 'z');
+}
+
+#if defined(__linux__) && !defined(__ANDROID__)
+#define READ_TEST(READ_N_BYTES)                                          \
+  char *x = new char[10];                                                \
+  int fd = open("/proc/self/stat", O_RDONLY);                            \
+  ASSERT_GT(fd, 0);                                                      \
+  EXPECT_DEATH(READ_N_BYTES,                                             \
+               ASAN_PCRE_DOTALL                                          \
+               "AddressSanitizer: heap-buffer-overflow"                  \
+               ".* is located 0 bytes to the right of 10-byte region");  \
+  close(fd);                                                             \
+  delete [] x;                                                           \
+
+TEST(AddressSanitizer, pread) {
+  READ_TEST(pread(fd, x, 15, 0));
+}
+
+TEST(AddressSanitizer, pread64) {
+  READ_TEST(pread64(fd, x, 15, 0));
+}
+
+TEST(AddressSanitizer, read) {
+  READ_TEST(read(fd, x, 15));
+}
+#endif  // defined(__linux__) && !defined(__ANDROID__)
+
+// This test case fails
+// Clang optimizes memcpy/memset calls which lead to unaligned access
+TEST(AddressSanitizer, DISABLED_MemIntrinsicUnalignedAccessTest) {
+  int size = Ident(4096);
+  char *s = Ident((char*)malloc(size));
+  EXPECT_DEATH(memset(s + size - 1, 0, 2), RightOOBWriteMessage(0));
+  free(s);
+}
+
+// TODO(samsonov): Add a test with malloc(0)
+// TODO(samsonov): Add tests for str* and mem* functions.
+
+NOINLINE static int LargeFunction(bool do_bad_access) {
+  int *x = new int[100];
+  x[0]++;
+  x[1]++;
+  x[2]++;
+  x[3]++;
+  x[4]++;
+  x[5]++;
+  x[6]++;
+  x[7]++;
+  x[8]++;
+  x[9]++;
+
+  x[do_bad_access ? 100 : 0]++; int res = __LINE__;
+
+  x[10]++;
+  x[11]++;
+  x[12]++;
+  x[13]++;
+  x[14]++;
+  x[15]++;
+  x[16]++;
+  x[17]++;
+  x[18]++;
+  x[19]++;
+
+  delete[] x;
+  return res;
+}
+
+// Test the we have correct debug info for the failing instruction.
+// This test requires the in-process symbolizer to be enabled by default.
+TEST(AddressSanitizer, DISABLED_LargeFunctionSymbolizeTest) {
+  int failing_line = LargeFunction(false);
+  char expected_warning[128];
+  sprintf(expected_warning, "LargeFunction.*asan_test.*:%d", failing_line);
+  EXPECT_DEATH(LargeFunction(true), expected_warning);
+}
+
+// Check that we unwind and symbolize correctly.
+TEST(AddressSanitizer, DISABLED_MallocFreeUnwindAndSymbolizeTest) {
+  int *a = (int*)malloc_aaa(sizeof(int));
+  *a = 1;
+  free_aaa(a);
+  EXPECT_DEATH(*a = 1, "free_ccc.*free_bbb.*free_aaa.*"
+               "malloc_fff.*malloc_eee.*malloc_ddd");
+}
+
+static bool TryToSetThreadName(const char *name) {
+#if defined(__linux__) && defined(PR_SET_NAME)
+  return 0 == prctl(PR_SET_NAME, (unsigned long)name, 0, 0, 0);
+#else
+  return false;
+#endif
+}
+
+void *ThreadedTestAlloc(void *a) {
+  EXPECT_EQ(true, TryToSetThreadName("AllocThr"));
+  int **p = (int**)a;
+  *p = new int;
+  return 0;
+}
+
+void *ThreadedTestFree(void *a) {
+  EXPECT_EQ(true, TryToSetThreadName("FreeThr"));
+  int **p = (int**)a;
+  delete *p;
+  return 0;
+}
+
+void *ThreadedTestUse(void *a) {
+  EXPECT_EQ(true, TryToSetThreadName("UseThr"));
+  int **p = (int**)a;
+  **p = 1;
+  return 0;
+}
+
+void ThreadedTestSpawn() {
+  pthread_t t;
+  int *x;
+  PTHREAD_CREATE(&t, 0, ThreadedTestAlloc, &x);
+  PTHREAD_JOIN(t, 0);
+  PTHREAD_CREATE(&t, 0, ThreadedTestFree, &x);
+  PTHREAD_JOIN(t, 0);
+  PTHREAD_CREATE(&t, 0, ThreadedTestUse, &x);
+  PTHREAD_JOIN(t, 0);
+}
+
+#if !defined(_WIN32)  // FIXME: This should be a lit test.
+TEST(AddressSanitizer, ThreadedTest) {
+  EXPECT_DEATH(ThreadedTestSpawn(),
+               ASAN_PCRE_DOTALL
+               "Thread T.*created"
+               ".*Thread T.*created"
+               ".*Thread T.*created");
+}
+#endif
+
+void *ThreadedTestFunc(void *unused) {
+  // Check if prctl(PR_SET_NAME) is supported. Return if not.
+  if (!TryToSetThreadName("TestFunc"))
+    return 0;
+  EXPECT_DEATH(ThreadedTestSpawn(),
+               ASAN_PCRE_DOTALL
+               "WRITE .*thread T. .UseThr."
+               ".*freed by thread T. .FreeThr. here:"
+               ".*previously allocated by thread T. .AllocThr. here:"
+               ".*Thread T. .UseThr. created by T.*TestFunc"
+               ".*Thread T. .FreeThr. created by T"
+               ".*Thread T. .AllocThr. created by T"
+               "");
+  return 0;
+}
+
+TEST(AddressSanitizer, ThreadNamesTest) {
+  // Run ThreadedTestFunc in a separate thread because it tries to set a
+  // thread name and we don't want to change the main thread's name.
+  pthread_t t;
+  PTHREAD_CREATE(&t, 0, ThreadedTestFunc, 0);
+  PTHREAD_JOIN(t, 0);
+}
+
+#if ASAN_NEEDS_SEGV
+TEST(AddressSanitizer, ShadowGapTest) {
+#if SANITIZER_WORDSIZE == 32
+  char *addr = (char*)0x22000000;
+#else
+# if defined(__powerpc64__)
+  char *addr = (char*)0x024000800000;
+# else
+  char *addr = (char*)0x0000100000080000;
+# endif
+#endif
+  EXPECT_DEATH(*addr = 1, "AddressSanitizer: SEGV on unknown");
+}
+#endif  // ASAN_NEEDS_SEGV
+
+extern "C" {
+NOINLINE static void UseThenFreeThenUse() {
+  char *x = Ident((char*)malloc(8));
+  *x = 1;
+  free_aaa(x);
+  *x = 2;
+}
+}
+
+TEST(AddressSanitizer, UseThenFreeThenUseTest) {
+  EXPECT_DEATH(UseThenFreeThenUse(), "freed by thread");
+}
+
+TEST(AddressSanitizer, StrDupTest) {
+  free(strdup(Ident("123")));
+}
+
+// Currently we create and poison redzone at right of global variables.
+static char static110[110];
+const char ConstGlob[7] = {1, 2, 3, 4, 5, 6, 7};
+static const char StaticConstGlob[3] = {9, 8, 7};
+
+TEST(AddressSanitizer, GlobalTest) {
+  static char func_static15[15];
+
+  static char fs1[10];
+  static char fs2[10];
+  static char fs3[10];
+
+  glob5[Ident(0)] = 0;
+  glob5[Ident(1)] = 0;
+  glob5[Ident(2)] = 0;
+  glob5[Ident(3)] = 0;
+  glob5[Ident(4)] = 0;
+
+  EXPECT_DEATH(glob5[Ident(5)] = 0,
+               "0 bytes to the right of global variable.*glob5.* size 5");
+  EXPECT_DEATH(glob5[Ident(5+6)] = 0,
+               "6 bytes to the right of global variable.*glob5.* size 5");
+  Ident(static110);  // avoid optimizations
+  static110[Ident(0)] = 0;
+  static110[Ident(109)] = 0;
+  EXPECT_DEATH(static110[Ident(110)] = 0,
+               "0 bytes to the right of global variable");
+  EXPECT_DEATH(static110[Ident(110+7)] = 0,
+               "7 bytes to the right of global variable");
+
+  Ident(func_static15);  // avoid optimizations
+  func_static15[Ident(0)] = 0;
+  EXPECT_DEATH(func_static15[Ident(15)] = 0,
+               "0 bytes to the right of global variable");
+  EXPECT_DEATH(func_static15[Ident(15 + 9)] = 0,
+               "9 bytes to the right of global variable");
+
+  Ident(fs1);
+  Ident(fs2);
+  Ident(fs3);
+
+  // We don't create left redzones, so this is not 100% guaranteed to fail.
+  // But most likely will.
+  EXPECT_DEATH(fs2[Ident(-1)] = 0, "is located.*of global variable");
+
+  EXPECT_DEATH(Ident(Ident(ConstGlob)[8]),
+               "is located 1 bytes to the right of .*ConstGlob");
+  EXPECT_DEATH(Ident(Ident(StaticConstGlob)[5]),
+               "is located 2 bytes to the right of .*StaticConstGlob");
+
+  // call stuff from another file.
+  GlobalsTest(0);
+}
+
+TEST(AddressSanitizer, GlobalStringConstTest) {
+  static const char *zoo = "FOOBAR123";
+  const char *p = Ident(zoo);
+  EXPECT_DEATH(Ident(p[15]), "is ascii string 'FOOBAR123'");
+}
+
+TEST(AddressSanitizer, FileNameInGlobalReportTest) {
+  static char zoo[10];
+  const char *p = Ident(zoo);
+  // The file name should be present in the report.
+  EXPECT_DEATH(Ident(p[15]), "zoo.*asan_test.");
+}
+
+int *ReturnsPointerToALocalObject() {
+  int a = 0;
+  return Ident(&a);
+}
+
+#if ASAN_UAR == 1
+TEST(AddressSanitizer, LocalReferenceReturnTest) {
+  int *(*f)() = Ident(ReturnsPointerToALocalObject);
+  int *p = f();
+  // Call 'f' a few more times, 'p' should still be poisoned.
+  for (int i = 0; i < 32; i++)
+    f();
+  EXPECT_DEATH(*p = 1, "AddressSanitizer: stack-use-after-return");
+  EXPECT_DEATH(*p = 1, "is located.*in frame .*ReturnsPointerToALocal");
+}
+#endif
+
+template <int kSize>
+NOINLINE static void FuncWithStack() {
+  char x[kSize];
+  Ident(x)[0] = 0;
+  Ident(x)[kSize-1] = 0;
+}
+
+static void LotsOfStackReuse() {
+  int LargeStack[10000];
+  Ident(LargeStack)[0] = 0;
+  for (int i = 0; i < 10000; i++) {
+    FuncWithStack<128 * 1>();
+    FuncWithStack<128 * 2>();
+    FuncWithStack<128 * 4>();
+    FuncWithStack<128 * 8>();
+    FuncWithStack<128 * 16>();
+    FuncWithStack<128 * 32>();
+    FuncWithStack<128 * 64>();
+    FuncWithStack<128 * 128>();
+    FuncWithStack<128 * 256>();
+    FuncWithStack<128 * 512>();
+    Ident(LargeStack)[0] = 0;
+  }
+}
+
+TEST(AddressSanitizer, StressStackReuseTest) {
+  LotsOfStackReuse();
+}
+
+TEST(AddressSanitizer, ThreadedStressStackReuseTest) {
+  const int kNumThreads = 20;
+  pthread_t t[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_CREATE(&t[i], 0, (void* (*)(void *x))LotsOfStackReuse, 0);
+  }
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_JOIN(t[i], 0);
+  }
+}
+
+static void *PthreadExit(void *a) {
+  pthread_exit(0);
+  return 0;
+}
+
+TEST(AddressSanitizer, PthreadExitTest) {
+  pthread_t t;
+  for (int i = 0; i < 1000; i++) {
+    PTHREAD_CREATE(&t, 0, PthreadExit, 0);
+    PTHREAD_JOIN(t, 0);
+  }
+}
+
+// FIXME: Why does clang-cl define __EXCEPTIONS?
+#if defined(__EXCEPTIONS) && !defined(_WIN32)
+NOINLINE static void StackReuseAndException() {
+  int large_stack[1000];
+  Ident(large_stack);
+  ASAN_THROW(1);
+}
+
+// TODO(kcc): support exceptions with use-after-return.
+TEST(AddressSanitizer, DISABLED_StressStackReuseAndExceptionsTest) {
+  for (int i = 0; i < 10000; i++) {
+    try {
+    StackReuseAndException();
+    } catch(...) {
+    }
+  }
+}
+#endif
+
+#if !defined(_WIN32)
+TEST(AddressSanitizer, MlockTest) {
+  EXPECT_EQ(0, mlockall(MCL_CURRENT));
+  EXPECT_EQ(0, mlock((void*)0x12345, 0x5678));
+  EXPECT_EQ(0, munlockall());
+  EXPECT_EQ(0, munlock((void*)0x987, 0x654));
+}
+#endif
+
+struct LargeStruct {
+  int foo[100];
+};
+
+// Test for bug http://llvm.org/bugs/show_bug.cgi?id=11763.
+// Struct copy should not cause asan warning even if lhs == rhs.
+TEST(AddressSanitizer, LargeStructCopyTest) {
+  LargeStruct a;
+  *Ident(&a) = *Ident(&a);
+}
+
+ATTRIBUTE_NO_SANITIZE_ADDRESS
+static void NoSanitizeAddress() {
+  char *foo = new char[10];
+  Ident(foo)[10] = 0;
+  delete [] foo;
+}
+
+TEST(AddressSanitizer, AttributeNoSanitizeAddressTest) {
+  Ident(NoSanitizeAddress)();
+}
+
+// The new/delete/etc mismatch checks don't work on Android,
+//   as calls to new/delete go through malloc/free.
+// OS X support is tracked here:
+//   https://github.com/google/sanitizers/issues/131
+// Windows support is tracked here:
+//   https://github.com/google/sanitizers/issues/309
+#if !defined(__ANDROID__) && \
+    !defined(__APPLE__) && \
+    !defined(_WIN32)
+static string MismatchStr(const string &str) {
+  return string("AddressSanitizer: alloc-dealloc-mismatch \\(") + str;
+}
+
+TEST(AddressSanitizer, AllocDeallocMismatch) {
+  EXPECT_DEATH(free(Ident(new int)),
+               MismatchStr("operator new vs free"));
+  EXPECT_DEATH(free(Ident(new int[2])),
+               MismatchStr("operator new \\[\\] vs free"));
+  EXPECT_DEATH(delete (Ident(new int[2])),
+               MismatchStr("operator new \\[\\] vs operator delete"));
+  EXPECT_DEATH(delete (Ident((int*)malloc(2 * sizeof(int)))),
+               MismatchStr("malloc vs operator delete"));
+  EXPECT_DEATH(delete [] (Ident(new int)),
+               MismatchStr("operator new vs operator delete \\[\\]"));
+  EXPECT_DEATH(delete [] (Ident((int*)malloc(2 * sizeof(int)))),
+               MismatchStr("malloc vs operator delete \\[\\]"));
+}
+#endif
+
+// ------------------ demo tests; run each one-by-one -------------
+// e.g. --gtest_filter=*DemoOOBLeftHigh --gtest_also_run_disabled_tests
+TEST(AddressSanitizer, DISABLED_DemoThreadedTest) {
+  ThreadedTestSpawn();
+}
+
+void *SimpleBugOnSTack(void *x = 0) {
+  char a[20];
+  Ident(a)[20] = 0;
+  return 0;
+}
+
+TEST(AddressSanitizer, DISABLED_DemoStackTest) {
+  SimpleBugOnSTack();
+}
+
+TEST(AddressSanitizer, DISABLED_DemoThreadStackTest) {
+  pthread_t t;
+  PTHREAD_CREATE(&t, 0, SimpleBugOnSTack, 0);
+  PTHREAD_JOIN(t, 0);
+}
+
+TEST(AddressSanitizer, DISABLED_DemoUAFLowIn) {
+  uaf_test<U1>(10, 0);
+}
+TEST(AddressSanitizer, DISABLED_DemoUAFLowLeft) {
+  uaf_test<U1>(10, -2);
+}
+TEST(AddressSanitizer, DISABLED_DemoUAFLowRight) {
+  uaf_test<U1>(10, 10);
+}
+
+TEST(AddressSanitizer, DISABLED_DemoUAFHigh) {
+  uaf_test<U1>(kLargeMalloc, 0);
+}
+
+TEST(AddressSanitizer, DISABLED_DemoOOM) {
+  size_t size = SANITIZER_WORDSIZE == 64 ? (size_t)(1ULL << 40) : (0xf0000000);
+  printf("%p\n", malloc(size));
+}
+
+TEST(AddressSanitizer, DISABLED_DemoDoubleFreeTest) {
+  DoubleFree();
+}
+
+TEST(AddressSanitizer, DISABLED_DemoNullDerefTest) {
+  int *a = 0;
+  Ident(a)[10] = 0;
+}
+
+TEST(AddressSanitizer, DISABLED_DemoFunctionStaticTest) {
+  static char a[100];
+  static char b[100];
+  static char c[100];
+  Ident(a);
+  Ident(b);
+  Ident(c);
+  Ident(a)[5] = 0;
+  Ident(b)[105] = 0;
+  Ident(a)[5] = 0;
+}
+
+TEST(AddressSanitizer, DISABLED_DemoTooMuchMemoryTest) {
+  const size_t kAllocSize = (1 << 28) - 1024;
+  size_t total_size = 0;
+  while (true) {
+    void *x = malloc(kAllocSize);
+    memset(x, 0, kAllocSize);
+    total_size += kAllocSize;
+    fprintf(stderr, "total: %ldM %p\n", (long)total_size >> 20, x);
+  }
+}
+
+// https://github.com/google/sanitizers/issues/66
+TEST(AddressSanitizer, BufferOverflowAfterManyFrees) {
+  for (int i = 0; i < 1000000; i++) {
+    delete [] (Ident(new char [8644]));
+  }
+  char *x = new char[8192];
+  EXPECT_DEATH(x[Ident(8192)] = 0, "AddressSanitizer: heap-buffer-overflow");
+  delete [] Ident(x);
+}
+
+
+// Test that instrumentation of stack allocations takes into account
+// AllocSize of a type, and not its StoreSize (16 vs 10 bytes for long double).
+// See http://llvm.org/bugs/show_bug.cgi?id=12047 for more details.
+TEST(AddressSanitizer, LongDoubleNegativeTest) {
+  long double a, b;
+  static long double c;
+  memcpy(Ident(&a), Ident(&b), sizeof(long double));
+  memcpy(Ident(&c), Ident(&b), sizeof(long double));
+}
+
+#if !defined(_WIN32)
+TEST(AddressSanitizer, pthread_getschedparam) {
+  int policy;
+  struct sched_param param;
+  EXPECT_DEATH(
+      pthread_getschedparam(pthread_self(), &policy, Ident(&param) + 2),
+      "AddressSanitizer: stack-buffer-.*flow");
+  EXPECT_DEATH(
+      pthread_getschedparam(pthread_self(), Ident(&policy) - 1, &param),
+      "AddressSanitizer: stack-buffer-.*flow");
+  int res = pthread_getschedparam(pthread_self(), &policy, &param);
+  ASSERT_EQ(0, res);
+}
+#endif
+
+#if SANITIZER_TEST_HAS_PRINTF_L
+static int vsnprintf_l_wrapper(char *s, size_t n,
+                               locale_t l, const char *format, ...) {
+  va_list va;
+  va_start(va, format);
+  int res = vsnprintf_l(s, n , l, format, va);
+  va_end(va);
+  return res;
+}
+
+TEST(AddressSanitizer, snprintf_l) {
+  char buff[5];
+  // Check that snprintf_l() works fine with Asan.
+  int res = snprintf_l(buff, 5,
+                       _LIBCPP_GET_C_LOCALE, "%s", "snprintf_l()");
+  EXPECT_EQ(12, res);
+  // Check that vsnprintf_l() works fine with Asan.
+  res = vsnprintf_l_wrapper(buff, 5,
+                            _LIBCPP_GET_C_LOCALE, "%s", "vsnprintf_l()");
+  EXPECT_EQ(13, res);
+
+  EXPECT_DEATH(snprintf_l(buff, 10,
+                          _LIBCPP_GET_C_LOCALE, "%s", "snprintf_l()"),
+                "AddressSanitizer: stack-buffer-overflow");
+  EXPECT_DEATH(vsnprintf_l_wrapper(buff, 10,
+                                  _LIBCPP_GET_C_LOCALE, "%s", "vsnprintf_l()"),
+                "AddressSanitizer: stack-buffer-overflow");
+}
+#endif
diff --git a/compiler-rt/lib/asan/tests/asan_test.ignore b/compiler-rt/lib/asan/tests/asan_test.ignore
new file mode 100644
index 0000000..ea5c260
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_test.ignore
@@ -0,0 +1,3 @@
+# blacklisted functions for instrumented ASan unit test
+fun:*IgnoreTest*
+fun:*SomeOtherFunc*
diff --git a/compiler-rt/lib/asan/tests/asan_test_config.h b/compiler-rt/lib/asan/tests/asan_test_config.h
new file mode 100644
index 0000000..92f2763
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_test_config.h
@@ -0,0 +1,54 @@
+//===-- asan_test_config.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#if !defined(INCLUDED_FROM_ASAN_TEST_UTILS_H)
+# error "This file should be included into asan_test_utils.h only"
+#endif
+
+#ifndef ASAN_TEST_CONFIG_H
+#define ASAN_TEST_CONFIG_H
+
+#include <vector>
+#include <string>
+#include <map>
+
+using std::string;
+using std::vector;
+using std::map;
+
+#ifndef ASAN_UAR
+# error "please define ASAN_UAR"
+#endif
+
+#ifndef ASAN_HAS_EXCEPTIONS
+# error "please define ASAN_HAS_EXCEPTIONS"
+#endif
+
+#ifndef ASAN_HAS_BLACKLIST
+# error "please define ASAN_HAS_BLACKLIST"
+#endif
+
+#ifndef ASAN_NEEDS_SEGV
+# if defined(_WIN32)
+#  define ASAN_NEEDS_SEGV 0
+# else
+#  define ASAN_NEEDS_SEGV 1
+# endif
+#endif
+
+#ifndef ASAN_AVOID_EXPENSIVE_TESTS
+# define ASAN_AVOID_EXPENSIVE_TESTS 0
+#endif
+
+#define ASAN_PCRE_DOTALL ""
+
+#endif  // ASAN_TEST_CONFIG_H
diff --git a/compiler-rt/lib/asan/tests/asan_test_main.cc b/compiler-rt/lib/asan/tests/asan_test_main.cc
new file mode 100644
index 0000000..cdaf801
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_test_main.cc
@@ -0,0 +1,33 @@
+//===-- asan_test_main.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+#include "asan_test_utils.h"
+#include "sanitizer_common/sanitizer_platform.h"
+
+// Default ASAN_OPTIONS for the unit tests. Let's turn symbolication off to
+// speed up testing (unit tests don't use it anyway).
+extern "C" const char* __asan_default_options() {
+#if SANITIZER_MAC
+  // On Darwin, we default to `abort_on_error=1`, which would make tests run
+  // much slower. Let's override this and run lit tests with 'abort_on_error=0'.
+  // Also, make sure we do not overwhelm the syslog while testing.
+  return "symbolize=false:abort_on_error=0:log_to_syslog=0";
+#else
+  return "symbolize=false";
+#endif
+}
+
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/compiler-rt/lib/asan/tests/asan_test_utils.h b/compiler-rt/lib/asan/tests/asan_test_utils.h
new file mode 100644
index 0000000..03d17cf
--- /dev/null
+++ b/compiler-rt/lib/asan/tests/asan_test_utils.h
@@ -0,0 +1,107 @@
+//===-- asan_test_utils.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_TEST_UTILS_H
+#define ASAN_TEST_UTILS_H
+
+#if !defined(SANITIZER_EXTERNAL_TEST_CONFIG)
+# define INCLUDED_FROM_ASAN_TEST_UTILS_H
+# include "asan_test_config.h"
+# undef INCLUDED_FROM_ASAN_TEST_UTILS_H
+#endif
+
+#include "sanitizer_test_utils.h"
+#include "sanitizer_pthread_wrappers.h"
+
+#include <stdio.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <assert.h>
+#include <algorithm>
+
+#if !defined(_WIN32)
+# include <strings.h>
+# include <sys/mman.h>
+# include <setjmp.h>
+#endif
+
+#ifdef __linux__
+# include <sys/prctl.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+# include <fcntl.h>
+#include <unistd.h>
+#endif
+
+#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#include <malloc.h>
+#endif
+
+#if ASAN_HAS_EXCEPTIONS
+# define ASAN_THROW(x) throw (x)
+#else
+# define ASAN_THROW(x)
+#endif
+
+typedef uint8_t   U1;
+typedef uint16_t  U2;
+typedef uint32_t  U4;
+typedef uint64_t  U8;
+
+static const int kPageSize = 4096;
+
+const size_t kLargeMalloc = 1 << 24;
+
+extern void free_aaa(void *p);
+extern void *malloc_aaa(size_t size);
+
+template<typename T>
+NOINLINE void asan_write(T *a) {
+  *a = 0;
+}
+
+string RightOOBErrorMessage(int oob_distance, bool is_write);
+string RightOOBWriteMessage(int oob_distance);
+string RightOOBReadMessage(int oob_distance);
+string LeftOOBErrorMessage(int oob_distance, bool is_write);
+string LeftOOBWriteMessage(int oob_distance);
+string LeftOOBReadMessage(int oob_distance);
+string LeftOOBAccessMessage(int oob_distance);
+char* MallocAndMemsetString(size_t size, char ch);
+char* MallocAndMemsetString(size_t size);
+
+extern char glob1[1];
+extern char glob2[2];
+extern char glob3[3];
+extern char glob4[4];
+extern char glob5[5];
+extern char glob6[6];
+extern char glob7[7];
+extern char glob8[8];
+extern char glob9[9];
+extern char glob10[10];
+extern char glob11[11];
+extern char glob12[12];
+extern char glob13[13];
+extern char glob14[14];
+extern char glob15[15];
+extern char glob16[16];
+extern char glob17[17];
+extern char glob1000[1000];
+extern char glob10000[10000];
+extern char glob100000[100000];
+extern int GlobalsTest(int x);
+
+#endif  // ASAN_TEST_UTILS_H
diff --git a/compiler-rt/lib/builtins/CMakeLists.txt b/compiler-rt/lib/builtins/CMakeLists.txt
new file mode 100644
index 0000000..5ffad1d
--- /dev/null
+++ b/compiler-rt/lib/builtins/CMakeLists.txt
@@ -0,0 +1,388 @@
+# This directory contains a large amount of C code which provides
+# generic implementations of the core runtime library along with optimized
+# architecture-specific code in various subdirectories.
+
+# TODO: Need to add a mechanism for logging errors when builtin source files are
+# added to a sub-directory and not this CMakeLists file.
+
+set(GENERIC_SOURCES
+  absvdi2.c
+  absvsi2.c
+  absvti2.c
+  adddf3.c
+  addsf3.c
+  addtf3.c
+  addvdi3.c
+  addvsi3.c
+  addvti3.c
+  apple_versioning.c
+  ashldi3.c
+  ashlti3.c
+  ashrdi3.c
+  ashrti3.c
+  # FIXME: atomic.c may only be compiled if host compiler understands _Atomic
+  # atomic.c
+  clear_cache.c
+  clzdi2.c
+  clzsi2.c
+  clzti2.c
+  cmpdi2.c
+  cmpti2.c
+  comparedf2.c
+  comparesf2.c
+  ctzdi2.c
+  ctzsi2.c
+  ctzti2.c
+  divdc3.c
+  divdf3.c
+  divdi3.c
+  divmoddi4.c
+  divmodsi4.c
+  divsc3.c
+  divsf3.c
+  divsi3.c
+  divtc3.c
+  divti3.c
+  divtf3.c
+  divxc3.c
+  enable_execute_stack.c
+  eprintf.c
+  extendsfdf2.c
+  extendhfsf2.c
+  ffsdi2.c
+  ffsti2.c
+  fixdfdi.c
+  fixdfsi.c
+  fixdfti.c
+  fixsfdi.c
+  fixsfsi.c
+  fixsfti.c
+  fixunsdfdi.c
+  fixunsdfsi.c
+  fixunsdfti.c
+  fixunssfdi.c
+  fixunssfsi.c
+  fixunssfti.c
+  fixunsxfdi.c
+  fixunsxfsi.c
+  fixunsxfti.c
+  fixxfdi.c
+  fixxfti.c
+  floatdidf.c
+  floatdisf.c
+  floatdixf.c
+  floatsidf.c
+  floatsisf.c
+  floattidf.c
+  floattisf.c
+  floattixf.c
+  floatundidf.c
+  floatundisf.c
+  floatundixf.c
+  floatunsidf.c
+  floatunsisf.c
+  floatuntidf.c
+  floatuntisf.c
+  floatuntixf.c
+  int_util.c
+  lshrdi3.c
+  lshrti3.c
+  moddi3.c
+  modsi3.c
+  modti3.c
+  muldc3.c
+  muldf3.c
+  muldi3.c
+  mulodi4.c
+  mulosi4.c
+  muloti4.c
+  mulsc3.c
+  mulsf3.c
+  multi3.c
+  multf3.c
+  mulvdi3.c
+  mulvsi3.c
+  mulvti3.c
+  mulxc3.c
+  negdf2.c
+  negdi2.c
+  negsf2.c
+  negti2.c
+  negvdi2.c
+  negvsi2.c
+  negvti2.c
+  paritydi2.c
+  paritysi2.c
+  parityti2.c
+  popcountdi2.c
+  popcountsi2.c
+  popcountti2.c
+  powidf2.c
+  powisf2.c
+  powitf2.c
+  powixf2.c
+  subdf3.c
+  subsf3.c
+  subvdi3.c
+  subvsi3.c
+  subvti3.c
+  subtf3.c
+  trampoline_setup.c
+  truncdfhf2.c
+  truncdfsf2.c
+  truncsfhf2.c
+  ucmpdi2.c
+  ucmpti2.c
+  udivdi3.c
+  udivmoddi4.c
+  udivmodsi4.c
+  udivmodti4.c
+  udivsi3.c
+  udivti3.c
+  umoddi3.c
+  umodsi3.c
+  umodti3.c)
+
+if(APPLE)
+  set(GENERIC_SOURCES
+    ${GENERIC_SOURCES}
+    atomic_flag_clear.c
+    atomic_flag_clear_explicit.c
+    atomic_flag_test_and_set.c
+    atomic_flag_test_and_set_explicit.c
+    atomic_signal_fence.c
+    atomic_thread_fence.c)
+endif()
+
+if(NOT WIN32 OR MINGW)
+  set(GENERIC_SOURCES
+      ${GENERIC_SOURCES}
+      emutls.c)
+endif()
+
+if (HAVE_UNWIND_H)
+  set(GENERIC_SOURCES
+      ${GENERIC_SOURCES}
+      gcc_personality_v0.c)
+endif ()
+
+if (NOT MSVC)
+  set(x86_64_SOURCES
+      x86_64/chkstk.S
+      x86_64/chkstk2.S
+      x86_64/floatdidf.c
+      x86_64/floatdisf.c
+      x86_64/floatdixf.c
+      x86_64/floatundidf.S
+      x86_64/floatundisf.S
+      x86_64/floatundixf.S
+      ${GENERIC_SOURCES})
+  set(x86_64h_SOURCES ${x86_64_SOURCES})
+
+  if (WIN32)
+    set(x86_64_SOURCES
+        ${x86_64_SOURCES}
+        x86_64/chkstk.S
+        x86_64/chkstk2.S)
+  endif()
+
+  set(i386_SOURCES
+      i386/ashldi3.S
+      i386/ashrdi3.S
+      i386/chkstk.S
+      i386/chkstk2.S
+      i386/divdi3.S
+      i386/floatdidf.S
+      i386/floatdisf.S
+      i386/floatdixf.S
+      i386/floatundidf.S
+      i386/floatundisf.S
+      i386/floatundixf.S
+      i386/lshrdi3.S
+      i386/moddi3.S
+      i386/muldi3.S
+      i386/udivdi3.S
+      i386/umoddi3.S
+      ${GENERIC_SOURCES})
+
+  if (WIN32)
+    set(i386_SOURCES
+        ${i386_SOURCES}
+        i386/chkstk.S
+        i386/chkstk2.S)
+  endif()
+
+  set(i686_SOURCES
+      ${i386_SOURCES})
+else () # MSVC
+  # Use C versions of functions when building on MSVC
+  # MSVC's assembler takes Intel syntax, not AT&T syntax
+  set(x86_64_SOURCES
+      x86_64/floatdidf.c
+      x86_64/floatdisf.c
+      x86_64/floatdixf.c
+      ${GENERIC_SOURCES})
+  set(x86_64h_SOURCES ${x86_64_SOURCES})
+  set(i386_SOURCES ${GENERIC_SOURCES})
+  set(i686_SOURCES ${i386_SOURCES})
+endif () # if (NOT MSVC)
+
+set(arm_SOURCES
+  arm/adddf3vfp.S
+  arm/addsf3vfp.S
+  arm/aeabi_cdcmp.S
+  arm/aeabi_cdcmpeq_check_nan.c
+  arm/aeabi_cfcmp.S
+  arm/aeabi_cfcmpeq_check_nan.c
+  arm/aeabi_dcmp.S
+  arm/aeabi_div0.c
+  arm/aeabi_drsub.c
+  arm/aeabi_fcmp.S
+  arm/aeabi_frsub.c
+  arm/aeabi_idivmod.S
+  arm/aeabi_ldivmod.S
+  arm/aeabi_memcmp.S
+  arm/aeabi_memcpy.S
+  arm/aeabi_memmove.S
+  arm/aeabi_memset.S
+  arm/aeabi_uidivmod.S
+  arm/aeabi_uldivmod.S
+  arm/bswapdi2.S
+  arm/bswapsi2.S
+  arm/clzdi2.S
+  arm/clzsi2.S
+  arm/comparesf2.S
+  arm/divdf3vfp.S
+  arm/divmodsi4.S
+  arm/divsf3vfp.S
+  arm/divsi3.S
+  arm/eqdf2vfp.S
+  arm/eqsf2vfp.S
+  arm/extendsfdf2vfp.S
+  arm/fixdfsivfp.S
+  arm/fixsfsivfp.S
+  arm/fixunsdfsivfp.S
+  arm/fixunssfsivfp.S
+  arm/floatsidfvfp.S
+  arm/floatsisfvfp.S
+  arm/floatunssidfvfp.S
+  arm/floatunssisfvfp.S
+  arm/gedf2vfp.S
+  arm/gesf2vfp.S
+  arm/gtdf2vfp.S
+  arm/gtsf2vfp.S
+  arm/ledf2vfp.S
+  arm/lesf2vfp.S
+  arm/ltdf2vfp.S
+  arm/ltsf2vfp.S
+  arm/modsi3.S
+  arm/muldf3vfp.S
+  arm/mulsf3vfp.S
+  arm/nedf2vfp.S
+  arm/negdf2vfp.S
+  arm/negsf2vfp.S
+  arm/nesf2vfp.S
+  arm/restore_vfp_d8_d15_regs.S
+  arm/save_vfp_d8_d15_regs.S
+  arm/subdf3vfp.S
+  arm/subsf3vfp.S
+  arm/switch16.S
+  arm/switch32.S
+  arm/switch8.S
+  arm/switchu8.S
+  arm/sync_fetch_and_add_4.S
+  arm/sync_fetch_and_add_8.S
+  arm/sync_fetch_and_and_4.S
+  arm/sync_fetch_and_and_8.S
+  arm/sync_fetch_and_max_4.S
+  arm/sync_fetch_and_max_8.S
+  arm/sync_fetch_and_min_4.S
+  arm/sync_fetch_and_min_8.S
+  arm/sync_fetch_and_nand_4.S
+  arm/sync_fetch_and_nand_8.S
+  arm/sync_fetch_and_or_4.S
+  arm/sync_fetch_and_or_8.S
+  arm/sync_fetch_and_sub_4.S
+  arm/sync_fetch_and_sub_8.S
+  arm/sync_fetch_and_umax_4.S
+  arm/sync_fetch_and_umax_8.S
+  arm/sync_fetch_and_umin_4.S
+  arm/sync_fetch_and_umin_8.S
+  arm/sync_fetch_and_xor_4.S
+  arm/sync_fetch_and_xor_8.S
+  arm/sync_synchronize.S
+  arm/truncdfsf2vfp.S
+  arm/udivmodsi4.S
+  arm/udivsi3.S
+  arm/umodsi3.S
+  arm/unorddf2vfp.S
+  arm/unordsf2vfp.S
+  ${GENERIC_SOURCES})
+
+set(aarch64_SOURCES
+  comparetf2.c
+  extenddftf2.c
+  extendsftf2.c
+  fixtfdi.c
+  fixtfsi.c
+  fixtfti.c
+  fixunstfdi.c
+  fixunstfsi.c
+  fixunstfti.c
+  floatditf.c
+  floatsitf.c
+  floatunditf.c
+  floatunsitf.c
+  multc3.c
+  trunctfdf2.c
+  trunctfsf2.c
+  ${GENERIC_SOURCES})
+
+set(armhf_SOURCES ${arm_SOURCES})
+set(armv7_SOURCES ${arm_SOURCES})
+set(armv7s_SOURCES ${arm_SOURCES})
+set(arm64_SOURCES ${aarch64_SOURCES})
+
+# macho_embedded archs
+set(armv6m_SOURCES ${GENERIC_SOURCES})
+set(armv7m_SOURCES ${arm_SOURCES})
+set(armv7em_SOURCES ${arm_SOURCES})
+
+set(mips_SOURCES ${GENERIC_SOURCES})
+set(mipsel_SOURCES ${mips_SOURCES})
+set(mips64_SOURCES ${mips_SOURCES})
+set(mips64el_SOURCES ${mips_SOURCES})
+
+add_custom_target(builtins)
+
+if (APPLE)
+  add_subdirectory(Darwin-excludes)
+  add_subdirectory(macho_embedded)
+  darwin_add_builtin_libraries(${BUILTIN_SUPPORTED_OS})
+elseif (NOT WIN32 OR MINGW)
+  append_string_if(COMPILER_RT_HAS_STD_C99_FLAG -std=c99 maybe_stdc99)
+
+  foreach (arch ${BUILTIN_SUPPORTED_ARCH})
+    if (CAN_TARGET_${arch})
+      # Filter out generic versions of routines that are re-implemented in
+      # architecture specific manner.  This prevents multiple definitions of the
+      # same symbols, making the symbol selection non-deterministic.
+      foreach (_file ${${arch}_SOURCES})
+        if (${_file} MATCHES ${arch}/*)
+          get_filename_component(_name ${_file} NAME)
+          string(REPLACE ".S" ".c" _cname "${_name}")
+          list(REMOVE_ITEM ${arch}_SOURCES ${_cname})
+        endif ()
+      endforeach ()
+
+      add_compiler_rt_runtime(clang_rt.builtins
+                              STATIC
+                              ARCHS ${arch}
+                              SOURCES ${${arch}_SOURCES}
+                              CFLAGS ${maybe_stdc99}
+                              PARENT_TARGET builtins)
+    endif ()
+  endforeach ()
+endif ()
+
+add_dependencies(compiler-rt builtins)
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/10.4-x86_64.txt b/compiler-rt/lib/builtins/Darwin-excludes/10.4-x86_64.txt
new file mode 100644
index 0000000..f2ee7fe
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/10.4-x86_64.txt
@@ -0,0 +1,35 @@
+absvti2
+addvti3
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divti3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+muloti4
+multi3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+subvti3
+ucmpti2
+udivmodti4
+udivti3
+umodti3
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/10.4.txt b/compiler-rt/lib/builtins/Darwin-excludes/10.4.txt
new file mode 100644
index 0000000..70d3644
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/10.4.txt
@@ -0,0 +1,96 @@
+apple_versioning
+absvdi2
+absvsi2
+adddf3
+addsf3
+addvdi3
+addvsi3
+ashldi3
+ashrdi3
+clear_cache
+clzdi2
+clzsi2
+cmpdi2
+ctzdi2
+ctzsi2
+divdc3
+divdf3
+divdi3
+divmoddi4
+divmodsi4
+divsc3
+divsf3
+divsi3
+divxc3
+enable_execute_stack
+comparedf2
+comparesf2
+extendhfsf2
+extendsfdf2
+ffsdi2
+fixdfdi
+fixdfsi
+fixsfdi
+fixsfsi
+fixunsdfdi
+fixunsdfsi
+fixunssfdi
+fixunssfsi
+fixunsxfdi
+fixunsxfsi
+fixxfdi
+floatdidf
+floatdisf
+floatdixf
+floatsidf
+floatsisf
+floatunsidf
+floatunsisf
+gcc_personality_v0
+gnu_f2h_ieee
+gnu_h2f_ieee
+lshrdi3
+moddi3
+modsi3
+muldc3
+muldf3
+muldi3
+mulodi4
+mulosi4
+mulsc3
+mulsf3
+mulvdi3
+mulvsi3
+mulxc3
+negdf2
+negdi2
+negsf2
+negvdi2
+negvsi2
+paritydi2
+paritysi2
+popcountdi2
+popcountsi2
+powidf2
+powisf2
+powixf2
+subdf3
+subsf3
+subvdi3
+subvsi3
+truncdfhf2
+truncdfsf2
+truncsfhf2
+ucmpdi2
+udivdi3
+udivmoddi4
+udivmodsi4
+udivsi3
+umoddi3
+umodsi3
+atomic_flag_clear
+atomic_flag_clear_explicit
+atomic_flag_test_and_set
+atomic_flag_test_and_set_explicit
+atomic_signal_fence
+atomic_thread_fence
\ No newline at end of file
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/CMakeLists.txt b/compiler-rt/lib/builtins/Darwin-excludes/CMakeLists.txt
new file mode 100644
index 0000000..266e422
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/CMakeLists.txt
@@ -0,0 +1,4 @@
+file(GLOB filter_files ${CMAKE_CURRENT_SOURCE_DIR}/*.txt)
+foreach(filter_file ${filter_files})
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${filter_file})
+endforeach()
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/README.TXT b/compiler-rt/lib/builtins/Darwin-excludes/README.TXT
new file mode 100644
index 0000000..173eccc
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/README.TXT
@@ -0,0 +1,11 @@
+This folder contains list of symbols that should be excluded from the builtin
+libraries for Darwin. There are two reasons symbols are excluded:
+
+(1) They aren't supported on Darwin
+(2) They are contained within the OS on the minimum supported target
+
+The builtin libraries must contain all symbols not provided by the lowest
+supported target OS. Meaning if minimum deployment target is iOS 6, all builtins
+not included in the ios6-<arch>.txt files need to be included. The one catch is
+that this is per-architecture. Since iOS 6 doesn't support arm64, when supporting
+iOS 6, the minimum deployment target for arm64 binaries is iOS 7.
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/ios-armv7.txt b/compiler-rt/lib/builtins/Darwin-excludes/ios-armv7.txt
new file mode 100644
index 0000000..6aa542f
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/ios-armv7.txt
@@ -0,0 +1,57 @@
+absvti2
+addtf3
+addvti3
+aeabi_cdcmp
+aeabi_cdcmpeq_check_nan
+aeabi_cfcmp
+aeabi_cfcmpeq_check_nan
+aeabi_dcmp
+aeabi_div0
+aeabi_drsub
+aeabi_fcmp
+aeabi_frsub
+aeabi_idivmod
+aeabi_ldivmod
+aeabi_memcmp
+aeabi_memcpy
+aeabi_memmove
+aeabi_memset
+aeabi_uidivmod
+aeabi_uldivmod
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divtf3
+divti3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+multf3
+multi3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+powitf2
+subtf3
+subvti3
+trampoline_setup
+ucmpti2
+udivmodti4
+udivti3
+umodti3
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/ios-armv7s.txt b/compiler-rt/lib/builtins/Darwin-excludes/ios-armv7s.txt
new file mode 100644
index 0000000..28167aa
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/ios-armv7s.txt
@@ -0,0 +1,57 @@
+absvti2
+addtf3
+addvti3
+aeabi_cdcmp
+aeabi_cdcmpeq_check_nan
+aeabi_cfcmp
+aeabi_cfcmpeq_check_nan
+aeabi_dcmp
+aeabi_div0
+aeabi_drsub
+aeabi_fcmp
+aeabi_frsub
+aeabi_idivmod
+aeabi_ldivmod
+aeabi_memcmp
+aeabi_memcpy
+aeabi_memmove
+aeabi_memset
+aeabi_uidivmod
+aeabi_uldivmod
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divtf3
+divti3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+multf
+multi3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+powitf2
+subtf3
+subvti3
+trampoline_setup
+ucmpti2
+udivmodti4
+udivti3
+umodti3
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/ios.txt b/compiler-rt/lib/builtins/Darwin-excludes/ios.txt
new file mode 100644
index 0000000..5db2400
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/ios.txt
@@ -0,0 +1 @@
+apple_versioning
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/ios6-armv7.txt b/compiler-rt/lib/builtins/Darwin-excludes/ios6-armv7.txt
new file mode 100644
index 0000000..b01fa71
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/ios6-armv7.txt
@@ -0,0 +1,120 @@
+absvdi2
+absvsi2
+adddf3
+adddf3vfp
+addsf3
+addsf3vfp
+addvdi3
+addvsi3
+ashldi3
+ashrdi3
+bswapdi2
+bswapsi2
+clzdi2
+clzsi2
+cmpdi2
+ctzdi2
+ctzsi2
+divdc3
+divdf3
+divdf3vfp
+divdi3
+divmodsi4
+divsc3
+divsf3
+divsf3vfp
+divsi3
+eqdf2
+eqdf2vfp
+eqsf2
+eqsf2vfp
+extendsfdf2
+extendsfdf2vfp
+ffsdi2
+fixdfdi
+fixdfsi
+fixdfsivfp
+fixsfdi
+fixsfsi
+fixsfsivfp
+fixunsdfdi
+fixunsdfsi
+fixunsdfsivfp
+fixunssfdi
+fixunssfsi
+fixunssfsivfp
+floatdidf
+floatdisf
+floatsidf
+floatsidfvfp
+floatsisf
+floatsisfvfp
+floatundidf
+floatundisf
+floatunsidf
+floatunsisf
+floatunssidfvfp
+floatunssisfvfp
+gcc_personality_sj0
+gedf2
+gedf2vfp
+gesf2
+gesf2vfp
+gtdf2
+gtdf2vfp
+gtsf2
+gtsf2vfp
+ledf2
+ledf2vfp
+lesf2
+lesf2vfp
+lshrdi3
+ltdf2
+ltdf2vfp
+ltsf2
+ltsf2vfp
+moddi3
+modsi3
+muldc3
+muldf3
+muldf3vfp
+muldi3
+mulodi4
+mulosi4
+mulsc3
+mulsf3
+mulsf3vfp
+mulvdi3
+mulvsi3
+nedf2
+nedf2vfp
+negdi2
+negvdi2
+negvsi2
+nesf2
+nesf2vfp
+paritydi2
+paritysi2
+popcountdi2
+popcountsi2
+powidf2
+powisf2
+subdf3
+subdf3vfp
+subsf3
+subsf3vfp
+subvdi3
+subvsi3
+truncdfsf2
+truncdfsf2vfp
+ucmpdi2
+udivdi3
+udivmoddi4
+udivmodsi4
+udivsi3
+umoddi3
+umodsi3
+unorddf2
+unorddf2vfp
+unordsf2
+unordsf2vfp
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/ios6-armv7s.txt b/compiler-rt/lib/builtins/Darwin-excludes/ios6-armv7s.txt
new file mode 100644
index 0000000..b01fa71
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/ios6-armv7s.txt
@@ -0,0 +1,120 @@
+absvdi2
+absvsi2
+adddf3
+adddf3vfp
+addsf3
+addsf3vfp
+addvdi3
+addvsi3
+ashldi3
+ashrdi3
+bswapdi2
+bswapsi2
+clzdi2
+clzsi2
+cmpdi2
+ctzdi2
+ctzsi2
+divdc3
+divdf3
+divdf3vfp
+divdi3
+divmodsi4
+divsc3
+divsf3
+divsf3vfp
+divsi3
+eqdf2
+eqdf2vfp
+eqsf2
+eqsf2vfp
+extendsfdf2
+extendsfdf2vfp
+ffsdi2
+fixdfdi
+fixdfsi
+fixdfsivfp
+fixsfdi
+fixsfsi
+fixsfsivfp
+fixunsdfdi
+fixunsdfsi
+fixunsdfsivfp
+fixunssfdi
+fixunssfsi
+fixunssfsivfp
+floatdidf
+floatdisf
+floatsidf
+floatsidfvfp
+floatsisf
+floatsisfvfp
+floatundidf
+floatundisf
+floatunsidf
+floatunsisf
+floatunssidfvfp
+floatunssisfvfp
+gcc_personality_sj0
+gedf2
+gedf2vfp
+gesf2
+gesf2vfp
+gtdf2
+gtdf2vfp
+gtsf2
+gtsf2vfp
+ledf2
+ledf2vfp
+lesf2
+lesf2vfp
+lshrdi3
+ltdf2
+ltdf2vfp
+ltsf2
+ltsf2vfp
+moddi3
+modsi3
+muldc3
+muldf3
+muldf3vfp
+muldi3
+mulodi4
+mulosi4
+mulsc3
+mulsf3
+mulsf3vfp
+mulvdi3
+mulvsi3
+nedf2
+nedf2vfp
+negdi2
+negvdi2
+negvsi2
+nesf2
+nesf2vfp
+paritydi2
+paritysi2
+popcountdi2
+popcountsi2
+powidf2
+powisf2
+subdf3
+subdf3vfp
+subsf3
+subsf3vfp
+subvdi3
+subvsi3
+truncdfsf2
+truncdfsf2vfp
+ucmpdi2
+udivdi3
+udivmoddi4
+udivmodsi4
+udivsi3
+umoddi3
+umodsi3
+unorddf2
+unorddf2vfp
+unordsf2
+unordsf2vfp
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/ios7-arm64.txt b/compiler-rt/lib/builtins/Darwin-excludes/ios7-arm64.txt
new file mode 100644
index 0000000..5e4caf9
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/ios7-arm64.txt
@@ -0,0 +1,16 @@
+clzti2
+divti3
+fixdfti
+fixsfti
+fixunsdfti
+floattidf
+floattisf
+floatuntidf
+floatuntisf
+gcc_personality_v0
+modti3
+powidf2
+powisf2
+udivmodti4
+udivti3
+umodti3
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/iossim-i386.txt b/compiler-rt/lib/builtins/Darwin-excludes/iossim-i386.txt
new file mode 100644
index 0000000..60c0e2d
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/iossim-i386.txt
@@ -0,0 +1,82 @@
+absvti2
+addtf3
+addvti3
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divti3
+divtf3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+muloti4
+multi3
+multf3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+powitf2
+subvti3
+subtf3
+trampoline_setup
+ucmpti2
+udivmodti4
+udivti3
+umodti3
+absvti2
+addtf3
+addvti3
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divti3
+divtf3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+muloti4
+multi3
+multf3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+powitf2
+subvti3
+subtf3
+trampoline_setup
+ucmpti2
+udivmodti4
+udivti3
+umodti3
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/iossim-x86_64.txt b/compiler-rt/lib/builtins/Darwin-excludes/iossim-x86_64.txt
new file mode 100644
index 0000000..de1574e
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/iossim-x86_64.txt
@@ -0,0 +1,12 @@
+addtf3
+divtf3
+multf3
+powitf2
+subtf3
+trampoline_setup
+addtf3
+divtf3
+multf3
+powitf2
+subtf3
+trampoline_setup
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/iossim.txt b/compiler-rt/lib/builtins/Darwin-excludes/iossim.txt
new file mode 100644
index 0000000..5db2400
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/iossim.txt
@@ -0,0 +1 @@
+apple_versioning
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/osx-i386.txt b/compiler-rt/lib/builtins/Darwin-excludes/osx-i386.txt
new file mode 100644
index 0000000..60c0e2d
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/osx-i386.txt
@@ -0,0 +1,82 @@
+absvti2
+addtf3
+addvti3
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divti3
+divtf3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+muloti4
+multi3
+multf3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+powitf2
+subvti3
+subtf3
+trampoline_setup
+ucmpti2
+udivmodti4
+udivti3
+umodti3
+absvti2
+addtf3
+addvti3
+ashlti3
+ashrti3
+clzti2
+cmpti2
+ctzti2
+divti3
+divtf3
+ffsti2
+fixdfti
+fixsfti
+fixunsdfti
+fixunssfti
+fixunsxfti
+fixxfti
+floattidf
+floattisf
+floattixf
+floatuntidf
+floatuntisf
+floatuntixf
+lshrti3
+modti3
+muloti4
+multi3
+multf3
+mulvti3
+negti2
+negvti2
+parityti2
+popcountti2
+powitf2
+subvti3
+subtf3
+trampoline_setup
+ucmpti2
+udivmodti4
+udivti3
+umodti3
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/osx-x86_64.txt b/compiler-rt/lib/builtins/Darwin-excludes/osx-x86_64.txt
new file mode 100644
index 0000000..de1574e
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/osx-x86_64.txt
@@ -0,0 +1,12 @@
+addtf3
+divtf3
+multf3
+powitf2
+subtf3
+trampoline_setup
+addtf3
+divtf3
+multf3
+powitf2
+subtf3
+trampoline_setup
diff --git a/compiler-rt/lib/builtins/Darwin-excludes/osx.txt b/compiler-rt/lib/builtins/Darwin-excludes/osx.txt
new file mode 100644
index 0000000..5db2400
--- /dev/null
+++ b/compiler-rt/lib/builtins/Darwin-excludes/osx.txt
@@ -0,0 +1 @@
+apple_versioning
diff --git a/compiler-rt/lib/builtins/Makefile.mk b/compiler-rt/lib/builtins/Makefile.mk
new file mode 100644
index 0000000..00e2f53
--- /dev/null
+++ b/compiler-rt/lib/builtins/Makefile.mk
@@ -0,0 +1,25 @@
+#===- lib/builtins/Makefile.mk -----------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs :=
+
+# Add arch specific optimized implementations.
+SubDirs += i386 ppc x86_64 arm armv6m
+
+# Add ARM64 dir.
+SubDirs += arm64
+
+# Define the variables for this specific directory.
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o)
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/README.txt b/compiler-rt/lib/builtins/README.txt
new file mode 100644
index 0000000..ad36e4e
--- /dev/null
+++ b/compiler-rt/lib/builtins/README.txt
@@ -0,0 +1,345 @@
+Compiler-RT
+================================
+
+This directory and its subdirectories contain source code for the compiler
+support routines.
+
+Compiler-RT is open source software. You may freely distribute it under the
+terms of the license agreement found in LICENSE.txt.
+
+================================
+
+This is a replacement library for libgcc.  Each function is contained
+in its own file.  Each function has a corresponding unit test under
+test/Unit.
+
+A rudimentary script to test each file is in the file called
+test/Unit/test.
+
+Here is the specification for this library:
+
+http://gcc.gnu.org/onlinedocs/gccint/Libgcc.html#Libgcc
+
+Here is a synopsis of the contents of this library:
+
+typedef      int si_int;
+typedef unsigned su_int;
+
+typedef          long long di_int;
+typedef unsigned long long du_int;
+
+// Integral bit manipulation
+
+di_int __ashldi3(di_int a, si_int b);      // a << b
+ti_int __ashlti3(ti_int a, si_int b);      // a << b
+
+di_int __ashrdi3(di_int a, si_int b);      // a >> b  arithmetic (sign fill)
+ti_int __ashrti3(ti_int a, si_int b);      // a >> b  arithmetic (sign fill)
+di_int __lshrdi3(di_int a, si_int b);      // a >> b  logical    (zero fill)
+ti_int __lshrti3(ti_int a, si_int b);      // a >> b  logical    (zero fill)
+
+si_int __clzsi2(si_int a);  // count leading zeros
+si_int __clzdi2(di_int a);  // count leading zeros
+si_int __clzti2(ti_int a);  // count leading zeros
+si_int __ctzsi2(si_int a);  // count trailing zeros
+si_int __ctzdi2(di_int a);  // count trailing zeros
+si_int __ctzti2(ti_int a);  // count trailing zeros
+
+si_int __ffsdi2(di_int a);  // find least significant 1 bit
+si_int __ffsti2(ti_int a);  // find least significant 1 bit
+
+si_int __paritysi2(si_int a);  // bit parity
+si_int __paritydi2(di_int a);  // bit parity
+si_int __parityti2(ti_int a);  // bit parity
+
+si_int __popcountsi2(si_int a);  // bit population
+si_int __popcountdi2(di_int a);  // bit population
+si_int __popcountti2(ti_int a);  // bit population
+
+uint32_t __bswapsi2(uint32_t a);   // a byteswapped, arm only
+uint64_t __bswapdi2(uint64_t a);   // a byteswapped, arm only
+
+// Integral arithmetic
+
+di_int __negdi2    (di_int a);                         // -a
+ti_int __negti2    (ti_int a);                         // -a
+di_int __muldi3    (di_int a, di_int b);               // a * b
+ti_int __multi3    (ti_int a, ti_int b);               // a * b
+si_int __divsi3    (si_int a, si_int b);               // a / b   signed
+di_int __divdi3    (di_int a, di_int b);               // a / b   signed
+ti_int __divti3    (ti_int a, ti_int b);               // a / b   signed
+su_int __udivsi3   (su_int n, su_int d);               // a / b   unsigned
+du_int __udivdi3   (du_int a, du_int b);               // a / b   unsigned
+tu_int __udivti3   (tu_int a, tu_int b);               // a / b   unsigned
+si_int __modsi3    (si_int a, si_int b);               // a % b   signed
+di_int __moddi3    (di_int a, di_int b);               // a % b   signed
+ti_int __modti3    (ti_int a, ti_int b);               // a % b   signed
+su_int __umodsi3   (su_int a, su_int b);               // a % b   unsigned
+du_int __umoddi3   (du_int a, du_int b);               // a % b   unsigned
+tu_int __umodti3   (tu_int a, tu_int b);               // a % b   unsigned
+du_int __udivmoddi4(du_int a, du_int b, du_int* rem);  // a / b, *rem = a % b  unsigned
+tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);  // a / b, *rem = a % b  unsigned
+su_int __udivmodsi4(su_int a, su_int b, su_int* rem);  // a / b, *rem = a % b  unsigned
+si_int __divmodsi4(si_int a, si_int b, si_int* rem);   // a / b, *rem = a % b  signed
+
+
+
+//  Integral arithmetic with trapping overflow
+
+si_int __absvsi2(si_int a);           // abs(a)
+di_int __absvdi2(di_int a);           // abs(a)
+ti_int __absvti2(ti_int a);           // abs(a)
+
+si_int __negvsi2(si_int a);           // -a
+di_int __negvdi2(di_int a);           // -a
+ti_int __negvti2(ti_int a);           // -a
+
+si_int __addvsi3(si_int a, si_int b);  // a + b
+di_int __addvdi3(di_int a, di_int b);  // a + b
+ti_int __addvti3(ti_int a, ti_int b);  // a + b
+
+si_int __subvsi3(si_int a, si_int b);  // a - b
+di_int __subvdi3(di_int a, di_int b);  // a - b
+ti_int __subvti3(ti_int a, ti_int b);  // a - b
+
+si_int __mulvsi3(si_int a, si_int b);  // a * b
+di_int __mulvdi3(di_int a, di_int b);  // a * b
+ti_int __mulvti3(ti_int a, ti_int b);  // a * b
+
+
+// Integral arithmetic which returns if overflow
+
+si_int __mulosi4(si_int a, si_int b, int* overflow);  // a * b, overflow set to one if result not in signed range
+di_int __mulodi4(di_int a, di_int b, int* overflow);  // a * b, overflow set to one if result not in signed range
+ti_int __muloti4(ti_int a, ti_int b, int* overflow);  // a * b, overflow set to
+ one if result not in signed range
+
+
+//  Integral comparison: a  < b -> 0
+//                       a == b -> 1
+//                       a  > b -> 2
+
+si_int __cmpdi2 (di_int a, di_int b);
+si_int __cmpti2 (ti_int a, ti_int b);
+si_int __ucmpdi2(du_int a, du_int b);
+si_int __ucmpti2(tu_int a, tu_int b);
+
+//  Integral / floating point conversion
+
+di_int __fixsfdi(      float a);
+di_int __fixdfdi(     double a);
+di_int __fixxfdi(long double a);
+
+ti_int __fixsfti(      float a);
+ti_int __fixdfti(     double a);
+ti_int __fixxfti(long double a);
+uint64_t __fixtfdi(long double input);  // ppc only, doesn't match documentation
+
+su_int __fixunssfsi(      float a);
+su_int __fixunsdfsi(     double a);
+su_int __fixunsxfsi(long double a);
+
+du_int __fixunssfdi(      float a);
+du_int __fixunsdfdi(     double a);
+du_int __fixunsxfdi(long double a);
+
+tu_int __fixunssfti(      float a);
+tu_int __fixunsdfti(     double a);
+tu_int __fixunsxfti(long double a);
+uint64_t __fixunstfdi(long double input);  // ppc only
+
+float       __floatdisf(di_int a);
+double      __floatdidf(di_int a);
+long double __floatdixf(di_int a);
+long double __floatditf(int64_t a);        // ppc only
+
+float       __floattisf(ti_int a);
+double      __floattidf(ti_int a);
+long double __floattixf(ti_int a);
+
+float       __floatundisf(du_int a);
+double      __floatundidf(du_int a);
+long double __floatundixf(du_int a);
+long double __floatunditf(uint64_t a);     // ppc only
+
+float       __floatuntisf(tu_int a);
+double      __floatuntidf(tu_int a);
+long double __floatuntixf(tu_int a);
+
+//  Floating point raised to integer power
+
+float       __powisf2(      float a, si_int b);  // a ^ b
+double      __powidf2(     double a, si_int b);  // a ^ b
+long double __powixf2(long double a, si_int b);  // a ^ b
+long double __powitf2(long double a, si_int b);  // ppc only, a ^ b
+
+//  Complex arithmetic
+
+//  (a + ib) * (c + id)
+
+      float _Complex __mulsc3( float a,  float b,  float c,  float d);
+     double _Complex __muldc3(double a, double b, double c, double d);
+long double _Complex __mulxc3(long double a, long double b,
+                              long double c, long double d);
+long double _Complex __multc3(long double a, long double b,
+                              long double c, long double d); // ppc only
+
+//  (a + ib) / (c + id)
+
+      float _Complex __divsc3( float a,  float b,  float c,  float d);
+     double _Complex __divdc3(double a, double b, double c, double d);
+long double _Complex __divxc3(long double a, long double b,
+                              long double c, long double d);
+long double _Complex __divtc3(long double a, long double b,
+                              long double c, long double d);  // ppc only
+
+
+//         Runtime support
+
+// __clear_cache() is used to tell process that new instructions have been
+// written to an address range.  Necessary on processors that do not have
+// a unified instruction and data cache.
+void __clear_cache(void* start, void* end);
+
+// __enable_execute_stack() is used with nested functions when a trampoline
+// function is written onto the stack and that page range needs to be made
+// executable.
+void __enable_execute_stack(void* addr);
+
+// __gcc_personality_v0() is normally only called by the system unwinder.
+// C code (as opposed to C++) normally does not need a personality function
+// because there are no catch clauses or destructors to be run.  But there
+// is a C language extension __attribute__((cleanup(func))) which marks local
+// variables as needing the cleanup function "func" to be run when the
+// variable goes out of scope.  That includes when an exception is thrown,
+// so a personality handler is needed.  
+_Unwind_Reason_Code __gcc_personality_v0(int version, _Unwind_Action actions,
+         uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
+         _Unwind_Context_t context);
+
+// for use with some implementations of assert() in <assert.h>
+void __eprintf(const char* format, const char* assertion_expression,
+				const char* line, const char* file);
+
+// for systems with emulated thread local storage
+void* __emutls_get_address(struct __emutls_control*);
+
+
+//   Power PC specific functions
+
+// There is no C interface to the saveFP/restFP functions.  They are helper
+// functions called by the prolog and epilog of functions that need to save
+// a number of non-volatile float point registers.  
+saveFP
+restFP
+
+// PowerPC has a standard template for trampoline functions.  This function
+// generates a custom trampoline function with the specific realFunc
+// and localsPtr values.
+void __trampoline_setup(uint32_t* trampOnStack, int trampSizeAllocated, 
+                                const void* realFunc, void* localsPtr);
+
+// adds two 128-bit double-double precision values ( x + y )
+long double __gcc_qadd(long double x, long double y);  
+
+// subtracts two 128-bit double-double precision values ( x - y )
+long double __gcc_qsub(long double x, long double y); 
+
+// multiples two 128-bit double-double precision values ( x * y )
+long double __gcc_qmul(long double x, long double y);  
+
+// divides two 128-bit double-double precision values ( x / y )
+long double __gcc_qdiv(long double a, long double b);  
+
+
+//    ARM specific functions
+
+// There is no C interface to the switch* functions.  These helper functions
+// are only needed by Thumb1 code for efficient switch table generation.
+switch16
+switch32
+switch8
+switchu8
+
+// There is no C interface to the *_vfp_d8_d15_regs functions.  There are
+// called in the prolog and epilog of Thumb1 functions.  When the C++ ABI use
+// SJLJ for exceptions, each function with a catch clause or destuctors needs
+// to save and restore all registers in it prolog and epliog.  But there is 
+// no way to access vector and high float registers from thumb1 code, so the 
+// compiler must add call outs to these helper functions in the prolog and 
+// epilog.
+restore_vfp_d8_d15_regs
+save_vfp_d8_d15_regs
+
+
+// Note: long ago ARM processors did not have floating point hardware support.
+// Floating point was done in software and floating point parameters were 
+// passed in integer registers.  When hardware support was added for floating
+// point, new *vfp functions were added to do the same operations but with 
+// floating point parameters in floating point registers.
+
+// Undocumented functions
+
+float  __addsf3vfp(float a, float b);   // Appears to return a + b
+double __adddf3vfp(double a, double b); // Appears to return a + b
+float  __divsf3vfp(float a, float b);   // Appears to return a / b
+double __divdf3vfp(double a, double b); // Appears to return a / b
+int    __eqsf2vfp(float a, float b);    // Appears to return  one
+                                        //     iff a == b and neither is NaN.
+int    __eqdf2vfp(double a, double b);  // Appears to return  one
+                                        //     iff a == b and neither is NaN.
+double __extendsfdf2vfp(float a);       // Appears to convert from
+                                        //     float to double.
+int    __fixdfsivfp(double a);          // Appears to convert from
+                                        //     double to int.
+int    __fixsfsivfp(float a);           // Appears to convert from
+                                        //     float to int.
+unsigned int __fixunssfsivfp(float a);  // Appears to convert from
+                                        //     float to unsigned int.
+unsigned int __fixunsdfsivfp(double a); // Appears to convert from
+                                        //     double to unsigned int.
+double __floatsidfvfp(int a);           // Appears to convert from
+                                        //     int to double.
+float __floatsisfvfp(int a);            // Appears to convert from
+                                        //     int to float.
+double __floatunssidfvfp(unsigned int a); // Appears to convert from
+                                        //     unisgned int to double.
+float __floatunssisfvfp(unsigned int a); // Appears to convert from
+                                        //     unisgned int to float.
+int __gedf2vfp(double a, double b);     // Appears to return __gedf2
+                                        //     (a >= b)
+int __gesf2vfp(float a, float b);       // Appears to return __gesf2
+                                        //     (a >= b)
+int __gtdf2vfp(double a, double b);     // Appears to return __gtdf2
+                                        //     (a > b)
+int __gtsf2vfp(float a, float b);       // Appears to return __gtsf2
+                                        //     (a > b)
+int __ledf2vfp(double a, double b);     // Appears to return __ledf2
+                                        //     (a <= b)
+int __lesf2vfp(float a, float b);       // Appears to return __lesf2
+                                        //     (a <= b)
+int __ltdf2vfp(double a, double b);     // Appears to return __ltdf2
+                                        //     (a < b)
+int __ltsf2vfp(float a, float b);       // Appears to return __ltsf2
+                                        //     (a < b)
+double __muldf3vfp(double a, double b); // Appears to return a * b
+float __mulsf3vfp(float a, float b);    // Appears to return a * b
+int __nedf2vfp(double a, double b);     // Appears to return __nedf2
+                                        //     (a != b)
+double __negdf2vfp(double a);           // Appears to return -a
+float __negsf2vfp(float a);             // Appears to return -a
+float __negsf2vfp(float a);             // Appears to return -a
+double __subdf3vfp(double a, double b); // Appears to return a - b
+float __subsf3vfp(float a, float b);    // Appears to return a - b
+float __truncdfsf2vfp(double a);        // Appears to convert from
+                                        //     double to float.
+int __unorddf2vfp(double a, double b);  // Appears to return __unorddf2
+int __unordsf2vfp(float a, float b);    // Appears to return __unordsf2
+
+
+Preconditions are listed for each function at the definition when there are any.
+Any preconditions reflect the specification at
+http://gcc.gnu.org/onlinedocs/gccint/Libgcc.html#Libgcc.
+
+Assumptions are listed in "int_lib.h", and in individual files.  Where possible
+assumptions are checked at compile time.
diff --git a/compiler-rt/lib/builtins/absvdi2.c b/compiler-rt/lib/builtins/absvdi2.c
new file mode 100644
index 0000000..682c235
--- /dev/null
+++ b/compiler-rt/lib/builtins/absvdi2.c
@@ -0,0 +1,29 @@
+/*===-- absvdi2.c - Implement __absvdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ * This file implements __absvdi2 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: absolute value */
+
+/* Effects: aborts if abs(x) < 0 */
+
+COMPILER_RT_ABI di_int
+__absvdi2(di_int a)
+{
+    const int N = (int)(sizeof(di_int) * CHAR_BIT);
+    if (a == ((di_int)1 << (N-1)))
+        compilerrt_abort();
+    const di_int t = a >> (N - 1);
+    return (a ^ t) - t;
+}
diff --git a/compiler-rt/lib/builtins/absvsi2.c b/compiler-rt/lib/builtins/absvsi2.c
new file mode 100644
index 0000000..4812af8
--- /dev/null
+++ b/compiler-rt/lib/builtins/absvsi2.c
@@ -0,0 +1,29 @@
+/* ===-- absvsi2.c - Implement __absvsi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __absvsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: absolute value */
+
+/* Effects: aborts if abs(x) < 0 */
+
+COMPILER_RT_ABI si_int
+__absvsi2(si_int a)
+{
+    const int N = (int)(sizeof(si_int) * CHAR_BIT);
+    if (a == (1 << (N-1)))
+        compilerrt_abort();
+    const si_int t = a >> (N - 1);
+    return (a ^ t) - t;
+}
diff --git a/compiler-rt/lib/builtins/absvti2.c b/compiler-rt/lib/builtins/absvti2.c
new file mode 100644
index 0000000..7927770
--- /dev/null
+++ b/compiler-rt/lib/builtins/absvti2.c
@@ -0,0 +1,34 @@
+/* ===-- absvti2.c - Implement __absvdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __absvti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: absolute value */
+
+/* Effects: aborts if abs(x) < 0 */
+
+COMPILER_RT_ABI ti_int
+__absvti2(ti_int a)
+{
+    const int N = (int)(sizeof(ti_int) * CHAR_BIT);
+    if (a == ((ti_int)1 << (N-1)))
+        compilerrt_abort();
+    const ti_int s = a >> (N - 1);
+    return (a ^ s) - s;
+}
+
+#endif /* CRT_HAS_128BIT */
+
diff --git a/compiler-rt/lib/builtins/adddf3.c b/compiler-rt/lib/builtins/adddf3.c
new file mode 100644
index 0000000..8b7aae0
--- /dev/null
+++ b/compiler-rt/lib/builtins/adddf3.c
@@ -0,0 +1,22 @@
+//===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements double-precision soft-float addition with the IEEE-754
+// default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_add_impl.inc"
+
+ARM_EABI_FNALIAS(dadd, adddf3)
+
+COMPILER_RT_ABI double __adddf3(double a, double b){
+    return __addXf3__(a, b);
+}
diff --git a/compiler-rt/lib/builtins/addsf3.c b/compiler-rt/lib/builtins/addsf3.c
new file mode 100644
index 0000000..0f5d6ea
--- /dev/null
+++ b/compiler-rt/lib/builtins/addsf3.c
@@ -0,0 +1,22 @@
+//===-- lib/addsf3.c - Single-precision addition ------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements single-precision soft-float addition with the IEEE-754
+// default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_add_impl.inc"
+
+ARM_EABI_FNALIAS(fadd, addsf3)
+
+COMPILER_RT_ABI float __addsf3(float a, float b) {
+    return __addXf3__(a, b);
+}
diff --git a/compiler-rt/lib/builtins/addtf3.c b/compiler-rt/lib/builtins/addtf3.c
new file mode 100644
index 0000000..e4bbe02
--- /dev/null
+++ b/compiler-rt/lib/builtins/addtf3.c
@@ -0,0 +1,25 @@
+//===-- lib/addtf3.c - Quad-precision addition --------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements quad-precision soft-float addition with the IEEE-754
+// default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#include "fp_add_impl.inc"
+
+COMPILER_RT_ABI long double __addtf3(long double a, long double b){
+    return __addXf3__(a, b);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/addvdi3.c b/compiler-rt/lib/builtins/addvdi3.c
new file mode 100644
index 0000000..0da3894
--- /dev/null
+++ b/compiler-rt/lib/builtins/addvdi3.c
@@ -0,0 +1,36 @@
+/* ===-- addvdi3.c - Implement __addvdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __addvdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a + b */
+
+/* Effects: aborts if a + b overflows */
+
+COMPILER_RT_ABI di_int
+__addvdi3(di_int a, di_int b)
+{
+    di_int s = (du_int) a + (du_int) b;
+    if (b >= 0)
+    {
+        if (s < a)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (s >= a)
+            compilerrt_abort();
+    }
+    return s;
+}
diff --git a/compiler-rt/lib/builtins/addvsi3.c b/compiler-rt/lib/builtins/addvsi3.c
new file mode 100644
index 0000000..94ca726
--- /dev/null
+++ b/compiler-rt/lib/builtins/addvsi3.c
@@ -0,0 +1,36 @@
+/* ===-- addvsi3.c - Implement __addvsi3 -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __addvsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a + b */
+
+/* Effects: aborts if a + b overflows */
+
+COMPILER_RT_ABI si_int
+__addvsi3(si_int a, si_int b)
+{
+    si_int s = (su_int) a + (su_int) b;
+    if (b >= 0)
+    {
+        if (s < a)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (s >= a)
+            compilerrt_abort();
+    }
+    return s;
+}
diff --git a/compiler-rt/lib/builtins/addvti3.c b/compiler-rt/lib/builtins/addvti3.c
new file mode 100644
index 0000000..c224de6
--- /dev/null
+++ b/compiler-rt/lib/builtins/addvti3.c
@@ -0,0 +1,40 @@
+/* ===-- addvti3.c - Implement __addvti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __addvti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a + b */
+
+/* Effects: aborts if a + b overflows */
+
+COMPILER_RT_ABI ti_int
+__addvti3(ti_int a, ti_int b)
+{
+    ti_int s = (tu_int) a + (tu_int) b;
+    if (b >= 0)
+    {
+        if (s < a)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (s >= a)
+            compilerrt_abort();
+    }
+    return s;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/apple_versioning.c b/compiler-rt/lib/builtins/apple_versioning.c
new file mode 100644
index 0000000..3797a1a
--- /dev/null
+++ b/compiler-rt/lib/builtins/apple_versioning.c
@@ -0,0 +1,350 @@
+/* ===-- apple_versioning.c - Adds versioning symbols for ld ---------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+
+#if __APPLE__
+  #include <Availability.h>
+  
+  #if __IPHONE_OS_VERSION_MIN_REQUIRED
+    #define NOT_HERE_BEFORE_10_6(sym) 
+    #define NOT_HERE_IN_10_8_AND_EARLIER(sym) \
+        extern const char sym##_tmp61 __asm("$ld$hide$os6.1$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp61 = 0; \
+        extern const char sym##_tmp60 __asm("$ld$hide$os6.0$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp60 = 0; \
+        extern const char sym##_tmp51 __asm("$ld$hide$os5.1$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp51 = 0; \
+        extern const char sym##_tmp50 __asm("$ld$hide$os5.0$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp50 = 0; 
+  #else
+    #define NOT_HERE_BEFORE_10_6(sym) \
+         extern const char sym##_tmp4 __asm("$ld$hide$os10.4$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp4 = 0; \
+        extern const char sym##_tmp5 __asm("$ld$hide$os10.5$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp5 = 0; 
+    #define NOT_HERE_IN_10_8_AND_EARLIER(sym) \
+         extern const char sym##_tmp8 __asm("$ld$hide$os10.8$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp8 = 0; \
+        extern const char sym##_tmp7 __asm("$ld$hide$os10.7$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp7 = 0; \
+        extern const char sym##_tmp6 __asm("$ld$hide$os10.6$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp6 = 0; 
+  #endif 
+
+
+/* Symbols in libSystem.dylib in 10.6 and later, 
+ *  but are in libgcc_s.dylib in earlier versions
+ */
+
+NOT_HERE_BEFORE_10_6(__absvdi2)
+NOT_HERE_BEFORE_10_6(__absvsi2)
+NOT_HERE_BEFORE_10_6(__absvti2)
+NOT_HERE_BEFORE_10_6(__addvdi3)
+NOT_HERE_BEFORE_10_6(__addvsi3)
+NOT_HERE_BEFORE_10_6(__addvti3)
+NOT_HERE_BEFORE_10_6(__ashldi3)
+NOT_HERE_BEFORE_10_6(__ashlti3)
+NOT_HERE_BEFORE_10_6(__ashrdi3)
+NOT_HERE_BEFORE_10_6(__ashrti3)
+NOT_HERE_BEFORE_10_6(__clear_cache)
+NOT_HERE_BEFORE_10_6(__clzdi2)
+NOT_HERE_BEFORE_10_6(__clzsi2)
+NOT_HERE_BEFORE_10_6(__clzti2)
+NOT_HERE_BEFORE_10_6(__cmpdi2)
+NOT_HERE_BEFORE_10_6(__cmpti2)
+NOT_HERE_BEFORE_10_6(__ctzdi2)
+NOT_HERE_BEFORE_10_6(__ctzsi2)
+NOT_HERE_BEFORE_10_6(__ctzti2)
+NOT_HERE_BEFORE_10_6(__divdc3)
+NOT_HERE_BEFORE_10_6(__divdi3)
+NOT_HERE_BEFORE_10_6(__divsc3)
+NOT_HERE_BEFORE_10_6(__divtc3)
+NOT_HERE_BEFORE_10_6(__divti3)
+NOT_HERE_BEFORE_10_6(__divxc3)
+NOT_HERE_BEFORE_10_6(__enable_execute_stack)
+NOT_HERE_BEFORE_10_6(__ffsdi2)
+NOT_HERE_BEFORE_10_6(__ffsti2)
+NOT_HERE_BEFORE_10_6(__fixdfdi)
+NOT_HERE_BEFORE_10_6(__fixdfti)
+NOT_HERE_BEFORE_10_6(__fixsfdi)
+NOT_HERE_BEFORE_10_6(__fixsfti)
+NOT_HERE_BEFORE_10_6(__fixtfdi)
+NOT_HERE_BEFORE_10_6(__fixunsdfdi)
+NOT_HERE_BEFORE_10_6(__fixunsdfsi)
+NOT_HERE_BEFORE_10_6(__fixunsdfti)
+NOT_HERE_BEFORE_10_6(__fixunssfdi)
+NOT_HERE_BEFORE_10_6(__fixunssfsi)
+NOT_HERE_BEFORE_10_6(__fixunssfti)
+NOT_HERE_BEFORE_10_6(__fixunstfdi)
+NOT_HERE_BEFORE_10_6(__fixunsxfdi)
+NOT_HERE_BEFORE_10_6(__fixunsxfsi)
+NOT_HERE_BEFORE_10_6(__fixunsxfti)
+NOT_HERE_BEFORE_10_6(__fixxfdi)
+NOT_HERE_BEFORE_10_6(__fixxfti)
+NOT_HERE_BEFORE_10_6(__floatdidf)
+NOT_HERE_BEFORE_10_6(__floatdisf)
+NOT_HERE_BEFORE_10_6(__floatditf)
+NOT_HERE_BEFORE_10_6(__floatdixf)
+NOT_HERE_BEFORE_10_6(__floattidf)
+NOT_HERE_BEFORE_10_6(__floattisf)
+NOT_HERE_BEFORE_10_6(__floattixf)
+NOT_HERE_BEFORE_10_6(__floatundidf)
+NOT_HERE_BEFORE_10_6(__floatundisf)
+NOT_HERE_BEFORE_10_6(__floatunditf)
+NOT_HERE_BEFORE_10_6(__floatundixf)
+NOT_HERE_BEFORE_10_6(__floatuntidf)
+NOT_HERE_BEFORE_10_6(__floatuntisf)
+NOT_HERE_BEFORE_10_6(__floatuntixf)
+NOT_HERE_BEFORE_10_6(__gcc_personality_v0)
+NOT_HERE_BEFORE_10_6(__lshrdi3)
+NOT_HERE_BEFORE_10_6(__lshrti3)
+NOT_HERE_BEFORE_10_6(__moddi3)
+NOT_HERE_BEFORE_10_6(__modti3)
+NOT_HERE_BEFORE_10_6(__muldc3)
+NOT_HERE_BEFORE_10_6(__muldi3)
+NOT_HERE_BEFORE_10_6(__mulsc3)
+NOT_HERE_BEFORE_10_6(__multc3)
+NOT_HERE_BEFORE_10_6(__multi3)
+NOT_HERE_BEFORE_10_6(__mulvdi3)
+NOT_HERE_BEFORE_10_6(__mulvsi3)
+NOT_HERE_BEFORE_10_6(__mulvti3)
+NOT_HERE_BEFORE_10_6(__mulxc3)
+NOT_HERE_BEFORE_10_6(__negdi2)
+NOT_HERE_BEFORE_10_6(__negti2)
+NOT_HERE_BEFORE_10_6(__negvdi2)
+NOT_HERE_BEFORE_10_6(__negvsi2)
+NOT_HERE_BEFORE_10_6(__negvti2)
+NOT_HERE_BEFORE_10_6(__paritydi2)
+NOT_HERE_BEFORE_10_6(__paritysi2)
+NOT_HERE_BEFORE_10_6(__parityti2)
+NOT_HERE_BEFORE_10_6(__popcountdi2)
+NOT_HERE_BEFORE_10_6(__popcountsi2)
+NOT_HERE_BEFORE_10_6(__popcountti2)
+NOT_HERE_BEFORE_10_6(__powidf2)
+NOT_HERE_BEFORE_10_6(__powisf2)
+NOT_HERE_BEFORE_10_6(__powitf2)
+NOT_HERE_BEFORE_10_6(__powixf2)
+NOT_HERE_BEFORE_10_6(__subvdi3)
+NOT_HERE_BEFORE_10_6(__subvsi3)
+NOT_HERE_BEFORE_10_6(__subvti3)
+NOT_HERE_BEFORE_10_6(__ucmpdi2)
+NOT_HERE_BEFORE_10_6(__ucmpti2)
+NOT_HERE_BEFORE_10_6(__udivdi3)
+NOT_HERE_BEFORE_10_6(__udivmoddi4)
+NOT_HERE_BEFORE_10_6(__udivmodti4)
+NOT_HERE_BEFORE_10_6(__udivti3)
+NOT_HERE_BEFORE_10_6(__umoddi3)
+NOT_HERE_BEFORE_10_6(__umodti3)
+
+
+#if __ppc__
+NOT_HERE_BEFORE_10_6(__gcc_qadd)
+NOT_HERE_BEFORE_10_6(__gcc_qdiv)
+NOT_HERE_BEFORE_10_6(__gcc_qmul)
+NOT_HERE_BEFORE_10_6(__gcc_qsub)
+NOT_HERE_BEFORE_10_6(__trampoline_setup)
+#endif /* __ppc__ */
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_compare_exchange_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_exchange_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_add_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_add_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_add_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_add_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_and_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_and_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_and_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_and_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_or_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_or_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_or_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_or_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_sub_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_sub_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_sub_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_sub_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_xor_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_xor_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_xor_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_fetch_xor_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_load_8)
+
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_1)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_2)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_4)
+NOT_HERE_IN_10_8_AND_EARLIER(__atomic_store_8)
+
+
+#if __arm__ && __DYNAMIC__
+   #define NOT_HERE_UNTIL_AFTER_4_3(sym) \
+        extern const char sym##_tmp1 __asm("$ld$hide$os3.0$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp1 = 0; \
+        extern const char sym##_tmp2 __asm("$ld$hide$os3.1$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp2 = 0; \
+        extern const char sym##_tmp3 __asm("$ld$hide$os3.2$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp3 = 0; \
+        extern const char sym##_tmp4 __asm("$ld$hide$os4.0$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp4 = 0; \
+        extern const char sym##_tmp5 __asm("$ld$hide$os4.1$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp5 = 0; \
+        extern const char sym##_tmp6 __asm("$ld$hide$os4.2$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp6 = 0; \
+        extern const char sym##_tmp7 __asm("$ld$hide$os4.3$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp7 = 0; 
+            
+NOT_HERE_UNTIL_AFTER_4_3(__absvdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__absvsi2)
+NOT_HERE_UNTIL_AFTER_4_3(__adddf3)
+NOT_HERE_UNTIL_AFTER_4_3(__adddf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__addsf3)
+NOT_HERE_UNTIL_AFTER_4_3(__addsf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__addvdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__addvsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__ashldi3)
+NOT_HERE_UNTIL_AFTER_4_3(__ashrdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__bswapdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__bswapsi2)
+NOT_HERE_UNTIL_AFTER_4_3(__clzdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__clzsi2)
+NOT_HERE_UNTIL_AFTER_4_3(__cmpdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__ctzdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__ctzsi2)
+NOT_HERE_UNTIL_AFTER_4_3(__divdc3)
+NOT_HERE_UNTIL_AFTER_4_3(__divdf3)
+NOT_HERE_UNTIL_AFTER_4_3(__divdf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__divdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__divsc3)
+NOT_HERE_UNTIL_AFTER_4_3(__divsf3)
+NOT_HERE_UNTIL_AFTER_4_3(__divsf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__divsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__eqdf2)
+NOT_HERE_UNTIL_AFTER_4_3(__eqdf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__eqsf2)
+NOT_HERE_UNTIL_AFTER_4_3(__eqsf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__extendsfdf2)
+NOT_HERE_UNTIL_AFTER_4_3(__extendsfdf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__ffsdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__fixdfdi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixdfsi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixdfsivfp)
+NOT_HERE_UNTIL_AFTER_4_3(__fixsfdi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixsfsi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixsfsivfp)
+NOT_HERE_UNTIL_AFTER_4_3(__fixunsdfdi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixunsdfsi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixunsdfsivfp)
+NOT_HERE_UNTIL_AFTER_4_3(__fixunssfdi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixunssfsi)
+NOT_HERE_UNTIL_AFTER_4_3(__fixunssfsivfp)
+NOT_HERE_UNTIL_AFTER_4_3(__floatdidf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatdisf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatsidf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatsidfvfp)
+NOT_HERE_UNTIL_AFTER_4_3(__floatsisf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatsisfvfp)
+NOT_HERE_UNTIL_AFTER_4_3(__floatundidf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatundisf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatunsidf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatunsisf)
+NOT_HERE_UNTIL_AFTER_4_3(__floatunssidfvfp)
+NOT_HERE_UNTIL_AFTER_4_3(__floatunssisfvfp)
+NOT_HERE_UNTIL_AFTER_4_3(__gedf2)
+NOT_HERE_UNTIL_AFTER_4_3(__gedf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__gesf2)
+NOT_HERE_UNTIL_AFTER_4_3(__gesf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__gtdf2)
+NOT_HERE_UNTIL_AFTER_4_3(__gtdf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__gtsf2)
+NOT_HERE_UNTIL_AFTER_4_3(__gtsf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__ledf2)
+NOT_HERE_UNTIL_AFTER_4_3(__ledf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__lesf2)
+NOT_HERE_UNTIL_AFTER_4_3(__lesf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__lshrdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__ltdf2)
+NOT_HERE_UNTIL_AFTER_4_3(__ltdf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__ltsf2)
+NOT_HERE_UNTIL_AFTER_4_3(__ltsf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__moddi3)
+NOT_HERE_UNTIL_AFTER_4_3(__modsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__muldc3)
+NOT_HERE_UNTIL_AFTER_4_3(__muldf3)
+NOT_HERE_UNTIL_AFTER_4_3(__muldf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__muldi3)
+NOT_HERE_UNTIL_AFTER_4_3(__mulsc3)
+NOT_HERE_UNTIL_AFTER_4_3(__mulsf3)
+NOT_HERE_UNTIL_AFTER_4_3(__mulsf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__mulvdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__mulvsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__nedf2)
+NOT_HERE_UNTIL_AFTER_4_3(__nedf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__negdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__negvdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__negvsi2)
+NOT_HERE_UNTIL_AFTER_4_3(__nesf2)
+NOT_HERE_UNTIL_AFTER_4_3(__nesf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__paritydi2)
+NOT_HERE_UNTIL_AFTER_4_3(__paritysi2)
+NOT_HERE_UNTIL_AFTER_4_3(__popcountdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__popcountsi2)
+NOT_HERE_UNTIL_AFTER_4_3(__powidf2)
+NOT_HERE_UNTIL_AFTER_4_3(__powisf2)
+NOT_HERE_UNTIL_AFTER_4_3(__subdf3)
+NOT_HERE_UNTIL_AFTER_4_3(__subdf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__subsf3)
+NOT_HERE_UNTIL_AFTER_4_3(__subsf3vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__subvdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__subvsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__truncdfsf2)
+NOT_HERE_UNTIL_AFTER_4_3(__truncdfsf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__ucmpdi2)
+NOT_HERE_UNTIL_AFTER_4_3(__udivdi3)
+NOT_HERE_UNTIL_AFTER_4_3(__udivmoddi4)
+NOT_HERE_UNTIL_AFTER_4_3(__udivsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__umoddi3)
+NOT_HERE_UNTIL_AFTER_4_3(__umodsi3)
+NOT_HERE_UNTIL_AFTER_4_3(__unorddf2)
+NOT_HERE_UNTIL_AFTER_4_3(__unorddf2vfp)
+NOT_HERE_UNTIL_AFTER_4_3(__unordsf2)
+NOT_HERE_UNTIL_AFTER_4_3(__unordsf2vfp)
+
+NOT_HERE_UNTIL_AFTER_4_3(__divmodsi4)
+NOT_HERE_UNTIL_AFTER_4_3(__udivmodsi4)
+#endif // __arm__ && __DYNAMIC__
+
+       
+       
+
+
+#else /* !__APPLE__ */
+
+extern int avoid_empty_file;
+
+#endif /* !__APPLE__*/
diff --git a/compiler-rt/lib/builtins/arm/Makefile.mk b/compiler-rt/lib/builtins/arm/Makefile.mk
new file mode 100644
index 0000000..ed2e832
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/Makefile.mk
@@ -0,0 +1,20 @@
+#===- lib/builtins/arm/Makefile.mk -------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs := 
+OnlyArchs := armv5 armv6 armv7 armv7k armv7m armv7em armv7s
+
+AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
+Implementation := Optimized
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard lib/*.h $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/arm/adddf3vfp.S b/compiler-rt/lib/builtins/arm/adddf3vfp.S
new file mode 100644
index 0000000..2825ae9
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/adddf3vfp.S
@@ -0,0 +1,26 @@
+//===-- adddf3vfp.S - Implement adddf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// double __adddf3vfp(double a, double b) { return a + b; }
+//
+// Adds two double precision floating point numbers using the Darwin
+// calling convention where double arguments are passsed in GPR pairs
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__adddf3vfp)
+	vmov	d6, r0, r1		// move first param from r0/r1 pair into d6
+	vmov	d7, r2, r3		// move second param from r2/r3 pair into d7
+	vadd.f64 d6, d6, d7		
+	vmov	r0, r1, d6		// move result back to r0/r1 pair
+	bx	lr
+END_COMPILERRT_FUNCTION(__adddf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/addsf3vfp.S b/compiler-rt/lib/builtins/arm/addsf3vfp.S
new file mode 100644
index 0000000..bff5a7e
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/addsf3vfp.S
@@ -0,0 +1,26 @@
+//===-- addsf3vfp.S - Implement addsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __addsf3vfp(float a, float b);
+//
+// Adds two single precision floating point numbers using the Darwin
+// calling convention where single arguments are passsed in GPRs
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__addsf3vfp)
+	vmov	s14, r0		// move first param from r0 into float register
+	vmov	s15, r1		// move second param from r1 into float register
+	vadd.f32 s14, s14, s15
+	vmov	r0, s14		// move result back to r0
+	bx	lr
+END_COMPILERRT_FUNCTION(__addsf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_cdcmp.S b/compiler-rt/lib/builtins/arm/aeabi_cdcmp.S
new file mode 100644
index 0000000..036a6f5
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_cdcmp.S
@@ -0,0 +1,96 @@
+//===-- aeabi_cdcmp.S - EABI cdcmp* implementation ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+#error big endian support not implemented
+#endif
+
+#define APSR_Z (1 << 30)
+#define APSR_C (1 << 29)
+
+// void __aeabi_cdcmpeq(double a, double b) {
+//   if (isnan(a) || isnan(b)) {
+//     Z = 0; C = 1;
+//   } else {
+//     __aeabi_cdcmple(a, b);
+//   }
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_cdcmpeq)
+        push {r0-r3, lr}
+        bl __aeabi_cdcmpeq_check_nan
+        cmp r0, #1
+        pop {r0-r3, lr}
+
+        // NaN has been ruled out, so __aeabi_cdcmple can't trap
+        bne __aeabi_cdcmple
+
+        msr CPSR_f, #APSR_C
+        JMP(lr)
+END_COMPILERRT_FUNCTION(__aeabi_cdcmpeq)
+
+
+// void __aeabi_cdcmple(double a, double b) {
+//   if (__aeabi_dcmplt(a, b)) {
+//     Z = 0; C = 0;
+//   } else if (__aeabi_dcmpeq(a, b)) {
+//     Z = 1; C = 1;
+//   } else {
+//     Z = 0; C = 1;
+//   }
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_cdcmple)
+        // Per the RTABI, this function must preserve r0-r11.
+        // Save lr in the same instruction for compactness
+        push {r0-r3, lr}
+
+        bl __aeabi_dcmplt
+        cmp r0, #1
+        moveq ip, #0
+        beq 1f
+
+        ldm sp, {r0-r3}
+        bl __aeabi_dcmpeq
+        cmp r0, #1
+        moveq ip, #(APSR_C | APSR_Z)
+        movne ip, #(APSR_C)
+
+1:
+        msr CPSR_f, ip
+        pop {r0-r3}
+        POP_PC()
+END_COMPILERRT_FUNCTION(__aeabi_cdcmple)
+
+// int __aeabi_cdrcmple(double a, double b) {
+//   return __aeabi_cdcmple(b, a);
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_cdrcmple)
+        // Swap r0 and r2
+        mov ip, r0
+        mov r0, r2
+        mov r2, ip
+
+        // Swap r1 and r3
+        mov ip, r1
+        mov r1, r3
+        mov r3, ip
+
+        b __aeabi_cdcmple
+END_COMPILERRT_FUNCTION(__aeabi_cdrcmple)
+
diff --git a/compiler-rt/lib/builtins/arm/aeabi_cdcmpeq_check_nan.c b/compiler-rt/lib/builtins/arm/aeabi_cdcmpeq_check_nan.c
new file mode 100644
index 0000000..577f6b2
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_cdcmpeq_check_nan.c
@@ -0,0 +1,16 @@
+//===-- lib/arm/aeabi_cdcmpeq_helper.c - Helper for cdcmpeq ---------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+
+__attribute__((pcs("aapcs")))
+__attribute__((visibility("hidden")))
+int __aeabi_cdcmpeq_check_nan(double a, double b) {
+    return __builtin_isnan(a) || __builtin_isnan(b);
+}
diff --git a/compiler-rt/lib/builtins/arm/aeabi_cfcmp.S b/compiler-rt/lib/builtins/arm/aeabi_cfcmp.S
new file mode 100644
index 0000000..43594e5
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_cfcmp.S
@@ -0,0 +1,91 @@
+//===-- aeabi_cfcmp.S - EABI cfcmp* implementation ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+#error big endian support not implemented
+#endif
+
+#define APSR_Z (1 << 30)
+#define APSR_C (1 << 29)
+
+// void __aeabi_cfcmpeq(float a, float b) {
+//   if (isnan(a) || isnan(b)) {
+//     Z = 0; C = 1;
+//   } else {
+//     __aeabi_cfcmple(a, b);
+//   }
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_cfcmpeq)
+        push {r0-r3, lr}
+        bl __aeabi_cfcmpeq_check_nan
+        cmp r0, #1
+        pop {r0-r3, lr}
+
+        // NaN has been ruled out, so __aeabi_cfcmple can't trap
+        bne __aeabi_cfcmple
+
+        msr CPSR_f, #APSR_C
+        JMP(lr)
+END_COMPILERRT_FUNCTION(__aeabi_cfcmpeq)
+
+
+// void __aeabi_cfcmple(float a, float b) {
+//   if (__aeabi_fcmplt(a, b)) {
+//     Z = 0; C = 0;
+//   } else if (__aeabi_fcmpeq(a, b)) {
+//     Z = 1; C = 1;
+//   } else {
+//     Z = 0; C = 1;
+//   }
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_cfcmple)
+        // Per the RTABI, this function must preserve r0-r11.
+        // Save lr in the same instruction for compactness
+        push {r0-r3, lr}
+
+        bl __aeabi_fcmplt
+        cmp r0, #1
+        moveq ip, #0
+        beq 1f
+
+        ldm sp, {r0-r3}
+        bl __aeabi_fcmpeq
+        cmp r0, #1
+        moveq ip, #(APSR_C | APSR_Z)
+        movne ip, #(APSR_C)
+
+1:
+        msr CPSR_f, ip
+        pop {r0-r3}
+        POP_PC()
+END_COMPILERRT_FUNCTION(__aeabi_cfcmple)
+
+// int __aeabi_cfrcmple(float a, float b) {
+//   return __aeabi_cfcmple(b, a);
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_cfrcmple)
+        // Swap r0 and r1
+        mov ip, r0
+        mov r0, r1
+        mov r1, ip
+
+        b __aeabi_cfcmple
+END_COMPILERRT_FUNCTION(__aeabi_cfrcmple)
+
diff --git a/compiler-rt/lib/builtins/arm/aeabi_cfcmpeq_check_nan.c b/compiler-rt/lib/builtins/arm/aeabi_cfcmpeq_check_nan.c
new file mode 100644
index 0000000..992e31f
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_cfcmpeq_check_nan.c
@@ -0,0 +1,16 @@
+//===-- lib/arm/aeabi_cfcmpeq_helper.c - Helper for cdcmpeq ---------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+
+__attribute__((pcs("aapcs")))
+__attribute__((visibility("hidden")))
+int __aeabi_cfcmpeq_check_nan(float a, float b) {
+    return __builtin_isnan(a) || __builtin_isnan(b);
+}
diff --git a/compiler-rt/lib/builtins/arm/aeabi_dcmp.S b/compiler-rt/lib/builtins/arm/aeabi_dcmp.S
new file mode 100644
index 0000000..310c35b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_dcmp.S
@@ -0,0 +1,40 @@
+//===-- aeabi_dcmp.S - EABI dcmp* implementation ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// int __aeabi_dcmp{eq,lt,le,ge,gt}(double a, double b) {
+//   int result = __{eq,lt,le,ge,gt}df2(a, b);
+//   if (result {==,<,<=,>=,>} 0) {
+//     return 1;
+//   } else {
+//     return 0;
+//   }
+// }
+
+#define DEFINE_AEABI_DCMP(cond)                            \
+        .syntax unified                          SEPARATOR \
+        .p2align 2                               SEPARATOR \
+DEFINE_COMPILERRT_FUNCTION(__aeabi_dcmp ## cond)           \
+        push      { r4, lr }                     SEPARATOR \
+        bl        SYMBOL_NAME(__ ## cond ## df2) SEPARATOR \
+        cmp       r0, #0                         SEPARATOR \
+        b ## cond 1f                             SEPARATOR \
+        mov       r0, #0                         SEPARATOR \
+        pop       { r4, pc }                     SEPARATOR \
+1:                                               SEPARATOR \
+        mov       r0, #1                         SEPARATOR \
+        pop       { r4, pc }                     SEPARATOR \
+END_COMPILERRT_FUNCTION(__aeabi_dcmp ## cond)
+
+DEFINE_AEABI_DCMP(eq)
+DEFINE_AEABI_DCMP(lt)
+DEFINE_AEABI_DCMP(le)
+DEFINE_AEABI_DCMP(ge)
+DEFINE_AEABI_DCMP(gt)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_div0.c b/compiler-rt/lib/builtins/arm/aeabi_div0.c
new file mode 100644
index 0000000..ccc95fa
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_div0.c
@@ -0,0 +1,43 @@
+/* ===-- aeabi_div0.c - ARM Runtime ABI support routines for compiler-rt ---===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements the division by zero helper routines as specified by the
+ * Run-time ABI for the ARM Architecture.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+/*
+ * RTABI 4.3.2 - Division by zero
+ *
+ * The *div0 functions:
+ * - Return the value passed to them as a parameter
+ * - Or, return a fixed value defined by the execution environment (such as 0)
+ * - Or, raise a signal (often SIGFPE) or throw an exception, and do not return
+ *
+ * An application may provide its own implementations of the *div0 functions to
+ * for a particular behaviour from the *div and *divmod functions called out of
+ * line.
+ */
+
+/* provide an unused declaration to pacify pendantic compilation */
+extern unsigned char declaration;
+
+#if defined(__ARM_EABI__)
+int __attribute__((weak)) __attribute__((visibility("hidden")))
+__aeabi_idiv0(int return_value) {
+  return return_value;
+}
+
+long long __attribute__((weak)) __attribute__((visibility("hidden")))
+__aeabi_ldiv0(long long return_value) {
+  return return_value;
+}
+#endif
+
diff --git a/compiler-rt/lib/builtins/arm/aeabi_drsub.c b/compiler-rt/lib/builtins/arm/aeabi_drsub.c
new file mode 100644
index 0000000..fc17d5a
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_drsub.c
@@ -0,0 +1,19 @@
+//===-- lib/arm/aeabi_drsub.c - Double-precision subtraction --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "../fp_lib.h"
+
+COMPILER_RT_ABI fp_t
+__aeabi_dsub(fp_t, fp_t);
+
+COMPILER_RT_ABI fp_t
+__aeabi_drsub(fp_t a, fp_t b) {
+    return __aeabi_dsub(b, a);
+}
diff --git a/compiler-rt/lib/builtins/arm/aeabi_fcmp.S b/compiler-rt/lib/builtins/arm/aeabi_fcmp.S
new file mode 100644
index 0000000..55f49a2
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_fcmp.S
@@ -0,0 +1,40 @@
+//===-- aeabi_fcmp.S - EABI fcmp* implementation ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// int __aeabi_fcmp{eq,lt,le,ge,gt}(float a, float b) {
+//   int result = __{eq,lt,le,ge,gt}sf2(a, b);
+//   if (result {==,<,<=,>=,>} 0) {
+//     return 1;
+//   } else {
+//     return 0;
+//   }
+// }
+
+#define DEFINE_AEABI_FCMP(cond)                            \
+        .syntax unified                          SEPARATOR \
+        .p2align 2                               SEPARATOR \
+DEFINE_COMPILERRT_FUNCTION(__aeabi_fcmp ## cond)           \
+        push      { r4, lr }                     SEPARATOR \
+        bl        SYMBOL_NAME(__ ## cond ## sf2) SEPARATOR \
+        cmp       r0, #0                         SEPARATOR \
+        b ## cond 1f                             SEPARATOR \
+        mov       r0, #0                         SEPARATOR \
+        pop       { r4, pc }                     SEPARATOR \
+1:                                               SEPARATOR \
+        mov       r0, #1                         SEPARATOR \
+        pop       { r4, pc }                     SEPARATOR \
+END_COMPILERRT_FUNCTION(__aeabi_fcmp ## cond)
+
+DEFINE_AEABI_FCMP(eq)
+DEFINE_AEABI_FCMP(lt)
+DEFINE_AEABI_FCMP(le)
+DEFINE_AEABI_FCMP(ge)
+DEFINE_AEABI_FCMP(gt)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_frsub.c b/compiler-rt/lib/builtins/arm/aeabi_frsub.c
new file mode 100644
index 0000000..64258dc
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_frsub.c
@@ -0,0 +1,19 @@
+//===-- lib/arm/aeabi_frsub.c - Single-precision subtraction --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "../fp_lib.h"
+
+COMPILER_RT_ABI fp_t
+__aeabi_fsub(fp_t, fp_t);
+
+COMPILER_RT_ABI fp_t
+__aeabi_frsub(fp_t a, fp_t b) {
+    return __aeabi_fsub(b, a);
+}
diff --git a/compiler-rt/lib/builtins/arm/aeabi_idivmod.S b/compiler-rt/lib/builtins/arm/aeabi_idivmod.S
new file mode 100644
index 0000000..384add3
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_idivmod.S
@@ -0,0 +1,28 @@
+//===-- aeabi_idivmod.S - EABI idivmod implementation ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// struct { int quot, int rem} __aeabi_idivmod(int numerator, int denominator) {
+//   int rem, quot;
+//   quot = __divmodsi4(numerator, denominator, &rem);
+//   return {quot, rem};
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_idivmod)
+        push    { lr }
+        sub     sp, sp, #4
+        mov     r2, sp
+        bl      SYMBOL_NAME(__divmodsi4)
+        ldr     r1, [sp]
+        add     sp, sp, #4
+        pop     { pc }
+END_COMPILERRT_FUNCTION(__aeabi_idivmod)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_ldivmod.S b/compiler-rt/lib/builtins/arm/aeabi_ldivmod.S
new file mode 100644
index 0000000..ad06f1d
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_ldivmod.S
@@ -0,0 +1,31 @@
+//===-- aeabi_ldivmod.S - EABI ldivmod implementation ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// struct { int64_t quot, int64_t rem}
+//        __aeabi_ldivmod(int64_t numerator, int64_t denominator) {
+//   int64_t rem, quot;
+//   quot = __divmoddi4(numerator, denominator, &rem);
+//   return {quot, rem};
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_ldivmod)
+        push    {r11, lr}
+        sub     sp, sp, #16
+        add     r12, sp, #8
+        str     r12, [sp]
+        bl      SYMBOL_NAME(__divmoddi4)
+        ldr     r2, [sp, #8]
+        ldr     r3, [sp, #12]
+        add     sp, sp, #16
+        pop     {r11, pc}
+END_COMPILERRT_FUNCTION(__aeabi_ldivmod)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_memcmp.S b/compiler-rt/lib/builtins/arm/aeabi_memcmp.S
new file mode 100644
index 0000000..051ce43
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_memcmp.S
@@ -0,0 +1,20 @@
+//===-- aeabi_memcmp.S - EABI memcmp implementation -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//  void __aeabi_memcmp(void *dest, void *src, size_t n) { memcmp(dest, src, n); }
+
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_memcmp)
+        b       memcmp
+END_COMPILERRT_FUNCTION(__aeabi_memcmp)
+
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memcmp4, __aeabi_memcmp)
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memcmp8, __aeabi_memcmp)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_memcpy.S b/compiler-rt/lib/builtins/arm/aeabi_memcpy.S
new file mode 100644
index 0000000..cf02332
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_memcpy.S
@@ -0,0 +1,20 @@
+//===-- aeabi_memcpy.S - EABI memcpy implementation -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//  void __aeabi_memcpy(void *dest, void *src, size_t n) { memcpy(dest, src, n); }
+
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_memcpy)
+        b       memcpy
+END_COMPILERRT_FUNCTION(__aeabi_memcpy)
+
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memcpy4, __aeabi_memcpy)
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memcpy8, __aeabi_memcpy)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_memmove.S b/compiler-rt/lib/builtins/arm/aeabi_memmove.S
new file mode 100644
index 0000000..4dda06f
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_memmove.S
@@ -0,0 +1,20 @@
+//===-- aeabi_memmove.S - EABI memmove implementation --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===---------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//  void __aeabi_memmove(void *dest, void *src, size_t n) { memmove(dest, src, n); }
+
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_memmove)
+        b       memmove
+END_COMPILERRT_FUNCTION(__aeabi_memmove)
+
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memmove4, __aeabi_memmove)
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memmove8, __aeabi_memmove)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_memset.S b/compiler-rt/lib/builtins/arm/aeabi_memset.S
new file mode 100644
index 0000000..c8b49c7
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_memset.S
@@ -0,0 +1,34 @@
+//===-- aeabi_memset.S - EABI memset implementation -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//  void __aeabi_memset(void *dest, size_t n, int c) { memset(dest, c, n); }
+//  void __aeabi_memclr(void *dest, size_t n) { __aeabi_memset(dest, n, 0); }
+
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_memset)
+        mov     r3, r1
+        mov     r1, r2
+        mov     r2, r3
+        b       memset
+END_COMPILERRT_FUNCTION(__aeabi_memset)
+
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memset4, __aeabi_memset)
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memset8, __aeabi_memset)
+
+DEFINE_COMPILERRT_FUNCTION(__aeabi_memclr)
+        mov     r2, r1
+        mov     r1, #0
+        b       memset
+END_COMPILERRT_FUNCTION(__aeabi_memclr)
+
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memclr4, __aeabi_memclr)
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_memclr8, __aeabi_memclr)
+
diff --git a/compiler-rt/lib/builtins/arm/aeabi_uidivmod.S b/compiler-rt/lib/builtins/arm/aeabi_uidivmod.S
new file mode 100644
index 0000000..8ea474d
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_uidivmod.S
@@ -0,0 +1,29 @@
+//===-- aeabi_uidivmod.S - EABI uidivmod implementation -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// struct { unsigned quot, unsigned rem}
+//        __aeabi_uidivmod(unsigned numerator, unsigned denominator) {
+//   unsigned rem, quot;
+//   quot = __udivmodsi4(numerator, denominator, &rem);
+//   return {quot, rem};
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_uidivmod)
+        push    { lr }
+        sub     sp, sp, #4
+        mov     r2, sp
+        bl      SYMBOL_NAME(__udivmodsi4)
+        ldr     r1, [sp]
+        add     sp, sp, #4
+        pop     { pc }
+END_COMPILERRT_FUNCTION(__aeabi_uidivmod)
diff --git a/compiler-rt/lib/builtins/arm/aeabi_uldivmod.S b/compiler-rt/lib/builtins/arm/aeabi_uldivmod.S
new file mode 100644
index 0000000..4e1f8e2
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/aeabi_uldivmod.S
@@ -0,0 +1,31 @@
+//===-- aeabi_uldivmod.S - EABI uldivmod implementation -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// struct { uint64_t quot, uint64_t rem}
+//        __aeabi_uldivmod(uint64_t numerator, uint64_t denominator) {
+//   uint64_t rem, quot;
+//   quot = __udivmoddi4(numerator, denominator, &rem);
+//   return {quot, rem};
+// }
+
+        .syntax unified
+        .p2align 2
+DEFINE_COMPILERRT_FUNCTION(__aeabi_uldivmod)
+        push	{r11, lr}
+        sub	sp, sp, #16
+        add	r12, sp, #8
+        str	r12, [sp]
+        bl	SYMBOL_NAME(__udivmoddi4)
+        ldr	r2, [sp, #8]
+        ldr	r3, [sp, #12]
+        add	sp, sp, #16
+        pop	{r11, pc}
+END_COMPILERRT_FUNCTION(__aeabi_uldivmod)
diff --git a/compiler-rt/lib/builtins/arm/bswapdi2.S b/compiler-rt/lib/builtins/arm/bswapdi2.S
new file mode 100644
index 0000000..86f3bba
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/bswapdi2.S
@@ -0,0 +1,47 @@
+//===------- bswapdi2 - Implement bswapdi2 --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+//
+// extern uint64_t __bswapdi2(uint64_t);
+//
+// Reverse all the bytes in a 64-bit integer.
+//
+	.p2align 2
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__bswapdi2)
+#else
+DEFINE_COMPILERRT_FUNCTION(__bswapdi2)
+#endif
+#if __ARM_ARCH < 6
+    // before armv6 does not have "rev" instruction
+    // r2 = rev(r0)
+    eor r2, r0, r0, ror #16
+    bic r2, r2, #0xff0000
+    mov r2, r2, lsr #8
+    eor r2, r2, r0, ror #8
+    // r0 = rev(r1)
+    eor r0, r1, r1, ror #16
+    bic r0, r0, #0xff0000
+    mov r0, r0, lsr #8
+    eor r0, r0, r1, ror #8
+#else
+    rev r2, r0  // r2 = rev(r0)
+    rev r0, r1  // r0 = rev(r1)
+#endif
+    mov r1, r2  // r1 = r2 = rev(r0)
+    JMP(lr)
+END_COMPILERRT_FUNCTION(__bswapdi2)
diff --git a/compiler-rt/lib/builtins/arm/bswapsi2.S b/compiler-rt/lib/builtins/arm/bswapsi2.S
new file mode 100644
index 0000000..59ba815
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/bswapsi2.S
@@ -0,0 +1,39 @@
+//===------- bswapsi2 - Implement bswapsi2 --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+//
+// extern uint32_t __bswapsi2(uint32_t);
+//
+// Reverse all the bytes in a 32-bit integer.
+//
+	.p2align 2
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__bswapsi2)
+#else
+DEFINE_COMPILERRT_FUNCTION(__bswapsi2)
+#endif
+#if __ARM_ARCH < 6
+    // before armv6 does not have "rev" instruction
+ 	eor	r1, r0, r0, ror #16
+ 	bic	r1, r1, #0xff0000
+ 	mov	r1, r1, lsr #8
+ 	eor	r0, r1, r0, ror #8
+#else
+    rev r0, r0
+#endif
+    JMP(lr)
+END_COMPILERRT_FUNCTION(__bswapsi2)
diff --git a/compiler-rt/lib/builtins/arm/clzdi2.S b/compiler-rt/lib/builtins/arm/clzdi2.S
new file mode 100644
index 0000000..a55abac
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/clzdi2.S
@@ -0,0 +1,97 @@
+/* ===-- clzdi2.c - Implement __clzdi2 -------------------------------------===
+ *
+ *               The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements count leading zeros for 64bit arguments.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+
+	.p2align	2
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__clzdi2)
+#else
+DEFINE_COMPILERRT_FUNCTION(__clzdi2)
+#endif
+#ifdef __ARM_FEATURE_CLZ
+#ifdef __ARMEB__
+	cmp	r0, 0
+	itee ne
+	clzne	r0, r0
+	clzeq	r0, r1
+	addeq	r0, r0, 32
+#else
+	cmp	r1, 0
+	itee ne
+	clzne	r0, r1
+	clzeq	r0, r0
+	addeq	r0, r0, 32
+#endif
+	JMP(lr)
+#else
+	/* Assumption: n != 0 */
+
+	/*
+	 * r0: n
+	 * r1: upper half of n, overwritten after check
+	 * r1: count of leading zeros in n + 1
+	 * r2: scratch register for shifted r0
+	 */
+#ifdef __ARMEB__
+	cmp	r0, 0
+	moveq	r0, r1
+#else
+	cmp	r1, 0
+	movne	r0, r1
+#endif
+	movne	r1, 1
+	moveq	r1, 33
+
+	/*
+	 * Basic block:
+	 * if ((r0 >> SHIFT) == 0)
+	 *   r1 += SHIFT;
+	 * else
+	 *   r0 >>= SHIFT;
+	 * for descending powers of two as SHIFT.
+	 */
+#define BLOCK(shift) \
+	lsrs	r2, r0, shift; \
+	movne	r0, r2; \
+	addeq	r1, shift \
+
+	BLOCK(16)
+	BLOCK(8)
+	BLOCK(4)
+	BLOCK(2)
+
+	/*
+	 * The basic block invariants at this point are (r0 >> 2) == 0 and
+	 * r0 != 0. This means 1 <= r0 <= 3 and 0 <= (r0 >> 1) <= 1.
+	 *
+	 * r0 | (r0 >> 1) == 0 | (r0 >> 1) == 1 | -(r0 >> 1) | 1 - (r0 >> 1)
+	 * ---+----------------+----------------+------------+--------------
+	 * 1  | 1              | 0              | 0          | 1
+	 * 2  | 0              | 1              | -1         | 0
+	 * 3  | 0              | 1              | -1         | 0
+	 *
+	 * The r1's initial value of 1 compensates for the 1 here.
+	 */
+	sub	r0, r1, r0, lsr #1
+
+	JMP(lr)
+#endif // __ARM_FEATURE_CLZ
+END_COMPILERRT_FUNCTION(__clzdi2)
diff --git a/compiler-rt/lib/builtins/arm/clzsi2.S b/compiler-rt/lib/builtins/arm/clzsi2.S
new file mode 100644
index 0000000..1cd379b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/clzsi2.S
@@ -0,0 +1,76 @@
+/* ===-- clzsi2.c - Implement __clzsi2 -------------------------------------===
+ *
+ *               The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements count leading zeros for 32bit arguments.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+	.p2align	2
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__clzsi2)
+#else
+DEFINE_COMPILERRT_FUNCTION(__clzsi2)
+#endif
+#ifdef __ARM_FEATURE_CLZ
+	clz	r0, r0
+	JMP(lr)
+#else
+	/* Assumption: n != 0 */
+
+	/*
+	 * r0: n
+	 * r1: count of leading zeros in n + 1
+	 * r2: scratch register for shifted r0
+	 */
+	mov	r1, 1
+
+	/*
+	 * Basic block:
+	 * if ((r0 >> SHIFT) == 0)
+	 *   r1 += SHIFT;
+	 * else
+	 *   r0 >>= SHIFT;
+	 * for descending powers of two as SHIFT.
+	 */
+
+#define BLOCK(shift) \
+	lsrs	r2, r0, shift; \
+	movne	r0, r2; \
+	addeq	r1, shift \
+
+	BLOCK(16)
+	BLOCK(8)
+	BLOCK(4)
+	BLOCK(2)
+
+	/*
+	 * The basic block invariants at this point are (r0 >> 2) == 0 and
+	 * r0 != 0. This means 1 <= r0 <= 3 and 0 <= (r0 >> 1) <= 1.
+	 *
+	 * r0 | (r0 >> 1) == 0 | (r0 >> 1) == 1 | -(r0 >> 1) | 1 - (r0 >> 1)
+	 * ---+----------------+----------------+------------+--------------
+	 * 1  | 1              | 0              | 0          | 1
+	 * 2  | 0              | 1              | -1         | 0
+	 * 3  | 0              | 1              | -1         | 0
+	 *
+	 * The r1's initial value of 1 compensates for the 1 here.
+	 */
+	sub	r0, r1, r0, lsr #1
+
+	JMP(lr)
+#endif // __ARM_FEATURE_CLZ
+END_COMPILERRT_FUNCTION(__clzsi2)
diff --git a/compiler-rt/lib/builtins/arm/comparesf2.S b/compiler-rt/lib/builtins/arm/comparesf2.S
new file mode 100644
index 0000000..cf71d36
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/comparesf2.S
@@ -0,0 +1,148 @@
+//===-- comparesf2.S - Implement single-precision soft-float comparisons --===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the following soft-fp_t comparison routines:
+//
+//   __eqsf2   __gesf2   __unordsf2
+//   __lesf2   __gtsf2
+//   __ltsf2
+//   __nesf2
+//
+// The semantics of the routines grouped in each column are identical, so there
+// is a single implementation for each, with multiple names.
+//
+// The routines behave as follows:
+//
+//   __lesf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                         1 if either a or b is NaN
+//
+//   __gesf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                        -1 if either a or b is NaN
+//
+//   __unordsf2(a,b) returns 0 if both a and b are numbers
+//                           1 if either a or b is NaN
+//
+// Note that __lesf2( ) and __gesf2( ) are identical except in their handling of
+// NaN values.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+.syntax unified
+
+.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__eqsf2)
+    // Make copies of a and b with the sign bit shifted off the top.  These will
+    // be used to detect zeros and NaNs.
+    mov     r2,         r0, lsl #1
+    mov     r3,         r1, lsl #1
+
+    // We do the comparison in three stages (ignoring NaN values for the time
+    // being).  First, we orr the absolute values of a and b; this sets the Z
+    // flag if both a and b are zero (of either sign).  The shift of r3 doesn't
+    // effect this at all, but it *does* make sure that the C flag is clear for
+    // the subsequent operations.
+    orrs    r12,    r2, r3, lsr #1
+
+    // Next, we check if a and b have the same or different signs.  If they have
+    // opposite signs, this eor will set the N flag.
+    it ne
+    eorsne  r12,    r0, r1
+
+    // If a and b are equal (either both zeros or bit identical; again, we're
+    // ignoring NaNs for now), this subtract will zero out r0.  If they have the
+    // same sign, the flags are updated as they would be for a comparison of the
+    // absolute values of a and b.
+    it pl
+    subspl  r0,     r2, r3
+
+    // If a is smaller in magnitude than b and both have the same sign, place
+    // the negation of the sign of b in r0.  Thus, if both are negative and
+    // a > b, this sets r0 to 0; if both are positive and a < b, this sets
+    // r0 to -1.
+    //
+    // This is also done if a and b have opposite signs and are not both zero,
+    // because in that case the subtract was not performed and the C flag is
+    // still clear from the shift argument in orrs; if a is positive and b
+    // negative, this places 0 in r0; if a is negative and b positive, -1 is
+    // placed in r0.
+    it lo
+    mvnlo   r0,         r1, asr #31
+
+    // If a is greater in magnitude than b and both have the same sign, place
+    // the sign of b in r0.  Thus, if both are negative and a < b, -1 is placed
+    // in r0, which is the desired result.  Conversely, if both are positive
+    // and a > b, zero is placed in r0.
+    it hi
+    movhi   r0,         r1, asr #31
+
+    // If you've been keeping track, at this point r0 contains -1 if a < b and
+    // 0 if a >= b.  All that remains to be done is to set it to 1 if a > b.
+    // If a == b, then the Z flag is set, so we can get the correct final value
+    // into r0 by simply or'ing with 1 if Z is clear.
+    it ne
+    orrne   r0,     r0, #1
+
+    // Finally, we need to deal with NaNs.  If either argument is NaN, replace
+    // the value in r0 with 1.
+    cmp     r2,         #0xff000000
+    ite ls
+    cmpls   r3,         #0xff000000
+    movhi   r0,         #1
+    JMP(lr)
+END_COMPILERRT_FUNCTION(__eqsf2)
+DEFINE_COMPILERRT_FUNCTION_ALIAS(__lesf2, __eqsf2)
+DEFINE_COMPILERRT_FUNCTION_ALIAS(__ltsf2, __eqsf2)
+DEFINE_COMPILERRT_FUNCTION_ALIAS(__nesf2, __eqsf2)
+
+.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__gtsf2)
+    // Identical to the preceding except in that we return -1 for NaN values.
+    // Given that the two paths share so much code, one might be tempted to 
+    // unify them; however, the extra code needed to do so makes the code size
+    // to performance tradeoff very hard to justify for such small functions.
+    mov     r2,         r0, lsl #1
+    mov     r3,         r1, lsl #1
+    orrs    r12,    r2, r3, lsr #1
+    it ne
+    eorsne  r12,    r0, r1
+    it pl
+    subspl  r0,     r2, r3
+    it lo
+    mvnlo   r0,         r1, asr #31
+    it hi
+    movhi   r0,         r1, asr #31
+    it ne
+    orrne   r0,     r0, #1
+    cmp     r2,         #0xff000000
+    ite ls
+    cmpls   r3,         #0xff000000
+    movhi   r0,         #-1
+    JMP(lr)
+END_COMPILERRT_FUNCTION(__gtsf2)
+DEFINE_COMPILERRT_FUNCTION_ALIAS(__gesf2, __gtsf2)
+
+.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__unordsf2)
+    // Return 1 for NaN values, 0 otherwise.
+    mov     r2,         r0, lsl #1
+    mov     r3,         r1, lsl #1
+    mov     r0,         #0
+    cmp     r2,         #0xff000000
+    ite ls
+    cmpls   r3,         #0xff000000
+    movhi   r0,         #1
+    JMP(lr)
+END_COMPILERRT_FUNCTION(__unordsf2)
+
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_fcmpun, __unordsf2)
diff --git a/compiler-rt/lib/builtins/arm/divdf3vfp.S b/compiler-rt/lib/builtins/arm/divdf3vfp.S
new file mode 100644
index 0000000..6eebef1
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/divdf3vfp.S
@@ -0,0 +1,26 @@
+//===-- divdf3vfp.S - Implement divdf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __divdf3vfp(double a, double b);
+//
+// Divides two double precision floating point numbers using the Darwin
+// calling convention where double arguments are passsed in GPR pairs
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__divdf3vfp)
+	vmov	d6, r0, r1		// move first param from r0/r1 pair into d6
+	vmov	d7, r2, r3		// move second param from r2/r3 pair into d7
+	vdiv.f64 d5, d6, d7		
+	vmov	r0, r1, d5		// move result back to r0/r1 pair
+	bx	lr
+END_COMPILERRT_FUNCTION(__divdf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/divmodsi4.S b/compiler-rt/lib/builtins/arm/divmodsi4.S
new file mode 100644
index 0000000..646b9ab
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/divmodsi4.S
@@ -0,0 +1,74 @@
+/*===-- divmodsi4.S - 32-bit signed integer divide and modulus ------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __divmodsi4 (32-bit signed integer divide and
+ * modulus) function for the ARM architecture.  A naive digit-by-digit
+ * computation is employed for simplicity.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+#define ESTABLISH_FRAME    \
+    push   {r4-r7, lr}   ;\
+    add     r7,     sp, #12
+#define CLEAR_FRAME_AND_RETURN \
+    pop    {r4-r7, pc}
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+@ int __divmodsi4(int divident, int divisor, int *remainder)
+@   Calculate the quotient and remainder of the (signed) division.  The return
+@   value is the quotient, the remainder is placed in the variable.
+
+	.p2align 3
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__divmodsi4)
+#else
+DEFINE_COMPILERRT_FUNCTION(__divmodsi4)
+#endif
+#if __ARM_ARCH_EXT_IDIV__
+	tst     r1, r1
+	beq     LOCAL_LABEL(divzero)
+	mov 	r3, r0
+	sdiv	r0, r3, r1
+	mls 	r1, r0, r1, r3
+	str 	r1, [r2]
+	bx  	lr
+LOCAL_LABEL(divzero):
+	mov     r0, #0
+	bx      lr
+#else
+    ESTABLISH_FRAME
+//  Set aside the sign of the quotient and modulus, and the address for the
+//  modulus.
+    eor     r4,     r0, r1
+    mov     r5,     r0
+    mov     r6,     r2
+//  Take the absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
+    eor     ip,     r0, r0, asr #31
+    eor     lr,     r1, r1, asr #31
+    sub     r0,     ip, r0, asr #31
+    sub     r1,     lr, r1, asr #31
+//  Unsigned divmod:
+    bl      SYMBOL_NAME(__udivmodsi4)
+//  Apply the sign of quotient and modulus
+    ldr     r1,    [r6]
+    eor     r0,     r0, r4, asr #31
+    eor     r1,     r1, r5, asr #31
+    sub     r0,     r0, r4, asr #31
+    sub     r1,     r1, r5, asr #31
+    str     r1,    [r6]
+    CLEAR_FRAME_AND_RETURN
+#endif
+END_COMPILERRT_FUNCTION(__divmodsi4)
diff --git a/compiler-rt/lib/builtins/arm/divsf3vfp.S b/compiler-rt/lib/builtins/arm/divsf3vfp.S
new file mode 100644
index 0000000..fdbaebc
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/divsf3vfp.S
@@ -0,0 +1,26 @@
+//===-- divsf3vfp.S - Implement divsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __divsf3vfp(float a, float b);
+//
+// Divides two single precision floating point numbers using the Darwin
+// calling convention where single arguments are passsed like 32-bit ints.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__divsf3vfp)
+	vmov	s14, r0		// move first param from r0 into float register
+	vmov	s15, r1		// move second param from r1 into float register
+	vdiv.f32 s13, s14, s15
+	vmov	r0, s13		// move result back to r0
+	bx	lr
+END_COMPILERRT_FUNCTION(__divsf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/divsi3.S b/compiler-rt/lib/builtins/arm/divsi3.S
new file mode 100644
index 0000000..adf8f94
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/divsi3.S
@@ -0,0 +1,65 @@
+/*===-- divsi3.S - 32-bit signed integer divide ---------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __divsi3 (32-bit signed integer divide) function
+ * for the ARM architecture as a wrapper around the unsigned routine.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+#define ESTABLISH_FRAME \
+    push   {r4, r7, lr}    ;\
+    add     r7,     sp, #4
+#define CLEAR_FRAME_AND_RETURN \
+    pop    {r4, r7, pc}
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+	.p2align 3
+// Ok, APCS and AAPCS agree on 32 bit args, so it's safe to use the same routine.
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_idiv, __divsi3)
+
+@ int __divsi3(int divident, int divisor)
+@   Calculate and return the quotient of the (signed) division.
+
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__divsi3)
+#else
+DEFINE_COMPILERRT_FUNCTION(__divsi3)
+#endif
+#if __ARM_ARCH_EXT_IDIV__
+   tst     r1,r1
+   beq     LOCAL_LABEL(divzero)
+   sdiv    r0, r0, r1
+   bx      lr
+LOCAL_LABEL(divzero):
+   mov     r0,#0
+   bx      lr
+#else
+ESTABLISH_FRAME
+//  Set aside the sign of the quotient.
+    eor     r4,     r0, r1
+//  Take absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
+    eor     r2,     r0, r0, asr #31
+    eor     r3,     r1, r1, asr #31
+    sub     r0,     r2, r0, asr #31
+    sub     r1,     r3, r1, asr #31
+//  abs(a) / abs(b)
+    bl      SYMBOL_NAME(__udivsi3)
+//  Apply sign of quotient to result and return.
+    eor     r0,     r0, r4, asr #31
+    sub     r0,     r0, r4, asr #31
+    CLEAR_FRAME_AND_RETURN
+#endif
+END_COMPILERRT_FUNCTION(__divsi3)
diff --git a/compiler-rt/lib/builtins/arm/eqdf2vfp.S b/compiler-rt/lib/builtins/arm/eqdf2vfp.S
new file mode 100644
index 0000000..7f2fbc3
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/eqdf2vfp.S
@@ -0,0 +1,29 @@
+//===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __eqdf2vfp(double a, double b);
+//
+// Returns one iff a == b and neither is NaN.
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp)
+	vmov	d6, r0, r1	// load r0/r1 pair in double register
+	vmov	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7		
+	vmrs	apsr_nzcv, fpscr
+	moveq	r0, #1		// set result register to 1 if equal
+	movne	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__eqdf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/eqsf2vfp.S b/compiler-rt/lib/builtins/arm/eqsf2vfp.S
new file mode 100644
index 0000000..a318b33
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/eqsf2vfp.S
@@ -0,0 +1,29 @@
+//===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __eqsf2vfp(float a, float b);
+//
+// Returns one iff a == b and neither is NaN.
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp)
+	vmov	s14, r0     // move from GPR 0 to float register
+	vmov	s15, r1	    // move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	moveq	r0, #1      // set result register to 1 if equal
+	movne	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__eqsf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/extendsfdf2vfp.S b/compiler-rt/lib/builtins/arm/extendsfdf2vfp.S
new file mode 100644
index 0000000..b998e58
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/extendsfdf2vfp.S
@@ -0,0 +1,26 @@
+//===-- extendsfdf2vfp.S - Implement extendsfdf2vfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __extendsfdf2vfp(float a);
+//
+// Converts single precision float to double precision result.
+// Uses Darwin calling convention where a single precision parameter is 
+// passed in a GPR and a double precision result is returned in R0/R1 pair.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__extendsfdf2vfp)
+	vmov	s15, r0      // load float register from R0
+	vcvt.f64.f32 d7, s15 // convert single to double
+	vmov	r0, r1, d7   // return result in r0/r1 pair
+	bx	lr
+END_COMPILERRT_FUNCTION(__extendsfdf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/fixdfsivfp.S b/compiler-rt/lib/builtins/arm/fixdfsivfp.S
new file mode 100644
index 0000000..e3bd8e0
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/fixdfsivfp.S
@@ -0,0 +1,26 @@
+//===-- fixdfsivfp.S - Implement fixdfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __fixdfsivfp(double a);
+//
+// Converts double precision float to a 32-bit int rounding towards zero.
+// Uses Darwin calling convention where a double precision parameter is 
+// passed in GPR register pair.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__fixdfsivfp)
+	vmov	d7, r0, r1    // load double register from R0/R1
+	vcvt.s32.f64 s15, d7  // convert double to 32-bit int into s15
+	vmov	r0, s15	      // move s15 to result register
+	bx	lr
+END_COMPILERRT_FUNCTION(__fixdfsivfp)
diff --git a/compiler-rt/lib/builtins/arm/fixsfsivfp.S b/compiler-rt/lib/builtins/arm/fixsfsivfp.S
new file mode 100644
index 0000000..3d0d0f5
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/fixsfsivfp.S
@@ -0,0 +1,26 @@
+//===-- fixsfsivfp.S - Implement fixsfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __fixsfsivfp(float a);
+//
+// Converts single precision float to a 32-bit int rounding towards zero.
+// Uses Darwin calling convention where a single precision parameter is 
+// passed in a GPR..
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__fixsfsivfp)
+	vmov	s15, r0        // load float register from R0
+	vcvt.s32.f32 s15, s15  // convert single to 32-bit int into s15
+	vmov	r0, s15	       // move s15 to result register
+	bx	lr
+END_COMPILERRT_FUNCTION(__fixsfsivfp)
diff --git a/compiler-rt/lib/builtins/arm/fixunsdfsivfp.S b/compiler-rt/lib/builtins/arm/fixunsdfsivfp.S
new file mode 100644
index 0000000..35dda5b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/fixunsdfsivfp.S
@@ -0,0 +1,27 @@
+//===-- fixunsdfsivfp.S - Implement fixunsdfsivfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern unsigned int __fixunsdfsivfp(double a);
+//
+// Converts double precision float to a 32-bit unsigned int rounding towards 
+// zero. All negative values become zero.
+// Uses Darwin calling convention where a double precision parameter is 
+// passed in GPR register pair.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__fixunsdfsivfp)
+	vmov	d7, r0, r1    // load double register from R0/R1
+	vcvt.u32.f64 s15, d7  // convert double to 32-bit int into s15
+	vmov	r0, s15	      // move s15 to result register
+	bx	lr
+END_COMPILERRT_FUNCTION(__fixunsdfsivfp)
diff --git a/compiler-rt/lib/builtins/arm/fixunssfsivfp.S b/compiler-rt/lib/builtins/arm/fixunssfsivfp.S
new file mode 100644
index 0000000..5c3a7d9
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/fixunssfsivfp.S
@@ -0,0 +1,27 @@
+//===-- fixunssfsivfp.S - Implement fixunssfsivfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern unsigned int __fixunssfsivfp(float a);
+//
+// Converts single precision float to a 32-bit unsigned int rounding towards 
+// zero. All negative values become zero.
+// Uses Darwin calling convention where a single precision parameter is 
+// passed in a GPR..
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__fixunssfsivfp)
+	vmov	s15, r0        // load float register from R0
+	vcvt.u32.f32 s15, s15  // convert single to 32-bit unsigned into s15
+	vmov	r0, s15	       // move s15 to result register
+	bx	lr
+END_COMPILERRT_FUNCTION(__fixunssfsivfp)
diff --git a/compiler-rt/lib/builtins/arm/floatsidfvfp.S b/compiler-rt/lib/builtins/arm/floatsidfvfp.S
new file mode 100644
index 0000000..d691849
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/floatsidfvfp.S
@@ -0,0 +1,26 @@
+//===-- floatsidfvfp.S - Implement floatsidfvfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __floatsidfvfp(int a);
+//
+// Converts a 32-bit int to a double precision float.
+// Uses Darwin calling convention where a double precision result is 
+// return in GPR register pair.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__floatsidfvfp)
+	vmov	s15, r0        // move int to float register s15
+	vcvt.f64.s32 d7, s15   // convert 32-bit int in s15 to double in d7
+	vmov	r0, r1, d7     // move d7 to result register pair r0/r1
+	bx	lr
+END_COMPILERRT_FUNCTION(__floatsidfvfp)
diff --git a/compiler-rt/lib/builtins/arm/floatsisfvfp.S b/compiler-rt/lib/builtins/arm/floatsisfvfp.S
new file mode 100644
index 0000000..4a0cb39
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/floatsisfvfp.S
@@ -0,0 +1,26 @@
+//===-- floatsisfvfp.S - Implement floatsisfvfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __floatsisfvfp(int a);
+//
+// Converts single precision float to a 32-bit int rounding towards zero.
+// Uses Darwin calling convention where a single precision result is 
+// return in a GPR..
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__floatsisfvfp)
+	vmov	s15, r0	       // move int to float register s15
+	vcvt.f32.s32 s15, s15  // convert 32-bit int in s15 to float in s15
+	vmov	r0, s15        // move s15 to result register
+	bx	lr
+END_COMPILERRT_FUNCTION(__floatsisfvfp)
diff --git a/compiler-rt/lib/builtins/arm/floatunssidfvfp.S b/compiler-rt/lib/builtins/arm/floatunssidfvfp.S
new file mode 100644
index 0000000..d92969e
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/floatunssidfvfp.S
@@ -0,0 +1,26 @@
+//===-- floatunssidfvfp.S - Implement floatunssidfvfp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __floatunssidfvfp(unsigned int a);
+//
+// Converts a 32-bit int to a double precision float.
+// Uses Darwin calling convention where a double precision result is 
+// return in GPR register pair.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__floatunssidfvfp)
+	vmov	s15, r0        // move int to float register s15
+	vcvt.f64.u32 d7, s15   // convert 32-bit int in s15 to double in d7
+	vmov	r0, r1, d7     // move d7 to result register pair r0/r1
+	bx	lr
+END_COMPILERRT_FUNCTION(__floatunssidfvfp)
diff --git a/compiler-rt/lib/builtins/arm/floatunssisfvfp.S b/compiler-rt/lib/builtins/arm/floatunssisfvfp.S
new file mode 100644
index 0000000..f6aeba5
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/floatunssisfvfp.S
@@ -0,0 +1,26 @@
+//===-- floatunssisfvfp.S - Implement floatunssisfvfp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __floatunssisfvfp(unsigned int a);
+//
+// Converts single precision float to a 32-bit int rounding towards zero.
+// Uses Darwin calling convention where a single precision result is 
+// return in a GPR..
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__floatunssisfvfp)
+	vmov	s15, r0	       // move int to float register s15
+	vcvt.f32.u32 s15, s15  // convert 32-bit int in s15 to float in s15
+	vmov	r0, s15        // move s15 to result register
+	bx	lr
+END_COMPILERRT_FUNCTION(__floatunssisfvfp)
diff --git a/compiler-rt/lib/builtins/arm/gedf2vfp.S b/compiler-rt/lib/builtins/arm/gedf2vfp.S
new file mode 100644
index 0000000..9e23527
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/gedf2vfp.S
@@ -0,0 +1,29 @@
+//===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __gedf2vfp(double a, double b);
+//
+// Returns one iff a >= b and neither is NaN.
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__gedf2vfp)
+	vmov 	d6, r0, r1	// load r0/r1 pair in double register
+	vmov 	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7
+	vmrs	apsr_nzcv, fpscr
+	movge	r0, #1      // set result register to 1 if greater than or equal
+	movlt	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__gedf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/gesf2vfp.S b/compiler-rt/lib/builtins/arm/gesf2vfp.S
new file mode 100644
index 0000000..0ff6084
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/gesf2vfp.S
@@ -0,0 +1,29 @@
+//===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __gesf2vfp(float a, float b);
+//
+// Returns one iff a >= b and neither is NaN.
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__gesf2vfp)
+	vmov	s14, r0	    // move from GPR 0 to float register
+	vmov	s15, r1	    // move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	movge	r0, #1      // set result register to 1 if greater than or equal
+	movlt	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__gesf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/gtdf2vfp.S b/compiler-rt/lib/builtins/arm/gtdf2vfp.S
new file mode 100644
index 0000000..3dc5d5b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/gtdf2vfp.S
@@ -0,0 +1,29 @@
+//===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __gtdf2vfp(double a, double b);
+//
+// Returns one iff a > b and neither is NaN.
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp)
+	vmov 	d6, r0, r1	// load r0/r1 pair in double register
+	vmov 	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7
+	vmrs	apsr_nzcv, fpscr
+	movgt	r0, #1		// set result register to 1 if equal
+	movle	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__gtdf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/gtsf2vfp.S b/compiler-rt/lib/builtins/arm/gtsf2vfp.S
new file mode 100644
index 0000000..ddd843a
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/gtsf2vfp.S
@@ -0,0 +1,29 @@
+//===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __gtsf2vfp(float a, float b);
+//
+// Returns one iff a > b and neither is NaN.
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp)
+	vmov	s14, r0		// move from GPR 0 to float register
+	vmov	s15, r1		// move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	movgt	r0, #1		// set result register to 1 if equal
+	movle	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__gtsf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/ledf2vfp.S b/compiler-rt/lib/builtins/arm/ledf2vfp.S
new file mode 100644
index 0000000..b06ff6d
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/ledf2vfp.S
@@ -0,0 +1,29 @@
+//===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __ledf2vfp(double a, double b);
+//
+// Returns one iff a <= b and neither is NaN.
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__ledf2vfp)
+	vmov 	d6, r0, r1	// load r0/r1 pair in double register
+	vmov 	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7
+	vmrs	apsr_nzcv, fpscr
+	movls	r0, #1		// set result register to 1 if equal
+	movhi	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__ledf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/lesf2vfp.S b/compiler-rt/lib/builtins/arm/lesf2vfp.S
new file mode 100644
index 0000000..9b33c0c
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/lesf2vfp.S
@@ -0,0 +1,29 @@
+//===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __lesf2vfp(float a, float b);
+//
+// Returns one iff a <= b and neither is NaN.
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__lesf2vfp)
+	vmov	s14, r0     // move from GPR 0 to float register
+	vmov	s15, r1     // move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	movls	r0, #1      // set result register to 1 if equal
+	movhi	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__lesf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/ltdf2vfp.S b/compiler-rt/lib/builtins/arm/ltdf2vfp.S
new file mode 100644
index 0000000..9f794b0
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/ltdf2vfp.S
@@ -0,0 +1,29 @@
+//===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __ltdf2vfp(double a, double b);
+//
+// Returns one iff a < b and neither is NaN.
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp)
+	vmov 	d6, r0, r1	// load r0/r1 pair in double register
+	vmov 	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7
+	vmrs	apsr_nzcv, fpscr
+	movmi	r0, #1		// set result register to 1 if equal
+	movpl	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__ltdf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/ltsf2vfp.S b/compiler-rt/lib/builtins/arm/ltsf2vfp.S
new file mode 100644
index 0000000..ba190d9
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/ltsf2vfp.S
@@ -0,0 +1,29 @@
+//===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __ltsf2vfp(float a, float b);
+//
+// Returns one iff a < b and neither is NaN.
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp)
+	vmov	s14, r0     // move from GPR 0 to float register
+	vmov	s15, r1     // move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	movmi	r0, #1      // set result register to 1 if equal
+	movpl	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__ltsf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/modsi3.S b/compiler-rt/lib/builtins/arm/modsi3.S
new file mode 100644
index 0000000..295a227
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/modsi3.S
@@ -0,0 +1,63 @@
+/*===-- modsi3.S - 32-bit signed integer modulus --------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __modsi3 (32-bit signed integer modulus) function
+ * for the ARM architecture as a wrapper around the unsigned routine.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+#define ESTABLISH_FRAME \
+    push   {r4, r7, lr}    ;\
+    add     r7,     sp, #4
+#define CLEAR_FRAME_AND_RETURN \
+    pop    {r4, r7, pc}
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+@ int __modsi3(int divident, int divisor)
+@   Calculate and return the remainder of the (signed) division.
+
+	.p2align 3
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__modsi3)
+#else
+DEFINE_COMPILERRT_FUNCTION(__modsi3)
+#endif
+#if __ARM_ARCH_EXT_IDIV__
+	tst     r1, r1
+	beq     LOCAL_LABEL(divzero)
+	sdiv	r2, r0, r1
+	mls 	r0, r2, r1, r0
+	bx      lr
+LOCAL_LABEL(divzero):
+	mov     r0, #0
+	bx      lr
+#else
+    ESTABLISH_FRAME
+    //  Set aside the sign of the dividend.
+    mov     r4,     r0
+    //  Take absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
+    eor     r2,     r0, r0, asr #31
+    eor     r3,     r1, r1, asr #31
+    sub     r0,     r2, r0, asr #31
+    sub     r1,     r3, r1, asr #31
+    //  abs(a) % abs(b)
+    bl     SYMBOL_NAME(__umodsi3)
+    //  Apply sign of dividend to result and return.
+    eor     r0,     r0, r4, asr #31
+    sub     r0,     r0, r4, asr #31
+    CLEAR_FRAME_AND_RETURN
+#endif
+END_COMPILERRT_FUNCTION(__modsi3)
diff --git a/compiler-rt/lib/builtins/arm/muldf3vfp.S b/compiler-rt/lib/builtins/arm/muldf3vfp.S
new file mode 100644
index 0000000..636cc71
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/muldf3vfp.S
@@ -0,0 +1,26 @@
+//===-- muldf3vfp.S - Implement muldf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __muldf3vfp(double a, double b);
+//
+// Multiplies two double precision floating point numbers using the Darwin
+// calling convention where double arguments are passsed in GPR pairs
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__muldf3vfp)
+	vmov 	d6, r0, r1         // move first param from r0/r1 pair into d6
+	vmov 	d7, r2, r3         // move second param from r2/r3 pair into d7
+	vmul.f64 d6, d6, d7		
+	vmov 	r0, r1, d6         // move result back to r0/r1 pair
+	bx	lr
+END_COMPILERRT_FUNCTION(__muldf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/mulsf3vfp.S b/compiler-rt/lib/builtins/arm/mulsf3vfp.S
new file mode 100644
index 0000000..7f40082
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/mulsf3vfp.S
@@ -0,0 +1,26 @@
+//===-- mulsf3vfp.S - Implement mulsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __mulsf3vfp(float a, float b);
+//
+// Multiplies two single precision floating point numbers using the Darwin
+// calling convention where single arguments are passsed like 32-bit ints.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__mulsf3vfp)
+	vmov	s14, r0		// move first param from r0 into float register
+	vmov	s15, r1		// move second param from r1 into float register
+	vmul.f32 s13, s14, s15
+	vmov	r0, s13		// move result back to r0
+	bx	lr
+END_COMPILERRT_FUNCTION(__mulsf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/nedf2vfp.S b/compiler-rt/lib/builtins/arm/nedf2vfp.S
new file mode 100644
index 0000000..7ab2f55
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/nedf2vfp.S
@@ -0,0 +1,29 @@
+//===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __nedf2vfp(double a, double b);
+//
+// Returns zero if a and b are unequal and neither is NaN.
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__nedf2vfp)
+	vmov 	d6, r0, r1	// load r0/r1 pair in double register
+	vmov 	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7		
+	vmrs	apsr_nzcv, fpscr
+	movne	r0, #1		// set result register to 0 if unequal
+	moveq	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__nedf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/negdf2vfp.S b/compiler-rt/lib/builtins/arm/negdf2vfp.S
new file mode 100644
index 0000000..56d73c6
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/negdf2vfp.S
@@ -0,0 +1,23 @@
+//===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __negdf2vfp(double a, double b);
+//
+// Returns the negation a double precision floating point numbers using the 
+// Darwin calling convention where double arguments are passsed in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__negdf2vfp)
+	eor	r1, r1, #-2147483648	// flip sign bit on double in r0/r1 pair
+	bx	lr
+END_COMPILERRT_FUNCTION(__negdf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/negsf2vfp.S b/compiler-rt/lib/builtins/arm/negsf2vfp.S
new file mode 100644
index 0000000..a6e32e1
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/negsf2vfp.S
@@ -0,0 +1,23 @@
+//===-- negsf2vfp.S - Implement negsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __negsf2vfp(float a);
+//
+// Returns the negation of a single precision floating point numbers using the 
+// Darwin calling convention where single arguments are passsed like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__negsf2vfp)
+	eor	r0, r0, #-2147483648	// flip sign bit on float in r0
+	bx	lr
+END_COMPILERRT_FUNCTION(__negsf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/nesf2vfp.S b/compiler-rt/lib/builtins/arm/nesf2vfp.S
new file mode 100644
index 0000000..9fe8ecd
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/nesf2vfp.S
@@ -0,0 +1,29 @@
+//===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __nesf2vfp(float a, float b);
+//
+// Returns one iff a != b and neither is NaN.
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__nesf2vfp)
+	vmov	s14, r0	    // move from GPR 0 to float register
+	vmov	s15, r1	    // move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	movne	r0, #1      // set result register to 1 if unequal
+	moveq	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__nesf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/restore_vfp_d8_d15_regs.S b/compiler-rt/lib/builtins/arm/restore_vfp_d8_d15_regs.S
new file mode 100644
index 0000000..0f6ea51
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/restore_vfp_d8_d15_regs.S
@@ -0,0 +1,33 @@
+//===-- save_restore_regs.S - Implement save/restore* ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling C++ functions that need to handle thrown exceptions the
+// compiler is required to save all registers and call __Unwind_SjLj_Register
+// in the function prolog.  But when compiling for thumb1, there are
+// no instructions to access the floating point registers, so the
+// compiler needs to add a call to the helper function _save_vfp_d8_d15_regs
+// written in ARM to save the float registers.  In the epilog, the compiler
+// must also add a call to __restore_vfp_d8_d15_regs to restore those registers.
+//
+
+	.text
+	.syntax unified
+
+//
+// Restore registers d8-d15 from stack
+//
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__restore_vfp_d8_d15_regs)
+	vldmia	sp!, {d8-d15}           // pop registers d8-d15 off stack
+	bx      lr                      // return to prolog
+END_COMPILERRT_FUNCTION(__restore_vfp_d8_d15_regs)
+
diff --git a/compiler-rt/lib/builtins/arm/save_vfp_d8_d15_regs.S b/compiler-rt/lib/builtins/arm/save_vfp_d8_d15_regs.S
new file mode 100644
index 0000000..f1d90e7
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/save_vfp_d8_d15_regs.S
@@ -0,0 +1,33 @@
+//===-- save_restore_regs.S - Implement save/restore* ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling C++ functions that need to handle thrown exceptions the
+// compiler is required to save all registers and call __Unwind_SjLj_Register
+// in the function prolog.  But when compiling for thumb1, there are
+// no instructions to access the floating point registers, so the
+// compiler needs to add a call to the helper function _save_vfp_d8_d15_regs
+// written in ARM to save the float registers.  In the epilog, the compiler
+// must also add a call to __restore_vfp_d8_d15_regs to restore those registers.
+//
+
+	.text
+	.syntax unified
+
+//
+// Save registers d8-d15 onto stack
+//
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__save_vfp_d8_d15_regs)
+	vstmdb	sp!, {d8-d15}           // push registers d8-d15 onto stack
+	bx      lr                      // return to prolog
+END_COMPILERRT_FUNCTION(__save_vfp_d8_d15_regs)
+
diff --git a/compiler-rt/lib/builtins/arm/softfloat-alias.list b/compiler-rt/lib/builtins/arm/softfloat-alias.list
new file mode 100644
index 0000000..cc6a4b3
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/softfloat-alias.list
@@ -0,0 +1,21 @@
+#
+# These are soft float functions which can be 
+# aliased to the *vfp functions on arm processors
+# that support floating point instructions.
+#
+___adddf3vfp		___adddf3
+___addsf3vfp		___addsf3
+___divdf3vfp		___divdf3
+___divsf3vfp		___divsf3
+___extendsfdf2vfp	___extendsfdf2
+___fixdfsivfp		___fixdfsi
+___fixsfsivfp		___fixsfsi
+___floatsidfvfp		___floatsidf
+___floatsisfvfp		___floatsisf
+___muldf3vfp		___muldf3
+___mulsf3vfp		___mulsf3
+___subdf3vfp		___subdf3
+___subsf3vfp		___subsf3
+___truncdfsf2vfp	___truncdfsf2
+___floatunssidfvfp	___floatunsidf
+___floatunssisfvfp	___floatunsisf
diff --git a/compiler-rt/lib/builtins/arm/subdf3vfp.S b/compiler-rt/lib/builtins/arm/subdf3vfp.S
new file mode 100644
index 0000000..5f3c0f7
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/subdf3vfp.S
@@ -0,0 +1,26 @@
+//===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern double __subdf3vfp(double a, double b);
+//
+// Returns difference between two double precision floating point numbers using 
+// the Darwin calling convention where double arguments are passsed in GPR pairs
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__subdf3vfp)
+	vmov 	d6, r0, r1         // move first param from r0/r1 pair into d6
+	vmov 	d7, r2, r3         // move second param from r2/r3 pair into d7
+	vsub.f64 d6, d6, d7		
+	vmov 	r0, r1, d6         // move result back to r0/r1 pair
+	bx	lr
+END_COMPILERRT_FUNCTION(__subdf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/subsf3vfp.S b/compiler-rt/lib/builtins/arm/subsf3vfp.S
new file mode 100644
index 0000000..d6e06df
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/subsf3vfp.S
@@ -0,0 +1,27 @@
+//===-- subsf3vfp.S - Implement subsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __subsf3vfp(float a, float b);
+//
+// Returns the difference between two single precision floating point numbers 
+// using the Darwin calling convention where single arguments are passsed
+// like 32-bit ints.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__subsf3vfp)
+	vmov	s14, r0		// move first param from r0 into float register
+	vmov	s15, r1		// move second param from r1 into float register
+	vsub.f32 s14, s14, s15
+	vmov	r0, s14		// move result back to r0
+	bx	lr
+END_COMPILERRT_FUNCTION(__subsf3vfp)
diff --git a/compiler-rt/lib/builtins/arm/switch16.S b/compiler-rt/lib/builtins/arm/switch16.S
new file mode 100644
index 0000000..3c3a6b1
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/switch16.S
@@ -0,0 +1,44 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling switch statements in thumb mode, the compiler
+// can use these __switch* helper functions  The compiler emits a blx to
+// the __switch* function followed by a table of displacements for each
+// case statement.  On entry, R0 is the index into the table. The __switch*
+// function uses the return address in lr to find the start of the table.
+// The first entry in the table is the count of the entries in the table.
+// It then uses R0 to index into the table and get the displacement of the
+// address to jump to.  If R0 is greater than the size of the table, it jumps
+// to the last entry in the table. Each displacement in the table is actually
+// the distance from lr to the label, thus making the tables PIC.
+
+
+	.text
+	.syntax unified
+
+//
+// The table contains signed 2-byte sized elements which are 1/2 the distance
+// from lr to the target label.
+//
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch16)
+	ldrh    ip, [lr, #-1]           // get first 16-bit word in table
+	cmp     r0, ip                  // compare with index
+	add     r0, lr, r0, lsl #1      // compute address of element in table
+	add     ip, lr, ip, lsl #1      // compute address of last element in table
+	ite lo
+	ldrshlo r0, [r0, #1]            // load 16-bit element if r0 is in range
+	ldrshhs r0, [ip, #1]            // load 16-bit element if r0 out of range
+	add     ip, lr, r0, lsl #1      // compute label = lr + element*2
+	bx      ip                      // jump to computed label
+END_COMPILERRT_FUNCTION(__switch16)
+
diff --git a/compiler-rt/lib/builtins/arm/switch32.S b/compiler-rt/lib/builtins/arm/switch32.S
new file mode 100644
index 0000000..b38cd2b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/switch32.S
@@ -0,0 +1,44 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling switch statements in thumb mode, the compiler
+// can use these __switch* helper functions  The compiler emits a blx to
+// the __switch* function followed by a table of displacements for each
+// case statement.  On entry, R0 is the index into the table. The __switch*
+// function uses the return address in lr to find the start of the table.
+// The first entry in the table is the count of the entries in the table.
+// It then uses R0 to index into the table and get the displacement of the
+// address to jump to.  If R0 is greater than the size of the table, it jumps
+// to the last entry in the table. Each displacement in the table is actually
+// the distance from lr to the label, thus making the tables PIC.
+
+
+	.text
+	.syntax unified
+
+//
+// The table contains signed 4-byte sized elements which are the distance
+// from lr to the target label.
+//
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch32)
+	ldr     ip, [lr, #-1]            // get first 32-bit word in table
+	cmp     r0, ip                   // compare with index
+	add     r0, lr, r0, lsl #2       // compute address of element in table
+	add     ip, lr, ip, lsl #2       // compute address of last element in table
+	ite lo
+	ldrlo   r0, [r0, #3]             // load 32-bit element if r0 is in range
+	ldrhs   r0, [ip, #3]             // load 32-bit element if r0 out of range
+	add     ip, lr, r0               // compute label = lr + element
+	bx      ip                       // jump to computed label
+END_COMPILERRT_FUNCTION(__switch32)
+
diff --git a/compiler-rt/lib/builtins/arm/switch8.S b/compiler-rt/lib/builtins/arm/switch8.S
new file mode 100644
index 0000000..d7c2042
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/switch8.S
@@ -0,0 +1,42 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling switch statements in thumb mode, the compiler
+// can use these __switch* helper functions  The compiler emits a blx to
+// the __switch* function followed by a table of displacements for each
+// case statement.  On entry, R0 is the index into the table. The __switch*
+// function uses the return address in lr to find the start of the table.
+// The first entry in the table is the count of the entries in the table.
+// It then uses R0 to index into the table and get the displacement of the
+// address to jump to.  If R0 is greater than the size of the table, it jumps
+// to the last entry in the table. Each displacement in the table is actually
+// the distance from lr to the label, thus making the tables PIC.
+
+
+	.text
+	.syntax unified
+
+//
+// The table contains signed byte sized elements which are 1/2 the distance
+// from lr to the target label.
+//
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch8)
+	ldrb    ip, [lr, #-1]           // get first byte in table
+	cmp     r0, ip                  // signed compare with index
+	ite lo
+	ldrsblo r0, [lr, r0]            // get indexed byte out of table
+	ldrsbhs r0, [lr, ip]            // if out of range, use last entry in table
+	add     ip, lr, r0, lsl #1      // compute label = lr + element*2
+	bx      ip                      // jump to computed label
+END_COMPILERRT_FUNCTION(__switch8)
+
diff --git a/compiler-rt/lib/builtins/arm/switchu8.S b/compiler-rt/lib/builtins/arm/switchu8.S
new file mode 100644
index 0000000..1844f11
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/switchu8.S
@@ -0,0 +1,42 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling switch statements in thumb mode, the compiler
+// can use these __switch* helper functions  The compiler emits a blx to
+// the __switch* function followed by a table of displacements for each
+// case statement.  On entry, R0 is the index into the table. The __switch*
+// function uses the return address in lr to find the start of the table.
+// The first entry in the table is the count of the entries in the table.
+// It then uses R0 to index into the table and get the displacement of the
+// address to jump to.  If R0 is greater than the size of the table, it jumps
+// to the last entry in the table. Each displacement in the table is actually
+// the distance from lr to the label, thus making the tables PIC.
+
+
+	.text
+	.syntax unified
+
+//
+// The table contains unsigned byte sized elements which are 1/2 the distance
+// from lr to the target label.
+//
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switchu8)
+	ldrb    ip, [lr, #-1]           // get first byte in table
+	cmp     r0, ip                  // compare with index
+	ite lo
+	ldrblo  r0, [lr, r0]            // get indexed byte out of table
+	ldrbhs  r0, [lr, ip]            // if out of range, use last entry in table
+	add     ip, lr, r0, lsl #1      // compute label = lr + element*2
+	bx      ip                      // jump to computed label
+END_COMPILERRT_FUNCTION(__switchu8)
+
diff --git a/compiler-rt/lib/builtins/arm/sync-ops.h b/compiler-rt/lib/builtins/arm/sync-ops.h
new file mode 100644
index 0000000..ee02c30
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync-ops.h
@@ -0,0 +1,64 @@
+/*===-- sync-ops.h - --===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements outline macros for the __sync_fetch_and_*
+ * operations. Different instantiations will generate appropriate assembly for
+ * ARM and Thumb-2 versions of the functions.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+#define SYNC_OP_4(op) \
+        .p2align 2 ; \
+        .thumb ; \
+        .syntax unified ; \
+        DEFINE_COMPILERRT_THUMB_FUNCTION(__sync_fetch_and_ ## op) \
+        dmb ; \
+        mov r12, r0 ; \
+        LOCAL_LABEL(tryatomic_ ## op): \
+        ldrex r0, [r12] ; \
+        op(r2, r0, r1) ; \
+        strex r3, r2, [r12] ; \
+        cmp r3, #0 ; \
+        bne LOCAL_LABEL(tryatomic_ ## op) ; \
+        dmb ; \
+        bx lr
+
+#define SYNC_OP_8(op) \
+        .p2align 2 ; \
+        .thumb ; \
+        .syntax unified ; \
+        DEFINE_COMPILERRT_THUMB_FUNCTION(__sync_fetch_and_ ## op) \
+        push {r4, r5, r6, lr} ; \
+        dmb ; \
+        mov r12, r0 ; \
+        LOCAL_LABEL(tryatomic_ ## op): \
+        ldrexd r0, r1, [r12] ; \
+        op(r4, r5, r0, r1, r2, r3) ; \
+        strexd r6, r4, r5, [r12] ; \
+        cmp r6, #0 ; \
+        bne LOCAL_LABEL(tryatomic_ ## op) ; \
+        dmb ; \
+        pop {r4, r5, r6, pc}
+
+#define MINMAX_4(rD, rN, rM, cmp_kind) \
+        cmp rN, rM ; \
+        mov rD, rM ; \
+        it cmp_kind ; \
+        mov##cmp_kind rD, rN
+
+#define MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, cmp_kind) \
+        cmp rN_LO, rM_LO ; \
+        sbcs rN_HI, rM_HI ; \
+        mov rD_LO, rM_LO ; \
+        mov rD_HI, rM_HI ; \
+        itt cmp_kind ; \
+        mov##cmp_kind rD_LO, rN_LO ; \
+        mov##cmp_kind rD_HI, rN_HI
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_add_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_add_4.S
new file mode 100644
index 0000000..54c33e2
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_add_4.S
@@ -0,0 +1,21 @@
+/*===-- sync_fetch_and_add_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_add_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+/* "adds" is 2 bytes shorter than "add". */
+#define add_4(rD, rN, rM)  add rD, rN, rM
+
+SYNC_OP_4(add_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_add_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_add_8.S
new file mode 100644
index 0000000..5724bb1
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_add_8.S
@@ -0,0 +1,24 @@
+/*===-- sync_fetch_and_add_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_add_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define add_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
+    adds rD_LO, rN_LO, rM_LO ; \
+    adc rD_HI, rN_HI, rM_HI
+
+SYNC_OP_8(add_8)
+#endif
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_and_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_and_4.S
new file mode 100644
index 0000000..e2b77a1
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_and_4.S
@@ -0,0 +1,19 @@
+/*===-- sync_fetch_and_and_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_and_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define and_4(rD, rN, rM)  and rD, rN, rM
+
+SYNC_OP_4(and_4)
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_and_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_and_8.S
new file mode 100644
index 0000000..a74163a
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_and_8.S
@@ -0,0 +1,23 @@
+/*===-- sync_fetch_and_and_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_and_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define and_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
+    and rD_LO, rN_LO, rM_LO ; \
+    and rD_HI, rN_HI, rM_HI
+
+SYNC_OP_8(and_8)
+#endif
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_max_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_max_4.S
new file mode 100644
index 0000000..01e4f44
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_max_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_max_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_max_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define max_4(rD, rN, rM)  MINMAX_4(rD, rN, rM, gt)
+
+SYNC_OP_4(max_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_max_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_max_8.S
new file mode 100644
index 0000000..1eef2b2
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_max_8.S
@@ -0,0 +1,21 @@
+/*===-- sync_fetch_and_max_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_max_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define max_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI)         MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, gt)
+
+SYNC_OP_8(max_8)
+#endif
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_min_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_min_4.S
new file mode 100644
index 0000000..015626b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_min_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_min_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_min_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define min_4(rD, rN, rM) MINMAX_4(rD, rN, rM, lt)
+
+SYNC_OP_4(min_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_min_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_min_8.S
new file mode 100644
index 0000000..ad5cce0
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_min_8.S
@@ -0,0 +1,21 @@
+/*===-- sync_fetch_and_min_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_min_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define min_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI)         MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, lt)
+
+SYNC_OP_8(min_8)
+#endif
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_nand_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_nand_4.S
new file mode 100644
index 0000000..b32a314
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_nand_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_nand_4.S - -----------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_nand_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define nand_4(rD, rN, rM)  bic rD, rN, rM
+
+SYNC_OP_4(nand_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_nand_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_nand_8.S
new file mode 100644
index 0000000..a2c17c0
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_nand_8.S
@@ -0,0 +1,24 @@
+/*===-- sync_fetch_and_nand_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_nand_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define nand_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
+    bic rD_LO, rN_LO, rM_LO ; \
+    bic rD_HI, rN_HI, rM_HI
+
+SYNC_OP_8(nand_8)
+#endif
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_or_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_or_4.S
new file mode 100644
index 0000000..f2e0857
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_or_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_or_4.S - -------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_or_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define or_4(rD, rN, rM)  orr rD, rN, rM
+
+SYNC_OP_4(or_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_or_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_or_8.S
new file mode 100644
index 0000000..87b940b
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_or_8.S
@@ -0,0 +1,24 @@
+/*===-- sync_fetch_and_or_8.S - -------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_or_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define or_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
+    orr rD_LO, rN_LO, rM_LO ; \
+    orr rD_HI, rN_HI, rM_HI
+
+SYNC_OP_8(or_8)
+#endif
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_sub_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_sub_4.S
new file mode 100644
index 0000000..460b2bc
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_sub_4.S
@@ -0,0 +1,21 @@
+/*===-- sync_fetch_and_sub_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_sub_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+/* "subs" is 2 bytes shorter than "sub". */
+#define sub_4(rD, rN, rM)  sub rD, rN, rM
+
+SYNC_OP_4(sub_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_sub_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_sub_8.S
new file mode 100644
index 0000000..a8035a2
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_sub_8.S
@@ -0,0 +1,24 @@
+/*===-- sync_fetch_and_sub_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_sub_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define sub_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
+    subs rD_LO, rN_LO, rM_LO ; \
+    sbc rD_HI, rN_HI, rM_HI
+
+SYNC_OP_8(sub_8)
+#endif
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_umax_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_umax_4.S
new file mode 100644
index 0000000..c591530
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_umax_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_umax_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_umax_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define umax_4(rD, rN, rM)  MINMAX_4(rD, rN, rM, hi)
+
+SYNC_OP_4(umax_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_umax_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_umax_8.S
new file mode 100644
index 0000000..d9b7965
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_umax_8.S
@@ -0,0 +1,21 @@
+/*===-- sync_fetch_and_umax_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_umax_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define umax_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI)         MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, hi)
+
+SYNC_OP_8(umax_8)
+#endif
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_umin_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_umin_4.S
new file mode 100644
index 0000000..9f3896f
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_umin_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_umin_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_umin_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define umin_4(rD, rN, rM) MINMAX_4(rD, rN, rM, lo)
+
+SYNC_OP_4(umin_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_umin_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_umin_8.S
new file mode 100644
index 0000000..7bf5e23
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_umin_8.S
@@ -0,0 +1,21 @@
+/*===-- sync_fetch_and_umin_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_umin_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define umin_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI)         MINMAX_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI, lo)
+
+SYNC_OP_8(umin_8)
+#endif
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_xor_4.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_xor_4.S
new file mode 100644
index 0000000..7e7c90c
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_xor_4.S
@@ -0,0 +1,20 @@
+/*===-- sync_fetch_and_xor_4.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_xor_4 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#define xor_4(rD, rN, rM)  eor rD, rN, rM
+
+SYNC_OP_4(xor_4)
+
diff --git a/compiler-rt/lib/builtins/arm/sync_fetch_and_xor_8.S b/compiler-rt/lib/builtins/arm/sync_fetch_and_xor_8.S
new file mode 100644
index 0000000..ea9aa6d
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_fetch_and_xor_8.S
@@ -0,0 +1,24 @@
+/*===-- sync_fetch_and_xor_8.S - ------------------------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __sync_fetch_and_xor_8 function for the ARM
+ * architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "sync-ops.h"
+
+#if __ARM_ARCH_PROFILE != 'M'
+#define xor_8(rD_LO, rD_HI, rN_LO, rN_HI, rM_LO, rM_HI) \
+    eor rD_LO, rN_LO, rM_LO ; \
+    eor rD_HI, rN_HI, rM_HI
+
+SYNC_OP_8(xor_8)
+#endif
+
diff --git a/compiler-rt/lib/builtins/arm/sync_synchronize.S b/compiler-rt/lib/builtins/arm/sync_synchronize.S
new file mode 100644
index 0000000..178f245
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/sync_synchronize.S
@@ -0,0 +1,35 @@
+//===-- sync_synchronize - Implement memory barrier * ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// When compiling a use of the gcc built-in __sync_synchronize() in thumb1 mode
+// the compiler may emit a call to __sync_synchronize.  
+// On Darwin the implementation jumps to an OS supplied function named 
+// OSMemoryBarrier
+//
+
+	.text
+	.syntax unified
+
+#if __APPLE__
+
+	.p2align 2
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__sync_synchronize)
+	stmfd	sp!, {r7, lr}
+	add		r7, sp, #0
+	bl		_OSMemoryBarrier
+	ldmfd	sp!, {r7, pc}
+END_COMPILERRT_FUNCTION(__sync_synchronize)
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+		
+#endif
diff --git a/compiler-rt/lib/builtins/arm/truncdfsf2vfp.S b/compiler-rt/lib/builtins/arm/truncdfsf2vfp.S
new file mode 100644
index 0000000..fa4362c
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/truncdfsf2vfp.S
@@ -0,0 +1,26 @@
+//===-- truncdfsf2vfp.S - Implement truncdfsf2vfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern float __truncdfsf2vfp(double a);
+//
+// Converts double precision float to signle precision result.
+// Uses Darwin calling convention where a double precision parameter is 
+// passed in a R0/R1 pair and a signle precision result is returned in R0.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp)
+	vmov 	d7, r0, r1   // load double from r0/r1 pair
+	vcvt.f32.f64 s15, d7 // convert double to single (trucate precision)
+	vmov 	r0, s15      // return result in r0
+	bx	lr
+END_COMPILERRT_FUNCTION(__truncdfsf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/udivmodsi4.S b/compiler-rt/lib/builtins/arm/udivmodsi4.S
new file mode 100644
index 0000000..85b8493
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/udivmodsi4.S
@@ -0,0 +1,184 @@
+/*===-- udivmodsi4.S - 32-bit unsigned integer divide and modulus ---------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __udivmodsi4 (32-bit unsigned integer divide and
+ * modulus) function for the ARM 32-bit architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+@ unsigned int __udivmodsi4(unsigned int divident, unsigned int divisor,
+@                           unsigned int *remainder)
+@   Calculate the quotient and remainder of the (unsigned) division.  The return
+@   value is the quotient, the remainder is placed in the variable.
+
+	.p2align 2
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__udivmodsi4)
+#else
+DEFINE_COMPILERRT_FUNCTION(__udivmodsi4)
+#endif
+#if __ARM_ARCH_EXT_IDIV__
+	tst     r1, r1
+	beq     LOCAL_LABEL(divby0)
+	mov 	r3, r0
+	udiv	r0, r3, r1
+	mls 	r1, r0, r1, r3
+	str 	r1, [r2]
+	bx  	lr
+#else
+	cmp	r1, #1
+	bcc	LOCAL_LABEL(divby0)
+	beq	LOCAL_LABEL(divby1)
+	cmp	r0, r1
+	bcc	LOCAL_LABEL(quotient0)
+	/*
+	 * Implement division using binary long division algorithm.
+	 *
+	 * r0 is the numerator, r1 the denominator.
+	 *
+	 * The code before JMP computes the correct shift I, so that
+	 * r0 and (r1 << I) have the highest bit set in the same position.
+	 * At the time of JMP, ip := .Ldiv0block - 12 * I.
+	 * This depends on the fixed instruction size of block.
+	 * For ARM mode, this is 12 Bytes, for THUMB mode 14 Bytes.
+	 *
+	 * block(shift) implements the test-and-update-quotient core.
+	 * It assumes (r0 << shift) can be computed without overflow and
+	 * that (r0 << shift) < 2 * r1. The quotient is stored in r3.
+	 */
+
+#  ifdef __ARM_FEATURE_CLZ
+	clz	ip, r0
+	clz	r3, r1
+	/* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */
+	sub	r3, r3, ip
+#    if __ARM_ARCH_ISA_THUMB == 2
+	adr	ip, LOCAL_LABEL(div0block) + 1
+	sub	ip, ip, r3, lsl #1
+#    else
+	adr	ip, LOCAL_LABEL(div0block)
+#    endif
+	sub	ip, ip, r3, lsl #2
+	sub	ip, ip, r3, lsl #3
+	mov	r3, #0
+	bx	ip
+#  else
+#    if __ARM_ARCH_ISA_THUMB == 2
+#    error THUMB mode requires CLZ or UDIV
+#    endif
+	str	r4, [sp, #-8]!
+
+	mov	r4, r0
+	adr	ip, LOCAL_LABEL(div0block)
+
+	lsr	r3, r4, #16
+	cmp	r3, r1
+	movhs	r4, r3
+	subhs	ip, ip, #(16 * 12)
+
+	lsr	r3, r4, #8
+	cmp	r3, r1
+	movhs	r4, r3
+	subhs	ip, ip, #(8 * 12)
+
+	lsr	r3, r4, #4
+	cmp	r3, r1
+	movhs	r4, r3
+	subhs	ip, #(4 * 12)
+
+	lsr	r3, r4, #2
+	cmp	r3, r1
+	movhs	r4, r3
+	subhs	ip, ip, #(2 * 12)
+
+	/* Last block, no need to update r3 or r4. */
+	cmp	r1, r4, lsr #1
+	subls	ip, ip, #(1 * 12)
+
+	ldr	r4, [sp], #8	/* restore r4, we are done with it. */
+	mov	r3, #0
+
+	JMP(ip)
+#  endif
+
+#define	IMM	#
+
+#define block(shift)                                                           \
+	cmp	r0, r1, lsl IMM shift;                                         \
+	ITT(hs);                                                               \
+	WIDE(addhs)	r3, r3, IMM (1 << shift);                              \
+	WIDE(subhs)	r0, r0, r1, lsl IMM shift
+
+	block(31)
+	block(30)
+	block(29)
+	block(28)
+	block(27)
+	block(26)
+	block(25)
+	block(24)
+	block(23)
+	block(22)
+	block(21)
+	block(20)
+	block(19)
+	block(18)
+	block(17)
+	block(16)
+	block(15)
+	block(14)
+	block(13)
+	block(12)
+	block(11)
+	block(10)
+	block(9)
+	block(8)
+	block(7)
+	block(6)
+	block(5)
+	block(4)
+	block(3)
+	block(2)
+	block(1)
+LOCAL_LABEL(div0block):
+	block(0)
+
+	str	r0, [r2]
+	mov	r0, r3
+	JMP(lr)
+
+LOCAL_LABEL(quotient0):
+	str	r0, [r2]
+	mov	r0, #0
+	JMP(lr)
+
+LOCAL_LABEL(divby1):
+	mov	r3, #0
+	str	r3, [r2]
+	JMP(lr)
+#endif /* __ARM_ARCH_EXT_IDIV__ */
+
+LOCAL_LABEL(divby0):
+	mov	r0, #0
+#ifdef __ARM_EABI__
+	b	__aeabi_idiv0
+#else
+	JMP(lr)
+#endif
+
+END_COMPILERRT_FUNCTION(__udivmodsi4)
diff --git a/compiler-rt/lib/builtins/arm/udivsi3.S b/compiler-rt/lib/builtins/arm/udivsi3.S
new file mode 100644
index 0000000..165b2b5
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/udivsi3.S
@@ -0,0 +1,170 @@
+/*===-- udivsi3.S - 32-bit unsigned integer divide ------------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __udivsi3 (32-bit unsigned integer divide)
+ * function for the ARM 32-bit architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+	.p2align 2
+DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_uidiv, __udivsi3)
+
+@ unsigned int __udivsi3(unsigned int divident, unsigned int divisor)
+@   Calculate and return the quotient of the (unsigned) division.
+
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__udivsi3)
+#else
+DEFINE_COMPILERRT_FUNCTION(__udivsi3)
+#endif
+#if __ARM_ARCH_EXT_IDIV__
+	tst     r1, r1
+	beq     LOCAL_LABEL(divby0)
+	udiv	r0, r0, r1
+	bx  	lr
+#else
+	cmp	r1, #1
+	bcc	LOCAL_LABEL(divby0)
+	IT(eq)
+	JMPc(lr, eq)
+	cmp	r0, r1
+	ITT(cc)
+	movcc	r0, #0
+	JMPc(lr, cc)
+	/*
+	 * Implement division using binary long division algorithm.
+	 *
+	 * r0 is the numerator, r1 the denominator.
+	 *
+	 * The code before JMP computes the correct shift I, so that
+	 * r0 and (r1 << I) have the highest bit set in the same position.
+	 * At the time of JMP, ip := .Ldiv0block - 12 * I.
+	 * This depends on the fixed instruction size of block.
+	 * For ARM mode, this is 12 Bytes, for THUMB mode 14 Bytes.
+	 *
+	 * block(shift) implements the test-and-update-quotient core.
+	 * It assumes (r0 << shift) can be computed without overflow and
+	 * that (r0 << shift) < 2 * r1. The quotient is stored in r3.
+	 */
+
+#  ifdef __ARM_FEATURE_CLZ
+	clz	ip, r0
+	clz	r3, r1
+	/* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */
+	sub	r3, r3, ip
+#    if __ARM_ARCH_ISA_THUMB == 2
+	adr	ip, LOCAL_LABEL(div0block) + 1
+	sub	ip, ip, r3, lsl #1
+#    else
+	adr	ip, LOCAL_LABEL(div0block)
+#    endif
+	sub	ip, ip, r3, lsl #2
+	sub	ip, ip, r3, lsl #3
+	mov	r3, #0
+	bx	ip
+#  else
+#    if __ARM_ARCH_ISA_THUMB == 2
+#    error THUMB mode requires CLZ or UDIV
+#    endif
+	mov	r2, r0
+	adr	ip, LOCAL_LABEL(div0block)
+
+	lsr	r3, r2, #16
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, ip, #(16 * 12)
+
+	lsr	r3, r2, #8
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, ip, #(8 * 12)
+
+	lsr	r3, r2, #4
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, #(4 * 12)
+
+	lsr	r3, r2, #2
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, ip, #(2 * 12)
+
+	/* Last block, no need to update r2 or r3. */
+	cmp	r1, r2, lsr #1
+	subls	ip, ip, #(1 * 12)
+
+	mov	r3, #0
+
+	JMP(ip)
+#  endif
+
+#define	IMM	#
+
+#define block(shift)                                                           \
+	cmp	r0, r1, lsl IMM shift;                                         \
+	ITT(hs);                                                               \
+	WIDE(addhs)	r3, r3, IMM (1 << shift);                              \
+	WIDE(subhs)	r0, r0, r1, lsl IMM shift
+
+	block(31)
+	block(30)
+	block(29)
+	block(28)
+	block(27)
+	block(26)
+	block(25)
+	block(24)
+	block(23)
+	block(22)
+	block(21)
+	block(20)
+	block(19)
+	block(18)
+	block(17)
+	block(16)
+	block(15)
+	block(14)
+	block(13)
+	block(12)
+	block(11)
+	block(10)
+	block(9)
+	block(8)
+	block(7)
+	block(6)
+	block(5)
+	block(4)
+	block(3)
+	block(2)
+	block(1)
+LOCAL_LABEL(div0block):
+	block(0)
+
+	mov	r0, r3
+	JMP(lr)
+#endif /* __ARM_ARCH_EXT_IDIV__ */
+
+LOCAL_LABEL(divby0):
+	mov	r0, #0
+#ifdef __ARM_EABI__
+	b	__aeabi_idiv0
+#else
+	JMP(lr)
+#endif
+
+END_COMPILERRT_FUNCTION(__udivsi3)
diff --git a/compiler-rt/lib/builtins/arm/umodsi3.S b/compiler-rt/lib/builtins/arm/umodsi3.S
new file mode 100644
index 0000000..9e7a148
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/umodsi3.S
@@ -0,0 +1,161 @@
+/*===-- umodsi3.S - 32-bit unsigned integer modulus -----------------------===//
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===//
+ *
+ * This file implements the __umodsi3 (32-bit unsigned integer modulus)
+ * function for the ARM 32-bit architecture.
+ *
+ *===----------------------------------------------------------------------===*/
+
+#include "../assembly.h"
+
+	.syntax unified
+	.text
+#if __ARM_ARCH_ISA_THUMB == 2
+	.thumb
+#endif
+
+@ unsigned int __umodsi3(unsigned int divident, unsigned int divisor)
+@   Calculate and return the remainder of the (unsigned) division.
+
+	.p2align 2
+#if __ARM_ARCH_ISA_THUMB == 2
+DEFINE_COMPILERRT_THUMB_FUNCTION(__umodsi3)
+#else
+DEFINE_COMPILERRT_FUNCTION(__umodsi3)
+#endif
+#if __ARM_ARCH_EXT_IDIV__
+	tst     r1, r1
+	beq     LOCAL_LABEL(divby0)
+	udiv	r2, r0, r1
+	mls 	r0, r2, r1, r0
+	bx  	lr
+#else
+	cmp	r1, #1
+	bcc	LOCAL_LABEL(divby0)
+	ITT(eq)
+	moveq	r0, #0
+	JMPc(lr, eq)
+	cmp	r0, r1
+	IT(cc)
+	JMPc(lr, cc)
+	/*
+	 * Implement division using binary long division algorithm.
+	 *
+	 * r0 is the numerator, r1 the denominator.
+	 *
+	 * The code before JMP computes the correct shift I, so that
+	 * r0 and (r1 << I) have the highest bit set in the same position.
+	 * At the time of JMP, ip := .Ldiv0block - 8 * I.
+	 * This depends on the fixed instruction size of block.
+	 * For ARM mode, this is 8 Bytes, for THUMB mode 10 Bytes.
+	 *
+	 * block(shift) implements the test-and-update-quotient core.
+	 * It assumes (r0 << shift) can be computed without overflow and
+	 * that (r0 << shift) < 2 * r1. The quotient is stored in r3.
+	 */
+
+#  ifdef __ARM_FEATURE_CLZ
+	clz	ip, r0
+	clz	r3, r1
+	/* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */
+	sub	r3, r3, ip
+#    if __ARM_ARCH_ISA_THUMB == 2
+	adr	ip, LOCAL_LABEL(div0block) + 1
+	sub	ip, ip, r3, lsl #1
+#    else
+	adr	ip, LOCAL_LABEL(div0block)
+#    endif
+	sub	ip, ip, r3, lsl #3
+	bx	ip
+#  else
+#    if __ARM_ARCH_ISA_THUMB == 2
+#    error THUMB mode requires CLZ or UDIV
+#    endif
+	mov	r2, r0
+	adr	ip, LOCAL_LABEL(div0block)
+
+	lsr	r3, r2, #16
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, ip, #(16 * 8)
+
+	lsr	r3, r2, #8
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, ip, #(8 * 8)
+
+	lsr	r3, r2, #4
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, #(4 * 8)
+
+	lsr	r3, r2, #2
+	cmp	r3, r1
+	movhs	r2, r3
+	subhs	ip, ip, #(2 * 8)
+
+	/* Last block, no need to update r2 or r3. */
+	cmp	r1, r2, lsr #1
+	subls	ip, ip, #(1 * 8)
+
+	JMP(ip)
+#  endif
+
+#define	IMM	#
+
+#define block(shift)                                                           \
+	cmp	r0, r1, lsl IMM shift;                                         \
+	IT(hs);                                                                \
+	WIDE(subhs)	r0, r0, r1, lsl IMM shift
+
+	block(31)
+	block(30)
+	block(29)
+	block(28)
+	block(27)
+	block(26)
+	block(25)
+	block(24)
+	block(23)
+	block(22)
+	block(21)
+	block(20)
+	block(19)
+	block(18)
+	block(17)
+	block(16)
+	block(15)
+	block(14)
+	block(13)
+	block(12)
+	block(11)
+	block(10)
+	block(9)
+	block(8)
+	block(7)
+	block(6)
+	block(5)
+	block(4)
+	block(3)
+	block(2)
+	block(1)
+LOCAL_LABEL(div0block):
+	block(0)
+	JMP(lr)
+#endif /* __ARM_ARCH_EXT_IDIV__ */
+
+LOCAL_LABEL(divby0):
+	mov	r0, #0
+#ifdef __ARM_EABI__
+	b	__aeabi_idiv0
+#else
+	JMP(lr)
+#endif
+
+END_COMPILERRT_FUNCTION(__umodsi3)
diff --git a/compiler-rt/lib/builtins/arm/unorddf2vfp.S b/compiler-rt/lib/builtins/arm/unorddf2vfp.S
new file mode 100644
index 0000000..c4bea2d
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/unorddf2vfp.S
@@ -0,0 +1,29 @@
+//===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __unorddf2vfp(double a, double b);
+//
+// Returns one iff a or b is NaN
+// Uses Darwin calling convention where double precision arguments are passsed 
+// like in GPR pairs.
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp)
+	vmov 	d6, r0, r1	// load r0/r1 pair in double register
+	vmov 	d7, r2, r3	// load r2/r3 pair in double register
+	vcmp.f64 d6, d7		
+	vmrs	apsr_nzcv, fpscr
+	movvs	r0, #1      // set result register to 1 if "overflow" (any NaNs)
+	movvc	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__unorddf2vfp)
diff --git a/compiler-rt/lib/builtins/arm/unordsf2vfp.S b/compiler-rt/lib/builtins/arm/unordsf2vfp.S
new file mode 100644
index 0000000..886e965
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm/unordsf2vfp.S
@@ -0,0 +1,29 @@
+//===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern int __unordsf2vfp(float a, float b);
+//
+// Returns one iff a or b is NaN
+// Uses Darwin calling convention where single precision arguments are passsed 
+// like 32-bit ints
+//
+	.syntax unified
+	.p2align 2
+DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp)
+	vmov	s14, r0     // move from GPR 0 to float register
+	vmov	s15, r1	    // move from GPR 1 to float register
+	vcmp.f32 s14, s15
+	vmrs	apsr_nzcv, fpscr
+	movvs	r0, #1      // set result register to 1 if "overflow" (any NaNs)
+	movvc	r0, #0
+	bx	lr
+END_COMPILERRT_FUNCTION(__unordsf2vfp)
diff --git a/compiler-rt/lib/builtins/arm64/Makefile.mk b/compiler-rt/lib/builtins/arm64/Makefile.mk
new file mode 100644
index 0000000..7f7e386
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm64/Makefile.mk
@@ -0,0 +1,20 @@
+#===- lib/builtins/arm64/Makefile.mk -----------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs := 
+OnlyArchs := arm64 
+
+AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
+Implementation := Optimized
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard lib/*.h $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/arm64/dummy.c b/compiler-rt/lib/builtins/arm64/dummy.c
new file mode 100644
index 0000000..76bec30
--- /dev/null
+++ b/compiler-rt/lib/builtins/arm64/dummy.c
@@ -0,0 +1,13 @@
+/* ===---------- dummy.c - Implements dummy function, for bringup -----------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+static void dummy(void) __attribute__((used));
+
+static void dummy(void) {}
diff --git a/compiler-rt/lib/builtins/armv6m/Makefile.mk b/compiler-rt/lib/builtins/armv6m/Makefile.mk
new file mode 100644
index 0000000..f3c1807
--- /dev/null
+++ b/compiler-rt/lib/builtins/armv6m/Makefile.mk
@@ -0,0 +1,20 @@
+#===- lib/builtins/arm/Makefile.mk -------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs := 
+OnlyArchs := armv6m
+
+AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
+Implementation := Optimized
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard lib/*.h $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/ashldi3.c b/compiler-rt/lib/builtins/ashldi3.c
new file mode 100644
index 0000000..eb4698a
--- /dev/null
+++ b/compiler-rt/lib/builtins/ashldi3.c
@@ -0,0 +1,43 @@
+/* ====-- ashldi3.c - Implement __ashldi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ashldi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a << b */
+
+/* Precondition:  0 <= b < bits_in_dword */
+
+ARM_EABI_FNALIAS(llsl, ashldi3)
+
+COMPILER_RT_ABI di_int
+__ashldi3(di_int a, si_int b)
+{
+    const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);
+    dwords input;
+    dwords result;
+    input.all = a;
+    if (b & bits_in_word)  /* bits_in_word <= b < bits_in_dword */
+    {
+        result.s.low = 0;
+        result.s.high = input.s.low << (b - bits_in_word);
+    }
+    else  /* 0 <= b < bits_in_word */
+    {
+        if (b == 0)
+            return a;
+        result.s.low  = input.s.low << b;
+        result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_word - b));
+    }
+    return result.all;
+}
diff --git a/compiler-rt/lib/builtins/ashlti3.c b/compiler-rt/lib/builtins/ashlti3.c
new file mode 100644
index 0000000..638ae84
--- /dev/null
+++ b/compiler-rt/lib/builtins/ashlti3.c
@@ -0,0 +1,45 @@
+/* ===-- ashlti3.c - Implement __ashlti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ashlti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a << b */
+
+/* Precondition:  0 <= b < bits_in_tword */
+
+COMPILER_RT_ABI ti_int
+__ashlti3(ti_int a, si_int b)
+{
+    const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
+    twords input;
+    twords result;
+    input.all = a;
+    if (b & bits_in_dword)  /* bits_in_dword <= b < bits_in_tword */
+    {
+        result.s.low = 0;
+        result.s.high = input.s.low << (b - bits_in_dword);
+    }
+    else  /* 0 <= b < bits_in_dword */
+    {
+        if (b == 0)
+            return a;
+        result.s.low  = input.s.low << b;
+        result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_dword - b));
+    }
+    return result.all;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/ashrdi3.c b/compiler-rt/lib/builtins/ashrdi3.c
new file mode 100644
index 0000000..14c878b
--- /dev/null
+++ b/compiler-rt/lib/builtins/ashrdi3.c
@@ -0,0 +1,44 @@
+/*===-- ashrdi3.c - Implement __ashrdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ashrdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: arithmetic a >> b */
+
+/* Precondition:  0 <= b < bits_in_dword */
+
+ARM_EABI_FNALIAS(lasr, ashrdi3)
+
+COMPILER_RT_ABI di_int
+__ashrdi3(di_int a, si_int b)
+{
+    const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);
+    dwords input;
+    dwords result;
+    input.all = a;
+    if (b & bits_in_word)  /* bits_in_word <= b < bits_in_dword */
+    {
+        /* result.s.high = input.s.high < 0 ? -1 : 0 */
+        result.s.high = input.s.high >> (bits_in_word - 1);
+        result.s.low = input.s.high >> (b - bits_in_word);
+    }
+    else  /* 0 <= b < bits_in_word */
+    {
+        if (b == 0)
+            return a;
+        result.s.high  = input.s.high >> b;
+        result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b);
+    }
+    return result.all;
+}
diff --git a/compiler-rt/lib/builtins/ashrti3.c b/compiler-rt/lib/builtins/ashrti3.c
new file mode 100644
index 0000000..f78205d
--- /dev/null
+++ b/compiler-rt/lib/builtins/ashrti3.c
@@ -0,0 +1,46 @@
+/* ===-- ashrti3.c - Implement __ashrti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ashrti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: arithmetic a >> b */
+
+/* Precondition:  0 <= b < bits_in_tword */
+
+COMPILER_RT_ABI ti_int
+__ashrti3(ti_int a, si_int b)
+{
+    const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
+    twords input;
+    twords result;
+    input.all = a;
+    if (b & bits_in_dword)  /* bits_in_dword <= b < bits_in_tword */
+    {
+        /* result.s.high = input.s.high < 0 ? -1 : 0 */
+        result.s.high = input.s.high >> (bits_in_dword - 1);
+        result.s.low = input.s.high >> (b - bits_in_dword);
+    }
+    else  /* 0 <= b < bits_in_dword */
+    {
+        if (b == 0)
+            return a;
+        result.s.high  = input.s.high >> b;
+        result.s.low = (input.s.high << (bits_in_dword - b)) | (input.s.low >> b);
+    }
+    return result.all;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/assembly.h b/compiler-rt/lib/builtins/assembly.h
new file mode 100644
index 0000000..c289705
--- /dev/null
+++ b/compiler-rt/lib/builtins/assembly.h
@@ -0,0 +1,158 @@
+/* ===-- assembly.h - compiler-rt assembler support macros -----------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file defines macros for use in compiler-rt assembler source.
+ * This file is not part of the interface of this library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifndef COMPILERRT_ASSEMBLY_H
+#define COMPILERRT_ASSEMBLY_H
+
+#if defined(__POWERPC__) || defined(__powerpc__) || defined(__ppc__)
+#define SEPARATOR @
+#else
+#define SEPARATOR ;
+#endif
+
+#if defined(__APPLE__)
+#define HIDDEN(name) .private_extern name
+#define LOCAL_LABEL(name) L_##name
+// tell linker it can break up file at label boundaries
+#define FILE_LEVEL_DIRECTIVE .subsections_via_symbols
+#define SYMBOL_IS_FUNC(name)
+#define CONST_SECTION .const
+
+#elif defined(__ELF__)
+
+#define HIDDEN(name) .hidden name
+#define LOCAL_LABEL(name) .L_##name
+#define FILE_LEVEL_DIRECTIVE
+#if defined(__arm__)
+#define SYMBOL_IS_FUNC(name) .type name,%function
+#else
+#define SYMBOL_IS_FUNC(name) .type name,@function
+#endif
+#define CONST_SECTION .section .rodata
+
+#else // !__APPLE__ && !__ELF__
+
+#define HIDDEN(name)
+#define LOCAL_LABEL(name) .L ## name
+#define FILE_LEVEL_DIRECTIVE
+#define SYMBOL_IS_FUNC(name)                                                   \
+  .def name SEPARATOR                                                          \
+    .scl 2 SEPARATOR                                                           \
+    .type 32 SEPARATOR                                                         \
+  .endef
+#define CONST_SECTION .section .rdata,"rd"
+
+#endif
+
+#if defined(__arm__)
+#if defined(__ARM_ARCH_4T__) || __ARM_ARCH >= 5
+#define ARM_HAS_BX
+#endif
+#if !defined(__ARM_FEATURE_CLZ) &&                                             \
+    (__ARM_ARCH >= 6 || (__ARM_ARCH == 5 && !defined(__ARM_ARCH_5__)))
+#define __ARM_FEATURE_CLZ
+#endif
+
+#ifdef ARM_HAS_BX
+#define JMP(r) bx r
+#define JMPc(r, c) bx##c r
+#else
+#define JMP(r) mov pc, r
+#define JMPc(r, c) mov##c pc, r
+#endif
+
+// pop {pc} can't switch Thumb mode on ARMv4T
+#if __ARM_ARCH >= 5
+#define POP_PC() pop {pc}
+#else
+#define POP_PC()                                                               \
+  pop {ip};                                                                    \
+  JMP(ip)
+#endif
+
+#if __ARM_ARCH_ISA_THUMB == 2
+#define IT(cond)  it cond
+#define ITT(cond) itt cond
+#else
+#define IT(cond)
+#define ITT(cond)
+#endif
+
+#if __ARM_ARCH_ISA_THUMB == 2
+#define WIDE(op) op.w
+#else
+#define WIDE(op) op
+#endif
+#endif
+
+#define GLUE2(a, b) a##b
+#define GLUE(a, b) GLUE2(a, b)
+#define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
+
+#ifdef VISIBILITY_HIDDEN
+#define DECLARE_SYMBOL_VISIBILITY(name)                                        \
+  HIDDEN(SYMBOL_NAME(name)) SEPARATOR
+#else
+#define DECLARE_SYMBOL_VISIBILITY(name)
+#endif
+
+#define DEFINE_COMPILERRT_FUNCTION(name)                                       \
+  FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  DECLARE_SYMBOL_VISIBILITY(name)                                              \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_THUMB_FUNCTION(name)                                 \
+  FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
+  .thumb_func SEPARATOR                                                        \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name)                               \
+  FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  HIDDEN(SYMBOL_NAME(name)) SEPARATOR                                          \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name)                     \
+  .globl name SEPARATOR                                                        \
+  SYMBOL_IS_FUNC(name) SEPARATOR                                               \
+  HIDDEN(name) SEPARATOR                                                       \
+  name:
+
+#define DEFINE_COMPILERRT_FUNCTION_ALIAS(name, target)                         \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  .set SYMBOL_NAME(name), SYMBOL_NAME(target) SEPARATOR
+
+#if defined(__ARM_EABI__)
+#define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)                          \
+  DEFINE_COMPILERRT_FUNCTION_ALIAS(aeabi_name, name)
+#else
+#define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)
+#endif
+
+#ifdef __ELF__
+#define END_COMPILERRT_FUNCTION(name)                                          \
+  .size SYMBOL_NAME(name), . - SYMBOL_NAME(name)
+#else
+#define END_COMPILERRT_FUNCTION(name)
+#endif
+
+#endif /* COMPILERRT_ASSEMBLY_H */
diff --git a/compiler-rt/lib/builtins/atomic.c b/compiler-rt/lib/builtins/atomic.c
new file mode 100644
index 0000000..f1ddc3e
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic.c
@@ -0,0 +1,331 @@
+/*===-- atomic.c - Implement support functions for atomic operations.------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ *  atomic.c defines a set of functions for performing atomic accesses on
+ *  arbitrary-sized memory locations.  This design uses locks that should
+ *  be fast in the uncontended case, for two reasons:
+ * 
+ *  1) This code must work with C programs that do not link to anything
+ *     (including pthreads) and so it should not depend on any pthread
+ *     functions.
+ *  2) Atomic operations, rather than explicit mutexes, are most commonly used
+ *     on code where contended operations are rate.
+ * 
+ *  To avoid needing a per-object lock, this code allocates an array of
+ *  locks and hashes the object pointers to find the one that it should use.
+ *  For operations that must be atomic on two locations, the lower lock is
+ *  always acquired first, to avoid deadlock.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "assembly.h"
+
+// Clang objects if you redefine a builtin.  This little hack allows us to
+// define a function with the same name as an intrinsic.
+#pragma redefine_extname __atomic_load_c SYMBOL_NAME(__atomic_load)
+#pragma redefine_extname __atomic_store_c SYMBOL_NAME(__atomic_store)
+#pragma redefine_extname __atomic_exchange_c SYMBOL_NAME(__atomic_exchange)
+#pragma redefine_extname __atomic_compare_exchange_c SYMBOL_NAME(__atomic_compare_exchange)
+
+/// Number of locks.  This allocates one page on 32-bit platforms, two on
+/// 64-bit.  This can be specified externally if a different trade between
+/// memory usage and contention probability is required for a given platform.
+#ifndef SPINLOCK_COUNT
+#define SPINLOCK_COUNT (1<<10)
+#endif
+static const long SPINLOCK_MASK = SPINLOCK_COUNT - 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// Platform-specific lock implementation.  Falls back to spinlocks if none is
+// defined.  Each platform should define the Lock type, and corresponding
+// lock() and unlock() functions.
+////////////////////////////////////////////////////////////////////////////////
+#ifdef __FreeBSD__
+#include <errno.h>
+#include <sys/types.h>
+#include <machine/atomic.h>
+#include <sys/umtx.h>
+typedef struct _usem Lock;
+__inline static void unlock(Lock *l) {
+  __c11_atomic_store((_Atomic(uint32_t)*)&l->_count, 1, __ATOMIC_RELEASE);
+  __c11_atomic_thread_fence(__ATOMIC_SEQ_CST);
+  if (l->_has_waiters)
+      _umtx_op(l, UMTX_OP_SEM_WAKE, 1, 0, 0);
+}
+__inline static void lock(Lock *l) {
+  uint32_t old = 1;
+  while (!__c11_atomic_compare_exchange_weak((_Atomic(uint32_t)*)&l->_count, &old,
+        0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
+    _umtx_op(l, UMTX_OP_SEM_WAIT, 0, 0, 0);
+    old = 1;
+  }
+}
+/// locks for atomic operations
+static Lock locks[SPINLOCK_COUNT] = { [0 ...  SPINLOCK_COUNT-1] = {0,1,0} };
+
+#elif defined(__APPLE__)
+#include <libkern/OSAtomic.h>
+typedef OSSpinLock Lock;
+__inline static void unlock(Lock *l) {
+  OSSpinLockUnlock(l);
+}
+/// Locks a lock.  In the current implementation, this is potentially
+/// unbounded in the contended case.
+__inline static void lock(Lock *l) {
+  OSSpinLockLock(l);
+}
+static Lock locks[SPINLOCK_COUNT]; // initialized to OS_SPINLOCK_INIT which is 0
+
+#else
+typedef _Atomic(uintptr_t) Lock;
+/// Unlock a lock.  This is a release operation.
+__inline static void unlock(Lock *l) {
+  __c11_atomic_store(l, 0, __ATOMIC_RELEASE);
+}
+/// Locks a lock.  In the current implementation, this is potentially
+/// unbounded in the contended case.
+__inline static void lock(Lock *l) {
+  uintptr_t old = 0;
+  while (!__c11_atomic_compare_exchange_weak(l, &old, 1, __ATOMIC_ACQUIRE,
+        __ATOMIC_RELAXED))
+    old = 0;
+}
+/// locks for atomic operations
+static Lock locks[SPINLOCK_COUNT];
+#endif
+
+
+/// Returns a lock to use for a given pointer.  
+static __inline Lock *lock_for_pointer(void *ptr) {
+  intptr_t hash = (intptr_t)ptr;
+  // Disregard the lowest 4 bits.  We want all values that may be part of the
+  // same memory operation to hash to the same value and therefore use the same
+  // lock.  
+  hash >>= 4;
+  // Use the next bits as the basis for the hash
+  intptr_t low = hash & SPINLOCK_MASK;
+  // Now use the high(er) set of bits to perturb the hash, so that we don't
+  // get collisions from atomic fields in a single object
+  hash >>= 16;
+  hash ^= low;
+  // Return a pointer to the word to use
+  return locks + (hash & SPINLOCK_MASK);
+}
+
+/// Macros for determining whether a size is lock free.  Clang can not yet
+/// codegen __atomic_is_lock_free(16), so for now we assume 16-byte values are
+/// not lock free.
+#define IS_LOCK_FREE_1 __c11_atomic_is_lock_free(1)
+#define IS_LOCK_FREE_2 __c11_atomic_is_lock_free(2)
+#define IS_LOCK_FREE_4 __c11_atomic_is_lock_free(4)
+#define IS_LOCK_FREE_8 __c11_atomic_is_lock_free(8)
+#define IS_LOCK_FREE_16 0
+
+/// Macro that calls the compiler-generated lock-free versions of functions
+/// when they exist.
+#define LOCK_FREE_CASES() \
+  do {\
+  switch (size) {\
+    case 2:\
+      if (IS_LOCK_FREE_2) {\
+        LOCK_FREE_ACTION(uint16_t);\
+      }\
+    case 4:\
+      if (IS_LOCK_FREE_4) {\
+        LOCK_FREE_ACTION(uint32_t);\
+      }\
+    case 8:\
+      if (IS_LOCK_FREE_8) {\
+        LOCK_FREE_ACTION(uint64_t);\
+      }\
+    case 16:\
+      if (IS_LOCK_FREE_16) {\
+        /* FIXME: __uint128_t isn't available on 32 bit platforms.
+        LOCK_FREE_ACTION(__uint128_t);*/\
+      }\
+  }\
+  } while (0)
+
+
+/// An atomic load operation.  This is atomic with respect to the source
+/// pointer only.
+void __atomic_load_c(int size, void *src, void *dest, int model) {
+#define LOCK_FREE_ACTION(type) \
+    *((type*)dest) = __c11_atomic_load((_Atomic(type)*)src, model);\
+    return;
+  LOCK_FREE_CASES();
+#undef LOCK_FREE_ACTION
+  Lock *l = lock_for_pointer(src);
+  lock(l);
+  memcpy(dest, src, size);
+  unlock(l);
+}
+
+/// An atomic store operation.  This is atomic with respect to the destination
+/// pointer only.
+void __atomic_store_c(int size, void *dest, void *src, int model) {
+#define LOCK_FREE_ACTION(type) \
+    __c11_atomic_store((_Atomic(type)*)dest, *(type*)dest, model);\
+    return;
+  LOCK_FREE_CASES();
+#undef LOCK_FREE_ACTION
+  Lock *l = lock_for_pointer(dest);
+  lock(l);
+  memcpy(dest, src, size);
+  unlock(l);
+}
+
+/// Atomic compare and exchange operation.  If the value at *ptr is identical
+/// to the value at *expected, then this copies value at *desired to *ptr.  If
+/// they  are not, then this stores the current value from *ptr in *expected.
+///
+/// This function returns 1 if the exchange takes place or 0 if it fails. 
+int __atomic_compare_exchange_c(int size, void *ptr, void *expected,
+    void *desired, int success, int failure) {
+#define LOCK_FREE_ACTION(type) \
+  return __c11_atomic_compare_exchange_strong((_Atomic(type)*)ptr, (type*)expected,\
+      *(type*)desired, success, failure)
+  LOCK_FREE_CASES();
+#undef LOCK_FREE_ACTION
+  Lock *l = lock_for_pointer(ptr);
+  lock(l);
+  if (memcmp(ptr, expected, size) == 0) {
+    memcpy(ptr, desired, size);
+    unlock(l);
+    return 1;
+  }
+  memcpy(expected, ptr, size);
+  unlock(l);
+  return 0;
+}
+
+/// Performs an atomic exchange operation between two pointers.  This is atomic
+/// with respect to the target address.
+void __atomic_exchange_c(int size, void *ptr, void *val, void *old, int model) {
+#define LOCK_FREE_ACTION(type) \
+    *(type*)old = __c11_atomic_exchange((_Atomic(type)*)ptr, *(type*)val,\
+        model);\
+    return;
+  LOCK_FREE_CASES();
+#undef LOCK_FREE_ACTION
+  Lock *l = lock_for_pointer(ptr);
+  lock(l);
+  memcpy(old, ptr, size);
+  memcpy(ptr, val, size);
+  unlock(l);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Where the size is known at compile time, the compiler may emit calls to
+// specialised versions of the above functions.
+////////////////////////////////////////////////////////////////////////////////
+#define OPTIMISED_CASES\
+  OPTIMISED_CASE(1, IS_LOCK_FREE_1, uint8_t)\
+  OPTIMISED_CASE(2, IS_LOCK_FREE_2, uint16_t)\
+  OPTIMISED_CASE(4, IS_LOCK_FREE_4, uint32_t)\
+  OPTIMISED_CASE(8, IS_LOCK_FREE_8, uint64_t)\
+  /* FIXME: __uint128_t isn't available on 32 bit platforms.
+  OPTIMISED_CASE(16, IS_LOCK_FREE_16, __uint128_t)*/\
+
+#define OPTIMISED_CASE(n, lockfree, type)\
+type __atomic_load_##n(type *src, int model) {\
+  if (lockfree)\
+    return __c11_atomic_load((_Atomic(type)*)src, model);\
+  Lock *l = lock_for_pointer(src);\
+  lock(l);\
+  type val = *src;\
+  unlock(l);\
+  return val;\
+}
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+
+#define OPTIMISED_CASE(n, lockfree, type)\
+void  __atomic_store_##n(type *dest, type val, int model) {\
+  if (lockfree) {\
+    __c11_atomic_store((_Atomic(type)*)dest, val, model);\
+    return;\
+  }\
+  Lock *l = lock_for_pointer(dest);\
+  lock(l);\
+  *dest = val;\
+  unlock(l);\
+  return;\
+}
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+
+#define OPTIMISED_CASE(n, lockfree, type)\
+type __atomic_exchange_##n(type *dest, type val, int model) {\
+  if (lockfree)\
+    return __c11_atomic_exchange((_Atomic(type)*)dest, val, model);\
+  Lock *l = lock_for_pointer(dest);\
+  lock(l);\
+  type tmp = *dest;\
+  *dest = val;\
+  unlock(l);\
+  return tmp;\
+}
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+
+#define OPTIMISED_CASE(n, lockfree, type)\
+int __atomic_compare_exchange_##n(type *ptr, type *expected, type desired,\
+    int success, int failure) {\
+  if (lockfree)\
+    return __c11_atomic_compare_exchange_strong((_Atomic(type)*)ptr, expected, desired,\
+        success, failure);\
+  Lock *l = lock_for_pointer(ptr);\
+  lock(l);\
+  if (*ptr == *expected) {\
+    *ptr = desired;\
+    unlock(l);\
+    return 1;\
+  }\
+  *expected = *ptr;\
+  unlock(l);\
+  return 0;\
+}
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+
+////////////////////////////////////////////////////////////////////////////////
+// Atomic read-modify-write operations for integers of various sizes.
+////////////////////////////////////////////////////////////////////////////////
+#define ATOMIC_RMW(n, lockfree, type, opname, op) \
+type __atomic_fetch_##opname##_##n(type *ptr, type val, int model) {\
+  if (lockfree) \
+    return __c11_atomic_fetch_##opname((_Atomic(type)*)ptr, val, model);\
+  Lock *l = lock_for_pointer(ptr);\
+  lock(l);\
+  type tmp = *ptr;\
+  *ptr = tmp op val;\
+  unlock(l);\
+  return tmp;\
+}
+
+#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, add, +)
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, sub, -)
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, and, &)
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, or, |)
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
+#define OPTIMISED_CASE(n, lockfree, type) ATOMIC_RMW(n, lockfree, type, xor, ^)
+OPTIMISED_CASES
+#undef OPTIMISED_CASE
diff --git a/compiler-rt/lib/builtins/atomic_flag_clear.c b/compiler-rt/lib/builtins/atomic_flag_clear.c
new file mode 100644
index 0000000..da912af
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic_flag_clear.c
@@ -0,0 +1,27 @@
+/*===-- atomic_flag_clear.c -------------------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===------------------------------------------------------------------------===
+ *
+ * This file implements atomic_flag_clear from C11's stdatomic.h.
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __has_include
+#define __has_include(inc) 0
+#endif
+
+#if __has_include(<stdatomic.h>)
+
+#include <stdatomic.h>
+#undef atomic_flag_clear
+void atomic_flag_clear(volatile atomic_flag *object) {
+  __c11_atomic_store(&(object)->_Value, 0, __ATOMIC_SEQ_CST);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/atomic_flag_clear_explicit.c b/compiler-rt/lib/builtins/atomic_flag_clear_explicit.c
new file mode 100644
index 0000000..1059b78
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic_flag_clear_explicit.c
@@ -0,0 +1,28 @@
+/*===-- atomic_flag_clear_explicit.c ----------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===------------------------------------------------------------------------===
+ *
+ * This file implements atomic_flag_clear_explicit from C11's stdatomic.h.
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __has_include
+#define __has_include(inc) 0
+#endif
+
+#if __has_include(<stdatomic.h>)
+
+#include <stdatomic.h>
+#undef atomic_flag_clear_explicit
+void atomic_flag_clear_explicit(volatile atomic_flag *object,
+                                memory_order order) {
+  __c11_atomic_store(&(object)->_Value, 0, order);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/atomic_flag_test_and_set.c b/compiler-rt/lib/builtins/atomic_flag_test_and_set.c
new file mode 100644
index 0000000..e8811d3
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic_flag_test_and_set.c
@@ -0,0 +1,27 @@
+/*===-- atomic_flag_test_and_set.c ------------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===------------------------------------------------------------------------===
+ *
+ * This file implements atomic_flag_test_and_set from C11's stdatomic.h.
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __has_include
+#define __has_include(inc) 0
+#endif
+
+#if __has_include(<stdatomic.h>)
+
+#include <stdatomic.h>
+#undef atomic_flag_test_and_set
+_Bool atomic_flag_test_and_set(volatile atomic_flag *object) {
+  return __c11_atomic_exchange(&(object)->_Value, 1, __ATOMIC_SEQ_CST);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/atomic_flag_test_and_set_explicit.c b/compiler-rt/lib/builtins/atomic_flag_test_and_set_explicit.c
new file mode 100644
index 0000000..5c8c2df
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic_flag_test_and_set_explicit.c
@@ -0,0 +1,28 @@
+/*===-- atomic_flag_test_and_set_explicit.c ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===------------------------------------------------------------------------===
+ *
+ * This file implements atomic_flag_test_and_set_explicit from C11's stdatomic.h
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __has_include
+#define __has_include(inc) 0
+#endif
+
+#if __has_include(<stdatomic.h>)
+
+#include <stdatomic.h>
+#undef atomic_flag_test_and_set_explicit
+_Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
+                                        memory_order order) {
+  return __c11_atomic_exchange(&(object)->_Value, 1, order);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/atomic_signal_fence.c b/compiler-rt/lib/builtins/atomic_signal_fence.c
new file mode 100644
index 0000000..9ccc2ae
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic_signal_fence.c
@@ -0,0 +1,27 @@
+/*===-- atomic_signal_fence.c -----------------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===------------------------------------------------------------------------===
+ *
+ * This file implements atomic_signal_fence from C11's stdatomic.h.
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __has_include
+#define __has_include(inc) 0
+#endif
+
+#if __has_include(<stdatomic.h>)
+
+#include <stdatomic.h>
+#undef atomic_signal_fence
+void atomic_signal_fence(memory_order order) {
+  __c11_atomic_signal_fence(order);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/atomic_thread_fence.c b/compiler-rt/lib/builtins/atomic_thread_fence.c
new file mode 100644
index 0000000..d225601
--- /dev/null
+++ b/compiler-rt/lib/builtins/atomic_thread_fence.c
@@ -0,0 +1,27 @@
+/*===-- atomic_thread_fence.c -----------------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===------------------------------------------------------------------------===
+ *
+ * This file implements atomic_thread_fence from C11's stdatomic.h.
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __has_include
+#define __has_include(inc) 0
+#endif
+
+#if __has_include(<stdatomic.h>)
+
+#include <stdatomic.h>
+#undef atomic_thread_fence
+void atomic_thread_fence(memory_order order) {
+  __c11_atomic_thread_fence(order);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/clear_cache.c b/compiler-rt/lib/builtins/clear_cache.c
new file mode 100644
index 0000000..ede7659
--- /dev/null
+++ b/compiler-rt/lib/builtins/clear_cache.c
@@ -0,0 +1,159 @@
+/* ===-- clear_cache.c - Implement __clear_cache ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stddef.h>
+
+#if __APPLE__
+  #include <libkern/OSCacheControl.h>
+#endif
+#if (defined(__FreeBSD__) || defined(__Bitrig__)) && defined(__arm__)
+  #include <sys/types.h>
+  #include <machine/sysarch.h>
+#endif
+
+#if defined(__NetBSD__) && defined(__arm__)
+  #include <machine/sysarch.h>
+#endif
+
+#if defined(__mips__)
+  #include <sys/cachectl.h>
+  #include <sys/syscall.h>
+  #include <unistd.h>
+  #if defined(__ANDROID__) && defined(__LP64__)
+    /*
+     * clear_mips_cache - Invalidates instruction cache for Mips.
+     */
+    static void clear_mips_cache(const void* Addr, size_t Size) {
+      asm volatile (
+        ".set push\n"
+        ".set noreorder\n"
+        ".set noat\n"
+        "beq %[Size], $zero, 20f\n"          /* If size == 0, branch around. */
+        "nop\n"
+        "daddu %[Size], %[Addr], %[Size]\n"  /* Calculate end address + 1 */
+        "rdhwr $v0, $1\n"                    /* Get step size for SYNCI.
+                                                $1 is $HW_SYNCI_Step */
+        "beq $v0, $zero, 20f\n"              /* If no caches require
+                                                synchronization, branch
+                                                around. */
+        "nop\n"
+        "10:\n"
+        "synci 0(%[Addr])\n"                 /* Synchronize all caches around
+                                                address. */
+        "daddu %[Addr], %[Addr], $v0\n"      /* Add step size. */
+        "sltu $at, %[Addr], %[Size]\n"       /* Compare current with end
+                                                address. */
+        "bne $at, $zero, 10b\n"              /* Branch if more to do. */
+        "nop\n"
+        "sync\n"                             /* Clear memory hazards. */
+        "20:\n"
+        "bal 30f\n"
+        "nop\n"
+        "30:\n"
+        "daddiu $ra, $ra, 12\n"              /* $ra has a value of $pc here.
+                                                Add offset of 12 to point to the
+                                                instruction after the last nop.
+                                              */
+        "jr.hb $ra\n"                        /* Return, clearing instruction
+                                                hazards. */
+        "nop\n"
+        ".set pop\n"
+        : [Addr] "+r"(Addr), [Size] "+r"(Size)
+        :: "at", "ra", "v0", "memory"
+      );
+    }
+  #endif
+#endif
+
+#if defined(__ANDROID__) && defined(__arm__)
+  #include <asm/unistd.h>
+#endif
+
+/*
+ * The compiler generates calls to __clear_cache() when creating 
+ * trampoline functions on the stack for use with nested functions.
+ * It is expected to invalidate the instruction cache for the 
+ * specified range.
+ */
+
+void __clear_cache(void *start, void *end) {
+#if __i386__ || __x86_64__
+/*
+ * Intel processors have a unified instruction and data cache
+ * so there is nothing to do
+ */
+#elif defined(__arm__) && !defined(__APPLE__)
+    #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__Bitrig__)
+        struct arm_sync_icache_args arg;
+
+        arg.addr = (uintptr_t)start;
+        arg.len = (uintptr_t)end - (uintptr_t)start;
+
+        sysarch(ARM_SYNC_ICACHE, &arg);
+    #elif defined(__ANDROID__)
+         register int start_reg __asm("r0") = (int) (intptr_t) start;
+         const register int end_reg __asm("r1") = (int) (intptr_t) end;
+         const register int flags __asm("r2") = 0;
+         const register int syscall_nr __asm("r7") = __ARM_NR_cacheflush;
+        __asm __volatile("svc 0x0" : "=r"(start_reg)
+            : "r"(syscall_nr), "r"(start_reg), "r"(end_reg), "r"(flags) : "r0");
+         if (start_reg != 0) {
+             compilerrt_abort();
+         }
+    #else
+        compilerrt_abort();
+    #endif
+#elif defined(__mips__)
+  const uintptr_t start_int = (uintptr_t) start;
+  const uintptr_t end_int = (uintptr_t) end;
+    #if defined(__ANDROID__) && defined(__LP64__)
+        // Call synci implementation for short address range.
+        const uintptr_t address_range_limit = 256;
+        if ((end_int - start_int) <= address_range_limit) {
+            clear_mips_cache(start, (end_int - start_int));
+        } else {
+            syscall(__NR_cacheflush, start, (end_int - start_int), BCACHE);
+        }
+    #else
+        syscall(__NR_cacheflush, start, (end_int - start_int), BCACHE);
+    #endif
+#elif defined(__aarch64__) && !defined(__APPLE__)
+  uint64_t xstart = (uint64_t)(uintptr_t) start;
+  uint64_t xend = (uint64_t)(uintptr_t) end;
+  uint64_t addr;
+
+  // Get Cache Type Info
+  uint64_t ctr_el0;
+  __asm __volatile("mrs %0, ctr_el0" : "=r"(ctr_el0));
+
+  /*
+   * dc & ic instructions must use 64bit registers so we don't use
+   * uintptr_t in case this runs in an IPL32 environment.
+   */
+  const size_t dcache_line_size = 4 << ((ctr_el0 >> 16) & 15);
+  for (addr = xstart; addr < xend; addr += dcache_line_size)
+    __asm __volatile("dc cvau, %0" :: "r"(addr));
+  __asm __volatile("dsb ish");
+
+  const size_t icache_line_size = 4 << ((ctr_el0 >> 0) & 15);
+  for (addr = xstart; addr < xend; addr += icache_line_size)
+    __asm __volatile("ic ivau, %0" :: "r"(addr));
+  __asm __volatile("isb sy");
+#else
+    #if __APPLE__
+        /* On Darwin, sys_icache_invalidate() provides this functionality */
+        sys_icache_invalidate(start, end-start);
+    #else
+        compilerrt_abort();
+    #endif
+#endif
+}
+
diff --git a/compiler-rt/lib/builtins/clzdi2.c b/compiler-rt/lib/builtins/clzdi2.c
new file mode 100644
index 0000000..b9e64da
--- /dev/null
+++ b/compiler-rt/lib/builtins/clzdi2.c
@@ -0,0 +1,29 @@
+/* ===-- clzdi2.c - Implement __clzdi2 -------------------------------------===
+ *
+ *               The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __clzdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: the number of leading 0-bits */
+
+/* Precondition: a != 0 */
+
+COMPILER_RT_ABI si_int
+__clzdi2(di_int a)
+{
+    dwords x;
+    x.all = a;
+    const si_int f = -(x.s.high == 0);
+    return __builtin_clz((x.s.high & ~f) | (x.s.low & f)) +
+           (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
+}
diff --git a/compiler-rt/lib/builtins/clzsi2.c b/compiler-rt/lib/builtins/clzsi2.c
new file mode 100644
index 0000000..25b8ed2
--- /dev/null
+++ b/compiler-rt/lib/builtins/clzsi2.c
@@ -0,0 +1,53 @@
+/* ===-- clzsi2.c - Implement __clzsi2 -------------------------------------===
+ *
+ *               The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __clzsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: the number of leading 0-bits */
+
+/* Precondition: a != 0 */
+
+COMPILER_RT_ABI si_int
+__clzsi2(si_int a)
+{
+    su_int x = (su_int)a;
+    si_int t = ((x & 0xFFFF0000) == 0) << 4;  /* if (x is small) t = 16 else 0 */
+    x >>= 16 - t;      /* x = [0 - 0xFFFF] */
+    su_int r = t;       /* r = [0, 16] */
+    /* return r + clz(x) */
+    t = ((x & 0xFF00) == 0) << 3;
+    x >>= 8 - t;       /* x = [0 - 0xFF] */
+    r += t;            /* r = [0, 8, 16, 24] */
+    /* return r + clz(x) */
+    t = ((x & 0xF0) == 0) << 2;
+    x >>= 4 - t;       /* x = [0 - 0xF] */
+    r += t;            /* r = [0, 4, 8, 12, 16, 20, 24, 28] */
+    /* return r + clz(x) */
+    t = ((x & 0xC) == 0) << 1;
+    x >>= 2 - t;       /* x = [0 - 3] */
+    r += t;            /* r = [0 - 30] and is even */
+    /* return r + clz(x) */
+/*     switch (x)
+ *     {
+ *     case 0:
+ *         return r + 2;
+ *     case 1:
+ *         return r + 1;
+ *     case 2:
+ *     case 3:
+ *         return r;
+ *     }
+ */
+    return r + ((2 - x) & -((x & 2) == 0));
+}
diff --git a/compiler-rt/lib/builtins/clzti2.c b/compiler-rt/lib/builtins/clzti2.c
new file mode 100644
index 0000000..15a7b3c
--- /dev/null
+++ b/compiler-rt/lib/builtins/clzti2.c
@@ -0,0 +1,33 @@
+/* ===-- clzti2.c - Implement __clzti2 -------------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __clzti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: the number of leading 0-bits */
+
+/* Precondition: a != 0 */
+
+COMPILER_RT_ABI si_int
+__clzti2(ti_int a)
+{
+    twords x;
+    x.all = a;
+    const di_int f = -(x.s.high == 0);
+    return __builtin_clzll((x.s.high & ~f) | (x.s.low & f)) +
+           ((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT)));
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/cmpdi2.c b/compiler-rt/lib/builtins/cmpdi2.c
new file mode 100644
index 0000000..52634d9
--- /dev/null
+++ b/compiler-rt/lib/builtins/cmpdi2.c
@@ -0,0 +1,51 @@
+/* ===-- cmpdi2.c - Implement __cmpdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __cmpdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: if (a <  b) returns 0
+*           if (a == b) returns 1
+*           if (a >  b) returns 2
+*/
+
+COMPILER_RT_ABI si_int
+__cmpdi2(di_int a, di_int b)
+{
+    dwords x;
+    x.all = a;
+    dwords y;
+    y.all = b;
+    if (x.s.high < y.s.high)
+        return 0;
+    if (x.s.high > y.s.high)
+        return 2;
+    if (x.s.low < y.s.low)
+        return 0;
+    if (x.s.low > y.s.low)
+        return 2;
+    return 1;
+}
+
+#ifdef __ARM_EABI__
+/* Returns: if (a <  b) returns -1
+*           if (a == b) returns  0
+*           if (a >  b) returns  1
+*/
+COMPILER_RT_ABI si_int
+__aeabi_lcmp(di_int a, di_int b)
+{
+	return __cmpdi2(a, b) - 1;
+}
+#endif
+
diff --git a/compiler-rt/lib/builtins/cmpti2.c b/compiler-rt/lib/builtins/cmpti2.c
new file mode 100644
index 0000000..2c8b56e
--- /dev/null
+++ b/compiler-rt/lib/builtins/cmpti2.c
@@ -0,0 +1,42 @@
+/* ===-- cmpti2.c - Implement __cmpti2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __cmpti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns:  if (a <  b) returns 0
+ *           if (a == b) returns 1
+ *           if (a >  b) returns 2
+ */
+
+COMPILER_RT_ABI si_int
+__cmpti2(ti_int a, ti_int b)
+{
+    twords x;
+    x.all = a;
+    twords y;
+    y.all = b;
+    if (x.s.high < y.s.high)
+        return 0;
+    if (x.s.high > y.s.high)
+        return 2;
+    if (x.s.low < y.s.low)
+        return 0;
+    if (x.s.low > y.s.low)
+        return 2;
+    return 1;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/comparedf2.c b/compiler-rt/lib/builtins/comparedf2.c
new file mode 100644
index 0000000..9e29752
--- /dev/null
+++ b/compiler-rt/lib/builtins/comparedf2.c
@@ -0,0 +1,146 @@
+//===-- lib/comparedf2.c - Double-precision comparisons -----------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// // This file implements the following soft-float comparison routines:
+//
+//   __eqdf2   __gedf2   __unorddf2
+//   __ledf2   __gtdf2
+//   __ltdf2
+//   __nedf2
+//
+// The semantics of the routines grouped in each column are identical, so there
+// is a single implementation for each, and wrappers to provide the other names.
+//
+// The main routines behave as follows:
+//
+//   __ledf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                         1 if either a or b is NaN
+//
+//   __gedf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                        -1 if either a or b is NaN
+//
+//   __unorddf2(a,b) returns 0 if both a and b are numbers
+//                           1 if either a or b is NaN
+//
+// Note that __ledf2( ) and __gedf2( ) are identical except in their handling of
+// NaN values.
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+enum LE_RESULT {
+    LE_LESS      = -1,
+    LE_EQUAL     =  0,
+    LE_GREATER   =  1,
+    LE_UNORDERED =  1
+};
+
+COMPILER_RT_ABI enum LE_RESULT
+__ledf2(fp_t a, fp_t b) {
+    
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+    
+    // If either a or b is NaN, they are unordered.
+    if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
+    
+    // If a and b are both zeros, they are equal.
+    if ((aAbs | bAbs) == 0) return LE_EQUAL;
+    
+    // If at least one of a and b is positive, we get the same result comparing
+    // a and b as signed integers as we would with a floating-point compare.
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+    
+    // Otherwise, both are negative, so we need to flip the sense of the
+    // comparison to get the correct result.  (This assumes a twos- or ones-
+    // complement integer representation; if integers are represented in a
+    // sign-magnitude representation, then this flip is incorrect).
+    else {
+        if (aInt > bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+}
+
+#if defined(__ELF__)
+// Alias for libgcc compatibility
+FNALIAS(__cmpdf2, __ledf2);
+#endif
+
+enum GE_RESULT {
+    GE_LESS      = -1,
+    GE_EQUAL     =  0,
+    GE_GREATER   =  1,
+    GE_UNORDERED = -1   // Note: different from LE_UNORDERED
+};
+
+COMPILER_RT_ABI enum GE_RESULT
+__gedf2(fp_t a, fp_t b) {
+    
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+    
+    if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
+    if ((aAbs | bAbs) == 0) return GE_EQUAL;
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    } else {
+        if (aInt > bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    }
+}
+
+ARM_EABI_FNALIAS(dcmpun, unorddf2)
+
+COMPILER_RT_ABI int
+__unorddf2(fp_t a, fp_t b) {
+    const rep_t aAbs = toRep(a) & absMask;
+    const rep_t bAbs = toRep(b) & absMask;
+    return aAbs > infRep || bAbs > infRep;
+}
+
+// The following are alternative names for the preceding routines.
+
+COMPILER_RT_ABI enum LE_RESULT
+__eqdf2(fp_t a, fp_t b) {
+    return __ledf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT
+__ltdf2(fp_t a, fp_t b) {
+    return __ledf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT
+__nedf2(fp_t a, fp_t b) {
+    return __ledf2(a, b);
+}
+
+COMPILER_RT_ABI enum GE_RESULT
+__gtdf2(fp_t a, fp_t b) {
+    return __gedf2(a, b);
+}
+
diff --git a/compiler-rt/lib/builtins/comparesf2.c b/compiler-rt/lib/builtins/comparesf2.c
new file mode 100644
index 0000000..1fd5063
--- /dev/null
+++ b/compiler-rt/lib/builtins/comparesf2.c
@@ -0,0 +1,145 @@
+//===-- lib/comparesf2.c - Single-precision comparisons -----------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the following soft-fp_t comparison routines:
+//
+//   __eqsf2   __gesf2   __unordsf2
+//   __lesf2   __gtsf2
+//   __ltsf2
+//   __nesf2
+//
+// The semantics of the routines grouped in each column are identical, so there
+// is a single implementation for each, and wrappers to provide the other names.
+//
+// The main routines behave as follows:
+//
+//   __lesf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                         1 if either a or b is NaN
+//
+//   __gesf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                        -1 if either a or b is NaN
+//
+//   __unordsf2(a,b) returns 0 if both a and b are numbers
+//                           1 if either a or b is NaN
+//
+// Note that __lesf2( ) and __gesf2( ) are identical except in their handling of
+// NaN values.
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+enum LE_RESULT {
+    LE_LESS      = -1,
+    LE_EQUAL     =  0,
+    LE_GREATER   =  1,
+    LE_UNORDERED =  1
+};
+
+COMPILER_RT_ABI enum LE_RESULT
+__lesf2(fp_t a, fp_t b) {
+    
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+    
+    // If either a or b is NaN, they are unordered.
+    if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
+    
+    // If a and b are both zeros, they are equal.
+    if ((aAbs | bAbs) == 0) return LE_EQUAL;
+    
+    // If at least one of a and b is positive, we get the same result comparing
+    // a and b as signed integers as we would with a fp_ting-point compare.
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+    
+    // Otherwise, both are negative, so we need to flip the sense of the
+    // comparison to get the correct result.  (This assumes a twos- or ones-
+    // complement integer representation; if integers are represented in a
+    // sign-magnitude representation, then this flip is incorrect).
+    else {
+        if (aInt > bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+}
+
+#if defined(__ELF__)
+// Alias for libgcc compatibility
+FNALIAS(__cmpsf2, __lesf2);
+#endif
+
+enum GE_RESULT {
+    GE_LESS      = -1,
+    GE_EQUAL     =  0,
+    GE_GREATER   =  1,
+    GE_UNORDERED = -1   // Note: different from LE_UNORDERED
+};
+
+COMPILER_RT_ABI enum GE_RESULT
+__gesf2(fp_t a, fp_t b) {
+    
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+    
+    if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
+    if ((aAbs | bAbs) == 0) return GE_EQUAL;
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    } else {
+        if (aInt > bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    }
+}
+
+ARM_EABI_FNALIAS(fcmpun, unordsf2)
+
+COMPILER_RT_ABI int
+__unordsf2(fp_t a, fp_t b) {
+    const rep_t aAbs = toRep(a) & absMask;
+    const rep_t bAbs = toRep(b) & absMask;
+    return aAbs > infRep || bAbs > infRep;
+}
+
+// The following are alternative names for the preceding routines.
+
+COMPILER_RT_ABI enum LE_RESULT
+__eqsf2(fp_t a, fp_t b) {
+    return __lesf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT
+__ltsf2(fp_t a, fp_t b) {
+    return __lesf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT
+__nesf2(fp_t a, fp_t b) {
+    return __lesf2(a, b);
+}
+
+COMPILER_RT_ABI enum GE_RESULT
+__gtsf2(fp_t a, fp_t b) {
+    return __gesf2(a, b);
+}
diff --git a/compiler-rt/lib/builtins/comparetf2.c b/compiler-rt/lib/builtins/comparetf2.c
new file mode 100644
index 0000000..c0ad8ed
--- /dev/null
+++ b/compiler-rt/lib/builtins/comparetf2.c
@@ -0,0 +1,138 @@
+//===-- lib/comparetf2.c - Quad-precision comparisons -------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// // This file implements the following soft-float comparison routines:
+//
+//   __eqtf2   __getf2   __unordtf2
+//   __letf2   __gttf2
+//   __lttf2
+//   __netf2
+//
+// The semantics of the routines grouped in each column are identical, so there
+// is a single implementation for each, and wrappers to provide the other names.
+//
+// The main routines behave as follows:
+//
+//   __letf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                         1 if either a or b is NaN
+//
+//   __getf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                        -1 if either a or b is NaN
+//
+//   __unordtf2(a,b) returns 0 if both a and b are numbers
+//                           1 if either a or b is NaN
+//
+// Note that __letf2( ) and __getf2( ) are identical except in their handling of
+// NaN values.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+enum LE_RESULT {
+    LE_LESS      = -1,
+    LE_EQUAL     =  0,
+    LE_GREATER   =  1,
+    LE_UNORDERED =  1
+};
+
+COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) {
+
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+
+    // If either a or b is NaN, they are unordered.
+    if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
+
+    // If a and b are both zeros, they are equal.
+    if ((aAbs | bAbs) == 0) return LE_EQUAL;
+
+    // If at least one of a and b is positive, we get the same result comparing
+    // a and b as signed integers as we would with a floating-point compare.
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+    else {
+        // Otherwise, both are negative, so we need to flip the sense of the
+        // comparison to get the correct result.  (This assumes a twos- or ones-
+        // complement integer representation; if integers are represented in a
+        // sign-magnitude representation, then this flip is incorrect).
+        if (aInt > bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+}
+
+#if defined(__ELF__)
+// Alias for libgcc compatibility
+FNALIAS(__cmptf2, __letf2);
+#endif
+
+enum GE_RESULT {
+    GE_LESS      = -1,
+    GE_EQUAL     =  0,
+    GE_GREATER   =  1,
+    GE_UNORDERED = -1   // Note: different from LE_UNORDERED
+};
+
+COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) {
+
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+
+    if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
+    if ((aAbs | bAbs) == 0) return GE_EQUAL;
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    } else {
+        if (aInt > bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    }
+}
+
+COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) {
+    const rep_t aAbs = toRep(a) & absMask;
+    const rep_t bAbs = toRep(b) & absMask;
+    return aAbs > infRep || bAbs > infRep;
+}
+
+// The following are alternative names for the preceding routines.
+
+COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) {
+    return __getf2(a, b);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/ctzdi2.c b/compiler-rt/lib/builtins/ctzdi2.c
new file mode 100644
index 0000000..db3c6fd
--- /dev/null
+++ b/compiler-rt/lib/builtins/ctzdi2.c
@@ -0,0 +1,29 @@
+/* ===-- ctzdi2.c - Implement __ctzdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ctzdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: the number of trailing 0-bits  */
+
+/* Precondition: a != 0 */
+
+COMPILER_RT_ABI si_int
+__ctzdi2(di_int a)
+{
+    dwords x;
+    x.all = a;
+    const si_int f = -(x.s.low == 0);
+    return __builtin_ctz((x.s.high & f) | (x.s.low & ~f)) +
+              (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
+}
diff --git a/compiler-rt/lib/builtins/ctzsi2.c b/compiler-rt/lib/builtins/ctzsi2.c
new file mode 100644
index 0000000..c69486e
--- /dev/null
+++ b/compiler-rt/lib/builtins/ctzsi2.c
@@ -0,0 +1,57 @@
+/* ===-- ctzsi2.c - Implement __ctzsi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ctzsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: the number of trailing 0-bits */
+
+/* Precondition: a != 0 */
+
+COMPILER_RT_ABI si_int
+__ctzsi2(si_int a)
+{
+    su_int x = (su_int)a;
+    si_int t = ((x & 0x0000FFFF) == 0) << 4;  /* if (x has no small bits) t = 16 else 0 */
+    x >>= t;           /* x = [0 - 0xFFFF] + higher garbage bits */
+    su_int r = t;       /* r = [0, 16]  */
+    /* return r + ctz(x) */
+    t = ((x & 0x00FF) == 0) << 3;
+    x >>= t;           /* x = [0 - 0xFF] + higher garbage bits */
+    r += t;            /* r = [0, 8, 16, 24] */
+    /* return r + ctz(x) */
+    t = ((x & 0x0F) == 0) << 2;
+    x >>= t;           /* x = [0 - 0xF] + higher garbage bits */
+    r += t;            /* r = [0, 4, 8, 12, 16, 20, 24, 28] */
+    /* return r + ctz(x) */
+    t = ((x & 0x3) == 0) << 1;
+    x >>= t;
+    x &= 3;            /* x = [0 - 3] */
+    r += t;            /* r = [0 - 30] and is even */
+    /* return r + ctz(x) */
+
+/*  The branch-less return statement below is equivalent
+ *  to the following switch statement:
+ *     switch (x)
+ *    {
+ *     case 0:
+ *         return r + 2;
+ *     case 2:
+ *         return r + 1;
+ *     case 1:
+ *     case 3:
+ *         return r;
+ *     }
+ */
+    return r + ((2 - (x >> 1)) & -((x & 1) == 0));
+}
diff --git a/compiler-rt/lib/builtins/ctzti2.c b/compiler-rt/lib/builtins/ctzti2.c
new file mode 100644
index 0000000..45de682
--- /dev/null
+++ b/compiler-rt/lib/builtins/ctzti2.c
@@ -0,0 +1,33 @@
+/* ===-- ctzti2.c - Implement __ctzti2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ctzti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: the number of trailing 0-bits */
+
+/* Precondition: a != 0 */
+
+COMPILER_RT_ABI si_int
+__ctzti2(ti_int a)
+{
+    twords x;
+    x.all = a;
+    const di_int f = -(x.s.low == 0);
+    return __builtin_ctzll((x.s.high & f) | (x.s.low & ~f)) +
+              ((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT)));
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/divdc3.c b/compiler-rt/lib/builtins/divdc3.c
new file mode 100644
index 0000000..3c88390
--- /dev/null
+++ b/compiler-rt/lib/builtins/divdc3.c
@@ -0,0 +1,60 @@
+/* ===-- divdc3.c - Implement __divdc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divdc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+COMPILER_RT_ABI Dcomplex
+__divdc3(double __a, double __b, double __c, double __d)
+{
+    int __ilogbw = 0;
+    double __logbw = crt_logb(crt_fmax(crt_fabs(__c), crt_fabs(__d)));
+    if (crt_isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = crt_scalbn(__c, -__ilogbw);
+        __d = crt_scalbn(__d, -__ilogbw);
+    }
+    double __denom = __c * __c + __d * __d;
+    Dcomplex z;
+    COMPLEX_REAL(z) = crt_scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
+    COMPLEX_IMAGINARY(z) = crt_scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
+    {
+        if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b)))
+        {
+            COMPLEX_REAL(z) = crt_copysign(CRT_INFINITY, __c) * __a;
+            COMPLEX_IMAGINARY(z) = crt_copysign(CRT_INFINITY, __c) * __b;
+        }
+        else if ((crt_isinf(__a) || crt_isinf(__b)) &&
+                 crt_isfinite(__c) && crt_isfinite(__d))
+        {
+            __a = crt_copysign(crt_isinf(__a) ? 1.0 : 0.0, __a);
+            __b = crt_copysign(crt_isinf(__b) ? 1.0 : 0.0, __b);
+            COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
+            COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
+        }
+        else if (crt_isinf(__logbw) && __logbw > 0.0 &&
+                 crt_isfinite(__a) && crt_isfinite(__b))
+        {
+            __c = crt_copysign(crt_isinf(__c) ? 1.0 : 0.0, __c);
+            __d = crt_copysign(crt_isinf(__d) ? 1.0 : 0.0, __d);
+            COMPLEX_REAL(z) = 0.0 * (__a * __c + __b * __d);
+            COMPLEX_IMAGINARY(z) = 0.0 * (__b * __c - __a * __d);
+        }
+    }
+    return z;
+}
diff --git a/compiler-rt/lib/builtins/divdf3.c b/compiler-rt/lib/builtins/divdf3.c
new file mode 100644
index 0000000..ab44c2b
--- /dev/null
+++ b/compiler-rt/lib/builtins/divdf3.c
@@ -0,0 +1,185 @@
+//===-- lib/divdf3.c - Double-precision division ------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements double-precision soft-float division
+// with the IEEE-754 default rounding (to nearest, ties to even).
+//
+// For simplicity, this implementation currently flushes denormals to zero.
+// It should be a fairly straightforward exercise to implement gradual
+// underflow with correct rounding.
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(ddiv, divdf3)
+
+COMPILER_RT_ABI fp_t
+__divdf3(fp_t a, fp_t b) {
+    
+    const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
+    const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
+    const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
+    
+    rep_t aSignificand = toRep(a) & significandMask;
+    rep_t bSignificand = toRep(b) & significandMask;
+    int scale = 0;
+    
+    // Detect if a or b is zero, denormal, infinity, or NaN.
+    if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) {
+        
+        const rep_t aAbs = toRep(a) & absMask;
+        const rep_t bAbs = toRep(b) & absMask;
+        
+        // NaN / anything = qNaN
+        if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
+        // anything / NaN = qNaN
+        if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
+        
+        if (aAbs == infRep) {
+            // infinity / infinity = NaN
+            if (bAbs == infRep) return fromRep(qnanRep);
+            // infinity / anything else = +/- infinity
+            else return fromRep(aAbs | quotientSign);
+        }
+        
+        // anything else / infinity = +/- 0
+        if (bAbs == infRep) return fromRep(quotientSign);
+        
+        if (!aAbs) {
+            // zero / zero = NaN
+            if (!bAbs) return fromRep(qnanRep);
+            // zero / anything else = +/- zero
+            else return fromRep(quotientSign);
+        }
+        // anything else / zero = +/- infinity
+        if (!bAbs) return fromRep(infRep | quotientSign);
+        
+        // one or both of a or b is denormal, the other (if applicable) is a
+        // normal number.  Renormalize one or both of a and b, and set scale to
+        // include the necessary exponent adjustment.
+        if (aAbs < implicitBit) scale += normalize(&aSignificand);
+        if (bAbs < implicitBit) scale -= normalize(&bSignificand);
+    }
+    
+    // Or in the implicit significand bit.  (If we fell through from the
+    // denormal path it was already set by normalize( ), but setting it twice
+    // won't hurt anything.)
+    aSignificand |= implicitBit;
+    bSignificand |= implicitBit;
+    int quotientExponent = aExponent - bExponent + scale;
+    
+    // Align the significand of b as a Q31 fixed-point number in the range
+    // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
+    // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
+    // is accurate to about 3.5 binary digits.
+    const uint32_t q31b = bSignificand >> 21;
+    uint32_t recip32 = UINT32_C(0x7504f333) - q31b;
+    
+    // Now refine the reciprocal estimate using a Newton-Raphson iteration:
+    //
+    //     x1 = x0 * (2 - x0 * b)
+    //
+    // This doubles the number of correct binary digits in the approximation
+    // with each iteration, so after three iterations, we have about 28 binary
+    // digits of accuracy.
+    uint32_t correction32;
+    correction32 = -((uint64_t)recip32 * q31b >> 32);
+    recip32 = (uint64_t)recip32 * correction32 >> 31;
+    correction32 = -((uint64_t)recip32 * q31b >> 32);
+    recip32 = (uint64_t)recip32 * correction32 >> 31;
+    correction32 = -((uint64_t)recip32 * q31b >> 32);
+    recip32 = (uint64_t)recip32 * correction32 >> 31;
+    
+    // recip32 might have overflowed to exactly zero in the preceding
+    // computation if the high word of b is exactly 1.0.  This would sabotage
+    // the full-width final stage of the computation that follows, so we adjust
+    // recip32 downward by one bit.
+    recip32--;
+    
+    // We need to perform one more iteration to get us to 56 binary digits;
+    // The last iteration needs to happen with extra precision.
+    const uint32_t q63blo = bSignificand << 11;
+    uint64_t correction, reciprocal;
+    correction = -((uint64_t)recip32*q31b + ((uint64_t)recip32*q63blo >> 32));
+    uint32_t cHi = correction >> 32;
+    uint32_t cLo = correction;
+    reciprocal = (uint64_t)recip32*cHi + ((uint64_t)recip32*cLo >> 32);
+    
+    // We already adjusted the 32-bit estimate, now we need to adjust the final
+    // 64-bit reciprocal estimate downward to ensure that it is strictly smaller
+    // than the infinitely precise exact reciprocal.  Because the computation
+    // of the Newton-Raphson step is truncating at every step, this adjustment
+    // is small; most of the work is already done.
+    reciprocal -= 2;
+    
+    // The numerical reciprocal is accurate to within 2^-56, lies in the
+    // interval [0.5, 1.0), and is strictly smaller than the true reciprocal
+    // of b.  Multiplying a by this reciprocal thus gives a numerical q = a/b
+    // in Q53 with the following properties:
+    //
+    //    1. q < a/b
+    //    2. q is in the interval [0.5, 2.0)
+    //    3. the error in q is bounded away from 2^-53 (actually, we have a
+    //       couple of bits to spare, but this is all we need).
+    
+    // We need a 64 x 64 multiply high to compute q, which isn't a basic
+    // operation in C, so we need to be a little bit fussy.
+    rep_t quotient, quotientLo;
+    wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo);
+    
+    // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
+    // In either case, we are going to compute a residual of the form
+    //
+    //     r = a - q*b
+    //
+    // We know from the construction of q that r satisfies:
+    //
+    //     0 <= r < ulp(q)*b
+    // 
+    // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we
+    // already have the correct result.  The exact halfway case cannot occur.
+    // We also take this time to right shift quotient if it falls in the [1,2)
+    // range and adjust the exponent accordingly.
+    rep_t residual;
+    if (quotient < (implicitBit << 1)) {
+        residual = (aSignificand << 53) - quotient * bSignificand;
+        quotientExponent--;
+    } else {
+        quotient >>= 1;
+        residual = (aSignificand << 52) - quotient * bSignificand;
+    }
+    
+    const int writtenExponent = quotientExponent + exponentBias;
+    
+    if (writtenExponent >= maxExponent) {
+        // If we have overflowed the exponent, return infinity.
+        return fromRep(infRep | quotientSign);
+    }
+    
+    else if (writtenExponent < 1) {
+        // Flush denormals to zero.  In the future, it would be nice to add
+        // code to round them correctly.
+        return fromRep(quotientSign);
+    }
+    
+    else {
+        const bool round = (residual << 1) > bSignificand;
+        // Clear the implicit bit
+        rep_t absResult = quotient & significandMask;
+        // Insert the exponent
+        absResult |= (rep_t)writtenExponent << significandBits;
+        // Round
+        absResult += round;
+        // Insert the sign and return
+        const double result = fromRep(absResult | quotientSign);
+        return result;
+    }
+}
diff --git a/compiler-rt/lib/builtins/divdi3.c b/compiler-rt/lib/builtins/divdi3.c
new file mode 100644
index 0000000..b8eebcb
--- /dev/null
+++ b/compiler-rt/lib/builtins/divdi3.c
@@ -0,0 +1,29 @@
+/* ===-- divdi3.c - Implement __divdi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b */
+
+COMPILER_RT_ABI di_int
+__divdi3(di_int a, di_int b)
+{
+    const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1;
+    di_int s_a = a >> bits_in_dword_m1;           /* s_a = a < 0 ? -1 : 0 */
+    di_int s_b = b >> bits_in_dword_m1;           /* s_b = b < 0 ? -1 : 0 */
+    a = (a ^ s_a) - s_a;                         /* negate if s_a == -1 */
+    b = (b ^ s_b) - s_b;                         /* negate if s_b == -1 */
+    s_a ^= s_b;                                  /*sign of quotient */
+    return (__udivmoddi4(a, b, (du_int*)0) ^ s_a) - s_a;  /* negate if s_a == -1 */
+}
diff --git a/compiler-rt/lib/builtins/divmoddi4.c b/compiler-rt/lib/builtins/divmoddi4.c
new file mode 100644
index 0000000..0d4df67
--- /dev/null
+++ b/compiler-rt/lib/builtins/divmoddi4.c
@@ -0,0 +1,25 @@
+/*===-- divmoddi4.c - Implement __divmoddi4 --------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divmoddi4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b, *rem = a % b  */
+
+COMPILER_RT_ABI di_int
+__divmoddi4(di_int a, di_int b, di_int* rem)
+{
+  di_int d = __divdi3(a,b);
+  *rem = a - (d*b);
+  return d;
+}
diff --git a/compiler-rt/lib/builtins/divmodsi4.c b/compiler-rt/lib/builtins/divmodsi4.c
new file mode 100644
index 0000000..dabe287
--- /dev/null
+++ b/compiler-rt/lib/builtins/divmodsi4.c
@@ -0,0 +1,27 @@
+/*===-- divmodsi4.c - Implement __divmodsi4 --------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divmodsi4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b, *rem = a % b  */
+
+COMPILER_RT_ABI si_int
+__divmodsi4(si_int a, si_int b, si_int* rem)
+{
+  si_int d = __divsi3(a,b);
+  *rem = a - (d*b);
+  return d; 
+}
+
+
diff --git a/compiler-rt/lib/builtins/divsc3.c b/compiler-rt/lib/builtins/divsc3.c
new file mode 100644
index 0000000..42a4831
--- /dev/null
+++ b/compiler-rt/lib/builtins/divsc3.c
@@ -0,0 +1,60 @@
+/*===-- divsc3.c - Implement __divsc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divsc3 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+COMPILER_RT_ABI Fcomplex
+__divsc3(float __a, float __b, float __c, float __d)
+{
+    int __ilogbw = 0;
+    float __logbw = crt_logbf(crt_fmaxf(crt_fabsf(__c), crt_fabsf(__d)));
+    if (crt_isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = crt_scalbnf(__c, -__ilogbw);
+        __d = crt_scalbnf(__d, -__ilogbw);
+    }
+    float __denom = __c * __c + __d * __d;
+    Fcomplex z;
+    COMPLEX_REAL(z) = crt_scalbnf((__a * __c + __b * __d) / __denom, -__ilogbw);
+    COMPLEX_IMAGINARY(z) = crt_scalbnf((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
+    {
+        if ((__denom == 0) && (!crt_isnan(__a) || !crt_isnan(__b)))
+        {
+            COMPLEX_REAL(z) = crt_copysignf(CRT_INFINITY, __c) * __a;
+            COMPLEX_IMAGINARY(z) = crt_copysignf(CRT_INFINITY, __c) * __b;
+        }
+        else if ((crt_isinf(__a) || crt_isinf(__b)) &&
+                 crt_isfinite(__c) && crt_isfinite(__d))
+        {
+            __a = crt_copysignf(crt_isinf(__a) ? 1 : 0, __a);
+            __b = crt_copysignf(crt_isinf(__b) ? 1 : 0, __b);
+            COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
+            COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
+        }
+        else if (crt_isinf(__logbw) && __logbw > 0 &&
+                 crt_isfinite(__a) && crt_isfinite(__b))
+        {
+            __c = crt_copysignf(crt_isinf(__c) ? 1 : 0, __c);
+            __d = crt_copysignf(crt_isinf(__d) ? 1 : 0, __d);
+            COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d);
+            COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d);
+        }
+    }
+    return z;
+}
diff --git a/compiler-rt/lib/builtins/divsf3.c b/compiler-rt/lib/builtins/divsf3.c
new file mode 100644
index 0000000..de2e376
--- /dev/null
+++ b/compiler-rt/lib/builtins/divsf3.c
@@ -0,0 +1,169 @@
+//===-- lib/divsf3.c - Single-precision division ------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements single-precision soft-float division
+// with the IEEE-754 default rounding (to nearest, ties to even).
+//
+// For simplicity, this implementation currently flushes denormals to zero.
+// It should be a fairly straightforward exercise to implement gradual
+// underflow with correct rounding.
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(fdiv, divsf3)
+
+COMPILER_RT_ABI fp_t
+__divsf3(fp_t a, fp_t b) {
+    
+    const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
+    const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
+    const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
+    
+    rep_t aSignificand = toRep(a) & significandMask;
+    rep_t bSignificand = toRep(b) & significandMask;
+    int scale = 0;
+    
+    // Detect if a or b is zero, denormal, infinity, or NaN.
+    if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) {
+        
+        const rep_t aAbs = toRep(a) & absMask;
+        const rep_t bAbs = toRep(b) & absMask;
+        
+        // NaN / anything = qNaN
+        if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
+        // anything / NaN = qNaN
+        if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
+        
+        if (aAbs == infRep) {
+            // infinity / infinity = NaN
+            if (bAbs == infRep) return fromRep(qnanRep);
+            // infinity / anything else = +/- infinity
+            else return fromRep(aAbs | quotientSign);
+        }
+        
+        // anything else / infinity = +/- 0
+        if (bAbs == infRep) return fromRep(quotientSign);
+        
+        if (!aAbs) {
+            // zero / zero = NaN
+            if (!bAbs) return fromRep(qnanRep);
+            // zero / anything else = +/- zero
+            else return fromRep(quotientSign);
+        }
+        // anything else / zero = +/- infinity
+        if (!bAbs) return fromRep(infRep | quotientSign);
+        
+        // one or both of a or b is denormal, the other (if applicable) is a
+        // normal number.  Renormalize one or both of a and b, and set scale to
+        // include the necessary exponent adjustment.
+        if (aAbs < implicitBit) scale += normalize(&aSignificand);
+        if (bAbs < implicitBit) scale -= normalize(&bSignificand);
+    }
+    
+    // Or in the implicit significand bit.  (If we fell through from the
+    // denormal path it was already set by normalize( ), but setting it twice
+    // won't hurt anything.)
+    aSignificand |= implicitBit;
+    bSignificand |= implicitBit;
+    int quotientExponent = aExponent - bExponent + scale;
+    
+    // Align the significand of b as a Q31 fixed-point number in the range
+    // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
+    // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
+    // is accurate to about 3.5 binary digits.
+    uint32_t q31b = bSignificand << 8;
+    uint32_t reciprocal = UINT32_C(0x7504f333) - q31b;
+    
+    // Now refine the reciprocal estimate using a Newton-Raphson iteration:
+    //
+    //     x1 = x0 * (2 - x0 * b)
+    //
+    // This doubles the number of correct binary digits in the approximation
+    // with each iteration, so after three iterations, we have about 28 binary
+    // digits of accuracy.
+    uint32_t correction;
+    correction = -((uint64_t)reciprocal * q31b >> 32);
+    reciprocal = (uint64_t)reciprocal * correction >> 31;
+    correction = -((uint64_t)reciprocal * q31b >> 32);
+    reciprocal = (uint64_t)reciprocal * correction >> 31;
+    correction = -((uint64_t)reciprocal * q31b >> 32);
+    reciprocal = (uint64_t)reciprocal * correction >> 31;
+    
+    // Exhaustive testing shows that the error in reciprocal after three steps
+    // is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our
+    // expectations.  We bump the reciprocal by a tiny value to force the error
+    // to be strictly positive (in the range [0x1.4fdfp-37,0x1.287246p-29], to
+    // be specific).  This also causes 1/1 to give a sensible approximation
+    // instead of zero (due to overflow).
+    reciprocal -= 2;
+    
+    // The numerical reciprocal is accurate to within 2^-28, lies in the
+    // interval [0x1.000000eep-1, 0x1.fffffffcp-1], and is strictly smaller
+    // than the true reciprocal of b.  Multiplying a by this reciprocal thus
+    // gives a numerical q = a/b in Q24 with the following properties:
+    //
+    //    1. q < a/b
+    //    2. q is in the interval [0x1.000000eep-1, 0x1.fffffffcp0)
+    //    3. the error in q is at most 2^-24 + 2^-27 -- the 2^24 term comes
+    //       from the fact that we truncate the product, and the 2^27 term
+    //       is the error in the reciprocal of b scaled by the maximum
+    //       possible value of a.  As a consequence of this error bound,
+    //       either q or nextafter(q) is the correctly rounded 
+    rep_t quotient = (uint64_t)reciprocal*(aSignificand << 1) >> 32;
+    
+    // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
+    // In either case, we are going to compute a residual of the form
+    //
+    //     r = a - q*b
+    //
+    // We know from the construction of q that r satisfies:
+    //
+    //     0 <= r < ulp(q)*b
+    // 
+    // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we
+    // already have the correct result.  The exact halfway case cannot occur.
+    // We also take this time to right shift quotient if it falls in the [1,2)
+    // range and adjust the exponent accordingly.
+    rep_t residual;
+    if (quotient < (implicitBit << 1)) {
+        residual = (aSignificand << 24) - quotient * bSignificand;
+        quotientExponent--;
+    } else {
+        quotient >>= 1;
+        residual = (aSignificand << 23) - quotient * bSignificand;
+    }
+
+    const int writtenExponent = quotientExponent + exponentBias;
+    
+    if (writtenExponent >= maxExponent) {
+        // If we have overflowed the exponent, return infinity.
+        return fromRep(infRep | quotientSign);
+    }
+    
+    else if (writtenExponent < 1) {
+        // Flush denormals to zero.  In the future, it would be nice to add
+        // code to round them correctly.
+        return fromRep(quotientSign);
+    }
+    
+    else {
+        const bool round = (residual << 1) > bSignificand;
+        // Clear the implicit bit
+        rep_t absResult = quotient & significandMask;
+        // Insert the exponent
+        absResult |= (rep_t)writtenExponent << significandBits;
+        // Round
+        absResult += round;
+        // Insert the sign and return
+        return fromRep(absResult | quotientSign);
+    }
+}
diff --git a/compiler-rt/lib/builtins/divsi3.c b/compiler-rt/lib/builtins/divsi3.c
new file mode 100644
index 0000000..bab4aef
--- /dev/null
+++ b/compiler-rt/lib/builtins/divsi3.c
@@ -0,0 +1,37 @@
+/* ===-- divsi3.c - Implement __divsi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b */
+
+ARM_EABI_FNALIAS(idiv, divsi3)
+
+COMPILER_RT_ABI si_int
+__divsi3(si_int a, si_int b)
+{
+    const int bits_in_word_m1 = (int)(sizeof(si_int) * CHAR_BIT) - 1;
+    si_int s_a = a >> bits_in_word_m1;           /* s_a = a < 0 ? -1 : 0 */
+    si_int s_b = b >> bits_in_word_m1;           /* s_b = b < 0 ? -1 : 0 */
+    a = (a ^ s_a) - s_a;                         /* negate if s_a == -1 */
+    b = (b ^ s_b) - s_b;                         /* negate if s_b == -1 */
+    s_a ^= s_b;                                  /* sign of quotient */
+    /*
+     * On CPUs without unsigned hardware division support,
+     *  this calls __udivsi3 (notice the cast to su_int).
+     * On CPUs with unsigned hardware division support,
+     *  this uses the unsigned division instruction.
+     */
+    return ((su_int)a/(su_int)b ^ s_a) - s_a;    /* negate if s_a == -1 */
+}
diff --git a/compiler-rt/lib/builtins/divtc3.c b/compiler-rt/lib/builtins/divtc3.c
new file mode 100644
index 0000000..04693df
--- /dev/null
+++ b/compiler-rt/lib/builtins/divtc3.c
@@ -0,0 +1,60 @@
+/*===-- divtc3.c - Implement __divtc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divtc3 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+COMPILER_RT_ABI long double _Complex
+__divtc3(long double __a, long double __b, long double __c, long double __d)
+{
+    int __ilogbw = 0;
+    long double __logbw = crt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
+    if (crt_isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = crt_scalbnl(__c, -__ilogbw);
+        __d = crt_scalbnl(__d, -__ilogbw);
+    }
+    long double __denom = __c * __c + __d * __d;
+    long double _Complex z;
+    __real__ z = crt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw);
+    __imag__ z = crt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (crt_isnan(__real__ z) && crt_isnan(__imag__ z))
+    {
+        if ((__denom == 0.0) && (!crt_isnan(__a) || !crt_isnan(__b)))
+        {
+            __real__ z = crt_copysignl(CRT_INFINITY, __c) * __a;
+            __imag__ z = crt_copysignl(CRT_INFINITY, __c) * __b;
+        }
+        else if ((crt_isinf(__a) || crt_isinf(__b)) &&
+                 crt_isfinite(__c) && crt_isfinite(__d))
+        {
+            __a = crt_copysignl(crt_isinf(__a) ? 1.0 : 0.0, __a);
+            __b = crt_copysignl(crt_isinf(__b) ? 1.0 : 0.0, __b);
+            __real__ z = CRT_INFINITY * (__a * __c + __b * __d);
+            __imag__ z = CRT_INFINITY * (__b * __c - __a * __d);
+        }
+        else if (crt_isinf(__logbw) && __logbw > 0.0 &&
+                 crt_isfinite(__a) && crt_isfinite(__b))
+        {
+            __c = crt_copysignl(crt_isinf(__c) ? 1.0 : 0.0, __c);
+            __d = crt_copysignl(crt_isinf(__d) ? 1.0 : 0.0, __d);
+            __real__ z = 0.0 * (__a * __c + __b * __d);
+            __imag__ z = 0.0 * (__b * __c - __a * __d);
+        }
+    }
+    return z;
+}
diff --git a/compiler-rt/lib/builtins/divtf3.c b/compiler-rt/lib/builtins/divtf3.c
new file mode 100644
index 0000000..e81dab8
--- /dev/null
+++ b/compiler-rt/lib/builtins/divtf3.c
@@ -0,0 +1,203 @@
+//===-- lib/divtf3.c - Quad-precision division --------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements quad-precision soft-float division
+// with the IEEE-754 default rounding (to nearest, ties to even).
+//
+// For simplicity, this implementation currently flushes denormals to zero.
+// It should be a fairly straightforward exercise to implement gradual
+// underflow with correct rounding.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __divtf3(fp_t a, fp_t b) {
+
+    const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
+    const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
+    const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
+
+    rep_t aSignificand = toRep(a) & significandMask;
+    rep_t bSignificand = toRep(b) & significandMask;
+    int scale = 0;
+
+    // Detect if a or b is zero, denormal, infinity, or NaN.
+    if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) {
+
+        const rep_t aAbs = toRep(a) & absMask;
+        const rep_t bAbs = toRep(b) & absMask;
+
+        // NaN / anything = qNaN
+        if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
+        // anything / NaN = qNaN
+        if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
+
+        if (aAbs == infRep) {
+            // infinity / infinity = NaN
+            if (bAbs == infRep) return fromRep(qnanRep);
+            // infinity / anything else = +/- infinity
+            else return fromRep(aAbs | quotientSign);
+        }
+
+        // anything else / infinity = +/- 0
+        if (bAbs == infRep) return fromRep(quotientSign);
+
+        if (!aAbs) {
+            // zero / zero = NaN
+            if (!bAbs) return fromRep(qnanRep);
+            // zero / anything else = +/- zero
+            else return fromRep(quotientSign);
+        }
+        // anything else / zero = +/- infinity
+        if (!bAbs) return fromRep(infRep | quotientSign);
+
+        // one or both of a or b is denormal, the other (if applicable) is a
+        // normal number.  Renormalize one or both of a and b, and set scale to
+        // include the necessary exponent adjustment.
+        if (aAbs < implicitBit) scale += normalize(&aSignificand);
+        if (bAbs < implicitBit) scale -= normalize(&bSignificand);
+    }
+
+    // Or in the implicit significand bit.  (If we fell through from the
+    // denormal path it was already set by normalize( ), but setting it twice
+    // won't hurt anything.)
+    aSignificand |= implicitBit;
+    bSignificand |= implicitBit;
+    int quotientExponent = aExponent - bExponent + scale;
+
+    // Align the significand of b as a Q63 fixed-point number in the range
+    // [1, 2.0) and get a Q64 approximate reciprocal using a small minimax
+    // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
+    // is accurate to about 3.5 binary digits.
+    const uint64_t q63b = bSignificand >> 49;
+    uint64_t recip64 = UINT64_C(0x7504f333F9DE6484) - q63b;
+    // 0x7504f333F9DE6484 / 2^64 + 1 = 3/4 + 1/sqrt(2)
+
+    // Now refine the reciprocal estimate using a Newton-Raphson iteration:
+    //
+    //     x1 = x0 * (2 - x0 * b)
+    //
+    // This doubles the number of correct binary digits in the approximation
+    // with each iteration.
+    uint64_t correction64;
+    correction64 = -((rep_t)recip64 * q63b >> 64);
+    recip64 = (rep_t)recip64 * correction64 >> 63;
+    correction64 = -((rep_t)recip64 * q63b >> 64);
+    recip64 = (rep_t)recip64 * correction64 >> 63;
+    correction64 = -((rep_t)recip64 * q63b >> 64);
+    recip64 = (rep_t)recip64 * correction64 >> 63;
+    correction64 = -((rep_t)recip64 * q63b >> 64);
+    recip64 = (rep_t)recip64 * correction64 >> 63;
+    correction64 = -((rep_t)recip64 * q63b >> 64);
+    recip64 = (rep_t)recip64 * correction64 >> 63;
+
+    // recip64 might have overflowed to exactly zero in the preceeding
+    // computation if the high word of b is exactly 1.0.  This would sabotage
+    // the full-width final stage of the computation that follows, so we adjust
+    // recip64 downward by one bit.
+    recip64--;
+
+    // We need to perform one more iteration to get us to 112 binary digits;
+    // The last iteration needs to happen with extra precision.
+    const uint64_t q127blo = bSignificand << 15;
+    rep_t correction, reciprocal;
+
+    // NOTE: This operation is equivalent to __multi3, which is not implemented
+    //       in some architechure
+    rep_t r64q63, r64q127, r64cH, r64cL, dummy;
+    wideMultiply((rep_t)recip64, (rep_t)q63b, &dummy, &r64q63);
+    wideMultiply((rep_t)recip64, (rep_t)q127blo, &dummy, &r64q127);
+
+    correction = -(r64q63 + (r64q127 >> 64));
+
+    uint64_t cHi = correction >> 64;
+    uint64_t cLo = correction;
+
+    wideMultiply((rep_t)recip64, (rep_t)cHi, &dummy, &r64cH);
+    wideMultiply((rep_t)recip64, (rep_t)cLo, &dummy, &r64cL);
+
+    reciprocal = r64cH + (r64cL >> 64);
+
+    // We already adjusted the 64-bit estimate, now we need to adjust the final
+    // 128-bit reciprocal estimate downward to ensure that it is strictly smaller
+    // than the infinitely precise exact reciprocal.  Because the computation
+    // of the Newton-Raphson step is truncating at every step, this adjustment
+    // is small; most of the work is already done.
+    reciprocal -= 2;
+
+    // The numerical reciprocal is accurate to within 2^-112, lies in the
+    // interval [0.5, 1.0), and is strictly smaller than the true reciprocal
+    // of b.  Multiplying a by this reciprocal thus gives a numerical q = a/b
+    // in Q127 with the following properties:
+    //
+    //    1. q < a/b
+    //    2. q is in the interval [0.5, 2.0)
+    //    3. the error in q is bounded away from 2^-113 (actually, we have a
+    //       couple of bits to spare, but this is all we need).
+
+    // We need a 128 x 128 multiply high to compute q, which isn't a basic
+    // operation in C, so we need to be a little bit fussy.
+    rep_t quotient, quotientLo;
+    wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo);
+
+    // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
+    // In either case, we are going to compute a residual of the form
+    //
+    //     r = a - q*b
+    //
+    // We know from the construction of q that r satisfies:
+    //
+    //     0 <= r < ulp(q)*b
+    //
+    // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we
+    // already have the correct result.  The exact halfway case cannot occur.
+    // We also take this time to right shift quotient if it falls in the [1,2)
+    // range and adjust the exponent accordingly.
+    rep_t residual;
+    rep_t qb;
+
+    if (quotient < (implicitBit << 1)) {
+        wideMultiply(quotient, bSignificand, &dummy, &qb);
+        residual = (aSignificand << 113) - qb;
+        quotientExponent--;
+    } else {
+        quotient >>= 1;
+        wideMultiply(quotient, bSignificand, &dummy, &qb);
+        residual = (aSignificand << 112) - qb;
+    }
+
+    const int writtenExponent = quotientExponent + exponentBias;
+
+    if (writtenExponent >= maxExponent) {
+        // If we have overflowed the exponent, return infinity.
+        return fromRep(infRep | quotientSign);
+    }
+    else if (writtenExponent < 1) {
+        // Flush denormals to zero.  In the future, it would be nice to add
+        // code to round them correctly.
+        return fromRep(quotientSign);
+    }
+    else {
+        const bool round = (residual << 1) >= bSignificand;
+        // Clear the implicit bit
+        rep_t absResult = quotient & significandMask;
+        // Insert the exponent
+        absResult |= (rep_t)writtenExponent << significandBits;
+        // Round
+        absResult += round;
+        // Insert the sign and return
+        const long double result = fromRep(absResult | quotientSign);
+        return result;
+    }
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/divti3.c b/compiler-rt/lib/builtins/divti3.c
new file mode 100644
index 0000000..c73eae2
--- /dev/null
+++ b/compiler-rt/lib/builtins/divti3.c
@@ -0,0 +1,33 @@
+/* ===-- divti3.c - Implement __divti3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a / b */
+
+COMPILER_RT_ABI ti_int
+__divti3(ti_int a, ti_int b)
+{
+    const int bits_in_tword_m1 = (int)(sizeof(ti_int) * CHAR_BIT) - 1;
+    ti_int s_a = a >> bits_in_tword_m1;           /* s_a = a < 0 ? -1 : 0 */
+    ti_int s_b = b >> bits_in_tword_m1;           /* s_b = b < 0 ? -1 : 0 */
+    a = (a ^ s_a) - s_a;                         /* negate if s_a == -1 */
+    b = (b ^ s_b) - s_b;                         /* negate if s_b == -1 */
+    s_a ^= s_b;                                  /* sign of quotient */
+    return (__udivmodti4(a, b, (tu_int*)0) ^ s_a) - s_a;  /* negate if s_a == -1 */
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/divxc3.c b/compiler-rt/lib/builtins/divxc3.c
new file mode 100644
index 0000000..6f49280
--- /dev/null
+++ b/compiler-rt/lib/builtins/divxc3.c
@@ -0,0 +1,63 @@
+/* ===-- divxc3.c - Implement __divxc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divxc3 for the compiler_rt library.
+ *
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+COMPILER_RT_ABI Lcomplex
+__divxc3(long double __a, long double __b, long double __c, long double __d)
+{
+    int __ilogbw = 0;
+    long double __logbw = crt_logbl(crt_fmaxl(crt_fabsl(__c), crt_fabsl(__d)));
+    if (crt_isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = crt_scalbnl(__c, -__ilogbw);
+        __d = crt_scalbnl(__d, -__ilogbw);
+    }
+    long double __denom = __c * __c + __d * __d;
+    Lcomplex z;
+    COMPLEX_REAL(z) = crt_scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw);
+    COMPLEX_IMAGINARY(z) = crt_scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
+    {
+        if ((__denom == 0) && (!crt_isnan(__a) || !crt_isnan(__b)))
+        {
+            COMPLEX_REAL(z) = crt_copysignl(CRT_INFINITY, __c) * __a;
+            COMPLEX_IMAGINARY(z) = crt_copysignl(CRT_INFINITY, __c) * __b;
+        }
+        else if ((crt_isinf(__a) || crt_isinf(__b)) &&
+                 crt_isfinite(__c) && crt_isfinite(__d))
+        {
+            __a = crt_copysignl(crt_isinf(__a) ? 1 : 0, __a);
+            __b = crt_copysignl(crt_isinf(__b) ? 1 : 0, __b);
+            COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c + __b * __d);
+            COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__b * __c - __a * __d);
+        }
+        else if (crt_isinf(__logbw) && __logbw > 0 &&
+                 crt_isfinite(__a) && crt_isfinite(__b))
+        {
+            __c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c);
+            __d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d);
+            COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d);
+            COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d);
+        }
+    }
+    return z;
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/emutls.c b/compiler-rt/lib/builtins/emutls.c
new file mode 100644
index 0000000..09e7956
--- /dev/null
+++ b/compiler-rt/lib/builtins/emutls.c
@@ -0,0 +1,183 @@
+/* ===---------- emutls.c - Implements __emutls_get_address ---------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+#include <pthread.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "int_lib.h"
+#include "int_util.h"
+
+/* Default is not to use posix_memalign, so systems like Android
+ * can use thread local data without heavier POSIX memory allocators.
+ */
+#ifndef EMUTLS_USE_POSIX_MEMALIGN
+#define EMUTLS_USE_POSIX_MEMALIGN 0
+#endif
+
+/* For every TLS variable xyz,
+ * there is one __emutls_control variable named __emutls_v.xyz.
+ * If xyz has non-zero initial value, __emutls_v.xyz's "value"
+ * will point to __emutls_t.xyz, which has the initial value.
+ */
+typedef struct __emutls_control {
+    size_t size;  /* size of the object in bytes */
+    size_t align;  /* alignment of the object in bytes */
+    union {
+        uintptr_t index;  /* data[index-1] is the object address */
+        void* address;  /* object address, when in single thread env */
+    } object;
+    void* value;  /* null or non-zero initial value for the object */
+} __emutls_control;
+
+static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
+    void *base;
+#if EMUTLS_USE_POSIX_MEMALIGN
+    if (posix_memalign(&base, align, size) != 0)
+        abort();
+#else
+    #define EXTRA_ALIGN_PTR_BYTES (align - 1 + sizeof(void*))
+    char* object;
+    if ((object = malloc(EXTRA_ALIGN_PTR_BYTES + size)) == NULL)
+        abort();
+    base = (void*)(((uintptr_t)(object + EXTRA_ALIGN_PTR_BYTES))
+                    & ~(uintptr_t)(align - 1));
+
+    ((void**)base)[-1] = object;
+#endif
+    return base;
+}
+
+static __inline void emutls_memalign_free(void *base) {
+#if EMUTLS_USE_POSIX_MEMALIGN
+    free(base);
+#else
+    /* The mallocated address is in ((void**)base)[-1] */
+    free(((void**)base)[-1]);
+#endif
+}
+
+/* Emulated TLS objects are always allocated at run-time. */
+static __inline void *emutls_allocate_object(__emutls_control *control) {
+    /* Use standard C types, check with gcc's emutls.o. */
+    typedef unsigned int gcc_word __attribute__((mode(word)));
+    typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
+    COMPILE_TIME_ASSERT(sizeof(size_t) == sizeof(gcc_word));
+    COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(gcc_pointer));
+    COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(void*));
+
+    size_t size = control->size;
+    size_t align = control->align;
+    if (align < sizeof(void*))
+        align = sizeof(void*);
+    /* Make sure that align is power of 2. */
+    if ((align & (align - 1)) != 0)
+        abort();
+
+    void* base = emutls_memalign_alloc(align, size);
+    if (control->value)
+        memcpy(base, control->value, size);
+    else
+        memset(base, 0, size);
+    return base;
+}
+
+static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static size_t emutls_num_object = 0;  /* number of allocated TLS objects */
+
+typedef struct emutls_address_array {
+    uintptr_t size;  /* number of elements in the 'data' array */
+    void* data[];
+} emutls_address_array;
+
+static pthread_key_t emutls_pthread_key;
+
+static void emutls_key_destructor(void* ptr) {
+    emutls_address_array* array = (emutls_address_array*)ptr;
+    uintptr_t i;
+    for (i = 0; i < array->size; ++i) {
+        if (array->data[i])
+            emutls_memalign_free(array->data[i]);
+    }
+    free(ptr);
+}
+
+static void emutls_init(void) {
+    if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0)
+        abort();
+}
+
+/* Returns control->object.index; set index if not allocated yet. */
+static __inline uintptr_t emutls_get_index(__emutls_control *control) {
+    uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE);
+    if (!index) {
+        static pthread_once_t once = PTHREAD_ONCE_INIT;
+        pthread_once(&once, emutls_init);
+        pthread_mutex_lock(&emutls_mutex);
+        index = control->object.index;
+        if (!index) {
+            index = ++emutls_num_object;
+            __atomic_store_n(&control->object.index, index, __ATOMIC_RELEASE);
+        }
+        pthread_mutex_unlock(&emutls_mutex);
+    }
+    return index;
+}
+
+/* Updates newly allocated thread local emutls_address_array. */
+static __inline void emutls_check_array_set_size(emutls_address_array *array,
+                                                 uintptr_t size) {
+    if (array == NULL)
+        abort();
+    array->size = size;
+    pthread_setspecific(emutls_pthread_key, (void*)array);
+}
+
+/* Returns the new 'data' array size, number of elements,
+ * which must be no smaller than the given index.
+ */
+static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) {
+   /* Need to allocate emutls_address_array with one extra slot
+    * to store the data array size.
+    * Round up the emutls_address_array size to multiple of 16.
+    */
+    return ((index + 1 + 15) & ~((uintptr_t)15)) - 1;
+}
+
+/* Returns the thread local emutls_address_array.
+ * Extends its size if necessary to hold address at index.
+ */
+static __inline emutls_address_array *
+emutls_get_address_array(uintptr_t index) {
+    emutls_address_array* array = pthread_getspecific(emutls_pthread_key);
+    if (array == NULL) {
+        uintptr_t new_size = emutls_new_data_array_size(index);
+        array = calloc(new_size + 1, sizeof(void*));
+        emutls_check_array_set_size(array, new_size);
+    } else if (index > array->size) {
+        uintptr_t orig_size = array->size;
+        uintptr_t new_size = emutls_new_data_array_size(index);
+        array = realloc(array, (new_size + 1) * sizeof(void*));
+        if (array)
+            memset(array->data + orig_size, 0,
+                   (new_size - orig_size) * sizeof(void*));
+        emutls_check_array_set_size(array, new_size);
+    }
+    return array;
+}
+
+void* __emutls_get_address(__emutls_control* control) {
+    uintptr_t index = emutls_get_index(control);
+    emutls_address_array* array = emutls_get_address_array(index);
+    if (array->data[index - 1] == NULL)
+        array->data[index - 1] = emutls_allocate_object(control);
+    return array->data[index - 1];
+}
diff --git a/compiler-rt/lib/builtins/enable_execute_stack.c b/compiler-rt/lib/builtins/enable_execute_stack.c
new file mode 100644
index 0000000..0dc3482
--- /dev/null
+++ b/compiler-rt/lib/builtins/enable_execute_stack.c
@@ -0,0 +1,72 @@
+/* ===-- enable_execute_stack.c - Implement __enable_execute_stack ---------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifndef _WIN32
+#include <sys/mman.h>
+#endif
+
+/* #include "config.h"
+ * FIXME: CMake - include when cmake system is ready.
+ * Remove #define HAVE_SYSCONF 1 line.
+ */
+#define HAVE_SYSCONF 1
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#else
+#ifndef __APPLE__
+#include <unistd.h>
+#endif /* __APPLE__ */
+#endif /* _WIN32 */
+
+#if __LP64__
+	#define TRAMPOLINE_SIZE 48
+#else
+	#define TRAMPOLINE_SIZE 40
+#endif
+
+/*
+ * The compiler generates calls to __enable_execute_stack() when creating 
+ * trampoline functions on the stack for use with nested functions.
+ * It is expected to mark the page(s) containing the address 
+ * and the next 48 bytes as executable.  Since the stack is normally rw-
+ * that means changing the protection on those page(s) to rwx. 
+ */
+
+COMPILER_RT_ABI void
+__enable_execute_stack(void* addr)
+{
+
+#if _WIN32
+	MEMORY_BASIC_INFORMATION mbi;
+	if (!VirtualQuery (addr, &mbi, sizeof(mbi)))
+		return; /* We should probably assert here because there is no return value */
+	VirtualProtect (mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &mbi.Protect);
+#else
+#if __APPLE__
+	/* On Darwin, pagesize is always 4096 bytes */
+	const uintptr_t pageSize = 4096;
+#elif !defined(HAVE_SYSCONF)
+#error "HAVE_SYSCONF not defined! See enable_execute_stack.c"
+#else
+        const uintptr_t pageSize = sysconf(_SC_PAGESIZE);
+#endif /* __APPLE__ */
+
+	const uintptr_t pageAlignMask = ~(pageSize-1);
+	uintptr_t p = (uintptr_t)addr;
+	unsigned char* startPage = (unsigned char*)(p & pageAlignMask);
+	unsigned char* endPage = (unsigned char*)((p+TRAMPOLINE_SIZE+pageSize) & pageAlignMask);
+	size_t length = endPage - startPage;
+	(void) mprotect((void *)startPage, length, PROT_READ | PROT_WRITE | PROT_EXEC);
+#endif
+}
diff --git a/compiler-rt/lib/builtins/eprintf.c b/compiler-rt/lib/builtins/eprintf.c
new file mode 100644
index 0000000..89f34b1
--- /dev/null
+++ b/compiler-rt/lib/builtins/eprintf.c
@@ -0,0 +1,35 @@
+/* ===---------- eprintf.c - Implements __eprintf --------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+
+
+#include "int_lib.h"
+#include <stdio.h>
+
+
+/*
+ * __eprintf() was used in an old version of <assert.h>.
+ * It can eventually go away, but it is needed when linking
+ * .o files built with the old <assert.h>.
+ *
+ * It should never be exported from a dylib, so it is marked
+ * visibility hidden.
+ */
+#ifndef _WIN32
+__attribute__((visibility("hidden")))
+#endif
+COMPILER_RT_ABI void
+__eprintf(const char* format, const char* assertion_expression,
+	  const char* line, const char* file)
+{
+	fprintf(stderr, format, assertion_expression, line, file);
+	fflush(stderr);
+	compilerrt_abort();
+}
diff --git a/compiler-rt/lib/builtins/extenddftf2.c b/compiler-rt/lib/builtins/extenddftf2.c
new file mode 100644
index 0000000..86dab8f
--- /dev/null
+++ b/compiler-rt/lib/builtins/extenddftf2.c
@@ -0,0 +1,23 @@
+//===-- lib/extenddftf2.c - double -> quad conversion -------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#define SRC_DOUBLE
+#define DST_QUAD
+#include "fp_extend_impl.inc"
+
+COMPILER_RT_ABI long double __extenddftf2(double a) {
+    return __extendXfYf2__(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/extendhfsf2.c b/compiler-rt/lib/builtins/extendhfsf2.c
new file mode 100644
index 0000000..27115a4
--- /dev/null
+++ b/compiler-rt/lib/builtins/extendhfsf2.c
@@ -0,0 +1,25 @@
+//===-- lib/extendhfsf2.c - half -> single conversion -------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+
+#define SRC_HALF
+#define DST_SINGLE
+#include "fp_extend_impl.inc"
+
+ARM_EABI_FNALIAS(h2f, extendhfsf2)
+
+// Use a forwarding definition and noinline to implement a poor man's alias,
+// as there isn't a good cross-platform way of defining one.
+COMPILER_RT_ABI NOINLINE float __extendhfsf2(uint16_t a) {
+    return __extendXfYf2__(a);
+}
+
+COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) {
+    return __extendhfsf2(a);
+}
diff --git a/compiler-rt/lib/builtins/extendsfdf2.c b/compiler-rt/lib/builtins/extendsfdf2.c
new file mode 100644
index 0000000..7a267c2
--- /dev/null
+++ b/compiler-rt/lib/builtins/extendsfdf2.c
@@ -0,0 +1,19 @@
+//===-- lib/extendsfdf2.c - single -> double conversion -----------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+
+#define SRC_SINGLE
+#define DST_DOUBLE
+#include "fp_extend_impl.inc"
+
+ARM_EABI_FNALIAS(f2d, extendsfdf2)
+
+COMPILER_RT_ABI double __extendsfdf2(float a) {
+    return __extendXfYf2__(a);
+}
diff --git a/compiler-rt/lib/builtins/extendsftf2.c b/compiler-rt/lib/builtins/extendsftf2.c
new file mode 100644
index 0000000..2eeeba2
--- /dev/null
+++ b/compiler-rt/lib/builtins/extendsftf2.c
@@ -0,0 +1,23 @@
+//===-- lib/extendsftf2.c - single -> quad conversion -------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#define SRC_SINGLE
+#define DST_QUAD
+#include "fp_extend_impl.inc"
+
+COMPILER_RT_ABI long double __extendsftf2(float a) {
+    return __extendXfYf2__(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/ffsdi2.c b/compiler-rt/lib/builtins/ffsdi2.c
new file mode 100644
index 0000000..a5ac990
--- /dev/null
+++ b/compiler-rt/lib/builtins/ffsdi2.c
@@ -0,0 +1,33 @@
+/* ===-- ffsdi2.c - Implement __ffsdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ffsdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: the index of the least significant 1-bit in a, or
+ * the value zero if a is zero. The least significant bit is index one.
+ */
+
+COMPILER_RT_ABI si_int
+__ffsdi2(di_int a)
+{
+    dwords x;
+    x.all = a;
+    if (x.s.low == 0)
+    {
+        if (x.s.high == 0)
+            return 0;
+        return __builtin_ctz(x.s.high) + (1 + sizeof(si_int) * CHAR_BIT);
+    }
+    return __builtin_ctz(x.s.low) + 1;
+}
diff --git a/compiler-rt/lib/builtins/ffsti2.c b/compiler-rt/lib/builtins/ffsti2.c
new file mode 100644
index 0000000..dcdb3bd
--- /dev/null
+++ b/compiler-rt/lib/builtins/ffsti2.c
@@ -0,0 +1,37 @@
+/* ===-- ffsti2.c - Implement __ffsti2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ffsti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: the index of the least significant 1-bit in a, or
+ * the value zero if a is zero. The least significant bit is index one.
+ */
+
+COMPILER_RT_ABI si_int
+__ffsti2(ti_int a)
+{
+    twords x;
+    x.all = a;
+    if (x.s.low == 0)
+    {
+        if (x.s.high == 0)
+            return 0;
+        return __builtin_ctzll(x.s.high) + (1 + sizeof(di_int) * CHAR_BIT);
+    }
+    return __builtin_ctzll(x.s.low) + 1;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/fixdfdi.c b/compiler-rt/lib/builtins/fixdfdi.c
new file mode 100644
index 0000000..14283ef
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixdfdi.c
@@ -0,0 +1,46 @@
+/* ===-- fixdfdi.c - Implement __fixdfdi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+ARM_EABI_FNALIAS(d2lz, fixdfdi)
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int __fixunsdfdi(double a);
+
+COMPILER_RT_ABI di_int
+__fixdfdi(double a)
+{
+    if (a < 0.0) {
+        return -__fixunsdfdi(-a);
+    }
+    return __fixunsdfdi(a);
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
+typedef di_int fixint_t;
+typedef du_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI di_int
+__fixdfdi(fp_t a) {
+    return __fixint(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fixdfsi.c b/compiler-rt/lib/builtins/fixdfsi.c
new file mode 100644
index 0000000..704e65b
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixdfsi.c
@@ -0,0 +1,22 @@
+/* ===-- fixdfsi.c - Implement __fixdfsi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+typedef si_int fixint_t;
+typedef su_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+ARM_EABI_FNALIAS(d2iz, fixdfsi)
+
+COMPILER_RT_ABI si_int
+__fixdfsi(fp_t a) {
+    return __fixint(a);
+}
diff --git a/compiler-rt/lib/builtins/fixdfti.c b/compiler-rt/lib/builtins/fixdfti.c
new file mode 100644
index 0000000..aaf225e
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixdfti.c
@@ -0,0 +1,26 @@
+/* ===-- fixdfti.c - Implement __fixdfti -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+typedef ti_int fixint_t;
+typedef tu_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI ti_int
+__fixdfti(fp_t a) {
+    return __fixint(a);
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/fixsfdi.c b/compiler-rt/lib/builtins/fixsfdi.c
new file mode 100644
index 0000000..fab47e2
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixsfdi.c
@@ -0,0 +1,47 @@
+/* ===-- fixsfdi.c - Implement __fixsfdi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(f2lz, fixsfdi)
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int __fixunssfdi(float a);
+
+COMPILER_RT_ABI di_int
+__fixsfdi(float a)
+{
+    if (a < 0.0f) {
+        return -__fixunssfdi(-a);
+    }
+    return __fixunssfdi(a);
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
+typedef di_int fixint_t;
+typedef du_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI di_int
+__fixsfdi(fp_t a) {
+    return __fixint(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fixsfsi.c b/compiler-rt/lib/builtins/fixsfsi.c
new file mode 100644
index 0000000..f045536
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixsfsi.c
@@ -0,0 +1,22 @@
+/* ===-- fixsfsi.c - Implement __fixsfsi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+typedef si_int fixint_t;
+typedef su_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+ARM_EABI_FNALIAS(f2iz, fixsfsi)
+
+COMPILER_RT_ABI si_int
+__fixsfsi(fp_t a) {
+    return __fixint(a);
+}
diff --git a/compiler-rt/lib/builtins/fixsfti.c b/compiler-rt/lib/builtins/fixsfti.c
new file mode 100644
index 0000000..3a159b3
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixsfti.c
@@ -0,0 +1,26 @@
+/* ===-- fixsfti.c - Implement __fixsfti -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+typedef ti_int fixint_t;
+typedef tu_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI ti_int
+__fixsfti(fp_t a) {
+    return __fixint(a);
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/fixtfdi.c b/compiler-rt/lib/builtins/fixtfdi.c
new file mode 100644
index 0000000..bc9dea1
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixtfdi.c
@@ -0,0 +1,23 @@
+/* ===-- fixtfdi.c - Implement __fixtfdi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+typedef di_int fixint_t;
+typedef du_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI di_int
+__fixtfdi(fp_t a) {
+    return __fixint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixtfsi.c b/compiler-rt/lib/builtins/fixtfsi.c
new file mode 100644
index 0000000..feb3de8
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixtfsi.c
@@ -0,0 +1,23 @@
+/* ===-- fixtfsi.c - Implement __fixtfsi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+typedef si_int fixint_t;
+typedef su_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI si_int
+__fixtfsi(fp_t a) {
+    return __fixint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixtfti.c b/compiler-rt/lib/builtins/fixtfti.c
new file mode 100644
index 0000000..ee4ada8
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixtfti.c
@@ -0,0 +1,23 @@
+/* ===-- fixtfti.c - Implement __fixtfti -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+typedef ti_int fixint_t;
+typedef tu_int fixuint_t;
+#include "fp_fixint_impl.inc"
+
+COMPILER_RT_ABI ti_int
+__fixtfti(fp_t a) {
+    return __fixint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixunsdfdi.c b/compiler-rt/lib/builtins/fixunsdfdi.c
new file mode 100644
index 0000000..4b0bc9e
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunsdfdi.c
@@ -0,0 +1,44 @@
+/* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(d2ulz, fixunsdfdi)
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int
+__fixunsdfdi(double a)
+{
+    if (a <= 0.0) return 0;
+    su_int high = a / 4294967296.f;               /* a / 0x1p32f; */
+    su_int low = a - (double)high * 4294967296.f; /* high * 0x1p32f; */
+    return ((du_int)high << 32) | low;
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
+typedef du_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI du_int
+__fixunsdfdi(fp_t a) {
+    return __fixuint(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fixunsdfsi.c b/compiler-rt/lib/builtins/fixunsdfsi.c
new file mode 100644
index 0000000..232d342
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunsdfsi.c
@@ -0,0 +1,21 @@
+/* ===-- fixunsdfsi.c - Implement __fixunsdfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+typedef su_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+ARM_EABI_FNALIAS(d2uiz, fixunsdfsi)
+
+COMPILER_RT_ABI su_int
+__fixunsdfsi(fp_t a) {
+    return __fixuint(a);
+}
diff --git a/compiler-rt/lib/builtins/fixunsdfti.c b/compiler-rt/lib/builtins/fixunsdfti.c
new file mode 100644
index 0000000..f8046a0
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunsdfti.c
@@ -0,0 +1,23 @@
+/* ===-- fixunsdfti.c - Implement __fixunsdfti -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+typedef tu_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI tu_int
+__fixunsdfti(fp_t a) {
+    return __fixuint(a);
+}
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/fixunssfdi.c b/compiler-rt/lib/builtins/fixunssfdi.c
new file mode 100644
index 0000000..f8ebab8
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunssfdi.c
@@ -0,0 +1,45 @@
+/* ===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(f2ulz, fixunssfdi)
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int
+__fixunssfdi(float a)
+{
+    if (a <= 0.0f) return 0;
+    double da = a;
+    su_int high = da / 4294967296.f;               /* da / 0x1p32f; */
+    su_int low = da - (double)high * 4294967296.f; /* high * 0x1p32f; */
+    return ((du_int)high << 32) | low;
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
+typedef du_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI du_int
+__fixunssfdi(fp_t a) {
+    return __fixuint(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fixunssfsi.c b/compiler-rt/lib/builtins/fixunssfsi.c
new file mode 100644
index 0000000..cc2b05b
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunssfsi.c
@@ -0,0 +1,25 @@
+/* ===-- fixunssfsi.c - Implement __fixunssfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunssfsi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+typedef su_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+ARM_EABI_FNALIAS(f2uiz, fixunssfsi)
+
+COMPILER_RT_ABI su_int
+__fixunssfsi(fp_t a) {
+    return __fixuint(a);
+}
diff --git a/compiler-rt/lib/builtins/fixunssfti.c b/compiler-rt/lib/builtins/fixunssfti.c
new file mode 100644
index 0000000..862d7bd
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunssfti.c
@@ -0,0 +1,26 @@
+/* ===-- fixunssfti.c - Implement __fixunssfti -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunssfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT)
+typedef tu_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI tu_int
+__fixunssfti(fp_t a) {
+    return __fixuint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixunstfdi.c b/compiler-rt/lib/builtins/fixunstfdi.c
new file mode 100644
index 0000000..b2995f6
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunstfdi.c
@@ -0,0 +1,22 @@
+/* ===-- fixunstfdi.c - Implement __fixunstfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+typedef du_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI du_int
+__fixunstfdi(fp_t a) {
+    return __fixuint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixunstfsi.c b/compiler-rt/lib/builtins/fixunstfsi.c
new file mode 100644
index 0000000..b5d3f6a
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunstfsi.c
@@ -0,0 +1,22 @@
+/* ===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+typedef su_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI su_int
+__fixunstfsi(fp_t a) {
+    return __fixuint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixunstfti.c b/compiler-rt/lib/builtins/fixunstfti.c
new file mode 100644
index 0000000..22ff9df
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunstfti.c
@@ -0,0 +1,22 @@
+/* ===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+typedef tu_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
+COMPILER_RT_ABI tu_int
+__fixunstfti(fp_t a) {
+    return __fixuint(a);
+}
+#endif
diff --git a/compiler-rt/lib/builtins/fixunsxfdi.c b/compiler-rt/lib/builtins/fixunsxfdi.c
new file mode 100644
index 0000000..075304e
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunsxfdi.c
@@ -0,0 +1,46 @@
+/* ===-- fixunsxfdi.c - Implement __fixunsxfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsxfdi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: convert a to a unsigned long long, rounding toward zero.
+ *          Negative values all become zero.
+ */
+
+/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+ *             du_int is a 64 bit integral type
+ *             value in long double is representable in du_int or is negative 
+ *                 (no range checking performed)
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI du_int
+__fixunsxfdi(long double a)
+{
+    long_double_bits fb;
+    fb.f = a;
+    int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
+    if (e < 0 || (fb.u.high.s.low & 0x00008000))
+        return 0;
+    if ((unsigned)e > sizeof(du_int) * CHAR_BIT)
+        return ~(du_int)0;
+    return fb.u.low.all >> (63 - e);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fixunsxfsi.c b/compiler-rt/lib/builtins/fixunsxfsi.c
new file mode 100644
index 0000000..c3c70f7
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunsxfsi.c
@@ -0,0 +1,45 @@
+/* ===-- fixunsxfsi.c - Implement __fixunsxfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsxfsi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: convert a to a unsigned int, rounding toward zero.
+ *          Negative values all become zero.
+ */
+
+/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+ *             su_int is a 32 bit integral type
+ *             value in long double is representable in su_int or is negative 
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI su_int
+__fixunsxfsi(long double a)
+{
+    long_double_bits fb;
+    fb.f = a;
+    int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
+    if (e < 0 || (fb.u.high.s.low & 0x00008000))
+        return 0;
+    if ((unsigned)e > sizeof(su_int) * CHAR_BIT)
+        return ~(su_int)0;
+    return fb.u.low.s.high >> (31 - e);
+}
+
+#endif /* !_ARCH_PPC */
diff --git a/compiler-rt/lib/builtins/fixunsxfti.c b/compiler-rt/lib/builtins/fixunsxfti.c
new file mode 100644
index 0000000..fb39d00
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixunsxfti.c
@@ -0,0 +1,50 @@
+/* ===-- fixunsxfti.c - Implement __fixunsxfti -----------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsxfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a unsigned long long, rounding toward zero.
+ *          Negative values all become zero.
+ */
+
+/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+ *             tu_int is a 128 bit integral type
+ *             value in long double is representable in tu_int or is negative 
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI tu_int
+__fixunsxfti(long double a)
+{
+    long_double_bits fb;
+    fb.f = a;
+    int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
+    if (e < 0 || (fb.u.high.s.low & 0x00008000))
+        return 0;
+    if ((unsigned)e > sizeof(tu_int) * CHAR_BIT)
+        return ~(tu_int)0;
+    tu_int r = fb.u.low.all;
+    if (e > 63)
+        r <<= (e - 63);
+    else
+        r >>= (63 - e);
+    return r;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/fixxfdi.c b/compiler-rt/lib/builtins/fixxfdi.c
new file mode 100644
index 0000000..011787f
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixxfdi.c
@@ -0,0 +1,48 @@
+/* ===-- fixxfdi.c - Implement __fixxfdi -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixxfdi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: convert a to a signed long long, rounding toward zero. */
+
+/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+ *             di_int is a 64 bit integral type
+ *             value in long double is representable in di_int (no range checking performed)
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI di_int
+__fixxfdi(long double a)
+{
+    const di_int di_max = (di_int)((~(du_int)0) / 2);
+    const di_int di_min = -di_max - 1;
+    long_double_bits fb;
+    fb.f = a;
+    int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
+    if (e < 0)
+        return 0;
+    if ((unsigned)e >= sizeof(di_int) * CHAR_BIT)
+        return a > 0 ? di_max : di_min;
+    di_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15);
+    di_int r = fb.u.low.all;
+    r = (du_int)r >> (63 - e);
+    return (r ^ s) - s;
+}
+
+#endif /* !_ARCH_PPC */
diff --git a/compiler-rt/lib/builtins/fixxfti.c b/compiler-rt/lib/builtins/fixxfti.c
new file mode 100644
index 0000000..968a4f0
--- /dev/null
+++ b/compiler-rt/lib/builtins/fixxfti.c
@@ -0,0 +1,51 @@
+/* ===-- fixxfti.c - Implement __fixxfti -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixxfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a signed long long, rounding toward zero. */
+
+/* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+ *             ti_int is a 128 bit integral type
+ *             value in long double is representable in ti_int
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI ti_int
+__fixxfti(long double a)
+{
+    const ti_int ti_max = (ti_int)((~(tu_int)0) / 2);
+    const ti_int ti_min = -ti_max - 1;
+    long_double_bits fb;
+    fb.f = a;
+    int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
+    if (e < 0)
+        return 0;
+    ti_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15);
+    ti_int r = fb.u.low.all;
+    if ((unsigned)e >= sizeof(ti_int) * CHAR_BIT)
+        return a > 0 ? ti_max : ti_min;
+    if (e > 63)
+        r <<= (e - 63);
+    else
+        r >>= (63 - e);
+    return (r ^ s) - s;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/floatdidf.c b/compiler-rt/lib/builtins/floatdidf.c
new file mode 100644
index 0000000..a300c9f
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatdidf.c
@@ -0,0 +1,107 @@
+/*===-- floatdidf.c - Implement __floatdidf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ * This file implements __floatdidf for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: convert a to a double, rounding toward even. */
+
+/* Assumption: double is a IEEE 64 bit floating point type 
+ *             di_int is a 64 bit integral type
+ */
+
+/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
+
+ARM_EABI_FNALIAS(l2d, floatdidf)
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; we'll set the inexact flag
+ * as a side-effect of this computation.
+ */
+
+COMPILER_RT_ABI double
+__floatdidf(di_int a)
+{
+	static const double twop52 = 4503599627370496.0; // 0x1.0p52
+	static const double twop32 = 4294967296.0; // 0x1.0p32
+	
+	union { int64_t x; double d; } low = { .d = twop52 };
+	
+	const double high = (int32_t)(a >> 32) * twop32;
+	low.x |= a & INT64_C(0x00000000ffffffff);
+	
+	const double result = (high - twop52) + low.d;
+	return result;
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no flags to
+ * set, and we don't want to code-gen to an unknown soft-float implementation.
+ */
+
+COMPILER_RT_ABI double
+__floatdidf(di_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(di_int) * CHAR_BIT;
+    const di_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int sd = N - __builtin_clzll(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > DBL_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit DBL_MANT_DIG-1 bits to the right of 1
+         * Q = bit DBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+        */
+        switch (sd)
+        {
+        case DBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case DBL_MANT_DIG + 2:
+            break;
+        default:
+            a = ((du_int)a >> (sd - (DBL_MANT_DIG+2))) |
+                ((a & ((du_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
+        if (a & ((du_int)1 << DBL_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (DBL_MANT_DIG - sd);
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    double_bits fb;
+    fb.u.high = ((su_int)s & 0x80000000) |        /* sign */
+                ((e + 1023) << 20)      |        /* exponent */
+                ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
+    fb.u.low = (su_int)a;                         /* mantissa-low */
+    return fb.f;
+}
+#endif
diff --git a/compiler-rt/lib/builtins/floatdisf.c b/compiler-rt/lib/builtins/floatdisf.c
new file mode 100644
index 0000000..3e47580
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatdisf.c
@@ -0,0 +1,80 @@
+/*===-- floatdisf.c - Implement __floatdisf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ * This file implements __floatdisf for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+/* Returns: convert a to a float, rounding toward even.*/
+
+/* Assumption: float is a IEEE 32 bit floating point type 
+ *             di_int is a 64 bit integral type
+ */ 
+
+/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(l2f, floatdisf)
+
+COMPILER_RT_ABI float
+__floatdisf(di_int a)
+{
+    if (a == 0)
+        return 0.0F;
+    const unsigned N = sizeof(di_int) * CHAR_BIT;
+    const di_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int sd = N - __builtin_clzll(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > FLT_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx 
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR 
+         *                                                12345678901234567890123456 
+         *  1 = msb 1 bit 
+         *  P = bit FLT_MANT_DIG-1 bits to the right of 1 
+         *  Q = bit FLT_MANT_DIG bits to the right of 1   
+         *  R = "or" of all bits to the right of Q 
+         */
+        switch (sd)
+        {
+        case FLT_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case FLT_MANT_DIG + 2:
+            break;
+        default:
+            a = ((du_int)a >> (sd - (FLT_MANT_DIG+2))) |
+                ((a & ((du_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
+        if (a & ((du_int)1 << FLT_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (FLT_MANT_DIG - sd);
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    float_bits fb;
+    fb.u = ((su_int)s & 0x80000000) |  /* sign */
+           ((e + 127) << 23)       |  /* exponent */
+           ((su_int)a & 0x007FFFFF);   /* mantissa */
+    return fb.f;
+}
diff --git a/compiler-rt/lib/builtins/floatditf.c b/compiler-rt/lib/builtins/floatditf.c
new file mode 100644
index 0000000..cd51dd8
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatditf.c
@@ -0,0 +1,50 @@
+//===-- lib/floatditf.c - integer -> quad-precision conversion ----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements di_int to quad-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __floatditf(di_int a) {
+
+    const int aWidth = sizeof a * CHAR_BIT;
+
+    // Handle zero as a special case to protect clz
+    if (a == 0)
+        return fromRep(0);
+
+    // All other cases begin by extracting the sign and absolute value of a
+    rep_t sign = 0;
+    du_int aAbs = (du_int)a;
+    if (a < 0) {
+        sign = signBit;
+        aAbs = ~(du_int)a + 1U;
+    }
+
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clzll(aAbs);
+    rep_t result;
+
+    // Shift a into the significand field, rounding if it is a right-shift
+    const int shift = significandBits - exponent;
+    result = (rep_t)aAbs << shift ^ implicitBit;
+
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    // Insert the sign bit and return
+    return fromRep(result | sign);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/floatdixf.c b/compiler-rt/lib/builtins/floatdixf.c
new file mode 100644
index 0000000..d39e81d
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatdixf.c
@@ -0,0 +1,46 @@
+/* ===-- floatdixf.c - Implement __floatdixf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatdixf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: convert a to a long double, rounding toward even. */
+
+/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+ *             di_int is a 64 bit integral type
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI long double
+__floatdixf(di_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(di_int) * CHAR_BIT;
+    const di_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int clz = __builtin_clzll(a);
+    int e = (N - 1) - clz ;    /* exponent */
+    long_double_bits fb;
+    fb.u.high.s.low = ((su_int)s & 0x00008000) |  /* sign */
+		      (e + 16383);                /* exponent */
+    fb.u.low.all = a << clz;                    /* mantissa */
+    return fb.f;
+}
+
+#endif /* !_ARCH_PPC */
diff --git a/compiler-rt/lib/builtins/floatsidf.c b/compiler-rt/lib/builtins/floatsidf.c
new file mode 100644
index 0000000..1cf99b7
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatsidf.c
@@ -0,0 +1,53 @@
+//===-- lib/floatsidf.c - integer -> double-precision conversion --*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements integer to double-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(i2d, floatsidf)
+
+COMPILER_RT_ABI fp_t
+__floatsidf(int a) {
+    
+    const int aWidth = sizeof a * CHAR_BIT;
+    
+    // Handle zero as a special case to protect clz
+    if (a == 0)
+        return fromRep(0);
+    
+    // All other cases begin by extracting the sign and absolute value of a
+    rep_t sign = 0;
+    if (a < 0) {
+        sign = signBit;
+        a = -a;
+    }
+    
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clz(a);
+    rep_t result;
+    
+    // Shift a into the significand field and clear the implicit bit.  Extra
+    // cast to unsigned int is necessary to get the correct behavior for
+    // the input INT_MIN.
+    const int shift = significandBits - exponent;
+    result = (rep_t)(unsigned int)a << shift ^ implicitBit;
+    
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    // Insert the sign bit and return
+    return fromRep(result | sign);
+}
diff --git a/compiler-rt/lib/builtins/floatsisf.c b/compiler-rt/lib/builtins/floatsisf.c
new file mode 100644
index 0000000..467dd1d
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatsisf.c
@@ -0,0 +1,59 @@
+//===-- lib/floatsisf.c - integer -> single-precision conversion --*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements integer to single-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(i2f, floatsisf)
+
+COMPILER_RT_ABI fp_t
+__floatsisf(int a) {
+    
+    const int aWidth = sizeof a * CHAR_BIT;
+    
+    // Handle zero as a special case to protect clz
+    if (a == 0)
+        return fromRep(0);
+    
+    // All other cases begin by extracting the sign and absolute value of a
+    rep_t sign = 0;
+    if (a < 0) {
+        sign = signBit;
+        a = -a;
+    }
+    
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clz(a);
+    rep_t result;
+    
+    // Shift a into the significand field, rounding if it is a right-shift
+    if (exponent <= significandBits) {
+        const int shift = significandBits - exponent;
+        result = (rep_t)a << shift ^ implicitBit;
+    } else {
+        const int shift = exponent - significandBits;
+        result = (rep_t)a >> shift ^ implicitBit;
+        rep_t round = (rep_t)a << (typeWidth - shift);
+        if (round > signBit) result++;
+        if (round == signBit) result += result & 1;
+    }
+    
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    // Insert the sign bit and return
+    return fromRep(result | sign);
+}
diff --git a/compiler-rt/lib/builtins/floatsitf.c b/compiler-rt/lib/builtins/floatsitf.c
new file mode 100644
index 0000000..f0abca3
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatsitf.c
@@ -0,0 +1,50 @@
+//===-- lib/floatsitf.c - integer -> quad-precision conversion ----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements integer to quad-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __floatsitf(int a) {
+
+    const int aWidth = sizeof a * CHAR_BIT;
+
+    // Handle zero as a special case to protect clz
+    if (a == 0)
+        return fromRep(0);
+
+    // All other cases begin by extracting the sign and absolute value of a
+    rep_t sign = 0;
+    unsigned aAbs = (unsigned)a;
+    if (a < 0) {
+        sign = signBit;
+        aAbs = ~(unsigned)a + 1U;
+    }
+
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clz(aAbs);
+    rep_t result;
+
+    // Shift a into the significand field and clear the implicit bit.
+    const int shift = significandBits - exponent;
+    result = (rep_t)aAbs << shift ^ implicitBit;
+
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    // Insert the sign bit and return
+    return fromRep(result | sign);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/floattidf.c b/compiler-rt/lib/builtins/floattidf.c
new file mode 100644
index 0000000..6331ba5
--- /dev/null
+++ b/compiler-rt/lib/builtins/floattidf.c
@@ -0,0 +1,83 @@
+/* ===-- floattidf.c - Implement __floattidf -------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floattidf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a double, rounding toward even.*/
+
+/* Assumption: double is a IEEE 64 bit floating point type 
+ *            ti_int is a 128 bit integral type
+ */
+
+/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */ 
+
+COMPILER_RT_ABI double
+__floattidf(ti_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(ti_int) * CHAR_BIT;
+    const ti_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > DBL_MANT_DIG)
+    {
+        /* start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                               12345678901234567890123456
+         * 1 = msb 1 bit
+         * P = bit DBL_MANT_DIG-1 bits to the right of 1
+         * Q = bit DBL_MANT_DIG bits to the right of 1
+         * R = "or" of all bits to the right of Q
+         */
+        switch (sd)
+        {
+        case DBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case DBL_MANT_DIG + 2:
+            break;
+        default:
+            a = ((tu_int)a >> (sd - (DBL_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << DBL_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (DBL_MANT_DIG - sd);
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    double_bits fb;
+    fb.u.s.high = ((su_int)s & 0x80000000) |        /* sign */
+                ((e + 1023) << 20)      |        /* exponent */
+                ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
+    fb.u.s.low = (su_int)a;                         /* mantissa-low */
+    return fb.f;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/floattisf.c b/compiler-rt/lib/builtins/floattisf.c
new file mode 100644
index 0000000..f1b585f
--- /dev/null
+++ b/compiler-rt/lib/builtins/floattisf.c
@@ -0,0 +1,82 @@
+/* ===-- floattisf.c - Implement __floattisf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floattisf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a float, rounding toward even. */
+
+/* Assumption: float is a IEEE 32 bit floating point type 
+ *             ti_int is a 128 bit integral type
+ */
+
+/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
+
+COMPILER_RT_ABI float
+__floattisf(ti_int a)
+{
+    if (a == 0)
+        return 0.0F;
+    const unsigned N = sizeof(ti_int) * CHAR_BIT;
+    const ti_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > FLT_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+        * finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+        *                                                12345678901234567890123456
+        *  1 = msb 1 bit
+        *  P = bit FLT_MANT_DIG-1 bits to the right of 1
+        *  Q = bit FLT_MANT_DIG bits to the right of 1
+        *  R = "or" of all bits to the right of Q
+        */
+        switch (sd)
+        {
+        case FLT_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case FLT_MANT_DIG + 2:
+            break;
+        default:
+            a = ((tu_int)a >> (sd - (FLT_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << FLT_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (FLT_MANT_DIG - sd);
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    float_bits fb;
+    fb.u = ((su_int)s & 0x80000000) |  /* sign */
+           ((e + 127) << 23)       |  /* exponent */
+           ((su_int)a & 0x007FFFFF);   /* mantissa */
+    return fb.f;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/floattixf.c b/compiler-rt/lib/builtins/floattixf.c
new file mode 100644
index 0000000..1203b3a
--- /dev/null
+++ b/compiler-rt/lib/builtins/floattixf.c
@@ -0,0 +1,84 @@
+/* ===-- floattixf.c - Implement __floattixf -------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floattixf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a long double, rounding toward even. */
+
+/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+ *             ti_int is a 128 bit integral type
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI long double
+__floattixf(ti_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(ti_int) * CHAR_BIT;
+    const ti_int s = a >> (N-1);
+    a = (a ^ s) - s;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > LDBL_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit LDBL_MANT_DIG-1 bits to the right of 1
+         *  Q = bit LDBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+         */
+        switch (sd)
+        {
+        case LDBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case LDBL_MANT_DIG + 2:
+            break;
+        default:
+            a = ((tu_int)a >> (sd - (LDBL_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << LDBL_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (LDBL_MANT_DIG - sd);
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    }
+    long_double_bits fb;
+    fb.u.high.s.low = ((su_int)s & 0x8000) |        /* sign */
+                    (e + 16383);                  /* exponent */
+    fb.u.low.all = (du_int)a;                     /* mantissa */
+    return fb.f;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/floatundidf.c b/compiler-rt/lib/builtins/floatundidf.c
new file mode 100644
index 0000000..67aa86e
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatundidf.c
@@ -0,0 +1,106 @@
+/* ===-- floatundidf.c - Implement __floatundidf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatundidf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+/* Returns: convert a to a double, rounding toward even. */
+
+/* Assumption: double is a IEEE 64 bit floating point type 
+ *             du_int is a 64 bit integral type
+ */
+
+/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(ul2d, floatundidf)
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; we'll set the inexact flag
+ * as a side-effect of this computation.
+ */
+
+COMPILER_RT_ABI double
+__floatundidf(du_int a)
+{
+	static const double twop52 = 4503599627370496.0; // 0x1.0p52
+	static const double twop84 = 19342813113834066795298816.0; // 0x1.0p84
+	static const double twop84_plus_twop52 = 19342813118337666422669312.0; // 0x1.00000001p84
+	
+	union { uint64_t x; double d; } high = { .d = twop84 };
+	union { uint64_t x; double d; } low = { .d = twop52 };
+	
+	high.x |= a >> 32;
+	low.x |= a & UINT64_C(0x00000000ffffffff);
+	
+	const double result = (high.d - twop84_plus_twop52) + low.d;
+	return result;
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no flags to
+ * set, and we don't want to code-gen to an unknown soft-float implementation.
+ */ 
+
+COMPILER_RT_ABI double
+__floatundidf(du_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(du_int) * CHAR_BIT;
+    int sd = N - __builtin_clzll(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > DBL_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit DBL_MANT_DIG-1 bits to the right of 1
+         *  Q = bit DBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+         */
+        switch (sd)
+        {
+        case DBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case DBL_MANT_DIG + 2:
+            break;
+        default:
+            a = (a >> (sd - (DBL_MANT_DIG+2))) |
+                ((a & ((du_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
+        if (a & ((du_int)1 << DBL_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (DBL_MANT_DIG - sd);
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    double_bits fb;
+    fb.u.high = ((e + 1023) << 20)      |        /* exponent */
+                ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
+    fb.u.low = (su_int)a;                         /* mantissa-low  */
+    return fb.f;
+}
+#endif
diff --git a/compiler-rt/lib/builtins/floatundisf.c b/compiler-rt/lib/builtins/floatundisf.c
new file mode 100644
index 0000000..713a44a
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatundisf.c
@@ -0,0 +1,77 @@
+/*===-- floatundisf.c - Implement __floatundisf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatundisf for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+/* Returns: convert a to a float, rounding toward even. */
+
+/* Assumption: float is a IEEE 32 bit floating point type 
+ *            du_int is a 64 bit integral type
+ */
+
+/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(ul2f, floatundisf)
+
+COMPILER_RT_ABI float
+__floatundisf(du_int a)
+{
+    if (a == 0)
+        return 0.0F;
+    const unsigned N = sizeof(du_int) * CHAR_BIT;
+    int sd = N - __builtin_clzll(a);  /* number of significant digits */
+    int e = sd - 1;             /* 8 exponent */
+    if (sd > FLT_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit FLT_MANT_DIG-1 bits to the right of 1
+         *  Q = bit FLT_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+         */
+        switch (sd)
+        {
+        case FLT_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case FLT_MANT_DIG + 2:
+            break;
+        default:
+            a = (a >> (sd - (FLT_MANT_DIG+2))) |
+                ((a & ((du_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
+        if (a & ((du_int)1 << FLT_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (FLT_MANT_DIG - sd);
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    float_bits fb;
+    fb.u = ((e + 127) << 23)       |  /* exponent */
+           ((su_int)a & 0x007FFFFF);  /* mantissa */
+    return fb.f;
+}
diff --git a/compiler-rt/lib/builtins/floatunditf.c b/compiler-rt/lib/builtins/floatunditf.c
new file mode 100644
index 0000000..8098e95
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatunditf.c
@@ -0,0 +1,40 @@
+//===-- lib/floatunditf.c - uint -> quad-precision conversion -----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements du_int to quad-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __floatunditf(du_int a) {
+
+    const int aWidth = sizeof a * CHAR_BIT;
+
+    // Handle zero as a special case to protect clz
+    if (a == 0) return fromRep(0);
+
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clzll(a);
+    rep_t result;
+
+    // Shift a into the significand field and clear the implicit bit.
+    const int shift = significandBits - exponent;
+    result = (rep_t)a << shift ^ implicitBit;
+
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    return fromRep(result);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/floatundixf.c b/compiler-rt/lib/builtins/floatundixf.c
new file mode 100644
index 0000000..ca5e06d
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatundixf.c
@@ -0,0 +1,42 @@
+/* ===-- floatundixf.c - Implement __floatundixf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatundixf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: convert a to a long double, rounding toward even. */
+
+/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+ *             du_int is a 64 bit integral type
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+COMPILER_RT_ABI long double
+__floatundixf(du_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(du_int) * CHAR_BIT;
+    int clz = __builtin_clzll(a);
+    int e = (N - 1) - clz ;    /* exponent */
+    long_double_bits fb;
+    fb.u.high.s.low = (e + 16383);              /* exponent */
+    fb.u.low.all = a << clz;                   /* mantissa */
+    return fb.f;
+}
+
+#endif /* _ARCH_PPC */
diff --git a/compiler-rt/lib/builtins/floatunsidf.c b/compiler-rt/lib/builtins/floatunsidf.c
new file mode 100644
index 0000000..445e180
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatunsidf.c
@@ -0,0 +1,42 @@
+//===-- lib/floatunsidf.c - uint -> double-precision conversion ---*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements unsigned integer to double-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(ui2d, floatunsidf)
+
+COMPILER_RT_ABI fp_t
+__floatunsidf(unsigned int a) {
+    
+    const int aWidth = sizeof a * CHAR_BIT;
+    
+    // Handle zero as a special case to protect clz
+    if (a == 0) return fromRep(0);
+    
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clz(a);
+    rep_t result;
+    
+    // Shift a into the significand field and clear the implicit bit.
+    const int shift = significandBits - exponent;
+    result = (rep_t)a << shift ^ implicitBit;
+    
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    return fromRep(result);
+}
diff --git a/compiler-rt/lib/builtins/floatunsisf.c b/compiler-rt/lib/builtins/floatunsisf.c
new file mode 100644
index 0000000..ea6f161
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatunsisf.c
@@ -0,0 +1,50 @@
+//===-- lib/floatunsisf.c - uint -> single-precision conversion ---*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements unsigned integer to single-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+#include "int_lib.h"
+
+ARM_EABI_FNALIAS(ui2f, floatunsisf)
+
+COMPILER_RT_ABI fp_t
+__floatunsisf(unsigned int a) {
+    
+    const int aWidth = sizeof a * CHAR_BIT;
+    
+    // Handle zero as a special case to protect clz
+    if (a == 0) return fromRep(0);
+    
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clz(a);
+    rep_t result;
+    
+    // Shift a into the significand field, rounding if it is a right-shift
+    if (exponent <= significandBits) {
+        const int shift = significandBits - exponent;
+        result = (rep_t)a << shift ^ implicitBit;
+    } else {
+        const int shift = exponent - significandBits;
+        result = (rep_t)a >> shift ^ implicitBit;
+        rep_t round = (rep_t)a << (typeWidth - shift);
+        if (round > signBit) result++;
+        if (round == signBit) result += result & 1;
+    }
+    
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    return fromRep(result);
+}
diff --git a/compiler-rt/lib/builtins/floatunsitf.c b/compiler-rt/lib/builtins/floatunsitf.c
new file mode 100644
index 0000000..1cd1842
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatunsitf.c
@@ -0,0 +1,40 @@
+//===-- lib/floatunsitf.c - uint -> quad-precision conversion -----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements unsigned integer to quad-precision conversion for the
+// compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even
+// mode.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __floatunsitf(unsigned int a) {
+
+    const int aWidth = sizeof a * CHAR_BIT;
+
+    // Handle zero as a special case to protect clz
+    if (a == 0) return fromRep(0);
+
+    // Exponent of (fp_t)a is the width of abs(a).
+    const int exponent = (aWidth - 1) - __builtin_clz(a);
+    rep_t result;
+
+    // Shift a into the significand field and clear the implicit bit.
+    const int shift = significandBits - exponent;
+    result = (rep_t)a << shift ^ implicitBit;
+
+    // Insert the exponent
+    result += (rep_t)(exponent + exponentBias) << significandBits;
+    return fromRep(result);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/floatuntidf.c b/compiler-rt/lib/builtins/floatuntidf.c
new file mode 100644
index 0000000..06202d9
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatuntidf.c
@@ -0,0 +1,80 @@
+/* ===-- floatuntidf.c - Implement __floatuntidf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatuntidf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a double, rounding toward even. */
+
+/* Assumption: double is a IEEE 64 bit floating point type 
+ *             tu_int is a 128 bit integral type
+ */
+
+/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
+
+COMPILER_RT_ABI double
+__floatuntidf(tu_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(tu_int) * CHAR_BIT;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > DBL_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit DBL_MANT_DIG-1 bits to the right of 1
+         *  Q = bit DBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+         */
+        switch (sd)
+        {
+        case DBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case DBL_MANT_DIG + 2:
+            break;
+        default:
+            a = (a >> (sd - (DBL_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + DBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << DBL_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (DBL_MANT_DIG - sd);
+        /* a is now rounded to DBL_MANT_DIG bits */
+    }
+    double_bits fb;
+    fb.u.s.high = ((e + 1023) << 20)      |        /* exponent */
+                ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
+    fb.u.s.low = (su_int)a;                         /* mantissa-low */
+    return fb.f;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/floatuntisf.c b/compiler-rt/lib/builtins/floatuntisf.c
new file mode 100644
index 0000000..c0dd027
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatuntisf.c
@@ -0,0 +1,79 @@
+/* ===-- floatuntisf.c - Implement __floatuntisf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatuntisf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a float, rounding toward even. */
+
+/* Assumption: float is a IEEE 32 bit floating point type 
+ *             tu_int is a 128 bit integral type
+ */
+
+/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
+
+COMPILER_RT_ABI float
+__floatuntisf(tu_int a)
+{
+    if (a == 0)
+        return 0.0F;
+    const unsigned N = sizeof(tu_int) * CHAR_BIT;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > FLT_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit FLT_MANT_DIG-1 bits to the right of 1
+         *  Q = bit FLT_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+	 */
+        switch (sd)
+        {
+        case FLT_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case FLT_MANT_DIG + 2:
+            break;
+        default:
+            a = (a >> (sd - (FLT_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + FLT_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << FLT_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (FLT_MANT_DIG - sd);
+        /* a is now rounded to FLT_MANT_DIG bits */
+    }
+    float_bits fb;
+    fb.u = ((e + 127) << 23)       |  /* exponent */
+           ((su_int)a & 0x007FFFFF);  /* mantissa */
+    return fb.f;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/floatuntixf.c b/compiler-rt/lib/builtins/floatuntixf.c
new file mode 100644
index 0000000..ea81cb1
--- /dev/null
+++ b/compiler-rt/lib/builtins/floatuntixf.c
@@ -0,0 +1,81 @@
+/* ===-- floatuntixf.c - Implement __floatuntixf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatuntixf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: convert a to a long double, rounding toward even. */
+
+/* Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+ *             tu_int is a 128 bit integral type
+ */
+
+/* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+ * 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+ */
+
+COMPILER_RT_ABI long double
+__floatuntixf(tu_int a)
+{
+    if (a == 0)
+        return 0.0;
+    const unsigned N = sizeof(tu_int) * CHAR_BIT;
+    int sd = N - __clzti2(a);  /* number of significant digits */
+    int e = sd - 1;             /* exponent */
+    if (sd > LDBL_MANT_DIG)
+    {
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
+         *                                                12345678901234567890123456
+         *  1 = msb 1 bit
+         *  P = bit LDBL_MANT_DIG-1 bits to the right of 1
+         *  Q = bit LDBL_MANT_DIG bits to the right of 1
+         *  R = "or" of all bits to the right of Q
+	 */
+        switch (sd)
+        {
+        case LDBL_MANT_DIG + 1:
+            a <<= 1;
+            break;
+        case LDBL_MANT_DIG + 2:
+            break;
+        default:
+            a = (a >> (sd - (LDBL_MANT_DIG+2))) |
+                ((a & ((tu_int)(-1) >> ((N + LDBL_MANT_DIG+2) - sd))) != 0);
+        };
+        /* finish: */
+        a |= (a & 4) != 0;  /* Or P into R */
+        ++a;  /* round - this step may add a significant bit */
+        a >>= 2;  /* dump Q and R */
+        /* a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits */
+        if (a & ((tu_int)1 << LDBL_MANT_DIG))
+        {
+            a >>= 1;
+            ++e;
+        }
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    }
+    else
+    {
+        a <<= (LDBL_MANT_DIG - sd);
+        /* a is now rounded to LDBL_MANT_DIG bits */
+    }
+    long_double_bits fb;
+    fb.u.high.s.low = (e + 16383);                  /* exponent */
+    fb.u.low.all = (du_int)a;                     /* mantissa */
+    return fb.f;
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/fp_add_impl.inc b/compiler-rt/lib/builtins/fp_add_impl.inc
new file mode 100644
index 0000000..b47be1b
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_add_impl.inc
@@ -0,0 +1,144 @@
+//===----- lib/fp_add_impl.inc - floaing point addition -----------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements soft-float addition with the IEEE-754 default rounding
+// (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#include "fp_lib.h"
+
+static __inline fp_t __addXf3__(fp_t a, fp_t b) {
+    rep_t aRep = toRep(a);
+    rep_t bRep = toRep(b);
+    const rep_t aAbs = aRep & absMask;
+    const rep_t bAbs = bRep & absMask;
+
+    // Detect if a or b is zero, infinity, or NaN.
+    if (aAbs - REP_C(1) >= infRep - REP_C(1) ||
+        bAbs - REP_C(1) >= infRep - REP_C(1)) {
+        // NaN + anything = qNaN
+        if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
+        // anything + NaN = qNaN
+        if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
+
+        if (aAbs == infRep) {
+            // +/-infinity + -/+infinity = qNaN
+            if ((toRep(a) ^ toRep(b)) == signBit) return fromRep(qnanRep);
+            // +/-infinity + anything remaining = +/- infinity
+            else return a;
+        }
+
+        // anything remaining + +/-infinity = +/-infinity
+        if (bAbs == infRep) return b;
+
+        // zero + anything = anything
+        if (!aAbs) {
+            // but we need to get the sign right for zero + zero
+            if (!bAbs) return fromRep(toRep(a) & toRep(b));
+            else return b;
+        }
+
+        // anything + zero = anything
+        if (!bAbs) return a;
+    }
+
+    // Swap a and b if necessary so that a has the larger absolute value.
+    if (bAbs > aAbs) {
+        const rep_t temp = aRep;
+        aRep = bRep;
+        bRep = temp;
+    }
+
+    // Extract the exponent and significand from the (possibly swapped) a and b.
+    int aExponent = aRep >> significandBits & maxExponent;
+    int bExponent = bRep >> significandBits & maxExponent;
+    rep_t aSignificand = aRep & significandMask;
+    rep_t bSignificand = bRep & significandMask;
+
+    // Normalize any denormals, and adjust the exponent accordingly.
+    if (aExponent == 0) aExponent = normalize(&aSignificand);
+    if (bExponent == 0) bExponent = normalize(&bSignificand);
+
+    // The sign of the result is the sign of the larger operand, a.  If they
+    // have opposite signs, we are performing a subtraction; otherwise addition.
+    const rep_t resultSign = aRep & signBit;
+    const bool subtraction = (aRep ^ bRep) & signBit;
+
+    // Shift the significands to give us round, guard and sticky, and or in the
+    // implicit significand bit.  (If we fell through from the denormal path it
+    // was already set by normalize( ), but setting it twice won't hurt
+    // anything.)
+    aSignificand = (aSignificand | implicitBit) << 3;
+    bSignificand = (bSignificand | implicitBit) << 3;
+
+    // Shift the significand of b by the difference in exponents, with a sticky
+    // bottom bit to get rounding correct.
+    const unsigned int align = aExponent - bExponent;
+    if (align) {
+        if (align < typeWidth) {
+            const bool sticky = bSignificand << (typeWidth - align);
+            bSignificand = bSignificand >> align | sticky;
+        } else {
+            bSignificand = 1; // sticky; b is known to be non-zero.
+        }
+    }
+    if (subtraction) {
+        aSignificand -= bSignificand;
+        // If a == -b, return +zero.
+        if (aSignificand == 0) return fromRep(0);
+
+        // If partial cancellation occured, we need to left-shift the result
+        // and adjust the exponent:
+        if (aSignificand < implicitBit << 3) {
+            const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3);
+            aSignificand <<= shift;
+            aExponent -= shift;
+        }
+    }
+    else /* addition */ {
+        aSignificand += bSignificand;
+
+        // If the addition carried up, we need to right-shift the result and
+        // adjust the exponent:
+        if (aSignificand & implicitBit << 4) {
+            const bool sticky = aSignificand & 1;
+            aSignificand = aSignificand >> 1 | sticky;
+            aExponent += 1;
+        }
+    }
+
+    // If we have overflowed the type, return +/- infinity:
+    if (aExponent >= maxExponent) return fromRep(infRep | resultSign);
+
+    if (aExponent <= 0) {
+        // Result is denormal before rounding; the exponent is zero and we
+        // need to shift the significand.
+        const int shift = 1 - aExponent;
+        const bool sticky = aSignificand << (typeWidth - shift);
+        aSignificand = aSignificand >> shift | sticky;
+        aExponent = 0;
+    }
+
+    // Low three bits are round, guard, and sticky.
+    const int roundGuardSticky = aSignificand & 0x7;
+
+    // Shift the significand into place, and mask off the implicit bit.
+    rep_t result = aSignificand >> 3 & significandMask;
+
+    // Insert the exponent and sign.
+    result |= (rep_t)aExponent << significandBits;
+    result |= resultSign;
+
+    // Final rounding.  The result may overflow to infinity, but that is the
+    // correct result in that case.
+    if (roundGuardSticky > 0x4) result++;
+    if (roundGuardSticky == 0x4) result += result & 1;
+    return fromRep(result);
+}
diff --git a/compiler-rt/lib/builtins/fp_extend.h b/compiler-rt/lib/builtins/fp_extend.h
new file mode 100644
index 0000000..6d95a06
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_extend.h
@@ -0,0 +1,89 @@
+//===-lib/fp_extend.h - low precision -> high precision conversion -*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Set source and destination setting
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FP_EXTEND_HEADER
+#define FP_EXTEND_HEADER
+
+#include "int_lib.h"
+
+#if defined SRC_SINGLE
+typedef float src_t;
+typedef uint32_t src_rep_t;
+#define SRC_REP_C UINT32_C
+static const int srcSigBits = 23;
+#define src_rep_t_clz __builtin_clz
+
+#elif defined SRC_DOUBLE
+typedef double src_t;
+typedef uint64_t src_rep_t;
+#define SRC_REP_C UINT64_C
+static const int srcSigBits = 52;
+static __inline int src_rep_t_clz(src_rep_t a) {
+#if defined __LP64__
+    return __builtin_clzl(a);
+#else
+    if (a & REP_C(0xffffffff00000000))
+        return __builtin_clz(a >> 32);
+    else
+        return 32 + __builtin_clz(a & REP_C(0xffffffff));
+#endif
+}
+
+#elif defined SRC_HALF
+typedef uint16_t src_t;
+typedef uint16_t src_rep_t;
+#define SRC_REP_C UINT16_C
+static const int srcSigBits = 10;
+#define src_rep_t_clz __builtin_clz
+
+#else
+#error Source should be half, single, or double precision!
+#endif //end source precision
+
+#if defined DST_SINGLE
+typedef float dst_t;
+typedef uint32_t dst_rep_t;
+#define DST_REP_C UINT32_C
+static const int dstSigBits = 23;
+
+#elif defined DST_DOUBLE
+typedef double dst_t;
+typedef uint64_t dst_rep_t;
+#define DST_REP_C UINT64_C
+static const int dstSigBits = 52;
+
+#elif defined DST_QUAD
+typedef long double dst_t;
+typedef __uint128_t dst_rep_t;
+#define DST_REP_C (__uint128_t)
+static const int dstSigBits = 112;
+
+#else
+#error Destination should be single, double, or quad precision!
+#endif //end destination precision
+
+// End of specialization parameters.  Two helper routines for conversion to and
+// from the representation of floating-point data as integer values follow.
+
+static __inline src_rep_t srcToRep(src_t x) {
+    const union { src_t f; src_rep_t i; } rep = {.f = x};
+    return rep.i;
+}
+
+static __inline dst_t dstFromRep(dst_rep_t x) {
+    const union { dst_t f; dst_rep_t i; } rep = {.i = x};
+    return rep.f;
+}
+// End helper routines.  Conversion implementation follows.
+
+#endif //FP_EXTEND_HEADER
diff --git a/compiler-rt/lib/builtins/fp_extend_impl.inc b/compiler-rt/lib/builtins/fp_extend_impl.inc
new file mode 100644
index 0000000..b785cc7
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_extend_impl.inc
@@ -0,0 +1,108 @@
+//=-lib/fp_extend_impl.inc - low precision -> high precision conversion -*-- -//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a fairly generic conversion from a narrower to a wider
+// IEEE-754 floating-point type.  The constants and types defined following the
+// includes below parameterize the conversion.
+//
+// It does not support types that don't use the usual IEEE-754 interchange
+// formats; specifically, some work would be needed to adapt it to
+// (for example) the Intel 80-bit format or PowerPC double-double format.
+//
+// Note please, however, that this implementation is only intended to support
+// *widening* operations; if you need to convert to a *narrower* floating-point
+// type (e.g. double -> float), then this routine will not do what you want it
+// to.
+//
+// It also requires that integer types at least as large as both formats
+// are available on the target platform; this may pose a problem when trying
+// to add support for quad on some 32-bit systems, for example.  You also may
+// run into trouble finding an appropriate CLZ function for wide source types;
+// you will likely need to roll your own on some platforms.
+//
+// Finally, the following assumptions are made:
+//
+// 1. floating-point types and integer types have the same endianness on the
+//    target platform
+//
+// 2. quiet NaNs, if supported, are indicated by the leading bit of the
+//    significand field being set
+//
+//===----------------------------------------------------------------------===//
+
+#include "fp_extend.h"
+
+static __inline dst_t __extendXfYf2__(src_t a) {
+    // Various constants whose values follow from the type parameters.
+    // Any reasonable optimizer will fold and propagate all of these.
+    const int srcBits = sizeof(src_t)*CHAR_BIT;
+    const int srcExpBits = srcBits - srcSigBits - 1;
+    const int srcInfExp = (1 << srcExpBits) - 1;
+    const int srcExpBias = srcInfExp >> 1;
+
+    const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits;
+    const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits;
+    const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits);
+    const src_rep_t srcAbsMask = srcSignMask - 1;
+    const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1);
+    const src_rep_t srcNaNCode = srcQNaN - 1;
+
+    const int dstBits = sizeof(dst_t)*CHAR_BIT;
+    const int dstExpBits = dstBits - dstSigBits - 1;
+    const int dstInfExp = (1 << dstExpBits) - 1;
+    const int dstExpBias = dstInfExp >> 1;
+
+    const dst_rep_t dstMinNormal = DST_REP_C(1) << dstSigBits;
+
+    // Break a into a sign and representation of the absolute value
+    const src_rep_t aRep = srcToRep(a);
+    const src_rep_t aAbs = aRep & srcAbsMask;
+    const src_rep_t sign = aRep & srcSignMask;
+    dst_rep_t absResult;
+
+    // If sizeof(src_rep_t) < sizeof(int), the subtraction result is promoted
+    // to (signed) int.  To avoid that, explicitly cast to src_rep_t.
+    if ((src_rep_t)(aAbs - srcMinNormal) < srcInfinity - srcMinNormal) {
+        // a is a normal number.
+        // Extend to the destination type by shifting the significand and
+        // exponent into the proper position and rebiasing the exponent.
+        absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits);
+        absResult += (dst_rep_t)(dstExpBias - srcExpBias) << dstSigBits;
+    }
+
+    else if (aAbs >= srcInfinity) {
+        // a is NaN or infinity.
+        // Conjure the result by beginning with infinity, then setting the qNaN
+        // bit (if needed) and right-aligning the rest of the trailing NaN
+        // payload field.
+        absResult = (dst_rep_t)dstInfExp << dstSigBits;
+        absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigBits - srcSigBits);
+        absResult |= (dst_rep_t)(aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
+    }
+
+    else if (aAbs) {
+        // a is denormal.
+        // renormalize the significand and clear the leading bit, then insert
+        // the correct adjusted exponent in the destination type.
+        const int scale = src_rep_t_clz(aAbs) - src_rep_t_clz(srcMinNormal);
+        absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits + scale);
+        absResult ^= dstMinNormal;
+        const int resultExponent = dstExpBias - srcExpBias - scale + 1;
+        absResult |= (dst_rep_t)resultExponent << dstSigBits;
+    }
+
+    else {
+        // a is zero.
+        absResult = 0;
+    }
+
+    // Apply the signbit to (dst_t)abs(a).
+    const dst_rep_t result = absResult | (dst_rep_t)sign << (dstBits - srcBits);
+    return dstFromRep(result);
+}
diff --git a/compiler-rt/lib/builtins/fp_fixint_impl.inc b/compiler-rt/lib/builtins/fp_fixint_impl.inc
new file mode 100644
index 0000000..da70d4d
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_fixint_impl.inc
@@ -0,0 +1,41 @@
+//===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements float to integer conversion for the
+// compiler-rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "fp_lib.h"
+
+static __inline fixint_t __fixint(fp_t a) {
+    const fixint_t fixint_max = (fixint_t)((~(fixuint_t)0) / 2);
+    const fixint_t fixint_min = -fixint_max - 1;
+    // Break a into sign, exponent, significand
+    const rep_t aRep = toRep(a);
+    const rep_t aAbs = aRep & absMask;
+    const fixint_t sign = aRep & signBit ? -1 : 1;
+    const int exponent = (aAbs >> significandBits) - exponentBias;
+    const rep_t significand = (aAbs & significandMask) | implicitBit;
+
+    // If exponent is negative, the result is zero.
+    if (exponent < 0)
+        return 0;
+
+    // If the value is too large for the integer type, saturate.
+    if ((unsigned)exponent >= sizeof(fixint_t) * CHAR_BIT)
+        return sign == 1 ? fixint_max : fixint_min;
+
+    // If 0 <= exponent < significandBits, right shift to get the result.
+    // Otherwise, shift left.
+    if (exponent < significandBits)
+        return sign * (significand >> (significandBits - exponent));
+    else
+        return sign * ((fixint_t)significand << (exponent - significandBits));
+}
diff --git a/compiler-rt/lib/builtins/fp_fixuint_impl.inc b/compiler-rt/lib/builtins/fp_fixuint_impl.inc
new file mode 100644
index 0000000..d68ccf2
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_fixuint_impl.inc
@@ -0,0 +1,39 @@
+//===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements float to unsigned integer conversion for the
+// compiler-rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "fp_lib.h"
+
+static __inline fixuint_t __fixuint(fp_t a) {
+    // Break a into sign, exponent, significand
+    const rep_t aRep = toRep(a);
+    const rep_t aAbs = aRep & absMask;
+    const int sign = aRep & signBit ? -1 : 1;
+    const int exponent = (aAbs >> significandBits) - exponentBias;
+    const rep_t significand = (aAbs & significandMask) | implicitBit;
+
+    // If either the value or the exponent is negative, the result is zero.
+    if (sign == -1 || exponent < 0)
+        return 0;
+
+    // If the value is too large for the integer type, saturate.
+    if ((unsigned)exponent >= sizeof(fixuint_t) * CHAR_BIT)
+        return ~(fixuint_t)0;
+
+    // If 0 <= exponent < significandBits, right shift to get the result.
+    // Otherwise, shift left.
+    if (exponent < significandBits)
+        return significand >> (significandBits - exponent);
+    else
+        return (fixuint_t)significand << (exponent - significandBits);
+}
diff --git a/compiler-rt/lib/builtins/fp_lib.h b/compiler-rt/lib/builtins/fp_lib.h
new file mode 100644
index 0000000..223fb98
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_lib.h
@@ -0,0 +1,270 @@
+//===-- lib/fp_lib.h - Floating-point utilities -------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a configuration header for soft-float routines in compiler-rt.
+// This file does not provide any part of the compiler-rt interface, but defines
+// many useful constants and utility routines that are used in the
+// implementation of the soft-float routines in compiler-rt.
+//
+// Assumes that float, double and long double correspond to the IEEE-754
+// binary32, binary64 and binary 128 types, respectively, and that integer
+// endianness matches floating point endianness on the target platform.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FP_LIB_HEADER
+#define FP_LIB_HEADER
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <limits.h>
+#include "int_lib.h"
+
+// x86_64 FreeBSD prior v9.3 define fixed-width types incorrectly in
+// 32-bit mode.
+#if defined(__FreeBSD__) && defined(__i386__)
+# include <sys/param.h>
+# if __FreeBSD_version < 903000  // v9.3
+#  define uint64_t unsigned long long
+#  define int64_t long long
+#  undef UINT64_C
+#  define UINT64_C(c) (c ## ULL)
+# endif
+#endif
+
+#if defined SINGLE_PRECISION
+
+typedef uint32_t rep_t;
+typedef int32_t srep_t;
+typedef float fp_t;
+#define REP_C UINT32_C
+#define significandBits 23
+
+static __inline int rep_clz(rep_t a) {
+    return __builtin_clz(a);
+}
+
+// 32x32 --> 64 bit multiply
+static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
+    const uint64_t product = (uint64_t)a*b;
+    *hi = product >> 32;
+    *lo = product;
+}
+COMPILER_RT_ABI fp_t __addsf3(fp_t a, fp_t b);
+
+#elif defined DOUBLE_PRECISION
+
+typedef uint64_t rep_t;
+typedef int64_t srep_t;
+typedef double fp_t;
+#define REP_C UINT64_C
+#define significandBits 52
+
+static __inline int rep_clz(rep_t a) {
+#if defined __LP64__
+    return __builtin_clzl(a);
+#else
+    if (a & REP_C(0xffffffff00000000))
+        return __builtin_clz(a >> 32);
+    else
+        return 32 + __builtin_clz(a & REP_C(0xffffffff));
+#endif
+}
+
+#define loWord(a) (a & 0xffffffffU)
+#define hiWord(a) (a >> 32)
+
+// 64x64 -> 128 wide multiply for platforms that don't have such an operation;
+// many 64-bit platforms have this operation, but they tend to have hardware
+// floating-point, so we don't bother with a special case for them here.
+static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
+    // Each of the component 32x32 -> 64 products
+    const uint64_t plolo = loWord(a) * loWord(b);
+    const uint64_t plohi = loWord(a) * hiWord(b);
+    const uint64_t philo = hiWord(a) * loWord(b);
+    const uint64_t phihi = hiWord(a) * hiWord(b);
+    // Sum terms that contribute to lo in a way that allows us to get the carry
+    const uint64_t r0 = loWord(plolo);
+    const uint64_t r1 = hiWord(plolo) + loWord(plohi) + loWord(philo);
+    *lo = r0 + (r1 << 32);
+    // Sum terms contributing to hi with the carry from lo
+    *hi = hiWord(plohi) + hiWord(philo) + hiWord(r1) + phihi;
+}
+#undef loWord
+#undef hiWord
+
+COMPILER_RT_ABI fp_t __adddf3(fp_t a, fp_t b);
+
+#elif defined QUAD_PRECISION
+#if __LDBL_MANT_DIG__ == 113
+#define CRT_LDBL_128BIT
+typedef __uint128_t rep_t;
+typedef __int128_t srep_t;
+typedef long double fp_t;
+#define REP_C (__uint128_t)
+// Note: Since there is no explicit way to tell compiler the constant is a
+// 128-bit integer, we let the constant be casted to 128-bit integer
+#define significandBits 112
+
+static __inline int rep_clz(rep_t a) {
+    const union
+        {
+             __uint128_t ll;
+#if _YUGA_BIG_ENDIAN
+             struct { uint64_t high, low; } s;
+#else
+             struct { uint64_t low, high; } s;
+#endif
+        } uu = { .ll = a };
+
+    uint64_t word;
+    uint64_t add;
+
+    if (uu.s.high){
+        word = uu.s.high;
+        add = 0;
+    }
+    else{
+        word = uu.s.low;
+        add = 64;
+    }
+    return __builtin_clzll(word) + add;
+}
+
+#define Word_LoMask   UINT64_C(0x00000000ffffffff)
+#define Word_HiMask   UINT64_C(0xffffffff00000000)
+#define Word_FullMask UINT64_C(0xffffffffffffffff)
+#define Word_1(a) (uint64_t)((a >> 96) & Word_LoMask)
+#define Word_2(a) (uint64_t)((a >> 64) & Word_LoMask)
+#define Word_3(a) (uint64_t)((a >> 32) & Word_LoMask)
+#define Word_4(a) (uint64_t)(a & Word_LoMask)
+
+// 128x128 -> 256 wide multiply for platforms that don't have such an operation;
+// many 64-bit platforms have this operation, but they tend to have hardware
+// floating-point, so we don't bother with a special case for them here.
+static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {
+
+    const uint64_t product11 = Word_1(a) * Word_1(b);
+    const uint64_t product12 = Word_1(a) * Word_2(b);
+    const uint64_t product13 = Word_1(a) * Word_3(b);
+    const uint64_t product14 = Word_1(a) * Word_4(b);
+    const uint64_t product21 = Word_2(a) * Word_1(b);
+    const uint64_t product22 = Word_2(a) * Word_2(b);
+    const uint64_t product23 = Word_2(a) * Word_3(b);
+    const uint64_t product24 = Word_2(a) * Word_4(b);
+    const uint64_t product31 = Word_3(a) * Word_1(b);
+    const uint64_t product32 = Word_3(a) * Word_2(b);
+    const uint64_t product33 = Word_3(a) * Word_3(b);
+    const uint64_t product34 = Word_3(a) * Word_4(b);
+    const uint64_t product41 = Word_4(a) * Word_1(b);
+    const uint64_t product42 = Word_4(a) * Word_2(b);
+    const uint64_t product43 = Word_4(a) * Word_3(b);
+    const uint64_t product44 = Word_4(a) * Word_4(b);
+
+    const __uint128_t sum0 = (__uint128_t)product44;
+    const __uint128_t sum1 = (__uint128_t)product34 +
+                             (__uint128_t)product43;
+    const __uint128_t sum2 = (__uint128_t)product24 +
+                             (__uint128_t)product33 +
+                             (__uint128_t)product42;
+    const __uint128_t sum3 = (__uint128_t)product14 +
+                             (__uint128_t)product23 +
+                             (__uint128_t)product32 +
+                             (__uint128_t)product41;
+    const __uint128_t sum4 = (__uint128_t)product13 +
+                             (__uint128_t)product22 +
+                             (__uint128_t)product31;
+    const __uint128_t sum5 = (__uint128_t)product12 +
+                             (__uint128_t)product21;
+    const __uint128_t sum6 = (__uint128_t)product11;
+
+    const __uint128_t r0 = (sum0 & Word_FullMask) +
+                           ((sum1 & Word_LoMask) << 32);
+    const __uint128_t r1 = (sum0 >> 64) +
+                           ((sum1 >> 32) & Word_FullMask) +
+                           (sum2 & Word_FullMask) +
+                           ((sum3 << 32) & Word_HiMask);
+
+    *lo = r0 + (r1 << 64);
+    *hi = (r1 >> 64) +
+          (sum1 >> 96) +
+          (sum2 >> 64) +
+          (sum3 >> 32) +
+          sum4 +
+          (sum5 << 32) +
+          (sum6 << 64);
+}
+#undef Word_1
+#undef Word_2
+#undef Word_3
+#undef Word_4
+#undef Word_HiMask
+#undef Word_LoMask
+#undef Word_FullMask
+#endif // __LDBL_MANT_DIG__ == 113
+#else
+#error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined.
+#endif
+
+#if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) || defined(CRT_LDBL_128BIT)
+#define typeWidth       (sizeof(rep_t)*CHAR_BIT)
+#define exponentBits    (typeWidth - significandBits - 1)
+#define maxExponent     ((1 << exponentBits) - 1)
+#define exponentBias    (maxExponent >> 1)
+
+#define implicitBit     (REP_C(1) << significandBits)
+#define significandMask (implicitBit - 1U)
+#define signBit         (REP_C(1) << (significandBits + exponentBits))
+#define absMask         (signBit - 1U)
+#define exponentMask    (absMask ^ significandMask)
+#define oneRep          ((rep_t)exponentBias << significandBits)
+#define infRep          exponentMask
+#define quietBit        (implicitBit >> 1)
+#define qnanRep         (exponentMask | quietBit)
+
+static __inline rep_t toRep(fp_t x) {
+    const union { fp_t f; rep_t i; } rep = {.f = x};
+    return rep.i;
+}
+
+static __inline fp_t fromRep(rep_t x) {
+    const union { fp_t f; rep_t i; } rep = {.i = x};
+    return rep.f;
+}
+
+static __inline int normalize(rep_t *significand) {
+    const int shift = rep_clz(*significand) - rep_clz(implicitBit);
+    *significand <<= shift;
+    return 1 - shift;
+}
+
+static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) {
+    *hi = *hi << count | *lo >> (typeWidth - count);
+    *lo = *lo << count;
+}
+
+static __inline void wideRightShiftWithSticky(rep_t *hi, rep_t *lo, unsigned int count) {
+    if (count < typeWidth) {
+        const bool sticky = *lo << (typeWidth - count);
+        *lo = *hi << (typeWidth - count) | *lo >> count | sticky;
+        *hi = *hi >> count;
+    }
+    else if (count < 2*typeWidth) {
+        const bool sticky = *hi << (2*typeWidth - count) | *lo;
+        *lo = *hi >> (count - typeWidth) | sticky;
+        *hi = 0;
+    } else {
+        const bool sticky = *hi | *lo;
+        *lo = sticky;
+        *hi = 0;
+    }
+}
+#endif
+
+#endif // FP_LIB_HEADER
diff --git a/compiler-rt/lib/builtins/fp_mul_impl.inc b/compiler-rt/lib/builtins/fp_mul_impl.inc
new file mode 100644
index 0000000..b34aa1b
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_mul_impl.inc
@@ -0,0 +1,116 @@
+//===---- lib/fp_mul_impl.inc - floating point multiplication -----*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements soft-float multiplication with the IEEE-754 default
+// rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#include "fp_lib.h"
+
+static __inline fp_t __mulXf3__(fp_t a, fp_t b) {
+    const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
+    const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
+    const rep_t productSign = (toRep(a) ^ toRep(b)) & signBit;
+
+    rep_t aSignificand = toRep(a) & significandMask;
+    rep_t bSignificand = toRep(b) & significandMask;
+    int scale = 0;
+
+    // Detect if a or b is zero, denormal, infinity, or NaN.
+    if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) {
+
+        const rep_t aAbs = toRep(a) & absMask;
+        const rep_t bAbs = toRep(b) & absMask;
+
+        // NaN * anything = qNaN
+        if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
+        // anything * NaN = qNaN
+        if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
+
+        if (aAbs == infRep) {
+            // infinity * non-zero = +/- infinity
+            if (bAbs) return fromRep(aAbs | productSign);
+            // infinity * zero = NaN
+            else return fromRep(qnanRep);
+        }
+
+        if (bAbs == infRep) {
+            //? non-zero * infinity = +/- infinity
+            if (aAbs) return fromRep(bAbs | productSign);
+            // zero * infinity = NaN
+            else return fromRep(qnanRep);
+        }
+
+        // zero * anything = +/- zero
+        if (!aAbs) return fromRep(productSign);
+        // anything * zero = +/- zero
+        if (!bAbs) return fromRep(productSign);
+
+        // one or both of a or b is denormal, the other (if applicable) is a
+        // normal number.  Renormalize one or both of a and b, and set scale to
+        // include the necessary exponent adjustment.
+        if (aAbs < implicitBit) scale += normalize(&aSignificand);
+        if (bAbs < implicitBit) scale += normalize(&bSignificand);
+    }
+
+    // Or in the implicit significand bit.  (If we fell through from the
+    // denormal path it was already set by normalize( ), but setting it twice
+    // won't hurt anything.)
+    aSignificand |= implicitBit;
+    bSignificand |= implicitBit;
+
+    // Get the significand of a*b.  Before multiplying the significands, shift
+    // one of them left to left-align it in the field.  Thus, the product will
+    // have (exponentBits + 2) integral digits, all but two of which must be
+    // zero.  Normalizing this result is just a conditional left-shift by one
+    // and bumping the exponent accordingly.
+    rep_t productHi, productLo;
+    wideMultiply(aSignificand, bSignificand << exponentBits,
+                 &productHi, &productLo);
+
+    int productExponent = aExponent + bExponent - exponentBias + scale;
+
+    // Normalize the significand, adjust exponent if needed.
+    if (productHi & implicitBit) productExponent++;
+    else wideLeftShift(&productHi, &productLo, 1);
+
+    // If we have overflowed the type, return +/- infinity.
+    if (productExponent >= maxExponent) return fromRep(infRep | productSign);
+
+    if (productExponent <= 0) {
+        // Result is denormal before rounding
+        //
+        // If the result is so small that it just underflows to zero, return
+        // a zero of the appropriate sign.  Mathematically there is no need to
+        // handle this case separately, but we make it a special case to
+        // simplify the shift logic.
+        const unsigned int shift = REP_C(1) - (unsigned int)productExponent;
+        if (shift >= typeWidth) return fromRep(productSign);
+
+        // Otherwise, shift the significand of the result so that the round
+        // bit is the high bit of productLo.
+        wideRightShiftWithSticky(&productHi, &productLo, shift);
+    }
+    else {
+        // Result is normal before rounding; insert the exponent.
+        productHi &= significandMask;
+        productHi |= (rep_t)productExponent << significandBits;
+    }
+
+    // Insert the sign of the result:
+    productHi |= productSign;
+
+    // Final rounding.  The final result may overflow to infinity, or underflow
+    // to zero, but those are the correct results in those cases.  We use the
+    // default IEEE-754 round-to-nearest, ties-to-even rounding mode.
+    if (productLo > signBit) productHi++;
+    if (productLo == signBit) productHi += productHi & 1;
+    return fromRep(productHi);
+}
diff --git a/compiler-rt/lib/builtins/fp_trunc.h b/compiler-rt/lib/builtins/fp_trunc.h
new file mode 100644
index 0000000..d5e79bb
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_trunc.h
@@ -0,0 +1,76 @@
+//=== lib/fp_trunc.h - high precision -> low precision conversion *- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Set source and destination precision setting
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FP_TRUNC_HEADER
+#define FP_TRUNC_HEADER
+
+#include "int_lib.h"
+
+#if defined SRC_SINGLE
+typedef float src_t;
+typedef uint32_t src_rep_t;
+#define SRC_REP_C UINT32_C
+static const int srcSigBits = 23;
+
+#elif defined SRC_DOUBLE
+typedef double src_t;
+typedef uint64_t src_rep_t;
+#define SRC_REP_C UINT64_C
+static const int srcSigBits = 52;
+
+#elif defined SRC_QUAD
+typedef long double src_t;
+typedef __uint128_t src_rep_t;
+#define SRC_REP_C (__uint128_t)
+static const int srcSigBits = 112;
+
+#else
+#error Source should be double precision or quad precision!
+#endif //end source precision
+
+#if defined DST_DOUBLE
+typedef double dst_t;
+typedef uint64_t dst_rep_t;
+#define DST_REP_C UINT64_C
+static const int dstSigBits = 52;
+
+#elif defined DST_SINGLE
+typedef float dst_t;
+typedef uint32_t dst_rep_t;
+#define DST_REP_C UINT32_C
+static const int dstSigBits = 23;
+
+#elif defined DST_HALF
+typedef uint16_t dst_t;
+typedef uint16_t dst_rep_t;
+#define DST_REP_C UINT16_C
+static const int dstSigBits = 10;
+
+#else
+#error Destination should be single precision or double precision!
+#endif //end destination precision
+
+// End of specialization parameters.  Two helper routines for conversion to and
+// from the representation of floating-point data as integer values follow.
+
+static __inline src_rep_t srcToRep(src_t x) {
+    const union { src_t f; src_rep_t i; } rep = {.f = x};
+    return rep.i;
+}
+
+static __inline dst_t dstFromRep(dst_rep_t x) {
+    const union { dst_t f; dst_rep_t i; } rep = {.i = x};
+    return rep.f;
+}
+
+#endif // FP_TRUNC_HEADER
diff --git a/compiler-rt/lib/builtins/fp_trunc_impl.inc b/compiler-rt/lib/builtins/fp_trunc_impl.inc
new file mode 100644
index 0000000..d88ae06
--- /dev/null
+++ b/compiler-rt/lib/builtins/fp_trunc_impl.inc
@@ -0,0 +1,135 @@
+//= lib/fp_trunc_impl.inc - high precision -> low precision conversion *-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a fairly generic conversion from a wider to a narrower
+// IEEE-754 floating-point type in the default (round to nearest, ties to even)
+// rounding mode.  The constants and types defined following the includes below
+// parameterize the conversion.
+//
+// This routine can be trivially adapted to support conversions to
+// half-precision or from quad-precision. It does not support types that don't
+// use the usual IEEE-754 interchange formats; specifically, some work would be
+// needed to adapt it to (for example) the Intel 80-bit format or PowerPC
+// double-double format.
+//
+// Note please, however, that this implementation is only intended to support
+// *narrowing* operations; if you need to convert to a *wider* floating-point
+// type (e.g. float -> double), then this routine will not do what you want it
+// to.
+//
+// It also requires that integer types at least as large as both formats
+// are available on the target platform; this may pose a problem when trying
+// to add support for quad on some 32-bit systems, for example.
+//
+// Finally, the following assumptions are made:
+//
+// 1. floating-point types and integer types have the same endianness on the
+//    target platform
+//
+// 2. quiet NaNs, if supported, are indicated by the leading bit of the
+//    significand field being set
+//
+//===----------------------------------------------------------------------===//
+
+#include "fp_trunc.h"
+
+static __inline dst_t __truncXfYf2__(src_t a) {
+    // Various constants whose values follow from the type parameters.
+    // Any reasonable optimizer will fold and propagate all of these.
+    const int srcBits = sizeof(src_t)*CHAR_BIT;
+    const int srcExpBits = srcBits - srcSigBits - 1;
+    const int srcInfExp = (1 << srcExpBits) - 1;
+    const int srcExpBias = srcInfExp >> 1;
+
+    const src_rep_t srcMinNormal = SRC_REP_C(1) << srcSigBits;
+    const src_rep_t srcSignificandMask = srcMinNormal - 1;
+    const src_rep_t srcInfinity = (src_rep_t)srcInfExp << srcSigBits;
+    const src_rep_t srcSignMask = SRC_REP_C(1) << (srcSigBits + srcExpBits);
+    const src_rep_t srcAbsMask = srcSignMask - 1;
+    const src_rep_t roundMask = (SRC_REP_C(1) << (srcSigBits - dstSigBits)) - 1;
+    const src_rep_t halfway = SRC_REP_C(1) << (srcSigBits - dstSigBits - 1);
+    const src_rep_t srcQNaN = SRC_REP_C(1) << (srcSigBits - 1);
+    const src_rep_t srcNaNCode = srcQNaN - 1;
+
+    const int dstBits = sizeof(dst_t)*CHAR_BIT;
+    const int dstExpBits = dstBits - dstSigBits - 1;
+    const int dstInfExp = (1 << dstExpBits) - 1;
+    const int dstExpBias = dstInfExp >> 1;
+
+    const int underflowExponent = srcExpBias + 1 - dstExpBias;
+    const int overflowExponent = srcExpBias + dstInfExp - dstExpBias;
+    const src_rep_t underflow = (src_rep_t)underflowExponent << srcSigBits;
+    const src_rep_t overflow = (src_rep_t)overflowExponent << srcSigBits;
+
+    const dst_rep_t dstQNaN = DST_REP_C(1) << (dstSigBits - 1);
+    const dst_rep_t dstNaNCode = dstQNaN - 1;
+
+    // Break a into a sign and representation of the absolute value
+    const src_rep_t aRep = srcToRep(a);
+    const src_rep_t aAbs = aRep & srcAbsMask;
+    const src_rep_t sign = aRep & srcSignMask;
+    dst_rep_t absResult;
+
+    if (aAbs - underflow < aAbs - overflow) {
+        // The exponent of a is within the range of normal numbers in the
+        // destination format.  We can convert by simply right-shifting with
+        // rounding and adjusting the exponent.
+        absResult = aAbs >> (srcSigBits - dstSigBits);
+        absResult -= (dst_rep_t)(srcExpBias - dstExpBias) << dstSigBits;
+
+        const src_rep_t roundBits = aAbs & roundMask;
+        // Round to nearest
+        if (roundBits > halfway)
+            absResult++;
+        // Ties to even
+        else if (roundBits == halfway)
+            absResult += absResult & 1;
+    }
+    else if (aAbs > srcInfinity) {
+        // a is NaN.
+        // Conjure the result by beginning with infinity, setting the qNaN
+        // bit and inserting the (truncated) trailing NaN field.
+        absResult = (dst_rep_t)dstInfExp << dstSigBits;
+        absResult |= dstQNaN;
+        absResult |= ((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode;
+    }
+    else if (aAbs >= overflow) {
+        // a overflows to infinity.
+        absResult = (dst_rep_t)dstInfExp << dstSigBits;
+    }
+    else {
+        // a underflows on conversion to the destination type or is an exact
+        // zero.  The result may be a denormal or zero.  Extract the exponent
+        // to get the shift amount for the denormalization.
+        const int aExp = aAbs >> srcSigBits;
+        const int shift = srcExpBias - dstExpBias - aExp + 1;
+
+        const src_rep_t significand = (aRep & srcSignificandMask) | srcMinNormal;
+
+        // Right shift by the denormalization amount with sticky.
+        if (shift > srcSigBits) {
+            absResult = 0;
+        } else {
+            const bool sticky = significand << (srcBits - shift);
+            src_rep_t denormalizedSignificand = significand >> shift | sticky;
+            absResult = denormalizedSignificand >> (srcSigBits - dstSigBits);
+            const src_rep_t roundBits = denormalizedSignificand & roundMask;
+            // Round to nearest
+            if (roundBits > halfway)
+                absResult++;
+            // Ties to even
+            else if (roundBits == halfway)
+                absResult += absResult & 1;
+        }
+    }
+
+    // Apply the signbit to (dst_t)abs(a).
+    const dst_rep_t result = absResult | sign >> (srcBits - dstBits);
+    return dstFromRep(result);
+}
diff --git a/compiler-rt/lib/builtins/gcc_personality_v0.c b/compiler-rt/lib/builtins/gcc_personality_v0.c
new file mode 100644
index 0000000..331dc2b
--- /dev/null
+++ b/compiler-rt/lib/builtins/gcc_personality_v0.c
@@ -0,0 +1,209 @@
+/* ===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ */
+
+#include "int_lib.h"
+
+#include <unwind.h>
+
+/*
+ * Pointer encodings documented at:
+ *   http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
+ */
+
+#define DW_EH_PE_omit      0xff  /* no data follows */
+
+#define DW_EH_PE_absptr    0x00
+#define DW_EH_PE_uleb128   0x01
+#define DW_EH_PE_udata2    0x02
+#define DW_EH_PE_udata4    0x03
+#define DW_EH_PE_udata8    0x04
+#define DW_EH_PE_sleb128   0x09
+#define DW_EH_PE_sdata2    0x0A
+#define DW_EH_PE_sdata4    0x0B
+#define DW_EH_PE_sdata8    0x0C
+
+#define DW_EH_PE_pcrel     0x10
+#define DW_EH_PE_textrel   0x20
+#define DW_EH_PE_datarel   0x30
+#define DW_EH_PE_funcrel   0x40
+#define DW_EH_PE_aligned   0x50  
+#define DW_EH_PE_indirect  0x80 /* gcc extension */
+
+
+
+/* read a uleb128 encoded value and advance pointer */
+static uintptr_t readULEB128(const uint8_t** data)
+{
+    uintptr_t result = 0;
+    uintptr_t shift = 0;
+    unsigned char byte;
+    const uint8_t* p = *data;
+    do {
+        byte = *p++;
+        result |= (byte & 0x7f) << shift;
+        shift += 7;
+    } while (byte & 0x80);
+    *data = p;
+    return result;
+}
+
+/* read a pointer encoded value and advance pointer */
+static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding)
+{
+    const uint8_t* p = *data;
+    uintptr_t result = 0;
+
+    if ( encoding == DW_EH_PE_omit ) 
+        return 0;
+
+    /* first get value */
+    switch (encoding & 0x0F) {
+        case DW_EH_PE_absptr:
+            result = *((const uintptr_t*)p);
+            p += sizeof(uintptr_t);
+            break;
+        case DW_EH_PE_uleb128:
+            result = readULEB128(&p);
+            break;
+        case DW_EH_PE_udata2:
+            result = *((const uint16_t*)p);
+            p += sizeof(uint16_t);
+            break;
+        case DW_EH_PE_udata4:
+            result = *((const uint32_t*)p);
+            p += sizeof(uint32_t);
+            break;
+        case DW_EH_PE_udata8:
+            result = *((const uint64_t*)p);
+            p += sizeof(uint64_t);
+            break;
+        case DW_EH_PE_sdata2:
+            result = *((const int16_t*)p);
+            p += sizeof(int16_t);
+            break;
+        case DW_EH_PE_sdata4:
+            result = *((const int32_t*)p);
+            p += sizeof(int32_t);
+            break;
+        case DW_EH_PE_sdata8:
+            result = *((const int64_t*)p);
+            p += sizeof(int64_t);
+            break;
+        case DW_EH_PE_sleb128:
+        default:
+            /* not supported */
+            compilerrt_abort();
+            break;
+    }
+
+    /* then add relative offset */
+    switch ( encoding & 0x70 ) {
+        case DW_EH_PE_absptr:
+            /* do nothing */
+            break;
+        case DW_EH_PE_pcrel:
+            result += (uintptr_t)(*data);
+            break;
+        case DW_EH_PE_textrel:
+        case DW_EH_PE_datarel:
+        case DW_EH_PE_funcrel:
+        case DW_EH_PE_aligned:
+        default:
+            /* not supported */
+            compilerrt_abort();
+            break;
+    }
+
+    /* then apply indirection */
+    if (encoding & DW_EH_PE_indirect) {
+        result = *((const uintptr_t*)result);
+    }
+
+    *data = p;
+    return result;
+}
+
+
+/*
+ * The C compiler makes references to __gcc_personality_v0 in
+ * the dwarf unwind information for translation units that use
+ * __attribute__((cleanup(xx))) on local variables.
+ * This personality routine is called by the system unwinder
+ * on each frame as the stack is unwound during a C++ exception
+ * throw through a C function compiled with -fexceptions.
+ */
+#if __USING_SJLJ_EXCEPTIONS__
+// the setjump-longjump based exceptions personality routine has a different name
+COMPILER_RT_ABI _Unwind_Reason_Code
+__gcc_personality_sj0(int version, _Unwind_Action actions,
+         uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
+         struct _Unwind_Context *context)
+#else
+COMPILER_RT_ABI _Unwind_Reason_Code
+__gcc_personality_v0(int version, _Unwind_Action actions,
+         uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
+         struct _Unwind_Context *context)
+#endif
+{
+    /* Since C does not have catch clauses, there is nothing to do during */
+    /* phase 1 (the search phase). */
+    if ( actions & _UA_SEARCH_PHASE ) 
+        return _URC_CONTINUE_UNWIND;
+        
+    /* There is nothing to do if there is no LSDA for this frame. */
+    const uint8_t* lsda = (uint8_t*)_Unwind_GetLanguageSpecificData(context);
+    if ( lsda == (uint8_t*) 0 )
+        return _URC_CONTINUE_UNWIND;
+
+    uintptr_t pc = _Unwind_GetIP(context)-1;
+    uintptr_t funcStart = _Unwind_GetRegionStart(context);
+    uintptr_t pcOffset = pc - funcStart;
+
+    /* Parse LSDA header. */
+    uint8_t lpStartEncoding = *lsda++;
+    if (lpStartEncoding != DW_EH_PE_omit) {
+        readEncodedPointer(&lsda, lpStartEncoding); 
+    }
+    uint8_t ttypeEncoding = *lsda++;
+    if (ttypeEncoding != DW_EH_PE_omit) {
+        readULEB128(&lsda);  
+    }
+    /* Walk call-site table looking for range that includes current PC. */
+    uint8_t         callSiteEncoding = *lsda++;
+    uint32_t        callSiteTableLength = readULEB128(&lsda);
+    const uint8_t*  callSiteTableStart = lsda;
+    const uint8_t*  callSiteTableEnd = callSiteTableStart + callSiteTableLength;
+    const uint8_t* p=callSiteTableStart;
+    while (p < callSiteTableEnd) {
+        uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
+        uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
+        uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);
+        readULEB128(&p); /* action value not used for C code */
+        if ( landingPad == 0 )
+            continue; /* no landing pad for this entry */
+        if ( (start <= pcOffset) && (pcOffset < (start+length)) ) {
+            /* Found landing pad for the PC.
+             * Set Instruction Pointer to so we re-enter function 
+             * at landing pad. The landing pad is created by the compiler
+             * to take two parameters in registers.
+             */
+            _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
+                          (uintptr_t)exceptionObject);
+            _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
+            _Unwind_SetIP(context, (funcStart + landingPad));
+            return _URC_INSTALL_CONTEXT;
+        }
+    }
+
+    /* No landing pad found, continue unwinding. */
+    return _URC_CONTINUE_UNWIND;
+}
+
diff --git a/compiler-rt/lib/builtins/i386/Makefile.mk b/compiler-rt/lib/builtins/i386/Makefile.mk
new file mode 100644
index 0000000..f3776a0
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/Makefile.mk
@@ -0,0 +1,20 @@
+#===- lib/builtins/i386/Makefile.mk ------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs := 
+OnlyArchs := i386
+
+AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
+Implementation := Optimized
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard lib/*.h $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/i386/ashldi3.S b/compiler-rt/lib/builtins/i386/ashldi3.S
new file mode 100644
index 0000000..3fbd739
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/ashldi3.S
@@ -0,0 +1,58 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __ashldi3(di_int input, int count);
+
+// This routine has some extra memory traffic, loading the 64-bit input via two
+// 32-bit loads, then immediately storing it back to the stack via a single 64-bit
+// store.  This is to avoid a write-small, read-large stall.
+// However, if callers of this routine can be safely assumed to store the argument
+// via a 64-bt store, this is unnecessary memory traffic, and should be avoided.
+// It can be turned off by defining the TRUST_CALLERS_USE_64_BIT_STORES macro.
+
+#ifdef __i386__
+#ifdef __SSE2__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__ashldi3)
+	movd	  12(%esp),		%xmm2	// Load count
+#ifndef TRUST_CALLERS_USE_64_BIT_STORES
+	movd	   4(%esp),		%xmm0
+	movd	   8(%esp),		%xmm1
+	punpckldq	%xmm1,		%xmm0	// Load input
+#else
+	movq	   4(%esp),		%xmm0	// Load input
+#endif
+	psllq		%xmm2,		%xmm0	// shift input by count
+	movd		%xmm0,		%eax
+	psrlq		$32,		%xmm0
+	movd		%xmm0,		%edx
+	ret
+END_COMPILERRT_FUNCTION(__ashldi3)
+
+#else // Use GPRs instead of SSE2 instructions, if they aren't available.
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__ashldi3)
+	movl	  12(%esp),		%ecx	// Load count
+	movl	   8(%esp),		%edx	// Load high
+	movl	   4(%esp),		%eax	// Load low
+
+	testl		$0x20,		%ecx	// If count >= 32
+	jnz		1f			//    goto 1
+	shldl		%cl, %eax,	%edx	// left shift high by count
+	shll		%cl,		%eax	// left shift low by count
+	ret
+
+1:	movl		%eax,		%edx	// Move low to high
+	xorl		%eax,		%eax	// clear low
+	shll		%cl,		%edx	// shift high by count - 32
+	ret
+END_COMPILERRT_FUNCTION(__ashldi3)
+
+#endif // __SSE2__
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/ashrdi3.S b/compiler-rt/lib/builtins/i386/ashrdi3.S
new file mode 100644
index 0000000..8f47424
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/ashrdi3.S
@@ -0,0 +1,69 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __ashrdi3(di_int input, int count);
+
+#ifdef __i386__
+#ifdef __SSE2__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__ashrdi3)
+	movd	  12(%esp),		%xmm2	// Load count
+	movl	   8(%esp),		%eax
+#ifndef TRUST_CALLERS_USE_64_BIT_STORES
+	movd	   4(%esp),		%xmm0
+	movd	   8(%esp),		%xmm1
+	punpckldq	%xmm1,		%xmm0	// Load input
+#else
+	movq	   4(%esp),		%xmm0	// Load input
+#endif
+
+	psrlq		%xmm2,		%xmm0	// unsigned shift input by count
+	
+	testl		%eax,		%eax	// check the sign-bit of the input
+	jns			1f					// early out for positive inputs
+	
+	// If the input is negative, we need to construct the shifted sign bit
+	// to or into the result, as xmm does not have a signed right shift.
+	pcmpeqb		%xmm1,		%xmm1	// -1ULL
+	psrlq		$58,		%xmm1	// 0x3f
+	pandn		%xmm1,		%xmm2	// 63 - count
+	pcmpeqb		%xmm1,		%xmm1	// -1ULL
+	psubq		%xmm1,		%xmm2	// 64 - count
+	psllq		%xmm2,		%xmm1	// -1 << (64 - count) = leading sign bits
+	por			%xmm1,		%xmm0
+	
+	// Move the result back to the general purpose registers and return
+1:	movd		%xmm0,		%eax
+	psrlq		$32,		%xmm0
+	movd		%xmm0,		%edx
+	ret
+END_COMPILERRT_FUNCTION(__ashrdi3)
+
+#else // Use GPRs instead of SSE2 instructions, if they aren't available.
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__ashrdi3)
+	movl	  12(%esp),		%ecx	// Load count
+	movl	   8(%esp),		%edx	// Load high
+	movl	   4(%esp),		%eax	// Load low
+	
+	testl		$0x20,		%ecx	// If count >= 32
+	jnz			1f					//    goto 1
+
+	shrdl		%cl, %edx,	%eax	// right shift low by count
+	sarl		%cl,		%edx	// right shift high by count
+	ret
+	
+1:	movl		%edx,		%eax	// Move high to low
+	sarl		$31,		%edx	// clear high
+	sarl		%cl,		%eax	// shift low by count - 32
+	ret
+END_COMPILERRT_FUNCTION(__ashrdi3)
+
+#endif // __SSE2__
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/chkstk.S b/compiler-rt/lib/builtins/i386/chkstk.S
new file mode 100644
index 0000000..b599748
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/chkstk.S
@@ -0,0 +1,34 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// _chkstk routine
+// This routine is windows specific
+// http://msdn.microsoft.com/en-us/library/ms648426.aspx
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__chkstk_ms)
+        push   %ecx
+        push   %eax
+        cmp    $0x1000,%eax
+        lea    12(%esp),%ecx
+        jb     1f
+2:
+        sub    $0x1000,%ecx
+        test   %ecx,(%ecx)
+        sub    $0x1000,%eax
+        cmp    $0x1000,%eax
+        ja     2b
+1:
+        sub    %eax,%ecx
+        test   %ecx,(%ecx)
+        pop    %eax
+        pop    %ecx
+        ret
+END_COMPILERRT_FUNCTION(__chkstk_ms)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/chkstk2.S b/compiler-rt/lib/builtins/i386/chkstk2.S
new file mode 100644
index 0000000..7d65bb0
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/chkstk2.S
@@ -0,0 +1,40 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+#ifdef __i386__
+
+// _chkstk (_alloca) routine - probe stack between %esp and (%esp-%eax) in 4k increments,
+// then decrement %esp by %eax.  Preserves all registers except %esp and flags.
+// This routine is windows specific
+// http://msdn.microsoft.com/en-us/library/ms648426.aspx
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(_alloca) // _chkstk and _alloca are the same function
+DEFINE_COMPILERRT_FUNCTION(__chkstk)
+        push   %ecx
+        cmp    $0x1000,%eax
+        lea    8(%esp),%ecx     // esp before calling this routine -> ecx
+        jb     1f
+2:
+        sub    $0x1000,%ecx
+        test   %ecx,(%ecx)
+        sub    $0x1000,%eax
+        cmp    $0x1000,%eax
+        ja     2b
+1:
+        sub    %eax,%ecx
+        test   %ecx,(%ecx)
+
+        lea    4(%esp),%eax     // load pointer to the return address into eax
+        mov    %ecx,%esp        // install the new top of stack pointer into esp
+        mov    -4(%eax),%ecx    // restore ecx
+        push   (%eax)           // push return address onto the stack
+        sub    %esp,%eax        // restore the original value in eax
+        ret
+END_COMPILERRT_FUNCTION(__chkstk)
+END_COMPILERRT_FUNCTION(_alloca)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/divdi3.S b/compiler-rt/lib/builtins/i386/divdi3.S
new file mode 100644
index 0000000..2cb0ddd
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/divdi3.S
@@ -0,0 +1,162 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __divdi3(di_int a, di_int b);
+
+// result = a / b.
+// both inputs and the output are 64-bit signed integers.
+// This will do whatever the underlying hardware is set to do on division by zero.
+// No other exceptions are generated, as the divide cannot overflow.
+//
+// This is targeted at 32-bit x86 *only*, as this can be done directly in hardware
+// on x86_64.  The performance goal is ~40 cycles per divide, which is faster than
+// currently possible via simulation of integer divides on the x87 unit.
+//
+// Stephen Canon, December 2008
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__divdi3)
+
+/* This is currently implemented by wrapping the unsigned divide up in an absolute
+   value, then restoring the correct sign at the end of the computation.  This could
+   certainly be improved upon. */
+
+	pushl		%esi
+	movl	 20(%esp),			%edx	// high word of b
+	movl	 16(%esp),			%eax	// low word of b
+	movl		%edx,			%ecx
+	sarl		$31,			%ecx	// (b < 0) ? -1 : 0
+	xorl		%ecx,			%eax
+	xorl		%ecx,			%edx	// EDX:EAX = (b < 0) ? not(b) : b
+	subl		%ecx,			%eax
+	sbbl		%ecx,			%edx	// EDX:EAX = abs(b)
+	movl		%edx,		 20(%esp)
+	movl		%eax,		 16(%esp)	// store abs(b) back to stack
+	movl		%ecx,			%esi	// set aside sign of b
+	
+	movl	 12(%esp),			%edx	// high word of b
+	movl	  8(%esp),			%eax	// low word of b
+	movl		%edx,			%ecx
+	sarl		$31,			%ecx	// (a < 0) ? -1 : 0
+	xorl		%ecx,			%eax
+	xorl		%ecx,			%edx	// EDX:EAX = (a < 0) ? not(a) : a
+	subl		%ecx,			%eax
+	sbbl		%ecx,			%edx	// EDX:EAX = abs(a)
+	movl		%edx,		 12(%esp)
+	movl		%eax,		  8(%esp)	// store abs(a) back to stack
+	xorl		%ecx,			%esi	// sign of result = (sign of a) ^ (sign of b)
+
+	pushl		%ebx
+	movl	 24(%esp),			%ebx	// Find the index i of the leading bit in b.
+	bsrl		%ebx,			%ecx	// If the high word of b is zero, jump to
+	jz			9f						// the code to handle that special case [9].
+	
+	/* High word of b is known to be non-zero on this branch */
+	
+	movl	 20(%esp),			%eax	// Construct bhi, containing bits [1+i:32+i] of b
+	
+	shrl		%cl,			%eax	// Practically, this means that bhi is given by:
+	shrl		%eax					//
+	notl		%ecx					//		bhi = (high word of b) << (31 - i) |
+	shll		%cl,			%ebx	//			  (low word of b) >> (1 + i)
+	orl			%eax,			%ebx	//
+	movl	 16(%esp),			%edx	// Load the high and low words of a, and jump
+	movl	 12(%esp),			%eax	// to [1] if the high word is larger than bhi
+	cmpl		%ebx,			%edx	// to avoid overflowing the upcoming divide.
+	jae			1f						
+		
+	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	
+	divl		%ebx					// eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	shrl		%cl,			%eax	// q = qs >> (1 + i)
+	movl		%eax,			%edi
+	mull	 24(%esp)					// q*blo
+	movl	 16(%esp),			%ebx
+	movl	 20(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 28(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+	sbbl		$0,				%edi	// decrement q if remainder is negative
+	xorl		%edx,			%edx
+	movl		%edi,			%eax
+	
+	addl		%esi,			%eax	// Restore correct sign to result
+	adcl		%esi,			%edx
+	xorl		%esi,			%eax
+	xorl		%esi,			%edx
+	popl		%edi					// Restore callee-save registers
+	popl		%ebx
+	popl		%esi
+	retl								// Return
+
+
+1:	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	 
+	subl		%ebx,			%edx	// subtract bhi from ahi so that divide will not
+	divl		%ebx					// overflow, and find q and r such that
+										//
+										//		ahi:alo = (1:q)*bhi + r
+										//
+										// Note that q is a number in (31-i).(1+i)
+										// fix point.
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	orl			$0x80000000,	%eax
+	shrl		%cl,			%eax	// q = (1:qs) >> (1 + i)
+	movl		%eax,			%edi
+	mull	 24(%esp)					// q*blo
+	movl	 16(%esp),			%ebx
+	movl	 20(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 28(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+	sbbl		$0,				%edi	// decrement q if remainder is negative
+	xorl		%edx,			%edx
+	movl		%edi,			%eax
+	
+	addl		%esi,			%eax	// Restore correct sign to result
+	adcl		%esi,			%edx
+	xorl		%esi,			%eax
+	xorl		%esi,			%edx
+	popl		%edi					// Restore callee-save registers
+	popl		%ebx
+	popl		%esi
+	retl								// Return
+
+	
+9:	/* High word of b is zero on this branch */
+
+	movl	 16(%esp),			%eax	// Find qhi and rhi such that
+	movl	 20(%esp),			%ecx	//
+	xorl		%edx,			%edx	//		ahi = qhi*b + rhi	with	0 ≤ rhi < b
+	divl		%ecx					//
+	movl		%eax,			%ebx	//
+	movl	 12(%esp),			%eax	// Find qlo such that
+	divl		%ecx					//
+	movl		%ebx,			%edx	//		rhi:alo = qlo*b + rlo  with 0 ≤ rlo < b
+	
+	addl		%esi,			%eax	// Restore correct sign to result
+	adcl		%esi,			%edx
+	xorl		%esi,			%eax
+	xorl		%esi,			%edx
+	popl		%ebx					// Restore callee-save registers
+	popl		%esi
+	retl								// Return
+END_COMPILERRT_FUNCTION(__divdi3)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/floatdidf.S b/compiler-rt/lib/builtins/i386/floatdidf.S
new file mode 100644
index 0000000..dcc32f8
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/floatdidf.S
@@ -0,0 +1,39 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// double __floatundidf(du_int a);
+
+#ifdef __i386__
+
+CONST_SECTION
+
+	.balign 16
+twop52:
+	.quad 0x4330000000000000
+
+	.balign 16
+twop32:
+	.quad 0x41f0000000000000
+
+#define REL_ADDR(_a)	(_a)-0b(%eax)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatdidf)
+	cvtsi2sd	8(%esp),			%xmm1
+	movss		4(%esp),			%xmm0 // low 32 bits of a
+	calll		0f
+0:	popl		%eax
+	mulsd		REL_ADDR(twop32),	%xmm1 // a_hi as a double (without rounding)
+	movsd		REL_ADDR(twop52),	%xmm2 // 0x1.0p52
+	subsd		%xmm2,				%xmm1 // a_hi - 0x1p52 (no rounding occurs)
+	orpd		%xmm2,				%xmm0 // 0x1p52 + a_lo (no rounding occurs)
+	addsd		%xmm1,				%xmm0 // a_hi + a_lo   (round happens here)
+	movsd		%xmm0,			   4(%esp)
+	fldl	   4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatdidf)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/floatdisf.S b/compiler-rt/lib/builtins/i386/floatdisf.S
new file mode 100644
index 0000000..f642767
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/floatdisf.S
@@ -0,0 +1,32 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// float __floatdisf(di_int a);
+
+// This routine has some extra memory traffic, loading the 64-bit input via two
+// 32-bit loads, then immediately storing it back to the stack via a single 64-bit
+// store.  This is to avoid a write-small, read-large stall.
+// However, if callers of this routine can be safely assumed to store the argument
+// via a 64-bt store, this is unnecessary memory traffic, and should be avoided.
+// It can be turned off by defining the TRUST_CALLERS_USE_64_BIT_STORES macro.
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatdisf)
+#ifndef TRUST_CALLERS_USE_64_BIT_STORES
+	movd		4(%esp),	%xmm0
+	movd		8(%esp),	%xmm1
+	punpckldq	%xmm1,		%xmm0
+	movq		%xmm0,		4(%esp)
+#endif
+	fildll		4(%esp)
+	fstps		4(%esp)
+	flds		4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatdisf)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/floatdixf.S b/compiler-rt/lib/builtins/i386/floatdixf.S
new file mode 100644
index 0000000..839b043
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/floatdixf.S
@@ -0,0 +1,30 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// float __floatdixf(di_int a);
+
+#ifdef __i386__
+
+// This routine has some extra memory traffic, loading the 64-bit input via two
+// 32-bit loads, then immediately storing it back to the stack via a single 64-bit
+// store.  This is to avoid a write-small, read-large stall.
+// However, if callers of this routine can be safely assumed to store the argument
+// via a 64-bt store, this is unnecessary memory traffic, and should be avoided.
+// It can be turned off by defining the TRUST_CALLERS_USE_64_BIT_STORES macro.
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatdixf)
+#ifndef TRUST_CALLERS_USE_64_BIT_STORES
+	movd		4(%esp),	%xmm0
+	movd		8(%esp),	%xmm1
+	punpckldq	%xmm1,		%xmm0
+	movq		%xmm0,		4(%esp)
+#endif
+	fildll		4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatdixf)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/floatundidf.S b/compiler-rt/lib/builtins/i386/floatundidf.S
new file mode 100644
index 0000000..8058c2a
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/floatundidf.S
@@ -0,0 +1,52 @@
+//===-- floatundidf.S - Implement __floatundidf for i386 ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements __floatundidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// double __floatundidf(du_int a);
+
+#ifdef __i386__
+
+CONST_SECTION
+
+	.balign 16
+twop52:
+	.quad 0x4330000000000000
+
+	.balign 16
+twop84_plus_twop52:
+	.quad 0x4530000000100000
+
+	.balign 16
+twop84:
+	.quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)-0b(%eax)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundidf)
+	movss	8(%esp),						%xmm1 // high 32 bits of a
+	movss	4(%esp),						%xmm0 // low 32 bits of a
+	calll	0f
+0:	popl	%eax
+	orpd	REL_ADDR(twop84),				%xmm1 // 0x1p84 + a_hi (no rounding occurs)
+	subsd	REL_ADDR(twop84_plus_twop52),	%xmm1 // a_hi - 0x1p52 (no rounding occurs)
+	orpd	REL_ADDR(twop52),				%xmm0 // 0x1p52 + a_lo (no rounding occurs)
+	addsd	%xmm1,							%xmm0 // a_hi + a_lo   (round happens here)
+	movsd	%xmm0,						   4(%esp)
+	fldl   4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatundidf)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/floatundisf.S b/compiler-rt/lib/builtins/i386/floatundisf.S
new file mode 100644
index 0000000..94c97e2
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/floatundisf.S
@@ -0,0 +1,105 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// float __floatundisf(du_int a);
+
+// Note that there is a hardware instruction, fildll, that does most of what
+// this function needs to do.  However, because of our ia32 ABI, it will take
+// a write-small read-large stall, so the software implementation here is
+// actually several cycles faster.
+
+// This is a branch-free implementation.  A branchy implementation might be
+// faster for the common case if you know something a priori about the input
+// distribution.
+
+/* branch-free x87 implementation - one cycle slower than without x87.
+
+#ifdef __i386__
+
+CONST_SECTION
+.balign 3
+
+		.quad	0x43f0000000000000
+twop64:	.quad	0x0000000000000000
+
+#define			TWOp64			twop64-0b(%ecx,%eax,8)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundisf)
+	movl		8(%esp),		%eax
+	movd		8(%esp),		%xmm1
+	movd		4(%esp),		%xmm0
+	punpckldq	%xmm1,			%xmm0
+	calll		0f
+0:	popl		%ecx
+	sarl		$31,			%eax
+	movq		%xmm0,			4(%esp)
+	fildll		4(%esp)
+	faddl		TWOp64
+	fstps		4(%esp)
+	flds		4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatundisf)
+
+#endif // __i386__
+
+*/
+
+/* branch-free, x87-free implementation - faster at the expense of code size */
+
+#ifdef __i386__
+
+CONST_SECTION
+
+	.balign 16
+twop52:
+	.quad 0x4330000000000000
+	.quad 0x0000000000000fff
+
+	.balign 16
+sticky:
+	.quad 0x0000000000000000
+	.long 0x00000012
+
+	.balign 16
+twelve:
+	.long 0x00000000
+
+#define			TWOp52			twop52-0b(%ecx)
+#define			STICKY			sticky-0b(%ecx,%eax,8)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundisf)
+	movl		8(%esp),		%eax
+	movd		8(%esp),		%xmm1
+	movd		4(%esp),		%xmm0
+	punpckldq	%xmm1,			%xmm0
+	
+	calll		0f
+0:	popl		%ecx
+	shrl		%eax					// high 31 bits of input as sint32
+	addl		$0x7ff80000,	%eax
+	sarl		$31,			%eax	// (big input) ? -1 : 0
+	movsd		STICKY,			%xmm1	// (big input) ? 0xfff : 0
+	movl		$12,			%edx
+	andl		%eax,			%edx	// (big input) ? 12 : 0
+	movd		%edx,			%xmm3
+	andpd		%xmm0,			%xmm1	// (big input) ? input & 0xfff : 0
+	movsd		TWOp52,			%xmm2	// 0x1.0p52
+	psrlq		%xmm3,			%xmm0	// (big input) ? input >> 12 : input
+	orpd		%xmm2,			%xmm1	// 0x1.0p52 + ((big input) ? input & 0xfff : input)
+	orpd		%xmm1,			%xmm0	// 0x1.0p52 + ((big input) ? (input >> 12 | input & 0xfff) : input)
+	subsd		%xmm2,			%xmm0	// (double)((big input) ? (input >> 12 | input & 0xfff) : input)
+	cvtsd2ss	%xmm0,			%xmm0	// (float)((big input) ? (input >> 12 | input & 0xfff) : input)
+	pslld		$23,			%xmm3
+	paddd		%xmm3,			%xmm0	// (float)input
+	movd		%xmm0,			4(%esp)
+	flds		4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatundisf)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/floatundixf.S b/compiler-rt/lib/builtins/i386/floatundixf.S
new file mode 100644
index 0000000..814b52f
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/floatundixf.S
@@ -0,0 +1,43 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// long double __floatundixf(du_int a);16
+
+#ifdef __i386__
+
+CONST_SECTION
+
+	.balign 16
+twop52:
+	.quad 0x4330000000000000
+
+	.balign 16
+twop84_plus_twop52_neg:
+	.quad 0xc530000000100000
+
+	.balign 16
+twop84:
+	.quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)-0b(%eax)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundixf)
+	calll	0f
+0:	popl	%eax
+	movss	8(%esp),			%xmm0	// hi 32 bits of input
+	movss	4(%esp),			%xmm1	// lo 32 bits of input
+	orpd	REL_ADDR(twop84),	%xmm0	// 2^84 + hi (as a double)
+	orpd	REL_ADDR(twop52),	%xmm1	// 2^52 + lo (as a double)
+	addsd	REL_ADDR(twop84_plus_twop52_neg),	%xmm0	// hi - 2^52 (no rounding occurs)
+	movsd	%xmm1,				4(%esp)
+	fldl	4(%esp)
+	movsd	%xmm0,				4(%esp)
+	faddl	4(%esp)
+	ret
+END_COMPILERRT_FUNCTION(__floatundixf)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/lshrdi3.S b/compiler-rt/lib/builtins/i386/lshrdi3.S
new file mode 100644
index 0000000..b80f11a
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/lshrdi3.S
@@ -0,0 +1,59 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __lshrdi3(di_int input, int count);
+
+// This routine has some extra memory traffic, loading the 64-bit input via two
+// 32-bit loads, then immediately storing it back to the stack via a single 64-bit
+// store.  This is to avoid a write-small, read-large stall.
+// However, if callers of this routine can be safely assumed to store the argument
+// via a 64-bt store, this is unnecessary memory traffic, and should be avoided.
+// It can be turned off by defining the TRUST_CALLERS_USE_64_BIT_STORES macro.
+
+#ifdef __i386__
+#ifdef __SSE2__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__lshrdi3)
+	movd	  12(%esp),		%xmm2	// Load count
+#ifndef TRUST_CALLERS_USE_64_BIT_STORES
+	movd	   4(%esp),		%xmm0
+	movd	   8(%esp),		%xmm1
+	punpckldq	%xmm1,		%xmm0	// Load input
+#else
+	movq	   4(%esp),		%xmm0	// Load input
+#endif
+	psrlq		%xmm2,		%xmm0	// shift input by count
+	movd		%xmm0,		%eax
+	psrlq		$32,		%xmm0
+	movd		%xmm0,		%edx
+	ret
+END_COMPILERRT_FUNCTION(__lshrdi3)
+
+#else // Use GPRs instead of SSE2 instructions, if they aren't available.
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__lshrdi3)
+	movl	  12(%esp),		%ecx	// Load count
+	movl	   8(%esp),		%edx	// Load high
+	movl	   4(%esp),		%eax	// Load low
+	
+	testl		$0x20,		%ecx	// If count >= 32
+	jnz			1f					//    goto 1
+
+	shrdl		%cl, %edx,	%eax	// right shift low by count
+	shrl		%cl,		%edx	// right shift high by count
+	ret
+	
+1:	movl		%edx,		%eax	// Move high to low
+	xorl		%edx,		%edx	// clear high
+	shrl		%cl,		%eax	// shift low by count - 32
+	ret
+END_COMPILERRT_FUNCTION(__lshrdi3)
+
+#endif // __SSE2__
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/moddi3.S b/compiler-rt/lib/builtins/i386/moddi3.S
new file mode 100644
index 0000000..b9cee9d
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/moddi3.S
@@ -0,0 +1,166 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __moddi3(di_int a, di_int b);
+
+// result = remainder of a / b.
+// both inputs and the output are 64-bit signed integers.
+// This will do whatever the underlying hardware is set to do on division by zero.
+// No other exceptions are generated, as the divide cannot overflow.
+//
+// This is targeted at 32-bit x86 *only*, as this can be done directly in hardware
+// on x86_64.  The performance goal is ~40 cycles per divide, which is faster than
+// currently possible via simulation of integer divides on the x87 unit.
+//
+
+// Stephen Canon, December 2008
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__moddi3)
+
+/* This is currently implemented by wrapping the unsigned modulus up in an absolute
+   value.  This could certainly be improved upon. */
+
+	pushl		%esi
+	movl	 20(%esp),			%edx	// high word of b
+	movl	 16(%esp),			%eax	// low word of b
+	movl		%edx,			%ecx
+	sarl		$31,			%ecx	// (b < 0) ? -1 : 0
+	xorl		%ecx,			%eax
+	xorl		%ecx,			%edx	// EDX:EAX = (b < 0) ? not(b) : b
+	subl		%ecx,			%eax
+	sbbl		%ecx,			%edx	// EDX:EAX = abs(b)
+	movl		%edx,		 20(%esp)
+	movl		%eax,		 16(%esp)	// store abs(b) back to stack
+	
+	movl	 12(%esp),			%edx	// high word of b
+	movl	  8(%esp),			%eax	// low word of b
+	movl		%edx,			%ecx
+	sarl		$31,			%ecx	// (a < 0) ? -1 : 0
+	xorl		%ecx,			%eax
+	xorl		%ecx,			%edx	// EDX:EAX = (a < 0) ? not(a) : a
+	subl		%ecx,			%eax
+	sbbl		%ecx,			%edx	// EDX:EAX = abs(a)
+	movl		%edx,		 12(%esp)
+	movl		%eax,		  8(%esp)	// store abs(a) back to stack
+	movl		%ecx,			%esi	// set aside sign of a
+
+	pushl		%ebx
+	movl	 24(%esp),			%ebx	// Find the index i of the leading bit in b.
+	bsrl		%ebx,			%ecx	// If the high word of b is zero, jump to
+	jz			9f						// the code to handle that special case [9].
+	
+	/* High word of b is known to be non-zero on this branch */
+	
+	movl	 20(%esp),			%eax	// Construct bhi, containing bits [1+i:32+i] of b
+	
+	shrl		%cl,			%eax	// Practically, this means that bhi is given by:
+	shrl		%eax					//
+	notl		%ecx					//		bhi = (high word of b) << (31 - i) |
+	shll		%cl,			%ebx	//			  (low word of b) >> (1 + i)
+	orl			%eax,			%ebx	//
+	movl	 16(%esp),			%edx	// Load the high and low words of a, and jump
+	movl	 12(%esp),			%eax	// to [2] if the high word is larger than bhi
+	cmpl		%ebx,			%edx	// to avoid overflowing the upcoming divide.
+	jae			2f						
+		
+	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	
+	divl		%ebx					// eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	shrl		%cl,			%eax	// q = qs >> (1 + i)
+	movl		%eax,			%edi
+	mull	 24(%esp)					// q*blo
+	movl	 16(%esp),			%ebx
+	movl	 20(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 28(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+	
+	jnc			1f						// if positive, this is the result.
+	addl	 24(%esp),			%ebx	// otherwise
+	adcl	 28(%esp),			%ecx	// ECX:EBX = a - (q-1)*b = result
+1:	movl		%ebx,			%eax
+	movl		%ecx,			%edx
+	
+	addl		%esi,			%eax	// Restore correct sign to result
+	adcl		%esi,			%edx
+	xorl		%esi,			%eax
+	xorl		%esi,			%edx
+	popl		%edi					// Restore callee-save registers
+	popl		%ebx
+	popl		%esi
+	retl								// Return
+
+2:	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	 
+	subl		%ebx,			%edx	// subtract bhi from ahi so that divide will not
+	divl		%ebx					// overflow, and find q and r such that
+										//
+										//		ahi:alo = (1:q)*bhi + r
+										//
+										// Note that q is a number in (31-i).(1+i)
+										// fix point.
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	orl			$0x80000000,	%eax
+	shrl		%cl,			%eax	// q = (1:qs) >> (1 + i)
+	movl		%eax,			%edi
+	mull	 24(%esp)					// q*blo
+	movl	 16(%esp),			%ebx
+	movl	 20(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 28(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+
+	jnc			3f						// if positive, this is the result.
+	addl	 24(%esp),			%ebx	// otherwise
+	adcl	 28(%esp),			%ecx	// ECX:EBX = a - (q-1)*b = result
+3:	movl		%ebx,			%eax
+	movl		%ecx,			%edx
+	
+	addl		%esi,			%eax	// Restore correct sign to result
+	adcl		%esi,			%edx
+	xorl		%esi,			%eax
+	xorl		%esi,			%edx
+	popl		%edi					// Restore callee-save registers
+	popl		%ebx
+	popl		%esi
+	retl								// Return
+	
+9:	/* High word of b is zero on this branch */
+
+	movl	 16(%esp),			%eax	// Find qhi and rhi such that
+	movl	 20(%esp),			%ecx	//
+	xorl		%edx,			%edx	//		ahi = qhi*b + rhi	with	0 ≤ rhi < b
+	divl		%ecx					//
+	movl		%eax,			%ebx	//
+	movl	 12(%esp),			%eax	// Find rlo such that
+	divl		%ecx					//
+	movl		%edx,			%eax	//		rhi:alo = qlo*b + rlo  with 0 ≤ rlo < b
+	popl		%ebx					//
+	xorl		%edx,			%edx	// and return 0:rlo
+
+	addl		%esi,			%eax	// Restore correct sign to result
+	adcl		%esi,			%edx
+	xorl		%esi,			%eax
+	xorl		%esi,			%edx
+	popl		%esi
+	retl								// Return
+END_COMPILERRT_FUNCTION(__moddi3)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/muldi3.S b/compiler-rt/lib/builtins/i386/muldi3.S
new file mode 100644
index 0000000..15b6b49
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/muldi3.S
@@ -0,0 +1,30 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __muldi3(di_int a, di_int b);
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__muldi3)
+	pushl	%ebx
+	movl  16(%esp),		%eax	// b.lo
+	movl  12(%esp),		%ecx	// a.hi
+	imull	%eax,		%ecx	// b.lo * a.hi
+	
+	movl   8(%esp),		%edx	// a.lo
+	movl  20(%esp),		%ebx	// b.hi
+	imull	%edx,		%ebx	// a.lo * b.hi
+	
+	mull	%edx				// EDX:EAX = a.lo * b.lo
+	addl	%ecx,		%ebx	// EBX = (a.lo*b.hi + a.hi*b.lo)
+	addl	%ebx,		%edx
+	
+	popl	%ebx
+	retl
+END_COMPILERRT_FUNCTION(__muldi3)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/udivdi3.S b/compiler-rt/lib/builtins/i386/udivdi3.S
new file mode 100644
index 0000000..41b2edf
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/udivdi3.S
@@ -0,0 +1,115 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// du_int __udivdi3(du_int a, du_int b);
+
+// result = a / b.
+// both inputs and the output are 64-bit unsigned integers.
+// This will do whatever the underlying hardware is set to do on division by zero.
+// No other exceptions are generated, as the divide cannot overflow.
+//
+// This is targeted at 32-bit x86 *only*, as this can be done directly in hardware
+// on x86_64.  The performance goal is ~40 cycles per divide, which is faster than
+// currently possible via simulation of integer divides on the x87 unit.
+//
+// Stephen Canon, December 2008
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__udivdi3)
+
+	pushl		%ebx
+	movl	 20(%esp),			%ebx	// Find the index i of the leading bit in b.
+	bsrl		%ebx,			%ecx	// If the high word of b is zero, jump to
+	jz			9f						// the code to handle that special case [9].
+	
+	/* High word of b is known to be non-zero on this branch */
+	
+	movl	 16(%esp),			%eax	// Construct bhi, containing bits [1+i:32+i] of b
+	
+	shrl		%cl,			%eax	// Practically, this means that bhi is given by:
+	shrl		%eax					//
+	notl		%ecx					//		bhi = (high word of b) << (31 - i) |
+	shll		%cl,			%ebx	//			  (low word of b) >> (1 + i)
+	orl			%eax,			%ebx	//
+	movl	 12(%esp),			%edx	// Load the high and low words of a, and jump
+	movl	  8(%esp),			%eax	// to [1] if the high word is larger than bhi
+	cmpl		%ebx,			%edx	// to avoid overflowing the upcoming divide.
+	jae			1f						
+		
+	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	
+	divl		%ebx					// eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	shrl		%cl,			%eax	// q = qs >> (1 + i)
+	movl		%eax,			%edi
+	mull	 20(%esp)					// q*blo
+	movl	 12(%esp),			%ebx
+	movl	 16(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 24(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+	sbbl		$0,				%edi	// decrement q if remainder is negative
+	xorl		%edx,			%edx
+	movl		%edi,			%eax
+	popl		%edi
+	popl		%ebx
+	retl
+
+
+1:	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	 
+	subl		%ebx,			%edx	// subtract bhi from ahi so that divide will not
+	divl		%ebx					// overflow, and find q and r such that
+										//
+										//		ahi:alo = (1:q)*bhi + r
+										//
+										// Note that q is a number in (31-i).(1+i)
+										// fix point.
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	orl			$0x80000000,	%eax
+	shrl		%cl,			%eax	// q = (1:qs) >> (1 + i)
+	movl		%eax,			%edi
+	mull	 20(%esp)					// q*blo
+	movl	 12(%esp),			%ebx
+	movl	 16(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 24(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+	sbbl		$0,				%edi	// decrement q if remainder is negative
+	xorl		%edx,			%edx
+	movl		%edi,			%eax
+	popl		%edi
+	popl		%ebx
+	retl
+
+	
+9:	/* High word of b is zero on this branch */
+
+	movl	 12(%esp),			%eax	// Find qhi and rhi such that
+	movl	 16(%esp),			%ecx	//
+	xorl		%edx,			%edx	//		ahi = qhi*b + rhi	with	0 ≤ rhi < b
+	divl		%ecx					//
+	movl		%eax,			%ebx	//
+	movl	  8(%esp),			%eax	// Find qlo such that
+	divl		%ecx					//
+	movl		%ebx,			%edx	//		rhi:alo = qlo*b + rlo  with 0 ≤ rlo < b
+	popl		%ebx					//
+	retl								// and return qhi:qlo
+END_COMPILERRT_FUNCTION(__udivdi3)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/i386/umoddi3.S b/compiler-rt/lib/builtins/i386/umoddi3.S
new file mode 100644
index 0000000..a190a7d
--- /dev/null
+++ b/compiler-rt/lib/builtins/i386/umoddi3.S
@@ -0,0 +1,126 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// du_int __umoddi3(du_int a, du_int b);
+
+// result = remainder of a / b.
+// both inputs and the output are 64-bit unsigned integers.
+// This will do whatever the underlying hardware is set to do on division by zero.
+// No other exceptions are generated, as the divide cannot overflow.
+//
+// This is targeted at 32-bit x86 *only*, as this can be done directly in hardware
+// on x86_64.  The performance goal is ~40 cycles per divide, which is faster than
+// currently possible via simulation of integer divides on the x87 unit.
+//
+
+// Stephen Canon, December 2008
+
+#ifdef __i386__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__umoddi3)
+
+	pushl		%ebx
+	movl	 20(%esp),			%ebx	// Find the index i of the leading bit in b.
+	bsrl		%ebx,			%ecx	// If the high word of b is zero, jump to
+	jz			9f						// the code to handle that special case [9].
+	
+	/* High word of b is known to be non-zero on this branch */
+	
+	movl	 16(%esp),			%eax	// Construct bhi, containing bits [1+i:32+i] of b
+	
+	shrl		%cl,			%eax	// Practically, this means that bhi is given by:
+	shrl		%eax					//
+	notl		%ecx					//		bhi = (high word of b) << (31 - i) |
+	shll		%cl,			%ebx	//			  (low word of b) >> (1 + i)
+	orl			%eax,			%ebx	//
+	movl	 12(%esp),			%edx	// Load the high and low words of a, and jump
+	movl	  8(%esp),			%eax	// to [2] if the high word is larger than bhi
+	cmpl		%ebx,			%edx	// to avoid overflowing the upcoming divide.
+	jae			2f						
+		
+	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	
+	divl		%ebx					// eax <-- qs, edx <-- r such that ahi:alo = bs*qs + r
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	shrl		%cl,			%eax	// q = qs >> (1 + i)
+	movl		%eax,			%edi
+	mull	 20(%esp)					// q*blo
+	movl	 12(%esp),			%ebx
+	movl	 16(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 24(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+	
+	jnc			1f						// if positive, this is the result.
+	addl	 20(%esp),			%ebx	// otherwise
+	adcl	 24(%esp),			%ecx	// ECX:EBX = a - (q-1)*b = result
+1:	movl		%ebx,			%eax
+	movl		%ecx,			%edx
+	
+	popl		%edi
+	popl		%ebx
+	retl
+
+
+2:	/* High word of a is greater than or equal to (b >> (1 + i)) on this branch */
+	 
+	subl		%ebx,			%edx	// subtract bhi from ahi so that divide will not
+	divl		%ebx					// overflow, and find q and r such that
+										//
+										//		ahi:alo = (1:q)*bhi + r
+										//
+										// Note that q is a number in (31-i).(1+i)
+										// fix point.
+
+	pushl		%edi
+	notl		%ecx
+	shrl		%eax
+	orl			$0x80000000,	%eax
+	shrl		%cl,			%eax	// q = (1:qs) >> (1 + i)
+	movl		%eax,			%edi
+	mull	 20(%esp)					// q*blo
+	movl	 12(%esp),			%ebx
+	movl	 16(%esp),			%ecx	// ECX:EBX = a
+	subl		%eax,			%ebx
+	sbbl		%edx,			%ecx	// ECX:EBX = a - q*blo
+	movl	 24(%esp),			%eax
+	imull		%edi,			%eax	// q*bhi
+	subl		%eax,			%ecx	// ECX:EBX = a - q*b
+
+	jnc			3f						// if positive, this is the result.
+	addl	 20(%esp),			%ebx	// otherwise
+	adcl	 24(%esp),			%ecx	// ECX:EBX = a - (q-1)*b = result
+3:	movl		%ebx,			%eax
+	movl		%ecx,			%edx
+	
+	popl		%edi
+	popl		%ebx
+	retl
+
+
+	
+9:	/* High word of b is zero on this branch */
+
+	movl	 12(%esp),			%eax	// Find qhi and rhi such that
+	movl	 16(%esp),			%ecx	//
+	xorl		%edx,			%edx	//		ahi = qhi*b + rhi	with	0 ≤ rhi < b
+	divl		%ecx					//
+	movl		%eax,			%ebx	//
+	movl	  8(%esp),			%eax	// Find rlo such that
+	divl		%ecx					//
+	movl		%edx,			%eax	//		rhi:alo = qlo*b + rlo  with 0 ≤ rlo < b
+	popl		%ebx					//
+	xorl		%edx,			%edx	// and return 0:rlo
+	retl								// 
+END_COMPILERRT_FUNCTION(__umoddi3)
+
+#endif // __i386__
diff --git a/compiler-rt/lib/builtins/int_endianness.h b/compiler-rt/lib/builtins/int_endianness.h
new file mode 100644
index 0000000..7995ddb
--- /dev/null
+++ b/compiler-rt/lib/builtins/int_endianness.h
@@ -0,0 +1,116 @@
+/* ===-- int_endianness.h - configuration header for compiler-rt ------------===
+ *
+ *		       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file is a configuration header for compiler-rt.
+ * This file is not part of the interface of this library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifndef INT_ENDIANNESS_H
+#define INT_ENDIANNESS_H
+
+#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+    defined(__ORDER_LITTLE_ENDIAN__)
+
+/* Clang and GCC provide built-in endianness definitions. */
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* __BYTE_ORDER__ */
+
+#else /* Compilers other than Clang or GCC. */
+
+#if defined(__SVR4) && defined(__sun)
+#include <sys/byteorder.h>
+
+#if defined(_BIG_ENDIAN)
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif defined(_LITTLE_ENDIAN)
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#else /* !_LITTLE_ENDIAN */
+#error "unknown endianness"
+#endif /* !_LITTLE_ENDIAN */
+
+#endif /* Solaris and AuroraUX. */
+
+/* .. */
+
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) ||   \
+    defined(__minix)
+#include <sys/endian.h>
+
+#if _BYTE_ORDER == _BIG_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif _BYTE_ORDER == _LITTLE_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* _BYTE_ORDER */
+
+#endif /* *BSD */
+
+#if defined(__OpenBSD__) || defined(__Bitrig__)
+#include <machine/endian.h>
+
+#if _BYTE_ORDER == _BIG_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif _BYTE_ORDER == _LITTLE_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* _BYTE_ORDER */
+
+#endif /* OpenBSD and Bitrig. */
+
+/* .. */
+
+/* Mac OSX has __BIG_ENDIAN__ or __LITTLE_ENDIAN__ automatically set by the
+ * compiler (at least with GCC) */
+#if defined(__APPLE__) || defined(__ellcc__ )
+
+#ifdef __BIG_ENDIAN__
+#if __BIG_ENDIAN__
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#endif
+#endif /* __BIG_ENDIAN__ */
+
+#ifdef __LITTLE_ENDIAN__
+#if __LITTLE_ENDIAN__
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif
+#endif /* __LITTLE_ENDIAN__ */
+
+#endif /* Mac OSX */
+
+/* .. */
+
+#if defined(_WIN32)
+
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+
+#endif /* Windows */
+
+#endif /* Clang or GCC. */
+
+/* . */
+
+#if !defined(_YUGA_LITTLE_ENDIAN) || !defined(_YUGA_BIG_ENDIAN)
+#error Unable to determine endian
+#endif /* Check we found an endianness correctly. */
+
+#endif /* INT_ENDIANNESS_H */
diff --git a/compiler-rt/lib/builtins/int_lib.h b/compiler-rt/lib/builtins/int_lib.h
new file mode 100644
index 0000000..272f9d9
--- /dev/null
+++ b/compiler-rt/lib/builtins/int_lib.h
@@ -0,0 +1,133 @@
+/* ===-- int_lib.h - configuration header for compiler-rt  -----------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file is a configuration header for compiler-rt.
+ * This file is not part of the interface of this library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifndef INT_LIB_H
+#define INT_LIB_H
+
+/* Assumption: Signed integral is 2's complement. */
+/* Assumption: Right shift of signed negative is arithmetic shift. */
+/* Assumption: Endianness is little or big (not mixed). */
+
+#if defined(__ELF__)
+#define FNALIAS(alias_name, original_name) \
+  void alias_name() __attribute__((alias(#original_name)))
+#else
+#define FNALIAS(alias, name) _Pragma("GCC error(\"alias unsupported on this file format\")")
+#endif
+
+/* ABI macro definitions */
+
+#if __ARM_EABI__
+# define ARM_EABI_FNALIAS(aeabi_name, name)         \
+  void __aeabi_##aeabi_name() __attribute__((alias("__" #name)));
+# define COMPILER_RT_ABI __attribute__((pcs("aapcs")))
+#else
+# define ARM_EABI_FNALIAS(aeabi_name, name)
+# if defined(__arm__) && defined(_WIN32) && (!defined(_MSC_VER) || defined(__clang__))
+#   define COMPILER_RT_ABI __attribute__((pcs("aapcs")))
+# else
+#   define COMPILER_RT_ABI
+# endif
+#endif
+
+#ifdef _MSC_VER
+#define ALWAYS_INLINE __forceinline
+#define NOINLINE __declspec(noinline)
+#define NORETURN __declspec(noreturn)
+#define UNUSED
+#else
+#define ALWAYS_INLINE __attribute__((always_inline))
+#define NOINLINE __attribute__((noinline))
+#define NORETURN __attribute__((noreturn))
+#define UNUSED __attribute__((unused))
+#endif
+
+#if defined(__NetBSD__) && (defined(_KERNEL) || defined(_STANDALONE))
+/*
+ * Kernel and boot environment can't use normal headers,
+ * so use the equivalent system headers.
+ */
+#  include <machine/limits.h>
+#  include <sys/stdint.h>
+#  include <sys/types.h>
+#else
+/* Include the standard compiler builtin headers we use functionality from. */
+#  include <limits.h>
+#  include <stdint.h>
+#  include <stdbool.h>
+#  include <float.h>
+#endif
+
+/* Include the commonly used internal type definitions. */
+#include "int_types.h"
+
+/* Include internal utility function declarations. */
+#include "int_util.h"
+
+COMPILER_RT_ABI si_int __paritysi2(si_int a);
+COMPILER_RT_ABI si_int __paritydi2(di_int a);
+
+COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
+COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
+COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d);
+
+COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int* rem);
+COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+#ifdef CRT_HAS_128BIT
+COMPILER_RT_ABI si_int __clzti2(ti_int a);
+COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+#endif
+
+/* Definitions for builtins unavailable on MSVC */
+#if defined(_MSC_VER) && !defined(__clang__)
+#include <intrin.h>
+
+uint32_t __inline __builtin_ctz(uint32_t value) {
+  uint32_t trailing_zero = 0;
+  if (_BitScanForward(&trailing_zero, value))
+    return trailing_zero;
+  return 32;
+}
+
+uint32_t __inline __builtin_clz(uint32_t value) {
+  uint32_t leading_zero = 0;
+  if (_BitScanReverse(&leading_zero, value))
+    return 31 - leading_zero;
+  return 32;
+}
+
+#if defined(_M_ARM) || defined(_M_X64)
+uint32_t __inline __builtin_clzll(uint64_t value) {
+  uint32_t leading_zero = 0;
+  if (_BitScanReverse64(&leading_zero, value))
+    return 63 - leading_zero;
+  return 64;
+}
+#else
+uint32_t __inline __builtin_clzll(uint64_t value) {
+  if (value == 0)
+    return 64;
+  uint32_t msh = (uint32_t)(value >> 32);
+  uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF);
+  if (msh != 0)
+    return __builtin_clz(msh);
+  return 32 + __builtin_clz(lsh);
+}
+#endif
+
+#define __builtin_clzl __builtin_clzll
+#endif // defined(_MSC_VER) && !defined(__clang__)
+
+#endif /* INT_LIB_H */
diff --git a/compiler-rt/lib/builtins/int_math.h b/compiler-rt/lib/builtins/int_math.h
new file mode 100644
index 0000000..fc81fb7
--- /dev/null
+++ b/compiler-rt/lib/builtins/int_math.h
@@ -0,0 +1,114 @@
+/* ===-- int_math.h - internal math inlines ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===-----------------------------------------------------------------------===
+ *
+ * This file is not part of the interface of this library.
+ *
+ * This file defines substitutes for the libm functions used in some of the
+ * compiler-rt implementations, defined in such a way that there is not a direct
+ * dependency on libm or math.h. Instead, we use the compiler builtin versions
+ * where available. This reduces our dependencies on the system SDK by foisting
+ * the responsibility onto the compiler.
+ *
+ * ===-----------------------------------------------------------------------===
+ */
+
+#ifndef INT_MATH_H
+#define INT_MATH_H
+
+#ifndef __has_builtin
+#  define  __has_builtin(x) 0
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#include <math.h>
+#include <stdlib.h>
+#include <ymath.h>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CRT_INFINITY INFINITY
+#else
+#define CRT_INFINITY __builtin_huge_valf()
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define crt_isfinite(x) _finite((x))
+#define crt_isinf(x) !_finite((x))
+#define crt_isnan(x) _isnan((x))
+#else
+/* Define crt_isfinite in terms of the builtin if available, otherwise provide
+ * an alternate version in terms of our other functions. This supports some
+ * versions of GCC which didn't have __builtin_isfinite.
+ */
+#if __has_builtin(__builtin_isfinite)
+#  define crt_isfinite(x) __builtin_isfinite((x))
+#elif defined(__GNUC__)
+#  define crt_isfinite(x) \
+  __extension__(({ \
+      __typeof((x)) x_ = (x); \
+      !crt_isinf(x_) && !crt_isnan(x_); \
+    }))
+#else
+#  error "Do not know how to check for infinity"
+#endif /* __has_builtin(__builtin_isfinite) */
+#define crt_isinf(x) __builtin_isinf((x))
+#define crt_isnan(x) __builtin_isnan((x))
+#endif /* _MSC_VER */
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define crt_copysign(x, y) copysign((x), (y))
+#define crt_copysignf(x, y) copysignf((x), (y))
+#define crt_copysignl(x, y) copysignl((x), (y))
+#else
+#define crt_copysign(x, y) __builtin_copysign((x), (y))
+#define crt_copysignf(x, y) __builtin_copysignf((x), (y))
+#define crt_copysignl(x, y) __builtin_copysignl((x), (y))
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define crt_fabs(x) fabs((x))
+#define crt_fabsf(x) fabsf((x))
+#define crt_fabsl(x) fabs((x))
+#else
+#define crt_fabs(x) __builtin_fabs((x))
+#define crt_fabsf(x) __builtin_fabsf((x))
+#define crt_fabsl(x) __builtin_fabsl((x))
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define crt_fmax(x, y) __max((x), (y))
+#define crt_fmaxf(x, y) __max((x), (y))
+#define crt_fmaxl(x, y) __max((x), (y))
+#else
+#define crt_fmax(x, y) __builtin_fmax((x), (y))
+#define crt_fmaxf(x, y) __builtin_fmaxf((x), (y))
+#define crt_fmaxl(x, y) __builtin_fmaxl((x), (y))
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define crt_logb(x) logb((x))
+#define crt_logbf(x) logbf((x))
+#define crt_logbl(x) logbl((x))
+#else
+#define crt_logb(x) __builtin_logb((x))
+#define crt_logbf(x) __builtin_logbf((x))
+#define crt_logbl(x) __builtin_logbl((x))
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define crt_scalbn(x, y) scalbn((x), (y))
+#define crt_scalbnf(x, y) scalbnf((x), (y))
+#define crt_scalbnl(x, y) scalbnl((x), (y))
+#else
+#define crt_scalbn(x, y) __builtin_scalbn((x), (y))
+#define crt_scalbnf(x, y) __builtin_scalbnf((x), (y))
+#define crt_scalbnl(x, y) __builtin_scalbnl((x), (y))
+#endif
+
+#endif /* INT_MATH_H */
diff --git a/compiler-rt/lib/builtins/int_types.h b/compiler-rt/lib/builtins/int_types.h
new file mode 100644
index 0000000..2dad43b
--- /dev/null
+++ b/compiler-rt/lib/builtins/int_types.h
@@ -0,0 +1,165 @@
+/* ===-- int_lib.h - configuration header for compiler-rt  -----------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file is not part of the interface of this library.
+ *
+ * This file defines various standard types, most importantly a number of unions
+ * used to access parts of larger types.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifndef INT_TYPES_H
+#define INT_TYPES_H
+
+#include "int_endianness.h"
+
+/* si_int is defined in Linux sysroot's asm-generic/siginfo.h */
+#ifdef si_int
+#undef si_int
+#endif
+typedef      int si_int;
+typedef unsigned su_int;
+
+typedef          long long di_int;
+typedef unsigned long long du_int;
+
+typedef union
+{
+    di_int all;
+    struct
+    {
+#if _YUGA_LITTLE_ENDIAN
+        su_int low;
+        si_int high;
+#else
+        si_int high;
+        su_int low;
+#endif /* _YUGA_LITTLE_ENDIAN */
+    }s;
+} dwords;
+
+typedef union
+{
+    du_int all;
+    struct
+    {
+#if _YUGA_LITTLE_ENDIAN
+        su_int low;
+        su_int high;
+#else
+        su_int high;
+        su_int low;
+#endif /* _YUGA_LITTLE_ENDIAN */
+    }s;
+} udwords;
+
+/* MIPS64 issue: PR 20098 */
+#if defined(__LP64__) && !(defined(__mips__) && defined(__clang__))
+#define CRT_HAS_128BIT
+#endif
+
+#ifdef CRT_HAS_128BIT
+typedef int      ti_int __attribute__ ((mode (TI)));
+typedef unsigned tu_int __attribute__ ((mode (TI)));
+
+typedef union
+{
+    ti_int all;
+    struct
+    {
+#if _YUGA_LITTLE_ENDIAN
+        du_int low;
+        di_int high;
+#else
+        di_int high;
+        du_int low;
+#endif /* _YUGA_LITTLE_ENDIAN */
+    }s;
+} twords;
+
+typedef union
+{
+    tu_int all;
+    struct
+    {
+#if _YUGA_LITTLE_ENDIAN
+        du_int low;
+        du_int high;
+#else
+        du_int high;
+        du_int low;
+#endif /* _YUGA_LITTLE_ENDIAN */
+    }s;
+} utwords;
+
+static __inline ti_int make_ti(di_int h, di_int l) {
+    twords r;
+    r.s.high = h;
+    r.s.low = l;
+    return r.all;
+}
+
+static __inline tu_int make_tu(du_int h, du_int l) {
+    utwords r;
+    r.s.high = h;
+    r.s.low = l;
+    return r.all;
+}
+
+#endif /* CRT_HAS_128BIT */
+
+typedef union
+{
+    su_int u;
+    float f;
+} float_bits;
+
+typedef union
+{
+    udwords u;
+    double  f;
+} double_bits;
+
+typedef struct
+{
+#if _YUGA_LITTLE_ENDIAN
+    udwords low;
+    udwords high;
+#else
+    udwords high;
+    udwords low;
+#endif /* _YUGA_LITTLE_ENDIAN */
+} uqwords;
+
+typedef union
+{
+    uqwords     u;
+    long double f;
+} long_double_bits;
+
+#if __STDC_VERSION__ >= 199901L
+typedef float _Complex Fcomplex;
+typedef double _Complex Dcomplex;
+typedef long double _Complex Lcomplex;
+
+#define COMPLEX_REAL(x) __real__(x)
+#define COMPLEX_IMAGINARY(x) __imag__(x)
+#else
+typedef struct { float real, imaginary; } Fcomplex;
+
+typedef struct { double real, imaginary; } Dcomplex;
+
+typedef struct { long double real, imaginary; } Lcomplex;
+
+#define COMPLEX_REAL(x) (x).real
+#define COMPLEX_IMAGINARY(x) (x).imaginary
+#endif
+#endif /* INT_TYPES_H */
+
diff --git a/compiler-rt/lib/builtins/int_util.c b/compiler-rt/lib/builtins/int_util.c
new file mode 100644
index 0000000..420d1e2
--- /dev/null
+++ b/compiler-rt/lib/builtins/int_util.c
@@ -0,0 +1,61 @@
+/* ===-- int_util.c - Implement internal utilities --------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_util.h"
+
+/* NOTE: The definitions in this file are declared weak because we clients to be
+ * able to arbitrarily package individual functions into separate .a files. If
+ * we did not declare these weak, some link situations might end up seeing
+ * duplicate strong definitions of the same symbol.
+ *
+ * We can't use this solution for kernel use (which may not support weak), but
+ * currently expect that when built for kernel use all the functionality is
+ * packaged into a single library.
+ */
+
+#ifdef KERNEL_USE
+
+NORETURN extern void panic(const char *, ...);
+#ifndef _WIN32
+__attribute__((visibility("hidden")))
+#endif
+void compilerrt_abort_impl(const char *file, int line, const char *function) {
+  panic("%s:%d: abort in %s", file, line, function);
+}
+
+#elif __APPLE__
+
+/* from libSystem.dylib */
+NORETURN extern void __assert_rtn(const char *func, const char *file, int line,
+                                  const char *message);
+
+#ifndef _WIN32
+__attribute__((weak))
+__attribute__((visibility("hidden")))
+#endif
+void compilerrt_abort_impl(const char *file, int line, const char *function) {
+  __assert_rtn(function, file, line, "libcompiler_rt abort");
+}
+
+#else
+
+/* Get the system definition of abort() */
+#include <stdlib.h>
+
+#ifndef _WIN32
+__attribute__((weak))
+__attribute__((visibility("hidden")))
+#endif
+void compilerrt_abort_impl(const char *file, int line, const char *function) {
+  abort();
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/int_util.h b/compiler-rt/lib/builtins/int_util.h
new file mode 100644
index 0000000..a7b20ed
--- /dev/null
+++ b/compiler-rt/lib/builtins/int_util.h
@@ -0,0 +1,33 @@
+/* ===-- int_util.h - internal utility functions ----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===-----------------------------------------------------------------------===
+ *
+ * This file is not part of the interface of this library.
+ *
+ * This file defines non-inline utilities which are available for use in the
+ * library. The function definitions themselves are all contained in int_util.c
+ * which will always be compiled into any compiler-rt library.
+ *
+ * ===-----------------------------------------------------------------------===
+ */
+
+#ifndef INT_UTIL_H
+#define INT_UTIL_H
+
+/** \brief Trigger a program abort (or panic for kernel code). */
+#define compilerrt_abort() compilerrt_abort_impl(__FILE__, __LINE__, __func__)
+
+NORETURN void compilerrt_abort_impl(const char *file, int line,
+                                    const char *function);
+
+#define COMPILE_TIME_ASSERT(expr) COMPILE_TIME_ASSERT1(expr, __COUNTER__)
+#define COMPILE_TIME_ASSERT1(expr, cnt) COMPILE_TIME_ASSERT2(expr, cnt)
+#define COMPILE_TIME_ASSERT2(expr, cnt)                                        \
+  typedef char ct_assert_##cnt[(expr) ? 1 : -1] UNUSED
+
+#endif /* INT_UTIL_H */
diff --git a/compiler-rt/lib/builtins/lshrdi3.c b/compiler-rt/lib/builtins/lshrdi3.c
new file mode 100644
index 0000000..6b1ea92
--- /dev/null
+++ b/compiler-rt/lib/builtins/lshrdi3.c
@@ -0,0 +1,43 @@
+/* ===-- lshrdi3.c - Implement __lshrdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __lshrdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: logical a >> b */
+
+/* Precondition:  0 <= b < bits_in_dword */
+
+ARM_EABI_FNALIAS(llsr, lshrdi3)
+
+COMPILER_RT_ABI di_int
+__lshrdi3(di_int a, si_int b)
+{
+    const int bits_in_word = (int)(sizeof(si_int) * CHAR_BIT);
+    udwords input;
+    udwords result;
+    input.all = a;
+    if (b & bits_in_word)  /* bits_in_word <= b < bits_in_dword */
+    {
+        result.s.high = 0;
+        result.s.low = input.s.high >> (b - bits_in_word);
+    }
+    else  /* 0 <= b < bits_in_word */
+    {
+        if (b == 0)
+            return a;
+        result.s.high  = input.s.high >> b;
+        result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b);
+    }
+    return result.all;
+}
diff --git a/compiler-rt/lib/builtins/lshrti3.c b/compiler-rt/lib/builtins/lshrti3.c
new file mode 100644
index 0000000..e4170ff
--- /dev/null
+++ b/compiler-rt/lib/builtins/lshrti3.c
@@ -0,0 +1,45 @@
+/* ===-- lshrti3.c - Implement __lshrti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __lshrti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: logical a >> b */
+
+/* Precondition:  0 <= b < bits_in_tword */
+
+COMPILER_RT_ABI ti_int
+__lshrti3(ti_int a, si_int b)
+{
+    const int bits_in_dword = (int)(sizeof(di_int) * CHAR_BIT);
+    utwords input;
+    utwords result;
+    input.all = a;
+    if (b & bits_in_dword)  /* bits_in_dword <= b < bits_in_tword */
+    {
+        result.s.high = 0;
+        result.s.low = input.s.high >> (b - bits_in_dword);
+    }
+    else  /* 0 <= b < bits_in_dword */
+    {
+        if (b == 0)
+            return a;
+        result.s.high  = input.s.high >> b;
+        result.s.low = (input.s.high << (bits_in_dword - b)) | (input.s.low >> b);
+    }
+    return result.all;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/macho_embedded/CMakeLists.txt b/compiler-rt/lib/builtins/macho_embedded/CMakeLists.txt
new file mode 100644
index 0000000..266e422
--- /dev/null
+++ b/compiler-rt/lib/builtins/macho_embedded/CMakeLists.txt
@@ -0,0 +1,4 @@
+file(GLOB filter_files ${CMAKE_CURRENT_SOURCE_DIR}/*.txt)
+foreach(filter_file ${filter_files})
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${filter_file})
+endforeach()
diff --git a/compiler-rt/lib/builtins/macho_embedded/arm.txt b/compiler-rt/lib/builtins/macho_embedded/arm.txt
new file mode 100644
index 0000000..4b1683a
--- /dev/null
+++ b/compiler-rt/lib/builtins/macho_embedded/arm.txt
@@ -0,0 +1,16 @@
+aeabi_cdcmpeq
+aeabi_cdrcmple
+aeabi_cfcmpeq
+aeabi_cfrcmple
+aeabi_dcmpeq
+aeabi_dcmpge
+aeabi_dcmpgt
+aeabi_dcmple
+aeabi_dcmplt
+aeabi_drsub
+aeabi_fcmpeq
+aeabi_fcmpge
+aeabi_fcmpgt
+aeabi_fcmple
+aeabi_fcmplt
+aeabi_frsub
diff --git a/compiler-rt/lib/builtins/macho_embedded/common.txt b/compiler-rt/lib/builtins/macho_embedded/common.txt
new file mode 100644
index 0000000..6ac85a7
--- /dev/null
+++ b/compiler-rt/lib/builtins/macho_embedded/common.txt
@@ -0,0 +1,92 @@
+absvdi2
+absvsi2
+addvdi3
+addvsi3
+ashldi3
+ashrdi3
+clzdi2
+clzsi2
+cmpdi2
+ctzdi2
+ctzsi2
+divdc3
+divdi3
+divsc3
+divmodsi4
+udivmodsi4
+do_global_dtors
+ffsdi2
+fixdfdi
+fixsfdi
+fixunsdfdi
+fixunsdfsi
+fixunssfdi
+fixunssfsi
+floatdidf
+floatdisf
+floatundidf
+floatundisf
+gcc_bcmp
+lshrdi3
+moddi3
+muldc3
+muldi3
+mulsc3
+mulvdi3
+mulvsi3
+negdi2
+negvdi2
+negvsi2
+paritydi2
+paritysi2
+popcountdi2
+popcountsi2
+powidf2
+powisf2
+subvdi3
+subvsi3
+ucmpdi2
+udiv_w_sdiv
+udivdi3
+udivmoddi4
+umoddi3
+adddf3
+addsf3
+cmpdf2
+cmpsf2
+div0
+divdf3
+divsf3
+divsi3
+extendsfdf2
+extendhfsf2
+ffssi2
+fixdfsi
+fixsfsi
+floatsidf
+floatsisf
+floatunsidf
+floatunsisf
+comparedf2
+comparesf2
+modsi3
+muldf3
+mulsf3
+negdf2
+negsf2
+subdf3
+subsf3
+truncdfhf2
+truncdfsf2
+truncsfhf2
+udivsi3
+umodsi3
+unorddf2
+unordsf2
+atomic_flag_clear
+atomic_flag_clear_explicit
+atomic_flag_test_and_set
+atomic_flag_test_and_set_explicit
+atomic_signal_fence
+atomic_thread_fence
+int_util
diff --git a/compiler-rt/lib/builtins/macho_embedded/i386.txt b/compiler-rt/lib/builtins/macho_embedded/i386.txt
new file mode 100644
index 0000000..b92e44b
--- /dev/null
+++ b/compiler-rt/lib/builtins/macho_embedded/i386.txt
@@ -0,0 +1,7 @@
+i686.get_pc_thunk.eax
+i686.get_pc_thunk.ebp
+i686.get_pc_thunk.ebx
+i686.get_pc_thunk.ecx
+i686.get_pc_thunk.edi
+i686.get_pc_thunk.edx
+i686.get_pc_thunk.esi
diff --git a/compiler-rt/lib/builtins/macho_embedded/thumb2-64.txt b/compiler-rt/lib/builtins/macho_embedded/thumb2-64.txt
new file mode 100644
index 0000000..1c72fb1
--- /dev/null
+++ b/compiler-rt/lib/builtins/macho_embedded/thumb2-64.txt
@@ -0,0 +1,10 @@
+sync_fetch_and_add_8
+sync_fetch_and_sub_8
+sync_fetch_and_and_8
+sync_fetch_and_or_8
+sync_fetch_and_xor_8
+sync_fetch_and_nand_8
+sync_fetch_and_max_8
+sync_fetch_and_umax_8
+sync_fetch_and_min_8
+sync_fetch_and_umin_8
diff --git a/compiler-rt/lib/builtins/macho_embedded/thumb2.txt b/compiler-rt/lib/builtins/macho_embedded/thumb2.txt
new file mode 100644
index 0000000..6add5ec
--- /dev/null
+++ b/compiler-rt/lib/builtins/macho_embedded/thumb2.txt
@@ -0,0 +1,14 @@
+switch16
+switch32
+switch8
+switchu8
+sync_fetch_and_add_4
+sync_fetch_and_sub_4
+sync_fetch_and_and_4
+sync_fetch_and_or_4
+sync_fetch_and_xor_4
+sync_fetch_and_nand_4
+sync_fetch_and_max_4
+sync_fetch_and_umax_4
+sync_fetch_and_min_4
+sync_fetch_and_umin_4
diff --git a/compiler-rt/lib/builtins/moddi3.c b/compiler-rt/lib/builtins/moddi3.c
new file mode 100644
index 0000000..a04279e
--- /dev/null
+++ b/compiler-rt/lib/builtins/moddi3.c
@@ -0,0 +1,30 @@
+/*===-- moddi3.c - Implement __moddi3 -------------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __moddi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a % b */
+
+COMPILER_RT_ABI di_int
+__moddi3(di_int a, di_int b)
+{
+    const int bits_in_dword_m1 = (int)(sizeof(di_int) * CHAR_BIT) - 1;
+    di_int s = b >> bits_in_dword_m1;  /* s = b < 0 ? -1 : 0 */
+    b = (b ^ s) - s;                   /* negate if s == -1 */
+    s = a >> bits_in_dword_m1;         /* s = a < 0 ? -1 : 0 */
+    a = (a ^ s) - s;                   /* negate if s == -1 */
+    du_int r;
+    __udivmoddi4(a, b, &r);
+    return ((di_int)r ^ s) - s;                /* negate if s == -1 */
+}
diff --git a/compiler-rt/lib/builtins/modsi3.c b/compiler-rt/lib/builtins/modsi3.c
new file mode 100644
index 0000000..86c73ce
--- /dev/null
+++ b/compiler-rt/lib/builtins/modsi3.c
@@ -0,0 +1,23 @@
+/* ===-- modsi3.c - Implement __modsi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __modsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a % b */
+
+COMPILER_RT_ABI si_int
+__modsi3(si_int a, si_int b)
+{
+    return a - __divsi3(a, b) * b;
+}
diff --git a/compiler-rt/lib/builtins/modti3.c b/compiler-rt/lib/builtins/modti3.c
new file mode 100644
index 0000000..d505c07
--- /dev/null
+++ b/compiler-rt/lib/builtins/modti3.c
@@ -0,0 +1,34 @@
+/* ===-- modti3.c - Implement __modti3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __modti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/*Returns: a % b */
+
+COMPILER_RT_ABI ti_int
+__modti3(ti_int a, ti_int b)
+{
+    const int bits_in_tword_m1 = (int)(sizeof(ti_int) * CHAR_BIT) - 1;
+    ti_int s = b >> bits_in_tword_m1;  /* s = b < 0 ? -1 : 0 */
+    b = (b ^ s) - s;                   /* negate if s == -1 */
+    s = a >> bits_in_tword_m1;         /* s = a < 0 ? -1 : 0 */
+    a = (a ^ s) - s;                   /* negate if s == -1 */
+    tu_int r;
+    __udivmodti4(a, b, &r);
+    return ((ti_int)r ^ s) - s;                /* negate if s == -1 */
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/muldc3.c b/compiler-rt/lib/builtins/muldc3.c
new file mode 100644
index 0000000..16d8e98
--- /dev/null
+++ b/compiler-rt/lib/builtins/muldc3.c
@@ -0,0 +1,73 @@
+/* ===-- muldc3.c - Implement __muldc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __muldc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the product of a + ib and c + id */
+
+COMPILER_RT_ABI Dcomplex
+__muldc3(double __a, double __b, double __c, double __d)
+{
+    double __ac = __a * __c;
+    double __bd = __b * __d;
+    double __ad = __a * __d;
+    double __bc = __b * __c;
+    Dcomplex z;
+    COMPLEX_REAL(z) = __ac - __bd;
+    COMPLEX_IMAGINARY(z) = __ad + __bc;
+    if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
+    {
+        int __recalc = 0;
+        if (crt_isinf(__a) || crt_isinf(__b))
+        {
+            __a = crt_copysign(crt_isinf(__a) ? 1 : 0, __a);
+            __b = crt_copysign(crt_isinf(__b) ? 1 : 0, __b);
+            if (crt_isnan(__c))
+                __c = crt_copysign(0, __c);
+            if (crt_isnan(__d))
+                __d = crt_copysign(0, __d);
+            __recalc = 1;
+        }
+        if (crt_isinf(__c) || crt_isinf(__d))
+        {
+            __c = crt_copysign(crt_isinf(__c) ? 1 : 0, __c);
+            __d = crt_copysign(crt_isinf(__d) ? 1 : 0, __d);
+            if (crt_isnan(__a))
+                __a = crt_copysign(0, __a);
+            if (crt_isnan(__b))
+                __b = crt_copysign(0, __b);
+            __recalc = 1;
+        }
+        if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) ||
+                          crt_isinf(__ad) || crt_isinf(__bc)))
+        {
+            if (crt_isnan(__a))
+                __a = crt_copysign(0, __a);
+            if (crt_isnan(__b))
+                __b = crt_copysign(0, __b);
+            if (crt_isnan(__c))
+                __c = crt_copysign(0, __c);
+            if (crt_isnan(__d))
+                __d = crt_copysign(0, __d);
+            __recalc = 1;
+        }
+        if (__recalc)
+        {
+            COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
+            COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
+        }
+    }
+    return z;
+}
diff --git a/compiler-rt/lib/builtins/muldf3.c b/compiler-rt/lib/builtins/muldf3.c
new file mode 100644
index 0000000..1eb7338
--- /dev/null
+++ b/compiler-rt/lib/builtins/muldf3.c
@@ -0,0 +1,22 @@
+//===-- lib/muldf3.c - Double-precision multiplication ------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements double-precision soft-float multiplication
+// with the IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_mul_impl.inc"
+
+ARM_EABI_FNALIAS(dmul, muldf3)
+
+COMPILER_RT_ABI fp_t __muldf3(fp_t a, fp_t b) {
+    return __mulXf3__(a, b);
+}
diff --git a/compiler-rt/lib/builtins/muldi3.c b/compiler-rt/lib/builtins/muldi3.c
new file mode 100644
index 0000000..2dae44c
--- /dev/null
+++ b/compiler-rt/lib/builtins/muldi3.c
@@ -0,0 +1,56 @@
+/* ===-- muldi3.c - Implement __muldi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __muldi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a * b */
+
+static
+di_int
+__muldsi3(su_int a, su_int b)
+{
+    dwords r;
+    const int bits_in_word_2 = (int)(sizeof(si_int) * CHAR_BIT) / 2;
+    const su_int lower_mask = (su_int)~0 >> bits_in_word_2;
+    r.s.low = (a & lower_mask) * (b & lower_mask);
+    su_int t = r.s.low >> bits_in_word_2;
+    r.s.low &= lower_mask;
+    t += (a >> bits_in_word_2) * (b & lower_mask);
+    r.s.low += (t & lower_mask) << bits_in_word_2;
+    r.s.high = t >> bits_in_word_2;
+    t = r.s.low >> bits_in_word_2;
+    r.s.low &= lower_mask;
+    t += (b >> bits_in_word_2) * (a & lower_mask);
+    r.s.low += (t & lower_mask) << bits_in_word_2;
+    r.s.high += t >> bits_in_word_2;
+    r.s.high += (a >> bits_in_word_2) * (b >> bits_in_word_2);
+    return r.all;
+}
+
+/* Returns: a * b */
+
+ARM_EABI_FNALIAS(lmul, muldi3)
+
+COMPILER_RT_ABI di_int
+__muldi3(di_int a, di_int b)
+{
+    dwords x;
+    x.all = a;
+    dwords y;
+    y.all = b;
+    dwords r;
+    r.all = __muldsi3(x.s.low, y.s.low);
+    r.s.high += x.s.high * y.s.low + x.s.low * y.s.high;
+    return r.all;
+}
diff --git a/compiler-rt/lib/builtins/mulodi4.c b/compiler-rt/lib/builtins/mulodi4.c
new file mode 100644
index 0000000..d2fd7db
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulodi4.c
@@ -0,0 +1,58 @@
+/*===-- mulodi4.c - Implement __mulodi4 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulodi4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a * b */
+
+/* Effects: sets *overflow to 1  if a * b overflows */
+
+COMPILER_RT_ABI di_int
+__mulodi4(di_int a, di_int b, int* overflow)
+{
+    const int N = (int)(sizeof(di_int) * CHAR_BIT);
+    const di_int MIN = (di_int)1 << (N-1);
+    const di_int MAX = ~MIN;
+    *overflow = 0; 
+    di_int result = a * b;
+    if (a == MIN)
+    {
+        if (b != 0 && b != 1)
+	    *overflow = 1;
+	return result;
+    }
+    if (b == MIN)
+    {
+        if (a != 0 && a != 1)
+	    *overflow = 1;
+        return result;
+    }
+    di_int sa = a >> (N - 1);
+    di_int abs_a = (a ^ sa) - sa;
+    di_int sb = b >> (N - 1);
+    di_int abs_b = (b ^ sb) - sb;
+    if (abs_a < 2 || abs_b < 2)
+        return result;
+    if (sa == sb)
+    {
+        if (abs_a > MAX / abs_b)
+            *overflow = 1;
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            *overflow = 1;
+    }
+    return result;
+}
diff --git a/compiler-rt/lib/builtins/mulosi4.c b/compiler-rt/lib/builtins/mulosi4.c
new file mode 100644
index 0000000..4225280
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulosi4.c
@@ -0,0 +1,58 @@
+/*===-- mulosi4.c - Implement __mulosi4 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulosi4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a * b */
+
+/* Effects: sets *overflow to 1  if a * b overflows */
+
+COMPILER_RT_ABI si_int
+__mulosi4(si_int a, si_int b, int* overflow)
+{
+    const int N = (int)(sizeof(si_int) * CHAR_BIT);
+    const si_int MIN = (si_int)1 << (N-1);
+    const si_int MAX = ~MIN;
+    *overflow = 0; 
+    si_int result = a * b;
+    if (a == MIN)
+    {
+        if (b != 0 && b != 1)
+	    *overflow = 1;
+	return result;
+    }
+    if (b == MIN)
+    {
+        if (a != 0 && a != 1)
+	    *overflow = 1;
+        return result;
+    }
+    si_int sa = a >> (N - 1);
+    si_int abs_a = (a ^ sa) - sa;
+    si_int sb = b >> (N - 1);
+    si_int abs_b = (b ^ sb) - sb;
+    if (abs_a < 2 || abs_b < 2)
+        return result;
+    if (sa == sb)
+    {
+        if (abs_a > MAX / abs_b)
+            *overflow = 1;
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            *overflow = 1;
+    }
+    return result;
+}
diff --git a/compiler-rt/lib/builtins/muloti4.c b/compiler-rt/lib/builtins/muloti4.c
new file mode 100644
index 0000000..16b2189
--- /dev/null
+++ b/compiler-rt/lib/builtins/muloti4.c
@@ -0,0 +1,62 @@
+/*===-- muloti4.c - Implement __muloti4 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __muloti4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a * b */
+
+/* Effects: sets *overflow to 1  if a * b overflows */
+
+COMPILER_RT_ABI ti_int
+__muloti4(ti_int a, ti_int b, int* overflow)
+{
+    const int N = (int)(sizeof(ti_int) * CHAR_BIT);
+    const ti_int MIN = (ti_int)1 << (N-1);
+    const ti_int MAX = ~MIN;
+    *overflow = 0;
+    ti_int result = a * b;
+    if (a == MIN)
+    {
+        if (b != 0 && b != 1)
+	    *overflow = 1;
+	return result;
+    }
+    if (b == MIN)
+    {
+        if (a != 0 && a != 1)
+	    *overflow = 1;
+        return result;
+    }
+    ti_int sa = a >> (N - 1);
+    ti_int abs_a = (a ^ sa) - sa;
+    ti_int sb = b >> (N - 1);
+    ti_int abs_b = (b ^ sb) - sb;
+    if (abs_a < 2 || abs_b < 2)
+        return result;
+    if (sa == sb)
+    {
+        if (abs_a > MAX / abs_b)
+            *overflow = 1;
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            *overflow = 1;
+    }
+    return result;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/mulsc3.c b/compiler-rt/lib/builtins/mulsc3.c
new file mode 100644
index 0000000..c89cfd2
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulsc3.c
@@ -0,0 +1,73 @@
+/* ===-- mulsc3.c - Implement __mulsc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulsc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the product of a + ib and c + id */
+
+COMPILER_RT_ABI Fcomplex
+__mulsc3(float __a, float __b, float __c, float __d)
+{
+    float __ac = __a * __c;
+    float __bd = __b * __d;
+    float __ad = __a * __d;
+    float __bc = __b * __c;
+    Fcomplex z;
+    COMPLEX_REAL(z) = __ac - __bd;
+    COMPLEX_IMAGINARY(z) = __ad + __bc;
+    if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
+    {
+        int __recalc = 0;
+        if (crt_isinf(__a) || crt_isinf(__b))
+        {
+            __a = crt_copysignf(crt_isinf(__a) ? 1 : 0, __a);
+            __b = crt_copysignf(crt_isinf(__b) ? 1 : 0, __b);
+            if (crt_isnan(__c))
+                __c = crt_copysignf(0, __c);
+            if (crt_isnan(__d))
+                __d = crt_copysignf(0, __d);
+            __recalc = 1;
+        }
+        if (crt_isinf(__c) || crt_isinf(__d))
+        {
+            __c = crt_copysignf(crt_isinf(__c) ? 1 : 0, __c);
+            __d = crt_copysignf(crt_isinf(__d) ? 1 : 0, __d);
+            if (crt_isnan(__a))
+                __a = crt_copysignf(0, __a);
+            if (crt_isnan(__b))
+                __b = crt_copysignf(0, __b);
+            __recalc = 1;
+        }
+        if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) ||
+                          crt_isinf(__ad) || crt_isinf(__bc)))
+        {
+            if (crt_isnan(__a))
+                __a = crt_copysignf(0, __a);
+            if (crt_isnan(__b))
+                __b = crt_copysignf(0, __b);
+            if (crt_isnan(__c))
+                __c = crt_copysignf(0, __c);
+            if (crt_isnan(__d))
+                __d = crt_copysignf(0, __d);
+            __recalc = 1;
+        }
+        if (__recalc)
+        {
+            COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
+            COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
+        }
+    }
+    return z;
+}
diff --git a/compiler-rt/lib/builtins/mulsf3.c b/compiler-rt/lib/builtins/mulsf3.c
new file mode 100644
index 0000000..478b3bc
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulsf3.c
@@ -0,0 +1,22 @@
+//===-- lib/mulsf3.c - Single-precision multiplication ------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements single-precision soft-float multiplication
+// with the IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_mul_impl.inc"
+
+ARM_EABI_FNALIAS(fmul, mulsf3)
+
+COMPILER_RT_ABI fp_t __mulsf3(fp_t a, fp_t b) {
+    return __mulXf3__(a, b);
+}
diff --git a/compiler-rt/lib/builtins/multc3.c b/compiler-rt/lib/builtins/multc3.c
new file mode 100644
index 0000000..0518bc2
--- /dev/null
+++ b/compiler-rt/lib/builtins/multc3.c
@@ -0,0 +1,68 @@
+/* ===-- multc3.c - Implement __multc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __multc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the product of a + ib and c + id */
+
+COMPILER_RT_ABI long double _Complex
+__multc3(long double a, long double b, long double c, long double d)
+{
+    long double ac = a * c;
+    long double bd = b * d;
+    long double ad = a * d;
+    long double bc = b * c;
+    long double _Complex z;
+    __real__ z = ac - bd;
+    __imag__ z = ad + bc;
+    if (crt_isnan(__real__ z) && crt_isnan(__imag__ z)) {
+        int recalc = 0;
+        if (crt_isinf(a) || crt_isinf(b)) {
+            a = crt_copysignl(crt_isinf(a) ? 1 : 0, a);
+            b = crt_copysignl(crt_isinf(b) ? 1 : 0, b);
+            if (crt_isnan(c))
+                c = crt_copysignl(0, c);
+            if (crt_isnan(d))
+                d = crt_copysignl(0, d);
+            recalc = 1;
+        }
+        if (crt_isinf(c) || crt_isinf(d)) {
+            c = crt_copysignl(crt_isinf(c) ? 1 : 0, c);
+            d = crt_copysignl(crt_isinf(d) ? 1 : 0, d);
+            if (crt_isnan(a))
+                a = crt_copysignl(0, a);
+            if (crt_isnan(b))
+                b = crt_copysignl(0, b);
+            recalc = 1;
+        }
+        if (!recalc && (crt_isinf(ac) || crt_isinf(bd) ||
+                          crt_isinf(ad) || crt_isinf(bc))) {
+            if (crt_isnan(a))
+                a = crt_copysignl(0, a);
+            if (crt_isnan(b))
+                b = crt_copysignl(0, b);
+            if (crt_isnan(c))
+                c = crt_copysignl(0, c);
+            if (crt_isnan(d))
+                d = crt_copysignl(0, d);
+            recalc = 1;
+        }
+        if (recalc) {
+            __real__ z = CRT_INFINITY * (a * c - b * d);
+            __imag__ z = CRT_INFINITY * (a * d + b * c);
+        }
+    }
+    return z;
+}
diff --git a/compiler-rt/lib/builtins/multf3.c b/compiler-rt/lib/builtins/multf3.c
new file mode 100644
index 0000000..0b91592
--- /dev/null
+++ b/compiler-rt/lib/builtins/multf3.c
@@ -0,0 +1,25 @@
+//===-- lib/multf3.c - Quad-precision multiplication --------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements quad-precision soft-float multiplication
+// with the IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#include "fp_mul_impl.inc"
+
+COMPILER_RT_ABI fp_t __multf3(fp_t a, fp_t b) {
+    return __mulXf3__(a, b);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/multi3.c b/compiler-rt/lib/builtins/multi3.c
new file mode 100644
index 0000000..e0d52d4
--- /dev/null
+++ b/compiler-rt/lib/builtins/multi3.c
@@ -0,0 +1,58 @@
+/* ===-- multi3.c - Implement __multi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+
+ * This file implements __multi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a * b */
+
+static
+ti_int
+__mulddi3(du_int a, du_int b)
+{
+    twords r;
+    const int bits_in_dword_2 = (int)(sizeof(di_int) * CHAR_BIT) / 2;
+    const du_int lower_mask = (du_int)~0 >> bits_in_dword_2;
+    r.s.low = (a & lower_mask) * (b & lower_mask);
+    du_int t = r.s.low >> bits_in_dword_2;
+    r.s.low &= lower_mask;
+    t += (a >> bits_in_dword_2) * (b & lower_mask);
+    r.s.low += (t & lower_mask) << bits_in_dword_2;
+    r.s.high = t >> bits_in_dword_2;
+    t = r.s.low >> bits_in_dword_2;
+    r.s.low &= lower_mask;
+    t += (b >> bits_in_dword_2) * (a & lower_mask);
+    r.s.low += (t & lower_mask) << bits_in_dword_2;
+    r.s.high += t >> bits_in_dword_2;
+    r.s.high += (a >> bits_in_dword_2) * (b >> bits_in_dword_2);
+    return r.all;
+}
+
+/* Returns: a * b */
+
+COMPILER_RT_ABI ti_int
+__multi3(ti_int a, ti_int b)
+{
+    twords x;
+    x.all = a;
+    twords y;
+    y.all = b;
+    twords r;
+    r.all = __mulddi3(x.s.low, y.s.low);
+    r.s.high += x.s.high * y.s.low + x.s.low * y.s.high;
+    return r.all;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/mulvdi3.c b/compiler-rt/lib/builtins/mulvdi3.c
new file mode 100644
index 0000000..e63249e
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulvdi3.c
@@ -0,0 +1,56 @@
+/*===-- mulvdi3.c - Implement __mulvdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulvdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a * b */
+
+/* Effects: aborts if a * b overflows */
+
+COMPILER_RT_ABI di_int
+__mulvdi3(di_int a, di_int b)
+{
+    const int N = (int)(sizeof(di_int) * CHAR_BIT);
+    const di_int MIN = (di_int)1 << (N-1);
+    const di_int MAX = ~MIN;
+    if (a == MIN)
+    {
+        if (b == 0 || b == 1)
+            return a * b;
+        compilerrt_abort();
+    }
+    if (b == MIN)
+    {
+        if (a == 0 || a == 1)
+            return a * b;
+        compilerrt_abort();
+    }
+    di_int sa = a >> (N - 1);
+    di_int abs_a = (a ^ sa) - sa;
+    di_int sb = b >> (N - 1);
+    di_int abs_b = (b ^ sb) - sb;
+    if (abs_a < 2 || abs_b < 2)
+        return a * b;
+    if (sa == sb)
+    {
+        if (abs_a > MAX / abs_b)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            compilerrt_abort();
+    }
+    return a * b;
+}
diff --git a/compiler-rt/lib/builtins/mulvsi3.c b/compiler-rt/lib/builtins/mulvsi3.c
new file mode 100644
index 0000000..74ea4f2
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulvsi3.c
@@ -0,0 +1,56 @@
+/* ===-- mulvsi3.c - Implement __mulvsi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulvsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a * b */
+
+/* Effects: aborts if a * b overflows */
+
+COMPILER_RT_ABI si_int
+__mulvsi3(si_int a, si_int b)
+{
+    const int N = (int)(sizeof(si_int) * CHAR_BIT);
+    const si_int MIN = (si_int)1 << (N-1);
+    const si_int MAX = ~MIN;
+    if (a == MIN)
+    {
+        if (b == 0 || b == 1)
+            return a * b;
+        compilerrt_abort();
+    }
+    if (b == MIN)
+    {
+        if (a == 0 || a == 1)
+            return a * b;
+        compilerrt_abort();
+    }
+    si_int sa = a >> (N - 1);
+    si_int abs_a = (a ^ sa) - sa;
+    si_int sb = b >> (N - 1);
+    si_int abs_b = (b ^ sb) - sb;
+    if (abs_a < 2 || abs_b < 2)
+        return a * b;
+    if (sa == sb)
+    {
+        if (abs_a > MAX / abs_b)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            compilerrt_abort();
+    }
+    return a * b;
+}
diff --git a/compiler-rt/lib/builtins/mulvti3.c b/compiler-rt/lib/builtins/mulvti3.c
new file mode 100644
index 0000000..f4c7d16
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulvti3.c
@@ -0,0 +1,60 @@
+/* ===-- mulvti3.c - Implement __mulvti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulvti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a * b */
+
+/* Effects: aborts if a * b overflows */
+
+COMPILER_RT_ABI ti_int
+__mulvti3(ti_int a, ti_int b)
+{
+    const int N = (int)(sizeof(ti_int) * CHAR_BIT);
+    const ti_int MIN = (ti_int)1 << (N-1);
+    const ti_int MAX = ~MIN;
+    if (a == MIN)
+    {
+        if (b == 0 || b == 1)
+            return a * b;
+        compilerrt_abort();
+    }
+    if (b == MIN)
+    {
+        if (a == 0 || a == 1)
+            return a * b;
+        compilerrt_abort();
+    }
+    ti_int sa = a >> (N - 1);
+    ti_int abs_a = (a ^ sa) - sa;
+    ti_int sb = b >> (N - 1);
+    ti_int abs_b = (b ^ sb) - sb;
+    if (abs_a < 2 || abs_b < 2)
+        return a * b;
+    if (sa == sb)
+    {
+        if (abs_a > MAX / abs_b)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            compilerrt_abort();
+    }
+    return a * b;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/mulxc3.c b/compiler-rt/lib/builtins/mulxc3.c
new file mode 100644
index 0000000..ba32216
--- /dev/null
+++ b/compiler-rt/lib/builtins/mulxc3.c
@@ -0,0 +1,77 @@
+/* ===-- mulxc3.c - Implement __mulxc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulxc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include "int_math.h"
+
+/* Returns: the product of a + ib and c + id */
+
+COMPILER_RT_ABI Lcomplex
+__mulxc3(long double __a, long double __b, long double __c, long double __d)
+{
+    long double __ac = __a * __c;
+    long double __bd = __b * __d;
+    long double __ad = __a * __d;
+    long double __bc = __b * __c;
+    Lcomplex z;
+    COMPLEX_REAL(z) = __ac - __bd;
+    COMPLEX_IMAGINARY(z) = __ad + __bc;
+    if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
+    {
+        int __recalc = 0;
+        if (crt_isinf(__a) || crt_isinf(__b))
+        {
+            __a = crt_copysignl(crt_isinf(__a) ? 1 : 0, __a);
+            __b = crt_copysignl(crt_isinf(__b) ? 1 : 0, __b);
+            if (crt_isnan(__c))
+                __c = crt_copysignl(0, __c);
+            if (crt_isnan(__d))
+                __d = crt_copysignl(0, __d);
+            __recalc = 1;
+        }
+        if (crt_isinf(__c) || crt_isinf(__d))
+        {
+            __c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c);
+            __d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d);
+            if (crt_isnan(__a))
+                __a = crt_copysignl(0, __a);
+            if (crt_isnan(__b))
+                __b = crt_copysignl(0, __b);
+            __recalc = 1;
+        }
+        if (!__recalc && (crt_isinf(__ac) || crt_isinf(__bd) ||
+                          crt_isinf(__ad) || crt_isinf(__bc)))
+        {
+            if (crt_isnan(__a))
+                __a = crt_copysignl(0, __a);
+            if (crt_isnan(__b))
+                __b = crt_copysignl(0, __b);
+            if (crt_isnan(__c))
+                __c = crt_copysignl(0, __c);
+            if (crt_isnan(__d))
+                __d = crt_copysignl(0, __d);
+            __recalc = 1;
+        }
+        if (__recalc)
+        {
+            COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
+            COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
+        }
+    }
+    return z;
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/negdf2.c b/compiler-rt/lib/builtins/negdf2.c
new file mode 100644
index 0000000..d634b42
--- /dev/null
+++ b/compiler-rt/lib/builtins/negdf2.c
@@ -0,0 +1,22 @@
+//===-- lib/negdf2.c - double-precision negation ------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements double-precision soft-float negation.
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(dneg, negdf2)
+
+COMPILER_RT_ABI fp_t
+__negdf2(fp_t a) {
+    return fromRep(toRep(a) ^ signBit);
+}
diff --git a/compiler-rt/lib/builtins/negdi2.c b/compiler-rt/lib/builtins/negdi2.c
new file mode 100644
index 0000000..3d49ba2
--- /dev/null
+++ b/compiler-rt/lib/builtins/negdi2.c
@@ -0,0 +1,26 @@
+/* ===-- negdi2.c - Implement __negdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: -a */
+
+COMPILER_RT_ABI di_int
+__negdi2(di_int a)
+{
+    /* Note: this routine is here for API compatibility; any sane compiler
+     * should expand it inline.
+     */
+    return -a;
+}
diff --git a/compiler-rt/lib/builtins/negsf2.c b/compiler-rt/lib/builtins/negsf2.c
new file mode 100644
index 0000000..29c17be
--- /dev/null
+++ b/compiler-rt/lib/builtins/negsf2.c
@@ -0,0 +1,22 @@
+//===-- lib/negsf2.c - single-precision negation ------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements single-precision soft-float negation.
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(fneg, negsf2)
+
+COMPILER_RT_ABI fp_t
+__negsf2(fp_t a) {
+    return fromRep(toRep(a) ^ signBit);
+}
diff --git a/compiler-rt/lib/builtins/negti2.c b/compiler-rt/lib/builtins/negti2.c
new file mode 100644
index 0000000..9b00b30
--- /dev/null
+++ b/compiler-rt/lib/builtins/negti2.c
@@ -0,0 +1,30 @@
+/* ===-- negti2.c - Implement __negti2 -------------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: -a */
+
+COMPILER_RT_ABI ti_int
+__negti2(ti_int a)
+{
+    /* Note: this routine is here for API compatibility; any sane compiler
+     * should expand it inline.
+     */
+    return -a;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/negvdi2.c b/compiler-rt/lib/builtins/negvdi2.c
new file mode 100644
index 0000000..e336ecf
--- /dev/null
+++ b/compiler-rt/lib/builtins/negvdi2.c
@@ -0,0 +1,28 @@
+/* ===-- negvdi2.c - Implement __negvdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negvdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: -a */
+
+/* Effects: aborts if -a overflows */
+
+COMPILER_RT_ABI di_int
+__negvdi2(di_int a)
+{
+    const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT)-1);
+    if (a == MIN)
+        compilerrt_abort();
+    return -a;
+}
diff --git a/compiler-rt/lib/builtins/negvsi2.c b/compiler-rt/lib/builtins/negvsi2.c
new file mode 100644
index 0000000..b9e93fe
--- /dev/null
+++ b/compiler-rt/lib/builtins/negvsi2.c
@@ -0,0 +1,28 @@
+/* ===-- negvsi2.c - Implement __negvsi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negvsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: -a */
+
+/* Effects: aborts if -a overflows */
+
+COMPILER_RT_ABI si_int
+__negvsi2(si_int a)
+{
+    const si_int MIN = (si_int)1 << ((int)(sizeof(si_int) * CHAR_BIT)-1);
+    if (a == MIN)
+        compilerrt_abort();
+    return -a;
+}
diff --git a/compiler-rt/lib/builtins/negvti2.c b/compiler-rt/lib/builtins/negvti2.c
new file mode 100644
index 0000000..85f9f7d
--- /dev/null
+++ b/compiler-rt/lib/builtins/negvti2.c
@@ -0,0 +1,32 @@
+/*===-- negvti2.c - Implement __negvti2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ *This file implements __negvti2 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: -a */
+
+/* Effects: aborts if -a overflows */
+
+COMPILER_RT_ABI ti_int
+__negvti2(ti_int a)
+{
+    const ti_int MIN = (ti_int)1 << ((int)(sizeof(ti_int) * CHAR_BIT)-1);
+    if (a == MIN)
+        compilerrt_abort();
+    return -a;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/paritydi2.c b/compiler-rt/lib/builtins/paritydi2.c
new file mode 100644
index 0000000..8ea5ab4
--- /dev/null
+++ b/compiler-rt/lib/builtins/paritydi2.c
@@ -0,0 +1,25 @@
+/* ===-- paritydi2.c - Implement __paritydi2 -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __paritydi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: 1 if number of bits is odd else returns 0 */
+
+COMPILER_RT_ABI si_int
+__paritydi2(di_int a)
+{
+    dwords x;
+    x.all = a;
+    return __paritysi2(x.s.high ^ x.s.low);
+}
diff --git a/compiler-rt/lib/builtins/paritysi2.c b/compiler-rt/lib/builtins/paritysi2.c
new file mode 100644
index 0000000..5999846
--- /dev/null
+++ b/compiler-rt/lib/builtins/paritysi2.c
@@ -0,0 +1,27 @@
+/* ===-- paritysi2.c - Implement __paritysi2 -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __paritysi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: 1 if number of bits is odd else returns 0 */
+
+COMPILER_RT_ABI si_int
+__paritysi2(si_int a)
+{
+    su_int x = (su_int)a;
+    x ^= x >> 16;
+    x ^= x >> 8;
+    x ^= x >> 4;
+    return (0x6996 >> (x & 0xF)) & 1;
+}
diff --git a/compiler-rt/lib/builtins/parityti2.c b/compiler-rt/lib/builtins/parityti2.c
new file mode 100644
index 0000000..5a4fe49
--- /dev/null
+++ b/compiler-rt/lib/builtins/parityti2.c
@@ -0,0 +1,29 @@
+/* ===-- parityti2.c - Implement __parityti2 -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __parityti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: 1 if number of bits is odd else returns 0 */
+
+COMPILER_RT_ABI si_int
+__parityti2(ti_int a)
+{
+    twords x;
+    x.all = a;
+    return __paritydi2(x.s.high ^ x.s.low);
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/popcountdi2.c b/compiler-rt/lib/builtins/popcountdi2.c
new file mode 100644
index 0000000..5e8a62f
--- /dev/null
+++ b/compiler-rt/lib/builtins/popcountdi2.c
@@ -0,0 +1,36 @@
+/* ===-- popcountdi2.c - Implement __popcountdi2 ----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __popcountdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: count of 1 bits */
+
+COMPILER_RT_ABI si_int
+__popcountdi2(di_int a)
+{
+    du_int x2 = (du_int)a;
+    x2 = x2 - ((x2 >> 1) & 0x5555555555555555uLL);
+    /* Every 2 bits holds the sum of every pair of bits (32) */
+    x2 = ((x2 >> 2) & 0x3333333333333333uLL) + (x2 & 0x3333333333333333uLL);
+    /* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (16) */
+    x2 = (x2 + (x2 >> 4)) & 0x0F0F0F0F0F0F0F0FuLL;
+    /* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (8) */
+    su_int x = (su_int)(x2 + (x2 >> 32));
+    /* The lower 32 bits hold four 16 bit sums (5 significant bits). */
+    /*   Upper 32 bits are garbage */
+    x = x + (x >> 16);
+    /* The lower 16 bits hold two 32 bit sums (6 significant bits). */
+    /*   Upper 16 bits are garbage */
+    return (x + (x >> 8)) & 0x0000007F;  /* (7 significant bits) */
+}
diff --git a/compiler-rt/lib/builtins/popcountsi2.c b/compiler-rt/lib/builtins/popcountsi2.c
new file mode 100644
index 0000000..44544ff
--- /dev/null
+++ b/compiler-rt/lib/builtins/popcountsi2.c
@@ -0,0 +1,33 @@
+/* ===-- popcountsi2.c - Implement __popcountsi2 ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __popcountsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: count of 1 bits */
+
+COMPILER_RT_ABI si_int
+__popcountsi2(si_int a)
+{
+    su_int x = (su_int)a;
+    x = x - ((x >> 1) & 0x55555555);
+    /* Every 2 bits holds the sum of every pair of bits */
+    x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
+    /* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) */
+    x = (x + (x >> 4)) & 0x0F0F0F0F;
+    /* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) */
+    x = (x + (x >> 16));
+    /* The lower 16 bits hold two 8 bit sums (5 significant bits).*/
+    /*    Upper 16 bits are garbage */
+    return (x + (x >> 8)) & 0x0000003F;  /* (6 significant bits) */
+}
diff --git a/compiler-rt/lib/builtins/popcountti2.c b/compiler-rt/lib/builtins/popcountti2.c
new file mode 100644
index 0000000..7451bbb
--- /dev/null
+++ b/compiler-rt/lib/builtins/popcountti2.c
@@ -0,0 +1,44 @@
+/* ===-- popcountti2.c - Implement __popcountti2 ----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __popcountti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: count of 1 bits */
+
+COMPILER_RT_ABI si_int
+__popcountti2(ti_int a)
+{
+    tu_int x3 = (tu_int)a;
+    x3 = x3 - ((x3 >> 1) & (((tu_int)0x5555555555555555uLL << 64) |
+                                     0x5555555555555555uLL));
+    /* Every 2 bits holds the sum of every pair of bits (64) */
+    x3 = ((x3 >> 2) & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL))
+       + (x3 & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL));
+    /* Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (32) */
+    x3 = (x3 + (x3 >> 4))
+       & (((tu_int)0x0F0F0F0F0F0F0F0FuLL << 64) | 0x0F0F0F0F0F0F0F0FuLL);
+    /* Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (16) */
+    du_int x2 = (du_int)(x3 + (x3 >> 64));
+    /* Every 8 bits holds the sum of every 8-set of bits (5 significant bits) (8) */
+    su_int x = (su_int)(x2 + (x2 >> 32));
+    /* Every 8 bits holds the sum of every 8-set of bits (6 significant bits) (4) */
+    x = x + (x >> 16);
+    /* Every 8 bits holds the sum of every 8-set of bits (7 significant bits) (2) */
+    /* Upper 16 bits are garbage */
+    return (x + (x >> 8)) & 0xFF;  /* (8 significant bits) */
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/powidf2.c b/compiler-rt/lib/builtins/powidf2.c
new file mode 100644
index 0000000..ac13b17
--- /dev/null
+++ b/compiler-rt/lib/builtins/powidf2.c
@@ -0,0 +1,34 @@
+/* ===-- powidf2.cpp - Implement __powidf2 ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powidf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+COMPILER_RT_ABI double
+__powidf2(double a, si_int b)
+{
+    const int recip = b < 0;
+    double r = 1;
+    while (1)
+    {
+        if (b & 1)
+            r *= a;
+        b /= 2;
+        if (b == 0)
+            break;
+        a *= a;
+    }
+    return recip ? 1/r : r;
+}
diff --git a/compiler-rt/lib/builtins/powisf2.c b/compiler-rt/lib/builtins/powisf2.c
new file mode 100644
index 0000000..0c400ec
--- /dev/null
+++ b/compiler-rt/lib/builtins/powisf2.c
@@ -0,0 +1,34 @@
+/*===-- powisf2.cpp - Implement __powisf2 ---------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powisf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+COMPILER_RT_ABI float
+__powisf2(float a, si_int b)
+{
+    const int recip = b < 0;
+    float r = 1;
+    while (1)
+    {
+        if (b & 1)
+            r *= a;
+        b /= 2;
+        if (b == 0)
+            break;
+        a *= a;
+    }
+    return recip ? 1/r : r;
+}
diff --git a/compiler-rt/lib/builtins/powitf2.c b/compiler-rt/lib/builtins/powitf2.c
new file mode 100644
index 0000000..172f29f
--- /dev/null
+++ b/compiler-rt/lib/builtins/powitf2.c
@@ -0,0 +1,38 @@
+/* ===-- powitf2.cpp - Implement __powitf2 ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powitf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#if _ARCH_PPC
+
+/* Returns: a ^ b */
+
+COMPILER_RT_ABI long double
+__powitf2(long double a, si_int b)
+{
+    const int recip = b < 0;
+    long double r = 1;
+    while (1)
+    {
+        if (b & 1)
+            r *= a;
+        b /= 2;
+        if (b == 0)
+            break;
+        a *= a;
+    }
+    return recip ? 1/r : r;
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/powixf2.c b/compiler-rt/lib/builtins/powixf2.c
new file mode 100644
index 0000000..0fd96e5
--- /dev/null
+++ b/compiler-rt/lib/builtins/powixf2.c
@@ -0,0 +1,38 @@
+/* ===-- powixf2.cpp - Implement __powixf2 ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powixf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+COMPILER_RT_ABI long double
+__powixf2(long double a, si_int b)
+{
+    const int recip = b < 0;
+    long double r = 1;
+    while (1)
+    {
+        if (b & 1)
+            r *= a;
+        b /= 2;
+        if (b == 0)
+            break;
+        a *= a;
+    }
+    return recip ? 1/r : r;
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/ppc/DD.h b/compiler-rt/lib/builtins/ppc/DD.h
new file mode 100644
index 0000000..3e5f9e5
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/DD.h
@@ -0,0 +1,45 @@
+#ifndef COMPILERRT_DD_HEADER
+#define COMPILERRT_DD_HEADER
+
+#include "../int_lib.h"
+
+typedef union {
+	long double ld;
+	struct {
+		double hi;
+		double lo;
+	}s;
+} DD;
+
+typedef union { 
+	double d;
+	uint64_t x;
+} doublebits;
+
+#define LOWORDER(xy,xHi,xLo,yHi,yLo) \
+	(((((xHi)*(yHi) - (xy)) + (xHi)*(yLo)) + (xLo)*(yHi)) + (xLo)*(yLo))
+
+static __inline ALWAYS_INLINE double local_fabs(double x) {
+  doublebits result = {.d = x};
+  result.x &= UINT64_C(0x7fffffffffffffff);
+  return result.d;
+}
+
+static __inline ALWAYS_INLINE double high26bits(double x) {
+  doublebits result = {.d = x};
+  result.x &= UINT64_C(0xfffffffff8000000);
+  return result.d;
+}
+
+static __inline ALWAYS_INLINE int different_sign(double x, double y) {
+  doublebits xsignbit = {.d = x}, ysignbit = {.d = y};
+  int result = (int)(xsignbit.x >> 63) ^ (int)(ysignbit.x >> 63);
+  return result;
+}
+
+long double __gcc_qadd(long double, long double);
+long double __gcc_qsub(long double, long double);
+long double __gcc_qmul(long double, long double);
+long double __gcc_qdiv(long double, long double);
+
+#endif /* COMPILERRT_DD_HEADER */
diff --git a/compiler-rt/lib/builtins/ppc/Makefile.mk b/compiler-rt/lib/builtins/ppc/Makefile.mk
new file mode 100644
index 0000000..0adc623
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/Makefile.mk
@@ -0,0 +1,20 @@
+#===- lib/builtins/ppc/Makefile.mk -------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs := 
+OnlyArchs := ppc
+
+AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
+Implementation := Optimized
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard lib/*.h $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/ppc/divtc3.c b/compiler-rt/lib/builtins/ppc/divtc3.c
new file mode 100644
index 0000000..8ec41c5
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/divtc3.c
@@ -0,0 +1,91 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+#include "DD.h"
+#include "../int_math.h"
+
+#if !defined(CRT_INFINITY) && defined(HUGE_VAL)
+#define CRT_INFINITY HUGE_VAL
+#endif /* CRT_INFINITY */
+
+#define makeFinite(x) { \
+    (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
+    (x).s.lo = 0.0;                                                     \
+  }
+
+long double _Complex
+__divtc3(long double a, long double b, long double c, long double d)
+{
+	DD cDD = { .ld = c };
+	DD dDD = { .ld = d };
+	
+	int ilogbw = 0;
+	const double logbw = crt_logb(crt_fmax(crt_fabs(cDD.s.hi), crt_fabs(dDD.s.hi) ));
+	
+	if (crt_isfinite(logbw))
+	{
+		ilogbw = (int)logbw;
+		
+		cDD.s.hi = crt_scalbn(cDD.s.hi, -ilogbw);
+		cDD.s.lo = crt_scalbn(cDD.s.lo, -ilogbw);
+		dDD.s.hi = crt_scalbn(dDD.s.hi, -ilogbw);
+		dDD.s.lo = crt_scalbn(dDD.s.lo, -ilogbw);
+	}
+	
+	const long double denom = __gcc_qadd(__gcc_qmul(cDD.ld, cDD.ld), __gcc_qmul(dDD.ld, dDD.ld));
+	const long double realNumerator = __gcc_qadd(__gcc_qmul(a,cDD.ld), __gcc_qmul(b,dDD.ld));
+	const long double imagNumerator = __gcc_qsub(__gcc_qmul(b,cDD.ld), __gcc_qmul(a,dDD.ld));
+	
+	DD real = { .ld = __gcc_qdiv(realNumerator, denom) };
+	DD imag = { .ld = __gcc_qdiv(imagNumerator, denom) };
+	
+	real.s.hi = crt_scalbn(real.s.hi, -ilogbw);
+	real.s.lo = crt_scalbn(real.s.lo, -ilogbw);
+	imag.s.hi = crt_scalbn(imag.s.hi, -ilogbw);
+	imag.s.lo = crt_scalbn(imag.s.lo, -ilogbw);
+	
+	if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi))
+	{
+		DD aDD = { .ld = a };
+		DD bDD = { .ld = b };
+		DD rDD = { .ld = denom };
+		
+		if ((rDD.s.hi == 0.0) && (!crt_isnan(aDD.s.hi) ||
+                                          !crt_isnan(bDD.s.hi)))
+		{
+			real.s.hi = crt_copysign(CRT_INFINITY,cDD.s.hi) * aDD.s.hi;
+			real.s.lo = 0.0;
+			imag.s.hi = crt_copysign(CRT_INFINITY,cDD.s.hi) * bDD.s.hi;
+			imag.s.lo = 0.0;
+		}
+		
+		else if ((crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) &&
+                         crt_isfinite(cDD.s.hi) && crt_isfinite(dDD.s.hi))
+		{
+			makeFinite(aDD);
+			makeFinite(bDD);
+			real.s.hi = CRT_INFINITY * (aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi);
+			real.s.lo = 0.0;
+			imag.s.hi = CRT_INFINITY * (bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi);
+			imag.s.lo = 0.0;
+		}
+		
+		else if ((crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) &&
+                         crt_isfinite(aDD.s.hi) && crt_isfinite(bDD.s.hi))
+		{
+			makeFinite(cDD);
+			makeFinite(dDD);
+			real.s.hi = crt_copysign(0.0,(aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi));
+			real.s.lo = 0.0;
+			imag.s.hi = crt_copysign(0.0,(bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi));
+			imag.s.lo = 0.0;
+		}
+	}
+	
+	long double _Complex z;
+	__real__ z = real.ld;
+	__imag__ z = imag.ld;
+	
+	return z;
+}
diff --git a/compiler-rt/lib/builtins/ppc/fixtfdi.c b/compiler-rt/lib/builtins/ppc/fixtfdi.c
new file mode 100644
index 0000000..2c7c0f8
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/fixtfdi.c
@@ -0,0 +1,104 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* int64_t __fixunstfdi(long double x);
+ * This file implements the PowerPC 128-bit double-double -> int64_t conversion
+ */
+
+#include "DD.h"
+#include "../int_math.h"
+
+uint64_t __fixtfdi(long double input)
+{
+	const DD x = { .ld = input };
+	const doublebits hibits = { .d = x.s.hi };
+	
+	const uint32_t absHighWord = (uint32_t)(hibits.x >> 32) & UINT32_C(0x7fffffff);
+	const uint32_t absHighWordMinusOne = absHighWord - UINT32_C(0x3ff00000);
+	
+	/* If (1.0 - tiny) <= input < 0x1.0p63: */
+	if (UINT32_C(0x03f00000) > absHighWordMinusOne)
+	{
+		/* Do an unsigned conversion of the absolute value, then restore the sign. */
+		const int unbiasedHeadExponent = absHighWordMinusOne >> 20;
+		
+		int64_t result = hibits.x & INT64_C(0x000fffffffffffff); /* mantissa(hi) */
+		result |= INT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */
+		result <<= 10; /* mantissa(hi) with one zero preceding bit. */
+		
+		const int64_t hiNegationMask = ((int64_t)(hibits.x)) >> 63;
+		
+		/* If the tail is non-zero, we need to patch in the tail bits. */
+		if (0.0 != x.s.lo)
+		{
+			const doublebits lobits = { .d = x.s.lo };
+			int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
+			tailMantissa |= INT64_C(0x0010000000000000);
+			
+			/* At this point we have the mantissa of |tail| */
+			/* We need to negate it if head and tail have different signs. */
+			const int64_t loNegationMask = ((int64_t)(lobits.x)) >> 63;
+			const int64_t negationMask = loNegationMask ^ hiNegationMask;
+			tailMantissa = (tailMantissa ^ negationMask) - negationMask;
+			
+			/* Now we have the mantissa of tail as a signed 2s-complement integer */
+			
+			const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
+			
+			/* Shift the tail mantissa into the right position, accounting for the
+			 * bias of 10 that we shifted the head mantissa by.
+			 */ 
+			tailMantissa >>= (unbiasedHeadExponent - (biasedTailExponent - (1023 - 10)));
+			
+			result += tailMantissa;
+		}
+		
+		result >>= (62 - unbiasedHeadExponent);
+		
+		/* Restore the sign of the result and return */
+		result = (result ^ hiNegationMask) - hiNegationMask;
+		return result;
+		
+	}
+
+	/* Edge cases handled here: */
+	
+	/* |x| < 1, result is zero. */
+	if (1.0 > crt_fabs(x.s.hi))
+		return INT64_C(0);
+	
+	/* x very close to INT64_MIN, care must be taken to see which side we are on. */
+	if (x.s.hi == -0x1.0p63) {
+		
+		int64_t result = INT64_MIN;
+		
+		if (0.0 < x.s.lo)
+		{
+			/* If the tail is positive, the correct result is something other than INT64_MIN.
+			 * we'll need to figure out what it is.
+			 */
+
+			const doublebits lobits = { .d = x.s.lo };
+			int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
+			tailMantissa |= INT64_C(0x0010000000000000);
+			
+			/* Now we negate the tailMantissa */
+			tailMantissa = (tailMantissa ^ INT64_C(-1)) + INT64_C(1);
+			
+			/* And shift it by the appropriate amount */
+			const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
+			tailMantissa >>= 1075 - biasedTailExponent;
+			
+			result -= tailMantissa;
+		}
+		
+		return result;
+	}
+	
+	/* Signed overflows, infinities, and NaNs */
+	if (x.s.hi > 0.0)
+		return INT64_MAX;
+	else
+		return INT64_MIN;
+}
diff --git a/compiler-rt/lib/builtins/ppc/fixunstfdi.c b/compiler-rt/lib/builtins/ppc/fixunstfdi.c
new file mode 100644
index 0000000..5e6e2ce
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/fixunstfdi.c
@@ -0,0 +1,59 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* uint64_t __fixunstfdi(long double x); */
+/* This file implements the PowerPC 128-bit double-double -> uint64_t conversion */
+
+#include "DD.h"
+
+uint64_t __fixunstfdi(long double input)
+{
+	const DD x = { .ld = input };
+	const doublebits hibits = { .d = x.s.hi };
+	
+	const uint32_t highWordMinusOne = (uint32_t)(hibits.x >> 32) - UINT32_C(0x3ff00000);
+	
+	/* If (1.0 - tiny) <= input < 0x1.0p64: */
+	if (UINT32_C(0x04000000) > highWordMinusOne)
+	{
+		const int unbiasedHeadExponent = highWordMinusOne >> 20;
+		
+		uint64_t result = hibits.x & UINT64_C(0x000fffffffffffff); /* mantissa(hi) */
+		result |= UINT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */
+		result <<= 11; /* mantissa(hi) left aligned in the int64 field. */
+		
+		/* If the tail is non-zero, we need to patch in the tail bits. */
+		if (0.0 != x.s.lo)
+		{
+			const doublebits lobits = { .d = x.s.lo };
+			int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
+			tailMantissa |= INT64_C(0x0010000000000000);
+			
+			/* At this point we have the mantissa of |tail| */
+			
+			const int64_t negationMask = ((int64_t)(lobits.x)) >> 63;
+			tailMantissa = (tailMantissa ^ negationMask) - negationMask;
+			
+			/* Now we have the mantissa of tail as a signed 2s-complement integer */
+			
+			const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
+			
+			/* Shift the tail mantissa into the right position, accounting for the
+			 * bias of 11 that we shifted the head mantissa by.
+			 */
+			tailMantissa >>= (unbiasedHeadExponent - (biasedTailExponent - (1023 - 11)));
+			
+			result += tailMantissa;
+		}
+		
+		result >>= (63 - unbiasedHeadExponent);
+		return result;
+	}
+	
+	/* Edge cases are handled here, with saturation. */
+	if (1.0 > x.s.hi)
+		return UINT64_C(0);
+	else
+		return UINT64_MAX;
+}
diff --git a/compiler-rt/lib/builtins/ppc/floatditf.c b/compiler-rt/lib/builtins/ppc/floatditf.c
new file mode 100644
index 0000000..beabdd0
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/floatditf.c
@@ -0,0 +1,36 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* long double __floatditf(long long x); */
+/* This file implements the PowerPC long long -> long double conversion */
+
+#include "DD.h"
+
+long double __floatditf(int64_t a) {
+	
+	static const double twop32 = 0x1.0p32;
+	static const double twop52 = 0x1.0p52;
+	
+	doublebits low  = { .d = twop52 };
+	low.x |= a & UINT64_C(0x00000000ffffffff);	/* 0x1.0p52 + low 32 bits of a. */
+	
+	const double high_addend = (double)((int32_t)(a >> 32))*twop32 - twop52;
+	
+	/* At this point, we have two double precision numbers
+	 * high_addend and low.d, and we wish to return their sum
+	 * as a canonicalized long double:
+	 */
+
+	/* This implementation sets the inexact flag spuriously.
+	 * This could be avoided, but at some substantial cost.
+	*/
+
+	DD result;
+	
+	result.s.hi = high_addend + low.d;
+	result.s.lo = (high_addend - result.s.hi) + low.d;
+	
+	return result.ld;
+	
+}
diff --git a/compiler-rt/lib/builtins/ppc/floatunditf.c b/compiler-rt/lib/builtins/ppc/floatunditf.c
new file mode 100644
index 0000000..b12e1e7
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/floatunditf.c
@@ -0,0 +1,41 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* long double __floatunditf(unsigned long long x); */
+/* This file implements the PowerPC unsigned long long -> long double conversion */
+
+#include "DD.h"
+
+long double __floatunditf(uint64_t a) {
+	
+	/* Begins with an exact copy of the code from __floatundidf */
+	
+	static const double twop52 = 0x1.0p52;
+	static const double twop84 = 0x1.0p84;
+	static const double twop84_plus_twop52 = 0x1.00000001p84;
+	
+	doublebits high = { .d = twop84 };
+	doublebits low  = { .d = twop52 };
+	
+	high.x |= a >> 32;							/* 0x1.0p84 + high 32 bits of a */
+	low.x |= a & UINT64_C(0x00000000ffffffff);	/* 0x1.0p52 + low 32 bits of a */
+	
+	const double high_addend = high.d - twop84_plus_twop52;
+	
+	/* At this point, we have two double precision numbers
+	 * high_addend and low.d, and we wish to return their sum
+	 * as a canonicalized long double:
+	 */
+
+	/* This implementation sets the inexact flag spuriously. */
+	/* This could be avoided, but at some substantial cost. */
+	
+	DD result;
+	
+	result.s.hi = high_addend + low.d;
+	result.s.lo = (high_addend - result.s.hi) + low.d;
+	
+	return result.ld;
+	
+}
diff --git a/compiler-rt/lib/builtins/ppc/gcc_qadd.c b/compiler-rt/lib/builtins/ppc/gcc_qadd.c
new file mode 100644
index 0000000..32e16e9
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/gcc_qadd.c
@@ -0,0 +1,76 @@
+/* This file is distributed under the University of Illinois Open Source
+ *  License. See LICENSE.TXT for details.
+ */
+
+/* long double __gcc_qadd(long double x, long double y);
+ * This file implements the PowerPC 128-bit double-double add operation.
+ * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
+ */
+
+#include "DD.h"
+
+long double __gcc_qadd(long double x, long double y)
+{
+	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+	
+	DD dst = { .ld = x }, src = { .ld = y };
+	
+	register double A = dst.s.hi, a = dst.s.lo,
+					B = src.s.hi, b = src.s.lo;
+	
+	/* If both operands are zero: */
+	if ((A == 0.0) && (B == 0.0)) {
+		dst.s.hi = A + B;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	/* If either operand is NaN or infinity: */
+	const doublebits abits = { .d = A };
+	const doublebits bbits = { .d = B };
+	if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
+		(((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
+		dst.s.hi = A + B;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	/* If the computation overflows: */
+	/* This may be playing things a little bit fast and loose, but it will do for a start. */
+	const double testForOverflow = A + (B + (a + b));
+	const doublebits testbits = { .d = testForOverflow };
+	if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
+		dst.s.hi = testForOverflow;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	double H, h;
+	double T, t;
+	double W, w;
+	double Y;
+	
+	H = B + (A - (A + B));
+	T = b + (a - (a + b));
+	h = A + (B - (A + B));
+	t = a + (b - (a + b));
+	
+	if (local_fabs(A) <= local_fabs(B))
+		w = (a + b) + h;
+	else
+		w = (a + b) + H;
+	
+	W = (A + B) + w;
+	Y = (A + B) - W;
+	Y += w;
+	
+	if (local_fabs(a) <= local_fabs(b))
+		w = t + Y;
+	else
+		w = T + Y;
+	
+	dst.s.hi = Y = W + w;
+	dst.s.lo = (W - Y) + w;
+	
+	return dst.ld;
+}
diff --git a/compiler-rt/lib/builtins/ppc/gcc_qdiv.c b/compiler-rt/lib/builtins/ppc/gcc_qdiv.c
new file mode 100644
index 0000000..70aa00b
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/gcc_qdiv.c
@@ -0,0 +1,55 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* long double __gcc_qdiv(long double x, long double y);
+ * This file implements the PowerPC 128-bit double-double division operation.
+ * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
+ */
+
+#include "DD.h"
+
+long double __gcc_qdiv(long double a, long double b)
+{	
+	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+	DD dst = { .ld = a }, src = { .ld = b };
+	
+	register double x = dst.s.hi, x1 = dst.s.lo,
+					y = src.s.hi, y1 = src.s.lo;
+	
+    double yHi, yLo, qHi, qLo;
+    double yq, tmp, q;
+	
+    q = x / y;
+	
+	/* Detect special cases */
+	if (q == 0.0) {
+		dst.s.hi = q;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	const doublebits qBits = { .d = q };
+	if (((uint32_t)(qBits.x >> 32) & infinityHi) == infinityHi) {
+		dst.s.hi = q;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+    yHi = high26bits(y);
+    qHi = high26bits(q);
+	
+    yq = y * q;
+    yLo = y - yHi;
+    qLo = q - qHi;
+	
+    tmp = LOWORDER(yq, yHi, yLo, qHi, qLo);
+    tmp = (x - yq) - tmp;
+    tmp = ((tmp + x1) - y1 * q) / y;
+    x = q + tmp;
+	
+    dst.s.lo = (q - x) + tmp;
+    dst.s.hi = x;
+	
+    return dst.ld;
+}
diff --git a/compiler-rt/lib/builtins/ppc/gcc_qmul.c b/compiler-rt/lib/builtins/ppc/gcc_qmul.c
new file mode 100644
index 0000000..fb4c516
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/gcc_qmul.c
@@ -0,0 +1,53 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* long double __gcc_qmul(long double x, long double y);
+ * This file implements the PowerPC 128-bit double-double multiply operation.
+ * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
+ */
+
+#include "DD.h"
+
+long double __gcc_qmul(long double x, long double y)
+{	
+	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+	DD dst = { .ld = x }, src = { .ld = y };
+	
+	register double A = dst.s.hi, a = dst.s.lo,
+					B = src.s.hi, b = src.s.lo;
+	
+	double aHi, aLo, bHi, bLo;
+    double ab, tmp, tau;
+	
+	ab = A * B;
+	
+	/* Detect special cases */
+	if (ab == 0.0) {
+		dst.s.hi = ab;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	const doublebits abBits = { .d = ab };
+	if (((uint32_t)(abBits.x >> 32) & infinityHi) == infinityHi) {
+		dst.s.hi = ab;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	/* Generic cases handled here. */
+    aHi = high26bits(A);
+    bHi = high26bits(B);
+    aLo = A - aHi;
+    bLo = B - bHi;
+	
+    tmp = LOWORDER(ab, aHi, aLo, bHi, bLo);
+    tmp += (A * b + a * B);
+    tau = ab + tmp;
+	
+    dst.s.lo = (ab - tau) + tmp;
+    dst.s.hi = tau;
+	
+    return dst.ld;
+}
diff --git a/compiler-rt/lib/builtins/ppc/gcc_qsub.c b/compiler-rt/lib/builtins/ppc/gcc_qsub.c
new file mode 100644
index 0000000..c092e24
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/gcc_qsub.c
@@ -0,0 +1,76 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* long double __gcc_qsub(long double x, long double y);
+ * This file implements the PowerPC 128-bit double-double add operation.
+ * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
+ */
+
+#include "DD.h"
+
+long double __gcc_qsub(long double x, long double y)
+{
+	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+	
+	DD dst = { .ld = x }, src = { .ld = y };
+	
+	register double A =  dst.s.hi, a =  dst.s.lo,
+					B = -src.s.hi, b = -src.s.lo;
+	
+	/* If both operands are zero: */
+	if ((A == 0.0) && (B == 0.0)) {
+		dst.s.hi = A + B;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	/* If either operand is NaN or infinity: */
+	const doublebits abits = { .d = A };
+	const doublebits bbits = { .d = B };
+	if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
+		(((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
+		dst.s.hi = A + B;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	/* If the computation overflows: */
+	/* This may be playing things a little bit fast and loose, but it will do for a start. */
+	const double testForOverflow = A + (B + (a + b));
+	const doublebits testbits = { .d = testForOverflow };
+	if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
+		dst.s.hi = testForOverflow;
+		dst.s.lo = 0.0;
+		return dst.ld;
+	}
+	
+	double H, h;
+	double T, t;
+	double W, w;
+	double Y;
+	
+	H = B + (A - (A + B));
+	T = b + (a - (a + b));
+	h = A + (B - (A + B));
+	t = a + (b - (a + b));
+	
+	if (local_fabs(A) <= local_fabs(B))
+		w = (a + b) + h;
+	else
+		w = (a + b) + H;
+	
+	W = (A + B) + w;
+	Y = (A + B) - W;
+	Y += w;
+	
+	if (local_fabs(a) <= local_fabs(b))
+		w = t + Y;
+	else
+		w = T + Y;
+	
+	dst.s.hi = Y = W + w;
+	dst.s.lo = (W - Y) + w;
+	
+	return dst.ld;
+}
diff --git a/compiler-rt/lib/builtins/ppc/multc3.c b/compiler-rt/lib/builtins/ppc/multc3.c
new file mode 100644
index 0000000..9dd79c9
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/multc3.c
@@ -0,0 +1,90 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+#include "DD.h"
+#include "../int_math.h"
+
+#define makeFinite(x) { \
+    (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
+    (x).s.lo = 0.0;                                                     \
+  }
+
+#define zeroNaN(x) { \
+    if (crt_isnan((x).s.hi)) {                                          \
+      (x).s.hi = crt_copysign(0.0, (x).s.hi);                     \
+      (x).s.lo = 0.0;                                                   \
+    }                                                                   \
+  }
+
+long double _Complex
+__multc3(long double a, long double b, long double c, long double d)
+{
+	long double ac = __gcc_qmul(a,c);
+	long double bd = __gcc_qmul(b,d);
+	long double ad = __gcc_qmul(a,d);
+	long double bc = __gcc_qmul(b,c);
+	
+	DD real = { .ld = __gcc_qsub(ac,bd) };
+	DD imag = { .ld = __gcc_qadd(ad,bc) };
+	
+	if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi))
+	{
+		int recalc = 0;
+		
+		DD aDD = { .ld = a };
+		DD bDD = { .ld = b };
+		DD cDD = { .ld = c };
+		DD dDD = { .ld = d };
+		
+		if (crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi))
+		{
+			makeFinite(aDD);
+			makeFinite(bDD);
+			zeroNaN(cDD);
+			zeroNaN(dDD);
+			recalc = 1;
+		}
+		
+		if (crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi))
+		{
+			makeFinite(cDD);
+			makeFinite(dDD);
+			zeroNaN(aDD);
+			zeroNaN(bDD);
+			recalc = 1;
+		}
+		
+		if (!recalc)
+		{
+			DD acDD = { .ld = ac };
+			DD bdDD = { .ld = bd };
+			DD adDD = { .ld = ad };
+			DD bcDD = { .ld = bc };
+			
+			if (crt_isinf(acDD.s.hi) || crt_isinf(bdDD.s.hi) ||
+                            crt_isinf(adDD.s.hi) || crt_isinf(bcDD.s.hi))
+			{
+				zeroNaN(aDD);
+				zeroNaN(bDD);
+				zeroNaN(cDD);
+				zeroNaN(dDD);
+				recalc = 1;
+			}
+		}
+		
+		if (recalc)
+		{
+			real.s.hi = CRT_INFINITY * (aDD.s.hi*cDD.s.hi - bDD.s.hi*dDD.s.hi);
+			real.s.lo = 0.0;
+			imag.s.hi = CRT_INFINITY * (aDD.s.hi*dDD.s.hi + bDD.s.hi*cDD.s.hi);
+			imag.s.lo = 0.0;
+		}
+	}
+	
+	long double _Complex z;
+	__real__ z = real.ld;
+	__imag__ z = imag.ld;
+	
+	return z;
+}
diff --git a/compiler-rt/lib/builtins/ppc/restFP.S b/compiler-rt/lib/builtins/ppc/restFP.S
new file mode 100644
index 0000000..9503289
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/restFP.S
@@ -0,0 +1,43 @@
+//===-- restFP.S - Implement restFP ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// Helper function used by compiler to restore ppc floating point registers at
+// the end of the function epilog.  This function returns to the address
+// in the LR slot.  So a function epilog must branch (b) not branch and link
+// (bl) to this function.
+// If the compiler wants to restore f27..f31, it does a "b restFP+52"
+//
+// This function should never be exported by a shared library.  Each linkage
+// unit carries its own copy of this function.
+//
+DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(restFP)
+        lfd    f14,-144(r1)
+        lfd    f15,-136(r1)
+        lfd    f16,-128(r1)
+        lfd    f17,-120(r1)
+        lfd    f18,-112(r1)
+        lfd    f19,-104(r1)
+        lfd    f20,-96(r1)
+        lfd    f21,-88(r1)
+        lfd    f22,-80(r1)
+        lfd    f23,-72(r1)
+        lfd    f24,-64(r1)
+        lfd    f25,-56(r1)
+        lfd    f26,-48(r1)
+        lfd    f27,-40(r1)
+        lfd    f28,-32(r1)
+        lfd    f29,-24(r1)
+        lfd    f30,-16(r1)
+        lfd    f31,-8(r1)
+        lwz     r0,8(r1)
+        mtlr	r0
+        blr
diff --git a/compiler-rt/lib/builtins/ppc/saveFP.S b/compiler-rt/lib/builtins/ppc/saveFP.S
new file mode 100644
index 0000000..72bd459
--- /dev/null
+++ b/compiler-rt/lib/builtins/ppc/saveFP.S
@@ -0,0 +1,40 @@
+//===-- saveFP.S - Implement saveFP ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// Helper function used by compiler to save ppc floating point registers in
+// function prologs.  This routines also saves r0 in the LR slot.
+// If the compiler wants to save f27..f31, it does a "bl saveFP+52"
+//
+// This function should never be exported by a shared library.  Each linkage
+// unit carries its own copy of this function.
+//
+DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(saveFP)
+	stfd    f14,-144(r1)
+        stfd    f15,-136(r1)
+        stfd    f16,-128(r1)
+        stfd    f17,-120(r1)
+        stfd    f18,-112(r1)
+        stfd    f19,-104(r1)
+        stfd    f20,-96(r1)
+        stfd    f21,-88(r1)
+        stfd    f22,-80(r1)
+        stfd    f23,-72(r1)
+        stfd    f24,-64(r1)
+        stfd    f25,-56(r1)
+        stfd    f26,-48(r1)
+        stfd    f27,-40(r1)
+        stfd    f28,-32(r1)
+        stfd    f29,-24(r1)
+        stfd    f30,-16(r1)
+        stfd    f31,-8(r1)
+        stw      r0,8(r1)
+        blr
diff --git a/compiler-rt/lib/builtins/subdf3.c b/compiler-rt/lib/builtins/subdf3.c
new file mode 100644
index 0000000..7a79e5e
--- /dev/null
+++ b/compiler-rt/lib/builtins/subdf3.c
@@ -0,0 +1,25 @@
+//===-- lib/adddf3.c - Double-precision subtraction ---------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements double-precision soft-float subtraction with the
+// IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define DOUBLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(dsub, subdf3)
+
+// Subtraction; flip the sign bit of b and add.
+COMPILER_RT_ABI fp_t
+__subdf3(fp_t a, fp_t b) {
+    return __adddf3(a, fromRep(toRep(b) ^ signBit));
+}
+
diff --git a/compiler-rt/lib/builtins/subsf3.c b/compiler-rt/lib/builtins/subsf3.c
new file mode 100644
index 0000000..c3b8514
--- /dev/null
+++ b/compiler-rt/lib/builtins/subsf3.c
@@ -0,0 +1,25 @@
+//===-- lib/subsf3.c - Single-precision subtraction ---------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements single-precision soft-float subtraction with the
+// IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define SINGLE_PRECISION
+#include "fp_lib.h"
+
+ARM_EABI_FNALIAS(fsub, subsf3)
+
+// Subtraction; flip the sign bit of b and add.
+COMPILER_RT_ABI fp_t
+__subsf3(fp_t a, fp_t b) {
+    return __addsf3(a, fromRep(toRep(b) ^ signBit));
+}
+
diff --git a/compiler-rt/lib/builtins/subtf3.c b/compiler-rt/lib/builtins/subtf3.c
new file mode 100644
index 0000000..609b816
--- /dev/null
+++ b/compiler-rt/lib/builtins/subtf3.c
@@ -0,0 +1,27 @@
+//===-- lib/subtf3.c - Quad-precision subtraction -----------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements quad-precision soft-float subtraction with the
+// IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b);
+
+// Subtraction; flip the sign bit of b and add.
+COMPILER_RT_ABI fp_t
+__subtf3(fp_t a, fp_t b) {
+    return __addtf3(a, fromRep(toRep(b) ^ signBit));
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/subvdi3.c b/compiler-rt/lib/builtins/subvdi3.c
new file mode 100644
index 0000000..71fc70f
--- /dev/null
+++ b/compiler-rt/lib/builtins/subvdi3.c
@@ -0,0 +1,36 @@
+/* ===-- subvdi3.c - Implement __subvdi3 -----------------------------------===
+ *
+ *                The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __subvdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a - b */
+
+/* Effects: aborts if a - b overflows */
+
+COMPILER_RT_ABI di_int
+__subvdi3(di_int a, di_int b)
+{
+    di_int s = (du_int) a - (du_int) b;
+    if (b >= 0)
+    {
+        if (s > a)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (s <= a)
+            compilerrt_abort();
+    }
+    return s;
+}
diff --git a/compiler-rt/lib/builtins/subvsi3.c b/compiler-rt/lib/builtins/subvsi3.c
new file mode 100644
index 0000000..e6c0fb6
--- /dev/null
+++ b/compiler-rt/lib/builtins/subvsi3.c
@@ -0,0 +1,36 @@
+/* ===-- subvsi3.c - Implement __subvsi3 -----------------------------------===
+ *
+ *                The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __subvsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a - b */
+
+/* Effects: aborts if a - b overflows */
+
+COMPILER_RT_ABI si_int
+__subvsi3(si_int a, si_int b)
+{
+    si_int s = (su_int) a - (su_int) b;
+    if (b >= 0)
+    {
+        if (s > a)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (s <= a)
+            compilerrt_abort();
+    }
+    return s;
+}
diff --git a/compiler-rt/lib/builtins/subvti3.c b/compiler-rt/lib/builtins/subvti3.c
new file mode 100644
index 0000000..a6804d2
--- /dev/null
+++ b/compiler-rt/lib/builtins/subvti3.c
@@ -0,0 +1,40 @@
+/* ===-- subvti3.c - Implement __subvti3 -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __subvti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a - b */
+
+/* Effects: aborts if a - b overflows */
+
+COMPILER_RT_ABI ti_int
+__subvti3(ti_int a, ti_int b)
+{
+    ti_int s = (tu_int) a - (tu_int) b;
+    if (b >= 0)
+    {
+        if (s > a)
+            compilerrt_abort();
+    }
+    else
+    {
+        if (s <= a)
+            compilerrt_abort();
+    }
+    return s;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/trampoline_setup.c b/compiler-rt/lib/builtins/trampoline_setup.c
new file mode 100644
index 0000000..25b627a
--- /dev/null
+++ b/compiler-rt/lib/builtins/trampoline_setup.c
@@ -0,0 +1,48 @@
+/* ===----- trampoline_setup.c - Implement __trampoline_setup -------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+extern void __clear_cache(void* start, void* end);
+
+/*
+ * The ppc compiler generates calls to __trampoline_setup() when creating 
+ * trampoline functions on the stack for use with nested functions.
+ * This function creates a custom 40-byte trampoline function on the stack 
+ * which loads r11 with a pointer to the outer function's locals
+ * and then jumps to the target nested function.
+ */
+
+#if __ppc__ && !defined(__powerpc64__)
+COMPILER_RT_ABI void
+__trampoline_setup(uint32_t* trampOnStack, int trampSizeAllocated, 
+                   const void* realFunc, void* localsPtr)
+{
+    /* should never happen, but if compiler did not allocate */
+    /* enough space on stack for the trampoline, abort */
+    if ( trampSizeAllocated < 40 )
+        compilerrt_abort();
+    
+    /* create trampoline */
+    trampOnStack[0] = 0x7c0802a6;    /* mflr r0 */
+    trampOnStack[1] = 0x4800000d;    /* bl Lbase */
+    trampOnStack[2] = (uint32_t)realFunc;
+    trampOnStack[3] = (uint32_t)localsPtr;
+    trampOnStack[4] = 0x7d6802a6;    /* Lbase: mflr r11 */
+    trampOnStack[5] = 0x818b0000;    /* lwz    r12,0(r11) */
+    trampOnStack[6] = 0x7c0803a6;    /* mtlr r0 */
+    trampOnStack[7] = 0x7d8903a6;    /* mtctr r12 */
+    trampOnStack[8] = 0x816b0004;    /* lwz    r11,4(r11) */
+    trampOnStack[9] = 0x4e800420;    /* bctr */
+    
+    /* clear instruction cache */
+    __clear_cache(trampOnStack, &trampOnStack[10]);
+}
+#endif /* __ppc__ && !defined(__powerpc64__) */
diff --git a/compiler-rt/lib/builtins/truncdfhf2.c b/compiler-rt/lib/builtins/truncdfhf2.c
new file mode 100644
index 0000000..17195cd
--- /dev/null
+++ b/compiler-rt/lib/builtins/truncdfhf2.c
@@ -0,0 +1,18 @@
+//===-- lib/truncdfhf2.c - double -> half conversion --------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define SRC_DOUBLE
+#define DST_HALF
+#include "fp_trunc_impl.inc"
+
+ARM_EABI_FNALIAS(d2h, truncdfhf2)
+
+COMPILER_RT_ABI uint16_t __truncdfhf2(double a) {
+    return __truncXfYf2__(a);
+}
diff --git a/compiler-rt/lib/builtins/truncdfsf2.c b/compiler-rt/lib/builtins/truncdfsf2.c
new file mode 100644
index 0000000..46ec11d
--- /dev/null
+++ b/compiler-rt/lib/builtins/truncdfsf2.c
@@ -0,0 +1,18 @@
+//===-- lib/truncdfsf2.c - double -> single conversion ------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define SRC_DOUBLE
+#define DST_SINGLE
+#include "fp_trunc_impl.inc"
+
+ARM_EABI_FNALIAS(d2f, truncdfsf2)
+
+COMPILER_RT_ABI float __truncdfsf2(double a) {
+    return __truncXfYf2__(a);
+}
diff --git a/compiler-rt/lib/builtins/truncsfhf2.c b/compiler-rt/lib/builtins/truncsfhf2.c
new file mode 100644
index 0000000..9d61895
--- /dev/null
+++ b/compiler-rt/lib/builtins/truncsfhf2.c
@@ -0,0 +1,24 @@
+//===-- lib/truncsfhf2.c - single -> half conversion --------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define SRC_SINGLE
+#define DST_HALF
+#include "fp_trunc_impl.inc"
+
+ARM_EABI_FNALIAS(f2h, truncsfhf2)
+
+// Use a forwarding definition and noinline to implement a poor man's alias,
+// as there isn't a good cross-platform way of defining one.
+COMPILER_RT_ABI NOINLINE uint16_t __truncsfhf2(float a) {
+    return __truncXfYf2__(a);
+}
+
+COMPILER_RT_ABI uint16_t __gnu_f2h_ieee(float a) {
+    return __truncsfhf2(a);
+}
diff --git a/compiler-rt/lib/builtins/trunctfdf2.c b/compiler-rt/lib/builtins/trunctfdf2.c
new file mode 100644
index 0000000..741a71b
--- /dev/null
+++ b/compiler-rt/lib/builtins/trunctfdf2.c
@@ -0,0 +1,22 @@
+//===-- lib/truncdfsf2.c - quad -> double conversion --------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#define SRC_QUAD
+#define DST_DOUBLE
+#include "fp_trunc_impl.inc"
+
+COMPILER_RT_ABI double __trunctfdf2(long double a) {
+    return __truncXfYf2__(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/trunctfsf2.c b/compiler-rt/lib/builtins/trunctfsf2.c
new file mode 100644
index 0000000..de96c1d
--- /dev/null
+++ b/compiler-rt/lib/builtins/trunctfsf2.c
@@ -0,0 +1,22 @@
+//===-- lib/trunctfsf2.c - quad -> single conversion --------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#define SRC_QUAD
+#define DST_SINGLE
+#include "fp_trunc_impl.inc"
+
+COMPILER_RT_ABI float __trunctfsf2(long double a) {
+    return __truncXfYf2__(a);
+}
+
+#endif
diff --git a/compiler-rt/lib/builtins/ucmpdi2.c b/compiler-rt/lib/builtins/ucmpdi2.c
new file mode 100644
index 0000000..40af236
--- /dev/null
+++ b/compiler-rt/lib/builtins/ucmpdi2.c
@@ -0,0 +1,51 @@
+/* ===-- ucmpdi2.c - Implement __ucmpdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ucmpdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns:  if (a <  b) returns 0
+ *           if (a == b) returns 1
+ *           if (a >  b) returns 2
+ */
+
+COMPILER_RT_ABI si_int
+__ucmpdi2(du_int a, du_int b)
+{
+    udwords x;
+    x.all = a;
+    udwords y;
+    y.all = b;
+    if (x.s.high < y.s.high)
+        return 0;
+    if (x.s.high > y.s.high)
+        return 2;
+    if (x.s.low < y.s.low)
+        return 0;
+    if (x.s.low > y.s.low)
+        return 2;
+    return 1;
+}
+
+#ifdef __ARM_EABI__
+/* Returns: if (a <  b) returns -1
+*           if (a == b) returns  0
+*           if (a >  b) returns  1
+*/
+COMPILER_RT_ABI si_int
+__aeabi_ulcmp(di_int a, di_int b)
+{
+	return __ucmpdi2(a, b) - 1;
+}
+#endif
+
diff --git a/compiler-rt/lib/builtins/ucmpti2.c b/compiler-rt/lib/builtins/ucmpti2.c
new file mode 100644
index 0000000..bda8083
--- /dev/null
+++ b/compiler-rt/lib/builtins/ucmpti2.c
@@ -0,0 +1,42 @@
+/* ===-- ucmpti2.c - Implement __ucmpti2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ucmpti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns:  if (a <  b) returns 0
+ *           if (a == b) returns 1
+ *           if (a >  b) returns 2
+ */
+
+COMPILER_RT_ABI si_int
+__ucmpti2(tu_int a, tu_int b)
+{
+    utwords x;
+    x.all = a;
+    utwords y;
+    y.all = b;
+    if (x.s.high < y.s.high)
+        return 0;
+    if (x.s.high > y.s.high)
+        return 2;
+    if (x.s.low < y.s.low)
+        return 0;
+    if (x.s.low > y.s.low)
+        return 2;
+    return 1;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/udivdi3.c b/compiler-rt/lib/builtins/udivdi3.c
new file mode 100644
index 0000000..dc68e15
--- /dev/null
+++ b/compiler-rt/lib/builtins/udivdi3.c
@@ -0,0 +1,23 @@
+/* ===-- udivdi3.c - Implement __udivdi3 -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b */
+
+COMPILER_RT_ABI du_int
+__udivdi3(du_int a, du_int b)
+{
+    return __udivmoddi4(a, b, 0);
+}
diff --git a/compiler-rt/lib/builtins/udivmoddi4.c b/compiler-rt/lib/builtins/udivmoddi4.c
new file mode 100644
index 0000000..0c8b4ff
--- /dev/null
+++ b/compiler-rt/lib/builtins/udivmoddi4.c
@@ -0,0 +1,231 @@
+/* ===-- udivmoddi4.c - Implement __udivmoddi4 -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivmoddi4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Effects: if rem != 0, *rem = a % b
+ * Returns: a / b
+ */
+
+/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
+
+COMPILER_RT_ABI du_int
+__udivmoddi4(du_int a, du_int b, du_int* rem)
+{
+    const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;
+    const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT;
+    udwords n;
+    n.all = a;
+    udwords d;
+    d.all = b;
+    udwords q;
+    udwords r;
+    unsigned sr;
+    /* special cases, X is unknown, K != 0 */
+    if (n.s.high == 0)
+    {
+        if (d.s.high == 0)
+        {
+            /* 0 X
+             * ---
+             * 0 X
+             */
+            if (rem)
+                *rem = n.s.low % d.s.low;
+            return n.s.low / d.s.low;
+        }
+        /* 0 X
+         * ---
+         * K X
+         */
+        if (rem)
+            *rem = n.s.low;
+        return 0;
+    }
+    /* n.s.high != 0 */
+    if (d.s.low == 0)
+    {
+        if (d.s.high == 0)
+        {
+            /* K X
+             * ---
+             * 0 0
+             */ 
+            if (rem)
+                *rem = n.s.high % d.s.low;
+            return n.s.high / d.s.low;
+        }
+        /* d.s.high != 0 */
+        if (n.s.low == 0)
+        {
+            /* K 0
+             * ---
+             * K 0
+             */
+            if (rem)
+            {
+                r.s.high = n.s.high % d.s.high;
+                r.s.low = 0;
+                *rem = r.all;
+            }
+            return n.s.high / d.s.high;
+        }
+        /* K K
+         * ---
+         * K 0
+         */
+        if ((d.s.high & (d.s.high - 1)) == 0)     /* if d is a power of 2 */
+        {
+            if (rem)
+            {
+                r.s.low = n.s.low;
+                r.s.high = n.s.high & (d.s.high - 1);
+                *rem = r.all;
+            }
+            return n.s.high >> __builtin_ctz(d.s.high);
+        }
+        /* K K
+         * ---
+         * K 0
+         */
+        sr = __builtin_clz(d.s.high) - __builtin_clz(n.s.high);
+        /* 0 <= sr <= n_uword_bits - 2 or sr large */
+        if (sr > n_uword_bits - 2)
+        {
+           if (rem)
+                *rem = n.all;
+            return 0;
+        }
+        ++sr;
+        /* 1 <= sr <= n_uword_bits - 1 */
+        /* q.all = n.all << (n_udword_bits - sr); */
+        q.s.low = 0;
+        q.s.high = n.s.low << (n_uword_bits - sr);
+        /* r.all = n.all >> sr; */
+        r.s.high = n.s.high >> sr;
+        r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
+    }
+    else  /* d.s.low != 0 */
+    {
+        if (d.s.high == 0)
+        {
+            /* K X
+             * ---
+             * 0 K
+             */
+            if ((d.s.low & (d.s.low - 1)) == 0)     /* if d is a power of 2 */
+            {
+                if (rem)
+                    *rem = n.s.low & (d.s.low - 1);
+                if (d.s.low == 1)
+                    return n.all;
+                sr = __builtin_ctz(d.s.low);
+                q.s.high = n.s.high >> sr;
+                q.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
+                return q.all;
+            }
+            /* K X
+             * ---
+             * 0 K
+             */
+            sr = 1 + n_uword_bits + __builtin_clz(d.s.low) - __builtin_clz(n.s.high);
+            /* 2 <= sr <= n_udword_bits - 1
+             * q.all = n.all << (n_udword_bits - sr);
+             * r.all = n.all >> sr;
+             */
+            if (sr == n_uword_bits)
+            {
+                q.s.low = 0;
+                q.s.high = n.s.low;
+                r.s.high = 0;
+                r.s.low = n.s.high;
+            }
+            else if (sr < n_uword_bits)  // 2 <= sr <= n_uword_bits - 1
+            {
+                q.s.low = 0;
+                q.s.high = n.s.low << (n_uword_bits - sr);
+                r.s.high = n.s.high >> sr;
+                r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
+            }
+            else              // n_uword_bits + 1 <= sr <= n_udword_bits - 1
+            {
+                q.s.low = n.s.low << (n_udword_bits - sr);
+                q.s.high = (n.s.high << (n_udword_bits - sr)) |
+                           (n.s.low >> (sr - n_uword_bits));
+                r.s.high = 0;
+                r.s.low = n.s.high >> (sr - n_uword_bits);
+            }
+        }
+        else
+        {
+            /* K X
+             * ---
+             * K K
+             */
+            sr = __builtin_clz(d.s.high) - __builtin_clz(n.s.high);
+            /* 0 <= sr <= n_uword_bits - 1 or sr large */
+            if (sr > n_uword_bits - 1)
+            {
+                if (rem)
+                    *rem = n.all;
+                return 0;
+            }
+            ++sr;
+            /* 1 <= sr <= n_uword_bits */
+            /*  q.all = n.all << (n_udword_bits - sr); */
+            q.s.low = 0;
+            if (sr == n_uword_bits)
+            {
+                q.s.high = n.s.low;
+                r.s.high = 0;
+                r.s.low = n.s.high;
+            }
+            else
+            {
+                q.s.high = n.s.low << (n_uword_bits - sr);
+                r.s.high = n.s.high >> sr;
+                r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
+            }
+        }
+    }
+    /* Not a special case
+     * q and r are initialized with:
+     * q.all = n.all << (n_udword_bits - sr);
+     * r.all = n.all >> sr;
+     * 1 <= sr <= n_udword_bits - 1
+     */
+    su_int carry = 0;
+    for (; sr > 0; --sr)
+    {
+        /* r:q = ((r:q)  << 1) | carry */
+        r.s.high = (r.s.high << 1) | (r.s.low  >> (n_uword_bits - 1));
+        r.s.low  = (r.s.low  << 1) | (q.s.high >> (n_uword_bits - 1));
+        q.s.high = (q.s.high << 1) | (q.s.low  >> (n_uword_bits - 1));
+        q.s.low  = (q.s.low  << 1) | carry;
+        /* carry = 0;
+         * if (r.all >= d.all)
+         * {
+         *      r.all -= d.all;
+         *      carry = 1;
+         * }
+         */
+        const di_int s = (di_int)(d.all - r.all - 1) >> (n_udword_bits - 1);
+        carry = s & 1;
+        r.all -= d.all & s;
+    }
+    q.all = (q.all << 1) | carry;
+    if (rem)
+        *rem = r.all;
+    return q.all;
+}
diff --git a/compiler-rt/lib/builtins/udivmodsi4.c b/compiler-rt/lib/builtins/udivmodsi4.c
new file mode 100644
index 0000000..789c4b5
--- /dev/null
+++ b/compiler-rt/lib/builtins/udivmodsi4.c
@@ -0,0 +1,27 @@
+/*===-- udivmodsi4.c - Implement __udivmodsi4 ------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivmodsi4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b, *rem = a % b  */
+
+COMPILER_RT_ABI su_int
+__udivmodsi4(su_int a, su_int b, su_int* rem)
+{
+  si_int d = __udivsi3(a,b);
+  *rem = a - (d*b);
+  return d;
+}
+
+
diff --git a/compiler-rt/lib/builtins/udivmodti4.c b/compiler-rt/lib/builtins/udivmodti4.c
new file mode 100644
index 0000000..8031688
--- /dev/null
+++ b/compiler-rt/lib/builtins/udivmodti4.c
@@ -0,0 +1,238 @@
+/* ===-- udivmodti4.c - Implement __udivmodti4 -----------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivmodti4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Effects: if rem != 0, *rem = a % b 
+ * Returns: a / b 
+ */
+
+/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
+
+COMPILER_RT_ABI tu_int
+__udivmodti4(tu_int a, tu_int b, tu_int* rem)
+{
+    const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT;
+    const unsigned n_utword_bits = sizeof(tu_int) * CHAR_BIT;
+    utwords n;
+    n.all = a;
+    utwords d;
+    d.all = b;
+    utwords q;
+    utwords r;
+    unsigned sr;
+    /* special cases, X is unknown, K != 0 */
+    if (n.s.high == 0)
+    {
+        if (d.s.high == 0)
+        {
+            /* 0 X
+             * ---
+             * 0 X
+             */
+            if (rem)
+                *rem = n.s.low % d.s.low;
+            return n.s.low / d.s.low;
+        }
+        /* 0 X
+         * ---
+         * K X
+         */
+        if (rem)
+            *rem = n.s.low;
+        return 0;
+    }
+    /* n.s.high != 0 */
+    if (d.s.low == 0)
+    {
+        if (d.s.high == 0)
+        {
+            /* K X
+             * ---
+             * 0 0
+             */
+            if (rem)
+                *rem = n.s.high % d.s.low;
+            return n.s.high / d.s.low;
+        }
+        /* d.s.high != 0 */
+        if (n.s.low == 0)
+        {
+            /* K 0
+             * ---
+             * K 0
+             */
+            if (rem)
+            {
+                r.s.high = n.s.high % d.s.high;
+                r.s.low = 0;
+                *rem = r.all;
+            }
+            return n.s.high / d.s.high;
+        }
+        /* K K
+         * ---
+         * K 0
+         */
+        if ((d.s.high & (d.s.high - 1)) == 0)     /* if d is a power of 2 */
+        {
+            if (rem)
+            {
+                r.s.low = n.s.low;
+                r.s.high = n.s.high & (d.s.high - 1);
+                *rem = r.all;
+            }
+            return n.s.high >> __builtin_ctzll(d.s.high);
+        }
+        /* K K
+         * ---
+         * K 0
+         */
+        sr = __builtin_clzll(d.s.high) - __builtin_clzll(n.s.high);
+        /* 0 <= sr <= n_udword_bits - 2 or sr large */
+        if (sr > n_udword_bits - 2)
+        {
+           if (rem)
+                *rem = n.all;
+            return 0;
+        }
+        ++sr;
+        /* 1 <= sr <= n_udword_bits - 1 */
+        /* q.all = n.all << (n_utword_bits - sr); */
+        q.s.low = 0;
+        q.s.high = n.s.low << (n_udword_bits - sr);
+        /* r.all = n.all >> sr; */
+        r.s.high = n.s.high >> sr;
+        r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
+    }
+    else  /* d.s.low != 0 */
+    {
+        if (d.s.high == 0)
+        {
+            /* K X
+             * ---
+             * 0 K
+             */
+            if ((d.s.low & (d.s.low - 1)) == 0)     /* if d is a power of 2 */
+            {
+                if (rem)
+                    *rem = n.s.low & (d.s.low - 1);
+                if (d.s.low == 1)
+                    return n.all;
+                sr = __builtin_ctzll(d.s.low);
+                q.s.high = n.s.high >> sr;
+                q.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
+                return q.all;
+            }
+            /* K X
+             * ---
+             * 0 K
+             */
+            sr = 1 + n_udword_bits + __builtin_clzll(d.s.low)
+                                   - __builtin_clzll(n.s.high);
+            /* 2 <= sr <= n_utword_bits - 1
+             * q.all = n.all << (n_utword_bits - sr);
+             * r.all = n.all >> sr;
+             */
+            if (sr == n_udword_bits)
+            {
+                q.s.low = 0;
+                q.s.high = n.s.low;
+                r.s.high = 0;
+                r.s.low = n.s.high;
+            }
+            else if (sr < n_udword_bits)  // 2 <= sr <= n_udword_bits - 1
+            {
+                q.s.low = 0;
+                q.s.high = n.s.low << (n_udword_bits - sr);
+                r.s.high = n.s.high >> sr;
+                r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
+            }
+            else              // n_udword_bits + 1 <= sr <= n_utword_bits - 1
+            {
+                q.s.low = n.s.low << (n_utword_bits - sr);
+                q.s.high = (n.s.high << (n_utword_bits - sr)) |
+                           (n.s.low >> (sr - n_udword_bits));
+                r.s.high = 0;
+                r.s.low = n.s.high >> (sr - n_udword_bits);
+            }
+        }
+        else
+        {
+            /* K X
+             * ---
+             * K K
+             */
+            sr = __builtin_clzll(d.s.high) - __builtin_clzll(n.s.high);
+            /*0 <= sr <= n_udword_bits - 1 or sr large */
+            if (sr > n_udword_bits - 1)
+            {
+               if (rem)
+                    *rem = n.all;
+                return 0;
+            }
+            ++sr;
+            /* 1 <= sr <= n_udword_bits
+             * q.all = n.all << (n_utword_bits - sr);
+             * r.all = n.all >> sr;
+             */
+            q.s.low = 0;
+            if (sr == n_udword_bits)
+            {
+                q.s.high = n.s.low;
+                r.s.high = 0;
+                r.s.low = n.s.high;
+            }
+            else
+            {
+                r.s.high = n.s.high >> sr;
+                r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
+                q.s.high = n.s.low << (n_udword_bits - sr);
+            }
+        }
+    }
+    /* Not a special case
+     * q and r are initialized with:
+     * q.all = n.all << (n_utword_bits - sr);
+     * r.all = n.all >> sr;
+     * 1 <= sr <= n_utword_bits - 1
+     */
+    su_int carry = 0;
+    for (; sr > 0; --sr)
+    {
+        /* r:q = ((r:q)  << 1) | carry */
+        r.s.high = (r.s.high << 1) | (r.s.low  >> (n_udword_bits - 1));
+        r.s.low  = (r.s.low  << 1) | (q.s.high >> (n_udword_bits - 1));
+        q.s.high = (q.s.high << 1) | (q.s.low  >> (n_udword_bits - 1));
+        q.s.low  = (q.s.low  << 1) | carry;
+        /* carry = 0;
+         * if (r.all >= d.all)
+         * {
+         *     r.all -= d.all;
+         *      carry = 1;
+         * }
+         */
+        const ti_int s = (ti_int)(d.all - r.all - 1) >> (n_utword_bits - 1);
+        carry = s & 1;
+        r.all -= d.all & s;
+    }
+    q.all = (q.all << 1) | carry;
+    if (rem)
+        *rem = r.all;
+    return q.all;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/udivsi3.c b/compiler-rt/lib/builtins/udivsi3.c
new file mode 100644
index 0000000..5d0140c
--- /dev/null
+++ b/compiler-rt/lib/builtins/udivsi3.c
@@ -0,0 +1,66 @@
+/* ===-- udivsi3.c - Implement __udivsi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a / b */
+
+/* Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide */
+
+ARM_EABI_FNALIAS(uidiv, udivsi3)
+
+/* This function should not call __divsi3! */
+COMPILER_RT_ABI su_int
+__udivsi3(su_int n, su_int d)
+{
+    const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;
+    su_int q;
+    su_int r;
+    unsigned sr;
+    /* special cases */
+    if (d == 0)
+        return 0; /* ?! */
+    if (n == 0)
+        return 0;
+    sr = __builtin_clz(d) - __builtin_clz(n);
+    /* 0 <= sr <= n_uword_bits - 1 or sr large */
+    if (sr > n_uword_bits - 1)  /* d > r */
+        return 0;
+    if (sr == n_uword_bits - 1)  /* d == 1 */
+        return n;
+    ++sr;
+    /* 1 <= sr <= n_uword_bits - 1 */
+    /* Not a special case */
+    q = n << (n_uword_bits - sr);
+    r = n >> sr;
+    su_int carry = 0;
+    for (; sr > 0; --sr)
+    {
+        /* r:q = ((r:q)  << 1) | carry */
+        r = (r << 1) | (q >> (n_uword_bits - 1));
+        q = (q << 1) | carry;
+        /* carry = 0;
+         * if (r.all >= d.all)
+         * {
+         *      r.all -= d.all;
+         *      carry = 1;
+         * }
+         */
+        const si_int s = (si_int)(d - r - 1) >> (n_uword_bits - 1);
+        carry = s & 1;
+        r -= d & s;
+    }
+    q = (q << 1) | carry;
+    return q;
+}
diff --git a/compiler-rt/lib/builtins/udivti3.c b/compiler-rt/lib/builtins/udivti3.c
new file mode 100644
index 0000000..ec94673
--- /dev/null
+++ b/compiler-rt/lib/builtins/udivti3.c
@@ -0,0 +1,27 @@
+/* ===-- udivti3.c - Implement __udivti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a / b */
+
+COMPILER_RT_ABI tu_int
+__udivti3(tu_int a, tu_int b)
+{
+    return __udivmodti4(a, b, 0);
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/umoddi3.c b/compiler-rt/lib/builtins/umoddi3.c
new file mode 100644
index 0000000..d513f08
--- /dev/null
+++ b/compiler-rt/lib/builtins/umoddi3.c
@@ -0,0 +1,25 @@
+/* ===-- umoddi3.c - Implement __umoddi3 -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __umoddi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a % b */
+
+COMPILER_RT_ABI du_int
+__umoddi3(du_int a, du_int b)
+{
+    du_int r;
+    __udivmoddi4(a, b, &r);
+    return r;
+}
diff --git a/compiler-rt/lib/builtins/umodsi3.c b/compiler-rt/lib/builtins/umodsi3.c
new file mode 100644
index 0000000..d5fda4a
--- /dev/null
+++ b/compiler-rt/lib/builtins/umodsi3.c
@@ -0,0 +1,23 @@
+/* ===-- umodsi3.c - Implement __umodsi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __umodsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a % b */
+
+COMPILER_RT_ABI su_int
+__umodsi3(su_int a, su_int b)
+{
+    return a - __udivsi3(a, b) * b;
+}
diff --git a/compiler-rt/lib/builtins/umodti3.c b/compiler-rt/lib/builtins/umodti3.c
new file mode 100644
index 0000000..6d1ca7a
--- /dev/null
+++ b/compiler-rt/lib/builtins/umodti3.c
@@ -0,0 +1,29 @@
+/* ===-- umodti3.c - Implement __umodti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __umodti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+#ifdef CRT_HAS_128BIT
+
+/* Returns: a % b */
+
+COMPILER_RT_ABI tu_int
+__umodti3(tu_int a, tu_int b)
+{
+    tu_int r;
+    __udivmodti4(a, b, &r);
+    return r;
+}
+
+#endif /* CRT_HAS_128BIT */
diff --git a/compiler-rt/lib/builtins/x86_64/Makefile.mk b/compiler-rt/lib/builtins/x86_64/Makefile.mk
new file mode 100644
index 0000000..83848dd
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/Makefile.mk
@@ -0,0 +1,20 @@
+#===- lib/builtins/x86_64/Makefile.mk ----------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := builtins
+SubDirs := 
+OnlyArchs := x86_64 x86_64h
+
+AsmSources := $(foreach file,$(wildcard $(Dir)/*.S),$(notdir $(file)))
+Sources := $(foreach file,$(wildcard $(Dir)/*.c),$(notdir $(file)))
+ObjNames := $(Sources:%.c=%.o) $(AsmSources:%.S=%.o)
+Implementation := Optimized
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard lib/*.h $(Dir)/*.h)
diff --git a/compiler-rt/lib/builtins/x86_64/chkstk.S b/compiler-rt/lib/builtins/x86_64/chkstk.S
new file mode 100644
index 0000000..4149ac6
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/chkstk.S
@@ -0,0 +1,39 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// _chkstk routine
+// This routine is windows specific
+// http://msdn.microsoft.com/en-us/library/ms648426.aspx
+
+// Notes from r227519
+// MSVC x64s __chkstk and cygmings ___chkstk_ms do not adjust %rsp
+// themselves. It also does not clobber %rax so we can reuse it when
+// adjusting %rsp.
+
+#ifdef __x86_64__
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(___chkstk_ms)
+        push   %rcx
+        push   %rax
+        cmp    $0x1000,%rax
+        lea    24(%rsp),%rcx
+        jb     1f
+2:
+        sub    $0x1000,%rcx
+        test   %rcx,(%rcx)
+        sub    $0x1000,%rax
+        cmp    $0x1000,%rax
+        ja     2b
+1:
+        sub    %rax,%rcx
+        test   %rcx,(%rcx)
+        pop    %rax
+        pop    %rcx
+        ret
+END_COMPILERRT_FUNCTION(___chkstk_ms)
+
+#endif // __x86_64__
diff --git a/compiler-rt/lib/builtins/x86_64/chkstk2.S b/compiler-rt/lib/builtins/x86_64/chkstk2.S
new file mode 100644
index 0000000..ac1eb92
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/chkstk2.S
@@ -0,0 +1,42 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+#ifdef __x86_64__
+
+// _chkstk (_alloca) routine - probe stack between %rsp and (%rsp-%rax) in 4k increments,
+// then decrement %rsp by %rax.  Preserves all registers except %rsp and flags.
+// This routine is windows specific
+// http://msdn.microsoft.com/en-us/library/ms648426.aspx
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__alloca)
+        mov    %rcx,%rax        // x64 _alloca is a normal function with parameter in rcx
+        // fallthrough
+DEFINE_COMPILERRT_FUNCTION(___chkstk)
+        push   %rcx
+        cmp    $0x1000,%rax
+        lea    16(%rsp),%rcx     // rsp before calling this routine -> rcx
+        jb     1f
+2:
+        sub    $0x1000,%rcx
+        test   %rcx,(%rcx)
+        sub    $0x1000,%rax
+        cmp    $0x1000,%rax
+        ja     2b
+1:
+        sub    %rax,%rcx
+        test   %rcx,(%rcx)
+
+        lea    8(%rsp),%rax     // load pointer to the return address into rax
+        mov    %rcx,%rsp        // install the new top of stack pointer into rsp
+        mov    -8(%rax),%rcx    // restore rcx
+        push   (%rax)           // push return address onto the stack
+        sub    %rsp,%rax        // restore the original value in rax
+        ret
+END_COMPILERRT_FUNCTION(___chkstk)
+END_COMPILERRT_FUNCTION(__alloca)
+
+#endif // __x86_64__
diff --git a/compiler-rt/lib/builtins/x86_64/floatdidf.c b/compiler-rt/lib/builtins/x86_64/floatdidf.c
new file mode 100644
index 0000000..388404e
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/floatdidf.c
@@ -0,0 +1,16 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* double __floatdidf(di_int a); */
+
+#ifdef __x86_64__
+
+#include "../int_lib.h"
+
+double __floatdidf(int64_t a)
+{
+	return (double)a;
+}
+
+#endif /* __x86_64__ */
diff --git a/compiler-rt/lib/builtins/x86_64/floatdisf.c b/compiler-rt/lib/builtins/x86_64/floatdisf.c
new file mode 100644
index 0000000..96c3728
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/floatdisf.c
@@ -0,0 +1,14 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+#ifdef __x86_64__
+
+#include "../int_lib.h"
+
+float __floatdisf(int64_t a)
+{
+	return (float)a;
+}
+
+#endif /* __x86_64__ */
diff --git a/compiler-rt/lib/builtins/x86_64/floatdixf.c b/compiler-rt/lib/builtins/x86_64/floatdixf.c
new file mode 100644
index 0000000..c01193a
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/floatdixf.c
@@ -0,0 +1,16 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+/* long double __floatdixf(di_int a); */
+
+#ifdef __x86_64__
+
+#include "../int_lib.h"
+
+long double __floatdixf(int64_t a)
+{
+	return (long double)a;
+}
+
+#endif /* __i386__ */
diff --git a/compiler-rt/lib/builtins/x86_64/floatundidf.S b/compiler-rt/lib/builtins/x86_64/floatundidf.S
new file mode 100644
index 0000000..3cd5d02
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/floatundidf.S
@@ -0,0 +1,49 @@
+//===-- floatundidf.S - Implement __floatundidf for x86_64 ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements __floatundidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// double __floatundidf(du_int a);
+
+#ifdef __x86_64__
+
+CONST_SECTION
+
+	.balign 16
+twop52:
+	.quad 0x4330000000000000
+
+	.balign 16
+twop84_plus_twop52:
+	.quad 0x4530000000100000
+
+	.balign 16
+twop84:
+	.quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundidf)
+	movd	%edi,							%xmm0 // low 32 bits of a
+	shrq	$32,							%rdi  // high 32 bits of a
+	orq		REL_ADDR(twop84),				%rdi  // 0x1p84 + a_hi (no rounding occurs)
+	orpd	REL_ADDR(twop52),				%xmm0 // 0x1p52 + a_lo (no rounding occurs)
+	movd	%rdi,							%xmm1
+	subsd	REL_ADDR(twop84_plus_twop52),	%xmm1 // a_hi - 0x1p52 (no rounding occurs)
+	addsd	%xmm1,							%xmm0 // a_hi + a_lo   (round happens here)
+	ret
+END_COMPILERRT_FUNCTION(__floatundidf)
+
+#endif // __x86_64__
diff --git a/compiler-rt/lib/builtins/x86_64/floatundisf.S b/compiler-rt/lib/builtins/x86_64/floatundisf.S
new file mode 100644
index 0000000..61952f4
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/floatundisf.S
@@ -0,0 +1,35 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// float __floatundisf(du_int a);
+
+#ifdef __x86_64__
+
+CONST_SECTION
+
+	.balign 16
+two:
+	.single 2.0
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundisf)
+	movq		$1,			%rsi
+	testq		%rdi,		%rdi
+	js			1f
+	cvtsi2ssq	%rdi,		%xmm0
+	ret
+	
+1:	andq		%rdi,		%rsi
+	shrq		%rdi
+	orq			%rsi,		%rdi
+	cvtsi2ssq	%rdi,		%xmm0
+	mulss	REL_ADDR(two),	%xmm0
+	ret
+END_COMPILERRT_FUNCTION(__floatundisf)
+
+#endif // __x86_64__
diff --git a/compiler-rt/lib/builtins/x86_64/floatundixf.S b/compiler-rt/lib/builtins/x86_64/floatundixf.S
new file mode 100644
index 0000000..92961c8
--- /dev/null
+++ b/compiler-rt/lib/builtins/x86_64/floatundixf.S
@@ -0,0 +1,68 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// long double __floatundixf(du_int a);
+
+#ifdef __x86_64__
+
+CONST_SECTION
+
+	.balign 16
+twop64:
+	.quad 0x43f0000000000000
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+	.text
+
+	.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundixf)
+	movq	%rdi,	 -8(%rsp)
+	fildq	-8(%rsp)
+	test	%rdi,		%rdi
+	js		1f
+	ret
+1:	faddl	REL_ADDR(twop64)
+	ret
+END_COMPILERRT_FUNCTION(__floatundixf)
+
+#endif // __x86_64__
+
+
+/* Branch-free implementation is ever so slightly slower, but more beautiful.
+   It is likely superior for inlining, so I kept it around for future reference.
+
+#ifdef __x86_64__
+
+CONST_SECTION
+
+	.balign 4
+twop52:
+	.quad 0x4330000000000000
+twop84_plus_twop52_neg:
+	.quad 0xc530000000100000
+twop84:
+	.quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.balign 4
+DEFINE_COMPILERRT_FUNCTION(__floatundixf)
+	movl	%edi,				%esi			// low 32 bits of input
+	shrq	$32,				%rdi			// hi 32 bits of input
+	orq		REL_ADDR(twop84),	%rdi			// 2^84 + hi (as a double)
+	orq		REL_ADDR(twop52),	%rsi			// 2^52 + lo (as a double)
+	movq	%rdi,			 -8(%rsp)
+	movq	%rsi,			-16(%rsp)
+	fldl	REL_ADDR(twop84_plus_twop52_neg)	
+	faddl	-8(%rsp)	// hi - 2^52 (as double extended, no rounding occurs)
+	faddl	-16(%rsp)	// hi + lo (as double extended)
+	ret
+END_COMPILERRT_FUNCTION(__floatundixf)
+
+#endif // __x86_64__
+
+*/
diff --git a/compiler-rt/lib/cfi/CMakeLists.txt b/compiler-rt/lib/cfi/CMakeLists.txt
new file mode 100644
index 0000000..24e5181
--- /dev/null
+++ b/compiler-rt/lib/cfi/CMakeLists.txt
@@ -0,0 +1,40 @@
+add_custom_target(cfi)
+
+set(CFI_SOURCES cfi.cc)
+
+include_directories(..)
+
+set(CFI_CFLAGS
+  ${SANITIZER_COMMON_CFLAGS}
+)
+
+set(CFI_DIAG_CFLAGS
+  -DCFI_ENABLE_DIAG=1
+)
+
+foreach(arch ${CFI_SUPPORTED_ARCH})
+  add_compiler_rt_runtime(clang_rt.cfi
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${CFI_SOURCES}
+    OBJECT_LIBS RTInterception
+                RTSanitizerCommon
+                RTSanitizerCommonLibc
+    CFLAGS ${CFI_CFLAGS}
+    PARENT_TARGET cfi)
+  add_compiler_rt_runtime(clang_rt.cfi_diag
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${CFI_SOURCES}
+    OBJECT_LIBS RTInterception
+                RTSanitizerCommon
+                RTSanitizerCommonLibc
+		RTUbsan
+		RTUbsan_cxx
+    CFLAGS ${CFI_CFLAGS} ${CFI_DIAG_CFLAGS}
+    PARENT_TARGET cfi)
+endforeach()
+
+add_compiler_rt_resource_file(cfi_blacklist cfi_blacklist.txt)
+add_dependencies(cfi cfi_blacklist)
+add_dependencies(compiler-rt cfi)
diff --git a/compiler-rt/lib/cfi/cfi.cc b/compiler-rt/lib/cfi/cfi.cc
new file mode 100644
index 0000000..e6249e6
--- /dev/null
+++ b/compiler-rt/lib/cfi/cfi.cc
@@ -0,0 +1,271 @@
+//===-------- cfi.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the runtime support for the cross-DSO CFI.
+//
+//===----------------------------------------------------------------------===//
+
+// FIXME: Intercept dlopen/dlclose.
+// FIXME: Support diagnostic mode.
+// FIXME: Harden:
+//  * mprotect shadow, use mremap for updates
+//  * something else equally important
+
+#include <assert.h>
+#include <elf.h>
+#include <link.h>
+#include <string.h>
+
+typedef ElfW(Phdr) Elf_Phdr;
+typedef ElfW(Ehdr) Elf_Ehdr;
+
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "ubsan/ubsan_init.h"
+#include "ubsan/ubsan_flags.h"
+
+static uptr __cfi_shadow;
+static constexpr uptr kShadowGranularity = 12;
+static constexpr uptr kShadowAlign = 1UL << kShadowGranularity; // 4096
+
+static constexpr uint16_t kInvalidShadow = 0;
+static constexpr uint16_t kUncheckedShadow = 0xFFFFU;
+
+static uint16_t *mem_to_shadow(uptr x) {
+  return (uint16_t *)(__cfi_shadow + ((x >> kShadowGranularity) << 1));
+}
+
+typedef int (*CFICheckFn)(uptr, void *);
+
+class ShadowValue {
+  uptr addr;
+  uint16_t v;
+  explicit ShadowValue(uptr addr, uint16_t v) : addr(addr), v(v) {}
+
+public:
+  bool is_invalid() const { return v == kInvalidShadow; }
+
+  bool is_unchecked() const { return v == kUncheckedShadow; }
+
+  CFICheckFn get_cfi_check() const {
+    assert(!is_invalid() && !is_unchecked());
+    uptr aligned_addr = addr & ~(kShadowAlign - 1);
+    uptr p = aligned_addr - (((uptr)v - 1) << kShadowGranularity);
+    return reinterpret_cast<CFICheckFn>(p);
+  }
+
+  // Load a shadow valud for the given application memory address.
+  static const ShadowValue load(uptr addr) {
+    return ShadowValue(addr, *mem_to_shadow(addr));
+  }
+};
+
+static void fill_shadow_constant(uptr begin, uptr end, uint16_t v) {
+  assert(v == kInvalidShadow || v == kUncheckedShadow);
+  uint16_t *shadow_begin = mem_to_shadow(begin);
+  uint16_t *shadow_end = mem_to_shadow(end - 1) + 1;
+  memset(shadow_begin, v, (shadow_end - shadow_begin) * sizeof(*shadow_begin));
+}
+
+static void fill_shadow(uptr begin, uptr end, uptr cfi_check) {
+  assert((cfi_check & (kShadowAlign - 1)) == 0);
+
+  // Don't fill anything below cfi_check. We can not represent those addresses
+  // in the shadow, and must make sure at codegen to place all valid call
+  // targets above cfi_check.
+  uptr p = Max(begin, cfi_check);
+  uint16_t *s = mem_to_shadow(p);
+  uint16_t *s_end = mem_to_shadow(end - 1) + 1;
+  uint16_t sv = ((p - cfi_check) >> kShadowGranularity) + 1;
+  for (; s < s_end; s++, sv++)
+    *s = sv;
+
+  // Sanity checks.
+  uptr q = p & ~(kShadowAlign - 1);
+  for (; q < end; q += kShadowAlign) {
+    assert((uptr)ShadowValue::load(q).get_cfi_check() == cfi_check);
+    assert((uptr)ShadowValue::load(q + kShadowAlign / 2).get_cfi_check() ==
+           cfi_check);
+    assert((uptr)ShadowValue::load(q + kShadowAlign - 1).get_cfi_check() ==
+           cfi_check);
+  }
+}
+
+// This is a workaround for a glibc bug:
+// https://sourceware.org/bugzilla/show_bug.cgi?id=15199
+// Other platforms can, hopefully, just do
+//    dlopen(RTLD_NOLOAD | RTLD_LAZY)
+//    dlsym("__cfi_check").
+static uptr find_cfi_check_in_dso(dl_phdr_info *info) {
+  const ElfW(Dyn) *dynamic = nullptr;
+  for (int i = 0; i < info->dlpi_phnum; ++i) {
+    if (info->dlpi_phdr[i].p_type == PT_DYNAMIC) {
+      dynamic =
+          (const ElfW(Dyn) *)(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr);
+      break;
+    }
+  }
+  if (!dynamic) return 0;
+  uptr strtab = 0, symtab = 0;
+  for (const ElfW(Dyn) *p = dynamic; p->d_tag != PT_NULL; ++p) {
+    if (p->d_tag == DT_SYMTAB)
+      symtab = p->d_un.d_ptr;
+    else if (p->d_tag == DT_STRTAB)
+      strtab = p->d_un.d_ptr;
+  }
+
+  if (symtab > strtab) {
+    VReport(1, "Can not handle: symtab > strtab (%p > %zx)\n", symtab, strtab);
+    return 0;
+  }
+
+  // Verify that strtab and symtab are inside of the same LOAD segment.
+  // This excludes VDSO, which has (very high) bogus strtab and symtab pointers.
+  int phdr_idx;
+  for (phdr_idx = 0; phdr_idx < info->dlpi_phnum; phdr_idx++) {
+    const Elf_Phdr *phdr = &info->dlpi_phdr[phdr_idx];
+    if (phdr->p_type == PT_LOAD) {
+      uptr beg = info->dlpi_addr + phdr->p_vaddr;
+      uptr end = beg + phdr->p_memsz;
+      if (strtab >= beg && strtab < end && symtab >= beg && symtab < end)
+        break;
+    }
+  }
+  if (phdr_idx == info->dlpi_phnum) {
+    // Nope, either different segments or just bogus pointers.
+    // Can not handle this.
+    VReport(1, "Can not handle: symtab %p, strtab %zx\n", symtab, strtab);
+    return 0;
+  }
+
+  for (const ElfW(Sym) *p = (const ElfW(Sym) *)symtab; (ElfW(Addr))p < strtab;
+       ++p) {
+    char *name = (char*)(strtab + p->st_name);
+    if (strcmp(name, "__cfi_check") == 0) {
+      assert(p->st_info == ELF32_ST_INFO(STB_GLOBAL, STT_FUNC));
+      uptr addr = info->dlpi_addr + p->st_value;
+      return addr;
+    }
+  }
+  return 0;
+}
+
+static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *data) {
+  uptr cfi_check = find_cfi_check_in_dso(info);
+  if (cfi_check)
+    VReport(1, "Module '%s' __cfi_check %zx\n", info->dlpi_name, cfi_check);
+
+  for (int i = 0; i < info->dlpi_phnum; i++) {
+    const Elf_Phdr *phdr = &info->dlpi_phdr[i];
+    if (phdr->p_type == PT_LOAD) {
+      // Jump tables are in the executable segment.
+      // VTables are in the non-executable one.
+      // Need to fill shadow for both.
+      // FIXME: reject writable if vtables are in the r/o segment. Depend on
+      // PT_RELRO?
+      uptr cur_beg = info->dlpi_addr + phdr->p_vaddr;
+      uptr cur_end = cur_beg + phdr->p_memsz;
+      if (cfi_check) {
+        VReport(1, "   %zx .. %zx\n", cur_beg, cur_end);
+        fill_shadow(cur_beg, cur_end, cfi_check ? cfi_check : (uptr)(-1));
+      } else {
+        fill_shadow_constant(cur_beg, cur_end, kInvalidShadow);
+      }
+    }
+  }
+  return 0;
+}
+
+// Fill shadow for the initial libraries.
+static void init_shadow() {
+  dl_iterate_phdr(dl_iterate_phdr_cb, nullptr);
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __cfi_slowpath(uptr CallSiteTypeId, void *Ptr) {
+  uptr Addr = (uptr)Ptr;
+  VReport(3, "__cfi_slowpath: %zx, %p\n", CallSiteTypeId, Ptr);
+  ShadowValue sv = ShadowValue::load(Addr);
+  if (sv.is_invalid()) {
+    VReport(2, "CFI: invalid memory region for a function pointer (shadow==0): %p\n", Ptr);
+    Die();
+  }
+  if (sv.is_unchecked()) {
+    VReport(2, "CFI: unchecked call (shadow=FFFF): %p\n", Ptr);
+    return;
+  }
+  CFICheckFn cfi_check = sv.get_cfi_check();
+  VReport(2, "__cfi_check at %p\n", cfi_check);
+  cfi_check(CallSiteTypeId, Ptr);
+}
+
+static void InitializeFlags() {
+  SetCommonFlagsDefaults();
+#ifdef CFI_ENABLE_DIAG
+  __ubsan::Flags *uf = __ubsan::flags();
+  uf->SetDefaults();
+#endif
+
+  FlagParser cfi_parser;
+  RegisterCommonFlags(&cfi_parser);
+  cfi_parser.ParseString(GetEnv("CFI_OPTIONS"));
+
+#ifdef CFI_ENABLE_DIAG
+  FlagParser ubsan_parser;
+  __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
+  RegisterCommonFlags(&ubsan_parser);
+
+  const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
+  ubsan_parser.ParseString(ubsan_default_options);
+  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+#endif
+
+  SetVerbosity(common_flags()->verbosity);
+
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) {
+    cfi_parser.PrintFlagDescriptions();
+  }
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+#if !SANITIZER_CAN_USE_PREINIT_ARRAY
+// On ELF platforms, the constructor is invoked using .preinit_array (see below)
+__attribute__((constructor(0)))
+#endif
+void __cfi_init() {
+  SanitizerToolName = "CFI";
+  InitializeFlags();
+
+  uptr vma = GetMaxVirtualAddress();
+  // Shadow is 2 -> 2**kShadowGranularity.
+  uptr shadow_size = (vma >> (kShadowGranularity - 1)) + 1;
+  VReport(1, "CFI: VMA size %zx, shadow size %zx\n", vma, shadow_size);
+  void *shadow = MmapNoReserveOrDie(shadow_size, "CFI shadow");
+  VReport(1, "CFI: shadow at %zx .. %zx\n", shadow,
+          reinterpret_cast<uptr>(shadow) + shadow_size);
+  __cfi_shadow = (uptr)shadow;
+  init_shadow();
+
+#ifdef CFI_ENABLE_DIAG
+  __ubsan::InitAsPlugin();
+#endif
+}
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+// On ELF platforms, run cfi initialization before any other constructors.
+// On other platforms we use the constructor attribute to arrange to run our
+// initialization early.
+extern "C" {
+__attribute__((section(".preinit_array"),
+               used)) void (*__cfi_preinit)(void) = __cfi_init;
+}
+#endif
diff --git a/compiler-rt/lib/cfi/cfi_blacklist.txt b/compiler-rt/lib/cfi/cfi_blacklist.txt
new file mode 100644
index 0000000..1f0eeb3
--- /dev/null
+++ b/compiler-rt/lib/cfi/cfi_blacklist.txt
@@ -0,0 +1,26 @@
+# Standard library types.
+type:std::*
+
+# The stdext namespace contains Microsoft standard library extensions.
+type:stdext::*
+
+# Types with a uuid attribute, i.e. COM types.
+type:attr:uuid
+
+# STL allocators (T *allocator<T *>::allocate(size_type, const void*)).
+# The type signature mandates a cast from uninitialized void* to T*.
+# size_type can either be unsigned int (j) or unsigned long (m).
+fun:*8allocateEjPKv
+fun:*8allocateEmPKv
+
+# std::get_temporary_buffer, likewise (libstdc++, libc++).
+fun:_ZSt20get_temporary_buffer*
+fun:_ZNSt3__120get_temporary_buffer*
+
+# STL address-of magic (libstdc++, libc++).
+fun:*__addressof*
+fun:_ZNSt3__19addressof*
+
+# Windows C++ stdlib headers that contain bad unrelated casts.
+src:*xmemory0
+src:*xstddef
diff --git a/compiler-rt/lib/dfsan/.clang-format b/compiler-rt/lib/dfsan/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/dfsan/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/dfsan/CMakeLists.txt b/compiler-rt/lib/dfsan/CMakeLists.txt
new file mode 100644
index 0000000..19a7909
--- /dev/null
+++ b/compiler-rt/lib/dfsan/CMakeLists.txt
@@ -0,0 +1,48 @@
+include_directories(..)
+
+# Runtime library sources and build flags.
+set(DFSAN_RTL_SOURCES
+  dfsan.cc
+  dfsan_custom.cc
+  dfsan_interceptors.cc)
+set(DFSAN_COMMON_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(DFSAN_COMMON_CFLAGS)
+# Prevent clang from generating libc calls.
+append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding DFSAN_COMMON_CFLAGS)
+
+# Static runtime library.
+add_custom_target(dfsan)
+foreach(arch ${DFSAN_SUPPORTED_ARCH})
+  set(DFSAN_CFLAGS ${DFSAN_COMMON_CFLAGS})
+  append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE DFSAN_CFLAGS)
+  add_compiler_rt_runtime(clang_rt.dfsan
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${DFSAN_RTL_SOURCES}
+            $<TARGET_OBJECTS:RTInterception.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+    CFLAGS ${DFSAN_CFLAGS}
+    PARENT_TARGET dfsan)
+  add_sanitizer_rt_symbols(clang_rt.dfsan
+    ARCHS ${arch}
+    EXTRA dfsan.syms.extra)
+  add_dependencies(dfsan
+    clang_rt.dfsan-${arch}-symbols)
+endforeach()
+
+set(dfsan_abilist_filename ${COMPILER_RT_OUTPUT_DIR}/dfsan_abilist.txt)
+add_custom_target(dfsan_abilist ALL
+  DEPENDS ${dfsan_abilist_filename})
+add_custom_command(OUTPUT ${dfsan_abilist_filename}
+                   VERBATIM
+                   COMMAND
+                     cat ${CMAKE_CURRENT_SOURCE_DIR}/done_abilist.txt
+                         ${CMAKE_CURRENT_SOURCE_DIR}/libc_ubuntu1404_abilist.txt
+                         > ${dfsan_abilist_filename}
+                   DEPENDS done_abilist.txt libc_ubuntu1404_abilist.txt)
+add_dependencies(dfsan dfsan_abilist)
+install(FILES ${dfsan_abilist_filename}
+        DESTINATION ${COMPILER_RT_INSTALL_PATH})
+
+add_dependencies(compiler-rt dfsan)
diff --git a/compiler-rt/lib/dfsan/dfsan.cc b/compiler-rt/lib/dfsan/dfsan.cc
new file mode 100644
index 0000000..7285f20
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan.cc
@@ -0,0 +1,429 @@
+//===-- dfsan.cc ----------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of DataFlowSanitizer.
+//
+// DataFlowSanitizer runtime.  This file defines the public interface to
+// DataFlowSanitizer as well as the definition of certain runtime functions
+// called automatically by the compiler (specifically the instrumentation pass
+// in llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp).
+//
+// The public interface is defined in include/sanitizer/dfsan_interface.h whose
+// functions are prefixed dfsan_ while the compiler interface functions are
+// prefixed __dfsan_.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_libc.h"
+
+#include "dfsan/dfsan.h"
+
+using namespace __dfsan;
+
+typedef atomic_uint16_t atomic_dfsan_label;
+static const dfsan_label kInitializingLabel = -1;
+
+static const uptr kNumLabels = 1 << (sizeof(dfsan_label) * 8);
+
+static atomic_dfsan_label __dfsan_last_label;
+static dfsan_label_info __dfsan_label_info[kNumLabels];
+
+Flags __dfsan::flags_data;
+
+SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL dfsan_label __dfsan_retval_tls;
+SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL dfsan_label __dfsan_arg_tls[64];
+
+SANITIZER_INTERFACE_ATTRIBUTE uptr __dfsan_shadow_ptr_mask;
+
+// On Linux/x86_64, memory is laid out as follows:
+//
+// +--------------------+ 0x800000000000 (top of memory)
+// | application memory |
+// +--------------------+ 0x700000008000 (kAppAddr)
+// |                    |
+// |       unused       |
+// |                    |
+// +--------------------+ 0x200200000000 (kUnusedAddr)
+// |    union table     |
+// +--------------------+ 0x200000000000 (kUnionTableAddr)
+// |   shadow memory    |
+// +--------------------+ 0x000000010000 (kShadowAddr)
+// | reserved by kernel |
+// +--------------------+ 0x000000000000
+//
+// To derive a shadow memory address from an application memory address,
+// bits 44-46 are cleared to bring the address into the range
+// [0x000000008000,0x100000000000).  Then the address is shifted left by 1 to
+// account for the double byte representation of shadow labels and move the
+// address into the shadow memory range.  See the function shadow_for below.
+
+// On Linux/MIPS64, memory is laid out as follows:
+//
+// +--------------------+ 0x10000000000 (top of memory)
+// | application memory |
+// +--------------------+ 0xF000008000 (kAppAddr)
+// |                    |
+// |       unused       |
+// |                    |
+// +--------------------+ 0x2200000000 (kUnusedAddr)
+// |    union table     |
+// +--------------------+ 0x2000000000 (kUnionTableAddr)
+// |   shadow memory    |
+// +--------------------+ 0x0000010000 (kShadowAddr)
+// | reserved by kernel |
+// +--------------------+ 0x0000000000
+
+// On Linux/AArch64 (39-bit VMA), memory is laid out as follow:
+//
+// +--------------------+ 0x8000000000 (top of memory)
+// | application memory |
+// +--------------------+ 0x7000008000 (kAppAddr)
+// |                    |
+// |       unused       |
+// |                    |
+// +--------------------+ 0x1200000000 (kUnusedAddr)
+// |    union table     |
+// +--------------------+ 0x1000000000 (kUnionTableAddr)
+// |   shadow memory    |
+// +--------------------+ 0x0000010000 (kShadowAddr)
+// | reserved by kernel |
+// +--------------------+ 0x0000000000
+
+// On Linux/AArch64 (42-bit VMA), memory is laid out as follow:
+//
+// +--------------------+ 0x40000000000 (top of memory)
+// | application memory |
+// +--------------------+ 0x3ff00008000 (kAppAddr)
+// |                    |
+// |       unused       |
+// |                    |
+// +--------------------+ 0x1200000000 (kUnusedAddr)
+// |    union table     |
+// +--------------------+ 0x8000000000 (kUnionTableAddr)
+// |   shadow memory    |
+// +--------------------+ 0x0000010000 (kShadowAddr)
+// | reserved by kernel |
+// +--------------------+ 0x0000000000
+
+typedef atomic_dfsan_label dfsan_union_table_t[kNumLabels][kNumLabels];
+
+#ifdef DFSAN_RUNTIME_VMA
+// Runtime detected VMA size.
+int __dfsan::vmaSize;
+#endif
+
+static uptr UnusedAddr() {
+  return MappingArchImpl<MAPPING_UNION_TABLE_ADDR>()
+         + sizeof(dfsan_union_table_t);
+}
+
+static atomic_dfsan_label *union_table(dfsan_label l1, dfsan_label l2) {
+  return &(*(dfsan_union_table_t *) UnionTableAddr())[l1][l2];
+}
+
+// Checks we do not run out of labels.
+static void dfsan_check_label(dfsan_label label) {
+  if (label == kInitializingLabel) {
+    Report("FATAL: DataFlowSanitizer: out of labels\n");
+    Die();
+  }
+}
+
+// Resolves the union of two unequal labels.  Nonequality is a precondition for
+// this function (the instrumentation pass inlines the equality test).
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+dfsan_label __dfsan_union(dfsan_label l1, dfsan_label l2) {
+  DCHECK_NE(l1, l2);
+
+  if (l1 == 0)
+    return l2;
+  if (l2 == 0)
+    return l1;
+
+  if (l1 > l2)
+    Swap(l1, l2);
+
+  atomic_dfsan_label *table_ent = union_table(l1, l2);
+  // We need to deal with the case where two threads concurrently request
+  // a union of the same pair of labels.  If the table entry is uninitialized,
+  // (i.e. 0) use a compare-exchange to set the entry to kInitializingLabel
+  // (i.e. -1) to mark that we are initializing it.
+  dfsan_label label = 0;
+  if (atomic_compare_exchange_strong(table_ent, &label, kInitializingLabel,
+                                     memory_order_acquire)) {
+    // Check whether l2 subsumes l1.  We don't need to check whether l1
+    // subsumes l2 because we are guaranteed here that l1 < l2, and (at least
+    // in the cases we are interested in) a label may only subsume labels
+    // created earlier (i.e. with a lower numerical value).
+    if (__dfsan_label_info[l2].l1 == l1 ||
+        __dfsan_label_info[l2].l2 == l1) {
+      label = l2;
+    } else {
+      label =
+        atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1;
+      dfsan_check_label(label);
+      __dfsan_label_info[label].l1 = l1;
+      __dfsan_label_info[label].l2 = l2;
+    }
+    atomic_store(table_ent, label, memory_order_release);
+  } else if (label == kInitializingLabel) {
+    // Another thread is initializing the entry.  Wait until it is finished.
+    do {
+      internal_sched_yield();
+      label = atomic_load(table_ent, memory_order_acquire);
+    } while (label == kInitializingLabel);
+  }
+  return label;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+dfsan_label __dfsan_union_load(const dfsan_label *ls, uptr n) {
+  dfsan_label label = ls[0];
+  for (uptr i = 1; i != n; ++i) {
+    dfsan_label next_label = ls[i];
+    if (label != next_label)
+      label = __dfsan_union(label, next_label);
+  }
+  return label;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __dfsan_unimplemented(char *fname) {
+  if (flags().warn_unimplemented)
+    Report("WARNING: DataFlowSanitizer: call to uninstrumented function %s\n",
+           fname);
+}
+
+// Use '-mllvm -dfsan-debug-nonzero-labels' and break on this function
+// to try to figure out where labels are being introduced in a nominally
+// label-free program.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_nonzero_label() {
+  if (flags().warn_nonzero_labels)
+    Report("WARNING: DataFlowSanitizer: saw nonzero label\n");
+}
+
+// Indirect call to an uninstrumented vararg function. We don't have a way of
+// handling these at the moment.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
+__dfsan_vararg_wrapper(const char *fname) {
+  Report("FATAL: DataFlowSanitizer: unsupported indirect call to vararg "
+         "function %s\n", fname);
+  Die();
+}
+
+// Like __dfsan_union, but for use from the client or custom functions.  Hence
+// the equality comparison is done here before calling __dfsan_union.
+SANITIZER_INTERFACE_ATTRIBUTE dfsan_label
+dfsan_union(dfsan_label l1, dfsan_label l2) {
+  if (l1 == l2)
+    return l1;
+  return __dfsan_union(l1, l2);
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+dfsan_label dfsan_create_label(const char *desc, void *userdata) {
+  dfsan_label label =
+    atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1;
+  dfsan_check_label(label);
+  __dfsan_label_info[label].l1 = __dfsan_label_info[label].l2 = 0;
+  __dfsan_label_info[label].desc = desc;
+  __dfsan_label_info[label].userdata = userdata;
+  return label;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __dfsan_set_label(dfsan_label label, void *addr, uptr size) {
+  for (dfsan_label *labelp = shadow_for(addr); size != 0; --size, ++labelp) {
+    // Don't write the label if it is already the value we need it to be.
+    // In a program where most addresses are not labeled, it is common that
+    // a page of shadow memory is entirely zeroed.  The Linux copy-on-write
+    // implementation will share all of the zeroed pages, making a copy of a
+    // page when any value is written.  The un-sharing will happen even if
+    // the value written does not change the value in memory.  Avoiding the
+    // write when both |label| and |*labelp| are zero dramatically reduces
+    // the amount of real memory used by large programs.
+    if (label == *labelp)
+      continue;
+
+    *labelp = label;
+  }
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void dfsan_set_label(dfsan_label label, void *addr, uptr size) {
+  __dfsan_set_label(label, addr, size);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void dfsan_add_label(dfsan_label label, void *addr, uptr size) {
+  for (dfsan_label *labelp = shadow_for(addr); size != 0; --size, ++labelp)
+    if (*labelp != label)
+      *labelp = __dfsan_union(*labelp, label);
+}
+
+// Unlike the other dfsan interface functions the behavior of this function
+// depends on the label of one of its arguments.  Hence it is implemented as a
+// custom function.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label
+__dfsw_dfsan_get_label(long data, dfsan_label data_label,
+                       dfsan_label *ret_label) {
+  *ret_label = 0;
+  return data_label;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE dfsan_label
+dfsan_read_label(const void *addr, uptr size) {
+  if (size == 0)
+    return 0;
+  return __dfsan_union_load(shadow_for(addr), size);
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+const struct dfsan_label_info *dfsan_get_label_info(dfsan_label label) {
+  return &__dfsan_label_info[label];
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE int
+dfsan_has_label(dfsan_label label, dfsan_label elem) {
+  if (label == elem)
+    return true;
+  const dfsan_label_info *info = dfsan_get_label_info(label);
+  if (info->l1 != 0) {
+    return dfsan_has_label(info->l1, elem) || dfsan_has_label(info->l2, elem);
+  } else {
+    return false;
+  }
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label
+dfsan_has_label_with_desc(dfsan_label label, const char *desc) {
+  const dfsan_label_info *info = dfsan_get_label_info(label);
+  if (info->l1 != 0) {
+    return dfsan_has_label_with_desc(info->l1, desc) ||
+           dfsan_has_label_with_desc(info->l2, desc);
+  } else {
+    return internal_strcmp(desc, info->desc) == 0;
+  }
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr
+dfsan_get_label_count(void) {
+  dfsan_label max_label_allocated =
+      atomic_load(&__dfsan_last_label, memory_order_relaxed);
+
+  return static_cast<uptr>(max_label_allocated);
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
+dfsan_dump_labels(int fd) {
+  dfsan_label last_label =
+      atomic_load(&__dfsan_last_label, memory_order_relaxed);
+
+  for (uptr l = 1; l <= last_label; ++l) {
+    char buf[64];
+    internal_snprintf(buf, sizeof(buf), "%u %u %u ", l,
+                      __dfsan_label_info[l].l1, __dfsan_label_info[l].l2);
+    WriteToFile(fd, buf, internal_strlen(buf));
+    if (__dfsan_label_info[l].l1 == 0 && __dfsan_label_info[l].desc) {
+      WriteToFile(fd, __dfsan_label_info[l].desc,
+                  internal_strlen(__dfsan_label_info[l].desc));
+    }
+    WriteToFile(fd, "\n", 1);
+  }
+}
+
+void Flags::SetDefaults() {
+#define DFSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "dfsan_flags.inc"
+#undef DFSAN_FLAG
+}
+
+static void RegisterDfsanFlags(FlagParser *parser, Flags *f) {
+#define DFSAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "dfsan_flags.inc"
+#undef DFSAN_FLAG
+}
+
+static void InitializeFlags() {
+  SetCommonFlagsDefaults();
+  flags().SetDefaults();
+
+  FlagParser parser;
+  RegisterCommonFlags(&parser);
+  RegisterDfsanFlags(&parser, &flags());
+  parser.ParseString(GetEnv("DFSAN_OPTIONS"));
+  SetVerbosity(common_flags()->verbosity);
+  if (Verbosity()) ReportUnrecognizedFlags();
+  if (common_flags()->help) parser.PrintFlagDescriptions();
+}
+
+static void InitializePlatformEarly() {
+#ifdef DFSAN_RUNTIME_VMA
+  __dfsan::vmaSize =
+    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
+  if (__dfsan::vmaSize == 39 || __dfsan::vmaSize == 42) {
+    __dfsan_shadow_ptr_mask = ShadowMask();
+  } else {
+    Printf("FATAL: DataFlowSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %d - Supported 39 and 42\n", __dfsan::vmaSize);
+    Die();
+  }
+#endif
+}
+
+static void dfsan_fini() {
+  if (internal_strcmp(flags().dump_labels_at_exit, "") != 0) {
+    fd_t fd = OpenFile(flags().dump_labels_at_exit, WrOnly);
+    if (fd == kInvalidFd) {
+      Report("WARNING: DataFlowSanitizer: unable to open output file %s\n",
+             flags().dump_labels_at_exit);
+      return;
+    }
+
+    Report("INFO: DataFlowSanitizer: dumping labels to %s\n",
+           flags().dump_labels_at_exit);
+    dfsan_dump_labels(fd);
+    CloseFile(fd);
+  }
+}
+
+static void dfsan_init(int argc, char **argv, char **envp) {
+  InitializeFlags();
+
+  InitializePlatformEarly();
+
+  MmapFixedNoReserve(ShadowAddr(), UnusedAddr() - ShadowAddr());
+
+  // Protect the region of memory we don't use, to preserve the one-to-one
+  // mapping from application to shadow memory. But if ASLR is disabled, Linux
+  // will load our executable in the middle of our unused region. This mostly
+  // works so long as the program doesn't use too much memory. We support this
+  // case by disabling memory protection when ASLR is disabled.
+  uptr init_addr = (uptr)&dfsan_init;
+  if (!(init_addr >= UnusedAddr() && init_addr < AppAddr()))
+    MmapNoAccess(UnusedAddr(), AppAddr() - UnusedAddr());
+
+  InitializeInterceptors();
+
+  // Register the fini callback to run when the program terminates successfully
+  // or it is killed by the runtime.
+  Atexit(dfsan_fini);
+  AddDieCallback(dfsan_fini);
+
+  __dfsan_label_info[kInitializingLabel].desc = "<init label>";
+}
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+__attribute__((section(".preinit_array"), used))
+static void (*dfsan_init_ptr)(int, char **, char **) = dfsan_init;
+#endif
diff --git a/compiler-rt/lib/dfsan/dfsan.h b/compiler-rt/lib/dfsan/dfsan.h
new file mode 100644
index 0000000..81f949e
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan.h
@@ -0,0 +1,70 @@
+//===-- dfsan.h -------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of DataFlowSanitizer.
+//
+// Private DFSan header.
+//===----------------------------------------------------------------------===//
+
+#ifndef DFSAN_H
+#define DFSAN_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "dfsan_platform.h"
+
+// Copy declarations from public sanitizer/dfsan_interface.h header here.
+typedef u16 dfsan_label;
+
+struct dfsan_label_info {
+  dfsan_label l1;
+  dfsan_label l2;
+  const char *desc;
+  void *userdata;
+};
+
+extern "C" {
+void dfsan_add_label(dfsan_label label, void *addr, uptr size);
+void dfsan_set_label(dfsan_label label, void *addr, uptr size);
+dfsan_label dfsan_read_label(const void *addr, uptr size);
+dfsan_label dfsan_union(dfsan_label l1, dfsan_label l2);
+}  // extern "C"
+
+template <typename T>
+void dfsan_set_label(dfsan_label label, T &data) {  // NOLINT
+  dfsan_set_label(label, (void *)&data, sizeof(T));
+}
+
+namespace __dfsan {
+
+void InitializeInterceptors();
+
+inline dfsan_label *shadow_for(void *ptr) {
+  return (dfsan_label *) ((((uptr) ptr) & ShadowMask()) << 1);
+}
+
+inline const dfsan_label *shadow_for(const void *ptr) {
+  return shadow_for(const_cast<void *>(ptr));
+}
+
+struct Flags {
+#define DFSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "dfsan_flags.inc"
+#undef DFSAN_FLAG
+
+  void SetDefaults();
+};
+
+extern Flags flags_data;
+inline Flags &flags() {
+  return flags_data;
+}
+
+}  // namespace __dfsan
+
+#endif  // DFSAN_H
diff --git a/compiler-rt/lib/dfsan/dfsan.syms.extra b/compiler-rt/lib/dfsan/dfsan.syms.extra
new file mode 100644
index 0000000..0d507ee
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan.syms.extra
@@ -0,0 +1,3 @@
+dfsan_*
+__dfsan_*
+__dfsw_*
diff --git a/compiler-rt/lib/dfsan/dfsan_custom.cc b/compiler-rt/lib/dfsan/dfsan_custom.cc
new file mode 100644
index 0000000..e0cd16a
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan_custom.cc
@@ -0,0 +1,1135 @@
+//===-- dfsan.cc ----------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of DataFlowSanitizer.
+//
+// This file defines the custom functions listed in done_abilist.txt.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_linux.h"
+
+#include "dfsan/dfsan.h"
+
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dlfcn.h>
+#include <link.h>
+#include <poll.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+using namespace __dfsan;
+
+#define CALL_WEAK_INTERCEPTOR_HOOK(f, ...)                                     \
+  do {                                                                         \
+    if (f)                                                                     \
+      f(__VA_ARGS__);                                                          \
+  } while (false)
+#define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...) \
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void f(__VA_ARGS__);
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE int
+__dfsw_stat(const char *path, struct stat *buf, dfsan_label path_label,
+            dfsan_label buf_label, dfsan_label *ret_label) {
+  int ret = stat(path, buf);
+  if (ret == 0)
+    dfsan_set_label(0, buf, sizeof(struct stat));
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fstat(int fd, struct stat *buf,
+                                               dfsan_label fd_label,
+                                               dfsan_label buf_label,
+                                               dfsan_label *ret_label) {
+  int ret = fstat(fd, buf);
+  if (ret == 0)
+    dfsan_set_label(0, buf, sizeof(struct stat));
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strchr(const char *s, int c,
+                                                  dfsan_label s_label,
+                                                  dfsan_label c_label,
+                                                  dfsan_label *ret_label) {
+  for (size_t i = 0;; ++i) {
+    if (s[i] == c || s[i] == 0) {
+      if (flags().strict_data_dependencies) {
+        *ret_label = s_label;
+      } else {
+        *ret_label = dfsan_union(dfsan_read_label(s, i + 1),
+                                 dfsan_union(s_label, c_label));
+      }
+      return s[i] == 0 ? nullptr : const_cast<char *>(s+i);
+    }
+  }
+}
+
+DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_memcmp, uptr caller_pc,
+                              const void *s1, const void *s2, size_t n,
+                              dfsan_label s1_label, dfsan_label s2_label,
+                              dfsan_label n_label)
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_memcmp(const void *s1, const void *s2,
+                                                size_t n, dfsan_label s1_label,
+                                                dfsan_label s2_label,
+                                                dfsan_label n_label,
+                                                dfsan_label *ret_label) {
+  CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_memcmp, GET_CALLER_PC(), s1, s2, n,
+                             s1_label, s2_label, n_label);
+  const char *cs1 = (const char *) s1, *cs2 = (const char *) s2;
+  for (size_t i = 0; i != n; ++i) {
+    if (cs1[i] != cs2[i]) {
+      if (flags().strict_data_dependencies) {
+        *ret_label = 0;
+      } else {
+        *ret_label = dfsan_union(dfsan_read_label(cs1, i + 1),
+                                 dfsan_read_label(cs2, i + 1));
+      }
+      return cs1[i] - cs2[i];
+    }
+  }
+
+  if (flags().strict_data_dependencies) {
+    *ret_label = 0;
+  } else {
+    *ret_label = dfsan_union(dfsan_read_label(cs1, n),
+                             dfsan_read_label(cs2, n));
+  }
+  return 0;
+}
+
+DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strcmp, uptr caller_pc,
+                              const char *s1, const char *s2,
+                              dfsan_label s1_label, dfsan_label s2_label)
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strcmp(const char *s1, const char *s2,
+                                                dfsan_label s1_label,
+                                                dfsan_label s2_label,
+                                                dfsan_label *ret_label) {
+  CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strcmp, GET_CALLER_PC(), s1, s2,
+                             s1_label, s2_label);
+  for (size_t i = 0;; ++i) {
+    if (s1[i] != s2[i] || s1[i] == 0 || s2[i] == 0) {
+      if (flags().strict_data_dependencies) {
+        *ret_label = 0;
+      } else {
+        *ret_label = dfsan_union(dfsan_read_label(s1, i + 1),
+                                 dfsan_read_label(s2, i + 1));
+      }
+      return s1[i] - s2[i];
+    }
+  }
+  return 0;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int
+__dfsw_strcasecmp(const char *s1, const char *s2, dfsan_label s1_label,
+                  dfsan_label s2_label, dfsan_label *ret_label) {
+  for (size_t i = 0;; ++i) {
+    if (tolower(s1[i]) != tolower(s2[i]) || s1[i] == 0 || s2[i] == 0) {
+      if (flags().strict_data_dependencies) {
+        *ret_label = 0;
+      } else {
+        *ret_label = dfsan_union(dfsan_read_label(s1, i + 1),
+                                 dfsan_read_label(s2, i + 1));
+      }
+      return s1[i] - s2[i];
+    }
+  }
+  return 0;
+}
+
+DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strncmp, uptr caller_pc,
+                              const char *s1, const char *s2, size_t n,
+                              dfsan_label s1_label, dfsan_label s2_label,
+                              dfsan_label n_label)
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strncmp(const char *s1, const char *s2,
+                                                 size_t n, dfsan_label s1_label,
+                                                 dfsan_label s2_label,
+                                                 dfsan_label n_label,
+                                                 dfsan_label *ret_label) {
+  if (n == 0) {
+    *ret_label = 0;
+    return 0;
+  }
+
+  CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strncmp, GET_CALLER_PC(), s1, s2,
+                             n, s1_label, s2_label, n_label);
+
+  for (size_t i = 0;; ++i) {
+    if (s1[i] != s2[i] || s1[i] == 0 || s2[i] == 0 || i == n - 1) {
+      if (flags().strict_data_dependencies) {
+        *ret_label = 0;
+      } else {
+        *ret_label = dfsan_union(dfsan_read_label(s1, i + 1),
+                                 dfsan_read_label(s2, i + 1));
+      }
+      return s1[i] - s2[i];
+    }
+  }
+  return 0;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int
+__dfsw_strncasecmp(const char *s1, const char *s2, size_t n,
+                   dfsan_label s1_label, dfsan_label s2_label,
+                   dfsan_label n_label, dfsan_label *ret_label) {
+  if (n == 0) {
+    *ret_label = 0;
+    return 0;
+  }
+
+  for (size_t i = 0;; ++i) {
+    if (tolower(s1[i]) != tolower(s2[i]) || s1[i] == 0 || s2[i] == 0 ||
+        i == n - 1) {
+      if (flags().strict_data_dependencies) {
+        *ret_label = 0;
+      } else {
+        *ret_label = dfsan_union(dfsan_read_label(s1, i + 1),
+                                 dfsan_read_label(s2, i + 1));
+      }
+      return s1[i] - s2[i];
+    }
+  }
+  return 0;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_calloc(size_t nmemb, size_t size,
+                                                  dfsan_label nmemb_label,
+                                                  dfsan_label size_label,
+                                                  dfsan_label *ret_label) {
+  void *p = calloc(nmemb, size);
+  dfsan_set_label(0, p, nmemb * size);
+  *ret_label = 0;
+  return p;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE size_t
+__dfsw_strlen(const char *s, dfsan_label s_label, dfsan_label *ret_label) {
+  size_t ret = strlen(s);
+  if (flags().strict_data_dependencies) {
+    *ret_label = 0;
+  } else {
+    *ret_label = dfsan_read_label(s, ret + 1);
+  }
+  return ret;
+}
+
+
+static void *dfsan_memcpy(void *dest, const void *src, size_t n) {
+  dfsan_label *sdest = shadow_for(dest);
+  const dfsan_label *ssrc = shadow_for(src);
+  internal_memcpy((void *)sdest, (const void *)ssrc, n * sizeof(dfsan_label));
+  return internal_memcpy(dest, src, n);
+}
+
+static void dfsan_memset(void *s, int c, dfsan_label c_label, size_t n) {
+  internal_memset(s, c, n);
+  dfsan_set_label(c_label, s, n);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__dfsw_memcpy(void *dest, const void *src, size_t n,
+                    dfsan_label dest_label, dfsan_label src_label,
+                    dfsan_label n_label, dfsan_label *ret_label) {
+  *ret_label = dest_label;
+  return dfsan_memcpy(dest, src, n);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__dfsw_memset(void *s, int c, size_t n,
+                    dfsan_label s_label, dfsan_label c_label,
+                    dfsan_label n_label, dfsan_label *ret_label) {
+  dfsan_memset(s, c, c_label, n);
+  *ret_label = s_label;
+  return s;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE char *
+__dfsw_strdup(const char *s, dfsan_label s_label, dfsan_label *ret_label) {
+  size_t len = strlen(s);
+  void *p = malloc(len+1);
+  dfsan_memcpy(p, s, len+1);
+  *ret_label = 0;
+  return static_cast<char *>(p);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE char *
+__dfsw_strncpy(char *s1, const char *s2, size_t n, dfsan_label s1_label,
+               dfsan_label s2_label, dfsan_label n_label,
+               dfsan_label *ret_label) {
+  size_t len = strlen(s2);
+  if (len < n) {
+    dfsan_memcpy(s1, s2, len+1);
+    dfsan_memset(s1+len+1, 0, 0, n-len-1);
+  } else {
+    dfsan_memcpy(s1, s2, n);
+  }
+
+  *ret_label = s1_label;
+  return s1;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE ssize_t
+__dfsw_pread(int fd, void *buf, size_t count, off_t offset,
+             dfsan_label fd_label, dfsan_label buf_label,
+             dfsan_label count_label, dfsan_label offset_label,
+             dfsan_label *ret_label) {
+  ssize_t ret = pread(fd, buf, count, offset);
+  if (ret > 0)
+    dfsan_set_label(0, buf, ret);
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE ssize_t
+__dfsw_read(int fd, void *buf, size_t count,
+             dfsan_label fd_label, dfsan_label buf_label,
+             dfsan_label count_label,
+             dfsan_label *ret_label) {
+  ssize_t ret = read(fd, buf, count);
+  if (ret > 0)
+    dfsan_set_label(0, buf, ret);
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_clock_gettime(clockid_t clk_id,
+                                                       struct timespec *tp,
+                                                       dfsan_label clk_id_label,
+                                                       dfsan_label tp_label,
+                                                       dfsan_label *ret_label) {
+  int ret = clock_gettime(clk_id, tp);
+  if (ret == 0)
+    dfsan_set_label(0, tp, sizeof(struct timespec));
+  *ret_label = 0;
+  return ret;
+}
+
+static void unpoison(const void *ptr, uptr size) {
+  dfsan_set_label(0, const_cast<void *>(ptr), size);
+}
+
+// dlopen() ultimately calls mmap() down inside the loader, which generally
+// doesn't participate in dynamic symbol resolution.  Therefore we won't
+// intercept its calls to mmap, and we have to hook it here.
+SANITIZER_INTERFACE_ATTRIBUTE void *
+__dfsw_dlopen(const char *filename, int flag, dfsan_label filename_label,
+              dfsan_label flag_label, dfsan_label *ret_label) {
+  void *handle = dlopen(filename, flag);
+  link_map *map = GET_LINK_MAP_BY_DLOPEN_HANDLE(handle);
+  if (map)
+    ForEachMappedRegion(map, unpoison);
+  *ret_label = 0;
+  return handle;
+}
+
+struct pthread_create_info {
+  void *(*start_routine_trampoline)(void *, void *, dfsan_label, dfsan_label *);
+  void *start_routine;
+  void *arg;
+};
+
+static void *pthread_create_cb(void *p) {
+  pthread_create_info pci(*(pthread_create_info *)p);
+  free(p);
+  dfsan_label ret_label;
+  return pci.start_routine_trampoline(pci.start_routine, pci.arg, 0,
+                                      &ret_label);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_pthread_create(
+    pthread_t *thread, const pthread_attr_t *attr,
+    void *(*start_routine_trampoline)(void *, void *, dfsan_label,
+                                      dfsan_label *),
+    void *start_routine, void *arg, dfsan_label thread_label,
+    dfsan_label attr_label, dfsan_label start_routine_label,
+    dfsan_label arg_label, dfsan_label *ret_label) {
+  pthread_create_info *pci =
+      (pthread_create_info *)malloc(sizeof(pthread_create_info));
+  pci->start_routine_trampoline = start_routine_trampoline;
+  pci->start_routine = start_routine;
+  pci->arg = arg;
+  int rv = pthread_create(thread, attr, pthread_create_cb, (void *)pci);
+  if (rv != 0)
+    free(pci);
+  *ret_label = 0;
+  return rv;
+}
+
+struct dl_iterate_phdr_info {
+  int (*callback_trampoline)(void *callback, struct dl_phdr_info *info,
+                             size_t size, void *data, dfsan_label info_label,
+                             dfsan_label size_label, dfsan_label data_label,
+                             dfsan_label *ret_label);
+  void *callback;
+  void *data;
+};
+
+int dl_iterate_phdr_cb(struct dl_phdr_info *info, size_t size, void *data) {
+  dl_iterate_phdr_info *dipi = (dl_iterate_phdr_info *)data;
+  dfsan_set_label(0, *info);
+  dfsan_set_label(0, const_cast<char *>(info->dlpi_name),
+                  strlen(info->dlpi_name) + 1);
+  dfsan_set_label(
+      0, const_cast<char *>(reinterpret_cast<const char *>(info->dlpi_phdr)),
+      sizeof(*info->dlpi_phdr) * info->dlpi_phnum);
+  dfsan_label ret_label;
+  return dipi->callback_trampoline(dipi->callback, info, size, dipi->data, 0, 0,
+                                   0, &ret_label);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_dl_iterate_phdr(
+    int (*callback_trampoline)(void *callback, struct dl_phdr_info *info,
+                               size_t size, void *data, dfsan_label info_label,
+                               dfsan_label size_label, dfsan_label data_label,
+                               dfsan_label *ret_label),
+    void *callback, void *data, dfsan_label callback_label,
+    dfsan_label data_label, dfsan_label *ret_label) {
+  dl_iterate_phdr_info dipi = { callback_trampoline, callback, data };
+  *ret_label = 0;
+  return dl_iterate_phdr(dl_iterate_phdr_cb, &dipi);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+char *__dfsw_ctime_r(const time_t *timep, char *buf, dfsan_label timep_label,
+                     dfsan_label buf_label, dfsan_label *ret_label) {
+  char *ret = ctime_r(timep, buf);
+  if (ret) {
+    dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), buf,
+                    strlen(buf) + 1);
+    *ret_label = buf_label;
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+char *__dfsw_fgets(char *s, int size, FILE *stream, dfsan_label s_label,
+                   dfsan_label size_label, dfsan_label stream_label,
+                   dfsan_label *ret_label) {
+  char *ret = fgets(s, size, stream);
+  if (ret) {
+    dfsan_set_label(0, ret, strlen(ret) + 1);
+    *ret_label = s_label;
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+char *__dfsw_getcwd(char *buf, size_t size, dfsan_label buf_label,
+                    dfsan_label size_label, dfsan_label *ret_label) {
+  char *ret = getcwd(buf, size);
+  if (ret) {
+    dfsan_set_label(0, ret, strlen(ret) + 1);
+    *ret_label = buf_label;
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+char *__dfsw_get_current_dir_name(dfsan_label *ret_label) {
+  char *ret = get_current_dir_name();
+  if (ret) {
+    dfsan_set_label(0, ret, strlen(ret) + 1);
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_gethostname(char *name, size_t len, dfsan_label name_label,
+                       dfsan_label len_label, dfsan_label *ret_label) {
+  int ret = gethostname(name, len);
+  if (ret == 0) {
+    dfsan_set_label(0, name, strlen(name) + 1);
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_getrlimit(int resource, struct rlimit *rlim,
+                     dfsan_label resource_label, dfsan_label rlim_label,
+                     dfsan_label *ret_label) {
+  int ret = getrlimit(resource, rlim);
+  if (ret == 0) {
+    dfsan_set_label(0, rlim, sizeof(struct rlimit));
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_getrusage(int who, struct rusage *usage, dfsan_label who_label,
+                     dfsan_label usage_label, dfsan_label *ret_label) {
+  int ret = getrusage(who, usage);
+  if (ret == 0) {
+    dfsan_set_label(0, usage, sizeof(struct rusage));
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+char *__dfsw_strcpy(char *dest, const char *src, dfsan_label dst_label,
+                    dfsan_label src_label, dfsan_label *ret_label) {
+  char *ret = strcpy(dest, src);
+  if (ret) {
+    internal_memcpy(shadow_for(dest), shadow_for(src),
+                    sizeof(dfsan_label) * (strlen(src) + 1));
+  }
+  *ret_label = dst_label;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+long int __dfsw_strtol(const char *nptr, char **endptr, int base,
+                       dfsan_label nptr_label, dfsan_label endptr_label,
+                       dfsan_label base_label, dfsan_label *ret_label) {
+  char *tmp_endptr;
+  long int ret = strtol(nptr, &tmp_endptr, base);
+  if (endptr) {
+    *endptr = tmp_endptr;
+  }
+  if (tmp_endptr > nptr) {
+    // If *tmp_endptr is '\0' include its label as well.
+    *ret_label = dfsan_union(
+        base_label,
+        dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1)));
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+double __dfsw_strtod(const char *nptr, char **endptr,
+                       dfsan_label nptr_label, dfsan_label endptr_label,
+                       dfsan_label *ret_label) {
+  char *tmp_endptr;
+  double ret = strtod(nptr, &tmp_endptr);
+  if (endptr) {
+    *endptr = tmp_endptr;
+  }
+  if (tmp_endptr > nptr) {
+    // If *tmp_endptr is '\0' include its label as well.
+    *ret_label = dfsan_read_label(
+        nptr,
+        tmp_endptr - nptr + (*tmp_endptr ? 0 : 1));
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+long long int __dfsw_strtoll(const char *nptr, char **endptr, int base,
+                       dfsan_label nptr_label, dfsan_label endptr_label,
+                       dfsan_label base_label, dfsan_label *ret_label) {
+  char *tmp_endptr;
+  long long int ret = strtoll(nptr, &tmp_endptr, base);
+  if (endptr) {
+    *endptr = tmp_endptr;
+  }
+  if (tmp_endptr > nptr) {
+    // If *tmp_endptr is '\0' include its label as well.
+    *ret_label = dfsan_union(
+        base_label,
+        dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1)));
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+unsigned long int __dfsw_strtoul(const char *nptr, char **endptr, int base,
+                       dfsan_label nptr_label, dfsan_label endptr_label,
+                       dfsan_label base_label, dfsan_label *ret_label) {
+  char *tmp_endptr;
+  unsigned long int ret = strtoul(nptr, &tmp_endptr, base);
+  if (endptr) {
+    *endptr = tmp_endptr;
+  }
+  if (tmp_endptr > nptr) {
+    // If *tmp_endptr is '\0' include its label as well.
+    *ret_label = dfsan_union(
+        base_label,
+        dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1)));
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+long long unsigned int __dfsw_strtoull(const char *nptr, char **endptr,
+                                       dfsan_label nptr_label,
+                                       int base, dfsan_label endptr_label,
+                                       dfsan_label base_label,
+                                       dfsan_label *ret_label) {
+  char *tmp_endptr;
+  long long unsigned int ret = strtoull(nptr, &tmp_endptr, base);
+  if (endptr) {
+    *endptr = tmp_endptr;
+  }
+  if (tmp_endptr > nptr) {
+    // If *tmp_endptr is '\0' include its label as well.
+    *ret_label = dfsan_union(
+        base_label,
+        dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1)));
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+time_t __dfsw_time(time_t *t, dfsan_label t_label, dfsan_label *ret_label) {
+  time_t ret = time(t);
+  if (ret != (time_t) -1 && t) {
+    dfsan_set_label(0, t, sizeof(time_t));
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_inet_pton(int af, const char *src, void *dst, dfsan_label af_label,
+                     dfsan_label src_label, dfsan_label dst_label,
+                     dfsan_label *ret_label) {
+  int ret = inet_pton(af, src, dst);
+  if (ret == 1) {
+    dfsan_set_label(dfsan_read_label(src, strlen(src) + 1), dst,
+                    af == AF_INET ? sizeof(struct in_addr) : sizeof(in6_addr));
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+struct tm *__dfsw_localtime_r(const time_t *timep, struct tm *result,
+                              dfsan_label timep_label, dfsan_label result_label,
+                              dfsan_label *ret_label) {
+  struct tm *ret = localtime_r(timep, result);
+  if (ret) {
+    dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), result,
+                    sizeof(struct tm));
+    *ret_label = result_label;
+  } else {
+    *ret_label = 0;
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_getpwuid_r(id_t uid, struct passwd *pwd,
+                      char *buf, size_t buflen, struct passwd **result,
+                      dfsan_label uid_label, dfsan_label pwd_label,
+                      dfsan_label buf_label, dfsan_label buflen_label,
+                      dfsan_label result_label, dfsan_label *ret_label) {
+  // Store the data in pwd, the strings referenced from pwd in buf, and the
+  // address of pwd in *result.  On failure, NULL is stored in *result.
+  int ret = getpwuid_r(uid, pwd, buf, buflen, result);
+  if (ret == 0) {
+    dfsan_set_label(0, pwd, sizeof(struct passwd));
+    dfsan_set_label(0, buf, strlen(buf) + 1);
+  }
+  *ret_label = 0;
+  dfsan_set_label(0, result, sizeof(struct passwd*));
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_poll(struct pollfd *fds, nfds_t nfds, int timeout,
+                dfsan_label dfs_label, dfsan_label nfds_label,
+                dfsan_label timeout_label, dfsan_label *ret_label) {
+  int ret = poll(fds, nfds, timeout);
+  if (ret >= 0) {
+    for (; nfds > 0; --nfds) {
+      dfsan_set_label(0, &fds[nfds - 1].revents, sizeof(fds[nfds - 1].revents));
+    }
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_select(int nfds, fd_set *readfds, fd_set *writefds,
+                  fd_set *exceptfds, struct timeval *timeout,
+                  dfsan_label nfds_label, dfsan_label readfds_label,
+                  dfsan_label writefds_label, dfsan_label exceptfds_label,
+                  dfsan_label timeout_label, dfsan_label *ret_label) {
+  int ret = select(nfds, readfds, writefds, exceptfds, timeout);
+  // Clear everything (also on error) since their content is either set or
+  // undefined.
+  if (readfds) {
+    dfsan_set_label(0, readfds, sizeof(fd_set));
+  }
+  if (writefds) {
+    dfsan_set_label(0, writefds, sizeof(fd_set));
+  }
+  if (exceptfds) {
+    dfsan_set_label(0, exceptfds, sizeof(fd_set));
+  }
+  dfsan_set_label(0, timeout, sizeof(struct timeval));
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask,
+                             dfsan_label pid_label,
+                             dfsan_label cpusetsize_label,
+                             dfsan_label mask_label, dfsan_label *ret_label) {
+  int ret = sched_getaffinity(pid, cpusetsize, mask);
+  if (ret == 0) {
+    dfsan_set_label(0, mask, cpusetsize);
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_sigemptyset(sigset_t *set, dfsan_label set_label,
+                       dfsan_label *ret_label) {
+  int ret = sigemptyset(set);
+  dfsan_set_label(0, set, sizeof(sigset_t));
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_sigaction(int signum, const struct sigaction *act,
+                     struct sigaction *oldact, dfsan_label signum_label,
+                     dfsan_label act_label, dfsan_label oldact_label,
+                     dfsan_label *ret_label) {
+  int ret = sigaction(signum, act, oldact);
+  if (oldact) {
+    dfsan_set_label(0, oldact, sizeof(struct sigaction));
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_gettimeofday(struct timeval *tv, struct timezone *tz,
+                        dfsan_label tv_label, dfsan_label tz_label,
+                        dfsan_label *ret_label) {
+  int ret = gettimeofday(tv, tz);
+  if (tv) {
+    dfsan_set_label(0, tv, sizeof(struct timeval));
+  }
+  if (tz) {
+    dfsan_set_label(0, tz, sizeof(struct timezone));
+  }
+  *ret_label = 0;
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memchr(void *s, int c, size_t n,
+                                                  dfsan_label s_label,
+                                                  dfsan_label c_label,
+                                                  dfsan_label n_label,
+                                                  dfsan_label *ret_label) {
+  void *ret = memchr(s, c, n);
+  if (flags().strict_data_dependencies) {
+    *ret_label = ret ? s_label : 0;
+  } else {
+    size_t len =
+        ret ? reinterpret_cast<char *>(ret) - reinterpret_cast<char *>(s) + 1
+            : n;
+    *ret_label =
+        dfsan_union(dfsan_read_label(s, len), dfsan_union(s_label, c_label));
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strrchr(char *s, int c,
+                                                   dfsan_label s_label,
+                                                   dfsan_label c_label,
+                                                   dfsan_label *ret_label) {
+  char *ret = strrchr(s, c);
+  if (flags().strict_data_dependencies) {
+    *ret_label = ret ? s_label : 0;
+  } else {
+    *ret_label =
+        dfsan_union(dfsan_read_label(s, strlen(s) + 1),
+                    dfsan_union(s_label, c_label));
+  }
+
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strstr(char *haystack, char *needle,
+                                                  dfsan_label haystack_label,
+                                                  dfsan_label needle_label,
+                                                  dfsan_label *ret_label) {
+  char *ret = strstr(haystack, needle);
+  if (flags().strict_data_dependencies) {
+    *ret_label = ret ? haystack_label : 0;
+  } else {
+    size_t len = ret ? ret + strlen(needle) - haystack : strlen(haystack) + 1;
+    *ret_label =
+        dfsan_union(dfsan_read_label(haystack, len),
+                    dfsan_union(dfsan_read_label(needle, strlen(needle) + 1),
+                                dfsan_union(haystack_label, needle_label)));
+  }
+
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_nanosleep(const struct timespec *req,
+                                                   struct timespec *rem,
+                                                   dfsan_label req_label,
+                                                   dfsan_label rem_label,
+                                                   dfsan_label *ret_label) {
+  int ret = nanosleep(req, rem);
+  *ret_label = 0;
+  if (ret == -1) {
+    // Interrupted by a signal, rem is filled with the remaining time.
+    dfsan_set_label(0, rem, sizeof(struct timespec));
+  }
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int
+__dfsw_socketpair(int domain, int type, int protocol, int sv[2],
+                  dfsan_label domain_label, dfsan_label type_label,
+                  dfsan_label protocol_label, dfsan_label sv_label,
+                  dfsan_label *ret_label) {
+  int ret = socketpair(domain, type, protocol, sv);
+  *ret_label = 0;
+  if (ret == 0) {
+    dfsan_set_label(0, sv, sizeof(*sv) * 2);
+  }
+  return ret;
+}
+
+// Type of the trampoline function passed to the custom version of
+// dfsan_set_write_callback.
+typedef void (*write_trampoline_t)(
+    void *callback,
+    int fd, const void *buf, ssize_t count,
+    dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label);
+
+// Calls to dfsan_set_write_callback() set the values in this struct.
+// Calls to the custom version of write() read (and invoke) them.
+static struct {
+  write_trampoline_t write_callback_trampoline = nullptr;
+  void *write_callback = nullptr;
+} write_callback_info;
+
+SANITIZER_INTERFACE_ATTRIBUTE void
+__dfsw_dfsan_set_write_callback(
+    write_trampoline_t write_callback_trampoline,
+    void *write_callback,
+    dfsan_label write_callback_label,
+    dfsan_label *ret_label) {
+  write_callback_info.write_callback_trampoline = write_callback_trampoline;
+  write_callback_info.write_callback = write_callback;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE int
+__dfsw_write(int fd, const void *buf, size_t count,
+             dfsan_label fd_label, dfsan_label buf_label,
+             dfsan_label count_label, dfsan_label *ret_label) {
+  if (write_callback_info.write_callback) {
+    write_callback_info.write_callback_trampoline(
+        write_callback_info.write_callback,
+        fd, buf, count,
+        fd_label, buf_label, count_label);
+  }
+
+  *ret_label = 0;
+  return write(fd, buf, count);
+}
+} // namespace __dfsan
+
+// Type used to extract a dfsan_label with va_arg()
+typedef int dfsan_label_va;
+
+// Formats a chunk either a constant string or a single format directive (e.g.,
+// '%.3f').
+struct Formatter {
+  Formatter(char *str_, const char *fmt_, size_t size_)
+      : str(str_), str_off(0), size(size_), fmt_start(fmt_), fmt_cur(fmt_),
+        width(-1) {}
+
+  int format() {
+    char *tmp_fmt = build_format_string();
+    int retval =
+        snprintf(str + str_off, str_off < size ? size - str_off : 0, tmp_fmt,
+                 0 /* used only to avoid warnings */);
+    free(tmp_fmt);
+    return retval;
+  }
+
+  template <typename T> int format(T arg) {
+    char *tmp_fmt = build_format_string();
+    int retval;
+    if (width >= 0) {
+      retval = snprintf(str + str_off, str_off < size ? size - str_off : 0,
+                        tmp_fmt, width, arg);
+    } else {
+      retval = snprintf(str + str_off, str_off < size ? size - str_off : 0,
+                        tmp_fmt, arg);
+    }
+    free(tmp_fmt);
+    return retval;
+  }
+
+  char *build_format_string() {
+    size_t fmt_size = fmt_cur - fmt_start + 1;
+    char *new_fmt = (char *)malloc(fmt_size + 1);
+    assert(new_fmt);
+    internal_memcpy(new_fmt, fmt_start, fmt_size);
+    new_fmt[fmt_size] = '\0';
+    return new_fmt;
+  }
+
+  char *str_cur() { return str + str_off; }
+
+  size_t num_written_bytes(int retval) {
+    if (retval < 0) {
+      return 0;
+    }
+
+    size_t num_avail = str_off < size ? size - str_off : 0;
+    if (num_avail == 0) {
+      return 0;
+    }
+
+    size_t num_written = retval;
+    // A return value of {v,}snprintf of size or more means that the output was
+    // truncated.
+    if (num_written >= num_avail) {
+      num_written -= num_avail;
+    }
+
+    return num_written;
+  }
+
+  char *str;
+  size_t str_off;
+  size_t size;
+  const char *fmt_start;
+  const char *fmt_cur;
+  int width;
+};
+
+// Formats the input and propagates the input labels to the output. The output
+// is stored in 'str'. 'size' bounds the number of output bytes. 'format' and
+// 'ap' are the format string and the list of arguments for formatting. Returns
+// the return value vsnprintf would return.
+//
+// The function tokenizes the format string in chunks representing either a
+// constant string or a single format directive (e.g., '%.3f') and formats each
+// chunk independently into the output string. This approach allows to figure
+// out which bytes of the output string depends on which argument and thus to
+// propagate labels more precisely.
+//
+// WARNING: This implementation does not support conversion specifiers with
+// positional arguments.
+static int format_buffer(char *str, size_t size, const char *fmt,
+                         dfsan_label *va_labels, dfsan_label *ret_label,
+                         va_list ap) {
+  Formatter formatter(str, fmt, size);
+
+  while (*formatter.fmt_cur) {
+    formatter.fmt_start = formatter.fmt_cur;
+    formatter.width = -1;
+    int retval = 0;
+
+    if (*formatter.fmt_cur != '%') {
+      // Ordinary character. Consume all the characters until a '%' or the end
+      // of the string.
+      for (; *(formatter.fmt_cur + 1) && *(formatter.fmt_cur + 1) != '%';
+           ++formatter.fmt_cur) {}
+      retval = formatter.format();
+      dfsan_set_label(0, formatter.str_cur(),
+                      formatter.num_written_bytes(retval));
+    } else {
+      // Conversion directive. Consume all the characters until a conversion
+      // specifier or the end of the string.
+      bool end_fmt = false;
+      for (; *formatter.fmt_cur && !end_fmt; ) {
+        switch (*++formatter.fmt_cur) {
+        case 'd':
+        case 'i':
+        case 'o':
+        case 'u':
+        case 'x':
+        case 'X':
+          switch (*(formatter.fmt_cur - 1)) {
+          case 'h':
+            // Also covers the 'hh' case (since the size of the arg is still
+            // an int).
+            retval = formatter.format(va_arg(ap, int));
+            break;
+          case 'l':
+            if (formatter.fmt_cur - formatter.fmt_start >= 2 &&
+                *(formatter.fmt_cur - 2) == 'l') {
+              retval = formatter.format(va_arg(ap, long long int));
+            } else {
+              retval = formatter.format(va_arg(ap, long int));
+            }
+            break;
+          case 'q':
+            retval = formatter.format(va_arg(ap, long long int));
+            break;
+          case 'j':
+            retval = formatter.format(va_arg(ap, intmax_t));
+            break;
+          case 'z':
+          case 't':
+            retval = formatter.format(va_arg(ap, size_t));
+            break;
+          default:
+            retval = formatter.format(va_arg(ap, int));
+          }
+          dfsan_set_label(*va_labels++, formatter.str_cur(),
+                          formatter.num_written_bytes(retval));
+          end_fmt = true;
+          break;
+
+        case 'a':
+        case 'A':
+        case 'e':
+        case 'E':
+        case 'f':
+        case 'F':
+        case 'g':
+        case 'G':
+          if (*(formatter.fmt_cur - 1) == 'L') {
+            retval = formatter.format(va_arg(ap, long double));
+          } else {
+            retval = formatter.format(va_arg(ap, double));
+          }
+          dfsan_set_label(*va_labels++, formatter.str_cur(),
+                          formatter.num_written_bytes(retval));
+          end_fmt = true;
+          break;
+
+        case 'c':
+          retval = formatter.format(va_arg(ap, int));
+          dfsan_set_label(*va_labels++, formatter.str_cur(),
+                          formatter.num_written_bytes(retval));
+          end_fmt = true;
+          break;
+
+        case 's': {
+          char *arg = va_arg(ap, char *);
+          retval = formatter.format(arg);
+          va_labels++;
+          internal_memcpy(shadow_for(formatter.str_cur()), shadow_for(arg),
+                          sizeof(dfsan_label) *
+                              formatter.num_written_bytes(retval));
+          end_fmt = true;
+          break;
+        }
+
+        case 'p':
+          retval = formatter.format(va_arg(ap, void *));
+          dfsan_set_label(*va_labels++, formatter.str_cur(),
+                          formatter.num_written_bytes(retval));
+          end_fmt = true;
+          break;
+
+        case 'n': {
+          int *ptr = va_arg(ap, int *);
+          *ptr = (int)formatter.str_off;
+          va_labels++;
+          dfsan_set_label(0, ptr, sizeof(ptr));
+          end_fmt = true;
+          break;
+        }
+
+        case '%':
+          retval = formatter.format();
+          dfsan_set_label(0, formatter.str_cur(),
+                          formatter.num_written_bytes(retval));
+          end_fmt = true;
+          break;
+
+        case '*':
+          formatter.width = va_arg(ap, int);
+          va_labels++;
+          break;
+
+        default:
+          break;
+        }
+      }
+    }
+
+    if (retval < 0) {
+      return retval;
+    }
+
+    formatter.fmt_cur++;
+    formatter.str_off += retval;
+  }
+
+  *ret_label = 0;
+
+  // Number of bytes written in total.
+  return formatter.str_off;
+}
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_sprintf(char *str, const char *format, dfsan_label str_label,
+                   dfsan_label format_label, dfsan_label *va_labels,
+                   dfsan_label *ret_label, ...) {
+  va_list ap;
+  va_start(ap, ret_label);
+  int ret = format_buffer(str, ~0ul, format, va_labels, ret_label, ap);
+  va_end(ap);
+  return ret;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __dfsw_snprintf(char *str, size_t size, const char *format,
+                    dfsan_label str_label, dfsan_label size_label,
+                    dfsan_label format_label, dfsan_label *va_labels,
+                    dfsan_label *ret_label, ...) {
+  va_list ap;
+  va_start(ap, ret_label);
+  int ret = format_buffer(str, size, format, va_labels, ret_label, ap);
+  va_end(ap);
+  return ret;
+}
+} // extern "C"
diff --git a/compiler-rt/lib/dfsan/dfsan_flags.inc b/compiler-rt/lib/dfsan/dfsan_flags.inc
new file mode 100644
index 0000000..24fbfcb
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan_flags.inc
@@ -0,0 +1,32 @@
+//===-- dfsan_flags.inc -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// DFSan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef DFSAN_FLAG
+# error "Define DFSAN_FLAG prior to including this file!"
+#endif
+
+// DFSAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+DFSAN_FLAG(bool, warn_unimplemented, true,
+           "Whether to warn on unimplemented functions.")
+DFSAN_FLAG(bool, warn_nonzero_labels, false,
+           "Whether to warn on unimplemented functions.")
+DFSAN_FLAG(
+    bool, strict_data_dependencies, true,
+    "Whether to propagate labels only when there is an obvious data dependency"
+    "(e.g., when comparing strings, ignore the fact that the output of the"
+    "comparison might be data-dependent on the content of the strings). This"
+    "applies only to the custom functions defined in 'custom.c'.")
+DFSAN_FLAG(const char *, dump_labels_at_exit, "", "The path of the file where "
+                                                  "to dump the labels when the "
+                                                  "program terminates.")
diff --git a/compiler-rt/lib/dfsan/dfsan_interceptors.cc b/compiler-rt/lib/dfsan/dfsan_interceptors.cc
new file mode 100644
index 0000000..8b7d64e
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan_interceptors.cc
@@ -0,0 +1,44 @@
+//===-- dfsan_interceptors.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of DataFlowSanitizer.
+//
+// Interceptors for standard library functions.
+//===----------------------------------------------------------------------===//
+
+#include "dfsan/dfsan.h"
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+INTERCEPTOR(void *, mmap, void *addr, SIZE_T length, int prot, int flags,
+            int fd, OFF_T offset) {
+  void *res = REAL(mmap)(addr, length, prot, flags, fd, offset);
+  if (res != (void*)-1)
+    dfsan_set_label(0, res, RoundUpTo(length, GetPageSize()));
+  return res;
+}
+
+INTERCEPTOR(void *, mmap64, void *addr, SIZE_T length, int prot, int flags,
+            int fd, OFF64_T offset) {
+  void *res = REAL(mmap64)(addr, length, prot, flags, fd, offset);
+  if (res != (void*)-1)
+    dfsan_set_label(0, res, RoundUpTo(length, GetPageSize()));
+  return res;
+}
+
+namespace __dfsan {
+void InitializeInterceptors() {
+  static int inited = 0;
+  CHECK_EQ(inited, 0);
+
+  INTERCEPT_FUNCTION(mmap);
+  INTERCEPT_FUNCTION(mmap64);
+  inited = 1;
+}
+}  // namespace __dfsan
diff --git a/compiler-rt/lib/dfsan/dfsan_platform.h b/compiler-rt/lib/dfsan/dfsan_platform.h
new file mode 100644
index 0000000..f1d9f10
--- /dev/null
+++ b/compiler-rt/lib/dfsan/dfsan_platform.h
@@ -0,0 +1,107 @@
+//===-- dfsan_platform.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of DataFlowSanitizer.
+//
+// Platform specific information for DFSan.
+//===----------------------------------------------------------------------===//
+
+#ifndef DFSAN_PLATFORM_H
+#define DFSAN_PLATFORM_H
+
+namespace __dfsan {
+
+#if defined(__x86_64__)
+struct Mapping {
+  static const uptr kShadowAddr = 0x10000;
+  static const uptr kUnionTableAddr = 0x200000000000;
+  static const uptr kAppAddr = 0x700000008000;
+  static const uptr kShadowMask = ~0x700000000000;
+};
+#elif defined(__mips64)
+struct Mapping {
+  static const uptr kShadowAddr = 0x10000;
+  static const uptr kUnionTableAddr = 0x2000000000;
+  static const uptr kAppAddr = 0xF000008000;
+  static const uptr kShadowMask = ~0xF000000000;
+};
+#elif defined(__aarch64__)
+struct Mapping39 {
+  static const uptr kShadowAddr = 0x10000;
+  static const uptr kUnionTableAddr = 0x1000000000;
+  static const uptr kAppAddr = 0x7000008000;
+  static const uptr kShadowMask = ~0x7800000000;
+};
+
+struct Mapping42 {
+  static const uptr kShadowAddr = 0x10000;
+  static const uptr kUnionTableAddr = 0x8000000000;
+  static const uptr kAppAddr = 0x3ff00008000;
+  static const uptr kShadowMask = ~0x3c000000000;
+};
+
+extern int vmaSize;
+# define DFSAN_RUNTIME_VMA 1
+#else
+# error "DFSan not supported for this platform!"
+#endif
+
+enum MappingType {
+  MAPPING_SHADOW_ADDR,
+  MAPPING_UNION_TABLE_ADDR,
+  MAPPING_APP_ADDR,
+  MAPPING_SHADOW_MASK
+};
+
+template<typename Mapping, int Type>
+uptr MappingImpl(void) {
+  switch (Type) {
+    case MAPPING_SHADOW_ADDR: return Mapping::kShadowAddr;
+    case MAPPING_UNION_TABLE_ADDR: return Mapping::kUnionTableAddr;
+    case MAPPING_APP_ADDR: return Mapping::kAppAddr;
+    case MAPPING_SHADOW_MASK: return Mapping::kShadowMask;
+  }
+}
+
+template<int Type>
+uptr MappingArchImpl(void) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return MappingImpl<Mapping39, Type>();
+  else
+    return MappingImpl<Mapping42, Type>();
+  DCHECK(0);
+#else
+  return MappingImpl<Mapping, Type>();
+#endif
+}
+
+ALWAYS_INLINE
+uptr ShadowAddr() {
+  return MappingArchImpl<MAPPING_SHADOW_ADDR>();
+}
+
+ALWAYS_INLINE
+uptr UnionTableAddr() {
+  return MappingArchImpl<MAPPING_UNION_TABLE_ADDR>();
+}
+
+ALWAYS_INLINE
+uptr AppAddr() {
+  return MappingArchImpl<MAPPING_APP_ADDR>();
+}
+
+ALWAYS_INLINE
+uptr ShadowMask() {
+  return MappingArchImpl<MAPPING_SHADOW_MASK>();
+}
+
+}  // namespace __dfsan
+
+#endif
diff --git a/compiler-rt/lib/dfsan/done_abilist.txt b/compiler-rt/lib/dfsan/done_abilist.txt
new file mode 100644
index 0000000..7ca8aeb
--- /dev/null
+++ b/compiler-rt/lib/dfsan/done_abilist.txt
@@ -0,0 +1,306 @@
+fun:main=uninstrumented
+fun:main=discard
+
+###############################################################################
+# DFSan interface functions
+###############################################################################
+fun:dfsan_union=uninstrumented
+fun:dfsan_union=discard
+fun:dfsan_create_label=uninstrumented
+fun:dfsan_create_label=discard
+fun:dfsan_set_label=uninstrumented
+fun:dfsan_set_label=discard
+fun:dfsan_add_label=uninstrumented
+fun:dfsan_add_label=discard
+fun:dfsan_get_label=uninstrumented
+fun:dfsan_get_label=custom
+fun:dfsan_read_label=uninstrumented
+fun:dfsan_read_label=discard
+fun:dfsan_get_label_count=uninstrumented
+fun:dfsan_get_label_count=discard
+fun:dfsan_get_label_info=uninstrumented
+fun:dfsan_get_label_info=discard
+fun:dfsan_has_label=uninstrumented
+fun:dfsan_has_label=discard
+fun:dfsan_has_label_with_desc=uninstrumented
+fun:dfsan_has_label_with_desc=discard
+fun:dfsan_set_write_callback=uninstrumented
+fun:dfsan_set_write_callback=custom
+
+###############################################################################
+# glibc
+###############################################################################
+fun:malloc=discard
+fun:realloc=discard
+fun:free=discard
+
+# Functions that return a value that depends on the input, but the output might
+# not be necessarily data-dependent on the input.
+fun:isalpha=functional
+fun:isdigit=functional
+fun:isprint=functional
+fun:isxdigit=functional
+fun:isalnum=functional
+fun:ispunct=functional
+fun:isspace=functional
+fun:tolower=functional
+fun:toupper=functional
+
+# Functions that return a value that is data-dependent on the input.
+fun:btowc=functional
+fun:exp=functional
+fun:exp2=functional
+fun:fabs=functional
+fun:finite=functional
+fun:floor=functional
+fun:fmod=functional
+fun:isinf=functional
+fun:isnan=functional
+fun:log=functional
+fun:modf=functional
+fun:pow=functional
+fun:round=functional
+fun:sqrt=functional
+fun:wctob=functional
+
+# Functions that produce an output that does not depend on the input (shadow is
+# zeroed automatically).
+fun:__assert_fail=discard
+fun:__ctype_b_loc=discard
+fun:__cxa_atexit=discard
+fun:__errno_location=discard
+fun:__newlocale=discard
+fun:__sbrk=discard
+fun:__sigsetjmp=discard
+fun:__uselocale=discard
+fun:__wctype_l=discard
+fun:access=discard
+fun:alarm=discard
+fun:atexit=discard
+fun:bind=discard
+fun:chdir=discard
+fun:close=discard
+fun:closedir=discard
+fun:connect=discard
+fun:dladdr=discard
+fun:dlclose=discard
+fun:fclose=discard
+fun:feof=discard
+fun:ferror=discard
+fun:fflush=discard
+fun:fileno=discard
+fun:fopen=discard
+fun:fprintf=discard
+fun:fputc=discard
+fun:fputc=discard
+fun:fputs=discard
+fun:fputs=discard
+fun:fseek=discard
+fun:ftell=discard
+fun:fwrite=discard
+fun:getenv=discard
+fun:getuid=discard
+fun:geteuid=discard
+fun:getpagesize=discard
+fun:getpid=discard
+fun:kill=discard
+fun:listen=discard
+fun:lseek=discard
+fun:mkdir=discard
+fun:mmap=discard
+fun:munmap=discard
+fun:open=discard
+fun:pipe=discard
+fun:posix_fadvise=discard
+fun:posix_memalign=discard
+fun:prctl=discard
+fun:printf=discard
+fun:pthread_sigmask=discard
+fun:putc=discard
+fun:putchar=discard
+fun:puts=discard
+fun:rand=discard
+fun:random=discard
+fun:remove=discard
+fun:sched_getcpu=discard
+fun:sched_get_priority_max=discard
+fun:sched_setaffinity=discard
+fun:sched_yield=discard
+fun:sem_destroy=discard
+fun:sem_init=discard
+fun:sem_post=discard
+fun:sem_wait=discard
+fun:send=discard
+fun:sendmsg=discard
+fun:sendto=discard
+fun:setsockopt=discard
+fun:shutdown=discard
+fun:sleep=discard
+fun:socket=discard
+fun:strerror=discard
+fun:strspn=discard
+fun:strcspn=discard
+fun:symlink=discard
+fun:syscall=discard
+fun:unlink=discard
+fun:uselocale=discard
+
+# Functions that produce output does not depend on the input (need to zero the
+# shadow manually).
+fun:calloc=custom
+fun:clock_gettime=custom
+fun:dlopen=custom
+fun:fgets=custom
+fun:fstat=custom
+fun:getcwd=custom
+fun:get_current_dir_name=custom
+fun:gethostname=custom
+fun:getrlimit=custom
+fun:getrusage=custom
+fun:nanosleep=custom
+fun:pread=custom
+fun:read=custom
+fun:socketpair=custom
+fun:stat=custom
+fun:time=custom
+
+# Functions that produce an output that depend on the input (propagate the
+# shadow manually).
+fun:ctime_r=custom
+fun:inet_pton=custom
+fun:localtime_r=custom
+fun:memcpy=custom
+fun:memset=custom
+fun:strcpy=custom
+fun:strdup=custom
+fun:strncpy=custom
+fun:strtod=custom
+fun:strtol=custom
+fun:strtoll=custom
+fun:strtoul=custom
+fun:strtoull=custom
+
+# Functions that produce an output that is computed from the input, but is not
+# necessarily data dependent.
+fun:memchr=custom
+fun:memcmp=custom
+fun:strcasecmp=custom
+fun:strchr=custom
+fun:strcmp=custom
+fun:strlen=custom
+fun:strncasecmp=custom
+fun:strncmp=custom
+fun:strrchr=custom
+fun:strstr=custom
+
+# Functions which take action based on global state, such as running a callback
+# set by a sepperate function.
+fun:write=custom
+
+# Functions that take a callback (wrap the callback manually).
+fun:dl_iterate_phdr=custom
+
+fun:getpwuid_r=custom
+fun:poll=custom
+fun:sched_getaffinity=custom
+fun:select=custom
+fun:sigemptyset=custom
+fun:sigaction=custom
+fun:gettimeofday=custom
+
+# sprintf-like
+fun:sprintf=custom
+fun:snprintf=custom
+
+# TODO: custom
+fun:asprintf=discard
+fun:qsort=discard
+
+###############################################################################
+# pthread
+###############################################################################
+fun:pthread_equal=discard
+fun:pthread_getspecific=discard
+fun:pthread_key_create=discard
+fun:pthread_key_delete=discard
+fun:pthread_mutex_destroy=discard
+fun:pthread_mutex_init=discard
+fun:pthread_mutex_lock=discard
+fun:pthread_mutex_trylock=discard
+fun:pthread_mutex_unlock=discard
+fun:pthread_mutexattr_destroy=discard
+fun:pthread_mutexattr_init=discard
+fun:pthread_mutexattr_settype=discard
+fun:pthread_once=discard
+fun:pthread_self=discard
+fun:pthread_setspecific=discard
+
+# Functions that take a callback (wrap the callback manually).
+fun:pthread_create=custom
+
+###############################################################################
+# libffi/libgo
+###############################################################################
+# Functions that are written in asm or are called from asm.
+fun:ffi_call_unix64=uninstrumented
+fun:ffi_call_unix64=discard
+fun:ffi_closure_unix64_inner=uninstrumented
+fun:ffi_closure_unix64_inner=discard
+fun:ffi_closure_unix64=uninstrumented
+fun:ffi_closure_unix64=discard
+fun:__go_get_closure=uninstrumented
+fun:__go_get_closure=discard
+fun:__go_makefunc_can_recover=uninstrumented
+fun:__go_makefunc_can_recover=discard
+fun:__go_makefunc_returning=uninstrumented
+fun:__go_makefunc_returning=discard
+fun:reflect.MakeFuncStubGo=uninstrumented
+fun:reflect.MakeFuncStubGo=discard
+fun:reflect.makeFuncStub=uninstrumented
+fun:reflect.makeFuncStub=discard
+
+
+###############################################################################
+# lib/Fuzzer
+###############################################################################
+# Replaces __sanitizer_cov_trace_cmp with __dfsw___sanitizer_cov_trace_cmp
+fun:__sanitizer_cov_trace_cmp=custom
+fun:__sanitizer_cov_trace_cmp=uninstrumented
+# Similar for __sanitizer_cov_trace_switch
+fun:__sanitizer_cov_trace_switch=custom
+fun:__sanitizer_cov_trace_switch=uninstrumented
+
+# Ignores all other __sanitizer callbacks.
+fun:__sanitizer_cov=uninstrumented
+fun:__sanitizer_cov=discard
+fun:__sanitizer_cov_module_init=uninstrumented
+fun:__sanitizer_cov_module_init=discard
+fun:__sanitizer_cov_with_check=uninstrumented
+fun:__sanitizer_cov_with_check=discard
+fun:__sanitizer_cov_indir_call16=uninstrumented
+fun:__sanitizer_cov_indir_call16=discard
+fun:__sanitizer_cov_indir_call16=uninstrumented
+fun:__sanitizer_cov_indir_call16=discard
+fun:__sanitizer_reset_coverage=uninstrumented
+fun:__sanitizer_reset_coverage=discard
+fun:__sanitizer_set_death_callback=uninstrumented
+fun:__sanitizer_set_death_callback=discard
+fun:__sanitizer_get_coverage_guards=uninstrumented
+fun:__sanitizer_get_coverage_guards=discard
+fun:__sanitizer_get_number_of_counters=uninstrumented
+fun:__sanitizer_get_number_of_counters=discard
+fun:__sanitizer_update_counter_bitset_and_clear_counters=uninstrumented
+fun:__sanitizer_update_counter_bitset_and_clear_counters=discard
+fun:__sanitizer_get_total_unique_coverage=uninstrumented
+fun:__sanitizer_get_total_unique_coverage=discard
+fun:__sanitizer_get_total_unique_coverage=uninstrumented
+fun:__sanitizer_get_total_unique_coverage=discard
+fun:__sanitizer_update_counter_bitset_and_clear_counters=uninstrumented
+fun:__sanitizer_update_counter_bitset_and_clear_counters=discard
+
+# Ignores the dfsan wrappers.
+fun:__dfsw_*=uninstrumented
+fun:__dfsw_*=discard
+
+# Don't add extra parameters to the Fuzzer callback.
+fun:LLVMFuzzerTestOneInput=uninstrumented
diff --git a/compiler-rt/lib/dfsan/libc_ubuntu1404_abilist.txt b/compiler-rt/lib/dfsan/libc_ubuntu1404_abilist.txt
new file mode 100644
index 0000000..a1ea0a0
--- /dev/null
+++ b/compiler-rt/lib/dfsan/libc_ubuntu1404_abilist.txt
@@ -0,0 +1,3433 @@
+fun:_Exit=uninstrumented
+fun:_IO_adjust_column=uninstrumented
+fun:_IO_adjust_wcolumn=uninstrumented
+fun:_IO_default_doallocate=uninstrumented
+fun:_IO_default_finish=uninstrumented
+fun:_IO_default_pbackfail=uninstrumented
+fun:_IO_default_uflow=uninstrumented
+fun:_IO_default_xsgetn=uninstrumented
+fun:_IO_default_xsputn=uninstrumented
+fun:_IO_do_write=uninstrumented
+fun:_IO_doallocbuf=uninstrumented
+fun:_IO_fclose=uninstrumented
+fun:_IO_fdopen=uninstrumented
+fun:_IO_feof=uninstrumented
+fun:_IO_ferror=uninstrumented
+fun:_IO_fflush=uninstrumented
+fun:_IO_fgetpos=uninstrumented
+fun:_IO_fgetpos64=uninstrumented
+fun:_IO_fgets=uninstrumented
+fun:_IO_file_attach=uninstrumented
+fun:_IO_file_close=uninstrumented
+fun:_IO_file_close_it=uninstrumented
+fun:_IO_file_doallocate=uninstrumented
+fun:_IO_file_finish=uninstrumented
+fun:_IO_file_fopen=uninstrumented
+fun:_IO_file_init=uninstrumented
+fun:_IO_file_open=uninstrumented
+fun:_IO_file_overflow=uninstrumented
+fun:_IO_file_read=uninstrumented
+fun:_IO_file_seek=uninstrumented
+fun:_IO_file_seekoff=uninstrumented
+fun:_IO_file_setbuf=uninstrumented
+fun:_IO_file_stat=uninstrumented
+fun:_IO_file_sync=uninstrumented
+fun:_IO_file_underflow=uninstrumented
+fun:_IO_file_write=uninstrumented
+fun:_IO_file_xsputn=uninstrumented
+fun:_IO_flockfile=uninstrumented
+fun:_IO_flush_all=uninstrumented
+fun:_IO_flush_all_linebuffered=uninstrumented
+fun:_IO_fopen=uninstrumented
+fun:_IO_fprintf=uninstrumented
+fun:_IO_fputs=uninstrumented
+fun:_IO_fread=uninstrumented
+fun:_IO_free_backup_area=uninstrumented
+fun:_IO_free_wbackup_area=uninstrumented
+fun:_IO_fsetpos=uninstrumented
+fun:_IO_fsetpos64=uninstrumented
+fun:_IO_ftell=uninstrumented
+fun:_IO_ftrylockfile=uninstrumented
+fun:_IO_funlockfile=uninstrumented
+fun:_IO_fwrite=uninstrumented
+fun:_IO_getc=uninstrumented
+fun:_IO_getline=uninstrumented
+fun:_IO_getline_info=uninstrumented
+fun:_IO_gets=uninstrumented
+fun:_IO_init=uninstrumented
+fun:_IO_init_marker=uninstrumented
+fun:_IO_init_wmarker=uninstrumented
+fun:_IO_iter_begin=uninstrumented
+fun:_IO_iter_end=uninstrumented
+fun:_IO_iter_file=uninstrumented
+fun:_IO_iter_next=uninstrumented
+fun:_IO_least_wmarker=uninstrumented
+fun:_IO_link_in=uninstrumented
+fun:_IO_list_lock=uninstrumented
+fun:_IO_list_resetlock=uninstrumented
+fun:_IO_list_unlock=uninstrumented
+fun:_IO_marker_delta=uninstrumented
+fun:_IO_marker_difference=uninstrumented
+fun:_IO_padn=uninstrumented
+fun:_IO_peekc_locked=uninstrumented
+fun:_IO_popen=uninstrumented
+fun:_IO_printf=uninstrumented
+fun:_IO_proc_close=uninstrumented
+fun:_IO_proc_open=uninstrumented
+fun:_IO_putc=uninstrumented
+fun:_IO_puts=uninstrumented
+fun:_IO_remove_marker=uninstrumented
+fun:_IO_seekmark=uninstrumented
+fun:_IO_seekoff=uninstrumented
+fun:_IO_seekpos=uninstrumented
+fun:_IO_seekwmark=uninstrumented
+fun:_IO_setb=uninstrumented
+fun:_IO_setbuffer=uninstrumented
+fun:_IO_setvbuf=uninstrumented
+fun:_IO_sgetn=uninstrumented
+fun:_IO_sprintf=uninstrumented
+fun:_IO_sputbackc=uninstrumented
+fun:_IO_sputbackwc=uninstrumented
+fun:_IO_sscanf=uninstrumented
+fun:_IO_str_init_readonly=uninstrumented
+fun:_IO_str_init_static=uninstrumented
+fun:_IO_str_overflow=uninstrumented
+fun:_IO_str_pbackfail=uninstrumented
+fun:_IO_str_seekoff=uninstrumented
+fun:_IO_str_underflow=uninstrumented
+fun:_IO_sungetc=uninstrumented
+fun:_IO_sungetwc=uninstrumented
+fun:_IO_switch_to_get_mode=uninstrumented
+fun:_IO_switch_to_main_wget_area=uninstrumented
+fun:_IO_switch_to_wbackup_area=uninstrumented
+fun:_IO_switch_to_wget_mode=uninstrumented
+fun:_IO_un_link=uninstrumented
+fun:_IO_ungetc=uninstrumented
+fun:_IO_unsave_markers=uninstrumented
+fun:_IO_unsave_wmarkers=uninstrumented
+fun:_IO_vfprintf=uninstrumented
+fun:_IO_vfscanf=uninstrumented
+fun:_IO_vsprintf=uninstrumented
+fun:_IO_wdefault_doallocate=uninstrumented
+fun:_IO_wdefault_finish=uninstrumented
+fun:_IO_wdefault_pbackfail=uninstrumented
+fun:_IO_wdefault_uflow=uninstrumented
+fun:_IO_wdefault_xsgetn=uninstrumented
+fun:_IO_wdefault_xsputn=uninstrumented
+fun:_IO_wdo_write=uninstrumented
+fun:_IO_wdoallocbuf=uninstrumented
+fun:_IO_wfile_overflow=uninstrumented
+fun:_IO_wfile_seekoff=uninstrumented
+fun:_IO_wfile_sync=uninstrumented
+fun:_IO_wfile_underflow=uninstrumented
+fun:_IO_wfile_xsputn=uninstrumented
+fun:_IO_wmarker_delta=uninstrumented
+fun:_IO_wsetb=uninstrumented
+fun:_Unwind_Backtrace=uninstrumented
+fun:_Unwind_DeleteException=uninstrumented
+fun:_Unwind_FindEnclosingFunction=uninstrumented
+fun:_Unwind_Find_FDE=uninstrumented
+fun:_Unwind_ForcedUnwind=uninstrumented
+fun:_Unwind_GetCFA=uninstrumented
+fun:_Unwind_GetDataRelBase=uninstrumented
+fun:_Unwind_GetGR=uninstrumented
+fun:_Unwind_GetIP=uninstrumented
+fun:_Unwind_GetIPInfo=uninstrumented
+fun:_Unwind_GetLanguageSpecificData=uninstrumented
+fun:_Unwind_GetRegionStart=uninstrumented
+fun:_Unwind_GetTextRelBase=uninstrumented
+fun:_Unwind_RaiseException=uninstrumented
+fun:_Unwind_Resume=uninstrumented
+fun:_Unwind_Resume_or_Rethrow=uninstrumented
+fun:_Unwind_SetGR=uninstrumented
+fun:_Unwind_SetIP=uninstrumented
+fun:__absvdi2=uninstrumented
+fun:__absvsi2=uninstrumented
+fun:__absvti2=uninstrumented
+fun:__acos_finite=uninstrumented
+fun:__acosf_finite=uninstrumented
+fun:__acosh_finite=uninstrumented
+fun:__acoshf_finite=uninstrumented
+fun:__acoshl_finite=uninstrumented
+fun:__acosl_finite=uninstrumented
+fun:__addtf3=uninstrumented
+fun:__addvdi3=uninstrumented
+fun:__addvsi3=uninstrumented
+fun:__addvti3=uninstrumented
+fun:__adjtimex=uninstrumented
+fun:__arch_prctl=uninstrumented
+fun:__argz_count=uninstrumented
+fun:__argz_next=uninstrumented
+fun:__argz_stringify=uninstrumented
+fun:__ashlti3=uninstrumented
+fun:__ashrti3=uninstrumented
+fun:__asin_finite=uninstrumented
+fun:__asinf_finite=uninstrumented
+fun:__asinl_finite=uninstrumented
+fun:__asprintf=uninstrumented
+fun:__asprintf_chk=uninstrumented
+fun:__assert=uninstrumented
+fun:__assert_fail=uninstrumented
+fun:__assert_perror_fail=uninstrumented
+fun:__atan2_finite=uninstrumented
+fun:__atan2f_finite=uninstrumented
+fun:__atan2l_finite=uninstrumented
+fun:__atanh_finite=uninstrumented
+fun:__atanhf_finite=uninstrumented
+fun:__atanhl_finite=uninstrumented
+fun:__b64_ntop=uninstrumented
+fun:__b64_pton=uninstrumented
+fun:__backtrace=uninstrumented
+fun:__backtrace_symbols=uninstrumented
+fun:__backtrace_symbols_fd=uninstrumented
+fun:__bid128_abs=uninstrumented
+fun:__bid128_add=uninstrumented
+fun:__bid128_class=uninstrumented
+fun:__bid128_copy=uninstrumented
+fun:__bid128_copySign=uninstrumented
+fun:__bid128_div=uninstrumented
+fun:__bid128_fma=uninstrumented
+fun:__bid128_from_int32=uninstrumented
+fun:__bid128_from_int64=uninstrumented
+fun:__bid128_from_uint32=uninstrumented
+fun:__bid128_from_uint64=uninstrumented
+fun:__bid128_isCanonical=uninstrumented
+fun:__bid128_isFinite=uninstrumented
+fun:__bid128_isInf=uninstrumented
+fun:__bid128_isNaN=uninstrumented
+fun:__bid128_isNormal=uninstrumented
+fun:__bid128_isSignaling=uninstrumented
+fun:__bid128_isSigned=uninstrumented
+fun:__bid128_isSubnormal=uninstrumented
+fun:__bid128_isZero=uninstrumented
+fun:__bid128_mul=uninstrumented
+fun:__bid128_negate=uninstrumented
+fun:__bid128_quiet_equal=uninstrumented
+fun:__bid128_quiet_greater=uninstrumented
+fun:__bid128_quiet_greater_equal=uninstrumented
+fun:__bid128_quiet_greater_unordered=uninstrumented
+fun:__bid128_quiet_less=uninstrumented
+fun:__bid128_quiet_less_equal=uninstrumented
+fun:__bid128_quiet_less_unordered=uninstrumented
+fun:__bid128_quiet_not_equal=uninstrumented
+fun:__bid128_quiet_not_greater=uninstrumented
+fun:__bid128_quiet_not_less=uninstrumented
+fun:__bid128_quiet_ordered=uninstrumented
+fun:__bid128_quiet_unordered=uninstrumented
+fun:__bid128_radix=uninstrumented
+fun:__bid128_sameQuantum=uninstrumented
+fun:__bid128_signaling_greater=uninstrumented
+fun:__bid128_signaling_greater_equal=uninstrumented
+fun:__bid128_signaling_greater_unordered=uninstrumented
+fun:__bid128_signaling_less=uninstrumented
+fun:__bid128_signaling_less_equal=uninstrumented
+fun:__bid128_signaling_less_unordered=uninstrumented
+fun:__bid128_signaling_not_greater=uninstrumented
+fun:__bid128_signaling_not_less=uninstrumented
+fun:__bid128_sub=uninstrumented
+fun:__bid128_to_bid32=uninstrumented
+fun:__bid128_to_bid64=uninstrumented
+fun:__bid128_to_binary128=uninstrumented
+fun:__bid128_to_binary32=uninstrumented
+fun:__bid128_to_binary64=uninstrumented
+fun:__bid128_to_binary80=uninstrumented
+fun:__bid128_to_int32_ceil=uninstrumented
+fun:__bid128_to_int32_floor=uninstrumented
+fun:__bid128_to_int32_int=uninstrumented
+fun:__bid128_to_int32_rnint=uninstrumented
+fun:__bid128_to_int32_rninta=uninstrumented
+fun:__bid128_to_int32_xceil=uninstrumented
+fun:__bid128_to_int32_xfloor=uninstrumented
+fun:__bid128_to_int32_xint=uninstrumented
+fun:__bid128_to_int32_xrnint=uninstrumented
+fun:__bid128_to_int32_xrninta=uninstrumented
+fun:__bid128_to_int64_ceil=uninstrumented
+fun:__bid128_to_int64_floor=uninstrumented
+fun:__bid128_to_int64_int=uninstrumented
+fun:__bid128_to_int64_rnint=uninstrumented
+fun:__bid128_to_int64_rninta=uninstrumented
+fun:__bid128_to_int64_xceil=uninstrumented
+fun:__bid128_to_int64_xfloor=uninstrumented
+fun:__bid128_to_int64_xint=uninstrumented
+fun:__bid128_to_int64_xrnint=uninstrumented
+fun:__bid128_to_int64_xrninta=uninstrumented
+fun:__bid128_to_uint32_ceil=uninstrumented
+fun:__bid128_to_uint32_floor=uninstrumented
+fun:__bid128_to_uint32_int=uninstrumented
+fun:__bid128_to_uint32_rnint=uninstrumented
+fun:__bid128_to_uint32_rninta=uninstrumented
+fun:__bid128_to_uint32_xceil=uninstrumented
+fun:__bid128_to_uint32_xfloor=uninstrumented
+fun:__bid128_to_uint32_xint=uninstrumented
+fun:__bid128_to_uint32_xrnint=uninstrumented
+fun:__bid128_to_uint32_xrninta=uninstrumented
+fun:__bid128_to_uint64_ceil=uninstrumented
+fun:__bid128_to_uint64_floor=uninstrumented
+fun:__bid128_to_uint64_int=uninstrumented
+fun:__bid128_to_uint64_rnint=uninstrumented
+fun:__bid128_to_uint64_rninta=uninstrumented
+fun:__bid128_to_uint64_xceil=uninstrumented
+fun:__bid128_to_uint64_xfloor=uninstrumented
+fun:__bid128_to_uint64_xint=uninstrumented
+fun:__bid128_to_uint64_xrnint=uninstrumented
+fun:__bid128_to_uint64_xrninta=uninstrumented
+fun:__bid128_totalOrder=uninstrumented
+fun:__bid128_totalOrderMag=uninstrumented
+fun:__bid128dd_add=uninstrumented
+fun:__bid128dd_div=uninstrumented
+fun:__bid128dd_mul=uninstrumented
+fun:__bid128dd_sub=uninstrumented
+fun:__bid128ddd_fma=uninstrumented
+fun:__bid128ddq_fma=uninstrumented
+fun:__bid128dq_add=uninstrumented
+fun:__bid128dq_div=uninstrumented
+fun:__bid128dq_mul=uninstrumented
+fun:__bid128dq_sub=uninstrumented
+fun:__bid128dqd_fma=uninstrumented
+fun:__bid128dqq_fma=uninstrumented
+fun:__bid128qd_add=uninstrumented
+fun:__bid128qd_div=uninstrumented
+fun:__bid128qd_mul=uninstrumented
+fun:__bid128qd_sub=uninstrumented
+fun:__bid128qdd_fma=uninstrumented
+fun:__bid128qdq_fma=uninstrumented
+fun:__bid128qqd_fma=uninstrumented
+fun:__bid32_to_bid128=uninstrumented
+fun:__bid32_to_bid64=uninstrumented
+fun:__bid32_to_binary128=uninstrumented
+fun:__bid32_to_binary32=uninstrumented
+fun:__bid32_to_binary64=uninstrumented
+fun:__bid32_to_binary80=uninstrumented
+fun:__bid64_abs=uninstrumented
+fun:__bid64_add=uninstrumented
+fun:__bid64_class=uninstrumented
+fun:__bid64_copy=uninstrumented
+fun:__bid64_copySign=uninstrumented
+fun:__bid64_div=uninstrumented
+fun:__bid64_from_int32=uninstrumented
+fun:__bid64_from_int64=uninstrumented
+fun:__bid64_from_uint32=uninstrumented
+fun:__bid64_from_uint64=uninstrumented
+fun:__bid64_isCanonical=uninstrumented
+fun:__bid64_isFinite=uninstrumented
+fun:__bid64_isInf=uninstrumented
+fun:__bid64_isNaN=uninstrumented
+fun:__bid64_isNormal=uninstrumented
+fun:__bid64_isSignaling=uninstrumented
+fun:__bid64_isSigned=uninstrumented
+fun:__bid64_isSubnormal=uninstrumented
+fun:__bid64_isZero=uninstrumented
+fun:__bid64_mul=uninstrumented
+fun:__bid64_negate=uninstrumented
+fun:__bid64_quiet_equal=uninstrumented
+fun:__bid64_quiet_greater=uninstrumented
+fun:__bid64_quiet_greater_equal=uninstrumented
+fun:__bid64_quiet_greater_unordered=uninstrumented
+fun:__bid64_quiet_less=uninstrumented
+fun:__bid64_quiet_less_equal=uninstrumented
+fun:__bid64_quiet_less_unordered=uninstrumented
+fun:__bid64_quiet_not_equal=uninstrumented
+fun:__bid64_quiet_not_greater=uninstrumented
+fun:__bid64_quiet_not_less=uninstrumented
+fun:__bid64_quiet_ordered=uninstrumented
+fun:__bid64_quiet_unordered=uninstrumented
+fun:__bid64_radix=uninstrumented
+fun:__bid64_sameQuantum=uninstrumented
+fun:__bid64_signaling_greater=uninstrumented
+fun:__bid64_signaling_greater_equal=uninstrumented
+fun:__bid64_signaling_greater_unordered=uninstrumented
+fun:__bid64_signaling_less=uninstrumented
+fun:__bid64_signaling_less_equal=uninstrumented
+fun:__bid64_signaling_less_unordered=uninstrumented
+fun:__bid64_signaling_not_greater=uninstrumented
+fun:__bid64_signaling_not_less=uninstrumented
+fun:__bid64_sub=uninstrumented
+fun:__bid64_to_bid128=uninstrumented
+fun:__bid64_to_bid32=uninstrumented
+fun:__bid64_to_binary128=uninstrumented
+fun:__bid64_to_binary32=uninstrumented
+fun:__bid64_to_binary64=uninstrumented
+fun:__bid64_to_binary80=uninstrumented
+fun:__bid64_to_int32_ceil=uninstrumented
+fun:__bid64_to_int32_floor=uninstrumented
+fun:__bid64_to_int32_int=uninstrumented
+fun:__bid64_to_int32_rnint=uninstrumented
+fun:__bid64_to_int32_rninta=uninstrumented
+fun:__bid64_to_int32_xceil=uninstrumented
+fun:__bid64_to_int32_xfloor=uninstrumented
+fun:__bid64_to_int32_xint=uninstrumented
+fun:__bid64_to_int32_xrnint=uninstrumented
+fun:__bid64_to_int32_xrninta=uninstrumented
+fun:__bid64_to_int64_ceil=uninstrumented
+fun:__bid64_to_int64_floor=uninstrumented
+fun:__bid64_to_int64_int=uninstrumented
+fun:__bid64_to_int64_rnint=uninstrumented
+fun:__bid64_to_int64_rninta=uninstrumented
+fun:__bid64_to_int64_xceil=uninstrumented
+fun:__bid64_to_int64_xfloor=uninstrumented
+fun:__bid64_to_int64_xint=uninstrumented
+fun:__bid64_to_int64_xrnint=uninstrumented
+fun:__bid64_to_int64_xrninta=uninstrumented
+fun:__bid64_to_uint32_ceil=uninstrumented
+fun:__bid64_to_uint32_floor=uninstrumented
+fun:__bid64_to_uint32_int=uninstrumented
+fun:__bid64_to_uint32_rnint=uninstrumented
+fun:__bid64_to_uint32_rninta=uninstrumented
+fun:__bid64_to_uint32_xceil=uninstrumented
+fun:__bid64_to_uint32_xfloor=uninstrumented
+fun:__bid64_to_uint32_xint=uninstrumented
+fun:__bid64_to_uint32_xrnint=uninstrumented
+fun:__bid64_to_uint32_xrninta=uninstrumented
+fun:__bid64_to_uint64_ceil=uninstrumented
+fun:__bid64_to_uint64_floor=uninstrumented
+fun:__bid64_to_uint64_int=uninstrumented
+fun:__bid64_to_uint64_rnint=uninstrumented
+fun:__bid64_to_uint64_rninta=uninstrumented
+fun:__bid64_to_uint64_xceil=uninstrumented
+fun:__bid64_to_uint64_xfloor=uninstrumented
+fun:__bid64_to_uint64_xint=uninstrumented
+fun:__bid64_to_uint64_xrnint=uninstrumented
+fun:__bid64_to_uint64_xrninta=uninstrumented
+fun:__bid64_totalOrder=uninstrumented
+fun:__bid64_totalOrderMag=uninstrumented
+fun:__bid64ddq_fma=uninstrumented
+fun:__bid64dq_add=uninstrumented
+fun:__bid64dq_div=uninstrumented
+fun:__bid64dq_mul=uninstrumented
+fun:__bid64dq_sub=uninstrumented
+fun:__bid64dqd_fma=uninstrumented
+fun:__bid64dqq_fma=uninstrumented
+fun:__bid64qd_add=uninstrumented
+fun:__bid64qd_div=uninstrumented
+fun:__bid64qd_mul=uninstrumented
+fun:__bid64qd_sub=uninstrumented
+fun:__bid64qdd_fma=uninstrumented
+fun:__bid64qdq_fma=uninstrumented
+fun:__bid64qq_add=uninstrumented
+fun:__bid64qq_div=uninstrumented
+fun:__bid64qq_mul=uninstrumented
+fun:__bid64qq_sub=uninstrumented
+fun:__bid64qqd_fma=uninstrumented
+fun:__bid64qqq_fma=uninstrumented
+fun:__bid_adddd3=uninstrumented
+fun:__bid_addsd3=uninstrumented
+fun:__bid_addtd3=uninstrumented
+fun:__bid_divdd3=uninstrumented
+fun:__bid_divsd3=uninstrumented
+fun:__bid_divtd3=uninstrumented
+fun:__bid_eqdd2=uninstrumented
+fun:__bid_eqsd2=uninstrumented
+fun:__bid_eqtd2=uninstrumented
+fun:__bid_extendddtd2=uninstrumented
+fun:__bid_extendddtf=uninstrumented
+fun:__bid_extendddxf=uninstrumented
+fun:__bid_extenddfdd=uninstrumented
+fun:__bid_extenddftd=uninstrumented
+fun:__bid_extendsddd2=uninstrumented
+fun:__bid_extendsddf=uninstrumented
+fun:__bid_extendsdtd2=uninstrumented
+fun:__bid_extendsdtf=uninstrumented
+fun:__bid_extendsdxf=uninstrumented
+fun:__bid_extendsfdd=uninstrumented
+fun:__bid_extendsfsd=uninstrumented
+fun:__bid_extendsftd=uninstrumented
+fun:__bid_extendtftd=uninstrumented
+fun:__bid_extendxftd=uninstrumented
+fun:__bid_fixdddi=uninstrumented
+fun:__bid_fixddsi=uninstrumented
+fun:__bid_fixsddi=uninstrumented
+fun:__bid_fixsdsi=uninstrumented
+fun:__bid_fixtddi=uninstrumented
+fun:__bid_fixtdsi=uninstrumented
+fun:__bid_fixunsdddi=uninstrumented
+fun:__bid_fixunsddsi=uninstrumented
+fun:__bid_fixunssddi=uninstrumented
+fun:__bid_fixunssdsi=uninstrumented
+fun:__bid_fixunstddi=uninstrumented
+fun:__bid_fixunstdsi=uninstrumented
+fun:__bid_floatdidd=uninstrumented
+fun:__bid_floatdisd=uninstrumented
+fun:__bid_floatditd=uninstrumented
+fun:__bid_floatsidd=uninstrumented
+fun:__bid_floatsisd=uninstrumented
+fun:__bid_floatsitd=uninstrumented
+fun:__bid_floatunsdidd=uninstrumented
+fun:__bid_floatunsdisd=uninstrumented
+fun:__bid_floatunsditd=uninstrumented
+fun:__bid_floatunssidd=uninstrumented
+fun:__bid_floatunssisd=uninstrumented
+fun:__bid_floatunssitd=uninstrumented
+fun:__bid_gedd2=uninstrumented
+fun:__bid_gesd2=uninstrumented
+fun:__bid_getd2=uninstrumented
+fun:__bid_gtdd2=uninstrumented
+fun:__bid_gtsd2=uninstrumented
+fun:__bid_gttd2=uninstrumented
+fun:__bid_ledd2=uninstrumented
+fun:__bid_lesd2=uninstrumented
+fun:__bid_letd2=uninstrumented
+fun:__bid_ltdd2=uninstrumented
+fun:__bid_ltsd2=uninstrumented
+fun:__bid_lttd2=uninstrumented
+fun:__bid_muldd3=uninstrumented
+fun:__bid_mulsd3=uninstrumented
+fun:__bid_multd3=uninstrumented
+fun:__bid_nedd2=uninstrumented
+fun:__bid_nesd2=uninstrumented
+fun:__bid_netd2=uninstrumented
+fun:__bid_round128_19_38=uninstrumented
+fun:__bid_round192_39_57=uninstrumented
+fun:__bid_round256_58_76=uninstrumented
+fun:__bid_round64_2_18=uninstrumented
+fun:__bid_subdd3=uninstrumented
+fun:__bid_subsd3=uninstrumented
+fun:__bid_subtd3=uninstrumented
+fun:__bid_truncdddf=uninstrumented
+fun:__bid_truncddsd2=uninstrumented
+fun:__bid_truncddsf=uninstrumented
+fun:__bid_truncdfsd=uninstrumented
+fun:__bid_truncsdsf=uninstrumented
+fun:__bid_trunctddd2=uninstrumented
+fun:__bid_trunctddf=uninstrumented
+fun:__bid_trunctdsd2=uninstrumented
+fun:__bid_trunctdsf=uninstrumented
+fun:__bid_trunctdtf=uninstrumented
+fun:__bid_trunctdxf=uninstrumented
+fun:__bid_trunctfdd=uninstrumented
+fun:__bid_trunctfsd=uninstrumented
+fun:__bid_truncxfdd=uninstrumented
+fun:__bid_truncxfsd=uninstrumented
+fun:__bid_unorddd2=uninstrumented
+fun:__bid_unordsd2=uninstrumented
+fun:__bid_unordtd2=uninstrumented
+fun:__binary128_to_bid128=uninstrumented
+fun:__binary128_to_bid32=uninstrumented
+fun:__binary128_to_bid64=uninstrumented
+fun:__binary32_to_bid128=uninstrumented
+fun:__binary32_to_bid32=uninstrumented
+fun:__binary32_to_bid64=uninstrumented
+fun:__binary64_to_bid128=uninstrumented
+fun:__binary64_to_bid32=uninstrumented
+fun:__binary64_to_bid64=uninstrumented
+fun:__binary80_to_bid128=uninstrumented
+fun:__binary80_to_bid32=uninstrumented
+fun:__binary80_to_bid64=uninstrumented
+fun:__bsd_getpgrp=uninstrumented
+fun:__bswapdi2=uninstrumented
+fun:__bswapsi2=uninstrumented
+fun:__bzero=uninstrumented
+fun:__call_tls_dtors=uninstrumented
+fun:__chk_fail=uninstrumented
+fun:__clear_cache=uninstrumented
+fun:__clock_getcpuclockid=uninstrumented
+fun:__clock_getres=uninstrumented
+fun:__clock_gettime=uninstrumented
+fun:__clock_nanosleep=uninstrumented
+fun:__clock_settime=uninstrumented
+fun:__clog10=uninstrumented
+fun:__clog10f=uninstrumented
+fun:__clog10l=uninstrumented
+fun:__clone=uninstrumented
+fun:__close=uninstrumented
+fun:__clrsbdi2=uninstrumented
+fun:__clrsbti2=uninstrumented
+fun:__clzdi2=uninstrumented
+fun:__clzti2=uninstrumented
+fun:__cmpti2=uninstrumented
+fun:__cmsg_nxthdr=uninstrumented
+fun:__confstr_chk=uninstrumented
+fun:__connect=uninstrumented
+fun:__cosh_finite=uninstrumented
+fun:__coshf_finite=uninstrumented
+fun:__coshl_finite=uninstrumented
+fun:__cpu_indicator_init=uninstrumented
+fun:__create_ib_request=uninstrumented
+fun:__ctype_b_loc=uninstrumented
+fun:__ctype_get_mb_cur_max=uninstrumented
+fun:__ctype_init=uninstrumented
+fun:__ctype_tolower_loc=uninstrumented
+fun:__ctype_toupper_loc=uninstrumented
+fun:__ctzdi2=uninstrumented
+fun:__ctzti2=uninstrumented
+fun:__cxa_at_quick_exit=uninstrumented
+fun:__cxa_atexit=uninstrumented
+fun:__cxa_finalize=uninstrumented
+fun:__cxa_thread_atexit_impl=uninstrumented
+fun:__cyg_profile_func_enter=uninstrumented
+fun:__cyg_profile_func_exit=uninstrumented
+fun:__dcgettext=uninstrumented
+fun:__default_morecore=uninstrumented
+fun:__deregister_frame=uninstrumented
+fun:__deregister_frame_info=uninstrumented
+fun:__deregister_frame_info_bases=uninstrumented
+fun:__dfp_clear_except=uninstrumented
+fun:__dfp_get_round=uninstrumented
+fun:__dfp_raise_except=uninstrumented
+fun:__dfp_set_round=uninstrumented
+fun:__dfp_test_except=uninstrumented
+fun:__dgettext=uninstrumented
+fun:__divdc3=uninstrumented
+fun:__divsc3=uninstrumented
+fun:__divtc3=uninstrumented
+fun:__divtf3=uninstrumented
+fun:__divti3=uninstrumented
+fun:__divxc3=uninstrumented
+fun:__dn_comp=uninstrumented
+fun:__dn_count_labels=uninstrumented
+fun:__dn_expand=uninstrumented
+fun:__dn_skipname=uninstrumented
+fun:__do_niscall3=uninstrumented
+fun:__dprintf_chk=uninstrumented
+fun:__dup2=uninstrumented
+fun:__duplocale=uninstrumented
+fun:__emutls_get_address=uninstrumented
+fun:__emutls_register_common=uninstrumented
+fun:__enable_execute_stack=uninstrumented
+fun:__endmntent=uninstrumented
+fun:__eprintf=uninstrumented
+fun:__eqtf2=uninstrumented
+fun:__errno_location=uninstrumented
+fun:__exp10_finite=uninstrumented
+fun:__exp10f_finite=uninstrumented
+fun:__exp10l_finite=uninstrumented
+fun:__exp2_finite=uninstrumented
+fun:__exp2f_finite=uninstrumented
+fun:__exp2l_finite=uninstrumented
+fun:__exp_finite=uninstrumented
+fun:__expf_finite=uninstrumented
+fun:__expl_finite=uninstrumented
+fun:__extenddftf2=uninstrumented
+fun:__extendsftf2=uninstrumented
+fun:__extendxftf2=uninstrumented
+fun:__fbufsize=uninstrumented
+fun:__fcntl=uninstrumented
+fun:__fdelt_chk=uninstrumented
+fun:__fdelt_warn=uninstrumented
+fun:__fentry__=uninstrumented
+fun:__ffs=uninstrumented
+fun:__ffsdi2=uninstrumented
+fun:__ffsti2=uninstrumented
+fun:__fgets_chk=uninstrumented
+fun:__fgets_unlocked_chk=uninstrumented
+fun:__fgetws_chk=uninstrumented
+fun:__fgetws_unlocked_chk=uninstrumented
+fun:__finite=uninstrumented
+fun:__finitef=uninstrumented
+fun:__finitel=uninstrumented
+fun:__fixdfti=uninstrumented
+fun:__fixsfti=uninstrumented
+fun:__fixtfdi=uninstrumented
+fun:__fixtfsi=uninstrumented
+fun:__fixtfti=uninstrumented
+fun:__fixunsdfdi=uninstrumented
+fun:__fixunsdfti=uninstrumented
+fun:__fixunssfdi=uninstrumented
+fun:__fixunssfti=uninstrumented
+fun:__fixunstfdi=uninstrumented
+fun:__fixunstfsi=uninstrumented
+fun:__fixunstfti=uninstrumented
+fun:__fixunsxfdi=uninstrumented
+fun:__fixunsxfti=uninstrumented
+fun:__fixxfti=uninstrumented
+fun:__flbf=uninstrumented
+fun:__floatditf=uninstrumented
+fun:__floatsitf=uninstrumented
+fun:__floattidf=uninstrumented
+fun:__floattisf=uninstrumented
+fun:__floattitf=uninstrumented
+fun:__floattixf=uninstrumented
+fun:__floatunditf=uninstrumented
+fun:__floatunsitf=uninstrumented
+fun:__floatuntidf=uninstrumented
+fun:__floatuntisf=uninstrumented
+fun:__floatuntitf=uninstrumented
+fun:__floatuntixf=uninstrumented
+fun:__fmod_finite=uninstrumented
+fun:__fmodf_finite=uninstrumented
+fun:__fmodl_finite=uninstrumented
+fun:__follow_path=uninstrumented
+fun:__fork=uninstrumented
+fun:__fortify_fail=uninstrumented
+fun:__fp_nquery=uninstrumented
+fun:__fp_query=uninstrumented
+fun:__fp_resstat=uninstrumented
+fun:__fpclassify=uninstrumented
+fun:__fpclassifyf=uninstrumented
+fun:__fpclassifyl=uninstrumented
+fun:__fpending=uninstrumented
+fun:__fprintf_chk=uninstrumented
+fun:__fpurge=uninstrumented
+fun:__fread_chk=uninstrumented
+fun:__fread_unlocked_chk=uninstrumented
+fun:__freadable=uninstrumented
+fun:__freading=uninstrumented
+fun:__free_fdresult=uninstrumented
+fun:__freelocale=uninstrumented
+fun:__fsetlocking=uninstrumented
+fun:__fstat=uninstrumented
+fun:__fwprintf_chk=uninstrumented
+fun:__fwritable=uninstrumented
+fun:__fwriting=uninstrumented
+fun:__fxstat=uninstrumented
+fun:__fxstat64=uninstrumented
+fun:__fxstatat=uninstrumented
+fun:__fxstatat64=uninstrumented
+fun:__gai_sigqueue=uninstrumented
+fun:__gamma_r_finite=uninstrumented
+fun:__gammaf_r_finite=uninstrumented
+fun:__gammal_r_finite=uninstrumented
+fun:__gcc_bcmp=uninstrumented
+fun:__gcc_personality_v0=uninstrumented
+fun:__gconv_get_alias_db=uninstrumented
+fun:__gconv_get_cache=uninstrumented
+fun:__gconv_get_modules_db=uninstrumented
+fun:__generic_findstack=uninstrumented
+fun:__generic_morestack=uninstrumented
+fun:__generic_morestack_set_initial_sp=uninstrumented
+fun:__generic_releasestack=uninstrumented
+fun:__get_cpu_features=uninstrumented
+fun:__getauxval=uninstrumented
+fun:__getcwd_chk=uninstrumented
+fun:__getdelim=uninstrumented
+fun:__getdomainname_chk=uninstrumented
+fun:__getf2=uninstrumented
+fun:__getgroups_chk=uninstrumented
+fun:__gethostname_chk=uninstrumented
+fun:__getlogin_r_chk=uninstrumented
+fun:__getmntent_r=uninstrumented
+fun:__getpagesize=uninstrumented
+fun:__getpgid=uninstrumented
+fun:__getpid=uninstrumented
+fun:__gets_chk=uninstrumented
+fun:__gettimeofday=uninstrumented
+fun:__getwd_chk=uninstrumented
+fun:__gmtime_r=uninstrumented
+fun:__gttf2=uninstrumented
+fun:__h_errno_location=uninstrumented
+fun:__hostalias=uninstrumented
+fun:__hypot_finite=uninstrumented
+fun:__hypotf_finite=uninstrumented
+fun:__hypotl_finite=uninstrumented
+fun:__internal_endnetgrent=uninstrumented
+fun:__internal_getnetgrent_r=uninstrumented
+fun:__internal_setnetgrent=uninstrumented
+fun:__isalnum_l=uninstrumented
+fun:__isalpha_l=uninstrumented
+fun:__isascii_l=uninstrumented
+fun:__isblank_l=uninstrumented
+fun:__iscntrl_l=uninstrumented
+fun:__isctype=uninstrumented
+fun:__isdigit_l=uninstrumented
+fun:__isgraph_l=uninstrumented
+fun:__isinf=uninstrumented
+fun:__isinff=uninstrumented
+fun:__isinfl=uninstrumented
+fun:__islower_l=uninstrumented
+fun:__isnan=uninstrumented
+fun:__isnanf=uninstrumented
+fun:__isnanl=uninstrumented
+fun:__isoc99_fscanf=uninstrumented
+fun:__isoc99_fwscanf=uninstrumented
+fun:__isoc99_scanf=uninstrumented
+fun:__isoc99_sscanf=uninstrumented
+fun:__isoc99_swscanf=uninstrumented
+fun:__isoc99_vfscanf=uninstrumented
+fun:__isoc99_vfwscanf=uninstrumented
+fun:__isoc99_vscanf=uninstrumented
+fun:__isoc99_vsscanf=uninstrumented
+fun:__isoc99_vswscanf=uninstrumented
+fun:__isoc99_vwscanf=uninstrumented
+fun:__isoc99_wscanf=uninstrumented
+fun:__isprint_l=uninstrumented
+fun:__ispunct_l=uninstrumented
+fun:__issignaling=uninstrumented
+fun:__issignalingf=uninstrumented
+fun:__issignalingl=uninstrumented
+fun:__isspace_l=uninstrumented
+fun:__isupper_l=uninstrumented
+fun:__iswalnum_l=uninstrumented
+fun:__iswalpha_l=uninstrumented
+fun:__iswblank_l=uninstrumented
+fun:__iswcntrl_l=uninstrumented
+fun:__iswctype=uninstrumented
+fun:__iswctype_l=uninstrumented
+fun:__iswdigit_l=uninstrumented
+fun:__iswgraph_l=uninstrumented
+fun:__iswlower_l=uninstrumented
+fun:__iswprint_l=uninstrumented
+fun:__iswpunct_l=uninstrumented
+fun:__iswspace_l=uninstrumented
+fun:__iswupper_l=uninstrumented
+fun:__iswxdigit_l=uninstrumented
+fun:__isxdigit_l=uninstrumented
+fun:__ivaliduser=uninstrumented
+fun:__j0_finite=uninstrumented
+fun:__j0f_finite=uninstrumented
+fun:__j0l_finite=uninstrumented
+fun:__j1_finite=uninstrumented
+fun:__j1f_finite=uninstrumented
+fun:__j1l_finite=uninstrumented
+fun:__jn_finite=uninstrumented
+fun:__jnf_finite=uninstrumented
+fun:__jnl_finite=uninstrumented
+fun:__letf2=uninstrumented
+fun:__lgamma_r_finite=uninstrumented
+fun:__lgammaf_r_finite=uninstrumented
+fun:__lgammal_r_finite=uninstrumented
+fun:__libc_alloca_cutoff=uninstrumented
+fun:__libc_allocate_rtsig=uninstrumented
+fun:__libc_allocate_rtsig_private=uninstrumented
+fun:__libc_calloc=uninstrumented
+fun:__libc_clntudp_bufcreate=uninstrumented
+fun:__libc_csu_fini=uninstrumented
+fun:__libc_csu_init=uninstrumented
+fun:__libc_current_sigrtmax=uninstrumented
+fun:__libc_current_sigrtmax_private=uninstrumented
+fun:__libc_current_sigrtmin=uninstrumented
+fun:__libc_current_sigrtmin_private=uninstrumented
+fun:__libc_dl_error_tsd=uninstrumented
+fun:__libc_dlclose=uninstrumented
+fun:__libc_dlopen_mode=uninstrumented
+fun:__libc_dlsym=uninstrumented
+fun:__libc_fatal=uninstrumented
+fun:__libc_fork=uninstrumented
+fun:__libc_free=uninstrumented
+fun:__libc_freeres=uninstrumented
+fun:__libc_ifunc_impl_list=uninstrumented
+fun:__libc_init_first=uninstrumented
+fun:__libc_longjmp=uninstrumented
+fun:__libc_mallinfo=uninstrumented
+fun:__libc_malloc=uninstrumented
+fun:__libc_mallopt=uninstrumented
+fun:__libc_memalign=uninstrumented
+fun:__libc_pthread_init=uninstrumented
+fun:__libc_pvalloc=uninstrumented
+fun:__libc_pwrite=uninstrumented
+fun:__libc_realloc=uninstrumented
+fun:__libc_res_nquery=uninstrumented
+fun:__libc_res_nsearch=uninstrumented
+fun:__libc_rpc_getport=uninstrumented
+fun:__libc_sa_len=uninstrumented
+fun:__libc_secure_getenv=uninstrumented
+fun:__libc_siglongjmp=uninstrumented
+fun:__libc_start_main=uninstrumented
+fun:__libc_system=uninstrumented
+fun:__libc_thread_freeres=uninstrumented
+fun:__libc_valloc=uninstrumented
+fun:__loc_aton=uninstrumented
+fun:__loc_ntoa=uninstrumented
+fun:__log10_finite=uninstrumented
+fun:__log10f_finite=uninstrumented
+fun:__log10l_finite=uninstrumented
+fun:__log2_finite=uninstrumented
+fun:__log2f_finite=uninstrumented
+fun:__log2l_finite=uninstrumented
+fun:__log_finite=uninstrumented
+fun:__logf_finite=uninstrumented
+fun:__logl_finite=uninstrumented
+fun:__longjmp_chk=uninstrumented
+fun:__lseek=uninstrumented
+fun:__lshrti3=uninstrumented
+fun:__lstat=uninstrumented
+fun:__lttf2=uninstrumented
+fun:__lxstat=uninstrumented
+fun:__lxstat64=uninstrumented
+fun:__madvise=uninstrumented
+fun:__mbrlen=uninstrumented
+fun:__mbrtowc=uninstrumented
+fun:__mbsnrtowcs_chk=uninstrumented
+fun:__mbsrtowcs_chk=uninstrumented
+fun:__mbstowcs_chk=uninstrumented
+fun:__memcpy_chk=uninstrumented
+fun:__memmove_chk=uninstrumented
+fun:__mempcpy=uninstrumented
+fun:__mempcpy_chk=uninstrumented
+fun:__mempcpy_small=uninstrumented
+fun:__memset_chk=uninstrumented
+fun:__mknod=uninstrumented
+fun:__mktemp=uninstrumented
+fun:__modti3=uninstrumented
+fun:__monstartup=uninstrumented
+fun:__morestack=uninstrumented
+fun:__morestack_allocate_stack_space=uninstrumented
+fun:__morestack_block_signals=uninstrumented
+fun:__morestack_fail=uninstrumented
+fun:__morestack_get_guard=uninstrumented
+fun:__morestack_large_model=uninstrumented
+fun:__morestack_load_mmap=uninstrumented
+fun:__morestack_make_guard=uninstrumented
+fun:__morestack_non_split=uninstrumented
+fun:__morestack_release_segments=uninstrumented
+fun:__morestack_set_guard=uninstrumented
+fun:__morestack_unblock_signals=uninstrumented
+fun:__mq_open_2=uninstrumented
+fun:__muldc3=uninstrumented
+fun:__mulsc3=uninstrumented
+fun:__multc3=uninstrumented
+fun:__multf3=uninstrumented
+fun:__multi3=uninstrumented
+fun:__mulvdi3=uninstrumented
+fun:__mulvsi3=uninstrumented
+fun:__mulvti3=uninstrumented
+fun:__mulxc3=uninstrumented
+fun:__nanosleep=uninstrumented
+fun:__negtf2=uninstrumented
+fun:__negti2=uninstrumented
+fun:__negvdi2=uninstrumented
+fun:__negvsi2=uninstrumented
+fun:__negvti2=uninstrumented
+fun:__netf2=uninstrumented
+fun:__newlocale=uninstrumented
+fun:__nis_default_access=uninstrumented
+fun:__nis_default_group=uninstrumented
+fun:__nis_default_owner=uninstrumented
+fun:__nis_default_ttl=uninstrumented
+fun:__nis_finddirectory=uninstrumented
+fun:__nis_hash=uninstrumented
+fun:__nisbind_connect=uninstrumented
+fun:__nisbind_create=uninstrumented
+fun:__nisbind_destroy=uninstrumented
+fun:__nisbind_next=uninstrumented
+fun:__nl_langinfo_l=uninstrumented
+fun:__ns_get16=uninstrumented
+fun:__ns_get32=uninstrumented
+fun:__ns_name_ntop=uninstrumented
+fun:__ns_name_unpack=uninstrumented
+fun:__nss_configure_lookup=uninstrumented
+fun:__nss_database_lookup=uninstrumented
+fun:__nss_disable_nscd=uninstrumented
+fun:__nss_group_lookup=uninstrumented
+fun:__nss_group_lookup2=uninstrumented
+fun:__nss_hostname_digits_dots=uninstrumented
+fun:__nss_hosts_lookup=uninstrumented
+fun:__nss_hosts_lookup2=uninstrumented
+fun:__nss_lookup=uninstrumented
+fun:__nss_lookup_function=uninstrumented
+fun:__nss_next=uninstrumented
+fun:__nss_next2=uninstrumented
+fun:__nss_passwd_lookup=uninstrumented
+fun:__nss_passwd_lookup2=uninstrumented
+fun:__nss_services_lookup2=uninstrumented
+fun:__obstack_printf_chk=uninstrumented
+fun:__obstack_vprintf_chk=uninstrumented
+fun:__open=uninstrumented
+fun:__open64=uninstrumented
+fun:__open64_2=uninstrumented
+fun:__open_2=uninstrumented
+fun:__open_catalog=uninstrumented
+fun:__openat64_2=uninstrumented
+fun:__openat_2=uninstrumented
+fun:__overflow=uninstrumented
+fun:__p_cdname=uninstrumented
+fun:__p_cdnname=uninstrumented
+fun:__p_class=uninstrumented
+fun:__p_fqname=uninstrumented
+fun:__p_fqnname=uninstrumented
+fun:__p_option=uninstrumented
+fun:__p_query=uninstrumented
+fun:__p_rcode=uninstrumented
+fun:__p_secstodate=uninstrumented
+fun:__p_time=uninstrumented
+fun:__p_type=uninstrumented
+fun:__paritydi2=uninstrumented
+fun:__parityti2=uninstrumented
+fun:__pipe=uninstrumented
+fun:__poll=uninstrumented
+fun:__poll_chk=uninstrumented
+fun:__popcountdi2=uninstrumented
+fun:__popcountti2=uninstrumented
+fun:__posix_getopt=uninstrumented
+fun:__pow_finite=uninstrumented
+fun:__powf_finite=uninstrumented
+fun:__powidf2=uninstrumented
+fun:__powisf2=uninstrumented
+fun:__powitf2=uninstrumented
+fun:__powixf2=uninstrumented
+fun:__powl_finite=uninstrumented
+fun:__ppoll_chk=uninstrumented
+fun:__pread64=uninstrumented
+fun:__pread64_chk=uninstrumented
+fun:__pread_chk=uninstrumented
+fun:__prepare_niscall=uninstrumented
+fun:__printf_chk=uninstrumented
+fun:__printf_fp=uninstrumented
+fun:__profile_frequency=uninstrumented
+fun:__pthread_atfork=uninstrumented
+fun:__pthread_cleanup_routine=uninstrumented
+fun:__pthread_clock_gettime=uninstrumented
+fun:__pthread_clock_settime=uninstrumented
+fun:__pthread_get_minstack=uninstrumented
+fun:__pthread_getspecific=uninstrumented
+fun:__pthread_initialize_minimal=uninstrumented
+fun:__pthread_key_create=uninstrumented
+fun:__pthread_mutex_destroy=uninstrumented
+fun:__pthread_mutex_init=uninstrumented
+fun:__pthread_mutex_lock=uninstrumented
+fun:__pthread_mutex_trylock=uninstrumented
+fun:__pthread_mutex_unlock=uninstrumented
+fun:__pthread_mutexattr_destroy=uninstrumented
+fun:__pthread_mutexattr_init=uninstrumented
+fun:__pthread_mutexattr_settype=uninstrumented
+fun:__pthread_once=uninstrumented
+fun:__pthread_register_cancel=uninstrumented
+fun:__pthread_register_cancel_defer=uninstrumented
+fun:__pthread_rwlock_destroy=uninstrumented
+fun:__pthread_rwlock_init=uninstrumented
+fun:__pthread_rwlock_rdlock=uninstrumented
+fun:__pthread_rwlock_tryrdlock=uninstrumented
+fun:__pthread_rwlock_trywrlock=uninstrumented
+fun:__pthread_rwlock_unlock=uninstrumented
+fun:__pthread_rwlock_wrlock=uninstrumented
+fun:__pthread_setspecific=uninstrumented
+fun:__pthread_unregister_cancel=uninstrumented
+fun:__pthread_unregister_cancel_restore=uninstrumented
+fun:__pthread_unwind=uninstrumented
+fun:__pthread_unwind_next=uninstrumented
+fun:__ptsname_r_chk=uninstrumented
+fun:__putlong=uninstrumented
+fun:__putshort=uninstrumented
+fun:__pwrite64=uninstrumented
+fun:__rawmemchr=uninstrumented
+fun:__read=uninstrumented
+fun:__read_chk=uninstrumented
+fun:__readlink_chk=uninstrumented
+fun:__readlinkat_chk=uninstrumented
+fun:__realpath_chk=uninstrumented
+fun:__recv_chk=uninstrumented
+fun:__recvfrom_chk=uninstrumented
+fun:__register_atfork=uninstrumented
+fun:__register_frame=uninstrumented
+fun:__register_frame_info=uninstrumented
+fun:__register_frame_info_bases=uninstrumented
+fun:__register_frame_info_table=uninstrumented
+fun:__register_frame_info_table_bases=uninstrumented
+fun:__register_frame_table=uninstrumented
+fun:__remainder_finite=uninstrumented
+fun:__remainderf_finite=uninstrumented
+fun:__remainderl_finite=uninstrumented
+fun:__res_close=uninstrumented
+fun:__res_dnok=uninstrumented
+fun:__res_hnok=uninstrumented
+fun:__res_hostalias=uninstrumented
+fun:__res_iclose=uninstrumented
+fun:__res_init=uninstrumented
+fun:__res_isourserver=uninstrumented
+fun:__res_mailok=uninstrumented
+fun:__res_maybe_init=uninstrumented
+fun:__res_mkquery=uninstrumented
+fun:__res_nameinquery=uninstrumented
+fun:__res_nclose=uninstrumented
+fun:__res_ninit=uninstrumented
+fun:__res_nmkquery=uninstrumented
+fun:__res_nquery=uninstrumented
+fun:__res_nquerydomain=uninstrumented
+fun:__res_nsearch=uninstrumented
+fun:__res_nsend=uninstrumented
+fun:__res_ownok=uninstrumented
+fun:__res_queriesmatch=uninstrumented
+fun:__res_query=uninstrumented
+fun:__res_querydomain=uninstrumented
+fun:__res_randomid=uninstrumented
+fun:__res_search=uninstrumented
+fun:__res_send=uninstrumented
+fun:__res_state=uninstrumented
+fun:__rpc_thread_createerr=uninstrumented
+fun:__rpc_thread_svc_fdset=uninstrumented
+fun:__rpc_thread_svc_max_pollfd=uninstrumented
+fun:__rpc_thread_svc_pollfd=uninstrumented
+fun:__sbrk=uninstrumented
+fun:__scalb_finite=uninstrumented
+fun:__scalbf_finite=uninstrumented
+fun:__scalbl_finite=uninstrumented
+fun:__sched_cpualloc=uninstrumented
+fun:__sched_cpucount=uninstrumented
+fun:__sched_cpufree=uninstrumented
+fun:__sched_get_priority_max=uninstrumented
+fun:__sched_get_priority_min=uninstrumented
+fun:__sched_getparam=uninstrumented
+fun:__sched_getscheduler=uninstrumented
+fun:__sched_setscheduler=uninstrumented
+fun:__sched_yield=uninstrumented
+fun:__secure_getenv=uninstrumented
+fun:__select=uninstrumented
+fun:__send=uninstrumented
+fun:__sendmmsg=uninstrumented
+fun:__setmntent=uninstrumented
+fun:__setpgid=uninstrumented
+fun:__sfp_handle_exceptions=uninstrumented
+fun:__sigaction=uninstrumented
+fun:__sigaddset=uninstrumented
+fun:__sigdelset=uninstrumented
+fun:__sigismember=uninstrumented
+fun:__signbit=uninstrumented
+fun:__signbitf=uninstrumented
+fun:__signbitl=uninstrumented
+fun:__sigpause=uninstrumented
+fun:__sigsetjmp=uninstrumented
+fun:__sigsuspend=uninstrumented
+fun:__sinh_finite=uninstrumented
+fun:__sinhf_finite=uninstrumented
+fun:__sinhl_finite=uninstrumented
+fun:__snprintf_chk=uninstrumented
+fun:__splitstack_block_signals=uninstrumented
+fun:__splitstack_block_signals_context=uninstrumented
+fun:__splitstack_find=uninstrumented
+fun:__splitstack_find_context=uninstrumented
+fun:__splitstack_getcontext=uninstrumented
+fun:__splitstack_makecontext=uninstrumented
+fun:__splitstack_releasecontext=uninstrumented
+fun:__splitstack_resetcontext=uninstrumented
+fun:__splitstack_setcontext=uninstrumented
+fun:__sprintf_chk=uninstrumented
+fun:__sqrt_finite=uninstrumented
+fun:__sqrtf_finite=uninstrumented
+fun:__sqrtl_finite=uninstrumented
+fun:__stack_chk_fail=uninstrumented
+fun:__stack_chk_fail_local=uninstrumented
+fun:__stack_split_initialize=uninstrumented
+fun:__stat=uninstrumented
+fun:__statfs=uninstrumented
+fun:__stpcpy=uninstrumented
+fun:__stpcpy_chk=uninstrumented
+fun:__stpcpy_small=uninstrumented
+fun:__stpncpy=uninstrumented
+fun:__stpncpy_chk=uninstrumented
+fun:__strcasecmp=uninstrumented
+fun:__strcasecmp_l=uninstrumented
+fun:__strcasestr=uninstrumented
+fun:__strcat_chk=uninstrumented
+fun:__strcoll_l=uninstrumented
+fun:__strcpy_chk=uninstrumented
+fun:__strcpy_small=uninstrumented
+fun:__strcspn_c1=uninstrumented
+fun:__strcspn_c2=uninstrumented
+fun:__strcspn_c3=uninstrumented
+fun:__strdup=uninstrumented
+fun:__strerror_r=uninstrumented
+fun:__strfmon_l=uninstrumented
+fun:__strftime_l=uninstrumented
+fun:__strncasecmp_l=uninstrumented
+fun:__strncat_chk=uninstrumented
+fun:__strncpy_chk=uninstrumented
+fun:__strndup=uninstrumented
+fun:__strpbrk_c2=uninstrumented
+fun:__strpbrk_c3=uninstrumented
+fun:__strsep_1c=uninstrumented
+fun:__strsep_2c=uninstrumented
+fun:__strsep_3c=uninstrumented
+fun:__strsep_g=uninstrumented
+fun:__strspn_c1=uninstrumented
+fun:__strspn_c2=uninstrumented
+fun:__strspn_c3=uninstrumented
+fun:__strtod_internal=uninstrumented
+fun:__strtod_l=uninstrumented
+fun:__strtof_internal=uninstrumented
+fun:__strtof_l=uninstrumented
+fun:__strtok_r=uninstrumented
+fun:__strtok_r_1c=uninstrumented
+fun:__strtol_internal=uninstrumented
+fun:__strtol_l=uninstrumented
+fun:__strtold_internal=uninstrumented
+fun:__strtold_l=uninstrumented
+fun:__strtoll_internal=uninstrumented
+fun:__strtoll_l=uninstrumented
+fun:__strtoul_internal=uninstrumented
+fun:__strtoul_l=uninstrumented
+fun:__strtoull_internal=uninstrumented
+fun:__strtoull_l=uninstrumented
+fun:__strverscmp=uninstrumented
+fun:__strxfrm_l=uninstrumented
+fun:__subtf3=uninstrumented
+fun:__subvdi3=uninstrumented
+fun:__subvsi3=uninstrumented
+fun:__subvti3=uninstrumented
+fun:__swprintf_chk=uninstrumented
+fun:__sym_ntop=uninstrumented
+fun:__sym_ntos=uninstrumented
+fun:__sym_ston=uninstrumented
+fun:__sysconf=uninstrumented
+fun:__sysctl=uninstrumented
+fun:__syslog_chk=uninstrumented
+fun:__sysv_signal=uninstrumented
+fun:__tls_get_addr=uninstrumented
+fun:__toascii_l=uninstrumented
+fun:__tolower_l=uninstrumented
+fun:__toupper_l=uninstrumented
+fun:__towctrans=uninstrumented
+fun:__towctrans_l=uninstrumented
+fun:__towlower_l=uninstrumented
+fun:__towupper_l=uninstrumented
+fun:__trunctfdf2=uninstrumented
+fun:__trunctfsf2=uninstrumented
+fun:__trunctfxf2=uninstrumented
+fun:__ttyname_r_chk=uninstrumented
+fun:__ucmpti2=uninstrumented
+fun:__udiv_w_sdiv=uninstrumented
+fun:__udivmodti4=uninstrumented
+fun:__udivti3=uninstrumented
+fun:__uflow=uninstrumented
+fun:__umodti3=uninstrumented
+fun:__underflow=uninstrumented
+fun:__unordtf2=uninstrumented
+fun:__uselocale=uninstrumented
+fun:__vasprintf_chk=uninstrumented
+fun:__vdprintf_chk=uninstrumented
+fun:__vfork=uninstrumented
+fun:__vfprintf_chk=uninstrumented
+fun:__vfscanf=uninstrumented
+fun:__vfwprintf_chk=uninstrumented
+fun:__vprintf_chk=uninstrumented
+fun:__vsnprintf=uninstrumented
+fun:__vsnprintf_chk=uninstrumented
+fun:__vsprintf_chk=uninstrumented
+fun:__vsscanf=uninstrumented
+fun:__vswprintf_chk=uninstrumented
+fun:__vsyslog_chk=uninstrumented
+fun:__vwprintf_chk=uninstrumented
+fun:__wait=uninstrumented
+fun:__waitpid=uninstrumented
+fun:__warn_memset_zero_len=uninstrumented
+fun:__wcpcpy_chk=uninstrumented
+fun:__wcpncpy_chk=uninstrumented
+fun:__wcrtomb_chk=uninstrumented
+fun:__wcscasecmp_l=uninstrumented
+fun:__wcscat_chk=uninstrumented
+fun:__wcscoll_l=uninstrumented
+fun:__wcscpy_chk=uninstrumented
+fun:__wcsftime_l=uninstrumented
+fun:__wcsncasecmp_l=uninstrumented
+fun:__wcsncat_chk=uninstrumented
+fun:__wcsncpy_chk=uninstrumented
+fun:__wcsnrtombs_chk=uninstrumented
+fun:__wcsrtombs_chk=uninstrumented
+fun:__wcstod_internal=uninstrumented
+fun:__wcstod_l=uninstrumented
+fun:__wcstof_internal=uninstrumented
+fun:__wcstof_l=uninstrumented
+fun:__wcstol_internal=uninstrumented
+fun:__wcstol_l=uninstrumented
+fun:__wcstold_internal=uninstrumented
+fun:__wcstold_l=uninstrumented
+fun:__wcstoll_internal=uninstrumented
+fun:__wcstoll_l=uninstrumented
+fun:__wcstombs_chk=uninstrumented
+fun:__wcstoul_internal=uninstrumented
+fun:__wcstoul_l=uninstrumented
+fun:__wcstoull_internal=uninstrumented
+fun:__wcstoull_l=uninstrumented
+fun:__wcsxfrm_l=uninstrumented
+fun:__wctomb_chk=uninstrumented
+fun:__wctrans_l=uninstrumented
+fun:__wctype_l=uninstrumented
+fun:__wmemcpy_chk=uninstrumented
+fun:__wmemmove_chk=uninstrumented
+fun:__wmempcpy_chk=uninstrumented
+fun:__wmemset_chk=uninstrumented
+fun:__woverflow=uninstrumented
+fun:__wprintf_chk=uninstrumented
+fun:__wrap_pthread_create=uninstrumented
+fun:__write=uninstrumented
+fun:__wuflow=uninstrumented
+fun:__wunderflow=uninstrumented
+fun:__xmknod=uninstrumented
+fun:__xmknodat=uninstrumented
+fun:__xpg_basename=uninstrumented
+fun:__xpg_sigpause=uninstrumented
+fun:__xpg_strerror_r=uninstrumented
+fun:__xstat=uninstrumented
+fun:__xstat64=uninstrumented
+fun:__y0_finite=uninstrumented
+fun:__y0f_finite=uninstrumented
+fun:__y0l_finite=uninstrumented
+fun:__y1_finite=uninstrumented
+fun:__y1f_finite=uninstrumented
+fun:__y1l_finite=uninstrumented
+fun:__yn_finite=uninstrumented
+fun:__ynf_finite=uninstrumented
+fun:__ynl_finite=uninstrumented
+fun:__yp_check=uninstrumented
+fun:_authenticate=uninstrumented
+fun:_dl_addr=uninstrumented
+fun:_dl_allocate_tls=uninstrumented
+fun:_dl_allocate_tls_init=uninstrumented
+fun:_dl_deallocate_tls=uninstrumented
+fun:_dl_debug_state=uninstrumented
+fun:_dl_find_dso_for_object=uninstrumented
+fun:_dl_get_tls_static_info=uninstrumented
+fun:_dl_make_stack_executable=uninstrumented
+fun:_dl_mcount=uninstrumented
+fun:_dl_mcount_wrapper=uninstrumented
+fun:_dl_mcount_wrapper_check=uninstrumented
+fun:_dl_rtld_di_serinfo=uninstrumented
+fun:_dl_sym=uninstrumented
+fun:_dl_tls_setup=uninstrumented
+fun:_dl_vsym=uninstrumented
+fun:_exit=uninstrumented
+fun:_flushlbf=uninstrumented
+fun:_gethtbyaddr=uninstrumented
+fun:_gethtbyname=uninstrumented
+fun:_gethtbyname2=uninstrumented
+fun:_gethtent=uninstrumented
+fun:_getlong=uninstrumented
+fun:_getshort=uninstrumented
+fun:_longjmp=uninstrumented
+fun:_mcleanup=uninstrumented
+fun:_mcount=uninstrumented
+fun:_nsl_default_nss=uninstrumented
+fun:_nss_files_parse_grent=uninstrumented
+fun:_nss_files_parse_pwent=uninstrumented
+fun:_nss_files_parse_sgent=uninstrumented
+fun:_nss_files_parse_spent=uninstrumented
+fun:_obstack_allocated_p=uninstrumented
+fun:_obstack_begin=uninstrumented
+fun:_obstack_begin_1=uninstrumented
+fun:_obstack_free=uninstrumented
+fun:_obstack_memory_used=uninstrumented
+fun:_obstack_newchunk=uninstrumented
+fun:_pthread_cleanup_pop=uninstrumented
+fun:_pthread_cleanup_pop_restore=uninstrumented
+fun:_pthread_cleanup_push=uninstrumented
+fun:_pthread_cleanup_push_defer=uninstrumented
+fun:_rpc_dtablesize=uninstrumented
+fun:_seterr_reply=uninstrumented
+fun:_sethtent=uninstrumented
+fun:_setjmp=uninstrumented
+fun:_tolower=uninstrumented
+fun:_toupper=uninstrumented
+fun:_xdr_ib_request=uninstrumented
+fun:_xdr_nis_result=uninstrumented
+fun:a64l=uninstrumented
+fun:abort=uninstrumented
+fun:abs=uninstrumented
+fun:accept=uninstrumented
+fun:accept4=uninstrumented
+fun:access=uninstrumented
+fun:acct=uninstrumented
+fun:acos=uninstrumented
+fun:acosf=uninstrumented
+fun:acosh=uninstrumented
+fun:acoshf=uninstrumented
+fun:acoshl=uninstrumented
+fun:acosl=uninstrumented
+fun:addmntent=uninstrumented
+fun:addseverity=uninstrumented
+fun:adjtime=uninstrumented
+fun:adjtimex=uninstrumented
+fun:advance=uninstrumented
+fun:aio_cancel=uninstrumented
+fun:aio_cancel64=uninstrumented
+fun:aio_error=uninstrumented
+fun:aio_error64=uninstrumented
+fun:aio_fsync=uninstrumented
+fun:aio_fsync64=uninstrumented
+fun:aio_init=uninstrumented
+fun:aio_read=uninstrumented
+fun:aio_read64=uninstrumented
+fun:aio_return=uninstrumented
+fun:aio_return64=uninstrumented
+fun:aio_suspend=uninstrumented
+fun:aio_suspend64=uninstrumented
+fun:aio_write=uninstrumented
+fun:aio_write64=uninstrumented
+fun:alarm=uninstrumented
+fun:aligned_alloc=uninstrumented
+fun:alphasort=uninstrumented
+fun:alphasort64=uninstrumented
+fun:arch_prctl=uninstrumented
+fun:argp_error=uninstrumented
+fun:argp_failure=uninstrumented
+fun:argp_help=uninstrumented
+fun:argp_parse=uninstrumented
+fun:argp_state_help=uninstrumented
+fun:argp_usage=uninstrumented
+fun:argz_add=uninstrumented
+fun:argz_add_sep=uninstrumented
+fun:argz_append=uninstrumented
+fun:argz_count=uninstrumented
+fun:argz_create=uninstrumented
+fun:argz_create_sep=uninstrumented
+fun:argz_delete=uninstrumented
+fun:argz_extract=uninstrumented
+fun:argz_insert=uninstrumented
+fun:argz_next=uninstrumented
+fun:argz_replace=uninstrumented
+fun:argz_stringify=uninstrumented
+fun:asctime=uninstrumented
+fun:asctime_r=uninstrumented
+fun:asin=uninstrumented
+fun:asinf=uninstrumented
+fun:asinh=uninstrumented
+fun:asinhf=uninstrumented
+fun:asinhl=uninstrumented
+fun:asinl=uninstrumented
+fun:asprintf=uninstrumented
+fun:at_quick_exit=uninstrumented
+fun:atan=uninstrumented
+fun:atan2=uninstrumented
+fun:atan2f=uninstrumented
+fun:atan2l=uninstrumented
+fun:atanf=uninstrumented
+fun:atanh=uninstrumented
+fun:atanhf=uninstrumented
+fun:atanhl=uninstrumented
+fun:atanl=uninstrumented
+fun:atexit=uninstrumented
+fun:atof=uninstrumented
+fun:atoi=uninstrumented
+fun:atol=uninstrumented
+fun:atoll=uninstrumented
+fun:authdes_create=uninstrumented
+fun:authdes_getucred=uninstrumented
+fun:authdes_pk_create=uninstrumented
+fun:authnone_create=uninstrumented
+fun:authunix_create=uninstrumented
+fun:authunix_create_default=uninstrumented
+fun:backtrace=uninstrumented
+fun:backtrace_symbols=uninstrumented
+fun:backtrace_symbols_fd=uninstrumented
+fun:basename=uninstrumented
+fun:bcmp=uninstrumented
+fun:bcopy=uninstrumented
+fun:bdflush=uninstrumented
+fun:bind=uninstrumented
+fun:bind_textdomain_codeset=uninstrumented
+fun:bindresvport=uninstrumented
+fun:bindtextdomain=uninstrumented
+fun:brk=uninstrumented
+fun:bsd_signal=uninstrumented
+fun:bsearch=uninstrumented
+fun:btowc=uninstrumented
+fun:bzero=uninstrumented
+fun:c16rtomb=uninstrumented
+fun:c32rtomb=uninstrumented
+fun:cabs=uninstrumented
+fun:cabsf=uninstrumented
+fun:cabsl=uninstrumented
+fun:cacos=uninstrumented
+fun:cacosf=uninstrumented
+fun:cacosh=uninstrumented
+fun:cacoshf=uninstrumented
+fun:cacoshl=uninstrumented
+fun:cacosl=uninstrumented
+fun:calloc=uninstrumented
+fun:callrpc=uninstrumented
+fun:canonicalize_file_name=uninstrumented
+fun:capget=uninstrumented
+fun:capset=uninstrumented
+fun:carg=uninstrumented
+fun:cargf=uninstrumented
+fun:cargl=uninstrumented
+fun:casin=uninstrumented
+fun:casinf=uninstrumented
+fun:casinh=uninstrumented
+fun:casinhf=uninstrumented
+fun:casinhl=uninstrumented
+fun:casinl=uninstrumented
+fun:catan=uninstrumented
+fun:catanf=uninstrumented
+fun:catanh=uninstrumented
+fun:catanhf=uninstrumented
+fun:catanhl=uninstrumented
+fun:catanl=uninstrumented
+fun:catclose=uninstrumented
+fun:catgets=uninstrumented
+fun:catopen=uninstrumented
+fun:cbc_crypt=uninstrumented
+fun:cbrt=uninstrumented
+fun:cbrtf=uninstrumented
+fun:cbrtl=uninstrumented
+fun:ccos=uninstrumented
+fun:ccosf=uninstrumented
+fun:ccosh=uninstrumented
+fun:ccoshf=uninstrumented
+fun:ccoshl=uninstrumented
+fun:ccosl=uninstrumented
+fun:ceil=uninstrumented
+fun:ceilf=uninstrumented
+fun:ceill=uninstrumented
+fun:cexp=uninstrumented
+fun:cexpf=uninstrumented
+fun:cexpl=uninstrumented
+fun:cfgetispeed=uninstrumented
+fun:cfgetospeed=uninstrumented
+fun:cfmakeraw=uninstrumented
+fun:cfree=uninstrumented
+fun:cfsetispeed=uninstrumented
+fun:cfsetospeed=uninstrumented
+fun:cfsetspeed=uninstrumented
+fun:chdir=uninstrumented
+fun:chflags=uninstrumented
+fun:chmod=uninstrumented
+fun:chown=uninstrumented
+fun:chroot=uninstrumented
+fun:cimag=uninstrumented
+fun:cimagf=uninstrumented
+fun:cimagl=uninstrumented
+fun:clearenv=uninstrumented
+fun:clearerr=uninstrumented
+fun:clearerr_unlocked=uninstrumented
+fun:clnt_broadcast=uninstrumented
+fun:clnt_create=uninstrumented
+fun:clnt_pcreateerror=uninstrumented
+fun:clnt_perrno=uninstrumented
+fun:clnt_perror=uninstrumented
+fun:clnt_spcreateerror=uninstrumented
+fun:clnt_sperrno=uninstrumented
+fun:clnt_sperror=uninstrumented
+fun:clntraw_create=uninstrumented
+fun:clnttcp_create=uninstrumented
+fun:clntudp_bufcreate=uninstrumented
+fun:clntudp_create=uninstrumented
+fun:clntunix_create=uninstrumented
+fun:clock=uninstrumented
+fun:clock_adjtime=uninstrumented
+fun:clock_getcpuclockid=uninstrumented
+fun:clock_getres=uninstrumented
+fun:clock_gettime=uninstrumented
+fun:clock_nanosleep=uninstrumented
+fun:clock_settime=uninstrumented
+fun:clog=uninstrumented
+fun:clog10=uninstrumented
+fun:clog10f=uninstrumented
+fun:clog10l=uninstrumented
+fun:clogf=uninstrumented
+fun:clogl=uninstrumented
+fun:clone=uninstrumented
+fun:close=uninstrumented
+fun:closedir=uninstrumented
+fun:closelog=uninstrumented
+fun:confstr=uninstrumented
+fun:conj=uninstrumented
+fun:conjf=uninstrumented
+fun:conjl=uninstrumented
+fun:connect=uninstrumented
+fun:copysign=uninstrumented
+fun:copysignf=uninstrumented
+fun:copysignl=uninstrumented
+fun:cos=uninstrumented
+fun:cosf=uninstrumented
+fun:cosh=uninstrumented
+fun:coshf=uninstrumented
+fun:coshl=uninstrumented
+fun:cosl=uninstrumented
+fun:cpow=uninstrumented
+fun:cpowf=uninstrumented
+fun:cpowl=uninstrumented
+fun:cproj=uninstrumented
+fun:cprojf=uninstrumented
+fun:cprojl=uninstrumented
+fun:creal=uninstrumented
+fun:crealf=uninstrumented
+fun:creall=uninstrumented
+fun:creat=uninstrumented
+fun:creat64=uninstrumented
+fun:create_module=uninstrumented
+fun:crypt=uninstrumented
+fun:crypt_r=uninstrumented
+fun:csin=uninstrumented
+fun:csinf=uninstrumented
+fun:csinh=uninstrumented
+fun:csinhf=uninstrumented
+fun:csinhl=uninstrumented
+fun:csinl=uninstrumented
+fun:csqrt=uninstrumented
+fun:csqrtf=uninstrumented
+fun:csqrtl=uninstrumented
+fun:ctan=uninstrumented
+fun:ctanf=uninstrumented
+fun:ctanh=uninstrumented
+fun:ctanhf=uninstrumented
+fun:ctanhl=uninstrumented
+fun:ctanl=uninstrumented
+fun:ctermid=uninstrumented
+fun:ctime=uninstrumented
+fun:ctime_r=uninstrumented
+fun:cuserid=uninstrumented
+fun:daemon=uninstrumented
+fun:dcgettext=uninstrumented
+fun:dcngettext=uninstrumented
+fun:delete_module=uninstrumented
+fun:des_setparity=uninstrumented
+fun:dgettext=uninstrumented
+fun:difftime=uninstrumented
+fun:dirfd=uninstrumented
+fun:dirname=uninstrumented
+fun:div=uninstrumented
+fun:dl_iterate_phdr=uninstrumented
+fun:dladdr=uninstrumented
+fun:dladdr1=uninstrumented
+fun:dlclose=uninstrumented
+fun:dlerror=uninstrumented
+fun:dlinfo=uninstrumented
+fun:dlmopen=uninstrumented
+fun:dlopen=uninstrumented
+fun:dlsym=uninstrumented
+fun:dlvsym=uninstrumented
+fun:dngettext=uninstrumented
+fun:dprintf=uninstrumented
+fun:drand48=uninstrumented
+fun:drand48_r=uninstrumented
+fun:drem=uninstrumented
+fun:dremf=uninstrumented
+fun:dreml=uninstrumented
+fun:dup=uninstrumented
+fun:dup2=uninstrumented
+fun:dup3=uninstrumented
+fun:duplocale=uninstrumented
+fun:dysize=uninstrumented
+fun:eaccess=uninstrumented
+fun:ecb_crypt=uninstrumented
+fun:ecvt=uninstrumented
+fun:ecvt_r=uninstrumented
+fun:encrypt=uninstrumented
+fun:encrypt_r=uninstrumented
+fun:endaliasent=uninstrumented
+fun:endfsent=uninstrumented
+fun:endgrent=uninstrumented
+fun:endhostent=uninstrumented
+fun:endmntent=uninstrumented
+fun:endnetent=uninstrumented
+fun:endnetgrent=uninstrumented
+fun:endprotoent=uninstrumented
+fun:endpwent=uninstrumented
+fun:endrpcent=uninstrumented
+fun:endservent=uninstrumented
+fun:endsgent=uninstrumented
+fun:endspent=uninstrumented
+fun:endttyent=uninstrumented
+fun:endusershell=uninstrumented
+fun:endutent=uninstrumented
+fun:endutxent=uninstrumented
+fun:envz_add=uninstrumented
+fun:envz_entry=uninstrumented
+fun:envz_get=uninstrumented
+fun:envz_merge=uninstrumented
+fun:envz_remove=uninstrumented
+fun:envz_strip=uninstrumented
+fun:epoll_create=uninstrumented
+fun:epoll_create1=uninstrumented
+fun:epoll_ctl=uninstrumented
+fun:epoll_pwait=uninstrumented
+fun:epoll_wait=uninstrumented
+fun:erand48=uninstrumented
+fun:erand48_r=uninstrumented
+fun:erf=uninstrumented
+fun:erfc=uninstrumented
+fun:erfcf=uninstrumented
+fun:erfcl=uninstrumented
+fun:erff=uninstrumented
+fun:erfl=uninstrumented
+fun:err=uninstrumented
+fun:error=uninstrumented
+fun:error_at_line=uninstrumented
+fun:errx=uninstrumented
+fun:ether_aton=uninstrumented
+fun:ether_aton_r=uninstrumented
+fun:ether_hostton=uninstrumented
+fun:ether_line=uninstrumented
+fun:ether_ntoa=uninstrumented
+fun:ether_ntoa_r=uninstrumented
+fun:ether_ntohost=uninstrumented
+fun:euidaccess=uninstrumented
+fun:eventfd=uninstrumented
+fun:eventfd_read=uninstrumented
+fun:eventfd_write=uninstrumented
+fun:execl=uninstrumented
+fun:execle=uninstrumented
+fun:execlp=uninstrumented
+fun:execv=uninstrumented
+fun:execve=uninstrumented
+fun:execvp=uninstrumented
+fun:execvpe=uninstrumented
+fun:exit=uninstrumented
+fun:exp=uninstrumented
+fun:exp10=uninstrumented
+fun:exp10f=uninstrumented
+fun:exp10l=uninstrumented
+fun:exp2=uninstrumented
+fun:exp2f=uninstrumented
+fun:exp2l=uninstrumented
+fun:expf=uninstrumented
+fun:expl=uninstrumented
+fun:expm1=uninstrumented
+fun:expm1f=uninstrumented
+fun:expm1l=uninstrumented
+fun:fabs=uninstrumented
+fun:fabsf=uninstrumented
+fun:fabsl=uninstrumented
+fun:faccessat=uninstrumented
+fun:fallocate=uninstrumented
+fun:fallocate64=uninstrumented
+fun:fanotify_init=uninstrumented
+fun:fanotify_mark=uninstrumented
+fun:fattach=uninstrumented
+fun:fchdir=uninstrumented
+fun:fchflags=uninstrumented
+fun:fchmod=uninstrumented
+fun:fchmodat=uninstrumented
+fun:fchown=uninstrumented
+fun:fchownat=uninstrumented
+fun:fclose=uninstrumented
+fun:fcloseall=uninstrumented
+fun:fcntl=uninstrumented
+fun:fcrypt=uninstrumented
+fun:fcvt=uninstrumented
+fun:fcvt_r=uninstrumented
+fun:fdatasync=uninstrumented
+fun:fdetach=uninstrumented
+fun:fdim=uninstrumented
+fun:fdimf=uninstrumented
+fun:fdiml=uninstrumented
+fun:fdopen=uninstrumented
+fun:fdopendir=uninstrumented
+fun:feclearexcept=uninstrumented
+fun:fedisableexcept=uninstrumented
+fun:feenableexcept=uninstrumented
+fun:fegetenv=uninstrumented
+fun:fegetexcept=uninstrumented
+fun:fegetexceptflag=uninstrumented
+fun:fegetround=uninstrumented
+fun:feholdexcept=uninstrumented
+fun:feof=uninstrumented
+fun:feof_unlocked=uninstrumented
+fun:feraiseexcept=uninstrumented
+fun:ferror=uninstrumented
+fun:ferror_unlocked=uninstrumented
+fun:fesetenv=uninstrumented
+fun:fesetexceptflag=uninstrumented
+fun:fesetround=uninstrumented
+fun:fetestexcept=uninstrumented
+fun:feupdateenv=uninstrumented
+fun:fexecve=uninstrumented
+fun:fflush=uninstrumented
+fun:fflush_unlocked=uninstrumented
+fun:ffs=uninstrumented
+fun:ffsl=uninstrumented
+fun:ffsll=uninstrumented
+fun:fgetc=uninstrumented
+fun:fgetc_unlocked=uninstrumented
+fun:fgetgrent=uninstrumented
+fun:fgetgrent_r=uninstrumented
+fun:fgetpos=uninstrumented
+fun:fgetpos64=uninstrumented
+fun:fgetpwent=uninstrumented
+fun:fgetpwent_r=uninstrumented
+fun:fgets=uninstrumented
+fun:fgets_unlocked=uninstrumented
+fun:fgetsgent=uninstrumented
+fun:fgetsgent_r=uninstrumented
+fun:fgetspent=uninstrumented
+fun:fgetspent_r=uninstrumented
+fun:fgetwc=uninstrumented
+fun:fgetwc_unlocked=uninstrumented
+fun:fgetws=uninstrumented
+fun:fgetws_unlocked=uninstrumented
+fun:fgetxattr=uninstrumented
+fun:fileno=uninstrumented
+fun:fileno_unlocked=uninstrumented
+fun:finite=uninstrumented
+fun:finitef=uninstrumented
+fun:finitel=uninstrumented
+fun:flistxattr=uninstrumented
+fun:flock=uninstrumented
+fun:flockfile=uninstrumented
+fun:floor=uninstrumented
+fun:floorf=uninstrumented
+fun:floorl=uninstrumented
+fun:fma=uninstrumented
+fun:fmaf=uninstrumented
+fun:fmal=uninstrumented
+fun:fmax=uninstrumented
+fun:fmaxf=uninstrumented
+fun:fmaxl=uninstrumented
+fun:fmemopen=uninstrumented
+fun:fmin=uninstrumented
+fun:fminf=uninstrumented
+fun:fminl=uninstrumented
+fun:fmod=uninstrumented
+fun:fmodf=uninstrumented
+fun:fmodl=uninstrumented
+fun:fmtmsg=uninstrumented
+fun:fnmatch=uninstrumented
+fun:fopen=uninstrumented
+fun:fopen64=uninstrumented
+fun:fopencookie=uninstrumented
+fun:fork=uninstrumented
+fun:forkpty=uninstrumented
+fun:fpathconf=uninstrumented
+fun:fprintf=uninstrumented
+fun:fputc=uninstrumented
+fun:fputc_unlocked=uninstrumented
+fun:fputs=uninstrumented
+fun:fputs_unlocked=uninstrumented
+fun:fputwc=uninstrumented
+fun:fputwc_unlocked=uninstrumented
+fun:fputws=uninstrumented
+fun:fputws_unlocked=uninstrumented
+fun:fread=uninstrumented
+fun:fread_unlocked=uninstrumented
+fun:free=uninstrumented
+fun:freeaddrinfo=uninstrumented
+fun:freeifaddrs=uninstrumented
+fun:freelocale=uninstrumented
+fun:fremovexattr=uninstrumented
+fun:freopen=uninstrumented
+fun:freopen64=uninstrumented
+fun:frexp=uninstrumented
+fun:frexpf=uninstrumented
+fun:frexpl=uninstrumented
+fun:fscanf=uninstrumented
+fun:fseek=uninstrumented
+fun:fseeko=uninstrumented
+fun:fseeko64=uninstrumented
+fun:fsetpos=uninstrumented
+fun:fsetpos64=uninstrumented
+fun:fsetxattr=uninstrumented
+fun:fstat=uninstrumented
+fun:fstat64=uninstrumented
+fun:fstatat=uninstrumented
+fun:fstatat64=uninstrumented
+fun:fstatfs=uninstrumented
+fun:fstatfs64=uninstrumented
+fun:fstatvfs=uninstrumented
+fun:fstatvfs64=uninstrumented
+fun:fsync=uninstrumented
+fun:ftell=uninstrumented
+fun:ftello=uninstrumented
+fun:ftello64=uninstrumented
+fun:ftime=uninstrumented
+fun:ftok=uninstrumented
+fun:ftruncate=uninstrumented
+fun:ftruncate64=uninstrumented
+fun:ftrylockfile=uninstrumented
+fun:fts_children=uninstrumented
+fun:fts_close=uninstrumented
+fun:fts_open=uninstrumented
+fun:fts_read=uninstrumented
+fun:fts_set=uninstrumented
+fun:ftw=uninstrumented
+fun:ftw64=uninstrumented
+fun:funlockfile=uninstrumented
+fun:futimens=uninstrumented
+fun:futimes=uninstrumented
+fun:futimesat=uninstrumented
+fun:fwide=uninstrumented
+fun:fwprintf=uninstrumented
+fun:fwrite=uninstrumented
+fun:fwrite_unlocked=uninstrumented
+fun:fwscanf=uninstrumented
+fun:gai_cancel=uninstrumented
+fun:gai_error=uninstrumented
+fun:gai_strerror=uninstrumented
+fun:gai_suspend=uninstrumented
+fun:gamma=uninstrumented
+fun:gammaf=uninstrumented
+fun:gammal=uninstrumented
+fun:gcvt=uninstrumented
+fun:get_avphys_pages=uninstrumented
+fun:get_current_dir_name=uninstrumented
+fun:get_kernel_syms=uninstrumented
+fun:get_myaddress=uninstrumented
+fun:get_nprocs=uninstrumented
+fun:get_nprocs_conf=uninstrumented
+fun:get_phys_pages=uninstrumented
+fun:getaddrinfo=uninstrumented
+fun:getaddrinfo_a=uninstrumented
+fun:getaliasbyname=uninstrumented
+fun:getaliasbyname_r=uninstrumented
+fun:getaliasent=uninstrumented
+fun:getaliasent_r=uninstrumented
+fun:getauxval=uninstrumented
+fun:getc=uninstrumented
+fun:getc_unlocked=uninstrumented
+fun:getchar=uninstrumented
+fun:getchar_unlocked=uninstrumented
+fun:getcontext=uninstrumented
+fun:getcwd=uninstrumented
+fun:getdate=uninstrumented
+fun:getdate_r=uninstrumented
+fun:getdelim=uninstrumented
+fun:getdirentries=uninstrumented
+fun:getdirentries64=uninstrumented
+fun:getdomainname=uninstrumented
+fun:getdtablesize=uninstrumented
+fun:getegid=uninstrumented
+fun:getenv=uninstrumented
+fun:geteuid=uninstrumented
+fun:getfsent=uninstrumented
+fun:getfsfile=uninstrumented
+fun:getfsspec=uninstrumented
+fun:getgid=uninstrumented
+fun:getgrent=uninstrumented
+fun:getgrent_r=uninstrumented
+fun:getgrgid=uninstrumented
+fun:getgrgid_r=uninstrumented
+fun:getgrnam=uninstrumented
+fun:getgrnam_r=uninstrumented
+fun:getgrouplist=uninstrumented
+fun:getgroups=uninstrumented
+fun:gethostbyaddr=uninstrumented
+fun:gethostbyaddr_r=uninstrumented
+fun:gethostbyname=uninstrumented
+fun:gethostbyname2=uninstrumented
+fun:gethostbyname2_r=uninstrumented
+fun:gethostbyname_r=uninstrumented
+fun:gethostent=uninstrumented
+fun:gethostent_r=uninstrumented
+fun:gethostid=uninstrumented
+fun:gethostname=uninstrumented
+fun:getifaddrs=uninstrumented
+fun:getipv4sourcefilter=uninstrumented
+fun:getitimer=uninstrumented
+fun:getline=uninstrumented
+fun:getloadavg=uninstrumented
+fun:getlogin=uninstrumented
+fun:getlogin_r=uninstrumented
+fun:getmntent=uninstrumented
+fun:getmntent_r=uninstrumented
+fun:getmsg=uninstrumented
+fun:getnameinfo=uninstrumented
+fun:getnetbyaddr=uninstrumented
+fun:getnetbyaddr_r=uninstrumented
+fun:getnetbyname=uninstrumented
+fun:getnetbyname_r=uninstrumented
+fun:getnetent=uninstrumented
+fun:getnetent_r=uninstrumented
+fun:getnetgrent=uninstrumented
+fun:getnetgrent_r=uninstrumented
+fun:getnetname=uninstrumented
+fun:getopt=uninstrumented
+fun:getopt_long=uninstrumented
+fun:getopt_long_only=uninstrumented
+fun:getpagesize=uninstrumented
+fun:getpass=uninstrumented
+fun:getpeername=uninstrumented
+fun:getpgid=uninstrumented
+fun:getpgrp=uninstrumented
+fun:getpid=uninstrumented
+fun:getpmsg=uninstrumented
+fun:getppid=uninstrumented
+fun:getpriority=uninstrumented
+fun:getprotobyname=uninstrumented
+fun:getprotobyname_r=uninstrumented
+fun:getprotobynumber=uninstrumented
+fun:getprotobynumber_r=uninstrumented
+fun:getprotoent=uninstrumented
+fun:getprotoent_r=uninstrumented
+fun:getpt=uninstrumented
+fun:getpublickey=uninstrumented
+fun:getpw=uninstrumented
+fun:getpwent=uninstrumented
+fun:getpwent_r=uninstrumented
+fun:getpwnam=uninstrumented
+fun:getpwnam_r=uninstrumented
+fun:getpwuid=uninstrumented
+fun:getpwuid_r=uninstrumented
+fun:getresgid=uninstrumented
+fun:getresuid=uninstrumented
+fun:getrlimit=uninstrumented
+fun:getrlimit64=uninstrumented
+fun:getrpcbyname=uninstrumented
+fun:getrpcbyname_r=uninstrumented
+fun:getrpcbynumber=uninstrumented
+fun:getrpcbynumber_r=uninstrumented
+fun:getrpcent=uninstrumented
+fun:getrpcent_r=uninstrumented
+fun:getrpcport=uninstrumented
+fun:getrusage=uninstrumented
+fun:gets=uninstrumented
+fun:getsecretkey=uninstrumented
+fun:getservbyname=uninstrumented
+fun:getservbyname_r=uninstrumented
+fun:getservbyport=uninstrumented
+fun:getservbyport_r=uninstrumented
+fun:getservent=uninstrumented
+fun:getservent_r=uninstrumented
+fun:getsgent=uninstrumented
+fun:getsgent_r=uninstrumented
+fun:getsgnam=uninstrumented
+fun:getsgnam_r=uninstrumented
+fun:getsid=uninstrumented
+fun:getsockname=uninstrumented
+fun:getsockopt=uninstrumented
+fun:getsourcefilter=uninstrumented
+fun:getspent=uninstrumented
+fun:getspent_r=uninstrumented
+fun:getspnam=uninstrumented
+fun:getspnam_r=uninstrumented
+fun:getsubopt=uninstrumented
+fun:gettext=uninstrumented
+fun:gettimeofday=uninstrumented
+fun:getttyent=uninstrumented
+fun:getttynam=uninstrumented
+fun:getuid=uninstrumented
+fun:getusershell=uninstrumented
+fun:getutent=uninstrumented
+fun:getutent_r=uninstrumented
+fun:getutid=uninstrumented
+fun:getutid_r=uninstrumented
+fun:getutline=uninstrumented
+fun:getutline_r=uninstrumented
+fun:getutmp=uninstrumented
+fun:getutmpx=uninstrumented
+fun:getutxent=uninstrumented
+fun:getutxid=uninstrumented
+fun:getutxline=uninstrumented
+fun:getw=uninstrumented
+fun:getwc=uninstrumented
+fun:getwc_unlocked=uninstrumented
+fun:getwchar=uninstrumented
+fun:getwchar_unlocked=uninstrumented
+fun:getwd=uninstrumented
+fun:getxattr=uninstrumented
+fun:glob=uninstrumented
+fun:glob64=uninstrumented
+fun:glob_pattern_p=uninstrumented
+fun:globfree=uninstrumented
+fun:globfree64=uninstrumented
+fun:gmtime=uninstrumented
+fun:gmtime_r=uninstrumented
+fun:gnu_dev_major=uninstrumented
+fun:gnu_dev_makedev=uninstrumented
+fun:gnu_dev_minor=uninstrumented
+fun:gnu_get_libc_release=uninstrumented
+fun:gnu_get_libc_version=uninstrumented
+fun:grantpt=uninstrumented
+fun:group_member=uninstrumented
+fun:gsignal=uninstrumented
+fun:gtty=uninstrumented
+fun:hasmntopt=uninstrumented
+fun:hcreate=uninstrumented
+fun:hcreate_r=uninstrumented
+fun:hdestroy=uninstrumented
+fun:hdestroy_r=uninstrumented
+fun:herror=uninstrumented
+fun:host2netname=uninstrumented
+fun:hsearch=uninstrumented
+fun:hsearch_r=uninstrumented
+fun:hstrerror=uninstrumented
+fun:htonl=uninstrumented
+fun:htons=uninstrumented
+fun:hypot=uninstrumented
+fun:hypotf=uninstrumented
+fun:hypotl=uninstrumented
+fun:iconv=uninstrumented
+fun:iconv_close=uninstrumented
+fun:iconv_open=uninstrumented
+fun:idna_to_ascii_lz=uninstrumented
+fun:idna_to_unicode_lzlz=uninstrumented
+fun:if_freenameindex=uninstrumented
+fun:if_indextoname=uninstrumented
+fun:if_nameindex=uninstrumented
+fun:if_nametoindex=uninstrumented
+fun:ilogb=uninstrumented
+fun:ilogbf=uninstrumented
+fun:ilogbl=uninstrumented
+fun:imaxabs=uninstrumented
+fun:imaxdiv=uninstrumented
+fun:index=uninstrumented
+fun:inet6_opt_append=uninstrumented
+fun:inet6_opt_find=uninstrumented
+fun:inet6_opt_finish=uninstrumented
+fun:inet6_opt_get_val=uninstrumented
+fun:inet6_opt_init=uninstrumented
+fun:inet6_opt_next=uninstrumented
+fun:inet6_opt_set_val=uninstrumented
+fun:inet6_option_alloc=uninstrumented
+fun:inet6_option_append=uninstrumented
+fun:inet6_option_find=uninstrumented
+fun:inet6_option_init=uninstrumented
+fun:inet6_option_next=uninstrumented
+fun:inet6_option_space=uninstrumented
+fun:inet6_rth_add=uninstrumented
+fun:inet6_rth_getaddr=uninstrumented
+fun:inet6_rth_init=uninstrumented
+fun:inet6_rth_reverse=uninstrumented
+fun:inet6_rth_segments=uninstrumented
+fun:inet6_rth_space=uninstrumented
+fun:inet_addr=uninstrumented
+fun:inet_aton=uninstrumented
+fun:inet_lnaof=uninstrumented
+fun:inet_makeaddr=uninstrumented
+fun:inet_net_ntop=uninstrumented
+fun:inet_net_pton=uninstrumented
+fun:inet_neta=uninstrumented
+fun:inet_netof=uninstrumented
+fun:inet_network=uninstrumented
+fun:inet_nsap_addr=uninstrumented
+fun:inet_nsap_ntoa=uninstrumented
+fun:inet_ntoa=uninstrumented
+fun:inet_ntop=uninstrumented
+fun:inet_pton=uninstrumented
+fun:init_module=uninstrumented
+fun:initgroups=uninstrumented
+fun:initstate=uninstrumented
+fun:initstate_r=uninstrumented
+fun:innetgr=uninstrumented
+fun:inotify_add_watch=uninstrumented
+fun:inotify_init=uninstrumented
+fun:inotify_init1=uninstrumented
+fun:inotify_rm_watch=uninstrumented
+fun:insque=uninstrumented
+fun:ioctl=uninstrumented
+fun:ioperm=uninstrumented
+fun:iopl=uninstrumented
+fun:iruserok=uninstrumented
+fun:iruserok_af=uninstrumented
+fun:isalnum=uninstrumented
+fun:isalnum_l=uninstrumented
+fun:isalpha=uninstrumented
+fun:isalpha_l=uninstrumented
+fun:isascii=uninstrumented
+fun:isastream=uninstrumented
+fun:isatty=uninstrumented
+fun:isblank=uninstrumented
+fun:isblank_l=uninstrumented
+fun:iscntrl=uninstrumented
+fun:iscntrl_l=uninstrumented
+fun:isctype=uninstrumented
+fun:isdigit=uninstrumented
+fun:isdigit_l=uninstrumented
+fun:isfdtype=uninstrumented
+fun:isgraph=uninstrumented
+fun:isgraph_l=uninstrumented
+fun:isinf=uninstrumented
+fun:isinfd128=uninstrumented
+fun:isinfd32=uninstrumented
+fun:isinfd64=uninstrumented
+fun:isinff=uninstrumented
+fun:isinfl=uninstrumented
+fun:islower=uninstrumented
+fun:islower_l=uninstrumented
+fun:isnan=uninstrumented
+fun:isnanf=uninstrumented
+fun:isnanl=uninstrumented
+fun:isprint=uninstrumented
+fun:isprint_l=uninstrumented
+fun:ispunct=uninstrumented
+fun:ispunct_l=uninstrumented
+fun:isspace=uninstrumented
+fun:isspace_l=uninstrumented
+fun:isupper=uninstrumented
+fun:isupper_l=uninstrumented
+fun:iswalnum=uninstrumented
+fun:iswalnum_l=uninstrumented
+fun:iswalpha=uninstrumented
+fun:iswalpha_l=uninstrumented
+fun:iswblank=uninstrumented
+fun:iswblank_l=uninstrumented
+fun:iswcntrl=uninstrumented
+fun:iswcntrl_l=uninstrumented
+fun:iswctype=uninstrumented
+fun:iswctype_l=uninstrumented
+fun:iswdigit=uninstrumented
+fun:iswdigit_l=uninstrumented
+fun:iswgraph=uninstrumented
+fun:iswgraph_l=uninstrumented
+fun:iswlower=uninstrumented
+fun:iswlower_l=uninstrumented
+fun:iswprint=uninstrumented
+fun:iswprint_l=uninstrumented
+fun:iswpunct=uninstrumented
+fun:iswpunct_l=uninstrumented
+fun:iswspace=uninstrumented
+fun:iswspace_l=uninstrumented
+fun:iswupper=uninstrumented
+fun:iswupper_l=uninstrumented
+fun:iswxdigit=uninstrumented
+fun:iswxdigit_l=uninstrumented
+fun:isxdigit=uninstrumented
+fun:isxdigit_l=uninstrumented
+fun:j0=uninstrumented
+fun:j0f=uninstrumented
+fun:j0l=uninstrumented
+fun:j1=uninstrumented
+fun:j1f=uninstrumented
+fun:j1l=uninstrumented
+fun:jn=uninstrumented
+fun:jnf=uninstrumented
+fun:jnl=uninstrumented
+fun:jrand48=uninstrumented
+fun:jrand48_r=uninstrumented
+fun:key_decryptsession=uninstrumented
+fun:key_decryptsession_pk=uninstrumented
+fun:key_encryptsession=uninstrumented
+fun:key_encryptsession_pk=uninstrumented
+fun:key_gendes=uninstrumented
+fun:key_get_conv=uninstrumented
+fun:key_secretkey_is_set=uninstrumented
+fun:key_setnet=uninstrumented
+fun:key_setsecret=uninstrumented
+fun:kill=uninstrumented
+fun:killpg=uninstrumented
+fun:klogctl=uninstrumented
+fun:l64a=uninstrumented
+fun:labs=uninstrumented
+fun:lchmod=uninstrumented
+fun:lchown=uninstrumented
+fun:lckpwdf=uninstrumented
+fun:lcong48=uninstrumented
+fun:lcong48_r=uninstrumented
+fun:ldexp=uninstrumented
+fun:ldexpf=uninstrumented
+fun:ldexpl=uninstrumented
+fun:ldiv=uninstrumented
+fun:lfind=uninstrumented
+fun:lgamma=uninstrumented
+fun:lgamma_r=uninstrumented
+fun:lgammaf=uninstrumented
+fun:lgammaf_r=uninstrumented
+fun:lgammal=uninstrumented
+fun:lgammal_r=uninstrumented
+fun:lgetxattr=uninstrumented
+fun:link=uninstrumented
+fun:linkat=uninstrumented
+fun:lio_listio=uninstrumented
+fun:lio_listio64=uninstrumented
+fun:listen=uninstrumented
+fun:listxattr=uninstrumented
+fun:llabs=uninstrumented
+fun:lldiv=uninstrumented
+fun:llistxattr=uninstrumented
+fun:llrint=uninstrumented
+fun:llrintf=uninstrumented
+fun:llrintl=uninstrumented
+fun:llround=uninstrumented
+fun:llroundf=uninstrumented
+fun:llroundl=uninstrumented
+fun:llseek=uninstrumented
+fun:localeconv=uninstrumented
+fun:localtime=uninstrumented
+fun:localtime_r=uninstrumented
+fun:lockf=uninstrumented
+fun:lockf64=uninstrumented
+fun:log=uninstrumented
+fun:log10=uninstrumented
+fun:log10f=uninstrumented
+fun:log10l=uninstrumented
+fun:log1p=uninstrumented
+fun:log1pf=uninstrumented
+fun:log1pl=uninstrumented
+fun:log2=uninstrumented
+fun:log2f=uninstrumented
+fun:log2l=uninstrumented
+fun:logb=uninstrumented
+fun:logbf=uninstrumented
+fun:logbl=uninstrumented
+fun:logf=uninstrumented
+fun:login=uninstrumented
+fun:login_tty=uninstrumented
+fun:logl=uninstrumented
+fun:logout=uninstrumented
+fun:logwtmp=uninstrumented
+fun:longjmp=uninstrumented
+fun:lrand48=uninstrumented
+fun:lrand48_r=uninstrumented
+fun:lremovexattr=uninstrumented
+fun:lrint=uninstrumented
+fun:lrintf=uninstrumented
+fun:lrintl=uninstrumented
+fun:lround=uninstrumented
+fun:lroundf=uninstrumented
+fun:lroundl=uninstrumented
+fun:lsearch=uninstrumented
+fun:lseek=uninstrumented
+fun:lseek64=uninstrumented
+fun:lsetxattr=uninstrumented
+fun:lstat=uninstrumented
+fun:lstat64=uninstrumented
+fun:lutimes=uninstrumented
+fun:madvise=uninstrumented
+fun:makecontext=uninstrumented
+fun:mallinfo=uninstrumented
+fun:malloc=uninstrumented
+fun:malloc_get_state=uninstrumented
+fun:malloc_info=uninstrumented
+fun:malloc_set_state=uninstrumented
+fun:malloc_stats=uninstrumented
+fun:malloc_trim=uninstrumented
+fun:malloc_usable_size=uninstrumented
+fun:mallopt=uninstrumented
+fun:matherr=uninstrumented
+fun:mblen=uninstrumented
+fun:mbrlen=uninstrumented
+fun:mbrtoc16=uninstrumented
+fun:mbrtoc32=uninstrumented
+fun:mbrtowc=uninstrumented
+fun:mbsinit=uninstrumented
+fun:mbsnrtowcs=uninstrumented
+fun:mbsrtowcs=uninstrumented
+fun:mbstowcs=uninstrumented
+fun:mbtowc=uninstrumented
+fun:mcheck=uninstrumented
+fun:mcheck_check_all=uninstrumented
+fun:mcheck_pedantic=uninstrumented
+fun:mcount=uninstrumented
+fun:memalign=uninstrumented
+fun:memccpy=uninstrumented
+fun:memchr=uninstrumented
+fun:memcmp=uninstrumented
+fun:memcpy=uninstrumented
+fun:memfrob=uninstrumented
+fun:memmem=uninstrumented
+fun:memmove=uninstrumented
+fun:mempcpy=uninstrumented
+fun:memrchr=uninstrumented
+fun:memset=uninstrumented
+fun:mincore=uninstrumented
+fun:mkdir=uninstrumented
+fun:mkdirat=uninstrumented
+fun:mkdtemp=uninstrumented
+fun:mkfifo=uninstrumented
+fun:mkfifoat=uninstrumented
+fun:mknod=uninstrumented
+fun:mknodat=uninstrumented
+fun:mkostemp=uninstrumented
+fun:mkostemp64=uninstrumented
+fun:mkostemps=uninstrumented
+fun:mkostemps64=uninstrumented
+fun:mkstemp=uninstrumented
+fun:mkstemp64=uninstrumented
+fun:mkstemps=uninstrumented
+fun:mkstemps64=uninstrumented
+fun:mktemp=uninstrumented
+fun:mktime=uninstrumented
+fun:mlock=uninstrumented
+fun:mlockall=uninstrumented
+fun:mmap=uninstrumented
+fun:mmap64=uninstrumented
+fun:modf=uninstrumented
+fun:modff=uninstrumented
+fun:modfl=uninstrumented
+fun:modify_ldt=uninstrumented
+fun:moncontrol=uninstrumented
+fun:monstartup=uninstrumented
+fun:mount=uninstrumented
+fun:mprobe=uninstrumented
+fun:mprotect=uninstrumented
+fun:mq_close=uninstrumented
+fun:mq_getattr=uninstrumented
+fun:mq_notify=uninstrumented
+fun:mq_open=uninstrumented
+fun:mq_receive=uninstrumented
+fun:mq_send=uninstrumented
+fun:mq_setattr=uninstrumented
+fun:mq_timedreceive=uninstrumented
+fun:mq_timedsend=uninstrumented
+fun:mq_unlink=uninstrumented
+fun:mrand48=uninstrumented
+fun:mrand48_r=uninstrumented
+fun:mremap=uninstrumented
+fun:msgctl=uninstrumented
+fun:msgget=uninstrumented
+fun:msgrcv=uninstrumented
+fun:msgsnd=uninstrumented
+fun:msync=uninstrumented
+fun:mtrace=uninstrumented
+fun:munlock=uninstrumented
+fun:munlockall=uninstrumented
+fun:munmap=uninstrumented
+fun:muntrace=uninstrumented
+fun:name_to_handle_at=uninstrumented
+fun:nan=uninstrumented
+fun:nanf=uninstrumented
+fun:nanl=uninstrumented
+fun:nanosleep=uninstrumented
+fun:nearbyint=uninstrumented
+fun:nearbyintf=uninstrumented
+fun:nearbyintl=uninstrumented
+fun:netname2host=uninstrumented
+fun:netname2user=uninstrumented
+fun:newlocale=uninstrumented
+fun:nextafter=uninstrumented
+fun:nextafterf=uninstrumented
+fun:nextafterl=uninstrumented
+fun:nexttoward=uninstrumented
+fun:nexttowardf=uninstrumented
+fun:nexttowardl=uninstrumented
+fun:nfsservctl=uninstrumented
+fun:nftw=uninstrumented
+fun:nftw64=uninstrumented
+fun:ngettext=uninstrumented
+fun:nice=uninstrumented
+fun:nis_add=uninstrumented
+fun:nis_add_entry=uninstrumented
+fun:nis_addmember=uninstrumented
+fun:nis_checkpoint=uninstrumented
+fun:nis_clone_directory=uninstrumented
+fun:nis_clone_object=uninstrumented
+fun:nis_clone_result=uninstrumented
+fun:nis_creategroup=uninstrumented
+fun:nis_destroy_object=uninstrumented
+fun:nis_destroygroup=uninstrumented
+fun:nis_dir_cmp=uninstrumented
+fun:nis_domain_of=uninstrumented
+fun:nis_domain_of_r=uninstrumented
+fun:nis_first_entry=uninstrumented
+fun:nis_free_directory=uninstrumented
+fun:nis_free_object=uninstrumented
+fun:nis_free_request=uninstrumented
+fun:nis_freenames=uninstrumented
+fun:nis_freeresult=uninstrumented
+fun:nis_freeservlist=uninstrumented
+fun:nis_freetags=uninstrumented
+fun:nis_getnames=uninstrumented
+fun:nis_getservlist=uninstrumented
+fun:nis_ismember=uninstrumented
+fun:nis_leaf_of=uninstrumented
+fun:nis_leaf_of_r=uninstrumented
+fun:nis_lerror=uninstrumented
+fun:nis_list=uninstrumented
+fun:nis_local_directory=uninstrumented
+fun:nis_local_group=uninstrumented
+fun:nis_local_host=uninstrumented
+fun:nis_local_principal=uninstrumented
+fun:nis_lookup=uninstrumented
+fun:nis_mkdir=uninstrumented
+fun:nis_modify=uninstrumented
+fun:nis_modify_entry=uninstrumented
+fun:nis_name_of=uninstrumented
+fun:nis_name_of_r=uninstrumented
+fun:nis_next_entry=uninstrumented
+fun:nis_perror=uninstrumented
+fun:nis_ping=uninstrumented
+fun:nis_print_directory=uninstrumented
+fun:nis_print_entry=uninstrumented
+fun:nis_print_group=uninstrumented
+fun:nis_print_group_entry=uninstrumented
+fun:nis_print_link=uninstrumented
+fun:nis_print_object=uninstrumented
+fun:nis_print_result=uninstrumented
+fun:nis_print_rights=uninstrumented
+fun:nis_print_table=uninstrumented
+fun:nis_read_obj=uninstrumented
+fun:nis_remove=uninstrumented
+fun:nis_remove_entry=uninstrumented
+fun:nis_removemember=uninstrumented
+fun:nis_rmdir=uninstrumented
+fun:nis_servstate=uninstrumented
+fun:nis_sperrno=uninstrumented
+fun:nis_sperror=uninstrumented
+fun:nis_sperror_r=uninstrumented
+fun:nis_stats=uninstrumented
+fun:nis_verifygroup=uninstrumented
+fun:nis_write_obj=uninstrumented
+fun:nl_langinfo=uninstrumented
+fun:nl_langinfo_l=uninstrumented
+fun:nrand48=uninstrumented
+fun:nrand48_r=uninstrumented
+fun:ns_datetosecs=uninstrumented
+fun:ns_format_ttl=uninstrumented
+fun:ns_get16=uninstrumented
+fun:ns_get32=uninstrumented
+fun:ns_initparse=uninstrumented
+fun:ns_makecanon=uninstrumented
+fun:ns_msg_getflag=uninstrumented
+fun:ns_name_compress=uninstrumented
+fun:ns_name_ntol=uninstrumented
+fun:ns_name_ntop=uninstrumented
+fun:ns_name_pack=uninstrumented
+fun:ns_name_pton=uninstrumented
+fun:ns_name_rollback=uninstrumented
+fun:ns_name_skip=uninstrumented
+fun:ns_name_uncompress=uninstrumented
+fun:ns_name_unpack=uninstrumented
+fun:ns_parse_ttl=uninstrumented
+fun:ns_parserr=uninstrumented
+fun:ns_put16=uninstrumented
+fun:ns_put32=uninstrumented
+fun:ns_samedomain=uninstrumented
+fun:ns_samename=uninstrumented
+fun:ns_skiprr=uninstrumented
+fun:ns_sprintrr=uninstrumented
+fun:ns_sprintrrf=uninstrumented
+fun:ns_subdomain=uninstrumented
+fun:ntohl=uninstrumented
+fun:ntohs=uninstrumented
+fun:ntp_adjtime=uninstrumented
+fun:ntp_gettime=uninstrumented
+fun:ntp_gettimex=uninstrumented
+fun:obstack_free=uninstrumented
+fun:obstack_printf=uninstrumented
+fun:obstack_vprintf=uninstrumented
+fun:on_exit=uninstrumented
+fun:open=uninstrumented
+fun:open64=uninstrumented
+fun:open_by_handle_at=uninstrumented
+fun:open_memstream=uninstrumented
+fun:open_wmemstream=uninstrumented
+fun:openat=uninstrumented
+fun:openat64=uninstrumented
+fun:opendir=uninstrumented
+fun:openlog=uninstrumented
+fun:openpty=uninstrumented
+fun:parse_printf_format=uninstrumented
+fun:passwd2des=uninstrumented
+fun:pathconf=uninstrumented
+fun:pause=uninstrumented
+fun:pclose=uninstrumented
+fun:perror=uninstrumented
+fun:personality=uninstrumented
+fun:pipe=uninstrumented
+fun:pipe2=uninstrumented
+fun:pivot_root=uninstrumented
+fun:pmap_getmaps=uninstrumented
+fun:pmap_getport=uninstrumented
+fun:pmap_rmtcall=uninstrumented
+fun:pmap_set=uninstrumented
+fun:pmap_unset=uninstrumented
+fun:poll=uninstrumented
+fun:popen=uninstrumented
+fun:posix_fadvise=uninstrumented
+fun:posix_fadvise64=uninstrumented
+fun:posix_fallocate=uninstrumented
+fun:posix_fallocate64=uninstrumented
+fun:posix_madvise=uninstrumented
+fun:posix_memalign=uninstrumented
+fun:posix_openpt=uninstrumented
+fun:posix_spawn=uninstrumented
+fun:posix_spawn_file_actions_addclose=uninstrumented
+fun:posix_spawn_file_actions_adddup2=uninstrumented
+fun:posix_spawn_file_actions_addopen=uninstrumented
+fun:posix_spawn_file_actions_destroy=uninstrumented
+fun:posix_spawn_file_actions_init=uninstrumented
+fun:posix_spawnattr_destroy=uninstrumented
+fun:posix_spawnattr_getflags=uninstrumented
+fun:posix_spawnattr_getpgroup=uninstrumented
+fun:posix_spawnattr_getschedparam=uninstrumented
+fun:posix_spawnattr_getschedpolicy=uninstrumented
+fun:posix_spawnattr_getsigdefault=uninstrumented
+fun:posix_spawnattr_getsigmask=uninstrumented
+fun:posix_spawnattr_init=uninstrumented
+fun:posix_spawnattr_setflags=uninstrumented
+fun:posix_spawnattr_setpgroup=uninstrumented
+fun:posix_spawnattr_setschedparam=uninstrumented
+fun:posix_spawnattr_setschedpolicy=uninstrumented
+fun:posix_spawnattr_setsigdefault=uninstrumented
+fun:posix_spawnattr_setsigmask=uninstrumented
+fun:posix_spawnp=uninstrumented
+fun:pow=uninstrumented
+fun:pow10=uninstrumented
+fun:pow10f=uninstrumented
+fun:pow10l=uninstrumented
+fun:powf=uninstrumented
+fun:powl=uninstrumented
+fun:ppoll=uninstrumented
+fun:prctl=uninstrumented
+fun:pread=uninstrumented
+fun:pread64=uninstrumented
+fun:preadv=uninstrumented
+fun:preadv64=uninstrumented
+fun:printf=uninstrumented
+fun:printf_size=uninstrumented
+fun:printf_size_info=uninstrumented
+fun:prlimit=uninstrumented
+fun:prlimit64=uninstrumented
+fun:process_vm_readv=uninstrumented
+fun:process_vm_writev=uninstrumented
+fun:profil=uninstrumented
+fun:pselect=uninstrumented
+fun:psiginfo=uninstrumented
+fun:psignal=uninstrumented
+fun:pthread_atfork=uninstrumented
+fun:pthread_attr_destroy=uninstrumented
+fun:pthread_attr_getaffinity_np=uninstrumented
+fun:pthread_attr_getdetachstate=uninstrumented
+fun:pthread_attr_getguardsize=uninstrumented
+fun:pthread_attr_getinheritsched=uninstrumented
+fun:pthread_attr_getschedparam=uninstrumented
+fun:pthread_attr_getschedpolicy=uninstrumented
+fun:pthread_attr_getscope=uninstrumented
+fun:pthread_attr_getstack=uninstrumented
+fun:pthread_attr_getstackaddr=uninstrumented
+fun:pthread_attr_getstacksize=uninstrumented
+fun:pthread_attr_init=uninstrumented
+fun:pthread_attr_setaffinity_np=uninstrumented
+fun:pthread_attr_setdetachstate=uninstrumented
+fun:pthread_attr_setguardsize=uninstrumented
+fun:pthread_attr_setinheritsched=uninstrumented
+fun:pthread_attr_setschedparam=uninstrumented
+fun:pthread_attr_setschedpolicy=uninstrumented
+fun:pthread_attr_setscope=uninstrumented
+fun:pthread_attr_setstack=uninstrumented
+fun:pthread_attr_setstackaddr=uninstrumented
+fun:pthread_attr_setstacksize=uninstrumented
+fun:pthread_barrier_destroy=uninstrumented
+fun:pthread_barrier_init=uninstrumented
+fun:pthread_barrier_wait=uninstrumented
+fun:pthread_barrierattr_destroy=uninstrumented
+fun:pthread_barrierattr_getpshared=uninstrumented
+fun:pthread_barrierattr_init=uninstrumented
+fun:pthread_barrierattr_setpshared=uninstrumented
+fun:pthread_cancel=uninstrumented
+fun:pthread_cond_broadcast=uninstrumented
+fun:pthread_cond_destroy=uninstrumented
+fun:pthread_cond_init=uninstrumented
+fun:pthread_cond_signal=uninstrumented
+fun:pthread_cond_timedwait=uninstrumented
+fun:pthread_cond_wait=uninstrumented
+fun:pthread_condattr_destroy=uninstrumented
+fun:pthread_condattr_getclock=uninstrumented
+fun:pthread_condattr_getpshared=uninstrumented
+fun:pthread_condattr_init=uninstrumented
+fun:pthread_condattr_setclock=uninstrumented
+fun:pthread_condattr_setpshared=uninstrumented
+fun:pthread_create=uninstrumented
+fun:pthread_detach=uninstrumented
+fun:pthread_equal=uninstrumented
+fun:pthread_exit=uninstrumented
+fun:pthread_getaffinity_np=uninstrumented
+fun:pthread_getattr_default_np=uninstrumented
+fun:pthread_getattr_np=uninstrumented
+fun:pthread_getconcurrency=uninstrumented
+fun:pthread_getcpuclockid=uninstrumented
+fun:pthread_getname_np=uninstrumented
+fun:pthread_getschedparam=uninstrumented
+fun:pthread_getspecific=uninstrumented
+fun:pthread_join=uninstrumented
+fun:pthread_key_create=uninstrumented
+fun:pthread_key_delete=uninstrumented
+fun:pthread_kill=uninstrumented
+fun:pthread_kill_other_threads_np=uninstrumented
+fun:pthread_mutex_consistent=uninstrumented
+fun:pthread_mutex_consistent_np=uninstrumented
+fun:pthread_mutex_destroy=uninstrumented
+fun:pthread_mutex_getprioceiling=uninstrumented
+fun:pthread_mutex_init=uninstrumented
+fun:pthread_mutex_lock=uninstrumented
+fun:pthread_mutex_setprioceiling=uninstrumented
+fun:pthread_mutex_timedlock=uninstrumented
+fun:pthread_mutex_trylock=uninstrumented
+fun:pthread_mutex_unlock=uninstrumented
+fun:pthread_mutexattr_destroy=uninstrumented
+fun:pthread_mutexattr_getkind_np=uninstrumented
+fun:pthread_mutexattr_getprioceiling=uninstrumented
+fun:pthread_mutexattr_getprotocol=uninstrumented
+fun:pthread_mutexattr_getpshared=uninstrumented
+fun:pthread_mutexattr_getrobust=uninstrumented
+fun:pthread_mutexattr_getrobust_np=uninstrumented
+fun:pthread_mutexattr_gettype=uninstrumented
+fun:pthread_mutexattr_init=uninstrumented
+fun:pthread_mutexattr_setkind_np=uninstrumented
+fun:pthread_mutexattr_setprioceiling=uninstrumented
+fun:pthread_mutexattr_setprotocol=uninstrumented
+fun:pthread_mutexattr_setpshared=uninstrumented
+fun:pthread_mutexattr_setrobust=uninstrumented
+fun:pthread_mutexattr_setrobust_np=uninstrumented
+fun:pthread_mutexattr_settype=uninstrumented
+fun:pthread_once=uninstrumented
+fun:pthread_rwlock_destroy=uninstrumented
+fun:pthread_rwlock_init=uninstrumented
+fun:pthread_rwlock_rdlock=uninstrumented
+fun:pthread_rwlock_timedrdlock=uninstrumented
+fun:pthread_rwlock_timedwrlock=uninstrumented
+fun:pthread_rwlock_tryrdlock=uninstrumented
+fun:pthread_rwlock_trywrlock=uninstrumented
+fun:pthread_rwlock_unlock=uninstrumented
+fun:pthread_rwlock_wrlock=uninstrumented
+fun:pthread_rwlockattr_destroy=uninstrumented
+fun:pthread_rwlockattr_getkind_np=uninstrumented
+fun:pthread_rwlockattr_getpshared=uninstrumented
+fun:pthread_rwlockattr_init=uninstrumented
+fun:pthread_rwlockattr_setkind_np=uninstrumented
+fun:pthread_rwlockattr_setpshared=uninstrumented
+fun:pthread_self=uninstrumented
+fun:pthread_setaffinity_np=uninstrumented
+fun:pthread_setattr_default_np=uninstrumented
+fun:pthread_setcancelstate=uninstrumented
+fun:pthread_setcanceltype=uninstrumented
+fun:pthread_setconcurrency=uninstrumented
+fun:pthread_setname_np=uninstrumented
+fun:pthread_setschedparam=uninstrumented
+fun:pthread_setschedprio=uninstrumented
+fun:pthread_setspecific=uninstrumented
+fun:pthread_sigmask=uninstrumented
+fun:pthread_sigqueue=uninstrumented
+fun:pthread_spin_destroy=uninstrumented
+fun:pthread_spin_init=uninstrumented
+fun:pthread_spin_lock=uninstrumented
+fun:pthread_spin_trylock=uninstrumented
+fun:pthread_spin_unlock=uninstrumented
+fun:pthread_testcancel=uninstrumented
+fun:pthread_timedjoin_np=uninstrumented
+fun:pthread_tryjoin_np=uninstrumented
+fun:pthread_yield=uninstrumented
+fun:ptrace=uninstrumented
+fun:ptsname=uninstrumented
+fun:ptsname_r=uninstrumented
+fun:putc=uninstrumented
+fun:putc_unlocked=uninstrumented
+fun:putchar=uninstrumented
+fun:putchar_unlocked=uninstrumented
+fun:putenv=uninstrumented
+fun:putgrent=uninstrumented
+fun:putmsg=uninstrumented
+fun:putpmsg=uninstrumented
+fun:putpwent=uninstrumented
+fun:puts=uninstrumented
+fun:putsgent=uninstrumented
+fun:putspent=uninstrumented
+fun:pututline=uninstrumented
+fun:pututxline=uninstrumented
+fun:putw=uninstrumented
+fun:putwc=uninstrumented
+fun:putwc_unlocked=uninstrumented
+fun:putwchar=uninstrumented
+fun:putwchar_unlocked=uninstrumented
+fun:pvalloc=uninstrumented
+fun:pwrite=uninstrumented
+fun:pwrite64=uninstrumented
+fun:pwritev=uninstrumented
+fun:pwritev64=uninstrumented
+fun:qecvt=uninstrumented
+fun:qecvt_r=uninstrumented
+fun:qfcvt=uninstrumented
+fun:qfcvt_r=uninstrumented
+fun:qgcvt=uninstrumented
+fun:qsort=uninstrumented
+fun:qsort_r=uninstrumented
+fun:query_module=uninstrumented
+fun:quick_exit=uninstrumented
+fun:quotactl=uninstrumented
+fun:raise=uninstrumented
+fun:rand=uninstrumented
+fun:rand_r=uninstrumented
+fun:random=uninstrumented
+fun:random_r=uninstrumented
+fun:rawmemchr=uninstrumented
+fun:rcmd=uninstrumented
+fun:rcmd_af=uninstrumented
+fun:re_comp=uninstrumented
+fun:re_compile_fastmap=uninstrumented
+fun:re_compile_pattern=uninstrumented
+fun:re_exec=uninstrumented
+fun:re_match=uninstrumented
+fun:re_match_2=uninstrumented
+fun:re_search=uninstrumented
+fun:re_search_2=uninstrumented
+fun:re_set_registers=uninstrumented
+fun:re_set_syntax=uninstrumented
+fun:read=uninstrumented
+fun:readColdStartFile=uninstrumented
+fun:readahead=uninstrumented
+fun:readdir=uninstrumented
+fun:readdir64=uninstrumented
+fun:readdir64_r=uninstrumented
+fun:readdir_r=uninstrumented
+fun:readlink=uninstrumented
+fun:readlinkat=uninstrumented
+fun:readv=uninstrumented
+fun:realloc=uninstrumented
+fun:realpath=uninstrumented
+fun:reboot=uninstrumented
+fun:recv=uninstrumented
+fun:recvfrom=uninstrumented
+fun:recvmmsg=uninstrumented
+fun:recvmsg=uninstrumented
+fun:regcomp=uninstrumented
+fun:regerror=uninstrumented
+fun:regexec=uninstrumented
+fun:regfree=uninstrumented
+fun:register_printf_function=uninstrumented
+fun:register_printf_modifier=uninstrumented
+fun:register_printf_specifier=uninstrumented
+fun:register_printf_type=uninstrumented
+fun:registerrpc=uninstrumented
+fun:remainder=uninstrumented
+fun:remainderf=uninstrumented
+fun:remainderl=uninstrumented
+fun:remap_file_pages=uninstrumented
+fun:remove=uninstrumented
+fun:removexattr=uninstrumented
+fun:remque=uninstrumented
+fun:remquo=uninstrumented
+fun:remquof=uninstrumented
+fun:remquol=uninstrumented
+fun:rename=uninstrumented
+fun:renameat=uninstrumented
+fun:res_gethostbyaddr=uninstrumented
+fun:res_gethostbyname=uninstrumented
+fun:res_gethostbyname2=uninstrumented
+fun:res_send_setqhook=uninstrumented
+fun:res_send_setrhook=uninstrumented
+fun:revoke=uninstrumented
+fun:rewind=uninstrumented
+fun:rewinddir=uninstrumented
+fun:rexec=uninstrumented
+fun:rexec_af=uninstrumented
+fun:rindex=uninstrumented
+fun:rint=uninstrumented
+fun:rintf=uninstrumented
+fun:rintl=uninstrumented
+fun:rmdir=uninstrumented
+fun:round=uninstrumented
+fun:roundf=uninstrumented
+fun:roundl=uninstrumented
+fun:rpmatch=uninstrumented
+fun:rresvport=uninstrumented
+fun:rresvport_af=uninstrumented
+fun:rtime=uninstrumented
+fun:ruserok=uninstrumented
+fun:ruserok_af=uninstrumented
+fun:ruserpass=uninstrumented
+fun:sbrk=uninstrumented
+fun:scalb=uninstrumented
+fun:scalbf=uninstrumented
+fun:scalbl=uninstrumented
+fun:scalbln=uninstrumented
+fun:scalblnf=uninstrumented
+fun:scalblnl=uninstrumented
+fun:scalbn=uninstrumented
+fun:scalbnf=uninstrumented
+fun:scalbnl=uninstrumented
+fun:scandir=uninstrumented
+fun:scandir64=uninstrumented
+fun:scandirat=uninstrumented
+fun:scandirat64=uninstrumented
+fun:scanf=uninstrumented
+fun:sched_get_priority_max=uninstrumented
+fun:sched_get_priority_min=uninstrumented
+fun:sched_getaffinity=uninstrumented
+fun:sched_getcpu=uninstrumented
+fun:sched_getparam=uninstrumented
+fun:sched_getscheduler=uninstrumented
+fun:sched_rr_get_interval=uninstrumented
+fun:sched_setaffinity=uninstrumented
+fun:sched_setparam=uninstrumented
+fun:sched_setscheduler=uninstrumented
+fun:sched_yield=uninstrumented
+fun:secure_getenv=uninstrumented
+fun:seed48=uninstrumented
+fun:seed48_r=uninstrumented
+fun:seekdir=uninstrumented
+fun:select=uninstrumented
+fun:sem_close=uninstrumented
+fun:sem_destroy=uninstrumented
+fun:sem_getvalue=uninstrumented
+fun:sem_init=uninstrumented
+fun:sem_open=uninstrumented
+fun:sem_post=uninstrumented
+fun:sem_timedwait=uninstrumented
+fun:sem_trywait=uninstrumented
+fun:sem_unlink=uninstrumented
+fun:sem_wait=uninstrumented
+fun:semctl=uninstrumented
+fun:semget=uninstrumented
+fun:semop=uninstrumented
+fun:semtimedop=uninstrumented
+fun:send=uninstrumented
+fun:sendfile=uninstrumented
+fun:sendfile64=uninstrumented
+fun:sendmmsg=uninstrumented
+fun:sendmsg=uninstrumented
+fun:sendto=uninstrumented
+fun:setaliasent=uninstrumented
+fun:setbuf=uninstrumented
+fun:setbuffer=uninstrumented
+fun:setcontext=uninstrumented
+fun:setdomainname=uninstrumented
+fun:setegid=uninstrumented
+fun:setenv=uninstrumented
+fun:seteuid=uninstrumented
+fun:setfsent=uninstrumented
+fun:setfsgid=uninstrumented
+fun:setfsuid=uninstrumented
+fun:setgid=uninstrumented
+fun:setgrent=uninstrumented
+fun:setgroups=uninstrumented
+fun:sethostent=uninstrumented
+fun:sethostid=uninstrumented
+fun:sethostname=uninstrumented
+fun:setipv4sourcefilter=uninstrumented
+fun:setitimer=uninstrumented
+fun:setjmp=uninstrumented
+fun:setkey=uninstrumented
+fun:setkey_r=uninstrumented
+fun:setlinebuf=uninstrumented
+fun:setlocale=uninstrumented
+fun:setlogin=uninstrumented
+fun:setlogmask=uninstrumented
+fun:setmntent=uninstrumented
+fun:setnetent=uninstrumented
+fun:setnetgrent=uninstrumented
+fun:setns=uninstrumented
+fun:setpgid=uninstrumented
+fun:setpgrp=uninstrumented
+fun:setpriority=uninstrumented
+fun:setprotoent=uninstrumented
+fun:setpwent=uninstrumented
+fun:setregid=uninstrumented
+fun:setresgid=uninstrumented
+fun:setresuid=uninstrumented
+fun:setreuid=uninstrumented
+fun:setrlimit=uninstrumented
+fun:setrlimit64=uninstrumented
+fun:setrpcent=uninstrumented
+fun:setservent=uninstrumented
+fun:setsgent=uninstrumented
+fun:setsid=uninstrumented
+fun:setsockopt=uninstrumented
+fun:setsourcefilter=uninstrumented
+fun:setspent=uninstrumented
+fun:setstate=uninstrumented
+fun:setstate_r=uninstrumented
+fun:settimeofday=uninstrumented
+fun:setttyent=uninstrumented
+fun:setuid=uninstrumented
+fun:setusershell=uninstrumented
+fun:setutent=uninstrumented
+fun:setutxent=uninstrumented
+fun:setvbuf=uninstrumented
+fun:setxattr=uninstrumented
+fun:sgetsgent=uninstrumented
+fun:sgetsgent_r=uninstrumented
+fun:sgetspent=uninstrumented
+fun:sgetspent_r=uninstrumented
+fun:shm_open=uninstrumented
+fun:shm_unlink=uninstrumented
+fun:shmat=uninstrumented
+fun:shmctl=uninstrumented
+fun:shmdt=uninstrumented
+fun:shmget=uninstrumented
+fun:shutdown=uninstrumented
+fun:sigaction=uninstrumented
+fun:sigaddset=uninstrumented
+fun:sigaltstack=uninstrumented
+fun:sigandset=uninstrumented
+fun:sigblock=uninstrumented
+fun:sigdelset=uninstrumented
+fun:sigemptyset=uninstrumented
+fun:sigfillset=uninstrumented
+fun:siggetmask=uninstrumented
+fun:sighold=uninstrumented
+fun:sigignore=uninstrumented
+fun:siginterrupt=uninstrumented
+fun:sigisemptyset=uninstrumented
+fun:sigismember=uninstrumented
+fun:siglongjmp=uninstrumented
+fun:signal=uninstrumented
+fun:signalfd=uninstrumented
+fun:significand=uninstrumented
+fun:significandf=uninstrumented
+fun:significandl=uninstrumented
+fun:sigorset=uninstrumented
+fun:sigpause=uninstrumented
+fun:sigpending=uninstrumented
+fun:sigprocmask=uninstrumented
+fun:sigqueue=uninstrumented
+fun:sigrelse=uninstrumented
+fun:sigreturn=uninstrumented
+fun:sigset=uninstrumented
+fun:sigsetmask=uninstrumented
+fun:sigstack=uninstrumented
+fun:sigsuspend=uninstrumented
+fun:sigtimedwait=uninstrumented
+fun:sigvec=uninstrumented
+fun:sigwait=uninstrumented
+fun:sigwaitinfo=uninstrumented
+fun:sin=uninstrumented
+fun:sincos=uninstrumented
+fun:sincosf=uninstrumented
+fun:sincosl=uninstrumented
+fun:sinf=uninstrumented
+fun:sinh=uninstrumented
+fun:sinhf=uninstrumented
+fun:sinhl=uninstrumented
+fun:sinl=uninstrumented
+fun:sleep=uninstrumented
+fun:snprintf=uninstrumented
+fun:sockatmark=uninstrumented
+fun:socket=uninstrumented
+fun:socketpair=uninstrumented
+fun:splice=uninstrumented
+fun:sprintf=uninstrumented
+fun:sprofil=uninstrumented
+fun:sqrt=uninstrumented
+fun:sqrtf=uninstrumented
+fun:sqrtl=uninstrumented
+fun:srand=uninstrumented
+fun:srand48=uninstrumented
+fun:srand48_r=uninstrumented
+fun:srandom=uninstrumented
+fun:srandom_r=uninstrumented
+fun:sscanf=uninstrumented
+fun:ssignal=uninstrumented
+fun:sstk=uninstrumented
+fun:stat=uninstrumented
+fun:stat64=uninstrumented
+fun:statfs=uninstrumented
+fun:statfs64=uninstrumented
+fun:statvfs=uninstrumented
+fun:statvfs64=uninstrumented
+fun:step=uninstrumented
+fun:stime=uninstrumented
+fun:stpcpy=uninstrumented
+fun:stpncpy=uninstrumented
+fun:strcasecmp=uninstrumented
+fun:strcasecmp_l=uninstrumented
+fun:strcasestr=uninstrumented
+fun:strcat=uninstrumented
+fun:strchr=uninstrumented
+fun:strchrnul=uninstrumented
+fun:strcmp=uninstrumented
+fun:strcoll=uninstrumented
+fun:strcoll_l=uninstrumented
+fun:strcpy=uninstrumented
+fun:strcspn=uninstrumented
+fun:strdup=uninstrumented
+fun:strerror=uninstrumented
+fun:strerror_l=uninstrumented
+fun:strerror_r=uninstrumented
+fun:strfmon=uninstrumented
+fun:strfmon_l=uninstrumented
+fun:strfry=uninstrumented
+fun:strftime=uninstrumented
+fun:strftime_l=uninstrumented
+fun:strlen=uninstrumented
+fun:strncasecmp=uninstrumented
+fun:strncasecmp_l=uninstrumented
+fun:strncat=uninstrumented
+fun:strncmp=uninstrumented
+fun:strncpy=uninstrumented
+fun:strndup=uninstrumented
+fun:strnlen=uninstrumented
+fun:strpbrk=uninstrumented
+fun:strptime=uninstrumented
+fun:strptime_l=uninstrumented
+fun:strrchr=uninstrumented
+fun:strsep=uninstrumented
+fun:strsignal=uninstrumented
+fun:strspn=uninstrumented
+fun:strstr=uninstrumented
+fun:strtod=uninstrumented
+fun:strtod_l=uninstrumented
+fun:strtof=uninstrumented
+fun:strtof_l=uninstrumented
+fun:strtoimax=uninstrumented
+fun:strtok=uninstrumented
+fun:strtok_r=uninstrumented
+fun:strtol=uninstrumented
+fun:strtol_l=uninstrumented
+fun:strtold=uninstrumented
+fun:strtold_l=uninstrumented
+fun:strtoll=uninstrumented
+fun:strtoll_l=uninstrumented
+fun:strtoq=uninstrumented
+fun:strtoul=uninstrumented
+fun:strtoul_l=uninstrumented
+fun:strtoull=uninstrumented
+fun:strtoull_l=uninstrumented
+fun:strtoumax=uninstrumented
+fun:strtouq=uninstrumented
+fun:strverscmp=uninstrumented
+fun:strxfrm=uninstrumented
+fun:strxfrm_l=uninstrumented
+fun:stty=uninstrumented
+fun:svc_exit=uninstrumented
+fun:svc_getreq=uninstrumented
+fun:svc_getreq_common=uninstrumented
+fun:svc_getreq_poll=uninstrumented
+fun:svc_getreqset=uninstrumented
+fun:svc_register=uninstrumented
+fun:svc_run=uninstrumented
+fun:svc_sendreply=uninstrumented
+fun:svc_unregister=uninstrumented
+fun:svcerr_auth=uninstrumented
+fun:svcerr_decode=uninstrumented
+fun:svcerr_noproc=uninstrumented
+fun:svcerr_noprog=uninstrumented
+fun:svcerr_progvers=uninstrumented
+fun:svcerr_systemerr=uninstrumented
+fun:svcerr_weakauth=uninstrumented
+fun:svcfd_create=uninstrumented
+fun:svcraw_create=uninstrumented
+fun:svctcp_create=uninstrumented
+fun:svcudp_bufcreate=uninstrumented
+fun:svcudp_create=uninstrumented
+fun:svcudp_enablecache=uninstrumented
+fun:svcunix_create=uninstrumented
+fun:svcunixfd_create=uninstrumented
+fun:swab=uninstrumented
+fun:swapcontext=uninstrumented
+fun:swapoff=uninstrumented
+fun:swapon=uninstrumented
+fun:swprintf=uninstrumented
+fun:swscanf=uninstrumented
+fun:symlink=uninstrumented
+fun:symlinkat=uninstrumented
+fun:sync=uninstrumented
+fun:sync_file_range=uninstrumented
+fun:syncfs=uninstrumented
+fun:syscall=uninstrumented
+fun:sysconf=uninstrumented
+fun:sysctl=uninstrumented
+fun:sysinfo=uninstrumented
+fun:syslog=uninstrumented
+fun:system=uninstrumented
+fun:sysv_signal=uninstrumented
+fun:tan=uninstrumented
+fun:tanf=uninstrumented
+fun:tanh=uninstrumented
+fun:tanhf=uninstrumented
+fun:tanhl=uninstrumented
+fun:tanl=uninstrumented
+fun:tcdrain=uninstrumented
+fun:tcflow=uninstrumented
+fun:tcflush=uninstrumented
+fun:tcgetattr=uninstrumented
+fun:tcgetpgrp=uninstrumented
+fun:tcgetsid=uninstrumented
+fun:tcsendbreak=uninstrumented
+fun:tcsetattr=uninstrumented
+fun:tcsetpgrp=uninstrumented
+fun:td_init=uninstrumented
+fun:td_log=uninstrumented
+fun:td_symbol_list=uninstrumented
+fun:td_ta_clear_event=uninstrumented
+fun:td_ta_delete=uninstrumented
+fun:td_ta_enable_stats=uninstrumented
+fun:td_ta_event_addr=uninstrumented
+fun:td_ta_event_getmsg=uninstrumented
+fun:td_ta_get_nthreads=uninstrumented
+fun:td_ta_get_ph=uninstrumented
+fun:td_ta_get_stats=uninstrumented
+fun:td_ta_map_id2thr=uninstrumented
+fun:td_ta_map_lwp2thr=uninstrumented
+fun:td_ta_new=uninstrumented
+fun:td_ta_reset_stats=uninstrumented
+fun:td_ta_set_event=uninstrumented
+fun:td_ta_setconcurrency=uninstrumented
+fun:td_ta_thr_iter=uninstrumented
+fun:td_ta_tsd_iter=uninstrumented
+fun:td_thr_clear_event=uninstrumented
+fun:td_thr_dbresume=uninstrumented
+fun:td_thr_dbsuspend=uninstrumented
+fun:td_thr_event_enable=uninstrumented
+fun:td_thr_event_getmsg=uninstrumented
+fun:td_thr_get_info=uninstrumented
+fun:td_thr_getfpregs=uninstrumented
+fun:td_thr_getgregs=uninstrumented
+fun:td_thr_getxregs=uninstrumented
+fun:td_thr_getxregsize=uninstrumented
+fun:td_thr_set_event=uninstrumented
+fun:td_thr_setfpregs=uninstrumented
+fun:td_thr_setgregs=uninstrumented
+fun:td_thr_setprio=uninstrumented
+fun:td_thr_setsigpending=uninstrumented
+fun:td_thr_setxregs=uninstrumented
+fun:td_thr_sigsetmask=uninstrumented
+fun:td_thr_tls_get_addr=uninstrumented
+fun:td_thr_tlsbase=uninstrumented
+fun:td_thr_tsd=uninstrumented
+fun:td_thr_validate=uninstrumented
+fun:tdelete=uninstrumented
+fun:tdestroy=uninstrumented
+fun:tee=uninstrumented
+fun:telldir=uninstrumented
+fun:tempnam=uninstrumented
+fun:textdomain=uninstrumented
+fun:tfind=uninstrumented
+fun:tgamma=uninstrumented
+fun:tgammaf=uninstrumented
+fun:tgammal=uninstrumented
+fun:time=uninstrumented
+fun:timegm=uninstrumented
+fun:timelocal=uninstrumented
+fun:timer_create=uninstrumented
+fun:timer_delete=uninstrumented
+fun:timer_getoverrun=uninstrumented
+fun:timer_gettime=uninstrumented
+fun:timer_settime=uninstrumented
+fun:timerfd_create=uninstrumented
+fun:timerfd_gettime=uninstrumented
+fun:timerfd_settime=uninstrumented
+fun:times=uninstrumented
+fun:timespec_get=uninstrumented
+fun:tmpfile=uninstrumented
+fun:tmpfile64=uninstrumented
+fun:tmpnam=uninstrumented
+fun:tmpnam_r=uninstrumented
+fun:toascii=uninstrumented
+fun:tolower=uninstrumented
+fun:tolower_l=uninstrumented
+fun:toupper=uninstrumented
+fun:toupper_l=uninstrumented
+fun:towctrans=uninstrumented
+fun:towctrans_l=uninstrumented
+fun:towlower=uninstrumented
+fun:towlower_l=uninstrumented
+fun:towupper=uninstrumented
+fun:towupper_l=uninstrumented
+fun:tr_break=uninstrumented
+fun:trunc=uninstrumented
+fun:truncate=uninstrumented
+fun:truncate64=uninstrumented
+fun:truncf=uninstrumented
+fun:truncl=uninstrumented
+fun:tsearch=uninstrumented
+fun:ttyname=uninstrumented
+fun:ttyname_r=uninstrumented
+fun:ttyslot=uninstrumented
+fun:twalk=uninstrumented
+fun:tzset=uninstrumented
+fun:ualarm=uninstrumented
+fun:ulckpwdf=uninstrumented
+fun:ulimit=uninstrumented
+fun:umask=uninstrumented
+fun:umount=uninstrumented
+fun:umount2=uninstrumented
+fun:uname=uninstrumented
+fun:ungetc=uninstrumented
+fun:ungetwc=uninstrumented
+fun:unlink=uninstrumented
+fun:unlinkat=uninstrumented
+fun:unlockpt=uninstrumented
+fun:unsetenv=uninstrumented
+fun:unshare=uninstrumented
+fun:updwtmp=uninstrumented
+fun:updwtmpx=uninstrumented
+fun:uselib=uninstrumented
+fun:uselocale=uninstrumented
+fun:user2netname=uninstrumented
+fun:usleep=uninstrumented
+fun:ustat=uninstrumented
+fun:utime=uninstrumented
+fun:utimensat=uninstrumented
+fun:utimes=uninstrumented
+fun:utmpname=uninstrumented
+fun:utmpxname=uninstrumented
+fun:valloc=uninstrumented
+fun:vasprintf=uninstrumented
+fun:vdprintf=uninstrumented
+fun:verr=uninstrumented
+fun:verrx=uninstrumented
+fun:versionsort=uninstrumented
+fun:versionsort64=uninstrumented
+fun:vfork=uninstrumented
+fun:vfprintf=uninstrumented
+fun:vfscanf=uninstrumented
+fun:vfwprintf=uninstrumented
+fun:vfwscanf=uninstrumented
+fun:vhangup=uninstrumented
+fun:vlimit=uninstrumented
+fun:vmsplice=uninstrumented
+fun:vprintf=uninstrumented
+fun:vscanf=uninstrumented
+fun:vsnprintf=uninstrumented
+fun:vsprintf=uninstrumented
+fun:vsscanf=uninstrumented
+fun:vswprintf=uninstrumented
+fun:vswscanf=uninstrumented
+fun:vsyslog=uninstrumented
+fun:vtimes=uninstrumented
+fun:vwarn=uninstrumented
+fun:vwarnx=uninstrumented
+fun:vwprintf=uninstrumented
+fun:vwscanf=uninstrumented
+fun:wait=uninstrumented
+fun:wait3=uninstrumented
+fun:wait4=uninstrumented
+fun:waitid=uninstrumented
+fun:waitpid=uninstrumented
+fun:warn=uninstrumented
+fun:warnx=uninstrumented
+fun:wcpcpy=uninstrumented
+fun:wcpncpy=uninstrumented
+fun:wcrtomb=uninstrumented
+fun:wcscasecmp=uninstrumented
+fun:wcscasecmp_l=uninstrumented
+fun:wcscat=uninstrumented
+fun:wcschr=uninstrumented
+fun:wcschrnul=uninstrumented
+fun:wcscmp=uninstrumented
+fun:wcscoll=uninstrumented
+fun:wcscoll_l=uninstrumented
+fun:wcscpy=uninstrumented
+fun:wcscspn=uninstrumented
+fun:wcsdup=uninstrumented
+fun:wcsftime=uninstrumented
+fun:wcsftime_l=uninstrumented
+fun:wcslen=uninstrumented
+fun:wcsncasecmp=uninstrumented
+fun:wcsncasecmp_l=uninstrumented
+fun:wcsncat=uninstrumented
+fun:wcsncmp=uninstrumented
+fun:wcsncpy=uninstrumented
+fun:wcsnlen=uninstrumented
+fun:wcsnrtombs=uninstrumented
+fun:wcspbrk=uninstrumented
+fun:wcsrchr=uninstrumented
+fun:wcsrtombs=uninstrumented
+fun:wcsspn=uninstrumented
+fun:wcsstr=uninstrumented
+fun:wcstod=uninstrumented
+fun:wcstod_l=uninstrumented
+fun:wcstof=uninstrumented
+fun:wcstof_l=uninstrumented
+fun:wcstoimax=uninstrumented
+fun:wcstok=uninstrumented
+fun:wcstol=uninstrumented
+fun:wcstol_l=uninstrumented
+fun:wcstold=uninstrumented
+fun:wcstold_l=uninstrumented
+fun:wcstoll=uninstrumented
+fun:wcstoll_l=uninstrumented
+fun:wcstombs=uninstrumented
+fun:wcstoq=uninstrumented
+fun:wcstoul=uninstrumented
+fun:wcstoul_l=uninstrumented
+fun:wcstoull=uninstrumented
+fun:wcstoull_l=uninstrumented
+fun:wcstoumax=uninstrumented
+fun:wcstouq=uninstrumented
+fun:wcswcs=uninstrumented
+fun:wcswidth=uninstrumented
+fun:wcsxfrm=uninstrumented
+fun:wcsxfrm_l=uninstrumented
+fun:wctob=uninstrumented
+fun:wctomb=uninstrumented
+fun:wctrans=uninstrumented
+fun:wctrans_l=uninstrumented
+fun:wctype=uninstrumented
+fun:wctype_l=uninstrumented
+fun:wcwidth=uninstrumented
+fun:wmemchr=uninstrumented
+fun:wmemcmp=uninstrumented
+fun:wmemcpy=uninstrumented
+fun:wmemmove=uninstrumented
+fun:wmempcpy=uninstrumented
+fun:wmemset=uninstrumented
+fun:wordexp=uninstrumented
+fun:wordfree=uninstrumented
+fun:wprintf=uninstrumented
+fun:write=uninstrumented
+fun:writeColdStartFile=uninstrumented
+fun:writev=uninstrumented
+fun:wscanf=uninstrumented
+fun:xdecrypt=uninstrumented
+fun:xdr_accepted_reply=uninstrumented
+fun:xdr_array=uninstrumented
+fun:xdr_authdes_cred=uninstrumented
+fun:xdr_authdes_verf=uninstrumented
+fun:xdr_authunix_parms=uninstrumented
+fun:xdr_bool=uninstrumented
+fun:xdr_bytes=uninstrumented
+fun:xdr_callhdr=uninstrumented
+fun:xdr_callmsg=uninstrumented
+fun:xdr_cback_data=uninstrumented
+fun:xdr_char=uninstrumented
+fun:xdr_cryptkeyarg=uninstrumented
+fun:xdr_cryptkeyarg2=uninstrumented
+fun:xdr_cryptkeyres=uninstrumented
+fun:xdr_des_block=uninstrumented
+fun:xdr_domainname=uninstrumented
+fun:xdr_double=uninstrumented
+fun:xdr_enum=uninstrumented
+fun:xdr_float=uninstrumented
+fun:xdr_free=uninstrumented
+fun:xdr_getcredres=uninstrumented
+fun:xdr_hyper=uninstrumented
+fun:xdr_int=uninstrumented
+fun:xdr_int16_t=uninstrumented
+fun:xdr_int32_t=uninstrumented
+fun:xdr_int64_t=uninstrumented
+fun:xdr_int8_t=uninstrumented
+fun:xdr_key_netstarg=uninstrumented
+fun:xdr_key_netstres=uninstrumented
+fun:xdr_keybuf=uninstrumented
+fun:xdr_keydat=uninstrumented
+fun:xdr_keystatus=uninstrumented
+fun:xdr_long=uninstrumented
+fun:xdr_longlong_t=uninstrumented
+fun:xdr_mapname=uninstrumented
+fun:xdr_netnamestr=uninstrumented
+fun:xdr_netobj=uninstrumented
+fun:xdr_obj_p=uninstrumented
+fun:xdr_opaque=uninstrumented
+fun:xdr_opaque_auth=uninstrumented
+fun:xdr_peername=uninstrumented
+fun:xdr_pmap=uninstrumented
+fun:xdr_pmaplist=uninstrumented
+fun:xdr_pointer=uninstrumented
+fun:xdr_quad_t=uninstrumented
+fun:xdr_reference=uninstrumented
+fun:xdr_rejected_reply=uninstrumented
+fun:xdr_replymsg=uninstrumented
+fun:xdr_rmtcall_args=uninstrumented
+fun:xdr_rmtcallres=uninstrumented
+fun:xdr_short=uninstrumented
+fun:xdr_sizeof=uninstrumented
+fun:xdr_string=uninstrumented
+fun:xdr_u_char=uninstrumented
+fun:xdr_u_hyper=uninstrumented
+fun:xdr_u_int=uninstrumented
+fun:xdr_u_long=uninstrumented
+fun:xdr_u_longlong_t=uninstrumented
+fun:xdr_u_quad_t=uninstrumented
+fun:xdr_u_short=uninstrumented
+fun:xdr_uint16_t=uninstrumented
+fun:xdr_uint32_t=uninstrumented
+fun:xdr_uint64_t=uninstrumented
+fun:xdr_uint8_t=uninstrumented
+fun:xdr_union=uninstrumented
+fun:xdr_unixcred=uninstrumented
+fun:xdr_valdat=uninstrumented
+fun:xdr_vector=uninstrumented
+fun:xdr_void=uninstrumented
+fun:xdr_wrapstring=uninstrumented
+fun:xdr_yp_buf=uninstrumented
+fun:xdr_ypall=uninstrumented
+fun:xdr_ypbind_binding=uninstrumented
+fun:xdr_ypbind_resp=uninstrumented
+fun:xdr_ypbind_resptype=uninstrumented
+fun:xdr_ypbind_setdom=uninstrumented
+fun:xdr_ypdelete_args=uninstrumented
+fun:xdr_ypmap_parms=uninstrumented
+fun:xdr_ypmaplist=uninstrumented
+fun:xdr_yppush_status=uninstrumented
+fun:xdr_yppushresp_xfr=uninstrumented
+fun:xdr_ypreq_key=uninstrumented
+fun:xdr_ypreq_nokey=uninstrumented
+fun:xdr_ypreq_xfr=uninstrumented
+fun:xdr_ypresp_all=uninstrumented
+fun:xdr_ypresp_key_val=uninstrumented
+fun:xdr_ypresp_maplist=uninstrumented
+fun:xdr_ypresp_master=uninstrumented
+fun:xdr_ypresp_order=uninstrumented
+fun:xdr_ypresp_val=uninstrumented
+fun:xdr_ypresp_xfr=uninstrumented
+fun:xdr_ypstat=uninstrumented
+fun:xdr_ypupdate_args=uninstrumented
+fun:xdr_ypxfrstat=uninstrumented
+fun:xdrmem_create=uninstrumented
+fun:xdrrec_create=uninstrumented
+fun:xdrrec_endofrecord=uninstrumented
+fun:xdrrec_eof=uninstrumented
+fun:xdrrec_skiprecord=uninstrumented
+fun:xdrstdio_create=uninstrumented
+fun:xencrypt=uninstrumented
+fun:xprt_register=uninstrumented
+fun:xprt_unregister=uninstrumented
+fun:y0=uninstrumented
+fun:y0f=uninstrumented
+fun:y0l=uninstrumented
+fun:y1=uninstrumented
+fun:y1f=uninstrumented
+fun:y1l=uninstrumented
+fun:yn=uninstrumented
+fun:ynf=uninstrumented
+fun:ynl=uninstrumented
+fun:yp_all=uninstrumented
+fun:yp_bind=uninstrumented
+fun:yp_first=uninstrumented
+fun:yp_get_default_domain=uninstrumented
+fun:yp_maplist=uninstrumented
+fun:yp_master=uninstrumented
+fun:yp_match=uninstrumented
+fun:yp_next=uninstrumented
+fun:yp_order=uninstrumented
+fun:yp_unbind=uninstrumented
+fun:yp_update=uninstrumented
+fun:ypbinderr_string=uninstrumented
+fun:yperr_string=uninstrumented
+fun:ypprot_err=uninstrumented
diff --git a/compiler-rt/lib/dfsan/scripts/build-libc-list.py b/compiler-rt/lib/dfsan/scripts/build-libc-list.py
new file mode 100755
index 0000000..eddb6c0
--- /dev/null
+++ b/compiler-rt/lib/dfsan/scripts/build-libc-list.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+#===- lib/dfsan/scripts/build-libc-list.py ---------------------------------===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+# The purpose of this script is to identify every function symbol in a set of
+# libraries (in this case, libc and libgcc) so that they can be marked as
+# uninstrumented, thus allowing the instrumentation pass to treat calls to those
+# functions correctly.
+
+import os
+import subprocess
+import sys
+from optparse import OptionParser
+
+def defined_function_list(object):
+  functions = []
+  readelf_proc = subprocess.Popen(['readelf', '-s', '-W', object],
+                                  stdout=subprocess.PIPE)
+  readelf = readelf_proc.communicate()[0].split('\n')
+  if readelf_proc.returncode != 0:
+    raise subprocess.CalledProcessError(readelf_proc.returncode, 'readelf')
+  for line in readelf:
+    if (line[31:35] == 'FUNC' or line[31:36] == 'IFUNC') and \
+       line[39:44] != 'LOCAL' and \
+       line[55:58] != 'UND':
+      function_name = line[59:].split('@')[0]
+      functions.append(function_name)
+  return functions
+
+p = OptionParser()
+
+p.add_option('--libc-dso-path', metavar='PATH',
+             help='path to libc DSO directory',
+             default='/lib/x86_64-linux-gnu')
+p.add_option('--libc-archive-path', metavar='PATH',
+             help='path to libc archive directory',
+             default='/usr/lib/x86_64-linux-gnu')
+
+p.add_option('--libgcc-dso-path', metavar='PATH',
+             help='path to libgcc DSO directory',
+             default='/lib/x86_64-linux-gnu')
+p.add_option('--libgcc-archive-path', metavar='PATH',
+             help='path to libgcc archive directory',
+             default='/usr/lib/gcc/x86_64-linux-gnu/4.6')
+
+p.add_option('--with-libstdcxx', action='store_true',
+             dest='with_libstdcxx',
+             help='include libstdc++ in the list (inadvisable)')
+p.add_option('--libstdcxx-dso-path', metavar='PATH',
+             help='path to libstdc++ DSO directory',
+             default='/usr/lib/x86_64-linux-gnu')
+
+(options, args) = p.parse_args()
+
+libs = [os.path.join(options.libc_dso_path, name) for name in
+        ['ld-linux-x86-64.so.2',
+         'libanl.so.1',
+         'libBrokenLocale.so.1',
+         'libcidn.so.1',
+         'libcrypt.so.1',
+         'libc.so.6',
+         'libdl.so.2',
+         'libm.so.6',
+         'libnsl.so.1',
+         'libpthread.so.0',
+         'libresolv.so.2',
+         'librt.so.1',
+         'libthread_db.so.1',
+         'libutil.so.1']]
+libs += [os.path.join(options.libc_archive_path, name) for name in
+         ['libc_nonshared.a',
+          'libpthread_nonshared.a']]
+
+libs.append(os.path.join(options.libgcc_dso_path, 'libgcc_s.so.1'))
+libs.append(os.path.join(options.libgcc_archive_path, 'libgcc.a'))
+
+if options.with_libstdcxx:
+  libs.append(os.path.join(options.libstdcxx_dso_path, 'libstdc++.so.6'))
+
+functions = []
+for l in libs:
+  if os.path.exists(l):
+    functions += defined_function_list(l)
+  else:
+    print >> sys.stderr, 'warning: library %s not found' % l
+
+functions = list(set(functions))
+functions.sort()
+
+for f in functions:
+  print 'fun:%s=uninstrumented' % f
diff --git a/compiler-rt/lib/dfsan/scripts/check_custom_wrappers.sh b/compiler-rt/lib/dfsan/scripts/check_custom_wrappers.sh
new file mode 100755
index 0000000..99bf50c
--- /dev/null
+++ b/compiler-rt/lib/dfsan/scripts/check_custom_wrappers.sh
@@ -0,0 +1,52 @@
+#!/bin/sh
+
+DFSAN_DIR=$(dirname "$0")/../
+DFSAN_CUSTOM_TESTS=${DFSAN_DIR}/../../test/dfsan/custom.cc
+DFSAN_CUSTOM_WRAPPERS=${DFSAN_DIR}/dfsan_custom.cc
+DFSAN_ABI_LIST=${DFSAN_DIR}/done_abilist.txt
+
+DIFFOUT=$(mktemp -q /tmp/tmp.XXXXXXXXXX)
+ERRORLOG=$(mktemp -q /tmp/tmp.XXXXXXXXXX)
+DIFF_A=$(mktemp -q /tmp/tmp.XXXXXXXXXX)
+DIFF_B=$(mktemp -q /tmp/tmp.XXXXXXXXXX)
+
+on_exit() {
+  rm -f ${DIFFOUT} 2> /dev/null
+  rm -f ${ERRORLOG} 2> /dev/null
+  rm -f ${DIFF_A} 2> /dev/null
+  rm -f ${DIFF_B} 2> /dev/null
+}
+
+# Ignore __sanitizer_cov_trace* because they are implemented elsewhere.
+trap on_exit EXIT
+grep -E "^fun:.*=custom" ${DFSAN_ABI_LIST} \
+  | grep -v "dfsan_get_label\|__sanitizer_cov_trace" \
+  | sed "s/^fun:\(.*\)=custom.*/\1/" | sort > $DIFF_A
+grep -E "__dfsw.*\(" ${DFSAN_CUSTOM_WRAPPERS} \
+  | sed "s/.*__dfsw_\(.*\)(.*/\1/" | sort > $DIFF_B
+diff -u $DIFF_A $DIFF_B > ${DIFFOUT}
+if [ $? -ne 0 ]
+then
+  echo -n "The following differences between the ABI list and ">> ${ERRORLOG}
+  echo "the implemented custom wrappers have been found:" >> ${ERRORLOG}
+  cat ${DIFFOUT} >> ${ERRORLOG}
+fi
+
+grep -E __dfsw_ ${DFSAN_CUSTOM_WRAPPERS} \
+  | sed "s/.*__dfsw_\([^(]*\).*/\1/" | sort > $DIFF_A
+grep -E "^[[:space:]]*test_.*\(\);" ${DFSAN_CUSTOM_TESTS} \
+  | sed "s/.*test_\(.*\)();/\1/" | sort > $DIFF_B
+diff -u $DIFF_A $DIFF_B > ${DIFFOUT}
+if [ $? -ne 0 ]
+then
+  echo -n "The following differences between the implemented " >> ${ERRORLOG}
+  echo "custom wrappers and the tests have been found:" >> ${ERRORLOG}
+  cat ${DIFFOUT} >> ${ERRORLOG}
+fi
+
+if [ -s ${ERRORLOG} ]
+then
+  cat ${ERRORLOG}
+  exit 1
+fi
+
diff --git a/compiler-rt/lib/interception/.clang-format b/compiler-rt/lib/interception/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/interception/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/interception/Android.bp b/compiler-rt/lib/interception/Android.bp
new file mode 100644
index 0000000..479ea67
--- /dev/null
+++ b/compiler-rt/lib/interception/Android.bp
@@ -0,0 +1,44 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+cc_library_static {
+    name: "libinterception",
+    host_supported: true,
+    clang: true,
+    sdk_version: "19",
+
+    include_dirs: ["external/compiler-rt/lib"],
+    cppflags: [
+        "-fvisibility=hidden",
+        "-fno-exceptions",
+        "-std=c++11",
+        "-Wall",
+        "-Werror",
+        "-Wno-unused-parameter",
+    ],
+    srcs: [
+        "interception_linux.cc",
+        "interception_mac.cc",
+        "interception_type_test.cc",
+        "interception_win.cc",
+    ],
+    stl: "none",
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+}
diff --git a/compiler-rt/lib/interception/CMakeLists.txt b/compiler-rt/lib/interception/CMakeLists.txt
new file mode 100644
index 0000000..16b41c9
--- /dev/null
+++ b/compiler-rt/lib/interception/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Build for the runtime interception helper library.
+
+set(INTERCEPTION_SOURCES
+  interception_linux.cc
+  interception_mac.cc
+  interception_win.cc
+  interception_type_test.cc
+  )
+
+include_directories(..)
+
+set(INTERCEPTION_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(INTERCEPTION_CFLAGS)
+
+add_compiler_rt_object_libraries(RTInterception
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
+    SOURCES ${INTERCEPTION_SOURCES}
+    CFLAGS ${INTERCEPTION_CFLAGS})
diff --git a/compiler-rt/lib/interception/Makefile.mk b/compiler-rt/lib/interception/Makefile.mk
new file mode 100644
index 0000000..88aa6cb
--- /dev/null
+++ b/compiler-rt/lib/interception/Makefile.mk
@@ -0,0 +1,23 @@
+#===- lib/interception/Makefile.mk -------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := interception
+SubDirs :=
+
+Sources := $(foreach file,$(wildcard $(Dir)/*.cc),$(notdir $(file)))
+ObjNames := $(Sources:%.cc=%.o)
+
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
+Dependencies += $(wildcard $(Dir)/../sanitizer_common/*.h)
+
+# Define a convenience variable for all the interception functions.
+InterceptionFunctions := $(Sources:%.cc=%)
diff --git a/compiler-rt/lib/interception/interception.h b/compiler-rt/lib/interception/interception.h
new file mode 100644
index 0000000..9e9aca2
--- /dev/null
+++ b/compiler-rt/lib/interception/interception.h
@@ -0,0 +1,261 @@
+//===-- interception.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Machinery for providing replacements/wrappers for system functions.
+//===----------------------------------------------------------------------===//
+
+#ifndef INTERCEPTION_H
+#define INTERCEPTION_H
+
+#if !defined(__linux__) && !defined(__FreeBSD__) && \
+  !defined(__APPLE__) && !defined(_WIN32)
+# error "Interception doesn't work on this operating system."
+#endif
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+// These typedefs should be used only in the interceptor definitions to replace
+// the standard system types (e.g. SSIZE_T instead of ssize_t)
+typedef __sanitizer::uptr    SIZE_T;
+typedef __sanitizer::sptr    SSIZE_T;
+typedef __sanitizer::sptr    PTRDIFF_T;
+typedef __sanitizer::s64     INTMAX_T;
+typedef __sanitizer::OFF_T   OFF_T;
+typedef __sanitizer::OFF64_T OFF64_T;
+
+// How to add an interceptor:
+// Suppose you need to wrap/replace system function (generally, from libc):
+//      int foo(const char *bar, double baz);
+// You'll need to:
+//      1) define INTERCEPTOR(int, foo, const char *bar, double baz) { ... } in
+//         your source file. See the notes below for cases when
+//         INTERCEPTOR_WITH_SUFFIX(...) should be used instead.
+//      2) Call "INTERCEPT_FUNCTION(foo)" prior to the first call of "foo".
+//         INTERCEPT_FUNCTION(foo) evaluates to "true" iff the function was
+//         intercepted successfully.
+// You can access original function by calling REAL(foo)(bar, baz).
+// By default, REAL(foo) will be visible only inside your interceptor, and if
+// you want to use it in other parts of RTL, you'll need to:
+//      3a) add DECLARE_REAL(int, foo, const char*, double) to a
+//          header file.
+// However, if the call "INTERCEPT_FUNCTION(foo)" and definition for
+// INTERCEPTOR(..., foo, ...) are in different files, you'll instead need to:
+//      3b) add DECLARE_REAL_AND_INTERCEPTOR(int, foo, const char*, double)
+//          to a header file.
+
+// Notes: 1. Things may not work properly if macro INTERCEPTOR(...) {...} or
+//           DECLARE_REAL(...) are located inside namespaces.
+//        2. On Mac you can also use: "OVERRIDE_FUNCTION(foo, zoo)" to
+//           effectively redirect calls from "foo" to "zoo". In this case
+//           you aren't required to implement
+//           INTERCEPTOR(int, foo, const char *bar, double baz) {...}
+//           but instead you'll have to add
+//           DECLARE_REAL(int, foo, const char *bar, double baz) in your
+//           source file (to define a pointer to overriden function).
+//        3. Some Mac functions have symbol variants discriminated by
+//           additional suffixes, e.g. _$UNIX2003 (see
+//           https://developer.apple.com/library/mac/#releasenotes/Darwin/SymbolVariantsRelNotes/index.html
+//           for more details). To intercept such functions you need to use the
+//           INTERCEPTOR_WITH_SUFFIX(...) macro.
+
+// How it works:
+// To replace system functions on Linux we just need to declare functions
+// with same names in our library and then obtain the real function pointers
+// using dlsym().
+// There is one complication. A user may also intercept some of the functions
+// we intercept. To resolve this we declare our interceptors with __interceptor_
+// prefix, and then make actual interceptors weak aliases to __interceptor_
+// functions.
+//
+// This is not so on Mac OS, where the two-level namespace makes
+// our replacement functions invisible to other libraries. This may be overcomed
+// using the DYLD_FORCE_FLAT_NAMESPACE, but some errors loading the shared
+// libraries in Chromium were noticed when doing so.
+// Instead we create a dylib containing a __DATA,__interpose section that
+// associates library functions with their wrappers. When this dylib is
+// preloaded before an executable using DYLD_INSERT_LIBRARIES, it routes all
+// the calls to interposed functions done through stubs to the wrapper
+// functions.
+// As it's decided at compile time which functions are to be intercepted on Mac,
+// INTERCEPT_FUNCTION() is effectively a no-op on this system.
+
+#if defined(__APPLE__)
+#include <sys/cdefs.h>  // For __DARWIN_ALIAS_C().
+
+// Just a pair of pointers.
+struct interpose_substitution {
+  const uptr replacement;
+  const uptr original;
+};
+
+// For a function foo() create a global pair of pointers { wrap_foo, foo } in
+// the __DATA,__interpose section.
+// As a result all the calls to foo() will be routed to wrap_foo() at runtime.
+#define INTERPOSER(func_name) __attribute__((used)) \
+const interpose_substitution substitution_##func_name[] \
+    __attribute__((section("__DATA, __interpose"))) = { \
+    { reinterpret_cast<const uptr>(WRAP(func_name)), \
+      reinterpret_cast<const uptr>(func_name) } \
+}
+
+// For a function foo() and a wrapper function bar() create a global pair
+// of pointers { bar, foo } in the __DATA,__interpose section.
+// As a result all the calls to foo() will be routed to bar() at runtime.
+#define INTERPOSER_2(func_name, wrapper_name) __attribute__((used)) \
+const interpose_substitution substitution_##func_name[] \
+    __attribute__((section("__DATA, __interpose"))) = { \
+    { reinterpret_cast<const uptr>(wrapper_name), \
+      reinterpret_cast<const uptr>(func_name) } \
+}
+
+# define WRAP(x) wrap_##x
+# define WRAPPER_NAME(x) "wrap_"#x
+# define INTERCEPTOR_ATTRIBUTE
+# define DECLARE_WRAPPER(ret_type, func, ...)
+
+#elif defined(_WIN32)
+# define WRAP(x) __asan_wrap_##x
+# define WRAPPER_NAME(x) "__asan_wrap_"#x
+# define INTERCEPTOR_ATTRIBUTE __declspec(dllexport)
+# define DECLARE_WRAPPER(ret_type, func, ...) \
+    extern "C" ret_type func(__VA_ARGS__);
+# define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \
+    extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__);
+#elif defined(__FreeBSD__)
+# define WRAP(x) __interceptor_ ## x
+# define WRAPPER_NAME(x) "__interceptor_" #x
+# define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
+// FreeBSD's dynamic linker (incompliantly) gives non-weak symbols higher
+// priority than weak ones so weak aliases won't work for indirect calls
+// in position-independent (-fPIC / -fPIE) mode.
+# define DECLARE_WRAPPER(ret_type, func, ...) \
+     extern "C" ret_type func(__VA_ARGS__) \
+     __attribute__((alias("__interceptor_" #func), visibility("default")));
+#else
+# define WRAP(x) __interceptor_ ## x
+# define WRAPPER_NAME(x) "__interceptor_" #x
+# define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
+# define DECLARE_WRAPPER(ret_type, func, ...) \
+    extern "C" ret_type func(__VA_ARGS__) \
+    __attribute__((weak, alias("__interceptor_" #func), visibility("default")));
+#endif
+
+#if !defined(__APPLE__)
+# define PTR_TO_REAL(x) real_##x
+# define REAL(x) __interception::PTR_TO_REAL(x)
+# define FUNC_TYPE(x) x##_f
+
+# define DECLARE_REAL(ret_type, func, ...) \
+    typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \
+    namespace __interception { \
+      extern FUNC_TYPE(func) PTR_TO_REAL(func); \
+    }
+#else  // __APPLE__
+# define REAL(x) x
+# define DECLARE_REAL(ret_type, func, ...) \
+    extern "C" ret_type func(__VA_ARGS__);
+#endif  // __APPLE__
+
+#define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...) \
+  DECLARE_REAL(ret_type, func, __VA_ARGS__) \
+  extern "C" ret_type WRAP(func)(__VA_ARGS__);
+
+// Generally, you don't need to use DEFINE_REAL by itself, as INTERCEPTOR
+// macros does its job. In exceptional cases you may need to call REAL(foo)
+// without defining INTERCEPTOR(..., foo, ...). For example, if you override
+// foo with an interceptor for other function.
+#if !defined(__APPLE__)
+# define DEFINE_REAL(ret_type, func, ...) \
+    typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \
+    namespace __interception { \
+      FUNC_TYPE(func) PTR_TO_REAL(func); \
+    }
+#else
+# define DEFINE_REAL(ret_type, func, ...)
+#endif
+
+#if !defined(__APPLE__)
+#define INTERCEPTOR(ret_type, func, ...) \
+  DEFINE_REAL(ret_type, func, __VA_ARGS__) \
+  DECLARE_WRAPPER(ret_type, func, __VA_ARGS__) \
+  extern "C" \
+  INTERCEPTOR_ATTRIBUTE \
+  ret_type WRAP(func)(__VA_ARGS__)
+
+// We don't need INTERCEPTOR_WITH_SUFFIX on non-Darwin for now.
+#define INTERCEPTOR_WITH_SUFFIX(ret_type, func, ...) \
+  INTERCEPTOR(ret_type, func, __VA_ARGS__)
+
+#else  // __APPLE__
+
+#define INTERCEPTOR_ZZZ(suffix, ret_type, func, ...) \
+  extern "C" ret_type func(__VA_ARGS__) suffix; \
+  extern "C" ret_type WRAP(func)(__VA_ARGS__); \
+  INTERPOSER(func); \
+  extern "C" INTERCEPTOR_ATTRIBUTE ret_type WRAP(func)(__VA_ARGS__)
+
+#define INTERCEPTOR(ret_type, func, ...) \
+  INTERCEPTOR_ZZZ(/*no symbol variants*/, ret_type, func, __VA_ARGS__)
+
+#define INTERCEPTOR_WITH_SUFFIX(ret_type, func, ...) \
+  INTERCEPTOR_ZZZ(__DARWIN_ALIAS_C(func), ret_type, func, __VA_ARGS__)
+
+// Override |overridee| with |overrider|.
+#define OVERRIDE_FUNCTION(overridee, overrider) \
+  INTERPOSER_2(overridee, WRAP(overrider))
+#endif
+
+#if defined(_WIN32)
+# define INTERCEPTOR_WINAPI(ret_type, func, ...) \
+    typedef ret_type (__stdcall *FUNC_TYPE(func))(__VA_ARGS__); \
+    namespace __interception { \
+      FUNC_TYPE(func) PTR_TO_REAL(func); \
+    } \
+    extern "C" \
+    INTERCEPTOR_ATTRIBUTE \
+    ret_type __stdcall WRAP(func)(__VA_ARGS__)
+#endif
+
+// ISO C++ forbids casting between pointer-to-function and pointer-to-object,
+// so we use casting via an integral type __interception::uptr,
+// assuming that system is POSIX-compliant. Using other hacks seem
+// challenging, as we don't even pass function type to
+// INTERCEPT_FUNCTION macro, only its name.
+namespace __interception {
+#if defined(_WIN64)
+typedef unsigned long long uptr;  // NOLINT
+#else
+typedef unsigned long uptr;  // NOLINT
+#endif  // _WIN64
+}  // namespace __interception
+
+#define INCLUDED_FROM_INTERCEPTION_LIB
+
+#if defined(__linux__) || defined(__FreeBSD__)
+# include "interception_linux.h"
+# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
+# define INTERCEPT_FUNCTION_VER(func, symver) \
+    INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver)
+#elif defined(__APPLE__)
+# include "interception_mac.h"
+# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_MAC(func)
+# define INTERCEPT_FUNCTION_VER(func, symver) \
+    INTERCEPT_FUNCTION_VER_MAC(func, symver)
+#else  // defined(_WIN32)
+# include "interception_win.h"
+# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_WIN(func)
+# define INTERCEPT_FUNCTION_VER(func, symver) \
+    INTERCEPT_FUNCTION_VER_WIN(func, symver)
+#endif
+
+#undef INCLUDED_FROM_INTERCEPTION_LIB
+
+#endif  // INTERCEPTION_H
diff --git a/compiler-rt/lib/interception/interception_linux.cc b/compiler-rt/lib/interception/interception_linux.cc
new file mode 100644
index 0000000..6e908ac
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_linux.cc
@@ -0,0 +1,36 @@
+//===-- interception_linux.cc -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Linux-specific interception methods.
+//===----------------------------------------------------------------------===//
+
+#if defined(__linux__) || defined(__FreeBSD__)
+#include "interception.h"
+
+#include <dlfcn.h>   // for dlsym() and dlvsym()
+
+namespace __interception {
+bool GetRealFunctionAddress(const char *func_name, uptr *func_addr,
+    uptr real, uptr wrapper) {
+  *func_addr = (uptr)dlsym(RTLD_NEXT, func_name);
+  return real == wrapper;
+}
+
+#if !defined(__ANDROID__)  // android does not have dlvsym
+void *GetFuncAddrVer(const char *func_name, const char *ver) {
+  return dlvsym(RTLD_NEXT, func_name, ver);
+}
+#endif  // !defined(__ANDROID__)
+
+}  // namespace __interception
+
+
+#endif  // __linux__ || __FreeBSD__
diff --git a/compiler-rt/lib/interception/interception_linux.h b/compiler-rt/lib/interception/interception_linux.h
new file mode 100644
index 0000000..27a66c8
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_linux.h
@@ -0,0 +1,47 @@
+//===-- interception_linux.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Linux-specific interception methods.
+//===----------------------------------------------------------------------===//
+
+#if defined(__linux__) || defined(__FreeBSD__)
+
+#if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
+# error "interception_linux.h should be included from interception library only"
+#endif
+
+#ifndef INTERCEPTION_LINUX_H
+#define INTERCEPTION_LINUX_H
+
+namespace __interception {
+// returns true if a function with the given name was found.
+bool GetRealFunctionAddress(const char *func_name, uptr *func_addr,
+    uptr real, uptr wrapper);
+void *GetFuncAddrVer(const char *func_name, const char *ver);
+}  // namespace __interception
+
+#define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)                          \
+  ::__interception::GetRealFunctionAddress(                                \
+      #func, (::__interception::uptr *)&__interception::PTR_TO_REAL(func), \
+      (::__interception::uptr) & (func),                                   \
+      (::__interception::uptr) & WRAP(func))
+
+#if !defined(__ANDROID__)  // android does not have dlvsym
+#define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
+  (::__interception::real_##func = (func##_f)(                \
+       unsigned long)::__interception::GetFuncAddrVer(#func, symver))
+#else
+#define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
+  INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
+#endif  // !defined(__ANDROID__)
+
+#endif  // INTERCEPTION_LINUX_H
+#endif  // __linux__ || __FreeBSD__
diff --git a/compiler-rt/lib/interception/interception_mac.cc b/compiler-rt/lib/interception/interception_mac.cc
new file mode 100644
index 0000000..b035cf9
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_mac.cc
@@ -0,0 +1,20 @@
+//===-- interception_mac.cc -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Mac-specific interception methods.
+//===----------------------------------------------------------------------===//
+
+#ifdef __APPLE__
+
+#include "interception.h"
+
+
+#endif  // __APPLE__
diff --git a/compiler-rt/lib/interception/interception_mac.h b/compiler-rt/lib/interception/interception_mac.h
new file mode 100644
index 0000000..e5a35c6
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_mac.h
@@ -0,0 +1,28 @@
+//===-- interception_mac.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Mac-specific interception methods.
+//===----------------------------------------------------------------------===//
+
+#ifdef __APPLE__
+
+#if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
+# error "interception_mac.h should be included from interception.h only"
+#endif
+
+#ifndef INTERCEPTION_MAC_H
+#define INTERCEPTION_MAC_H
+
+#define INTERCEPT_FUNCTION_MAC(func)
+#define INTERCEPT_FUNCTION_VER_MAC(func, symver)
+
+#endif  // INTERCEPTION_MAC_H
+#endif  // __APPLE__
diff --git a/compiler-rt/lib/interception/interception_type_test.cc b/compiler-rt/lib/interception/interception_type_test.cc
new file mode 100644
index 0000000..98ce2e6
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_type_test.cc
@@ -0,0 +1,39 @@
+//===-- interception_type_test.cc -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Compile-time tests of the internal type definitions.
+//===----------------------------------------------------------------------===//
+
+#if defined(__linux__) || defined(__APPLE__)
+
+#include "interception.h"
+#include <sys/types.h>
+#include <stddef.h>
+#include <stdint.h>
+
+COMPILER_CHECK(sizeof(::SIZE_T) == sizeof(size_t));
+COMPILER_CHECK(sizeof(::SSIZE_T) == sizeof(ssize_t));
+COMPILER_CHECK(sizeof(::PTRDIFF_T) == sizeof(ptrdiff_t));
+COMPILER_CHECK(sizeof(::INTMAX_T) == sizeof(intmax_t));
+
+#ifndef __APPLE__
+COMPILER_CHECK(sizeof(::OFF64_T) == sizeof(off64_t));
+#endif
+
+// The following are the cases when pread (and friends) is used instead of
+// pread64. In those cases we need OFF_T to match off_t. We don't care about the
+// rest (they depend on _FILE_OFFSET_BITS setting when building an application).
+# if defined(__ANDROID__) || !defined _FILE_OFFSET_BITS || \
+  _FILE_OFFSET_BITS != 64
+COMPILER_CHECK(sizeof(::OFF_T) == sizeof(off_t));
+# endif
+
+#endif
diff --git a/compiler-rt/lib/interception/interception_win.cc b/compiler-rt/lib/interception/interception_win.cc
new file mode 100644
index 0000000..4c04c83
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_win.cc
@@ -0,0 +1,273 @@
+//===-- interception_linux.cc -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Windows-specific interception methods.
+//===----------------------------------------------------------------------===//
+
+#ifdef _WIN32
+
+#include "interception.h"
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+namespace __interception {
+
+// FIXME: internal_str* and internal_mem* functions should be moved from the
+// ASan sources into interception/.
+
+static void _memset(void *p, int value, size_t sz) {
+  for (size_t i = 0; i < sz; ++i)
+    ((char*)p)[i] = (char)value;
+}
+
+static void _memcpy(void *dst, void *src, size_t sz) {
+  char *dst_c = (char*)dst,
+       *src_c = (char*)src;
+  for (size_t i = 0; i < sz; ++i)
+    dst_c[i] = src_c[i];
+}
+
+static void WriteJumpInstruction(char *jmp_from, char *to) {
+  // jmp XXYYZZWW = E9 WW ZZ YY XX, where XXYYZZWW is an offset fromt jmp_from
+  // to the next instruction to the destination.
+  ptrdiff_t offset = to - jmp_from - 5;
+  *jmp_from = '\xE9';
+  *(ptrdiff_t*)(jmp_from + 1) = offset;
+}
+
+static char *GetMemoryForTrampoline(size_t size) {
+  // Trampolines are allocated from a common pool.
+  const int POOL_SIZE = 1024;
+  static char *pool = NULL;
+  static size_t pool_used = 0;
+  if (!pool) {
+    pool = (char *)VirtualAlloc(NULL, POOL_SIZE, MEM_RESERVE | MEM_COMMIT,
+                                PAGE_EXECUTE_READWRITE);
+    // FIXME: Might want to apply PAGE_EXECUTE_READ access after all the
+    // interceptors are in place.
+    if (!pool)
+      return NULL;
+    _memset(pool, 0xCC /* int 3 */, POOL_SIZE);
+  }
+
+  if (pool_used + size > POOL_SIZE)
+    return NULL;
+
+  char *ret = pool + pool_used;
+  pool_used += size;
+  return ret;
+}
+
+// Returns 0 on error.
+static size_t RoundUpToInstrBoundary(size_t size, char *code) {
+  size_t cursor = 0;
+  while (cursor < size) {
+    switch (code[cursor]) {
+      case '\x51':  // push ecx
+      case '\x52':  // push edx
+      case '\x53':  // push ebx
+      case '\x54':  // push esp
+      case '\x55':  // push ebp
+      case '\x56':  // push esi
+      case '\x57':  // push edi
+      case '\x5D':  // pop ebp
+        cursor++;
+        continue;
+      case '\x6A':  // 6A XX = push XX
+        cursor += 2;
+        continue;
+      case '\xE9':  // E9 XX YY ZZ WW = jmp WWZZYYXX
+      case '\xB8':  // B8 XX YY ZZ WW = mov eax, WWZZYYXX
+        cursor += 5;
+        continue;
+    }
+    switch (*(unsigned short*)(code + cursor)) {  // NOLINT
+      case 0xFF8B:  // 8B FF = mov edi, edi
+      case 0xEC8B:  // 8B EC = mov ebp, esp
+      case 0xC033:  // 33 C0 = xor eax, eax
+        cursor += 2;
+        continue;
+      case 0x458B:  // 8B 45 XX = mov eax, dword ptr [ebp+XXh]
+      case 0x5D8B:  // 8B 5D XX = mov ebx, dword ptr [ebp+XXh]
+      case 0xEC83:  // 83 EC XX = sub esp, XX
+      case 0x75FF:  // FF 75 XX = push dword ptr [ebp+XXh]
+        cursor += 3;
+        continue;
+      case 0xC1F7:  // F7 C1 XX YY ZZ WW = test ecx, WWZZYYXX
+      case 0x25FF:  // FF 25 XX YY ZZ WW = jmp dword ptr ds:[WWZZYYXX]
+        cursor += 6;
+        continue;
+      case 0x3D83:  // 83 3D XX YY ZZ WW TT = cmp TT, WWZZYYXX
+        cursor += 7;
+        continue;
+    }
+    switch (0x00FFFFFF & *(unsigned int*)(code + cursor)) {
+      case 0x24448A:  // 8A 44 24 XX = mov eal, dword ptr [esp+XXh]
+      case 0x24448B:  // 8B 44 24 XX = mov eax, dword ptr [esp+XXh]
+      case 0x244C8B:  // 8B 4C 24 XX = mov ecx, dword ptr [esp+XXh]
+      case 0x24548B:  // 8B 54 24 XX = mov edx, dword ptr [esp+XXh]
+      case 0x24748B:  // 8B 74 24 XX = mov esi, dword ptr [esp+XXh]
+      case 0x247C8B:  // 8B 7C 24 XX = mov edi, dword ptr [esp+XXh]
+        cursor += 4;
+        continue;
+    }
+
+    // Unknown instruction!
+    // FIXME: Unknown instruction failures might happen when we add a new
+    // interceptor or a new compiler version. In either case, they should result
+    // in visible and readable error messages. However, merely calling abort()
+    // leads to an infinite recursion in CheckFailed.
+    // Do we have a good way to abort with an error message here?
+    __debugbreak();
+    return 0;
+  }
+
+  return cursor;
+}
+
+bool OverrideFunction(uptr old_func, uptr new_func, uptr *orig_old_func) {
+#ifdef _WIN64
+#error OverrideFunction is not yet supported on x64
+#endif
+  // Function overriding works basically like this:
+  // We write "jmp <new_func>" (5 bytes) at the beginning of the 'old_func'
+  // to override it.
+  // We might want to be able to execute the original 'old_func' from the
+  // wrapper, in this case we need to keep the leading 5+ bytes ('head')
+  // of the original code somewhere with a "jmp <old_func+head>".
+  // We call these 'head'+5 bytes of instructions a "trampoline".
+  char *old_bytes = (char *)old_func;
+
+  // We'll need at least 5 bytes for a 'jmp'.
+  size_t head = 5;
+  if (orig_old_func) {
+    // Find out the number of bytes of the instructions we need to copy
+    // to the trampoline and store it in 'head'.
+    head = RoundUpToInstrBoundary(head, old_bytes);
+    if (!head)
+      return false;
+
+    // Put the needed instructions into the trampoline bytes.
+    char *trampoline = GetMemoryForTrampoline(head + 5);
+    if (!trampoline)
+      return false;
+    _memcpy(trampoline, old_bytes, head);
+    WriteJumpInstruction(trampoline + head, old_bytes + head);
+    *orig_old_func = (uptr)trampoline;
+  }
+
+  // Now put the "jmp <new_func>" instruction at the original code location.
+  // We should preserve the EXECUTE flag as some of our own code might be
+  // located in the same page (sic!).  FIXME: might consider putting the
+  // __interception code into a separate section or something?
+  DWORD old_prot, unused_prot;
+  if (!VirtualProtect((void *)old_bytes, head, PAGE_EXECUTE_READWRITE,
+                      &old_prot))
+    return false;
+
+  WriteJumpInstruction(old_bytes, (char *)new_func);
+  _memset(old_bytes + 5, 0xCC /* int 3 */, head - 5);
+
+  // Restore the original permissions.
+  if (!VirtualProtect((void *)old_bytes, head, old_prot, &unused_prot))
+    return false;  // not clear if this failure bothers us.
+
+  return true;
+}
+
+static void **InterestingDLLsAvailable() {
+  const char *InterestingDLLs[] = {
+    "kernel32.dll",
+    "msvcr110.dll", // VS2012
+    "msvcr120.dll", // VS2013
+    // NTDLL should go last as it exports some functions that we should override
+    // in the CRT [presumably only used internally].
+    "ntdll.dll", NULL
+  };
+  static void *result[ARRAY_SIZE(InterestingDLLs)] = { 0 };
+  if (!result[0]) {
+    for (size_t i = 0, j = 0; InterestingDLLs[i]; ++i) {
+      if (HMODULE h = GetModuleHandleA(InterestingDLLs[i]))
+        result[j++] = (void *)h;
+    }
+  }
+  return &result[0];
+}
+
+namespace {
+// Utility for reading loaded PE images.
+template <typename T> class RVAPtr {
+ public:
+  RVAPtr(void *module, uptr rva)
+      : ptr_(reinterpret_cast<T *>(reinterpret_cast<char *>(module) + rva)) {}
+  operator T *() { return ptr_; }
+  T *operator->() { return ptr_; }
+  T *operator++() { return ++ptr_; }
+
+ private:
+  T *ptr_;
+};
+} // namespace
+
+// Internal implementation of GetProcAddress. At least since Windows 8,
+// GetProcAddress appears to initialize DLLs before returning function pointers
+// into them. This is problematic for the sanitizers, because they typically
+// want to intercept malloc *before* MSVCRT initializes. Our internal
+// implementation walks the export list manually without doing initialization.
+uptr InternalGetProcAddress(void *module, const char *func_name) {
+  // Check that the module header is full and present.
+  RVAPtr<IMAGE_DOS_HEADER> dos_stub(module, 0);
+  RVAPtr<IMAGE_NT_HEADERS> headers(module, dos_stub->e_lfanew);
+  if (!module || dos_stub->e_magic != IMAGE_DOS_SIGNATURE || // "MZ"
+      headers->Signature != IMAGE_NT_SIGNATURE ||           // "PE\0\0"
+      headers->FileHeader.SizeOfOptionalHeader <
+          sizeof(IMAGE_OPTIONAL_HEADER)) {
+    return 0;
+  }
+
+  IMAGE_DATA_DIRECTORY *export_directory =
+      &headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
+  RVAPtr<IMAGE_EXPORT_DIRECTORY> exports(module,
+                                         export_directory->VirtualAddress);
+  RVAPtr<DWORD> functions(module, exports->AddressOfFunctions);
+  RVAPtr<DWORD> names(module, exports->AddressOfNames);
+  RVAPtr<WORD> ordinals(module, exports->AddressOfNameOrdinals);
+
+  for (DWORD i = 0; i < exports->NumberOfNames; i++) {
+    RVAPtr<char> name(module, names[i]);
+    if (!strcmp(func_name, name)) {
+      DWORD index = ordinals[i];
+      RVAPtr<char> func(module, functions[index]);
+      return (uptr)(char *)func;
+    }
+  }
+
+  return 0;
+}
+
+static bool GetFunctionAddressInDLLs(const char *func_name, uptr *func_addr) {
+  *func_addr = 0;
+  void **DLLs = InterestingDLLsAvailable();
+  for (size_t i = 0; *func_addr == 0 && DLLs[i]; ++i)
+    *func_addr = InternalGetProcAddress(DLLs[i], func_name);
+  return (*func_addr != 0);
+}
+
+bool OverrideFunction(const char *name, uptr new_func, uptr *orig_old_func) {
+  uptr orig_func;
+  if (!GetFunctionAddressInDLLs(name, &orig_func))
+    return false;
+  return OverrideFunction(orig_func, new_func, orig_old_func);
+}
+
+}  // namespace __interception
+
+#endif  // _WIN32
diff --git a/compiler-rt/lib/interception/interception_win.h b/compiler-rt/lib/interception/interception_win.h
new file mode 100644
index 0000000..96c4a0c
--- /dev/null
+++ b/compiler-rt/lib/interception/interception_win.h
@@ -0,0 +1,54 @@
+//===-- interception_linux.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Windows-specific interception methods.
+//===----------------------------------------------------------------------===//
+
+#ifdef _WIN32
+
+#if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
+# error "interception_win.h should be included from interception library only"
+#endif
+
+#ifndef INTERCEPTION_WIN_H
+#define INTERCEPTION_WIN_H
+
+namespace __interception {
+// All the functions in the OverrideFunction() family return true on success,
+// false on failure (including "couldn't find the function").
+
+// Overrides a function by its address.
+bool OverrideFunction(uptr old_func, uptr new_func, uptr *orig_old_func = 0);
+
+// Overrides a function in a system DLL or DLL CRT by its exported name.
+bool OverrideFunction(const char *name, uptr new_func, uptr *orig_old_func = 0);
+
+// Windows-only replacement for GetProcAddress. Useful for some sanitizers.
+uptr InternalGetProcAddress(void *module, const char *func_name);
+
+}  // namespace __interception
+
+#if defined(INTERCEPTION_DYNAMIC_CRT)
+#define INTERCEPT_FUNCTION_WIN(func)                                           \
+  ::__interception::OverrideFunction(#func,                                    \
+                                     (::__interception::uptr)WRAP(func),       \
+                                     (::__interception::uptr *)&REAL(func))
+#else
+#define INTERCEPT_FUNCTION_WIN(func)                                           \
+  ::__interception::OverrideFunction((::__interception::uptr)func,             \
+                                     (::__interception::uptr)WRAP(func),       \
+                                     (::__interception::uptr *)&REAL(func))
+#endif
+
+#define INTERCEPT_FUNCTION_VER_WIN(func, symver) INTERCEPT_FUNCTION_WIN(func)
+
+#endif  // INTERCEPTION_WIN_H
+#endif  // _WIN32
diff --git a/compiler-rt/lib/lsan/.clang-format b/compiler-rt/lib/lsan/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/lsan/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/lsan/Android.bp b/compiler-rt/lib/lsan/Android.bp
new file mode 100644
index 0000000..97f55c3
--- /dev/null
+++ b/compiler-rt/lib/lsan/Android.bp
@@ -0,0 +1,49 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+cc_library_static {
+    name: "liblsan",
+    host_supported: true,
+    defaults: ["asan_arch_defaults"],
+    include_dirs: [
+        "external/compiler-rt/lib",
+        "external/compiler-rt/include",
+    ],
+    cflags: [
+        "-fvisibility=hidden",
+        "-fno-exceptions",
+        "-Wno-covered-switch-default",
+        "-Wno-non-virtual-dtor",
+        "-Wno-sign-compare",
+        "-Wno-unused-parameter",
+        "-std=c++11",
+        "-fno-rtti",
+        "-fno-builtin",
+    ],
+    srcs: [
+        "lsan_common.cc",
+        "lsan_common_linux.cc",
+    ],
+
+    clang: true,
+    sdk_version: "19",
+    stl: "none",
+
+    sanitize: {
+        never: true,
+    },
+}
diff --git a/compiler-rt/lib/lsan/CMakeLists.txt b/compiler-rt/lib/lsan/CMakeLists.txt
new file mode 100644
index 0000000..20e4093
--- /dev/null
+++ b/compiler-rt/lib/lsan/CMakeLists.txt
@@ -0,0 +1,42 @@
+include_directories(..)
+
+set(LSAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(LSAN_CFLAGS)
+
+set(LSAN_COMMON_SOURCES
+  lsan_common.cc
+  lsan_common_linux.cc)
+
+set(LSAN_SOURCES
+  lsan.cc
+  lsan_allocator.cc
+  lsan_interceptors.cc
+  lsan_preinit.cc
+  lsan_thread.cc)
+
+set(LSAN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+add_custom_target(lsan)
+
+add_compiler_rt_object_libraries(RTLSanCommon
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${LSAN_COMMON_SUPPORTED_ARCH}
+    SOURCES ${LSAN_COMMON_SOURCES}
+    CFLAGS ${LSAN_CFLAGS})
+
+if(COMPILER_RT_HAS_LSAN)
+  foreach(arch ${LSAN_SUPPORTED_ARCH})
+    add_compiler_rt_runtime(clang_rt.lsan
+      STATIC
+      ARCHS ${arch}
+      SOURCES ${LSAN_SOURCES}
+              $<TARGET_OBJECTS:RTInterception.${arch}>
+              $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+              $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+              $<TARGET_OBJECTS:RTLSanCommon.${arch}>
+      CFLAGS ${LSAN_CFLAGS}
+      PARENT_TARGET lsan)
+  endforeach()
+endif()
+
+add_dependencies(compiler-rt lsan)
diff --git a/compiler-rt/lib/lsan/Makefile.mk b/compiler-rt/lib/lsan/Makefile.mk
new file mode 100644
index 0000000..5e70634
--- /dev/null
+++ b/compiler-rt/lib/lsan/Makefile.mk
@@ -0,0 +1,25 @@
+#===- lib/lsan/Makefile.mk ---------------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := lsan
+SubDirs := 
+
+Sources := $(foreach file,$(wildcard $(Dir)/*.cc),$(notdir $(file)))
+ObjNames := $(Sources:%.cc=%.o)
+
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
+Dependencies += $(wildcard $(Dir)/../interception/*.h)
+Dependencies += $(wildcard $(Dir)/../sanitizer_common/*.h)
+
+# lsan functions used in another sanitizers.
+LsanCommonSources := $(foreach file,$(wildcard $(Dir)/lsan_common*.cc),$(notdir $(file)))
+LsanCommonFunctions := $(LsanCommonSources:%.cc=%)
diff --git a/compiler-rt/lib/lsan/lsan.cc b/compiler-rt/lib/lsan/lsan.cc
new file mode 100644
index 0000000..f3e6ad7
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan.cc
@@ -0,0 +1,98 @@
+//=-- lsan.cc -------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Standalone LSan RTL.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lsan.h"
+
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "lsan_allocator.h"
+#include "lsan_common.h"
+#include "lsan_thread.h"
+
+bool lsan_inited;
+bool lsan_init_is_running;
+
+namespace __lsan {
+
+///// Interface to the common LSan module. /////
+bool WordIsPoisoned(uptr addr) {
+  return false;
+}
+
+}  // namespace __lsan
+
+using namespace __lsan;  // NOLINT
+
+static void InitializeFlags() {
+  // Set all the default values.
+  SetCommonFlagsDefaults();
+  {
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.external_symbolizer_path = GetEnv("LSAN_SYMBOLIZER_PATH");
+    cf.malloc_context_size = 30;
+    cf.detect_leaks = true;
+    cf.exitcode = 23;
+    OverrideCommonFlags(cf);
+  }
+
+  Flags *f = flags();
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterLsanFlags(&parser, f);
+  RegisterCommonFlags(&parser);
+
+  parser.ParseString(GetEnv("LSAN_OPTIONS"));
+
+  SetVerbosity(common_flags()->verbosity);
+
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) parser.PrintFlagDescriptions();
+}
+
+extern "C" void __lsan_init() {
+  CHECK(!lsan_init_is_running);
+  if (lsan_inited)
+    return;
+  lsan_init_is_running = true;
+  SanitizerToolName = "LeakSanitizer";
+  CacheBinaryName();
+  InitializeFlags();
+  InitCommonLsan();
+  InitializeAllocator();
+  InitTlsSize();
+  InitializeInterceptors();
+  InitializeThreadRegistry();
+  u32 tid = ThreadCreate(0, 0, true);
+  CHECK_EQ(tid, 0);
+  ThreadStart(tid, GetTid());
+  SetCurrentThread(tid);
+
+  if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)
+    Atexit(DoLeakCheck);
+
+  InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
+
+  lsan_inited = true;
+  lsan_init_is_running = false;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_print_stack_trace() {
+  GET_STACK_TRACE_FATAL;
+  stack.Print();
+}
diff --git a/compiler-rt/lib/lsan/lsan.h b/compiler-rt/lib/lsan/lsan.h
new file mode 100644
index 0000000..53783cd
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan.h
@@ -0,0 +1,47 @@
+//=-- lsan.h --------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Private header for standalone LSan RTL.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+
+#define GET_STACK_TRACE(max_size, fast)                                        \
+  BufferedStackTrace stack;                                                    \
+  {                                                                            \
+    uptr stack_top = 0, stack_bottom = 0;                                      \
+    ThreadContext *t;                                                          \
+    if (fast && (t = CurrentThreadContext())) {                                \
+      stack_top = t->stack_end();                                              \
+      stack_bottom = t->stack_begin();                                         \
+    }                                                                          \
+    stack.Unwind(max_size, StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),    \
+                 /* context */ 0, stack_top, stack_bottom, fast);              \
+  }
+
+#define GET_STACK_TRACE_FATAL \
+  GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
+
+#define GET_STACK_TRACE_MALLOC                                      \
+  GET_STACK_TRACE(__sanitizer::common_flags()->malloc_context_size, \
+                  common_flags()->fast_unwind_on_malloc)
+
+namespace __lsan {
+
+void InitializeInterceptors();
+
+}  // namespace __lsan
+
+extern bool lsan_inited;
+extern bool lsan_init_is_running;
+
+extern "C" void __lsan_init();
diff --git a/compiler-rt/lib/lsan/lsan_allocator.cc b/compiler-rt/lib/lsan/lsan_allocator.cc
new file mode 100644
index 0000000..0a36781
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_allocator.cc
@@ -0,0 +1,250 @@
+//=-- lsan_allocator.cc ---------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// See lsan_allocator.h for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lsan_allocator.h"
+
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_allocator_interface.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "lsan_common.h"
+
+extern "C" void *memset(void *ptr, int value, uptr num);
+
+namespace __lsan {
+
+struct ChunkMetadata {
+  u8 allocated : 8;  // Must be first.
+  ChunkTag tag : 2;
+  uptr requested_size : 54;
+  u32 stack_trace_id;
+};
+
+#if defined(__mips64) || defined(__aarch64__)
+static const uptr kMaxAllowedMallocSize = 4UL << 30;
+static const uptr kRegionSizeLog = 20;
+static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+typedef CompactSizeClassMap SizeClassMap;
+typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE,
+    sizeof(ChunkMetadata), SizeClassMap, kRegionSizeLog, ByteMap>
+    PrimaryAllocator;
+#else
+static const uptr kMaxAllowedMallocSize = 8UL << 30;
+static const uptr kAllocatorSpace = 0x600000000000ULL;
+static const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
+typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize,
+        sizeof(ChunkMetadata), DefaultSizeClassMap> PrimaryAllocator;
+#endif
+typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef LargeMmapAllocator<> SecondaryAllocator;
+typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
+          SecondaryAllocator> Allocator;
+
+static Allocator allocator;
+static THREADLOCAL AllocatorCache cache;
+
+void InitializeAllocator() {
+  allocator.InitLinkerInitialized(common_flags()->allocator_may_return_null);
+}
+
+void AllocatorThreadFinish() {
+  allocator.SwallowCache(&cache);
+}
+
+static ChunkMetadata *Metadata(const void *p) {
+  return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
+}
+
+static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
+  if (!p) return;
+  ChunkMetadata *m = Metadata(p);
+  CHECK(m);
+  m->tag = DisabledInThisThread() ? kIgnored : kDirectlyLeaked;
+  m->stack_trace_id = StackDepotPut(stack);
+  m->requested_size = size;
+  atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 1, memory_order_relaxed);
+}
+
+static void RegisterDeallocation(void *p) {
+  if (!p) return;
+  ChunkMetadata *m = Metadata(p);
+  CHECK(m);
+  atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 0, memory_order_relaxed);
+}
+
+void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
+               bool cleared) {
+  if (size == 0)
+    size = 1;
+  if (size > kMaxAllowedMallocSize) {
+    Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", size);
+    return nullptr;
+  }
+  void *p = allocator.Allocate(&cache, size, alignment, false);
+  // Do not rely on the allocator to clear the memory (it's slow).
+  if (cleared && allocator.FromPrimary(p))
+    memset(p, 0, size);
+  RegisterAllocation(stack, p, size);
+  if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size);
+  return p;
+}
+
+void Deallocate(void *p) {
+  if (&__sanitizer_free_hook) __sanitizer_free_hook(p);
+  RegisterDeallocation(p);
+  allocator.Deallocate(&cache, p);
+}
+
+void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
+                 uptr alignment) {
+  RegisterDeallocation(p);
+  if (new_size > kMaxAllowedMallocSize) {
+    Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", new_size);
+    allocator.Deallocate(&cache, p);
+    return nullptr;
+  }
+  p = allocator.Reallocate(&cache, p, new_size, alignment);
+  RegisterAllocation(stack, p, new_size);
+  return p;
+}
+
+void GetAllocatorCacheRange(uptr *begin, uptr *end) {
+  *begin = (uptr)&cache;
+  *end = *begin + sizeof(cache);
+}
+
+uptr GetMallocUsableSize(const void *p) {
+  ChunkMetadata *m = Metadata(p);
+  if (!m) return 0;
+  return m->requested_size;
+}
+
+///// Interface to the common LSan module. /////
+
+void LockAllocator() {
+  allocator.ForceLock();
+}
+
+void UnlockAllocator() {
+  allocator.ForceUnlock();
+}
+
+void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
+  *begin = (uptr)&allocator;
+  *end = *begin + sizeof(allocator);
+}
+
+uptr PointsIntoChunk(void* p) {
+  uptr addr = reinterpret_cast<uptr>(p);
+  uptr chunk = reinterpret_cast<uptr>(allocator.GetBlockBeginFastLocked(p));
+  if (!chunk) return 0;
+  // LargeMmapAllocator considers pointers to the meta-region of a chunk to be
+  // valid, but we don't want that.
+  if (addr < chunk) return 0;
+  ChunkMetadata *m = Metadata(reinterpret_cast<void *>(chunk));
+  CHECK(m);
+  if (!m->allocated)
+    return 0;
+  if (addr < chunk + m->requested_size)
+    return chunk;
+  if (IsSpecialCaseOfOperatorNew0(chunk, m->requested_size, addr))
+    return chunk;
+  return 0;
+}
+
+uptr GetUserBegin(uptr chunk) {
+  return chunk;
+}
+
+LsanMetadata::LsanMetadata(uptr chunk) {
+  metadata_ = Metadata(reinterpret_cast<void *>(chunk));
+  CHECK(metadata_);
+}
+
+bool LsanMetadata::allocated() const {
+  return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated;
+}
+
+ChunkTag LsanMetadata::tag() const {
+  return reinterpret_cast<ChunkMetadata *>(metadata_)->tag;
+}
+
+void LsanMetadata::set_tag(ChunkTag value) {
+  reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value;
+}
+
+uptr LsanMetadata::requested_size() const {
+  return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size;
+}
+
+u32 LsanMetadata::stack_trace_id() const {
+  return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
+}
+
+void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+  allocator.ForEachChunk(callback, arg);
+}
+
+IgnoreObjectResult IgnoreObjectLocked(const void *p) {
+  void *chunk = allocator.GetBlockBegin(p);
+  if (!chunk || p < chunk) return kIgnoreObjectInvalid;
+  ChunkMetadata *m = Metadata(chunk);
+  CHECK(m);
+  if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) {
+    if (m->tag == kIgnored)
+      return kIgnoreObjectAlreadyIgnored;
+    m->tag = kIgnored;
+    return kIgnoreObjectSuccess;
+  } else {
+    return kIgnoreObjectInvalid;
+  }
+}
+} // namespace __lsan
+
+using namespace __lsan;
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_current_allocated_bytes() {
+  uptr stats[AllocatorStatCount];
+  allocator.GetStats(stats);
+  return stats[AllocatorStatAllocated];
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_heap_size() {
+  uptr stats[AllocatorStatCount];
+  allocator.GetStats(stats);
+  return stats[AllocatorStatMapped];
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_free_bytes() { return 0; }
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_unmapped_bytes() { return 0; }
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_allocated_size(const void *p) {
+  return GetMallocUsableSize(p);
+}
+} // extern "C"
diff --git a/compiler-rt/lib/lsan/lsan_allocator.h b/compiler-rt/lib/lsan/lsan_allocator.h
new file mode 100644
index 0000000..f564601
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_allocator.h
@@ -0,0 +1,39 @@
+//=-- lsan_allocator.h ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Allocator for standalone LSan.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LSAN_ALLOCATOR_H
+#define LSAN_ALLOCATOR_H
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+namespace __lsan {
+
+void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
+               bool cleared);
+void Deallocate(void *p);
+void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
+                 uptr alignment);
+uptr GetMallocUsableSize(const void *p);
+
+template<typename Callable>
+void ForEachChunk(const Callable &callback);
+
+void GetAllocatorCacheRange(uptr *begin, uptr *end);
+void AllocatorThreadFinish();
+void InitializeAllocator();
+
+}  // namespace __lsan
+
+#endif  // LSAN_ALLOCATOR_H
diff --git a/compiler-rt/lib/lsan/lsan_common.cc b/compiler-rt/lib/lsan/lsan_common.cc
new file mode 100644
index 0000000..1cffac4
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_common.cc
@@ -0,0 +1,723 @@
+//=-- lsan_common.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Implementation of common leak checking functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lsan_common.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "sanitizer_common/sanitizer_report_decorator.h"
+
+#if CAN_SANITIZE_LEAKS
+namespace __lsan {
+
+// This mutex is used to prevent races between DoLeakCheck and IgnoreObject, and
+// also to protect the global list of root regions.
+BlockingMutex global_mutex(LINKER_INITIALIZED);
+
+THREADLOCAL int disable_counter;
+bool DisabledInThisThread() { return disable_counter > 0; }
+
+Flags lsan_flags;
+
+void Flags::SetDefaults() {
+#define LSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "lsan_flags.inc"
+#undef LSAN_FLAG
+}
+
+void RegisterLsanFlags(FlagParser *parser, Flags *f) {
+#define LSAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "lsan_flags.inc"
+#undef LSAN_FLAG
+}
+
+#define LOG_POINTERS(...)                           \
+  do {                                              \
+    if (flags()->log_pointers) Report(__VA_ARGS__); \
+  } while (0);
+
+#define LOG_THREADS(...)                           \
+  do {                                             \
+    if (flags()->log_threads) Report(__VA_ARGS__); \
+  } while (0);
+
+ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
+static SuppressionContext *suppression_ctx = nullptr;
+static const char kSuppressionLeak[] = "leak";
+static const char *kSuppressionTypes[] = { kSuppressionLeak };
+
+void InitializeSuppressions() {
+  CHECK_EQ(nullptr, suppression_ctx);
+  suppression_ctx = new (suppression_placeholder) // NOLINT
+      SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
+  suppression_ctx->ParseFromFile(flags()->suppressions);
+  if (&__lsan_default_suppressions)
+    suppression_ctx->Parse(__lsan_default_suppressions());
+}
+
+static SuppressionContext *GetSuppressionContext() {
+  CHECK(suppression_ctx);
+  return suppression_ctx;
+}
+
+struct RootRegion {
+  const void *begin;
+  uptr size;
+};
+
+InternalMmapVector<RootRegion> *root_regions;
+
+void InitializeRootRegions() {
+  CHECK(!root_regions);
+  ALIGNED(64) static char placeholder[sizeof(InternalMmapVector<RootRegion>)];
+  root_regions = new(placeholder) InternalMmapVector<RootRegion>(1);
+}
+
+void InitCommonLsan() {
+  InitializeRootRegions();
+  if (common_flags()->detect_leaks) {
+    // Initialization which can fail or print warnings should only be done if
+    // LSan is actually enabled.
+    InitializeSuppressions();
+    InitializePlatformSpecificModules();
+  }
+}
+
+class Decorator: public __sanitizer::SanitizerCommonDecorator {
+ public:
+  Decorator() : SanitizerCommonDecorator() { }
+  const char *Error() { return Red(); }
+  const char *Leak() { return Blue(); }
+  const char *End() { return Default(); }
+};
+
+static inline bool CanBeAHeapPointer(uptr p) {
+  // Since our heap is located in mmap-ed memory, we can assume a sensible lower
+  // bound on heap addresses.
+  const uptr kMinAddress = 4 * 4096;
+  if (p < kMinAddress) return false;
+#if defined(__x86_64__)
+  // Accept only canonical form user-space addresses.
+  return ((p >> 47) == 0);
+#elif defined(__mips64)
+  return ((p >> 40) == 0);
+#elif defined(__aarch64__)
+  unsigned runtimeVMA =
+    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
+  return ((p >> runtimeVMA) == 0);
+#else
+  return true;
+#endif
+}
+
+// Scans the memory range, looking for byte patterns that point into allocator
+// chunks. Marks those chunks with |tag| and adds them to |frontier|.
+// There are two usage modes for this function: finding reachable chunks
+// (|tag| = kReachable) and finding indirectly leaked chunks
+// (|tag| = kIndirectlyLeaked). In the second case, there's no flood fill,
+// so |frontier| = 0.
+void ScanRangeForPointers(uptr begin, uptr end,
+                          Frontier *frontier,
+                          const char *region_type, ChunkTag tag) {
+  CHECK(tag == kReachable || tag == kIndirectlyLeaked);
+  const uptr alignment = flags()->pointer_alignment();
+  LOG_POINTERS("Scanning %s range %p-%p.\n", region_type, begin, end);
+  uptr pp = begin;
+  if (pp % alignment)
+    pp = pp + alignment - pp % alignment;
+  for (; pp + sizeof(void *) <= end; pp += alignment) {  // NOLINT
+    void *p = *reinterpret_cast<void **>(pp);
+    if (!CanBeAHeapPointer(reinterpret_cast<uptr>(p))) continue;
+    uptr chunk = PointsIntoChunk(p);
+    if (!chunk) continue;
+    // Pointers to self don't count. This matters when tag == kIndirectlyLeaked.
+    if (chunk == begin) continue;
+    LsanMetadata m(chunk);
+    if (m.tag() == kReachable || m.tag() == kIgnored) continue;
+
+    // Do this check relatively late so we can log only the interesting cases.
+    if (!flags()->use_poisoned && WordIsPoisoned(pp)) {
+      LOG_POINTERS(
+          "%p is poisoned: ignoring %p pointing into chunk %p-%p of size "
+          "%zu.\n",
+          pp, p, chunk, chunk + m.requested_size(), m.requested_size());
+      continue;
+    }
+
+    m.set_tag(tag);
+    LOG_POINTERS("%p: found %p pointing into chunk %p-%p of size %zu.\n", pp, p,
+                 chunk, chunk + m.requested_size(), m.requested_size());
+    if (frontier)
+      frontier->push_back(chunk);
+  }
+}
+
+void ForEachExtraStackRangeCb(uptr begin, uptr end, void* arg) {
+  Frontier *frontier = reinterpret_cast<Frontier *>(arg);
+  ScanRangeForPointers(begin, end, frontier, "FAKE STACK", kReachable);
+}
+
+// Scans thread data (stacks and TLS) for heap pointers.
+static void ProcessThreads(SuspendedThreadsList const &suspended_threads,
+                           Frontier *frontier) {
+  InternalScopedBuffer<uptr> registers(SuspendedThreadsList::RegisterCount());
+  uptr registers_begin = reinterpret_cast<uptr>(registers.data());
+  uptr registers_end = registers_begin + registers.size();
+  for (uptr i = 0; i < suspended_threads.thread_count(); i++) {
+    uptr os_id = static_cast<uptr>(suspended_threads.GetThreadID(i));
+    LOG_THREADS("Processing thread %d.\n", os_id);
+    uptr stack_begin, stack_end, tls_begin, tls_end, cache_begin, cache_end;
+    bool thread_found = GetThreadRangesLocked(os_id, &stack_begin, &stack_end,
+                                              &tls_begin, &tls_end,
+                                              &cache_begin, &cache_end);
+    if (!thread_found) {
+      // If a thread can't be found in the thread registry, it's probably in the
+      // process of destruction. Log this event and move on.
+      LOG_THREADS("Thread %d not found in registry.\n", os_id);
+      continue;
+    }
+    uptr sp;
+    bool have_registers =
+        (suspended_threads.GetRegistersAndSP(i, registers.data(), &sp) == 0);
+    if (!have_registers) {
+      Report("Unable to get registers from thread %d.\n");
+      // If unable to get SP, consider the entire stack to be reachable.
+      sp = stack_begin;
+    }
+
+    if (flags()->use_registers && have_registers)
+      ScanRangeForPointers(registers_begin, registers_end, frontier,
+                           "REGISTERS", kReachable);
+
+    if (flags()->use_stacks) {
+      LOG_THREADS("Stack at %p-%p (SP = %p).\n", stack_begin, stack_end, sp);
+      if (sp < stack_begin || sp >= stack_end) {
+        // SP is outside the recorded stack range (e.g. the thread is running a
+        // signal handler on alternate stack). Again, consider the entire stack
+        // range to be reachable.
+        LOG_THREADS("WARNING: stack pointer not in stack range.\n");
+      } else {
+        // Shrink the stack range to ignore out-of-scope values.
+        stack_begin = sp;
+      }
+      ScanRangeForPointers(stack_begin, stack_end, frontier, "STACK",
+                           kReachable);
+      ForEachExtraStackRange(os_id, ForEachExtraStackRangeCb, frontier);
+    }
+
+    if (flags()->use_tls) {
+      LOG_THREADS("TLS at %p-%p.\n", tls_begin, tls_end);
+      if (cache_begin == cache_end) {
+        ScanRangeForPointers(tls_begin, tls_end, frontier, "TLS", kReachable);
+      } else {
+        // Because LSan should not be loaded with dlopen(), we can assume
+        // that allocator cache will be part of static TLS image.
+        CHECK_LE(tls_begin, cache_begin);
+        CHECK_GE(tls_end, cache_end);
+        if (tls_begin < cache_begin)
+          ScanRangeForPointers(tls_begin, cache_begin, frontier, "TLS",
+                               kReachable);
+        if (tls_end > cache_end)
+          ScanRangeForPointers(cache_end, tls_end, frontier, "TLS", kReachable);
+      }
+    }
+  }
+}
+
+static void ProcessRootRegion(Frontier *frontier, uptr root_begin,
+                              uptr root_end) {
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  uptr begin, end, prot;
+  while (proc_maps.Next(&begin, &end,
+                        /*offset*/ nullptr, /*filename*/ nullptr,
+                        /*filename_size*/ 0, &prot)) {
+    uptr intersection_begin = Max(root_begin, begin);
+    uptr intersection_end = Min(end, root_end);
+    if (intersection_begin >= intersection_end) continue;
+    bool is_readable = prot & MemoryMappingLayout::kProtectionRead;
+    LOG_POINTERS("Root region %p-%p intersects with mapped region %p-%p (%s)\n",
+                 root_begin, root_end, begin, end,
+                 is_readable ? "readable" : "unreadable");
+    if (is_readable)
+      ScanRangeForPointers(intersection_begin, intersection_end, frontier,
+                           "ROOT", kReachable);
+  }
+}
+
+// Scans root regions for heap pointers.
+static void ProcessRootRegions(Frontier *frontier) {
+  if (!flags()->use_root_regions) return;
+  CHECK(root_regions);
+  for (uptr i = 0; i < root_regions->size(); i++) {
+    RootRegion region = (*root_regions)[i];
+    uptr begin_addr = reinterpret_cast<uptr>(region.begin);
+    ProcessRootRegion(frontier, begin_addr, begin_addr + region.size);
+  }
+}
+
+static void FloodFillTag(Frontier *frontier, ChunkTag tag) {
+  while (frontier->size()) {
+    uptr next_chunk = frontier->back();
+    frontier->pop_back();
+    LsanMetadata m(next_chunk);
+    ScanRangeForPointers(next_chunk, next_chunk + m.requested_size(), frontier,
+                         "HEAP", tag);
+  }
+}
+
+// ForEachChunk callback. If the chunk is marked as leaked, marks all chunks
+// which are reachable from it as indirectly leaked.
+static void MarkIndirectlyLeakedCb(uptr chunk, void *arg) {
+  chunk = GetUserBegin(chunk);
+  LsanMetadata m(chunk);
+  if (m.allocated() && m.tag() != kReachable) {
+    ScanRangeForPointers(chunk, chunk + m.requested_size(),
+                         /* frontier */ nullptr, "HEAP", kIndirectlyLeaked);
+  }
+}
+
+// ForEachChunk callback. If chunk is marked as ignored, adds its address to
+// frontier.
+static void CollectIgnoredCb(uptr chunk, void *arg) {
+  CHECK(arg);
+  chunk = GetUserBegin(chunk);
+  LsanMetadata m(chunk);
+  if (m.allocated() && m.tag() == kIgnored) {
+    LOG_POINTERS("Ignored: chunk %p-%p of size %zu.\n",
+                 chunk, chunk + m.requested_size(), m.requested_size());
+    reinterpret_cast<Frontier *>(arg)->push_back(chunk);
+  }
+}
+
+// Sets the appropriate tag on each chunk.
+static void ClassifyAllChunks(SuspendedThreadsList const &suspended_threads) {
+  // Holds the flood fill frontier.
+  Frontier frontier(1);
+
+  ForEachChunk(CollectIgnoredCb, &frontier);
+  ProcessGlobalRegions(&frontier);
+  ProcessThreads(suspended_threads, &frontier);
+  ProcessRootRegions(&frontier);
+  FloodFillTag(&frontier, kReachable);
+
+  // The check here is relatively expensive, so we do this in a separate flood
+  // fill. That way we can skip the check for chunks that are reachable
+  // otherwise.
+  LOG_POINTERS("Processing platform-specific allocations.\n");
+  CHECK_EQ(0, frontier.size());
+  ProcessPlatformSpecificAllocations(&frontier);
+  FloodFillTag(&frontier, kReachable);
+
+  // Iterate over leaked chunks and mark those that are reachable from other
+  // leaked chunks.
+  LOG_POINTERS("Scanning leaked chunks.\n");
+  ForEachChunk(MarkIndirectlyLeakedCb, nullptr);
+}
+
+// ForEachChunk callback. Resets the tags to pre-leak-check state.
+static void ResetTagsCb(uptr chunk, void *arg) {
+  (void)arg;
+  chunk = GetUserBegin(chunk);
+  LsanMetadata m(chunk);
+  if (m.allocated() && m.tag() != kIgnored)
+    m.set_tag(kDirectlyLeaked);
+}
+
+static void PrintStackTraceById(u32 stack_trace_id) {
+  CHECK(stack_trace_id);
+  StackDepotGet(stack_trace_id).Print();
+}
+
+// ForEachChunk callback. Aggregates information about unreachable chunks into
+// a LeakReport.
+static void CollectLeaksCb(uptr chunk, void *arg) {
+  CHECK(arg);
+  LeakReport *leak_report = reinterpret_cast<LeakReport *>(arg);
+  chunk = GetUserBegin(chunk);
+  LsanMetadata m(chunk);
+  if (!m.allocated()) return;
+  if (m.tag() == kDirectlyLeaked || m.tag() == kIndirectlyLeaked) {
+    u32 resolution = flags()->resolution;
+    u32 stack_trace_id = 0;
+    if (resolution > 0) {
+      StackTrace stack = StackDepotGet(m.stack_trace_id());
+      stack.size = Min(stack.size, resolution);
+      stack_trace_id = StackDepotPut(stack);
+    } else {
+      stack_trace_id = m.stack_trace_id();
+    }
+    leak_report->AddLeakedChunk(chunk, stack_trace_id, m.requested_size(),
+                                m.tag());
+  }
+}
+
+static void PrintMatchedSuppressions() {
+  InternalMmapVector<Suppression *> matched(1);
+  GetSuppressionContext()->GetMatched(&matched);
+  if (!matched.size())
+    return;
+  const char *line = "-----------------------------------------------------";
+  Printf("%s\n", line);
+  Printf("Suppressions used:\n");
+  Printf("  count      bytes template\n");
+  for (uptr i = 0; i < matched.size(); i++)
+    Printf("%7zu %10zu %s\n", static_cast<uptr>(atomic_load_relaxed(
+        &matched[i]->hit_count)), matched[i]->weight, matched[i]->templ);
+  Printf("%s\n\n", line);
+}
+
+struct CheckForLeaksParam {
+  bool success;
+  LeakReport leak_report;
+};
+
+static void CheckForLeaksCallback(const SuspendedThreadsList &suspended_threads,
+                                  void *arg) {
+  CheckForLeaksParam *param = reinterpret_cast<CheckForLeaksParam *>(arg);
+  CHECK(param);
+  CHECK(!param->success);
+  ClassifyAllChunks(suspended_threads);
+  ForEachChunk(CollectLeaksCb, &param->leak_report);
+  // Clean up for subsequent leak checks. This assumes we did not overwrite any
+  // kIgnored tags.
+  ForEachChunk(ResetTagsCb, nullptr);
+  param->success = true;
+}
+
+static bool CheckForLeaks() {
+  if (&__lsan_is_turned_off && __lsan_is_turned_off())
+      return false;
+  EnsureMainThreadIDIsCorrect();
+  CheckForLeaksParam param;
+  param.success = false;
+  LockThreadRegistry();
+  LockAllocator();
+  DoStopTheWorld(CheckForLeaksCallback, &param);
+  UnlockAllocator();
+  UnlockThreadRegistry();
+
+  if (!param.success) {
+    Report("LeakSanitizer has encountered a fatal error.\n");
+    Die();
+  }
+  param.leak_report.ApplySuppressions();
+  uptr unsuppressed_count = param.leak_report.UnsuppressedLeakCount();
+  if (unsuppressed_count > 0) {
+    Decorator d;
+    Printf("\n"
+           "================================================================="
+           "\n");
+    Printf("%s", d.Error());
+    Report("ERROR: LeakSanitizer: detected memory leaks\n");
+    Printf("%s", d.End());
+    param.leak_report.ReportTopLeaks(flags()->max_leaks);
+  }
+  if (common_flags()->print_suppressions)
+    PrintMatchedSuppressions();
+  if (unsuppressed_count > 0) {
+    param.leak_report.PrintSummary();
+    return true;
+  }
+  return false;
+}
+
+void DoLeakCheck() {
+  BlockingMutexLock l(&global_mutex);
+  static bool already_done;
+  if (already_done) return;
+  already_done = true;
+  bool have_leaks = CheckForLeaks();
+  if (!have_leaks) {
+    return;
+  }
+  if (common_flags()->exitcode) {
+    Die();
+  }
+}
+
+static int DoRecoverableLeakCheck() {
+  BlockingMutexLock l(&global_mutex);
+  bool have_leaks = CheckForLeaks();
+  return have_leaks ? 1 : 0;
+}
+
+static Suppression *GetSuppressionForAddr(uptr addr) {
+  Suppression *s = nullptr;
+
+  // Suppress by module name.
+  SuppressionContext *suppressions = GetSuppressionContext();
+  if (const char *module_name =
+          Symbolizer::GetOrInit()->GetModuleNameForPc(addr))
+    if (suppressions->Match(module_name, kSuppressionLeak, &s))
+      return s;
+
+  // Suppress by file or function name.
+  SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(addr);
+  for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+    if (suppressions->Match(cur->info.function, kSuppressionLeak, &s) ||
+        suppressions->Match(cur->info.file, kSuppressionLeak, &s)) {
+      break;
+    }
+  }
+  frames->ClearAll();
+  return s;
+}
+
+static Suppression *GetSuppressionForStack(u32 stack_trace_id) {
+  StackTrace stack = StackDepotGet(stack_trace_id);
+  for (uptr i = 0; i < stack.size; i++) {
+    Suppression *s = GetSuppressionForAddr(
+        StackTrace::GetPreviousInstructionPc(stack.trace[i]));
+    if (s) return s;
+  }
+  return nullptr;
+}
+
+///// LeakReport implementation. /////
+
+// A hard limit on the number of distinct leaks, to avoid quadratic complexity
+// in LeakReport::AddLeakedChunk(). We don't expect to ever see this many leaks
+// in real-world applications.
+// FIXME: Get rid of this limit by changing the implementation of LeakReport to
+// use a hash table.
+const uptr kMaxLeaksConsidered = 5000;
+
+void LeakReport::AddLeakedChunk(uptr chunk, u32 stack_trace_id,
+                                uptr leaked_size, ChunkTag tag) {
+  CHECK(tag == kDirectlyLeaked || tag == kIndirectlyLeaked);
+  bool is_directly_leaked = (tag == kDirectlyLeaked);
+  uptr i;
+  for (i = 0; i < leaks_.size(); i++) {
+    if (leaks_[i].stack_trace_id == stack_trace_id &&
+        leaks_[i].is_directly_leaked == is_directly_leaked) {
+      leaks_[i].hit_count++;
+      leaks_[i].total_size += leaked_size;
+      break;
+    }
+  }
+  if (i == leaks_.size()) {
+    if (leaks_.size() == kMaxLeaksConsidered) return;
+    Leak leak = { next_id_++, /* hit_count */ 1, leaked_size, stack_trace_id,
+                  is_directly_leaked, /* is_suppressed */ false };
+    leaks_.push_back(leak);
+  }
+  if (flags()->report_objects) {
+    LeakedObject obj = {leaks_[i].id, chunk, leaked_size};
+    leaked_objects_.push_back(obj);
+  }
+}
+
+static bool LeakComparator(const Leak &leak1, const Leak &leak2) {
+  if (leak1.is_directly_leaked == leak2.is_directly_leaked)
+    return leak1.total_size > leak2.total_size;
+  else
+    return leak1.is_directly_leaked;
+}
+
+void LeakReport::ReportTopLeaks(uptr num_leaks_to_report) {
+  CHECK(leaks_.size() <= kMaxLeaksConsidered);
+  Printf("\n");
+  if (leaks_.size() == kMaxLeaksConsidered)
+    Printf("Too many leaks! Only the first %zu leaks encountered will be "
+           "reported.\n",
+           kMaxLeaksConsidered);
+
+  uptr unsuppressed_count = UnsuppressedLeakCount();
+  if (num_leaks_to_report > 0 && num_leaks_to_report < unsuppressed_count)
+    Printf("The %zu top leak(s):\n", num_leaks_to_report);
+  InternalSort(&leaks_, leaks_.size(), LeakComparator);
+  uptr leaks_reported = 0;
+  for (uptr i = 0; i < leaks_.size(); i++) {
+    if (leaks_[i].is_suppressed) continue;
+    PrintReportForLeak(i);
+    leaks_reported++;
+    if (leaks_reported == num_leaks_to_report) break;
+  }
+  if (leaks_reported < unsuppressed_count) {
+    uptr remaining = unsuppressed_count - leaks_reported;
+    Printf("Omitting %zu more leak(s).\n", remaining);
+  }
+}
+
+void LeakReport::PrintReportForLeak(uptr index) {
+  Decorator d;
+  Printf("%s", d.Leak());
+  Printf("%s leak of %zu byte(s) in %zu object(s) allocated from:\n",
+         leaks_[index].is_directly_leaked ? "Direct" : "Indirect",
+         leaks_[index].total_size, leaks_[index].hit_count);
+  Printf("%s", d.End());
+
+  PrintStackTraceById(leaks_[index].stack_trace_id);
+
+  if (flags()->report_objects) {
+    Printf("Objects leaked above:\n");
+    PrintLeakedObjectsForLeak(index);
+    Printf("\n");
+  }
+}
+
+void LeakReport::PrintLeakedObjectsForLeak(uptr index) {
+  u32 leak_id = leaks_[index].id;
+  for (uptr j = 0; j < leaked_objects_.size(); j++) {
+    if (leaked_objects_[j].leak_id == leak_id)
+      Printf("%p (%zu bytes)\n", leaked_objects_[j].addr,
+             leaked_objects_[j].size);
+  }
+}
+
+void LeakReport::PrintSummary() {
+  CHECK(leaks_.size() <= kMaxLeaksConsidered);
+  uptr bytes = 0, allocations = 0;
+  for (uptr i = 0; i < leaks_.size(); i++) {
+      if (leaks_[i].is_suppressed) continue;
+      bytes += leaks_[i].total_size;
+      allocations += leaks_[i].hit_count;
+  }
+  InternalScopedString summary(kMaxSummaryLength);
+  summary.append("%zu byte(s) leaked in %zu allocation(s).", bytes,
+                 allocations);
+  ReportErrorSummary(summary.data());
+}
+
+void LeakReport::ApplySuppressions() {
+  for (uptr i = 0; i < leaks_.size(); i++) {
+    Suppression *s = GetSuppressionForStack(leaks_[i].stack_trace_id);
+    if (s) {
+      s->weight += leaks_[i].total_size;
+      atomic_store_relaxed(&s->hit_count, atomic_load_relaxed(&s->hit_count) +
+          leaks_[i].hit_count);
+      leaks_[i].is_suppressed = true;
+    }
+  }
+}
+
+uptr LeakReport::UnsuppressedLeakCount() {
+  uptr result = 0;
+  for (uptr i = 0; i < leaks_.size(); i++)
+    if (!leaks_[i].is_suppressed) result++;
+  return result;
+}
+
+} // namespace __lsan
+#endif // CAN_SANITIZE_LEAKS
+
+using namespace __lsan;  // NOLINT
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void __lsan_ignore_object(const void *p) {
+#if CAN_SANITIZE_LEAKS
+  if (!common_flags()->detect_leaks)
+    return;
+  // Cannot use PointsIntoChunk or LsanMetadata here, since the allocator is not
+  // locked.
+  BlockingMutexLock l(&global_mutex);
+  IgnoreObjectResult res = IgnoreObjectLocked(p);
+  if (res == kIgnoreObjectInvalid)
+    VReport(1, "__lsan_ignore_object(): no heap object found at %p", p);
+  if (res == kIgnoreObjectAlreadyIgnored)
+    VReport(1, "__lsan_ignore_object(): "
+           "heap object at %p is already being ignored\n", p);
+  if (res == kIgnoreObjectSuccess)
+    VReport(1, "__lsan_ignore_object(): ignoring heap object at %p\n", p);
+#endif // CAN_SANITIZE_LEAKS
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __lsan_register_root_region(const void *begin, uptr size) {
+#if CAN_SANITIZE_LEAKS
+  BlockingMutexLock l(&global_mutex);
+  CHECK(root_regions);
+  RootRegion region = {begin, size};
+  root_regions->push_back(region);
+  VReport(1, "Registered root region at %p of size %llu\n", begin, size);
+#endif // CAN_SANITIZE_LEAKS
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __lsan_unregister_root_region(const void *begin, uptr size) {
+#if CAN_SANITIZE_LEAKS
+  BlockingMutexLock l(&global_mutex);
+  CHECK(root_regions);
+  bool removed = false;
+  for (uptr i = 0; i < root_regions->size(); i++) {
+    RootRegion region = (*root_regions)[i];
+    if (region.begin == begin && region.size == size) {
+      removed = true;
+      uptr last_index = root_regions->size() - 1;
+      (*root_regions)[i] = (*root_regions)[last_index];
+      root_regions->pop_back();
+      VReport(1, "Unregistered root region at %p of size %llu\n", begin, size);
+      break;
+    }
+  }
+  if (!removed) {
+    Report(
+        "__lsan_unregister_root_region(): region at %p of size %llu has not "
+        "been registered.\n",
+        begin, size);
+    Die();
+  }
+#endif // CAN_SANITIZE_LEAKS
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __lsan_disable() {
+#if CAN_SANITIZE_LEAKS
+  __lsan::disable_counter++;
+#endif
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __lsan_enable() {
+#if CAN_SANITIZE_LEAKS
+  if (!__lsan::disable_counter && common_flags()->detect_leaks) {
+    Report("Unmatched call to __lsan_enable().\n");
+    Die();
+  }
+  __lsan::disable_counter--;
+#endif
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __lsan_do_leak_check() {
+#if CAN_SANITIZE_LEAKS
+  if (common_flags()->detect_leaks)
+    __lsan::DoLeakCheck();
+#endif // CAN_SANITIZE_LEAKS
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __lsan_do_recoverable_leak_check() {
+#if CAN_SANITIZE_LEAKS
+  if (common_flags()->detect_leaks)
+    return __lsan::DoRecoverableLeakCheck();
+#endif // CAN_SANITIZE_LEAKS
+  return 0;
+}
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+int __lsan_is_turned_off() {
+  return 0;
+}
+#endif
+} // extern "C"
diff --git a/compiler-rt/lib/lsan/lsan_common.h b/compiler-rt/lib/lsan/lsan_common.h
new file mode 100644
index 0000000..0dfd0d4
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_common.h
@@ -0,0 +1,186 @@
+//=-- lsan_common.h -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Private LSan header.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LSAN_COMMON_H
+#define LSAN_COMMON_H
+
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_platform.h"
+#include "sanitizer_common/sanitizer_stoptheworld.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+#if (SANITIZER_LINUX && !SANITIZER_ANDROID) && (SANITIZER_WORDSIZE == 64) \
+     && (defined(__x86_64__) ||  defined(__mips64) ||  defined(__aarch64__))
+#define CAN_SANITIZE_LEAKS 1
+#else
+#define CAN_SANITIZE_LEAKS 0
+#endif
+
+namespace __sanitizer {
+class FlagParser;
+}
+
+namespace __lsan {
+
+// Chunk tags.
+enum ChunkTag {
+  kDirectlyLeaked = 0,  // default
+  kIndirectlyLeaked = 1,
+  kReachable = 2,
+  kIgnored = 3
+};
+
+struct Flags {
+#define LSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "lsan_flags.inc"
+#undef LSAN_FLAG
+
+  void SetDefaults();
+  uptr pointer_alignment() const {
+    return use_unaligned ? 1 : sizeof(uptr);
+  }
+};
+
+extern Flags lsan_flags;
+inline Flags *flags() { return &lsan_flags; }
+void RegisterLsanFlags(FlagParser *parser, Flags *f);
+
+struct Leak {
+  u32 id;
+  uptr hit_count;
+  uptr total_size;
+  u32 stack_trace_id;
+  bool is_directly_leaked;
+  bool is_suppressed;
+};
+
+struct LeakedObject {
+  u32 leak_id;
+  uptr addr;
+  uptr size;
+};
+
+// Aggregates leaks by stack trace prefix.
+class LeakReport {
+ public:
+  LeakReport() : next_id_(0), leaks_(1), leaked_objects_(1) {}
+  void AddLeakedChunk(uptr chunk, u32 stack_trace_id, uptr leaked_size,
+                      ChunkTag tag);
+  void ReportTopLeaks(uptr max_leaks);
+  void PrintSummary();
+  void ApplySuppressions();
+  uptr UnsuppressedLeakCount();
+
+
+ private:
+  void PrintReportForLeak(uptr index);
+  void PrintLeakedObjectsForLeak(uptr index);
+
+  u32 next_id_;
+  InternalMmapVector<Leak> leaks_;
+  InternalMmapVector<LeakedObject> leaked_objects_;
+};
+
+typedef InternalMmapVector<uptr> Frontier;
+
+// Platform-specific functions.
+void InitializePlatformSpecificModules();
+void ProcessGlobalRegions(Frontier *frontier);
+void ProcessPlatformSpecificAllocations(Frontier *frontier);
+// Run stoptheworld while holding any platform-specific locks.
+void DoStopTheWorld(StopTheWorldCallback callback, void* argument);
+
+void ScanRangeForPointers(uptr begin, uptr end,
+                          Frontier *frontier,
+                          const char *region_type, ChunkTag tag);
+
+enum IgnoreObjectResult {
+  kIgnoreObjectSuccess,
+  kIgnoreObjectAlreadyIgnored,
+  kIgnoreObjectInvalid
+};
+
+// Functions called from the parent tool.
+void InitCommonLsan();
+void DoLeakCheck();
+bool DisabledInThisThread();
+
+// Special case for "new T[0]" where T is a type with DTOR.
+// new T[0] will allocate one word for the array size (0) and store a pointer
+// to the end of allocated chunk.
+inline bool IsSpecialCaseOfOperatorNew0(uptr chunk_beg, uptr chunk_size,
+                                        uptr addr) {
+  return chunk_size == sizeof(uptr) && chunk_beg + chunk_size == addr &&
+         *reinterpret_cast<uptr *>(chunk_beg) == 0;
+}
+
+// The following must be implemented in the parent tool.
+
+void ForEachChunk(ForEachChunkCallback callback, void *arg);
+// Returns the address range occupied by the global allocator object.
+void GetAllocatorGlobalRange(uptr *begin, uptr *end);
+// Wrappers for allocator's ForceLock()/ForceUnlock().
+void LockAllocator();
+void UnlockAllocator();
+// Returns true if [addr, addr + sizeof(void *)) is poisoned.
+bool WordIsPoisoned(uptr addr);
+// Wrappers for ThreadRegistry access.
+void LockThreadRegistry();
+void UnlockThreadRegistry();
+bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
+                           uptr *tls_begin, uptr *tls_end,
+                           uptr *cache_begin, uptr *cache_end);
+void ForEachExtraStackRange(uptr os_id, RangeIteratorCallback callback,
+                            void *arg);
+// If called from the main thread, updates the main thread's TID in the thread
+// registry. We need this to handle processes that fork() without a subsequent
+// exec(), which invalidates the recorded TID. To update it, we must call
+// gettid() from the main thread. Our solution is to call this function before
+// leak checking and also before every call to pthread_create() (to handle cases
+// where leak checking is initiated from a non-main thread).
+void EnsureMainThreadIDIsCorrect();
+// If p points into a chunk that has been allocated to the user, returns its
+// user-visible address. Otherwise, returns 0.
+uptr PointsIntoChunk(void *p);
+// Returns address of user-visible chunk contained in this allocator chunk.
+uptr GetUserBegin(uptr chunk);
+// Helper for __lsan_ignore_object().
+IgnoreObjectResult IgnoreObjectLocked(const void *p);
+// Wrapper for chunk metadata operations.
+class LsanMetadata {
+ public:
+  // Constructor accepts address of user-visible chunk.
+  explicit LsanMetadata(uptr chunk);
+  bool allocated() const;
+  ChunkTag tag() const;
+  void set_tag(ChunkTag value);
+  uptr requested_size() const;
+  u32 stack_trace_id() const;
+ private:
+  void *metadata_;
+};
+
+}  // namespace __lsan
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+int __lsan_is_turned_off();
+
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+const char *__lsan_default_suppressions();
+}  // extern "C"
+
+#endif  // LSAN_COMMON_H
diff --git a/compiler-rt/lib/lsan/lsan_common_linux.cc b/compiler-rt/lib/lsan/lsan_common_linux.cc
new file mode 100644
index 0000000..1dc0561
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_common_linux.cc
@@ -0,0 +1,179 @@
+//=-- lsan_common_linux.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Implementation of common leak checking functionality. Linux-specific code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#include "lsan_common.h"
+
+#if CAN_SANITIZE_LEAKS && SANITIZER_LINUX
+#include <link.h>
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+
+namespace __lsan {
+
+static const char kLinkerName[] = "ld";
+// We request 2 modules matching "ld", so we can print a warning if there's more
+// than one match. But only the first one is actually used.
+static char linker_placeholder[2 * sizeof(LoadedModule)] ALIGNED(64);
+static LoadedModule *linker = nullptr;
+
+static bool IsLinker(const char* full_name) {
+  return LibraryNameIs(full_name, kLinkerName);
+}
+
+void InitializePlatformSpecificModules() {
+  internal_memset(linker_placeholder, 0, sizeof(linker_placeholder));
+  uptr num_matches = GetListOfModules(
+      reinterpret_cast<LoadedModule *>(linker_placeholder), 2, IsLinker);
+  if (num_matches == 1) {
+    linker = reinterpret_cast<LoadedModule *>(linker_placeholder);
+    return;
+  }
+  if (num_matches == 0)
+    VReport(1, "LeakSanitizer: Dynamic linker not found. "
+            "TLS will not be handled correctly.\n");
+  else if (num_matches > 1)
+    VReport(1, "LeakSanitizer: Multiple modules match \"%s\". "
+            "TLS will not be handled correctly.\n", kLinkerName);
+  linker = nullptr;
+}
+
+static int ProcessGlobalRegionsCallback(struct dl_phdr_info *info, size_t size,
+                                        void *data) {
+  Frontier *frontier = reinterpret_cast<Frontier *>(data);
+  for (uptr j = 0; j < info->dlpi_phnum; j++) {
+    const ElfW(Phdr) *phdr = &(info->dlpi_phdr[j]);
+    // We're looking for .data and .bss sections, which reside in writeable,
+    // loadable segments.
+    if (!(phdr->p_flags & PF_W) || (phdr->p_type != PT_LOAD) ||
+        (phdr->p_memsz == 0))
+      continue;
+    uptr begin = info->dlpi_addr + phdr->p_vaddr;
+    uptr end = begin + phdr->p_memsz;
+    uptr allocator_begin = 0, allocator_end = 0;
+    GetAllocatorGlobalRange(&allocator_begin, &allocator_end);
+    if (begin <= allocator_begin && allocator_begin < end) {
+      CHECK_LE(allocator_begin, allocator_end);
+      CHECK_LT(allocator_end, end);
+      if (begin < allocator_begin)
+        ScanRangeForPointers(begin, allocator_begin, frontier, "GLOBAL",
+                             kReachable);
+      if (allocator_end < end)
+        ScanRangeForPointers(allocator_end, end, frontier, "GLOBAL",
+                             kReachable);
+    } else {
+      ScanRangeForPointers(begin, end, frontier, "GLOBAL", kReachable);
+    }
+  }
+  return 0;
+}
+
+// Scans global variables for heap pointers.
+void ProcessGlobalRegions(Frontier *frontier) {
+  if (!flags()->use_globals) return;
+  dl_iterate_phdr(ProcessGlobalRegionsCallback, frontier);
+}
+
+static uptr GetCallerPC(u32 stack_id, StackDepotReverseMap *map) {
+  CHECK(stack_id);
+  StackTrace stack = map->Get(stack_id);
+  // The top frame is our malloc/calloc/etc. The next frame is the caller.
+  if (stack.size >= 2)
+    return stack.trace[1];
+  return 0;
+}
+
+struct ProcessPlatformAllocParam {
+  Frontier *frontier;
+  StackDepotReverseMap *stack_depot_reverse_map;
+};
+
+// ForEachChunk callback. Identifies unreachable chunks which must be treated as
+// reachable. Marks them as reachable and adds them to the frontier.
+static void ProcessPlatformSpecificAllocationsCb(uptr chunk, void *arg) {
+  CHECK(arg);
+  ProcessPlatformAllocParam *param =
+      reinterpret_cast<ProcessPlatformAllocParam *>(arg);
+  chunk = GetUserBegin(chunk);
+  LsanMetadata m(chunk);
+  if (m.allocated() && m.tag() != kReachable && m.tag() != kIgnored) {
+    u32 stack_id = m.stack_trace_id();
+    uptr caller_pc = 0;
+    if (stack_id > 0)
+      caller_pc = GetCallerPC(stack_id, param->stack_depot_reverse_map);
+    // If caller_pc is unknown, this chunk may be allocated in a coroutine. Mark
+    // it as reachable, as we can't properly report its allocation stack anyway.
+    if (caller_pc == 0 || linker->containsAddress(caller_pc)) {
+      m.set_tag(kReachable);
+      param->frontier->push_back(chunk);
+    }
+  }
+}
+
+// Handles dynamically allocated TLS blocks by treating all chunks allocated
+// from ld-linux.so as reachable.
+// Dynamic TLS blocks contain the TLS variables of dynamically loaded modules.
+// They are allocated with a __libc_memalign() call in allocate_and_init()
+// (elf/dl-tls.c). Glibc won't tell us the address ranges occupied by those
+// blocks, but we can make sure they come from our own allocator by intercepting
+// __libc_memalign(). On top of that, there is no easy way to reach them. Their
+// addresses are stored in a dynamically allocated array (the DTV) which is
+// referenced from the static TLS. Unfortunately, we can't just rely on the DTV
+// being reachable from the static TLS, and the dynamic TLS being reachable from
+// the DTV. This is because the initial DTV is allocated before our interception
+// mechanism kicks in, and thus we don't recognize it as allocated memory. We
+// can't special-case it either, since we don't know its size.
+// Our solution is to include in the root set all allocations made from
+// ld-linux.so (which is where allocate_and_init() is implemented). This is
+// guaranteed to include all dynamic TLS blocks (and possibly other allocations
+// which we don't care about).
+void ProcessPlatformSpecificAllocations(Frontier *frontier) {
+  if (!flags()->use_tls) return;
+  if (!linker) return;
+  StackDepotReverseMap stack_depot_reverse_map;
+  ProcessPlatformAllocParam arg = {frontier, &stack_depot_reverse_map};
+  ForEachChunk(ProcessPlatformSpecificAllocationsCb, &arg);
+}
+
+struct DoStopTheWorldParam {
+  StopTheWorldCallback callback;
+  void *argument;
+};
+
+static int DoStopTheWorldCallback(struct dl_phdr_info *info, size_t size,
+                                  void *data) {
+  DoStopTheWorldParam *param = reinterpret_cast<DoStopTheWorldParam *>(data);
+  StopTheWorld(param->callback, param->argument);
+  return 1;
+}
+
+// LSan calls dl_iterate_phdr() from the tracer task. This may deadlock: if one
+// of the threads is frozen while holding the libdl lock, the tracer will hang
+// in dl_iterate_phdr() forever.
+// Luckily, (a) the lock is reentrant and (b) libc can't distinguish between the
+// tracer task and the thread that spawned it. Thus, if we run the tracer task
+// while holding the libdl lock in the parent thread, we can safely reenter it
+// in the tracer. The solution is to run stoptheworld from a dl_iterate_phdr()
+// callback in the parent thread.
+void DoStopTheWorld(StopTheWorldCallback callback, void *argument) {
+  DoStopTheWorldParam param = {callback, argument};
+  dl_iterate_phdr(DoStopTheWorldCallback, &param);
+}
+
+} // namespace __lsan
+
+#endif // CAN_SANITIZE_LEAKS && SANITIZER_LINUX
diff --git a/compiler-rt/lib/lsan/lsan_flags.inc b/compiler-rt/lib/lsan/lsan_flags.inc
new file mode 100644
index 0000000..c405005
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_flags.inc
@@ -0,0 +1,43 @@
+//===-- lsan_flags.inc ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// LSan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LSAN_FLAG
+# error "Define LSAN_FLAG prior to including this file!"
+#endif
+
+// LSAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+LSAN_FLAG(bool, report_objects, false,
+          "Print addresses of leaked objects after main leak report.")
+LSAN_FLAG(
+    int, resolution, 0,
+    "Aggregate two objects into one leak if this many stack frames match. If "
+    "zero, the entire stack trace must match.")
+LSAN_FLAG(int, max_leaks, 0, "The number of leaks reported.")
+
+// Flags controlling the root set of reachable memory.
+LSAN_FLAG(bool, use_globals, true,
+          "Root set: include global variables (.data and .bss)")
+LSAN_FLAG(bool, use_stacks, true, "Root set: include thread stacks")
+LSAN_FLAG(bool, use_registers, true, "Root set: include thread registers")
+LSAN_FLAG(bool, use_tls, true,
+          "Root set: include TLS and thread-specific storage")
+LSAN_FLAG(bool, use_root_regions, true,
+          "Root set: include regions added via __lsan_register_root_region().")
+
+LSAN_FLAG(bool, use_unaligned, false, "Consider unaligned pointers valid.")
+LSAN_FLAG(bool, use_poisoned, false,
+          "Consider pointers found in poisoned memory to be valid.")
+LSAN_FLAG(bool, log_pointers, false, "Debug logging")
+LSAN_FLAG(bool, log_threads, false, "Debug logging")
+LSAN_FLAG(const char *, suppressions, "", "Suppressions file name.")
diff --git a/compiler-rt/lib/lsan/lsan_interceptors.cc b/compiler-rt/lib/lsan/lsan_interceptors.cc
new file mode 100644
index 0000000..be0d0dd
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_interceptors.cc
@@ -0,0 +1,287 @@
+//=-- lsan_interceptors.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Interceptors for standalone LSan.
+//
+//===----------------------------------------------------------------------===//
+
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_platform_limits_posix.h"
+#include "lsan.h"
+#include "lsan_allocator.h"
+#include "lsan_thread.h"
+
+using namespace __lsan;
+
+extern "C" {
+int pthread_attr_init(void *attr);
+int pthread_attr_destroy(void *attr);
+int pthread_attr_getdetachstate(void *attr, int *v);
+int pthread_key_create(unsigned *key, void (*destructor)(void* v));
+int pthread_setspecific(unsigned key, const void *v);
+}
+
+#define ENSURE_LSAN_INITED do {   \
+  CHECK(!lsan_init_is_running);   \
+  if (!lsan_inited)               \
+    __lsan_init();                \
+} while (0)
+
+///// Malloc/free interceptors. /////
+
+const bool kAlwaysClearMemory = true;
+
+namespace std {
+  struct nothrow_t;
+}
+
+INTERCEPTOR(void*, malloc, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  return Allocate(stack, size, 1, kAlwaysClearMemory);
+}
+
+INTERCEPTOR(void, free, void *p) {
+  ENSURE_LSAN_INITED;
+  Deallocate(p);
+}
+
+INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
+  if (lsan_init_is_running) {
+    // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
+    const uptr kCallocPoolSize = 1024;
+    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
+    static uptr allocated;
+    uptr size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
+    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
+    allocated += size_in_words;
+    CHECK(allocated < kCallocPoolSize);
+    return mem;
+  }
+  if (CallocShouldReturnNullDueToOverflow(size, nmemb)) return nullptr;
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  size *= nmemb;
+  return Allocate(stack, size, 1, true);
+}
+
+INTERCEPTOR(void*, realloc, void *q, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  return Reallocate(stack, q, size, 1);
+}
+
+INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  return Allocate(stack, size, alignment, kAlwaysClearMemory);
+}
+
+INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  return Allocate(stack, size, alignment, kAlwaysClearMemory);
+}
+
+INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  *memptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
+  // FIXME: Return ENOMEM if user requested more than max alloc size.
+  return 0;
+}
+
+INTERCEPTOR(void*, valloc, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  if (size == 0)
+    size = GetPageSizeCached();
+  return Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory);
+}
+
+INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
+  ENSURE_LSAN_INITED;
+  return GetMallocUsableSize(ptr);
+}
+
+struct fake_mallinfo {
+  int x[10];
+};
+
+INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
+  struct fake_mallinfo res;
+  internal_memset(&res, 0, sizeof(res));
+  return res;
+}
+
+INTERCEPTOR(int, mallopt, int cmd, int value) {
+  return -1;
+}
+
+INTERCEPTOR(void*, pvalloc, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  uptr PageSize = GetPageSizeCached();
+  size = RoundUpTo(size, PageSize);
+  if (size == 0) {
+    // pvalloc(0) should allocate one page.
+    size = PageSize;
+  }
+  return Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory);
+}
+
+INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
+
+#define OPERATOR_NEW_BODY                              \
+  ENSURE_LSAN_INITED;                                  \
+  GET_STACK_TRACE_MALLOC;                              \
+  return Allocate(stack, size, 1, kAlwaysClearMemory);
+
+INTERCEPTOR_ATTRIBUTE
+void *operator new(uptr size) { OPERATOR_NEW_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void *operator new[](uptr size) { OPERATOR_NEW_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void *operator new(uptr size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void *operator new[](uptr size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
+
+#define OPERATOR_DELETE_BODY \
+  ENSURE_LSAN_INITED;        \
+  Deallocate(ptr);
+
+INTERCEPTOR_ATTRIBUTE
+void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void operator delete[](void *ptr, std::nothrow_t const &) {
+  OPERATOR_DELETE_BODY;
+}
+
+// We need this to intercept the __libc_memalign calls that are used to
+// allocate dynamic TLS space in ld-linux.so.
+INTERCEPTOR(void *, __libc_memalign, uptr align, uptr s)
+    ALIAS(WRAPPER_NAME(memalign));
+
+///// Thread initialization and finalization. /////
+
+static unsigned g_thread_finalize_key;
+
+static void thread_finalize(void *v) {
+  uptr iter = (uptr)v;
+  if (iter > 1) {
+    if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
+      Report("LeakSanitizer: failed to set thread key.\n");
+      Die();
+    }
+    return;
+  }
+  ThreadFinish();
+}
+
+struct ThreadParam {
+  void *(*callback)(void *arg);
+  void *param;
+  atomic_uintptr_t tid;
+};
+
+extern "C" void *__lsan_thread_start_func(void *arg) {
+  ThreadParam *p = (ThreadParam*)arg;
+  void* (*callback)(void *arg) = p->callback;
+  void *param = p->param;
+  // Wait until the last iteration to maximize the chance that we are the last
+  // destructor to run.
+  if (pthread_setspecific(g_thread_finalize_key,
+                          (void*)GetPthreadDestructorIterations())) {
+    Report("LeakSanitizer: failed to set thread key.\n");
+    Die();
+  }
+  int tid = 0;
+  while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
+    internal_sched_yield();
+  SetCurrentThread(tid);
+  ThreadStart(tid, GetTid());
+  atomic_store(&p->tid, 0, memory_order_release);
+  return callback(param);
+}
+
+INTERCEPTOR(int, pthread_create, void *th, void *attr,
+            void *(*callback)(void *), void *param) {
+  ENSURE_LSAN_INITED;
+  EnsureMainThreadIDIsCorrect();
+  __sanitizer_pthread_attr_t myattr;
+  if (!attr) {
+    pthread_attr_init(&myattr);
+    attr = &myattr;
+  }
+  AdjustStackSize(attr);
+  int detached = 0;
+  pthread_attr_getdetachstate(attr, &detached);
+  ThreadParam p;
+  p.callback = callback;
+  p.param = param;
+  atomic_store(&p.tid, 0, memory_order_relaxed);
+  int res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
+  if (res == 0) {
+    int tid = ThreadCreate(GetCurrentThread(), *(uptr *)th, detached);
+    CHECK_NE(tid, 0);
+    atomic_store(&p.tid, tid, memory_order_release);
+    while (atomic_load(&p.tid, memory_order_acquire) != 0)
+      internal_sched_yield();
+  }
+  if (attr == &myattr)
+    pthread_attr_destroy(&myattr);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_join, void *th, void **ret) {
+  ENSURE_LSAN_INITED;
+  int tid = ThreadTid((uptr)th);
+  int res = REAL(pthread_join)(th, ret);
+  if (res == 0)
+    ThreadJoin(tid);
+  return res;
+}
+
+namespace __lsan {
+
+void InitializeInterceptors() {
+  INTERCEPT_FUNCTION(malloc);
+  INTERCEPT_FUNCTION(free);
+  INTERCEPT_FUNCTION(cfree);
+  INTERCEPT_FUNCTION(calloc);
+  INTERCEPT_FUNCTION(realloc);
+  INTERCEPT_FUNCTION(memalign);
+  INTERCEPT_FUNCTION(posix_memalign);
+  INTERCEPT_FUNCTION(__libc_memalign);
+  INTERCEPT_FUNCTION(valloc);
+  INTERCEPT_FUNCTION(pvalloc);
+  INTERCEPT_FUNCTION(malloc_usable_size);
+  INTERCEPT_FUNCTION(mallinfo);
+  INTERCEPT_FUNCTION(mallopt);
+  INTERCEPT_FUNCTION(pthread_create);
+  INTERCEPT_FUNCTION(pthread_join);
+
+  if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
+    Report("LeakSanitizer: failed to create thread key.\n");
+    Die();
+  }
+}
+
+} // namespace __lsan
diff --git a/compiler-rt/lib/lsan/lsan_preinit.cc b/compiler-rt/lib/lsan/lsan_preinit.cc
new file mode 100644
index 0000000..5a19095
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_preinit.cc
@@ -0,0 +1,22 @@
+//===-- lsan_preinit.cc ---------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+//
+// Call __lsan_init at the very early stage of process startup.
+//===----------------------------------------------------------------------===//
+
+#include "lsan.h"
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+  // We force __lsan_init to be called before anyone else by placing it into
+  // .preinit_array section.
+  __attribute__((section(".preinit_array"), used))
+  void (*__local_lsan_preinit)(void) = __lsan_init;
+#endif
diff --git a/compiler-rt/lib/lsan/lsan_thread.cc b/compiler-rt/lib/lsan/lsan_thread.cc
new file mode 100644
index 0000000..10ac2c9
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_thread.cc
@@ -0,0 +1,160 @@
+//=-- lsan_thread.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// See lsan_thread.h for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lsan_thread.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_thread_registry.h"
+#include "lsan_allocator.h"
+
+namespace __lsan {
+
+const u32 kInvalidTid = (u32) -1;
+
+static ThreadRegistry *thread_registry;
+static THREADLOCAL u32 current_thread_tid = kInvalidTid;
+
+static ThreadContextBase *CreateThreadContext(u32 tid) {
+  void *mem = MmapOrDie(sizeof(ThreadContext), "ThreadContext");
+  return new(mem) ThreadContext(tid);
+}
+
+static const uptr kMaxThreads = 1 << 13;
+static const uptr kThreadQuarantineSize = 64;
+
+void InitializeThreadRegistry() {
+  static char thread_registry_placeholder[sizeof(ThreadRegistry)] ALIGNED(64);
+  thread_registry = new(thread_registry_placeholder)
+    ThreadRegistry(CreateThreadContext, kMaxThreads, kThreadQuarantineSize);
+}
+
+u32 GetCurrentThread() {
+  return current_thread_tid;
+}
+
+void SetCurrentThread(u32 tid) {
+  current_thread_tid = tid;
+}
+
+ThreadContext::ThreadContext(int tid)
+  : ThreadContextBase(tid),
+    stack_begin_(0),
+    stack_end_(0),
+    cache_begin_(0),
+    cache_end_(0),
+    tls_begin_(0),
+    tls_end_(0) {}
+
+struct OnStartedArgs {
+  uptr stack_begin, stack_end,
+       cache_begin, cache_end,
+       tls_begin, tls_end;
+};
+
+void ThreadContext::OnStarted(void *arg) {
+  OnStartedArgs *args = reinterpret_cast<OnStartedArgs *>(arg);
+  stack_begin_ = args->stack_begin;
+  stack_end_ = args->stack_end;
+  tls_begin_ = args->tls_begin;
+  tls_end_ = args->tls_end;
+  cache_begin_ = args->cache_begin;
+  cache_end_ = args->cache_end;
+}
+
+void ThreadContext::OnFinished() {
+  AllocatorThreadFinish();
+}
+
+u32 ThreadCreate(u32 parent_tid, uptr user_id, bool detached) {
+  return thread_registry->CreateThread(user_id, detached, parent_tid,
+                                       /* arg */ nullptr);
+}
+
+void ThreadStart(u32 tid, uptr os_id) {
+  OnStartedArgs args;
+  uptr stack_size = 0;
+  uptr tls_size = 0;
+  GetThreadStackAndTls(tid == 0, &args.stack_begin, &stack_size,
+                       &args.tls_begin, &tls_size);
+  args.stack_end = args.stack_begin + stack_size;
+  args.tls_end = args.tls_begin + tls_size;
+  GetAllocatorCacheRange(&args.cache_begin, &args.cache_end);
+  thread_registry->StartThread(tid, os_id, &args);
+}
+
+void ThreadFinish() {
+  thread_registry->FinishThread(GetCurrentThread());
+}
+
+ThreadContext *CurrentThreadContext() {
+  if (!thread_registry) return nullptr;
+  if (GetCurrentThread() == kInvalidTid)
+    return nullptr;
+  // No lock needed when getting current thread.
+  return (ThreadContext *)thread_registry->GetThreadLocked(GetCurrentThread());
+}
+
+static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) {
+  uptr uid = (uptr)arg;
+  if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) {
+    return true;
+  }
+  return false;
+}
+
+u32 ThreadTid(uptr uid) {
+  return thread_registry->FindThread(FindThreadByUid, (void*)uid);
+}
+
+void ThreadJoin(u32 tid) {
+  CHECK_NE(tid, kInvalidTid);
+  thread_registry->JoinThread(tid, /* arg */nullptr);
+}
+
+void EnsureMainThreadIDIsCorrect() {
+  if (GetCurrentThread() == 0)
+    CurrentThreadContext()->os_id = GetTid();
+}
+
+///// Interface to the common LSan module. /////
+
+bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
+                           uptr *tls_begin, uptr *tls_end,
+                           uptr *cache_begin, uptr *cache_end) {
+  ThreadContext *context = static_cast<ThreadContext *>(
+      thread_registry->FindThreadContextByOsIDLocked(os_id));
+  if (!context) return false;
+  *stack_begin = context->stack_begin();
+  *stack_end = context->stack_end();
+  *tls_begin = context->tls_begin();
+  *tls_end = context->tls_end();
+  *cache_begin = context->cache_begin();
+  *cache_end = context->cache_end();
+  return true;
+}
+
+void ForEachExtraStackRange(uptr os_id, RangeIteratorCallback callback,
+                            void *arg) {
+}
+
+void LockThreadRegistry() {
+  thread_registry->Lock();
+}
+
+void UnlockThreadRegistry() {
+  thread_registry->Unlock();
+}
+
+} // namespace __lsan
diff --git a/compiler-rt/lib/lsan/lsan_thread.h b/compiler-rt/lib/lsan/lsan_thread.h
new file mode 100644
index 0000000..99e2c1d
--- /dev/null
+++ b/compiler-rt/lib/lsan/lsan_thread.h
@@ -0,0 +1,53 @@
+//=-- lsan_thread.h -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Thread registry for standalone LSan.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LSAN_THREAD_H
+#define LSAN_THREAD_H
+
+#include "sanitizer_common/sanitizer_thread_registry.h"
+
+namespace __lsan {
+
+class ThreadContext : public ThreadContextBase {
+ public:
+  explicit ThreadContext(int tid);
+  void OnStarted(void *arg) override;
+  void OnFinished() override;
+  uptr stack_begin() { return stack_begin_; }
+  uptr stack_end() { return stack_end_; }
+  uptr tls_begin() { return tls_begin_; }
+  uptr tls_end() { return tls_end_; }
+  uptr cache_begin() { return cache_begin_; }
+  uptr cache_end() { return cache_end_; }
+ private:
+  uptr stack_begin_, stack_end_,
+       cache_begin_, cache_end_,
+       tls_begin_, tls_end_;
+};
+
+void InitializeThreadRegistry();
+
+void ThreadStart(u32 tid, uptr os_id);
+void ThreadFinish();
+u32 ThreadCreate(u32 tid, uptr uid, bool detached);
+void ThreadJoin(u32 tid);
+u32 ThreadTid(uptr uid);
+
+u32 GetCurrentThread();
+void SetCurrentThread(u32 tid);
+ThreadContext *CurrentThreadContext();
+void EnsureMainThreadIDIsCorrect();
+}  // namespace __lsan
+
+#endif  // LSAN_THREAD_H
diff --git a/compiler-rt/lib/msan/.clang-format b/compiler-rt/lib/msan/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/msan/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/msan/CMakeLists.txt b/compiler-rt/lib/msan/CMakeLists.txt
new file mode 100644
index 0000000..1b48def
--- /dev/null
+++ b/compiler-rt/lib/msan/CMakeLists.txt
@@ -0,0 +1,67 @@
+include_directories(..)
+
+# Runtime library sources and build flags.
+set(MSAN_RTL_SOURCES
+  msan.cc
+  msan_allocator.cc
+  msan_chained_origin_depot.cc
+  msan_interceptors.cc
+  msan_linux.cc
+  msan_report.cc
+  msan_thread.cc
+  msan_poisoning.cc
+  )
+
+set(MSAN_RTL_CXX_SOURCES
+  msan_new_delete.cc)
+
+
+set(MSAN_RTL_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(MSAN_RTL_CFLAGS)
+append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE MSAN_RTL_CFLAGS)
+# Prevent clang from generating libc calls.
+append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding MSAN_RTL_CFLAGS)
+
+set(MSAN_RUNTIME_LIBRARIES)
+
+# Static runtime library.
+add_custom_target(msan)
+foreach(arch ${MSAN_SUPPORTED_ARCH})
+  add_compiler_rt_runtime(clang_rt.msan
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${MSAN_RTL_SOURCES}
+            $<TARGET_OBJECTS:RTInterception.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+            $<TARGET_OBJECTS:RTUbsan.${arch}>
+    CFLAGS ${MSAN_RTL_CFLAGS}
+    PARENT_TARGET msan)
+  add_compiler_rt_runtime(clang_rt.msan_cxx
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${MSAN_RTL_CXX_SOURCES}
+            $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
+    CFLAGS ${MSAN_RTL_CFLAGS}
+    PARENT_TARGET msan)
+  list(APPEND MSAN_RUNTIME_LIBRARIES clang_rt.msan-${arch}
+                                     clang_rt.msan_cxx-${arch})
+  if(UNIX)
+    add_sanitizer_rt_symbols(clang_rt.msan
+      ARCHS ${arch}
+      EXTRA msan.syms.extra)
+    add_sanitizer_rt_symbols(clang_rt.msan_cxx
+      ARCHS ${arch}
+      EXTRA msan.syms.extra)
+    add_dependencies(msan clang_rt.msan-${arch}-symbols
+                          clang_rt.msan_cxx-${arch}-symbols)
+  endif()
+endforeach()
+
+add_compiler_rt_resource_file(msan_blacklist msan_blacklist.txt)
+add_dependencies(msan msan_blacklist)
+add_dependencies(compiler-rt msan)
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(tests)
+endif()
diff --git a/compiler-rt/lib/msan/msan.cc b/compiler-rt/lib/msan/msan.cc
new file mode 100644
index 0000000..9949db4
--- /dev/null
+++ b/compiler-rt/lib/msan/msan.cc
@@ -0,0 +1,642 @@
+//===-- msan.cc -----------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// MemorySanitizer runtime.
+//===----------------------------------------------------------------------===//
+
+#include "msan.h"
+#include "msan_chained_origin_depot.h"
+#include "msan_origin.h"
+#include "msan_thread.h"
+#include "msan_poisoning.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "ubsan/ubsan_flags.h"
+#include "ubsan/ubsan_init.h"
+
+// ACHTUNG! No system header includes in this file.
+
+using namespace __sanitizer;
+
+// Globals.
+static THREADLOCAL int msan_expect_umr = 0;
+static THREADLOCAL int msan_expected_umr_found = 0;
+
+// Function argument shadow. Each argument starts at the next available 8-byte
+// aligned address.
+SANITIZER_INTERFACE_ATTRIBUTE
+THREADLOCAL u64 __msan_param_tls[kMsanParamTlsSize / sizeof(u64)];
+
+// Function argument origin. Each argument starts at the same offset as the
+// corresponding shadow in (__msan_param_tls). Slightly weird, but changing this
+// would break compatibility with older prebuilt binaries.
+SANITIZER_INTERFACE_ATTRIBUTE
+THREADLOCAL u32 __msan_param_origin_tls[kMsanParamTlsSize / sizeof(u32)];
+
+SANITIZER_INTERFACE_ATTRIBUTE
+THREADLOCAL u64 __msan_retval_tls[kMsanRetvalTlsSize / sizeof(u64)];
+
+SANITIZER_INTERFACE_ATTRIBUTE
+THREADLOCAL u32 __msan_retval_origin_tls;
+
+SANITIZER_INTERFACE_ATTRIBUTE
+ALIGNED(16) THREADLOCAL u64 __msan_va_arg_tls[kMsanParamTlsSize / sizeof(u64)];
+
+SANITIZER_INTERFACE_ATTRIBUTE
+THREADLOCAL u64 __msan_va_arg_overflow_size_tls;
+
+SANITIZER_INTERFACE_ATTRIBUTE
+THREADLOCAL u32 __msan_origin_tls;
+
+static THREADLOCAL int is_in_symbolizer;
+
+extern "C" SANITIZER_WEAK_ATTRIBUTE const int __msan_track_origins;
+
+int __msan_get_track_origins() {
+  return &__msan_track_origins ? __msan_track_origins : 0;
+}
+
+extern "C" SANITIZER_WEAK_ATTRIBUTE const int __msan_keep_going;
+
+namespace __msan {
+
+void EnterSymbolizer() { ++is_in_symbolizer; }
+void ExitSymbolizer()  { --is_in_symbolizer; }
+bool IsInSymbolizer() { return is_in_symbolizer; }
+
+static Flags msan_flags;
+
+Flags *flags() {
+  return &msan_flags;
+}
+
+int msan_inited = 0;
+bool msan_init_is_running;
+
+int msan_report_count = 0;
+
+// Array of stack origins.
+// FIXME: make it resizable.
+static const uptr kNumStackOriginDescrs = 1024 * 1024;
+static const char *StackOriginDescr[kNumStackOriginDescrs];
+static uptr StackOriginPC[kNumStackOriginDescrs];
+static atomic_uint32_t NumStackOriginDescrs;
+
+void Flags::SetDefaults() {
+#define MSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "msan_flags.inc"
+#undef MSAN_FLAG
+}
+
+// keep_going is an old name for halt_on_error,
+// and it has inverse meaning.
+class FlagHandlerKeepGoing : public FlagHandlerBase {
+  bool *halt_on_error_;
+
+ public:
+  explicit FlagHandlerKeepGoing(bool *halt_on_error)
+      : halt_on_error_(halt_on_error) {}
+  bool Parse(const char *value) final {
+    bool tmp;
+    FlagHandler<bool> h(&tmp);
+    if (!h.Parse(value)) return false;
+    *halt_on_error_ = !tmp;
+    return true;
+  }
+};
+
+static void RegisterMsanFlags(FlagParser *parser, Flags *f) {
+#define MSAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "msan_flags.inc"
+#undef MSAN_FLAG
+
+  FlagHandlerKeepGoing *fh_keep_going = new (FlagParser::Alloc)  // NOLINT
+      FlagHandlerKeepGoing(&f->halt_on_error);
+  parser->RegisterHandler("keep_going", fh_keep_going,
+                          "deprecated, use halt_on_error");
+}
+
+static void InitializeFlags() {
+  SetCommonFlagsDefaults();
+  {
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.external_symbolizer_path = GetEnv("MSAN_SYMBOLIZER_PATH");
+    cf.malloc_context_size = 20;
+    cf.handle_ioctl = true;
+    // FIXME: test and enable.
+    cf.check_printf = false;
+    cf.intercept_tls_get_addr = true;
+    cf.exitcode = 77;
+    OverrideCommonFlags(cf);
+  }
+
+  Flags *f = flags();
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterMsanFlags(&parser, f);
+  RegisterCommonFlags(&parser);
+
+#if MSAN_CONTAINS_UBSAN
+  __ubsan::Flags *uf = __ubsan::flags();
+  uf->SetDefaults();
+
+  FlagParser ubsan_parser;
+  __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
+  RegisterCommonFlags(&ubsan_parser);
+#endif
+
+  // Override from user-specified string.
+  if (__msan_default_options)
+    parser.ParseString(__msan_default_options());
+#if MSAN_CONTAINS_UBSAN
+  const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
+  ubsan_parser.ParseString(ubsan_default_options);
+#endif
+
+  const char *msan_options = GetEnv("MSAN_OPTIONS");
+  parser.ParseString(msan_options);
+#if MSAN_CONTAINS_UBSAN
+  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+#endif
+  VPrintf(1, "MSAN_OPTIONS: %s\n", msan_options ? msan_options : "<empty>");
+
+  SetVerbosity(common_flags()->verbosity);
+
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) parser.PrintFlagDescriptions();
+
+  // Check if deprecated exit_code MSan flag is set.
+  if (f->exit_code != -1) {
+    if (Verbosity())
+      Printf("MSAN_OPTIONS=exit_code is deprecated! "
+             "Please use MSAN_OPTIONS=exitcode instead.\n");
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.exitcode = f->exit_code;
+    OverrideCommonFlags(cf);
+  }
+
+  // Check flag values:
+  if (f->origin_history_size < 0 ||
+      f->origin_history_size > Origin::kMaxDepth) {
+    Printf(
+        "Origin history size invalid: %d. Must be 0 (unlimited) or in [1, %d] "
+        "range.\n",
+        f->origin_history_size, Origin::kMaxDepth);
+    Die();
+  }
+  // Limiting to kStackDepotMaxUseCount / 2 to avoid overflow in
+  // StackDepotHandle::inc_use_count_unsafe.
+  if (f->origin_history_per_stack_limit < 0 ||
+      f->origin_history_per_stack_limit > kStackDepotMaxUseCount / 2) {
+    Printf(
+        "Origin per-stack limit invalid: %d. Must be 0 (unlimited) or in [1, "
+        "%d] range.\n",
+        f->origin_history_per_stack_limit, kStackDepotMaxUseCount / 2);
+    Die();
+  }
+  if (f->store_context_size < 1) f->store_context_size = 1;
+}
+
+void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
+                   bool request_fast_unwind) {
+  MsanThread *t = GetCurrentThread();
+  if (!t || !StackTrace::WillUseFastUnwind(request_fast_unwind)) {
+    // Block reports from our interceptors during _Unwind_Backtrace.
+    SymbolizerScope sym_scope;
+    return stack->Unwind(max_s, pc, bp, nullptr, 0, 0, request_fast_unwind);
+  }
+  stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
+                request_fast_unwind);
+}
+
+void PrintWarning(uptr pc, uptr bp) {
+  PrintWarningWithOrigin(pc, bp, __msan_origin_tls);
+}
+
+void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin) {
+  if (msan_expect_umr) {
+    // Printf("Expected UMR\n");
+    __msan_origin_tls = origin;
+    msan_expected_umr_found = 1;
+    return;
+  }
+
+  ++msan_report_count;
+
+  GET_FATAL_STACK_TRACE_PC_BP(pc, bp);
+
+  u32 report_origin =
+    (__msan_get_track_origins() && Origin::isValidId(origin)) ? origin : 0;
+  ReportUMR(&stack, report_origin);
+
+  if (__msan_get_track_origins() && !Origin::isValidId(origin)) {
+    Printf(
+        "  ORIGIN: invalid (%x). Might be a bug in MemorySanitizer origin "
+        "tracking.\n    This could still be a bug in your code, too!\n",
+        origin);
+  }
+}
+
+void UnpoisonParam(uptr n) {
+  internal_memset(__msan_param_tls, 0, n * sizeof(*__msan_param_tls));
+}
+
+// Backup MSan runtime TLS state.
+// Implementation must be async-signal-safe.
+// Instances of this class may live on the signal handler stack, and data size
+// may be an issue.
+void ScopedThreadLocalStateBackup::Backup() {
+  va_arg_overflow_size_tls = __msan_va_arg_overflow_size_tls;
+}
+
+void ScopedThreadLocalStateBackup::Restore() {
+  // A lame implementation that only keeps essential state and resets the rest.
+  __msan_va_arg_overflow_size_tls = va_arg_overflow_size_tls;
+
+  internal_memset(__msan_param_tls, 0, sizeof(__msan_param_tls));
+  internal_memset(__msan_retval_tls, 0, sizeof(__msan_retval_tls));
+  internal_memset(__msan_va_arg_tls, 0, sizeof(__msan_va_arg_tls));
+
+  if (__msan_get_track_origins()) {
+    internal_memset(&__msan_retval_origin_tls, 0,
+                    sizeof(__msan_retval_origin_tls));
+    internal_memset(__msan_param_origin_tls, 0,
+                    sizeof(__msan_param_origin_tls));
+  }
+}
+
+void UnpoisonThreadLocalState() {
+}
+
+const char *GetStackOriginDescr(u32 id, uptr *pc) {
+  CHECK_LT(id, kNumStackOriginDescrs);
+  if (pc) *pc = StackOriginPC[id];
+  return StackOriginDescr[id];
+}
+
+u32 ChainOrigin(u32 id, StackTrace *stack) {
+  MsanThread *t = GetCurrentThread();
+  if (t && t->InSignalHandler())
+    return id;
+
+  Origin o = Origin::FromRawId(id);
+  stack->tag = StackTrace::TAG_UNKNOWN;
+  Origin chained = Origin::CreateChainedOrigin(o, stack);
+  return chained.raw_id();
+}
+
+} // namespace __msan
+
+// Interface.
+
+using namespace __msan;
+
+#define MSAN_MAYBE_WARNING(type, size)              \
+  void __msan_maybe_warning_##size(type s, u32 o) { \
+    GET_CALLER_PC_BP_SP;                            \
+    (void) sp;                                      \
+    if (UNLIKELY(s)) {                              \
+      PrintWarningWithOrigin(pc, bp, o);            \
+      if (__msan::flags()->halt_on_error) {         \
+        Printf("Exiting\n");                        \
+        Die();                                      \
+      }                                             \
+    }                                               \
+  }
+
+MSAN_MAYBE_WARNING(u8, 1)
+MSAN_MAYBE_WARNING(u16, 2)
+MSAN_MAYBE_WARNING(u32, 4)
+MSAN_MAYBE_WARNING(u64, 8)
+
+#define MSAN_MAYBE_STORE_ORIGIN(type, size)                       \
+  void __msan_maybe_store_origin_##size(type s, void *p, u32 o) { \
+    if (UNLIKELY(s)) {                                            \
+      if (__msan_get_track_origins() > 1) {                       \
+        GET_CALLER_PC_BP_SP;                                      \
+        (void) sp;                                                \
+        GET_STORE_STACK_TRACE_PC_BP(pc, bp);                      \
+        o = ChainOrigin(o, &stack);                               \
+      }                                                           \
+      *(u32 *)MEM_TO_ORIGIN((uptr)p & ~3UL) = o;                  \
+    }                                                             \
+  }
+
+MSAN_MAYBE_STORE_ORIGIN(u8, 1)
+MSAN_MAYBE_STORE_ORIGIN(u16, 2)
+MSAN_MAYBE_STORE_ORIGIN(u32, 4)
+MSAN_MAYBE_STORE_ORIGIN(u64, 8)
+
+void __msan_warning() {
+  GET_CALLER_PC_BP_SP;
+  (void)sp;
+  PrintWarning(pc, bp);
+  if (__msan::flags()->halt_on_error) {
+    if (__msan::flags()->print_stats)
+      ReportStats();
+    Printf("Exiting\n");
+    Die();
+  }
+}
+
+void __msan_warning_noreturn() {
+  GET_CALLER_PC_BP_SP;
+  (void)sp;
+  PrintWarning(pc, bp);
+  if (__msan::flags()->print_stats)
+    ReportStats();
+  Printf("Exiting\n");
+  Die();
+}
+
+void __msan_init() {
+  CHECK(!msan_init_is_running);
+  if (msan_inited) return;
+  msan_init_is_running = 1;
+  SanitizerToolName = "MemorySanitizer";
+
+  InitTlsSize();
+
+  CacheBinaryName();
+  InitializeFlags();
+
+  __sanitizer_set_report_path(common_flags()->log_path);
+
+  InitializeInterceptors();
+  InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
+
+  DisableCoreDumperIfNecessary();
+  if (StackSizeIsUnlimited()) {
+    VPrintf(1, "Unlimited stack, doing reexec\n");
+    // A reasonably large stack size. It is bigger than the usual 8Mb, because,
+    // well, the program could have been run with unlimited stack for a reason.
+    SetStackSizeLimitInBytes(32 * 1024 * 1024);
+    ReExec();
+  }
+
+  __msan_clear_on_return();
+  if (__msan_get_track_origins())
+    VPrintf(1, "msan_track_origins\n");
+  if (!InitShadow(__msan_get_track_origins())) {
+    Printf("FATAL: MemorySanitizer can not mmap the shadow memory.\n");
+    Printf("FATAL: Make sure to compile with -fPIE and to link with -pie.\n");
+    Printf("FATAL: Disabling ASLR is known to cause this error.\n");
+    Printf("FATAL: If running under GDB, try "
+           "'set disable-randomization off'.\n");
+    DumpProcessMap();
+    Die();
+  }
+
+  Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
+
+  InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
+
+  MsanTSDInit(MsanTSDDtor);
+
+  MsanAllocatorInit();
+
+  MsanThread *main_thread = MsanThread::Create(nullptr, nullptr);
+  SetCurrentThread(main_thread);
+  main_thread->ThreadStart();
+
+#if MSAN_CONTAINS_UBSAN
+  __ubsan::InitAsPlugin();
+#endif
+
+  VPrintf(1, "MemorySanitizer init done\n");
+
+  msan_init_is_running = 0;
+  msan_inited = 1;
+}
+
+void __msan_set_keep_going(int keep_going) {
+  flags()->halt_on_error = !keep_going;
+}
+
+void __msan_set_expect_umr(int expect_umr) {
+  if (expect_umr) {
+    msan_expected_umr_found = 0;
+  } else if (!msan_expected_umr_found) {
+    GET_CALLER_PC_BP_SP;
+    (void)sp;
+    GET_FATAL_STACK_TRACE_PC_BP(pc, bp);
+    ReportExpectedUMRNotFound(&stack);
+    Die();
+  }
+  msan_expect_umr = expect_umr;
+}
+
+void __msan_print_shadow(const void *x, uptr size) {
+  if (!MEM_IS_APP(x)) {
+    Printf("Not a valid application address: %p\n", x);
+    return;
+  }
+
+  DescribeMemoryRange(x, size);
+}
+
+void __msan_dump_shadow(const void *x, uptr size) {
+  if (!MEM_IS_APP(x)) {
+    Printf("Not a valid application address: %p\n", x);
+    return;
+  }
+
+  unsigned char *s = (unsigned char*)MEM_TO_SHADOW(x);
+  for (uptr i = 0; i < size; i++) {
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    Printf("%x%x ", s[i] & 0xf, s[i] >> 4);
+#else
+    Printf("%x%x ", s[i] >> 4, s[i] & 0xf);
+#endif
+  }
+  Printf("\n");
+}
+
+sptr __msan_test_shadow(const void *x, uptr size) {
+  if (!MEM_IS_APP(x)) return -1;
+  unsigned char *s = (unsigned char *)MEM_TO_SHADOW((uptr)x);
+  for (uptr i = 0; i < size; ++i)
+    if (s[i])
+      return i;
+  return -1;
+}
+
+void __msan_check_mem_is_initialized(const void *x, uptr size) {
+  if (!__msan::flags()->report_umrs) return;
+  sptr offset = __msan_test_shadow(x, size);
+  if (offset < 0)
+    return;
+
+  GET_CALLER_PC_BP_SP;
+  (void)sp;
+  ReportUMRInsideAddressRange(__func__, x, size, offset);
+  __msan::PrintWarningWithOrigin(pc, bp,
+                                 __msan_get_origin(((const char *)x) + offset));
+  if (__msan::flags()->halt_on_error) {
+    Printf("Exiting\n");
+    Die();
+  }
+}
+
+int __msan_set_poison_in_malloc(int do_poison) {
+  int old = flags()->poison_in_malloc;
+  flags()->poison_in_malloc = do_poison;
+  return old;
+}
+
+int __msan_has_dynamic_component() { return false; }
+
+NOINLINE
+void __msan_clear_on_return() {
+  __msan_param_tls[0] = 0;
+}
+
+void __msan_partial_poison(const void* data, void* shadow, uptr size) {
+  internal_memcpy((void*)MEM_TO_SHADOW((uptr)data), shadow, size);
+}
+
+void __msan_load_unpoisoned(const void *src, uptr size, void *dst) {
+  internal_memcpy(dst, src, size);
+  __msan_unpoison(dst, size);
+}
+
+void __msan_set_origin(const void *a, uptr size, u32 origin) {
+  if (__msan_get_track_origins()) SetOrigin(a, size, origin);
+}
+
+// 'descr' is created at compile time and contains '----' in the beginning.
+// When we see descr for the first time we replace '----' with a uniq id
+// and set the origin to (id | (31-th bit)).
+void __msan_set_alloca_origin(void *a, uptr size, char *descr) {
+  __msan_set_alloca_origin4(a, size, descr, 0);
+}
+
+void __msan_set_alloca_origin4(void *a, uptr size, char *descr, uptr pc) {
+  static const u32 dash = '-';
+  static const u32 first_timer =
+      dash + (dash << 8) + (dash << 16) + (dash << 24);
+  u32 *id_ptr = (u32*)descr;
+  bool print = false;  // internal_strstr(descr + 4, "AllocaTOTest") != 0;
+  u32 id = *id_ptr;
+  if (id == first_timer) {
+    u32 idx = atomic_fetch_add(&NumStackOriginDescrs, 1, memory_order_relaxed);
+    CHECK_LT(idx, kNumStackOriginDescrs);
+    StackOriginDescr[idx] = descr + 4;
+    StackOriginPC[idx] = pc;
+    id = Origin::CreateStackOrigin(idx).raw_id();
+    *id_ptr = id;
+    if (print)
+      Printf("First time: idx=%d id=%d %s %p \n", idx, id, descr + 4, pc);
+  }
+  if (print)
+    Printf("__msan_set_alloca_origin: descr=%s id=%x\n", descr + 4, id);
+  __msan_set_origin(a, size, id);
+}
+
+u32 __msan_chain_origin(u32 id) {
+  GET_CALLER_PC_BP_SP;
+  (void)sp;
+  GET_STORE_STACK_TRACE_PC_BP(pc, bp);
+  return ChainOrigin(id, &stack);
+}
+
+u32 __msan_get_origin(const void *a) {
+  if (!__msan_get_track_origins()) return 0;
+  uptr x = (uptr)a;
+  uptr aligned = x & ~3ULL;
+  uptr origin_ptr = MEM_TO_ORIGIN(aligned);
+  return *(u32*)origin_ptr;
+}
+
+int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id) {
+  Origin o = Origin::FromRawId(this_id);
+  while (o.raw_id() != prev_id && o.isChainedOrigin())
+    o = o.getNextChainedOrigin(nullptr);
+  return o.raw_id() == prev_id;
+}
+
+u32 __msan_get_umr_origin() {
+  return __msan_origin_tls;
+}
+
+u16 __sanitizer_unaligned_load16(const uu16 *p) {
+  __msan_retval_tls[0] = *(uu16 *)MEM_TO_SHADOW((uptr)p);
+  if (__msan_get_track_origins())
+    __msan_retval_origin_tls = GetOriginIfPoisoned((uptr)p, sizeof(*p));
+  return *p;
+}
+u32 __sanitizer_unaligned_load32(const uu32 *p) {
+  __msan_retval_tls[0] = *(uu32 *)MEM_TO_SHADOW((uptr)p);
+  if (__msan_get_track_origins())
+    __msan_retval_origin_tls = GetOriginIfPoisoned((uptr)p, sizeof(*p));
+  return *p;
+}
+u64 __sanitizer_unaligned_load64(const uu64 *p) {
+  __msan_retval_tls[0] = *(uu64 *)MEM_TO_SHADOW((uptr)p);
+  if (__msan_get_track_origins())
+    __msan_retval_origin_tls = GetOriginIfPoisoned((uptr)p, sizeof(*p));
+  return *p;
+}
+void __sanitizer_unaligned_store16(uu16 *p, u16 x) {
+  u16 s = __msan_param_tls[1];
+  *(uu16 *)MEM_TO_SHADOW((uptr)p) = s;
+  if (s && __msan_get_track_origins())
+    if (uu32 o = __msan_param_origin_tls[2])
+      SetOriginIfPoisoned((uptr)p, (uptr)&s, sizeof(s), o);
+  *p = x;
+}
+void __sanitizer_unaligned_store32(uu32 *p, u32 x) {
+  u32 s = __msan_param_tls[1];
+  *(uu32 *)MEM_TO_SHADOW((uptr)p) = s;
+  if (s && __msan_get_track_origins())
+    if (uu32 o = __msan_param_origin_tls[2])
+      SetOriginIfPoisoned((uptr)p, (uptr)&s, sizeof(s), o);
+  *p = x;
+}
+void __sanitizer_unaligned_store64(uu64 *p, u64 x) {
+  u64 s = __msan_param_tls[1];
+  *(uu64 *)MEM_TO_SHADOW((uptr)p) = s;
+  if (s && __msan_get_track_origins())
+    if (uu32 o = __msan_param_origin_tls[2])
+      SetOriginIfPoisoned((uptr)p, (uptr)&s, sizeof(s), o);
+  *p = x;
+}
+
+void __msan_set_death_callback(void (*callback)(void)) {
+  SetUserDieCallback(callback);
+}
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+const char* __msan_default_options() { return ""; }
+}  // extern "C"
+#endif
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_print_stack_trace() {
+  GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME());
+  stack.Print();
+}
+} // extern "C"
diff --git a/compiler-rt/lib/msan/msan.h b/compiler-rt/lib/msan/msan.h
new file mode 100644
index 0000000..2079a59
--- /dev/null
+++ b/compiler-rt/lib/msan/msan.h
@@ -0,0 +1,317 @@
+//===-- msan.h --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Private MSan header.
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_H
+#define MSAN_H
+
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "msan_interface_internal.h"
+#include "msan_flags.h"
+#include "ubsan/ubsan_platform.h"
+
+#ifndef MSAN_REPLACE_OPERATORS_NEW_AND_DELETE
+# define MSAN_REPLACE_OPERATORS_NEW_AND_DELETE 1
+#endif
+
+#ifndef MSAN_CONTAINS_UBSAN
+# define MSAN_CONTAINS_UBSAN CAN_SANITIZE_UB
+#endif
+
+struct MappingDesc {
+  uptr start;
+  uptr end;
+  enum Type {
+    INVALID, APP, SHADOW, ORIGIN
+  } type;
+  const char *name;
+};
+
+
+#if SANITIZER_LINUX && defined(__mips64)
+
+// Everything is above 0x00e000000000.
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x00a000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x00a000000000ULL, 0x00c000000000ULL, MappingDesc::SHADOW, "shadow"},
+    {0x00c000000000ULL, 0x00e000000000ULL, MappingDesc::ORIGIN, "origin"},
+    {0x00e000000000ULL, 0x010000000000ULL, MappingDesc::APP, "app"}};
+
+#define MEM_TO_SHADOW(mem) (((uptr)(mem)) & ~0x4000000000ULL)
+#define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x002000000000)
+
+#elif SANITIZER_LINUX && defined(__aarch64__)
+
+// The mapping describes both 39-bits and 42-bits.  AArch64 maps:
+// - 0x00000000000-0x00010000000: 39/42-bits program own segments
+// - 0x05500000000-0x05600000000: 39-bits PIE program segments
+// - 0x07f80000000-0x07fffffffff: 39-bits libraries segments
+// - 0x2aa00000000-0x2ab00000000: 42-bits PIE program segments
+// - 0x3ff00000000-0x3ffffffffff: 42-bits libraries segments
+// It is fragmented in multiples segments to increase the memory available
+// on 42-bits (12.21% of total VMA available for 42-bits and 13.28 for
+// 39 bits).
+const MappingDesc kMemoryLayout[] = {
+    {0x00000000000ULL, 0x01000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x01000000000ULL, 0x02000000000ULL, MappingDesc::SHADOW, "shadow-2"},
+    {0x02000000000ULL, 0x03000000000ULL, MappingDesc::ORIGIN, "origin-2"},
+    {0x03000000000ULL, 0x04000000000ULL, MappingDesc::SHADOW, "shadow-1"},
+    {0x04000000000ULL, 0x05000000000ULL, MappingDesc::ORIGIN, "origin-1"},
+    {0x05000000000ULL, 0x06000000000ULL, MappingDesc::APP, "app-1"},
+    {0x06000000000ULL, 0x07000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x07000000000ULL, 0x08000000000ULL, MappingDesc::APP, "app-2"},
+    {0x08000000000ULL, 0x09000000000ULL, MappingDesc::INVALID, "invalid"},
+    // The mappings below are used only for 42-bits VMA.
+    {0x09000000000ULL, 0x0A000000000ULL, MappingDesc::SHADOW, "shadow-3"},
+    {0x0A000000000ULL, 0x0B000000000ULL, MappingDesc::ORIGIN, "origin-3"},
+    {0x0B000000000ULL, 0x0F000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x0F000000000ULL, 0x10000000000ULL, MappingDesc::APP, "app-3"},
+    {0x10000000000ULL, 0x11000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x11000000000ULL, 0x12000000000ULL, MappingDesc::APP, "app-4"},
+    {0x12000000000ULL, 0x17000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x17000000000ULL, 0x18000000000ULL, MappingDesc::SHADOW, "shadow-4"},
+    {0x18000000000ULL, 0x19000000000ULL, MappingDesc::ORIGIN, "origin-4"},
+    {0x19000000000ULL, 0x20000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x20000000000ULL, 0x21000000000ULL, MappingDesc::APP, "app-5"},
+    {0x21000000000ULL, 0x26000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x26000000000ULL, 0x27000000000ULL, MappingDesc::SHADOW, "shadow-5"},
+    {0x27000000000ULL, 0x28000000000ULL, MappingDesc::ORIGIN, "origin-5"},
+    {0x28000000000ULL, 0x29000000000ULL, MappingDesc::SHADOW, "shadow-7"},
+    {0x29000000000ULL, 0x2A000000000ULL, MappingDesc::ORIGIN, "origin-7"},
+    {0x2A000000000ULL, 0x2B000000000ULL, MappingDesc::APP, "app-6"},
+    {0x2B000000000ULL, 0x2C000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x2C000000000ULL, 0x2D000000000ULL, MappingDesc::SHADOW, "shadow-6"},
+    {0x2D000000000ULL, 0x2E000000000ULL, MappingDesc::ORIGIN, "origin-6"},
+    {0x2E000000000ULL, 0x2F000000000ULL, MappingDesc::APP, "app-7"},
+    {0x2F000000000ULL, 0x39000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x39000000000ULL, 0x3A000000000ULL, MappingDesc::SHADOW, "shadow-9"},
+    {0x3A000000000ULL, 0x3B000000000ULL, MappingDesc::ORIGIN, "origin-9"},
+    {0x3B000000000ULL, 0x3C000000000ULL, MappingDesc::APP, "app-8"},
+    {0x3C000000000ULL, 0x3D000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x3D000000000ULL, 0x3E000000000ULL, MappingDesc::SHADOW, "shadow-8"},
+    {0x3E000000000ULL, 0x3F000000000ULL, MappingDesc::ORIGIN, "origin-8"},
+    {0x3F000000000ULL, 0x40000000000ULL, MappingDesc::APP, "app-9"},
+};
+# define MEM_TO_SHADOW(mem) ((uptr)mem ^ 0x6000000000ULL)
+# define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x1000000000ULL)
+
+#elif SANITIZER_LINUX && defined(__powerpc64__)
+
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x000100000000ULL, MappingDesc::APP, "low memory"},
+    {0x000100000000ULL, 0x080000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x080000000000ULL, 0x180100000000ULL, MappingDesc::SHADOW, "shadow"},
+    {0x180100000000ULL, 0x1C0000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x1C0000000000ULL, 0x2C0100000000ULL, MappingDesc::ORIGIN, "origin"},
+    {0x2C0100000000ULL, 0x300000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x300000000000ULL, 0x400000000000ULL, MappingDesc::APP, "high memory"}};
+
+// Maps low and high app ranges to contiguous space with zero base:
+//   Low:  0000 0000 0000 - 0000 ffff ffff  ->  1000 0000 0000 - 1000 ffff ffff
+//   High: 3000 0000 0000 - 3fff ffff ffff  ->  0000 0000 0000 - 0fff ffff ffff
+#define LINEARIZE_MEM(mem) \
+  (((uptr)(mem) & ~0x200000000000ULL) ^ 0x100000000000ULL)
+#define MEM_TO_SHADOW(mem) (LINEARIZE_MEM((mem)) + 0x080000000000ULL)
+#define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x140000000000ULL)
+
+#elif SANITIZER_FREEBSD && SANITIZER_WORDSIZE == 64
+
+// Low memory: main binary, MAP_32BIT mappings and modules
+// High memory: heap, modules and main thread stack
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "low memory"},
+    {0x010000000000ULL, 0x100000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x100000000000ULL, 0x310000000000ULL, MappingDesc::SHADOW, "shadow"},
+    {0x310000000000ULL, 0x380000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x380000000000ULL, 0x590000000000ULL, MappingDesc::ORIGIN, "origin"},
+    {0x590000000000ULL, 0x600000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x600000000000ULL, 0x800000000000ULL, MappingDesc::APP, "high memory"}};
+
+// Maps low and high app ranges to contiguous space with zero base:
+//   Low:  0000 0000 0000 - 00ff ffff ffff  ->  2000 0000 0000 - 20ff ffff ffff
+//   High: 6000 0000 0000 - 7fff ffff ffff  ->  0000 0000 0000 - 1fff ffff ffff
+#define LINEARIZE_MEM(mem) \
+  (((uptr)(mem) & ~0xc00000000000ULL) ^ 0x200000000000ULL)
+#define MEM_TO_SHADOW(mem) (LINEARIZE_MEM((mem)) + 0x100000000000ULL)
+#define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x280000000000)
+
+#elif SANITIZER_LINUX && SANITIZER_WORDSIZE == 64
+
+#ifdef MSAN_LINUX_X86_64_OLD_MAPPING
+// Requries PIE binary and ASLR enabled.
+// Main thread stack and DSOs at 0x7f0000000000 (sometimes 0x7e0000000000).
+// Heap at 0x600000000000.
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x200000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x200000000000ULL, 0x400000000000ULL, MappingDesc::SHADOW, "shadow"},
+    {0x400000000000ULL, 0x600000000000ULL, MappingDesc::ORIGIN, "origin"},
+    {0x600000000000ULL, 0x800000000000ULL, MappingDesc::APP, "app"}};
+
+#define MEM_TO_SHADOW(mem) (((uptr)(mem)) & ~0x400000000000ULL)
+#define SHADOW_TO_ORIGIN(mem) (((uptr)(mem)) + 0x200000000000ULL)
+#else  // MSAN_LINUX_X86_64_OLD_MAPPING
+// All of the following configurations are supported.
+// ASLR disabled: main executable and DSOs at 0x555550000000
+// PIE and ASLR: main executable and DSOs at 0x7f0000000000
+// non-PIE: main executable below 0x100000000, DSOs at 0x7f0000000000
+// Heap at 0x700000000000.
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "app-1"},
+    {0x010000000000ULL, 0x100000000000ULL, MappingDesc::SHADOW, "shadow-2"},
+    {0x100000000000ULL, 0x110000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x110000000000ULL, 0x200000000000ULL, MappingDesc::ORIGIN, "origin-2"},
+    {0x200000000000ULL, 0x300000000000ULL, MappingDesc::SHADOW, "shadow-3"},
+    {0x300000000000ULL, 0x400000000000ULL, MappingDesc::ORIGIN, "origin-3"},
+    {0x400000000000ULL, 0x500000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x500000000000ULL, 0x510000000000ULL, MappingDesc::SHADOW, "shadow-1"},
+    {0x510000000000ULL, 0x600000000000ULL, MappingDesc::APP, "app-2"},
+    {0x600000000000ULL, 0x610000000000ULL, MappingDesc::ORIGIN, "origin-1"},
+    {0x610000000000ULL, 0x700000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x700000000000ULL, 0x800000000000ULL, MappingDesc::APP, "app-3"}};
+#define MEM_TO_SHADOW(mem) (((uptr)(mem)) ^ 0x500000000000ULL)
+#define SHADOW_TO_ORIGIN(mem) (((uptr)(mem)) + 0x100000000000ULL)
+#endif  // MSAN_LINUX_X86_64_OLD_MAPPING
+
+#else
+#error "Unsupported platform"
+#endif
+
+const uptr kMemoryLayoutSize = sizeof(kMemoryLayout) / sizeof(kMemoryLayout[0]);
+
+#define MEM_TO_ORIGIN(mem) (SHADOW_TO_ORIGIN(MEM_TO_SHADOW((mem))))
+
+#ifndef __clang__
+__attribute__((optimize("unroll-loops")))
+#endif
+inline bool addr_is_type(uptr addr, MappingDesc::Type mapping_type) {
+// It is critical for performance that this loop is unrolled (because then it is
+// simplified into just a few constant comparisons).
+#ifdef __clang__
+#pragma unroll
+#endif
+  for (unsigned i = 0; i < kMemoryLayoutSize; ++i)
+    if (kMemoryLayout[i].type == mapping_type &&
+        addr >= kMemoryLayout[i].start && addr < kMemoryLayout[i].end)
+      return true;
+  return false;
+}
+
+#define MEM_IS_APP(mem) addr_is_type((uptr)(mem), MappingDesc::APP)
+#define MEM_IS_SHADOW(mem) addr_is_type((uptr)(mem), MappingDesc::SHADOW)
+#define MEM_IS_ORIGIN(mem) addr_is_type((uptr)(mem), MappingDesc::ORIGIN)
+
+// These constants must be kept in sync with the ones in MemorySanitizer.cc.
+const int kMsanParamTlsSize = 800;
+const int kMsanRetvalTlsSize = 800;
+
+namespace __msan {
+extern int msan_inited;
+extern bool msan_init_is_running;
+extern int msan_report_count;
+
+bool ProtectRange(uptr beg, uptr end);
+bool InitShadow(bool init_origins);
+char *GetProcSelfMaps();
+void InitializeInterceptors();
+
+void MsanAllocatorInit();
+void MsanAllocatorThreadFinish();
+void *MsanCalloc(StackTrace *stack, uptr nmemb, uptr size);
+void *MsanReallocate(StackTrace *stack, void *oldp, uptr size,
+                     uptr alignment, bool zeroise);
+void MsanDeallocate(StackTrace *stack, void *ptr);
+void InstallTrapHandler();
+void InstallAtExitHandler();
+
+const char *GetStackOriginDescr(u32 id, uptr *pc);
+
+void EnterSymbolizer();
+void ExitSymbolizer();
+bool IsInSymbolizer();
+
+struct SymbolizerScope {
+  SymbolizerScope() { EnterSymbolizer(); }
+  ~SymbolizerScope() { ExitSymbolizer(); }
+};
+
+void PrintWarning(uptr pc, uptr bp);
+void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin);
+
+void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
+                   bool request_fast_unwind);
+
+void ReportUMR(StackTrace *stack, u32 origin);
+void ReportExpectedUMRNotFound(StackTrace *stack);
+void ReportStats();
+void ReportAtExitStatistics();
+void DescribeMemoryRange(const void *x, uptr size);
+void ReportUMRInsideAddressRange(const char *what, const void *start, uptr size,
+                                 uptr offset);
+
+// Unpoison first n function arguments.
+void UnpoisonParam(uptr n);
+void UnpoisonThreadLocalState();
+
+// Returns a "chained" origin id, pointing to the given stack trace followed by
+// the previous origin id.
+u32 ChainOrigin(u32 id, StackTrace *stack);
+
+const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
+
+#define GET_MALLOC_STACK_TRACE                                                 \
+  BufferedStackTrace stack;                                                    \
+  if (__msan_get_track_origins() && msan_inited)                               \
+  GetStackTrace(&stack, common_flags()->malloc_context_size,                   \
+                StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),               \
+                common_flags()->fast_unwind_on_malloc)
+
+#define GET_STORE_STACK_TRACE_PC_BP(pc, bp)                                    \
+  BufferedStackTrace stack;                                                    \
+  if (__msan_get_track_origins() > 1 && msan_inited)                           \
+  GetStackTrace(&stack, flags()->store_context_size, pc, bp,                   \
+                common_flags()->fast_unwind_on_malloc)
+
+#define GET_FATAL_STACK_TRACE_PC_BP(pc, bp)                                    \
+  BufferedStackTrace stack;                                                    \
+  if (msan_inited)                                                             \
+  GetStackTrace(&stack, kStackTraceMax, pc, bp,                                \
+                common_flags()->fast_unwind_on_fatal)
+
+#define GET_STORE_STACK_TRACE \
+  GET_STORE_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
+
+class ScopedThreadLocalStateBackup {
+ public:
+  ScopedThreadLocalStateBackup() { Backup(); }
+  ~ScopedThreadLocalStateBackup() { Restore(); }
+  void Backup();
+  void Restore();
+ private:
+  u64 va_arg_overflow_size_tls;
+};
+
+void MsanTSDInit(void (*destructor)(void *tsd));
+void *MsanTSDGet();
+void MsanTSDSet(void *tsd);
+void MsanTSDDtor(void *tsd);
+
+}  // namespace __msan
+
+#define MSAN_MALLOC_HOOK(ptr, size) \
+  if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(ptr, size)
+#define MSAN_FREE_HOOK(ptr) \
+  if (&__sanitizer_free_hook) __sanitizer_free_hook(ptr)
+
+#endif  // MSAN_H
diff --git a/compiler-rt/lib/msan/msan.syms.extra b/compiler-rt/lib/msan/msan.syms.extra
new file mode 100644
index 0000000..950e6f4
--- /dev/null
+++ b/compiler-rt/lib/msan/msan.syms.extra
@@ -0,0 +1,2 @@
+__msan_*
+__ubsan_*
diff --git a/compiler-rt/lib/msan/msan_allocator.cc b/compiler-rt/lib/msan/msan_allocator.cc
new file mode 100644
index 0000000..b7d3947
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_allocator.cc
@@ -0,0 +1,244 @@
+//===-- msan_allocator.cc --------------------------- ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// MemorySanitizer allocator.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_allocator_interface.h"
+#include "msan.h"
+#include "msan_allocator.h"
+#include "msan_origin.h"
+#include "msan_thread.h"
+#include "msan_poisoning.h"
+
+namespace __msan {
+
+struct Metadata {
+  uptr requested_size;
+};
+
+struct MsanMapUnmapCallback {
+  void OnMap(uptr p, uptr size) const {}
+  void OnUnmap(uptr p, uptr size) const {
+    __msan_unpoison((void *)p, size);
+
+    // We are about to unmap a chunk of user memory.
+    // Mark the corresponding shadow memory as not needed.
+    FlushUnneededShadowMemory(MEM_TO_SHADOW(p), size);
+    if (__msan_get_track_origins())
+      FlushUnneededShadowMemory(MEM_TO_ORIGIN(p), size);
+  }
+};
+
+#if defined(__mips64)
+  static const uptr kMaxAllowedMallocSize = 2UL << 30;
+  static const uptr kRegionSizeLog = 20;
+  static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+  typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+  typedef CompactSizeClassMap SizeClassMap;
+
+  typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, sizeof(Metadata),
+                               SizeClassMap, kRegionSizeLog, ByteMap,
+                               MsanMapUnmapCallback> PrimaryAllocator;
+
+#elif defined(__x86_64__)
+#if SANITIZER_LINUX && !defined(MSAN_LINUX_X86_64_OLD_MAPPING)
+  static const uptr kAllocatorSpace = 0x700000000000ULL;
+#else
+  static const uptr kAllocatorSpace = 0x600000000000ULL;
+#endif
+  static const uptr kAllocatorSize = 0x80000000000; // 8T.
+  static const uptr kMetadataSize  = sizeof(Metadata);
+  static const uptr kMaxAllowedMallocSize = 8UL << 30;
+
+  typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, kMetadataSize,
+                             DefaultSizeClassMap,
+                             MsanMapUnmapCallback> PrimaryAllocator;
+
+#elif defined(__powerpc64__)
+  static const uptr kAllocatorSpace = 0x300000000000;
+  static const uptr kAllocatorSize  = 0x020000000000;  // 2T
+  static const uptr kMetadataSize  = sizeof(Metadata);
+  static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
+
+  typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, kMetadataSize,
+                             DefaultSizeClassMap,
+                             MsanMapUnmapCallback> PrimaryAllocator;
+#elif defined(__aarch64__)
+  static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
+  static const uptr kRegionSizeLog = 20;
+  static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+  typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+  typedef CompactSizeClassMap SizeClassMap;
+
+  typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, sizeof(Metadata),
+                               SizeClassMap, kRegionSizeLog, ByteMap,
+                               MsanMapUnmapCallback> PrimaryAllocator;
+#endif
+typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;
+typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
+                          SecondaryAllocator> Allocator;
+
+static Allocator allocator;
+static AllocatorCache fallback_allocator_cache;
+static SpinMutex fallback_mutex;
+
+void MsanAllocatorInit() {
+  allocator.Init(common_flags()->allocator_may_return_null);
+}
+
+AllocatorCache *GetAllocatorCache(MsanThreadLocalMallocStorage *ms) {
+  CHECK(ms);
+  CHECK_LE(sizeof(AllocatorCache), sizeof(ms->allocator_cache));
+  return reinterpret_cast<AllocatorCache *>(ms->allocator_cache);
+}
+
+void MsanThreadLocalMallocStorage::CommitBack() {
+  allocator.SwallowCache(GetAllocatorCache(this));
+}
+
+static void *MsanAllocate(StackTrace *stack, uptr size, uptr alignment,
+                          bool zeroise) {
+  if (size > kMaxAllowedMallocSize) {
+    Report("WARNING: MemorySanitizer failed to allocate %p bytes\n",
+           (void *)size);
+    return allocator.ReturnNullOrDie();
+  }
+  MsanThread *t = GetCurrentThread();
+  void *allocated;
+  if (t) {
+    AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
+    allocated = allocator.Allocate(cache, size, alignment, false);
+  } else {
+    SpinMutexLock l(&fallback_mutex);
+    AllocatorCache *cache = &fallback_allocator_cache;
+    allocated = allocator.Allocate(cache, size, alignment, false);
+  }
+  Metadata *meta =
+      reinterpret_cast<Metadata *>(allocator.GetMetaData(allocated));
+  meta->requested_size = size;
+  if (zeroise) {
+    __msan_clear_and_unpoison(allocated, size);
+  } else if (flags()->poison_in_malloc) {
+    __msan_poison(allocated, size);
+    if (__msan_get_track_origins()) {
+      stack->tag = StackTrace::TAG_ALLOC;
+      Origin o = Origin::CreateHeapOrigin(stack);
+      __msan_set_origin(allocated, size, o.raw_id());
+    }
+  }
+  MSAN_MALLOC_HOOK(allocated, size);
+  return allocated;
+}
+
+void MsanDeallocate(StackTrace *stack, void *p) {
+  CHECK(p);
+  MSAN_FREE_HOOK(p);
+  Metadata *meta = reinterpret_cast<Metadata *>(allocator.GetMetaData(p));
+  uptr size = meta->requested_size;
+  meta->requested_size = 0;
+  // This memory will not be reused by anyone else, so we are free to keep it
+  // poisoned.
+  if (flags()->poison_in_free) {
+    __msan_poison(p, size);
+    if (__msan_get_track_origins()) {
+      stack->tag = StackTrace::TAG_DEALLOC;
+      Origin o = Origin::CreateHeapOrigin(stack);
+      __msan_set_origin(p, size, o.raw_id());
+    }
+  }
+  MsanThread *t = GetCurrentThread();
+  if (t) {
+    AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
+    allocator.Deallocate(cache, p);
+  } else {
+    SpinMutexLock l(&fallback_mutex);
+    AllocatorCache *cache = &fallback_allocator_cache;
+    allocator.Deallocate(cache, p);
+  }
+}
+
+void *MsanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
+  if (CallocShouldReturnNullDueToOverflow(size, nmemb))
+    return allocator.ReturnNullOrDie();
+  return MsanReallocate(stack, nullptr, nmemb * size, sizeof(u64), true);
+}
+
+void *MsanReallocate(StackTrace *stack, void *old_p, uptr new_size,
+                     uptr alignment, bool zeroise) {
+  if (!old_p)
+    return MsanAllocate(stack, new_size, alignment, zeroise);
+  if (!new_size) {
+    MsanDeallocate(stack, old_p);
+    return nullptr;
+  }
+  Metadata *meta = reinterpret_cast<Metadata*>(allocator.GetMetaData(old_p));
+  uptr old_size = meta->requested_size;
+  uptr actually_allocated_size = allocator.GetActuallyAllocatedSize(old_p);
+  if (new_size <= actually_allocated_size) {
+    // We are not reallocating here.
+    meta->requested_size = new_size;
+    if (new_size > old_size) {
+      if (zeroise) {
+        __msan_clear_and_unpoison((char *)old_p + old_size,
+                                  new_size - old_size);
+      } else if (flags()->poison_in_malloc) {
+        stack->tag = StackTrace::TAG_ALLOC;
+        PoisonMemory((char *)old_p + old_size, new_size - old_size, stack);
+      }
+    }
+    return old_p;
+  }
+  uptr memcpy_size = Min(new_size, old_size);
+  void *new_p = MsanAllocate(stack, new_size, alignment, zeroise);
+  // Printf("realloc: old_size %zd new_size %zd\n", old_size, new_size);
+  if (new_p) {
+    CopyMemory(new_p, old_p, memcpy_size, stack);
+    MsanDeallocate(stack, old_p);
+  }
+  return new_p;
+}
+
+static uptr AllocationSize(const void *p) {
+  if (!p) return 0;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (beg != p) return 0;
+  Metadata *b = (Metadata *)allocator.GetMetaData(p);
+  return b->requested_size;
+}
+
+} // namespace __msan
+
+using namespace __msan;
+
+uptr __sanitizer_get_current_allocated_bytes() {
+  uptr stats[AllocatorStatCount];
+  allocator.GetStats(stats);
+  return stats[AllocatorStatAllocated];
+}
+
+uptr __sanitizer_get_heap_size() {
+  uptr stats[AllocatorStatCount];
+  allocator.GetStats(stats);
+  return stats[AllocatorStatMapped];
+}
+
+uptr __sanitizer_get_free_bytes() { return 1; }
+
+uptr __sanitizer_get_unmapped_bytes() { return 1; }
+
+uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
+
+int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
+
+uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }
diff --git a/compiler-rt/lib/msan/msan_allocator.h b/compiler-rt/lib/msan/msan_allocator.h
new file mode 100644
index 0000000..407942e
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_allocator.h
@@ -0,0 +1,33 @@
+//===-- msan_allocator.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_ALLOCATOR_H
+#define MSAN_ALLOCATOR_H
+
+#include "sanitizer_common/sanitizer_common.h"
+
+namespace __msan {
+
+struct MsanThreadLocalMallocStorage {
+  uptr quarantine_cache[16];
+  // Allocator cache contains atomic_uint64_t which must be 8-byte aligned.
+  ALIGNED(8) uptr allocator_cache[96 * (512 * 8 + 16)];  // Opaque.
+  void CommitBack();
+
+ private:
+  // These objects are allocated via mmap() and are zero-initialized.
+  MsanThreadLocalMallocStorage() {}
+};
+
+} // namespace __msan
+#endif // MSAN_ALLOCATOR_H
diff --git a/compiler-rt/lib/msan/msan_blacklist.txt b/compiler-rt/lib/msan/msan_blacklist.txt
new file mode 100644
index 0000000..44a5680
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_blacklist.txt
@@ -0,0 +1,7 @@
+# Blacklist for MemorySanitizer. Turns off instrumentation of particular
+# functions or sources. Use with care. You may set location of blacklist
+# at compile-time using -fsanitize-blacklist=<path> flag.
+
+# Example usage:
+# fun:*bad_function_name*
+# src:file_with_tricky_code.cc
diff --git a/compiler-rt/lib/msan/msan_chained_origin_depot.cc b/compiler-rt/lib/msan/msan_chained_origin_depot.cc
new file mode 100644
index 0000000..e2796fd
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_chained_origin_depot.cc
@@ -0,0 +1,132 @@
+//===-- msan_chained_origin_depot.cc -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// A storage for chained origins.
+//===----------------------------------------------------------------------===//
+
+#include "msan_chained_origin_depot.h"
+
+#include "sanitizer_common/sanitizer_stackdepotbase.h"
+
+namespace __msan {
+
+struct ChainedOriginDepotDesc {
+  u32 here_id;
+  u32 prev_id;
+};
+
+struct ChainedOriginDepotNode {
+  ChainedOriginDepotNode *link;
+  u32 id;
+  u32 here_id;
+  u32 prev_id;
+
+  typedef ChainedOriginDepotDesc args_type;
+
+  bool eq(u32 hash, const args_type &args) const {
+    return here_id == args.here_id && prev_id == args.prev_id;
+  }
+
+  static uptr storage_size(const args_type &args) {
+    return sizeof(ChainedOriginDepotNode);
+  }
+
+  /* This is murmur2 hash for the 64->32 bit case.
+     It does not behave all that well because the keys have a very biased
+     distribution (I've seen 7-element buckets with the table only 14% full).
+
+     here_id is built of
+     * (1 bits) Reserved, zero.
+     * (8 bits) Part id = bits 13..20 of the hash value of here_id's key.
+     * (23 bits) Sequential number (each part has each own sequence).
+
+     prev_id has either the same distribution as here_id (but with 3:8:21)
+     split, or one of two reserved values (-1) or (-2). Either case can
+     dominate depending on the workload.
+  */
+  static u32 hash(const args_type &args) {
+    const u32 m = 0x5bd1e995;
+    const u32 seed = 0x9747b28c;
+    const u32 r = 24;
+    u32 h = seed;
+    u32 k = args.here_id;
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+    h *= m;
+    h ^= k;
+
+    k = args.prev_id;
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+    h *= m;
+    h ^= k;
+
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+    return h;
+  }
+  static bool is_valid(const args_type &args) { return true; }
+  void store(const args_type &args, u32 other_hash) {
+    here_id = args.here_id;
+    prev_id = args.prev_id;
+  }
+
+  args_type load() const {
+    args_type ret = {here_id, prev_id};
+    return ret;
+  }
+
+  struct Handle {
+    ChainedOriginDepotNode *node_;
+    Handle() : node_(nullptr) {}
+    explicit Handle(ChainedOriginDepotNode *node) : node_(node) {}
+    bool valid() { return node_; }
+    u32 id() { return node_->id; }
+    int here_id() { return node_->here_id; }
+    int prev_id() { return node_->prev_id; }
+  };
+
+  Handle get_handle() { return Handle(this); }
+
+  typedef Handle handle_type;
+};
+
+static StackDepotBase<ChainedOriginDepotNode, 4, 20> chainedOriginDepot;
+
+StackDepotStats *ChainedOriginDepotGetStats() {
+  return chainedOriginDepot.GetStats();
+}
+
+bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id) {
+  ChainedOriginDepotDesc desc = {here_id, prev_id};
+  bool inserted;
+  ChainedOriginDepotNode::Handle h = chainedOriginDepot.Put(desc, &inserted);
+  *new_id = h.valid() ? h.id() : 0;
+  return inserted;
+}
+
+// Retrieves a stored stack trace by the id.
+u32 ChainedOriginDepotGet(u32 id, u32 *other) {
+  ChainedOriginDepotDesc desc = chainedOriginDepot.Get(id);
+  *other = desc.prev_id;
+  return desc.here_id;
+}
+
+void ChainedOriginDepotLockAll() {
+  chainedOriginDepot.LockAll();
+}
+
+void ChainedOriginDepotUnlockAll() {
+  chainedOriginDepot.UnlockAll();
+}
+
+} // namespace __msan
diff --git a/compiler-rt/lib/msan/msan_chained_origin_depot.h b/compiler-rt/lib/msan/msan_chained_origin_depot.h
new file mode 100644
index 0000000..f7a71ce
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_chained_origin_depot.h
@@ -0,0 +1,29 @@
+//===-- msan_chained_origin_depot.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// A storage for chained origins.
+//===----------------------------------------------------------------------===//
+#ifndef MSAN_CHAINED_ORIGIN_DEPOT_H
+#define MSAN_CHAINED_ORIGIN_DEPOT_H
+
+#include "sanitizer_common/sanitizer_common.h"
+
+namespace __msan {
+
+StackDepotStats *ChainedOriginDepotGetStats();
+bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id);
+// Retrieves a stored stack trace by the id.
+u32 ChainedOriginDepotGet(u32 id, u32 *other);
+
+void ChainedOriginDepotLockAll();
+void ChainedOriginDepotUnlockAll();
+
+}  // namespace __msan
+
+#endif  // MSAN_CHAINED_ORIGIN_DEPOT_H
diff --git a/compiler-rt/lib/msan/msan_flags.h b/compiler-rt/lib/msan/msan_flags.h
new file mode 100644
index 0000000..4fc6d17
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_flags.h
@@ -0,0 +1,30 @@
+//===-- msan_flags.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MSAN_FLAGS_H
+#define MSAN_FLAGS_H
+
+namespace __msan {
+
+struct Flags {
+#define MSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "msan_flags.inc"
+#undef MSAN_FLAG
+
+  void SetDefaults();
+};
+
+Flags *flags();
+
+}  // namespace __msan
+
+#endif  // MSAN_FLAGS_H
diff --git a/compiler-rt/lib/msan/msan_flags.inc b/compiler-rt/lib/msan/msan_flags.inc
new file mode 100644
index 0000000..a7ff6c5
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_flags.inc
@@ -0,0 +1,35 @@
+//===-- msan_flags.inc ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// MSan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MSAN_FLAG
+# error "Define MSAN_FLAG prior to including this file!"
+#endif
+
+// MSAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+MSAN_FLAG(int, exit_code, -1,
+          "DEPRECATED. Use exitcode from common flags instead.")
+MSAN_FLAG(int, origin_history_size, Origin::kMaxDepth, "")
+MSAN_FLAG(int, origin_history_per_stack_limit, 20000, "")
+MSAN_FLAG(bool, poison_heap_with_zeroes, false, "")
+MSAN_FLAG(bool, poison_stack_with_zeroes, false, "")
+MSAN_FLAG(bool, poison_in_malloc, true, "")
+MSAN_FLAG(bool, poison_in_free, true, "")
+MSAN_FLAG(bool, poison_in_dtor, false, "")
+MSAN_FLAG(bool, report_umrs, true, "")
+MSAN_FLAG(bool, wrap_signals, true, "")
+MSAN_FLAG(bool, print_stats, false, "")
+MSAN_FLAG(bool, halt_on_error, !&__msan_keep_going, "")
+MSAN_FLAG(bool, atexit, false, "")
+MSAN_FLAG(int, store_context_size, 20,
+          "Like malloc_context_size, but for uninit stores.")
diff --git a/compiler-rt/lib/msan/msan_interceptors.cc b/compiler-rt/lib/msan/msan_interceptors.cc
new file mode 100644
index 0000000..fc28e08
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_interceptors.cc
@@ -0,0 +1,1643 @@
+//===-- msan_interceptors.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Interceptors for standard library functions.
+//
+// FIXME: move as many interceptors as possible into
+// sanitizer_common/sanitizer_common_interceptors.h
+//===----------------------------------------------------------------------===//
+
+#include "interception/interception.h"
+#include "msan.h"
+#include "msan_chained_origin_depot.h"
+#include "msan_origin.h"
+#include "msan_thread.h"
+#include "msan_poisoning.h"
+#include "sanitizer_common/sanitizer_platform_limits_posix.h"
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_allocator_interface.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_tls_get_addr.h"
+
+#include <stdarg.h>
+// ACHTUNG! No other system header includes in this file.
+// Ideally, we should get rid of stdarg.h as well.
+
+using namespace __msan;
+
+using __sanitizer::memory_order;
+using __sanitizer::atomic_load;
+using __sanitizer::atomic_store;
+using __sanitizer::atomic_uintptr_t;
+
+#if SANITIZER_FREEBSD
+#define __errno_location __error
+#endif
+
+// True if this is a nested interceptor.
+static THREADLOCAL int in_interceptor_scope;
+
+extern "C" int *__errno_location(void);
+
+struct InterceptorScope {
+  InterceptorScope() { ++in_interceptor_scope; }
+  ~InterceptorScope() { --in_interceptor_scope; }
+};
+
+bool IsInInterceptorScope() {
+  return in_interceptor_scope;
+}
+
+#define ENSURE_MSAN_INITED() do { \
+  CHECK(!msan_init_is_running); \
+  if (!msan_inited) { \
+    __msan_init(); \
+  } \
+} while (0)
+
+// Check that [x, x+n) range is unpoisoned.
+#define CHECK_UNPOISONED_0(x, n)                                               \
+  do {                                                                         \
+    sptr offset = __msan_test_shadow(x, n);                                    \
+    if (__msan::IsInSymbolizer())                                              \
+      break;                                                                   \
+    if (offset >= 0 && __msan::flags()->report_umrs) {                         \
+      GET_CALLER_PC_BP_SP;                                                     \
+      (void) sp;                                                               \
+      ReportUMRInsideAddressRange(__func__, x, n, offset);                     \
+      __msan::PrintWarningWithOrigin(                                          \
+          pc, bp, __msan_get_origin((const char *)x + offset));                \
+      if (__msan::flags()->halt_on_error) {                                    \
+        Printf("Exiting\n");                                                   \
+        Die();                                                                 \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+// Check that [x, x+n) range is unpoisoned unless we are in a nested
+// interceptor.
+#define CHECK_UNPOISONED(x, n)                             \
+  do {                                                     \
+    if (!IsInInterceptorScope()) CHECK_UNPOISONED_0(x, n); \
+  } while (0);
+
+#define CHECK_UNPOISONED_STRING_OF_LEN(x, len, n)               \
+  CHECK_UNPOISONED((x),                                         \
+    common_flags()->strict_string_checks ? (len) + 1 : (n) )
+
+#define CHECK_UNPOISONED_STRING(x, n)                           \
+    CHECK_UNPOISONED_STRING_OF_LEN((x), internal_strlen(x), (n))
+
+INTERCEPTOR(SIZE_T, fread, void *ptr, SIZE_T size, SIZE_T nmemb, void *file) {
+  ENSURE_MSAN_INITED();
+  SIZE_T res = REAL(fread)(ptr, size, nmemb, file);
+  if (res > 0)
+    __msan_unpoison(ptr, res *size);
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(SIZE_T, fread_unlocked, void *ptr, SIZE_T size, SIZE_T nmemb,
+            void *file) {
+  ENSURE_MSAN_INITED();
+  SIZE_T res = REAL(fread_unlocked)(ptr, size, nmemb, file);
+  if (res > 0)
+    __msan_unpoison(ptr, res *size);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT_FREAD_UNLOCKED INTERCEPT_FUNCTION(fread_unlocked)
+#else
+#define MSAN_MAYBE_INTERCEPT_FREAD_UNLOCKED
+#endif
+
+INTERCEPTOR(SSIZE_T, readlink, const char *path, char *buf, SIZE_T bufsiz) {
+  ENSURE_MSAN_INITED();
+  CHECK_UNPOISONED_STRING(path, 0)
+  SSIZE_T res = REAL(readlink)(path, buf, bufsiz);
+  if (res > 0)
+    __msan_unpoison(buf, res);
+  return res;
+}
+
+INTERCEPTOR(void *, memcpy, void *dest, const void *src, SIZE_T n) {
+  return __msan_memcpy(dest, src, n);
+}
+
+INTERCEPTOR(void *, mempcpy, void *dest, const void *src, SIZE_T n) {
+  return (char *)__msan_memcpy(dest, src, n) + n;
+}
+
+INTERCEPTOR(void *, memccpy, void *dest, const void *src, int c, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  void *res = REAL(memccpy)(dest, src, c, n);
+  CHECK(!res || (res >= dest && res <= (char *)dest + n));
+  SIZE_T sz = res ? (char *)res - (char *)dest : n;
+  CHECK_UNPOISONED(src, sz);
+  __msan_unpoison(dest, sz);
+  return res;
+}
+
+INTERCEPTOR(void *, memmove, void *dest, const void *src, SIZE_T n) {
+  return __msan_memmove(dest, src, n);
+}
+
+INTERCEPTOR(void *, memset, void *s, int c, SIZE_T n) {
+  return __msan_memset(s, c, n);
+}
+
+INTERCEPTOR(void *, bcopy, const void *src, void *dest, SIZE_T n) {
+  return __msan_memmove(dest, src, n);
+}
+
+INTERCEPTOR(int, posix_memalign, void **memptr, SIZE_T alignment, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  CHECK_EQ(alignment & (alignment - 1), 0);
+  CHECK_NE(memptr, 0);
+  *memptr = MsanReallocate(&stack, nullptr, size, alignment, false);
+  CHECK_NE(*memptr, 0);
+  __msan_unpoison(memptr, sizeof(*memptr));
+  return 0;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(void *, memalign, SIZE_T boundary, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  CHECK_EQ(boundary & (boundary - 1), 0);
+  void *ptr = MsanReallocate(&stack, nullptr, size, boundary, false);
+  return ptr;
+}
+#define MSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
+#else
+#define MSAN_MAYBE_INTERCEPT_MEMALIGN
+#endif
+
+INTERCEPTOR(void *, aligned_alloc, SIZE_T boundary, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  CHECK_EQ(boundary & (boundary - 1), 0);
+  void *ptr = MsanReallocate(&stack, nullptr, size, boundary, false);
+  return ptr;
+}
+
+INTERCEPTOR(void *, __libc_memalign, SIZE_T boundary, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  CHECK_EQ(boundary & (boundary - 1), 0);
+  void *ptr = MsanReallocate(&stack, nullptr, size, boundary, false);
+  DTLS_on_libc_memalign(ptr, size * boundary);
+  return ptr;
+}
+
+INTERCEPTOR(void *, valloc, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  void *ptr = MsanReallocate(&stack, nullptr, size, GetPageSizeCached(), false);
+  return ptr;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(void *, pvalloc, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  uptr PageSize = GetPageSizeCached();
+  size = RoundUpTo(size, PageSize);
+  if (size == 0) {
+    // pvalloc(0) should allocate one page.
+    size = PageSize;
+  }
+  void *ptr = MsanReallocate(&stack, nullptr, size, PageSize, false);
+  return ptr;
+}
+#define MSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
+#else
+#define MSAN_MAYBE_INTERCEPT_PVALLOC
+#endif
+
+INTERCEPTOR(void, free, void *ptr) {
+  GET_MALLOC_STACK_TRACE;
+  if (!ptr) return;
+  MsanDeallocate(&stack, ptr);
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(void, cfree, void *ptr) {
+  GET_MALLOC_STACK_TRACE;
+  if (!ptr) return;
+  MsanDeallocate(&stack, ptr);
+}
+#define MSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
+#else
+#define MSAN_MAYBE_INTERCEPT_CFREE
+#endif
+
+INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
+  return __sanitizer_get_allocated_size(ptr);
+}
+
+#if !SANITIZER_FREEBSD
+// This function actually returns a struct by value, but we can't unpoison a
+// temporary! The following is equivalent on all supported platforms but
+// aarch64 (which uses a different register for sret value).  We have a test
+// to confirm that.
+INTERCEPTOR(void, mallinfo, __sanitizer_mallinfo *sret) {
+#ifdef __aarch64__
+  uptr r8;
+  asm volatile("mov %0,x8" : "=r" (r8));
+  sret = reinterpret_cast<__sanitizer_mallinfo*>(r8);
+#endif
+  REAL(memset)(sret, 0, sizeof(*sret));
+  __msan_unpoison(sret, sizeof(*sret));
+}
+#define MSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
+#else
+#define MSAN_MAYBE_INTERCEPT_MALLINFO
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, mallopt, int cmd, int value) {
+  return -1;
+}
+#define MSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
+#else
+#define MSAN_MAYBE_INTERCEPT_MALLOPT
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(void, malloc_stats, void) {
+  // FIXME: implement, but don't call REAL(malloc_stats)!
+}
+#define MSAN_MAYBE_INTERCEPT_MALLOC_STATS INTERCEPT_FUNCTION(malloc_stats)
+#else
+#define MSAN_MAYBE_INTERCEPT_MALLOC_STATS
+#endif
+
+INTERCEPTOR(SIZE_T, strlen, const char *s) {
+  if (msan_init_is_running)
+    return REAL(strlen)(s);
+  ENSURE_MSAN_INITED();
+  SIZE_T res = REAL(strlen)(s);
+  CHECK_UNPOISONED(s, res + 1);
+  return res;
+}
+
+INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  SIZE_T res = REAL(strnlen)(s, n);
+  SIZE_T scan_size = (res == n) ? res : res + 1;
+  CHECK_UNPOISONED(s, scan_size);
+  return res;
+}
+
+INTERCEPTOR(char *, strcpy, char *dest, const char *src) {  // NOLINT
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T n = REAL(strlen)(src);
+  CHECK_UNPOISONED_STRING(src + n, 0);
+  char *res = REAL(strcpy)(dest, src);  // NOLINT
+  CopyShadowAndOrigin(dest, src, n + 1, &stack);
+  return res;
+}
+
+INTERCEPTOR(char *, strncpy, char *dest, const char *src, SIZE_T n) {  // NOLINT
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T copy_size = REAL(strnlen)(src, n);
+  if (copy_size < n)
+    copy_size++;  // trailing \0
+  char *res = REAL(strncpy)(dest, src, n);  // NOLINT
+  CopyShadowAndOrigin(dest, src, copy_size, &stack);
+  __msan_unpoison(dest + copy_size, n - copy_size);
+  return res;
+}
+
+INTERCEPTOR(char *, stpcpy, char *dest, const char *src) {  // NOLINT
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T n = REAL(strlen)(src);
+  CHECK_UNPOISONED_STRING(src + n, 0);
+  char *res = REAL(stpcpy)(dest, src);  // NOLINT
+  CopyShadowAndOrigin(dest, src, n + 1, &stack);
+  return res;
+}
+
+INTERCEPTOR(char *, strdup, char *src) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  // On FreeBSD strdup() leverages strlen().
+  InterceptorScope interceptor_scope;
+  SIZE_T n = REAL(strlen)(src);
+  CHECK_UNPOISONED_STRING(src + n, 0);
+  char *res = REAL(strdup)(src);
+  CopyShadowAndOrigin(res, src, n + 1, &stack);
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(char *, __strdup, char *src) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T n = REAL(strlen)(src);
+  CHECK_UNPOISONED_STRING(src + n, 0);
+  char *res = REAL(__strdup)(src);
+  CopyShadowAndOrigin(res, src, n + 1, &stack);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___STRDUP INTERCEPT_FUNCTION(__strdup)
+#else
+#define MSAN_MAYBE_INTERCEPT___STRDUP
+#endif
+
+INTERCEPTOR(char *, strndup, char *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  // On FreeBSD strndup() leverages strnlen().
+  InterceptorScope interceptor_scope;
+  SIZE_T copy_size = REAL(strnlen)(src, n);
+  char *res = REAL(strndup)(src, n);
+  CopyShadowAndOrigin(res, src, copy_size, &stack);
+  __msan_unpoison(res + copy_size, 1); // \0
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(char *, __strndup, char *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T copy_size = REAL(strnlen)(src, n);
+  char *res = REAL(__strndup)(src, n);
+  CopyShadowAndOrigin(res, src, copy_size, &stack);
+  __msan_unpoison(res + copy_size, 1); // \0
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___STRNDUP INTERCEPT_FUNCTION(__strndup)
+#else
+#define MSAN_MAYBE_INTERCEPT___STRNDUP
+#endif
+
+INTERCEPTOR(char *, gcvt, double number, SIZE_T ndigit, char *buf) {
+  ENSURE_MSAN_INITED();
+  char *res = REAL(gcvt)(number, ndigit, buf);
+  SIZE_T n = REAL(strlen)(buf);
+  __msan_unpoison(buf, n + 1);
+  return res;
+}
+
+INTERCEPTOR(char *, strcat, char *dest, const char *src) {  // NOLINT
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T src_size = REAL(strlen)(src);
+  SIZE_T dest_size = REAL(strlen)(dest);
+  CHECK_UNPOISONED_STRING(src + src_size, 0);
+  CHECK_UNPOISONED_STRING(dest + dest_size, 0);
+  char *res = REAL(strcat)(dest, src);  // NOLINT
+  CopyShadowAndOrigin(dest + dest_size, src, src_size + 1, &stack);
+  return res;
+}
+
+INTERCEPTOR(char *, strncat, char *dest, const char *src, SIZE_T n) {  // NOLINT
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  SIZE_T dest_size = REAL(strlen)(dest);
+  SIZE_T copy_size = REAL(strnlen)(src, n);
+  CHECK_UNPOISONED_STRING(dest + dest_size, 0);
+  char *res = REAL(strncat)(dest, src, n);  // NOLINT
+  CopyShadowAndOrigin(dest + dest_size, src, copy_size, &stack);
+  __msan_unpoison(dest + dest_size + copy_size, 1); // \0
+  return res;
+}
+
+// Hack: always pass nptr and endptr as part of __VA_ARGS_ to avoid having to
+// deal with empty __VA_ARGS__ in the case of INTERCEPTOR_STRTO.
+#define INTERCEPTOR_STRTO_BODY(ret_type, func, ...) \
+  ENSURE_MSAN_INITED();                             \
+  ret_type res = REAL(func)(__VA_ARGS__);           \
+  __msan_unpoison(endptr, sizeof(*endptr));         \
+  return res;
+
+#define INTERCEPTOR_STRTO(ret_type, func, char_type)                       \
+  INTERCEPTOR(ret_type, func, const char_type *nptr, char_type **endptr) { \
+    INTERCEPTOR_STRTO_BODY(ret_type, func, nptr, endptr);                  \
+  }
+
+#define INTERCEPTOR_STRTO_BASE(ret_type, func, char_type)                \
+  INTERCEPTOR(ret_type, func, const char_type *nptr, char_type **endptr, \
+              int base) {                                                \
+    INTERCEPTOR_STRTO_BODY(ret_type, func, nptr, endptr, base);          \
+  }
+
+#define INTERCEPTOR_STRTO_LOC(ret_type, func, char_type)                 \
+  INTERCEPTOR(ret_type, func, const char_type *nptr, char_type **endptr, \
+              void *loc) {                                               \
+    INTERCEPTOR_STRTO_BODY(ret_type, func, nptr, endptr, loc);           \
+  }
+
+#define INTERCEPTOR_STRTO_BASE_LOC(ret_type, func, char_type)            \
+  INTERCEPTOR(ret_type, func, const char_type *nptr, char_type **endptr, \
+              int base, void *loc) {                                     \
+    INTERCEPTOR_STRTO_BODY(ret_type, func, nptr, endptr, base, loc);     \
+  }
+
+#define INTERCEPTORS_STRTO(ret_type, func, char_type)      \
+  INTERCEPTOR_STRTO(ret_type, func, char_type)             \
+  INTERCEPTOR_STRTO_LOC(ret_type, func##_l, char_type)     \
+  INTERCEPTOR_STRTO_LOC(ret_type, __##func##_l, char_type) \
+  INTERCEPTOR_STRTO_LOC(ret_type, __##func##_internal, char_type)
+
+#define INTERCEPTORS_STRTO_BASE(ret_type, func, char_type)      \
+  INTERCEPTOR_STRTO_BASE(ret_type, func, char_type)             \
+  INTERCEPTOR_STRTO_BASE_LOC(ret_type, func##_l, char_type)     \
+  INTERCEPTOR_STRTO_BASE_LOC(ret_type, __##func##_l, char_type) \
+  INTERCEPTOR_STRTO_BASE_LOC(ret_type, __##func##_internal, char_type)
+
+INTERCEPTORS_STRTO(double, strtod, char)                     // NOLINT
+INTERCEPTORS_STRTO(float, strtof, char)                      // NOLINT
+INTERCEPTORS_STRTO(long double, strtold, char)               // NOLINT
+INTERCEPTORS_STRTO_BASE(long, strtol, char)                  // NOLINT
+INTERCEPTORS_STRTO_BASE(long long, strtoll, char)            // NOLINT
+INTERCEPTORS_STRTO_BASE(unsigned long, strtoul, char)        // NOLINT
+INTERCEPTORS_STRTO_BASE(unsigned long long, strtoull, char)  // NOLINT
+
+INTERCEPTORS_STRTO(double, wcstod, wchar_t)                     // NOLINT
+INTERCEPTORS_STRTO(float, wcstof, wchar_t)                      // NOLINT
+INTERCEPTORS_STRTO(long double, wcstold, wchar_t)               // NOLINT
+INTERCEPTORS_STRTO_BASE(long, wcstol, wchar_t)                  // NOLINT
+INTERCEPTORS_STRTO_BASE(long long, wcstoll, wchar_t)            // NOLINT
+INTERCEPTORS_STRTO_BASE(unsigned long, wcstoul, wchar_t)        // NOLINT
+INTERCEPTORS_STRTO_BASE(unsigned long long, wcstoull, wchar_t)  // NOLINT
+
+#define INTERCEPT_STRTO(func) \
+  INTERCEPT_FUNCTION(func); \
+  INTERCEPT_FUNCTION(func##_l); \
+  INTERCEPT_FUNCTION(__##func##_l); \
+  INTERCEPT_FUNCTION(__##func##_internal);
+
+
+// FIXME: support *wprintf in common format interceptors.
+INTERCEPTOR(int, vswprintf, void *str, uptr size, void *format, va_list ap) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(vswprintf)(str, size, format, ap);
+  if (res >= 0) {
+    __msan_unpoison(str, 4 * (res + 1));
+  }
+  return res;
+}
+
+INTERCEPTOR(int, swprintf, void *str, uptr size, void *format, ...) {
+  ENSURE_MSAN_INITED();
+  va_list ap;
+  va_start(ap, format);
+  int res = vswprintf(str, size, format, ap);
+  va_end(ap);
+  return res;
+}
+
+INTERCEPTOR(SIZE_T, strxfrm, char *dest, const char *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  CHECK_UNPOISONED(src, REAL(strlen)(src) + 1);
+  SIZE_T res = REAL(strxfrm)(dest, src, n);
+  if (res < n) __msan_unpoison(dest, res + 1);
+  return res;
+}
+
+INTERCEPTOR(SIZE_T, strxfrm_l, char *dest, const char *src, SIZE_T n,
+            void *loc) {
+  ENSURE_MSAN_INITED();
+  CHECK_UNPOISONED(src, REAL(strlen)(src) + 1);
+  SIZE_T res = REAL(strxfrm_l)(dest, src, n, loc);
+  if (res < n) __msan_unpoison(dest, res + 1);
+  return res;
+}
+
+#define INTERCEPTOR_STRFTIME_BODY(char_type, ret_type, func, s, ...) \
+  ENSURE_MSAN_INITED();                                              \
+  ret_type res = REAL(func)(s, __VA_ARGS__);                         \
+  if (s) __msan_unpoison(s, sizeof(char_type) * (res + 1));          \
+  return res;
+
+INTERCEPTOR(SIZE_T, strftime, char *s, SIZE_T max, const char *format,
+            __sanitizer_tm *tm) {
+  INTERCEPTOR_STRFTIME_BODY(char, SIZE_T, strftime, s, max, format, tm);
+}
+
+INTERCEPTOR(SIZE_T, strftime_l, char *s, SIZE_T max, const char *format,
+            __sanitizer_tm *tm, void *loc) {
+  INTERCEPTOR_STRFTIME_BODY(char, SIZE_T, strftime_l, s, max, format, tm, loc);
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(SIZE_T, __strftime_l, char *s, SIZE_T max, const char *format,
+            __sanitizer_tm *tm, void *loc) {
+  INTERCEPTOR_STRFTIME_BODY(char, SIZE_T, __strftime_l, s, max, format, tm,
+                            loc);
+}
+#define MSAN_MAYBE_INTERCEPT___STRFTIME_L INTERCEPT_FUNCTION(__strftime_l)
+#else
+#define MSAN_MAYBE_INTERCEPT___STRFTIME_L
+#endif
+
+INTERCEPTOR(SIZE_T, wcsftime, wchar_t *s, SIZE_T max, const wchar_t *format,
+            __sanitizer_tm *tm) {
+  INTERCEPTOR_STRFTIME_BODY(wchar_t, SIZE_T, wcsftime, s, max, format, tm);
+}
+
+INTERCEPTOR(SIZE_T, wcsftime_l, wchar_t *s, SIZE_T max, const wchar_t *format,
+            __sanitizer_tm *tm, void *loc) {
+  INTERCEPTOR_STRFTIME_BODY(wchar_t, SIZE_T, wcsftime_l, s, max, format, tm,
+                            loc);
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(SIZE_T, __wcsftime_l, wchar_t *s, SIZE_T max, const wchar_t *format,
+            __sanitizer_tm *tm, void *loc) {
+  INTERCEPTOR_STRFTIME_BODY(wchar_t, SIZE_T, __wcsftime_l, s, max, format, tm,
+                            loc);
+}
+#define MSAN_MAYBE_INTERCEPT___WCSFTIME_L INTERCEPT_FUNCTION(__wcsftime_l)
+#else
+#define MSAN_MAYBE_INTERCEPT___WCSFTIME_L
+#endif
+
+INTERCEPTOR(int, mbtowc, wchar_t *dest, const char *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(mbtowc)(dest, src, n);
+  if (res != -1 && dest) __msan_unpoison(dest, sizeof(wchar_t));
+  return res;
+}
+
+INTERCEPTOR(int, mbrtowc, wchar_t *dest, const char *src, SIZE_T n, void *ps) {
+  ENSURE_MSAN_INITED();
+  SIZE_T res = REAL(mbrtowc)(dest, src, n, ps);
+  if (res != (SIZE_T)-1 && dest) __msan_unpoison(dest, sizeof(wchar_t));
+  return res;
+}
+
+INTERCEPTOR(SIZE_T, wcslen, const wchar_t *s) {
+  ENSURE_MSAN_INITED();
+  SIZE_T res = REAL(wcslen)(s);
+  CHECK_UNPOISONED(s, sizeof(wchar_t) * (res + 1));
+  return res;
+}
+
+// wchar_t *wcschr(const wchar_t *wcs, wchar_t wc);
+INTERCEPTOR(wchar_t *, wcschr, void *s, wchar_t wc, void *ps) {
+  ENSURE_MSAN_INITED();
+  wchar_t *res = REAL(wcschr)(s, wc, ps);
+  return res;
+}
+
+// wchar_t *wcscpy(wchar_t *dest, const wchar_t *src);
+INTERCEPTOR(wchar_t *, wcscpy, wchar_t *dest, const wchar_t *src) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  wchar_t *res = REAL(wcscpy)(dest, src);
+  CopyShadowAndOrigin(dest, src, sizeof(wchar_t) * (REAL(wcslen)(src) + 1),
+                      &stack);
+  return res;
+}
+
+// wchar_t *wmemcpy(wchar_t *dest, const wchar_t *src, SIZE_T n);
+INTERCEPTOR(wchar_t *, wmemcpy, wchar_t *dest, const wchar_t *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  wchar_t *res = REAL(wmemcpy)(dest, src, n);
+  CopyShadowAndOrigin(dest, src, n * sizeof(wchar_t), &stack);
+  return res;
+}
+
+INTERCEPTOR(wchar_t *, wmempcpy, wchar_t *dest, const wchar_t *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  wchar_t *res = REAL(wmempcpy)(dest, src, n);
+  CopyShadowAndOrigin(dest, src, n * sizeof(wchar_t), &stack);
+  return res;
+}
+
+INTERCEPTOR(wchar_t *, wmemset, wchar_t *s, wchar_t c, SIZE_T n) {
+  CHECK(MEM_IS_APP(s));
+  ENSURE_MSAN_INITED();
+  wchar_t *res = REAL(wmemset)(s, c, n);
+  __msan_unpoison(s, n * sizeof(wchar_t));
+  return res;
+}
+
+INTERCEPTOR(wchar_t *, wmemmove, wchar_t *dest, const wchar_t *src, SIZE_T n) {
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  wchar_t *res = REAL(wmemmove)(dest, src, n);
+  MoveShadowAndOrigin(dest, src, n * sizeof(wchar_t), &stack);
+  return res;
+}
+
+INTERCEPTOR(int, wcscmp, const wchar_t *s1, const wchar_t *s2) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(wcscmp)(s1, s2);
+  return res;
+}
+
+INTERCEPTOR(int, gettimeofday, void *tv, void *tz) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(gettimeofday)(tv, tz);
+  if (tv)
+    __msan_unpoison(tv, 16);
+  if (tz)
+    __msan_unpoison(tz, 8);
+  return res;
+}
+
+INTERCEPTOR(char *, fcvt, double x, int a, int *b, int *c) {
+  ENSURE_MSAN_INITED();
+  char *res = REAL(fcvt)(x, a, b, c);
+  __msan_unpoison(b, sizeof(*b));
+  __msan_unpoison(c, sizeof(*c));
+  if (res) __msan_unpoison(res, REAL(strlen)(res) + 1);
+  return res;
+}
+
+INTERCEPTOR(char *, getenv, char *name) {
+  if (msan_init_is_running)
+    return REAL(getenv)(name);
+  ENSURE_MSAN_INITED();
+  char *res = REAL(getenv)(name);
+  if (res) __msan_unpoison(res, REAL(strlen)(res) + 1);
+  return res;
+}
+
+extern char **environ;
+
+static void UnpoisonEnviron() {
+  char **envp = environ;
+  for (; *envp; ++envp) {
+    __msan_unpoison(envp, sizeof(*envp));
+    __msan_unpoison(*envp, REAL(strlen)(*envp) + 1);
+  }
+  // Trailing NULL pointer.
+  __msan_unpoison(envp, sizeof(*envp));
+}
+
+INTERCEPTOR(int, setenv, const char *name, const char *value, int overwrite) {
+  ENSURE_MSAN_INITED();
+  CHECK_UNPOISONED_STRING(name, 0)
+  int res = REAL(setenv)(name, value, overwrite);
+  if (!res) UnpoisonEnviron();
+  return res;
+}
+
+INTERCEPTOR(int, putenv, char *string) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(putenv)(string);
+  if (!res) UnpoisonEnviron();
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, __fxstat, int magic, int fd, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__fxstat)(magic, fd, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___FXSTAT INTERCEPT_FUNCTION(__fxstat)
+#else
+#define MSAN_MAYBE_INTERCEPT___FXSTAT
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, __fxstat64, int magic, int fd, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__fxstat64)(magic, fd, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat64_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___FXSTAT64 INTERCEPT_FUNCTION(__fxstat64)
+#else
+#define MSAN_MAYBE_INTERCEPT___FXSTAT64
+#endif
+
+#if SANITIZER_FREEBSD
+INTERCEPTOR(int, fstatat, int fd, char *pathname, void *buf, int flags) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(fstatat)(fd, pathname, buf, flags);
+  if (!res) __msan_unpoison(buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+# define MSAN_INTERCEPT_FSTATAT INTERCEPT_FUNCTION(fstatat)
+#else
+INTERCEPTOR(int, __fxstatat, int magic, int fd, char *pathname, void *buf,
+            int flags) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__fxstatat)(magic, fd, pathname, buf, flags);
+  if (!res) __msan_unpoison(buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+# define MSAN_INTERCEPT_FSTATAT INTERCEPT_FUNCTION(__fxstatat)
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, __fxstatat64, int magic, int fd, char *pathname, void *buf,
+            int flags) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__fxstatat64)(magic, fd, pathname, buf, flags);
+  if (!res) __msan_unpoison(buf, __sanitizer::struct_stat64_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___FXSTATAT64 INTERCEPT_FUNCTION(__fxstatat64)
+#else
+#define MSAN_MAYBE_INTERCEPT___FXSTATAT64
+#endif
+
+#if SANITIZER_FREEBSD
+INTERCEPTOR(int, stat, char *path, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(stat)(path, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+# define MSAN_INTERCEPT_STAT INTERCEPT_FUNCTION(stat)
+#else
+INTERCEPTOR(int, __xstat, int magic, char *path, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__xstat)(magic, path, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+# define MSAN_INTERCEPT_STAT INTERCEPT_FUNCTION(__xstat)
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, __xstat64, int magic, char *path, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__xstat64)(magic, path, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat64_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___XSTAT64 INTERCEPT_FUNCTION(__xstat64)
+#else
+#define MSAN_MAYBE_INTERCEPT___XSTAT64
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, __lxstat, int magic, char *path, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__lxstat)(magic, path, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___LXSTAT INTERCEPT_FUNCTION(__lxstat)
+#else
+#define MSAN_MAYBE_INTERCEPT___LXSTAT
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, __lxstat64, int magic, char *path, void *buf) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__lxstat64)(magic, path, buf);
+  if (!res)
+    __msan_unpoison(buf, __sanitizer::struct_stat64_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT___LXSTAT64 INTERCEPT_FUNCTION(__lxstat64)
+#else
+#define MSAN_MAYBE_INTERCEPT___LXSTAT64
+#endif
+
+INTERCEPTOR(int, pipe, int pipefd[2]) {
+  if (msan_init_is_running)
+    return REAL(pipe)(pipefd);
+  ENSURE_MSAN_INITED();
+  int res = REAL(pipe)(pipefd);
+  if (!res)
+    __msan_unpoison(pipefd, sizeof(int[2]));
+  return res;
+}
+
+INTERCEPTOR(int, pipe2, int pipefd[2], int flags) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(pipe2)(pipefd, flags);
+  if (!res)
+    __msan_unpoison(pipefd, sizeof(int[2]));
+  return res;
+}
+
+INTERCEPTOR(int, socketpair, int domain, int type, int protocol, int sv[2]) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(socketpair)(domain, type, protocol, sv);
+  if (!res)
+    __msan_unpoison(sv, sizeof(int[2]));
+  return res;
+}
+
+INTERCEPTOR(char *, fgets, char *s, int size, void *stream) {
+  ENSURE_MSAN_INITED();
+  char *res = REAL(fgets)(s, size, stream);
+  if (res)
+    __msan_unpoison(s, REAL(strlen)(s) + 1);
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(char *, fgets_unlocked, char *s, int size, void *stream) {
+  ENSURE_MSAN_INITED();
+  char *res = REAL(fgets_unlocked)(s, size, stream);
+  if (res)
+    __msan_unpoison(s, REAL(strlen)(s) + 1);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED INTERCEPT_FUNCTION(fgets_unlocked)
+#else
+#define MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED
+#endif
+
+INTERCEPTOR(int, getrlimit, int resource, void *rlim) {
+  if (msan_init_is_running)
+    return REAL(getrlimit)(resource, rlim);
+  ENSURE_MSAN_INITED();
+  int res = REAL(getrlimit)(resource, rlim);
+  if (!res)
+    __msan_unpoison(rlim, __sanitizer::struct_rlimit_sz);
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, getrlimit64, int resource, void *rlim) {
+  if (msan_init_is_running)
+    return REAL(getrlimit64)(resource, rlim);
+  ENSURE_MSAN_INITED();
+  int res = REAL(getrlimit64)(resource, rlim);
+  if (!res)
+    __msan_unpoison(rlim, __sanitizer::struct_rlimit64_sz);
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT_GETRLIMIT64 INTERCEPT_FUNCTION(getrlimit64)
+#else
+#define MSAN_MAYBE_INTERCEPT_GETRLIMIT64
+#endif
+
+#if SANITIZER_FREEBSD
+// FreeBSD's <sys/utsname.h> define uname() as
+// static __inline int uname(struct utsname *name) {
+//   return __xuname(SYS_NMLN, (void*)name);
+// }
+INTERCEPTOR(int, __xuname, int size, void *utsname) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(__xuname)(size, utsname);
+  if (!res)
+    __msan_unpoison(utsname, __sanitizer::struct_utsname_sz);
+  return res;
+}
+#define MSAN_INTERCEPT_UNAME INTERCEPT_FUNCTION(__xuname)
+#else
+INTERCEPTOR(int, uname, struct utsname *utsname) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(uname)(utsname);
+  if (!res)
+    __msan_unpoison(utsname, __sanitizer::struct_utsname_sz);
+  return res;
+}
+#define MSAN_INTERCEPT_UNAME INTERCEPT_FUNCTION(uname)
+#endif
+
+INTERCEPTOR(int, gethostname, char *name, SIZE_T len) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(gethostname)(name, len);
+  if (!res) {
+    SIZE_T real_len = REAL(strnlen)(name, len);
+    if (real_len < len)
+      ++real_len;
+    __msan_unpoison(name, real_len);
+  }
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, epoll_wait, int epfd, void *events, int maxevents,
+    int timeout) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(epoll_wait)(epfd, events, maxevents, timeout);
+  if (res > 0) {
+    __msan_unpoison(events, __sanitizer::struct_epoll_event_sz * res);
+  }
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT_EPOLL_WAIT INTERCEPT_FUNCTION(epoll_wait)
+#else
+#define MSAN_MAYBE_INTERCEPT_EPOLL_WAIT
+#endif
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(int, epoll_pwait, int epfd, void *events, int maxevents,
+    int timeout, void *sigmask) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(epoll_pwait)(epfd, events, maxevents, timeout, sigmask);
+  if (res > 0) {
+    __msan_unpoison(events, __sanitizer::struct_epoll_event_sz * res);
+  }
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT_EPOLL_PWAIT INTERCEPT_FUNCTION(epoll_pwait)
+#else
+#define MSAN_MAYBE_INTERCEPT_EPOLL_PWAIT
+#endif
+
+INTERCEPTOR(SSIZE_T, recv, int fd, void *buf, SIZE_T len, int flags) {
+  ENSURE_MSAN_INITED();
+  SSIZE_T res = REAL(recv)(fd, buf, len, flags);
+  if (res > 0)
+    __msan_unpoison(buf, res);
+  return res;
+}
+
+INTERCEPTOR(SSIZE_T, recvfrom, int fd, void *buf, SIZE_T len, int flags,
+            void *srcaddr, int *addrlen) {
+  ENSURE_MSAN_INITED();
+  SIZE_T srcaddr_sz;
+  if (srcaddr) srcaddr_sz = *addrlen;
+  SSIZE_T res = REAL(recvfrom)(fd, buf, len, flags, srcaddr, addrlen);
+  if (res > 0) {
+    __msan_unpoison(buf, res);
+    if (srcaddr) {
+      SIZE_T sz = *addrlen;
+      __msan_unpoison(srcaddr, Min(sz, srcaddr_sz));
+    }
+  }
+  return res;
+}
+
+INTERCEPTOR(void *, calloc, SIZE_T nmemb, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  if (UNLIKELY(!msan_inited)) {
+    // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
+    const SIZE_T kCallocPoolSize = 1024;
+    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
+    static SIZE_T allocated;
+    SIZE_T size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
+    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
+    allocated += size_in_words;
+    CHECK(allocated < kCallocPoolSize);
+    return mem;
+  }
+  return MsanCalloc(&stack, nmemb, size);
+}
+
+INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  return MsanReallocate(&stack, ptr, size, sizeof(u64), false);
+}
+
+INTERCEPTOR(void *, malloc, SIZE_T size) {
+  GET_MALLOC_STACK_TRACE;
+  return MsanReallocate(&stack, nullptr, size, sizeof(u64), false);
+}
+
+void __msan_allocated_memory(const void *data, uptr size) {
+  GET_MALLOC_STACK_TRACE;
+  if (flags()->poison_in_malloc) {
+    stack.tag = STACK_TRACE_TAG_POISON;
+    PoisonMemory(data, size, &stack);
+  }
+}
+
+void __msan_copy_shadow(void *dest, const void *src, uptr n) {
+  GET_STORE_STACK_TRACE;
+  MoveShadowAndOrigin(dest, src, n, &stack);
+}
+
+void __sanitizer_dtor_callback(const void *data, uptr size) {
+  GET_MALLOC_STACK_TRACE;
+  if (flags()->poison_in_dtor) {
+    stack.tag = STACK_TRACE_TAG_POISON;
+    PoisonMemory(data, size, &stack);
+  }
+}
+
+INTERCEPTOR(void *, mmap, void *addr, SIZE_T length, int prot, int flags,
+            int fd, OFF_T offset) {
+  if (msan_init_is_running)
+    return REAL(mmap)(addr, length, prot, flags, fd, offset);
+  ENSURE_MSAN_INITED();
+  if (addr && !MEM_IS_APP(addr)) {
+    if (flags & map_fixed) {
+      *__errno_location() = errno_EINVAL;
+      return (void *)-1;
+    } else {
+      addr = nullptr;
+    }
+  }
+  void *res = REAL(mmap)(addr, length, prot, flags, fd, offset);
+  if (res != (void*)-1)
+    __msan_unpoison(res, RoundUpTo(length, GetPageSize()));
+  return res;
+}
+
+#if !SANITIZER_FREEBSD
+INTERCEPTOR(void *, mmap64, void *addr, SIZE_T length, int prot, int flags,
+            int fd, OFF64_T offset) {
+  ENSURE_MSAN_INITED();
+  if (addr && !MEM_IS_APP(addr)) {
+    if (flags & map_fixed) {
+      *__errno_location() = errno_EINVAL;
+      return (void *)-1;
+    } else {
+      addr = nullptr;
+    }
+  }
+  void *res = REAL(mmap64)(addr, length, prot, flags, fd, offset);
+  if (res != (void*)-1)
+    __msan_unpoison(res, RoundUpTo(length, GetPageSize()));
+  return res;
+}
+#define MSAN_MAYBE_INTERCEPT_MMAP64 INTERCEPT_FUNCTION(mmap64)
+#else
+#define MSAN_MAYBE_INTERCEPT_MMAP64
+#endif
+
+struct dlinfo {
+  char *dli_fname;
+  void *dli_fbase;
+  char *dli_sname;
+  void *dli_saddr;
+};
+
+INTERCEPTOR(int, dladdr, void *addr, dlinfo *info) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(dladdr)(addr, info);
+  if (res != 0) {
+    __msan_unpoison(info, sizeof(*info));
+    if (info->dli_fname)
+      __msan_unpoison(info->dli_fname, REAL(strlen)(info->dli_fname) + 1);
+    if (info->dli_sname)
+      __msan_unpoison(info->dli_sname, REAL(strlen)(info->dli_sname) + 1);
+  }
+  return res;
+}
+
+INTERCEPTOR(char *, dlerror, int fake) {
+  ENSURE_MSAN_INITED();
+  char *res = REAL(dlerror)(fake);
+  if (res) __msan_unpoison(res, REAL(strlen)(res) + 1);
+  return res;
+}
+
+typedef int (*dl_iterate_phdr_cb)(__sanitizer_dl_phdr_info *info, SIZE_T size,
+                                  void *data);
+struct dl_iterate_phdr_data {
+  dl_iterate_phdr_cb callback;
+  void *data;
+};
+
+static int msan_dl_iterate_phdr_cb(__sanitizer_dl_phdr_info *info, SIZE_T size,
+                                   void *data) {
+  if (info) {
+    __msan_unpoison(info, size);
+    if (info->dlpi_phdr && info->dlpi_phnum)
+      __msan_unpoison(info->dlpi_phdr, struct_ElfW_Phdr_sz * info->dlpi_phnum);
+    if (info->dlpi_name)
+      __msan_unpoison(info->dlpi_name, REAL(strlen)(info->dlpi_name) + 1);
+  }
+  dl_iterate_phdr_data *cbdata = (dl_iterate_phdr_data *)data;
+  UnpoisonParam(3);
+  return cbdata->callback(info, size, cbdata->data);
+}
+
+INTERCEPTOR(int, dl_iterate_phdr, dl_iterate_phdr_cb callback, void *data) {
+  ENSURE_MSAN_INITED();
+  dl_iterate_phdr_data cbdata;
+  cbdata.callback = callback;
+  cbdata.data = data;
+  int res = REAL(dl_iterate_phdr)(msan_dl_iterate_phdr_cb, (void *)&cbdata);
+  return res;
+}
+
+INTERCEPTOR(int, getrusage, int who, void *usage) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(getrusage)(who, usage);
+  if (res == 0) {
+    __msan_unpoison(usage, __sanitizer::struct_rusage_sz);
+  }
+  return res;
+}
+
+class SignalHandlerScope {
+ public:
+  SignalHandlerScope() {
+    if (MsanThread *t = GetCurrentThread())
+      t->EnterSignalHandler();
+  }
+  ~SignalHandlerScope() {
+    if (MsanThread *t = GetCurrentThread())
+      t->LeaveSignalHandler();
+  }
+};
+
+// sigactions_mu guarantees atomicity of sigaction() and signal() calls.
+// Access to sigactions[] is gone with relaxed atomics to avoid data race with
+// the signal handler.
+const int kMaxSignals = 1024;
+static atomic_uintptr_t sigactions[kMaxSignals];
+static StaticSpinMutex sigactions_mu;
+
+static void SignalHandler(int signo) {
+  SignalHandlerScope signal_handler_scope;
+  ScopedThreadLocalStateBackup stlsb;
+  UnpoisonParam(1);
+
+  typedef void (*signal_cb)(int x);
+  signal_cb cb =
+      (signal_cb)atomic_load(&sigactions[signo], memory_order_relaxed);
+  cb(signo);
+}
+
+static void SignalAction(int signo, void *si, void *uc) {
+  SignalHandlerScope signal_handler_scope;
+  ScopedThreadLocalStateBackup stlsb;
+  UnpoisonParam(3);
+  __msan_unpoison(si, sizeof(__sanitizer_sigaction));
+  __msan_unpoison(uc, __sanitizer::ucontext_t_sz);
+
+  typedef void (*sigaction_cb)(int, void *, void *);
+  sigaction_cb cb =
+      (sigaction_cb)atomic_load(&sigactions[signo], memory_order_relaxed);
+  cb(signo, si, uc);
+}
+
+INTERCEPTOR(int, sigaction, int signo, const __sanitizer_sigaction *act,
+            __sanitizer_sigaction *oldact) {
+  ENSURE_MSAN_INITED();
+  // FIXME: check that *act is unpoisoned.
+  // That requires intercepting all of sigemptyset, sigfillset, etc.
+  int res;
+  if (flags()->wrap_signals) {
+    SpinMutexLock lock(&sigactions_mu);
+    CHECK_LT(signo, kMaxSignals);
+    uptr old_cb = atomic_load(&sigactions[signo], memory_order_relaxed);
+    __sanitizer_sigaction new_act;
+    __sanitizer_sigaction *pnew_act = act ? &new_act : nullptr;
+    if (act) {
+      REAL(memcpy)(pnew_act, act, sizeof(__sanitizer_sigaction));
+      uptr cb = (uptr)pnew_act->sigaction;
+      uptr new_cb = (pnew_act->sa_flags & __sanitizer::sa_siginfo)
+                        ? (uptr)SignalAction
+                        : (uptr)SignalHandler;
+      if (cb != __sanitizer::sig_ign && cb != __sanitizer::sig_dfl) {
+        atomic_store(&sigactions[signo], cb, memory_order_relaxed);
+        pnew_act->sigaction = (void (*)(int, void *, void *))new_cb;
+      }
+    }
+    res = REAL(sigaction)(signo, pnew_act, oldact);
+    if (res == 0 && oldact) {
+      uptr cb = (uptr)oldact->sigaction;
+      if (cb != __sanitizer::sig_ign && cb != __sanitizer::sig_dfl) {
+        oldact->sigaction = (void (*)(int, void *, void *))old_cb;
+      }
+    }
+  } else {
+    res = REAL(sigaction)(signo, act, oldact);
+  }
+
+  if (res == 0 && oldact) {
+    __msan_unpoison(oldact, sizeof(__sanitizer_sigaction));
+  }
+  return res;
+}
+
+INTERCEPTOR(int, signal, int signo, uptr cb) {
+  ENSURE_MSAN_INITED();
+  if (flags()->wrap_signals) {
+    CHECK_LT(signo, kMaxSignals);
+    SpinMutexLock lock(&sigactions_mu);
+    if (cb != __sanitizer::sig_ign && cb != __sanitizer::sig_dfl) {
+      atomic_store(&sigactions[signo], cb, memory_order_relaxed);
+      cb = (uptr) SignalHandler;
+    }
+    return REAL(signal)(signo, cb);
+  } else {
+    return REAL(signal)(signo, cb);
+  }
+}
+
+extern "C" int pthread_attr_init(void *attr);
+extern "C" int pthread_attr_destroy(void *attr);
+
+static void *MsanThreadStartFunc(void *arg) {
+  MsanThread *t = (MsanThread *)arg;
+  SetCurrentThread(t);
+  return t->ThreadStart();
+}
+
+INTERCEPTOR(int, pthread_create, void *th, void *attr, void *(*callback)(void*),
+            void * param) {
+  ENSURE_MSAN_INITED(); // for GetTlsSize()
+  __sanitizer_pthread_attr_t myattr;
+  if (!attr) {
+    pthread_attr_init(&myattr);
+    attr = &myattr;
+  }
+
+  AdjustStackSize(attr);
+
+  MsanThread *t = MsanThread::Create(callback, param);
+
+  int res = REAL(pthread_create)(th, attr, MsanThreadStartFunc, t);
+
+  if (attr == &myattr)
+    pthread_attr_destroy(&myattr);
+  if (!res) {
+    __msan_unpoison(th, __sanitizer::pthread_t_sz);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, pthread_key_create, __sanitizer_pthread_key_t *key,
+            void (*dtor)(void *value)) {
+  if (msan_init_is_running) return REAL(pthread_key_create)(key, dtor);
+  ENSURE_MSAN_INITED();
+  int res = REAL(pthread_key_create)(key, dtor);
+  if (!res && key)
+    __msan_unpoison(key, sizeof(*key));
+  return res;
+}
+
+INTERCEPTOR(int, pthread_join, void *th, void **retval) {
+  ENSURE_MSAN_INITED();
+  int res = REAL(pthread_join)(th, retval);
+  if (!res && retval)
+    __msan_unpoison(retval, sizeof(*retval));
+  return res;
+}
+
+extern char *tzname[2];
+
+INTERCEPTOR(void, tzset, int fake) {
+  ENSURE_MSAN_INITED();
+  REAL(tzset)(fake);
+  if (tzname[0])
+    __msan_unpoison(tzname[0], REAL(strlen)(tzname[0]) + 1);
+  if (tzname[1])
+    __msan_unpoison(tzname[1], REAL(strlen)(tzname[1]) + 1);
+  return;
+}
+
+struct MSanAtExitRecord {
+  void (*func)(void *arg);
+  void *arg;
+};
+
+void MSanAtExitWrapper(void *arg) {
+  UnpoisonParam(1);
+  MSanAtExitRecord *r = (MSanAtExitRecord *)arg;
+  r->func(r->arg);
+  InternalFree(r);
+}
+
+// Unpoison argument shadow for C++ module destructors.
+INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
+            void *dso_handle) {
+  if (msan_init_is_running) return REAL(__cxa_atexit)(func, arg, dso_handle);
+  ENSURE_MSAN_INITED();
+  MSanAtExitRecord *r =
+      (MSanAtExitRecord *)InternalAlloc(sizeof(MSanAtExitRecord));
+  r->func = func;
+  r->arg = arg;
+  return REAL(__cxa_atexit)(MSanAtExitWrapper, r, dso_handle);
+}
+
+DECLARE_REAL(int, shmctl, int shmid, int cmd, void *buf)
+
+INTERCEPTOR(void *, shmat, int shmid, const void *shmaddr, int shmflg) {
+  ENSURE_MSAN_INITED();
+  void *p = REAL(shmat)(shmid, shmaddr, shmflg);
+  if (p != (void *)-1) {
+    __sanitizer_shmid_ds ds;
+    int res = REAL(shmctl)(shmid, shmctl_ipc_stat, &ds);
+    if (!res) {
+      __msan_unpoison(p, ds.shm_segsz);
+    }
+  }
+  return p;
+}
+
+static void BeforeFork() {
+  StackDepotLockAll();
+  ChainedOriginDepotLockAll();
+}
+
+static void AfterFork() {
+  ChainedOriginDepotUnlockAll();
+  StackDepotUnlockAll();
+}
+
+INTERCEPTOR(int, fork, void) {
+  ENSURE_MSAN_INITED();
+  BeforeFork();
+  int pid = REAL(fork)();
+  AfterFork();
+  return pid;
+}
+
+INTERCEPTOR(int, openpty, int *amaster, int *aslave, char *name,
+            const void *termp, const void *winp) {
+  ENSURE_MSAN_INITED();
+  InterceptorScope interceptor_scope;
+  int res = REAL(openpty)(amaster, aslave, name, termp, winp);
+  if (!res) {
+    __msan_unpoison(amaster, sizeof(*amaster));
+    __msan_unpoison(aslave, sizeof(*aslave));
+  }
+  return res;
+}
+
+INTERCEPTOR(int, forkpty, int *amaster, char *name, const void *termp,
+            const void *winp) {
+  ENSURE_MSAN_INITED();
+  InterceptorScope interceptor_scope;
+  int res = REAL(forkpty)(amaster, name, termp, winp);
+  if (res != -1)
+    __msan_unpoison(amaster, sizeof(*amaster));
+  return res;
+}
+
+struct MSanInterceptorContext {
+  bool in_interceptor_scope;
+};
+
+namespace __msan {
+
+int OnExit() {
+  // FIXME: ask frontend whether we need to return failure.
+  return 0;
+}
+
+} // namespace __msan
+
+// A version of CHECK_UNPOISONED using a saved scope value. Used in common
+// interceptors.
+#define CHECK_UNPOISONED_CTX(ctx, x, n)                         \
+  do {                                                          \
+    if (!((MSanInterceptorContext *)ctx)->in_interceptor_scope) \
+      CHECK_UNPOISONED_0(x, n);                                 \
+  } while (0)
+
+#define MSAN_INTERCEPT_FUNC(name)                                       \
+  do {                                                                  \
+    if ((!INTERCEPT_FUNCTION(name) || !REAL(name)))                     \
+      VReport(1, "MemorySanitizer: failed to intercept '" #name "'\n"); \
+  } while (0)
+
+#define COMMON_INTERCEPT_FUNCTION(name) MSAN_INTERCEPT_FUNC(name)
+#define COMMON_INTERCEPTOR_UNPOISON_PARAM(count)  \
+  UnpoisonParam(count)
+#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
+  __msan_unpoison(ptr, size)
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
+  CHECK_UNPOISONED_CTX(ctx, ptr, size)
+#define COMMON_INTERCEPTOR_INITIALIZE_RANGE(ptr, size) \
+  __msan_unpoison(ptr, size)
+#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)                  \
+  if (msan_init_is_running) return REAL(func)(__VA_ARGS__);       \
+  MSanInterceptorContext msan_ctx = {IsInInterceptorScope()};     \
+  ctx = (void *)&msan_ctx;                                        \
+  (void)ctx;                                                      \
+  InterceptorScope interceptor_scope;                             \
+  __msan_unpoison(__errno_location(), sizeof(int)); /* NOLINT */  \
+  ENSURE_MSAN_INITED();
+#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
+  do {                                            \
+  } while (false)
+#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
+  do {                                         \
+  } while (false)
+#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
+  do {                                         \
+  } while (false)
+#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
+  do {                                                      \
+  } while (false)
+#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) \
+  do {                                                \
+  } while (false)  // FIXME
+#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
+  do {                                                         \
+  } while (false)  // FIXME
+#define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
+#define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit()
+#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle)                    \
+  do {                                                                         \
+    link_map *map = GET_LINK_MAP_BY_DLOPEN_HANDLE((handle));                   \
+    if (filename && map)                                                       \
+      ForEachMappedRegion(map, __msan_unpoison);                               \
+  } while (false)
+
+#define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end)                           \
+  if (MsanThread *t = GetCurrentThread()) {                                    \
+    *begin = t->tls_begin();                                                   \
+    *end = t->tls_end();                                                       \
+  } else {                                                                     \
+    *begin = *end = 0;                                                         \
+  }
+
+#include "sanitizer_common/sanitizer_common_interceptors.inc"
+
+#define COMMON_SYSCALL_PRE_READ_RANGE(p, s) CHECK_UNPOISONED(p, s)
+#define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) \
+  do {                                       \
+  } while (false)
+#define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
+  do {                                       \
+  } while (false)
+#define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) __msan_unpoison(p, s)
+#include "sanitizer_common/sanitizer_common_syscalls.inc"
+
+// These interface functions reside here so that they can use
+// REAL(memset), etc.
+void __msan_unpoison(const void *a, uptr size) {
+  if (!MEM_IS_APP(a)) return;
+  SetShadow(a, size, 0);
+}
+
+void __msan_poison(const void *a, uptr size) {
+  if (!MEM_IS_APP(a)) return;
+  SetShadow(a, size, __msan::flags()->poison_heap_with_zeroes ? 0 : -1);
+}
+
+void __msan_poison_stack(void *a, uptr size) {
+  if (!MEM_IS_APP(a)) return;
+  SetShadow(a, size, __msan::flags()->poison_stack_with_zeroes ? 0 : -1);
+}
+
+void __msan_clear_and_unpoison(void *a, uptr size) {
+  REAL(memset)(a, 0, size);
+  SetShadow(a, size, 0);
+}
+
+void *__msan_memcpy(void *dest, const void *src, SIZE_T n) {
+  if (!msan_inited) return internal_memcpy(dest, src, n);
+  if (msan_init_is_running || __msan::IsInSymbolizer())
+    return REAL(memcpy)(dest, src, n);
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  void *res = REAL(memcpy)(dest, src, n);
+  CopyShadowAndOrigin(dest, src, n, &stack);
+  return res;
+}
+
+void *__msan_memset(void *s, int c, SIZE_T n) {
+  if (!msan_inited) return internal_memset(s, c, n);
+  if (msan_init_is_running) return REAL(memset)(s, c, n);
+  ENSURE_MSAN_INITED();
+  void *res = REAL(memset)(s, c, n);
+  __msan_unpoison(s, n);
+  return res;
+}
+
+void *__msan_memmove(void *dest, const void *src, SIZE_T n) {
+  if (!msan_inited) return internal_memmove(dest, src, n);
+  if (msan_init_is_running) return REAL(memmove)(dest, src, n);
+  ENSURE_MSAN_INITED();
+  GET_STORE_STACK_TRACE;
+  void *res = REAL(memmove)(dest, src, n);
+  MoveShadowAndOrigin(dest, src, n, &stack);
+  return res;
+}
+
+void __msan_unpoison_string(const char* s) {
+  if (!MEM_IS_APP(s)) return;
+  __msan_unpoison(s, REAL(strlen)(s) + 1);
+}
+
+namespace __msan {
+
+void InitializeInterceptors() {
+  static int inited = 0;
+  CHECK_EQ(inited, 0);
+  InitializeCommonInterceptors();
+
+  INTERCEPT_FUNCTION(mmap);
+  MSAN_MAYBE_INTERCEPT_MMAP64;
+  INTERCEPT_FUNCTION(posix_memalign);
+  MSAN_MAYBE_INTERCEPT_MEMALIGN;
+  INTERCEPT_FUNCTION(__libc_memalign);
+  INTERCEPT_FUNCTION(valloc);
+  MSAN_MAYBE_INTERCEPT_PVALLOC;
+  INTERCEPT_FUNCTION(malloc);
+  INTERCEPT_FUNCTION(calloc);
+  INTERCEPT_FUNCTION(realloc);
+  INTERCEPT_FUNCTION(free);
+  MSAN_MAYBE_INTERCEPT_CFREE;
+  INTERCEPT_FUNCTION(malloc_usable_size);
+  MSAN_MAYBE_INTERCEPT_MALLINFO;
+  MSAN_MAYBE_INTERCEPT_MALLOPT;
+  MSAN_MAYBE_INTERCEPT_MALLOC_STATS;
+  INTERCEPT_FUNCTION(fread);
+  MSAN_MAYBE_INTERCEPT_FREAD_UNLOCKED;
+  INTERCEPT_FUNCTION(readlink);
+  INTERCEPT_FUNCTION(memcpy);
+  INTERCEPT_FUNCTION(memccpy);
+  INTERCEPT_FUNCTION(mempcpy);
+  INTERCEPT_FUNCTION(memset);
+  INTERCEPT_FUNCTION(memmove);
+  INTERCEPT_FUNCTION(bcopy);
+  INTERCEPT_FUNCTION(wmemset);
+  INTERCEPT_FUNCTION(wmemcpy);
+  INTERCEPT_FUNCTION(wmempcpy);
+  INTERCEPT_FUNCTION(wmemmove);
+  INTERCEPT_FUNCTION(strcpy);  // NOLINT
+  INTERCEPT_FUNCTION(stpcpy);  // NOLINT
+  INTERCEPT_FUNCTION(strdup);
+  MSAN_MAYBE_INTERCEPT___STRDUP;
+  INTERCEPT_FUNCTION(strndup);
+  MSAN_MAYBE_INTERCEPT___STRNDUP;
+  INTERCEPT_FUNCTION(strncpy);  // NOLINT
+  INTERCEPT_FUNCTION(strlen);
+  INTERCEPT_FUNCTION(strnlen);
+  INTERCEPT_FUNCTION(gcvt);
+  INTERCEPT_FUNCTION(strcat);  // NOLINT
+  INTERCEPT_FUNCTION(strncat);  // NOLINT
+  INTERCEPT_STRTO(strtod);
+  INTERCEPT_STRTO(strtof);
+  INTERCEPT_STRTO(strtold);
+  INTERCEPT_STRTO(strtol);
+  INTERCEPT_STRTO(strtoul);
+  INTERCEPT_STRTO(strtoll);
+  INTERCEPT_STRTO(strtoull);
+  INTERCEPT_STRTO(wcstod);
+  INTERCEPT_STRTO(wcstof);
+  INTERCEPT_STRTO(wcstold);
+  INTERCEPT_STRTO(wcstol);
+  INTERCEPT_STRTO(wcstoul);
+  INTERCEPT_STRTO(wcstoll);
+  INTERCEPT_STRTO(wcstoull);
+  INTERCEPT_FUNCTION(vswprintf);
+  INTERCEPT_FUNCTION(swprintf);
+  INTERCEPT_FUNCTION(strxfrm);
+  INTERCEPT_FUNCTION(strxfrm_l);
+  INTERCEPT_FUNCTION(strftime);
+  INTERCEPT_FUNCTION(strftime_l);
+  MSAN_MAYBE_INTERCEPT___STRFTIME_L;
+  INTERCEPT_FUNCTION(wcsftime);
+  INTERCEPT_FUNCTION(wcsftime_l);
+  MSAN_MAYBE_INTERCEPT___WCSFTIME_L;
+  INTERCEPT_FUNCTION(mbtowc);
+  INTERCEPT_FUNCTION(mbrtowc);
+  INTERCEPT_FUNCTION(wcslen);
+  INTERCEPT_FUNCTION(wcschr);
+  INTERCEPT_FUNCTION(wcscpy);
+  INTERCEPT_FUNCTION(wcscmp);
+  INTERCEPT_FUNCTION(getenv);
+  INTERCEPT_FUNCTION(setenv);
+  INTERCEPT_FUNCTION(putenv);
+  INTERCEPT_FUNCTION(gettimeofday);
+  INTERCEPT_FUNCTION(fcvt);
+  MSAN_MAYBE_INTERCEPT___FXSTAT;
+  MSAN_INTERCEPT_FSTATAT;
+  MSAN_INTERCEPT_STAT;
+  MSAN_MAYBE_INTERCEPT___LXSTAT;
+  MSAN_MAYBE_INTERCEPT___FXSTAT64;
+  MSAN_MAYBE_INTERCEPT___FXSTATAT64;
+  MSAN_MAYBE_INTERCEPT___XSTAT64;
+  MSAN_MAYBE_INTERCEPT___LXSTAT64;
+  INTERCEPT_FUNCTION(pipe);
+  INTERCEPT_FUNCTION(pipe2);
+  INTERCEPT_FUNCTION(socketpair);
+  INTERCEPT_FUNCTION(fgets);
+  MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED;
+  INTERCEPT_FUNCTION(getrlimit);
+  MSAN_MAYBE_INTERCEPT_GETRLIMIT64;
+  MSAN_INTERCEPT_UNAME;
+  INTERCEPT_FUNCTION(gethostname);
+  MSAN_MAYBE_INTERCEPT_EPOLL_WAIT;
+  MSAN_MAYBE_INTERCEPT_EPOLL_PWAIT;
+  INTERCEPT_FUNCTION(recv);
+  INTERCEPT_FUNCTION(recvfrom);
+  INTERCEPT_FUNCTION(dladdr);
+  INTERCEPT_FUNCTION(dlerror);
+  INTERCEPT_FUNCTION(dl_iterate_phdr);
+  INTERCEPT_FUNCTION(getrusage);
+  INTERCEPT_FUNCTION(sigaction);
+  INTERCEPT_FUNCTION(signal);
+  INTERCEPT_FUNCTION(pthread_create);
+  INTERCEPT_FUNCTION(pthread_key_create);
+  INTERCEPT_FUNCTION(pthread_join);
+  INTERCEPT_FUNCTION(tzset);
+  INTERCEPT_FUNCTION(__cxa_atexit);
+  INTERCEPT_FUNCTION(shmat);
+  INTERCEPT_FUNCTION(fork);
+  INTERCEPT_FUNCTION(openpty);
+  INTERCEPT_FUNCTION(forkpty);
+
+  inited = 1;
+}
+} // namespace __msan
diff --git a/compiler-rt/lib/msan/msan_interface_internal.h b/compiler-rt/lib/msan/msan_interface_internal.h
new file mode 100644
index 0000000..c1e02ce
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_interface_internal.h
@@ -0,0 +1,169 @@
+//===-- msan_interface_internal.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Private MSan interface header.
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_INTERFACE_INTERNAL_H
+#define MSAN_INTERFACE_INTERNAL_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+extern "C" {
+// FIXME: document all interface functions.
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __msan_get_track_origins();
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_init();
+
+// Print a warning and maybe return.
+// This function can die based on common_flags()->exitcode.
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_warning();
+
+// Print a warning and die.
+// Intrumentation inserts calls to this function when building in "fast" mode
+// (i.e. -mllvm -msan-keep-going)
+SANITIZER_INTERFACE_ATTRIBUTE __attribute__((noreturn))
+void __msan_warning_noreturn();
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_warning_1(u8 s, u32 o);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_warning_2(u16 s, u32 o);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_warning_4(u32 s, u32 o);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_warning_8(u64 s, u32 o);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_store_origin_1(u8 s, void *p, u32 o);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_store_origin_2(u16 s, void *p, u32 o);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_store_origin_4(u32 s, void *p, u32 o);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_maybe_store_origin_8(u64 s, void *p, u32 o);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_unpoison(const void *a, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_unpoison_string(const char *s);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_clear_and_unpoison(void *a, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE
+void* __msan_memcpy(void *dst, const void *src, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE
+void* __msan_memset(void *s, int c, uptr n);
+SANITIZER_INTERFACE_ATTRIBUTE
+void* __msan_memmove(void* dest, const void* src, uptr n);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_poison(const void *a, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_poison_stack(void *a, uptr size);
+
+// Copy size bytes from src to dst and unpoison the result.
+// Useful to implement unsafe loads.
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_load_unpoisoned(void *src, uptr size, void *dst);
+
+// Returns the offset of the first (at least partially) poisoned byte,
+// or -1 if the whole range is good.
+SANITIZER_INTERFACE_ATTRIBUTE
+sptr __msan_test_shadow(const void *x, uptr size);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_check_mem_is_initialized(const void *x, uptr size);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_set_origin(const void *a, uptr size, u32 origin);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_set_alloca_origin(void *a, uptr size, char *descr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_set_alloca_origin4(void *a, uptr size, char *descr, uptr pc);
+SANITIZER_INTERFACE_ATTRIBUTE
+u32 __msan_chain_origin(u32 id);
+SANITIZER_INTERFACE_ATTRIBUTE
+u32 __msan_get_origin(const void *a);
+
+// Test that this_id is a descendant of prev_id (or they are simply equal).
+// "descendant" here means that are part of the same chain, created with
+// __msan_chain_origin.
+SANITIZER_INTERFACE_ATTRIBUTE
+int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id);
+
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_clear_on_return();
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_set_keep_going(int keep_going);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __msan_set_poison_in_malloc(int do_poison);
+
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+/* OPTIONAL */ const char* __msan_default_options();
+
+// For testing.
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_set_expect_umr(int expect_umr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_print_shadow(const void *x, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_dump_shadow(const void *x, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE
+int  __msan_has_dynamic_component();
+
+// For testing.
+SANITIZER_INTERFACE_ATTRIBUTE
+u32 __msan_get_umr_origin();
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_partial_poison(const void* data, void* shadow, uptr size);
+
+// Tell MSan about newly allocated memory (ex.: custom allocator).
+// Memory will be marked uninitialized, with origin at the call site.
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_allocated_memory(const void* data, uptr size);
+
+// Tell MSan about newly destroyed memory. Memory will be marked
+// uninitialized.
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_dtor_callback(const void* data, uptr size);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+u16 __sanitizer_unaligned_load16(const uu16 *p);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+u32 __sanitizer_unaligned_load32(const uu32 *p);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+u64 __sanitizer_unaligned_load64(const uu64 *p);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store16(uu16 *p, u16 x);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store32(uu32 *p, u32 x);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store64(uu64 *p, u64 x);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_set_death_callback(void (*callback)(void));
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __msan_copy_shadow(void *dst, const void *src, uptr size);
+}  // extern "C"
+
+#endif  // MSAN_INTERFACE_INTERNAL_H
diff --git a/compiler-rt/lib/msan/msan_linux.cc b/compiler-rt/lib/msan/msan_linux.cc
new file mode 100644
index 0000000..ab3be91
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_linux.cc
@@ -0,0 +1,215 @@
+//===-- msan_linux.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Linux- and FreeBSD-specific code.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+
+#include "msan.h"
+#include "msan_thread.h"
+
+#include <elf.h>
+#include <link.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <unwind.h>
+#include <execinfo.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+
+namespace __msan {
+
+void ReportMapRange(const char *descr, uptr beg, uptr size) {
+  if (size > 0) {
+    uptr end = beg + size - 1;
+    VPrintf(1, "%s : %p - %p\n", descr, beg, end);
+  }
+}
+
+static bool CheckMemoryRangeAvailability(uptr beg, uptr size) {
+  if (size > 0) {
+    uptr end = beg + size - 1;
+    if (!MemoryRangeIsAvailable(beg, end)) {
+      Printf("FATAL: Memory range %p - %p is not available.\n", beg, end);
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool ProtectMemoryRange(uptr beg, uptr size, const char *name) {
+  if (size > 0) {
+    void *addr = MmapNoAccess(beg, size, name);
+    if (beg == 0 && addr) {
+      // Depending on the kernel configuration, we may not be able to protect
+      // the page at address zero.
+      uptr gap = 16 * GetPageSizeCached();
+      beg += gap;
+      size -= gap;
+      addr = MmapNoAccess(beg, size, name);
+    }
+    if ((uptr)addr != beg) {
+      uptr end = beg + size - 1;
+      Printf("FATAL: Cannot protect memory range %p - %p.\n", beg, end);
+      return false;
+    }
+  }
+  return true;
+}
+
+static void CheckMemoryLayoutSanity() {
+  uptr prev_end = 0;
+  for (unsigned i = 0; i < kMemoryLayoutSize; ++i) {
+    uptr start = kMemoryLayout[i].start;
+    uptr end = kMemoryLayout[i].end;
+    MappingDesc::Type type = kMemoryLayout[i].type;
+    CHECK_LT(start, end);
+    CHECK_EQ(prev_end, start);
+    CHECK(addr_is_type(start, type));
+    CHECK(addr_is_type((start + end) / 2, type));
+    CHECK(addr_is_type(end - 1, type));
+    if (type == MappingDesc::APP) {
+      uptr addr = start;
+      CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
+      CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
+      CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
+
+      addr = (start + end) / 2;
+      CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
+      CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
+      CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
+
+      addr = end - 1;
+      CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
+      CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
+      CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
+    }
+    prev_end = end;
+  }
+}
+
+bool InitShadow(bool init_origins) {
+  // Let user know mapping parameters first.
+  VPrintf(1, "__msan_init %p\n", &__msan_init);
+  for (unsigned i = 0; i < kMemoryLayoutSize; ++i)
+    VPrintf(1, "%s: %zx - %zx\n", kMemoryLayout[i].name, kMemoryLayout[i].start,
+            kMemoryLayout[i].end - 1);
+
+  CheckMemoryLayoutSanity();
+
+  if (!MEM_IS_APP(&__msan_init)) {
+    Printf("FATAL: Code %p is out of application range. Non-PIE build?\n",
+           (uptr)&__msan_init);
+    return false;
+  }
+
+  const uptr maxVirtualAddress = GetMaxVirtualAddress();
+
+  for (unsigned i = 0; i < kMemoryLayoutSize; ++i) {
+    uptr start = kMemoryLayout[i].start;
+    uptr end = kMemoryLayout[i].end;
+    uptr size= end - start;
+    MappingDesc::Type type = kMemoryLayout[i].type;
+
+    // Check if the segment should be mapped based on platform constraints.
+    if (start >= maxVirtualAddress)
+      continue;
+
+    bool map = type == MappingDesc::SHADOW ||
+               (init_origins && type == MappingDesc::ORIGIN);
+    bool protect = type == MappingDesc::INVALID ||
+                   (!init_origins && type == MappingDesc::ORIGIN);
+    CHECK(!(map && protect));
+    if (!map && !protect)
+      CHECK(type == MappingDesc::APP);
+    if (map) {
+      if (!CheckMemoryRangeAvailability(start, size))
+        return false;
+      if ((uptr)MmapFixedNoReserve(start, size, kMemoryLayout[i].name) != start)
+        return false;
+      if (common_flags()->use_madv_dontdump)
+        DontDumpShadowMemory(start, size);
+    }
+    if (protect) {
+      if (!CheckMemoryRangeAvailability(start, size))
+        return false;
+      if (!ProtectMemoryRange(start, size, kMemoryLayout[i].name))
+        return false;
+    }
+  }
+
+  return true;
+}
+
+static void MsanAtExit(void) {
+  if (flags()->print_stats && (flags()->atexit || msan_report_count > 0))
+    ReportStats();
+  if (msan_report_count > 0) {
+    ReportAtExitStatistics();
+    if (common_flags()->exitcode)
+      internal__exit(common_flags()->exitcode);
+  }
+}
+
+void InstallAtExitHandler() {
+  atexit(MsanAtExit);
+}
+
+// ---------------------- TSD ---------------- {{{1
+
+static pthread_key_t tsd_key;
+static bool tsd_key_inited = false;
+
+void MsanTSDInit(void (*destructor)(void *tsd)) {
+  CHECK(!tsd_key_inited);
+  tsd_key_inited = true;
+  CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
+}
+
+static THREADLOCAL MsanThread* msan_current_thread;
+
+MsanThread *GetCurrentThread() {
+  return msan_current_thread;
+}
+
+void SetCurrentThread(MsanThread *t) {
+  // Make sure we do not reset the current MsanThread.
+  CHECK_EQ(0, msan_current_thread);
+  msan_current_thread = t;
+  // Make sure that MsanTSDDtor gets called at the end.
+  CHECK(tsd_key_inited);
+  pthread_setspecific(tsd_key, (void *)t);
+}
+
+void MsanTSDDtor(void *tsd) {
+  MsanThread *t = (MsanThread*)tsd;
+  if (t->destructor_iterations_ > 1) {
+    t->destructor_iterations_--;
+    CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));
+    return;
+  }
+  msan_current_thread = nullptr;
+  // Make sure that signal handler can not see a stale current thread pointer.
+  atomic_signal_fence(memory_order_seq_cst);
+  MsanThread::TSDDtor(tsd);
+}
+
+} // namespace __msan
+
+#endif // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/msan/msan_new_delete.cc b/compiler-rt/lib/msan/msan_new_delete.cc
new file mode 100644
index 0000000..5401003
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_new_delete.cc
@@ -0,0 +1,58 @@
+//===-- msan_new_delete.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Interceptors for operators new and delete.
+//===----------------------------------------------------------------------===//
+
+#include "msan.h"
+#include "interception/interception.h"
+
+#if MSAN_REPLACE_OPERATORS_NEW_AND_DELETE
+
+#include <stddef.h>
+
+using namespace __msan;  // NOLINT
+
+// Fake std::nothrow_t to avoid including <new>.
+namespace std {
+  struct nothrow_t {};
+}  // namespace std
+
+
+#define OPERATOR_NEW_BODY \
+  GET_MALLOC_STACK_TRACE; \
+  return MsanReallocate(&stack, 0, size, sizeof(u64), false)
+
+INTERCEPTOR_ATTRIBUTE
+void *operator new(size_t size) { OPERATOR_NEW_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void *operator new[](size_t size) { OPERATOR_NEW_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void *operator new(size_t size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void *operator new[](size_t size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
+
+#define OPERATOR_DELETE_BODY \
+  GET_MALLOC_STACK_TRACE; \
+  if (ptr) MsanDeallocate(&stack, ptr)
+
+INTERCEPTOR_ATTRIBUTE
+void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; }
+INTERCEPTOR_ATTRIBUTE
+void operator delete[](void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY;
+}
+
+#endif // MSAN_REPLACE_OPERATORS_NEW_AND_DELETE
diff --git a/compiler-rt/lib/msan/msan_origin.h b/compiler-rt/lib/msan/msan_origin.h
new file mode 100644
index 0000000..36c168b
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_origin.h
@@ -0,0 +1,169 @@
+//===-- msan_origin.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Origin id utils.
+//===----------------------------------------------------------------------===//
+#ifndef MSAN_ORIGIN_H
+#define MSAN_ORIGIN_H
+
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "msan_chained_origin_depot.h"
+
+namespace __msan {
+
+// Origin handling.
+//
+// Origin is a 32-bit identifier that is attached to any uninitialized value in
+// the program and describes, more or less exactly, how this memory came to be
+// uninitialized.
+//
+// There are 3 kinds of origin ids:
+// 1xxx xxxx xxxx xxxx   heap origin id
+// 0000 xxxx xxxx xxxx   stack origin id
+// 0zzz xxxx xxxx xxxx   chained origin id
+//
+// Heap origin id describes a heap memory allocation and contains (in the xxx
+// part) a value of StackDepot.
+//
+// Stack origin id describes a stack memory allocation and contains (in the xxx
+// part) an index into StackOriginDescr and StackOriginPC. We don't store a
+// stack trace for such origins for performance reasons.
+//
+// Chained origin id describes an event of storing an uninitialized value to
+// memory. The xxx part is a value of ChainedOriginDepot, which is a mapping of
+// (stack_id, prev_id) -> id, where
+//  * stack_id describes the event.
+//    StackDepot keeps a mapping between those and corresponding stack traces.
+//  * prev_id is another origin id that describes the earlier part of the
+//    uninitialized value history.
+// Following a chain of prev_id provides the full recorded history of an
+// uninitialized value.
+//
+// This, effectively, defines a tree (or 2 trees, see below) where nodes are
+// points in value history marked with origin ids, and edges are events that are
+// marked with stack_id.
+//
+// The "zzz" bits of chained origin id are used to store the length (or depth)
+// of the origin chain.
+
+class Origin {
+ public:
+  static bool isValidId(u32 id) { return id != 0 && id != (u32)-1; }
+
+  u32 raw_id() const { return raw_id_; }
+  bool isHeapOrigin() const {
+    // 1xxx xxxx xxxx xxxx
+    return raw_id_ >> kHeapShift == 0;
+  }
+  bool isStackOrigin() const {
+    // 1000 xxxx xxxx xxxx
+    return (raw_id_ >> kDepthShift) == (1 << kDepthBits);
+  }
+  bool isChainedOrigin() const {
+    // 1zzz xxxx xxxx xxxx, zzz != 000
+    return (raw_id_ >> kDepthShift) > (1 << kDepthBits);
+  }
+  u32 getChainedId() const {
+    CHECK(isChainedOrigin());
+    return raw_id_ & kChainedIdMask;
+  }
+  u32 getStackId() const {
+    CHECK(isStackOrigin());
+    return raw_id_ & kChainedIdMask;
+  }
+  u32 getHeapId() const {
+    CHECK(isHeapOrigin());
+    return raw_id_ & kHeapIdMask;
+  }
+
+  // Returns the next origin in the chain and the current stack trace.
+  Origin getNextChainedOrigin(StackTrace *stack) const {
+    CHECK(isChainedOrigin());
+    u32 prev_id;
+    u32 stack_id = ChainedOriginDepotGet(getChainedId(), &prev_id);
+    if (stack) *stack = StackDepotGet(stack_id);
+    return Origin(prev_id);
+  }
+
+  StackTrace getStackTraceForHeapOrigin() const {
+    return StackDepotGet(getHeapId());
+  }
+
+  static Origin CreateStackOrigin(u32 id) {
+    CHECK((id & kStackIdMask) == id);
+    return Origin((1 << kHeapShift) | id);
+  }
+
+  static Origin CreateHeapOrigin(StackTrace *stack) {
+    u32 stack_id = StackDepotPut(*stack);
+    CHECK(stack_id);
+    CHECK((stack_id & kHeapIdMask) == stack_id);
+    return Origin(stack_id);
+  }
+
+  static Origin CreateChainedOrigin(Origin prev, StackTrace *stack) {
+    int depth = prev.isChainedOrigin() ? prev.depth() : 0;
+    // depth is the length of the chain minus 1.
+    // origin_history_size of 0 means unlimited depth.
+    if (flags()->origin_history_size > 0) {
+      if (depth + 1 >= flags()->origin_history_size) {
+        return prev;
+      } else {
+        ++depth;
+        CHECK(depth < (1 << kDepthBits));
+      }
+    }
+
+    StackDepotHandle h = StackDepotPut_WithHandle(*stack);
+    if (!h.valid()) return prev;
+
+    if (flags()->origin_history_per_stack_limit > 0) {
+      int use_count = h.use_count();
+      if (use_count > flags()->origin_history_per_stack_limit) return prev;
+    }
+
+    u32 chained_id;
+    bool inserted = ChainedOriginDepotPut(h.id(), prev.raw_id(), &chained_id);
+    CHECK((chained_id & kChainedIdMask) == chained_id);
+
+    if (inserted && flags()->origin_history_per_stack_limit > 0)
+      h.inc_use_count_unsafe();
+
+    return Origin((1 << kHeapShift) | (depth << kDepthShift) | chained_id);
+  }
+
+  static Origin FromRawId(u32 id) {
+    return Origin(id);
+  }
+
+ private:
+  static const int kDepthBits = 3;
+  static const int kDepthShift = 32 - kDepthBits - 1;
+
+  static const int kHeapShift = 31;
+  static const u32 kChainedIdMask = ((u32)-1) >> (32 - kDepthShift);
+  static const u32 kStackIdMask = ((u32)-1) >> (32 - kDepthShift);
+  static const u32 kHeapIdMask = ((u32)-1) >> (32 - kHeapShift);
+
+  u32 raw_id_;
+
+  explicit Origin(u32 raw_id) : raw_id_(raw_id) {}
+
+  int depth() const {
+    CHECK(isChainedOrigin());
+    return (raw_id_ >> kDepthShift) & ((1 << kDepthBits) - 1);
+  }
+
+ public:
+  static const int kMaxDepth = (1 << kDepthBits) - 1;
+};
+
+}  // namespace __msan
+
+#endif  // MSAN_ORIGIN_H
diff --git a/compiler-rt/lib/msan/msan_poisoning.cc b/compiler-rt/lib/msan/msan_poisoning.cc
new file mode 100644
index 0000000..92134f6
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_poisoning.cc
@@ -0,0 +1,174 @@
+//===-- msan_poisoning.cc ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+
+#include "msan_poisoning.h"
+
+#include "interception/interception.h"
+#include "msan_origin.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+DECLARE_REAL(void *, memset, void *dest, int c, uptr n)
+DECLARE_REAL(void *, memcpy, void *dest, const void *src, uptr n)
+DECLARE_REAL(void *, memmove, void *dest, const void *src, uptr n)
+
+namespace __msan {
+
+u32 GetOriginIfPoisoned(uptr addr, uptr size) {
+  unsigned char *s = (unsigned char *)MEM_TO_SHADOW(addr);
+  for (uptr i = 0; i < size; ++i)
+    if (s[i]) return *(u32 *)SHADOW_TO_ORIGIN(((uptr)s + i) & ~3UL);
+  return 0;
+}
+
+void SetOriginIfPoisoned(uptr addr, uptr src_shadow, uptr size,
+                         u32 src_origin) {
+  uptr dst_s = MEM_TO_SHADOW(addr);
+  uptr src_s = src_shadow;
+  uptr src_s_end = src_s + size;
+
+  for (; src_s < src_s_end; ++dst_s, ++src_s)
+    if (*(u8 *)src_s) *(u32 *)SHADOW_TO_ORIGIN(dst_s & ~3UL) = src_origin;
+}
+
+void CopyOrigin(const void *dst, const void *src, uptr size,
+                StackTrace *stack) {
+  if (!MEM_IS_APP(dst) || !MEM_IS_APP(src)) return;
+
+  uptr d = (uptr)dst;
+  uptr beg = d & ~3UL;
+  // Copy left unaligned origin if that memory is poisoned.
+  if (beg < d) {
+    u32 o = GetOriginIfPoisoned((uptr)src, d - beg);
+    if (o) {
+      if (__msan_get_track_origins() > 1) o = ChainOrigin(o, stack);
+      *(u32 *)MEM_TO_ORIGIN(beg) = o;
+    }
+    beg += 4;
+  }
+
+  uptr end = (d + size) & ~3UL;
+  // If both ends fall into the same 4-byte slot, we are done.
+  if (end < beg) return;
+
+  // Copy right unaligned origin if that memory is poisoned.
+  if (end < d + size) {
+    u32 o = GetOriginIfPoisoned((uptr)src + (end - d), (d + size) - end);
+    if (o) {
+      if (__msan_get_track_origins() > 1) o = ChainOrigin(o, stack);
+      *(u32 *)MEM_TO_ORIGIN(end) = o;
+    }
+  }
+
+  if (beg < end) {
+    // Align src up.
+    uptr s = ((uptr)src + 3) & ~3UL;
+    // FIXME: factor out to msan_copy_origin_aligned
+    if (__msan_get_track_origins() > 1) {
+      u32 *src = (u32 *)MEM_TO_ORIGIN(s);
+      u32 *src_s = (u32 *)MEM_TO_SHADOW(s);
+      u32 *src_end = (u32 *)MEM_TO_ORIGIN(s + (end - beg));
+      u32 *dst = (u32 *)MEM_TO_ORIGIN(beg);
+      u32 src_o = 0;
+      u32 dst_o = 0;
+      for (; src < src_end; ++src, ++src_s, ++dst) {
+        if (!*src_s) continue;
+        if (*src != src_o) {
+          src_o = *src;
+          dst_o = ChainOrigin(src_o, stack);
+        }
+        *dst = dst_o;
+      }
+    } else {
+      REAL(memcpy)((void *)MEM_TO_ORIGIN(beg), (void *)MEM_TO_ORIGIN(s),
+                   end - beg);
+    }
+  }
+}
+
+void MoveShadowAndOrigin(const void *dst, const void *src, uptr size,
+                         StackTrace *stack) {
+  if (!MEM_IS_APP(dst)) return;
+  if (!MEM_IS_APP(src)) return;
+  if (src == dst) return;
+  REAL(memmove)((void *)MEM_TO_SHADOW((uptr)dst),
+                (void *)MEM_TO_SHADOW((uptr)src), size);
+  if (__msan_get_track_origins()) CopyOrigin(dst, src, size, stack);
+}
+
+void CopyShadowAndOrigin(const void *dst, const void *src, uptr size,
+                         StackTrace *stack) {
+  if (!MEM_IS_APP(dst)) return;
+  if (!MEM_IS_APP(src)) return;
+  REAL(memcpy)((void *)MEM_TO_SHADOW((uptr)dst),
+               (void *)MEM_TO_SHADOW((uptr)src), size);
+  if (__msan_get_track_origins()) CopyOrigin(dst, src, size, stack);
+}
+
+void CopyMemory(void *dst, const void *src, uptr size, StackTrace *stack) {
+  REAL(memcpy)(dst, src, size);
+  CopyShadowAndOrigin(dst, src, size, stack);
+}
+
+void SetShadow(const void *ptr, uptr size, u8 value) {
+  uptr PageSize = GetPageSizeCached();
+  uptr shadow_beg = MEM_TO_SHADOW(ptr);
+  uptr shadow_end = shadow_beg + size;
+  if (value ||
+      shadow_end - shadow_beg < common_flags()->clear_shadow_mmap_threshold) {
+    REAL(memset)((void *)shadow_beg, value, shadow_end - shadow_beg);
+  } else {
+    uptr page_beg = RoundUpTo(shadow_beg, PageSize);
+    uptr page_end = RoundDownTo(shadow_end, PageSize);
+
+    if (page_beg >= page_end) {
+      REAL(memset)((void *)shadow_beg, 0, shadow_end - shadow_beg);
+    } else {
+      if (page_beg != shadow_beg) {
+        REAL(memset)((void *)shadow_beg, 0, page_beg - shadow_beg);
+      }
+      if (page_end != shadow_end) {
+        REAL(memset)((void *)page_end, 0, shadow_end - page_end);
+      }
+      MmapFixedNoReserve(page_beg, page_end - page_beg);
+    }
+  }
+}
+
+void SetOrigin(const void *dst, uptr size, u32 origin) {
+  // Origin mapping is 4 bytes per 4 bytes of application memory.
+  // Here we extend the range such that its left and right bounds are both
+  // 4 byte aligned.
+  uptr x = MEM_TO_ORIGIN((uptr)dst);
+  uptr beg = x & ~3UL;               // align down.
+  uptr end = (x + size + 3) & ~3UL;  // align up.
+  u64 origin64 = ((u64)origin << 32) | origin;
+  // This is like memset, but the value is 32-bit. We unroll by 2 to write
+  // 64 bits at once. May want to unroll further to get 128-bit stores.
+  if (beg & 7ULL) {
+    *(u32 *)beg = origin;
+    beg += 4;
+  }
+  for (uptr addr = beg; addr < (end & ~7UL); addr += 8) *(u64 *)addr = origin64;
+  if (end & 7ULL) *(u32 *)(end - 4) = origin;
+}
+
+void PoisonMemory(const void *dst, uptr size, StackTrace *stack) {
+  SetShadow(dst, size, (u8)-1);
+
+  if (__msan_get_track_origins()) {
+    Origin o = Origin::CreateHeapOrigin(stack);
+    SetOrigin(dst, size, o.raw_id());
+  }
+}
+
+}  // namespace __msan
diff --git a/compiler-rt/lib/msan/msan_poisoning.h b/compiler-rt/lib/msan/msan_poisoning.h
new file mode 100644
index 0000000..edacbee
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_poisoning.h
@@ -0,0 +1,59 @@
+//===-- msan_poisoning.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_POISONING_H
+#define MSAN_POISONING_H
+
+#include "msan.h"
+
+namespace __msan {
+
+// Return origin for the first poisoned byte in the memory range, or 0.
+u32 GetOriginIfPoisoned(uptr addr, uptr size);
+
+// Walk [addr, addr+size) app memory region, copying origin tags from the
+// corresponding positions in [src_origin, src_origin+size) where the
+// corresponding shadow in [src_shadow, src_shadow+size) is non-zero.
+void SetOriginIfPoisoned(uptr addr, uptr src_shadow, uptr size, u32 src_origin);
+
+// Copy origin from src (app address) to dst (app address), creating chained
+// origin ids as necessary, without overriding origin for fully initialized
+// quads.
+void CopyOrigin(const void *dst, const void *src, uptr size, StackTrace *stack);
+
+// memmove() shadow and origin. Dst and src are application addresses.
+// See CopyOrigin() for the origin copying logic.
+void MoveShadowAndOrigin(const void *dst, const void *src, uptr size,
+                         StackTrace *stack);
+
+// memcpy() shadow and origin. Dst and src are application addresses.
+// See CopyOrigin() for the origin copying logic.
+void CopyShadowAndOrigin(const void *dst, const void *src, uptr size,
+                         StackTrace *stack);
+
+// memcpy() app memory, and do "the right thing" to the corresponding shadow and
+// origin regions.
+void CopyMemory(void *dst, const void *src, uptr size, StackTrace *stack);
+
+// Fill shadow will value. Ptr is an application address.
+void SetShadow(const void *ptr, uptr size, u8 value);
+
+// Set origin for the memory region.
+void SetOrigin(const void *dst, uptr size, u32 origin);
+
+// Mark memory region uninitialized, with origins.
+void PoisonMemory(const void *dst, uptr size, StackTrace *stack);
+
+}  // namespace __msan
+
+#endif  // MSAN_POISONING_H
diff --git a/compiler-rt/lib/msan/msan_report.cc b/compiler-rt/lib/msan/msan_report.cc
new file mode 100644
index 0000000..ddb8070
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_report.cc
@@ -0,0 +1,277 @@
+//===-- msan_report.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// Error reporting.
+//===----------------------------------------------------------------------===//
+
+#include "msan.h"
+#include "msan_chained_origin_depot.h"
+#include "msan_origin.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "sanitizer_common/sanitizer_report_decorator.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+using namespace __sanitizer;
+
+namespace __msan {
+
+class Decorator: public __sanitizer::SanitizerCommonDecorator {
+ public:
+  Decorator() : SanitizerCommonDecorator() { }
+  const char *Warning()    { return Red(); }
+  const char *Origin()     { return Magenta(); }
+  const char *Name()   { return Green(); }
+  const char *End()    { return Default(); }
+};
+
+static void DescribeStackOrigin(const char *so, uptr pc) {
+  Decorator d;
+  char *s = internal_strdup(so);
+  char *sep = internal_strchr(s, '@');
+  CHECK(sep);
+  *sep = '\0';
+  Printf("%s", d.Origin());
+  Printf(
+      "  %sUninitialized value was created by an allocation of '%s%s%s'"
+      " in the stack frame of function '%s%s%s'%s\n",
+      d.Origin(), d.Name(), s, d.Origin(), d.Name(), sep + 1, d.Origin(),
+      d.End());
+  InternalFree(s);
+
+  if (pc) {
+    // For some reason function address in LLVM IR is 1 less then the address
+    // of the first instruction.
+    pc = StackTrace::GetNextInstructionPc(pc);
+    StackTrace(&pc, 1).Print();
+  }
+}
+
+static void DescribeOrigin(u32 id) {
+  VPrintf(1, "  raw origin id: %d\n", id);
+  Decorator d;
+  Origin o = Origin::FromRawId(id);
+  while (o.isChainedOrigin()) {
+    StackTrace stack;
+    o = o.getNextChainedOrigin(&stack);
+    Printf("  %sUninitialized value was stored to memory at%s\n", d.Origin(),
+        d.End());
+    stack.Print();
+  }
+  if (o.isStackOrigin()) {
+    uptr pc;
+    const char *so = GetStackOriginDescr(o.getStackId(), &pc);
+    DescribeStackOrigin(so, pc);
+  } else {
+    StackTrace stack = o.getStackTraceForHeapOrigin();
+    switch (stack.tag) {
+      case StackTrace::TAG_ALLOC:
+        Printf("  %sUninitialized value was created by a heap allocation%s\n",
+               d.Origin(), d.End());
+        break;
+      case StackTrace::TAG_DEALLOC:
+        Printf("  %sUninitialized value was created by a heap deallocation%s\n",
+               d.Origin(), d.End());
+        break;
+      case STACK_TRACE_TAG_POISON:
+        Printf("  %sMemory was marked as uninitialized%s\n", d.Origin(),
+               d.End());
+        break;
+      default:
+        Printf("  %sUninitialized value was created%s\n", d.Origin(), d.End());
+        break;
+    }
+    stack.Print();
+  }
+}
+
+void ReportUMR(StackTrace *stack, u32 origin) {
+  if (!__msan::flags()->report_umrs) return;
+
+  SpinMutexLock l(&CommonSanitizerReportMutex);
+
+  Decorator d;
+  Printf("%s", d.Warning());
+  Report("WARNING: MemorySanitizer: use-of-uninitialized-value\n");
+  Printf("%s", d.End());
+  stack->Print();
+  if (origin) {
+    DescribeOrigin(origin);
+  }
+  ReportErrorSummary("use-of-uninitialized-value", stack);
+}
+
+void ReportExpectedUMRNotFound(StackTrace *stack) {
+  SpinMutexLock l(&CommonSanitizerReportMutex);
+
+  Printf("WARNING: Expected use of uninitialized value not found\n");
+  stack->Print();
+}
+
+void ReportStats() {
+  SpinMutexLock l(&CommonSanitizerReportMutex);
+
+  if (__msan_get_track_origins() > 0) {
+    StackDepotStats *stack_depot_stats = StackDepotGetStats();
+    // FIXME: we want this at normal exit, too!
+    // FIXME: but only with verbosity=1 or something
+    Printf("Unique heap origins: %zu\n", stack_depot_stats->n_uniq_ids);
+    Printf("Stack depot allocated bytes: %zu\n", stack_depot_stats->allocated);
+
+    StackDepotStats *chained_origin_depot_stats = ChainedOriginDepotGetStats();
+    Printf("Unique origin histories: %zu\n",
+           chained_origin_depot_stats->n_uniq_ids);
+    Printf("History depot allocated bytes: %zu\n",
+           chained_origin_depot_stats->allocated);
+  }
+}
+
+void ReportAtExitStatistics() {
+  SpinMutexLock l(&CommonSanitizerReportMutex);
+
+  if (msan_report_count > 0) {
+    Decorator d;
+    Printf("%s", d.Warning());
+    Printf("MemorySanitizer: %d warnings reported.\n", msan_report_count);
+    Printf("%s", d.End());
+  }
+}
+
+class OriginSet {
+ public:
+  OriginSet() : next_id_(0) {}
+  int insert(u32 o) {
+    // Scan from the end for better locality.
+    for (int i = next_id_ - 1; i >= 0; --i)
+      if (origins_[i] == o) return i;
+    if (next_id_ == kMaxSize_) return OVERFLOW;
+    int id = next_id_++;
+    origins_[id] = o;
+    return id;
+  }
+  int size() { return next_id_; }
+  u32 get(int id) { return origins_[id]; }
+  static char asChar(int id) {
+    switch (id) {
+      case MISSING:
+        return '.';
+      case OVERFLOW:
+        return '*';
+      default:
+        return 'A' + id;
+    }
+  }
+  static const int OVERFLOW = -1;
+  static const int MISSING = -2;
+
+ private:
+  static const int kMaxSize_ = 'Z' - 'A' + 1;
+  u32 origins_[kMaxSize_];
+  int next_id_;
+};
+
+void DescribeMemoryRange(const void *x, uptr size) {
+  // Real limits.
+  uptr start = MEM_TO_SHADOW(x);
+  uptr end = start + size;
+  // Scan limits: align start down to 4; align size up to 16.
+  uptr s = start & ~3UL;
+  size = end - s;
+  size = (size + 15) & ~15UL;
+  uptr e = s + size;
+
+  // Single letter names to origin id mapping.
+  OriginSet origin_set;
+
+  uptr pos = 0;  // Offset from aligned start.
+  bool with_origins = __msan_get_track_origins();
+  // True if there is at least 1 poisoned bit in the last 4-byte group.
+  bool last_quad_poisoned;
+  int origin_ids[4];  // Single letter origin ids for the current line.
+
+  Decorator d;
+  Printf("%s", d.Warning());
+  Printf("Shadow map of [%p, %p), %zu bytes:\n", start, end, end - start);
+  Printf("%s", d.End());
+  while (s < e) {
+    // Line start.
+    if (pos % 16 == 0) {
+      for (int i = 0; i < 4; ++i) origin_ids[i] = -1;
+      Printf("%p:", s);
+    }
+    // Group start.
+    if (pos % 4 == 0) {
+      Printf(" ");
+      last_quad_poisoned = false;
+    }
+    // Print shadow byte.
+    if (s < start || s >= end) {
+      Printf("..");
+    } else {
+      unsigned char v = *(unsigned char *)s;
+      if (v) last_quad_poisoned = true;
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+      Printf("%x%x", v & 0xf, v >> 4);
+#else
+      Printf("%x%x", v >> 4, v & 0xf);
+#endif
+    }
+    // Group end.
+    if (pos % 4 == 3 && with_origins) {
+      int id = OriginSet::MISSING;
+      if (last_quad_poisoned) {
+        u32 o = *(u32 *)SHADOW_TO_ORIGIN(s - 3);
+        id = origin_set.insert(o);
+      }
+      origin_ids[(pos % 16) / 4] = id;
+    }
+    // Line end.
+    if (pos % 16 == 15) {
+      if (with_origins) {
+        Printf("  |");
+        for (int i = 0; i < 4; ++i) {
+          char c = OriginSet::asChar(origin_ids[i]);
+          Printf("%c", c);
+          if (i != 3) Printf(" ");
+        }
+        Printf("|");
+      }
+      Printf("\n");
+    }
+    size--;
+    s++;
+    pos++;
+  }
+
+  Printf("\n");
+
+  for (int i = 0; i < origin_set.size(); ++i) {
+    u32 o = origin_set.get(i);
+    Printf("Origin %c (origin_id %x):\n", OriginSet::asChar(i), o);
+    DescribeOrigin(o);
+  }
+}
+
+void ReportUMRInsideAddressRange(const char *what, const void *start, uptr size,
+                                 uptr offset) {
+  Decorator d;
+  Printf("%s", d.Warning());
+  Printf("%sUninitialized bytes in %s%s%s at offset %zu inside [%p, %zu)%s\n",
+         d.Warning(), d.Name(), what, d.Warning(), offset, start, size,
+         d.End());
+  if (__sanitizer::Verbosity())
+    DescribeMemoryRange(start, size);
+}
+
+}  // namespace __msan
diff --git a/compiler-rt/lib/msan/msan_thread.cc b/compiler-rt/lib/msan/msan_thread.cc
new file mode 100644
index 0000000..0ba4993
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_thread.cc
@@ -0,0 +1,82 @@
+
+#include "msan.h"
+#include "msan_thread.h"
+#include "msan_interface_internal.h"
+
+#include "sanitizer_common/sanitizer_tls_get_addr.h"
+
+namespace __msan {
+
+MsanThread *MsanThread::Create(thread_callback_t start_routine,
+                               void *arg) {
+  uptr PageSize = GetPageSizeCached();
+  uptr size = RoundUpTo(sizeof(MsanThread), PageSize);
+  MsanThread *thread = (MsanThread*)MmapOrDie(size, __func__);
+  thread->start_routine_ = start_routine;
+  thread->arg_ = arg;
+  thread->destructor_iterations_ = GetPthreadDestructorIterations();
+
+  return thread;
+}
+
+void MsanThread::SetThreadStackAndTls() {
+  uptr tls_size = 0;
+  uptr stack_size = 0;
+  GetThreadStackAndTls(IsMainThread(), &stack_bottom_, &stack_size,
+                       &tls_begin_, &tls_size);
+  stack_top_ = stack_bottom_ + stack_size;
+  tls_end_ = tls_begin_ + tls_size;
+
+  int local;
+  CHECK(AddrIsInStack((uptr)&local));
+}
+
+void MsanThread::ClearShadowForThreadStackAndTLS() {
+  __msan_unpoison((void *)stack_bottom_, stack_top_ - stack_bottom_);
+  if (tls_begin_ != tls_end_)
+    __msan_unpoison((void *)tls_begin_, tls_end_ - tls_begin_);
+  DTLS *dtls = DTLS_Get();
+  CHECK_NE(dtls, 0);
+  for (uptr i = 0; i < dtls->dtv_size; ++i)
+    __msan_unpoison((void *)(dtls->dtv[i].beg), dtls->dtv[i].size);
+}
+
+void MsanThread::Init() {
+  SetThreadStackAndTls();
+  CHECK(MEM_IS_APP(stack_bottom_));
+  CHECK(MEM_IS_APP(stack_top_ - 1));
+  ClearShadowForThreadStackAndTLS();
+}
+
+void MsanThread::TSDDtor(void *tsd) {
+  MsanThread *t = (MsanThread*)tsd;
+  t->Destroy();
+}
+
+void MsanThread::Destroy() {
+  malloc_storage().CommitBack();
+  // We also clear the shadow on thread destruction because
+  // some code may still be executing in later TSD destructors
+  // and we don't want it to have any poisoned stack.
+  ClearShadowForThreadStackAndTLS();
+  uptr size = RoundUpTo(sizeof(MsanThread), GetPageSizeCached());
+  UnmapOrDie(this, size);
+  DTLS_Destroy();
+}
+
+thread_return_t MsanThread::ThreadStart() {
+  Init();
+
+  if (!start_routine_) {
+    // start_routine_ == 0 if we're on the main thread or on one of the
+    // OS X libdispatch worker threads. But nobody is supposed to call
+    // ThreadStart() for the worker threads.
+    return 0;
+  }
+
+  thread_return_t res = start_routine_(arg_);
+
+  return res;
+}
+
+} // namespace __msan
diff --git a/compiler-rt/lib/msan/msan_thread.h b/compiler-rt/lib/msan/msan_thread.h
new file mode 100644
index 0000000..ed22e67
--- /dev/null
+++ b/compiler-rt/lib/msan/msan_thread.h
@@ -0,0 +1,71 @@
+//===-- msan_thread.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_THREAD_H
+#define MSAN_THREAD_H
+
+#include "msan_allocator.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+namespace __msan {
+
+class MsanThread {
+ public:
+  static MsanThread *Create(thread_callback_t start_routine, void *arg);
+  static void TSDDtor(void *tsd);
+  void Destroy();
+
+  void Init();  // Should be called from the thread itself.
+  thread_return_t ThreadStart();
+
+  uptr stack_top() { return stack_top_; }
+  uptr stack_bottom() { return stack_bottom_; }
+  uptr tls_begin() { return tls_begin_; }
+  uptr tls_end() { return tls_end_; }
+  bool IsMainThread() { return start_routine_ == nullptr; }
+
+  bool AddrIsInStack(uptr addr) {
+    return addr >= stack_bottom_ && addr < stack_top_;
+  }
+
+  bool InSignalHandler() { return in_signal_handler_; }
+  void EnterSignalHandler() { in_signal_handler_++; }
+  void LeaveSignalHandler() { in_signal_handler_--; }
+
+  MsanThreadLocalMallocStorage &malloc_storage() { return malloc_storage_; }
+
+  int destructor_iterations_;
+
+ private:
+  // NOTE: There is no MsanThread constructor. It is allocated
+  // via mmap() and *must* be valid in zero-initialized state.
+  void SetThreadStackAndTls();
+  void ClearShadowForThreadStackAndTLS();
+  thread_callback_t start_routine_;
+  void *arg_;
+  uptr stack_top_;
+  uptr stack_bottom_;
+  uptr tls_begin_;
+  uptr tls_end_;
+
+  unsigned in_signal_handler_;
+
+  MsanThreadLocalMallocStorage malloc_storage_;
+};
+
+MsanThread *GetCurrentThread();
+void SetCurrentThread(MsanThread *t);
+
+} // namespace __msan
+
+#endif // MSAN_THREAD_H
diff --git a/compiler-rt/lib/msan/tests/CMakeLists.txt b/compiler-rt/lib/msan/tests/CMakeLists.txt
new file mode 100644
index 0000000..087b1af
--- /dev/null
+++ b/compiler-rt/lib/msan/tests/CMakeLists.txt
@@ -0,0 +1,144 @@
+include(CheckCXXCompilerFlag)
+include(CompilerRTCompile)
+include(CompilerRTLink)
+
+include_directories(..)
+include_directories(../..)
+
+set(MSAN_LIBCXX_CFLAGS
+  -fsanitize=memory
+  -fsanitize-memory-track-origins
+  -Wno-pedantic)
+
+# Unittest sources and build flags.
+set(MSAN_UNITTEST_SOURCES msan_test.cc msan_test_main.cc)
+set(MSAN_LOADABLE_SOURCE msan_loadable.cc)
+set(MSAN_UNITTEST_HEADERS
+  msan_test_config.h
+  ../../../include/sanitizer/msan_interface.h
+)
+set(MSAN_UNITTEST_COMMON_CFLAGS
+  -nostdinc++
+  -isystem ${COMPILER_RT_LIBCXX_PATH}/include
+  ${COMPILER_RT_TEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/include
+  -I${COMPILER_RT_SOURCE_DIR}/lib
+  -I${COMPILER_RT_SOURCE_DIR}/lib/msan
+  -g
+  -O2
+  -fno-exceptions
+  -fno-omit-frame-pointer
+  -mno-omit-leaf-frame-pointer
+  -Wno-deprecated-declarations
+  -Wno-unused-variable
+  -Wno-zero-length-array
+  -Wno-uninitialized
+  -Werror=sign-compare
+)
+set(MSAN_UNITTEST_INSTRUMENTED_CFLAGS
+  ${MSAN_UNITTEST_COMMON_CFLAGS}
+  -fsanitize=memory
+  -fsanitize-memory-track-origins
+  -mllvm -msan-keep-going=1
+)
+set(MSAN_UNITTEST_LINK_FLAGS
+  -fsanitize=memory
+  # Don't need -stdlib=libc++ because we explicitly list libc++.so in the linker
+  # inputs.
+  # FIXME: we build libcxx without cxxabi and need libstdc++ to provide it.
+  -lstdc++
+)
+
+append_list_if(COMPILER_RT_HAS_LIBDL -ldl MSAN_UNITTEST_LINK_FLAGS)
+
+# Compile source for the given architecture, using compiler
+# options in ${ARGN}, and add it to the object list.
+macro(msan_compile obj_list source arch kind)
+  get_filename_component(basename ${source} NAME)
+  set(output_obj "${basename}.${arch}${kind}.o")
+  get_target_flags_for_arch(${arch} TARGET_CFLAGS)
+  set(COMPILE_DEPS ${MSAN_UNITTEST_HEADERS})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND COMPILE_DEPS gtest msan)
+  endif()
+  clang_compile(${output_obj} ${source}
+                CFLAGS ${ARGN} ${TARGET_CFLAGS}
+                DEPS ${COMPILE_DEPS})
+  list(APPEND ${obj_list} ${output_obj})
+endmacro()
+
+macro(msan_link_shared so_list so_name arch kind)
+  cmake_parse_arguments(SOURCE "" "" "OBJECTS;LINKFLAGS;DEPS" ${ARGN})
+  set(output_so "${CMAKE_CURRENT_BINARY_DIR}/${so_name}.${arch}${kind}.so")
+  get_target_flags_for_arch(${arch} TARGET_LINKFLAGS)
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND SOURCE_DEPS msan)
+  endif()
+  clang_link_shared(${output_so}
+                OBJECTS ${SOURCE_OBJECTS}
+                LINKFLAGS ${TARGET_LINKFLAGS} ${SOURCE_LINKFLAGS}
+                DEPS ${SOURCE_DEPS})
+  list(APPEND ${so_list} ${output_so})
+endmacro()
+
+# Main MemorySanitizer unit tests.
+add_custom_target(MsanUnitTests)
+set_target_properties(MsanUnitTests PROPERTIES FOLDER "MSan unit tests")
+
+# Adds MSan unit tests and benchmarks for architecture.
+macro(add_msan_tests_for_arch arch kind)
+  # Build gtest instrumented with MSan.
+  set(MSAN_INST_GTEST)
+  msan_compile(MSAN_INST_GTEST ${COMPILER_RT_GTEST_SOURCE} ${arch} "${kind}"
+                               ${MSAN_UNITTEST_INSTRUMENTED_CFLAGS} ${ARGN})
+
+  # Instrumented tests.
+  set(MSAN_INST_TEST_OBJECTS)
+  foreach (SOURCE ${MSAN_UNITTEST_SOURCES})
+    msan_compile(MSAN_INST_TEST_OBJECTS ${SOURCE} ${arch} "${kind}"
+                 ${MSAN_UNITTEST_INSTRUMENTED_CFLAGS} ${ARGN})
+  endforeach(SOURCE)
+
+  # Instrumented loadable module objects.
+  set(MSAN_INST_LOADABLE_OBJECTS)
+  msan_compile(MSAN_INST_LOADABLE_OBJECTS ${MSAN_LOADABLE_SOURCE} ${arch} "${kind}"
+               ${MSAN_UNITTEST_INSTRUMENTED_CFLAGS} "-fPIC" ${ARGN})
+
+  # Instrumented loadable library tests.
+  set(MSAN_LOADABLE_SO)
+  msan_link_shared(MSAN_LOADABLE_SO "libmsan_loadable" ${arch} "${kind}"
+                   OBJECTS ${MSAN_INST_LOADABLE_OBJECTS}
+                   DEPS ${MSAN_INST_LOADABLE_OBJECTS})
+
+  set(MSAN_TEST_OBJECTS ${MSAN_INST_TEST_OBJECTS} ${MSAN_INST_GTEST})
+  set(MSAN_TEST_DEPS ${MSAN_TEST_OBJECTS} libcxx_msan_${arch}
+                     ${MSAN_LOADABLE_SO})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND MSAN_TEST_DEPS msan)
+  endif()
+  get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
+  add_compiler_rt_test(MsanUnitTests "Msan-${arch}${kind}-Test" ${arch}
+    OBJECTS ${MSAN_TEST_OBJECTS} ${MSAN_LIBCXX_SO}
+    DEPS ${MSAN_TEST_DEPS}
+    LINK_FLAGS ${MSAN_UNITTEST_LINK_FLAGS}
+               ${TARGET_LINK_FLAGS}
+               "-Wl,-rpath=${CMAKE_CURRENT_BINARY_DIR}"
+               "-Wl,-rpath=${LIBCXX_PREFIX}/lib")
+endmacro()
+
+# We should only build MSan unit tests if we can build instrumented libcxx.
+if(COMPILER_RT_CAN_EXECUTE_TESTS AND COMPILER_RT_HAS_LIBCXX_SOURCES)
+  foreach(arch ${MSAN_SUPPORTED_ARCH})
+    get_target_flags_for_arch(${arch} TARGET_CFLAGS)
+    set(LIBCXX_PREFIX ${CMAKE_CURRENT_BINARY_DIR}/../libcxx_msan_${arch})
+    add_custom_libcxx(libcxx_msan_${arch} ${LIBCXX_PREFIX}
+      DEPS ${MSAN_RUNTIME_LIBRARIES}
+      CFLAGS ${MSAN_LIBCXX_CFLAGS} ${TARGET_CFLAGS})
+    set(MSAN_LIBCXX_SO ${LIBCXX_PREFIX}/lib/libc++.so)
+
+    add_msan_tests_for_arch(${arch} "")
+    add_msan_tests_for_arch(${arch} "-with-call"
+                            -mllvm -msan-instrumentation-with-call-threshold=0)
+  endforeach()
+endif()
diff --git a/compiler-rt/lib/msan/tests/msan_loadable.cc b/compiler-rt/lib/msan/tests/msan_loadable.cc
new file mode 100644
index 0000000..06e880f
--- /dev/null
+++ b/compiler-rt/lib/msan/tests/msan_loadable.cc
@@ -0,0 +1,27 @@
+//===-- msan_loadable.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// MemorySanitizer unit tests.
+//===----------------------------------------------------------------------===//
+
+#include "msan/msan_interface_internal.h"
+#include <stdlib.h>
+
+static void *dso_global;
+
+// No name mangling.
+extern "C" {
+
+void **get_dso_global() {
+  return &dso_global;
+}
+
+}
diff --git a/compiler-rt/lib/msan/tests/msan_test.cc b/compiler-rt/lib/msan/tests/msan_test.cc
new file mode 100644
index 0000000..b7162b3
--- /dev/null
+++ b/compiler-rt/lib/msan/tests/msan_test.cc
@@ -0,0 +1,4307 @@
+//===-- msan_test.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// MemorySanitizer unit tests.
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_EXTERNAL_TEST_CONFIG
+#include "msan_test_config.h"
+#endif // MSAN_EXTERNAL_TEST_CONFIG
+
+#include "sanitizer_common/tests/sanitizer_test_utils.h"
+
+#include "sanitizer/allocator_interface.h"
+#include "sanitizer/msan_interface.h"
+
+#if defined(__FreeBSD__)
+# define _KERNEL  // To declare 'shminfo' structure.
+# include <sys/shm.h>
+# undef _KERNEL
+extern "C" {
+// <sys/shm.h> doesn't declare these functions in _KERNEL mode.
+void *shmat(int, const void *, int);
+int shmget(key_t, size_t, int);
+int shmctl(int, int, struct shmid_ds *);
+int shmdt(const void *);
+}
+#endif
+
+#include <inttypes.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <math.h>
+
+#include <arpa/inet.h>
+#include <dlfcn.h>
+#include <grp.h>
+#include <unistd.h>
+#include <link.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <poll.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/resource.h>
+#include <sys/ioctl.h>
+#include <sys/statvfs.h>
+#include <sys/utsname.h>
+#include <sys/mman.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <wordexp.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#if !defined(__FreeBSD__)
+# include <malloc.h>
+# include <sys/sysinfo.h>
+# include <sys/vfs.h>
+# include <mntent.h>
+# include <netinet/ether.h>
+#else
+# include <signal.h>
+# include <netinet/in.h>
+# include <pthread_np.h>
+# include <sys/uio.h>
+# include <sys/mount.h>
+# include <sys/sysctl.h>
+# include <net/ethernet.h>
+# define f_namelen f_namemax  // FreeBSD names this statfs field so.
+# define cpu_set_t cpuset_t
+extern "C" {
+// FreeBSD's <ssp/string.h> defines mempcpy() to be a macro expanding into
+// a __builtin___mempcpy_chk() call, but since Msan RTL defines it as an
+// ordinary function, we can declare it here to complete the tests.
+void *mempcpy(void *dest, const void *src, size_t n);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+# include <emmintrin.h>
+# define MSAN_HAS_M128 1
+#else
+# define MSAN_HAS_M128 0
+#endif
+
+#ifdef __AVX2__
+# include <immintrin.h>
+#endif
+
+// On FreeBSD procfs is not enabled by default.
+#if defined(__FreeBSD__)
+# define FILE_TO_READ "/bin/cat"
+# define DIR_TO_READ "/bin"
+# define SUBFILE_TO_READ "cat"
+# define SYMLINK_TO_READ "/usr/bin/tar"
+# define SUPERUSER_GROUP "wheel"
+#else
+# define FILE_TO_READ "/proc/self/stat"
+# define DIR_TO_READ "/proc/self"
+# define SUBFILE_TO_READ "stat"
+# define SYMLINK_TO_READ "/proc/self/exe"
+# define SUPERUSER_GROUP "root"
+#endif
+
+const size_t kPageSize = 4096;
+const size_t kMaxPathLength = 4096;
+
+typedef unsigned char      U1;
+typedef unsigned short     U2;  // NOLINT
+typedef unsigned int       U4;
+typedef unsigned long long U8;  // NOLINT
+typedef   signed char      S1;
+typedef   signed short     S2;  // NOLINT
+typedef   signed int       S4;
+typedef   signed long long S8;  // NOLINT
+#define NOINLINE      __attribute__((noinline))
+#define INLINE      __attribute__((always_inline))
+
+static bool TrackingOrigins() {
+  S8 x;
+  __msan_set_origin(&x, sizeof(x), 0x1234);
+  U4 origin = __msan_get_origin(&x);
+  __msan_set_origin(&x, sizeof(x), 0);
+  return __msan_origin_is_descendant_or_same(origin, 0x1234);
+}
+
+#define EXPECT_ORIGIN(expected, origin) \
+  EXPECT_TRUE(__msan_origin_is_descendant_or_same((origin), (expected)))
+
+#define EXPECT_UMR(action) \
+    do {                        \
+      __msan_set_expect_umr(1); \
+      action;                   \
+      __msan_set_expect_umr(0); \
+    } while (0)
+
+#define EXPECT_UMR_O(action, origin)                                       \
+  do {                                                                     \
+    __msan_set_expect_umr(1);                                              \
+    action;                                                                \
+    __msan_set_expect_umr(0);                                              \
+    if (TrackingOrigins()) EXPECT_ORIGIN(origin, __msan_get_umr_origin()); \
+  } while (0)
+
+#define EXPECT_POISONED(x) ExpectPoisoned(x)
+
+template<typename T>
+void ExpectPoisoned(const T& t) {
+  EXPECT_NE(-1, __msan_test_shadow((void*)&t, sizeof(t)));
+}
+
+#define EXPECT_POISONED_O(x, origin) \
+  ExpectPoisonedWithOrigin(x, origin)
+
+template<typename T>
+void ExpectPoisonedWithOrigin(const T& t, unsigned origin) {
+  EXPECT_NE(-1, __msan_test_shadow((void*)&t, sizeof(t)));
+  if (TrackingOrigins()) EXPECT_ORIGIN(origin, __msan_get_origin((void *)&t));
+}
+
+#define EXPECT_NOT_POISONED(x) EXPECT_EQ(true, TestForNotPoisoned((x)))
+
+template<typename T>
+bool TestForNotPoisoned(const T& t) {
+  return __msan_test_shadow((void*)&t, sizeof(t)) == -1;
+}
+
+static U8 poisoned_array[100];
+template<class T>
+T *GetPoisoned(int i = 0, T val = 0) {
+  T *res = (T*)&poisoned_array[i];
+  *res = val;
+  __msan_poison(&poisoned_array[i], sizeof(T));
+  return res;
+}
+
+template<class T>
+T *GetPoisonedO(int i, U4 origin, T val = 0) {
+  T *res = (T*)&poisoned_array[i];
+  *res = val;
+  __msan_poison(&poisoned_array[i], sizeof(T));
+  __msan_set_origin(&poisoned_array[i], sizeof(T), origin);
+  return res;
+}
+
+template<typename T>
+T Poisoned(T v = 0, T s = (T)(-1)) {
+  __msan_partial_poison(&v, &s, sizeof(T));
+  return v;
+}
+
+template<class T> NOINLINE T ReturnPoisoned() { return *GetPoisoned<T>(); }
+
+static volatile int g_one = 1;
+static volatile int g_zero = 0;
+static volatile int g_0 = 0;
+static volatile int g_1 = 1;
+
+S4 a_s4[100];
+S8 a_s8[100];
+
+// Check that malloc poisons memory.
+// A lot of tests below depend on this.
+TEST(MemorySanitizerSanity, PoisonInMalloc) {
+  int *x = (int*)malloc(sizeof(int));
+  EXPECT_POISONED(*x);
+  free(x);
+}
+
+TEST(MemorySanitizer, NegativeTest1) {
+  S4 *x = GetPoisoned<S4>();
+  if (g_one)
+    *x = 0;
+  EXPECT_NOT_POISONED(*x);
+}
+
+TEST(MemorySanitizer, PositiveTest1) {
+  // Load to store.
+  EXPECT_POISONED(*GetPoisoned<S1>());
+  EXPECT_POISONED(*GetPoisoned<S2>());
+  EXPECT_POISONED(*GetPoisoned<S4>());
+  EXPECT_POISONED(*GetPoisoned<S8>());
+
+  // S->S conversions.
+  EXPECT_POISONED(*GetPoisoned<S1>());
+  EXPECT_POISONED(*GetPoisoned<S1>());
+  EXPECT_POISONED(*GetPoisoned<S1>());
+
+  EXPECT_POISONED(*GetPoisoned<S2>());
+  EXPECT_POISONED(*GetPoisoned<S2>());
+  EXPECT_POISONED(*GetPoisoned<S2>());
+
+  EXPECT_POISONED(*GetPoisoned<S4>());
+  EXPECT_POISONED(*GetPoisoned<S4>());
+  EXPECT_POISONED(*GetPoisoned<S4>());
+
+  EXPECT_POISONED(*GetPoisoned<S8>());
+  EXPECT_POISONED(*GetPoisoned<S8>());
+  EXPECT_POISONED(*GetPoisoned<S8>());
+
+  // ZExt
+  EXPECT_POISONED(*GetPoisoned<U1>());
+  EXPECT_POISONED(*GetPoisoned<U1>());
+  EXPECT_POISONED(*GetPoisoned<U1>());
+  EXPECT_POISONED(*GetPoisoned<U2>());
+  EXPECT_POISONED(*GetPoisoned<U2>());
+  EXPECT_POISONED(*GetPoisoned<U4>());
+
+  // Unary ops.
+  EXPECT_POISONED(- *GetPoisoned<S4>());
+
+  EXPECT_UMR(a_s4[g_zero] = 100 / *GetPoisoned<S4>(0, 1));
+
+
+  a_s4[g_zero] = 1 - *GetPoisoned<S4>();
+  a_s4[g_zero] = 1 + *GetPoisoned<S4>();
+}
+
+TEST(MemorySanitizer, Phi1) {
+  S4 c;
+  if (g_one) {
+    c = *GetPoisoned<S4>();
+  } else {
+    break_optimization(0);
+    c = 0;
+  }
+  EXPECT_POISONED(c);
+}
+
+TEST(MemorySanitizer, Phi2) {
+  S4 i = *GetPoisoned<S4>();
+  S4 n = g_one;
+  EXPECT_UMR(for (; i < g_one; i++););
+  EXPECT_POISONED(i);
+}
+
+NOINLINE void Arg1ExpectUMR(S4 a1) { EXPECT_POISONED(a1); }
+NOINLINE void Arg2ExpectUMR(S4 a1, S4 a2) { EXPECT_POISONED(a2); }
+NOINLINE void Arg3ExpectUMR(S1 a1, S4 a2, S8 a3) { EXPECT_POISONED(a3); }
+
+TEST(MemorySanitizer, ArgTest) {
+  Arg1ExpectUMR(*GetPoisoned<S4>());
+  Arg2ExpectUMR(0, *GetPoisoned<S4>());
+  Arg3ExpectUMR(0, 1, *GetPoisoned<S8>());
+}
+
+
+TEST(MemorySanitizer, CallAndRet) {
+  ReturnPoisoned<S1>();
+  ReturnPoisoned<S2>();
+  ReturnPoisoned<S4>();
+  ReturnPoisoned<S8>();
+
+  EXPECT_POISONED(ReturnPoisoned<S1>());
+  EXPECT_POISONED(ReturnPoisoned<S2>());
+  EXPECT_POISONED(ReturnPoisoned<S4>());
+  EXPECT_POISONED(ReturnPoisoned<S8>());
+}
+
+// malloc() in the following test may be optimized to produce a compile-time
+// undef value. Check that we trap on the volatile assignment anyway.
+TEST(MemorySanitizer, DISABLED_MallocNoIdent) {
+  S4 *x = (int*)malloc(sizeof(S4));
+  EXPECT_POISONED(*x);
+  free(x);
+}
+
+TEST(MemorySanitizer, Malloc) {
+  S4 *x = (int*)Ident(malloc(sizeof(S4)));
+  EXPECT_POISONED(*x);
+  free(x);
+}
+
+TEST(MemorySanitizer, Realloc) {
+  S4 *x = (int*)Ident(realloc(0, sizeof(S4)));
+  EXPECT_POISONED(x[0]);
+  x[0] = 1;
+  x = (int*)Ident(realloc(x, 2 * sizeof(S4)));
+  EXPECT_NOT_POISONED(x[0]);  // Ok, was inited before.
+  EXPECT_POISONED(x[1]);
+  x = (int*)Ident(realloc(x, 3 * sizeof(S4)));
+  EXPECT_NOT_POISONED(x[0]);  // Ok, was inited before.
+  EXPECT_POISONED(x[2]);
+  EXPECT_POISONED(x[1]);
+  x[2] = 1;  // Init this here. Check that after realloc it is poisoned again.
+  x = (int*)Ident(realloc(x, 2 * sizeof(S4)));
+  EXPECT_NOT_POISONED(x[0]);  // Ok, was inited before.
+  EXPECT_POISONED(x[1]);
+  x = (int*)Ident(realloc(x, 3 * sizeof(S4)));
+  EXPECT_POISONED(x[1]);
+  EXPECT_POISONED(x[2]);
+  free(x);
+}
+
+TEST(MemorySanitizer, Calloc) {
+  S4 *x = (int*)Ident(calloc(1, sizeof(S4)));
+  EXPECT_NOT_POISONED(*x);  // Should not be poisoned.
+  EXPECT_EQ(0, *x);
+  free(x);
+}
+
+TEST(MemorySanitizer, CallocReturnsZeroMem) {
+  size_t sizes[] = {16, 1000, 10000, 100000, 2100000};
+  for (size_t s = 0; s < sizeof(sizes)/sizeof(sizes[0]); s++) {
+    size_t size = sizes[s];
+    for (size_t iter = 0; iter < 5; iter++) {
+      char *x = Ident((char*)calloc(1, size));
+      EXPECT_EQ(x[0], 0);
+      EXPECT_EQ(x[size - 1], 0);
+      EXPECT_EQ(x[size / 2], 0);
+      EXPECT_EQ(x[size / 3], 0);
+      EXPECT_EQ(x[size / 4], 0);
+      memset(x, 0x42, size);
+      free(Ident(x));
+    }
+  }
+}
+
+TEST(MemorySanitizer, AndOr) {
+  U4 *p = GetPoisoned<U4>();
+  // We poison two bytes in the midle of a 4-byte word to make the test
+  // correct regardless of endianness.
+  ((U1*)p)[1] = 0;
+  ((U1*)p)[2] = 0xff;
+  EXPECT_NOT_POISONED(*p & 0x00ffff00);
+  EXPECT_NOT_POISONED(*p & 0x00ff0000);
+  EXPECT_NOT_POISONED(*p & 0x0000ff00);
+  EXPECT_POISONED(*p & 0xff000000);
+  EXPECT_POISONED(*p & 0x000000ff);
+  EXPECT_POISONED(*p & 0x0000ffff);
+  EXPECT_POISONED(*p & 0xffff0000);
+
+  EXPECT_NOT_POISONED(*p | 0xff0000ff);
+  EXPECT_NOT_POISONED(*p | 0xff00ffff);
+  EXPECT_NOT_POISONED(*p | 0xffff00ff);
+  EXPECT_POISONED(*p | 0xff000000);
+  EXPECT_POISONED(*p | 0x000000ff);
+  EXPECT_POISONED(*p | 0x0000ffff);
+  EXPECT_POISONED(*p | 0xffff0000);
+
+  EXPECT_POISONED(*GetPoisoned<bool>() & *GetPoisoned<bool>());
+}
+
+template<class T>
+static bool applyNot(T value, T shadow) {
+  __msan_partial_poison(&value, &shadow, sizeof(T));
+  return !value;
+}
+
+TEST(MemorySanitizer, Not) {
+  EXPECT_NOT_POISONED(applyNot<U4>(0x0, 0x0));
+  EXPECT_NOT_POISONED(applyNot<U4>(0xFFFFFFFF, 0x0));
+  EXPECT_POISONED(applyNot<U4>(0xFFFFFFFF, 0xFFFFFFFF));
+  EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x0FFFFFFF));
+  EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x00FFFFFF));
+  EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x0000FFFF));
+  EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x00000000));
+  EXPECT_POISONED(applyNot<U4>(0xFF000000, 0xFF000000));
+  EXPECT_NOT_POISONED(applyNot<U4>(0xFF800000, 0xFF000000));
+  EXPECT_POISONED(applyNot<U4>(0x00008000, 0x00008000));
+
+  EXPECT_NOT_POISONED(applyNot<U1>(0x0, 0x0));
+  EXPECT_NOT_POISONED(applyNot<U1>(0xFF, 0xFE));
+  EXPECT_NOT_POISONED(applyNot<U1>(0xFF, 0x0));
+  EXPECT_POISONED(applyNot<U1>(0xFF, 0xFF));
+
+  EXPECT_POISONED(applyNot<void*>((void*)0xFFFFFF, (void*)(-1)));
+  EXPECT_NOT_POISONED(applyNot<void*>((void*)0xFFFFFF, (void*)(-2)));
+}
+
+TEST(MemorySanitizer, Shift) {
+  U4 *up = GetPoisoned<U4>();
+  ((U1*)up)[0] = 0;
+  ((U1*)up)[3] = 0xff;
+  EXPECT_NOT_POISONED(*up >> 30);
+  EXPECT_NOT_POISONED(*up >> 24);
+  EXPECT_POISONED(*up >> 23);
+  EXPECT_POISONED(*up >> 10);
+
+  EXPECT_NOT_POISONED(*up << 30);
+  EXPECT_NOT_POISONED(*up << 24);
+  EXPECT_POISONED(*up << 23);
+  EXPECT_POISONED(*up << 10);
+
+  S4 *sp = (S4*)up;
+  EXPECT_NOT_POISONED(*sp >> 30);
+  EXPECT_NOT_POISONED(*sp >> 24);
+  EXPECT_POISONED(*sp >> 23);
+  EXPECT_POISONED(*sp >> 10);
+
+  sp = GetPoisoned<S4>();
+  ((S1*)sp)[1] = 0;
+  ((S1*)sp)[2] = 0;
+  EXPECT_POISONED(*sp >> 31);
+
+  EXPECT_POISONED(100 >> *GetPoisoned<S4>());
+  EXPECT_POISONED(100U >> *GetPoisoned<S4>());
+}
+
+NOINLINE static int GetPoisonedZero() {
+  int *zero = new int;
+  *zero = 0;
+  __msan_poison(zero, sizeof(*zero));
+  int res = *zero;
+  delete zero;
+  return res;
+}
+
+TEST(MemorySanitizer, LoadFromDirtyAddress) {
+  int *a = new int;
+  *a = 0;
+  EXPECT_UMR(break_optimization((void*)(U8)a[GetPoisonedZero()]));
+  delete a;
+}
+
+TEST(MemorySanitizer, StoreToDirtyAddress) {
+  int *a = new int;
+  EXPECT_UMR(a[GetPoisonedZero()] = 0);
+  break_optimization(a);
+  delete a;
+}
+
+
+NOINLINE void StackTestFunc() {
+  S4 p4;
+  S4 ok4 = 1;
+  S2 p2;
+  S2 ok2 = 1;
+  S1 p1;
+  S1 ok1 = 1;
+  break_optimization(&p4);
+  break_optimization(&ok4);
+  break_optimization(&p2);
+  break_optimization(&ok2);
+  break_optimization(&p1);
+  break_optimization(&ok1);
+
+  EXPECT_POISONED(p4);
+  EXPECT_POISONED(p2);
+  EXPECT_POISONED(p1);
+  EXPECT_NOT_POISONED(ok1);
+  EXPECT_NOT_POISONED(ok2);
+  EXPECT_NOT_POISONED(ok4);
+}
+
+TEST(MemorySanitizer, StackTest) {
+  StackTestFunc();
+}
+
+NOINLINE void StackStressFunc() {
+  int foo[10000];
+  break_optimization(foo);
+}
+
+TEST(MemorySanitizer, DISABLED_StackStressTest) {
+  for (int i = 0; i < 1000000; i++)
+    StackStressFunc();
+}
+
+template<class T>
+void TestFloatingPoint() {
+  static volatile T v;
+  static T g[100];
+  break_optimization(&g);
+  T *x = GetPoisoned<T>();
+  T *y = GetPoisoned<T>(1);
+  EXPECT_POISONED(*x);
+  EXPECT_POISONED((long long)*x);
+  EXPECT_POISONED((int)*x);
+  g[0] = *x;
+  g[1] = *x + *y;
+  g[2] = *x - *y;
+  g[3] = *x * *y;
+}
+
+TEST(MemorySanitizer, FloatingPointTest) {
+  TestFloatingPoint<float>();
+  TestFloatingPoint<double>();
+}
+
+TEST(MemorySanitizer, DynMem) {
+  S4 x = 0;
+  S4 *y = GetPoisoned<S4>();
+  memcpy(y, &x, g_one * sizeof(S4));
+  EXPECT_NOT_POISONED(*y);
+}
+
+static char *DynRetTestStr;
+
+TEST(MemorySanitizer, DynRet) {
+  ReturnPoisoned<S8>();
+  EXPECT_NOT_POISONED(atoi("0"));
+}
+
+TEST(MemorySanitizer, DynRet1) {
+  ReturnPoisoned<S8>();
+}
+
+struct LargeStruct {
+  S4 x[10];
+};
+
+NOINLINE
+LargeStruct LargeRetTest() {
+  LargeStruct res;
+  res.x[0] = *GetPoisoned<S4>();
+  res.x[1] = *GetPoisoned<S4>();
+  res.x[2] = *GetPoisoned<S4>();
+  res.x[3] = *GetPoisoned<S4>();
+  res.x[4] = *GetPoisoned<S4>();
+  res.x[5] = *GetPoisoned<S4>();
+  res.x[6] = *GetPoisoned<S4>();
+  res.x[7] = *GetPoisoned<S4>();
+  res.x[8] = *GetPoisoned<S4>();
+  res.x[9] = *GetPoisoned<S4>();
+  return res;
+}
+
+TEST(MemorySanitizer, strcmp) {
+  char s1[10];
+  char s2[10];
+  strncpy(s1, "foo", 10);
+  s2[0] = 'f';
+  s2[1] = 'n';
+  EXPECT_GT(strcmp(s1, s2), 0);
+  s2[1] = 'o';
+  int res;
+  EXPECT_UMR(res = strcmp(s1, s2));
+  EXPECT_NOT_POISONED(res);
+  EXPECT_EQ(strncmp(s1, s2, 1), 0);
+}
+
+TEST(MemorySanitizer, LargeRet) {
+  LargeStruct a = LargeRetTest();
+  EXPECT_POISONED(a.x[0]);
+  EXPECT_POISONED(a.x[9]);
+}
+
+TEST(MemorySanitizer, strerror) {
+  char *buf = strerror(EINVAL);
+  EXPECT_NOT_POISONED(strlen(buf));
+  buf = strerror(123456);
+  EXPECT_NOT_POISONED(strlen(buf));
+}
+
+TEST(MemorySanitizer, strerror_r) {
+  errno = 0;
+  char buf[1000];
+  char *res = (char*) (size_t) strerror_r(EINVAL, buf, sizeof(buf));
+  ASSERT_EQ(0, errno);
+  if (!res) res = buf; // POSIX version success.
+  EXPECT_NOT_POISONED(strlen(res));
+}
+
+TEST(MemorySanitizer, fread) {
+  char *x = new char[32];
+  FILE *f = fopen(FILE_TO_READ, "r");
+  ASSERT_TRUE(f != NULL);
+  fread(x, 1, 32, f);
+  EXPECT_NOT_POISONED(x[0]);
+  EXPECT_NOT_POISONED(x[16]);
+  EXPECT_NOT_POISONED(x[31]);
+  fclose(f);
+  delete[] x;
+}
+
+TEST(MemorySanitizer, read) {
+  char *x = new char[32];
+  int fd = open(FILE_TO_READ, O_RDONLY);
+  ASSERT_GT(fd, 0);
+  int sz = read(fd, x, 32);
+  ASSERT_EQ(sz, 32);
+  EXPECT_NOT_POISONED(x[0]);
+  EXPECT_NOT_POISONED(x[16]);
+  EXPECT_NOT_POISONED(x[31]);
+  close(fd);
+  delete[] x;
+}
+
+TEST(MemorySanitizer, pread) {
+  char *x = new char[32];
+  int fd = open(FILE_TO_READ, O_RDONLY);
+  ASSERT_GT(fd, 0);
+  int sz = pread(fd, x, 32, 0);
+  ASSERT_EQ(sz, 32);
+  EXPECT_NOT_POISONED(x[0]);
+  EXPECT_NOT_POISONED(x[16]);
+  EXPECT_NOT_POISONED(x[31]);
+  close(fd);
+  delete[] x;
+}
+
+TEST(MemorySanitizer, readv) {
+  char buf[2011];
+  struct iovec iov[2];
+  iov[0].iov_base = buf + 1;
+  iov[0].iov_len = 5;
+  iov[1].iov_base = buf + 10;
+  iov[1].iov_len = 2000;
+  int fd = open(FILE_TO_READ, O_RDONLY);
+  ASSERT_GT(fd, 0);
+  int sz = readv(fd, iov, 2);
+  ASSERT_GE(sz, 0);
+  ASSERT_LE(sz, 5 + 2000);
+  ASSERT_GT((size_t)sz, iov[0].iov_len);
+  EXPECT_POISONED(buf[0]);
+  EXPECT_NOT_POISONED(buf[1]);
+  EXPECT_NOT_POISONED(buf[5]);
+  EXPECT_POISONED(buf[6]);
+  EXPECT_POISONED(buf[9]);
+  EXPECT_NOT_POISONED(buf[10]);
+  EXPECT_NOT_POISONED(buf[10 + (sz - 1) - 5]);
+  EXPECT_POISONED(buf[11 + (sz - 1) - 5]);
+  close(fd);
+}
+
+TEST(MemorySanitizer, preadv) {
+  char buf[2011];
+  struct iovec iov[2];
+  iov[0].iov_base = buf + 1;
+  iov[0].iov_len = 5;
+  iov[1].iov_base = buf + 10;
+  iov[1].iov_len = 2000;
+  int fd = open(FILE_TO_READ, O_RDONLY);
+  ASSERT_GT(fd, 0);
+  int sz = preadv(fd, iov, 2, 3);
+  ASSERT_GE(sz, 0);
+  ASSERT_LE(sz, 5 + 2000);
+  ASSERT_GT((size_t)sz, iov[0].iov_len);
+  EXPECT_POISONED(buf[0]);
+  EXPECT_NOT_POISONED(buf[1]);
+  EXPECT_NOT_POISONED(buf[5]);
+  EXPECT_POISONED(buf[6]);
+  EXPECT_POISONED(buf[9]);
+  EXPECT_NOT_POISONED(buf[10]);
+  EXPECT_NOT_POISONED(buf[10 + (sz - 1) - 5]);
+  EXPECT_POISONED(buf[11 + (sz - 1) - 5]);
+  close(fd);
+}
+
+// FIXME: fails now.
+TEST(MemorySanitizer, DISABLED_ioctl) {
+  struct winsize ws;
+  EXPECT_EQ(ioctl(2, TIOCGWINSZ, &ws), 0);
+  EXPECT_NOT_POISONED(ws.ws_col);
+}
+
+TEST(MemorySanitizer, readlink) {
+  char *x = new char[1000];
+  readlink(SYMLINK_TO_READ, x, 1000);
+  EXPECT_NOT_POISONED(x[0]);
+  delete [] x;
+}
+
+TEST(MemorySanitizer, stat) {
+  struct stat* st = new struct stat;
+  int res = stat(FILE_TO_READ, st);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(st->st_dev);
+  EXPECT_NOT_POISONED(st->st_mode);
+  EXPECT_NOT_POISONED(st->st_size);
+}
+
+TEST(MemorySanitizer, fstatat) {
+  struct stat* st = new struct stat;
+  int dirfd = open(DIR_TO_READ, O_RDONLY);
+  ASSERT_GT(dirfd, 0);
+  int res = fstatat(dirfd, SUBFILE_TO_READ, st, 0);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(st->st_dev);
+  EXPECT_NOT_POISONED(st->st_mode);
+  EXPECT_NOT_POISONED(st->st_size);
+  close(dirfd);
+}
+
+TEST(MemorySanitizer, statfs) {
+  struct statfs st;
+  int res = statfs("/", &st);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(st.f_type);
+  EXPECT_NOT_POISONED(st.f_bfree);
+  EXPECT_NOT_POISONED(st.f_namelen);
+}
+
+TEST(MemorySanitizer, statvfs) {
+  struct statvfs st;
+  int res = statvfs("/", &st);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(st.f_bsize);
+  EXPECT_NOT_POISONED(st.f_blocks);
+  EXPECT_NOT_POISONED(st.f_bfree);
+  EXPECT_NOT_POISONED(st.f_namemax);
+}
+
+TEST(MemorySanitizer, fstatvfs) {
+  struct statvfs st;
+  int fd = open("/", O_RDONLY | O_DIRECTORY);
+  int res = fstatvfs(fd, &st);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(st.f_bsize);
+  EXPECT_NOT_POISONED(st.f_blocks);
+  EXPECT_NOT_POISONED(st.f_bfree);
+  EXPECT_NOT_POISONED(st.f_namemax);
+  close(fd);
+}
+
+TEST(MemorySanitizer, pipe) {
+  int* pipefd = new int[2];
+  int res = pipe(pipefd);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(pipefd[0]);
+  EXPECT_NOT_POISONED(pipefd[1]);
+  close(pipefd[0]);
+  close(pipefd[1]);
+}
+
+TEST(MemorySanitizer, pipe2) {
+  int* pipefd = new int[2];
+  int res = pipe2(pipefd, O_NONBLOCK);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(pipefd[0]);
+  EXPECT_NOT_POISONED(pipefd[1]);
+  close(pipefd[0]);
+  close(pipefd[1]);
+}
+
+TEST(MemorySanitizer, socketpair) {
+  int sv[2];
+  int res = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(sv[0]);
+  EXPECT_NOT_POISONED(sv[1]);
+  close(sv[0]);
+  close(sv[1]);
+}
+
+TEST(MemorySanitizer, poll) {
+  int* pipefd = new int[2];
+  int res = pipe(pipefd);
+  ASSERT_EQ(0, res);
+
+  char data = 42;
+  res = write(pipefd[1], &data, 1);
+  ASSERT_EQ(1, res);
+
+  pollfd fds[2];
+  fds[0].fd = pipefd[0];
+  fds[0].events = POLLIN;
+  fds[1].fd = pipefd[1];
+  fds[1].events = POLLIN;
+  res = poll(fds, 2, 500);
+  ASSERT_EQ(1, res);
+  EXPECT_NOT_POISONED(fds[0].revents);
+  EXPECT_NOT_POISONED(fds[1].revents);
+
+  close(pipefd[0]);
+  close(pipefd[1]);
+}
+
+// There is no ppoll() on FreeBSD.
+#if !defined (__FreeBSD__)
+TEST(MemorySanitizer, ppoll) {
+  int* pipefd = new int[2];
+  int res = pipe(pipefd);
+  ASSERT_EQ(0, res);
+
+  char data = 42;
+  res = write(pipefd[1], &data, 1);
+  ASSERT_EQ(1, res);
+
+  pollfd fds[2];
+  fds[0].fd = pipefd[0];
+  fds[0].events = POLLIN;
+  fds[1].fd = pipefd[1];
+  fds[1].events = POLLIN;
+  sigset_t ss;
+  sigemptyset(&ss);
+  res = ppoll(fds, 2, NULL, &ss);
+  ASSERT_EQ(1, res);
+  EXPECT_NOT_POISONED(fds[0].revents);
+  EXPECT_NOT_POISONED(fds[1].revents);
+
+  close(pipefd[0]);
+  close(pipefd[1]);
+}
+#endif
+
+TEST(MemorySanitizer, poll_positive) {
+  int* pipefd = new int[2];
+  int res = pipe(pipefd);
+  ASSERT_EQ(0, res);
+
+  pollfd fds[2];
+  fds[0].fd = pipefd[0];
+  fds[0].events = POLLIN;
+  // fds[1].fd uninitialized
+  fds[1].events = POLLIN;
+  EXPECT_UMR(poll(fds, 2, 0));
+
+  close(pipefd[0]);
+  close(pipefd[1]);
+}
+
+TEST(MemorySanitizer, bind_getsockname) {
+  int sock = socket(AF_UNIX, SOCK_STREAM, 0);
+
+  struct sockaddr_in sai;
+  memset(&sai, 0, sizeof(sai));
+  sai.sin_family = AF_UNIX;
+  int res = bind(sock, (struct sockaddr *)&sai, sizeof(sai));
+
+  ASSERT_EQ(0, res);
+  char buf[200];
+  socklen_t addrlen;
+  EXPECT_UMR(getsockname(sock, (struct sockaddr *)&buf, &addrlen));
+
+  addrlen = sizeof(buf);
+  res = getsockname(sock, (struct sockaddr *)&buf, &addrlen);
+  EXPECT_NOT_POISONED(addrlen);
+  EXPECT_NOT_POISONED(buf[0]);
+  EXPECT_NOT_POISONED(buf[addrlen - 1]);
+  EXPECT_POISONED(buf[addrlen]);
+  close(sock);
+}
+
+TEST(MemorySanitizer, accept) {
+  int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
+  ASSERT_LT(0, listen_socket);
+
+  struct sockaddr_in sai;
+  memset(&sai, 0, sizeof(sai));
+  sai.sin_family = AF_INET;
+  sai.sin_port = 0;
+  sai.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  int res = bind(listen_socket, (struct sockaddr *)&sai, sizeof(sai));
+  ASSERT_EQ(0, res);
+
+  res = listen(listen_socket, 1);
+  ASSERT_EQ(0, res);
+
+  socklen_t sz = sizeof(sai);
+  res = getsockname(listen_socket, (struct sockaddr *)&sai, &sz);
+  ASSERT_EQ(0, res);
+  ASSERT_EQ(sizeof(sai), sz);
+
+  int connect_socket = socket(AF_INET, SOCK_STREAM, 0);
+  ASSERT_LT(0, connect_socket);
+  res = fcntl(connect_socket, F_SETFL, O_NONBLOCK);
+  ASSERT_EQ(0, res);
+  res = connect(connect_socket, (struct sockaddr *)&sai, sizeof(sai));
+  // On FreeBSD this connection completes immediately.
+  if (res != 0) {
+    ASSERT_EQ(-1, res);
+    ASSERT_EQ(EINPROGRESS, errno);
+  }
+
+  __msan_poison(&sai, sizeof(sai));
+  int new_sock = accept(listen_socket, (struct sockaddr *)&sai, &sz);
+  ASSERT_LT(0, new_sock);
+  ASSERT_EQ(sizeof(sai), sz);
+  EXPECT_NOT_POISONED(sai);
+
+  __msan_poison(&sai, sizeof(sai));
+  res = getpeername(new_sock, (struct sockaddr *)&sai, &sz);
+  ASSERT_EQ(0, res);
+  ASSERT_EQ(sizeof(sai), sz);
+  EXPECT_NOT_POISONED(sai);
+
+  close(new_sock);
+  close(connect_socket);
+  close(listen_socket);
+}
+
+TEST(MemorySanitizer, getaddrinfo) {
+  struct addrinfo *ai;
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_INET;
+  int res = getaddrinfo("localhost", NULL, &hints, &ai);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(*ai);
+  ASSERT_EQ(sizeof(sockaddr_in), ai->ai_addrlen);
+  EXPECT_NOT_POISONED(*(sockaddr_in*)ai->ai_addr); 
+}
+
+TEST(MemorySanitizer, getnameinfo) {
+  struct sockaddr_in sai;
+  memset(&sai, 0, sizeof(sai));
+  sai.sin_family = AF_INET;
+  sai.sin_port = 80;
+  sai.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  char host[500];
+  char serv[500];
+  int res = getnameinfo((struct sockaddr *)&sai, sizeof(sai), host,
+                        sizeof(host), serv, sizeof(serv), 0);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(host[0]);
+  EXPECT_POISONED(host[sizeof(host) - 1]);
+
+  ASSERT_NE(0U, strlen(host));
+  EXPECT_NOT_POISONED(serv[0]);
+  EXPECT_POISONED(serv[sizeof(serv) - 1]);
+  ASSERT_NE(0U, strlen(serv));
+}
+
+#define EXPECT_HOSTENT_NOT_POISONED(he)        \
+  do {                                         \
+    EXPECT_NOT_POISONED(*(he));                \
+    ASSERT_NE((void *) 0, (he)->h_name);       \
+    ASSERT_NE((void *) 0, (he)->h_aliases);    \
+    ASSERT_NE((void *) 0, (he)->h_addr_list);  \
+    EXPECT_NOT_POISONED(strlen((he)->h_name)); \
+    char **p = (he)->h_aliases;                \
+    while (*p) {                               \
+      EXPECT_NOT_POISONED(strlen(*p));         \
+      ++p;                                     \
+    }                                          \
+    char **q = (he)->h_addr_list;              \
+    while (*q) {                               \
+      EXPECT_NOT_POISONED(*q[0]);              \
+      ++q;                                     \
+    }                                          \
+    EXPECT_NOT_POISONED(*q);                   \
+  } while (0)
+
+TEST(MemorySanitizer, gethostent) {
+  struct hostent *he = gethostent();
+  ASSERT_NE((void *)NULL, he);
+  EXPECT_HOSTENT_NOT_POISONED(he);
+}
+
+#ifndef MSAN_TEST_DISABLE_GETHOSTBYNAME
+
+TEST(MemorySanitizer, gethostbyname) {
+  struct hostent *he = gethostbyname("localhost");
+  ASSERT_NE((void *)NULL, he);
+  EXPECT_HOSTENT_NOT_POISONED(he);
+}
+
+#endif // MSAN_TEST_DISABLE_GETHOSTBYNAME
+
+TEST(MemorySanitizer, recvmsg) {
+  int server_socket = socket(AF_INET, SOCK_DGRAM, 0);
+  ASSERT_LT(0, server_socket);
+
+  struct sockaddr_in sai;
+  memset(&sai, 0, sizeof(sai));
+  sai.sin_family = AF_INET;
+  sai.sin_port = 0;
+  sai.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  int res = bind(server_socket, (struct sockaddr *)&sai, sizeof(sai));
+  ASSERT_EQ(0, res);
+
+  socklen_t sz = sizeof(sai);
+  res = getsockname(server_socket, (struct sockaddr *)&sai, &sz);
+  ASSERT_EQ(0, res);
+  ASSERT_EQ(sizeof(sai), sz);
+
+
+  int client_socket = socket(AF_INET, SOCK_DGRAM, 0);
+  ASSERT_LT(0, client_socket);
+
+  struct sockaddr_in client_sai;
+  memset(&client_sai, 0, sizeof(client_sai));
+  client_sai.sin_family = AF_INET;
+  client_sai.sin_port = 0;
+  client_sai.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  res = bind(client_socket, (struct sockaddr *)&client_sai, sizeof(client_sai));
+  ASSERT_EQ(0, res);
+
+  sz = sizeof(client_sai);
+  res = getsockname(client_socket, (struct sockaddr *)&client_sai, &sz);
+  ASSERT_EQ(0, res);
+  ASSERT_EQ(sizeof(client_sai), sz);
+
+  const char *s = "message text";
+  struct iovec iov;
+  iov.iov_base = (void *)s;
+  iov.iov_len = strlen(s) + 1;
+  struct msghdr msg;
+  memset(&msg, 0, sizeof(msg));
+  msg.msg_name = &sai;
+  msg.msg_namelen = sizeof(sai);
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  res = sendmsg(client_socket, &msg, 0);
+  ASSERT_LT(0, res);
+
+
+  char buf[1000];
+  struct iovec recv_iov;
+  recv_iov.iov_base = (void *)&buf;
+  recv_iov.iov_len = sizeof(buf);
+  struct sockaddr_in recv_sai;
+  struct msghdr recv_msg;
+  memset(&recv_msg, 0, sizeof(recv_msg));
+  recv_msg.msg_name = &recv_sai;
+  recv_msg.msg_namelen = sizeof(recv_sai);
+  recv_msg.msg_iov = &recv_iov;
+  recv_msg.msg_iovlen = 1;
+  res = recvmsg(server_socket, &recv_msg, 0);
+  ASSERT_LT(0, res);
+
+  ASSERT_EQ(sizeof(recv_sai), recv_msg.msg_namelen);
+  EXPECT_NOT_POISONED(*(struct sockaddr_in *)recv_msg.msg_name);
+  EXPECT_STREQ(s, buf);
+
+  close(server_socket);
+  close(client_socket);
+}
+
+TEST(MemorySanitizer, gethostbyname2) {
+  struct hostent *he = gethostbyname2("localhost", AF_INET);
+  ASSERT_NE((void *)NULL, he);
+  EXPECT_HOSTENT_NOT_POISONED(he);
+}
+
+TEST(MemorySanitizer, gethostbyaddr) {
+  in_addr_t addr = inet_addr("127.0.0.1");
+  EXPECT_NOT_POISONED(addr);
+  struct hostent *he = gethostbyaddr(&addr, sizeof(addr), AF_INET);
+  ASSERT_NE((void *)NULL, he);
+  EXPECT_HOSTENT_NOT_POISONED(he);
+}
+
+TEST(MemorySanitizer, gethostent_r) {
+  char buf[2000];
+  struct hostent he;
+  struct hostent *result;
+  int err;
+  int res = gethostent_r(&he, buf, sizeof(buf), &result, &err);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(result);
+  ASSERT_NE((void *)NULL, result);
+  EXPECT_HOSTENT_NOT_POISONED(result);
+  EXPECT_NOT_POISONED(err);
+}
+
+TEST(MemorySanitizer, gethostbyname_r) {
+  char buf[2000];
+  struct hostent he;
+  struct hostent *result;
+  int err;
+  int res = gethostbyname_r("localhost", &he, buf, sizeof(buf), &result, &err);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(result);
+  ASSERT_NE((void *)NULL, result);
+  EXPECT_HOSTENT_NOT_POISONED(result);
+  EXPECT_NOT_POISONED(err);
+}
+
+TEST(MemorySanitizer, gethostbyname_r_bad_host_name) {
+  char buf[2000];
+  struct hostent he;
+  struct hostent *result;
+  int err;
+  int res = gethostbyname_r("bad-host-name", &he, buf, sizeof(buf), &result, &err);
+  ASSERT_EQ((struct hostent *)0, result);
+  EXPECT_NOT_POISONED(err);
+}
+
+TEST(MemorySanitizer, gethostbyname_r_erange) {
+  char buf[5];
+  struct hostent he;
+  struct hostent *result;
+  int err;
+  int res = gethostbyname_r("localhost", &he, buf, sizeof(buf), &result, &err);
+  ASSERT_EQ(ERANGE, res);
+  EXPECT_NOT_POISONED(err);
+}
+
+TEST(MemorySanitizer, gethostbyname2_r) {
+  char buf[2000];
+  struct hostent he;
+  struct hostent *result;
+  int err;
+  int res = gethostbyname2_r("localhost", AF_INET, &he, buf, sizeof(buf),
+                             &result, &err);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(result);
+  ASSERT_NE((void *)NULL, result);
+  EXPECT_HOSTENT_NOT_POISONED(result);
+  EXPECT_NOT_POISONED(err);
+}
+
+TEST(MemorySanitizer, gethostbyaddr_r) {
+  char buf[2000];
+  struct hostent he;
+  struct hostent *result;
+  int err;
+  in_addr_t addr = inet_addr("127.0.0.1");
+  EXPECT_NOT_POISONED(addr);
+  int res = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &he, buf, sizeof(buf),
+                            &result, &err);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(result);
+  ASSERT_NE((void *)NULL, result);
+  EXPECT_HOSTENT_NOT_POISONED(result);
+  EXPECT_NOT_POISONED(err);
+}
+
+TEST(MemorySanitizer, getsockopt) {
+  int sock = socket(AF_UNIX, SOCK_STREAM, 0);
+  struct linger l[2];
+  socklen_t sz = sizeof(l[0]);
+  int res = getsockopt(sock, SOL_SOCKET, SO_LINGER, &l[0], &sz);
+  ASSERT_EQ(0, res);
+  ASSERT_EQ(sizeof(l[0]), sz);
+  EXPECT_NOT_POISONED(l[0]);
+  EXPECT_POISONED(*(char *)(l + 1));
+}
+
+TEST(MemorySanitizer, getcwd) {
+  char path[PATH_MAX + 1];
+  char* res = getcwd(path, sizeof(path));
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(path[0]);
+}
+
+TEST(MemorySanitizer, getcwd_gnu) {
+  char* res = getcwd(NULL, 0);
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(res[0]);
+  free(res);
+}
+
+// There's no get_current_dir_name() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, get_current_dir_name) {
+  char* res = get_current_dir_name();
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(res[0]);
+  free(res);
+}
+#endif
+
+TEST(MemorySanitizer, shmctl) {
+  int id = shmget(IPC_PRIVATE, 4096, 0644 | IPC_CREAT);
+  ASSERT_GT(id, -1);
+
+  struct shmid_ds ds;
+  int res = shmctl(id, IPC_STAT, &ds);
+  ASSERT_GT(res, -1);
+  EXPECT_NOT_POISONED(ds);
+
+  // FreeBSD does not support shmctl(IPC_INFO) and shmctl(SHM_INFO).
+#if !defined(__FreeBSD__)
+  struct shminfo si;
+  res = shmctl(id, IPC_INFO, (struct shmid_ds *)&si);
+  ASSERT_GT(res, -1);
+  EXPECT_NOT_POISONED(si);
+
+  struct shm_info s_i;
+  res = shmctl(id, SHM_INFO, (struct shmid_ds *)&s_i);
+  ASSERT_GT(res, -1);
+  EXPECT_NOT_POISONED(s_i);
+#endif
+
+  res = shmctl(id, IPC_RMID, 0);
+  ASSERT_GT(res, -1);
+}
+
+TEST(MemorySanitizer, shmat) {
+  void *p = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
+                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  ASSERT_NE(MAP_FAILED, p);
+
+  ((char *)p)[10] = *GetPoisoned<U1>();
+  ((char *)p)[4095] = *GetPoisoned<U1>();
+
+  int res = munmap(p, 4096);
+  ASSERT_EQ(0, res);
+
+  int id = shmget(IPC_PRIVATE, 4096, 0644 | IPC_CREAT);
+  ASSERT_GT(id, -1);
+
+  void *q = shmat(id, p, 0);
+  ASSERT_EQ(p, q);
+
+  EXPECT_NOT_POISONED(((char *)q)[0]);
+  EXPECT_NOT_POISONED(((char *)q)[10]);
+  EXPECT_NOT_POISONED(((char *)q)[4095]);
+
+  res = shmdt(q);
+  ASSERT_EQ(0, res);
+
+  res = shmctl(id, IPC_RMID, 0);
+  ASSERT_GT(res, -1);
+}
+
+// There's no random_r() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, random_r) {
+  int32_t x;
+  char z[64];
+  memset(z, 0, sizeof(z));
+
+  struct random_data buf;
+  memset(&buf, 0, sizeof(buf));
+
+  int res = initstate_r(0, z, sizeof(z), &buf);
+  ASSERT_EQ(0, res);
+
+  res = random_r(&buf, &x);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(x);
+}
+#endif
+
+TEST(MemorySanitizer, confstr) {
+  char buf[3];
+  size_t res = confstr(_CS_PATH, buf, sizeof(buf));
+  ASSERT_GT(res, sizeof(buf));
+  EXPECT_NOT_POISONED(buf[0]);
+  EXPECT_NOT_POISONED(buf[sizeof(buf) - 1]);
+
+  char buf2[1000];
+  res = confstr(_CS_PATH, buf2, sizeof(buf2));
+  ASSERT_LT(res, sizeof(buf2));
+  EXPECT_NOT_POISONED(buf2[0]);
+  EXPECT_NOT_POISONED(buf2[res - 1]);
+  EXPECT_POISONED(buf2[res]);
+  ASSERT_EQ(res, strlen(buf2) + 1);
+}
+
+TEST(MemorySanitizer, opendir) {
+  DIR *dir = opendir(".");
+  closedir(dir);
+
+  char name[10] = ".";
+  __msan_poison(name, sizeof(name));
+  EXPECT_UMR(dir = opendir(name));
+  closedir(dir);
+}
+
+TEST(MemorySanitizer, readdir) {
+  DIR *dir = opendir(".");
+  struct dirent *d = readdir(dir);
+  ASSERT_TRUE(d != NULL);
+  EXPECT_NOT_POISONED(d->d_name[0]);
+  closedir(dir);
+}
+
+TEST(MemorySanitizer, readdir_r) {
+  DIR *dir = opendir(".");
+  struct dirent d;
+  struct dirent *pd;
+  int res = readdir_r(dir, &d, &pd);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(pd);
+  EXPECT_NOT_POISONED(d.d_name[0]);
+  closedir(dir);
+}
+
+TEST(MemorySanitizer, realpath) {
+  const char* relpath = ".";
+  char path[PATH_MAX + 1];
+  char* res = realpath(relpath, path);
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(path[0]);
+}
+
+TEST(MemorySanitizer, realpath_null) {
+  const char* relpath = ".";
+  char* res = realpath(relpath, NULL);
+  printf("%d, %s\n", errno, strerror(errno));
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(res[0]);
+  free(res);
+}
+
+// There's no canonicalize_file_name() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, canonicalize_file_name) {
+  const char* relpath = ".";
+  char* res = canonicalize_file_name(relpath);
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(res[0]);
+  free(res);
+}
+#endif
+
+extern char **environ;
+
+TEST(MemorySanitizer, setenv) {
+  setenv("AAA", "BBB", 1);
+  for (char **envp = environ; *envp; ++envp) {
+    EXPECT_NOT_POISONED(*envp);
+    EXPECT_NOT_POISONED(*envp[0]);
+  }
+}
+
+TEST(MemorySanitizer, putenv) {
+  char s[] = "AAA=BBB";
+  putenv(s);
+  for (char **envp = environ; *envp; ++envp) {
+    EXPECT_NOT_POISONED(*envp);
+    EXPECT_NOT_POISONED(*envp[0]);
+  }
+}
+
+TEST(MemorySanitizer, memcpy) {
+  char* x = new char[2];
+  char* y = new char[2];
+  x[0] = 1;
+  x[1] = *GetPoisoned<char>();
+  memcpy(y, x, 2);
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_POISONED(y[1]);
+}
+
+void TestUnalignedMemcpy(unsigned left, unsigned right, bool src_is_aligned,
+                         bool src_is_poisoned, bool dst_is_poisoned) {
+  fprintf(stderr, "%s(%d, %d, %d, %d, %d)\n", __func__, left, right,
+          src_is_aligned, src_is_poisoned, dst_is_poisoned);
+
+  const unsigned sz = 20;
+  U4 dst_origin, src_origin;
+  char *dst = (char *)malloc(sz);
+  if (dst_is_poisoned)
+    dst_origin = __msan_get_origin(dst);
+  else
+    memset(dst, 0, sz);
+
+  char *src = (char *)malloc(sz);
+  if (src_is_poisoned)
+    src_origin = __msan_get_origin(src);
+  else
+    memset(src, 0, sz);
+
+  memcpy(dst + left, src_is_aligned ? src + left : src, sz - left - right);
+
+  for (unsigned i = 0; i < (left & (~3U)); ++i)
+    if (dst_is_poisoned)
+      EXPECT_POISONED_O(dst[i], dst_origin);
+    else
+      EXPECT_NOT_POISONED(dst[i]);
+
+  for (unsigned i = 0; i < (right & (~3U)); ++i)
+    if (dst_is_poisoned)
+      EXPECT_POISONED_O(dst[sz - i - 1], dst_origin);
+    else
+      EXPECT_NOT_POISONED(dst[sz - i - 1]);
+
+  for (unsigned i = left; i < sz - right; ++i)
+    if (src_is_poisoned)
+      EXPECT_POISONED_O(dst[i], src_origin);
+    else
+      EXPECT_NOT_POISONED(dst[i]);
+
+  free(dst);
+  free(src);
+}
+
+TEST(MemorySanitizer, memcpy_unaligned) {
+  for (int i = 0; i < 10; ++i)
+    for (int j = 0; j < 10; ++j)
+      for (int aligned = 0; aligned < 2; ++aligned)
+        for (int srcp = 0; srcp < 2; ++srcp)
+          for (int dstp = 0; dstp < 2; ++dstp)
+            TestUnalignedMemcpy(i, j, aligned, srcp, dstp);
+}
+
+TEST(MemorySanitizer, memmove) {
+  char* x = new char[2];
+  char* y = new char[2];
+  x[0] = 1;
+  x[1] = *GetPoisoned<char>();
+  memmove(y, x, 2);
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_POISONED(y[1]);
+}
+
+TEST(MemorySanitizer, memccpy_nomatch) {
+  char* x = new char[5];
+  char* y = new char[5];
+  strcpy(x, "abc");
+  memccpy(y, x, 'd', 4);
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_NOT_POISONED(y[1]);
+  EXPECT_NOT_POISONED(y[2]);
+  EXPECT_NOT_POISONED(y[3]);
+  EXPECT_POISONED(y[4]);
+  delete[] x;
+  delete[] y;
+}
+
+TEST(MemorySanitizer, memccpy_match) {
+  char* x = new char[5];
+  char* y = new char[5];
+  strcpy(x, "abc");
+  memccpy(y, x, 'b', 4);
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_NOT_POISONED(y[1]);
+  EXPECT_POISONED(y[2]);
+  EXPECT_POISONED(y[3]);
+  EXPECT_POISONED(y[4]);
+  delete[] x;
+  delete[] y;
+}
+
+TEST(MemorySanitizer, memccpy_nomatch_positive) {
+  char* x = new char[5];
+  char* y = new char[5];
+  strcpy(x, "abc");
+  EXPECT_UMR(memccpy(y, x, 'd', 5));
+  delete[] x;
+  delete[] y;
+}
+
+TEST(MemorySanitizer, memccpy_match_positive) {
+  char* x = new char[5];
+  char* y = new char[5];
+  x[0] = 'a';
+  x[2] = 'b';
+  EXPECT_UMR(memccpy(y, x, 'b', 5));
+  delete[] x;
+  delete[] y;
+}
+
+TEST(MemorySanitizer, bcopy) {
+  char* x = new char[2];
+  char* y = new char[2];
+  x[0] = 1;
+  x[1] = *GetPoisoned<char>();
+  bcopy(x, y, 2);
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_POISONED(y[1]);
+}
+
+TEST(MemorySanitizer, strdup) {
+  char buf[4] = "abc";
+  __msan_poison(buf + 2, sizeof(*buf));
+  char *x = strdup(buf);
+  EXPECT_NOT_POISONED(x[0]);
+  EXPECT_NOT_POISONED(x[1]);
+  EXPECT_POISONED(x[2]);
+  EXPECT_NOT_POISONED(x[3]);
+  free(x);
+}
+
+TEST(MemorySanitizer, strndup) {
+  char buf[4] = "abc";
+  __msan_poison(buf + 2, sizeof(*buf));
+  char *x = strndup(buf, 3);
+  EXPECT_NOT_POISONED(x[0]);
+  EXPECT_NOT_POISONED(x[1]);
+  EXPECT_POISONED(x[2]);
+  EXPECT_NOT_POISONED(x[3]);
+  free(x);
+}
+
+TEST(MemorySanitizer, strndup_short) {
+  char buf[4] = "abc";
+  __msan_poison(buf + 1, sizeof(*buf));
+  __msan_poison(buf + 2, sizeof(*buf));
+  char *x = strndup(buf, 2);
+  EXPECT_NOT_POISONED(x[0]);
+  EXPECT_POISONED(x[1]);
+  EXPECT_NOT_POISONED(x[2]);
+  free(x);
+}
+
+
+template<class T, int size>
+void TestOverlapMemmove() {
+  T *x = new T[size];
+  ASSERT_GE(size, 3);
+  x[2] = 0;
+  memmove(x, x + 1, (size - 1) * sizeof(T));
+  EXPECT_NOT_POISONED(x[1]);
+  EXPECT_POISONED(x[0]);
+  EXPECT_POISONED(x[2]);
+  delete [] x;
+}
+
+TEST(MemorySanitizer, overlap_memmove) {
+  TestOverlapMemmove<U1, 10>();
+  TestOverlapMemmove<U1, 1000>();
+  TestOverlapMemmove<U8, 4>();
+  TestOverlapMemmove<U8, 1000>();
+}
+
+TEST(MemorySanitizer, strcpy) {  // NOLINT
+  char* x = new char[3];
+  char* y = new char[3];
+  x[0] = 'a';
+  x[1] = *GetPoisoned<char>(1, 1);
+  x[2] = 0;
+  strcpy(y, x);  // NOLINT
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_POISONED(y[1]);
+  EXPECT_NOT_POISONED(y[2]);
+}
+
+TEST(MemorySanitizer, strncpy) {  // NOLINT
+  char* x = new char[3];
+  char* y = new char[5];
+  x[0] = 'a';
+  x[1] = *GetPoisoned<char>(1, 1);
+  x[2] = '\0';
+  strncpy(y, x, 4);  // NOLINT
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_POISONED(y[1]);
+  EXPECT_NOT_POISONED(y[2]);
+  EXPECT_NOT_POISONED(y[3]);
+  EXPECT_POISONED(y[4]);
+}
+
+TEST(MemorySanitizer, stpcpy) {  // NOLINT
+  char* x = new char[3];
+  char* y = new char[3];
+  x[0] = 'a';
+  x[1] = *GetPoisoned<char>(1, 1);
+  x[2] = 0;
+  char *res = stpcpy(y, x);  // NOLINT
+  ASSERT_EQ(res, y + 2);
+  EXPECT_NOT_POISONED(y[0]);
+  EXPECT_POISONED(y[1]);
+  EXPECT_NOT_POISONED(y[2]);
+}
+
+TEST(MemorySanitizer, strcat) {  // NOLINT
+  char a[10];
+  char b[] = "def";
+  strcpy(a, "abc");
+  __msan_poison(b + 1, 1);
+  strcat(a, b);
+  EXPECT_NOT_POISONED(a[3]);
+  EXPECT_POISONED(a[4]);
+  EXPECT_NOT_POISONED(a[5]);
+  EXPECT_NOT_POISONED(a[6]);
+  EXPECT_POISONED(a[7]);
+}
+
+TEST(MemorySanitizer, strncat) {  // NOLINT
+  char a[10];
+  char b[] = "def";
+  strcpy(a, "abc");
+  __msan_poison(b + 1, 1);
+  strncat(a, b, 5);
+  EXPECT_NOT_POISONED(a[3]);
+  EXPECT_POISONED(a[4]);
+  EXPECT_NOT_POISONED(a[5]);
+  EXPECT_NOT_POISONED(a[6]);
+  EXPECT_POISONED(a[7]);
+}
+
+TEST(MemorySanitizer, strncat_overflow) {  // NOLINT
+  char a[10];
+  char b[] = "def";
+  strcpy(a, "abc");
+  __msan_poison(b + 1, 1);
+  strncat(a, b, 2);
+  EXPECT_NOT_POISONED(a[3]);
+  EXPECT_POISONED(a[4]);
+  EXPECT_NOT_POISONED(a[5]);
+  EXPECT_POISONED(a[6]);
+  EXPECT_POISONED(a[7]);
+}
+
+#define TEST_STRTO_INT(func_name, char_type, str_prefix) \
+  TEST(MemorySanitizer, func_name) {                     \
+    char_type *e;                                        \
+    EXPECT_EQ(1U, func_name(str_prefix##"1", &e, 10));   \
+    EXPECT_NOT_POISONED((S8)e);                          \
+  }
+
+#define TEST_STRTO_FLOAT(func_name, char_type, str_prefix) \
+  TEST(MemorySanitizer, func_name) {                       \
+    char_type *e;                                          \
+    EXPECT_NE(0, func_name(str_prefix##"1.5", &e));        \
+    EXPECT_NOT_POISONED((S8)e);                            \
+  }
+
+#define TEST_STRTO_FLOAT_LOC(func_name, char_type, str_prefix)   \
+  TEST(MemorySanitizer, func_name) {                             \
+    locale_t loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0); \
+    char_type *e;                                                \
+    EXPECT_NE(0, func_name(str_prefix##"1.5", &e, loc));         \
+    EXPECT_NOT_POISONED((S8)e);                                  \
+    freelocale(loc);                                             \
+  }
+
+#define TEST_STRTO_INT_LOC(func_name, char_type, str_prefix)     \
+  TEST(MemorySanitizer, func_name) {                             \
+    locale_t loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0); \
+    char_type *e;                                                \
+    ASSERT_EQ(1U, func_name(str_prefix##"1", &e, 10, loc));      \
+    EXPECT_NOT_POISONED((S8)e);                                  \
+    freelocale(loc);                                             \
+  }
+
+TEST_STRTO_INT(strtol, char, )
+TEST_STRTO_INT(strtoll, char, )
+TEST_STRTO_INT(strtoul, char, )
+TEST_STRTO_INT(strtoull, char, )
+
+TEST_STRTO_FLOAT(strtof, char, )
+TEST_STRTO_FLOAT(strtod, char, )
+TEST_STRTO_FLOAT(strtold, char, )
+
+TEST_STRTO_FLOAT_LOC(strtof_l, char, )
+TEST_STRTO_FLOAT_LOC(strtod_l, char, )
+TEST_STRTO_FLOAT_LOC(strtold_l, char, )
+
+TEST_STRTO_INT_LOC(strtol_l, char, )
+TEST_STRTO_INT_LOC(strtoll_l, char, )
+TEST_STRTO_INT_LOC(strtoul_l, char, )
+TEST_STRTO_INT_LOC(strtoull_l, char, )
+
+TEST_STRTO_INT(wcstol, wchar_t, L)
+TEST_STRTO_INT(wcstoll, wchar_t, L)
+TEST_STRTO_INT(wcstoul, wchar_t, L)
+TEST_STRTO_INT(wcstoull, wchar_t, L)
+
+TEST_STRTO_FLOAT(wcstof, wchar_t, L)
+TEST_STRTO_FLOAT(wcstod, wchar_t, L)
+TEST_STRTO_FLOAT(wcstold, wchar_t, L)
+
+TEST_STRTO_FLOAT_LOC(wcstof_l, wchar_t, L)
+TEST_STRTO_FLOAT_LOC(wcstod_l, wchar_t, L)
+TEST_STRTO_FLOAT_LOC(wcstold_l, wchar_t, L)
+
+TEST_STRTO_INT_LOC(wcstol_l, wchar_t, L)
+TEST_STRTO_INT_LOC(wcstoll_l, wchar_t, L)
+TEST_STRTO_INT_LOC(wcstoul_l, wchar_t, L)
+TEST_STRTO_INT_LOC(wcstoull_l, wchar_t, L)
+
+
+TEST(MemorySanitizer, strtoimax) {
+  char *e;
+  ASSERT_EQ(1, strtoimax("1", &e, 10));
+  EXPECT_NOT_POISONED((S8) e);
+}
+
+TEST(MemorySanitizer, strtoumax) {
+  char *e;
+  ASSERT_EQ(1U, strtoumax("1", &e, 10));
+  EXPECT_NOT_POISONED((S8) e);
+}
+
+#ifdef __GLIBC__
+extern "C" float __strtof_l(const char *nptr, char **endptr, locale_t loc);
+TEST_STRTO_FLOAT_LOC(__strtof_l, char, )
+extern "C" double __strtod_l(const char *nptr, char **endptr, locale_t loc);
+TEST_STRTO_FLOAT_LOC(__strtod_l, char, )
+extern "C" long double __strtold_l(const char *nptr, char **endptr,
+                                   locale_t loc);
+TEST_STRTO_FLOAT_LOC(__strtold_l, char, )
+
+extern "C" float __wcstof_l(const wchar_t *nptr, wchar_t **endptr, locale_t loc);
+TEST_STRTO_FLOAT_LOC(__wcstof_l, wchar_t, L)
+extern "C" double __wcstod_l(const wchar_t *nptr, wchar_t **endptr, locale_t loc);
+TEST_STRTO_FLOAT_LOC(__wcstod_l, wchar_t, L)
+extern "C" long double __wcstold_l(const wchar_t *nptr, wchar_t **endptr,
+                                   locale_t loc);
+TEST_STRTO_FLOAT_LOC(__wcstold_l, wchar_t, L)
+#endif  // __GLIBC__
+
+TEST(MemorySanitizer, modf) {
+  double x, y;
+  x = modf(2.1, &y);
+  EXPECT_NOT_POISONED(y);
+}
+
+TEST(MemorySanitizer, modff) {
+  float x, y;
+  x = modff(2.1, &y);
+  EXPECT_NOT_POISONED(y);
+}
+
+TEST(MemorySanitizer, modfl) {
+  long double x, y;
+  x = modfl(2.1, &y);
+  EXPECT_NOT_POISONED(y);
+}
+
+// There's no sincos() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, sincos) {
+  double s, c;
+  sincos(0.2, &s, &c);
+  EXPECT_NOT_POISONED(s);
+  EXPECT_NOT_POISONED(c);
+}
+#endif
+
+// There's no sincosf() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, sincosf) {
+  float s, c;
+  sincosf(0.2, &s, &c);
+  EXPECT_NOT_POISONED(s);
+  EXPECT_NOT_POISONED(c);
+}
+#endif
+
+// There's no sincosl() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, sincosl) {
+  long double s, c;
+  sincosl(0.2, &s, &c);
+  EXPECT_NOT_POISONED(s);
+  EXPECT_NOT_POISONED(c);
+}
+#endif
+
+TEST(MemorySanitizer, remquo) {
+  int quo;
+  double res = remquo(29.0, 3.0, &quo);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(quo);
+}
+
+TEST(MemorySanitizer, remquof) {
+  int quo;
+  float res = remquof(29.0, 3.0, &quo);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(quo);
+}
+
+TEST(MemorySanitizer, remquol) {
+  int quo;
+  long double res = remquof(29.0, 3.0, &quo);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(quo);
+}
+
+TEST(MemorySanitizer, lgamma) {
+  double res = lgamma(1.1);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(signgam);
+}
+
+TEST(MemorySanitizer, lgammaf) {
+  float res = lgammaf(1.1);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(signgam);
+}
+
+TEST(MemorySanitizer, lgammal) {
+  long double res = lgammal(1.1);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(signgam);
+}
+
+TEST(MemorySanitizer, lgamma_r) {
+  int sgn;
+  double res = lgamma_r(1.1, &sgn);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(sgn);
+}
+
+TEST(MemorySanitizer, lgammaf_r) {
+  int sgn;
+  float res = lgammaf_r(1.1, &sgn);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(sgn);
+}
+
+// There's no lgammal_r() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, lgammal_r) {
+  int sgn;
+  long double res = lgammal_r(1.1, &sgn);
+  ASSERT_NE(0.0, res);
+  EXPECT_NOT_POISONED(sgn);
+}
+#endif
+
+// There's no drand48_r() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, drand48_r) {
+  struct drand48_data buf;
+  srand48_r(0, &buf);
+  double d;
+  drand48_r(&buf, &d);
+  EXPECT_NOT_POISONED(d);
+}
+#endif
+
+// There's no lrand48_r() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, lrand48_r) {
+  struct drand48_data buf;
+  srand48_r(0, &buf);
+  long d;
+  lrand48_r(&buf, &d);
+  EXPECT_NOT_POISONED(d);
+}
+#endif
+
+TEST(MemorySanitizer, sprintf) {  // NOLINT
+  char buff[10];
+  break_optimization(buff);
+  EXPECT_POISONED(buff[0]);
+  int res = sprintf(buff, "%d", 1234567);  // NOLINT
+  ASSERT_EQ(res, 7);
+  ASSERT_EQ(buff[0], '1');
+  ASSERT_EQ(buff[1], '2');
+  ASSERT_EQ(buff[2], '3');
+  ASSERT_EQ(buff[6], '7');
+  ASSERT_EQ(buff[7], 0);
+  EXPECT_POISONED(buff[8]);
+}
+
+TEST(MemorySanitizer, snprintf) {
+  char buff[10];
+  break_optimization(buff);
+  EXPECT_POISONED(buff[0]);
+  int res = snprintf(buff, sizeof(buff), "%d", 1234567);
+  ASSERT_EQ(res, 7);
+  ASSERT_EQ(buff[0], '1');
+  ASSERT_EQ(buff[1], '2');
+  ASSERT_EQ(buff[2], '3');
+  ASSERT_EQ(buff[6], '7');
+  ASSERT_EQ(buff[7], 0);
+  EXPECT_POISONED(buff[8]);
+}
+
+TEST(MemorySanitizer, swprintf) {
+  wchar_t buff[10];
+  ASSERT_EQ(4U, sizeof(wchar_t));
+  break_optimization(buff);
+  EXPECT_POISONED(buff[0]);
+  int res = swprintf(buff, 9, L"%d", 1234567);
+  ASSERT_EQ(res, 7);
+  ASSERT_EQ(buff[0], '1');
+  ASSERT_EQ(buff[1], '2');
+  ASSERT_EQ(buff[2], '3');
+  ASSERT_EQ(buff[6], '7');
+  ASSERT_EQ(buff[7], L'\0');
+  EXPECT_POISONED(buff[8]);
+}
+
+TEST(MemorySanitizer, asprintf) {  // NOLINT
+  char *pbuf;
+  EXPECT_POISONED(pbuf);
+  int res = asprintf(&pbuf, "%d", 1234567);  // NOLINT
+  ASSERT_EQ(res, 7);
+  EXPECT_NOT_POISONED(pbuf);
+  ASSERT_EQ(pbuf[0], '1');
+  ASSERT_EQ(pbuf[1], '2');
+  ASSERT_EQ(pbuf[2], '3');
+  ASSERT_EQ(pbuf[6], '7');
+  ASSERT_EQ(pbuf[7], 0);
+  free(pbuf);
+}
+
+TEST(MemorySanitizer, mbstowcs) {
+  const char *x = "abc";
+  wchar_t buff[10];
+  int res = mbstowcs(buff, x, 2);
+  EXPECT_EQ(2, res);
+  EXPECT_EQ(L'a', buff[0]);
+  EXPECT_EQ(L'b', buff[1]);
+  EXPECT_POISONED(buff[2]);
+  res = mbstowcs(buff, x, 10);
+  EXPECT_EQ(3, res);
+  EXPECT_NOT_POISONED(buff[3]);
+}
+
+TEST(MemorySanitizer, wcstombs) {
+  const wchar_t *x = L"abc";
+  char buff[10];
+  int res = wcstombs(buff, x, 4);
+  EXPECT_EQ(res, 3);
+  EXPECT_EQ(buff[0], 'a');
+  EXPECT_EQ(buff[1], 'b');
+  EXPECT_EQ(buff[2], 'c');
+}
+
+TEST(MemorySanitizer, wcsrtombs) {
+  const wchar_t *x = L"abc";
+  const wchar_t *p = x;
+  char buff[10];
+  mbstate_t mbs;
+  memset(&mbs, 0, sizeof(mbs));
+  int res = wcsrtombs(buff, &p, 4, &mbs);
+  EXPECT_EQ(res, 3);
+  EXPECT_EQ(buff[0], 'a');
+  EXPECT_EQ(buff[1], 'b');
+  EXPECT_EQ(buff[2], 'c');
+  EXPECT_EQ(buff[3], '\0');
+  EXPECT_POISONED(buff[4]);
+}
+
+TEST(MemorySanitizer, wcsnrtombs) {
+  const wchar_t *x = L"abc";
+  const wchar_t *p = x;
+  char buff[10];
+  mbstate_t mbs;
+  memset(&mbs, 0, sizeof(mbs));
+  int res = wcsnrtombs(buff, &p, 2, 4, &mbs);
+  EXPECT_EQ(res, 2);
+  EXPECT_EQ(buff[0], 'a');
+  EXPECT_EQ(buff[1], 'b');
+  EXPECT_POISONED(buff[2]);
+}
+
+TEST(MemorySanitizer, wcrtomb) {
+  wchar_t x = L'a';
+  char buff[10];
+  mbstate_t mbs;
+  memset(&mbs, 0, sizeof(mbs));
+  size_t res = wcrtomb(buff, x, &mbs);
+  EXPECT_EQ(res, (size_t)1);
+  EXPECT_EQ(buff[0], 'a');
+}
+
+TEST(MemorySanitizer, wmemset) {
+    wchar_t x[25];
+    break_optimization(x);
+    EXPECT_POISONED(x[0]);
+    wmemset(x, L'A', 10);
+    EXPECT_EQ(x[0], L'A');
+    EXPECT_EQ(x[9], L'A');
+    EXPECT_POISONED(x[10]);
+}
+
+TEST(MemorySanitizer, mbtowc) {
+  const char *x = "abc";
+  wchar_t wx;
+  int res = mbtowc(&wx, x, 3);
+  EXPECT_GT(res, 0);
+  EXPECT_NOT_POISONED(wx);
+}
+
+TEST(MemorySanitizer, mbrtowc) {
+  const char *x = "abc";
+  wchar_t wx;
+  mbstate_t mbs;
+  memset(&mbs, 0, sizeof(mbs));
+  int res = mbrtowc(&wx, x, 3, &mbs);
+  EXPECT_GT(res, 0);
+  EXPECT_NOT_POISONED(wx);
+}
+
+TEST(MemorySanitizer, wcsftime) {
+  wchar_t x[100];
+  time_t t = time(NULL);
+  struct tm tms;
+  struct tm *tmres = localtime_r(&t, &tms);
+  ASSERT_NE((void *)0, tmres);
+  size_t res = wcsftime(x, sizeof(x) / sizeof(x[0]), L"%Y-%m-%d", tmres);
+  EXPECT_GT(res, 0UL);
+  EXPECT_EQ(res, wcslen(x));
+}
+
+TEST(MemorySanitizer, gettimeofday) {
+  struct timeval tv;
+  struct timezone tz;
+  break_optimization(&tv);
+  break_optimization(&tz);
+  ASSERT_EQ(16U, sizeof(tv));
+  ASSERT_EQ(8U, sizeof(tz));
+  EXPECT_POISONED(tv.tv_sec);
+  EXPECT_POISONED(tv.tv_usec);
+  EXPECT_POISONED(tz.tz_minuteswest);
+  EXPECT_POISONED(tz.tz_dsttime);
+  ASSERT_EQ(0, gettimeofday(&tv, &tz));
+  EXPECT_NOT_POISONED(tv.tv_sec);
+  EXPECT_NOT_POISONED(tv.tv_usec);
+  EXPECT_NOT_POISONED(tz.tz_minuteswest);
+  EXPECT_NOT_POISONED(tz.tz_dsttime);
+}
+
+TEST(MemorySanitizer, clock_gettime) {
+  struct timespec tp;
+  EXPECT_POISONED(tp.tv_sec);
+  EXPECT_POISONED(tp.tv_nsec);
+  ASSERT_EQ(0, clock_gettime(CLOCK_REALTIME, &tp));
+  EXPECT_NOT_POISONED(tp.tv_sec);
+  EXPECT_NOT_POISONED(tp.tv_nsec);
+}
+
+TEST(MemorySanitizer, clock_getres) {
+  struct timespec tp;
+  EXPECT_POISONED(tp.tv_sec);
+  EXPECT_POISONED(tp.tv_nsec);
+  ASSERT_EQ(0, clock_getres(CLOCK_REALTIME, 0));
+  EXPECT_POISONED(tp.tv_sec);
+  EXPECT_POISONED(tp.tv_nsec);
+  ASSERT_EQ(0, clock_getres(CLOCK_REALTIME, &tp));
+  EXPECT_NOT_POISONED(tp.tv_sec);
+  EXPECT_NOT_POISONED(tp.tv_nsec);
+}
+
+TEST(MemorySanitizer, getitimer) {
+  struct itimerval it1, it2;
+  int res;
+  EXPECT_POISONED(it1.it_interval.tv_sec);
+  EXPECT_POISONED(it1.it_interval.tv_usec);
+  EXPECT_POISONED(it1.it_value.tv_sec);
+  EXPECT_POISONED(it1.it_value.tv_usec);
+  res = getitimer(ITIMER_VIRTUAL, &it1);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(it1.it_interval.tv_sec);
+  EXPECT_NOT_POISONED(it1.it_interval.tv_usec);
+  EXPECT_NOT_POISONED(it1.it_value.tv_sec);
+  EXPECT_NOT_POISONED(it1.it_value.tv_usec);
+
+  it1.it_interval.tv_sec = it1.it_value.tv_sec = 10000;
+  it1.it_interval.tv_usec = it1.it_value.tv_usec = 0;
+
+  res = setitimer(ITIMER_VIRTUAL, &it1, &it2);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(it2.it_interval.tv_sec);
+  EXPECT_NOT_POISONED(it2.it_interval.tv_usec);
+  EXPECT_NOT_POISONED(it2.it_value.tv_sec);
+  EXPECT_NOT_POISONED(it2.it_value.tv_usec);
+
+  // Check that old_value can be 0, and disable the timer.
+  memset(&it1, 0, sizeof(it1));
+  res = setitimer(ITIMER_VIRTUAL, &it1, 0);
+  ASSERT_EQ(0, res);
+}
+
+TEST(MemorySanitizer, setitimer_null) {
+  setitimer(ITIMER_VIRTUAL, 0, 0);
+  // Not testing the return value, since it the behaviour seems to differ
+  // between libc implementations and POSIX.
+  // Should never crash, though.
+}
+
+TEST(MemorySanitizer, time) {
+  time_t t;
+  EXPECT_POISONED(t);
+  time_t t2 = time(&t);
+  ASSERT_NE(t2, (time_t)-1);
+  EXPECT_NOT_POISONED(t);
+}
+
+TEST(MemorySanitizer, strptime) {
+  struct tm time;
+  char *p = strptime("11/1/2013-05:39", "%m/%d/%Y-%H:%M", &time);
+  ASSERT_TRUE(p != NULL);
+  EXPECT_NOT_POISONED(time.tm_sec);
+  EXPECT_NOT_POISONED(time.tm_hour);
+  EXPECT_NOT_POISONED(time.tm_year);
+}
+
+TEST(MemorySanitizer, localtime) {
+  time_t t = 123;
+  struct tm *time = localtime(&t);
+  ASSERT_TRUE(time != NULL);
+  EXPECT_NOT_POISONED(time->tm_sec);
+  EXPECT_NOT_POISONED(time->tm_hour);
+  EXPECT_NOT_POISONED(time->tm_year);
+  EXPECT_NOT_POISONED(time->tm_isdst);
+  EXPECT_NE(0U, strlen(time->tm_zone));
+}
+
+TEST(MemorySanitizer, localtime_r) {
+  time_t t = 123;
+  struct tm time;
+  struct tm *res = localtime_r(&t, &time);
+  ASSERT_TRUE(res != NULL);
+  EXPECT_NOT_POISONED(time.tm_sec);
+  EXPECT_NOT_POISONED(time.tm_hour);
+  EXPECT_NOT_POISONED(time.tm_year);
+  EXPECT_NOT_POISONED(time.tm_isdst);
+  EXPECT_NE(0U, strlen(time.tm_zone));
+}
+
+// There's no getmntent() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, getmntent) {
+  FILE *fp = setmntent("/etc/fstab", "r");
+  struct mntent *mnt = getmntent(fp);
+  ASSERT_TRUE(mnt != NULL);
+  ASSERT_NE(0U, strlen(mnt->mnt_fsname));
+  ASSERT_NE(0U, strlen(mnt->mnt_dir));
+  ASSERT_NE(0U, strlen(mnt->mnt_type));
+  ASSERT_NE(0U, strlen(mnt->mnt_opts));
+  EXPECT_NOT_POISONED(mnt->mnt_freq);
+  EXPECT_NOT_POISONED(mnt->mnt_passno);
+  fclose(fp);
+}
+#endif
+
+// There's no getmntent_r() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, getmntent_r) {
+  FILE *fp = setmntent("/etc/fstab", "r");
+  struct mntent mntbuf;
+  char buf[1000];
+  struct mntent *mnt = getmntent_r(fp, &mntbuf, buf, sizeof(buf));
+  ASSERT_TRUE(mnt != NULL);
+  ASSERT_NE(0U, strlen(mnt->mnt_fsname));
+  ASSERT_NE(0U, strlen(mnt->mnt_dir));
+  ASSERT_NE(0U, strlen(mnt->mnt_type));
+  ASSERT_NE(0U, strlen(mnt->mnt_opts));
+  EXPECT_NOT_POISONED(mnt->mnt_freq);
+  EXPECT_NOT_POISONED(mnt->mnt_passno);
+  fclose(fp);
+}
+#endif
+
+TEST(MemorySanitizer, ether) {
+  const char *asc = "11:22:33:44:55:66";
+  struct ether_addr *paddr = ether_aton(asc);
+  EXPECT_NOT_POISONED(*paddr);
+
+  struct ether_addr addr;
+  paddr = ether_aton_r(asc, &addr);
+  ASSERT_EQ(paddr, &addr);
+  EXPECT_NOT_POISONED(addr);
+
+  char *s = ether_ntoa(&addr);
+  ASSERT_NE(0U, strlen(s));
+
+  char buf[100];
+  s = ether_ntoa_r(&addr, buf);
+  ASSERT_EQ(s, buf);
+  ASSERT_NE(0U, strlen(buf));
+}
+
+TEST(MemorySanitizer, mmap) {
+  const int size = 4096;
+  void *p1, *p2;
+  p1 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
+  __msan_poison(p1, size);
+  munmap(p1, size);
+  for (int i = 0; i < 1000; i++) {
+    p2 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
+    if (p2 == p1)
+      break;
+    else
+      munmap(p2, size);
+  }
+  if (p1 == p2) {
+    EXPECT_NOT_POISONED(*(char*)p2);
+    munmap(p2, size);
+  }
+}
+
+// There's no fcvt() on FreeBSD.
+#if !defined(__FreeBSD__)
+// FIXME: enable and add ecvt.
+// FIXME: check why msandr does nt handle fcvt.
+TEST(MemorySanitizer, fcvt) {
+  int a, b;
+  break_optimization(&a);
+  break_optimization(&b);
+  EXPECT_POISONED(a);
+  EXPECT_POISONED(b);
+  char *str = fcvt(12345.6789, 10, &a, &b);
+  EXPECT_NOT_POISONED(a);
+  EXPECT_NOT_POISONED(b);
+  ASSERT_NE(nullptr, str);
+  EXPECT_NOT_POISONED(str[0]);
+  ASSERT_NE(0U, strlen(str));
+}
+#endif
+
+// There's no fcvt_long() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, fcvt_long) {
+  int a, b;
+  break_optimization(&a);
+  break_optimization(&b);
+  EXPECT_POISONED(a);
+  EXPECT_POISONED(b);
+  char *str = fcvt(111111112345.6789, 10, &a, &b);
+  EXPECT_NOT_POISONED(a);
+  EXPECT_NOT_POISONED(b);
+  ASSERT_NE(nullptr, str);
+  EXPECT_NOT_POISONED(str[0]);
+  ASSERT_NE(0U, strlen(str));
+}
+#endif
+
+TEST(MemorySanitizer, memchr) {
+  char x[10];
+  break_optimization(x);
+  EXPECT_POISONED(x[0]);
+  x[2] = '2';
+  void *res;
+  EXPECT_UMR(res = memchr(x, '2', 10));
+  EXPECT_NOT_POISONED(res);
+  x[0] = '0';
+  x[1] = '1';
+  res = memchr(x, '2', 10);
+  EXPECT_EQ(&x[2], res);
+  EXPECT_UMR(res = memchr(x, '3', 10));
+  EXPECT_NOT_POISONED(res);
+}
+
+TEST(MemorySanitizer, memrchr) {
+  char x[10];
+  break_optimization(x);
+  EXPECT_POISONED(x[0]);
+  x[9] = '9';
+  void *res;
+  EXPECT_UMR(res = memrchr(x, '9', 10));
+  EXPECT_NOT_POISONED(res);
+  x[0] = '0';
+  x[1] = '1';
+  res = memrchr(x, '0', 2);
+  EXPECT_EQ(&x[0], res);
+  EXPECT_UMR(res = memrchr(x, '7', 10));
+  EXPECT_NOT_POISONED(res);
+}
+
+TEST(MemorySanitizer, frexp) {
+  int x;
+  x = *GetPoisoned<int>();
+  double r = frexp(1.1, &x);
+  EXPECT_NOT_POISONED(r);
+  EXPECT_NOT_POISONED(x);
+
+  x = *GetPoisoned<int>();
+  float rf = frexpf(1.1, &x);
+  EXPECT_NOT_POISONED(rf);
+  EXPECT_NOT_POISONED(x);
+
+  x = *GetPoisoned<int>();
+  double rl = frexpl(1.1, &x);
+  EXPECT_NOT_POISONED(rl);
+  EXPECT_NOT_POISONED(x);
+}
+
+namespace {
+
+static int cnt;
+
+void SigactionHandler(int signo, siginfo_t* si, void* uc) {
+  ASSERT_EQ(signo, SIGPROF);
+  ASSERT_TRUE(si != NULL);
+  EXPECT_NOT_POISONED(si->si_errno);
+  EXPECT_NOT_POISONED(si->si_pid);
+#if __linux__
+# if defined(__x86_64__)
+  EXPECT_NOT_POISONED(((ucontext_t*)uc)->uc_mcontext.gregs[REG_RIP]);
+# elif defined(__i386__)
+  EXPECT_NOT_POISONED(((ucontext_t*)uc)->uc_mcontext.gregs[REG_EIP]);
+# endif
+#endif
+  ++cnt;
+}
+
+TEST(MemorySanitizer, sigaction) {
+  struct sigaction act = {};
+  struct sigaction oldact = {};
+  struct sigaction origact = {};
+
+  sigaction(SIGPROF, 0, &origact);
+
+  act.sa_flags |= SA_SIGINFO;
+  act.sa_sigaction = &SigactionHandler;
+  sigaction(SIGPROF, &act, 0);
+
+  kill(getpid(), SIGPROF);
+
+  act.sa_flags &= ~SA_SIGINFO;
+  act.sa_handler = SIG_DFL;
+  sigaction(SIGPROF, &act, 0);
+
+  act.sa_flags &= ~SA_SIGINFO;
+  act.sa_handler = SIG_IGN;
+  sigaction(SIGPROF, &act, &oldact);
+  EXPECT_FALSE(oldact.sa_flags & SA_SIGINFO);
+  EXPECT_EQ(SIG_DFL, oldact.sa_handler);
+  kill(getpid(), SIGPROF);
+
+  act.sa_flags |= SA_SIGINFO;
+  act.sa_sigaction = &SigactionHandler;
+  sigaction(SIGPROF, &act, &oldact);
+  EXPECT_FALSE(oldact.sa_flags & SA_SIGINFO);
+  EXPECT_EQ(SIG_IGN, oldact.sa_handler);
+  kill(getpid(), SIGPROF);
+
+  act.sa_flags &= ~SA_SIGINFO;
+  act.sa_handler = SIG_DFL;
+  sigaction(SIGPROF, &act, &oldact);
+  EXPECT_TRUE(oldact.sa_flags & SA_SIGINFO);
+  EXPECT_EQ(&SigactionHandler, oldact.sa_sigaction);
+  EXPECT_EQ(2, cnt);
+
+  sigaction(SIGPROF, &origact, 0);
+}
+
+} // namespace
+
+
+TEST(MemorySanitizer, sigemptyset) {
+  sigset_t s;
+  EXPECT_POISONED(s);
+  int res = sigemptyset(&s);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(s);
+}
+
+TEST(MemorySanitizer, sigfillset) {
+  sigset_t s;
+  EXPECT_POISONED(s);
+  int res = sigfillset(&s);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(s);
+}
+
+TEST(MemorySanitizer, sigpending) {
+  sigset_t s;
+  EXPECT_POISONED(s);
+  int res = sigpending(&s);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(s);
+}
+
+TEST(MemorySanitizer, sigprocmask) {
+  sigset_t s;
+  EXPECT_POISONED(s);
+  int res = sigprocmask(SIG_BLOCK, 0, &s);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(s);
+}
+
+struct StructWithDtor {
+  ~StructWithDtor();
+};
+
+NOINLINE StructWithDtor::~StructWithDtor() {
+  break_optimization(0);
+}
+
+TEST(MemorySanitizer, Invoke) {
+  StructWithDtor s;  // Will cause the calls to become invokes.
+  EXPECT_NOT_POISONED(0);
+  EXPECT_POISONED(*GetPoisoned<int>());
+  EXPECT_NOT_POISONED(0);
+  EXPECT_POISONED(*GetPoisoned<int>());
+  EXPECT_POISONED(ReturnPoisoned<S4>());
+}
+
+TEST(MemorySanitizer, ptrtoint) {
+  // Test that shadow is propagated through pointer-to-integer conversion.
+  void* p = (void*)0xABCD;
+  __msan_poison(((char*)&p) + 1, sizeof(p));
+  EXPECT_NOT_POISONED((((uintptr_t)p) & 0xFF) == 0);
+
+  void* q = (void*)0xABCD;
+  __msan_poison(&q, sizeof(q) - 1);
+  EXPECT_POISONED((((uintptr_t)q) & 0xFF) == 0);
+}
+
+static void vaargsfn2(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, double));
+  va_end(vl);
+}
+
+static void vaargsfn(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  // The following call will overwrite __msan_param_tls.
+  // Checks after it test that arg shadow was somehow saved across the call.
+  vaargsfn2(1, 2, 3, 4, *GetPoisoned<double>());
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgTest) {
+  int* x = GetPoisoned<int>();
+  int* y = GetPoisoned<int>(4);
+  vaargsfn(1, 13, *x, 42, *y);
+}
+
+static void vaargsfn_many(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgManyTest) {
+  int* x = GetPoisoned<int>();
+  int* y = GetPoisoned<int>(4);
+  vaargsfn_many(1, 2, *x, 3, 4, 5, 6, 7, 8, 9, *y);
+}
+
+static void vaargsfn_pass2(va_list vl) {
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+}
+
+static void vaargsfn_pass(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_POISONED(va_arg(vl, int));
+  vaargsfn_pass2(vl);
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgPass) {
+  int* x = GetPoisoned<int>();
+  int* y = GetPoisoned<int>(4);
+  vaargsfn_pass(1, *x, 2, 3, *y);
+}
+
+static void vaargsfn_copy2(va_list vl) {
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+}
+
+static void vaargsfn_copy(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  va_list vl2;
+  va_copy(vl2, vl);
+  vaargsfn_copy2(vl2);
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgCopy) {
+  int* x = GetPoisoned<int>();
+  int* y = GetPoisoned<int>(4);
+  vaargsfn_copy(1, 2, *x, 3, *y);
+}
+
+static void vaargsfn_ptr(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_NOT_POISONED(va_arg(vl, int*));
+  EXPECT_POISONED(va_arg(vl, int*));
+  EXPECT_NOT_POISONED(va_arg(vl, int*));
+  EXPECT_POISONED(va_arg(vl, double*));
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgPtr) {
+  int** x = GetPoisoned<int*>();
+  double** y = GetPoisoned<double*>(8);
+  int z;
+  vaargsfn_ptr(1, &z, *x, &z, *y);
+}
+
+static void vaargsfn_overflow(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+  EXPECT_POISONED(va_arg(vl, double));
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+  EXPECT_POISONED(va_arg(vl, int*));
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+
+  EXPECT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, double));
+  EXPECT_POISONED(va_arg(vl, int*));
+
+  EXPECT_NOT_POISONED(va_arg(vl, int));
+  EXPECT_NOT_POISONED(va_arg(vl, double));
+  EXPECT_NOT_POISONED(va_arg(vl, int*));
+
+  EXPECT_POISONED(va_arg(vl, int));
+  EXPECT_POISONED(va_arg(vl, double));
+  EXPECT_POISONED(va_arg(vl, int*));
+
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgOverflow) {
+  int* x = GetPoisoned<int>();
+  double* y = GetPoisoned<double>(8);
+  int** p = GetPoisoned<int*>(16);
+  int z;
+  vaargsfn_overflow(1,
+      1, 2, *x, 4, 5, 6,
+      1.1, 2.2, 3.3, *y, 5.5, *p, 7.7, 8.8,
+      // the following args will overflow for sure
+      *x, *y, *p,
+      7, 9.9, &z,
+      *x, *y, *p);
+}
+
+static void vaargsfn_tlsoverwrite2(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  for (int i = 0; i < 20; ++i)
+    EXPECT_NOT_POISONED(va_arg(vl, int));
+  va_end(vl);
+}
+
+static void vaargsfn_tlsoverwrite(int guard, ...) {
+  // This call will overwrite TLS contents unless it's backed up somewhere.
+  vaargsfn_tlsoverwrite2(2,
+      42, 42, 42, 42, 42,
+      42, 42, 42, 42, 42,
+      42, 42, 42, 42, 42,
+      42, 42, 42, 42, 42); // 20x
+  va_list vl;
+  va_start(vl, guard);
+  for (int i = 0; i < 20; ++i)
+    EXPECT_POISONED(va_arg(vl, int));
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgTLSOverwrite) {
+  int* x = GetPoisoned<int>();
+  vaargsfn_tlsoverwrite(1,
+      *x, *x, *x, *x, *x,
+      *x, *x, *x, *x, *x,
+      *x, *x, *x, *x, *x,
+      *x, *x, *x, *x, *x); // 20x
+
+}
+
+struct StructByVal {
+  int a, b, c, d, e, f;
+};
+
+static void vaargsfn_structbyval(int guard, ...) {
+  va_list vl;
+  va_start(vl, guard);
+  {
+    StructByVal s = va_arg(vl, StructByVal);
+    EXPECT_NOT_POISONED(s.a);
+    EXPECT_POISONED(s.b);
+    EXPECT_NOT_POISONED(s.c);
+    EXPECT_POISONED(s.d);
+    EXPECT_NOT_POISONED(s.e);
+    EXPECT_POISONED(s.f);
+  }
+  {
+    StructByVal s = va_arg(vl, StructByVal);
+    EXPECT_NOT_POISONED(s.a);
+    EXPECT_POISONED(s.b);
+    EXPECT_NOT_POISONED(s.c);
+    EXPECT_POISONED(s.d);
+    EXPECT_NOT_POISONED(s.e);
+    EXPECT_POISONED(s.f);
+  }
+  va_end(vl);
+}
+
+TEST(MemorySanitizer, VAArgStructByVal) {
+  StructByVal s;
+  s.a = 1;
+  s.b = *GetPoisoned<int>();
+  s.c = 2;
+  s.d = *GetPoisoned<int>();
+  s.e = 3;
+  s.f = *GetPoisoned<int>();
+  vaargsfn_structbyval(0, s, s);
+}
+
+NOINLINE void StructByValTestFunc(struct StructByVal s) {
+  EXPECT_NOT_POISONED(s.a);
+  EXPECT_POISONED(s.b);
+  EXPECT_NOT_POISONED(s.c);
+  EXPECT_POISONED(s.d);
+  EXPECT_NOT_POISONED(s.e);
+  EXPECT_POISONED(s.f);
+}
+
+NOINLINE void StructByValTestFunc1(struct StructByVal s) {
+  StructByValTestFunc(s);
+}
+
+NOINLINE void StructByValTestFunc2(int z, struct StructByVal s) {
+  StructByValTestFunc(s);
+}
+
+TEST(MemorySanitizer, StructByVal) {
+  // Large aggregates are passed as "byval" pointer argument in LLVM.
+  struct StructByVal s;
+  s.a = 1;
+  s.b = *GetPoisoned<int>();
+  s.c = 2;
+  s.d = *GetPoisoned<int>();
+  s.e = 3;
+  s.f = *GetPoisoned<int>();
+  StructByValTestFunc(s);
+  StructByValTestFunc1(s);
+  StructByValTestFunc2(0, s);
+}
+
+
+#if MSAN_HAS_M128
+NOINLINE __m128i m128Eq(__m128i *a, __m128i *b) { return _mm_cmpeq_epi16(*a, *b); }
+NOINLINE __m128i m128Lt(__m128i *a, __m128i *b) { return _mm_cmplt_epi16(*a, *b); }
+TEST(MemorySanitizer, m128) {
+  __m128i a = _mm_set1_epi16(0x1234);
+  __m128i b = _mm_set1_epi16(0x7890);
+  EXPECT_NOT_POISONED(m128Eq(&a, &b));
+  EXPECT_NOT_POISONED(m128Lt(&a, &b));
+}
+// FIXME: add more tests for __m128i.
+#endif  // MSAN_HAS_M128
+
+// We should not complain when copying this poisoned hole.
+struct StructWithHole {
+  U4  a;
+  // 4-byte hole.
+  U8  b;
+};
+
+NOINLINE StructWithHole ReturnStructWithHole() {
+  StructWithHole res;
+  __msan_poison(&res, sizeof(res));
+  res.a = 1;
+  res.b = 2;
+  return res;
+}
+
+TEST(MemorySanitizer, StructWithHole) {
+  StructWithHole a = ReturnStructWithHole();
+  break_optimization(&a);
+}
+
+template <class T>
+NOINLINE T ReturnStruct() {
+  T res;
+  __msan_poison(&res, sizeof(res));
+  res.a = 1;
+  return res;
+}
+
+template <class T>
+NOINLINE void TestReturnStruct() {
+  T s1 = ReturnStruct<T>();
+  EXPECT_NOT_POISONED(s1.a);
+  EXPECT_POISONED(s1.b);
+}
+
+struct SSS1 {
+  int a, b, c;
+};
+struct SSS2 {
+  int b, a, c;
+};
+struct SSS3 {
+  int b, c, a;
+};
+struct SSS4 {
+  int c, b, a;
+};
+
+struct SSS5 {
+  int a;
+  float b;
+};
+struct SSS6 {
+  int a;
+  double b;
+};
+struct SSS7 {
+  S8 b;
+  int a;
+};
+struct SSS8 {
+  S2 b;
+  S8 a;
+};
+
+TEST(MemorySanitizer, IntStruct3) {
+  TestReturnStruct<SSS1>();
+  TestReturnStruct<SSS2>();
+  TestReturnStruct<SSS3>();
+  TestReturnStruct<SSS4>();
+  TestReturnStruct<SSS5>();
+  TestReturnStruct<SSS6>();
+  TestReturnStruct<SSS7>();
+  TestReturnStruct<SSS8>();
+}
+
+struct LongStruct {
+  U1 a1, b1;
+  U2 a2, b2;
+  U4 a4, b4;
+  U8 a8, b8;
+};
+
+NOINLINE LongStruct ReturnLongStruct1() {
+  LongStruct res;
+  __msan_poison(&res, sizeof(res));
+  res.a1 = res.a2 = res.a4 = res.a8 = 111;
+  // leaves b1, .., b8 poisoned.
+  return res;
+}
+
+NOINLINE LongStruct ReturnLongStruct2() {
+  LongStruct res;
+  __msan_poison(&res, sizeof(res));
+  res.b1 = res.b2 = res.b4 = res.b8 = 111;
+  // leaves a1, .., a8 poisoned.
+  return res;
+}
+
+TEST(MemorySanitizer, LongStruct) {
+  LongStruct s1 = ReturnLongStruct1();
+  __msan_print_shadow(&s1, sizeof(s1));
+  EXPECT_NOT_POISONED(s1.a1);
+  EXPECT_NOT_POISONED(s1.a2);
+  EXPECT_NOT_POISONED(s1.a4);
+  EXPECT_NOT_POISONED(s1.a8);
+
+  EXPECT_POISONED(s1.b1);
+  EXPECT_POISONED(s1.b2);
+  EXPECT_POISONED(s1.b4);
+  EXPECT_POISONED(s1.b8);
+
+  LongStruct s2 = ReturnLongStruct2();
+  __msan_print_shadow(&s2, sizeof(s2));
+  EXPECT_NOT_POISONED(s2.b1);
+  EXPECT_NOT_POISONED(s2.b2);
+  EXPECT_NOT_POISONED(s2.b4);
+  EXPECT_NOT_POISONED(s2.b8);
+
+  EXPECT_POISONED(s2.a1);
+  EXPECT_POISONED(s2.a2);
+  EXPECT_POISONED(s2.a4);
+  EXPECT_POISONED(s2.a8);
+}
+
+TEST(MemorySanitizer, getrlimit) {
+  struct rlimit limit;
+  __msan_poison(&limit, sizeof(limit));
+  int result = getrlimit(RLIMIT_DATA, &limit);
+  ASSERT_EQ(result, 0);
+  EXPECT_NOT_POISONED(limit.rlim_cur);
+  EXPECT_NOT_POISONED(limit.rlim_max);
+}
+
+TEST(MemorySanitizer, getrusage) {
+  struct rusage usage;
+  __msan_poison(&usage, sizeof(usage));
+  int result = getrusage(RUSAGE_SELF, &usage);
+  ASSERT_EQ(result, 0);
+  EXPECT_NOT_POISONED(usage.ru_utime.tv_sec);
+  EXPECT_NOT_POISONED(usage.ru_utime.tv_usec);
+  EXPECT_NOT_POISONED(usage.ru_stime.tv_sec);
+  EXPECT_NOT_POISONED(usage.ru_stime.tv_usec);
+  EXPECT_NOT_POISONED(usage.ru_maxrss);
+  EXPECT_NOT_POISONED(usage.ru_minflt);
+  EXPECT_NOT_POISONED(usage.ru_majflt);
+  EXPECT_NOT_POISONED(usage.ru_inblock);
+  EXPECT_NOT_POISONED(usage.ru_oublock);
+  EXPECT_NOT_POISONED(usage.ru_nvcsw);
+  EXPECT_NOT_POISONED(usage.ru_nivcsw);
+}
+
+#if defined(__FreeBSD__)
+static void GetProgramPath(char *buf, size_t sz) {
+  int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
+  int res = sysctl(mib, 4, buf, &sz, NULL, 0);
+  ASSERT_EQ(0, res);
+}
+#elif defined(__GLIBC__)
+static void GetProgramPath(char *buf, size_t sz) {
+  extern char *program_invocation_name;
+  int res = snprintf(buf, sz, "%s", program_invocation_name);
+  ASSERT_GE(res, 0);
+  ASSERT_LT((size_t)res, sz);
+}
+#else
+# error "TODO: port this"
+#endif
+
+static void dladdr_testfn() {}
+
+TEST(MemorySanitizer, dladdr) {
+  Dl_info info;
+  __msan_poison(&info, sizeof(info));
+  int result = dladdr((const void*)dladdr_testfn, &info);
+  ASSERT_NE(result, 0);
+  EXPECT_NOT_POISONED((unsigned long)info.dli_fname);
+  if (info.dli_fname)
+    EXPECT_NOT_POISONED(strlen(info.dli_fname));
+  EXPECT_NOT_POISONED((unsigned long)info.dli_fbase);
+  EXPECT_NOT_POISONED((unsigned long)info.dli_sname);
+  if (info.dli_sname)
+    EXPECT_NOT_POISONED(strlen(info.dli_sname));
+  EXPECT_NOT_POISONED((unsigned long)info.dli_saddr);
+}
+
+#ifndef MSAN_TEST_DISABLE_DLOPEN
+
+static int dl_phdr_callback(struct dl_phdr_info *info, size_t size, void *data) {
+  (*(int *)data)++;
+  EXPECT_NOT_POISONED(info->dlpi_addr);
+  EXPECT_NOT_POISONED(strlen(info->dlpi_name));
+  EXPECT_NOT_POISONED(info->dlpi_phnum);
+  for (int i = 0; i < info->dlpi_phnum; ++i)
+    EXPECT_NOT_POISONED(info->dlpi_phdr[i]);
+  return 0;
+}
+
+// Compute the path to our loadable DSO.  We assume it's in the same
+// directory.  Only use string routines that we intercept so far to do this.
+static void GetPathToLoadable(char *buf, size_t sz) {
+  char program_path[kMaxPathLength];
+  GetProgramPath(program_path, sizeof(program_path));
+
+  const char *last_slash = strrchr(program_path, '/');
+  ASSERT_NE(nullptr, last_slash);
+  size_t dir_len = (size_t)(last_slash - program_path);
+#if defined(__x86_64__)
+  static const char basename[] = "libmsan_loadable.x86_64.so";
+#elif defined(__MIPSEB__) || defined(MIPSEB)
+  static const char basename[] = "libmsan_loadable.mips64.so";
+#elif defined(__mips64)
+  static const char basename[] = "libmsan_loadable.mips64el.so";
+#elif defined(__aarch64__)
+  static const char basename[] = "libmsan_loadable.aarch64.so";
+#endif
+  int res = snprintf(buf, sz, "%.*s/%s",
+                     (int)dir_len, program_path, basename);
+  ASSERT_GE(res, 0);
+  ASSERT_LT((size_t)res, sz);
+}
+
+TEST(MemorySanitizer, dl_iterate_phdr) {
+  char path[kMaxPathLength];
+  GetPathToLoadable(path, sizeof(path));
+
+  // Having at least one dlopen'ed library in the process makes this more
+  // entertaining.
+  void *lib = dlopen(path, RTLD_LAZY);
+  ASSERT_NE((void*)0, lib);
+
+  int count = 0;
+  int result = dl_iterate_phdr(dl_phdr_callback, &count);
+  ASSERT_GT(count, 0);
+
+  dlclose(lib);
+}
+
+TEST(MemorySanitizer, dlopen) {
+  char path[kMaxPathLength];
+  GetPathToLoadable(path, sizeof(path));
+
+  // We need to clear shadow for globals when doing dlopen.  In order to test
+  // this, we have to poison the shadow for the DSO before we load it.  In
+  // general this is difficult, but the loader tends to reload things in the
+  // same place, so we open, close, and then reopen.  The global should always
+  // start out clean after dlopen.
+  for (int i = 0; i < 2; i++) {
+    void *lib = dlopen(path, RTLD_LAZY);
+    if (lib == NULL) {
+      printf("dlerror: %s\n", dlerror());
+      ASSERT_TRUE(lib != NULL);
+    }
+    void **(*get_dso_global)() = (void **(*)())dlsym(lib, "get_dso_global");
+    ASSERT_TRUE(get_dso_global != NULL);
+    void **dso_global = get_dso_global();
+    EXPECT_NOT_POISONED(*dso_global);
+    __msan_poison(dso_global, sizeof(*dso_global));
+    EXPECT_POISONED(*dso_global);
+    dlclose(lib);
+  }
+}
+
+// Regression test for a crash in dlopen() interceptor.
+TEST(MemorySanitizer, dlopenFailed) {
+  const char *path = "/libmsan_loadable_does_not_exist.so";
+  void *lib = dlopen(path, RTLD_LAZY);
+  ASSERT_TRUE(lib == NULL);
+}
+
+#endif // MSAN_TEST_DISABLE_DLOPEN
+
+// There's no sched_getaffinity() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, sched_getaffinity) {
+  cpu_set_t mask;
+  int res = sched_getaffinity(getpid(), sizeof(mask), &mask);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(mask);
+}
+#endif
+
+TEST(MemorySanitizer, scanf) {
+  const char *input = "42 hello";
+  int* d = new int;
+  char* s = new char[7];
+  int res = sscanf(input, "%d %5s", d, s);
+  printf("res %d\n", res);
+  ASSERT_EQ(res, 2);
+  EXPECT_NOT_POISONED(*d);
+  EXPECT_NOT_POISONED(s[0]);
+  EXPECT_NOT_POISONED(s[1]);
+  EXPECT_NOT_POISONED(s[2]);
+  EXPECT_NOT_POISONED(s[3]);
+  EXPECT_NOT_POISONED(s[4]);
+  EXPECT_NOT_POISONED(s[5]);
+  EXPECT_POISONED(s[6]);
+  delete[] s;
+  delete d;
+}
+
+static void *SimpleThread_threadfn(void* data) {
+  return new int;
+}
+
+TEST(MemorySanitizer, SimpleThread) {
+  pthread_t t;
+  void *p;
+  int res = pthread_create(&t, NULL, SimpleThread_threadfn, NULL);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(t);
+  res = pthread_join(t, &p);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(p);
+  delete (int*)p;
+}
+
+static void *SmallStackThread_threadfn(void* data) {
+  return 0;
+}
+
+#ifdef PTHREAD_STACK_MIN
+# define SMALLSTACKSIZE    PTHREAD_STACK_MIN
+# define SMALLPRESTACKSIZE PTHREAD_STACK_MIN
+#else
+# define SMALLSTACKSIZE    64 * 1024
+# define SMALLPRESTACKSIZE 16 * 1024
+#endif
+
+TEST(MemorySanitizer, SmallStackThread) {
+  pthread_attr_t attr;
+  pthread_t t;
+  void *p;
+  int res;
+  res = pthread_attr_init(&attr);
+  ASSERT_EQ(0, res);
+  res = pthread_attr_setstacksize(&attr, SMALLSTACKSIZE);
+  ASSERT_EQ(0, res);
+  res = pthread_create(&t, &attr, SmallStackThread_threadfn, NULL);
+  ASSERT_EQ(0, res);
+  res = pthread_join(t, &p);
+  ASSERT_EQ(0, res);
+  res = pthread_attr_destroy(&attr);
+  ASSERT_EQ(0, res);
+}
+
+TEST(MemorySanitizer, SmallPreAllocatedStackThread) {
+  pthread_attr_t attr;
+  pthread_t t;
+  int res;
+  res = pthread_attr_init(&attr);
+  ASSERT_EQ(0, res);
+  void *stack;
+  const size_t kStackSize = SMALLPRESTACKSIZE;
+  res = posix_memalign(&stack, 4096, kStackSize);
+  ASSERT_EQ(0, res);
+  res = pthread_attr_setstack(&attr, stack, kStackSize);
+  ASSERT_EQ(0, res);
+  res = pthread_create(&t, &attr, SmallStackThread_threadfn, NULL);
+  EXPECT_EQ(0, res);
+  res = pthread_join(t, NULL);
+  ASSERT_EQ(0, res);
+  res = pthread_attr_destroy(&attr);
+  ASSERT_EQ(0, res);
+}
+
+TEST(MemorySanitizer, pthread_attr_get) {
+  pthread_attr_t attr;
+  int res;
+  res = pthread_attr_init(&attr);
+  ASSERT_EQ(0, res);
+  {
+    int v;
+    res = pthread_attr_getdetachstate(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    size_t v;
+    res = pthread_attr_getguardsize(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    struct sched_param v;
+    res = pthread_attr_getschedparam(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    int v;
+    res = pthread_attr_getschedpolicy(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    int v;
+    res = pthread_attr_getinheritsched(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    int v;
+    res = pthread_attr_getscope(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    size_t v;
+    res = pthread_attr_getstacksize(&attr, &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  {
+    void *v;
+    size_t w;
+    res = pthread_attr_getstack(&attr, &v, &w);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+    EXPECT_NOT_POISONED(w);
+  }
+  {
+    cpu_set_t v;
+    res = pthread_attr_getaffinity_np(&attr, sizeof(v), &v);
+    ASSERT_EQ(0, res);
+    EXPECT_NOT_POISONED(v);
+  }
+  res = pthread_attr_destroy(&attr);
+  ASSERT_EQ(0, res);
+}
+
+TEST(MemorySanitizer, pthread_getschedparam) {
+  int policy;
+  struct sched_param param;
+  int res = pthread_getschedparam(pthread_self(), &policy, &param);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(policy);
+  EXPECT_NOT_POISONED(param.sched_priority);
+}
+
+TEST(MemorySanitizer, pthread_key_create) {
+  pthread_key_t key;
+  int res = pthread_key_create(&key, NULL);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(key);
+  res = pthread_key_delete(key);
+  ASSERT_EQ(0, res);
+}
+
+namespace {
+struct SignalCondArg {
+  pthread_cond_t* cond;
+  pthread_mutex_t* mu;
+  bool broadcast;
+};
+
+void *SignalCond(void *param) {
+  SignalCondArg *arg = reinterpret_cast<SignalCondArg *>(param);
+  pthread_mutex_lock(arg->mu);
+  if (arg->broadcast)
+    pthread_cond_broadcast(arg->cond);
+  else
+    pthread_cond_signal(arg->cond);
+  pthread_mutex_unlock(arg->mu);
+  return 0;
+}
+}  // namespace
+
+TEST(MemorySanitizer, pthread_cond_wait) {
+  pthread_cond_t cond;
+  pthread_mutex_t mu;
+  SignalCondArg args = {&cond, &mu, false};
+  pthread_cond_init(&cond, 0);
+  pthread_mutex_init(&mu, 0);
+  pthread_mutex_lock(&mu);
+
+  // signal
+  pthread_t thr;
+  pthread_create(&thr, 0, SignalCond, &args);
+  int res = pthread_cond_wait(&cond, &mu);
+  ASSERT_EQ(0, res);
+  pthread_join(thr, 0);
+
+  // broadcast
+  args.broadcast = true;
+  pthread_create(&thr, 0, SignalCond, &args);
+  res = pthread_cond_wait(&cond, &mu);
+  ASSERT_EQ(0, res);
+  pthread_join(thr, 0);
+
+  pthread_mutex_unlock(&mu);
+  pthread_mutex_destroy(&mu);
+  pthread_cond_destroy(&cond);
+}
+
+TEST(MemorySanitizer, tmpnam) {
+  char s[L_tmpnam];
+  char *res = tmpnam(s);
+  ASSERT_EQ(s, res);
+  EXPECT_NOT_POISONED(strlen(res));
+}
+
+TEST(MemorySanitizer, tempnam) {
+  char *res = tempnam(NULL, "zzz");
+  EXPECT_NOT_POISONED(strlen(res));
+  free(res);
+}
+
+TEST(MemorySanitizer, posix_memalign) {
+  void *p;
+  EXPECT_POISONED(p);
+  int res = posix_memalign(&p, 4096, 13);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(p);
+  EXPECT_EQ(0U, (uintptr_t)p % 4096);
+  free(p);
+}
+
+// There's no memalign() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, memalign) {
+  void *p = memalign(4096, 13);
+  EXPECT_EQ(0U, (uintptr_t)p % kPageSize);
+  free(p);
+}
+#endif
+
+TEST(MemorySanitizer, valloc) {
+  void *a = valloc(100);
+  EXPECT_EQ(0U, (uintptr_t)a % kPageSize);
+  free(a);
+}
+
+// There's no pvalloc() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, pvalloc) {
+  void *p = pvalloc(kPageSize + 100);
+  EXPECT_EQ(0U, (uintptr_t)p % kPageSize);
+  EXPECT_EQ(2 * kPageSize, __sanitizer_get_allocated_size(p));
+  free(p);
+
+  p = pvalloc(0);  // pvalloc(0) should allocate at least one page.
+  EXPECT_EQ(0U, (uintptr_t)p % kPageSize);
+  EXPECT_EQ(kPageSize, __sanitizer_get_allocated_size(p));
+  free(p);
+}
+#endif
+
+TEST(MemorySanitizer, inet_pton) {
+  const char *s = "1:0:0:0:0:0:0:8";
+  unsigned char buf[sizeof(struct in6_addr)];
+  int res = inet_pton(AF_INET6, s, buf);
+  ASSERT_EQ(1, res);
+  EXPECT_NOT_POISONED(buf[0]);
+  EXPECT_NOT_POISONED(buf[sizeof(struct in6_addr) - 1]);
+
+  char s_out[INET6_ADDRSTRLEN];
+  EXPECT_POISONED(s_out[3]);
+  const char *q = inet_ntop(AF_INET6, buf, s_out, INET6_ADDRSTRLEN);
+  ASSERT_NE((void*)0, q);
+  EXPECT_NOT_POISONED(s_out[3]);
+}
+
+TEST(MemorySanitizer, inet_aton) {
+  const char *s = "127.0.0.1";
+  struct in_addr in[2];
+  int res = inet_aton(s, in);
+  ASSERT_NE(0, res);
+  EXPECT_NOT_POISONED(in[0]);
+  EXPECT_POISONED(*(char *)(in + 1));
+}
+
+TEST(MemorySanitizer, uname) {
+  struct utsname u;
+  int res = uname(&u);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(strlen(u.sysname));
+  EXPECT_NOT_POISONED(strlen(u.nodename));
+  EXPECT_NOT_POISONED(strlen(u.release));
+  EXPECT_NOT_POISONED(strlen(u.version));
+  EXPECT_NOT_POISONED(strlen(u.machine));
+}
+
+TEST(MemorySanitizer, gethostname) {
+  char buf[100];
+  int res = gethostname(buf, 100);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(strlen(buf));
+}
+
+// There's no sysinfo() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, sysinfo) {
+  struct sysinfo info;
+  int res = sysinfo(&info);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(info);
+}
+#endif
+
+TEST(MemorySanitizer, getpwuid) {
+  struct passwd *p = getpwuid(0); // root
+  ASSERT_TRUE(p != NULL);
+  EXPECT_NOT_POISONED(p->pw_name);
+  ASSERT_TRUE(p->pw_name != NULL);
+  EXPECT_NOT_POISONED(p->pw_name[0]);
+  EXPECT_NOT_POISONED(p->pw_uid);
+  ASSERT_EQ(0U, p->pw_uid);
+}
+
+TEST(MemorySanitizer, getpwuid_r) {
+  struct passwd pwd;
+  struct passwd *pwdres;
+  char buf[10000];
+  int res = getpwuid_r(0, &pwd, buf, sizeof(buf), &pwdres);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(pwd.pw_name);
+  ASSERT_TRUE(pwd.pw_name != NULL);
+  EXPECT_NOT_POISONED(pwd.pw_name[0]);
+  EXPECT_NOT_POISONED(pwd.pw_uid);
+  ASSERT_EQ(0U, pwd.pw_uid);
+  EXPECT_NOT_POISONED(pwdres);
+}
+
+TEST(MemorySanitizer, getpwnam_r) {
+  struct passwd pwd;
+  struct passwd *pwdres;
+  char buf[10000];
+  int res = getpwnam_r("root", &pwd, buf, sizeof(buf), &pwdres);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(pwd.pw_name);
+  ASSERT_TRUE(pwd.pw_name != NULL);
+  EXPECT_NOT_POISONED(pwd.pw_name[0]);
+  EXPECT_NOT_POISONED(pwd.pw_uid);
+  ASSERT_EQ(0U, pwd.pw_uid);
+  EXPECT_NOT_POISONED(pwdres);
+}
+
+TEST(MemorySanitizer, getpwnam_r_positive) {
+  struct passwd pwd;
+  struct passwd *pwdres;
+  char s[5];
+  strncpy(s, "abcd", 5);
+  __msan_poison(s, 5);
+  char buf[10000];
+  int res;
+  EXPECT_UMR(res = getpwnam_r(s, &pwd, buf, sizeof(buf), &pwdres));
+}
+
+TEST(MemorySanitizer, getgrnam_r) {
+  struct group grp;
+  struct group *grpres;
+  char buf[10000];
+  int res = getgrnam_r(SUPERUSER_GROUP, &grp, buf, sizeof(buf), &grpres);
+  ASSERT_EQ(0, res);
+  // Note that getgrnam_r() returns 0 if the matching group is not found.
+  ASSERT_NE(nullptr, grpres);
+  EXPECT_NOT_POISONED(grp.gr_name);
+  ASSERT_TRUE(grp.gr_name != NULL);
+  EXPECT_NOT_POISONED(grp.gr_name[0]);
+  EXPECT_NOT_POISONED(grp.gr_gid);
+  EXPECT_NOT_POISONED(grpres);
+}
+
+TEST(MemorySanitizer, getpwent) {
+  setpwent();
+  struct passwd *p = getpwent();
+  ASSERT_TRUE(p != NULL);
+  EXPECT_NOT_POISONED(p->pw_name);
+  ASSERT_TRUE(p->pw_name != NULL);
+  EXPECT_NOT_POISONED(p->pw_name[0]);
+  EXPECT_NOT_POISONED(p->pw_uid);
+}
+
+TEST(MemorySanitizer, getpwent_r) {
+  struct passwd pwd;
+  struct passwd *pwdres;
+  char buf[10000];
+  setpwent();
+  int res = getpwent_r(&pwd, buf, sizeof(buf), &pwdres);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(pwd.pw_name);
+  ASSERT_TRUE(pwd.pw_name != NULL);
+  EXPECT_NOT_POISONED(pwd.pw_name[0]);
+  EXPECT_NOT_POISONED(pwd.pw_uid);
+  EXPECT_NOT_POISONED(pwdres);
+}
+
+// There's no fgetpwent() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, fgetpwent) {
+  FILE *fp = fopen("/etc/passwd", "r");
+  struct passwd *p = fgetpwent(fp);
+  ASSERT_TRUE(p != NULL);
+  EXPECT_NOT_POISONED(p->pw_name);
+  ASSERT_TRUE(p->pw_name != NULL);
+  EXPECT_NOT_POISONED(p->pw_name[0]);
+  EXPECT_NOT_POISONED(p->pw_uid);
+  fclose(fp);
+}
+#endif
+
+TEST(MemorySanitizer, getgrent) {
+  setgrent();
+  struct group *p = getgrent();
+  ASSERT_TRUE(p != NULL);
+  EXPECT_NOT_POISONED(p->gr_name);
+  ASSERT_TRUE(p->gr_name != NULL);
+  EXPECT_NOT_POISONED(p->gr_name[0]);
+  EXPECT_NOT_POISONED(p->gr_gid);
+}
+
+// There's no fgetgrent() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, fgetgrent) {
+  FILE *fp = fopen("/etc/group", "r");
+  struct group *grp = fgetgrent(fp);
+  ASSERT_TRUE(grp != NULL);
+  EXPECT_NOT_POISONED(grp->gr_name);
+  ASSERT_TRUE(grp->gr_name != NULL);
+  EXPECT_NOT_POISONED(grp->gr_name[0]);
+  EXPECT_NOT_POISONED(grp->gr_gid);
+  for (char **p = grp->gr_mem; *p; ++p) {
+    EXPECT_NOT_POISONED((*p)[0]);
+    EXPECT_TRUE(strlen(*p) > 0);
+  }
+  fclose(fp);
+}
+#endif
+
+TEST(MemorySanitizer, getgrent_r) {
+  struct group grp;
+  struct group *grpres;
+  char buf[10000];
+  setgrent();
+  int res = getgrent_r(&grp, buf, sizeof(buf), &grpres);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(grp.gr_name);
+  ASSERT_TRUE(grp.gr_name != NULL);
+  EXPECT_NOT_POISONED(grp.gr_name[0]);
+  EXPECT_NOT_POISONED(grp.gr_gid);
+  EXPECT_NOT_POISONED(grpres);
+}
+
+// There's no fgetgrent_r() on FreeBSD.
+#if !defined(__FreeBSD__)
+TEST(MemorySanitizer, fgetgrent_r) {
+  FILE *fp = fopen("/etc/group", "r");
+  struct group grp;
+  struct group *grpres;
+  char buf[10000];
+  setgrent();
+  int res = fgetgrent_r(fp, &grp, buf, sizeof(buf), &grpres);
+  ASSERT_EQ(0, res);
+  EXPECT_NOT_POISONED(grp.gr_name);
+  ASSERT_TRUE(grp.gr_name != NULL);
+  EXPECT_NOT_POISONED(grp.gr_name[0]);
+  EXPECT_NOT_POISONED(grp.gr_gid);
+  EXPECT_NOT_POISONED(grpres);
+  fclose(fp);
+}
+#endif
+
+TEST(MemorySanitizer, getgroups) {
+  int n = getgroups(0, 0);
+  gid_t *gids = new gid_t[n];
+  int res = getgroups(n, gids);
+  ASSERT_EQ(n, res);
+  for (int i = 0; i < n; ++i)
+    EXPECT_NOT_POISONED(gids[i]);
+}
+
+TEST(MemorySanitizer, wordexp) {
+  wordexp_t w;
+  int res = wordexp("a b c", &w, 0);
+  ASSERT_EQ(0, res);
+  ASSERT_EQ(3U, w.we_wordc);
+  ASSERT_STREQ("a", w.we_wordv[0]);
+  ASSERT_STREQ("b", w.we_wordv[1]);
+  ASSERT_STREQ("c", w.we_wordv[2]);
+}
+
+template<class T>
+static bool applySlt(T value, T shadow) {
+  __msan_partial_poison(&value, &shadow, sizeof(T));
+  volatile bool zzz = true;
+  // This "|| zzz" trick somehow makes LLVM emit "icmp slt" instead of
+  // a shift-and-trunc to get at the highest bit.
+  volatile bool v = value < 0 || zzz;
+  return v;
+}
+
+TEST(MemorySanitizer, SignedCompareWithZero) {
+  EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0xF));
+  EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0xFF));
+  EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0xFFFFFF));
+  EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0x7FFFFFF));
+  EXPECT_UMR(applySlt<S4>(0xF, 0x80FFFFFF));
+  EXPECT_UMR(applySlt<S4>(0xF, 0xFFFFFFFF));
+}
+
+template <class T, class S>
+static T poisoned(T Va, S Sa) {
+  char SIZE_CHECK1[(ssize_t)sizeof(T) - (ssize_t)sizeof(S)];
+  char SIZE_CHECK2[(ssize_t)sizeof(S) - (ssize_t)sizeof(T)];
+  T a;
+  a = Va;
+  __msan_partial_poison(&a, &Sa, sizeof(T));
+  return a;
+}
+
+TEST(MemorySanitizer, ICmpRelational) {
+  EXPECT_NOT_POISONED(poisoned(0, 0) < poisoned(0, 0));
+  EXPECT_NOT_POISONED(poisoned(0U, 0) < poisoned(0U, 0));
+  EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) < poisoned(0LL, 0LLU));
+  EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) < poisoned(0LLU, 0LLU));
+  EXPECT_POISONED(poisoned(0xFF, 0xFF) < poisoned(0xFF, 0xFF));
+  EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) <
+                  poisoned(0xFFFFFFFFU, 0xFFFFFFFFU));
+  EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) <
+                  poisoned(-1, 0xFFFFFFFFU));
+
+  EXPECT_NOT_POISONED(poisoned(0, 0) <= poisoned(0, 0));
+  EXPECT_NOT_POISONED(poisoned(0U, 0) <= poisoned(0U, 0));
+  EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) <= poisoned(0LL, 0LLU));
+  EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) <= poisoned(0LLU, 0LLU));
+  EXPECT_POISONED(poisoned(0xFF, 0xFF) <= poisoned(0xFF, 0xFF));
+  EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) <=
+                  poisoned(0xFFFFFFFFU, 0xFFFFFFFFU));
+  EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) <=
+                  poisoned(-1, 0xFFFFFFFFU));
+
+  EXPECT_NOT_POISONED(poisoned(0, 0) > poisoned(0, 0));
+  EXPECT_NOT_POISONED(poisoned(0U, 0) > poisoned(0U, 0));
+  EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) > poisoned(0LL, 0LLU));
+  EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) > poisoned(0LLU, 0LLU));
+  EXPECT_POISONED(poisoned(0xFF, 0xFF) > poisoned(0xFF, 0xFF));
+  EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) >
+                  poisoned(0xFFFFFFFFU, 0xFFFFFFFFU));
+  EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) >
+                  poisoned(-1, 0xFFFFFFFFU));
+
+  EXPECT_NOT_POISONED(poisoned(0, 0) >= poisoned(0, 0));
+  EXPECT_NOT_POISONED(poisoned(0U, 0) >= poisoned(0U, 0));
+  EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) >= poisoned(0LL, 0LLU));
+  EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) >= poisoned(0LLU, 0LLU));
+  EXPECT_POISONED(poisoned(0xFF, 0xFF) >= poisoned(0xFF, 0xFF));
+  EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) >=
+                  poisoned(0xFFFFFFFFU, 0xFFFFFFFFU));
+  EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) >=
+                  poisoned(-1, 0xFFFFFFFFU));
+
+  EXPECT_POISONED(poisoned(6, 0xF) > poisoned(7, 0));
+  EXPECT_POISONED(poisoned(0xF, 0xF) > poisoned(7, 0));
+
+  EXPECT_NOT_POISONED(poisoned(-1, 0x80000000U) >= poisoned(-1, 0U));
+}
+
+#if MSAN_HAS_M128
+TEST(MemorySanitizer, ICmpVectorRelational) {
+  EXPECT_NOT_POISONED(
+      _mm_cmplt_epi16(poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0)),
+                   poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0))));
+  EXPECT_NOT_POISONED(
+      _mm_cmplt_epi16(poisoned(_mm_set1_epi32(0), _mm_set1_epi32(0)),
+                   poisoned(_mm_set1_epi32(0), _mm_set1_epi32(0))));
+  EXPECT_POISONED(
+      _mm_cmplt_epi16(poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0xFFFF)),
+                   poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0xFFFF))));
+  EXPECT_POISONED(_mm_cmpgt_epi16(poisoned(_mm_set1_epi16(6), _mm_set1_epi16(0xF)),
+                               poisoned(_mm_set1_epi16(7), _mm_set1_epi16(0))));
+}
+#endif
+
+// Volatile bitfield store is implemented as load-mask-store
+// Test that we don't warn on the store of (uninitialized) padding.
+struct VolatileBitfieldStruct {
+  volatile unsigned x : 1;
+  unsigned y : 1;
+};
+
+TEST(MemorySanitizer, VolatileBitfield) {
+  VolatileBitfieldStruct *S = new VolatileBitfieldStruct;
+  S->x = 1;
+  EXPECT_NOT_POISONED((unsigned)S->x);
+  EXPECT_POISONED((unsigned)S->y);
+}
+
+TEST(MemorySanitizer, UnalignedLoad) {
+  char x[32] __attribute__((aligned(8)));
+  U4 origin = __LINE__;
+  for (unsigned i = 0; i < sizeof(x) / 4; ++i)
+    __msan_set_origin(x + 4 * i, 4, origin + i);
+
+  memset(x + 8, 0, 16);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load16(x + 6), origin + 1);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load16(x + 7), origin + 1);
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load16(x + 8));
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load16(x + 9));
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load16(x + 22));
+  EXPECT_POISONED_O(__sanitizer_unaligned_load16(x + 23), origin + 6);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load16(x + 24), origin + 6);
+
+  EXPECT_POISONED_O(__sanitizer_unaligned_load32(x + 4), origin + 1);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load32(x + 7), origin + 1);
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load32(x + 8));
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load32(x + 9));
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load32(x + 20));
+  EXPECT_POISONED_O(__sanitizer_unaligned_load32(x + 21), origin + 6);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load32(x + 24), origin + 6);
+
+  EXPECT_POISONED_O(__sanitizer_unaligned_load64(x), origin);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load64(x + 1), origin);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load64(x + 7), origin + 1);
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load64(x + 8));
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load64(x + 9));
+  EXPECT_NOT_POISONED(__sanitizer_unaligned_load64(x + 16));
+  EXPECT_POISONED_O(__sanitizer_unaligned_load64(x + 17), origin + 6);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load64(x + 21), origin + 6);
+  EXPECT_POISONED_O(__sanitizer_unaligned_load64(x + 24), origin + 6);
+}
+
+TEST(MemorySanitizer, UnalignedStore16) {
+  char x[5] __attribute__((aligned(4)));
+  U2 y2 = 0;
+  U4 origin = __LINE__;
+  __msan_poison(&y2, 1);
+  __msan_set_origin(&y2, 1, origin);
+
+  __sanitizer_unaligned_store16(x + 1, y2);
+  EXPECT_POISONED_O(x[0], origin);
+  EXPECT_POISONED_O(x[1], origin);
+  EXPECT_NOT_POISONED(x[2]);
+  EXPECT_POISONED_O(x[3], origin);
+}
+
+TEST(MemorySanitizer, UnalignedStore32) {
+  char x[8] __attribute__((aligned(4)));
+  U4 y4 = 0;
+  U4 origin = __LINE__;
+  __msan_poison(&y4, 2);
+  __msan_set_origin(&y4, 2, origin);
+
+  __sanitizer_unaligned_store32(x + 3, y4);
+  EXPECT_POISONED_O(x[0], origin);
+  EXPECT_POISONED_O(x[1], origin);
+  EXPECT_POISONED_O(x[2], origin);
+  EXPECT_POISONED_O(x[3], origin);
+  EXPECT_POISONED_O(x[4], origin);
+  EXPECT_NOT_POISONED(x[5]);
+  EXPECT_NOT_POISONED(x[6]);
+  EXPECT_POISONED_O(x[7], origin);
+}
+
+TEST(MemorySanitizer, UnalignedStore64) {
+  char x[16] __attribute__((aligned(8)));
+  U8 y8 = 0;
+  U4 origin = __LINE__;
+  __msan_poison(&y8, 3);
+  __msan_poison(((char *)&y8) + sizeof(y8) - 2, 1);
+  __msan_set_origin(&y8, 8, origin);
+
+  __sanitizer_unaligned_store64(x + 3, y8);
+  EXPECT_POISONED_O(x[0], origin);
+  EXPECT_POISONED_O(x[1], origin);
+  EXPECT_POISONED_O(x[2], origin);
+  EXPECT_POISONED_O(x[3], origin);
+  EXPECT_POISONED_O(x[4], origin);
+  EXPECT_POISONED_O(x[5], origin);
+  EXPECT_NOT_POISONED(x[6]);
+  EXPECT_NOT_POISONED(x[7]);
+  EXPECT_NOT_POISONED(x[8]);
+  EXPECT_POISONED_O(x[9], origin);
+  EXPECT_NOT_POISONED(x[10]);
+  EXPECT_POISONED_O(x[11], origin);
+}
+
+TEST(MemorySanitizer, UnalignedStore16_precise) {
+  char x[8] __attribute__((aligned(4)));
+  U2 y = 0;
+  U4 originx1 = __LINE__;
+  U4 originx2 = __LINE__;
+  U4 originy = __LINE__;
+  __msan_poison(x, sizeof(x));
+  __msan_set_origin(x, 4, originx1);
+  __msan_set_origin(x + 4, 4, originx2);
+  __msan_poison(((char *)&y) + 1, 1);
+  __msan_set_origin(&y, sizeof(y), originy);
+
+  __sanitizer_unaligned_store16(x + 3, y);
+  EXPECT_POISONED_O(x[0], originx1);
+  EXPECT_POISONED_O(x[1], originx1);
+  EXPECT_POISONED_O(x[2], originx1);
+  EXPECT_NOT_POISONED(x[3]);
+  EXPECT_POISONED_O(x[4], originy);
+  EXPECT_POISONED_O(x[5], originy);
+  EXPECT_POISONED_O(x[6], originy);
+  EXPECT_POISONED_O(x[7], originy);
+}
+
+TEST(MemorySanitizer, UnalignedStore16_precise2) {
+  char x[8] __attribute__((aligned(4)));
+  U2 y = 0;
+  U4 originx1 = __LINE__;
+  U4 originx2 = __LINE__;
+  U4 originy = __LINE__;
+  __msan_poison(x, sizeof(x));
+  __msan_set_origin(x, 4, originx1);
+  __msan_set_origin(x + 4, 4, originx2);
+  __msan_poison(((char *)&y), 1);
+  __msan_set_origin(&y, sizeof(y), originy);
+
+  __sanitizer_unaligned_store16(x + 3, y);
+  EXPECT_POISONED_O(x[0], originy);
+  EXPECT_POISONED_O(x[1], originy);
+  EXPECT_POISONED_O(x[2], originy);
+  EXPECT_POISONED_O(x[3], originy);
+  EXPECT_NOT_POISONED(x[4]);
+  EXPECT_POISONED_O(x[5], originx2);
+  EXPECT_POISONED_O(x[6], originx2);
+  EXPECT_POISONED_O(x[7], originx2);
+}
+
+TEST(MemorySanitizer, UnalignedStore64_precise) {
+  char x[12] __attribute__((aligned(8)));
+  U8 y = 0;
+  U4 originx1 = __LINE__;
+  U4 originx2 = __LINE__;
+  U4 originx3 = __LINE__;
+  U4 originy = __LINE__;
+  __msan_poison(x, sizeof(x));
+  __msan_set_origin(x, 4, originx1);
+  __msan_set_origin(x + 4, 4, originx2);
+  __msan_set_origin(x + 8, 4, originx3);
+  __msan_poison(((char *)&y) + 1, 1);
+  __msan_poison(((char *)&y) + 7, 1);
+  __msan_set_origin(&y, sizeof(y), originy);
+
+  __sanitizer_unaligned_store64(x + 2, y);
+  EXPECT_POISONED_O(x[0], originy);
+  EXPECT_POISONED_O(x[1], originy);
+  EXPECT_NOT_POISONED(x[2]);
+  EXPECT_POISONED_O(x[3], originy);
+
+  EXPECT_NOT_POISONED(x[4]);
+  EXPECT_NOT_POISONED(x[5]);
+  EXPECT_NOT_POISONED(x[6]);
+  EXPECT_NOT_POISONED(x[7]);
+
+  EXPECT_NOT_POISONED(x[8]);
+  EXPECT_POISONED_O(x[9], originy);
+  EXPECT_POISONED_O(x[10], originy);
+  EXPECT_POISONED_O(x[11], originy);
+}
+
+TEST(MemorySanitizer, UnalignedStore64_precise2) {
+  char x[12] __attribute__((aligned(8)));
+  U8 y = 0;
+  U4 originx1 = __LINE__;
+  U4 originx2 = __LINE__;
+  U4 originx3 = __LINE__;
+  U4 originy = __LINE__;
+  __msan_poison(x, sizeof(x));
+  __msan_set_origin(x, 4, originx1);
+  __msan_set_origin(x + 4, 4, originx2);
+  __msan_set_origin(x + 8, 4, originx3);
+  __msan_poison(((char *)&y) + 3, 3);
+  __msan_set_origin(&y, sizeof(y), originy);
+
+  __sanitizer_unaligned_store64(x + 2, y);
+  EXPECT_POISONED_O(x[0], originx1);
+  EXPECT_POISONED_O(x[1], originx1);
+  EXPECT_NOT_POISONED(x[2]);
+  EXPECT_NOT_POISONED(x[3]);
+
+  EXPECT_NOT_POISONED(x[4]);
+  EXPECT_POISONED_O(x[5], originy);
+  EXPECT_POISONED_O(x[6], originy);
+  EXPECT_POISONED_O(x[7], originy);
+
+  EXPECT_NOT_POISONED(x[8]);
+  EXPECT_NOT_POISONED(x[9]);
+  EXPECT_POISONED_O(x[10], originx3);
+  EXPECT_POISONED_O(x[11], originx3);
+}
+
+#if (defined(__x86_64__) && defined(__clang__))
+namespace {
+typedef U1 V16x8 __attribute__((__vector_size__(16)));
+typedef U2 V8x16 __attribute__((__vector_size__(16)));
+typedef U4 V4x32 __attribute__((__vector_size__(16)));
+typedef U8 V2x64 __attribute__((__vector_size__(16)));
+typedef U4 V8x32 __attribute__((__vector_size__(32)));
+typedef U8 V4x64 __attribute__((__vector_size__(32)));
+typedef U4 V2x32 __attribute__((__vector_size__(8)));
+typedef U2 V4x16 __attribute__((__vector_size__(8)));
+typedef U1 V8x8 __attribute__((__vector_size__(8)));
+
+
+V8x16 shift_sse2_left_scalar(V8x16 x, U4 y) {
+  return _mm_slli_epi16(x, y);
+}
+
+V8x16 shift_sse2_left(V8x16 x, V8x16 y) {
+  return _mm_sll_epi16(x, y);
+}
+
+TEST(VectorShiftTest, sse2_left_scalar) {
+  V8x16 v = {Poisoned<U2>(0, 3), Poisoned<U2>(0, 7), 2, 3, 4, 5, 6, 7};
+  V8x16 u = shift_sse2_left_scalar(v, 2);
+  EXPECT_POISONED(u[0]);
+  EXPECT_POISONED(u[1]);
+  EXPECT_NOT_POISONED(u[0] | (3U << 2));
+  EXPECT_NOT_POISONED(u[1] | (7U << 2));
+  u[0] = u[1] = 0;
+  EXPECT_NOT_POISONED(u);
+}
+
+TEST(VectorShiftTest, sse2_left_scalar_by_uninit) {
+  V8x16 v = {0, 1, 2, 3, 4, 5, 6, 7};
+  V8x16 u = shift_sse2_left_scalar(v, Poisoned<U4>());
+  EXPECT_POISONED(u[0]);
+  EXPECT_POISONED(u[1]);
+  EXPECT_POISONED(u[2]);
+  EXPECT_POISONED(u[3]);
+  EXPECT_POISONED(u[4]);
+  EXPECT_POISONED(u[5]);
+  EXPECT_POISONED(u[6]);
+  EXPECT_POISONED(u[7]);
+}
+
+TEST(VectorShiftTest, sse2_left) {
+  V8x16 v = {Poisoned<U2>(0, 3), Poisoned<U2>(0, 7), 2, 3, 4, 5, 6, 7};
+  // Top 64 bits of shift count don't affect the result.
+  V2x64 s = {2, Poisoned<U8>()};
+  V8x16 u = shift_sse2_left(v, s);
+  EXPECT_POISONED(u[0]);
+  EXPECT_POISONED(u[1]);
+  EXPECT_NOT_POISONED(u[0] | (3U << 2));
+  EXPECT_NOT_POISONED(u[1] | (7U << 2));
+  u[0] = u[1] = 0;
+  EXPECT_NOT_POISONED(u);
+}
+
+TEST(VectorShiftTest, sse2_left_by_uninit) {
+  V8x16 v = {Poisoned<U2>(0, 3), Poisoned<U2>(0, 7), 2, 3, 4, 5, 6, 7};
+  V2x64 s = {Poisoned<U8>(), Poisoned<U8>()};
+  V8x16 u = shift_sse2_left(v, s);
+  EXPECT_POISONED(u[0]);
+  EXPECT_POISONED(u[1]);
+  EXPECT_POISONED(u[2]);
+  EXPECT_POISONED(u[3]);
+  EXPECT_POISONED(u[4]);
+  EXPECT_POISONED(u[5]);
+  EXPECT_POISONED(u[6]);
+  EXPECT_POISONED(u[7]);
+}
+
+#ifdef __AVX2__
+V4x32 shift_avx2_left(V4x32 x, V4x32 y) {
+  return _mm_sllv_epi32(x, y);
+}
+// This is variable vector shift that's only available starting with AVX2.
+// V4x32 shift_avx2_left(V4x32 x, V4x32 y) {
+TEST(VectorShiftTest, avx2_left) {
+  V4x32 v = {Poisoned<U2>(0, 3), Poisoned<U2>(0, 7), 2, 3};
+  V4x32 s = {2, Poisoned<U4>(), 3, Poisoned<U4>()};
+  V4x32 u = shift_avx2_left(v, s);
+  EXPECT_POISONED(u[0]);
+  EXPECT_NOT_POISONED(u[0] | (~7U));
+  EXPECT_POISONED(u[1]);
+  EXPECT_POISONED(u[1] | (~31U));
+  EXPECT_NOT_POISONED(u[2]);
+  EXPECT_POISONED(u[3]);
+  EXPECT_POISONED(u[3] | (~31U));
+}
+#endif // __AVX2__
+} // namespace
+
+TEST(VectorPackTest, sse2_packssdw_128) {
+  const unsigned S2_max = (1 << 15) - 1;
+  V4x32 a = {Poisoned<U4>(0, 0xFF0000), Poisoned<U4>(0, 0xFFFF0000),
+             S2_max + 100, 4};
+  V4x32 b = {Poisoned<U4>(0, 0xFF), S2_max + 10000, Poisoned<U4>(0, 0xFF00),
+             S2_max};
+
+  V8x16 c = _mm_packs_epi32(a, b);
+
+  EXPECT_POISONED(c[0]);
+  EXPECT_POISONED(c[1]);
+  EXPECT_NOT_POISONED(c[2]);
+  EXPECT_NOT_POISONED(c[3]);
+  EXPECT_POISONED(c[4]);
+  EXPECT_NOT_POISONED(c[5]);
+  EXPECT_POISONED(c[6]);
+  EXPECT_NOT_POISONED(c[7]);
+
+  EXPECT_EQ(c[2], S2_max);
+  EXPECT_EQ(c[3], 4);
+  EXPECT_EQ(c[5], S2_max);
+  EXPECT_EQ(c[7], S2_max);
+}
+
+TEST(VectorPackTest, mmx_packuswb) {
+  const unsigned U1_max = (1 << 8) - 1;
+  V4x16 a = {Poisoned<U2>(0, 0xFF00), Poisoned<U2>(0, 0xF000U), U1_max + 100,
+             4};
+  V4x16 b = {Poisoned<U2>(0, 0xFF), U1_max - 1, Poisoned<U2>(0, 0xF), U1_max};
+  V8x8 c = _mm_packs_pu16(a, b);
+
+  EXPECT_POISONED(c[0]);
+  EXPECT_POISONED(c[1]);
+  EXPECT_NOT_POISONED(c[2]);
+  EXPECT_NOT_POISONED(c[3]);
+  EXPECT_POISONED(c[4]);
+  EXPECT_NOT_POISONED(c[5]);
+  EXPECT_POISONED(c[6]);
+  EXPECT_NOT_POISONED(c[7]);
+
+  EXPECT_EQ(c[2], U1_max);
+  EXPECT_EQ(c[3], 4);
+  EXPECT_EQ(c[5], U1_max - 1);
+  EXPECT_EQ(c[7], U1_max);
+}
+
+TEST(VectorSadTest, sse2_psad_bw) {
+  V16x8 a = {Poisoned<U1>(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+  V16x8 b = {100, 101, 102, 103, 104, 105, 106, 107,
+             108, 109, 110, 111, 112, 113, 114, 115};
+  V2x64 c = _mm_sad_epu8(a, b);
+
+  EXPECT_POISONED(c[0]);
+  EXPECT_NOT_POISONED(c[1]);
+
+  EXPECT_EQ(800U, c[1]);
+}
+
+TEST(VectorMaddTest, mmx_pmadd_wd) {
+  V4x16 a = {Poisoned<U2>(), 1, 2, 3};
+  V4x16 b = {100, 101, 102, 103};
+  V2x32 c = _mm_madd_pi16(a, b);
+
+  EXPECT_POISONED(c[0]);
+  EXPECT_NOT_POISONED(c[1]);
+
+  EXPECT_EQ((unsigned)(2 * 102 + 3 * 103), c[1]);
+}
+#endif  // defined(__clang__)
+
+TEST(MemorySanitizerOrigins, SetGet) {
+  EXPECT_EQ(TrackingOrigins(), !!__msan_get_track_origins());
+  if (!TrackingOrigins()) return;
+  int x;
+  __msan_set_origin(&x, sizeof(x), 1234);
+  EXPECT_ORIGIN(1234U, __msan_get_origin(&x));
+  __msan_set_origin(&x, sizeof(x), 5678);
+  EXPECT_ORIGIN(5678U, __msan_get_origin(&x));
+  __msan_set_origin(&x, sizeof(x), 0);
+  EXPECT_ORIGIN(0U, __msan_get_origin(&x));
+}
+
+namespace {
+struct S {
+  U4 dummy;
+  U2 a;
+  U2 b;
+};
+
+TEST(MemorySanitizerOrigins, InitializedStoreDoesNotChangeOrigin) {
+  if (!TrackingOrigins()) return;
+
+  S s;
+  U4 origin = rand();  // NOLINT
+  s.a = *GetPoisonedO<U2>(0, origin);
+  EXPECT_ORIGIN(origin, __msan_get_origin(&s.a));
+  EXPECT_ORIGIN(origin, __msan_get_origin(&s.b));
+
+  s.b = 42;
+  EXPECT_ORIGIN(origin, __msan_get_origin(&s.a));
+  EXPECT_ORIGIN(origin, __msan_get_origin(&s.b));
+}
+}  // namespace
+
+template<class T, class BinaryOp>
+INLINE
+void BinaryOpOriginTest(BinaryOp op) {
+  U4 ox = rand();  //NOLINT
+  U4 oy = rand();  //NOLINT
+  T *x = GetPoisonedO<T>(0, ox, 0);
+  T *y = GetPoisonedO<T>(1, oy, 0);
+  T *z = GetPoisonedO<T>(2, 0, 0);
+
+  *z = op(*x, *y);
+  U4 origin = __msan_get_origin(z);
+  EXPECT_POISONED_O(*z, origin);
+  EXPECT_EQ(true, __msan_origin_is_descendant_or_same(origin, ox) ||
+                      __msan_origin_is_descendant_or_same(origin, oy));
+
+  // y is poisoned, x is not.
+  *x = 10101;
+  *y = *GetPoisonedO<T>(1, oy);
+  break_optimization(x);
+  __msan_set_origin(z, sizeof(*z), 0);
+  *z = op(*x, *y);
+  EXPECT_POISONED_O(*z, oy);
+  EXPECT_ORIGIN(oy, __msan_get_origin(z));
+
+  // x is poisoned, y is not.
+  *x = *GetPoisonedO<T>(0, ox);
+  *y = 10101010;
+  break_optimization(y);
+  __msan_set_origin(z, sizeof(*z), 0);
+  *z = op(*x, *y);
+  EXPECT_POISONED_O(*z, ox);
+  EXPECT_ORIGIN(ox, __msan_get_origin(z));
+}
+
+template<class T> INLINE T XOR(const T &a, const T&b) { return a ^ b; }
+template<class T> INLINE T ADD(const T &a, const T&b) { return a + b; }
+template<class T> INLINE T SUB(const T &a, const T&b) { return a - b; }
+template<class T> INLINE T MUL(const T &a, const T&b) { return a * b; }
+template<class T> INLINE T AND(const T &a, const T&b) { return a & b; }
+template<class T> INLINE T OR (const T &a, const T&b) { return a | b; }
+
+TEST(MemorySanitizerOrigins, BinaryOp) {
+  if (!TrackingOrigins()) return;
+  BinaryOpOriginTest<S8>(XOR<S8>);
+  BinaryOpOriginTest<U8>(ADD<U8>);
+  BinaryOpOriginTest<S4>(SUB<S4>);
+  BinaryOpOriginTest<S4>(MUL<S4>);
+  BinaryOpOriginTest<U4>(OR<U4>);
+  BinaryOpOriginTest<U4>(AND<U4>);
+  BinaryOpOriginTest<double>(ADD<U4>);
+  BinaryOpOriginTest<float>(ADD<S4>);
+  BinaryOpOriginTest<double>(ADD<double>);
+  BinaryOpOriginTest<float>(ADD<double>);
+}
+
+TEST(MemorySanitizerOrigins, Unary) {
+  if (!TrackingOrigins()) return;
+  EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__);
+
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+
+  EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__);
+
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+
+  EXPECT_POISONED_O((void*)*GetPoisonedO<S8>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O((U8)*GetPoisonedO<void*>(0, __LINE__), __LINE__);
+}
+
+TEST(MemorySanitizerOrigins, EQ) {
+  if (!TrackingOrigins()) return;
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__) <= 11, __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__) == 11, __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<float>(0, __LINE__) == 1.1, __LINE__);
+}
+
+TEST(MemorySanitizerOrigins, DIV) {
+  if (!TrackingOrigins()) return;
+  EXPECT_POISONED_O(*GetPoisonedO<U8>(0, __LINE__) / 100, __LINE__);
+  unsigned o = __LINE__;
+  EXPECT_UMR_O(volatile unsigned y = 100 / *GetPoisonedO<S4>(0, o, 1), o);
+}
+
+TEST(MemorySanitizerOrigins, SHIFT) {
+  if (!TrackingOrigins()) return;
+  EXPECT_POISONED_O(*GetPoisonedO<U8>(0, __LINE__) >> 10, __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__) >> 10, __LINE__);
+  EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__) << 10, __LINE__);
+  EXPECT_POISONED_O(10U << *GetPoisonedO<U8>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(-10 >> *GetPoisonedO<S8>(0, __LINE__), __LINE__);
+  EXPECT_POISONED_O(-10 << *GetPoisonedO<S8>(0, __LINE__), __LINE__);
+}
+
+template<class T, int N>
+void MemCpyTest() {
+  int ox = __LINE__;
+  T *x = new T[N];
+  T *y = new T[N];
+  T *z = new T[N];
+  T *q = new T[N];
+  __msan_poison(x, N * sizeof(T));
+  __msan_set_origin(x, N * sizeof(T), ox);
+  __msan_set_origin(y, N * sizeof(T), 777777);
+  __msan_set_origin(z, N * sizeof(T), 888888);
+  EXPECT_NOT_POISONED(x);
+  memcpy(y, x, N * sizeof(T));
+  EXPECT_POISONED_O(y[0], ox);
+  EXPECT_POISONED_O(y[N/2], ox);
+  EXPECT_POISONED_O(y[N-1], ox);
+  EXPECT_NOT_POISONED(x);
+  void *res = mempcpy(q, x, N * sizeof(T));
+  ASSERT_EQ(q + N, res);
+  EXPECT_POISONED_O(q[0], ox);
+  EXPECT_POISONED_O(q[N/2], ox);
+  EXPECT_POISONED_O(q[N-1], ox);
+  EXPECT_NOT_POISONED(x);
+  memmove(z, x, N * sizeof(T));
+  EXPECT_POISONED_O(z[0], ox);
+  EXPECT_POISONED_O(z[N/2], ox);
+  EXPECT_POISONED_O(z[N-1], ox);
+}
+
+TEST(MemorySanitizerOrigins, LargeMemCpy) {
+  if (!TrackingOrigins()) return;
+  MemCpyTest<U1, 10000>();
+  MemCpyTest<U8, 10000>();
+}
+
+TEST(MemorySanitizerOrigins, SmallMemCpy) {
+  if (!TrackingOrigins()) return;
+  MemCpyTest<U8, 1>();
+  MemCpyTest<U8, 2>();
+  MemCpyTest<U8, 3>();
+}
+
+TEST(MemorySanitizerOrigins, Select) {
+  if (!TrackingOrigins()) return;
+  EXPECT_NOT_POISONED(g_one ? 1 : *GetPoisonedO<S4>(0, __LINE__));
+  EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__);
+  S4 x;
+  break_optimization(&x);
+  x = g_1 ? *GetPoisonedO<S4>(0, __LINE__) : 0;
+
+  EXPECT_POISONED_O(g_1 ? *GetPoisonedO<S4>(0, __LINE__) : 1, __LINE__);
+  EXPECT_POISONED_O(g_0 ? 1 : *GetPoisonedO<S4>(0, __LINE__), __LINE__);
+}
+
+NOINLINE int RetvalOriginTest(U4 origin) {
+  int *a = new int;
+  break_optimization(a);
+  __msan_set_origin(a, sizeof(*a), origin);
+  int res = *a;
+  delete a;
+  return res;
+}
+
+TEST(MemorySanitizerOrigins, Retval) {
+  if (!TrackingOrigins()) return;
+  EXPECT_POISONED_O(RetvalOriginTest(__LINE__), __LINE__);
+}
+
+NOINLINE void ParamOriginTest(int param, U4 origin) {
+  EXPECT_POISONED_O(param, origin);
+}
+
+TEST(MemorySanitizerOrigins, Param) {
+  if (!TrackingOrigins()) return;
+  int *a = new int;
+  U4 origin = __LINE__;
+  break_optimization(a);
+  __msan_set_origin(a, sizeof(*a), origin);
+  ParamOriginTest(*a, origin);
+  delete a;
+}
+
+TEST(MemorySanitizerOrigins, Invoke) {
+  if (!TrackingOrigins()) return;
+  StructWithDtor s;  // Will cause the calls to become invokes.
+  EXPECT_POISONED_O(RetvalOriginTest(__LINE__), __LINE__);
+}
+
+TEST(MemorySanitizerOrigins, strlen) {
+  S8 alignment;
+  break_optimization(&alignment);
+  char x[4] = {'a', 'b', 0, 0};
+  __msan_poison(&x[2], 1);
+  U4 origin = __LINE__;
+  __msan_set_origin(x, sizeof(x), origin);
+  EXPECT_UMR_O(volatile unsigned y = strlen(x), origin);
+}
+
+TEST(MemorySanitizerOrigins, wcslen) {
+  wchar_t w[3] = {'a', 'b', 0};
+  U4 origin = __LINE__;
+  __msan_set_origin(w, sizeof(w), origin);
+  __msan_poison(&w[2], sizeof(wchar_t));
+  EXPECT_UMR_O(volatile unsigned y = wcslen(w), origin);
+}
+
+#if MSAN_HAS_M128
+TEST(MemorySanitizerOrigins, StoreIntrinsic) {
+  __m128 x, y;
+  U4 origin = __LINE__;
+  __msan_set_origin(&x, sizeof(x), origin);
+  __msan_poison(&x, sizeof(x));
+  __builtin_ia32_storeups((float*)&y, x);
+  EXPECT_POISONED_O(y, origin);
+}
+#endif
+
+NOINLINE void RecursiveMalloc(int depth) {
+  static int count;
+  count++;
+  if ((count % (1024 * 1024)) == 0)
+    printf("RecursiveMalloc: %d\n", count);
+  int *x1 = new int;
+  int *x2 = new int;
+  break_optimization(x1);
+  break_optimization(x2);
+  if (depth > 0) {
+    RecursiveMalloc(depth-1);
+    RecursiveMalloc(depth-1);
+  }
+  delete x1;
+  delete x2;
+}
+
+TEST(MemorySanitizer, Select) {
+  int x;
+  int volatile* p = &x;
+  int z = *p ? 1 : 0;
+  EXPECT_POISONED(z);
+}
+
+TEST(MemorySanitizer, SelectPartial) {
+  // Precise instrumentation of select.
+  // Some bits of the result do not depend on select condition, and must stay
+  // initialized even if select condition is not. These are the bits that are
+  // equal and initialized in both left and right select arguments.
+  U4 x = 0xFFFFABCDU;
+  U4 x_s = 0xFFFF0000U;
+  __msan_partial_poison(&x, &x_s, sizeof(x));
+  U4 y = 0xAB00U;
+  U1 cond = true;
+  __msan_poison(&cond, sizeof(cond));
+  U4 z = cond ? x : y;
+  __msan_print_shadow(&z, sizeof(z));
+  EXPECT_POISONED(z & 0xFFU);
+  EXPECT_NOT_POISONED(z & 0xFF00U);
+  EXPECT_POISONED(z & 0xFF0000U);
+  EXPECT_POISONED(z & 0xFF000000U);
+  EXPECT_EQ(0xAB00U, z & 0xFF00U);
+}
+
+TEST(MemorySanitizerStress, DISABLED_MallocStackTrace) {
+  RecursiveMalloc(22);
+}
+
+TEST(MemorySanitizerAllocator, get_estimated_allocated_size) {
+  size_t sizes[] = {0, 20, 5000, 1<<20};
+  for (size_t i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) {
+    size_t alloc_size = __sanitizer_get_estimated_allocated_size(sizes[i]);
+    EXPECT_EQ(alloc_size, sizes[i]);
+  }
+}
+
+TEST(MemorySanitizerAllocator, get_allocated_size_and_ownership) {
+  char *array = reinterpret_cast<char*>(malloc(100));
+  int *int_ptr = new int;
+
+  EXPECT_TRUE(__sanitizer_get_ownership(array));
+  EXPECT_EQ(100U, __sanitizer_get_allocated_size(array));
+
+  EXPECT_TRUE(__sanitizer_get_ownership(int_ptr));
+  EXPECT_EQ(sizeof(*int_ptr), __sanitizer_get_allocated_size(int_ptr));
+
+  void *wild_addr = reinterpret_cast<void*>(0x1);
+  EXPECT_FALSE(__sanitizer_get_ownership(wild_addr));
+  EXPECT_EQ(0U, __sanitizer_get_allocated_size(wild_addr));
+
+  EXPECT_FALSE(__sanitizer_get_ownership(array + 50));
+  EXPECT_EQ(0U, __sanitizer_get_allocated_size(array + 50));
+
+  // NULL is a valid argument for GetAllocatedSize but is not owned.
+  EXPECT_FALSE(__sanitizer_get_ownership(NULL));
+  EXPECT_EQ(0U, __sanitizer_get_allocated_size(NULL));
+
+  free(array);
+  EXPECT_FALSE(__sanitizer_get_ownership(array));
+  EXPECT_EQ(0U, __sanitizer_get_allocated_size(array));
+
+  delete int_ptr;
+}
+
+TEST(MemorySanitizer, MlockTest) {
+  EXPECT_EQ(0, mlockall(MCL_CURRENT));
+  EXPECT_EQ(0, mlock((void*)0x12345, 0x5678));
+  EXPECT_EQ(0, munlockall());
+  EXPECT_EQ(0, munlock((void*)0x987, 0x654));
+}
+
+// Test that LargeAllocator unpoisons memory before releasing it to the OS.
+TEST(MemorySanitizer, LargeAllocatorUnpoisonsOnFree) {
+  void *p = malloc(1024 * 1024);
+  free(p);
+
+  typedef void *(*mmap_fn)(void *, size_t, int, int, int, off_t);
+  mmap_fn real_mmap = (mmap_fn)dlsym(RTLD_NEXT, "mmap");
+
+  // Allocate the page that was released to the OS in free() with the real mmap,
+  // bypassing the interceptor.
+  char *q = (char *)real_mmap(p, 4096, PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  ASSERT_NE((char *)0, q);
+
+  ASSERT_TRUE(q <= p);
+  ASSERT_TRUE(q + 4096 > p);
+
+  EXPECT_NOT_POISONED(q[0]);
+  EXPECT_NOT_POISONED(q[10]);
+  EXPECT_NOT_POISONED(q[100]);
+
+  munmap(q, 4096);
+}
+
+#if SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE
+TEST(MemorySanitizer, MallocUsableSizeTest) {
+  const size_t kArraySize = 100;
+  char *array = Ident((char*)malloc(kArraySize));
+  int *int_ptr = Ident(new int);
+  EXPECT_EQ(0U, malloc_usable_size(NULL));
+  EXPECT_EQ(kArraySize, malloc_usable_size(array));
+  EXPECT_EQ(sizeof(int), malloc_usable_size(int_ptr));
+  free(array);
+  delete int_ptr;
+}
+#endif  // SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE
diff --git a/compiler-rt/lib/msan/tests/msan_test_config.h b/compiler-rt/lib/msan/tests/msan_test_config.h
new file mode 100644
index 0000000..5404c43
--- /dev/null
+++ b/compiler-rt/lib/msan/tests/msan_test_config.h
@@ -0,0 +1,20 @@
+//===-- msan_test_config.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+// MemorySanitizer unit tests.
+//===----------------------------------------------------------------------===//
+
+#ifndef MSAN_TEST_CONFIG_H
+#define MSAN_TEST_CONFIG_H
+
+#include "gtest/gtest.h"
+
+#endif // MSAN_TEST_CONFIG_H
diff --git a/compiler-rt/lib/msan/tests/msan_test_main.cc b/compiler-rt/lib/msan/tests/msan_test_main.cc
new file mode 100644
index 0000000..c8c5fef
--- /dev/null
+++ b/compiler-rt/lib/msan/tests/msan_test_main.cc
@@ -0,0 +1,21 @@
+//===-- msan_test_main.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of MemorySanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MSAN_EXTERNAL_TEST_CONFIG
+#include "msan_test_config.h"
+#endif // MSAN_EXTERNAL_TEST_CONFIG
+
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/compiler-rt/lib/profile/Android.bp b/compiler-rt/lib/profile/Android.bp
new file mode 100644
index 0000000..a0059e5
--- /dev/null
+++ b/compiler-rt/lib/profile/Android.bp
@@ -0,0 +1,48 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+//=====================================================================
+// Static Library: libprofile_rt
+//=====================================================================
+
+cc_library_static {
+    name: "libprofile_rt",
+    host_supported: true,
+
+    cflags: [
+        "-Werror",
+        "-Wall",
+    ],
+    clang: true,
+    srcs:  [
+        "GCDAProfiling.c",
+        "InstrProfiling.c",
+        "InstrProfilingBuffer.c",
+        "InstrProfilingFile.c",
+        "InstrProfilingPlatformDarwin.c",
+        "InstrProfilingPlatformOther.c",
+        "InstrProfilingRuntime.cc",
+        "InstrProfilingUtil.c",
+    ],
+
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+    stl: "none",
+    sdk_version: "21",
+}
diff --git a/compiler-rt/lib/profile/CMakeLists.txt b/compiler-rt/lib/profile/CMakeLists.txt
new file mode 100644
index 0000000..1b10ade
--- /dev/null
+++ b/compiler-rt/lib/profile/CMakeLists.txt
@@ -0,0 +1,71 @@
+
+CHECK_CXX_SOURCE_COMPILES("
+#ifdef _MSC_VER
+#include <Intrin.h> /* Workaround for PR19898. */
+#include <windows.h>
+#endif
+int main() {
+#ifdef _MSC_VER
+        volatile LONG val = 1;
+        MemoryBarrier();
+        InterlockedCompareExchange(&val, 0, 1);
+        InterlockedIncrement(&val);
+        InterlockedDecrement(&val);
+#else
+        volatile unsigned long val = 1;
+        __sync_synchronize();
+        __sync_val_compare_and_swap(&val, 1, 0);
+        __sync_add_and_fetch(&val, 1);
+        __sync_sub_and_fetch(&val, 1);
+#endif
+        return 0;
+      }
+" COMPILER_RT_TARGET_HAS_ATOMICS)
+
+add_custom_target(profile)
+
+set(PROFILE_SOURCES
+  GCDAProfiling.c
+  InstrProfiling.c
+  InstrProfilingValue.c
+  InstrProfilingBuffer.c
+  InstrProfilingFile.c
+  InstrProfilingWriter.c
+  InstrProfilingPlatformDarwin.c
+  InstrProfilingPlatformLinux.c
+  InstrProfilingPlatformOther.c
+  InstrProfilingRuntime.cc
+  InstrProfilingUtil.c)
+
+if(UNIX)
+ set(EXTRA_FLAGS
+     -fPIC
+     -Wno-pedantic)
+else()
+ set(EXTRA_FLAGS
+     -fPIC)
+endif()
+
+if(COMPILER_RT_TARGET_HAS_ATOMICS)
+ set(EXTRA_FLAGS
+     ${EXTRA_FLAGS}
+     -DCOMPILER_RT_HAS_ATOMICS=1)
+endif() 
+
+if(APPLE)
+  add_compiler_rt_runtime(clang_rt.profile
+    STATIC
+    OS ${PROFILE_SUPPORTED_OS}
+    ARCHS ${PROFILE_SUPPORTED_ARCH}
+    SOURCES ${PROFILE_SOURCES}
+    PARENT_TARGET profile)
+else()
+  add_compiler_rt_runtime(clang_rt.profile
+    STATIC
+    ARCHS ${PROFILE_SUPPORTED_ARCH}
+    CFLAGS ${EXTRA_FLAGS}
+    SOURCES ${PROFILE_SOURCES}
+    PARENT_TARGET profile)
+endif()
+
+add_dependencies(compiler-rt profile)
diff --git a/compiler-rt/lib/profile/GCDAProfiling.c b/compiler-rt/lib/profile/GCDAProfiling.c
new file mode 100644
index 0000000..aec2328
--- /dev/null
+++ b/compiler-rt/lib/profile/GCDAProfiling.c
@@ -0,0 +1,572 @@
+/*===- GCDAProfiling.c - Support library for GCDA file emission -----------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|* 
+|*===----------------------------------------------------------------------===*|
+|* 
+|* This file implements the call back routines for the gcov profiling
+|* instrumentation pass. Link against this library when running code through
+|* the -insert-gcov-profiling LLVM pass.
+|*
+|* We emit files in a corrupt version of GCOV's "gcda" file format. These files
+|* are only close enough that LCOV will happily parse them. Anything that lcov
+|* ignores is missing.
+|*
+|* TODO: gcov is multi-process safe by having each exit open the existing file
+|* and append to it. We'd like to achieve that and be thread-safe too.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfilingUtil.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/file.h>
+
+#define I386_FREEBSD (defined(__FreeBSD__) && defined(__i386__))
+
+#if !defined(_MSC_VER) && !I386_FREEBSD
+#include <stdint.h>
+#endif
+
+#if defined(_MSC_VER)
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+#elif I386_FREEBSD
+/* System headers define 'size_t' incorrectly on x64 FreeBSD (prior to
+ * FreeBSD 10, r232261) when compiled in 32-bit mode.
+ */
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+#endif
+
+/* #define DEBUG_GCDAPROFILING */
+
+/*
+ * --- GCOV file format I/O primitives ---
+ */
+
+/*
+ * The current file name we're outputting. Used primarily for error logging.
+ */
+static char *filename = NULL;
+
+/*
+ * The current file we're outputting.
+ */ 
+static FILE *output_file = NULL;
+
+/*
+ * Buffer that we write things into.
+ */
+#define WRITE_BUFFER_SIZE (128 * 1024)
+static char *write_buffer = NULL;
+static uint64_t cur_buffer_size = 0;
+static uint64_t cur_pos = 0;
+static uint64_t file_size = 0;
+static int new_file = 0;
+static int fd = -1;
+
+/*
+ * A list of functions to write out the data.
+ */
+typedef void (*writeout_fn)();
+
+struct writeout_fn_node {
+  writeout_fn fn;
+  struct writeout_fn_node *next;
+};
+
+static struct writeout_fn_node *writeout_fn_head = NULL;
+static struct writeout_fn_node *writeout_fn_tail = NULL;
+
+/*
+ *  A list of flush functions that our __gcov_flush() function should call.
+ */
+typedef void (*flush_fn)();
+
+struct flush_fn_node {
+  flush_fn fn;
+  struct flush_fn_node *next;
+};
+
+static struct flush_fn_node *flush_fn_head = NULL;
+static struct flush_fn_node *flush_fn_tail = NULL;
+
+static void resize_write_buffer(uint64_t size) {
+  if (!new_file) return;
+  size += cur_pos;
+  if (size <= cur_buffer_size) return;
+  size = (size - 1) / WRITE_BUFFER_SIZE + 1;
+  size *= WRITE_BUFFER_SIZE;
+  write_buffer = realloc(write_buffer, size);
+  cur_buffer_size = size;
+}
+
+static void write_bytes(const char *s, size_t len) {
+  resize_write_buffer(len);
+  memcpy(&write_buffer[cur_pos], s, len);
+  cur_pos += len;
+}
+
+static void write_32bit_value(uint32_t i) {
+  write_bytes((char*)&i, 4);
+}
+
+static void write_64bit_value(uint64_t i) {
+  write_bytes((char*)&i, 8);
+}
+
+static uint32_t length_of_string(const char *s) {
+  return (strlen(s) / 4) + 1;
+}
+
+static void write_string(const char *s) {
+  uint32_t len = length_of_string(s);
+  write_32bit_value(len);
+  write_bytes(s, strlen(s));
+  write_bytes("\0\0\0\0", 4 - (strlen(s) % 4));
+}
+
+static uint32_t read_32bit_value() {
+  uint32_t val;
+
+  if (new_file)
+    return (uint32_t)-1;
+
+  val = *(uint32_t*)&write_buffer[cur_pos];
+  cur_pos += 4;
+  return val;
+}
+
+static uint64_t read_64bit_value() {
+  uint64_t val;
+
+  if (new_file)
+    return (uint64_t)-1;
+
+  val = *(uint64_t*)&write_buffer[cur_pos];
+  cur_pos += 8;
+  return val;
+}
+
+static char *mangle_filename(const char *orig_filename) {
+  char *new_filename;
+  size_t filename_len, prefix_len;
+  int prefix_strip;
+  int level = 0;
+  const char *fname, *ptr;
+  const char *prefix = getenv("GCOV_PREFIX");
+  const char *prefix_strip_str = getenv("GCOV_PREFIX_STRIP");
+
+  if (prefix == NULL || prefix[0] == '\0')
+    return strdup(orig_filename);
+
+  if (prefix_strip_str) {
+    prefix_strip = atoi(prefix_strip_str);
+
+    /* Negative GCOV_PREFIX_STRIP values are ignored */
+    if (prefix_strip < 0)
+      prefix_strip = 0;
+  } else {
+    prefix_strip = 0;
+  }
+
+  fname = orig_filename;
+  for (level = 0, ptr = fname + 1; level < prefix_strip; ++ptr) {
+    if (*ptr == '\0')
+      break;
+    if (*ptr != '/')
+      continue;
+    fname = ptr;
+    ++level;
+  }
+
+  filename_len = strlen(fname);
+  prefix_len = strlen(prefix);
+  new_filename = malloc(prefix_len + 1 + filename_len + 1);
+  memcpy(new_filename, prefix, prefix_len);
+
+  if (prefix[prefix_len - 1] != '/')
+    new_filename[prefix_len++] = '/';
+  memcpy(new_filename + prefix_len, fname, filename_len + 1);
+
+  return new_filename;
+}
+
+static int map_file() {
+  fseek(output_file, 0L, SEEK_END);
+  file_size = ftell(output_file);
+
+  /* A size of 0 is invalid to `mmap'. Return a fail here, but don't issue an
+   * error message because it should "just work" for the user. */
+  if (file_size == 0)
+    return -1;
+
+  write_buffer = mmap(0, file_size, PROT_READ | PROT_WRITE,
+                      MAP_FILE | MAP_SHARED, fd, 0);
+  if (write_buffer == (void *)-1) {
+    int errnum = errno;
+    fprintf(stderr, "profiling: %s: cannot map: %s\n", filename,
+            strerror(errnum));
+    return -1;
+  }
+  return 0;
+}
+
+static void unmap_file() {
+  if (msync(write_buffer, file_size, MS_SYNC) == -1) {
+    int errnum = errno;
+    fprintf(stderr, "profiling: %s: cannot msync: %s\n", filename,
+            strerror(errnum));
+  }
+
+  /* We explicitly ignore errors from unmapping because at this point the data
+   * is written and we don't care.
+   */
+  (void)munmap(write_buffer, file_size);
+  write_buffer = NULL;
+  file_size = 0;
+}
+
+/*
+ * --- LLVM line counter API ---
+ */
+
+/* A file in this case is a translation unit. Each .o file built with line
+ * profiling enabled will emit to a different file. Only one file may be
+ * started at a time.
+ */
+void llvm_gcda_start_file(const char *orig_filename, const char version[4],
+                          uint32_t checksum) {
+  const char *mode = "r+b";
+  filename = mangle_filename(orig_filename);
+
+  /* Try just opening the file. */
+  new_file = 0;
+  fd = open(filename, O_RDWR);
+
+  if (fd == -1) {
+    /* Try opening the file, creating it if necessary. */
+    new_file = 1;
+    mode = "w+b";
+    fd = open(filename, O_RDWR | O_CREAT, 0644);
+    if (fd == -1) {
+      /* Try creating the directories first then opening the file. */
+      __llvm_profile_recursive_mkdir(filename);
+      fd = open(filename, O_RDWR | O_CREAT, 0644);
+      if (fd == -1) {
+        /* Bah! It's hopeless. */
+        int errnum = errno;
+        fprintf(stderr, "profiling: %s: cannot open: %s\n", filename,
+                strerror(errnum));
+        return;
+      }
+    }
+  }
+
+  /* Try to flock the file to serialize concurrent processes writing out to the
+   * same GCDA. This can fail if the filesystem doesn't support it, but in that
+   * case we'll just carry on with the old racy behaviour and hope for the best.
+   */
+  flock(fd, LOCK_EX);
+  output_file = fdopen(fd, mode);
+
+  /* Initialize the write buffer. */
+  write_buffer = NULL;
+  cur_buffer_size = 0;
+  cur_pos = 0;
+
+  if (new_file) {
+    resize_write_buffer(WRITE_BUFFER_SIZE);
+    memset(write_buffer, 0, WRITE_BUFFER_SIZE);
+  } else {
+    if (map_file() == -1) {
+      /* mmap failed, try to recover by clobbering */
+      new_file = 1;
+      write_buffer = NULL;
+      cur_buffer_size = 0;
+      resize_write_buffer(WRITE_BUFFER_SIZE);
+      memset(write_buffer, 0, WRITE_BUFFER_SIZE);
+    }
+  }
+
+  /* gcda file, version, stamp checksum. */
+  write_bytes("adcg", 4);
+  write_bytes(version, 4);
+  write_32bit_value(checksum);
+
+#ifdef DEBUG_GCDAPROFILING
+  fprintf(stderr, "llvmgcda: [%s]\n", orig_filename);
+#endif
+}
+
+/* Given an array of pointers to counters (counters), increment the n-th one,
+ * where we're also given a pointer to n (predecessor).
+ */
+void llvm_gcda_increment_indirect_counter(uint32_t *predecessor,
+                                          uint64_t **counters) {
+  uint64_t *counter;
+  uint32_t pred;
+
+  pred = *predecessor;
+  if (pred == 0xffffffff)
+    return;
+  counter = counters[pred];
+
+  /* Don't crash if the pred# is out of sync. This can happen due to threads,
+     or because of a TODO in GCOVProfiling.cpp buildEdgeLookupTable(). */
+  if (counter)
+    ++*counter;
+#ifdef DEBUG_GCDAPROFILING
+  else
+    fprintf(stderr,
+            "llvmgcda: increment_indirect_counter counters=%08llx, pred=%u\n",
+            *counter, *predecessor);
+#endif
+}
+
+void llvm_gcda_emit_function(uint32_t ident, const char *function_name,
+                             uint32_t func_checksum, uint8_t use_extra_checksum,
+                             uint32_t cfg_checksum) {
+  uint32_t len = 2;
+
+  if (use_extra_checksum)
+    len++;
+#ifdef DEBUG_GCDAPROFILING
+  fprintf(stderr, "llvmgcda: function id=0x%08x name=%s\n", ident,
+          function_name ? function_name : "NULL");
+#endif
+  if (!output_file) return;
+
+  /* function tag */
+  write_bytes("\0\0\0\1", 4);
+  if (function_name)
+    len += 1 + length_of_string(function_name);
+  write_32bit_value(len);
+  write_32bit_value(ident);
+  write_32bit_value(func_checksum);
+  if (use_extra_checksum)
+    write_32bit_value(cfg_checksum);
+  if (function_name)
+    write_string(function_name);
+}
+
+void llvm_gcda_emit_arcs(uint32_t num_counters, uint64_t *counters) {
+  uint32_t i;
+  uint64_t *old_ctrs = NULL;
+  uint32_t val = 0;
+  uint64_t save_cur_pos = cur_pos;
+
+  if (!output_file) return;
+
+  val = read_32bit_value();
+
+  if (val != (uint32_t)-1) {
+    /* There are counters present in the file. Merge them. */
+    if (val != 0x01a10000) {
+      fprintf(stderr, "profiling: %s: cannot merge previous GCDA file: "
+                      "corrupt arc tag (0x%08x)\n",
+              filename, val);
+      return;
+    }
+
+    val = read_32bit_value();
+    if (val == (uint32_t)-1 || val / 2 != num_counters) {
+      fprintf(stderr, "profiling: %s: cannot merge previous GCDA file: "
+                      "mismatched number of counters (%d)\n",
+              filename, val);
+      return;
+    }
+
+    old_ctrs = malloc(sizeof(uint64_t) * num_counters);
+    for (i = 0; i < num_counters; ++i)
+      old_ctrs[i] = read_64bit_value();
+  }
+
+  cur_pos = save_cur_pos;
+
+  /* Counter #1 (arcs) tag */
+  write_bytes("\0\0\xa1\1", 4);
+  write_32bit_value(num_counters * 2);
+  for (i = 0; i < num_counters; ++i) {
+    counters[i] += (old_ctrs ? old_ctrs[i] : 0);
+    write_64bit_value(counters[i]);
+  }
+
+  free(old_ctrs);
+
+#ifdef DEBUG_GCDAPROFILING
+  fprintf(stderr, "llvmgcda:   %u arcs\n", num_counters);
+  for (i = 0; i < num_counters; ++i)
+    fprintf(stderr, "llvmgcda:   %llu\n", (unsigned long long)counters[i]);
+#endif
+}
+
+void llvm_gcda_summary_info() {
+  const uint32_t obj_summary_len = 9; /* Length for gcov compatibility. */
+  uint32_t i;
+  uint32_t runs = 1;
+  uint32_t val = 0;
+  uint64_t save_cur_pos = cur_pos;
+
+  if (!output_file) return;
+
+  val = read_32bit_value();
+
+  if (val != (uint32_t)-1) {
+    /* There are counters present in the file. Merge them. */
+    if (val != 0xa1000000) {
+      fprintf(stderr, "profiling: %s: cannot merge previous run count: "
+                      "corrupt object tag (0x%08x)\n",
+              filename, val);
+      return;
+    }
+
+    val = read_32bit_value(); /* length */
+    if (val != obj_summary_len) {
+      fprintf(stderr, "profiling: %s: cannot merge previous run count: "
+                      "mismatched object length (%d)\n",
+              filename, val);
+      return;
+    }
+
+    read_32bit_value(); /* checksum, unused */
+    read_32bit_value(); /* num, unused */
+    runs += read_32bit_value(); /* Add previous run count to new counter. */
+  }
+
+  cur_pos = save_cur_pos;
+
+  /* Object summary tag */
+  write_bytes("\0\0\0\xa1", 4);
+  write_32bit_value(obj_summary_len);
+  write_32bit_value(0); /* checksum, unused */
+  write_32bit_value(0); /* num, unused */
+  write_32bit_value(runs);
+  for (i = 3; i < obj_summary_len; ++i)
+    write_32bit_value(0);
+
+  /* Program summary tag */
+  write_bytes("\0\0\0\xa3", 4); /* tag indicates 1 program */
+  write_32bit_value(0); /* 0 length */
+
+#ifdef DEBUG_GCDAPROFILING
+  fprintf(stderr, "llvmgcda:   %u runs\n", runs);
+#endif
+}
+
+void llvm_gcda_end_file() {
+  /* Write out EOF record. */
+  if (output_file) {
+    write_bytes("\0\0\0\0\0\0\0\0", 8);
+
+    if (new_file) {
+      fwrite(write_buffer, cur_pos, 1, output_file);
+      free(write_buffer);
+    } else {
+      unmap_file();
+    }
+
+    fclose(output_file);
+    flock(fd, LOCK_UN);
+    output_file = NULL;
+    write_buffer = NULL;
+  }
+  free(filename);
+
+#ifdef DEBUG_GCDAPROFILING
+  fprintf(stderr, "llvmgcda: -----\n");
+#endif
+}
+
+void llvm_register_writeout_function(writeout_fn fn) {
+  struct writeout_fn_node *new_node = malloc(sizeof(struct writeout_fn_node));
+  new_node->fn = fn;
+  new_node->next = NULL;
+
+  if (!writeout_fn_head) {
+    writeout_fn_head = writeout_fn_tail = new_node;
+  } else {
+    writeout_fn_tail->next = new_node;
+    writeout_fn_tail = new_node;
+  }
+}
+
+void llvm_writeout_files() {
+  struct writeout_fn_node *curr = writeout_fn_head;
+
+  while (curr) {
+    curr->fn();
+    curr = curr->next;
+  }
+}
+
+void llvm_delete_writeout_function_list() {
+  while (writeout_fn_head) {
+    struct writeout_fn_node *node = writeout_fn_head;
+    writeout_fn_head = writeout_fn_head->next;
+    free(node);
+  }
+  
+  writeout_fn_head = writeout_fn_tail = NULL;
+}
+
+void llvm_register_flush_function(flush_fn fn) {
+  struct flush_fn_node *new_node = malloc(sizeof(struct flush_fn_node));
+  new_node->fn = fn;
+  new_node->next = NULL;
+
+  if (!flush_fn_head) {
+    flush_fn_head = flush_fn_tail = new_node;
+  } else {
+    flush_fn_tail->next = new_node;
+    flush_fn_tail = new_node;
+  }
+}
+
+void __gcov_flush() {
+  struct flush_fn_node *curr = flush_fn_head;
+
+  while (curr) {
+    curr->fn();
+    curr = curr->next;
+  }
+}
+
+void llvm_delete_flush_function_list() {
+  while (flush_fn_head) {
+    struct flush_fn_node *node = flush_fn_head;
+    flush_fn_head = flush_fn_head->next;
+    free(node);
+  }
+
+  flush_fn_head = flush_fn_tail = NULL;
+}
+
+void llvm_gcov_init(writeout_fn wfn, flush_fn ffn) {
+  static int atexit_ran = 0;
+
+  if (wfn)
+    llvm_register_writeout_function(wfn);
+
+  if (ffn)
+    llvm_register_flush_function(ffn);
+
+  if (atexit_ran == 0) {
+    atexit_ran = 1;
+
+    /* Make sure we write out the data and delete the data structures. */
+    atexit(llvm_delete_flush_function_list);
+    atexit(llvm_delete_writeout_function_list);
+    atexit(llvm_writeout_files);
+  }
+}
diff --git a/compiler-rt/lib/profile/InstrProfData.inc b/compiler-rt/lib/profile/InstrProfData.inc
new file mode 100644
index 0000000..48dae50
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfData.inc
@@ -0,0 +1,735 @@
+/*===-- InstrProfData.inc - instr profiling runtime structures -----------=== *\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+/*
+ * This is the master file that defines all the data structure, signature,
+ * constant literals that are shared across profiling runtime library,
+ * compiler (instrumentation), and host tools (reader/writer). The entities
+ * defined in this file affect the profile runtime ABI, the raw profile format,
+ * or both.
+ *
+ * The file has two identical copies. The master copy lives in LLVM and
+ * the other one  sits in compiler-rt/lib/profile directory. To make changes
+ * in this file, first modify the master copy and copy it over to compiler-rt.
+ * Testing of any change in this file can start only after the two copies are
+ * synced up.
+ *
+ * The first part of the file includes macros that defines types, names, and
+ * initializers for the member fields of the core data structures. The field
+ * declarations for one structure is enabled by defining the field activation
+ * macro associated with that structure. Only one field activation record
+ * can be defined at one time and the rest definitions will be filtered out by
+ * the preprocessor.
+ *
+ * Examples of how the template is used to instantiate structure definition:
+ * 1. To declare a structure:
+ * 
+ * struct ProfData {
+ * #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \
+ *    Type Name;
+ * #include "llvm/ProfileData/InstrProfData.inc"
+ * };
+ *
+ * 2. To construct LLVM type arrays for the struct type:
+ *
+ * Type *DataTypes[] = {
+ * #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \
+ *   LLVMType,
+ * #include "llvm/ProfileData/InstrProfData.inc"
+ * };
+ *
+ * 4. To construct constant array for the initializers:
+ * #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \
+ *   Initializer,
+ * Constant *ConstantVals[] = {
+ * #include "llvm/ProfileData/InstrProfData.inc"
+ * };
+ *
+ *
+ * The second part of the file includes definitions all other entities that
+ * are related to runtime ABI and format. When no field activation macro is
+ * defined, this file can be included to introduce the definitions.
+ *
+\*===----------------------------------------------------------------------===*/
+
+/* INSTR_PROF_DATA start. */
+/* Definition of member fields of the per-function control structure. */
+#ifndef INSTR_PROF_DATA
+#define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer)
+#else
+#define INSTR_PROF_DATA_DEFINED
+#endif
+
+INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NameSize, \
+                ConstantInt::get(llvm::Type::getInt32Ty(Ctx), \
+                NamePtr->getType()->getPointerElementType()->getArrayNumElements()))
+INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumCounters, \
+                ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumCounters))
+INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \
+                ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
+                Inc->getHash()->getZExtValue()))
+INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), NamePtr, \
+                ConstantExpr::getBitCast(NamePtr, llvm::Type::getInt8PtrTy(Ctx)))
+INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt64PtrTy(Ctx), CounterPtr, \
+                ConstantExpr::getBitCast(CounterPtr, \
+                llvm::Type::getInt64PtrTy(Ctx)))
+INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), FunctionPointer, \
+                FunctionAddr)
+INSTR_PROF_DATA(IntPtrT, llvm::Type::getInt8PtrTy(Ctx), Values, \
+                ConstantPointerNull::get(Int8PtrTy))
+INSTR_PROF_DATA(const uint16_t, Int16ArrayTy, NumValueSites[IPVK_Last+1], \
+                ConstantArray::get(Int16ArrayTy, Int16ArrayVals))
+#undef INSTR_PROF_DATA
+/* INSTR_PROF_DATA end. */
+
+/* INSTR_PROF_RAW_HEADER  start */
+/* Definition of member fields of the raw profile header data structure. */
+#ifndef INSTR_PROF_RAW_HEADER
+#define INSTR_PROF_RAW_HEADER(Type, Name, Initializer)
+#else
+#define INSTR_PROF_DATA_DEFINED
+#endif
+INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic())
+INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
+INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
+INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
+INSTR_PROF_RAW_HEADER(uint64_t, NamesSize,  NamesSize)
+INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
+INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
+INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
+INSTR_PROF_RAW_HEADER(uint64_t, ValueDataSize, ValueDataSize)
+INSTR_PROF_RAW_HEADER(uint64_t, ValueDataDelta, (uintptr_t)ValueDataBegin)
+#undef INSTR_PROF_RAW_HEADER
+/* INSTR_PROF_RAW_HEADER  end */
+
+/* VALUE_PROF_FUNC_PARAM start */
+/* Definition of parameter types of the runtime API used to do value profiling
+ * for a given value site.
+ */
+#ifndef VALUE_PROF_FUNC_PARAM
+#define VALUE_PROF_FUNC_PARAM(ArgType, ArgName, ArgLLVMType)
+#define INSTR_PROF_COMMA
+#else
+#define INSTR_PROF_DATA_DEFINED
+#define INSTR_PROF_COMMA ,
+#endif
+VALUE_PROF_FUNC_PARAM(uint64_t, TargetValue, Type::getInt64Ty(Ctx)) \
+                      INSTR_PROF_COMMA
+VALUE_PROF_FUNC_PARAM(void *, Data, Type::getInt8PtrTy(Ctx)) INSTR_PROF_COMMA
+VALUE_PROF_FUNC_PARAM(uint32_t, CounterIndex, Type::getInt32Ty(Ctx))
+#undef VALUE_PROF_FUNC_PARAM
+#undef INSTR_PROF_COMMA
+/* VALUE_PROF_FUNC_PARAM end */
+
+/* VALUE_PROF_KIND start */
+#ifndef VALUE_PROF_KIND
+#define VALUE_PROF_KIND(Enumerator, Value)
+#else
+#define INSTR_PROF_DATA_DEFINED
+#endif
+VALUE_PROF_KIND(IPVK_IndirectCallTarget, 0)
+/* These two kinds must be the last to be
+ * declared. This is to make sure the string
+ * array created with the template can be
+ * indexed with the kind value.
+ */
+VALUE_PROF_KIND(IPVK_First, IPVK_IndirectCallTarget)
+VALUE_PROF_KIND(IPVK_Last, IPVK_IndirectCallTarget)
+
+#undef VALUE_PROF_KIND
+/* VALUE_PROF_KIND end */
+
+/* COVMAP_FUNC_RECORD start */
+/* Definition of member fields of the function record structure in coverage
+ * map.
+ */
+#ifndef COVMAP_FUNC_RECORD
+#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Initializer)
+#else
+#define INSTR_PROF_DATA_DEFINED
+#endif
+COVMAP_FUNC_RECORD(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), \
+                   NamePtr, llvm::ConstantExpr::getBitCast(NamePtr, \
+                   llvm::Type::getInt8PtrTy(Ctx))) 
+COVMAP_FUNC_RECORD(const uint32_t, llvm::Type::getInt32Ty(Ctx), NameSize, \
+                   llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx),\
+                   NameValue.size()))
+COVMAP_FUNC_RECORD(const uint32_t, llvm::Type::getInt32Ty(Ctx), DataSize, \
+                   llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx),\
+                   CoverageMapping.size()))
+COVMAP_FUNC_RECORD(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \
+                   llvm::ConstantInt::get(llvm::Type::getInt64Ty(Ctx), FuncHash))
+#undef COVMAP_FUNC_RECORD
+/* COVMAP_FUNC_RECORD end.  */
+
+
+#ifdef INSTR_PROF_VALUE_PROF_DATA
+#define INSTR_PROF_DATA_DEFINED
+
+/*! 
+ * This is the header of the data structure that defines the on-disk
+ * layout of the value profile data of a particular kind for one function.
+ */
+typedef struct ValueProfRecord {
+  /* The kind of the value profile record. */
+  uint32_t Kind;
+  /*
+   * The number of value profile sites. It is guaranteed to be non-zero;
+   * otherwise the record for this kind won't be emitted.
+   */
+  uint32_t NumValueSites;
+  /* 
+   * The first element of the array that stores the number of profiled
+   * values for each value site. The size of the array is NumValueSites.
+   * Since NumValueSites is greater than zero, there is at least one
+   * element in the array.
+   */
+  uint8_t SiteCountArray[1];
+
+  /*
+   * The fake declaration is for documentation purpose only.
+   * Align the start of next field to be on 8 byte boundaries.
+  uint8_t Padding[X];
+   */
+
+  /* The array of value profile data. The size of the array is the sum
+   * of all elements in SiteCountArray[].
+  InstrProfValueData ValueData[];
+   */
+
+#ifdef __cplusplus
+  /*!
+   * \brief Return the number of value sites.
+   */
+  uint32_t getNumValueSites() const { return NumValueSites; }
+  /*! 
+   * \brief Read data from this record and save it to Record.
+   */
+  void deserializeTo(InstrProfRecord &Record,
+                     InstrProfRecord::ValueMapType *VMap);
+  /*
+   * In-place byte swap:
+   * Do byte swap for this instance. \c Old is the original order before
+   * the swap, and \c New is the New byte order.
+   */
+  void swapBytes(support::endianness Old, support::endianness New);
+#endif
+} ValueProfRecord;
+
+/*!
+ * Per-function header/control data structure for value profiling
+ * data in indexed format.
+ */
+typedef struct ValueProfData {
+  /*
+   * Total size in bytes including this field. It must be a multiple
+   * of sizeof(uint64_t). 
+   */
+  uint32_t TotalSize;
+  /* 
+   *The number of value profile kinds that has value profile data.
+   * In this implementation, a value profile kind is considered to
+   * have profile data if the number of value profile sites for the
+   * kind is not zero. More aggressively, the implementation can
+   * choose to check the actual data value: if none of the value sites
+   * has any profiled values, the kind can be skipped.
+   */
+  uint32_t NumValueKinds;
+
+  /* 
+   * Following are a sequence of variable length records. The prefix/header
+   * of each record is defined by ValueProfRecord type. The number of
+   * records is NumValueKinds.
+   * ValueProfRecord Record_1;
+   * ValueProfRecord Record_N;
+   */
+
+#if __cplusplus
+  /*!
+   * Return the total size in bytes of the on-disk value profile data
+   * given the data stored in Record.
+   */
+  static uint32_t getSize(const InstrProfRecord &Record);
+  /*!
+   * Return a pointer to \c ValueProfData instance ready to be streamed.
+   */
+  static std::unique_ptr<ValueProfData>
+  serializeFrom(const InstrProfRecord &Record);
+  /*!
+   * Check the integrity of the record. Return the error code when
+   * an error is detected, otherwise return instrprof_error::success.
+   */
+  instrprof_error checkIntegrity();
+  /*!
+   * Return a pointer to \c ValueProfileData instance ready to be read.
+   * All data in the instance are properly byte swapped. The input
+   * data is assumed to be in little endian order.
+   */
+  static ErrorOr<std::unique_ptr<ValueProfData>>
+  getValueProfData(const unsigned char *SrcBuffer,
+                   const unsigned char *const SrcBufferEnd,
+                   support::endianness SrcDataEndianness);
+  /*!
+   * Swap byte order from \c Endianness order to host byte order.
+   */
+  void swapBytesToHost(support::endianness Endianness);
+  /*!
+   * Swap byte order from host byte order to \c Endianness order.
+   */
+  void swapBytesFromHost(support::endianness Endianness);
+  /*!
+   * Return the total size of \c ValueProfileData.
+   */
+  uint32_t getSize() const { return TotalSize; }
+  /*!
+   * Read data from this data and save it to \c Record.
+   */
+  void deserializeTo(InstrProfRecord &Record,
+                     InstrProfRecord::ValueMapType *VMap);
+  void operator delete(void *ptr) { ::operator delete(ptr); }
+#endif
+} ValueProfData;
+
+/* 
+ * The closure is designed to abstact away two types of value profile data:
+ * - InstrProfRecord which is the primary data structure used to
+ *   represent profile data in host tools (reader, writer, and profile-use)
+ * - value profile runtime data structure suitable to be used by C
+ *   runtime library.
+ *
+ * Both sources of data need to serialize to disk/memory-buffer in common
+ * format: ValueProfData. The abstraction allows compiler-rt's raw profiler
+ * writer to share the same format and code with indexed profile writer.
+ *
+ * For documentation of the member methods below, refer to corresponding methods
+ * in class InstrProfRecord.
+ */
+typedef struct ValueProfRecordClosure {
+  const void *Record;
+  uint32_t (*GetNumValueKinds)(const void *Record);
+  uint32_t (*GetNumValueSites)(const void *Record, uint32_t VKind);
+  uint32_t (*GetNumValueData)(const void *Record, uint32_t VKind);
+  uint32_t (*GetNumValueDataForSite)(const void *R, uint32_t VK, uint32_t S);
+
+  /* 
+   * After extracting the value profile data from the value profile record,
+   * this method is used to map the in-memory value to on-disk value. If
+   * the method is null, value will be written out untranslated.
+   */
+  uint64_t (*RemapValueData)(uint32_t, uint64_t Value);
+  void (*GetValueForSite)(const void *R, InstrProfValueData *Dst, uint32_t K,
+                          uint32_t S, uint64_t (*Mapper)(uint32_t, uint64_t));
+  ValueProfData *(*AllocValueProfData)(size_t TotalSizeInBytes);
+} ValueProfRecordClosure;
+
+/* 
+ * A wrapper struct that represents value profile runtime data.
+ * Like InstrProfRecord class which is used by profiling host tools,
+ * ValueProfRuntimeRecord also implements the abstract intefaces defined in
+ * ValueProfRecordClosure so that the runtime data can be serialized using
+ * shared C implementation. In this structure, NumValueSites and Nodes
+ * members are the primary fields while other fields hold the derived
+ * information for fast implementation of closure interfaces.
+ */
+typedef struct ValueProfRuntimeRecord {
+  /* Number of sites for each value profile kind.  */
+  const uint16_t *NumValueSites;
+  /* An array of linked-list headers. The size of of the array is the
+   * total number of value profile sites : sum(NumValueSites[*])). Each
+   * linked-list stores the values profiled for a value profile site. */
+  ValueProfNode **Nodes;
+
+  /* Total number of value profile kinds which have at least one
+   *  value profile sites. */
+  uint32_t NumValueKinds;
+  /* An array recording the number of values tracked at each site.
+   * The size of the array is TotalNumValueSites. */
+  uint8_t *SiteCountArray[IPVK_Last + 1];
+  ValueProfNode **NodesKind[IPVK_Last + 1];
+} ValueProfRuntimeRecord;
+
+/* Forward declarations of C interfaces.  */
+int initializeValueProfRuntimeRecord(ValueProfRuntimeRecord *RuntimeRecord,
+                                     const uint16_t *NumValueSites,
+                                     ValueProfNode **Nodes);
+void finalizeValueProfRuntimeRecord(ValueProfRuntimeRecord *RuntimeRecord);
+uint32_t getValueProfDataSizeRT(const ValueProfRuntimeRecord *Record);
+ValueProfData *
+serializeValueProfDataFromRT(const ValueProfRuntimeRecord *Record,
+                             ValueProfData *Dst);
+uint32_t getNumValueKindsRT(const void *R);
+
+#undef INSTR_PROF_VALUE_PROF_DATA
+#endif  /* INSTR_PROF_VALUE_PROF_DATA */ 
+
+
+#ifdef INSTR_PROF_COMMON_API_IMPL
+#define INSTR_PROF_DATA_DEFINED
+#ifdef __cplusplus
+#define INSTR_PROF_INLINE inline
+#else
+#define INSTR_PROF_INLINE
+#endif
+
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+
+/*!
+ * \brief Return the \c ValueProfRecord header size including the
+ * padding bytes.
+ */
+INSTR_PROF_INLINE
+uint32_t getValueProfRecordHeaderSize(uint32_t NumValueSites) {
+  uint32_t Size = offsetof(ValueProfRecord, SiteCountArray) +
+                  sizeof(uint8_t) * NumValueSites;
+  /* Round the size to multiple of 8 bytes. */
+  Size = (Size + 7) & ~7;
+  return Size;
+}
+
+/*! 
+ * \brief Return the total size of the value profile record including the
+ * header and the value data.
+ */
+INSTR_PROF_INLINE
+uint32_t getValueProfRecordSize(uint32_t NumValueSites,
+                                uint32_t NumValueData) {
+  return getValueProfRecordHeaderSize(NumValueSites) +
+         sizeof(InstrProfValueData) * NumValueData;
+}
+
+/*!
+ * \brief Return the pointer to the start of value data array.
+ */
+INSTR_PROF_INLINE
+InstrProfValueData *getValueProfRecordValueData(ValueProfRecord *This) {
+  return (InstrProfValueData *)((char *)This + getValueProfRecordHeaderSize(
+                                                   This->NumValueSites));
+}
+
+/*! 
+ * \brief Return the total number of value data for \c This record.
+ */
+INSTR_PROF_INLINE
+uint32_t getValueProfRecordNumValueData(ValueProfRecord *This) {
+  uint32_t NumValueData = 0;
+  uint32_t I;
+  for (I = 0; I < This->NumValueSites; I++)
+    NumValueData += This->SiteCountArray[I];
+  return NumValueData;
+}
+
+/*! 
+ * \brief Use this method to advance to the next \c This \c ValueProfRecord.
+ */
+INSTR_PROF_INLINE
+ValueProfRecord *getValueProfRecordNext(ValueProfRecord *This) {
+  uint32_t NumValueData = getValueProfRecordNumValueData(This);
+  return (ValueProfRecord *)((char *)This +
+                             getValueProfRecordSize(This->NumValueSites,
+                                                    NumValueData));
+}
+
+/*!
+ * \brief Return the first \c ValueProfRecord instance.
+ */
+INSTR_PROF_INLINE
+ValueProfRecord *getFirstValueProfRecord(ValueProfData *This) {
+  return (ValueProfRecord *)((char *)This + sizeof(ValueProfData));
+}
+
+/* Closure based interfaces.  */
+
+/*! 
+ * Return the total size in bytes of the on-disk value profile data
+ * given the data stored in Record.
+ */
+uint32_t getValueProfDataSize(ValueProfRecordClosure *Closure) {
+  uint32_t Kind;
+  uint32_t TotalSize = sizeof(ValueProfData);
+  const void *Record = Closure->Record;
+  uint32_t NumValueKinds = Closure->GetNumValueKinds(Record);
+  if (NumValueKinds == 0)
+    return TotalSize;
+
+  for (Kind = IPVK_First; Kind <= IPVK_Last; Kind++) {
+    uint32_t NumValueSites = Closure->GetNumValueSites(Record, Kind);
+    if (!NumValueSites)
+      continue;
+    TotalSize += getValueProfRecordSize(NumValueSites,
+                                        Closure->GetNumValueData(Record, Kind));
+  }
+  return TotalSize;
+}
+
+/*!
+ * Extract value profile data of a function for the profile kind \c ValueKind
+ * from the \c Closure and serialize the data into \c This record instance.
+ */
+void serializeValueProfRecordFrom(ValueProfRecord *This,
+                                  ValueProfRecordClosure *Closure,
+                                  uint32_t ValueKind, uint32_t NumValueSites) {
+  uint32_t S;
+  const void *Record = Closure->Record;
+  This->Kind = ValueKind;
+  This->NumValueSites = NumValueSites;
+  InstrProfValueData *DstVD = getValueProfRecordValueData(This);
+
+  for (S = 0; S < NumValueSites; S++) {
+    uint32_t ND = Closure->GetNumValueDataForSite(Record, ValueKind, S);
+    This->SiteCountArray[S] = ND;
+    Closure->GetValueForSite(Record, DstVD, ValueKind, S,
+                             Closure->RemapValueData);
+    DstVD += ND;
+  }
+}
+
+/*!
+ * Extract value profile data of a function  from the \c Closure
+ * and serialize the data into \c DstData if it is not NULL or heap
+ * memory allocated by the \c Closure's allocator method.
+ */
+ValueProfData *serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
+                                          ValueProfData *DstData) {
+  uint32_t Kind;
+  uint32_t TotalSize = getValueProfDataSize(Closure);
+
+  ValueProfData *VPD =
+      DstData ? DstData : Closure->AllocValueProfData(TotalSize);
+
+  VPD->TotalSize = TotalSize;
+  VPD->NumValueKinds = Closure->GetNumValueKinds(Closure->Record);
+  ValueProfRecord *VR = getFirstValueProfRecord(VPD);
+  for (Kind = IPVK_First; Kind <= IPVK_Last; Kind++) {
+    uint32_t NumValueSites = Closure->GetNumValueSites(Closure->Record, Kind);
+    if (!NumValueSites)
+      continue;
+    serializeValueProfRecordFrom(VR, Closure, Kind, NumValueSites);
+    VR = getValueProfRecordNext(VR);
+  }
+  return VPD;
+}
+
+/* 
+ * The value profiler runtime library stores the value profile data
+ * for a given function in \c NumValueSites and \c Nodes structures.
+ * \c ValueProfRuntimeRecord class is used to encapsulate the runtime
+ * profile data and provides fast interfaces to retrieve the profile
+ * information. This interface is used to initialize the runtime record
+ * and pre-compute the information needed for efficient implementation
+ * of callbacks required by ValueProfRecordClosure class.
+ */
+int initializeValueProfRuntimeRecord(ValueProfRuntimeRecord *RuntimeRecord,
+                                     const uint16_t *NumValueSites,
+                                     ValueProfNode **Nodes) {
+  unsigned I, J, S = 0, NumValueKinds = 0;
+  RuntimeRecord->NumValueSites = NumValueSites;
+  RuntimeRecord->Nodes = Nodes;
+  for (I = 0; I <= IPVK_Last; I++) {
+    uint16_t N = NumValueSites[I];
+    if (!N) {
+      RuntimeRecord->SiteCountArray[I] = 0;
+      continue;
+    }
+    NumValueKinds++;
+    RuntimeRecord->SiteCountArray[I] = (uint8_t *)calloc(N, 1);
+    if (!RuntimeRecord->SiteCountArray[I])
+      return 1;
+    RuntimeRecord->NodesKind[I] = Nodes ? &Nodes[S] : NULL;
+    for (J = 0; J < N; J++) {
+      /* Compute value count for each site. */
+      uint32_t C = 0;
+      ValueProfNode *Site = Nodes ? RuntimeRecord->NodesKind[I][J] : NULL;
+      while (Site) {
+        C++;
+        Site = Site->Next;
+      }
+      if (C > UCHAR_MAX)
+        C = UCHAR_MAX;
+      RuntimeRecord->SiteCountArray[I][J] = C;
+    }
+    S += N;
+  }
+  RuntimeRecord->NumValueKinds = NumValueKinds;
+  return 0;
+}
+
+void finalizeValueProfRuntimeRecord(ValueProfRuntimeRecord *RuntimeRecord) {
+  unsigned I;
+  for (I = 0; I <= IPVK_Last; I++) {
+    if (RuntimeRecord->SiteCountArray[I])
+      free(RuntimeRecord->SiteCountArray[I]);
+  }
+}
+
+/* ValueProfRecordClosure Interface implementation for
+ * ValueProfDataRuntimeRecord.  */
+uint32_t getNumValueKindsRT(const void *R) {
+  return ((const ValueProfRuntimeRecord *)R)->NumValueKinds;
+}
+
+uint32_t getNumValueSitesRT(const void *R, uint32_t VK) {
+  return ((const ValueProfRuntimeRecord *)R)->NumValueSites[VK];
+}
+
+uint32_t getNumValueDataForSiteRT(const void *R, uint32_t VK, uint32_t S) {
+  const ValueProfRuntimeRecord *Record = (const ValueProfRuntimeRecord *)R;
+  return Record->SiteCountArray[VK][S];
+}
+
+uint32_t getNumValueDataRT(const void *R, uint32_t VK) {
+  unsigned I, S = 0;
+  const ValueProfRuntimeRecord *Record = (const ValueProfRuntimeRecord *)R;
+  if (Record->SiteCountArray[VK] == 0)
+    return 0;
+  for (I = 0; I < Record->NumValueSites[VK]; I++)
+    S += Record->SiteCountArray[VK][I];
+  return S;
+}
+
+void getValueForSiteRT(const void *R, InstrProfValueData *Dst, uint32_t VK,
+                       uint32_t S, uint64_t (*Mapper)(uint32_t, uint64_t)) {
+  unsigned I, N = 0;
+  const ValueProfRuntimeRecord *Record = (const ValueProfRuntimeRecord *)R;
+  N = getNumValueDataForSiteRT(R, VK, S);
+  if (N == 0)
+    return;
+  ValueProfNode *VNode = Record->NodesKind[VK][S];
+  for (I = 0; I < N; I++) {
+    Dst[I] = VNode->VData;
+    VNode = VNode->Next;
+  }
+}
+
+ValueProfData *allocValueProfDataRT(size_t TotalSizeInBytes) {
+  return (ValueProfData *)calloc(TotalSizeInBytes, 1);
+}
+
+static ValueProfRecordClosure RTRecordClosure = {0,
+                                                 getNumValueKindsRT,
+                                                 getNumValueSitesRT,
+                                                 getNumValueDataRT,
+                                                 getNumValueDataForSiteRT,
+                                                 0,
+                                                 getValueForSiteRT,
+                                                 allocValueProfDataRT};
+
+/* 
+ * Return the size of ValueProfData structure to store data
+ * recorded in the runtime record.
+ */
+uint32_t getValueProfDataSizeRT(const ValueProfRuntimeRecord *Record) {
+  RTRecordClosure.Record = Record;
+  return getValueProfDataSize(&RTRecordClosure);
+}
+
+/* 
+ * Return a ValueProfData instance that stores the data collected
+ * from runtime. If \c DstData is provided by the caller, the value
+ * profile data will be store in *DstData and DstData is returned,
+ * otherwise the method will allocate space for the value data and
+ * return pointer to the newly allocated space.
+ */
+ValueProfData *
+serializeValueProfDataFromRT(const ValueProfRuntimeRecord *Record,
+                             ValueProfData *DstData) {
+  RTRecordClosure.Record = Record;
+  return serializeValueProfDataFrom(&RTRecordClosure, DstData);
+}
+
+
+#undef INSTR_PROF_COMMON_API_IMPL
+#endif /* INSTR_PROF_COMMON_API_IMPL */
+
+/*============================================================================*/
+
+
+#ifndef INSTR_PROF_DATA_DEFINED
+
+#ifndef INSTR_PROF_DATA_INC_
+#define INSTR_PROF_DATA_INC_
+
+/* Helper macros.  */
+#define INSTR_PROF_SIMPLE_QUOTE(x) #x
+#define INSTR_PROF_QUOTE(x) INSTR_PROF_SIMPLE_QUOTE(x)
+#define INSTR_PROF_SIMPLE_CONCAT(x,y) x ## y
+#define INSTR_PROF_CONCAT(x,y) INSTR_PROF_SIMPLE_CONCAT(x,y)
+
+/* Magic number to detect file format and endianness.
+ * Use 255 at one end, since no UTF-8 file can use that character.  Avoid 0,
+ * so that utilities, like strings, don't grab it as a string.  129 is also
+ * invalid UTF-8, and high enough to be interesting.
+ * Use "lprofr" in the centre to stand for "LLVM Profile Raw", or "lprofR"
+ * for 32-bit platforms.
+ */
+#define INSTR_PROF_RAW_MAGIC_64 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
+       (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \
+        (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129
+#define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
+       (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 |  \
+        (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
+
+/* Raw profile format version. */
+#define INSTR_PROF_RAW_VERSION 2
+
+/* Runtime section names and name strings.  */
+#define INSTR_PROF_DATA_SECT_NAME __llvm_prf_data
+#define INSTR_PROF_NAME_SECT_NAME __llvm_prf_names
+#define INSTR_PROF_CNTS_SECT_NAME __llvm_prf_cnts
+
+#define INSTR_PROF_DATA_SECT_NAME_STR \
+        INSTR_PROF_QUOTE(INSTR_PROF_DATA_SECT_NAME)
+#define INSTR_PROF_NAME_SECT_NAME_STR \
+        INSTR_PROF_QUOTE(INSTR_PROF_NAME_SECT_NAME)
+#define INSTR_PROF_CNTS_SECT_NAME_STR \
+        INSTR_PROF_QUOTE(INSTR_PROF_CNTS_SECT_NAME)
+
+/* Macros to define start/stop section symbol for a given
+ * section on Linux. For instance
+ * INSTR_PROF_SECT_START(INSTR_PROF_DATA_SECT_NAME) will
+ * expand to __start___llvm_prof_data
+ */
+#define INSTR_PROF_SECT_START(Sect) \
+        INSTR_PROF_CONCAT(__start_,Sect)
+#define INSTR_PROF_SECT_STOP(Sect) \
+        INSTR_PROF_CONCAT(__stop_,Sect)
+
+/* Value Profiling API linkage name.  */
+#define INSTR_PROF_VALUE_PROF_FUNC __llvm_profile_instrument_target
+#define INSTR_PROF_VALUE_PROF_FUNC_STR \
+        INSTR_PROF_QUOTE(INSTR_PROF_VALUE_PROF_FUNC)
+
+/* InstrProfile per-function control data alignment.  */
+#define INSTR_PROF_DATA_ALIGNMENT 8
+
+/* The data structure that represents a tracked value by the
+ * value profiler.
+ */
+typedef struct InstrProfValueData {
+  /* Profiled value. */
+  uint64_t Value;
+  /* Number of times the value appears in the training run. */
+  uint64_t Count;
+} InstrProfValueData;
+
+/* This is an internal data structure used by value profiler. It
+ * is defined here to allow serialization code sharing by LLVM
+ * to be used in unit test.
+ */
+typedef struct ValueProfNode {
+  InstrProfValueData VData;
+  struct ValueProfNode *Next;
+} ValueProfNode;
+
+#endif /* INSTR_PROF_DATA_INC_ */
+
+#else
+#undef INSTR_PROF_DATA_DEFINED
+#endif
+
diff --git a/compiler-rt/lib/profile/InstrProfiling.c b/compiler-rt/lib/profile/InstrProfiling.c
new file mode 100644
index 0000000..58778ae
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfiling.c
@@ -0,0 +1,68 @@
+/*===- InstrProfiling.c - Support library for PGO instrumentation ---------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define INSTR_PROF_VALUE_PROF_DATA
+#include "InstrProfData.inc"
+
+char *(*GetEnvHook)(const char *) = 0;
+
+COMPILER_RT_VISIBILITY uint64_t __llvm_profile_get_magic(void) {
+  return sizeof(void *) == sizeof(uint64_t) ? (INSTR_PROF_RAW_MAGIC_64)
+                                            : (INSTR_PROF_RAW_MAGIC_32);
+}
+
+/* Return the number of bytes needed to add to SizeInBytes to make it
+ *   the result a multiple of 8.
+ */
+COMPILER_RT_VISIBILITY uint8_t
+__llvm_profile_get_num_padding_bytes(uint64_t SizeInBytes) {
+  return 7 & (sizeof(uint64_t) - SizeInBytes % sizeof(uint64_t));
+}
+
+COMPILER_RT_VISIBILITY uint64_t __llvm_profile_get_version(void) {
+  return INSTR_PROF_RAW_VERSION;
+}
+
+COMPILER_RT_VISIBILITY void __llvm_profile_reset_counters(void) {
+  uint64_t *I = __llvm_profile_begin_counters();
+  uint64_t *E = __llvm_profile_end_counters();
+
+  memset(I, 0, sizeof(uint64_t) * (E - I));
+
+  const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
+  const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
+  const __llvm_profile_data *DI;
+  for (DI = DataBegin; DI != DataEnd; ++DI) {
+    uint64_t CurrentVSiteCount = 0;
+    uint32_t VKI, i;
+    if (!DI->Values)
+      continue;
+
+    ValueProfNode **ValueCounters = (ValueProfNode **)DI->Values;
+
+    for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
+      CurrentVSiteCount += DI->NumValueSites[VKI];
+
+    for (i = 0; i < CurrentVSiteCount; ++i) {
+      ValueProfNode *CurrentVNode = ValueCounters[i];
+
+      while (CurrentVNode) {
+        CurrentVNode->VData.Count = 0;
+        CurrentVNode = CurrentVNode->Next;
+      }
+    }
+  }
+}
+
diff --git a/compiler-rt/lib/profile/InstrProfiling.h b/compiler-rt/lib/profile/InstrProfiling.h
new file mode 100644
index 0000000..c924a42
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfiling.h
@@ -0,0 +1,133 @@
+/*===- InstrProfiling.h- Support library for PGO instrumentation ----------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#ifndef PROFILE_INSTRPROFILING_H_
+#define PROFILE_INSTRPROFILING_H_
+
+#include "InstrProfilingPort.h"
+#include "InstrProfData.inc"
+
+enum ValueKind {
+#define VALUE_PROF_KIND(Enumerator, Value) Enumerator = Value,
+#include "InstrProfData.inc"
+};
+
+typedef void *IntPtrT;
+typedef struct COMPILER_RT_ALIGNAS(INSTR_PROF_DATA_ALIGNMENT)
+    __llvm_profile_data {
+#define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) Type Name;
+#include "InstrProfData.inc"
+} __llvm_profile_data;
+
+typedef struct __llvm_profile_header {
+#define INSTR_PROF_RAW_HEADER(Type, Name, Initializer) Type Name;
+#include "InstrProfData.inc"
+} __llvm_profile_header;
+
+/*!
+ * \brief Get number of bytes necessary to pad the argument to eight
+ * byte boundary.
+ */
+uint8_t __llvm_profile_get_num_padding_bytes(uint64_t SizeInBytes);
+
+/*!
+ * \brief Get required size for profile buffer.
+ */
+uint64_t __llvm_profile_get_size_for_buffer(void);
+
+/*!
+ * \brief Write instrumentation data to the given buffer.
+ *
+ * \pre \c Buffer is the start of a buffer at least as big as \a
+ * __llvm_profile_get_size_for_buffer().
+ */
+int __llvm_profile_write_buffer(char *Buffer);
+
+const __llvm_profile_data *__llvm_profile_begin_data(void);
+const __llvm_profile_data *__llvm_profile_end_data(void);
+const char *__llvm_profile_begin_names(void);
+const char *__llvm_profile_end_names(void);
+uint64_t *__llvm_profile_begin_counters(void);
+uint64_t *__llvm_profile_end_counters(void);
+
+/*!
+ * \brief Clear profile counters to zero.
+ *
+ */
+void __llvm_profile_reset_counters(void);
+
+/*!
+ * \brief Counts the number of times a target value is seen.
+ *
+ * Records the target value for the CounterIndex if not seen before. Otherwise,
+ * increments the counter associated w/ the target value.
+ * void __llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
+ *                                       uint32_t CounterIndex);
+ */
+void INSTR_PROF_VALUE_PROF_FUNC(
+#define VALUE_PROF_FUNC_PARAM(ArgType, ArgName, ArgLLVMType) ArgType ArgName
+#include "InstrProfData.inc"
+);
+
+/*!
+ * \brief Prepares the value profiling data for output.
+ *
+ * Prepares a single __llvm_profile_value_data array out of the many
+ * ValueProfNode trees (one per instrumented function).
+ */
+uint64_t __llvm_profile_gather_value_data(uint8_t **DataArray);
+
+/*!
+ * \brief Write instrumentation data to the current file.
+ *
+ * Writes to the file with the last name given to \a __llvm_profile_set_filename(),
+ * or if it hasn't been called, the \c LLVM_PROFILE_FILE environment variable,
+ * or if that's not set, the last name given to
+ * \a __llvm_profile_override_default_filename(), or if that's not set,
+ * \c "default.profraw".
+ */
+int __llvm_profile_write_file(void);
+
+/*!
+ * \brief Set the filename for writing instrumentation data.
+ *
+ * Sets the filename to be used for subsequent calls to
+ * \a __llvm_profile_write_file().
+ *
+ * \c Name is not copied, so it must remain valid.  Passing NULL resets the
+ * filename logic to the default behaviour.
+ */
+void __llvm_profile_set_filename(const char *Name);
+
+/*!
+ * \brief Set the filename for writing instrumentation data, unless the
+ * \c LLVM_PROFILE_FILE environment variable was set.
+ *
+ * Unless overridden, sets the filename to be used for subsequent calls to
+ * \a __llvm_profile_write_file().
+ *
+ * \c Name is not copied, so it must remain valid.  Passing NULL resets the
+ * filename logic to the default behaviour (unless the \c LLVM_PROFILE_FILE
+ * was set in which case it has no effect).
+ */
+void __llvm_profile_override_default_filename(const char *Name);
+
+/*! \brief Register to write instrumentation data to file at exit. */
+int __llvm_profile_register_write_file_atexit(void);
+
+/*! \brief Initialize file handling. */
+void __llvm_profile_initialize_file(void);
+
+/*! \brief Get the magic token for the file format. */
+uint64_t __llvm_profile_get_magic(void);
+
+/*! \brief Get the version of the file format. */
+uint64_t __llvm_profile_get_version(void);
+
+#endif /* PROFILE_INSTRPROFILING_H_ */
diff --git a/compiler-rt/lib/profile/InstrProfilingBuffer.c b/compiler-rt/lib/profile/InstrProfilingBuffer.c
new file mode 100644
index 0000000..8bade76
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingBuffer.c
@@ -0,0 +1,69 @@
+/*===- InstrProfilingBuffer.c - Write instrumentation to a memory buffer --===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+
+#include <string.h>
+
+COMPILER_RT_VISIBILITY
+uint64_t __llvm_profile_get_size_for_buffer(void) {
+  const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
+  const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
+  const uint64_t *CountersBegin = __llvm_profile_begin_counters();
+  const uint64_t *CountersEnd = __llvm_profile_end_counters();
+  const char *NamesBegin = __llvm_profile_begin_names();
+  const char *NamesEnd = __llvm_profile_end_names();
+
+  return __llvm_profile_get_size_for_buffer_internal(
+      DataBegin, DataEnd, CountersBegin, CountersEnd, NamesBegin, NamesEnd);
+}
+
+#define PROFILE_RANGE_SIZE(Range) (Range##End - Range##Begin)
+
+COMPILER_RT_VISIBILITY
+uint64_t __llvm_profile_get_size_for_buffer_internal(
+    const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
+    const uint64_t *CountersBegin, const uint64_t *CountersEnd,
+    const char *NamesBegin, const char *NamesEnd) {
+  /* Match logic in __llvm_profile_write_buffer(). */
+  const uint64_t NamesSize = PROFILE_RANGE_SIZE(Names) * sizeof(char);
+  const uint8_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);
+  return sizeof(__llvm_profile_header) +
+         PROFILE_RANGE_SIZE(Data) * sizeof(__llvm_profile_data) +
+         PROFILE_RANGE_SIZE(Counters) * sizeof(uint64_t) + NamesSize + Padding;
+}
+
+/* The buffer writer is reponsponsible in keeping writer state
+ * across the call.
+ */
+static uint32_t bufferWriter(ProfDataIOVec *IOVecs, uint32_t NumIOVecs,
+                             void **WriterCtx) {
+  uint32_t I;
+  char **Buffer = (char **)WriterCtx;
+  for (I = 0; I < NumIOVecs; I++) {
+    size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
+    memcpy(*Buffer, IOVecs[I].Data, Length);
+    *Buffer += Length;
+  }
+  return 0;
+}
+
+COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer(char *Buffer) {
+  return llvmWriteProfData(bufferWriter, Buffer, 0, 0);
+}
+
+COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal(
+    char *Buffer, const __llvm_profile_data *DataBegin,
+    const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
+    const uint64_t *CountersEnd, const char *NamesBegin, const char *NamesEnd) {
+  return llvmWriteProfDataImpl(bufferWriter, Buffer, DataBegin, DataEnd,
+                               CountersBegin, CountersEnd, 0, 0, NamesBegin,
+                               NamesEnd);
+}
diff --git a/compiler-rt/lib/profile/InstrProfilingFile.c b/compiler-rt/lib/profile/InstrProfilingFile.c
new file mode 100644
index 0000000..7f2923c
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingFile.c
@@ -0,0 +1,221 @@
+/*===- InstrProfilingFile.c - Write instrumentation to a file -------------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+#include "InstrProfilingUtil.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define UNCONST(ptr) ((void *)(uintptr_t)(ptr))
+
+/* Return 1 if there is an error, otherwise return  0.  */
+static uint32_t fileWriter(ProfDataIOVec *IOVecs, uint32_t NumIOVecs,
+                           void **WriterCtx) {
+  uint32_t I;
+  FILE *File = (FILE *)*WriterCtx;
+  for (I = 0; I < NumIOVecs; I++) {
+    if (fwrite(IOVecs[I].Data, IOVecs[I].ElmSize, IOVecs[I].NumElm, File) !=
+        IOVecs[I].NumElm)
+      return 1;
+  }
+  return 0;
+}
+
+static int writeFile(FILE *File) {
+  uint8_t *ValueDataBegin = NULL;
+  const uint64_t ValueDataSize =
+      __llvm_profile_gather_value_data(&ValueDataBegin);
+  int r = llvmWriteProfData(fileWriter, File, ValueDataBegin, ValueDataSize);
+  free(ValueDataBegin);
+  return r;
+}
+
+static int writeFileWithName(const char *OutputName) {
+  int RetVal;
+  FILE *OutputFile;
+  if (!OutputName || !OutputName[0])
+    return -1;
+
+  /* Append to the file to support profiling multiple shared objects. */
+  OutputFile = fopen(OutputName, "ab");
+  if (!OutputFile)
+    return -1;
+
+  RetVal = writeFile(OutputFile);
+
+  fclose(OutputFile);
+  return RetVal;
+}
+
+COMPILER_RT_WEAK int __llvm_profile_OwnsFilename = 0;
+COMPILER_RT_WEAK const char *__llvm_profile_CurrentFilename = NULL;
+
+static void truncateCurrentFile(void) {
+  const char *Filename;
+  FILE *File;
+
+  Filename = __llvm_profile_CurrentFilename;
+  if (!Filename || !Filename[0])
+    return;
+
+  /* Create the directory holding the file, if needed. */
+  if (strchr(Filename, '/')) {
+    char *Copy = malloc(strlen(Filename) + 1);
+    strcpy(Copy, Filename);
+    __llvm_profile_recursive_mkdir(Copy);
+    free(Copy);
+  }
+
+  /* Truncate the file.  Later we'll reopen and append. */
+  File = fopen(Filename, "w");
+  if (!File)
+    return;
+  fclose(File);
+}
+
+static void setFilename(const char *Filename, int OwnsFilename) {
+  /* Check if this is a new filename and therefore needs truncation. */
+  int NewFile = !__llvm_profile_CurrentFilename ||
+      (Filename && strcmp(Filename, __llvm_profile_CurrentFilename));
+  if (__llvm_profile_OwnsFilename)
+    free(UNCONST(__llvm_profile_CurrentFilename));
+
+  __llvm_profile_CurrentFilename = Filename;
+  __llvm_profile_OwnsFilename = OwnsFilename;
+
+  /* If not a new file, append to support profiling multiple shared objects. */
+  if (NewFile)
+    truncateCurrentFile();
+}
+
+static void resetFilenameToDefault(void) { setFilename("default.profraw", 0); }
+
+int getpid(void);
+static int setFilenamePossiblyWithPid(const char *Filename) {
+#define MAX_PID_SIZE 16
+  char PidChars[MAX_PID_SIZE] = {0};
+  int NumPids = 0, PidLength = 0;
+  char *Allocated;
+  int I, J;
+
+  /* Reset filename on NULL, except with env var which is checked by caller. */
+  if (!Filename) {
+    resetFilenameToDefault();
+    return 0;
+  }
+
+  /* Check the filename for "%p", which indicates a pid-substitution. */
+  for (I = 0; Filename[I]; ++I)
+    if (Filename[I] == '%' && Filename[++I] == 'p')
+      if (!NumPids++) {
+        PidLength = snprintf(PidChars, MAX_PID_SIZE, "%d", getpid());
+        if (PidLength <= 0)
+          return -1;
+      }
+  if (!NumPids) {
+    setFilename(Filename, 0);
+    return 0;
+  }
+
+  /* Allocate enough space for the substituted filename. */
+  Allocated = malloc(I + NumPids*(PidLength - 2) + 1);
+  if (!Allocated)
+    return -1;
+
+  /* Construct the new filename. */
+  for (I = 0, J = 0; Filename[I]; ++I)
+    if (Filename[I] == '%') {
+      if (Filename[++I] == 'p') {
+        memcpy(Allocated + J, PidChars, PidLength);
+        J += PidLength;
+      }
+      /* Drop any unknown substitutions. */
+    } else
+      Allocated[J++] = Filename[I];
+  Allocated[J] = 0;
+
+  /* Use the computed name. */
+  setFilename(Allocated, 1);
+  return 0;
+}
+
+static int setFilenameFromEnvironment(void) {
+  const char *Filename = getenv("LLVM_PROFILE_FILE");
+
+  if (!Filename || !Filename[0])
+    return -1;
+
+  return setFilenamePossiblyWithPid(Filename);
+}
+
+static void setFilenameAutomatically(void) {
+  if (!setFilenameFromEnvironment())
+    return;
+
+  resetFilenameToDefault();
+}
+
+COMPILER_RT_VISIBILITY
+void __llvm_profile_initialize_file(void) {
+  /* Check if the filename has been initialized. */
+  if (__llvm_profile_CurrentFilename)
+    return;
+
+  /* Detect the filename and truncate. */
+  setFilenameAutomatically();
+}
+
+COMPILER_RT_VISIBILITY
+void __llvm_profile_set_filename(const char *Filename) {
+  setFilenamePossiblyWithPid(Filename);
+}
+
+COMPILER_RT_VISIBILITY
+void __llvm_profile_override_default_filename(const char *Filename) {
+  /* If the env var is set, skip setting filename from argument. */
+  const char *Env_Filename = getenv("LLVM_PROFILE_FILE");
+  if (Env_Filename && Env_Filename[0])
+    return;
+  setFilenamePossiblyWithPid(Filename);
+}
+
+COMPILER_RT_VISIBILITY
+int __llvm_profile_write_file(void) {
+  int rc;
+
+  GetEnvHook = &getenv;
+  /* Check the filename. */
+  if (!__llvm_profile_CurrentFilename) {
+    PROF_ERR("LLVM Profile: Failed to write file : %s\n", "Filename not set");
+    return -1;
+  }
+
+  /* Write the file. */
+  rc = writeFileWithName(__llvm_profile_CurrentFilename);
+  if (rc)
+    PROF_ERR("LLVM Profile: Failed to write file \"%s\": %s\n",
+            __llvm_profile_CurrentFilename, strerror(errno));
+  return rc;
+}
+
+static void writeFileWithoutReturn(void) { __llvm_profile_write_file(); }
+
+COMPILER_RT_VISIBILITY
+int __llvm_profile_register_write_file_atexit(void) {
+  static int HasBeenRegistered = 0;
+
+  if (HasBeenRegistered)
+    return 0;
+
+  HasBeenRegistered = 1;
+  return atexit(writeFileWithoutReturn);
+}
diff --git a/compiler-rt/lib/profile/InstrProfilingInternal.h b/compiler-rt/lib/profile/InstrProfilingInternal.h
new file mode 100644
index 0000000..d247ca4
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingInternal.h
@@ -0,0 +1,66 @@
+/*===- InstrProfiling.h- Support library for PGO instrumentation ----------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#ifndef PROFILE_INSTRPROFILING_INTERNALH_
+#define PROFILE_INSTRPROFILING_INTERNALH_
+
+#include "InstrProfiling.h"
+#include "stddef.h"
+
+/*!
+ * \brief Write instrumentation data to the given buffer, given explicit
+ * pointers to the live data in memory.  This function is probably not what you
+ * want.  Use __llvm_profile_get_size_for_buffer instead.  Use this function if
+ * your program has a custom memory layout.
+ */
+uint64_t __llvm_profile_get_size_for_buffer_internal(
+    const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
+    const uint64_t *CountersBegin, const uint64_t *CountersEnd,
+    const char *NamesBegin, const char *NamesEnd);
+
+/*!
+ * \brief Write instrumentation data to the given buffer, given explicit
+ * pointers to the live data in memory.  This function is probably not what you
+ * want.  Use __llvm_profile_write_buffer instead.  Use this function if your
+ * program has a custom memory layout.
+ *
+ * \pre \c Buffer is the start of a buffer at least as big as \a
+ * __llvm_profile_get_size_for_buffer_internal().
+ */
+int __llvm_profile_write_buffer_internal(
+    char *Buffer, const __llvm_profile_data *DataBegin,
+    const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
+    const uint64_t *CountersEnd, const char *NamesBegin, const char *NamesEnd);
+
+/*!
+ * This is an internal function not intended to be used externally.
+ */
+typedef struct ProfDataIOVec {
+  const void *Data;
+  size_t ElmSize;
+  size_t NumElm;
+} ProfDataIOVec;
+
+typedef uint32_t (*WriterCallback)(ProfDataIOVec *, uint32_t NumIOVecs,
+                                   void **WriterCtx);
+int llvmWriteProfData(WriterCallback Writer, void *WriterCtx,
+                      const uint8_t *ValueDataBegin,
+                      const uint64_t ValueDataSize);
+int llvmWriteProfDataImpl(WriterCallback Writer, void *WriterCtx,
+                          const __llvm_profile_data *DataBegin,
+                          const __llvm_profile_data *DataEnd,
+                          const uint64_t *CountersBegin,
+                          const uint64_t *CountersEnd,
+                          const uint8_t *ValueDataBegin,
+                          const uint64_t ValueDataSize, const char *NamesBegin,
+                          const char *NamesEnd);
+
+extern char *(*GetEnvHook)(const char *);
+
+#endif
diff --git a/compiler-rt/lib/profile/InstrProfilingPlatformDarwin.c b/compiler-rt/lib/profile/InstrProfilingPlatformDarwin.c
new file mode 100644
index 0000000..30ddbd2
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingPlatformDarwin.c
@@ -0,0 +1,46 @@
+/*===- InstrProfilingPlatformDarwin.c - Profile data on Darwin ------------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+
+#if defined(__APPLE__)
+/* Use linker magic to find the bounds of the Data section. */
+COMPILER_RT_VISIBILITY
+extern __llvm_profile_data
+    DataStart __asm("section$start$__DATA$" INSTR_PROF_DATA_SECT_NAME_STR);
+COMPILER_RT_VISIBILITY
+extern __llvm_profile_data
+    DataEnd __asm("section$end$__DATA$" INSTR_PROF_DATA_SECT_NAME_STR);
+COMPILER_RT_VISIBILITY
+extern char
+    NamesStart __asm("section$start$__DATA$" INSTR_PROF_NAME_SECT_NAME_STR);
+COMPILER_RT_VISIBILITY
+extern char NamesEnd __asm("section$end$__DATA$" INSTR_PROF_NAME_SECT_NAME_STR);
+COMPILER_RT_VISIBILITY
+extern uint64_t
+    CountersStart __asm("section$start$__DATA$" INSTR_PROF_CNTS_SECT_NAME_STR);
+COMPILER_RT_VISIBILITY
+extern uint64_t
+    CountersEnd __asm("section$end$__DATA$" INSTR_PROF_CNTS_SECT_NAME_STR);
+
+COMPILER_RT_VISIBILITY
+const __llvm_profile_data *__llvm_profile_begin_data(void) {
+  return &DataStart;
+}
+COMPILER_RT_VISIBILITY
+const __llvm_profile_data *__llvm_profile_end_data(void) { return &DataEnd; }
+COMPILER_RT_VISIBILITY
+const char *__llvm_profile_begin_names(void) { return &NamesStart; }
+COMPILER_RT_VISIBILITY
+const char *__llvm_profile_end_names(void) { return &NamesEnd; }
+COMPILER_RT_VISIBILITY
+uint64_t *__llvm_profile_begin_counters(void) { return &CountersStart; }
+COMPILER_RT_VISIBILITY
+uint64_t *__llvm_profile_end_counters(void) { return &CountersEnd; }
+#endif
diff --git a/compiler-rt/lib/profile/InstrProfilingPlatformLinux.c b/compiler-rt/lib/profile/InstrProfilingPlatformLinux.c
new file mode 100644
index 0000000..7843f47
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingPlatformLinux.c
@@ -0,0 +1,59 @@
+/*===- InstrProfilingPlatformLinux.c - Profile data Linux platform ------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+
+#if defined(__linux__) || defined(__FreeBSD__)
+#include <stdlib.h>
+
+#define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_SECT_NAME)
+#define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_SECT_NAME)
+#define PROF_NAME_START INSTR_PROF_SECT_START(INSTR_PROF_NAME_SECT_NAME)
+#define PROF_NAME_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_NAME_SECT_NAME)
+#define PROF_CNTS_START INSTR_PROF_SECT_START(INSTR_PROF_CNTS_SECT_NAME)
+#define PROF_CNTS_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_CNTS_SECT_NAME)
+
+/* Declare section start and stop symbols for various sections
+ * generated by compiler instrumentation.
+ */
+extern __llvm_profile_data PROF_DATA_START COMPILER_RT_VISIBILITY;
+extern __llvm_profile_data PROF_DATA_STOP COMPILER_RT_VISIBILITY;
+extern uint64_t PROF_CNTS_START COMPILER_RT_VISIBILITY;
+extern uint64_t PROF_CNTS_STOP COMPILER_RT_VISIBILITY;
+extern char PROF_NAME_START COMPILER_RT_VISIBILITY;
+extern char PROF_NAME_STOP COMPILER_RT_VISIBILITY;
+
+/* Add dummy data to ensure the section is always created. */
+__llvm_profile_data
+    __prof_data_sect_data[0] COMPILER_RT_SECTION(INSTR_PROF_DATA_SECT_NAME_STR);
+uint64_t
+    __prof_cnts_sect_data[0] COMPILER_RT_SECTION(INSTR_PROF_CNTS_SECT_NAME_STR);
+char __prof_nms_sect_data[0] COMPILER_RT_SECTION(INSTR_PROF_NAME_SECT_NAME_STR);
+
+COMPILER_RT_VISIBILITY const __llvm_profile_data *
+__llvm_profile_begin_data(void) {
+  return &PROF_DATA_START;
+}
+COMPILER_RT_VISIBILITY const __llvm_profile_data *
+__llvm_profile_end_data(void) {
+  return &PROF_DATA_STOP;
+}
+COMPILER_RT_VISIBILITY const char *__llvm_profile_begin_names(void) {
+  return &PROF_NAME_START;
+}
+COMPILER_RT_VISIBILITY const char *__llvm_profile_end_names(void) {
+  return &PROF_NAME_STOP;
+}
+COMPILER_RT_VISIBILITY uint64_t *__llvm_profile_begin_counters(void) {
+  return &PROF_CNTS_START;
+}
+COMPILER_RT_VISIBILITY uint64_t *__llvm_profile_end_counters(void) {
+  return &PROF_CNTS_STOP;
+}
+#endif
diff --git a/compiler-rt/lib/profile/InstrProfilingPlatformOther.c b/compiler-rt/lib/profile/InstrProfilingPlatformOther.c
new file mode 100644
index 0000000..58ceb34
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingPlatformOther.c
@@ -0,0 +1,68 @@
+/*===- InstrProfilingPlatformOther.c - Profile data default platform ------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(__FreeBSD__)
+#include <stdlib.h>
+
+static const __llvm_profile_data *DataFirst = NULL;
+static const __llvm_profile_data *DataLast = NULL;
+static const char *NamesFirst = NULL;
+static const char *NamesLast = NULL;
+static uint64_t *CountersFirst = NULL;
+static uint64_t *CountersLast = NULL;
+
+/*!
+ * \brief Register an instrumented function.
+ *
+ * Calls to this are emitted by clang with -fprofile-instr-generate.  Such
+ * calls are only required (and only emitted) on targets where we haven't
+ * implemented linker magic to find the bounds of the sections.
+ */
+COMPILER_RT_VISIBILITY
+void __llvm_profile_register_function(void *Data_) {
+  /* TODO: Only emit this function if we can't use linker magic. */
+  const __llvm_profile_data *Data = (__llvm_profile_data *)Data_;
+  if (!DataFirst) {
+    DataFirst = Data;
+    DataLast = Data + 1;
+    NamesFirst = Data->NamePtr;
+    NamesLast = (const char *)Data->NamePtr + Data->NameSize;
+    CountersFirst = Data->CounterPtr;
+    CountersLast = (uint64_t *)Data->CounterPtr + Data->NumCounters;
+    return;
+  }
+
+#define UPDATE_FIRST(First, New) First = New < First ? New : First
+  UPDATE_FIRST(DataFirst, Data);
+  UPDATE_FIRST(NamesFirst, (const char *)Data->NamePtr);
+  UPDATE_FIRST(CountersFirst, (uint64_t *)Data->CounterPtr);
+#undef UPDATE_FIRST
+
+#define UPDATE_LAST(Last, New) Last = New > Last ? New : Last
+  UPDATE_LAST(DataLast, Data + 1);
+  UPDATE_LAST(NamesLast, (const char *)Data->NamePtr + Data->NameSize);
+  UPDATE_LAST(CountersLast, (uint64_t *)Data->CounterPtr + Data->NumCounters);
+#undef UPDATE_LAST
+}
+
+COMPILER_RT_VISIBILITY
+const __llvm_profile_data *__llvm_profile_begin_data(void) { return DataFirst; }
+COMPILER_RT_VISIBILITY
+const __llvm_profile_data *__llvm_profile_end_data(void) { return DataLast; }
+COMPILER_RT_VISIBILITY
+const char *__llvm_profile_begin_names(void) { return NamesFirst; }
+COMPILER_RT_VISIBILITY
+const char *__llvm_profile_end_names(void) { return NamesLast; }
+COMPILER_RT_VISIBILITY
+uint64_t *__llvm_profile_begin_counters(void) { return CountersFirst; }
+COMPILER_RT_VISIBILITY
+uint64_t *__llvm_profile_end_counters(void) { return CountersLast; }
+#endif
diff --git a/compiler-rt/lib/profile/InstrProfilingPort.h b/compiler-rt/lib/profile/InstrProfilingPort.h
new file mode 100644
index 0000000..da4f18f
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingPort.h
@@ -0,0 +1,76 @@
+/*===- InstrProfilingPort.h- Support library for PGO instrumentation ------===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#ifndef PROFILE_INSTRPROFILING_PORT_H_
+#define PROFILE_INSTRPROFILING_PORT_H_
+
+#ifdef _MSC_VER
+#define COMPILER_RT_ALIGNAS(x) __declspec(align(x))
+#define COMPILER_RT_VISIBILITY
+#define COMPILER_RT_WEAK __declspec(selectany)
+#elif __GNUC__
+#define COMPILER_RT_ALIGNAS(x) __attribute__((aligned(x)))
+#define COMPILER_RT_VISIBILITY __attribute__((visibility("hidden")))
+#define COMPILER_RT_WEAK __attribute__((weak))
+#endif
+
+#define COMPILER_RT_SECTION(Sect) __attribute__((section(Sect)))
+
+#if COMPILER_RT_HAS_ATOMICS == 1
+#ifdef _MSC_VER
+#include <windows.h>
+#if defined(_WIN64)
+#define COMPILER_RT_BOOL_CMPXCHG(Ptr, OldV, NewV)                              \
+  (InterlockedCompareExchange64((LONGLONG volatile *)Ptr, (LONGLONG)NewV,      \
+                                (LONGLONG)OldV) == (LONGLONG)OldV)
+#else
+#define COMPILER_RT_BOOL_CMPXCHG(Ptr, OldV, NewV)                              \
+  (InterlockedCompareExchange((LONG volatile *)Ptr, (LONG)NewV, (LONG)OldV) == \
+   (LONG)OldV)
+#endif
+#else
+#define COMPILER_RT_BOOL_CMPXCHG(Ptr, OldV, NewV)                              \
+  __sync_bool_compare_and_swap(Ptr, OldV, NewV)
+#endif
+#else
+#define COMPILER_RT_BOOL_CMPXCHG(Ptr, OldV, NewV)                              \
+  BoolCmpXchg((void **)Ptr, OldV, NewV)
+#endif
+
+#define PROF_ERR(Format, ...)                                                  \
+  if (GetEnvHook && GetEnvHook("LLVM_PROFILE_VERBOSE_ERRORS"))                 \
+    fprintf(stderr, Format, __VA_ARGS__);
+
+#if defined(__FreeBSD__) && defined(__i386__)
+
+/* System headers define 'size_t' incorrectly on x64 FreeBSD (prior to
+ * FreeBSD 10, r232261) when compiled in 32-bit mode.
+ */
+#define PRIu64 "llu"
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef uint32_t uintptr_t;
+#elif defined(__FreeBSD__) && defined(__x86_64__)
+#define PRIu64 "lu"
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long int uintptr_t;
+
+#else /* defined(__FreeBSD__) && defined(__i386__) */
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#endif /* defined(__FreeBSD__) && defined(__i386__) */
+
+#endif /* PROFILE_INSTRPROFILING_PORT_H_ */
diff --git a/compiler-rt/lib/profile/InstrProfilingRuntime.cc b/compiler-rt/lib/profile/InstrProfilingRuntime.cc
new file mode 100644
index 0000000..12ad9f1
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingRuntime.cc
@@ -0,0 +1,29 @@
+//===- InstrProfilingRuntime.cpp - PGO runtime initialization -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+extern "C" {
+
+#include "InstrProfiling.h"
+
+COMPILER_RT_VISIBILITY int __llvm_profile_runtime;
+}
+
+namespace {
+
+class RegisterRuntime {
+public:
+  RegisterRuntime() {
+    __llvm_profile_register_write_file_atexit();
+    __llvm_profile_initialize_file();
+  }
+};
+
+RegisterRuntime Registration;
+
+}
diff --git a/compiler-rt/lib/profile/InstrProfilingUtil.c b/compiler-rt/lib/profile/InstrProfilingUtil.c
new file mode 100644
index 0000000..6f0443d
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingUtil.c
@@ -0,0 +1,36 @@
+/*===- InstrProfilingUtil.c - Support library for PGO instrumentation -----===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfilingUtil.h"
+#include "InstrProfiling.h"
+
+#ifdef _WIN32
+#include <direct.h>
+#elif I386_FREEBSD
+int mkdir(const char*, unsigned short);
+#else
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+COMPILER_RT_VISIBILITY
+void __llvm_profile_recursive_mkdir(char *path) {
+  int i;
+
+  for (i = 1; path[i] != '\0'; ++i) {
+    if (path[i] != '/') continue;
+    path[i] = '\0';
+#ifdef _WIN32
+    _mkdir(path);
+#else
+    mkdir(path, 0755);  /* Some of these will fail, ignore it. */
+#endif
+    path[i] = '/';
+  }
+}
diff --git a/compiler-rt/lib/profile/InstrProfilingUtil.h b/compiler-rt/lib/profile/InstrProfilingUtil.h
new file mode 100644
index 0000000..756b18e
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingUtil.h
@@ -0,0 +1,16 @@
+/*===- InstrProfilingUtil.h - Support library for PGO instrumentation -----===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#ifndef PROFILE_INSTRPROFILINGUTIL_H
+#define PROFILE_INSTRPROFILINGUTIL_H
+
+/*! \brief Create a directory tree. */
+void __llvm_profile_recursive_mkdir(char *Pathname);
+
+#endif  /* PROFILE_INSTRPROFILINGUTIL_H */
diff --git a/compiler-rt/lib/profile/InstrProfilingValue.c b/compiler-rt/lib/profile/InstrProfilingValue.c
new file mode 100644
index 0000000..4888eec
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingValue.c
@@ -0,0 +1,238 @@
+/*===- InstrProfilingValue.c - Support library for PGO instrumentation ----===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define INSTR_PROF_VALUE_PROF_DATA
+#define INSTR_PROF_COMMON_API_IMPL
+#include "InstrProfData.inc"
+
+#define PROF_OOM(Msg) PROF_ERR(Msg ":%s\n", "Out of memory");
+#define PROF_OOM_RETURN(Msg)                                                   \
+  {                                                                            \
+    PROF_OOM(Msg)                                                              \
+    return 0;                                                                  \
+  }
+
+#if COMPILER_RT_HAS_ATOMICS != 1
+COMPILER_RT_VISIBILITY
+uint32_t BoolCmpXchg(void **Ptr, void *OldV, void *NewV) {
+  void *R = *Ptr;
+  if (R == OldV) {
+    *Ptr = NewV;
+    return 1;
+  }
+  return 0;
+}
+#endif
+
+/* This method is only used in value profiler mock testing.  */
+COMPILER_RT_VISIBILITY void
+__llvm_profile_set_num_value_sites(__llvm_profile_data *Data,
+                                   uint32_t ValueKind, uint16_t NumValueSites) {
+  *((uint16_t *)&Data->NumValueSites[ValueKind]) = NumValueSites;
+}
+
+/* This method is only used in value profiler mock testing.  */
+COMPILER_RT_VISIBILITY const __llvm_profile_data *
+__llvm_profile_iterate_data(const __llvm_profile_data *Data) {
+  return Data + 1;
+}
+
+/* This method is only used in value profiler mock testing.  */
+COMPILER_RT_VISIBILITY void *
+__llvm_get_function_addr(const __llvm_profile_data *Data) {
+  return Data->FunctionPointer;
+}
+
+/* Allocate an array that holds the pointers to the linked lists of
+ * value profile counter nodes. The number of element of the array
+ * is the total number of value profile sites instrumented. Returns
+ * 0 if allocation fails.
+ */
+
+static int allocateValueProfileCounters(__llvm_profile_data *Data) {
+  uint64_t NumVSites = 0;
+  uint32_t VKI;
+  for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
+    NumVSites += Data->NumValueSites[VKI];
+
+  ValueProfNode **Mem =
+      (ValueProfNode **)calloc(NumVSites, sizeof(ValueProfNode *));
+  if (!Mem)
+    return 0;
+  if (!COMPILER_RT_BOOL_CMPXCHG(&Data->Values, 0, Mem)) {
+    free(Mem);
+    return 0;
+  }
+  return 1;
+}
+
+static void deallocateValueProfileCounters(__llvm_profile_data *Data) {
+  uint64_t NumVSites = 0, I;
+  uint32_t VKI;
+  if (!Data->Values)
+    return;
+  for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
+    NumVSites += Data->NumValueSites[VKI];
+  for (I = 0; I < NumVSites; I++) {
+    ValueProfNode *Node = ((ValueProfNode **)Data->Values)[I];
+    while (Node) {
+      ValueProfNode *Next = Node->Next;
+      free(Node);
+      Node = Next;
+    }
+  }
+  free(Data->Values);
+}
+
+COMPILER_RT_VISIBILITY void
+__llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
+                                 uint32_t CounterIndex) {
+
+  __llvm_profile_data *PData = (__llvm_profile_data *)Data;
+  if (!PData)
+    return;
+
+  if (!PData->Values) {
+    if (!allocateValueProfileCounters(PData))
+      return;
+  }
+
+  ValueProfNode **ValueCounters = (ValueProfNode **)PData->Values;
+  ValueProfNode *PrevVNode = NULL;
+  ValueProfNode *CurrentVNode = ValueCounters[CounterIndex];
+
+  uint8_t VDataCount = 0;
+  while (CurrentVNode) {
+    if (TargetValue == CurrentVNode->VData.Value) {
+      CurrentVNode->VData.Count++;
+      return;
+    }
+    PrevVNode = CurrentVNode;
+    CurrentVNode = CurrentVNode->Next;
+    ++VDataCount;
+  }
+
+  if (VDataCount >= UCHAR_MAX)
+    return;
+
+  CurrentVNode = (ValueProfNode *)calloc(1, sizeof(ValueProfNode));
+  if (!CurrentVNode)
+    return;
+
+  CurrentVNode->VData.Value = TargetValue;
+  CurrentVNode->VData.Count++;
+
+  uint32_t Success = 0;
+  if (!ValueCounters[CounterIndex])
+    Success =
+        COMPILER_RT_BOOL_CMPXCHG(&ValueCounters[CounterIndex], 0, CurrentVNode);
+  else if (PrevVNode && !PrevVNode->Next)
+    Success = COMPILER_RT_BOOL_CMPXCHG(&(PrevVNode->Next), 0, CurrentVNode);
+
+  if (!Success) {
+    free(CurrentVNode);
+    return;
+  }
+}
+
+/* For multi-threaded programs, while the profile is being dumped, other
+   threads may still be updating the value profile data and creating new
+   value entries. To accommadate this, we need to add extra bytes to the
+   data buffer. The size of the extra space is controlled by an environment
+   variable. */
+static unsigned getVprofExtraBytes() {
+  const char *ExtraStr =
+      GetEnvHook ? GetEnvHook("LLVM_VALUE_PROF_BUFFER_EXTRA") : 0;
+  if (!ExtraStr || !ExtraStr[0])
+    return 1024;
+  return (unsigned)atoi(ExtraStr);
+}
+
+/* Extract the value profile data info from the runtime. */
+#define DEF_VALUE_RECORD(R, NS, V)                                             \
+  ValueProfRuntimeRecord R;                                                    \
+  if (initializeValueProfRuntimeRecord(&R, NS, V))                             \
+    PROF_OOM_RETURN("Failed to write value profile data ");
+
+#define DTOR_VALUE_RECORD(R) finalizeValueProfRuntimeRecord(&R);
+
+COMPILER_RT_VISIBILITY uint64_t
+__llvm_profile_gather_value_data(uint8_t **VDataArray) {
+  size_t S = 0, RealSize = 0, BufferCapacity = 0, Extra = 0;
+  __llvm_profile_data *I;
+  if (!VDataArray)
+    PROF_OOM_RETURN("Failed to write value profile data ");
+
+  const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
+  const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
+
+  /*
+   * Compute the total Size of the buffer to hold ValueProfData
+   * structures for functions with value profile data.
+   */
+  for (I = (__llvm_profile_data *)DataBegin; I != DataEnd; ++I) {
+
+    DEF_VALUE_RECORD(R, I->NumValueSites, I->Values);
+
+    /* Compute the size of ValueProfData from this runtime record.  */
+    if (getNumValueKindsRT(&R) != 0)
+      S += getValueProfDataSizeRT(&R);
+
+    DTOR_VALUE_RECORD(R);
+  }
+  /* No value sites or no value profile data is collected. */
+  if (!S)
+    return 0;
+
+  Extra = getVprofExtraBytes();
+  BufferCapacity = S + Extra;
+  *VDataArray = calloc(BufferCapacity, sizeof(uint8_t));
+  if (!*VDataArray)
+    PROF_OOM_RETURN("Failed to write value profile data ");
+
+  ValueProfData *VD = (ValueProfData *)(*VDataArray);
+  /*
+   * Extract value profile data and write into ValueProfData structure
+   * one by one. Note that new value profile data added to any value
+   * site (from another thread) after the ValueProfRuntimeRecord is
+   * initialized (when the profile data snapshot is taken) won't be
+   * collected. This is not a problem as those dropped value will have
+   * very low taken count.
+   */
+  for (I = (__llvm_profile_data *)DataBegin; I != DataEnd; ++I) {
+    DEF_VALUE_RECORD(R, I->NumValueSites, I->Values);
+    if (getNumValueKindsRT(&R) == 0)
+      continue;
+
+    /* Record R has taken a snapshot of the VP data at this point. Newly
+       added VP data for this function will be dropped.  */
+    /* Check if there is enough space.  */
+    if (BufferCapacity - RealSize < getValueProfDataSizeRT(&R)) {
+      PROF_ERR("Value profile data is dropped :%s \n",
+               "Out of buffer space. Use environment "
+               " LLVM_VALUE_PROF_BUFFER_EXTRA to allocate more");
+      I->Values = 0;
+    }
+
+    serializeValueProfDataFromRT(&R, VD);
+    deallocateValueProfileCounters(I);
+    I->Values = VD;
+    RealSize += VD->TotalSize;
+    VD = (ValueProfData *)((char *)VD + VD->TotalSize);
+    DTOR_VALUE_RECORD(R);
+  }
+
+  return RealSize;
+}
diff --git a/compiler-rt/lib/profile/InstrProfilingWriter.c b/compiler-rt/lib/profile/InstrProfilingWriter.c
new file mode 100644
index 0000000..4c9e679
--- /dev/null
+++ b/compiler-rt/lib/profile/InstrProfilingWriter.c
@@ -0,0 +1,70 @@
+/*===- InstrProfilingWriter.c - Write instrumentation to a file or buffer -===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+
+COMPILER_RT_VISIBILITY int llvmWriteProfData(WriterCallback Writer,
+                                             void *WriterCtx,
+                                             const uint8_t *ValueDataBegin,
+                                             const uint64_t ValueDataSize) {
+  /* Match logic in __llvm_profile_write_buffer(). */
+  const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
+  const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
+  const uint64_t *CountersBegin = __llvm_profile_begin_counters();
+  const uint64_t *CountersEnd = __llvm_profile_end_counters();
+  const char *NamesBegin = __llvm_profile_begin_names();
+  const char *NamesEnd = __llvm_profile_end_names();
+  return llvmWriteProfDataImpl(Writer, WriterCtx, DataBegin, DataEnd,
+                               CountersBegin, CountersEnd, ValueDataBegin,
+                               ValueDataSize, NamesBegin, NamesEnd);
+}
+
+COMPILER_RT_VISIBILITY int llvmWriteProfDataImpl(
+    WriterCallback Writer, void *WriterCtx,
+    const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
+    const uint64_t *CountersBegin, const uint64_t *CountersEnd,
+    const uint8_t *ValueDataBegin, const uint64_t ValueDataSize,
+    const char *NamesBegin, const char *NamesEnd) {
+
+  /* Calculate size of sections. */
+  const uint64_t DataSize = DataEnd - DataBegin;
+  const uint64_t CountersSize = CountersEnd - CountersBegin;
+  const uint64_t NamesSize = NamesEnd - NamesBegin;
+  const uint64_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);
+
+  /* Enough zeroes for padding. */
+  const char Zeroes[sizeof(uint64_t)] = {0};
+
+  /* Create the header. */
+  __llvm_profile_header Header;
+
+  if (!DataSize)
+    return 0;
+
+  /* Initialize header struture.  */
+#define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
+#include "InstrProfData.inc"
+
+  /* Write the data. */
+  ProfDataIOVec IOVec[] = {
+      {&Header, sizeof(__llvm_profile_header), 1},
+      {DataBegin, sizeof(__llvm_profile_data), DataSize},
+      {CountersBegin, sizeof(uint64_t), CountersSize},
+      {NamesBegin, sizeof(char), NamesSize},
+      {Zeroes, sizeof(char), Padding}};
+  if (Writer(IOVec, sizeof(IOVec) / sizeof(*IOVec), &WriterCtx))
+    return -1;
+  if (ValueDataBegin) {
+    ProfDataIOVec IOVec2[] = {{ValueDataBegin, sizeof(char), ValueDataSize}};
+    if (Writer(IOVec2, sizeof(IOVec2) / sizeof(*IOVec2), &WriterCtx))
+      return -1;
+  }
+  return 0;
+}
diff --git a/compiler-rt/lib/profile/Makefile.mk b/compiler-rt/lib/profile/Makefile.mk
new file mode 100644
index 0000000..dd3a36f
--- /dev/null
+++ b/compiler-rt/lib/profile/Makefile.mk
@@ -0,0 +1,18 @@
+#===- lib/profile/Makefile.mk ------------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := profile
+SubDirs :=
+
+Sources := $(foreach file,$(wildcard $(Dir)/*.c $(Dir)/*.cc),$(notdir $(file)))
+ObjNames := $(patsubst %.c,%.o,$(patsubst %.cc,%.o,$(Sources)))
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
diff --git a/compiler-rt/lib/safestack/.clang-format b/compiler-rt/lib/safestack/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/safestack/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/safestack/CMakeLists.txt b/compiler-rt/lib/safestack/CMakeLists.txt
new file mode 100644
index 0000000..9c11bb6
--- /dev/null
+++ b/compiler-rt/lib/safestack/CMakeLists.txt
@@ -0,0 +1,34 @@
+add_custom_target(safestack)
+
+set(SAFESTACK_SOURCES safestack.cc)
+
+include_directories(..)
+
+set(SAFESTACK_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+
+if(APPLE)
+  # Build universal binary on APPLE.
+  add_compiler_rt_runtime(clang_rt.safestack
+    STATIC
+    OS osx
+    ARCHS ${SAFESTACK_SUPPORTED_ARCH}
+    SOURCES ${SAFESTACK_SOURCES}
+            $<TARGET_OBJECTS:RTInterception.osx>
+            $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+            $<TARGET_OBJECTS:RTSanitizerCommonNoLibc.osx>
+    CFLAGS ${SAFESTACK_CFLAGS}
+    PARENT_TARGET safestack)
+else()
+  # Otherwise, build separate libraries for each target.
+  foreach(arch ${SAFESTACK_SUPPORTED_ARCH})
+    add_compiler_rt_runtime(clang_rt.safestack
+      STATIC
+      ARCHS ${arch}
+      SOURCES ${SAFESTACK_SOURCES}
+              $<TARGET_OBJECTS:RTInterception.${arch}>
+              $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+              $<TARGET_OBJECTS:RTSanitizerCommonNoLibc.${arch}>
+      CFLAGS ${SAFESTACK_CFLAGS}
+      PARENT_TARGET safestack)
+  endforeach()
+endif()
diff --git a/compiler-rt/lib/safestack/safestack.cc b/compiler-rt/lib/safestack/safestack.cc
new file mode 100644
index 0000000..92c24b3
--- /dev/null
+++ b/compiler-rt/lib/safestack/safestack.cc
@@ -0,0 +1,251 @@
+//===-- safestack.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the runtime support for the safe stack protection
+// mechanism. The runtime manages allocation/deallocation of the unsafe stack
+// for the main thread, as well as all pthreads that are created/destroyed
+// during program execution.
+//
+//===----------------------------------------------------------------------===//
+
+#include <limits.h>
+#include <pthread.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/user.h>
+
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+// TODO: The runtime library does not currently protect the safe stack beyond
+// relying on the system-enforced ASLR. The protection of the (safe) stack can
+// be provided by three alternative features:
+//
+// 1) Protection via hardware segmentation on x86-32 and some x86-64
+// architectures: the (safe) stack segment (implicitly accessed via the %ss
+// segment register) can be separated from the data segment (implicitly
+// accessed via the %ds segment register). Dereferencing a pointer to the safe
+// segment would result in a segmentation fault.
+//
+// 2) Protection via software fault isolation: memory writes that are not meant
+// to access the safe stack can be prevented from doing so through runtime
+// instrumentation. One way to do it is to allocate the safe stack(s) in the
+// upper half of the userspace and bitmask the corresponding upper bit of the
+// memory addresses of memory writes that are not meant to access the safe
+// stack.
+//
+// 3) Protection via information hiding on 64 bit architectures: the location
+// of the safe stack(s) can be randomized through secure mechanisms, and the
+// leakage of the stack pointer can be prevented. Currently, libc can leak the
+// stack pointer in several ways (e.g. in longjmp, signal handling, user-level
+// context switching related functions, etc.). These can be fixed in libc and
+// in other low-level libraries, by either eliminating the escaping/dumping of
+// the stack pointer (i.e., %rsp) when that's possible, or by using
+// encryption/PTR_MANGLE (XOR-ing the dumped stack pointer with another secret
+// we control and protect better, as is already done for setjmp in glibc.)
+// Furthermore, a static machine code level verifier can be ran after code
+// generation to make sure that the stack pointer is never written to memory,
+// or if it is, its written on the safe stack.
+//
+// Finally, while the Unsafe Stack pointer is currently stored in a thread
+// local variable, with libc support it could be stored in the TCB (thread
+// control block) as well, eliminating another level of indirection and making
+// such accesses faster. Alternatively, dedicating a separate register for
+// storing it would also be possible.
+
+/// Minimum stack alignment for the unsafe stack.
+const unsigned kStackAlign = 16;
+
+/// Default size of the unsafe stack. This value is only used if the stack
+/// size rlimit is set to infinity.
+const unsigned kDefaultUnsafeStackSize = 0x2800000;
+
+/// Runtime page size obtained through sysconf
+static unsigned pageSize;
+
+// TODO: To make accessing the unsafe stack pointer faster, we plan to
+// eventually store it directly in the thread control block data structure on
+// platforms where this structure is pointed to by %fs or %gs. This is exactly
+// the same mechanism as currently being used by the traditional stack
+// protector pass to store the stack guard (see getStackCookieLocation()
+// function above). Doing so requires changing the tcbhead_t struct in glibc
+// on Linux and tcb struct in libc on FreeBSD.
+//
+// For now, store it in a thread-local variable.
+extern "C" {
+__attribute__((visibility(
+    "default"))) __thread void *__safestack_unsafe_stack_ptr = nullptr;
+}
+
+// Per-thread unsafe stack information. It's not frequently accessed, so there
+// it can be kept out of the tcb in normal thread-local variables.
+static __thread void *unsafe_stack_start = nullptr;
+static __thread size_t unsafe_stack_size = 0;
+static __thread size_t unsafe_stack_guard = 0;
+
+static inline void *unsafe_stack_alloc(size_t size, size_t guard) {
+  CHECK_GE(size + guard, size);
+  void *addr = MmapOrDie(size + guard, "unsafe_stack_alloc");
+  MprotectNoAccess((uptr)addr, (uptr)guard);
+  return (char *)addr + guard;
+}
+
+static inline void unsafe_stack_setup(void *start, size_t size, size_t guard) {
+  CHECK_GE((char *)start + size, (char *)start);
+  CHECK_GE((char *)start + guard, (char *)start);
+  void *stack_ptr = (char *)start + size;
+  CHECK_EQ((((size_t)stack_ptr) & (kStackAlign - 1)), 0);
+
+  __safestack_unsafe_stack_ptr = stack_ptr;
+  unsafe_stack_start = start;
+  unsafe_stack_size = size;
+  unsafe_stack_guard = guard;
+}
+
+static void unsafe_stack_free() {
+  if (unsafe_stack_start) {
+    UnmapOrDie((char *)unsafe_stack_start - unsafe_stack_guard,
+               unsafe_stack_size + unsafe_stack_guard);
+  }
+  unsafe_stack_start = nullptr;
+}
+
+/// Thread data for the cleanup handler
+static pthread_key_t thread_cleanup_key;
+
+/// Safe stack per-thread information passed to the thread_start function
+struct tinfo {
+  void *(*start_routine)(void *);
+  void *start_routine_arg;
+
+  void *unsafe_stack_start;
+  size_t unsafe_stack_size;
+  size_t unsafe_stack_guard;
+};
+
+/// Wrap the thread function in order to deallocate the unsafe stack when the
+/// thread terminates by returning from its main function.
+static void *thread_start(void *arg) {
+  struct tinfo *tinfo = (struct tinfo *)arg;
+
+  void *(*start_routine)(void *) = tinfo->start_routine;
+  void *start_routine_arg = tinfo->start_routine_arg;
+
+  // Setup the unsafe stack; this will destroy tinfo content
+  unsafe_stack_setup(tinfo->unsafe_stack_start, tinfo->unsafe_stack_size,
+                     tinfo->unsafe_stack_guard);
+
+  // Make sure out thread-specific destructor will be called
+  // FIXME: we can do this only any other specific key is set by
+  // intercepting the pthread_setspecific function itself
+  pthread_setspecific(thread_cleanup_key, (void *)1);
+
+  return start_routine(start_routine_arg);
+}
+
+/// Thread-specific data destructor
+static void thread_cleanup_handler(void *_iter) {
+  // We want to free the unsafe stack only after all other destructors
+  // have already run. We force this function to be called multiple times.
+  // User destructors that might run more then PTHREAD_DESTRUCTOR_ITERATIONS-1
+  // times might still end up executing after the unsafe stack is deallocated.
+  size_t iter = (size_t)_iter;
+  if (iter < PTHREAD_DESTRUCTOR_ITERATIONS) {
+    pthread_setspecific(thread_cleanup_key, (void *)(iter + 1));
+  } else {
+    // This is the last iteration
+    unsafe_stack_free();
+  }
+}
+
+/// Intercept thread creation operation to allocate and setup the unsafe stack
+INTERCEPTOR(int, pthread_create, pthread_t *thread,
+            const pthread_attr_t *attr,
+            void *(*start_routine)(void*), void *arg) {
+
+  size_t size = 0;
+  size_t guard = 0;
+
+  if (attr) {
+    pthread_attr_getstacksize(attr, &size);
+    pthread_attr_getguardsize(attr, &guard);
+  } else {
+    // get pthread default stack size
+    pthread_attr_t tmpattr;
+    pthread_attr_init(&tmpattr);
+    pthread_attr_getstacksize(&tmpattr, &size);
+    pthread_attr_getguardsize(&tmpattr, &guard);
+    pthread_attr_destroy(&tmpattr);
+  }
+
+  CHECK_NE(size, 0);
+  CHECK_EQ((size & (kStackAlign - 1)), 0);
+  CHECK_EQ((guard & (pageSize - 1)), 0);
+
+  void *addr = unsafe_stack_alloc(size, guard);
+  struct tinfo *tinfo =
+      (struct tinfo *)(((char *)addr) + size - sizeof(struct tinfo));
+  tinfo->start_routine = start_routine;
+  tinfo->start_routine_arg = arg;
+  tinfo->unsafe_stack_start = addr;
+  tinfo->unsafe_stack_size = size;
+  tinfo->unsafe_stack_guard = guard;
+
+  return REAL(pthread_create)(thread, attr, thread_start, tinfo);
+}
+
+extern "C" __attribute__((visibility("default")))
+#if !SANITIZER_CAN_USE_PREINIT_ARRAY
+// On ELF platforms, the constructor is invoked using .preinit_array (see below)
+__attribute__((constructor(0)))
+#endif
+void __safestack_init() {
+  // Determine the stack size for the main thread.
+  size_t size = kDefaultUnsafeStackSize;
+  size_t guard = 4096;
+
+  struct rlimit limit;
+  if (getrlimit(RLIMIT_STACK, &limit) == 0 && limit.rlim_cur != RLIM_INFINITY)
+    size = limit.rlim_cur;
+
+  // Allocate unsafe stack for main thread
+  void *addr = unsafe_stack_alloc(size, guard);
+
+  unsafe_stack_setup(addr, size, guard);
+  pageSize = sysconf(_SC_PAGESIZE);
+
+  // Initialize pthread interceptors for thread allocation
+  INTERCEPT_FUNCTION(pthread_create);
+
+  // Setup the cleanup handler
+  pthread_key_create(&thread_cleanup_key, thread_cleanup_handler);
+}
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+// On ELF platforms, run safestack initialization before any other constructors.
+// On other platforms we use the constructor attribute to arrange to run our
+// initialization early.
+extern "C" {
+__attribute__((section(".preinit_array"),
+               used)) void (*__safestack_preinit)(void) = __safestack_init;
+}
+#endif
+
+extern "C"
+    __attribute__((visibility("default"))) void *__get_unsafe_stack_start() {
+  return unsafe_stack_start;
+}
+
+extern "C"
+    __attribute__((visibility("default"))) void *__get_unsafe_stack_ptr() {
+  return __safestack_unsafe_stack_ptr;
+}
diff --git a/compiler-rt/lib/sanitizer_common/.clang-format b/compiler-rt/lib/sanitizer_common/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/sanitizer_common/Android.bp b/compiler-rt/lib/sanitizer_common/Android.bp
new file mode 100644
index 0000000..2de4ff1
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/Android.bp
@@ -0,0 +1,100 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+//###############################################################################
+// Host modules
+
+cc_library_static {
+    name: "libsan",
+    host_supported: true,
+    clang: true,
+    sdk_version: "19",
+
+    include_dirs: ["external/compiler-rt/lib"],
+    cppflags: [
+        "-fvisibility=hidden",
+        "-fno-exceptions",
+        "-std=c++11",
+        "-Wall",
+        "-Werror",
+        "-Wno-non-virtual-dtor",
+        "-Wno-unused-parameter",
+    ],
+    srcs: [
+        // rtl
+        "sanitizer_allocator.cc",
+        "sanitizer_common.cc",
+        "sanitizer_deadlock_detector1.cc",
+        "sanitizer_deadlock_detector2.cc",
+        "sanitizer_flags.cc",
+        "sanitizer_flag_parser.cc",
+        "sanitizer_libc.cc",
+        "sanitizer_libignore.cc",
+        "sanitizer_linux.cc",
+        "sanitizer_mac.cc",
+        "sanitizer_persistent_allocator.cc",
+        "sanitizer_platform_limits_linux.cc",
+        "sanitizer_platform_limits_posix.cc",
+        "sanitizer_posix.cc",
+        "sanitizer_printf.cc",
+        "sanitizer_procmaps_common.cc",
+        "sanitizer_procmaps_freebsd.cc",
+        "sanitizer_procmaps_linux.cc",
+        "sanitizer_procmaps_mac.cc",
+        "sanitizer_stackdepot.cc",
+        "sanitizer_stacktrace.cc",
+        "sanitizer_stacktrace_printer.cc",
+        "sanitizer_suppressions.cc",
+        "sanitizer_symbolizer.cc",
+        "sanitizer_symbolizer_libbacktrace.cc",
+        "sanitizer_symbolizer_win.cc",
+        "sanitizer_tls_get_addr.cc",
+        "sanitizer_thread_registry.cc",
+        "sanitizer_win.cc",
+
+        // cdep
+        "sanitizer_common_libcdep.cc",
+        "sanitizer_coverage_libcdep.cc",
+        "sanitizer_coverage_mapping_libcdep.cc",
+        "sanitizer_linux_libcdep.cc",
+        "sanitizer_posix_libcdep.cc",
+        "sanitizer_stacktrace_libcdep.cc",
+        "sanitizer_stoptheworld_linux_libcdep.cc",
+        "sanitizer_symbolizer_libcdep.cc",
+        "sanitizer_symbolizer_posix_libcdep.cc",
+        "sanitizer_unwind_linux_libcdep.cc",
+    ],
+    stl: "none",
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+subdirs = ["tests"]
+
+// ANDROIDMK TRANSLATION ERROR: unsupported conditional
+// ifndef SANITIZE_HOST
+// ANDROIDMK TRANSLATION ERROR: unsupported include
+// include $(LOCAL_PATH)/tests/Android.mk
+// ANDROIDMK TRANSLATION ERROR: endif from unsupported contitional
+// endif
diff --git a/compiler-rt/lib/sanitizer_common/CMakeLists.txt b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
new file mode 100644
index 0000000..6a20f02
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
@@ -0,0 +1,158 @@
+# Build system for the common Sanitizer runtime support library components.
+# These components are shared between AddressSanitizer and ThreadSanitizer.
+
+set(SANITIZER_SOURCES
+  sanitizer_allocator.cc
+  sanitizer_common.cc
+  sanitizer_deadlock_detector1.cc
+  sanitizer_deadlock_detector2.cc
+  sanitizer_flags.cc
+  sanitizer_flag_parser.cc
+  sanitizer_libc.cc
+  sanitizer_libignore.cc
+  sanitizer_linux.cc
+  sanitizer_mac.cc
+  sanitizer_persistent_allocator.cc
+  sanitizer_platform_limits_linux.cc
+  sanitizer_platform_limits_posix.cc
+  sanitizer_posix.cc
+  sanitizer_printf.cc
+  sanitizer_procmaps_common.cc
+  sanitizer_procmaps_freebsd.cc
+  sanitizer_procmaps_linux.cc
+  sanitizer_procmaps_mac.cc
+  sanitizer_stackdepot.cc
+  sanitizer_stacktrace.cc
+  sanitizer_stacktrace_printer.cc
+  sanitizer_suppressions.cc
+  sanitizer_symbolizer.cc
+  sanitizer_symbolizer_libbacktrace.cc
+  sanitizer_symbolizer_mac.cc
+  sanitizer_symbolizer_win.cc
+  sanitizer_tls_get_addr.cc
+  sanitizer_thread_registry.cc
+  sanitizer_win.cc)
+
+# Libc functions stubs. These sources should be linked instead of
+# SANITIZER_LIBCDEP_SOURCES when sanitizer_common library must not depend on
+# libc.
+set(SANITIZER_NOLIBC_SOURCES
+  sanitizer_common_nolibc.cc)
+
+set(SANITIZER_LIBCDEP_SOURCES
+  sanitizer_common_libcdep.cc
+  sanitizer_coverage_libcdep.cc
+  sanitizer_coverage_mapping_libcdep.cc
+  sanitizer_linux_libcdep.cc
+  sanitizer_posix_libcdep.cc
+  sanitizer_stacktrace_libcdep.cc
+  sanitizer_stoptheworld_linux_libcdep.cc
+  sanitizer_symbolizer_libcdep.cc
+  sanitizer_symbolizer_posix_libcdep.cc
+  sanitizer_unwind_linux_libcdep.cc)
+
+# Explicitly list all sanitizer_common headers. Not all of these are
+# included in sanitizer_common source files, but we need to depend on
+# headers when building our custom unit tests.
+set(SANITIZER_HEADERS
+  sanitizer_addrhashmap.h
+  sanitizer_allocator.h
+  sanitizer_allocator_interface.h
+  sanitizer_allocator_internal.h
+  sanitizer_atomic.h
+  sanitizer_atomic_clang.h
+  sanitizer_atomic_msvc.h
+  sanitizer_bitvector.h
+  sanitizer_bvgraph.h
+  sanitizer_common.h
+  sanitizer_common_interceptors.inc
+  sanitizer_common_interceptors_ioctl.inc
+  sanitizer_common_interceptors_format.inc
+  sanitizer_common_syscalls.inc
+  sanitizer_deadlock_detector.h
+  sanitizer_deadlock_detector_interface.h
+  sanitizer_flag_parser.h
+  sanitizer_flags.h
+  sanitizer_flags.inc
+  sanitizer_interface_internal.h
+  sanitizer_internal_defs.h
+  sanitizer_lfstack.h
+  sanitizer_libc.h
+  sanitizer_libignore.h
+  sanitizer_linux.h
+  sanitizer_list.h
+  sanitizer_mac.h
+  sanitizer_mutex.h
+  sanitizer_persistent_allocator.h
+  sanitizer_placement_new.h
+  sanitizer_platform.h
+  sanitizer_platform_interceptors.h
+  sanitizer_platform_limits_posix.h
+  sanitizer_posix.h
+  sanitizer_procmaps.h
+  sanitizer_quarantine.h
+  sanitizer_report_decorator.h
+  sanitizer_stackdepot.h
+  sanitizer_stackdepotbase.h
+  sanitizer_stacktrace.h
+  sanitizer_stacktrace_printer.h
+  sanitizer_stoptheworld.h
+  sanitizer_suppressions.h
+  sanitizer_symbolizer.h
+  sanitizer_symbolizer_internal.h
+  sanitizer_symbolizer_libbacktrace.h
+  sanitizer_symbolizer_mac.h
+  sanitizer_syscall_generic.inc
+  sanitizer_syscall_linux_x86_64.inc
+  sanitizer_syscall_linux_aarch64.inc
+  sanitizer_thread_registry.h)
+
+set(SANITIZER_COMMON_DEFINITIONS)
+
+if(MSVC)
+  list(APPEND SANITIZER_COMMON_DEFINITIONS
+    SANITIZER_NEEDS_SEGV=0)
+else()
+  list(APPEND SANITIZER_COMMON_DEFINITIONS
+    SANITIZER_NEEDS_SEGV=1)
+endif()
+
+include(CheckIncludeFile)
+append_have_file_definition(rpc/xdr.h HAVE_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
+append_have_file_definition(tirpc/rpc/xdr.h HAVE_TIRPC_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
+
+set(SANITIZER_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(SANITIZER_CFLAGS)
+
+append_list_if(SANITIZER_LIMIT_FRAME_SIZE -Wframe-larger-than=570
+               SANITIZER_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG -Wglobal-constructors
+               SANITIZER_CFLAGS)
+
+if(APPLE)
+  set(OS_OPTION OS ${SANITIZER_COMMON_SUPPORTED_OS})
+endif()
+
+add_compiler_rt_object_libraries(RTSanitizerCommon
+  ${OS_OPTION}
+  ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
+  SOURCES ${SANITIZER_SOURCES}
+  CFLAGS ${SANITIZER_CFLAGS}
+  DEFS ${SANITIZER_COMMON_DEFINITIONS})
+add_compiler_rt_object_libraries(RTSanitizerCommonNoLibc
+  ${OS_OPTION}
+  ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
+  SOURCES ${SANITIZER_NOLIBC_SOURCES}
+  CFLAGS ${SANITIZER_CFLAGS}
+  DEFS ${SANITIZER_COMMON_DEFINITIONS})
+add_compiler_rt_object_libraries(RTSanitizerCommonLibc
+  ${OS_OPTION}
+  ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
+  SOURCES ${SANITIZER_LIBCDEP_SOURCES}
+  CFLAGS ${SANITIZER_CFLAGS}
+  DEFS ${SANITIZER_COMMON_DEFINITIONS})
+
+# Unit tests for common sanitizer runtime.
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(tests)
+endif()
diff --git a/compiler-rt/lib/sanitizer_common/Makefile.mk b/compiler-rt/lib/sanitizer_common/Makefile.mk
new file mode 100644
index 0000000..5bb20d0
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/Makefile.mk
@@ -0,0 +1,24 @@
+#===- lib/sanitizer_common/Makefile.mk ---------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := sanitizer_common
+SubDirs :=
+
+Sources := $(foreach file,$(wildcard $(Dir)/*.cc),$(notdir $(file)))
+NolibcSources := $(foreach file,$(wildcard $(Dir)/*_nolibc.cc),$(notdir $(file)))
+Sources := $(filter-out $(NolibcSources),$(Sources))
+ObjNames := $(Sources:%.cc=%.o)
+
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
+
+# Define a convenience variable for all the sanitizer_common functions.
+SanitizerCommonFunctions := $(Sources:%.cc=%)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_addrhashmap.h b/compiler-rt/lib/sanitizer_common/sanitizer_addrhashmap.h
new file mode 100644
index 0000000..e55fc4f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_addrhashmap.h
@@ -0,0 +1,342 @@
+//===-- sanitizer_addrhashmap.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Concurrent uptr->T hashmap.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ADDRHASHMAP_H
+#define SANITIZER_ADDRHASHMAP_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_allocator_internal.h"
+
+namespace __sanitizer {
+
+// Concurrent uptr->T hashmap.
+// T must be a POD type, kSize is preferably a prime but can be any number.
+// Usage example:
+//
+// typedef AddrHashMap<uptr, 11> Map;
+// Map m;
+// {
+//   Map::Handle h(&m, addr);
+//   use h.operator->() to access the data
+//   if h.created() then the element was just created, and the current thread
+//     has exclusive access to it
+//   otherwise the current thread has only read access to the data
+// }
+// {
+//   Map::Handle h(&m, addr, true);
+//   this will remove the data from the map in Handle dtor
+//   the current thread has exclusive access to the data
+//   if !h.exists() then the element never existed
+// }
+template<typename T, uptr kSize>
+class AddrHashMap {
+ private:
+  struct Cell {
+    atomic_uintptr_t addr;
+    T                val;
+  };
+
+  struct AddBucket {
+    uptr cap;
+    uptr size;
+    Cell cells[1];  // variable len
+  };
+
+  static const uptr kBucketSize = 3;
+
+  struct Bucket {
+    RWMutex          mtx;
+    atomic_uintptr_t add;
+    Cell             cells[kBucketSize];
+  };
+
+ public:
+  AddrHashMap();
+
+  class Handle {
+   public:
+    Handle(AddrHashMap<T, kSize> *map, uptr addr);
+    Handle(AddrHashMap<T, kSize> *map, uptr addr, bool remove);
+    Handle(AddrHashMap<T, kSize> *map, uptr addr, bool remove, bool create);
+
+    ~Handle();
+    T *operator->();
+    bool created() const;
+    bool exists() const;
+
+   private:
+    friend AddrHashMap<T, kSize>;
+    AddrHashMap<T, kSize> *map_;
+    Bucket                *bucket_;
+    Cell                  *cell_;
+    uptr                   addr_;
+    uptr                   addidx_;
+    bool                   created_;
+    bool                   remove_;
+    bool                   create_;
+  };
+
+ private:
+  friend class Handle;
+  Bucket *table_;
+
+  void acquire(Handle *h);
+  void release(Handle *h);
+  uptr calcHash(uptr addr);
+};
+
+template<typename T, uptr kSize>
+AddrHashMap<T, kSize>::Handle::Handle(AddrHashMap<T, kSize> *map, uptr addr) {
+  map_ = map;
+  addr_ = addr;
+  remove_ = false;
+  create_ = true;
+  map_->acquire(this);
+}
+
+template<typename T, uptr kSize>
+AddrHashMap<T, kSize>::Handle::Handle(AddrHashMap<T, kSize> *map, uptr addr,
+    bool remove) {
+  map_ = map;
+  addr_ = addr;
+  remove_ = remove;
+  create_ = true;
+  map_->acquire(this);
+}
+
+template<typename T, uptr kSize>
+AddrHashMap<T, kSize>::Handle::Handle(AddrHashMap<T, kSize> *map, uptr addr,
+    bool remove, bool create) {
+  map_ = map;
+  addr_ = addr;
+  remove_ = remove;
+  create_ = create;
+  map_->acquire(this);
+}
+
+template<typename T, uptr kSize>
+AddrHashMap<T, kSize>::Handle::~Handle() {
+  map_->release(this);
+}
+
+template <typename T, uptr kSize>
+T *AddrHashMap<T, kSize>::Handle::operator->() {
+  return &cell_->val;
+}
+
+template<typename T, uptr kSize>
+bool AddrHashMap<T, kSize>::Handle::created() const {
+  return created_;
+}
+
+template<typename T, uptr kSize>
+bool AddrHashMap<T, kSize>::Handle::exists() const {
+  return cell_ != nullptr;
+}
+
+template<typename T, uptr kSize>
+AddrHashMap<T, kSize>::AddrHashMap() {
+  table_ = (Bucket*)MmapOrDie(kSize * sizeof(table_[0]), "AddrHashMap");
+}
+
+template<typename T, uptr kSize>
+void AddrHashMap<T, kSize>::acquire(Handle *h) {
+  uptr addr = h->addr_;
+  uptr hash = calcHash(addr);
+  Bucket *b = &table_[hash];
+
+  h->created_ = false;
+  h->addidx_ = -1U;
+  h->bucket_ = b;
+  h->cell_ = nullptr;
+
+  // If we want to remove the element, we need exclusive access to the bucket,
+  // so skip the lock-free phase.
+  if (h->remove_)
+    goto locked;
+
+ retry:
+  // First try to find an existing element w/o read mutex.
+  CHECK(!h->remove_);
+  // Check the embed cells.
+  for (uptr i = 0; i < kBucketSize; i++) {
+    Cell *c = &b->cells[i];
+    uptr addr1 = atomic_load(&c->addr, memory_order_acquire);
+    if (addr1 == addr) {
+      h->cell_ = c;
+      return;
+    }
+  }
+
+  // Check the add cells with read lock.
+  if (atomic_load(&b->add, memory_order_relaxed)) {
+    b->mtx.ReadLock();
+    AddBucket *add = (AddBucket*)atomic_load(&b->add, memory_order_relaxed);
+    for (uptr i = 0; i < add->size; i++) {
+      Cell *c = &add->cells[i];
+      uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
+      if (addr1 == addr) {
+        h->addidx_ = i;
+        h->cell_ = c;
+        return;
+      }
+    }
+    b->mtx.ReadUnlock();
+  }
+
+ locked:
+  // Re-check existence under write lock.
+  // Embed cells.
+  b->mtx.Lock();
+  for (uptr i = 0; i < kBucketSize; i++) {
+    Cell *c = &b->cells[i];
+    uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
+    if (addr1 == addr) {
+      if (h->remove_) {
+        h->cell_ = c;
+        return;
+      }
+      b->mtx.Unlock();
+      goto retry;
+    }
+  }
+
+  // Add cells.
+  AddBucket *add = (AddBucket*)atomic_load(&b->add, memory_order_relaxed);
+  if (add) {
+    for (uptr i = 0; i < add->size; i++) {
+      Cell *c = &add->cells[i];
+      uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
+      if (addr1 == addr) {
+        if (h->remove_) {
+          h->addidx_ = i;
+          h->cell_ = c;
+          return;
+        }
+        b->mtx.Unlock();
+        goto retry;
+      }
+    }
+  }
+
+  // The element does not exist, no need to create it if we want to remove.
+  if (h->remove_ || !h->create_) {
+    b->mtx.Unlock();
+    return;
+  }
+
+  // Now try to create it under the mutex.
+  h->created_ = true;
+  // See if we have a free embed cell.
+  for (uptr i = 0; i < kBucketSize; i++) {
+    Cell *c = &b->cells[i];
+    uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
+    if (addr1 == 0) {
+      h->cell_ = c;
+      return;
+    }
+  }
+
+  // Store in the add cells.
+  if (!add) {
+    // Allocate a new add array.
+    const uptr kInitSize = 64;
+    add = (AddBucket*)InternalAlloc(kInitSize);
+    internal_memset(add, 0, kInitSize);
+    add->cap = (kInitSize - sizeof(*add)) / sizeof(add->cells[0]) + 1;
+    add->size = 0;
+    atomic_store(&b->add, (uptr)add, memory_order_relaxed);
+  }
+  if (add->size == add->cap) {
+    // Grow existing add array.
+    uptr oldsize = sizeof(*add) + (add->cap - 1) * sizeof(add->cells[0]);
+    uptr newsize = oldsize * 2;
+    AddBucket *add1 = (AddBucket*)InternalAlloc(newsize);
+    internal_memset(add1, 0, newsize);
+    add1->cap = (newsize - sizeof(*add)) / sizeof(add->cells[0]) + 1;
+    add1->size = add->size;
+    internal_memcpy(add1->cells, add->cells, add->size * sizeof(add->cells[0]));
+    InternalFree(add);
+    atomic_store(&b->add, (uptr)add1, memory_order_relaxed);
+    add = add1;
+  }
+  // Store.
+  uptr i = add->size++;
+  Cell *c = &add->cells[i];
+  CHECK_EQ(atomic_load(&c->addr, memory_order_relaxed), 0);
+  h->addidx_ = i;
+  h->cell_ = c;
+}
+
+template<typename T, uptr kSize>
+void AddrHashMap<T, kSize>::release(Handle *h) {
+  if (!h->cell_)
+    return;
+  Bucket *b = h->bucket_;
+  Cell *c = h->cell_;
+  uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
+  if (h->created_) {
+    // Denote completion of insertion.
+    CHECK_EQ(addr1, 0);
+    // After the following store, the element becomes available
+    // for lock-free reads.
+    atomic_store(&c->addr, h->addr_, memory_order_release);
+    b->mtx.Unlock();
+  } else if (h->remove_) {
+    // Denote that the cell is empty now.
+    CHECK_EQ(addr1, h->addr_);
+    atomic_store(&c->addr, 0, memory_order_release);
+    // See if we need to compact the bucket.
+    AddBucket *add = (AddBucket*)atomic_load(&b->add, memory_order_relaxed);
+    if (h->addidx_ == -1U) {
+      // Removed from embed array, move an add element into the freed cell.
+      if (add && add->size != 0) {
+        uptr last = --add->size;
+        Cell *c1 = &add->cells[last];
+        c->val = c1->val;
+        uptr addr1 = atomic_load(&c1->addr, memory_order_relaxed);
+        atomic_store(&c->addr, addr1, memory_order_release);
+        atomic_store(&c1->addr, 0, memory_order_release);
+      }
+    } else {
+      // Removed from add array, compact it.
+      uptr last = --add->size;
+      Cell *c1 = &add->cells[last];
+      if (c != c1) {
+        *c = *c1;
+        atomic_store(&c1->addr, 0, memory_order_relaxed);
+      }
+    }
+    if (add && add->size == 0) {
+      // FIXME(dvyukov): free add?
+    }
+    b->mtx.Unlock();
+  } else {
+    CHECK_EQ(addr1, h->addr_);
+    if (h->addidx_ != -1U)
+      b->mtx.ReadUnlock();
+  }
+}
+
+template<typename T, uptr kSize>
+uptr AddrHashMap<T, kSize>::calcHash(uptr addr) {
+  addr += addr << 10;
+  addr ^= addr >> 6;
+  return addr % kSize;
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_ADDRHASHMAP_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_allocator.cc b/compiler-rt/lib/sanitizer_common/sanitizer_allocator.cc
new file mode 100644
index 0000000..538e2db
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_allocator.cc
@@ -0,0 +1,151 @@
+//===-- sanitizer_allocator.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// This allocator is used inside run-times.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_allocator.h"
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+
+// ThreadSanitizer for Go uses libc malloc/free.
+#if defined(SANITIZER_GO) || defined(SANITIZER_USE_MALLOC)
+# if SANITIZER_LINUX && !SANITIZER_ANDROID
+extern "C" void *__libc_malloc(uptr size);
+extern "C" void __libc_free(void *ptr);
+#  define LIBC_MALLOC __libc_malloc
+#  define LIBC_FREE __libc_free
+# else
+#  include <stdlib.h>
+#  define LIBC_MALLOC malloc
+#  define LIBC_FREE free
+# endif
+
+static void *RawInternalAlloc(uptr size, InternalAllocatorCache *cache) {
+  (void)cache;
+  return LIBC_MALLOC(size);
+}
+
+static void RawInternalFree(void *ptr, InternalAllocatorCache *cache) {
+  (void)cache;
+  LIBC_FREE(ptr);
+}
+
+InternalAllocator *internal_allocator() {
+  return 0;
+}
+
+#else // SANITIZER_GO
+
+static ALIGNED(64) char internal_alloc_placeholder[sizeof(InternalAllocator)];
+static atomic_uint8_t internal_allocator_initialized;
+static StaticSpinMutex internal_alloc_init_mu;
+
+static InternalAllocatorCache internal_allocator_cache;
+static StaticSpinMutex internal_allocator_cache_mu;
+
+InternalAllocator *internal_allocator() {
+  InternalAllocator *internal_allocator_instance =
+      reinterpret_cast<InternalAllocator *>(&internal_alloc_placeholder);
+  if (atomic_load(&internal_allocator_initialized, memory_order_acquire) == 0) {
+    SpinMutexLock l(&internal_alloc_init_mu);
+    if (atomic_load(&internal_allocator_initialized, memory_order_relaxed) ==
+        0) {
+      internal_allocator_instance->Init(/* may_return_null*/ false);
+      atomic_store(&internal_allocator_initialized, 1, memory_order_release);
+    }
+  }
+  return internal_allocator_instance;
+}
+
+static void *RawInternalAlloc(uptr size, InternalAllocatorCache *cache) {
+  if (cache == 0) {
+    SpinMutexLock l(&internal_allocator_cache_mu);
+    return internal_allocator()->Allocate(&internal_allocator_cache, size, 8,
+                                          false);
+  }
+  return internal_allocator()->Allocate(cache, size, 8, false);
+}
+
+static void RawInternalFree(void *ptr, InternalAllocatorCache *cache) {
+  if (!cache) {
+    SpinMutexLock l(&internal_allocator_cache_mu);
+    return internal_allocator()->Deallocate(&internal_allocator_cache, ptr);
+  }
+  internal_allocator()->Deallocate(cache, ptr);
+}
+
+#endif // SANITIZER_GO
+
+const u64 kBlockMagic = 0x6A6CB03ABCEBC041ull;
+
+void *InternalAlloc(uptr size, InternalAllocatorCache *cache) {
+  if (size + sizeof(u64) < size)
+    return nullptr;
+  void *p = RawInternalAlloc(size + sizeof(u64), cache);
+  if (!p)
+    return nullptr;
+  ((u64*)p)[0] = kBlockMagic;
+  return (char*)p + sizeof(u64);
+}
+
+void InternalFree(void *addr, InternalAllocatorCache *cache) {
+  if (!addr)
+    return;
+  addr = (char*)addr - sizeof(u64);
+  CHECK_EQ(kBlockMagic, ((u64*)addr)[0]);
+  ((u64*)addr)[0] = 0;
+  RawInternalFree(addr, cache);
+}
+
+// LowLevelAllocator
+static LowLevelAllocateCallback low_level_alloc_callback;
+
+void *LowLevelAllocator::Allocate(uptr size) {
+  // Align allocation size.
+  size = RoundUpTo(size, 8);
+  if (allocated_end_ - allocated_current_ < (sptr)size) {
+    uptr size_to_allocate = Max(size, GetPageSizeCached());
+    allocated_current_ =
+        (char*)MmapOrDie(size_to_allocate, __func__);
+    allocated_end_ = allocated_current_ + size_to_allocate;
+    if (low_level_alloc_callback) {
+      low_level_alloc_callback((uptr)allocated_current_,
+                               size_to_allocate);
+    }
+  }
+  CHECK(allocated_end_ - allocated_current_ >= (sptr)size);
+  void *res = allocated_current_;
+  allocated_current_ += size;
+  return res;
+}
+
+void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback) {
+  low_level_alloc_callback = callback;
+}
+
+bool CallocShouldReturnNullDueToOverflow(uptr size, uptr n) {
+  if (!size) return false;
+  uptr max = (uptr)-1L;
+  return (max / size) < n;
+}
+
+void NORETURN ReportAllocatorCannotReturnNull() {
+  Report("%s's allocator is terminating the process instead of returning 0\n",
+         SanitizerToolName);
+  Report("If you don't like this behavior set allocator_may_return_null=1\n");
+  CHECK(0);
+  Die();
+}
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_allocator.h b/compiler-rt/lib/sanitizer_common/sanitizer_allocator.h
new file mode 100644
index 0000000..44d6fce
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_allocator.h
@@ -0,0 +1,1455 @@
+//===-- sanitizer_allocator.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Specialized memory allocator for ThreadSanitizer, MemorySanitizer, etc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ALLOCATOR_H
+#define SANITIZER_ALLOCATOR_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_list.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_lfstack.h"
+
+namespace __sanitizer {
+
+// Prints error message and kills the program.
+void NORETURN ReportAllocatorCannotReturnNull();
+
+// SizeClassMap maps allocation sizes into size classes and back.
+// Class 0 corresponds to size 0.
+// Classes 1 - 16 correspond to sizes 16 to 256 (size = class_id * 16).
+// Next 4 classes: 256 + i * 64  (i = 1 to 4).
+// Next 4 classes: 512 + i * 128 (i = 1 to 4).
+// ...
+// Next 4 classes: 2^k + i * 2^(k-2) (i = 1 to 4).
+// Last class corresponds to kMaxSize = 1 << kMaxSizeLog.
+//
+// This structure of the size class map gives us:
+//   - Efficient table-free class-to-size and size-to-class functions.
+//   - Difference between two consequent size classes is betweed 14% and 25%
+//
+// This class also gives a hint to a thread-caching allocator about the amount
+// of chunks that need to be cached per-thread:
+//  - kMaxNumCached is the maximal number of chunks per size class.
+//  - (1 << kMaxBytesCachedLog) is the maximal number of bytes per size class.
+//
+// Part of output of SizeClassMap::Print():
+// c00 => s: 0 diff: +0 00% l 0 cached: 0 0; id 0
+// c01 => s: 16 diff: +16 00% l 4 cached: 256 4096; id 1
+// c02 => s: 32 diff: +16 100% l 5 cached: 256 8192; id 2
+// c03 => s: 48 diff: +16 50% l 5 cached: 256 12288; id 3
+// c04 => s: 64 diff: +16 33% l 6 cached: 256 16384; id 4
+// c05 => s: 80 diff: +16 25% l 6 cached: 256 20480; id 5
+// c06 => s: 96 diff: +16 20% l 6 cached: 256 24576; id 6
+// c07 => s: 112 diff: +16 16% l 6 cached: 256 28672; id 7
+//
+// c08 => s: 128 diff: +16 14% l 7 cached: 256 32768; id 8
+// c09 => s: 144 diff: +16 12% l 7 cached: 256 36864; id 9
+// c10 => s: 160 diff: +16 11% l 7 cached: 256 40960; id 10
+// c11 => s: 176 diff: +16 10% l 7 cached: 256 45056; id 11
+// c12 => s: 192 diff: +16 09% l 7 cached: 256 49152; id 12
+// c13 => s: 208 diff: +16 08% l 7 cached: 256 53248; id 13
+// c14 => s: 224 diff: +16 07% l 7 cached: 256 57344; id 14
+// c15 => s: 240 diff: +16 07% l 7 cached: 256 61440; id 15
+//
+// c16 => s: 256 diff: +16 06% l 8 cached: 256 65536; id 16
+// c17 => s: 320 diff: +64 25% l 8 cached: 204 65280; id 17
+// c18 => s: 384 diff: +64 20% l 8 cached: 170 65280; id 18
+// c19 => s: 448 diff: +64 16% l 8 cached: 146 65408; id 19
+//
+// c20 => s: 512 diff: +64 14% l 9 cached: 128 65536; id 20
+// c21 => s: 640 diff: +128 25% l 9 cached: 102 65280; id 21
+// c22 => s: 768 diff: +128 20% l 9 cached: 85 65280; id 22
+// c23 => s: 896 diff: +128 16% l 9 cached: 73 65408; id 23
+//
+// c24 => s: 1024 diff: +128 14% l 10 cached: 64 65536; id 24
+// c25 => s: 1280 diff: +256 25% l 10 cached: 51 65280; id 25
+// c26 => s: 1536 diff: +256 20% l 10 cached: 42 64512; id 26
+// c27 => s: 1792 diff: +256 16% l 10 cached: 36 64512; id 27
+//
+// ...
+//
+// c48 => s: 65536 diff: +8192 14% l 16 cached: 1 65536; id 48
+// c49 => s: 81920 diff: +16384 25% l 16 cached: 1 81920; id 49
+// c50 => s: 98304 diff: +16384 20% l 16 cached: 1 98304; id 50
+// c51 => s: 114688 diff: +16384 16% l 16 cached: 1 114688; id 51
+//
+// c52 => s: 131072 diff: +16384 14% l 17 cached: 1 131072; id 52
+
+template <uptr kMaxSizeLog, uptr kMaxNumCachedT, uptr kMaxBytesCachedLog>
+class SizeClassMap {
+  static const uptr kMinSizeLog = 4;
+  static const uptr kMidSizeLog = kMinSizeLog + 4;
+  static const uptr kMinSize = 1 << kMinSizeLog;
+  static const uptr kMidSize = 1 << kMidSizeLog;
+  static const uptr kMidClass = kMidSize / kMinSize;
+  static const uptr S = 2;
+  static const uptr M = (1 << S) - 1;
+
+ public:
+  static const uptr kMaxNumCached = kMaxNumCachedT;
+  // We transfer chunks between central and thread-local free lists in batches.
+  // For small size classes we allocate batches separately.
+  // For large size classes we use one of the chunks to store the batch.
+  struct TransferBatch {
+    TransferBatch *next;
+    uptr count;
+    void *batch[kMaxNumCached];
+  };
+
+  static const uptr kMaxSize = 1UL << kMaxSizeLog;
+  static const uptr kNumClasses =
+      kMidClass + ((kMaxSizeLog - kMidSizeLog) << S) + 1;
+  COMPILER_CHECK(kNumClasses >= 32 && kNumClasses <= 256);
+  static const uptr kNumClassesRounded =
+      kNumClasses == 32  ? 32 :
+      kNumClasses <= 64  ? 64 :
+      kNumClasses <= 128 ? 128 : 256;
+
+  static uptr Size(uptr class_id) {
+    if (class_id <= kMidClass)
+      return kMinSize * class_id;
+    class_id -= kMidClass;
+    uptr t = kMidSize << (class_id >> S);
+    return t + (t >> S) * (class_id & M);
+  }
+
+  static uptr ClassID(uptr size) {
+    if (size <= kMidSize)
+      return (size + kMinSize - 1) >> kMinSizeLog;
+    if (size > kMaxSize) return 0;
+    uptr l = MostSignificantSetBitIndex(size);
+    uptr hbits = (size >> (l - S)) & M;
+    uptr lbits = size & ((1 << (l - S)) - 1);
+    uptr l1 = l - kMidSizeLog;
+    return kMidClass + (l1 << S) + hbits + (lbits > 0);
+  }
+
+  static uptr MaxCached(uptr class_id) {
+    if (class_id == 0) return 0;
+    uptr n = (1UL << kMaxBytesCachedLog) / Size(class_id);
+    return Max<uptr>(1, Min(kMaxNumCached, n));
+  }
+
+  static void Print() {
+    uptr prev_s = 0;
+    uptr total_cached = 0;
+    for (uptr i = 0; i < kNumClasses; i++) {
+      uptr s = Size(i);
+      if (s >= kMidSize / 2 && (s & (s - 1)) == 0)
+        Printf("\n");
+      uptr d = s - prev_s;
+      uptr p = prev_s ? (d * 100 / prev_s) : 0;
+      uptr l = s ? MostSignificantSetBitIndex(s) : 0;
+      uptr cached = MaxCached(i) * s;
+      Printf("c%02zd => s: %zd diff: +%zd %02zd%% l %zd "
+             "cached: %zd %zd; id %zd\n",
+             i, Size(i), d, p, l, MaxCached(i), cached, ClassID(s));
+      total_cached += cached;
+      prev_s = s;
+    }
+    Printf("Total cached: %zd\n", total_cached);
+  }
+
+  static bool SizeClassRequiresSeparateTransferBatch(uptr class_id) {
+    return Size(class_id) < sizeof(TransferBatch) -
+        sizeof(uptr) * (kMaxNumCached - MaxCached(class_id));
+  }
+
+  static void Validate() {
+    for (uptr c = 1; c < kNumClasses; c++) {
+      // Printf("Validate: c%zd\n", c);
+      uptr s = Size(c);
+      CHECK_NE(s, 0U);
+      CHECK_EQ(ClassID(s), c);
+      if (c != kNumClasses - 1)
+        CHECK_EQ(ClassID(s + 1), c + 1);
+      CHECK_EQ(ClassID(s - 1), c);
+      if (c)
+        CHECK_GT(Size(c), Size(c-1));
+    }
+    CHECK_EQ(ClassID(kMaxSize + 1), 0);
+
+    for (uptr s = 1; s <= kMaxSize; s++) {
+      uptr c = ClassID(s);
+      // Printf("s%zd => c%zd\n", s, c);
+      CHECK_LT(c, kNumClasses);
+      CHECK_GE(Size(c), s);
+      if (c > 0)
+        CHECK_LT(Size(c-1), s);
+    }
+  }
+};
+
+typedef SizeClassMap<17, 128, 16> DefaultSizeClassMap;
+typedef SizeClassMap<17, 64,  14> CompactSizeClassMap;
+template<class SizeClassAllocator> struct SizeClassAllocatorLocalCache;
+
+// Memory allocator statistics
+enum AllocatorStat {
+  AllocatorStatAllocated,
+  AllocatorStatMapped,
+  AllocatorStatCount
+};
+
+typedef uptr AllocatorStatCounters[AllocatorStatCount];
+
+// Per-thread stats, live in per-thread cache.
+class AllocatorStats {
+ public:
+  void Init() {
+    internal_memset(this, 0, sizeof(*this));
+  }
+  void InitLinkerInitialized() {}
+
+  void Add(AllocatorStat i, uptr v) {
+    v += atomic_load(&stats_[i], memory_order_relaxed);
+    atomic_store(&stats_[i], v, memory_order_relaxed);
+  }
+
+  void Sub(AllocatorStat i, uptr v) {
+    v = atomic_load(&stats_[i], memory_order_relaxed) - v;
+    atomic_store(&stats_[i], v, memory_order_relaxed);
+  }
+
+  void Set(AllocatorStat i, uptr v) {
+    atomic_store(&stats_[i], v, memory_order_relaxed);
+  }
+
+  uptr Get(AllocatorStat i) const {
+    return atomic_load(&stats_[i], memory_order_relaxed);
+  }
+
+ private:
+  friend class AllocatorGlobalStats;
+  AllocatorStats *next_;
+  AllocatorStats *prev_;
+  atomic_uintptr_t stats_[AllocatorStatCount];
+};
+
+// Global stats, used for aggregation and querying.
+class AllocatorGlobalStats : public AllocatorStats {
+ public:
+  void InitLinkerInitialized() {
+    next_ = this;
+    prev_ = this;
+  }
+  void Init() {
+    internal_memset(this, 0, sizeof(*this));
+    InitLinkerInitialized();
+  }
+
+  void Register(AllocatorStats *s) {
+    SpinMutexLock l(&mu_);
+    s->next_ = next_;
+    s->prev_ = this;
+    next_->prev_ = s;
+    next_ = s;
+  }
+
+  void Unregister(AllocatorStats *s) {
+    SpinMutexLock l(&mu_);
+    s->prev_->next_ = s->next_;
+    s->next_->prev_ = s->prev_;
+    for (int i = 0; i < AllocatorStatCount; i++)
+      Add(AllocatorStat(i), s->Get(AllocatorStat(i)));
+  }
+
+  void Get(AllocatorStatCounters s) const {
+    internal_memset(s, 0, AllocatorStatCount * sizeof(uptr));
+    SpinMutexLock l(&mu_);
+    const AllocatorStats *stats = this;
+    for (;;) {
+      for (int i = 0; i < AllocatorStatCount; i++)
+        s[i] += stats->Get(AllocatorStat(i));
+      stats = stats->next_;
+      if (stats == this)
+        break;
+    }
+    // All stats must be non-negative.
+    for (int i = 0; i < AllocatorStatCount; i++)
+      s[i] = ((sptr)s[i]) >= 0 ? s[i] : 0;
+  }
+
+ private:
+  mutable SpinMutex mu_;
+};
+
+// Allocators call these callbacks on mmap/munmap.
+struct NoOpMapUnmapCallback {
+  void OnMap(uptr p, uptr size) const { }
+  void OnUnmap(uptr p, uptr size) const { }
+};
+
+// Callback type for iterating over chunks.
+typedef void (*ForEachChunkCallback)(uptr chunk, void *arg);
+
+// SizeClassAllocator64 -- allocator for 64-bit address space.
+//
+// Space: a portion of address space of kSpaceSize bytes starting at
+// a fixed address (kSpaceBeg). Both constants are powers of two and
+// kSpaceBeg is kSpaceSize-aligned.
+// At the beginning the entire space is mprotect-ed, then small parts of it
+// are mapped on demand.
+//
+// Region: a part of Space dedicated to a single size class.
+// There are kNumClasses Regions of equal size.
+//
+// UserChunk: a piece of memory returned to user.
+// MetaChunk: kMetadataSize bytes of metadata associated with a UserChunk.
+//
+// A Region looks like this:
+// UserChunk1 ... UserChunkN <gap> MetaChunkN ... MetaChunk1
+template <const uptr kSpaceBeg, const uptr kSpaceSize,
+          const uptr kMetadataSize, class SizeClassMap,
+          class MapUnmapCallback = NoOpMapUnmapCallback>
+class SizeClassAllocator64 {
+ public:
+  typedef typename SizeClassMap::TransferBatch Batch;
+  typedef SizeClassAllocator64<kSpaceBeg, kSpaceSize, kMetadataSize,
+      SizeClassMap, MapUnmapCallback> ThisT;
+  typedef SizeClassAllocatorLocalCache<ThisT> AllocatorCache;
+
+  void Init() {
+    CHECK_EQ(kSpaceBeg,
+             reinterpret_cast<uptr>(MmapNoAccess(kSpaceBeg, kSpaceSize)));
+    MapWithCallback(kSpaceEnd, AdditionalSize());
+  }
+
+  void MapWithCallback(uptr beg, uptr size) {
+    CHECK_EQ(beg, reinterpret_cast<uptr>(MmapFixedOrDie(beg, size)));
+    MapUnmapCallback().OnMap(beg, size);
+  }
+
+  void UnmapWithCallback(uptr beg, uptr size) {
+    MapUnmapCallback().OnUnmap(beg, size);
+    UnmapOrDie(reinterpret_cast<void *>(beg), size);
+  }
+
+  static bool CanAllocate(uptr size, uptr alignment) {
+    return size <= SizeClassMap::kMaxSize &&
+      alignment <= SizeClassMap::kMaxSize;
+  }
+
+  NOINLINE Batch* AllocateBatch(AllocatorStats *stat, AllocatorCache *c,
+                                uptr class_id) {
+    CHECK_LT(class_id, kNumClasses);
+    RegionInfo *region = GetRegionInfo(class_id);
+    Batch *b = region->free_list.Pop();
+    if (!b)
+      b = PopulateFreeList(stat, c, class_id, region);
+    region->n_allocated += b->count;
+    return b;
+  }
+
+  NOINLINE void DeallocateBatch(AllocatorStats *stat, uptr class_id, Batch *b) {
+    RegionInfo *region = GetRegionInfo(class_id);
+    CHECK_GT(b->count, 0);
+    region->free_list.Push(b);
+    region->n_freed += b->count;
+  }
+
+  static bool PointerIsMine(const void *p) {
+    return reinterpret_cast<uptr>(p) / kSpaceSize == kSpaceBeg / kSpaceSize;
+  }
+
+  static uptr GetSizeClass(const void *p) {
+    return (reinterpret_cast<uptr>(p) / kRegionSize) % kNumClassesRounded;
+  }
+
+  void *GetBlockBegin(const void *p) {
+    uptr class_id = GetSizeClass(p);
+    uptr size = SizeClassMap::Size(class_id);
+    if (!size) return nullptr;
+    uptr chunk_idx = GetChunkIdx((uptr)p, size);
+    uptr reg_beg = (uptr)p & ~(kRegionSize - 1);
+    uptr beg = chunk_idx * size;
+    uptr next_beg = beg + size;
+    if (class_id >= kNumClasses) return nullptr;
+    RegionInfo *region = GetRegionInfo(class_id);
+    if (region->mapped_user >= next_beg)
+      return reinterpret_cast<void*>(reg_beg + beg);
+    return nullptr;
+  }
+
+  static uptr GetActuallyAllocatedSize(void *p) {
+    CHECK(PointerIsMine(p));
+    return SizeClassMap::Size(GetSizeClass(p));
+  }
+
+  uptr ClassID(uptr size) { return SizeClassMap::ClassID(size); }
+
+  void *GetMetaData(const void *p) {
+    uptr class_id = GetSizeClass(p);
+    uptr size = SizeClassMap::Size(class_id);
+    uptr chunk_idx = GetChunkIdx(reinterpret_cast<uptr>(p), size);
+    return reinterpret_cast<void*>(kSpaceBeg + (kRegionSize * (class_id + 1)) -
+                                   (1 + chunk_idx) * kMetadataSize);
+  }
+
+  uptr TotalMemoryUsed() {
+    uptr res = 0;
+    for (uptr i = 0; i < kNumClasses; i++)
+      res += GetRegionInfo(i)->allocated_user;
+    return res;
+  }
+
+  // Test-only.
+  void TestOnlyUnmap() {
+    UnmapWithCallback(kSpaceBeg, kSpaceSize + AdditionalSize());
+  }
+
+  void PrintStats() {
+    uptr total_mapped = 0;
+    uptr n_allocated = 0;
+    uptr n_freed = 0;
+    for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
+      RegionInfo *region = GetRegionInfo(class_id);
+      total_mapped += region->mapped_user;
+      n_allocated += region->n_allocated;
+      n_freed += region->n_freed;
+    }
+    Printf("Stats: SizeClassAllocator64: %zdM mapped in %zd allocations; "
+           "remains %zd\n",
+           total_mapped >> 20, n_allocated, n_allocated - n_freed);
+    for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
+      RegionInfo *region = GetRegionInfo(class_id);
+      if (region->mapped_user == 0) continue;
+      Printf("  %02zd (%zd): total: %zd K allocs: %zd remains: %zd\n",
+             class_id,
+             SizeClassMap::Size(class_id),
+             region->mapped_user >> 10,
+             region->n_allocated,
+             region->n_allocated - region->n_freed);
+    }
+  }
+
+  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
+  // introspection API.
+  void ForceLock() {
+    for (uptr i = 0; i < kNumClasses; i++) {
+      GetRegionInfo(i)->mutex.Lock();
+    }
+  }
+
+  void ForceUnlock() {
+    for (int i = (int)kNumClasses - 1; i >= 0; i--) {
+      GetRegionInfo(i)->mutex.Unlock();
+    }
+  }
+
+  // Iterate over all existing chunks.
+  // The allocator must be locked when calling this function.
+  void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+    for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
+      RegionInfo *region = GetRegionInfo(class_id);
+      uptr chunk_size = SizeClassMap::Size(class_id);
+      uptr region_beg = kSpaceBeg + class_id * kRegionSize;
+      for (uptr chunk = region_beg;
+           chunk < region_beg + region->allocated_user;
+           chunk += chunk_size) {
+        // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
+        callback(chunk, arg);
+      }
+    }
+  }
+
+  static uptr AdditionalSize() {
+    return RoundUpTo(sizeof(RegionInfo) * kNumClassesRounded,
+                     GetPageSizeCached());
+  }
+
+  typedef SizeClassMap SizeClassMapT;
+  static const uptr kNumClasses = SizeClassMap::kNumClasses;
+  static const uptr kNumClassesRounded = SizeClassMap::kNumClassesRounded;
+
+ private:
+  static const uptr kRegionSize = kSpaceSize / kNumClassesRounded;
+  static const uptr kSpaceEnd = kSpaceBeg + kSpaceSize;
+  COMPILER_CHECK(kSpaceBeg % kSpaceSize == 0);
+  // kRegionSize must be >= 2^32.
+  COMPILER_CHECK((kRegionSize) >= (1ULL << (SANITIZER_WORDSIZE / 2)));
+  // Populate the free list with at most this number of bytes at once
+  // or with one element if its size is greater.
+  static const uptr kPopulateSize = 1 << 14;
+  // Call mmap for user memory with at least this size.
+  static const uptr kUserMapSize = 1 << 16;
+  // Call mmap for metadata memory with at least this size.
+  static const uptr kMetaMapSize = 1 << 16;
+
+  struct RegionInfo {
+    BlockingMutex mutex;
+    LFStack<Batch> free_list;
+    uptr allocated_user;  // Bytes allocated for user memory.
+    uptr allocated_meta;  // Bytes allocated for metadata.
+    uptr mapped_user;  // Bytes mapped for user memory.
+    uptr mapped_meta;  // Bytes mapped for metadata.
+    uptr n_allocated, n_freed;  // Just stats.
+  };
+  COMPILER_CHECK(sizeof(RegionInfo) >= kCacheLineSize);
+
+  RegionInfo *GetRegionInfo(uptr class_id) {
+    CHECK_LT(class_id, kNumClasses);
+    RegionInfo *regions = reinterpret_cast<RegionInfo*>(kSpaceBeg + kSpaceSize);
+    return &regions[class_id];
+  }
+
+  static uptr GetChunkIdx(uptr chunk, uptr size) {
+    uptr offset = chunk % kRegionSize;
+    // Here we divide by a non-constant. This is costly.
+    // size always fits into 32-bits. If the offset fits too, use 32-bit div.
+    if (offset >> (SANITIZER_WORDSIZE / 2))
+      return offset / size;
+    return (u32)offset / (u32)size;
+  }
+
+  NOINLINE Batch* PopulateFreeList(AllocatorStats *stat, AllocatorCache *c,
+                                   uptr class_id, RegionInfo *region) {
+    BlockingMutexLock l(&region->mutex);
+    Batch *b = region->free_list.Pop();
+    if (b)
+      return b;
+    uptr size = SizeClassMap::Size(class_id);
+    uptr count = size < kPopulateSize ? SizeClassMap::MaxCached(class_id) : 1;
+    uptr beg_idx = region->allocated_user;
+    uptr end_idx = beg_idx + count * size;
+    uptr region_beg = kSpaceBeg + kRegionSize * class_id;
+    if (end_idx + size > region->mapped_user) {
+      // Do the mmap for the user memory.
+      uptr map_size = kUserMapSize;
+      while (end_idx + size > region->mapped_user + map_size)
+        map_size += kUserMapSize;
+      CHECK_GE(region->mapped_user + map_size, end_idx);
+      MapWithCallback(region_beg + region->mapped_user, map_size);
+      stat->Add(AllocatorStatMapped, map_size);
+      region->mapped_user += map_size;
+    }
+    uptr total_count = (region->mapped_user - beg_idx - size)
+        / size / count * count;
+    region->allocated_meta += total_count * kMetadataSize;
+    if (region->allocated_meta > region->mapped_meta) {
+      uptr map_size = kMetaMapSize;
+      while (region->allocated_meta > region->mapped_meta + map_size)
+        map_size += kMetaMapSize;
+      // Do the mmap for the metadata.
+      CHECK_GE(region->mapped_meta + map_size, region->allocated_meta);
+      MapWithCallback(region_beg + kRegionSize -
+                      region->mapped_meta - map_size, map_size);
+      region->mapped_meta += map_size;
+    }
+    CHECK_LE(region->allocated_meta, region->mapped_meta);
+    if (region->mapped_user + region->mapped_meta > kRegionSize) {
+      Printf("%s: Out of memory. Dying. ", SanitizerToolName);
+      Printf("The process has exhausted %zuMB for size class %zu.\n",
+          kRegionSize / 1024 / 1024, size);
+      Die();
+    }
+    for (;;) {
+      if (SizeClassMap::SizeClassRequiresSeparateTransferBatch(class_id))
+        b = (Batch*)c->Allocate(this, SizeClassMap::ClassID(sizeof(Batch)));
+      else
+        b = (Batch*)(region_beg + beg_idx);
+      b->count = count;
+      for (uptr i = 0; i < count; i++)
+        b->batch[i] = (void*)(region_beg + beg_idx + i * size);
+      region->allocated_user += count * size;
+      CHECK_LE(region->allocated_user, region->mapped_user);
+      beg_idx += count * size;
+      if (beg_idx + count * size + size > region->mapped_user)
+        break;
+      CHECK_GT(b->count, 0);
+      region->free_list.Push(b);
+    }
+    return b;
+  }
+};
+
+// Maps integers in rage [0, kSize) to u8 values.
+template<u64 kSize>
+class FlatByteMap {
+ public:
+  void TestOnlyInit() {
+    internal_memset(map_, 0, sizeof(map_));
+  }
+
+  void set(uptr idx, u8 val) {
+    CHECK_LT(idx, kSize);
+    CHECK_EQ(0U, map_[idx]);
+    map_[idx] = val;
+  }
+  u8 operator[] (uptr idx) {
+    CHECK_LT(idx, kSize);
+    // FIXME: CHECK may be too expensive here.
+    return map_[idx];
+  }
+ private:
+  u8 map_[kSize];
+};
+
+// TwoLevelByteMap maps integers in range [0, kSize1*kSize2) to u8 values.
+// It is implemented as a two-dimensional array: array of kSize1 pointers
+// to kSize2-byte arrays. The secondary arrays are mmaped on demand.
+// Each value is initially zero and can be set to something else only once.
+// Setting and getting values from multiple threads is safe w/o extra locking.
+template <u64 kSize1, u64 kSize2, class MapUnmapCallback = NoOpMapUnmapCallback>
+class TwoLevelByteMap {
+ public:
+  void TestOnlyInit() {
+    internal_memset(map1_, 0, sizeof(map1_));
+    mu_.Init();
+  }
+
+  void TestOnlyUnmap() {
+    for (uptr i = 0; i < kSize1; i++) {
+      u8 *p = Get(i);
+      if (!p) continue;
+      MapUnmapCallback().OnUnmap(reinterpret_cast<uptr>(p), kSize2);
+      UnmapOrDie(p, kSize2);
+    }
+  }
+
+  uptr size() const { return kSize1 * kSize2; }
+  uptr size1() const { return kSize1; }
+  uptr size2() const { return kSize2; }
+
+  void set(uptr idx, u8 val) {
+    CHECK_LT(idx, kSize1 * kSize2);
+    u8 *map2 = GetOrCreate(idx / kSize2);
+    CHECK_EQ(0U, map2[idx % kSize2]);
+    map2[idx % kSize2] = val;
+  }
+
+  u8 operator[] (uptr idx) const {
+    CHECK_LT(idx, kSize1 * kSize2);
+    u8 *map2 = Get(idx / kSize2);
+    if (!map2) return 0;
+    return map2[idx % kSize2];
+  }
+
+ private:
+  u8 *Get(uptr idx) const {
+    CHECK_LT(idx, kSize1);
+    return reinterpret_cast<u8 *>(
+        atomic_load(&map1_[idx], memory_order_acquire));
+  }
+
+  u8 *GetOrCreate(uptr idx) {
+    u8 *res = Get(idx);
+    if (!res) {
+      SpinMutexLock l(&mu_);
+      if (!(res = Get(idx))) {
+        res = (u8*)MmapOrDie(kSize2, "TwoLevelByteMap");
+        MapUnmapCallback().OnMap(reinterpret_cast<uptr>(res), kSize2);
+        atomic_store(&map1_[idx], reinterpret_cast<uptr>(res),
+                     memory_order_release);
+      }
+    }
+    return res;
+  }
+
+  atomic_uintptr_t map1_[kSize1];
+  StaticSpinMutex mu_;
+};
+
+// SizeClassAllocator32 -- allocator for 32-bit address space.
+// This allocator can theoretically be used on 64-bit arch, but there it is less
+// efficient than SizeClassAllocator64.
+//
+// [kSpaceBeg, kSpaceBeg + kSpaceSize) is the range of addresses which can
+// be returned by MmapOrDie().
+//
+// Region:
+//   a result of a single call to MmapAlignedOrDie(kRegionSize, kRegionSize).
+// Since the regions are aligned by kRegionSize, there are exactly
+// kNumPossibleRegions possible regions in the address space and so we keep
+// a ByteMap possible_regions to store the size classes of each Region.
+// 0 size class means the region is not used by the allocator.
+//
+// One Region is used to allocate chunks of a single size class.
+// A Region looks like this:
+// UserChunk1 .. UserChunkN <gap> MetaChunkN .. MetaChunk1
+//
+// In order to avoid false sharing the objects of this class should be
+// chache-line aligned.
+template <const uptr kSpaceBeg, const u64 kSpaceSize,
+          const uptr kMetadataSize, class SizeClassMap,
+          const uptr kRegionSizeLog,
+          class ByteMap,
+          class MapUnmapCallback = NoOpMapUnmapCallback>
+class SizeClassAllocator32 {
+ public:
+  typedef typename SizeClassMap::TransferBatch Batch;
+  typedef SizeClassAllocator32<kSpaceBeg, kSpaceSize, kMetadataSize,
+      SizeClassMap, kRegionSizeLog, ByteMap, MapUnmapCallback> ThisT;
+  typedef SizeClassAllocatorLocalCache<ThisT> AllocatorCache;
+
+  void Init() {
+    possible_regions.TestOnlyInit();
+    internal_memset(size_class_info_array, 0, sizeof(size_class_info_array));
+  }
+
+  void *MapWithCallback(uptr size) {
+    size = RoundUpTo(size, GetPageSizeCached());
+    void *res = MmapOrDie(size, "SizeClassAllocator32");
+    MapUnmapCallback().OnMap((uptr)res, size);
+    return res;
+  }
+
+  void UnmapWithCallback(uptr beg, uptr size) {
+    MapUnmapCallback().OnUnmap(beg, size);
+    UnmapOrDie(reinterpret_cast<void *>(beg), size);
+  }
+
+  static bool CanAllocate(uptr size, uptr alignment) {
+    return size <= SizeClassMap::kMaxSize &&
+      alignment <= SizeClassMap::kMaxSize;
+  }
+
+  void *GetMetaData(const void *p) {
+    CHECK(PointerIsMine(p));
+    uptr mem = reinterpret_cast<uptr>(p);
+    uptr beg = ComputeRegionBeg(mem);
+    uptr size = SizeClassMap::Size(GetSizeClass(p));
+    u32 offset = mem - beg;
+    uptr n = offset / (u32)size;  // 32-bit division
+    uptr meta = (beg + kRegionSize) - (n + 1) * kMetadataSize;
+    return reinterpret_cast<void*>(meta);
+  }
+
+  NOINLINE Batch* AllocateBatch(AllocatorStats *stat, AllocatorCache *c,
+                                uptr class_id) {
+    CHECK_LT(class_id, kNumClasses);
+    SizeClassInfo *sci = GetSizeClassInfo(class_id);
+    SpinMutexLock l(&sci->mutex);
+    if (sci->free_list.empty())
+      PopulateFreeList(stat, c, sci, class_id);
+    CHECK(!sci->free_list.empty());
+    Batch *b = sci->free_list.front();
+    sci->free_list.pop_front();
+    return b;
+  }
+
+  NOINLINE void DeallocateBatch(AllocatorStats *stat, uptr class_id, Batch *b) {
+    CHECK_LT(class_id, kNumClasses);
+    SizeClassInfo *sci = GetSizeClassInfo(class_id);
+    SpinMutexLock l(&sci->mutex);
+    CHECK_GT(b->count, 0);
+    sci->free_list.push_front(b);
+  }
+
+  bool PointerIsMine(const void *p) {
+    return GetSizeClass(p) != 0;
+  }
+
+  uptr GetSizeClass(const void *p) {
+    return possible_regions[ComputeRegionId(reinterpret_cast<uptr>(p))];
+  }
+
+  void *GetBlockBegin(const void *p) {
+    CHECK(PointerIsMine(p));
+    uptr mem = reinterpret_cast<uptr>(p);
+    uptr beg = ComputeRegionBeg(mem);
+    uptr size = SizeClassMap::Size(GetSizeClass(p));
+    u32 offset = mem - beg;
+    u32 n = offset / (u32)size;  // 32-bit division
+    uptr res = beg + (n * (u32)size);
+    return reinterpret_cast<void*>(res);
+  }
+
+  uptr GetActuallyAllocatedSize(void *p) {
+    CHECK(PointerIsMine(p));
+    return SizeClassMap::Size(GetSizeClass(p));
+  }
+
+  uptr ClassID(uptr size) { return SizeClassMap::ClassID(size); }
+
+  uptr TotalMemoryUsed() {
+    // No need to lock here.
+    uptr res = 0;
+    for (uptr i = 0; i < kNumPossibleRegions; i++)
+      if (possible_regions[i])
+        res += kRegionSize;
+    return res;
+  }
+
+  void TestOnlyUnmap() {
+    for (uptr i = 0; i < kNumPossibleRegions; i++)
+      if (possible_regions[i])
+        UnmapWithCallback((i * kRegionSize), kRegionSize);
+  }
+
+  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
+  // introspection API.
+  void ForceLock() {
+    for (uptr i = 0; i < kNumClasses; i++) {
+      GetSizeClassInfo(i)->mutex.Lock();
+    }
+  }
+
+  void ForceUnlock() {
+    for (int i = kNumClasses - 1; i >= 0; i--) {
+      GetSizeClassInfo(i)->mutex.Unlock();
+    }
+  }
+
+  // Iterate over all existing chunks.
+  // The allocator must be locked when calling this function.
+  void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+    for (uptr region = 0; region < kNumPossibleRegions; region++)
+      if (possible_regions[region]) {
+        uptr chunk_size = SizeClassMap::Size(possible_regions[region]);
+        uptr max_chunks_in_region = kRegionSize / (chunk_size + kMetadataSize);
+        uptr region_beg = region * kRegionSize;
+        for (uptr chunk = region_beg;
+             chunk < region_beg + max_chunks_in_region * chunk_size;
+             chunk += chunk_size) {
+          // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
+          callback(chunk, arg);
+        }
+      }
+  }
+
+  void PrintStats() {
+  }
+
+  static uptr AdditionalSize() {
+    return 0;
+  }
+
+  typedef SizeClassMap SizeClassMapT;
+  static const uptr kNumClasses = SizeClassMap::kNumClasses;
+
+ private:
+  static const uptr kRegionSize = 1 << kRegionSizeLog;
+  static const uptr kNumPossibleRegions = kSpaceSize / kRegionSize;
+
+  struct SizeClassInfo {
+    SpinMutex mutex;
+    IntrusiveList<Batch> free_list;
+    char padding[kCacheLineSize - sizeof(uptr) - sizeof(IntrusiveList<Batch>)];
+  };
+  COMPILER_CHECK(sizeof(SizeClassInfo) == kCacheLineSize);
+
+  uptr ComputeRegionId(uptr mem) {
+    uptr res = mem >> kRegionSizeLog;
+    CHECK_LT(res, kNumPossibleRegions);
+    return res;
+  }
+
+  uptr ComputeRegionBeg(uptr mem) {
+    return mem & ~(kRegionSize - 1);
+  }
+
+  uptr AllocateRegion(AllocatorStats *stat, uptr class_id) {
+    CHECK_LT(class_id, kNumClasses);
+    uptr res = reinterpret_cast<uptr>(MmapAlignedOrDie(kRegionSize, kRegionSize,
+                                      "SizeClassAllocator32"));
+    MapUnmapCallback().OnMap(res, kRegionSize);
+    stat->Add(AllocatorStatMapped, kRegionSize);
+    CHECK_EQ(0U, (res & (kRegionSize - 1)));
+    possible_regions.set(ComputeRegionId(res), static_cast<u8>(class_id));
+    return res;
+  }
+
+  SizeClassInfo *GetSizeClassInfo(uptr class_id) {
+    CHECK_LT(class_id, kNumClasses);
+    return &size_class_info_array[class_id];
+  }
+
+  void PopulateFreeList(AllocatorStats *stat, AllocatorCache *c,
+                        SizeClassInfo *sci, uptr class_id) {
+    uptr size = SizeClassMap::Size(class_id);
+    uptr reg = AllocateRegion(stat, class_id);
+    uptr n_chunks = kRegionSize / (size + kMetadataSize);
+    uptr max_count = SizeClassMap::MaxCached(class_id);
+    Batch *b = nullptr;
+    for (uptr i = reg; i < reg + n_chunks * size; i += size) {
+      if (!b) {
+        if (SizeClassMap::SizeClassRequiresSeparateTransferBatch(class_id))
+          b = (Batch*)c->Allocate(this, SizeClassMap::ClassID(sizeof(Batch)));
+        else
+          b = (Batch*)i;
+        b->count = 0;
+      }
+      b->batch[b->count++] = (void*)i;
+      if (b->count == max_count) {
+        CHECK_GT(b->count, 0);
+        sci->free_list.push_back(b);
+        b = nullptr;
+      }
+    }
+    if (b) {
+      CHECK_GT(b->count, 0);
+      sci->free_list.push_back(b);
+    }
+  }
+
+  ByteMap possible_regions;
+  SizeClassInfo size_class_info_array[kNumClasses];
+};
+
+// Objects of this type should be used as local caches for SizeClassAllocator64
+// or SizeClassAllocator32. Since the typical use of this class is to have one
+// object per thread in TLS, is has to be POD.
+template<class SizeClassAllocator>
+struct SizeClassAllocatorLocalCache {
+  typedef SizeClassAllocator Allocator;
+  static const uptr kNumClasses = SizeClassAllocator::kNumClasses;
+
+  void Init(AllocatorGlobalStats *s) {
+    stats_.Init();
+    if (s)
+      s->Register(&stats_);
+  }
+
+  void Destroy(SizeClassAllocator *allocator, AllocatorGlobalStats *s) {
+    Drain(allocator);
+    if (s)
+      s->Unregister(&stats_);
+  }
+
+  void *Allocate(SizeClassAllocator *allocator, uptr class_id) {
+    CHECK_NE(class_id, 0UL);
+    CHECK_LT(class_id, kNumClasses);
+    stats_.Add(AllocatorStatAllocated, SizeClassMap::Size(class_id));
+    PerClass *c = &per_class_[class_id];
+    if (UNLIKELY(c->count == 0))
+      Refill(allocator, class_id);
+    void *res = c->batch[--c->count];
+    PREFETCH(c->batch[c->count - 1]);
+    return res;
+  }
+
+  void Deallocate(SizeClassAllocator *allocator, uptr class_id, void *p) {
+    CHECK_NE(class_id, 0UL);
+    CHECK_LT(class_id, kNumClasses);
+    // If the first allocator call on a new thread is a deallocation, then
+    // max_count will be zero, leading to check failure.
+    InitCache();
+    stats_.Sub(AllocatorStatAllocated, SizeClassMap::Size(class_id));
+    PerClass *c = &per_class_[class_id];
+    CHECK_NE(c->max_count, 0UL);
+    if (UNLIKELY(c->count == c->max_count))
+      Drain(allocator, class_id);
+    c->batch[c->count++] = p;
+  }
+
+  void Drain(SizeClassAllocator *allocator) {
+    for (uptr class_id = 0; class_id < kNumClasses; class_id++) {
+      PerClass *c = &per_class_[class_id];
+      while (c->count > 0)
+        Drain(allocator, class_id);
+    }
+  }
+
+  // private:
+  typedef typename SizeClassAllocator::SizeClassMapT SizeClassMap;
+  typedef typename SizeClassMap::TransferBatch Batch;
+  struct PerClass {
+    uptr count;
+    uptr max_count;
+    void *batch[2 * SizeClassMap::kMaxNumCached];
+  };
+  PerClass per_class_[kNumClasses];
+  AllocatorStats stats_;
+
+  void InitCache() {
+    if (per_class_[1].max_count)
+      return;
+    for (uptr i = 0; i < kNumClasses; i++) {
+      PerClass *c = &per_class_[i];
+      c->max_count = 2 * SizeClassMap::MaxCached(i);
+    }
+  }
+
+  NOINLINE void Refill(SizeClassAllocator *allocator, uptr class_id) {
+    InitCache();
+    PerClass *c = &per_class_[class_id];
+    Batch *b = allocator->AllocateBatch(&stats_, this, class_id);
+    CHECK_GT(b->count, 0);
+    for (uptr i = 0; i < b->count; i++)
+      c->batch[i] = b->batch[i];
+    c->count = b->count;
+    if (SizeClassMap::SizeClassRequiresSeparateTransferBatch(class_id))
+      Deallocate(allocator, SizeClassMap::ClassID(sizeof(Batch)), b);
+  }
+
+  NOINLINE void Drain(SizeClassAllocator *allocator, uptr class_id) {
+    InitCache();
+    PerClass *c = &per_class_[class_id];
+    Batch *b;
+    if (SizeClassMap::SizeClassRequiresSeparateTransferBatch(class_id))
+      b = (Batch*)Allocate(allocator, SizeClassMap::ClassID(sizeof(Batch)));
+    else
+      b = (Batch*)c->batch[0];
+    uptr cnt = Min(c->max_count / 2, c->count);
+    for (uptr i = 0; i < cnt; i++) {
+      b->batch[i] = c->batch[i];
+      c->batch[i] = c->batch[i + c->max_count / 2];
+    }
+    b->count = cnt;
+    c->count -= cnt;
+    CHECK_GT(b->count, 0);
+    allocator->DeallocateBatch(&stats_, class_id, b);
+  }
+};
+
+// This class can (de)allocate only large chunks of memory using mmap/unmap.
+// The main purpose of this allocator is to cover large and rare allocation
+// sizes not covered by more efficient allocators (e.g. SizeClassAllocator64).
+template <class MapUnmapCallback = NoOpMapUnmapCallback>
+class LargeMmapAllocator {
+ public:
+  void InitLinkerInitialized(bool may_return_null) {
+    page_size_ = GetPageSizeCached();
+    atomic_store(&may_return_null_, may_return_null, memory_order_relaxed);
+  }
+
+  void Init(bool may_return_null) {
+    internal_memset(this, 0, sizeof(*this));
+    InitLinkerInitialized(may_return_null);
+  }
+
+  void *Allocate(AllocatorStats *stat, uptr size, uptr alignment) {
+    CHECK(IsPowerOfTwo(alignment));
+    uptr map_size = RoundUpMapSize(size);
+    if (alignment > page_size_)
+      map_size += alignment;
+    // Overflow.
+    if (map_size < size)
+      return ReturnNullOrDie();
+    uptr map_beg = reinterpret_cast<uptr>(
+        MmapOrDie(map_size, "LargeMmapAllocator"));
+    CHECK(IsAligned(map_beg, page_size_));
+    MapUnmapCallback().OnMap(map_beg, map_size);
+    uptr map_end = map_beg + map_size;
+    uptr res = map_beg + page_size_;
+    if (res & (alignment - 1))  // Align.
+      res += alignment - (res & (alignment - 1));
+    CHECK(IsAligned(res, alignment));
+    CHECK(IsAligned(res, page_size_));
+    CHECK_GE(res + size, map_beg);
+    CHECK_LE(res + size, map_end);
+    Header *h = GetHeader(res);
+    h->size = size;
+    h->map_beg = map_beg;
+    h->map_size = map_size;
+    uptr size_log = MostSignificantSetBitIndex(map_size);
+    CHECK_LT(size_log, ARRAY_SIZE(stats.by_size_log));
+    {
+      SpinMutexLock l(&mutex_);
+      uptr idx = n_chunks_++;
+      chunks_sorted_ = false;
+      CHECK_LT(idx, kMaxNumChunks);
+      h->chunk_idx = idx;
+      chunks_[idx] = h;
+      stats.n_allocs++;
+      stats.currently_allocated += map_size;
+      stats.max_allocated = Max(stats.max_allocated, stats.currently_allocated);
+      stats.by_size_log[size_log]++;
+      stat->Add(AllocatorStatAllocated, map_size);
+      stat->Add(AllocatorStatMapped, map_size);
+    }
+    return reinterpret_cast<void*>(res);
+  }
+
+  void *ReturnNullOrDie() {
+    if (atomic_load(&may_return_null_, memory_order_acquire))
+      return nullptr;
+    ReportAllocatorCannotReturnNull();
+  }
+
+  void SetMayReturnNull(bool may_return_null) {
+    atomic_store(&may_return_null_, may_return_null, memory_order_release);
+  }
+
+  void Deallocate(AllocatorStats *stat, void *p) {
+    Header *h = GetHeader(p);
+    {
+      SpinMutexLock l(&mutex_);
+      uptr idx = h->chunk_idx;
+      CHECK_EQ(chunks_[idx], h);
+      CHECK_LT(idx, n_chunks_);
+      chunks_[idx] = chunks_[n_chunks_ - 1];
+      chunks_[idx]->chunk_idx = idx;
+      n_chunks_--;
+      chunks_sorted_ = false;
+      stats.n_frees++;
+      stats.currently_allocated -= h->map_size;
+      stat->Sub(AllocatorStatAllocated, h->map_size);
+      stat->Sub(AllocatorStatMapped, h->map_size);
+    }
+    MapUnmapCallback().OnUnmap(h->map_beg, h->map_size);
+    UnmapOrDie(reinterpret_cast<void*>(h->map_beg), h->map_size);
+  }
+
+  uptr TotalMemoryUsed() {
+    SpinMutexLock l(&mutex_);
+    uptr res = 0;
+    for (uptr i = 0; i < n_chunks_; i++) {
+      Header *h = chunks_[i];
+      CHECK_EQ(h->chunk_idx, i);
+      res += RoundUpMapSize(h->size);
+    }
+    return res;
+  }
+
+  bool PointerIsMine(const void *p) {
+    return GetBlockBegin(p) != nullptr;
+  }
+
+  uptr GetActuallyAllocatedSize(void *p) {
+    return RoundUpTo(GetHeader(p)->size, page_size_);
+  }
+
+  // At least page_size_/2 metadata bytes is available.
+  void *GetMetaData(const void *p) {
+    // Too slow: CHECK_EQ(p, GetBlockBegin(p));
+    if (!IsAligned(reinterpret_cast<uptr>(p), page_size_)) {
+      Printf("%s: bad pointer %p\n", SanitizerToolName, p);
+      CHECK(IsAligned(reinterpret_cast<uptr>(p), page_size_));
+    }
+    return GetHeader(p) + 1;
+  }
+
+  void *GetBlockBegin(const void *ptr) {
+    uptr p = reinterpret_cast<uptr>(ptr);
+    SpinMutexLock l(&mutex_);
+    uptr nearest_chunk = 0;
+    // Cache-friendly linear search.
+    for (uptr i = 0; i < n_chunks_; i++) {
+      uptr ch = reinterpret_cast<uptr>(chunks_[i]);
+      if (p < ch) continue;  // p is at left to this chunk, skip it.
+      if (p - ch < p - nearest_chunk)
+        nearest_chunk = ch;
+    }
+    if (!nearest_chunk)
+      return nullptr;
+    Header *h = reinterpret_cast<Header *>(nearest_chunk);
+    CHECK_GE(nearest_chunk, h->map_beg);
+    CHECK_LT(nearest_chunk, h->map_beg + h->map_size);
+    CHECK_LE(nearest_chunk, p);
+    if (h->map_beg + h->map_size <= p)
+      return nullptr;
+    return GetUser(h);
+  }
+
+  // This function does the same as GetBlockBegin, but is much faster.
+  // Must be called with the allocator locked.
+  void *GetBlockBeginFastLocked(void *ptr) {
+    mutex_.CheckLocked();
+    uptr p = reinterpret_cast<uptr>(ptr);
+    uptr n = n_chunks_;
+    if (!n) return nullptr;
+    if (!chunks_sorted_) {
+      // Do one-time sort. chunks_sorted_ is reset in Allocate/Deallocate.
+      SortArray(reinterpret_cast<uptr*>(chunks_), n);
+      for (uptr i = 0; i < n; i++)
+        chunks_[i]->chunk_idx = i;
+      chunks_sorted_ = true;
+      min_mmap_ = reinterpret_cast<uptr>(chunks_[0]);
+      max_mmap_ = reinterpret_cast<uptr>(chunks_[n - 1]) +
+          chunks_[n - 1]->map_size;
+    }
+    if (p < min_mmap_ || p >= max_mmap_)
+      return nullptr;
+    uptr beg = 0, end = n - 1;
+    // This loop is a log(n) lower_bound. It does not check for the exact match
+    // to avoid expensive cache-thrashing loads.
+    while (end - beg >= 2) {
+      uptr mid = (beg + end) / 2;  // Invariant: mid >= beg + 1
+      if (p < reinterpret_cast<uptr>(chunks_[mid]))
+        end = mid - 1;  // We are not interested in chunks_[mid].
+      else
+        beg = mid;  // chunks_[mid] may still be what we want.
+    }
+
+    if (beg < end) {
+      CHECK_EQ(beg + 1, end);
+      // There are 2 chunks left, choose one.
+      if (p >= reinterpret_cast<uptr>(chunks_[end]))
+        beg = end;
+    }
+
+    Header *h = chunks_[beg];
+    if (h->map_beg + h->map_size <= p || p < h->map_beg)
+      return nullptr;
+    return GetUser(h);
+  }
+
+  void PrintStats() {
+    Printf("Stats: LargeMmapAllocator: allocated %zd times, "
+           "remains %zd (%zd K) max %zd M; by size logs: ",
+           stats.n_allocs, stats.n_allocs - stats.n_frees,
+           stats.currently_allocated >> 10, stats.max_allocated >> 20);
+    for (uptr i = 0; i < ARRAY_SIZE(stats.by_size_log); i++) {
+      uptr c = stats.by_size_log[i];
+      if (!c) continue;
+      Printf("%zd:%zd; ", i, c);
+    }
+    Printf("\n");
+  }
+
+  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
+  // introspection API.
+  void ForceLock() {
+    mutex_.Lock();
+  }
+
+  void ForceUnlock() {
+    mutex_.Unlock();
+  }
+
+  // Iterate over all existing chunks.
+  // The allocator must be locked when calling this function.
+  void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+    for (uptr i = 0; i < n_chunks_; i++)
+      callback(reinterpret_cast<uptr>(GetUser(chunks_[i])), arg);
+  }
+
+ private:
+  static const int kMaxNumChunks = 1 << FIRST_32_SECOND_64(15, 18);
+  struct Header {
+    uptr map_beg;
+    uptr map_size;
+    uptr size;
+    uptr chunk_idx;
+  };
+
+  Header *GetHeader(uptr p) {
+    CHECK(IsAligned(p, page_size_));
+    return reinterpret_cast<Header*>(p - page_size_);
+  }
+  Header *GetHeader(const void *p) {
+    return GetHeader(reinterpret_cast<uptr>(p));
+  }
+
+  void *GetUser(Header *h) {
+    CHECK(IsAligned((uptr)h, page_size_));
+    return reinterpret_cast<void*>(reinterpret_cast<uptr>(h) + page_size_);
+  }
+
+  uptr RoundUpMapSize(uptr size) {
+    return RoundUpTo(size, page_size_) + page_size_;
+  }
+
+  uptr page_size_;
+  Header *chunks_[kMaxNumChunks];
+  uptr n_chunks_;
+  uptr min_mmap_, max_mmap_;
+  bool chunks_sorted_;
+  struct Stats {
+    uptr n_allocs, n_frees, currently_allocated, max_allocated, by_size_log[64];
+  } stats;
+  atomic_uint8_t may_return_null_;
+  SpinMutex mutex_;
+};
+
+// This class implements a complete memory allocator by using two
+// internal allocators:
+// PrimaryAllocator is efficient, but may not allocate some sizes (alignments).
+//  When allocating 2^x bytes it should return 2^x aligned chunk.
+// PrimaryAllocator is used via a local AllocatorCache.
+// SecondaryAllocator can allocate anything, but is not efficient.
+template <class PrimaryAllocator, class AllocatorCache,
+          class SecondaryAllocator>  // NOLINT
+class CombinedAllocator {
+ public:
+  void InitCommon(bool may_return_null) {
+    primary_.Init();
+    atomic_store(&may_return_null_, may_return_null, memory_order_relaxed);
+  }
+
+  void InitLinkerInitialized(bool may_return_null) {
+    secondary_.InitLinkerInitialized(may_return_null);
+    stats_.InitLinkerInitialized();
+    InitCommon(may_return_null);
+  }
+
+  void Init(bool may_return_null) {
+    secondary_.Init(may_return_null);
+    stats_.Init();
+    InitCommon(may_return_null);
+  }
+
+  void *Allocate(AllocatorCache *cache, uptr size, uptr alignment,
+                 bool cleared = false, bool check_rss_limit = false) {
+    // Returning 0 on malloc(0) may break a lot of code.
+    if (size == 0)
+      size = 1;
+    if (size + alignment < size)
+      return ReturnNullOrDie();
+    if (check_rss_limit && RssLimitIsExceeded())
+      return ReturnNullOrDie();
+    if (alignment > 8)
+      size = RoundUpTo(size, alignment);
+    void *res;
+    bool from_primary = primary_.CanAllocate(size, alignment);
+    if (from_primary)
+      res = cache->Allocate(&primary_, primary_.ClassID(size));
+    else
+      res = secondary_.Allocate(&stats_, size, alignment);
+    if (alignment > 8)
+      CHECK_EQ(reinterpret_cast<uptr>(res) & (alignment - 1), 0);
+    if (cleared && res && from_primary)
+      internal_bzero_aligned16(res, RoundUpTo(size, 16));
+    return res;
+  }
+
+  bool MayReturnNull() const {
+    return atomic_load(&may_return_null_, memory_order_acquire);
+  }
+
+  void *ReturnNullOrDie() {
+    if (MayReturnNull())
+      return nullptr;
+    ReportAllocatorCannotReturnNull();
+  }
+
+  void SetMayReturnNull(bool may_return_null) {
+    secondary_.SetMayReturnNull(may_return_null);
+    atomic_store(&may_return_null_, may_return_null, memory_order_release);
+  }
+
+  bool RssLimitIsExceeded() {
+    return atomic_load(&rss_limit_is_exceeded_, memory_order_acquire);
+  }
+
+  void SetRssLimitIsExceeded(bool rss_limit_is_exceeded) {
+    atomic_store(&rss_limit_is_exceeded_, rss_limit_is_exceeded,
+                 memory_order_release);
+  }
+
+  void Deallocate(AllocatorCache *cache, void *p) {
+    if (!p) return;
+    if (primary_.PointerIsMine(p))
+      cache->Deallocate(&primary_, primary_.GetSizeClass(p), p);
+    else
+      secondary_.Deallocate(&stats_, p);
+  }
+
+  void *Reallocate(AllocatorCache *cache, void *p, uptr new_size,
+                   uptr alignment) {
+    if (!p)
+      return Allocate(cache, new_size, alignment);
+    if (!new_size) {
+      Deallocate(cache, p);
+      return nullptr;
+    }
+    CHECK(PointerIsMine(p));
+    uptr old_size = GetActuallyAllocatedSize(p);
+    uptr memcpy_size = Min(new_size, old_size);
+    void *new_p = Allocate(cache, new_size, alignment);
+    if (new_p)
+      internal_memcpy(new_p, p, memcpy_size);
+    Deallocate(cache, p);
+    return new_p;
+  }
+
+  bool PointerIsMine(void *p) {
+    if (primary_.PointerIsMine(p))
+      return true;
+    return secondary_.PointerIsMine(p);
+  }
+
+  bool FromPrimary(void *p) {
+    return primary_.PointerIsMine(p);
+  }
+
+  void *GetMetaData(const void *p) {
+    if (primary_.PointerIsMine(p))
+      return primary_.GetMetaData(p);
+    return secondary_.GetMetaData(p);
+  }
+
+  void *GetBlockBegin(const void *p) {
+    if (primary_.PointerIsMine(p))
+      return primary_.GetBlockBegin(p);
+    return secondary_.GetBlockBegin(p);
+  }
+
+  // This function does the same as GetBlockBegin, but is much faster.
+  // Must be called with the allocator locked.
+  void *GetBlockBeginFastLocked(void *p) {
+    if (primary_.PointerIsMine(p))
+      return primary_.GetBlockBegin(p);
+    return secondary_.GetBlockBeginFastLocked(p);
+  }
+
+  uptr GetActuallyAllocatedSize(void *p) {
+    if (primary_.PointerIsMine(p))
+      return primary_.GetActuallyAllocatedSize(p);
+    return secondary_.GetActuallyAllocatedSize(p);
+  }
+
+  uptr TotalMemoryUsed() {
+    return primary_.TotalMemoryUsed() + secondary_.TotalMemoryUsed();
+  }
+
+  void TestOnlyUnmap() { primary_.TestOnlyUnmap(); }
+
+  void InitCache(AllocatorCache *cache) {
+    cache->Init(&stats_);
+  }
+
+  void DestroyCache(AllocatorCache *cache) {
+    cache->Destroy(&primary_, &stats_);
+  }
+
+  void SwallowCache(AllocatorCache *cache) {
+    cache->Drain(&primary_);
+  }
+
+  void GetStats(AllocatorStatCounters s) const {
+    stats_.Get(s);
+  }
+
+  void PrintStats() {
+    primary_.PrintStats();
+    secondary_.PrintStats();
+  }
+
+  // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
+  // introspection API.
+  void ForceLock() {
+    primary_.ForceLock();
+    secondary_.ForceLock();
+  }
+
+  void ForceUnlock() {
+    secondary_.ForceUnlock();
+    primary_.ForceUnlock();
+  }
+
+  // Iterate over all existing chunks.
+  // The allocator must be locked when calling this function.
+  void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+    primary_.ForEachChunk(callback, arg);
+    secondary_.ForEachChunk(callback, arg);
+  }
+
+ private:
+  PrimaryAllocator primary_;
+  SecondaryAllocator secondary_;
+  AllocatorGlobalStats stats_;
+  atomic_uint8_t may_return_null_;
+  atomic_uint8_t rss_limit_is_exceeded_;
+};
+
+// Returns true if calloc(size, n) should return 0 due to overflow in size*n.
+bool CallocShouldReturnNullDueToOverflow(uptr size, uptr n);
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_ALLOCATOR_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h b/compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h
new file mode 100644
index 0000000..2cd924c
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h
@@ -0,0 +1,38 @@
+//===-- sanitizer_allocator_interface.h ------------------------- C++ -----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Re-declaration of functions from public sanitizer allocator interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ALLOCATOR_INTERFACE_H
+#define SANITIZER_ALLOCATOR_INTERFACE_H
+
+#include "sanitizer_internal_defs.h"
+
+using __sanitizer::uptr;
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_estimated_allocated_size(uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_get_ownership(const void *p);
+SANITIZER_INTERFACE_ATTRIBUTE uptr
+__sanitizer_get_allocated_size(const void *p);
+SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_current_allocated_bytes();
+SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_heap_size();
+SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_free_bytes();
+SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_unmapped_bytes();
+
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+    /* OPTIONAL */ void __sanitizer_malloc_hook(void *ptr, uptr size);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+    /* OPTIONAL */ void __sanitizer_free_hook(void *ptr);
+}  // extern "C"
+
+#endif  // SANITIZER_ALLOCATOR_INTERFACE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_allocator_internal.h b/compiler-rt/lib/sanitizer_common/sanitizer_allocator_internal.h
new file mode 100644
index 0000000..3dcfccd
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_allocator_internal.h
@@ -0,0 +1,63 @@
+//===-- sanitizer_allocator_internal.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This allocator is used inside run-times.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ALLOCATOR_INTERNAL_H
+#define SANITIZER_ALLOCATOR_INTERNAL_H
+
+#include "sanitizer_allocator.h"
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+// FIXME: Check if we may use even more compact size class map for internal
+// purposes.
+typedef CompactSizeClassMap InternalSizeClassMap;
+
+static const uptr kInternalAllocatorSpace = 0;
+static const u64 kInternalAllocatorSize = SANITIZER_MMAP_RANGE_SIZE;
+static const uptr kInternalAllocatorRegionSizeLog = 20;
+#if SANITIZER_WORDSIZE == 32
+static const uptr kInternalAllocatorNumRegions =
+    kInternalAllocatorSize >> kInternalAllocatorRegionSizeLog;
+typedef FlatByteMap<kInternalAllocatorNumRegions> ByteMap;
+#else
+static const uptr kInternalAllocatorNumRegions =
+    kInternalAllocatorSize >> kInternalAllocatorRegionSizeLog;
+typedef TwoLevelByteMap<(kInternalAllocatorNumRegions >> 12), 1 << 12> ByteMap;
+#endif
+typedef SizeClassAllocator32<
+    kInternalAllocatorSpace, kInternalAllocatorSize, 0, InternalSizeClassMap,
+    kInternalAllocatorRegionSizeLog, ByteMap> PrimaryInternalAllocator;
+
+typedef SizeClassAllocatorLocalCache<PrimaryInternalAllocator>
+    InternalAllocatorCache;
+
+typedef CombinedAllocator<PrimaryInternalAllocator, InternalAllocatorCache,
+                          LargeMmapAllocator<> > InternalAllocator;
+
+void *InternalAlloc(uptr size, InternalAllocatorCache *cache = nullptr);
+void InternalFree(void *p, InternalAllocatorCache *cache = nullptr);
+InternalAllocator *internal_allocator();
+
+enum InternalAllocEnum {
+  INTERNAL_ALLOC
+};
+
+} // namespace __sanitizer
+
+inline void *operator new(__sanitizer::operator_new_size_type size,
+                          InternalAllocEnum) {
+  return InternalAlloc(size);
+}
+
+#endif // SANITIZER_ALLOCATOR_INTERNAL_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_asm.h b/compiler-rt/lib/sanitizer_common/sanitizer_asm.h
new file mode 100644
index 0000000..47c2b12
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_asm.h
@@ -0,0 +1,58 @@
+//===-- sanitizer_asm.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Various support for assemebler.
+//
+//===----------------------------------------------------------------------===//
+
+// Some toolchains do not support .cfi asm directives, so we have to hide
+// them inside macros.
+#if defined(__clang__) ||                                                      \
+    (defined(__GNUC__) && defined(__GCC_HAVE_DWARF2_CFI_ASM))
+  // GCC defined __GCC_HAVE_DWARF2_CFI_ASM if it supports CFI.
+  // Clang seems to support CFI by default (or not?).
+  // We need two versions of macros: for inline asm and standalone asm files.
+# define CFI_INL_ADJUST_CFA_OFFSET(n) ".cfi_adjust_cfa_offset " #n ";"
+
+# define CFI_STARTPROC .cfi_startproc
+# define CFI_ENDPROC .cfi_endproc
+# define CFI_ADJUST_CFA_OFFSET(n) .cfi_adjust_cfa_offset n
+# define CFI_DEF_CFA_OFFSET(n) .cfi_def_cfa_offset n
+# define CFI_REL_OFFSET(reg, n) .cfi_rel_offset reg, n
+# define CFI_OFFSET(reg, n) .cfi_offset reg, n
+# define CFI_DEF_CFA_REGISTER(reg) .cfi_def_cfa_register reg
+# define CFI_DEF_CFA(reg, n) .cfi_def_cfa reg, n
+# define CFI_RESTORE(reg) .cfi_restore reg
+
+#else  // No CFI
+# define CFI_INL_ADJUST_CFA_OFFSET(n)
+# define CFI_STARTPROC
+# define CFI_ENDPROC
+# define CFI_ADJUST_CFA_OFFSET(n)
+# define CFI_DEF_CFA_OFFSET(n)
+# define CFI_REL_OFFSET(reg, n)
+# define CFI_OFFSET(reg, n)
+# define CFI_DEF_CFA_REGISTER(reg)
+# define CFI_DEF_CFA(reg, n)
+# define CFI_RESTORE(reg)
+#endif
+
+#if !defined(__APPLE__)
+# define ASM_HIDDEN(symbol) .hidden symbol
+# define ASM_TYPE_FUNCTION(symbol) .type symbol, @function
+# define ASM_SIZE(symbol) .size symbol, .-symbol
+# define ASM_TSAN_SYMBOL(symbol) symbol
+# define ASM_TSAN_SYMBOL_INTERCEPTOR(symbol) symbol
+#else
+# define ASM_HIDDEN(symbol)
+# define ASM_TYPE_FUNCTION(symbol)
+# define ASM_SIZE(symbol)
+# define ASM_TSAN_SYMBOL(symbol) _##symbol
+# define ASM_TSAN_SYMBOL_INTERCEPTOR(symbol) _wrap_##symbol
+#endif
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_atomic.h b/compiler-rt/lib/sanitizer_common/sanitizer_atomic.h
new file mode 100644
index 0000000..b26693e
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_atomic.h
@@ -0,0 +1,82 @@
+//===-- sanitizer_atomic.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ATOMIC_H
+#define SANITIZER_ATOMIC_H
+
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+enum memory_order {
+  memory_order_relaxed = 1 << 0,
+  memory_order_consume = 1 << 1,
+  memory_order_acquire = 1 << 2,
+  memory_order_release = 1 << 3,
+  memory_order_acq_rel = 1 << 4,
+  memory_order_seq_cst = 1 << 5
+};
+
+struct atomic_uint8_t {
+  typedef u8 Type;
+  volatile Type val_dont_use;
+};
+
+struct atomic_uint16_t {
+  typedef u16 Type;
+  volatile Type val_dont_use;
+};
+
+struct atomic_uint32_t {
+  typedef u32 Type;
+  volatile Type val_dont_use;
+};
+
+struct atomic_uint64_t {
+  typedef u64 Type;
+  // On 32-bit platforms u64 is not necessary aligned on 8 bytes.
+  volatile ALIGNED(8) Type val_dont_use;
+};
+
+struct atomic_uintptr_t {
+  typedef uptr Type;
+  volatile Type val_dont_use;
+};
+
+}  // namespace __sanitizer
+
+#if defined(__clang__) || defined(__GNUC__)
+# include "sanitizer_atomic_clang.h"
+#elif defined(_MSC_VER)
+# include "sanitizer_atomic_msvc.h"
+#else
+# error "Unsupported compiler"
+#endif
+
+namespace __sanitizer {
+
+// Clutter-reducing helpers.
+
+template<typename T>
+INLINE typename T::Type atomic_load_relaxed(const volatile T *a) {
+  return atomic_load(a, memory_order_relaxed);
+}
+
+template<typename T>
+INLINE void atomic_store_relaxed(volatile T *a, typename T::Type v) {
+  atomic_store(a, v, memory_order_relaxed);
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_ATOMIC_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang.h b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang.h
new file mode 100644
index 0000000..38363e8
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang.h
@@ -0,0 +1,100 @@
+//===-- sanitizer_atomic_clang.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Not intended for direct inclusion. Include sanitizer_atomic.h.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ATOMIC_CLANG_H
+#define SANITIZER_ATOMIC_CLANG_H
+
+#if defined(__i386__) || defined(__x86_64__)
+# include "sanitizer_atomic_clang_x86.h"
+#else
+# include "sanitizer_atomic_clang_other.h"
+#endif
+
+namespace __sanitizer {
+
+// We would like to just use compiler builtin atomic operations
+// for loads and stores, but they are mostly broken in clang:
+// - they lead to vastly inefficient code generation
+// (http://llvm.org/bugs/show_bug.cgi?id=17281)
+// - 64-bit atomic operations are not implemented on x86_32
+// (http://llvm.org/bugs/show_bug.cgi?id=15034)
+// - they are not implemented on ARM
+// error: undefined reference to '__atomic_load_4'
+
+// See http://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html
+// for mappings of the memory model to different processors.
+
+INLINE void atomic_signal_fence(memory_order) {
+  __asm__ __volatile__("" ::: "memory");
+}
+
+INLINE void atomic_thread_fence(memory_order) {
+  __sync_synchronize();
+}
+
+template<typename T>
+INLINE typename T::Type atomic_fetch_add(volatile T *a,
+    typename T::Type v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return __sync_fetch_and_add(&a->val_dont_use, v);
+}
+
+template<typename T>
+INLINE typename T::Type atomic_fetch_sub(volatile T *a,
+    typename T::Type v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return __sync_fetch_and_add(&a->val_dont_use, -v);
+}
+
+template<typename T>
+INLINE typename T::Type atomic_exchange(volatile T *a,
+    typename T::Type v, memory_order mo) {
+  DCHECK(!((uptr)a % sizeof(*a)));
+  if (mo & (memory_order_release | memory_order_acq_rel | memory_order_seq_cst))
+    __sync_synchronize();
+  v = __sync_lock_test_and_set(&a->val_dont_use, v);
+  if (mo == memory_order_seq_cst)
+    __sync_synchronize();
+  return v;
+}
+
+template<typename T>
+INLINE bool atomic_compare_exchange_strong(volatile T *a,
+                                           typename T::Type *cmp,
+                                           typename T::Type xchg,
+                                           memory_order mo) {
+  typedef typename T::Type Type;
+  Type cmpv = *cmp;
+  Type prev = __sync_val_compare_and_swap(&a->val_dont_use, cmpv, xchg);
+  if (prev == cmpv)
+    return true;
+  *cmp = prev;
+  return false;
+}
+
+template<typename T>
+INLINE bool atomic_compare_exchange_weak(volatile T *a,
+                                         typename T::Type *cmp,
+                                         typename T::Type xchg,
+                                         memory_order mo) {
+  return atomic_compare_exchange_strong(a, cmp, xchg, mo);
+}
+
+}  // namespace __sanitizer
+
+#undef ATOMIC_ORDER
+
+#endif  // SANITIZER_ATOMIC_CLANG_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_other.h b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_other.h
new file mode 100644
index 0000000..099b9f7
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_other.h
@@ -0,0 +1,97 @@
+//===-- sanitizer_atomic_clang_other.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Not intended for direct inclusion. Include sanitizer_atomic.h.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ATOMIC_CLANG_OTHER_H
+#define SANITIZER_ATOMIC_CLANG_OTHER_H
+
+namespace __sanitizer {
+
+INLINE void proc_yield(int cnt) {
+  __asm__ __volatile__("" ::: "memory");
+}
+
+template<typename T>
+INLINE typename T::Type atomic_load(
+    const volatile T *a, memory_order mo) {
+  DCHECK(mo & (memory_order_relaxed | memory_order_consume
+      | memory_order_acquire | memory_order_seq_cst));
+  DCHECK(!((uptr)a % sizeof(*a)));
+  typename T::Type v;
+
+  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
+    // Assume that aligned loads are atomic.
+    if (mo == memory_order_relaxed) {
+      v = a->val_dont_use;
+    } else if (mo == memory_order_consume) {
+      // Assume that processor respects data dependencies
+      // (and that compiler won't break them).
+      __asm__ __volatile__("" ::: "memory");
+      v = a->val_dont_use;
+      __asm__ __volatile__("" ::: "memory");
+    } else if (mo == memory_order_acquire) {
+      __asm__ __volatile__("" ::: "memory");
+      v = a->val_dont_use;
+      __sync_synchronize();
+    } else {  // seq_cst
+      // E.g. on POWER we need a hw fence even before the store.
+      __sync_synchronize();
+      v = a->val_dont_use;
+      __sync_synchronize();
+    }
+  } else {
+    // 64-bit load on 32-bit platform.
+    // Gross, but simple and reliable.
+    // Assume that it is not in read-only memory.
+    v = __sync_fetch_and_add(
+        const_cast<typename T::Type volatile *>(&a->val_dont_use), 0);
+  }
+  return v;
+}
+
+template<typename T>
+INLINE void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
+  DCHECK(mo & (memory_order_relaxed | memory_order_release
+      | memory_order_seq_cst));
+  DCHECK(!((uptr)a % sizeof(*a)));
+
+  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
+    // Assume that aligned loads are atomic.
+    if (mo == memory_order_relaxed) {
+      a->val_dont_use = v;
+    } else if (mo == memory_order_release) {
+      __sync_synchronize();
+      a->val_dont_use = v;
+      __asm__ __volatile__("" ::: "memory");
+    } else {  // seq_cst
+      __sync_synchronize();
+      a->val_dont_use = v;
+      __sync_synchronize();
+    }
+  } else {
+    // 64-bit store on 32-bit platform.
+    // Gross, but simple and reliable.
+    typename T::Type cmp = a->val_dont_use;
+    typename T::Type cur;
+    for (;;) {
+      cur = __sync_val_compare_and_swap(&a->val_dont_use, cmp, v);
+      if (cmp == v)
+        break;
+      cmp = cur;
+    }
+  }
+}
+
+}  // namespace __sanitizer
+
+#endif  // #ifndef SANITIZER_ATOMIC_CLANG_OTHER_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_x86.h b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_x86.h
new file mode 100644
index 0000000..38feb29
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_x86.h
@@ -0,0 +1,116 @@
+//===-- sanitizer_atomic_clang_x86.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Not intended for direct inclusion. Include sanitizer_atomic.h.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ATOMIC_CLANG_X86_H
+#define SANITIZER_ATOMIC_CLANG_X86_H
+
+namespace __sanitizer {
+
+INLINE void proc_yield(int cnt) {
+  __asm__ __volatile__("" ::: "memory");
+  for (int i = 0; i < cnt; i++)
+    __asm__ __volatile__("pause");
+  __asm__ __volatile__("" ::: "memory");
+}
+
+template<typename T>
+INLINE typename T::Type atomic_load(
+    const volatile T *a, memory_order mo) {
+  DCHECK(mo & (memory_order_relaxed | memory_order_consume
+      | memory_order_acquire | memory_order_seq_cst));
+  DCHECK(!((uptr)a % sizeof(*a)));
+  typename T::Type v;
+
+  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
+    // Assume that aligned loads are atomic.
+    if (mo == memory_order_relaxed) {
+      v = a->val_dont_use;
+    } else if (mo == memory_order_consume) {
+      // Assume that processor respects data dependencies
+      // (and that compiler won't break them).
+      __asm__ __volatile__("" ::: "memory");
+      v = a->val_dont_use;
+      __asm__ __volatile__("" ::: "memory");
+    } else if (mo == memory_order_acquire) {
+      __asm__ __volatile__("" ::: "memory");
+      v = a->val_dont_use;
+      // On x86 loads are implicitly acquire.
+      __asm__ __volatile__("" ::: "memory");
+    } else {  // seq_cst
+      // On x86 plain MOV is enough for seq_cst store.
+      __asm__ __volatile__("" ::: "memory");
+      v = a->val_dont_use;
+      __asm__ __volatile__("" ::: "memory");
+    }
+  } else {
+    // 64-bit load on 32-bit platform.
+    __asm__ __volatile__(
+        "movq %1, %%mm0;"  // Use mmx reg for 64-bit atomic moves
+        "movq %%mm0, %0;"  // (ptr could be read-only)
+        "emms;"            // Empty mmx state/Reset FP regs
+        : "=m" (v)
+        : "m" (a->val_dont_use)
+        : // mark the FP stack and mmx registers as clobbered
+          "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
+#ifdef __MMX__
+          "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
+#endif  // #ifdef __MMX__
+          "memory");
+  }
+  return v;
+}
+
+template<typename T>
+INLINE void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
+  DCHECK(mo & (memory_order_relaxed | memory_order_release
+      | memory_order_seq_cst));
+  DCHECK(!((uptr)a % sizeof(*a)));
+
+  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
+    // Assume that aligned loads are atomic.
+    if (mo == memory_order_relaxed) {
+      a->val_dont_use = v;
+    } else if (mo == memory_order_release) {
+      // On x86 stores are implicitly release.
+      __asm__ __volatile__("" ::: "memory");
+      a->val_dont_use = v;
+      __asm__ __volatile__("" ::: "memory");
+    } else {  // seq_cst
+      // On x86 stores are implicitly release.
+      __asm__ __volatile__("" ::: "memory");
+      a->val_dont_use = v;
+      __sync_synchronize();
+    }
+  } else {
+    // 64-bit store on 32-bit platform.
+    __asm__ __volatile__(
+        "movq %1, %%mm0;"  // Use mmx reg for 64-bit atomic moves
+        "movq %%mm0, %0;"
+        "emms;"            // Empty mmx state/Reset FP regs
+        : "=m" (a->val_dont_use)
+        : "m" (v)
+        : // mark the FP stack and mmx registers as clobbered
+          "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
+#ifdef __MMX__
+          "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
+#endif  // #ifdef __MMX__
+          "memory");
+    if (mo == memory_order_seq_cst)
+      __sync_synchronize();
+  }
+}
+
+}  // namespace __sanitizer
+
+#endif  // #ifndef SANITIZER_ATOMIC_CLANG_X86_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_atomic_msvc.h b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_msvc.h
new file mode 100644
index 0000000..24d6f0f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_atomic_msvc.h
@@ -0,0 +1,261 @@
+//===-- sanitizer_atomic_msvc.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Not intended for direct inclusion. Include sanitizer_atomic.h.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_ATOMIC_MSVC_H
+#define SANITIZER_ATOMIC_MSVC_H
+
+extern "C" void _ReadWriteBarrier();
+#pragma intrinsic(_ReadWriteBarrier)
+extern "C" void _mm_mfence();
+#pragma intrinsic(_mm_mfence)
+extern "C" void _mm_pause();
+#pragma intrinsic(_mm_pause)
+extern "C" char _InterlockedExchange8(   // NOLINT
+    char volatile *Addend, char Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchange8)
+extern "C" short _InterlockedExchange16(   // NOLINT
+    short volatile *Addend, short Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchange16)
+extern "C" long _InterlockedExchange(    // NOLINT
+    long volatile *Addend, long Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchange)
+extern "C" long _InterlockedExchangeAdd(  // NOLINT
+    long volatile * Addend, long Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchangeAdd)
+extern "C" short _InterlockedCompareExchange16(  // NOLINT
+    short volatile *Destination,                 // NOLINT
+    short Exchange, short Comparand);            // NOLINT
+#pragma intrinsic(_InterlockedCompareExchange16)
+extern "C"
+long long _InterlockedCompareExchange64(  // NOLINT
+    long long volatile *Destination,              // NOLINT
+    long long Exchange, long long Comparand);     // NOLINT
+#pragma intrinsic(_InterlockedCompareExchange64)
+extern "C" void *_InterlockedCompareExchangePointer(
+    void *volatile *Destination,
+    void *Exchange, void *Comparand);
+#pragma intrinsic(_InterlockedCompareExchangePointer)
+extern "C"
+long __cdecl _InterlockedCompareExchange(  // NOLINT
+    long volatile *Destination,            // NOLINT
+    long Exchange, long Comparand);        // NOLINT
+#pragma intrinsic(_InterlockedCompareExchange)
+
+#ifdef _WIN64
+extern "C" long long _InterlockedExchangeAdd64(     // NOLINT
+    long long volatile * Addend, long long Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchangeAdd64)
+#endif
+
+namespace __sanitizer {
+
+INLINE void atomic_signal_fence(memory_order) {
+  _ReadWriteBarrier();
+}
+
+INLINE void atomic_thread_fence(memory_order) {
+  _mm_mfence();
+}
+
+INLINE void proc_yield(int cnt) {
+  for (int i = 0; i < cnt; i++)
+    _mm_pause();
+}
+
+template<typename T>
+INLINE typename T::Type atomic_load(
+    const volatile T *a, memory_order mo) {
+  DCHECK(mo & (memory_order_relaxed | memory_order_consume
+      | memory_order_acquire | memory_order_seq_cst));
+  DCHECK(!((uptr)a % sizeof(*a)));
+  typename T::Type v;
+  // FIXME(dvyukov): 64-bit load is not atomic on 32-bits.
+  if (mo == memory_order_relaxed) {
+    v = a->val_dont_use;
+  } else {
+    atomic_signal_fence(memory_order_seq_cst);
+    v = a->val_dont_use;
+    atomic_signal_fence(memory_order_seq_cst);
+  }
+  return v;
+}
+
+template<typename T>
+INLINE void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
+  DCHECK(mo & (memory_order_relaxed | memory_order_release
+      | memory_order_seq_cst));
+  DCHECK(!((uptr)a % sizeof(*a)));
+  // FIXME(dvyukov): 64-bit store is not atomic on 32-bits.
+  if (mo == memory_order_relaxed) {
+    a->val_dont_use = v;
+  } else {
+    atomic_signal_fence(memory_order_seq_cst);
+    a->val_dont_use = v;
+    atomic_signal_fence(memory_order_seq_cst);
+  }
+  if (mo == memory_order_seq_cst)
+    atomic_thread_fence(memory_order_seq_cst);
+}
+
+INLINE u32 atomic_fetch_add(volatile atomic_uint32_t *a,
+    u32 v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return (u32)_InterlockedExchangeAdd(
+      (volatile long*)&a->val_dont_use, (long)v);  // NOLINT
+}
+
+INLINE uptr atomic_fetch_add(volatile atomic_uintptr_t *a,
+    uptr v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+#ifdef _WIN64
+  return (uptr)_InterlockedExchangeAdd64(
+      (volatile long long*)&a->val_dont_use, (long long)v);  // NOLINT
+#else
+  return (uptr)_InterlockedExchangeAdd(
+      (volatile long*)&a->val_dont_use, (long)v);  // NOLINT
+#endif
+}
+
+INLINE u32 atomic_fetch_sub(volatile atomic_uint32_t *a,
+    u32 v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return (u32)_InterlockedExchangeAdd(
+      (volatile long*)&a->val_dont_use, -(long)v);  // NOLINT
+}
+
+INLINE uptr atomic_fetch_sub(volatile atomic_uintptr_t *a,
+    uptr v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+#ifdef _WIN64
+  return (uptr)_InterlockedExchangeAdd64(
+      (volatile long long*)&a->val_dont_use, -(long long)v);  // NOLINT
+#else
+  return (uptr)_InterlockedExchangeAdd(
+      (volatile long*)&a->val_dont_use, -(long)v);  // NOLINT
+#endif
+}
+
+INLINE u8 atomic_exchange(volatile atomic_uint8_t *a,
+    u8 v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return (u8)_InterlockedExchange8((volatile char*)&a->val_dont_use, v);
+}
+
+INLINE u16 atomic_exchange(volatile atomic_uint16_t *a,
+    u16 v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return (u16)_InterlockedExchange16((volatile short*)&a->val_dont_use, v);
+}
+
+INLINE u32 atomic_exchange(volatile atomic_uint32_t *a,
+    u32 v, memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return (u32)_InterlockedExchange((volatile long*)&a->val_dont_use, v);
+}
+
+#ifndef _WIN64
+
+INLINE bool atomic_compare_exchange_strong(volatile atomic_uint8_t *a,
+                                           u8 *cmp,
+                                           u8 xchgv,
+                                           memory_order mo) {
+  (void)mo;
+  DCHECK(!((uptr)a % sizeof(*a)));
+  u8 cmpv = *cmp;
+  u8 prev;
+  __asm {
+    mov al, cmpv
+    mov ecx, a
+    mov dl, xchgv
+    lock cmpxchg [ecx], dl
+    mov prev, al
+  }
+  if (prev == cmpv)
+    return true;
+  *cmp = prev;
+  return false;
+}
+
+#endif
+
+INLINE bool atomic_compare_exchange_strong(volatile atomic_uintptr_t *a,
+                                           uptr *cmp,
+                                           uptr xchg,
+                                           memory_order mo) {
+  uptr cmpv = *cmp;
+  uptr prev = (uptr)_InterlockedCompareExchangePointer(
+      (void*volatile*)&a->val_dont_use, (void*)xchg, (void*)cmpv);
+  if (prev == cmpv)
+    return true;
+  *cmp = prev;
+  return false;
+}
+
+INLINE bool atomic_compare_exchange_strong(volatile atomic_uint16_t *a,
+                                           u16 *cmp,
+                                           u16 xchg,
+                                           memory_order mo) {
+  u16 cmpv = *cmp;
+  u16 prev = (u16)_InterlockedCompareExchange16(
+      (volatile short*)&a->val_dont_use, (short)xchg, (short)cmpv);
+  if (prev == cmpv)
+    return true;
+  *cmp = prev;
+  return false;
+}
+
+INLINE bool atomic_compare_exchange_strong(volatile atomic_uint32_t *a,
+                                           u32 *cmp,
+                                           u32 xchg,
+                                           memory_order mo) {
+  u32 cmpv = *cmp;
+  u32 prev = (u32)_InterlockedCompareExchange(
+      (volatile long*)&a->val_dont_use, (long)xchg, (long)cmpv);
+  if (prev == cmpv)
+    return true;
+  *cmp = prev;
+  return false;
+}
+
+INLINE bool atomic_compare_exchange_strong(volatile atomic_uint64_t *a,
+                                           u64 *cmp,
+                                           u64 xchg,
+                                           memory_order mo) {
+  u64 cmpv = *cmp;
+  u64 prev = (u64)_InterlockedCompareExchange64(
+      (volatile long long*)&a->val_dont_use, (long long)xchg, (long long)cmpv);
+  if (prev == cmpv)
+    return true;
+  *cmp = prev;
+  return false;
+}
+
+template<typename T>
+INLINE bool atomic_compare_exchange_weak(volatile T *a,
+                                         typename T::Type *cmp,
+                                         typename T::Type xchg,
+                                         memory_order mo) {
+  return atomic_compare_exchange_strong(a, cmp, xchg, mo);
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_ATOMIC_CLANG_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_bitvector.h b/compiler-rt/lib/sanitizer_common/sanitizer_bitvector.h
new file mode 100644
index 0000000..d847273
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_bitvector.h
@@ -0,0 +1,351 @@
+//===-- sanitizer_bitvector.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Specializer BitVector implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_BITVECTOR_H
+#define SANITIZER_BITVECTOR_H
+
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+
+// Fixed size bit vector based on a single basic integer.
+template <class basic_int_t = uptr>
+class BasicBitVector {
+ public:
+  enum SizeEnum { kSize = sizeof(basic_int_t) * 8 };
+
+  uptr size() const { return kSize; }
+  // No CTOR.
+  void clear() { bits_ = 0; }
+  void setAll() { bits_ = ~(basic_int_t)0; }
+  bool empty() const { return bits_ == 0; }
+
+  // Returns true if the bit has changed from 0 to 1.
+  bool setBit(uptr idx) {
+    basic_int_t old = bits_;
+    bits_ |= mask(idx);
+    return bits_ != old;
+  }
+
+  // Returns true if the bit has changed from 1 to 0.
+  bool clearBit(uptr idx) {
+    basic_int_t old = bits_;
+    bits_ &= ~mask(idx);
+    return bits_ != old;
+  }
+
+  bool getBit(uptr idx) const { return (bits_ & mask(idx)) != 0; }
+
+  uptr getAndClearFirstOne() {
+    CHECK(!empty());
+    uptr idx = LeastSignificantSetBitIndex(bits_);
+    clearBit(idx);
+    return idx;
+  }
+
+  // Do "this |= v" and return whether new bits have been added.
+  bool setUnion(const BasicBitVector &v) {
+    basic_int_t old = bits_;
+    bits_ |= v.bits_;
+    return bits_ != old;
+  }
+
+  // Do "this &= v" and return whether any bits have been removed.
+  bool setIntersection(const BasicBitVector &v) {
+    basic_int_t old = bits_;
+    bits_ &= v.bits_;
+    return bits_ != old;
+  }
+
+  // Do "this &= ~v" and return whether any bits have been removed.
+  bool setDifference(const BasicBitVector &v) {
+    basic_int_t old = bits_;
+    bits_ &= ~v.bits_;
+    return bits_ != old;
+  }
+
+  void copyFrom(const BasicBitVector &v) { bits_ = v.bits_; }
+
+  // Returns true if 'this' intersects with 'v'.
+  bool intersectsWith(const BasicBitVector &v) const {
+    return (bits_ & v.bits_) != 0;
+  }
+
+  // for (BasicBitVector<>::Iterator it(bv); it.hasNext();) {
+  //   uptr idx = it.next();
+  //   use(idx);
+  // }
+  class Iterator {
+   public:
+    Iterator() { }
+    explicit Iterator(const BasicBitVector &bv) : bv_(bv) {}
+    bool hasNext() const { return !bv_.empty(); }
+    uptr next() { return bv_.getAndClearFirstOne(); }
+    void clear() { bv_.clear(); }
+   private:
+    BasicBitVector bv_;
+  };
+
+ private:
+  basic_int_t mask(uptr idx) const {
+    CHECK_LT(idx, size());
+    return (basic_int_t)1UL << idx;
+  }
+  basic_int_t bits_;
+};
+
+// Fixed size bit vector of (kLevel1Size*BV::kSize**2) bits.
+// The implementation is optimized for better performance on
+// sparse bit vectors, i.e. the those with few set bits.
+template <uptr kLevel1Size = 1, class BV = BasicBitVector<> >
+class TwoLevelBitVector {
+  // This is essentially a 2-level bit vector.
+  // Set bit in the first level BV indicates that there are set bits
+  // in the corresponding BV of the second level.
+  // This structure allows O(kLevel1Size) time for clear() and empty(),
+  // as well fast handling of sparse BVs.
+ public:
+  enum SizeEnum { kSize = BV::kSize * BV::kSize * kLevel1Size };
+  // No CTOR.
+
+  uptr size() const { return kSize; }
+
+  void clear() {
+    for (uptr i = 0; i < kLevel1Size; i++)
+      l1_[i].clear();
+  }
+
+  void setAll() {
+    for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
+      l1_[i0].setAll();
+      for (uptr i1 = 0; i1 < BV::kSize; i1++)
+        l2_[i0][i1].setAll();
+    }
+  }
+
+  bool empty() const {
+    for (uptr i = 0; i < kLevel1Size; i++)
+      if (!l1_[i].empty())
+        return false;
+    return true;
+  }
+
+  // Returns true if the bit has changed from 0 to 1.
+  bool setBit(uptr idx) {
+    check(idx);
+    uptr i0 = idx0(idx);
+    uptr i1 = idx1(idx);
+    uptr i2 = idx2(idx);
+    if (!l1_[i0].getBit(i1)) {
+      l1_[i0].setBit(i1);
+      l2_[i0][i1].clear();
+    }
+    bool res = l2_[i0][i1].setBit(i2);
+    // Printf("%s: %zd => %zd %zd %zd; %d\n", __func__,
+    // idx, i0, i1, i2, res);
+    return res;
+  }
+
+  bool clearBit(uptr idx) {
+    check(idx);
+    uptr i0 = idx0(idx);
+    uptr i1 = idx1(idx);
+    uptr i2 = idx2(idx);
+    bool res = false;
+    if (l1_[i0].getBit(i1)) {
+      res = l2_[i0][i1].clearBit(i2);
+      if (l2_[i0][i1].empty())
+        l1_[i0].clearBit(i1);
+    }
+    return res;
+  }
+
+  bool getBit(uptr idx) const {
+    check(idx);
+    uptr i0 = idx0(idx);
+    uptr i1 = idx1(idx);
+    uptr i2 = idx2(idx);
+    // Printf("%s: %zd => %zd %zd %zd\n", __func__, idx, i0, i1, i2);
+    return l1_[i0].getBit(i1) && l2_[i0][i1].getBit(i2);
+  }
+
+  uptr getAndClearFirstOne() {
+    for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
+      if (l1_[i0].empty()) continue;
+      uptr i1 = l1_[i0].getAndClearFirstOne();
+      uptr i2 = l2_[i0][i1].getAndClearFirstOne();
+      if (!l2_[i0][i1].empty())
+        l1_[i0].setBit(i1);
+      uptr res = i0 * BV::kSize * BV::kSize + i1 * BV::kSize + i2;
+      // Printf("getAndClearFirstOne: %zd %zd %zd => %zd\n", i0, i1, i2, res);
+      return res;
+    }
+    CHECK(0);
+    return 0;
+  }
+
+  // Do "this |= v" and return whether new bits have been added.
+  bool setUnion(const TwoLevelBitVector &v) {
+    bool res = false;
+    for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
+      BV t = v.l1_[i0];
+      while (!t.empty()) {
+        uptr i1 = t.getAndClearFirstOne();
+        if (l1_[i0].setBit(i1))
+          l2_[i0][i1].clear();
+        if (l2_[i0][i1].setUnion(v.l2_[i0][i1]))
+          res = true;
+      }
+    }
+    return res;
+  }
+
+  // Do "this &= v" and return whether any bits have been removed.
+  bool setIntersection(const TwoLevelBitVector &v) {
+    bool res = false;
+    for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
+      if (l1_[i0].setIntersection(v.l1_[i0]))
+        res = true;
+      if (!l1_[i0].empty()) {
+        BV t = l1_[i0];
+        while (!t.empty()) {
+          uptr i1 = t.getAndClearFirstOne();
+          if (l2_[i0][i1].setIntersection(v.l2_[i0][i1]))
+            res = true;
+          if (l2_[i0][i1].empty())
+            l1_[i0].clearBit(i1);
+        }
+      }
+    }
+    return res;
+  }
+
+  // Do "this &= ~v" and return whether any bits have been removed.
+  bool setDifference(const TwoLevelBitVector &v) {
+    bool res = false;
+    for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
+      BV t = l1_[i0];
+      t.setIntersection(v.l1_[i0]);
+      while (!t.empty()) {
+        uptr i1 = t.getAndClearFirstOne();
+        if (l2_[i0][i1].setDifference(v.l2_[i0][i1]))
+          res = true;
+        if (l2_[i0][i1].empty())
+          l1_[i0].clearBit(i1);
+      }
+    }
+    return res;
+  }
+
+  void copyFrom(const TwoLevelBitVector &v) {
+    clear();
+    setUnion(v);
+  }
+
+  // Returns true if 'this' intersects with 'v'.
+  bool intersectsWith(const TwoLevelBitVector &v) const {
+    for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
+      BV t = l1_[i0];
+      t.setIntersection(v.l1_[i0]);
+      while (!t.empty()) {
+        uptr i1 = t.getAndClearFirstOne();
+        if (!v.l1_[i0].getBit(i1)) continue;
+        if (l2_[i0][i1].intersectsWith(v.l2_[i0][i1]))
+          return true;
+      }
+    }
+    return false;
+  }
+
+  // for (TwoLevelBitVector<>::Iterator it(bv); it.hasNext();) {
+  //   uptr idx = it.next();
+  //   use(idx);
+  // }
+  class Iterator {
+   public:
+    Iterator() { }
+    explicit Iterator(const TwoLevelBitVector &bv) : bv_(bv), i0_(0), i1_(0) {
+      it1_.clear();
+      it2_.clear();
+    }
+
+    bool hasNext() const {
+      if (it1_.hasNext()) return true;
+      for (uptr i = i0_; i < kLevel1Size; i++)
+        if (!bv_.l1_[i].empty()) return true;
+      return false;
+    }
+
+    uptr next() {
+      // Printf("++++: %zd %zd; %d %d; size %zd\n", i0_, i1_, it1_.hasNext(),
+      //       it2_.hasNext(), kSize);
+      if (!it1_.hasNext() && !it2_.hasNext()) {
+        for (; i0_ < kLevel1Size; i0_++) {
+          if (bv_.l1_[i0_].empty()) continue;
+          it1_ = typename BV::Iterator(bv_.l1_[i0_]);
+          // Printf("+i0: %zd %zd; %d %d; size %zd\n", i0_, i1_, it1_.hasNext(),
+          //   it2_.hasNext(), kSize);
+          break;
+        }
+      }
+      if (!it2_.hasNext()) {
+        CHECK(it1_.hasNext());
+        i1_ = it1_.next();
+        it2_ = typename BV::Iterator(bv_.l2_[i0_][i1_]);
+        // Printf("++i1: %zd %zd; %d %d; size %zd\n", i0_, i1_, it1_.hasNext(),
+        //       it2_.hasNext(), kSize);
+      }
+      CHECK(it2_.hasNext());
+      uptr i2 = it2_.next();
+      uptr res = i0_ * BV::kSize * BV::kSize + i1_ * BV::kSize + i2;
+      // Printf("+ret: %zd %zd; %d %d; size %zd; res: %zd\n", i0_, i1_,
+      //       it1_.hasNext(), it2_.hasNext(), kSize, res);
+      if (!it1_.hasNext() && !it2_.hasNext())
+        i0_++;
+      return res;
+    }
+
+   private:
+    const TwoLevelBitVector &bv_;
+    uptr i0_, i1_;
+    typename BV::Iterator it1_, it2_;
+  };
+
+ private:
+  void check(uptr idx) const { CHECK_LE(idx, size()); }
+
+  uptr idx0(uptr idx) const {
+    uptr res = idx / (BV::kSize * BV::kSize);
+    CHECK_LE(res, kLevel1Size);
+    return res;
+  }
+
+  uptr idx1(uptr idx) const {
+    uptr res = (idx / BV::kSize) % BV::kSize;
+    CHECK_LE(res, BV::kSize);
+    return res;
+  }
+
+  uptr idx2(uptr idx) const {
+    uptr res = idx % BV::kSize;
+    CHECK_LE(res, BV::kSize);
+    return res;
+  }
+
+  BV l1_[kLevel1Size];
+  BV l2_[kLevel1Size][BV::kSize];
+};
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_BITVECTOR_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_bvgraph.h b/compiler-rt/lib/sanitizer_common/sanitizer_bvgraph.h
new file mode 100644
index 0000000..df72f1c
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_bvgraph.h
@@ -0,0 +1,165 @@
+//===-- sanitizer_bvgraph.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime.
+// BVGraph -- a directed graph.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_BVGRAPH_H
+#define SANITIZER_BVGRAPH_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_bitvector.h"
+
+namespace __sanitizer {
+
+// Directed graph of fixed size implemented as an array of bit vectors.
+// Not thread-safe, all accesses should be protected by an external lock.
+template<class BV>
+class BVGraph {
+ public:
+  enum SizeEnum { kSize = BV::kSize };
+  uptr size() const { return kSize; }
+  // No CTOR.
+  void clear() {
+    for (uptr i = 0; i < size(); i++)
+      v[i].clear();
+  }
+
+  bool empty() const {
+    for (uptr i = 0; i < size(); i++)
+      if (!v[i].empty())
+        return false;
+    return true;
+  }
+
+  // Returns true if a new edge was added.
+  bool addEdge(uptr from, uptr to) {
+    check(from, to);
+    return v[from].setBit(to);
+  }
+
+  // Returns true if at least one new edge was added.
+  uptr addEdges(const BV &from, uptr to, uptr added_edges[],
+                uptr max_added_edges) {
+    uptr res = 0;
+    t1.copyFrom(from);
+    while (!t1.empty()) {
+      uptr node = t1.getAndClearFirstOne();
+      if (v[node].setBit(to))
+        if (res < max_added_edges)
+          added_edges[res++] = node;
+    }
+    return res;
+  }
+
+  // *EXPERIMENTAL*
+  // Returns true if an edge from=>to exist.
+  // This function does not use any global state except for 'this' itself,
+  // and thus can be called from different threads w/o locking.
+  // This would be racy.
+  // FIXME: investigate how much we can prove about this race being "benign".
+  bool hasEdge(uptr from, uptr to) { return v[from].getBit(to); }
+
+  // Returns true if the edge from=>to was removed.
+  bool removeEdge(uptr from, uptr to) {
+    return v[from].clearBit(to);
+  }
+
+  // Returns true if at least one edge *=>to was removed.
+  bool removeEdgesTo(const BV &to) {
+    bool res = 0;
+    for (uptr from = 0; from < size(); from++) {
+      if (v[from].setDifference(to))
+        res = true;
+    }
+    return res;
+  }
+
+  // Returns true if at least one edge from=>* was removed.
+  bool removeEdgesFrom(const BV &from) {
+    bool res = false;
+    t1.copyFrom(from);
+    while (!t1.empty()) {
+      uptr idx = t1.getAndClearFirstOne();
+      if (!v[idx].empty()) {
+        v[idx].clear();
+        res = true;
+      }
+    }
+    return res;
+  }
+
+  void removeEdgesFrom(uptr from) {
+    return v[from].clear();
+  }
+
+  bool hasEdge(uptr from, uptr to) const {
+    check(from, to);
+    return v[from].getBit(to);
+  }
+
+  // Returns true if there is a path from the node 'from'
+  // to any of the nodes in 'targets'.
+  bool isReachable(uptr from, const BV &targets) {
+    BV &to_visit = t1,
+       &visited = t2;
+    to_visit.copyFrom(v[from]);
+    visited.clear();
+    visited.setBit(from);
+    while (!to_visit.empty()) {
+      uptr idx = to_visit.getAndClearFirstOne();
+      if (visited.setBit(idx))
+        to_visit.setUnion(v[idx]);
+    }
+    return targets.intersectsWith(visited);
+  }
+
+  // Finds a path from 'from' to one of the nodes in 'target',
+  // stores up to 'path_size' items of the path into 'path',
+  // returns the path length, or 0 if there is no path of size 'path_size'.
+  uptr findPath(uptr from, const BV &targets, uptr *path, uptr path_size) {
+    if (path_size == 0)
+      return 0;
+    path[0] = from;
+    if (targets.getBit(from))
+      return 1;
+    // The function is recursive, so we don't want to create BV on stack.
+    // Instead of a getAndClearFirstOne loop we use the slower iterator.
+    for (typename BV::Iterator it(v[from]); it.hasNext(); ) {
+      uptr idx = it.next();
+      if (uptr res = findPath(idx, targets, path + 1, path_size - 1))
+        return res + 1;
+    }
+    return 0;
+  }
+
+  // Same as findPath, but finds a shortest path.
+  uptr findShortestPath(uptr from, const BV &targets, uptr *path,
+                        uptr path_size) {
+    for (uptr p = 1; p <= path_size; p++)
+      if (findPath(from, targets, path, p) == p)
+        return p;
+    return 0;
+  }
+
+ private:
+  void check(uptr idx1, uptr idx2) const {
+    CHECK_LT(idx1, size());
+    CHECK_LT(idx2, size());
+  }
+  BV v[kSize];
+  // Keep temporary vectors here since we can not create large objects on stack.
+  BV t1, t2;
+};
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_BVGRAPH_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common.cc b/compiler-rt/lib/sanitizer_common/sanitizer_common.cc
new file mode 100644
index 0000000..9b41a3a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common.cc
@@ -0,0 +1,508 @@
+//===-- sanitizer_common.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common.h"
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_stacktrace_printer.h"
+#include "sanitizer_symbolizer.h"
+
+namespace __sanitizer {
+
+const char *SanitizerToolName = "SanitizerTool";
+
+atomic_uint32_t current_verbosity;
+
+uptr GetPageSizeCached() {
+  static uptr PageSize;
+  if (!PageSize)
+    PageSize = GetPageSize();
+  return PageSize;
+}
+
+StaticSpinMutex report_file_mu;
+ReportFile report_file = {&report_file_mu, kStderrFd, "", "", 0};
+
+void RawWrite(const char *buffer) {
+  report_file.Write(buffer, internal_strlen(buffer));
+}
+
+void ReportFile::ReopenIfNecessary() {
+  mu->CheckLocked();
+  if (fd == kStdoutFd || fd == kStderrFd) return;
+
+  uptr pid = internal_getpid();
+  // If in tracer, use the parent's file.
+  if (pid == stoptheworld_tracer_pid)
+    pid = stoptheworld_tracer_ppid;
+  if (fd != kInvalidFd) {
+    // If the report file is already opened by the current process,
+    // do nothing. Otherwise the report file was opened by the parent
+    // process, close it now.
+    if (fd_pid == pid)
+      return;
+    else
+      CloseFile(fd);
+  }
+
+  const char *exe_name = GetProcessName();
+  if (common_flags()->log_exe_name && exe_name) {
+    internal_snprintf(full_path, kMaxPathLength, "%s.%s.%zu", path_prefix,
+                      exe_name, pid);
+  } else {
+    internal_snprintf(full_path, kMaxPathLength, "%s.%zu", path_prefix, pid);
+  }
+  fd = OpenFile(full_path, WrOnly);
+  if (fd == kInvalidFd) {
+    const char *ErrorMsgPrefix = "ERROR: Can't open file: ";
+    WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
+    WriteToFile(kStderrFd, full_path, internal_strlen(full_path));
+    Die();
+  }
+  fd_pid = pid;
+}
+
+void ReportFile::SetReportPath(const char *path) {
+  if (!path)
+    return;
+  uptr len = internal_strlen(path);
+  if (len > sizeof(path_prefix) - 100) {
+    Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n",
+           path[0], path[1], path[2], path[3],
+           path[4], path[5], path[6], path[7]);
+    Die();
+  }
+
+  SpinMutexLock l(mu);
+  if (fd != kStdoutFd && fd != kStderrFd && fd != kInvalidFd)
+    CloseFile(fd);
+  fd = kInvalidFd;
+  if (internal_strcmp(path, "stdout") == 0) {
+    fd = kStdoutFd;
+  } else if (internal_strcmp(path, "stderr") == 0) {
+    fd = kStderrFd;
+  } else {
+    internal_snprintf(path_prefix, kMaxPathLength, "%s", path);
+  }
+}
+
+// PID of the tracer task in StopTheWorld. It shares the address space with the
+// main process, but has a different PID and thus requires special handling.
+uptr stoptheworld_tracer_pid = 0;
+// Cached pid of parent process - if the parent process dies, we want to keep
+// writing to the same log file.
+uptr stoptheworld_tracer_ppid = 0;
+
+static const int kMaxNumOfInternalDieCallbacks = 5;
+static DieCallbackType InternalDieCallbacks[kMaxNumOfInternalDieCallbacks];
+
+bool AddDieCallback(DieCallbackType callback) {
+  for (int i = 0; i < kMaxNumOfInternalDieCallbacks; i++) {
+    if (InternalDieCallbacks[i] == nullptr) {
+      InternalDieCallbacks[i] = callback;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool RemoveDieCallback(DieCallbackType callback) {
+  for (int i = 0; i < kMaxNumOfInternalDieCallbacks; i++) {
+    if (InternalDieCallbacks[i] == callback) {
+      internal_memmove(&InternalDieCallbacks[i], &InternalDieCallbacks[i + 1],
+                       sizeof(InternalDieCallbacks[0]) *
+                           (kMaxNumOfInternalDieCallbacks - i - 1));
+      InternalDieCallbacks[kMaxNumOfInternalDieCallbacks - 1] = nullptr;
+      return true;
+    }
+  }
+  return false;
+}
+
+static DieCallbackType UserDieCallback;
+void SetUserDieCallback(DieCallbackType callback) {
+  UserDieCallback = callback;
+}
+
+void NORETURN Die() {
+  if (UserDieCallback)
+    UserDieCallback();
+  for (int i = kMaxNumOfInternalDieCallbacks - 1; i >= 0; i--) {
+    if (InternalDieCallbacks[i])
+      InternalDieCallbacks[i]();
+  }
+  if (common_flags()->abort_on_error)
+    Abort();
+  internal__exit(common_flags()->exitcode);
+}
+
+static CheckFailedCallbackType CheckFailedCallback;
+void SetCheckFailedCallback(CheckFailedCallbackType callback) {
+  CheckFailedCallback = callback;
+}
+
+void NORETURN CheckFailed(const char *file, int line, const char *cond,
+                          u64 v1, u64 v2) {
+  if (CheckFailedCallback) {
+    CheckFailedCallback(file, line, cond, v1, v2);
+  }
+  Report("Sanitizer CHECK failed: %s:%d %s (%lld, %lld)\n", file, line, cond,
+                                                            v1, v2);
+  Die();
+}
+
+void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
+                                      const char *mmap_type, error_t err,
+                                      bool raw_report) {
+  static int recursion_count;
+  if (raw_report || recursion_count) {
+    // If raw report is requested or we went into recursion, just die.
+    // The Report() and CHECK calls below may call mmap recursively and fail.
+    RawWrite("ERROR: Failed to mmap\n");
+    Die();
+  }
+  recursion_count++;
+  Report("ERROR: %s failed to "
+         "%s 0x%zx (%zd) bytes of %s (error code: %d)\n",
+         SanitizerToolName, mmap_type, size, size, mem_type, err);
+#ifndef SANITIZER_GO
+  DumpProcessMap();
+#endif
+  UNREACHABLE("unable to mmap");
+}
+
+bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
+                      uptr *read_len, uptr max_len, error_t *errno_p) {
+  uptr PageSize = GetPageSizeCached();
+  uptr kMinFileLen = PageSize;
+  *buff = nullptr;
+  *buff_size = 0;
+  *read_len = 0;
+  // The files we usually open are not seekable, so try different buffer sizes.
+  for (uptr size = kMinFileLen; size <= max_len; size *= 2) {
+    fd_t fd = OpenFile(file_name, RdOnly, errno_p);
+    if (fd == kInvalidFd) return false;
+    UnmapOrDie(*buff, *buff_size);
+    *buff = (char*)MmapOrDie(size, __func__);
+    *buff_size = size;
+    *read_len = 0;
+    // Read up to one page at a time.
+    bool reached_eof = false;
+    while (*read_len + PageSize <= size) {
+      uptr just_read;
+      if (!ReadFromFile(fd, *buff + *read_len, PageSize, &just_read, errno_p)) {
+        UnmapOrDie(*buff, *buff_size);
+        return false;
+      }
+      if (just_read == 0) {
+        reached_eof = true;
+        break;
+      }
+      *read_len += just_read;
+    }
+    CloseFile(fd);
+    if (reached_eof)  // We've read the whole file.
+      break;
+  }
+  return true;
+}
+
+typedef bool UptrComparisonFunction(const uptr &a, const uptr &b);
+
+template<class T>
+static inline bool CompareLess(const T &a, const T &b) {
+  return a < b;
+}
+
+void SortArray(uptr *array, uptr size) {
+  InternalSort<uptr*, UptrComparisonFunction>(&array, size, CompareLess);
+}
+
+// We want to map a chunk of address space aligned to 'alignment'.
+// We do it by maping a bit more and then unmaping redundant pieces.
+// We probably can do it with fewer syscalls in some OS-dependent way.
+void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) {
+// uptr PageSize = GetPageSizeCached();
+  CHECK(IsPowerOfTwo(size));
+  CHECK(IsPowerOfTwo(alignment));
+  uptr map_size = size + alignment;
+  uptr map_res = (uptr)MmapOrDie(map_size, mem_type);
+  uptr map_end = map_res + map_size;
+  uptr res = map_res;
+  if (res & (alignment - 1))  // Not aligned.
+    res = (map_res + alignment) & ~(alignment - 1);
+  uptr end = res + size;
+  if (res != map_res)
+    UnmapOrDie((void*)map_res, res - map_res);
+  if (end != map_end)
+    UnmapOrDie((void*)end, map_end - end);
+  return (void*)res;
+}
+
+const char *StripPathPrefix(const char *filepath,
+                            const char *strip_path_prefix) {
+  if (!filepath) return nullptr;
+  if (!strip_path_prefix) return filepath;
+  const char *res = filepath;
+  if (const char *pos = internal_strstr(filepath, strip_path_prefix))
+    res = pos + internal_strlen(strip_path_prefix);
+  if (res[0] == '.' && res[1] == '/')
+    res += 2;
+  return res;
+}
+
+const char *StripModuleName(const char *module) {
+  if (!module)
+    return nullptr;
+  if (SANITIZER_WINDOWS) {
+    // On Windows, both slash and backslash are possible.
+    // Pick the one that goes last.
+    if (const char *bslash_pos = internal_strrchr(module, '\\'))
+      return StripModuleName(bslash_pos + 1);
+  }
+  if (const char *slash_pos = internal_strrchr(module, '/')) {
+    return slash_pos + 1;
+  }
+  return module;
+}
+
+void ReportErrorSummary(const char *error_message) {
+  if (!common_flags()->print_summary)
+    return;
+  InternalScopedString buff(kMaxSummaryLength);
+  buff.append("SUMMARY: %s: %s", SanitizerToolName, error_message);
+  __sanitizer_report_error_summary(buff.data());
+}
+
+#ifndef SANITIZER_GO
+void ReportErrorSummary(const char *error_type, const AddressInfo &info) {
+  if (!common_flags()->print_summary)
+    return;
+  InternalScopedString buff(kMaxSummaryLength);
+  buff.append("%s ", error_type);
+  RenderFrame(&buff, "%L %F", 0, info, common_flags()->symbolize_vs_style,
+              common_flags()->strip_path_prefix);
+  ReportErrorSummary(buff.data());
+}
+#endif
+
+// Removes the ANSI escape sequences from the input string (in-place).
+void RemoveANSIEscapeSequencesFromString(char *str) {
+  if (!str)
+    return;
+
+  // We are going to remove the escape sequences in place.
+  char *s = str;
+  char *z = str;
+  while (*s != '\0') {
+    CHECK_GE(s, z);
+    // Skip over ANSI escape sequences with pointer 's'.
+    if (*s == '\033' && *(s + 1) == '[') {
+      s = internal_strchrnul(s, 'm');
+      if (*s == '\0') {
+        break;
+      }
+      s++;
+      continue;
+    }
+    // 's' now points at a character we want to keep. Copy over the buffer
+    // content if the escape sequence has been perviously skipped andadvance
+    // both pointers.
+    if (s != z)
+      *z = *s;
+
+    // If we have not seen an escape sequence, just advance both pointers.
+    z++;
+    s++;
+  }
+
+  // Null terminate the string.
+  *z = '\0';
+}
+
+void LoadedModule::set(const char *module_name, uptr base_address) {
+  clear();
+  full_name_ = internal_strdup(module_name);
+  base_address_ = base_address;
+}
+
+void LoadedModule::clear() {
+  InternalFree(full_name_);
+  full_name_ = nullptr;
+  while (!ranges_.empty()) {
+    AddressRange *r = ranges_.front();
+    ranges_.pop_front();
+    InternalFree(r);
+  }
+}
+
+void LoadedModule::addAddressRange(uptr beg, uptr end, bool executable) {
+  void *mem = InternalAlloc(sizeof(AddressRange));
+  AddressRange *r = new(mem) AddressRange(beg, end, executable);
+  ranges_.push_back(r);
+}
+
+bool LoadedModule::containsAddress(uptr address) const {
+  for (Iterator iter = ranges(); iter.hasNext();) {
+    const AddressRange *r = iter.next();
+    if (r->beg <= address && address < r->end)
+      return true;
+  }
+  return false;
+}
+
+static atomic_uintptr_t g_total_mmaped;
+
+void IncreaseTotalMmap(uptr size) {
+  if (!common_flags()->mmap_limit_mb) return;
+  uptr total_mmaped =
+      atomic_fetch_add(&g_total_mmaped, size, memory_order_relaxed) + size;
+  // Since for now mmap_limit_mb is not a user-facing flag, just kill
+  // a program. Use RAW_CHECK to avoid extra mmaps in reporting.
+  RAW_CHECK((total_mmaped >> 20) < common_flags()->mmap_limit_mb);
+}
+
+void DecreaseTotalMmap(uptr size) {
+  if (!common_flags()->mmap_limit_mb) return;
+  atomic_fetch_sub(&g_total_mmaped, size, memory_order_relaxed);
+}
+
+bool TemplateMatch(const char *templ, const char *str) {
+  if ((!str) || str[0] == 0)
+    return false;
+  bool start = false;
+  if (templ && templ[0] == '^') {
+    start = true;
+    templ++;
+  }
+  bool asterisk = false;
+  while (templ && templ[0]) {
+    if (templ[0] == '*') {
+      templ++;
+      start = false;
+      asterisk = true;
+      continue;
+    }
+    if (templ[0] == '$')
+      return str[0] == 0 || asterisk;
+    if (str[0] == 0)
+      return false;
+    char *tpos = (char*)internal_strchr(templ, '*');
+    char *tpos1 = (char*)internal_strchr(templ, '$');
+    if ((!tpos) || (tpos1 && tpos1 < tpos))
+      tpos = tpos1;
+    if (tpos)
+      tpos[0] = 0;
+    const char *str0 = str;
+    const char *spos = internal_strstr(str, templ);
+    str = spos + internal_strlen(templ);
+    templ = tpos;
+    if (tpos)
+      tpos[0] = tpos == tpos1 ? '$' : '*';
+    if (!spos)
+      return false;
+    if (start && spos != str0)
+      return false;
+    start = false;
+    asterisk = false;
+  }
+  return true;
+}
+
+static const char kPathSeparator = SANITIZER_WINDOWS ? ';' : ':';
+
+char *FindPathToBinary(const char *name) {
+  const char *path = GetEnv("PATH");
+  if (!path)
+    return nullptr;
+  uptr name_len = internal_strlen(name);
+  InternalScopedBuffer<char> buffer(kMaxPathLength);
+  const char *beg = path;
+  while (true) {
+    const char *end = internal_strchrnul(beg, kPathSeparator);
+    uptr prefix_len = end - beg;
+    if (prefix_len + name_len + 2 <= kMaxPathLength) {
+      internal_memcpy(buffer.data(), beg, prefix_len);
+      buffer[prefix_len] = '/';
+      internal_memcpy(&buffer[prefix_len + 1], name, name_len);
+      buffer[prefix_len + 1 + name_len] = '\0';
+      if (FileExists(buffer.data()))
+        return internal_strdup(buffer.data());
+    }
+    if (*end == '\0') break;
+    beg = end + 1;
+  }
+  return nullptr;
+}
+
+static char binary_name_cache_str[kMaxPathLength];
+static char process_name_cache_str[kMaxPathLength];
+
+const char *GetProcessName() {
+  return process_name_cache_str;
+}
+
+static uptr ReadProcessName(/*out*/ char *buf, uptr buf_len) {
+  ReadLongProcessName(buf, buf_len);
+  char *s = const_cast<char *>(StripModuleName(buf));
+  uptr len = internal_strlen(s);
+  if (s != buf) {
+    internal_memmove(buf, s, len);
+    buf[len] = '\0';
+  }
+  return len;
+}
+
+void UpdateProcessName() {
+  ReadProcessName(process_name_cache_str, sizeof(process_name_cache_str));
+}
+
+// Call once to make sure that binary_name_cache_str is initialized
+void CacheBinaryName() {
+  if (binary_name_cache_str[0] != '\0')
+    return;
+  ReadBinaryName(binary_name_cache_str, sizeof(binary_name_cache_str));
+  ReadProcessName(process_name_cache_str, sizeof(process_name_cache_str));
+}
+
+uptr ReadBinaryNameCached(/*out*/char *buf, uptr buf_len) {
+  CacheBinaryName();
+  uptr name_len = internal_strlen(binary_name_cache_str);
+  name_len = (name_len < buf_len - 1) ? name_len : buf_len - 1;
+  if (buf_len == 0)
+    return 0;
+  internal_memcpy(buf, binary_name_cache_str, name_len);
+  buf[name_len] = '\0';
+  return name_len;
+}
+
+} // namespace __sanitizer
+
+using namespace __sanitizer;  // NOLINT
+
+extern "C" {
+void __sanitizer_set_report_path(const char *path) {
+  report_file.SetReportPath(path);
+}
+
+void __sanitizer_report_error_summary(const char *error_summary) {
+  Printf("%s\n", error_summary);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_set_death_callback(void (*callback)(void)) {
+  SetUserDieCallback(callback);
+}
+} // extern "C"
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common.h b/compiler-rt/lib/sanitizer_common/sanitizer_common.h
new file mode 100644
index 0000000..0585f6b
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common.h
@@ -0,0 +1,749 @@
+//===-- sanitizer_common.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between run-time libraries of sanitizers.
+//
+// It declares common functions and classes that are used in both runtimes.
+// Implementation of some functions are provided in sanitizer_common, while
+// others must be defined by run-time library itself.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_COMMON_H
+#define SANITIZER_COMMON_H
+
+#include "sanitizer_flags.h"
+#include "sanitizer_interface_internal.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_list.h"
+#include "sanitizer_mutex.h"
+
+#ifdef _MSC_VER
+extern "C" void _ReadWriteBarrier();
+#pragma intrinsic(_ReadWriteBarrier)
+#endif
+
+namespace __sanitizer {
+struct StackTrace;
+struct AddressInfo;
+
+// Constants.
+const uptr kWordSize = SANITIZER_WORDSIZE / 8;
+const uptr kWordSizeInBits = 8 * kWordSize;
+
+#if defined(__powerpc__) || defined(__powerpc64__)
+  const uptr kCacheLineSize = 128;
+#else
+  const uptr kCacheLineSize = 64;
+#endif
+
+const uptr kMaxPathLength = 4096;
+
+// 16K loaded modules should be enough for everyone.
+static const uptr kMaxNumberOfModules = 1 << 14;
+
+const uptr kMaxThreadStackSize = 1 << 30;  // 1Gb
+
+static const uptr kErrorMessageBufferSize = 1 << 16;
+
+// Denotes fake PC values that come from JIT/JAVA/etc.
+// For such PC values __tsan_symbolize_external() will be called.
+const u64 kExternalPCBit = 1ULL << 60;
+
+extern const char *SanitizerToolName;  // Can be changed by the tool.
+
+extern atomic_uint32_t current_verbosity;
+INLINE void SetVerbosity(int verbosity) {
+  atomic_store(&current_verbosity, verbosity, memory_order_relaxed);
+}
+INLINE int Verbosity() {
+  return atomic_load(&current_verbosity, memory_order_relaxed);
+}
+
+uptr GetPageSize();
+uptr GetPageSizeCached();
+uptr GetMmapGranularity();
+uptr GetMaxVirtualAddress();
+// Threads
+uptr GetTid();
+uptr GetThreadSelf();
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+                                uptr *stack_bottom);
+void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
+                          uptr *tls_addr, uptr *tls_size);
+
+// Memory management
+void *MmapOrDie(uptr size, const char *mem_type, bool raw_report = false);
+INLINE void *MmapOrDieQuietly(uptr size, const char *mem_type) {
+  return MmapOrDie(size, mem_type, /*raw_report*/ true);
+}
+void UnmapOrDie(void *addr, uptr size);
+void *MmapFixedNoReserve(uptr fixed_addr, uptr size,
+                         const char *name = nullptr);
+void *MmapNoReserveOrDie(uptr size, const char *mem_type);
+void *MmapFixedOrDie(uptr fixed_addr, uptr size);
+void *MmapNoAccess(uptr fixed_addr, uptr size, const char *name = nullptr);
+// Map aligned chunk of address space; size and alignment are powers of two.
+void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type);
+// Disallow access to a memory range.  Use MmapNoAccess to allocate an
+// unaccessible memory.
+bool MprotectNoAccess(uptr addr, uptr size);
+
+// Used to check if we can map shadow memory to a fixed location.
+bool MemoryRangeIsAvailable(uptr range_start, uptr range_end);
+void FlushUnneededShadowMemory(uptr addr, uptr size);
+void IncreaseTotalMmap(uptr size);
+void DecreaseTotalMmap(uptr size);
+uptr GetRSS();
+void NoHugePagesInRegion(uptr addr, uptr length);
+void DontDumpShadowMemory(uptr addr, uptr length);
+// Check if the built VMA size matches the runtime one.
+void CheckVMASize();
+
+// InternalScopedBuffer can be used instead of large stack arrays to
+// keep frame size low.
+// FIXME: use InternalAlloc instead of MmapOrDie once
+// InternalAlloc is made libc-free.
+template<typename T>
+class InternalScopedBuffer {
+ public:
+  explicit InternalScopedBuffer(uptr cnt) {
+    cnt_ = cnt;
+    ptr_ = (T*)MmapOrDie(cnt * sizeof(T), "InternalScopedBuffer");
+  }
+  ~InternalScopedBuffer() {
+    UnmapOrDie(ptr_, cnt_ * sizeof(T));
+  }
+  T &operator[](uptr i) { return ptr_[i]; }
+  T *data() { return ptr_; }
+  uptr size() { return cnt_ * sizeof(T); }
+
+ private:
+  T *ptr_;
+  uptr cnt_;
+  // Disallow evil constructors.
+  InternalScopedBuffer(const InternalScopedBuffer&);
+  void operator=(const InternalScopedBuffer&);
+};
+
+class InternalScopedString : public InternalScopedBuffer<char> {
+ public:
+  explicit InternalScopedString(uptr max_length)
+      : InternalScopedBuffer<char>(max_length), length_(0) {
+    (*this)[0] = '\0';
+  }
+  uptr length() { return length_; }
+  void clear() {
+    (*this)[0] = '\0';
+    length_ = 0;
+  }
+  void append(const char *format, ...);
+
+ private:
+  uptr length_;
+};
+
+// Simple low-level (mmap-based) allocator for internal use. Doesn't have
+// constructor, so all instances of LowLevelAllocator should be
+// linker initialized.
+class LowLevelAllocator {
+ public:
+  // Requires an external lock.
+  void *Allocate(uptr size);
+ private:
+  char *allocated_end_;
+  char *allocated_current_;
+};
+typedef void (*LowLevelAllocateCallback)(uptr ptr, uptr size);
+// Allows to register tool-specific callbacks for LowLevelAllocator.
+// Passing NULL removes the callback.
+void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback);
+
+// IO
+void RawWrite(const char *buffer);
+bool ColorizeReports();
+void RemoveANSIEscapeSequencesFromString(char *buffer);
+void Printf(const char *format, ...);
+void Report(const char *format, ...);
+void SetPrintfAndReportCallback(void (*callback)(const char *));
+#define VReport(level, ...)                                              \
+  do {                                                                   \
+    if ((uptr)Verbosity() >= (level)) Report(__VA_ARGS__); \
+  } while (0)
+#define VPrintf(level, ...)                                              \
+  do {                                                                   \
+    if ((uptr)Verbosity() >= (level)) Printf(__VA_ARGS__); \
+  } while (0)
+
+// Can be used to prevent mixing error reports from different sanitizers.
+extern StaticSpinMutex CommonSanitizerReportMutex;
+
+struct ReportFile {
+  void Write(const char *buffer, uptr length);
+  bool SupportsColors();
+  void SetReportPath(const char *path);
+
+  // Don't use fields directly. They are only declared public to allow
+  // aggregate initialization.
+
+  // Protects fields below.
+  StaticSpinMutex *mu;
+  // Opened file descriptor. Defaults to stderr. It may be equal to
+  // kInvalidFd, in which case new file will be opened when necessary.
+  fd_t fd;
+  // Path prefix of report file, set via __sanitizer_set_report_path.
+  char path_prefix[kMaxPathLength];
+  // Full path to report, obtained as <path_prefix>.PID
+  char full_path[kMaxPathLength];
+  // PID of the process that opened fd. If a fork() occurs,
+  // the PID of child will be different from fd_pid.
+  uptr fd_pid;
+
+ private:
+  void ReopenIfNecessary();
+};
+extern ReportFile report_file;
+
+extern uptr stoptheworld_tracer_pid;
+extern uptr stoptheworld_tracer_ppid;
+
+enum FileAccessMode {
+  RdOnly,
+  WrOnly,
+  RdWr
+};
+
+// Returns kInvalidFd on error.
+fd_t OpenFile(const char *filename, FileAccessMode mode,
+              error_t *errno_p = nullptr);
+void CloseFile(fd_t);
+
+// Return true on success, false on error.
+bool ReadFromFile(fd_t fd, void *buff, uptr buff_size,
+                  uptr *bytes_read = nullptr, error_t *error_p = nullptr);
+bool WriteToFile(fd_t fd, const void *buff, uptr buff_size,
+                 uptr *bytes_written = nullptr, error_t *error_p = nullptr);
+
+bool RenameFile(const char *oldpath, const char *newpath,
+                error_t *error_p = nullptr);
+
+// Scoped file handle closer.
+struct FileCloser {
+  explicit FileCloser(fd_t fd) : fd(fd) {}
+  ~FileCloser() { CloseFile(fd); }
+  fd_t fd;
+};
+
+bool SupportsColoredOutput(fd_t fd);
+
+// Opens the file 'file_name" and reads up to 'max_len' bytes.
+// The resulting buffer is mmaped and stored in '*buff'.
+// The size of the mmaped region is stored in '*buff_size'.
+// The total number of read bytes is stored in '*read_len'.
+// Returns true if file was successfully opened and read.
+bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
+                      uptr *read_len, uptr max_len = 1 << 26,
+                      error_t *errno_p = nullptr);
+// Maps given file to virtual memory, and returns pointer to it
+// (or NULL if mapping fails). Stores the size of mmaped region
+// in '*buff_size'.
+void *MapFileToMemory(const char *file_name, uptr *buff_size);
+void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset);
+
+bool IsAccessibleMemoryRange(uptr beg, uptr size);
+
+// Error report formatting.
+const char *StripPathPrefix(const char *filepath,
+                            const char *strip_file_prefix);
+// Strip the directories from the module name.
+const char *StripModuleName(const char *module);
+
+// OS
+uptr ReadBinaryName(/*out*/char *buf, uptr buf_len);
+uptr ReadBinaryNameCached(/*out*/char *buf, uptr buf_len);
+uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len);
+const char *GetProcessName();
+void UpdateProcessName();
+void CacheBinaryName();
+void DisableCoreDumperIfNecessary();
+void DumpProcessMap();
+bool FileExists(const char *filename);
+const char *GetEnv(const char *name);
+bool SetEnv(const char *name, const char *value);
+const char *GetPwd();
+char *FindPathToBinary(const char *name);
+bool IsPathSeparator(const char c);
+bool IsAbsolutePath(const char *path);
+
+u32 GetUid();
+void ReExec();
+bool StackSizeIsUnlimited();
+void SetStackSizeLimitInBytes(uptr limit);
+bool AddressSpaceIsUnlimited();
+void SetAddressSpaceUnlimited();
+void AdjustStackSize(void *attr);
+void PrepareForSandboxing(__sanitizer_sandbox_arguments *args);
+void CovPrepareForSandboxing(__sanitizer_sandbox_arguments *args);
+void SetSandboxingCallback(void (*f)());
+
+void CoverageUpdateMapping();
+void CovBeforeFork();
+void CovAfterFork(int child_pid);
+
+void InitializeCoverage(bool enabled, const char *coverage_dir);
+void ReInitializeCoverage(bool enabled, const char *coverage_dir);
+
+void InitTlsSize();
+uptr GetTlsSize();
+
+// Other
+void SleepForSeconds(int seconds);
+void SleepForMillis(int millis);
+u64 NanoTime();
+int Atexit(void (*function)(void));
+void SortArray(uptr *array, uptr size);
+bool TemplateMatch(const char *templ, const char *str);
+
+// Exit
+void NORETURN Abort();
+void NORETURN Die();
+void NORETURN
+CheckFailed(const char *file, int line, const char *cond, u64 v1, u64 v2);
+void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
+                                      const char *mmap_type, error_t err,
+                                      bool raw_report = false);
+
+// Set the name of the current thread to 'name', return true on succees.
+// The name may be truncated to a system-dependent limit.
+bool SanitizerSetThreadName(const char *name);
+// Get the name of the current thread (no more than max_len bytes),
+// return true on succees. name should have space for at least max_len+1 bytes.
+bool SanitizerGetThreadName(char *name, int max_len);
+
+// Specific tools may override behavior of "Die" and "CheckFailed" functions
+// to do tool-specific job.
+typedef void (*DieCallbackType)(void);
+
+// It's possible to add several callbacks that would be run when "Die" is
+// called. The callbacks will be run in the opposite order. The tools are
+// strongly recommended to setup all callbacks during initialization, when there
+// is only a single thread.
+bool AddDieCallback(DieCallbackType callback);
+bool RemoveDieCallback(DieCallbackType callback);
+
+void SetUserDieCallback(DieCallbackType callback);
+
+typedef void (*CheckFailedCallbackType)(const char *, int, const char *,
+                                       u64, u64);
+void SetCheckFailedCallback(CheckFailedCallbackType callback);
+
+// Callback will be called if soft_rss_limit_mb is given and the limit is
+// exceeded (exceeded==true) or if rss went down below the limit
+// (exceeded==false).
+// The callback should be registered once at the tool init time.
+void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded));
+
+// Functions related to signal handling.
+typedef void (*SignalHandlerType)(int, void *, void *);
+bool IsDeadlySignal(int signum);
+void InstallDeadlySignalHandlers(SignalHandlerType handler);
+// Alternative signal stack (POSIX-only).
+void SetAlternateSignalStack();
+void UnsetAlternateSignalStack();
+
+// We don't want a summary too long.
+const int kMaxSummaryLength = 1024;
+// Construct a one-line string:
+//   SUMMARY: SanitizerToolName: error_message
+// and pass it to __sanitizer_report_error_summary.
+void ReportErrorSummary(const char *error_message);
+// Same as above, but construct error_message as:
+//   error_type file:line[:column][ function]
+void ReportErrorSummary(const char *error_type, const AddressInfo &info);
+// Same as above, but obtains AddressInfo by symbolizing top stack trace frame.
+void ReportErrorSummary(const char *error_type, StackTrace *trace);
+
+// Math
+#if SANITIZER_WINDOWS && !defined(__clang__) && !defined(__GNUC__)
+extern "C" {
+unsigned char _BitScanForward(unsigned long *index, unsigned long mask);  // NOLINT
+unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);  // NOLINT
+#if defined(_WIN64)
+unsigned char _BitScanForward64(unsigned long *index, unsigned __int64 mask);  // NOLINT
+unsigned char _BitScanReverse64(unsigned long *index, unsigned __int64 mask);  // NOLINT
+#endif
+}
+#endif
+
+INLINE uptr MostSignificantSetBitIndex(uptr x) {
+  CHECK_NE(x, 0U);
+  unsigned long up;  // NOLINT
+#if !SANITIZER_WINDOWS || defined(__clang__) || defined(__GNUC__)
+# ifdef _WIN64
+  up = SANITIZER_WORDSIZE - 1 - __builtin_clzll(x);
+# else
+  up = SANITIZER_WORDSIZE - 1 - __builtin_clzl(x);
+# endif
+#elif defined(_WIN64)
+  _BitScanReverse64(&up, x);
+#else
+  _BitScanReverse(&up, x);
+#endif
+  return up;
+}
+
+INLINE uptr LeastSignificantSetBitIndex(uptr x) {
+  CHECK_NE(x, 0U);
+  unsigned long up;  // NOLINT
+#if !SANITIZER_WINDOWS || defined(__clang__) || defined(__GNUC__)
+# ifdef _WIN64
+  up = __builtin_ctzll(x);
+# else
+  up = __builtin_ctzl(x);
+# endif
+#elif defined(_WIN64)
+  _BitScanForward64(&up, x);
+#else
+  _BitScanForward(&up, x);
+#endif
+  return up;
+}
+
+INLINE bool IsPowerOfTwo(uptr x) {
+  return (x & (x - 1)) == 0;
+}
+
+INLINE uptr RoundUpToPowerOfTwo(uptr size) {
+  CHECK(size);
+  if (IsPowerOfTwo(size)) return size;
+
+  uptr up = MostSignificantSetBitIndex(size);
+  CHECK(size < (1ULL << (up + 1)));
+  CHECK(size > (1ULL << up));
+  return 1ULL << (up + 1);
+}
+
+INLINE uptr RoundUpTo(uptr size, uptr boundary) {
+  RAW_CHECK(IsPowerOfTwo(boundary));
+  return (size + boundary - 1) & ~(boundary - 1);
+}
+
+INLINE uptr RoundDownTo(uptr x, uptr boundary) {
+  return x & ~(boundary - 1);
+}
+
+INLINE bool IsAligned(uptr a, uptr alignment) {
+  return (a & (alignment - 1)) == 0;
+}
+
+INLINE uptr Log2(uptr x) {
+  CHECK(IsPowerOfTwo(x));
+  return LeastSignificantSetBitIndex(x);
+}
+
+// Don't use std::min, std::max or std::swap, to minimize dependency
+// on libstdc++.
+template<class T> T Min(T a, T b) { return a < b ? a : b; }
+template<class T> T Max(T a, T b) { return a > b ? a : b; }
+template<class T> void Swap(T& a, T& b) {
+  T tmp = a;
+  a = b;
+  b = tmp;
+}
+
+// Char handling
+INLINE bool IsSpace(int c) {
+  return (c == ' ') || (c == '\n') || (c == '\t') ||
+         (c == '\f') || (c == '\r') || (c == '\v');
+}
+INLINE bool IsDigit(int c) {
+  return (c >= '0') && (c <= '9');
+}
+INLINE int ToLower(int c) {
+  return (c >= 'A' && c <= 'Z') ? (c + 'a' - 'A') : c;
+}
+
+// A low-level vector based on mmap. May incur a significant memory overhead for
+// small vectors.
+// WARNING: The current implementation supports only POD types.
+template<typename T>
+class InternalMmapVectorNoCtor {
+ public:
+  void Initialize(uptr initial_capacity) {
+    capacity_ = Max(initial_capacity, (uptr)1);
+    size_ = 0;
+    data_ = (T *)MmapOrDie(capacity_ * sizeof(T), "InternalMmapVectorNoCtor");
+  }
+  void Destroy() {
+    UnmapOrDie(data_, capacity_ * sizeof(T));
+  }
+  T &operator[](uptr i) {
+    CHECK_LT(i, size_);
+    return data_[i];
+  }
+  const T &operator[](uptr i) const {
+    CHECK_LT(i, size_);
+    return data_[i];
+  }
+  void push_back(const T &element) {
+    CHECK_LE(size_, capacity_);
+    if (size_ == capacity_) {
+      uptr new_capacity = RoundUpToPowerOfTwo(size_ + 1);
+      Resize(new_capacity);
+    }
+    data_[size_++] = element;
+  }
+  T &back() {
+    CHECK_GT(size_, 0);
+    return data_[size_ - 1];
+  }
+  void pop_back() {
+    CHECK_GT(size_, 0);
+    size_--;
+  }
+  uptr size() const {
+    return size_;
+  }
+  const T *data() const {
+    return data_;
+  }
+  T *data() {
+    return data_;
+  }
+  uptr capacity() const {
+    return capacity_;
+  }
+
+  void clear() { size_ = 0; }
+  bool empty() const { return size() == 0; }
+
+ private:
+  void Resize(uptr new_capacity) {
+    CHECK_GT(new_capacity, 0);
+    CHECK_LE(size_, new_capacity);
+    T *new_data = (T *)MmapOrDie(new_capacity * sizeof(T),
+                                 "InternalMmapVector");
+    internal_memcpy(new_data, data_, size_ * sizeof(T));
+    T *old_data = data_;
+    data_ = new_data;
+    UnmapOrDie(old_data, capacity_ * sizeof(T));
+    capacity_ = new_capacity;
+  }
+
+  T *data_;
+  uptr capacity_;
+  uptr size_;
+};
+
+template<typename T>
+class InternalMmapVector : public InternalMmapVectorNoCtor<T> {
+ public:
+  explicit InternalMmapVector(uptr initial_capacity) {
+    InternalMmapVectorNoCtor<T>::Initialize(initial_capacity);
+  }
+  ~InternalMmapVector() { InternalMmapVectorNoCtor<T>::Destroy(); }
+  // Disallow evil constructors.
+  InternalMmapVector(const InternalMmapVector&);
+  void operator=(const InternalMmapVector&);
+};
+
+// HeapSort for arrays and InternalMmapVector.
+template<class Container, class Compare>
+void InternalSort(Container *v, uptr size, Compare comp) {
+  if (size < 2)
+    return;
+  // Stage 1: insert elements to the heap.
+  for (uptr i = 1; i < size; i++) {
+    uptr j, p;
+    for (j = i; j > 0; j = p) {
+      p = (j - 1) / 2;
+      if (comp((*v)[p], (*v)[j]))
+        Swap((*v)[j], (*v)[p]);
+      else
+        break;
+    }
+  }
+  // Stage 2: swap largest element with the last one,
+  // and sink the new top.
+  for (uptr i = size - 1; i > 0; i--) {
+    Swap((*v)[0], (*v)[i]);
+    uptr j, max_ind;
+    for (j = 0; j < i; j = max_ind) {
+      uptr left = 2 * j + 1;
+      uptr right = 2 * j + 2;
+      max_ind = j;
+      if (left < i && comp((*v)[max_ind], (*v)[left]))
+        max_ind = left;
+      if (right < i && comp((*v)[max_ind], (*v)[right]))
+        max_ind = right;
+      if (max_ind != j)
+        Swap((*v)[j], (*v)[max_ind]);
+      else
+        break;
+    }
+  }
+}
+
+template<class Container, class Value, class Compare>
+uptr InternalBinarySearch(const Container &v, uptr first, uptr last,
+                          const Value &val, Compare comp) {
+  uptr not_found = last + 1;
+  while (last >= first) {
+    uptr mid = (first + last) / 2;
+    if (comp(v[mid], val))
+      first = mid + 1;
+    else if (comp(val, v[mid]))
+      last = mid - 1;
+    else
+      return mid;
+  }
+  return not_found;
+}
+
+// Represents a binary loaded into virtual memory (e.g. this can be an
+// executable or a shared object).
+class LoadedModule {
+ public:
+  LoadedModule() : full_name_(nullptr), base_address_(0) { ranges_.clear(); }
+  void set(const char *module_name, uptr base_address);
+  void clear();
+  void addAddressRange(uptr beg, uptr end, bool executable);
+  bool containsAddress(uptr address) const;
+
+  const char *full_name() const { return full_name_; }
+  uptr base_address() const { return base_address_; }
+
+  struct AddressRange {
+    AddressRange *next;
+    uptr beg;
+    uptr end;
+    bool executable;
+
+    AddressRange(uptr beg, uptr end, bool executable)
+        : next(nullptr), beg(beg), end(end), executable(executable) {}
+  };
+
+  typedef IntrusiveList<AddressRange>::ConstIterator Iterator;
+  Iterator ranges() const { return Iterator(&ranges_); }
+
+ private:
+  char *full_name_;  // Owned.
+  uptr base_address_;
+  IntrusiveList<AddressRange> ranges_;
+};
+
+// OS-dependent function that fills array with descriptions of at most
+// "max_modules" currently loaded modules. Returns the number of
+// initialized modules. If filter is nonzero, ignores modules for which
+// filter(full_name) is false.
+typedef bool (*string_predicate_t)(const char *);
+uptr GetListOfModules(LoadedModule *modules, uptr max_modules,
+                      string_predicate_t filter);
+
+// Callback type for iterating over a set of memory ranges.
+typedef void (*RangeIteratorCallback)(uptr begin, uptr end, void *arg);
+
+enum AndroidApiLevel {
+  ANDROID_NOT_ANDROID = 0,
+  ANDROID_KITKAT = 19,
+  ANDROID_LOLLIPOP_MR1 = 22,
+  ANDROID_POST_LOLLIPOP = 23
+};
+
+void WriteToSyslog(const char *buffer);
+
+#if SANITIZER_MAC
+void LogFullErrorReport(const char *buffer);
+#else
+INLINE void LogFullErrorReport(const char *buffer) {}
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_MAC
+void WriteOneLineToSyslog(const char *s);
+#else
+INLINE void WriteOneLineToSyslog(const char *s) {}
+#endif
+
+#if SANITIZER_LINUX
+// Initialize Android logging. Any writes before this are silently lost.
+void AndroidLogInit();
+bool ShouldLogAfterPrintf();
+#else
+INLINE void AndroidLogInit() {}
+INLINE bool ShouldLogAfterPrintf() { return false; }
+#endif
+
+#if SANITIZER_ANDROID
+void SanitizerInitializeUnwinder();
+AndroidApiLevel AndroidGetApiLevel();
+#else
+INLINE void AndroidLogWrite(const char *buffer_unused) {}
+INLINE void SanitizerInitializeUnwinder() {}
+INLINE AndroidApiLevel AndroidGetApiLevel() { return ANDROID_NOT_ANDROID; }
+#endif
+
+INLINE uptr GetPthreadDestructorIterations() {
+#if SANITIZER_ANDROID
+  return (AndroidGetApiLevel() == ANDROID_LOLLIPOP_MR1) ? 8 : 4;
+#elif SANITIZER_POSIX
+  return 4;
+#else
+// Unused on Windows.
+  return 0;
+#endif
+}
+
+void *internal_start_thread(void(*func)(void*), void *arg);
+void internal_join_thread(void *th);
+void MaybeStartBackgroudThread();
+
+// Make the compiler think that something is going on there.
+// Use this inside a loop that looks like memset/memcpy/etc to prevent the
+// compiler from recognising it and turning it into an actual call to
+// memset/memcpy/etc.
+static inline void SanitizerBreakOptimization(void *arg) {
+#if _MSC_VER && !defined(__clang__)
+  _ReadWriteBarrier();
+#else
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+#endif
+}
+
+struct SignalContext {
+  void *context;
+  uptr addr;
+  uptr pc;
+  uptr sp;
+  uptr bp;
+
+  SignalContext(void *context, uptr addr, uptr pc, uptr sp, uptr bp) :
+      context(context), addr(addr), pc(pc), sp(sp), bp(bp) {
+  }
+
+  // Creates signal context in a platform-specific manner.
+  static SignalContext Create(void *siginfo, void *context);
+};
+
+void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp);
+
+void DisableReexec();
+void MaybeReexec();
+
+}  // namespace __sanitizer
+
+inline void *operator new(__sanitizer::operator_new_size_type size,
+                          __sanitizer::LowLevelAllocator &alloc) {
+  return alloc.Allocate(size);
+}
+
+struct StackDepotStats {
+  uptr n_uniq_ids;
+  uptr allocated;
+};
+
+#endif  // SANITIZER_COMMON_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc
new file mode 100644
index 0000000..4639ddc
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc
@@ -0,0 +1,5494 @@
+//===-- sanitizer_common_interceptors.inc -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Common function interceptors for tools like AddressSanitizer,
+// ThreadSanitizer, MemorySanitizer, etc.
+//
+// This file should be included into the tool's interceptor file,
+// which has to define it's own macros:
+//   COMMON_INTERCEPTOR_ENTER
+//   COMMON_INTERCEPTOR_ENTER_NOIGNORE
+//   COMMON_INTERCEPTOR_READ_RANGE
+//   COMMON_INTERCEPTOR_WRITE_RANGE
+//   COMMON_INTERCEPTOR_INITIALIZE_RANGE
+//   COMMON_INTERCEPTOR_DIR_ACQUIRE
+//   COMMON_INTERCEPTOR_FD_ACQUIRE
+//   COMMON_INTERCEPTOR_FD_RELEASE
+//   COMMON_INTERCEPTOR_FD_ACCESS
+//   COMMON_INTERCEPTOR_SET_THREAD_NAME
+//   COMMON_INTERCEPTOR_ON_DLOPEN
+//   COMMON_INTERCEPTOR_ON_EXIT
+//   COMMON_INTERCEPTOR_MUTEX_LOCK
+//   COMMON_INTERCEPTOR_MUTEX_UNLOCK
+//   COMMON_INTERCEPTOR_MUTEX_REPAIR
+//   COMMON_INTERCEPTOR_SET_PTHREAD_NAME
+//   COMMON_INTERCEPTOR_HANDLE_RECVMSG
+//   COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED
+//===----------------------------------------------------------------------===//
+
+#include "interception/interception.h"
+#include "sanitizer_addrhashmap.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_platform_interceptors.h"
+#include "sanitizer_tls_get_addr.h"
+
+#include <stdarg.h>
+
+#if SANITIZER_INTERCEPTOR_HOOKS
+#define CALL_WEAK_INTERCEPTOR_HOOK(f, ...)                                     \
+  do {                                                                         \
+    if (f)                                                                     \
+      f(__VA_ARGS__);                                                          \
+  } while (false);
+#define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...)                                  \
+  extern "C" {                                                                 \
+  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void f(__VA_ARGS__);  \
+  } // extern "C"
+#else
+#define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...)
+#define CALL_WEAK_INTERCEPTOR_HOOK(f, ...)
+
+#endif  // SANITIZER_INTERCEPTOR_HOOKS
+
+#if SANITIZER_WINDOWS && !defined(va_copy)
+#define va_copy(dst, src) ((dst) = (src))
+#endif // _WIN32
+
+#if SANITIZER_FREEBSD
+#define pthread_setname_np pthread_set_name_np
+#define inet_aton __inet_aton
+#define inet_pton __inet_pton
+#define iconv __bsd_iconv
+#endif
+
+#ifndef COMMON_INTERCEPTOR_INITIALIZE_RANGE
+#define COMMON_INTERCEPTOR_INITIALIZE_RANGE(p, size) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_UNPOISON_PARAM
+#define COMMON_INTERCEPTOR_UNPOISON_PARAM(count) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_FD_ACCESS
+#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_MUTEX_LOCK
+#define COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_MUTEX_UNLOCK
+#define COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_MUTEX_REPAIR
+#define COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_HANDLE_RECVMSG
+#define COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg) ((void)(msg))
+#endif
+
+#ifndef COMMON_INTERCEPTOR_FILE_OPEN
+#define COMMON_INTERCEPTOR_FILE_OPEN(ctx, file, path) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_FILE_CLOSE
+#define COMMON_INTERCEPTOR_FILE_CLOSE(ctx, file) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_LIBRARY_LOADED
+#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_LIBRARY_UNLOADED
+#define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_ENTER_NOIGNORE
+#define COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, ...) \
+  COMMON_INTERCEPTOR_ENTER(ctx, __VA_ARGS__)
+#endif
+
+#ifndef COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED
+#define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (0)
+#endif
+
+#define COMMON_INTERCEPTOR_READ_STRING_OF_LEN(ctx, s, len, n)       \
+    COMMON_INTERCEPTOR_READ_RANGE((ctx), (s),                       \
+      common_flags()->strict_string_checks ? (len) + 1 : (n) )
+
+#define COMMON_INTERCEPTOR_READ_STRING(ctx, s, n)                   \
+    COMMON_INTERCEPTOR_READ_STRING_OF_LEN((ctx), (s), REAL(strlen)(s), (n))
+
+#ifndef COMMON_INTERCEPTOR_ON_DLOPEN
+#define COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_GET_TLS_RANGE
+#define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end) *begin = *end = 0;
+#endif
+
+#ifndef COMMON_INTERCEPTOR_ACQUIRE
+#define COMMON_INTERCEPTOR_ACQUIRE(ctx, u) {}
+#endif
+
+#ifndef COMMON_INTERCEPTOR_RELEASE
+#define COMMON_INTERCEPTOR_RELEASE(ctx, u) {}
+#endif
+
+struct FileMetadata {
+  // For open_memstream().
+  char **addr;
+  SIZE_T *size;
+};
+
+struct CommonInterceptorMetadata {
+  enum {
+    CIMT_INVALID = 0,
+    CIMT_FILE
+  } type;
+  union {
+    FileMetadata file;
+  };
+};
+
+typedef AddrHashMap<CommonInterceptorMetadata, 31051> MetadataHashMap;
+
+static MetadataHashMap *interceptor_metadata_map;
+
+#if SI_NOT_WINDOWS
+UNUSED static void SetInterceptorMetadata(__sanitizer_FILE *addr,
+                                          const FileMetadata &file) {
+  MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr);
+  CHECK(h.created());
+  h->type = CommonInterceptorMetadata::CIMT_FILE;
+  h->file = file;
+}
+
+UNUSED static const FileMetadata *GetInterceptorMetadata(
+    __sanitizer_FILE *addr) {
+  MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr,
+                            /* remove */ false,
+                            /* create */ false);
+  if (h.exists()) {
+    CHECK(!h.created());
+    CHECK(h->type == CommonInterceptorMetadata::CIMT_FILE);
+    return &h->file;
+  } else {
+    return 0;
+  }
+}
+
+UNUSED static void DeleteInterceptorMetadata(void *addr) {
+  MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr, true);
+  CHECK(h.exists());
+}
+#endif  // SI_NOT_WINDOWS
+
+#if SANITIZER_INTERCEPT_TEXTDOMAIN
+INTERCEPTOR(char*, textdomain, const char *domainname) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, textdomain, domainname);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, domainname, 0);
+  char *domain = REAL(textdomain)(domainname);
+  if (domain) {
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(domain, REAL(strlen)(domain) + 1);
+  }
+  return domain;
+}
+#define INIT_TEXTDOMAIN COMMON_INTERCEPT_FUNCTION(textdomain)
+#else
+#define INIT_TEXTDOMAIN
+#endif
+
+#if SANITIZER_INTERCEPT_STRCMP
+static inline int CharCmpX(unsigned char c1, unsigned char c2) {
+  return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;
+}
+
+DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strcmp, uptr called_pc,
+                              const char *s1, const char *s2)
+
+INTERCEPTOR(int, strcmp, const char *s1, const char *s2) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strcmp, s1, s2);
+  CALL_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strcmp, GET_CALLER_PC(), s1,
+                             s2);
+  unsigned char c1, c2;
+  uptr i;
+  for (i = 0;; i++) {
+    c1 = (unsigned char)s1[i];
+    c2 = (unsigned char)s2[i];
+    if (c1 != c2 || c1 == '\0') break;
+  }
+  COMMON_INTERCEPTOR_READ_STRING(ctx, s1, i + 1);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, s2, i + 1);
+  return CharCmpX(c1, c2);
+}
+
+DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strncmp, uptr called_pc,
+                              const char *s1, const char *s2, uptr n)
+
+INTERCEPTOR(int, strncmp, const char *s1, const char *s2, uptr size) {
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
+    return internal_strncmp(s1, s2, size);
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strncmp, s1, s2, size);
+  CALL_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strncmp, GET_CALLER_PC(), s1,
+                             s2, size);
+  unsigned char c1 = 0, c2 = 0;
+  uptr i;
+  for (i = 0; i < size; i++) {
+    c1 = (unsigned char)s1[i];
+    c2 = (unsigned char)s2[i];
+    if (c1 != c2 || c1 == '\0') break;
+  }
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s1, Min(i + 1, size));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, Min(i + 1, size));
+  return CharCmpX(c1, c2);
+}
+
+#define INIT_STRCMP COMMON_INTERCEPT_FUNCTION(strcmp)
+#define INIT_STRNCMP COMMON_INTERCEPT_FUNCTION(strncmp)
+#else
+#define INIT_STRCMP
+#define INIT_STRNCMP
+#endif
+
+#if SANITIZER_INTERCEPT_STRCASECMP
+static inline int CharCaseCmp(unsigned char c1, unsigned char c2) {
+  int c1_low = ToLower(c1);
+  int c2_low = ToLower(c2);
+  return c1_low - c2_low;
+}
+
+INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strcasecmp, s1, s2);
+  unsigned char c1 = 0, c2 = 0;
+  uptr i;
+  for (i = 0;; i++) {
+    c1 = (unsigned char)s1[i];
+    c2 = (unsigned char)s2[i];
+    if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break;
+  }
+  COMMON_INTERCEPTOR_READ_STRING(ctx, s1, i + 1);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, s2, i + 1);
+  return CharCaseCmp(c1, c2);
+}
+
+INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, SIZE_T n) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strncasecmp, s1, s2, n);
+  unsigned char c1 = 0, c2 = 0;
+  uptr i;
+  for (i = 0; i < n; i++) {
+    c1 = (unsigned char)s1[i];
+    c2 = (unsigned char)s2[i];
+    if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break;
+  }
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s1, Min(i + 1, n));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, Min(i + 1, n));
+  return CharCaseCmp(c1, c2);
+}
+
+#define INIT_STRCASECMP COMMON_INTERCEPT_FUNCTION(strcasecmp)
+#define INIT_STRNCASECMP COMMON_INTERCEPT_FUNCTION(strncasecmp)
+#else
+#define INIT_STRCASECMP
+#define INIT_STRNCASECMP
+#endif
+
+#if SANITIZER_INTERCEPT_STRSTR || SANITIZER_INTERCEPT_STRCASESTR
+static inline void StrstrCheck(void *ctx, char *r, const char *s1,
+                               const char *s2) {
+    uptr len1 = REAL(strlen)(s1);
+    uptr len2 = REAL(strlen)(s2);
+    COMMON_INTERCEPTOR_READ_STRING_OF_LEN(ctx, s1, len1,
+                                          r ? r - s1 + len2 : len1 + 1);
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, len2 + 1);
+}
+#endif
+
+#if SANITIZER_INTERCEPT_STRSTR
+INTERCEPTOR(char*, strstr, const char *s1, const char *s2) {
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
+    return internal_strstr(s1, s2);
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strstr, s1, s2);
+  char *r = REAL(strstr)(s1, s2);
+  if (common_flags()->intercept_strstr)
+    StrstrCheck(ctx, r, s1, s2);
+  return r;
+}
+
+#define INIT_STRSTR COMMON_INTERCEPT_FUNCTION(strstr);
+#else
+#define INIT_STRSTR
+#endif
+
+#if SANITIZER_INTERCEPT_STRCASESTR
+INTERCEPTOR(char*, strcasestr, const char *s1, const char *s2) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strcasestr, s1, s2);
+  char *r = REAL(strcasestr)(s1, s2);
+  if (common_flags()->intercept_strstr)
+    StrstrCheck(ctx, r, s1, s2);
+  return r;
+}
+
+#define INIT_STRCASESTR COMMON_INTERCEPT_FUNCTION(strcasestr);
+#else
+#define INIT_STRCASESTR
+#endif
+
+#if SANITIZER_INTERCEPT_STRSPN
+INTERCEPTOR(SIZE_T, strspn, const char *s1, const char *s2) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strspn, s1, s2);
+  SIZE_T r = REAL(strspn)(s1, s2);
+  if (common_flags()->intercept_strspn) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, REAL(strlen)(s2) + 1);
+    COMMON_INTERCEPTOR_READ_STRING(ctx, s1, r + 1);
+  }
+  return r;
+}
+
+INTERCEPTOR(SIZE_T, strcspn, const char *s1, const char *s2) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strcspn, s1, s2);
+  SIZE_T r = REAL(strcspn)(s1, s2);
+  if (common_flags()->intercept_strspn) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, REAL(strlen)(s2) + 1);
+    COMMON_INTERCEPTOR_READ_STRING(ctx, s1, r + 1);
+  }
+  return r;
+}
+
+#define INIT_STRSPN \
+  COMMON_INTERCEPT_FUNCTION(strspn); \
+  COMMON_INTERCEPT_FUNCTION(strcspn);
+#else
+#define INIT_STRSPN
+#endif
+
+#if SANITIZER_INTERCEPT_STRPBRK
+INTERCEPTOR(char *, strpbrk, const char *s1, const char *s2) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strpbrk, s1, s2);
+  char *r = REAL(strpbrk)(s1, s2);
+  if (common_flags()->intercept_strpbrk) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, REAL(strlen)(s2) + 1);
+    COMMON_INTERCEPTOR_READ_STRING(ctx, s1,
+        r ? r - s1 + 1 : REAL(strlen)(s1) + 1);
+  }
+  return r;
+}
+
+#define INIT_STRPBRK COMMON_INTERCEPT_FUNCTION(strpbrk);
+#else
+#define INIT_STRPBRK
+#endif
+
+#if SANITIZER_INTERCEPT_MEMCMP
+
+DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_memcmp, uptr called_pc,
+                              const void *s1, const void *s2, uptr n)
+
+INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) {
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
+    return internal_memcmp(a1, a2, size);
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, memcmp, a1, a2, size);
+  CALL_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_memcmp, GET_CALLER_PC(), a1,
+                             a2, size);
+  if (common_flags()->intercept_memcmp) {
+    if (common_flags()->strict_memcmp) {
+      // Check the entire regions even if the first bytes of the buffers are
+      // different.
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, a1, size);
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, a2, size);
+      // Fallthrough to REAL(memcmp) below.
+    } else {
+      unsigned char c1 = 0, c2 = 0;
+      const unsigned char *s1 = (const unsigned char*)a1;
+      const unsigned char *s2 = (const unsigned char*)a2;
+      uptr i;
+      for (i = 0; i < size; i++) {
+        c1 = s1[i];
+        c2 = s2[i];
+        if (c1 != c2) break;
+      }
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, s1, Min(i + 1, size));
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, Min(i + 1, size));
+      return CharCmpX(c1, c2);
+    }
+  }
+  return REAL(memcmp(a1, a2, size));
+}
+
+#define INIT_MEMCMP COMMON_INTERCEPT_FUNCTION(memcmp)
+#else
+#define INIT_MEMCMP
+#endif
+
+#if SANITIZER_INTERCEPT_MEMCHR
+INTERCEPTOR(void*, memchr, const void *s, int c, SIZE_T n) {
+  if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
+    return internal_memchr(s, c, n);
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, memchr, s, c, n);
+  void *res = REAL(memchr)(s, c, n);
+  uptr len = res ? (char *)res - (const char *)s + 1 : n;
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s, len);
+  return res;
+}
+
+#define INIT_MEMCHR COMMON_INTERCEPT_FUNCTION(memchr)
+#else
+#define INIT_MEMCHR
+#endif
+
+#if SANITIZER_INTERCEPT_MEMRCHR
+INTERCEPTOR(void*, memrchr, const void *s, int c, SIZE_T n) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, memrchr, s, c, n);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, s, n);
+  return REAL(memrchr)(s, c, n);
+}
+
+#define INIT_MEMRCHR COMMON_INTERCEPT_FUNCTION(memrchr)
+#else
+#define INIT_MEMRCHR
+#endif
+
+#if SANITIZER_INTERCEPT_FREXP
+INTERCEPTOR(double, frexp, double x, int *exp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, frexp, x, exp);
+  // Assuming frexp() always writes to |exp|.
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, exp, sizeof(*exp));
+  double res = REAL(frexp)(x, exp);
+  return res;
+}
+
+#define INIT_FREXP COMMON_INTERCEPT_FUNCTION(frexp);
+#else
+#define INIT_FREXP
+#endif  // SANITIZER_INTERCEPT_FREXP
+
+#if SANITIZER_INTERCEPT_FREXPF_FREXPL
+INTERCEPTOR(float, frexpf, float x, int *exp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, frexpf, x, exp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  float res = REAL(frexpf)(x, exp);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, exp, sizeof(*exp));
+  return res;
+}
+
+INTERCEPTOR(long double, frexpl, long double x, int *exp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, frexpl, x, exp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  long double res = REAL(frexpl)(x, exp);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, exp, sizeof(*exp));
+  return res;
+}
+
+#define INIT_FREXPF_FREXPL           \
+  COMMON_INTERCEPT_FUNCTION(frexpf); \
+  COMMON_INTERCEPT_FUNCTION(frexpl)
+#else
+#define INIT_FREXPF_FREXPL
+#endif  // SANITIZER_INTERCEPT_FREXPF_FREXPL
+
+#if SI_NOT_WINDOWS
+static void write_iovec(void *ctx, struct __sanitizer_iovec *iovec,
+                        SIZE_T iovlen, SIZE_T maxlen) {
+  for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
+    SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, iovec[i].iov_base, sz);
+    maxlen -= sz;
+  }
+}
+
+static void read_iovec(void *ctx, struct __sanitizer_iovec *iovec,
+                       SIZE_T iovlen, SIZE_T maxlen) {
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, iovec, sizeof(*iovec) * iovlen);
+  for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
+    SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, iovec[i].iov_base, sz);
+    maxlen -= sz;
+  }
+}
+#endif
+
+#if SANITIZER_INTERCEPT_READ
+INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, read, fd, ptr, count);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(read)(fd, ptr, count);
+  if (res > 0) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_READ COMMON_INTERCEPT_FUNCTION(read)
+#else
+#define INIT_READ
+#endif
+
+#if SANITIZER_INTERCEPT_PREAD
+INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pread, fd, ptr, count, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(pread)(fd, ptr, count, offset);
+  if (res > 0) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_PREAD COMMON_INTERCEPT_FUNCTION(pread)
+#else
+#define INIT_PREAD
+#endif
+
+#if SANITIZER_INTERCEPT_PREAD64
+INTERCEPTOR(SSIZE_T, pread64, int fd, void *ptr, SIZE_T count, OFF64_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pread64, fd, ptr, count, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(pread64)(fd, ptr, count, offset);
+  if (res > 0) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_PREAD64 COMMON_INTERCEPT_FUNCTION(pread64)
+#else
+#define INIT_PREAD64
+#endif
+
+#if SANITIZER_INTERCEPT_READV
+INTERCEPTOR_WITH_SUFFIX(SSIZE_T, readv, int fd, __sanitizer_iovec *iov,
+                        int iovcnt) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, readv, fd, iov, iovcnt);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  SSIZE_T res = REAL(readv)(fd, iov, iovcnt);
+  if (res > 0) write_iovec(ctx, iov, iovcnt, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_READV COMMON_INTERCEPT_FUNCTION(readv)
+#else
+#define INIT_READV
+#endif
+
+#if SANITIZER_INTERCEPT_PREADV
+INTERCEPTOR(SSIZE_T, preadv, int fd, __sanitizer_iovec *iov, int iovcnt,
+            OFF_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, preadv, fd, iov, iovcnt, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  SSIZE_T res = REAL(preadv)(fd, iov, iovcnt, offset);
+  if (res > 0) write_iovec(ctx, iov, iovcnt, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_PREADV COMMON_INTERCEPT_FUNCTION(preadv)
+#else
+#define INIT_PREADV
+#endif
+
+#if SANITIZER_INTERCEPT_PREADV64
+INTERCEPTOR(SSIZE_T, preadv64, int fd, __sanitizer_iovec *iov, int iovcnt,
+            OFF64_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, preadv64, fd, iov, iovcnt, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  SSIZE_T res = REAL(preadv64)(fd, iov, iovcnt, offset);
+  if (res > 0) write_iovec(ctx, iov, iovcnt, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_PREADV64 COMMON_INTERCEPT_FUNCTION(preadv64)
+#else
+#define INIT_PREADV64
+#endif
+
+#if SANITIZER_INTERCEPT_WRITE
+INTERCEPTOR(SSIZE_T, write, int fd, void *ptr, SIZE_T count) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, write, fd, ptr, count);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(write)(fd, ptr, count);
+  // FIXME: this check should be _before_ the call to REAL(write), not after
+  if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
+  return res;
+}
+#define INIT_WRITE COMMON_INTERCEPT_FUNCTION(write)
+#else
+#define INIT_WRITE
+#endif
+
+#if SANITIZER_INTERCEPT_PWRITE
+INTERCEPTOR(SSIZE_T, pwrite, int fd, void *ptr, SIZE_T count, OFF_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pwrite, fd, ptr, count, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(pwrite)(fd, ptr, count, offset);
+  if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
+  return res;
+}
+#define INIT_PWRITE COMMON_INTERCEPT_FUNCTION(pwrite)
+#else
+#define INIT_PWRITE
+#endif
+
+#if SANITIZER_INTERCEPT_PWRITE64
+INTERCEPTOR(SSIZE_T, pwrite64, int fd, void *ptr, OFF64_T count,
+            OFF64_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pwrite64, fd, ptr, count, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(pwrite64)(fd, ptr, count, offset);
+  if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
+  return res;
+}
+#define INIT_PWRITE64 COMMON_INTERCEPT_FUNCTION(pwrite64)
+#else
+#define INIT_PWRITE64
+#endif
+
+#if SANITIZER_INTERCEPT_WRITEV
+INTERCEPTOR_WITH_SUFFIX(SSIZE_T, writev, int fd, __sanitizer_iovec *iov,
+                        int iovcnt) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, writev, fd, iov, iovcnt);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(writev)(fd, iov, iovcnt);
+  if (res > 0) read_iovec(ctx, iov, iovcnt, res);
+  return res;
+}
+#define INIT_WRITEV COMMON_INTERCEPT_FUNCTION(writev)
+#else
+#define INIT_WRITEV
+#endif
+
+#if SANITIZER_INTERCEPT_PWRITEV
+INTERCEPTOR(SSIZE_T, pwritev, int fd, __sanitizer_iovec *iov, int iovcnt,
+            OFF_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pwritev, fd, iov, iovcnt, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(pwritev)(fd, iov, iovcnt, offset);
+  if (res > 0) read_iovec(ctx, iov, iovcnt, res);
+  return res;
+}
+#define INIT_PWRITEV COMMON_INTERCEPT_FUNCTION(pwritev)
+#else
+#define INIT_PWRITEV
+#endif
+
+#if SANITIZER_INTERCEPT_PWRITEV64
+INTERCEPTOR(SSIZE_T, pwritev64, int fd, __sanitizer_iovec *iov, int iovcnt,
+            OFF64_T offset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pwritev64, fd, iov, iovcnt, offset);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(pwritev64)(fd, iov, iovcnt, offset);
+  if (res > 0) read_iovec(ctx, iov, iovcnt, res);
+  return res;
+}
+#define INIT_PWRITEV64 COMMON_INTERCEPT_FUNCTION(pwritev64)
+#else
+#define INIT_PWRITEV64
+#endif
+
+#if SANITIZER_INTERCEPT_PRCTL
+INTERCEPTOR(int, prctl, int option, unsigned long arg2,
+            unsigned long arg3,                        // NOLINT
+            unsigned long arg4, unsigned long arg5) {  // NOLINT
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, prctl, option, arg2, arg3, arg4, arg5);
+  static const int PR_SET_NAME = 15;
+  int res = REAL(prctl(option, arg2, arg3, arg4, arg5));
+  if (option == PR_SET_NAME) {
+    char buff[16];
+    internal_strncpy(buff, (char *)arg2, 15);
+    buff[15] = 0;
+    COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, buff);
+  }
+  return res;
+}
+#define INIT_PRCTL COMMON_INTERCEPT_FUNCTION(prctl)
+#else
+#define INIT_PRCTL
+#endif  // SANITIZER_INTERCEPT_PRCTL
+
+#if SANITIZER_INTERCEPT_TIME
+INTERCEPTOR(unsigned long, time, unsigned long *t) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, time, t);
+  unsigned long local_t;
+  unsigned long res = REAL(time)(&local_t);
+  if (t && res != (unsigned long)-1) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, t, sizeof(*t));
+    *t = local_t;
+  }
+  return res;
+}
+#define INIT_TIME COMMON_INTERCEPT_FUNCTION(time);
+#else
+#define INIT_TIME
+#endif  // SANITIZER_INTERCEPT_TIME
+
+#if SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS
+static void unpoison_tm(void *ctx, __sanitizer_tm *tm) {
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tm, sizeof(*tm));
+  if (tm->tm_zone) {
+    // Can not use COMMON_INTERCEPTOR_WRITE_RANGE here, because tm->tm_zone
+    // can point to shared memory and tsan would report a data race.
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(tm->tm_zone,
+                                        REAL(strlen(tm->tm_zone)) + 1);
+  }
+}
+INTERCEPTOR(__sanitizer_tm *, localtime, unsigned long *timep) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, localtime, timep);
+  __sanitizer_tm *res = REAL(localtime)(timep);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timep, sizeof(*timep));
+    unpoison_tm(ctx, res);
+  }
+  return res;
+}
+INTERCEPTOR(__sanitizer_tm *, localtime_r, unsigned long *timep, void *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, localtime_r, timep, result);
+  __sanitizer_tm *res = REAL(localtime_r)(timep, result);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timep, sizeof(*timep));
+    unpoison_tm(ctx, res);
+  }
+  return res;
+}
+INTERCEPTOR(__sanitizer_tm *, gmtime, unsigned long *timep) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gmtime, timep);
+  __sanitizer_tm *res = REAL(gmtime)(timep);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timep, sizeof(*timep));
+    unpoison_tm(ctx, res);
+  }
+  return res;
+}
+INTERCEPTOR(__sanitizer_tm *, gmtime_r, unsigned long *timep, void *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gmtime_r, timep, result);
+  __sanitizer_tm *res = REAL(gmtime_r)(timep, result);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timep, sizeof(*timep));
+    unpoison_tm(ctx, res);
+  }
+  return res;
+}
+INTERCEPTOR(char *, ctime, unsigned long *timep) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ctime, timep);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(ctime)(timep);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timep, sizeof(*timep));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+INTERCEPTOR(char *, ctime_r, unsigned long *timep, char *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ctime_r, timep, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(ctime_r)(timep, result);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timep, sizeof(*timep));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+INTERCEPTOR(char *, asctime, __sanitizer_tm *tm) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, asctime, tm);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(asctime)(tm);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, tm, sizeof(*tm));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+INTERCEPTOR(char *, asctime_r, __sanitizer_tm *tm, char *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, asctime_r, tm, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(asctime_r)(tm, result);
+  if (res) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, tm, sizeof(*tm));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+INTERCEPTOR(long, mktime, __sanitizer_tm *tm) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, mktime, tm);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_sec, sizeof(tm->tm_sec));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_min, sizeof(tm->tm_min));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_hour, sizeof(tm->tm_hour));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_mday, sizeof(tm->tm_mday));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_mon, sizeof(tm->tm_mon));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_year, sizeof(tm->tm_year));
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, &tm->tm_isdst, sizeof(tm->tm_isdst));
+  long res = REAL(mktime)(tm);
+  if (res != -1) unpoison_tm(ctx, tm);
+  return res;
+}
+#define INIT_LOCALTIME_AND_FRIENDS        \
+  COMMON_INTERCEPT_FUNCTION(localtime);   \
+  COMMON_INTERCEPT_FUNCTION(localtime_r); \
+  COMMON_INTERCEPT_FUNCTION(gmtime);      \
+  COMMON_INTERCEPT_FUNCTION(gmtime_r);    \
+  COMMON_INTERCEPT_FUNCTION(ctime);       \
+  COMMON_INTERCEPT_FUNCTION(ctime_r);     \
+  COMMON_INTERCEPT_FUNCTION(asctime);     \
+  COMMON_INTERCEPT_FUNCTION(asctime_r);   \
+  COMMON_INTERCEPT_FUNCTION(mktime);
+#else
+#define INIT_LOCALTIME_AND_FRIENDS
+#endif  // SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS
+
+#if SANITIZER_INTERCEPT_STRPTIME
+INTERCEPTOR(char *, strptime, char *s, char *format, __sanitizer_tm *tm) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strptime, s, format, tm);
+  if (format)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, format, REAL(strlen)(format) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(strptime)(s, format, tm);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, s, res ? res - s : 0);
+  if (res && tm) {
+    // Do not call unpoison_tm here, because strptime does not, in fact,
+    // initialize the entire struct tm. For example, tm_zone pointer is left
+    // uninitialized.
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tm, sizeof(*tm));
+  }
+  return res;
+}
+#define INIT_STRPTIME COMMON_INTERCEPT_FUNCTION(strptime);
+#else
+#define INIT_STRPTIME
+#endif
+
+#if SANITIZER_INTERCEPT_SCANF || SANITIZER_INTERCEPT_PRINTF
+#include "sanitizer_common_interceptors_format.inc"
+
+#define FORMAT_INTERCEPTOR_IMPL(name, vname, ...)                              \
+  {                                                                            \
+    void *ctx;                                                                 \
+    va_list ap;                                                                \
+    va_start(ap, format);                                                      \
+    COMMON_INTERCEPTOR_ENTER(ctx, vname, __VA_ARGS__, ap);                     \
+    int res = WRAP(vname)(__VA_ARGS__, ap);                                    \
+    va_end(ap);                                                                \
+    return res;                                                                \
+  }
+
+#endif
+
+#if SANITIZER_INTERCEPT_SCANF
+
+#define VSCANF_INTERCEPTOR_IMPL(vname, allowGnuMalloc, ...)                    \
+  {                                                                            \
+    void *ctx;                                                                 \
+    COMMON_INTERCEPTOR_ENTER(ctx, vname, __VA_ARGS__);                         \
+    va_list aq;                                                                \
+    va_copy(aq, ap);                                                           \
+    int res = REAL(vname)(__VA_ARGS__);                                        \
+    if (res > 0)                                                               \
+      scanf_common(ctx, res, allowGnuMalloc, format, aq);                      \
+    va_end(aq);                                                                \
+    return res;                                                                \
+  }
+
+INTERCEPTOR(int, vscanf, const char *format, va_list ap)
+VSCANF_INTERCEPTOR_IMPL(vscanf, true, format, ap)
+
+INTERCEPTOR(int, vsscanf, const char *str, const char *format, va_list ap)
+VSCANF_INTERCEPTOR_IMPL(vsscanf, true, str, format, ap)
+
+INTERCEPTOR(int, vfscanf, void *stream, const char *format, va_list ap)
+VSCANF_INTERCEPTOR_IMPL(vfscanf, true, stream, format, ap)
+
+#if SANITIZER_INTERCEPT_ISOC99_SCANF
+INTERCEPTOR(int, __isoc99_vscanf, const char *format, va_list ap)
+VSCANF_INTERCEPTOR_IMPL(__isoc99_vscanf, false, format, ap)
+
+INTERCEPTOR(int, __isoc99_vsscanf, const char *str, const char *format,
+            va_list ap)
+VSCANF_INTERCEPTOR_IMPL(__isoc99_vsscanf, false, str, format, ap)
+
+INTERCEPTOR(int, __isoc99_vfscanf, void *stream, const char *format, va_list ap)
+VSCANF_INTERCEPTOR_IMPL(__isoc99_vfscanf, false, stream, format, ap)
+#endif  // SANITIZER_INTERCEPT_ISOC99_SCANF
+
+INTERCEPTOR(int, scanf, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(scanf, vscanf, format)
+
+INTERCEPTOR(int, fscanf, void *stream, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(fscanf, vfscanf, stream, format)
+
+INTERCEPTOR(int, sscanf, const char *str, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(sscanf, vsscanf, str, format)
+
+#if SANITIZER_INTERCEPT_ISOC99_SCANF
+INTERCEPTOR(int, __isoc99_scanf, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_scanf, __isoc99_vscanf, format)
+
+INTERCEPTOR(int, __isoc99_fscanf, void *stream, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_fscanf, __isoc99_vfscanf, stream, format)
+
+INTERCEPTOR(int, __isoc99_sscanf, const char *str, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_sscanf, __isoc99_vsscanf, str, format)
+#endif
+
+#endif
+
+#if SANITIZER_INTERCEPT_SCANF
+#define INIT_SCANF                    \
+  COMMON_INTERCEPT_FUNCTION(scanf);   \
+  COMMON_INTERCEPT_FUNCTION(sscanf);  \
+  COMMON_INTERCEPT_FUNCTION(fscanf);  \
+  COMMON_INTERCEPT_FUNCTION(vscanf);  \
+  COMMON_INTERCEPT_FUNCTION(vsscanf); \
+  COMMON_INTERCEPT_FUNCTION(vfscanf);
+#else
+#define INIT_SCANF
+#endif
+
+#if SANITIZER_INTERCEPT_ISOC99_SCANF
+#define INIT_ISOC99_SCANF                      \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_scanf);   \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_sscanf);  \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_fscanf);  \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vscanf);  \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vsscanf); \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vfscanf);
+#else
+#define INIT_ISOC99_SCANF
+#endif
+
+#if SANITIZER_INTERCEPT_PRINTF
+
+#define VPRINTF_INTERCEPTOR_ENTER(vname, ...)                                  \
+  void *ctx;                                                                   \
+  COMMON_INTERCEPTOR_ENTER(ctx, vname, __VA_ARGS__);                           \
+  va_list aq;                                                                  \
+  va_copy(aq, ap);
+
+#define VPRINTF_INTERCEPTOR_RETURN()                                           \
+  va_end(aq);
+
+#define VPRINTF_INTERCEPTOR_IMPL(vname, ...)                                   \
+  {                                                                            \
+    VPRINTF_INTERCEPTOR_ENTER(vname, __VA_ARGS__);                             \
+    if (common_flags()->check_printf)                                          \
+      printf_common(ctx, format, aq);                                          \
+    int res = REAL(vname)(__VA_ARGS__);                                        \
+    VPRINTF_INTERCEPTOR_RETURN();                                              \
+    return res;                                                                \
+  }
+
+// FIXME: under ASan the REAL() call below may write to freed memory and
+// corrupt its metadata. See
+// https://github.com/google/sanitizers/issues/321.
+#define VSPRINTF_INTERCEPTOR_IMPL(vname, str, ...)                             \
+  {                                                                            \
+    VPRINTF_INTERCEPTOR_ENTER(vname, str, __VA_ARGS__)                         \
+    if (common_flags()->check_printf) {                                        \
+      printf_common(ctx, format, aq);                                          \
+    }                                                                          \
+    int res = REAL(vname)(str, __VA_ARGS__);                                   \
+    if (res >= 0) {                                                            \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, str, res + 1);                       \
+    }                                                                          \
+    VPRINTF_INTERCEPTOR_RETURN();                                              \
+    return res;                                                                \
+  }
+
+// FIXME: under ASan the REAL() call below may write to freed memory and
+// corrupt its metadata. See
+// https://github.com/google/sanitizers/issues/321.
+#define VSNPRINTF_INTERCEPTOR_IMPL(vname, str, size, ...)                      \
+  {                                                                            \
+    VPRINTF_INTERCEPTOR_ENTER(vname, str, size, __VA_ARGS__)                   \
+    if (common_flags()->check_printf) {                                        \
+      printf_common(ctx, format, aq);                                          \
+    }                                                                          \
+    int res = REAL(vname)(str, size, __VA_ARGS__);                             \
+    if (res >= 0) {                                                            \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, str, Min(size, (SIZE_T)(res + 1)));  \
+    }                                                                          \
+    VPRINTF_INTERCEPTOR_RETURN();                                              \
+    return res;                                                                \
+  }
+
+// FIXME: under ASan the REAL() call below may write to freed memory and
+// corrupt its metadata. See
+// https://github.com/google/sanitizers/issues/321.
+#define VASPRINTF_INTERCEPTOR_IMPL(vname, strp, ...)                           \
+  {                                                                            \
+    VPRINTF_INTERCEPTOR_ENTER(vname, strp, __VA_ARGS__)                        \
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, strp, sizeof(char *));                 \
+    if (common_flags()->check_printf) {                                        \
+      printf_common(ctx, format, aq);                                          \
+    }                                                                          \
+    int res = REAL(vname)(strp, __VA_ARGS__);                                  \
+    if (res >= 0) {                                                            \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *strp, res + 1);                     \
+    }                                                                          \
+    VPRINTF_INTERCEPTOR_RETURN();                                              \
+    return res;                                                                \
+  }
+
+INTERCEPTOR(int, vprintf, const char *format, va_list ap)
+VPRINTF_INTERCEPTOR_IMPL(vprintf, format, ap)
+
+INTERCEPTOR(int, vfprintf, __sanitizer_FILE *stream, const char *format,
+            va_list ap)
+VPRINTF_INTERCEPTOR_IMPL(vfprintf, stream, format, ap)
+
+INTERCEPTOR(int, vsnprintf, char *str, SIZE_T size, const char *format,
+            va_list ap)
+VSNPRINTF_INTERCEPTOR_IMPL(vsnprintf, str, size, format, ap)
+
+#if SANITIZER_INTERCEPT_PRINTF_L
+INTERCEPTOR(int, vsnprintf_l, char *str, SIZE_T size, void *loc,
+            const char *format, va_list ap)
+VSNPRINTF_INTERCEPTOR_IMPL(vsnprintf_l, str, size, loc, format, ap)
+
+INTERCEPTOR(int, snprintf_l, char *str, SIZE_T size, void *loc,
+            const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(snprintf_l, vsnprintf_l, str, size, loc, format)
+#endif  // SANITIZER_INTERCEPT_PRINTF_L
+
+INTERCEPTOR(int, vsprintf, char *str, const char *format, va_list ap)
+VSPRINTF_INTERCEPTOR_IMPL(vsprintf, str, format, ap)
+
+INTERCEPTOR(int, vasprintf, char **strp, const char *format, va_list ap)
+VASPRINTF_INTERCEPTOR_IMPL(vasprintf, strp, format, ap)
+
+#if SANITIZER_INTERCEPT_ISOC99_PRINTF
+INTERCEPTOR(int, __isoc99_vprintf, const char *format, va_list ap)
+VPRINTF_INTERCEPTOR_IMPL(__isoc99_vprintf, format, ap)
+
+INTERCEPTOR(int, __isoc99_vfprintf, __sanitizer_FILE *stream,
+            const char *format, va_list ap)
+VPRINTF_INTERCEPTOR_IMPL(__isoc99_vfprintf, stream, format, ap)
+
+INTERCEPTOR(int, __isoc99_vsnprintf, char *str, SIZE_T size, const char *format,
+            va_list ap)
+VSNPRINTF_INTERCEPTOR_IMPL(__isoc99_vsnprintf, str, size, format, ap)
+
+INTERCEPTOR(int, __isoc99_vsprintf, char *str, const char *format,
+            va_list ap)
+VSPRINTF_INTERCEPTOR_IMPL(__isoc99_vsprintf, str, format,
+                          ap)
+
+#endif  // SANITIZER_INTERCEPT_ISOC99_PRINTF
+
+INTERCEPTOR(int, printf, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(printf, vprintf, format)
+
+INTERCEPTOR(int, fprintf, __sanitizer_FILE *stream, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(fprintf, vfprintf, stream, format)
+
+INTERCEPTOR(int, sprintf, char *str, const char *format, ...) // NOLINT
+FORMAT_INTERCEPTOR_IMPL(sprintf, vsprintf, str, format) // NOLINT
+
+INTERCEPTOR(int, snprintf, char *str, SIZE_T size, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(snprintf, vsnprintf, str, size, format)
+
+INTERCEPTOR(int, asprintf, char **strp, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(asprintf, vasprintf, strp, format)
+
+#if SANITIZER_INTERCEPT_ISOC99_PRINTF
+INTERCEPTOR(int, __isoc99_printf, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_printf, __isoc99_vprintf, format)
+
+INTERCEPTOR(int, __isoc99_fprintf, __sanitizer_FILE *stream, const char *format,
+            ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_fprintf, __isoc99_vfprintf, stream, format)
+
+INTERCEPTOR(int, __isoc99_sprintf, char *str, const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_sprintf, __isoc99_vsprintf, str, format)
+
+INTERCEPTOR(int, __isoc99_snprintf, char *str, SIZE_T size,
+            const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(__isoc99_snprintf, __isoc99_vsnprintf, str, size,
+                        format)
+
+#endif  // SANITIZER_INTERCEPT_ISOC99_PRINTF
+
+#endif  // SANITIZER_INTERCEPT_PRINTF
+
+#if SANITIZER_INTERCEPT_PRINTF
+#define INIT_PRINTF                     \
+  COMMON_INTERCEPT_FUNCTION(printf);    \
+  COMMON_INTERCEPT_FUNCTION(sprintf);   \
+  COMMON_INTERCEPT_FUNCTION(snprintf);  \
+  COMMON_INTERCEPT_FUNCTION(asprintf);  \
+  COMMON_INTERCEPT_FUNCTION(fprintf);   \
+  COMMON_INTERCEPT_FUNCTION(vprintf);   \
+  COMMON_INTERCEPT_FUNCTION(vsprintf);  \
+  COMMON_INTERCEPT_FUNCTION(vsnprintf); \
+  COMMON_INTERCEPT_FUNCTION(vasprintf); \
+  COMMON_INTERCEPT_FUNCTION(vfprintf);
+#else
+#define INIT_PRINTF
+#endif
+
+#if SANITIZER_INTERCEPT_PRINTF_L
+#define INIT_PRINTF_L                     \
+  COMMON_INTERCEPT_FUNCTION(snprintf_l);  \
+  COMMON_INTERCEPT_FUNCTION(vsnprintf_l);
+#else
+#define INIT_PRINTF_L
+#endif
+
+#if SANITIZER_INTERCEPT_ISOC99_PRINTF
+#define INIT_ISOC99_PRINTF                       \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_printf);    \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_sprintf);   \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_snprintf);  \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_fprintf);   \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vprintf);   \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vsprintf);  \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vsnprintf); \
+  COMMON_INTERCEPT_FUNCTION(__isoc99_vfprintf);
+#else
+#define INIT_ISOC99_PRINTF
+#endif
+
+#if SANITIZER_INTERCEPT_IOCTL
+#include "sanitizer_common_interceptors_ioctl.inc"
+INTERCEPTOR(int, ioctl, int d, unsigned long request, ...) {
+  // We need a frame pointer, because we call into ioctl_common_[pre|post] which
+  // can trigger a report and we need to be able to unwind through this
+  // function.  On Mac in debug mode we might not have a frame pointer, because
+  // ioctl_common_[pre|post] doesn't get inlined here.
+  ENABLE_FRAME_POINTER;
+
+  void *ctx;
+  va_list ap;
+  va_start(ap, request);
+  void *arg = va_arg(ap, void *);
+  va_end(ap);
+  COMMON_INTERCEPTOR_ENTER(ctx, ioctl, d, request, arg);
+
+  CHECK(ioctl_initialized);
+
+  // Note: TSan does not use common flags, and they are zero-initialized.
+  // This effectively disables ioctl handling in TSan.
+  if (!common_flags()->handle_ioctl) return REAL(ioctl)(d, request, arg);
+
+  // Although request is unsigned long, the rest of the interceptor uses it
+  // as just "unsigned" to save space, because we know that all values fit in
+  // "unsigned" - they are compile-time constants.
+
+  const ioctl_desc *desc = ioctl_lookup(request);
+  ioctl_desc decoded_desc;
+  if (!desc) {
+    VPrintf(2, "Decoding unknown ioctl 0x%x\n", request);
+    if (!ioctl_decode(request, &decoded_desc))
+      Printf("WARNING: failed decoding unknown ioctl 0x%x\n", request);
+    else
+      desc = &decoded_desc;
+  }
+
+  if (desc) ioctl_common_pre(ctx, desc, d, request, arg);
+  int res = REAL(ioctl)(d, request, arg);
+  // FIXME: some ioctls have different return values for success and failure.
+  if (desc && res != -1) ioctl_common_post(ctx, desc, res, d, request, arg);
+  return res;
+}
+#define INIT_IOCTL \
+  ioctl_init();    \
+  COMMON_INTERCEPT_FUNCTION(ioctl);
+#else
+#define INIT_IOCTL
+#endif
+
+#if SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS || \
+    SANITIZER_INTERCEPT_GETPWENT || SANITIZER_INTERCEPT_FGETPWENT || \
+    SANITIZER_INTERCEPT_GETPWENT_R || SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS
+static void unpoison_passwd(void *ctx, __sanitizer_passwd *pwd) {
+  if (pwd) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pwd, sizeof(*pwd));
+    if (pwd->pw_name)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(pwd->pw_name,
+                                          REAL(strlen)(pwd->pw_name) + 1);
+    if (pwd->pw_passwd)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(pwd->pw_passwd,
+                                          REAL(strlen)(pwd->pw_passwd) + 1);
+#if !SANITIZER_ANDROID
+    if (pwd->pw_gecos)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(pwd->pw_gecos,
+                                          REAL(strlen)(pwd->pw_gecos) + 1);
+#endif
+#if SANITIZER_MAC
+    if (pwd->pw_class)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(pwd->pw_class,
+                                          REAL(strlen)(pwd->pw_class) + 1);
+#endif
+    if (pwd->pw_dir)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(pwd->pw_dir,
+                                          REAL(strlen)(pwd->pw_dir) + 1);
+    if (pwd->pw_shell)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(pwd->pw_shell,
+                                          REAL(strlen)(pwd->pw_shell) + 1);
+  }
+}
+
+static void unpoison_group(void *ctx, __sanitizer_group *grp) {
+  if (grp) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, grp, sizeof(*grp));
+    if (grp->gr_name)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(grp->gr_name,
+                                          REAL(strlen)(grp->gr_name) + 1);
+    if (grp->gr_passwd)
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(grp->gr_passwd,
+                                          REAL(strlen)(grp->gr_passwd) + 1);
+    char **p = grp->gr_mem;
+    for (; *p; ++p) {
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(*p, REAL(strlen)(*p) + 1);
+    }
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(grp->gr_mem,
+                                        (p - grp->gr_mem + 1) * sizeof(*p));
+  }
+}
+#endif  // SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS ||
+        // SANITIZER_INTERCEPT_GETPWENT || SANITIZER_INTERCEPT_FGETPWENT ||
+        // SANITIZER_INTERCEPT_GETPWENT_R ||
+        // SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS
+
+#if SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS
+INTERCEPTOR(__sanitizer_passwd *, getpwnam, const char *name) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpwnam, name);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  __sanitizer_passwd *res = REAL(getpwnam)(name);
+  if (res) unpoison_passwd(ctx, res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_passwd *, getpwuid, u32 uid) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpwuid, uid);
+  __sanitizer_passwd *res = REAL(getpwuid)(uid);
+  if (res) unpoison_passwd(ctx, res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_group *, getgrnam, const char *name) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgrnam, name);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  __sanitizer_group *res = REAL(getgrnam)(name);
+  if (res) unpoison_group(ctx, res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_group *, getgrgid, u32 gid) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgrgid, gid);
+  __sanitizer_group *res = REAL(getgrgid)(gid);
+  if (res) unpoison_group(ctx, res);
+  return res;
+}
+#define INIT_GETPWNAM_AND_FRIENDS      \
+  COMMON_INTERCEPT_FUNCTION(getpwnam); \
+  COMMON_INTERCEPT_FUNCTION(getpwuid); \
+  COMMON_INTERCEPT_FUNCTION(getgrnam); \
+  COMMON_INTERCEPT_FUNCTION(getgrgid);
+#else
+#define INIT_GETPWNAM_AND_FRIENDS
+#endif
+
+#if SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS
+INTERCEPTOR(int, getpwnam_r, const char *name, __sanitizer_passwd *pwd,
+            char *buf, SIZE_T buflen, __sanitizer_passwd **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpwnam_r, name, pwd, buf, buflen, result);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getpwnam_r)(name, pwd, buf, buflen, result);
+  if (!res) {
+    if (result && *result) unpoison_passwd(ctx, *result);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (result) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+INTERCEPTOR(int, getpwuid_r, u32 uid, __sanitizer_passwd *pwd, char *buf,
+            SIZE_T buflen, __sanitizer_passwd **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpwuid_r, uid, pwd, buf, buflen, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getpwuid_r)(uid, pwd, buf, buflen, result);
+  if (!res) {
+    if (result && *result) unpoison_passwd(ctx, *result);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (result) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+INTERCEPTOR(int, getgrnam_r, const char *name, __sanitizer_group *grp,
+            char *buf, SIZE_T buflen, __sanitizer_group **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgrnam_r, name, grp, buf, buflen, result);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getgrnam_r)(name, grp, buf, buflen, result);
+  if (!res) {
+    if (result && *result) unpoison_group(ctx, *result);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (result) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+INTERCEPTOR(int, getgrgid_r, u32 gid, __sanitizer_group *grp, char *buf,
+            SIZE_T buflen, __sanitizer_group **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgrgid_r, gid, grp, buf, buflen, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getgrgid_r)(gid, grp, buf, buflen, result);
+  if (!res) {
+    if (result && *result) unpoison_group(ctx, *result);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (result) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+#define INIT_GETPWNAM_R_AND_FRIENDS      \
+  COMMON_INTERCEPT_FUNCTION(getpwnam_r); \
+  COMMON_INTERCEPT_FUNCTION(getpwuid_r); \
+  COMMON_INTERCEPT_FUNCTION(getgrnam_r); \
+  COMMON_INTERCEPT_FUNCTION(getgrgid_r);
+#else
+#define INIT_GETPWNAM_R_AND_FRIENDS
+#endif
+
+#if SANITIZER_INTERCEPT_GETPWENT
+INTERCEPTOR(__sanitizer_passwd *, getpwent, int dummy) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpwent, dummy);
+  __sanitizer_passwd *res = REAL(getpwent)(dummy);
+  if (res) unpoison_passwd(ctx, res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_group *, getgrent, int dummy) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgrent, dummy);
+  __sanitizer_group *res = REAL(getgrent)(dummy);
+  if (res) unpoison_group(ctx, res);;
+  return res;
+}
+#define INIT_GETPWENT                  \
+  COMMON_INTERCEPT_FUNCTION(getpwent); \
+  COMMON_INTERCEPT_FUNCTION(getgrent);
+#else
+#define INIT_GETPWENT
+#endif
+
+#if SANITIZER_INTERCEPT_FGETPWENT
+INTERCEPTOR(__sanitizer_passwd *, fgetpwent, void *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fgetpwent, fp);
+  __sanitizer_passwd *res = REAL(fgetpwent)(fp);
+  if (res) unpoison_passwd(ctx, res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_group *, fgetgrent, void *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fgetgrent, fp);
+  __sanitizer_group *res = REAL(fgetgrent)(fp);
+  if (res) unpoison_group(ctx, res);
+  return res;
+}
+#define INIT_FGETPWENT                  \
+  COMMON_INTERCEPT_FUNCTION(fgetpwent); \
+  COMMON_INTERCEPT_FUNCTION(fgetgrent);
+#else
+#define INIT_FGETPWENT
+#endif
+
+#if SANITIZER_INTERCEPT_GETPWENT_R
+INTERCEPTOR(int, getpwent_r, __sanitizer_passwd *pwbuf, char *buf,
+            SIZE_T buflen, __sanitizer_passwd **pwbufp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpwent_r, pwbuf, buf, buflen, pwbufp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getpwent_r)(pwbuf, buf, buflen, pwbufp);
+  if (!res) {
+    if (pwbufp && *pwbufp) unpoison_passwd(ctx, *pwbufp);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (pwbufp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pwbufp, sizeof(*pwbufp));
+  return res;
+}
+INTERCEPTOR(int, fgetpwent_r, void *fp, __sanitizer_passwd *pwbuf, char *buf,
+            SIZE_T buflen, __sanitizer_passwd **pwbufp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fgetpwent_r, fp, pwbuf, buf, buflen, pwbufp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(fgetpwent_r)(fp, pwbuf, buf, buflen, pwbufp);
+  if (!res) {
+    if (pwbufp && *pwbufp) unpoison_passwd(ctx, *pwbufp);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (pwbufp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pwbufp, sizeof(*pwbufp));
+  return res;
+}
+INTERCEPTOR(int, getgrent_r, __sanitizer_group *pwbuf, char *buf, SIZE_T buflen,
+            __sanitizer_group **pwbufp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgrent_r, pwbuf, buf, buflen, pwbufp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getgrent_r)(pwbuf, buf, buflen, pwbufp);
+  if (!res) {
+    if (pwbufp && *pwbufp) unpoison_group(ctx, *pwbufp);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (pwbufp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pwbufp, sizeof(*pwbufp));
+  return res;
+}
+INTERCEPTOR(int, fgetgrent_r, void *fp, __sanitizer_group *pwbuf, char *buf,
+            SIZE_T buflen, __sanitizer_group **pwbufp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fgetgrent_r, fp, pwbuf, buf, buflen, pwbufp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(fgetgrent_r)(fp, pwbuf, buf, buflen, pwbufp);
+  if (!res) {
+    if (pwbufp && *pwbufp) unpoison_group(ctx, *pwbufp);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
+  }
+  if (pwbufp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pwbufp, sizeof(*pwbufp));
+  return res;
+}
+#define INIT_GETPWENT_R                   \
+  COMMON_INTERCEPT_FUNCTION(getpwent_r);  \
+  COMMON_INTERCEPT_FUNCTION(fgetpwent_r); \
+  COMMON_INTERCEPT_FUNCTION(getgrent_r);  \
+  COMMON_INTERCEPT_FUNCTION(fgetgrent_r);
+#else
+#define INIT_GETPWENT_R
+#endif
+
+#if SANITIZER_INTERCEPT_SETPWENT
+// The only thing these interceptors do is disable any nested interceptors.
+// These functions may open nss modules and call uninstrumented functions from
+// them, and we don't want things like strlen() to trigger.
+INTERCEPTOR(void, setpwent, int dummy) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, setpwent, dummy);
+  REAL(setpwent)(dummy);
+}
+INTERCEPTOR(void, endpwent, int dummy) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, endpwent, dummy);
+  REAL(endpwent)(dummy);
+}
+INTERCEPTOR(void, setgrent, int dummy) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, setgrent, dummy);
+  REAL(setgrent)(dummy);
+}
+INTERCEPTOR(void, endgrent, int dummy) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, endgrent, dummy);
+  REAL(endgrent)(dummy);
+}
+#define INIT_SETPWENT                  \
+  COMMON_INTERCEPT_FUNCTION(setpwent); \
+  COMMON_INTERCEPT_FUNCTION(endpwent); \
+  COMMON_INTERCEPT_FUNCTION(setgrent); \
+  COMMON_INTERCEPT_FUNCTION(endgrent);
+#else
+#define INIT_SETPWENT
+#endif
+
+#if SANITIZER_INTERCEPT_CLOCK_GETTIME
+INTERCEPTOR(int, clock_getres, u32 clk_id, void *tp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, clock_getres, clk_id, tp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(clock_getres)(clk_id, tp);
+  if (!res && tp) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tp, struct_timespec_sz);
+  }
+  return res;
+}
+INTERCEPTOR(int, clock_gettime, u32 clk_id, void *tp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, clock_gettime, clk_id, tp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(clock_gettime)(clk_id, tp);
+  if (!res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tp, struct_timespec_sz);
+  }
+  return res;
+}
+INTERCEPTOR(int, clock_settime, u32 clk_id, const void *tp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, clock_settime, clk_id, tp);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, tp, struct_timespec_sz);
+  return REAL(clock_settime)(clk_id, tp);
+}
+#define INIT_CLOCK_GETTIME                  \
+  COMMON_INTERCEPT_FUNCTION(clock_getres);  \
+  COMMON_INTERCEPT_FUNCTION(clock_gettime); \
+  COMMON_INTERCEPT_FUNCTION(clock_settime);
+#else
+#define INIT_CLOCK_GETTIME
+#endif
+
+#if SANITIZER_INTERCEPT_GETITIMER
+INTERCEPTOR(int, getitimer, int which, void *curr_value) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getitimer, which, curr_value);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getitimer)(which, curr_value);
+  if (!res && curr_value) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, curr_value, struct_itimerval_sz);
+  }
+  return res;
+}
+INTERCEPTOR(int, setitimer, int which, const void *new_value, void *old_value) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, setitimer, which, new_value, old_value);
+  if (new_value)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, new_value, struct_itimerval_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(setitimer)(which, new_value, old_value);
+  if (!res && old_value) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, old_value, struct_itimerval_sz);
+  }
+  return res;
+}
+#define INIT_GETITIMER                  \
+  COMMON_INTERCEPT_FUNCTION(getitimer); \
+  COMMON_INTERCEPT_FUNCTION(setitimer);
+#else
+#define INIT_GETITIMER
+#endif
+
+#if SANITIZER_INTERCEPT_GLOB
+static void unpoison_glob_t(void *ctx, __sanitizer_glob_t *pglob) {
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, pglob, sizeof(*pglob));
+  // +1 for NULL pointer at the end.
+  if (pglob->gl_pathv)
+    COMMON_INTERCEPTOR_WRITE_RANGE(
+        ctx, pglob->gl_pathv, (pglob->gl_pathc + 1) * sizeof(*pglob->gl_pathv));
+  for (SIZE_T i = 0; i < pglob->gl_pathc; ++i) {
+    char *p = pglob->gl_pathv[i];
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, REAL(strlen)(p) + 1);
+  }
+}
+
+static THREADLOCAL __sanitizer_glob_t *pglob_copy;
+
+static void wrapped_gl_closedir(void *dir) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(1);
+  pglob_copy->gl_closedir(dir);
+}
+
+static void *wrapped_gl_readdir(void *dir) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(1);
+  return pglob_copy->gl_readdir(dir);
+}
+
+static void *wrapped_gl_opendir(const char *s) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(1);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(s, REAL(strlen)(s) + 1);
+  return pglob_copy->gl_opendir(s);
+}
+
+static int wrapped_gl_lstat(const char *s, void *st) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(2);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(s, REAL(strlen)(s) + 1);
+  return pglob_copy->gl_lstat(s, st);
+}
+
+static int wrapped_gl_stat(const char *s, void *st) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(2);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(s, REAL(strlen)(s) + 1);
+  return pglob_copy->gl_stat(s, st);
+}
+
+static const __sanitizer_glob_t kGlobCopy = {
+      0,                  0,                   0,
+      0,                  wrapped_gl_closedir, wrapped_gl_readdir,
+      wrapped_gl_opendir, wrapped_gl_lstat,    wrapped_gl_stat};
+
+INTERCEPTOR(int, glob, const char *pattern, int flags,
+            int (*errfunc)(const char *epath, int eerrno),
+            __sanitizer_glob_t *pglob) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, glob, pattern, flags, errfunc, pglob);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, pattern, 0);
+  __sanitizer_glob_t glob_copy;
+  internal_memcpy(&glob_copy, &kGlobCopy, sizeof(glob_copy));
+  if (flags & glob_altdirfunc) {
+    Swap(pglob->gl_closedir, glob_copy.gl_closedir);
+    Swap(pglob->gl_readdir, glob_copy.gl_readdir);
+    Swap(pglob->gl_opendir, glob_copy.gl_opendir);
+    Swap(pglob->gl_lstat, glob_copy.gl_lstat);
+    Swap(pglob->gl_stat, glob_copy.gl_stat);
+    pglob_copy = &glob_copy;
+  }
+  int res = REAL(glob)(pattern, flags, errfunc, pglob);
+  if (flags & glob_altdirfunc) {
+    Swap(pglob->gl_closedir, glob_copy.gl_closedir);
+    Swap(pglob->gl_readdir, glob_copy.gl_readdir);
+    Swap(pglob->gl_opendir, glob_copy.gl_opendir);
+    Swap(pglob->gl_lstat, glob_copy.gl_lstat);
+    Swap(pglob->gl_stat, glob_copy.gl_stat);
+  }
+  pglob_copy = 0;
+  if ((!res || res == glob_nomatch) && pglob) unpoison_glob_t(ctx, pglob);
+  return res;
+}
+
+INTERCEPTOR(int, glob64, const char *pattern, int flags,
+            int (*errfunc)(const char *epath, int eerrno),
+            __sanitizer_glob_t *pglob) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, glob64, pattern, flags, errfunc, pglob);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, pattern, 0);
+  __sanitizer_glob_t glob_copy;
+  internal_memcpy(&glob_copy, &kGlobCopy, sizeof(glob_copy));
+  if (flags & glob_altdirfunc) {
+    Swap(pglob->gl_closedir, glob_copy.gl_closedir);
+    Swap(pglob->gl_readdir, glob_copy.gl_readdir);
+    Swap(pglob->gl_opendir, glob_copy.gl_opendir);
+    Swap(pglob->gl_lstat, glob_copy.gl_lstat);
+    Swap(pglob->gl_stat, glob_copy.gl_stat);
+    pglob_copy = &glob_copy;
+  }
+  int res = REAL(glob64)(pattern, flags, errfunc, pglob);
+  if (flags & glob_altdirfunc) {
+    Swap(pglob->gl_closedir, glob_copy.gl_closedir);
+    Swap(pglob->gl_readdir, glob_copy.gl_readdir);
+    Swap(pglob->gl_opendir, glob_copy.gl_opendir);
+    Swap(pglob->gl_lstat, glob_copy.gl_lstat);
+    Swap(pglob->gl_stat, glob_copy.gl_stat);
+  }
+  pglob_copy = 0;
+  if ((!res || res == glob_nomatch) && pglob) unpoison_glob_t(ctx, pglob);
+  return res;
+}
+#define INIT_GLOB                  \
+  COMMON_INTERCEPT_FUNCTION(glob); \
+  COMMON_INTERCEPT_FUNCTION(glob64);
+#else  // SANITIZER_INTERCEPT_GLOB
+#define INIT_GLOB
+#endif  // SANITIZER_INTERCEPT_GLOB
+
+#if SANITIZER_INTERCEPT_WAIT
+// According to sys/wait.h, wait(), waitid(), waitpid() may have symbol version
+// suffixes on Darwin. See the declaration of INTERCEPTOR_WITH_SUFFIX for
+// details.
+INTERCEPTOR_WITH_SUFFIX(int, wait, int *status) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wait, status);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(wait)(status);
+  if (res != -1 && status)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
+  return res;
+}
+// On FreeBSD id_t is always 64-bit wide.
+#if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
+INTERCEPTOR_WITH_SUFFIX(int, waitid, int idtype, long long id, void *infop,
+                        int options) {
+#else
+INTERCEPTOR_WITH_SUFFIX(int, waitid, int idtype, int id, void *infop,
+                        int options) {
+#endif
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, waitid, idtype, id, infop, options);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(waitid)(idtype, id, infop, options);
+  if (res != -1 && infop)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, infop, siginfo_t_sz);
+  return res;
+}
+INTERCEPTOR_WITH_SUFFIX(int, waitpid, int pid, int *status, int options) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, waitpid, pid, status, options);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(waitpid)(pid, status, options);
+  if (res != -1 && status)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
+  return res;
+}
+INTERCEPTOR(int, wait3, int *status, int options, void *rusage) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wait3, status, options, rusage);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(wait3)(status, options, rusage);
+  if (res != -1) {
+    if (status) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
+    if (rusage) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rusage, struct_rusage_sz);
+  }
+  return res;
+}
+#if SANITIZER_ANDROID
+INTERCEPTOR(int, __wait4, int pid, int *status, int options, void *rusage) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __wait4, pid, status, options, rusage);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(__wait4)(pid, status, options, rusage);
+  if (res != -1) {
+    if (status) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
+    if (rusage) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rusage, struct_rusage_sz);
+  }
+  return res;
+}
+#define INIT_WAIT4 COMMON_INTERCEPT_FUNCTION(__wait4);
+#else
+INTERCEPTOR(int, wait4, int pid, int *status, int options, void *rusage) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wait4, pid, status, options, rusage);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(wait4)(pid, status, options, rusage);
+  if (res != -1) {
+    if (status) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
+    if (rusage) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rusage, struct_rusage_sz);
+  }
+  return res;
+}
+#define INIT_WAIT4 COMMON_INTERCEPT_FUNCTION(wait4);
+#endif  // SANITIZER_ANDROID
+#define INIT_WAIT                     \
+  COMMON_INTERCEPT_FUNCTION(wait);    \
+  COMMON_INTERCEPT_FUNCTION(waitid);  \
+  COMMON_INTERCEPT_FUNCTION(waitpid); \
+  COMMON_INTERCEPT_FUNCTION(wait3);
+#else
+#define INIT_WAIT
+#define INIT_WAIT4
+#endif
+
+#if SANITIZER_INTERCEPT_INET
+INTERCEPTOR(char *, inet_ntop, int af, const void *src, char *dst, u32 size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, inet_ntop, af, src, dst, size);
+  uptr sz = __sanitizer_in_addr_sz(af);
+  if (sz) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sz);
+  // FIXME: figure out read size based on the address family.
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(inet_ntop)(af, src, dst, size);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+INTERCEPTOR(int, inet_pton, int af, const char *src, void *dst) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, inet_pton, af, src, dst);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, src, 0);
+  // FIXME: figure out read size based on the address family.
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(inet_pton)(af, src, dst);
+  if (res == 1) {
+    uptr sz = __sanitizer_in_addr_sz(af);
+    if (sz) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, sz);
+  }
+  return res;
+}
+#define INIT_INET                       \
+  COMMON_INTERCEPT_FUNCTION(inet_ntop); \
+  COMMON_INTERCEPT_FUNCTION(inet_pton);
+#else
+#define INIT_INET
+#endif
+
+#if SANITIZER_INTERCEPT_INET
+INTERCEPTOR(int, inet_aton, const char *cp, void *dst) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, inet_aton, cp, dst);
+  if (cp) COMMON_INTERCEPTOR_READ_RANGE(ctx, cp, REAL(strlen)(cp) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(inet_aton)(cp, dst);
+  if (res != 0) {
+    uptr sz = __sanitizer_in_addr_sz(af_inet);
+    if (sz) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, sz);
+  }
+  return res;
+}
+#define INIT_INET_ATON COMMON_INTERCEPT_FUNCTION(inet_aton);
+#else
+#define INIT_INET_ATON
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_GETSCHEDPARAM
+INTERCEPTOR(int, pthread_getschedparam, uptr thread, int *policy, int *param) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_getschedparam, thread, policy, param);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(pthread_getschedparam)(thread, policy, param);
+  if (res == 0) {
+    if (policy) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, policy, sizeof(*policy));
+    if (param) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, param, sizeof(*param));
+  }
+  return res;
+}
+#define INIT_PTHREAD_GETSCHEDPARAM \
+  COMMON_INTERCEPT_FUNCTION(pthread_getschedparam);
+#else
+#define INIT_PTHREAD_GETSCHEDPARAM
+#endif
+
+#if SANITIZER_INTERCEPT_GETADDRINFO
+INTERCEPTOR(int, getaddrinfo, char *node, char *service,
+            struct __sanitizer_addrinfo *hints,
+            struct __sanitizer_addrinfo **out) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getaddrinfo, node, service, hints, out);
+  if (node) COMMON_INTERCEPTOR_READ_RANGE(ctx, node, REAL(strlen)(node) + 1);
+  if (service)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, service, REAL(strlen)(service) + 1);
+  if (hints)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, hints, sizeof(__sanitizer_addrinfo));
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getaddrinfo)(node, service, hints, out);
+  if (res == 0 && out) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, out, sizeof(*out));
+    struct __sanitizer_addrinfo *p = *out;
+    while (p) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
+      if (p->ai_addr)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->ai_addr, p->ai_addrlen);
+      if (p->ai_canonname)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->ai_canonname,
+                                       REAL(strlen)(p->ai_canonname) + 1);
+      p = p->ai_next;
+    }
+  }
+  return res;
+}
+#define INIT_GETADDRINFO COMMON_INTERCEPT_FUNCTION(getaddrinfo);
+#else
+#define INIT_GETADDRINFO
+#endif
+
+#if SANITIZER_INTERCEPT_GETNAMEINFO
+INTERCEPTOR(int, getnameinfo, void *sockaddr, unsigned salen, char *host,
+            unsigned hostlen, char *serv, unsigned servlen, int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getnameinfo, sockaddr, salen, host, hostlen,
+                           serv, servlen, flags);
+  // FIXME: consider adding READ_RANGE(sockaddr, salen)
+  // There is padding in in_addr that may make this too noisy
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res =
+      REAL(getnameinfo)(sockaddr, salen, host, hostlen, serv, servlen, flags);
+  if (res == 0) {
+    if (host && hostlen)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, host, REAL(strlen)(host) + 1);
+    if (serv && servlen)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, serv, REAL(strlen)(serv) + 1);
+  }
+  return res;
+}
+#define INIT_GETNAMEINFO COMMON_INTERCEPT_FUNCTION(getnameinfo);
+#else
+#define INIT_GETNAMEINFO
+#endif
+
+#if SANITIZER_INTERCEPT_GETSOCKNAME
+INTERCEPTOR(int, getsockname, int sock_fd, void *addr, int *addrlen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getsockname, sock_fd, addr, addrlen);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, addrlen, sizeof(*addrlen));
+  int addrlen_in = *addrlen;
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getsockname)(sock_fd, addr, addrlen);
+  if (res == 0) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, Min(addrlen_in, *addrlen));
+  }
+  return res;
+}
+#define INIT_GETSOCKNAME COMMON_INTERCEPT_FUNCTION(getsockname);
+#else
+#define INIT_GETSOCKNAME
+#endif
+
+#if SANITIZER_INTERCEPT_GETHOSTBYNAME || SANITIZER_INTERCEPT_GETHOSTBYNAME_R
+static void write_hostent(void *ctx, struct __sanitizer_hostent *h) {
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h, sizeof(__sanitizer_hostent));
+  if (h->h_name)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h->h_name, REAL(strlen)(h->h_name) + 1);
+  char **p = h->h_aliases;
+  while (*p) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
+    ++p;
+  }
+  COMMON_INTERCEPTOR_WRITE_RANGE(
+      ctx, h->h_aliases, (p - h->h_aliases + 1) * sizeof(*h->h_aliases));
+  p = h->h_addr_list;
+  while (*p) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, h->h_length);
+    ++p;
+  }
+  COMMON_INTERCEPTOR_WRITE_RANGE(
+      ctx, h->h_addr_list, (p - h->h_addr_list + 1) * sizeof(*h->h_addr_list));
+}
+#endif
+
+#if SANITIZER_INTERCEPT_GETHOSTBYNAME
+INTERCEPTOR(struct __sanitizer_hostent *, gethostbyname, char *name) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname, name);
+  struct __sanitizer_hostent *res = REAL(gethostbyname)(name);
+  if (res) write_hostent(ctx, res);
+  return res;
+}
+
+INTERCEPTOR(struct __sanitizer_hostent *, gethostbyaddr, void *addr, int len,
+            int type) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostbyaddr, addr, len, type);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, len);
+  struct __sanitizer_hostent *res = REAL(gethostbyaddr)(addr, len, type);
+  if (res) write_hostent(ctx, res);
+  return res;
+}
+
+INTERCEPTOR(struct __sanitizer_hostent *, gethostent, int fake) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostent, fake);
+  struct __sanitizer_hostent *res = REAL(gethostent)(fake);
+  if (res) write_hostent(ctx, res);
+  return res;
+}
+
+INTERCEPTOR(struct __sanitizer_hostent *, gethostbyname2, char *name, int af) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname2, name, af);
+  struct __sanitizer_hostent *res = REAL(gethostbyname2)(name, af);
+  if (res) write_hostent(ctx, res);
+  return res;
+}
+#define INIT_GETHOSTBYNAME                  \
+  COMMON_INTERCEPT_FUNCTION(gethostent);    \
+  COMMON_INTERCEPT_FUNCTION(gethostbyaddr); \
+  COMMON_INTERCEPT_FUNCTION(gethostbyname); \
+  COMMON_INTERCEPT_FUNCTION(gethostbyname2);
+#else
+#define INIT_GETHOSTBYNAME
+#endif
+
+#if SANITIZER_INTERCEPT_GETHOSTBYNAME_R
+INTERCEPTOR(int, gethostbyname_r, char *name, struct __sanitizer_hostent *ret,
+            char *buf, SIZE_T buflen, __sanitizer_hostent **result,
+            int *h_errnop) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname_r, name, ret, buf, buflen, result,
+                           h_errnop);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(gethostbyname_r)(name, ret, buf, buflen, result, h_errnop);
+  if (result) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+    if (res == 0 && *result) write_hostent(ctx, *result);
+  }
+  if (h_errnop)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h_errnop, sizeof(*h_errnop));
+  return res;
+}
+#define INIT_GETHOSTBYNAME_R COMMON_INTERCEPT_FUNCTION(gethostbyname_r);
+#else
+#define INIT_GETHOSTBYNAME_R
+#endif
+
+#if SANITIZER_INTERCEPT_GETHOSTENT_R
+INTERCEPTOR(int, gethostent_r, struct __sanitizer_hostent *ret, char *buf,
+            SIZE_T buflen, __sanitizer_hostent **result, int *h_errnop) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostent_r, ret, buf, buflen, result,
+                           h_errnop);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(gethostent_r)(ret, buf, buflen, result, h_errnop);
+  if (result) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+    if (res == 0 && *result) write_hostent(ctx, *result);
+  }
+  if (h_errnop)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h_errnop, sizeof(*h_errnop));
+  return res;
+}
+#define INIT_GETHOSTENT_R                  \
+  COMMON_INTERCEPT_FUNCTION(gethostent_r);
+#else
+#define INIT_GETHOSTENT_R
+#endif
+
+#if SANITIZER_INTERCEPT_GETHOSTBYADDR_R
+INTERCEPTOR(int, gethostbyaddr_r, void *addr, int len, int type,
+            struct __sanitizer_hostent *ret, char *buf, SIZE_T buflen,
+            __sanitizer_hostent **result, int *h_errnop) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostbyaddr_r, addr, len, type, ret, buf,
+                           buflen, result, h_errnop);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, len);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(gethostbyaddr_r)(addr, len, type, ret, buf, buflen, result,
+                                  h_errnop);
+  if (result) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+    if (res == 0 && *result) write_hostent(ctx, *result);
+  }
+  if (h_errnop)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h_errnop, sizeof(*h_errnop));
+  return res;
+}
+#define INIT_GETHOSTBYADDR_R                  \
+  COMMON_INTERCEPT_FUNCTION(gethostbyaddr_r);
+#else
+#define INIT_GETHOSTBYADDR_R
+#endif
+
+#if SANITIZER_INTERCEPT_GETHOSTBYNAME2_R
+INTERCEPTOR(int, gethostbyname2_r, char *name, int af,
+            struct __sanitizer_hostent *ret, char *buf, SIZE_T buflen,
+            __sanitizer_hostent **result, int *h_errnop) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname2_r, name, af, ret, buf, buflen,
+                           result, h_errnop);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res =
+      REAL(gethostbyname2_r)(name, af, ret, buf, buflen, result, h_errnop);
+  if (result) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+    if (res == 0 && *result) write_hostent(ctx, *result);
+  }
+  if (h_errnop)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h_errnop, sizeof(*h_errnop));
+  return res;
+}
+#define INIT_GETHOSTBYNAME2_R                  \
+  COMMON_INTERCEPT_FUNCTION(gethostbyname2_r);
+#else
+#define INIT_GETHOSTBYNAME2_R
+#endif
+
+#if SANITIZER_INTERCEPT_GETSOCKOPT
+INTERCEPTOR(int, getsockopt, int sockfd, int level, int optname, void *optval,
+            int *optlen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getsockopt, sockfd, level, optname, optval,
+                           optlen);
+  if (optlen) COMMON_INTERCEPTOR_READ_RANGE(ctx, optlen, sizeof(*optlen));
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getsockopt)(sockfd, level, optname, optval, optlen);
+  if (res == 0)
+    if (optval && optlen) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, optval, *optlen);
+  return res;
+}
+#define INIT_GETSOCKOPT COMMON_INTERCEPT_FUNCTION(getsockopt);
+#else
+#define INIT_GETSOCKOPT
+#endif
+
+#if SANITIZER_INTERCEPT_ACCEPT
+INTERCEPTOR(int, accept, int fd, void *addr, unsigned *addrlen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, accept, fd, addr, addrlen);
+  unsigned addrlen0 = 0;
+  if (addrlen) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, addrlen, sizeof(*addrlen));
+    addrlen0 = *addrlen;
+  }
+  int fd2 = REAL(accept)(fd, addr, addrlen);
+  if (fd2 >= 0) {
+    if (fd >= 0) COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, fd2);
+    if (addr && addrlen)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, Min(*addrlen, addrlen0));
+  }
+  return fd2;
+}
+#define INIT_ACCEPT COMMON_INTERCEPT_FUNCTION(accept);
+#else
+#define INIT_ACCEPT
+#endif
+
+#if SANITIZER_INTERCEPT_ACCEPT4
+INTERCEPTOR(int, accept4, int fd, void *addr, unsigned *addrlen, int f) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, accept4, fd, addr, addrlen, f);
+  unsigned addrlen0 = 0;
+  if (addrlen) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, addrlen, sizeof(*addrlen));
+    addrlen0 = *addrlen;
+  }
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int fd2 = REAL(accept4)(fd, addr, addrlen, f);
+  if (fd2 >= 0) {
+    if (fd >= 0) COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, fd2);
+    if (addr && addrlen)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, Min(*addrlen, addrlen0));
+  }
+  return fd2;
+}
+#define INIT_ACCEPT4 COMMON_INTERCEPT_FUNCTION(accept4);
+#else
+#define INIT_ACCEPT4
+#endif
+
+#if SANITIZER_INTERCEPT_MODF
+INTERCEPTOR(double, modf, double x, double *iptr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, modf, x, iptr);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  double res = REAL(modf)(x, iptr);
+  if (iptr) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, iptr, sizeof(*iptr));
+  }
+  return res;
+}
+INTERCEPTOR(float, modff, float x, float *iptr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, modff, x, iptr);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  float res = REAL(modff)(x, iptr);
+  if (iptr) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, iptr, sizeof(*iptr));
+  }
+  return res;
+}
+INTERCEPTOR(long double, modfl, long double x, long double *iptr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, modfl, x, iptr);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  long double res = REAL(modfl)(x, iptr);
+  if (iptr) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, iptr, sizeof(*iptr));
+  }
+  return res;
+}
+#define INIT_MODF                   \
+  COMMON_INTERCEPT_FUNCTION(modf);  \
+  COMMON_INTERCEPT_FUNCTION(modff); \
+  COMMON_INTERCEPT_FUNCTION(modfl);
+#else
+#define INIT_MODF
+#endif
+
+#if SANITIZER_INTERCEPT_RECVMSG
+static void write_msghdr(void *ctx, struct __sanitizer_msghdr *msg,
+                         SSIZE_T maxlen) {
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, msg, sizeof(*msg));
+  if (msg->msg_name && msg->msg_namelen)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, msg->msg_name, msg->msg_namelen);
+  if (msg->msg_iov && msg->msg_iovlen)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, msg->msg_iov,
+                                   sizeof(*msg->msg_iov) * msg->msg_iovlen);
+  write_iovec(ctx, msg->msg_iov, msg->msg_iovlen, maxlen);
+  if (msg->msg_control && msg->msg_controllen)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, msg->msg_control, msg->msg_controllen);
+}
+
+INTERCEPTOR(SSIZE_T, recvmsg, int fd, struct __sanitizer_msghdr *msg,
+            int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, recvmsg, fd, msg, flags);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(recvmsg)(fd, msg, flags);
+  if (res >= 0) {
+    if (fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+    if (msg) {
+      write_msghdr(ctx, msg, res);
+      COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg);
+    }
+  }
+  return res;
+}
+#define INIT_RECVMSG COMMON_INTERCEPT_FUNCTION(recvmsg);
+#else
+#define INIT_RECVMSG
+#endif
+
+#if SANITIZER_INTERCEPT_GETPEERNAME
+INTERCEPTOR(int, getpeername, int sockfd, void *addr, unsigned *addrlen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpeername, sockfd, addr, addrlen);
+  unsigned addr_sz;
+  if (addrlen) addr_sz = *addrlen;
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getpeername)(sockfd, addr, addrlen);
+  if (!res && addr && addrlen)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, Min(addr_sz, *addrlen));
+  return res;
+}
+#define INIT_GETPEERNAME COMMON_INTERCEPT_FUNCTION(getpeername);
+#else
+#define INIT_GETPEERNAME
+#endif
+
+#if SANITIZER_INTERCEPT_SYSINFO
+INTERCEPTOR(int, sysinfo, void *info) {
+  void *ctx;
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  COMMON_INTERCEPTOR_ENTER(ctx, sysinfo, info);
+  int res = REAL(sysinfo)(info);
+  if (!res && info)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, info, struct_sysinfo_sz);
+  return res;
+}
+#define INIT_SYSINFO COMMON_INTERCEPT_FUNCTION(sysinfo);
+#else
+#define INIT_SYSINFO
+#endif
+
+#if SANITIZER_INTERCEPT_READDIR
+INTERCEPTOR(__sanitizer_dirent *, opendir, const char *path) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, opendir, path);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  __sanitizer_dirent *res = REAL(opendir)(path);
+  if (res)
+    COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path);
+  return res;
+}
+
+INTERCEPTOR(__sanitizer_dirent *, readdir, void *dirp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, readdir, dirp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  __sanitizer_dirent *res = REAL(readdir)(dirp);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, res->d_reclen);
+  return res;
+}
+
+INTERCEPTOR(int, readdir_r, void *dirp, __sanitizer_dirent *entry,
+            __sanitizer_dirent **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, readdir_r, dirp, entry, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(readdir_r)(dirp, entry, result);
+  if (!res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+    if (*result)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *result, (*result)->d_reclen);
+  }
+  return res;
+}
+
+#define INIT_READDIR                  \
+  COMMON_INTERCEPT_FUNCTION(opendir); \
+  COMMON_INTERCEPT_FUNCTION(readdir); \
+  COMMON_INTERCEPT_FUNCTION(readdir_r);
+#else
+#define INIT_READDIR
+#endif
+
+#if SANITIZER_INTERCEPT_READDIR64
+INTERCEPTOR(__sanitizer_dirent64 *, readdir64, void *dirp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, readdir64, dirp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  __sanitizer_dirent64 *res = REAL(readdir64)(dirp);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, res->d_reclen);
+  return res;
+}
+
+INTERCEPTOR(int, readdir64_r, void *dirp, __sanitizer_dirent64 *entry,
+            __sanitizer_dirent64 **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, readdir64_r, dirp, entry, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(readdir64_r)(dirp, entry, result);
+  if (!res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+    if (*result)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *result, (*result)->d_reclen);
+  }
+  return res;
+}
+#define INIT_READDIR64                  \
+  COMMON_INTERCEPT_FUNCTION(readdir64); \
+  COMMON_INTERCEPT_FUNCTION(readdir64_r);
+#else
+#define INIT_READDIR64
+#endif
+
+#if SANITIZER_INTERCEPT_PTRACE
+INTERCEPTOR(uptr, ptrace, int request, int pid, void *addr, void *data) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ptrace, request, pid, addr, data);
+  __sanitizer_iovec local_iovec;
+
+  if (data) {
+    if (request == ptrace_setregs)
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_regs_struct_sz);
+    else if (request == ptrace_setfpregs)
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_fpregs_struct_sz);
+    else if (request == ptrace_setfpxregs)
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_fpxregs_struct_sz);
+    else if (request == ptrace_setvfpregs)
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_vfpregs_struct_sz);
+    else if (request == ptrace_setsiginfo)
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, siginfo_t_sz);
+    // Some kernel might zero the iovec::iov_base in case of invalid
+    // write access.  In this case copy the invalid address for further
+    // inspection.
+    else if (request == ptrace_setregset || request == ptrace_getregset) {
+      __sanitizer_iovec *iovec = (__sanitizer_iovec*)data;
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, iovec, sizeof(*iovec));
+      local_iovec = *iovec;
+      if (request == ptrace_setregset)
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, iovec->iov_base, iovec->iov_len);
+    }
+  }
+
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  uptr res = REAL(ptrace)(request, pid, addr, data);
+
+  if (!res && data) {
+    // Note that PEEK* requests assign different meaning to the return value.
+    // This function does not handle them (nor does it need to).
+    if (request == ptrace_getregs)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data, struct_user_regs_struct_sz);
+    else if (request == ptrace_getfpregs)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data, struct_user_fpregs_struct_sz);
+    else if (request == ptrace_getfpxregs)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data, struct_user_fpxregs_struct_sz);
+    else if (request == ptrace_getvfpregs)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data, struct_user_vfpregs_struct_sz);
+    else if (request == ptrace_getsiginfo)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data, siginfo_t_sz);
+    else if (request == ptrace_geteventmsg)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data, sizeof(unsigned long));
+    else if (request == ptrace_getregset) {
+      __sanitizer_iovec *iovec = (__sanitizer_iovec*)data;
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, iovec, sizeof(*iovec));
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, local_iovec.iov_base,
+                                     local_iovec.iov_len);
+    }
+  }
+  return res;
+}
+
+#define INIT_PTRACE COMMON_INTERCEPT_FUNCTION(ptrace);
+#else
+#define INIT_PTRACE
+#endif
+
+#if SANITIZER_INTERCEPT_SETLOCALE
+INTERCEPTOR(char *, setlocale, int category, char *locale) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, setlocale, category, locale);
+  if (locale)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, locale, REAL(strlen)(locale) + 1);
+  char *res = REAL(setlocale)(category, locale);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+
+#define INIT_SETLOCALE COMMON_INTERCEPT_FUNCTION(setlocale);
+#else
+#define INIT_SETLOCALE
+#endif
+
+#if SANITIZER_INTERCEPT_GETCWD
+INTERCEPTOR(char *, getcwd, char *buf, SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getcwd, buf, size);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(getcwd)(buf, size);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+#define INIT_GETCWD COMMON_INTERCEPT_FUNCTION(getcwd);
+#else
+#define INIT_GETCWD
+#endif
+
+#if SANITIZER_INTERCEPT_GET_CURRENT_DIR_NAME
+INTERCEPTOR(char *, get_current_dir_name, int fake) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, get_current_dir_name, fake);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(get_current_dir_name)(fake);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+
+#define INIT_GET_CURRENT_DIR_NAME \
+  COMMON_INTERCEPT_FUNCTION(get_current_dir_name);
+#else
+#define INIT_GET_CURRENT_DIR_NAME
+#endif
+
+UNUSED static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) {
+  CHECK(endptr);
+  if (nptr == *endptr) {
+    // No digits were found at strtol call, we need to find out the last
+    // symbol accessed by strtoll on our own.
+    // We get this symbol by skipping leading blanks and optional +/- sign.
+    while (IsSpace(*nptr)) nptr++;
+    if (*nptr == '+' || *nptr == '-') nptr++;
+    *endptr = const_cast<char *>(nptr);
+  }
+  CHECK(*endptr >= nptr);
+}
+
+UNUSED static inline void StrtolFixAndCheck(void *ctx, const char *nptr,
+                             char **endptr, char *real_endptr, int base) {
+  if (endptr) {
+    *endptr = real_endptr;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, endptr, sizeof(*endptr));
+  }
+  // If base has unsupported value, strtol can exit with EINVAL
+  // without reading any characters. So do additional checks only
+  // if base is valid.
+  bool is_valid_base = (base == 0) || (2 <= base && base <= 36);
+  if (is_valid_base) {
+    FixRealStrtolEndptr(nptr, &real_endptr);
+  }
+  COMMON_INTERCEPTOR_READ_STRING(ctx, nptr, is_valid_base ?
+                                 (real_endptr - nptr) + 1 : 0);
+}
+
+
+#if SANITIZER_INTERCEPT_STRTOIMAX
+INTERCEPTOR(INTMAX_T, strtoimax, const char *nptr, char **endptr, int base) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strtoimax, nptr, endptr, base);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *real_endptr;
+  INTMAX_T res = REAL(strtoimax)(nptr, &real_endptr, base);
+  StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base);
+  return res;
+}
+
+INTERCEPTOR(INTMAX_T, strtoumax, const char *nptr, char **endptr, int base) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strtoumax, nptr, endptr, base);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *real_endptr;
+  INTMAX_T res = REAL(strtoumax)(nptr, &real_endptr, base);
+  StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base);
+  return res;
+}
+
+#define INIT_STRTOIMAX                  \
+  COMMON_INTERCEPT_FUNCTION(strtoimax); \
+  COMMON_INTERCEPT_FUNCTION(strtoumax);
+#else
+#define INIT_STRTOIMAX
+#endif
+
+#if SANITIZER_INTERCEPT_MBSTOWCS
+INTERCEPTOR(SIZE_T, mbstowcs, wchar_t *dest, const char *src, SIZE_T len) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, mbstowcs, dest, src, len);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(mbstowcs)(dest, src, len);
+  if (res != (SIZE_T) - 1 && dest) {
+    SIZE_T write_cnt = res + (res < len);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt * sizeof(wchar_t));
+  }
+  return res;
+}
+
+INTERCEPTOR(SIZE_T, mbsrtowcs, wchar_t *dest, const char **src, SIZE_T len,
+            void *ps) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, mbsrtowcs, dest, src, len, ps);
+  if (src) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
+  if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(mbsrtowcs)(dest, src, len, ps);
+  if (res != (SIZE_T)(-1) && dest && src) {
+    // This function, and several others, may or may not write the terminating
+    // \0 character. They write it iff they clear *src.
+    SIZE_T write_cnt = res + !*src;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt * sizeof(wchar_t));
+  }
+  return res;
+}
+
+#define INIT_MBSTOWCS                  \
+  COMMON_INTERCEPT_FUNCTION(mbstowcs); \
+  COMMON_INTERCEPT_FUNCTION(mbsrtowcs);
+#else
+#define INIT_MBSTOWCS
+#endif
+
+#if SANITIZER_INTERCEPT_MBSNRTOWCS
+INTERCEPTOR(SIZE_T, mbsnrtowcs, wchar_t *dest, const char **src, SIZE_T nms,
+            SIZE_T len, void *ps) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, mbsnrtowcs, dest, src, nms, len, ps);
+  if (src) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
+    if (nms) COMMON_INTERCEPTOR_READ_RANGE(ctx, *src, nms);
+  }
+  if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(mbsnrtowcs)(dest, src, nms, len, ps);
+  if (res != (SIZE_T)(-1) && dest && src) {
+    SIZE_T write_cnt = res + !*src;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt * sizeof(wchar_t));
+  }
+  return res;
+}
+
+#define INIT_MBSNRTOWCS COMMON_INTERCEPT_FUNCTION(mbsnrtowcs);
+#else
+#define INIT_MBSNRTOWCS
+#endif
+
+#if SANITIZER_INTERCEPT_WCSTOMBS
+INTERCEPTOR(SIZE_T, wcstombs, char *dest, const wchar_t *src, SIZE_T len) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wcstombs, dest, src, len);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(wcstombs)(dest, src, len);
+  if (res != (SIZE_T) - 1 && dest) {
+    SIZE_T write_cnt = res + (res < len);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt);
+  }
+  return res;
+}
+
+INTERCEPTOR(SIZE_T, wcsrtombs, char *dest, const wchar_t **src, SIZE_T len,
+            void *ps) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wcsrtombs, dest, src, len, ps);
+  if (src) COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
+  if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(wcsrtombs)(dest, src, len, ps);
+  if (res != (SIZE_T) - 1 && dest && src) {
+    SIZE_T write_cnt = res + !*src;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt);
+  }
+  return res;
+}
+
+#define INIT_WCSTOMBS                  \
+  COMMON_INTERCEPT_FUNCTION(wcstombs); \
+  COMMON_INTERCEPT_FUNCTION(wcsrtombs);
+#else
+#define INIT_WCSTOMBS
+#endif
+
+#if SANITIZER_INTERCEPT_WCSNRTOMBS
+INTERCEPTOR(SIZE_T, wcsnrtombs, char *dest, const wchar_t **src, SIZE_T nms,
+            SIZE_T len, void *ps) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wcsnrtombs, dest, src, nms, len, ps);
+  if (src) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, src, sizeof(*src));
+    if (nms) COMMON_INTERCEPTOR_READ_RANGE(ctx, *src, nms);
+  }
+  if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(wcsnrtombs)(dest, src, nms, len, ps);
+  if (res != ((SIZE_T)-1) && dest && src) {
+    SIZE_T write_cnt = res + !*src;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt);
+  }
+  return res;
+}
+
+#define INIT_WCSNRTOMBS COMMON_INTERCEPT_FUNCTION(wcsnrtombs);
+#else
+#define INIT_WCSNRTOMBS
+#endif
+
+
+#if SANITIZER_INTERCEPT_WCRTOMB
+INTERCEPTOR(SIZE_T, wcrtomb, char *dest, wchar_t src, void *ps) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wcrtomb, dest, src, ps);
+  if (ps) COMMON_INTERCEPTOR_READ_RANGE(ctx, ps, mbstate_t_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(wcrtomb)(dest, src, ps);
+  if (res != ((SIZE_T)-1) && dest) {
+    SIZE_T write_cnt = res;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, write_cnt);
+  }
+  return res;
+}
+
+#define INIT_WCRTOMB COMMON_INTERCEPT_FUNCTION(wcrtomb);
+#else
+#define INIT_WCRTOMB
+#endif
+
+#if SANITIZER_INTERCEPT_TCGETATTR
+INTERCEPTOR(int, tcgetattr, int fd, void *termios_p) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, tcgetattr, fd, termios_p);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(tcgetattr)(fd, termios_p);
+  if (!res && termios_p)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, termios_p, struct_termios_sz);
+  return res;
+}
+
+#define INIT_TCGETATTR COMMON_INTERCEPT_FUNCTION(tcgetattr);
+#else
+#define INIT_TCGETATTR
+#endif
+
+#if SANITIZER_INTERCEPT_REALPATH
+INTERCEPTOR(char *, realpath, const char *path, char *resolved_path) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, realpath, path, resolved_path);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+
+  // Workaround a bug in glibc where dlsym(RTLD_NEXT, ...) returns the oldest
+  // version of a versioned symbol. For realpath(), this gives us something
+  // (called __old_realpath) that does not handle NULL in the second argument.
+  // Handle it as part of the interceptor.
+  char *allocated_path = nullptr;
+  if (!resolved_path)
+    allocated_path = resolved_path = (char *)WRAP(malloc)(path_max + 1);
+
+  char *res = REAL(realpath)(path, resolved_path);
+  if (allocated_path && !res) WRAP(free)(allocated_path);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+#define INIT_REALPATH COMMON_INTERCEPT_FUNCTION(realpath);
+#else
+#define INIT_REALPATH
+#endif
+
+#if SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME
+INTERCEPTOR(char *, canonicalize_file_name, const char *path) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, canonicalize_file_name, path);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  char *res = REAL(canonicalize_file_name)(path);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+#define INIT_CANONICALIZE_FILE_NAME \
+  COMMON_INTERCEPT_FUNCTION(canonicalize_file_name);
+#else
+#define INIT_CANONICALIZE_FILE_NAME
+#endif
+
+#if SANITIZER_INTERCEPT_CONFSTR
+INTERCEPTOR(SIZE_T, confstr, int name, char *buf, SIZE_T len) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, confstr, name, buf, len);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(confstr)(name, buf, len);
+  if (buf && res)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, res < len ? res : len);
+  return res;
+}
+#define INIT_CONFSTR COMMON_INTERCEPT_FUNCTION(confstr);
+#else
+#define INIT_CONFSTR
+#endif
+
+#if SANITIZER_INTERCEPT_SCHED_GETAFFINITY
+INTERCEPTOR(int, sched_getaffinity, int pid, SIZE_T cpusetsize, void *mask) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sched_getaffinity, pid, cpusetsize, mask);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sched_getaffinity)(pid, cpusetsize, mask);
+  if (mask && !res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mask, cpusetsize);
+  return res;
+}
+#define INIT_SCHED_GETAFFINITY COMMON_INTERCEPT_FUNCTION(sched_getaffinity);
+#else
+#define INIT_SCHED_GETAFFINITY
+#endif
+
+#if SANITIZER_INTERCEPT_SCHED_GETPARAM
+INTERCEPTOR(int, sched_getparam, int pid, void *param) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sched_getparam, pid, param);
+  int res = REAL(sched_getparam)(pid, param);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, param, struct_sched_param_sz);
+  return res;
+}
+#define INIT_SCHED_GETPARAM COMMON_INTERCEPT_FUNCTION(sched_getparam);
+#else
+#define INIT_SCHED_GETPARAM
+#endif
+
+#if SANITIZER_INTERCEPT_STRERROR
+INTERCEPTOR(char *, strerror, int errnum) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strerror, errnum);
+  char *res = REAL(strerror)(errnum);
+  if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
+  return res;
+}
+#define INIT_STRERROR COMMON_INTERCEPT_FUNCTION(strerror);
+#else
+#define INIT_STRERROR
+#endif
+
+#if SANITIZER_INTERCEPT_STRERROR_R
+INTERCEPTOR(char *, strerror_r, int errnum, char *buf, SIZE_T buflen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, strerror_r, errnum, buf, buflen);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(strerror_r)(errnum, buf, buflen);
+  // There are 2 versions of strerror_r:
+  //  * POSIX version returns 0 on success, negative error code on failure,
+  //    writes message to buf.
+  //  * GNU version returns message pointer, which points to either buf or some
+  //    static storage.
+  SIZE_T posix_res = (SIZE_T)res;
+  if (posix_res < 1024 || posix_res > (SIZE_T) - 1024) {
+    // POSIX version. Spec is not clear on whether buf is NULL-terminated.
+    // At least on OSX, buf contents are valid even when the call fails.
+    SIZE_T sz = internal_strnlen(buf, buflen);
+    if (sz < buflen) ++sz;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, sz);
+  } else {
+    // GNU version.
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+#define INIT_STRERROR_R COMMON_INTERCEPT_FUNCTION(strerror_r);
+#else
+#define INIT_STRERROR_R
+#endif
+
+#if SANITIZER_INTERCEPT_XPG_STRERROR_R
+INTERCEPTOR(int, __xpg_strerror_r, int errnum, char *buf, SIZE_T buflen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __xpg_strerror_r, errnum, buf, buflen);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(__xpg_strerror_r)(errnum, buf, buflen);
+  // This version always returns a null-terminated string.
+  if (buf && buflen)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
+  return res;
+}
+#define INIT_XPG_STRERROR_R COMMON_INTERCEPT_FUNCTION(__xpg_strerror_r);
+#else
+#define INIT_XPG_STRERROR_R
+#endif
+
+#if SANITIZER_INTERCEPT_SCANDIR
+typedef int (*scandir_filter_f)(const struct __sanitizer_dirent *);
+typedef int (*scandir_compar_f)(const struct __sanitizer_dirent **,
+                                const struct __sanitizer_dirent **);
+
+static THREADLOCAL scandir_filter_f scandir_filter;
+static THREADLOCAL scandir_compar_f scandir_compar;
+
+static int wrapped_scandir_filter(const struct __sanitizer_dirent *dir) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(1);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(dir, dir->d_reclen);
+  return scandir_filter(dir);
+}
+
+static int wrapped_scandir_compar(const struct __sanitizer_dirent **a,
+                                  const struct __sanitizer_dirent **b) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(2);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(a, sizeof(*a));
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(*a, (*a)->d_reclen);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(b, sizeof(*b));
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(*b, (*b)->d_reclen);
+  return scandir_compar(a, b);
+}
+
+INTERCEPTOR(int, scandir, char *dirp, __sanitizer_dirent ***namelist,
+            scandir_filter_f filter, scandir_compar_f compar) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, scandir, dirp, namelist, filter, compar);
+  if (dirp) COMMON_INTERCEPTOR_READ_RANGE(ctx, dirp, REAL(strlen)(dirp) + 1);
+  scandir_filter = filter;
+  scandir_compar = compar;
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(scandir)(dirp, namelist,
+                          filter ? wrapped_scandir_filter : nullptr,
+                          compar ? wrapped_scandir_compar : nullptr);
+  scandir_filter = nullptr;
+  scandir_compar = nullptr;
+  if (namelist && res > 0) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, namelist, sizeof(*namelist));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *namelist, sizeof(**namelist) * res);
+    for (int i = 0; i < res; ++i)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, (*namelist)[i],
+                                     (*namelist)[i]->d_reclen);
+  }
+  return res;
+}
+#define INIT_SCANDIR COMMON_INTERCEPT_FUNCTION(scandir);
+#else
+#define INIT_SCANDIR
+#endif
+
+#if SANITIZER_INTERCEPT_SCANDIR64
+typedef int (*scandir64_filter_f)(const struct __sanitizer_dirent64 *);
+typedef int (*scandir64_compar_f)(const struct __sanitizer_dirent64 **,
+                                  const struct __sanitizer_dirent64 **);
+
+static THREADLOCAL scandir64_filter_f scandir64_filter;
+static THREADLOCAL scandir64_compar_f scandir64_compar;
+
+static int wrapped_scandir64_filter(const struct __sanitizer_dirent64 *dir) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(1);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(dir, dir->d_reclen);
+  return scandir64_filter(dir);
+}
+
+static int wrapped_scandir64_compar(const struct __sanitizer_dirent64 **a,
+                                    const struct __sanitizer_dirent64 **b) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(2);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(a, sizeof(*a));
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(*a, (*a)->d_reclen);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(b, sizeof(*b));
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(*b, (*b)->d_reclen);
+  return scandir64_compar(a, b);
+}
+
+INTERCEPTOR(int, scandir64, char *dirp, __sanitizer_dirent64 ***namelist,
+            scandir64_filter_f filter, scandir64_compar_f compar) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, scandir64, dirp, namelist, filter, compar);
+  if (dirp) COMMON_INTERCEPTOR_READ_RANGE(ctx, dirp, REAL(strlen)(dirp) + 1);
+  scandir64_filter = filter;
+  scandir64_compar = compar;
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res =
+      REAL(scandir64)(dirp, namelist,
+                      filter ? wrapped_scandir64_filter : nullptr,
+                      compar ? wrapped_scandir64_compar : nullptr);
+  scandir64_filter = nullptr;
+  scandir64_compar = nullptr;
+  if (namelist && res > 0) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, namelist, sizeof(*namelist));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *namelist, sizeof(**namelist) * res);
+    for (int i = 0; i < res; ++i)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, (*namelist)[i],
+                                     (*namelist)[i]->d_reclen);
+  }
+  return res;
+}
+#define INIT_SCANDIR64 COMMON_INTERCEPT_FUNCTION(scandir64);
+#else
+#define INIT_SCANDIR64
+#endif
+
+#if SANITIZER_INTERCEPT_GETGROUPS
+INTERCEPTOR(int, getgroups, int size, u32 *lst) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getgroups, size, lst);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getgroups)(size, lst);
+  if (res && lst) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, lst, res * sizeof(*lst));
+  return res;
+}
+#define INIT_GETGROUPS COMMON_INTERCEPT_FUNCTION(getgroups);
+#else
+#define INIT_GETGROUPS
+#endif
+
+#if SANITIZER_INTERCEPT_POLL
+static void read_pollfd(void *ctx, __sanitizer_pollfd *fds,
+                        __sanitizer_nfds_t nfds) {
+  for (unsigned i = 0; i < nfds; ++i) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, &fds[i].fd, sizeof(fds[i].fd));
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, &fds[i].events, sizeof(fds[i].events));
+  }
+}
+
+static void write_pollfd(void *ctx, __sanitizer_pollfd *fds,
+                         __sanitizer_nfds_t nfds) {
+  for (unsigned i = 0; i < nfds; ++i)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &fds[i].revents,
+                                   sizeof(fds[i].revents));
+}
+
+INTERCEPTOR(int, poll, __sanitizer_pollfd *fds, __sanitizer_nfds_t nfds,
+            int timeout) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, poll, fds, nfds, timeout);
+  if (fds && nfds) read_pollfd(ctx, fds, nfds);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(poll)(fds, nfds, timeout);
+  if (fds && nfds) write_pollfd(ctx, fds, nfds);
+  return res;
+}
+#define INIT_POLL COMMON_INTERCEPT_FUNCTION(poll);
+#else
+#define INIT_POLL
+#endif
+
+#if SANITIZER_INTERCEPT_PPOLL
+INTERCEPTOR(int, ppoll, __sanitizer_pollfd *fds, __sanitizer_nfds_t nfds,
+            void *timeout_ts, __sanitizer_sigset_t *sigmask) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ppoll, fds, nfds, timeout_ts, sigmask);
+  if (fds && nfds) read_pollfd(ctx, fds, nfds);
+  if (timeout_ts)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, timeout_ts, struct_timespec_sz);
+  // FIXME: read sigmask when all of sigemptyset, etc are intercepted.
+  int res =
+      COMMON_INTERCEPTOR_BLOCK_REAL(ppoll)(fds, nfds, timeout_ts, sigmask);
+  if (fds && nfds) write_pollfd(ctx, fds, nfds);
+  return res;
+}
+#define INIT_PPOLL COMMON_INTERCEPT_FUNCTION(ppoll);
+#else
+#define INIT_PPOLL
+#endif
+
+#if SANITIZER_INTERCEPT_WORDEXP
+INTERCEPTOR(int, wordexp, char *s, __sanitizer_wordexp_t *p, int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, wordexp, s, p, flags);
+  if (s) COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(wordexp)(s, p, flags);
+  if (!res && p) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
+    if (p->we_wordc)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->we_wordv,
+                                     sizeof(*p->we_wordv) * p->we_wordc);
+    for (uptr i = 0; i < p->we_wordc; ++i) {
+      char *w = p->we_wordv[i];
+      if (w) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, w, REAL(strlen)(w) + 1);
+    }
+  }
+  return res;
+}
+#define INIT_WORDEXP COMMON_INTERCEPT_FUNCTION(wordexp);
+#else
+#define INIT_WORDEXP
+#endif
+
+#if SANITIZER_INTERCEPT_SIGWAIT
+INTERCEPTOR(int, sigwait, __sanitizer_sigset_t *set, int *sig) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigwait, set, sig);
+  // FIXME: read sigset_t when all of sigemptyset, etc are intercepted
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigwait)(set, sig);
+  if (!res && sig) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sig, sizeof(*sig));
+  return res;
+}
+#define INIT_SIGWAIT COMMON_INTERCEPT_FUNCTION(sigwait);
+#else
+#define INIT_SIGWAIT
+#endif
+
+#if SANITIZER_INTERCEPT_SIGWAITINFO
+INTERCEPTOR(int, sigwaitinfo, __sanitizer_sigset_t *set, void *info) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigwaitinfo, set, info);
+  // FIXME: read sigset_t when all of sigemptyset, etc are intercepted
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigwaitinfo)(set, info);
+  if (res > 0 && info) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, info, siginfo_t_sz);
+  return res;
+}
+#define INIT_SIGWAITINFO COMMON_INTERCEPT_FUNCTION(sigwaitinfo);
+#else
+#define INIT_SIGWAITINFO
+#endif
+
+#if SANITIZER_INTERCEPT_SIGTIMEDWAIT
+INTERCEPTOR(int, sigtimedwait, __sanitizer_sigset_t *set, void *info,
+            void *timeout) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigtimedwait, set, info, timeout);
+  if (timeout) COMMON_INTERCEPTOR_READ_RANGE(ctx, timeout, struct_timespec_sz);
+  // FIXME: read sigset_t when all of sigemptyset, etc are intercepted
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigtimedwait)(set, info, timeout);
+  if (res > 0 && info) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, info, siginfo_t_sz);
+  return res;
+}
+#define INIT_SIGTIMEDWAIT COMMON_INTERCEPT_FUNCTION(sigtimedwait);
+#else
+#define INIT_SIGTIMEDWAIT
+#endif
+
+#if SANITIZER_INTERCEPT_SIGSETOPS
+INTERCEPTOR(int, sigemptyset, __sanitizer_sigset_t *set) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigemptyset, set);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigemptyset)(set);
+  if (!res && set) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, set, sizeof(*set));
+  return res;
+}
+
+INTERCEPTOR(int, sigfillset, __sanitizer_sigset_t *set) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigfillset, set);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigfillset)(set);
+  if (!res && set) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, set, sizeof(*set));
+  return res;
+}
+#define INIT_SIGSETOPS                    \
+  COMMON_INTERCEPT_FUNCTION(sigemptyset); \
+  COMMON_INTERCEPT_FUNCTION(sigfillset);
+#else
+#define INIT_SIGSETOPS
+#endif
+
+#if SANITIZER_INTERCEPT_SIGPENDING
+INTERCEPTOR(int, sigpending, __sanitizer_sigset_t *set) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigpending, set);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigpending)(set);
+  if (!res && set) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, set, sizeof(*set));
+  return res;
+}
+#define INIT_SIGPENDING COMMON_INTERCEPT_FUNCTION(sigpending);
+#else
+#define INIT_SIGPENDING
+#endif
+
+#if SANITIZER_INTERCEPT_SIGPROCMASK
+INTERCEPTOR(int, sigprocmask, int how, __sanitizer_sigset_t *set,
+            __sanitizer_sigset_t *oldset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sigprocmask, how, set, oldset);
+  // FIXME: read sigset_t when all of sigemptyset, etc are intercepted
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(sigprocmask)(how, set, oldset);
+  if (!res && oldset)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldset, sizeof(*oldset));
+  return res;
+}
+#define INIT_SIGPROCMASK COMMON_INTERCEPT_FUNCTION(sigprocmask);
+#else
+#define INIT_SIGPROCMASK
+#endif
+
+#if SANITIZER_INTERCEPT_BACKTRACE
+INTERCEPTOR(int, backtrace, void **buffer, int size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, backtrace, buffer, size);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(backtrace)(buffer, size);
+  if (res && buffer)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buffer, res * sizeof(*buffer));
+  return res;
+}
+
+INTERCEPTOR(char **, backtrace_symbols, void **buffer, int size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, backtrace_symbols, buffer, size);
+  if (buffer && size)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, buffer, size * sizeof(*buffer));
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char **res = REAL(backtrace_symbols)(buffer, size);
+  if (res && size) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, size * sizeof(*res));
+    for (int i = 0; i < size; ++i)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res[i], REAL(strlen(res[i])) + 1);
+  }
+  return res;
+}
+#define INIT_BACKTRACE                  \
+  COMMON_INTERCEPT_FUNCTION(backtrace); \
+  COMMON_INTERCEPT_FUNCTION(backtrace_symbols);
+#else
+#define INIT_BACKTRACE
+#endif
+
+#if SANITIZER_INTERCEPT__EXIT
+INTERCEPTOR(void, _exit, int status) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, _exit, status);
+  int status1 = COMMON_INTERCEPTOR_ON_EXIT(ctx);
+  if (status == 0) status = status1;
+  REAL(_exit)(status);
+}
+#define INIT__EXIT COMMON_INTERCEPT_FUNCTION(_exit);
+#else
+#define INIT__EXIT
+#endif
+
+#if SANITIZER_INTERCEPT_PHTREAD_MUTEX
+INTERCEPTOR(int, pthread_mutex_lock, void *m) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_lock, m);
+  int res = REAL(pthread_mutex_lock)(m);
+  if (res == errno_EOWNERDEAD)
+    COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m);
+  if (res == 0 || res == errno_EOWNERDEAD)
+    COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_mutex_unlock, void *m) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_unlock, m);
+  COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m);
+  return REAL(pthread_mutex_unlock)(m);
+}
+
+#define INIT_PTHREAD_MUTEX_LOCK COMMON_INTERCEPT_FUNCTION(pthread_mutex_lock)
+#define INIT_PTHREAD_MUTEX_UNLOCK \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutex_unlock)
+#else
+#define INIT_PTHREAD_MUTEX_LOCK
+#define INIT_PTHREAD_MUTEX_UNLOCK
+#endif
+
+#if SANITIZER_INTERCEPT_GETMNTENT || SANITIZER_INTERCEPT_GETMNTENT_R
+static void write_mntent(void *ctx, __sanitizer_mntent *mnt) {
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mnt, sizeof(*mnt));
+  if (mnt->mnt_fsname)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mnt->mnt_fsname,
+                                   REAL(strlen)(mnt->mnt_fsname) + 1);
+  if (mnt->mnt_dir)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mnt->mnt_dir,
+                                   REAL(strlen)(mnt->mnt_dir) + 1);
+  if (mnt->mnt_type)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mnt->mnt_type,
+                                   REAL(strlen)(mnt->mnt_type) + 1);
+  if (mnt->mnt_opts)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mnt->mnt_opts,
+                                   REAL(strlen)(mnt->mnt_opts) + 1);
+}
+#endif
+
+#if SANITIZER_INTERCEPT_GETMNTENT
+INTERCEPTOR(__sanitizer_mntent *, getmntent, void *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getmntent, fp);
+  __sanitizer_mntent *res = REAL(getmntent)(fp);
+  if (res) write_mntent(ctx, res);
+  return res;
+}
+#define INIT_GETMNTENT COMMON_INTERCEPT_FUNCTION(getmntent);
+#else
+#define INIT_GETMNTENT
+#endif
+
+#if SANITIZER_INTERCEPT_GETMNTENT_R
+INTERCEPTOR(__sanitizer_mntent *, getmntent_r, void *fp,
+            __sanitizer_mntent *mntbuf, char *buf, int buflen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getmntent_r, fp, mntbuf, buf, buflen);
+  __sanitizer_mntent *res = REAL(getmntent_r)(fp, mntbuf, buf, buflen);
+  if (res) write_mntent(ctx, res);
+  return res;
+}
+#define INIT_GETMNTENT_R COMMON_INTERCEPT_FUNCTION(getmntent_r);
+#else
+#define INIT_GETMNTENT_R
+#endif
+
+#if SANITIZER_INTERCEPT_STATFS
+INTERCEPTOR(int, statfs, char *path, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, statfs, path, buf);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(statfs)(path, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statfs_sz);
+  return res;
+}
+INTERCEPTOR(int, fstatfs, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fstatfs, fd, buf);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(fstatfs)(fd, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statfs_sz);
+  return res;
+}
+#define INIT_STATFS                  \
+  COMMON_INTERCEPT_FUNCTION(statfs); \
+  COMMON_INTERCEPT_FUNCTION(fstatfs);
+#else
+#define INIT_STATFS
+#endif
+
+#if SANITIZER_INTERCEPT_STATFS64
+INTERCEPTOR(int, statfs64, char *path, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, statfs64, path, buf);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(statfs64)(path, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statfs64_sz);
+  return res;
+}
+INTERCEPTOR(int, fstatfs64, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fstatfs64, fd, buf);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(fstatfs64)(fd, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statfs64_sz);
+  return res;
+}
+#define INIT_STATFS64                  \
+  COMMON_INTERCEPT_FUNCTION(statfs64); \
+  COMMON_INTERCEPT_FUNCTION(fstatfs64);
+#else
+#define INIT_STATFS64
+#endif
+
+#if SANITIZER_INTERCEPT_STATVFS
+INTERCEPTOR(int, statvfs, char *path, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, statvfs, path, buf);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(statvfs)(path, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs_sz);
+  return res;
+}
+INTERCEPTOR(int, fstatvfs, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fstatvfs, fd, buf);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(fstatvfs)(fd, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs_sz);
+  return res;
+}
+#define INIT_STATVFS                  \
+  COMMON_INTERCEPT_FUNCTION(statvfs); \
+  COMMON_INTERCEPT_FUNCTION(fstatvfs);
+#else
+#define INIT_STATVFS
+#endif
+
+#if SANITIZER_INTERCEPT_STATVFS64
+INTERCEPTOR(int, statvfs64, char *path, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, statvfs64, path, buf);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(statvfs64)(path, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs64_sz);
+  return res;
+}
+INTERCEPTOR(int, fstatvfs64, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fstatvfs64, fd, buf);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(fstatvfs64)(fd, buf);
+  if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs64_sz);
+  return res;
+}
+#define INIT_STATVFS64                  \
+  COMMON_INTERCEPT_FUNCTION(statvfs64); \
+  COMMON_INTERCEPT_FUNCTION(fstatvfs64);
+#else
+#define INIT_STATVFS64
+#endif
+
+#if SANITIZER_INTERCEPT_INITGROUPS
+INTERCEPTOR(int, initgroups, char *user, u32 group) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, initgroups, user, group);
+  if (user) COMMON_INTERCEPTOR_READ_RANGE(ctx, user, REAL(strlen)(user) + 1);
+  int res = REAL(initgroups)(user, group);
+  return res;
+}
+#define INIT_INITGROUPS COMMON_INTERCEPT_FUNCTION(initgroups);
+#else
+#define INIT_INITGROUPS
+#endif
+
+#if SANITIZER_INTERCEPT_ETHER_NTOA_ATON
+INTERCEPTOR(char *, ether_ntoa, __sanitizer_ether_addr *addr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_ntoa, addr);
+  if (addr) COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, sizeof(*addr));
+  char *res = REAL(ether_ntoa)(addr);
+  if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
+  return res;
+}
+INTERCEPTOR(__sanitizer_ether_addr *, ether_aton, char *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_aton, buf);
+  if (buf) COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
+  __sanitizer_ether_addr *res = REAL(ether_aton)(buf);
+  if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, sizeof(*res));
+  return res;
+}
+#define INIT_ETHER_NTOA_ATON             \
+  COMMON_INTERCEPT_FUNCTION(ether_ntoa); \
+  COMMON_INTERCEPT_FUNCTION(ether_aton);
+#else
+#define INIT_ETHER_NTOA_ATON
+#endif
+
+#if SANITIZER_INTERCEPT_ETHER_HOST
+INTERCEPTOR(int, ether_ntohost, char *hostname, __sanitizer_ether_addr *addr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_ntohost, hostname, addr);
+  if (addr) COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, sizeof(*addr));
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(ether_ntohost)(hostname, addr);
+  if (!res && hostname)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
+  return res;
+}
+INTERCEPTOR(int, ether_hostton, char *hostname, __sanitizer_ether_addr *addr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_hostton, hostname, addr);
+  if (hostname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(ether_hostton)(hostname, addr);
+  if (!res && addr) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, sizeof(*addr));
+  return res;
+}
+INTERCEPTOR(int, ether_line, char *line, __sanitizer_ether_addr *addr,
+            char *hostname) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_line, line, addr, hostname);
+  if (line) COMMON_INTERCEPTOR_READ_RANGE(ctx, line, REAL(strlen)(line) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(ether_line)(line, addr, hostname);
+  if (!res) {
+    if (addr) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, sizeof(*addr));
+    if (hostname)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
+  }
+  return res;
+}
+#define INIT_ETHER_HOST                     \
+  COMMON_INTERCEPT_FUNCTION(ether_ntohost); \
+  COMMON_INTERCEPT_FUNCTION(ether_hostton); \
+  COMMON_INTERCEPT_FUNCTION(ether_line);
+#else
+#define INIT_ETHER_HOST
+#endif
+
+#if SANITIZER_INTERCEPT_ETHER_R
+INTERCEPTOR(char *, ether_ntoa_r, __sanitizer_ether_addr *addr, char *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_ntoa_r, addr, buf);
+  if (addr) COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, sizeof(*addr));
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(ether_ntoa_r)(addr, buf);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
+  return res;
+}
+INTERCEPTOR(__sanitizer_ether_addr *, ether_aton_r, char *buf,
+            __sanitizer_ether_addr *addr) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ether_aton_r, buf, addr);
+  if (buf) COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  __sanitizer_ether_addr *res = REAL(ether_aton_r)(buf, addr);
+  if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, sizeof(*res));
+  return res;
+}
+#define INIT_ETHER_R                       \
+  COMMON_INTERCEPT_FUNCTION(ether_ntoa_r); \
+  COMMON_INTERCEPT_FUNCTION(ether_aton_r);
+#else
+#define INIT_ETHER_R
+#endif
+
+#if SANITIZER_INTERCEPT_SHMCTL
+INTERCEPTOR(int, shmctl, int shmid, int cmd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, shmctl, shmid, cmd, buf);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(shmctl)(shmid, cmd, buf);
+  if (res >= 0) {
+    unsigned sz = 0;
+    if (cmd == shmctl_ipc_stat || cmd == shmctl_shm_stat)
+      sz = sizeof(__sanitizer_shmid_ds);
+    else if (cmd == shmctl_ipc_info)
+      sz = struct_shminfo_sz;
+    else if (cmd == shmctl_shm_info)
+      sz = struct_shm_info_sz;
+    if (sz) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, sz);
+  }
+  return res;
+}
+#define INIT_SHMCTL COMMON_INTERCEPT_FUNCTION(shmctl);
+#else
+#define INIT_SHMCTL
+#endif
+
+#if SANITIZER_INTERCEPT_RANDOM_R
+INTERCEPTOR(int, random_r, void *buf, u32 *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, random_r, buf, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(random_r)(buf, result);
+  if (!res && result)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+#define INIT_RANDOM_R COMMON_INTERCEPT_FUNCTION(random_r);
+#else
+#define INIT_RANDOM_R
+#endif
+
+// FIXME: under ASan the REAL() call below may write to freed memory and corrupt
+// its metadata. See
+// https://github.com/google/sanitizers/issues/321.
+#if SANITIZER_INTERCEPT_PTHREAD_ATTR_GET ||              \
+    SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSSCHED || \
+    SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GET ||         \
+    SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GET ||        \
+    SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GET ||          \
+    SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GET
+#define INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(fn, sz)            \
+  INTERCEPTOR(int, fn, void *attr, void *r) {                  \
+    void *ctx;                                                 \
+    COMMON_INTERCEPTOR_ENTER(ctx, fn, attr, r);                \
+    int res = REAL(fn)(attr, r);                               \
+    if (!res && r) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, sz); \
+    return res;                                                \
+  }
+#define INTERCEPTOR_PTHREAD_ATTR_GET(what, sz) \
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_attr_get##what, sz)
+#define INTERCEPTOR_PTHREAD_MUTEXATTR_GET(what, sz) \
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_mutexattr_get##what, sz)
+#define INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(what, sz) \
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_rwlockattr_get##what, sz)
+#define INTERCEPTOR_PTHREAD_CONDATTR_GET(what, sz) \
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_condattr_get##what, sz)
+#define INTERCEPTOR_PTHREAD_BARRIERATTR_GET(what, sz) \
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_barrierattr_get##what, sz)
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_ATTR_GET
+INTERCEPTOR_PTHREAD_ATTR_GET(detachstate, sizeof(int))
+INTERCEPTOR_PTHREAD_ATTR_GET(guardsize, sizeof(SIZE_T))
+INTERCEPTOR_PTHREAD_ATTR_GET(schedparam, struct_sched_param_sz)
+INTERCEPTOR_PTHREAD_ATTR_GET(schedpolicy, sizeof(int))
+INTERCEPTOR_PTHREAD_ATTR_GET(scope, sizeof(int))
+INTERCEPTOR_PTHREAD_ATTR_GET(stacksize, sizeof(SIZE_T))
+INTERCEPTOR(int, pthread_attr_getstack, void *attr, void **addr, SIZE_T *size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getstack, attr, addr, size);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(pthread_attr_getstack)(attr, addr, size);
+  if (!res) {
+    if (addr) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, sizeof(*addr));
+    if (size) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, size, sizeof(*size));
+  }
+  return res;
+}
+
+// We may need to call the real pthread_attr_getstack from the run-time
+// in sanitizer_common, but we don't want to include the interception headers
+// there. So, just define this function here.
+namespace __sanitizer {
+extern "C" {
+int real_pthread_attr_getstack(void *attr, void **addr, SIZE_T *size) {
+  return REAL(pthread_attr_getstack)(attr, addr, size);
+}
+}  // extern "C"
+}  // namespace __sanitizer
+
+#define INIT_PTHREAD_ATTR_GET                             \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getdetachstate); \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getguardsize);   \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getschedparam);  \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getschedpolicy); \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getscope);       \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getstacksize);   \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getstack);
+#else
+#define INIT_PTHREAD_ATTR_GET
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED
+INTERCEPTOR_PTHREAD_ATTR_GET(inheritsched, sizeof(int))
+
+#define INIT_PTHREAD_ATTR_GETINHERITSCHED \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getinheritsched);
+#else
+#define INIT_PTHREAD_ATTR_GETINHERITSCHED
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP
+INTERCEPTOR(int, pthread_attr_getaffinity_np, void *attr, SIZE_T cpusetsize,
+            void *cpuset) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getaffinity_np, attr, cpusetsize,
+                           cpuset);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(pthread_attr_getaffinity_np)(attr, cpusetsize, cpuset);
+  if (!res && cpusetsize && cpuset)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cpuset, cpusetsize);
+  return res;
+}
+
+#define INIT_PTHREAD_ATTR_GETAFFINITY_NP \
+  COMMON_INTERCEPT_FUNCTION(pthread_attr_getaffinity_np);
+#else
+#define INIT_PTHREAD_ATTR_GETAFFINITY_NP
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED
+INTERCEPTOR_PTHREAD_MUTEXATTR_GET(pshared, sizeof(int))
+#define INIT_PTHREAD_MUTEXATTR_GETPSHARED \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getpshared);
+#else
+#define INIT_PTHREAD_MUTEXATTR_GETPSHARED
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE
+INTERCEPTOR_PTHREAD_MUTEXATTR_GET(type, sizeof(int))
+#define INIT_PTHREAD_MUTEXATTR_GETTYPE \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_gettype);
+#else
+#define INIT_PTHREAD_MUTEXATTR_GETTYPE
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL
+INTERCEPTOR_PTHREAD_MUTEXATTR_GET(protocol, sizeof(int))
+#define INIT_PTHREAD_MUTEXATTR_GETPROTOCOL \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getprotocol);
+#else
+#define INIT_PTHREAD_MUTEXATTR_GETPROTOCOL
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING
+INTERCEPTOR_PTHREAD_MUTEXATTR_GET(prioceiling, sizeof(int))
+#define INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getprioceiling);
+#else
+#define INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST
+INTERCEPTOR_PTHREAD_MUTEXATTR_GET(robust, sizeof(int))
+#define INIT_PTHREAD_MUTEXATTR_GETROBUST \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getrobust);
+#else
+#define INIT_PTHREAD_MUTEXATTR_GETROBUST
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST_NP
+INTERCEPTOR_PTHREAD_MUTEXATTR_GET(robust_np, sizeof(int))
+#define INIT_PTHREAD_MUTEXATTR_GETROBUST_NP \
+  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getrobust_np);
+#else
+#define INIT_PTHREAD_MUTEXATTR_GETROBUST_NP
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETPSHARED
+INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(pshared, sizeof(int))
+#define INIT_PTHREAD_RWLOCKATTR_GETPSHARED \
+  COMMON_INTERCEPT_FUNCTION(pthread_rwlockattr_getpshared);
+#else
+#define INIT_PTHREAD_RWLOCKATTR_GETPSHARED
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETKIND_NP
+INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(kind_np, sizeof(int))
+#define INIT_PTHREAD_RWLOCKATTR_GETKIND_NP \
+  COMMON_INTERCEPT_FUNCTION(pthread_rwlockattr_getkind_np);
+#else
+#define INIT_PTHREAD_RWLOCKATTR_GETKIND_NP
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETPSHARED
+INTERCEPTOR_PTHREAD_CONDATTR_GET(pshared, sizeof(int))
+#define INIT_PTHREAD_CONDATTR_GETPSHARED \
+  COMMON_INTERCEPT_FUNCTION(pthread_condattr_getpshared);
+#else
+#define INIT_PTHREAD_CONDATTR_GETPSHARED
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETCLOCK
+INTERCEPTOR_PTHREAD_CONDATTR_GET(clock, sizeof(int))
+#define INIT_PTHREAD_CONDATTR_GETCLOCK \
+  COMMON_INTERCEPT_FUNCTION(pthread_condattr_getclock);
+#else
+#define INIT_PTHREAD_CONDATTR_GETCLOCK
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GETPSHARED
+INTERCEPTOR_PTHREAD_BARRIERATTR_GET(pshared, sizeof(int)) // !mac !android
+#define INIT_PTHREAD_BARRIERATTR_GETPSHARED \
+  COMMON_INTERCEPT_FUNCTION(pthread_barrierattr_getpshared);
+#else
+#define INIT_PTHREAD_BARRIERATTR_GETPSHARED
+#endif
+
+#if SANITIZER_INTERCEPT_TMPNAM
+INTERCEPTOR(char *, tmpnam, char *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, tmpnam, s);
+  char *res = REAL(tmpnam)(s);
+  if (res) {
+    if (s)
+      // FIXME: under ASan the call below may write to freed memory and corrupt
+      // its metadata. See
+      // https://github.com/google/sanitizers/issues/321.
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, REAL(strlen)(s) + 1);
+    else
+      COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+#define INIT_TMPNAM COMMON_INTERCEPT_FUNCTION(tmpnam);
+#else
+#define INIT_TMPNAM
+#endif
+
+#if SANITIZER_INTERCEPT_TMPNAM_R
+INTERCEPTOR(char *, tmpnam_r, char *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, tmpnam_r, s);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(tmpnam_r)(s);
+  if (res && s) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, REAL(strlen)(s) + 1);
+  return res;
+}
+#define INIT_TMPNAM_R COMMON_INTERCEPT_FUNCTION(tmpnam_r);
+#else
+#define INIT_TMPNAM_R
+#endif
+
+#if SANITIZER_INTERCEPT_TEMPNAM
+INTERCEPTOR(char *, tempnam, char *dir, char *pfx) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, tempnam, dir, pfx);
+  if (dir) COMMON_INTERCEPTOR_READ_RANGE(ctx, dir, REAL(strlen)(dir) + 1);
+  if (pfx) COMMON_INTERCEPTOR_READ_RANGE(ctx, pfx, REAL(strlen)(pfx) + 1);
+  char *res = REAL(tempnam)(dir, pfx);
+  if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
+  return res;
+}
+#define INIT_TEMPNAM COMMON_INTERCEPT_FUNCTION(tempnam);
+#else
+#define INIT_TEMPNAM
+#endif
+
+#if SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP
+INTERCEPTOR(int, pthread_setname_np, uptr thread, const char *name) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_setname_np, thread, name);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
+  COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name);
+  return REAL(pthread_setname_np)(thread, name);
+}
+#define INIT_PTHREAD_SETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_setname_np);
+#else
+#define INIT_PTHREAD_SETNAME_NP
+#endif
+
+#if SANITIZER_INTERCEPT_SINCOS
+INTERCEPTOR(void, sincos, double x, double *sin, double *cos) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sincos, x, sin, cos);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  REAL(sincos)(x, sin, cos);
+  if (sin) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sin, sizeof(*sin));
+  if (cos) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cos, sizeof(*cos));
+}
+INTERCEPTOR(void, sincosf, float x, float *sin, float *cos) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sincosf, x, sin, cos);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  REAL(sincosf)(x, sin, cos);
+  if (sin) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sin, sizeof(*sin));
+  if (cos) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cos, sizeof(*cos));
+}
+INTERCEPTOR(void, sincosl, long double x, long double *sin, long double *cos) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sincosl, x, sin, cos);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  REAL(sincosl)(x, sin, cos);
+  if (sin) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sin, sizeof(*sin));
+  if (cos) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cos, sizeof(*cos));
+}
+#define INIT_SINCOS                   \
+  COMMON_INTERCEPT_FUNCTION(sincos);  \
+  COMMON_INTERCEPT_FUNCTION(sincosf); \
+  COMMON_INTERCEPT_FUNCTION(sincosl);
+#else
+#define INIT_SINCOS
+#endif
+
+#if SANITIZER_INTERCEPT_REMQUO
+INTERCEPTOR(double, remquo, double x, double y, int *quo) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, remquo, x, y, quo);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  double res = REAL(remquo)(x, y, quo);
+  if (quo) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, quo, sizeof(*quo));
+  return res;
+}
+INTERCEPTOR(float, remquof, float x, float y, int *quo) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, remquof, x, y, quo);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  float res = REAL(remquof)(x, y, quo);
+  if (quo) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, quo, sizeof(*quo));
+  return res;
+}
+INTERCEPTOR(long double, remquol, long double x, long double y, int *quo) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, remquol, x, y, quo);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  long double res = REAL(remquol)(x, y, quo);
+  if (quo) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, quo, sizeof(*quo));
+  return res;
+}
+#define INIT_REMQUO                   \
+  COMMON_INTERCEPT_FUNCTION(remquo);  \
+  COMMON_INTERCEPT_FUNCTION(remquof); \
+  COMMON_INTERCEPT_FUNCTION(remquol);
+#else
+#define INIT_REMQUO
+#endif
+
+#if SANITIZER_INTERCEPT_LGAMMA
+extern int signgam;
+INTERCEPTOR(double, lgamma, double x) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgamma, x);
+  double res = REAL(lgamma)(x);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &signgam, sizeof(signgam));
+  return res;
+}
+INTERCEPTOR(float, lgammaf, float x) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgammaf, x);
+  float res = REAL(lgammaf)(x);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &signgam, sizeof(signgam));
+  return res;
+}
+INTERCEPTOR(long double, lgammal, long double x) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgammal, x);
+  long double res = REAL(lgammal)(x);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &signgam, sizeof(signgam));
+  return res;
+}
+#define INIT_LGAMMA                   \
+  COMMON_INTERCEPT_FUNCTION(lgamma);  \
+  COMMON_INTERCEPT_FUNCTION(lgammaf); \
+  COMMON_INTERCEPT_FUNCTION(lgammal);
+#else
+#define INIT_LGAMMA
+#endif
+
+#if SANITIZER_INTERCEPT_LGAMMA_R
+INTERCEPTOR(double, lgamma_r, double x, int *signp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgamma_r, x, signp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  double res = REAL(lgamma_r)(x, signp);
+  if (signp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, signp, sizeof(*signp));
+  return res;
+}
+INTERCEPTOR(float, lgammaf_r, float x, int *signp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgammaf_r, x, signp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  float res = REAL(lgammaf_r)(x, signp);
+  if (signp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, signp, sizeof(*signp));
+  return res;
+}
+#define INIT_LGAMMA_R                   \
+  COMMON_INTERCEPT_FUNCTION(lgamma_r);  \
+  COMMON_INTERCEPT_FUNCTION(lgammaf_r);
+#else
+#define INIT_LGAMMA_R
+#endif
+
+#if SANITIZER_INTERCEPT_LGAMMAL_R
+INTERCEPTOR(long double, lgammal_r, long double x, int *signp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgammal_r, x, signp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  long double res = REAL(lgammal_r)(x, signp);
+  if (signp) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, signp, sizeof(*signp));
+  return res;
+}
+#define INIT_LGAMMAL_R COMMON_INTERCEPT_FUNCTION(lgammal_r);
+#else
+#define INIT_LGAMMAL_R
+#endif
+
+#if SANITIZER_INTERCEPT_DRAND48_R
+INTERCEPTOR(int, drand48_r, void *buffer, double *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, drand48_r, buffer, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(drand48_r)(buffer, result);
+  if (result) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+INTERCEPTOR(int, lrand48_r, void *buffer, long *result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lrand48_r, buffer, result);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(lrand48_r)(buffer, result);
+  if (result) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof(*result));
+  return res;
+}
+#define INIT_DRAND48_R                  \
+  COMMON_INTERCEPT_FUNCTION(drand48_r); \
+  COMMON_INTERCEPT_FUNCTION(lrand48_r);
+#else
+#define INIT_DRAND48_R
+#endif
+
+#if SANITIZER_INTERCEPT_RAND_R
+INTERCEPTOR(int, rand_r, unsigned *seedp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, rand_r, seedp);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, seedp, sizeof(*seedp));
+  return REAL(rand_r)(seedp);
+}
+#define INIT_RAND_R COMMON_INTERCEPT_FUNCTION(rand_r);
+#else
+#define INIT_RAND_R
+#endif
+
+#if SANITIZER_INTERCEPT_GETLINE
+INTERCEPTOR(SSIZE_T, getline, char **lineptr, SIZE_T *n, void *stream) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getline, lineptr, n, stream);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(getline)(lineptr, n, stream);
+  if (res > 0) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, lineptr, sizeof(*lineptr));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n, sizeof(*n));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *lineptr, res + 1);
+  }
+  return res;
+}
+
+// FIXME: under ASan the call below may write to freed memory and corrupt its
+// metadata. See
+// https://github.com/google/sanitizers/issues/321.
+#define GETDELIM_INTERCEPTOR_IMPL(vname)                                       \
+  {                                                                            \
+    void *ctx;                                                                 \
+    COMMON_INTERCEPTOR_ENTER(ctx, vname, lineptr, n, delim, stream);           \
+    SSIZE_T res = REAL(vname)(lineptr, n, delim, stream);                      \
+    if (res > 0) {                                                             \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, lineptr, sizeof(*lineptr));          \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n, sizeof(*n));                      \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *lineptr, res + 1);                  \
+    }                                                                          \
+    return res;                                                                \
+  }
+
+INTERCEPTOR(SSIZE_T, __getdelim, char **lineptr, SIZE_T *n, int delim,
+            void *stream)
+GETDELIM_INTERCEPTOR_IMPL(__getdelim)
+
+// There's no __getdelim() on FreeBSD so we supply the getdelim() interceptor
+// with its own body.
+INTERCEPTOR(SSIZE_T, getdelim, char **lineptr, SIZE_T *n, int delim,
+            void *stream)
+GETDELIM_INTERCEPTOR_IMPL(getdelim)
+
+#define INIT_GETLINE                     \
+  COMMON_INTERCEPT_FUNCTION(getline);    \
+  COMMON_INTERCEPT_FUNCTION(__getdelim); \
+  COMMON_INTERCEPT_FUNCTION(getdelim);
+#else
+#define INIT_GETLINE
+#endif
+
+#if SANITIZER_INTERCEPT_ICONV
+INTERCEPTOR(SIZE_T, iconv, void *cd, char **inbuf, SIZE_T *inbytesleft,
+            char **outbuf, SIZE_T *outbytesleft) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, iconv, cd, inbuf, inbytesleft, outbuf,
+                           outbytesleft);
+  if (inbytesleft)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, inbytesleft, sizeof(*inbytesleft));
+  if (inbuf && inbytesleft)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, *inbuf, *inbytesleft);
+  if (outbytesleft)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, outbytesleft, sizeof(*outbytesleft));
+  void *outbuf_orig = outbuf ? *outbuf : nullptr;
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SIZE_T res = REAL(iconv)(cd, inbuf, inbytesleft, outbuf, outbytesleft);
+  if (res != (SIZE_T) - 1 && outbuf && *outbuf > outbuf_orig) {
+    SIZE_T sz = (char *)*outbuf - (char *)outbuf_orig;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, outbuf_orig, sz);
+  }
+  return res;
+}
+#define INIT_ICONV COMMON_INTERCEPT_FUNCTION(iconv);
+#else
+#define INIT_ICONV
+#endif
+
+#if SANITIZER_INTERCEPT_TIMES
+INTERCEPTOR(__sanitizer_clock_t, times, void *tms) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, times, tms);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  __sanitizer_clock_t res = REAL(times)(tms);
+  if (res != (__sanitizer_clock_t)-1 && tms)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tms, struct_tms_sz);
+  return res;
+}
+#define INIT_TIMES COMMON_INTERCEPT_FUNCTION(times);
+#else
+#define INIT_TIMES
+#endif
+
+#if SANITIZER_INTERCEPT_TLS_GET_ADDR
+#define INIT_TLS_GET_ADDR COMMON_INTERCEPT_FUNCTION(__tls_get_addr)
+// If you see any crashes around this functions, there are 2 known issues with
+// it: 1. __tls_get_addr can be called with mis-aligned stack due to:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58066
+// 2. It can be called recursively if sanitizer code uses __tls_get_addr
+// to access thread local variables (it should not happen normally,
+// because sanitizers use initial-exec tls model).
+INTERCEPTOR(void *, __tls_get_addr, void *arg) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __tls_get_addr, arg);
+  void *res = REAL(__tls_get_addr)(arg);
+  uptr tls_begin, tls_end;
+  COMMON_INTERCEPTOR_GET_TLS_RANGE(&tls_begin, &tls_end);
+  DTLS::DTV *dtv = DTLS_on_tls_get_addr(arg, res, tls_begin, tls_end);
+  if (dtv) {
+    // New DTLS block has been allocated.
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE((void *)dtv->beg, dtv->size);
+  }
+  return res;
+}
+#else
+#define INIT_TLS_GET_ADDR
+#endif
+
+#if SANITIZER_INTERCEPT_LISTXATTR
+INTERCEPTOR(SSIZE_T, listxattr, const char *path, char *list, SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, listxattr, path, list, size);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(listxattr)(path, list, size);
+  // Here and below, size == 0 is a special case where nothing is written to the
+  // buffer, and res contains the desired buffer size.
+  if (size && res > 0 && list) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, list, res);
+  return res;
+}
+INTERCEPTOR(SSIZE_T, llistxattr, const char *path, char *list, SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, llistxattr, path, list, size);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(llistxattr)(path, list, size);
+  if (size && res > 0 && list) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, list, res);
+  return res;
+}
+INTERCEPTOR(SSIZE_T, flistxattr, int fd, char *list, SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, flistxattr, fd, list, size);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(flistxattr)(fd, list, size);
+  if (size && res > 0 && list) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, list, res);
+  return res;
+}
+#define INIT_LISTXATTR                   \
+  COMMON_INTERCEPT_FUNCTION(listxattr);  \
+  COMMON_INTERCEPT_FUNCTION(llistxattr); \
+  COMMON_INTERCEPT_FUNCTION(flistxattr);
+#else
+#define INIT_LISTXATTR
+#endif
+
+#if SANITIZER_INTERCEPT_GETXATTR
+INTERCEPTOR(SSIZE_T, getxattr, const char *path, const char *name, char *value,
+            SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getxattr, path, name, value, size);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(getxattr)(path, name, value, size);
+  if (size && res > 0 && value) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, value, res);
+  return res;
+}
+INTERCEPTOR(SSIZE_T, lgetxattr, const char *path, const char *name, char *value,
+            SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, lgetxattr, path, name, value, size);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(lgetxattr)(path, name, value, size);
+  if (size && res > 0 && value) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, value, res);
+  return res;
+}
+INTERCEPTOR(SSIZE_T, fgetxattr, int fd, const char *name, char *value,
+            SIZE_T size) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fgetxattr, fd, name, value, size);
+  if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  SSIZE_T res = REAL(fgetxattr)(fd, name, value, size);
+  if (size && res > 0 && value) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, value, res);
+  return res;
+}
+#define INIT_GETXATTR                   \
+  COMMON_INTERCEPT_FUNCTION(getxattr);  \
+  COMMON_INTERCEPT_FUNCTION(lgetxattr); \
+  COMMON_INTERCEPT_FUNCTION(fgetxattr);
+#else
+#define INIT_GETXATTR
+#endif
+
+#if SANITIZER_INTERCEPT_GETRESID
+INTERCEPTOR(int, getresuid, void *ruid, void *euid, void *suid) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getresuid, ruid, euid, suid);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getresuid)(ruid, euid, suid);
+  if (res >= 0) {
+    if (ruid) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ruid, uid_t_sz);
+    if (euid) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, euid, uid_t_sz);
+    if (suid) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, suid, uid_t_sz);
+  }
+  return res;
+}
+INTERCEPTOR(int, getresgid, void *rgid, void *egid, void *sgid) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getresgid, rgid, egid, sgid);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getresgid)(rgid, egid, sgid);
+  if (res >= 0) {
+    if (rgid) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rgid, gid_t_sz);
+    if (egid) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, egid, gid_t_sz);
+    if (sgid) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sgid, gid_t_sz);
+  }
+  return res;
+}
+#define INIT_GETRESID                   \
+  COMMON_INTERCEPT_FUNCTION(getresuid); \
+  COMMON_INTERCEPT_FUNCTION(getresgid);
+#else
+#define INIT_GETRESID
+#endif
+
+#if SANITIZER_INTERCEPT_GETIFADDRS
+// As long as getifaddrs()/freeifaddrs() use calloc()/free(), we don't need to
+// intercept freeifaddrs(). If that ceases to be the case, we might need to
+// intercept it to poison the memory again.
+INTERCEPTOR(int, getifaddrs, __sanitizer_ifaddrs **ifap) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getifaddrs, ifap);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(getifaddrs)(ifap);
+  if (res == 0 && ifap) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifap, sizeof(void *));
+    __sanitizer_ifaddrs *p = *ifap;
+    while (p) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(__sanitizer_ifaddrs));
+      if (p->ifa_name)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->ifa_name,
+                                       REAL(strlen)(p->ifa_name) + 1);
+      if (p->ifa_addr)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->ifa_addr, struct_sockaddr_sz);
+      if (p->ifa_netmask)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->ifa_netmask, struct_sockaddr_sz);
+      // On Linux this is a union, but the other member also points to a
+      // struct sockaddr, so the following is sufficient.
+      if (p->ifa_dstaddr)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->ifa_dstaddr, struct_sockaddr_sz);
+      // FIXME(smatveev): Unpoison p->ifa_data as well.
+      p = p->ifa_next;
+    }
+  }
+  return res;
+}
+#define INIT_GETIFADDRS                  \
+  COMMON_INTERCEPT_FUNCTION(getifaddrs);
+#else
+#define INIT_GETIFADDRS
+#endif
+
+#if SANITIZER_INTERCEPT_IF_INDEXTONAME
+INTERCEPTOR(char *, if_indextoname, unsigned int ifindex, char* ifname) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, if_indextoname, ifindex, ifname);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  char *res = REAL(if_indextoname)(ifindex, ifname);
+  if (res && ifname)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifname, REAL(strlen)(ifname) + 1);
+  return res;
+}
+INTERCEPTOR(unsigned int, if_nametoindex, const char* ifname) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, if_nametoindex, ifname);
+  if (ifname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, ifname, REAL(strlen)(ifname) + 1);
+  return REAL(if_nametoindex)(ifname);
+}
+#define INIT_IF_INDEXTONAME                  \
+  COMMON_INTERCEPT_FUNCTION(if_indextoname); \
+  COMMON_INTERCEPT_FUNCTION(if_nametoindex);
+#else
+#define INIT_IF_INDEXTONAME
+#endif
+
+#if SANITIZER_INTERCEPT_CAPGET
+INTERCEPTOR(int, capget, void *hdrp, void *datap) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, capget, hdrp, datap);
+  if (hdrp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, hdrp, __user_cap_header_struct_sz);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(capget)(hdrp, datap);
+  if (res == 0 && datap)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, datap, __user_cap_data_struct_sz);
+  // We can also return -1 and write to hdrp->version if the version passed in
+  // hdrp->version is unsupported. But that's not a trivial condition to check,
+  // and anyway COMMON_INTERCEPTOR_READ_RANGE protects us to some extent.
+  return res;
+}
+INTERCEPTOR(int, capset, void *hdrp, const void *datap) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, capset, hdrp, datap);
+  if (hdrp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, hdrp, __user_cap_header_struct_sz);
+  if (datap)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, datap, __user_cap_data_struct_sz);
+  return REAL(capset)(hdrp, datap);
+}
+#define INIT_CAPGET                  \
+  COMMON_INTERCEPT_FUNCTION(capget); \
+  COMMON_INTERCEPT_FUNCTION(capset);
+#else
+#define INIT_CAPGET
+#endif
+
+#if SANITIZER_INTERCEPT_AEABI_MEM
+DECLARE_REAL_AND_INTERCEPTOR(void *, memmove, void *, const void *, uptr)
+DECLARE_REAL_AND_INTERCEPTOR(void *, memcpy, void *, const void *, uptr)
+DECLARE_REAL_AND_INTERCEPTOR(void *, memset, void *, int, uptr)
+
+INTERCEPTOR(void *, __aeabi_memmove, void *to, const void *from, uptr size) {
+  return WRAP(memmove)(to, from, size);
+}
+INTERCEPTOR(void *, __aeabi_memmove4, void *to, const void *from, uptr size) {
+  return WRAP(memmove)(to, from, size);
+}
+INTERCEPTOR(void *, __aeabi_memmove8, void *to, const void *from, uptr size) {
+  return WRAP(memmove)(to, from, size);
+}
+INTERCEPTOR(void *, __aeabi_memcpy, void *to, const void *from, uptr size) {
+  return WRAP(memcpy)(to, from, size);
+}
+INTERCEPTOR(void *, __aeabi_memcpy4, void *to, const void *from, uptr size) {
+  return WRAP(memcpy)(to, from, size);
+}
+INTERCEPTOR(void *, __aeabi_memcpy8, void *to, const void *from, uptr size) {
+  return WRAP(memcpy)(to, from, size);
+}
+// Note the argument order.
+INTERCEPTOR(void *, __aeabi_memset, void *block, uptr size, int c) {
+  return WRAP(memset)(block, c, size);
+}
+INTERCEPTOR(void *, __aeabi_memset4, void *block, uptr size, int c) {
+  return WRAP(memset)(block, c, size);
+}
+INTERCEPTOR(void *, __aeabi_memset8, void *block, uptr size, int c) {
+  return WRAP(memset)(block, c, size);
+}
+INTERCEPTOR(void *, __aeabi_memclr, void *block, uptr size) {
+  return WRAP(memset)(block, 0, size);
+}
+INTERCEPTOR(void *, __aeabi_memclr4, void *block, uptr size) {
+  return WRAP(memset)(block, 0, size);
+}
+INTERCEPTOR(void *, __aeabi_memclr8, void *block, uptr size) {
+  return WRAP(memset)(block, 0, size);
+}
+#define INIT_AEABI_MEM                         \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memmove);  \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memmove4); \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memmove8); \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy);   \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy4);  \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memcpy8);  \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memset);   \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memset4);  \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memset8);  \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memclr);   \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memclr4);  \
+  COMMON_INTERCEPT_FUNCTION(__aeabi_memclr8);
+#else
+#define INIT_AEABI_MEM
+#endif  // SANITIZER_INTERCEPT_AEABI_MEM
+
+#if SANITIZER_INTERCEPT___BZERO
+DECLARE_REAL_AND_INTERCEPTOR(void *, memset, void *, int, uptr);
+
+INTERCEPTOR(void *, __bzero, void *block, uptr size) {
+  return WRAP(memset)(block, 0, size);
+}
+#define INIT___BZERO COMMON_INTERCEPT_FUNCTION(__bzero);
+#else
+#define INIT___BZERO
+#endif  // SANITIZER_INTERCEPT___BZERO
+
+#if SANITIZER_INTERCEPT_FTIME
+INTERCEPTOR(int, ftime, __sanitizer_timeb *tp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ftime, tp);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(ftime)(tp);
+  if (tp)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tp, sizeof(*tp));
+  return res;
+}
+#define INIT_FTIME COMMON_INTERCEPT_FUNCTION(ftime);
+#else
+#define INIT_FTIME
+#endif  // SANITIZER_INTERCEPT_FTIME
+
+#if SANITIZER_INTERCEPT_XDR
+INTERCEPTOR(void, xdrmem_create, __sanitizer_XDR *xdrs, uptr addr,
+            unsigned size, int op) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, xdrmem_create, xdrs, addr, size, op);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  REAL(xdrmem_create)(xdrs, addr, size, op);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, xdrs, sizeof(*xdrs));
+  if (op == __sanitizer_XDR_ENCODE) {
+    // It's not obvious how much data individual xdr_ routines write.
+    // Simply unpoison the entire target buffer in advance.
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, (void *)addr, size);
+  }
+}
+
+INTERCEPTOR(void, xdrstdio_create, __sanitizer_XDR *xdrs, void *file, int op) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, xdrstdio_create, xdrs, file, op);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  REAL(xdrstdio_create)(xdrs, file, op);
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, xdrs, sizeof(*xdrs));
+}
+
+// FIXME: under ASan the call below may write to freed memory and corrupt
+// its metadata. See
+// https://github.com/google/sanitizers/issues/321.
+#define XDR_INTERCEPTOR(F, T)                             \
+  INTERCEPTOR(int, F, __sanitizer_XDR *xdrs, T *p) {      \
+    void *ctx;                                            \
+    COMMON_INTERCEPTOR_ENTER(ctx, F, xdrs, p);            \
+    if (p && xdrs->x_op == __sanitizer_XDR_ENCODE)        \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, p, sizeof(*p));  \
+    int res = REAL(F)(xdrs, p);                           \
+    if (res && p && xdrs->x_op == __sanitizer_XDR_DECODE) \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p)); \
+    return res;                                           \
+  }
+
+XDR_INTERCEPTOR(xdr_short, short)
+XDR_INTERCEPTOR(xdr_u_short, unsigned short)
+XDR_INTERCEPTOR(xdr_int, int)
+XDR_INTERCEPTOR(xdr_u_int, unsigned)
+XDR_INTERCEPTOR(xdr_long, long)
+XDR_INTERCEPTOR(xdr_u_long, unsigned long)
+XDR_INTERCEPTOR(xdr_hyper, long long)
+XDR_INTERCEPTOR(xdr_u_hyper, unsigned long long)
+XDR_INTERCEPTOR(xdr_longlong_t, long long)
+XDR_INTERCEPTOR(xdr_u_longlong_t, unsigned long long)
+XDR_INTERCEPTOR(xdr_int8_t, u8)
+XDR_INTERCEPTOR(xdr_uint8_t, u8)
+XDR_INTERCEPTOR(xdr_int16_t, u16)
+XDR_INTERCEPTOR(xdr_uint16_t, u16)
+XDR_INTERCEPTOR(xdr_int32_t, u32)
+XDR_INTERCEPTOR(xdr_uint32_t, u32)
+XDR_INTERCEPTOR(xdr_int64_t, u64)
+XDR_INTERCEPTOR(xdr_uint64_t, u64)
+XDR_INTERCEPTOR(xdr_quad_t, long long)
+XDR_INTERCEPTOR(xdr_u_quad_t, unsigned long long)
+XDR_INTERCEPTOR(xdr_bool, bool)
+XDR_INTERCEPTOR(xdr_enum, int)
+XDR_INTERCEPTOR(xdr_char, char)
+XDR_INTERCEPTOR(xdr_u_char, unsigned char)
+XDR_INTERCEPTOR(xdr_float, float)
+XDR_INTERCEPTOR(xdr_double, double)
+
+// FIXME: intercept xdr_array, opaque, union, vector, reference, pointer,
+// wrapstring, sizeof
+
+INTERCEPTOR(int, xdr_bytes, __sanitizer_XDR *xdrs, char **p, unsigned *sizep,
+            unsigned maxsize) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, xdr_bytes, xdrs, p, sizep, maxsize);
+  if (p && sizep && xdrs->x_op == __sanitizer_XDR_ENCODE) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, p, sizeof(*p));
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sizep, sizeof(*sizep));
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, *p, *sizep);
+  }
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(xdr_bytes)(xdrs, p, sizep, maxsize);
+  if (p && sizep && xdrs->x_op == __sanitizer_XDR_DECODE) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sizep, sizeof(*sizep));
+    if (res && *p && *sizep) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, *sizep);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, xdr_string, __sanitizer_XDR *xdrs, char **p,
+            unsigned maxsize) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, xdr_string, xdrs, p, maxsize);
+  if (p && xdrs->x_op == __sanitizer_XDR_ENCODE) {
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, p, sizeof(*p));
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
+  }
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  int res = REAL(xdr_string)(xdrs, p, maxsize);
+  if (p && xdrs->x_op == __sanitizer_XDR_DECODE) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
+    if (res && *p)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
+  }
+  return res;
+}
+
+#define INIT_XDR                               \
+  COMMON_INTERCEPT_FUNCTION(xdrmem_create);    \
+  COMMON_INTERCEPT_FUNCTION(xdrstdio_create);  \
+  COMMON_INTERCEPT_FUNCTION(xdr_short);        \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_short);      \
+  COMMON_INTERCEPT_FUNCTION(xdr_int);          \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_int);        \
+  COMMON_INTERCEPT_FUNCTION(xdr_long);         \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_long);       \
+  COMMON_INTERCEPT_FUNCTION(xdr_hyper);        \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_hyper);      \
+  COMMON_INTERCEPT_FUNCTION(xdr_longlong_t);   \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_longlong_t); \
+  COMMON_INTERCEPT_FUNCTION(xdr_int8_t);       \
+  COMMON_INTERCEPT_FUNCTION(xdr_uint8_t);      \
+  COMMON_INTERCEPT_FUNCTION(xdr_int16_t);      \
+  COMMON_INTERCEPT_FUNCTION(xdr_uint16_t);     \
+  COMMON_INTERCEPT_FUNCTION(xdr_int32_t);      \
+  COMMON_INTERCEPT_FUNCTION(xdr_uint32_t);     \
+  COMMON_INTERCEPT_FUNCTION(xdr_int64_t);      \
+  COMMON_INTERCEPT_FUNCTION(xdr_uint64_t);     \
+  COMMON_INTERCEPT_FUNCTION(xdr_quad_t);       \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_quad_t);     \
+  COMMON_INTERCEPT_FUNCTION(xdr_bool);         \
+  COMMON_INTERCEPT_FUNCTION(xdr_enum);         \
+  COMMON_INTERCEPT_FUNCTION(xdr_char);         \
+  COMMON_INTERCEPT_FUNCTION(xdr_u_char);       \
+  COMMON_INTERCEPT_FUNCTION(xdr_float);        \
+  COMMON_INTERCEPT_FUNCTION(xdr_double);       \
+  COMMON_INTERCEPT_FUNCTION(xdr_bytes);        \
+  COMMON_INTERCEPT_FUNCTION(xdr_string);
+#else
+#define INIT_XDR
+#endif  // SANITIZER_INTERCEPT_XDR
+
+#if SANITIZER_INTERCEPT_TSEARCH
+INTERCEPTOR(void *, tsearch, void *key, void **rootp,
+            int (*compar)(const void *, const void *)) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, tsearch, key, rootp, compar);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  void *res = REAL(tsearch)(key, rootp, compar);
+  if (res && *(void **)res == key)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, sizeof(void *));
+  return res;
+}
+#define INIT_TSEARCH COMMON_INTERCEPT_FUNCTION(tsearch);
+#else
+#define INIT_TSEARCH
+#endif
+
+#if SANITIZER_INTERCEPT_LIBIO_INTERNALS || SANITIZER_INTERCEPT_FOPEN || \
+    SANITIZER_INTERCEPT_OPEN_MEMSTREAM
+void unpoison_file(__sanitizer_FILE *fp) {
+#if SANITIZER_HAS_STRUCT_FILE
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(fp, sizeof(*fp));
+  if (fp->_IO_read_base && fp->_IO_read_base < fp->_IO_read_end)
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(fp->_IO_read_base,
+                                        fp->_IO_read_end - fp->_IO_read_base);
+#endif  // SANITIZER_HAS_STRUCT_FILE
+}
+#endif
+
+#if SANITIZER_INTERCEPT_LIBIO_INTERNALS
+// These guys are called when a .c source is built with -O2.
+INTERCEPTOR(int, __uflow, __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __uflow, fp);
+  int res = REAL(__uflow)(fp);
+  unpoison_file(fp);
+  return res;
+}
+INTERCEPTOR(int, __underflow, __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __underflow, fp);
+  int res = REAL(__underflow)(fp);
+  unpoison_file(fp);
+  return res;
+}
+INTERCEPTOR(int, __overflow, __sanitizer_FILE *fp, int ch) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __overflow, fp, ch);
+  int res = REAL(__overflow)(fp, ch);
+  unpoison_file(fp);
+  return res;
+}
+INTERCEPTOR(int, __wuflow, __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __wuflow, fp);
+  int res = REAL(__wuflow)(fp);
+  unpoison_file(fp);
+  return res;
+}
+INTERCEPTOR(int, __wunderflow, __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __wunderflow, fp);
+  int res = REAL(__wunderflow)(fp);
+  unpoison_file(fp);
+  return res;
+}
+INTERCEPTOR(int, __woverflow, __sanitizer_FILE *fp, int ch) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __woverflow, fp, ch);
+  int res = REAL(__woverflow)(fp, ch);
+  unpoison_file(fp);
+  return res;
+}
+#define INIT_LIBIO_INTERNALS               \
+  COMMON_INTERCEPT_FUNCTION(__uflow);      \
+  COMMON_INTERCEPT_FUNCTION(__underflow);  \
+  COMMON_INTERCEPT_FUNCTION(__overflow);   \
+  COMMON_INTERCEPT_FUNCTION(__wuflow);     \
+  COMMON_INTERCEPT_FUNCTION(__wunderflow); \
+  COMMON_INTERCEPT_FUNCTION(__woverflow);
+#else
+#define INIT_LIBIO_INTERNALS
+#endif
+
+#if SANITIZER_INTERCEPT_FOPEN
+INTERCEPTOR(__sanitizer_FILE *, fopen, const char *path, const char *mode) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fopen, path, mode);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
+  __sanitizer_FILE *res = REAL(fopen)(path, mode);
+  COMMON_INTERCEPTOR_FILE_OPEN(ctx, res, path);
+  if (res) unpoison_file(res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_FILE *, fdopen, int fd, const char *mode) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fdopen, fd, mode);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
+  __sanitizer_FILE *res = REAL(fdopen)(fd, mode);
+  if (res) unpoison_file(res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_FILE *, freopen, const char *path, const char *mode,
+            __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, freopen, path, mode, fp);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
+  COMMON_INTERCEPTOR_FILE_CLOSE(ctx, fp);
+  __sanitizer_FILE *res = REAL(freopen)(path, mode, fp);
+  COMMON_INTERCEPTOR_FILE_OPEN(ctx, res, path);
+  if (res) unpoison_file(res);
+  return res;
+}
+#define INIT_FOPEN                   \
+  COMMON_INTERCEPT_FUNCTION(fopen);  \
+  COMMON_INTERCEPT_FUNCTION(fdopen); \
+  COMMON_INTERCEPT_FUNCTION(freopen);
+#else
+#define INIT_FOPEN
+#endif
+
+#if SANITIZER_INTERCEPT_FOPEN64
+INTERCEPTOR(__sanitizer_FILE *, fopen64, const char *path, const char *mode) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fopen64, path, mode);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
+  __sanitizer_FILE *res = REAL(fopen64)(path, mode);
+  COMMON_INTERCEPTOR_FILE_OPEN(ctx, res, path);
+  if (res) unpoison_file(res);
+  return res;
+}
+INTERCEPTOR(__sanitizer_FILE *, freopen64, const char *path, const char *mode,
+            __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, freopen64, path, mode, fp);
+  if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
+  COMMON_INTERCEPTOR_FILE_CLOSE(ctx, fp);
+  __sanitizer_FILE *res = REAL(freopen64)(path, mode, fp);
+  COMMON_INTERCEPTOR_FILE_OPEN(ctx, res, path);
+  if (res) unpoison_file(res);
+  return res;
+}
+#define INIT_FOPEN64                  \
+  COMMON_INTERCEPT_FUNCTION(fopen64); \
+  COMMON_INTERCEPT_FUNCTION(freopen64);
+#else
+#define INIT_FOPEN64
+#endif
+
+#if SANITIZER_INTERCEPT_OPEN_MEMSTREAM
+INTERCEPTOR(__sanitizer_FILE *, open_memstream, char **ptr, SIZE_T *sizeloc) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, open_memstream, ptr, sizeloc);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  __sanitizer_FILE *res = REAL(open_memstream)(ptr, sizeloc);
+  if (res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, sizeof(*ptr));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sizeloc, sizeof(*sizeloc));
+    unpoison_file(res);
+    FileMetadata file = {ptr, sizeloc};
+    SetInterceptorMetadata(res, file);
+  }
+  return res;
+}
+INTERCEPTOR(__sanitizer_FILE *, open_wmemstream, wchar_t **ptr,
+            SIZE_T *sizeloc) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, open_wmemstream, ptr, sizeloc);
+  __sanitizer_FILE *res = REAL(open_wmemstream)(ptr, sizeloc);
+  if (res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, sizeof(*ptr));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sizeloc, sizeof(*sizeloc));
+    unpoison_file(res);
+    FileMetadata file = {(char **)ptr, sizeloc};
+    SetInterceptorMetadata(res, file);
+  }
+  return res;
+}
+INTERCEPTOR(__sanitizer_FILE *, fmemopen, void *buf, SIZE_T size,
+            const char *mode) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fmemopen, buf, size, mode);
+  // FIXME: under ASan the call below may write to freed memory and corrupt
+  // its metadata. See
+  // https://github.com/google/sanitizers/issues/321.
+  __sanitizer_FILE *res = REAL(fmemopen)(buf, size, mode);
+  if (res) unpoison_file(res);
+  return res;
+}
+#define INIT_OPEN_MEMSTREAM                   \
+  COMMON_INTERCEPT_FUNCTION(open_memstream);  \
+  COMMON_INTERCEPT_FUNCTION(open_wmemstream); \
+  COMMON_INTERCEPT_FUNCTION(fmemopen);
+#else
+#define INIT_OPEN_MEMSTREAM
+#endif
+
+#if SANITIZER_INTERCEPT_OBSTACK
+static void initialize_obstack(__sanitizer_obstack *obstack) {
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(obstack, sizeof(*obstack));
+  if (obstack->chunk)
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(obstack->chunk,
+                                        sizeof(*obstack->chunk));
+}
+
+INTERCEPTOR(int, _obstack_begin_1, __sanitizer_obstack *obstack, int sz,
+            int align, void *(*alloc_fn)(uptr arg, uptr sz),
+            void (*free_fn)(uptr arg, void *p)) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, _obstack_begin_1, obstack, sz, align, alloc_fn,
+                           free_fn);
+  int res = REAL(_obstack_begin_1)(obstack, sz, align, alloc_fn, free_fn);
+  if (res) initialize_obstack(obstack);
+  return res;
+}
+INTERCEPTOR(int, _obstack_begin, __sanitizer_obstack *obstack, int sz,
+            int align, void *(*alloc_fn)(uptr sz), void (*free_fn)(void *p)) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, _obstack_begin, obstack, sz, align, alloc_fn,
+                           free_fn);
+  int res = REAL(_obstack_begin)(obstack, sz, align, alloc_fn, free_fn);
+  if (res) initialize_obstack(obstack);
+  return res;
+}
+INTERCEPTOR(void, _obstack_newchunk, __sanitizer_obstack *obstack, int length) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, _obstack_newchunk, obstack, length);
+  REAL(_obstack_newchunk)(obstack, length);
+  if (obstack->chunk)
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(
+        obstack->chunk, obstack->next_free - (char *)obstack->chunk);
+}
+#define INIT_OBSTACK                           \
+  COMMON_INTERCEPT_FUNCTION(_obstack_begin_1); \
+  COMMON_INTERCEPT_FUNCTION(_obstack_begin);   \
+  COMMON_INTERCEPT_FUNCTION(_obstack_newchunk);
+#else
+#define INIT_OBSTACK
+#endif
+
+#if SANITIZER_INTERCEPT_FFLUSH
+INTERCEPTOR(int, fflush, __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fflush, fp);
+  int res = REAL(fflush)(fp);
+  // FIXME: handle fp == NULL
+  if (fp) {
+    const FileMetadata *m = GetInterceptorMetadata(fp);
+    if (m) COMMON_INTERCEPTOR_INITIALIZE_RANGE(*m->addr, *m->size);
+  }
+  return res;
+}
+#define INIT_FFLUSH COMMON_INTERCEPT_FUNCTION(fflush);
+#else
+#define INIT_FFLUSH
+#endif
+
+#if SANITIZER_INTERCEPT_FCLOSE
+INTERCEPTOR(int, fclose, __sanitizer_FILE *fp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fclose, fp);
+  COMMON_INTERCEPTOR_FILE_CLOSE(ctx, fp);
+  const FileMetadata *m = GetInterceptorMetadata(fp);
+  int res = REAL(fclose)(fp);
+  if (m) {
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(*m->addr, *m->size);
+    DeleteInterceptorMetadata(fp);
+  }
+  return res;
+}
+#define INIT_FCLOSE COMMON_INTERCEPT_FUNCTION(fclose);
+#else
+#define INIT_FCLOSE
+#endif
+
+#if SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
+INTERCEPTOR(void*, dlopen, const char *filename, int flag) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, dlopen, filename, flag);
+  if (filename) COMMON_INTERCEPTOR_READ_STRING(ctx, filename, 0);
+  COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag);
+  void *res = REAL(dlopen)(filename, flag);
+  COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, res);
+  return res;
+}
+
+INTERCEPTOR(int, dlclose, void *handle) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, dlclose, handle);
+  int res = REAL(dlclose)(handle);
+  COMMON_INTERCEPTOR_LIBRARY_UNLOADED();
+  return res;
+}
+#define INIT_DLOPEN_DLCLOSE          \
+  COMMON_INTERCEPT_FUNCTION(dlopen); \
+  COMMON_INTERCEPT_FUNCTION(dlclose);
+#else
+#define INIT_DLOPEN_DLCLOSE
+#endif
+
+#if SANITIZER_INTERCEPT_GETPASS
+INTERCEPTOR(char *, getpass, const char *prompt) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getpass, prompt);
+  if (prompt)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, prompt, REAL(strlen)(prompt)+1);
+  char *res = REAL(getpass)(prompt);
+  if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res)+1);
+  return res;
+}
+
+#define INIT_GETPASS COMMON_INTERCEPT_FUNCTION(getpass);
+#else
+#define INIT_GETPASS
+#endif
+
+#if SANITIZER_INTERCEPT_TIMERFD
+INTERCEPTOR(int, timerfd_settime, int fd, int flags, void *new_value,
+            void *old_value) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, timerfd_settime, fd, flags, new_value,
+                           old_value);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, new_value, struct_itimerspec_sz);
+  int res = REAL(timerfd_settime)(fd, flags, new_value, old_value);
+  if (res != -1 && old_value)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, old_value, struct_itimerspec_sz);
+  return res;
+}
+
+INTERCEPTOR(int, timerfd_gettime, int fd, void *curr_value) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, timerfd_gettime, fd, curr_value);
+  int res = REAL(timerfd_gettime)(fd, curr_value);
+  if (res != -1 && curr_value)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, curr_value, struct_itimerspec_sz);
+  return res;
+}
+#define INIT_TIMERFD                          \
+  COMMON_INTERCEPT_FUNCTION(timerfd_settime); \
+  COMMON_INTERCEPT_FUNCTION(timerfd_gettime);
+#else
+#define INIT_TIMERFD
+#endif
+
+#if SANITIZER_INTERCEPT_MLOCKX
+// Linux kernel has a bug that leads to kernel deadlock if a process
+// maps TBs of memory and then calls mlock().
+static void MlockIsUnsupported() {
+  static atomic_uint8_t printed;
+  if (atomic_exchange(&printed, 1, memory_order_relaxed))
+    return;
+  VPrintf(1, "%s ignores mlock/mlockall/munlock/munlockall\n",
+          SanitizerToolName);
+}
+
+INTERCEPTOR(int, mlock, const void *addr, uptr len) {
+  MlockIsUnsupported();
+  return 0;
+}
+
+INTERCEPTOR(int, munlock, const void *addr, uptr len) {
+  MlockIsUnsupported();
+  return 0;
+}
+
+INTERCEPTOR(int, mlockall, int flags) {
+  MlockIsUnsupported();
+  return 0;
+}
+
+INTERCEPTOR(int, munlockall, void) {
+  MlockIsUnsupported();
+  return 0;
+}
+
+#define INIT_MLOCKX                                                            \
+  COMMON_INTERCEPT_FUNCTION(mlock);                                            \
+  COMMON_INTERCEPT_FUNCTION(munlock);                                          \
+  COMMON_INTERCEPT_FUNCTION(mlockall);                                         \
+  COMMON_INTERCEPT_FUNCTION(munlockall);
+
+#else
+#define INIT_MLOCKX
+#endif  // SANITIZER_INTERCEPT_MLOCKX
+
+#if SANITIZER_INTERCEPT_FOPENCOOKIE
+struct WrappedCookie {
+  void *real_cookie;
+  __sanitizer_cookie_io_functions_t real_io_funcs;
+};
+
+static uptr wrapped_read(void *cookie, char *buf, uptr size) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(3);
+  WrappedCookie *wrapped_cookie = (WrappedCookie *)cookie;
+  __sanitizer_cookie_io_read real_read = wrapped_cookie->real_io_funcs.read;
+  return real_read ? real_read(wrapped_cookie->real_cookie, buf, size) : 0;
+}
+
+static uptr wrapped_write(void *cookie, const char *buf, uptr size) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(3);
+  WrappedCookie *wrapped_cookie = (WrappedCookie *)cookie;
+  __sanitizer_cookie_io_write real_write = wrapped_cookie->real_io_funcs.write;
+  return real_write ? real_write(wrapped_cookie->real_cookie, buf, size) : size;
+}
+
+static int wrapped_seek(void *cookie, u64 *offset, int whence) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(3);
+  COMMON_INTERCEPTOR_INITIALIZE_RANGE(offset, sizeof(*offset));
+  WrappedCookie *wrapped_cookie = (WrappedCookie *)cookie;
+  __sanitizer_cookie_io_seek real_seek = wrapped_cookie->real_io_funcs.seek;
+  return real_seek ? real_seek(wrapped_cookie->real_cookie, offset, whence)
+                   : -1;
+}
+
+static int wrapped_close(void *cookie) {
+  COMMON_INTERCEPTOR_UNPOISON_PARAM(1);
+  WrappedCookie *wrapped_cookie = (WrappedCookie *)cookie;
+  __sanitizer_cookie_io_close real_close = wrapped_cookie->real_io_funcs.close;
+  int res = real_close ? real_close(wrapped_cookie->real_cookie) : 0;
+  InternalFree(wrapped_cookie);
+  return res;
+}
+
+INTERCEPTOR(__sanitizer_FILE *, fopencookie, void *cookie, const char *mode,
+            __sanitizer_cookie_io_functions_t io_funcs) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fopencookie, cookie, mode, io_funcs);
+  WrappedCookie *wrapped_cookie =
+      (WrappedCookie *)InternalAlloc(sizeof(WrappedCookie));
+  wrapped_cookie->real_cookie = cookie;
+  wrapped_cookie->real_io_funcs = io_funcs;
+  __sanitizer_FILE *res =
+      REAL(fopencookie)(wrapped_cookie, mode, {wrapped_read, wrapped_write,
+                                               wrapped_seek, wrapped_close});
+  return res;
+}
+
+#define INIT_FOPENCOOKIE COMMON_INTERCEPT_FUNCTION(fopencookie);
+#else
+#define INIT_FOPENCOOKIE
+#endif  // SANITIZER_INTERCEPT_FOPENCOOKIE
+
+#if SANITIZER_INTERCEPT_SEM
+INTERCEPTOR(int, sem_init, __sanitizer_sem_t *s, int pshared, unsigned value) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_init, s, pshared, value);
+  // Workaround a bug in glibc's "old" semaphore implementation by
+  // zero-initializing the sem_t contents. This has to be done here because
+  // interceptors bind to the lowest symbols version by default, hitting the
+  // buggy code path while the non-sanitized build of the same code works fine.
+  REAL(memset)(s, 0, sizeof(*s));
+  int res = REAL(sem_init)(s, pshared, value);
+  return res;
+}
+
+INTERCEPTOR(int, sem_destroy, __sanitizer_sem_t *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_destroy, s);
+  int res = REAL(sem_destroy)(s);
+  return res;
+}
+
+INTERCEPTOR(int, sem_wait, __sanitizer_sem_t *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_wait, s);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(sem_wait)(s);
+  if (res == 0) {
+    COMMON_INTERCEPTOR_ACQUIRE(ctx, (uptr)s);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sem_trywait, __sanitizer_sem_t *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_trywait, s);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(sem_trywait)(s);
+  if (res == 0) {
+    COMMON_INTERCEPTOR_ACQUIRE(ctx, (uptr)s);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sem_timedwait, __sanitizer_sem_t *s, void *abstime) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_timedwait, s, abstime);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, abstime, struct_timespec_sz);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(sem_timedwait)(s, abstime);
+  if (res == 0) {
+    COMMON_INTERCEPTOR_ACQUIRE(ctx, (uptr)s);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sem_post, __sanitizer_sem_t *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_post, s);
+  COMMON_INTERCEPTOR_RELEASE(ctx, (uptr)s);
+  int res = REAL(sem_post)(s);
+  return res;
+}
+
+INTERCEPTOR(int, sem_getvalue, __sanitizer_sem_t *s, int *sval) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sem_getvalue, s, sval);
+  int res = REAL(sem_getvalue)(s, sval);
+  if (res == 0) {
+    COMMON_INTERCEPTOR_ACQUIRE(ctx, (uptr)s);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, sval, sizeof(*sval));
+  }
+  return res;
+}
+#define INIT_SEM                                                               \
+  COMMON_INTERCEPT_FUNCTION(sem_init);                                         \
+  COMMON_INTERCEPT_FUNCTION(sem_destroy);                                      \
+  COMMON_INTERCEPT_FUNCTION(sem_wait);                                         \
+  COMMON_INTERCEPT_FUNCTION(sem_trywait);                                      \
+  COMMON_INTERCEPT_FUNCTION(sem_timedwait);                                    \
+  COMMON_INTERCEPT_FUNCTION(sem_post);                                         \
+  COMMON_INTERCEPT_FUNCTION(sem_getvalue);
+#else
+#define INIT_SEM
+#endif // SANITIZER_INTERCEPT_SEM
+
+#if SANITIZER_INTERCEPT_PTHREAD_SETCANCEL
+INTERCEPTOR(int, pthread_setcancelstate, int state, int *oldstate) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcancelstate, state, oldstate);
+  int res = REAL(pthread_setcancelstate)(state, oldstate);
+  if (res == 0)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldstate, sizeof(*oldstate));
+  return res;
+}
+
+INTERCEPTOR(int, pthread_setcanceltype, int type, int *oldtype) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcanceltype, type, oldtype);
+  int res = REAL(pthread_setcanceltype)(type, oldtype);
+  if (res == 0)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldtype, sizeof(*oldtype));
+  return res;
+}
+#define INIT_PTHREAD_SETCANCEL                                                 \
+  COMMON_INTERCEPT_FUNCTION(pthread_setcancelstate);                           \
+  COMMON_INTERCEPT_FUNCTION(pthread_setcanceltype);
+#else
+#define INIT_PTHREAD_SETCANCEL
+#endif
+
+#if SANITIZER_INTERCEPT_MINCORE
+INTERCEPTOR(int, mincore, void *addr, uptr length, unsigned char *vec) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, mincore, addr, length, vec);
+  int res = REAL(mincore)(addr, length, vec);
+  if (res == 0) {
+    uptr page_size = GetPageSizeCached();
+    uptr vec_size = ((length + page_size - 1) & (~(page_size - 1))) / page_size;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, vec, vec_size);
+  }
+  return res;
+}
+#define INIT_MINCORE COMMON_INTERCEPT_FUNCTION(mincore);
+#else
+#define INIT_MINCORE
+#endif
+
+#if SANITIZER_INTERCEPT_PROCESS_VM_READV
+INTERCEPTOR(SSIZE_T, process_vm_readv, int pid, __sanitizer_iovec *local_iov,
+            uptr liovcnt, __sanitizer_iovec *remote_iov, uptr riovcnt,
+            uptr flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, process_vm_readv, pid, local_iov, liovcnt,
+                           remote_iov, riovcnt, flags);
+  SSIZE_T res = REAL(process_vm_readv)(pid, local_iov, liovcnt, remote_iov,
+                                       riovcnt, flags);
+  if (res > 0)
+    write_iovec(ctx, local_iov, liovcnt, res);
+  return res;
+}
+
+INTERCEPTOR(SSIZE_T, process_vm_writev, int pid, __sanitizer_iovec *local_iov,
+            uptr liovcnt, __sanitizer_iovec *remote_iov, uptr riovcnt,
+            uptr flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, process_vm_writev, pid, local_iov, liovcnt,
+                           remote_iov, riovcnt, flags);
+  SSIZE_T res = REAL(process_vm_writev)(pid, local_iov, liovcnt, remote_iov,
+                                        riovcnt, flags);
+  if (res > 0)
+    read_iovec(ctx, local_iov, liovcnt, res);
+  return res;
+}
+#define INIT_PROCESS_VM_READV                                                  \
+  COMMON_INTERCEPT_FUNCTION(process_vm_readv);                                 \
+  COMMON_INTERCEPT_FUNCTION(process_vm_writev);
+#else
+#define INIT_PROCESS_VM_READV
+#endif
+
+#if SANITIZER_INTERCEPT_CTERMID
+INTERCEPTOR(char *, ctermid, char *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ctermid, s);
+  char *res = REAL(ctermid)(s);
+  if (res) {
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+#define INIT_CTERMID COMMON_INTERCEPT_FUNCTION(ctermid);
+#else
+#define INIT_CTERMID
+#endif
+
+#if SANITIZER_INTERCEPT_CTERMID_R
+INTERCEPTOR(char *, ctermid_r, char *s) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, ctermid_r, s);
+  char *res = REAL(ctermid_r)(s);
+  if (res) {
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
+  }
+  return res;
+}
+#define INIT_CTERMID_R COMMON_INTERCEPT_FUNCTION(ctermid_r);
+#else
+#define INIT_CTERMID_R
+#endif
+
+static void InitializeCommonInterceptors() {
+  static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
+  interceptor_metadata_map = new((void *)&metadata_mem) MetadataHashMap();
+
+  INIT_TEXTDOMAIN;
+  INIT_STRCMP;
+  INIT_STRNCMP;
+  INIT_STRCASECMP;
+  INIT_STRNCASECMP;
+  INIT_STRSTR;
+  INIT_STRCASESTR;
+  INIT_STRSPN;
+  INIT_STRPBRK;
+  INIT_MEMCHR;
+  INIT_MEMCMP;
+  INIT_MEMRCHR;
+  INIT_READ;
+  INIT_PREAD;
+  INIT_PREAD64;
+  INIT_READV;
+  INIT_PREADV;
+  INIT_PREADV64;
+  INIT_WRITE;
+  INIT_PWRITE;
+  INIT_PWRITE64;
+  INIT_WRITEV;
+  INIT_PWRITEV;
+  INIT_PWRITEV64;
+  INIT_PRCTL;
+  INIT_LOCALTIME_AND_FRIENDS;
+  INIT_STRPTIME;
+  INIT_SCANF;
+  INIT_ISOC99_SCANF;
+  INIT_PRINTF;
+  INIT_PRINTF_L;
+  INIT_ISOC99_PRINTF;
+  INIT_FREXP;
+  INIT_FREXPF_FREXPL;
+  INIT_GETPWNAM_AND_FRIENDS;
+  INIT_GETPWNAM_R_AND_FRIENDS;
+  INIT_GETPWENT;
+  INIT_FGETPWENT;
+  INIT_GETPWENT_R;
+  INIT_SETPWENT;
+  INIT_CLOCK_GETTIME;
+  INIT_GETITIMER;
+  INIT_TIME;
+  INIT_GLOB;
+  INIT_WAIT;
+  INIT_WAIT4;
+  INIT_INET;
+  INIT_PTHREAD_GETSCHEDPARAM;
+  INIT_GETADDRINFO;
+  INIT_GETNAMEINFO;
+  INIT_GETSOCKNAME;
+  INIT_GETHOSTBYNAME;
+  INIT_GETHOSTBYNAME_R;
+  INIT_GETHOSTBYNAME2_R;
+  INIT_GETHOSTBYADDR_R;
+  INIT_GETHOSTENT_R;
+  INIT_GETSOCKOPT;
+  INIT_ACCEPT;
+  INIT_ACCEPT4;
+  INIT_MODF;
+  INIT_RECVMSG;
+  INIT_GETPEERNAME;
+  INIT_IOCTL;
+  INIT_INET_ATON;
+  INIT_SYSINFO;
+  INIT_READDIR;
+  INIT_READDIR64;
+  INIT_PTRACE;
+  INIT_SETLOCALE;
+  INIT_GETCWD;
+  INIT_GET_CURRENT_DIR_NAME;
+  INIT_STRTOIMAX;
+  INIT_MBSTOWCS;
+  INIT_MBSNRTOWCS;
+  INIT_WCSTOMBS;
+  INIT_WCSNRTOMBS;
+  INIT_WCRTOMB;
+  INIT_TCGETATTR;
+  INIT_REALPATH;
+  INIT_CANONICALIZE_FILE_NAME;
+  INIT_CONFSTR;
+  INIT_SCHED_GETAFFINITY;
+  INIT_SCHED_GETPARAM;
+  INIT_STRERROR;
+  INIT_STRERROR_R;
+  INIT_XPG_STRERROR_R;
+  INIT_SCANDIR;
+  INIT_SCANDIR64;
+  INIT_GETGROUPS;
+  INIT_POLL;
+  INIT_PPOLL;
+  INIT_WORDEXP;
+  INIT_SIGWAIT;
+  INIT_SIGWAITINFO;
+  INIT_SIGTIMEDWAIT;
+  INIT_SIGSETOPS;
+  INIT_SIGPENDING;
+  INIT_SIGPROCMASK;
+  INIT_BACKTRACE;
+  INIT__EXIT;
+  INIT_PTHREAD_MUTEX_LOCK;
+  INIT_PTHREAD_MUTEX_UNLOCK;
+  INIT_GETMNTENT;
+  INIT_GETMNTENT_R;
+  INIT_STATFS;
+  INIT_STATFS64;
+  INIT_STATVFS;
+  INIT_STATVFS64;
+  INIT_INITGROUPS;
+  INIT_ETHER_NTOA_ATON;
+  INIT_ETHER_HOST;
+  INIT_ETHER_R;
+  INIT_SHMCTL;
+  INIT_RANDOM_R;
+  INIT_PTHREAD_ATTR_GET;
+  INIT_PTHREAD_ATTR_GETINHERITSCHED;
+  INIT_PTHREAD_ATTR_GETAFFINITY_NP;
+  INIT_PTHREAD_MUTEXATTR_GETPSHARED;
+  INIT_PTHREAD_MUTEXATTR_GETTYPE;
+  INIT_PTHREAD_MUTEXATTR_GETPROTOCOL;
+  INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING;
+  INIT_PTHREAD_MUTEXATTR_GETROBUST;
+  INIT_PTHREAD_MUTEXATTR_GETROBUST_NP;
+  INIT_PTHREAD_RWLOCKATTR_GETPSHARED;
+  INIT_PTHREAD_RWLOCKATTR_GETKIND_NP;
+  INIT_PTHREAD_CONDATTR_GETPSHARED;
+  INIT_PTHREAD_CONDATTR_GETCLOCK;
+  INIT_PTHREAD_BARRIERATTR_GETPSHARED;
+  INIT_TMPNAM;
+  INIT_TMPNAM_R;
+  INIT_TEMPNAM;
+  INIT_PTHREAD_SETNAME_NP;
+  INIT_SINCOS;
+  INIT_REMQUO;
+  INIT_LGAMMA;
+  INIT_LGAMMA_R;
+  INIT_LGAMMAL_R;
+  INIT_DRAND48_R;
+  INIT_RAND_R;
+  INIT_GETLINE;
+  INIT_ICONV;
+  INIT_TIMES;
+  INIT_TLS_GET_ADDR;
+  INIT_LISTXATTR;
+  INIT_GETXATTR;
+  INIT_GETRESID;
+  INIT_GETIFADDRS;
+  INIT_IF_INDEXTONAME;
+  INIT_CAPGET;
+  INIT_AEABI_MEM;
+  INIT___BZERO;
+  INIT_FTIME;
+  INIT_XDR;
+  INIT_TSEARCH;
+  INIT_LIBIO_INTERNALS;
+  INIT_FOPEN;
+  INIT_FOPEN64;
+  INIT_OPEN_MEMSTREAM;
+  INIT_OBSTACK;
+  INIT_FFLUSH;
+  INIT_FCLOSE;
+  INIT_DLOPEN_DLCLOSE;
+  INIT_GETPASS;
+  INIT_TIMERFD;
+  INIT_MLOCKX;
+  INIT_FOPENCOOKIE;
+  INIT_SEM;
+  INIT_PTHREAD_SETCANCEL;
+  INIT_MINCORE;
+  INIT_PROCESS_VM_READV;
+  INIT_CTERMID;
+  INIT_CTERMID_R;
+}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc
new file mode 100644
index 0000000..92318cd
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc
@@ -0,0 +1,560 @@
+//===-- sanitizer_common_interceptors_format.inc ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Scanf/printf implementation for use in *Sanitizer interceptors.
+// Follows http://pubs.opengroup.org/onlinepubs/9699919799/functions/fscanf.html
+// and http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html
+// with a few common GNU extensions.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdarg.h>
+
+static const char *parse_number(const char *p, int *out) {
+  *out = internal_atoll(p);
+  while (*p >= '0' && *p <= '9')
+    ++p;
+  return p;
+}
+
+static const char *maybe_parse_param_index(const char *p, int *out) {
+  // n$
+  if (*p >= '0' && *p <= '9') {
+    int number;
+    const char *q = parse_number(p, &number);
+    CHECK(q);
+    if (*q == '$') {
+      *out = number;
+      p = q + 1;
+    }
+  }
+
+  // Otherwise, do not change p. This will be re-parsed later as the field
+  // width.
+  return p;
+}
+
+static bool char_is_one_of(char c, const char *s) {
+  return !!internal_strchr(s, c);
+}
+
+static const char *maybe_parse_length_modifier(const char *p, char ll[2]) {
+  if (char_is_one_of(*p, "jztLq")) {
+    ll[0] = *p;
+    ++p;
+  } else if (*p == 'h') {
+    ll[0] = 'h';
+    ++p;
+    if (*p == 'h') {
+      ll[1] = 'h';
+      ++p;
+    }
+  } else if (*p == 'l') {
+    ll[0] = 'l';
+    ++p;
+    if (*p == 'l') {
+      ll[1] = 'l';
+      ++p;
+    }
+  }
+  return p;
+}
+
+// Returns true if the character is an integer conversion specifier.
+static bool format_is_integer_conv(char c) {
+  return char_is_one_of(c, "diouxXn");
+}
+
+// Returns true if the character is an floating point conversion specifier.
+static bool format_is_float_conv(char c) {
+  return char_is_one_of(c, "aAeEfFgG");
+}
+
+// Returns string output character size for string-like conversions,
+// or 0 if the conversion is invalid.
+static int format_get_char_size(char convSpecifier,
+                                const char lengthModifier[2]) {
+  if (char_is_one_of(convSpecifier, "CS")) {
+    return sizeof(wchar_t);
+  }
+
+  if (char_is_one_of(convSpecifier, "cs[")) {
+    if (lengthModifier[0] == 'l' && lengthModifier[1] == '\0')
+      return sizeof(wchar_t);
+    else if (lengthModifier[0] == '\0')
+      return sizeof(char);
+  }
+
+  return 0;
+}
+
+enum FormatStoreSize {
+  // Store size not known in advance; can be calculated as wcslen() of the
+  // destination buffer.
+  FSS_WCSLEN = -2,
+  // Store size not known in advance; can be calculated as strlen() of the
+  // destination buffer.
+  FSS_STRLEN = -1,
+  // Invalid conversion specifier.
+  FSS_INVALID = 0
+};
+
+// Returns the memory size of a format directive (if >0), or a value of
+// FormatStoreSize.
+static int format_get_value_size(char convSpecifier,
+                                 const char lengthModifier[2],
+                                 bool promote_float) {
+  if (format_is_integer_conv(convSpecifier)) {
+    switch (lengthModifier[0]) {
+    case 'h':
+      return lengthModifier[1] == 'h' ? sizeof(char) : sizeof(short);
+    case 'l':
+      return lengthModifier[1] == 'l' ? sizeof(long long) : sizeof(long);
+    case 'q':
+      return sizeof(long long);
+    case 'L':
+      return sizeof(long long);
+    case 'j':
+      return sizeof(INTMAX_T);
+    case 'z':
+      return sizeof(SIZE_T);
+    case 't':
+      return sizeof(PTRDIFF_T);
+    case 0:
+      return sizeof(int);
+    default:
+      return FSS_INVALID;
+    }
+  }
+
+  if (format_is_float_conv(convSpecifier)) {
+    switch (lengthModifier[0]) {
+    case 'L':
+    case 'q':
+      return sizeof(long double);
+    case 'l':
+      return lengthModifier[1] == 'l' ? sizeof(long double)
+                                           : sizeof(double);
+    case 0:
+      // Printf promotes floats to doubles but scanf does not
+      return promote_float ? sizeof(double) : sizeof(float);
+    default:
+      return FSS_INVALID;
+    }
+  }
+
+  if (convSpecifier == 'p') {
+    if (lengthModifier[0] != 0)
+      return FSS_INVALID;
+    return sizeof(void *);
+  }
+
+  return FSS_INVALID;
+}
+
+struct ScanfDirective {
+  int argIdx; // argument index, or -1 if not specified ("%n$")
+  int fieldWidth;
+  const char *begin;
+  const char *end;
+  bool suppressed; // suppress assignment ("*")
+  bool allocate;   // allocate space ("m")
+  char lengthModifier[2];
+  char convSpecifier;
+  bool maybeGnuMalloc;
+};
+
+// Parse scanf format string. If a valid directive in encountered, it is
+// returned in dir. This function returns the pointer to the first
+// unprocessed character, or 0 in case of error.
+// In case of the end-of-string, a pointer to the closing \0 is returned.
+static const char *scanf_parse_next(const char *p, bool allowGnuMalloc,
+                                    ScanfDirective *dir) {
+  internal_memset(dir, 0, sizeof(*dir));
+  dir->argIdx = -1;
+
+  while (*p) {
+    if (*p != '%') {
+      ++p;
+      continue;
+    }
+    dir->begin = p;
+    ++p;
+    // %%
+    if (*p == '%') {
+      ++p;
+      continue;
+    }
+    if (*p == '\0') {
+      return nullptr;
+    }
+    // %n$
+    p = maybe_parse_param_index(p, &dir->argIdx);
+    CHECK(p);
+    // *
+    if (*p == '*') {
+      dir->suppressed = true;
+      ++p;
+    }
+    // Field width
+    if (*p >= '0' && *p <= '9') {
+      p = parse_number(p, &dir->fieldWidth);
+      CHECK(p);
+      if (dir->fieldWidth <= 0)  // Width if at all must be non-zero
+        return nullptr;
+    }
+    // m
+    if (*p == 'm') {
+      dir->allocate = true;
+      ++p;
+    }
+    // Length modifier.
+    p = maybe_parse_length_modifier(p, dir->lengthModifier);
+    // Conversion specifier.
+    dir->convSpecifier = *p++;
+    // Consume %[...] expression.
+    if (dir->convSpecifier == '[') {
+      if (*p == '^')
+        ++p;
+      if (*p == ']')
+        ++p;
+      while (*p && *p != ']')
+        ++p;
+      if (*p == 0)
+        return nullptr; // unexpected end of string
+                        // Consume the closing ']'.
+      ++p;
+    }
+    // This is unfortunately ambiguous between old GNU extension
+    // of %as, %aS and %a[...] and newer POSIX %a followed by
+    // letters s, S or [.
+    if (allowGnuMalloc && dir->convSpecifier == 'a' &&
+        !dir->lengthModifier[0]) {
+      if (*p == 's' || *p == 'S') {
+        dir->maybeGnuMalloc = true;
+        ++p;
+      } else if (*p == '[') {
+        // Watch for %a[h-j%d], if % appears in the
+        // [...] range, then we need to give up, we don't know
+        // if scanf will parse it as POSIX %a [h-j %d ] or
+        // GNU allocation of string with range dh-j plus %.
+        const char *q = p + 1;
+        if (*q == '^')
+          ++q;
+        if (*q == ']')
+          ++q;
+        while (*q && *q != ']' && *q != '%')
+          ++q;
+        if (*q == 0 || *q == '%')
+          return nullptr;
+        p = q + 1; // Consume the closing ']'.
+        dir->maybeGnuMalloc = true;
+      }
+    }
+    dir->end = p;
+    break;
+  }
+  return p;
+}
+
+static int scanf_get_value_size(ScanfDirective *dir) {
+  if (dir->allocate) {
+    if (!char_is_one_of(dir->convSpecifier, "cCsS["))
+      return FSS_INVALID;
+    return sizeof(char *);
+  }
+
+  if (dir->maybeGnuMalloc) {
+    if (dir->convSpecifier != 'a' || dir->lengthModifier[0])
+      return FSS_INVALID;
+    // This is ambiguous, so check the smaller size of char * (if it is
+    // a GNU extension of %as, %aS or %a[...]) and float (if it is
+    // POSIX %a followed by s, S or [ letters).
+    return sizeof(char *) < sizeof(float) ? sizeof(char *) : sizeof(float);
+  }
+
+  if (char_is_one_of(dir->convSpecifier, "cCsS[")) {
+    bool needsTerminator = char_is_one_of(dir->convSpecifier, "sS[");
+    unsigned charSize =
+        format_get_char_size(dir->convSpecifier, dir->lengthModifier);
+    if (charSize == 0)
+      return FSS_INVALID;
+    if (dir->fieldWidth == 0) {
+      if (!needsTerminator)
+        return charSize;
+      return (charSize == sizeof(char)) ? FSS_STRLEN : FSS_WCSLEN;
+    }
+    return (dir->fieldWidth + needsTerminator) * charSize;
+  }
+
+  return format_get_value_size(dir->convSpecifier, dir->lengthModifier, false);
+}
+
+// Common part of *scanf interceptors.
+// Process format string and va_list, and report all store ranges.
+// Stops when "consuming" n_inputs input items.
+static void scanf_common(void *ctx, int n_inputs, bool allowGnuMalloc,
+                         const char *format, va_list aq) {
+  CHECK_GT(n_inputs, 0);
+  const char *p = format;
+
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, format, internal_strlen(format) + 1);
+
+  while (*p) {
+    ScanfDirective dir;
+    p = scanf_parse_next(p, allowGnuMalloc, &dir);
+    if (!p)
+      break;
+    if (dir.convSpecifier == 0) {
+      // This can only happen at the end of the format string.
+      CHECK_EQ(*p, 0);
+      break;
+    }
+    // Here the directive is valid. Do what it says.
+    if (dir.argIdx != -1) {
+      // Unsupported.
+      break;
+    }
+    if (dir.suppressed)
+      continue;
+    int size = scanf_get_value_size(&dir);
+    if (size == FSS_INVALID) {
+      Report("WARNING: unexpected format specifier in scanf interceptor: "
+        "%.*s\n", dir.end - dir.begin, dir.begin);
+      break;
+    }
+    void *argp = va_arg(aq, void *);
+    if (dir.convSpecifier != 'n')
+      --n_inputs;
+    if (n_inputs < 0)
+      break;
+    if (size == FSS_STRLEN) {
+      size = internal_strlen((const char *)argp) + 1;
+    } else if (size == FSS_WCSLEN) {
+      // FIXME: actually use wcslen() to calculate it.
+      size = 0;
+    }
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, argp, size);
+  }
+}
+
+#if SANITIZER_INTERCEPT_PRINTF
+
+struct PrintfDirective {
+  int fieldWidth;
+  int fieldPrecision;
+  int argIdx; // width argument index, or -1 if not specified ("%*n$")
+  int precisionIdx; // precision argument index, or -1 if not specified (".*n$")
+  const char *begin;
+  const char *end;
+  bool starredWidth;
+  bool starredPrecision;
+  char lengthModifier[2];
+  char convSpecifier;
+};
+
+static const char *maybe_parse_number(const char *p, int *out) {
+  if (*p >= '0' && *p <= '9')
+    p = parse_number(p, out);
+  return p;
+}
+
+static const char *maybe_parse_number_or_star(const char *p, int *out,
+                                              bool *star) {
+  if (*p == '*') {
+    *star = true;
+    ++p;
+  } else {
+    *star = false;
+    p = maybe_parse_number(p, out);
+  }
+  return p;
+}
+
+// Parse printf format string. Same as scanf_parse_next.
+static const char *printf_parse_next(const char *p, PrintfDirective *dir) {
+  internal_memset(dir, 0, sizeof(*dir));
+  dir->argIdx = -1;
+  dir->precisionIdx = -1;
+
+  while (*p) {
+    if (*p != '%') {
+      ++p;
+      continue;
+    }
+    dir->begin = p;
+    ++p;
+    // %%
+    if (*p == '%') {
+      ++p;
+      continue;
+    }
+    if (*p == '\0') {
+      return nullptr;
+    }
+    // %n$
+    p = maybe_parse_param_index(p, &dir->precisionIdx);
+    CHECK(p);
+    // Flags
+    while (char_is_one_of(*p, "'-+ #0")) {
+      ++p;
+    }
+    // Field width
+    p = maybe_parse_number_or_star(p, &dir->fieldWidth,
+                                   &dir->starredWidth);
+    if (!p)
+      return nullptr;
+    // Precision
+    if (*p == '.') {
+      ++p;
+      // Actual precision is optional (surprise!)
+      p = maybe_parse_number_or_star(p, &dir->fieldPrecision,
+                                     &dir->starredPrecision);
+      if (!p)
+        return nullptr;
+      // m$
+      if (dir->starredPrecision) {
+        p = maybe_parse_param_index(p, &dir->precisionIdx);
+        CHECK(p);
+      }
+    }
+    // Length modifier.
+    p = maybe_parse_length_modifier(p, dir->lengthModifier);
+    // Conversion specifier.
+    dir->convSpecifier = *p++;
+    dir->end = p;
+    break;
+  }
+  return p;
+}
+
+static int printf_get_value_size(PrintfDirective *dir) {
+  if (dir->convSpecifier == 'm') {
+    return sizeof(char *);
+  }
+
+  if (char_is_one_of(dir->convSpecifier, "cCsS")) {
+    unsigned charSize =
+        format_get_char_size(dir->convSpecifier, dir->lengthModifier);
+    if (charSize == 0)
+      return FSS_INVALID;
+    if (char_is_one_of(dir->convSpecifier, "sS")) {
+      return (charSize == sizeof(char)) ? FSS_STRLEN : FSS_WCSLEN;
+    }
+    return charSize;
+  }
+
+  return format_get_value_size(dir->convSpecifier, dir->lengthModifier, true);
+}
+
+#define SKIP_SCALAR_ARG(aq, convSpecifier, size)                   \
+  do {                                                             \
+    if (format_is_float_conv(convSpecifier)) {                     \
+      switch (size) {                                              \
+      case 8:                                                      \
+        va_arg(*aq, double);                                       \
+        break;                                                     \
+      case 12:                                                     \
+        va_arg(*aq, long double);                                  \
+        break;                                                     \
+      case 16:                                                     \
+        va_arg(*aq, long double);                                  \
+        break;                                                     \
+      default:                                                     \
+        Report("WARNING: unexpected floating-point arg size"       \
+               " in printf interceptor: %d\n", size);              \
+        return;                                                    \
+      }                                                            \
+    } else {                                                       \
+      switch (size) {                                              \
+      case 1:                                                      \
+      case 2:                                                      \
+      case 4:                                                      \
+        va_arg(*aq, u32);                                          \
+        break;                                                     \
+      case 8:                                                      \
+        va_arg(*aq, u64);                                          \
+        break;                                                     \
+      default:                                                     \
+        Report("WARNING: unexpected arg size"                      \
+               " in printf interceptor: %d\n", size);              \
+        return;                                                    \
+      }                                                            \
+    }                                                              \
+  } while (0)
+
+// Common part of *printf interceptors.
+// Process format string and va_list, and report all load ranges.
+static void printf_common(void *ctx, const char *format, va_list aq) {
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, format, internal_strlen(format) + 1);
+
+  const char *p = format;
+
+  while (*p) {
+    PrintfDirective dir;
+    p = printf_parse_next(p, &dir);
+    if (!p)
+      break;
+    if (dir.convSpecifier == 0) {
+      // This can only happen at the end of the format string.
+      CHECK_EQ(*p, 0);
+      break;
+    }
+    // Here the directive is valid. Do what it says.
+    if (dir.argIdx != -1 || dir.precisionIdx != -1) {
+      // Unsupported.
+      break;
+    }
+    if (dir.starredWidth) {
+      // Dynamic width
+      SKIP_SCALAR_ARG(&aq, 'd', sizeof(int));
+    }
+    if (dir.starredPrecision) {
+      // Dynamic precision
+      SKIP_SCALAR_ARG(&aq, 'd', sizeof(int));
+    }
+    int size = printf_get_value_size(&dir);
+    if (size == FSS_INVALID) {
+      Report("WARNING: unexpected format specifier in printf "
+             "interceptor: %.*s\n", dir.end - dir.begin, dir.begin);
+      break;
+    }
+    if (dir.convSpecifier == 'n') {
+      void *argp = va_arg(aq, void *);
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, argp, size);
+      continue;
+    } else if (size == FSS_STRLEN) {
+      if (void *argp = va_arg(aq, void *)) {
+        if (dir.starredPrecision) {
+          // FIXME: properly support starred precision for strings.
+          size = 0;
+        } else if (dir.fieldPrecision > 0) {
+          // Won't read more than "precision" symbols.
+          size = internal_strnlen((const char *)argp, dir.fieldPrecision);
+          if (size < dir.fieldPrecision) size++;
+        } else {
+          // Whole string will be accessed.
+          size = internal_strlen((const char *)argp) + 1;
+        }
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, argp, size);
+      }
+    } else if (size == FSS_WCSLEN) {
+      if (void *argp = va_arg(aq, void *)) {
+        // FIXME: Properly support wide-character strings (via wcsrtombs).
+        size = 0;
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, argp, size);
+      }
+    } else {
+      // Skip non-pointer args
+      SKIP_SCALAR_ARG(&aq, dir.convSpecifier, size);
+    }
+  }
+}
+
+#endif // SANITIZER_INTERCEPT_PRINTF
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc
new file mode 100644
index 0000000..fcd0a3d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc
@@ -0,0 +1,600 @@
+//===-- sanitizer_common_interceptors_ioctl.inc -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Ioctl handling in common sanitizer interceptors.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_flags.h"
+
+struct ioctl_desc {
+  unsigned req;
+  // FIXME: support read+write arguments. Currently READWRITE and WRITE do the
+  // same thing.
+  // XXX: The declarations below may use WRITE instead of READWRITE, unless
+  // explicitly noted.
+  enum {
+    NONE,
+    READ,
+    WRITE,
+    READWRITE,
+    CUSTOM
+  } type : 3;
+  unsigned size : 29;
+  const char* name;
+};
+
+const unsigned ioctl_table_max = 500;
+static ioctl_desc ioctl_table[ioctl_table_max];
+static unsigned ioctl_table_size = 0;
+
+// This can not be declared as a global, because references to struct_*_sz
+// require a global initializer. And this table must be available before global
+// initializers are run.
+static void ioctl_table_fill() {
+#define _(rq, tp, sz)                                    \
+  if (IOCTL_##rq != IOCTL_NOT_PRESENT) {                 \
+    CHECK(ioctl_table_size < ioctl_table_max);           \
+    ioctl_table[ioctl_table_size].req = IOCTL_##rq;      \
+    ioctl_table[ioctl_table_size].type = ioctl_desc::tp; \
+    ioctl_table[ioctl_table_size].size = sz;             \
+    ioctl_table[ioctl_table_size].name = #rq;            \
+    ++ioctl_table_size;                                  \
+  }
+
+  _(FIOASYNC, READ, sizeof(int));
+  _(FIOCLEX, NONE, 0);
+  _(FIOGETOWN, WRITE, sizeof(int));
+  _(FIONBIO, READ, sizeof(int));
+  _(FIONCLEX, NONE, 0);
+  _(FIOSETOWN, READ, sizeof(int));
+  _(SIOCADDMULTI, READ, struct_ifreq_sz);
+  _(SIOCATMARK, WRITE, sizeof(int));
+  _(SIOCDELMULTI, READ, struct_ifreq_sz);
+  _(SIOCGIFADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFBRDADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFCONF, CUSTOM, 0);
+  _(SIOCGIFDSTADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFFLAGS, WRITE, struct_ifreq_sz);
+  _(SIOCGIFMETRIC, WRITE, struct_ifreq_sz);
+  _(SIOCGIFMTU, WRITE, struct_ifreq_sz);
+  _(SIOCGIFNETMASK, WRITE, struct_ifreq_sz);
+  _(SIOCGPGRP, WRITE, sizeof(int));
+  _(SIOCSIFADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFBRDADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFDSTADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFFLAGS, READ, struct_ifreq_sz);
+  _(SIOCSIFMETRIC, READ, struct_ifreq_sz);
+  _(SIOCSIFMTU, READ, struct_ifreq_sz);
+  _(SIOCSIFNETMASK, READ, struct_ifreq_sz);
+  _(SIOCSPGRP, READ, sizeof(int));
+  _(TIOCCONS, NONE, 0);
+  _(TIOCEXCL, NONE, 0);
+  _(TIOCGETD, WRITE, sizeof(int));
+  _(TIOCGPGRP, WRITE, pid_t_sz);
+  _(TIOCGWINSZ, WRITE, struct_winsize_sz);
+  _(TIOCMBIC, READ, sizeof(int));
+  _(TIOCMBIS, READ, sizeof(int));
+  _(TIOCMGET, WRITE, sizeof(int));
+  _(TIOCMSET, READ, sizeof(int));
+  _(TIOCNOTTY, NONE, 0);
+  _(TIOCNXCL, NONE, 0);
+  _(TIOCOUTQ, WRITE, sizeof(int));
+  _(TIOCPKT, READ, sizeof(int));
+  _(TIOCSCTTY, NONE, 0);
+  _(TIOCSETD, READ, sizeof(int));
+  _(TIOCSPGRP, READ, pid_t_sz);
+  _(TIOCSTI, READ, sizeof(char));
+  _(TIOCSWINSZ, READ, struct_winsize_sz);
+
+#if (SANITIZER_LINUX && !SANITIZER_ANDROID)
+  _(SIOCGETSGCNT, WRITE, struct_sioc_sg_req_sz);
+  _(SIOCGETVIFCNT, WRITE, struct_sioc_vif_req_sz);
+#endif
+
+#if SANITIZER_LINUX
+  // Conflicting request ids.
+  // _(CDROMAUDIOBUFSIZ, NONE, 0);
+  // _(SNDCTL_TMR_CONTINUE, NONE, 0);
+  // _(SNDCTL_TMR_START, NONE, 0);
+  // _(SNDCTL_TMR_STOP, NONE, 0);
+  // _(SOUND_MIXER_READ_LOUD, WRITE, sizeof(int)); // same as ...READ_ENHANCE
+  // _(SOUND_MIXER_READ_MUTE, WRITE, sizeof(int)); // same as ...READ_ENHANCE
+  // _(SOUND_MIXER_WRITE_LOUD, WRITE, sizeof(int)); // same as ...WRITE_ENHANCE
+  // _(SOUND_MIXER_WRITE_MUTE, WRITE, sizeof(int)); // same as ...WRITE_ENHANCE
+  _(BLKFLSBUF, NONE, 0);
+  _(BLKGETSIZE, WRITE, sizeof(uptr));
+  _(BLKRAGET, WRITE, sizeof(int));
+  _(BLKRASET, NONE, 0);
+  _(BLKROGET, WRITE, sizeof(int));
+  _(BLKROSET, READ, sizeof(int));
+  _(BLKRRPART, NONE, 0);
+  _(CDROMEJECT, NONE, 0);
+  _(CDROMEJECT_SW, NONE, 0);
+  _(CDROMMULTISESSION, WRITE, struct_cdrom_multisession_sz);
+  _(CDROMPAUSE, NONE, 0);
+  _(CDROMPLAYMSF, READ, struct_cdrom_msf_sz);
+  _(CDROMPLAYTRKIND, READ, struct_cdrom_ti_sz);
+  _(CDROMREADAUDIO, READ, struct_cdrom_read_audio_sz);
+  _(CDROMREADCOOKED, READ, struct_cdrom_msf_sz);
+  _(CDROMREADMODE1, READ, struct_cdrom_msf_sz);
+  _(CDROMREADMODE2, READ, struct_cdrom_msf_sz);
+  _(CDROMREADRAW, READ, struct_cdrom_msf_sz);
+  _(CDROMREADTOCENTRY, WRITE, struct_cdrom_tocentry_sz);
+  _(CDROMREADTOCHDR, WRITE, struct_cdrom_tochdr_sz);
+  _(CDROMRESET, NONE, 0);
+  _(CDROMRESUME, NONE, 0);
+  _(CDROMSEEK, READ, struct_cdrom_msf_sz);
+  _(CDROMSTART, NONE, 0);
+  _(CDROMSTOP, NONE, 0);
+  _(CDROMSUBCHNL, WRITE, struct_cdrom_subchnl_sz);
+  _(CDROMVOLCTRL, READ, struct_cdrom_volctrl_sz);
+  _(CDROMVOLREAD, WRITE, struct_cdrom_volctrl_sz);
+  _(CDROM_GET_UPC, WRITE, 8);
+  _(EVIOCGABS, WRITE, struct_input_absinfo_sz); // fixup
+  _(EVIOCGBIT, WRITE, struct_input_id_sz); // fixup
+  _(EVIOCGEFFECTS, WRITE, sizeof(int));
+  _(EVIOCGID, WRITE, struct_input_id_sz);
+  _(EVIOCGKEY, WRITE, 0);
+  _(EVIOCGKEYCODE, WRITE, sizeof(int) * 2);
+  _(EVIOCGLED, WRITE, 0);
+  _(EVIOCGNAME, WRITE, 0);
+  _(EVIOCGPHYS, WRITE, 0);
+  _(EVIOCGRAB, READ, sizeof(int));
+  _(EVIOCGREP, WRITE, sizeof(int) * 2);
+  _(EVIOCGSND, WRITE, 0);
+  _(EVIOCGSW, WRITE, 0);
+  _(EVIOCGUNIQ, WRITE, 0);
+  _(EVIOCGVERSION, WRITE, sizeof(int));
+  _(EVIOCRMFF, READ, sizeof(int));
+  _(EVIOCSABS, READ, struct_input_absinfo_sz); // fixup
+  _(EVIOCSFF, READ, struct_ff_effect_sz);
+  _(EVIOCSKEYCODE, READ, sizeof(int) * 2);
+  _(EVIOCSREP, READ, sizeof(int) * 2);
+  _(FDCLRPRM, NONE, 0);
+  _(FDDEFPRM, READ, struct_floppy_struct_sz);
+  _(FDFLUSH, NONE, 0);
+  _(FDFMTBEG, NONE, 0);
+  _(FDFMTEND, NONE, 0);
+  _(FDFMTTRK, READ, struct_format_descr_sz);
+  _(FDGETDRVPRM, WRITE, struct_floppy_drive_params_sz);
+  _(FDGETDRVSTAT, WRITE, struct_floppy_drive_struct_sz);
+  _(FDGETDRVTYP, WRITE, 16);
+  _(FDGETFDCSTAT, WRITE, struct_floppy_fdc_state_sz);
+  _(FDGETMAXERRS, WRITE, struct_floppy_max_errors_sz);
+  _(FDGETPRM, WRITE, struct_floppy_struct_sz);
+  _(FDMSGOFF, NONE, 0);
+  _(FDMSGON, NONE, 0);
+  _(FDPOLLDRVSTAT, WRITE, struct_floppy_drive_struct_sz);
+  _(FDRAWCMD, WRITE, struct_floppy_raw_cmd_sz);
+  _(FDRESET, NONE, 0);
+  _(FDSETDRVPRM, READ, struct_floppy_drive_params_sz);
+  _(FDSETEMSGTRESH, NONE, 0);
+  _(FDSETMAXERRS, READ, struct_floppy_max_errors_sz);
+  _(FDSETPRM, READ, struct_floppy_struct_sz);
+  _(FDTWADDLE, NONE, 0);
+  _(FDWERRORCLR, NONE, 0);
+  _(FDWERRORGET, WRITE, struct_floppy_write_errors_sz);
+  _(HDIO_DRIVE_CMD, WRITE, sizeof(int));
+  _(HDIO_GETGEO, WRITE, struct_hd_geometry_sz);
+  _(HDIO_GET_32BIT, WRITE, sizeof(int));
+  _(HDIO_GET_DMA, WRITE, sizeof(int));
+  _(HDIO_GET_IDENTITY, WRITE, struct_hd_driveid_sz);
+  _(HDIO_GET_KEEPSETTINGS, WRITE, sizeof(int));
+  _(HDIO_GET_MULTCOUNT, WRITE, sizeof(int));
+  _(HDIO_GET_NOWERR, WRITE, sizeof(int));
+  _(HDIO_GET_UNMASKINTR, WRITE, sizeof(int));
+  _(HDIO_SET_32BIT, NONE, 0);
+  _(HDIO_SET_DMA, NONE, 0);
+  _(HDIO_SET_KEEPSETTINGS, NONE, 0);
+  _(HDIO_SET_MULTCOUNT, NONE, 0);
+  _(HDIO_SET_NOWERR, NONE, 0);
+  _(HDIO_SET_UNMASKINTR, NONE, 0);
+  _(MTIOCGET, WRITE, struct_mtget_sz);
+  _(MTIOCPOS, WRITE, struct_mtpos_sz);
+  _(MTIOCTOP, READ, struct_mtop_sz);
+  _(PPPIOCGASYNCMAP, WRITE, sizeof(int));
+  _(PPPIOCGDEBUG, WRITE, sizeof(int));
+  _(PPPIOCGFLAGS, WRITE, sizeof(int));
+  _(PPPIOCGUNIT, WRITE, sizeof(int));
+  _(PPPIOCGXASYNCMAP, WRITE, sizeof(int) * 8);
+  _(PPPIOCSASYNCMAP, READ, sizeof(int));
+  _(PPPIOCSDEBUG, READ, sizeof(int));
+  _(PPPIOCSFLAGS, READ, sizeof(int));
+  _(PPPIOCSMAXCID, READ, sizeof(int));
+  _(PPPIOCSMRU, READ, sizeof(int));
+  _(PPPIOCSXASYNCMAP, READ, sizeof(int) * 8);
+  _(SIOCADDRT, READ, struct_rtentry_sz);
+  _(SIOCDARP, READ, struct_arpreq_sz);
+  _(SIOCDELRT, READ, struct_rtentry_sz);
+  _(SIOCDRARP, READ, struct_arpreq_sz);
+  _(SIOCGARP, WRITE, struct_arpreq_sz);
+  _(SIOCGIFENCAP, WRITE, sizeof(int));
+  _(SIOCGIFHWADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFMAP, WRITE, struct_ifreq_sz);
+  _(SIOCGIFMEM, WRITE, struct_ifreq_sz);
+  _(SIOCGIFNAME, NONE, 0);
+  _(SIOCGIFSLAVE, NONE, 0);
+  _(SIOCGRARP, WRITE, struct_arpreq_sz);
+  _(SIOCGSTAMP, WRITE, timeval_sz);
+  _(SIOCSARP, READ, struct_arpreq_sz);
+  _(SIOCSIFENCAP, READ, sizeof(int));
+  _(SIOCSIFHWADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFLINK, NONE, 0);
+  _(SIOCSIFMAP, READ, struct_ifreq_sz);
+  _(SIOCSIFMEM, READ, struct_ifreq_sz);
+  _(SIOCSIFSLAVE, NONE, 0);
+  _(SIOCSRARP, READ, struct_arpreq_sz);
+  _(SNDCTL_COPR_HALT, WRITE, struct_copr_debug_buf_sz);
+  _(SNDCTL_COPR_LOAD, READ, struct_copr_buffer_sz);
+  _(SNDCTL_COPR_RCODE, WRITE, struct_copr_debug_buf_sz);
+  _(SNDCTL_COPR_RCVMSG, WRITE, struct_copr_msg_sz);
+  _(SNDCTL_COPR_RDATA, WRITE, struct_copr_debug_buf_sz);
+  _(SNDCTL_COPR_RESET, NONE, 0);
+  _(SNDCTL_COPR_RUN, WRITE, struct_copr_debug_buf_sz);
+  _(SNDCTL_COPR_SENDMSG, READ, struct_copr_msg_sz);
+  _(SNDCTL_COPR_WCODE, READ, struct_copr_debug_buf_sz);
+  _(SNDCTL_COPR_WDATA, READ, struct_copr_debug_buf_sz);
+  _(SNDCTL_DSP_GETBLKSIZE, WRITE, sizeof(int));
+  _(SNDCTL_DSP_GETFMTS, WRITE, sizeof(int));
+  _(SNDCTL_DSP_NONBLOCK, NONE, 0);
+  _(SNDCTL_DSP_POST, NONE, 0);
+  _(SNDCTL_DSP_RESET, NONE, 0);
+  _(SNDCTL_DSP_SETFMT, WRITE, sizeof(int));
+  _(SNDCTL_DSP_SETFRAGMENT, WRITE, sizeof(int));
+  _(SNDCTL_DSP_SPEED, WRITE, sizeof(int));
+  _(SNDCTL_DSP_STEREO, WRITE, sizeof(int));
+  _(SNDCTL_DSP_SUBDIVIDE, WRITE, sizeof(int));
+  _(SNDCTL_DSP_SYNC, NONE, 0);
+  _(SNDCTL_FM_4OP_ENABLE, READ, sizeof(int));
+  _(SNDCTL_FM_LOAD_INSTR, READ, struct_sbi_instrument_sz);
+  _(SNDCTL_MIDI_INFO, WRITE, struct_midi_info_sz);
+  _(SNDCTL_MIDI_PRETIME, WRITE, sizeof(int));
+  _(SNDCTL_SEQ_CTRLRATE, WRITE, sizeof(int));
+  _(SNDCTL_SEQ_GETINCOUNT, WRITE, sizeof(int));
+  _(SNDCTL_SEQ_GETOUTCOUNT, WRITE, sizeof(int));
+  _(SNDCTL_SEQ_NRMIDIS, WRITE, sizeof(int));
+  _(SNDCTL_SEQ_NRSYNTHS, WRITE, sizeof(int));
+  _(SNDCTL_SEQ_OUTOFBAND, READ, struct_seq_event_rec_sz);
+  _(SNDCTL_SEQ_PANIC, NONE, 0);
+  _(SNDCTL_SEQ_PERCMODE, NONE, 0);
+  _(SNDCTL_SEQ_RESET, NONE, 0);
+  _(SNDCTL_SEQ_RESETSAMPLES, READ, sizeof(int));
+  _(SNDCTL_SEQ_SYNC, NONE, 0);
+  _(SNDCTL_SEQ_TESTMIDI, READ, sizeof(int));
+  _(SNDCTL_SEQ_THRESHOLD, READ, sizeof(int));
+  _(SNDCTL_SYNTH_INFO, WRITE, struct_synth_info_sz);
+  _(SNDCTL_SYNTH_MEMAVL, WRITE, sizeof(int));
+  _(SNDCTL_TMR_METRONOME, READ, sizeof(int));
+  _(SNDCTL_TMR_SELECT, WRITE, sizeof(int));
+  _(SNDCTL_TMR_SOURCE, WRITE, sizeof(int));
+  _(SNDCTL_TMR_TEMPO, WRITE, sizeof(int));
+  _(SNDCTL_TMR_TIMEBASE, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_ALTPCM, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_BASS, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_CAPS, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_CD, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_DEVMASK, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_ENHANCE, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_IGAIN, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_IMIX, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_LINE, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_LINE1, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_LINE2, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_LINE3, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_MIC, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_OGAIN, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_PCM, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_RECLEV, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_RECMASK, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_RECSRC, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_SPEAKER, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_STEREODEVS, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_SYNTH, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_TREBLE, WRITE, sizeof(int));
+  _(SOUND_MIXER_READ_VOLUME, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_ALTPCM, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_BASS, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_CD, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_ENHANCE, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_IGAIN, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_IMIX, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_LINE, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_LINE1, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_LINE2, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_LINE3, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_MIC, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_OGAIN, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_PCM, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_RECLEV, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_RECSRC, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_SPEAKER, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_SYNTH, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_TREBLE, WRITE, sizeof(int));
+  _(SOUND_MIXER_WRITE_VOLUME, WRITE, sizeof(int));
+  _(SOUND_PCM_READ_BITS, WRITE, sizeof(int));
+  _(SOUND_PCM_READ_CHANNELS, WRITE, sizeof(int));
+  _(SOUND_PCM_READ_FILTER, WRITE, sizeof(int));
+  _(SOUND_PCM_READ_RATE, WRITE, sizeof(int));
+  _(SOUND_PCM_WRITE_CHANNELS, WRITE, sizeof(int));
+  _(SOUND_PCM_WRITE_FILTER, WRITE, sizeof(int));
+  _(TCFLSH, NONE, 0);
+  _(TCGETA, WRITE, struct_termio_sz);
+  _(TCGETS, WRITE, struct_termios_sz);
+  _(TCSBRK, NONE, 0);
+  _(TCSBRKP, NONE, 0);
+  _(TCSETA, READ, struct_termio_sz);
+  _(TCSETAF, READ, struct_termio_sz);
+  _(TCSETAW, READ, struct_termio_sz);
+  _(TCSETS, READ, struct_termios_sz);
+  _(TCSETSF, READ, struct_termios_sz);
+  _(TCSETSW, READ, struct_termios_sz);
+  _(TCXONC, NONE, 0);
+  _(TIOCGLCKTRMIOS, WRITE, struct_termios_sz);
+  _(TIOCGSOFTCAR, WRITE, sizeof(int));
+  _(TIOCINQ, WRITE, sizeof(int));
+  _(TIOCLINUX, READ, sizeof(char));
+  _(TIOCSERCONFIG, NONE, 0);
+  _(TIOCSERGETLSR, WRITE, sizeof(int));
+  _(TIOCSERGWILD, WRITE, sizeof(int));
+  _(TIOCSERSWILD, READ, sizeof(int));
+  _(TIOCSLCKTRMIOS, READ, struct_termios_sz);
+  _(TIOCSSOFTCAR, READ, sizeof(int));
+  _(VT_ACTIVATE, NONE, 0);
+  _(VT_DISALLOCATE, NONE, 0);
+  _(VT_GETMODE, WRITE, struct_vt_mode_sz);
+  _(VT_GETSTATE, WRITE, struct_vt_stat_sz);
+  _(VT_OPENQRY, WRITE, sizeof(int));
+  _(VT_RELDISP, NONE, 0);
+  _(VT_RESIZE, READ, struct_vt_sizes_sz);
+  _(VT_RESIZEX, READ, struct_vt_consize_sz);
+  _(VT_SENDSIG, NONE, 0);
+  _(VT_SETMODE, READ, struct_vt_mode_sz);
+  _(VT_WAITACTIVE, NONE, 0);
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  // _(SIOCDEVPLIP, WRITE, struct_ifreq_sz); // the same as EQL_ENSLAVE
+  _(CYGETDEFTHRESH, WRITE, sizeof(int));
+  _(CYGETDEFTIMEOUT, WRITE, sizeof(int));
+  _(CYGETMON, WRITE, struct_cyclades_monitor_sz);
+  _(CYGETTHRESH, WRITE, sizeof(int));
+  _(CYGETTIMEOUT, WRITE, sizeof(int));
+  _(CYSETDEFTHRESH, NONE, 0);
+  _(CYSETDEFTIMEOUT, NONE, 0);
+  _(CYSETTHRESH, NONE, 0);
+  _(CYSETTIMEOUT, NONE, 0);
+  _(EQL_EMANCIPATE, WRITE, struct_ifreq_sz);
+  _(EQL_ENSLAVE, WRITE, struct_ifreq_sz);
+  _(EQL_GETMASTRCFG, WRITE, struct_ifreq_sz);
+  _(EQL_GETSLAVECFG, WRITE, struct_ifreq_sz);
+  _(EQL_SETMASTRCFG, WRITE, struct_ifreq_sz);
+  _(EQL_SETSLAVECFG, WRITE, struct_ifreq_sz);
+  _(EVIOCGKEYCODE_V2, WRITE, struct_input_keymap_entry_sz);
+  _(EVIOCGPROP, WRITE, 0);
+  _(EVIOCSKEYCODE_V2, READ, struct_input_keymap_entry_sz);
+  _(FS_IOC_GETFLAGS, WRITE, sizeof(int));
+  _(FS_IOC_GETVERSION, WRITE, sizeof(int));
+  _(FS_IOC_SETFLAGS, READ, sizeof(int));
+  _(FS_IOC_SETVERSION, READ, sizeof(int));
+  _(GIO_CMAP, WRITE, 48);
+  _(GIO_FONT, WRITE, 8192);
+  _(GIO_SCRNMAP, WRITE, e_tabsz);
+  _(GIO_UNIMAP, WRITE, struct_unimapdesc_sz);
+  _(GIO_UNISCRNMAP, WRITE, sizeof(short) * e_tabsz);
+  _(KDADDIO, NONE, 0);
+  _(KDDELIO, NONE, 0);
+  _(KDDISABIO, NONE, 0);
+  _(KDENABIO, NONE, 0);
+  _(KDGETKEYCODE, WRITE, struct_kbkeycode_sz);
+  _(KDGETLED, WRITE, 1);
+  _(KDGETMODE, WRITE, sizeof(int));
+  _(KDGKBDIACR, WRITE, struct_kbdiacrs_sz);
+  _(KDGKBENT, WRITE, struct_kbentry_sz);
+  _(KDGKBLED, WRITE, sizeof(int));
+  _(KDGKBMETA, WRITE, sizeof(int));
+  _(KDGKBMODE, WRITE, sizeof(int));
+  _(KDGKBSENT, WRITE, struct_kbsentry_sz);
+  _(KDGKBTYPE, WRITE, 1);
+  _(KDMAPDISP, NONE, 0);
+  _(KDMKTONE, NONE, 0);
+  _(KDSETKEYCODE, READ, struct_kbkeycode_sz);
+  _(KDSETLED, NONE, 0);
+  _(KDSETMODE, NONE, 0);
+  _(KDSIGACCEPT, NONE, 0);
+  _(KDSKBDIACR, READ, struct_kbdiacrs_sz);
+  _(KDSKBENT, READ, struct_kbentry_sz);
+  _(KDSKBLED, NONE, 0);
+  _(KDSKBMETA, NONE, 0);
+  _(KDSKBMODE, NONE, 0);
+  _(KDSKBSENT, READ, struct_kbsentry_sz);
+  _(KDUNMAPDISP, NONE, 0);
+  _(KIOCSOUND, NONE, 0);
+  _(LPABORT, NONE, 0);
+  _(LPABORTOPEN, NONE, 0);
+  _(LPCAREFUL, NONE, 0);
+  _(LPCHAR, NONE, 0);
+  _(LPGETIRQ, WRITE, sizeof(int));
+  _(LPGETSTATUS, WRITE, sizeof(int));
+  _(LPRESET, NONE, 0);
+  _(LPSETIRQ, NONE, 0);
+  _(LPTIME, NONE, 0);
+  _(LPWAIT, NONE, 0);
+  _(MTIOCGETCONFIG, WRITE, struct_mtconfiginfo_sz);
+  _(MTIOCSETCONFIG, READ, struct_mtconfiginfo_sz);
+  _(PIO_CMAP, NONE, 0);
+  _(PIO_FONT, READ, 8192);
+  _(PIO_SCRNMAP, READ, e_tabsz);
+  _(PIO_UNIMAP, READ, struct_unimapdesc_sz);
+  _(PIO_UNIMAPCLR, READ, struct_unimapinit_sz);
+  _(PIO_UNISCRNMAP, READ, sizeof(short) * e_tabsz);
+  _(SCSI_IOCTL_PROBE_HOST, READ, sizeof(int));
+  _(SCSI_IOCTL_TAGGED_DISABLE, NONE, 0);
+  _(SCSI_IOCTL_TAGGED_ENABLE, NONE, 0);
+  _(SNDCTL_DSP_GETISPACE, WRITE, struct_audio_buf_info_sz);
+  _(SNDCTL_DSP_GETOSPACE, WRITE, struct_audio_buf_info_sz);
+  _(TIOCGSERIAL, WRITE, struct_serial_struct_sz);
+  _(TIOCSERGETMULTI, WRITE, struct_serial_multiport_struct_sz);
+  _(TIOCSERSETMULTI, READ, struct_serial_multiport_struct_sz);
+  _(TIOCSSERIAL, READ, struct_serial_struct_sz);
+
+  // The following ioctl requests are shared between AX25, IPX, netrom and
+  // mrouted.
+  // _(SIOCAIPXITFCRT, READ, sizeof(char));
+  // _(SIOCAX25GETUID, READ, struct_sockaddr_ax25_sz);
+  // _(SIOCNRGETPARMS, WRITE, struct_nr_parms_struct_sz);
+  // _(SIOCAIPXPRISLT, READ, sizeof(char));
+  // _(SIOCNRSETPARMS, READ, struct_nr_parms_struct_sz);
+  // _(SIOCAX25ADDUID, READ, struct_sockaddr_ax25_sz);
+  // _(SIOCNRDECOBS, NONE, 0);
+  // _(SIOCAX25DELUID, READ, struct_sockaddr_ax25_sz);
+  // _(SIOCIPXCFGDATA, WRITE, struct_ipx_config_data_sz);
+  // _(SIOCAX25NOUID, READ, sizeof(int));
+  // _(SIOCNRRTCTL, READ, sizeof(int));
+  // _(SIOCAX25DIGCTL, READ, sizeof(int));
+  // _(SIOCAX25GETPARMS, WRITE, struct_ax25_parms_struct_sz);
+  // _(SIOCAX25SETPARMS, READ, struct_ax25_parms_struct_sz);
+#endif
+#undef _
+}
+
+static bool ioctl_initialized = false;
+
+struct ioctl_desc_compare {
+  bool operator()(const ioctl_desc& left, const ioctl_desc& right) const {
+    return left.req < right.req;
+  }
+};
+
+static void ioctl_init() {
+  ioctl_table_fill();
+  InternalSort(&ioctl_table, ioctl_table_size, ioctl_desc_compare());
+
+  bool bad = false;
+  for (unsigned i = 0; i < ioctl_table_size - 1; ++i) {
+    if (ioctl_table[i].req >= ioctl_table[i + 1].req) {
+      Printf("Duplicate or unsorted ioctl request id %x >= %x (%s vs %s)\n",
+             ioctl_table[i].req, ioctl_table[i + 1].req, ioctl_table[i].name,
+             ioctl_table[i + 1].name);
+      bad = true;
+    }
+  }
+
+  if (bad) Die();
+
+  ioctl_initialized = true;
+}
+
+// Handle the most evil ioctls that encode argument value as part of request id.
+static unsigned ioctl_request_fixup(unsigned req) {
+#if SANITIZER_LINUX
+  // Strip size and event number.
+  const unsigned kEviocgbitMask =
+      (IOC_SIZEMASK << IOC_SIZESHIFT) | EVIOC_EV_MAX;
+  if ((req & ~kEviocgbitMask) == IOCTL_EVIOCGBIT)
+    return IOCTL_EVIOCGBIT;
+  // Strip absolute axis number.
+  if ((req & ~EVIOC_ABS_MAX) == IOCTL_EVIOCGABS)
+    return IOCTL_EVIOCGABS;
+  if ((req & ~EVIOC_ABS_MAX) == IOCTL_EVIOCSABS)
+    return IOCTL_EVIOCSABS;
+#endif
+  return req;
+}
+
+static const ioctl_desc *ioctl_table_lookup(unsigned req) {
+  int left = 0;
+  int right = ioctl_table_size;
+  while (left < right) {
+    int mid = (left + right) / 2;
+    if (ioctl_table[mid].req < req)
+      left = mid + 1;
+    else
+      right = mid;
+  }
+  if (left == right && ioctl_table[left].req == req)
+    return ioctl_table + left;
+  else
+    return nullptr;
+}
+
+static bool ioctl_decode(unsigned req, ioctl_desc *desc) {
+  CHECK(desc);
+  desc->req = req;
+  desc->name = "<DECODED_IOCTL>";
+  desc->size = IOC_SIZE(req);
+  // Sanity check.
+  if (desc->size > 0xFFFF) return false;
+  unsigned dir = IOC_DIR(req);
+  switch (dir) {
+    case IOC_NONE:
+      desc->type = ioctl_desc::NONE;
+      break;
+    case IOC_READ | IOC_WRITE:
+      desc->type = ioctl_desc::READWRITE;
+      break;
+    case IOC_READ:
+      desc->type = ioctl_desc::WRITE;
+      break;
+    case IOC_WRITE:
+      desc->type = ioctl_desc::READ;
+      break;
+    default:
+      return false;
+  }
+  // Size can be 0 iff type is NONE.
+  if ((desc->type == IOC_NONE) != (desc->size == 0)) return false;
+  // Sanity check.
+  if (IOC_TYPE(req) == 0) return false;
+  return true;
+}
+
+static const ioctl_desc *ioctl_lookup(unsigned req) {
+  req = ioctl_request_fixup(req);
+  const ioctl_desc *desc = ioctl_table_lookup(req);
+  if (desc) return desc;
+
+  // Try stripping access size from the request id.
+  desc = ioctl_table_lookup(req & ~(IOC_SIZEMASK << IOC_SIZESHIFT));
+  // Sanity check: requests that encode access size are either read or write and
+  // have size of 0 in the table.
+  if (desc && desc->size == 0 &&
+      (desc->type == ioctl_desc::READWRITE || desc->type == ioctl_desc::WRITE ||
+       desc->type == ioctl_desc::READ))
+    return desc;
+  return nullptr;
+}
+
+static void ioctl_common_pre(void *ctx, const ioctl_desc *desc, int d,
+                             unsigned request, void *arg) {
+  if (desc->type == ioctl_desc::READ || desc->type == ioctl_desc::READWRITE) {
+    unsigned size = desc->size ? desc->size : IOC_SIZE(request);
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, arg, size);
+  }
+  if (desc->type != ioctl_desc::CUSTOM)
+    return;
+  if (request == IOCTL_SIOCGIFCONF) {
+    struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, &ifc->ifc_len, sizeof(ifc->ifc_len));
+  }
+}
+
+static void ioctl_common_post(void *ctx, const ioctl_desc *desc, int res, int d,
+                              unsigned request, void *arg) {
+  if (desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READWRITE) {
+    // FIXME: add verbose output
+    unsigned size = desc->size ? desc->size : IOC_SIZE(request);
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, arg, size);
+  }
+  if (desc->type != ioctl_desc::CUSTOM)
+    return;
+  if (request == IOCTL_SIOCGIFCONF) {
+    struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifc->ifc_ifcu.ifcu_req, ifc->ifc_len);
+  }
+}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cc
new file mode 100644
index 0000000..b5d46f2
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cc
@@ -0,0 +1,161 @@
+//===-- sanitizer_common_libcdep.cc ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common.h"
+
+#include "sanitizer_flags.h"
+#include "sanitizer_stackdepot.h"
+#include "sanitizer_stacktrace.h"
+#include "sanitizer_symbolizer.h"
+
+#if SANITIZER_POSIX
+#include "sanitizer_posix.h"
+#endif
+
+namespace __sanitizer {
+
+bool ReportFile::SupportsColors() {
+  SpinMutexLock l(mu);
+  ReopenIfNecessary();
+  return SupportsColoredOutput(fd);
+}
+
+bool ColorizeReports() {
+  // FIXME: Add proper Windows support to AnsiColorDecorator and re-enable color
+  // printing on Windows.
+  if (SANITIZER_WINDOWS)
+    return false;
+
+  const char *flag = common_flags()->color;
+  return internal_strcmp(flag, "always") == 0 ||
+         (internal_strcmp(flag, "auto") == 0 && report_file.SupportsColors());
+}
+
+static void (*sandboxing_callback)();
+void SetSandboxingCallback(void (*f)()) {
+  sandboxing_callback = f;
+}
+
+void ReportErrorSummary(const char *error_type, StackTrace *stack) {
+#if !SANITIZER_GO
+  if (!common_flags()->print_summary)
+    return;
+  if (stack->size == 0) {
+    ReportErrorSummary(error_type);
+    return;
+  }
+  // Currently, we include the first stack frame into the report summary.
+  // Maybe sometimes we need to choose another frame (e.g. skip memcpy/etc).
+  uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
+  SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
+  ReportErrorSummary(error_type, frame->info);
+  frame->ClearAll();
+#endif
+}
+
+static void (*SoftRssLimitExceededCallback)(bool exceeded);
+void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded)) {
+  CHECK_EQ(SoftRssLimitExceededCallback, nullptr);
+  SoftRssLimitExceededCallback = Callback;
+}
+
+void BackgroundThread(void *arg) {
+  uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb;
+  uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb;
+  uptr prev_reported_rss = 0;
+  uptr prev_reported_stack_depot_size = 0;
+  bool reached_soft_rss_limit = false;
+  while (true) {
+    SleepForMillis(100);
+    uptr current_rss_mb = GetRSS() >> 20;
+    if (Verbosity()) {
+      // If RSS has grown 10% since last time, print some information.
+      if (prev_reported_rss * 11 / 10 < current_rss_mb) {
+        Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb);
+        prev_reported_rss = current_rss_mb;
+      }
+      // If stack depot has grown 10% since last time, print it too.
+      StackDepotStats *stack_depot_stats = StackDepotGetStats();
+      if (prev_reported_stack_depot_size * 11 / 10 <
+          stack_depot_stats->allocated) {
+        Printf("%s: StackDepot: %zd ids; %zdM allocated\n",
+               SanitizerToolName,
+               stack_depot_stats->n_uniq_ids,
+               stack_depot_stats->allocated >> 20);
+        prev_reported_stack_depot_size = stack_depot_stats->allocated;
+      }
+    }
+    // Check RSS against the limit.
+    if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) {
+      Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n",
+             SanitizerToolName, hard_rss_limit_mb, current_rss_mb);
+      DumpProcessMap();
+      Die();
+    }
+    if (soft_rss_limit_mb) {
+      if (soft_rss_limit_mb < current_rss_mb && !reached_soft_rss_limit) {
+        reached_soft_rss_limit = true;
+        Report("%s: soft rss limit exhausted (%zdMb vs %zdMb)\n",
+               SanitizerToolName, soft_rss_limit_mb, current_rss_mb);
+        if (SoftRssLimitExceededCallback)
+          SoftRssLimitExceededCallback(true);
+      } else if (soft_rss_limit_mb >= current_rss_mb &&
+                 reached_soft_rss_limit) {
+        reached_soft_rss_limit = false;
+        if (SoftRssLimitExceededCallback)
+          SoftRssLimitExceededCallback(false);
+      }
+    }
+  }
+}
+
+void WriteToSyslog(const char *msg) {
+  InternalScopedString msg_copy(kErrorMessageBufferSize);
+  msg_copy.append("%s", msg);
+  char *p = msg_copy.data();
+  char *q;
+
+  // Remove color sequences since syslogs cannot print them.
+  RemoveANSIEscapeSequencesFromString(p);
+
+  // Print one line at a time.
+  // syslog, at least on Android, has an implicit message length limit.
+  do {
+    q = internal_strchr(p, '\n');
+    if (q)
+      *q = '\0';
+    WriteOneLineToSyslog(p);
+    if (q)
+      p = q + 1;
+  } while (q);
+}
+
+void MaybeStartBackgroudThread() {
+#if SANITIZER_LINUX && \
+    !SANITIZER_GO  // Need to implement/test on other platforms.
+  // Start the background thread if one of the rss limits is given.
+  if (!common_flags()->hard_rss_limit_mb &&
+      !common_flags()->soft_rss_limit_mb) return;
+  if (!&real_pthread_create) return;  // Can't spawn the thread anyway.
+  internal_start_thread(BackgroundThread, nullptr);
+#endif
+}
+
+}  // namespace __sanitizer
+
+void NOINLINE
+__sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args) {
+  PrepareForSandboxing(args);
+  if (sandboxing_callback)
+    sandboxing_callback();
+}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_nolibc.cc b/compiler-rt/lib/sanitizer_common/sanitizer_common_nolibc.cc
new file mode 100644
index 0000000..89c17e0
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_nolibc.cc
@@ -0,0 +1,26 @@
+//===-- sanitizer_common_nolibc.cc ----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains stubs for libc function to facilitate optional use of
+// libc in no-libcdep sources.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+
+namespace __sanitizer {
+
+#if SANITIZER_LINUX
+bool ShouldLogAfterPrintf() { return false; }
+#endif
+void WriteToSyslog(const char *buffer) {}
+void Abort() { internal__exit(1); }
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc
new file mode 100644
index 0000000..008e577
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc
@@ -0,0 +1,2856 @@
+//===-- sanitizer_common_syscalls.inc ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Common syscalls handlers for tools like AddressSanitizer,
+// ThreadSanitizer, MemorySanitizer, etc.
+//
+// This file should be included into the tool's interceptor file,
+// which has to define it's own macros:
+//   COMMON_SYSCALL_PRE_READ_RANGE
+//          Called in prehook for regions that will be read by the kernel and
+//          must be initialized.
+//   COMMON_SYSCALL_PRE_WRITE_RANGE
+//          Called in prehook for regions that will be written to by the kernel
+//          and must be addressable. The actual write range may be smaller than
+//          reported in the prehook. See POST_WRITE_RANGE.
+//   COMMON_SYSCALL_POST_READ_RANGE
+//          Called in posthook for regions that were read by the kernel. Does
+//          not make much sense.
+//   COMMON_SYSCALL_POST_WRITE_RANGE
+//          Called in posthook for regions that were written to by the kernel
+//          and are now initialized.
+//   COMMON_SYSCALL_ACQUIRE(addr)
+//          Acquire memory visibility from addr.
+//   COMMON_SYSCALL_RELEASE(addr)
+//          Release memory visibility to addr.
+//   COMMON_SYSCALL_FD_CLOSE(fd)
+//          Called before closing file descriptor fd.
+//   COMMON_SYSCALL_FD_ACQUIRE(fd)
+//          Acquire memory visibility from fd.
+//   COMMON_SYSCALL_FD_RELEASE(fd)
+//          Release memory visibility to fd.
+//   COMMON_SYSCALL_PRE_FORK()
+//          Called before fork syscall.
+//   COMMON_SYSCALL_POST_FORK(long res)
+//          Called after fork syscall.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_LINUX
+
+#include "sanitizer_libc.h"
+
+#define PRE_SYSCALL(name)                                                      \
+  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_pre_impl_##name
+#define PRE_READ(p, s) COMMON_SYSCALL_PRE_READ_RANGE(p, s)
+#define PRE_WRITE(p, s) COMMON_SYSCALL_PRE_WRITE_RANGE(p, s)
+
+#define POST_SYSCALL(name)                                                     \
+  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_post_impl_##name
+#define POST_READ(p, s) COMMON_SYSCALL_POST_READ_RANGE(p, s)
+#define POST_WRITE(p, s) COMMON_SYSCALL_POST_WRITE_RANGE(p, s)
+
+#ifndef COMMON_SYSCALL_ACQUIRE
+# define COMMON_SYSCALL_ACQUIRE(addr) ((void)(addr))
+#endif
+
+#ifndef COMMON_SYSCALL_RELEASE
+# define COMMON_SYSCALL_RELEASE(addr) ((void)(addr))
+#endif
+
+#ifndef COMMON_SYSCALL_FD_CLOSE
+# define COMMON_SYSCALL_FD_CLOSE(fd) ((void)(fd))
+#endif
+
+#ifndef COMMON_SYSCALL_FD_ACQUIRE
+# define COMMON_SYSCALL_FD_ACQUIRE(fd) ((void)(fd))
+#endif
+
+#ifndef COMMON_SYSCALL_FD_RELEASE
+# define COMMON_SYSCALL_FD_RELEASE(fd) ((void)(fd))
+#endif
+
+#ifndef COMMON_SYSCALL_PRE_FORK
+# define COMMON_SYSCALL_PRE_FORK() {}
+#endif
+
+#ifndef COMMON_SYSCALL_POST_FORK
+# define COMMON_SYSCALL_POST_FORK(res) {}
+#endif
+
+// FIXME: do some kind of PRE_READ for all syscall arguments (int(s) and such).
+
+extern "C" {
+struct sanitizer_kernel_iovec {
+  void *iov_base;
+  unsigned long iov_len;
+};
+
+struct sanitizer_kernel_msghdr {
+  void *msg_name;
+  int msg_namelen;
+  struct sanitizer_kernel_iovec *msg_iov;
+  unsigned long msg_iovlen;
+  void *msg_control;
+  unsigned long msg_controllen;
+  unsigned msg_flags;
+};
+
+struct sanitizer_kernel_mmsghdr {
+  struct sanitizer_kernel_msghdr msg_hdr;
+  unsigned msg_len;
+};
+
+struct sanitizer_kernel_timespec {
+  long tv_sec;
+  long tv_nsec;
+};
+
+struct sanitizer_kernel_timeval {
+  long tv_sec;
+  long tv_usec;
+};
+
+struct sanitizer_kernel_rusage {
+  struct sanitizer_kernel_timeval ru_timeval[2];
+  long ru_long[14];
+};
+
+struct sanitizer_kernel_sockaddr {
+  unsigned short sa_family;
+  char sa_data[14];
+};
+
+// Real sigset size is always passed as a syscall argument.
+// Declare it "void" to catch sizeof(kernel_sigset_t).
+typedef void kernel_sigset_t;
+
+static void kernel_write_iovec(const __sanitizer_iovec *iovec,
+                        SIZE_T iovlen, SIZE_T maxlen) {
+  for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
+    SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
+    POST_WRITE(iovec[i].iov_base, sz);
+    maxlen -= sz;
+  }
+}
+
+// This functions uses POST_READ, because it needs to run after syscall to know
+// the real read range.
+static void kernel_read_iovec(const __sanitizer_iovec *iovec,
+                       SIZE_T iovlen, SIZE_T maxlen) {
+  POST_READ(iovec, sizeof(*iovec) * iovlen);
+  for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
+    SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
+    POST_READ(iovec[i].iov_base, sz);
+    maxlen -= sz;
+  }
+}
+
+PRE_SYSCALL(recvmsg)(long sockfd, sanitizer_kernel_msghdr *msg, long flags) {
+  PRE_READ(msg, sizeof(*msg));
+}
+
+POST_SYSCALL(recvmsg)(long res, long sockfd, sanitizer_kernel_msghdr *msg,
+                      long flags) {
+  if (res >= 0) {
+    if (msg) {
+      for (unsigned long i = 0; i < msg->msg_iovlen; ++i) {
+        POST_WRITE(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len);
+      }
+      POST_WRITE(msg->msg_control, msg->msg_controllen);
+    }
+  }
+}
+
+PRE_SYSCALL(recvmmsg)(long fd, sanitizer_kernel_mmsghdr *msg, long vlen,
+                      long flags, void *timeout) {
+  PRE_READ(msg, vlen * sizeof(*msg));
+}
+
+POST_SYSCALL(recvmmsg)(long res, long fd, sanitizer_kernel_mmsghdr *msg,
+                       long vlen, long flags, void *timeout) {
+  if (res >= 0) {
+    if (msg) {
+      for (unsigned long i = 0; i < msg->msg_hdr.msg_iovlen; ++i) {
+        POST_WRITE(msg->msg_hdr.msg_iov[i].iov_base,
+                   msg->msg_hdr.msg_iov[i].iov_len);
+      }
+      POST_WRITE(msg->msg_hdr.msg_control, msg->msg_hdr.msg_controllen);
+      POST_WRITE(&msg->msg_len, sizeof(msg->msg_len));
+    }
+    if (timeout) POST_WRITE(timeout, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(read)(long fd, void *buf, uptr count) {
+  if (buf) {
+    PRE_WRITE(buf, count);
+  }
+}
+
+POST_SYSCALL(read)(long res, long fd, void *buf, uptr count) {
+  if (res > 0 && buf) {
+    POST_WRITE(buf, res);
+  }
+}
+
+PRE_SYSCALL(time)(void *tloc) {}
+
+POST_SYSCALL(time)(long res, void *tloc) {
+  if (res >= 0) {
+    if (tloc) POST_WRITE(tloc, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(stime)(void *tptr) {}
+
+POST_SYSCALL(stime)(long res, void *tptr) {
+  if (res >= 0) {
+    if (tptr) POST_WRITE(tptr, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(gettimeofday)(void *tv, void *tz) {}
+
+POST_SYSCALL(gettimeofday)(long res, void *tv, void *tz) {
+  if (res >= 0) {
+    if (tv) POST_WRITE(tv, timeval_sz);
+    if (tz) POST_WRITE(tz, struct_timezone_sz);
+  }
+}
+
+PRE_SYSCALL(settimeofday)(void *tv, void *tz) {}
+
+POST_SYSCALL(settimeofday)(long res, void *tv, void *tz) {
+  if (res >= 0) {
+    if (tv) POST_WRITE(tv, timeval_sz);
+    if (tz) POST_WRITE(tz, struct_timezone_sz);
+  }
+}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(adjtimex)(void *txc_p) {}
+
+POST_SYSCALL(adjtimex)(long res, void *txc_p) {
+  if (res >= 0) {
+    if (txc_p) POST_WRITE(txc_p, struct_timex_sz);
+  }
+}
+#endif
+
+PRE_SYSCALL(times)(void *tbuf) {}
+
+POST_SYSCALL(times)(long res, void *tbuf) {
+  if (res >= 0) {
+    if (tbuf) POST_WRITE(tbuf, struct_tms_sz);
+  }
+}
+
+PRE_SYSCALL(gettid)() {}
+
+POST_SYSCALL(gettid)(long res) {}
+
+PRE_SYSCALL(nanosleep)(void *rqtp, void *rmtp) {}
+
+POST_SYSCALL(nanosleep)(long res, void *rqtp, void *rmtp) {
+  if (res >= 0) {
+    if (rqtp) POST_WRITE(rqtp, struct_timespec_sz);
+    if (rmtp) POST_WRITE(rmtp, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(alarm)(long seconds) {}
+
+POST_SYSCALL(alarm)(long res, long seconds) {}
+
+PRE_SYSCALL(getpid)() {}
+
+POST_SYSCALL(getpid)(long res) {}
+
+PRE_SYSCALL(getppid)() {}
+
+POST_SYSCALL(getppid)(long res) {}
+
+PRE_SYSCALL(getuid)() {}
+
+POST_SYSCALL(getuid)(long res) {}
+
+PRE_SYSCALL(geteuid)() {}
+
+POST_SYSCALL(geteuid)(long res) {}
+
+PRE_SYSCALL(getgid)() {}
+
+POST_SYSCALL(getgid)(long res) {}
+
+PRE_SYSCALL(getegid)() {}
+
+POST_SYSCALL(getegid)(long res) {}
+
+PRE_SYSCALL(getresuid)(void *ruid, void *euid, void *suid) {}
+
+POST_SYSCALL(getresuid)(long res, void *ruid, void *euid, void *suid) {
+  if (res >= 0) {
+    if (ruid) POST_WRITE(ruid, sizeof(unsigned));
+    if (euid) POST_WRITE(euid, sizeof(unsigned));
+    if (suid) POST_WRITE(suid, sizeof(unsigned));
+  }
+}
+
+PRE_SYSCALL(getresgid)(void *rgid, void *egid, void *sgid) {}
+
+POST_SYSCALL(getresgid)(long res, void *rgid, void *egid, void *sgid) {
+  if (res >= 0) {
+    if (rgid) POST_WRITE(rgid, sizeof(unsigned));
+    if (egid) POST_WRITE(egid, sizeof(unsigned));
+    if (sgid) POST_WRITE(sgid, sizeof(unsigned));
+  }
+}
+
+PRE_SYSCALL(getpgid)(long pid) {}
+
+POST_SYSCALL(getpgid)(long res, long pid) {}
+
+PRE_SYSCALL(getpgrp)() {}
+
+POST_SYSCALL(getpgrp)(long res) {}
+
+PRE_SYSCALL(getsid)(long pid) {}
+
+POST_SYSCALL(getsid)(long res, long pid) {}
+
+PRE_SYSCALL(getgroups)(long gidsetsize, void *grouplist) {}
+
+POST_SYSCALL(getgroups)(long res, long gidsetsize,
+                        __sanitizer___kernel_gid_t *grouplist) {
+  if (res >= 0) {
+    if (grouplist) POST_WRITE(grouplist, res * sizeof(*grouplist));
+  }
+}
+
+PRE_SYSCALL(setregid)(long rgid, long egid) {}
+
+POST_SYSCALL(setregid)(long res, long rgid, long egid) {}
+
+PRE_SYSCALL(setgid)(long gid) {}
+
+POST_SYSCALL(setgid)(long res, long gid) {}
+
+PRE_SYSCALL(setreuid)(long ruid, long euid) {}
+
+POST_SYSCALL(setreuid)(long res, long ruid, long euid) {}
+
+PRE_SYSCALL(setuid)(long uid) {}
+
+POST_SYSCALL(setuid)(long res, long uid) {}
+
+PRE_SYSCALL(setresuid)(long ruid, long euid, long suid) {}
+
+POST_SYSCALL(setresuid)(long res, long ruid, long euid, long suid) {}
+
+PRE_SYSCALL(setresgid)(long rgid, long egid, long sgid) {}
+
+POST_SYSCALL(setresgid)(long res, long rgid, long egid, long sgid) {}
+
+PRE_SYSCALL(setfsuid)(long uid) {}
+
+POST_SYSCALL(setfsuid)(long res, long uid) {}
+
+PRE_SYSCALL(setfsgid)(long gid) {}
+
+POST_SYSCALL(setfsgid)(long res, long gid) {}
+
+PRE_SYSCALL(setpgid)(long pid, long pgid) {}
+
+POST_SYSCALL(setpgid)(long res, long pid, long pgid) {}
+
+PRE_SYSCALL(setsid)() {}
+
+POST_SYSCALL(setsid)(long res) {}
+
+PRE_SYSCALL(setgroups)(long gidsetsize, __sanitizer___kernel_gid_t *grouplist) {
+  if (grouplist) POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist));
+}
+
+POST_SYSCALL(setgroups)(long res, long gidsetsize,
+                        __sanitizer___kernel_gid_t *grouplist) {}
+
+PRE_SYSCALL(acct)(const void *name) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(acct)(long res, const void *name) {}
+
+PRE_SYSCALL(capget)(void *header, void *dataptr) {
+  if (header) PRE_READ(header, __user_cap_header_struct_sz);
+}
+
+POST_SYSCALL(capget)(long res, void *header, void *dataptr) {
+  if (res >= 0)
+    if (dataptr) POST_WRITE(dataptr, __user_cap_data_struct_sz);
+}
+
+PRE_SYSCALL(capset)(void *header, const void *data) {
+  if (header) PRE_READ(header, __user_cap_header_struct_sz);
+  if (data) PRE_READ(data, __user_cap_data_struct_sz);
+}
+
+POST_SYSCALL(capset)(long res, void *header, const void *data) {}
+
+PRE_SYSCALL(personality)(long personality) {}
+
+POST_SYSCALL(personality)(long res, long personality) {}
+
+PRE_SYSCALL(sigpending)(void *set) {}
+
+POST_SYSCALL(sigpending)(long res, void *set) {
+  if (res >= 0) {
+    if (set) POST_WRITE(set, old_sigset_t_sz);
+  }
+}
+
+PRE_SYSCALL(sigprocmask)(long how, void *set, void *oset) {}
+
+POST_SYSCALL(sigprocmask)(long res, long how, void *set, void *oset) {
+  if (res >= 0) {
+    if (set) POST_WRITE(set, old_sigset_t_sz);
+    if (oset) POST_WRITE(oset, old_sigset_t_sz);
+  }
+}
+
+PRE_SYSCALL(getitimer)(long which, void *value) {}
+
+POST_SYSCALL(getitimer)(long res, long which, void *value) {
+  if (res >= 0) {
+    if (value) POST_WRITE(value, struct_itimerval_sz);
+  }
+}
+
+PRE_SYSCALL(setitimer)(long which, void *value, void *ovalue) {}
+
+POST_SYSCALL(setitimer)(long res, long which, void *value, void *ovalue) {
+  if (res >= 0) {
+    if (value) POST_WRITE(value, struct_itimerval_sz);
+    if (ovalue) POST_WRITE(ovalue, struct_itimerval_sz);
+  }
+}
+
+PRE_SYSCALL(timer_create)(long which_clock, void *timer_event_spec,
+                          void *created_timer_id) {}
+
+POST_SYSCALL(timer_create)(long res, long which_clock, void *timer_event_spec,
+                           void *created_timer_id) {
+  if (res >= 0) {
+    if (timer_event_spec) POST_WRITE(timer_event_spec, struct_sigevent_sz);
+    if (created_timer_id) POST_WRITE(created_timer_id, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(timer_gettime)(long timer_id, void *setting) {}
+
+POST_SYSCALL(timer_gettime)(long res, long timer_id, void *setting) {
+  if (res >= 0) {
+    if (setting) POST_WRITE(setting, struct_itimerspec_sz);
+  }
+}
+
+PRE_SYSCALL(timer_getoverrun)(long timer_id) {}
+
+POST_SYSCALL(timer_getoverrun)(long res, long timer_id) {}
+
+PRE_SYSCALL(timer_settime)(long timer_id, long flags, const void *new_setting,
+                           void *old_setting) {
+  if (new_setting) PRE_READ(new_setting, struct_itimerspec_sz);
+}
+
+POST_SYSCALL(timer_settime)(long res, long timer_id, long flags,
+                            const void *new_setting, void *old_setting) {
+  if (res >= 0) {
+    if (old_setting) POST_WRITE(old_setting, struct_itimerspec_sz);
+  }
+}
+
+PRE_SYSCALL(timer_delete)(long timer_id) {}
+
+POST_SYSCALL(timer_delete)(long res, long timer_id) {}
+
+PRE_SYSCALL(clock_settime)(long which_clock, const void *tp) {
+  if (tp) PRE_READ(tp, struct_timespec_sz);
+}
+
+POST_SYSCALL(clock_settime)(long res, long which_clock, const void *tp) {}
+
+PRE_SYSCALL(clock_gettime)(long which_clock, void *tp) {}
+
+POST_SYSCALL(clock_gettime)(long res, long which_clock, void *tp) {
+  if (res >= 0) {
+    if (tp) POST_WRITE(tp, struct_timespec_sz);
+  }
+}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(clock_adjtime)(long which_clock, void *tx) {}
+
+POST_SYSCALL(clock_adjtime)(long res, long which_clock, void *tx) {
+  if (res >= 0) {
+    if (tx) POST_WRITE(tx, struct_timex_sz);
+  }
+}
+#endif
+
+PRE_SYSCALL(clock_getres)(long which_clock, void *tp) {}
+
+POST_SYSCALL(clock_getres)(long res, long which_clock, void *tp) {
+  if (res >= 0) {
+    if (tp) POST_WRITE(tp, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(clock_nanosleep)(long which_clock, long flags, const void *rqtp,
+                             void *rmtp) {
+  if (rqtp) PRE_READ(rqtp, struct_timespec_sz);
+}
+
+POST_SYSCALL(clock_nanosleep)(long res, long which_clock, long flags,
+                              const void *rqtp, void *rmtp) {
+  if (res >= 0) {
+    if (rmtp) POST_WRITE(rmtp, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(nice)(long increment) {}
+
+POST_SYSCALL(nice)(long res, long increment) {}
+
+PRE_SYSCALL(sched_setscheduler)(long pid, long policy, void *param) {}
+
+POST_SYSCALL(sched_setscheduler)(long res, long pid, long policy, void *param) {
+  if (res >= 0) {
+    if (param) POST_WRITE(param, struct_sched_param_sz);
+  }
+}
+
+PRE_SYSCALL(sched_setparam)(long pid, void *param) {
+  if (param) PRE_READ(param, struct_sched_param_sz);
+}
+
+POST_SYSCALL(sched_setparam)(long res, long pid, void *param) {}
+
+PRE_SYSCALL(sched_getscheduler)(long pid) {}
+
+POST_SYSCALL(sched_getscheduler)(long res, long pid) {}
+
+PRE_SYSCALL(sched_getparam)(long pid, void *param) {}
+
+POST_SYSCALL(sched_getparam)(long res, long pid, void *param) {
+  if (res >= 0) {
+    if (param) POST_WRITE(param, struct_sched_param_sz);
+  }
+}
+
+PRE_SYSCALL(sched_setaffinity)(long pid, long len, void *user_mask_ptr) {
+  if (user_mask_ptr) PRE_READ(user_mask_ptr, len);
+}
+
+POST_SYSCALL(sched_setaffinity)(long res, long pid, long len,
+                                void *user_mask_ptr) {}
+
+PRE_SYSCALL(sched_getaffinity)(long pid, long len, void *user_mask_ptr) {}
+
+POST_SYSCALL(sched_getaffinity)(long res, long pid, long len,
+                                void *user_mask_ptr) {
+  if (res >= 0) {
+    if (user_mask_ptr) POST_WRITE(user_mask_ptr, len);
+  }
+}
+
+PRE_SYSCALL(sched_yield)() {}
+
+POST_SYSCALL(sched_yield)(long res) {}
+
+PRE_SYSCALL(sched_get_priority_max)(long policy) {}
+
+POST_SYSCALL(sched_get_priority_max)(long res, long policy) {}
+
+PRE_SYSCALL(sched_get_priority_min)(long policy) {}
+
+POST_SYSCALL(sched_get_priority_min)(long res, long policy) {}
+
+PRE_SYSCALL(sched_rr_get_interval)(long pid, void *interval) {}
+
+POST_SYSCALL(sched_rr_get_interval)(long res, long pid, void *interval) {
+  if (res >= 0) {
+    if (interval) POST_WRITE(interval, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(setpriority)(long which, long who, long niceval) {}
+
+POST_SYSCALL(setpriority)(long res, long which, long who, long niceval) {}
+
+PRE_SYSCALL(getpriority)(long which, long who) {}
+
+POST_SYSCALL(getpriority)(long res, long which, long who) {}
+
+PRE_SYSCALL(shutdown)(long arg0, long arg1) {}
+
+POST_SYSCALL(shutdown)(long res, long arg0, long arg1) {}
+
+PRE_SYSCALL(reboot)(long magic1, long magic2, long cmd, void *arg) {}
+
+POST_SYSCALL(reboot)(long res, long magic1, long magic2, long cmd, void *arg) {}
+
+PRE_SYSCALL(restart_syscall)() {}
+
+POST_SYSCALL(restart_syscall)(long res) {}
+
+PRE_SYSCALL(kexec_load)(long entry, long nr_segments, void *segments,
+                        long flags) {}
+
+POST_SYSCALL(kexec_load)(long res, long entry, long nr_segments, void *segments,
+                         long flags) {
+  if (res >= 0) {
+    if (segments) POST_WRITE(segments, struct_kexec_segment_sz);
+  }
+}
+
+PRE_SYSCALL(exit)(long error_code) {}
+
+POST_SYSCALL(exit)(long res, long error_code) {}
+
+PRE_SYSCALL(exit_group)(long error_code) {}
+
+POST_SYSCALL(exit_group)(long res, long error_code) {}
+
+PRE_SYSCALL(wait4)(long pid, void *stat_addr, long options, void *ru) {}
+
+POST_SYSCALL(wait4)(long res, long pid, void *stat_addr, long options,
+                    void *ru) {
+  if (res >= 0) {
+    if (stat_addr) POST_WRITE(stat_addr, sizeof(int));
+    if (ru) POST_WRITE(ru, struct_rusage_sz);
+  }
+}
+
+PRE_SYSCALL(waitid)(long which, long pid, void *infop, long options, void *ru) {
+}
+
+POST_SYSCALL(waitid)(long res, long which, long pid, void *infop, long options,
+                     void *ru) {
+  if (res >= 0) {
+    if (infop) POST_WRITE(infop, siginfo_t_sz);
+    if (ru) POST_WRITE(ru, struct_rusage_sz);
+  }
+}
+
+PRE_SYSCALL(waitpid)(long pid, void *stat_addr, long options) {}
+
+POST_SYSCALL(waitpid)(long res, long pid, void *stat_addr, long options) {
+  if (res >= 0) {
+    if (stat_addr) POST_WRITE(stat_addr, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(set_tid_address)(void *tidptr) {}
+
+POST_SYSCALL(set_tid_address)(long res, void *tidptr) {
+  if (res >= 0) {
+    if (tidptr) POST_WRITE(tidptr, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(init_module)(void *umod, long len, const void *uargs) {
+  if (uargs)
+    PRE_READ(uargs, __sanitizer::internal_strlen((const char *)uargs) + 1);
+}
+
+POST_SYSCALL(init_module)(long res, void *umod, long len, const void *uargs) {}
+
+PRE_SYSCALL(delete_module)(const void *name_user, long flags) {
+  if (name_user)
+    PRE_READ(name_user,
+             __sanitizer::internal_strlen((const char *)name_user) + 1);
+}
+
+POST_SYSCALL(delete_module)(long res, const void *name_user, long flags) {}
+
+PRE_SYSCALL(rt_sigprocmask)(long how, void *set, void *oset, long sigsetsize) {}
+
+POST_SYSCALL(rt_sigprocmask)(long res, long how, kernel_sigset_t *set,
+                             kernel_sigset_t *oset, long sigsetsize) {
+  if (res >= 0) {
+    if (set) POST_WRITE(set, sigsetsize);
+    if (oset) POST_WRITE(oset, sigsetsize);
+  }
+}
+
+PRE_SYSCALL(rt_sigpending)(void *set, long sigsetsize) {}
+
+POST_SYSCALL(rt_sigpending)(long res, kernel_sigset_t *set, long sigsetsize) {
+  if (res >= 0) {
+    if (set) POST_WRITE(set, sigsetsize);
+  }
+}
+
+PRE_SYSCALL(rt_sigtimedwait)(const kernel_sigset_t *uthese, void *uinfo,
+                             const void *uts, long sigsetsize) {
+  if (uthese) PRE_READ(uthese, sigsetsize);
+  if (uts) PRE_READ(uts, struct_timespec_sz);
+}
+
+POST_SYSCALL(rt_sigtimedwait)(long res, const void *uthese, void *uinfo,
+                              const void *uts, long sigsetsize) {
+  if (res >= 0) {
+    if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
+  }
+}
+
+PRE_SYSCALL(rt_tgsigqueueinfo)(long tgid, long pid, long sig, void *uinfo) {}
+
+POST_SYSCALL(rt_tgsigqueueinfo)(long res, long tgid, long pid, long sig,
+                                void *uinfo) {
+  if (res >= 0) {
+    if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
+  }
+}
+
+PRE_SYSCALL(kill)(long pid, long sig) {}
+
+POST_SYSCALL(kill)(long res, long pid, long sig) {}
+
+PRE_SYSCALL(tgkill)(long tgid, long pid, long sig) {}
+
+POST_SYSCALL(tgkill)(long res, long tgid, long pid, long sig) {}
+
+PRE_SYSCALL(tkill)(long pid, long sig) {}
+
+POST_SYSCALL(tkill)(long res, long pid, long sig) {}
+
+PRE_SYSCALL(rt_sigqueueinfo)(long pid, long sig, void *uinfo) {}
+
+POST_SYSCALL(rt_sigqueueinfo)(long res, long pid, long sig, void *uinfo) {
+  if (res >= 0) {
+    if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
+  }
+}
+
+PRE_SYSCALL(sgetmask)() {}
+
+POST_SYSCALL(sgetmask)(long res) {}
+
+PRE_SYSCALL(ssetmask)(long newmask) {}
+
+POST_SYSCALL(ssetmask)(long res, long newmask) {}
+
+PRE_SYSCALL(signal)(long sig, long handler) {}
+
+POST_SYSCALL(signal)(long res, long sig, long handler) {}
+
+PRE_SYSCALL(pause)() {}
+
+POST_SYSCALL(pause)(long res) {}
+
+PRE_SYSCALL(sync)() {}
+
+POST_SYSCALL(sync)(long res) {}
+
+PRE_SYSCALL(fsync)(long fd) {}
+
+POST_SYSCALL(fsync)(long res, long fd) {}
+
+PRE_SYSCALL(fdatasync)(long fd) {}
+
+POST_SYSCALL(fdatasync)(long res, long fd) {}
+
+PRE_SYSCALL(bdflush)(long func, long data) {}
+
+POST_SYSCALL(bdflush)(long res, long func, long data) {}
+
+PRE_SYSCALL(mount)(void *dev_name, void *dir_name, void *type, long flags,
+                   void *data) {}
+
+POST_SYSCALL(mount)(long res, void *dev_name, void *dir_name, void *type,
+                    long flags, void *data) {
+  if (res >= 0) {
+    if (dev_name)
+      POST_WRITE(dev_name,
+                 __sanitizer::internal_strlen((const char *)dev_name) + 1);
+    if (dir_name)
+      POST_WRITE(dir_name,
+                 __sanitizer::internal_strlen((const char *)dir_name) + 1);
+    if (type)
+      POST_WRITE(type, __sanitizer::internal_strlen((const char *)type) + 1);
+  }
+}
+
+PRE_SYSCALL(umount)(void *name, long flags) {}
+
+POST_SYSCALL(umount)(long res, void *name, long flags) {
+  if (res >= 0) {
+    if (name)
+      POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  }
+}
+
+PRE_SYSCALL(oldumount)(void *name) {}
+
+POST_SYSCALL(oldumount)(long res, void *name) {
+  if (res >= 0) {
+    if (name)
+      POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  }
+}
+
+PRE_SYSCALL(truncate)(const void *path, long length) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(truncate)(long res, const void *path, long length) {}
+
+PRE_SYSCALL(ftruncate)(long fd, long length) {}
+
+POST_SYSCALL(ftruncate)(long res, long fd, long length) {}
+
+PRE_SYSCALL(stat)(const void *filename, void *statbuf) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(stat)(long res, const void *filename, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
+  }
+}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(statfs)(const void *path, void *buf) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(statfs)(long res, const void *path, void *buf) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, struct_statfs_sz);
+  }
+}
+
+PRE_SYSCALL(statfs64)(const void *path, long sz, void *buf) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(statfs64)(long res, const void *path, long sz, void *buf) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, struct_statfs64_sz);
+  }
+}
+
+PRE_SYSCALL(fstatfs)(long fd, void *buf) {}
+
+POST_SYSCALL(fstatfs)(long res, long fd, void *buf) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, struct_statfs_sz);
+  }
+}
+
+PRE_SYSCALL(fstatfs64)(long fd, long sz, void *buf) {}
+
+POST_SYSCALL(fstatfs64)(long res, long fd, long sz, void *buf) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, struct_statfs64_sz);
+  }
+}
+#endif // !SANITIZER_ANDROID
+
+PRE_SYSCALL(lstat)(const void *filename, void *statbuf) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(lstat)(long res, const void *filename, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
+  }
+}
+
+PRE_SYSCALL(fstat)(long fd, void *statbuf) {}
+
+POST_SYSCALL(fstat)(long res, long fd, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
+  }
+}
+
+PRE_SYSCALL(newstat)(const void *filename, void *statbuf) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(newstat)(long res, const void *filename, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
+  }
+}
+
+PRE_SYSCALL(newlstat)(const void *filename, void *statbuf) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(newlstat)(long res, const void *filename, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
+  }
+}
+
+PRE_SYSCALL(newfstat)(long fd, void *statbuf) {}
+
+POST_SYSCALL(newfstat)(long res, long fd, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
+  }
+}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(ustat)(long dev, void *ubuf) {}
+
+POST_SYSCALL(ustat)(long res, long dev, void *ubuf) {
+  if (res >= 0) {
+    if (ubuf) POST_WRITE(ubuf, struct_ustat_sz);
+  }
+}
+#endif  // !SANITIZER_ANDROID
+
+PRE_SYSCALL(stat64)(const void *filename, void *statbuf) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(stat64)(long res, const void *filename, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
+  }
+}
+
+PRE_SYSCALL(fstat64)(long fd, void *statbuf) {}
+
+POST_SYSCALL(fstat64)(long res, long fd, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
+  }
+}
+
+PRE_SYSCALL(lstat64)(const void *filename, void *statbuf) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(lstat64)(long res, const void *filename, void *statbuf) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
+  }
+}
+
+PRE_SYSCALL(setxattr)(const void *path, const void *name, const void *value,
+                      long size, long flags) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  if (value) PRE_READ(value, size);
+}
+
+POST_SYSCALL(setxattr)(long res, const void *path, const void *name,
+                       const void *value, long size, long flags) {}
+
+PRE_SYSCALL(lsetxattr)(const void *path, const void *name, const void *value,
+                       long size, long flags) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  if (value) PRE_READ(value, size);
+}
+
+POST_SYSCALL(lsetxattr)(long res, const void *path, const void *name,
+                        const void *value, long size, long flags) {}
+
+PRE_SYSCALL(fsetxattr)(long fd, const void *name, const void *value, long size,
+                       long flags) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  if (value) PRE_READ(value, size);
+}
+
+POST_SYSCALL(fsetxattr)(long res, long fd, const void *name, const void *value,
+                        long size, long flags) {}
+
+PRE_SYSCALL(getxattr)(const void *path, const void *name, void *value,
+                      long size) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(getxattr)(long res, const void *path, const void *name,
+                       void *value, long size) {
+  if (size && res > 0) {
+    if (value) POST_WRITE(value, res);
+  }
+}
+
+PRE_SYSCALL(lgetxattr)(const void *path, const void *name, void *value,
+                       long size) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(lgetxattr)(long res, const void *path, const void *name,
+                        void *value, long size) {
+  if (size && res > 0) {
+    if (value) POST_WRITE(value, res);
+  }
+}
+
+PRE_SYSCALL(fgetxattr)(long fd, const void *name, void *value, long size) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(fgetxattr)(long res, long fd, const void *name, void *value,
+                        long size) {
+  if (size && res > 0) {
+    if (value) POST_WRITE(value, res);
+  }
+}
+
+PRE_SYSCALL(listxattr)(const void *path, void *list, long size) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(listxattr)(long res, const void *path, void *list, long size) {
+  if (size && res > 0) {
+    if (list) POST_WRITE(list, res);
+  }
+}
+
+PRE_SYSCALL(llistxattr)(const void *path, void *list, long size) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(llistxattr)(long res, const void *path, void *list, long size) {
+  if (size && res > 0) {
+    if (list) POST_WRITE(list, res);
+  }
+}
+
+PRE_SYSCALL(flistxattr)(long fd, void *list, long size) {}
+
+POST_SYSCALL(flistxattr)(long res, long fd, void *list, long size) {
+  if (size && res > 0) {
+    if (list) POST_WRITE(list, res);
+  }
+}
+
+PRE_SYSCALL(removexattr)(const void *path, const void *name) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(removexattr)(long res, const void *path, const void *name) {}
+
+PRE_SYSCALL(lremovexattr)(const void *path, const void *name) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(lremovexattr)(long res, const void *path, const void *name) {}
+
+PRE_SYSCALL(fremovexattr)(long fd, const void *name) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(fremovexattr)(long res, long fd, const void *name) {}
+
+PRE_SYSCALL(brk)(long brk) {}
+
+POST_SYSCALL(brk)(long res, long brk) {}
+
+PRE_SYSCALL(mprotect)(long start, long len, long prot) {}
+
+POST_SYSCALL(mprotect)(long res, long start, long len, long prot) {}
+
+PRE_SYSCALL(mremap)(long addr, long old_len, long new_len, long flags,
+                    long new_addr) {}
+
+POST_SYSCALL(mremap)(long res, long addr, long old_len, long new_len,
+                     long flags, long new_addr) {}
+
+PRE_SYSCALL(remap_file_pages)(long start, long size, long prot, long pgoff,
+                              long flags) {}
+
+POST_SYSCALL(remap_file_pages)(long res, long start, long size, long prot,
+                               long pgoff, long flags) {}
+
+PRE_SYSCALL(msync)(long start, long len, long flags) {}
+
+POST_SYSCALL(msync)(long res, long start, long len, long flags) {}
+
+PRE_SYSCALL(munmap)(long addr, long len) {}
+
+POST_SYSCALL(munmap)(long res, long addr, long len) {}
+
+PRE_SYSCALL(mlock)(long start, long len) {}
+
+POST_SYSCALL(mlock)(long res, long start, long len) {}
+
+PRE_SYSCALL(munlock)(long start, long len) {}
+
+POST_SYSCALL(munlock)(long res, long start, long len) {}
+
+PRE_SYSCALL(mlockall)(long flags) {}
+
+POST_SYSCALL(mlockall)(long res, long flags) {}
+
+PRE_SYSCALL(munlockall)() {}
+
+POST_SYSCALL(munlockall)(long res) {}
+
+PRE_SYSCALL(madvise)(long start, long len, long behavior) {}
+
+POST_SYSCALL(madvise)(long res, long start, long len, long behavior) {}
+
+PRE_SYSCALL(mincore)(long start, long len, void *vec) {}
+
+POST_SYSCALL(mincore)(long res, long start, long len, void *vec) {
+  if (res >= 0) {
+    if (vec) {
+      POST_WRITE(vec, (len + GetPageSizeCached() - 1) / GetPageSizeCached());
+    }
+  }
+}
+
+PRE_SYSCALL(pivot_root)(const void *new_root, const void *put_old) {
+  if (new_root)
+    PRE_READ(new_root,
+             __sanitizer::internal_strlen((const char *)new_root) + 1);
+  if (put_old)
+    PRE_READ(put_old, __sanitizer::internal_strlen((const char *)put_old) + 1);
+}
+
+POST_SYSCALL(pivot_root)(long res, const void *new_root, const void *put_old) {}
+
+PRE_SYSCALL(chroot)(const void *filename) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(chroot)(long res, const void *filename) {}
+
+PRE_SYSCALL(mknod)(const void *filename, long mode, long dev) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(mknod)(long res, const void *filename, long mode, long dev) {}
+
+PRE_SYSCALL(link)(const void *oldname, const void *newname) {
+  if (oldname)
+    PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
+  if (newname)
+    PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
+}
+
+POST_SYSCALL(link)(long res, const void *oldname, const void *newname) {}
+
+PRE_SYSCALL(symlink)(const void *old, const void *new_) {
+  if (old) PRE_READ(old, __sanitizer::internal_strlen((const char *)old) + 1);
+  if (new_)
+    PRE_READ(new_, __sanitizer::internal_strlen((const char *)new_) + 1);
+}
+
+POST_SYSCALL(symlink)(long res, const void *old, const void *new_) {}
+
+PRE_SYSCALL(unlink)(const void *pathname) {
+  if (pathname)
+    PRE_READ(pathname,
+             __sanitizer::internal_strlen((const char *)pathname) + 1);
+}
+
+POST_SYSCALL(unlink)(long res, const void *pathname) {}
+
+PRE_SYSCALL(rename)(const void *oldname, const void *newname) {
+  if (oldname)
+    PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
+  if (newname)
+    PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
+}
+
+POST_SYSCALL(rename)(long res, const void *oldname, const void *newname) {}
+
+PRE_SYSCALL(chmod)(const void *filename, long mode) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(chmod)(long res, const void *filename, long mode) {}
+
+PRE_SYSCALL(fchmod)(long fd, long mode) {}
+
+POST_SYSCALL(fchmod)(long res, long fd, long mode) {}
+
+PRE_SYSCALL(fcntl)(long fd, long cmd, long arg) {}
+
+POST_SYSCALL(fcntl)(long res, long fd, long cmd, long arg) {}
+
+PRE_SYSCALL(fcntl64)(long fd, long cmd, long arg) {}
+
+POST_SYSCALL(fcntl64)(long res, long fd, long cmd, long arg) {}
+
+PRE_SYSCALL(pipe)(void *fildes) {}
+
+POST_SYSCALL(pipe)(long res, void *fildes) {
+  if (res >= 0) {
+    if (fildes) POST_WRITE(fildes, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(pipe2)(void *fildes, long flags) {}
+
+POST_SYSCALL(pipe2)(long res, void *fildes, long flags) {
+  if (res >= 0) {
+    if (fildes) POST_WRITE(fildes, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(dup)(long fildes) {}
+
+POST_SYSCALL(dup)(long res, long fildes) {}
+
+PRE_SYSCALL(dup2)(long oldfd, long newfd) {}
+
+POST_SYSCALL(dup2)(long res, long oldfd, long newfd) {}
+
+PRE_SYSCALL(dup3)(long oldfd, long newfd, long flags) {}
+
+POST_SYSCALL(dup3)(long res, long oldfd, long newfd, long flags) {}
+
+PRE_SYSCALL(ioperm)(long from, long num, long on) {}
+
+POST_SYSCALL(ioperm)(long res, long from, long num, long on) {}
+
+PRE_SYSCALL(ioctl)(long fd, long cmd, long arg) {}
+
+POST_SYSCALL(ioctl)(long res, long fd, long cmd, long arg) {}
+
+PRE_SYSCALL(flock)(long fd, long cmd) {}
+
+POST_SYSCALL(flock)(long res, long fd, long cmd) {}
+
+PRE_SYSCALL(io_setup)(long nr_reqs, void **ctx) {
+  if (ctx) PRE_WRITE(ctx, sizeof(*ctx));
+}
+
+POST_SYSCALL(io_setup)(long res, long nr_reqs, void **ctx) {
+  if (res >= 0) {
+    if (ctx) POST_WRITE(ctx, sizeof(*ctx));
+    // (*ctx) is actually a pointer to a kernel mapped page, and there are
+    // people out there who are crazy enough to peek into that page's 32-byte
+    // header.
+    if (*ctx) POST_WRITE(*ctx, 32);
+  }
+}
+
+PRE_SYSCALL(io_destroy)(long ctx) {}
+
+POST_SYSCALL(io_destroy)(long res, long ctx) {}
+
+PRE_SYSCALL(io_getevents)(long ctx_id, long min_nr, long nr,
+                          __sanitizer_io_event *ioevpp, void *timeout) {
+  if (timeout) PRE_READ(timeout, struct_timespec_sz);
+}
+
+POST_SYSCALL(io_getevents)(long res, long ctx_id, long min_nr, long nr,
+                           __sanitizer_io_event *ioevpp, void *timeout) {
+  if (res >= 0) {
+    if (ioevpp) POST_WRITE(ioevpp, res * sizeof(*ioevpp));
+    if (timeout) POST_WRITE(timeout, struct_timespec_sz);
+  }
+  for (long i = 0; i < res; i++) {
+    // We synchronize io_submit -> io_getevents/io_cancel using the
+    // user-provided data context. Data is not necessary a pointer, it can be
+    // an int, 0 or whatever; acquire/release will correctly handle this.
+    // This scheme can lead to false negatives, e.g. when all operations
+    // synchronize on 0. But there does not seem to be a better solution
+    // (except wrapping all operations in own context, which is unreliable).
+    // We can not reliably extract fildes in io_getevents.
+    COMMON_SYSCALL_ACQUIRE((void*)ioevpp[i].data);
+  }
+}
+
+PRE_SYSCALL(io_submit)(long ctx_id, long nr, __sanitizer_iocb **iocbpp) {
+  for (long i = 0; i < nr; ++i) {
+    uptr op = iocbpp[i]->aio_lio_opcode;
+    void *data = (void*)iocbpp[i]->aio_data;
+    void *buf = (void*)iocbpp[i]->aio_buf;
+    uptr len = (uptr)iocbpp[i]->aio_nbytes;
+    if (op == iocb_cmd_pwrite && buf && len) {
+      PRE_READ(buf, len);
+    } else if (op == iocb_cmd_pread && buf && len) {
+      POST_WRITE(buf, len);
+    } else if (op == iocb_cmd_pwritev) {
+      __sanitizer_iovec *iovec = (__sanitizer_iovec*)buf;
+      for (uptr v = 0; v < len; v++)
+        PRE_READ(iovec[v].iov_base, iovec[v].iov_len);
+    } else if (op == iocb_cmd_preadv) {
+      __sanitizer_iovec *iovec = (__sanitizer_iovec*)buf;
+      for (uptr v = 0; v < len; v++)
+        POST_WRITE(iovec[v].iov_base, iovec[v].iov_len);
+    }
+    // See comment in io_getevents.
+    COMMON_SYSCALL_RELEASE(data);
+  }
+}
+
+POST_SYSCALL(io_submit)(long res, long ctx_id, long nr,
+    __sanitizer_iocb **iocbpp) {}
+
+PRE_SYSCALL(io_cancel)(long ctx_id, __sanitizer_iocb *iocb,
+    __sanitizer_io_event *result) {
+}
+
+POST_SYSCALL(io_cancel)(long res, long ctx_id, __sanitizer_iocb *iocb,
+    __sanitizer_io_event *result) {
+  if (res == 0) {
+    if (result) {
+      // See comment in io_getevents.
+      COMMON_SYSCALL_ACQUIRE((void*)result->data);
+      POST_WRITE(result, sizeof(*result));
+    }
+    if (iocb)
+      POST_WRITE(iocb, sizeof(*iocb));
+  }
+}
+
+PRE_SYSCALL(sendfile)(long out_fd, long in_fd, void *offset, long count) {}
+
+POST_SYSCALL(sendfile)(long res, long out_fd, long in_fd,
+                       __sanitizer___kernel_off_t *offset, long count) {
+  if (res >= 0) {
+    if (offset) POST_WRITE(offset, sizeof(*offset));
+  }
+}
+
+PRE_SYSCALL(sendfile64)(long out_fd, long in_fd, void *offset, long count) {}
+
+POST_SYSCALL(sendfile64)(long res, long out_fd, long in_fd,
+                         __sanitizer___kernel_loff_t *offset, long count) {
+  if (res >= 0) {
+    if (offset) POST_WRITE(offset, sizeof(*offset));
+  }
+}
+
+PRE_SYSCALL(readlink)(const void *path, void *buf, long bufsiz) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(readlink)(long res, const void *path, void *buf, long bufsiz) {
+  if (res >= 0) {
+    if (buf)
+      POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
+  }
+}
+
+PRE_SYSCALL(creat)(const void *pathname, long mode) {
+  if (pathname)
+    PRE_READ(pathname,
+             __sanitizer::internal_strlen((const char *)pathname) + 1);
+}
+
+POST_SYSCALL(creat)(long res, const void *pathname, long mode) {}
+
+PRE_SYSCALL(open)(const void *filename, long flags, long mode) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(open)(long res, const void *filename, long flags, long mode) {}
+
+PRE_SYSCALL(close)(long fd) {
+  COMMON_SYSCALL_FD_CLOSE((int)fd);
+}
+
+POST_SYSCALL(close)(long res, long fd) {}
+
+PRE_SYSCALL(access)(const void *filename, long mode) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(access)(long res, const void *filename, long mode) {}
+
+PRE_SYSCALL(vhangup)() {}
+
+POST_SYSCALL(vhangup)(long res) {}
+
+PRE_SYSCALL(chown)(const void *filename, long user, long group) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(chown)(long res, const void *filename, long user, long group) {}
+
+PRE_SYSCALL(lchown)(const void *filename, long user, long group) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(lchown)(long res, const void *filename, long user, long group) {}
+
+PRE_SYSCALL(fchown)(long fd, long user, long group) {}
+
+POST_SYSCALL(fchown)(long res, long fd, long user, long group) {}
+
+#if SANITIZER_USES_UID16_SYSCALLS
+PRE_SYSCALL(chown16)(const void *filename, long user, long group) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(chown16)(long res, const void *filename, long user, long group) {}
+
+PRE_SYSCALL(lchown16)(const void *filename, long user, long group) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(lchown16)(long res, const void *filename, long user, long group) {}
+
+PRE_SYSCALL(fchown16)(long fd, long user, long group) {}
+
+POST_SYSCALL(fchown16)(long res, long fd, long user, long group) {}
+
+PRE_SYSCALL(setregid16)(long rgid, long egid) {}
+
+POST_SYSCALL(setregid16)(long res, long rgid, long egid) {}
+
+PRE_SYSCALL(setgid16)(long gid) {}
+
+POST_SYSCALL(setgid16)(long res, long gid) {}
+
+PRE_SYSCALL(setreuid16)(long ruid, long euid) {}
+
+POST_SYSCALL(setreuid16)(long res, long ruid, long euid) {}
+
+PRE_SYSCALL(setuid16)(long uid) {}
+
+POST_SYSCALL(setuid16)(long res, long uid) {}
+
+PRE_SYSCALL(setresuid16)(long ruid, long euid, long suid) {}
+
+POST_SYSCALL(setresuid16)(long res, long ruid, long euid, long suid) {}
+
+PRE_SYSCALL(getresuid16)(void *ruid, void *euid, void *suid) {}
+
+POST_SYSCALL(getresuid16)(long res, __sanitizer___kernel_old_uid_t *ruid,
+                          __sanitizer___kernel_old_uid_t *euid,
+                          __sanitizer___kernel_old_uid_t *suid) {
+  if (res >= 0) {
+    if (ruid) POST_WRITE(ruid, sizeof(*ruid));
+    if (euid) POST_WRITE(euid, sizeof(*euid));
+    if (suid) POST_WRITE(suid, sizeof(*suid));
+  }
+}
+
+PRE_SYSCALL(setresgid16)(long rgid, long egid, long sgid) {}
+
+POST_SYSCALL(setresgid16)(long res, long rgid, long egid, long sgid) {}
+
+PRE_SYSCALL(getresgid16)(void *rgid, void *egid, void *sgid) {}
+
+POST_SYSCALL(getresgid16)(long res, __sanitizer___kernel_old_gid_t *rgid,
+                          __sanitizer___kernel_old_gid_t *egid,
+                          __sanitizer___kernel_old_gid_t *sgid) {
+  if (res >= 0) {
+    if (rgid) POST_WRITE(rgid, sizeof(*rgid));
+    if (egid) POST_WRITE(egid, sizeof(*egid));
+    if (sgid) POST_WRITE(sgid, sizeof(*sgid));
+  }
+}
+
+PRE_SYSCALL(setfsuid16)(long uid) {}
+
+POST_SYSCALL(setfsuid16)(long res, long uid) {}
+
+PRE_SYSCALL(setfsgid16)(long gid) {}
+
+POST_SYSCALL(setfsgid16)(long res, long gid) {}
+
+PRE_SYSCALL(getgroups16)(long gidsetsize,
+                         __sanitizer___kernel_old_gid_t *grouplist) {}
+
+POST_SYSCALL(getgroups16)(long res, long gidsetsize,
+                          __sanitizer___kernel_old_gid_t *grouplist) {
+  if (res >= 0) {
+    if (grouplist) POST_WRITE(grouplist, res * sizeof(*grouplist));
+  }
+}
+
+PRE_SYSCALL(setgroups16)(long gidsetsize,
+                         __sanitizer___kernel_old_gid_t *grouplist) {
+  if (grouplist) POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist));
+}
+
+POST_SYSCALL(setgroups16)(long res, long gidsetsize,
+                          __sanitizer___kernel_old_gid_t *grouplist) {}
+
+PRE_SYSCALL(getuid16)() {}
+
+POST_SYSCALL(getuid16)(long res) {}
+
+PRE_SYSCALL(geteuid16)() {}
+
+POST_SYSCALL(geteuid16)(long res) {}
+
+PRE_SYSCALL(getgid16)() {}
+
+POST_SYSCALL(getgid16)(long res) {}
+
+PRE_SYSCALL(getegid16)() {}
+
+POST_SYSCALL(getegid16)(long res) {}
+#endif // SANITIZER_USES_UID16_SYSCALLS
+
+PRE_SYSCALL(utime)(void *filename, void *times) {}
+
+POST_SYSCALL(utime)(long res, void *filename, void *times) {
+  if (res >= 0) {
+    if (filename)
+      POST_WRITE(filename,
+                 __sanitizer::internal_strlen((const char *)filename) + 1);
+    if (times) POST_WRITE(times, struct_utimbuf_sz);
+  }
+}
+
+PRE_SYSCALL(utimes)(void *filename, void *utimes) {}
+
+POST_SYSCALL(utimes)(long res, void *filename, void *utimes) {
+  if (res >= 0) {
+    if (filename)
+      POST_WRITE(filename,
+                 __sanitizer::internal_strlen((const char *)filename) + 1);
+    if (utimes) POST_WRITE(utimes, timeval_sz);
+  }
+}
+
+PRE_SYSCALL(lseek)(long fd, long offset, long origin) {}
+
+POST_SYSCALL(lseek)(long res, long fd, long offset, long origin) {}
+
+PRE_SYSCALL(llseek)(long fd, long offset_high, long offset_low, void *result,
+                    long origin) {}
+
+POST_SYSCALL(llseek)(long res, long fd, long offset_high, long offset_low,
+                     void *result, long origin) {
+  if (res >= 0) {
+    if (result) POST_WRITE(result, sizeof(long long));
+  }
+}
+
+PRE_SYSCALL(readv)(long fd, const __sanitizer_iovec *vec, long vlen) {}
+
+POST_SYSCALL(readv)(long res, long fd, const __sanitizer_iovec *vec,
+                    long vlen) {
+  if (res >= 0) {
+    if (vec) kernel_write_iovec(vec, vlen, res);
+  }
+}
+
+PRE_SYSCALL(write)(long fd, const void *buf, long count) {
+  if (buf) PRE_READ(buf, count);
+}
+
+POST_SYSCALL(write)(long res, long fd, const void *buf, long count) {}
+
+PRE_SYSCALL(writev)(long fd, const __sanitizer_iovec *vec, long vlen) {}
+
+POST_SYSCALL(writev)(long res, long fd, const __sanitizer_iovec *vec,
+                     long vlen) {
+  if (res >= 0) {
+    if (vec) kernel_read_iovec(vec, vlen, res);
+  }
+}
+
+#ifdef _LP64
+PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos) {}
+
+POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, res);
+  }
+}
+
+PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos) {
+  if (buf) PRE_READ(buf, count);
+}
+
+POST_SYSCALL(pwrite64)(long res, long fd, const void *buf, long count,
+                       long pos) {}
+#else
+PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos0, long pos1) {}
+
+POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos0,
+                      long pos1) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, res);
+  }
+}
+
+PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos0,
+                      long pos1) {
+  if (buf) PRE_READ(buf, count);
+}
+
+POST_SYSCALL(pwrite64)(long res, long fd, const void *buf, long count,
+                       long pos0, long pos1) {}
+#endif
+
+PRE_SYSCALL(preadv)(long fd, const __sanitizer_iovec *vec, long vlen,
+                    long pos_l, long pos_h) {}
+
+POST_SYSCALL(preadv)(long res, long fd, const __sanitizer_iovec *vec, long vlen,
+                     long pos_l, long pos_h) {
+  if (res >= 0) {
+    if (vec) kernel_write_iovec(vec, vlen, res);
+  }
+}
+
+PRE_SYSCALL(pwritev)(long fd, const __sanitizer_iovec *vec, long vlen,
+                     long pos_l, long pos_h) {}
+
+POST_SYSCALL(pwritev)(long res, long fd, const __sanitizer_iovec *vec,
+                      long vlen, long pos_l, long pos_h) {
+  if (res >= 0) {
+    if (vec) kernel_read_iovec(vec, vlen, res);
+  }
+}
+
+PRE_SYSCALL(getcwd)(void *buf, long size) {}
+
+POST_SYSCALL(getcwd)(long res, void *buf, long size) {
+  if (res >= 0) {
+    if (buf)
+      POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
+  }
+}
+
+PRE_SYSCALL(mkdir)(const void *pathname, long mode) {
+  if (pathname)
+    PRE_READ(pathname,
+             __sanitizer::internal_strlen((const char *)pathname) + 1);
+}
+
+POST_SYSCALL(mkdir)(long res, const void *pathname, long mode) {}
+
+PRE_SYSCALL(chdir)(const void *filename) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(chdir)(long res, const void *filename) {}
+
+PRE_SYSCALL(fchdir)(long fd) {}
+
+POST_SYSCALL(fchdir)(long res, long fd) {}
+
+PRE_SYSCALL(rmdir)(const void *pathname) {
+  if (pathname)
+    PRE_READ(pathname,
+             __sanitizer::internal_strlen((const char *)pathname) + 1);
+}
+
+POST_SYSCALL(rmdir)(long res, const void *pathname) {}
+
+PRE_SYSCALL(lookup_dcookie)(u64 cookie64, void *buf, long len) {}
+
+POST_SYSCALL(lookup_dcookie)(long res, u64 cookie64, void *buf, long len) {
+  if (res >= 0) {
+    if (buf)
+      POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
+  }
+}
+
+PRE_SYSCALL(quotactl)(long cmd, const void *special, long id, void *addr) {
+  if (special)
+    PRE_READ(special, __sanitizer::internal_strlen((const char *)special) + 1);
+}
+
+POST_SYSCALL(quotactl)(long res, long cmd, const void *special, long id,
+                       void *addr) {}
+
+PRE_SYSCALL(getdents)(long fd, void *dirent, long count) {}
+
+POST_SYSCALL(getdents)(long res, long fd, void *dirent, long count) {
+  if (res >= 0) {
+    if (dirent) POST_WRITE(dirent, res);
+  }
+}
+
+PRE_SYSCALL(getdents64)(long fd, void *dirent, long count) {}
+
+POST_SYSCALL(getdents64)(long res, long fd, void *dirent, long count) {
+  if (res >= 0) {
+    if (dirent) POST_WRITE(dirent, res);
+  }
+}
+
+PRE_SYSCALL(setsockopt)(long fd, long level, long optname, void *optval,
+                        long optlen) {}
+
+POST_SYSCALL(setsockopt)(long res, long fd, long level, long optname,
+                         void *optval, long optlen) {
+  if (res >= 0) {
+    if (optval)
+      POST_WRITE(optval,
+                 __sanitizer::internal_strlen((const char *)optval) + 1);
+  }
+}
+
+PRE_SYSCALL(getsockopt)(long fd, long level, long optname, void *optval,
+                        void *optlen) {}
+
+POST_SYSCALL(getsockopt)(long res, long fd, long level, long optname,
+                         void *optval, void *optlen) {
+  if (res >= 0) {
+    if (optval)
+      POST_WRITE(optval,
+                 __sanitizer::internal_strlen((const char *)optval) + 1);
+    if (optlen) POST_WRITE(optlen, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(bind)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {}
+
+POST_SYSCALL(bind)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
+                   long arg2) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+  }
+}
+
+PRE_SYSCALL(connect)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {}
+
+POST_SYSCALL(connect)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
+                      long arg2) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+  }
+}
+
+PRE_SYSCALL(accept)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) {}
+
+POST_SYSCALL(accept)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
+                     void *arg2) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+    if (arg2) POST_WRITE(arg2, sizeof(unsigned));
+  }
+}
+
+PRE_SYSCALL(accept4)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2,
+                     long arg3) {}
+
+POST_SYSCALL(accept4)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
+                      void *arg2, long arg3) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+    if (arg2) POST_WRITE(arg2, sizeof(unsigned));
+  }
+}
+
+PRE_SYSCALL(getsockname)(long arg0, sanitizer_kernel_sockaddr *arg1,
+                         void *arg2) {}
+
+POST_SYSCALL(getsockname)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
+                          void *arg2) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+    if (arg2) POST_WRITE(arg2, sizeof(unsigned));
+  }
+}
+
+PRE_SYSCALL(getpeername)(long arg0, sanitizer_kernel_sockaddr *arg1,
+                         void *arg2) {}
+
+POST_SYSCALL(getpeername)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
+                          void *arg2) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+    if (arg2) POST_WRITE(arg2, sizeof(unsigned));
+  }
+}
+
+PRE_SYSCALL(send)(long arg0, void *arg1, long arg2, long arg3) {}
+
+POST_SYSCALL(send)(long res, long arg0, void *arg1, long arg2, long arg3) {
+  if (res) {
+    if (arg1) POST_READ(arg1, res);
+  }
+}
+
+PRE_SYSCALL(sendto)(long arg0, void *arg1, long arg2, long arg3,
+                    sanitizer_kernel_sockaddr *arg4, long arg5) {}
+
+POST_SYSCALL(sendto)(long res, long arg0, void *arg1, long arg2, long arg3,
+                     sanitizer_kernel_sockaddr *arg4, long arg5) {
+  if (res >= 0) {
+    if (arg1) POST_READ(arg1, res);
+    if (arg4) POST_WRITE(arg4, sizeof(*arg4));
+  }
+}
+
+PRE_SYSCALL(sendmsg)(long fd, void *msg, long flags) {}
+
+POST_SYSCALL(sendmsg)(long res, long fd, void *msg, long flags) {
+  // FIXME: POST_READ
+}
+
+PRE_SYSCALL(sendmmsg)(long fd, void *msg, long vlen, long flags) {}
+
+POST_SYSCALL(sendmmsg)(long res, long fd, void *msg, long vlen, long flags) {
+  // FIXME: POST_READ
+}
+
+PRE_SYSCALL(recv)(long arg0, void *buf, long len, long flags) {}
+
+POST_SYSCALL(recv)(long res, void *buf, long len, long flags) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, res);
+  }
+}
+
+PRE_SYSCALL(recvfrom)(long arg0, void *buf, long len, long flags,
+                      sanitizer_kernel_sockaddr *arg4, void *arg5) {}
+
+POST_SYSCALL(recvfrom)(long res, long arg0, void *buf, long len, long flags,
+                       sanitizer_kernel_sockaddr *arg4, void *arg5) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, res);
+    if (arg4) POST_WRITE(arg4, sizeof(*arg4));
+    if (arg5) POST_WRITE(arg5, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(socket)(long arg0, long arg1, long arg2) {}
+
+POST_SYSCALL(socket)(long res, long arg0, long arg1, long arg2) {}
+
+PRE_SYSCALL(socketpair)(long arg0, long arg1, long arg2, void *arg3) {}
+
+POST_SYSCALL(socketpair)(long res, long arg0, long arg1, long arg2,
+                         void *arg3) {
+  if (res >= 0) {
+    if (arg3) POST_WRITE(arg3, sizeof(int));
+  }
+}
+
+PRE_SYSCALL(socketcall)(long call, void *args) {}
+
+POST_SYSCALL(socketcall)(long res, long call, void *args) {
+  if (res >= 0) {
+    if (args) POST_WRITE(args, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(listen)(long arg0, long arg1) {}
+
+POST_SYSCALL(listen)(long res, long arg0, long arg1) {}
+
+PRE_SYSCALL(poll)(void *ufds, long nfds, long timeout) {}
+
+POST_SYSCALL(poll)(long res, __sanitizer_pollfd *ufds, long nfds,
+                   long timeout) {
+  if (res >= 0) {
+    if (ufds) POST_WRITE(ufds, nfds * sizeof(*ufds));
+  }
+}
+
+PRE_SYSCALL(select)(long n, __sanitizer___kernel_fd_set *inp,
+                    __sanitizer___kernel_fd_set *outp,
+                    __sanitizer___kernel_fd_set *exp, void *tvp) {}
+
+POST_SYSCALL(select)(long res, long n, __sanitizer___kernel_fd_set *inp,
+                     __sanitizer___kernel_fd_set *outp,
+                     __sanitizer___kernel_fd_set *exp, void *tvp) {
+  if (res >= 0) {
+    if (inp) POST_WRITE(inp, sizeof(*inp));
+    if (outp) POST_WRITE(outp, sizeof(*outp));
+    if (exp) POST_WRITE(exp, sizeof(*exp));
+    if (tvp) POST_WRITE(tvp, timeval_sz);
+  }
+}
+
+PRE_SYSCALL(old_select)(void *arg) {}
+
+POST_SYSCALL(old_select)(long res, void *arg) {}
+
+PRE_SYSCALL(epoll_create)(long size) {}
+
+POST_SYSCALL(epoll_create)(long res, long size) {}
+
+PRE_SYSCALL(epoll_create1)(long flags) {}
+
+POST_SYSCALL(epoll_create1)(long res, long flags) {}
+
+PRE_SYSCALL(epoll_ctl)(long epfd, long op, long fd, void *event) {}
+
+POST_SYSCALL(epoll_ctl)(long res, long epfd, long op, long fd, void *event) {
+  if (res >= 0) {
+    if (event) POST_WRITE(event, struct_epoll_event_sz);
+  }
+}
+
+PRE_SYSCALL(epoll_wait)(long epfd, void *events, long maxevents, long timeout) {
+}
+
+POST_SYSCALL(epoll_wait)(long res, long epfd, void *events, long maxevents,
+                         long timeout) {
+  if (res >= 0) {
+    if (events) POST_WRITE(events, struct_epoll_event_sz);
+  }
+}
+
+PRE_SYSCALL(epoll_pwait)(long epfd, void *events, long maxevents, long timeout,
+                         const kernel_sigset_t *sigmask, long sigsetsize) {
+  if (sigmask) PRE_READ(sigmask, sigsetsize);
+}
+
+POST_SYSCALL(epoll_pwait)(long res, long epfd, void *events, long maxevents,
+                          long timeout, const void *sigmask, long sigsetsize) {
+  if (res >= 0) {
+    if (events) POST_WRITE(events, struct_epoll_event_sz);
+  }
+}
+
+PRE_SYSCALL(gethostname)(void *name, long len) {}
+
+POST_SYSCALL(gethostname)(long res, void *name, long len) {
+  if (res >= 0) {
+    if (name)
+      POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  }
+}
+
+PRE_SYSCALL(sethostname)(void *name, long len) {}
+
+POST_SYSCALL(sethostname)(long res, void *name, long len) {
+  if (res >= 0) {
+    if (name)
+      POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  }
+}
+
+PRE_SYSCALL(setdomainname)(void *name, long len) {}
+
+POST_SYSCALL(setdomainname)(long res, void *name, long len) {
+  if (res >= 0) {
+    if (name)
+      POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
+  }
+}
+
+PRE_SYSCALL(newuname)(void *name) {}
+
+POST_SYSCALL(newuname)(long res, void *name) {
+  if (res >= 0) {
+    if (name) POST_WRITE(name, struct_new_utsname_sz);
+  }
+}
+
+PRE_SYSCALL(uname)(void *arg0) {}
+
+POST_SYSCALL(uname)(long res, void *arg0) {
+  if (res >= 0) {
+    if (arg0) POST_WRITE(arg0, struct_old_utsname_sz);
+  }
+}
+
+PRE_SYSCALL(olduname)(void *arg0) {}
+
+POST_SYSCALL(olduname)(long res, void *arg0) {
+  if (res >= 0) {
+    if (arg0) POST_WRITE(arg0, struct_oldold_utsname_sz);
+  }
+}
+
+PRE_SYSCALL(getrlimit)(long resource, void *rlim) {}
+
+POST_SYSCALL(getrlimit)(long res, long resource, void *rlim) {
+  if (res >= 0) {
+    if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
+  }
+}
+
+PRE_SYSCALL(old_getrlimit)(long resource, void *rlim) {}
+
+POST_SYSCALL(old_getrlimit)(long res, long resource, void *rlim) {
+  if (res >= 0) {
+    if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
+  }
+}
+
+PRE_SYSCALL(setrlimit)(long resource, void *rlim) {}
+
+POST_SYSCALL(setrlimit)(long res, long resource, void *rlim) {
+  if (res >= 0) {
+    if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
+  }
+}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(prlimit64)(long pid, long resource, const void *new_rlim,
+                       void *old_rlim) {
+  if (new_rlim) PRE_READ(new_rlim, struct_rlimit64_sz);
+}
+
+POST_SYSCALL(prlimit64)(long res, long pid, long resource, const void *new_rlim,
+                        void *old_rlim) {
+  if (res >= 0) {
+    if (old_rlim) POST_WRITE(old_rlim, struct_rlimit64_sz);
+  }
+}
+#endif
+
+PRE_SYSCALL(getrusage)(long who, void *ru) {}
+
+POST_SYSCALL(getrusage)(long res, long who, void *ru) {
+  if (res >= 0) {
+    if (ru) POST_WRITE(ru, struct_rusage_sz);
+  }
+}
+
+PRE_SYSCALL(umask)(long mask) {}
+
+POST_SYSCALL(umask)(long res, long mask) {}
+
+PRE_SYSCALL(msgget)(long key, long msgflg) {}
+
+POST_SYSCALL(msgget)(long res, long key, long msgflg) {}
+
+PRE_SYSCALL(msgsnd)(long msqid, void *msgp, long msgsz, long msgflg) {
+  if (msgp) PRE_READ(msgp, msgsz);
+}
+
+POST_SYSCALL(msgsnd)(long res, long msqid, void *msgp, long msgsz,
+                     long msgflg) {}
+
+PRE_SYSCALL(msgrcv)(long msqid, void *msgp, long msgsz, long msgtyp,
+                    long msgflg) {}
+
+POST_SYSCALL(msgrcv)(long res, long msqid, void *msgp, long msgsz, long msgtyp,
+                     long msgflg) {
+  if (res >= 0) {
+    if (msgp) POST_WRITE(msgp, res);
+  }
+}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(msgctl)(long msqid, long cmd, void *buf) {}
+
+POST_SYSCALL(msgctl)(long res, long msqid, long cmd, void *buf) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, struct_msqid_ds_sz);
+  }
+}
+#endif
+
+PRE_SYSCALL(semget)(long key, long nsems, long semflg) {}
+
+POST_SYSCALL(semget)(long res, long key, long nsems, long semflg) {}
+
+PRE_SYSCALL(semop)(long semid, void *sops, long nsops) {}
+
+POST_SYSCALL(semop)(long res, long semid, void *sops, long nsops) {}
+
+PRE_SYSCALL(semctl)(long semid, long semnum, long cmd, void *arg) {}
+
+POST_SYSCALL(semctl)(long res, long semid, long semnum, long cmd, void *arg) {}
+
+PRE_SYSCALL(semtimedop)(long semid, void *sops, long nsops,
+                        const void *timeout) {
+  if (timeout) PRE_READ(timeout, struct_timespec_sz);
+}
+
+POST_SYSCALL(semtimedop)(long res, long semid, void *sops, long nsops,
+                         const void *timeout) {}
+
+PRE_SYSCALL(shmat)(long shmid, void *shmaddr, long shmflg) {}
+
+POST_SYSCALL(shmat)(long res, long shmid, void *shmaddr, long shmflg) {
+  if (res >= 0) {
+    if (shmaddr)
+      POST_WRITE(shmaddr,
+                 __sanitizer::internal_strlen((const char *)shmaddr) + 1);
+  }
+}
+
+PRE_SYSCALL(shmget)(long key, long size, long flag) {}
+
+POST_SYSCALL(shmget)(long res, long key, long size, long flag) {}
+
+PRE_SYSCALL(shmdt)(void *shmaddr) {}
+
+POST_SYSCALL(shmdt)(long res, void *shmaddr) {
+  if (res >= 0) {
+    if (shmaddr)
+      POST_WRITE(shmaddr,
+                 __sanitizer::internal_strlen((const char *)shmaddr) + 1);
+  }
+}
+
+PRE_SYSCALL(ipc)(long call, long first, long second, long third, void *ptr,
+                 long fifth) {}
+
+POST_SYSCALL(ipc)(long res, long call, long first, long second, long third,
+                  void *ptr, long fifth) {}
+
+#if !SANITIZER_ANDROID
+PRE_SYSCALL(shmctl)(long shmid, long cmd, void *buf) {}
+
+POST_SYSCALL(shmctl)(long res, long shmid, long cmd, void *buf) {
+  if (res >= 0) {
+    if (buf) POST_WRITE(buf, sizeof(__sanitizer_shmid_ds));
+  }
+}
+
+PRE_SYSCALL(mq_open)(const void *name, long oflag, long mode, void *attr) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(mq_open)(long res, const void *name, long oflag, long mode,
+                      void *attr) {
+  if (res >= 0) {
+    if (attr) POST_WRITE(attr, struct_mq_attr_sz);
+  }
+}
+
+PRE_SYSCALL(mq_unlink)(const void *name) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(mq_unlink)(long res, const void *name) {}
+
+PRE_SYSCALL(mq_timedsend)(long mqdes, const void *msg_ptr, long msg_len,
+                          long msg_prio, const void *abs_timeout) {
+  if (msg_ptr) PRE_READ(msg_ptr, msg_len);
+  if (abs_timeout) PRE_READ(abs_timeout, struct_timespec_sz);
+}
+
+POST_SYSCALL(mq_timedsend)(long res, long mqdes, const void *msg_ptr,
+                           long msg_len, long msg_prio,
+                           const void *abs_timeout) {}
+
+PRE_SYSCALL(mq_timedreceive)(long mqdes, void *msg_ptr, long msg_len,
+                             void *msg_prio, const void *abs_timeout) {
+  if (abs_timeout) PRE_READ(abs_timeout, struct_timespec_sz);
+}
+
+POST_SYSCALL(mq_timedreceive)(long res, long mqdes, void *msg_ptr, long msg_len,
+                              int *msg_prio, const void *abs_timeout) {
+  if (res >= 0) {
+    if (msg_ptr) POST_WRITE(msg_ptr, res);
+    if (msg_prio) POST_WRITE(msg_prio, sizeof(*msg_prio));
+  }
+}
+
+PRE_SYSCALL(mq_notify)(long mqdes, const void *notification) {
+  if (notification) PRE_READ(notification, struct_sigevent_sz);
+}
+
+POST_SYSCALL(mq_notify)(long res, long mqdes, const void *notification) {}
+
+PRE_SYSCALL(mq_getsetattr)(long mqdes, const void *mqstat, void *omqstat) {
+  if (mqstat) PRE_READ(mqstat, struct_mq_attr_sz);
+}
+
+POST_SYSCALL(mq_getsetattr)(long res, long mqdes, const void *mqstat,
+                            void *omqstat) {
+  if (res >= 0) {
+    if (omqstat) POST_WRITE(omqstat, struct_mq_attr_sz);
+  }
+}
+#endif  // SANITIZER_ANDROID
+
+PRE_SYSCALL(pciconfig_iobase)(long which, long bus, long devfn) {}
+
+POST_SYSCALL(pciconfig_iobase)(long res, long which, long bus, long devfn) {}
+
+PRE_SYSCALL(pciconfig_read)(long bus, long dfn, long off, long len, void *buf) {
+}
+
+POST_SYSCALL(pciconfig_read)(long res, long bus, long dfn, long off, long len,
+                             void *buf) {}
+
+PRE_SYSCALL(pciconfig_write)(long bus, long dfn, long off, long len,
+                             void *buf) {}
+
+POST_SYSCALL(pciconfig_write)(long res, long bus, long dfn, long off, long len,
+                              void *buf) {}
+
+PRE_SYSCALL(swapon)(const void *specialfile, long swap_flags) {
+  if (specialfile)
+    PRE_READ(specialfile,
+             __sanitizer::internal_strlen((const char *)specialfile) + 1);
+}
+
+POST_SYSCALL(swapon)(long res, const void *specialfile, long swap_flags) {}
+
+PRE_SYSCALL(swapoff)(const void *specialfile) {
+  if (specialfile)
+    PRE_READ(specialfile,
+             __sanitizer::internal_strlen((const char *)specialfile) + 1);
+}
+
+POST_SYSCALL(swapoff)(long res, const void *specialfile) {}
+
+PRE_SYSCALL(sysctl)(__sanitizer___sysctl_args *args) {
+  if (args) {
+    if (args->name) PRE_READ(args->name, args->nlen * sizeof(*args->name));
+    if (args->newval) PRE_READ(args->name, args->newlen);
+  }
+}
+
+POST_SYSCALL(sysctl)(long res, __sanitizer___sysctl_args *args) {
+  if (res >= 0) {
+    if (args && args->oldval && args->oldlenp) {
+      POST_WRITE(args->oldlenp, sizeof(*args->oldlenp));
+      POST_WRITE(args->oldval, *args->oldlenp);
+    }
+  }
+}
+
+PRE_SYSCALL(sysinfo)(void *info) {}
+
+POST_SYSCALL(sysinfo)(long res, void *info) {
+  if (res >= 0) {
+    if (info) POST_WRITE(info, struct_sysinfo_sz);
+  }
+}
+
+PRE_SYSCALL(sysfs)(long option, long arg1, long arg2) {}
+
+POST_SYSCALL(sysfs)(long res, long option, long arg1, long arg2) {}
+
+PRE_SYSCALL(syslog)(long type, void *buf, long len) {}
+
+POST_SYSCALL(syslog)(long res, long type, void *buf, long len) {
+  if (res >= 0) {
+    if (buf)
+      POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
+  }
+}
+
+PRE_SYSCALL(uselib)(const void *library) {
+  if (library)
+    PRE_READ(library, __sanitizer::internal_strlen((const char *)library) + 1);
+}
+
+POST_SYSCALL(uselib)(long res, const void *library) {}
+
+PRE_SYSCALL(ni_syscall)() {}
+
+POST_SYSCALL(ni_syscall)(long res) {}
+
+PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) {
+#if !SANITIZER_ANDROID && \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
+     defined(__powerpc64__) || defined(__aarch64__))
+  if (data) {
+    if (request == ptrace_setregs) {
+      PRE_READ((void *)data, struct_user_regs_struct_sz);
+    } else if (request == ptrace_setfpregs) {
+      PRE_READ((void *)data, struct_user_fpregs_struct_sz);
+    } else if (request == ptrace_setfpxregs) {
+      PRE_READ((void *)data, struct_user_fpxregs_struct_sz);
+    } else if (request == ptrace_setsiginfo) {
+      PRE_READ((void *)data, siginfo_t_sz);
+    } else if (request == ptrace_setregset) {
+      __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
+      PRE_READ(iov->iov_base, iov->iov_len);
+    }
+  }
+#endif
+}
+
+POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) {
+#if !SANITIZER_ANDROID && \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
+     defined(__powerpc64__) || defined(__aarch64__))
+  if (res >= 0 && data) {
+    // Note that this is different from the interceptor in
+    // sanitizer_common_interceptors.inc.
+    // PEEK* requests return resulting values through data pointer.
+    if (request == ptrace_getregs) {
+      POST_WRITE((void *)data, struct_user_regs_struct_sz);
+    } else if (request == ptrace_getfpregs) {
+      POST_WRITE((void *)data, struct_user_fpregs_struct_sz);
+    } else if (request == ptrace_getfpxregs) {
+      POST_WRITE((void *)data, struct_user_fpxregs_struct_sz);
+    } else if (request == ptrace_getsiginfo) {
+      POST_WRITE((void *)data, siginfo_t_sz);
+    } else if (request == ptrace_getregset) {
+      __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
+      POST_WRITE(iov->iov_base, iov->iov_len);
+    } else if (request == ptrace_peekdata || request == ptrace_peektext ||
+               request == ptrace_peekuser) {
+      POST_WRITE((void *)data, sizeof(void *));
+    }
+  }
+#endif
+}
+
+PRE_SYSCALL(add_key)(const void *_type, const void *_description,
+                     const void *_payload, long plen, long destringid) {
+  if (_type)
+    PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1);
+  if (_description)
+    PRE_READ(_description,
+             __sanitizer::internal_strlen((const char *)_description) + 1);
+}
+
+POST_SYSCALL(add_key)(long res, const void *_type, const void *_description,
+                      const void *_payload, long plen, long destringid) {}
+
+PRE_SYSCALL(request_key)(const void *_type, const void *_description,
+                         const void *_callout_info, long destringid) {
+  if (_type)
+    PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1);
+  if (_description)
+    PRE_READ(_description,
+             __sanitizer::internal_strlen((const char *)_description) + 1);
+  if (_callout_info)
+    PRE_READ(_callout_info,
+             __sanitizer::internal_strlen((const char *)_callout_info) + 1);
+}
+
+POST_SYSCALL(request_key)(long res, const void *_type, const void *_description,
+                          const void *_callout_info, long destringid) {}
+
+PRE_SYSCALL(keyctl)(long cmd, long arg2, long arg3, long arg4, long arg5) {}
+
+POST_SYSCALL(keyctl)(long res, long cmd, long arg2, long arg3, long arg4,
+                     long arg5) {}
+
+PRE_SYSCALL(ioprio_set)(long which, long who, long ioprio) {}
+
+POST_SYSCALL(ioprio_set)(long res, long which, long who, long ioprio) {}
+
+PRE_SYSCALL(ioprio_get)(long which, long who) {}
+
+POST_SYSCALL(ioprio_get)(long res, long which, long who) {}
+
+PRE_SYSCALL(set_mempolicy)(long mode, void *nmask, long maxnode) {}
+
+POST_SYSCALL(set_mempolicy)(long res, long mode, void *nmask, long maxnode) {
+  if (res >= 0) {
+    if (nmask) POST_WRITE(nmask, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(migrate_pages)(long pid, long maxnode, const void *from,
+                           const void *to) {
+  if (from) PRE_READ(from, sizeof(long));
+  if (to) PRE_READ(to, sizeof(long));
+}
+
+POST_SYSCALL(migrate_pages)(long res, long pid, long maxnode, const void *from,
+                            const void *to) {}
+
+PRE_SYSCALL(move_pages)(long pid, long nr_pages, const void **pages,
+                        const int *nodes, int *status, long flags) {
+  if (pages) PRE_READ(pages, nr_pages * sizeof(*pages));
+  if (nodes) PRE_READ(nodes, nr_pages * sizeof(*nodes));
+}
+
+POST_SYSCALL(move_pages)(long res, long pid, long nr_pages, const void **pages,
+                         const int *nodes, int *status, long flags) {
+  if (res >= 0) {
+    if (status) POST_WRITE(status, nr_pages * sizeof(*status));
+  }
+}
+
+PRE_SYSCALL(mbind)(long start, long len, long mode, void *nmask, long maxnode,
+                   long flags) {}
+
+POST_SYSCALL(mbind)(long res, long start, long len, long mode, void *nmask,
+                    long maxnode, long flags) {
+  if (res >= 0) {
+    if (nmask) POST_WRITE(nmask, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(get_mempolicy)(void *policy, void *nmask, long maxnode, long addr,
+                           long flags) {}
+
+POST_SYSCALL(get_mempolicy)(long res, void *policy, void *nmask, long maxnode,
+                            long addr, long flags) {
+  if (res >= 0) {
+    if (policy) POST_WRITE(policy, sizeof(int));
+    if (nmask) POST_WRITE(nmask, sizeof(long));
+  }
+}
+
+PRE_SYSCALL(inotify_init)() {}
+
+POST_SYSCALL(inotify_init)(long res) {}
+
+PRE_SYSCALL(inotify_init1)(long flags) {}
+
+POST_SYSCALL(inotify_init1)(long res, long flags) {}
+
+PRE_SYSCALL(inotify_add_watch)(long fd, const void *path, long mask) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(inotify_add_watch)(long res, long fd, const void *path,
+                                long mask) {}
+
+PRE_SYSCALL(inotify_rm_watch)(long fd, long wd) {}
+
+POST_SYSCALL(inotify_rm_watch)(long res, long fd, long wd) {}
+
+PRE_SYSCALL(spu_run)(long fd, void *unpc, void *ustatus) {}
+
+POST_SYSCALL(spu_run)(long res, long fd, unsigned *unpc, unsigned *ustatus) {
+  if (res >= 0) {
+    if (unpc) POST_WRITE(unpc, sizeof(*unpc));
+    if (ustatus) POST_WRITE(ustatus, sizeof(*ustatus));
+  }
+}
+
+PRE_SYSCALL(spu_create)(const void *name, long flags, long mode, long fd) {
+  if (name)
+    PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
+}
+
+POST_SYSCALL(spu_create)(long res, const void *name, long flags, long mode,
+                         long fd) {}
+
+PRE_SYSCALL(mknodat)(long dfd, const void *filename, long mode, long dev) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(mknodat)(long res, long dfd, const void *filename, long mode,
+                      long dev) {}
+
+PRE_SYSCALL(mkdirat)(long dfd, const void *pathname, long mode) {
+  if (pathname)
+    PRE_READ(pathname,
+             __sanitizer::internal_strlen((const char *)pathname) + 1);
+}
+
+POST_SYSCALL(mkdirat)(long res, long dfd, const void *pathname, long mode) {}
+
+PRE_SYSCALL(unlinkat)(long dfd, const void *pathname, long flag) {
+  if (pathname)
+    PRE_READ(pathname,
+             __sanitizer::internal_strlen((const char *)pathname) + 1);
+}
+
+POST_SYSCALL(unlinkat)(long res, long dfd, const void *pathname, long flag) {}
+
+PRE_SYSCALL(symlinkat)(const void *oldname, long newdfd, const void *newname) {
+  if (oldname)
+    PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
+  if (newname)
+    PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
+}
+
+POST_SYSCALL(symlinkat)(long res, const void *oldname, long newdfd,
+                        const void *newname) {}
+
+PRE_SYSCALL(linkat)(long olddfd, const void *oldname, long newdfd,
+                    const void *newname, long flags) {
+  if (oldname)
+    PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
+  if (newname)
+    PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
+}
+
+POST_SYSCALL(linkat)(long res, long olddfd, const void *oldname, long newdfd,
+                     const void *newname, long flags) {}
+
+PRE_SYSCALL(renameat)(long olddfd, const void *oldname, long newdfd,
+                      const void *newname) {
+  if (oldname)
+    PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
+  if (newname)
+    PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
+}
+
+POST_SYSCALL(renameat)(long res, long olddfd, const void *oldname, long newdfd,
+                       const void *newname) {}
+
+PRE_SYSCALL(futimesat)(long dfd, const void *filename, void *utimes) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(futimesat)(long res, long dfd, const void *filename,
+                        void *utimes) {
+  if (res >= 0) {
+    if (utimes) POST_WRITE(utimes, timeval_sz);
+  }
+}
+
+PRE_SYSCALL(faccessat)(long dfd, const void *filename, long mode) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(faccessat)(long res, long dfd, const void *filename, long mode) {}
+
+PRE_SYSCALL(fchmodat)(long dfd, const void *filename, long mode) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(fchmodat)(long res, long dfd, const void *filename, long mode) {}
+
+PRE_SYSCALL(fchownat)(long dfd, const void *filename, long user, long group,
+                      long flag) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(fchownat)(long res, long dfd, const void *filename, long user,
+                       long group, long flag) {}
+
+PRE_SYSCALL(openat)(long dfd, const void *filename, long flags, long mode) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(openat)(long res, long dfd, const void *filename, long flags,
+                     long mode) {}
+
+PRE_SYSCALL(newfstatat)(long dfd, const void *filename, void *statbuf,
+                        long flag) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(newfstatat)(long res, long dfd, const void *filename,
+                         void *statbuf, long flag) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
+  }
+}
+
+PRE_SYSCALL(fstatat64)(long dfd, const void *filename, void *statbuf,
+                       long flag) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(fstatat64)(long res, long dfd, const void *filename, void *statbuf,
+                        long flag) {
+  if (res >= 0) {
+    if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
+  }
+}
+
+PRE_SYSCALL(readlinkat)(long dfd, const void *path, void *buf, long bufsiz) {
+  if (path)
+    PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
+}
+
+POST_SYSCALL(readlinkat)(long res, long dfd, const void *path, void *buf,
+                         long bufsiz) {
+  if (res >= 0) {
+    if (buf)
+      POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
+  }
+}
+
+PRE_SYSCALL(utimensat)(long dfd, const void *filename, void *utimes,
+                       long flags) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(utimensat)(long res, long dfd, const void *filename, void *utimes,
+                        long flags) {
+  if (res >= 0) {
+    if (utimes) POST_WRITE(utimes, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(unshare)(long unshare_flags) {}
+
+POST_SYSCALL(unshare)(long res, long unshare_flags) {}
+
+PRE_SYSCALL(splice)(long fd_in, void *off_in, long fd_out, void *off_out,
+                    long len, long flags) {}
+
+POST_SYSCALL(splice)(long res, long fd_in, void *off_in, long fd_out,
+                     void *off_out, long len, long flags) {
+  if (res >= 0) {
+    if (off_in) POST_WRITE(off_in, sizeof(long long));
+    if (off_out) POST_WRITE(off_out, sizeof(long long));
+  }
+}
+
+PRE_SYSCALL(vmsplice)(long fd, const __sanitizer_iovec *iov, long nr_segs,
+                      long flags) {}
+
+POST_SYSCALL(vmsplice)(long res, long fd, const __sanitizer_iovec *iov,
+                       long nr_segs, long flags) {
+  if (res >= 0) {
+    if (iov) kernel_read_iovec(iov, nr_segs, res);
+  }
+}
+
+PRE_SYSCALL(tee)(long fdin, long fdout, long len, long flags) {}
+
+POST_SYSCALL(tee)(long res, long fdin, long fdout, long len, long flags) {}
+
+PRE_SYSCALL(get_robust_list)(long pid, void *head_ptr, void *len_ptr) {}
+
+POST_SYSCALL(get_robust_list)(long res, long pid, void *head_ptr,
+                              void *len_ptr) {}
+
+PRE_SYSCALL(set_robust_list)(void *head, long len) {}
+
+POST_SYSCALL(set_robust_list)(long res, void *head, long len) {}
+
+PRE_SYSCALL(getcpu)(void *cpu, void *node, void *cache) {}
+
+POST_SYSCALL(getcpu)(long res, void *cpu, void *node, void *cache) {
+  if (res >= 0) {
+    if (cpu) POST_WRITE(cpu, sizeof(unsigned));
+    if (node) POST_WRITE(node, sizeof(unsigned));
+    // The third argument to this system call is nowadays unused.
+  }
+}
+
+PRE_SYSCALL(signalfd)(long ufd, void *user_mask, long sizemask) {}
+
+POST_SYSCALL(signalfd)(long res, long ufd, kernel_sigset_t *user_mask,
+                       long sizemask) {
+  if (res >= 0) {
+    if (user_mask) POST_WRITE(user_mask, sizemask);
+  }
+}
+
+PRE_SYSCALL(signalfd4)(long ufd, void *user_mask, long sizemask, long flags) {}
+
+POST_SYSCALL(signalfd4)(long res, long ufd, kernel_sigset_t *user_mask,
+                        long sizemask, long flags) {
+  if (res >= 0) {
+    if (user_mask) POST_WRITE(user_mask, sizemask);
+  }
+}
+
+PRE_SYSCALL(timerfd_create)(long clockid, long flags) {}
+
+POST_SYSCALL(timerfd_create)(long res, long clockid, long flags) {}
+
+PRE_SYSCALL(timerfd_settime)(long ufd, long flags, const void *utmr,
+                             void *otmr) {
+  if (utmr) PRE_READ(utmr, struct_itimerspec_sz);
+}
+
+POST_SYSCALL(timerfd_settime)(long res, long ufd, long flags, const void *utmr,
+                              void *otmr) {
+  if (res >= 0) {
+    if (otmr) POST_WRITE(otmr, struct_itimerspec_sz);
+  }
+}
+
+PRE_SYSCALL(timerfd_gettime)(long ufd, void *otmr) {}
+
+POST_SYSCALL(timerfd_gettime)(long res, long ufd, void *otmr) {
+  if (res >= 0) {
+    if (otmr) POST_WRITE(otmr, struct_itimerspec_sz);
+  }
+}
+
+PRE_SYSCALL(eventfd)(long count) {}
+
+POST_SYSCALL(eventfd)(long res, long count) {}
+
+PRE_SYSCALL(eventfd2)(long count, long flags) {}
+
+POST_SYSCALL(eventfd2)(long res, long count, long flags) {}
+
+PRE_SYSCALL(old_readdir)(long arg0, void *arg1, long arg2) {}
+
+POST_SYSCALL(old_readdir)(long res, long arg0, void *arg1, long arg2) {
+  // Missing definition of 'struct old_linux_dirent'.
+}
+
+PRE_SYSCALL(pselect6)(long arg0, __sanitizer___kernel_fd_set *arg1,
+                      __sanitizer___kernel_fd_set *arg2,
+                      __sanitizer___kernel_fd_set *arg3, void *arg4,
+                      void *arg5) {}
+
+POST_SYSCALL(pselect6)(long res, long arg0, __sanitizer___kernel_fd_set *arg1,
+                       __sanitizer___kernel_fd_set *arg2,
+                       __sanitizer___kernel_fd_set *arg3, void *arg4,
+                       void *arg5) {
+  if (res >= 0) {
+    if (arg1) POST_WRITE(arg1, sizeof(*arg1));
+    if (arg2) POST_WRITE(arg2, sizeof(*arg2));
+    if (arg3) POST_WRITE(arg3, sizeof(*arg3));
+    if (arg4) POST_WRITE(arg4, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(ppoll)(__sanitizer_pollfd *arg0, long arg1, void *arg2,
+                   const kernel_sigset_t *arg3, long arg4) {
+  if (arg3) PRE_READ(arg3, arg4);
+}
+
+POST_SYSCALL(ppoll)(long res, __sanitizer_pollfd *arg0, long arg1, void *arg2,
+                    const void *arg3, long arg4) {
+  if (res >= 0) {
+    if (arg0) POST_WRITE(arg0, sizeof(*arg0));
+    if (arg2) POST_WRITE(arg2, struct_timespec_sz);
+  }
+}
+
+PRE_SYSCALL(syncfs)(long fd) {}
+
+POST_SYSCALL(syncfs)(long res, long fd) {}
+
+PRE_SYSCALL(perf_event_open)(__sanitizer_perf_event_attr *attr_uptr, long pid,
+                             long cpu, long group_fd, long flags) {
+  if (attr_uptr) PRE_READ(attr_uptr, attr_uptr->size);
+}
+
+POST_SYSCALL(perf_event_open)(long res, __sanitizer_perf_event_attr *attr_uptr,
+                              long pid, long cpu, long group_fd, long flags) {}
+
+PRE_SYSCALL(mmap_pgoff)(long addr, long len, long prot, long flags, long fd,
+                        long pgoff) {}
+
+POST_SYSCALL(mmap_pgoff)(long res, long addr, long len, long prot, long flags,
+                         long fd, long pgoff) {}
+
+PRE_SYSCALL(old_mmap)(void *arg) {}
+
+POST_SYSCALL(old_mmap)(long res, void *arg) {}
+
+PRE_SYSCALL(name_to_handle_at)(long dfd, const void *name, void *handle,
+                               void *mnt_id, long flag) {}
+
+POST_SYSCALL(name_to_handle_at)(long res, long dfd, const void *name,
+                                void *handle, void *mnt_id, long flag) {}
+
+PRE_SYSCALL(open_by_handle_at)(long mountdirfd, void *handle, long flags) {}
+
+POST_SYSCALL(open_by_handle_at)(long res, long mountdirfd, void *handle,
+                                long flags) {}
+
+PRE_SYSCALL(setns)(long fd, long nstype) {}
+
+POST_SYSCALL(setns)(long res, long fd, long nstype) {}
+
+PRE_SYSCALL(process_vm_readv)(long pid, const __sanitizer_iovec *lvec,
+                              long liovcnt, const void *rvec, long riovcnt,
+                              long flags) {}
+
+POST_SYSCALL(process_vm_readv)(long res, long pid,
+                               const __sanitizer_iovec *lvec, long liovcnt,
+                               const void *rvec, long riovcnt, long flags) {
+  if (res >= 0) {
+    if (lvec) kernel_write_iovec(lvec, liovcnt, res);
+  }
+}
+
+PRE_SYSCALL(process_vm_writev)(long pid, const __sanitizer_iovec *lvec,
+                               long liovcnt, const void *rvec, long riovcnt,
+                               long flags) {}
+
+POST_SYSCALL(process_vm_writev)(long res, long pid,
+                                const __sanitizer_iovec *lvec, long liovcnt,
+                                const void *rvec, long riovcnt, long flags) {
+  if (res >= 0) {
+    if (lvec) kernel_read_iovec(lvec, liovcnt, res);
+  }
+}
+
+PRE_SYSCALL(fork)() {
+  COMMON_SYSCALL_PRE_FORK();
+}
+
+POST_SYSCALL(fork)(long res) {
+  COMMON_SYSCALL_POST_FORK(res);
+}
+
+PRE_SYSCALL(vfork)() {
+  COMMON_SYSCALL_PRE_FORK();
+}
+
+POST_SYSCALL(vfork)(long res) {
+  COMMON_SYSCALL_POST_FORK(res);
+}
+}  // extern "C"
+
+#undef PRE_SYSCALL
+#undef PRE_READ
+#undef PRE_WRITE
+#undef POST_SYSCALL
+#undef POST_READ
+#undef POST_WRITE
+
+#endif  // SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep.cc
new file mode 100644
index 0000000..b9833c5
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep.cc
@@ -0,0 +1,960 @@
+//===-- sanitizer_coverage.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage.
+// This file implements run-time support for a poor man's coverage tool.
+//
+// Compiler instrumentation:
+// For every interesting basic block the compiler injects the following code:
+// if (Guard < 0) {
+//    __sanitizer_cov(&Guard);
+// }
+// At the module start up time __sanitizer_cov_module_init sets the guards
+// to consecutive negative numbers (-1, -2, -3, ...).
+// It's fine to call __sanitizer_cov more than once for a given block.
+//
+// Run-time:
+//  - __sanitizer_cov(): record that we've executed the PC (GET_CALLER_PC).
+//    and atomically set Guard to -Guard.
+//  - __sanitizer_cov_dump: dump the coverage data to disk.
+//  For every module of the current process that has coverage data
+//  this will create a file module_name.PID.sancov.
+//
+// The file format is simple: the first 8 bytes is the magic,
+// one of 0xC0BFFFFFFFFFFF64 and 0xC0BFFFFFFFFFFF32. The last byte of the
+// magic defines the size of the following offsets.
+// The rest of the data is the offsets in the module.
+//
+// Eventually, this coverage implementation should be obsoleted by a more
+// powerful general purpose Clang/LLVM coverage instrumentation.
+// Consider this implementation as prototype.
+//
+// FIXME: support (or at least test with) dlclose.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_procmaps.h"
+#include "sanitizer_stacktrace.h"
+#include "sanitizer_symbolizer.h"
+#include "sanitizer_flags.h"
+
+static const u64 kMagic64 = 0xC0BFFFFFFFFFFF64ULL;
+static const u64 kMagic32 = 0xC0BFFFFFFFFFFF32ULL;
+
+static atomic_uint32_t dump_once_guard;  // Ensure that CovDump runs only once.
+
+static atomic_uintptr_t coverage_counter;
+static atomic_uintptr_t caller_callee_counter;
+
+static void ResetGlobalCounters() {
+  return atomic_store(&coverage_counter, 0, memory_order_relaxed);
+  return atomic_store(&caller_callee_counter, 0, memory_order_relaxed);
+}
+
+// pc_array is the array containing the covered PCs.
+// To make the pc_array thread- and async-signal-safe it has to be large enough.
+// 128M counters "ought to be enough for anybody" (4M on 32-bit).
+
+// With coverage_direct=1 in ASAN_OPTIONS, pc_array memory is mapped to a file.
+// In this mode, __sanitizer_cov_dump does nothing, and CovUpdateMapping()
+// dump current memory layout to another file.
+
+static bool cov_sandboxed = false;
+static fd_t cov_fd = kInvalidFd;
+static unsigned int cov_max_block_size = 0;
+static bool coverage_enabled = false;
+static const char *coverage_dir;
+
+namespace __sanitizer {
+
+class CoverageData {
+ public:
+  void Init();
+  void Enable();
+  void Disable();
+  void ReInit();
+  void BeforeFork();
+  void AfterFork(int child_pid);
+  void Extend(uptr npcs);
+  void Add(uptr pc, u32 *guard);
+  void IndirCall(uptr caller, uptr callee, uptr callee_cache[],
+                 uptr cache_size);
+  void DumpCallerCalleePairs();
+  void DumpTrace();
+  void DumpAsBitSet();
+  void DumpCounters();
+  void DumpOffsets();
+  void DumpAll();
+
+  ALWAYS_INLINE
+  void TraceBasicBlock(u32 *id);
+
+  void InitializeGuardArray(s32 *guards);
+  void InitializeGuards(s32 *guards, uptr n, const char *module_name,
+                        uptr caller_pc);
+  void InitializeCounters(u8 *counters, uptr n);
+  void ReinitializeGuards();
+  uptr GetNumberOf8bitCounters();
+  uptr Update8bitCounterBitsetAndClearCounters(u8 *bitset);
+
+  uptr *data();
+  uptr size();
+
+ private:
+  void DirectOpen();
+  void UpdateModuleNameVec(uptr caller_pc, uptr range_beg, uptr range_end);
+
+  // Maximal size pc array may ever grow.
+  // We MmapNoReserve this space to ensure that the array is contiguous.
+  static const uptr kPcArrayMaxSize = FIRST_32_SECOND_64(
+      1 << (SANITIZER_ANDROID ? 24 : (SANITIZER_WINDOWS ? 27 : 26)),
+      1 << 27);
+  // The amount file mapping for the pc array is grown by.
+  static const uptr kPcArrayMmapSize = 64 * 1024;
+
+  // pc_array is allocated with MmapNoReserveOrDie and so it uses only as
+  // much RAM as it really needs.
+  uptr *pc_array;
+  // Index of the first available pc_array slot.
+  atomic_uintptr_t pc_array_index;
+  // Array size.
+  atomic_uintptr_t pc_array_size;
+  // Current file mapped size of the pc array.
+  uptr pc_array_mapped_size;
+  // Descriptor of the file mapped pc array.
+  fd_t pc_fd;
+
+  // Vector of coverage guard arrays, protected by mu.
+  InternalMmapVectorNoCtor<s32*> guard_array_vec;
+
+  struct NamedPcRange {
+    const char *copied_module_name;
+    uptr beg, end; // elements [beg,end) in pc_array.
+  };
+
+  // Vector of module and compilation unit pc ranges.
+  InternalMmapVectorNoCtor<NamedPcRange> comp_unit_name_vec;
+  InternalMmapVectorNoCtor<NamedPcRange> module_name_vec;
+
+  struct CounterAndSize {
+    u8 *counters;
+    uptr n;
+  };
+
+  InternalMmapVectorNoCtor<CounterAndSize> counters_vec;
+  uptr num_8bit_counters;
+
+  // Caller-Callee (cc) array, size and current index.
+  static const uptr kCcArrayMaxSize = FIRST_32_SECOND_64(1 << 18, 1 << 24);
+  uptr **cc_array;
+  atomic_uintptr_t cc_array_index;
+  atomic_uintptr_t cc_array_size;
+
+  // Tracing event array, size and current pointer.
+  // We record all events (basic block entries) in a global buffer of u32
+  // values. Each such value is the index in pc_array.
+  // So far the tracing is highly experimental:
+  //   - not thread-safe;
+  //   - does not support long traces;
+  //   - not tuned for performance.
+  static const uptr kTrEventArrayMaxSize = FIRST_32_SECOND_64(1 << 22, 1 << 30);
+  u32 *tr_event_array;
+  uptr tr_event_array_size;
+  u32 *tr_event_pointer;
+  static const uptr kTrPcArrayMaxSize    = FIRST_32_SECOND_64(1 << 22, 1 << 27);
+
+  StaticSpinMutex mu;
+};
+
+static CoverageData coverage_data;
+
+void CovUpdateMapping(const char *path, uptr caller_pc = 0);
+
+void CoverageData::DirectOpen() {
+  InternalScopedString path(kMaxPathLength);
+  internal_snprintf((char *)path.data(), path.size(), "%s/%zd.sancov.raw",
+                    coverage_dir, internal_getpid());
+  pc_fd = OpenFile(path.data(), RdWr);
+  if (pc_fd == kInvalidFd) {
+    Report("Coverage: failed to open %s for reading/writing\n", path.data());
+    Die();
+  }
+
+  pc_array_mapped_size = 0;
+  CovUpdateMapping(coverage_dir);
+}
+
+void CoverageData::Init() {
+  pc_fd = kInvalidFd;
+}
+
+void CoverageData::Enable() {
+  if (pc_array)
+    return;
+  pc_array = reinterpret_cast<uptr *>(
+      MmapNoReserveOrDie(sizeof(uptr) * kPcArrayMaxSize, "CovInit"));
+  atomic_store(&pc_array_index, 0, memory_order_relaxed);
+  if (common_flags()->coverage_direct) {
+    atomic_store(&pc_array_size, 0, memory_order_relaxed);
+  } else {
+    atomic_store(&pc_array_size, kPcArrayMaxSize, memory_order_relaxed);
+  }
+
+  cc_array = reinterpret_cast<uptr **>(MmapNoReserveOrDie(
+      sizeof(uptr *) * kCcArrayMaxSize, "CovInit::cc_array"));
+  atomic_store(&cc_array_size, kCcArrayMaxSize, memory_order_relaxed);
+  atomic_store(&cc_array_index, 0, memory_order_relaxed);
+
+  // Allocate tr_event_array with a guard page at the end.
+  tr_event_array = reinterpret_cast<u32 *>(MmapNoReserveOrDie(
+      sizeof(tr_event_array[0]) * kTrEventArrayMaxSize + GetMmapGranularity(),
+      "CovInit::tr_event_array"));
+  MprotectNoAccess(
+      reinterpret_cast<uptr>(&tr_event_array[kTrEventArrayMaxSize]),
+      GetMmapGranularity());
+  tr_event_array_size = kTrEventArrayMaxSize;
+  tr_event_pointer = tr_event_array;
+
+  num_8bit_counters = 0;
+}
+
+void CoverageData::InitializeGuardArray(s32 *guards) {
+  Enable();  // Make sure coverage is enabled at this point.
+  s32 n = guards[0];
+  for (s32 j = 1; j <= n; j++) {
+    uptr idx = atomic_load_relaxed(&pc_array_index);
+    atomic_store_relaxed(&pc_array_index, idx + 1);
+    guards[j] = -static_cast<s32>(idx + 1);
+  }
+}
+
+void CoverageData::Disable() {
+  if (pc_array) {
+    UnmapOrDie(pc_array, sizeof(uptr) * kPcArrayMaxSize);
+    pc_array = nullptr;
+  }
+  if (cc_array) {
+    UnmapOrDie(cc_array, sizeof(uptr *) * kCcArrayMaxSize);
+    cc_array = nullptr;
+  }
+  if (tr_event_array) {
+    UnmapOrDie(tr_event_array,
+               sizeof(tr_event_array[0]) * kTrEventArrayMaxSize +
+                   GetMmapGranularity());
+    tr_event_array = nullptr;
+    tr_event_pointer = nullptr;
+  }
+  if (pc_fd != kInvalidFd) {
+    CloseFile(pc_fd);
+    pc_fd = kInvalidFd;
+  }
+}
+
+void CoverageData::ReinitializeGuards() {
+  // Assuming single thread.
+  atomic_store(&pc_array_index, 0, memory_order_relaxed);
+  for (uptr i = 0; i < guard_array_vec.size(); i++)
+    InitializeGuardArray(guard_array_vec[i]);
+}
+
+void CoverageData::ReInit() {
+  Disable();
+  if (coverage_enabled) {
+    if (common_flags()->coverage_direct) {
+      // In memory-mapped mode we must extend the new file to the known array
+      // size.
+      uptr size = atomic_load(&pc_array_size, memory_order_relaxed);
+      uptr npcs = size / sizeof(uptr);
+      Enable();
+      if (size) Extend(npcs);
+      if (coverage_enabled) CovUpdateMapping(coverage_dir);
+    } else {
+      Enable();
+    }
+  }
+  // Re-initialize the guards.
+  // We are single-threaded now, no need to grab any lock.
+  CHECK_EQ(atomic_load(&pc_array_index, memory_order_relaxed), 0);
+  ReinitializeGuards();
+}
+
+void CoverageData::BeforeFork() {
+  mu.Lock();
+}
+
+void CoverageData::AfterFork(int child_pid) {
+  // We are single-threaded so it's OK to release the lock early.
+  mu.Unlock();
+  if (child_pid == 0) ReInit();
+}
+
+// Extend coverage PC array to fit additional npcs elements.
+void CoverageData::Extend(uptr npcs) {
+  if (!common_flags()->coverage_direct) return;
+  SpinMutexLock l(&mu);
+
+  uptr size = atomic_load(&pc_array_size, memory_order_relaxed);
+  size += npcs * sizeof(uptr);
+
+  if (coverage_enabled && size > pc_array_mapped_size) {
+    if (pc_fd == kInvalidFd) DirectOpen();
+    CHECK_NE(pc_fd, kInvalidFd);
+
+    uptr new_mapped_size = pc_array_mapped_size;
+    while (size > new_mapped_size) new_mapped_size += kPcArrayMmapSize;
+    CHECK_LE(new_mapped_size, sizeof(uptr) * kPcArrayMaxSize);
+
+    // Extend the file and map the new space at the end of pc_array.
+    uptr res = internal_ftruncate(pc_fd, new_mapped_size);
+    int err;
+    if (internal_iserror(res, &err)) {
+      Printf("failed to extend raw coverage file: %d\n", err);
+      Die();
+    }
+
+    uptr next_map_base = ((uptr)pc_array) + pc_array_mapped_size;
+    void *p = MapWritableFileToMemory((void *)next_map_base,
+                                      new_mapped_size - pc_array_mapped_size,
+                                      pc_fd, pc_array_mapped_size);
+    CHECK_EQ((uptr)p, next_map_base);
+    pc_array_mapped_size = new_mapped_size;
+  }
+
+  atomic_store(&pc_array_size, size, memory_order_release);
+}
+
+void CoverageData::InitializeCounters(u8 *counters, uptr n) {
+  if (!counters) return;
+  CHECK_EQ(reinterpret_cast<uptr>(counters) % 16, 0);
+  n = RoundUpTo(n, 16); // The compiler must ensure that counters is 16-aligned.
+  SpinMutexLock l(&mu);
+  counters_vec.push_back({counters, n});
+  num_8bit_counters += n;
+}
+
+void CoverageData::UpdateModuleNameVec(uptr caller_pc, uptr range_beg,
+                                       uptr range_end) {
+  auto sym = Symbolizer::GetOrInit();
+  if (!sym)
+    return;
+  const char *module_name = sym->GetModuleNameForPc(caller_pc);
+  if (!module_name) return;
+  if (module_name_vec.empty() ||
+      module_name_vec.back().copied_module_name != module_name)
+    module_name_vec.push_back({module_name, range_beg, range_end});
+  else
+    module_name_vec.back().end = range_end;
+}
+
+void CoverageData::InitializeGuards(s32 *guards, uptr n,
+                                    const char *comp_unit_name,
+                                    uptr caller_pc) {
+  // The array 'guards' has n+1 elements, we use the element zero
+  // to store 'n'.
+  CHECK_LT(n, 1 << 30);
+  guards[0] = static_cast<s32>(n);
+  InitializeGuardArray(guards);
+  SpinMutexLock l(&mu);
+  uptr range_end = atomic_load(&pc_array_index, memory_order_relaxed);
+  uptr range_beg = range_end - n;
+  comp_unit_name_vec.push_back({comp_unit_name, range_beg, range_end});
+  guard_array_vec.push_back(guards);
+  UpdateModuleNameVec(caller_pc, range_beg, range_end);
+}
+
+static const uptr kBundleCounterBits = 16;
+
+// When coverage_order_pcs==true and SANITIZER_WORDSIZE==64
+// we insert the global counter into the first 16 bits of the PC.
+uptr BundlePcAndCounter(uptr pc, uptr counter) {
+  if (SANITIZER_WORDSIZE != 64 || !common_flags()->coverage_order_pcs)
+    return pc;
+  static const uptr kMaxCounter = (1 << kBundleCounterBits) - 1;
+  if (counter > kMaxCounter)
+    counter = kMaxCounter;
+  CHECK_EQ(0, pc >> (SANITIZER_WORDSIZE - kBundleCounterBits));
+  return pc | (counter << (SANITIZER_WORDSIZE - kBundleCounterBits));
+}
+
+uptr UnbundlePc(uptr bundle) {
+  if (SANITIZER_WORDSIZE != 64 || !common_flags()->coverage_order_pcs)
+    return bundle;
+  return (bundle << kBundleCounterBits) >> kBundleCounterBits;
+}
+
+uptr UnbundleCounter(uptr bundle) {
+  if (SANITIZER_WORDSIZE != 64 || !common_flags()->coverage_order_pcs)
+    return 0;
+  return bundle >> (SANITIZER_WORDSIZE - kBundleCounterBits);
+}
+
+// If guard is negative, atomically set it to -guard and store the PC in
+// pc_array.
+void CoverageData::Add(uptr pc, u32 *guard) {
+  atomic_uint32_t *atomic_guard = reinterpret_cast<atomic_uint32_t*>(guard);
+  s32 guard_value = atomic_load(atomic_guard, memory_order_relaxed);
+  if (guard_value >= 0) return;
+
+  atomic_store(atomic_guard, -guard_value, memory_order_relaxed);
+  if (!pc_array) return;
+
+  uptr idx = -guard_value - 1;
+  if (idx >= atomic_load(&pc_array_index, memory_order_acquire))
+    return;  // May happen after fork when pc_array_index becomes 0.
+  CHECK_LT(idx * sizeof(uptr),
+           atomic_load(&pc_array_size, memory_order_acquire));
+  uptr counter = atomic_fetch_add(&coverage_counter, 1, memory_order_relaxed);
+  pc_array[idx] = BundlePcAndCounter(pc, counter);
+}
+
+// Registers a pair caller=>callee.
+// When a given caller is seen for the first time, the callee_cache is added
+// to the global array cc_array, callee_cache[0] is set to caller and
+// callee_cache[1] is set to cache_size.
+// Then we are trying to add callee to callee_cache [2,cache_size) if it is
+// not there yet.
+// If the cache is full we drop the callee (may want to fix this later).
+void CoverageData::IndirCall(uptr caller, uptr callee, uptr callee_cache[],
+                             uptr cache_size) {
+  if (!cc_array) return;
+  atomic_uintptr_t *atomic_callee_cache =
+      reinterpret_cast<atomic_uintptr_t *>(callee_cache);
+  uptr zero = 0;
+  if (atomic_compare_exchange_strong(&atomic_callee_cache[0], &zero, caller,
+                                     memory_order_seq_cst)) {
+    uptr idx = atomic_fetch_add(&cc_array_index, 1, memory_order_relaxed);
+    CHECK_LT(idx * sizeof(uptr),
+             atomic_load(&cc_array_size, memory_order_acquire));
+    callee_cache[1] = cache_size;
+    cc_array[idx] = callee_cache;
+  }
+  CHECK_EQ(atomic_load(&atomic_callee_cache[0], memory_order_relaxed), caller);
+  for (uptr i = 2; i < cache_size; i++) {
+    uptr was = 0;
+    if (atomic_compare_exchange_strong(&atomic_callee_cache[i], &was, callee,
+                                       memory_order_seq_cst)) {
+      atomic_fetch_add(&caller_callee_counter, 1, memory_order_relaxed);
+      return;
+    }
+    if (was == callee)  // Already have this callee.
+      return;
+  }
+}
+
+uptr CoverageData::GetNumberOf8bitCounters() {
+  return num_8bit_counters;
+}
+
+// Map every 8bit counter to a 8-bit bitset and clear the counter.
+uptr CoverageData::Update8bitCounterBitsetAndClearCounters(u8 *bitset) {
+  uptr num_new_bits = 0;
+  uptr cur = 0;
+  // For better speed we map 8 counters to 8 bytes of bitset at once.
+  static const uptr kBatchSize = 8;
+  CHECK_EQ(reinterpret_cast<uptr>(bitset) % kBatchSize, 0);
+  for (uptr i = 0, len = counters_vec.size(); i < len; i++) {
+    u8 *c = counters_vec[i].counters;
+    uptr n = counters_vec[i].n;
+    CHECK_EQ(n % 16, 0);
+    CHECK_EQ(cur % kBatchSize, 0);
+    CHECK_EQ(reinterpret_cast<uptr>(c) % kBatchSize, 0);
+    if (!bitset) {
+      internal_bzero_aligned16(c, n);
+      cur += n;
+      continue;
+    }
+    for (uptr j = 0; j < n; j += kBatchSize, cur += kBatchSize) {
+      CHECK_LT(cur, num_8bit_counters);
+      u64 *pc64 = reinterpret_cast<u64*>(c + j);
+      u64 *pb64 = reinterpret_cast<u64*>(bitset + cur);
+      u64 c64 = *pc64;
+      u64 old_bits_64 = *pb64;
+      u64 new_bits_64 = old_bits_64;
+      if (c64) {
+        *pc64 = 0;
+        for (uptr k = 0; k < kBatchSize; k++) {
+          u64 x = (c64 >> (8 * k)) & 0xff;
+          if (x) {
+            u64 bit = 0;
+            /**/ if (x >= 128) bit = 128;
+            else if (x >= 32) bit = 64;
+            else if (x >= 16) bit = 32;
+            else if (x >= 8) bit = 16;
+            else if (x >= 4) bit = 8;
+            else if (x >= 3) bit = 4;
+            else if (x >= 2) bit = 2;
+            else if (x >= 1) bit = 1;
+            u64 mask = bit << (8 * k);
+            if (!(new_bits_64 & mask)) {
+              num_new_bits++;
+              new_bits_64 |= mask;
+            }
+          }
+        }
+        *pb64 = new_bits_64;
+      }
+    }
+  }
+  CHECK_EQ(cur, num_8bit_counters);
+  return num_new_bits;
+}
+
+uptr *CoverageData::data() {
+  return pc_array;
+}
+
+uptr CoverageData::size() {
+  return atomic_load(&pc_array_index, memory_order_relaxed);
+}
+
+// Block layout for packed file format: header, followed by module name (no
+// trailing zero), followed by data blob.
+struct CovHeader {
+  int pid;
+  unsigned int module_name_length;
+  unsigned int data_length;
+};
+
+static void CovWritePacked(int pid, const char *module, const void *blob,
+                           unsigned int blob_size) {
+  if (cov_fd == kInvalidFd) return;
+  unsigned module_name_length = internal_strlen(module);
+  CovHeader header = {pid, module_name_length, blob_size};
+
+  if (cov_max_block_size == 0) {
+    // Writing to a file. Just go ahead.
+    WriteToFile(cov_fd, &header, sizeof(header));
+    WriteToFile(cov_fd, module, module_name_length);
+    WriteToFile(cov_fd, blob, blob_size);
+  } else {
+    // Writing to a socket. We want to split the data into appropriately sized
+    // blocks.
+    InternalScopedBuffer<char> block(cov_max_block_size);
+    CHECK_EQ((uptr)block.data(), (uptr)(CovHeader *)block.data());
+    uptr header_size_with_module = sizeof(header) + module_name_length;
+    CHECK_LT(header_size_with_module, cov_max_block_size);
+    unsigned int max_payload_size =
+        cov_max_block_size - header_size_with_module;
+    char *block_pos = block.data();
+    internal_memcpy(block_pos, &header, sizeof(header));
+    block_pos += sizeof(header);
+    internal_memcpy(block_pos, module, module_name_length);
+    block_pos += module_name_length;
+    char *block_data_begin = block_pos;
+    const char *blob_pos = (const char *)blob;
+    while (blob_size > 0) {
+      unsigned int payload_size = Min(blob_size, max_payload_size);
+      blob_size -= payload_size;
+      internal_memcpy(block_data_begin, blob_pos, payload_size);
+      blob_pos += payload_size;
+      ((CovHeader *)block.data())->data_length = payload_size;
+      WriteToFile(cov_fd, block.data(), header_size_with_module + payload_size);
+    }
+  }
+}
+
+// If packed = false: <name>.<pid>.<sancov> (name = module name).
+// If packed = true and name == 0: <pid>.<sancov>.<packed>.
+// If packed = true and name != 0: <name>.<sancov>.<packed> (name is
+// user-supplied).
+static fd_t CovOpenFile(InternalScopedString *path, bool packed,
+                       const char *name, const char *extension = "sancov") {
+  path->clear();
+  if (!packed) {
+    CHECK(name);
+    path->append("%s/%s.%zd.%s", coverage_dir, name, internal_getpid(),
+                extension);
+  } else {
+    if (!name)
+      path->append("%s/%zd.%s.packed", coverage_dir, internal_getpid(),
+                  extension);
+    else
+      path->append("%s/%s.%s.packed", coverage_dir, name, extension);
+  }
+  error_t err;
+  fd_t fd = OpenFile(path->data(), WrOnly, &err);
+  if (fd == kInvalidFd)
+    Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
+           path->data(), err);
+  return fd;
+}
+
+// Dump trace PCs and trace events into two separate files.
+void CoverageData::DumpTrace() {
+  uptr max_idx = tr_event_pointer - tr_event_array;
+  if (!max_idx) return;
+  auto sym = Symbolizer::GetOrInit();
+  if (!sym)
+    return;
+  InternalScopedString out(32 << 20);
+  for (uptr i = 0, n = size(); i < n; i++) {
+    const char *module_name = "<unknown>";
+    uptr module_address = 0;
+    sym->GetModuleNameAndOffsetForPC(UnbundlePc(pc_array[i]), &module_name,
+                                     &module_address);
+    out.append("%s 0x%zx\n", module_name, module_address);
+  }
+  InternalScopedString path(kMaxPathLength);
+  fd_t fd = CovOpenFile(&path, false, "trace-points");
+  if (fd == kInvalidFd) return;
+  WriteToFile(fd, out.data(), out.length());
+  CloseFile(fd);
+
+  fd = CovOpenFile(&path, false, "trace-compunits");
+  if (fd == kInvalidFd) return;
+  out.clear();
+  for (uptr i = 0; i < comp_unit_name_vec.size(); i++)
+    out.append("%s\n", comp_unit_name_vec[i].copied_module_name);
+  WriteToFile(fd, out.data(), out.length());
+  CloseFile(fd);
+
+  fd = CovOpenFile(&path, false, "trace-events");
+  if (fd == kInvalidFd) return;
+  uptr bytes_to_write = max_idx * sizeof(tr_event_array[0]);
+  u8 *event_bytes = reinterpret_cast<u8*>(tr_event_array);
+  // The trace file could be huge, and may not be written with a single syscall.
+  while (bytes_to_write) {
+    uptr actually_written;
+    if (WriteToFile(fd, event_bytes, bytes_to_write, &actually_written) &&
+        actually_written <= bytes_to_write) {
+      bytes_to_write -= actually_written;
+      event_bytes += actually_written;
+    } else {
+      break;
+    }
+  }
+  CloseFile(fd);
+  VReport(1, " CovDump: Trace: %zd PCs written\n", size());
+  VReport(1, " CovDump: Trace: %zd Events written\n", max_idx);
+}
+
+// This function dumps the caller=>callee pairs into a file as a sequence of
+// lines like "module_name offset".
+void CoverageData::DumpCallerCalleePairs() {
+  uptr max_idx = atomic_load(&cc_array_index, memory_order_relaxed);
+  if (!max_idx) return;
+  auto sym = Symbolizer::GetOrInit();
+  if (!sym)
+    return;
+  InternalScopedString out(32 << 20);
+  uptr total = 0;
+  for (uptr i = 0; i < max_idx; i++) {
+    uptr *cc_cache = cc_array[i];
+    CHECK(cc_cache);
+    uptr caller = cc_cache[0];
+    uptr n_callees = cc_cache[1];
+    const char *caller_module_name = "<unknown>";
+    uptr caller_module_address = 0;
+    sym->GetModuleNameAndOffsetForPC(caller, &caller_module_name,
+                                     &caller_module_address);
+    for (uptr j = 2; j < n_callees; j++) {
+      uptr callee = cc_cache[j];
+      if (!callee) break;
+      total++;
+      const char *callee_module_name = "<unknown>";
+      uptr callee_module_address = 0;
+      sym->GetModuleNameAndOffsetForPC(callee, &callee_module_name,
+                                       &callee_module_address);
+      out.append("%s 0x%zx\n%s 0x%zx\n", caller_module_name,
+                 caller_module_address, callee_module_name,
+                 callee_module_address);
+    }
+  }
+  InternalScopedString path(kMaxPathLength);
+  fd_t fd = CovOpenFile(&path, false, "caller-callee");
+  if (fd == kInvalidFd) return;
+  WriteToFile(fd, out.data(), out.length());
+  CloseFile(fd);
+  VReport(1, " CovDump: %zd caller-callee pairs written\n", total);
+}
+
+// Record the current PC into the event buffer.
+// Every event is a u32 value (index in tr_pc_array_index) so we compute
+// it once and then cache in the provided 'cache' storage.
+//
+// This function will eventually be inlined by the compiler.
+void CoverageData::TraceBasicBlock(u32 *id) {
+  // Will trap here if
+  //  1. coverage is not enabled at run-time.
+  //  2. The array tr_event_array is full.
+  *tr_event_pointer = *id - 1;
+  tr_event_pointer++;
+}
+
+void CoverageData::DumpCounters() {
+  if (!common_flags()->coverage_counters) return;
+  uptr n = coverage_data.GetNumberOf8bitCounters();
+  if (!n) return;
+  InternalScopedBuffer<u8> bitset(n);
+  coverage_data.Update8bitCounterBitsetAndClearCounters(bitset.data());
+  InternalScopedString path(kMaxPathLength);
+
+  for (uptr m = 0; m < module_name_vec.size(); m++) {
+    auto r = module_name_vec[m];
+    CHECK(r.copied_module_name);
+    CHECK_LE(r.beg, r.end);
+    CHECK_LE(r.end, size());
+    const char *base_name = StripModuleName(r.copied_module_name);
+    fd_t fd =
+        CovOpenFile(&path, /* packed */ false, base_name, "counters-sancov");
+    if (fd == kInvalidFd) return;
+    WriteToFile(fd, bitset.data() + r.beg, r.end - r.beg);
+    CloseFile(fd);
+    VReport(1, " CovDump: %zd counters written for '%s'\n", r.end - r.beg,
+            base_name);
+  }
+}
+
+void CoverageData::DumpAsBitSet() {
+  if (!common_flags()->coverage_bitset) return;
+  if (!size()) return;
+  InternalScopedBuffer<char> out(size());
+  InternalScopedString path(kMaxPathLength);
+  for (uptr m = 0; m < module_name_vec.size(); m++) {
+    uptr n_set_bits = 0;
+    auto r = module_name_vec[m];
+    CHECK(r.copied_module_name);
+    CHECK_LE(r.beg, r.end);
+    CHECK_LE(r.end, size());
+    for (uptr i = r.beg; i < r.end; i++) {
+      uptr pc = UnbundlePc(pc_array[i]);
+      out[i] = pc ? '1' : '0';
+      if (pc)
+        n_set_bits++;
+    }
+    const char *base_name = StripModuleName(r.copied_module_name);
+    fd_t fd = CovOpenFile(&path, /* packed */false, base_name, "bitset-sancov");
+    if (fd == kInvalidFd) return;
+    WriteToFile(fd, out.data() + r.beg, r.end - r.beg);
+    CloseFile(fd);
+    VReport(1,
+            " CovDump: bitset of %zd bits written for '%s', %zd bits are set\n",
+            r.end - r.beg, base_name, n_set_bits);
+  }
+}
+
+void CoverageData::DumpOffsets() {
+  auto sym = Symbolizer::GetOrInit();
+  if (!common_flags()->coverage_pcs) return;
+  CHECK_NE(sym, nullptr);
+  InternalMmapVector<uptr> offsets(0);
+  InternalScopedString path(kMaxPathLength);
+  for (uptr m = 0; m < module_name_vec.size(); m++) {
+    offsets.clear();
+    uptr num_words_for_magic = SANITIZER_WORDSIZE == 64 ? 1 : 2;
+    for (uptr i = 0; i < num_words_for_magic; i++)
+      offsets.push_back(0);
+    auto r = module_name_vec[m];
+    CHECK(r.copied_module_name);
+    CHECK_LE(r.beg, r.end);
+    CHECK_LE(r.end, size());
+    for (uptr i = r.beg; i < r.end; i++) {
+      uptr pc = UnbundlePc(pc_array[i]);
+      uptr counter = UnbundleCounter(pc_array[i]);
+      if (!pc) continue; // Not visited.
+      uptr offset = 0;
+      sym->GetModuleNameAndOffsetForPC(pc, nullptr, &offset);
+      offsets.push_back(BundlePcAndCounter(offset, counter));
+    }
+
+    CHECK_GE(offsets.size(), num_words_for_magic);
+    SortArray(offsets.data(), offsets.size());
+    for (uptr i = 0; i < offsets.size(); i++)
+      offsets[i] = UnbundlePc(offsets[i]);
+
+    uptr num_offsets = offsets.size() - num_words_for_magic;
+    u64 *magic_p = reinterpret_cast<u64*>(offsets.data());
+    CHECK_EQ(*magic_p, 0ULL);
+    // FIXME: we may want to write 32-bit offsets even in 64-mode
+    // if all the offsets are small enough.
+    *magic_p = SANITIZER_WORDSIZE == 64 ? kMagic64 : kMagic32;
+
+    const char *module_name = StripModuleName(r.copied_module_name);
+    if (cov_sandboxed) {
+      if (cov_fd != kInvalidFd) {
+        CovWritePacked(internal_getpid(), module_name, offsets.data(),
+                       offsets.size() * sizeof(offsets[0]));
+        VReport(1, " CovDump: %zd PCs written to packed file\n", num_offsets);
+      }
+    } else {
+      // One file per module per process.
+      fd_t fd = CovOpenFile(&path, false /* packed */, module_name);
+      if (fd == kInvalidFd) continue;
+      WriteToFile(fd, offsets.data(), offsets.size() * sizeof(offsets[0]));
+      CloseFile(fd);
+      VReport(1, " CovDump: %s: %zd PCs written\n", path.data(), num_offsets);
+    }
+  }
+  if (cov_fd != kInvalidFd)
+    CloseFile(cov_fd);
+}
+
+void CoverageData::DumpAll() {
+  if (!coverage_enabled || common_flags()->coverage_direct) return;
+  if (atomic_fetch_add(&dump_once_guard, 1, memory_order_relaxed))
+    return;
+  DumpAsBitSet();
+  DumpCounters();
+  DumpTrace();
+  DumpOffsets();
+  DumpCallerCalleePairs();
+}
+
+void CovPrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
+  if (!args) return;
+  if (!coverage_enabled) return;
+  cov_sandboxed = args->coverage_sandboxed;
+  if (!cov_sandboxed) return;
+  cov_max_block_size = args->coverage_max_block_size;
+  if (args->coverage_fd >= 0) {
+    cov_fd = (fd_t)args->coverage_fd;
+  } else {
+    InternalScopedString path(kMaxPathLength);
+    // Pre-open the file now. The sandbox won't allow us to do it later.
+    cov_fd = CovOpenFile(&path, true /* packed */, nullptr);
+  }
+}
+
+fd_t MaybeOpenCovFile(const char *name) {
+  CHECK(name);
+  if (!coverage_enabled) return kInvalidFd;
+  InternalScopedString path(kMaxPathLength);
+  return CovOpenFile(&path, true /* packed */, name);
+}
+
+void CovBeforeFork() {
+  coverage_data.BeforeFork();
+}
+
+void CovAfterFork(int child_pid) {
+  coverage_data.AfterFork(child_pid);
+}
+
+static void MaybeDumpCoverage() {
+  if (common_flags()->coverage)
+    __sanitizer_cov_dump();
+}
+
+void InitializeCoverage(bool enabled, const char *dir) {
+  if (coverage_enabled)
+    return;  // May happen if two sanitizer enable coverage in the same process.
+  coverage_enabled = enabled;
+  coverage_dir = dir;
+  coverage_data.Init();
+  if (enabled) coverage_data.Enable();
+  if (!common_flags()->coverage_direct) Atexit(__sanitizer_cov_dump);
+  AddDieCallback(MaybeDumpCoverage);
+}
+
+void ReInitializeCoverage(bool enabled, const char *dir) {
+  coverage_enabled = enabled;
+  coverage_dir = dir;
+  coverage_data.ReInit();
+}
+
+void CoverageUpdateMapping() {
+  if (coverage_enabled)
+    CovUpdateMapping(coverage_dir);
+}
+
+} // namespace __sanitizer
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov(u32 *guard) {
+  coverage_data.Add(StackTrace::GetPreviousInstructionPc(GET_CALLER_PC()),
+                    guard);
+}
+SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_with_check(u32 *guard) {
+  atomic_uint32_t *atomic_guard = reinterpret_cast<atomic_uint32_t*>(guard);
+  if (static_cast<s32>(
+          __sanitizer::atomic_load(atomic_guard, memory_order_relaxed)) < 0)
+    __sanitizer_cov(guard);
+}
+SANITIZER_INTERFACE_ATTRIBUTE void
+__sanitizer_cov_indir_call16(uptr callee, uptr callee_cache16[]) {
+  coverage_data.IndirCall(StackTrace::GetPreviousInstructionPc(GET_CALLER_PC()),
+                          callee, callee_cache16, 16);
+}
+SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_init() {
+  coverage_enabled = true;
+  coverage_dir = common_flags()->coverage_dir;
+  coverage_data.Init();
+}
+SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
+  coverage_data.DumpAll();
+}
+SANITIZER_INTERFACE_ATTRIBUTE void
+__sanitizer_cov_module_init(s32 *guards, uptr npcs, u8 *counters,
+                            const char *comp_unit_name) {
+  coverage_data.InitializeGuards(guards, npcs, comp_unit_name, GET_CALLER_PC());
+  coverage_data.InitializeCounters(counters, npcs);
+  if (!common_flags()->coverage_direct) return;
+  if (SANITIZER_ANDROID && coverage_enabled) {
+    // dlopen/dlclose interceptors do not work on Android, so we rely on
+    // Extend() calls to update .sancov.map.
+    CovUpdateMapping(coverage_dir, GET_CALLER_PC());
+  }
+  coverage_data.Extend(npcs);
+}
+SANITIZER_INTERFACE_ATTRIBUTE
+sptr __sanitizer_maybe_open_cov_file(const char *name) {
+  return (sptr)MaybeOpenCovFile(name);
+}
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_total_unique_coverage() {
+  return atomic_load(&coverage_counter, memory_order_relaxed);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_total_unique_caller_callee_pairs() {
+  return atomic_load(&caller_callee_counter, memory_order_relaxed);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_cov_trace_func_enter(u32 *id) {
+  __sanitizer_cov_with_check(id);
+  coverage_data.TraceBasicBlock(id);
+}
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_cov_trace_basic_block(u32 *id) {
+  __sanitizer_cov_with_check(id);
+  coverage_data.TraceBasicBlock(id);
+}
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_reset_coverage() {
+  ResetGlobalCounters();
+  coverage_data.ReinitializeGuards();
+  internal_bzero_aligned16(
+      coverage_data.data(),
+      RoundUpTo(coverage_data.size() * sizeof(coverage_data.data()[0]), 16));
+}
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_coverage_guards(uptr **data) {
+  *data = coverage_data.data();
+  return coverage_data.size();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_get_number_of_counters() {
+  return coverage_data.GetNumberOf8bitCounters();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+uptr __sanitizer_update_counter_bitset_and_clear_counters(u8 *bitset) {
+  return coverage_data.Update8bitCounterBitsetAndClearCounters(bitset);
+}
+// Default empty implementations (weak). Users should redefine them.
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+void __sanitizer_cov_trace_cmp() {}
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+void __sanitizer_cov_trace_switch() {}
+} // extern "C"
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_mapping_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_coverage_mapping_libcdep.cc
new file mode 100644
index 0000000..c8b5d90
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_coverage_mapping_libcdep.cc
@@ -0,0 +1,127 @@
+//===-- sanitizer_coverage_mapping.cc -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Mmap-based implementation of sanitizer coverage.
+//
+// This is part of the implementation of code coverage that does not require
+// __sanitizer_cov_dump() call. Data is stored in 2 files per process.
+//
+// $pid.sancov.map describes process memory layout in the following text-based
+// format:
+// <pointer size in bits>  // 1 line, 32 or 64
+// <mapping start> <mapping end> <base address> <dso name> // repeated
+// ...
+// Mapping lines are NOT sorted. This file is updated every time memory layout
+// is changed (i.e. in dlopen() and dlclose() interceptors).
+//
+// $pid.sancov.raw is a binary dump of PC values, sizeof(uptr) each. Again, not
+// sorted. This file is extended by 64Kb at a time and mapped into memory. It
+// contains one or more 0 words at the end, up to the next 64Kb aligned offset.
+//
+// To convert these 2 files to the usual .sancov format, run sancov.py rawunpack
+// $pid.sancov.raw.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_procmaps.h"
+
+namespace __sanitizer {
+
+static const uptr kMaxTextSize = 64 * 1024;
+
+struct CachedMapping {
+ public:
+  bool NeedsUpdate(uptr pc) {
+    int new_pid = internal_getpid();
+    if (last_pid == new_pid && pc && pc >= last_range_start &&
+        pc < last_range_end)
+      return false;
+    last_pid = new_pid;
+    return true;
+  }
+
+  void SetModuleRange(uptr start, uptr end) {
+    last_range_start = start;
+    last_range_end = end;
+  }
+
+ private:
+  uptr last_range_start, last_range_end;
+  int last_pid;
+};
+
+static CachedMapping cached_mapping;
+static StaticSpinMutex mapping_mu;
+
+void CovUpdateMapping(const char *coverage_dir, uptr caller_pc) {
+  if (!common_flags()->coverage_direct) return;
+
+  SpinMutexLock l(&mapping_mu);
+
+  if (!cached_mapping.NeedsUpdate(caller_pc))
+    return;
+
+  InternalScopedString text(kMaxTextSize);
+
+  {
+    InternalScopedBuffer<LoadedModule> modules(kMaxNumberOfModules);
+    CHECK(modules.data());
+    int n_modules = GetListOfModules(modules.data(), kMaxNumberOfModules,
+                                     /* filter */ nullptr);
+
+    text.append("%d\n", sizeof(uptr) * 8);
+    for (int i = 0; i < n_modules; ++i) {
+      const char *module_name = StripModuleName(modules[i].full_name());
+      uptr base = modules[i].base_address();
+      for (auto iter = modules[i].ranges(); iter.hasNext();) {
+        const auto *range = iter.next();
+        if (range->executable) {
+          uptr start = range->beg;
+          uptr end = range->end;
+          text.append("%zx %zx %zx %s\n", start, end, base, module_name);
+          if (caller_pc && caller_pc >= start && caller_pc < end)
+            cached_mapping.SetModuleRange(start, end);
+        }
+      }
+      modules[i].clear();
+    }
+  }
+
+  error_t err;
+  InternalScopedString tmp_path(64 + internal_strlen(coverage_dir));
+  uptr res = internal_snprintf((char *)tmp_path.data(), tmp_path.size(),
+                               "%s/%zd.sancov.map.tmp", coverage_dir,
+                               internal_getpid());
+  CHECK_LE(res, tmp_path.size());
+  fd_t map_fd = OpenFile(tmp_path.data(), WrOnly, &err);
+  if (map_fd == kInvalidFd) {
+    Report("Coverage: failed to open %s for writing: %d\n", tmp_path.data(),
+           err);
+    Die();
+  }
+
+  if (!WriteToFile(map_fd, text.data(), text.length(), nullptr, &err)) {
+    Printf("sancov.map write failed: %d\n", err);
+    Die();
+  }
+  CloseFile(map_fd);
+
+  InternalScopedString path(64 + internal_strlen(coverage_dir));
+  res = internal_snprintf((char *)path.data(), path.size(), "%s/%zd.sancov.map",
+                          coverage_dir, internal_getpid());
+  CHECK_LE(res, path.size());
+  if (!RenameFile(tmp_path.data(), path.data(), &err)) {
+    Printf("sancov.map rename failed: %d\n", err);
+    Die();
+  }
+}
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h
new file mode 100644
index 0000000..86d5743
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h
@@ -0,0 +1,416 @@
+//===-- sanitizer_deadlock_detector.h ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime.
+// The deadlock detector maintains a directed graph of lock acquisitions.
+// When a lock event happens, the detector checks if the locks already held by
+// the current thread are reachable from the newly acquired lock.
+//
+// The detector can handle only a fixed amount of simultaneously live locks
+// (a lock is alive if it has been locked at least once and has not been
+// destroyed). When the maximal number of locks is reached the entire graph
+// is flushed and the new lock epoch is started. The node ids from the old
+// epochs can not be used with any of the detector methods except for
+// nodeBelongsToCurrentEpoch().
+//
+// FIXME: this is work in progress, nothing really works yet.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_DEADLOCK_DETECTOR_H
+#define SANITIZER_DEADLOCK_DETECTOR_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_bvgraph.h"
+
+namespace __sanitizer {
+
+// Thread-local state for DeadlockDetector.
+// It contains the locks currently held by the owning thread.
+template <class BV>
+class DeadlockDetectorTLS {
+ public:
+  // No CTOR.
+  void clear() {
+    bv_.clear();
+    epoch_ = 0;
+    n_recursive_locks = 0;
+    n_all_locks_ = 0;
+  }
+
+  bool empty() const { return bv_.empty(); }
+
+  void ensureCurrentEpoch(uptr current_epoch) {
+    if (epoch_ == current_epoch) return;
+    bv_.clear();
+    epoch_ = current_epoch;
+    n_recursive_locks = 0;
+    n_all_locks_ = 0;
+  }
+
+  uptr getEpoch() const { return epoch_; }
+
+  // Returns true if this is the first (non-recursive) acquisition of this lock.
+  bool addLock(uptr lock_id, uptr current_epoch, u32 stk) {
+    // Printf("addLock: %zx %zx stk %u\n", lock_id, current_epoch, stk);
+    CHECK_EQ(epoch_, current_epoch);
+    if (!bv_.setBit(lock_id)) {
+      // The lock is already held by this thread, it must be recursive.
+      CHECK_LT(n_recursive_locks, ARRAY_SIZE(recursive_locks));
+      recursive_locks[n_recursive_locks++] = lock_id;
+      return false;
+    }
+    CHECK_LT(n_all_locks_, ARRAY_SIZE(all_locks_with_contexts_));
+    // lock_id < BV::kSize, can cast to a smaller int.
+    u32 lock_id_short = static_cast<u32>(lock_id);
+    LockWithContext l = {lock_id_short, stk};
+    all_locks_with_contexts_[n_all_locks_++] = l;
+    return true;
+  }
+
+  void removeLock(uptr lock_id) {
+    if (n_recursive_locks) {
+      for (sptr i = n_recursive_locks - 1; i >= 0; i--) {
+        if (recursive_locks[i] == lock_id) {
+          n_recursive_locks--;
+          Swap(recursive_locks[i], recursive_locks[n_recursive_locks]);
+          return;
+        }
+      }
+    }
+    // Printf("remLock: %zx %zx\n", lock_id, epoch_);
+    if (!bv_.clearBit(lock_id))
+      return;  // probably addLock happened before flush
+    if (n_all_locks_) {
+      for (sptr i = n_all_locks_ - 1; i >= 0; i--) {
+        if (all_locks_with_contexts_[i].lock == static_cast<u32>(lock_id)) {
+          Swap(all_locks_with_contexts_[i],
+               all_locks_with_contexts_[n_all_locks_ - 1]);
+          n_all_locks_--;
+          break;
+        }
+      }
+    }
+  }
+
+  u32 findLockContext(uptr lock_id) {
+    for (uptr i = 0; i < n_all_locks_; i++)
+      if (all_locks_with_contexts_[i].lock == static_cast<u32>(lock_id))
+        return all_locks_with_contexts_[i].stk;
+    return 0;
+  }
+
+  const BV &getLocks(uptr current_epoch) const {
+    CHECK_EQ(epoch_, current_epoch);
+    return bv_;
+  }
+
+  uptr getNumLocks() const { return n_all_locks_; }
+  uptr getLock(uptr idx) const { return all_locks_with_contexts_[idx].lock; }
+
+ private:
+  BV bv_;
+  uptr epoch_;
+  uptr recursive_locks[64];
+  uptr n_recursive_locks;
+  struct LockWithContext {
+    u32 lock;
+    u32 stk;
+  };
+  LockWithContext all_locks_with_contexts_[64];
+  uptr n_all_locks_;
+};
+
+// DeadlockDetector.
+// For deadlock detection to work we need one global DeadlockDetector object
+// and one DeadlockDetectorTLS object per evey thread.
+// This class is not thread safe, all concurrent accesses should be guarded
+// by an external lock.
+// Most of the methods of this class are not thread-safe (i.e. should
+// be protected by an external lock) unless explicitly told otherwise.
+template <class BV>
+class DeadlockDetector {
+ public:
+  typedef BV BitVector;
+
+  uptr size() const { return g_.size(); }
+
+  // No CTOR.
+  void clear() {
+    current_epoch_ = 0;
+    available_nodes_.clear();
+    recycled_nodes_.clear();
+    g_.clear();
+    n_edges_ = 0;
+  }
+
+  // Allocate new deadlock detector node.
+  // If we are out of available nodes first try to recycle some.
+  // If there is nothing to recycle, flush the graph and increment the epoch.
+  // Associate 'data' (opaque user's object) with the new node.
+  uptr newNode(uptr data) {
+    if (!available_nodes_.empty())
+      return getAvailableNode(data);
+    if (!recycled_nodes_.empty()) {
+      // Printf("recycling: n_edges_ %zd\n", n_edges_);
+      for (sptr i = n_edges_ - 1; i >= 0; i--) {
+        if (recycled_nodes_.getBit(edges_[i].from) ||
+            recycled_nodes_.getBit(edges_[i].to)) {
+          Swap(edges_[i], edges_[n_edges_ - 1]);
+          n_edges_--;
+        }
+      }
+      CHECK(available_nodes_.empty());
+      // removeEdgesFrom was called in removeNode.
+      g_.removeEdgesTo(recycled_nodes_);
+      available_nodes_.setUnion(recycled_nodes_);
+      recycled_nodes_.clear();
+      return getAvailableNode(data);
+    }
+    // We are out of vacant nodes. Flush and increment the current_epoch_.
+    current_epoch_ += size();
+    recycled_nodes_.clear();
+    available_nodes_.setAll();
+    g_.clear();
+    n_edges_ = 0;
+    return getAvailableNode(data);
+  }
+
+  // Get data associated with the node created by newNode().
+  uptr getData(uptr node) const { return data_[nodeToIndex(node)]; }
+
+  bool nodeBelongsToCurrentEpoch(uptr node) {
+    return node && (node / size() * size()) == current_epoch_;
+  }
+
+  void removeNode(uptr node) {
+    uptr idx = nodeToIndex(node);
+    CHECK(!available_nodes_.getBit(idx));
+    CHECK(recycled_nodes_.setBit(idx));
+    g_.removeEdgesFrom(idx);
+  }
+
+  void ensureCurrentEpoch(DeadlockDetectorTLS<BV> *dtls) {
+    dtls->ensureCurrentEpoch(current_epoch_);
+  }
+
+  // Returns true if there is a cycle in the graph after this lock event.
+  // Ideally should be called before the lock is acquired so that we can
+  // report a deadlock before a real deadlock happens.
+  bool onLockBefore(DeadlockDetectorTLS<BV> *dtls, uptr cur_node) {
+    ensureCurrentEpoch(dtls);
+    uptr cur_idx = nodeToIndex(cur_node);
+    return g_.isReachable(cur_idx, dtls->getLocks(current_epoch_));
+  }
+
+  u32 findLockContext(DeadlockDetectorTLS<BV> *dtls, uptr node) {
+    return dtls->findLockContext(nodeToIndex(node));
+  }
+
+  // Add cur_node to the set of locks held currently by dtls.
+  void onLockAfter(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk = 0) {
+    ensureCurrentEpoch(dtls);
+    uptr cur_idx = nodeToIndex(cur_node);
+    dtls->addLock(cur_idx, current_epoch_, stk);
+  }
+
+  // Experimental *racy* fast path function.
+  // Returns true if all edges from the currently held locks to cur_node exist.
+  bool hasAllEdges(DeadlockDetectorTLS<BV> *dtls, uptr cur_node) {
+    uptr local_epoch = dtls->getEpoch();
+    // Read from current_epoch_ is racy.
+    if (cur_node && local_epoch == current_epoch_ &&
+        local_epoch == nodeToEpoch(cur_node)) {
+      uptr cur_idx = nodeToIndexUnchecked(cur_node);
+      for (uptr i = 0, n = dtls->getNumLocks(); i < n; i++) {
+        if (!g_.hasEdge(dtls->getLock(i), cur_idx))
+          return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  // Adds edges from currently held locks to cur_node,
+  // returns the number of added edges, and puts the sources of added edges
+  // into added_edges[].
+  // Should be called before onLockAfter.
+  uptr addEdges(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk,
+                int unique_tid) {
+    ensureCurrentEpoch(dtls);
+    uptr cur_idx = nodeToIndex(cur_node);
+    uptr added_edges[40];
+    uptr n_added_edges = g_.addEdges(dtls->getLocks(current_epoch_), cur_idx,
+                                     added_edges, ARRAY_SIZE(added_edges));
+    for (uptr i = 0; i < n_added_edges; i++) {
+      if (n_edges_ < ARRAY_SIZE(edges_)) {
+        Edge e = {(u16)added_edges[i], (u16)cur_idx,
+                  dtls->findLockContext(added_edges[i]), stk,
+                  unique_tid};
+        edges_[n_edges_++] = e;
+      }
+      // Printf("Edge%zd: %u %zd=>%zd in T%d\n",
+      //        n_edges_, stk, added_edges[i], cur_idx, unique_tid);
+    }
+    return n_added_edges;
+  }
+
+  bool findEdge(uptr from_node, uptr to_node, u32 *stk_from, u32 *stk_to,
+                int *unique_tid) {
+    uptr from_idx = nodeToIndex(from_node);
+    uptr to_idx = nodeToIndex(to_node);
+    for (uptr i = 0; i < n_edges_; i++) {
+      if (edges_[i].from == from_idx && edges_[i].to == to_idx) {
+        *stk_from = edges_[i].stk_from;
+        *stk_to = edges_[i].stk_to;
+        *unique_tid = edges_[i].unique_tid;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Test-only function. Handles the before/after lock events,
+  // returns true if there is a cycle.
+  bool onLock(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk = 0) {
+    ensureCurrentEpoch(dtls);
+    bool is_reachable = !isHeld(dtls, cur_node) && onLockBefore(dtls, cur_node);
+    addEdges(dtls, cur_node, stk, 0);
+    onLockAfter(dtls, cur_node, stk);
+    return is_reachable;
+  }
+
+  // Handles the try_lock event, returns false.
+  // When a try_lock event happens (i.e. a try_lock call succeeds) we need
+  // to add this lock to the currently held locks, but we should not try to
+  // change the lock graph or to detect a cycle.  We may want to investigate
+  // whether a more aggressive strategy is possible for try_lock.
+  bool onTryLock(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk = 0) {
+    ensureCurrentEpoch(dtls);
+    uptr cur_idx = nodeToIndex(cur_node);
+    dtls->addLock(cur_idx, current_epoch_, stk);
+    return false;
+  }
+
+  // Returns true iff dtls is empty (no locks are currently held) and we can
+  // add the node to the currently held locks w/o chanding the global state.
+  // This operation is thread-safe as it only touches the dtls.
+  bool onFirstLock(DeadlockDetectorTLS<BV> *dtls, uptr node, u32 stk = 0) {
+    if (!dtls->empty()) return false;
+    if (dtls->getEpoch() && dtls->getEpoch() == nodeToEpoch(node)) {
+      dtls->addLock(nodeToIndexUnchecked(node), nodeToEpoch(node), stk);
+      return true;
+    }
+    return false;
+  }
+
+  // Finds a path between the lock 'cur_node' (currently not held in dtls)
+  // and some currently held lock, returns the length of the path
+  // or 0 on failure.
+  uptr findPathToLock(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, uptr *path,
+                      uptr path_size) {
+    tmp_bv_.copyFrom(dtls->getLocks(current_epoch_));
+    uptr idx = nodeToIndex(cur_node);
+    CHECK(!tmp_bv_.getBit(idx));
+    uptr res = g_.findShortestPath(idx, tmp_bv_, path, path_size);
+    for (uptr i = 0; i < res; i++)
+      path[i] = indexToNode(path[i]);
+    if (res)
+      CHECK_EQ(path[0], cur_node);
+    return res;
+  }
+
+  // Handle the unlock event.
+  // This operation is thread-safe as it only touches the dtls.
+  void onUnlock(DeadlockDetectorTLS<BV> *dtls, uptr node) {
+    if (dtls->getEpoch() == nodeToEpoch(node))
+      dtls->removeLock(nodeToIndexUnchecked(node));
+  }
+
+  // Tries to handle the lock event w/o writing to global state.
+  // Returns true on success.
+  // This operation is thread-safe as it only touches the dtls
+  // (modulo racy nature of hasAllEdges).
+  bool onLockFast(DeadlockDetectorTLS<BV> *dtls, uptr node, u32 stk = 0) {
+    if (hasAllEdges(dtls, node)) {
+      dtls->addLock(nodeToIndexUnchecked(node), nodeToEpoch(node), stk);
+      return true;
+    }
+    return false;
+  }
+
+  bool isHeld(DeadlockDetectorTLS<BV> *dtls, uptr node) const {
+    return dtls->getLocks(current_epoch_).getBit(nodeToIndex(node));
+  }
+
+  uptr testOnlyGetEpoch() const { return current_epoch_; }
+  bool testOnlyHasEdge(uptr l1, uptr l2) {
+    return g_.hasEdge(nodeToIndex(l1), nodeToIndex(l2));
+  }
+  // idx1 and idx2 are raw indices to g_, not lock IDs.
+  bool testOnlyHasEdgeRaw(uptr idx1, uptr idx2) {
+    return g_.hasEdge(idx1, idx2);
+  }
+
+  void Print() {
+    for (uptr from = 0; from < size(); from++)
+      for (uptr to = 0; to < size(); to++)
+        if (g_.hasEdge(from, to))
+          Printf("  %zx => %zx\n", from, to);
+  }
+
+ private:
+  void check_idx(uptr idx) const { CHECK_LT(idx, size()); }
+
+  void check_node(uptr node) const {
+    CHECK_GE(node, size());
+    CHECK_EQ(current_epoch_, nodeToEpoch(node));
+  }
+
+  uptr indexToNode(uptr idx) const {
+    check_idx(idx);
+    return idx + current_epoch_;
+  }
+
+  uptr nodeToIndexUnchecked(uptr node) const { return node % size(); }
+
+  uptr nodeToIndex(uptr node) const {
+    check_node(node);
+    return nodeToIndexUnchecked(node);
+  }
+
+  uptr nodeToEpoch(uptr node) const { return node / size() * size(); }
+
+  uptr getAvailableNode(uptr data) {
+    uptr idx = available_nodes_.getAndClearFirstOne();
+    data_[idx] = data;
+    return indexToNode(idx);
+  }
+
+  struct Edge {
+    u16 from;
+    u16 to;
+    u32 stk_from;
+    u32 stk_to;
+    int unique_tid;
+  };
+
+  uptr current_epoch_;
+  BV available_nodes_;
+  BV recycled_nodes_;
+  BV tmp_bv_;
+  BVGraph<BV> g_;
+  uptr data_[BV::kSize];
+  Edge edges_[BV::kSize * 32];
+  uptr n_edges_;
+};
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_DEADLOCK_DETECTOR_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector1.cc b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector1.cc
new file mode 100644
index 0000000..bd57a40
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector1.cc
@@ -0,0 +1,190 @@
+//===-- sanitizer_deadlock_detector1.cc -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Deadlock detector implementation based on NxN adjacency bit matrix.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_deadlock_detector_interface.h"
+#include "sanitizer_deadlock_detector.h"
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_mutex.h"
+
+#if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1
+
+namespace __sanitizer {
+
+typedef TwoLevelBitVector<> DDBV;  // DeadlockDetector's bit vector.
+
+struct DDPhysicalThread {
+};
+
+struct DDLogicalThread {
+  u64 ctx;
+  DeadlockDetectorTLS<DDBV> dd;
+  DDReport rep;
+  bool report_pending;
+};
+
+struct DD : public DDetector {
+  SpinMutex mtx;
+  DeadlockDetector<DDBV> dd;
+  DDFlags flags;
+
+  explicit DD(const DDFlags *flags);
+
+  DDPhysicalThread *CreatePhysicalThread() override;
+  void DestroyPhysicalThread(DDPhysicalThread *pt) override;
+
+  DDLogicalThread *CreateLogicalThread(u64 ctx) override;
+  void DestroyLogicalThread(DDLogicalThread *lt) override;
+
+  void MutexInit(DDCallback *cb, DDMutex *m) override;
+  void MutexBeforeLock(DDCallback *cb, DDMutex *m, bool wlock) override;
+  void MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock,
+                      bool trylock) override;
+  void MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock) override;
+  void MutexDestroy(DDCallback *cb, DDMutex *m) override;
+
+  DDReport *GetReport(DDCallback *cb) override;
+
+  void MutexEnsureID(DDLogicalThread *lt, DDMutex *m);
+  void ReportDeadlock(DDCallback *cb, DDMutex *m);
+};
+
+DDetector *DDetector::Create(const DDFlags *flags) {
+  (void)flags;
+  void *mem = MmapOrDie(sizeof(DD), "deadlock detector");
+  return new(mem) DD(flags);
+}
+
+DD::DD(const DDFlags *flags)
+    : flags(*flags) {
+  dd.clear();
+}
+
+DDPhysicalThread* DD::CreatePhysicalThread() {
+  return nullptr;
+}
+
+void DD::DestroyPhysicalThread(DDPhysicalThread *pt) {
+}
+
+DDLogicalThread* DD::CreateLogicalThread(u64 ctx) {
+  DDLogicalThread *lt = (DDLogicalThread*)InternalAlloc(sizeof(*lt));
+  lt->ctx = ctx;
+  lt->dd.clear();
+  lt->report_pending = false;
+  return lt;
+}
+
+void DD::DestroyLogicalThread(DDLogicalThread *lt) {
+  lt->~DDLogicalThread();
+  InternalFree(lt);
+}
+
+void DD::MutexInit(DDCallback *cb, DDMutex *m) {
+  m->id = 0;
+  m->stk = cb->Unwind();
+}
+
+void DD::MutexEnsureID(DDLogicalThread *lt, DDMutex *m) {
+  if (!dd.nodeBelongsToCurrentEpoch(m->id))
+    m->id = dd.newNode(reinterpret_cast<uptr>(m));
+  dd.ensureCurrentEpoch(&lt->dd);
+}
+
+void DD::MutexBeforeLock(DDCallback *cb,
+    DDMutex *m, bool wlock) {
+  DDLogicalThread *lt = cb->lt;
+  if (lt->dd.empty()) return;  // This will be the first lock held by lt.
+  if (dd.hasAllEdges(&lt->dd, m->id)) return;  // We already have all edges.
+  SpinMutexLock lk(&mtx);
+  MutexEnsureID(lt, m);
+  if (dd.isHeld(&lt->dd, m->id))
+    return;  // FIXME: allow this only for recursive locks.
+  if (dd.onLockBefore(&lt->dd, m->id)) {
+    // Actually add this edge now so that we have all the stack traces.
+    dd.addEdges(&lt->dd, m->id, cb->Unwind(), cb->UniqueTid());
+    ReportDeadlock(cb, m);
+  }
+}
+
+void DD::ReportDeadlock(DDCallback *cb, DDMutex *m) {
+  DDLogicalThread *lt = cb->lt;
+  uptr path[10];
+  uptr len = dd.findPathToLock(&lt->dd, m->id, path, ARRAY_SIZE(path));
+  CHECK_GT(len, 0U);  // Hm.. cycle of 10 locks? I'd like to see that.
+  CHECK_EQ(m->id, path[0]);
+  lt->report_pending = true;
+  DDReport *rep = &lt->rep;
+  rep->n = len;
+  for (uptr i = 0; i < len; i++) {
+    uptr from = path[i];
+    uptr to = path[(i + 1) % len];
+    DDMutex *m0 = (DDMutex*)dd.getData(from);
+    DDMutex *m1 = (DDMutex*)dd.getData(to);
+
+    u32 stk_from = -1U, stk_to = -1U;
+    int unique_tid = 0;
+    dd.findEdge(from, to, &stk_from, &stk_to, &unique_tid);
+    // Printf("Edge: %zd=>%zd: %u/%u T%d\n", from, to, stk_from, stk_to,
+    //    unique_tid);
+    rep->loop[i].thr_ctx = unique_tid;
+    rep->loop[i].mtx_ctx0 = m0->ctx;
+    rep->loop[i].mtx_ctx1 = m1->ctx;
+    rep->loop[i].stk[0] = stk_to;
+    rep->loop[i].stk[1] = stk_from;
+  }
+}
+
+void DD::MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock, bool trylock) {
+  DDLogicalThread *lt = cb->lt;
+  u32 stk = 0;
+  if (flags.second_deadlock_stack)
+    stk = cb->Unwind();
+  // Printf("T%p MutexLock:   %zx stk %u\n", lt, m->id, stk);
+  if (dd.onFirstLock(&lt->dd, m->id, stk))
+    return;
+  if (dd.onLockFast(&lt->dd, m->id, stk))
+    return;
+
+  SpinMutexLock lk(&mtx);
+  MutexEnsureID(lt, m);
+  if (wlock)  // Only a recursive rlock may be held.
+    CHECK(!dd.isHeld(&lt->dd, m->id));
+  if (!trylock)
+    dd.addEdges(&lt->dd, m->id, stk ? stk : cb->Unwind(), cb->UniqueTid());
+  dd.onLockAfter(&lt->dd, m->id, stk);
+}
+
+void DD::MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock) {
+  // Printf("T%p MutexUnLock: %zx\n", cb->lt, m->id);
+  dd.onUnlock(&cb->lt->dd, m->id);
+}
+
+void DD::MutexDestroy(DDCallback *cb,
+    DDMutex *m) {
+  if (!m->id) return;
+  SpinMutexLock lk(&mtx);
+  if (dd.nodeBelongsToCurrentEpoch(m->id))
+    dd.removeNode(m->id);
+  m->id = 0;
+}
+
+DDReport *DD::GetReport(DDCallback *cb) {
+  if (!cb->lt->report_pending)
+    return nullptr;
+  cb->lt->report_pending = false;
+  return &cb->lt->rep;
+}
+
+} // namespace __sanitizer
+#endif // #if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector2.cc b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector2.cc
new file mode 100644
index 0000000..87d4a4d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector2.cc
@@ -0,0 +1,428 @@
+//===-- sanitizer_deadlock_detector2.cc -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Deadlock detector implementation based on adjacency lists.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_deadlock_detector_interface.h"
+#include "sanitizer_common.h"
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_mutex.h"
+
+#if SANITIZER_DEADLOCK_DETECTOR_VERSION == 2
+
+namespace __sanitizer {
+
+const int kMaxNesting = 64;
+const u32 kNoId = -1;
+const u32 kEndId = -2;
+const int kMaxLink = 8;
+const int kL1Size = 1024;
+const int kL2Size = 1024;
+const int kMaxMutex = kL1Size * kL2Size;
+
+struct Id {
+  u32 id;
+  u32 seq;
+
+  explicit Id(u32 id = 0, u32 seq = 0)
+      : id(id)
+      , seq(seq) {
+  }
+};
+
+struct Link {
+  u32 id;
+  u32 seq;
+  u32 tid;
+  u32 stk0;
+  u32 stk1;
+
+  explicit Link(u32 id = 0, u32 seq = 0, u32 tid = 0, u32 s0 = 0, u32 s1 = 0)
+      : id(id)
+      , seq(seq)
+      , tid(tid)
+      , stk0(s0)
+      , stk1(s1) {
+  }
+};
+
+struct DDPhysicalThread {
+  DDReport rep;
+  bool report_pending;
+  bool visited[kMaxMutex];
+  Link pending[kMaxMutex];
+  Link path[kMaxMutex];
+};
+
+struct ThreadMutex {
+  u32 id;
+  u32 stk;
+};
+
+struct DDLogicalThread {
+  u64         ctx;
+  ThreadMutex locked[kMaxNesting];
+  int         nlocked;
+};
+
+struct Mutex {
+  StaticSpinMutex mtx;
+  u32 seq;
+  int nlink;
+  Link link[kMaxLink];
+};
+
+struct DD : public DDetector {
+  explicit DD(const DDFlags *flags);
+
+  DDPhysicalThread* CreatePhysicalThread();
+  void DestroyPhysicalThread(DDPhysicalThread *pt);
+
+  DDLogicalThread* CreateLogicalThread(u64 ctx);
+  void DestroyLogicalThread(DDLogicalThread *lt);
+
+  void MutexInit(DDCallback *cb, DDMutex *m);
+  void MutexBeforeLock(DDCallback *cb, DDMutex *m, bool wlock);
+  void MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock,
+      bool trylock);
+  void MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock);
+  void MutexDestroy(DDCallback *cb, DDMutex *m);
+
+  DDReport *GetReport(DDCallback *cb);
+
+  void CycleCheck(DDPhysicalThread *pt, DDLogicalThread *lt, DDMutex *mtx);
+  void Report(DDPhysicalThread *pt, DDLogicalThread *lt, int npath);
+  u32 allocateId(DDCallback *cb);
+  Mutex *getMutex(u32 id);
+  u32 getMutexId(Mutex *m);
+
+  DDFlags flags;
+
+  Mutex* mutex[kL1Size];
+
+  SpinMutex mtx;
+  InternalMmapVector<u32> free_id;
+  int id_gen;
+};
+
+DDetector *DDetector::Create(const DDFlags *flags) {
+  (void)flags;
+  void *mem = MmapOrDie(sizeof(DD), "deadlock detector");
+  return new(mem) DD(flags);
+}
+
+DD::DD(const DDFlags *flags)
+    : flags(*flags)
+    , free_id(1024) {
+  id_gen = 0;
+}
+
+DDPhysicalThread* DD::CreatePhysicalThread() {
+  DDPhysicalThread *pt = (DDPhysicalThread*)MmapOrDie(sizeof(DDPhysicalThread),
+      "deadlock detector (physical thread)");
+  return pt;
+}
+
+void DD::DestroyPhysicalThread(DDPhysicalThread *pt) {
+  pt->~DDPhysicalThread();
+  UnmapOrDie(pt, sizeof(DDPhysicalThread));
+}
+
+DDLogicalThread* DD::CreateLogicalThread(u64 ctx) {
+  DDLogicalThread *lt = (DDLogicalThread*)InternalAlloc(
+      sizeof(DDLogicalThread));
+  lt->ctx = ctx;
+  lt->nlocked = 0;
+  return lt;
+}
+
+void DD::DestroyLogicalThread(DDLogicalThread *lt) {
+  lt->~DDLogicalThread();
+  InternalFree(lt);
+}
+
+void DD::MutexInit(DDCallback *cb, DDMutex *m) {
+  VPrintf(2, "#%llu: DD::MutexInit(%p)\n", cb->lt->ctx, m);
+  m->id = kNoId;
+  m->recursion = 0;
+  atomic_store(&m->owner, 0, memory_order_relaxed);
+}
+
+Mutex *DD::getMutex(u32 id) {
+  return &mutex[id / kL2Size][id % kL2Size];
+}
+
+u32 DD::getMutexId(Mutex *m) {
+  for (int i = 0; i < kL1Size; i++) {
+    Mutex *tab = mutex[i];
+    if (tab == 0)
+      break;
+    if (m >= tab && m < tab + kL2Size)
+      return i * kL2Size + (m - tab);
+  }
+  return -1;
+}
+
+u32 DD::allocateId(DDCallback *cb) {
+  u32 id = -1;
+  SpinMutexLock l(&mtx);
+  if (free_id.size() > 0) {
+    id = free_id.back();
+    free_id.pop_back();
+  } else {
+    CHECK_LT(id_gen, kMaxMutex);
+    if ((id_gen % kL2Size) == 0) {
+      mutex[id_gen / kL2Size] = (Mutex*)MmapOrDie(kL2Size * sizeof(Mutex),
+          "deadlock detector (mutex table)");
+    }
+    id = id_gen++;
+  }
+  CHECK_LE(id, kMaxMutex);
+  VPrintf(3, "#%llu: DD::allocateId assign id %d\n", cb->lt->ctx, id);
+  return id;
+}
+
+void DD::MutexBeforeLock(DDCallback *cb, DDMutex *m, bool wlock) {
+  VPrintf(2, "#%llu: DD::MutexBeforeLock(%p, wlock=%d) nlocked=%d\n",
+      cb->lt->ctx, m, wlock, cb->lt->nlocked);
+  DDPhysicalThread *pt = cb->pt;
+  DDLogicalThread *lt = cb->lt;
+
+  uptr owner = atomic_load(&m->owner, memory_order_relaxed);
+  if (owner == (uptr)cb->lt) {
+    VPrintf(3, "#%llu: DD::MutexBeforeLock recursive\n",
+        cb->lt->ctx);
+    return;
+  }
+
+  CHECK_LE(lt->nlocked, kMaxNesting);
+
+  // FIXME(dvyukov): don't allocate id if lt->nlocked == 0?
+  if (m->id == kNoId)
+    m->id = allocateId(cb);
+
+  ThreadMutex *tm = &lt->locked[lt->nlocked++];
+  tm->id = m->id;
+  if (flags.second_deadlock_stack)
+    tm->stk = cb->Unwind();
+  if (lt->nlocked == 1) {
+    VPrintf(3, "#%llu: DD::MutexBeforeLock first mutex\n",
+        cb->lt->ctx);
+    return;
+  }
+
+  bool added = false;
+  Mutex *mtx = getMutex(m->id);
+  for (int i = 0; i < lt->nlocked - 1; i++) {
+    u32 id1 = lt->locked[i].id;
+    u32 stk1 = lt->locked[i].stk;
+    Mutex *mtx1 = getMutex(id1);
+    SpinMutexLock l(&mtx1->mtx);
+    if (mtx1->nlink == kMaxLink) {
+      // FIXME(dvyukov): check stale links
+      continue;
+    }
+    int li = 0;
+    for (; li < mtx1->nlink; li++) {
+      Link *link = &mtx1->link[li];
+      if (link->id == m->id) {
+        if (link->seq != mtx->seq) {
+          link->seq = mtx->seq;
+          link->tid = lt->ctx;
+          link->stk0 = stk1;
+          link->stk1 = cb->Unwind();
+          added = true;
+          VPrintf(3, "#%llu: DD::MutexBeforeLock added %d->%d link\n",
+              cb->lt->ctx, getMutexId(mtx1), m->id);
+        }
+        break;
+      }
+    }
+    if (li == mtx1->nlink) {
+      // FIXME(dvyukov): check stale links
+      Link *link = &mtx1->link[mtx1->nlink++];
+      link->id = m->id;
+      link->seq = mtx->seq;
+      link->tid = lt->ctx;
+      link->stk0 = stk1;
+      link->stk1 = cb->Unwind();
+      added = true;
+      VPrintf(3, "#%llu: DD::MutexBeforeLock added %d->%d link\n",
+          cb->lt->ctx, getMutexId(mtx1), m->id);
+    }
+  }
+
+  if (!added || mtx->nlink == 0) {
+    VPrintf(3, "#%llu: DD::MutexBeforeLock don't check\n",
+        cb->lt->ctx);
+    return;
+  }
+
+  CycleCheck(pt, lt, m);
+}
+
+void DD::MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock,
+    bool trylock) {
+  VPrintf(2, "#%llu: DD::MutexAfterLock(%p, wlock=%d, try=%d) nlocked=%d\n",
+      cb->lt->ctx, m, wlock, trylock, cb->lt->nlocked);
+  DDLogicalThread *lt = cb->lt;
+
+  uptr owner = atomic_load(&m->owner, memory_order_relaxed);
+  if (owner == (uptr)cb->lt) {
+    VPrintf(3, "#%llu: DD::MutexAfterLock recursive\n", cb->lt->ctx);
+    CHECK(wlock);
+    m->recursion++;
+    return;
+  }
+  CHECK_EQ(owner, 0);
+  if (wlock) {
+    VPrintf(3, "#%llu: DD::MutexAfterLock set owner\n", cb->lt->ctx);
+    CHECK_EQ(m->recursion, 0);
+    m->recursion = 1;
+    atomic_store(&m->owner, (uptr)cb->lt, memory_order_relaxed);
+  }
+
+  if (!trylock)
+    return;
+
+  CHECK_LE(lt->nlocked, kMaxNesting);
+  if (m->id == kNoId)
+    m->id = allocateId(cb);
+  ThreadMutex *tm = &lt->locked[lt->nlocked++];
+  tm->id = m->id;
+  if (flags.second_deadlock_stack)
+    tm->stk = cb->Unwind();
+}
+
+void DD::MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock) {
+  VPrintf(2, "#%llu: DD::MutexBeforeUnlock(%p, wlock=%d) nlocked=%d\n",
+      cb->lt->ctx, m, wlock, cb->lt->nlocked);
+  DDLogicalThread *lt = cb->lt;
+
+  uptr owner = atomic_load(&m->owner, memory_order_relaxed);
+  if (owner == (uptr)cb->lt) {
+    VPrintf(3, "#%llu: DD::MutexBeforeUnlock recursive\n", cb->lt->ctx);
+    if (--m->recursion > 0)
+      return;
+    VPrintf(3, "#%llu: DD::MutexBeforeUnlock reset owner\n", cb->lt->ctx);
+    atomic_store(&m->owner, 0, memory_order_relaxed);
+  }
+  CHECK_NE(m->id, kNoId);
+  int last = lt->nlocked - 1;
+  for (int i = last; i >= 0; i--) {
+    if (cb->lt->locked[i].id == m->id) {
+      lt->locked[i] = lt->locked[last];
+      lt->nlocked--;
+      break;
+    }
+  }
+}
+
+void DD::MutexDestroy(DDCallback *cb, DDMutex *m) {
+  VPrintf(2, "#%llu: DD::MutexDestroy(%p)\n",
+      cb->lt->ctx, m);
+  DDLogicalThread *lt = cb->lt;
+
+  if (m->id == kNoId)
+    return;
+
+  // Remove the mutex from lt->locked if there.
+  int last = lt->nlocked - 1;
+  for (int i = last; i >= 0; i--) {
+    if (lt->locked[i].id == m->id) {
+      lt->locked[i] = lt->locked[last];
+      lt->nlocked--;
+      break;
+    }
+  }
+
+  // Clear and invalidate the mutex descriptor.
+  {
+    Mutex *mtx = getMutex(m->id);
+    SpinMutexLock l(&mtx->mtx);
+    mtx->seq++;
+    mtx->nlink = 0;
+  }
+
+  // Return id to cache.
+  {
+    SpinMutexLock l(&mtx);
+    free_id.push_back(m->id);
+  }
+}
+
+void DD::CycleCheck(DDPhysicalThread *pt, DDLogicalThread *lt,
+    DDMutex *m) {
+  internal_memset(pt->visited, 0, sizeof(pt->visited));
+  int npath = 0;
+  int npending = 0;
+  {
+    Mutex *mtx = getMutex(m->id);
+    SpinMutexLock l(&mtx->mtx);
+    for (int li = 0; li < mtx->nlink; li++)
+      pt->pending[npending++] = mtx->link[li];
+  }
+  while (npending > 0) {
+    Link link = pt->pending[--npending];
+    if (link.id == kEndId) {
+      npath--;
+      continue;
+    }
+    if (pt->visited[link.id])
+      continue;
+    Mutex *mtx1 = getMutex(link.id);
+    SpinMutexLock l(&mtx1->mtx);
+    if (mtx1->seq != link.seq)
+      continue;
+    pt->visited[link.id] = true;
+    if (mtx1->nlink == 0)
+      continue;
+    pt->path[npath++] = link;
+    pt->pending[npending++] = Link(kEndId);
+    if (link.id == m->id)
+      return Report(pt, lt, npath);  // Bingo!
+    for (int li = 0; li < mtx1->nlink; li++) {
+      Link *link1 = &mtx1->link[li];
+      // Mutex *mtx2 = getMutex(link->id);
+      // FIXME(dvyukov): fast seq check
+      // FIXME(dvyukov): fast nlink != 0 check
+      // FIXME(dvyukov): fast pending check?
+      // FIXME(dvyukov): npending can be larger than kMaxMutex
+      pt->pending[npending++] = *link1;
+    }
+  }
+}
+
+void DD::Report(DDPhysicalThread *pt, DDLogicalThread *lt, int npath) {
+  DDReport *rep = &pt->rep;
+  rep->n = npath;
+  for (int i = 0; i < npath; i++) {
+    Link *link = &pt->path[i];
+    Link *link0 = &pt->path[i ? i - 1 : npath - 1];
+    rep->loop[i].thr_ctx = link->tid;
+    rep->loop[i].mtx_ctx0 = link0->id;
+    rep->loop[i].mtx_ctx1 = link->id;
+    rep->loop[i].stk[0] = flags.second_deadlock_stack ? link->stk0 : 0;
+    rep->loop[i].stk[1] = link->stk1;
+  }
+  pt->report_pending = true;
+}
+
+DDReport *DD::GetReport(DDCallback *cb) {
+  if (!cb->pt->report_pending)
+    return 0;
+  cb->pt->report_pending = false;
+  return &cb->pt->rep;
+}
+
+}  // namespace __sanitizer
+#endif  // #if SANITIZER_DEADLOCK_DETECTOR_VERSION == 2
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector_interface.h b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector_interface.h
new file mode 100644
index 0000000..b6e91a1
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector_interface.h
@@ -0,0 +1,93 @@
+//===-- sanitizer_deadlock_detector_interface.h -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime.
+// Abstract deadlock detector interface.
+// FIXME: this is work in progress, nothing really works yet.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_DEADLOCK_DETECTOR_INTERFACE_H
+#define SANITIZER_DEADLOCK_DETECTOR_INTERFACE_H
+
+#ifndef SANITIZER_DEADLOCK_DETECTOR_VERSION
+# define SANITIZER_DEADLOCK_DETECTOR_VERSION 1
+#endif
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_atomic.h"
+
+namespace __sanitizer {
+
+// dd - deadlock detector.
+// lt - logical (user) thread.
+// pt - physical (OS) thread.
+
+struct DDPhysicalThread;
+struct DDLogicalThread;
+
+struct DDMutex {
+#if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1
+  uptr id;
+  u32  stk;  // creation stack
+#elif SANITIZER_DEADLOCK_DETECTOR_VERSION == 2
+  u32              id;
+  u32              recursion;
+  atomic_uintptr_t owner;
+#else
+# error "BAD SANITIZER_DEADLOCK_DETECTOR_VERSION"
+#endif
+  u64  ctx;
+};
+
+struct DDFlags {
+  bool second_deadlock_stack;
+};
+
+struct DDReport {
+  enum { kMaxLoopSize = 8 };
+  int n;  // number of entries in loop
+  struct {
+    u64 thr_ctx;   // user thread context
+    u64 mtx_ctx0;  // user mutex context, start of the edge
+    u64 mtx_ctx1;  // user mutex context, end of the edge
+    u32 stk[2];  // stack ids for the edge
+  } loop[kMaxLoopSize];
+};
+
+struct DDCallback {
+  DDPhysicalThread *pt;
+  DDLogicalThread  *lt;
+
+  virtual u32 Unwind() { return 0; }
+  virtual int UniqueTid() { return 0; }
+};
+
+struct DDetector {
+  static DDetector *Create(const DDFlags *flags);
+
+  virtual DDPhysicalThread* CreatePhysicalThread() { return nullptr; }
+  virtual void DestroyPhysicalThread(DDPhysicalThread *pt) {}
+
+  virtual DDLogicalThread* CreateLogicalThread(u64 ctx) { return nullptr; }
+  virtual void DestroyLogicalThread(DDLogicalThread *lt) {}
+
+  virtual void MutexInit(DDCallback *cb, DDMutex *m) {}
+  virtual void MutexBeforeLock(DDCallback *cb, DDMutex *m, bool wlock) {}
+  virtual void MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock,
+      bool trylock) {}
+  virtual void MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock) {}
+  virtual void MutexDestroy(DDCallback *cb, DDMutex *m) {}
+
+  virtual DDReport *GetReport(DDCallback *cb) { return nullptr; }
+};
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_DEADLOCK_DETECTOR_INTERFACE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc
new file mode 100644
index 0000000..67830b2
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc
@@ -0,0 +1,171 @@
+//===-- sanitizer_flag_parser.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_flag_parser.h"
+
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_flag_parser.h"
+
+namespace __sanitizer {
+
+LowLevelAllocator FlagParser::Alloc;
+
+class UnknownFlags {
+  static const int kMaxUnknownFlags = 20;
+  const char *unknown_flags_[kMaxUnknownFlags];
+  int n_unknown_flags_;
+
+ public:
+  void Add(const char *name) {
+    CHECK_LT(n_unknown_flags_, kMaxUnknownFlags);
+    unknown_flags_[n_unknown_flags_++] = name;
+  }
+
+  void Report() {
+    if (!n_unknown_flags_) return;
+    Printf("WARNING: found %d unrecognized flag(s):\n", n_unknown_flags_);
+    for (int i = 0; i < n_unknown_flags_; ++i)
+      Printf("    %s\n", unknown_flags_[i]);
+    n_unknown_flags_ = 0;
+  }
+};
+
+UnknownFlags unknown_flags;
+
+void ReportUnrecognizedFlags() {
+  unknown_flags.Report();
+}
+
+char *FlagParser::ll_strndup(const char *s, uptr n) {
+  uptr len = internal_strnlen(s, n);
+  char *s2 = (char*)Alloc.Allocate(len + 1);
+  internal_memcpy(s2, s, len);
+  s2[len] = 0;
+  return s2;
+}
+
+void FlagParser::PrintFlagDescriptions() {
+  Printf("Available flags for %s:\n", SanitizerToolName);
+  for (int i = 0; i < n_flags_; ++i)
+    Printf("\t%s\n\t\t- %s\n", flags_[i].name, flags_[i].desc);
+}
+
+void FlagParser::fatal_error(const char *err) {
+  Printf("ERROR: %s\n", err);
+  Die();
+}
+
+bool FlagParser::is_space(char c) {
+  return c == ' ' || c == ',' || c == ':' || c == '\n' || c == '\t' ||
+         c == '\r';
+}
+
+void FlagParser::skip_whitespace() {
+  while (is_space(buf_[pos_])) ++pos_;
+}
+
+void FlagParser::parse_flag() {
+  uptr name_start = pos_;
+  while (buf_[pos_] != 0 && buf_[pos_] != '=' && !is_space(buf_[pos_])) ++pos_;
+  if (buf_[pos_] != '=') fatal_error("expected '='");
+  char *name = ll_strndup(buf_ + name_start, pos_ - name_start);
+
+  uptr value_start = ++pos_;
+  char *value;
+  if (buf_[pos_] == '\'' || buf_[pos_] == '"') {
+    char quote = buf_[pos_++];
+    while (buf_[pos_] != 0 && buf_[pos_] != quote) ++pos_;
+    if (buf_[pos_] == 0) fatal_error("unterminated string");
+    value = ll_strndup(buf_ + value_start + 1, pos_ - value_start - 1);
+    ++pos_; // consume the closing quote
+  } else {
+    while (buf_[pos_] != 0 && !is_space(buf_[pos_])) ++pos_;
+    if (buf_[pos_] != 0 && !is_space(buf_[pos_]))
+      fatal_error("expected separator or eol");
+    value = ll_strndup(buf_ + value_start, pos_ - value_start);
+  }
+
+  bool res = run_handler(name, value);
+  if (!res) fatal_error("Flag parsing failed.");
+}
+
+void FlagParser::parse_flags() {
+  while (true) {
+    skip_whitespace();
+    if (buf_[pos_] == 0) break;
+    parse_flag();
+  }
+
+  // Do a sanity check for certain flags.
+  if (common_flags_dont_use.malloc_context_size < 1)
+    common_flags_dont_use.malloc_context_size = 1;
+}
+
+void FlagParser::ParseString(const char *s) {
+  if (!s) return;
+  // Backup current parser state to allow nested ParseString() calls.
+  const char *old_buf_ = buf_;
+  uptr old_pos_ = pos_;
+  buf_ = s;
+  pos_ = 0;
+
+  parse_flags();
+
+  buf_ = old_buf_;
+  pos_ = old_pos_;
+}
+
+bool FlagParser::ParseFile(const char *path, bool ignore_missing) {
+  static const uptr kMaxIncludeSize = 1 << 15;
+  char *data;
+  uptr data_mapped_size;
+  error_t err;
+  uptr len;
+  if (!ReadFileToBuffer(path, &data, &data_mapped_size, &len,
+                        Max(kMaxIncludeSize, GetPageSizeCached()), &err)) {
+    if (ignore_missing)
+      return true;
+    Printf("Failed to read options from '%s': error %d\n", path, err);
+    return false;
+  }
+  ParseString(data);
+  UnmapOrDie(data, data_mapped_size);
+  return true;
+}
+
+bool FlagParser::run_handler(const char *name, const char *value) {
+  for (int i = 0; i < n_flags_; ++i) {
+    if (internal_strcmp(name, flags_[i].name) == 0)
+      return flags_[i].handler->Parse(value);
+  }
+  // Unrecognized flag. This is not a fatal error, we may print a warning later.
+  unknown_flags.Add(name);
+  return true;
+}
+
+void FlagParser::RegisterHandler(const char *name, FlagHandlerBase *handler,
+                                 const char *desc) {
+  CHECK_LT(n_flags_, kMaxFlags);
+  flags_[n_flags_].name = name;
+  flags_[n_flags_].desc = desc;
+  flags_[n_flags_].handler = handler;
+  ++n_flags_;
+}
+
+FlagParser::FlagParser() : n_flags_(0), buf_(nullptr), pos_(0) {
+  flags_ = (Flag *)Alloc.Allocate(sizeof(Flag) * kMaxFlags);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h
new file mode 100644
index 0000000..2477aed
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h
@@ -0,0 +1,122 @@
+//===-- sanitizer_flag_parser.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_FLAG_REGISTRY_H
+#define SANITIZER_FLAG_REGISTRY_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+
+class FlagHandlerBase {
+ public:
+  virtual bool Parse(const char *value) { return false; }
+};
+
+template <typename T>
+class FlagHandler : public FlagHandlerBase {
+  T *t_;
+
+ public:
+  explicit FlagHandler(T *t) : t_(t) {}
+  bool Parse(const char *value) final;
+};
+
+template <>
+inline bool FlagHandler<bool>::Parse(const char *value) {
+  if (internal_strcmp(value, "0") == 0 ||
+      internal_strcmp(value, "no") == 0 ||
+      internal_strcmp(value, "false") == 0) {
+    *t_ = false;
+    return true;
+  }
+  if (internal_strcmp(value, "1") == 0 ||
+      internal_strcmp(value, "yes") == 0 ||
+      internal_strcmp(value, "true") == 0) {
+    *t_ = true;
+    return true;
+  }
+  Printf("ERROR: Invalid value for bool option: '%s'\n", value);
+  return false;
+}
+
+template <>
+inline bool FlagHandler<const char *>::Parse(const char *value) {
+  *t_ = internal_strdup(value);
+  return true;
+}
+
+template <>
+inline bool FlagHandler<int>::Parse(const char *value) {
+  char *value_end;
+  *t_ = internal_simple_strtoll(value, &value_end, 10);
+  bool ok = *value_end == 0;
+  if (!ok) Printf("ERROR: Invalid value for int option: '%s'\n", value);
+  return ok;
+}
+
+template <>
+inline bool FlagHandler<uptr>::Parse(const char *value) {
+  char *value_end;
+  *t_ = internal_simple_strtoll(value, &value_end, 10);
+  bool ok = *value_end == 0;
+  if (!ok) Printf("ERROR: Invalid value for uptr option: '%s'\n", value);
+  return ok;
+}
+
+class FlagParser {
+  static const int kMaxFlags = 200;
+  struct Flag {
+    const char *name;
+    const char *desc;
+    FlagHandlerBase *handler;
+  } *flags_;
+  int n_flags_;
+
+  const char *buf_;
+  uptr pos_;
+
+ public:
+  FlagParser();
+  void RegisterHandler(const char *name, FlagHandlerBase *handler,
+                       const char *desc);
+  void ParseString(const char *s);
+  bool ParseFile(const char *path, bool ignore_missing);
+  void PrintFlagDescriptions();
+
+  static LowLevelAllocator Alloc;
+
+ private:
+  void fatal_error(const char *err);
+  bool is_space(char c);
+  void skip_whitespace();
+  void parse_flags();
+  void parse_flag();
+  bool run_handler(const char *name, const char *value);
+  char *ll_strndup(const char *s, uptr n);
+};
+
+template <typename T>
+static void RegisterFlag(FlagParser *parser, const char *name, const char *desc,
+                         T *var) {
+  FlagHandler<T> *fh = new (FlagParser::Alloc) FlagHandler<T>(var);  // NOLINT
+  parser->RegisterHandler(name, fh, desc);
+}
+
+void ReportUnrecognizedFlags();
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FLAG_REGISTRY_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc b/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc
new file mode 100644
index 0000000..18b9ea3
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc
@@ -0,0 +1,102 @@
+//===-- sanitizer_flags.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_flags.h"
+
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_list.h"
+#include "sanitizer_flag_parser.h"
+
+namespace __sanitizer {
+
+CommonFlags common_flags_dont_use;
+
+struct FlagDescription {
+  const char *name;
+  const char *description;
+  FlagDescription *next;
+};
+
+IntrusiveList<FlagDescription> flag_descriptions;
+
+// If set, the tool will install its own SEGV signal handler by default.
+#ifndef SANITIZER_NEEDS_SEGV
+# define SANITIZER_NEEDS_SEGV 1
+#endif
+
+void CommonFlags::SetDefaults() {
+#define COMMON_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "sanitizer_flags.inc"
+#undef COMMON_FLAG
+}
+
+void CommonFlags::CopyFrom(const CommonFlags &other) {
+  internal_memcpy(this, &other, sizeof(*this));
+}
+
+// Copy the string from "s" to "out", replacing "%b" with the binary basename.
+static void SubstituteBinaryName(const char *s, char *out, uptr out_size) {
+  char *out_end = out + out_size;
+  while (*s && out < out_end - 1) {
+    if (s[0] != '%' || s[1] != 'b') { *out++ = *s++; continue; }
+    const char *base = GetProcessName();
+    CHECK(base);
+    while (*base && out < out_end - 1)
+      *out++ = *base++;
+    s += 2; // skip "%b"
+  }
+  *out = '\0';
+}
+
+class FlagHandlerInclude : public FlagHandlerBase {
+  FlagParser *parser_;
+  bool ignore_missing_;
+
+ public:
+  explicit FlagHandlerInclude(FlagParser *parser, bool ignore_missing)
+      : parser_(parser), ignore_missing_(ignore_missing) {}
+  bool Parse(const char *value) final {
+    if (internal_strchr(value, '%')) {
+      char *buf = (char *)MmapOrDie(kMaxPathLength, "FlagHandlerInclude");
+      SubstituteBinaryName(value, buf, kMaxPathLength);
+      bool res = parser_->ParseFile(buf, ignore_missing_);
+      UnmapOrDie(buf, kMaxPathLength);
+      return res;
+    }
+    return parser_->ParseFile(value, ignore_missing_);
+  }
+};
+
+void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf) {
+  FlagHandlerInclude *fh_include = new (FlagParser::Alloc) // NOLINT
+      FlagHandlerInclude(parser, /*ignore_missing*/ false);
+  parser->RegisterHandler("include", fh_include,
+                          "read more options from the given file");
+  FlagHandlerInclude *fh_include_if_exists = new (FlagParser::Alloc) // NOLINT
+      FlagHandlerInclude(parser, /*ignore_missing*/ true);
+  parser->RegisterHandler(
+      "include_if_exists", fh_include_if_exists,
+      "read more options from the given file (if it exists)");
+}
+
+void RegisterCommonFlags(FlagParser *parser, CommonFlags *cf) {
+#define COMMON_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &cf->Name);
+#include "sanitizer_flags.inc"
+#undef COMMON_FLAG
+
+  RegisterIncludeFlags(parser, cf);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flags.h b/compiler-rt/lib/sanitizer_common/sanitizer_flags.h
new file mode 100644
index 0000000..33c3c45
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flags.h
@@ -0,0 +1,55 @@
+//===-- sanitizer_flags.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_FLAGS_H
+#define SANITIZER_FLAGS_H
+
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+struct CommonFlags {
+#define COMMON_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "sanitizer_flags.inc"
+#undef COMMON_FLAG
+
+  void SetDefaults();
+  void CopyFrom(const CommonFlags &other);
+};
+
+// Functions to get/set global CommonFlags shared by all sanitizer runtimes:
+extern CommonFlags common_flags_dont_use;
+inline const CommonFlags *common_flags() {
+  return &common_flags_dont_use;
+}
+
+inline void SetCommonFlagsDefaults() {
+  common_flags_dont_use.SetDefaults();
+}
+
+// This function can only be used to setup tool-specific overrides for
+// CommonFlags defaults. Generally, it should only be used right after
+// SetCommonFlagsDefaults(), but before ParseCommonFlagsFromString(), and
+// only during the flags initialization (i.e. before they are used for
+// the first time).
+inline void OverrideCommonFlags(const CommonFlags &cf) {
+  common_flags_dont_use.CopyFrom(cf);
+}
+
+class FlagParser;
+void RegisterCommonFlags(FlagParser *parser,
+                         CommonFlags *cf = &common_flags_dont_use);
+void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf);
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FLAGS_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc b/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc
new file mode 100644
index 0000000..c892731
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc
@@ -0,0 +1,199 @@
+//===-- sanitizer_flags.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file describes common flags available in all sanitizers.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef COMMON_FLAG
+#error "Define COMMON_FLAG prior to including this file!"
+#endif
+
+// COMMON_FLAG(Type, Name, DefaultValue, Description)
+// Supported types: bool, const char *, int, uptr.
+// Default value must be a compile-time constant.
+// Description must be a string literal.
+
+COMMON_FLAG(
+    bool, symbolize, true,
+    "If set, use the online symbolizer from common sanitizer runtime to turn "
+    "virtual addresses to file/line locations.")
+COMMON_FLAG(
+    const char *, external_symbolizer_path, nullptr,
+    "Path to external symbolizer. If empty, the tool will search $PATH for "
+    "the symbolizer.")
+COMMON_FLAG(
+    bool, allow_addr2line, false,
+    "If set, allows online symbolizer to run addr2line binary to symbolize "
+    "stack traces (addr2line will only be used if llvm-symbolizer binary is "
+    "unavailable.")
+COMMON_FLAG(const char *, strip_path_prefix, "",
+            "Strips this prefix from file paths in error reports.")
+COMMON_FLAG(bool, fast_unwind_on_check, false,
+            "If available, use the fast frame-pointer-based unwinder on "
+            "internal CHECK failures.")
+COMMON_FLAG(bool, fast_unwind_on_fatal, false,
+            "If available, use the fast frame-pointer-based unwinder on fatal "
+            "errors.")
+COMMON_FLAG(bool, fast_unwind_on_malloc, true,
+            "If available, use the fast frame-pointer-based unwinder on "
+            "malloc/free.")
+COMMON_FLAG(bool, handle_ioctl, false, "Intercept and handle ioctl requests.")
+COMMON_FLAG(int, malloc_context_size, 1,
+            "Max number of stack frames kept for each allocation/deallocation.")
+COMMON_FLAG(
+    const char *, log_path, "stderr",
+    "Write logs to \"log_path.pid\". The special values are \"stdout\" and "
+    "\"stderr\". The default is \"stderr\".")
+COMMON_FLAG(
+    bool, log_exe_name, false,
+    "Mention name of executable when reporting error and "
+    "append executable name to logs (as in \"log_path.exe_name.pid\").")
+COMMON_FLAG(
+    bool, log_to_syslog, SANITIZER_ANDROID || SANITIZER_MAC,
+    "Write all sanitizer output to syslog in addition to other means of "
+    "logging.")
+COMMON_FLAG(
+    int, verbosity, 0,
+    "Verbosity level (0 - silent, 1 - a bit of output, 2+ - more output).")
+COMMON_FLAG(bool, detect_leaks, true, "Enable memory leak detection.")
+COMMON_FLAG(
+    bool, leak_check_at_exit, true,
+    "Invoke leak checking in an atexit handler. Has no effect if "
+    "detect_leaks=false, or if __lsan_do_leak_check() is called before the "
+    "handler has a chance to run.")
+COMMON_FLAG(bool, allocator_may_return_null, false,
+            "If false, the allocator will crash instead of returning 0 on "
+            "out-of-memory.")
+COMMON_FLAG(bool, print_summary, true,
+            "If false, disable printing error summaries in addition to error "
+            "reports.")
+COMMON_FLAG(bool, check_printf, true, "Check printf arguments.")
+COMMON_FLAG(bool, handle_segv, SANITIZER_NEEDS_SEGV,
+            "If set, registers the tool's custom SIGSEGV/SIGBUS handler.")
+COMMON_FLAG(bool, handle_abort, false,
+            "If set, registers the tool's custom SIGABRT handler.")
+COMMON_FLAG(bool, handle_sigill, false,
+            "If set, registers the tool's custom SIGILL handler.")
+COMMON_FLAG(bool, handle_sigfpe, true,
+            "If set, registers the tool's custom SIGFPE handler.")
+COMMON_FLAG(bool, allow_user_segv_handler, false,
+            "If set, allows user to register a SEGV handler even if the tool "
+            "registers one.")
+COMMON_FLAG(bool, use_sigaltstack, true,
+            "If set, uses alternate stack for signal handling.")
+COMMON_FLAG(bool, detect_deadlocks, false,
+            "If set, deadlock detection is enabled.")
+COMMON_FLAG(
+    uptr, clear_shadow_mmap_threshold, 64 * 1024,
+    "Large shadow regions are zero-filled using mmap(NORESERVE) instead of "
+    "memset(). This is the threshold size in bytes.")
+COMMON_FLAG(const char *, color, "auto",
+            "Colorize reports: (always|never|auto).")
+COMMON_FLAG(
+    bool, legacy_pthread_cond, false,
+    "Enables support for dynamic libraries linked with libpthread 2.2.5.")
+COMMON_FLAG(bool, intercept_tls_get_addr, false, "Intercept __tls_get_addr.")
+COMMON_FLAG(bool, help, false, "Print the flag descriptions.")
+COMMON_FLAG(uptr, mmap_limit_mb, 0,
+            "Limit the amount of mmap-ed memory (excluding shadow) in Mb; "
+            "not a user-facing flag, used mosly for testing the tools")
+COMMON_FLAG(uptr, hard_rss_limit_mb, 0,
+            "Hard RSS limit in Mb."
+            " If non-zero, a background thread is spawned at startup"
+            " which periodically reads RSS and aborts the process if the"
+            " limit is reached")
+COMMON_FLAG(uptr, soft_rss_limit_mb, 0,
+            "Soft RSS limit in Mb."
+            " If non-zero, a background thread is spawned at startup"
+            " which periodically reads RSS. If the limit is reached"
+            " all subsequent malloc/new calls will fail or return NULL"
+            " (depending on the value of allocator_may_return_null)"
+            " until the RSS goes below the soft limit."
+            " This limit does not affect memory allocations other than"
+            " malloc/new.")
+COMMON_FLAG(bool, can_use_proc_maps_statm, true,
+            "If false, do not attempt to read /proc/maps/statm."
+            " Mostly useful for testing sanitizers.")
+COMMON_FLAG(
+    bool, coverage, false,
+    "If set, coverage information will be dumped at program shutdown (if the "
+    "coverage instrumentation was enabled at compile time).")
+COMMON_FLAG(bool, coverage_pcs, true,
+            "If set (and if 'coverage' is set too), the coverage information "
+            "will be dumped as a set of PC offsets for every module.")
+COMMON_FLAG(bool, coverage_order_pcs, false,
+             "If true, the PCs will be dumped in the order they've"
+             " appeared during the execution.")
+COMMON_FLAG(bool, coverage_bitset, false,
+            "If set (and if 'coverage' is set too), the coverage information "
+            "will also be dumped as a bitset to a separate file.")
+COMMON_FLAG(bool, coverage_counters, false,
+            "If set (and if 'coverage' is set too), the bitmap that corresponds"
+            " to coverage counters will be dumped.")
+COMMON_FLAG(bool, coverage_direct, SANITIZER_ANDROID,
+            "If set, coverage information will be dumped directly to a memory "
+            "mapped file. This way data is not lost even if the process is "
+            "suddenly killed.")
+COMMON_FLAG(const char *, coverage_dir, ".",
+            "Target directory for coverage dumps. Defaults to the current "
+            "directory.")
+COMMON_FLAG(bool, full_address_space, false,
+            "Sanitize complete address space; "
+            "by default kernel area on 32-bit platforms will not be sanitized")
+COMMON_FLAG(bool, print_suppressions, true,
+            "Print matched suppressions at exit.")
+COMMON_FLAG(
+    bool, disable_coredump, (SANITIZER_WORDSIZE == 64),
+    "Disable core dumping. By default, disable_core=1 on 64-bit to avoid "
+    "dumping a 16T+ core file. Ignored on OSes that don't dump core by"
+    "default and for sanitizers that don't reserve lots of virtual memory.")
+COMMON_FLAG(bool, use_madv_dontdump, true,
+          "If set, instructs kernel to not store the (huge) shadow "
+          "in core file.")
+COMMON_FLAG(bool, symbolize_inline_frames, true,
+            "Print inlined frames in stacktraces. Defaults to true.")
+COMMON_FLAG(bool, symbolize_vs_style, false,
+            "Print file locations in Visual Studio style (e.g: "
+            " file(10,42): ...")
+COMMON_FLAG(const char *, stack_trace_format, "DEFAULT",
+            "Format string used to render stack frames. "
+            "See sanitizer_stacktrace_printer.h for the format description. "
+            "Use DEFAULT to get default format.")
+COMMON_FLAG(bool, no_huge_pages_for_shadow, true,
+            "If true, the shadow is not allowed to use huge pages. ")
+COMMON_FLAG(bool, strict_string_checks, false,
+            "If set check that string arguments are properly null-terminated")
+COMMON_FLAG(bool, intercept_strstr, true,
+            "If set, uses custom wrappers for strstr and strcasestr functions "
+            "to find more errors.")
+COMMON_FLAG(bool, intercept_strspn, true,
+            "If set, uses custom wrappers for strspn and strcspn function "
+            "to find more errors.")
+COMMON_FLAG(bool, intercept_strpbrk, true,
+            "If set, uses custom wrappers for strpbrk function "
+            "to find more errors.")
+COMMON_FLAG(bool, intercept_memcmp, true,
+            "If set, uses custom wrappers for memcmp function "
+            "to find more errors.")
+COMMON_FLAG(bool, strict_memcmp, true,
+          "If true, assume that memcmp(p1, p2, n) always reads n bytes before "
+          "comparing p1 and p2.")
+COMMON_FLAG(bool, decorate_proc_maps, false, "If set, decorate sanitizer "
+                                             "mappings in /proc/self/maps with "
+                                             "user-readable names")
+COMMON_FLAG(int, exitcode, 1, "Override the program exit status if the tool "
+                              "found an error")
+COMMON_FLAG(
+    bool, abort_on_error, SANITIZER_MAC,
+    "If set, the tool calls abort() instead of _exit() after printing the "
+    "error report.")
+COMMON_FLAG(bool, suppress_equal_pcs, true,
+            "Deduplicate multiple reports for single source location in "
+            "halt_on_error=false mode (asan only).")
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_freebsd.h b/compiler-rt/lib/sanitizer_common/sanitizer_freebsd.h
new file mode 100644
index 0000000..c9bba80
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_freebsd.h
@@ -0,0 +1,137 @@
+//===-- sanitizer_freebsd.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime. It contains FreeBSD-specific
+// definitions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_FREEBSD_H
+#define SANITIZER_FREEBSD_H
+
+#include "sanitizer_internal_defs.h"
+
+// x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in
+// 32-bit mode.
+#if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
+# include <osreldate.h>
+# if __FreeBSD_version <= 902001  // v9.2
+#  include <link.h>
+#  include <sys/param.h>
+#  include <ucontext.h>
+
+namespace __sanitizer {
+
+typedef unsigned long long __xuint64_t;
+
+typedef __int32_t __xregister_t;
+
+typedef struct __xmcontext {
+  __xregister_t mc_onstack;
+  __xregister_t mc_gs;
+  __xregister_t mc_fs;
+  __xregister_t mc_es;
+  __xregister_t mc_ds;
+  __xregister_t mc_edi;
+  __xregister_t mc_esi;
+  __xregister_t mc_ebp;
+  __xregister_t mc_isp;
+  __xregister_t mc_ebx;
+  __xregister_t mc_edx;
+  __xregister_t mc_ecx;
+  __xregister_t mc_eax;
+  __xregister_t mc_trapno;
+  __xregister_t mc_err;
+  __xregister_t mc_eip;
+  __xregister_t mc_cs;
+  __xregister_t mc_eflags;
+  __xregister_t mc_esp;
+  __xregister_t mc_ss;
+
+  int mc_len;
+  int mc_fpformat;
+  int mc_ownedfp;
+  __xregister_t mc_flags;
+
+  int mc_fpstate[128] __aligned(16);
+  __xregister_t mc_fsbase;
+  __xregister_t mc_gsbase;
+  __xregister_t mc_xfpustate;
+  __xregister_t mc_xfpustate_len;
+
+  int mc_spare2[4];
+} xmcontext_t;
+
+typedef struct __xucontext {
+  sigset_t  uc_sigmask;
+  xmcontext_t  uc_mcontext;
+
+  struct __ucontext *uc_link;
+  stack_t uc_stack;
+  int uc_flags;
+  int __spare__[4];
+} xucontext_t;
+
+struct xkinfo_vmentry {
+  int kve_structsize;
+  int kve_type;
+  __xuint64_t kve_start;
+  __xuint64_t kve_end;
+  __xuint64_t kve_offset;
+  __xuint64_t kve_vn_fileid;
+  __uint32_t kve_vn_fsid;
+  int kve_flags;
+  int kve_resident;
+  int kve_private_resident;
+  int kve_protection;
+  int kve_ref_count;
+  int kve_shadow_count;
+  int kve_vn_type;
+  __xuint64_t kve_vn_size;
+  __uint32_t kve_vn_rdev;
+  __uint16_t kve_vn_mode;
+  __uint16_t kve_status;
+  int _kve_ispare[12];
+  char kve_path[PATH_MAX];
+};
+
+typedef struct {
+  __uint32_t p_type;
+  __uint32_t p_offset;
+  __uint32_t p_vaddr;
+  __uint32_t p_paddr;
+  __uint32_t p_filesz;
+  __uint32_t p_memsz;
+  __uint32_t p_flags;
+  __uint32_t p_align;
+} XElf32_Phdr;
+
+struct xdl_phdr_info {
+  Elf_Addr dlpi_addr;
+  const char *dlpi_name;
+  const XElf32_Phdr *dlpi_phdr;
+  Elf_Half dlpi_phnum;
+  unsigned long long int dlpi_adds;
+  unsigned long long int dlpi_subs;
+  size_t dlpi_tls_modid;
+  void *dlpi_tls_data;
+};
+
+typedef int (*__xdl_iterate_hdr_callback)(struct xdl_phdr_info*, size_t, void*);
+typedef int xdl_iterate_phdr_t(__xdl_iterate_hdr_callback, void*);
+
+#define xdl_iterate_phdr(callback, param) \
+  (((xdl_iterate_phdr_t*) dl_iterate_phdr)((callback), (param)))
+
+}  // namespace __sanitizer
+
+# endif  // __FreeBSD_version <= 902001
+#endif  // SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
+
+#endif  // SANITIZER_FREEBSD_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_interface_internal.h b/compiler-rt/lib/sanitizer_common/sanitizer_interface_internal.h
new file mode 100644
index 0000000..b11ae30
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_interface_internal.h
@@ -0,0 +1,61 @@
+//===-- sanitizer_interface_internal.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between run-time libraries of sanitizers.
+//
+// This header declares the sanitizer runtime interface functions.
+// The runtime library has to define these functions so the instrumented program
+// could call them.
+//
+// See also include/sanitizer/common_interface_defs.h
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_INTERFACE_INTERNAL_H
+#define SANITIZER_INTERFACE_INTERNAL_H
+
+#include "sanitizer_internal_defs.h"
+
+extern "C" {
+  // Tell the tools to write their reports to "path.<pid>" instead of stderr.
+  // The special values are "stdout" and "stderr".
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __sanitizer_set_report_path(const char *path);
+
+  typedef struct {
+      int coverage_sandboxed;
+      __sanitizer::sptr coverage_fd;
+      unsigned int coverage_max_block_size;
+  } __sanitizer_sandbox_arguments;
+
+  // Notify the tools that the sandbox is going to be turned on.
+  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
+      __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args);
+
+  // This function is called by the tool when it has just finished reporting
+  // an error. 'error_summary' is a one-line string that summarizes
+  // the error message. This function can be overridden by the client.
+  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+  void __sanitizer_report_error_summary(const char *error_summary);
+
+  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump();
+  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_init();
+  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov(__sanitizer::u32 *guard);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __sanitizer_annotate_contiguous_container(const void *beg,
+                                                 const void *end,
+                                                 const void *old_mid,
+                                                 const void *new_mid);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  int __sanitizer_verify_contiguous_container(const void *beg, const void *mid,
+                                              const void *end);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  const void *__sanitizer_contiguous_container_find_bad_address(
+      const void *beg, const void *mid, const void *end);
+  } // extern "C"
+
+#endif  // SANITIZER_INTERFACE_INTERNAL_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h b/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h
new file mode 100644
index 0000000..e83eed0
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h
@@ -0,0 +1,316 @@
+//===-- sanitizer_internal_defs.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer.
+// It contains macro used in run-time libraries code.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_DEFS_H
+#define SANITIZER_DEFS_H
+
+#include "sanitizer_platform.h"
+
+#ifndef SANITIZER_DEBUG
+# define SANITIZER_DEBUG 0
+#endif
+
+// Only use SANITIZER_*ATTRIBUTE* before the function return type!
+#if SANITIZER_WINDOWS
+# define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllexport)
+// FIXME find out what we need on Windows, if anything.
+# define SANITIZER_WEAK_ATTRIBUTE
+#elif defined(SANITIZER_GO)
+# define SANITIZER_INTERFACE_ATTRIBUTE
+# define SANITIZER_WEAK_ATTRIBUTE
+#else
+# define SANITIZER_INTERFACE_ATTRIBUTE __attribute__((visibility("default")))
+# define SANITIZER_WEAK_ATTRIBUTE  __attribute__((weak))
+#endif
+
+#if (SANITIZER_LINUX || SANITIZER_WINDOWS) && !defined(SANITIZER_GO)
+# define SANITIZER_SUPPORTS_WEAK_HOOKS 1
+#else
+# define SANITIZER_SUPPORTS_WEAK_HOOKS 0
+#endif
+
+// We can use .preinit_array section on Linux to call sanitizer initialization
+// functions very early in the process startup (unless PIC macro is defined).
+// FIXME: do we have anything like this on Mac?
+#if SANITIZER_LINUX && !SANITIZER_ANDROID && !defined(PIC)
+# define SANITIZER_CAN_USE_PREINIT_ARRAY 1
+#else
+# define SANITIZER_CAN_USE_PREINIT_ARRAY 0
+#endif
+
+// GCC does not understand __has_feature
+#if !defined(__has_feature)
+# define __has_feature(x) 0
+#endif
+
+// For portability reasons we do not include stddef.h, stdint.h or any other
+// system header, but we do need some basic types that are not defined
+// in a portable way by the language itself.
+namespace __sanitizer {
+
+#if defined(_WIN64)
+// 64-bit Windows uses LLP64 data model.
+typedef unsigned long long uptr;  // NOLINT
+typedef signed   long long sptr;  // NOLINT
+#else
+typedef unsigned long uptr;  // NOLINT
+typedef signed   long sptr;  // NOLINT
+#endif  // defined(_WIN64)
+#if defined(__x86_64__)
+// Since x32 uses ILP32 data model in 64-bit hardware mode, we must use
+// 64-bit pointer to unwind stack frame.
+typedef unsigned long long uhwptr;  // NOLINT
+#else
+typedef uptr uhwptr;   // NOLINT
+#endif
+typedef unsigned char u8;
+typedef unsigned short u16;  // NOLINT
+typedef unsigned int u32;
+typedef unsigned long long u64;  // NOLINT
+typedef signed   char s8;
+typedef signed   short s16;  // NOLINT
+typedef signed   int s32;
+typedef signed   long long s64;  // NOLINT
+#if SANITIZER_WINDOWS
+// On Windows, files are HANDLE, which is a synonim of void*.
+// Use void* to avoid including <windows.h> everywhere.
+typedef void* fd_t;
+typedef unsigned error_t;
+#else
+typedef int fd_t;
+typedef int error_t;
+#endif
+
+// WARNING: OFF_T may be different from OS type off_t, depending on the value of
+// _FILE_OFFSET_BITS. This definition of OFF_T matches the ABI of system calls
+// like pread and mmap, as opposed to pread64 and mmap64.
+// FreeBSD, Mac and Linux/x86-64 are special.
+#if SANITIZER_FREEBSD || SANITIZER_MAC || \
+  (SANITIZER_LINUX && defined(__x86_64__))
+typedef u64 OFF_T;
+#else
+typedef uptr OFF_T;
+#endif
+typedef u64  OFF64_T;
+
+#if (SANITIZER_WORDSIZE == 64) || SANITIZER_MAC
+typedef uptr operator_new_size_type;
+#else
+typedef u32 operator_new_size_type;
+#endif
+}  // namespace __sanitizer
+
+
+using namespace __sanitizer;  // NOLINT
+// ----------- ATTENTION -------------
+// This header should NOT include any other headers to avoid portability issues.
+
+// Common defs.
+#define INLINE inline
+#define INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
+#define SANITIZER_WEAK_DEFAULT_IMPL \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE
+#define SANITIZER_WEAK_CXX_DEFAULT_IMPL \
+  extern "C++" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE
+
+// Platform-specific defs.
+#if defined(_MSC_VER)
+# define ALWAYS_INLINE __forceinline
+// FIXME(timurrrr): do we need this on Windows?
+# define ALIAS(x)
+# define ALIGNED(x) __declspec(align(x))
+# define FORMAT(f, a)
+# define NOINLINE __declspec(noinline)
+# define NORETURN __declspec(noreturn)
+# define THREADLOCAL   __declspec(thread)
+# define LIKELY(x) (x)
+# define UNLIKELY(x) (x)
+# define PREFETCH(x) /* _mm_prefetch(x, _MM_HINT_NTA) */
+#else  // _MSC_VER
+# define ALWAYS_INLINE inline __attribute__((always_inline))
+# define ALIAS(x) __attribute__((alias(x)))
+// Please only use the ALIGNED macro before the type.
+// Using ALIGNED after the variable declaration is not portable!
+# define ALIGNED(x) __attribute__((aligned(x)))
+# define FORMAT(f, a)  __attribute__((format(printf, f, a)))
+# define NOINLINE __attribute__((noinline))
+# define NORETURN  __attribute__((noreturn))
+# define THREADLOCAL   __thread
+# define LIKELY(x)     __builtin_expect(!!(x), 1)
+# define UNLIKELY(x)   __builtin_expect(!!(x), 0)
+# if defined(__i386__) || defined(__x86_64__)
+// __builtin_prefetch(x) generates prefetchnt0 on x86
+#  define PREFETCH(x) __asm__("prefetchnta (%0)" : : "r" (x))
+# else
+#  define PREFETCH(x) __builtin_prefetch(x)
+# endif
+#endif  // _MSC_VER
+
+#if !defined(_MSC_VER) || defined(__clang__)
+# define UNUSED __attribute__((unused))
+# define USED __attribute__((used))
+#else
+# define UNUSED
+# define USED
+#endif
+
+#if !defined(_MSC_VER) || defined(__clang__) || MSC_PREREQ(1900)
+# define NOEXCEPT noexcept
+#else
+# define NOEXCEPT throw()
+#endif
+
+// Unaligned versions of basic types.
+typedef ALIGNED(1) u16 uu16;
+typedef ALIGNED(1) u32 uu32;
+typedef ALIGNED(1) u64 uu64;
+typedef ALIGNED(1) s16 us16;
+typedef ALIGNED(1) s32 us32;
+typedef ALIGNED(1) s64 us64;
+
+#if SANITIZER_WINDOWS
+typedef unsigned long DWORD;  // NOLINT
+typedef DWORD thread_return_t;
+# define THREAD_CALLING_CONV __stdcall
+#else  // _WIN32
+typedef void* thread_return_t;
+# define THREAD_CALLING_CONV
+#endif  // _WIN32
+typedef thread_return_t (THREAD_CALLING_CONV *thread_callback_t)(void* arg);
+
+// NOTE: Functions below must be defined in each run-time.
+namespace __sanitizer {
+void NORETURN Die();
+
+// FIXME: No, this shouldn't be in the sanitizer interface.
+SANITIZER_INTERFACE_ATTRIBUTE
+void NORETURN CheckFailed(const char *file, int line, const char *cond,
+                          u64 v1, u64 v2);
+}  // namespace __sanitizer
+
+// Check macro
+#define RAW_CHECK_MSG(expr, msg) do { \
+  if (UNLIKELY(!(expr))) { \
+    RawWrite(msg); \
+    Die(); \
+  } \
+} while (0)
+
+#define RAW_CHECK(expr) RAW_CHECK_MSG(expr, #expr)
+
+#define CHECK_IMPL(c1, op, c2) \
+  do { \
+    __sanitizer::u64 v1 = (u64)(c1); \
+    __sanitizer::u64 v2 = (u64)(c2); \
+    if (UNLIKELY(!(v1 op v2))) \
+      __sanitizer::CheckFailed(__FILE__, __LINE__, \
+        "(" #c1 ") " #op " (" #c2 ")", v1, v2); \
+  } while (false) \
+/**/
+
+#define CHECK(a)       CHECK_IMPL((a), !=, 0)
+#define CHECK_EQ(a, b) CHECK_IMPL((a), ==, (b))
+#define CHECK_NE(a, b) CHECK_IMPL((a), !=, (b))
+#define CHECK_LT(a, b) CHECK_IMPL((a), <,  (b))
+#define CHECK_LE(a, b) CHECK_IMPL((a), <=, (b))
+#define CHECK_GT(a, b) CHECK_IMPL((a), >,  (b))
+#define CHECK_GE(a, b) CHECK_IMPL((a), >=, (b))
+
+#if SANITIZER_DEBUG
+#define DCHECK(a)       CHECK(a)
+#define DCHECK_EQ(a, b) CHECK_EQ(a, b)
+#define DCHECK_NE(a, b) CHECK_NE(a, b)
+#define DCHECK_LT(a, b) CHECK_LT(a, b)
+#define DCHECK_LE(a, b) CHECK_LE(a, b)
+#define DCHECK_GT(a, b) CHECK_GT(a, b)
+#define DCHECK_GE(a, b) CHECK_GE(a, b)
+#else
+#define DCHECK(a)
+#define DCHECK_EQ(a, b)
+#define DCHECK_NE(a, b)
+#define DCHECK_LT(a, b)
+#define DCHECK_LE(a, b)
+#define DCHECK_GT(a, b)
+#define DCHECK_GE(a, b)
+#endif
+
+#define UNREACHABLE(msg) do { \
+  CHECK(0 && msg); \
+  Die(); \
+} while (0)
+
+#define UNIMPLEMENTED() UNREACHABLE("unimplemented")
+
+#define COMPILER_CHECK(pred) IMPL_COMPILER_ASSERT(pred, __LINE__)
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
+
+#define IMPL_PASTE(a, b) a##b
+#define IMPL_COMPILER_ASSERT(pred, line) \
+    typedef char IMPL_PASTE(assertion_failed_##_, line)[2*(int)(pred)-1]
+
+// Limits for integral types. We have to redefine it in case we don't
+// have stdint.h (like in Visual Studio 9).
+#undef __INT64_C
+#undef __UINT64_C
+#if SANITIZER_WORDSIZE == 64
+# define __INT64_C(c)  c ## L
+# define __UINT64_C(c) c ## UL
+#else
+# define __INT64_C(c)  c ## LL
+# define __UINT64_C(c) c ## ULL
+#endif  // SANITIZER_WORDSIZE == 64
+#undef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#undef INT32_MAX
+#define INT32_MAX              (2147483647)
+#undef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#undef INT64_MIN
+#define INT64_MIN              (-__INT64_C(9223372036854775807)-1)
+#undef INT64_MAX
+#define INT64_MAX              (__INT64_C(9223372036854775807))
+#undef UINT64_MAX
+#define UINT64_MAX             (__UINT64_C(18446744073709551615))
+
+enum LinkerInitialized { LINKER_INITIALIZED = 0 };
+
+#if !defined(_MSC_VER) || defined(__clang__)
+# define GET_CALLER_PC() (uptr)__builtin_return_address(0)
+# define GET_CURRENT_FRAME() (uptr)__builtin_frame_address(0)
+#else
+extern "C" void* _ReturnAddress(void);
+# pragma intrinsic(_ReturnAddress)
+# define GET_CALLER_PC() (uptr)_ReturnAddress()
+// CaptureStackBackTrace doesn't need to know BP on Windows.
+// FIXME: This macro is still used when printing error reports though it's not
+// clear if the BP value is needed in the ASan reports on Windows.
+# define GET_CURRENT_FRAME() (uptr)0xDEADBEEF
+#endif
+
+#define HANDLE_EINTR(res, f)                                       \
+  {                                                                \
+    int rverrno;                                                   \
+    do {                                                           \
+      res = (f);                                                   \
+    } while (internal_iserror(res, &rverrno) && rverrno == EINTR); \
+  }
+
+// Forces the compiler to generate a frame pointer in the function.
+#define ENABLE_FRAME_POINTER                                       \
+  do {                                                             \
+    volatile uptr enable_fp;                                       \
+    enable_fp = GET_CURRENT_FRAME();                               \
+    (void)enable_fp;                                               \
+  } while (0)
+
+#endif  // SANITIZER_DEFS_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_lfstack.h b/compiler-rt/lib/sanitizer_common/sanitizer_lfstack.h
new file mode 100644
index 0000000..879cc80
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_lfstack.h
@@ -0,0 +1,73 @@
+//===-- sanitizer_lfstack.h -=-----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Lock-free stack.
+// Uses 32/17 bits as ABA-counter on 32/64-bit platforms.
+// The memory passed to Push() must not be ever munmap'ed.
+// The type T must contain T *next field.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_LFSTACK_H
+#define SANITIZER_LFSTACK_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_common.h"
+#include "sanitizer_atomic.h"
+
+namespace __sanitizer {
+
+template<typename T>
+struct LFStack {
+  void Clear() {
+    atomic_store(&head_, 0, memory_order_relaxed);
+  }
+
+  bool Empty() const {
+    return (atomic_load(&head_, memory_order_relaxed) & kPtrMask) == 0;
+  }
+
+  void Push(T *p) {
+    u64 cmp = atomic_load(&head_, memory_order_relaxed);
+    for (;;) {
+      u64 cnt = (cmp & kCounterMask) + kCounterInc;
+      u64 xch = (u64)(uptr)p | cnt;
+      p->next = (T*)(uptr)(cmp & kPtrMask);
+      if (atomic_compare_exchange_weak(&head_, &cmp, xch,
+                                       memory_order_release))
+        break;
+    }
+  }
+
+  T *Pop() {
+    u64 cmp = atomic_load(&head_, memory_order_acquire);
+    for (;;) {
+      T *cur = (T*)(uptr)(cmp & kPtrMask);
+      if (!cur)
+        return nullptr;
+      T *nxt = cur->next;
+      u64 cnt = (cmp & kCounterMask);
+      u64 xch = (u64)(uptr)nxt | cnt;
+      if (atomic_compare_exchange_weak(&head_, &cmp, xch,
+                                       memory_order_acquire))
+        return cur;
+    }
+  }
+
+  // private:
+  static const int kCounterBits = FIRST_32_SECOND_64(32, 17);
+  static const u64 kPtrMask = ((u64)-1) >> kCounterBits;
+  static const u64 kCounterMask = ~kPtrMask;
+  static const u64 kCounterInc = kPtrMask + 1;
+
+  atomic_uint64_t head_;
+};
+} // namespace __sanitizer
+
+#endif // SANITIZER_LFSTACK_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_libc.cc b/compiler-rt/lib/sanitizer_common/sanitizer_libc.cc
new file mode 100644
index 0000000..cf31e68
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_libc.cc
@@ -0,0 +1,287 @@
+//===-- sanitizer_libc.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries. See sanitizer_libc.h for details.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+
+namespace __sanitizer {
+
+s64 internal_atoll(const char *nptr) {
+  return internal_simple_strtoll(nptr, nullptr, 10);
+}
+
+void *internal_memchr(const void *s, int c, uptr n) {
+  const char *t = (const char *)s;
+  for (uptr i = 0; i < n; ++i, ++t)
+    if (*t == c)
+      return reinterpret_cast<void *>(const_cast<char *>(t));
+  return nullptr;
+}
+
+void *internal_memrchr(const void *s, int c, uptr n) {
+  const char *t = (const char *)s;
+  void *res = nullptr;
+  for (uptr i = 0; i < n; ++i, ++t) {
+    if (*t == c) res = reinterpret_cast<void *>(const_cast<char *>(t));
+  }
+  return res;
+}
+
+int internal_memcmp(const void* s1, const void* s2, uptr n) {
+  const char *t1 = (const char *)s1;
+  const char *t2 = (const char *)s2;
+  for (uptr i = 0; i < n; ++i, ++t1, ++t2)
+    if (*t1 != *t2)
+      return *t1 < *t2 ? -1 : 1;
+  return 0;
+}
+
+void *internal_memcpy(void *dest, const void *src, uptr n) {
+  char *d = (char*)dest;
+  const char *s = (const char *)src;
+  for (uptr i = 0; i < n; ++i)
+    d[i] = s[i];
+  return dest;
+}
+
+void *internal_memmove(void *dest, const void *src, uptr n) {
+  char *d = (char*)dest;
+  const char *s = (const char *)src;
+  sptr i, signed_n = (sptr)n;
+  CHECK_GE(signed_n, 0);
+  if (d < s) {
+    for (i = 0; i < signed_n; ++i)
+      d[i] = s[i];
+  } else {
+    if (d > s && signed_n > 0)
+      for (i = signed_n - 1; i >= 0 ; --i) {
+        d[i] = s[i];
+      }
+  }
+  return dest;
+}
+
+// Semi-fast bzero for 16-aligned data. Still far from peak performance.
+void internal_bzero_aligned16(void *s, uptr n) {
+  struct S16 { u64 a, b; } ALIGNED(16);
+  CHECK_EQ((reinterpret_cast<uptr>(s) | n) & 15, 0);
+  for (S16 *p = reinterpret_cast<S16*>(s), *end = p + n / 16; p < end; p++) {
+    p->a = p->b = 0;
+    // Make sure this does not become memset.
+    SanitizerBreakOptimization(nullptr);
+  }
+}
+
+void *internal_memset(void* s, int c, uptr n) {
+  // The next line prevents Clang from making a call to memset() instead of the
+  // loop below.
+  // FIXME: building the runtime with -ffreestanding is a better idea. However
+  // there currently are linktime problems due to PR12396.
+  char volatile *t = (char*)s;
+  for (uptr i = 0; i < n; ++i, ++t) {
+    *t = c;
+  }
+  return s;
+}
+
+uptr internal_strcspn(const char *s, const char *reject) {
+  uptr i;
+  for (i = 0; s[i]; i++) {
+    if (internal_strchr(reject, s[i]))
+      return i;
+  }
+  return i;
+}
+
+char* internal_strdup(const char *s) {
+  uptr len = internal_strlen(s);
+  char *s2 = (char*)InternalAlloc(len + 1);
+  internal_memcpy(s2, s, len);
+  s2[len] = 0;
+  return s2;
+}
+
+char* internal_strndup(const char *s, uptr n) {
+  uptr len = internal_strnlen(s, n);
+  char *s2 = (char*)InternalAlloc(len + 1);
+  internal_memcpy(s2, s, len);
+  s2[len] = 0;
+  return s2;
+}
+
+int internal_strcmp(const char *s1, const char *s2) {
+  while (true) {
+    unsigned c1 = *s1;
+    unsigned c2 = *s2;
+    if (c1 != c2) return (c1 < c2) ? -1 : 1;
+    if (c1 == 0) break;
+    s1++;
+    s2++;
+  }
+  return 0;
+}
+
+int internal_strncmp(const char *s1, const char *s2, uptr n) {
+  for (uptr i = 0; i < n; i++) {
+    unsigned c1 = *s1;
+    unsigned c2 = *s2;
+    if (c1 != c2) return (c1 < c2) ? -1 : 1;
+    if (c1 == 0) break;
+    s1++;
+    s2++;
+  }
+  return 0;
+}
+
+char* internal_strchr(const char *s, int c) {
+  while (true) {
+    if (*s == (char)c)
+      return const_cast<char *>(s);
+    if (*s == 0)
+      return nullptr;
+    s++;
+  }
+}
+
+char *internal_strchrnul(const char *s, int c) {
+  char *res = internal_strchr(s, c);
+  if (!res)
+    res = const_cast<char *>(s) + internal_strlen(s);
+  return res;
+}
+
+char *internal_strrchr(const char *s, int c) {
+  const char *res = nullptr;
+  for (uptr i = 0; s[i]; i++) {
+    if (s[i] == c) res = s + i;
+  }
+  return const_cast<char *>(res);
+}
+
+uptr internal_strlen(const char *s) {
+  uptr i = 0;
+  while (s[i]) i++;
+  return i;
+}
+
+uptr internal_strlcat(char *dst, const char *src, uptr maxlen) {
+  const uptr srclen = internal_strlen(src);
+  const uptr dstlen = internal_strnlen(dst, maxlen);
+  if (dstlen == maxlen) return maxlen + srclen;
+  if (srclen < maxlen - dstlen) {
+    internal_memmove(dst + dstlen, src, srclen + 1);
+  } else {
+    internal_memmove(dst + dstlen, src, maxlen - dstlen - 1);
+    dst[maxlen - 1] = '\0';
+  }
+  return dstlen + srclen;
+}
+
+char *internal_strncat(char *dst, const char *src, uptr n) {
+  uptr len = internal_strlen(dst);
+  uptr i;
+  for (i = 0; i < n && src[i]; i++)
+    dst[len + i] = src[i];
+  dst[len + i] = 0;
+  return dst;
+}
+
+uptr internal_strlcpy(char *dst, const char *src, uptr maxlen) {
+  const uptr srclen = internal_strlen(src);
+  if (srclen < maxlen) {
+    internal_memmove(dst, src, srclen + 1);
+  } else if (maxlen != 0) {
+    internal_memmove(dst, src, maxlen - 1);
+    dst[maxlen - 1] = '\0';
+  }
+  return srclen;
+}
+
+char *internal_strncpy(char *dst, const char *src, uptr n) {
+  uptr i;
+  for (i = 0; i < n && src[i]; i++)
+    dst[i] = src[i];
+  internal_memset(dst + i, '\0', n - i);
+  return dst;
+}
+
+uptr internal_strnlen(const char *s, uptr maxlen) {
+  uptr i = 0;
+  while (i < maxlen && s[i]) i++;
+  return i;
+}
+
+char *internal_strstr(const char *haystack, const char *needle) {
+  // This is O(N^2), but we are not using it in hot places.
+  uptr len1 = internal_strlen(haystack);
+  uptr len2 = internal_strlen(needle);
+  if (len1 < len2) return nullptr;
+  for (uptr pos = 0; pos <= len1 - len2; pos++) {
+    if (internal_memcmp(haystack + pos, needle, len2) == 0)
+      return const_cast<char *>(haystack) + pos;
+  }
+  return nullptr;
+}
+
+s64 internal_simple_strtoll(const char *nptr, char **endptr, int base) {
+  CHECK_EQ(base, 10);
+  while (IsSpace(*nptr)) nptr++;
+  int sgn = 1;
+  u64 res = 0;
+  bool have_digits = false;
+  char *old_nptr = const_cast<char *>(nptr);
+  if (*nptr == '+') {
+    sgn = 1;
+    nptr++;
+  } else if (*nptr == '-') {
+    sgn = -1;
+    nptr++;
+  }
+  while (IsDigit(*nptr)) {
+    res = (res <= UINT64_MAX / 10) ? res * 10 : UINT64_MAX;
+    int digit = ((*nptr) - '0');
+    res = (res <= UINT64_MAX - digit) ? res + digit : UINT64_MAX;
+    have_digits = true;
+    nptr++;
+  }
+  if (endptr) {
+    *endptr = (have_digits) ? const_cast<char *>(nptr) : old_nptr;
+  }
+  if (sgn > 0) {
+    return (s64)(Min((u64)INT64_MAX, res));
+  } else {
+    return (res > INT64_MAX) ? INT64_MIN : ((s64)res * -1);
+  }
+}
+
+bool mem_is_zero(const char *beg, uptr size) {
+  CHECK_LE(size, 1ULL << FIRST_32_SECOND_64(30, 40));  // Sanity check.
+  const char *end = beg + size;
+  uptr *aligned_beg = (uptr *)RoundUpTo((uptr)beg, sizeof(uptr));
+  uptr *aligned_end = (uptr *)RoundDownTo((uptr)end, sizeof(uptr));
+  uptr all = 0;
+  // Prologue.
+  for (const char *mem = beg; mem < (char*)aligned_beg && mem < end; mem++)
+    all |= *mem;
+  // Aligned loop.
+  for (; aligned_beg < aligned_end; aligned_beg++)
+    all |= *aligned_beg;
+  // Epilogue.
+  if ((char*)aligned_end >= beg)
+    for (const char *mem = (char*)aligned_end; mem < end; mem++)
+      all |= *mem;
+  return all == 0;
+}
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_libc.h b/compiler-rt/lib/sanitizer_common/sanitizer_libc.h
new file mode 100644
index 0000000..df28677
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_libc.h
@@ -0,0 +1,85 @@
+//===-- sanitizer_libc.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// These tools can not use some of the libc functions directly because those
+// functions are intercepted. Instead, we implement a tiny subset of libc here.
+// FIXME: Some of functions declared in this file are in fact POSIX, not libc.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_LIBC_H
+#define SANITIZER_LIBC_H
+
+// ----------- ATTENTION -------------
+// This header should NOT include any other headers from sanitizer runtime.
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+// internal_X() is a custom implementation of X() for use in RTL.
+
+// String functions
+s64 internal_atoll(const char *nptr);
+void *internal_memchr(const void *s, int c, uptr n);
+void *internal_memrchr(const void *s, int c, uptr n);
+int internal_memcmp(const void* s1, const void* s2, uptr n);
+void *internal_memcpy(void *dest, const void *src, uptr n);
+void *internal_memmove(void *dest, const void *src, uptr n);
+// Set [s, s + n) to 0. Both s and n should be 16-aligned.
+void internal_bzero_aligned16(void *s, uptr n);
+// Should not be used in performance-critical places.
+void *internal_memset(void *s, int c, uptr n);
+char* internal_strchr(const char *s, int c);
+char *internal_strchrnul(const char *s, int c);
+int internal_strcmp(const char *s1, const char *s2);
+uptr internal_strcspn(const char *s, const char *reject);
+char *internal_strdup(const char *s);
+char *internal_strndup(const char *s, uptr n);
+uptr internal_strlen(const char *s);
+uptr internal_strlcat(char *dst, const char *src, uptr maxlen);
+char *internal_strncat(char *dst, const char *src, uptr n);
+int internal_strncmp(const char *s1, const char *s2, uptr n);
+uptr internal_strlcpy(char *dst, const char *src, uptr maxlen);
+char *internal_strncpy(char *dst, const char *src, uptr n);
+uptr internal_strnlen(const char *s, uptr maxlen);
+char *internal_strrchr(const char *s, int c);
+// This is O(N^2), but we are not using it in hot places.
+char *internal_strstr(const char *haystack, const char *needle);
+// Works only for base=10 and doesn't set errno.
+s64 internal_simple_strtoll(const char *nptr, char **endptr, int base);
+int internal_snprintf(char *buffer, uptr length, const char *format, ...);
+
+// Return true if all bytes in [mem, mem+size) are zero.
+// Optimized for the case when the result is true.
+bool mem_is_zero(const char *mem, uptr size);
+
+// I/O
+const fd_t kInvalidFd = (fd_t)-1;
+const fd_t kStdinFd = 0;
+const fd_t kStdoutFd = (fd_t)1;
+const fd_t kStderrFd = (fd_t)2;
+
+uptr internal_ftruncate(fd_t fd, uptr size);
+
+// OS
+void NORETURN internal__exit(int exitcode);
+
+uptr internal_getpid();
+uptr internal_getppid();
+
+// Threading
+uptr internal_sched_yield();
+
+// Error handling
+bool internal_iserror(uptr retval, int *rverrno = nullptr);
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_LIBC_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_libignore.cc b/compiler-rt/lib/sanitizer_common/sanitizer_libignore.cc
new file mode 100644
index 0000000..5453939
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_libignore.cc
@@ -0,0 +1,102 @@
+//===-- sanitizer_libignore.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC
+
+#include "sanitizer_libignore.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_posix.h"
+#include "sanitizer_procmaps.h"
+
+namespace __sanitizer {
+
+LibIgnore::LibIgnore(LinkerInitialized) {
+}
+
+void LibIgnore::AddIgnoredLibrary(const char *name_templ) {
+  BlockingMutexLock lock(&mutex_);
+  if (count_ >= kMaxLibs) {
+    Report("%s: too many ignored libraries (max: %d)\n", SanitizerToolName,
+           kMaxLibs);
+    Die();
+  }
+  Lib *lib = &libs_[count_++];
+  lib->templ = internal_strdup(name_templ);
+  lib->name = nullptr;
+  lib->real_name = nullptr;
+  lib->loaded = false;
+}
+
+void LibIgnore::OnLibraryLoaded(const char *name) {
+  BlockingMutexLock lock(&mutex_);
+  // Try to match suppressions with symlink target.
+  InternalScopedString buf(kMaxPathLength);
+  if (name && internal_readlink(name, buf.data(), buf.size() - 1) > 0 &&
+      buf[0]) {
+    for (uptr i = 0; i < count_; i++) {
+      Lib *lib = &libs_[i];
+      if (!lib->loaded && (!lib->real_name) &&
+          TemplateMatch(lib->templ, name))
+        lib->real_name = internal_strdup(buf.data());
+    }
+  }
+
+  // Scan suppressions list and find newly loaded and unloaded libraries.
+  MemoryMappingLayout proc_maps(/*cache_enabled*/false);
+  InternalScopedString module(kMaxPathLength);
+  for (uptr i = 0; i < count_; i++) {
+    Lib *lib = &libs_[i];
+    bool loaded = false;
+    proc_maps.Reset();
+    uptr b, e, off, prot;
+    while (proc_maps.Next(&b, &e, &off, module.data(), module.size(), &prot)) {
+      if ((prot & MemoryMappingLayout::kProtectionExecute) == 0)
+        continue;
+      if (TemplateMatch(lib->templ, module.data()) ||
+          (lib->real_name &&
+          internal_strcmp(lib->real_name, module.data()) == 0)) {
+        if (loaded) {
+          Report("%s: called_from_lib suppression '%s' is matched against"
+                 " 2 libraries: '%s' and '%s'\n",
+                 SanitizerToolName, lib->templ, lib->name, module.data());
+          Die();
+        }
+        loaded = true;
+        if (lib->loaded)
+          continue;
+        VReport(1,
+                "Matched called_from_lib suppression '%s' against library"
+                " '%s'\n",
+                lib->templ, module.data());
+        lib->loaded = true;
+        lib->name = internal_strdup(module.data());
+        const uptr idx = atomic_load(&loaded_count_, memory_order_relaxed);
+        code_ranges_[idx].begin = b;
+        code_ranges_[idx].end = e;
+        atomic_store(&loaded_count_, idx + 1, memory_order_release);
+      }
+    }
+    if (lib->loaded && !loaded) {
+      Report("%s: library '%s' that was matched against called_from_lib"
+             " suppression '%s' is unloaded\n",
+             SanitizerToolName, lib->name, lib->templ);
+      Die();
+    }
+  }
+}
+
+void LibIgnore::OnLibraryUnloaded() {
+  OnLibraryLoaded(nullptr);
+}
+
+} // namespace __sanitizer
+
+#endif // #if SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_libignore.h b/compiler-rt/lib/sanitizer_common/sanitizer_libignore.h
new file mode 100644
index 0000000..cd56c36
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_libignore.h
@@ -0,0 +1,83 @@
+//===-- sanitizer_libignore.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// LibIgnore allows to ignore all interceptors called from a particular set
+// of dynamic libraries. LibIgnore can be initialized with several templates
+// of names of libraries to be ignored. It finds code ranges for the libraries;
+// and checks whether the provided PC value belongs to the code ranges.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_LIBIGNORE_H
+#define SANITIZER_LIBIGNORE_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_common.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_mutex.h"
+
+namespace __sanitizer {
+
+class LibIgnore {
+ public:
+  explicit LibIgnore(LinkerInitialized);
+
+  // Must be called during initialization.
+  void AddIgnoredLibrary(const char *name_templ);
+
+  // Must be called after a new dynamic library is loaded.
+  void OnLibraryLoaded(const char *name);
+
+  // Must be called after a dynamic library is unloaded.
+  void OnLibraryUnloaded();
+
+  // Checks whether the provided PC belongs to one of the ignored libraries.
+  bool IsIgnored(uptr pc) const;
+
+ private:
+  struct Lib {
+    char *templ;
+    char *name;
+    char *real_name;  // target of symlink
+    bool loaded;
+  };
+
+  struct LibCodeRange {
+    uptr begin;
+    uptr end;
+  };
+
+  static const uptr kMaxLibs = 128;
+
+  // Hot part:
+  atomic_uintptr_t loaded_count_;
+  LibCodeRange code_ranges_[kMaxLibs];
+
+  // Cold part:
+  BlockingMutex mutex_;
+  uptr count_;
+  Lib libs_[kMaxLibs];
+
+  // Disallow copying of LibIgnore objects.
+  LibIgnore(const LibIgnore&);  // not implemented
+  void operator = (const LibIgnore&);  // not implemented
+};
+
+inline bool LibIgnore::IsIgnored(uptr pc) const {
+  const uptr n = atomic_load(&loaded_count_, memory_order_acquire);
+  for (uptr i = 0; i < n; i++) {
+    if (pc >= code_ranges_[i].begin && pc < code_ranges_[i].end)
+      return true;
+  }
+  return false;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_LIBIGNORE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_linux.cc b/compiler-rt/lib/sanitizer_common/sanitizer_linux.cc
new file mode 100644
index 0000000..8c3ebff
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_linux.cc
@@ -0,0 +1,1236 @@
+//===-- sanitizer_linux.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries and implements linux-specific functions from
+// sanitizer_libc.h.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_linux.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_procmaps.h"
+#include "sanitizer_stacktrace.h"
+#include "sanitizer_symbolizer.h"
+
+#if !SANITIZER_FREEBSD
+#include <asm/param.h>
+#endif
+
+// For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
+// format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
+// access stat from asm/stat.h, without conflicting with definition in
+// sys/stat.h, we use this trick.
+#if defined(__mips64)
+#include <asm/unistd.h>
+#include <sys/types.h>
+#define stat kernel_stat
+#include <asm/stat.h>
+#undef stat
+#endif
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <link.h>
+#include <pthread.h>
+#include <sched.h>
+#include <sys/mman.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+#if SANITIZER_FREEBSD
+#include <sys/sysctl.h>
+#include <machine/atomic.h>
+extern "C" {
+// <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on
+// FreeBSD 9.2 and 10.0.
+#include <sys/umtx.h>
+}
+extern char **environ;  // provided by crt1
+#endif  // SANITIZER_FREEBSD
+
+#if !SANITIZER_ANDROID
+#include <sys/signal.h>
+#endif
+
+#if SANITIZER_LINUX
+// <linux/time.h>
+struct kernel_timeval {
+  long tv_sec;
+  long tv_usec;
+};
+
+// <linux/futex.h> is broken on some linux distributions.
+const int FUTEX_WAIT = 0;
+const int FUTEX_WAKE = 1;
+#endif  // SANITIZER_LINUX
+
+// Are we using 32-bit or 64-bit Linux syscalls?
+// x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
+// but it still needs to use 64-bit syscalls.
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
+    SANITIZER_WORDSIZE == 64)
+# define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
+#else
+# define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
+#endif
+
+namespace __sanitizer {
+
+#if SANITIZER_LINUX && defined(__x86_64__)
+#include "sanitizer_syscall_linux_x86_64.inc"
+#elif SANITIZER_LINUX && defined(__aarch64__)
+#include "sanitizer_syscall_linux_aarch64.inc"
+#else
+#include "sanitizer_syscall_generic.inc"
+#endif
+
+// --------------- sanitizer_libc.h
+uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
+                   OFF_T offset) {
+#if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
+  return internal_syscall(SYSCALL(mmap), (uptr)addr, length, prot, flags, fd,
+                          offset);
+#else
+  // mmap2 specifies file offset in 4096-byte units.
+  CHECK(IsAligned(offset, 4096));
+  return internal_syscall(SYSCALL(mmap2), addr, length, prot, flags, fd,
+                          offset / 4096);
+#endif
+}
+
+uptr internal_munmap(void *addr, uptr length) {
+  return internal_syscall(SYSCALL(munmap), (uptr)addr, length);
+}
+
+int internal_mprotect(void *addr, uptr length, int prot) {
+  return internal_syscall(SYSCALL(mprotect), (uptr)addr, length, prot);
+}
+
+uptr internal_close(fd_t fd) {
+  return internal_syscall(SYSCALL(close), fd);
+}
+
+uptr internal_open(const char *filename, int flags) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags);
+#else
+  return internal_syscall(SYSCALL(open), (uptr)filename, flags);
+#endif
+}
+
+uptr internal_open(const char *filename, int flags, u32 mode) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags,
+                          mode);
+#else
+  return internal_syscall(SYSCALL(open), (uptr)filename, flags, mode);
+#endif
+}
+
+uptr internal_read(fd_t fd, void *buf, uptr count) {
+  sptr res;
+  HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(read), fd, (uptr)buf,
+               count));
+  return res;
+}
+
+uptr internal_write(fd_t fd, const void *buf, uptr count) {
+  sptr res;
+  HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(write), fd, (uptr)buf,
+               count));
+  return res;
+}
+
+uptr internal_ftruncate(fd_t fd, uptr size) {
+  sptr res;
+  HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate), fd,
+               (OFF_T)size));
+  return res;
+}
+
+#if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && !SANITIZER_FREEBSD
+static void stat64_to_stat(struct stat64 *in, struct stat *out) {
+  internal_memset(out, 0, sizeof(*out));
+  out->st_dev = in->st_dev;
+  out->st_ino = in->st_ino;
+  out->st_mode = in->st_mode;
+  out->st_nlink = in->st_nlink;
+  out->st_uid = in->st_uid;
+  out->st_gid = in->st_gid;
+  out->st_rdev = in->st_rdev;
+  out->st_size = in->st_size;
+  out->st_blksize = in->st_blksize;
+  out->st_blocks = in->st_blocks;
+  out->st_atime = in->st_atime;
+  out->st_mtime = in->st_mtime;
+  out->st_ctime = in->st_ctime;
+  out->st_ino = in->st_ino;
+}
+#endif
+
+#if defined(__mips64)
+static void kernel_stat_to_stat(struct kernel_stat *in, struct stat *out) {
+  internal_memset(out, 0, sizeof(*out));
+  out->st_dev = in->st_dev;
+  out->st_ino = in->st_ino;
+  out->st_mode = in->st_mode;
+  out->st_nlink = in->st_nlink;
+  out->st_uid = in->st_uid;
+  out->st_gid = in->st_gid;
+  out->st_rdev = in->st_rdev;
+  out->st_size = in->st_size;
+  out->st_blksize = in->st_blksize;
+  out->st_blocks = in->st_blocks;
+  out->st_atime = in->st_atime_nsec;
+  out->st_mtime = in->st_mtime_nsec;
+  out->st_ctime = in->st_ctime_nsec;
+  out->st_ino = in->st_ino;
+}
+#endif
+
+uptr internal_stat(const char *path, void *buf) {
+#if SANITIZER_FREEBSD
+  return internal_syscall(SYSCALL(stat), path, buf);
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
+                          (uptr)buf, 0);
+#elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
+# if defined(__mips64)
+  // For mips64, stat syscall fills buffer in the format of kernel_stat
+  struct kernel_stat kbuf;
+  int res = internal_syscall(SYSCALL(stat), path, &kbuf);
+  kernel_stat_to_stat(&kbuf, (struct stat *)buf);
+  return res;
+# else
+  return internal_syscall(SYSCALL(stat), (uptr)path, (uptr)buf);
+# endif
+#else
+  struct stat64 buf64;
+  int res = internal_syscall(SYSCALL(stat64), path, &buf64);
+  stat64_to_stat(&buf64, (struct stat *)buf);
+  return res;
+#endif
+}
+
+uptr internal_lstat(const char *path, void *buf) {
+#if SANITIZER_FREEBSD
+  return internal_syscall(SYSCALL(lstat), path, buf);
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
+                         (uptr)buf, AT_SYMLINK_NOFOLLOW);
+#elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
+  return internal_syscall(SYSCALL(lstat), (uptr)path, (uptr)buf);
+#else
+  struct stat64 buf64;
+  int res = internal_syscall(SYSCALL(lstat64), path, &buf64);
+  stat64_to_stat(&buf64, (struct stat *)buf);
+  return res;
+#endif
+}
+
+uptr internal_fstat(fd_t fd, void *buf) {
+#if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
+  return internal_syscall(SYSCALL(fstat), fd, (uptr)buf);
+#else
+  struct stat64 buf64;
+  int res = internal_syscall(SYSCALL(fstat64), fd, &buf64);
+  stat64_to_stat(&buf64, (struct stat *)buf);
+  return res;
+#endif
+}
+
+uptr internal_filesize(fd_t fd) {
+  struct stat st;
+  if (internal_fstat(fd, &st))
+    return -1;
+  return (uptr)st.st_size;
+}
+
+uptr internal_dup2(int oldfd, int newfd) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0);
+#else
+  return internal_syscall(SYSCALL(dup2), oldfd, newfd);
+#endif
+}
+
+uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(readlinkat), AT_FDCWD,
+                          (uptr)path, (uptr)buf, bufsize);
+#else
+  return internal_syscall(SYSCALL(readlink), (uptr)path, (uptr)buf, bufsize);
+#endif
+}
+
+uptr internal_unlink(const char *path) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
+#else
+  return internal_syscall(SYSCALL(unlink), (uptr)path);
+#endif
+}
+
+uptr internal_rename(const char *oldpath, const char *newpath) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
+                          (uptr)newpath);
+#else
+  return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
+#endif
+}
+
+uptr internal_sched_yield() {
+  return internal_syscall(SYSCALL(sched_yield));
+}
+
+void internal__exit(int exitcode) {
+#if SANITIZER_FREEBSD
+  internal_syscall(SYSCALL(exit), exitcode);
+#else
+  internal_syscall(SYSCALL(exit_group), exitcode);
+#endif
+  Die();  // Unreachable.
+}
+
+uptr internal_execve(const char *filename, char *const argv[],
+                     char *const envp[]) {
+  return internal_syscall(SYSCALL(execve), (uptr)filename, (uptr)argv,
+                          (uptr)envp);
+}
+
+// ----------------- sanitizer_common.h
+bool FileExists(const char *filename) {
+  struct stat st;
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  if (internal_syscall(SYSCALL(newfstatat), AT_FDCWD, filename, &st, 0))
+#else
+  if (internal_stat(filename, &st))
+#endif
+    return false;
+  // Sanity check: filename is a regular file.
+  return S_ISREG(st.st_mode);
+}
+
+uptr GetTid() {
+#if SANITIZER_FREEBSD
+  return (uptr)pthread_self();
+#else
+  return internal_syscall(SYSCALL(gettid));
+#endif
+}
+
+u64 NanoTime() {
+#if SANITIZER_FREEBSD
+  timeval tv;
+#else
+  kernel_timeval tv;
+#endif
+  internal_memset(&tv, 0, sizeof(tv));
+  internal_syscall(SYSCALL(gettimeofday), (uptr)&tv, 0);
+  return (u64)tv.tv_sec * 1000*1000*1000 + tv.tv_usec * 1000;
+}
+
+// Like getenv, but reads env directly from /proc (on Linux) or parses the
+// 'environ' array (on FreeBSD) and does not use libc. This function should be
+// called first inside __asan_init.
+const char *GetEnv(const char *name) {
+#if SANITIZER_FREEBSD
+  if (::environ != 0) {
+    uptr NameLen = internal_strlen(name);
+    for (char **Env = ::environ; *Env != 0; Env++) {
+      if (internal_strncmp(*Env, name, NameLen) == 0 && (*Env)[NameLen] == '=')
+        return (*Env) + NameLen + 1;
+    }
+  }
+  return 0;  // Not found.
+#elif SANITIZER_LINUX
+  static char *environ;
+  static uptr len;
+  static bool inited;
+  if (!inited) {
+    inited = true;
+    uptr environ_size;
+    if (!ReadFileToBuffer("/proc/self/environ", &environ, &environ_size, &len))
+      environ = nullptr;
+  }
+  if (!environ || len == 0) return nullptr;
+  uptr namelen = internal_strlen(name);
+  const char *p = environ;
+  while (*p != '\0') {  // will happen at the \0\0 that terminates the buffer
+    // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
+    const char* endp =
+        (char*)internal_memchr(p, '\0', len - (p - environ));
+    if (!endp)  // this entry isn't NUL terminated
+      return nullptr;
+    else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=')  // Match.
+      return p + namelen + 1;  // point after =
+    p = endp + 1;
+  }
+  return nullptr;  // Not found.
+#else
+#error "Unsupported platform"
+#endif
+}
+
+extern "C" {
+  SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end;
+}
+
+#if !SANITIZER_GO
+static void ReadNullSepFileToArray(const char *path, char ***arr,
+                                   int arr_size) {
+  char *buff;
+  uptr buff_size;
+  uptr buff_len;
+  *arr = (char **)MmapOrDie(arr_size * sizeof(char *), "NullSepFileArray");
+  if (!ReadFileToBuffer(path, &buff, &buff_size, &buff_len, 1024 * 1024)) {
+    (*arr)[0] = nullptr;
+    return;
+  }
+  (*arr)[0] = buff;
+  int count, i;
+  for (count = 1, i = 1; ; i++) {
+    if (buff[i] == 0) {
+      if (buff[i+1] == 0) break;
+      (*arr)[count] = &buff[i+1];
+      CHECK_LE(count, arr_size - 1);  // FIXME: make this more flexible.
+      count++;
+    }
+  }
+  (*arr)[count] = nullptr;
+}
+#endif
+
+static void GetArgsAndEnv(char*** argv, char*** envp) {
+#if !SANITIZER_GO
+  if (&__libc_stack_end) {
+#endif
+    uptr* stack_end = (uptr*)__libc_stack_end;
+    int argc = *stack_end;
+    *argv = (char**)(stack_end + 1);
+    *envp = (char**)(stack_end + argc + 2);
+#if !SANITIZER_GO
+  } else {
+    static const int kMaxArgv = 2000, kMaxEnvp = 2000;
+    ReadNullSepFileToArray("/proc/self/cmdline", argv, kMaxArgv);
+    ReadNullSepFileToArray("/proc/self/environ", envp, kMaxEnvp);
+  }
+#endif
+}
+
+void ReExec() {
+  char **argv, **envp;
+  GetArgsAndEnv(&argv, &envp);
+  uptr rv = internal_execve("/proc/self/exe", argv, envp);
+  int rverrno;
+  CHECK_EQ(internal_iserror(rv, &rverrno), true);
+  Printf("execve failed, errno %d\n", rverrno);
+  Die();
+}
+
+enum MutexState {
+  MtxUnlocked = 0,
+  MtxLocked = 1,
+  MtxSleeping = 2
+};
+
+BlockingMutex::BlockingMutex() {
+  internal_memset(this, 0, sizeof(*this));
+}
+
+void BlockingMutex::Lock() {
+  CHECK_EQ(owner_, 0);
+  atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
+  if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked)
+    return;
+  while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) {
+#if SANITIZER_FREEBSD
+    _umtx_op(m, UMTX_OP_WAIT_UINT, MtxSleeping, 0, 0);
+#else
+    internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAIT, MtxSleeping, 0, 0, 0);
+#endif
+  }
+}
+
+void BlockingMutex::Unlock() {
+  atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
+  u32 v = atomic_exchange(m, MtxUnlocked, memory_order_relaxed);
+  CHECK_NE(v, MtxUnlocked);
+  if (v == MtxSleeping) {
+#if SANITIZER_FREEBSD
+    _umtx_op(m, UMTX_OP_WAKE, 1, 0, 0);
+#else
+    internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAKE, 1, 0, 0, 0);
+#endif
+  }
+}
+
+void BlockingMutex::CheckLocked() {
+  atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
+  CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed));
+}
+
+// ----------------- sanitizer_linux.h
+// The actual size of this structure is specified by d_reclen.
+// Note that getdents64 uses a different structure format. We only provide the
+// 32-bit syscall here.
+struct linux_dirent {
+#if SANITIZER_X32 || defined(__aarch64__)
+  u64 d_ino;
+  u64 d_off;
+#else
+  unsigned long      d_ino;
+  unsigned long      d_off;
+#endif
+  unsigned short     d_reclen;
+#ifdef __aarch64__
+  unsigned char      d_type;
+#endif
+  char               d_name[256];
+};
+
+// Syscall wrappers.
+uptr internal_ptrace(int request, int pid, void *addr, void *data) {
+  return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr,
+                          (uptr)data);
+}
+
+uptr internal_waitpid(int pid, int *status, int options) {
+  return internal_syscall(SYSCALL(wait4), pid, (uptr)status, options,
+                          0 /* rusage */);
+}
+
+uptr internal_getpid() {
+  return internal_syscall(SYSCALL(getpid));
+}
+
+uptr internal_getppid() {
+  return internal_syscall(SYSCALL(getppid));
+}
+
+uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count);
+#else
+  return internal_syscall(SYSCALL(getdents), fd, (uptr)dirp, count);
+#endif
+}
+
+uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
+  return internal_syscall(SYSCALL(lseek), fd, offset, whence);
+}
+
+#if SANITIZER_LINUX
+uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
+  return internal_syscall(SYSCALL(prctl), option, arg2, arg3, arg4, arg5);
+}
+#endif
+
+uptr internal_sigaltstack(const struct sigaltstack *ss,
+                         struct sigaltstack *oss) {
+  return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss);
+}
+
+int internal_fork() {
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+  return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
+#else
+  return internal_syscall(SYSCALL(fork));
+#endif
+}
+
+#if SANITIZER_LINUX
+#define SA_RESTORER 0x04000000
+// Doesn't set sa_restorer, use with caution (see below).
+int internal_sigaction_norestorer(int signum, const void *act, void *oldact) {
+  __sanitizer_kernel_sigaction_t k_act, k_oldact;
+  internal_memset(&k_act, 0, sizeof(__sanitizer_kernel_sigaction_t));
+  internal_memset(&k_oldact, 0, sizeof(__sanitizer_kernel_sigaction_t));
+  const __sanitizer_sigaction *u_act = (const __sanitizer_sigaction *)act;
+  __sanitizer_sigaction *u_oldact = (__sanitizer_sigaction *)oldact;
+  if (u_act) {
+    k_act.handler = u_act->handler;
+    k_act.sigaction = u_act->sigaction;
+    internal_memcpy(&k_act.sa_mask, &u_act->sa_mask,
+                    sizeof(__sanitizer_kernel_sigset_t));
+    // Without SA_RESTORER kernel ignores the calls (probably returns EINVAL).
+    k_act.sa_flags = u_act->sa_flags | SA_RESTORER;
+    // FIXME: most often sa_restorer is unset, however the kernel requires it
+    // to point to a valid signal restorer that calls the rt_sigreturn syscall.
+    // If sa_restorer passed to the kernel is NULL, the program may crash upon
+    // signal delivery or fail to unwind the stack in the signal handler.
+    // libc implementation of sigaction() passes its own restorer to
+    // rt_sigaction, so we need to do the same (we'll need to reimplement the
+    // restorers; for x86_64 the restorer address can be obtained from
+    // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
+#if !SANITIZER_ANDROID || !SANITIZER_MIPS32
+    k_act.sa_restorer = u_act->sa_restorer;
+#endif
+  }
+
+  uptr result = internal_syscall(SYSCALL(rt_sigaction), (uptr)signum,
+      (uptr)(u_act ? &k_act : nullptr),
+      (uptr)(u_oldact ? &k_oldact : nullptr),
+      (uptr)sizeof(__sanitizer_kernel_sigset_t));
+
+  if ((result == 0) && u_oldact) {
+    u_oldact->handler = k_oldact.handler;
+    u_oldact->sigaction = k_oldact.sigaction;
+    internal_memcpy(&u_oldact->sa_mask, &k_oldact.sa_mask,
+                    sizeof(__sanitizer_kernel_sigset_t));
+    u_oldact->sa_flags = k_oldact.sa_flags;
+#if !SANITIZER_ANDROID || !SANITIZER_MIPS32
+    u_oldact->sa_restorer = k_oldact.sa_restorer;
+#endif
+  }
+  return result;
+}
+#endif  // SANITIZER_LINUX
+
+uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
+    __sanitizer_sigset_t *oldset) {
+#if SANITIZER_FREEBSD
+  return internal_syscall(SYSCALL(sigprocmask), how, set, oldset);
+#else
+  __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
+  __sanitizer_kernel_sigset_t *k_oldset = (__sanitizer_kernel_sigset_t *)oldset;
+  return internal_syscall(SYSCALL(rt_sigprocmask), (uptr)how,
+                          (uptr)&k_set->sig[0], (uptr)&k_oldset->sig[0],
+                          sizeof(__sanitizer_kernel_sigset_t));
+#endif
+}
+
+void internal_sigfillset(__sanitizer_sigset_t *set) {
+  internal_memset(set, 0xff, sizeof(*set));
+}
+
+#if SANITIZER_LINUX
+void internal_sigdelset(__sanitizer_sigset_t *set, int signum) {
+  signum -= 1;
+  CHECK_GE(signum, 0);
+  CHECK_LT(signum, sizeof(*set) * 8);
+  __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
+  const uptr idx = signum / (sizeof(k_set->sig[0]) * 8);
+  const uptr bit = signum % (sizeof(k_set->sig[0]) * 8);
+  k_set->sig[idx] &= ~(1 << bit);
+}
+#endif  // SANITIZER_LINUX
+
+// ThreadLister implementation.
+ThreadLister::ThreadLister(int pid)
+  : pid_(pid),
+    descriptor_(-1),
+    buffer_(4096),
+    error_(true),
+    entry_((struct linux_dirent *)buffer_.data()),
+    bytes_read_(0) {
+  char task_directory_path[80];
+  internal_snprintf(task_directory_path, sizeof(task_directory_path),
+                    "/proc/%d/task/", pid);
+  uptr openrv = internal_open(task_directory_path, O_RDONLY | O_DIRECTORY);
+  if (internal_iserror(openrv)) {
+    error_ = true;
+    Report("Can't open /proc/%d/task for reading.\n", pid);
+  } else {
+    error_ = false;
+    descriptor_ = openrv;
+  }
+}
+
+int ThreadLister::GetNextTID() {
+  int tid = -1;
+  do {
+    if (error_)
+      return -1;
+    if ((char *)entry_ >= &buffer_[bytes_read_] && !GetDirectoryEntries())
+      return -1;
+    if (entry_->d_ino != 0 && entry_->d_name[0] >= '0' &&
+        entry_->d_name[0] <= '9') {
+      // Found a valid tid.
+      tid = (int)internal_atoll(entry_->d_name);
+    }
+    entry_ = (struct linux_dirent *)(((char *)entry_) + entry_->d_reclen);
+  } while (tid < 0);
+  return tid;
+}
+
+void ThreadLister::Reset() {
+  if (error_ || descriptor_ < 0)
+    return;
+  internal_lseek(descriptor_, 0, SEEK_SET);
+}
+
+ThreadLister::~ThreadLister() {
+  if (descriptor_ >= 0)
+    internal_close(descriptor_);
+}
+
+bool ThreadLister::error() { return error_; }
+
+bool ThreadLister::GetDirectoryEntries() {
+  CHECK_GE(descriptor_, 0);
+  CHECK_NE(error_, true);
+  bytes_read_ = internal_getdents(descriptor_,
+                                  (struct linux_dirent *)buffer_.data(),
+                                  buffer_.size());
+  if (internal_iserror(bytes_read_)) {
+    Report("Can't read directory entries from /proc/%d/task.\n", pid_);
+    error_ = true;
+    return false;
+  } else if (bytes_read_ == 0) {
+    return false;
+  }
+  entry_ = (struct linux_dirent *)buffer_.data();
+  return true;
+}
+
+uptr GetPageSize() {
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__))
+  return EXEC_PAGESIZE;
+#else
+  return sysconf(_SC_PAGESIZE);  // EXEC_PAGESIZE may not be trustworthy.
+#endif
+}
+
+uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
+#if SANITIZER_FREEBSD
+  const int Mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
+  const char *default_module_name = "kern.proc.pathname";
+  size_t Size = buf_len;
+  bool IsErr = (sysctl(Mib, ARRAY_SIZE(Mib), buf, &Size, NULL, 0) != 0);
+  int readlink_error = IsErr ? errno : 0;
+  uptr module_name_len = Size;
+#else
+  const char *default_module_name = "/proc/self/exe";
+  uptr module_name_len = internal_readlink(
+      default_module_name, buf, buf_len);
+  int readlink_error;
+  bool IsErr = internal_iserror(module_name_len, &readlink_error);
+#endif
+  if (IsErr) {
+    // We can't read binary name for some reason, assume it's unknown.
+    Report("WARNING: reading executable name failed with errno %d, "
+           "some stack frames may not be symbolized\n", readlink_error);
+    module_name_len = internal_snprintf(buf, buf_len, "%s",
+                                        default_module_name);
+    CHECK_LT(module_name_len, buf_len);
+  }
+  return module_name_len;
+}
+
+uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) {
+#if SANITIZER_LINUX
+  char *tmpbuf;
+  uptr tmpsize;
+  uptr tmplen;
+  if (ReadFileToBuffer("/proc/self/cmdline", &tmpbuf, &tmpsize, &tmplen,
+                       1024 * 1024)) {
+    internal_strncpy(buf, tmpbuf, buf_len);
+    UnmapOrDie(tmpbuf, tmpsize);
+    return internal_strlen(buf);
+  }
+#endif
+  return ReadBinaryName(buf, buf_len);
+}
+
+// Match full names of the form /path/to/base_name{-,.}*
+bool LibraryNameIs(const char *full_name, const char *base_name) {
+  const char *name = full_name;
+  // Strip path.
+  while (*name != '\0') name++;
+  while (name > full_name && *name != '/') name--;
+  if (*name == '/') name++;
+  uptr base_name_length = internal_strlen(base_name);
+  if (internal_strncmp(name, base_name, base_name_length)) return false;
+  return (name[base_name_length] == '-' || name[base_name_length] == '.');
+}
+
+#if !SANITIZER_ANDROID
+// Call cb for each region mapped by map.
+void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) {
+  CHECK_NE(map, nullptr);
+#if !SANITIZER_FREEBSD
+  typedef ElfW(Phdr) Elf_Phdr;
+  typedef ElfW(Ehdr) Elf_Ehdr;
+#endif  // !SANITIZER_FREEBSD
+  char *base = (char *)map->l_addr;
+  Elf_Ehdr *ehdr = (Elf_Ehdr *)base;
+  char *phdrs = base + ehdr->e_phoff;
+  char *phdrs_end = phdrs + ehdr->e_phnum * ehdr->e_phentsize;
+
+  // Find the segment with the minimum base so we can "relocate" the p_vaddr
+  // fields.  Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC
+  // objects have a non-zero base.
+  uptr preferred_base = (uptr)-1;
+  for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) {
+    Elf_Phdr *phdr = (Elf_Phdr *)iter;
+    if (phdr->p_type == PT_LOAD && preferred_base > (uptr)phdr->p_vaddr)
+      preferred_base = (uptr)phdr->p_vaddr;
+  }
+
+  // Compute the delta from the real base to get a relocation delta.
+  sptr delta = (uptr)base - preferred_base;
+  // Now we can figure out what the loader really mapped.
+  for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) {
+    Elf_Phdr *phdr = (Elf_Phdr *)iter;
+    if (phdr->p_type == PT_LOAD) {
+      uptr seg_start = phdr->p_vaddr + delta;
+      uptr seg_end = seg_start + phdr->p_memsz;
+      // None of these values are aligned.  We consider the ragged edges of the
+      // load command as defined, since they are mapped from the file.
+      seg_start = RoundDownTo(seg_start, GetPageSizeCached());
+      seg_end = RoundUpTo(seg_end, GetPageSizeCached());
+      cb((void *)seg_start, seg_end - seg_start);
+    }
+  }
+}
+#endif
+
+#if defined(__x86_64__) && SANITIZER_LINUX
+// We cannot use glibc's clone wrapper, because it messes with the child
+// task's TLS. It writes the PID and TID of the child task to its thread
+// descriptor, but in our case the child task shares the thread descriptor with
+// the parent (because we don't know how to allocate a new thread
+// descriptor to keep glibc happy). So the stock version of clone(), when
+// used with CLONE_VM, would end up corrupting the parent's thread descriptor.
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  long long res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
+  ((unsigned long long *)child_stack)[0] = (uptr)fn;
+  ((unsigned long long *)child_stack)[1] = (uptr)arg;
+  register void *r8 __asm__("r8") = newtls;
+  register int *r10 __asm__("r10") = child_tidptr;
+  __asm__ __volatile__(
+                       /* %rax = syscall(%rax = SYSCALL(clone),
+                        *                %rdi = flags,
+                        *                %rsi = child_stack,
+                        *                %rdx = parent_tidptr,
+                        *                %r8  = new_tls,
+                        *                %r10 = child_tidptr)
+                        */
+                       "syscall\n"
+
+                       /* if (%rax != 0)
+                        *   return;
+                        */
+                       "testq  %%rax,%%rax\n"
+                       "jnz    1f\n"
+
+                       /* In the child. Terminate unwind chain. */
+                       // XXX: We should also terminate the CFI unwind chain
+                       // here. Unfortunately clang 3.2 doesn't support the
+                       // necessary CFI directives, so we skip that part.
+                       "xorq   %%rbp,%%rbp\n"
+
+                       /* Call "fn(arg)". */
+                       "popq   %%rax\n"
+                       "popq   %%rdi\n"
+                       "call   *%%rax\n"
+
+                       /* Call _exit(%rax). */
+                       "movq   %%rax,%%rdi\n"
+                       "movq   %2,%%rax\n"
+                       "syscall\n"
+
+                       /* Return to parent. */
+                     "1:\n"
+                       : "=a" (res)
+                       : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
+                         "S"(child_stack),
+                         "D"(flags),
+                         "d"(parent_tidptr),
+                         "r"(r8),
+                         "r"(r10)
+                       : "rsp", "memory", "r11", "rcx");
+  return res;
+}
+#elif defined(__mips__)
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  long long res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
+  ((unsigned long long *)child_stack)[0] = (uptr)fn;
+  ((unsigned long long *)child_stack)[1] = (uptr)arg;
+  register void *a3 __asm__("$7") = newtls;
+  register int *a4 __asm__("$8") = child_tidptr;
+  // We don't have proper CFI directives here because it requires alot of code
+  // for very marginal benefits.
+  __asm__ __volatile__(
+                       /* $v0 = syscall($v0 = __NR_clone,
+                        * $a0 = flags,
+                        * $a1 = child_stack,
+                        * $a2 = parent_tidptr,
+                        * $a3 = new_tls,
+                        * $a4 = child_tidptr)
+                        */
+                       ".cprestore 16;\n"
+                       "move $4,%1;\n"
+                       "move $5,%2;\n"
+                       "move $6,%3;\n"
+                       "move $7,%4;\n"
+                       /* Store the fifth argument on stack
+                        * if we are using 32-bit abi.
+                        */
+#if SANITIZER_WORDSIZE == 32
+                       "lw %5,16($29);\n"
+#else
+                       "move $8,%5;\n"
+#endif
+                       "li $2,%6;\n"
+                       "syscall;\n"
+
+                       /* if ($v0 != 0)
+                        * return;
+                        */
+                       "bnez $2,1f;\n"
+
+                       /* Call "fn(arg)". */
+                       "ld $25,0($29);\n"
+                       "ld $4,8($29);\n"
+                       "jal $25;\n"
+
+                       /* Call _exit($v0). */
+                       "move $4,$2;\n"
+                       "li $2,%7;\n"
+                       "syscall;\n"
+
+                       /* Return to parent. */
+                     "1:\n"
+                       : "=r" (res)
+                       : "r"(flags),
+                         "r"(child_stack),
+                         "r"(parent_tidptr),
+                         "r"(a3),
+                         "r"(a4),
+                         "i"(__NR_clone),
+                         "i"(__NR_exit)
+                       : "memory", "$29" );
+  return res;
+}
+#elif defined(__aarch64__)
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  long long res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
+  ((unsigned long long *)child_stack)[0] = (uptr)fn;
+  ((unsigned long long *)child_stack)[1] = (uptr)arg;
+
+  register int (*__fn)(void *)  __asm__("x0") = fn;
+  register void *__stack __asm__("x1") = child_stack;
+  register int   __flags __asm__("x2") = flags;
+  register void *__arg   __asm__("x3") = arg;
+  register int  *__ptid  __asm__("x4") = parent_tidptr;
+  register void *__tls   __asm__("x5") = newtls;
+  register int  *__ctid  __asm__("x6") = child_tidptr;
+
+  __asm__ __volatile__(
+                       "mov x0,x2\n" /* flags  */
+                       "mov x2,x4\n" /* ptid  */
+                       "mov x3,x5\n" /* tls  */
+                       "mov x4,x6\n" /* ctid  */
+                       "mov x8,%9\n" /* clone  */
+
+                       "svc 0x0\n"
+
+                       /* if (%r0 != 0)
+                        *   return %r0;
+                        */
+                       "cmp x0, #0\n"
+                       "bne 1f\n"
+
+                       /* In the child, now. Call "fn(arg)". */
+                       "ldp x1, x0, [sp], #16\n"
+                       "blr x1\n"
+
+                       /* Call _exit(%r0).  */
+                       "mov x8, %10\n"
+                       "svc 0x0\n"
+                     "1:\n"
+
+                       : "=r" (res)
+                       : "i"(-EINVAL),
+                         "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg),
+                         "r"(__ptid), "r"(__tls), "r"(__ctid),
+                         "i"(__NR_clone), "i"(__NR_exit)
+                       : "x30", "memory");
+  return res;
+}
+#elif defined(__powerpc64__)
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                   int *parent_tidptr, void *newtls, int *child_tidptr) {
+  long long res;
+/* Stack frame offsets.  */
+#if _CALL_ELF != 2
+#define FRAME_MIN_SIZE         112
+#define FRAME_TOC_SAVE         40
+#else
+#define FRAME_MIN_SIZE         32
+#define FRAME_TOC_SAVE         24
+#endif
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
+  ((unsigned long long *)child_stack)[0] = (uptr)fn;
+  ((unsigned long long *)child_stack)[1] = (uptr)arg;
+
+  register int (*__fn)(void *) __asm__("r3") = fn;
+  register void *__cstack      __asm__("r4") = child_stack;
+  register int __flags         __asm__("r5") = flags;
+  register void * __arg        __asm__("r6") = arg;
+  register int * __ptidptr     __asm__("r7") = parent_tidptr;
+  register void * __newtls     __asm__("r8") = newtls;
+  register int * __ctidptr     __asm__("r9") = child_tidptr;
+
+ __asm__ __volatile__(
+           /* fn, arg, child_stack are saved acrVoss the syscall */
+           "mr 28, %5\n\t"
+           "mr 29, %6\n\t"
+           "mr 27, %8\n\t"
+
+           /* syscall
+             r3 == flags
+             r4 == child_stack
+             r5 == parent_tidptr
+             r6 == newtls
+             r7 == child_tidptr */
+           "mr 3, %7\n\t"
+           "mr 5, %9\n\t"
+           "mr 6, %10\n\t"
+           "mr 7, %11\n\t"
+           "li 0, %3\n\t"
+           "sc\n\t"
+
+           /* Test if syscall was successful */
+           "cmpdi  cr1, 3, 0\n\t"
+           "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
+           "bne-   cr1, 1f\n\t"
+
+           /* Do the function call */
+           "std   2, %13(1)\n\t"
+#if _CALL_ELF != 2
+           "ld    0, 0(28)\n\t"
+           "ld    2, 8(28)\n\t"
+           "mtctr 0\n\t"
+#else
+           "mr    12, 28\n\t"
+           "mtctr 12\n\t"
+#endif
+           "mr    3, 27\n\t"
+           "bctrl\n\t"
+           "ld    2, %13(1)\n\t"
+
+           /* Call _exit(r3) */
+           "li 0, %4\n\t"
+           "sc\n\t"
+
+           /* Return to parent */
+           "1:\n\t"
+           "mr %0, 3\n\t"
+             : "=r" (res)
+             : "0" (-1), "i" (EINVAL),
+               "i" (__NR_clone), "i" (__NR_exit),
+               "r" (__fn), "r" (__cstack), "r" (__flags),
+               "r" (__arg), "r" (__ptidptr), "r" (__newtls),
+               "r" (__ctidptr), "i" (FRAME_MIN_SIZE), "i" (FRAME_TOC_SAVE)
+             : "cr0", "cr1", "memory", "ctr",
+               "r0", "r29", "r27", "r28");
+  return res;
+}
+#endif  // defined(__x86_64__) && SANITIZER_LINUX
+
+#if SANITIZER_ANDROID
+#if __ANDROID_API__ < 21
+extern "C" __attribute__((weak)) int dl_iterate_phdr(
+    int (*)(struct dl_phdr_info *, size_t, void *), void *);
+#endif
+
+static int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
+                                   void *data) {
+  // Any name starting with "lib" indicates a bug in L where library base names
+  // are returned instead of paths.
+  if (info->dlpi_name && info->dlpi_name[0] == 'l' &&
+      info->dlpi_name[1] == 'i' && info->dlpi_name[2] == 'b') {
+    *(bool *)data = true;
+    return 1;
+  }
+  return 0;
+}
+
+static atomic_uint32_t android_api_level;
+
+static AndroidApiLevel AndroidDetectApiLevel() {
+  if (!&dl_iterate_phdr)
+    return ANDROID_KITKAT; // K or lower
+  bool base_name_seen = false;
+  dl_iterate_phdr(dl_iterate_phdr_test_cb, &base_name_seen);
+  if (base_name_seen)
+    return ANDROID_LOLLIPOP_MR1; // L MR1
+  return ANDROID_POST_LOLLIPOP;   // post-L
+  // Plain L (API level 21) is completely broken wrt ASan and not very
+  // interesting to detect.
+}
+
+AndroidApiLevel AndroidGetApiLevel() {
+  AndroidApiLevel level =
+      (AndroidApiLevel)atomic_load(&android_api_level, memory_order_relaxed);
+  if (level) return level;
+  level = AndroidDetectApiLevel();
+  atomic_store(&android_api_level, level, memory_order_relaxed);
+  return level;
+}
+
+#endif
+
+bool IsDeadlySignal(int signum) {
+  if (common_flags()->handle_abort && signum == SIGABRT)
+    return true;
+  if (common_flags()->handle_sigill && signum == SIGILL)
+    return true;
+  if (common_flags()->handle_sigfpe && signum == SIGFPE)
+    return true;
+  return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
+}
+
+#ifndef SANITIZER_GO
+void *internal_start_thread(void(*func)(void *arg), void *arg) {
+  // Start the thread with signals blocked, otherwise it can steal user signals.
+  __sanitizer_sigset_t set, old;
+  internal_sigfillset(&set);
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  // Glibc uses SIGSETXID signal during setuid call. If this signal is blocked
+  // on any thread, setuid call hangs (see test/tsan/setuid.c).
+  internal_sigdelset(&set, 33);
+#endif
+  internal_sigprocmask(SIG_SETMASK, &set, &old);
+  void *th;
+  real_pthread_create(&th, nullptr, (void*(*)(void *arg))func, arg);
+  internal_sigprocmask(SIG_SETMASK, &old, nullptr);
+  return th;
+}
+
+void internal_join_thread(void *th) {
+  real_pthread_join(th, nullptr);
+}
+#else
+void *internal_start_thread(void (*func)(void *), void *arg) { return 0; }
+
+void internal_join_thread(void *th) {}
+#endif
+
+void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
+#if defined(__arm__)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.arm_pc;
+  *bp = ucontext->uc_mcontext.arm_fp;
+  *sp = ucontext->uc_mcontext.arm_sp;
+#elif defined(__aarch64__)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.pc;
+  *bp = ucontext->uc_mcontext.regs[29];
+  *sp = ucontext->uc_mcontext.sp;
+#elif defined(__hppa__)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.sc_iaoq[0];
+  /* GCC uses %r3 whenever a frame pointer is needed.  */
+  *bp = ucontext->uc_mcontext.sc_gr[3];
+  *sp = ucontext->uc_mcontext.sc_gr[30];
+#elif defined(__x86_64__)
+# if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.mc_rip;
+  *bp = ucontext->uc_mcontext.mc_rbp;
+  *sp = ucontext->uc_mcontext.mc_rsp;
+# else
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.gregs[REG_RIP];
+  *bp = ucontext->uc_mcontext.gregs[REG_RBP];
+  *sp = ucontext->uc_mcontext.gregs[REG_RSP];
+# endif
+#elif defined(__i386__)
+# if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.mc_eip;
+  *bp = ucontext->uc_mcontext.mc_ebp;
+  *sp = ucontext->uc_mcontext.mc_esp;
+# else
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.gregs[REG_EIP];
+  *bp = ucontext->uc_mcontext.gregs[REG_EBP];
+  *sp = ucontext->uc_mcontext.gregs[REG_ESP];
+# endif
+#elif defined(__powerpc__) || defined(__powerpc64__)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.regs->nip;
+  *sp = ucontext->uc_mcontext.regs->gpr[PT_R1];
+  // The powerpc{,64}-linux ABIs do not specify r31 as the frame
+  // pointer, but GCC always uses r31 when we need a frame pointer.
+  *bp = ucontext->uc_mcontext.regs->gpr[PT_R31];
+#elif defined(__sparc__)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  uptr *stk_ptr;
+# if defined (__arch64__)
+  *pc = ucontext->uc_mcontext.mc_gregs[MC_PC];
+  *sp = ucontext->uc_mcontext.mc_gregs[MC_O6];
+  stk_ptr = (uptr *) (*sp + 2047);
+  *bp = stk_ptr[15];
+# else
+  *pc = ucontext->uc_mcontext.gregs[REG_PC];
+  *sp = ucontext->uc_mcontext.gregs[REG_O6];
+  stk_ptr = (uptr *) *sp;
+  *bp = stk_ptr[15];
+# endif
+#elif defined(__mips__)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.pc;
+  *bp = ucontext->uc_mcontext.gregs[30];
+  *sp = ucontext->uc_mcontext.gregs[29];
+#else
+# error "Unsupported arch"
+#endif
+}
+
+void DisableReexec() {
+  // No need to re-exec on Linux.
+}
+
+void MaybeReexec() {
+  // No need to re-exec on Linux.
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_linux.h b/compiler-rt/lib/sanitizer_common/sanitizer_linux.h
new file mode 100644
index 0000000..77bfbd1
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_linux.h
@@ -0,0 +1,90 @@
+//===-- sanitizer_linux.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Linux-specific syscall wrappers and classes.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_LINUX_H
+#define SANITIZER_LINUX_H
+
+#include "sanitizer_platform.h"
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+#include "sanitizer_common.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_posix.h"
+#include "sanitizer_platform_limits_posix.h"
+
+struct link_map;  // Opaque type returned by dlopen().
+struct sigaltstack;
+
+namespace __sanitizer {
+// Dirent structure for getdents(). Note that this structure is different from
+// the one in <dirent.h>, which is used by readdir().
+struct linux_dirent;
+
+// Syscall wrappers.
+uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count);
+uptr internal_sigaltstack(const struct sigaltstack* ss,
+                          struct sigaltstack* oss);
+uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
+    __sanitizer_sigset_t *oldset);
+void internal_sigfillset(__sanitizer_sigset_t *set);
+
+// Linux-only syscalls.
+#if SANITIZER_LINUX
+uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
+// Used only by sanitizer_stoptheworld. Signal handlers that are actually used
+// (like the process-wide error reporting SEGV handler) must use
+// internal_sigaction instead.
+int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
+void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
+#if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) \
+  || defined(__powerpc64__)
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr);
+#endif
+#endif  // SANITIZER_LINUX
+
+// This class reads thread IDs from /proc/<pid>/task using only syscalls.
+class ThreadLister {
+ public:
+  explicit ThreadLister(int pid);
+  ~ThreadLister();
+  // GetNextTID returns -1 if the list of threads is exhausted, or if there has
+  // been an error.
+  int GetNextTID();
+  void Reset();
+  bool error();
+
+ private:
+  bool GetDirectoryEntries();
+
+  int pid_;
+  int descriptor_;
+  InternalScopedBuffer<char> buffer_;
+  bool error_;
+  struct linux_dirent* entry_;
+  int bytes_read_;
+};
+
+// Exposed for testing.
+uptr ThreadDescriptorSize();
+uptr ThreadSelf();
+uptr ThreadSelfOffset();
+
+// Matches a library's file name against a base name (stripping path and version
+// information).
+bool LibraryNameIs(const char *full_name, const char *base_name);
+
+// Call cb for each region mapped by map.
+void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr));
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FREEBSD || SANITIZER_LINUX
+#endif  // SANITIZER_LINUX_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cc
new file mode 100644
index 0000000..0fb67f3
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cc
@@ -0,0 +1,548 @@
+//===-- sanitizer_linux_libcdep.cc ----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries and implements linux-specific functions from
+// sanitizer_libc.h.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_freebsd.h"
+#include "sanitizer_linux.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_procmaps.h"
+#include "sanitizer_stacktrace.h"
+
+#if SANITIZER_ANDROID || SANITIZER_FREEBSD
+#include <dlfcn.h>  // for dlsym()
+#endif
+
+#include <link.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/resource.h>
+
+#if SANITIZER_FREEBSD
+#include <pthread_np.h>
+#include <osreldate.h>
+#define pthread_getattr_np pthread_attr_get_np
+#endif
+
+#if SANITIZER_LINUX
+#include <sys/prctl.h>
+#endif
+
+#if SANITIZER_ANDROID
+#include <android/api-level.h>
+#endif
+
+#if SANITIZER_ANDROID && __ANDROID_API__ < 21
+#include <android/log.h>
+#else
+#include <syslog.h>
+#endif
+
+#if !SANITIZER_ANDROID
+#include <elf.h>
+#include <unistd.h>
+#endif
+
+namespace __sanitizer {
+
+SANITIZER_WEAK_ATTRIBUTE int
+real_sigaction(int signum, const void *act, void *oldact);
+
+int internal_sigaction(int signum, const void *act, void *oldact) {
+#if !SANITIZER_GO
+  if (&real_sigaction)
+    return real_sigaction(signum, act, oldact);
+#endif
+  return sigaction(signum, (const struct sigaction *)act,
+                   (struct sigaction *)oldact);
+}
+
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+                                uptr *stack_bottom) {
+  CHECK(stack_top);
+  CHECK(stack_bottom);
+  if (at_initialization) {
+    // This is the main thread. Libpthread may not be initialized yet.
+    struct rlimit rl;
+    CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
+
+    // Find the mapping that contains a stack variable.
+    MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+    uptr start, end, offset;
+    uptr prev_end = 0;
+    while (proc_maps.Next(&start, &end, &offset, nullptr, 0,
+          /* protection */nullptr)) {
+      if ((uptr)&rl < end)
+        break;
+      prev_end = end;
+    }
+    CHECK((uptr)&rl >= start && (uptr)&rl < end);
+
+    // Get stacksize from rlimit, but clip it so that it does not overlap
+    // with other mappings.
+    uptr stacksize = rl.rlim_cur;
+    if (stacksize > end - prev_end)
+      stacksize = end - prev_end;
+    // When running with unlimited stack size, we still want to set some limit.
+    // The unlimited stack size is caused by 'ulimit -s unlimited'.
+    // Also, for some reason, GNU make spawns subprocesses with unlimited stack.
+    if (stacksize > kMaxThreadStackSize)
+      stacksize = kMaxThreadStackSize;
+    *stack_top = end;
+    *stack_bottom = end - stacksize;
+    return;
+  }
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  CHECK_EQ(pthread_getattr_np(pthread_self(), &attr), 0);
+  uptr stacksize = 0;
+  void *stackaddr = nullptr;
+  my_pthread_attr_getstack(&attr, &stackaddr, &stacksize);
+  pthread_attr_destroy(&attr);
+
+  CHECK_LE(stacksize, kMaxThreadStackSize);  // Sanity check.
+  *stack_top = (uptr)stackaddr + stacksize;
+  *stack_bottom = (uptr)stackaddr;
+}
+
+#if !SANITIZER_GO
+bool SetEnv(const char *name, const char *value) {
+  void *f = dlsym(RTLD_NEXT, "setenv");
+  if (!f)
+    return false;
+  typedef int(*setenv_ft)(const char *name, const char *value, int overwrite);
+  setenv_ft setenv_f;
+  CHECK_EQ(sizeof(setenv_f), sizeof(f));
+  internal_memcpy(&setenv_f, &f, sizeof(f));
+  return setenv_f(name, value, 1) == 0;
+}
+#endif
+
+bool SanitizerSetThreadName(const char *name) {
+#ifdef PR_SET_NAME
+  return 0 == prctl(PR_SET_NAME, (unsigned long)name, 0, 0, 0);  // NOLINT
+#else
+  return false;
+#endif
+}
+
+bool SanitizerGetThreadName(char *name, int max_len) {
+#ifdef PR_GET_NAME
+  char buff[17];
+  if (prctl(PR_GET_NAME, (unsigned long)buff, 0, 0, 0))  // NOLINT
+    return false;
+  internal_strncpy(name, buff, max_len);
+  name[max_len] = 0;
+  return true;
+#else
+  return false;
+#endif
+}
+
+#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
+static uptr g_tls_size;
+
+#ifdef __i386__
+# define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
+#else
+# define DL_INTERNAL_FUNCTION
+#endif
+
+void InitTlsSize() {
+// all current supported platforms have 16 bytes stack alignment
+  const size_t kStackAlign = 16;
+  typedef void (*get_tls_func)(size_t*, size_t*) DL_INTERNAL_FUNCTION;
+  get_tls_func get_tls;
+  void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
+  CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr));
+  internal_memcpy(&get_tls, &get_tls_static_info_ptr,
+                  sizeof(get_tls_static_info_ptr));
+  CHECK_NE(get_tls, 0);
+  size_t tls_size = 0;
+  size_t tls_align = 0;
+  get_tls(&tls_size, &tls_align);
+  if (tls_align < kStackAlign)
+    tls_align = kStackAlign;
+  g_tls_size = RoundUpTo(tls_size, tls_align);
+}
+#else
+void InitTlsSize() { }
+#endif  // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
+
+#if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) \
+    || defined(__aarch64__) || defined(__powerpc64__)) \
+    && SANITIZER_LINUX && !SANITIZER_ANDROID
+// sizeof(struct pthread) from glibc.
+static atomic_uintptr_t kThreadDescriptorSize;
+
+uptr ThreadDescriptorSize() {
+  uptr val = atomic_load(&kThreadDescriptorSize, memory_order_relaxed);
+  if (val)
+    return val;
+#if defined(__x86_64__) || defined(__i386__)
+#ifdef _CS_GNU_LIBC_VERSION
+  char buf[64];
+  uptr len = confstr(_CS_GNU_LIBC_VERSION, buf, sizeof(buf));
+  if (len < sizeof(buf) && internal_strncmp(buf, "glibc 2.", 8) == 0) {
+    char *end;
+    int minor = internal_simple_strtoll(buf + 8, &end, 10);
+    if (end != buf + 8 && (*end == '\0' || *end == '.')) {
+      /* sizeof(struct pthread) values from various glibc versions.  */
+      if (SANITIZER_X32)
+        val = 1728;  // Assume only one particular version for x32.
+      else if (minor <= 3)
+        val = FIRST_32_SECOND_64(1104, 1696);
+      else if (minor == 4)
+        val = FIRST_32_SECOND_64(1120, 1728);
+      else if (minor == 5)
+        val = FIRST_32_SECOND_64(1136, 1728);
+      else if (minor <= 9)
+        val = FIRST_32_SECOND_64(1136, 1712);
+      else if (minor == 10)
+        val = FIRST_32_SECOND_64(1168, 1776);
+      else if (minor <= 12)
+        val = FIRST_32_SECOND_64(1168, 2288);
+      else if (minor == 13)
+        val = FIRST_32_SECOND_64(1168, 2304);
+      else
+        val = FIRST_32_SECOND_64(1216, 2304);
+    }
+    if (val)
+      atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
+    return val;
+  }
+#endif
+#elif defined(__mips__)
+  // TODO(sagarthakur): add more values as per different glibc versions.
+  val = FIRST_32_SECOND_64(1152, 1776);
+  if (val)
+    atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
+  return val;
+#elif defined(__aarch64__)
+  // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
+  val = 1776;
+  atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
+  return val;
+#elif defined(__powerpc64__)
+  val = 1776; // from glibc.ppc64le 2.20-8.fc21
+  atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
+  return val;
+#endif
+  return 0;
+}
+
+// The offset at which pointer to self is located in the thread descriptor.
+const uptr kThreadSelfOffset = FIRST_32_SECOND_64(8, 16);
+
+uptr ThreadSelfOffset() {
+  return kThreadSelfOffset;
+}
+
+#if defined(__mips__) || defined(__powerpc64__)
+// TlsPreTcbSize includes size of struct pthread_descr and size of tcb
+// head structure. It lies before the static tls blocks.
+static uptr TlsPreTcbSize() {
+# if defined(__mips__)
+  const uptr kTcbHead = 16; // sizeof (tcbhead_t)
+# elif defined(__powerpc64__)
+  const uptr kTcbHead = 88; // sizeof (tcbhead_t)
+# endif
+  const uptr kTlsAlign = 16;
+  const uptr kTlsPreTcbSize =
+    (ThreadDescriptorSize() + kTcbHead + kTlsAlign - 1) & ~(kTlsAlign - 1);
+  InitTlsSize();
+  g_tls_size = (g_tls_size + kTlsPreTcbSize + kTlsAlign -1) & ~(kTlsAlign - 1);
+  return kTlsPreTcbSize;
+}
+#endif
+
+uptr ThreadSelf() {
+  uptr descr_addr;
+# if defined(__i386__)
+  asm("mov %%gs:%c1,%0" : "=r"(descr_addr) : "i"(kThreadSelfOffset));
+# elif defined(__x86_64__)
+  asm("mov %%fs:%c1,%0" : "=r"(descr_addr) : "i"(kThreadSelfOffset));
+# elif defined(__mips__)
+  // MIPS uses TLS variant I. The thread pointer (in hardware register $29)
+  // points to the end of the TCB + 0x7000. The pthread_descr structure is
+  // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
+  // TCB and the size of pthread_descr.
+  const uptr kTlsTcbOffset = 0x7000;
+  uptr thread_pointer;
+  asm volatile(".set push;\
+                .set mips64r2;\
+                rdhwr %0,$29;\
+                .set pop" : "=r" (thread_pointer));
+  descr_addr = thread_pointer - kTlsTcbOffset - TlsPreTcbSize();
+# elif defined(__aarch64__)
+  descr_addr = reinterpret_cast<uptr>(__builtin_thread_pointer());
+# elif defined(__powerpc64__)
+  // PPC64LE uses TLS variant I. The thread pointer (in GPR 13)
+  // points to the end of the TCB + 0x7000. The pthread_descr structure is
+  // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
+  // TCB and the size of pthread_descr.
+  const uptr kTlsTcbOffset = 0x7000;
+  uptr thread_pointer;
+  asm("addi %0,13,%1" : "=r"(thread_pointer) : "I"(-kTlsTcbOffset));
+  descr_addr = thread_pointer - TlsPreTcbSize();
+# else
+#  error "unsupported CPU arch"
+# endif
+  return descr_addr;
+}
+#endif  // (x86_64 || i386 || MIPS) && SANITIZER_LINUX
+
+#if SANITIZER_FREEBSD
+static void **ThreadSelfSegbase() {
+  void **segbase = 0;
+# if defined(__i386__)
+  // sysarch(I386_GET_GSBASE, segbase);
+  __asm __volatile("mov %%gs:0, %0" : "=r" (segbase));
+# elif defined(__x86_64__)
+  // sysarch(AMD64_GET_FSBASE, segbase);
+  __asm __volatile("movq %%fs:0, %0" : "=r" (segbase));
+# else
+#  error "unsupported CPU arch for FreeBSD platform"
+# endif
+  return segbase;
+}
+
+uptr ThreadSelf() {
+  return (uptr)ThreadSelfSegbase()[2];
+}
+#endif  // SANITIZER_FREEBSD
+
+#if !SANITIZER_GO
+static void GetTls(uptr *addr, uptr *size) {
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+# if defined(__x86_64__) || defined(__i386__)
+  *addr = ThreadSelf();
+  *size = GetTlsSize();
+  *addr -= *size;
+  *addr += ThreadDescriptorSize();
+# elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__)
+  *addr = ThreadSelf();
+  *size = GetTlsSize();
+# else
+  *addr = 0;
+  *size = 0;
+# endif
+#elif SANITIZER_FREEBSD
+  void** segbase = ThreadSelfSegbase();
+  *addr = 0;
+  *size = 0;
+  if (segbase != 0) {
+    // tcbalign = 16
+    // tls_size = round(tls_static_space, tcbalign);
+    // dtv = segbase[1];
+    // dtv[2] = segbase - tls_static_space;
+    void **dtv = (void**) segbase[1];
+    *addr = (uptr) dtv[2];
+    *size = (*addr == 0) ? 0 : ((uptr) segbase[0] - (uptr) dtv[2]);
+  }
+#elif SANITIZER_ANDROID
+  *addr = 0;
+  *size = 0;
+#else
+# error "Unknown OS"
+#endif
+}
+#endif
+
+#if !SANITIZER_GO
+uptr GetTlsSize() {
+#if SANITIZER_FREEBSD || SANITIZER_ANDROID
+  uptr addr, size;
+  GetTls(&addr, &size);
+  return size;
+#else
+  return g_tls_size;
+#endif
+}
+#endif
+
+void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
+                          uptr *tls_addr, uptr *tls_size) {
+#if SANITIZER_GO
+  // Stub implementation for Go.
+  *stk_addr = *stk_size = *tls_addr = *tls_size = 0;
+#else
+  GetTls(tls_addr, tls_size);
+
+  uptr stack_top, stack_bottom;
+  GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
+  *stk_addr = stack_bottom;
+  *stk_size = stack_top - stack_bottom;
+
+  if (!main) {
+    // If stack and tls intersect, make them non-intersecting.
+    if (*tls_addr > *stk_addr && *tls_addr < *stk_addr + *stk_size) {
+      CHECK_GT(*tls_addr + *tls_size, *stk_addr);
+      CHECK_LE(*tls_addr + *tls_size, *stk_addr + *stk_size);
+      *stk_size -= *tls_size;
+      *tls_addr = *stk_addr + *stk_size;
+    }
+  }
+#endif
+}
+
+# if !SANITIZER_FREEBSD
+typedef ElfW(Phdr) Elf_Phdr;
+# elif SANITIZER_WORDSIZE == 32 && __FreeBSD_version <= 902001  // v9.2
+#  define Elf_Phdr XElf32_Phdr
+#  define dl_phdr_info xdl_phdr_info
+#  define dl_iterate_phdr(c, b) xdl_iterate_phdr((c), (b))
+# endif
+
+struct DlIteratePhdrData {
+  LoadedModule *modules;
+  uptr current_n;
+  bool first;
+  uptr max_n;
+  string_predicate_t filter;
+};
+
+static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
+  DlIteratePhdrData *data = (DlIteratePhdrData*)arg;
+  if (data->current_n == data->max_n)
+    return 0;
+  InternalScopedString module_name(kMaxPathLength);
+  if (data->first) {
+    data->first = false;
+    // First module is the binary itself.
+    ReadBinaryNameCached(module_name.data(), module_name.size());
+  } else if (info->dlpi_name) {
+    module_name.append("%s", info->dlpi_name);
+  }
+  if (module_name[0] == '\0')
+    return 0;
+  if (data->filter && !data->filter(module_name.data()))
+    return 0;
+  LoadedModule *cur_module = &data->modules[data->current_n];
+  cur_module->set(module_name.data(), info->dlpi_addr);
+  data->current_n++;
+  for (int i = 0; i < info->dlpi_phnum; i++) {
+    const Elf_Phdr *phdr = &info->dlpi_phdr[i];
+    if (phdr->p_type == PT_LOAD) {
+      uptr cur_beg = info->dlpi_addr + phdr->p_vaddr;
+      uptr cur_end = cur_beg + phdr->p_memsz;
+      bool executable = phdr->p_flags & PF_X;
+      cur_module->addAddressRange(cur_beg, cur_end, executable);
+    }
+  }
+  return 0;
+}
+
+#if SANITIZER_ANDROID && __ANDROID_API__ < 21
+extern "C" __attribute__((weak)) int dl_iterate_phdr(
+    int (*)(struct dl_phdr_info *, size_t, void *), void *);
+#endif
+
+uptr GetListOfModules(LoadedModule *modules, uptr max_modules,
+                      string_predicate_t filter) {
+#if SANITIZER_ANDROID && __ANDROID_API__ <= 22
+  u32 api_level = AndroidGetApiLevel();
+  // Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
+  // The runtime check allows the same library to work with
+  // both K and L (and future) Android releases.
+  if (api_level <= ANDROID_LOLLIPOP_MR1) { // L or earlier
+    MemoryMappingLayout memory_mapping(false);
+    return memory_mapping.DumpListOfModules(modules, max_modules, filter);
+  }
+#endif
+  CHECK(modules);
+  DlIteratePhdrData data = {modules, 0, true, max_modules, filter};
+  dl_iterate_phdr(dl_iterate_phdr_cb, &data);
+  return data.current_n;
+}
+
+// getrusage does not give us the current RSS, only the max RSS.
+// Still, this is better than nothing if /proc/self/statm is not available
+// for some reason, e.g. due to a sandbox.
+static uptr GetRSSFromGetrusage() {
+  struct rusage usage;
+  if (getrusage(RUSAGE_SELF, &usage))  // Failed, probably due to a sandbox.
+    return 0;
+  return usage.ru_maxrss << 10;  // ru_maxrss is in Kb.
+}
+
+uptr GetRSS() {
+  if (!common_flags()->can_use_proc_maps_statm)
+    return GetRSSFromGetrusage();
+  fd_t fd = OpenFile("/proc/self/statm", RdOnly);
+  if (fd == kInvalidFd)
+    return GetRSSFromGetrusage();
+  char buf[64];
+  uptr len = internal_read(fd, buf, sizeof(buf) - 1);
+  internal_close(fd);
+  if ((sptr)len <= 0)
+    return 0;
+  buf[len] = 0;
+  // The format of the file is:
+  // 1084 89 69 11 0 79 0
+  // We need the second number which is RSS in pages.
+  char *pos = buf;
+  // Skip the first number.
+  while (*pos >= '0' && *pos <= '9')
+    pos++;
+  // Skip whitespaces.
+  while (!(*pos >= '0' && *pos <= '9') && *pos != 0)
+    pos++;
+  // Read the number.
+  uptr rss = 0;
+  while (*pos >= '0' && *pos <= '9')
+    rss = rss * 10 + *pos++ - '0';
+  return rss * GetPageSizeCached();
+}
+
+// 64-bit Android targets don't provide the deprecated __android_log_write.
+// Starting with the L release, syslog() works and is preferable to
+// __android_log_write.
+#if SANITIZER_LINUX
+
+#if SANITIZER_ANDROID
+static atomic_uint8_t android_log_initialized;
+
+void AndroidLogInit() {
+  atomic_store(&android_log_initialized, 1, memory_order_release);
+}
+
+bool ShouldLogAfterPrintf() {
+  return atomic_load(&android_log_initialized, memory_order_acquire);
+}
+#else
+void AndroidLogInit() {}
+
+bool ShouldLogAfterPrintf() { return true; }
+#endif  // SANITIZER_ANDROID
+
+void WriteOneLineToSyslog(const char *s) {
+#if SANITIZER_ANDROID &&__ANDROID_API__ < 21
+  __android_log_write(ANDROID_LOG_INFO, NULL, s);
+#else
+  syslog(LOG_INFO, "%s", s);
+#endif
+}
+
+#endif // SANITIZER_LINUX
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_list.h b/compiler-rt/lib/sanitizer_common/sanitizer_list.h
new file mode 100644
index 0000000..adbb97d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_list.h
@@ -0,0 +1,146 @@
+//===-- sanitizer_list.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains implementation of a list class to be used by
+// ThreadSanitizer, etc run-times.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_LIST_H
+#define SANITIZER_LIST_H
+
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+// Intrusive singly-linked list with size(), push_back(), push_front()
+// pop_front(), append_front() and append_back().
+// This class should be a POD (so that it can be put into TLS)
+// and an object with all zero fields should represent a valid empty list.
+// This class does not have a CTOR, so clear() should be called on all
+// non-zero-initialized objects before using.
+template<class Item>
+struct IntrusiveList {
+  friend class Iterator;
+
+  void clear() {
+    first_ = last_ = nullptr;
+    size_ = 0;
+  }
+
+  bool empty() const { return size_ == 0; }
+  uptr size() const { return size_; }
+
+  void push_back(Item *x) {
+    if (empty()) {
+      x->next = nullptr;
+      first_ = last_ = x;
+      size_ = 1;
+    } else {
+      x->next = nullptr;
+      last_->next = x;
+      last_ = x;
+      size_++;
+    }
+  }
+
+  void push_front(Item *x) {
+    if (empty()) {
+      x->next = nullptr;
+      first_ = last_ = x;
+      size_ = 1;
+    } else {
+      x->next = first_;
+      first_ = x;
+      size_++;
+    }
+  }
+
+  void pop_front() {
+    CHECK(!empty());
+    first_ = first_->next;
+    if (!first_)
+      last_ = nullptr;
+    size_--;
+  }
+
+  Item *front() { return first_; }
+  Item *back() { return last_; }
+
+  void append_front(IntrusiveList<Item> *l) {
+    CHECK_NE(this, l);
+    if (l->empty())
+      return;
+    if (empty()) {
+      *this = *l;
+    } else if (!l->empty()) {
+      l->last_->next = first_;
+      first_ = l->first_;
+      size_ += l->size();
+    }
+    l->clear();
+  }
+
+  void append_back(IntrusiveList<Item> *l) {
+    CHECK_NE(this, l);
+    if (l->empty())
+      return;
+    if (empty()) {
+      *this = *l;
+    } else {
+      last_->next = l->first_;
+      last_ = l->last_;
+      size_ += l->size();
+    }
+    l->clear();
+  }
+
+  void CheckConsistency() {
+    if (size_ == 0) {
+      CHECK_EQ(first_, 0);
+      CHECK_EQ(last_, 0);
+    } else {
+      uptr count = 0;
+      for (Item *i = first_; ; i = i->next) {
+        count++;
+        if (i == last_) break;
+      }
+      CHECK_EQ(size(), count);
+      CHECK_EQ(last_->next, 0);
+    }
+  }
+
+  template<class ListTy, class ItemTy>
+  class IteratorBase {
+   public:
+    explicit IteratorBase(ListTy *list)
+        : list_(list), current_(list->first_) { }
+    ItemTy *next() {
+      ItemTy *ret = current_;
+      if (current_) current_ = current_->next;
+      return ret;
+    }
+    bool hasNext() const { return current_ != nullptr; }
+   private:
+    ListTy *list_;
+    ItemTy *current_;
+  };
+
+  typedef IteratorBase<IntrusiveList<Item>, Item> Iterator;
+  typedef IteratorBase<const IntrusiveList<Item>, const Item> ConstIterator;
+
+// private, don't use directly.
+  uptr size_;
+  Item *first_;
+  Item *last_;
+};
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_LIST_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_mac.cc b/compiler-rt/lib/sanitizer_common/sanitizer_mac.cc
new file mode 100644
index 0000000..1c96a6b
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_mac.cc
@@ -0,0 +1,667 @@
+//===-- sanitizer_mac.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries and
+// implements OSX-specific functions.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_MAC
+#include "sanitizer_mac.h"
+
+// Use 64-bit inodes in file operations. ASan does not support OS X 10.5, so
+// the clients will most certainly use 64-bit ones as well.
+#ifndef _DARWIN_USE_64_BIT_INODE
+#define _DARWIN_USE_64_BIT_INODE 1
+#endif
+#include <stdio.h>
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_platform_limits_posix.h"
+#include "sanitizer_procmaps.h"
+
+#if !SANITIZER_IOS
+#include <crt_externs.h>  // for _NSGetEnviron
+#else
+extern char **environ;
+#endif
+
+#if defined(__has_include) && __has_include(<os/trace.h>)
+#define SANITIZER_OS_TRACE 1
+#include <os/trace.h>
+#else
+#define SANITIZER_OS_TRACE 0
+#endif
+
+#if !SANITIZER_IOS
+#include <crt_externs.h>  // for _NSGetArgv and _NSGetEnviron
+#else
+extern "C" {
+  extern char ***_NSGetArgv(void);
+}
+#endif
+
+#include <asl.h>
+#include <dlfcn.h>  // for dladdr()
+#include <errno.h>
+#include <fcntl.h>
+#include <libkern/OSAtomic.h>
+#include <mach-o/dyld.h>
+#include <mach/mach.h>
+#include <mach/vm_statistics.h>
+#include <pthread.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <util.h>
+
+namespace __sanitizer {
+
+#include "sanitizer_syscall_generic.inc"
+
+// ---------------------- sanitizer_libc.h
+uptr internal_mmap(void *addr, size_t length, int prot, int flags,
+                   int fd, u64 offset) {
+  if (fd == -1) fd = VM_MAKE_TAG(VM_MEMORY_ANALYSIS_TOOL);
+  return (uptr)mmap(addr, length, prot, flags, fd, offset);
+}
+
+uptr internal_munmap(void *addr, uptr length) {
+  return munmap(addr, length);
+}
+
+int internal_mprotect(void *addr, uptr length, int prot) {
+  return mprotect(addr, length, prot);
+}
+
+uptr internal_close(fd_t fd) {
+  return close(fd);
+}
+
+uptr internal_open(const char *filename, int flags) {
+  return open(filename, flags);
+}
+
+uptr internal_open(const char *filename, int flags, u32 mode) {
+  return open(filename, flags, mode);
+}
+
+uptr internal_read(fd_t fd, void *buf, uptr count) {
+  return read(fd, buf, count);
+}
+
+uptr internal_write(fd_t fd, const void *buf, uptr count) {
+  return write(fd, buf, count);
+}
+
+uptr internal_stat(const char *path, void *buf) {
+  return stat(path, (struct stat *)buf);
+}
+
+uptr internal_lstat(const char *path, void *buf) {
+  return lstat(path, (struct stat *)buf);
+}
+
+uptr internal_fstat(fd_t fd, void *buf) {
+  return fstat(fd, (struct stat *)buf);
+}
+
+uptr internal_filesize(fd_t fd) {
+  struct stat st;
+  if (internal_fstat(fd, &st))
+    return -1;
+  return (uptr)st.st_size;
+}
+
+uptr internal_dup2(int oldfd, int newfd) {
+  return dup2(oldfd, newfd);
+}
+
+uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
+  return readlink(path, buf, bufsize);
+}
+
+uptr internal_unlink(const char *path) {
+  return unlink(path);
+}
+
+uptr internal_sched_yield() {
+  return sched_yield();
+}
+
+void internal__exit(int exitcode) {
+  _exit(exitcode);
+}
+
+uptr internal_getpid() {
+  return getpid();
+}
+
+int internal_sigaction(int signum, const void *act, void *oldact) {
+  return sigaction(signum,
+                   (struct sigaction *)act, (struct sigaction *)oldact);
+}
+
+void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
+
+uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
+                          __sanitizer_sigset_t *oldset) {
+  return sigprocmask(how, set, oldset);
+}
+
+// Doesn't call pthread_atfork() handlers.
+extern "C" pid_t __fork(void);
+
+int internal_fork() {
+  return __fork();
+}
+
+int internal_forkpty(int *amaster) {
+  int master, slave;
+  if (openpty(&master, &slave, nullptr, nullptr, nullptr) == -1) return -1;
+  int pid = __fork();
+  if (pid == -1) {
+    close(master);
+    close(slave);
+    return -1;
+  }
+  if (pid == 0) {
+    close(master);
+    CHECK_EQ(login_tty(slave), 0);
+  } else {
+    *amaster = master;
+    close(slave);
+  }
+  return pid;
+}
+
+uptr internal_rename(const char *oldpath, const char *newpath) {
+  return rename(oldpath, newpath);
+}
+
+uptr internal_ftruncate(fd_t fd, uptr size) {
+  return ftruncate(fd, size);
+}
+
+// ----------------- sanitizer_common.h
+bool FileExists(const char *filename) {
+  struct stat st;
+  if (stat(filename, &st))
+    return false;
+  // Sanity check: filename is a regular file.
+  return S_ISREG(st.st_mode);
+}
+
+uptr GetTid() {
+  return reinterpret_cast<uptr>(pthread_self());
+}
+
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+                                uptr *stack_bottom) {
+  CHECK(stack_top);
+  CHECK(stack_bottom);
+  uptr stacksize = pthread_get_stacksize_np(pthread_self());
+  // pthread_get_stacksize_np() returns an incorrect stack size for the main
+  // thread on Mavericks. See
+  // https://github.com/google/sanitizers/issues/261
+  if ((GetMacosVersion() >= MACOS_VERSION_MAVERICKS) && at_initialization &&
+      stacksize == (1 << 19))  {
+    struct rlimit rl;
+    CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
+    // Most often rl.rlim_cur will be the desired 8M.
+    if (rl.rlim_cur < kMaxThreadStackSize) {
+      stacksize = rl.rlim_cur;
+    } else {
+      stacksize = kMaxThreadStackSize;
+    }
+  }
+  void *stackaddr = pthread_get_stackaddr_np(pthread_self());
+  *stack_top = (uptr)stackaddr;
+  *stack_bottom = *stack_top - stacksize;
+}
+
+char **GetEnviron() {
+#if !SANITIZER_IOS
+  char ***env_ptr = _NSGetEnviron();
+  if (!env_ptr) {
+    Report("_NSGetEnviron() returned NULL. Please make sure __asan_init() is "
+           "called after libSystem_initializer().\n");
+    CHECK(env_ptr);
+  }
+  char **environ = *env_ptr;
+#endif
+  CHECK(environ);
+  return environ;
+}
+
+const char *GetEnv(const char *name) {
+  char **env = GetEnviron();
+  uptr name_len = internal_strlen(name);
+  while (*env != 0) {
+    uptr len = internal_strlen(*env);
+    if (len > name_len) {
+      const char *p = *env;
+      if (!internal_memcmp(p, name, name_len) &&
+          p[name_len] == '=') {  // Match.
+        return *env + name_len + 1;  // String starting after =.
+      }
+    }
+    env++;
+  }
+  return 0;
+}
+
+uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
+  CHECK_LE(kMaxPathLength, buf_len);
+
+  // On OS X the executable path is saved to the stack by dyld. Reading it
+  // from there is much faster than calling dladdr, especially for large
+  // binaries with symbols.
+  InternalScopedString exe_path(kMaxPathLength);
+  uint32_t size = exe_path.size();
+  if (_NSGetExecutablePath(exe_path.data(), &size) == 0 &&
+      realpath(exe_path.data(), buf) != 0) {
+    return internal_strlen(buf);
+  }
+  return 0;
+}
+
+uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
+  return ReadBinaryName(buf, buf_len);
+}
+
+void ReExec() {
+  UNIMPLEMENTED();
+}
+
+uptr GetPageSize() {
+  return sysconf(_SC_PAGESIZE);
+}
+
+BlockingMutex::BlockingMutex() {
+  internal_memset(this, 0, sizeof(*this));
+}
+
+void BlockingMutex::Lock() {
+  CHECK(sizeof(OSSpinLock) <= sizeof(opaque_storage_));
+  CHECK_EQ(OS_SPINLOCK_INIT, 0);
+  CHECK_NE(owner_, (uptr)pthread_self());
+  OSSpinLockLock((OSSpinLock*)&opaque_storage_);
+  CHECK(!owner_);
+  owner_ = (uptr)pthread_self();
+}
+
+void BlockingMutex::Unlock() {
+  CHECK(owner_ == (uptr)pthread_self());
+  owner_ = 0;
+  OSSpinLockUnlock((OSSpinLock*)&opaque_storage_);
+}
+
+void BlockingMutex::CheckLocked() {
+  CHECK_EQ((uptr)pthread_self(), owner_);
+}
+
+u64 NanoTime() {
+  return 0;
+}
+
+uptr GetTlsSize() {
+  return 0;
+}
+
+void InitTlsSize() {
+}
+
+void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
+                          uptr *tls_addr, uptr *tls_size) {
+#ifndef SANITIZER_GO
+  uptr stack_top, stack_bottom;
+  GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
+  *stk_addr = stack_bottom;
+  *stk_size = stack_top - stack_bottom;
+  *tls_addr = 0;
+  *tls_size = 0;
+#else
+  *stk_addr = 0;
+  *stk_size = 0;
+  *tls_addr = 0;
+  *tls_size = 0;
+#endif
+}
+
+uptr GetListOfModules(LoadedModule *modules, uptr max_modules,
+                      string_predicate_t filter) {
+  MemoryMappingLayout memory_mapping(false);
+  return memory_mapping.DumpListOfModules(modules, max_modules, filter);
+}
+
+bool IsDeadlySignal(int signum) {
+  return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
+}
+
+MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
+
+MacosVersion GetMacosVersionInternal() {
+  int mib[2] = { CTL_KERN, KERN_OSRELEASE };
+  char version[100];
+  uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);
+  for (uptr i = 0; i < maxlen; i++) version[i] = '\0';
+  // Get the version length.
+  CHECK_NE(sysctl(mib, 2, 0, &len, 0, 0), -1);
+  CHECK_LT(len, maxlen);
+  CHECK_NE(sysctl(mib, 2, version, &len, 0, 0), -1);
+  switch (version[0]) {
+    case '9': return MACOS_VERSION_LEOPARD;
+    case '1': {
+      switch (version[1]) {
+        case '0': return MACOS_VERSION_SNOW_LEOPARD;
+        case '1': return MACOS_VERSION_LION;
+        case '2': return MACOS_VERSION_MOUNTAIN_LION;
+        case '3': return MACOS_VERSION_MAVERICKS;
+        case '4': return MACOS_VERSION_YOSEMITE;
+        default:
+          if (IsDigit(version[1]))
+            return MACOS_VERSION_UNKNOWN_NEWER;
+          else
+            return MACOS_VERSION_UNKNOWN;
+      }
+    }
+    default: return MACOS_VERSION_UNKNOWN;
+  }
+}
+
+MacosVersion GetMacosVersion() {
+  atomic_uint32_t *cache =
+      reinterpret_cast<atomic_uint32_t*>(&cached_macos_version);
+  MacosVersion result =
+      static_cast<MacosVersion>(atomic_load(cache, memory_order_acquire));
+  if (result == MACOS_VERSION_UNINITIALIZED) {
+    result = GetMacosVersionInternal();
+    atomic_store(cache, result, memory_order_release);
+  }
+  return result;
+}
+
+uptr GetRSS() {
+  struct task_basic_info info;
+  unsigned count = TASK_BASIC_INFO_COUNT;
+  kern_return_t result =
+      task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
+  if (UNLIKELY(result != KERN_SUCCESS)) {
+    Report("Cannot get task info. Error: %d\n", result);
+    Die();
+  }
+  return info.resident_size;
+}
+
+void *internal_start_thread(void(*func)(void *arg), void *arg) {
+  // Start the thread with signals blocked, otherwise it can steal user signals.
+  __sanitizer_sigset_t set, old;
+  internal_sigfillset(&set);
+  internal_sigprocmask(SIG_SETMASK, &set, &old);
+  pthread_t th;
+  pthread_create(&th, 0, (void*(*)(void *arg))func, arg);
+  internal_sigprocmask(SIG_SETMASK, &old, 0);
+  return th;
+}
+
+void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
+
+static BlockingMutex syslog_lock(LINKER_INITIALIZED);
+
+void WriteOneLineToSyslog(const char *s) {
+  syslog_lock.CheckLocked();
+  asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
+}
+
+void LogFullErrorReport(const char *buffer) {
+  // Log with os_trace. This will make it into the crash log.
+#if SANITIZER_OS_TRACE
+  if (GetMacosVersion() >= MACOS_VERSION_YOSEMITE) {
+    // os_trace requires the message (format parameter) to be a string literal.
+    if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
+                         sizeof("AddressSanitizer") - 1) == 0)
+      os_trace("Address Sanitizer reported a failure.");
+    else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
+                              sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
+      os_trace("Undefined Behavior Sanitizer reported a failure.");
+    else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
+                              sizeof("ThreadSanitizer") - 1) == 0)
+      os_trace("Thread Sanitizer reported a failure.");
+    else
+      os_trace("Sanitizer tool reported a failure.");
+
+    if (common_flags()->log_to_syslog)
+      os_trace("Consult syslog for more information.");
+  }
+#endif
+
+  // Log to syslog.
+  // The logging on OS X may call pthread_create so we need the threading
+  // environment to be fully initialized. Also, this should never be called when
+  // holding the thread registry lock since that may result in a deadlock. If
+  // the reporting thread holds the thread registry mutex, and asl_log waits
+  // for GCD to dispatch a new thread, the process will deadlock, because the
+  // pthread_create wrapper needs to acquire the lock as well.
+  BlockingMutexLock l(&syslog_lock);
+  if (common_flags()->log_to_syslog)
+    WriteToSyslog(buffer);
+
+  // Log to CrashLog.
+  if (common_flags()->abort_on_error)
+    CRSetCrashLogMessage(buffer);
+}
+
+void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
+  ucontext_t *ucontext = (ucontext_t*)context;
+# if defined(__aarch64__)
+  *pc = ucontext->uc_mcontext->__ss.__pc;
+#   if defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0
+  *bp = ucontext->uc_mcontext->__ss.__fp;
+#   else
+  *bp = ucontext->uc_mcontext->__ss.__lr;
+#   endif
+  *sp = ucontext->uc_mcontext->__ss.__sp;
+# elif defined(__x86_64__)
+  *pc = ucontext->uc_mcontext->__ss.__rip;
+  *bp = ucontext->uc_mcontext->__ss.__rbp;
+  *sp = ucontext->uc_mcontext->__ss.__rsp;
+# elif defined(__arm__)
+  *pc = ucontext->uc_mcontext->__ss.__pc;
+  *bp = ucontext->uc_mcontext->__ss.__r[7];
+  *sp = ucontext->uc_mcontext->__ss.__sp;
+# elif defined(__i386__)
+  *pc = ucontext->uc_mcontext->__ss.__eip;
+  *bp = ucontext->uc_mcontext->__ss.__ebp;
+  *sp = ucontext->uc_mcontext->__ss.__esp;
+# else
+# error "Unknown architecture"
+# endif
+}
+
+static const char kDyldInsertLibraries[] = "DYLD_INSERT_LIBRARIES";
+LowLevelAllocator allocator_for_env;
+
+// Change the value of the env var |name|, leaking the original value.
+// If |name_value| is NULL, the variable is deleted from the environment,
+// otherwise the corresponding "NAME=value" string is replaced with
+// |name_value|.
+void LeakyResetEnv(const char *name, const char *name_value) {
+  char **env = GetEnviron();
+  uptr name_len = internal_strlen(name);
+  while (*env != 0) {
+    uptr len = internal_strlen(*env);
+    if (len > name_len) {
+      const char *p = *env;
+      if (!internal_memcmp(p, name, name_len) && p[name_len] == '=') {
+        // Match.
+        if (name_value) {
+          // Replace the old value with the new one.
+          *env = const_cast<char*>(name_value);
+        } else {
+          // Shift the subsequent pointers back.
+          char **del = env;
+          do {
+            del[0] = del[1];
+          } while (*del++);
+        }
+      }
+    }
+    env++;
+  }
+}
+
+static bool reexec_disabled = false;
+
+void DisableReexec() {
+  reexec_disabled = true;
+}
+
+extern "C" double dyldVersionNumber;
+static const double kMinDyldVersionWithAutoInterposition = 360.0;
+
+bool DyldNeedsEnvVariable() {
+  // If running on OS X 10.11+ or iOS 9.0+, dyld will interpose even if
+  // DYLD_INSERT_LIBRARIES is not set. However, checking OS version via
+  // GetMacosVersion() doesn't work for the simulator. Let's instead check
+  // `dyldVersionNumber`, which is exported by dyld, against a known version
+  // number from the first OS release where this appeared.
+  return dyldVersionNumber < kMinDyldVersionWithAutoInterposition;
+}
+
+void MaybeReexec() {
+  if (reexec_disabled) return;
+
+  // Make sure the dynamic runtime library is preloaded so that the
+  // wrappers work. If it is not, set DYLD_INSERT_LIBRARIES and re-exec
+  // ourselves.
+  Dl_info info;
+  CHECK(dladdr((void*)((uptr)&__sanitizer_report_error_summary), &info));
+  char *dyld_insert_libraries =
+      const_cast<char*>(GetEnv(kDyldInsertLibraries));
+  uptr old_env_len = dyld_insert_libraries ?
+      internal_strlen(dyld_insert_libraries) : 0;
+  uptr fname_len = internal_strlen(info.dli_fname);
+  const char *dylib_name = StripModuleName(info.dli_fname);
+  uptr dylib_name_len = internal_strlen(dylib_name);
+
+  bool lib_is_in_env = dyld_insert_libraries &&
+                       internal_strstr(dyld_insert_libraries, dylib_name);
+  if (DyldNeedsEnvVariable() && !lib_is_in_env) {
+    // DYLD_INSERT_LIBRARIES is not set or does not contain the runtime
+    // library.
+    InternalScopedString program_name(1024);
+    uint32_t buf_size = program_name.size();
+    _NSGetExecutablePath(program_name.data(), &buf_size);
+    char *new_env = const_cast<char*>(info.dli_fname);
+    if (dyld_insert_libraries) {
+      // Append the runtime dylib name to the existing value of
+      // DYLD_INSERT_LIBRARIES.
+      new_env = (char*)allocator_for_env.Allocate(old_env_len + fname_len + 2);
+      internal_strncpy(new_env, dyld_insert_libraries, old_env_len);
+      new_env[old_env_len] = ':';
+      // Copy fname_len and add a trailing zero.
+      internal_strncpy(new_env + old_env_len + 1, info.dli_fname,
+                       fname_len + 1);
+      // Ok to use setenv() since the wrappers don't depend on the value of
+      // asan_inited.
+      setenv(kDyldInsertLibraries, new_env, /*overwrite*/1);
+    } else {
+      // Set DYLD_INSERT_LIBRARIES equal to the runtime dylib name.
+      setenv(kDyldInsertLibraries, info.dli_fname, /*overwrite*/0);
+    }
+    VReport(1, "exec()-ing the program with\n");
+    VReport(1, "%s=%s\n", kDyldInsertLibraries, new_env);
+    VReport(1, "to enable wrappers.\n");
+    execv(program_name.data(), *_NSGetArgv());
+
+    // We get here only if execv() failed.
+    Report("ERROR: The process is launched without DYLD_INSERT_LIBRARIES, "
+           "which is required for the sanitizer to work. We tried to set the "
+           "environment variable and re-execute itself, but execv() failed, "
+           "possibly because of sandbox restrictions. Make sure to launch the "
+           "executable with:\n%s=%s\n", kDyldInsertLibraries, new_env);
+    CHECK("execv failed" && 0);
+  }
+
+  if (!lib_is_in_env)
+    return;
+
+  // DYLD_INSERT_LIBRARIES is set and contains the runtime library. Let's remove
+  // the dylib from the environment variable, because interceptors are installed
+  // and we don't want our children to inherit the variable.
+
+  uptr env_name_len = internal_strlen(kDyldInsertLibraries);
+  // Allocate memory to hold the previous env var name, its value, the '='
+  // sign and the '\0' char.
+  char *new_env = (char*)allocator_for_env.Allocate(
+      old_env_len + 2 + env_name_len);
+  CHECK(new_env);
+  internal_memset(new_env, '\0', old_env_len + 2 + env_name_len);
+  internal_strncpy(new_env, kDyldInsertLibraries, env_name_len);
+  new_env[env_name_len] = '=';
+  char *new_env_pos = new_env + env_name_len + 1;
+
+  // Iterate over colon-separated pieces of |dyld_insert_libraries|.
+  char *piece_start = dyld_insert_libraries;
+  char *piece_end = NULL;
+  char *old_env_end = dyld_insert_libraries + old_env_len;
+  do {
+    if (piece_start[0] == ':') piece_start++;
+    piece_end = internal_strchr(piece_start, ':');
+    if (!piece_end) piece_end = dyld_insert_libraries + old_env_len;
+    if ((uptr)(piece_start - dyld_insert_libraries) > old_env_len) break;
+    uptr piece_len = piece_end - piece_start;
+
+    char *filename_start =
+        (char *)internal_memrchr(piece_start, '/', piece_len);
+    uptr filename_len = piece_len;
+    if (filename_start) {
+      filename_start += 1;
+      filename_len = piece_len - (filename_start - piece_start);
+    } else {
+      filename_start = piece_start;
+    }
+
+    // If the current piece isn't the runtime library name,
+    // append it to new_env.
+    if ((dylib_name_len != filename_len) ||
+        (internal_memcmp(filename_start, dylib_name, dylib_name_len) != 0)) {
+      if (new_env_pos != new_env + env_name_len + 1) {
+        new_env_pos[0] = ':';
+        new_env_pos++;
+      }
+      internal_strncpy(new_env_pos, piece_start, piece_len);
+      new_env_pos += piece_len;
+    }
+    // Move on to the next piece.
+    piece_start = piece_end;
+  } while (piece_start < old_env_end);
+
+  // Can't use setenv() here, because it requires the allocator to be
+  // initialized.
+  // FIXME: instead of filtering DYLD_INSERT_LIBRARIES here, do it in
+  // a separate function called after InitializeAllocator().
+  if (new_env_pos == new_env + env_name_len + 1) new_env = NULL;
+  LeakyResetEnv(kDyldInsertLibraries, new_env);
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_mac.h b/compiler-rt/lib/sanitizer_common/sanitizer_mac.h
new file mode 100644
index 0000000..86a9956
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_mac.h
@@ -0,0 +1,53 @@
+//===-- sanitizer_mac.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries and
+// provides definitions for OSX-specific functions.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_MAC_H
+#define SANITIZER_MAC_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_platform.h"
+#if SANITIZER_MAC
+#include "sanitizer_posix.h"
+
+namespace __sanitizer {
+
+enum MacosVersion {
+  MACOS_VERSION_UNINITIALIZED = 0,
+  MACOS_VERSION_UNKNOWN,
+  MACOS_VERSION_LEOPARD,
+  MACOS_VERSION_SNOW_LEOPARD,
+  MACOS_VERSION_LION,
+  MACOS_VERSION_MOUNTAIN_LION,
+  MACOS_VERSION_MAVERICKS,
+  MACOS_VERSION_YOSEMITE,
+  MACOS_VERSION_UNKNOWN_NEWER
+};
+
+MacosVersion GetMacosVersion();
+
+char **GetEnviron();
+
+}  // namespace __sanitizer
+
+extern "C" {
+static char __crashreporter_info_buff__[kErrorMessageBufferSize] = {};
+static const char *__crashreporter_info__ __attribute__((__used__)) =
+  &__crashreporter_info_buff__[0];
+asm(".desc ___crashreporter_info__, 0x10");
+} // extern "C"
+
+INLINE void CRSetCrashLogMessage(const char *msg) {
+  internal_strlcpy(__crashreporter_info_buff__, msg,
+                   sizeof(__crashreporter_info_buff__)); }
+
+#endif  // SANITIZER_MAC
+#endif  // SANITIZER_MAC_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_malloc_mac.inc b/compiler-rt/lib/sanitizer_common/sanitizer_malloc_mac.inc
new file mode 100644
index 0000000..149857c
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_malloc_mac.inc
@@ -0,0 +1,329 @@
+//===-- sanitizer_malloc_mac.inc --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains Mac-specific malloc interceptors and a custom zone
+// implementation, which together replace the system allocator.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if !SANITIZER_MAC
+#error "This file should only be compiled on Darwin."
+#endif
+
+#include <AvailabilityMacros.h>
+#include <CoreFoundation/CFBase.h>
+#include <dlfcn.h>
+#include <malloc/malloc.h>
+#include <sys/mman.h>
+
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_mac.h"
+
+// Similar code is used in Google Perftools,
+// https://github.com/gperftools/gperftools.
+
+static malloc_zone_t sanitizer_zone;
+
+INTERCEPTOR(malloc_zone_t *, malloc_create_zone,
+                             vm_size_t start_size, unsigned zone_flags) {
+  COMMON_MALLOC_ENTER();
+  uptr page_size = GetPageSizeCached();
+  uptr allocated_size = RoundUpTo(sizeof(sanitizer_zone), page_size);
+  COMMON_MALLOC_MEMALIGN(page_size, allocated_size);
+  malloc_zone_t *new_zone = (malloc_zone_t *)p;
+  internal_memcpy(new_zone, &sanitizer_zone, sizeof(sanitizer_zone));
+  new_zone->zone_name = NULL;  // The name will be changed anyway.
+  if (GetMacosVersion() >= MACOS_VERSION_LION) {
+    // Prevent the client app from overwriting the zone contents.
+    // Library functions that need to modify the zone will set PROT_WRITE on it.
+    // This matches the behavior of malloc_create_zone() on OSX 10.7 and higher.
+    mprotect(new_zone, allocated_size, PROT_READ);
+  }
+  return new_zone;
+}
+
+INTERCEPTOR(malloc_zone_t *, malloc_default_zone, void) {
+  COMMON_MALLOC_ENTER();
+  return &sanitizer_zone;
+}
+
+INTERCEPTOR(malloc_zone_t *, malloc_default_purgeable_zone, void) {
+  // FIXME: ASan should support purgeable allocations.
+  // https://github.com/google/sanitizers/issues/139
+  COMMON_MALLOC_ENTER();
+  return &sanitizer_zone;
+}
+
+INTERCEPTOR(void, malloc_make_purgeable, void *ptr) {
+  // FIXME: ASan should support purgeable allocations. Ignoring them is fine
+  // for now.
+  COMMON_MALLOC_ENTER();
+}
+
+INTERCEPTOR(int, malloc_make_nonpurgeable, void *ptr) {
+  // FIXME: ASan should support purgeable allocations. Ignoring them is fine
+  // for now.
+  COMMON_MALLOC_ENTER();
+  // Must return 0 if the contents were not purged since the last call to
+  // malloc_make_purgeable().
+  return 0;
+}
+
+INTERCEPTOR(void, malloc_set_zone_name, malloc_zone_t *zone, const char *name) {
+  COMMON_MALLOC_ENTER();
+  // Allocate |sizeof(COMMON_MALLOC_ZONE_NAME "-") + internal_strlen(name)|
+  // bytes.
+  size_t buflen =
+      sizeof(COMMON_MALLOC_ZONE_NAME "-") + (name ? internal_strlen(name) : 0);
+  InternalScopedString new_name(buflen);
+  if (name && zone->introspect == sanitizer_zone.introspect) {
+    new_name.append(COMMON_MALLOC_ZONE_NAME "-%s", name);
+    name = new_name.data();
+  }
+
+  // Call the system malloc's implementation for both external and our zones,
+  // since that appropriately changes VM region protections on the zone.
+  REAL(malloc_set_zone_name)(zone, name);
+}
+
+INTERCEPTOR(void *, malloc, size_t size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_MALLOC(size);
+  return p;
+}
+
+INTERCEPTOR(void, free, void *ptr) {
+  COMMON_MALLOC_ENTER();
+  if (!ptr) return;
+  COMMON_MALLOC_FREE(ptr);
+}
+
+INTERCEPTOR(void *, realloc, void *ptr, size_t size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_REALLOC(ptr, size);
+  return p;
+}
+
+INTERCEPTOR(void *, calloc, size_t nmemb, size_t size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_CALLOC(nmemb, size);
+  return p;
+}
+
+INTERCEPTOR(void *, valloc, size_t size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_VALLOC(size);
+  return p;
+}
+
+INTERCEPTOR(size_t, malloc_good_size, size_t size) {
+  COMMON_MALLOC_ENTER();
+  return sanitizer_zone.introspect->good_size(&sanitizer_zone, size);
+}
+
+INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) {
+  COMMON_MALLOC_ENTER();
+  CHECK(memptr);
+  COMMON_MALLOC_MEMALIGN(alignment, size);
+  if (p) {
+    *memptr = p;
+    return 0;
+  }
+  return -1;
+}
+
+namespace {
+
+// TODO(glider): the __sanitizer_mz_* functions should be united with the Linux
+// wrappers, as they are basically copied from there.
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+size_t __sanitizer_mz_size(malloc_zone_t* zone, const void* ptr) {
+  COMMON_MALLOC_SIZE(ptr);
+  return size;
+}
+
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__sanitizer_mz_malloc(malloc_zone_t *zone, uptr size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_MALLOC(size);
+  return p;
+}
+
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__sanitizer_mz_calloc(malloc_zone_t *zone, size_t nmemb, size_t size) {
+  if (UNLIKELY(!COMMON_MALLOC_SANITIZER_INITIALIZED)) {
+    // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
+    const size_t kCallocPoolSize = 1024;
+    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
+    static size_t allocated;
+    size_t size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
+    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
+    allocated += size_in_words;
+    CHECK(allocated < kCallocPoolSize);
+    return mem;
+  }
+  COMMON_MALLOC_CALLOC(nmemb, size);
+  return p;
+}
+
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__sanitizer_mz_valloc(malloc_zone_t *zone, size_t size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_VALLOC(size);
+  return p;
+}
+
+// TODO(glider): the allocation callbacks need to be refactored.
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_mz_free(malloc_zone_t *zone, void *ptr) {
+  if (!ptr) return;
+  COMMON_MALLOC_FREE(ptr);
+}
+
+#define GET_ZONE_FOR_PTR(ptr) \
+  malloc_zone_t *zone_ptr = malloc_zone_from_ptr(ptr); \
+  const char *zone_name = (zone_ptr == 0) ? 0 : zone_ptr->zone_name
+
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__sanitizer_mz_realloc(malloc_zone_t *zone, void *ptr, size_t new_size) {
+  if (!ptr) {
+    COMMON_MALLOC_MALLOC(new_size);
+    return p;
+  } else {
+    COMMON_MALLOC_SIZE(ptr);
+    if (size) {
+      COMMON_MALLOC_REALLOC(ptr, new_size);
+      return p;
+    } else {
+      // We can't recover from reallocating an unknown address, because
+      // this would require reading at most |new_size| bytes from
+      // potentially unaccessible memory.
+      GET_ZONE_FOR_PTR(ptr);
+      COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name);
+      return nullptr;
+    }
+  }
+}
+
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_mz_destroy(malloc_zone_t* zone) {
+  // A no-op -- we will not be destroyed!
+  Report("__sanitizer_mz_destroy() called -- ignoring\n");
+}
+
+extern "C"
+SANITIZER_INTERFACE_ATTRIBUTE
+void *__sanitizer_mz_memalign(malloc_zone_t *zone, size_t align, size_t size) {
+  COMMON_MALLOC_ENTER();
+  COMMON_MALLOC_MEMALIGN(align, size);
+  return p;
+}
+
+// This function is currently unused, and we build with -Werror.
+#if 0
+void __sanitizer_mz_free_definite_size(
+    malloc_zone_t* zone, void *ptr, size_t size) {
+  // TODO(glider): check that |size| is valid.
+  UNIMPLEMENTED();
+}
+#endif
+
+kern_return_t mi_enumerator(task_t task, void *,
+                            unsigned type_mask, vm_address_t zone_address,
+                            memory_reader_t reader,
+                            vm_range_recorder_t recorder) {
+  // Should enumerate all the pointers we have.  Seems like a lot of work.
+  return KERN_FAILURE;
+}
+
+size_t mi_good_size(malloc_zone_t *zone, size_t size) {
+  // I think it's always safe to return size, but we maybe could do better.
+  return size;
+}
+
+boolean_t mi_check(malloc_zone_t *zone) {
+  UNIMPLEMENTED();
+}
+
+void mi_print(malloc_zone_t *zone, boolean_t verbose) {
+  UNIMPLEMENTED();
+}
+
+void mi_log(malloc_zone_t *zone, void *address) {
+  // I don't think we support anything like this
+}
+
+void mi_force_lock(malloc_zone_t *zone) {
+  COMMON_MALLOC_FORCE_LOCK();
+}
+
+void mi_force_unlock(malloc_zone_t *zone) {
+  COMMON_MALLOC_FORCE_UNLOCK();
+}
+
+void mi_statistics(malloc_zone_t *zone, malloc_statistics_t *stats) {
+  COMMON_MALLOC_FILL_STATS(zone, stats);
+}
+
+boolean_t mi_zone_locked(malloc_zone_t *zone) {
+  // UNIMPLEMENTED();
+  return false;
+}
+
+}  // unnamed namespace
+
+namespace COMMON_MALLOC_NAMESPACE {
+
+void ReplaceSystemMalloc() {
+  static malloc_introspection_t sanitizer_zone_introspection;
+  // Ok to use internal_memset, these places are not performance-critical.
+  internal_memset(&sanitizer_zone_introspection, 0,
+                  sizeof(sanitizer_zone_introspection));
+
+  sanitizer_zone_introspection.enumerator = &mi_enumerator;
+  sanitizer_zone_introspection.good_size = &mi_good_size;
+  sanitizer_zone_introspection.check = &mi_check;
+  sanitizer_zone_introspection.print = &mi_print;
+  sanitizer_zone_introspection.log = &mi_log;
+  sanitizer_zone_introspection.force_lock = &mi_force_lock;
+  sanitizer_zone_introspection.force_unlock = &mi_force_unlock;
+  sanitizer_zone_introspection.statistics = &mi_statistics;
+  sanitizer_zone_introspection.zone_locked = &mi_zone_locked;
+
+  internal_memset(&sanitizer_zone, 0, sizeof(malloc_zone_t));
+
+  // Use version 6 for OSX >= 10.6.
+  sanitizer_zone.version = 6;
+  sanitizer_zone.zone_name = COMMON_MALLOC_ZONE_NAME;
+  sanitizer_zone.size = &__sanitizer_mz_size;
+  sanitizer_zone.malloc = &__sanitizer_mz_malloc;
+  sanitizer_zone.calloc = &__sanitizer_mz_calloc;
+  sanitizer_zone.valloc = &__sanitizer_mz_valloc;
+  sanitizer_zone.free = &__sanitizer_mz_free;
+  sanitizer_zone.realloc = &__sanitizer_mz_realloc;
+  sanitizer_zone.destroy = &__sanitizer_mz_destroy;
+  sanitizer_zone.batch_malloc = 0;
+  sanitizer_zone.batch_free = 0;
+  sanitizer_zone.free_definite_size = 0;
+  sanitizer_zone.memalign = &__sanitizer_mz_memalign;
+  sanitizer_zone.introspect = &sanitizer_zone_introspection;
+
+  // Register the zone.
+  malloc_zone_register(&sanitizer_zone);
+}
+
+}  // namespace COMMON_MALLOC_NAMESPACE
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_mutex.h b/compiler-rt/lib/sanitizer_common/sanitizer_mutex.h
new file mode 100644
index 0000000..d06fc45
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_mutex.h
@@ -0,0 +1,219 @@
+//===-- sanitizer_mutex.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_MUTEX_H
+#define SANITIZER_MUTEX_H
+
+#include "sanitizer_atomic.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
+
+namespace __sanitizer {
+
+class StaticSpinMutex {
+ public:
+  void Init() {
+    atomic_store(&state_, 0, memory_order_relaxed);
+  }
+
+  void Lock() {
+    if (TryLock())
+      return;
+    LockSlow();
+  }
+
+  bool TryLock() {
+    return atomic_exchange(&state_, 1, memory_order_acquire) == 0;
+  }
+
+  void Unlock() {
+    atomic_store(&state_, 0, memory_order_release);
+  }
+
+  void CheckLocked() {
+    CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
+  }
+
+ private:
+  atomic_uint8_t state_;
+
+  void NOINLINE LockSlow() {
+    for (int i = 0;; i++) {
+      if (i < 10)
+        proc_yield(10);
+      else
+        internal_sched_yield();
+      if (atomic_load(&state_, memory_order_relaxed) == 0
+          && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
+        return;
+    }
+  }
+};
+
+class SpinMutex : public StaticSpinMutex {
+ public:
+  SpinMutex() {
+    Init();
+  }
+
+ private:
+  SpinMutex(const SpinMutex&);
+  void operator=(const SpinMutex&);
+};
+
+class BlockingMutex {
+ public:
+#if SANITIZER_WINDOWS
+  // Windows does not currently support LinkerInitialized
+  explicit BlockingMutex(LinkerInitialized);
+#else
+  explicit constexpr BlockingMutex(LinkerInitialized)
+      : opaque_storage_ {0, }, owner_(0) {}
+#endif
+  BlockingMutex();
+  void Lock();
+  void Unlock();
+  void CheckLocked();
+ private:
+  uptr opaque_storage_[10];
+  uptr owner_;  // for debugging
+};
+
+// Reader-writer spin mutex.
+class RWMutex {
+ public:
+  RWMutex() {
+    atomic_store(&state_, kUnlocked, memory_order_relaxed);
+  }
+
+  ~RWMutex() {
+    CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);
+  }
+
+  void Lock() {
+    u32 cmp = kUnlocked;
+    if (atomic_compare_exchange_strong(&state_, &cmp, kWriteLock,
+                                       memory_order_acquire))
+      return;
+    LockSlow();
+  }
+
+  void Unlock() {
+    u32 prev = atomic_fetch_sub(&state_, kWriteLock, memory_order_release);
+    DCHECK_NE(prev & kWriteLock, 0);
+    (void)prev;
+  }
+
+  void ReadLock() {
+    u32 prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
+    if ((prev & kWriteLock) == 0)
+      return;
+    ReadLockSlow();
+  }
+
+  void ReadUnlock() {
+    u32 prev = atomic_fetch_sub(&state_, kReadLock, memory_order_release);
+    DCHECK_EQ(prev & kWriteLock, 0);
+    DCHECK_GT(prev & ~kWriteLock, 0);
+    (void)prev;
+  }
+
+  void CheckLocked() {
+    CHECK_NE(atomic_load(&state_, memory_order_relaxed), kUnlocked);
+  }
+
+ private:
+  atomic_uint32_t state_;
+
+  enum {
+    kUnlocked = 0,
+    kWriteLock = 1,
+    kReadLock = 2
+  };
+
+  void NOINLINE LockSlow() {
+    for (int i = 0;; i++) {
+      if (i < 10)
+        proc_yield(10);
+      else
+        internal_sched_yield();
+      u32 cmp = atomic_load(&state_, memory_order_relaxed);
+      if (cmp == kUnlocked &&
+          atomic_compare_exchange_weak(&state_, &cmp, kWriteLock,
+                                       memory_order_acquire))
+          return;
+    }
+  }
+
+  void NOINLINE ReadLockSlow() {
+    for (int i = 0;; i++) {
+      if (i < 10)
+        proc_yield(10);
+      else
+        internal_sched_yield();
+      u32 prev = atomic_load(&state_, memory_order_acquire);
+      if ((prev & kWriteLock) == 0)
+        return;
+    }
+  }
+
+  RWMutex(const RWMutex&);
+  void operator = (const RWMutex&);
+};
+
+template<typename MutexType>
+class GenericScopedLock {
+ public:
+  explicit GenericScopedLock(MutexType *mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+
+  ~GenericScopedLock() {
+    mu_->Unlock();
+  }
+
+ private:
+  MutexType *mu_;
+
+  GenericScopedLock(const GenericScopedLock&);
+  void operator=(const GenericScopedLock&);
+};
+
+template<typename MutexType>
+class GenericScopedReadLock {
+ public:
+  explicit GenericScopedReadLock(MutexType *mu)
+      : mu_(mu) {
+    mu_->ReadLock();
+  }
+
+  ~GenericScopedReadLock() {
+    mu_->ReadUnlock();
+  }
+
+ private:
+  MutexType *mu_;
+
+  GenericScopedReadLock(const GenericScopedReadLock&);
+  void operator=(const GenericScopedReadLock&);
+};
+
+typedef GenericScopedLock<StaticSpinMutex> SpinMutexLock;
+typedef GenericScopedLock<BlockingMutex> BlockingMutexLock;
+typedef GenericScopedLock<RWMutex> RWMutexLock;
+typedef GenericScopedReadLock<RWMutex> RWMutexReadLock;
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_MUTEX_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.cc b/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.cc
new file mode 100644
index 0000000..5fa533a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.cc
@@ -0,0 +1,19 @@
+//===-- sanitizer_persistent_allocator.cc -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+#include "sanitizer_persistent_allocator.h"
+
+namespace __sanitizer {
+
+PersistentAllocator thePersistentAllocator;
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h b/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h
new file mode 100644
index 0000000..8e5ce06
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h
@@ -0,0 +1,72 @@
+//===-- sanitizer_persistent_allocator.h ------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// A fast memory allocator that does not support free() nor realloc().
+// All allocations are forever.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_PERSISTENT_ALLOCATOR_H
+#define SANITIZER_PERSISTENT_ALLOCATOR_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+
+class PersistentAllocator {
+ public:
+  void *alloc(uptr size);
+
+ private:
+  void *tryAlloc(uptr size);
+  StaticSpinMutex mtx;  // Protects alloc of new blocks for region allocator.
+  atomic_uintptr_t region_pos;  // Region allocator for Node's.
+  atomic_uintptr_t region_end;
+};
+
+inline void *PersistentAllocator::tryAlloc(uptr size) {
+  // Optimisic lock-free allocation, essentially try to bump the region ptr.
+  for (;;) {
+    uptr cmp = atomic_load(&region_pos, memory_order_acquire);
+    uptr end = atomic_load(&region_end, memory_order_acquire);
+    if (cmp == 0 || cmp + size > end) return nullptr;
+    if (atomic_compare_exchange_weak(&region_pos, &cmp, cmp + size,
+                                     memory_order_acquire))
+      return (void *)cmp;
+  }
+}
+
+inline void *PersistentAllocator::alloc(uptr size) {
+  // First, try to allocate optimisitically.
+  void *s = tryAlloc(size);
+  if (s) return s;
+  // If failed, lock, retry and alloc new superblock.
+  SpinMutexLock l(&mtx);
+  for (;;) {
+    s = tryAlloc(size);
+    if (s) return s;
+    atomic_store(&region_pos, 0, memory_order_relaxed);
+    uptr allocsz = 64 * 1024;
+    if (allocsz < size) allocsz = size;
+    uptr mem = (uptr)MmapOrDie(allocsz, "stack depot");
+    atomic_store(&region_end, mem + allocsz, memory_order_release);
+    atomic_store(&region_pos, mem, memory_order_release);
+  }
+}
+
+extern PersistentAllocator thePersistentAllocator;
+inline void *PersistentAlloc(uptr sz) {
+  return thePersistentAllocator.alloc(sz);
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_PERSISTENT_ALLOCATOR_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_placement_new.h b/compiler-rt/lib/sanitizer_common/sanitizer_placement_new.h
new file mode 100644
index 0000000..8904d10
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_placement_new.h
@@ -0,0 +1,25 @@
+//===-- sanitizer_placement_new.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//
+// The file provides 'placement new'.
+// Do not include it into header files, only into source files.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_PLACEMENT_NEW_H
+#define SANITIZER_PLACEMENT_NEW_H
+
+#include "sanitizer_internal_defs.h"
+
+inline void *operator new(__sanitizer::operator_new_size_type sz, void *p) {
+  return p;
+}
+
+#endif  // SANITIZER_PLACEMENT_NEW_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_platform.h b/compiler-rt/lib/sanitizer_common/sanitizer_platform.h
new file mode 100644
index 0000000..c31e631
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_platform.h
@@ -0,0 +1,168 @@
+//===-- sanitizer_platform.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Common platform macros.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_PLATFORM_H
+#define SANITIZER_PLATFORM_H
+
+#if !defined(__linux__) && !defined(__FreeBSD__) && \
+  !defined(__APPLE__) && !defined(_WIN32)
+# error "This operating system is not supported"
+#endif
+
+#if defined(__linux__)
+# define SANITIZER_LINUX   1
+#else
+# define SANITIZER_LINUX   0
+#endif
+
+#if defined(__FreeBSD__)
+# define SANITIZER_FREEBSD 1
+#else
+# define SANITIZER_FREEBSD 0
+#endif
+
+#if defined(__APPLE__)
+# define SANITIZER_MAC     1
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#  define SANITIZER_IOS    1
+# else
+#  define SANITIZER_IOS    0
+# endif
+# if TARGET_IPHONE_SIMULATOR
+#  define SANITIZER_IOSSIM 1
+# else
+#  define SANITIZER_IOSSIM 0
+# endif
+#else
+# define SANITIZER_MAC     0
+# define SANITIZER_IOS     0
+# define SANITIZER_IOSSIM  0
+#endif
+
+#if defined(_WIN32)
+# define SANITIZER_WINDOWS 1
+#else
+# define SANITIZER_WINDOWS 0
+#endif
+
+#if defined(__ANDROID__)
+# define SANITIZER_ANDROID 1
+#else
+# define SANITIZER_ANDROID 0
+#endif
+
+#define SANITIZER_POSIX (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC)
+
+#if __LP64__ || defined(_WIN64)
+#  define SANITIZER_WORDSIZE 64
+#else
+#  define SANITIZER_WORDSIZE 32
+#endif
+
+#if SANITIZER_WORDSIZE == 64
+# define FIRST_32_SECOND_64(a, b) (b)
+#else
+# define FIRST_32_SECOND_64(a, b) (a)
+#endif
+
+#if defined(__x86_64__) && !defined(_LP64)
+# define SANITIZER_X32 1
+#else
+# define SANITIZER_X32 0
+#endif
+
+#if defined(__mips__)
+# define SANITIZER_MIPS 1
+# if defined(__mips64)
+#  define SANITIZER_MIPS32 0
+#  define SANITIZER_MIPS64 1
+# else
+#  define SANITIZER_MIPS32 1
+#  define SANITIZER_MIPS64 0
+# endif
+#else
+# define SANITIZER_MIPS 0
+# define SANITIZER_MIPS32 0
+# define SANITIZER_MIPS64 0
+#endif
+
+// By default we allow to use SizeClassAllocator64 on 64-bit platform.
+// But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
+// does not work well and we need to fallback to SizeClassAllocator32.
+// For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
+// change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
+#ifndef SANITIZER_CAN_USE_ALLOCATOR64
+# if defined(__mips64) || defined(__aarch64__)
+#  define SANITIZER_CAN_USE_ALLOCATOR64 0
+# else
+#  define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64)
+# endif
+#endif
+
+// The range of addresses which can be returned my mmap.
+// FIXME: this value should be different on different platforms.  Larger values
+// will still work but will consume more memory for TwoLevelByteMap.
+#if defined(__mips__)
+# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40)
+#else
+# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
+#endif
+
+// The AArch64 linux port uses the canonical syscall set as mandated by
+// the upstream linux community for all new ports. Other ports may still
+// use legacy syscalls.
+#ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+# if defined(__aarch64__) && SANITIZER_LINUX
+# define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
+# else
+# define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0
+# endif
+#endif
+
+// udi16 syscalls can only be used when the following conditions are
+// met:
+// * target is one of arm32, x86-32, sparc32, sh or m68k
+// * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15
+//   built against > linux-2.2 kernel headers
+// Since we don't want to include libc headers here, we check the
+// target only.
+#if defined(__arm__) || SANITIZER_X32 || defined(__sparc__)
+#define SANITIZER_USES_UID16_SYSCALLS 1
+#else
+#define SANITIZER_USES_UID16_SYSCALLS 0
+#endif
+
+#if defined(__mips__)
+# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10)
+#else
+# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12)
+#endif
+
+// Assume obsolete RPC headers are available by default
+#if !defined(HAVE_RPC_XDR_H) && !defined(HAVE_TIRPC_RPC_XDR_H)
+# define HAVE_RPC_XDR_H (SANITIZER_LINUX && !SANITIZER_ANDROID)
+# define HAVE_TIRPC_RPC_XDR_H 0
+#endif
+
+/// \macro MSC_PREREQ
+/// \brief Is the compiler MSVC of at least the specified version?
+/// The common \param version values to check for are:
+///  * 1800: Microsoft Visual Studio 2013 / 12.0
+///  * 1900: Microsoft Visual Studio 2015 / 14.0
+#ifdef _MSC_VER
+# define MSC_PREREQ(version) (_MSC_VER >= (version))
+#else
+# define MSC_PREREQ(version) 0
+#endif
+
+#endif // SANITIZER_PLATFORM_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h b/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h
new file mode 100644
index 0000000..430ad48
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h
@@ -0,0 +1,268 @@
+//===-- sanitizer_platform_interceptors.h -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines macro telling whether sanitizer tools can/should intercept
+// given library functions on a given platform.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_PLATFORM_INTERCEPTORS_H
+#define SANITIZER_PLATFORM_INTERCEPTORS_H
+
+#include "sanitizer_internal_defs.h"
+
+#if !SANITIZER_WINDOWS
+# define SI_NOT_WINDOWS 1
+# include "sanitizer_platform_limits_posix.h"
+#else
+# define SI_NOT_WINDOWS 0
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+# define SI_LINUX_NOT_ANDROID 1
+#else
+# define SI_LINUX_NOT_ANDROID 0
+#endif
+
+#if SANITIZER_FREEBSD
+# define SI_FREEBSD 1
+#else
+# define SI_FREEBSD 0
+#endif
+
+#if SANITIZER_LINUX
+# define SI_LINUX 1
+#else
+# define SI_LINUX 0
+#endif
+
+#if SANITIZER_MAC
+# define SI_MAC 1
+#else
+# define SI_MAC 0
+#endif
+
+#if SANITIZER_IOS
+# define SI_IOS 1
+#else
+# define SI_IOS 0
+#endif
+
+#define SANITIZER_INTERCEPT_STRCMP 1
+#define SANITIZER_INTERCEPT_STRSTR 1
+#define SANITIZER_INTERCEPT_STRCASESTR SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_STRSPN 1
+#define SANITIZER_INTERCEPT_STRPBRK 1
+#define SANITIZER_INTERCEPT_TEXTDOMAIN SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STRCASECMP SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_MEMCMP 1
+#define SANITIZER_INTERCEPT_MEMCHR 1
+#define SANITIZER_INTERCEPT_MEMRCHR SI_FREEBSD || SI_LINUX
+
+#define SANITIZER_INTERCEPT_READ   SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PREAD  SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_WRITE  SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PWRITE SI_NOT_WINDOWS
+
+#define SANITIZER_INTERCEPT_PREAD64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PWRITE64 SI_LINUX_NOT_ANDROID
+
+#define SANITIZER_INTERCEPT_READV SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_WRITEV SI_NOT_WINDOWS
+
+#define SANITIZER_INTERCEPT_PREADV SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PWRITEV SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PREADV64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PWRITEV64 SI_LINUX_NOT_ANDROID
+
+#define SANITIZER_INTERCEPT_PRCTL   SI_LINUX
+
+#define SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_STRPTIME SI_NOT_WINDOWS
+
+#define SANITIZER_INTERCEPT_SCANF SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_ISOC99_SCANF SI_LINUX_NOT_ANDROID
+
+#ifndef SANITIZER_INTERCEPT_PRINTF
+# define SANITIZER_INTERCEPT_PRINTF SI_NOT_WINDOWS
+# define SANITIZER_INTERCEPT_PRINTF_L SI_FREEBSD
+# define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_LINUX_NOT_ANDROID
+#endif
+
+#define SANITIZER_INTERCEPT_FREXP 1
+#define SANITIZER_INTERCEPT_FREXPF_FREXPL SI_NOT_WINDOWS
+
+#define SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETPWENT \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_FGETPWENT SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETPWENT_R SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SETPWENT SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_CLOCK_GETTIME SI_FREEBSD || SI_LINUX
+#define SANITIZER_INTERCEPT_GETITIMER SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_TIME SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GLOB SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_WAIT SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_INET SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_GETSCHEDPARAM SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETADDRINFO SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETNAMEINFO SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETSOCKNAME SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETHOSTBYNAME SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETHOSTBYNAME_R SI_FREEBSD || SI_LINUX
+#define SANITIZER_INTERCEPT_GETHOSTBYNAME2_R SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETHOSTBYADDR_R SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETHOSTENT_R SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETSOCKOPT SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_ACCEPT SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_ACCEPT4 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_MODF SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_RECVMSG SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETPEERNAME SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_IOCTL SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_INET_ATON SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_SYSINFO SI_LINUX
+#define SANITIZER_INTERCEPT_READDIR SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_READDIR64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTRACE SI_LINUX_NOT_ANDROID && \
+  (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
+    defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__))
+#define SANITIZER_INTERCEPT_SETLOCALE SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GETCWD SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_GET_CURRENT_DIR_NAME SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STRTOIMAX SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_MBSTOWCS SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_MBSNRTOWCS SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_WCSTOMBS SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_WCSNRTOMBS \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_WCRTOMB \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_TCGETATTR SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_REALPATH SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_CONFSTR \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SCHED_GETAFFINITY SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SCHED_GETPARAM SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STRERROR SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_STRERROR_R SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_XPG_STRERROR_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SCANDIR \
+  SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SCANDIR64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETGROUPS SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_POLL SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PPOLL SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_WORDEXP \
+  SI_FREEBSD || (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SIGWAIT SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_SIGWAITINFO SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SIGTIMEDWAIT SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SIGSETOPS \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SIGPENDING SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_SIGPROCMASK SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_BACKTRACE SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GETMNTENT SI_LINUX
+#define SANITIZER_INTERCEPT_GETMNTENT_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STATFS SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STATFS64 \
+  (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STATVFS SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_STATVFS64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_INITGROUPS SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_ETHER_NTOA_ATON SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_ETHER_HOST \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_ETHER_R SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SHMCTL \
+  ((SI_FREEBSD || SI_LINUX_NOT_ANDROID) && SANITIZER_WORDSIZE == 64)
+#define SANITIZER_INTERCEPT_RANDOM_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL \
+  SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING \
+  SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST_NP SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETPSHARED SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETKIND_NP SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETPSHARED SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETCLOCK SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GETPSHARED SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_TMPNAM SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_TMPNAM_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_TEMPNAM SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_SINCOS SI_LINUX
+#define SANITIZER_INTERCEPT_REMQUO SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_LGAMMA SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_LGAMMA_R SI_FREEBSD || SI_LINUX
+#define SANITIZER_INTERCEPT_LGAMMAL_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_DRAND48_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_RAND_R \
+  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_ICONV SI_FREEBSD || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_TIMES SI_NOT_WINDOWS
+
+// FIXME: getline seems to be available on OSX 10.7
+#define SANITIZER_INTERCEPT_GETLINE SI_FREEBSD || SI_LINUX_NOT_ANDROID
+
+#define SANITIZER_INTERCEPT__EXIT SI_LINUX || SI_FREEBSD || SI_MAC
+
+#define SANITIZER_INTERCEPT_PHTREAD_MUTEX SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP \
+  SI_FREEBSD || SI_LINUX_NOT_ANDROID
+
+#define SANITIZER_INTERCEPT_TLS_GET_ADDR \
+  SI_FREEBSD || SI_LINUX_NOT_ANDROID
+
+#define SANITIZER_INTERCEPT_LISTXATTR SI_LINUX
+#define SANITIZER_INTERCEPT_GETXATTR SI_LINUX
+#define SANITIZER_INTERCEPT_GETRESID SI_LINUX
+#define SANITIZER_INTERCEPT_GETIFADDRS \
+  SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_MAC
+#define SANITIZER_INTERCEPT_IF_INDEXTONAME \
+  SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_MAC
+#define SANITIZER_INTERCEPT_CAPGET SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_AEABI_MEM SI_LINUX && defined(__arm__)
+#define SANITIZER_INTERCEPT___BZERO SI_MAC
+#define SANITIZER_INTERCEPT_FTIME !SI_FREEBSD && SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_XDR SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_TSEARCH SI_LINUX_NOT_ANDROID || SI_MAC
+#define SANITIZER_INTERCEPT_LIBIO_INTERNALS SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_FOPEN SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_FOPEN64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_OPEN_MEMSTREAM SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_OBSTACK SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_FFLUSH SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_FCLOSE SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_DLOPEN_DLCLOSE \
+    SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_MAC
+#define SANITIZER_INTERCEPT_GETPASS SI_LINUX_NOT_ANDROID || SI_MAC
+#define SANITIZER_INTERCEPT_TIMERFD SI_LINUX_NOT_ANDROID
+
+#define SANITIZER_INTERCEPT_MLOCKX SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_FOPENCOOKIE SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SEM SI_LINUX || SI_FREEBSD
+#define SANITIZER_INTERCEPT_PTHREAD_SETCANCEL SI_NOT_WINDOWS
+#define SANITIZER_INTERCEPT_MINCORE SI_LINUX
+#define SANITIZER_INTERCEPT_PROCESS_VM_READV SI_LINUX
+#define SANITIZER_INTERCEPT_CTERMID SI_LINUX || SI_MAC || SI_FREEBSD
+#define SANITIZER_INTERCEPT_CTERMID_R SI_MAC || SI_FREEBSD
+
+#define SANITIZER_INTERCEPTOR_HOOKS SI_LINUX
+
+#endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cc b/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cc
new file mode 100644
index 0000000..92353e4
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cc
@@ -0,0 +1,105 @@
+//===-- sanitizer_platform_limits_linux.cc --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer common code.
+//
+// Sizes and layouts of linux kernel data structures.
+//===----------------------------------------------------------------------===//
+
+// This is a separate compilation unit for linux headers that conflict with
+// userspace headers.
+// Most "normal" includes go in sanitizer_platform_limits_posix.cc
+
+#include "sanitizer_platform.h"
+#if SANITIZER_LINUX
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_platform_limits_posix.h"
+
+// For offsetof -> __builtin_offsetof definition.
+#include <stddef.h>
+
+// With old kernels (and even new kernels on powerpc) asm/stat.h uses types that
+// are not defined anywhere in userspace headers. Fake them. This seems to work
+// fine with newer headers, too.
+#include <asm/posix_types.h>
+#if defined(__x86_64__) ||  defined(__mips__)
+#include <sys/stat.h>
+#else
+#define ino_t __kernel_ino_t
+#define mode_t __kernel_mode_t
+#define nlink_t __kernel_nlink_t
+#define uid_t __kernel_uid_t
+#define gid_t __kernel_gid_t
+#define off_t __kernel_off_t
+// This header seems to contain the definitions of _kernel_ stat* structs.
+#include <asm/stat.h>
+#undef ino_t
+#undef mode_t
+#undef nlink_t
+#undef uid_t
+#undef gid_t
+#undef off_t
+#endif
+
+#include <linux/aio_abi.h>
+
+#if !SANITIZER_ANDROID
+#include <sys/statfs.h>
+#include <linux/perf_event.h>
+#endif
+
+namespace __sanitizer {
+#if !SANITIZER_ANDROID
+  unsigned struct_statfs64_sz = sizeof(struct statfs64);
+#endif
+}  // namespace __sanitizer
+
+#if !defined(__powerpc64__) && !defined(__x86_64__) && !defined(__aarch64__)\
+                            && !defined(__mips__)
+COMPILER_CHECK(struct___old_kernel_stat_sz == sizeof(struct __old_kernel_stat));
+#endif
+
+COMPILER_CHECK(struct_kernel_stat_sz == sizeof(struct stat));
+
+#if defined(__i386__)
+COMPILER_CHECK(struct_kernel_stat64_sz == sizeof(struct stat64));
+#endif
+
+CHECK_TYPE_SIZE(io_event);
+CHECK_SIZE_AND_OFFSET(io_event, data);
+CHECK_SIZE_AND_OFFSET(io_event, obj);
+CHECK_SIZE_AND_OFFSET(io_event, res);
+CHECK_SIZE_AND_OFFSET(io_event, res2);
+
+#if !SANITIZER_ANDROID
+COMPILER_CHECK(sizeof(struct __sanitizer_perf_event_attr) <=
+               sizeof(struct perf_event_attr));
+CHECK_SIZE_AND_OFFSET(perf_event_attr, type);
+CHECK_SIZE_AND_OFFSET(perf_event_attr, size);
+#endif
+
+COMPILER_CHECK(iocb_cmd_pread == IOCB_CMD_PREAD);
+COMPILER_CHECK(iocb_cmd_pwrite == IOCB_CMD_PWRITE);
+#if !SANITIZER_ANDROID
+COMPILER_CHECK(iocb_cmd_preadv == IOCB_CMD_PREADV);
+COMPILER_CHECK(iocb_cmd_pwritev == IOCB_CMD_PWRITEV);
+#endif
+
+CHECK_TYPE_SIZE(iocb);
+CHECK_SIZE_AND_OFFSET(iocb, aio_data);
+// Skip aio_key, it's weird.
+CHECK_SIZE_AND_OFFSET(iocb, aio_lio_opcode);
+CHECK_SIZE_AND_OFFSET(iocb, aio_reqprio);
+CHECK_SIZE_AND_OFFSET(iocb, aio_fildes);
+CHECK_SIZE_AND_OFFSET(iocb, aio_buf);
+CHECK_SIZE_AND_OFFSET(iocb, aio_nbytes);
+CHECK_SIZE_AND_OFFSET(iocb, aio_offset);
+
+#endif  // SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cc b/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cc
new file mode 100644
index 0000000..0e07737
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cc
@@ -0,0 +1,1275 @@
+//===-- sanitizer_platform_limits_posix.cc --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer common code.
+//
+// Sizes and layouts of platform-specific POSIX data structures.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC
+// Tests in this file assume that off_t-dependent data structures match the
+// libc ABI. For example, struct dirent here is what readdir() function (as
+// exported from libc) returns, and not the user-facing "dirent", which
+// depends on _FILE_OFFSET_BITS setting.
+// To get this "true" dirent definition, we undefine _FILE_OFFSET_BITS below.
+#ifdef _FILE_OFFSET_BITS
+#undef _FILE_OFFSET_BITS
+#endif
+#if SANITIZER_FREEBSD
+#define _WANT_RTENTRY
+#include <sys/param.h>
+#include <sys/socketvar.h>
+#endif
+#include <arpa/inet.h>
+#include <dirent.h>
+#include <errno.h>
+#include <grp.h>
+#include <limits.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <poll.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <signal.h>
+#include <stddef.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <termios.h>
+#include <time.h>
+#include <wchar.h>
+
+#if !SANITIZER_IOS
+#include <net/route.h>
+#endif
+
+#if !SANITIZER_ANDROID
+#include <sys/mount.h>
+#include <sys/timeb.h>
+#endif
+
+#if SANITIZER_LINUX
+#include <malloc.h>
+#include <mntent.h>
+#include <netinet/ether.h>
+#include <sys/sysinfo.h>
+#include <sys/vt.h>
+#include <linux/cdrom.h>
+#include <linux/fd.h>
+#include <linux/fs.h>
+#include <linux/hdreg.h>
+#include <linux/input.h>
+#include <linux/ioctl.h>
+#include <linux/soundcard.h>
+#include <linux/sysctl.h>
+#include <linux/utsname.h>
+#include <linux/posix_types.h>
+#include <net/if_arp.h>
+#endif
+
+#if SANITIZER_FREEBSD
+# include <sys/mount.h>
+# include <sys/sockio.h>
+# include <sys/socket.h>
+# include <sys/filio.h>
+# include <sys/signal.h>
+# include <sys/timespec.h>
+# include <sys/timex.h>
+# include <sys/mqueue.h>
+# include <sys/msg.h>
+# include <sys/ipc.h>
+# include <sys/msg.h>
+# include <sys/statvfs.h>
+# include <sys/soundcard.h>
+# include <sys/mtio.h>
+# include <sys/consio.h>
+# include <sys/kbio.h>
+# include <sys/link_elf.h>
+# include <netinet/ip_mroute.h>
+# include <netinet/in.h>
+# include <net/ethernet.h>
+# include <net/ppp_defs.h>
+# include <glob.h>
+# include <term.h>
+
+#define _KERNEL  // to declare 'shminfo' structure
+# include <sys/shm.h>
+#undef _KERNEL
+
+#undef INLINE  // to avoid clashes with sanitizers' definitions
+#endif
+
+#if SANITIZER_FREEBSD || SANITIZER_IOS
+#undef IOC_DIRMASK
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+# include <utime.h>
+# include <sys/ptrace.h>
+# if defined(__mips64) || defined(__aarch64__) || defined(__arm__)
+#  include <asm/ptrace.h>
+#  ifdef __arm__
+typedef struct user_fpregs elf_fpregset_t;
+#   define ARM_VFPREGS_SIZE_ASAN (32 * 8 /*fpregs*/ + 4 /*fpscr*/)
+#   if !defined(ARM_VFPREGS_SIZE)
+#     define ARM_VFPREGS_SIZE ARM_VFPREGS_SIZE_ASAN
+#   endif
+#  endif
+# endif
+# include <semaphore.h>
+#endif
+
+#if !SANITIZER_ANDROID
+#include <ifaddrs.h>
+#include <sys/ucontext.h>
+#include <wordexp.h>
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#include <glob.h>
+#include <obstack.h>
+#include <mqueue.h>
+#include <net/if_ppp.h>
+#include <netax25/ax25.h>
+#include <netipx/ipx.h>
+#include <netrom/netrom.h>
+#if HAVE_RPC_XDR_H
+# include <rpc/xdr.h>
+#elif HAVE_TIRPC_RPC_XDR_H
+# include <tirpc/rpc/xdr.h>
+#endif
+#include <scsi/scsi.h>
+#include <sys/mtio.h>
+#include <sys/kd.h>
+#include <sys/shm.h>
+#include <sys/statvfs.h>
+#include <sys/timex.h>
+#if defined(__mips64)
+# include <sys/procfs.h>
+#endif
+#include <sys/user.h>
+#include <sys/ustat.h>
+#include <linux/cyclades.h>
+#include <linux/if_eql.h>
+#include <linux/if_plip.h>
+#include <linux/lp.h>
+#include <linux/mroute.h>
+#include <linux/mroute6.h>
+#include <linux/scc.h>
+#include <linux/serial.h>
+#include <sys/msg.h>
+#include <sys/ipc.h>
+#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+#if SANITIZER_ANDROID
+#include <linux/kd.h>
+#include <linux/mtio.h>
+#include <linux/ppp_defs.h>
+#include <linux/if_ppp.h>
+#endif
+
+#if SANITIZER_LINUX
+#include <link.h>
+#include <sys/vfs.h>
+#include <sys/epoll.h>
+#include <linux/capability.h>
+#endif // SANITIZER_LINUX
+
+#if SANITIZER_MAC
+#include <net/ethernet.h>
+#include <sys/filio.h>
+#include <sys/sockio.h>
+#endif
+
+// Include these after system headers to avoid name clashes and ambiguities.
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_platform_limits_posix.h"
+
+namespace __sanitizer {
+  unsigned struct_utsname_sz = sizeof(struct utsname);
+  unsigned struct_stat_sz = sizeof(struct stat);
+#if !SANITIZER_IOS && !SANITIZER_FREEBSD
+  unsigned struct_stat64_sz = sizeof(struct stat64);
+#endif // !SANITIZER_IOS && !SANITIZER_FREEBSD
+  unsigned struct_rusage_sz = sizeof(struct rusage);
+  unsigned struct_tm_sz = sizeof(struct tm);
+  unsigned struct_passwd_sz = sizeof(struct passwd);
+  unsigned struct_group_sz = sizeof(struct group);
+  unsigned siginfo_t_sz = sizeof(siginfo_t);
+  unsigned struct_sigaction_sz = sizeof(struct sigaction);
+  unsigned struct_itimerval_sz = sizeof(struct itimerval);
+  unsigned pthread_t_sz = sizeof(pthread_t);
+  unsigned pthread_cond_t_sz = sizeof(pthread_cond_t);
+  unsigned pid_t_sz = sizeof(pid_t);
+  unsigned timeval_sz = sizeof(timeval);
+  unsigned uid_t_sz = sizeof(uid_t);
+  unsigned gid_t_sz = sizeof(gid_t);
+  unsigned mbstate_t_sz = sizeof(mbstate_t);
+  unsigned sigset_t_sz = sizeof(sigset_t);
+  unsigned struct_timezone_sz = sizeof(struct timezone);
+  unsigned struct_tms_sz = sizeof(struct tms);
+  unsigned struct_sigevent_sz = sizeof(struct sigevent);
+  unsigned struct_sched_param_sz = sizeof(struct sched_param);
+
+
+#if SANITIZER_MAC && !SANITIZER_IOS
+  unsigned struct_statfs64_sz = sizeof(struct statfs64);
+#endif // SANITIZER_MAC && !SANITIZER_IOS
+
+#if !SANITIZER_ANDROID
+  unsigned struct_statfs_sz = sizeof(struct statfs);
+  unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
+  unsigned ucontext_t_sz = sizeof(ucontext_t);
+#endif // !SANITIZER_ANDROID
+
+#if SANITIZER_LINUX
+  unsigned struct_epoll_event_sz = sizeof(struct epoll_event);
+  unsigned struct_sysinfo_sz = sizeof(struct sysinfo);
+  unsigned __user_cap_header_struct_sz =
+      sizeof(struct __user_cap_header_struct);
+  unsigned __user_cap_data_struct_sz = sizeof(struct __user_cap_data_struct);
+  unsigned struct_new_utsname_sz = sizeof(struct new_utsname);
+  unsigned struct_old_utsname_sz = sizeof(struct old_utsname);
+  unsigned struct_oldold_utsname_sz = sizeof(struct oldold_utsname);
+#endif // SANITIZER_LINUX
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+  unsigned struct_rlimit_sz = sizeof(struct rlimit);
+  unsigned struct_timespec_sz = sizeof(struct timespec);
+  unsigned struct_utimbuf_sz = sizeof(struct utimbuf);
+  unsigned struct_itimerspec_sz = sizeof(struct itimerspec);
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  unsigned struct_ustat_sz = sizeof(struct ustat);
+  unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
+  unsigned struct_statvfs64_sz = sizeof(struct statvfs64);
+#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  unsigned struct_timex_sz = sizeof(struct timex);
+  unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
+  unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
+  unsigned struct_statvfs_sz = sizeof(struct statvfs);
+#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+
+  uptr sig_ign = (uptr)SIG_IGN;
+  uptr sig_dfl = (uptr)SIG_DFL;
+  uptr sa_siginfo = (uptr)SA_SIGINFO;
+
+#if SANITIZER_LINUX
+  int e_tabsz = (int)E_TABSZ;
+#endif
+
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  unsigned struct_shminfo_sz = sizeof(struct shminfo);
+  unsigned struct_shm_info_sz = sizeof(struct shm_info);
+  int shmctl_ipc_stat = (int)IPC_STAT;
+  int shmctl_ipc_info = (int)IPC_INFO;
+  int shmctl_shm_info = (int)SHM_INFO;
+  int shmctl_shm_stat = (int)SHM_STAT;
+#endif
+
+  int map_fixed = MAP_FIXED;
+
+  int af_inet = (int)AF_INET;
+  int af_inet6 = (int)AF_INET6;
+
+  uptr __sanitizer_in_addr_sz(int af) {
+    if (af == AF_INET)
+      return sizeof(struct in_addr);
+    else if (af == AF_INET6)
+      return sizeof(struct in6_addr);
+    else
+      return 0;
+  }
+
+#if SANITIZER_LINUX
+unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr));
+#elif SANITIZER_FREEBSD
+unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
+#endif
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  int glob_nomatch = GLOB_NOMATCH;
+  int glob_altdirfunc = GLOB_ALTDIRFUNC;
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID && \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
+      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__))
+#if defined(__mips64) || defined(__powerpc64__) || defined(__arm__)
+  unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs);
+  unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t);
+#elif defined(__aarch64__)
+  unsigned struct_user_regs_struct_sz = sizeof(struct user_pt_regs);
+  unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpsimd_state);
+#else
+  unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
+  unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpregs_struct);
+#endif // __mips64 || __powerpc64__ || __aarch64__
+#if defined(__x86_64) || defined(__mips64) || defined(__powerpc64__) || \
+    defined(__aarch64__) || defined(__arm__)
+  unsigned struct_user_fpxregs_struct_sz = 0;
+#else
+  unsigned struct_user_fpxregs_struct_sz = sizeof(struct user_fpxregs_struct);
+#endif // __x86_64 || __mips64 || __powerpc64__ || __aarch64__ || __arm__
+#ifdef __arm__
+  unsigned struct_user_vfpregs_struct_sz = ARM_VFPREGS_SIZE;
+#else
+  unsigned struct_user_vfpregs_struct_sz = 0;
+#endif
+
+  int ptrace_peektext = PTRACE_PEEKTEXT;
+  int ptrace_peekdata = PTRACE_PEEKDATA;
+  int ptrace_peekuser = PTRACE_PEEKUSER;
+#if (defined(PTRACE_GETREGS) && defined(PTRACE_SETREGS)) || \
+    (defined(PT_GETREGS) && defined(PT_SETREGS))
+  int ptrace_getregs = PTRACE_GETREGS;
+  int ptrace_setregs = PTRACE_SETREGS;
+#else
+  int ptrace_getregs = -1;
+  int ptrace_setregs = -1;
+#endif
+#if (defined(PTRACE_GETFPREGS) && defined(PTRACE_SETFPREGS)) || \
+    (defined(PT_GETFPREGS) && defined(PT_SETFPREGS))
+  int ptrace_getfpregs = PTRACE_GETFPREGS;
+  int ptrace_setfpregs = PTRACE_SETFPREGS;
+#else
+  int ptrace_getfpregs = -1;
+  int ptrace_setfpregs = -1;
+#endif
+#if (defined(PTRACE_GETFPXREGS) && defined(PTRACE_SETFPXREGS)) || \
+    (defined(PT_GETFPXREGS) && defined(PT_SETFPXREGS))
+  int ptrace_getfpxregs = PTRACE_GETFPXREGS;
+  int ptrace_setfpxregs = PTRACE_SETFPXREGS;
+#else
+  int ptrace_getfpxregs = -1;
+  int ptrace_setfpxregs = -1;
+#endif // PTRACE_GETFPXREGS/PTRACE_SETFPXREGS
+#if defined(PTRACE_GETVFPREGS) && defined(PTRACE_SETVFPREGS)
+  int ptrace_getvfpregs = PTRACE_GETVFPREGS;
+  int ptrace_setvfpregs = PTRACE_SETVFPREGS;
+#else
+  int ptrace_getvfpregs = -1;
+  int ptrace_setvfpregs = -1;
+#endif
+  int ptrace_geteventmsg = PTRACE_GETEVENTMSG;
+#if (defined(PTRACE_GETSIGINFO) && defined(PTRACE_SETSIGINFO)) ||              \
+    (defined(PT_GETSIGINFO) && defined(PT_SETSIGINFO))
+  int ptrace_getsiginfo = PTRACE_GETSIGINFO;
+  int ptrace_setsiginfo = PTRACE_SETSIGINFO;
+#else
+  int ptrace_getsiginfo = -1;
+  int ptrace_setsiginfo = -1;
+#endif // PTRACE_GETSIGINFO/PTRACE_SETSIGINFO
+#if defined(PTRACE_GETREGSET) && defined(PTRACE_SETREGSET)
+  int ptrace_getregset = PTRACE_GETREGSET;
+  int ptrace_setregset = PTRACE_SETREGSET;
+#else
+  int ptrace_getregset = -1;
+  int ptrace_setregset = -1;
+#endif // PTRACE_GETREGSET/PTRACE_SETREGSET
+#endif
+
+  unsigned path_max = PATH_MAX;
+
+  // ioctl arguments
+  unsigned struct_ifreq_sz = sizeof(struct ifreq);
+  unsigned struct_termios_sz = sizeof(struct termios);
+  unsigned struct_winsize_sz = sizeof(struct winsize);
+
+#if SANITIZER_LINUX
+  unsigned struct_arpreq_sz = sizeof(struct arpreq);
+  unsigned struct_cdrom_msf_sz = sizeof(struct cdrom_msf);
+  unsigned struct_cdrom_multisession_sz = sizeof(struct cdrom_multisession);
+  unsigned struct_cdrom_read_audio_sz = sizeof(struct cdrom_read_audio);
+  unsigned struct_cdrom_subchnl_sz = sizeof(struct cdrom_subchnl);
+  unsigned struct_cdrom_ti_sz = sizeof(struct cdrom_ti);
+  unsigned struct_cdrom_tocentry_sz = sizeof(struct cdrom_tocentry);
+  unsigned struct_cdrom_tochdr_sz = sizeof(struct cdrom_tochdr);
+  unsigned struct_cdrom_volctrl_sz = sizeof(struct cdrom_volctrl);
+  unsigned struct_ff_effect_sz = sizeof(struct ff_effect);
+  unsigned struct_floppy_drive_params_sz = sizeof(struct floppy_drive_params);
+  unsigned struct_floppy_drive_struct_sz = sizeof(struct floppy_drive_struct);
+  unsigned struct_floppy_fdc_state_sz = sizeof(struct floppy_fdc_state);
+  unsigned struct_floppy_max_errors_sz = sizeof(struct floppy_max_errors);
+  unsigned struct_floppy_raw_cmd_sz = sizeof(struct floppy_raw_cmd);
+  unsigned struct_floppy_struct_sz = sizeof(struct floppy_struct);
+  unsigned struct_floppy_write_errors_sz = sizeof(struct floppy_write_errors);
+  unsigned struct_format_descr_sz = sizeof(struct format_descr);
+  unsigned struct_hd_driveid_sz = sizeof(struct hd_driveid);
+  unsigned struct_hd_geometry_sz = sizeof(struct hd_geometry);
+  unsigned struct_input_absinfo_sz = sizeof(struct input_absinfo);
+  unsigned struct_input_id_sz = sizeof(struct input_id);
+  unsigned struct_mtpos_sz = sizeof(struct mtpos);
+  unsigned struct_termio_sz = sizeof(struct termio);
+  unsigned struct_vt_consize_sz = sizeof(struct vt_consize);
+  unsigned struct_vt_sizes_sz = sizeof(struct vt_sizes);
+  unsigned struct_vt_stat_sz = sizeof(struct vt_stat);
+#endif // SANITIZER_LINUX
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SOUND_VERSION >= 0x040000
+  unsigned struct_copr_buffer_sz = 0;
+  unsigned struct_copr_debug_buf_sz = 0;
+  unsigned struct_copr_msg_sz = 0;
+#else
+  unsigned struct_copr_buffer_sz = sizeof(struct copr_buffer);
+  unsigned struct_copr_debug_buf_sz = sizeof(struct copr_debug_buf);
+  unsigned struct_copr_msg_sz = sizeof(struct copr_msg);
+#endif
+  unsigned struct_midi_info_sz = sizeof(struct midi_info);
+  unsigned struct_mtget_sz = sizeof(struct mtget);
+  unsigned struct_mtop_sz = sizeof(struct mtop);
+  unsigned struct_rtentry_sz = sizeof(struct rtentry);
+  unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument);
+  unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec);
+  unsigned struct_synth_info_sz = sizeof(struct synth_info);
+  unsigned struct_vt_mode_sz = sizeof(struct vt_mode);
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct);
+  unsigned struct_cyclades_monitor_sz = sizeof(struct cyclades_monitor);
+#if EV_VERSION > (0x010000)
+  unsigned struct_input_keymap_entry_sz = sizeof(struct input_keymap_entry);
+#else
+  unsigned struct_input_keymap_entry_sz = 0;
+#endif
+  unsigned struct_ipx_config_data_sz = sizeof(struct ipx_config_data);
+  unsigned struct_kbdiacrs_sz = sizeof(struct kbdiacrs);
+  unsigned struct_kbentry_sz = sizeof(struct kbentry);
+  unsigned struct_kbkeycode_sz = sizeof(struct kbkeycode);
+  unsigned struct_kbsentry_sz = sizeof(struct kbsentry);
+  unsigned struct_mtconfiginfo_sz = sizeof(struct mtconfiginfo);
+  unsigned struct_nr_parms_struct_sz = sizeof(struct nr_parms_struct);
+  unsigned struct_scc_modem_sz = sizeof(struct scc_modem);
+  unsigned struct_scc_stat_sz = sizeof(struct scc_stat);
+  unsigned struct_serial_multiport_struct_sz
+      = sizeof(struct serial_multiport_struct);
+  unsigned struct_serial_struct_sz = sizeof(struct serial_struct);
+  unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25);
+  unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc);
+  unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
+#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
+  unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
+#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+
+#if !SANITIZER_ANDROID && !SANITIZER_MAC
+  unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
+  unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
+#endif
+
+  const unsigned IOCTL_NOT_PRESENT = 0;
+
+  unsigned IOCTL_FIOASYNC = FIOASYNC;
+  unsigned IOCTL_FIOCLEX = FIOCLEX;
+  unsigned IOCTL_FIOGETOWN = FIOGETOWN;
+  unsigned IOCTL_FIONBIO = FIONBIO;
+  unsigned IOCTL_FIONCLEX = FIONCLEX;
+  unsigned IOCTL_FIOSETOWN = FIOSETOWN;
+  unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI;
+  unsigned IOCTL_SIOCATMARK = SIOCATMARK;
+  unsigned IOCTL_SIOCDELMULTI = SIOCDELMULTI;
+  unsigned IOCTL_SIOCGIFADDR = SIOCGIFADDR;
+  unsigned IOCTL_SIOCGIFBRDADDR = SIOCGIFBRDADDR;
+  unsigned IOCTL_SIOCGIFCONF = SIOCGIFCONF;
+  unsigned IOCTL_SIOCGIFDSTADDR = SIOCGIFDSTADDR;
+  unsigned IOCTL_SIOCGIFFLAGS = SIOCGIFFLAGS;
+  unsigned IOCTL_SIOCGIFMETRIC = SIOCGIFMETRIC;
+  unsigned IOCTL_SIOCGIFMTU = SIOCGIFMTU;
+  unsigned IOCTL_SIOCGIFNETMASK = SIOCGIFNETMASK;
+  unsigned IOCTL_SIOCGPGRP = SIOCGPGRP;
+  unsigned IOCTL_SIOCSIFADDR = SIOCSIFADDR;
+  unsigned IOCTL_SIOCSIFBRDADDR = SIOCSIFBRDADDR;
+  unsigned IOCTL_SIOCSIFDSTADDR = SIOCSIFDSTADDR;
+  unsigned IOCTL_SIOCSIFFLAGS = SIOCSIFFLAGS;
+  unsigned IOCTL_SIOCSIFMETRIC = SIOCSIFMETRIC;
+  unsigned IOCTL_SIOCSIFMTU = SIOCSIFMTU;
+  unsigned IOCTL_SIOCSIFNETMASK = SIOCSIFNETMASK;
+  unsigned IOCTL_SIOCSPGRP = SIOCSPGRP;
+  unsigned IOCTL_TIOCCONS = TIOCCONS;
+  unsigned IOCTL_TIOCEXCL = TIOCEXCL;
+  unsigned IOCTL_TIOCGETD = TIOCGETD;
+  unsigned IOCTL_TIOCGPGRP = TIOCGPGRP;
+  unsigned IOCTL_TIOCGWINSZ = TIOCGWINSZ;
+  unsigned IOCTL_TIOCMBIC = TIOCMBIC;
+  unsigned IOCTL_TIOCMBIS = TIOCMBIS;
+  unsigned IOCTL_TIOCMGET = TIOCMGET;
+  unsigned IOCTL_TIOCMSET = TIOCMSET;
+  unsigned IOCTL_TIOCNOTTY = TIOCNOTTY;
+  unsigned IOCTL_TIOCNXCL = TIOCNXCL;
+  unsigned IOCTL_TIOCOUTQ = TIOCOUTQ;
+  unsigned IOCTL_TIOCPKT = TIOCPKT;
+  unsigned IOCTL_TIOCSCTTY = TIOCSCTTY;
+  unsigned IOCTL_TIOCSETD = TIOCSETD;
+  unsigned IOCTL_TIOCSPGRP = TIOCSPGRP;
+  unsigned IOCTL_TIOCSTI = TIOCSTI;
+  unsigned IOCTL_TIOCSWINSZ = TIOCSWINSZ;
+#if ((SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID)
+  unsigned IOCTL_SIOCGETSGCNT = SIOCGETSGCNT;
+  unsigned IOCTL_SIOCGETVIFCNT = SIOCGETVIFCNT;
+#endif
+
+#if SANITIZER_LINUX
+  unsigned IOCTL_EVIOCGABS = EVIOCGABS(0);
+  unsigned IOCTL_EVIOCGBIT = EVIOCGBIT(0, 0);
+  unsigned IOCTL_EVIOCGEFFECTS = EVIOCGEFFECTS;
+  unsigned IOCTL_EVIOCGID = EVIOCGID;
+  unsigned IOCTL_EVIOCGKEY = EVIOCGKEY(0);
+  unsigned IOCTL_EVIOCGKEYCODE = EVIOCGKEYCODE;
+  unsigned IOCTL_EVIOCGLED = EVIOCGLED(0);
+  unsigned IOCTL_EVIOCGNAME = EVIOCGNAME(0);
+  unsigned IOCTL_EVIOCGPHYS = EVIOCGPHYS(0);
+  unsigned IOCTL_EVIOCGRAB = EVIOCGRAB;
+  unsigned IOCTL_EVIOCGREP = EVIOCGREP;
+  unsigned IOCTL_EVIOCGSND = EVIOCGSND(0);
+  unsigned IOCTL_EVIOCGSW = EVIOCGSW(0);
+  unsigned IOCTL_EVIOCGUNIQ = EVIOCGUNIQ(0);
+  unsigned IOCTL_EVIOCGVERSION = EVIOCGVERSION;
+  unsigned IOCTL_EVIOCRMFF = EVIOCRMFF;
+  unsigned IOCTL_EVIOCSABS = EVIOCSABS(0);
+  unsigned IOCTL_EVIOCSFF = EVIOCSFF;
+  unsigned IOCTL_EVIOCSKEYCODE = EVIOCSKEYCODE;
+  unsigned IOCTL_EVIOCSREP = EVIOCSREP;
+  unsigned IOCTL_BLKFLSBUF = BLKFLSBUF;
+  unsigned IOCTL_BLKGETSIZE = BLKGETSIZE;
+  unsigned IOCTL_BLKRAGET = BLKRAGET;
+  unsigned IOCTL_BLKRASET = BLKRASET;
+  unsigned IOCTL_BLKROGET = BLKROGET;
+  unsigned IOCTL_BLKROSET = BLKROSET;
+  unsigned IOCTL_BLKRRPART = BLKRRPART;
+  unsigned IOCTL_CDROMAUDIOBUFSIZ = CDROMAUDIOBUFSIZ;
+  unsigned IOCTL_CDROMEJECT = CDROMEJECT;
+  unsigned IOCTL_CDROMEJECT_SW = CDROMEJECT_SW;
+  unsigned IOCTL_CDROMMULTISESSION = CDROMMULTISESSION;
+  unsigned IOCTL_CDROMPAUSE = CDROMPAUSE;
+  unsigned IOCTL_CDROMPLAYMSF = CDROMPLAYMSF;
+  unsigned IOCTL_CDROMPLAYTRKIND = CDROMPLAYTRKIND;
+  unsigned IOCTL_CDROMREADAUDIO = CDROMREADAUDIO;
+  unsigned IOCTL_CDROMREADCOOKED = CDROMREADCOOKED;
+  unsigned IOCTL_CDROMREADMODE1 = CDROMREADMODE1;
+  unsigned IOCTL_CDROMREADMODE2 = CDROMREADMODE2;
+  unsigned IOCTL_CDROMREADRAW = CDROMREADRAW;
+  unsigned IOCTL_CDROMREADTOCENTRY = CDROMREADTOCENTRY;
+  unsigned IOCTL_CDROMREADTOCHDR = CDROMREADTOCHDR;
+  unsigned IOCTL_CDROMRESET = CDROMRESET;
+  unsigned IOCTL_CDROMRESUME = CDROMRESUME;
+  unsigned IOCTL_CDROMSEEK = CDROMSEEK;
+  unsigned IOCTL_CDROMSTART = CDROMSTART;
+  unsigned IOCTL_CDROMSTOP = CDROMSTOP;
+  unsigned IOCTL_CDROMSUBCHNL = CDROMSUBCHNL;
+  unsigned IOCTL_CDROMVOLCTRL = CDROMVOLCTRL;
+  unsigned IOCTL_CDROMVOLREAD = CDROMVOLREAD;
+  unsigned IOCTL_CDROM_GET_UPC = CDROM_GET_UPC;
+  unsigned IOCTL_FDCLRPRM = FDCLRPRM;
+  unsigned IOCTL_FDDEFPRM = FDDEFPRM;
+  unsigned IOCTL_FDFLUSH = FDFLUSH;
+  unsigned IOCTL_FDFMTBEG = FDFMTBEG;
+  unsigned IOCTL_FDFMTEND = FDFMTEND;
+  unsigned IOCTL_FDFMTTRK = FDFMTTRK;
+  unsigned IOCTL_FDGETDRVPRM = FDGETDRVPRM;
+  unsigned IOCTL_FDGETDRVSTAT = FDGETDRVSTAT;
+  unsigned IOCTL_FDGETDRVTYP = FDGETDRVTYP;
+  unsigned IOCTL_FDGETFDCSTAT = FDGETFDCSTAT;
+  unsigned IOCTL_FDGETMAXERRS = FDGETMAXERRS;
+  unsigned IOCTL_FDGETPRM = FDGETPRM;
+  unsigned IOCTL_FDMSGOFF = FDMSGOFF;
+  unsigned IOCTL_FDMSGON = FDMSGON;
+  unsigned IOCTL_FDPOLLDRVSTAT = FDPOLLDRVSTAT;
+  unsigned IOCTL_FDRAWCMD = FDRAWCMD;
+  unsigned IOCTL_FDRESET = FDRESET;
+  unsigned IOCTL_FDSETDRVPRM = FDSETDRVPRM;
+  unsigned IOCTL_FDSETEMSGTRESH = FDSETEMSGTRESH;
+  unsigned IOCTL_FDSETMAXERRS = FDSETMAXERRS;
+  unsigned IOCTL_FDSETPRM = FDSETPRM;
+  unsigned IOCTL_FDTWADDLE = FDTWADDLE;
+  unsigned IOCTL_FDWERRORCLR = FDWERRORCLR;
+  unsigned IOCTL_FDWERRORGET = FDWERRORGET;
+  unsigned IOCTL_HDIO_DRIVE_CMD = HDIO_DRIVE_CMD;
+  unsigned IOCTL_HDIO_GETGEO = HDIO_GETGEO;
+  unsigned IOCTL_HDIO_GET_32BIT = HDIO_GET_32BIT;
+  unsigned IOCTL_HDIO_GET_DMA = HDIO_GET_DMA;
+  unsigned IOCTL_HDIO_GET_IDENTITY = HDIO_GET_IDENTITY;
+  unsigned IOCTL_HDIO_GET_KEEPSETTINGS = HDIO_GET_KEEPSETTINGS;
+  unsigned IOCTL_HDIO_GET_MULTCOUNT = HDIO_GET_MULTCOUNT;
+  unsigned IOCTL_HDIO_GET_NOWERR = HDIO_GET_NOWERR;
+  unsigned IOCTL_HDIO_GET_UNMASKINTR = HDIO_GET_UNMASKINTR;
+  unsigned IOCTL_HDIO_SET_32BIT = HDIO_SET_32BIT;
+  unsigned IOCTL_HDIO_SET_DMA = HDIO_SET_DMA;
+  unsigned IOCTL_HDIO_SET_KEEPSETTINGS = HDIO_SET_KEEPSETTINGS;
+  unsigned IOCTL_HDIO_SET_MULTCOUNT = HDIO_SET_MULTCOUNT;
+  unsigned IOCTL_HDIO_SET_NOWERR = HDIO_SET_NOWERR;
+  unsigned IOCTL_HDIO_SET_UNMASKINTR = HDIO_SET_UNMASKINTR;
+  unsigned IOCTL_MTIOCPOS = MTIOCPOS;
+  unsigned IOCTL_PPPIOCGASYNCMAP = PPPIOCGASYNCMAP;
+  unsigned IOCTL_PPPIOCGDEBUG = PPPIOCGDEBUG;
+  unsigned IOCTL_PPPIOCGFLAGS = PPPIOCGFLAGS;
+  unsigned IOCTL_PPPIOCGUNIT = PPPIOCGUNIT;
+  unsigned IOCTL_PPPIOCGXASYNCMAP = PPPIOCGXASYNCMAP;
+  unsigned IOCTL_PPPIOCSASYNCMAP = PPPIOCSASYNCMAP;
+  unsigned IOCTL_PPPIOCSDEBUG = PPPIOCSDEBUG;
+  unsigned IOCTL_PPPIOCSFLAGS = PPPIOCSFLAGS;
+  unsigned IOCTL_PPPIOCSMAXCID = PPPIOCSMAXCID;
+  unsigned IOCTL_PPPIOCSMRU = PPPIOCSMRU;
+  unsigned IOCTL_PPPIOCSXASYNCMAP = PPPIOCSXASYNCMAP;
+  unsigned IOCTL_SIOCADDRT = SIOCADDRT;
+  unsigned IOCTL_SIOCDARP = SIOCDARP;
+  unsigned IOCTL_SIOCDELRT = SIOCDELRT;
+  unsigned IOCTL_SIOCDRARP = SIOCDRARP;
+  unsigned IOCTL_SIOCGARP = SIOCGARP;
+  unsigned IOCTL_SIOCGIFENCAP = SIOCGIFENCAP;
+  unsigned IOCTL_SIOCGIFHWADDR = SIOCGIFHWADDR;
+  unsigned IOCTL_SIOCGIFMAP = SIOCGIFMAP;
+  unsigned IOCTL_SIOCGIFMEM = SIOCGIFMEM;
+  unsigned IOCTL_SIOCGIFNAME = SIOCGIFNAME;
+  unsigned IOCTL_SIOCGIFSLAVE = SIOCGIFSLAVE;
+  unsigned IOCTL_SIOCGRARP = SIOCGRARP;
+  unsigned IOCTL_SIOCGSTAMP = SIOCGSTAMP;
+  unsigned IOCTL_SIOCSARP = SIOCSARP;
+  unsigned IOCTL_SIOCSIFENCAP = SIOCSIFENCAP;
+  unsigned IOCTL_SIOCSIFHWADDR = SIOCSIFHWADDR;
+  unsigned IOCTL_SIOCSIFLINK = SIOCSIFLINK;
+  unsigned IOCTL_SIOCSIFMAP = SIOCSIFMAP;
+  unsigned IOCTL_SIOCSIFMEM = SIOCSIFMEM;
+  unsigned IOCTL_SIOCSIFSLAVE = SIOCSIFSLAVE;
+  unsigned IOCTL_SIOCSRARP = SIOCSRARP;
+# if SOUND_VERSION >= 0x040000
+  unsigned IOCTL_SNDCTL_COPR_HALT = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_LOAD = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_RCODE = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_RCVMSG = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_RDATA = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_RESET = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_RUN = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_SENDMSG = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_WCODE = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SNDCTL_COPR_WDATA = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SOUND_PCM_READ_BITS = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SOUND_PCM_READ_CHANNELS = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SOUND_PCM_READ_FILTER = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SOUND_PCM_READ_RATE = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_SOUND_PCM_WRITE_FILTER = IOCTL_NOT_PRESENT;
+# else  // SOUND_VERSION
+  unsigned IOCTL_SNDCTL_COPR_HALT = SNDCTL_COPR_HALT;
+  unsigned IOCTL_SNDCTL_COPR_LOAD = SNDCTL_COPR_LOAD;
+  unsigned IOCTL_SNDCTL_COPR_RCODE = SNDCTL_COPR_RCODE;
+  unsigned IOCTL_SNDCTL_COPR_RCVMSG = SNDCTL_COPR_RCVMSG;
+  unsigned IOCTL_SNDCTL_COPR_RDATA = SNDCTL_COPR_RDATA;
+  unsigned IOCTL_SNDCTL_COPR_RESET = SNDCTL_COPR_RESET;
+  unsigned IOCTL_SNDCTL_COPR_RUN = SNDCTL_COPR_RUN;
+  unsigned IOCTL_SNDCTL_COPR_SENDMSG = SNDCTL_COPR_SENDMSG;
+  unsigned IOCTL_SNDCTL_COPR_WCODE = SNDCTL_COPR_WCODE;
+  unsigned IOCTL_SNDCTL_COPR_WDATA = SNDCTL_COPR_WDATA;
+  unsigned IOCTL_SOUND_PCM_READ_BITS = SOUND_PCM_READ_BITS;
+  unsigned IOCTL_SOUND_PCM_READ_CHANNELS = SOUND_PCM_READ_CHANNELS;
+  unsigned IOCTL_SOUND_PCM_READ_FILTER = SOUND_PCM_READ_FILTER;
+  unsigned IOCTL_SOUND_PCM_READ_RATE = SOUND_PCM_READ_RATE;
+  unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS = SOUND_PCM_WRITE_CHANNELS;
+  unsigned IOCTL_SOUND_PCM_WRITE_FILTER = SOUND_PCM_WRITE_FILTER;
+#endif // SOUND_VERSION
+  unsigned IOCTL_TCFLSH = TCFLSH;
+  unsigned IOCTL_TCGETA = TCGETA;
+  unsigned IOCTL_TCGETS = TCGETS;
+  unsigned IOCTL_TCSBRK = TCSBRK;
+  unsigned IOCTL_TCSBRKP = TCSBRKP;
+  unsigned IOCTL_TCSETA = TCSETA;
+  unsigned IOCTL_TCSETAF = TCSETAF;
+  unsigned IOCTL_TCSETAW = TCSETAW;
+  unsigned IOCTL_TCSETS = TCSETS;
+  unsigned IOCTL_TCSETSF = TCSETSF;
+  unsigned IOCTL_TCSETSW = TCSETSW;
+  unsigned IOCTL_TCXONC = TCXONC;
+  unsigned IOCTL_TIOCGLCKTRMIOS = TIOCGLCKTRMIOS;
+  unsigned IOCTL_TIOCGSOFTCAR = TIOCGSOFTCAR;
+  unsigned IOCTL_TIOCINQ = TIOCINQ;
+  unsigned IOCTL_TIOCLINUX = TIOCLINUX;
+  unsigned IOCTL_TIOCSERCONFIG = TIOCSERCONFIG;
+  unsigned IOCTL_TIOCSERGETLSR = TIOCSERGETLSR;
+  unsigned IOCTL_TIOCSERGWILD = TIOCSERGWILD;
+  unsigned IOCTL_TIOCSERSWILD = TIOCSERSWILD;
+  unsigned IOCTL_TIOCSLCKTRMIOS = TIOCSLCKTRMIOS;
+  unsigned IOCTL_TIOCSSOFTCAR = TIOCSSOFTCAR;
+  unsigned IOCTL_VT_DISALLOCATE = VT_DISALLOCATE;
+  unsigned IOCTL_VT_GETSTATE = VT_GETSTATE;
+  unsigned IOCTL_VT_RESIZE = VT_RESIZE;
+  unsigned IOCTL_VT_RESIZEX = VT_RESIZEX;
+  unsigned IOCTL_VT_SENDSIG = VT_SENDSIG;
+#endif // SANITIZER_LINUX
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+  unsigned IOCTL_MTIOCGET = MTIOCGET;
+  unsigned IOCTL_MTIOCTOP = MTIOCTOP;
+  unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE = SNDCTL_DSP_GETBLKSIZE;
+  unsigned IOCTL_SNDCTL_DSP_GETFMTS = SNDCTL_DSP_GETFMTS;
+  unsigned IOCTL_SNDCTL_DSP_NONBLOCK = SNDCTL_DSP_NONBLOCK;
+  unsigned IOCTL_SNDCTL_DSP_POST = SNDCTL_DSP_POST;
+  unsigned IOCTL_SNDCTL_DSP_RESET = SNDCTL_DSP_RESET;
+  unsigned IOCTL_SNDCTL_DSP_SETFMT = SNDCTL_DSP_SETFMT;
+  unsigned IOCTL_SNDCTL_DSP_SETFRAGMENT = SNDCTL_DSP_SETFRAGMENT;
+  unsigned IOCTL_SNDCTL_DSP_SPEED = SNDCTL_DSP_SPEED;
+  unsigned IOCTL_SNDCTL_DSP_STEREO = SNDCTL_DSP_STEREO;
+  unsigned IOCTL_SNDCTL_DSP_SUBDIVIDE = SNDCTL_DSP_SUBDIVIDE;
+  unsigned IOCTL_SNDCTL_DSP_SYNC = SNDCTL_DSP_SYNC;
+  unsigned IOCTL_SNDCTL_FM_4OP_ENABLE = SNDCTL_FM_4OP_ENABLE;
+  unsigned IOCTL_SNDCTL_FM_LOAD_INSTR = SNDCTL_FM_LOAD_INSTR;
+  unsigned IOCTL_SNDCTL_MIDI_INFO = SNDCTL_MIDI_INFO;
+  unsigned IOCTL_SNDCTL_MIDI_PRETIME = SNDCTL_MIDI_PRETIME;
+  unsigned IOCTL_SNDCTL_SEQ_CTRLRATE = SNDCTL_SEQ_CTRLRATE;
+  unsigned IOCTL_SNDCTL_SEQ_GETINCOUNT = SNDCTL_SEQ_GETINCOUNT;
+  unsigned IOCTL_SNDCTL_SEQ_GETOUTCOUNT = SNDCTL_SEQ_GETOUTCOUNT;
+  unsigned IOCTL_SNDCTL_SEQ_NRMIDIS = SNDCTL_SEQ_NRMIDIS;
+  unsigned IOCTL_SNDCTL_SEQ_NRSYNTHS = SNDCTL_SEQ_NRSYNTHS;
+  unsigned IOCTL_SNDCTL_SEQ_OUTOFBAND = SNDCTL_SEQ_OUTOFBAND;
+  unsigned IOCTL_SNDCTL_SEQ_PANIC = SNDCTL_SEQ_PANIC;
+  unsigned IOCTL_SNDCTL_SEQ_PERCMODE = SNDCTL_SEQ_PERCMODE;
+  unsigned IOCTL_SNDCTL_SEQ_RESET = SNDCTL_SEQ_RESET;
+  unsigned IOCTL_SNDCTL_SEQ_RESETSAMPLES = SNDCTL_SEQ_RESETSAMPLES;
+  unsigned IOCTL_SNDCTL_SEQ_SYNC = SNDCTL_SEQ_SYNC;
+  unsigned IOCTL_SNDCTL_SEQ_TESTMIDI = SNDCTL_SEQ_TESTMIDI;
+  unsigned IOCTL_SNDCTL_SEQ_THRESHOLD = SNDCTL_SEQ_THRESHOLD;
+  unsigned IOCTL_SNDCTL_SYNTH_INFO = SNDCTL_SYNTH_INFO;
+  unsigned IOCTL_SNDCTL_SYNTH_MEMAVL = SNDCTL_SYNTH_MEMAVL;
+  unsigned IOCTL_SNDCTL_TMR_CONTINUE = SNDCTL_TMR_CONTINUE;
+  unsigned IOCTL_SNDCTL_TMR_METRONOME = SNDCTL_TMR_METRONOME;
+  unsigned IOCTL_SNDCTL_TMR_SELECT = SNDCTL_TMR_SELECT;
+  unsigned IOCTL_SNDCTL_TMR_SOURCE = SNDCTL_TMR_SOURCE;
+  unsigned IOCTL_SNDCTL_TMR_START = SNDCTL_TMR_START;
+  unsigned IOCTL_SNDCTL_TMR_STOP = SNDCTL_TMR_STOP;
+  unsigned IOCTL_SNDCTL_TMR_TEMPO = SNDCTL_TMR_TEMPO;
+  unsigned IOCTL_SNDCTL_TMR_TIMEBASE = SNDCTL_TMR_TIMEBASE;
+  unsigned IOCTL_SOUND_MIXER_READ_ALTPCM = SOUND_MIXER_READ_ALTPCM;
+  unsigned IOCTL_SOUND_MIXER_READ_BASS = SOUND_MIXER_READ_BASS;
+  unsigned IOCTL_SOUND_MIXER_READ_CAPS = SOUND_MIXER_READ_CAPS;
+  unsigned IOCTL_SOUND_MIXER_READ_CD = SOUND_MIXER_READ_CD;
+  unsigned IOCTL_SOUND_MIXER_READ_DEVMASK = SOUND_MIXER_READ_DEVMASK;
+  unsigned IOCTL_SOUND_MIXER_READ_ENHANCE = SOUND_MIXER_READ_ENHANCE;
+  unsigned IOCTL_SOUND_MIXER_READ_IGAIN = SOUND_MIXER_READ_IGAIN;
+  unsigned IOCTL_SOUND_MIXER_READ_IMIX = SOUND_MIXER_READ_IMIX;
+  unsigned IOCTL_SOUND_MIXER_READ_LINE = SOUND_MIXER_READ_LINE;
+  unsigned IOCTL_SOUND_MIXER_READ_LINE1 = SOUND_MIXER_READ_LINE1;
+  unsigned IOCTL_SOUND_MIXER_READ_LINE2 = SOUND_MIXER_READ_LINE2;
+  unsigned IOCTL_SOUND_MIXER_READ_LINE3 = SOUND_MIXER_READ_LINE3;
+  unsigned IOCTL_SOUND_MIXER_READ_LOUD = SOUND_MIXER_READ_LOUD;
+  unsigned IOCTL_SOUND_MIXER_READ_MIC = SOUND_MIXER_READ_MIC;
+  unsigned IOCTL_SOUND_MIXER_READ_MUTE = SOUND_MIXER_READ_MUTE;
+  unsigned IOCTL_SOUND_MIXER_READ_OGAIN = SOUND_MIXER_READ_OGAIN;
+  unsigned IOCTL_SOUND_MIXER_READ_PCM = SOUND_MIXER_READ_PCM;
+  unsigned IOCTL_SOUND_MIXER_READ_RECLEV = SOUND_MIXER_READ_RECLEV;
+  unsigned IOCTL_SOUND_MIXER_READ_RECMASK = SOUND_MIXER_READ_RECMASK;
+  unsigned IOCTL_SOUND_MIXER_READ_RECSRC = SOUND_MIXER_READ_RECSRC;
+  unsigned IOCTL_SOUND_MIXER_READ_SPEAKER = SOUND_MIXER_READ_SPEAKER;
+  unsigned IOCTL_SOUND_MIXER_READ_STEREODEVS = SOUND_MIXER_READ_STEREODEVS;
+  unsigned IOCTL_SOUND_MIXER_READ_SYNTH = SOUND_MIXER_READ_SYNTH;
+  unsigned IOCTL_SOUND_MIXER_READ_TREBLE = SOUND_MIXER_READ_TREBLE;
+  unsigned IOCTL_SOUND_MIXER_READ_VOLUME = SOUND_MIXER_READ_VOLUME;
+  unsigned IOCTL_SOUND_MIXER_WRITE_ALTPCM = SOUND_MIXER_WRITE_ALTPCM;
+  unsigned IOCTL_SOUND_MIXER_WRITE_BASS = SOUND_MIXER_WRITE_BASS;
+  unsigned IOCTL_SOUND_MIXER_WRITE_CD = SOUND_MIXER_WRITE_CD;
+  unsigned IOCTL_SOUND_MIXER_WRITE_ENHANCE = SOUND_MIXER_WRITE_ENHANCE;
+  unsigned IOCTL_SOUND_MIXER_WRITE_IGAIN = SOUND_MIXER_WRITE_IGAIN;
+  unsigned IOCTL_SOUND_MIXER_WRITE_IMIX = SOUND_MIXER_WRITE_IMIX;
+  unsigned IOCTL_SOUND_MIXER_WRITE_LINE = SOUND_MIXER_WRITE_LINE;
+  unsigned IOCTL_SOUND_MIXER_WRITE_LINE1 = SOUND_MIXER_WRITE_LINE1;
+  unsigned IOCTL_SOUND_MIXER_WRITE_LINE2 = SOUND_MIXER_WRITE_LINE2;
+  unsigned IOCTL_SOUND_MIXER_WRITE_LINE3 = SOUND_MIXER_WRITE_LINE3;
+  unsigned IOCTL_SOUND_MIXER_WRITE_LOUD = SOUND_MIXER_WRITE_LOUD;
+  unsigned IOCTL_SOUND_MIXER_WRITE_MIC = SOUND_MIXER_WRITE_MIC;
+  unsigned IOCTL_SOUND_MIXER_WRITE_MUTE = SOUND_MIXER_WRITE_MUTE;
+  unsigned IOCTL_SOUND_MIXER_WRITE_OGAIN = SOUND_MIXER_WRITE_OGAIN;
+  unsigned IOCTL_SOUND_MIXER_WRITE_PCM = SOUND_MIXER_WRITE_PCM;
+  unsigned IOCTL_SOUND_MIXER_WRITE_RECLEV = SOUND_MIXER_WRITE_RECLEV;
+  unsigned IOCTL_SOUND_MIXER_WRITE_RECSRC = SOUND_MIXER_WRITE_RECSRC;
+  unsigned IOCTL_SOUND_MIXER_WRITE_SPEAKER = SOUND_MIXER_WRITE_SPEAKER;
+  unsigned IOCTL_SOUND_MIXER_WRITE_SYNTH = SOUND_MIXER_WRITE_SYNTH;
+  unsigned IOCTL_SOUND_MIXER_WRITE_TREBLE = SOUND_MIXER_WRITE_TREBLE;
+  unsigned IOCTL_SOUND_MIXER_WRITE_VOLUME = SOUND_MIXER_WRITE_VOLUME;
+  unsigned IOCTL_VT_ACTIVATE = VT_ACTIVATE;
+  unsigned IOCTL_VT_GETMODE = VT_GETMODE;
+  unsigned IOCTL_VT_OPENQRY = VT_OPENQRY;
+  unsigned IOCTL_VT_RELDISP = VT_RELDISP;
+  unsigned IOCTL_VT_SETMODE = VT_SETMODE;
+  unsigned IOCTL_VT_WAITACTIVE = VT_WAITACTIVE;
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  unsigned IOCTL_CYGETDEFTHRESH = CYGETDEFTHRESH;
+  unsigned IOCTL_CYGETDEFTIMEOUT = CYGETDEFTIMEOUT;
+  unsigned IOCTL_CYGETMON = CYGETMON;
+  unsigned IOCTL_CYGETTHRESH = CYGETTHRESH;
+  unsigned IOCTL_CYGETTIMEOUT = CYGETTIMEOUT;
+  unsigned IOCTL_CYSETDEFTHRESH = CYSETDEFTHRESH;
+  unsigned IOCTL_CYSETDEFTIMEOUT = CYSETDEFTIMEOUT;
+  unsigned IOCTL_CYSETTHRESH = CYSETTHRESH;
+  unsigned IOCTL_CYSETTIMEOUT = CYSETTIMEOUT;
+  unsigned IOCTL_EQL_EMANCIPATE = EQL_EMANCIPATE;
+  unsigned IOCTL_EQL_ENSLAVE = EQL_ENSLAVE;
+  unsigned IOCTL_EQL_GETMASTRCFG = EQL_GETMASTRCFG;
+  unsigned IOCTL_EQL_GETSLAVECFG = EQL_GETSLAVECFG;
+  unsigned IOCTL_EQL_SETMASTRCFG = EQL_SETMASTRCFG;
+  unsigned IOCTL_EQL_SETSLAVECFG = EQL_SETSLAVECFG;
+#if EV_VERSION > (0x010000)
+  unsigned IOCTL_EVIOCGKEYCODE_V2 = EVIOCGKEYCODE_V2;
+  unsigned IOCTL_EVIOCGPROP = EVIOCGPROP(0);
+  unsigned IOCTL_EVIOCSKEYCODE_V2 = EVIOCSKEYCODE_V2;
+#else
+  unsigned IOCTL_EVIOCGKEYCODE_V2 = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_EVIOCGPROP = IOCTL_NOT_PRESENT;
+  unsigned IOCTL_EVIOCSKEYCODE_V2 = IOCTL_NOT_PRESENT;
+#endif
+  unsigned IOCTL_FS_IOC_GETFLAGS = FS_IOC_GETFLAGS;
+  unsigned IOCTL_FS_IOC_GETVERSION = FS_IOC_GETVERSION;
+  unsigned IOCTL_FS_IOC_SETFLAGS = FS_IOC_SETFLAGS;
+  unsigned IOCTL_FS_IOC_SETVERSION = FS_IOC_SETVERSION;
+  unsigned IOCTL_GIO_CMAP = GIO_CMAP;
+  unsigned IOCTL_GIO_FONT = GIO_FONT;
+  unsigned IOCTL_GIO_UNIMAP = GIO_UNIMAP;
+  unsigned IOCTL_GIO_UNISCRNMAP = GIO_UNISCRNMAP;
+  unsigned IOCTL_KDADDIO = KDADDIO;
+  unsigned IOCTL_KDDELIO = KDDELIO;
+  unsigned IOCTL_KDGETKEYCODE = KDGETKEYCODE;
+  unsigned IOCTL_KDGKBDIACR = KDGKBDIACR;
+  unsigned IOCTL_KDGKBENT = KDGKBENT;
+  unsigned IOCTL_KDGKBLED = KDGKBLED;
+  unsigned IOCTL_KDGKBMETA = KDGKBMETA;
+  unsigned IOCTL_KDGKBSENT = KDGKBSENT;
+  unsigned IOCTL_KDMAPDISP = KDMAPDISP;
+  unsigned IOCTL_KDSETKEYCODE = KDSETKEYCODE;
+  unsigned IOCTL_KDSIGACCEPT = KDSIGACCEPT;
+  unsigned IOCTL_KDSKBDIACR = KDSKBDIACR;
+  unsigned IOCTL_KDSKBENT = KDSKBENT;
+  unsigned IOCTL_KDSKBLED = KDSKBLED;
+  unsigned IOCTL_KDSKBMETA = KDSKBMETA;
+  unsigned IOCTL_KDSKBSENT = KDSKBSENT;
+  unsigned IOCTL_KDUNMAPDISP = KDUNMAPDISP;
+  unsigned IOCTL_LPABORT = LPABORT;
+  unsigned IOCTL_LPABORTOPEN = LPABORTOPEN;
+  unsigned IOCTL_LPCAREFUL = LPCAREFUL;
+  unsigned IOCTL_LPCHAR = LPCHAR;
+  unsigned IOCTL_LPGETIRQ = LPGETIRQ;
+  unsigned IOCTL_LPGETSTATUS = LPGETSTATUS;
+  unsigned IOCTL_LPRESET = LPRESET;
+  unsigned IOCTL_LPSETIRQ = LPSETIRQ;
+  unsigned IOCTL_LPTIME = LPTIME;
+  unsigned IOCTL_LPWAIT = LPWAIT;
+  unsigned IOCTL_MTIOCGETCONFIG = MTIOCGETCONFIG;
+  unsigned IOCTL_MTIOCSETCONFIG = MTIOCSETCONFIG;
+  unsigned IOCTL_PIO_CMAP = PIO_CMAP;
+  unsigned IOCTL_PIO_FONT = PIO_FONT;
+  unsigned IOCTL_PIO_UNIMAP = PIO_UNIMAP;
+  unsigned IOCTL_PIO_UNIMAPCLR = PIO_UNIMAPCLR;
+  unsigned IOCTL_PIO_UNISCRNMAP = PIO_UNISCRNMAP;
+  unsigned IOCTL_SCSI_IOCTL_GET_IDLUN = SCSI_IOCTL_GET_IDLUN;
+  unsigned IOCTL_SCSI_IOCTL_PROBE_HOST = SCSI_IOCTL_PROBE_HOST;
+  unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE = SCSI_IOCTL_TAGGED_DISABLE;
+  unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE = SCSI_IOCTL_TAGGED_ENABLE;
+  unsigned IOCTL_SIOCAIPXITFCRT = SIOCAIPXITFCRT;
+  unsigned IOCTL_SIOCAIPXPRISLT = SIOCAIPXPRISLT;
+  unsigned IOCTL_SIOCAX25ADDUID = SIOCAX25ADDUID;
+  unsigned IOCTL_SIOCAX25DELUID = SIOCAX25DELUID;
+  unsigned IOCTL_SIOCAX25GETPARMS = SIOCAX25GETPARMS;
+  unsigned IOCTL_SIOCAX25GETUID = SIOCAX25GETUID;
+  unsigned IOCTL_SIOCAX25NOUID = SIOCAX25NOUID;
+  unsigned IOCTL_SIOCAX25SETPARMS = SIOCAX25SETPARMS;
+  unsigned IOCTL_SIOCDEVPLIP = SIOCDEVPLIP;
+  unsigned IOCTL_SIOCIPXCFGDATA = SIOCIPXCFGDATA;
+  unsigned IOCTL_SIOCNRDECOBS = SIOCNRDECOBS;
+  unsigned IOCTL_SIOCNRGETPARMS = SIOCNRGETPARMS;
+  unsigned IOCTL_SIOCNRRTCTL = SIOCNRRTCTL;
+  unsigned IOCTL_SIOCNRSETPARMS = SIOCNRSETPARMS;
+  unsigned IOCTL_TIOCGSERIAL = TIOCGSERIAL;
+  unsigned IOCTL_TIOCSERGETMULTI = TIOCSERGETMULTI;
+  unsigned IOCTL_TIOCSERSETMULTI = TIOCSERSETMULTI;
+  unsigned IOCTL_TIOCSSERIAL = TIOCSSERIAL;
+#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  unsigned IOCTL_GIO_SCRNMAP = GIO_SCRNMAP;
+  unsigned IOCTL_KDDISABIO = KDDISABIO;
+  unsigned IOCTL_KDENABIO = KDENABIO;
+  unsigned IOCTL_KDGETLED = KDGETLED;
+  unsigned IOCTL_KDGETMODE = KDGETMODE;
+  unsigned IOCTL_KDGKBMODE = KDGKBMODE;
+  unsigned IOCTL_KDGKBTYPE = KDGKBTYPE;
+  unsigned IOCTL_KDMKTONE = KDMKTONE;
+  unsigned IOCTL_KDSETLED = KDSETLED;
+  unsigned IOCTL_KDSETMODE = KDSETMODE;
+  unsigned IOCTL_KDSKBMODE = KDSKBMODE;
+  unsigned IOCTL_KIOCSOUND = KIOCSOUND;
+  unsigned IOCTL_PIO_SCRNMAP = PIO_SCRNMAP;
+  unsigned IOCTL_SNDCTL_DSP_GETISPACE = SNDCTL_DSP_GETISPACE;
+  unsigned IOCTL_SNDCTL_DSP_GETOSPACE = SNDCTL_DSP_GETOSPACE;
+#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+
+  const int errno_EINVAL = EINVAL;
+// EOWNERDEAD is not present in some older platforms.
+#if defined(EOWNERDEAD)
+  const int errno_EOWNERDEAD = EOWNERDEAD;
+#else
+  const int errno_EOWNERDEAD = -1;
+#endif
+
+  const int si_SEGV_MAPERR = SEGV_MAPERR;
+  const int si_SEGV_ACCERR = SEGV_ACCERR;
+} // namespace __sanitizer
+
+COMPILER_CHECK(sizeof(__sanitizer_pthread_attr_t) >= sizeof(pthread_attr_t));
+
+COMPILER_CHECK(sizeof(socklen_t) == sizeof(unsigned));
+CHECK_TYPE_SIZE(pthread_key_t);
+
+#if SANITIZER_LINUX
+// FIXME: We define those on Linux and Mac, but only check on Linux.
+COMPILER_CHECK(IOC_NRBITS == _IOC_NRBITS);
+COMPILER_CHECK(IOC_TYPEBITS == _IOC_TYPEBITS);
+COMPILER_CHECK(IOC_SIZEBITS == _IOC_SIZEBITS);
+COMPILER_CHECK(IOC_DIRBITS == _IOC_DIRBITS);
+COMPILER_CHECK(IOC_NRMASK == _IOC_NRMASK);
+COMPILER_CHECK(IOC_TYPEMASK == _IOC_TYPEMASK);
+COMPILER_CHECK(IOC_SIZEMASK == _IOC_SIZEMASK);
+COMPILER_CHECK(IOC_DIRMASK == _IOC_DIRMASK);
+COMPILER_CHECK(IOC_NRSHIFT == _IOC_NRSHIFT);
+COMPILER_CHECK(IOC_TYPESHIFT == _IOC_TYPESHIFT);
+COMPILER_CHECK(IOC_SIZESHIFT == _IOC_SIZESHIFT);
+COMPILER_CHECK(IOC_DIRSHIFT == _IOC_DIRSHIFT);
+COMPILER_CHECK(IOC_NONE == _IOC_NONE);
+COMPILER_CHECK(IOC_WRITE == _IOC_WRITE);
+COMPILER_CHECK(IOC_READ == _IOC_READ);
+COMPILER_CHECK(EVIOC_ABS_MAX == ABS_MAX);
+COMPILER_CHECK(EVIOC_EV_MAX == EV_MAX);
+COMPILER_CHECK(IOC_SIZE(0x12345678) == _IOC_SIZE(0x12345678));
+COMPILER_CHECK(IOC_DIR(0x12345678) == _IOC_DIR(0x12345678));
+COMPILER_CHECK(IOC_NR(0x12345678) == _IOC_NR(0x12345678));
+COMPILER_CHECK(IOC_TYPE(0x12345678) == _IOC_TYPE(0x12345678));
+#endif // SANITIZER_LINUX
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+// There are more undocumented fields in dl_phdr_info that we are not interested
+// in.
+COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info));
+CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr);
+CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name);
+CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr);
+CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum);
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+CHECK_TYPE_SIZE(glob_t);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_offs);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_flags);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_lstat);
+CHECK_SIZE_AND_OFFSET(glob_t, gl_stat);
+#endif
+
+CHECK_TYPE_SIZE(addrinfo);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_flags);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_family);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_socktype);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_addrlen);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_canonname);
+CHECK_SIZE_AND_OFFSET(addrinfo, ai_addr);
+
+CHECK_TYPE_SIZE(hostent);
+CHECK_SIZE_AND_OFFSET(hostent, h_name);
+CHECK_SIZE_AND_OFFSET(hostent, h_aliases);
+CHECK_SIZE_AND_OFFSET(hostent, h_addrtype);
+CHECK_SIZE_AND_OFFSET(hostent, h_length);
+CHECK_SIZE_AND_OFFSET(hostent, h_addr_list);
+
+CHECK_TYPE_SIZE(iovec);
+CHECK_SIZE_AND_OFFSET(iovec, iov_base);
+CHECK_SIZE_AND_OFFSET(iovec, iov_len);
+
+CHECK_TYPE_SIZE(msghdr);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_name);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_iov);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_iovlen);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_control);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_controllen);
+CHECK_SIZE_AND_OFFSET(msghdr, msg_flags);
+
+CHECK_TYPE_SIZE(cmsghdr);
+CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len);
+CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level);
+CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type);
+
+COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
+CHECK_SIZE_AND_OFFSET(dirent, d_ino);
+#if SANITIZER_MAC
+CHECK_SIZE_AND_OFFSET(dirent, d_seekoff);
+#elif SANITIZER_FREEBSD
+// There is no 'd_off' field on FreeBSD.
+#else
+CHECK_SIZE_AND_OFFSET(dirent, d_off);
+#endif
+CHECK_SIZE_AND_OFFSET(dirent, d_reclen);
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+COMPILER_CHECK(sizeof(__sanitizer_dirent64) <= sizeof(dirent64));
+CHECK_SIZE_AND_OFFSET(dirent64, d_ino);
+CHECK_SIZE_AND_OFFSET(dirent64, d_off);
+CHECK_SIZE_AND_OFFSET(dirent64, d_reclen);
+#endif
+
+CHECK_TYPE_SIZE(ifconf);
+CHECK_SIZE_AND_OFFSET(ifconf, ifc_len);
+CHECK_SIZE_AND_OFFSET(ifconf, ifc_ifcu);
+
+CHECK_TYPE_SIZE(pollfd);
+CHECK_SIZE_AND_OFFSET(pollfd, fd);
+CHECK_SIZE_AND_OFFSET(pollfd, events);
+CHECK_SIZE_AND_OFFSET(pollfd, revents);
+
+CHECK_TYPE_SIZE(nfds_t);
+
+CHECK_TYPE_SIZE(sigset_t);
+
+COMPILER_CHECK(sizeof(__sanitizer_sigaction) == sizeof(struct sigaction));
+// Can't write checks for sa_handler and sa_sigaction due to them being
+// preprocessor macros.
+CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_mask);
+CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_flags);
+#if SANITIZER_LINUX && (!SANITIZER_ANDROID || !SANITIZER_MIPS32)
+CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_restorer);
+#endif
+
+#if SANITIZER_LINUX
+CHECK_TYPE_SIZE(__sysctl_args);
+CHECK_SIZE_AND_OFFSET(__sysctl_args, name);
+CHECK_SIZE_AND_OFFSET(__sysctl_args, nlen);
+CHECK_SIZE_AND_OFFSET(__sysctl_args, oldval);
+CHECK_SIZE_AND_OFFSET(__sysctl_args, oldlenp);
+CHECK_SIZE_AND_OFFSET(__sysctl_args, newval);
+CHECK_SIZE_AND_OFFSET(__sysctl_args, newlen);
+
+CHECK_TYPE_SIZE(__kernel_uid_t);
+CHECK_TYPE_SIZE(__kernel_gid_t);
+
+#if SANITIZER_USES_UID16_SYSCALLS
+CHECK_TYPE_SIZE(__kernel_old_uid_t);
+CHECK_TYPE_SIZE(__kernel_old_gid_t);
+#endif
+
+CHECK_TYPE_SIZE(__kernel_off_t);
+CHECK_TYPE_SIZE(__kernel_loff_t);
+CHECK_TYPE_SIZE(__kernel_fd_set);
+#endif
+
+#if !SANITIZER_ANDROID
+CHECK_TYPE_SIZE(wordexp_t);
+CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordc);
+CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordv);
+CHECK_SIZE_AND_OFFSET(wordexp_t, we_offs);
+#endif
+
+CHECK_TYPE_SIZE(tm);
+CHECK_SIZE_AND_OFFSET(tm, tm_sec);
+CHECK_SIZE_AND_OFFSET(tm, tm_min);
+CHECK_SIZE_AND_OFFSET(tm, tm_hour);
+CHECK_SIZE_AND_OFFSET(tm, tm_mday);
+CHECK_SIZE_AND_OFFSET(tm, tm_mon);
+CHECK_SIZE_AND_OFFSET(tm, tm_year);
+CHECK_SIZE_AND_OFFSET(tm, tm_wday);
+CHECK_SIZE_AND_OFFSET(tm, tm_yday);
+CHECK_SIZE_AND_OFFSET(tm, tm_isdst);
+CHECK_SIZE_AND_OFFSET(tm, tm_gmtoff);
+CHECK_SIZE_AND_OFFSET(tm, tm_zone);
+
+#if SANITIZER_LINUX
+CHECK_TYPE_SIZE(mntent);
+CHECK_SIZE_AND_OFFSET(mntent, mnt_fsname);
+CHECK_SIZE_AND_OFFSET(mntent, mnt_dir);
+CHECK_SIZE_AND_OFFSET(mntent, mnt_type);
+CHECK_SIZE_AND_OFFSET(mntent, mnt_opts);
+CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
+CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
+#endif
+
+CHECK_TYPE_SIZE(ether_addr);
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+CHECK_TYPE_SIZE(ipc_perm);
+# if SANITIZER_FREEBSD
+CHECK_SIZE_AND_OFFSET(ipc_perm, key);
+CHECK_SIZE_AND_OFFSET(ipc_perm, seq);
+# else
+CHECK_SIZE_AND_OFFSET(ipc_perm, __key);
+CHECK_SIZE_AND_OFFSET(ipc_perm, __seq);
+# endif
+CHECK_SIZE_AND_OFFSET(ipc_perm, uid);
+CHECK_SIZE_AND_OFFSET(ipc_perm, gid);
+CHECK_SIZE_AND_OFFSET(ipc_perm, cuid);
+CHECK_SIZE_AND_OFFSET(ipc_perm, cgid);
+#ifndef __GLIBC_PREREQ
+#define __GLIBC_PREREQ(x, y) 0
+#endif
+#if !defined(__aarch64__) || !SANITIZER_LINUX || __GLIBC_PREREQ (2, 21)
+/* On aarch64 glibc 2.20 and earlier provided incorrect mode field.  */
+CHECK_SIZE_AND_OFFSET(ipc_perm, mode);
+#endif
+
+CHECK_TYPE_SIZE(shmid_ds);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_perm);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_segsz);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_atime);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_dtime);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_ctime);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_cpid);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_lpid);
+CHECK_SIZE_AND_OFFSET(shmid_ds, shm_nattch);
+#endif
+
+CHECK_TYPE_SIZE(clock_t);
+
+#if SANITIZER_LINUX
+CHECK_TYPE_SIZE(clockid_t);
+#endif
+
+#if !SANITIZER_ANDROID
+CHECK_TYPE_SIZE(ifaddrs);
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_next);
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_name);
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_addr);
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_netmask);
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+// Compare against the union, because we can't reach into the union in a
+// compliant way.
+#ifdef ifa_dstaddr
+#undef ifa_dstaddr
+#endif
+# if SANITIZER_FREEBSD
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
+# else
+COMPILER_CHECK(sizeof(((__sanitizer_ifaddrs *)nullptr)->ifa_dstaddr) ==
+               sizeof(((ifaddrs *)nullptr)->ifa_ifu));
+COMPILER_CHECK(offsetof(__sanitizer_ifaddrs, ifa_dstaddr) ==
+               offsetof(ifaddrs, ifa_ifu));
+# endif // SANITIZER_FREEBSD
+#else
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
+#endif // SANITIZER_LINUX
+CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
+#endif
+
+#if SANITIZER_LINUX
+COMPILER_CHECK(sizeof(__sanitizer_mallinfo) == sizeof(struct mallinfo));
+#endif
+
+#if !SANITIZER_ANDROID
+CHECK_TYPE_SIZE(timeb);
+CHECK_SIZE_AND_OFFSET(timeb, time);
+CHECK_SIZE_AND_OFFSET(timeb, millitm);
+CHECK_SIZE_AND_OFFSET(timeb, timezone);
+CHECK_SIZE_AND_OFFSET(timeb, dstflag);
+#endif
+
+CHECK_TYPE_SIZE(passwd);
+CHECK_SIZE_AND_OFFSET(passwd, pw_name);
+CHECK_SIZE_AND_OFFSET(passwd, pw_passwd);
+CHECK_SIZE_AND_OFFSET(passwd, pw_uid);
+CHECK_SIZE_AND_OFFSET(passwd, pw_gid);
+CHECK_SIZE_AND_OFFSET(passwd, pw_dir);
+CHECK_SIZE_AND_OFFSET(passwd, pw_shell);
+
+#if !SANITIZER_ANDROID
+CHECK_SIZE_AND_OFFSET(passwd, pw_gecos);
+#endif
+
+#if SANITIZER_MAC
+CHECK_SIZE_AND_OFFSET(passwd, pw_change);
+CHECK_SIZE_AND_OFFSET(passwd, pw_expire);
+CHECK_SIZE_AND_OFFSET(passwd, pw_class);
+#endif
+
+
+CHECK_TYPE_SIZE(group);
+CHECK_SIZE_AND_OFFSET(group, gr_name);
+CHECK_SIZE_AND_OFFSET(group, gr_passwd);
+CHECK_SIZE_AND_OFFSET(group, gr_gid);
+CHECK_SIZE_AND_OFFSET(group, gr_mem);
+
+#if HAVE_RPC_XDR_H || HAVE_TIRPC_RPC_XDR_H
+CHECK_TYPE_SIZE(XDR);
+CHECK_SIZE_AND_OFFSET(XDR, x_op);
+CHECK_SIZE_AND_OFFSET(XDR, x_ops);
+CHECK_SIZE_AND_OFFSET(XDR, x_public);
+CHECK_SIZE_AND_OFFSET(XDR, x_private);
+CHECK_SIZE_AND_OFFSET(XDR, x_base);
+CHECK_SIZE_AND_OFFSET(XDR, x_handy);
+COMPILER_CHECK(__sanitizer_XDR_ENCODE == XDR_ENCODE);
+COMPILER_CHECK(__sanitizer_XDR_DECODE == XDR_DECODE);
+COMPILER_CHECK(__sanitizer_XDR_FREE == XDR_FREE);
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE));
+CHECK_SIZE_AND_OFFSET(FILE, _flags);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_read_ptr);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_read_end);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_read_base);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_write_ptr);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_write_end);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_write_base);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_base);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_end);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_save_base);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_backup_base);
+CHECK_SIZE_AND_OFFSET(FILE, _IO_save_end);
+CHECK_SIZE_AND_OFFSET(FILE, _markers);
+CHECK_SIZE_AND_OFFSET(FILE, _chain);
+CHECK_SIZE_AND_OFFSET(FILE, _fileno);
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+COMPILER_CHECK(sizeof(__sanitizer__obstack_chunk) <= sizeof(_obstack_chunk));
+CHECK_SIZE_AND_OFFSET(_obstack_chunk, limit);
+CHECK_SIZE_AND_OFFSET(_obstack_chunk, prev);
+CHECK_TYPE_SIZE(obstack);
+CHECK_SIZE_AND_OFFSET(obstack, chunk_size);
+CHECK_SIZE_AND_OFFSET(obstack, chunk);
+CHECK_SIZE_AND_OFFSET(obstack, object_base);
+CHECK_SIZE_AND_OFFSET(obstack, next_free);
+
+CHECK_TYPE_SIZE(cookie_io_functions_t);
+CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, read);
+CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, write);
+CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, seek);
+CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, close);
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+CHECK_TYPE_SIZE(sem_t);
+#endif
+
+#if SANITIZER_LINUX && defined(__arm__)
+COMPILER_CHECK(ARM_VFPREGS_SIZE == ARM_VFPREGS_SIZE_ASAN);
+#endif
+
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h b/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
new file mode 100644
index 0000000..af33a45
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
@@ -0,0 +1,1381 @@
+//===-- sanitizer_platform_limits_posix.h ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer common code.
+//
+// Sizes and layouts of platform-specific POSIX data structures.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H
+#define SANITIZER_PLATFORM_LIMITS_POSIX_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_platform.h"
+
+#if SANITIZER_FREEBSD
+// FreeBSD's dlopen() returns a pointer to an Obj_Entry structure that
+// incroporates the map structure.
+# define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
+    ((link_map*)((handle) == nullptr ? nullptr : ((char*)(handle) + 544)))
+#else
+# define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map*)(handle))
+#endif  // !SANITIZER_FREEBSD
+
+namespace __sanitizer {
+  extern unsigned struct_utsname_sz;
+  extern unsigned struct_stat_sz;
+#if !SANITIZER_FREEBSD && !SANITIZER_IOS
+  extern unsigned struct_stat64_sz;
+#endif
+  extern unsigned struct_rusage_sz;
+  extern unsigned siginfo_t_sz;
+  extern unsigned struct_itimerval_sz;
+  extern unsigned pthread_t_sz;
+  extern unsigned pthread_cond_t_sz;
+  extern unsigned pid_t_sz;
+  extern unsigned timeval_sz;
+  extern unsigned uid_t_sz;
+  extern unsigned gid_t_sz;
+  extern unsigned mbstate_t_sz;
+  extern unsigned struct_timezone_sz;
+  extern unsigned struct_tms_sz;
+  extern unsigned struct_itimerspec_sz;
+  extern unsigned struct_sigevent_sz;
+  extern unsigned struct_sched_param_sz;
+  extern unsigned struct_statfs64_sz;
+
+#if !SANITIZER_ANDROID
+  extern unsigned struct_statfs_sz;
+  extern unsigned struct_sockaddr_sz;
+  extern unsigned ucontext_t_sz;
+#endif // !SANITIZER_ANDROID
+
+#if SANITIZER_LINUX
+
+#if defined(__x86_64__)
+  const unsigned struct_kernel_stat_sz = 144;
+  const unsigned struct_kernel_stat64_sz = 0;
+#elif defined(__i386__)
+  const unsigned struct_kernel_stat_sz = 64;
+  const unsigned struct_kernel_stat64_sz = 96;
+#elif defined(__arm__)
+  const unsigned struct_kernel_stat_sz = 64;
+  const unsigned struct_kernel_stat64_sz = 104;
+#elif defined(__aarch64__)
+  const unsigned struct_kernel_stat_sz = 128;
+  const unsigned struct_kernel_stat64_sz = 104;
+#elif defined(__powerpc__) && !defined(__powerpc64__)
+  const unsigned struct_kernel_stat_sz = 72;
+  const unsigned struct_kernel_stat64_sz = 104;
+#elif defined(__powerpc64__)
+  const unsigned struct_kernel_stat_sz = 144;
+  const unsigned struct_kernel_stat64_sz = 104;
+#elif defined(__mips__)
+  const unsigned struct_kernel_stat_sz =
+                 SANITIZER_ANDROID ? FIRST_32_SECOND_64(104, 128) :
+                                     FIRST_32_SECOND_64(144, 216);
+  const unsigned struct_kernel_stat64_sz = 104;
+#endif
+  struct __sanitizer_perf_event_attr {
+    unsigned type;
+    unsigned size;
+    // More fields that vary with the kernel version.
+  };
+
+  extern unsigned struct_epoll_event_sz;
+  extern unsigned struct_sysinfo_sz;
+  extern unsigned __user_cap_header_struct_sz;
+  extern unsigned __user_cap_data_struct_sz;
+  extern unsigned struct_new_utsname_sz;
+  extern unsigned struct_old_utsname_sz;
+  extern unsigned struct_oldold_utsname_sz;
+
+  const unsigned struct_kexec_segment_sz = 4 * sizeof(unsigned long);
+#endif  // SANITIZER_LINUX
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if defined(__powerpc64__)
+  const unsigned struct___old_kernel_stat_sz = 0;
+#else
+  const unsigned struct___old_kernel_stat_sz = 32;
+#endif
+
+  extern unsigned struct_rlimit_sz;
+  extern unsigned struct_utimbuf_sz;
+  extern unsigned struct_timespec_sz;
+
+  struct __sanitizer_iocb {
+    u64   aio_data;
+    u32   aio_key_or_aio_reserved1; // Simply crazy.
+    u32   aio_reserved1_or_aio_key; // Luckily, we don't need these.
+    u16   aio_lio_opcode;
+    s16   aio_reqprio;
+    u32   aio_fildes;
+    u64   aio_buf;
+    u64   aio_nbytes;
+    s64   aio_offset;
+    u64   aio_reserved2;
+    u64   aio_reserved3;
+  };
+
+  struct __sanitizer_io_event {
+    u64 data;
+    u64 obj;
+    u64 res;
+    u64 res2;
+  };
+
+  const unsigned iocb_cmd_pread = 0;
+  const unsigned iocb_cmd_pwrite = 1;
+  const unsigned iocb_cmd_preadv = 7;
+  const unsigned iocb_cmd_pwritev = 8;
+
+  struct __sanitizer___sysctl_args {
+    int *name;
+    int nlen;
+    void *oldval;
+    uptr *oldlenp;
+    void *newval;
+    uptr newlen;
+    unsigned long ___unused[4];
+  };
+
+  const unsigned old_sigset_t_sz = sizeof(unsigned long);
+
+  struct __sanitizer_sem_t {
+#if SANITIZER_ANDROID && defined(_LP64)
+    int data[4];
+#elif SANITIZER_ANDROID && !defined(_LP64)
+    int data;
+#elif SANITIZER_LINUX
+    uptr data[4];
+#elif SANITIZER_FREEBSD
+    u32 data[4];
+#endif
+  };
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_ANDROID
+  struct __sanitizer_mallinfo {
+    uptr v[10];
+  };
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  struct __sanitizer_mallinfo {
+    int v[10];
+  };
+
+  extern unsigned struct_ustat_sz;
+  extern unsigned struct_rlimit64_sz;
+  extern unsigned struct_statvfs64_sz;
+
+  struct __sanitizer_ipc_perm {
+    int __key;
+    int uid;
+    int gid;
+    int cuid;
+    int cgid;
+#ifdef __powerpc__
+    unsigned mode;
+    unsigned __seq;
+    u64 __unused1;
+    u64 __unused2;
+#elif defined(__mips__) || defined(__aarch64__)
+    unsigned int mode;
+    unsigned short __seq;
+    unsigned short __pad1;
+    unsigned long __unused1;
+    unsigned long __unused2;
+#else
+    unsigned short mode;
+    unsigned short __pad1;
+    unsigned short __seq;
+    unsigned short __pad2;
+#if defined(__x86_64__) && !defined(_LP64)
+    u64 __unused1;
+    u64 __unused2;
+#else
+    unsigned long __unused1;
+    unsigned long __unused2;
+#endif
+#endif
+  };
+
+  struct __sanitizer_shmid_ds {
+    __sanitizer_ipc_perm shm_perm;
+  #ifndef __powerpc__
+    uptr shm_segsz;
+  #elif !defined(__powerpc64__)
+    uptr __unused0;
+  #endif
+  #if defined(__x86_64__) && !defined(_LP64)
+    u64 shm_atime;
+    u64 shm_dtime;
+    u64 shm_ctime;
+  #else
+    uptr shm_atime;
+  #if !defined(_LP64) && !defined(__mips__)
+    uptr __unused1;
+  #endif
+    uptr shm_dtime;
+  #if !defined(_LP64) && !defined(__mips__)
+    uptr __unused2;
+  #endif
+    uptr shm_ctime;
+  #if !defined(_LP64) && !defined(__mips__)
+    uptr __unused3;
+  #endif
+  #endif
+  #ifdef __powerpc__
+    uptr shm_segsz;
+  #endif
+    int shm_cpid;
+    int shm_lpid;
+  #if defined(__x86_64__) && !defined(_LP64)
+    u64 shm_nattch;
+    u64 __unused4;
+    u64 __unused5;
+  #else
+    uptr shm_nattch;
+    uptr __unused4;
+    uptr __unused5;
+  #endif
+  };
+#elif SANITIZER_FREEBSD
+  struct __sanitizer_ipc_perm {
+    unsigned int cuid;
+    unsigned int cgid;
+    unsigned int uid;
+    unsigned int gid;
+    unsigned short mode;
+    unsigned short seq;
+    long key;
+  };
+
+  struct __sanitizer_shmid_ds {
+    __sanitizer_ipc_perm shm_perm;
+    unsigned long shm_segsz;
+    unsigned int shm_lpid;
+    unsigned int shm_cpid;
+    int shm_nattch;
+    unsigned long shm_atime;
+    unsigned long shm_dtime;
+    unsigned long shm_ctime;
+  };
+#endif
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  extern unsigned struct_msqid_ds_sz;
+  extern unsigned struct_mq_attr_sz;
+  extern unsigned struct_timex_sz;
+  extern unsigned struct_statvfs_sz;
+#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+
+  struct __sanitizer_iovec {
+    void *iov_base;
+    uptr iov_len;
+  };
+
+#if !SANITIZER_ANDROID
+  struct __sanitizer_ifaddrs {
+    struct __sanitizer_ifaddrs *ifa_next;
+    char *ifa_name;
+    unsigned int ifa_flags;
+    void *ifa_addr;    // (struct sockaddr *)
+    void *ifa_netmask; // (struct sockaddr *)
+    // This is a union on Linux.
+# ifdef ifa_dstaddr
+# undef ifa_dstaddr
+# endif
+    void *ifa_dstaddr; // (struct sockaddr *)
+    void *ifa_data;
+  };
+#endif  // !SANITIZER_ANDROID
+
+#if SANITIZER_MAC
+  typedef unsigned long __sanitizer_pthread_key_t;
+#else
+  typedef unsigned __sanitizer_pthread_key_t;
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+
+  struct __sanitizer_XDR {
+    int x_op;
+    void *x_ops;
+    uptr x_public;
+    uptr x_private;
+    uptr x_base;
+    unsigned x_handy;
+  };
+
+  const int __sanitizer_XDR_ENCODE = 0;
+  const int __sanitizer_XDR_DECODE = 1;
+  const int __sanitizer_XDR_FREE = 2;
+#endif
+
+  struct __sanitizer_passwd {
+    char *pw_name;
+    char *pw_passwd;
+    int pw_uid;
+    int pw_gid;
+#if SANITIZER_MAC || SANITIZER_FREEBSD
+    long pw_change;
+    char *pw_class;
+#endif
+#if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32))
+    char *pw_gecos;
+#endif
+    char *pw_dir;
+    char *pw_shell;
+#if SANITIZER_MAC || SANITIZER_FREEBSD
+    long pw_expire;
+#endif
+#if SANITIZER_FREEBSD
+    int pw_fields;
+#endif
+  };
+
+  struct __sanitizer_group {
+    char *gr_name;
+    char *gr_passwd;
+    int gr_gid;
+    char **gr_mem;
+  };
+
+#if defined(__x86_64__) && !defined(_LP64)
+  typedef long long __sanitizer_time_t;
+#else
+  typedef long __sanitizer_time_t;
+#endif
+
+  struct __sanitizer_timeb {
+    __sanitizer_time_t time;
+    unsigned short millitm;
+    short timezone;
+    short dstflag;
+  };
+
+  struct __sanitizer_ether_addr {
+    u8 octet[6];
+  };
+
+  struct __sanitizer_tm {
+    int tm_sec;
+    int tm_min;
+    int tm_hour;
+    int tm_mday;
+    int tm_mon;
+    int tm_year;
+    int tm_wday;
+    int tm_yday;
+    int tm_isdst;
+    long int tm_gmtoff;
+    const char *tm_zone;
+  };
+
+#if SANITIZER_LINUX
+  struct __sanitizer_mntent {
+    char *mnt_fsname;
+    char *mnt_dir;
+    char *mnt_type;
+    char *mnt_opts;
+    int mnt_freq;
+    int mnt_passno;
+  };
+#endif
+
+#if SANITIZER_MAC || SANITIZER_FREEBSD
+  struct __sanitizer_msghdr {
+    void *msg_name;
+    unsigned msg_namelen;
+    struct __sanitizer_iovec *msg_iov;
+    unsigned msg_iovlen;
+    void *msg_control;
+    unsigned msg_controllen;
+    int msg_flags;
+  };
+  struct __sanitizer_cmsghdr {
+    unsigned cmsg_len;
+    int cmsg_level;
+    int cmsg_type;
+  };
+#else
+  struct __sanitizer_msghdr {
+    void *msg_name;
+    unsigned msg_namelen;
+    struct __sanitizer_iovec *msg_iov;
+    uptr msg_iovlen;
+    void *msg_control;
+    uptr msg_controllen;
+    int msg_flags;
+  };
+  struct __sanitizer_cmsghdr {
+    uptr cmsg_len;
+    int cmsg_level;
+    int cmsg_type;
+  };
+#endif
+
+#if SANITIZER_MAC
+  struct __sanitizer_dirent {
+    unsigned long long d_ino;
+    unsigned long long d_seekoff;
+    unsigned short d_reclen;
+    // more fields that we don't care about
+  };
+#elif SANITIZER_FREEBSD
+  struct __sanitizer_dirent {
+    unsigned int d_fileno;
+    unsigned short d_reclen;
+    // more fields that we don't care about
+  };
+#elif SANITIZER_ANDROID || defined(__x86_64__)
+  struct __sanitizer_dirent {
+    unsigned long long d_ino;
+    unsigned long long d_off;
+    unsigned short d_reclen;
+    // more fields that we don't care about
+  };
+#else
+  struct __sanitizer_dirent {
+    uptr d_ino;
+    uptr d_off;
+    unsigned short d_reclen;
+    // more fields that we don't care about
+  };
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  struct __sanitizer_dirent64 {
+    unsigned long long d_ino;
+    unsigned long long d_off;
+    unsigned short d_reclen;
+    // more fields that we don't care about
+  };
+#endif
+
+// 'clock_t' is 32 bits wide on x64 FreeBSD
+#if SANITIZER_FREEBSD
+  typedef int __sanitizer_clock_t;
+#elif defined(__x86_64__) && !defined(_LP64)
+  typedef long long __sanitizer_clock_t;
+#else
+  typedef long __sanitizer_clock_t;
+#endif
+
+#if SANITIZER_LINUX
+  typedef int __sanitizer_clockid_t;
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__)\
+                   || defined(__mips__)
+  typedef unsigned __sanitizer___kernel_uid_t;
+  typedef unsigned __sanitizer___kernel_gid_t;
+#else
+  typedef unsigned short __sanitizer___kernel_uid_t;
+  typedef unsigned short __sanitizer___kernel_gid_t;
+#endif
+#if defined(__x86_64__) && !defined(_LP64)
+  typedef long long __sanitizer___kernel_off_t;
+#else
+  typedef long __sanitizer___kernel_off_t;
+#endif
+
+#if defined(__powerpc__) || defined(__mips__)
+  typedef unsigned int __sanitizer___kernel_old_uid_t;
+  typedef unsigned int __sanitizer___kernel_old_gid_t;
+#else
+  typedef unsigned short __sanitizer___kernel_old_uid_t;
+  typedef unsigned short __sanitizer___kernel_old_gid_t;
+#endif
+
+  typedef long long __sanitizer___kernel_loff_t;
+  typedef struct {
+    unsigned long fds_bits[1024 / (8 * sizeof(long))];
+  } __sanitizer___kernel_fd_set;
+#endif
+
+  // This thing depends on the platform. We are only interested in the upper
+  // limit. Verified with a compiler assert in .cc.
+  const int pthread_attr_t_max_sz = 128;
+  union __sanitizer_pthread_attr_t {
+    char size[pthread_attr_t_max_sz]; // NOLINT
+    void *align;
+  };
+
+#if SANITIZER_ANDROID
+# if SANITIZER_MIPS
+  typedef unsigned long __sanitizer_sigset_t[16/sizeof(unsigned long)];
+# else
+  typedef unsigned long __sanitizer_sigset_t;
+# endif
+#elif SANITIZER_MAC
+  typedef unsigned __sanitizer_sigset_t;
+#elif SANITIZER_LINUX
+  struct __sanitizer_sigset_t {
+    // The size is determined by looking at sizeof of real sigset_t on linux.
+    uptr val[128 / sizeof(uptr)];
+  };
+#elif SANITIZER_FREEBSD
+  struct __sanitizer_sigset_t {
+     // uint32_t * 4
+     unsigned int __bits[4];
+  };
+#endif
+
+  // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
+#if SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 64)
+  struct __sanitizer_sigaction {
+    unsigned sa_flags;
+    union {
+      void (*sigaction)(int sig, void *siginfo, void *uctx);
+      void (*handler)(int sig);
+    };
+    __sanitizer_sigset_t sa_mask;
+    void (*sa_restorer)();
+  };
+#elif SANITIZER_ANDROID && SANITIZER_MIPS32  // check this before WORDSIZE == 32
+  struct __sanitizer_sigaction {
+    unsigned sa_flags;
+    union {
+      void (*sigaction)(int sig, void *siginfo, void *uctx);
+      void (*handler)(int sig);
+    };
+    __sanitizer_sigset_t sa_mask;
+  };
+#elif SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)
+  struct __sanitizer_sigaction {
+    union {
+      void (*sigaction)(int sig, void *siginfo, void *uctx);
+      void (*handler)(int sig);
+    };
+    __sanitizer_sigset_t sa_mask;
+    uptr sa_flags;
+    void (*sa_restorer)();
+  };
+#else // !SANITIZER_ANDROID
+  struct __sanitizer_sigaction {
+#if defined(__mips__) && !SANITIZER_FREEBSD
+    unsigned int sa_flags;
+#endif
+    union {
+      void (*sigaction)(int sig, void *siginfo, void *uctx);
+      void (*handler)(int sig);
+    };
+#if SANITIZER_FREEBSD
+    int sa_flags;
+    __sanitizer_sigset_t sa_mask;
+#else
+    __sanitizer_sigset_t sa_mask;
+#ifndef __mips__
+    int sa_flags;
+#endif
+#endif
+#if SANITIZER_LINUX
+    void (*sa_restorer)();
+#endif
+#if defined(__mips__) && (SANITIZER_WORDSIZE == 32)
+    int sa_resv[1];
+#endif
+  };
+#endif // !SANITIZER_ANDROID
+
+#if SANITIZER_FREEBSD
+  typedef __sanitizer_sigset_t __sanitizer_kernel_sigset_t;
+#elif defined(__mips__)
+  struct __sanitizer_kernel_sigset_t {
+    u8 sig[16];
+  };
+#else
+  struct __sanitizer_kernel_sigset_t {
+    u8 sig[8];
+  };
+#endif
+
+  // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
+  struct __sanitizer_kernel_sigaction_t {
+    union {
+      void (*handler)(int signo);
+      void (*sigaction)(int signo, void *info, void *ctx);
+    };
+    unsigned long sa_flags;
+    void (*sa_restorer)(void);
+    __sanitizer_kernel_sigset_t sa_mask;
+  };
+
+  extern uptr sig_ign;
+  extern uptr sig_dfl;
+  extern uptr sa_siginfo;
+
+#if SANITIZER_LINUX
+  extern int e_tabsz;
+#endif
+
+  extern int af_inet;
+  extern int af_inet6;
+  uptr __sanitizer_in_addr_sz(int af);
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+  struct __sanitizer_dl_phdr_info {
+    uptr dlpi_addr;
+    const char *dlpi_name;
+    const void *dlpi_phdr;
+    short dlpi_phnum;
+  };
+
+  extern unsigned struct_ElfW_Phdr_sz;
+#endif
+
+  struct __sanitizer_addrinfo {
+    int ai_flags;
+    int ai_family;
+    int ai_socktype;
+    int ai_protocol;
+#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD
+    unsigned ai_addrlen;
+    char *ai_canonname;
+    void *ai_addr;
+#else // LINUX
+    unsigned ai_addrlen;
+    void *ai_addr;
+    char *ai_canonname;
+#endif
+    struct __sanitizer_addrinfo *ai_next;
+  };
+
+  struct __sanitizer_hostent {
+    char *h_name;
+    char **h_aliases;
+    int h_addrtype;
+    int h_length;
+    char **h_addr_list;
+  };
+
+  struct __sanitizer_pollfd {
+    int fd;
+    short events;
+    short revents;
+  };
+
+#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD
+  typedef unsigned __sanitizer_nfds_t;
+#else
+  typedef unsigned long __sanitizer_nfds_t;
+#endif
+
+#if !SANITIZER_ANDROID
+# if SANITIZER_LINUX
+  struct __sanitizer_glob_t {
+    uptr gl_pathc;
+    char **gl_pathv;
+    uptr gl_offs;
+    int gl_flags;
+
+    void (*gl_closedir)(void *dirp);
+    void *(*gl_readdir)(void *dirp);
+    void *(*gl_opendir)(const char *);
+    int (*gl_lstat)(const char *, void *);
+    int (*gl_stat)(const char *, void *);
+  };
+# elif SANITIZER_FREEBSD
+  struct __sanitizer_glob_t {
+    uptr gl_pathc;
+    uptr gl_matchc;
+    uptr gl_offs;
+    int gl_flags;
+    char **gl_pathv;
+    int (*gl_errfunc)(const char*, int);
+    void (*gl_closedir)(void *dirp);
+    struct dirent *(*gl_readdir)(void *dirp);
+    void *(*gl_opendir)(const char*);
+    int (*gl_lstat)(const char*, void* /* struct stat* */);
+    int (*gl_stat)(const char*, void* /* struct stat* */);
+  };
+# endif  // SANITIZER_FREEBSD
+
+# if SANITIZER_LINUX || SANITIZER_FREEBSD
+  extern int glob_nomatch;
+  extern int glob_altdirfunc;
+# endif
+#endif  // !SANITIZER_ANDROID
+
+  extern unsigned path_max;
+
+  struct __sanitizer_wordexp_t {
+    uptr we_wordc;
+    char **we_wordv;
+    uptr we_offs;
+#if SANITIZER_FREEBSD
+    char *we_strings;
+    uptr we_nbytes;
+#endif
+  };
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  struct __sanitizer_FILE {
+    int _flags;
+    char *_IO_read_ptr;
+    char *_IO_read_end;
+    char *_IO_read_base;
+    char *_IO_write_base;
+    char *_IO_write_ptr;
+    char *_IO_write_end;
+    char *_IO_buf_base;
+    char *_IO_buf_end;
+    char *_IO_save_base;
+    char *_IO_backup_base;
+    char *_IO_save_end;
+    void *_markers;
+    __sanitizer_FILE *_chain;
+    int _fileno;
+  };
+# define SANITIZER_HAS_STRUCT_FILE 1
+#else
+  typedef void __sanitizer_FILE;
+# define SANITIZER_HAS_STRUCT_FILE 0
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID && \
+  (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
+    defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__))
+  extern unsigned struct_user_regs_struct_sz;
+  extern unsigned struct_user_fpregs_struct_sz;
+  extern unsigned struct_user_fpxregs_struct_sz;
+  extern unsigned struct_user_vfpregs_struct_sz;
+
+  extern int ptrace_peektext;
+  extern int ptrace_peekdata;
+  extern int ptrace_peekuser;
+  extern int ptrace_getregs;
+  extern int ptrace_setregs;
+  extern int ptrace_getfpregs;
+  extern int ptrace_setfpregs;
+  extern int ptrace_getfpxregs;
+  extern int ptrace_setfpxregs;
+  extern int ptrace_getvfpregs;
+  extern int ptrace_setvfpregs;
+  extern int ptrace_getsiginfo;
+  extern int ptrace_setsiginfo;
+  extern int ptrace_getregset;
+  extern int ptrace_setregset;
+  extern int ptrace_geteventmsg;
+#endif
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  extern unsigned struct_shminfo_sz;
+  extern unsigned struct_shm_info_sz;
+  extern int shmctl_ipc_stat;
+  extern int shmctl_ipc_info;
+  extern int shmctl_shm_info;
+  extern int shmctl_shm_stat;
+#endif
+
+  extern int map_fixed;
+
+  // ioctl arguments
+  struct __sanitizer_ifconf {
+    int ifc_len;
+    union {
+      void *ifcu_req;
+    } ifc_ifcu;
+#if SANITIZER_MAC
+  } __attribute__((packed));
+#else
+  };
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+struct __sanitizer__obstack_chunk {
+  char *limit;
+  struct __sanitizer__obstack_chunk *prev;
+};
+
+struct __sanitizer_obstack {
+  long chunk_size;
+  struct __sanitizer__obstack_chunk *chunk;
+  char *object_base;
+  char *next_free;
+  uptr more_fields[7];
+};
+
+typedef uptr (*__sanitizer_cookie_io_read)(void *cookie, char *buf, uptr size);
+typedef uptr (*__sanitizer_cookie_io_write)(void *cookie, const char *buf,
+                                            uptr size);
+typedef int (*__sanitizer_cookie_io_seek)(void *cookie, u64 *offset,
+                                          int whence);
+typedef int (*__sanitizer_cookie_io_close)(void *cookie);
+
+struct __sanitizer_cookie_io_functions_t {
+  __sanitizer_cookie_io_read read;
+  __sanitizer_cookie_io_write write;
+  __sanitizer_cookie_io_seek seek;
+  __sanitizer_cookie_io_close close;
+};
+#endif
+
+#define IOC_NRBITS 8
+#define IOC_TYPEBITS 8
+#if defined(__powerpc__) || defined(__powerpc64__) || defined(__mips__)
+#define IOC_SIZEBITS 13
+#define IOC_DIRBITS 3
+#define IOC_NONE 1U
+#define IOC_WRITE 4U
+#define IOC_READ 2U
+#else
+#define IOC_SIZEBITS 14
+#define IOC_DIRBITS 2
+#define IOC_NONE 0U
+#define IOC_WRITE 1U
+#define IOC_READ 2U
+#endif
+#define IOC_NRMASK ((1 << IOC_NRBITS) - 1)
+#define IOC_TYPEMASK ((1 << IOC_TYPEBITS) - 1)
+#define IOC_SIZEMASK ((1 << IOC_SIZEBITS) - 1)
+#if defined(IOC_DIRMASK)
+#undef IOC_DIRMASK
+#endif
+#define IOC_DIRMASK ((1 << IOC_DIRBITS) - 1)
+#define IOC_NRSHIFT 0
+#define IOC_TYPESHIFT (IOC_NRSHIFT + IOC_NRBITS)
+#define IOC_SIZESHIFT (IOC_TYPESHIFT + IOC_TYPEBITS)
+#define IOC_DIRSHIFT (IOC_SIZESHIFT + IOC_SIZEBITS)
+#define EVIOC_EV_MAX 0x1f
+#define EVIOC_ABS_MAX 0x3f
+
+#define IOC_DIR(nr) (((nr) >> IOC_DIRSHIFT) & IOC_DIRMASK)
+#define IOC_TYPE(nr) (((nr) >> IOC_TYPESHIFT) & IOC_TYPEMASK)
+#define IOC_NR(nr) (((nr) >> IOC_NRSHIFT) & IOC_NRMASK)
+#define IOC_SIZE(nr) (((nr) >> IOC_SIZESHIFT) & IOC_SIZEMASK)
+
+  extern unsigned struct_ifreq_sz;
+  extern unsigned struct_termios_sz;
+  extern unsigned struct_winsize_sz;
+
+#if SANITIZER_LINUX
+  extern unsigned struct_arpreq_sz;
+  extern unsigned struct_cdrom_msf_sz;
+  extern unsigned struct_cdrom_multisession_sz;
+  extern unsigned struct_cdrom_read_audio_sz;
+  extern unsigned struct_cdrom_subchnl_sz;
+  extern unsigned struct_cdrom_ti_sz;
+  extern unsigned struct_cdrom_tocentry_sz;
+  extern unsigned struct_cdrom_tochdr_sz;
+  extern unsigned struct_cdrom_volctrl_sz;
+  extern unsigned struct_ff_effect_sz;
+  extern unsigned struct_floppy_drive_params_sz;
+  extern unsigned struct_floppy_drive_struct_sz;
+  extern unsigned struct_floppy_fdc_state_sz;
+  extern unsigned struct_floppy_max_errors_sz;
+  extern unsigned struct_floppy_raw_cmd_sz;
+  extern unsigned struct_floppy_struct_sz;
+  extern unsigned struct_floppy_write_errors_sz;
+  extern unsigned struct_format_descr_sz;
+  extern unsigned struct_hd_driveid_sz;
+  extern unsigned struct_hd_geometry_sz;
+  extern unsigned struct_input_absinfo_sz;
+  extern unsigned struct_input_id_sz;
+  extern unsigned struct_mtpos_sz;
+  extern unsigned struct_termio_sz;
+  extern unsigned struct_vt_consize_sz;
+  extern unsigned struct_vt_sizes_sz;
+  extern unsigned struct_vt_stat_sz;
+#endif  // SANITIZER_LINUX
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+  extern unsigned struct_copr_buffer_sz;
+  extern unsigned struct_copr_debug_buf_sz;
+  extern unsigned struct_copr_msg_sz;
+  extern unsigned struct_midi_info_sz;
+  extern unsigned struct_mtget_sz;
+  extern unsigned struct_mtop_sz;
+  extern unsigned struct_rtentry_sz;
+  extern unsigned struct_sbi_instrument_sz;
+  extern unsigned struct_seq_event_rec_sz;
+  extern unsigned struct_synth_info_sz;
+  extern unsigned struct_vt_mode_sz;
+#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  extern unsigned struct_ax25_parms_struct_sz;
+  extern unsigned struct_cyclades_monitor_sz;
+  extern unsigned struct_input_keymap_entry_sz;
+  extern unsigned struct_ipx_config_data_sz;
+  extern unsigned struct_kbdiacrs_sz;
+  extern unsigned struct_kbentry_sz;
+  extern unsigned struct_kbkeycode_sz;
+  extern unsigned struct_kbsentry_sz;
+  extern unsigned struct_mtconfiginfo_sz;
+  extern unsigned struct_nr_parms_struct_sz;
+  extern unsigned struct_scc_modem_sz;
+  extern unsigned struct_scc_stat_sz;
+  extern unsigned struct_serial_multiport_struct_sz;
+  extern unsigned struct_serial_struct_sz;
+  extern unsigned struct_sockaddr_ax25_sz;
+  extern unsigned struct_unimapdesc_sz;
+  extern unsigned struct_unimapinit_sz;
+#endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  extern unsigned struct_audio_buf_info_sz;
+  extern unsigned struct_ppp_stats_sz;
+#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+
+#if !SANITIZER_ANDROID && !SANITIZER_MAC
+  extern unsigned struct_sioc_sg_req_sz;
+  extern unsigned struct_sioc_vif_req_sz;
+#endif
+
+  // ioctl request identifiers
+
+  // A special value to mark ioctls that are not present on the target platform,
+  // when it can not be determined without including any system headers.
+  extern const unsigned IOCTL_NOT_PRESENT;
+
+  extern unsigned IOCTL_FIOASYNC;
+  extern unsigned IOCTL_FIOCLEX;
+  extern unsigned IOCTL_FIOGETOWN;
+  extern unsigned IOCTL_FIONBIO;
+  extern unsigned IOCTL_FIONCLEX;
+  extern unsigned IOCTL_FIOSETOWN;
+  extern unsigned IOCTL_SIOCADDMULTI;
+  extern unsigned IOCTL_SIOCATMARK;
+  extern unsigned IOCTL_SIOCDELMULTI;
+  extern unsigned IOCTL_SIOCGIFADDR;
+  extern unsigned IOCTL_SIOCGIFBRDADDR;
+  extern unsigned IOCTL_SIOCGIFCONF;
+  extern unsigned IOCTL_SIOCGIFDSTADDR;
+  extern unsigned IOCTL_SIOCGIFFLAGS;
+  extern unsigned IOCTL_SIOCGIFMETRIC;
+  extern unsigned IOCTL_SIOCGIFMTU;
+  extern unsigned IOCTL_SIOCGIFNETMASK;
+  extern unsigned IOCTL_SIOCGPGRP;
+  extern unsigned IOCTL_SIOCSIFADDR;
+  extern unsigned IOCTL_SIOCSIFBRDADDR;
+  extern unsigned IOCTL_SIOCSIFDSTADDR;
+  extern unsigned IOCTL_SIOCSIFFLAGS;
+  extern unsigned IOCTL_SIOCSIFMETRIC;
+  extern unsigned IOCTL_SIOCSIFMTU;
+  extern unsigned IOCTL_SIOCSIFNETMASK;
+  extern unsigned IOCTL_SIOCSPGRP;
+  extern unsigned IOCTL_TIOCCONS;
+  extern unsigned IOCTL_TIOCEXCL;
+  extern unsigned IOCTL_TIOCGETD;
+  extern unsigned IOCTL_TIOCGPGRP;
+  extern unsigned IOCTL_TIOCGWINSZ;
+  extern unsigned IOCTL_TIOCMBIC;
+  extern unsigned IOCTL_TIOCMBIS;
+  extern unsigned IOCTL_TIOCMGET;
+  extern unsigned IOCTL_TIOCMSET;
+  extern unsigned IOCTL_TIOCNOTTY;
+  extern unsigned IOCTL_TIOCNXCL;
+  extern unsigned IOCTL_TIOCOUTQ;
+  extern unsigned IOCTL_TIOCPKT;
+  extern unsigned IOCTL_TIOCSCTTY;
+  extern unsigned IOCTL_TIOCSETD;
+  extern unsigned IOCTL_TIOCSPGRP;
+  extern unsigned IOCTL_TIOCSTI;
+  extern unsigned IOCTL_TIOCSWINSZ;
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  extern unsigned IOCTL_SIOCGETSGCNT;
+  extern unsigned IOCTL_SIOCGETVIFCNT;
+#endif
+#if SANITIZER_LINUX
+  extern unsigned IOCTL_EVIOCGABS;
+  extern unsigned IOCTL_EVIOCGBIT;
+  extern unsigned IOCTL_EVIOCGEFFECTS;
+  extern unsigned IOCTL_EVIOCGID;
+  extern unsigned IOCTL_EVIOCGKEY;
+  extern unsigned IOCTL_EVIOCGKEYCODE;
+  extern unsigned IOCTL_EVIOCGLED;
+  extern unsigned IOCTL_EVIOCGNAME;
+  extern unsigned IOCTL_EVIOCGPHYS;
+  extern unsigned IOCTL_EVIOCGRAB;
+  extern unsigned IOCTL_EVIOCGREP;
+  extern unsigned IOCTL_EVIOCGSND;
+  extern unsigned IOCTL_EVIOCGSW;
+  extern unsigned IOCTL_EVIOCGUNIQ;
+  extern unsigned IOCTL_EVIOCGVERSION;
+  extern unsigned IOCTL_EVIOCRMFF;
+  extern unsigned IOCTL_EVIOCSABS;
+  extern unsigned IOCTL_EVIOCSFF;
+  extern unsigned IOCTL_EVIOCSKEYCODE;
+  extern unsigned IOCTL_EVIOCSREP;
+  extern unsigned IOCTL_BLKFLSBUF;
+  extern unsigned IOCTL_BLKGETSIZE;
+  extern unsigned IOCTL_BLKRAGET;
+  extern unsigned IOCTL_BLKRASET;
+  extern unsigned IOCTL_BLKROGET;
+  extern unsigned IOCTL_BLKROSET;
+  extern unsigned IOCTL_BLKRRPART;
+  extern unsigned IOCTL_CDROMAUDIOBUFSIZ;
+  extern unsigned IOCTL_CDROMEJECT;
+  extern unsigned IOCTL_CDROMEJECT_SW;
+  extern unsigned IOCTL_CDROMMULTISESSION;
+  extern unsigned IOCTL_CDROMPAUSE;
+  extern unsigned IOCTL_CDROMPLAYMSF;
+  extern unsigned IOCTL_CDROMPLAYTRKIND;
+  extern unsigned IOCTL_CDROMREADAUDIO;
+  extern unsigned IOCTL_CDROMREADCOOKED;
+  extern unsigned IOCTL_CDROMREADMODE1;
+  extern unsigned IOCTL_CDROMREADMODE2;
+  extern unsigned IOCTL_CDROMREADRAW;
+  extern unsigned IOCTL_CDROMREADTOCENTRY;
+  extern unsigned IOCTL_CDROMREADTOCHDR;
+  extern unsigned IOCTL_CDROMRESET;
+  extern unsigned IOCTL_CDROMRESUME;
+  extern unsigned IOCTL_CDROMSEEK;
+  extern unsigned IOCTL_CDROMSTART;
+  extern unsigned IOCTL_CDROMSTOP;
+  extern unsigned IOCTL_CDROMSUBCHNL;
+  extern unsigned IOCTL_CDROMVOLCTRL;
+  extern unsigned IOCTL_CDROMVOLREAD;
+  extern unsigned IOCTL_CDROM_GET_UPC;
+  extern unsigned IOCTL_FDCLRPRM;
+  extern unsigned IOCTL_FDDEFPRM;
+  extern unsigned IOCTL_FDFLUSH;
+  extern unsigned IOCTL_FDFMTBEG;
+  extern unsigned IOCTL_FDFMTEND;
+  extern unsigned IOCTL_FDFMTTRK;
+  extern unsigned IOCTL_FDGETDRVPRM;
+  extern unsigned IOCTL_FDGETDRVSTAT;
+  extern unsigned IOCTL_FDGETDRVTYP;
+  extern unsigned IOCTL_FDGETFDCSTAT;
+  extern unsigned IOCTL_FDGETMAXERRS;
+  extern unsigned IOCTL_FDGETPRM;
+  extern unsigned IOCTL_FDMSGOFF;
+  extern unsigned IOCTL_FDMSGON;
+  extern unsigned IOCTL_FDPOLLDRVSTAT;
+  extern unsigned IOCTL_FDRAWCMD;
+  extern unsigned IOCTL_FDRESET;
+  extern unsigned IOCTL_FDSETDRVPRM;
+  extern unsigned IOCTL_FDSETEMSGTRESH;
+  extern unsigned IOCTL_FDSETMAXERRS;
+  extern unsigned IOCTL_FDSETPRM;
+  extern unsigned IOCTL_FDTWADDLE;
+  extern unsigned IOCTL_FDWERRORCLR;
+  extern unsigned IOCTL_FDWERRORGET;
+  extern unsigned IOCTL_HDIO_DRIVE_CMD;
+  extern unsigned IOCTL_HDIO_GETGEO;
+  extern unsigned IOCTL_HDIO_GET_32BIT;
+  extern unsigned IOCTL_HDIO_GET_DMA;
+  extern unsigned IOCTL_HDIO_GET_IDENTITY;
+  extern unsigned IOCTL_HDIO_GET_KEEPSETTINGS;
+  extern unsigned IOCTL_HDIO_GET_MULTCOUNT;
+  extern unsigned IOCTL_HDIO_GET_NOWERR;
+  extern unsigned IOCTL_HDIO_GET_UNMASKINTR;
+  extern unsigned IOCTL_HDIO_SET_32BIT;
+  extern unsigned IOCTL_HDIO_SET_DMA;
+  extern unsigned IOCTL_HDIO_SET_KEEPSETTINGS;
+  extern unsigned IOCTL_HDIO_SET_MULTCOUNT;
+  extern unsigned IOCTL_HDIO_SET_NOWERR;
+  extern unsigned IOCTL_HDIO_SET_UNMASKINTR;
+  extern unsigned IOCTL_MTIOCPOS;
+  extern unsigned IOCTL_PPPIOCGASYNCMAP;
+  extern unsigned IOCTL_PPPIOCGDEBUG;
+  extern unsigned IOCTL_PPPIOCGFLAGS;
+  extern unsigned IOCTL_PPPIOCGUNIT;
+  extern unsigned IOCTL_PPPIOCGXASYNCMAP;
+  extern unsigned IOCTL_PPPIOCSASYNCMAP;
+  extern unsigned IOCTL_PPPIOCSDEBUG;
+  extern unsigned IOCTL_PPPIOCSFLAGS;
+  extern unsigned IOCTL_PPPIOCSMAXCID;
+  extern unsigned IOCTL_PPPIOCSMRU;
+  extern unsigned IOCTL_PPPIOCSXASYNCMAP;
+  extern unsigned IOCTL_SIOCDARP;
+  extern unsigned IOCTL_SIOCDRARP;
+  extern unsigned IOCTL_SIOCGARP;
+  extern unsigned IOCTL_SIOCGIFENCAP;
+  extern unsigned IOCTL_SIOCGIFHWADDR;
+  extern unsigned IOCTL_SIOCGIFMAP;
+  extern unsigned IOCTL_SIOCGIFMEM;
+  extern unsigned IOCTL_SIOCGIFNAME;
+  extern unsigned IOCTL_SIOCGIFSLAVE;
+  extern unsigned IOCTL_SIOCGRARP;
+  extern unsigned IOCTL_SIOCGSTAMP;
+  extern unsigned IOCTL_SIOCSARP;
+  extern unsigned IOCTL_SIOCSIFENCAP;
+  extern unsigned IOCTL_SIOCSIFHWADDR;
+  extern unsigned IOCTL_SIOCSIFLINK;
+  extern unsigned IOCTL_SIOCSIFMAP;
+  extern unsigned IOCTL_SIOCSIFMEM;
+  extern unsigned IOCTL_SIOCSIFSLAVE;
+  extern unsigned IOCTL_SIOCSRARP;
+  extern unsigned IOCTL_SNDCTL_COPR_HALT;
+  extern unsigned IOCTL_SNDCTL_COPR_LOAD;
+  extern unsigned IOCTL_SNDCTL_COPR_RCODE;
+  extern unsigned IOCTL_SNDCTL_COPR_RCVMSG;
+  extern unsigned IOCTL_SNDCTL_COPR_RDATA;
+  extern unsigned IOCTL_SNDCTL_COPR_RESET;
+  extern unsigned IOCTL_SNDCTL_COPR_RUN;
+  extern unsigned IOCTL_SNDCTL_COPR_SENDMSG;
+  extern unsigned IOCTL_SNDCTL_COPR_WCODE;
+  extern unsigned IOCTL_SNDCTL_COPR_WDATA;
+  extern unsigned IOCTL_TCFLSH;
+  extern unsigned IOCTL_TCGETA;
+  extern unsigned IOCTL_TCGETS;
+  extern unsigned IOCTL_TCSBRK;
+  extern unsigned IOCTL_TCSBRKP;
+  extern unsigned IOCTL_TCSETA;
+  extern unsigned IOCTL_TCSETAF;
+  extern unsigned IOCTL_TCSETAW;
+  extern unsigned IOCTL_TCSETS;
+  extern unsigned IOCTL_TCSETSF;
+  extern unsigned IOCTL_TCSETSW;
+  extern unsigned IOCTL_TCXONC;
+  extern unsigned IOCTL_TIOCGLCKTRMIOS;
+  extern unsigned IOCTL_TIOCGSOFTCAR;
+  extern unsigned IOCTL_TIOCINQ;
+  extern unsigned IOCTL_TIOCLINUX;
+  extern unsigned IOCTL_TIOCSERCONFIG;
+  extern unsigned IOCTL_TIOCSERGETLSR;
+  extern unsigned IOCTL_TIOCSERGWILD;
+  extern unsigned IOCTL_TIOCSERSWILD;
+  extern unsigned IOCTL_TIOCSLCKTRMIOS;
+  extern unsigned IOCTL_TIOCSSOFTCAR;
+  extern unsigned IOCTL_VT_DISALLOCATE;
+  extern unsigned IOCTL_VT_GETSTATE;
+  extern unsigned IOCTL_VT_RESIZE;
+  extern unsigned IOCTL_VT_RESIZEX;
+  extern unsigned IOCTL_VT_SENDSIG;
+#endif  // SANITIZER_LINUX
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+  extern unsigned IOCTL_MTIOCGET;
+  extern unsigned IOCTL_MTIOCTOP;
+  extern unsigned IOCTL_SIOCADDRT;
+  extern unsigned IOCTL_SIOCDELRT;
+  extern unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE;
+  extern unsigned IOCTL_SNDCTL_DSP_GETFMTS;
+  extern unsigned IOCTL_SNDCTL_DSP_NONBLOCK;
+  extern unsigned IOCTL_SNDCTL_DSP_POST;
+  extern unsigned IOCTL_SNDCTL_DSP_RESET;
+  extern unsigned IOCTL_SNDCTL_DSP_SETFMT;
+  extern unsigned IOCTL_SNDCTL_DSP_SETFRAGMENT;
+  extern unsigned IOCTL_SNDCTL_DSP_SPEED;
+  extern unsigned IOCTL_SNDCTL_DSP_STEREO;
+  extern unsigned IOCTL_SNDCTL_DSP_SUBDIVIDE;
+  extern unsigned IOCTL_SNDCTL_DSP_SYNC;
+  extern unsigned IOCTL_SNDCTL_FM_4OP_ENABLE;
+  extern unsigned IOCTL_SNDCTL_FM_LOAD_INSTR;
+  extern unsigned IOCTL_SNDCTL_MIDI_INFO;
+  extern unsigned IOCTL_SNDCTL_MIDI_PRETIME;
+  extern unsigned IOCTL_SNDCTL_SEQ_CTRLRATE;
+  extern unsigned IOCTL_SNDCTL_SEQ_GETINCOUNT;
+  extern unsigned IOCTL_SNDCTL_SEQ_GETOUTCOUNT;
+  extern unsigned IOCTL_SNDCTL_SEQ_NRMIDIS;
+  extern unsigned IOCTL_SNDCTL_SEQ_NRSYNTHS;
+  extern unsigned IOCTL_SNDCTL_SEQ_OUTOFBAND;
+  extern unsigned IOCTL_SNDCTL_SEQ_PANIC;
+  extern unsigned IOCTL_SNDCTL_SEQ_PERCMODE;
+  extern unsigned IOCTL_SNDCTL_SEQ_RESET;
+  extern unsigned IOCTL_SNDCTL_SEQ_RESETSAMPLES;
+  extern unsigned IOCTL_SNDCTL_SEQ_SYNC;
+  extern unsigned IOCTL_SNDCTL_SEQ_TESTMIDI;
+  extern unsigned IOCTL_SNDCTL_SEQ_THRESHOLD;
+  extern unsigned IOCTL_SNDCTL_SYNTH_INFO;
+  extern unsigned IOCTL_SNDCTL_SYNTH_MEMAVL;
+  extern unsigned IOCTL_SNDCTL_TMR_CONTINUE;
+  extern unsigned IOCTL_SNDCTL_TMR_METRONOME;
+  extern unsigned IOCTL_SNDCTL_TMR_SELECT;
+  extern unsigned IOCTL_SNDCTL_TMR_SOURCE;
+  extern unsigned IOCTL_SNDCTL_TMR_START;
+  extern unsigned IOCTL_SNDCTL_TMR_STOP;
+  extern unsigned IOCTL_SNDCTL_TMR_TEMPO;
+  extern unsigned IOCTL_SNDCTL_TMR_TIMEBASE;
+  extern unsigned IOCTL_SOUND_MIXER_READ_ALTPCM;
+  extern unsigned IOCTL_SOUND_MIXER_READ_BASS;
+  extern unsigned IOCTL_SOUND_MIXER_READ_CAPS;
+  extern unsigned IOCTL_SOUND_MIXER_READ_CD;
+  extern unsigned IOCTL_SOUND_MIXER_READ_DEVMASK;
+  extern unsigned IOCTL_SOUND_MIXER_READ_ENHANCE;
+  extern unsigned IOCTL_SOUND_MIXER_READ_IGAIN;
+  extern unsigned IOCTL_SOUND_MIXER_READ_IMIX;
+  extern unsigned IOCTL_SOUND_MIXER_READ_LINE1;
+  extern unsigned IOCTL_SOUND_MIXER_READ_LINE2;
+  extern unsigned IOCTL_SOUND_MIXER_READ_LINE3;
+  extern unsigned IOCTL_SOUND_MIXER_READ_LINE;
+  extern unsigned IOCTL_SOUND_MIXER_READ_LOUD;
+  extern unsigned IOCTL_SOUND_MIXER_READ_MIC;
+  extern unsigned IOCTL_SOUND_MIXER_READ_MUTE;
+  extern unsigned IOCTL_SOUND_MIXER_READ_OGAIN;
+  extern unsigned IOCTL_SOUND_MIXER_READ_PCM;
+  extern unsigned IOCTL_SOUND_MIXER_READ_RECLEV;
+  extern unsigned IOCTL_SOUND_MIXER_READ_RECMASK;
+  extern unsigned IOCTL_SOUND_MIXER_READ_RECSRC;
+  extern unsigned IOCTL_SOUND_MIXER_READ_SPEAKER;
+  extern unsigned IOCTL_SOUND_MIXER_READ_STEREODEVS;
+  extern unsigned IOCTL_SOUND_MIXER_READ_SYNTH;
+  extern unsigned IOCTL_SOUND_MIXER_READ_TREBLE;
+  extern unsigned IOCTL_SOUND_MIXER_READ_VOLUME;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_ALTPCM;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_BASS;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_CD;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_ENHANCE;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_IGAIN;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_IMIX;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE1;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE2;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE3;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_LOUD;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_MIC;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_MUTE;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_OGAIN;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_PCM;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_RECLEV;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_RECSRC;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_SPEAKER;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_SYNTH;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_TREBLE;
+  extern unsigned IOCTL_SOUND_MIXER_WRITE_VOLUME;
+  extern unsigned IOCTL_SOUND_PCM_READ_BITS;
+  extern unsigned IOCTL_SOUND_PCM_READ_CHANNELS;
+  extern unsigned IOCTL_SOUND_PCM_READ_FILTER;
+  extern unsigned IOCTL_SOUND_PCM_READ_RATE;
+  extern unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS;
+  extern unsigned IOCTL_SOUND_PCM_WRITE_FILTER;
+  extern unsigned IOCTL_VT_ACTIVATE;
+  extern unsigned IOCTL_VT_GETMODE;
+  extern unsigned IOCTL_VT_OPENQRY;
+  extern unsigned IOCTL_VT_RELDISP;
+  extern unsigned IOCTL_VT_SETMODE;
+  extern unsigned IOCTL_VT_WAITACTIVE;
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  extern unsigned IOCTL_CYGETDEFTHRESH;
+  extern unsigned IOCTL_CYGETDEFTIMEOUT;
+  extern unsigned IOCTL_CYGETMON;
+  extern unsigned IOCTL_CYGETTHRESH;
+  extern unsigned IOCTL_CYGETTIMEOUT;
+  extern unsigned IOCTL_CYSETDEFTHRESH;
+  extern unsigned IOCTL_CYSETDEFTIMEOUT;
+  extern unsigned IOCTL_CYSETTHRESH;
+  extern unsigned IOCTL_CYSETTIMEOUT;
+  extern unsigned IOCTL_EQL_EMANCIPATE;
+  extern unsigned IOCTL_EQL_ENSLAVE;
+  extern unsigned IOCTL_EQL_GETMASTRCFG;
+  extern unsigned IOCTL_EQL_GETSLAVECFG;
+  extern unsigned IOCTL_EQL_SETMASTRCFG;
+  extern unsigned IOCTL_EQL_SETSLAVECFG;
+  extern unsigned IOCTL_EVIOCGKEYCODE_V2;
+  extern unsigned IOCTL_EVIOCGPROP;
+  extern unsigned IOCTL_EVIOCSKEYCODE_V2;
+  extern unsigned IOCTL_FS_IOC_GETFLAGS;
+  extern unsigned IOCTL_FS_IOC_GETVERSION;
+  extern unsigned IOCTL_FS_IOC_SETFLAGS;
+  extern unsigned IOCTL_FS_IOC_SETVERSION;
+  extern unsigned IOCTL_GIO_CMAP;
+  extern unsigned IOCTL_GIO_FONT;
+  extern unsigned IOCTL_GIO_UNIMAP;
+  extern unsigned IOCTL_GIO_UNISCRNMAP;
+  extern unsigned IOCTL_KDADDIO;
+  extern unsigned IOCTL_KDDELIO;
+  extern unsigned IOCTL_KDGETKEYCODE;
+  extern unsigned IOCTL_KDGKBDIACR;
+  extern unsigned IOCTL_KDGKBENT;
+  extern unsigned IOCTL_KDGKBLED;
+  extern unsigned IOCTL_KDGKBMETA;
+  extern unsigned IOCTL_KDGKBSENT;
+  extern unsigned IOCTL_KDMAPDISP;
+  extern unsigned IOCTL_KDSETKEYCODE;
+  extern unsigned IOCTL_KDSIGACCEPT;
+  extern unsigned IOCTL_KDSKBDIACR;
+  extern unsigned IOCTL_KDSKBENT;
+  extern unsigned IOCTL_KDSKBLED;
+  extern unsigned IOCTL_KDSKBMETA;
+  extern unsigned IOCTL_KDSKBSENT;
+  extern unsigned IOCTL_KDUNMAPDISP;
+  extern unsigned IOCTL_LPABORT;
+  extern unsigned IOCTL_LPABORTOPEN;
+  extern unsigned IOCTL_LPCAREFUL;
+  extern unsigned IOCTL_LPCHAR;
+  extern unsigned IOCTL_LPGETIRQ;
+  extern unsigned IOCTL_LPGETSTATUS;
+  extern unsigned IOCTL_LPRESET;
+  extern unsigned IOCTL_LPSETIRQ;
+  extern unsigned IOCTL_LPTIME;
+  extern unsigned IOCTL_LPWAIT;
+  extern unsigned IOCTL_MTIOCGETCONFIG;
+  extern unsigned IOCTL_MTIOCSETCONFIG;
+  extern unsigned IOCTL_PIO_CMAP;
+  extern unsigned IOCTL_PIO_FONT;
+  extern unsigned IOCTL_PIO_UNIMAP;
+  extern unsigned IOCTL_PIO_UNIMAPCLR;
+  extern unsigned IOCTL_PIO_UNISCRNMAP;
+  extern unsigned IOCTL_SCSI_IOCTL_GET_IDLUN;
+  extern unsigned IOCTL_SCSI_IOCTL_PROBE_HOST;
+  extern unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE;
+  extern unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE;
+  extern unsigned IOCTL_SIOCAIPXITFCRT;
+  extern unsigned IOCTL_SIOCAIPXPRISLT;
+  extern unsigned IOCTL_SIOCAX25ADDUID;
+  extern unsigned IOCTL_SIOCAX25DELUID;
+  extern unsigned IOCTL_SIOCAX25GETPARMS;
+  extern unsigned IOCTL_SIOCAX25GETUID;
+  extern unsigned IOCTL_SIOCAX25NOUID;
+  extern unsigned IOCTL_SIOCAX25SETPARMS;
+  extern unsigned IOCTL_SIOCDEVPLIP;
+  extern unsigned IOCTL_SIOCIPXCFGDATA;
+  extern unsigned IOCTL_SIOCNRDECOBS;
+  extern unsigned IOCTL_SIOCNRGETPARMS;
+  extern unsigned IOCTL_SIOCNRRTCTL;
+  extern unsigned IOCTL_SIOCNRSETPARMS;
+  extern unsigned IOCTL_SNDCTL_DSP_GETISPACE;
+  extern unsigned IOCTL_SNDCTL_DSP_GETOSPACE;
+  extern unsigned IOCTL_TIOCGSERIAL;
+  extern unsigned IOCTL_TIOCSERGETMULTI;
+  extern unsigned IOCTL_TIOCSERSETMULTI;
+  extern unsigned IOCTL_TIOCSSERIAL;
+#endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
+
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+  extern unsigned IOCTL_GIO_SCRNMAP;
+  extern unsigned IOCTL_KDDISABIO;
+  extern unsigned IOCTL_KDENABIO;
+  extern unsigned IOCTL_KDGETLED;
+  extern unsigned IOCTL_KDGETMODE;
+  extern unsigned IOCTL_KDGKBMODE;
+  extern unsigned IOCTL_KDGKBTYPE;
+  extern unsigned IOCTL_KDMKTONE;
+  extern unsigned IOCTL_KDSETLED;
+  extern unsigned IOCTL_KDSETMODE;
+  extern unsigned IOCTL_KDSKBMODE;
+  extern unsigned IOCTL_KIOCSOUND;
+  extern unsigned IOCTL_PIO_SCRNMAP;
+#endif
+
+  extern const int errno_EINVAL;
+  extern const int errno_EOWNERDEAD;
+
+  extern const int si_SEGV_MAPERR;
+  extern const int si_SEGV_ACCERR;
+}  // namespace __sanitizer
+
+#define CHECK_TYPE_SIZE(TYPE) \
+  COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
+
+#define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER)                       \
+  COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *) NULL)->MEMBER) == \
+                 sizeof(((CLASS *) NULL)->MEMBER));                \
+  COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) ==          \
+                 offsetof(CLASS, MEMBER))
+
+// For sigaction, which is a function and struct at the same time,
+// and thus requires explicit "struct" in sizeof() expression.
+#define CHECK_STRUCT_SIZE_AND_OFFSET(CLASS, MEMBER)                       \
+  COMPILER_CHECK(sizeof(((struct __sanitizer_##CLASS *) NULL)->MEMBER) == \
+                 sizeof(((struct CLASS *) NULL)->MEMBER));                \
+  COMPILER_CHECK(offsetof(struct __sanitizer_##CLASS, MEMBER) ==          \
+                 offsetof(struct CLASS, MEMBER))
+
+#endif
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix.cc b/compiler-rt/lib/sanitizer_common/sanitizer_posix.cc
new file mode 100644
index 0000000..5ae6866
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix.cc
@@ -0,0 +1,326 @@
+//===-- sanitizer_posix.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries and implements POSIX-specific functions from
+// sanitizer_posix.h.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_POSIX
+
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_posix.h"
+#include "sanitizer_procmaps.h"
+#include "sanitizer_stacktrace.h"
+
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/mman.h>
+
+#if SANITIZER_LINUX
+#include <sys/utsname.h>
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#include <sys/personality.h>
+#endif
+
+#if SANITIZER_FREEBSD
+// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
+// that, it was never implemented.  So just define it to zero.
+#undef  MAP_NORESERVE
+#define MAP_NORESERVE 0
+#endif
+
+namespace __sanitizer {
+
+// ------------- sanitizer_common.h
+uptr GetMmapGranularity() {
+  return GetPageSize();
+}
+
+#if SANITIZER_WORDSIZE == 32
+// Take care of unusable kernel area in top gigabyte.
+static uptr GetKernelAreaSize() {
+#if SANITIZER_LINUX && !SANITIZER_X32
+  const uptr gbyte = 1UL << 30;
+
+  // Firstly check if there are writable segments
+  // mapped to top gigabyte (e.g. stack).
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  uptr end, prot;
+  while (proc_maps.Next(/*start*/nullptr, &end,
+                        /*offset*/nullptr, /*filename*/nullptr,
+                        /*filename_size*/0, &prot)) {
+    if ((end >= 3 * gbyte)
+        && (prot & MemoryMappingLayout::kProtectionWrite) != 0)
+      return 0;
+  }
+
+#if !SANITIZER_ANDROID
+  // Even if nothing is mapped, top Gb may still be accessible
+  // if we are running on 64-bit kernel.
+  // Uname may report misleading results if personality type
+  // is modified (e.g. under schroot) so check this as well.
+  struct utsname uname_info;
+  int pers = personality(0xffffffffUL);
+  if (!(pers & PER_MASK)
+      && uname(&uname_info) == 0
+      && internal_strstr(uname_info.machine, "64"))
+    return 0;
+#endif  // SANITIZER_ANDROID
+
+  // Top gigabyte is reserved for kernel.
+  return gbyte;
+#else
+  return 0;
+#endif  // SANITIZER_LINUX && !SANITIZER_X32
+}
+#endif  // SANITIZER_WORDSIZE == 32
+
+uptr GetMaxVirtualAddress() {
+#if SANITIZER_WORDSIZE == 64
+# if defined(__powerpc64__) || defined(__aarch64__)
+  // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
+  // We somehow need to figure out which one we are using now and choose
+  // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
+  // Note that with 'ulimit -s unlimited' the stack is moved away from the top
+  // of the address space, so simply checking the stack address is not enough.
+  // This should (does) work for both PowerPC64 Endian modes.
+  // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit.
+  return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1;
+# elif defined(__mips64)
+  return (1ULL << 40) - 1;  // 0x000000ffffffffffUL;
+# else
+  return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;
+# endif
+#else  // SANITIZER_WORDSIZE == 32
+  uptr res = (1ULL << 32) - 1;  // 0xffffffff;
+  if (!common_flags()->full_address_space)
+    res -= GetKernelAreaSize();
+  CHECK_LT(reinterpret_cast<uptr>(&res), res);
+  return res;
+#endif  // SANITIZER_WORDSIZE
+}
+
+void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
+  size = RoundUpTo(size, GetPageSizeCached());
+  uptr res = internal_mmap(nullptr, size,
+                           PROT_READ | PROT_WRITE,
+                           MAP_PRIVATE | MAP_ANON, -1, 0);
+  int reserrno;
+  if (internal_iserror(res, &reserrno))
+    ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno, raw_report);
+  IncreaseTotalMmap(size);
+  return (void *)res;
+}
+
+void UnmapOrDie(void *addr, uptr size) {
+  if (!addr || !size) return;
+  uptr res = internal_munmap(addr, size);
+  if (internal_iserror(res)) {
+    Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n",
+           SanitizerToolName, size, size, addr);
+    CHECK("unable to unmap" && 0);
+  }
+  DecreaseTotalMmap(size);
+}
+
+void *MmapNoReserveOrDie(uptr size, const char *mem_type) {
+  uptr PageSize = GetPageSizeCached();
+  uptr p = internal_mmap(nullptr,
+                         RoundUpTo(size, PageSize),
+                         PROT_READ | PROT_WRITE,
+                         MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
+                         -1, 0);
+  int reserrno;
+  if (internal_iserror(p, &reserrno))
+    ReportMmapFailureAndDie(size, mem_type, "allocate noreserve", reserrno);
+  IncreaseTotalMmap(size);
+  return (void *)p;
+}
+
+void *MmapFixedOrDie(uptr fixed_addr, uptr size) {
+  uptr PageSize = GetPageSizeCached();
+  uptr p = internal_mmap((void*)(fixed_addr & ~(PageSize - 1)),
+      RoundUpTo(size, PageSize),
+      PROT_READ | PROT_WRITE,
+      MAP_PRIVATE | MAP_ANON | MAP_FIXED,
+      -1, 0);
+  int reserrno;
+  if (internal_iserror(p, &reserrno)) {
+    char mem_type[30];
+    internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx",
+                      fixed_addr);
+    ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno);
+  }
+  IncreaseTotalMmap(size);
+  return (void *)p;
+}
+
+bool MprotectNoAccess(uptr addr, uptr size) {
+  return 0 == internal_mprotect((void*)addr, size, PROT_NONE);
+}
+
+fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) {
+  int flags;
+  switch (mode) {
+    case RdOnly: flags = O_RDONLY; break;
+    case WrOnly: flags = O_WRONLY | O_CREAT; break;
+    case RdWr: flags = O_RDWR | O_CREAT; break;
+  }
+  fd_t res = internal_open(filename, flags, 0660);
+  if (internal_iserror(res, errno_p))
+    return kInvalidFd;
+  return res;
+}
+
+void CloseFile(fd_t fd) {
+  internal_close(fd);
+}
+
+bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,
+                  error_t *error_p) {
+  uptr res = internal_read(fd, buff, buff_size);
+  if (internal_iserror(res, error_p))
+    return false;
+  if (bytes_read)
+    *bytes_read = res;
+  return true;
+}
+
+bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written,
+                 error_t *error_p) {
+  uptr res = internal_write(fd, buff, buff_size);
+  if (internal_iserror(res, error_p))
+    return false;
+  if (bytes_written)
+    *bytes_written = res;
+  return true;
+}
+
+bool RenameFile(const char *oldpath, const char *newpath, error_t *error_p) {
+  uptr res = internal_rename(oldpath, newpath);
+  return !internal_iserror(res, error_p);
+}
+
+void *MapFileToMemory(const char *file_name, uptr *buff_size) {
+  fd_t fd = OpenFile(file_name, RdOnly);
+  CHECK(fd != kInvalidFd);
+  uptr fsize = internal_filesize(fd);
+  CHECK_NE(fsize, (uptr)-1);
+  CHECK_GT(fsize, 0);
+  *buff_size = RoundUpTo(fsize, GetPageSizeCached());
+  uptr map = internal_mmap(nullptr, *buff_size, PROT_READ, MAP_PRIVATE, fd, 0);
+  return internal_iserror(map) ? nullptr : (void *)map;
+}
+
+void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
+  uptr flags = MAP_SHARED;
+  if (addr) flags |= MAP_FIXED;
+  uptr p = internal_mmap(addr, size, PROT_READ | PROT_WRITE, flags, fd, offset);
+  int mmap_errno = 0;
+  if (internal_iserror(p, &mmap_errno)) {
+    Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",
+           fd, (long long)offset, size, p, mmap_errno);
+    return nullptr;
+  }
+  return (void *)p;
+}
+
+static inline bool IntervalsAreSeparate(uptr start1, uptr end1,
+                                        uptr start2, uptr end2) {
+  CHECK(start1 <= end1);
+  CHECK(start2 <= end2);
+  return (end1 < start2) || (end2 < start1);
+}
+
+// FIXME: this is thread-unsafe, but should not cause problems most of the time.
+// When the shadow is mapped only a single thread usually exists (plus maybe
+// several worker threads on Mac, which aren't expected to map big chunks of
+// memory).
+bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  uptr start, end;
+  while (proc_maps.Next(&start, &end,
+                        /*offset*/nullptr, /*filename*/nullptr,
+                        /*filename_size*/0, /*protection*/nullptr)) {
+    if (start == end) continue;  // Empty range.
+    CHECK_NE(0, end);
+    if (!IntervalsAreSeparate(start, end - 1, range_start, range_end))
+      return false;
+  }
+  return true;
+}
+
+void DumpProcessMap() {
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  uptr start, end;
+  const sptr kBufSize = 4095;
+  char *filename = (char*)MmapOrDie(kBufSize, __func__);
+  Report("Process memory map follows:\n");
+  while (proc_maps.Next(&start, &end, /* file_offset */nullptr,
+                        filename, kBufSize, /* protection */nullptr)) {
+    Printf("\t%p-%p\t%s\n", (void*)start, (void*)end, filename);
+  }
+  Report("End of process memory map.\n");
+  UnmapOrDie(filename, kBufSize);
+}
+
+const char *GetPwd() {
+  return GetEnv("PWD");
+}
+
+bool IsPathSeparator(const char c) {
+  return c == '/';
+}
+
+bool IsAbsolutePath(const char *path) {
+  return path != nullptr && IsPathSeparator(path[0]);
+}
+
+void ReportFile::Write(const char *buffer, uptr length) {
+  SpinMutexLock l(mu);
+  static const char *kWriteError =
+      "ReportFile::Write() can't output requested buffer!\n";
+  ReopenIfNecessary();
+  if (length != internal_write(fd, buffer, length)) {
+    internal_write(fd, kWriteError, internal_strlen(kWriteError));
+    Die();
+  }
+}
+
+bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end) {
+  uptr s, e, off, prot;
+  InternalScopedString buff(kMaxPathLength);
+  MemoryMappingLayout proc_maps(/*cache_enabled*/false);
+  while (proc_maps.Next(&s, &e, &off, buff.data(), buff.size(), &prot)) {
+    if ((prot & MemoryMappingLayout::kProtectionExecute) != 0
+        && internal_strcmp(module, buff.data()) == 0) {
+      *start = s;
+      *end = e;
+      return true;
+    }
+  }
+  return false;
+}
+
+SignalContext SignalContext::Create(void *siginfo, void *context) {
+  uptr addr = (uptr)((siginfo_t*)siginfo)->si_addr;
+  uptr pc, sp, bp;
+  GetPcSpBp(context, &pc, &sp, &bp);
+  return SignalContext(context, addr, pc, sp, bp);
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_POSIX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix.h b/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
new file mode 100644
index 0000000..c0426a0
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
@@ -0,0 +1,84 @@
+//===-- sanitizer_posix.h -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries and declares some useful POSIX-specific functions.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_POSIX_H
+#define SANITIZER_POSIX_H
+
+// ----------- ATTENTION -------------
+// This header should NOT include any other headers from sanitizer runtime.
+#include "sanitizer_internal_defs.h"
+
+#if !SANITIZER_POSIX
+// Make it hard to accidentally use any of functions declared in this file:
+#error This file should only be included on POSIX
+#endif
+
+namespace __sanitizer {
+
+// I/O
+// Don't use directly, use __sanitizer::OpenFile() instead.
+uptr internal_open(const char *filename, int flags);
+uptr internal_open(const char *filename, int flags, u32 mode);
+uptr internal_close(fd_t fd);
+
+uptr internal_read(fd_t fd, void *buf, uptr count);
+uptr internal_write(fd_t fd, const void *buf, uptr count);
+
+// Memory
+uptr internal_mmap(void *addr, uptr length, int prot, int flags,
+                   int fd, OFF_T offset);
+uptr internal_munmap(void *addr, uptr length);
+int internal_mprotect(void *addr, uptr length, int prot);
+
+// OS
+uptr internal_filesize(fd_t fd);  // -1 on error.
+uptr internal_stat(const char *path, void *buf);
+uptr internal_lstat(const char *path, void *buf);
+uptr internal_fstat(fd_t fd, void *buf);
+uptr internal_dup2(int oldfd, int newfd);
+uptr internal_readlink(const char *path, char *buf, uptr bufsize);
+uptr internal_unlink(const char *path);
+uptr internal_rename(const char *oldpath, const char *newpath);
+uptr internal_lseek(fd_t fd, OFF_T offset, int whence);
+
+uptr internal_ptrace(int request, int pid, void *addr, void *data);
+uptr internal_waitpid(int pid, int *status, int options);
+
+int internal_fork();
+int internal_forkpty(int *amaster);
+
+// These functions call appropriate pthread_ functions directly, bypassing
+// the interceptor. They are weak and may not be present in some tools.
+SANITIZER_WEAK_ATTRIBUTE
+int real_pthread_create(void *th, void *attr, void *(*callback)(void *),
+                        void *param);
+SANITIZER_WEAK_ATTRIBUTE
+int real_pthread_join(void *th, void **ret);
+
+#define DEFINE_REAL_PTHREAD_FUNCTIONS                                          \
+  namespace __sanitizer {                                                      \
+  int real_pthread_create(void *th, void *attr, void *(*callback)(void *),     \
+                          void *param) {                                       \
+    return REAL(pthread_create)(th, attr, callback, param);                    \
+  }                                                                            \
+  int real_pthread_join(void *th, void **ret) {                                \
+    return REAL(pthread_join(th, ret));                                        \
+  }                                                                            \
+  }  // namespace __sanitizer
+
+int my_pthread_attr_getstack(void *attr, void **addr, uptr *size);
+
+int internal_sigaction(int signum, const void *act, void *oldact);
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_POSIX_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc
new file mode 100644
index 0000000..c158eed
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc
@@ -0,0 +1,325 @@
+//===-- sanitizer_posix_libcdep.cc ----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries and implements libc-dependent POSIX-specific functions
+// from sanitizer_libc.h.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_POSIX
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_platform_limits_posix.h"
+#include "sanitizer_posix.h"
+#include "sanitizer_procmaps.h"
+#include "sanitizer_stacktrace.h"
+#include "sanitizer_symbolizer.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#if SANITIZER_FREEBSD
+// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
+// that, it was never implemented.  So just define it to zero.
+#undef  MAP_NORESERVE
+#define MAP_NORESERVE 0
+#endif
+
+namespace __sanitizer {
+
+u32 GetUid() {
+  return getuid();
+}
+
+uptr GetThreadSelf() {
+  return (uptr)pthread_self();
+}
+
+void FlushUnneededShadowMemory(uptr addr, uptr size) {
+  madvise((void*)addr, size, MADV_DONTNEED);
+}
+
+void NoHugePagesInRegion(uptr addr, uptr size) {
+#ifdef MADV_NOHUGEPAGE  // May not be defined on old systems.
+  madvise((void *)addr, size, MADV_NOHUGEPAGE);
+#endif  // MADV_NOHUGEPAGE
+}
+
+void DontDumpShadowMemory(uptr addr, uptr length) {
+#ifdef MADV_DONTDUMP
+  madvise((void *)addr, length, MADV_DONTDUMP);
+#endif
+}
+
+static rlim_t getlim(int res) {
+  rlimit rlim;
+  CHECK_EQ(0, getrlimit(res, &rlim));
+  return rlim.rlim_cur;
+}
+
+static void setlim(int res, rlim_t lim) {
+  // The following magic is to prevent clang from replacing it with memset.
+  volatile struct rlimit rlim;
+  rlim.rlim_cur = lim;
+  rlim.rlim_max = lim;
+  if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) {
+    Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno);
+    Die();
+  }
+}
+
+void DisableCoreDumperIfNecessary() {
+  if (common_flags()->disable_coredump) {
+    setlim(RLIMIT_CORE, 0);
+  }
+}
+
+bool StackSizeIsUnlimited() {
+  rlim_t stack_size = getlim(RLIMIT_STACK);
+  return (stack_size == RLIM_INFINITY);
+}
+
+void SetStackSizeLimitInBytes(uptr limit) {
+  setlim(RLIMIT_STACK, (rlim_t)limit);
+  CHECK(!StackSizeIsUnlimited());
+}
+
+bool AddressSpaceIsUnlimited() {
+  rlim_t as_size = getlim(RLIMIT_AS);
+  return (as_size == RLIM_INFINITY);
+}
+
+void SetAddressSpaceUnlimited() {
+  setlim(RLIMIT_AS, RLIM_INFINITY);
+  CHECK(AddressSpaceIsUnlimited());
+}
+
+void SleepForSeconds(int seconds) {
+  sleep(seconds);
+}
+
+void SleepForMillis(int millis) {
+  usleep(millis * 1000);
+}
+
+void Abort() {
+  abort();
+}
+
+int Atexit(void (*function)(void)) {
+#ifndef SANITIZER_GO
+  return atexit(function);
+#else
+  return 0;
+#endif
+}
+
+bool SupportsColoredOutput(fd_t fd) {
+  return isatty(fd) != 0;
+}
+
+#ifndef SANITIZER_GO
+// TODO(glider): different tools may require different altstack size.
+static const uptr kAltStackSize = SIGSTKSZ * 4;  // SIGSTKSZ is not enough.
+
+void SetAlternateSignalStack() {
+  stack_t altstack, oldstack;
+  CHECK_EQ(0, sigaltstack(nullptr, &oldstack));
+  // If the alternate stack is already in place, do nothing.
+  // Android always sets an alternate stack, but it's too small for us.
+  if (!SANITIZER_ANDROID && !(oldstack.ss_flags & SS_DISABLE)) return;
+  // TODO(glider): the mapped stack should have the MAP_STACK flag in the
+  // future. It is not required by man 2 sigaltstack now (they're using
+  // malloc()).
+  void* base = MmapOrDie(kAltStackSize, __func__);
+  altstack.ss_sp = (char*) base;
+  altstack.ss_flags = 0;
+  altstack.ss_size = kAltStackSize;
+  CHECK_EQ(0, sigaltstack(&altstack, nullptr));
+}
+
+void UnsetAlternateSignalStack() {
+  stack_t altstack, oldstack;
+  altstack.ss_sp = nullptr;
+  altstack.ss_flags = SS_DISABLE;
+  altstack.ss_size = kAltStackSize;  // Some sane value required on Darwin.
+  CHECK_EQ(0, sigaltstack(&altstack, &oldstack));
+  UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);
+}
+
+typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
+static void MaybeInstallSigaction(int signum,
+                                  SignalHandlerType handler) {
+  if (!IsDeadlySignal(signum))
+    return;
+  struct sigaction sigact;
+  internal_memset(&sigact, 0, sizeof(sigact));
+  sigact.sa_sigaction = (sa_sigaction_t)handler;
+  // Do not block the signal from being received in that signal's handler.
+  // Clients are responsible for handling this correctly.
+  sigact.sa_flags = SA_SIGINFO | SA_NODEFER;
+  if (common_flags()->use_sigaltstack) sigact.sa_flags |= SA_ONSTACK;
+  CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));
+  VReport(1, "Installed the sigaction for signal %d\n", signum);
+}
+
+void InstallDeadlySignalHandlers(SignalHandlerType handler) {
+  // Set the alternate signal stack for the main thread.
+  // This will cause SetAlternateSignalStack to be called twice, but the stack
+  // will be actually set only once.
+  if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
+  MaybeInstallSigaction(SIGSEGV, handler);
+  MaybeInstallSigaction(SIGBUS, handler);
+  MaybeInstallSigaction(SIGABRT, handler);
+  MaybeInstallSigaction(SIGFPE, handler);
+  MaybeInstallSigaction(SIGILL, handler);
+}
+#endif  // SANITIZER_GO
+
+bool IsAccessibleMemoryRange(uptr beg, uptr size) {
+  uptr page_size = GetPageSizeCached();
+  // Checking too large memory ranges is slow.
+  CHECK_LT(size, page_size * 10);
+  int sock_pair[2];
+  if (pipe(sock_pair))
+    return false;
+  uptr bytes_written =
+      internal_write(sock_pair[1], reinterpret_cast<void *>(beg), size);
+  int write_errno;
+  bool result;
+  if (internal_iserror(bytes_written, &write_errno)) {
+    CHECK_EQ(EFAULT, write_errno);
+    result = false;
+  } else {
+    result = (bytes_written == size);
+  }
+  internal_close(sock_pair[0]);
+  internal_close(sock_pair[1]);
+  return result;
+}
+
+void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
+  // Some kinds of sandboxes may forbid filesystem access, so we won't be able
+  // to read the file mappings from /proc/self/maps. Luckily, neither the
+  // process will be able to load additional libraries, so it's fine to use the
+  // cached mappings.
+  MemoryMappingLayout::CacheMemoryMappings();
+  // Same for /proc/self/exe in the symbolizer.
+#if !SANITIZER_GO
+  Symbolizer::GetOrInit()->PrepareForSandboxing();
+  CovPrepareForSandboxing(args);
+#endif
+}
+
+#if SANITIZER_ANDROID || SANITIZER_GO
+int GetNamedMappingFd(const char *name, uptr size) {
+  return -1;
+}
+#else
+int GetNamedMappingFd(const char *name, uptr size) {
+  if (!common_flags()->decorate_proc_maps)
+    return -1;
+  char shmname[200];
+  CHECK(internal_strlen(name) < sizeof(shmname) - 10);
+  internal_snprintf(shmname, sizeof(shmname), "%zu [%s]", internal_getpid(),
+                    name);
+  int fd = shm_open(shmname, O_RDWR | O_CREAT | O_TRUNC, S_IRWXU);
+  CHECK_GE(fd, 0);
+  int res = internal_ftruncate(fd, size);
+  CHECK_EQ(0, res);
+  res = shm_unlink(shmname);
+  CHECK_EQ(0, res);
+  return fd;
+}
+#endif
+
+void *MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) {
+  int fd = name ? GetNamedMappingFd(name, size) : -1;
+  unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE;
+  if (fd == -1) flags |= MAP_ANON;
+
+  uptr PageSize = GetPageSizeCached();
+  uptr p = internal_mmap((void *)(fixed_addr & ~(PageSize - 1)),
+                         RoundUpTo(size, PageSize), PROT_READ | PROT_WRITE,
+                         flags, fd, 0);
+  int reserrno;
+  if (internal_iserror(p, &reserrno))
+    Report("ERROR: %s failed to "
+           "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n",
+           SanitizerToolName, size, size, fixed_addr, reserrno);
+  IncreaseTotalMmap(size);
+  return (void *)p;
+}
+
+void *MmapNoAccess(uptr fixed_addr, uptr size, const char *name) {
+  int fd = name ? GetNamedMappingFd(name, size) : -1;
+  unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE;
+  if (fd == -1) flags |= MAP_ANON;
+
+  return (void *)internal_mmap((void *)fixed_addr, size, PROT_NONE, flags, fd,
+                               0);
+}
+
+// This function is defined elsewhere if we intercepted pthread_attr_getstack.
+extern "C" {
+SANITIZER_WEAK_ATTRIBUTE int
+real_pthread_attr_getstack(void *attr, void **addr, size_t *size);
+} // extern "C"
+
+int my_pthread_attr_getstack(void *attr, void **addr, uptr *size) {
+#if !SANITIZER_GO && !SANITIZER_MAC
+  if (&real_pthread_attr_getstack)
+    return real_pthread_attr_getstack((pthread_attr_t *)attr, addr,
+                                      (size_t *)size);
+#endif
+  return pthread_attr_getstack((pthread_attr_t *)attr, addr, (size_t *)size);
+}
+
+#if !SANITIZER_GO
+void AdjustStackSize(void *attr_) {
+  pthread_attr_t *attr = (pthread_attr_t *)attr_;
+  uptr stackaddr = 0;
+  uptr stacksize = 0;
+  my_pthread_attr_getstack(attr, (void**)&stackaddr, &stacksize);
+  // GLibC will return (0 - stacksize) as the stack address in the case when
+  // stacksize is set, but stackaddr is not.
+  bool stack_set = (stackaddr != 0) && (stackaddr + stacksize != 0);
+  // We place a lot of tool data into TLS, account for that.
+  const uptr minstacksize = GetTlsSize() + 128*1024;
+  if (stacksize < minstacksize) {
+    if (!stack_set) {
+      if (stacksize != 0) {
+        VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize,
+                minstacksize);
+        pthread_attr_setstacksize(attr, minstacksize);
+      }
+    } else {
+      Printf("Sanitizer: pre-allocated stack size is insufficient: "
+             "%zu < %zu\n", stacksize, minstacksize);
+      Printf("Sanitizer: pthread_create is likely to fail.\n");
+    }
+  }
+}
+#endif // !SANITIZER_GO
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_POSIX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_printf.cc b/compiler-rt/lib/sanitizer_common/sanitizer_printf.cc
new file mode 100644
index 0000000..2794e66
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_printf.cc
@@ -0,0 +1,331 @@
+//===-- sanitizer_printf.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer.
+//
+// Internal printf function, used inside run-time libraries.
+// We can't use libc printf because we intercept some of the functions used
+// inside it.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_libc.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 &&               \
+      !defined(va_copy)
+# define va_copy(dst, src) ((dst) = (src))
+#endif
+
+namespace __sanitizer {
+
+StaticSpinMutex CommonSanitizerReportMutex;
+
+static int AppendChar(char **buff, const char *buff_end, char c) {
+  if (*buff < buff_end) {
+    **buff = c;
+    (*buff)++;
+  }
+  return 1;
+}
+
+// Appends number in a given base to buffer. If its length is less than
+// |minimal_num_length|, it is padded with leading zeroes or spaces, depending
+// on the value of |pad_with_zero|.
+static int AppendNumber(char **buff, const char *buff_end, u64 absolute_value,
+                        u8 base, u8 minimal_num_length, bool pad_with_zero,
+                        bool negative) {
+  uptr const kMaxLen = 30;
+  RAW_CHECK(base == 10 || base == 16);
+  RAW_CHECK(base == 10 || !negative);
+  RAW_CHECK(absolute_value || !negative);
+  RAW_CHECK(minimal_num_length < kMaxLen);
+  int result = 0;
+  if (negative && minimal_num_length)
+    --minimal_num_length;
+  if (negative && pad_with_zero)
+    result += AppendChar(buff, buff_end, '-');
+  uptr num_buffer[kMaxLen];
+  int pos = 0;
+  do {
+    RAW_CHECK_MSG((uptr)pos < kMaxLen, "AppendNumber buffer overflow");
+    num_buffer[pos++] = absolute_value % base;
+    absolute_value /= base;
+  } while (absolute_value > 0);
+  if (pos < minimal_num_length) {
+    // Make sure compiler doesn't insert call to memset here.
+    internal_memset(&num_buffer[pos], 0,
+                    sizeof(num_buffer[0]) * (minimal_num_length - pos));
+    pos = minimal_num_length;
+  }
+  RAW_CHECK(pos > 0);
+  pos--;
+  for (; pos >= 0 && num_buffer[pos] == 0; pos--) {
+    char c = (pad_with_zero || pos == 0) ? '0' : ' ';
+    result += AppendChar(buff, buff_end, c);
+  }
+  if (negative && !pad_with_zero) result += AppendChar(buff, buff_end, '-');
+  for (; pos >= 0; pos--) {
+    char digit = static_cast<char>(num_buffer[pos]);
+    result += AppendChar(buff, buff_end, (digit < 10) ? '0' + digit
+                                                      : 'a' + digit - 10);
+  }
+  return result;
+}
+
+static int AppendUnsigned(char **buff, const char *buff_end, u64 num, u8 base,
+                          u8 minimal_num_length, bool pad_with_zero) {
+  return AppendNumber(buff, buff_end, num, base, minimal_num_length,
+                      pad_with_zero, false /* negative */);
+}
+
+static int AppendSignedDecimal(char **buff, const char *buff_end, s64 num,
+                               u8 minimal_num_length, bool pad_with_zero) {
+  bool negative = (num < 0);
+  return AppendNumber(buff, buff_end, (u64)(negative ? -num : num), 10,
+                      minimal_num_length, pad_with_zero, negative);
+}
+
+static int AppendString(char **buff, const char *buff_end, int precision,
+                        const char *s) {
+  if (!s)
+    s = "<null>";
+  int result = 0;
+  for (; *s; s++) {
+    if (precision >= 0 && result >= precision)
+      break;
+    result += AppendChar(buff, buff_end, *s);
+  }
+  return result;
+}
+
+static int AppendPointer(char **buff, const char *buff_end, u64 ptr_value) {
+  int result = 0;
+  result += AppendString(buff, buff_end, -1, "0x");
+  result += AppendUnsigned(buff, buff_end, ptr_value, 16,
+                           SANITIZER_POINTER_FORMAT_LENGTH, true);
+  return result;
+}
+
+int VSNPrintf(char *buff, int buff_length,
+              const char *format, va_list args) {
+  static const char *kPrintfFormatsHelp =
+    "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x}; %p; %(\\.\\*)?s; %c\n";
+  RAW_CHECK(format);
+  RAW_CHECK(buff_length > 0);
+  const char *buff_end = &buff[buff_length - 1];
+  const char *cur = format;
+  int result = 0;
+  for (; *cur; cur++) {
+    if (*cur != '%') {
+      result += AppendChar(&buff, buff_end, *cur);
+      continue;
+    }
+    cur++;
+    bool have_width = (*cur >= '0' && *cur <= '9');
+    bool pad_with_zero = (*cur == '0');
+    int width = 0;
+    if (have_width) {
+      while (*cur >= '0' && *cur <= '9') {
+        width = width * 10 + *cur++ - '0';
+      }
+    }
+    bool have_precision = (cur[0] == '.' && cur[1] == '*');
+    int precision = -1;
+    if (have_precision) {
+      cur += 2;
+      precision = va_arg(args, int);
+    }
+    bool have_z = (*cur == 'z');
+    cur += have_z;
+    bool have_ll = !have_z && (cur[0] == 'l' && cur[1] == 'l');
+    cur += have_ll * 2;
+    s64 dval;
+    u64 uval;
+    bool have_flags = have_width | have_z | have_ll;
+    // Only %s supports precision for now
+    CHECK(!(precision >= 0 && *cur != 's'));
+    switch (*cur) {
+      case 'd': {
+        dval = have_ll ? va_arg(args, s64)
+             : have_z ? va_arg(args, sptr)
+             : va_arg(args, int);
+        result += AppendSignedDecimal(&buff, buff_end, dval, width,
+                                      pad_with_zero);
+        break;
+      }
+      case 'u':
+      case 'x': {
+        uval = have_ll ? va_arg(args, u64)
+             : have_z ? va_arg(args, uptr)
+             : va_arg(args, unsigned);
+        result += AppendUnsigned(&buff, buff_end, uval,
+                                 (*cur == 'u') ? 10 : 16, width, pad_with_zero);
+        break;
+      }
+      case 'p': {
+        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
+        result += AppendPointer(&buff, buff_end, va_arg(args, uptr));
+        break;
+      }
+      case 's': {
+        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
+        result += AppendString(&buff, buff_end, precision, va_arg(args, char*));
+        break;
+      }
+      case 'c': {
+        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
+        result += AppendChar(&buff, buff_end, va_arg(args, int));
+        break;
+      }
+      case '%' : {
+        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
+        result += AppendChar(&buff, buff_end, '%');
+        break;
+      }
+      default: {
+        RAW_CHECK_MSG(false, kPrintfFormatsHelp);
+      }
+    }
+  }
+  RAW_CHECK(buff <= buff_end);
+  AppendChar(&buff, buff_end + 1, '\0');
+  return result;
+}
+
+static void (*PrintfAndReportCallback)(const char *);
+void SetPrintfAndReportCallback(void (*callback)(const char *)) {
+  PrintfAndReportCallback = callback;
+}
+
+// Can be overriden in frontend.
+#if SANITIZER_SUPPORTS_WEAK_HOOKS
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+void OnPrint(const char *str) {
+  (void)str;
+}
+#elif defined(SANITIZER_GO) && defined(TSAN_EXTERNAL_HOOKS)
+void OnPrint(const char *str);
+#else
+void OnPrint(const char *str) {
+  (void)str;
+}
+#endif
+
+static void CallPrintfAndReportCallback(const char *str) {
+  OnPrint(str);
+  if (PrintfAndReportCallback)
+    PrintfAndReportCallback(str);
+}
+
+static void SharedPrintfCode(bool append_pid, const char *format,
+                             va_list args) {
+  va_list args2;
+  va_copy(args2, args);
+  const int kLen = 16 * 1024;
+  // |local_buffer| is small enough not to overflow the stack and/or violate
+  // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
+  // hand, the bigger the buffer is, the more the chance the error report will
+  // fit into it.
+  char local_buffer[400];
+  int needed_length;
+  char *buffer = local_buffer;
+  int buffer_size = ARRAY_SIZE(local_buffer);
+  // First try to print a message using a local buffer, and then fall back to
+  // mmaped buffer.
+  for (int use_mmap = 0; use_mmap < 2; use_mmap++) {
+    if (use_mmap) {
+      va_end(args);
+      va_copy(args, args2);
+      buffer = (char*)MmapOrDie(kLen, "Report");
+      buffer_size = kLen;
+    }
+    needed_length = 0;
+    // Check that data fits into the current buffer.
+#   define CHECK_NEEDED_LENGTH \
+      if (needed_length >= buffer_size) { \
+        if (!use_mmap) continue; \
+        RAW_CHECK_MSG(needed_length < kLen, \
+                      "Buffer in Report is too short!\n"); \
+      }
+    if (append_pid) {
+      int pid = internal_getpid();
+      const char *exe_name = GetProcessName();
+      if (common_flags()->log_exe_name && exe_name) {
+        needed_length += internal_snprintf(buffer, buffer_size,
+                                           "==%s", exe_name);
+        CHECK_NEEDED_LENGTH
+      }
+      needed_length += internal_snprintf(buffer + needed_length,
+                                         buffer_size - needed_length,
+                                         "==%d==", pid);
+      CHECK_NEEDED_LENGTH
+    }
+    needed_length += VSNPrintf(buffer + needed_length,
+                               buffer_size - needed_length, format, args);
+    CHECK_NEEDED_LENGTH
+    // If the message fit into the buffer, print it and exit.
+    break;
+#   undef CHECK_NEEDED_LENGTH
+  }
+  RawWrite(buffer);
+  if (common_flags()->log_to_syslog && ShouldLogAfterPrintf())
+    WriteToSyslog(buffer);
+  CallPrintfAndReportCallback(buffer);
+  // If we had mapped any memory, clean up.
+  if (buffer != local_buffer)
+    UnmapOrDie((void *)buffer, buffer_size);
+  va_end(args2);
+}
+
+FORMAT(1, 2)
+void Printf(const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  SharedPrintfCode(false, format, args);
+  va_end(args);
+}
+
+// Like Printf, but prints the current PID before the output string.
+FORMAT(1, 2)
+void Report(const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  SharedPrintfCode(true, format, args);
+  va_end(args);
+}
+
+// Writes at most "length" symbols to "buffer" (including trailing '\0').
+// Returns the number of symbols that should have been written to buffer
+// (not including trailing '\0'). Thus, the string is truncated
+// iff return value is not less than "length".
+FORMAT(3, 4)
+int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  int needed_length = VSNPrintf(buffer, length, format, args);
+  va_end(args);
+  return needed_length;
+}
+
+FORMAT(2, 3)
+void InternalScopedString::append(const char *format, ...) {
+  CHECK_LT(length_, size());
+  va_list args;
+  va_start(args, format);
+  VSNPrintf(data() + length_, size() - length_, format, args);
+  va_end(args);
+  length_ += internal_strlen(data() + length_);
+  CHECK_LT(length_, size());
+}
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
new file mode 100644
index 0000000..94e3871
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
@@ -0,0 +1,99 @@
+//===-- sanitizer_procmaps.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer.
+//
+// Information about the process mappings.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_PROCMAPS_H
+#define SANITIZER_PROCMAPS_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_mutex.h"
+
+namespace __sanitizer {
+
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+struct ProcSelfMapsBuff {
+  char *data;
+  uptr mmaped_size;
+  uptr len;
+};
+
+// Reads process memory map in an OS-specific way.
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
+#endif  // SANITIZER_FREEBSD || SANITIZER_LINUX
+
+class MemoryMappingLayout {
+ public:
+  explicit MemoryMappingLayout(bool cache_enabled);
+  ~MemoryMappingLayout();
+  bool Next(uptr *start, uptr *end, uptr *offset,
+            char filename[], uptr filename_size, uptr *protection);
+  void Reset();
+  // In some cases, e.g. when running under a sandbox on Linux, ASan is unable
+  // to obtain the memory mappings. It should fall back to pre-cached data
+  // instead of aborting.
+  static void CacheMemoryMappings();
+
+  // Stores the list of mapped objects into an array.
+  uptr DumpListOfModules(LoadedModule *modules, uptr max_modules,
+                         string_predicate_t filter);
+
+  // Memory protection masks.
+  static const uptr kProtectionRead = 1;
+  static const uptr kProtectionWrite = 2;
+  static const uptr kProtectionExecute = 4;
+  static const uptr kProtectionShared = 8;
+
+ private:
+  void LoadFromCache();
+
+  // FIXME: Hide implementation details for different platforms in
+  // platform-specific files.
+# if SANITIZER_FREEBSD || SANITIZER_LINUX
+  ProcSelfMapsBuff proc_self_maps_;
+  const char *current_;
+
+  // Static mappings cache.
+  static ProcSelfMapsBuff cached_proc_self_maps_;
+  static StaticSpinMutex cache_lock_;  // protects cached_proc_self_maps_.
+# elif SANITIZER_MAC
+  template<u32 kLCSegment, typename SegmentCommand>
+  bool NextSegmentLoad(uptr *start, uptr *end, uptr *offset,
+                       char filename[], uptr filename_size,
+                       uptr *protection);
+  int current_image_;
+  u32 current_magic_;
+  u32 current_filetype_;
+  int current_load_cmd_count_;
+  char *current_load_cmd_addr_;
+# endif
+};
+
+typedef void (*fill_profile_f)(uptr start, uptr rss, bool file,
+                               /*out*/uptr *stats, uptr stats_size);
+
+// Parse the contents of /proc/self/smaps and generate a memory profile.
+// |cb| is a tool-specific callback that fills the |stats| array containing
+// |stats_size| elements.
+void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size);
+
+// Returns code range for the specified module.
+bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end);
+
+bool IsDecimal(char c);
+uptr ParseDecimal(const char **p);
+bool IsHex(char c);
+uptr ParseHex(const char **p);
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_PROCMAPS_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cc b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cc
new file mode 100644
index 0000000..d43432c
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cc
@@ -0,0 +1,181 @@
+//===-- sanitizer_procmaps_common.cc --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Information about the process mappings (common parts).
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+
+#include "sanitizer_common.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_procmaps.h"
+
+namespace __sanitizer {
+
+// Linker initialized.
+ProcSelfMapsBuff MemoryMappingLayout::cached_proc_self_maps_;
+StaticSpinMutex MemoryMappingLayout::cache_lock_;  // Linker initialized.
+
+static int TranslateDigit(char c) {
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  return -1;
+}
+
+// Parse a number and promote 'p' up to the first non-digit character.
+static uptr ParseNumber(const char **p, int base) {
+  uptr n = 0;
+  int d;
+  CHECK(base >= 2 && base <= 16);
+  while ((d = TranslateDigit(**p)) >= 0 && d < base) {
+    n = n * base + d;
+    (*p)++;
+  }
+  return n;
+}
+
+bool IsDecimal(char c) {
+  int d = TranslateDigit(c);
+  return d >= 0 && d < 10;
+}
+
+uptr ParseDecimal(const char **p) {
+  return ParseNumber(p, 10);
+}
+
+bool IsHex(char c) {
+  int d = TranslateDigit(c);
+  return d >= 0 && d < 16;
+}
+
+uptr ParseHex(const char **p) {
+  return ParseNumber(p, 16);
+}
+
+MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
+  ReadProcMaps(&proc_self_maps_);
+  if (cache_enabled) {
+    if (proc_self_maps_.mmaped_size == 0) {
+      LoadFromCache();
+      CHECK_GT(proc_self_maps_.len, 0);
+    }
+  } else {
+    CHECK_GT(proc_self_maps_.mmaped_size, 0);
+  }
+  Reset();
+  // FIXME: in the future we may want to cache the mappings on demand only.
+  if (cache_enabled)
+    CacheMemoryMappings();
+}
+
+MemoryMappingLayout::~MemoryMappingLayout() {
+  // Only unmap the buffer if it is different from the cached one. Otherwise
+  // it will be unmapped when the cache is refreshed.
+  if (proc_self_maps_.data != cached_proc_self_maps_.data) {
+    UnmapOrDie(proc_self_maps_.data, proc_self_maps_.mmaped_size);
+  }
+}
+
+void MemoryMappingLayout::Reset() {
+  current_ = proc_self_maps_.data;
+}
+
+// static
+void MemoryMappingLayout::CacheMemoryMappings() {
+  SpinMutexLock l(&cache_lock_);
+  // Don't invalidate the cache if the mappings are unavailable.
+  ProcSelfMapsBuff old_proc_self_maps;
+  old_proc_self_maps = cached_proc_self_maps_;
+  ReadProcMaps(&cached_proc_self_maps_);
+  if (cached_proc_self_maps_.mmaped_size == 0) {
+    cached_proc_self_maps_ = old_proc_self_maps;
+  } else {
+    if (old_proc_self_maps.mmaped_size) {
+      UnmapOrDie(old_proc_self_maps.data,
+                 old_proc_self_maps.mmaped_size);
+    }
+  }
+}
+
+void MemoryMappingLayout::LoadFromCache() {
+  SpinMutexLock l(&cache_lock_);
+  if (cached_proc_self_maps_.data) {
+    proc_self_maps_ = cached_proc_self_maps_;
+  }
+}
+
+uptr MemoryMappingLayout::DumpListOfModules(LoadedModule *modules,
+                                            uptr max_modules,
+                                            string_predicate_t filter) {
+  Reset();
+  uptr cur_beg, cur_end, cur_offset, prot;
+  InternalScopedString module_name(kMaxPathLength);
+  uptr n_modules = 0;
+  for (uptr i = 0; n_modules < max_modules &&
+                       Next(&cur_beg, &cur_end, &cur_offset, module_name.data(),
+                            module_name.size(), &prot);
+       i++) {
+    const char *cur_name = module_name.data();
+    if (cur_name[0] == '\0')
+      continue;
+    if (filter && !filter(cur_name))
+      continue;
+    // Don't subtract 'cur_beg' from the first entry:
+    // * If a binary is compiled w/o -pie, then the first entry in
+    //   process maps is likely the binary itself (all dynamic libs
+    //   are mapped higher in address space). For such a binary,
+    //   instruction offset in binary coincides with the actual
+    //   instruction address in virtual memory (as code section
+    //   is mapped to a fixed memory range).
+    // * If a binary is compiled with -pie, all the modules are
+    //   mapped high at address space (in particular, higher than
+    //   shadow memory of the tool), so the module can't be the
+    //   first entry.
+    uptr base_address = (i ? cur_beg : 0) - cur_offset;
+    LoadedModule *cur_module = &modules[n_modules];
+    cur_module->set(cur_name, base_address);
+    cur_module->addAddressRange(cur_beg, cur_end, prot & kProtectionExecute);
+    n_modules++;
+  }
+  return n_modules;
+}
+
+void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) {
+  char *smaps = nullptr;
+  uptr smaps_cap = 0;
+  uptr smaps_len = 0;
+  if (!ReadFileToBuffer("/proc/self/smaps", &smaps, &smaps_cap, &smaps_len))
+    return;
+  uptr start = 0;
+  bool file = false;
+  const char *pos = smaps;
+  while (pos < smaps + smaps_len) {
+    if (IsHex(pos[0])) {
+      start = ParseHex(&pos);
+      for (; *pos != '/' && *pos > '\n'; pos++) {}
+      file = *pos == '/';
+    } else if (internal_strncmp(pos, "Rss:", 4) == 0) {
+      while (!IsDecimal(*pos)) pos++;
+      uptr rss = ParseDecimal(&pos) * 1024;
+      cb(start, rss, file, stats, stats_size);
+    }
+    while (*pos++ != '\n') {}
+  }
+  UnmapOrDie(smaps, smaps_cap);
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_freebsd.cc b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_freebsd.cc
new file mode 100644
index 0000000..5011b1f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_freebsd.cc
@@ -0,0 +1,88 @@
+//===-- sanitizer_procmaps_freebsd.cc -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Information about the process mappings (FreeBSD-specific parts).
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_FREEBSD
+#include "sanitizer_common.h"
+#include "sanitizer_freebsd.h"
+#include "sanitizer_procmaps.h"
+
+#include <unistd.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+// Fix 'kinfo_vmentry' definition on FreeBSD prior v9.2 in 32-bit mode.
+#if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
+# include <osreldate.h>
+# if __FreeBSD_version <= 902001  // v9.2
+#  define kinfo_vmentry xkinfo_vmentry
+# endif
+#endif
+
+namespace __sanitizer {
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
+  const int Mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, getpid() };
+  size_t Size = 0;
+  int Err = sysctl(Mib, 4, NULL, &Size, NULL, 0);
+  CHECK_EQ(Err, 0);
+  CHECK_GT(Size, 0);
+
+  size_t MmapedSize = Size * 4 / 3;
+  void *VmMap = MmapOrDie(MmapedSize, "ReadProcMaps()");
+  Size = MmapedSize;
+  Err = sysctl(Mib, 4, VmMap, &Size, NULL, 0);
+  CHECK_EQ(Err, 0);
+
+  proc_maps->data = (char*)VmMap;
+  proc_maps->mmaped_size = MmapedSize;
+  proc_maps->len = Size;
+}
+
+bool MemoryMappingLayout::Next(uptr *start, uptr *end, uptr *offset,
+                               char filename[], uptr filename_size,
+                               uptr *protection) {
+  char *last = proc_self_maps_.data + proc_self_maps_.len;
+  if (current_ >= last) return false;
+  uptr dummy;
+  if (!start) start = &dummy;
+  if (!end) end = &dummy;
+  if (!offset) offset = &dummy;
+  if (!protection) protection = &dummy;
+  struct kinfo_vmentry *VmEntry = (struct kinfo_vmentry*)current_;
+
+  *start = (uptr)VmEntry->kve_start;
+  *end = (uptr)VmEntry->kve_end;
+  *offset = (uptr)VmEntry->kve_offset;
+
+  *protection = 0;
+  if ((VmEntry->kve_protection & KVME_PROT_READ) != 0)
+    *protection |= kProtectionRead;
+  if ((VmEntry->kve_protection & KVME_PROT_WRITE) != 0)
+    *protection |= kProtectionWrite;
+  if ((VmEntry->kve_protection & KVME_PROT_EXEC) != 0)
+    *protection |= kProtectionExecute;
+
+  if (filename != NULL && filename_size > 0) {
+    internal_snprintf(filename,
+                      Min(filename_size, (uptr)PATH_MAX),
+                      "%s", VmEntry->kve_path);
+  }
+
+  current_ += VmEntry->kve_structsize;
+
+  return true;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FREEBSD
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_linux.cc b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_linux.cc
new file mode 100644
index 0000000..b6fb703
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_linux.cc
@@ -0,0 +1,90 @@
+//===-- sanitizer_procmaps_linux.cc ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Information about the process mappings (Linux-specific parts).
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_LINUX
+#include "sanitizer_common.h"
+#include "sanitizer_procmaps.h"
+
+namespace __sanitizer {
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
+  CHECK(ReadFileToBuffer("/proc/self/maps", &proc_maps->data,
+                         &proc_maps->mmaped_size, &proc_maps->len));
+}
+
+static bool IsOneOf(char c, char c1, char c2) {
+  return c == c1 || c == c2;
+}
+
+bool MemoryMappingLayout::Next(uptr *start, uptr *end, uptr *offset,
+                               char filename[], uptr filename_size,
+                               uptr *protection) {
+  char *last = proc_self_maps_.data + proc_self_maps_.len;
+  if (current_ >= last) return false;
+  uptr dummy;
+  if (!start) start = &dummy;
+  if (!end) end = &dummy;
+  if (!offset) offset = &dummy;
+  if (!protection) protection = &dummy;
+  char *next_line = (char*)internal_memchr(current_, '\n', last - current_);
+  if (next_line == 0)
+    next_line = last;
+  // Example: 08048000-08056000 r-xp 00000000 03:0c 64593   /foo/bar
+  *start = ParseHex(&current_);
+  CHECK_EQ(*current_++, '-');
+  *end = ParseHex(&current_);
+  CHECK_EQ(*current_++, ' ');
+  CHECK(IsOneOf(*current_, '-', 'r'));
+  *protection = 0;
+  if (*current_++ == 'r')
+    *protection |= kProtectionRead;
+  CHECK(IsOneOf(*current_, '-', 'w'));
+  if (*current_++ == 'w')
+    *protection |= kProtectionWrite;
+  CHECK(IsOneOf(*current_, '-', 'x'));
+  if (*current_++ == 'x')
+    *protection |= kProtectionExecute;
+  CHECK(IsOneOf(*current_, 's', 'p'));
+  if (*current_++ == 's')
+    *protection |= kProtectionShared;
+  CHECK_EQ(*current_++, ' ');
+  *offset = ParseHex(&current_);
+  CHECK_EQ(*current_++, ' ');
+  ParseHex(&current_);
+  CHECK_EQ(*current_++, ':');
+  ParseHex(&current_);
+  CHECK_EQ(*current_++, ' ');
+  while (IsDecimal(*current_))
+    current_++;
+  // Qemu may lack the trailing space.
+  // https://github.com/google/sanitizers/issues/160
+  // CHECK_EQ(*current_++, ' ');
+  // Skip spaces.
+  while (current_ < next_line && *current_ == ' ')
+    current_++;
+  // Fill in the filename.
+  uptr i = 0;
+  while (current_ < next_line) {
+    if (filename && i < filename_size - 1)
+      filename[i++] = *current_;
+    current_++;
+  }
+  if (filename && i < filename_size)
+    filename[i] = 0;
+  current_ = next_line + 1;
+  return true;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_mac.cc b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_mac.cc
new file mode 100644
index 0000000..d10881e
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_mac.cc
@@ -0,0 +1,190 @@
+//===-- sanitizer_procmaps_mac.cc -----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Information about the process mappings (Mac-specific parts).
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_MAC
+#include "sanitizer_common.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_procmaps.h"
+
+#include <mach-o/dyld.h>
+#include <mach-o/loader.h>
+
+namespace __sanitizer {
+
+MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
+  Reset();
+}
+
+MemoryMappingLayout::~MemoryMappingLayout() {
+}
+
+// More information about Mach-O headers can be found in mach-o/loader.h
+// Each Mach-O image has a header (mach_header or mach_header_64) starting with
+// a magic number, and a list of linker load commands directly following the
+// header.
+// A load command is at least two 32-bit words: the command type and the
+// command size in bytes. We're interested only in segment load commands
+// (LC_SEGMENT and LC_SEGMENT_64), which tell that a part of the file is mapped
+// into the task's address space.
+// The |vmaddr|, |vmsize| and |fileoff| fields of segment_command or
+// segment_command_64 correspond to the memory address, memory size and the
+// file offset of the current memory segment.
+// Because these fields are taken from the images as is, one needs to add
+// _dyld_get_image_vmaddr_slide() to get the actual addresses at runtime.
+
+void MemoryMappingLayout::Reset() {
+  // Count down from the top.
+  // TODO(glider): as per man 3 dyld, iterating over the headers with
+  // _dyld_image_count is thread-unsafe. We need to register callbacks for
+  // adding and removing images which will invalidate the MemoryMappingLayout
+  // state.
+  current_image_ = _dyld_image_count();
+  current_load_cmd_count_ = -1;
+  current_load_cmd_addr_ = 0;
+  current_magic_ = 0;
+  current_filetype_ = 0;
+}
+
+// static
+void MemoryMappingLayout::CacheMemoryMappings() {
+  // No-op on Mac for now.
+}
+
+void MemoryMappingLayout::LoadFromCache() {
+  // No-op on Mac for now.
+}
+
+// Next and NextSegmentLoad were inspired by base/sysinfo.cc in
+// Google Perftools, https://github.com/gperftools/gperftools.
+
+// NextSegmentLoad scans the current image for the next segment load command
+// and returns the start and end addresses and file offset of the corresponding
+// segment.
+// Note that the segment addresses are not necessarily sorted.
+template<u32 kLCSegment, typename SegmentCommand>
+bool MemoryMappingLayout::NextSegmentLoad(
+    uptr *start, uptr *end, uptr *offset,
+    char filename[], uptr filename_size, uptr *protection) {
+  const char* lc = current_load_cmd_addr_;
+  current_load_cmd_addr_ += ((const load_command *)lc)->cmdsize;
+  if (((const load_command *)lc)->cmd == kLCSegment) {
+    const sptr dlloff = _dyld_get_image_vmaddr_slide(current_image_);
+    const SegmentCommand* sc = (const SegmentCommand *)lc;
+    if (start) *start = sc->vmaddr + dlloff;
+    if (protection) {
+      // Return the initial protection.
+      *protection = sc->initprot;
+    }
+    if (end) *end = sc->vmaddr + sc->vmsize + dlloff;
+    if (offset) {
+      if (current_filetype_ == /*MH_EXECUTE*/ 0x2) {
+        *offset = sc->vmaddr;
+      } else {
+        *offset = sc->fileoff;
+      }
+    }
+    if (filename) {
+      internal_strncpy(filename, _dyld_get_image_name(current_image_),
+                       filename_size);
+    }
+    return true;
+  }
+  return false;
+}
+
+bool MemoryMappingLayout::Next(uptr *start, uptr *end, uptr *offset,
+                               char filename[], uptr filename_size,
+                               uptr *protection) {
+  for (; current_image_ >= 0; current_image_--) {
+    const mach_header* hdr = _dyld_get_image_header(current_image_);
+    if (!hdr) continue;
+    if (current_load_cmd_count_ < 0) {
+      // Set up for this image;
+      current_load_cmd_count_ = hdr->ncmds;
+      current_magic_ = hdr->magic;
+      current_filetype_ = hdr->filetype;
+      switch (current_magic_) {
+#ifdef MH_MAGIC_64
+        case MH_MAGIC_64: {
+          current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header_64);
+          break;
+        }
+#endif
+        case MH_MAGIC: {
+          current_load_cmd_addr_ = (char*)hdr + sizeof(mach_header);
+          break;
+        }
+        default: {
+          continue;
+        }
+      }
+    }
+
+    for (; current_load_cmd_count_ >= 0; current_load_cmd_count_--) {
+      switch (current_magic_) {
+        // current_magic_ may be only one of MH_MAGIC, MH_MAGIC_64.
+#ifdef MH_MAGIC_64
+        case MH_MAGIC_64: {
+          if (NextSegmentLoad<LC_SEGMENT_64, struct segment_command_64>(
+                  start, end, offset, filename, filename_size, protection))
+            return true;
+          break;
+        }
+#endif
+        case MH_MAGIC: {
+          if (NextSegmentLoad<LC_SEGMENT, struct segment_command>(
+                  start, end, offset, filename, filename_size, protection))
+            return true;
+          break;
+        }
+      }
+    }
+    // If we get here, no more load_cmd's in this image talk about
+    // segments.  Go on to the next image.
+  }
+  return false;
+}
+
+uptr MemoryMappingLayout::DumpListOfModules(LoadedModule *modules,
+                                            uptr max_modules,
+                                            string_predicate_t filter) {
+  Reset();
+  uptr cur_beg, cur_end, prot;
+  InternalScopedString module_name(kMaxPathLength);
+  uptr n_modules = 0;
+  for (uptr i = 0; n_modules < max_modules &&
+                       Next(&cur_beg, &cur_end, 0, module_name.data(),
+                            module_name.size(), &prot);
+       i++) {
+    const char *cur_name = module_name.data();
+    if (cur_name[0] == '\0')
+      continue;
+    if (filter && !filter(cur_name))
+      continue;
+    LoadedModule *cur_module = nullptr;
+    if (n_modules > 0 &&
+        0 == internal_strcmp(cur_name, modules[n_modules - 1].full_name())) {
+      cur_module = &modules[n_modules - 1];
+    } else {
+      cur_module = &modules[n_modules];
+      cur_module->set(cur_name, cur_beg);
+      n_modules++;
+    }
+    cur_module->addAddressRange(cur_beg, cur_end, prot & kProtectionExecute);
+  }
+  return n_modules;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_quarantine.h b/compiler-rt/lib/sanitizer_common/sanitizer_quarantine.h
new file mode 100644
index 0000000..9e0bf2d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_quarantine.h
@@ -0,0 +1,185 @@
+//===-- sanitizer_quarantine.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Memory quarantine for AddressSanitizer and potentially other tools.
+// Quarantine caches some specified amount of memory in per-thread caches,
+// then evicts to global FIFO queue. When the queue reaches specified threshold,
+// oldest memory is recycled.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_QUARANTINE_H
+#define SANITIZER_QUARANTINE_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_list.h"
+
+namespace __sanitizer {
+
+template<typename Node> class QuarantineCache;
+
+struct QuarantineBatch {
+  static const uptr kSize = 1021;
+  QuarantineBatch *next;
+  uptr size;
+  uptr count;
+  void *batch[kSize];
+};
+
+COMPILER_CHECK(sizeof(QuarantineBatch) <= (1 << 13));  // 8Kb.
+
+// The callback interface is:
+// void Callback::Recycle(Node *ptr);
+// void *cb.Allocate(uptr size);
+// void cb.Deallocate(void *ptr);
+template<typename Callback, typename Node>
+class Quarantine {
+ public:
+  typedef QuarantineCache<Callback> Cache;
+
+  explicit Quarantine(LinkerInitialized)
+      : cache_(LINKER_INITIALIZED) {
+  }
+
+  void Init(uptr size, uptr cache_size) {
+    atomic_store(&max_size_, size, memory_order_release);
+    atomic_store(&min_size_, size / 10 * 9,
+                 memory_order_release); // 90% of max size.
+    max_cache_size_ = cache_size;
+  }
+
+  uptr GetSize() const { return atomic_load(&max_size_, memory_order_acquire); }
+
+  void Put(Cache *c, Callback cb, Node *ptr, uptr size) {
+    c->Enqueue(cb, ptr, size);
+    if (c->Size() > max_cache_size_)
+      Drain(c, cb);
+  }
+
+  void NOINLINE Drain(Cache *c, Callback cb) {
+    {
+      SpinMutexLock l(&cache_mutex_);
+      cache_.Transfer(c);
+    }
+    if (cache_.Size() > GetSize() && recycle_mutex_.TryLock())
+      Recycle(cb);
+  }
+
+ private:
+  // Read-only data.
+  char pad0_[kCacheLineSize];
+  atomic_uintptr_t max_size_;
+  atomic_uintptr_t min_size_;
+  uptr max_cache_size_;
+  char pad1_[kCacheLineSize];
+  SpinMutex cache_mutex_;
+  SpinMutex recycle_mutex_;
+  Cache cache_;
+  char pad2_[kCacheLineSize];
+
+  void NOINLINE Recycle(Callback cb) {
+    Cache tmp;
+    uptr min_size = atomic_load(&min_size_, memory_order_acquire);
+    {
+      SpinMutexLock l(&cache_mutex_);
+      while (cache_.Size() > min_size) {
+        QuarantineBatch *b = cache_.DequeueBatch();
+        tmp.EnqueueBatch(b);
+      }
+    }
+    recycle_mutex_.Unlock();
+    DoRecycle(&tmp, cb);
+  }
+
+  void NOINLINE DoRecycle(Cache *c, Callback cb) {
+    while (QuarantineBatch *b = c->DequeueBatch()) {
+      const uptr kPrefetch = 16;
+      for (uptr i = 0; i < kPrefetch; i++)
+        PREFETCH(b->batch[i]);
+      for (uptr i = 0; i < b->count; i++) {
+        PREFETCH(b->batch[i + kPrefetch]);
+        cb.Recycle((Node*)b->batch[i]);
+      }
+      cb.Deallocate(b);
+    }
+  }
+};
+
+// Per-thread cache of memory blocks.
+template<typename Callback>
+class QuarantineCache {
+ public:
+  explicit QuarantineCache(LinkerInitialized) {
+  }
+
+  QuarantineCache()
+      : size_() {
+    list_.clear();
+  }
+
+  uptr Size() const {
+    return atomic_load(&size_, memory_order_relaxed);
+  }
+
+  void Enqueue(Callback cb, void *ptr, uptr size) {
+    if (list_.empty() || list_.back()->count == QuarantineBatch::kSize) {
+      AllocBatch(cb);
+      size += sizeof(QuarantineBatch);  // Count the batch in Quarantine size.
+    }
+    QuarantineBatch *b = list_.back();
+    CHECK(b);
+    b->batch[b->count++] = ptr;
+    b->size += size;
+    SizeAdd(size);
+  }
+
+  void Transfer(QuarantineCache *c) {
+    list_.append_back(&c->list_);
+    SizeAdd(c->Size());
+    atomic_store(&c->size_, 0, memory_order_relaxed);
+  }
+
+  void EnqueueBatch(QuarantineBatch *b) {
+    list_.push_back(b);
+    SizeAdd(b->size);
+  }
+
+  QuarantineBatch *DequeueBatch() {
+    if (list_.empty())
+      return nullptr;
+    QuarantineBatch *b = list_.front();
+    list_.pop_front();
+    SizeSub(b->size);
+    return b;
+  }
+
+ private:
+  IntrusiveList<QuarantineBatch> list_;
+  atomic_uintptr_t size_;
+
+  void SizeAdd(uptr add) {
+    atomic_store(&size_, Size() + add, memory_order_relaxed);
+  }
+  void SizeSub(uptr sub) {
+    atomic_store(&size_, Size() - sub, memory_order_relaxed);
+  }
+
+  NOINLINE QuarantineBatch* AllocBatch(Callback cb) {
+    QuarantineBatch *b = (QuarantineBatch *)cb.Allocate(sizeof(*b));
+    CHECK(b);
+    b->count = 0;
+    b->size = 0;
+    list_.push_back(b);
+    return b;
+  }
+};
+} // namespace __sanitizer
+
+#endif // SANITIZER_QUARANTINE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_report_decorator.h b/compiler-rt/lib/sanitizer_common/sanitizer_report_decorator.h
new file mode 100644
index 0000000..86536aa
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_report_decorator.h
@@ -0,0 +1,47 @@
+//===-- sanitizer_report_decorator.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tags to decorate the sanitizer reports.
+// Currently supported tags:
+//   * None.
+//   * ANSI color sequences.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_REPORT_DECORATOR_H
+#define SANITIZER_REPORT_DECORATOR_H
+
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+class SanitizerCommonDecorator {
+  // FIXME: This is not portable. It assumes the special strings are printed to
+  // stdout, which is not the case on Windows (see SetConsoleTextAttribute()).
+ public:
+  SanitizerCommonDecorator() : ansi_(ColorizeReports()) {}
+  const char *Bold()    const { return ansi_ ? "\033[1m" : ""; }
+  const char *Default() const { return ansi_ ? "\033[1m\033[0m"  : ""; }
+  const char *Warning()    { return Red(); }
+  const char *EndWarning() { return Default(); }
+ protected:
+  const char *Black()   const { return ansi_ ? "\033[1m\033[30m" : ""; }
+  const char *Red()     const { return ansi_ ? "\033[1m\033[31m" : ""; }
+  const char *Green()   const { return ansi_ ? "\033[1m\033[32m" : ""; }
+  const char *Yellow()  const { return ansi_ ? "\033[1m\033[33m" : ""; }
+  const char *Blue()    const { return ansi_ ? "\033[1m\033[34m" : ""; }
+  const char *Magenta() const { return ansi_ ? "\033[1m\033[35m" : ""; }
+  const char *Cyan()    const { return ansi_ ? "\033[1m\033[36m" : ""; }
+  const char *White()   const { return ansi_ ? "\033[1m\033[37m" : ""; }
+ private:
+  bool ansi_;
+};
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_REPORT_DECORATOR_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cc b/compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cc
new file mode 100644
index 0000000..985193d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cc
@@ -0,0 +1,163 @@
+//===-- sanitizer_stackdepot.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_stackdepot.h"
+
+#include "sanitizer_common.h"
+#include "sanitizer_stackdepotbase.h"
+
+namespace __sanitizer {
+
+struct StackDepotNode {
+  StackDepotNode *link;
+  u32 id;
+  atomic_uint32_t hash_and_use_count; // hash_bits : 12; use_count : 20;
+  u32 size;
+  u32 tag;
+  uptr stack[1];  // [size]
+
+  static const u32 kTabSizeLog = 20;
+  // Lower kTabSizeLog bits are equal for all items in one bucket.
+  // We use these bits to store the per-stack use counter.
+  static const u32 kUseCountBits = kTabSizeLog;
+  static const u32 kMaxUseCount = 1 << kUseCountBits;
+  static const u32 kUseCountMask = (1 << kUseCountBits) - 1;
+  static const u32 kHashMask = ~kUseCountMask;
+
+  typedef StackTrace args_type;
+  bool eq(u32 hash, const args_type &args) const {
+    u32 hash_bits =
+        atomic_load(&hash_and_use_count, memory_order_relaxed) & kHashMask;
+    if ((hash & kHashMask) != hash_bits || args.size != size || args.tag != tag)
+      return false;
+    uptr i = 0;
+    for (; i < size; i++) {
+      if (stack[i] != args.trace[i]) return false;
+    }
+    return true;
+  }
+  static uptr storage_size(const args_type &args) {
+    return sizeof(StackDepotNode) + (args.size - 1) * sizeof(uptr);
+  }
+  static u32 hash(const args_type &args) {
+    // murmur2
+    const u32 m = 0x5bd1e995;
+    const u32 seed = 0x9747b28c;
+    const u32 r = 24;
+    u32 h = seed ^ (args.size * sizeof(uptr));
+    for (uptr i = 0; i < args.size; i++) {
+      u32 k = args.trace[i];
+      k *= m;
+      k ^= k >> r;
+      k *= m;
+      h *= m;
+      h ^= k;
+    }
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+    return h;
+  }
+  static bool is_valid(const args_type &args) {
+    return args.size > 0 && args.trace;
+  }
+  void store(const args_type &args, u32 hash) {
+    atomic_store(&hash_and_use_count, hash & kHashMask, memory_order_relaxed);
+    size = args.size;
+    tag = args.tag;
+    internal_memcpy(stack, args.trace, size * sizeof(uptr));
+  }
+  args_type load() const {
+    return args_type(&stack[0], size, tag);
+  }
+  StackDepotHandle get_handle() { return StackDepotHandle(this); }
+
+  typedef StackDepotHandle handle_type;
+};
+
+COMPILER_CHECK(StackDepotNode::kMaxUseCount == (u32)kStackDepotMaxUseCount);
+
+u32 StackDepotHandle::id() { return node_->id; }
+int StackDepotHandle::use_count() {
+  return atomic_load(&node_->hash_and_use_count, memory_order_relaxed) &
+         StackDepotNode::kUseCountMask;
+}
+void StackDepotHandle::inc_use_count_unsafe() {
+  u32 prev =
+      atomic_fetch_add(&node_->hash_and_use_count, 1, memory_order_relaxed) &
+      StackDepotNode::kUseCountMask;
+  CHECK_LT(prev + 1, StackDepotNode::kMaxUseCount);
+}
+
+// FIXME(dvyukov): this single reserved bit is used in TSan.
+typedef StackDepotBase<StackDepotNode, 1, StackDepotNode::kTabSizeLog>
+    StackDepot;
+static StackDepot theDepot;
+
+StackDepotStats *StackDepotGetStats() {
+  return theDepot.GetStats();
+}
+
+u32 StackDepotPut(StackTrace stack) {
+  StackDepotHandle h = theDepot.Put(stack);
+  return h.valid() ? h.id() : 0;
+}
+
+StackDepotHandle StackDepotPut_WithHandle(StackTrace stack) {
+  return theDepot.Put(stack);
+}
+
+StackTrace StackDepotGet(u32 id) {
+  return theDepot.Get(id);
+}
+
+void StackDepotLockAll() {
+  theDepot.LockAll();
+}
+
+void StackDepotUnlockAll() {
+  theDepot.UnlockAll();
+}
+
+bool StackDepotReverseMap::IdDescPair::IdComparator(
+    const StackDepotReverseMap::IdDescPair &a,
+    const StackDepotReverseMap::IdDescPair &b) {
+  return a.id < b.id;
+}
+
+StackDepotReverseMap::StackDepotReverseMap()
+    : map_(StackDepotGetStats()->n_uniq_ids + 100) {
+  for (int idx = 0; idx < StackDepot::kTabSize; idx++) {
+    atomic_uintptr_t *p = &theDepot.tab[idx];
+    uptr v = atomic_load(p, memory_order_consume);
+    StackDepotNode *s = (StackDepotNode*)(v & ~1);
+    for (; s; s = s->link) {
+      IdDescPair pair = {s->id, s};
+      map_.push_back(pair);
+    }
+  }
+  InternalSort(&map_, map_.size(), IdDescPair::IdComparator);
+}
+
+StackTrace StackDepotReverseMap::Get(u32 id) {
+  if (!map_.size())
+    return StackTrace();
+  IdDescPair pair = {id, nullptr};
+  uptr idx = InternalBinarySearch(map_, 0, map_.size(), pair,
+                                  IdDescPair::IdComparator);
+  if (idx > map_.size())
+    return StackTrace();
+  return map_[idx].desc->load();
+}
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.h b/compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.h
new file mode 100644
index 0000000..cb73450
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.h
@@ -0,0 +1,72 @@
+//===-- sanitizer_stackdepot.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_STACKDEPOT_H
+#define SANITIZER_STACKDEPOT_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+// StackDepot efficiently stores huge amounts of stack traces.
+struct StackDepotNode;
+struct StackDepotHandle {
+  StackDepotNode *node_;
+  StackDepotHandle() : node_(nullptr) {}
+  explicit StackDepotHandle(StackDepotNode *node) : node_(node) {}
+  bool valid() { return node_; }
+  u32 id();
+  int use_count();
+  void inc_use_count_unsafe();
+};
+
+const int kStackDepotMaxUseCount = 1U << 20;
+
+StackDepotStats *StackDepotGetStats();
+u32 StackDepotPut(StackTrace stack);
+StackDepotHandle StackDepotPut_WithHandle(StackTrace stack);
+// Retrieves a stored stack trace by the id.
+StackTrace StackDepotGet(u32 id);
+
+void StackDepotLockAll();
+void StackDepotUnlockAll();
+
+// Instantiating this class creates a snapshot of StackDepot which can be
+// efficiently queried with StackDepotGet(). You can use it concurrently with
+// StackDepot, but the snapshot is only guaranteed to contain those stack traces
+// which were stored before it was instantiated.
+class StackDepotReverseMap {
+ public:
+  StackDepotReverseMap();
+  StackTrace Get(u32 id);
+
+ private:
+  struct IdDescPair {
+    u32 id;
+    StackDepotNode *desc;
+
+    static bool IdComparator(const IdDescPair &a, const IdDescPair &b);
+  };
+
+  InternalMmapVector<IdDescPair> map_;
+
+  // Disallow evil constructors.
+  StackDepotReverseMap(const StackDepotReverseMap&);
+  void operator=(const StackDepotReverseMap&);
+};
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_STACKDEPOT_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stackdepotbase.h b/compiler-rt/lib/sanitizer_common/sanitizer_stackdepotbase.h
new file mode 100644
index 0000000..4ec77b4
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stackdepotbase.h
@@ -0,0 +1,178 @@
+//===-- sanitizer_stackdepotbase.h ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of a mapping from arbitrary values to unique 32-bit
+// identifiers.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_STACKDEPOTBASE_H
+#define SANITIZER_STACKDEPOTBASE_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_persistent_allocator.h"
+
+namespace __sanitizer {
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+class StackDepotBase {
+ public:
+  typedef typename Node::args_type args_type;
+  typedef typename Node::handle_type handle_type;
+  // Maps stack trace to an unique id.
+  handle_type Put(args_type args, bool *inserted = nullptr);
+  // Retrieves a stored stack trace by the id.
+  args_type Get(u32 id);
+
+  StackDepotStats *GetStats() { return &stats; }
+
+  void LockAll();
+  void UnlockAll();
+
+ private:
+  static Node *find(Node *s, args_type args, u32 hash);
+  static Node *lock(atomic_uintptr_t *p);
+  static void unlock(atomic_uintptr_t *p, Node *s);
+
+  static const int kTabSize = 1 << kTabSizeLog;  // Hash table size.
+  static const int kPartBits = 8;
+  static const int kPartShift = sizeof(u32) * 8 - kPartBits - kReservedBits;
+  static const int kPartCount =
+      1 << kPartBits;  // Number of subparts in the table.
+  static const int kPartSize = kTabSize / kPartCount;
+  static const int kMaxId = 1 << kPartShift;
+
+  atomic_uintptr_t tab[kTabSize];   // Hash table of Node's.
+  atomic_uint32_t seq[kPartCount];  // Unique id generators.
+
+  StackDepotStats stats;
+
+  friend class StackDepotReverseMap;
+};
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+Node *StackDepotBase<Node, kReservedBits, kTabSizeLog>::find(Node *s,
+                                                             args_type args,
+                                                             u32 hash) {
+  // Searches linked list s for the stack, returns its id.
+  for (; s; s = s->link) {
+    if (s->eq(hash, args)) {
+      return s;
+    }
+  }
+  return nullptr;
+}
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+Node *StackDepotBase<Node, kReservedBits, kTabSizeLog>::lock(
+    atomic_uintptr_t *p) {
+  // Uses the pointer lsb as mutex.
+  for (int i = 0;; i++) {
+    uptr cmp = atomic_load(p, memory_order_relaxed);
+    if ((cmp & 1) == 0 &&
+        atomic_compare_exchange_weak(p, &cmp, cmp | 1, memory_order_acquire))
+      return (Node *)cmp;
+    if (i < 10)
+      proc_yield(10);
+    else
+      internal_sched_yield();
+  }
+}
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+void StackDepotBase<Node, kReservedBits, kTabSizeLog>::unlock(
+    atomic_uintptr_t *p, Node *s) {
+  DCHECK_EQ((uptr)s & 1, 0);
+  atomic_store(p, (uptr)s, memory_order_release);
+}
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+typename StackDepotBase<Node, kReservedBits, kTabSizeLog>::handle_type
+StackDepotBase<Node, kReservedBits, kTabSizeLog>::Put(args_type args,
+                                                      bool *inserted) {
+  if (inserted) *inserted = false;
+  if (!Node::is_valid(args)) return handle_type();
+  uptr h = Node::hash(args);
+  atomic_uintptr_t *p = &tab[h % kTabSize];
+  uptr v = atomic_load(p, memory_order_consume);
+  Node *s = (Node *)(v & ~1);
+  // First, try to find the existing stack.
+  Node *node = find(s, args, h);
+  if (node) return node->get_handle();
+  // If failed, lock, retry and insert new.
+  Node *s2 = lock(p);
+  if (s2 != s) {
+    node = find(s2, args, h);
+    if (node) {
+      unlock(p, s2);
+      return node->get_handle();
+    }
+  }
+  uptr part = (h % kTabSize) / kPartSize;
+  u32 id = atomic_fetch_add(&seq[part], 1, memory_order_relaxed) + 1;
+  stats.n_uniq_ids++;
+  CHECK_LT(id, kMaxId);
+  id |= part << kPartShift;
+  CHECK_NE(id, 0);
+  CHECK_EQ(id & (((u32)-1) >> kReservedBits), id);
+  uptr memsz = Node::storage_size(args);
+  s = (Node *)PersistentAlloc(memsz);
+  stats.allocated += memsz;
+  s->id = id;
+  s->store(args, h);
+  s->link = s2;
+  unlock(p, s);
+  if (inserted) *inserted = true;
+  return s->get_handle();
+}
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+typename StackDepotBase<Node, kReservedBits, kTabSizeLog>::args_type
+StackDepotBase<Node, kReservedBits, kTabSizeLog>::Get(u32 id) {
+  if (id == 0) {
+    return args_type();
+  }
+  CHECK_EQ(id & (((u32)-1) >> kReservedBits), id);
+  // High kPartBits contain part id, so we need to scan at most kPartSize lists.
+  uptr part = id >> kPartShift;
+  for (int i = 0; i != kPartSize; i++) {
+    uptr idx = part * kPartSize + i;
+    CHECK_LT(idx, kTabSize);
+    atomic_uintptr_t *p = &tab[idx];
+    uptr v = atomic_load(p, memory_order_consume);
+    Node *s = (Node *)(v & ~1);
+    for (; s; s = s->link) {
+      if (s->id == id) {
+        return s->load();
+      }
+    }
+  }
+  return args_type();
+}
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+void StackDepotBase<Node, kReservedBits, kTabSizeLog>::LockAll() {
+  for (int i = 0; i < kTabSize; ++i) {
+    lock(&tab[i]);
+  }
+}
+
+template <class Node, int kReservedBits, int kTabSizeLog>
+void StackDepotBase<Node, kReservedBits, kTabSizeLog>::UnlockAll() {
+  for (int i = 0; i < kTabSize; ++i) {
+    atomic_uintptr_t *p = &tab[i];
+    uptr s = atomic_load(p, memory_order_relaxed);
+    unlock(p, (Node *)(s & ~1UL));
+  }
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_STACKDEPOTBASE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cc b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cc
new file mode 100644
index 0000000..7862575
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cc
@@ -0,0 +1,129 @@
+//===-- sanitizer_stacktrace.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+uptr StackTrace::GetNextInstructionPc(uptr pc) {
+#if defined(__mips__)
+  return pc + 8;
+#elif defined(__powerpc__)
+  return pc + 4;
+#else
+  return pc + 1;
+#endif
+}
+
+uptr StackTrace::GetCurrentPc() {
+  return GET_CALLER_PC();
+}
+
+void BufferedStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
+  size = cnt + !!extra_top_pc;
+  CHECK_LE(size, kStackTraceMax);
+  internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
+  if (extra_top_pc)
+    trace_buffer[cnt] = extra_top_pc;
+  top_frame_bp = 0;
+}
+
+// Check if given pointer points into allocated stack area.
+static inline bool IsValidFrame(uptr frame, uptr stack_top, uptr stack_bottom) {
+  return frame > stack_bottom && frame < stack_top - 2 * sizeof (uhwptr);
+}
+
+// In GCC on ARM bp points to saved lr, not fp, so we should check the next
+// cell in stack to be a saved frame pointer. GetCanonicFrame returns the
+// pointer to saved frame pointer in any case.
+static inline uhwptr *GetCanonicFrame(uptr bp,
+                                      uptr stack_top,
+                                      uptr stack_bottom) {
+#ifdef __arm__
+  if (!IsValidFrame(bp, stack_top, stack_bottom)) return 0;
+  uhwptr *bp_prev = (uhwptr *)bp;
+  if (IsValidFrame((uptr)bp_prev[0], stack_top, stack_bottom)) return bp_prev;
+  // The next frame pointer does not look right. This could be a GCC frame, step
+  // back by 1 word and try again.
+  if (IsValidFrame((uptr)bp_prev[-1], stack_top, stack_bottom))
+    return bp_prev - 1;
+  // Nope, this does not look right either. This means the frame after next does
+  // not have a valid frame pointer, but we can still extract the caller PC.
+  // Unfortunately, there is no way to decide between GCC and LLVM frame
+  // layouts. Assume LLVM.
+  return bp_prev;
+#else
+  return (uhwptr*)bp;
+#endif
+}
+
+void BufferedStackTrace::FastUnwindStack(uptr pc, uptr bp, uptr stack_top,
+                                         uptr stack_bottom, u32 max_depth) {
+  CHECK_GE(max_depth, 2);
+  trace_buffer[0] = pc;
+  size = 1;
+  if (stack_top < 4096) return;  // Sanity check for stack top.
+  uhwptr *frame = GetCanonicFrame(bp, stack_top, stack_bottom);
+  // Lowest possible address that makes sense as the next frame pointer.
+  // Goes up as we walk the stack.
+  uptr bottom = stack_bottom;
+  // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
+  while (IsValidFrame((uptr)frame, stack_top, bottom) &&
+         IsAligned((uptr)frame, sizeof(*frame)) &&
+         size < max_depth) {
+#ifdef __powerpc__
+    // PowerPC ABIs specify that the return address is saved at offset
+    // 16 of the *caller's* stack frame.  Thus we must dereference the
+    // back chain to find the caller frame before extracting it.
+    uhwptr *caller_frame = (uhwptr*)frame[0];
+    if (!IsValidFrame((uptr)caller_frame, stack_top, bottom) ||
+        !IsAligned((uptr)caller_frame, sizeof(uhwptr)))
+      break;
+    uhwptr pc1 = caller_frame[2];
+#else
+    uhwptr pc1 = frame[1];
+#endif
+    if (pc1 != pc) {
+      trace_buffer[size++] = (uptr) pc1;
+    }
+    bottom = (uptr)frame;
+    frame = GetCanonicFrame((uptr)frame[0], stack_top, bottom);
+  }
+}
+
+static bool MatchPc(uptr cur_pc, uptr trace_pc, uptr threshold) {
+  return cur_pc - trace_pc <= threshold || trace_pc - cur_pc <= threshold;
+}
+
+void BufferedStackTrace::PopStackFrames(uptr count) {
+  CHECK_LT(count, size);
+  size -= count;
+  for (uptr i = 0; i < size; ++i) {
+    trace_buffer[i] = trace_buffer[i + count];
+  }
+}
+
+uptr BufferedStackTrace::LocatePcInTrace(uptr pc) {
+  // Use threshold to find PC in stack trace, as PC we want to unwind from may
+  // slightly differ from return address in the actual unwinded stack trace.
+  const int kPcThreshold = 320;
+  for (uptr i = 0; i < size; ++i) {
+    if (MatchPc(pc, trace[i], kPcThreshold))
+      return i;
+  }
+  return 0;
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h
new file mode 100644
index 0000000..969cedb
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h
@@ -0,0 +1,136 @@
+//===-- sanitizer_stacktrace.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_STACKTRACE_H
+#define SANITIZER_STACKTRACE_H
+
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+static const u32 kStackTraceMax = 256;
+
+#if SANITIZER_LINUX &&  (defined(__sparc__) || defined(__mips__))
+# define SANITIZER_CAN_FAST_UNWIND 0
+#elif SANITIZER_WINDOWS
+# define SANITIZER_CAN_FAST_UNWIND 0
+#else
+# define SANITIZER_CAN_FAST_UNWIND 1
+#endif
+
+// Fast unwind is the only option on Mac for now; we will need to
+// revisit this macro when slow unwind works on Mac, see
+// https://github.com/google/sanitizers/issues/137
+#if SANITIZER_MAC
+# define SANITIZER_CAN_SLOW_UNWIND 0
+#else
+# define SANITIZER_CAN_SLOW_UNWIND 1
+#endif
+
+struct StackTrace {
+  const uptr *trace;
+  u32 size;
+  u32 tag;
+
+  static const int TAG_UNKNOWN = 0;
+  static const int TAG_ALLOC = 1;
+  static const int TAG_DEALLOC = 2;
+  static const int TAG_CUSTOM = 100; // Tool specific tags start here.
+
+  StackTrace() : trace(nullptr), size(0), tag(0) {}
+  StackTrace(const uptr *trace, u32 size) : trace(trace), size(size), tag(0) {}
+  StackTrace(const uptr *trace, u32 size, u32 tag)
+      : trace(trace), size(size), tag(tag) {}
+
+  // Prints a symbolized stacktrace, followed by an empty line.
+  void Print() const;
+
+  static bool WillUseFastUnwind(bool request_fast_unwind) {
+    if (!SANITIZER_CAN_FAST_UNWIND)
+      return false;
+    else if (!SANITIZER_CAN_SLOW_UNWIND)
+      return true;
+    return request_fast_unwind;
+  }
+
+  static uptr GetCurrentPc();
+  static inline uptr GetPreviousInstructionPc(uptr pc);
+  static uptr GetNextInstructionPc(uptr pc);
+  typedef bool (*SymbolizeCallback)(const void *pc, char *out_buffer,
+                                    int out_size);
+};
+
+// Performance-critical, must be in the header.
+ALWAYS_INLINE
+uptr StackTrace::GetPreviousInstructionPc(uptr pc) {
+#if defined(__arm__)
+  // Cancel Thumb bit.
+  pc = pc & (~1);
+#endif
+#if defined(__powerpc__) || defined(__powerpc64__)
+  // PCs are always 4 byte aligned.
+  return pc - 4;
+#elif defined(__sparc__) || defined(__mips__)
+  return pc - 8;
+#else
+  return pc - 1;
+#endif
+}
+
+// StackTrace that owns the buffer used to store the addresses.
+struct BufferedStackTrace : public StackTrace {
+  uptr trace_buffer[kStackTraceMax];
+  uptr top_frame_bp;  // Optional bp of a top frame.
+
+  BufferedStackTrace() : StackTrace(trace_buffer, 0), top_frame_bp(0) {}
+
+  void Init(const uptr *pcs, uptr cnt, uptr extra_top_pc = 0);
+  void Unwind(u32 max_depth, uptr pc, uptr bp, void *context, uptr stack_top,
+              uptr stack_bottom, bool request_fast_unwind);
+
+ private:
+  void FastUnwindStack(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom,
+                       u32 max_depth);
+  void SlowUnwindStack(uptr pc, u32 max_depth);
+  void SlowUnwindStackWithContext(uptr pc, void *context,
+                                  u32 max_depth);
+  void PopStackFrames(uptr count);
+  uptr LocatePcInTrace(uptr pc);
+
+  BufferedStackTrace(const BufferedStackTrace &);
+  void operator=(const BufferedStackTrace &);
+};
+
+}  // namespace __sanitizer
+
+// Use this macro if you want to print stack trace with the caller
+// of the current function in the top frame.
+#define GET_CALLER_PC_BP_SP \
+  uptr bp = GET_CURRENT_FRAME();              \
+  uptr pc = GET_CALLER_PC();                  \
+  uptr local_stack;                           \
+  uptr sp = (uptr)&local_stack
+
+#define GET_CALLER_PC_BP \
+  uptr bp = GET_CURRENT_FRAME();              \
+  uptr pc = GET_CALLER_PC();
+
+// Use this macro if you want to print stack trace with the current
+// function in the top frame.
+#define GET_CURRENT_PC_BP_SP \
+  uptr bp = GET_CURRENT_FRAME();              \
+  uptr pc = StackTrace::GetCurrentPc();   \
+  uptr local_stack;                           \
+  uptr sp = (uptr)&local_stack
+
+
+#endif  // SANITIZER_STACKTRACE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc
new file mode 100644
index 0000000..f66fa79
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc
@@ -0,0 +1,76 @@
+//===-- sanitizer_stacktrace_libcdep.cc -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_stacktrace.h"
+#include "sanitizer_stacktrace_printer.h"
+#include "sanitizer_symbolizer.h"
+
+namespace __sanitizer {
+
+void StackTrace::Print() const {
+  if (trace == nullptr || size == 0) {
+    Printf("    <empty stack>\n\n");
+    return;
+  }
+  InternalScopedString frame_desc(GetPageSizeCached() * 2);
+  uptr frame_num = 0;
+  for (uptr i = 0; i < size && trace[i]; i++) {
+    // PCs in stack traces are actually the return addresses, that is,
+    // addresses of the next instructions after the call.
+    uptr pc = GetPreviousInstructionPc(trace[i]);
+    SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
+    CHECK(frames);
+    for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+      frame_desc.clear();
+      RenderFrame(&frame_desc, common_flags()->stack_trace_format, frame_num++,
+                  cur->info, common_flags()->symbolize_vs_style,
+                  common_flags()->strip_path_prefix);
+      Printf("%s\n", frame_desc.data());
+    }
+    frames->ClearAll();
+  }
+  // Always print a trailing empty line after stack trace.
+  Printf("\n");
+}
+
+void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
+                                uptr stack_top, uptr stack_bottom,
+                                bool request_fast_unwind) {
+  top_frame_bp = (max_depth > 0) ? bp : 0;
+  // Avoid doing any work for small max_depth.
+  if (max_depth == 0) {
+    size = 0;
+    return;
+  }
+  if (max_depth == 1) {
+    size = 1;
+    trace_buffer[0] = pc;
+    return;
+  }
+  if (!WillUseFastUnwind(request_fast_unwind)) {
+#if SANITIZER_CAN_SLOW_UNWIND
+    if (context)
+      SlowUnwindStackWithContext(pc, context, max_depth);
+    else
+      SlowUnwindStack(pc, max_depth);
+#else
+    UNREACHABLE("slow unwind requested but not available");
+#endif
+  } else {
+    FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
+  }
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cc b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cc
new file mode 100644
index 0000000..669b0ba
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cc
@@ -0,0 +1,144 @@
+//===-- sanitizer_common.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between sanitizers' run-time libraries.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_stacktrace_printer.h"
+
+namespace __sanitizer {
+
+static const char *StripFunctionName(const char *function, const char *prefix) {
+  if (!function) return nullptr;
+  if (!prefix) return function;
+  uptr prefix_len = internal_strlen(prefix);
+  if (0 == internal_strncmp(function, prefix, prefix_len))
+    return function + prefix_len;
+  return function;
+}
+
+static const char kDefaultFormat[] = "    #%n %p %F %L";
+
+void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
+                 const AddressInfo &info, bool vs_style,
+                 const char *strip_path_prefix, const char *strip_func_prefix) {
+  if (0 == internal_strcmp(format, "DEFAULT"))
+    format = kDefaultFormat;
+  for (const char *p = format; *p != '\0'; p++) {
+    if (*p != '%') {
+      buffer->append("%c", *p);
+      continue;
+    }
+    p++;
+    switch (*p) {
+    case '%':
+      buffer->append("%%");
+      break;
+    // Frame number and all fields of AddressInfo structure.
+    case 'n':
+      buffer->append("%zu", frame_no);
+      break;
+    case 'p':
+      buffer->append("0x%zx", info.address);
+      break;
+    case 'm':
+      buffer->append("%s", StripPathPrefix(info.module, strip_path_prefix));
+      break;
+    case 'o':
+      buffer->append("0x%zx", info.module_offset);
+      break;
+    case 'f':
+      buffer->append("%s", StripFunctionName(info.function, strip_func_prefix));
+      break;
+    case 'q':
+      buffer->append("0x%zx", info.function_offset != AddressInfo::kUnknown
+                                  ? info.function_offset
+                                  : 0x0);
+      break;
+    case 's':
+      buffer->append("%s", StripPathPrefix(info.file, strip_path_prefix));
+      break;
+    case 'l':
+      buffer->append("%d", info.line);
+      break;
+    case 'c':
+      buffer->append("%d", info.column);
+      break;
+    // Smarter special cases.
+    case 'F':
+      // Function name and offset, if file is unknown.
+      if (info.function) {
+        buffer->append("in %s",
+                       StripFunctionName(info.function, strip_func_prefix));
+        if (!info.file && info.function_offset != AddressInfo::kUnknown)
+          buffer->append("+0x%zx", info.function_offset);
+      }
+      break;
+    case 'S':
+      // File/line information.
+      RenderSourceLocation(buffer, info.file, info.line, info.column, vs_style,
+                           strip_path_prefix);
+      break;
+    case 'L':
+      // Source location, or module location.
+      if (info.file) {
+        RenderSourceLocation(buffer, info.file, info.line, info.column,
+                             vs_style, strip_path_prefix);
+      } else if (info.module) {
+        RenderModuleLocation(buffer, info.module, info.module_offset,
+                             strip_path_prefix);
+      } else {
+        buffer->append("(<unknown module>)");
+      }
+      break;
+    case 'M':
+      // Module basename and offset, or PC.
+      if (info.address & kExternalPCBit)
+        {} // There PCs are not meaningful.
+      else if (info.module)
+        buffer->append("(%s+%p)", StripModuleName(info.module),
+                       (void *)info.module_offset);
+      else
+        buffer->append("(%p)", (void *)info.address);
+      break;
+    default:
+      Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
+             *p);
+      Die();
+    }
+  }
+}
+
+void RenderSourceLocation(InternalScopedString *buffer, const char *file,
+                          int line, int column, bool vs_style,
+                          const char *strip_path_prefix) {
+  if (vs_style && line > 0) {
+    buffer->append("%s(%d", StripPathPrefix(file, strip_path_prefix), line);
+    if (column > 0)
+      buffer->append(",%d", column);
+    buffer->append(")");
+    return;
+  }
+
+  buffer->append("%s", StripPathPrefix(file, strip_path_prefix));
+  if (line > 0) {
+    buffer->append(":%d", line);
+    if (column > 0)
+      buffer->append(":%d", column);
+  }
+}
+
+void RenderModuleLocation(InternalScopedString *buffer, const char *module,
+                          uptr offset, const char *strip_path_prefix) {
+  buffer->append("(%s+0x%zx)", StripPathPrefix(module, strip_path_prefix),
+                 offset);
+}
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
new file mode 100644
index 0000000..7f6c5c7
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
@@ -0,0 +1,64 @@
+//===-- sanitizer_stacktrace_printer.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between sanitizers' run-time libraries.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_STACKTRACE_PRINTER_H
+#define SANITIZER_STACKTRACE_PRINTER_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_symbolizer.h"
+
+namespace __sanitizer {
+
+// Render the contents of "info" structure, which represents the contents of
+// stack frame "frame_no" and appends it to the "buffer". "format" is a
+// string with placeholders, which is copied to the output with
+// placeholders substituted with the contents of "info". For example,
+// format string
+//   "  frame %n: function %F at %S"
+// will be turned into
+//   "  frame 10: function foo::bar() at my/file.cc:10"
+// You may additionally pass "strip_path_prefix" to strip prefixes of paths to
+// source files and modules, and "strip_func_prefix" to strip prefixes of
+// function names.
+// Here's the full list of available placeholders:
+//   %% - represents a '%' character;
+//   %n - frame number (copy of frame_no);
+//   %p - PC in hex format;
+//   %m - path to module (binary or shared object);
+//   %o - offset in the module in hex format;
+//   %f - function name;
+//   %q - offset in the function in hex format (*if available*);
+//   %s - path to source file;
+//   %l - line in the source file;
+//   %c - column in the source file;
+//   %F - if function is known to be <foo>, prints "in <foo>", possibly
+//        followed by the offset in this function, but only if source file
+//        is unknown;
+//   %S - prints file/line/column information;
+//   %L - prints location information: file/line/column, if it is known, or
+//        module+offset if it is known, or (<unknown module>) string.
+//   %M - prints module basename and offset, if it is known, or PC.
+void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
+                 const AddressInfo &info, bool vs_style,
+                 const char *strip_path_prefix = "",
+                 const char *strip_func_prefix = "");
+
+void RenderSourceLocation(InternalScopedString *buffer, const char *file,
+                          int line, int column, bool vs_style,
+                          const char *strip_path_prefix);
+
+void RenderModuleLocation(InternalScopedString *buffer, const char *module,
+                          uptr offset, const char *strip_path_prefix);
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_STACKTRACE_PRINTER_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld.h b/compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld.h
new file mode 100644
index 0000000..aa6f5d8
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld.h
@@ -0,0 +1,69 @@
+//===-- sanitizer_stoptheworld.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the StopTheWorld function which suspends the execution of the current
+// process and runs the user-supplied callback in the same address space.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_STOPTHEWORLD_H
+#define SANITIZER_STOPTHEWORLD_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+typedef int SuspendedThreadID;
+
+// Holds the list of suspended threads and provides an interface to dump their
+// register contexts.
+class SuspendedThreadsList {
+ public:
+  SuspendedThreadsList()
+    : thread_ids_(1024) {}
+  SuspendedThreadID GetThreadID(uptr index) const {
+    CHECK_LT(index, thread_ids_.size());
+    return thread_ids_[index];
+  }
+  int GetRegistersAndSP(uptr index, uptr *buffer, uptr *sp) const;
+  // The buffer in GetRegistersAndSP should be at least this big.
+  static uptr RegisterCount();
+  uptr thread_count() const { return thread_ids_.size(); }
+  bool Contains(SuspendedThreadID thread_id) const {
+    for (uptr i = 0; i < thread_ids_.size(); i++) {
+      if (thread_ids_[i] == thread_id)
+        return true;
+    }
+    return false;
+  }
+  void Append(SuspendedThreadID thread_id) {
+    thread_ids_.push_back(thread_id);
+  }
+
+ private:
+  InternalMmapVector<SuspendedThreadID> thread_ids_;
+
+  // Prohibit copy and assign.
+  SuspendedThreadsList(const SuspendedThreadsList&);
+  void operator=(const SuspendedThreadsList&);
+};
+
+typedef void (*StopTheWorldCallback)(
+    const SuspendedThreadsList &suspended_threads_list,
+    void *argument);
+
+// Suspend all threads in the current process and run the callback on the list
+// of suspended threads. This function will resume the threads before returning.
+// The callback should not call any libc functions. The callback must not call
+// exit() nor _exit() and instead return to the caller.
+// This function should NOT be called from multiple threads simultaneously.
+void StopTheWorld(StopTheWorldCallback callback, void *argument);
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_STOPTHEWORLD_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
new file mode 100644
index 0000000..d1e2f6a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
@@ -0,0 +1,522 @@
+//===-- sanitizer_stoptheworld_linux_libcdep.cc ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// See sanitizer_stoptheworld.h for details.
+// This implementation was inspired by Markus Gutschke's linuxthreads.cc.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__) || \
+                        defined(__aarch64__) || defined(__powerpc64__))
+
+#include "sanitizer_stoptheworld.h"
+
+#include "sanitizer_platform_limits_posix.h"
+#include "sanitizer_atomic.h"
+
+#include <errno.h>
+#include <sched.h> // for CLONE_* definitions
+#include <stddef.h>
+#include <sys/prctl.h> // for PR_* definitions
+#include <sys/ptrace.h> // for PTRACE_* definitions
+#include <sys/types.h> // for pid_t
+#include <sys/uio.h> // for iovec
+#include <elf.h> // for NT_PRSTATUS
+#if SANITIZER_ANDROID && defined(__arm__)
+# include <linux/user.h>  // for pt_regs
+#else
+# ifdef __aarch64__
+// GLIBC 2.20+ sys/user does not include asm/ptrace.h
+#  include <asm/ptrace.h>
+# endif
+# include <sys/user.h>  // for user_regs_struct
+# if SANITIZER_ANDROID && SANITIZER_MIPS
+#   include <asm/reg.h>  // for mips SP register in sys/user.h
+# endif
+#endif
+#include <sys/wait.h> // for signal-related stuff
+
+#ifdef sa_handler
+# undef sa_handler
+#endif
+
+#ifdef sa_sigaction
+# undef sa_sigaction
+#endif
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_linux.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_placement_new.h"
+
+// This module works by spawning a Linux task which then attaches to every
+// thread in the caller process with ptrace. This suspends the threads, and
+// PTRACE_GETREGS can then be used to obtain their register state. The callback
+// supplied to StopTheWorld() is run in the tracer task while the threads are
+// suspended.
+// The tracer task must be placed in a different thread group for ptrace to
+// work, so it cannot be spawned as a pthread. Instead, we use the low-level
+// clone() interface (we want to share the address space with the caller
+// process, so we prefer clone() over fork()).
+//
+// We don't use any libc functions, relying instead on direct syscalls. There
+// are two reasons for this:
+// 1. calling a library function while threads are suspended could cause a
+// deadlock, if one of the treads happens to be holding a libc lock;
+// 2. it's generally not safe to call libc functions from the tracer task,
+// because clone() does not set up a thread-local storage for it. Any
+// thread-local variables used by libc will be shared between the tracer task
+// and the thread which spawned it.
+
+COMPILER_CHECK(sizeof(SuspendedThreadID) == sizeof(pid_t));
+
+namespace __sanitizer {
+
+// Structure for passing arguments into the tracer thread.
+struct TracerThreadArgument {
+  StopTheWorldCallback callback;
+  void *callback_argument;
+  // The tracer thread waits on this mutex while the parent finishes its
+  // preparations.
+  BlockingMutex mutex;
+  // Tracer thread signals its completion by setting done.
+  atomic_uintptr_t done;
+  uptr parent_pid;
+};
+
+// This class handles thread suspending/unsuspending in the tracer thread.
+class ThreadSuspender {
+ public:
+  explicit ThreadSuspender(pid_t pid, TracerThreadArgument *arg)
+    : arg(arg)
+    , pid_(pid) {
+      CHECK_GE(pid, 0);
+    }
+  bool SuspendAllThreads();
+  void ResumeAllThreads();
+  void KillAllThreads();
+  SuspendedThreadsList &suspended_threads_list() {
+    return suspended_threads_list_;
+  }
+  TracerThreadArgument *arg;
+ private:
+  SuspendedThreadsList suspended_threads_list_;
+  pid_t pid_;
+  bool SuspendThread(SuspendedThreadID thread_id);
+};
+
+bool ThreadSuspender::SuspendThread(SuspendedThreadID tid) {
+  // Are we already attached to this thread?
+  // Currently this check takes linear time, however the number of threads is
+  // usually small.
+  if (suspended_threads_list_.Contains(tid))
+    return false;
+  int pterrno;
+  if (internal_iserror(internal_ptrace(PTRACE_ATTACH, tid, nullptr, nullptr),
+                       &pterrno)) {
+    // Either the thread is dead, or something prevented us from attaching.
+    // Log this event and move on.
+    VReport(1, "Could not attach to thread %d (errno %d).\n", tid, pterrno);
+    return false;
+  } else {
+    VReport(2, "Attached to thread %d.\n", tid);
+    // The thread is not guaranteed to stop before ptrace returns, so we must
+    // wait on it. Note: if the thread receives a signal concurrently,
+    // we can get notification about the signal before notification about stop.
+    // In such case we need to forward the signal to the thread, otherwise
+    // the signal will be missed (as we do PTRACE_DETACH with arg=0) and
+    // any logic relying on signals will break. After forwarding we need to
+    // continue to wait for stopping, because the thread is not stopped yet.
+    // We do ignore delivery of SIGSTOP, because we want to make stop-the-world
+    // as invisible as possible.
+    for (;;) {
+      int status;
+      uptr waitpid_status;
+      HANDLE_EINTR(waitpid_status, internal_waitpid(tid, &status, __WALL));
+      int wperrno;
+      if (internal_iserror(waitpid_status, &wperrno)) {
+        // Got a ECHILD error. I don't think this situation is possible, but it
+        // doesn't hurt to report it.
+        VReport(1, "Waiting on thread %d failed, detaching (errno %d).\n",
+                tid, wperrno);
+        internal_ptrace(PTRACE_DETACH, tid, nullptr, nullptr);
+        return false;
+      }
+      if (WIFSTOPPED(status) && WSTOPSIG(status) != SIGSTOP) {
+        internal_ptrace(PTRACE_CONT, tid, nullptr,
+                        (void*)(uptr)WSTOPSIG(status));
+        continue;
+      }
+      break;
+    }
+    suspended_threads_list_.Append(tid);
+    return true;
+  }
+}
+
+void ThreadSuspender::ResumeAllThreads() {
+  for (uptr i = 0; i < suspended_threads_list_.thread_count(); i++) {
+    pid_t tid = suspended_threads_list_.GetThreadID(i);
+    int pterrno;
+    if (!internal_iserror(internal_ptrace(PTRACE_DETACH, tid, nullptr, nullptr),
+                          &pterrno)) {
+      VReport(2, "Detached from thread %d.\n", tid);
+    } else {
+      // Either the thread is dead, or we are already detached.
+      // The latter case is possible, for instance, if this function was called
+      // from a signal handler.
+      VReport(1, "Could not detach from thread %d (errno %d).\n", tid, pterrno);
+    }
+  }
+}
+
+void ThreadSuspender::KillAllThreads() {
+  for (uptr i = 0; i < suspended_threads_list_.thread_count(); i++)
+    internal_ptrace(PTRACE_KILL, suspended_threads_list_.GetThreadID(i),
+                    nullptr, nullptr);
+}
+
+bool ThreadSuspender::SuspendAllThreads() {
+  ThreadLister thread_lister(pid_);
+  bool added_threads;
+  do {
+    // Run through the directory entries once.
+    added_threads = false;
+    pid_t tid = thread_lister.GetNextTID();
+    while (tid >= 0) {
+      if (SuspendThread(tid))
+        added_threads = true;
+      tid = thread_lister.GetNextTID();
+    }
+    if (thread_lister.error()) {
+      // Detach threads and fail.
+      ResumeAllThreads();
+      return false;
+    }
+    thread_lister.Reset();
+  } while (added_threads);
+  return true;
+}
+
+// Pointer to the ThreadSuspender instance for use in signal handler.
+static ThreadSuspender *thread_suspender_instance = nullptr;
+
+// Synchronous signals that should not be blocked.
+static const int kSyncSignals[] = { SIGABRT, SIGILL, SIGFPE, SIGSEGV, SIGBUS,
+                                    SIGXCPU, SIGXFSZ };
+
+static void TracerThreadDieCallback() {
+  // Generally a call to Die() in the tracer thread should be fatal to the
+  // parent process as well, because they share the address space.
+  // This really only works correctly if all the threads are suspended at this
+  // point. So we correctly handle calls to Die() from within the callback, but
+  // not those that happen before or after the callback. Hopefully there aren't
+  // a lot of opportunities for that to happen...
+  ThreadSuspender *inst = thread_suspender_instance;
+  if (inst && stoptheworld_tracer_pid == internal_getpid()) {
+    inst->KillAllThreads();
+    thread_suspender_instance = nullptr;
+  }
+}
+
+// Signal handler to wake up suspended threads when the tracer thread dies.
+static void TracerThreadSignalHandler(int signum, void *siginfo, void *uctx) {
+  SignalContext ctx = SignalContext::Create(siginfo, uctx);
+  VPrintf(1, "Tracer caught signal %d: addr=0x%zx pc=0x%zx sp=0x%zx\n",
+      signum, ctx.addr, ctx.pc, ctx.sp);
+  ThreadSuspender *inst = thread_suspender_instance;
+  if (inst) {
+    if (signum == SIGABRT)
+      inst->KillAllThreads();
+    else
+      inst->ResumeAllThreads();
+    RAW_CHECK(RemoveDieCallback(TracerThreadDieCallback));
+    thread_suspender_instance = nullptr;
+    atomic_store(&inst->arg->done, 1, memory_order_relaxed);
+  }
+  internal__exit((signum == SIGABRT) ? 1 : 2);
+}
+
+// Size of alternative stack for signal handlers in the tracer thread.
+static const int kHandlerStackSize = 4096;
+
+// This function will be run as a cloned task.
+static int TracerThread(void* argument) {
+  TracerThreadArgument *tracer_thread_argument =
+      (TracerThreadArgument *)argument;
+
+  internal_prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
+  // Check if parent is already dead.
+  if (internal_getppid() != tracer_thread_argument->parent_pid)
+    internal__exit(4);
+
+  // Wait for the parent thread to finish preparations.
+  tracer_thread_argument->mutex.Lock();
+  tracer_thread_argument->mutex.Unlock();
+
+  RAW_CHECK(AddDieCallback(TracerThreadDieCallback));
+
+  ThreadSuspender thread_suspender(internal_getppid(), tracer_thread_argument);
+  // Global pointer for the signal handler.
+  thread_suspender_instance = &thread_suspender;
+
+  // Alternate stack for signal handling.
+  InternalScopedBuffer<char> handler_stack_memory(kHandlerStackSize);
+  struct sigaltstack handler_stack;
+  internal_memset(&handler_stack, 0, sizeof(handler_stack));
+  handler_stack.ss_sp = handler_stack_memory.data();
+  handler_stack.ss_size = kHandlerStackSize;
+  internal_sigaltstack(&handler_stack, nullptr);
+
+  // Install our handler for synchronous signals. Other signals should be
+  // blocked by the mask we inherited from the parent thread.
+  for (uptr i = 0; i < ARRAY_SIZE(kSyncSignals); i++) {
+    __sanitizer_sigaction act;
+    internal_memset(&act, 0, sizeof(act));
+    act.sigaction = TracerThreadSignalHandler;
+    act.sa_flags = SA_ONSTACK | SA_SIGINFO;
+    internal_sigaction_norestorer(kSyncSignals[i], &act, 0);
+  }
+
+  int exit_code = 0;
+  if (!thread_suspender.SuspendAllThreads()) {
+    VReport(1, "Failed suspending threads.\n");
+    exit_code = 3;
+  } else {
+    tracer_thread_argument->callback(thread_suspender.suspended_threads_list(),
+                                     tracer_thread_argument->callback_argument);
+    thread_suspender.ResumeAllThreads();
+    exit_code = 0;
+  }
+  RAW_CHECK(RemoveDieCallback(TracerThreadDieCallback));
+  thread_suspender_instance = nullptr;
+  atomic_store(&tracer_thread_argument->done, 1, memory_order_relaxed);
+  return exit_code;
+}
+
+class ScopedStackSpaceWithGuard {
+ public:
+  explicit ScopedStackSpaceWithGuard(uptr stack_size) {
+    stack_size_ = stack_size;
+    guard_size_ = GetPageSizeCached();
+    // FIXME: Omitting MAP_STACK here works in current kernels but might break
+    // in the future.
+    guard_start_ = (uptr)MmapOrDie(stack_size_ + guard_size_,
+                                   "ScopedStackWithGuard");
+    CHECK(MprotectNoAccess((uptr)guard_start_, guard_size_));
+  }
+  ~ScopedStackSpaceWithGuard() {
+    UnmapOrDie((void *)guard_start_, stack_size_ + guard_size_);
+  }
+  void *Bottom() const {
+    return (void *)(guard_start_ + stack_size_ + guard_size_);
+  }
+
+ private:
+  uptr stack_size_;
+  uptr guard_size_;
+  uptr guard_start_;
+};
+
+// We have a limitation on the stack frame size, so some stuff had to be moved
+// into globals.
+static __sanitizer_sigset_t blocked_sigset;
+static __sanitizer_sigset_t old_sigset;
+
+class StopTheWorldScope {
+ public:
+  StopTheWorldScope() {
+    // Make this process dumpable. Processes that are not dumpable cannot be
+    // attached to.
+    process_was_dumpable_ = internal_prctl(PR_GET_DUMPABLE, 0, 0, 0, 0);
+    if (!process_was_dumpable_)
+      internal_prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
+  }
+
+  ~StopTheWorldScope() {
+    // Restore the dumpable flag.
+    if (!process_was_dumpable_)
+      internal_prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
+  }
+
+ private:
+  int process_was_dumpable_;
+};
+
+// When sanitizer output is being redirected to file (i.e. by using log_path),
+// the tracer should write to the parent's log instead of trying to open a new
+// file. Alert the logging code to the fact that we have a tracer.
+struct ScopedSetTracerPID {
+  explicit ScopedSetTracerPID(uptr tracer_pid) {
+    stoptheworld_tracer_pid = tracer_pid;
+    stoptheworld_tracer_ppid = internal_getpid();
+  }
+  ~ScopedSetTracerPID() {
+    stoptheworld_tracer_pid = 0;
+    stoptheworld_tracer_ppid = 0;
+  }
+};
+
+void StopTheWorld(StopTheWorldCallback callback, void *argument) {
+  StopTheWorldScope in_stoptheworld;
+  // Prepare the arguments for TracerThread.
+  struct TracerThreadArgument tracer_thread_argument;
+  tracer_thread_argument.callback = callback;
+  tracer_thread_argument.callback_argument = argument;
+  tracer_thread_argument.parent_pid = internal_getpid();
+  atomic_store(&tracer_thread_argument.done, 0, memory_order_relaxed);
+  const uptr kTracerStackSize = 2 * 1024 * 1024;
+  ScopedStackSpaceWithGuard tracer_stack(kTracerStackSize);
+  // Block the execution of TracerThread until after we have set ptrace
+  // permissions.
+  tracer_thread_argument.mutex.Lock();
+  // Signal handling story.
+  // We don't want async signals to be delivered to the tracer thread,
+  // so we block all async signals before creating the thread. An async signal
+  // handler can temporary modify errno, which is shared with this thread.
+  // We ought to use pthread_sigmask here, because sigprocmask has undefined
+  // behavior in multithreaded programs. However, on linux sigprocmask is
+  // equivalent to pthread_sigmask with the exception that pthread_sigmask
+  // does not allow to block some signals used internally in pthread
+  // implementation. We are fine with blocking them here, we are really not
+  // going to pthread_cancel the thread.
+  // The tracer thread should not raise any synchronous signals. But in case it
+  // does, we setup a special handler for sync signals that properly kills the
+  // parent as well. Note: we don't pass CLONE_SIGHAND to clone, so handlers
+  // in the tracer thread won't interfere with user program. Double note: if a
+  // user does something along the lines of 'kill -11 pid', that can kill the
+  // process even if user setup own handler for SEGV.
+  // Thing to watch out for: this code should not change behavior of user code
+  // in any observable way. In particular it should not override user signal
+  // handlers.
+  internal_sigfillset(&blocked_sigset);
+  for (uptr i = 0; i < ARRAY_SIZE(kSyncSignals); i++)
+    internal_sigdelset(&blocked_sigset, kSyncSignals[i]);
+  int rv = internal_sigprocmask(SIG_BLOCK, &blocked_sigset, &old_sigset);
+  CHECK_EQ(rv, 0);
+  uptr tracer_pid = internal_clone(
+      TracerThread, tracer_stack.Bottom(),
+      CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_UNTRACED,
+      &tracer_thread_argument, nullptr /* parent_tidptr */,
+      nullptr /* newtls */, nullptr /* child_tidptr */);
+  internal_sigprocmask(SIG_SETMASK, &old_sigset, 0);
+  int local_errno = 0;
+  if (internal_iserror(tracer_pid, &local_errno)) {
+    VReport(1, "Failed spawning a tracer thread (errno %d).\n", local_errno);
+    tracer_thread_argument.mutex.Unlock();
+  } else {
+    ScopedSetTracerPID scoped_set_tracer_pid(tracer_pid);
+    // On some systems we have to explicitly declare that we want to be traced
+    // by the tracer thread.
+#ifdef PR_SET_PTRACER
+    internal_prctl(PR_SET_PTRACER, tracer_pid, 0, 0, 0);
+#endif
+    // Allow the tracer thread to start.
+    tracer_thread_argument.mutex.Unlock();
+    // NOTE: errno is shared between this thread and the tracer thread.
+    // internal_waitpid() may call syscall() which can access/spoil errno,
+    // so we can't call it now. Instead we for the tracer thread to finish using
+    // the spin loop below. Man page for sched_yield() says "In the Linux
+    // implementation, sched_yield() always succeeds", so let's hope it does not
+    // spoil errno. Note that this spin loop runs only for brief periods before
+    // the tracer thread has suspended us and when it starts unblocking threads.
+    while (atomic_load(&tracer_thread_argument.done, memory_order_relaxed) == 0)
+      sched_yield();
+    // Now the tracer thread is about to exit and does not touch errno,
+    // wait for it.
+    for (;;) {
+      uptr waitpid_status = internal_waitpid(tracer_pid, nullptr, __WALL);
+      if (!internal_iserror(waitpid_status, &local_errno))
+        break;
+      if (local_errno == EINTR)
+        continue;
+      VReport(1, "Waiting on the tracer thread failed (errno %d).\n",
+              local_errno);
+      break;
+    }
+  }
+}
+
+// Platform-specific methods from SuspendedThreadsList.
+#if SANITIZER_ANDROID && defined(__arm__)
+typedef pt_regs regs_struct;
+#define REG_SP ARM_sp
+
+#elif SANITIZER_LINUX && defined(__arm__)
+typedef user_regs regs_struct;
+#define REG_SP uregs[13]
+
+#elif defined(__i386__) || defined(__x86_64__)
+typedef user_regs_struct regs_struct;
+#if defined(__i386__)
+#define REG_SP esp
+#else
+#define REG_SP rsp
+#endif
+
+#elif defined(__powerpc__) || defined(__powerpc64__)
+typedef pt_regs regs_struct;
+#define REG_SP gpr[PT_R1]
+
+#elif defined(__mips__)
+typedef struct user regs_struct;
+# if SANITIZER_ANDROID
+#  define REG_SP regs[EF_R29]
+# else
+#  define REG_SP regs[EF_REG29]
+# endif
+
+#elif defined(__aarch64__)
+typedef struct user_pt_regs regs_struct;
+#define REG_SP sp
+#define ARCH_IOVEC_FOR_GETREGSET
+
+#else
+#error "Unsupported architecture"
+#endif // SANITIZER_ANDROID && defined(__arm__)
+
+int SuspendedThreadsList::GetRegistersAndSP(uptr index,
+                                            uptr *buffer,
+                                            uptr *sp) const {
+  pid_t tid = GetThreadID(index);
+  regs_struct regs;
+  int pterrno;
+#ifdef ARCH_IOVEC_FOR_GETREGSET
+  struct iovec regset_io;
+  regset_io.iov_base = &regs;
+  regset_io.iov_len = sizeof(regs_struct);
+  bool isErr = internal_iserror(internal_ptrace(PTRACE_GETREGSET, tid,
+                                (void*)NT_PRSTATUS, (void*)&regset_io),
+                                &pterrno);
+#else
+  bool isErr = internal_iserror(internal_ptrace(PTRACE_GETREGS, tid, nullptr,
+                                &regs), &pterrno);
+#endif
+  if (isErr) {
+    VReport(1, "Could not get registers from thread %d (errno %d).\n", tid,
+            pterrno);
+    return -1;
+  }
+
+  *sp = regs.REG_SP;
+  internal_memcpy(buffer, &regs, sizeof(regs));
+  return 0;
+}
+
+uptr SuspendedThreadsList::RegisterCount() {
+  return sizeof(regs_struct) / sizeof(uptr);
+}
+} // namespace __sanitizer
+
+#endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__)
+        // || defined(__aarch64__) || defined(__powerpc64__)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_suppressions.cc b/compiler-rt/lib/sanitizer_common/sanitizer_suppressions.cc
new file mode 100644
index 0000000..f0f2c9c
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_suppressions.cc
@@ -0,0 +1,168 @@
+//===-- sanitizer_suppressions.cc -----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Suppression parsing/matching code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_suppressions.h"
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_placement_new.h"
+
+namespace __sanitizer {
+
+SuppressionContext::SuppressionContext(const char *suppression_types[],
+                                       int suppression_types_num)
+    : suppression_types_(suppression_types),
+      suppression_types_num_(suppression_types_num), suppressions_(1),
+      can_parse_(true) {
+  CHECK_LE(suppression_types_num_, kMaxSuppressionTypes);
+  internal_memset(has_suppression_type_, 0, suppression_types_num_);
+}
+
+static bool GetPathAssumingFileIsRelativeToExec(const char *file_path,
+                                                /*out*/char *new_file_path,
+                                                uptr new_file_path_size) {
+  InternalScopedString exec(kMaxPathLength);
+  if (ReadBinaryNameCached(exec.data(), exec.size())) {
+    const char *file_name_pos = StripModuleName(exec.data());
+    uptr path_to_exec_len = file_name_pos - exec.data();
+    internal_strncat(new_file_path, exec.data(),
+                     Min(path_to_exec_len, new_file_path_size - 1));
+    internal_strncat(new_file_path, file_path,
+                     new_file_path_size - internal_strlen(new_file_path) - 1);
+    return true;
+  }
+  return false;
+}
+
+void SuppressionContext::ParseFromFile(const char *filename) {
+  if (filename[0] == '\0')
+    return;
+
+  // If we cannot find the file, check if its location is relative to
+  // the location of the executable.
+  InternalScopedString new_file_path(kMaxPathLength);
+  if (!FileExists(filename) && !IsAbsolutePath(filename) &&
+      GetPathAssumingFileIsRelativeToExec(filename, new_file_path.data(),
+                                          new_file_path.size())) {
+    filename = new_file_path.data();
+  }
+
+  // Read the file.
+  VPrintf(1, "%s: reading suppressions file at %s\n",
+          SanitizerToolName, filename);
+  char *file_contents;
+  uptr buffer_size;
+  uptr contents_size;
+  if (!ReadFileToBuffer(filename, &file_contents, &buffer_size,
+                        &contents_size)) {
+    Printf("%s: failed to read suppressions file '%s'\n", SanitizerToolName,
+           filename);
+    Die();
+  }
+
+  Parse(file_contents);
+}
+
+bool SuppressionContext::Match(const char *str, const char *type,
+                               Suppression **s) {
+  can_parse_ = false;
+  if (!HasSuppressionType(type))
+    return false;
+  for (uptr i = 0; i < suppressions_.size(); i++) {
+    Suppression &cur = suppressions_[i];
+    if (0 == internal_strcmp(cur.type, type) && TemplateMatch(cur.templ, str)) {
+      *s = &cur;
+      return true;
+    }
+  }
+  return false;
+}
+
+static const char *StripPrefix(const char *str, const char *prefix) {
+  while (str && *str == *prefix) {
+    str++;
+    prefix++;
+  }
+  if (!*prefix)
+    return str;
+  return 0;
+}
+
+void SuppressionContext::Parse(const char *str) {
+  // Context must not mutate once Match has been called.
+  CHECK(can_parse_);
+  const char *line = str;
+  while (line) {
+    while (line[0] == ' ' || line[0] == '\t')
+      line++;
+    const char *end = internal_strchr(line, '\n');
+    if (end == 0)
+      end = line + internal_strlen(line);
+    if (line != end && line[0] != '#') {
+      const char *end2 = end;
+      while (line != end2 &&
+             (end2[-1] == ' ' || end2[-1] == '\t' || end2[-1] == '\r'))
+        end2--;
+      int type;
+      for (type = 0; type < suppression_types_num_; type++) {
+        const char *next_char = StripPrefix(line, suppression_types_[type]);
+        if (next_char && *next_char == ':') {
+          line = ++next_char;
+          break;
+        }
+      }
+      if (type == suppression_types_num_) {
+        Printf("%s: failed to parse suppressions\n", SanitizerToolName);
+        Die();
+      }
+      Suppression s;
+      s.type = suppression_types_[type];
+      s.templ = (char*)InternalAlloc(end2 - line + 1);
+      internal_memcpy(s.templ, line, end2 - line);
+      s.templ[end2 - line] = 0;
+      suppressions_.push_back(s);
+      has_suppression_type_[type] = true;
+    }
+    if (end[0] == 0)
+      break;
+    line = end + 1;
+  }
+}
+
+uptr SuppressionContext::SuppressionCount() const {
+  return suppressions_.size();
+}
+
+bool SuppressionContext::HasSuppressionType(const char *type) const {
+  for (int i = 0; i < suppression_types_num_; i++) {
+    if (0 == internal_strcmp(type, suppression_types_[i]))
+      return has_suppression_type_[i];
+  }
+  return false;
+}
+
+const Suppression *SuppressionContext::SuppressionAt(uptr i) const {
+  CHECK_LT(i, suppressions_.size());
+  return &suppressions_[i];
+}
+
+void SuppressionContext::GetMatched(
+    InternalMmapVector<Suppression *> *matched) {
+  for (uptr i = 0; i < suppressions_.size(); i++)
+    if (atomic_load_relaxed(&suppressions_[i].hit_count))
+      matched->push_back(&suppressions_[i]);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_suppressions.h b/compiler-rt/lib/sanitizer_common/sanitizer_suppressions.h
new file mode 100644
index 0000000..0ca875a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_suppressions.h
@@ -0,0 +1,57 @@
+//===-- sanitizer_suppressions.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Suppression parsing/matching code.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_SUPPRESSIONS_H
+#define SANITIZER_SUPPRESSIONS_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+
+struct Suppression {
+  Suppression() { internal_memset(this, 0, sizeof(*this)); }
+  const char *type;
+  char *templ;
+  atomic_uint32_t hit_count;
+  uptr weight;
+};
+
+class SuppressionContext {
+ public:
+  // Create new SuppressionContext capable of parsing given suppression types.
+  SuppressionContext(const char *supprression_types[],
+                     int suppression_types_num);
+
+  void ParseFromFile(const char *filename);
+  void Parse(const char *str);
+
+  bool Match(const char *str, const char *type, Suppression **s);
+  uptr SuppressionCount() const;
+  bool HasSuppressionType(const char *type) const;
+  const Suppression *SuppressionAt(uptr i) const;
+  void GetMatched(InternalMmapVector<Suppression *> *matched);
+
+ private:
+  static const int kMaxSuppressionTypes = 32;
+  const char **const suppression_types_;
+  const int suppression_types_num_;
+
+  InternalMmapVector<Suppression> suppressions_;
+  bool has_suppression_type_[kMaxSuppressionTypes];
+  bool can_parse_;
+};
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_SUPPRESSIONS_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cc b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cc
new file mode 100644
index 0000000..8b2496a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cc
@@ -0,0 +1,113 @@
+//===-- sanitizer_symbolizer.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_platform.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+AddressInfo::AddressInfo() {
+  internal_memset(this, 0, sizeof(AddressInfo));
+  function_offset = kUnknown;
+}
+
+void AddressInfo::Clear() {
+  InternalFree(module);
+  InternalFree(function);
+  InternalFree(file);
+  internal_memset(this, 0, sizeof(AddressInfo));
+  function_offset = kUnknown;
+}
+
+void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset) {
+  module = internal_strdup(mod_name);
+  module_offset = mod_offset;
+}
+
+SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
+
+SymbolizedStack *SymbolizedStack::New(uptr addr) {
+  void *mem = InternalAlloc(sizeof(SymbolizedStack));
+  SymbolizedStack *res = new(mem) SymbolizedStack();
+  res->info.address = addr;
+  return res;
+}
+
+void SymbolizedStack::ClearAll() {
+  info.Clear();
+  if (next)
+    next->ClearAll();
+  InternalFree(this);
+}
+
+DataInfo::DataInfo() {
+  internal_memset(this, 0, sizeof(DataInfo));
+}
+
+void DataInfo::Clear() {
+  InternalFree(module);
+  InternalFree(name);
+  internal_memset(this, 0, sizeof(DataInfo));
+}
+
+Symbolizer *Symbolizer::symbolizer_;
+StaticSpinMutex Symbolizer::init_mu_;
+LowLevelAllocator Symbolizer::symbolizer_allocator_;
+
+void Symbolizer::AddHooks(Symbolizer::StartSymbolizationHook start_hook,
+                          Symbolizer::EndSymbolizationHook end_hook) {
+  CHECK(start_hook_ == 0 && end_hook_ == 0);
+  start_hook_ = start_hook;
+  end_hook_ = end_hook;
+}
+
+const char *Symbolizer::ModuleNameOwner::GetOwnedCopy(const char *str) {
+  mu_->CheckLocked();
+
+  // 'str' will be the same string multiple times in a row, optimize this case.
+  if (last_match_ && !internal_strcmp(last_match_, str))
+    return last_match_;
+
+  // FIXME: this is linear search.
+  // We should optimize this further if this turns out to be a bottleneck later.
+  for (uptr i = 0; i < storage_.size(); ++i) {
+    if (!internal_strcmp(storage_[i], str)) {
+      last_match_ = storage_[i];
+      return last_match_;
+    }
+  }
+  last_match_ = internal_strdup(str);
+  storage_.push_back(last_match_);
+  return last_match_;
+}
+
+Symbolizer::Symbolizer(IntrusiveList<SymbolizerTool> tools)
+    : module_names_(&mu_), n_modules_(0), modules_fresh_(false), tools_(tools),
+      start_hook_(0), end_hook_(0) {}
+
+Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
+    : sym_(sym) {
+  if (sym_->start_hook_)
+    sym_->start_hook_();
+}
+
+Symbolizer::SymbolizerScope::~SymbolizerScope() {
+  if (sym_->end_hook_)
+    sym_->end_hook_();
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h
new file mode 100644
index 0000000..9233223
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h
@@ -0,0 +1,180 @@
+//===-- sanitizer_symbolizer.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Symbolizer is used by sanitizers to map instruction address to a location in
+// source code at run-time. Symbolizer either uses __sanitizer_symbolize_*
+// defined in the program, or (if they are missing) tries to find and
+// launch "llvm-symbolizer" commandline tool in a separate process and
+// communicate with it.
+//
+// Generally we should try to avoid calling system library functions during
+// symbolization (and use their replacements from sanitizer_libc.h instead).
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_SYMBOLIZER_H
+#define SANITIZER_SYMBOLIZER_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_mutex.h"
+
+namespace __sanitizer {
+
+struct AddressInfo {
+  // Owns all the string members. Storage for them is
+  // (de)allocated using sanitizer internal allocator.
+  uptr address;
+
+  char *module;
+  uptr module_offset;
+
+  static const uptr kUnknown = ~(uptr)0;
+  char *function;
+  uptr function_offset;
+
+  char *file;
+  int line;
+  int column;
+
+  AddressInfo();
+  // Deletes all strings and resets all fields.
+  void Clear();
+  void FillModuleInfo(const char *mod_name, uptr mod_offset);
+};
+
+// Linked list of symbolized frames (each frame is described by AddressInfo).
+struct SymbolizedStack {
+  SymbolizedStack *next;
+  AddressInfo info;
+  static SymbolizedStack *New(uptr addr);
+  // Deletes current, and all subsequent frames in the linked list.
+  // The object cannot be accessed after the call to this function.
+  void ClearAll();
+
+ private:
+  SymbolizedStack();
+};
+
+// For now, DataInfo is used to describe global variable.
+struct DataInfo {
+  // Owns all the string members. Storage for them is
+  // (de)allocated using sanitizer internal allocator.
+  char *module;
+  uptr module_offset;
+  char *name;
+  uptr start;
+  uptr size;
+
+  DataInfo();
+  void Clear();
+};
+
+class SymbolizerTool;
+
+class Symbolizer final {
+ public:
+  /// Initialize and return platform-specific implementation of symbolizer
+  /// (if it wasn't already initialized).
+  static Symbolizer *GetOrInit();
+  // Returns a list of symbolized frames for a given address (containing
+  // all inlined functions, if necessary).
+  SymbolizedStack *SymbolizePC(uptr address);
+  bool SymbolizeData(uptr address, DataInfo *info);
+
+  // The module names Symbolizer returns are stable and unique for every given
+  // module.  It is safe to store and compare them as pointers.
+  bool GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
+                                   uptr *module_address);
+  const char *GetModuleNameForPc(uptr pc) {
+    const char *module_name = nullptr;
+    uptr unused;
+    if (GetModuleNameAndOffsetForPC(pc, &module_name, &unused))
+      return module_name;
+    return nullptr;
+  }
+
+  // Release internal caches (if any).
+  void Flush();
+  // Attempts to demangle the provided C++ mangled name.
+  const char *Demangle(const char *name);
+  void PrepareForSandboxing();
+
+  // Allow user to install hooks that would be called before/after Symbolizer
+  // does the actual file/line info fetching. Specific sanitizers may need this
+  // to distinguish system library calls made in user code from calls made
+  // during in-process symbolization.
+  typedef void (*StartSymbolizationHook)();
+  typedef void (*EndSymbolizationHook)();
+  // May be called at most once.
+  void AddHooks(StartSymbolizationHook start_hook,
+                EndSymbolizationHook end_hook);
+
+ private:
+  // GetModuleNameAndOffsetForPC has to return a string to the caller.
+  // Since the corresponding module might get unloaded later, we should create
+  // our owned copies of the strings that we can safely return.
+  // ModuleNameOwner does not provide any synchronization, thus calls to
+  // its method should be protected by |mu_|.
+  class ModuleNameOwner {
+   public:
+    explicit ModuleNameOwner(BlockingMutex *synchronized_by)
+        : storage_(kInitialCapacity), last_match_(nullptr),
+          mu_(synchronized_by) {}
+    const char *GetOwnedCopy(const char *str);
+
+   private:
+    static const uptr kInitialCapacity = 1000;
+    InternalMmapVector<const char*> storage_;
+    const char *last_match_;
+
+    BlockingMutex *mu_;
+  } module_names_;
+
+  /// Platform-specific function for creating a Symbolizer object.
+  static Symbolizer *PlatformInit();
+
+  bool FindModuleNameAndOffsetForAddress(uptr address, const char **module_name,
+                                         uptr *module_offset);
+  LoadedModule *FindModuleForAddress(uptr address);
+  LoadedModule modules_[kMaxNumberOfModules];
+  uptr n_modules_;
+  // If stale, need to reload the modules before looking up addresses.
+  bool modules_fresh_;
+
+  // Platform-specific default demangler, must not return nullptr.
+  const char *PlatformDemangle(const char *name);
+  void PlatformPrepareForSandboxing();
+
+  static Symbolizer *symbolizer_;
+  static StaticSpinMutex init_mu_;
+
+  // Mutex locked from public methods of |Symbolizer|, so that the internals
+  // (including individual symbolizer tools and platform-specific methods) are
+  // always synchronized.
+  BlockingMutex mu_;
+
+  typedef IntrusiveList<SymbolizerTool>::Iterator Iterator;
+  IntrusiveList<SymbolizerTool> tools_;
+
+  explicit Symbolizer(IntrusiveList<SymbolizerTool> tools);
+
+  static LowLevelAllocator symbolizer_allocator_;
+
+  StartSymbolizationHook start_hook_;
+  EndSymbolizationHook end_hook_;
+  class SymbolizerScope {
+   public:
+    explicit SymbolizerScope(const Symbolizer *sym);
+    ~SymbolizerScope();
+   private:
+    const Symbolizer *sym_;
+  };
+};
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_SYMBOLIZER_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h
new file mode 100644
index 0000000..12c70b6
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h
@@ -0,0 +1,151 @@
+//===-- sanitizer_symbolizer_internal.h -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Header for internal classes and functions to be used by implementations of
+// symbolizers.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_SYMBOLIZER_INTERNAL_H
+#define SANITIZER_SYMBOLIZER_INTERNAL_H
+
+#include "sanitizer_symbolizer.h"
+
+namespace __sanitizer {
+
+// Parsing helpers, 'str' is searched for delimiter(s) and a string or uptr
+// is extracted. When extracting a string, a newly allocated (using
+// InternalAlloc) and null-terminataed buffer is returned. They return a pointer
+// to the next characted after the found delimiter.
+const char *ExtractToken(const char *str, const char *delims, char **result);
+const char *ExtractInt(const char *str, const char *delims, int *result);
+const char *ExtractUptr(const char *str, const char *delims, uptr *result);
+const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
+                                      char **result);
+
+const char *DemangleCXXABI(const char *name);
+
+// SymbolizerTool is an interface that is implemented by individual "tools"
+// that can perform symbolication (external llvm-symbolizer, libbacktrace,
+// Windows DbgHelp symbolizer, etc.).
+class SymbolizerTool {
+ public:
+  // The main |Symbolizer| class implements a "fallback chain" of symbolizer
+  // tools. In a request to symbolize an address, if one tool returns false,
+  // the next tool in the chain will be tried.
+  SymbolizerTool *next;
+
+  SymbolizerTool() : next(nullptr) { }
+
+  // Can't declare pure virtual functions in sanitizer runtimes:
+  // __cxa_pure_virtual might be unavailable.
+
+  // The |stack| parameter is inout. It is pre-filled with the address,
+  // module base and module offset values and is to be used to construct
+  // other stack frames.
+  virtual bool SymbolizePC(uptr addr, SymbolizedStack *stack) {
+    UNIMPLEMENTED();
+  }
+
+  // The |info| parameter is inout. It is pre-filled with the module base
+  // and module offset values.
+  virtual bool SymbolizeData(uptr addr, DataInfo *info) {
+    UNIMPLEMENTED();
+  }
+
+  virtual void Flush() {}
+
+  // Return nullptr to fallback to the default platform-specific demangler.
+  virtual const char *Demangle(const char *name) {
+    return nullptr;
+  }
+};
+
+// SymbolizerProcess encapsulates communication between the tool and
+// external symbolizer program, running in a different subprocess.
+// SymbolizerProcess may not be used from two threads simultaneously.
+class SymbolizerProcess {
+ public:
+  explicit SymbolizerProcess(const char *path, bool use_forkpty = false);
+  const char *SendCommand(const char *command);
+
+ protected:
+  virtual bool ReachedEndOfOutput(const char *buffer, uptr length) const {
+    UNIMPLEMENTED();
+  }
+
+  /// The maximum number of arguments required to invoke a tool process.
+  enum { kArgVMax = 6 };
+
+  /// Fill in an argv array to invoke the child process.
+  virtual void GetArgV(const char *path_to_binary,
+                       const char *(&argv)[kArgVMax]) const {
+    UNIMPLEMENTED();
+  }
+
+  virtual bool ReadFromSymbolizer(char *buffer, uptr max_length);
+
+ private:
+  bool Restart();
+  const char *SendCommandImpl(const char *command);
+  bool WriteToSymbolizer(const char *buffer, uptr length);
+  bool StartSymbolizerSubprocess();
+
+  const char *path_;
+  fd_t input_fd_;
+  fd_t output_fd_;
+
+  static const uptr kBufferSize = 16 * 1024;
+  char buffer_[kBufferSize];
+
+  static const uptr kMaxTimesRestarted = 5;
+  static const int kSymbolizerStartupTimeMillis = 10;
+  uptr times_restarted_;
+  bool failed_to_start_;
+  bool reported_invalid_path_;
+  bool use_forkpty_;
+};
+
+class LLVMSymbolizerProcess;
+
+// This tool invokes llvm-symbolizer in a subprocess. It should be as portable
+// as the llvm-symbolizer tool is.
+class LLVMSymbolizer : public SymbolizerTool {
+ public:
+  explicit LLVMSymbolizer(const char *path, LowLevelAllocator *allocator);
+
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+
+  bool SymbolizeData(uptr addr, DataInfo *info) override;
+
+ private:
+  const char *SendCommand(bool is_data, const char *module_name,
+                          uptr module_offset);
+
+  LLVMSymbolizerProcess *symbolizer_process_;
+  static const uptr kBufferSize = 16 * 1024;
+  char buffer_[kBufferSize];
+};
+
+// Parses one or more two-line strings in the following format:
+//   <function_name>
+//   <file_name>:<line_number>[:<column_number>]
+// Used by LLVMSymbolizer, Addr2LinePool and InternalSymbolizer, since all of
+// them use the same output format.  Returns true if any useful debug
+// information was found.
+void ParseSymbolizePCOutput(const char *str, SymbolizedStack *res);
+
+// Parses a two-line string in the following format:
+//   <symbol_name>
+//   <start_address> <size>
+// Used by LLVMSymbolizer and InternalSymbolizer.
+void ParseSymbolizeDataOutput(const char *str, DataInfo *info);
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_SYMBOLIZER_INTERNAL_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc
new file mode 100644
index 0000000..5735466
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc
@@ -0,0 +1,209 @@
+//===-- sanitizer_symbolizer_libbacktrace.cc ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// Libbacktrace implementation of symbolizer parts.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_symbolizer.h"
+#include "sanitizer_symbolizer_libbacktrace.h"
+
+#if SANITIZER_LIBBACKTRACE
+# include "backtrace-supported.h"
+# if SANITIZER_POSIX && BACKTRACE_SUPPORTED && !BACKTRACE_USES_MALLOC
+#  include "backtrace.h"
+#  if SANITIZER_CP_DEMANGLE
+#   undef ARRAY_SIZE
+#   include "demangle.h"
+#  endif
+# else
+#  define SANITIZER_LIBBACKTRACE 0
+# endif
+#endif
+
+namespace __sanitizer {
+
+static char *DemangleAlloc(const char *name, bool always_alloc);
+
+#if SANITIZER_LIBBACKTRACE
+
+namespace {
+
+# if SANITIZER_CP_DEMANGLE
+struct CplusV3DemangleData {
+  char *buf;
+  uptr size, allocated;
+};
+
+extern "C" {
+static void CplusV3DemangleCallback(const char *s, size_t l, void *vdata) {
+  CplusV3DemangleData *data = (CplusV3DemangleData *)vdata;
+  uptr needed = data->size + l + 1;
+  if (needed > data->allocated) {
+    data->allocated *= 2;
+    if (needed > data->allocated)
+      data->allocated = needed;
+    char *buf = (char *)InternalAlloc(data->allocated);
+    if (data->buf) {
+      internal_memcpy(buf, data->buf, data->size);
+      InternalFree(data->buf);
+    }
+    data->buf = buf;
+  }
+  internal_memcpy(data->buf + data->size, s, l);
+  data->buf[data->size + l] = '\0';
+  data->size += l;
+}
+}  // extern "C"
+
+char *CplusV3Demangle(const char *name) {
+  CplusV3DemangleData data;
+  data.buf = 0;
+  data.size = 0;
+  data.allocated = 0;
+  if (cplus_demangle_v3_callback(name, DMGL_PARAMS | DMGL_ANSI,
+                                 CplusV3DemangleCallback, &data)) {
+    if (data.size + 64 > data.allocated)
+      return data.buf;
+    char *buf = internal_strdup(data.buf);
+    InternalFree(data.buf);
+    return buf;
+  }
+  if (data.buf)
+    InternalFree(data.buf);
+  return 0;
+}
+# endif  // SANITIZER_CP_DEMANGLE
+
+struct SymbolizeCodeCallbackArg {
+  SymbolizedStack *first;
+  SymbolizedStack *last;
+  uptr frames_symbolized;
+
+  AddressInfo *get_new_frame(uintptr_t addr) {
+    CHECK(last);
+    if (frames_symbolized > 0) {
+      SymbolizedStack *cur = SymbolizedStack::New(addr);
+      AddressInfo *info = &cur->info;
+      info->FillModuleInfo(first->info.module, first->info.module_offset);
+      last->next = cur;
+      last = cur;
+    }
+    CHECK_EQ(addr, first->info.address);
+    CHECK_EQ(addr, last->info.address);
+    return &last->info;
+  }
+};
+
+extern "C" {
+static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
+                                       const char *filename, int lineno,
+                                       const char *function) {
+  SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
+  if (function) {
+    AddressInfo *info = cdata->get_new_frame(addr);
+    info->function = DemangleAlloc(function, /*always_alloc*/ true);
+    if (filename)
+      info->file = internal_strdup(filename);
+    info->line = lineno;
+    cdata->frames_symbolized++;
+  }
+  return 0;
+}
+
+static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
+                                  const char *symname, uintptr_t, uintptr_t) {
+  SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
+  if (symname) {
+    AddressInfo *info = cdata->get_new_frame(addr);
+    info->function = DemangleAlloc(symname, /*always_alloc*/ true);
+    cdata->frames_symbolized++;
+  }
+}
+
+static void SymbolizeDataCallback(void *vdata, uintptr_t, const char *symname,
+                                  uintptr_t symval, uintptr_t symsize) {
+  DataInfo *info = (DataInfo *)vdata;
+  if (symname && symval) {
+    info->name = DemangleAlloc(symname, /*always_alloc*/ true);
+    info->start = symval;
+    info->size = symsize;
+  }
+}
+
+static void ErrorCallback(void *, const char *, int) {}
+}  // extern "C"
+
+}  // namespace
+
+LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
+  // State created in backtrace_create_state is leaked.
+  void *state = (void *)(backtrace_create_state("/proc/self/exe", 0,
+                                                ErrorCallback, NULL));
+  if (!state)
+    return 0;
+  return new(*alloc) LibbacktraceSymbolizer(state);
+}
+
+bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+  SymbolizeCodeCallbackArg data;
+  data.first = stack;
+  data.last = stack;
+  data.frames_symbolized = 0;
+  backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
+                   ErrorCallback, &data);
+  if (data.frames_symbolized > 0)
+    return true;
+  backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
+                    ErrorCallback, &data);
+  return (data.frames_symbolized > 0);
+}
+
+bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeDataCallback,
+                    ErrorCallback, info);
+  return true;
+}
+
+#else  // SANITIZER_LIBBACKTRACE
+
+LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
+  return 0;
+}
+
+bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+  (void)state_;
+  return false;
+}
+
+bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  return false;
+}
+
+#endif  // SANITIZER_LIBBACKTRACE
+
+static char *DemangleAlloc(const char *name, bool always_alloc) {
+#if SANITIZER_LIBBACKTRACE && SANITIZER_CP_DEMANGLE
+  if (char *demangled = CplusV3Demangle(name))
+    return demangled;
+#endif
+  if (always_alloc)
+    return internal_strdup(name);
+  return 0;
+}
+
+const char *LibbacktraceSymbolizer::Demangle(const char *name) {
+  return DemangleAlloc(name, /*always_alloc*/ false);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.h
new file mode 100644
index 0000000..ddfd475
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.h
@@ -0,0 +1,50 @@
+//===-- sanitizer_symbolizer_libbacktrace.h ---------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// Header for libbacktrace symbolizer.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_SYMBOLIZER_LIBBACKTRACE_H
+#define SANITIZER_SYMBOLIZER_LIBBACKTRACE_H
+
+#include "sanitizer_platform.h"
+#include "sanitizer_common.h"
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_symbolizer_internal.h"
+
+#ifndef SANITIZER_LIBBACKTRACE
+# define SANITIZER_LIBBACKTRACE 0
+#endif
+
+#ifndef SANITIZER_CP_DEMANGLE
+# define SANITIZER_CP_DEMANGLE 0
+#endif
+
+namespace __sanitizer {
+
+class LibbacktraceSymbolizer : public SymbolizerTool {
+ public:
+  static LibbacktraceSymbolizer *get(LowLevelAllocator *alloc);
+
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+
+  bool SymbolizeData(uptr addr, DataInfo *info) override;
+
+  // May return NULL if demangling failed.
+  const char *Demangle(const char *name) override;
+
+ private:
+  explicit LibbacktraceSymbolizer(void *state) : state_(state) {}
+
+  void *state_;  // Leaked.
+};
+
+}  // namespace __sanitizer
+#endif  // SANITIZER_SYMBOLIZER_LIBBACKTRACE_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc
new file mode 100644
index 0000000..8c3ad81
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc
@@ -0,0 +1,428 @@
+//===-- sanitizer_symbolizer_libcdep.cc -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+const char *ExtractToken(const char *str, const char *delims, char **result) {
+  uptr prefix_len = internal_strcspn(str, delims);
+  *result = (char*)InternalAlloc(prefix_len + 1);
+  internal_memcpy(*result, str, prefix_len);
+  (*result)[prefix_len] = '\0';
+  const char *prefix_end = str + prefix_len;
+  if (*prefix_end != '\0') prefix_end++;
+  return prefix_end;
+}
+
+const char *ExtractInt(const char *str, const char *delims, int *result) {
+  char *buff;
+  const char *ret = ExtractToken(str, delims, &buff);
+  if (buff != 0) {
+    *result = (int)internal_atoll(buff);
+  }
+  InternalFree(buff);
+  return ret;
+}
+
+const char *ExtractUptr(const char *str, const char *delims, uptr *result) {
+  char *buff;
+  const char *ret = ExtractToken(str, delims, &buff);
+  if (buff != 0) {
+    *result = (uptr)internal_atoll(buff);
+  }
+  InternalFree(buff);
+  return ret;
+}
+
+const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
+                                      char **result) {
+  const char *found_delimiter = internal_strstr(str, delimiter);
+  uptr prefix_len =
+      found_delimiter ? found_delimiter - str : internal_strlen(str);
+  *result = (char *)InternalAlloc(prefix_len + 1);
+  internal_memcpy(*result, str, prefix_len);
+  (*result)[prefix_len] = '\0';
+  const char *prefix_end = str + prefix_len;
+  if (*prefix_end != '\0') prefix_end += internal_strlen(delimiter);
+  return prefix_end;
+}
+
+SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
+  BlockingMutexLock l(&mu_);
+  const char *module_name;
+  uptr module_offset;
+  SymbolizedStack *res = SymbolizedStack::New(addr);
+  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
+    return res;
+  // Always fill data about module name and offset.
+  res->info.FillModuleInfo(module_name, module_offset);
+  for (auto iter = Iterator(&tools_); iter.hasNext();) {
+    auto *tool = iter.next();
+    SymbolizerScope sym_scope(this);
+    if (tool->SymbolizePC(addr, res)) {
+      return res;
+    }
+  }
+  return res;
+}
+
+bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  BlockingMutexLock l(&mu_);
+  const char *module_name;
+  uptr module_offset;
+  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
+    return false;
+  info->Clear();
+  info->module = internal_strdup(module_name);
+  info->module_offset = module_offset;
+  for (auto iter = Iterator(&tools_); iter.hasNext();) {
+    auto *tool = iter.next();
+    SymbolizerScope sym_scope(this);
+    if (tool->SymbolizeData(addr, info)) {
+      return true;
+    }
+  }
+  return true;
+}
+
+bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
+                                             uptr *module_address) {
+  BlockingMutexLock l(&mu_);
+  const char *internal_module_name = nullptr;
+  if (!FindModuleNameAndOffsetForAddress(pc, &internal_module_name,
+                                         module_address))
+    return false;
+
+  if (module_name)
+    *module_name = module_names_.GetOwnedCopy(internal_module_name);
+  return true;
+}
+
+void Symbolizer::Flush() {
+  BlockingMutexLock l(&mu_);
+  for (auto iter = Iterator(&tools_); iter.hasNext();) {
+    auto *tool = iter.next();
+    SymbolizerScope sym_scope(this);
+    tool->Flush();
+  }
+}
+
+const char *Symbolizer::Demangle(const char *name) {
+  BlockingMutexLock l(&mu_);
+  for (auto iter = Iterator(&tools_); iter.hasNext();) {
+    auto *tool = iter.next();
+    SymbolizerScope sym_scope(this);
+    if (const char *demangled = tool->Demangle(name))
+      return demangled;
+  }
+  return PlatformDemangle(name);
+}
+
+void Symbolizer::PrepareForSandboxing() {
+  BlockingMutexLock l(&mu_);
+  PlatformPrepareForSandboxing();
+}
+
+bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
+                                                   const char **module_name,
+                                                   uptr *module_offset) {
+  LoadedModule *module = FindModuleForAddress(address);
+  if (module == 0)
+    return false;
+  *module_name = module->full_name();
+  *module_offset = address - module->base_address();
+  return true;
+}
+
+LoadedModule *Symbolizer::FindModuleForAddress(uptr address) {
+  bool modules_were_reloaded = false;
+  if (!modules_fresh_) {
+    for (uptr i = 0; i < n_modules_; i++)
+      modules_[i].clear();
+    n_modules_ =
+        GetListOfModules(modules_, kMaxNumberOfModules, /* filter */ nullptr);
+    CHECK_GT(n_modules_, 0);
+    CHECK_LT(n_modules_, kMaxNumberOfModules);
+    modules_fresh_ = true;
+    modules_were_reloaded = true;
+  }
+  for (uptr i = 0; i < n_modules_; i++) {
+    if (modules_[i].containsAddress(address)) {
+      return &modules_[i];
+    }
+  }
+  // Reload the modules and look up again, if we haven't tried it yet.
+  if (!modules_were_reloaded) {
+    // FIXME: set modules_fresh_ from dlopen()/dlclose() interceptors.
+    // It's too aggressive to reload the list of modules each time we fail
+    // to find a module for a given address.
+    modules_fresh_ = false;
+    return FindModuleForAddress(address);
+  }
+  return 0;
+}
+
+Symbolizer *Symbolizer::GetOrInit() {
+  SpinMutexLock l(&init_mu_);
+  if (symbolizer_)
+    return symbolizer_;
+  symbolizer_ = PlatformInit();
+  CHECK(symbolizer_);
+  return symbolizer_;
+}
+
+// For now we assume the following protocol:
+// For each request of the form
+//   <module_name> <module_offset>
+// passed to STDIN, external symbolizer prints to STDOUT response:
+//   <function_name>
+//   <file_name>:<line_number>:<column_number>
+//   <function_name>
+//   <file_name>:<line_number>:<column_number>
+//   ...
+//   <empty line>
+class LLVMSymbolizerProcess : public SymbolizerProcess {
+ public:
+  explicit LLVMSymbolizerProcess(const char *path) : SymbolizerProcess(path) {}
+
+ private:
+  bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
+    // Empty line marks the end of llvm-symbolizer output.
+    return length >= 2 && buffer[length - 1] == '\n' &&
+           buffer[length - 2] == '\n';
+  }
+
+  void GetArgV(const char *path_to_binary,
+               const char *(&argv)[kArgVMax]) const override {
+#if defined(__x86_64h__)
+    const char* const kSymbolizerArch = "--default-arch=x86_64h";
+#elif defined(__x86_64__)
+    const char* const kSymbolizerArch = "--default-arch=x86_64";
+#elif defined(__i386__)
+    const char* const kSymbolizerArch = "--default-arch=i386";
+#elif defined(__powerpc64__) && defined(__BIG_ENDIAN__)
+    const char* const kSymbolizerArch = "--default-arch=powerpc64";
+#elif defined(__powerpc64__) && defined(__LITTLE_ENDIAN__)
+    const char* const kSymbolizerArch = "--default-arch=powerpc64le";
+#else
+    const char* const kSymbolizerArch = "--default-arch=unknown";
+#endif
+
+    const char *const inline_flag = common_flags()->symbolize_inline_frames
+                                        ? "--inlining=true"
+                                        : "--inlining=false";
+    int i = 0;
+    argv[i++] = path_to_binary;
+    argv[i++] = inline_flag;
+    argv[i++] = kSymbolizerArch;
+    argv[i++] = nullptr;
+  }
+};
+
+LLVMSymbolizer::LLVMSymbolizer(const char *path, LowLevelAllocator *allocator)
+    : symbolizer_process_(new(*allocator) LLVMSymbolizerProcess(path)) {}
+
+// Parse a <file>:<line>[:<column>] buffer. The file path may contain colons on
+// Windows, so extract tokens from the right hand side first. The column info is
+// also optional.
+static const char *ParseFileLineInfo(AddressInfo *info, const char *str) {
+  char *file_line_info = 0;
+  str = ExtractToken(str, "\n", &file_line_info);
+  CHECK(file_line_info);
+  // Parse the last :<int>, which must be there.
+  char *last_colon = internal_strrchr(file_line_info, ':');
+  CHECK(last_colon);
+  int line_or_column = internal_atoll(last_colon + 1);
+  // Truncate the string at the last colon and find the next-to-last colon.
+  *last_colon = '\0';
+  last_colon = internal_strrchr(file_line_info, ':');
+  if (last_colon && IsDigit(last_colon[1])) {
+    // If the second-to-last colon is followed by a digit, it must be the line
+    // number, and the previous parsed number was a column.
+    info->line = internal_atoll(last_colon + 1);
+    info->column = line_or_column;
+    *last_colon = '\0';
+  } else {
+    // Otherwise, we have line info but no column info.
+    info->line = line_or_column;
+    info->column = 0;
+  }
+  ExtractToken(file_line_info, "", &info->file);
+  InternalFree(file_line_info);
+  return str;
+}
+
+// Parses one or more two-line strings in the following format:
+//   <function_name>
+//   <file_name>:<line_number>[:<column_number>]
+// Used by LLVMSymbolizer, Addr2LinePool and InternalSymbolizer, since all of
+// them use the same output format.
+void ParseSymbolizePCOutput(const char *str, SymbolizedStack *res) {
+  bool top_frame = true;
+  SymbolizedStack *last = res;
+  while (true) {
+    char *function_name = 0;
+    str = ExtractToken(str, "\n", &function_name);
+    CHECK(function_name);
+    if (function_name[0] == '\0') {
+      // There are no more frames.
+      InternalFree(function_name);
+      break;
+    }
+    SymbolizedStack *cur;
+    if (top_frame) {
+      cur = res;
+      top_frame = false;
+    } else {
+      cur = SymbolizedStack::New(res->info.address);
+      cur->info.FillModuleInfo(res->info.module, res->info.module_offset);
+      last->next = cur;
+      last = cur;
+    }
+
+    AddressInfo *info = &cur->info;
+    info->function = function_name;
+    str = ParseFileLineInfo(info, str);
+
+    // Functions and filenames can be "??", in which case we write 0
+    // to address info to mark that names are unknown.
+    if (0 == internal_strcmp(info->function, "??")) {
+      InternalFree(info->function);
+      info->function = 0;
+    }
+    if (0 == internal_strcmp(info->file, "??")) {
+      InternalFree(info->file);
+      info->file = 0;
+    }
+  }
+}
+
+// Parses a two-line string in the following format:
+//   <symbol_name>
+//   <start_address> <size>
+// Used by LLVMSymbolizer and InternalSymbolizer.
+void ParseSymbolizeDataOutput(const char *str, DataInfo *info) {
+  str = ExtractToken(str, "\n", &info->name);
+  str = ExtractUptr(str, " ", &info->start);
+  str = ExtractUptr(str, "\n", &info->size);
+}
+
+bool LLVMSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+  if (const char *buf = SendCommand(/*is_data*/ false, stack->info.module,
+                                    stack->info.module_offset)) {
+    ParseSymbolizePCOutput(buf, stack);
+    return true;
+  }
+  return false;
+}
+
+bool LLVMSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  if (const char *buf =
+          SendCommand(/*is_data*/ true, info->module, info->module_offset)) {
+    ParseSymbolizeDataOutput(buf, info);
+    info->start += (addr - info->module_offset); // Add the base address.
+    return true;
+  }
+  return false;
+}
+
+const char *LLVMSymbolizer::SendCommand(bool is_data, const char *module_name,
+                                        uptr module_offset) {
+  CHECK(module_name);
+  internal_snprintf(buffer_, kBufferSize, "%s\"%s\" 0x%zx\n",
+                    is_data ? "DATA " : "", module_name, module_offset);
+  return symbolizer_process_->SendCommand(buffer_);
+}
+
+SymbolizerProcess::SymbolizerProcess(const char *path, bool use_forkpty)
+    : path_(path),
+      input_fd_(kInvalidFd),
+      output_fd_(kInvalidFd),
+      times_restarted_(0),
+      failed_to_start_(false),
+      reported_invalid_path_(false),
+      use_forkpty_(use_forkpty) {
+  CHECK(path_);
+  CHECK_NE(path_[0], '\0');
+}
+
+const char *SymbolizerProcess::SendCommand(const char *command) {
+  for (; times_restarted_ < kMaxTimesRestarted; times_restarted_++) {
+    // Start or restart symbolizer if we failed to send command to it.
+    if (const char *res = SendCommandImpl(command))
+      return res;
+    Restart();
+  }
+  if (!failed_to_start_) {
+    Report("WARNING: Failed to use and restart external symbolizer!\n");
+    failed_to_start_ = true;
+  }
+  return 0;
+}
+
+const char *SymbolizerProcess::SendCommandImpl(const char *command) {
+  if (input_fd_ == kInvalidFd || output_fd_ == kInvalidFd)
+      return 0;
+  if (!WriteToSymbolizer(command, internal_strlen(command)))
+      return 0;
+  if (!ReadFromSymbolizer(buffer_, kBufferSize))
+      return 0;
+  return buffer_;
+}
+
+bool SymbolizerProcess::Restart() {
+  if (input_fd_ != kInvalidFd)
+    CloseFile(input_fd_);
+  if (output_fd_ != kInvalidFd)
+    CloseFile(output_fd_);
+  return StartSymbolizerSubprocess();
+}
+
+bool SymbolizerProcess::ReadFromSymbolizer(char *buffer, uptr max_length) {
+  if (max_length == 0)
+    return true;
+  uptr read_len = 0;
+  while (true) {
+    uptr just_read = 0;
+    bool success = ReadFromFile(input_fd_, buffer + read_len,
+                                max_length - read_len - 1, &just_read);
+    // We can't read 0 bytes, as we don't expect external symbolizer to close
+    // its stdout.
+    if (!success || just_read == 0) {
+      Report("WARNING: Can't read from symbolizer at fd %d\n", input_fd_);
+      return false;
+    }
+    read_len += just_read;
+    if (ReachedEndOfOutput(buffer, read_len))
+      break;
+  }
+  buffer[read_len] = '\0';
+  return true;
+}
+
+bool SymbolizerProcess::WriteToSymbolizer(const char *buffer, uptr length) {
+  if (length == 0)
+    return true;
+  uptr write_len = 0;
+  bool success = WriteToFile(output_fd_, buffer, length, &write_len);
+  if (!success || write_len != length) {
+    Report("WARNING: Can't write to symbolizer at fd %d\n", output_fd_);
+    return false;
+  }
+  return true;
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.cc b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.cc
new file mode 100644
index 0000000..64048fa
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.cc
@@ -0,0 +1,190 @@
+//===-- sanitizer_symbolizer_mac.cc ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Implementation of Mac-specific "atos" symbolizer.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_mac.h"
+#include "sanitizer_symbolizer_mac.h"
+
+namespace __sanitizer {
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <util.h>
+
+bool DlAddrSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+  Dl_info info;
+  int result = dladdr((const void *)addr, &info);
+  if (!result) return false;
+  const char *demangled = DemangleCXXABI(info.dli_sname);
+  stack->info.function = demangled ? internal_strdup(demangled) : nullptr;
+  return true;
+}
+
+bool DlAddrSymbolizer::SymbolizeData(uptr addr, DataInfo *datainfo) {
+  Dl_info info;
+  int result = dladdr((const void *)addr, &info);
+  if (!result) return false;
+  const char *demangled = DemangleCXXABI(info.dli_sname);
+  datainfo->name = internal_strdup(demangled);
+  datainfo->start = (uptr)info.dli_saddr;
+  return true;
+}
+
+class AtosSymbolizerProcess : public SymbolizerProcess {
+ public:
+  explicit AtosSymbolizerProcess(const char *path, pid_t parent_pid)
+      : SymbolizerProcess(path, /*use_forkpty*/ true) {
+    // Put the string command line argument in the object so that it outlives
+    // the call to GetArgV.
+    internal_snprintf(pid_str_, sizeof(pid_str_), "%d", parent_pid);
+  }
+
+ private:
+  bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
+    return (length >= 1 && buffer[length - 1] == '\n');
+  }
+
+  void GetArgV(const char *path_to_binary,
+               const char *(&argv)[kArgVMax]) const override {
+    int i = 0;
+    argv[i++] = path_to_binary;
+    argv[i++] = "-p";
+    argv[i++] = &pid_str_[0];
+    if (GetMacosVersion() == MACOS_VERSION_MAVERICKS) {
+      // On Mavericks atos prints a deprecation warning which we suppress by
+      // passing -d. The warning isn't present on other OSX versions, even the
+      // newer ones.
+      argv[i++] = "-d";
+    }
+    argv[i++] = nullptr;
+  }
+
+  char pid_str_[16];
+};
+
+static const char *kAtosErrorMessages[] = {
+  "atos cannot examine process",
+  "unable to get permission to examine process",
+  "An admin user name and password is required",
+  "could not load inserted library",
+  "architecture mismatch between analysis process",
+};
+
+static bool IsAtosErrorMessage(const char *str) {
+  for (uptr i = 0; i < ARRAY_SIZE(kAtosErrorMessages); i++) {
+    if (internal_strstr(str, kAtosErrorMessages[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool ParseCommandOutput(const char *str, uptr addr, char **out_name,
+                               char **out_module, char **out_file, uptr *line,
+                               uptr *start_address) {
+  // Trim ending newlines.
+  char *trim;
+  ExtractTokenUpToDelimiter(str, "\n", &trim);
+
+  // The line from `atos` is in one of these formats:
+  //   myfunction (in library.dylib) (sourcefile.c:17)
+  //   myfunction (in library.dylib) + 0x1fe
+  //   myfunction (in library.dylib) + 15
+  //   0xdeadbeef (in library.dylib) + 0x1fe
+  //   0xdeadbeef (in library.dylib) + 15
+  //   0xdeadbeef (in library.dylib)
+  //   0xdeadbeef
+
+  if (IsAtosErrorMessage(trim)) {
+    Report("atos returned an error: %s\n", trim);
+    InternalFree(trim);
+    return false;
+  }
+
+  const char *rest = trim;
+  char *symbol_name;
+  rest = ExtractTokenUpToDelimiter(rest, " (in ", &symbol_name);
+  if (rest[0] == '\0') {
+    InternalFree(symbol_name);
+    InternalFree(trim);
+    return false;
+  }
+
+  if (internal_strncmp(symbol_name, "0x", 2) != 0)
+    *out_name = symbol_name;
+  else
+    InternalFree(symbol_name);
+  rest = ExtractTokenUpToDelimiter(rest, ") ", out_module);
+
+  if (rest[0] == '(') {
+    if (out_file) {
+      rest++;
+      rest = ExtractTokenUpToDelimiter(rest, ":", out_file);
+      char *extracted_line_number;
+      rest = ExtractTokenUpToDelimiter(rest, ")", &extracted_line_number);
+      if (line) *line = (uptr)internal_atoll(extracted_line_number);
+      InternalFree(extracted_line_number);
+    }
+  } else if (rest[0] == '+') {
+    rest += 2;
+    uptr offset = internal_atoll(rest);
+    if (start_address) *start_address = addr - offset;
+  }
+
+  InternalFree(trim);
+  return true;
+}
+
+AtosSymbolizer::AtosSymbolizer(const char *path, LowLevelAllocator *allocator)
+    : process_(new(*allocator) AtosSymbolizerProcess(path, getpid())) {}
+
+bool AtosSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+  if (!process_) return false;
+  char command[32];
+  internal_snprintf(command, sizeof(command), "0x%zx\n", addr);
+  const char *buf = process_->SendCommand(command);
+  if (!buf) return false;
+  uptr line;
+  if (!ParseCommandOutput(buf, addr, &stack->info.function, &stack->info.module,
+                          &stack->info.file, &line, nullptr)) {
+    process_ = nullptr;
+    return false;
+  }
+  stack->info.line = (int)line;
+  return true;
+}
+
+bool AtosSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  if (!process_) return false;
+  char command[32];
+  internal_snprintf(command, sizeof(command), "0x%zx\n", addr);
+  const char *buf = process_->SendCommand(command);
+  if (!buf) return false;
+  if (!ParseCommandOutput(buf, addr, &info->name, &info->module, nullptr,
+                          nullptr, &info->start)) {
+    process_ = nullptr;
+    return false;
+  }
+  return true;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.h
new file mode 100644
index 0000000..068644d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.h
@@ -0,0 +1,48 @@
+//===-- sanitizer_symbolizer_mac.h ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Header for Mac-specific "atos" symbolizer.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_SYMBOLIZER_MAC_H
+#define SANITIZER_SYMBOLIZER_MAC_H
+
+#include "sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+class DlAddrSymbolizer : public SymbolizerTool {
+ public:
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+  bool SymbolizeData(uptr addr, DataInfo *info) override;
+};
+
+class AtosSymbolizerProcess;
+
+class AtosSymbolizer : public SymbolizerTool {
+ public:
+  explicit AtosSymbolizer(const char *path, LowLevelAllocator *allocator);
+
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+  bool SymbolizeData(uptr addr, DataInfo *info) override;
+
+ private:
+  AtosSymbolizerProcess *process_;
+};
+
+} // namespace __sanitizer
+
+#endif  // SANITIZER_MAC
+
+#endif // SANITIZER_SYMBOLIZER_MAC_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
new file mode 100644
index 0000000..fc8a7d9
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc
@@ -0,0 +1,466 @@
+//===-- sanitizer_symbolizer_posix_libcdep.cc -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// POSIX-specific implementation of symbolizer parts.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_POSIX
+#include "sanitizer_allocator_internal.h"
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_linux.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_posix.h"
+#include "sanitizer_procmaps.h"
+#include "sanitizer_symbolizer_internal.h"
+#include "sanitizer_symbolizer_libbacktrace.h"
+#include "sanitizer_symbolizer_mac.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#if SANITIZER_MAC
+#include <util.h>  // for forkpty()
+#endif  // SANITIZER_MAC
+
+// C++ demangling function, as required by Itanium C++ ABI. This is weak,
+// because we do not require a C++ ABI library to be linked to a program
+// using sanitizers; if it's not present, we'll just use the mangled name.
+namespace __cxxabiv1 {
+  extern "C" SANITIZER_WEAK_ATTRIBUTE
+  char *__cxa_demangle(const char *mangled, char *buffer,
+                                  size_t *length, int *status);
+}
+
+namespace __sanitizer {
+
+// Attempts to demangle the name via __cxa_demangle from __cxxabiv1.
+const char *DemangleCXXABI(const char *name) {
+  // FIXME: __cxa_demangle aggressively insists on allocating memory.
+  // There's not much we can do about that, short of providing our
+  // own demangler (libc++abi's implementation could be adapted so that
+  // it does not allocate). For now, we just call it anyway, and we leak
+  // the returned value.
+  if (__cxxabiv1::__cxa_demangle)
+    if (const char *demangled_name =
+          __cxxabiv1::__cxa_demangle(name, 0, 0, 0))
+      return demangled_name;
+
+  return name;
+}
+
+bool SymbolizerProcess::StartSymbolizerSubprocess() {
+  if (!FileExists(path_)) {
+    if (!reported_invalid_path_) {
+      Report("WARNING: invalid path to external symbolizer!\n");
+      reported_invalid_path_ = true;
+    }
+    return false;
+  }
+
+  int pid;
+  if (use_forkpty_) {
+#if SANITIZER_MAC
+    fd_t fd = kInvalidFd;
+    // Use forkpty to disable buffering in the new terminal.
+    pid = internal_forkpty(&fd);
+    if (pid == -1) {
+      // forkpty() failed.
+      Report("WARNING: failed to fork external symbolizer (errno: %d)\n",
+             errno);
+      return false;
+    } else if (pid == 0) {
+      // Child subprocess.
+      const char *argv[kArgVMax];
+      GetArgV(path_, argv);
+      execv(path_, const_cast<char **>(&argv[0]));
+      internal__exit(1);
+    }
+
+    // Continue execution in parent process.
+    input_fd_ = output_fd_ = fd;
+
+    // Disable echo in the new terminal, disable CR.
+    struct termios termflags;
+    tcgetattr(fd, &termflags);
+    termflags.c_oflag &= ~ONLCR;
+    termflags.c_lflag &= ~ECHO;
+    tcsetattr(fd, TCSANOW, &termflags);
+#else  // SANITIZER_MAC
+    UNIMPLEMENTED();
+#endif  // SANITIZER_MAC
+  } else {
+    int *infd = NULL;
+    int *outfd = NULL;
+    // The client program may close its stdin and/or stdout and/or stderr
+    // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
+    // In this case the communication between the forked processes may be
+    // broken if either the parent or the child tries to close or duplicate
+    // these descriptors. The loop below produces two pairs of file
+    // descriptors, each greater than 2 (stderr).
+    int sock_pair[5][2];
+    for (int i = 0; i < 5; i++) {
+      if (pipe(sock_pair[i]) == -1) {
+        for (int j = 0; j < i; j++) {
+          internal_close(sock_pair[j][0]);
+          internal_close(sock_pair[j][1]);
+        }
+        Report("WARNING: Can't create a socket pair to start "
+               "external symbolizer (errno: %d)\n", errno);
+        return false;
+      } else if (sock_pair[i][0] > 2 && sock_pair[i][1] > 2) {
+        if (infd == NULL) {
+          infd = sock_pair[i];
+        } else {
+          outfd = sock_pair[i];
+          for (int j = 0; j < i; j++) {
+            if (sock_pair[j] == infd) continue;
+            internal_close(sock_pair[j][0]);
+            internal_close(sock_pair[j][1]);
+          }
+          break;
+        }
+      }
+    }
+    CHECK(infd);
+    CHECK(outfd);
+
+    // Real fork() may call user callbacks registered with pthread_atfork().
+    pid = internal_fork();
+    if (pid == -1) {
+      // Fork() failed.
+      internal_close(infd[0]);
+      internal_close(infd[1]);
+      internal_close(outfd[0]);
+      internal_close(outfd[1]);
+      Report("WARNING: failed to fork external symbolizer "
+             " (errno: %d)\n", errno);
+      return false;
+    } else if (pid == 0) {
+      // Child subprocess.
+      internal_close(STDOUT_FILENO);
+      internal_close(STDIN_FILENO);
+      internal_dup2(outfd[0], STDIN_FILENO);
+      internal_dup2(infd[1], STDOUT_FILENO);
+      internal_close(outfd[0]);
+      internal_close(outfd[1]);
+      internal_close(infd[0]);
+      internal_close(infd[1]);
+      for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--)
+        internal_close(fd);
+      const char *argv[kArgVMax];
+      GetArgV(path_, argv);
+      execv(path_, const_cast<char **>(&argv[0]));
+      internal__exit(1);
+    }
+
+    // Continue execution in parent process.
+    internal_close(outfd[0]);
+    internal_close(infd[1]);
+    input_fd_ = infd[0];
+    output_fd_ = outfd[1];
+  }
+
+  // Check that symbolizer subprocess started successfully.
+  int pid_status;
+  SleepForMillis(kSymbolizerStartupTimeMillis);
+  int exited_pid = waitpid(pid, &pid_status, WNOHANG);
+  if (exited_pid != 0) {
+    // Either waitpid failed, or child has already exited.
+    Report("WARNING: external symbolizer didn't start up correctly!\n");
+    return false;
+  }
+
+  return true;
+}
+
+class Addr2LineProcess : public SymbolizerProcess {
+ public:
+  Addr2LineProcess(const char *path, const char *module_name)
+      : SymbolizerProcess(path), module_name_(internal_strdup(module_name)) {}
+
+  const char *module_name() const { return module_name_; }
+
+ private:
+  void GetArgV(const char *path_to_binary,
+               const char *(&argv)[kArgVMax]) const override {
+    int i = 0;
+    argv[i++] = path_to_binary;
+    argv[i++] = "-iCfe";
+    argv[i++] = module_name_;
+    argv[i++] = nullptr;
+  }
+
+  bool ReachedEndOfOutput(const char *buffer, uptr length) const override;
+
+  bool ReadFromSymbolizer(char *buffer, uptr max_length) override {
+    if (!SymbolizerProcess::ReadFromSymbolizer(buffer, max_length))
+      return false;
+    // We should cut out output_terminator_ at the end of given buffer,
+    // appended by addr2line to mark the end of its meaningful output.
+    // We cannot scan buffer from it's beginning, because it is legal for it
+    // to start with output_terminator_ in case given offset is invalid. So,
+    // scanning from second character.
+    char *garbage = internal_strstr(buffer + 1, output_terminator_);
+    // This should never be NULL since buffer must end up with
+    // output_terminator_.
+    CHECK(garbage);
+    // Trim the buffer.
+    garbage[0] = '\0';
+    return true;
+  }
+
+  const char *module_name_;  // Owned, leaked.
+  static const char output_terminator_[];
+};
+
+const char Addr2LineProcess::output_terminator_[] = "??\n??:0\n";
+
+bool Addr2LineProcess::ReachedEndOfOutput(const char *buffer,
+                                          uptr length) const {
+  const size_t kTerminatorLen = sizeof(output_terminator_) - 1;
+  // Skip, if we read just kTerminatorLen bytes, because Addr2Line output
+  // should consist at least of two pairs of lines:
+  // 1. First one, corresponding to given offset to be symbolized
+  // (may be equal to output_terminator_, if offset is not valid).
+  // 2. Second one for output_terminator_, itself to mark the end of output.
+  if (length <= kTerminatorLen) return false;
+  // Addr2Line output should end up with output_terminator_.
+  return !internal_memcmp(buffer + length - kTerminatorLen,
+                          output_terminator_, kTerminatorLen);
+}
+
+class Addr2LinePool : public SymbolizerTool {
+ public:
+  explicit Addr2LinePool(const char *addr2line_path,
+                         LowLevelAllocator *allocator)
+      : addr2line_path_(addr2line_path), allocator_(allocator),
+        addr2line_pool_(16) {}
+
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override {
+    if (const char *buf =
+            SendCommand(stack->info.module, stack->info.module_offset)) {
+      ParseSymbolizePCOutput(buf, stack);
+      return true;
+    }
+    return false;
+  }
+
+  bool SymbolizeData(uptr addr, DataInfo *info) override {
+    return false;
+  }
+
+ private:
+  const char *SendCommand(const char *module_name, uptr module_offset) {
+    Addr2LineProcess *addr2line = 0;
+    for (uptr i = 0; i < addr2line_pool_.size(); ++i) {
+      if (0 ==
+          internal_strcmp(module_name, addr2line_pool_[i]->module_name())) {
+        addr2line = addr2line_pool_[i];
+        break;
+      }
+    }
+    if (!addr2line) {
+      addr2line =
+          new(*allocator_) Addr2LineProcess(addr2line_path_, module_name);
+      addr2line_pool_.push_back(addr2line);
+    }
+    CHECK_EQ(0, internal_strcmp(module_name, addr2line->module_name()));
+    char buffer[kBufferSize];
+    internal_snprintf(buffer, kBufferSize, "0x%zx\n0x%zx\n",
+                      module_offset, dummy_address_);
+    return addr2line->SendCommand(buffer);
+  }
+
+  static const uptr kBufferSize = 64;
+  const char *addr2line_path_;
+  LowLevelAllocator *allocator_;
+  InternalMmapVector<Addr2LineProcess*> addr2line_pool_;
+  static const uptr dummy_address_ =
+      FIRST_32_SECOND_64(UINT32_MAX, UINT64_MAX);
+};
+
+#if SANITIZER_SUPPORTS_WEAK_HOOKS
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+bool __sanitizer_symbolize_code(const char *ModuleName, u64 ModuleOffset,
+                                char *Buffer, int MaxLength);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+bool __sanitizer_symbolize_data(const char *ModuleName, u64 ModuleOffset,
+                                char *Buffer, int MaxLength);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+void __sanitizer_symbolize_flush();
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+int __sanitizer_symbolize_demangle(const char *Name, char *Buffer,
+                                   int MaxLength);
+}  // extern "C"
+
+class InternalSymbolizer : public SymbolizerTool {
+ public:
+  static InternalSymbolizer *get(LowLevelAllocator *alloc) {
+    if (__sanitizer_symbolize_code != 0 &&
+        __sanitizer_symbolize_data != 0) {
+      return new(*alloc) InternalSymbolizer();
+    }
+    return 0;
+  }
+
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override {
+    bool result = __sanitizer_symbolize_code(
+        stack->info.module, stack->info.module_offset, buffer_, kBufferSize);
+    if (result) ParseSymbolizePCOutput(buffer_, stack);
+    return result;
+  }
+
+  bool SymbolizeData(uptr addr, DataInfo *info) override {
+    bool result = __sanitizer_symbolize_data(info->module, info->module_offset,
+                                             buffer_, kBufferSize);
+    if (result) {
+      ParseSymbolizeDataOutput(buffer_, info);
+      info->start += (addr - info->module_offset);  // Add the base address.
+    }
+    return result;
+  }
+
+  void Flush() override {
+    if (__sanitizer_symbolize_flush)
+      __sanitizer_symbolize_flush();
+  }
+
+  const char *Demangle(const char *name) override {
+    if (__sanitizer_symbolize_demangle) {
+      for (uptr res_length = 1024;
+           res_length <= InternalSizeClassMap::kMaxSize;) {
+        char *res_buff = static_cast<char*>(InternalAlloc(res_length));
+        uptr req_length =
+            __sanitizer_symbolize_demangle(name, res_buff, res_length);
+        if (req_length > res_length) {
+          res_length = req_length + 1;
+          InternalFree(res_buff);
+          continue;
+        }
+        return res_buff;
+      }
+    }
+    return name;
+  }
+
+ private:
+  InternalSymbolizer() { }
+
+  static const int kBufferSize = 16 * 1024;
+  static const int kMaxDemangledNameSize = 1024;
+  char buffer_[kBufferSize];
+};
+#else  // SANITIZER_SUPPORTS_WEAK_HOOKS
+
+class InternalSymbolizer : public SymbolizerTool {
+ public:
+  static InternalSymbolizer *get(LowLevelAllocator *alloc) { return 0; }
+};
+
+#endif  // SANITIZER_SUPPORTS_WEAK_HOOKS
+
+const char *Symbolizer::PlatformDemangle(const char *name) {
+  return DemangleCXXABI(name);
+}
+
+void Symbolizer::PlatformPrepareForSandboxing() {}
+
+static SymbolizerTool *ChooseExternalSymbolizer(LowLevelAllocator *allocator) {
+  const char *path = common_flags()->external_symbolizer_path;
+  const char *binary_name = path ? StripModuleName(path) : "";
+  if (path && path[0] == '\0') {
+    VReport(2, "External symbolizer is explicitly disabled.\n");
+    return nullptr;
+  } else if (!internal_strcmp(binary_name, "llvm-symbolizer")) {
+    VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path);
+    return new(*allocator) LLVMSymbolizer(path, allocator);
+  } else if (!internal_strcmp(binary_name, "atos")) {
+#if SANITIZER_MAC
+    VReport(2, "Using atos at user-specified path: %s\n", path);
+    return new(*allocator) AtosSymbolizer(path, allocator);
+#else  // SANITIZER_MAC
+    Report("ERROR: Using `atos` is only supported on Darwin.\n");
+    Die();
+#endif  // SANITIZER_MAC
+  } else if (!internal_strcmp(binary_name, "addr2line")) {
+    VReport(2, "Using addr2line at user-specified path: %s\n", path);
+    return new(*allocator) Addr2LinePool(path, allocator);
+  } else if (path) {
+    Report("ERROR: External symbolizer path is set to '%s' which isn't "
+           "a known symbolizer. Please set the path to the llvm-symbolizer "
+           "binary or other known tool.\n", path);
+    Die();
+  }
+
+  // Otherwise symbolizer program is unknown, let's search $PATH
+  CHECK(path == nullptr);
+  if (const char *found_path = FindPathToBinary("llvm-symbolizer")) {
+    VReport(2, "Using llvm-symbolizer found at: %s\n", found_path);
+    return new(*allocator) LLVMSymbolizer(found_path, allocator);
+  }
+#if SANITIZER_MAC
+  if (const char *found_path = FindPathToBinary("atos")) {
+    VReport(2, "Using atos found at: %s\n", found_path);
+    return new(*allocator) AtosSymbolizer(found_path, allocator);
+  }
+#endif  // SANITIZER_MAC
+  if (common_flags()->allow_addr2line) {
+    if (const char *found_path = FindPathToBinary("addr2line")) {
+      VReport(2, "Using addr2line found at: %s\n", found_path);
+      return new(*allocator) Addr2LinePool(found_path, allocator);
+    }
+  }
+  return nullptr;
+}
+
+static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
+                                  LowLevelAllocator *allocator) {
+  if (!common_flags()->symbolize) {
+    VReport(2, "Symbolizer is disabled.\n");
+    return;
+  }
+  if (SymbolizerTool *tool = InternalSymbolizer::get(allocator)) {
+    VReport(2, "Using internal symbolizer.\n");
+    list->push_back(tool);
+    return;
+  }
+  if (SymbolizerTool *tool = LibbacktraceSymbolizer::get(allocator)) {
+    VReport(2, "Using libbacktrace symbolizer.\n");
+    list->push_back(tool);
+    return;
+  }
+
+  if (SymbolizerTool *tool = ChooseExternalSymbolizer(allocator)) {
+    list->push_back(tool);
+  }
+
+#if SANITIZER_MAC
+  VReport(2, "Using dladdr symbolizer.\n");
+  list->push_back(new(*allocator) DlAddrSymbolizer());
+#endif  // SANITIZER_MAC
+}
+
+Symbolizer *Symbolizer::PlatformInit() {
+  IntrusiveList<SymbolizerTool> list;
+  list.clear();
+  ChooseSymbolizerTools(&list, &symbolizer_allocator_);
+  return new(symbolizer_allocator_) Symbolizer(list);
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_POSIX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cc b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cc
new file mode 100644
index 0000000..b1dceeb
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cc
@@ -0,0 +1,284 @@
+//===-- sanitizer_symbolizer_win.cc ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// Windows-specific implementation of symbolizer parts.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_WINDOWS
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <dbghelp.h>
+#pragma comment(lib, "dbghelp.lib")
+
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+namespace {
+
+class WinSymbolizerTool : public SymbolizerTool {
+ public:
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+  bool SymbolizeData(uptr addr, DataInfo *info) override {
+    return false;
+  }
+  const char *Demangle(const char *name) override;
+};
+
+bool is_dbghelp_initialized = false;
+
+bool TrySymInitialize() {
+  SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME | SYMOPT_LOAD_LINES);
+  return SymInitialize(GetCurrentProcess(), 0, TRUE);
+  // FIXME: We don't call SymCleanup() on exit yet - should we?
+}
+
+// Initializes DbgHelp library, if it's not yet initialized. Calls to this
+// function should be synchronized with respect to other calls to DbgHelp API
+// (e.g. from WinSymbolizerTool).
+void InitializeDbgHelpIfNeeded() {
+  if (is_dbghelp_initialized)
+    return;
+  if (!TrySymInitialize()) {
+    // OK, maybe the client app has called SymInitialize already.
+    // That's a bit unfortunate for us as all the DbgHelp functions are
+    // single-threaded and we can't coordinate with the app.
+    // FIXME: Can we stop the other threads at this point?
+    // Anyways, we have to reconfigure stuff to make sure that SymInitialize
+    // has all the appropriate options set.
+    // Cross our fingers and reinitialize DbgHelp.
+    Report("*** WARNING: Failed to initialize DbgHelp!              ***\n");
+    Report("*** Most likely this means that the app is already      ***\n");
+    Report("*** using DbgHelp, possibly with incompatible flags.    ***\n");
+    Report("*** Due to technical reasons, symbolization might crash ***\n");
+    Report("*** or produce wrong results.                           ***\n");
+    SymCleanup(GetCurrentProcess());
+    TrySymInitialize();
+  }
+  is_dbghelp_initialized = true;
+
+  // When an executable is run from a location different from the one where it
+  // was originally built, we may not see the nearby PDB files.
+  // To work around this, let's append the directory of the main module
+  // to the symbol search path.  All the failures below are not fatal.
+  const size_t kSymPathSize = 2048;
+  static wchar_t path_buffer[kSymPathSize + 1 + MAX_PATH];
+  if (!SymGetSearchPathW(GetCurrentProcess(), path_buffer, kSymPathSize)) {
+    Report("*** WARNING: Failed to SymGetSearchPathW ***\n");
+    return;
+  }
+  size_t sz = wcslen(path_buffer);
+  if (sz) {
+    CHECK_EQ(0, wcscat_s(path_buffer, L";"));
+    sz++;
+  }
+  DWORD res = GetModuleFileNameW(NULL, path_buffer + sz, MAX_PATH);
+  if (res == 0 || res == MAX_PATH) {
+    Report("*** WARNING: Failed to getting the EXE directory ***\n");
+    return;
+  }
+  // Write the zero character in place of the last backslash to get the
+  // directory of the main module at the end of path_buffer.
+  wchar_t *last_bslash = wcsrchr(path_buffer + sz, L'\\');
+  CHECK_NE(last_bslash, 0);
+  *last_bslash = L'\0';
+  if (!SymSetSearchPathW(GetCurrentProcess(), path_buffer)) {
+    Report("*** WARNING: Failed to SymSetSearchPathW\n");
+    return;
+  }
+}
+
+}  // namespace
+
+bool WinSymbolizerTool::SymbolizePC(uptr addr, SymbolizedStack *frame) {
+  InitializeDbgHelpIfNeeded();
+
+  // See http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
+  char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(CHAR)];
+  PSYMBOL_INFO symbol = (PSYMBOL_INFO)buffer;
+  symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+  symbol->MaxNameLen = MAX_SYM_NAME;
+  DWORD64 offset = 0;
+  BOOL got_objname = SymFromAddr(GetCurrentProcess(),
+                                 (DWORD64)addr, &offset, symbol);
+  if (!got_objname)
+    return false;
+
+  DWORD unused;
+  IMAGEHLP_LINE64 line_info;
+  line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+  BOOL got_fileline = SymGetLineFromAddr64(GetCurrentProcess(), (DWORD64)addr,
+                                           &unused, &line_info);
+  frame->info.function = internal_strdup(symbol->Name);
+  frame->info.function_offset = (uptr)offset;
+  if (got_fileline) {
+    frame->info.file = internal_strdup(line_info.FileName);
+    frame->info.line = line_info.LineNumber;
+  }
+  // Only consider this a successful symbolization attempt if we got file info.
+  // Otherwise, try llvm-symbolizer.
+  return got_fileline;
+}
+
+const char *WinSymbolizerTool::Demangle(const char *name) {
+  CHECK(is_dbghelp_initialized);
+  static char demangle_buffer[1000];
+  if (name[0] == '\01' &&
+      UnDecorateSymbolName(name + 1, demangle_buffer, sizeof(demangle_buffer),
+                           UNDNAME_NAME_ONLY))
+    return demangle_buffer;
+  else
+    return name;
+}
+
+const char *Symbolizer::PlatformDemangle(const char *name) {
+  return name;
+}
+
+void Symbolizer::PlatformPrepareForSandboxing() {
+  // Do nothing.
+}
+
+namespace {
+struct ScopedHandle {
+  ScopedHandle() : h_(nullptr) {}
+  explicit ScopedHandle(HANDLE h) : h_(h) {}
+  ~ScopedHandle() {
+    if (h_)
+      ::CloseHandle(h_);
+  }
+  HANDLE get() { return h_; }
+  HANDLE *receive() { return &h_; }
+  HANDLE release() {
+    HANDLE h = h_;
+    h_ = nullptr;
+    return h;
+  }
+  HANDLE h_;
+};
+} // namespace
+
+bool SymbolizerProcess::StartSymbolizerSubprocess() {
+  // Create inherited pipes for stdin and stdout.
+  ScopedHandle stdin_read, stdin_write;
+  ScopedHandle stdout_read, stdout_write;
+  SECURITY_ATTRIBUTES attrs;
+  attrs.nLength = sizeof(SECURITY_ATTRIBUTES);
+  attrs.bInheritHandle = TRUE;
+  attrs.lpSecurityDescriptor = nullptr;
+  if (!::CreatePipe(stdin_read.receive(), stdin_write.receive(), &attrs, 0) ||
+      !::CreatePipe(stdout_read.receive(), stdout_write.receive(), &attrs, 0)) {
+    VReport(2, "WARNING: %s CreatePipe failed (error code: %d)\n",
+            SanitizerToolName, path_, GetLastError());
+    return false;
+  }
+
+  // Don't inherit the writing end of stdin or the reading end of stdout.
+  if (!SetHandleInformation(stdin_write.get(), HANDLE_FLAG_INHERIT, 0) ||
+      !SetHandleInformation(stdout_read.get(), HANDLE_FLAG_INHERIT, 0)) {
+    VReport(2, "WARNING: %s SetHandleInformation failed (error code: %d)\n",
+            SanitizerToolName, path_, GetLastError());
+    return false;
+  }
+
+  // Compute the command line. Wrap double quotes around everything.
+  const char *argv[kArgVMax];
+  GetArgV(path_, argv);
+  InternalScopedString command_line(kMaxPathLength * 3);
+  for (int i = 0; argv[i]; i++) {
+    const char *arg = argv[i];
+    int arglen = internal_strlen(arg);
+    // Check that tool command lines are simple and that complete escaping is
+    // unnecessary.
+    CHECK(!internal_strchr(arg, '"') && "quotes in args unsupported");
+    CHECK(!internal_strstr(arg, "\\\\") &&
+          "double backslashes in args unsupported");
+    CHECK(arglen > 0 && arg[arglen - 1] != '\\' &&
+          "args ending in backslash and empty args unsupported");
+    command_line.append("\"%s\" ", arg);
+  }
+  VReport(3, "Launching symbolizer command: %s\n", command_line.data());
+
+  // Launch llvm-symbolizer with stdin and stdout redirected.
+  STARTUPINFOA si;
+  memset(&si, 0, sizeof(si));
+  si.cb = sizeof(si);
+  si.dwFlags |= STARTF_USESTDHANDLES;
+  si.hStdInput = stdin_read.get();
+  si.hStdOutput = stdout_write.get();
+  PROCESS_INFORMATION pi;
+  memset(&pi, 0, sizeof(pi));
+  if (!CreateProcessA(path_,               // Executable
+                      command_line.data(), // Command line
+                      nullptr,             // Process handle not inheritable
+                      nullptr,             // Thread handle not inheritable
+                      TRUE,                // Set handle inheritance to TRUE
+                      0,                   // Creation flags
+                      nullptr,             // Use parent's environment block
+                      nullptr,             // Use parent's starting directory
+                      &si, &pi)) {
+    VReport(2, "WARNING: %s failed to create process for %s (error code: %d)\n",
+            SanitizerToolName, path_, GetLastError());
+    return false;
+  }
+
+  // Process creation succeeded, so transfer handle ownership into the fields.
+  input_fd_ = stdout_read.release();
+  output_fd_ = stdin_write.release();
+
+  // The llvm-symbolizer process is responsible for quitting itself when the
+  // stdin pipe is closed, so we don't need these handles. Close them to prevent
+  // leaks. If we ever want to try to kill the symbolizer process from the
+  // parent, we'll want to hang on to these handles.
+  CloseHandle(pi.hProcess);
+  CloseHandle(pi.hThread);
+  return true;
+}
+
+static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
+                                  LowLevelAllocator *allocator) {
+  if (!common_flags()->symbolize) {
+    VReport(2, "Symbolizer is disabled.\n");
+    return;
+  }
+
+  // Add llvm-symbolizer in case the binary has dwarf.
+  const char *user_path = common_flags()->external_symbolizer_path;
+  const char *path =
+      user_path ? user_path : FindPathToBinary("llvm-symbolizer.exe");
+  if (path) {
+    VReport(2, "Using llvm-symbolizer at %spath: %s\n",
+            user_path ? "user-specified " : "", path);
+    list->push_back(new(*allocator) LLVMSymbolizer(path, allocator));
+  } else {
+    if (user_path && user_path[0] == '\0') {
+      VReport(2, "External symbolizer is explicitly disabled.\n");
+    } else {
+      VReport(2, "External symbolizer is not present.\n");
+    }
+  }
+
+  // Add the dbghelp based symbolizer.
+  list->push_back(new(*allocator) WinSymbolizerTool());
+}
+
+Symbolizer *Symbolizer::PlatformInit() {
+  IntrusiveList<SymbolizerTool> list;
+  list.clear();
+  ChooseSymbolizerTools(&list, &symbolizer_allocator_);
+
+  return new(symbolizer_allocator_) Symbolizer(list);
+}
+
+}  // namespace __sanitizer
+
+#endif  // _WIN32
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc b/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc
new file mode 100644
index 0000000..15cf05f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_syscall_generic.inc
@@ -0,0 +1,34 @@
+//===-- sanitizer_syscall_generic.inc ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic implementations of internal_syscall and internal_iserror.
+//
+//===----------------------------------------------------------------------===//
+
+#if SANITIZER_FREEBSD || SANITIZER_MAC
+# define SYSCALL(name) SYS_ ## name
+#else
+# define SYSCALL(name) __NR_ ## name
+#endif
+
+#if (SANITIZER_FREEBSD || SANITIZER_MAC) && defined(__x86_64__)
+# define internal_syscall __syscall
+# else
+# define internal_syscall syscall
+#endif
+
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval == (uptr)-1) {
+    if (rverrno)
+      *rverrno = errno;
+    return true;
+  } else {
+    return false;
+  }
+}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc b/compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc
new file mode 100644
index 0000000..7ab1d76
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc
@@ -0,0 +1,138 @@
+//===-- sanitizer_syscall_linux_aarch64.inc --------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for Linux/aarch64.
+//
+//===----------------------------------------------------------------------===//
+
+#define SYSCALL(name) __NR_ ## name
+
+static uptr __internal_syscall(u64 nr) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0");
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall0(n) \
+  (__internal_syscall)(n)
+
+static uptr __internal_syscall(u64 nr, u64 arg1) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0") = arg1;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall1(n, a1) \
+  (__internal_syscall)(n, (u64)(a1))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0") = arg1;
+  register u64 x1 asm("x1") = arg2;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall2(n, a1, a2) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0") = arg1;
+  register u64 x1 asm("x1") = arg2;
+  register u64 x2 asm("x2") = arg3;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall3(n, a1, a2, a3) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0") = arg1;
+  register u64 x1 asm("x1") = arg2;
+  register u64 x2 asm("x2") = arg3;
+  register u64 x3 asm("x3") = arg4;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall4(n, a1, a2, a3, a4) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4, long arg5) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0") = arg1;
+  register u64 x1 asm("x1") = arg2;
+  register u64 x2 asm("x2") = arg3;
+  register u64 x3 asm("x3") = arg4;
+  register u64 x4 asm("x4") = arg5;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall5(n, a1, a2, a3, a4, a5) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4, long arg5, long arg6) {
+  register u64 x8 asm("x8") = nr;
+  register u64 x0 asm("x0") = arg1;
+  register u64 x1 asm("x1") = arg2;
+  register u64 x2 asm("x2") = arg3;
+  register u64 x3 asm("x3") = arg4;
+  register u64 x4 asm("x4") = arg5;
+  register u64 x5 asm("x5") = arg6;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6))
+
+#define __SYSCALL_NARGS_X(a1, a2, a3, a4, a5, a6, a7, a8, n, ...) n
+#define __SYSCALL_NARGS(...) \
+  __SYSCALL_NARGS_X(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0, )
+#define __SYSCALL_CONCAT_X(a, b) a##b
+#define __SYSCALL_CONCAT(a, b) __SYSCALL_CONCAT_X(a, b)
+#define __SYSCALL_DISP(b, ...) \
+  __SYSCALL_CONCAT(b, __SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+#define internal_syscall(...) __SYSCALL_DISP(__internal_syscall, __VA_ARGS__)
+
+// Helper function used to avoid cobbler errno.
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_x86_64.inc b/compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_x86_64.inc
new file mode 100644
index 0000000..9853a6a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_x86_64.inc
@@ -0,0 +1,91 @@
+//===-- sanitizer_syscall_linux_x86_64.inc ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for Linux/x86_64.
+//
+//===----------------------------------------------------------------------===//
+
+#define SYSCALL(name) __NR_ ## name
+
+static uptr internal_syscall(u64 nr) {
+  u64 retval;
+  asm volatile("syscall" : "=a"(retval) : "a"(nr) : "rcx", "r11",
+               "memory", "cc");
+  return retval;
+}
+
+template <typename T1>
+static uptr internal_syscall(u64 nr, T1 arg1) {
+  u64 retval;
+  asm volatile("syscall" : "=a"(retval) : "a"(nr), "D"((u64)arg1) :
+               "rcx", "r11", "memory", "cc");
+  return retval;
+}
+
+template <typename T1, typename T2>
+static uptr internal_syscall(u64 nr, T1 arg1, T2 arg2) {
+  u64 retval;
+  asm volatile("syscall" : "=a"(retval) : "a"(nr), "D"((u64)arg1),
+               "S"((u64)arg2) : "rcx", "r11", "memory", "cc");
+  return retval;
+}
+
+template <typename T1, typename T2, typename T3>
+static uptr internal_syscall(u64 nr, T1 arg1, T2 arg2, T3 arg3) {
+  u64 retval;
+  asm volatile("syscall" : "=a"(retval) : "a"(nr), "D"((u64)arg1),
+               "S"((u64)arg2), "d"((u64)arg3) : "rcx", "r11", "memory", "cc");
+  return retval;
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+static uptr internal_syscall(u64 nr, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
+  u64 retval;
+  asm volatile("mov %5, %%r10;"
+               "syscall" : "=a"(retval) : "a"(nr), "D"((u64)arg1),
+               "S"((u64)arg2), "d"((u64)arg3), "r"((u64)arg4) :
+               "rcx", "r11", "r10", "memory", "cc");
+  return retval;
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+static uptr internal_syscall(u64 nr, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
+                             T5 arg5) {
+  u64 retval;
+  asm volatile("mov %5, %%r10;"
+               "mov %6, %%r8;"
+               "syscall" : "=a"(retval) : "a"(nr), "D"((u64)arg1),
+               "S"((u64)arg2), "d"((u64)arg3), "r"((u64)arg4), "r"((u64)arg5) :
+               "rcx", "r11", "r10", "r8", "memory", "cc");
+  return retval;
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6>
+static uptr internal_syscall(u64 nr, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
+                             T5 arg5, T6 arg6) {
+  u64 retval;
+  asm volatile("mov %5, %%r10;"
+               "mov %6, %%r8;"
+               "mov %7, %%r9;"
+               "syscall" : "=a"(retval) : "a"(nr), "D"((u64)arg1),
+               "S"((u64)arg2), "d"((u64)arg3), "r"((u64)arg4), "r"((u64)arg5),
+               "r"((u64)arg6) : "rcx", "r11", "r10", "r8", "r9",
+               "memory", "cc");
+  return retval;
+}
+
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cc b/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cc
new file mode 100644
index 0000000..2ec92ff
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cc
@@ -0,0 +1,301 @@
+//===-- sanitizer_thread_registry.cc --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between sanitizer tools.
+//
+// General thread bookkeeping functionality.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_thread_registry.h"
+
+namespace __sanitizer {
+
+ThreadContextBase::ThreadContextBase(u32 tid)
+    : tid(tid), unique_id(0), reuse_count(), os_id(0), user_id(0),
+      status(ThreadStatusInvalid),
+      detached(false), parent_tid(0), next(0) {
+  name[0] = '\0';
+}
+
+ThreadContextBase::~ThreadContextBase() {
+  // ThreadContextBase should never be deleted.
+  CHECK(0);
+}
+
+void ThreadContextBase::SetName(const char *new_name) {
+  name[0] = '\0';
+  if (new_name) {
+    internal_strncpy(name, new_name, sizeof(name));
+    name[sizeof(name) - 1] = '\0';
+  }
+}
+
+void ThreadContextBase::SetDead() {
+  CHECK(status == ThreadStatusRunning ||
+        status == ThreadStatusFinished);
+  status = ThreadStatusDead;
+  user_id = 0;
+  OnDead();
+}
+
+void ThreadContextBase::SetJoined(void *arg) {
+  // FIXME(dvyukov): print message and continue (it's user error).
+  CHECK_EQ(false, detached);
+  CHECK_EQ(ThreadStatusFinished, status);
+  status = ThreadStatusDead;
+  user_id = 0;
+  OnJoined(arg);
+}
+
+void ThreadContextBase::SetFinished() {
+  if (!detached)
+    status = ThreadStatusFinished;
+  OnFinished();
+}
+
+void ThreadContextBase::SetStarted(uptr _os_id, void *arg) {
+  status = ThreadStatusRunning;
+  os_id = _os_id;
+  OnStarted(arg);
+}
+
+void ThreadContextBase::SetCreated(uptr _user_id, u64 _unique_id,
+                                   bool _detached, u32 _parent_tid, void *arg) {
+  status = ThreadStatusCreated;
+  user_id = _user_id;
+  unique_id = _unique_id;
+  detached = _detached;
+  // Parent tid makes no sense for the main thread.
+  if (tid != 0)
+    parent_tid = _parent_tid;
+  OnCreated(arg);
+}
+
+void ThreadContextBase::Reset() {
+  status = ThreadStatusInvalid;
+  SetName(0);
+  OnReset();
+}
+
+// ThreadRegistry implementation.
+
+const u32 ThreadRegistry::kUnknownTid = ~0U;
+
+ThreadRegistry::ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
+                               u32 thread_quarantine_size, u32 max_reuse)
+    : context_factory_(factory),
+      max_threads_(max_threads),
+      thread_quarantine_size_(thread_quarantine_size),
+      max_reuse_(max_reuse),
+      mtx_(),
+      n_contexts_(0),
+      total_threads_(0),
+      alive_threads_(0),
+      max_alive_threads_(0),
+      running_threads_(0) {
+  threads_ = (ThreadContextBase **)MmapOrDie(max_threads_ * sizeof(threads_[0]),
+                                             "ThreadRegistry");
+  dead_threads_.clear();
+  invalid_threads_.clear();
+}
+
+void ThreadRegistry::GetNumberOfThreads(uptr *total, uptr *running,
+                                        uptr *alive) {
+  BlockingMutexLock l(&mtx_);
+  if (total) *total = n_contexts_;
+  if (running) *running = running_threads_;
+  if (alive) *alive = alive_threads_;
+}
+
+uptr ThreadRegistry::GetMaxAliveThreads() {
+  BlockingMutexLock l(&mtx_);
+  return max_alive_threads_;
+}
+
+u32 ThreadRegistry::CreateThread(uptr user_id, bool detached, u32 parent_tid,
+                                 void *arg) {
+  BlockingMutexLock l(&mtx_);
+  u32 tid = kUnknownTid;
+  ThreadContextBase *tctx = QuarantinePop();
+  if (tctx) {
+    tid = tctx->tid;
+  } else if (n_contexts_ < max_threads_) {
+    // Allocate new thread context and tid.
+    tid = n_contexts_++;
+    tctx = context_factory_(tid);
+    threads_[tid] = tctx;
+  } else {
+#ifndef SANITIZER_GO
+    Report("%s: Thread limit (%u threads) exceeded. Dying.\n",
+           SanitizerToolName, max_threads_);
+#else
+    Printf("race: limit on %u simultaneously alive goroutines is exceeded,"
+        " dying\n", max_threads_);
+#endif
+    Die();
+  }
+  CHECK_NE(tctx, 0);
+  CHECK_NE(tid, kUnknownTid);
+  CHECK_LT(tid, max_threads_);
+  CHECK_EQ(tctx->status, ThreadStatusInvalid);
+  alive_threads_++;
+  if (max_alive_threads_ < alive_threads_) {
+    max_alive_threads_++;
+    CHECK_EQ(alive_threads_, max_alive_threads_);
+  }
+  tctx->SetCreated(user_id, total_threads_++, detached,
+                   parent_tid, arg);
+  return tid;
+}
+
+void ThreadRegistry::RunCallbackForEachThreadLocked(ThreadCallback cb,
+                                                    void *arg) {
+  CheckLocked();
+  for (u32 tid = 0; tid < n_contexts_; tid++) {
+    ThreadContextBase *tctx = threads_[tid];
+    if (tctx == 0)
+      continue;
+    cb(tctx, arg);
+  }
+}
+
+u32 ThreadRegistry::FindThread(FindThreadCallback cb, void *arg) {
+  BlockingMutexLock l(&mtx_);
+  for (u32 tid = 0; tid < n_contexts_; tid++) {
+    ThreadContextBase *tctx = threads_[tid];
+    if (tctx != 0 && cb(tctx, arg))
+      return tctx->tid;
+  }
+  return kUnknownTid;
+}
+
+ThreadContextBase *
+ThreadRegistry::FindThreadContextLocked(FindThreadCallback cb, void *arg) {
+  CheckLocked();
+  for (u32 tid = 0; tid < n_contexts_; tid++) {
+    ThreadContextBase *tctx = threads_[tid];
+    if (tctx != 0 && cb(tctx, arg))
+      return tctx;
+  }
+  return 0;
+}
+
+static bool FindThreadContextByOsIdCallback(ThreadContextBase *tctx,
+                                            void *arg) {
+  return (tctx->os_id == (uptr)arg && tctx->status != ThreadStatusInvalid &&
+      tctx->status != ThreadStatusDead);
+}
+
+ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(uptr os_id) {
+  return FindThreadContextLocked(FindThreadContextByOsIdCallback,
+                                 (void *)os_id);
+}
+
+void ThreadRegistry::SetThreadName(u32 tid, const char *name) {
+  BlockingMutexLock l(&mtx_);
+  CHECK_LT(tid, n_contexts_);
+  ThreadContextBase *tctx = threads_[tid];
+  CHECK_NE(tctx, 0);
+  CHECK_EQ(ThreadStatusRunning, tctx->status);
+  tctx->SetName(name);
+}
+
+void ThreadRegistry::SetThreadNameByUserId(uptr user_id, const char *name) {
+  BlockingMutexLock l(&mtx_);
+  for (u32 tid = 0; tid < n_contexts_; tid++) {
+    ThreadContextBase *tctx = threads_[tid];
+    if (tctx != 0 && tctx->user_id == user_id &&
+        tctx->status != ThreadStatusInvalid) {
+      tctx->SetName(name);
+      return;
+    }
+  }
+}
+
+void ThreadRegistry::DetachThread(u32 tid, void *arg) {
+  BlockingMutexLock l(&mtx_);
+  CHECK_LT(tid, n_contexts_);
+  ThreadContextBase *tctx = threads_[tid];
+  CHECK_NE(tctx, 0);
+  if (tctx->status == ThreadStatusInvalid) {
+    Report("%s: Detach of non-existent thread\n", SanitizerToolName);
+    return;
+  }
+  tctx->OnDetached(arg);
+  if (tctx->status == ThreadStatusFinished) {
+    tctx->SetDead();
+    QuarantinePush(tctx);
+  } else {
+    tctx->detached = true;
+  }
+}
+
+void ThreadRegistry::JoinThread(u32 tid, void *arg) {
+  BlockingMutexLock l(&mtx_);
+  CHECK_LT(tid, n_contexts_);
+  ThreadContextBase *tctx = threads_[tid];
+  CHECK_NE(tctx, 0);
+  if (tctx->status == ThreadStatusInvalid) {
+    Report("%s: Join of non-existent thread\n", SanitizerToolName);
+    return;
+  }
+  tctx->SetJoined(arg);
+  QuarantinePush(tctx);
+}
+
+void ThreadRegistry::FinishThread(u32 tid) {
+  BlockingMutexLock l(&mtx_);
+  CHECK_GT(alive_threads_, 0);
+  alive_threads_--;
+  CHECK_GT(running_threads_, 0);
+  running_threads_--;
+  CHECK_LT(tid, n_contexts_);
+  ThreadContextBase *tctx = threads_[tid];
+  CHECK_NE(tctx, 0);
+  CHECK_EQ(ThreadStatusRunning, tctx->status);
+  tctx->SetFinished();
+  if (tctx->detached) {
+    tctx->SetDead();
+    QuarantinePush(tctx);
+  }
+}
+
+void ThreadRegistry::StartThread(u32 tid, uptr os_id, void *arg) {
+  BlockingMutexLock l(&mtx_);
+  running_threads_++;
+  CHECK_LT(tid, n_contexts_);
+  ThreadContextBase *tctx = threads_[tid];
+  CHECK_NE(tctx, 0);
+  CHECK_EQ(ThreadStatusCreated, tctx->status);
+  tctx->SetStarted(os_id, arg);
+}
+
+void ThreadRegistry::QuarantinePush(ThreadContextBase *tctx) {
+  dead_threads_.push_back(tctx);
+  if (dead_threads_.size() <= thread_quarantine_size_)
+    return;
+  tctx = dead_threads_.front();
+  dead_threads_.pop_front();
+  CHECK_EQ(tctx->status, ThreadStatusDead);
+  tctx->Reset();
+  tctx->reuse_count++;
+  if (max_reuse_ > 0 && tctx->reuse_count >= max_reuse_)
+    return;
+  invalid_threads_.push_back(tctx);
+}
+
+ThreadContextBase *ThreadRegistry::QuarantinePop() {
+  if (invalid_threads_.size() == 0)
+    return 0;
+  ThreadContextBase *tctx = invalid_threads_.front();
+  invalid_threads_.pop_front();
+  return tctx;
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.h b/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.h
new file mode 100644
index 0000000..a27bbb3
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.h
@@ -0,0 +1,148 @@
+//===-- sanitizer_thread_registry.h -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between sanitizer tools.
+//
+// General thread bookkeeping functionality.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_THREAD_REGISTRY_H
+#define SANITIZER_THREAD_REGISTRY_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_list.h"
+#include "sanitizer_mutex.h"
+
+namespace __sanitizer {
+
+enum ThreadStatus {
+  ThreadStatusInvalid,   // Non-existent thread, data is invalid.
+  ThreadStatusCreated,   // Created but not yet running.
+  ThreadStatusRunning,   // The thread is currently running.
+  ThreadStatusFinished,  // Joinable thread is finished but not yet joined.
+  ThreadStatusDead       // Joined, but some info is still available.
+};
+
+// Generic thread context. Specific sanitizer tools may inherit from it.
+// If thread is dead, context may optionally be reused for a new thread.
+class ThreadContextBase {
+ public:
+  explicit ThreadContextBase(u32 tid);
+  ~ThreadContextBase();  // Should never be called.
+
+  const u32 tid;  // Thread ID. Main thread should have tid = 0.
+  u64 unique_id;  // Unique thread ID.
+  u32 reuse_count;  // Number of times this tid was reused.
+  uptr os_id;     // PID (used for reporting).
+  uptr user_id;   // Some opaque user thread id (e.g. pthread_t).
+  char name[64];  // As annotated by user.
+
+  ThreadStatus status;
+  bool detached;
+
+  u32 parent_tid;
+  ThreadContextBase *next;  // For storing thread contexts in a list.
+
+  void SetName(const char *new_name);
+
+  void SetDead();
+  void SetJoined(void *arg);
+  void SetFinished();
+  void SetStarted(uptr _os_id, void *arg);
+  void SetCreated(uptr _user_id, u64 _unique_id, bool _detached,
+                  u32 _parent_tid, void *arg);
+  void Reset();
+
+  // The following methods may be overriden by subclasses.
+  // Some of them take opaque arg that may be optionally be used
+  // by subclasses.
+  virtual void OnDead() {}
+  virtual void OnJoined(void *arg) {}
+  virtual void OnFinished() {}
+  virtual void OnStarted(void *arg) {}
+  virtual void OnCreated(void *arg) {}
+  virtual void OnReset() {}
+  virtual void OnDetached(void *arg) {}
+};
+
+typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
+
+class ThreadRegistry {
+ public:
+  static const u32 kUnknownTid;
+
+  ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
+                 u32 thread_quarantine_size, u32 max_reuse = 0);
+  void GetNumberOfThreads(uptr *total = nullptr, uptr *running = nullptr,
+                          uptr *alive = nullptr);
+  uptr GetMaxAliveThreads();
+
+  void Lock() { mtx_.Lock(); }
+  void CheckLocked() { mtx_.CheckLocked(); }
+  void Unlock() { mtx_.Unlock(); }
+
+  // Should be guarded by ThreadRegistryLock.
+  ThreadContextBase *GetThreadLocked(u32 tid) {
+    DCHECK_LT(tid, n_contexts_);
+    return threads_[tid];
+  }
+
+  u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg);
+
+  typedef void (*ThreadCallback)(ThreadContextBase *tctx, void *arg);
+  // Invokes callback with a specified arg for each thread context.
+  // Should be guarded by ThreadRegistryLock.
+  void RunCallbackForEachThreadLocked(ThreadCallback cb, void *arg);
+
+  typedef bool (*FindThreadCallback)(ThreadContextBase *tctx, void *arg);
+  // Finds a thread using the provided callback. Returns kUnknownTid if no
+  // thread is found.
+  u32 FindThread(FindThreadCallback cb, void *arg);
+  // Should be guarded by ThreadRegistryLock. Return 0 if no thread
+  // is found.
+  ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb,
+                                             void *arg);
+  ThreadContextBase *FindThreadContextByOsIDLocked(uptr os_id);
+
+  void SetThreadName(u32 tid, const char *name);
+  void SetThreadNameByUserId(uptr user_id, const char *name);
+  void DetachThread(u32 tid, void *arg);
+  void JoinThread(u32 tid, void *arg);
+  void FinishThread(u32 tid);
+  void StartThread(u32 tid, uptr os_id, void *arg);
+
+ private:
+  const ThreadContextFactory context_factory_;
+  const u32 max_threads_;
+  const u32 thread_quarantine_size_;
+  const u32 max_reuse_;
+
+  BlockingMutex mtx_;
+
+  u32 n_contexts_;      // Number of created thread contexts,
+                        // at most max_threads_.
+  u64 total_threads_;   // Total number of created threads. May be greater than
+                        // max_threads_ if contexts were reused.
+  uptr alive_threads_;  // Created or running.
+  uptr max_alive_threads_;
+  uptr running_threads_;
+
+  ThreadContextBase **threads_;  // Array of thread contexts is leaked.
+  IntrusiveList<ThreadContextBase> dead_threads_;
+  IntrusiveList<ThreadContextBase> invalid_threads_;
+
+  void QuarantinePush(ThreadContextBase *tctx);
+  ThreadContextBase *QuarantinePop();
+};
+
+typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock;
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_THREAD_REGISTRY_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cc b/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cc
new file mode 100644
index 0000000..213aced
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cc
@@ -0,0 +1,146 @@
+//===-- sanitizer_tls_get_addr.cc -----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Handle the __tls_get_addr call.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_tls_get_addr.h"
+
+#include "sanitizer_flags.h"
+#include "sanitizer_platform_interceptors.h"
+
+namespace __sanitizer {
+#if SANITIZER_INTERCEPT_TLS_GET_ADDR
+
+// The actual parameter that comes to __tls_get_addr
+// is a pointer to a struct with two words in it:
+struct TlsGetAddrParam {
+  uptr dso_id;
+  uptr offset;
+};
+
+// Glibc starting from 2.19 allocates tls using __signal_safe_memalign,
+// which has such header.
+struct Glibc_2_19_tls_header {
+  uptr size;
+  uptr start;
+};
+
+// This must be static TLS
+__attribute__((tls_model("initial-exec")))
+static __thread DTLS dtls;
+
+// Make sure we properly destroy the DTLS objects:
+// this counter should never get too large.
+static atomic_uintptr_t number_of_live_dtls;
+
+static const uptr kDestroyedThread = -1;
+
+static inline void DTLS_Deallocate(DTLS::DTV *dtv, uptr size) {
+  if (!size) return;
+  VPrintf(2, "__tls_get_addr: DTLS_Deallocate %p %zd\n", dtv, size);
+  UnmapOrDie(dtv, size * sizeof(DTLS::DTV));
+  atomic_fetch_sub(&number_of_live_dtls, 1, memory_order_relaxed);
+}
+
+static inline void DTLS_Resize(uptr new_size) {
+  if (dtls.dtv_size >= new_size) return;
+  new_size = RoundUpToPowerOfTwo(new_size);
+  new_size = Max(new_size, 4096UL / sizeof(DTLS::DTV));
+  DTLS::DTV *new_dtv =
+      (DTLS::DTV *)MmapOrDie(new_size * sizeof(DTLS::DTV), "DTLS_Resize");
+  uptr num_live_dtls =
+      atomic_fetch_add(&number_of_live_dtls, 1, memory_order_relaxed);
+  VPrintf(2, "__tls_get_addr: DTLS_Resize %p %zd\n", &dtls, num_live_dtls);
+  CHECK_LT(num_live_dtls, 1 << 20);
+  uptr old_dtv_size = dtls.dtv_size;
+  DTLS::DTV *old_dtv = dtls.dtv;
+  if (old_dtv_size)
+    internal_memcpy(new_dtv, dtls.dtv, dtls.dtv_size * sizeof(DTLS::DTV));
+  dtls.dtv = new_dtv;
+  dtls.dtv_size = new_size;
+  if (old_dtv_size)
+    DTLS_Deallocate(old_dtv, old_dtv_size);
+}
+
+void DTLS_Destroy() {
+  if (!common_flags()->intercept_tls_get_addr) return;
+  VPrintf(2, "__tls_get_addr: DTLS_Destroy %p %zd\n", &dtls, dtls.dtv_size);
+  uptr s = dtls.dtv_size;
+  dtls.dtv_size = kDestroyedThread;  // Do this before unmap for AS-safety.
+  DTLS_Deallocate(dtls.dtv, s);
+}
+
+#if defined(__powerpc64__)
+// This is glibc's TLS_DTV_OFFSET:
+// "Dynamic thread vector pointers point 0x8000 past the start of each
+//  TLS block."
+static const uptr kDtvOffset = 0x8000;
+#else
+static const uptr kDtvOffset = 0;
+#endif
+
+DTLS::DTV *DTLS_on_tls_get_addr(void *arg_void, void *res,
+                                uptr static_tls_begin, uptr static_tls_end) {
+  if (!common_flags()->intercept_tls_get_addr) return 0;
+  TlsGetAddrParam *arg = reinterpret_cast<TlsGetAddrParam *>(arg_void);
+  uptr dso_id = arg->dso_id;
+  if (dtls.dtv_size == kDestroyedThread) return 0;
+  DTLS_Resize(dso_id + 1);
+  if (dtls.dtv[dso_id].beg) return 0;
+  uptr tls_size = 0;
+  uptr tls_beg = reinterpret_cast<uptr>(res) - arg->offset - kDtvOffset;
+  VPrintf(2, "__tls_get_addr: %p {%p,%p} => %p; tls_beg: %p; sp: %p "
+             "num_live_dtls %zd\n",
+          arg, arg->dso_id, arg->offset, res, tls_beg, &tls_beg,
+          atomic_load(&number_of_live_dtls, memory_order_relaxed));
+  if (dtls.last_memalign_ptr == tls_beg) {
+    tls_size = dtls.last_memalign_size;
+    VPrintf(2, "__tls_get_addr: glibc <=2.18 suspected; tls={%p,%p}\n",
+        tls_beg, tls_size);
+  } else if (tls_beg >= static_tls_begin && tls_beg < static_tls_end) {
+    // This is the static TLS block which was initialized / unpoisoned at thread
+    // creation.
+    VPrintf(2, "__tls_get_addr: static tls: %p\n", tls_beg);
+    tls_size = 0;
+  } else if ((tls_beg % 4096) == sizeof(Glibc_2_19_tls_header)) {
+    // We may want to check gnu_get_libc_version().
+    Glibc_2_19_tls_header *header = (Glibc_2_19_tls_header *)tls_beg - 1;
+    tls_size = header->size;
+    tls_beg = header->start;
+    VPrintf(2, "__tls_get_addr: glibc >=2.19 suspected; tls={%p %p}\n",
+        tls_beg, tls_size);
+  } else {
+    VPrintf(2, "__tls_get_addr: Can't guess glibc version\n");
+    // This may happen inside the DTOR of main thread, so just ignore it.
+    tls_size = 0;
+  }
+  dtls.dtv[dso_id].beg = tls_beg;
+  dtls.dtv[dso_id].size = tls_size;
+  return dtls.dtv + dso_id;
+}
+
+void DTLS_on_libc_memalign(void *ptr, uptr size) {
+  if (!common_flags()->intercept_tls_get_addr) return;
+  VPrintf(2, "DTLS_on_libc_memalign: %p %p\n", ptr, size);
+  dtls.last_memalign_ptr = reinterpret_cast<uptr>(ptr);
+  dtls.last_memalign_size = size;
+}
+
+DTLS *DTLS_Get() { return &dtls; }
+
+#else
+void DTLS_on_libc_memalign(void *ptr, uptr size) {}
+DTLS::DTV *DTLS_on_tls_get_addr(void *arg, void *res) { return 0; }
+DTLS *DTLS_Get() { return 0; }
+void DTLS_Destroy() {}
+#endif  // SANITIZER_INTERCEPT_TLS_GET_ADDR
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.h b/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.h
new file mode 100644
index 0000000..58d4763
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.h
@@ -0,0 +1,61 @@
+//===-- sanitizer_tls_get_addr.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Handle the __tls_get_addr call.
+//
+// All this magic is specific to glibc and is required to workaround
+// the lack of interface that would tell us about the Dynamic TLS (DTLS).
+// https://sourceware.org/bugzilla/show_bug.cgi?id=16291
+//
+// The matters get worse because the glibc implementation changed between
+// 2.18 and 2.19:
+// https://groups.google.com/forum/#!topic/address-sanitizer/BfwYD8HMxTM
+//
+// Before 2.19, every DTLS chunk is allocated with __libc_memalign,
+// which we intercept and thus know where is the DTLS.
+// Since 2.19, DTLS chunks are allocated with __signal_safe_memalign,
+// which is an internal function that wraps a mmap call, neither of which
+// we can intercept. Luckily, __signal_safe_memalign has a simple parseable
+// header which we can use.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_TLS_GET_ADDR_H
+#define SANITIZER_TLS_GET_ADDR_H
+
+#include "sanitizer_common.h"
+
+namespace __sanitizer {
+
+struct DTLS {
+  // Array of DTLS chunks for the current Thread.
+  // If beg == 0, the chunk is unused.
+  struct DTV {
+    uptr beg, size;
+  };
+
+  uptr dtv_size;
+  DTV *dtv;  // dtv_size elements, allocated by MmapOrDie.
+
+  // Auxiliary fields, don't access them outside sanitizer_tls_get_addr.cc
+  uptr last_memalign_size;
+  uptr last_memalign_ptr;
+};
+
+// Returns pointer and size of a linker-allocated TLS block.
+// Each block is returned exactly once.
+DTLS::DTV *DTLS_on_tls_get_addr(void *arg, void *res, uptr static_tls_begin,
+                                uptr static_tls_end);
+void DTLS_on_libc_memalign(void *ptr, uptr size);
+DTLS *DTLS_Get();
+void DTLS_Destroy();  // Make sure to call this before the thread is destroyed.
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_TLS_GET_ADDR_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc b/compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc
new file mode 100644
index 0000000..1082ccf
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc
@@ -0,0 +1,158 @@
+//===-- sanitizer_unwind_linux_libcdep.cc ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the unwind.h-based (aka "slow") stack unwinding routines
+// available to the tools on Linux, Android, and FreeBSD.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_FREEBSD || SANITIZER_LINUX
+#include "sanitizer_common.h"
+#include "sanitizer_stacktrace.h"
+
+#if SANITIZER_ANDROID
+#include <dlfcn.h>  // for dlopen()
+#endif
+
+#if SANITIZER_FREEBSD
+#define _GNU_SOURCE  // to declare _Unwind_Backtrace() from <unwind.h>
+#endif
+#include <unwind.h>
+
+namespace __sanitizer {
+
+//------------------------- SlowUnwindStack -----------------------------------
+
+typedef struct {
+  uptr absolute_pc;
+  uptr stack_top;
+  uptr stack_size;
+} backtrace_frame_t;
+
+extern "C" {
+typedef void *(*acquire_my_map_info_list_func)();
+typedef void (*release_my_map_info_list_func)(void *map);
+typedef sptr (*unwind_backtrace_signal_arch_func)(
+    void *siginfo, void *sigcontext, void *map_info_list,
+    backtrace_frame_t *backtrace, uptr ignore_depth, uptr max_depth);
+acquire_my_map_info_list_func acquire_my_map_info_list;
+release_my_map_info_list_func release_my_map_info_list;
+unwind_backtrace_signal_arch_func unwind_backtrace_signal_arch;
+} // extern "C"
+
+#if SANITIZER_ANDROID
+void SanitizerInitializeUnwinder() {
+  void *p = dlopen("libcorkscrew.so", RTLD_LAZY);
+  if (!p) {
+    VReport(1,
+            "Failed to open libcorkscrew.so. You may see broken stack traces "
+            "in SEGV reports.");
+    return;
+  }
+  acquire_my_map_info_list =
+      (acquire_my_map_info_list_func)(uptr)dlsym(p, "acquire_my_map_info_list");
+  release_my_map_info_list =
+      (release_my_map_info_list_func)(uptr)dlsym(p, "release_my_map_info_list");
+  unwind_backtrace_signal_arch = (unwind_backtrace_signal_arch_func)(uptr)dlsym(
+      p, "unwind_backtrace_signal_arch");
+  if (!acquire_my_map_info_list || !release_my_map_info_list ||
+      !unwind_backtrace_signal_arch) {
+    VReport(1,
+            "Failed to find one of the required symbols in libcorkscrew.so. "
+            "You may see broken stack traces in SEGV reports.");
+    acquire_my_map_info_list = 0;
+    unwind_backtrace_signal_arch = 0;
+    release_my_map_info_list = 0;
+  }
+}
+#endif
+
+#ifdef __arm__
+#define UNWIND_STOP _URC_END_OF_STACK
+#define UNWIND_CONTINUE _URC_NO_REASON
+#else
+#define UNWIND_STOP _URC_NORMAL_STOP
+#define UNWIND_CONTINUE _URC_NO_REASON
+#endif
+
+uptr Unwind_GetIP(struct _Unwind_Context *ctx) {
+#if defined(__arm__) && !SANITIZER_MAC
+  uptr val;
+  _Unwind_VRS_Result res = _Unwind_VRS_Get(ctx, _UVRSC_CORE,
+      15 /* r15 = PC */, _UVRSD_UINT32, &val);
+  CHECK(res == _UVRSR_OK && "_Unwind_VRS_Get failed");
+  // Clear the Thumb bit.
+  return val & ~(uptr)1;
+#else
+  return _Unwind_GetIP(ctx);
+#endif
+}
+
+struct UnwindTraceArg {
+  BufferedStackTrace *stack;
+  u32 max_depth;
+};
+
+_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
+  UnwindTraceArg *arg = (UnwindTraceArg*)param;
+  CHECK_LT(arg->stack->size, arg->max_depth);
+  uptr pc = Unwind_GetIP(ctx);
+  arg->stack->trace_buffer[arg->stack->size++] = pc;
+  if (arg->stack->size == arg->max_depth) return UNWIND_STOP;
+  return UNWIND_CONTINUE;
+}
+
+void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
+  CHECK_GE(max_depth, 2);
+  size = 0;
+  UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
+  _Unwind_Backtrace(Unwind_Trace, &arg);
+  // We need to pop a few frames so that pc is on top.
+  uptr to_pop = LocatePcInTrace(pc);
+  // trace_buffer[0] belongs to the current function so we always pop it,
+  // unless there is only 1 frame in the stack trace (1 frame is always better
+  // than 0!).
+  // 1-frame stacks don't normally happen, but this depends on the actual
+  // unwinder implementation (libgcc, libunwind, etc) which is outside of our
+  // control.
+  if (to_pop == 0 && size > 1)
+    to_pop = 1;
+  PopStackFrames(to_pop);
+  trace_buffer[0] = pc;
+}
+
+void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
+                                                    u32 max_depth) {
+  CHECK_GE(max_depth, 2);
+  if (!unwind_backtrace_signal_arch) {
+    SlowUnwindStack(pc, max_depth);
+    return;
+  }
+
+  void *map = acquire_my_map_info_list();
+  CHECK(map);
+  InternalScopedBuffer<backtrace_frame_t> frames(kStackTraceMax);
+  // siginfo argument appears to be unused.
+  sptr res = unwind_backtrace_signal_arch(/* siginfo */ 0, context, map,
+                                          frames.data(),
+                                          /* ignore_depth */ 0, max_depth);
+  release_my_map_info_list(map);
+  if (res < 0) return;
+  CHECK_LE((uptr)res, kStackTraceMax);
+
+  size = 0;
+  // +2 compensate for libcorkscrew unwinder returning addresses of call
+  // instructions instead of raw return addresses.
+  for (sptr i = 0; i < res; ++i)
+    trace_buffer[size++] = frames[i].absolute_pc + 2;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FREEBSD || SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_win.cc b/compiler-rt/lib/sanitizer_common/sanitizer_win.cc
new file mode 100644
index 0000000..861261d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_win.cc
@@ -0,0 +1,775 @@
+//===-- sanitizer_win.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries and implements windows-specific functions from
+// sanitizer_libc.h.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_WINDOWS
+
+#define WIN32_LEAN_AND_MEAN
+#define NOGDI
+#include <windows.h>
+#include <dbghelp.h>
+#include <io.h>
+#include <psapi.h>
+#include <stdlib.h>
+
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+#include "sanitizer_syscall_generic.inc"
+
+// --------------------- sanitizer_common.h
+uptr GetPageSize() {
+  // FIXME: there is an API for getting the system page size (GetSystemInfo or
+  // GetNativeSystemInfo), but if we use it here we get test failures elsewhere.
+  return 1U << 14;
+}
+
+uptr GetMmapGranularity() {
+  return 1U << 16;  // FIXME: is this configurable?
+}
+
+uptr GetMaxVirtualAddress() {
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return (uptr)si.lpMaximumApplicationAddress;
+}
+
+bool FileExists(const char *filename) {
+  return ::GetFileAttributesA(filename) != INVALID_FILE_ATTRIBUTES;
+}
+
+uptr internal_getpid() {
+  return GetProcessId(GetCurrentProcess());
+}
+
+// In contrast to POSIX, on Windows GetCurrentThreadId()
+// returns a system-unique identifier.
+uptr GetTid() {
+  return GetCurrentThreadId();
+}
+
+uptr GetThreadSelf() {
+  return GetTid();
+}
+
+#if !SANITIZER_GO
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+                                uptr *stack_bottom) {
+  CHECK(stack_top);
+  CHECK(stack_bottom);
+  MEMORY_BASIC_INFORMATION mbi;
+  CHECK_NE(VirtualQuery(&mbi /* on stack */, &mbi, sizeof(mbi)), 0);
+  // FIXME: is it possible for the stack to not be a single allocation?
+  // Are these values what ASan expects to get (reserved, not committed;
+  // including stack guard page) ?
+  *stack_top = (uptr)mbi.BaseAddress + mbi.RegionSize;
+  *stack_bottom = (uptr)mbi.AllocationBase;
+}
+#endif  // #if !SANITIZER_GO
+
+void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
+  void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+  if (rv == 0)
+    ReportMmapFailureAndDie(size, mem_type, "allocate",
+                            GetLastError(), raw_report);
+  return rv;
+}
+
+void UnmapOrDie(void *addr, uptr size) {
+  if (!size || !addr)
+    return;
+
+  if (VirtualFree(addr, size, MEM_DECOMMIT) == 0) {
+    Report("ERROR: %s failed to "
+           "deallocate 0x%zx (%zd) bytes at address %p (error code: %d)\n",
+           SanitizerToolName, size, size, addr, GetLastError());
+    CHECK("unable to unmap" && 0);
+  }
+}
+
+void *MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) {
+  // FIXME: is this really "NoReserve"? On Win32 this does not matter much,
+  // but on Win64 it does.
+  (void)name; // unsupported
+  void *p = VirtualAlloc((LPVOID)fixed_addr, size,
+      MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+  if (p == 0)
+    Report("ERROR: %s failed to "
+           "allocate %p (%zd) bytes at %p (error code: %d)\n",
+           SanitizerToolName, size, size, fixed_addr, GetLastError());
+  return p;
+}
+
+void *MmapFixedOrDie(uptr fixed_addr, uptr size) {
+  return MmapFixedNoReserve(fixed_addr, size);
+}
+
+void *MmapNoReserveOrDie(uptr size, const char *mem_type) {
+  // FIXME: make this really NoReserve?
+  return MmapOrDie(size, mem_type);
+}
+
+void *MmapNoAccess(uptr fixed_addr, uptr size, const char *name) {
+  (void)name; // unsupported
+  void *res = VirtualAlloc((LPVOID)fixed_addr, size,
+                           MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
+  if (res == 0)
+    Report("WARNING: %s failed to "
+           "mprotect %p (%zd) bytes at %p (error code: %d)\n",
+           SanitizerToolName, size, size, fixed_addr, GetLastError());
+  return res;
+}
+
+bool MprotectNoAccess(uptr addr, uptr size) {
+  DWORD old_protection;
+  return VirtualProtect((LPVOID)addr, size, PAGE_NOACCESS, &old_protection);
+}
+
+
+void FlushUnneededShadowMemory(uptr addr, uptr size) {
+  // This is almost useless on 32-bits.
+  // FIXME: add madvise-analog when we move to 64-bits.
+}
+
+void NoHugePagesInRegion(uptr addr, uptr size) {
+  // FIXME: probably similar to FlushUnneededShadowMemory.
+}
+
+void DontDumpShadowMemory(uptr addr, uptr length) {
+  // This is almost useless on 32-bits.
+  // FIXME: add madvise-analog when we move to 64-bits.
+}
+
+bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
+  MEMORY_BASIC_INFORMATION mbi;
+  CHECK(VirtualQuery((void *)range_start, &mbi, sizeof(mbi)));
+  return mbi.Protect == PAGE_NOACCESS &&
+         (uptr)mbi.BaseAddress + mbi.RegionSize >= range_end;
+}
+
+void *MapFileToMemory(const char *file_name, uptr *buff_size) {
+  UNIMPLEMENTED();
+}
+
+void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
+  UNIMPLEMENTED();
+}
+
+static const int kMaxEnvNameLength = 128;
+static const DWORD kMaxEnvValueLength = 32767;
+
+namespace {
+
+struct EnvVariable {
+  char name[kMaxEnvNameLength];
+  char value[kMaxEnvValueLength];
+};
+
+}  // namespace
+
+static const int kEnvVariables = 5;
+static EnvVariable env_vars[kEnvVariables];
+static int num_env_vars;
+
+const char *GetEnv(const char *name) {
+  // Note: this implementation caches the values of the environment variables
+  // and limits their quantity.
+  for (int i = 0; i < num_env_vars; i++) {
+    if (0 == internal_strcmp(name, env_vars[i].name))
+      return env_vars[i].value;
+  }
+  CHECK_LT(num_env_vars, kEnvVariables);
+  DWORD rv = GetEnvironmentVariableA(name, env_vars[num_env_vars].value,
+                                     kMaxEnvValueLength);
+  if (rv > 0 && rv < kMaxEnvValueLength) {
+    CHECK_LT(internal_strlen(name), kMaxEnvNameLength);
+    internal_strncpy(env_vars[num_env_vars].name, name, kMaxEnvNameLength);
+    num_env_vars++;
+    return env_vars[num_env_vars - 1].value;
+  }
+  return 0;
+}
+
+const char *GetPwd() {
+  UNIMPLEMENTED();
+}
+
+u32 GetUid() {
+  UNIMPLEMENTED();
+}
+
+namespace {
+struct ModuleInfo {
+  const char *filepath;
+  uptr base_address;
+  uptr end_address;
+};
+
+#ifndef SANITIZER_GO
+int CompareModulesBase(const void *pl, const void *pr) {
+  const ModuleInfo *l = (ModuleInfo *)pl, *r = (ModuleInfo *)pr;
+  if (l->base_address < r->base_address)
+    return -1;
+  return l->base_address > r->base_address;
+}
+#endif
+}  // namespace
+
+#ifndef SANITIZER_GO
+void DumpProcessMap() {
+  Report("Dumping process modules:\n");
+  InternalScopedBuffer<LoadedModule> modules(kMaxNumberOfModules);
+  uptr num_modules =
+      GetListOfModules(modules.data(), kMaxNumberOfModules, nullptr);
+
+  InternalScopedBuffer<ModuleInfo> module_infos(num_modules);
+  for (size_t i = 0; i < num_modules; ++i) {
+    module_infos[i].filepath = modules[i].full_name();
+    module_infos[i].base_address = modules[i].base_address();
+    module_infos[i].end_address = modules[i].ranges().next()->end;
+  }
+  qsort(module_infos.data(), num_modules, sizeof(ModuleInfo),
+        CompareModulesBase);
+
+  for (size_t i = 0; i < num_modules; ++i) {
+    const ModuleInfo &mi = module_infos[i];
+    if (mi.end_address != 0) {
+      Printf("\t%p-%p %s\n", mi.base_address, mi.end_address,
+             mi.filepath[0] ? mi.filepath : "[no name]");
+    } else if (mi.filepath[0]) {
+      Printf("\t??\?-??? %s\n", mi.filepath);
+    } else {
+      Printf("\t???\n");
+    }
+  }
+}
+#endif
+
+void DisableCoreDumperIfNecessary() {
+  // Do nothing.
+}
+
+void ReExec() {
+  UNIMPLEMENTED();
+}
+
+void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
+#if !SANITIZER_GO
+  CovPrepareForSandboxing(args);
+#endif
+}
+
+bool StackSizeIsUnlimited() {
+  UNIMPLEMENTED();
+}
+
+void SetStackSizeLimitInBytes(uptr limit) {
+  UNIMPLEMENTED();
+}
+
+bool AddressSpaceIsUnlimited() {
+  UNIMPLEMENTED();
+}
+
+void SetAddressSpaceUnlimited() {
+  UNIMPLEMENTED();
+}
+
+bool IsPathSeparator(const char c) {
+  return c == '\\' || c == '/';
+}
+
+bool IsAbsolutePath(const char *path) {
+  UNIMPLEMENTED();
+}
+
+void SleepForSeconds(int seconds) {
+  Sleep(seconds * 1000);
+}
+
+void SleepForMillis(int millis) {
+  Sleep(millis);
+}
+
+u64 NanoTime() {
+  return 0;
+}
+
+void Abort() {
+  if (::IsDebuggerPresent())
+    __debugbreak();
+  internal__exit(3);
+}
+
+// Read the file to extract the ImageBase field from the PE header. If ASLR is
+// disabled and this virtual address is available, the loader will typically
+// load the image at this address. Therefore, we call it the preferred base. Any
+// addresses in the DWARF typically assume that the object has been loaded at
+// this address.
+static uptr GetPreferredBase(const char *modname) {
+  fd_t fd = OpenFile(modname, RdOnly, nullptr);
+  if (fd == kInvalidFd)
+    return 0;
+  FileCloser closer(fd);
+
+  // Read just the DOS header.
+  IMAGE_DOS_HEADER dos_header;
+  uptr bytes_read;
+  if (!ReadFromFile(fd, &dos_header, sizeof(dos_header), &bytes_read) ||
+      bytes_read != sizeof(dos_header))
+    return 0;
+
+  // The file should start with the right signature.
+  if (dos_header.e_magic != IMAGE_DOS_SIGNATURE)
+    return 0;
+
+  // The layout at e_lfanew is:
+  // "PE\0\0"
+  // IMAGE_FILE_HEADER
+  // IMAGE_OPTIONAL_HEADER
+  // Seek to e_lfanew and read all that data.
+  char buf[4 + sizeof(IMAGE_FILE_HEADER) + sizeof(IMAGE_OPTIONAL_HEADER)];
+  if (::SetFilePointer(fd, dos_header.e_lfanew, nullptr, FILE_BEGIN) ==
+      INVALID_SET_FILE_POINTER)
+    return 0;
+  if (!ReadFromFile(fd, &buf[0], sizeof(buf), &bytes_read) ||
+      bytes_read != sizeof(buf))
+    return 0;
+
+  // Check for "PE\0\0" before the PE header.
+  char *pe_sig = &buf[0];
+  if (internal_memcmp(pe_sig, "PE\0\0", 4) != 0)
+    return 0;
+
+  // Skip over IMAGE_FILE_HEADER. We could do more validation here if we wanted.
+  IMAGE_OPTIONAL_HEADER *pe_header =
+      (IMAGE_OPTIONAL_HEADER *)(pe_sig + 4 + sizeof(IMAGE_FILE_HEADER));
+
+  // Check for more magic in the PE header.
+  if (pe_header->Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
+    return 0;
+
+  // Finally, return the ImageBase.
+  return (uptr)pe_header->ImageBase;
+}
+
+#ifndef SANITIZER_GO
+uptr GetListOfModules(LoadedModule *modules, uptr max_modules,
+                      string_predicate_t filter) {
+  HANDLE cur_process = GetCurrentProcess();
+
+  // Query the list of modules.  Start by assuming there are no more than 256
+  // modules and retry if that's not sufficient.
+  HMODULE *hmodules = 0;
+  uptr modules_buffer_size = sizeof(HMODULE) * 256;
+  DWORD bytes_required;
+  while (!hmodules) {
+    hmodules = (HMODULE *)MmapOrDie(modules_buffer_size, __FUNCTION__);
+    CHECK(EnumProcessModules(cur_process, hmodules, modules_buffer_size,
+                             &bytes_required));
+    if (bytes_required > modules_buffer_size) {
+      // Either there turned out to be more than 256 hmodules, or new hmodules
+      // could have loaded since the last try.  Retry.
+      UnmapOrDie(hmodules, modules_buffer_size);
+      hmodules = 0;
+      modules_buffer_size = bytes_required;
+    }
+  }
+
+  // |num_modules| is the number of modules actually present,
+  // |count| is the number of modules we return.
+  size_t nun_modules = bytes_required / sizeof(HMODULE),
+         count = 0;
+  for (size_t i = 0; i < nun_modules && count < max_modules; ++i) {
+    HMODULE handle = hmodules[i];
+    MODULEINFO mi;
+    if (!GetModuleInformation(cur_process, handle, &mi, sizeof(mi)))
+      continue;
+
+    // Get the UTF-16 path and convert to UTF-8.
+    wchar_t modname_utf16[kMaxPathLength];
+    int modname_utf16_len =
+        GetModuleFileNameW(handle, modname_utf16, kMaxPathLength);
+    if (modname_utf16_len == 0)
+      modname_utf16[0] = '\0';
+    char module_name[kMaxPathLength];
+    int module_name_len =
+        ::WideCharToMultiByte(CP_UTF8, 0, modname_utf16, modname_utf16_len + 1,
+                              &module_name[0], kMaxPathLength, NULL, NULL);
+    module_name[module_name_len] = '\0';
+
+    if (filter && !filter(module_name))
+      continue;
+
+    uptr base_address = (uptr)mi.lpBaseOfDll;
+    uptr end_address = (uptr)mi.lpBaseOfDll + mi.SizeOfImage;
+
+    // Adjust the base address of the module so that we get a VA instead of an
+    // RVA when computing the module offset. This helps llvm-symbolizer find the
+    // right DWARF CU. In the common case that the image is loaded at it's
+    // preferred address, we will now print normal virtual addresses.
+    uptr preferred_base = GetPreferredBase(&module_name[0]);
+    uptr adjusted_base = base_address - preferred_base;
+
+    LoadedModule *cur_module = &modules[count];
+    cur_module->set(module_name, adjusted_base);
+    // We add the whole module as one single address range.
+    cur_module->addAddressRange(base_address, end_address, /*executable*/ true);
+    count++;
+  }
+  UnmapOrDie(hmodules, modules_buffer_size);
+
+  return count;
+};
+
+// We can't use atexit() directly at __asan_init time as the CRT is not fully
+// initialized at this point.  Place the functions into a vector and use
+// atexit() as soon as it is ready for use (i.e. after .CRT$XIC initializers).
+InternalMmapVectorNoCtor<void (*)(void)> atexit_functions;
+
+int Atexit(void (*function)(void)) {
+  atexit_functions.push_back(function);
+  return 0;
+}
+
+static int RunAtexit() {
+  int ret = 0;
+  for (uptr i = 0; i < atexit_functions.size(); ++i) {
+    ret |= atexit(atexit_functions[i]);
+  }
+  return ret;
+}
+
+#pragma section(".CRT$XID", long, read)  // NOLINT
+__declspec(allocate(".CRT$XID")) int (*__run_atexit)() = RunAtexit;
+#endif
+
+// ------------------ sanitizer_libc.h
+fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *last_error) {
+  fd_t res;
+  if (mode == RdOnly) {
+    res = CreateFile(filename, GENERIC_READ,
+                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                     nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+  } else if (mode == WrOnly) {
+    res = CreateFile(filename, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS,
+                     FILE_ATTRIBUTE_NORMAL, nullptr);
+  } else {
+    UNIMPLEMENTED();
+  }
+  CHECK(res != kStdoutFd || kStdoutFd == kInvalidFd);
+  CHECK(res != kStderrFd || kStderrFd == kInvalidFd);
+  if (res == kInvalidFd && last_error)
+    *last_error = GetLastError();
+  return res;
+}
+
+void CloseFile(fd_t fd) {
+  CloseHandle(fd);
+}
+
+bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,
+                  error_t *error_p) {
+  CHECK(fd != kInvalidFd);
+
+  // bytes_read can't be passed directly to ReadFile:
+  // uptr is unsigned long long on 64-bit Windows.
+  unsigned long num_read_long;
+
+  bool success = ::ReadFile(fd, buff, buff_size, &num_read_long, nullptr);
+  if (!success && error_p)
+    *error_p = GetLastError();
+  if (bytes_read)
+    *bytes_read = num_read_long;
+  return success;
+}
+
+bool SupportsColoredOutput(fd_t fd) {
+  // FIXME: support colored output.
+  return false;
+}
+
+bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written,
+                 error_t *error_p) {
+  CHECK(fd != kInvalidFd);
+
+  // Handle null optional parameters.
+  error_t dummy_error;
+  error_p = error_p ? error_p : &dummy_error;
+  uptr dummy_bytes_written;
+  bytes_written = bytes_written ? bytes_written : &dummy_bytes_written;
+
+  // Initialize output parameters in case we fail.
+  *error_p = 0;
+  *bytes_written = 0;
+
+  // Map the conventional Unix fds 1 and 2 to Windows handles. They might be
+  // closed, in which case this will fail.
+  if (fd == kStdoutFd || fd == kStderrFd) {
+    fd = GetStdHandle(fd == kStdoutFd ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE);
+    if (fd == 0) {
+      *error_p = ERROR_INVALID_HANDLE;
+      return false;
+    }
+  }
+
+  DWORD bytes_written_32;
+  if (!WriteFile(fd, buff, buff_size, &bytes_written_32, 0)) {
+    *error_p = GetLastError();
+    return false;
+  } else {
+    *bytes_written = bytes_written_32;
+    return true;
+  }
+}
+
+bool RenameFile(const char *oldpath, const char *newpath, error_t *error_p) {
+  UNIMPLEMENTED();
+}
+
+uptr internal_sched_yield() {
+  Sleep(0);
+  return 0;
+}
+
+void internal__exit(int exitcode) {
+  ExitProcess(exitcode);
+}
+
+uptr internal_ftruncate(fd_t fd, uptr size) {
+  UNIMPLEMENTED();
+}
+
+uptr GetRSS() {
+  return 0;
+}
+
+void *internal_start_thread(void (*func)(void *arg), void *arg) { return 0; }
+void internal_join_thread(void *th) { }
+
+// ---------------------- BlockingMutex ---------------- {{{1
+const uptr LOCK_UNINITIALIZED = 0;
+const uptr LOCK_READY = (uptr)-1;
+
+BlockingMutex::BlockingMutex(LinkerInitialized li) {
+  // FIXME: see comments in BlockingMutex::Lock() for the details.
+  CHECK(li == LINKER_INITIALIZED || owner_ == LOCK_UNINITIALIZED);
+
+  CHECK(sizeof(CRITICAL_SECTION) <= sizeof(opaque_storage_));
+  InitializeCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
+  owner_ = LOCK_READY;
+}
+
+BlockingMutex::BlockingMutex() {
+  CHECK(sizeof(CRITICAL_SECTION) <= sizeof(opaque_storage_));
+  InitializeCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
+  owner_ = LOCK_READY;
+}
+
+void BlockingMutex::Lock() {
+  if (owner_ == LOCK_UNINITIALIZED) {
+    // FIXME: hm, global BlockingMutex objects are not initialized?!?
+    // This might be a side effect of the clang+cl+link Frankenbuild...
+    new(this) BlockingMutex((LinkerInitialized)(LINKER_INITIALIZED + 1));
+
+    // FIXME: If it turns out the linker doesn't invoke our
+    // constructors, we should probably manually Lock/Unlock all the global
+    // locks while we're starting in one thread to avoid double-init races.
+  }
+  EnterCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
+  CHECK_EQ(owner_, LOCK_READY);
+  owner_ = GetThreadSelf();
+}
+
+void BlockingMutex::Unlock() {
+  CHECK_EQ(owner_, GetThreadSelf());
+  owner_ = LOCK_READY;
+  LeaveCriticalSection((LPCRITICAL_SECTION)opaque_storage_);
+}
+
+void BlockingMutex::CheckLocked() {
+  CHECK_EQ(owner_, GetThreadSelf());
+}
+
+uptr GetTlsSize() {
+  return 0;
+}
+
+void InitTlsSize() {
+}
+
+void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
+                          uptr *tls_addr, uptr *tls_size) {
+#ifdef SANITIZER_GO
+  *stk_addr = 0;
+  *stk_size = 0;
+  *tls_addr = 0;
+  *tls_size = 0;
+#else
+  uptr stack_top, stack_bottom;
+  GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
+  *stk_addr = stack_bottom;
+  *stk_size = stack_top - stack_bottom;
+  *tls_addr = 0;
+  *tls_size = 0;
+#endif
+}
+
+#if !SANITIZER_GO
+void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
+  CHECK_GE(max_depth, 2);
+  // FIXME: CaptureStackBackTrace might be too slow for us.
+  // FIXME: Compare with StackWalk64.
+  // FIXME: Look at LLVMUnhandledExceptionFilter in Signals.inc
+  size = CaptureStackBackTrace(2, Min(max_depth, kStackTraceMax),
+                               (void**)trace, 0);
+  if (size == 0)
+    return;
+
+  // Skip the RTL frames by searching for the PC in the stacktrace.
+  uptr pc_location = LocatePcInTrace(pc);
+  PopStackFrames(pc_location);
+}
+
+void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
+                                                    u32 max_depth) {
+  CONTEXT ctx = *(CONTEXT *)context;
+  STACKFRAME64 stack_frame;
+  memset(&stack_frame, 0, sizeof(stack_frame));
+  size = 0;
+#if defined(_WIN64)
+  int machine_type = IMAGE_FILE_MACHINE_AMD64;
+  stack_frame.AddrPC.Offset = ctx.Rip;
+  stack_frame.AddrFrame.Offset = ctx.Rbp;
+  stack_frame.AddrStack.Offset = ctx.Rsp;
+#else
+  int machine_type = IMAGE_FILE_MACHINE_I386;
+  stack_frame.AddrPC.Offset = ctx.Eip;
+  stack_frame.AddrFrame.Offset = ctx.Ebp;
+  stack_frame.AddrStack.Offset = ctx.Esp;
+#endif
+  stack_frame.AddrPC.Mode = AddrModeFlat;
+  stack_frame.AddrFrame.Mode = AddrModeFlat;
+  stack_frame.AddrStack.Mode = AddrModeFlat;
+  while (StackWalk64(machine_type, GetCurrentProcess(), GetCurrentThread(),
+                     &stack_frame, &ctx, NULL, &SymFunctionTableAccess64,
+                     &SymGetModuleBase64, NULL) &&
+         size < Min(max_depth, kStackTraceMax)) {
+    trace_buffer[size++] = (uptr)stack_frame.AddrPC.Offset;
+  }
+}
+#endif  // #if !SANITIZER_GO
+
+void ReportFile::Write(const char *buffer, uptr length) {
+  SpinMutexLock l(mu);
+  ReopenIfNecessary();
+  if (!WriteToFile(fd, buffer, length)) {
+    // stderr may be closed, but we may be able to print to the debugger
+    // instead.  This is the case when launching a program from Visual Studio,
+    // and the following routine should write to its console.
+    OutputDebugStringA(buffer);
+  }
+}
+
+void SetAlternateSignalStack() {
+  // FIXME: Decide what to do on Windows.
+}
+
+void UnsetAlternateSignalStack() {
+  // FIXME: Decide what to do on Windows.
+}
+
+void InstallDeadlySignalHandlers(SignalHandlerType handler) {
+  (void)handler;
+  // FIXME: Decide what to do on Windows.
+}
+
+bool IsDeadlySignal(int signum) {
+  // FIXME: Decide what to do on Windows.
+  return false;
+}
+
+bool IsAccessibleMemoryRange(uptr beg, uptr size) {
+  SYSTEM_INFO si;
+  GetNativeSystemInfo(&si);
+  uptr page_size = si.dwPageSize;
+  uptr page_mask = ~(page_size - 1);
+
+  for (uptr page = beg & page_mask, end = (beg + size - 1) & page_mask;
+       page <= end;) {
+    MEMORY_BASIC_INFORMATION info;
+    if (VirtualQuery((LPCVOID)page, &info, sizeof(info)) != sizeof(info))
+      return false;
+
+    if (info.Protect == 0 || info.Protect == PAGE_NOACCESS ||
+        info.Protect == PAGE_EXECUTE)
+      return false;
+
+    if (info.RegionSize == 0)
+      return false;
+
+    page += info.RegionSize;
+  }
+
+  return true;
+}
+
+SignalContext SignalContext::Create(void *siginfo, void *context) {
+  EXCEPTION_RECORD *exception_record = (EXCEPTION_RECORD*)siginfo;
+  CONTEXT *context_record = (CONTEXT*)context;
+
+  uptr pc = (uptr)exception_record->ExceptionAddress;
+#ifdef _WIN64
+  uptr bp = (uptr)context_record->Rbp;
+  uptr sp = (uptr)context_record->Rsp;
+#else
+  uptr bp = (uptr)context_record->Ebp;
+  uptr sp = (uptr)context_record->Esp;
+#endif
+  uptr access_addr = exception_record->ExceptionInformation[1];
+
+  return SignalContext(context, access_addr, pc, sp, bp);
+}
+
+uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
+  // FIXME: Actually implement this function.
+  CHECK_GT(buf_len, 0);
+  buf[0] = 0;
+  return 0;
+}
+
+uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
+  return ReadBinaryName(buf, buf_len);
+}
+
+void CheckVMASize() {
+  // Do nothing.
+}
+
+void DisableReexec() {
+  // No need to re-exec on Windows.
+}
+
+void MaybeReexec() {
+  // No need to re-exec on Windows.
+}
+
+}  // namespace __sanitizer
+
+#endif  // _WIN32
diff --git a/compiler-rt/lib/sanitizer_common/scripts/check_lint.sh b/compiler-rt/lib/sanitizer_common/scripts/check_lint.sh
new file mode 100755
index 0000000..9108a81
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/scripts/check_lint.sh
@@ -0,0 +1,136 @@
+#!/bin/sh
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Guess path to LLVM_CHECKOUT if not provided
+if [ "${LLVM_CHECKOUT}" = "" ]; then
+  LLVM_CHECKOUT="${SCRIPT_DIR}/../../../../../"
+fi
+
+# python tools setup
+CPPLINT=${SCRIPT_DIR}/cpplint.py
+LITLINT=${SCRIPT_DIR}/litlint.py
+if [ "${PYTHON_EXECUTABLE}" != "" ]; then
+  CPPLINT="${PYTHON_EXECUTABLE} ${CPPLINT}"
+  LITLINT="${PYTHON_EXECUTABLE} ${LITLINT}"
+fi
+
+# Filters
+# TODO: remove some of these filters
+COMMON_LINT_FILTER=-build/include,-build/header_guard,-legal/copyright,-whitespace/comments,-readability/casting,\
+-build/namespaces
+ASAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int
+ASAN_TEST_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/sizeof,-runtime/int,-runtime/printf,-runtime/threadsafe_fn
+ASAN_LIT_TEST_LINT_FILTER=${ASAN_TEST_LINT_FILTER},-whitespace/line_length
+TSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER}
+TSAN_TEST_LINT_FILTER=${TSAN_RTL_LINT_FILTER},-runtime/threadsafe_fn,-runtime/int
+TSAN_LIT_TEST_LINT_FILTER=${TSAN_TEST_LINT_FILTER},-whitespace/line_length
+MSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER}
+LSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER}
+LSAN_LIT_TEST_LINT_FILTER=${LSAN_RTL_LINT_FILTER},-whitespace/line_length
+DFSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int,-runtime/printf,-runtime/references,-readability/function
+COMMON_RTL_INC_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int,-runtime/sizeof,-runtime/printf,-readability/fn_size
+SANITIZER_INCLUDES_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int
+
+MKTEMP_DIR=$(mktemp -qd /tmp/check_lint.XXXXXXXXXX)
+MKTEMP="mktemp -q ${MKTEMP_DIR}/tmp.XXXXXXXXXX"
+cleanup() {
+  rm -rf $MKTEMP_DIR
+}
+trap cleanup EXIT
+
+cd ${LLVM_CHECKOUT}
+
+EXITSTATUS=0
+ERROR_LOG=$(${MKTEMP})
+
+run_lint() {
+  FILTER=$1
+  shift
+  TASK_LOG=$(${MKTEMP})
+  ${CPPLINT} --filter=${FILTER} "$@" 2>$TASK_LOG
+  if [ "$?" != "0" ]; then
+    cat $TASK_LOG | grep -v "Done processing" | grep -v "Total errors found" \
+      | grep -v "Skipping input" >> $ERROR_LOG
+  fi
+  if [ "${SILENT}" != "1" ]; then
+    cat $TASK_LOG
+  fi
+  ${LITLINT} "$@" 2>>$ERROR_LOG
+}
+
+if [ "${COMPILER_RT}" = "" ]; then
+  COMPILER_RT=projects/compiler-rt
+fi
+LIT_TESTS=${COMPILER_RT}/test
+# Headers
+SANITIZER_INCLUDES=${COMPILER_RT}/include/sanitizer
+run_lint ${SANITIZER_INCLUDES_LINT_FILTER} ${SANITIZER_INCLUDES}/*.h &
+
+# Sanitizer_common
+COMMON_RTL=${COMPILER_RT}/lib/sanitizer_common
+run_lint ${COMMON_RTL_INC_LINT_FILTER} ${COMMON_RTL}/*.cc \
+                                       ${COMMON_RTL}/*.h \
+                                       ${COMMON_RTL}/tests/*.cc &
+
+# Interception
+INTERCEPTION=${COMPILER_RT}/lib/interception
+run_lint ${ASAN_RTL_LINT_FILTER} ${INTERCEPTION}/*.cc \
+                                 ${INTERCEPTION}/*.h &
+
+# ASan
+ASAN_RTL=${COMPILER_RT}/lib/asan
+run_lint ${ASAN_RTL_LINT_FILTER} ${ASAN_RTL}/*.cc \
+                                 ${ASAN_RTL}/*.h &
+run_lint ${ASAN_TEST_LINT_FILTER} ${ASAN_RTL}/tests/*.cc \
+                                  ${ASAN_RTL}/tests/*.h &
+run_lint ${ASAN_LIT_TEST_LINT_FILTER} ${LIT_TESTS}/asan/*/*.cc &
+
+# TSan
+TSAN_RTL=${COMPILER_RT}/lib/tsan
+run_lint ${TSAN_RTL_LINT_FILTER} ${TSAN_RTL}/rtl/*.cc \
+                                 ${TSAN_RTL}/rtl/*.h &
+run_lint ${TSAN_TEST_LINT_FILTER} ${TSAN_RTL}/tests/rtl/*.cc \
+                                  ${TSAN_RTL}/tests/rtl/*.h \
+                                  ${TSAN_RTL}/tests/unit/*.cc &
+run_lint ${TSAN_LIT_TEST_LINT_FILTER} ${LIT_TESTS}/tsan/*.cc &
+
+# MSan
+MSAN_RTL=${COMPILER_RT}/lib/msan
+run_lint ${MSAN_RTL_LINT_FILTER} ${MSAN_RTL}/*.cc \
+                                 ${MSAN_RTL}/*.h &
+
+# LSan
+LSAN_RTL=${COMPILER_RT}/lib/lsan
+run_lint ${LSAN_RTL_LINT_FILTER} ${LSAN_RTL}/*.cc \
+                                 ${LSAN_RTL}/*.h &
+run_lint ${LSAN_LIT_TEST_LINT_FILTER} ${LIT_TESTS}/lsan/*/*.cc &
+
+# DFSan
+DFSAN_RTL=${COMPILER_RT}/lib/dfsan
+run_lint ${DFSAN_RTL_LINT_FILTER} ${DFSAN_RTL}/*.cc \
+                                  ${DFSAN_RTL}/*.h &
+${DFSAN_RTL}/scripts/check_custom_wrappers.sh >> $ERROR_LOG
+
+# Misc files
+FILES=${COMMON_RTL}/*.inc
+TMPFILES=""
+for FILE in $FILES; do
+  TMPFILE="$(${MKTEMP}).$(basename ${FILE}).cc"
+  cp -f $FILE $TMPFILE
+  run_lint ${COMMON_RTL_INC_LINT_FILTER} $TMPFILE &
+  TMPFILES="$TMPFILES $TMPFILE"
+done
+
+wait
+
+for temp in $TMPFILES; do
+  rm -f $temp
+done
+
+if [ -s $ERROR_LOG ]; then
+  cat $ERROR_LOG
+  exit 1
+fi
+
+exit 0
diff --git a/compiler-rt/lib/sanitizer_common/scripts/cpplint.py b/compiler-rt/lib/sanitizer_common/scripts/cpplint.py
new file mode 100755
index 0000000..d45c47f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/scripts/cpplint.py
@@ -0,0 +1,4024 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2009 Google Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#    * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#    * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Here are some issues that I've had people identify in my code during reviews,
+# that I think are possible to flag automatically in a lint tool.  If these were
+# caught by lint, it would save time both for myself and that of my reviewers.
+# Most likely, some of these are beyond the scope of the current lint framework,
+# but I think it is valuable to retain these wish-list items even if they cannot
+# be immediately implemented.
+#
+#  Suggestions
+#  -----------
+#  - Check for no 'explicit' for multi-arg ctor
+#  - Check for boolean assign RHS in parens
+#  - Check for ctor initializer-list colon position and spacing
+#  - Check that if there's a ctor, there should be a dtor
+#  - Check accessors that return non-pointer member variables are
+#    declared const
+#  - Check accessors that return non-const pointer member vars are
+#    *not* declared const
+#  - Check for using public includes for testing
+#  - Check for spaces between brackets in one-line inline method
+#  - Check for no assert()
+#  - Check for spaces surrounding operators
+#  - Check for 0 in pointer context (should be NULL)
+#  - Check for 0 in char context (should be '\0')
+#  - Check for camel-case method name conventions for methods
+#    that are not simple inline getters and setters
+#  - Do not indent namespace contents
+#  - Avoid inlining non-trivial constructors in header files
+#  - Check for old-school (void) cast for call-sites of functions
+#    ignored return value
+#  - Check gUnit usage of anonymous namespace
+#  - Check for class declaration order (typedefs, consts, enums,
+#    ctor(s?), dtor, friend declarations, methods, member vars)
+#
+
+"""Does google-lint on c++ files.
+
+The goal of this script is to identify places in the code that *may*
+be in non-compliance with google style.  It does not attempt to fix
+up these problems -- the point is to educate.  It does also not
+attempt to find all problems, or to ensure that everything it does
+find is legitimately a problem.
+
+In particular, we can get very confused by /* and // inside strings!
+We do a small hack, which is to ignore //'s with "'s after them on the
+same line, but it is far from perfect (in either direction).
+"""
+
+import codecs
+import copy
+import getopt
+import math  # for log
+import os
+import re
+import sre_compile
+import string
+import sys
+import unicodedata
+
+
+_USAGE = """
+Syntax: cpplint.py [--verbose=#] [--output=vs7] [--filter=-x,+y,...]
+                   [--counting=total|toplevel|detailed]
+        <file> [file] ...
+
+  The style guidelines this tries to follow are those in
+    http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
+
+  Every problem is given a confidence score from 1-5, with 5 meaning we are
+  certain of the problem, and 1 meaning it could be a legitimate construct.
+  This will miss some errors, and is not a substitute for a code review.
+
+  To suppress false-positive errors of a certain category, add a
+  'NOLINT(category)' comment to the line.  NOLINT or NOLINT(*)
+  suppresses errors of all categories on that line.
+
+  The files passed in will be linted; at least one file must be provided.
+  Linted extensions are .cc, .cpp, and .h.  Other file types will be ignored.
+
+  Flags:
+
+    output=vs7
+      By default, the output is formatted to ease emacs parsing.  Visual Studio
+      compatible output (vs7) may also be used.  Other formats are unsupported.
+
+    verbose=#
+      Specify a number 0-5 to restrict errors to certain verbosity levels.
+
+    filter=-x,+y,...
+      Specify a comma-separated list of category-filters to apply: only
+      error messages whose category names pass the filters will be printed.
+      (Category names are printed with the message and look like
+      "[whitespace/indent]".)  Filters are evaluated left to right.
+      "-FOO" and "FOO" means "do not print categories that start with FOO".
+      "+FOO" means "do print categories that start with FOO".
+
+      Examples: --filter=-whitespace,+whitespace/braces
+                --filter=whitespace,runtime/printf,+runtime/printf_format
+                --filter=-,+build/include_what_you_use
+
+      To see a list of all the categories used in cpplint, pass no arg:
+         --filter=
+
+    counting=total|toplevel|detailed
+      The total number of errors found is always printed. If
+      'toplevel' is provided, then the count of errors in each of
+      the top-level categories like 'build' and 'whitespace' will
+      also be printed. If 'detailed' is provided, then a count
+      is provided for each category like 'build/class'.
+
+    root=subdir
+      The root directory used for deriving header guard CPP variable.
+      By default, the header guard CPP variable is calculated as the relative
+      path to the directory that contains .git, .hg, or .svn.  When this flag
+      is specified, the relative path is calculated from the specified
+      directory. If the specified directory does not exist, this flag is
+      ignored.
+
+      Examples:
+        Assuing that src/.git exists, the header guard CPP variables for
+        src/chrome/browser/ui/browser.h are:
+
+        No flag => CHROME_BROWSER_UI_BROWSER_H_
+        --root=chrome => BROWSER_UI_BROWSER_H_
+        --root=chrome/browser => UI_BROWSER_H_
+"""
+
+# We categorize each error message we print.  Here are the categories.
+# We want an explicit list so we can list them all in cpplint --filter=.
+# If you add a new error message with a new category, add it to the list
+# here!  cpplint_unittest.py should tell you if you forget to do this.
+# \ used for clearer layout -- pylint: disable-msg=C6013
+_ERROR_CATEGORIES = [
+  'build/class',
+  'build/deprecated',
+  'build/endif_comment',
+  'build/explicit_make_pair',
+  'build/forward_decl',
+  'build/header_guard',
+  'build/include',
+  'build/include_alpha',
+  'build/include_order',
+  'build/include_what_you_use',
+  'build/namespaces',
+  'build/printf_format',
+  'build/storage_class',
+  'legal/copyright',
+  'readability/alt_tokens',
+  'readability/braces',
+  'readability/casting',
+  'readability/check',
+  'readability/constructors',
+  'readability/fn_size',
+  'readability/function',
+  'readability/multiline_comment',
+  'readability/multiline_string',
+  'readability/namespace',
+  'readability/nolint',
+  'readability/streams',
+  'readability/todo',
+  'readability/utf8',
+  'runtime/arrays',
+  'runtime/casting',
+  'runtime/explicit',
+  'runtime/int',
+  'runtime/init',
+  'runtime/invalid_increment',
+  'runtime/member_string_references',
+  'runtime/memset',
+  'runtime/operator',
+  'runtime/printf',
+  'runtime/printf_format',
+  'runtime/references',
+  'runtime/rtti',
+  'runtime/sizeof',
+  'runtime/string',
+  'runtime/threadsafe_fn',
+  'whitespace/blank_line',
+  'whitespace/braces',
+  'whitespace/comma',
+  'whitespace/comments',
+  'whitespace/empty_loop_body',
+  'whitespace/end_of_line',
+  'whitespace/ending_newline',
+  'whitespace/forcolon',
+  'whitespace/indent',
+  'whitespace/labels',
+  'whitespace/line_length',
+  'whitespace/newline',
+  'whitespace/operators',
+  'whitespace/parens',
+  'whitespace/semicolon',
+  'whitespace/tab',
+  'whitespace/todo'
+  ]
+
+# The default state of the category filter. This is overrided by the --filter=
+# flag. By default all errors are on, so only add here categories that should be
+# off by default (i.e., categories that must be enabled by the --filter= flags).
+# All entries here should start with a '-' or '+', as in the --filter= flag.
+_DEFAULT_FILTERS = ['-build/include_alpha']
+
+# We used to check for high-bit characters, but after much discussion we
+# decided those were OK, as long as they were in UTF-8 and didn't represent
+# hard-coded international strings, which belong in a separate i18n file.
+
+# Headers that we consider STL headers.
+_STL_HEADERS = frozenset([
+    'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception',
+    'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set',
+    'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'new',
+    'pair.h', 'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack',
+    'stl_alloc.h', 'stl_relops.h', 'type_traits.h',
+    'utility', 'vector', 'vector.h',
+    ])
+
+
+# Non-STL C++ system headers.
+_CPP_HEADERS = frozenset([
+    'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype',
+    'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath',
+    'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef',
+    'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype',
+    'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream',
+    'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip',
+    'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream',
+    'istream.h', 'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h',
+    'numeric', 'ostream', 'ostream.h', 'parsestream.h', 'pfstream.h',
+    'PlotFile.h', 'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h',
+    'ropeimpl.h', 'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept',
+    'stdiostream.h', 'streambuf', 'streambuf.h', 'stream.h', 'strfile.h',
+    'string', 'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo',
+    'valarray',
+    ])
+
+
+# Assertion macros.  These are defined in base/logging.h and
+# testing/base/gunit.h.  Note that the _M versions need to come first
+# for substring matching to work.
+_CHECK_MACROS = [
+    'DCHECK', 'CHECK',
+    'EXPECT_TRUE_M', 'EXPECT_TRUE',
+    'ASSERT_TRUE_M', 'ASSERT_TRUE',
+    'EXPECT_FALSE_M', 'EXPECT_FALSE',
+    'ASSERT_FALSE_M', 'ASSERT_FALSE',
+    ]
+
+# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE
+_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS])
+
+for op, replacement in [('==', 'EQ'), ('!=', 'NE'),
+                        ('>=', 'GE'), ('>', 'GT'),
+                        ('<=', 'LE'), ('<', 'LT')]:
+  _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement
+  _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement
+  _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement
+  _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement
+  _CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement
+  _CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement
+
+for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),
+                            ('>=', 'LT'), ('>', 'LE'),
+                            ('<=', 'GT'), ('<', 'GE')]:
+  _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement
+  _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement
+  _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement
+  _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement
+
+# Alternative tokens and their replacements.  For full list, see section 2.5
+# Alternative tokens [lex.digraph] in the C++ standard.
+#
+# Digraphs (such as '%:') are not included here since it's a mess to
+# match those on a word boundary.
+_ALT_TOKEN_REPLACEMENT = {
+    'and': '&&',
+    'bitor': '|',
+    'or': '||',
+    'xor': '^',
+    'compl': '~',
+    'bitand': '&',
+    'and_eq': '&=',
+    'or_eq': '|=',
+    'xor_eq': '^=',
+    'not': '!',
+    'not_eq': '!='
+    }
+
+# Compile regular expression that matches all the above keywords.  The "[ =()]"
+# bit is meant to avoid matching these keywords outside of boolean expressions.
+#
+# False positives include C-style multi-line comments (http://go/nsiut )
+# and multi-line strings (http://go/beujw ), but those have always been
+# troublesome for cpplint.
+_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile(
+    r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)')
+
+
+# These constants define types of headers for use with
+# _IncludeState.CheckNextIncludeOrder().
+_C_SYS_HEADER = 1
+_CPP_SYS_HEADER = 2
+_LIKELY_MY_HEADER = 3
+_POSSIBLE_MY_HEADER = 4
+_OTHER_HEADER = 5
+
+# These constants define the current inline assembly state
+_NO_ASM = 0       # Outside of inline assembly block
+_INSIDE_ASM = 1   # Inside inline assembly block
+_END_ASM = 2      # Last line of inline assembly block
+_BLOCK_ASM = 3    # The whole block is an inline assembly block
+
+# Match start of assembly blocks
+_MATCH_ASM = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)'
+                        r'(?:\s+(volatile|__volatile__))?'
+                        r'\s*[{(]')
+
+
+_regexp_compile_cache = {}
+
+# Finds occurrences of NOLINT or NOLINT(...).
+_RE_SUPPRESSION = re.compile(r'\bNOLINT\b(\([^)]*\))?')
+
+# {str, set(int)}: a map from error categories to sets of linenumbers
+# on which those errors are expected and should be suppressed.
+_error_suppressions = {}
+
+# The root directory used for deriving header guard CPP variable.
+# This is set by --root flag.
+_root = None
+
+def ParseNolintSuppressions(filename, raw_line, linenum, error):
+  """Updates the global list of error-suppressions.
+
+  Parses any NOLINT comments on the current line, updating the global
+  error_suppressions store.  Reports an error if the NOLINT comment
+  was malformed.
+
+  Args:
+    filename: str, the name of the input file.
+    raw_line: str, the line of input text, with comments.
+    linenum: int, the number of the current line.
+    error: function, an error handler.
+  """
+  # FIXME(adonovan): "NOLINT(" is misparsed as NOLINT(*).
+  matched = _RE_SUPPRESSION.search(raw_line)
+  if matched:
+    category = matched.group(1)
+    if category in (None, '(*)'):  # => "suppress all"
+      _error_suppressions.setdefault(None, set()).add(linenum)
+    else:
+      if category.startswith('(') and category.endswith(')'):
+        category = category[1:-1]
+        if category in _ERROR_CATEGORIES:
+          _error_suppressions.setdefault(category, set()).add(linenum)
+        else:
+          error(filename, linenum, 'readability/nolint', 5,
+                'Unknown NOLINT error category: %s' % category)
+
+
+def ResetNolintSuppressions():
+  "Resets the set of NOLINT suppressions to empty."
+  _error_suppressions.clear()
+
+
+def IsErrorSuppressedByNolint(category, linenum):
+  """Returns true if the specified error category is suppressed on this line.
+
+  Consults the global error_suppressions map populated by
+  ParseNolintSuppressions/ResetNolintSuppressions.
+
+  Args:
+    category: str, the category of the error.
+    linenum: int, the current line number.
+  Returns:
+    bool, True iff the error should be suppressed due to a NOLINT comment.
+  """
+  return (linenum in _error_suppressions.get(category, set()) or
+          linenum in _error_suppressions.get(None, set()))
+
+def Match(pattern, s):
+  """Matches the string with the pattern, caching the compiled regexp."""
+  # The regexp compilation caching is inlined in both Match and Search for
+  # performance reasons; factoring it out into a separate function turns out
+  # to be noticeably expensive.
+  if not pattern in _regexp_compile_cache:
+    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+  return _regexp_compile_cache[pattern].match(s)
+
+
+def Search(pattern, s):
+  """Searches the string for the pattern, caching the compiled regexp."""
+  if not pattern in _regexp_compile_cache:
+    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+  return _regexp_compile_cache[pattern].search(s)
+
+
+class _IncludeState(dict):
+  """Tracks line numbers for includes, and the order in which includes appear.
+
+  As a dict, an _IncludeState object serves as a mapping between include
+  filename and line number on which that file was included.
+
+  Call CheckNextIncludeOrder() once for each header in the file, passing
+  in the type constants defined above. Calls in an illegal order will
+  raise an _IncludeError with an appropriate error message.
+
+  """
+  # self._section will move monotonically through this set. If it ever
+  # needs to move backwards, CheckNextIncludeOrder will raise an error.
+  _INITIAL_SECTION = 0
+  _MY_H_SECTION = 1
+  _C_SECTION = 2
+  _CPP_SECTION = 3
+  _OTHER_H_SECTION = 4
+
+  _TYPE_NAMES = {
+      _C_SYS_HEADER: 'C system header',
+      _CPP_SYS_HEADER: 'C++ system header',
+      _LIKELY_MY_HEADER: 'header this file implements',
+      _POSSIBLE_MY_HEADER: 'header this file may implement',
+      _OTHER_HEADER: 'other header',
+      }
+  _SECTION_NAMES = {
+      _INITIAL_SECTION: "... nothing. (This can't be an error.)",
+      _MY_H_SECTION: 'a header this file implements',
+      _C_SECTION: 'C system header',
+      _CPP_SECTION: 'C++ system header',
+      _OTHER_H_SECTION: 'other header',
+      }
+
+  def __init__(self):
+    dict.__init__(self)
+    # The name of the current section.
+    self._section = self._INITIAL_SECTION
+    # The path of last found header.
+    self._last_header = ''
+
+  def CanonicalizeAlphabeticalOrder(self, header_path):
+    """Returns a path canonicalized for alphabetical comparison.
+
+    - replaces "-" with "_" so they both cmp the same.
+    - removes '-inl' since we don't require them to be after the main header.
+    - lowercase everything, just in case.
+
+    Args:
+      header_path: Path to be canonicalized.
+
+    Returns:
+      Canonicalized path.
+    """
+    return header_path.replace('-inl.h', '.h').replace('-', '_').lower()
+
+  def IsInAlphabeticalOrder(self, header_path):
+    """Check if a header is in alphabetical order with the previous header.
+
+    Args:
+      header_path: Header to be checked.
+
+    Returns:
+      Returns true if the header is in alphabetical order.
+    """
+    canonical_header = self.CanonicalizeAlphabeticalOrder(header_path)
+    if self._last_header > canonical_header:
+      return False
+    self._last_header = canonical_header
+    return True
+
+  def CheckNextIncludeOrder(self, header_type):
+    """Returns a non-empty error message if the next header is out of order.
+
+    This function also updates the internal state to be ready to check
+    the next include.
+
+    Args:
+      header_type: One of the _XXX_HEADER constants defined above.
+
+    Returns:
+      The empty string if the header is in the right order, or an
+      error message describing what's wrong.
+
+    """
+    error_message = ('Found %s after %s' %
+                     (self._TYPE_NAMES[header_type],
+                      self._SECTION_NAMES[self._section]))
+
+    last_section = self._section
+
+    if header_type == _C_SYS_HEADER:
+      if self._section <= self._C_SECTION:
+        self._section = self._C_SECTION
+      else:
+        self._last_header = ''
+        return error_message
+    elif header_type == _CPP_SYS_HEADER:
+      if self._section <= self._CPP_SECTION:
+        self._section = self._CPP_SECTION
+      else:
+        self._last_header = ''
+        return error_message
+    elif header_type == _LIKELY_MY_HEADER:
+      if self._section <= self._MY_H_SECTION:
+        self._section = self._MY_H_SECTION
+      else:
+        self._section = self._OTHER_H_SECTION
+    elif header_type == _POSSIBLE_MY_HEADER:
+      if self._section <= self._MY_H_SECTION:
+        self._section = self._MY_H_SECTION
+      else:
+        # This will always be the fallback because we're not sure
+        # enough that the header is associated with this file.
+        self._section = self._OTHER_H_SECTION
+    else:
+      assert header_type == _OTHER_HEADER
+      self._section = self._OTHER_H_SECTION
+
+    if last_section != self._section:
+      self._last_header = ''
+
+    return ''
+
+
+class _CppLintState(object):
+  """Maintains module-wide state.."""
+
+  def __init__(self):
+    self.verbose_level = 1  # global setting.
+    self.error_count = 0    # global count of reported errors
+    # filters to apply when emitting error messages
+    self.filters = _DEFAULT_FILTERS[:]
+    self.counting = 'total'  # In what way are we counting errors?
+    self.errors_by_category = {}  # string to int dict storing error counts
+
+    # output format:
+    # "emacs" - format that emacs can parse (default)
+    # "vs7" - format that Microsoft Visual Studio 7 can parse
+    self.output_format = 'emacs'
+
+  def SetOutputFormat(self, output_format):
+    """Sets the output format for errors."""
+    self.output_format = output_format
+
+  def SetVerboseLevel(self, level):
+    """Sets the module's verbosity, and returns the previous setting."""
+    last_verbose_level = self.verbose_level
+    self.verbose_level = level
+    return last_verbose_level
+
+  def SetCountingStyle(self, counting_style):
+    """Sets the module's counting options."""
+    self.counting = counting_style
+
+  def SetFilters(self, filters):
+    """Sets the error-message filters.
+
+    These filters are applied when deciding whether to emit a given
+    error message.
+
+    Args:
+      filters: A string of comma-separated filters (eg "+whitespace/indent").
+               Each filter should start with + or -; else we die.
+
+    Raises:
+      ValueError: The comma-separated filters did not all start with '+' or '-'.
+                  E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter"
+    """
+    # Default filters always have less priority than the flag ones.
+    self.filters = _DEFAULT_FILTERS[:]
+    for filt in filters.split(','):
+      clean_filt = filt.strip()
+      if clean_filt:
+        self.filters.append(clean_filt)
+    for filt in self.filters:
+      if not (filt.startswith('+') or filt.startswith('-')):
+        raise ValueError('Every filter in --filters must start with + or -'
+                         ' (%s does not)' % filt)
+
+  def ResetErrorCounts(self):
+    """Sets the module's error statistic back to zero."""
+    self.error_count = 0
+    self.errors_by_category = {}
+
+  def IncrementErrorCount(self, category):
+    """Bumps the module's error statistic."""
+    self.error_count += 1
+    if self.counting in ('toplevel', 'detailed'):
+      if self.counting != 'detailed':
+        category = category.split('/')[0]
+      if category not in self.errors_by_category:
+        self.errors_by_category[category] = 0
+      self.errors_by_category[category] += 1
+
+  def PrintErrorCounts(self):
+    """Print a summary of errors by category, and the total."""
+    for category, count in self.errors_by_category.iteritems():
+      sys.stderr.write('Category \'%s\' errors found: %d\n' %
+                       (category, count))
+    sys.stderr.write('Total errors found: %d\n' % self.error_count)
+
+_cpplint_state = _CppLintState()
+
+
+def _OutputFormat():
+  """Gets the module's output format."""
+  return _cpplint_state.output_format
+
+
+def _SetOutputFormat(output_format):
+  """Sets the module's output format."""
+  _cpplint_state.SetOutputFormat(output_format)
+
+
+def _VerboseLevel():
+  """Returns the module's verbosity setting."""
+  return _cpplint_state.verbose_level
+
+
+def _SetVerboseLevel(level):
+  """Sets the module's verbosity, and returns the previous setting."""
+  return _cpplint_state.SetVerboseLevel(level)
+
+
+def _SetCountingStyle(level):
+  """Sets the module's counting options."""
+  _cpplint_state.SetCountingStyle(level)
+
+
+def _Filters():
+  """Returns the module's list of output filters, as a list."""
+  return _cpplint_state.filters
+
+
+def _SetFilters(filters):
+  """Sets the module's error-message filters.
+
+  These filters are applied when deciding whether to emit a given
+  error message.
+
+  Args:
+    filters: A string of comma-separated filters (eg "whitespace/indent").
+             Each filter should start with + or -; else we die.
+  """
+  _cpplint_state.SetFilters(filters)
+
+
+class _FunctionState(object):
+  """Tracks current function name and the number of lines in its body."""
+
+  _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.
+  _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.
+
+  def __init__(self):
+    self.in_a_function = False
+    self.lines_in_function = 0
+    self.current_function = ''
+
+  def Begin(self, function_name):
+    """Start analyzing function body.
+
+    Args:
+      function_name: The name of the function being tracked.
+    """
+    self.in_a_function = True
+    self.lines_in_function = 0
+    self.current_function = function_name
+
+  def Count(self):
+    """Count line in current function body."""
+    if self.in_a_function:
+      self.lines_in_function += 1
+
+  def Check(self, error, filename, linenum):
+    """Report if too many lines in function body.
+
+    Args:
+      error: The function to call with any errors found.
+      filename: The name of the current file.
+      linenum: The number of the line to check.
+    """
+    if Match(r'T(EST|est)', self.current_function):
+      base_trigger = self._TEST_TRIGGER
+    else:
+      base_trigger = self._NORMAL_TRIGGER
+    trigger = base_trigger * 2**_VerboseLevel()
+
+    if self.lines_in_function > trigger:
+      error_level = int(math.log(self.lines_in_function / base_trigger, 2))
+      # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...
+      if error_level > 5:
+        error_level = 5
+      error(filename, linenum, 'readability/fn_size', error_level,
+            'Small and focused functions are preferred:'
+            ' %s has %d non-comment lines'
+            ' (error triggered by exceeding %d lines).'  % (
+                self.current_function, self.lines_in_function, trigger))
+
+  def End(self):
+    """Stop analyzing function body."""
+    self.in_a_function = False
+
+
+class _IncludeError(Exception):
+  """Indicates a problem with the include order in a file."""
+  pass
+
+
+class FileInfo:
+  """Provides utility functions for filenames.
+
+  FileInfo provides easy access to the components of a file's path
+  relative to the project root.
+  """
+
+  def __init__(self, filename):
+    self._filename = filename
+
+  def FullName(self):
+    """Make Windows paths like Unix."""
+    return os.path.abspath(self._filename).replace('\\', '/')
+
+  def RepositoryName(self):
+    """FullName after removing the local path to the repository.
+
+    If we have a real absolute path name here we can try to do something smart:
+    detecting the root of the checkout and truncating /path/to/checkout from
+    the name so that we get header guards that don't include things like
+    "C:\Documents and Settings\..." or "/home/username/..." in them and thus
+    people on different computers who have checked the source out to different
+    locations won't see bogus errors.
+    """
+    fullname = self.FullName()
+
+    if os.path.exists(fullname):
+      project_dir = os.path.dirname(fullname)
+
+      if os.path.exists(os.path.join(project_dir, ".svn")):
+        # If there's a .svn file in the current directory, we recursively look
+        # up the directory tree for the top of the SVN checkout
+        root_dir = project_dir
+        one_up_dir = os.path.dirname(root_dir)
+        while os.path.exists(os.path.join(one_up_dir, ".svn")):
+          root_dir = os.path.dirname(root_dir)
+          one_up_dir = os.path.dirname(one_up_dir)
+
+        prefix = os.path.commonprefix([root_dir, project_dir])
+        return fullname[len(prefix) + 1:]
+
+      # Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by
+      # searching up from the current path.
+      root_dir = os.path.dirname(fullname)
+      while (root_dir != os.path.dirname(root_dir) and
+             not os.path.exists(os.path.join(root_dir, ".git")) and
+             not os.path.exists(os.path.join(root_dir, ".hg")) and
+             not os.path.exists(os.path.join(root_dir, ".svn"))):
+        root_dir = os.path.dirname(root_dir)
+
+      if (os.path.exists(os.path.join(root_dir, ".git")) or
+          os.path.exists(os.path.join(root_dir, ".hg")) or
+          os.path.exists(os.path.join(root_dir, ".svn"))):
+        prefix = os.path.commonprefix([root_dir, project_dir])
+        return fullname[len(prefix) + 1:]
+
+    # Don't know what to do; header guard warnings may be wrong...
+    return fullname
+
+  def Split(self):
+    """Splits the file into the directory, basename, and extension.
+
+    For 'chrome/browser/browser.cc', Split() would
+    return ('chrome/browser', 'browser', '.cc')
+
+    Returns:
+      A tuple of (directory, basename, extension).
+    """
+
+    googlename = self.RepositoryName()
+    project, rest = os.path.split(googlename)
+    return (project,) + os.path.splitext(rest)
+
+  def BaseName(self):
+    """File base name - text after the final slash, before the final period."""
+    return self.Split()[1]
+
+  def Extension(self):
+    """File extension - text following the final period."""
+    return self.Split()[2]
+
+  def NoExtension(self):
+    """File has no source file extension."""
+    return '/'.join(self.Split()[0:2])
+
+  def IsSource(self):
+    """File has a source file extension."""
+    return self.Extension()[1:] in ('c', 'cc', 'cpp', 'cxx')
+
+
+def _ShouldPrintError(category, confidence, linenum):
+  """If confidence >= verbose, category passes filter and is not suppressed."""
+
+  # There are three ways we might decide not to print an error message:
+  # a "NOLINT(category)" comment appears in the source,
+  # the verbosity level isn't high enough, or the filters filter it out.
+  if IsErrorSuppressedByNolint(category, linenum):
+    return False
+  if confidence < _cpplint_state.verbose_level:
+    return False
+
+  is_filtered = False
+  for one_filter in _Filters():
+    if one_filter.startswith('-'):
+      if category.startswith(one_filter[1:]):
+        is_filtered = True
+    elif one_filter.startswith('+'):
+      if category.startswith(one_filter[1:]):
+        is_filtered = False
+    else:
+      assert False  # should have been checked for in SetFilter.
+  if is_filtered:
+    return False
+
+  return True
+
+
+def Error(filename, linenum, category, confidence, message):
+  """Logs the fact we've found a lint error.
+
+  We log where the error was found, and also our confidence in the error,
+  that is, how certain we are this is a legitimate style regression, and
+  not a misidentification or a use that's sometimes justified.
+
+  False positives can be suppressed by the use of
+  "cpplint(category)"  comments on the offending line.  These are
+  parsed into _error_suppressions.
+
+  Args:
+    filename: The name of the file containing the error.
+    linenum: The number of the line containing the error.
+    category: A string used to describe the "category" this bug
+      falls under: "whitespace", say, or "runtime".  Categories
+      may have a hierarchy separated by slashes: "whitespace/indent".
+    confidence: A number from 1-5 representing a confidence score for
+      the error, with 5 meaning that we are certain of the problem,
+      and 1 meaning that it could be a legitimate construct.
+    message: The error message.
+  """
+  if _ShouldPrintError(category, confidence, linenum):
+    _cpplint_state.IncrementErrorCount(category)
+    if _cpplint_state.output_format == 'vs7':
+      sys.stderr.write('%s(%s):  %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence))
+    elif _cpplint_state.output_format == 'eclipse':
+      sys.stderr.write('%s:%s: warning: %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence))
+    else:
+      sys.stderr.write('%s:%s:  %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence))
+
+
+# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard.
+_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(
+    r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)')
+# Matches strings.  Escape codes should already be removed by ESCAPES.
+_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"')
+# Matches characters.  Escape codes should already be removed by ESCAPES.
+_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'")
+# Matches multi-line C++ comments.
+# This RE is a little bit more complicated than one might expect, because we
+# have to take care of space removals tools so we can handle comments inside
+# statements better.
+# The current rule is: We only clear spaces from both sides when we're at the
+# end of the line. Otherwise, we try to remove spaces from the right side,
+# if this doesn't work we try on left side but only if there's a non-character
+# on the right.
+_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(
+    r"""(\s*/\*.*\*/\s*$|
+            /\*.*\*/\s+|
+         \s+/\*.*\*/(?=\W)|
+            /\*.*\*/)""", re.VERBOSE)
+
+
+def IsCppString(line):
+  """Does line terminate so, that the next symbol is in string constant.
+
+  This function does not consider single-line nor multi-line comments.
+
+  Args:
+    line: is a partial line of code starting from the 0..n.
+
+  Returns:
+    True, if next character appended to 'line' is inside a
+    string constant.
+  """
+
+  line = line.replace(r'\\', 'XX')  # after this, \\" does not match to \"
+  return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1
+
+
+def FindNextMultiLineCommentStart(lines, lineix):
+  """Find the beginning marker for a multiline comment."""
+  while lineix < len(lines):
+    if lines[lineix].strip().startswith('/*'):
+      # Only return this marker if the comment goes beyond this line
+      if lines[lineix].strip().find('*/', 2) < 0:
+        return lineix
+    lineix += 1
+  return len(lines)
+
+
+def FindNextMultiLineCommentEnd(lines, lineix):
+  """We are inside a comment, find the end marker."""
+  while lineix < len(lines):
+    if lines[lineix].strip().endswith('*/'):
+      return lineix
+    lineix += 1
+  return len(lines)
+
+
+def RemoveMultiLineCommentsFromRange(lines, begin, end):
+  """Clears a range of lines for multi-line comments."""
+  # Having // dummy comments makes the lines non-empty, so we will not get
+  # unnecessary blank line warnings later in the code.
+  for i in range(begin, end):
+    lines[i] = '// dummy'
+
+
+def RemoveMultiLineComments(filename, lines, error):
+  """Removes multiline (c-style) comments from lines."""
+  lineix = 0
+  while lineix < len(lines):
+    lineix_begin = FindNextMultiLineCommentStart(lines, lineix)
+    if lineix_begin >= len(lines):
+      return
+    lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin)
+    if lineix_end >= len(lines):
+      error(filename, lineix_begin + 1, 'readability/multiline_comment', 5,
+            'Could not find end of multi-line comment')
+      return
+    RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1)
+    lineix = lineix_end + 1
+
+
+def CleanseComments(line):
+  """Removes //-comments and single-line C-style /* */ comments.
+
+  Args:
+    line: A line of C++ source.
+
+  Returns:
+    The line with single-line comments removed.
+  """
+  commentpos = line.find('//')
+  if commentpos != -1 and not IsCppString(line[:commentpos]):
+    line = line[:commentpos].rstrip()
+  # get rid of /* ... */
+  return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)
+
+
+class CleansedLines(object):
+  """Holds 3 copies of all lines with different preprocessing applied to them.
+
+  1) elided member contains lines without strings and comments,
+  2) lines member contains lines without comments, and
+  3) raw_lines member contains all the lines without processing.
+  All these three members are of <type 'list'>, and of the same length.
+  """
+
+  def __init__(self, lines):
+    self.elided = []
+    self.lines = []
+    self.raw_lines = lines
+    self.num_lines = len(lines)
+    for linenum in range(len(lines)):
+      self.lines.append(CleanseComments(lines[linenum]))
+      elided = self._CollapseStrings(lines[linenum])
+      self.elided.append(CleanseComments(elided))
+
+  def NumLines(self):
+    """Returns the number of lines represented."""
+    return self.num_lines
+
+  @staticmethod
+  def _CollapseStrings(elided):
+    """Collapses strings and chars on a line to simple "" or '' blocks.
+
+    We nix strings first so we're not fooled by text like '"http://"'
+
+    Args:
+      elided: The line being processed.
+
+    Returns:
+      The line with collapsed strings.
+    """
+    if not _RE_PATTERN_INCLUDE.match(elided):
+      # Remove escaped characters first to make quote/single quote collapsing
+      # basic.  Things that look like escaped characters shouldn't occur
+      # outside of strings and chars.
+      elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided)
+      elided = _RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES.sub("''", elided)
+      elided = _RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES.sub('""', elided)
+    return elided
+
+
+def FindEndOfExpressionInLine(line, startpos, depth, startchar, endchar):
+  """Find the position just after the matching endchar.
+
+  Args:
+    line: a CleansedLines line.
+    startpos: start searching at this position.
+    depth: nesting level at startpos.
+    startchar: expression opening character.
+    endchar: expression closing character.
+
+  Returns:
+    Index just after endchar.
+  """
+  for i in xrange(startpos, len(line)):
+    if line[i] == startchar:
+      depth += 1
+    elif line[i] == endchar:
+      depth -= 1
+      if depth == 0:
+        return i + 1
+  return -1
+
+
+def CloseExpression(clean_lines, linenum, pos):
+  """If input points to ( or { or [, finds the position that closes it.
+
+  If lines[linenum][pos] points to a '(' or '{' or '[', finds the
+  linenum/pos that correspond to the closing of the expression.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    pos: A position on the line.
+
+  Returns:
+    A tuple (line, linenum, pos) pointer *past* the closing brace, or
+    (line, len(lines), -1) if we never find a close.  Note we ignore
+    strings and comments when matching; and the line we return is the
+    'cleansed' line at linenum.
+  """
+
+  line = clean_lines.elided[linenum]
+  startchar = line[pos]
+  if startchar not in '({[':
+    return (line, clean_lines.NumLines(), -1)
+  if startchar == '(': endchar = ')'
+  if startchar == '[': endchar = ']'
+  if startchar == '{': endchar = '}'
+
+  # Check first line
+  end_pos = FindEndOfExpressionInLine(line, pos, 0, startchar, endchar)
+  if end_pos > -1:
+    return (line, linenum, end_pos)
+  tail = line[pos:]
+  num_open = tail.count(startchar) - tail.count(endchar)
+  while linenum < clean_lines.NumLines() - 1:
+    linenum += 1
+    line = clean_lines.elided[linenum]
+    delta = line.count(startchar) - line.count(endchar)
+    if num_open + delta <= 0:
+      return (line, linenum,
+              FindEndOfExpressionInLine(line, 0, num_open, startchar, endchar))
+    num_open += delta
+
+  # Did not find endchar before end of file, give up
+  return (line, clean_lines.NumLines(), -1)
+
+def CheckForCopyright(filename, lines, error):
+  """Logs an error if no Copyright message appears at the top of the file."""
+
+  # We'll say it should occur by line 10. Don't forget there's a
+  # dummy line at the front.
+  for line in xrange(1, min(len(lines), 11)):
+    if re.search(r'Copyright', lines[line], re.I): break
+  else:                       # means no copyright line was found
+    error(filename, 0, 'legal/copyright', 5,
+          'No copyright message found.  '
+          'You should have a line: "Copyright [year] <Copyright Owner>"')
+
+
+def GetHeaderGuardCPPVariable(filename):
+  """Returns the CPP variable that should be used as a header guard.
+
+  Args:
+    filename: The name of a C++ header file.
+
+  Returns:
+    The CPP variable that should be used as a header guard in the
+    named file.
+
+  """
+
+  # Restores original filename in case that cpplint is invoked from Emacs's
+  # flymake.
+  filename = re.sub(r'_flymake\.h$', '.h', filename)
+  filename = re.sub(r'/\.flymake/([^/]*)$', r'/\1', filename)
+
+  fileinfo = FileInfo(filename)
+  file_path_from_root = fileinfo.RepositoryName()
+  if _root:
+    file_path_from_root = re.sub('^' + _root + os.sep, '', file_path_from_root)
+  return re.sub(r'[-./\s]', '_', file_path_from_root).upper() + '_'
+
+
+def CheckForHeaderGuard(filename, lines, error):
+  """Checks that the file contains a header guard.
+
+  Logs an error if no #ifndef header guard is present.  For other
+  headers, checks that the full pathname is used.
+
+  Args:
+    filename: The name of the C++ header file.
+    lines: An array of strings, each representing a line of the file.
+    error: The function to call with any errors found.
+  """
+
+  cppvar = GetHeaderGuardCPPVariable(filename)
+
+  ifndef = None
+  ifndef_linenum = 0
+  define = None
+  endif = None
+  endif_linenum = 0
+  for linenum, line in enumerate(lines):
+    linesplit = line.split()
+    if len(linesplit) >= 2:
+      # find the first occurrence of #ifndef and #define, save arg
+      if not ifndef and linesplit[0] == '#ifndef':
+        # set ifndef to the header guard presented on the #ifndef line.
+        ifndef = linesplit[1]
+        ifndef_linenum = linenum
+      if not define and linesplit[0] == '#define':
+        define = linesplit[1]
+    # find the last occurrence of #endif, save entire line
+    if line.startswith('#endif'):
+      endif = line
+      endif_linenum = linenum
+
+  if not ifndef:
+    error(filename, 0, 'build/header_guard', 5,
+          'No #ifndef header guard found, suggested CPP variable is: %s' %
+          cppvar)
+    return
+
+  if not define:
+    error(filename, 0, 'build/header_guard', 5,
+          'No #define header guard found, suggested CPP variable is: %s' %
+          cppvar)
+    return
+
+  # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__
+  # for backward compatibility.
+  if ifndef != cppvar:
+    error_level = 0
+    if ifndef != cppvar + '_':
+      error_level = 5
+
+    ParseNolintSuppressions(filename, lines[ifndef_linenum], ifndef_linenum,
+                            error)
+    error(filename, ifndef_linenum, 'build/header_guard', error_level,
+          '#ifndef header guard has wrong style, please use: %s' % cppvar)
+
+  if define != ifndef:
+    error(filename, 0, 'build/header_guard', 5,
+          '#ifndef and #define don\'t match, suggested CPP variable is: %s' %
+          cppvar)
+    return
+
+  if endif != ('#endif  // %s' % cppvar):
+    error_level = 0
+    if endif != ('#endif  // %s' % (cppvar + '_')):
+      error_level = 5
+
+    ParseNolintSuppressions(filename, lines[endif_linenum], endif_linenum,
+                            error)
+    error(filename, endif_linenum, 'build/header_guard', error_level,
+          '#endif line should be "#endif  // %s"' % cppvar)
+
+
+def CheckForUnicodeReplacementCharacters(filename, lines, error):
+  """Logs an error for each line containing Unicode replacement characters.
+
+  These indicate that either the file contained invalid UTF-8 (likely)
+  or Unicode replacement characters (which it shouldn't).  Note that
+  it's possible for this to throw off line numbering if the invalid
+  UTF-8 occurred adjacent to a newline.
+
+  Args:
+    filename: The name of the current file.
+    lines: An array of strings, each representing a line of the file.
+    error: The function to call with any errors found.
+  """
+  for linenum, line in enumerate(lines):
+    if u'\ufffd' in line:
+      error(filename, linenum, 'readability/utf8', 5,
+            'Line contains invalid UTF-8 (or Unicode replacement character).')
+
+
+def CheckForNewlineAtEOF(filename, lines, error):
+  """Logs an error if there is no newline char at the end of the file.
+
+  Args:
+    filename: The name of the current file.
+    lines: An array of strings, each representing a line of the file.
+    error: The function to call with any errors found.
+  """
+
+  # The array lines() was created by adding two newlines to the
+  # original file (go figure), then splitting on \n.
+  # To verify that the file ends in \n, we just have to make sure the
+  # last-but-two element of lines() exists and is empty.
+  if len(lines) < 3 or lines[-2]:
+    error(filename, len(lines) - 2, 'whitespace/ending_newline', 5,
+          'Could not find a newline character at the end of the file.')
+
+
+def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):
+  """Logs an error if we see /* ... */ or "..." that extend past one line.
+
+  /* ... */ comments are legit inside macros, for one line.
+  Otherwise, we prefer // comments, so it's ok to warn about the
+  other.  Likewise, it's ok for strings to extend across multiple
+  lines, as long as a line continuation character (backslash)
+  terminates each line. Although not currently prohibited by the C++
+  style guide, it's ugly and unnecessary. We don't do well with either
+  in this lint program, so we warn about both.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Remove all \\ (escaped backslashes) from the line. They are OK, and the
+  # second (escaped) slash may trigger later \" detection erroneously.
+  line = line.replace('\\\\', '')
+
+  if line.count('/*') > line.count('*/'):
+    error(filename, linenum, 'readability/multiline_comment', 5,
+          'Complex multi-line /*...*/-style comment found. '
+          'Lint may give bogus warnings.  '
+          'Consider replacing these with //-style comments, '
+          'with #if 0...#endif, '
+          'or with more clearly structured multi-line comments.')
+
+  if (line.count('"') - line.count('\\"')) % 2:
+    error(filename, linenum, 'readability/multiline_string', 5,
+          'Multi-line string ("...") found.  This lint script doesn\'t '
+          'do well with such strings, and may give bogus warnings.  They\'re '
+          'ugly and unnecessary, and you should use concatenation instead".')
+
+
+threading_list = (
+    ('asctime(', 'asctime_r('),
+    ('ctime(', 'ctime_r('),
+    ('getgrgid(', 'getgrgid_r('),
+    ('getgrnam(', 'getgrnam_r('),
+    ('getlogin(', 'getlogin_r('),
+    ('getpwnam(', 'getpwnam_r('),
+    ('getpwuid(', 'getpwuid_r('),
+    ('gmtime(', 'gmtime_r('),
+    ('localtime(', 'localtime_r('),
+    ('rand(', 'rand_r('),
+    ('readdir(', 'readdir_r('),
+    ('strtok(', 'strtok_r('),
+    ('ttyname(', 'ttyname_r('),
+    )
+
+
+def CheckPosixThreading(filename, clean_lines, linenum, error):
+  """Checks for calls to thread-unsafe functions.
+
+  Much code has been originally written without consideration of
+  multi-threading. Also, engineers are relying on their old experience;
+  they have learned posix before threading extensions were added. These
+  tests guide the engineers to use thread-safe functions (when using
+  posix directly).
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+  for single_thread_function, multithread_safe_function in threading_list:
+    ix = line.find(single_thread_function)
+    # Comparisons made explicit for clarity -- pylint: disable-msg=C6403
+    if ix >= 0 and (ix == 0 or (not line[ix - 1].isalnum() and
+                                line[ix - 1] not in ('_', '.', '>'))):
+      error(filename, linenum, 'runtime/threadsafe_fn', 2,
+            'Consider using ' + multithread_safe_function +
+            '...) instead of ' + single_thread_function +
+            '...) for improved thread safety.')
+
+
+# Matches invalid increment: *count++, which moves pointer instead of
+# incrementing a value.
+_RE_PATTERN_INVALID_INCREMENT = re.compile(
+    r'^\s*\*\w+(\+\+|--);')
+
+
+def CheckInvalidIncrement(filename, clean_lines, linenum, error):
+  """Checks for invalid increment *count++.
+
+  For example following function:
+  void increment_counter(int* count) {
+    *count++;
+  }
+  is invalid, because it effectively does count++, moving pointer, and should
+  be replaced with ++*count, (*count)++ or *count += 1.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+  if _RE_PATTERN_INVALID_INCREMENT.match(line):
+    error(filename, linenum, 'runtime/invalid_increment', 5,
+          'Changing pointer instead of value (or unused value of operator*).')
+
+
+class _BlockInfo(object):
+  """Stores information about a generic block of code."""
+
+  def __init__(self, seen_open_brace):
+    self.seen_open_brace = seen_open_brace
+    self.open_parentheses = 0
+    self.inline_asm = _NO_ASM
+
+  def CheckBegin(self, filename, clean_lines, linenum, error):
+    """Run checks that applies to text up to the opening brace.
+
+    This is mostly for checking the text after the class identifier
+    and the "{", usually where the base class is specified.  For other
+    blocks, there isn't much to check, so we always pass.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    pass
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    """Run checks that applies to text after the closing brace.
+
+    This is mostly used for checking end of namespace comments.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    pass
+
+
+class _ClassInfo(_BlockInfo):
+  """Stores information about a class."""
+
+  def __init__(self, name, class_or_struct, clean_lines, linenum):
+    _BlockInfo.__init__(self, False)
+    self.name = name
+    self.starting_linenum = linenum
+    self.is_derived = False
+    if class_or_struct == 'struct':
+      self.access = 'public'
+    else:
+      self.access = 'private'
+
+    # Try to find the end of the class.  This will be confused by things like:
+    #   class A {
+    #   } *x = { ...
+    #
+    # But it's still good enough for CheckSectionSpacing.
+    self.last_line = 0
+    depth = 0
+    for i in range(linenum, clean_lines.NumLines()):
+      line = clean_lines.elided[i]
+      depth += line.count('{') - line.count('}')
+      if not depth:
+        self.last_line = i
+        break
+
+  def CheckBegin(self, filename, clean_lines, linenum, error):
+    # Look for a bare ':'
+    if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]):
+      self.is_derived = True
+
+
+class _NamespaceInfo(_BlockInfo):
+  """Stores information about a namespace."""
+
+  def __init__(self, name, linenum):
+    _BlockInfo.__init__(self, False)
+    self.name = name or ''
+    self.starting_linenum = linenum
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    """Check end of namespace comments."""
+    line = clean_lines.raw_lines[linenum]
+
+    # Check how many lines is enclosed in this namespace.  Don't issue
+    # warning for missing namespace comments if there aren't enough
+    # lines.  However, do apply checks if there is already an end of
+    # namespace comment and it's incorrect.
+    #
+    # TODO(unknown): We always want to check end of namespace comments
+    # if a namespace is large, but sometimes we also want to apply the
+    # check if a short namespace contained nontrivial things (something
+    # other than forward declarations).  There is currently no logic on
+    # deciding what these nontrivial things are, so this check is
+    # triggered by namespace size only, which works most of the time.
+    if (linenum - self.starting_linenum < 10
+        and not Match(r'};*\s*(//|/\*).*\bnamespace\b', line)):
+      return
+
+    # Look for matching comment at end of namespace.
+    #
+    # Note that we accept C style "/* */" comments for terminating
+    # namespaces, so that code that terminate namespaces inside
+    # preprocessor macros can be cpplint clean.  Example: http://go/nxpiz
+    #
+    # We also accept stuff like "// end of namespace <name>." with the
+    # period at the end.
+    #
+    # Besides these, we don't accept anything else, otherwise we might
+    # get false negatives when existing comment is a substring of the
+    # expected namespace.  Example: http://go/ldkdc, http://cl/23548205
+    if self.name:
+      # Named namespace
+      if not Match((r'};*\s*(//|/\*).*\bnamespace\s+' + re.escape(self.name) +
+                    r'[\*/\.\\\s]*$'),
+                   line):
+        error(filename, linenum, 'readability/namespace', 5,
+              'Namespace should be terminated with "// namespace %s"' %
+              self.name)
+    else:
+      # Anonymous namespace
+      if not Match(r'};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line):
+        error(filename, linenum, 'readability/namespace', 5,
+              'Namespace should be terminated with "// namespace"')
+
+
+class _PreprocessorInfo(object):
+  """Stores checkpoints of nesting stacks when #if/#else is seen."""
+
+  def __init__(self, stack_before_if):
+    # The entire nesting stack before #if
+    self.stack_before_if = stack_before_if
+
+    # The entire nesting stack up to #else
+    self.stack_before_else = []
+
+    # Whether we have already seen #else or #elif
+    self.seen_else = False
+
+
+class _NestingState(object):
+  """Holds states related to parsing braces."""
+
+  def __init__(self):
+    # Stack for tracking all braces.  An object is pushed whenever we
+    # see a "{", and popped when we see a "}".  Only 3 types of
+    # objects are possible:
+    # - _ClassInfo: a class or struct.
+    # - _NamespaceInfo: a namespace.
+    # - _BlockInfo: some other type of block.
+    self.stack = []
+
+    # Stack of _PreprocessorInfo objects.
+    self.pp_stack = []
+
+  def SeenOpenBrace(self):
+    """Check if we have seen the opening brace for the innermost block.
+
+    Returns:
+      True if we have seen the opening brace, False if the innermost
+      block is still expecting an opening brace.
+    """
+    return (not self.stack) or self.stack[-1].seen_open_brace
+
+  def InNamespaceBody(self):
+    """Check if we are currently one level inside a namespace body.
+
+    Returns:
+      True if top of the stack is a namespace block, False otherwise.
+    """
+    return self.stack and isinstance(self.stack[-1], _NamespaceInfo)
+
+  def UpdatePreprocessor(self, line):
+    """Update preprocessor stack.
+
+    We need to handle preprocessors due to classes like this:
+      #ifdef SWIG
+      struct ResultDetailsPageElementExtensionPoint {
+      #else
+      struct ResultDetailsPageElementExtensionPoint : public Extension {
+      #endif
+    (see http://go/qwddn for original example)
+
+    We make the following assumptions (good enough for most files):
+    - Preprocessor condition evaluates to true from #if up to first
+      #else/#elif/#endif.
+
+    - Preprocessor condition evaluates to false from #else/#elif up
+      to #endif.  We still perform lint checks on these lines, but
+      these do not affect nesting stack.
+
+    Args:
+      line: current line to check.
+    """
+    if Match(r'^\s*#\s*(if|ifdef|ifndef)\b', line):
+      # Beginning of #if block, save the nesting stack here.  The saved
+      # stack will allow us to restore the parsing state in the #else case.
+      self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack)))
+    elif Match(r'^\s*#\s*(else|elif)\b', line):
+      # Beginning of #else block
+      if self.pp_stack:
+        if not self.pp_stack[-1].seen_else:
+          # This is the first #else or #elif block.  Remember the
+          # whole nesting stack up to this point.  This is what we
+          # keep after the #endif.
+          self.pp_stack[-1].seen_else = True
+          self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack)
+
+        # Restore the stack to how it was before the #if
+        self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if)
+      else:
+        # TODO(unknown): unexpected #else, issue warning?
+        pass
+    elif Match(r'^\s*#\s*endif\b', line):
+      # End of #if or #else blocks.
+      if self.pp_stack:
+        # If we saw an #else, we will need to restore the nesting
+        # stack to its former state before the #else, otherwise we
+        # will just continue from where we left off.
+        if self.pp_stack[-1].seen_else:
+          # Here we can just use a shallow copy since we are the last
+          # reference to it.
+          self.stack = self.pp_stack[-1].stack_before_else
+        # Drop the corresponding #if
+        self.pp_stack.pop()
+      else:
+        # TODO(unknown): unexpected #endif, issue warning?
+        pass
+
+  def Update(self, filename, clean_lines, linenum, error):
+    """Update nesting state with current line.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    line = clean_lines.elided[linenum]
+
+    # Update pp_stack first
+    self.UpdatePreprocessor(line)
+
+    # Count parentheses.  This is to avoid adding struct arguments to
+    # the nesting stack.
+    if self.stack:
+      inner_block = self.stack[-1]
+      depth_change = line.count('(') - line.count(')')
+      inner_block.open_parentheses += depth_change
+
+      # Also check if we are starting or ending an inline assembly block.
+      if inner_block.inline_asm in (_NO_ASM, _END_ASM):
+        if (depth_change != 0 and
+            inner_block.open_parentheses == 1 and
+            _MATCH_ASM.match(line)):
+          # Enter assembly block
+          inner_block.inline_asm = _INSIDE_ASM
+        else:
+          # Not entering assembly block.  If previous line was _END_ASM,
+          # we will now shift to _NO_ASM state.
+          inner_block.inline_asm = _NO_ASM
+      elif (inner_block.inline_asm == _INSIDE_ASM and
+            inner_block.open_parentheses == 0):
+        # Exit assembly block
+        inner_block.inline_asm = _END_ASM
+
+    # Consume namespace declaration at the beginning of the line.  Do
+    # this in a loop so that we catch same line declarations like this:
+    #   namespace proto2 { namespace bridge { class MessageSet; } }
+    while True:
+      # Match start of namespace.  The "\b\s*" below catches namespace
+      # declarations even if it weren't followed by a whitespace, this
+      # is so that we don't confuse our namespace checker.  The
+      # missing spaces will be flagged by CheckSpacing.
+      namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line)
+      if not namespace_decl_match:
+        break
+
+      new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum)
+      self.stack.append(new_namespace)
+
+      line = namespace_decl_match.group(2)
+      if line.find('{') != -1:
+        new_namespace.seen_open_brace = True
+        line = line[line.find('{') + 1:]
+
+    # Look for a class declaration in whatever is left of the line
+    # after parsing namespaces.  The regexp accounts for decorated classes
+    # such as in:
+    #   class LOCKABLE API Object {
+    #   };
+    #
+    # Templates with class arguments may confuse the parser, for example:
+    #   template <class T
+    #             class Comparator = less<T>,
+    #             class Vector = vector<T> >
+    #   class HeapQueue {
+    #
+    # Because this parser has no nesting state about templates, by the
+    # time it saw "class Comparator", it may think that it's a new class.
+    # Nested templates have a similar problem:
+    #   template <
+    #       typename ExportedType,
+    #       typename TupleType,
+    #       template <typename, typename> class ImplTemplate>
+    #
+    # To avoid these cases, we ignore classes that are followed by '=' or '>'
+    class_decl_match = Match(
+        r'\s*(template\s*<[\w\s<>,:]*>\s*)?'
+        '(class|struct)\s+([A-Z_]+\s+)*(\w+(?:::\w+)*)'
+        '(([^=>]|<[^<>]*>)*)$', line)
+    if (class_decl_match and
+        (not self.stack or self.stack[-1].open_parentheses == 0)):
+      self.stack.append(_ClassInfo(
+          class_decl_match.group(4), class_decl_match.group(2),
+          clean_lines, linenum))
+      line = class_decl_match.group(5)
+
+    # If we have not yet seen the opening brace for the innermost block,
+    # run checks here.
+    if not self.SeenOpenBrace():
+      self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
+
+    # Update access control if we are inside a class/struct
+    if self.stack and isinstance(self.stack[-1], _ClassInfo):
+      access_match = Match(r'\s*(public|private|protected)\s*:', line)
+      if access_match:
+        self.stack[-1].access = access_match.group(1)
+
+    # Consume braces or semicolons from what's left of the line
+    while True:
+      # Match first brace, semicolon, or closed parenthesis.
+      matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line)
+      if not matched:
+        break
+
+      token = matched.group(1)
+      if token == '{':
+        # If namespace or class hasn't seen a opening brace yet, mark
+        # namespace/class head as complete.  Push a new block onto the
+        # stack otherwise.
+        if not self.SeenOpenBrace():
+          self.stack[-1].seen_open_brace = True
+        else:
+          self.stack.append(_BlockInfo(True))
+          if _MATCH_ASM.match(line):
+            self.stack[-1].inline_asm = _BLOCK_ASM
+      elif token == ';' or token == ')':
+        # If we haven't seen an opening brace yet, but we already saw
+        # a semicolon, this is probably a forward declaration.  Pop
+        # the stack for these.
+        #
+        # Similarly, if we haven't seen an opening brace yet, but we
+        # already saw a closing parenthesis, then these are probably
+        # function arguments with extra "class" or "struct" keywords.
+        # Also pop these stack for these.
+        if not self.SeenOpenBrace():
+          self.stack.pop()
+      else:  # token == '}'
+        # Perform end of block checks and pop the stack.
+        if self.stack:
+          self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
+          self.stack.pop()
+      line = matched.group(2)
+
+  def InnermostClass(self):
+    """Get class info on the top of the stack.
+
+    Returns:
+      A _ClassInfo object if we are inside a class, or None otherwise.
+    """
+    for i in range(len(self.stack), 0, -1):
+      classinfo = self.stack[i - 1]
+      if isinstance(classinfo, _ClassInfo):
+        return classinfo
+    return None
+
+  def CheckClassFinished(self, filename, error):
+    """Checks that all classes have been completely parsed.
+
+    Call this when all lines in a file have been processed.
+    Args:
+      filename: The name of the current file.
+      error: The function to call with any errors found.
+    """
+    # Note: This test can result in false positives if #ifdef constructs
+    # get in the way of brace matching. See the testBuildClass test in
+    # cpplint_unittest.py for an example of this.
+    for obj in self.stack:
+      if isinstance(obj, _ClassInfo):
+        error(filename, obj.starting_linenum, 'build/class', 5,
+              'Failed to find complete declaration of class %s' %
+              obj.name)
+
+
+def CheckForNonStandardConstructs(filename, clean_lines, linenum,
+                                  nesting_state, error):
+  """Logs an error if we see certain non-ANSI constructs ignored by gcc-2.
+
+  Complain about several constructs which gcc-2 accepts, but which are
+  not standard C++.  Warning about these in lint is one way to ease the
+  transition to new compilers.
+  - put storage class first (e.g. "static const" instead of "const static").
+  - "%lld" instead of %qd" in printf-type functions.
+  - "%1$d" is non-standard in printf-type functions.
+  - "\%" is an undefined character escape sequence.
+  - text after #endif is not allowed.
+  - invalid inner-style forward declaration.
+  - >? and <? operators, and their >?= and <?= cousins.
+
+  Additionally, check for constructor/destructor style violations and reference
+  members, as it is very convenient to do so while checking for
+  gcc-2 compliance.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: A callable to which errors are reported, which takes 4 arguments:
+           filename, line number, error level, and message
+  """
+
+  # Remove comments from the line, but leave in strings for now.
+  line = clean_lines.lines[linenum]
+
+  if Search(r'printf\s*\(.*".*%[-+ ]?\d*q', line):
+    error(filename, linenum, 'runtime/printf_format', 3,
+          '%q in format strings is deprecated.  Use %ll instead.')
+
+  if Search(r'printf\s*\(.*".*%\d+\$', line):
+    error(filename, linenum, 'runtime/printf_format', 2,
+          '%N$ formats are unconventional.  Try rewriting to avoid them.')
+
+  # Remove escaped backslashes before looking for undefined escapes.
+  line = line.replace('\\\\', '')
+
+  if Search(r'("|\').*\\(%|\[|\(|{)', line):
+    error(filename, linenum, 'build/printf_format', 3,
+          '%, [, (, and { are undefined character escapes.  Unescape them.')
+
+  # For the rest, work with both comments and strings removed.
+  line = clean_lines.elided[linenum]
+
+  if Search(r'\b(const|volatile|void|char|short|int|long'
+            r'|float|double|signed|unsigned'
+            r'|schar|u?int8|u?int16|u?int32|u?int64)'
+            r'\s+(register|static|extern|typedef)\b',
+            line):
+    error(filename, linenum, 'build/storage_class', 5,
+          'Storage class (static, extern, typedef, etc) should be first.')
+
+  if Match(r'\s*#\s*endif\s*[^/\s]+', line):
+    error(filename, linenum, 'build/endif_comment', 5,
+          'Uncommented text after #endif is non-standard.  Use a comment.')
+
+  if Match(r'\s*class\s+(\w+\s*::\s*)+\w+\s*;', line):
+    error(filename, linenum, 'build/forward_decl', 5,
+          'Inner-style forward declarations are invalid.  Remove this line.')
+
+  if Search(r'(\w+|[+-]?\d+(\.\d*)?)\s*(<|>)\?=?\s*(\w+|[+-]?\d+)(\.\d*)?',
+            line):
+    error(filename, linenum, 'build/deprecated', 3,
+          '>? and <? (max and min) operators are non-standard and deprecated.')
+
+  if Search(r'^\s*const\s*string\s*&\s*\w+\s*;', line):
+    # TODO(unknown): Could it be expanded safely to arbitrary references,
+    # without triggering too many false positives? The first
+    # attempt triggered 5 warnings for mostly benign code in the regtest, hence
+    # the restriction.
+    # Here's the original regexp, for the reference:
+    # type_name = r'\w+((\s*::\s*\w+)|(\s*<\s*\w+?\s*>))?'
+    # r'\s*const\s*' + type_name + '\s*&\s*\w+\s*;'
+    error(filename, linenum, 'runtime/member_string_references', 2,
+          'const string& members are dangerous. It is much better to use '
+          'alternatives, such as pointers or simple constants.')
+
+  # Everything else in this function operates on class declarations.
+  # Return early if the top of the nesting stack is not a class, or if
+  # the class head is not completed yet.
+  classinfo = nesting_state.InnermostClass()
+  if not classinfo or not classinfo.seen_open_brace:
+    return
+
+  # The class may have been declared with namespace or classname qualifiers.
+  # The constructor and destructor will not have those qualifiers.
+  base_classname = classinfo.name.split('::')[-1]
+
+  # Look for single-argument constructors that aren't marked explicit.
+  # Technically a valid construct, but against style.
+  args = Match(r'\s+(?:inline\s+)?%s\s*\(([^,()]+)\)'
+               % re.escape(base_classname),
+               line)
+  if (args and
+      args.group(1) != 'void' and
+      not Match(r'(const\s+)?%s\s*(?:<\w+>\s*)?&' % re.escape(base_classname),
+                args.group(1).strip())):
+    error(filename, linenum, 'runtime/explicit', 5,
+          'Single-argument constructors should be marked explicit.')
+
+
+def CheckSpacingForFunctionCall(filename, line, linenum, error):
+  """Checks for the correctness of various spacing around function calls.
+
+  Args:
+    filename: The name of the current file.
+    line: The text of the line to check.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  # Since function calls often occur inside if/for/while/switch
+  # expressions - which have their own, more liberal conventions - we
+  # first see if we should be looking inside such an expression for a
+  # function call, to which we can apply more strict standards.
+  fncall = line    # if there's no control flow construct, look at whole line
+  for pattern in (r'\bif\s*\((.*)\)\s*{',
+                  r'\bfor\s*\((.*)\)\s*{',
+                  r'\bwhile\s*\((.*)\)\s*[{;]',
+                  r'\bswitch\s*\((.*)\)\s*{'):
+    match = Search(pattern, line)
+    if match:
+      fncall = match.group(1)    # look inside the parens for function calls
+      break
+
+  # Except in if/for/while/switch, there should never be space
+  # immediately inside parens (eg "f( 3, 4 )").  We make an exception
+  # for nested parens ( (a+b) + c ).  Likewise, there should never be
+  # a space before a ( when it's a function argument.  I assume it's a
+  # function argument when the char before the whitespace is legal in
+  # a function name (alnum + _) and we're not starting a macro. Also ignore
+  # pointers and references to arrays and functions coz they're too tricky:
+  # we use a very simple way to recognize these:
+  # " (something)(maybe-something)" or
+  # " (something)(maybe-something," or
+  # " (something)[something]"
+  # Note that we assume the contents of [] to be short enough that
+  # they'll never need to wrap.
+  if (  # Ignore control structures.
+      not Search(r'\b(if|for|while|switch|return|delete)\b', fncall) and
+      # Ignore pointers/references to functions.
+      not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and
+      # Ignore pointers/references to arrays.
+      not Search(r' \([^)]+\)\[[^\]]+\]', fncall)):
+    if Search(r'\w\s*\(\s(?!\s*\\$)', fncall):      # a ( used for a fn call
+      error(filename, linenum, 'whitespace/parens', 4,
+            'Extra space after ( in function call')
+    elif Search(r'\(\s+(?!(\s*\\)|\()', fncall):
+      error(filename, linenum, 'whitespace/parens', 2,
+            'Extra space after (')
+    if (Search(r'\w\s+\(', fncall) and
+        not Search(r'#\s*define|typedef', fncall) and
+        not Search(r'\w\s+\((\w+::)?\*\w+\)\(', fncall)):
+      error(filename, linenum, 'whitespace/parens', 4,
+            'Extra space before ( in function call')
+    # If the ) is followed only by a newline or a { + newline, assume it's
+    # part of a control statement (if/while/etc), and don't complain
+    if Search(r'[^)]\s+\)\s*[^{\s]', fncall):
+      # If the closing parenthesis is preceded by only whitespaces,
+      # try to give a more descriptive error message.
+      if Search(r'^\s+\)', fncall):
+        error(filename, linenum, 'whitespace/parens', 2,
+              'Closing ) should be moved to the previous line')
+      else:
+        error(filename, linenum, 'whitespace/parens', 2,
+              'Extra space before )')
+
+
+def IsBlankLine(line):
+  """Returns true if the given line is blank.
+
+  We consider a line to be blank if the line is empty or consists of
+  only white spaces.
+
+  Args:
+    line: A line of a string.
+
+  Returns:
+    True, if the given line is blank.
+  """
+  return not line or line.isspace()
+
+
+def CheckForFunctionLengths(filename, clean_lines, linenum,
+                            function_state, error):
+  """Reports for long function bodies.
+
+  For an overview why this is done, see:
+  http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions
+
+  Uses a simplistic algorithm assuming other style guidelines
+  (especially spacing) are followed.
+  Only checks unindented functions, so class members are unchecked.
+  Trivial bodies are unchecked, so constructors with huge initializer lists
+  may be missed.
+  Blank/comment lines are not counted so as to avoid encouraging the removal
+  of vertical space and comments just to get through a lint check.
+  NOLINT *on the last line of a function* disables this check.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    function_state: Current function name and lines in body so far.
+    error: The function to call with any errors found.
+  """
+  lines = clean_lines.lines
+  line = lines[linenum]
+  raw = clean_lines.raw_lines
+  raw_line = raw[linenum]
+  joined_line = ''
+
+  starting_func = False
+  regexp = r'(\w(\w|::|\*|\&|\s)*)\('  # decls * & space::name( ...
+  match_result = Match(regexp, line)
+  if match_result:
+    # If the name is all caps and underscores, figure it's a macro and
+    # ignore it, unless it's TEST or TEST_F.
+    function_name = match_result.group(1).split()[-1]
+    if function_name == 'TEST' or function_name == 'TEST_F' or (
+        not Match(r'[A-Z_]+$', function_name)):
+      starting_func = True
+
+  if starting_func:
+    body_found = False
+    for start_linenum in xrange(linenum, clean_lines.NumLines()):
+      start_line = lines[start_linenum]
+      joined_line += ' ' + start_line.lstrip()
+      if Search(r'(;|})', start_line):  # Declarations and trivial functions
+        body_found = True
+        break                              # ... ignore
+      elif Search(r'{', start_line):
+        body_found = True
+        function = Search(r'((\w|:)*)\(', line).group(1)
+        if Match(r'TEST', function):    # Handle TEST... macros
+          parameter_regexp = Search(r'(\(.*\))', joined_line)
+          if parameter_regexp:             # Ignore bad syntax
+            function += parameter_regexp.group(1)
+        else:
+          function += '()'
+        function_state.Begin(function)
+        break
+    if not body_found:
+      # No body for the function (or evidence of a non-function) was found.
+      error(filename, linenum, 'readability/fn_size', 5,
+            'Lint failed to find start of function body.')
+  elif Match(r'^\}\s*$', line):  # function end
+    function_state.Check(error, filename, linenum)
+    function_state.End()
+  elif not Match(r'^\s*$', line):
+    function_state.Count()  # Count non-blank/non-comment lines.
+
+
+_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO(\(.+?\))?:?(\s|$)?')
+
+
+def CheckComment(comment, filename, linenum, error):
+  """Checks for common mistakes in TODO comments.
+
+  Args:
+    comment: The text of the comment from the line in question.
+    filename: The name of the current file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  match = _RE_PATTERN_TODO.match(comment)
+  if match:
+    # One whitespace is correct; zero whitespace is handled elsewhere.
+    leading_whitespace = match.group(1)
+    if len(leading_whitespace) > 1:
+      error(filename, linenum, 'whitespace/todo', 2,
+            'Too many spaces before TODO')
+
+    username = match.group(2)
+    if not username:
+      error(filename, linenum, 'readability/todo', 2,
+            'Missing username in TODO; it should look like '
+            '"// TODO(my_username): Stuff."')
+
+    middle_whitespace = match.group(3)
+    # Comparisons made explicit for correctness -- pylint: disable-msg=C6403
+    if middle_whitespace != ' ' and middle_whitespace != '':
+      error(filename, linenum, 'whitespace/todo', 2,
+            'TODO(my_username) should be followed by a space')
+
+def CheckAccess(filename, clean_lines, linenum, nesting_state, error):
+  """Checks for improper use of DISALLOW* macros.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]  # get rid of comments and strings
+
+  matched = Match((r'\s*(DISALLOW_COPY_AND_ASSIGN|'
+                   r'DISALLOW_EVIL_CONSTRUCTORS|'
+                   r'DISALLOW_IMPLICIT_CONSTRUCTORS)'), line)
+  if not matched:
+    return
+  if nesting_state.stack and isinstance(nesting_state.stack[-1], _ClassInfo):
+    if nesting_state.stack[-1].access != 'private':
+      error(filename, linenum, 'readability/constructors', 3,
+            '%s must be in the private: section' % matched.group(1))
+
+  else:
+    # Found DISALLOW* macro outside a class declaration, or perhaps it
+    # was used inside a function when it should have been part of the
+    # class declaration.  We could issue a warning here, but it
+    # probably resulted in a compiler error already.
+    pass
+
+
+def FindNextMatchingAngleBracket(clean_lines, linenum, init_suffix):
+  """Find the corresponding > to close a template.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: Current line number.
+    init_suffix: Remainder of the current line after the initial <.
+
+  Returns:
+    True if a matching bracket exists.
+  """
+  line = init_suffix
+  nesting_stack = ['<']
+  while True:
+    # Find the next operator that can tell us whether < is used as an
+    # opening bracket or as a less-than operator.  We only want to
+    # warn on the latter case.
+    #
+    # We could also check all other operators and terminate the search
+    # early, e.g. if we got something like this "a<b+c", the "<" is
+    # most likely a less-than operator, but then we will get false
+    # positives for default arguments (e.g. http://go/prccd) and
+    # other template expressions (e.g. http://go/oxcjq).
+    match = Search(r'^[^<>(),;\[\]]*([<>(),;\[\]])(.*)$', line)
+    if match:
+      # Found an operator, update nesting stack
+      operator = match.group(1)
+      line = match.group(2)
+
+      if nesting_stack[-1] == '<':
+        # Expecting closing angle bracket
+        if operator in ('<', '(', '['):
+          nesting_stack.append(operator)
+        elif operator == '>':
+          nesting_stack.pop()
+          if not nesting_stack:
+            # Found matching angle bracket
+            return True
+        elif operator == ',':
+          # Got a comma after a bracket, this is most likely a template
+          # argument.  We have not seen a closing angle bracket yet, but
+          # it's probably a few lines later if we look for it, so just
+          # return early here.
+          return True
+        else:
+          # Got some other operator.
+          return False
+
+      else:
+        # Expecting closing parenthesis or closing bracket
+        if operator in ('<', '(', '['):
+          nesting_stack.append(operator)
+        elif operator in (')', ']'):
+          # We don't bother checking for matching () or [].  If we got
+          # something like (] or [), it would have been a syntax error.
+          nesting_stack.pop()
+
+    else:
+      # Scan the next line
+      linenum += 1
+      if linenum >= len(clean_lines.elided):
+        break
+      line = clean_lines.elided[linenum]
+
+  # Exhausted all remaining lines and still no matching angle bracket.
+  # Most likely the input was incomplete, otherwise we should have
+  # seen a semicolon and returned early.
+  return True
+
+
+def FindPreviousMatchingAngleBracket(clean_lines, linenum, init_prefix):
+  """Find the corresponding < that started a template.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: Current line number.
+    init_prefix: Part of the current line before the initial >.
+
+  Returns:
+    True if a matching bracket exists.
+  """
+  line = init_prefix
+  nesting_stack = ['>']
+  while True:
+    # Find the previous operator
+    match = Search(r'^(.*)([<>(),;\[\]])[^<>(),;\[\]]*$', line)
+    if match:
+      # Found an operator, update nesting stack
+      operator = match.group(2)
+      line = match.group(1)
+
+      if nesting_stack[-1] == '>':
+        # Expecting opening angle bracket
+        if operator in ('>', ')', ']'):
+          nesting_stack.append(operator)
+        elif operator == '<':
+          nesting_stack.pop()
+          if not nesting_stack:
+            # Found matching angle bracket
+            return True
+        elif operator == ',':
+          # Got a comma before a bracket, this is most likely a
+          # template argument.  The opening angle bracket is probably
+          # there if we look for it, so just return early here.
+          return True
+        else:
+          # Got some other operator.
+          return False
+
+      else:
+        # Expecting opening parenthesis or opening bracket
+        if operator in ('>', ')', ']'):
+          nesting_stack.append(operator)
+        elif operator in ('(', '['):
+          nesting_stack.pop()
+
+    else:
+      # Scan the previous line
+      linenum -= 1
+      if linenum < 0:
+        break
+      line = clean_lines.elided[linenum]
+
+  # Exhausted all earlier lines and still no matching angle bracket.
+  return False
+
+
+def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):
+  """Checks for the correctness of various spacing issues in the code.
+
+  Things we check for: spaces around operators, spaces after
+  if/for/while/switch, no spaces around parens in function calls, two
+  spaces between code and comment, don't start a block with a blank
+  line, don't end a function with a blank line, don't add a blank line
+  after public/protected/private, don't have too many blank lines in a row.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+
+  raw = clean_lines.raw_lines
+  line = raw[linenum]
+
+  # Before nixing comments, check if the line is blank for no good
+  # reason.  This includes the first line after a block is opened, and
+  # blank lines at the end of a function (ie, right before a line like '}'
+  #
+  # Skip all the blank line checks if we are immediately inside a
+  # namespace body.  In other words, don't issue blank line warnings
+  # for this block:
+  #   namespace {
+  #
+  #   }
+  #
+  # A warning about missing end of namespace comments will be issued instead.
+  if IsBlankLine(line) and not nesting_state.InNamespaceBody():
+    elided = clean_lines.elided
+    prev_line = elided[linenum - 1]
+    prevbrace = prev_line.rfind('{')
+    # TODO(unknown): Don't complain if line before blank line, and line after,
+    #                both start with alnums and are indented the same amount.
+    #                This ignores whitespace at the start of a namespace block
+    #                because those are not usually indented.
+    if prevbrace != -1 and prev_line[prevbrace:].find('}') == -1:
+      # OK, we have a blank line at the start of a code block.  Before we
+      # complain, we check if it is an exception to the rule: The previous
+      # non-empty line has the parameters of a function header that are indented
+      # 4 spaces (because they did not fit in a 80 column line when placed on
+      # the same line as the function name).  We also check for the case where
+      # the previous line is indented 6 spaces, which may happen when the
+      # initializers of a constructor do not fit into a 80 column line.
+      exception = False
+      if Match(r' {6}\w', prev_line):  # Initializer list?
+        # We are looking for the opening column of initializer list, which
+        # should be indented 4 spaces to cause 6 space indentation afterwards.
+        search_position = linenum-2
+        while (search_position >= 0
+               and Match(r' {6}\w', elided[search_position])):
+          search_position -= 1
+        exception = (search_position >= 0
+                     and elided[search_position][:5] == '    :')
+      else:
+        # Search for the function arguments or an initializer list.  We use a
+        # simple heuristic here: If the line is indented 4 spaces; and we have a
+        # closing paren, without the opening paren, followed by an opening brace
+        # or colon (for initializer lists) we assume that it is the last line of
+        # a function header.  If we have a colon indented 4 spaces, it is an
+        # initializer list.
+        exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)',
+                           prev_line)
+                     or Match(r' {4}:', prev_line))
+
+      if not exception:
+        error(filename, linenum, 'whitespace/blank_line', 2,
+              'Blank line at the start of a code block.  Is this needed?')
+    # Ignore blank lines at the end of a block in a long if-else
+    # chain, like this:
+    #   if (condition1) {
+    #     // Something followed by a blank line
+    #
+    #   } else if (condition2) {
+    #     // Something else
+    #   }
+    if linenum + 1 < clean_lines.NumLines():
+      next_line = raw[linenum + 1]
+      if (next_line
+          and Match(r'\s*}', next_line)
+          and next_line.find('} else ') == -1):
+        error(filename, linenum, 'whitespace/blank_line', 3,
+              'Blank line at the end of a code block.  Is this needed?')
+
+    matched = Match(r'\s*(public|protected|private):', prev_line)
+    if matched:
+      error(filename, linenum, 'whitespace/blank_line', 3,
+            'Do not leave a blank line after "%s:"' % matched.group(1))
+
+  # Next, we complain if there's a comment too near the text
+  commentpos = line.find('//')
+  if commentpos != -1:
+    # Check if the // may be in quotes.  If so, ignore it
+    # Comparisons made explicit for clarity -- pylint: disable-msg=C6403
+    if (line.count('"', 0, commentpos) -
+        line.count('\\"', 0, commentpos)) % 2 == 0:   # not in quotes
+      # Allow one space for new scopes, two spaces otherwise:
+      if (not Match(r'^\s*{ //', line) and
+          ((commentpos >= 1 and
+            line[commentpos-1] not in string.whitespace) or
+           (commentpos >= 2 and
+            line[commentpos-2] not in string.whitespace))):
+        error(filename, linenum, 'whitespace/comments', 2,
+              'At least two spaces is best between code and comments')
+      # There should always be a space between the // and the comment
+      commentend = commentpos + 2
+      if commentend < len(line) and not line[commentend] == ' ':
+        # but some lines are exceptions -- e.g. if they're big
+        # comment delimiters like:
+        # //----------------------------------------------------------
+        # or are an empty C++ style Doxygen comment, like:
+        # ///
+        # or they begin with multiple slashes followed by a space:
+        # //////// Header comment
+        match = (Search(r'[=/-]{4,}\s*$', line[commentend:]) or
+                 Search(r'^/$', line[commentend:]) or
+                 Search(r'^/+ ', line[commentend:]))
+        if not match:
+          error(filename, linenum, 'whitespace/comments', 4,
+                'Should have a space between // and comment')
+      CheckComment(line[commentpos:], filename, linenum, error)
+
+  line = clean_lines.elided[linenum]  # get rid of comments and strings
+
+  # Don't try to do spacing checks for operator methods
+  line = re.sub(r'operator(==|!=|<|<<|<=|>=|>>|>)\(', 'operator\(', line)
+
+  # We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )".
+  # Otherwise not.  Note we only check for non-spaces on *both* sides;
+  # sometimes people put non-spaces on one side when aligning ='s among
+  # many lines (not that this is behavior that I approve of...)
+  if Search(r'[\w.]=[\w.]', line) and not Search(r'\b(if|while) ', line):
+    error(filename, linenum, 'whitespace/operators', 4,
+          'Missing spaces around =')
+
+  # It's ok not to have spaces around binary operators like + - * /, but if
+  # there's too little whitespace, we get concerned.  It's hard to tell,
+  # though, so we punt on this one for now.  TODO.
+
+  # You should always have whitespace around binary operators.
+  #
+  # Check <= and >= first to avoid false positives with < and >, then
+  # check non-include lines for spacing around < and >.
+  match = Search(r'[^<>=!\s](==|!=|<=|>=)[^<>=!\s]', line)
+  if match:
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around %s' % match.group(1))
+  # We allow no-spaces around << when used like this: 10<<20, but
+  # not otherwise (particularly, not when used as streams)
+  match = Search(r'(\S)(?:L|UL|ULL|l|ul|ull)?<<(\S)', line)
+  if match and not (match.group(1).isdigit() and match.group(2).isdigit()):
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around <<')
+  elif not Match(r'#.*include', line):
+    # Avoid false positives on ->
+    reduced_line = line.replace('->', '')
+
+    # Look for < that is not surrounded by spaces.  This is only
+    # triggered if both sides are missing spaces, even though
+    # technically should should flag if at least one side is missing a
+    # space.  This is done to avoid some false positives with shifts.
+    match = Search(r'[^\s<]<([^\s=<].*)', reduced_line)
+    if (match and
+        not FindNextMatchingAngleBracket(clean_lines, linenum, match.group(1))):
+      error(filename, linenum, 'whitespace/operators', 3,
+            'Missing spaces around <')
+
+    # Look for > that is not surrounded by spaces.  Similar to the
+    # above, we only trigger if both sides are missing spaces to avoid
+    # false positives with shifts.
+    match = Search(r'^(.*[^\s>])>[^\s=>]', reduced_line)
+    if (match and
+        not FindPreviousMatchingAngleBracket(clean_lines, linenum,
+                                             match.group(1))):
+      error(filename, linenum, 'whitespace/operators', 3,
+            'Missing spaces around >')
+
+  # We allow no-spaces around >> for almost anything.  This is because
+  # C++11 allows ">>" to close nested templates, which accounts for
+  # most cases when ">>" is not followed by a space.
+  #
+  # We still warn on ">>" followed by alpha character, because that is
+  # likely due to ">>" being used for right shifts, e.g.:
+  #   value >> alpha
+  #
+  # When ">>" is used to close templates, the alphanumeric letter that
+  # follows would be part of an identifier, and there should still be
+  # a space separating the template type and the identifier.
+  #   type<type<type>> alpha
+  match = Search(r'>>[a-zA-Z_]', line)
+  if match:
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around >>')
+
+  # There shouldn't be space around unary operators
+  match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line)
+  if match:
+    error(filename, linenum, 'whitespace/operators', 4,
+          'Extra space for operator %s' % match.group(1))
+
+  # A pet peeve of mine: no spaces after an if, while, switch, or for
+  match = Search(r' (if\(|for\(|while\(|switch\()', line)
+  if match:
+    error(filename, linenum, 'whitespace/parens', 5,
+          'Missing space before ( in %s' % match.group(1))
+
+  # For if/for/while/switch, the left and right parens should be
+  # consistent about how many spaces are inside the parens, and
+  # there should either be zero or one spaces inside the parens.
+  # We don't want: "if ( foo)" or "if ( foo   )".
+  # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed.
+  match = Search(r'\b(if|for|while|switch)\s*'
+                 r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$',
+                 line)
+  if match:
+    if len(match.group(2)) != len(match.group(4)):
+      if not (match.group(3) == ';' and
+              len(match.group(2)) == 1 + len(match.group(4)) or
+              not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)):
+        error(filename, linenum, 'whitespace/parens', 5,
+              'Mismatching spaces inside () in %s' % match.group(1))
+    if not len(match.group(2)) in [0, 1]:
+      error(filename, linenum, 'whitespace/parens', 5,
+            'Should have zero or one spaces inside ( and ) in %s' %
+            match.group(1))
+
+  # You should always have a space after a comma (either as fn arg or operator)
+  if Search(r',[^\s]', line):
+    error(filename, linenum, 'whitespace/comma', 3,
+          'Missing space after ,')
+
+  # You should always have a space after a semicolon
+  # except for few corner cases
+  # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more
+  # space after ;
+  if Search(r';[^\s};\\)/]', line):
+    error(filename, linenum, 'whitespace/semicolon', 3,
+          'Missing space after ;')
+
+  # Next we will look for issues with function calls.
+  CheckSpacingForFunctionCall(filename, line, linenum, error)
+
+  # Except after an opening paren, or after another opening brace (in case of
+  # an initializer list, for instance), you should have spaces before your
+  # braces. And since you should never have braces at the beginning of a line,
+  # this is an easy test.
+  if Search(r'[^ ({]{', line):
+    error(filename, linenum, 'whitespace/braces', 5,
+          'Missing space before {')
+
+  # Make sure '} else {' has spaces.
+  if Search(r'}else', line):
+    error(filename, linenum, 'whitespace/braces', 5,
+          'Missing space before else')
+
+  # You shouldn't have spaces before your brackets, except maybe after
+  # 'delete []' or 'new char * []'.
+  if Search(r'\w\s+\[', line) and not Search(r'delete\s+\[', line):
+    error(filename, linenum, 'whitespace/braces', 5,
+          'Extra space before [')
+
+  # You shouldn't have a space before a semicolon at the end of the line.
+  # There's a special case for "for" since the style guide allows space before
+  # the semicolon there.
+  if Search(r':\s*;\s*$', line):
+    error(filename, linenum, 'whitespace/semicolon', 5,
+          'Semicolon defining empty statement. Use {} instead.')
+  elif Search(r'^\s*;\s*$', line):
+    error(filename, linenum, 'whitespace/semicolon', 5,
+          'Line contains only semicolon. If this should be an empty statement, '
+          'use {} instead.')
+  elif (Search(r'\s+;\s*$', line) and
+        not Search(r'\bfor\b', line)):
+    error(filename, linenum, 'whitespace/semicolon', 5,
+          'Extra space before last semicolon. If this should be an empty '
+          'statement, use {} instead.')
+
+  # In range-based for, we wanted spaces before and after the colon, but
+  # not around "::" tokens that might appear.
+  if (Search('for *\(.*[^:]:[^: ]', line) or
+      Search('for *\(.*[^: ]:[^:]', line)):
+    error(filename, linenum, 'whitespace/forcolon', 2,
+          'Missing space around colon in range-based for loop')
+
+
+def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
+  """Checks for additional blank line issues related to sections.
+
+  Currently the only thing checked here is blank line before protected/private.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    class_info: A _ClassInfo objects.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  # Skip checks if the class is small, where small means 25 lines or less.
+  # 25 lines seems like a good cutoff since that's the usual height of
+  # terminals, and any class that can't fit in one screen can't really
+  # be considered "small".
+  #
+  # Also skip checks if we are on the first line.  This accounts for
+  # classes that look like
+  #   class Foo { public: ... };
+  #
+  # If we didn't find the end of the class, last_line would be zero,
+  # and the check will be skipped by the first condition.
+  if (class_info.last_line - class_info.starting_linenum <= 24 or
+      linenum <= class_info.starting_linenum):
+    return
+
+  matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum])
+  if matched:
+    # Issue warning if the line before public/protected/private was
+    # not a blank line, but don't do this if the previous line contains
+    # "class" or "struct".  This can happen two ways:
+    #  - We are at the beginning of the class.
+    #  - We are forward-declaring an inner class that is semantically
+    #    private, but needed to be public for implementation reasons.
+    # Also ignores cases where the previous line ends with a backslash as can be
+    # common when defining classes in C macros.
+    prev_line = clean_lines.lines[linenum - 1]
+    if (not IsBlankLine(prev_line) and
+        not Search(r'\b(class|struct)\b', prev_line) and
+        not Search(r'\\$', prev_line)):
+      # Try a bit harder to find the beginning of the class.  This is to
+      # account for multi-line base-specifier lists, e.g.:
+      #   class Derived
+      #       : public Base {
+      end_class_head = class_info.starting_linenum
+      for i in range(class_info.starting_linenum, linenum):
+        if Search(r'\{\s*$', clean_lines.lines[i]):
+          end_class_head = i
+          break
+      if end_class_head < linenum - 1:
+        error(filename, linenum, 'whitespace/blank_line', 3,
+              '"%s:" should be preceded by a blank line' % matched.group(1))
+
+
+def GetPreviousNonBlankLine(clean_lines, linenum):
+  """Return the most recent non-blank line and its line number.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file contents.
+    linenum: The number of the line to check.
+
+  Returns:
+    A tuple with two elements.  The first element is the contents of the last
+    non-blank line before the current line, or the empty string if this is the
+    first non-blank line.  The second is the line number of that line, or -1
+    if this is the first non-blank line.
+  """
+
+  prevlinenum = linenum - 1
+  while prevlinenum >= 0:
+    prevline = clean_lines.elided[prevlinenum]
+    if not IsBlankLine(prevline):     # if not a blank line...
+      return (prevline, prevlinenum)
+    prevlinenum -= 1
+  return ('', -1)
+
+
+def CheckBraces(filename, clean_lines, linenum, error):
+  """Looks for misplaced braces (e.g. at the end of line).
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  line = clean_lines.elided[linenum]        # get rid of comments and strings
+
+  if Match(r'\s*{\s*$', line):
+    # We allow an open brace to start a line in the case where someone
+    # is using braces in a block to explicitly create a new scope,
+    # which is commonly used to control the lifetime of
+    # stack-allocated variables.  We don't detect this perfectly: we
+    # just don't complain if the last non-whitespace character on the
+    # previous non-blank line is ';', ':', '{', or '}', or if the previous
+    # line starts a preprocessor block.
+    prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
+    if (not Search(r'[;:}{]\s*$', prevline) and
+        not Match(r'\s*#', prevline)):
+      error(filename, linenum, 'whitespace/braces', 4,
+            '{ should almost always be at the end of the previous line')
+
+  # An else clause should be on the same line as the preceding closing brace.
+  if Match(r'\s*else\s*', line):
+    prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
+    if Match(r'\s*}\s*$', prevline):
+      error(filename, linenum, 'whitespace/newline', 4,
+            'An else should appear on the same line as the preceding }')
+
+  # If braces come on one side of an else, they should be on both.
+  # However, we have to worry about "else if" that spans multiple lines!
+  if Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line):
+    if Search(r'}\s*else if([^{]*)$', line):       # could be multi-line if
+      # find the ( after the if
+      pos = line.find('else if')
+      pos = line.find('(', pos)
+      if pos > 0:
+        (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)
+        if endline[endpos:].find('{') == -1:    # must be brace after if
+          error(filename, linenum, 'readability/braces', 5,
+                'If an else has a brace on one side, it should have it on both')
+    else:            # common case: else not followed by a multi-line if
+      error(filename, linenum, 'readability/braces', 5,
+            'If an else has a brace on one side, it should have it on both')
+
+  # Likewise, an else should never have the else clause on the same line
+  if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line):
+    error(filename, linenum, 'whitespace/newline', 4,
+          'Else clause should never be on same line as else (use 2 lines)')
+
+  # In the same way, a do/while should never be on one line
+  if Match(r'\s*do [^\s{]', line):
+    error(filename, linenum, 'whitespace/newline', 4,
+          'do/while clauses should not be on a single line')
+
+  # Braces shouldn't be followed by a ; unless they're defining a struct
+  # or initializing an array.
+  # We can't tell in general, but we can for some common cases.
+  prevlinenum = linenum
+  while True:
+    (prevline, prevlinenum) = GetPreviousNonBlankLine(clean_lines, prevlinenum)
+    if Match(r'\s+{.*}\s*;', line) and not prevline.count(';'):
+      line = prevline + line
+    else:
+      break
+  if (Search(r'{.*}\s*;', line) and
+      line.count('{') == line.count('}') and
+      not Search(r'struct|class|enum|\s*=\s*{', line)):
+    error(filename, linenum, 'readability/braces', 4,
+          "You don't need a ; after a }")
+
+
+def CheckEmptyLoopBody(filename, clean_lines, linenum, error):
+  """Loop for empty loop body with only a single semicolon.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  # Search for loop keywords at the beginning of the line.  Because only
+  # whitespaces are allowed before the keywords, this will also ignore most
+  # do-while-loops, since those lines should start with closing brace.
+  line = clean_lines.elided[linenum]
+  if Match(r'\s*(for|while)\s*\(', line):
+    # Find the end of the conditional expression
+    (end_line, end_linenum, end_pos) = CloseExpression(
+        clean_lines, linenum, line.find('('))
+
+    # Output warning if what follows the condition expression is a semicolon.
+    # No warning for all other cases, including whitespace or newline, since we
+    # have a separate check for semicolons preceded by whitespace.
+    if end_pos >= 0 and Match(r';', end_line[end_pos:]):
+      error(filename, end_linenum, 'whitespace/empty_loop_body', 5,
+            'Empty loop bodies should use {} or continue')
+
+
+def ReplaceableCheck(operator, macro, line):
+  """Determine whether a basic CHECK can be replaced with a more specific one.
+
+  For example suggest using CHECK_EQ instead of CHECK(a == b) and
+  similarly for CHECK_GE, CHECK_GT, CHECK_LE, CHECK_LT, CHECK_NE.
+
+  Args:
+    operator: The C++ operator used in the CHECK.
+    macro: The CHECK or EXPECT macro being called.
+    line: The current source line.
+
+  Returns:
+    True if the CHECK can be replaced with a more specific one.
+  """
+
+  # This matches decimal and hex integers, strings, and chars (in that order).
+  match_constant = r'([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')'
+
+  # Expression to match two sides of the operator with something that
+  # looks like a literal, since CHECK(x == iterator) won't compile.
+  # This means we can't catch all the cases where a more specific
+  # CHECK is possible, but it's less annoying than dealing with
+  # extraneous warnings.
+  match_this = (r'\s*' + macro + r'\((\s*' +
+                match_constant + r'\s*' + operator + r'[^<>].*|'
+                r'.*[^<>]' + operator + r'\s*' + match_constant +
+                r'\s*\))')
+
+  # Don't complain about CHECK(x == NULL) or similar because
+  # CHECK_EQ(x, NULL) won't compile (requires a cast).
+  # Also, don't complain about more complex boolean expressions
+  # involving && or || such as CHECK(a == b || c == d).
+  return Match(match_this, line) and not Search(r'NULL|&&|\|\|', line)
+
+
+def CheckCheck(filename, clean_lines, linenum, error):
+  """Checks the use of CHECK and EXPECT macros.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  # Decide the set of replacement macros that should be suggested
+  raw_lines = clean_lines.raw_lines
+  current_macro = ''
+  for macro in _CHECK_MACROS:
+    if raw_lines[linenum].find(macro) >= 0:
+      current_macro = macro
+      break
+  if not current_macro:
+    # Don't waste time here if line doesn't contain 'CHECK' or 'EXPECT'
+    return
+
+  line = clean_lines.elided[linenum]        # get rid of comments and strings
+
+  # Encourage replacing plain CHECKs with CHECK_EQ/CHECK_NE/etc.
+  for operator in ['==', '!=', '>=', '>', '<=', '<']:
+    if ReplaceableCheck(operator, current_macro, line):
+      error(filename, linenum, 'readability/check', 2,
+            'Consider using %s instead of %s(a %s b)' % (
+                _CHECK_REPLACEMENT[current_macro][operator],
+                current_macro, operator))
+      break
+
+
+def CheckAltTokens(filename, clean_lines, linenum, error):
+  """Check alternative keywords being used in boolean expressions.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Avoid preprocessor lines
+  if Match(r'^\s*#', line):
+    return
+
+  # Last ditch effort to avoid multi-line comments.  This will not help
+  # if the comment started before the current line or ended after the
+  # current line, but it catches most of the false positives.  At least,
+  # it provides a way to workaround this warning for people who use
+  # multi-line comments in preprocessor macros.
+  #
+  # TODO(unknown): remove this once cpplint has better support for
+  # multi-line comments.
+  if line.find('/*') >= 0 or line.find('*/') >= 0:
+    return
+
+  for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line):
+    error(filename, linenum, 'readability/alt_tokens', 2,
+          'Use operator %s instead of %s' % (
+              _ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1)))
+
+
+def GetLineWidth(line):
+  """Determines the width of the line in column positions.
+
+  Args:
+    line: A string, which may be a Unicode string.
+
+  Returns:
+    The width of the line in column positions, accounting for Unicode
+    combining characters and wide characters.
+  """
+  if isinstance(line, unicode):
+    width = 0
+    for uc in unicodedata.normalize('NFC', line):
+      if unicodedata.east_asian_width(uc) in ('W', 'F'):
+        width += 2
+      elif not unicodedata.combining(uc):
+        width += 1
+    return width
+  else:
+    return len(line)
+
+
+def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,
+               error):
+  """Checks rules from the 'C++ style rules' section of cppguide.html.
+
+  Most of these rules are hard to test (naming, comment style), but we
+  do what we can.  In particular we check for 2-space indents, line lengths,
+  tab usage, spaces inside code, etc.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    file_extension: The extension (without the dot) of the filename.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+
+  raw_lines = clean_lines.raw_lines
+  line = raw_lines[linenum]
+
+  if line.find('\t') != -1:
+    error(filename, linenum, 'whitespace/tab', 1,
+          'Tab found; better to use spaces')
+
+  # One or three blank spaces at the beginning of the line is weird; it's
+  # hard to reconcile that with 2-space indents.
+  # NOTE: here are the conditions rob pike used for his tests.  Mine aren't
+  # as sophisticated, but it may be worth becoming so:  RLENGTH==initial_spaces
+  # if(RLENGTH > 20) complain = 0;
+  # if(match($0, " +(error|private|public|protected):")) complain = 0;
+  # if(match(prev, "&& *$")) complain = 0;
+  # if(match(prev, "\\|\\| *$")) complain = 0;
+  # if(match(prev, "[\",=><] *$")) complain = 0;
+  # if(match($0, " <<")) complain = 0;
+  # if(match(prev, " +for \\(")) complain = 0;
+  # if(prevodd && match(prevprev, " +for \\(")) complain = 0;
+  initial_spaces = 0
+  cleansed_line = clean_lines.elided[linenum]
+  while initial_spaces < len(line) and line[initial_spaces] == ' ':
+    initial_spaces += 1
+  if line and line[-1].isspace():
+    error(filename, linenum, 'whitespace/end_of_line', 4,
+          'Line ends in whitespace.  Consider deleting these extra spaces.')
+  # There are certain situations we allow one space, notably for labels
+  elif ((initial_spaces == 1 or initial_spaces == 3) and
+        not Match(r'\s*\w+\s*:\s*$', cleansed_line)):
+    error(filename, linenum, 'whitespace/indent', 3,
+          'Weird number of spaces at line-start.  '
+          'Are you using a 2-space indent?')
+  # Labels should always be indented at least one space.
+  elif not initial_spaces and line[:2] != '//' and Search(r'[^:]:\s*$',
+                                                          line):
+    error(filename, linenum, 'whitespace/labels', 4,
+          'Labels should always be indented at least one space.  '
+          'If this is a member-initializer list in a constructor or '
+          'the base class list in a class definition, the colon should '
+          'be on the following line.')
+
+
+  # Check if the line is a header guard.
+  is_header_guard = False
+  if file_extension == 'h':
+    cppvar = GetHeaderGuardCPPVariable(filename)
+    if (line.startswith('#ifndef %s' % cppvar) or
+        line.startswith('#define %s' % cppvar) or
+        line.startswith('#endif  // %s' % cppvar)):
+      is_header_guard = True
+  # #include lines and header guards can be long, since there's no clean way to
+  # split them.
+  #
+  # URLs can be long too.  It's possible to split these, but it makes them
+  # harder to cut&paste.
+  #
+  # The "$Id:...$" comment may also get very long without it being the
+  # developers fault.
+  if (not line.startswith('#include') and not is_header_guard and
+      not Match(r'^\s*//.*http(s?)://\S*$', line) and
+      not Match(r'^// \$Id:.*#[0-9]+ \$$', line)):
+    line_width = GetLineWidth(line)
+    if line_width > 100:
+      error(filename, linenum, 'whitespace/line_length', 4,
+            'Lines should very rarely be longer than 100 characters')
+    elif line_width > 80:
+      error(filename, linenum, 'whitespace/line_length', 2,
+            'Lines should be <= 80 characters long')
+
+  if (cleansed_line.count(';') > 1 and
+      # for loops are allowed two ;'s (and may run over two lines).
+      cleansed_line.find('for') == -1 and
+      (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
+       GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and
+      # It's ok to have many commands in a switch case that fits in 1 line
+      not ((cleansed_line.find('case ') != -1 or
+            cleansed_line.find('default:') != -1) and
+           cleansed_line.find('break;') != -1)):
+    error(filename, linenum, 'whitespace/newline', 0,
+          'More than one command on the same line')
+
+  # Some more style checks
+  CheckBraces(filename, clean_lines, linenum, error)
+  CheckEmptyLoopBody(filename, clean_lines, linenum, error)
+  CheckAccess(filename, clean_lines, linenum, nesting_state, error)
+  CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
+  CheckCheck(filename, clean_lines, linenum, error)
+  CheckAltTokens(filename, clean_lines, linenum, error)
+  classinfo = nesting_state.InnermostClass()
+  if classinfo:
+    CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)
+
+
+_RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')
+_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$')
+# Matches the first component of a filename delimited by -s and _s. That is:
+#  _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo'
+_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')
+
+
+def _DropCommonSuffixes(filename):
+  """Drops common suffixes like _test.cc or -inl.h from filename.
+
+  For example:
+    >>> _DropCommonSuffixes('foo/foo-inl.h')
+    'foo/foo'
+    >>> _DropCommonSuffixes('foo/bar/foo.cc')
+    'foo/bar/foo'
+    >>> _DropCommonSuffixes('foo/foo_internal.h')
+    'foo/foo'
+    >>> _DropCommonSuffixes('foo/foo_unusualinternal.h')
+    'foo/foo_unusualinternal'
+
+  Args:
+    filename: The input filename.
+
+  Returns:
+    The filename with the common suffix removed.
+  """
+  for suffix in ('test.cc', 'regtest.cc', 'unittest.cc',
+                 'inl.h', 'impl.h', 'internal.h'):
+    if (filename.endswith(suffix) and len(filename) > len(suffix) and
+        filename[-len(suffix) - 1] in ('-', '_')):
+      return filename[:-len(suffix) - 1]
+  return os.path.splitext(filename)[0]
+
+
+def _IsTestFilename(filename):
+  """Determines if the given filename has a suffix that identifies it as a test.
+
+  Args:
+    filename: The input filename.
+
+  Returns:
+    True if 'filename' looks like a test, False otherwise.
+  """
+  if (filename.endswith('_test.cc') or
+      filename.endswith('_unittest.cc') or
+      filename.endswith('_regtest.cc')):
+    return True
+  else:
+    return False
+
+
+def _ClassifyInclude(fileinfo, include, is_system):
+  """Figures out what kind of header 'include' is.
+
+  Args:
+    fileinfo: The current file cpplint is running over. A FileInfo instance.
+    include: The path to a #included file.
+    is_system: True if the #include used <> rather than "".
+
+  Returns:
+    One of the _XXX_HEADER constants.
+
+  For example:
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True)
+    _C_SYS_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True)
+    _CPP_SYS_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False)
+    _LIKELY_MY_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'),
+    ...                  'bar/foo_other_ext.h', False)
+    _POSSIBLE_MY_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False)
+    _OTHER_HEADER
+  """
+  # This is a list of all standard c++ header files, except
+  # those already checked for above.
+  is_stl_h = include in _STL_HEADERS
+  is_cpp_h = is_stl_h or include in _CPP_HEADERS
+
+  if is_system:
+    if is_cpp_h:
+      return _CPP_SYS_HEADER
+    else:
+      return _C_SYS_HEADER
+
+  # If the target file and the include we're checking share a
+  # basename when we drop common extensions, and the include
+  # lives in . , then it's likely to be owned by the target file.
+  target_dir, target_base = (
+      os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName())))
+  include_dir, include_base = os.path.split(_DropCommonSuffixes(include))
+  if target_base == include_base and (
+      include_dir == target_dir or
+      include_dir == os.path.normpath(target_dir + '/../public')):
+    return _LIKELY_MY_HEADER
+
+  # If the target and include share some initial basename
+  # component, it's possible the target is implementing the
+  # include, so it's allowed to be first, but we'll never
+  # complain if it's not there.
+  target_first_component = _RE_FIRST_COMPONENT.match(target_base)
+  include_first_component = _RE_FIRST_COMPONENT.match(include_base)
+  if (target_first_component and include_first_component and
+      target_first_component.group(0) ==
+      include_first_component.group(0)):
+    return _POSSIBLE_MY_HEADER
+
+  return _OTHER_HEADER
+
+
+
+def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):
+  """Check rules that are applicable to #include lines.
+
+  Strings on #include lines are NOT removed from elided line, to make
+  certain tasks easier. However, to prevent false positives, checks
+  applicable to #include lines in CheckLanguage must be put here.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    include_state: An _IncludeState instance in which the headers are inserted.
+    error: The function to call with any errors found.
+  """
+  fileinfo = FileInfo(filename)
+
+  line = clean_lines.lines[linenum]
+
+  # "include" should use the new style "foo/bar.h" instead of just "bar.h"
+  if _RE_PATTERN_INCLUDE_NEW_STYLE.search(line):
+    error(filename, linenum, 'build/include', 4,
+          'Include the directory when naming .h files')
+
+  # we shouldn't include a file more than once. actually, there are a
+  # handful of instances where doing so is okay, but in general it's
+  # not.
+  match = _RE_PATTERN_INCLUDE.search(line)
+  if match:
+    include = match.group(2)
+    is_system = (match.group(1) == '<')
+    if include in include_state:
+      error(filename, linenum, 'build/include', 4,
+            '"%s" already included at %s:%s' %
+            (include, filename, include_state[include]))
+    else:
+      include_state[include] = linenum
+
+      # We want to ensure that headers appear in the right order:
+      # 1) for foo.cc, foo.h  (preferred location)
+      # 2) c system files
+      # 3) cpp system files
+      # 4) for foo.cc, foo.h  (deprecated location)
+      # 5) other google headers
+      #
+      # We classify each include statement as one of those 5 types
+      # using a number of techniques. The include_state object keeps
+      # track of the highest type seen, and complains if we see a
+      # lower type after that.
+      error_message = include_state.CheckNextIncludeOrder(
+          _ClassifyInclude(fileinfo, include, is_system))
+      if error_message:
+        error(filename, linenum, 'build/include_order', 4,
+              '%s. Should be: %s.h, c system, c++ system, other.' %
+              (error_message, fileinfo.BaseName()))
+      if not include_state.IsInAlphabeticalOrder(include):
+        error(filename, linenum, 'build/include_alpha', 4,
+              'Include "%s" not in alphabetical order' % include)
+
+  # Look for any of the stream classes that are part of standard C++.
+  match = _RE_PATTERN_INCLUDE.match(line)
+  if match:
+    include = match.group(2)
+    if Match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include):
+      # Many unit tests use cout, so we exempt them.
+      if not _IsTestFilename(filename):
+        error(filename, linenum, 'readability/streams', 3,
+              'Streams are highly discouraged.')
+
+
+def _GetTextInside(text, start_pattern):
+  """Retrieves all the text between matching open and close parentheses.
+
+  Given a string of lines and a regular expression string, retrieve all the text
+  following the expression and between opening punctuation symbols like
+  (, [, or {, and the matching close-punctuation symbol. This properly nested
+  occurrences of the punctuations, so for the text like
+    printf(a(), b(c()));
+  a call to _GetTextInside(text, r'printf\(') will return 'a(), b(c())'.
+  start_pattern must match string having an open punctuation symbol at the end.
+
+  Args:
+    text: The lines to extract text. Its comments and strings must be elided.
+           It can be single line and can span multiple lines.
+    start_pattern: The regexp string indicating where to start extracting
+                   the text.
+  Returns:
+    The extracted text.
+    None if either the opening string or ending punctuation could not be found.
+  """
+  # TODO(sugawarayu): Audit cpplint.py to see what places could be profitably
+  # rewritten to use _GetTextInside (and use inferior regexp matching today).
+
+  # Give opening punctuations to get the matching close-punctuations.
+  matching_punctuation = {'(': ')', '{': '}', '[': ']'}
+  closing_punctuation = set(matching_punctuation.itervalues())
+
+  # Find the position to start extracting text.
+  match = re.search(start_pattern, text, re.M)
+  if not match:  # start_pattern not found in text.
+    return None
+  start_position = match.end(0)
+
+  assert start_position > 0, (
+      'start_pattern must ends with an opening punctuation.')
+  assert text[start_position - 1] in matching_punctuation, (
+      'start_pattern must ends with an opening punctuation.')
+  # Stack of closing punctuations we expect to have in text after position.
+  punctuation_stack = [matching_punctuation[text[start_position - 1]]]
+  position = start_position
+  while punctuation_stack and position < len(text):
+    if text[position] == punctuation_stack[-1]:
+      punctuation_stack.pop()
+    elif text[position] in closing_punctuation:
+      # A closing punctuation without matching opening punctuations.
+      return None
+    elif text[position] in matching_punctuation:
+      punctuation_stack.append(matching_punctuation[text[position]])
+    position += 1
+  if punctuation_stack:
+    # Opening punctuations left without matching close-punctuations.
+    return None
+  # punctuations match.
+  return text[start_position:position - 1]
+
+
+def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,
+                  error):
+  """Checks rules from the 'C++ language rules' section of cppguide.html.
+
+  Some of these rules are hard to test (function overloading, using
+  uint32 inappropriately), but we do the best we can.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    file_extension: The extension (without the dot) of the filename.
+    include_state: An _IncludeState instance in which the headers are inserted.
+    error: The function to call with any errors found.
+  """
+  # If the line is empty or consists of entirely a comment, no need to
+  # check it.
+  line = clean_lines.elided[linenum]
+  if not line:
+    return
+
+  match = _RE_PATTERN_INCLUDE.search(line)
+  if match:
+    CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
+    return
+
+  # Create an extended_line, which is the concatenation of the current and
+  # next lines, for more effective checking of code that may span more than one
+  # line.
+  if linenum + 1 < clean_lines.NumLines():
+    extended_line = line + clean_lines.elided[linenum + 1]
+  else:
+    extended_line = line
+
+  # Make Windows paths like Unix.
+  fullname = os.path.abspath(filename).replace('\\', '/')
+
+  # TODO(unknown): figure out if they're using default arguments in fn proto.
+
+  # Check for non-const references in functions.  This is tricky because &
+  # is also used to take the address of something.  We allow <> for templates,
+  # (ignoring whatever is between the braces) and : for classes.
+  # These are complicated re's.  They try to capture the following:
+  # paren (for fn-prototype start), typename, &, varname.  For the const
+  # version, we're willing for const to be before typename or after
+  # Don't check the implementation on same line.
+  fnline = line.split('{', 1)[0]
+  if (len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) >
+      len(re.findall(r'\([^()]*\bconst\s+(?:typename\s+)?(?:struct\s+)?'
+                     r'(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) +
+      len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+\s+const(\s?&|&\s?)[\w]+',
+                     fnline))):
+
+    # We allow non-const references in a few standard places, like functions
+    # called "swap()" or iostream operators like "<<" or ">>". We also filter
+    # out for loops, which lint otherwise mistakenly thinks are functions.
+    if not Search(
+        r'(for|swap|Swap|operator[<>][<>])\s*\(\s*'
+        r'(?:(?:typename\s*)?[\w:]|<.*>)+\s*&',
+        fnline):
+      error(filename, linenum, 'runtime/references', 2,
+            'Is this a non-const reference? '
+            'If so, make const or use a pointer.')
+
+  # Check to see if they're using an conversion function cast.
+  # I just try to capture the most common basic types, though there are more.
+  # Parameterless conversion functions, such as bool(), are allowed as they are
+  # probably a member operator declaration or default constructor.
+  match = Search(
+      r'(\bnew\s+)?\b'  # Grab 'new' operator, if it's there
+      r'(int|float|double|bool|char|int32|uint32|int64|uint64)\([^)]', line)
+  if match:
+    # gMock methods are defined using some variant of MOCK_METHODx(name, type)
+    # where type may be float(), int(string), etc.  Without context they are
+    # virtually indistinguishable from int(x) casts. Likewise, gMock's
+    # MockCallback takes a template parameter of the form return_type(arg_type),
+    # which looks much like the cast we're trying to detect.
+    if (match.group(1) is None and  # If new operator, then this isn't a cast
+        not (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or
+             Match(r'^\s*MockCallback<.*>', line))):
+      # Try a bit harder to catch gmock lines: the only place where
+      # something looks like an old-style cast is where we declare the
+      # return type of the mocked method, and the only time when we
+      # are missing context is if MOCK_METHOD was split across
+      # multiple lines (for example http://go/hrfhr ), so we only need
+      # to check the previous line for MOCK_METHOD.
+      if (linenum == 0 or
+          not Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(\S+,\s*$',
+                    clean_lines.elided[linenum - 1])):
+        error(filename, linenum, 'readability/casting', 4,
+              'Using deprecated casting style.  '
+              'Use static_cast<%s>(...) instead' %
+              match.group(2))
+
+  CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
+                  'static_cast',
+                  r'\((int|float|double|bool|char|u?int(16|32|64))\)', error)
+
+  # This doesn't catch all cases. Consider (const char * const)"hello".
+  #
+  # (char *) "foo" should always be a const_cast (reinterpret_cast won't
+  # compile).
+  if CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
+                     'const_cast', r'\((char\s?\*+\s?)\)\s*"', error):
+    pass
+  else:
+    # Check pointer casts for other than string constants
+    CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
+                    'reinterpret_cast', r'\((\w+\s?\*+\s?)\)', error)
+
+  # In addition, we look for people taking the address of a cast.  This
+  # is dangerous -- casts can assign to temporaries, so the pointer doesn't
+  # point where you think.
+  if Search(
+      r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line):
+    error(filename, linenum, 'runtime/casting', 4,
+          ('Are you taking an address of a cast?  '
+           'This is dangerous: could be a temp var.  '
+           'Take the address before doing the cast, rather than after'))
+
+  # Check for people declaring static/global STL strings at the top level.
+  # This is dangerous because the C++ language does not guarantee that
+  # globals with constructors are initialized before the first access.
+  match = Match(
+      r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)',
+      line)
+  # Make sure it's not a function.
+  # Function template specialization looks like: "string foo<Type>(...".
+  # Class template definitions look like: "string Foo<Type>::Method(...".
+  if match and not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)?\s*\(([^"]|$)',
+                         match.group(3)):
+    error(filename, linenum, 'runtime/string', 4,
+          'For a static/global string constant, use a C style string instead: '
+          '"%schar %s[]".' %
+          (match.group(1), match.group(2)))
+
+  # Check that we're not using RTTI outside of testing code.
+  if Search(r'\bdynamic_cast<', line) and not _IsTestFilename(filename):
+    error(filename, linenum, 'runtime/rtti', 5,
+          'Do not use dynamic_cast<>.  If you need to cast within a class '
+          "hierarchy, use static_cast<> to upcast.  Google doesn't support "
+          'RTTI.')
+
+  if Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line):
+    error(filename, linenum, 'runtime/init', 4,
+          'You seem to be initializing a member variable with itself.')
+
+  if file_extension == 'h':
+    # TODO(unknown): check that 1-arg constructors are explicit.
+    #                How to tell it's a constructor?
+    #                (handled in CheckForNonStandardConstructs for now)
+    # TODO(unknown): check that classes have DISALLOW_EVIL_CONSTRUCTORS
+    #                (level 1 error)
+    pass
+
+  # Check if people are using the verboten C basic types.  The only exception
+  # we regularly allow is "unsigned short port" for port.
+  if Search(r'\bshort port\b', line):
+    if not Search(r'\bunsigned short port\b', line):
+      error(filename, linenum, 'runtime/int', 4,
+            'Use "unsigned short" for ports, not "short"')
+  else:
+    match = Search(r'\b(short|long(?! +double)|long long)\b', line)
+    if match:
+      error(filename, linenum, 'runtime/int', 4,
+            'Use int16/int64/etc, rather than the C type %s' % match.group(1))
+
+  # When snprintf is used, the second argument shouldn't be a literal.
+  match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line)
+  if match and match.group(2) != '0':
+    # If 2nd arg is zero, snprintf is used to calculate size.
+    error(filename, linenum, 'runtime/printf', 3,
+          'If you can, use sizeof(%s) instead of %s as the 2nd arg '
+          'to snprintf.' % (match.group(1), match.group(2)))
+
+  # Check if some verboten C functions are being used.
+  if Search(r'\bsprintf\b', line):
+    error(filename, linenum, 'runtime/printf', 5,
+          'Never use sprintf.  Use snprintf instead.')
+  match = Search(r'\b(strcpy|strcat)\b', line)
+  if match:
+    error(filename, linenum, 'runtime/printf', 4,
+          'Almost always, snprintf is better than %s' % match.group(1))
+
+  if Search(r'\bsscanf\b', line):
+    error(filename, linenum, 'runtime/printf', 1,
+          'sscanf can be ok, but is slow and can overflow buffers.')
+
+  # Check if some verboten operator overloading is going on
+  # TODO(unknown): catch out-of-line unary operator&:
+  #   class X {};
+  #   int operator&(const X& x) { return 42; }  // unary operator&
+  # The trick is it's hard to tell apart from binary operator&:
+  #   class Y { int operator&(const Y& x) { return 23; } }; // binary operator&
+  if Search(r'\boperator\s*&\s*\(\s*\)', line):
+    error(filename, linenum, 'runtime/operator', 4,
+          'Unary operator& is dangerous.  Do not use it.')
+
+  # Check for suspicious usage of "if" like
+  # } if (a == b) {
+  if Search(r'\}\s*if\s*\(', line):
+    error(filename, linenum, 'readability/braces', 4,
+          'Did you mean "else if"? If not, start a new line for "if".')
+
+  # Check for potential format string bugs like printf(foo).
+  # We constrain the pattern not to pick things like DocidForPrintf(foo).
+  # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())
+  # TODO(sugawarayu): Catch the following case. Need to change the calling
+  # convention of the whole function to process multiple line to handle it.
+  #   printf(
+  #       boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line);
+  printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(')
+  if printf_args:
+    match = Match(r'([\w.\->()]+)$', printf_args)
+    if match and match.group(1) != '__VA_ARGS__':
+      function_name = re.search(r'\b((?:string)?printf)\s*\(',
+                                line, re.I).group(1)
+      error(filename, linenum, 'runtime/printf', 4,
+            'Potential format string bug. Do %s("%%s", %s) instead.'
+            % (function_name, match.group(1)))
+
+  # Check for potential memset bugs like memset(buf, sizeof(buf), 0).
+  match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line)
+  if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)):
+    error(filename, linenum, 'runtime/memset', 4,
+          'Did you mean "memset(%s, 0, %s)"?'
+          % (match.group(1), match.group(2)))
+
+  if Search(r'\busing namespace\b', line):
+    error(filename, linenum, 'build/namespaces', 5,
+          'Do not use namespace using-directives.  '
+          'Use using-declarations instead.')
+
+  # Detect variable-length arrays.
+  match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line)
+  if (match and match.group(2) != 'return' and match.group(2) != 'delete' and
+      match.group(3).find(']') == -1):
+    # Split the size using space and arithmetic operators as delimiters.
+    # If any of the resulting tokens are not compile time constants then
+    # report the error.
+    tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3))
+    is_const = True
+    skip_next = False
+    for tok in tokens:
+      if skip_next:
+        skip_next = False
+        continue
+
+      if Search(r'sizeof\(.+\)', tok): continue
+      if Search(r'arraysize\(\w+\)', tok): continue
+
+      tok = tok.lstrip('(')
+      tok = tok.rstrip(')')
+      if not tok: continue
+      if Match(r'\d+', tok): continue
+      if Match(r'0[xX][0-9a-fA-F]+', tok): continue
+      if Match(r'k[A-Z0-9]\w*', tok): continue
+      if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue
+      if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue
+      # A catch all for tricky sizeof cases, including 'sizeof expression',
+      # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'
+      # requires skipping the next token because we split on ' ' and '*'.
+      if tok.startswith('sizeof'):
+        skip_next = True
+        continue
+      is_const = False
+      break
+    if not is_const:
+      error(filename, linenum, 'runtime/arrays', 1,
+            'Do not use variable-length arrays.  Use an appropriately named '
+            "('k' followed by CamelCase) compile-time constant for the size.")
+
+  # If DISALLOW_EVIL_CONSTRUCTORS, DISALLOW_COPY_AND_ASSIGN, or
+  # DISALLOW_IMPLICIT_CONSTRUCTORS is present, then it should be the last thing
+  # in the class declaration.
+  match = Match(
+      (r'\s*'
+       r'(DISALLOW_(EVIL_CONSTRUCTORS|COPY_AND_ASSIGN|IMPLICIT_CONSTRUCTORS))'
+       r'\(.*\);$'),
+      line)
+  if match and linenum + 1 < clean_lines.NumLines():
+    next_line = clean_lines.elided[linenum + 1]
+    # We allow some, but not all, declarations of variables to be present
+    # in the statement that defines the class.  The [\w\*,\s]* fragment of
+    # the regular expression below allows users to declare instances of
+    # the class or pointers to instances, but not less common types such
+    # as function pointers or arrays.  It's a tradeoff between allowing
+    # reasonable code and avoiding trying to parse more C++ using regexps.
+    if not Search(r'^\s*}[\w\*,\s]*;', next_line):
+      error(filename, linenum, 'readability/constructors', 3,
+            match.group(1) + ' should be the last thing in the class')
+
+  # Check for use of unnamed namespaces in header files.  Registration
+  # macros are typically OK, so we allow use of "namespace {" on lines
+  # that end with backslashes.
+  if (file_extension == 'h'
+      and Search(r'\bnamespace\s*{', line)
+      and line[-1] != '\\'):
+    error(filename, linenum, 'build/namespaces', 4,
+          'Do not use unnamed namespaces in header files.  See '
+          'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
+          ' for more information.')
+
+
+def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern,
+                    error):
+  """Checks for a C-style cast by looking for the pattern.
+
+  This also handles sizeof(type) warnings, due to similarity of content.
+
+  Args:
+    filename: The name of the current file.
+    linenum: The number of the line to check.
+    line: The line of code to check.
+    raw_line: The raw line of code to check, with comments.
+    cast_type: The string for the C++ cast to recommend.  This is either
+      reinterpret_cast, static_cast, or const_cast, depending.
+    pattern: The regular expression used to find C-style casts.
+    error: The function to call with any errors found.
+
+  Returns:
+    True if an error was emitted.
+    False otherwise.
+  """
+  match = Search(pattern, line)
+  if not match:
+    return False
+
+  # e.g., sizeof(int)
+  sizeof_match = Match(r'.*sizeof\s*$', line[0:match.start(1) - 1])
+  if sizeof_match:
+    error(filename, linenum, 'runtime/sizeof', 1,
+          'Using sizeof(type).  Use sizeof(varname) instead if possible')
+    return True
+
+  # operator++(int) and operator--(int)
+  if (line[0:match.start(1) - 1].endswith(' operator++') or
+      line[0:match.start(1) - 1].endswith(' operator--')):
+    return False
+
+  remainder = line[match.end(0):]
+
+  # The close paren is for function pointers as arguments to a function.
+  # eg, void foo(void (*bar)(int));
+  # The semicolon check is a more basic function check; also possibly a
+  # function pointer typedef.
+  # eg, void foo(int); or void foo(int) const;
+  # The equals check is for function pointer assignment.
+  # eg, void *(*foo)(int) = ...
+  # The > is for MockCallback<...> ...
+  #
+  # Right now, this will only catch cases where there's a single argument, and
+  # it's unnamed.  It should probably be expanded to check for multiple
+  # arguments with some unnamed.
+  function_match = Match(r'\s*(\)|=|(const)?\s*(;|\{|throw\(\)|>))', remainder)
+  if function_match:
+    if (not function_match.group(3) or
+        function_match.group(3) == ';' or
+        ('MockCallback<' not in raw_line and
+         '/*' not in raw_line)):
+      error(filename, linenum, 'readability/function', 3,
+            'All parameters should be named in a function')
+    return True
+
+  # At this point, all that should be left is actual casts.
+  error(filename, linenum, 'readability/casting', 4,
+        'Using C-style cast.  Use %s<%s>(...) instead' %
+        (cast_type, match.group(1)))
+
+  return True
+
+
+_HEADERS_CONTAINING_TEMPLATES = (
+    ('<deque>', ('deque',)),
+    ('<functional>', ('unary_function', 'binary_function',
+                      'plus', 'minus', 'multiplies', 'divides', 'modulus',
+                      'negate',
+                      'equal_to', 'not_equal_to', 'greater', 'less',
+                      'greater_equal', 'less_equal',
+                      'logical_and', 'logical_or', 'logical_not',
+                      'unary_negate', 'not1', 'binary_negate', 'not2',
+                      'bind1st', 'bind2nd',
+                      'pointer_to_unary_function',
+                      'pointer_to_binary_function',
+                      'ptr_fun',
+                      'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',
+                      'mem_fun_ref_t',
+                      'const_mem_fun_t', 'const_mem_fun1_t',
+                      'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',
+                      'mem_fun_ref',
+                     )),
+    ('<limits>', ('numeric_limits',)),
+    ('<list>', ('list',)),
+    ('<map>', ('map', 'multimap',)),
+    ('<memory>', ('allocator',)),
+    ('<queue>', ('queue', 'priority_queue',)),
+    ('<set>', ('set', 'multiset',)),
+    ('<stack>', ('stack',)),
+    ('<string>', ('char_traits', 'basic_string',)),
+    ('<utility>', ('pair',)),
+    ('<vector>', ('vector',)),
+
+    # gcc extensions.
+    # Note: std::hash is their hash, ::hash is our hash
+    ('<hash_map>', ('hash_map', 'hash_multimap',)),
+    ('<hash_set>', ('hash_set', 'hash_multiset',)),
+    ('<slist>', ('slist',)),
+    )
+
+_RE_PATTERN_STRING = re.compile(r'\bstring\b')
+
+_re_pattern_algorithm_header = []
+for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap',
+                  'transform'):
+  # Match max<type>(..., ...), max(..., ...), but not foo->max, foo.max or
+  # type::max().
+  _re_pattern_algorithm_header.append(
+      (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'),
+       _template,
+       '<algorithm>'))
+
+_re_pattern_templates = []
+for _header, _templates in _HEADERS_CONTAINING_TEMPLATES:
+  for _template in _templates:
+    _re_pattern_templates.append(
+        (re.compile(r'(\<|\b)' + _template + r'\s*\<'),
+         _template + '<>',
+         _header))
+
+
+def FilesBelongToSameModule(filename_cc, filename_h):
+  """Check if these two filenames belong to the same module.
+
+  The concept of a 'module' here is a as follows:
+  foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the
+  same 'module' if they are in the same directory.
+  some/path/public/xyzzy and some/path/internal/xyzzy are also considered
+  to belong to the same module here.
+
+  If the filename_cc contains a longer path than the filename_h, for example,
+  '/absolute/path/to/base/sysinfo.cc', and this file would include
+  'base/sysinfo.h', this function also produces the prefix needed to open the
+  header. This is used by the caller of this function to more robustly open the
+  header file. We don't have access to the real include paths in this context,
+  so we need this guesswork here.
+
+  Known bugs: tools/base/bar.cc and base/bar.h belong to the same module
+  according to this implementation. Because of this, this function gives
+  some false positives. This should be sufficiently rare in practice.
+
+  Args:
+    filename_cc: is the path for the .cc file
+    filename_h: is the path for the header path
+
+  Returns:
+    Tuple with a bool and a string:
+    bool: True if filename_cc and filename_h belong to the same module.
+    string: the additional prefix needed to open the header file.
+  """
+
+  if not filename_cc.endswith('.cc'):
+    return (False, '')
+  filename_cc = filename_cc[:-len('.cc')]
+  if filename_cc.endswith('_unittest'):
+    filename_cc = filename_cc[:-len('_unittest')]
+  elif filename_cc.endswith('_test'):
+    filename_cc = filename_cc[:-len('_test')]
+  filename_cc = filename_cc.replace('/public/', '/')
+  filename_cc = filename_cc.replace('/internal/', '/')
+
+  if not filename_h.endswith('.h'):
+    return (False, '')
+  filename_h = filename_h[:-len('.h')]
+  if filename_h.endswith('-inl'):
+    filename_h = filename_h[:-len('-inl')]
+  filename_h = filename_h.replace('/public/', '/')
+  filename_h = filename_h.replace('/internal/', '/')
+
+  files_belong_to_same_module = filename_cc.endswith(filename_h)
+  common_path = ''
+  if files_belong_to_same_module:
+    common_path = filename_cc[:-len(filename_h)]
+  return files_belong_to_same_module, common_path
+
+
+def UpdateIncludeState(filename, include_state, io=codecs):
+  """Fill up the include_state with new includes found from the file.
+
+  Args:
+    filename: the name of the header to read.
+    include_state: an _IncludeState instance in which the headers are inserted.
+    io: The io factory to use to read the file. Provided for testability.
+
+  Returns:
+    True if a header was successfully added. False otherwise.
+  """
+  headerfile = None
+  try:
+    headerfile = io.open(filename, 'r', 'utf8', 'replace')
+  except IOError:
+    return False
+  linenum = 0
+  for line in headerfile:
+    linenum += 1
+    clean_line = CleanseComments(line)
+    match = _RE_PATTERN_INCLUDE.search(clean_line)
+    if match:
+      include = match.group(2)
+      # The value formatting is cute, but not really used right now.
+      # What matters here is that the key is in include_state.
+      include_state.setdefault(include, '%s:%d' % (filename, linenum))
+  return True
+
+
+def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,
+                              io=codecs):
+  """Reports for missing stl includes.
+
+  This function will output warnings to make sure you are including the headers
+  necessary for the stl containers and functions that you use. We only give one
+  reason to include a header. For example, if you use both equal_to<> and
+  less<> in a .h file, only one (the latter in the file) of these will be
+  reported as a reason to include the <functional>.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    include_state: An _IncludeState instance.
+    error: The function to call with any errors found.
+    io: The IO factory to use to read the header file. Provided for unittest
+        injection.
+  """
+  required = {}  # A map of header name to linenumber and the template entity.
+                 # Example of required: { '<functional>': (1219, 'less<>') }
+
+  for linenum in xrange(clean_lines.NumLines()):
+    line = clean_lines.elided[linenum]
+    if not line or line[0] == '#':
+      continue
+
+    # String is special -- it is a non-templatized type in STL.
+    matched = _RE_PATTERN_STRING.search(line)
+    if matched:
+      # Don't warn about strings in non-STL namespaces:
+      # (We check only the first match per line; good enough.)
+      prefix = line[:matched.start()]
+      if prefix.endswith('std::') or not prefix.endswith('::'):
+        required['<string>'] = (linenum, 'string')
+
+    for pattern, template, header in _re_pattern_algorithm_header:
+      if pattern.search(line):
+        required[header] = (linenum, template)
+
+    # The following function is just a speed up, no semantics are changed.
+    if not '<' in line:  # Reduces the cpu time usage by skipping lines.
+      continue
+
+    for pattern, template, header in _re_pattern_templates:
+      if pattern.search(line):
+        required[header] = (linenum, template)
+
+  # The policy is that if you #include something in foo.h you don't need to
+  # include it again in foo.cc. Here, we will look at possible includes.
+  # Let's copy the include_state so it is only messed up within this function.
+  include_state = include_state.copy()
+
+  # Did we find the header for this file (if any) and successfully load it?
+  header_found = False
+
+  # Use the absolute path so that matching works properly.
+  abs_filename = FileInfo(filename).FullName()
+
+  # For Emacs's flymake.
+  # If cpplint is invoked from Emacs's flymake, a temporary file is generated
+  # by flymake and that file name might end with '_flymake.cc'. In that case,
+  # restore original file name here so that the corresponding header file can be
+  # found.
+  # e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h'
+  # instead of 'foo_flymake.h'
+  abs_filename = re.sub(r'_flymake\.cc$', '.cc', abs_filename)
+
+  # include_state is modified during iteration, so we iterate over a copy of
+  # the keys.
+  header_keys = include_state.keys()
+  for header in header_keys:
+    (same_module, common_path) = FilesBelongToSameModule(abs_filename, header)
+    fullpath = common_path + header
+    if same_module and UpdateIncludeState(fullpath, include_state, io):
+      header_found = True
+
+  # If we can't find the header file for a .cc, assume it's because we don't
+  # know where to look. In that case we'll give up as we're not sure they
+  # didn't include it in the .h file.
+  # TODO(unknown): Do a better job of finding .h files so we are confident that
+  # not having the .h file means there isn't one.
+  if filename.endswith('.cc') and not header_found:
+    return
+
+  # All the lines have been processed, report the errors found.
+  for required_header_unstripped in required:
+    template = required[required_header_unstripped][1]
+    if required_header_unstripped.strip('<>"') not in include_state:
+      error(filename, required[required_header_unstripped][0],
+            'build/include_what_you_use', 4,
+            'Add #include ' + required_header_unstripped + ' for ' + template)
+
+
+_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<')
+
+
+def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):
+  """Check that make_pair's template arguments are deduced.
+
+  G++ 4.6 in C++0x mode fails badly if make_pair's template arguments are
+  specified explicitly, and such use isn't intended in any case.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  raw = clean_lines.raw_lines
+  line = raw[linenum]
+  match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line)
+  if match:
+    error(filename, linenum, 'build/explicit_make_pair',
+          4,  # 4 = high confidence
+          'For C++11-compatibility, omit template arguments from make_pair'
+          ' OR use pair directly OR if appropriate, construct a pair directly')
+
+
+def ProcessLine(filename, file_extension, clean_lines, line,
+                include_state, function_state, nesting_state, error,
+                extra_check_functions=[]):
+  """Processes a single line in the file.
+
+  Args:
+    filename: Filename of the file that is being processed.
+    file_extension: The extension (dot not included) of the file.
+    clean_lines: An array of strings, each representing a line of the file,
+                 with comments stripped.
+    line: Number of line being processed.
+    include_state: An _IncludeState instance in which the headers are inserted.
+    function_state: A _FunctionState instance which counts function lines, etc.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: A callable to which errors are reported, which takes 4 arguments:
+           filename, line number, error level, and message
+    extra_check_functions: An array of additional check functions that will be
+                           run on each source line. Each function takes 4
+                           arguments: filename, clean_lines, line, error
+  """
+  raw_lines = clean_lines.raw_lines
+  ParseNolintSuppressions(filename, raw_lines[line], line, error)
+  nesting_state.Update(filename, clean_lines, line, error)
+  if nesting_state.stack and nesting_state.stack[-1].inline_asm != _NO_ASM:
+    return
+  CheckForFunctionLengths(filename, clean_lines, line, function_state, error)
+  CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)
+  CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error)
+  CheckLanguage(filename, clean_lines, line, file_extension, include_state,
+                error)
+  CheckForNonStandardConstructs(filename, clean_lines, line,
+                                nesting_state, error)
+  CheckPosixThreading(filename, clean_lines, line, error)
+  CheckInvalidIncrement(filename, clean_lines, line, error)
+  CheckMakePairUsesDeduction(filename, clean_lines, line, error)
+  for check_fn in extra_check_functions:
+    check_fn(filename, clean_lines, line, error)
+
+def ProcessFileData(filename, file_extension, lines, error,
+                    extra_check_functions=[]):
+  """Performs lint checks and reports any errors to the given error function.
+
+  Args:
+    filename: Filename of the file that is being processed.
+    file_extension: The extension (dot not included) of the file.
+    lines: An array of strings, each representing a line of the file, with the
+           last element being empty if the file is terminated with a newline.
+    error: A callable to which errors are reported, which takes 4 arguments:
+           filename, line number, error level, and message
+    extra_check_functions: An array of additional check functions that will be
+                           run on each source line. Each function takes 4
+                           arguments: filename, clean_lines, line, error
+  """
+  lines = (['// marker so line numbers and indices both start at 1'] + lines +
+           ['// marker so line numbers end in a known way'])
+
+  include_state = _IncludeState()
+  function_state = _FunctionState()
+  nesting_state = _NestingState()
+
+  ResetNolintSuppressions()
+
+  CheckForCopyright(filename, lines, error)
+
+  if file_extension == 'h':
+    CheckForHeaderGuard(filename, lines, error)
+
+  RemoveMultiLineComments(filename, lines, error)
+  clean_lines = CleansedLines(lines)
+  for line in xrange(clean_lines.NumLines()):
+    ProcessLine(filename, file_extension, clean_lines, line,
+                include_state, function_state, nesting_state, error,
+                extra_check_functions)
+  nesting_state.CheckClassFinished(filename, error)
+
+  CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)
+
+  # We check here rather than inside ProcessLine so that we see raw
+  # lines rather than "cleaned" lines.
+  CheckForUnicodeReplacementCharacters(filename, lines, error)
+
+  CheckForNewlineAtEOF(filename, lines, error)
+
+def ProcessFile(filename, vlevel, extra_check_functions=[]):
+  """Does google-lint on a single file.
+
+  Args:
+    filename: The name of the file to parse.
+
+    vlevel: The level of errors to report.  Every error of confidence
+    >= verbose_level will be reported.  0 is a good default.
+
+    extra_check_functions: An array of additional check functions that will be
+                           run on each source line. Each function takes 4
+                           arguments: filename, clean_lines, line, error
+  """
+
+  _SetVerboseLevel(vlevel)
+
+  try:
+    # Support the UNIX convention of using "-" for stdin.  Note that
+    # we are not opening the file with universal newline support
+    # (which codecs doesn't support anyway), so the resulting lines do
+    # contain trailing '\r' characters if we are reading a file that
+    # has CRLF endings.
+    # If after the split a trailing '\r' is present, it is removed
+    # below. If it is not expected to be present (i.e. os.linesep !=
+    # '\r\n' as in Windows), a warning is issued below if this file
+    # is processed.
+
+    if filename == '-':
+      lines = codecs.StreamReaderWriter(sys.stdin,
+                                        codecs.getreader('utf8'),
+                                        codecs.getwriter('utf8'),
+                                        'replace').read().split('\n')
+    else:
+      lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\n')
+
+    carriage_return_found = False
+    # Remove trailing '\r'.
+    for linenum in range(len(lines)):
+      if lines[linenum].endswith('\r'):
+        lines[linenum] = lines[linenum].rstrip('\r')
+        carriage_return_found = True
+
+  except IOError:
+    sys.stderr.write(
+        "Skipping input '%s': Can't open for reading\n" % filename)
+    return
+
+  # Note, if no dot is found, this will give the entire filename as the ext.
+  file_extension = filename[filename.rfind('.') + 1:]
+
+  # When reading from stdin, the extension is unknown, so no cpplint tests
+  # should rely on the extension.
+  if (filename != '-' and file_extension != 'cc' and file_extension != 'h'
+      and file_extension != 'cpp'):
+    sys.stderr.write('Ignoring %s; not a .cc or .h file\n' % filename)
+  else:
+    ProcessFileData(filename, file_extension, lines, Error,
+                    extra_check_functions)
+    if carriage_return_found and os.linesep != '\r\n':
+      # Use 0 for linenum since outputting only one error for potentially
+      # several lines.
+      Error(filename, 0, 'whitespace/newline', 1,
+            'One or more unexpected \\r (^M) found;'
+            'better to use only a \\n')
+
+  sys.stderr.write('Done processing %s\n' % filename)
+
+
+def PrintUsage(message):
+  """Prints a brief usage string and exits, optionally with an error message.
+
+  Args:
+    message: The optional error message.
+  """
+  sys.stderr.write(_USAGE)
+  if message:
+    sys.exit('\nFATAL ERROR: ' + message)
+  else:
+    sys.exit(1)
+
+
+def PrintCategories():
+  """Prints a list of all the error-categories used by error messages.
+
+  These are the categories used to filter messages via --filter.
+  """
+  sys.stderr.write(''.join('  %s\n' % cat for cat in _ERROR_CATEGORIES))
+  sys.exit(0)
+
+
+def ParseArguments(args):
+  """Parses the command line arguments.
+
+  This may set the output format and verbosity level as side-effects.
+
+  Args:
+    args: The command line arguments:
+
+  Returns:
+    The list of filenames to lint.
+  """
+  try:
+    (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=',
+                                                 'counting=',
+                                                 'filter=',
+                                                 'root='])
+  except getopt.GetoptError:
+    PrintUsage('Invalid arguments.')
+
+  verbosity = _VerboseLevel()
+  output_format = _OutputFormat()
+  filters = ''
+  counting_style = ''
+
+  for (opt, val) in opts:
+    if opt == '--help':
+      PrintUsage(None)
+    elif opt == '--output':
+      if not val in ('emacs', 'vs7', 'eclipse'):
+        PrintUsage('The only allowed output formats are emacs, vs7 and eclipse.')
+      output_format = val
+    elif opt == '--verbose':
+      verbosity = int(val)
+    elif opt == '--filter':
+      filters = val
+      if not filters:
+        PrintCategories()
+    elif opt == '--counting':
+      if val not in ('total', 'toplevel', 'detailed'):
+        PrintUsage('Valid counting options are total, toplevel, and detailed')
+      counting_style = val
+    elif opt == '--root':
+      global _root
+      _root = val
+
+  if not filenames:
+    PrintUsage('No files were specified.')
+
+  _SetOutputFormat(output_format)
+  _SetVerboseLevel(verbosity)
+  _SetFilters(filters)
+  _SetCountingStyle(counting_style)
+
+  return filenames
+
+
+def main():
+  filenames = ParseArguments(sys.argv[1:])
+
+  # Change stderr to write with replacement characters so we don't die
+  # if we try to print something containing non-ASCII characters.
+  sys.stderr = codecs.StreamReaderWriter(sys.stderr,
+                                         codecs.getreader('utf8'),
+                                         codecs.getwriter('utf8'),
+                                         'replace')
+
+  _cpplint_state.ResetErrorCounts()
+  for filename in filenames:
+    ProcessFile(filename, _cpplint_state.verbose_level)
+  _cpplint_state.PrintErrorCounts()
+
+  sys.exit(_cpplint_state.error_count > 0)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/compiler-rt/lib/sanitizer_common/scripts/gen_dynamic_list.py b/compiler-rt/lib/sanitizer_common/scripts/gen_dynamic_list.py
new file mode 100755
index 0000000..b8b79b5
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/scripts/gen_dynamic_list.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+#===- lib/sanitizer_common/scripts/gen_dynamic_list.py ---------------------===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+#
+# Generates the list of functions that should be exported from sanitizer
+# runtimes. The output format is recognized by --dynamic-list linker option.
+# Usage:
+#   gen_dynamic_list.py libclang_rt.*san*.a [ files ... ]
+#
+#===------------------------------------------------------------------------===#
+import argparse
+import os
+import re
+import subprocess
+import sys
+
+new_delete = set([
+                  '_Znam', '_ZnamRKSt9nothrow_t',    # operator new[](unsigned long)
+                  '_Znwm', '_ZnwmRKSt9nothrow_t',    # operator new(unsigned long)
+                  '_Znaj', '_ZnajRKSt9nothrow_t',    # operator new[](unsigned int)
+                  '_Znwj', '_ZnwjRKSt9nothrow_t',    # operator new(unsigned int)
+                  '_ZdaPv', '_ZdaPvRKSt9nothrow_t',  # operator delete[](void *)
+                  '_ZdlPv', '_ZdlPvRKSt9nothrow_t',  # operator delete(void *)
+                  '_ZdaPvm',                         # operator delete[](void*, unsigned long)
+                  '_ZdlPvm',                         # operator delete(void*, unsigned long)
+                  '_ZdaPvj',                         # operator delete[](void*, unsigned int)
+                  '_ZdlPvj',                         # operator delete(void*, unsigned int)
+                  ])
+
+versioned_functions = set(['memcpy', 'pthread_attr_getaffinity_np',
+                           'pthread_cond_broadcast',
+                           'pthread_cond_destroy', 'pthread_cond_init',
+                           'pthread_cond_signal', 'pthread_cond_timedwait',
+                           'pthread_cond_wait', 'realpath',
+                           'sched_getaffinity'])
+
+def get_global_functions(library):
+  functions = []
+  nm_proc = subprocess.Popen(['nm', library], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+  nm_out = nm_proc.communicate()[0].decode().split('\n')
+  if nm_proc.returncode != 0:
+    raise subprocess.CalledProcessError(nm_proc.returncode, 'nm')
+  func_symbols = ['T', 'W']
+  # On PowerPC, nm prints function descriptors from .data section.
+  if os.uname()[4] in ["powerpc", "ppc64"]:
+    func_symbols += ['D']
+  for line in nm_out:
+    cols = line.split(' ')
+    if len(cols) == 3 and cols[1] in func_symbols :
+      functions.append(cols[2])
+  return functions
+
+def main(argv):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--version-list', action='store_true')
+  parser.add_argument('--extra', default=[], action='append')
+  parser.add_argument('libraries', default=[], nargs='+')
+  args = parser.parse_args()
+
+  result = []
+
+  all_functions = []
+  for library in args.libraries:
+    all_functions.extend(get_global_functions(library))
+  function_set = set(all_functions)
+  for func in all_functions:
+    # Export new/delete operators.
+    if func in new_delete:
+      result.append(func)
+      continue
+    # Export interceptors.
+    match = re.match('__interceptor_(.*)', func)
+    if match:
+      result.append(func)
+      # We have to avoid exporting the interceptors for versioned library
+      # functions due to gold internal error.
+      orig_name = match.group(1)
+      if orig_name in function_set and (args.version_list or orig_name not in versioned_functions):
+        result.append(orig_name)
+      continue
+    # Export sanitizer interface functions.
+    if re.match('__sanitizer_(.*)', func):
+      result.append(func)
+
+  # Additional exported functions from files.
+  for fname in args.extra:
+    f = open(fname, 'r')
+    for line in f:
+      result.append(line.rstrip())
+  # Print the resulting list in the format recognized by ld.
+  print('{')
+  if args.version_list:
+    print('global:')
+  result.sort()
+  for f in result:
+    print(u'  %s;' % f)
+  if args.version_list:
+    print('local:')
+    print('  *;')
+  print('};')
+
+if __name__ == '__main__':
+  main(sys.argv)
diff --git a/compiler-rt/lib/sanitizer_common/scripts/litlint.py b/compiler-rt/lib/sanitizer_common/scripts/litlint.py
new file mode 100755
index 0000000..81b89c2
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/scripts/litlint.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+#
+# litlint
+#
+# Ensure RUN commands in lit tests are free of common errors.
+#
+# If any errors are detected, litlint returns a nonzero exit code.
+#
+
+import optparse
+import re
+import sys
+
+# Compile regex once for all files
+runRegex = re.compile(r'(?<!-o)(?<!%run) %t\s')
+
+def LintLine(s):
+  """ Validate a line
+
+  Args:
+    s: str, the line to validate
+
+  Returns:
+    Returns an error message and a 1-based column number if an error was
+    detected, otherwise (None, None).
+  """
+
+  # Check that RUN command can be executed with an emulator
+  m = runRegex.search(s)
+  if m:
+    start, end = m.span()
+    return ('missing %run before %t', start + 2)
+
+  # No errors
+  return (None, None)
+
+
+def LintFile(p):
+  """ Check that each RUN command can be executed with an emulator
+
+  Args:
+    p: str, valid path to a file
+
+  Returns:
+    The number of errors detected.
+  """
+  errs = 0
+  with open(p, 'r') as f:
+    for i, s in enumerate(f.readlines(), start=1):
+      msg, col = LintLine(s)
+      if msg != None:
+        errs += 1
+        errorMsg = 'litlint: {}:{}:{}: error: {}.\n{}{}\n'
+        arrow = (col-1) * ' ' + '^'
+        sys.stderr.write(errorMsg.format(p, i, col, msg, s, arrow))
+  return errs
+
+
+if __name__ == "__main__":
+  # Parse args
+  parser = optparse.OptionParser()
+  parser.add_option('--filter')  # ignored
+  (options, filenames) = parser.parse_args()
+
+  # Lint each file
+  errs = 0
+  for p in filenames:
+    errs += LintFile(p)
+
+  # If errors, return nonzero
+  if errs > 0:
+    sys.exit(1)
diff --git a/compiler-rt/lib/sanitizer_common/scripts/litlint_test.py b/compiler-rt/lib/sanitizer_common/scripts/litlint_test.py
new file mode 100755
index 0000000..3ce482d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/scripts/litlint_test.py
@@ -0,0 +1,23 @@
+#!/usr/bin/python
+
+# Tests for litlint.py
+#
+# Usage: python litlint_test.py
+#
+# Returns nonzero if any test fails
+
+import litlint
+import unittest
+
+class TestLintLine(unittest.TestCase):
+  def test_missing_run(self):
+    f = litlint.LintLine
+    self.assertEqual(f(' %t '),     ('missing %run before %t', 2))
+    self.assertEqual(f(' %t\n'),    ('missing %run before %t', 2))
+    self.assertEqual(f(' %t.so '),  (None, None))
+    self.assertEqual(f(' %t.o '),   (None, None))
+    self.assertEqual(f('%run %t '), (None, None))
+    self.assertEqual(f('-o %t '),   (None, None))
+
+if __name__ == '__main__':
+  unittest.main()
diff --git a/compiler-rt/lib/sanitizer_common/scripts/sancov.py b/compiler-rt/lib/sanitizer_common/scripts/sancov.py
new file mode 100755
index 0000000..a5ae957
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/scripts/sancov.py
@@ -0,0 +1,241 @@
+#!/usr/bin/env python
+# Merge or print the coverage data collected by asan's coverage.
+# Input files are sequences of 4-byte integers.
+# We need to merge these integers into a set and then
+# either print them (as hex) or dump them into another file.
+import array
+import bisect
+import glob
+import os.path
+import struct
+import subprocess
+import sys
+
+prog_name = ""
+
+def Usage():
+  print >> sys.stderr, "Usage: \n" + \
+      " " + prog_name + " merge FILE [FILE...] > OUTPUT\n" \
+      " " + prog_name + " print FILE [FILE...]\n" \
+      " " + prog_name + " unpack FILE [FILE...]\n" \
+      " " + prog_name + " rawunpack FILE [FILE ...]\n" \
+      " " + prog_name + " missing BINARY < LIST_OF_PCS\n"
+  exit(1)
+
+def CheckBits(bits):
+  if bits != 32 and bits != 64:
+    raise Exception("Wrong bitness: %d" % bits)
+
+def TypeCodeForBits(bits):
+  CheckBits(bits)
+  return 'L' if bits == 64 else 'I'
+
+kMagic32SecondHalf = 0xFFFFFF32;
+kMagic64SecondHalf = 0xFFFFFF64;
+kMagicFirstHalf    = 0xC0BFFFFF;
+
+def MagicForBits(bits):
+  CheckBits(bits)
+  if sys.byteorder == 'little':
+    return [kMagic64SecondHalf if bits == 64 else kMagic32SecondHalf, kMagicFirstHalf]
+  else:
+    return [kMagicFirstHalf, kMagic64SecondHalf if bits == 64 else kMagic32SecondHalf]
+
+def ReadMagicAndReturnBitness(f, path):
+  magic_bytes = f.read(8)
+  magic_words = struct.unpack('II', magic_bytes);
+  bits = 0
+  idx = 1 if sys.byteorder == 'little' else 0
+  if magic_words[idx] == kMagicFirstHalf:
+    if magic_words[1-idx] == kMagic64SecondHalf:
+      bits = 64
+    elif magic_words[1-idx] == kMagic32SecondHalf:
+      bits = 32
+  if bits == 0:
+    raise Exception('Bad magic word in %s' % path)
+  return bits
+
+def ReadOneFile(path):
+  with open(path, mode="rb") as f:
+    f.seek(0, 2)
+    size = f.tell()
+    f.seek(0, 0)
+    if size < 8:
+      raise Exception('File %s is short (< 8 bytes)' % path)
+    bits = ReadMagicAndReturnBitness(f, path)
+    size -= 8
+    s = array.array(TypeCodeForBits(bits), f.read(size))
+  print >>sys.stderr, "%s: read %d %d-bit PCs from %s" % (prog_name, size * 8 / bits, bits, path)
+  return s
+
+def Merge(files):
+  s = set()
+  for f in files:
+    s = s.union(set(ReadOneFile(f)))
+  print >> sys.stderr, "%s: %d files merged; %d PCs total" % \
+    (prog_name, len(files), len(s))
+  return sorted(s)
+
+def PrintFiles(files):
+  if len(files) > 1:
+    s = Merge(files)
+  else:  # If there is just on file, print the PCs in order.
+    s = ReadOneFile(files[0])
+    print >> sys.stderr, "%s: 1 file merged; %d PCs total" % \
+      (prog_name, len(s))
+  for i in s:
+    print "0x%x" % i
+
+def MergeAndPrint(files):
+  if sys.stdout.isatty():
+    Usage()
+  s = Merge(files)
+  bits = 32
+  if max(s) > 0xFFFFFFFF:
+    bits = 64
+  array.array('I', MagicForBits(bits)).tofile(sys.stdout)
+  a = array.array(TypeCodeForBits(bits), s)
+  a.tofile(sys.stdout)
+
+
+def UnpackOneFile(path):
+  with open(path, mode="rb") as f:
+    print >> sys.stderr, "%s: unpacking %s" % (prog_name, path)
+    while True:
+      header = f.read(12)
+      if not header: return
+      if len(header) < 12:
+        break
+      pid, module_length, blob_size = struct.unpack('iII', header)
+      module = f.read(module_length)
+      blob = f.read(blob_size)
+      assert(len(module) == module_length)
+      assert(len(blob) == blob_size)
+      extracted_file = "%s.%d.sancov" % (module, pid)
+      print >> sys.stderr, "%s: extracting %s" % \
+        (prog_name, extracted_file)
+      # The packed file may contain multiple blobs for the same pid/module
+      # pair. Append to the end of the file instead of overwriting.
+      with open(extracted_file, 'ab') as f2:
+        f2.write(blob)
+    # fail
+    raise Exception('Error reading file %s' % path)
+
+
+def Unpack(files):
+  for f in files:
+    UnpackOneFile(f)
+
+def UnpackOneRawFile(path, map_path):
+  mem_map = []
+  with open(map_path, mode="rt") as f_map:
+    print >> sys.stderr, "%s: reading map %s" % (prog_name, map_path)
+    bits = int(f_map.readline())
+    if bits != 32 and bits != 64:
+      raise Exception('Wrong bits size in the map')
+    for line in f_map:
+      parts = line.rstrip().split()
+      mem_map.append((int(parts[0], 16),
+                  int(parts[1], 16),
+                  int(parts[2], 16),
+                  ' '.join(parts[3:])))
+  mem_map.sort(key=lambda m : m[0])
+  mem_map_keys = [m[0] for m in mem_map]
+
+  with open(path, mode="rb") as f:
+    print >> sys.stderr, "%s: unpacking %s" % (prog_name, path)
+
+    f.seek(0, 2)
+    size = f.tell()
+    f.seek(0, 0)
+    pcs = array.array(TypeCodeForBits(bits), f.read(size))
+    mem_map_pcs = [[] for i in range(0, len(mem_map))]
+
+    for pc in pcs:
+      if pc == 0: continue
+      map_idx = bisect.bisect(mem_map_keys, pc) - 1
+      (start, end, base, module_path) = mem_map[map_idx]
+      assert pc >= start
+      if pc >= end:
+        print >> sys.stderr, "warning: %s: pc %x outside of any known mapping" % (prog_name, pc)
+        continue
+      mem_map_pcs[map_idx].append(pc - base)
+
+    for ((start, end, base, module_path), pc_list) in zip(mem_map, mem_map_pcs):
+      if len(pc_list) == 0: continue
+      assert path.endswith('.sancov.raw')
+      dst_path = module_path + '.' + os.path.basename(path)[:-4]
+      print >> sys.stderr, "%s: writing %d PCs to %s" % (prog_name, len(pc_list), dst_path)
+      arr = array.array(TypeCodeForBits(bits))
+      arr.fromlist(sorted(pc_list))
+      with open(dst_path, 'ab') as f2:
+        array.array('I', MagicForBits(bits)).tofile(f2)
+        arr.tofile(f2)
+
+def RawUnpack(files):
+  for f in files:
+    if not f.endswith('.sancov.raw'):
+      raise Exception('Unexpected raw file name %s' % f)
+    f_map = f[:-3] + 'map'
+    UnpackOneRawFile(f, f_map)
+
+def GetInstrumentedPCs(binary):
+  # This looks scary, but all it does is extract all offsets where we call:
+  # - __sanitizer_cov() or __sanitizer_cov_with_check(),
+  # - with call or callq,
+  # - directly or via PLT.
+  cmd = "objdump -d %s | " \
+        "grep '^\s\+[0-9a-f]\+:.*\scall\(q\|\)\s\+[0-9a-f]\+ <__sanitizer_cov\(_with_check\|\)\(@plt\|\)>' | " \
+        "grep '^\s\+[0-9a-f]\+' -o" % binary
+  proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                          shell=True)
+  proc.stdin.close()
+  # The PCs we get from objdump are off by 4 bytes, as they point to the
+  # beginning of the callq instruction. Empirically this is true on x86 and
+  # x86_64.
+  return set(int(line.strip(), 16) + 4 for line in proc.stdout)
+
+def PrintMissing(binary):
+  if not os.path.isfile(binary):
+    raise Exception('File not found: %s' % binary)
+  instrumented = GetInstrumentedPCs(binary)
+  print >> sys.stderr, "%s: found %d instrumented PCs in %s" % (prog_name,
+                                                                len(instrumented),
+                                                                binary)
+  covered = set(int(line, 16) for line in sys.stdin)
+  print >> sys.stderr, "%s: read %d PCs from stdin" % (prog_name, len(covered))
+  missing = instrumented - covered
+  print >> sys.stderr, "%s: %d PCs missing from coverage" % (prog_name, len(missing))
+  if (len(missing) > len(instrumented) - len(covered)):
+    print >> sys.stderr, \
+        "%s: WARNING: stdin contains PCs not found in binary" % prog_name
+  for pc in sorted(missing):
+    print "0x%x" % pc
+
+if __name__ == '__main__':
+  prog_name = sys.argv[0]
+  if len(sys.argv) <= 2:
+    Usage();
+
+  if sys.argv[1] == "missing":
+    if len(sys.argv) != 3:
+      Usage()
+    PrintMissing(sys.argv[2])
+    exit(0)
+
+  file_list = []
+  for f in sys.argv[2:]:
+    file_list += glob.glob(f)
+  if not file_list:
+    Usage()
+
+  if sys.argv[1] == "print":
+    PrintFiles(file_list)
+  elif sys.argv[1] == "merge":
+    MergeAndPrint(file_list)
+  elif sys.argv[1] == "unpack":
+    Unpack(file_list)
+  elif sys.argv[1] == "rawunpack":
+    RawUnpack(file_list)
+  else:
+    Usage()
diff --git a/compiler-rt/lib/sanitizer_common/tests/Android.bp b/compiler-rt/lib/sanitizer_common/tests/Android.bp
new file mode 100644
index 0000000..4547e6a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/Android.bp
@@ -0,0 +1,107 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+cc_defaults {
+    name: "san_test_defaults",
+
+    cppflags: [
+        "-fvisibility=hidden",
+        "-fno-exceptions",
+        "-fno-rtti",
+        "-std=c++11",
+        "-Wall",
+        "-Werror",
+        "-Wno-unused-parameter",
+        "-Wno-non-virtual-dtor",
+    ],
+
+    include_dirs: ["external/compiler-rt/lib"],
+}
+
+
+cc_test_host {
+    name: "san_test",
+    defaults: ["san_test_defaults"],
+
+    srcs: [
+        "sanitizer_allocator_test.cc",
+        "sanitizer_atomic_test.cc",
+        "sanitizer_bitvector_test.cc",
+        "sanitizer_bvgraph_test.cc",
+        "sanitizer_common_test.cc",
+        "sanitizer_deadlock_detector_test.cc",
+        "sanitizer_flags_test.cc",
+        "sanitizer_format_interceptor_test.cc",
+        "sanitizer_ioctl_test.cc",
+        "sanitizer_libc_test.cc",
+        "sanitizer_linux_test.cc",
+        "sanitizer_list_test.cc",
+        "sanitizer_mutex_test.cc",
+        "sanitizer_nolibc_test.cc",
+        "sanitizer_posix_test.cc",
+        "sanitizer_printf_test.cc",
+        "sanitizer_procmaps_test.cc",
+        "sanitizer_stackdepot_test.cc",
+        "sanitizer_stacktrace_printer_test.cc",
+        "sanitizer_stacktrace_test.cc",
+        "sanitizer_stoptheworld_test.cc",
+        "sanitizer_suppressions_test.cc",
+        "sanitizer_test_main.cc",
+        "sanitizer_thread_registry_test.cc",
+    ],
+    static_libs: ["libsan"],
+    host_ldlibs: [
+        "-ldl",
+        "-lrt",
+    ],
+    sanitize: {
+        never: true,
+    },
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_binary_host {
+    name: "san_test-Nolibc",
+    defaults: ["san_test_defaults"],
+
+    include_dirs: ["external/gtest/include"],
+    srcs: ["sanitizer_nolibc_test_main.cc"],
+    static_libs: [
+        "libsan",
+        "libgtest_host",
+    ],
+    ldflags: [
+        "-nostdlib",
+        "-Qunused-arguments",
+    ],
+    host_ldlibs: [
+        "-ldl",
+        "-lrt",
+    ],
+    sanitize: {
+        never: true,
+    },
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/CMakeLists.txt b/compiler-rt/lib/sanitizer_common/tests/CMakeLists.txt
new file mode 100644
index 0000000..18b7636
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/CMakeLists.txt
@@ -0,0 +1,211 @@
+include(CompilerRTCompile)
+
+clang_compiler_add_cxx_check()
+
+# FIXME: use SANITIZER_COMMON_SUPPORTED_ARCH here
+filter_available_targets(SANITIZER_UNITTEST_SUPPORTED_ARCH x86_64 i386 mips64 mips64el)
+if(APPLE)
+  darwin_filter_host_archs(SANITIZER_UNITTEST_SUPPORTED_ARCH SANITIZER_COMMON_SUPPORTED_ARCH)
+endif()
+
+set(SANITIZER_UNITTESTS
+  sanitizer_allocator_test.cc
+  sanitizer_atomic_test.cc
+  sanitizer_bitvector_test.cc
+  sanitizer_bvgraph_test.cc
+  sanitizer_common_test.cc
+  sanitizer_deadlock_detector_test.cc
+  sanitizer_flags_test.cc
+  sanitizer_format_interceptor_test.cc
+  sanitizer_ioctl_test.cc
+  sanitizer_libc_test.cc
+  sanitizer_linux_test.cc
+  sanitizer_list_test.cc
+  sanitizer_mutex_test.cc
+  sanitizer_nolibc_test.cc
+  sanitizer_posix_test.cc
+  sanitizer_printf_test.cc
+  sanitizer_procmaps_test.cc
+  sanitizer_stackdepot_test.cc
+  sanitizer_stacktrace_printer_test.cc
+  sanitizer_stacktrace_test.cc
+  sanitizer_stoptheworld_test.cc
+  sanitizer_suppressions_test.cc
+  sanitizer_symbolizer_test.cc
+  sanitizer_test_main.cc
+  sanitizer_thread_registry_test.cc)
+
+set(SANITIZER_TEST_HEADERS
+  sanitizer_pthread_wrappers.h
+  sanitizer_test_config.h
+  sanitizer_test_utils.h)
+foreach(header ${SANITIZER_HEADERS})
+  list(APPEND SANITIZER_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
+endforeach()
+
+set(SANITIZER_TEST_CFLAGS_COMMON
+  ${COMPILER_RT_TEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/include
+  -I${COMPILER_RT_SOURCE_DIR}/lib
+  -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common
+  -fno-rtti
+  -O2
+  -Werror=sign-compare
+  -Wno-non-virtual-dtor)
+
+if(MSVC)
+  # Disable exceptions on Windows until they work reliably.
+  list(APPEND SANITIZER_TEST_CFLAGS_COMMON -fno-exceptions -DGTEST_HAS_SEH=0)
+endif()
+
+# -gline-tables-only must be enough for these tests, so use it if possible.
+if(COMPILER_RT_TEST_COMPILER_ID MATCHES "Clang")
+  list(APPEND SANITIZER_TEST_CFLAGS_COMMON -gline-tables-only)
+else()
+  list(APPEND SANITIZER_TEST_CFLAGS_COMMON -g)
+endif()
+
+if(NOT MSVC)
+  list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON --driver-mode=g++)
+endif()
+
+if(ANDROID)
+  list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON -pie)
+endif()
+
+set(SANITIZER_TEST_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBLOG log SANITIZER_TEST_LINK_LIBS)
+# NDK r10 requires -latomic almost always.
+append_list_if(ANDROID atomic SANITIZER_TEST_LINK_LIBS)
+
+append_list_if(COMPILER_RT_HAS_LIBDL -ldl SANITIZER_TEST_LINK_FLAGS_COMMON)
+append_list_if(COMPILER_RT_HAS_LIBRT -lrt SANITIZER_TEST_LINK_FLAGS_COMMON)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread SANITIZER_TEST_LINK_FLAGS_COMMON)
+# x86_64 FreeBSD 9.2 additionally requires libc++ to build the tests. Also,
+# 'libm' shall be specified explicitly to build i386 tests.
+if(CMAKE_SYSTEM MATCHES "FreeBSD-9.2-RELEASE")
+  list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON "-lc++ -lm")
+endif()
+
+include_directories(..)
+include_directories(../..)
+
+# Adds static library which contains sanitizer_common object file
+# (universal binary on Mac and arch-specific object files on Linux).
+macro(add_sanitizer_common_lib library)
+  add_library(${library} STATIC ${ARGN})
+  set_target_properties(${library} PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+endmacro()
+
+function(get_sanitizer_common_lib_for_arch arch lib lib_name)
+  if(APPLE)
+    set(tgt_name "RTSanitizerCommon.test.osx")
+  else()
+    set(tgt_name "RTSanitizerCommon.test.${arch}")
+  endif()
+  set(${lib} "${tgt_name}" PARENT_SCOPE)
+  if(NOT MSVC)
+    set(${lib_name} "lib${tgt_name}.a" PARENT_SCOPE)
+  else()
+    set(${lib_name} "${tgt_name}.lib" PARENT_SCOPE)
+  endif()
+endfunction()
+
+# Sanitizer_common unit tests testsuite.
+add_custom_target(SanitizerUnitTests)
+set_target_properties(SanitizerUnitTests PROPERTIES
+  FOLDER "Sanitizer unittests")
+
+# Adds sanitizer tests for architecture.
+macro(add_sanitizer_tests_for_arch arch)
+  get_target_flags_for_arch(${arch} TARGET_FLAGS)
+  set(SANITIZER_TEST_SOURCES ${SANITIZER_UNITTESTS}
+                             ${COMPILER_RT_GTEST_SOURCE})
+  set(SANITIZER_TEST_COMPILE_DEPS ${SANITIZER_TEST_HEADERS})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND SANITIZER_TEST_COMPILE_DEPS gtest)
+  endif()
+  set(SANITIZER_TEST_OBJECTS)
+  foreach(source ${SANITIZER_TEST_SOURCES})
+    get_filename_component(basename ${source} NAME)
+    set(output_obj "${basename}.${arch}.o")
+    clang_compile(${output_obj} ${source}
+                  CFLAGS ${SANITIZER_TEST_CFLAGS_COMMON} ${TARGET_FLAGS}
+                  DEPS ${SANITIZER_TEST_COMPILE_DEPS})
+    list(APPEND SANITIZER_TEST_OBJECTS ${output_obj})
+  endforeach()
+  get_sanitizer_common_lib_for_arch(${arch} SANITIZER_COMMON_LIB
+                                    SANITIZER_COMMON_LIB_NAME)
+  # Add unittest target.
+  set(SANITIZER_TEST_NAME "Sanitizer-${arch}-Test")
+  add_compiler_rt_test(SanitizerUnitTests ${SANITIZER_TEST_NAME}
+                       OBJECTS ${SANITIZER_TEST_OBJECTS}
+                               ${SANITIZER_COMMON_LIB_NAME}
+                       DEPS ${SANITIZER_TEST_OBJECTS} ${SANITIZER_COMMON_LIB}
+                       LINK_FLAGS ${SANITIZER_TEST_LINK_FLAGS_COMMON}
+                                  ${TARGET_FLAGS})
+
+  if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND "${arch}" STREQUAL "x86_64")
+    # Test that the libc-independent part of sanitizer_common is indeed
+    # independent of libc, by linking this binary without libc (here) and
+    # executing it (unit test in sanitizer_nolibc_test.cc).
+    clang_compile(sanitizer_nolibc_test_main.${arch}.o
+                  sanitizer_nolibc_test_main.cc
+                  CFLAGS ${SANITIZER_TEST_CFLAGS_COMMON} ${TARGET_FLAGS}
+                  DEPS ${SANITIZER_TEST_COMPILE_DEPS})
+    add_compiler_rt_test(SanitizerUnitTests "Sanitizer-${arch}-Test-Nolibc"
+                         OBJECTS sanitizer_nolibc_test_main.${arch}.o
+                                 -Wl,-whole-archive
+                                 libRTSanitizerCommon.test.nolibc.${arch}.a
+                                 -Wl,-no-whole-archive
+                         DEPS sanitizer_nolibc_test_main.${arch}.o
+                              RTSanitizerCommon.test.nolibc.${arch}
+                         LINK_FLAGS -nostdlib ${TARGET_FLAGS})
+  endif()
+endmacro()
+
+if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
+  # We use just-built clang to build sanitizer_common unittests, so we must
+  # be sure that produced binaries would work.
+  if(APPLE)
+    add_sanitizer_common_lib("RTSanitizerCommon.test.osx"
+                             $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+                             $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>)
+  else()
+    if(CAN_TARGET_x86_64)
+      add_sanitizer_common_lib("RTSanitizerCommon.test.nolibc.x86_64"
+                               $<TARGET_OBJECTS:RTSanitizerCommon.x86_64>
+                               $<TARGET_OBJECTS:RTSanitizerCommonNoLibc.x86_64>)
+    endif()
+    foreach(arch ${SANITIZER_UNITTEST_SUPPORTED_ARCH})
+      add_sanitizer_common_lib("RTSanitizerCommon.test.${arch}"
+                               $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+                               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
+    endforeach()
+  endif()
+  foreach(arch ${SANITIZER_UNITTEST_SUPPORTED_ARCH})
+    add_sanitizer_tests_for_arch(${arch})
+  endforeach()
+endif()
+
+if(ANDROID)
+  foreach(arch ${SANITIZER_COMMON_SUPPORTED_ARCH})
+    add_executable(SanitizerTest
+      ${SANITIZER_UNITTESTS}
+      ${COMPILER_RT_GTEST_SOURCE}
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
+    set_target_compile_flags(SanitizerTest
+      ${SANITIZER_COMMON_CFLAGS}
+      ${SANITIZER_TEST_CFLAGS_COMMON})
+    # Setup correct output directory and link flags.
+    set_target_properties(SanitizerTest PROPERTIES
+      RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    set_target_link_flags(SanitizerTest ${SANITIZER_TEST_LINK_FLAGS_COMMON})
+    target_link_libraries(SanitizerTest ${SANITIZER_TEST_LINK_LIBS})
+    # Add unit test to test suite.
+    add_dependencies(SanitizerUnitTests SanitizerTest)
+  endforeach()
+endif()
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_test.cc
new file mode 100644
index 0000000..7ba3345
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_test.cc
@@ -0,0 +1,862 @@
+//===-- sanitizer_allocator_test.cc ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Tests for sanitizer_allocator.h.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+#include "sanitizer_test_utils.h"
+#include "sanitizer_pthread_wrappers.h"
+
+#include "gtest/gtest.h"
+
+#include <stdlib.h>
+#include <algorithm>
+#include <vector>
+#include <set>
+
+// Too slow for debug build
+#if !SANITIZER_DEBUG
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+static const uptr kAllocatorSpace = 0x700000000000ULL;
+static const uptr kAllocatorSize  = 0x010000000000ULL;  // 1T.
+static const u64 kAddressSpaceSize = 1ULL << 47;
+
+typedef SizeClassAllocator64<
+  kAllocatorSpace, kAllocatorSize, 16, DefaultSizeClassMap> Allocator64;
+
+typedef SizeClassAllocator64<
+  kAllocatorSpace, kAllocatorSize, 16, CompactSizeClassMap> Allocator64Compact;
+#elif defined(__mips64)
+static const u64 kAddressSpaceSize = 1ULL << 40;
+#elif defined(__aarch64__)
+static const u64 kAddressSpaceSize = 1ULL << 39;
+#else
+static const u64 kAddressSpaceSize = 1ULL << 32;
+#endif
+
+static const uptr kRegionSizeLog = FIRST_32_SECOND_64(20, 24);
+static const uptr kFlatByteMapSize = kAddressSpaceSize >> kRegionSizeLog;
+
+typedef SizeClassAllocator32<
+  0, kAddressSpaceSize,
+  /*kMetadataSize*/16,
+  CompactSizeClassMap,
+  kRegionSizeLog,
+  FlatByteMap<kFlatByteMapSize> >
+  Allocator32Compact;
+
+template <class SizeClassMap>
+void TestSizeClassMap() {
+  typedef SizeClassMap SCMap;
+  // SCMap::Print();
+  SCMap::Validate();
+}
+
+TEST(SanitizerCommon, DefaultSizeClassMap) {
+  TestSizeClassMap<DefaultSizeClassMap>();
+}
+
+TEST(SanitizerCommon, CompactSizeClassMap) {
+  TestSizeClassMap<CompactSizeClassMap>();
+}
+
+TEST(SanitizerCommon, InternalSizeClassMap) {
+  TestSizeClassMap<InternalSizeClassMap>();
+}
+
+template <class Allocator>
+void TestSizeClassAllocator() {
+  Allocator *a = new Allocator;
+  a->Init();
+  SizeClassAllocatorLocalCache<Allocator> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+
+  static const uptr sizes[] = {1, 16, 30, 40, 100, 1000, 10000,
+    50000, 60000, 100000, 120000, 300000, 500000, 1000000, 2000000};
+
+  std::vector<void *> allocated;
+
+  uptr last_total_allocated = 0;
+  for (int i = 0; i < 3; i++) {
+    // Allocate a bunch of chunks.
+    for (uptr s = 0; s < ARRAY_SIZE(sizes); s++) {
+      uptr size = sizes[s];
+      if (!a->CanAllocate(size, 1)) continue;
+      // printf("s = %ld\n", size);
+      uptr n_iter = std::max((uptr)6, 4000000 / size);
+      // fprintf(stderr, "size: %ld iter: %ld\n", size, n_iter);
+      for (uptr i = 0; i < n_iter; i++) {
+        uptr class_id0 = Allocator::SizeClassMapT::ClassID(size);
+        char *x = (char*)cache.Allocate(a, class_id0);
+        x[0] = 0;
+        x[size - 1] = 0;
+        x[size / 2] = 0;
+        allocated.push_back(x);
+        CHECK_EQ(x, a->GetBlockBegin(x));
+        CHECK_EQ(x, a->GetBlockBegin(x + size - 1));
+        CHECK(a->PointerIsMine(x));
+        CHECK(a->PointerIsMine(x + size - 1));
+        CHECK(a->PointerIsMine(x + size / 2));
+        CHECK_GE(a->GetActuallyAllocatedSize(x), size);
+        uptr class_id = a->GetSizeClass(x);
+        CHECK_EQ(class_id, Allocator::SizeClassMapT::ClassID(size));
+        uptr *metadata = reinterpret_cast<uptr*>(a->GetMetaData(x));
+        metadata[0] = reinterpret_cast<uptr>(x) + 1;
+        metadata[1] = 0xABCD;
+      }
+    }
+    // Deallocate all.
+    for (uptr i = 0; i < allocated.size(); i++) {
+      void *x = allocated[i];
+      uptr *metadata = reinterpret_cast<uptr*>(a->GetMetaData(x));
+      CHECK_EQ(metadata[0], reinterpret_cast<uptr>(x) + 1);
+      CHECK_EQ(metadata[1], 0xABCD);
+      cache.Deallocate(a, a->GetSizeClass(x), x);
+    }
+    allocated.clear();
+    uptr total_allocated = a->TotalMemoryUsed();
+    if (last_total_allocated == 0)
+      last_total_allocated = total_allocated;
+    CHECK_EQ(last_total_allocated, total_allocated);
+  }
+
+  // Check that GetBlockBegin never crashes.
+  for (uptr x = 0, step = kAddressSpaceSize / 100000;
+       x < kAddressSpaceSize - step; x += step)
+    if (a->PointerIsMine(reinterpret_cast<void *>(x)))
+      Ident(a->GetBlockBegin(reinterpret_cast<void *>(x)));
+
+  a->TestOnlyUnmap();
+  delete a;
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64) {
+  TestSizeClassAllocator<Allocator64>();
+}
+
+TEST(SanitizerCommon, SizeClassAllocator64Compact) {
+  TestSizeClassAllocator<Allocator64Compact>();
+}
+#endif
+
+TEST(SanitizerCommon, SizeClassAllocator32Compact) {
+  TestSizeClassAllocator<Allocator32Compact>();
+}
+
+template <class Allocator>
+void SizeClassAllocatorMetadataStress() {
+  Allocator *a = new Allocator;
+  a->Init();
+  SizeClassAllocatorLocalCache<Allocator> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+
+  const uptr kNumAllocs = 1 << 13;
+  void *allocated[kNumAllocs];
+  void *meta[kNumAllocs];
+  for (uptr i = 0; i < kNumAllocs; i++) {
+    void *x = cache.Allocate(a, 1 + i % 50);
+    allocated[i] = x;
+    meta[i] = a->GetMetaData(x);
+  }
+  // Get Metadata kNumAllocs^2 times.
+  for (uptr i = 0; i < kNumAllocs * kNumAllocs; i++) {
+    uptr idx = i % kNumAllocs;
+    void *m = a->GetMetaData(allocated[idx]);
+    EXPECT_EQ(m, meta[idx]);
+  }
+  for (uptr i = 0; i < kNumAllocs; i++) {
+    cache.Deallocate(a, 1 + i % 50, allocated[i]);
+  }
+
+  a->TestOnlyUnmap();
+  delete a;
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64MetadataStress) {
+  SizeClassAllocatorMetadataStress<Allocator64>();
+}
+
+TEST(SanitizerCommon, SizeClassAllocator64CompactMetadataStress) {
+  SizeClassAllocatorMetadataStress<Allocator64Compact>();
+}
+#endif  // SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator32CompactMetadataStress) {
+  SizeClassAllocatorMetadataStress<Allocator32Compact>();
+}
+
+template <class Allocator>
+void SizeClassAllocatorGetBlockBeginStress() {
+  Allocator *a = new Allocator;
+  a->Init();
+  SizeClassAllocatorLocalCache<Allocator> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+
+  uptr max_size_class = Allocator::kNumClasses - 1;
+  uptr size = Allocator::SizeClassMapT::Size(max_size_class);
+  u64 G8 = 1ULL << 33;
+  // Make sure we correctly compute GetBlockBegin() w/o overflow.
+  for (size_t i = 0; i <= G8 / size; i++) {
+    void *x = cache.Allocate(a, max_size_class);
+    void *beg = a->GetBlockBegin(x);
+    // if ((i & (i - 1)) == 0)
+    //   fprintf(stderr, "[%zd] %p %p\n", i, x, beg);
+    EXPECT_EQ(x, beg);
+  }
+
+  a->TestOnlyUnmap();
+  delete a;
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64GetBlockBegin) {
+  SizeClassAllocatorGetBlockBeginStress<Allocator64>();
+}
+TEST(SanitizerCommon, SizeClassAllocator64CompactGetBlockBegin) {
+  SizeClassAllocatorGetBlockBeginStress<Allocator64Compact>();
+}
+TEST(SanitizerCommon, SizeClassAllocator32CompactGetBlockBegin) {
+  SizeClassAllocatorGetBlockBeginStress<Allocator32Compact>();
+}
+#endif  // SANITIZER_CAN_USE_ALLOCATOR64
+
+struct TestMapUnmapCallback {
+  static int map_count, unmap_count;
+  void OnMap(uptr p, uptr size) const { map_count++; }
+  void OnUnmap(uptr p, uptr size) const { unmap_count++; }
+};
+int TestMapUnmapCallback::map_count;
+int TestMapUnmapCallback::unmap_count;
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64MapUnmapCallback) {
+  TestMapUnmapCallback::map_count = 0;
+  TestMapUnmapCallback::unmap_count = 0;
+  typedef SizeClassAllocator64<
+      kAllocatorSpace, kAllocatorSize, 16, DefaultSizeClassMap,
+      TestMapUnmapCallback> Allocator64WithCallBack;
+  Allocator64WithCallBack *a = new Allocator64WithCallBack;
+  a->Init();
+  EXPECT_EQ(TestMapUnmapCallback::map_count, 1);  // Allocator state.
+  SizeClassAllocatorLocalCache<Allocator64WithCallBack> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+  AllocatorStats stats;
+  stats.Init();
+  a->AllocateBatch(&stats, &cache, 32);
+  EXPECT_EQ(TestMapUnmapCallback::map_count, 3);  // State + alloc + metadata.
+  a->TestOnlyUnmap();
+  EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);  // The whole thing.
+  delete a;
+}
+#endif
+
+TEST(SanitizerCommon, SizeClassAllocator32MapUnmapCallback) {
+  TestMapUnmapCallback::map_count = 0;
+  TestMapUnmapCallback::unmap_count = 0;
+  typedef SizeClassAllocator32<
+      0, kAddressSpaceSize,
+      /*kMetadataSize*/16,
+      CompactSizeClassMap,
+      kRegionSizeLog,
+      FlatByteMap<kFlatByteMapSize>,
+      TestMapUnmapCallback>
+    Allocator32WithCallBack;
+  Allocator32WithCallBack *a = new Allocator32WithCallBack;
+  a->Init();
+  EXPECT_EQ(TestMapUnmapCallback::map_count, 0);
+  SizeClassAllocatorLocalCache<Allocator32WithCallBack>  cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+  AllocatorStats stats;
+  stats.Init();
+  a->AllocateBatch(&stats, &cache, 32);
+  EXPECT_EQ(TestMapUnmapCallback::map_count, 1);
+  a->TestOnlyUnmap();
+  EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);
+  delete a;
+  // fprintf(stderr, "Map: %d Unmap: %d\n",
+  //         TestMapUnmapCallback::map_count,
+  //         TestMapUnmapCallback::unmap_count);
+}
+
+TEST(SanitizerCommon, LargeMmapAllocatorMapUnmapCallback) {
+  TestMapUnmapCallback::map_count = 0;
+  TestMapUnmapCallback::unmap_count = 0;
+  LargeMmapAllocator<TestMapUnmapCallback> a;
+  a.Init(/* may_return_null */ false);
+  AllocatorStats stats;
+  stats.Init();
+  void *x = a.Allocate(&stats, 1 << 20, 1);
+  EXPECT_EQ(TestMapUnmapCallback::map_count, 1);
+  a.Deallocate(&stats, x);
+  EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);
+}
+
+template<class Allocator>
+void FailInAssertionOnOOM() {
+  Allocator a;
+  a.Init();
+  SizeClassAllocatorLocalCache<Allocator> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+  AllocatorStats stats;
+  stats.Init();
+  for (int i = 0; i < 1000000; i++) {
+    a.AllocateBatch(&stats, &cache, 52);
+  }
+
+  a.TestOnlyUnmap();
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64Overflow) {
+  EXPECT_DEATH(FailInAssertionOnOOM<Allocator64>(), "Out of memory");
+}
+#endif
+
+#if !defined(_WIN32)  // FIXME: This currently fails on Windows.
+TEST(SanitizerCommon, LargeMmapAllocator) {
+  LargeMmapAllocator<> a;
+  a.Init(/* may_return_null */ false);
+  AllocatorStats stats;
+  stats.Init();
+
+  static const int kNumAllocs = 1000;
+  char *allocated[kNumAllocs];
+  static const uptr size = 4000;
+  // Allocate some.
+  for (int i = 0; i < kNumAllocs; i++) {
+    allocated[i] = (char *)a.Allocate(&stats, size, 1);
+    CHECK(a.PointerIsMine(allocated[i]));
+  }
+  // Deallocate all.
+  CHECK_GT(a.TotalMemoryUsed(), size * kNumAllocs);
+  for (int i = 0; i < kNumAllocs; i++) {
+    char *p = allocated[i];
+    CHECK(a.PointerIsMine(p));
+    a.Deallocate(&stats, p);
+  }
+  // Check that non left.
+  CHECK_EQ(a.TotalMemoryUsed(), 0);
+
+  // Allocate some more, also add metadata.
+  for (int i = 0; i < kNumAllocs; i++) {
+    char *x = (char *)a.Allocate(&stats, size, 1);
+    CHECK_GE(a.GetActuallyAllocatedSize(x), size);
+    uptr *meta = reinterpret_cast<uptr*>(a.GetMetaData(x));
+    *meta = i;
+    allocated[i] = x;
+  }
+  for (int i = 0; i < kNumAllocs * kNumAllocs; i++) {
+    char *p = allocated[i % kNumAllocs];
+    CHECK(a.PointerIsMine(p));
+    CHECK(a.PointerIsMine(p + 2000));
+  }
+  CHECK_GT(a.TotalMemoryUsed(), size * kNumAllocs);
+  // Deallocate all in reverse order.
+  for (int i = 0; i < kNumAllocs; i++) {
+    int idx = kNumAllocs - i - 1;
+    char *p = allocated[idx];
+    uptr *meta = reinterpret_cast<uptr*>(a.GetMetaData(p));
+    CHECK_EQ(*meta, idx);
+    CHECK(a.PointerIsMine(p));
+    a.Deallocate(&stats, p);
+  }
+  CHECK_EQ(a.TotalMemoryUsed(), 0);
+
+  // Test alignments.
+  uptr max_alignment = SANITIZER_WORDSIZE == 64 ? (1 << 28) : (1 << 24);
+  for (uptr alignment = 8; alignment <= max_alignment; alignment *= 2) {
+    const uptr kNumAlignedAllocs = 100;
+    for (uptr i = 0; i < kNumAlignedAllocs; i++) {
+      uptr size = ((i % 10) + 1) * 4096;
+      char *p = allocated[i] = (char *)a.Allocate(&stats, size, alignment);
+      CHECK_EQ(p, a.GetBlockBegin(p));
+      CHECK_EQ(p, a.GetBlockBegin(p + size - 1));
+      CHECK_EQ(p, a.GetBlockBegin(p + size / 2));
+      CHECK_EQ(0, (uptr)allocated[i] % alignment);
+      p[0] = p[size - 1] = 0;
+    }
+    for (uptr i = 0; i < kNumAlignedAllocs; i++) {
+      a.Deallocate(&stats, allocated[i]);
+    }
+  }
+
+  // Regression test for boundary condition in GetBlockBegin().
+  uptr page_size = GetPageSizeCached();
+  char *p = (char *)a.Allocate(&stats, page_size, 1);
+  CHECK_EQ(p, a.GetBlockBegin(p));
+  CHECK_EQ(p, (char *)a.GetBlockBegin(p + page_size - 1));
+  CHECK_NE(p, (char *)a.GetBlockBegin(p + page_size));
+  a.Deallocate(&stats, p);
+}
+#endif
+
+template
+<class PrimaryAllocator, class SecondaryAllocator, class AllocatorCache>
+void TestCombinedAllocator() {
+  typedef
+      CombinedAllocator<PrimaryAllocator, AllocatorCache, SecondaryAllocator>
+      Allocator;
+  Allocator *a = new Allocator;
+  a->Init(/* may_return_null */ true);
+
+  AllocatorCache cache;
+  memset(&cache, 0, sizeof(cache));
+  a->InitCache(&cache);
+
+  EXPECT_EQ(a->Allocate(&cache, -1, 1), (void*)0);
+  EXPECT_EQ(a->Allocate(&cache, -1, 1024), (void*)0);
+  EXPECT_EQ(a->Allocate(&cache, (uptr)-1 - 1024, 1), (void*)0);
+  EXPECT_EQ(a->Allocate(&cache, (uptr)-1 - 1024, 1024), (void*)0);
+  EXPECT_EQ(a->Allocate(&cache, (uptr)-1 - 1023, 1024), (void*)0);
+
+  // Set to false
+  a->SetMayReturnNull(false);
+  EXPECT_DEATH(a->Allocate(&cache, -1, 1),
+               "allocator is terminating the process");
+
+  const uptr kNumAllocs = 100000;
+  const uptr kNumIter = 10;
+  for (uptr iter = 0; iter < kNumIter; iter++) {
+    std::vector<void*> allocated;
+    for (uptr i = 0; i < kNumAllocs; i++) {
+      uptr size = (i % (1 << 14)) + 1;
+      if ((i % 1024) == 0)
+        size = 1 << (10 + (i % 14));
+      void *x = a->Allocate(&cache, size, 1);
+      uptr *meta = reinterpret_cast<uptr*>(a->GetMetaData(x));
+      CHECK_EQ(*meta, 0);
+      *meta = size;
+      allocated.push_back(x);
+    }
+
+    random_shuffle(allocated.begin(), allocated.end());
+
+    for (uptr i = 0; i < kNumAllocs; i++) {
+      void *x = allocated[i];
+      uptr *meta = reinterpret_cast<uptr*>(a->GetMetaData(x));
+      CHECK_NE(*meta, 0);
+      CHECK(a->PointerIsMine(x));
+      *meta = 0;
+      a->Deallocate(&cache, x);
+    }
+    allocated.clear();
+    a->SwallowCache(&cache);
+  }
+  a->DestroyCache(&cache);
+  a->TestOnlyUnmap();
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, CombinedAllocator64) {
+  TestCombinedAllocator<Allocator64,
+      LargeMmapAllocator<>,
+      SizeClassAllocatorLocalCache<Allocator64> > ();
+}
+
+TEST(SanitizerCommon, CombinedAllocator64Compact) {
+  TestCombinedAllocator<Allocator64Compact,
+      LargeMmapAllocator<>,
+      SizeClassAllocatorLocalCache<Allocator64Compact> > ();
+}
+#endif
+
+#if !defined(_WIN32)  // FIXME: This currently fails on Windows.
+TEST(SanitizerCommon, CombinedAllocator32Compact) {
+  TestCombinedAllocator<Allocator32Compact,
+      LargeMmapAllocator<>,
+      SizeClassAllocatorLocalCache<Allocator32Compact> > ();
+}
+#endif
+
+template <class AllocatorCache>
+void TestSizeClassAllocatorLocalCache() {
+  AllocatorCache cache;
+  typedef typename AllocatorCache::Allocator Allocator;
+  Allocator *a = new Allocator();
+
+  a->Init();
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+
+  const uptr kNumAllocs = 10000;
+  const int kNumIter = 100;
+  uptr saved_total = 0;
+  for (int class_id = 1; class_id <= 5; class_id++) {
+    for (int it = 0; it < kNumIter; it++) {
+      void *allocated[kNumAllocs];
+      for (uptr i = 0; i < kNumAllocs; i++) {
+        allocated[i] = cache.Allocate(a, class_id);
+      }
+      for (uptr i = 0; i < kNumAllocs; i++) {
+        cache.Deallocate(a, class_id, allocated[i]);
+      }
+      cache.Drain(a);
+      uptr total_allocated = a->TotalMemoryUsed();
+      if (it)
+        CHECK_EQ(saved_total, total_allocated);
+      saved_total = total_allocated;
+    }
+  }
+
+  a->TestOnlyUnmap();
+  delete a;
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64LocalCache) {
+  TestSizeClassAllocatorLocalCache<
+      SizeClassAllocatorLocalCache<Allocator64> >();
+}
+
+TEST(SanitizerCommon, SizeClassAllocator64CompactLocalCache) {
+  TestSizeClassAllocatorLocalCache<
+      SizeClassAllocatorLocalCache<Allocator64Compact> >();
+}
+#endif
+
+TEST(SanitizerCommon, SizeClassAllocator32CompactLocalCache) {
+  TestSizeClassAllocatorLocalCache<
+      SizeClassAllocatorLocalCache<Allocator32Compact> >();
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+typedef SizeClassAllocatorLocalCache<Allocator64> AllocatorCache;
+static AllocatorCache static_allocator_cache;
+
+void *AllocatorLeakTestWorker(void *arg) {
+  typedef AllocatorCache::Allocator Allocator;
+  Allocator *a = (Allocator*)(arg);
+  static_allocator_cache.Allocate(a, 10);
+  static_allocator_cache.Drain(a);
+  return 0;
+}
+
+TEST(SanitizerCommon, AllocatorLeakTest) {
+  typedef AllocatorCache::Allocator Allocator;
+  Allocator a;
+  a.Init();
+  uptr total_used_memory = 0;
+  for (int i = 0; i < 100; i++) {
+    pthread_t t;
+    PTHREAD_CREATE(&t, 0, AllocatorLeakTestWorker, &a);
+    PTHREAD_JOIN(t, 0);
+    if (i == 0)
+      total_used_memory = a.TotalMemoryUsed();
+    EXPECT_EQ(a.TotalMemoryUsed(), total_used_memory);
+  }
+
+  a.TestOnlyUnmap();
+}
+
+// Struct which is allocated to pass info to new threads.  The new thread frees
+// it.
+struct NewThreadParams {
+  AllocatorCache *thread_cache;
+  AllocatorCache::Allocator *allocator;
+  uptr class_id;
+};
+
+// Called in a new thread.  Just frees its argument.
+static void *DeallocNewThreadWorker(void *arg) {
+  NewThreadParams *params = reinterpret_cast<NewThreadParams*>(arg);
+  params->thread_cache->Deallocate(params->allocator, params->class_id, params);
+  return NULL;
+}
+
+// The allocator cache is supposed to be POD and zero initialized.  We should be
+// able to call Deallocate on a zeroed cache, and it will self-initialize.
+TEST(Allocator, AllocatorCacheDeallocNewThread) {
+  AllocatorCache::Allocator allocator;
+  allocator.Init();
+  AllocatorCache main_cache;
+  AllocatorCache child_cache;
+  memset(&main_cache, 0, sizeof(main_cache));
+  memset(&child_cache, 0, sizeof(child_cache));
+
+  uptr class_id = DefaultSizeClassMap::ClassID(sizeof(NewThreadParams));
+  NewThreadParams *params = reinterpret_cast<NewThreadParams*>(
+      main_cache.Allocate(&allocator, class_id));
+  params->thread_cache = &child_cache;
+  params->allocator = &allocator;
+  params->class_id = class_id;
+  pthread_t t;
+  PTHREAD_CREATE(&t, 0, DeallocNewThreadWorker, params);
+  PTHREAD_JOIN(t, 0);
+}
+#endif
+
+TEST(Allocator, Basic) {
+  char *p = (char*)InternalAlloc(10);
+  EXPECT_NE(p, (char*)0);
+  char *p2 = (char*)InternalAlloc(20);
+  EXPECT_NE(p2, (char*)0);
+  EXPECT_NE(p2, p);
+  InternalFree(p);
+  InternalFree(p2);
+}
+
+TEST(Allocator, Stress) {
+  const int kCount = 1000;
+  char *ptrs[kCount];
+  unsigned rnd = 42;
+  for (int i = 0; i < kCount; i++) {
+    uptr sz = my_rand_r(&rnd) % 1000;
+    char *p = (char*)InternalAlloc(sz);
+    EXPECT_NE(p, (char*)0);
+    ptrs[i] = p;
+  }
+  for (int i = 0; i < kCount; i++) {
+    InternalFree(ptrs[i]);
+  }
+}
+
+TEST(Allocator, LargeAlloc) {
+  void *p = InternalAlloc(10 << 20);
+  InternalFree(p);
+}
+
+TEST(Allocator, ScopedBuffer) {
+  const int kSize = 512;
+  {
+    InternalScopedBuffer<int> int_buf(kSize);
+    EXPECT_EQ(sizeof(int) * kSize, int_buf.size());  // NOLINT
+  }
+  InternalScopedBuffer<char> char_buf(kSize);
+  EXPECT_EQ(sizeof(char) * kSize, char_buf.size());  // NOLINT
+  internal_memset(char_buf.data(), 'c', kSize);
+  for (int i = 0; i < kSize; i++) {
+    EXPECT_EQ('c', char_buf[i]);
+  }
+}
+
+void IterationTestCallback(uptr chunk, void *arg) {
+  reinterpret_cast<std::set<uptr> *>(arg)->insert(chunk);
+}
+
+template <class Allocator>
+void TestSizeClassAllocatorIteration() {
+  Allocator *a = new Allocator;
+  a->Init();
+  SizeClassAllocatorLocalCache<Allocator> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+
+  static const uptr sizes[] = {1, 16, 30, 40, 100, 1000, 10000,
+    50000, 60000, 100000, 120000, 300000, 500000, 1000000, 2000000};
+
+  std::vector<void *> allocated;
+
+  // Allocate a bunch of chunks.
+  for (uptr s = 0; s < ARRAY_SIZE(sizes); s++) {
+    uptr size = sizes[s];
+    if (!a->CanAllocate(size, 1)) continue;
+    // printf("s = %ld\n", size);
+    uptr n_iter = std::max((uptr)6, 80000 / size);
+    // fprintf(stderr, "size: %ld iter: %ld\n", size, n_iter);
+    for (uptr j = 0; j < n_iter; j++) {
+      uptr class_id0 = Allocator::SizeClassMapT::ClassID(size);
+      void *x = cache.Allocate(a, class_id0);
+      allocated.push_back(x);
+    }
+  }
+
+  std::set<uptr> reported_chunks;
+  a->ForceLock();
+  a->ForEachChunk(IterationTestCallback, &reported_chunks);
+  a->ForceUnlock();
+
+  for (uptr i = 0; i < allocated.size(); i++) {
+    // Don't use EXPECT_NE. Reporting the first mismatch is enough.
+    ASSERT_NE(reported_chunks.find(reinterpret_cast<uptr>(allocated[i])),
+              reported_chunks.end());
+  }
+
+  a->TestOnlyUnmap();
+  delete a;
+}
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+TEST(SanitizerCommon, SizeClassAllocator64Iteration) {
+  TestSizeClassAllocatorIteration<Allocator64>();
+}
+#endif
+
+TEST(SanitizerCommon, SizeClassAllocator32Iteration) {
+  TestSizeClassAllocatorIteration<Allocator32Compact>();
+}
+
+TEST(SanitizerCommon, LargeMmapAllocatorIteration) {
+  LargeMmapAllocator<> a;
+  a.Init(/* may_return_null */ false);
+  AllocatorStats stats;
+  stats.Init();
+
+  static const uptr kNumAllocs = 1000;
+  char *allocated[kNumAllocs];
+  static const uptr size = 40;
+  // Allocate some.
+  for (uptr i = 0; i < kNumAllocs; i++)
+    allocated[i] = (char *)a.Allocate(&stats, size, 1);
+
+  std::set<uptr> reported_chunks;
+  a.ForceLock();
+  a.ForEachChunk(IterationTestCallback, &reported_chunks);
+  a.ForceUnlock();
+
+  for (uptr i = 0; i < kNumAllocs; i++) {
+    // Don't use EXPECT_NE. Reporting the first mismatch is enough.
+    ASSERT_NE(reported_chunks.find(reinterpret_cast<uptr>(allocated[i])),
+              reported_chunks.end());
+  }
+  for (uptr i = 0; i < kNumAllocs; i++)
+    a.Deallocate(&stats, allocated[i]);
+}
+
+TEST(SanitizerCommon, LargeMmapAllocatorBlockBegin) {
+  LargeMmapAllocator<> a;
+  a.Init(/* may_return_null */ false);
+  AllocatorStats stats;
+  stats.Init();
+
+  static const uptr kNumAllocs = 1024;
+  static const uptr kNumExpectedFalseLookups = 10000000;
+  char *allocated[kNumAllocs];
+  static const uptr size = 4096;
+  // Allocate some.
+  for (uptr i = 0; i < kNumAllocs; i++) {
+    allocated[i] = (char *)a.Allocate(&stats, size, 1);
+  }
+
+  a.ForceLock();
+  for (uptr i = 0; i < kNumAllocs  * kNumAllocs; i++) {
+    // if ((i & (i - 1)) == 0) fprintf(stderr, "[%zd]\n", i);
+    char *p1 = allocated[i % kNumAllocs];
+    EXPECT_EQ(p1, a.GetBlockBeginFastLocked(p1));
+    EXPECT_EQ(p1, a.GetBlockBeginFastLocked(p1 + size / 2));
+    EXPECT_EQ(p1, a.GetBlockBeginFastLocked(p1 + size - 1));
+    EXPECT_EQ(p1, a.GetBlockBeginFastLocked(p1 - 100));
+  }
+
+  for (uptr i = 0; i < kNumExpectedFalseLookups; i++) {
+    void *p = reinterpret_cast<void *>(i % 1024);
+    EXPECT_EQ((void *)0, a.GetBlockBeginFastLocked(p));
+    p = reinterpret_cast<void *>(~0L - (i % 1024));
+    EXPECT_EQ((void *)0, a.GetBlockBeginFastLocked(p));
+  }
+  a.ForceUnlock();
+
+  for (uptr i = 0; i < kNumAllocs; i++)
+    a.Deallocate(&stats, allocated[i]);
+}
+
+
+#if SANITIZER_CAN_USE_ALLOCATOR64
+// Regression test for out-of-memory condition in PopulateFreeList().
+TEST(SanitizerCommon, SizeClassAllocator64PopulateFreeListOOM) {
+  // In a world where regions are small and chunks are huge...
+  typedef SizeClassMap<63, 128, 16> SpecialSizeClassMap;
+  typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, 0,
+                               SpecialSizeClassMap> SpecialAllocator64;
+  const uptr kRegionSize =
+      kAllocatorSize / SpecialSizeClassMap::kNumClassesRounded;
+  SpecialAllocator64 *a = new SpecialAllocator64;
+  a->Init();
+  SizeClassAllocatorLocalCache<SpecialAllocator64> cache;
+  memset(&cache, 0, sizeof(cache));
+  cache.Init(0);
+
+  // ...one man is on a mission to overflow a region with a series of
+  // successive allocations.
+  const uptr kClassID = 107;
+  const uptr kAllocationSize = DefaultSizeClassMap::Size(kClassID);
+  ASSERT_LT(2 * kAllocationSize, kRegionSize);
+  ASSERT_GT(3 * kAllocationSize, kRegionSize);
+  cache.Allocate(a, kClassID);
+  EXPECT_DEATH(cache.Allocate(a, kClassID) && cache.Allocate(a, kClassID),
+               "The process has exhausted");
+  a->TestOnlyUnmap();
+  delete a;
+}
+#endif
+
+TEST(SanitizerCommon, TwoLevelByteMap) {
+  const u64 kSize1 = 1 << 6, kSize2 = 1 << 12;
+  const u64 n = kSize1 * kSize2;
+  TwoLevelByteMap<kSize1, kSize2> m;
+  m.TestOnlyInit();
+  for (u64 i = 0; i < n; i += 7) {
+    m.set(i, (i % 100) + 1);
+  }
+  for (u64 j = 0; j < n; j++) {
+    if (j % 7)
+      EXPECT_EQ(m[j], 0);
+    else
+      EXPECT_EQ(m[j], (j % 100) + 1);
+  }
+
+  m.TestOnlyUnmap();
+}
+
+
+typedef TwoLevelByteMap<1 << 12, 1 << 13, TestMapUnmapCallback> TestByteMap;
+
+struct TestByteMapParam {
+  TestByteMap *m;
+  size_t shard;
+  size_t num_shards;
+};
+
+void *TwoLevelByteMapUserThread(void *param) {
+  TestByteMapParam *p = (TestByteMapParam*)param;
+  for (size_t i = p->shard; i < p->m->size(); i += p->num_shards) {
+    size_t val = (i % 100) + 1;
+    p->m->set(i, val);
+    EXPECT_EQ((*p->m)[i], val);
+  }
+  return 0;
+}
+
+TEST(SanitizerCommon, ThreadedTwoLevelByteMap) {
+  TestByteMap m;
+  m.TestOnlyInit();
+  TestMapUnmapCallback::map_count = 0;
+  TestMapUnmapCallback::unmap_count = 0;
+  static const int kNumThreads = 4;
+  pthread_t t[kNumThreads];
+  TestByteMapParam p[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++) {
+    p[i].m = &m;
+    p[i].shard = i;
+    p[i].num_shards = kNumThreads;
+    PTHREAD_CREATE(&t[i], 0, TwoLevelByteMapUserThread, &p[i]);
+  }
+  for (int i = 0; i < kNumThreads; i++) {
+    PTHREAD_JOIN(t[i], 0);
+  }
+  EXPECT_EQ((uptr)TestMapUnmapCallback::map_count, m.size1());
+  EXPECT_EQ((uptr)TestMapUnmapCallback::unmap_count, 0UL);
+  m.TestOnlyUnmap();
+  EXPECT_EQ((uptr)TestMapUnmapCallback::map_count, m.size1());
+  EXPECT_EQ((uptr)TestMapUnmapCallback::unmap_count, m.size1());
+}
+
+#endif  // #if !SANITIZER_DEBUG
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_testlib.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_testlib.cc
new file mode 100644
index 0000000..0cc3b9b
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_testlib.cc
@@ -0,0 +1,162 @@
+//===-- sanitizer_allocator_testlib.cc ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Malloc replacement library based on CombinedAllocator.
+// The primary purpose of this file is an end-to-end integration test
+// for CombinedAllocator.
+//===----------------------------------------------------------------------===//
+/* Usage:
+clang++ -fno-exceptions  -g -fPIC -I. -I../include -Isanitizer \
+ sanitizer_common/tests/sanitizer_allocator_testlib.cc \
+ sanitizer_common/sanitizer_*.cc -shared -lpthread -o testmalloc.so
+LD_PRELOAD=`pwd`/testmalloc.so /your/app
+*/
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+
+#ifndef SANITIZER_MALLOC_HOOK
+# define SANITIZER_MALLOC_HOOK(p, s)
+#endif
+
+#ifndef SANITIZER_FREE_HOOK
+# define SANITIZER_FREE_HOOK(p)
+#endif
+
+namespace {
+static const uptr kAllocatorSpace = 0x600000000000ULL;
+static const uptr kAllocatorSize  =  0x10000000000ULL;  // 1T.
+
+typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, 0,
+  CompactSizeClassMap> PrimaryAllocator;
+typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef LargeMmapAllocator<> SecondaryAllocator;
+typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
+          SecondaryAllocator> Allocator;
+
+static Allocator allocator;
+static bool global_inited;
+static THREADLOCAL AllocatorCache cache;
+static THREADLOCAL bool thread_inited;
+static pthread_key_t pkey;
+
+static void thread_dtor(void *v) {
+  if ((uptr)v != 3) {
+    pthread_setspecific(pkey, (void*)((uptr)v + 1));
+    return;
+  }
+  allocator.SwallowCache(&cache);
+}
+
+static void NOINLINE thread_init() {
+  if (!global_inited) {
+    global_inited = true;
+    allocator.Init();
+    pthread_key_create(&pkey, thread_dtor);
+  }
+  thread_inited = true;
+  pthread_setspecific(pkey, (void*)1);
+  cache.Init();
+}
+}  // namespace
+
+extern "C" {
+void *malloc(size_t size) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  void *p = allocator.Allocate(&cache, size, 8);
+  SANITIZER_MALLOC_HOOK(p, size);
+  return p;
+}
+
+void free(void *p) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  SANITIZER_FREE_HOOK(p);
+  allocator.Deallocate(&cache, p);
+}
+
+void *calloc(size_t nmemb, size_t size) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  size *= nmemb;
+  void *p = allocator.Allocate(&cache, size, 8, false);
+  memset(p, 0, size);
+  SANITIZER_MALLOC_HOOK(p, size);
+  return p;
+}
+
+void *realloc(void *p, size_t size) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  if (p) {
+    SANITIZER_FREE_HOOK(p);
+  }
+  p = allocator.Reallocate(&cache, p, size, 8);
+  if (p) {
+    SANITIZER_MALLOC_HOOK(p, size);
+  }
+  return p;
+}
+
+void *memalign(size_t alignment, size_t size) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  void *p = allocator.Allocate(&cache, size, alignment);
+  SANITIZER_MALLOC_HOOK(p, size);
+  return p;
+}
+
+int posix_memalign(void **memptr, size_t alignment, size_t size) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  *memptr = allocator.Allocate(&cache, size, alignment);
+  SANITIZER_MALLOC_HOOK(*memptr, size);
+  return 0;
+}
+
+void *valloc(size_t size) {
+  if (UNLIKELY(!thread_inited))
+    thread_init();
+  if (size == 0)
+    size = GetPageSizeCached();
+  void *p = allocator.Allocate(&cache, size, GetPageSizeCached());
+  SANITIZER_MALLOC_HOOK(p, size);
+  return p;
+}
+
+void cfree(void *p) ALIAS("free");
+void *pvalloc(size_t size) ALIAS("valloc");
+void *__libc_memalign(size_t alignment, size_t size) ALIAS("memalign");
+
+void malloc_usable_size() {
+}
+
+void mallinfo() {
+}
+
+void mallopt() {
+}
+}  // extern "C"
+
+namespace std {
+  struct nothrow_t;
+}
+
+void *operator new(size_t size) ALIAS("malloc");
+void *operator new[](size_t size) ALIAS("malloc");
+void *operator new(size_t size, std::nothrow_t const&) ALIAS("malloc");
+void *operator new[](size_t size, std::nothrow_t const&) ALIAS("malloc");
+void operator delete(void *ptr) throw() ALIAS("free");
+void operator delete[](void *ptr) throw() ALIAS("free");
+void operator delete(void *ptr, std::nothrow_t const&) ALIAS("free");
+void operator delete[](void *ptr, std::nothrow_t const&) ALIAS("free");
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cc
new file mode 100644
index 0000000..56bcd35
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cc
@@ -0,0 +1,128 @@
+//===-- sanitizer_atomic_test.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+template<typename T>
+struct ValAndMagic {
+  typename T::Type magic0;
+  T a;
+  typename T::Type magic1;
+
+  static ValAndMagic<T> *sink;
+};
+
+template<typename T>
+ValAndMagic<T> *ValAndMagic<T>::sink;
+
+template<typename T, memory_order load_mo, memory_order store_mo>
+void CheckStoreLoad() {
+  typedef typename T::Type Type;
+  ValAndMagic<T> val;
+  // Prevent the compiler from scalarizing the struct.
+  ValAndMagic<T>::sink = &val;
+  // Ensure that surrounding memory is not overwritten.
+  val.magic0 = val.magic1 = (Type)-3;
+  for (u64 i = 0; i < 100; i++) {
+    // Generate a value that occupies all bytes of the variable.
+    u64 v = i;
+    v |= v << 8;
+    v |= v << 16;
+    v |= v << 32;
+    val.a.val_dont_use = (Type)v;
+    EXPECT_EQ(atomic_load(&val.a, load_mo), (Type)v);
+    val.a.val_dont_use = (Type)-1;
+    atomic_store(&val.a, (Type)v, store_mo);
+    EXPECT_EQ(val.a.val_dont_use, (Type)v);
+  }
+  EXPECT_EQ(val.magic0, (Type)-3);
+  EXPECT_EQ(val.magic1, (Type)-3);
+}
+
+TEST(SanitizerCommon, AtomicStoreLoad) {
+  CheckStoreLoad<atomic_uint8_t, memory_order_relaxed, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint8_t, memory_order_consume, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint8_t, memory_order_acquire, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint8_t, memory_order_relaxed, memory_order_release>();
+  CheckStoreLoad<atomic_uint8_t, memory_order_seq_cst, memory_order_seq_cst>();
+
+  CheckStoreLoad<atomic_uint16_t, memory_order_relaxed, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint16_t, memory_order_consume, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint16_t, memory_order_acquire, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint16_t, memory_order_relaxed, memory_order_release>();
+  CheckStoreLoad<atomic_uint16_t, memory_order_seq_cst, memory_order_seq_cst>();
+
+  CheckStoreLoad<atomic_uint32_t, memory_order_relaxed, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint32_t, memory_order_consume, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint32_t, memory_order_acquire, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint32_t, memory_order_relaxed, memory_order_release>();
+  CheckStoreLoad<atomic_uint32_t, memory_order_seq_cst, memory_order_seq_cst>();
+
+  CheckStoreLoad<atomic_uint64_t, memory_order_relaxed, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint64_t, memory_order_consume, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint64_t, memory_order_acquire, memory_order_relaxed>();
+  CheckStoreLoad<atomic_uint64_t, memory_order_relaxed, memory_order_release>();
+  CheckStoreLoad<atomic_uint64_t, memory_order_seq_cst, memory_order_seq_cst>();
+
+  CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_relaxed>
+      ();
+  CheckStoreLoad<atomic_uintptr_t, memory_order_consume, memory_order_relaxed>
+      ();
+  CheckStoreLoad<atomic_uintptr_t, memory_order_acquire, memory_order_relaxed>
+      ();
+  CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_release>
+      ();
+  CheckStoreLoad<atomic_uintptr_t, memory_order_seq_cst, memory_order_seq_cst>
+      ();
+}
+
+// Clang crashes while compiling this test for Android:
+// http://llvm.org/bugs/show_bug.cgi?id=15587
+#if !SANITIZER_ANDROID
+template<typename T>
+void CheckAtomicCompareExchange() {
+  typedef typename T::Type Type;
+  {
+    Type old_val = 42;
+    Type new_val = 24;
+    Type var = old_val;
+    EXPECT_TRUE(atomic_compare_exchange_strong((T*)&var, &old_val, new_val,
+                                               memory_order_relaxed));
+    EXPECT_FALSE(atomic_compare_exchange_strong((T*)&var, &old_val, new_val,
+                                                memory_order_relaxed));
+    EXPECT_EQ(new_val, old_val);
+  }
+  {
+    Type old_val = 42;
+    Type new_val = 24;
+    Type var = old_val;
+    EXPECT_TRUE(atomic_compare_exchange_weak((T*)&var, &old_val, new_val,
+                                             memory_order_relaxed));
+    EXPECT_FALSE(atomic_compare_exchange_weak((T*)&var, &old_val, new_val,
+                                              memory_order_relaxed));
+    EXPECT_EQ(new_val, old_val);
+  }
+}
+
+TEST(SanitizerCommon, AtomicCompareExchangeTest) {
+  CheckAtomicCompareExchange<atomic_uint8_t>();
+  CheckAtomicCompareExchange<atomic_uint16_t>();
+  CheckAtomicCompareExchange<atomic_uint32_t>();
+  CheckAtomicCompareExchange<atomic_uint64_t>();
+  CheckAtomicCompareExchange<atomic_uintptr_t>();
+}
+#endif  //!SANITIZER_ANDROID
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_bitvector_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_bitvector_test.cc
new file mode 100644
index 0000000..706b4c5
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_bitvector_test.cc
@@ -0,0 +1,176 @@
+//===-- sanitizer_bitvector_test.cc ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime.
+// Tests for sanitizer_bitvector.h.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_bitvector.h"
+
+#include "sanitizer_test_utils.h"
+
+#include "gtest/gtest.h"
+
+#include <algorithm>
+#include <vector>
+#include <set>
+
+using namespace __sanitizer;
+using namespace std;
+
+
+// Check the 'bv' == 's' and that the indexes go in increasing order.
+// Also check the BV::Iterator
+template <class BV>
+static void CheckBV(const BV &bv, const set<uptr> &s) {
+  BV t;
+  t.copyFrom(bv);
+  set<uptr> t_s(s);
+  uptr last_idx = bv.size();
+  uptr count = 0;
+  for (typename BV::Iterator it(bv); it.hasNext();) {
+    uptr idx = it.next();
+    count++;
+    if (last_idx != bv.size())
+      EXPECT_LT(last_idx, idx);
+    last_idx = idx;
+    EXPECT_TRUE(s.count(idx));
+  }
+  EXPECT_EQ(count, s.size());
+
+  last_idx = bv.size();
+  while (!t.empty()) {
+    uptr idx = t.getAndClearFirstOne();
+    if (last_idx != bv.size())
+      EXPECT_LT(last_idx, idx);
+    last_idx = idx;
+    EXPECT_TRUE(t_s.erase(idx));
+  }
+  EXPECT_TRUE(t_s.empty());
+}
+
+template <class BV>
+void Print(const BV &bv) {
+  BV t;
+  t.copyFrom(bv);
+  while (!t.empty()) {
+    uptr idx = t.getAndClearFirstOne();
+    fprintf(stderr, "%zd ", idx);
+  }
+  fprintf(stderr, "\n");
+}
+
+void Print(const set<uptr> &s) {
+  for (set<uptr>::iterator it = s.begin(); it != s.end(); ++it) {
+    fprintf(stderr, "%zd ", *it);
+  }
+  fprintf(stderr, "\n");
+}
+
+template <class BV>
+void TestBitVector(uptr expected_size) {
+  BV bv, bv1, t_bv;
+  EXPECT_EQ(expected_size, BV::kSize);
+  bv.clear();
+  EXPECT_TRUE(bv.empty());
+  bv.setBit(5);
+  EXPECT_FALSE(bv.empty());
+  EXPECT_FALSE(bv.getBit(4));
+  EXPECT_FALSE(bv.getBit(6));
+  EXPECT_TRUE(bv.getBit(5));
+  bv.clearBit(5);
+  EXPECT_FALSE(bv.getBit(5));
+
+  // test random bits
+  bv.clear();
+  set<uptr> s;
+  for (uptr it = 0; it < 1000; it++) {
+    uptr bit = ((uptr)my_rand() % bv.size());
+    EXPECT_EQ(bv.getBit(bit), s.count(bit) == 1);
+    switch (my_rand() % 2) {
+      case 0:
+        EXPECT_EQ(bv.setBit(bit), s.insert(bit).second);
+        break;
+      case 1:
+        size_t old_size = s.size();
+        s.erase(bit);
+        EXPECT_EQ(bv.clearBit(bit), old_size > s.size());
+        break;
+    }
+    EXPECT_EQ(bv.getBit(bit), s.count(bit) == 1);
+  }
+
+  vector<uptr>bits(bv.size());
+  // Test setUnion, setIntersection, setDifference,
+  // intersectsWith, and getAndClearFirstOne.
+  for (uptr it = 0; it < 30; it++) {
+    // iota
+    for (size_t j = 0; j < bits.size(); j++) bits[j] = j;
+    random_shuffle(bits.begin(), bits.end());
+    set<uptr> s, s1, t_s;
+    bv.clear();
+    bv1.clear();
+    uptr n_bits = ((uptr)my_rand() % bv.size()) + 1;
+    uptr n_bits1 = (uptr)my_rand() % (bv.size() / 2);
+    EXPECT_TRUE(n_bits > 0 && n_bits <= bv.size());
+    EXPECT_TRUE(n_bits1 < bv.size() / 2);
+    for (uptr i = 0; i < n_bits; i++) {
+      bv.setBit(bits[i]);
+      s.insert(bits[i]);
+    }
+    CheckBV(bv, s);
+    for (uptr i = 0; i < n_bits1; i++) {
+      bv1.setBit(bits[bv.size() / 2 + i]);
+      s1.insert(bits[bv.size() / 2 + i]);
+    }
+    CheckBV(bv1, s1);
+
+    vector<uptr> vec;
+    set_intersection(s.begin(), s.end(), s1.begin(), s1.end(),
+                     back_insert_iterator<vector<uptr> >(vec));
+    EXPECT_EQ(bv.intersectsWith(bv1), !vec.empty());
+
+    // setUnion
+    t_s = s;
+    t_bv.copyFrom(bv);
+    t_s.insert(s1.begin(), s1.end());
+    EXPECT_EQ(t_bv.setUnion(bv1), s.size() != t_s.size());
+    CheckBV(t_bv, t_s);
+
+    // setIntersection
+    t_s = set<uptr>(vec.begin(), vec.end());
+    t_bv.copyFrom(bv);
+    EXPECT_EQ(t_bv.setIntersection(bv1), s.size() != t_s.size());
+    CheckBV(t_bv, t_s);
+
+    // setDifference
+    vec.clear();
+    set_difference(s.begin(), s.end(), s1.begin(), s1.end(),
+                     back_insert_iterator<vector<uptr> >(vec));
+    t_s = set<uptr>(vec.begin(), vec.end());
+    t_bv.copyFrom(bv);
+    EXPECT_EQ(t_bv.setDifference(bv1), s.size() != t_s.size());
+    CheckBV(t_bv, t_s);
+  }
+}
+
+TEST(SanitizerCommon, BasicBitVector) {
+  TestBitVector<BasicBitVector<u8> >(8);
+  TestBitVector<BasicBitVector<u16> >(16);
+  TestBitVector<BasicBitVector<> >(SANITIZER_WORDSIZE);
+}
+
+TEST(SanitizerCommon, TwoLevelBitVector) {
+  uptr ws = SANITIZER_WORDSIZE;
+  TestBitVector<TwoLevelBitVector<1, BasicBitVector<u8> > >(8 * 8);
+  TestBitVector<TwoLevelBitVector<> >(ws * ws);
+  TestBitVector<TwoLevelBitVector<2> >(ws * ws * 2);
+  TestBitVector<TwoLevelBitVector<3> >(ws * ws * 3);
+  TestBitVector<TwoLevelBitVector<3, BasicBitVector<u16> > >(16 * 16 * 3);
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_bvgraph_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_bvgraph_test.cc
new file mode 100644
index 0000000..3b39f8d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_bvgraph_test.cc
@@ -0,0 +1,339 @@
+//===-- sanitizer_bvgraph_test.cc -----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime.
+// Tests for sanitizer_bvgraph.h.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_bvgraph.h"
+
+#include "sanitizer_test_utils.h"
+
+#include "gtest/gtest.h"
+
+#include <algorithm>
+#include <vector>
+#include <set>
+
+using namespace __sanitizer;
+using namespace std;
+
+typedef BasicBitVector<u8> BV1;
+typedef BasicBitVector<> BV2;
+typedef TwoLevelBitVector<> BV3;
+typedef TwoLevelBitVector<3, BasicBitVector<u8> > BV4;
+
+template<class G>
+void PrintGraph(const G &g) {
+  for (uptr i = 0; i < g.size(); i++) {
+    for (uptr j = 0; j < g.size(); j++) {
+      fprintf(stderr, "%d", g.hasEdge(i, j));
+    }
+    fprintf(stderr, "\n");
+  }
+}
+
+
+class SimpleGraph {
+ public:
+  void clear() { s_.clear(); }
+  bool addEdge(uptr from, uptr to) {
+    return s_.insert(idx(from, to)).second;
+  }
+  bool removeEdge(uptr from, uptr to) {
+    return s_.erase(idx(from, to));
+  }
+  template <class G>
+  void checkSameAs(G *g) {
+    for (set<uptr>::iterator it = s_.begin(); it != s_.end(); ++it) {
+      uptr from = *it >> 16;
+      uptr to = *it & ((1 << 16) - 1);
+      EXPECT_TRUE(g->removeEdge(from, to));
+    }
+    EXPECT_TRUE(g->empty());
+  }
+ private:
+  uptr idx(uptr from, uptr to) {
+    CHECK_LE(from|to, 1 << 16);
+    return (from << 16) + to;
+  }
+  set<uptr> s_;
+};
+
+template <class BV>
+void BasicTest() {
+  BVGraph<BV> g;
+  g.clear();
+  BV target;
+  SimpleGraph s_g;
+  set<uptr> s;
+  set<uptr> s_target;
+  int num_reachable = 0;
+  for (int it = 0; it < 1000; it++) {
+    target.clear();
+    s_target.clear();
+    for (int t = 0; t < 4; t++) {
+      uptr idx = (uptr)my_rand() % g.size();
+      EXPECT_EQ(target.setBit(idx), s_target.insert(idx).second);
+    }
+    uptr from = my_rand() % g.size();
+    uptr to = my_rand() % g.size();
+    EXPECT_EQ(g.addEdge(from, to), s_g.addEdge(from, to));
+    EXPECT_TRUE(g.hasEdge(from, to));
+    for (int i = 0; i < 10; i++) {
+      from = my_rand() % g.size();
+      bool is_reachable = g.isReachable(from, target);
+      if (is_reachable) {
+        uptr path[BV::kSize];
+        uptr len;
+        for (len = 1; len < BV::kSize; len++) {
+          if (g.findPath(from, target, path, len) == len)
+            break;
+        }
+        EXPECT_LT(len, BV::kSize);
+        EXPECT_TRUE(target.getBit(path[len - 1]));
+        // fprintf(stderr, "reachable: %zd; path %zd {%zd %zd %zd}\n",
+        //        from, len, path[0], path[1], path[2]);
+        num_reachable++;
+      }
+    }
+  }
+  EXPECT_GT(num_reachable, 0);
+}
+
+TEST(BVGraph, BasicTest) {
+  BasicTest<BV1>();
+  BasicTest<BV2>();
+  BasicTest<BV3>();
+  BasicTest<BV4>();
+}
+
+template <class BV>
+void RemoveEdges() {
+  SimpleGraph s_g;
+  BVGraph<BV> g;
+  g.clear();
+  BV bv;
+  set<uptr> s;
+  for (int it = 0; it < 100; it++) {
+    s.clear();
+    bv.clear();
+    s_g.clear();
+    g.clear();
+    for (uptr j = 0; j < g.size() * 2; j++) {
+      uptr from = my_rand() % g.size();
+      uptr to = my_rand() % g.size();
+      EXPECT_EQ(g.addEdge(from, to), s_g.addEdge(from, to));
+    }
+    for (uptr j = 0; j < 5; j++) {
+      uptr idx = my_rand() % g.size();
+      s.insert(idx);
+      bv.setBit(idx);
+    }
+
+    if (it % 2) {
+      g.removeEdgesFrom(bv);
+      for (set<uptr>::iterator from = s.begin(); from != s.end(); ++from) {
+        for (uptr to = 0; to < g.size(); to++)
+          s_g.removeEdge(*from, to);
+      }
+    } else {
+      g.removeEdgesTo(bv);
+      for (set<uptr>::iterator to = s.begin(); to != s.end(); ++to) {
+        for (uptr from = 0; from < g.size(); from++)
+          s_g.removeEdge(from, *to);
+      }
+    }
+    s_g.checkSameAs(&g);
+  }
+}
+
+TEST(BVGraph, RemoveEdges) {
+  RemoveEdges<BV1>();
+  RemoveEdges<BV2>();
+  RemoveEdges<BV3>();
+  RemoveEdges<BV4>();
+}
+
+template <class BV>
+void Test_isReachable() {
+  uptr path[5];
+  BVGraph<BV> g;
+  g.clear();
+  BV target;
+  target.clear();
+  uptr t0 = 0;
+  uptr t1 = g.size() - 1;
+  target.setBit(t0);
+  target.setBit(t1);
+
+  uptr f0 = 1;
+  uptr f1 = 2;
+  uptr f2 = g.size() / 2;
+  uptr f3 = g.size() - 2;
+
+  EXPECT_FALSE(g.isReachable(f0, target));
+  EXPECT_FALSE(g.isReachable(f1, target));
+  EXPECT_FALSE(g.isReachable(f2, target));
+  EXPECT_FALSE(g.isReachable(f3, target));
+
+  g.addEdge(f0, f1);
+  g.addEdge(f1, f2);
+  g.addEdge(f2, f3);
+  EXPECT_FALSE(g.isReachable(f0, target));
+  EXPECT_FALSE(g.isReachable(f1, target));
+  EXPECT_FALSE(g.isReachable(f2, target));
+  EXPECT_FALSE(g.isReachable(f3, target));
+
+  g.addEdge(f1, t0);
+  EXPECT_TRUE(g.isReachable(f0, target));
+  EXPECT_TRUE(g.isReachable(f1, target));
+  EXPECT_FALSE(g.isReachable(f2, target));
+  EXPECT_FALSE(g.isReachable(f3, target));
+  EXPECT_EQ(g.findPath(f0, target, path, ARRAY_SIZE(path)), 3U);
+  EXPECT_EQ(path[0], f0);
+  EXPECT_EQ(path[1], f1);
+  EXPECT_EQ(path[2], t0);
+  EXPECT_EQ(g.findPath(f1, target, path, ARRAY_SIZE(path)), 2U);
+  EXPECT_EQ(path[0], f1);
+  EXPECT_EQ(path[1], t0);
+
+  g.addEdge(f3, t1);
+  EXPECT_TRUE(g.isReachable(f0, target));
+  EXPECT_TRUE(g.isReachable(f1, target));
+  EXPECT_TRUE(g.isReachable(f2, target));
+  EXPECT_TRUE(g.isReachable(f3, target));
+}
+
+TEST(BVGraph, isReachable) {
+  Test_isReachable<BV1>();
+  Test_isReachable<BV2>();
+  Test_isReachable<BV3>();
+  Test_isReachable<BV4>();
+}
+
+template <class BV>
+void LongCycle() {
+  BVGraph<BV> g;
+  g.clear();
+  vector<uptr> path_vec(g.size());
+  uptr *path = path_vec.data();
+  uptr start = 5;
+  for (uptr i = start; i < g.size() - 1; i++) {
+    g.addEdge(i, i + 1);
+    for (uptr j = 0; j < start; j++)
+      g.addEdge(i, j);
+  }
+  //  Bad graph that looks like this:
+  // 00000000000000
+  // 00000000000000
+  // 00000000000000
+  // 00000000000000
+  // 00000000000000
+  // 11111010000000
+  // 11111001000000
+  // 11111000100000
+  // 11111000010000
+  // 11111000001000
+  // 11111000000100
+  // 11111000000010
+  // 11111000000001
+  // if (g.size() <= 64) PrintGraph(g);
+  BV target;
+  for (uptr i = start + 1; i < g.size(); i += 11) {
+    // if ((i & (i - 1)) == 0) fprintf(stderr, "Path: : %zd\n", i);
+    target.clear();
+    target.setBit(i);
+    EXPECT_TRUE(g.isReachable(start, target));
+    EXPECT_EQ(g.findPath(start, target, path, g.size()), i - start + 1);
+  }
+}
+
+TEST(BVGraph, LongCycle) {
+  LongCycle<BV1>();
+  LongCycle<BV2>();
+  LongCycle<BV3>();
+  LongCycle<BV4>();
+}
+
+template <class BV>
+void ShortestPath() {
+  uptr path[8];
+  BVGraph<BV> g;
+  g.clear();
+  BV t7;
+  t7.clear();
+  t7.setBit(7);
+  // 1=>2=>3=>4=>5=>6=>7
+  // 1=>7
+  g.addEdge(1, 2);
+  g.addEdge(2, 3);
+  g.addEdge(3, 4);
+  g.addEdge(4, 5);
+  g.addEdge(5, 6);
+  g.addEdge(6, 7);
+  g.addEdge(1, 7);
+  EXPECT_TRUE(g.isReachable(1, t7));
+  // No path of length 1.
+  EXPECT_EQ(0U, g.findPath(1, t7, path, 1));
+  // Trying to find a path of len 2..6 gives path of len 2.
+  EXPECT_EQ(2U, g.findPath(1, t7, path, 2));
+  EXPECT_EQ(2U, g.findPath(1, t7, path, 3));
+  EXPECT_EQ(2U, g.findPath(1, t7, path, 4));
+  EXPECT_EQ(2U, g.findPath(1, t7, path, 5));
+  EXPECT_EQ(2U, g.findPath(1, t7, path, 6));
+  // Trying to find a path of len 7 gives path of len 7, because this is DFS.
+  EXPECT_EQ(7U, g.findPath(1, t7, path, 7));
+  // But findShortestPath will find the shortest path.
+  EXPECT_EQ(2U, g.findShortestPath(1, t7, path, 2));
+  EXPECT_EQ(2U, g.findShortestPath(1, t7, path, 7));
+}
+
+TEST(BVGraph, ShortestPath) {
+  ShortestPath<BV1>();
+  ShortestPath<BV2>();
+  ShortestPath<BV3>();
+  ShortestPath<BV4>();
+}
+
+template <class BV>
+void RunAddEdgesTest() {
+  BVGraph<BV> g;
+  BV from;
+  const int kMaxEdges = 10;
+  uptr added_edges[kMaxEdges];
+  g.clear();
+  from.clear();
+  EXPECT_EQ(0U, g.addEdges(from, 0, added_edges, kMaxEdges));
+  EXPECT_EQ(0U, g.addEdges(from, 1, added_edges, kMaxEdges));
+  from.setBit(0);
+  EXPECT_EQ(1U, g.addEdges(from, 1, added_edges, kMaxEdges));
+  EXPECT_EQ(0U, added_edges[0]);
+  EXPECT_EQ(0U, g.addEdges(from, 1, added_edges, kMaxEdges));
+
+  from.clear();
+  from.setBit(1);
+  EXPECT_EQ(1U, g.addEdges(from, 4, added_edges, kMaxEdges));
+  EXPECT_TRUE(g.hasEdge(1, 4));
+  EXPECT_FALSE(g.hasEdge(1, 5));
+  EXPECT_EQ(1U, added_edges[0]);
+  from.setBit(2);
+  from.setBit(3);
+  EXPECT_EQ(2U, g.addEdges(from, 4, added_edges, kMaxEdges));
+  EXPECT_TRUE(g.hasEdge(2, 4));
+  EXPECT_FALSE(g.hasEdge(2, 5));
+  EXPECT_TRUE(g.hasEdge(3, 4));
+  EXPECT_FALSE(g.hasEdge(3, 5));
+  EXPECT_EQ(2U, added_edges[0]);
+  EXPECT_EQ(3U, added_edges[1]);
+}
+
+TEST(BVGraph, AddEdgesTest) {
+  RunAddEdgesTest<BV2>();
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cc
new file mode 100644
index 0000000..6fc308a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cc
@@ -0,0 +1,262 @@
+//===-- sanitizer_common_test.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_platform.h"
+
+#include "sanitizer_pthread_wrappers.h"
+
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+static bool IsSorted(const uptr *array, uptr n) {
+  for (uptr i = 1; i < n; i++) {
+    if (array[i] < array[i - 1]) return false;
+  }
+  return true;
+}
+
+TEST(SanitizerCommon, SortTest) {
+  uptr array[100];
+  uptr n = 100;
+  // Already sorted.
+  for (uptr i = 0; i < n; i++) {
+    array[i] = i;
+  }
+  SortArray(array, n);
+  EXPECT_TRUE(IsSorted(array, n));
+  // Reverse order.
+  for (uptr i = 0; i < n; i++) {
+    array[i] = n - 1 - i;
+  }
+  SortArray(array, n);
+  EXPECT_TRUE(IsSorted(array, n));
+  // Mixed order.
+  for (uptr i = 0; i < n; i++) {
+    array[i] = (i % 2 == 0) ? i : n - 1 - i;
+  }
+  SortArray(array, n);
+  EXPECT_TRUE(IsSorted(array, n));
+  // All equal.
+  for (uptr i = 0; i < n; i++) {
+    array[i] = 42;
+  }
+  SortArray(array, n);
+  EXPECT_TRUE(IsSorted(array, n));
+  // All but one sorted.
+  for (uptr i = 0; i < n - 1; i++) {
+    array[i] = i;
+  }
+  array[n - 1] = 42;
+  SortArray(array, n);
+  EXPECT_TRUE(IsSorted(array, n));
+  // Minimal case - sort three elements.
+  array[0] = 1;
+  array[1] = 0;
+  SortArray(array, 2);
+  EXPECT_TRUE(IsSorted(array, 2));
+}
+
+TEST(SanitizerCommon, MmapAlignedOrDie) {
+  uptr PageSize = GetPageSizeCached();
+  for (uptr size = 1; size <= 32; size *= 2) {
+    for (uptr alignment = 1; alignment <= 32; alignment *= 2) {
+      for (int iter = 0; iter < 100; iter++) {
+        uptr res = (uptr)MmapAlignedOrDie(
+            size * PageSize, alignment * PageSize, "MmapAlignedOrDieTest");
+        EXPECT_EQ(0U, res % (alignment * PageSize));
+        internal_memset((void*)res, 1, size * PageSize);
+        UnmapOrDie((void*)res, size * PageSize);
+      }
+    }
+  }
+}
+
+#if SANITIZER_LINUX
+TEST(SanitizerCommon, SanitizerSetThreadName) {
+  const char *names[] = {
+    "0123456789012",
+    "01234567890123",
+    "012345678901234",  // Larger names will be truncated on linux.
+  };
+
+  for (size_t i = 0; i < ARRAY_SIZE(names); i++) {
+    EXPECT_TRUE(SanitizerSetThreadName(names[i]));
+    char buff[100];
+    EXPECT_TRUE(SanitizerGetThreadName(buff, sizeof(buff) - 1));
+    EXPECT_EQ(0, internal_strcmp(buff, names[i]));
+  }
+}
+#endif
+
+TEST(SanitizerCommon, InternalMmapVector) {
+  InternalMmapVector<uptr> vector(1);
+  for (uptr i = 0; i < 100; i++) {
+    EXPECT_EQ(i, vector.size());
+    vector.push_back(i);
+  }
+  for (uptr i = 0; i < 100; i++) {
+    EXPECT_EQ(i, vector[i]);
+  }
+  for (int i = 99; i >= 0; i--) {
+    EXPECT_EQ((uptr)i, vector.back());
+    vector.pop_back();
+    EXPECT_EQ((uptr)i, vector.size());
+  }
+  InternalMmapVector<uptr> empty_vector(0);
+  CHECK_GT(empty_vector.capacity(), 0U);
+  CHECK_EQ(0U, empty_vector.size());
+}
+
+void TestThreadInfo(bool main) {
+  uptr stk_addr = 0;
+  uptr stk_size = 0;
+  uptr tls_addr = 0;
+  uptr tls_size = 0;
+  GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr, &tls_size);
+
+  int stack_var;
+  EXPECT_NE(stk_addr, (uptr)0);
+  EXPECT_NE(stk_size, (uptr)0);
+  EXPECT_GT((uptr)&stack_var, stk_addr);
+  EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
+
+#if SANITIZER_LINUX && defined(__x86_64__)
+  static __thread int thread_var;
+  EXPECT_NE(tls_addr, (uptr)0);
+  EXPECT_NE(tls_size, (uptr)0);
+  EXPECT_GT((uptr)&thread_var, tls_addr);
+  EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
+
+  // Ensure that tls and stack do not intersect.
+  uptr tls_end = tls_addr + tls_size;
+  EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
+  EXPECT_TRUE(tls_end  < stk_addr || tls_end  >=  stk_addr + stk_size);
+  EXPECT_TRUE((tls_addr < stk_addr) == (tls_end  < stk_addr));
+#endif
+}
+
+static void *WorkerThread(void *arg) {
+  TestThreadInfo(false);
+  return 0;
+}
+
+TEST(SanitizerCommon, ThreadStackTlsMain) {
+  InitTlsSize();
+  TestThreadInfo(true);
+}
+
+TEST(SanitizerCommon, ThreadStackTlsWorker) {
+  InitTlsSize();
+  pthread_t t;
+  PTHREAD_CREATE(&t, 0, WorkerThread, 0);
+  PTHREAD_JOIN(t, 0);
+}
+
+bool UptrLess(uptr a, uptr b) {
+  return a < b;
+}
+
+TEST(SanitizerCommon, InternalBinarySearch) {
+  static const uptr kSize = 5;
+  uptr arr[kSize];
+  for (uptr i = 0; i < kSize; i++) arr[i] = i * i;
+
+  for (uptr i = 0; i < kSize; i++)
+    ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, i * i, UptrLess), i);
+
+  ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, 7, UptrLess), kSize + 1);
+}
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TEST(SanitizerCommon, FindPathToBinary) {
+  char *true_path = FindPathToBinary("true");
+  EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true"));
+  InternalFree(true_path);
+  EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
+}
+#elif SANITIZER_WINDOWS
+TEST(SanitizerCommon, FindPathToBinary) {
+  // ntdll.dll should be on PATH in all supported test environments on all
+  // supported Windows versions.
+  char *ntdll_path = FindPathToBinary("ntdll.dll");
+  EXPECT_NE((char*)0, internal_strstr(ntdll_path, "ntdll.dll"));
+  InternalFree(ntdll_path);
+  EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
+}
+#endif
+
+TEST(SanitizerCommon, StripPathPrefix) {
+  EXPECT_EQ(0, StripPathPrefix(0, "prefix"));
+  EXPECT_STREQ("foo", StripPathPrefix("foo", 0));
+  EXPECT_STREQ("dir/file.cc",
+               StripPathPrefix("/usr/lib/dir/file.cc", "/usr/lib/"));
+  EXPECT_STREQ("/file.cc", StripPathPrefix("/usr/myroot/file.cc", "/myroot"));
+  EXPECT_STREQ("file.h", StripPathPrefix("/usr/lib/./file.h", "/usr/lib/"));
+}
+
+TEST(SanitizerCommon, RemoveANSIEscapeSequencesFromString) {
+  RemoveANSIEscapeSequencesFromString(nullptr);
+  const char *buffs[22] = {
+    "Default",                                "Default",
+    "\033[95mLight magenta",                  "Light magenta",
+    "\033[30mBlack\033[32mGreen\033[90mGray", "BlackGreenGray",
+    "\033[106mLight cyan \033[107mWhite ",    "Light cyan White ",
+    "\033[31mHello\033[0m World",             "Hello World",
+    "\033[38;5;82mHello \033[38;5;198mWorld", "Hello World",
+    "123[653456789012",                       "123[653456789012",
+    "Normal \033[5mBlink \033[25mNormal",     "Normal Blink Normal",
+    "\033[106m\033[107m",                     "",
+    "",                                       "",
+    " ",                                      " ",
+  };
+
+  for (size_t i = 0; i < ARRAY_SIZE(buffs); i+=2) {
+    char *buffer_copy = internal_strdup(buffs[i]);
+    RemoveANSIEscapeSequencesFromString(buffer_copy);
+    EXPECT_STREQ(buffer_copy, buffs[i+1]);
+    InternalFree(buffer_copy);
+  }
+}
+
+TEST(SanitizerCommon, InternalScopedString) {
+  InternalScopedString str(10);
+  EXPECT_EQ(0U, str.length());
+  EXPECT_STREQ("", str.data());
+
+  str.append("foo");
+  EXPECT_EQ(3U, str.length());
+  EXPECT_STREQ("foo", str.data());
+
+  int x = 1234;
+  str.append("%d", x);
+  EXPECT_EQ(7U, str.length());
+  EXPECT_STREQ("foo1234", str.data());
+
+  str.append("%d", x);
+  EXPECT_EQ(9U, str.length());
+  EXPECT_STREQ("foo123412", str.data());
+
+  str.clear();
+  EXPECT_EQ(0U, str.length());
+  EXPECT_STREQ("", str.data());
+
+  str.append("0123456789");
+  EXPECT_EQ(9U, str.length());
+  EXPECT_STREQ("012345678", str.data());
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_deadlock_detector_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_deadlock_detector_test.cc
new file mode 100644
index 0000000..7835eef
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_deadlock_detector_test.cc
@@ -0,0 +1,496 @@
+//===-- sanitizer_deadlock_detector_test.cc -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Sanitizer runtime.
+// Tests for sanitizer_deadlock_detector.h
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_deadlock_detector.h"
+
+#include "sanitizer_test_utils.h"
+
+#include "gtest/gtest.h"
+
+#include <algorithm>
+#include <vector>
+#include <set>
+
+using namespace __sanitizer;
+using namespace std;
+
+typedef BasicBitVector<u8> BV1;
+typedef BasicBitVector<> BV2;
+typedef TwoLevelBitVector<> BV3;
+typedef TwoLevelBitVector<3, BasicBitVector<u8> > BV4;
+
+// Poor man's unique_ptr.
+template<class BV>
+struct ScopedDD {
+  ScopedDD() {
+    dp = new DeadlockDetector<BV>;
+    dp->clear();
+    dtls.clear();
+  }
+  ~ScopedDD() { delete dp; }
+  DeadlockDetector<BV> *dp;
+  DeadlockDetectorTLS<BV> dtls;
+};
+
+template <class BV>
+void RunBasicTest() {
+  uptr path[10];
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+  set<uptr> s;
+  for (size_t i = 0; i < d.size() * 3; i++) {
+    uptr node = d.newNode(0);
+    EXPECT_TRUE(s.insert(node).second);
+  }
+
+  d.clear();
+  s.clear();
+  // Add size() nodes.
+  for (size_t i = 0; i < d.size(); i++) {
+    uptr node = d.newNode(0);
+    EXPECT_TRUE(s.insert(node).second);
+  }
+  // Remove all nodes.
+  for (set<uptr>::iterator it = s.begin(); it != s.end(); ++it)
+    d.removeNode(*it);
+  // The nodes should be reused.
+  for (size_t i = 0; i < d.size(); i++) {
+    uptr node = d.newNode(0);
+    EXPECT_FALSE(s.insert(node).second);
+  }
+
+  // Cycle: n1->n2->n1
+  {
+    d.clear();
+    dtls.clear();
+    uptr n1 = d.newNode(1);
+    uptr n2 = d.newNode(2);
+    EXPECT_FALSE(d.onLock(&dtls, n1));
+    EXPECT_FALSE(d.onLock(&dtls, n2));
+    d.onUnlock(&dtls, n2);
+    d.onUnlock(&dtls, n1);
+
+    EXPECT_FALSE(d.onLock(&dtls, n2));
+    EXPECT_EQ(0U, d.findPathToLock(&dtls, n1, path, 1));
+    EXPECT_EQ(2U, d.findPathToLock(&dtls, n1, path, 10));
+    EXPECT_EQ(2U, d.findPathToLock(&dtls, n1, path, 2));
+    EXPECT_TRUE(d.onLock(&dtls, n1));
+    EXPECT_EQ(path[0], n1);
+    EXPECT_EQ(path[1], n2);
+    EXPECT_EQ(d.getData(n1), 1U);
+    EXPECT_EQ(d.getData(n2), 2U);
+    d.onUnlock(&dtls, n1);
+    d.onUnlock(&dtls, n2);
+  }
+
+  // Cycle: n1->n2->n3->n1
+  {
+    d.clear();
+    dtls.clear();
+    uptr n1 = d.newNode(1);
+    uptr n2 = d.newNode(2);
+    uptr n3 = d.newNode(3);
+
+    EXPECT_FALSE(d.onLock(&dtls, n1));
+    EXPECT_FALSE(d.onLock(&dtls, n2));
+    d.onUnlock(&dtls, n2);
+    d.onUnlock(&dtls, n1);
+
+    EXPECT_FALSE(d.onLock(&dtls, n2));
+    EXPECT_FALSE(d.onLock(&dtls, n3));
+    d.onUnlock(&dtls, n3);
+    d.onUnlock(&dtls, n2);
+
+    EXPECT_FALSE(d.onLock(&dtls, n3));
+    EXPECT_EQ(0U, d.findPathToLock(&dtls, n1, path, 2));
+    EXPECT_EQ(3U, d.findPathToLock(&dtls, n1, path, 10));
+    EXPECT_TRUE(d.onLock(&dtls, n1));
+    EXPECT_EQ(path[0], n1);
+    EXPECT_EQ(path[1], n2);
+    EXPECT_EQ(path[2], n3);
+    EXPECT_EQ(d.getData(n1), 1U);
+    EXPECT_EQ(d.getData(n2), 2U);
+    EXPECT_EQ(d.getData(n3), 3U);
+    d.onUnlock(&dtls, n1);
+    d.onUnlock(&dtls, n3);
+  }
+}
+
+TEST(DeadlockDetector, BasicTest) {
+  RunBasicTest<BV1>();
+  RunBasicTest<BV2>();
+  RunBasicTest<BV3>();
+  RunBasicTest<BV4>();
+}
+
+template <class BV>
+void RunRemoveNodeTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+
+  uptr l0 = d.newNode(0);
+  uptr l1 = d.newNode(1);
+  uptr l2 = d.newNode(2);
+  uptr l3 = d.newNode(3);
+  uptr l4 = d.newNode(4);
+  uptr l5 = d.newNode(5);
+
+  // l0=>l1=>l2
+  d.onLock(&dtls, l0);
+  d.onLock(&dtls, l1);
+  d.onLock(&dtls, l2);
+  d.onUnlock(&dtls, l1);
+  d.onUnlock(&dtls, l0);
+  d.onUnlock(&dtls, l2);
+  // l3=>l4=>l5
+  d.onLock(&dtls, l3);
+  d.onLock(&dtls, l4);
+  d.onLock(&dtls, l5);
+  d.onUnlock(&dtls, l4);
+  d.onUnlock(&dtls, l3);
+  d.onUnlock(&dtls, l5);
+
+  set<uptr> locks;
+  locks.insert(l0);
+  locks.insert(l1);
+  locks.insert(l2);
+  locks.insert(l3);
+  locks.insert(l4);
+  locks.insert(l5);
+  for (uptr i = 6; i < d.size(); i++) {
+    uptr lt = d.newNode(i);
+    locks.insert(lt);
+    d.onLock(&dtls, lt);
+    d.onUnlock(&dtls, lt);
+    d.removeNode(lt);
+  }
+  EXPECT_EQ(locks.size(), d.size());
+  // l2=>l0
+  EXPECT_FALSE(d.onLock(&dtls, l2));
+  EXPECT_TRUE(d.onLock(&dtls, l0));
+  d.onUnlock(&dtls, l2);
+  d.onUnlock(&dtls, l0);
+  // l4=>l3
+  EXPECT_FALSE(d.onLock(&dtls, l4));
+  EXPECT_TRUE(d.onLock(&dtls, l3));
+  d.onUnlock(&dtls, l4);
+  d.onUnlock(&dtls, l3);
+
+  EXPECT_EQ(d.size(), d.testOnlyGetEpoch());
+
+  d.removeNode(l2);
+  d.removeNode(l3);
+  locks.clear();
+  // make sure no edges from or to l0,l1,l4,l5 left.
+  for (uptr i = 4; i < d.size(); i++) {
+    uptr lt = d.newNode(i);
+    locks.insert(lt);
+    uptr a, b;
+    // l0 => lt?
+    a = l0; b = lt;
+    EXPECT_FALSE(d.onLock(&dtls, a));
+    EXPECT_FALSE(d.onLock(&dtls, b));
+    d.onUnlock(&dtls, a);
+    d.onUnlock(&dtls, b);
+    // l1 => lt?
+    a = l1; b = lt;
+    EXPECT_FALSE(d.onLock(&dtls, a));
+    EXPECT_FALSE(d.onLock(&dtls, b));
+    d.onUnlock(&dtls, a);
+    d.onUnlock(&dtls, b);
+    // lt => l4?
+    a = lt; b = l4;
+    EXPECT_FALSE(d.onLock(&dtls, a));
+    EXPECT_FALSE(d.onLock(&dtls, b));
+    d.onUnlock(&dtls, a);
+    d.onUnlock(&dtls, b);
+    // lt => l5?
+    a = lt; b = l5;
+    EXPECT_FALSE(d.onLock(&dtls, a));
+    EXPECT_FALSE(d.onLock(&dtls, b));
+    d.onUnlock(&dtls, a);
+    d.onUnlock(&dtls, b);
+
+    d.removeNode(lt);
+  }
+  // Still the same epoch.
+  EXPECT_EQ(d.size(), d.testOnlyGetEpoch());
+  EXPECT_EQ(locks.size(), d.size() - 4);
+  // l2 and l3 should have ben reused.
+  EXPECT_EQ(locks.count(l2), 1U);
+  EXPECT_EQ(locks.count(l3), 1U);
+}
+
+TEST(DeadlockDetector, RemoveNodeTest) {
+  RunRemoveNodeTest<BV1>();
+  RunRemoveNodeTest<BV2>();
+  RunRemoveNodeTest<BV3>();
+  RunRemoveNodeTest<BV4>();
+}
+
+template <class BV>
+void RunMultipleEpochsTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+
+  set<uptr> locks;
+  for (uptr i = 0; i < d.size(); i++) {
+    EXPECT_TRUE(locks.insert(d.newNode(i)).second);
+  }
+  EXPECT_EQ(d.testOnlyGetEpoch(), d.size());
+  for (uptr i = 0; i < d.size(); i++) {
+    EXPECT_TRUE(locks.insert(d.newNode(i)).second);
+    EXPECT_EQ(d.testOnlyGetEpoch(), d.size() * 2);
+  }
+  locks.clear();
+
+  uptr l0 = d.newNode(0);
+  uptr l1 = d.newNode(0);
+  d.onLock(&dtls, l0);
+  d.onLock(&dtls, l1);
+  d.onUnlock(&dtls, l0);
+  EXPECT_EQ(d.testOnlyGetEpoch(), 3 * d.size());
+  for (uptr i = 0; i < d.size(); i++) {
+    EXPECT_TRUE(locks.insert(d.newNode(i)).second);
+  }
+  EXPECT_EQ(d.testOnlyGetEpoch(), 4 * d.size());
+
+#if !SANITIZER_DEBUG
+  // EXPECT_DEATH clones a thread with 4K stack,
+  // which is overflown by tsan memory accesses functions in debug mode.
+
+  // Can not handle the locks from the previous epoch.
+  // The caller should update the lock id.
+  EXPECT_DEATH(d.onLock(&dtls, l0), "CHECK failed.*current_epoch_");
+#endif
+}
+
+TEST(DeadlockDetector, MultipleEpochsTest) {
+  RunMultipleEpochsTest<BV1>();
+  RunMultipleEpochsTest<BV2>();
+  RunMultipleEpochsTest<BV3>();
+  RunMultipleEpochsTest<BV4>();
+}
+
+template <class BV>
+void RunCorrectEpochFlush() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+  vector<uptr> locks1;
+  for (uptr i = 0; i < d.size(); i++)
+    locks1.push_back(d.newNode(i));
+  EXPECT_EQ(d.testOnlyGetEpoch(), d.size());
+  d.onLock(&dtls, locks1[3]);
+  d.onLock(&dtls, locks1[4]);
+  d.onLock(&dtls, locks1[5]);
+
+  // We have a new epoch, old locks in dtls will have to be forgotten.
+  uptr l0 = d.newNode(0);
+  EXPECT_EQ(d.testOnlyGetEpoch(), d.size() * 2);
+  uptr l1 = d.newNode(0);
+  EXPECT_EQ(d.testOnlyGetEpoch(), d.size() * 2);
+  d.onLock(&dtls, l0);
+  d.onLock(&dtls, l1);
+  EXPECT_TRUE(d.testOnlyHasEdgeRaw(0, 1));
+  EXPECT_FALSE(d.testOnlyHasEdgeRaw(1, 0));
+  EXPECT_FALSE(d.testOnlyHasEdgeRaw(3, 0));
+  EXPECT_FALSE(d.testOnlyHasEdgeRaw(4, 0));
+  EXPECT_FALSE(d.testOnlyHasEdgeRaw(5, 0));
+}
+
+TEST(DeadlockDetector, CorrectEpochFlush) {
+  RunCorrectEpochFlush<BV1>();
+  RunCorrectEpochFlush<BV2>();
+}
+
+template <class BV>
+void RunTryLockTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+
+  uptr l0 = d.newNode(0);
+  uptr l1 = d.newNode(0);
+  uptr l2 = d.newNode(0);
+  EXPECT_FALSE(d.onLock(&dtls, l0));
+  EXPECT_FALSE(d.onTryLock(&dtls, l1));
+  EXPECT_FALSE(d.onLock(&dtls, l2));
+  EXPECT_TRUE(d.isHeld(&dtls, l0));
+  EXPECT_TRUE(d.isHeld(&dtls, l1));
+  EXPECT_TRUE(d.isHeld(&dtls, l2));
+  EXPECT_FALSE(d.testOnlyHasEdge(l0, l1));
+  EXPECT_TRUE(d.testOnlyHasEdge(l1, l2));
+  d.onUnlock(&dtls, l0);
+  d.onUnlock(&dtls, l1);
+  d.onUnlock(&dtls, l2);
+}
+
+TEST(DeadlockDetector, TryLockTest) {
+  RunTryLockTest<BV1>();
+  RunTryLockTest<BV2>();
+}
+
+template <class BV>
+void RunOnFirstLockTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+
+  uptr l0 = d.newNode(0);
+  uptr l1 = d.newNode(0);
+  EXPECT_FALSE(d.onFirstLock(&dtls, l0));  // dtls has old epoch.
+  d.onLock(&dtls, l0);
+  d.onUnlock(&dtls, l0);
+
+  EXPECT_TRUE(d.onFirstLock(&dtls, l0));  // Ok, same ecpoch, first lock.
+  EXPECT_FALSE(d.onFirstLock(&dtls, l1));  // Second lock.
+  d.onLock(&dtls, l1);
+  d.onUnlock(&dtls, l1);
+  d.onUnlock(&dtls, l0);
+
+  EXPECT_TRUE(d.onFirstLock(&dtls, l0));  // Ok
+  d.onUnlock(&dtls, l0);
+
+  vector<uptr> locks1;
+  for (uptr i = 0; i < d.size(); i++)
+    locks1.push_back(d.newNode(i));
+
+  EXPECT_TRUE(d.onFirstLock(&dtls, l0));  // Epoch has changed, but not in dtls.
+
+  uptr l3 = d.newNode(0);
+  d.onLock(&dtls, l3);
+  d.onUnlock(&dtls, l3);
+
+  EXPECT_FALSE(d.onFirstLock(&dtls, l0));  // Epoch has changed in dtls.
+}
+
+TEST(DeadlockDetector, onFirstLockTest) {
+  RunOnFirstLockTest<BV2>();
+}
+
+template <class BV>
+void RunRecusriveLockTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+
+  uptr l0 = d.newNode(0);
+  uptr l1 = d.newNode(0);
+  uptr l2 = d.newNode(0);
+  uptr l3 = d.newNode(0);
+
+  EXPECT_FALSE(d.onLock(&dtls, l0));
+  EXPECT_FALSE(d.onLock(&dtls, l1));
+  EXPECT_FALSE(d.onLock(&dtls, l0));  // Recurisve.
+  EXPECT_FALSE(d.onLock(&dtls, l2));
+  d.onUnlock(&dtls, l0);
+  EXPECT_FALSE(d.onLock(&dtls, l3));
+  d.onUnlock(&dtls, l0);
+  d.onUnlock(&dtls, l1);
+  d.onUnlock(&dtls, l2);
+  d.onUnlock(&dtls, l3);
+  EXPECT_TRUE(d.testOnlyHasEdge(l0, l1));
+  EXPECT_TRUE(d.testOnlyHasEdge(l0, l2));
+  EXPECT_TRUE(d.testOnlyHasEdge(l0, l3));
+}
+
+TEST(DeadlockDetector, RecusriveLockTest) {
+  RunRecusriveLockTest<BV2>();
+}
+
+template <class BV>
+void RunLockContextTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+
+  uptr l0 = d.newNode(0);
+  uptr l1 = d.newNode(0);
+  uptr l2 = d.newNode(0);
+  uptr l3 = d.newNode(0);
+  uptr l4 = d.newNode(0);
+  EXPECT_FALSE(d.onLock(&dtls, l0, 10));
+  EXPECT_FALSE(d.onLock(&dtls, l1, 11));
+  EXPECT_FALSE(d.onLock(&dtls, l2, 12));
+  EXPECT_FALSE(d.onLock(&dtls, l3, 13));
+  EXPECT_EQ(10U, d.findLockContext(&dtls, l0));
+  EXPECT_EQ(11U, d.findLockContext(&dtls, l1));
+  EXPECT_EQ(12U, d.findLockContext(&dtls, l2));
+  EXPECT_EQ(13U, d.findLockContext(&dtls, l3));
+  d.onUnlock(&dtls, l0);
+  EXPECT_EQ(0U, d.findLockContext(&dtls, l0));
+  EXPECT_EQ(11U, d.findLockContext(&dtls, l1));
+  EXPECT_EQ(12U, d.findLockContext(&dtls, l2));
+  EXPECT_EQ(13U, d.findLockContext(&dtls, l3));
+  d.onUnlock(&dtls, l2);
+  EXPECT_EQ(0U, d.findLockContext(&dtls, l0));
+  EXPECT_EQ(11U, d.findLockContext(&dtls, l1));
+  EXPECT_EQ(0U, d.findLockContext(&dtls, l2));
+  EXPECT_EQ(13U, d.findLockContext(&dtls, l3));
+
+  EXPECT_FALSE(d.onLock(&dtls, l4, 14));
+  EXPECT_EQ(14U, d.findLockContext(&dtls, l4));
+}
+
+TEST(DeadlockDetector, LockContextTest) {
+  RunLockContextTest<BV2>();
+}
+
+template <class BV>
+void RunRemoveEdgesTest() {
+  ScopedDD<BV> sdd;
+  DeadlockDetector<BV> &d = *sdd.dp;
+  DeadlockDetectorTLS<BV> &dtls = sdd.dtls;
+  vector<uptr> node(BV::kSize);
+  u32 stk_from = 0, stk_to = 0;
+  int unique_tid = 0;
+  for (size_t i = 0; i < BV::kSize; i++)
+    node[i] = d.newNode(0);
+
+  for (size_t i = 0; i < BV::kSize; i++)
+    EXPECT_FALSE(d.onLock(&dtls, node[i], i + 1));
+  for (size_t i = 0; i < BV::kSize; i++) {
+    for (uptr j = i + 1; j < BV::kSize; j++) {
+      EXPECT_TRUE(
+          d.findEdge(node[i], node[j], &stk_from, &stk_to, &unique_tid));
+      EXPECT_EQ(stk_from, i + 1);
+      EXPECT_EQ(stk_to, j + 1);
+    }
+  }
+  EXPECT_EQ(d.testOnlyGetEpoch(), d.size());
+  // Remove and re-create half of the nodes.
+  for (uptr i = 1; i < BV::kSize; i += 2)
+    d.removeNode(node[i]);
+  for (uptr i = 1; i < BV::kSize; i += 2)
+    node[i] = d.newNode(0);
+  EXPECT_EQ(d.testOnlyGetEpoch(), d.size());
+  // The edges from or to the removed nodes should be gone.
+  for (size_t i = 0; i < BV::kSize; i++) {
+    for (uptr j = i + 1; j < BV::kSize; j++) {
+      if ((i % 2) || (j % 2))
+        EXPECT_FALSE(
+            d.findEdge(node[i], node[j], &stk_from, &stk_to, &unique_tid));
+      else
+        EXPECT_TRUE(
+            d.findEdge(node[i], node[j], &stk_from, &stk_to, &unique_tid));
+    }
+  }
+}
+
+TEST(DeadlockDetector, RemoveEdgesTest) {
+  RunRemoveEdgesTest<BV1>();
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_flags_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_flags_test.cc
new file mode 100644
index 0000000..3e5d838
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_flags_test.cc
@@ -0,0 +1,142 @@
+//===-- sanitizer_flags_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "gtest/gtest.h"
+
+#include <string.h>
+
+namespace __sanitizer {
+
+static const char kFlagName[] = "flag_name";
+static const char kFlagDesc[] = "flag description";
+
+template <typename T>
+static void TestFlag(T start_value, const char *env, T final_value) {
+  T flag = start_value;
+
+  FlagParser parser;
+  RegisterFlag(&parser, kFlagName, kFlagDesc, &flag);
+
+  parser.ParseString(env);
+
+  EXPECT_EQ(final_value, flag);
+}
+
+template <>
+void TestFlag(const char *start_value, const char *env,
+                     const char *final_value) {
+  const char *flag = start_value;
+
+  FlagParser parser;
+  RegisterFlag(&parser, kFlagName, kFlagDesc, &flag);
+
+  parser.ParseString(env);
+
+  EXPECT_EQ(0, internal_strcmp(final_value, flag));
+}
+
+TEST(SanitizerCommon, BooleanFlags) {
+  TestFlag(false, "flag_name=1", true);
+  TestFlag(false, "flag_name=yes", true);
+  TestFlag(false, "flag_name=true", true);
+  TestFlag(true, "flag_name=0", false);
+  TestFlag(true, "flag_name=no", false);
+  TestFlag(true, "flag_name=false", false);
+}
+
+TEST(SanitizerCommon, IntFlags) {
+  TestFlag(-11, 0, -11);
+  TestFlag(-11, "flag_name=0", 0);
+  TestFlag(-11, "flag_name=42", 42);
+  TestFlag(-11, "flag_name=-42", -42);
+
+  // Unrecognized flags are ignored.
+  TestFlag(-11, "--flag_name=42", -11);
+  TestFlag(-11, "zzzzzzz=42", -11);
+
+  EXPECT_DEATH(TestFlag(-11, "flag_name", 0), "expected '='");
+  EXPECT_DEATH(TestFlag(-11, "flag_name=42U", 0),
+               "Invalid value for int option");
+}
+
+TEST(SanitizerCommon, StrFlags) {
+  TestFlag("zzz", 0, "zzz");
+  TestFlag("zzz", "flag_name=", "");
+  TestFlag("zzz", "flag_name=abc", "abc");
+  TestFlag("", "flag_name=abc", "abc");
+  TestFlag("", "flag_name='abc zxc'", "abc zxc");
+  // TestStrFlag("", "flag_name=\"abc qwe\" asd", "abc qwe");
+}
+
+static void TestTwoFlags(const char *env, bool expected_flag1,
+                         const char *expected_flag2,
+                         const char *name1 = "flag1",
+                         const char *name2 = "flag2") {
+  bool flag1 = !expected_flag1;
+  const char *flag2 = "";
+
+  FlagParser parser;
+  RegisterFlag(&parser, name1, kFlagDesc, &flag1);
+  RegisterFlag(&parser, name2, kFlagDesc, &flag2);
+
+  parser.ParseString(env);
+
+  EXPECT_EQ(expected_flag1, flag1);
+  EXPECT_EQ(0, internal_strcmp(flag2, expected_flag2));
+}
+
+TEST(SanitizerCommon, MultipleFlags) {
+  TestTwoFlags("flag1=1 flag2='zzz'", true, "zzz");
+  TestTwoFlags("flag2='qxx' flag1=0", false, "qxx");
+  TestTwoFlags("flag1=false:flag2='zzz'", false, "zzz");
+  TestTwoFlags("flag2=qxx:flag1=yes", true, "qxx");
+  TestTwoFlags("flag2=qxx\nflag1=yes", true, "qxx");
+  TestTwoFlags("flag2=qxx\r\nflag1=yes", true, "qxx");
+  TestTwoFlags("flag2=qxx\tflag1=yes", true, "qxx");
+}
+
+TEST(SanitizerCommon, CommonSuffixFlags) {
+  TestTwoFlags("flag=1 other_flag='zzz'", true, "zzz", "flag", "other_flag");
+  TestTwoFlags("other_flag='zzz' flag=1", true, "zzz", "flag", "other_flag");
+  TestTwoFlags("other_flag=' flag=0 ' flag=1", true, " flag=0 ", "flag",
+               "other_flag");
+  TestTwoFlags("flag=1 other_flag=' flag=0 '", true, " flag=0 ", "flag",
+               "other_flag");
+}
+
+TEST(SanitizerCommon, CommonFlags) {
+  CommonFlags cf;
+  FlagParser parser;
+  RegisterCommonFlags(&parser, &cf);
+
+  cf.SetDefaults();
+  EXPECT_TRUE(cf.symbolize);
+  EXPECT_STREQ(".", cf.coverage_dir);
+
+  cf.symbolize = false;
+  cf.coverage = true;
+  cf.coverage_direct = true;
+  cf.log_path = "path/one";
+
+  parser.ParseString("symbolize=1:coverage_direct=false log_path='path/two'");
+  EXPECT_TRUE(cf.symbolize);
+  EXPECT_TRUE(cf.coverage);
+  EXPECT_FALSE(cf.coverage_direct);
+  EXPECT_STREQ("path/two", cf.log_path);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_format_interceptor_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_format_interceptor_test.cc
new file mode 100644
index 0000000..13918af
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_format_interceptor_test.cc
@@ -0,0 +1,259 @@
+//===-- sanitizer_format_interceptor_test.cc ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for *scanf interceptors implementation in sanitizer_common.
+//
+//===----------------------------------------------------------------------===//
+#include <algorithm>
+#include <vector>
+
+#include "interception/interception.h"
+#include "sanitizer_test_utils.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "gtest/gtest.h"
+
+using namespace __sanitizer;
+
+#define COMMON_INTERCEPTOR_READ_WRITE_RANGE(ctx, ptr, size)                    \
+  do {                                                                         \
+    ((std::vector<unsigned> *)ctx)->push_back(size);                           \
+    ptr = ptr;                                                                 \
+  } while (0)
+
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size)                          \
+  COMMON_INTERCEPTOR_READ_WRITE_RANGE(ctx, ptr, size)
+
+#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size)                         \
+  COMMON_INTERCEPTOR_READ_WRITE_RANGE(ctx, ptr, size)
+
+#define SANITIZER_INTERCEPT_PRINTF 1
+#include "sanitizer_common/sanitizer_common_interceptors_format.inc"
+
+static const unsigned I = sizeof(int);
+static const unsigned L = sizeof(long);
+static const unsigned LL = sizeof(long long);
+static const unsigned S = sizeof(short);
+static const unsigned C = sizeof(char);
+static const unsigned LC = sizeof(wchar_t);
+static const unsigned D = sizeof(double);
+static const unsigned LD = sizeof(long double);
+static const unsigned F = sizeof(float);
+static const unsigned P = sizeof(char *);
+
+static void verifyFormatResults(const char *format, unsigned n,
+                                const std::vector<unsigned> &computed_sizes,
+                                va_list expected_sizes) {
+  // "+ 1" because of format string
+  ASSERT_EQ(n + 1,
+            computed_sizes.size()) << "Unexpected number of format arguments: '"
+                                   << format << "'";
+  for (unsigned i = 0; i < n; ++i)
+    EXPECT_EQ(va_arg(expected_sizes, unsigned), computed_sizes[i + 1])
+        << "Unexpect write size for argument " << i << ", format string '"
+        << format << "'";
+}
+
+static const char test_buf[] = "Test string.";
+static const size_t test_buf_size = sizeof(test_buf);
+
+static const unsigned SCANF_ARGS_MAX = 16;
+
+static void testScanf3(void *ctx, int result, bool allowGnuMalloc,
+                       const char *format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  scanf_common(ctx, result, allowGnuMalloc, format, ap);
+  va_end(ap);
+}
+
+static void testScanf2(const char *format, int scanf_result,
+                       bool allowGnuMalloc, unsigned n,
+                       va_list expected_sizes) {
+  std::vector<unsigned> scanf_sizes;
+  // 16 args should be enough.
+  testScanf3((void *)&scanf_sizes, scanf_result, allowGnuMalloc, format,
+             test_buf, test_buf, test_buf, test_buf, test_buf, test_buf,
+             test_buf, test_buf, test_buf, test_buf, test_buf, test_buf,
+             test_buf, test_buf, test_buf, test_buf);
+  verifyFormatResults(format, n, scanf_sizes, expected_sizes);
+}
+
+static void testScanf(const char *format, unsigned n, ...) {
+  va_list ap;
+  va_start(ap, n);
+  testScanf2(format, SCANF_ARGS_MAX, /* allowGnuMalloc */ true, n, ap);
+  va_end(ap);
+}
+
+static void testScanfPartial(const char *format, int scanf_result, unsigned n,
+                             ...) {
+  va_list ap;
+  va_start(ap, n);
+  testScanf2(format, scanf_result, /* allowGnuMalloc */ true,  n, ap);
+  va_end(ap);
+}
+
+static void testScanfNoGnuMalloc(const char *format, unsigned n, ...) {
+  va_list ap;
+  va_start(ap, n);
+  testScanf2(format, SCANF_ARGS_MAX, /* allowGnuMalloc */ false, n, ap);
+  va_end(ap);
+}
+
+TEST(SanitizerCommonInterceptors, Scanf) {
+  testScanf("%d", 1, I);
+  testScanf("%d%d%d", 3, I, I, I);
+  testScanf("ab%u%dc", 2, I, I);
+  testScanf("%ld", 1, L);
+  testScanf("%llu", 1, LL);
+  testScanf("%qd", 1, LL);
+  testScanf("a %hd%hhx", 2, S, C);
+  testScanf("%c", 1, C);
+  testScanf("%lc", 1, LC);
+
+  testScanf("%%", 0);
+  testScanf("a%%", 0);
+  testScanf("a%%b", 0);
+  testScanf("a%%%%b", 0);
+  testScanf("a%%b%%", 0);
+  testScanf("a%%%%%%b", 0);
+  testScanf("a%%%%%b", 0);
+  testScanf("a%%%%%f", 1, F);
+  testScanf("a%%%lxb", 1, L);
+  testScanf("a%lf%%%lxb", 2, D, L);
+  testScanf("%nf", 1, I);
+
+  testScanf("%10s", 1, 11);
+  testScanf("%10c", 1, 10);
+  testScanf("%10ls", 1, 11 * LC);
+  testScanf("%10lc", 1, 10 * LC);
+  testScanf("%%10s", 0);
+  testScanf("%*10s", 0);
+  testScanf("%*d", 0);
+
+  testScanf("%4d%8f%c", 3, I, F, C);
+  testScanf("%s%d", 2, test_buf_size, I);
+  testScanf("%[abc]", 1, test_buf_size);
+  testScanf("%4[bcdef]", 1, 5);
+  testScanf("%[]]", 1, test_buf_size);
+  testScanf("%8[^]%d0-9-]%c", 2, 9, C);
+
+  testScanf("%*[^:]%n:%d:%1[ ]%n", 4, I, I, 2, I);
+
+  testScanf("%*d%u", 1, I);
+
+  testScanf("%c%d", 2, C, I);
+  testScanf("%A%lf", 2, F, D);
+
+  testScanf("%ms %Lf", 2, P, LD);
+  testScanf("s%Las", 1, LD);
+  testScanf("%ar", 1, F);
+
+  // In the cases with std::min below the format spec can be interpreted as
+  // either floating-something, or (GNU extension) callee-allocated string.
+  // Our conservative implementation reports one of the two possibilities with
+  // the least store range.
+  testScanf("%a[", 0);
+  testScanf("%a[]", 0);
+  testScanf("%a[]]", 1, std::min(F, P));
+  testScanf("%a[abc]", 1, std::min(F, P));
+  testScanf("%a[^abc]", 1, std::min(F, P));
+  testScanf("%a[ab%c] %d", 0);
+  testScanf("%a[^ab%c] %d", 0);
+  testScanf("%as", 1, std::min(F, P));
+  testScanf("%aS", 1, std::min(F, P));
+  testScanf("%a13S", 1, std::min(F, P));
+  testScanf("%alS", 1, std::min(F, P));
+
+  testScanfNoGnuMalloc("s%Las", 1, LD);
+  testScanfNoGnuMalloc("%ar", 1, F);
+  testScanfNoGnuMalloc("%a[", 1, F);
+  testScanfNoGnuMalloc("%a[]", 1, F);
+  testScanfNoGnuMalloc("%a[]]", 1, F);
+  testScanfNoGnuMalloc("%a[abc]", 1, F);
+  testScanfNoGnuMalloc("%a[^abc]", 1, F);
+  testScanfNoGnuMalloc("%a[ab%c] %d", 3, F, C, I);
+  testScanfNoGnuMalloc("%a[^ab%c] %d", 3, F, C, I);
+  testScanfNoGnuMalloc("%as", 1, F);
+  testScanfNoGnuMalloc("%aS", 1, F);
+  testScanfNoGnuMalloc("%a13S", 1, F);
+  testScanfNoGnuMalloc("%alS", 1, F);
+
+  testScanf("%5$d", 0);
+  testScanf("%md", 0);
+  testScanf("%m10s", 0);
+
+  testScanfPartial("%d%d%d%d //1\n", 1, 1, I);
+  testScanfPartial("%d%d%d%d //2\n", 2, 2, I, I);
+  testScanfPartial("%d%d%d%d //3\n", 3, 3, I, I, I);
+  testScanfPartial("%d%d%d%d //4\n", 4, 4, I, I, I, I);
+
+  testScanfPartial("%d%n%n%d //1\n", 1, 3, I, I, I);
+  testScanfPartial("%d%n%n%d //2\n", 2, 4, I, I, I, I);
+
+  testScanfPartial("%d%n%n%d %s %s", 3, 5, I, I, I, I, test_buf_size);
+  testScanfPartial("%d%n%n%d %s %s", 4, 6, I, I, I, I, test_buf_size,
+                   test_buf_size);
+}
+
+static void testPrintf3(void *ctx, const char *format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  printf_common(ctx, format, ap);
+  va_end(ap);
+}
+
+static void testPrintf2(const char *format, unsigned n,
+                       va_list expected_sizes) {
+  std::vector<unsigned> printf_sizes;
+  // 16 args should be enough.
+  testPrintf3((void *)&printf_sizes, format,
+             test_buf, test_buf, test_buf, test_buf, test_buf, test_buf,
+             test_buf, test_buf, test_buf, test_buf, test_buf, test_buf,
+             test_buf, test_buf, test_buf, test_buf);
+  verifyFormatResults(format, n, printf_sizes, expected_sizes);
+}
+
+static void testPrintf(const char *format, unsigned n, ...) {
+  va_list ap;
+  va_start(ap, n);
+  testPrintf2(format, n, ap);
+  va_end(ap);
+}
+
+TEST(SanitizerCommonInterceptors, Printf) {
+  // Only test functionality which differs from scanf
+
+  // Indexed arguments
+  testPrintf("%5$d", 0);
+  testPrintf("%.*5$d", 0);
+
+  // errno
+  testPrintf("%0-m", 0);
+
+  // Dynamic width
+  testPrintf("%*n", 1, I);
+  testPrintf("%*.10n", 1, I);
+
+  // Precision
+  testPrintf("%10.10n", 1, I);
+  testPrintf("%.3s", 1, 3);
+  testPrintf("%.20s", 1, test_buf_size);
+
+  // Dynamic precision
+  testPrintf("%.*n", 1, I);
+  testPrintf("%10.*n", 1, I);
+
+  // Dynamic precision for strings is not implemented yet.
+  testPrintf("%.*s", 1, 0);
+
+  // Checks for wide-character strings are not implemented yet.
+  testPrintf("%ls", 1, 0);
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_ioctl_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_ioctl_test.cc
new file mode 100644
index 0000000..22fa522
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_ioctl_test.cc
@@ -0,0 +1,103 @@
+//===-- sanitizer_ioctl_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for ioctl interceptor implementation in sanitizer_common.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_LINUX
+
+#include <linux/input.h>
+#include <vector>
+
+#include "interception/interception.h"
+#include "sanitizer_test_utils.h"
+#include "sanitizer_common/sanitizer_platform_limits_posix.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "gtest/gtest.h"
+
+
+using namespace __sanitizer;
+
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, sz) \
+  do {                                              \
+    (void) ctx;                                     \
+    (void) ptr;                                     \
+    (void) sz;                                      \
+  } while (0)
+#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, sz) \
+  do {                                               \
+    (void) ctx;                                      \
+    (void) ptr;                                      \
+    (void) sz;                                       \
+  } while (0)
+
+#include "sanitizer_common/sanitizer_common_interceptors_ioctl.inc"
+
+static struct IoctlInit {
+  IoctlInit() {
+    ioctl_init();
+    // Avoid unused function warnings.
+    (void)&ioctl_common_pre;
+    (void)&ioctl_common_post;
+    (void)&ioctl_decode;
+  }
+} ioctl_static_initializer;
+
+TEST(SanitizerIoctl, Fixup) {
+  EXPECT_EQ((unsigned)FIONBIO, ioctl_request_fixup(FIONBIO));
+
+  EXPECT_EQ(EVIOCGBIT(0, 0), ioctl_request_fixup(EVIOCGBIT(0, 16)));
+  EXPECT_EQ(EVIOCGBIT(0, 0), ioctl_request_fixup(EVIOCGBIT(1, 16)));
+  EXPECT_EQ(EVIOCGBIT(0, 0), ioctl_request_fixup(EVIOCGBIT(1, 17)));
+  EXPECT_EQ(EVIOCGBIT(0, 0), ioctl_request_fixup(EVIOCGBIT(31, 16)));
+  EXPECT_NE(EVIOCGBIT(0, 0), ioctl_request_fixup(EVIOCGBIT(32, 16)));
+
+  EXPECT_EQ(EVIOCGABS(0), ioctl_request_fixup(EVIOCGABS(0)));
+  EXPECT_EQ(EVIOCGABS(0), ioctl_request_fixup(EVIOCGABS(5)));
+  EXPECT_EQ(EVIOCGABS(0), ioctl_request_fixup(EVIOCGABS(63)));
+  EXPECT_NE(EVIOCGABS(0), ioctl_request_fixup(EVIOCGABS(64)));
+
+  EXPECT_EQ(EVIOCSABS(0), ioctl_request_fixup(EVIOCSABS(0)));
+  EXPECT_EQ(EVIOCSABS(0), ioctl_request_fixup(EVIOCSABS(5)));
+  EXPECT_EQ(EVIOCSABS(0), ioctl_request_fixup(EVIOCSABS(63)));
+  EXPECT_NE(EVIOCSABS(0), ioctl_request_fixup(EVIOCSABS(64)));
+
+  const ioctl_desc *desc = ioctl_lookup(EVIOCGKEY(16));
+  EXPECT_NE((void *)0, desc);
+  EXPECT_EQ(EVIOCGKEY(0), desc->req);
+}
+
+// Test decoding KVM ioctl numbers.
+TEST(SanitizerIoctl, KVM_GET_MP_STATE) {
+  ioctl_desc desc;
+  bool res = ioctl_decode(0x8004ae98U, &desc);
+  EXPECT_TRUE(res);
+  EXPECT_EQ(ioctl_desc::WRITE, desc.type);
+  EXPECT_EQ(4U, desc.size);
+}
+
+TEST(SanitizerIoctl, KVM_GET_LAPIC) {
+  ioctl_desc desc;
+  bool res = ioctl_decode(0x8400ae8eU, &desc);
+  EXPECT_TRUE(res);
+  EXPECT_EQ(ioctl_desc::WRITE, desc.type);
+  EXPECT_EQ(1024U, desc.size);
+}
+
+TEST(SanitizerIoctl, KVM_GET_MSR_INDEX_LIST) {
+  ioctl_desc desc;
+  bool res = ioctl_decode(0xc004ae02U, &desc);
+  EXPECT_TRUE(res);
+  EXPECT_EQ(ioctl_desc::READWRITE, desc.type);
+  EXPECT_EQ(4U, desc.size);
+}
+
+#endif // SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_libc_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_libc_test.cc
new file mode 100644
index 0000000..015e32a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_libc_test.cc
@@ -0,0 +1,241 @@
+//===-- sanitizer_libc_test.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Tests for sanitizer_libc.h.
+//===----------------------------------------------------------------------===//
+#include <algorithm>
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_platform.h"
+#include "gtest/gtest.h"
+
+#if SANITIZER_WINDOWS
+#define NOMINMAX
+#include <windows.h>
+#undef NOMINMAX
+#endif
+#if SANITIZER_POSIX
+# include <sys/stat.h>
+# include "sanitizer_common/sanitizer_posix.h"
+#endif
+
+// A regression test for internal_memmove() implementation.
+TEST(SanitizerCommon, InternalMemmoveRegression) {
+  char src[] = "Hello World";
+  char *dest = src + 6;
+  __sanitizer::internal_memmove(dest, src, 5);
+  EXPECT_EQ(dest[0], src[0]);
+  EXPECT_EQ(dest[4], src[4]);
+}
+
+TEST(SanitizerCommon, mem_is_zero) {
+  size_t size = 128;
+  char *x = new char[size];
+  memset(x, 0, size);
+  for (size_t pos = 0; pos < size; pos++) {
+    x[pos] = 1;
+    for (size_t beg = 0; beg < size; beg++) {
+      for (size_t end = beg; end < size; end++) {
+        // fprintf(stderr, "pos %zd beg %zd end %zd \n", pos, beg, end);
+        if (beg <= pos && pos < end)
+          EXPECT_FALSE(__sanitizer::mem_is_zero(x + beg, end - beg));
+        else
+          EXPECT_TRUE(__sanitizer::mem_is_zero(x + beg, end - beg));
+      }
+    }
+    x[pos] = 0;
+  }
+  delete [] x;
+}
+
+struct stat_and_more {
+  struct stat st;
+  unsigned char z;
+};
+
+static void temp_file_name(char *buf, size_t bufsize, const char *prefix) {
+#if SANITIZER_WINDOWS
+  buf[0] = '\0';
+  char tmp_dir[MAX_PATH];
+  if (!::GetTempPathA(MAX_PATH, tmp_dir))
+    return;
+  // GetTempFileNameA needs a MAX_PATH buffer.
+  char tmp_path[MAX_PATH];
+  if (!::GetTempFileNameA(tmp_dir, prefix, 0, tmp_path))
+    return;
+  internal_strncpy(buf, tmp_path, bufsize);
+#else
+  const char *tmpdir = "/tmp";
+#if SANITIZER_ANDROID
+  // I don't know a way to query temp directory location on Android without
+  // going through Java interfaces. The code below is not ideal, but should
+  // work. May require "adb root", but it is needed for almost any use of ASan
+  // on Android already.
+  tmpdir = GetEnv("EXTERNAL_STORAGE");
+#endif
+  u32 uid = GetUid();
+  internal_snprintf(buf, bufsize, "%s/%s%d", tmpdir, prefix, uid);
+#endif
+}
+
+TEST(SanitizerCommon, FileOps) {
+  const char *str1 = "qwerty";
+  uptr len1 = internal_strlen(str1);
+  const char *str2 = "zxcv";
+  uptr len2 = internal_strlen(str2);
+
+  char tmpfile[128];
+  temp_file_name(tmpfile, sizeof(tmpfile), "sanitizer_common.fileops.tmp.");
+  fd_t fd = OpenFile(tmpfile, WrOnly);
+  ASSERT_NE(fd, kInvalidFd);
+  uptr bytes_written = 0;
+  EXPECT_TRUE(WriteToFile(fd, str1, len1, &bytes_written));
+  EXPECT_EQ(len1, bytes_written);
+  EXPECT_TRUE(WriteToFile(fd, str2, len2, &bytes_written));
+  EXPECT_EQ(len2, bytes_written);
+  CloseFile(fd);
+
+  EXPECT_TRUE(FileExists(tmpfile));
+
+  fd = OpenFile(tmpfile, RdOnly);
+  ASSERT_NE(fd, kInvalidFd);
+
+#if SANITIZER_POSIX
+  // The stat wrappers are posix-only.
+  uptr fsize = internal_filesize(fd);
+  EXPECT_EQ(len1 + len2, fsize);
+
+  struct stat st1, st2, st3;
+  EXPECT_EQ(0u, internal_stat(tmpfile, &st1));
+  EXPECT_EQ(0u, internal_lstat(tmpfile, &st2));
+  EXPECT_EQ(0u, internal_fstat(fd, &st3));
+  EXPECT_EQ(fsize, (uptr)st3.st_size);
+
+  // Verify that internal_fstat does not write beyond the end of the supplied
+  // buffer.
+  struct stat_and_more sam;
+  memset(&sam, 0xAB, sizeof(sam));
+  EXPECT_EQ(0u, internal_fstat(fd, &sam.st));
+  EXPECT_EQ(0xAB, sam.z);
+  EXPECT_NE(0xAB, sam.st.st_size);
+  EXPECT_NE(0, sam.st.st_size);
+#endif
+
+  char buf[64] = {};
+  uptr bytes_read = 0;
+  EXPECT_TRUE(ReadFromFile(fd, buf, len1, &bytes_read));
+  EXPECT_EQ(len1, bytes_read);
+  EXPECT_EQ(0, internal_memcmp(buf, str1, len1));
+  EXPECT_EQ((char)0, buf[len1 + 1]);
+  internal_memset(buf, 0, len1);
+  EXPECT_TRUE(ReadFromFile(fd, buf, len2, &bytes_read));
+  EXPECT_EQ(len2, bytes_read);
+  EXPECT_EQ(0, internal_memcmp(buf, str2, len2));
+  CloseFile(fd);
+
+#if SANITIZER_WINDOWS
+  // No sanitizer needs to delete a file on Windows yet. If we ever do, we can
+  // add a portable wrapper and test it from here.
+  ::DeleteFileA(&tmpfile[0]);
+#else
+  internal_unlink(tmpfile);
+#endif
+}
+
+static const size_t kStrlcpyBufSize = 8;
+void test_internal_strlcpy(char *dbuf, const char *sbuf) {
+  uptr retval = 0;
+  retval = internal_strlcpy(dbuf, sbuf, kStrlcpyBufSize);
+  EXPECT_EQ(internal_strncmp(dbuf, sbuf, kStrlcpyBufSize - 1), 0);
+  EXPECT_EQ(internal_strlen(dbuf),
+            std::min(internal_strlen(sbuf), (uptr)(kStrlcpyBufSize - 1)));
+  EXPECT_EQ(retval, internal_strlen(sbuf));
+
+  // Test with shorter maxlen.
+  uptr maxlen = 2;
+  if (internal_strlen(sbuf) > maxlen) {
+    retval = internal_strlcpy(dbuf, sbuf, maxlen);
+    EXPECT_EQ(internal_strncmp(dbuf, sbuf, maxlen - 1), 0);
+    EXPECT_EQ(internal_strlen(dbuf), maxlen - 1);
+  }
+}
+
+TEST(SanitizerCommon, InternalStrFunctions) {
+  const char *haystack = "haystack";
+  EXPECT_EQ(haystack + 2, internal_strchr(haystack, 'y'));
+  EXPECT_EQ(haystack + 2, internal_strchrnul(haystack, 'y'));
+  EXPECT_EQ(0, internal_strchr(haystack, 'z'));
+  EXPECT_EQ(haystack + 8, internal_strchrnul(haystack, 'z'));
+
+  char dbuf[kStrlcpyBufSize] = {};
+  const char *samesizestr = "1234567";
+  const char *shortstr = "123";
+  const char *longerstr = "123456789";
+
+  // Test internal_strlcpy.
+  internal_strlcpy(dbuf, shortstr, 0);
+  EXPECT_EQ(dbuf[0], 0);
+  EXPECT_EQ(dbuf[0], 0);
+  test_internal_strlcpy(dbuf, samesizestr);
+  test_internal_strlcpy(dbuf, shortstr);
+  test_internal_strlcpy(dbuf, longerstr);
+
+  // Test internal_strlcat.
+  char dcatbuf[kStrlcpyBufSize] = {};
+  uptr retval = 0;
+  retval = internal_strlcat(dcatbuf, "aaa", 0);
+  EXPECT_EQ(internal_strlen(dcatbuf), (uptr)0);
+  EXPECT_EQ(retval, (uptr)3);
+
+  retval = internal_strlcat(dcatbuf, "123", kStrlcpyBufSize);
+  EXPECT_EQ(internal_strcmp(dcatbuf, "123"), 0);
+  EXPECT_EQ(internal_strlen(dcatbuf), (uptr)3);
+  EXPECT_EQ(retval, (uptr)3);
+
+  retval = internal_strlcat(dcatbuf, "123", kStrlcpyBufSize);
+  EXPECT_EQ(internal_strcmp(dcatbuf, "123123"), 0);
+  EXPECT_EQ(internal_strlen(dcatbuf), (uptr)6);
+  EXPECT_EQ(retval, (uptr)6);
+
+  retval = internal_strlcat(dcatbuf, "123", kStrlcpyBufSize);
+  EXPECT_EQ(internal_strcmp(dcatbuf, "1231231"), 0);
+  EXPECT_EQ(internal_strlen(dcatbuf), (uptr)7);
+  EXPECT_EQ(retval, (uptr)9);
+}
+
+// FIXME: File manipulations are not yet supported on Windows
+#if SANITIZER_POSIX && !SANITIZER_MAC
+TEST(SanitizerCommon, InternalMmapWithOffset) {
+  char tmpfile[128];
+  temp_file_name(tmpfile, sizeof(tmpfile),
+                 "sanitizer_common.internalmmapwithoffset.tmp.");
+  fd_t fd = OpenFile(tmpfile, RdWr);
+  ASSERT_NE(fd, kInvalidFd);
+
+  uptr page_size = GetPageSizeCached();
+  uptr res = internal_ftruncate(fd, page_size * 2);
+  ASSERT_FALSE(internal_iserror(res));
+
+  res = internal_lseek(fd, page_size, SEEK_SET);
+  ASSERT_FALSE(internal_iserror(res));
+
+  res = internal_write(fd, "AB", 2);
+  ASSERT_FALSE(internal_iserror(res));
+
+  char *p = (char *)MapWritableFileToMemory(nullptr, page_size, fd, page_size);
+  ASSERT_NE(nullptr, p);
+
+  ASSERT_EQ('A', p[0]);
+  ASSERT_EQ('B', p[1]);
+
+  CloseFile(fd);
+  UnmapOrDie(p, page_size);
+  internal_unlink(tmpfile);
+}
+#endif
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cc
new file mode 100644
index 0000000..eef7101
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cc
@@ -0,0 +1,268 @@
+//===-- sanitizer_linux_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for sanitizer_linux.h
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_LINUX
+
+#include "sanitizer_common/sanitizer_linux.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "gtest/gtest.h"
+
+#include <pthread.h>
+#include <sched.h>
+#include <stdlib.h>
+
+#include <algorithm>
+#include <vector>
+
+namespace __sanitizer {
+
+struct TidReporterArgument {
+  TidReporterArgument() {
+    pthread_mutex_init(&terminate_thread_mutex, NULL);
+    pthread_mutex_init(&tid_reported_mutex, NULL);
+    pthread_cond_init(&terminate_thread_cond, NULL);
+    pthread_cond_init(&tid_reported_cond, NULL);
+    terminate_thread = false;
+  }
+
+  ~TidReporterArgument() {
+    pthread_mutex_destroy(&terminate_thread_mutex);
+    pthread_mutex_destroy(&tid_reported_mutex);
+    pthread_cond_destroy(&terminate_thread_cond);
+    pthread_cond_destroy(&tid_reported_cond);
+  }
+
+  pid_t reported_tid;
+  // For signaling to spawned threads that they should terminate.
+  pthread_cond_t terminate_thread_cond;
+  pthread_mutex_t terminate_thread_mutex;
+  bool terminate_thread;
+  // For signaling to main thread that a child thread has reported its tid.
+  pthread_cond_t tid_reported_cond;
+  pthread_mutex_t tid_reported_mutex;
+
+ private:
+  // Disallow evil constructors
+  TidReporterArgument(const TidReporterArgument &);
+  void operator=(const TidReporterArgument &);
+};
+
+class ThreadListerTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    pthread_t pthread_id;
+    pid_t tid;
+    for (uptr i = 0; i < kThreadCount; i++) {
+      SpawnTidReporter(&pthread_id, &tid);
+      pthread_ids_.push_back(pthread_id);
+      tids_.push_back(tid);
+    }
+  }
+
+  virtual void TearDown() {
+    pthread_mutex_lock(&thread_arg.terminate_thread_mutex);
+    thread_arg.terminate_thread = true;
+    pthread_cond_broadcast(&thread_arg.terminate_thread_cond);
+    pthread_mutex_unlock(&thread_arg.terminate_thread_mutex);
+    for (uptr i = 0; i < pthread_ids_.size(); i++)
+      pthread_join(pthread_ids_[i], NULL);
+  }
+
+  void SpawnTidReporter(pthread_t *pthread_id, pid_t *tid);
+
+  static const uptr kThreadCount = 20;
+
+  std::vector<pthread_t> pthread_ids_;
+  std::vector<pid_t> tids_;
+
+  TidReporterArgument thread_arg;
+};
+
+// Writes its TID once to reported_tid and waits until signaled to terminate.
+void *TidReporterThread(void *argument) {
+  TidReporterArgument *arg = reinterpret_cast<TidReporterArgument *>(argument);
+  pthread_mutex_lock(&arg->tid_reported_mutex);
+  arg->reported_tid = GetTid();
+  pthread_cond_broadcast(&arg->tid_reported_cond);
+  pthread_mutex_unlock(&arg->tid_reported_mutex);
+
+  pthread_mutex_lock(&arg->terminate_thread_mutex);
+  while (!arg->terminate_thread)
+    pthread_cond_wait(&arg->terminate_thread_cond,
+                      &arg->terminate_thread_mutex);
+  pthread_mutex_unlock(&arg->terminate_thread_mutex);
+  return NULL;
+}
+
+void ThreadListerTest::SpawnTidReporter(pthread_t *pthread_id,
+                                        pid_t *tid) {
+  pthread_mutex_lock(&thread_arg.tid_reported_mutex);
+  thread_arg.reported_tid = -1;
+  ASSERT_EQ(0, pthread_create(pthread_id, NULL,
+                              TidReporterThread,
+                              &thread_arg));
+  while (thread_arg.reported_tid == -1)
+    pthread_cond_wait(&thread_arg.tid_reported_cond,
+                      &thread_arg.tid_reported_mutex);
+  pthread_mutex_unlock(&thread_arg.tid_reported_mutex);
+  *tid = thread_arg.reported_tid;
+}
+
+static std::vector<pid_t> ReadTidsToVector(ThreadLister *thread_lister) {
+  std::vector<pid_t> listed_tids;
+  pid_t tid;
+  while ((tid = thread_lister->GetNextTID()) >= 0)
+    listed_tids.push_back(tid);
+  EXPECT_FALSE(thread_lister->error());
+  return listed_tids;
+}
+
+static bool Includes(std::vector<pid_t> first, std::vector<pid_t> second) {
+  std::sort(first.begin(), first.end());
+  std::sort(second.begin(), second.end());
+  return std::includes(first.begin(), first.end(),
+                       second.begin(), second.end());
+}
+
+static bool HasElement(std::vector<pid_t> vector, pid_t element) {
+  return std::find(vector.begin(), vector.end(), element) != vector.end();
+}
+
+// ThreadLister's output should include the current thread's TID and the TID of
+// every thread we spawned.
+TEST_F(ThreadListerTest, ThreadListerSeesAllSpawnedThreads) {
+  pid_t self_tid = GetTid();
+  ThreadLister thread_lister(getpid());
+  std::vector<pid_t> listed_tids = ReadTidsToVector(&thread_lister);
+  ASSERT_TRUE(HasElement(listed_tids, self_tid));
+  ASSERT_TRUE(Includes(listed_tids, tids_));
+}
+
+// Calling Reset() should not cause ThreadLister to forget any threads it's
+// supposed to know about.
+TEST_F(ThreadListerTest, ResetDoesNotForgetThreads) {
+  ThreadLister thread_lister(getpid());
+
+  // Run the loop body twice, because Reset() might behave differently if called
+  // on a freshly created object.
+  for (uptr i = 0; i < 2; i++) {
+    thread_lister.Reset();
+    std::vector<pid_t> listed_tids = ReadTidsToVector(&thread_lister);
+    ASSERT_TRUE(Includes(listed_tids, tids_));
+  }
+}
+
+// If new threads have spawned during ThreadLister object's lifetime, calling
+// Reset() should cause ThreadLister to recognize their existence.
+TEST_F(ThreadListerTest, ResetMakesNewThreadsKnown) {
+  ThreadLister thread_lister(getpid());
+  std::vector<pid_t> threads_before_extra = ReadTidsToVector(&thread_lister);
+
+  pthread_t extra_pthread_id;
+  pid_t extra_tid;
+  SpawnTidReporter(&extra_pthread_id, &extra_tid);
+  // Register the new thread so it gets terminated in TearDown().
+  pthread_ids_.push_back(extra_pthread_id);
+
+  // It would be very bizarre if the new TID had been listed before we even
+  // spawned that thread, but it would also cause a false success in this test,
+  // so better check for that.
+  ASSERT_FALSE(HasElement(threads_before_extra, extra_tid));
+
+  thread_lister.Reset();
+
+  std::vector<pid_t> threads_after_extra = ReadTidsToVector(&thread_lister);
+  ASSERT_TRUE(HasElement(threads_after_extra, extra_tid));
+}
+
+TEST(SanitizerCommon, SetEnvTest) {
+  const char kEnvName[] = "ENV_FOO";
+  SetEnv(kEnvName, "value");
+  EXPECT_STREQ("value", getenv(kEnvName));
+  unsetenv(kEnvName);
+  EXPECT_EQ(0, getenv(kEnvName));
+}
+
+#if (defined(__x86_64__) || defined(__i386__)) && !SANITIZER_ANDROID
+void *thread_self_offset_test_func(void *arg) {
+  bool result =
+      *(uptr *)((char *)ThreadSelf() + ThreadSelfOffset()) == ThreadSelf();
+  return (void *)result;
+}
+
+TEST(SanitizerLinux, ThreadSelfOffset) {
+  EXPECT_TRUE((bool)thread_self_offset_test_func(0));
+  pthread_t tid;
+  void *result;
+  ASSERT_EQ(0, pthread_create(&tid, 0, thread_self_offset_test_func, 0));
+  ASSERT_EQ(0, pthread_join(tid, &result));
+  EXPECT_TRUE((bool)result);
+}
+
+// libpthread puts the thread descriptor at the end of stack space.
+void *thread_descriptor_size_test_func(void *arg) {
+  uptr descr_addr = ThreadSelf();
+  pthread_attr_t attr;
+  pthread_getattr_np(pthread_self(), &attr);
+  void *stackaddr;
+  size_t stacksize;
+  pthread_attr_getstack(&attr, &stackaddr, &stacksize);
+  return (void *)((uptr)stackaddr + stacksize - descr_addr);
+}
+
+TEST(SanitizerLinux, ThreadDescriptorSize) {
+  pthread_t tid;
+  void *result;
+  ASSERT_EQ(0, pthread_create(&tid, 0, thread_descriptor_size_test_func, 0));
+  ASSERT_EQ(0, pthread_join(tid, &result));
+  EXPECT_EQ((uptr)result, ThreadDescriptorSize());
+}
+#endif
+
+TEST(SanitizerCommon, LibraryNameIs) {
+  EXPECT_FALSE(LibraryNameIs("", ""));
+
+  char full_name[256];
+  const char *paths[] = { "", "/", "/path/to/" };
+  const char *suffixes[] = { "", "-linux", ".1.2", "-linux.1.2" };
+  const char *base_names[] = { "lib", "lib.0", "lib-i386" };
+  const char *wrong_names[] = { "", "lib.9", "lib-x86_64" };
+  for (uptr i = 0; i < ARRAY_SIZE(paths); i++)
+    for (uptr j = 0; j < ARRAY_SIZE(suffixes); j++) {
+      for (uptr k = 0; k < ARRAY_SIZE(base_names); k++) {
+        internal_snprintf(full_name, ARRAY_SIZE(full_name), "%s%s%s.so",
+                          paths[i], base_names[k], suffixes[j]);
+        EXPECT_TRUE(LibraryNameIs(full_name, base_names[k]))
+            << "Full name " << full_name
+            << " doesn't match base name " << base_names[k];
+        for (uptr m = 0; m < ARRAY_SIZE(wrong_names); m++)
+          EXPECT_FALSE(LibraryNameIs(full_name, wrong_names[m]))
+            << "Full name " << full_name
+            << " matches base name " << wrong_names[m];
+      }
+    }
+}
+
+#if defined(__mips64)
+// Effectively, this is a test for ThreadDescriptorSize() which is used to
+// compute ThreadSelf().
+TEST(SanitizerLinux, ThreadSelfTest) {
+  ASSERT_EQ(pthread_self(), ThreadSelf());
+}
+#endif
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_list_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_list_test.cc
new file mode 100644
index 0000000..fbe53c0
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_list_test.cc
@@ -0,0 +1,173 @@
+//===-- sanitizer_list_test.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_list.h"
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+struct ListItem {
+  ListItem *next;
+};
+
+typedef IntrusiveList<ListItem> List;
+
+static List static_list;
+
+static void SetList(List *l, ListItem *x = 0,
+                    ListItem *y = 0, ListItem *z = 0) {
+  l->clear();
+  if (x) l->push_back(x);
+  if (y) l->push_back(y);
+  if (z) l->push_back(z);
+}
+
+static void CheckList(List *l, ListItem *i1, ListItem *i2 = 0, ListItem *i3 = 0,
+                      ListItem *i4 = 0, ListItem *i5 = 0, ListItem *i6 = 0) {
+  if (i1) {
+    CHECK_EQ(l->front(), i1);
+    l->pop_front();
+  }
+  if (i2) {
+    CHECK_EQ(l->front(), i2);
+    l->pop_front();
+  }
+  if (i3) {
+    CHECK_EQ(l->front(), i3);
+    l->pop_front();
+  }
+  if (i4) {
+    CHECK_EQ(l->front(), i4);
+    l->pop_front();
+  }
+  if (i5) {
+    CHECK_EQ(l->front(), i5);
+    l->pop_front();
+  }
+  if (i6) {
+    CHECK_EQ(l->front(), i6);
+    l->pop_front();
+  }
+  CHECK(l->empty());
+}
+
+TEST(SanitizerCommon, IntrusiveList) {
+  ListItem items[6];
+  CHECK_EQ(static_list.size(), 0);
+
+  List l;
+  l.clear();
+
+  ListItem *x = &items[0];
+  ListItem *y = &items[1];
+  ListItem *z = &items[2];
+  ListItem *a = &items[3];
+  ListItem *b = &items[4];
+  ListItem *c = &items[5];
+
+  CHECK_EQ(l.size(), 0);
+  l.push_back(x);
+  CHECK_EQ(l.size(), 1);
+  CHECK_EQ(l.back(), x);
+  CHECK_EQ(l.front(), x);
+  l.pop_front();
+  CHECK(l.empty());
+  l.CheckConsistency();
+
+  l.push_front(x);
+  CHECK_EQ(l.size(), 1);
+  CHECK_EQ(l.back(), x);
+  CHECK_EQ(l.front(), x);
+  l.pop_front();
+  CHECK(l.empty());
+  l.CheckConsistency();
+
+  l.push_front(x);
+  l.push_front(y);
+  l.push_front(z);
+  CHECK_EQ(l.size(), 3);
+  CHECK_EQ(l.front(), z);
+  CHECK_EQ(l.back(), x);
+  l.CheckConsistency();
+
+  l.pop_front();
+  CHECK_EQ(l.size(), 2);
+  CHECK_EQ(l.front(), y);
+  CHECK_EQ(l.back(), x);
+  l.pop_front();
+  l.pop_front();
+  CHECK(l.empty());
+  l.CheckConsistency();
+
+  l.push_back(x);
+  l.push_back(y);
+  l.push_back(z);
+  CHECK_EQ(l.size(), 3);
+  CHECK_EQ(l.front(), x);
+  CHECK_EQ(l.back(), z);
+  l.CheckConsistency();
+
+  l.pop_front();
+  CHECK_EQ(l.size(), 2);
+  CHECK_EQ(l.front(), y);
+  CHECK_EQ(l.back(), z);
+  l.pop_front();
+  l.pop_front();
+  CHECK(l.empty());
+  l.CheckConsistency();
+
+  List l1, l2;
+  l1.clear();
+  l2.clear();
+
+  l1.append_front(&l2);
+  CHECK(l1.empty());
+  CHECK(l2.empty());
+
+  l1.append_back(&l2);
+  CHECK(l1.empty());
+  CHECK(l2.empty());
+
+  SetList(&l1, x);
+  CheckList(&l1, x);
+
+  SetList(&l1, x, y, z);
+  SetList(&l2, a, b, c);
+  l1.append_back(&l2);
+  CheckList(&l1, x, y, z, a, b, c);
+  CHECK(l2.empty());
+
+  SetList(&l1, x, y);
+  SetList(&l2);
+  l1.append_front(&l2);
+  CheckList(&l1, x, y);
+  CHECK(l2.empty());
+}
+
+TEST(SanitizerCommon, IntrusiveListAppendEmpty) {
+  ListItem i;
+  List l;
+  l.clear();
+  l.push_back(&i);
+  List l2;
+  l2.clear();
+  l.append_back(&l2);
+  CHECK_EQ(l.back(), &i);
+  CHECK_EQ(l.front(), &i);
+  CHECK_EQ(l.size(), 1);
+  l.append_front(&l2);
+  CHECK_EQ(l.back(), &i);
+  CHECK_EQ(l.front(), &i);
+  CHECK_EQ(l.size(), 1);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_mutex_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_mutex_test.cc
new file mode 100644
index 0000000..d14e7c2
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_mutex_test.cc
@@ -0,0 +1,137 @@
+//===-- sanitizer_mutex_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+#include "sanitizer_pthread_wrappers.h"
+
+#include "gtest/gtest.h"
+
+#include <string.h>
+
+namespace __sanitizer {
+
+template<typename MutexType>
+class TestData {
+ public:
+  explicit TestData(MutexType *mtx)
+      : mtx_(mtx) {
+    for (int i = 0; i < kSize; i++)
+      data_[i] = 0;
+  }
+
+  void Write() {
+    Lock l(mtx_);
+    T v0 = data_[0];
+    for (int i = 0; i < kSize; i++) {
+      CHECK_EQ(data_[i], v0);
+      data_[i]++;
+    }
+  }
+
+  void TryWrite() {
+    if (!mtx_->TryLock())
+      return;
+    T v0 = data_[0];
+    for (int i = 0; i < kSize; i++) {
+      CHECK_EQ(data_[i], v0);
+      data_[i]++;
+    }
+    mtx_->Unlock();
+  }
+
+  void Backoff() {
+    volatile T data[kSize] = {};
+    for (int i = 0; i < kSize; i++) {
+      data[i]++;
+      CHECK_EQ(data[i], 1);
+    }
+  }
+
+ private:
+  typedef GenericScopedLock<MutexType> Lock;
+  static const int kSize = 64;
+  typedef u64 T;
+  MutexType *mtx_;
+  char pad_[kCacheLineSize];
+  T data_[kSize];
+};
+
+const int kThreads = 8;
+#if SANITIZER_DEBUG
+const int kIters = 16*1024;
+#else
+const int kIters = 64*1024;
+#endif
+
+template<typename MutexType>
+static void *lock_thread(void *param) {
+  TestData<MutexType> *data = (TestData<MutexType>*)param;
+  for (int i = 0; i < kIters; i++) {
+    data->Write();
+    data->Backoff();
+  }
+  return 0;
+}
+
+template<typename MutexType>
+static void *try_thread(void *param) {
+  TestData<MutexType> *data = (TestData<MutexType>*)param;
+  for (int i = 0; i < kIters; i++) {
+    data->TryWrite();
+    data->Backoff();
+  }
+  return 0;
+}
+
+template<typename MutexType>
+static void check_locked(MutexType *mtx) {
+  GenericScopedLock<MutexType> l(mtx);
+  mtx->CheckLocked();
+}
+
+TEST(SanitizerCommon, SpinMutex) {
+  SpinMutex mtx;
+  mtx.Init();
+  TestData<SpinMutex> data(&mtx);
+  pthread_t threads[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    PTHREAD_CREATE(&threads[i], 0, lock_thread<SpinMutex>, &data);
+  for (int i = 0; i < kThreads; i++)
+    PTHREAD_JOIN(threads[i], 0);
+}
+
+TEST(SanitizerCommon, SpinMutexTry) {
+  SpinMutex mtx;
+  mtx.Init();
+  TestData<SpinMutex> data(&mtx);
+  pthread_t threads[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    PTHREAD_CREATE(&threads[i], 0, try_thread<SpinMutex>, &data);
+  for (int i = 0; i < kThreads; i++)
+    PTHREAD_JOIN(threads[i], 0);
+}
+
+TEST(SanitizerCommon, BlockingMutex) {
+  u64 mtxmem[1024] = {};
+  BlockingMutex *mtx = new(mtxmem) BlockingMutex(LINKER_INITIALIZED);
+  TestData<BlockingMutex> data(mtx);
+  pthread_t threads[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    PTHREAD_CREATE(&threads[i], 0, lock_thread<BlockingMutex>, &data);
+  for (int i = 0; i < kThreads; i++)
+    PTHREAD_JOIN(threads[i], 0);
+  check_locked(mtx);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_nolibc_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_nolibc_test.cc
new file mode 100644
index 0000000..d0d5a5e
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_nolibc_test.cc
@@ -0,0 +1,31 @@
+//===-- sanitizer_nolibc_test.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Tests for libc independence of sanitizer_common.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+
+#include "gtest/gtest.h"
+
+#include <stdlib.h>
+
+extern const char *argv0;
+
+#if SANITIZER_LINUX && defined(__x86_64__)
+TEST(SanitizerCommon, NolibcMain) {
+  std::string NolibcTestPath = argv0;
+  NolibcTestPath += "-Nolibc";
+  int status = system(NolibcTestPath.c_str());
+  EXPECT_EQ(true, WIFEXITED(status));
+  EXPECT_EQ(0, WEXITSTATUS(status));
+}
+#endif
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_nolibc_test_main.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_nolibc_test_main.cc
new file mode 100644
index 0000000..72df621
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_nolibc_test_main.cc
@@ -0,0 +1,19 @@
+//===-- sanitizer_nolibc_test_main.cc -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+// Tests for libc independence of sanitizer_common.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_libc.h"
+
+extern "C" void _start() {
+  internal__exit(0);
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_posix_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_posix_test.cc
new file mode 100644
index 0000000..03ca449
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_posix_test.cc
@@ -0,0 +1,80 @@
+//===-- sanitizer_posix_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for POSIX-specific code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_POSIX
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "gtest/gtest.h"
+
+#include <pthread.h>
+#include <sys/mman.h>
+
+namespace __sanitizer {
+
+static pthread_key_t key;
+static bool destructor_executed;
+
+extern "C"
+void destructor(void *arg) {
+  uptr iter = reinterpret_cast<uptr>(arg);
+  if (iter > 1) {
+    ASSERT_EQ(0, pthread_setspecific(key, reinterpret_cast<void *>(iter - 1)));
+    return;
+  }
+  destructor_executed = true;
+}
+
+extern "C"
+void *thread_func(void *arg) {
+  return reinterpret_cast<void*>(pthread_setspecific(key, arg));
+}
+
+static void SpawnThread(uptr iteration) {
+  destructor_executed = false;
+  pthread_t tid;
+  ASSERT_EQ(0, pthread_create(&tid, 0, &thread_func,
+                              reinterpret_cast<void *>(iteration)));
+  void *retval;
+  ASSERT_EQ(0, pthread_join(tid, &retval));
+  ASSERT_EQ(0, retval);
+}
+
+TEST(SanitizerCommon, PthreadDestructorIterations) {
+  ASSERT_EQ(0, pthread_key_create(&key, &destructor));
+  SpawnThread(GetPthreadDestructorIterations());
+  EXPECT_TRUE(destructor_executed);
+  SpawnThread(GetPthreadDestructorIterations() + 1);
+  EXPECT_FALSE(destructor_executed);
+}
+
+TEST(SanitizerCommon, IsAccessibleMemoryRange) {
+  const int page_size = GetPageSize();
+  uptr mem = (uptr)mmap(0, 3 * page_size, PROT_READ | PROT_WRITE,
+                        MAP_PRIVATE | MAP_ANON, -1, 0);
+  // Protect the middle page.
+  mprotect((void *)(mem + page_size), page_size, PROT_NONE);
+  EXPECT_TRUE(IsAccessibleMemoryRange(mem, page_size - 1));
+  EXPECT_TRUE(IsAccessibleMemoryRange(mem, page_size));
+  EXPECT_FALSE(IsAccessibleMemoryRange(mem, page_size + 1));
+  EXPECT_TRUE(IsAccessibleMemoryRange(mem + page_size - 1, 1));
+  EXPECT_FALSE(IsAccessibleMemoryRange(mem + page_size - 1, 2));
+  EXPECT_FALSE(IsAccessibleMemoryRange(mem + 2 * page_size - 1, 1));
+  EXPECT_TRUE(IsAccessibleMemoryRange(mem + 2 * page_size, page_size));
+  EXPECT_FALSE(IsAccessibleMemoryRange(mem, 3 * page_size));
+  EXPECT_FALSE(IsAccessibleMemoryRange(0x0, 2));
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_POSIX
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_printf_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_printf_test.cc
new file mode 100644
index 0000000..5e39e0a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_printf_test.cc
@@ -0,0 +1,153 @@
+//===-- sanitizer_printf_test.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for sanitizer_printf.cc
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "gtest/gtest.h"
+
+#include <string.h>
+#include <limits.h>
+
+namespace __sanitizer {
+
+TEST(Printf, Basic) {
+  char buf[1024];
+  uptr len = internal_snprintf(buf, sizeof(buf),
+      "a%db%zdc%ue%zuf%xh%zxq%pe%sr",
+      (int)-1, (long)-2, // NOLINT
+      (unsigned)-4, (unsigned long)5, // NOLINT
+      (unsigned)10, (unsigned long)11, // NOLINT
+      (void*)0x123, "_string_");
+  EXPECT_EQ(len, strlen(buf));
+
+  std::string expectedString = "a-1b-2c4294967292e5fahbq0x";
+  expectedString += std::string(SANITIZER_POINTER_FORMAT_LENGTH - 3, '0');
+  expectedString += "123e_string_r";
+  EXPECT_STREQ(expectedString.c_str(), buf);
+}
+
+TEST(Printf, OverflowStr) {
+  char buf[] = "123456789";
+  uptr len = internal_snprintf(buf, 4, "%s", "abcdef");  // NOLINT
+  EXPECT_EQ(len, (uptr)6);
+  EXPECT_STREQ("abc", buf);
+  EXPECT_EQ(buf[3], 0);
+  EXPECT_EQ(buf[4], '5');
+  EXPECT_EQ(buf[5], '6');
+  EXPECT_EQ(buf[6], '7');
+  EXPECT_EQ(buf[7], '8');
+  EXPECT_EQ(buf[8], '9');
+  EXPECT_EQ(buf[9], 0);
+}
+
+TEST(Printf, OverflowInt) {
+  char buf[] = "123456789";
+  internal_snprintf(buf, 4, "%d", -123456789);  // NOLINT
+  EXPECT_STREQ("-12", buf);
+  EXPECT_EQ(buf[3], 0);
+  EXPECT_EQ(buf[4], '5');
+  EXPECT_EQ(buf[5], '6');
+  EXPECT_EQ(buf[6], '7');
+  EXPECT_EQ(buf[7], '8');
+  EXPECT_EQ(buf[8], '9');
+  EXPECT_EQ(buf[9], 0);
+}
+
+TEST(Printf, OverflowUint) {
+  char buf[] = "123456789";
+  uptr val;
+  if (sizeof(val) == 4) {
+    val = (uptr)0x12345678;
+  } else {
+    val = (uptr)0x123456789ULL;
+  }
+  internal_snprintf(buf, 4, "a%zx", val);  // NOLINT
+  EXPECT_STREQ("a12", buf);
+  EXPECT_EQ(buf[3], 0);
+  EXPECT_EQ(buf[4], '5');
+  EXPECT_EQ(buf[5], '6');
+  EXPECT_EQ(buf[6], '7');
+  EXPECT_EQ(buf[7], '8');
+  EXPECT_EQ(buf[8], '9');
+  EXPECT_EQ(buf[9], 0);
+}
+
+TEST(Printf, OverflowPtr) {
+  char buf[] = "123456789";
+  void *p;
+  if (sizeof(p) == 4) {
+    p = (void*)0x1234567;
+  } else {
+    p = (void*)0x123456789ULL;
+  }
+  internal_snprintf(buf, 4, "%p", p);  // NOLINT
+  EXPECT_STREQ("0x0", buf);
+  EXPECT_EQ(buf[3], 0);
+  EXPECT_EQ(buf[4], '5');
+  EXPECT_EQ(buf[5], '6');
+  EXPECT_EQ(buf[6], '7');
+  EXPECT_EQ(buf[7], '8');
+  EXPECT_EQ(buf[8], '9');
+  EXPECT_EQ(buf[9], 0);
+}
+
+#if defined(_WIN32)
+// Oh well, MSVS headers don't define snprintf.
+# define snprintf _snprintf
+#endif
+
+template<typename T>
+static void TestAgainstLibc(const char *fmt, T arg1, T arg2) {
+  char buf[1024];
+  uptr len = internal_snprintf(buf, sizeof(buf), fmt, arg1, arg2);
+  char buf2[1024];
+  snprintf(buf2, sizeof(buf2), fmt, arg1, arg2);
+  EXPECT_EQ(len, strlen(buf));
+  EXPECT_STREQ(buf2, buf);
+}
+
+TEST(Printf, MinMax) {
+  TestAgainstLibc<int>("%d-%d", INT_MIN, INT_MAX);  // NOLINT
+  TestAgainstLibc<unsigned>("%u-%u", 0, UINT_MAX);  // NOLINT
+  TestAgainstLibc<unsigned>("%x-%x", 0, UINT_MAX);  // NOLINT
+#if !defined(_WIN32)
+  // %z* format doesn't seem to be supported by MSVS.
+  TestAgainstLibc<long>("%zd-%zd", LONG_MIN, LONG_MAX);  // NOLINT
+  TestAgainstLibc<unsigned long>("%zu-%zu", 0, ULONG_MAX);  // NOLINT
+  TestAgainstLibc<unsigned long>("%zx-%zx", 0, ULONG_MAX);  // NOLINT
+#endif
+}
+
+TEST(Printf, Padding) {
+  TestAgainstLibc<int>("%3d - %3d", 1, 0);
+  TestAgainstLibc<int>("%3d - %3d", -1, 123);
+  TestAgainstLibc<int>("%3d - %3d", -1, -123);
+  TestAgainstLibc<int>("%3d - %3d", 12, 1234);
+  TestAgainstLibc<int>("%3d - %3d", -12, -1234);
+  TestAgainstLibc<int>("%03d - %03d", 1, 0);
+  TestAgainstLibc<int>("%03d - %03d", -1, 123);
+  TestAgainstLibc<int>("%03d - %03d", -1, -123);
+  TestAgainstLibc<int>("%03d - %03d", 12, 1234);
+  TestAgainstLibc<int>("%03d - %03d", -12, -1234);
+}
+
+TEST(Printf, Precision) {
+  char buf[1024];
+  uptr len = internal_snprintf(buf, sizeof(buf), "%.*s", 3, "12345");
+  EXPECT_EQ(3U, len);
+  EXPECT_STREQ("123", buf);
+  len = internal_snprintf(buf, sizeof(buf), "%.*s", 6, "12345");
+  EXPECT_EQ(5U, len);
+  EXPECT_STREQ("12345", buf);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_procmaps_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_procmaps_test.cc
new file mode 100644
index 0000000..12bc9e1
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_procmaps_test.cc
@@ -0,0 +1,56 @@
+//===-- sanitizer_procmaps_test.cc ----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#if !defined(_WIN32)  // There are no /proc/maps on Windows.
+
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include "gtest/gtest.h"
+
+#include <stdlib.h>
+
+static void noop() {}
+extern const char *argv0;
+
+namespace __sanitizer {
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TEST(MemoryMappingLayout, CodeRange) {
+  uptr start, end;
+  bool res = GetCodeRangeForFile("[vdso]", &start, &end);
+  EXPECT_EQ(res, true);
+  EXPECT_GT(start, 0U);
+  EXPECT_LT(start, end);
+}
+#endif
+
+TEST(MemoryMappingLayout, DumpListOfModules) {
+  const char *last_slash = strrchr(argv0, '/');
+  const char *binary_name = last_slash ? last_slash + 1 : argv0;
+  MemoryMappingLayout memory_mapping(false);
+  const uptr kMaxModules = 100;
+  LoadedModule modules[kMaxModules];
+  uptr n_modules = memory_mapping.DumpListOfModules(modules, kMaxModules, 0);
+  EXPECT_GT(n_modules, 0U);
+  bool found = false;
+  for (uptr i = 0; i < n_modules; ++i) {
+    if (modules[i].containsAddress((uptr)&noop)) {
+      // Verify that the module name is sane.
+      if (strstr(modules[i].full_name(), binary_name) != 0)
+        found = true;
+    }
+    modules[i].clear();
+  }
+  EXPECT_TRUE(found);
+}
+
+}  // namespace __sanitizer
+#endif  // !defined(_WIN32)
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h b/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h
new file mode 100644
index 0000000..47b0f97
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h
@@ -0,0 +1,66 @@
+//===-- sanitizer_pthread_wrappers.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of *Sanitizer runtime.
+// It provides handy wrappers for thread manipulation, that:
+//  a) assert on any failure rather than returning an error code
+//  b) defines pthread-like interface on platforms where where <pthread.h>
+//     is not supplied by default.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_PTHREAD_WRAPPERS_H
+#define SANITIZER_PTHREAD_WRAPPERS_H
+
+#include "sanitizer_test_utils.h"
+
+#if !defined(_WIN32)
+# include <pthread.h>
+// Simply forward the arguments and check that the pthread functions succeed.
+# define PTHREAD_CREATE(a, b, c, d) ASSERT_EQ(0, pthread_create(a, b, c, d))
+# define PTHREAD_JOIN(a, b) ASSERT_EQ(0, pthread_join(a, b))
+#else
+typedef HANDLE pthread_t;
+
+struct PthreadHelperCreateThreadInfo {
+  void *(*start_routine)(void *);
+  void *arg;
+};
+
+inline DWORD WINAPI PthreadHelperThreadProc(void *arg) {
+  PthreadHelperCreateThreadInfo *start_data =
+      reinterpret_cast<PthreadHelperCreateThreadInfo*>(arg);
+  void *ret = (start_data->start_routine)(start_data->arg);
+  delete start_data;
+  return (DWORD)ret;
+}
+
+inline void PTHREAD_CREATE(pthread_t *thread, void *attr,
+                           void *(*start_routine)(void *), void *arg) {
+  ASSERT_EQ(0, attr) << "Thread attributes are not supported yet.";
+  PthreadHelperCreateThreadInfo *data = new PthreadHelperCreateThreadInfo;
+  data->start_routine = start_routine;
+  data->arg = arg;
+  *thread = CreateThread(0, 0, PthreadHelperThreadProc, data, 0, 0);
+  ASSERT_NE(nullptr, *thread) << "Failed to create a thread.";
+}
+
+inline void PTHREAD_JOIN(pthread_t thread, void **value_ptr) {
+  ASSERT_EQ(0, value_ptr) << "Nonzero value_ptr is not supported yet.";
+  ASSERT_EQ(WAIT_OBJECT_0, WaitForSingleObject(thread, INFINITE));
+  ASSERT_NE(0, CloseHandle(thread));
+}
+
+inline void pthread_exit(void *retval) {
+  ASSERT_EQ(0, retval) << "Nonzero retval is not supported yet.";
+  ExitThread((DWORD)retval);
+}
+#endif  // _WIN32
+
+#endif  // SANITIZER_PTHREAD_WRAPPERS_H
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cc
new file mode 100644
index 0000000..513432f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stackdepot_test.cc
@@ -0,0 +1,93 @@
+//===-- sanitizer_stackdepot_test.cc --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+TEST(SanitizerCommon, StackDepotBasic) {
+  uptr array[] = {1, 2, 3, 4, 5};
+  StackTrace s1(array, ARRAY_SIZE(array));
+  u32 i1 = StackDepotPut(s1);
+  StackTrace stack = StackDepotGet(i1);
+  EXPECT_NE(stack.trace, (uptr*)0);
+  EXPECT_EQ(ARRAY_SIZE(array), stack.size);
+  EXPECT_EQ(0, internal_memcmp(stack.trace, array, sizeof(array)));
+}
+
+TEST(SanitizerCommon, StackDepotAbsent) {
+  StackTrace stack = StackDepotGet((1 << 30) - 1);
+  EXPECT_EQ((uptr*)0, stack.trace);
+}
+
+TEST(SanitizerCommon, StackDepotEmptyStack) {
+  u32 i1 = StackDepotPut(StackTrace());
+  StackTrace stack = StackDepotGet(i1);
+  EXPECT_EQ((uptr*)0, stack.trace);
+}
+
+TEST(SanitizerCommon, StackDepotZeroId) {
+  StackTrace stack = StackDepotGet(0);
+  EXPECT_EQ((uptr*)0, stack.trace);
+}
+
+TEST(SanitizerCommon, StackDepotSame) {
+  uptr array[] = {1, 2, 3, 4, 6};
+  StackTrace s1(array, ARRAY_SIZE(array));
+  u32 i1 = StackDepotPut(s1);
+  u32 i2 = StackDepotPut(s1);
+  EXPECT_EQ(i1, i2);
+  StackTrace stack = StackDepotGet(i1);
+  EXPECT_NE(stack.trace, (uptr*)0);
+  EXPECT_EQ(ARRAY_SIZE(array), stack.size);
+  EXPECT_EQ(0, internal_memcmp(stack.trace, array, sizeof(array)));
+}
+
+TEST(SanitizerCommon, StackDepotSeveral) {
+  uptr array1[] = {1, 2, 3, 4, 7};
+  StackTrace s1(array1, ARRAY_SIZE(array1));
+  u32 i1 = StackDepotPut(s1);
+  uptr array2[] = {1, 2, 3, 4, 8, 9};
+  StackTrace s2(array2, ARRAY_SIZE(array2));
+  u32 i2 = StackDepotPut(s2);
+  EXPECT_NE(i1, i2);
+}
+
+TEST(SanitizerCommon, StackDepotReverseMap) {
+  uptr array1[] = {1, 2, 3, 4, 5};
+  uptr array2[] = {7, 1, 3, 0};
+  uptr array3[] = {10, 2, 5, 3};
+  uptr array4[] = {1, 3, 2, 5};
+  u32 ids[4] = {0};
+  StackTrace s1(array1, ARRAY_SIZE(array1));
+  StackTrace s2(array2, ARRAY_SIZE(array2));
+  StackTrace s3(array3, ARRAY_SIZE(array3));
+  StackTrace s4(array4, ARRAY_SIZE(array4));
+  ids[0] = StackDepotPut(s1);
+  ids[1] = StackDepotPut(s2);
+  ids[2] = StackDepotPut(s3);
+  ids[3] = StackDepotPut(s4);
+
+  StackDepotReverseMap map;
+
+  for (uptr i = 0; i < 4; i++) {
+    StackTrace stack = StackDepotGet(ids[i]);
+    StackTrace from_map = map.Get(ids[i]);
+    EXPECT_EQ(stack.size, from_map.size);
+    EXPECT_EQ(stack.trace, from_map.trace);
+  }
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cc
new file mode 100644
index 0000000..05796fc
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cc
@@ -0,0 +1,152 @@
+//===-- sanitizer_common_printer_test.cc ----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of sanitizer_common test suite.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_stacktrace_printer.h"
+
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+TEST(SanitizerStacktracePrinter, RenderSourceLocation) {
+  InternalScopedString str(128);
+  RenderSourceLocation(&str, "/dir/file.cc", 10, 5, false, "");
+  EXPECT_STREQ("/dir/file.cc:10:5", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 11, 0, false, "");
+  EXPECT_STREQ("/dir/file.cc:11", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 0, 0, false, "");
+  EXPECT_STREQ("/dir/file.cc", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 10, 5, false, "/dir/");
+  EXPECT_STREQ("file.cc:10:5", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 10, 5, true, "");
+  EXPECT_STREQ("/dir/file.cc(10,5)", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 11, 0, true, "");
+  EXPECT_STREQ("/dir/file.cc(11)", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 0, 0, true, "");
+  EXPECT_STREQ("/dir/file.cc", str.data());
+
+  str.clear();
+  RenderSourceLocation(&str, "/dir/file.cc", 10, 5, true, "/dir/");
+  EXPECT_STREQ("file.cc(10,5)", str.data());
+}
+
+TEST(SanitizerStacktracePrinter, RenderModuleLocation) {
+  InternalScopedString str(128);
+  RenderModuleLocation(&str, "/dir/exe", 0x123, "");
+  EXPECT_STREQ("(/dir/exe+0x123)", str.data());
+
+  // Check that we strip file prefix if necessary.
+  str.clear();
+  RenderModuleLocation(&str, "/dir/exe", 0x123, "/dir/");
+  EXPECT_STREQ("(exe+0x123)", str.data());
+}
+
+TEST(SanitizerStacktracePrinter, RenderFrame) {
+  int frame_no = 42;
+  AddressInfo info;
+  info.address = 0x400000;
+  info.module = internal_strdup("/path/to/my/module");
+  info.module_offset = 0x200;
+  info.function = internal_strdup("function_foo");
+  info.function_offset = 0x100;
+  info.file = internal_strdup("/path/to/my/source");
+  info.line = 10;
+  info.column = 5;
+  InternalScopedString str(256);
+
+  // Dump all the AddressInfo fields.
+  RenderFrame(&str, "%% Frame:%n PC:%p Module:%m ModuleOffset:%o "
+                    "Function:%f FunctionOffset:%q Source:%s Line:%l "
+                    "Column:%c",
+              frame_no, info, false, "/path/to/", "function_");
+  EXPECT_STREQ("% Frame:42 PC:0x400000 Module:my/module ModuleOffset:0x200 "
+               "Function:foo FunctionOffset:0x100 Source:my/source Line:10 "
+               "Column:5",
+               str.data());
+  info.Clear();
+  str.clear();
+
+  // Test special format specifiers.
+  info.address = 0x400000;
+  RenderFrame(&str, "%M", frame_no, info, false);
+  EXPECT_NE(nullptr, internal_strstr(str.data(), "400000"));
+  str.clear();
+
+  RenderFrame(&str, "%L", frame_no, info, false);
+  EXPECT_STREQ("(<unknown module>)", str.data());
+  str.clear();
+
+  info.module = internal_strdup("/path/to/module");
+  info.module_offset = 0x200;
+  RenderFrame(&str, "%M", frame_no, info, false);
+  EXPECT_NE(nullptr, internal_strstr(str.data(), "(module+0x"));
+  EXPECT_NE(nullptr, internal_strstr(str.data(), "200"));
+  str.clear();
+
+  RenderFrame(&str, "%L", frame_no, info, false);
+  EXPECT_STREQ("(/path/to/module+0x200)", str.data());
+  str.clear();
+
+  info.function = internal_strdup("my_function");
+  RenderFrame(&str, "%F", frame_no, info, false);
+  EXPECT_STREQ("in my_function", str.data());
+  str.clear();
+
+  info.function_offset = 0x100;
+  RenderFrame(&str, "%F %S", frame_no, info, false);
+  EXPECT_STREQ("in my_function+0x100 <null>", str.data());
+  str.clear();
+
+  info.file = internal_strdup("my_file");
+  RenderFrame(&str, "%F %S", frame_no, info, false);
+  EXPECT_STREQ("in my_function my_file", str.data());
+  str.clear();
+
+  info.line = 10;
+  RenderFrame(&str, "%F %S", frame_no, info, false);
+  EXPECT_STREQ("in my_function my_file:10", str.data());
+  str.clear();
+
+  info.column = 5;
+  RenderFrame(&str, "%S %L", frame_no, info, false);
+  EXPECT_STREQ("my_file:10:5 my_file:10:5", str.data());
+  str.clear();
+
+  RenderFrame(&str, "%S %L", frame_no, info, true);
+  EXPECT_STREQ("my_file(10,5) my_file(10,5)", str.data());
+  str.clear();
+
+  info.column = 0;
+  RenderFrame(&str, "%F %S", frame_no, info, true);
+  EXPECT_STREQ("in my_function my_file(10)", str.data());
+  str.clear();
+
+  info.line = 0;
+  RenderFrame(&str, "%F %S", frame_no, info, true);
+  EXPECT_STREQ("in my_function my_file", str.data());
+  str.clear();
+
+  info.Clear();
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cc
new file mode 100644
index 0000000..3d57ede
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cc
@@ -0,0 +1,154 @@
+//===-- sanitizer_stacktrace_test.cc --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+class FastUnwindTest : public ::testing::Test {
+ protected:
+  virtual void SetUp();
+  virtual void TearDown();
+  bool TryFastUnwind(uptr max_depth) {
+    if (!StackTrace::WillUseFastUnwind(true))
+      return false;
+    trace.Unwind(max_depth, start_pc, (uptr)&fake_stack[0], 0, fake_top,
+                 fake_bottom, true);
+    return true;
+  }
+
+  void *mapping;
+  uhwptr *fake_stack;
+  const uptr fake_stack_size = 10;
+  uhwptr start_pc;
+  uhwptr fake_top;
+  uhwptr fake_bottom;
+  BufferedStackTrace trace;
+};
+
+static uptr PC(uptr idx) {
+  return (1<<20) + idx;
+}
+
+void FastUnwindTest::SetUp() {
+  size_t ps = GetPageSize();
+  mapping = MmapOrDie(2 * ps, "FastUnwindTest");
+  MprotectNoAccess((uptr)mapping, ps);
+
+  // Unwinder may peek 1 word down from the starting FP.
+  fake_stack = (uhwptr *)((uptr)mapping + ps + sizeof(uhwptr));
+
+  // Fill an array of pointers with fake fp+retaddr pairs.  Frame pointers have
+  // even indices.
+  for (uptr i = 0; i + 1 < fake_stack_size; i += 2) {
+    fake_stack[i] = (uptr)&fake_stack[i+2];  // fp
+    fake_stack[i+1] = PC(i + 1); // retaddr
+  }
+  // Mark the last fp point back up to terminate the stack trace.
+  fake_stack[RoundDownTo(fake_stack_size - 1, 2)] = (uhwptr)&fake_stack[0];
+
+  // Top is two slots past the end because FastUnwindStack subtracts two.
+  fake_top = (uhwptr)&fake_stack[fake_stack_size + 2];
+  // Bottom is one slot before the start because FastUnwindStack uses >.
+  fake_bottom = (uhwptr)mapping;
+  start_pc = PC(0);
+}
+
+void FastUnwindTest::TearDown() {
+  size_t ps = GetPageSize();
+  UnmapOrDie(mapping, 2 * ps);
+}
+
+TEST_F(FastUnwindTest, Basic) {
+  if (!TryFastUnwind(kStackTraceMax))
+    return;
+  // Should get all on-stack retaddrs and start_pc.
+  EXPECT_EQ(6U, trace.size);
+  EXPECT_EQ(start_pc, trace.trace[0]);
+  for (uptr i = 1; i <= 5; i++) {
+    EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
+  }
+}
+
+// From: https://github.com/google/sanitizers/issues/162
+TEST_F(FastUnwindTest, FramePointerLoop) {
+  // Make one fp point to itself.
+  fake_stack[4] = (uhwptr)&fake_stack[4];
+  if (!TryFastUnwind(kStackTraceMax))
+    return;
+  // Should get all on-stack retaddrs up to the 4th slot and start_pc.
+  EXPECT_EQ(4U, trace.size);
+  EXPECT_EQ(start_pc, trace.trace[0]);
+  for (uptr i = 1; i <= 3; i++) {
+    EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
+  }
+}
+
+TEST_F(FastUnwindTest, MisalignedFramePointer) {
+  // Make one fp misaligned.
+  fake_stack[4] += 3;
+  if (!TryFastUnwind(kStackTraceMax))
+    return;
+  // Should get all on-stack retaddrs up to the 4th slot and start_pc.
+  EXPECT_EQ(4U, trace.size);
+  EXPECT_EQ(start_pc, trace.trace[0]);
+  for (uptr i = 1; i < 4U; i++) {
+    EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
+  }
+}
+
+TEST_F(FastUnwindTest, OneFrameStackTrace) {
+  if (!TryFastUnwind(1))
+    return;
+  EXPECT_EQ(1U, trace.size);
+  EXPECT_EQ(start_pc, trace.trace[0]);
+  EXPECT_EQ((uhwptr)&fake_stack[0], trace.top_frame_bp);
+}
+
+TEST_F(FastUnwindTest, ZeroFramesStackTrace) {
+  if (!TryFastUnwind(0))
+    return;
+  EXPECT_EQ(0U, trace.size);
+  EXPECT_EQ(0U, trace.top_frame_bp);
+}
+
+TEST_F(FastUnwindTest, FPBelowPrevFP) {
+  // The next FP points to unreadable memory inside the stack limits, but below
+  // current FP.
+  fake_stack[0] = (uhwptr)&fake_stack[-50];
+  fake_stack[1] = PC(1);
+  if (!TryFastUnwind(3))
+    return;
+  EXPECT_EQ(2U, trace.size);
+  EXPECT_EQ(PC(0), trace.trace[0]);
+  EXPECT_EQ(PC(1), trace.trace[1]);
+}
+
+TEST(SlowUnwindTest, ShortStackTrace) {
+  if (StackTrace::WillUseFastUnwind(false))
+    return;
+  BufferedStackTrace stack;
+  uptr pc = StackTrace::GetCurrentPc();
+  uptr bp = GET_CURRENT_FRAME();
+  stack.Unwind(0, pc, bp, 0, 0, 0, false);
+  EXPECT_EQ(0U, stack.size);
+  EXPECT_EQ(0U, stack.top_frame_bp);
+  stack.Unwind(1, pc, bp, 0, 0, 0, false);
+  EXPECT_EQ(1U, stack.size);
+  EXPECT_EQ(pc, stack.trace[0]);
+  EXPECT_EQ(bp, stack.top_frame_bp);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cc
new file mode 100644
index 0000000..802af39
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cc
@@ -0,0 +1,204 @@
+//===-- sanitizer_stoptheworld_test.cc ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for sanitizer_stoptheworld.h
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_LINUX && defined(__x86_64__)
+
+#include "sanitizer_common/sanitizer_stoptheworld.h"
+#include "gtest/gtest.h"
+
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+#include <pthread.h>
+#include <sched.h>
+
+namespace __sanitizer {
+
+static pthread_mutex_t incrementer_thread_exit_mutex;
+
+struct CallbackArgument {
+  volatile int counter;
+  volatile bool threads_stopped;
+  volatile bool callback_executed;
+  CallbackArgument()
+    : counter(0),
+      threads_stopped(false),
+      callback_executed(false) {}
+};
+
+void *IncrementerThread(void *argument) {
+  CallbackArgument *callback_argument = (CallbackArgument *)argument;
+  while (true) {
+    __sync_fetch_and_add(&callback_argument->counter, 1);
+    if (pthread_mutex_trylock(&incrementer_thread_exit_mutex) == 0) {
+      pthread_mutex_unlock(&incrementer_thread_exit_mutex);
+      return NULL;
+    } else {
+      sched_yield();
+    }
+  }
+}
+
+// This callback checks that IncrementerThread is suspended at the time of its
+// execution.
+void Callback(const SuspendedThreadsList &suspended_threads_list,
+              void *argument) {
+  CallbackArgument *callback_argument = (CallbackArgument *)argument;
+  callback_argument->callback_executed = true;
+  int counter_at_init = __sync_fetch_and_add(&callback_argument->counter, 0);
+  for (uptr i = 0; i < 1000; i++) {
+    sched_yield();
+    if (__sync_fetch_and_add(&callback_argument->counter, 0) !=
+          counter_at_init) {
+      callback_argument->threads_stopped = false;
+      return;
+    }
+  }
+  callback_argument->threads_stopped = true;
+}
+
+TEST(StopTheWorld, SuspendThreadsSimple) {
+  pthread_mutex_init(&incrementer_thread_exit_mutex, NULL);
+  CallbackArgument argument;
+  pthread_t thread_id;
+  int pthread_create_result;
+  pthread_mutex_lock(&incrementer_thread_exit_mutex);
+  pthread_create_result = pthread_create(&thread_id, NULL, IncrementerThread,
+                                         &argument);
+  ASSERT_EQ(0, pthread_create_result);
+  StopTheWorld(&Callback, &argument);
+  pthread_mutex_unlock(&incrementer_thread_exit_mutex);
+  EXPECT_TRUE(argument.callback_executed);
+  EXPECT_TRUE(argument.threads_stopped);
+  // argument is on stack, so we have to wait for the incrementer thread to
+  // terminate before we can return from this function.
+  ASSERT_EQ(0, pthread_join(thread_id, NULL));
+  pthread_mutex_destroy(&incrementer_thread_exit_mutex);
+}
+
+// A more comprehensive test where we spawn a bunch of threads while executing
+// StopTheWorld in parallel.
+static const uptr kThreadCount = 50;
+static const uptr kStopWorldAfter = 10; // let this many threads spawn first
+
+static pthread_mutex_t advanced_incrementer_thread_exit_mutex;
+
+struct AdvancedCallbackArgument {
+  volatile uptr thread_index;
+  volatile int counters[kThreadCount];
+  pthread_t thread_ids[kThreadCount];
+  volatile bool threads_stopped;
+  volatile bool callback_executed;
+  volatile bool fatal_error;
+  AdvancedCallbackArgument()
+    : thread_index(0),
+      threads_stopped(false),
+      callback_executed(false),
+      fatal_error(false) {}
+};
+
+void *AdvancedIncrementerThread(void *argument) {
+  AdvancedCallbackArgument *callback_argument =
+      (AdvancedCallbackArgument *)argument;
+  uptr this_thread_index = __sync_fetch_and_add(
+      &callback_argument->thread_index, 1);
+  // Spawn the next thread.
+  int pthread_create_result;
+  if (this_thread_index + 1 < kThreadCount) {
+    pthread_create_result =
+        pthread_create(&callback_argument->thread_ids[this_thread_index + 1],
+                       NULL, AdvancedIncrementerThread, argument);
+    // Cannot use ASSERT_EQ in non-void-returning functions. If there's a
+    // problem, defer failing to the main thread.
+    if (pthread_create_result != 0) {
+      callback_argument->fatal_error = true;
+      __sync_fetch_and_add(&callback_argument->thread_index,
+                           kThreadCount - callback_argument->thread_index);
+    }
+  }
+  // Do the actual work.
+  while (true) {
+    __sync_fetch_and_add(&callback_argument->counters[this_thread_index], 1);
+    if (pthread_mutex_trylock(&advanced_incrementer_thread_exit_mutex) == 0) {
+      pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex);
+      return NULL;
+    } else {
+      sched_yield();
+    }
+  }
+}
+
+void AdvancedCallback(const SuspendedThreadsList &suspended_threads_list,
+                             void *argument) {
+  AdvancedCallbackArgument *callback_argument =
+      (AdvancedCallbackArgument *)argument;
+  callback_argument->callback_executed = true;
+
+  int counters_at_init[kThreadCount];
+  for (uptr j = 0; j < kThreadCount; j++)
+    counters_at_init[j] = __sync_fetch_and_add(&callback_argument->counters[j],
+                                               0);
+  for (uptr i = 0; i < 10; i++) {
+    sched_yield();
+    for (uptr j = 0; j < kThreadCount; j++)
+      if (__sync_fetch_and_add(&callback_argument->counters[j], 0) !=
+            counters_at_init[j]) {
+        callback_argument->threads_stopped = false;
+        return;
+      }
+  }
+  callback_argument->threads_stopped = true;
+}
+
+TEST(StopTheWorld, SuspendThreadsAdvanced) {
+  pthread_mutex_init(&advanced_incrementer_thread_exit_mutex, NULL);
+  AdvancedCallbackArgument argument;
+
+  pthread_mutex_lock(&advanced_incrementer_thread_exit_mutex);
+  int pthread_create_result;
+  pthread_create_result = pthread_create(&argument.thread_ids[0], NULL,
+                                         AdvancedIncrementerThread,
+                                         &argument);
+  ASSERT_EQ(0, pthread_create_result);
+  // Wait for several threads to spawn before proceeding.
+  while (__sync_fetch_and_add(&argument.thread_index, 0) < kStopWorldAfter)
+    sched_yield();
+  StopTheWorld(&AdvancedCallback, &argument);
+  EXPECT_TRUE(argument.callback_executed);
+  EXPECT_TRUE(argument.threads_stopped);
+
+  // Wait for all threads to spawn before we start terminating them.
+  while (__sync_fetch_and_add(&argument.thread_index, 0) < kThreadCount)
+    sched_yield();
+  ASSERT_FALSE(argument.fatal_error); // a pthread_create has failed
+  // Signal the threads to terminate.
+  pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex);
+  for (uptr i = 0; i < kThreadCount; i++)
+    ASSERT_EQ(0, pthread_join(argument.thread_ids[i], NULL));
+  pthread_mutex_destroy(&advanced_incrementer_thread_exit_mutex);
+}
+
+static void SegvCallback(const SuspendedThreadsList &suspended_threads_list,
+                         void *argument) {
+  *(volatile int*)0x1234 = 0;
+}
+
+TEST(StopTheWorld, SegvInCallback) {
+  // Test that tracer thread catches SIGSEGV.
+  StopTheWorld(&SegvCallback, NULL);
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_LINUX && defined(__x86_64__)
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_testlib.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_testlib.cc
new file mode 100644
index 0000000..d8be2af
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_testlib.cc
@@ -0,0 +1,53 @@
+//===-- sanitizer_stoptheworld_testlib.cc ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Dynamic library to test StopTheWorld functionality.
+// When loaded with LD_PRELOAD, it will periodically suspend all threads.
+//===----------------------------------------------------------------------===//
+/* Usage:
+clang++ -fno-exceptions -g -fPIC -I. \
+ sanitizer_common/tests/sanitizer_stoptheworld_testlib.cc \
+ sanitizer_common/sanitizer_*.cc -shared -lpthread -o teststoptheworld.so
+LD_PRELOAD=`pwd`/teststoptheworld.so /your/app
+*/
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_LINUX
+
+#include <dlfcn.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#include "sanitizer_common/sanitizer_stoptheworld.h"
+
+namespace {
+const uptr kSuspendDuration = 3;
+const uptr kRunDuration = 3;
+
+void Callback(const SuspendedThreadsList &suspended_threads_list,
+              void *argument) {
+  sleep(kSuspendDuration);
+}
+
+void *SuspenderThread(void *argument) {
+  while (true) {
+    sleep(kRunDuration);
+    StopTheWorld(Callback, NULL);
+  }
+  return NULL;
+}
+
+__attribute__((constructor)) void StopTheWorldTestLibConstructor(void) {
+  pthread_t thread_id;
+  pthread_create(&thread_id, NULL, SuspenderThread, NULL);
+}
+}  // namespace
+
+#endif  // SANITIZER_LINUX
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_suppressions_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_suppressions_test.cc
new file mode 100644
index 0000000..224ab05
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_suppressions_test.cc
@@ -0,0 +1,135 @@
+//===-- sanitizer_suppressions_test.cc ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "gtest/gtest.h"
+
+#include <string.h>
+
+namespace __sanitizer {
+
+static bool MyMatch(const char *templ, const char *func) {
+  char tmp[1024];
+  strcpy(tmp, templ);  // NOLINT
+  return TemplateMatch(tmp, func);
+}
+
+TEST(Suppressions, Match) {
+  EXPECT_TRUE(MyMatch("foobar$", "foobar"));
+
+  EXPECT_TRUE(MyMatch("foobar", "foobar"));
+  EXPECT_TRUE(MyMatch("*foobar*", "foobar"));
+  EXPECT_TRUE(MyMatch("foobar", "prefix_foobar_postfix"));
+  EXPECT_TRUE(MyMatch("*foobar*", "prefix_foobar_postfix"));
+  EXPECT_TRUE(MyMatch("foo*bar", "foo_middle_bar"));
+  EXPECT_TRUE(MyMatch("foo*bar", "foobar"));
+  EXPECT_TRUE(MyMatch("foo*bar*baz", "foo_middle_bar_another_baz"));
+  EXPECT_TRUE(MyMatch("foo*bar*baz", "foo_middle_barbaz"));
+  EXPECT_TRUE(MyMatch("^foobar", "foobar"));
+  EXPECT_TRUE(MyMatch("^foobar", "foobar_postfix"));
+  EXPECT_TRUE(MyMatch("^*foobar", "foobar"));
+  EXPECT_TRUE(MyMatch("^*foobar", "prefix_foobar"));
+  EXPECT_TRUE(MyMatch("foobar$", "foobar"));
+  EXPECT_TRUE(MyMatch("foobar$", "prefix_foobar"));
+  EXPECT_TRUE(MyMatch("*foobar*$", "foobar"));
+  EXPECT_TRUE(MyMatch("*foobar*$", "foobar_postfix"));
+  EXPECT_TRUE(MyMatch("^foobar$", "foobar"));
+
+  EXPECT_FALSE(MyMatch("foo", "baz"));
+  EXPECT_FALSE(MyMatch("foobarbaz", "foobar"));
+  EXPECT_FALSE(MyMatch("foobarbaz", "barbaz"));
+  EXPECT_FALSE(MyMatch("foo*bar", "foobaz"));
+  EXPECT_FALSE(MyMatch("foo*bar", "foo_baz"));
+  EXPECT_FALSE(MyMatch("^foobar", "prefix_foobar"));
+  EXPECT_FALSE(MyMatch("foobar$", "foobar_postfix"));
+  EXPECT_FALSE(MyMatch("^foobar$", "prefix_foobar"));
+  EXPECT_FALSE(MyMatch("^foobar$", "foobar_postfix"));
+  EXPECT_FALSE(MyMatch("foo^bar", "foobar"));
+  EXPECT_FALSE(MyMatch("foo$bar", "foobar"));
+  EXPECT_FALSE(MyMatch("foo$^bar", "foobar"));
+}
+
+static const char *kTestSuppressionTypes[] = {"race", "thread", "mutex",
+                                              "signal"};
+
+class SuppressionContextTest : public ::testing::Test {
+ public:
+  SuppressionContextTest()
+      : ctx_(kTestSuppressionTypes, ARRAY_SIZE(kTestSuppressionTypes)) {}
+
+ protected:
+  SuppressionContext ctx_;
+
+  void CheckSuppressions(unsigned count, std::vector<const char *> types,
+                         std::vector<const char *> templs) const {
+    EXPECT_EQ(count, ctx_.SuppressionCount());
+    for (unsigned i = 0; i < count; i++) {
+      const Suppression *s = ctx_.SuppressionAt(i);
+      EXPECT_STREQ(types[i], s->type);
+      EXPECT_STREQ(templs[i], s->templ);
+    }
+  }
+};
+
+TEST_F(SuppressionContextTest, Parse) {
+  ctx_.Parse("race:foo\n"
+             " 	race:bar\n"  // NOLINT
+             "race:baz	 \n" // NOLINT
+             "# a comment\n"
+             "race:quz\n"); // NOLINT
+  CheckSuppressions(4, {"race", "race", "race", "race"},
+                    {"foo", "bar", "baz", "quz"});
+}
+
+TEST_F(SuppressionContextTest, Parse2) {
+  ctx_.Parse(
+    "  	# first line comment\n"  // NOLINT
+    " 	race:bar 	\n"  // NOLINT
+    "race:baz* *baz\n"
+    "# a comment\n"
+    "# last line comment\n"
+  );  // NOLINT
+  CheckSuppressions(2, {"race", "race"}, {"bar", "baz* *baz"});
+}
+
+TEST_F(SuppressionContextTest, Parse3) {
+  ctx_.Parse(
+    "# last suppression w/o line-feed\n"
+    "race:foo\n"
+    "race:bar\r\n"
+    "race:baz"
+  );  // NOLINT
+  CheckSuppressions(3, {"race", "race", "race"}, {"foo", "bar", "baz"});
+}
+
+TEST_F(SuppressionContextTest, ParseType) {
+  ctx_.Parse(
+    "race:foo\n"
+    "thread:bar\n"
+    "mutex:baz\n"
+    "signal:quz\n"
+  );  // NOLINT
+  CheckSuppressions(4, {"race", "thread", "mutex", "signal"},
+                    {"foo", "bar", "baz", "quz"});
+}
+
+TEST_F(SuppressionContextTest, HasSuppressionType) {
+  ctx_.Parse(
+    "race:foo\n"
+    "thread:bar\n");
+  EXPECT_TRUE(ctx_.HasSuppressionType("race"));
+  EXPECT_TRUE(ctx_.HasSuppressionType("thread"));
+  EXPECT_FALSE(ctx_.HasSuppressionType("mutex"));
+  EXPECT_FALSE(ctx_.HasSuppressionType("signal"));
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_symbolizer_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_symbolizer_test.cc
new file mode 100644
index 0000000..429ac59
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_symbolizer_test.cc
@@ -0,0 +1,58 @@
+//===-- sanitizer_symbolizer_test.cc --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for sanitizer_symbolizer.h and sanitizer_symbolizer_internal.h
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_symbolizer_internal.h"
+#include "gtest/gtest.h"
+
+namespace __sanitizer {
+
+TEST(Symbolizer, ExtractToken) {
+  char *token;
+  const char *rest;
+
+  rest = ExtractToken("a;b;c", ";", &token);
+  EXPECT_STREQ("a", token);
+  EXPECT_STREQ("b;c", rest);
+  InternalFree(token);
+
+  rest = ExtractToken("aaa-bbb.ccc", ";.-*", &token);
+  EXPECT_STREQ("aaa", token);
+  EXPECT_STREQ("bbb.ccc", rest);
+  InternalFree(token);
+}
+
+TEST(Symbolizer, ExtractInt) {
+  int token;
+  const char *rest = ExtractInt("123,456;789", ";,", &token);
+  EXPECT_EQ(123, token);
+  EXPECT_STREQ("456;789", rest);
+}
+
+TEST(Symbolizer, ExtractUptr) {
+  uptr token;
+  const char *rest = ExtractUptr("123,456;789", ";,", &token);
+  EXPECT_EQ(123U, token);
+  EXPECT_STREQ("456;789", rest);
+}
+
+TEST(Symbolizer, ExtractTokenUpToDelimiter) {
+  char *token;
+  const char *rest =
+      ExtractTokenUpToDelimiter("aaa-+-bbb-+-ccc", "-+-", &token);
+  EXPECT_STREQ("aaa", token);
+  EXPECT_STREQ("bbb-+-ccc", rest);
+  InternalFree(token);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_config.h b/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_config.h
new file mode 100644
index 0000000..bdf6146
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_config.h
@@ -0,0 +1,30 @@
+//===-- sanitizer_test_config.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of *Sanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#if !defined(INCLUDED_FROM_SANITIZER_TEST_UTILS_H)
+# error "This file should be included into sanitizer_test_utils.h only"
+#endif
+
+#ifndef SANITIZER_TEST_CONFIG_H
+#define SANITIZER_TEST_CONFIG_H
+
+#include <vector>
+#include <string>
+#include <map>
+
+#if SANITIZER_USE_DEJAGNU_GTEST
+# include "dejagnu-gtest.h"
+#else
+# include "gtest/gtest.h"
+#endif
+
+#endif  // SANITIZER_TEST_CONFIG_H
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_main.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_main.cc
new file mode 100644
index 0000000..20f8f53
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_main.cc
@@ -0,0 +1,24 @@
+//===-- sanitizer_test_main.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "gtest/gtest.h"
+#include "sanitizer_common/sanitizer_flags.h"
+
+const char *argv0;
+
+int main(int argc, char **argv) {
+  argv0 = argv[0];
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  SetCommonFlagsDefaults();
+  return RUN_ALL_TESTS();
+}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_utils.h b/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_utils.h
new file mode 100644
index 0000000..9c162a6
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_test_utils.h
@@ -0,0 +1,127 @@
+//===-- sanitizer_test_utils.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of *Sanitizer runtime.
+// Common unit tests utilities.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_TEST_UTILS_H
+#define SANITIZER_TEST_UTILS_H
+
+#if defined(_WIN32)
+// <windows.h> should always be the first include on Windows.
+# include <windows.h>
+// MSVS headers define max/min as macros, so std::max/min gets crazy.
+# undef max
+# undef min
+#endif
+
+#if !defined(SANITIZER_EXTERNAL_TEST_CONFIG)
+# define INCLUDED_FROM_SANITIZER_TEST_UTILS_H
+# include "sanitizer_test_config.h"
+# undef INCLUDED_FROM_SANITIZER_TEST_UTILS_H
+#endif
+
+#include <stdint.h>
+
+#if defined(_MSC_VER)
+# define NOINLINE __declspec(noinline)
+#else  // defined(_MSC_VER)
+# define NOINLINE __attribute__((noinline))
+#endif  // defined(_MSC_VER)
+
+#if !defined(_MSC_VER) || defined(__clang__)
+# define UNUSED __attribute__((unused))
+# define USED __attribute__((used))
+#else
+# define UNUSED
+# define USED
+#endif
+
+#if !defined(__has_feature)
+#define __has_feature(x) 0
+#endif
+
+#ifndef ATTRIBUTE_NO_SANITIZE_ADDRESS
+# if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+#  define ATTRIBUTE_NO_SANITIZE_ADDRESS \
+    __attribute__((no_sanitize_address))
+# else
+#  define ATTRIBUTE_NO_SANITIZE_ADDRESS
+# endif
+#endif  // ATTRIBUTE_NO_SANITIZE_ADDRESS
+
+#if __LP64__ || defined(_WIN64)
+#  define SANITIZER_WORDSIZE 64
+#else
+#  define SANITIZER_WORDSIZE 32
+#endif
+
+// Make the compiler thinks that something is going on there.
+inline void break_optimization(void *arg) {
+#if !defined(_WIN32) || defined(__clang__)
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+#endif
+}
+
+// This function returns its parameter but in such a way that compiler
+// can not prove it.
+template<class T>
+NOINLINE
+static T Ident(T t) {
+  T ret = t;
+  break_optimization(&ret);
+  return ret;
+}
+
+// Simple stand-alone pseudorandom number generator.
+// Current algorithm is ANSI C linear congruential PRNG.
+static inline uint32_t my_rand_r(uint32_t* state) {
+  return (*state = *state * 1103515245 + 12345) >> 16;
+}
+
+static uint32_t global_seed = 0;
+
+static inline uint32_t my_rand() {
+  return my_rand_r(&global_seed);
+}
+
+// Set availability of platform-specific functions.
+
+#if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(_WIN32)
+# define SANITIZER_TEST_HAS_POSIX_MEMALIGN 1
+#else
+# define SANITIZER_TEST_HAS_POSIX_MEMALIGN 0
+#endif
+
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && \
+    !defined(__ANDROID__) && !defined(_WIN32)
+# define SANITIZER_TEST_HAS_MEMALIGN 1
+# define SANITIZER_TEST_HAS_PVALLOC 1
+# define SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE 1
+#else
+# define SANITIZER_TEST_HAS_MEMALIGN 0
+# define SANITIZER_TEST_HAS_PVALLOC 0
+# define SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE 0
+#endif
+
+#if !defined(__APPLE__)
+# define SANITIZER_TEST_HAS_STRNLEN 1
+#else
+# define SANITIZER_TEST_HAS_STRNLEN 0
+#endif
+
+#if defined(__FreeBSD__)
+# define SANITIZER_TEST_HAS_PRINTF_L 1
+#else
+# define SANITIZER_TEST_HAS_PRINTF_L 0
+#endif
+
+#endif  // SANITIZER_TEST_UTILS_H
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_thread_registry_test.cc b/compiler-rt/lib/sanitizer_common/tests/sanitizer_thread_registry_test.cc
new file mode 100644
index 0000000..58c627a
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_thread_registry_test.cc
@@ -0,0 +1,232 @@
+//===-- sanitizer_thread_registry_test.cc ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of shared sanitizer runtime.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_thread_registry.h"
+
+#include "sanitizer_pthread_wrappers.h"
+
+#include "gtest/gtest.h"
+
+#include <vector>
+
+namespace __sanitizer {
+
+static BlockingMutex tctx_allocator_lock(LINKER_INITIALIZED);
+static LowLevelAllocator tctx_allocator;
+
+template<typename TCTX>
+static ThreadContextBase *GetThreadContext(u32 tid) {
+  BlockingMutexLock l(&tctx_allocator_lock);
+  return new(tctx_allocator) TCTX(tid);
+}
+
+static const u32 kMaxRegistryThreads = 1000;
+static const u32 kRegistryQuarantine = 2;
+
+static void CheckThreadQuantity(ThreadRegistry *registry, uptr exp_total,
+                                uptr exp_running, uptr exp_alive) {
+  uptr total, running, alive;
+  registry->GetNumberOfThreads(&total, &running, &alive);
+  EXPECT_EQ(exp_total, total);
+  EXPECT_EQ(exp_running, running);
+  EXPECT_EQ(exp_alive, alive);
+}
+
+static bool is_detached(u32 tid) {
+  return (tid % 2 == 0);
+}
+
+static uptr get_uid(u32 tid) {
+  return tid * 2;
+}
+
+static bool HasName(ThreadContextBase *tctx, void *arg) {
+  char *name = (char*)arg;
+  return (0 == internal_strcmp(tctx->name, name));
+}
+
+static bool HasUid(ThreadContextBase *tctx, void *arg) {
+  uptr uid = (uptr)arg;
+  return (tctx->user_id == uid);
+}
+
+static void MarkUidAsPresent(ThreadContextBase *tctx, void *arg) {
+  bool *arr = (bool*)arg;
+  arr[tctx->tid] = true;
+}
+
+static void TestRegistry(ThreadRegistry *registry, bool has_quarantine) {
+  // Create and start a main thread.
+  EXPECT_EQ(0U, registry->CreateThread(get_uid(0), true, -1, 0));
+  registry->StartThread(0, 0, 0);
+  // Create a bunch of threads.
+  for (u32 i = 1; i <= 10; i++) {
+    EXPECT_EQ(i, registry->CreateThread(get_uid(i), is_detached(i), 0, 0));
+  }
+  CheckThreadQuantity(registry, 11, 1, 11);
+  // Start some of them.
+  for (u32 i = 1; i <= 5; i++) {
+    registry->StartThread(i, 0, 0);
+  }
+  CheckThreadQuantity(registry, 11, 6, 11);
+  // Finish, create and start more threads.
+  for (u32 i = 1; i <= 5; i++) {
+    registry->FinishThread(i);
+    if (!is_detached(i))
+      registry->JoinThread(i, 0);
+  }
+  for (u32 i = 6; i <= 10; i++) {
+    registry->StartThread(i, 0, 0);
+  }
+  std::vector<u32> new_tids;
+  for (u32 i = 11; i <= 15; i++) {
+    new_tids.push_back(
+        registry->CreateThread(get_uid(i), is_detached(i), 0, 0));
+  }
+  ASSERT_LE(kRegistryQuarantine, 5U);
+  u32 exp_total = 16 - (has_quarantine ? 5 - kRegistryQuarantine  : 0);
+  CheckThreadQuantity(registry, exp_total, 6, 11);
+  // Test SetThreadName and FindThread.
+  registry->SetThreadName(6, "six");
+  registry->SetThreadName(7, "seven");
+  EXPECT_EQ(7U, registry->FindThread(HasName, (void*)"seven"));
+  EXPECT_EQ(ThreadRegistry::kUnknownTid,
+            registry->FindThread(HasName, (void*)"none"));
+  EXPECT_EQ(0U, registry->FindThread(HasUid, (void*)get_uid(0)));
+  EXPECT_EQ(10U, registry->FindThread(HasUid, (void*)get_uid(10)));
+  EXPECT_EQ(ThreadRegistry::kUnknownTid,
+            registry->FindThread(HasUid, (void*)0x1234));
+  // Detach and finish and join remaining threads.
+  for (u32 i = 6; i <= 10; i++) {
+    registry->DetachThread(i, 0);
+    registry->FinishThread(i);
+  }
+  for (u32 i = 0; i < new_tids.size(); i++) {
+    u32 tid = new_tids[i];
+    registry->StartThread(tid, 0, 0);
+    registry->DetachThread(tid, 0);
+    registry->FinishThread(tid);
+  }
+  CheckThreadQuantity(registry, exp_total, 1, 1);
+  // Test methods that require the caller to hold a ThreadRegistryLock.
+  bool has_tid[16];
+  internal_memset(&has_tid[0], 0, sizeof(has_tid));
+  {
+    ThreadRegistryLock l(registry);
+    registry->RunCallbackForEachThreadLocked(MarkUidAsPresent, &has_tid[0]);
+  }
+  for (u32 i = 0; i < exp_total; i++) {
+    EXPECT_TRUE(has_tid[i]);
+  }
+  {
+    ThreadRegistryLock l(registry);
+    registry->CheckLocked();
+    ThreadContextBase *main_thread = registry->GetThreadLocked(0);
+    EXPECT_EQ(main_thread, registry->FindThreadContextLocked(
+        HasUid, (void*)get_uid(0)));
+  }
+  EXPECT_EQ(11U, registry->GetMaxAliveThreads());
+}
+
+TEST(SanitizerCommon, ThreadRegistryTest) {
+  ThreadRegistry quarantine_registry(GetThreadContext<ThreadContextBase>,
+                                     kMaxRegistryThreads,
+                                     kRegistryQuarantine);
+  TestRegistry(&quarantine_registry, true);
+
+  ThreadRegistry no_quarantine_registry(GetThreadContext<ThreadContextBase>,
+                                        kMaxRegistryThreads,
+                                        kMaxRegistryThreads);
+  TestRegistry(&no_quarantine_registry, false);
+}
+
+static const int kThreadsPerShard = 20;
+static const int kNumShards = 25;
+
+static int num_created[kNumShards + 1];
+static int num_started[kNumShards + 1];
+static int num_joined[kNumShards + 1];
+
+namespace {
+
+struct RunThreadArgs {
+  ThreadRegistry *registry;
+  uptr shard;  // started from 1.
+};
+
+class TestThreadContext : public ThreadContextBase {
+ public:
+  explicit TestThreadContext(int tid) : ThreadContextBase(tid) {}
+  void OnJoined(void *arg) {
+    uptr shard = (uptr)arg;
+    num_joined[shard]++;
+  }
+  void OnStarted(void *arg) {
+    uptr shard = (uptr)arg;
+    num_started[shard]++;
+  }
+  void OnCreated(void *arg) {
+    uptr shard = (uptr)arg;
+    num_created[shard]++;
+  }
+};
+
+}  // namespace
+
+void *RunThread(void *arg) {
+  RunThreadArgs *args = static_cast<RunThreadArgs*>(arg);
+  std::vector<int> tids;
+  for (int i = 0; i < kThreadsPerShard; i++)
+    tids.push_back(
+        args->registry->CreateThread(0, false, 0, (void*)args->shard));
+  for (int i = 0; i < kThreadsPerShard; i++)
+    args->registry->StartThread(tids[i], 0, (void*)args->shard);
+  for (int i = 0; i < kThreadsPerShard; i++)
+    args->registry->FinishThread(tids[i]);
+  for (int i = 0; i < kThreadsPerShard; i++)
+    args->registry->JoinThread(tids[i], (void*)args->shard);
+  return 0;
+}
+
+static void ThreadedTestRegistry(ThreadRegistry *registry) {
+  // Create and start a main thread.
+  EXPECT_EQ(0U, registry->CreateThread(0, true, -1, 0));
+  registry->StartThread(0, 0, 0);
+  pthread_t threads[kNumShards];
+  RunThreadArgs args[kNumShards];
+  for (int i = 0; i < kNumShards; i++) {
+    args[i].registry = registry;
+    args[i].shard = i + 1;
+    PTHREAD_CREATE(&threads[i], 0, RunThread, &args[i]);
+  }
+  for (int i = 0; i < kNumShards; i++) {
+    PTHREAD_JOIN(threads[i], 0);
+  }
+  // Check that each thread created/started/joined correct amount
+  // of "threads" in thread_registry.
+  EXPECT_EQ(1, num_created[0]);
+  EXPECT_EQ(1, num_started[0]);
+  EXPECT_EQ(0, num_joined[0]);
+  for (int i = 1; i <= kNumShards; i++) {
+    EXPECT_EQ(kThreadsPerShard, num_created[i]);
+    EXPECT_EQ(kThreadsPerShard, num_started[i]);
+    EXPECT_EQ(kThreadsPerShard, num_joined[i]);
+  }
+}
+
+TEST(SanitizerCommon, ThreadRegistryThreadedTest) {
+  ThreadRegistry registry(GetThreadContext<TestThreadContext>,
+                          kThreadsPerShard * kNumShards + 1, 10);
+  ThreadedTestRegistry(&registry);
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/tests/standalone_malloc_test.cc b/compiler-rt/lib/sanitizer_common/tests/standalone_malloc_test.cc
new file mode 100644
index 0000000..9e6f7c9
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/tests/standalone_malloc_test.cc
@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <vector>
+#include <pthread.h>
+#include <malloc.h>
+#include <algorithm>
+
+using namespace std;
+
+const size_t kNumThreds = 16;
+const size_t kNumIters = 1 << 23;
+
+inline void break_optimization(void *arg) {
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+}
+
+__attribute__((noinline))
+static void *MallocThread(void *t) {
+  size_t total_malloced = 0, total_freed = 0;
+  size_t max_in_use = 0;
+  size_t tid = reinterpret_cast<size_t>(t);
+  vector<pair<char *, size_t> > allocated;
+  allocated.reserve(kNumIters);
+  for (size_t i = 1; i < kNumIters; i++) {
+    if ((i % (kNumIters / 4)) == 0 && tid == 0)
+      fprintf(stderr, "   T[%ld] iter %ld\n", tid, i);
+    bool allocate = (i % 5) <= 2;  // 60% malloc, 40% free
+    if (i > kNumIters / 4)
+      allocate = i % 2;  // then switch to 50% malloc, 50% free
+    if (allocate) {
+      size_t size = 1 + (i % 200);
+      if ((i % 10001) == 0)
+        size *= 4096;
+      total_malloced += size;
+      char *x = new char[size];
+      x[0] = x[size - 1] = x[size / 2] = 0;
+      allocated.push_back(make_pair(x, size));
+      max_in_use = max(max_in_use, total_malloced - total_freed);
+    } else {
+      if (allocated.empty()) continue;
+      size_t slot = i % allocated.size();
+      char *p = allocated[slot].first;
+      p[0] = 0;  // emulate last user touch of the block
+      size_t size = allocated[slot].second;
+      total_freed += size;
+      swap(allocated[slot], allocated.back());
+      allocated.pop_back();
+      delete [] p;
+    }
+  }
+  if (tid == 0)
+    fprintf(stderr, "   T[%ld] total_malloced: %ldM in use %ldM max %ldM\n",
+           tid, total_malloced >> 20, (total_malloced - total_freed) >> 20,
+           max_in_use >> 20);
+  for (size_t i = 0; i < allocated.size(); i++)
+    delete [] allocated[i].first;
+  return 0;
+}
+
+template <int depth>
+struct DeepStack {
+  __attribute__((noinline))
+  static void *run(void *t) {
+    break_optimization(0);
+    DeepStack<depth - 1>::run(t);
+    break_optimization(0);
+    return 0;
+  }
+};
+
+template<>
+struct DeepStack<0> {
+  static void *run(void *t) {
+    MallocThread(t);
+    return 0;
+  }
+};
+
+// Build with -Dstandalone_malloc_test=main to make it a separate program.
+int standalone_malloc_test() {
+  pthread_t t[kNumThreds];
+  for (size_t i = 0; i < kNumThreds; i++)
+    pthread_create(&t[i], 0, DeepStack<200>::run, reinterpret_cast<void *>(i));
+  for (size_t i = 0; i < kNumThreds; i++)
+    pthread_join(t[i], 0);
+  malloc_stats();
+  return 0;
+}
diff --git a/compiler-rt/lib/tsan/.clang-format b/compiler-rt/lib/tsan/.clang-format
new file mode 100644
index 0000000..f6cb8ad
--- /dev/null
+++ b/compiler-rt/lib/tsan/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Google
diff --git a/compiler-rt/lib/tsan/Android.bp b/compiler-rt/lib/tsan/Android.bp
new file mode 100644
index 0000000..2d93818
--- /dev/null
+++ b/compiler-rt/lib/tsan/Android.bp
@@ -0,0 +1,168 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+tsan_rtl_cppflags = [
+    "-std=c++11",
+    "-Wall",
+    "-Werror",
+    "-Wno-unused-parameter",
+    "-Wno-non-virtual-dtor",
+    "-fno-rtti",
+    "-fno-builtin",
+]
+
+cc_library_host_static {
+    name: "libtsan",
+
+    include_dirs: ["external/compiler-rt/lib"],
+    cppflags: tsan_rtl_cppflags,
+    srcs: [
+        "rtl/tsan_clock.cc",
+        "rtl/tsan_flags.cc",
+        "rtl/tsan_fd.cc",
+        "rtl/tsan_ignoreset.cc",
+        "rtl/tsan_interceptors.cc",
+        "rtl/tsan_interface_ann.cc",
+        "rtl/tsan_interface_atomic.cc",
+        "rtl/tsan_interface.cc",
+        "rtl/tsan_interface_java.cc",
+        "rtl/tsan_md5.cc",
+        "rtl/tsan_mman.cc",
+        "rtl/tsan_mutex.cc",
+        "rtl/tsan_mutexset.cc",
+        "rtl/tsan_report.cc",
+        "rtl/tsan_rtl.cc",
+        "rtl/tsan_rtl_mutex.cc",
+        "rtl/tsan_rtl_report.cc",
+        "rtl/tsan_rtl_thread.cc",
+        "rtl/tsan_stack_trace.cc",
+        "rtl/tsan_stat.cc",
+        "rtl/tsan_suppressions.cc",
+        "rtl/tsan_symbolize.cc",
+        "rtl/tsan_sync.cc",
+        "rtl/tsan_platform_linux.cc",
+        "rtl/tsan_platform_posix.cc",
+        "rtl/tsan_rtl_amd64.S",
+    ],
+    stl: "none",
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "64",
+    whole_static_libs: [
+        "libinterception",
+        "libsan",
+        "libubsan",
+    ],
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_library_host_static {
+    name: "libtsan_cxx",
+
+    include_dirs: ["external/compiler-rt/lib"],
+    cppflags: tsan_rtl_cppflags,
+    srcs: ["rtl/tsan_new_delete.cc"],
+    stl: "none",
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "64",
+    whole_static_libs: ["libubsan_cxx"],
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_test_host {
+    name: "libtsan_unit_test",
+
+    include_dirs: ["external/compiler-rt/lib"],
+    local_include_dirs: ["rtl"],
+    cppflags: tsan_rtl_cppflags,
+    srcs: [
+        "tests/unit/tsan_clock_test.cc",
+        "tests/unit/tsan_dense_alloc_test.cc",
+        "tests/unit/tsan_flags_test.cc",
+        "tests/unit/tsan_mman_test.cc",
+        "tests/unit/tsan_mutex_test.cc",
+        "tests/unit/tsan_mutexset_test.cc",
+        "tests/unit/tsan_shadow_test.cc",
+        "tests/unit/tsan_stack_test.cc",
+        "tests/unit/tsan_sync_test.cc",
+        "tests/unit/tsan_unit_test_main.cc",
+        "tests/unit/tsan_vector_test.cc",
+    ],
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "64",
+    static_libs: [
+        "libtsan",
+        "libubsan",
+    ],
+    host_ldlibs: [
+        "-lrt",
+        "-ldl",
+    ],
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_test_host {
+    name: "libtsan_rtl_test",
+
+    include_dirs: ["external/compiler-rt/lib"],
+    local_include_dirs: ["rtl"],
+    cppflags: tsan_rtl_cppflags,
+    srcs: [
+        "tests/rtl/tsan_bench.cc",
+        "tests/rtl/tsan_mop.cc",
+        "tests/rtl/tsan_mutex.cc",
+        "tests/rtl/tsan_posix.cc",
+        "tests/rtl/tsan_string.cc",
+        "tests/rtl/tsan_test_util_posix.cc",
+        "tests/rtl/tsan_test.cc",
+        "tests/rtl/tsan_thread.cc",
+    ],
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "64",
+    static_libs: [
+        "libtsan",
+        "libubsan",
+    ],
+    host_ldlibs: [
+        "-lrt",
+        "-ldl",
+    ],
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
diff --git a/compiler-rt/lib/tsan/CMakeLists.txt b/compiler-rt/lib/tsan/CMakeLists.txt
new file mode 100644
index 0000000..0e60cd3
--- /dev/null
+++ b/compiler-rt/lib/tsan/CMakeLists.txt
@@ -0,0 +1,215 @@
+# Build for the ThreadSanitizer runtime support library.
+
+include_directories(..)
+
+set(TSAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+# SANITIZER_COMMON_CFLAGS contains -fPIC, but it's performance-critical for
+# TSan runtime to be built with -fPIE to reduce the number of register spills.
+append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE TSAN_CFLAGS)
+append_no_rtti_flag(TSAN_CFLAGS)
+
+if(COMPILER_RT_TSAN_DEBUG_OUTPUT)
+  # Add extra debug information to TSan runtime. This configuration is rarely
+  # used, but we need to support it so that debug output will not bitrot.
+  list(APPEND TSAN_CFLAGS -DTSAN_COLLECT_STATS=1
+                          -DTSAN_DEBUG_OUTPUT=2)
+endif()
+
+set(TSAN_RTL_CFLAGS ${TSAN_CFLAGS})
+append_list_if(COMPILER_RT_HAS_MSSE3_FLAG -msse3 TSAN_RTL_CFLAGS)
+append_list_if(SANITIZER_LIMIT_FRAME_SIZE -Wframe-larger-than=512
+               TSAN_RTL_CFLAGS)
+append_list_if(COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG -Wglobal-constructors
+               TSAN_RTL_CFLAGS)
+
+set(TSAN_SOURCES
+  rtl/tsan_clock.cc
+  rtl/tsan_flags.cc
+  rtl/tsan_fd.cc
+  rtl/tsan_ignoreset.cc
+  rtl/tsan_interceptors.cc
+  rtl/tsan_interface_ann.cc
+  rtl/tsan_interface_atomic.cc
+  rtl/tsan_interface.cc
+  rtl/tsan_interface_java.cc
+  rtl/tsan_malloc_mac.cc
+  rtl/tsan_md5.cc
+  rtl/tsan_mman.cc
+  rtl/tsan_mutex.cc
+  rtl/tsan_mutexset.cc
+  rtl/tsan_report.cc
+  rtl/tsan_rtl.cc
+  rtl/tsan_rtl_mutex.cc
+  rtl/tsan_rtl_report.cc
+  rtl/tsan_rtl_thread.cc
+  rtl/tsan_stack_trace.cc
+  rtl/tsan_stat.cc
+  rtl/tsan_suppressions.cc
+  rtl/tsan_symbolize.cc
+  rtl/tsan_sync.cc)
+
+set(TSAN_CXX_SOURCES
+  rtl/tsan_new_delete.cc)
+
+if(APPLE)
+  list(APPEND TSAN_SOURCES
+    rtl/tsan_interceptors_mac.cc
+    rtl/tsan_libdispatch_mac.cc
+    rtl/tsan_platform_mac.cc
+    rtl/tsan_platform_posix.cc)
+elseif(UNIX)
+  # Assume Linux
+  list(APPEND TSAN_SOURCES
+    rtl/tsan_platform_linux.cc
+    rtl/tsan_platform_posix.cc)
+endif()
+
+set(TSAN_HEADERS
+  rtl/tsan_clock.h
+  rtl/tsan_defs.h
+  rtl/tsan_dense_alloc.h
+  rtl/tsan_fd.h
+  rtl/tsan_flags.h
+  rtl/tsan_flags.inc
+  rtl/tsan_ignoreset.h
+  rtl/tsan_interceptors.h
+  rtl/tsan_interface_ann.h
+  rtl/tsan_interface.h
+  rtl/tsan_interface_inl.h
+  rtl/tsan_interface_java.h
+  rtl/tsan_mman.h
+  rtl/tsan_mutex.h
+  rtl/tsan_mutexset.h
+  rtl/tsan_platform.h
+  rtl/tsan_report.h
+  rtl/tsan_rtl.h
+  rtl/tsan_stack_trace.h
+  rtl/tsan_stat.h
+  rtl/tsan_suppressions.h
+  rtl/tsan_symbolize.h
+  rtl/tsan_sync.h
+  rtl/tsan_trace.h
+  rtl/tsan_update_shadow_word_inl.h
+  rtl/tsan_vector.h)
+
+set(TSAN_RUNTIME_LIBRARIES)
+add_custom_target(tsan)
+
+if(APPLE)
+  set(TSAN_ASM_SOURCES rtl/tsan_rtl_amd64.S)
+  # Xcode will try to compile this file as C ('clang -x c'), and that will fail.
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
+    enable_language(ASM)
+  else()
+    # Pass ASM file directly to the C++ compiler.
+    set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES LANGUAGE C)
+  endif()
+  add_compiler_rt_runtime(clang_rt.tsan
+    SHARED
+    OS ${TSAN_SUPPORTED_OS}
+    ARCHS ${TSAN_SUPPORTED_ARCH}
+    SOURCES ${TSAN_SOURCES} ${TSAN_CXX_SOURCES} ${TSAN_ASM_SOURCES}
+    OBJECT_LIBS RTInterception
+                RTSanitizerCommon
+                RTSanitizerCommonLibc
+                RTUbsan
+    CFLAGS ${TSAN_RTL_CFLAGS}
+    PARENT_TARGET tsan)
+  add_compiler_rt_object_libraries(RTTsan_dynamic 
+    OS ${TSAN_SUPPORTED_OS}
+    ARCHS ${TSAN_SUPPORTED_ARCH}
+    SOURCES ${TSAN_SOURCES} ${TSAN_CXX_SOURCES} ${TSAN_ASM_SOURCES}
+    CFLAGS ${TSAN_RTL_CFLAGS})
+
+  # Build and check Go runtime.
+  set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/go/buildgo.sh)
+  add_custom_target(GotsanRuntimeCheck
+    COMMAND env "CC=${CMAKE_C_COMPILER} ${OSX_SYSROOT_FLAG}"
+            IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
+    DEPENDS tsan ${BUILDGO_SCRIPT}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
+    COMMENT "Checking TSan Go runtime..."
+    VERBATIM)
+else()
+  foreach(arch ${TSAN_SUPPORTED_ARCH})
+    if(arch STREQUAL "x86_64")
+      set(TSAN_ASM_SOURCES rtl/tsan_rtl_amd64.S)
+      # Pass ASM file directly to the C++ compiler.
+      set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
+        LANGUAGE C)
+      # Sanity check for Go runtime.
+      set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/go/buildgo.sh)
+      add_custom_target(GotsanRuntimeCheck
+        COMMAND env "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"
+                IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
+        DEPENDS clang_rt.tsan-${arch} ${BUILDGO_SCRIPT}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
+        COMMENT "Checking TSan Go runtime..."
+        VERBATIM)
+    elseif(arch STREQUAL "aarch64")
+      set(TSAN_ASM_SOURCES rtl/tsan_rtl_aarch64.S)
+      # Pass ASM file directly to the C++ compiler.
+      set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
+        LANGUAGE C)
+   elseif(arch MATCHES "powerpc64|powerpc64le")
+     set(TSAN_ASM_SOURCES rtl/tsan_rtl_ppc64.S)
+     # Pass ASM file directly to the C++ compiler.
+     set_source_files_properties(${TSAN_ASM_SOURCES} PROPERTIES
+       LANGUAGE C)
+    else()
+      set(TSAN_ASM_SOURCES)
+    endif()
+    add_compiler_rt_runtime(clang_rt.tsan
+      STATIC
+      ARCHS ${arch}
+      SOURCES ${TSAN_SOURCES} ${TSAN_ASM_SOURCES}
+              $<TARGET_OBJECTS:RTInterception.${arch}>
+              $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+              $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+              $<TARGET_OBJECTS:RTUbsan.${arch}>
+      CFLAGS ${TSAN_RTL_CFLAGS})
+    add_compiler_rt_runtime(clang_rt.tsan_cxx
+      STATIC
+      ARCHS ${arch}
+      SOURCES ${TSAN_CXX_SOURCES}
+              $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
+      CFLAGS ${TSAN_RTL_CFLAGS})
+    list(APPEND TSAN_RUNTIME_LIBRARIES clang_rt.tsan-${arch}
+                                       clang_rt.tsan_cxx-${arch})
+    add_sanitizer_rt_symbols(clang_rt.tsan
+      ARCHS ${arch}
+      EXTRA rtl/tsan.syms.extra)
+    add_sanitizer_rt_symbols(clang_rt.tsan_cxx
+      ARCHS ${arch}
+      EXTRA rtl/tsan.syms.extra)
+    add_dependencies(tsan clang_rt.tsan-${arch}
+                          clang_rt.tsan_cxx-${arch}
+                          clang_rt.tsan-${arch}-symbols
+                          clang_rt.tsan_cxx-${arch}-symbols)
+  endforeach()
+endif()
+
+add_dependencies(compiler-rt tsan)
+
+# Make sure that non-platform-specific files don't include any system headers.
+if(COMPILER_RT_HAS_SYSROOT_FLAG)
+  file(GLOB _tsan_generic_sources rtl/tsan*)
+  file(GLOB _tsan_platform_sources rtl/tsan*posix* rtl/tsan*mac*
+                                   rtl/tsan*linux*)
+  list(REMOVE_ITEM _tsan_generic_sources ${_tsan_platform_sources})
+  set_source_files_properties(${_tsan_generic_sources}
+    PROPERTIES COMPILE_FLAGS "--sysroot=.")
+endif()
+
+# Build libcxx instrumented with TSan.
+if(COMPILER_RT_HAS_LIBCXX_SOURCES AND
+   COMPILER_RT_TEST_COMPILER_ID STREQUAL "Clang")
+  set(LIBCXX_PREFIX ${CMAKE_CURRENT_BINARY_DIR}/libcxx_tsan)
+  add_custom_libcxx(libcxx_tsan ${LIBCXX_PREFIX}
+    DEPS ${TSAN_RUNTIME_LIBRARIES}
+    CFLAGS -fsanitize=thread)
+endif()
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(tests)
+endif()
diff --git a/compiler-rt/lib/tsan/analyze_libtsan.sh b/compiler-rt/lib/tsan/analyze_libtsan.sh
new file mode 100755
index 0000000..ae29f1b
--- /dev/null
+++ b/compiler-rt/lib/tsan/analyze_libtsan.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+#
+# Script that prints information about generated code in TSan runtime.
+
+set -e
+set -u
+
+if [[ "$#" != 1 ]]; then
+  echo "Usage: $0 /path/to/binary/built/with/tsan"
+  exit 1
+fi
+
+get_asm() {
+  grep __tsan_$1.: -A 10000 ${OBJDUMP_CONTENTS} | \
+    awk "/[^:]$/ {print;} />:/ {c++; if (c == 2) {exit}}"
+}
+
+list="write1 \
+      write2 \
+      write4 \
+      write8 \
+      read1 \
+      read2 \
+      read4 \
+      read8 \
+      func_entry \
+      func_exit"
+
+BIN=$1
+OUTPUT_DIR=$(mktemp -t -d analyze_libtsan_out.XXXXXXXX)
+OBJDUMP_CONTENTS=${OUTPUT_DIR}/libtsan_objdump
+NM_CONTENTS=${OUTPUT_DIR}/libtsan_nm
+
+objdump -d $BIN  > ${OBJDUMP_CONTENTS}
+nm -S $BIN | grep "__tsan_" > ${NM_CONTENTS}
+
+for f in $list; do
+  file=${OUTPUT_DIR}/asm_$f.s
+  get_asm $f > $file
+  tot=$(wc -l < $file)
+  size=$(grep __tsan_$f$ ${NM_CONTENTS} | awk --non-decimal-data '{print ("0x"$2)+0}')
+  rsp=$(grep '(%rsp)' $file | wc -l)
+  push=$(grep 'push' $file | wc -l)
+  pop=$(grep 'pop' $file | wc -l)
+  call=$(grep 'call' $file | wc -l)
+  load=$(egrep 'mov .*\,.*\(.*\)|cmp .*\,.*\(.*\)' $file | wc -l)
+  store=$(egrep 'mov .*\(.*\),' $file | wc -l)
+  mov=$(grep 'mov' $file | wc -l)
+  lea=$(grep 'lea' $file | wc -l)
+  sh=$(grep 'shr\|shl' $file | wc -l)
+  cmp=$(grep 'cmp\|test' $file | wc -l)
+  printf "%10s tot %3d; size %4d; rsp %d; push %d; pop %d; call %d; load %2d; store %2d; sh %3d; mov %3d; lea %3d; cmp %3d\n" \
+    $f $tot $size $rsp $push $pop $call $load $store $sh $mov $lea $cmp;
+done
diff --git a/compiler-rt/lib/tsan/benchmarks/mini_bench_local.cc b/compiler-rt/lib/tsan/benchmarks/mini_bench_local.cc
new file mode 100644
index 0000000..accdcb6
--- /dev/null
+++ b/compiler-rt/lib/tsan/benchmarks/mini_bench_local.cc
@@ -0,0 +1,49 @@
+// Mini-benchmark for tsan: non-shared memory writes.
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+int len;
+int *a;
+const int kNumIter = 1000;
+
+__attribute__((noinline))
+void Run(int idx) {
+  for (int i = 0, n = len; i < n; i++)
+    a[i + idx * n] = i;
+}
+
+void *Thread(void *arg) {
+  long idx = (long)arg;
+  printf("Thread %ld started\n", idx);
+  for (int i = 0; i < kNumIter; i++)
+    Run(idx);
+  printf("Thread %ld done\n", idx);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int n_threads = 0;
+  if (argc != 3) {
+    n_threads = 4;
+    len = 1000000;
+  } else {
+    n_threads = atoi(argv[1]);
+    assert(n_threads > 0 && n_threads <= 32);
+    len = atoi(argv[2]);
+  }
+  printf("%s: n_threads=%d len=%d iter=%d\n",
+         __FILE__, n_threads, len, kNumIter);
+  a = new int[n_threads * len];
+  pthread_t *t = new pthread_t[n_threads];
+  for (int i = 0; i < n_threads; i++) {
+    pthread_create(&t[i], 0, Thread, (void*)i);
+  }
+  for (int i = 0; i < n_threads; i++) {
+    pthread_join(t[i], 0);
+  }
+  delete [] t;
+  delete [] a;
+  return 0;
+}
diff --git a/compiler-rt/lib/tsan/benchmarks/mini_bench_shared.cc b/compiler-rt/lib/tsan/benchmarks/mini_bench_shared.cc
new file mode 100644
index 0000000..f9b9f42
--- /dev/null
+++ b/compiler-rt/lib/tsan/benchmarks/mini_bench_shared.cc
@@ -0,0 +1,51 @@
+// Mini-benchmark for tsan: shared memory reads.
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+int len;
+int *a;
+const int kNumIter = 1000;
+
+__attribute__((noinline))
+void Run(int idx) {
+  for (int i = 0, n = len; i < n; i++)
+    if (a[i] != i) abort();
+}
+
+void *Thread(void *arg) {
+  long idx = (long)arg;
+  printf("Thread %ld started\n", idx);
+  for (int i = 0; i < kNumIter; i++)
+    Run(idx);
+  printf("Thread %ld done\n", idx);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int n_threads = 0;
+  if (argc != 3) {
+    n_threads = 4;
+    len = 1000000;
+  } else {
+    n_threads = atoi(argv[1]);
+    assert(n_threads > 0 && n_threads <= 32);
+    len = atoi(argv[2]);
+  }
+  printf("%s: n_threads=%d len=%d iter=%d\n",
+         __FILE__, n_threads, len, kNumIter);
+  a = new int[len];
+  for (int i = 0, n = len; i < n; i++)
+    a[i] = i;
+  pthread_t *t = new pthread_t[n_threads];
+  for (int i = 0; i < n_threads; i++) {
+    pthread_create(&t[i], 0, Thread, (void*)i);
+  }
+  for (int i = 0; i < n_threads; i++) {
+    pthread_join(t[i], 0);
+  }
+  delete [] t;
+  delete [] a;
+  return 0;
+}
diff --git a/compiler-rt/lib/tsan/benchmarks/start_many_threads.cc b/compiler-rt/lib/tsan/benchmarks/start_many_threads.cc
new file mode 100644
index 0000000..1e86fa6
--- /dev/null
+++ b/compiler-rt/lib/tsan/benchmarks/start_many_threads.cc
@@ -0,0 +1,52 @@
+// Mini-benchmark for creating a lot of threads.
+//
+// Some facts:
+// a) clang -O1 takes <15ms to start N=500 threads,
+//    consuming ~4MB more RAM than N=1.
+// b) clang -O1 -ftsan takes ~26s to start N=500 threads,
+//    eats 5GB more RAM than N=1 (which is somewhat expected but still a lot)
+//    but then it consumes ~4GB of extra memory when the threads shut down!
+//        (definitely not in the barrier_wait interceptor)
+//    Also, it takes 26s to run with N=500 vs just 1.1s to run with N=1.
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+pthread_barrier_t all_threads_ready;
+
+void* Thread(void *unused) {
+  pthread_barrier_wait(&all_threads_ready);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int n_threads;
+  if (argc == 1) {
+    n_threads = 100;
+  } else if (argc == 2) {
+    n_threads = atoi(argv[1]);
+  } else {
+    printf("Usage: %s n_threads\n", argv[0]);
+    return 1;
+  }
+  printf("%s: n_threads=%d\n", __FILE__, n_threads);
+
+  pthread_barrier_init(&all_threads_ready, NULL, n_threads + 1);
+
+  pthread_t *t = new pthread_t[n_threads];
+  for (int i = 0; i < n_threads; i++) {
+    int status = pthread_create(&t[i], 0, Thread, (void*)i);
+    assert(status == 0);
+  }
+  // sleep(5);  // FIXME: simplify measuring the memory usage.
+  pthread_barrier_wait(&all_threads_ready);
+  for (int i = 0; i < n_threads; i++) {
+    pthread_join(t[i], 0);
+  }
+  // sleep(5);  // FIXME: simplify measuring the memory usage.
+  delete [] t;
+
+  return 0;
+}
diff --git a/compiler-rt/lib/tsan/benchmarks/vts_many_threads_bench.cc b/compiler-rt/lib/tsan/benchmarks/vts_many_threads_bench.cc
new file mode 100644
index 0000000..f1056e2
--- /dev/null
+++ b/compiler-rt/lib/tsan/benchmarks/vts_many_threads_bench.cc
@@ -0,0 +1,120 @@
+// Mini-benchmark for tsan VTS worst case performance
+// Idea:
+// 1) Spawn M + N threads (M >> N)
+//    We'll call the 'M' threads as 'garbage threads'.
+// 2) Make sure all threads have created thus no TIDs were reused
+// 3) Join the garbage threads
+// 4) Do many sync operations on the remaining N threads
+//
+// It turns out that due to O(M+N) VTS complexity the (4) is much slower with
+// when N is large.
+//
+// Some numbers:
+// a) clang++ native O1 with n_iterations=200kk takes
+//      5s regardless of M
+//    clang++ tsanv2 O1 with n_iterations=20kk takes
+//      23.5s with M=200
+//      11.5s with M=1
+//    i.e. tsanv2 is ~23x to ~47x slower than native, depends on M.
+// b) g++ native O1 with n_iterations=200kk takes
+//      5.5s regardless of M
+//    g++ tsanv1 O1 with n_iterations=2kk takes
+//      39.5s with M=200
+//      20.5s with M=1
+//    i.e. tsanv1 is ~370x to ~720x slower than native, depends on M.
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+class __attribute__((aligned(64))) Mutex {
+ public:
+  Mutex()  { pthread_mutex_init(&m_, NULL); }
+  ~Mutex() { pthread_mutex_destroy(&m_); }
+  void Lock() { pthread_mutex_lock(&m_); }
+  void Unlock() { pthread_mutex_unlock(&m_); }
+
+ private:
+  pthread_mutex_t m_;
+};
+
+const int kNumMutexes = 1024;
+Mutex mutexes[kNumMutexes];
+
+int n_threads, n_iterations;
+
+pthread_barrier_t all_threads_ready, main_threads_ready;
+
+void* GarbageThread(void *unused) {
+  pthread_barrier_wait(&all_threads_ready);
+  return 0;
+}
+
+void *Thread(void *arg) {
+  long idx = (long)arg;
+  pthread_barrier_wait(&all_threads_ready);
+
+  // Wait for the main thread to join the garbage threads.
+  pthread_barrier_wait(&main_threads_ready);
+
+  printf("Thread %ld go!\n", idx);
+  int offset = idx * kNumMutexes / n_threads;
+  for (int i = 0; i < n_iterations; i++) {
+    mutexes[(offset + i) % kNumMutexes].Lock();
+    mutexes[(offset + i) % kNumMutexes].Unlock();
+  }
+  printf("Thread %ld done\n", idx);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int n_garbage_threads;
+  if (argc == 1) {
+    n_threads = 2;
+    n_garbage_threads = 200;
+    n_iterations = 20000000;
+  } else if (argc == 4) {
+    n_threads = atoi(argv[1]);
+    assert(n_threads > 0 && n_threads <= 32);
+    n_garbage_threads = atoi(argv[2]);
+    assert(n_garbage_threads > 0 && n_garbage_threads <= 16000);
+    n_iterations = atoi(argv[3]);
+  } else {
+    printf("Usage: %s n_threads n_garbage_threads n_iterations\n", argv[0]);
+    return 1;
+  }
+  printf("%s: n_threads=%d n_garbage_threads=%d n_iterations=%d\n",
+         __FILE__, n_threads, n_garbage_threads, n_iterations);
+
+  pthread_barrier_init(&all_threads_ready, NULL, n_garbage_threads + n_threads + 1);
+  pthread_barrier_init(&main_threads_ready, NULL, n_threads + 1);
+
+  pthread_t *t = new pthread_t[n_threads];
+  {
+    pthread_t *g_t = new pthread_t[n_garbage_threads];
+    for (int i = 0; i < n_garbage_threads; i++) {
+      int status = pthread_create(&g_t[i], 0, GarbageThread, NULL);
+      assert(status == 0);
+    }
+    for (int i = 0; i < n_threads; i++) {
+      int status = pthread_create(&t[i], 0, Thread, (void*)i);
+      assert(status == 0);
+    }
+    pthread_barrier_wait(&all_threads_ready);
+    printf("All threads started! Killing the garbage threads.\n");
+    for (int i = 0; i < n_garbage_threads; i++) {
+      pthread_join(g_t[i], 0);
+    }
+    delete [] g_t;
+  }
+  printf("Resuming the main threads.\n");
+  pthread_barrier_wait(&main_threads_ready);
+
+
+  for (int i = 0; i < n_threads; i++) {
+    pthread_join(t[i], 0);
+  }
+  delete [] t;
+  return 0;
+}
diff --git a/compiler-rt/lib/tsan/check_analyze.sh b/compiler-rt/lib/tsan/check_analyze.sh
new file mode 100755
index 0000000..0f6cc06
--- /dev/null
+++ b/compiler-rt/lib/tsan/check_analyze.sh
@@ -0,0 +1,60 @@
+#!/bin/bash
+#
+# Script that checks that critical functions in TSan runtime have correct number
+# of push/pop/rsp instructions to verify that runtime is efficient enough.
+
+set -u
+
+if [[ "$#" != 1 ]]; then
+  echo "Usage: $0 /path/to/binary/built/with/tsan"
+  exit 1
+fi
+
+SCRIPTDIR=$(dirname $0)
+RES=$(${SCRIPTDIR}/analyze_libtsan.sh $1)
+PrintRes() {
+  printf "%s\n" "$RES"
+}
+
+PrintRes
+
+check() {
+  res=$(PrintRes | egrep "$1 .* $2 $3; ")
+  if [ "$res" == "" ]; then
+    echo FAILED $1 must contain $2 $3
+    exit 1
+  fi
+}
+
+for f in write1; do
+  check $f rsp 1
+  check $f push 2
+  check $f pop 2
+done
+
+for f in write2 write4; do
+  check $f rsp 1
+  check $f push 4
+  check $f pop 4
+done
+
+for f in write8; do
+  check $f rsp 1
+  check $f push 3
+  check $f pop 3
+done
+
+for f in read1 read2 read4 read8; do
+  check $f rsp 1
+  check $f push 5
+  check $f pop 5
+done
+
+for f in func_entry func_exit; do
+  check $f rsp 0
+  check $f push 0
+  check $f pop 0
+  check $f call 1  # TraceSwitch()
+done
+
+echo LGTM
diff --git a/compiler-rt/lib/tsan/check_cmake.sh b/compiler-rt/lib/tsan/check_cmake.sh
new file mode 100755
index 0000000..7668c5b
--- /dev/null
+++ b/compiler-rt/lib/tsan/check_cmake.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -u
+set -e
+
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+if [ -d "$ROOT/llvm-build" ]; then
+  cd $ROOT/llvm-build
+else
+  mkdir -p $ROOT/llvm-build
+  cd $ROOT/llvm-build
+  CC=clang CXX=clang++ cmake -G Ninja -DLLVM_ENABLE_WERROR=ON -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON $ROOT/../../../..
+fi
+ninja
+ninja check-sanitizer
+ninja check-tsan
+ninja check-asan
+ninja check-msan
+ninja check-lsan
diff --git a/compiler-rt/lib/tsan/dd/CMakeLists.txt b/compiler-rt/lib/tsan/dd/CMakeLists.txt
new file mode 100644
index 0000000..6330bd9
--- /dev/null
+++ b/compiler-rt/lib/tsan/dd/CMakeLists.txt
@@ -0,0 +1,47 @@
+# Build for the experimental deadlock detector runtime library.
+
+include_directories(../..)
+
+set(DD_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(DD_CFLAGS)
+
+set(DD_SOURCES
+  dd_rtl.cc
+  dd_interceptors.cc
+)
+
+set(DD_LINKLIBS)
+append_list_if(COMPILER_RT_HAS_LIBDL dl DD_LINKLIBS)
+append_list_if(COMPILER_RT_HAS_LIBRT rt DD_LINKLIBS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread DD_LINKLIBS)
+
+add_custom_target(dd)
+# Deadlock detector is currently supported on 64-bit Linux only.
+if(CAN_TARGET_x86_64 AND UNIX AND NOT APPLE AND NOT ANDROID)
+  set(arch "x86_64")
+  add_compiler_rt_runtime(clang_rt.dd
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${DD_SOURCES}
+            $<TARGET_OBJECTS:RTInterception.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+    CFLAGS ${DD_CFLAGS}
+    PARENT_TARGET dd)
+
+  add_compiler_rt_object_libraries(RTDD
+    ARCHS ${arch}
+    SOURCES ${DD_SOURCES} CFLAGS ${DD_CFLAGS})
+
+  add_compiler_rt_runtime(clang_rt.dyndd
+    SHARED
+    ARCHS ${arch}
+    SOURCES $<TARGET_OBJECTS:RTDD.${arch}>
+            $<TARGET_OBJECTS:RTInterception.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+    LINK_LIBS ${DD_LINKLIBS}
+    PARENT_TARGET dd)
+endif()
+
+add_dependencies(compiler-rt dd)
diff --git a/compiler-rt/lib/tsan/dd/dd_interceptors.cc b/compiler-rt/lib/tsan/dd/dd_interceptors.cc
new file mode 100644
index 0000000..8151f7f
--- /dev/null
+++ b/compiler-rt/lib/tsan/dd/dd_interceptors.cc
@@ -0,0 +1,333 @@
+//===-- dd_interceptors.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "dd_rtl.h"
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include <pthread.h>
+#include <stdlib.h>
+
+using namespace __dsan;
+
+extern "C" void *__libc_malloc(uptr size);
+extern "C" void __libc_free(void *ptr);
+
+__attribute__((tls_model("initial-exec")))
+static __thread Thread *thr;
+__attribute__((tls_model("initial-exec")))
+static __thread volatile int initing;
+static bool inited;
+static uptr g_data_start;
+static uptr g_data_end;
+
+static bool InitThread() {
+  if (initing)
+    return false;
+  if (thr != 0)
+    return true;
+  initing = true;
+  if (!inited) {
+    inited = true;
+    Initialize();
+  }
+  thr = (Thread*)InternalAlloc(sizeof(*thr));
+  internal_memset(thr, 0, sizeof(*thr));
+  ThreadInit(thr);
+  initing = false;
+  return true;
+}
+
+INTERCEPTOR(int, pthread_mutex_destroy, pthread_mutex_t *m) {
+  InitThread();
+  MutexDestroy(thr, (uptr)m);
+  return REAL(pthread_mutex_destroy)(m);
+}
+
+INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *m) {
+  InitThread();
+  MutexBeforeLock(thr, (uptr)m, true);
+  int res = REAL(pthread_mutex_lock)(m);
+  MutexAfterLock(thr, (uptr)m, true, false);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_mutex_trylock, pthread_mutex_t *m) {
+  InitThread();
+  int res = REAL(pthread_mutex_trylock)(m);
+  if (res == 0)
+    MutexAfterLock(thr, (uptr)m, true, true);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *m) {
+  InitThread();
+  MutexBeforeUnlock(thr, (uptr)m, true);
+  return REAL(pthread_mutex_unlock)(m);
+}
+
+INTERCEPTOR(int, pthread_spin_destroy, pthread_spinlock_t *m) {
+  InitThread();
+  int res = REAL(pthread_spin_destroy)(m);
+  MutexDestroy(thr, (uptr)m);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *m) {
+  InitThread();
+  MutexBeforeLock(thr, (uptr)m, true);
+  int res = REAL(pthread_spin_lock)(m);
+  MutexAfterLock(thr, (uptr)m, true, false);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_spin_trylock, pthread_spinlock_t *m) {
+  InitThread();
+  int res = REAL(pthread_spin_trylock)(m);
+  if (res == 0)
+    MutexAfterLock(thr, (uptr)m, true, true);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_spin_unlock, pthread_spinlock_t *m) {
+  InitThread();
+  MutexBeforeUnlock(thr, (uptr)m, true);
+  return REAL(pthread_spin_unlock)(m);
+}
+
+INTERCEPTOR(int, pthread_rwlock_destroy, pthread_rwlock_t *m) {
+  InitThread();
+  MutexDestroy(thr, (uptr)m);
+  return REAL(pthread_rwlock_destroy)(m);
+}
+
+INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *m) {
+  InitThread();
+  MutexBeforeLock(thr, (uptr)m, false);
+  int res = REAL(pthread_rwlock_rdlock)(m);
+  MutexAfterLock(thr, (uptr)m, false, false);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_rwlock_tryrdlock, pthread_rwlock_t *m) {
+  InitThread();
+  int res = REAL(pthread_rwlock_tryrdlock)(m);
+  if (res == 0)
+    MutexAfterLock(thr, (uptr)m, false, true);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_rwlock_timedrdlock, pthread_rwlock_t *m,
+    const timespec *abstime) {
+  InitThread();
+  int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
+  if (res == 0)
+    MutexAfterLock(thr, (uptr)m, false, true);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *m) {
+  InitThread();
+  MutexBeforeLock(thr, (uptr)m, true);
+  int res = REAL(pthread_rwlock_wrlock)(m);
+  MutexAfterLock(thr, (uptr)m, true, false);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_rwlock_trywrlock, pthread_rwlock_t *m) {
+  InitThread();
+  int res = REAL(pthread_rwlock_trywrlock)(m);
+  if (res == 0)
+    MutexAfterLock(thr, (uptr)m, true, true);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_rwlock_timedwrlock, pthread_rwlock_t *m,
+    const timespec *abstime) {
+  InitThread();
+  int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
+  if (res == 0)
+    MutexAfterLock(thr, (uptr)m, true, true);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *m) {
+  InitThread();
+  MutexBeforeUnlock(thr, (uptr)m, true);  // note: not necessary write unlock
+  return REAL(pthread_rwlock_unlock)(m);
+}
+
+static pthread_cond_t *init_cond(pthread_cond_t *c, bool force = false) {
+  atomic_uintptr_t *p = (atomic_uintptr_t*)c;
+  uptr cond = atomic_load(p, memory_order_acquire);
+  if (!force && cond != 0)
+    return (pthread_cond_t*)cond;
+  void *newcond = malloc(sizeof(pthread_cond_t));
+  internal_memset(newcond, 0, sizeof(pthread_cond_t));
+  if (atomic_compare_exchange_strong(p, &cond, (uptr)newcond,
+      memory_order_acq_rel))
+    return (pthread_cond_t*)newcond;
+  free(newcond);
+  return (pthread_cond_t*)cond;
+}
+
+INTERCEPTOR(int, pthread_cond_init, pthread_cond_t *c,
+    const pthread_condattr_t *a) {
+  InitThread();
+  pthread_cond_t *cond = init_cond(c, true);
+  return REAL(pthread_cond_init)(cond, a);
+}
+
+INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *c, pthread_mutex_t *m) {
+  InitThread();
+  pthread_cond_t *cond = init_cond(c);
+  MutexBeforeUnlock(thr, (uptr)m, true);
+  MutexBeforeLock(thr, (uptr)m, true);
+  int res = REAL(pthread_cond_wait)(cond, m);
+  MutexAfterLock(thr, (uptr)m, true, false);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *c, pthread_mutex_t *m,
+    const timespec *abstime) {
+  InitThread();
+  pthread_cond_t *cond = init_cond(c);
+  MutexBeforeUnlock(thr, (uptr)m, true);
+  MutexBeforeLock(thr, (uptr)m, true);
+  int res = REAL(pthread_cond_timedwait)(cond, m, abstime);
+  MutexAfterLock(thr, (uptr)m, true, false);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *c) {
+  InitThread();
+  pthread_cond_t *cond = init_cond(c);
+  return REAL(pthread_cond_signal)(cond);
+}
+
+INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *c) {
+  InitThread();
+  pthread_cond_t *cond = init_cond(c);
+  return REAL(pthread_cond_broadcast)(cond);
+}
+
+INTERCEPTOR(int, pthread_cond_destroy, pthread_cond_t *c) {
+  InitThread();
+  pthread_cond_t *cond = init_cond(c);
+  int res = REAL(pthread_cond_destroy)(cond);
+  free(cond);
+  atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
+  return res;
+}
+
+// for symbolizer
+INTERCEPTOR(char*, realpath, const char *path, char *resolved_path) {
+  InitThread();
+  return REAL(realpath)(path, resolved_path);
+}
+
+INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
+  InitThread();
+  return REAL(read)(fd, ptr, count);
+}
+
+INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
+  InitThread();
+  return REAL(pread)(fd, ptr, count, offset);
+}
+
+extern "C" {
+void __dsan_before_mutex_lock(uptr m, int writelock) {
+  if (!InitThread())
+    return;
+  MutexBeforeLock(thr, m, writelock);
+}
+
+void __dsan_after_mutex_lock(uptr m, int writelock, int trylock) {
+  if (!InitThread())
+    return;
+  MutexAfterLock(thr, m, writelock, trylock);
+}
+
+void __dsan_before_mutex_unlock(uptr m, int writelock) {
+  if (!InitThread())
+    return;
+  MutexBeforeUnlock(thr, m, writelock);
+}
+
+void __dsan_mutex_destroy(uptr m) {
+  if (!InitThread())
+    return;
+  // if (m >= g_data_start && m < g_data_end)
+  //   return;
+  MutexDestroy(thr, m);
+}
+}  // extern "C"
+
+namespace __dsan {
+
+static void InitDataSeg() {
+  MemoryMappingLayout proc_maps(true);
+  uptr start, end, offset;
+  char name[128];
+  bool prev_is_data = false;
+  while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name),
+                        /*protection*/ 0)) {
+    bool is_data = offset != 0 && name[0] != 0;
+    // BSS may get merged with [heap] in /proc/self/maps. This is not very
+    // reliable.
+    bool is_bss = offset == 0 &&
+      (name[0] == 0 || internal_strcmp(name, "[heap]") == 0) && prev_is_data;
+    if (g_data_start == 0 && is_data)
+      g_data_start = start;
+    if (is_bss)
+      g_data_end = end;
+    prev_is_data = is_data;
+  }
+  VPrintf(1, "guessed data_start=%p data_end=%p\n",  g_data_start, g_data_end);
+  CHECK_LT(g_data_start, g_data_end);
+  CHECK_GE((uptr)&g_data_start, g_data_start);
+  CHECK_LT((uptr)&g_data_start, g_data_end);
+}
+
+void InitializeInterceptors() {
+  INTERCEPT_FUNCTION(pthread_mutex_destroy);
+  INTERCEPT_FUNCTION(pthread_mutex_lock);
+  INTERCEPT_FUNCTION(pthread_mutex_trylock);
+  INTERCEPT_FUNCTION(pthread_mutex_unlock);
+
+  INTERCEPT_FUNCTION(pthread_spin_destroy);
+  INTERCEPT_FUNCTION(pthread_spin_lock);
+  INTERCEPT_FUNCTION(pthread_spin_trylock);
+  INTERCEPT_FUNCTION(pthread_spin_unlock);
+
+  INTERCEPT_FUNCTION(pthread_rwlock_destroy);
+  INTERCEPT_FUNCTION(pthread_rwlock_rdlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_tryrdlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_timedrdlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_wrlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_trywrlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_timedwrlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_unlock);
+
+  INTERCEPT_FUNCTION_VER(pthread_cond_init, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_signal, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_broadcast, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_wait, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_timedwait, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_destroy, "GLIBC_2.3.2");
+
+  // for symbolizer
+  INTERCEPT_FUNCTION(realpath);
+  INTERCEPT_FUNCTION(read);
+  INTERCEPT_FUNCTION(pread);
+
+  InitDataSeg();
+}
+
+}  // namespace __dsan
diff --git a/compiler-rt/lib/tsan/dd/dd_rtl.cc b/compiler-rt/lib/tsan/dd/dd_rtl.cc
new file mode 100644
index 0000000..99b8ee5
--- /dev/null
+++ b/compiler-rt/lib/tsan/dd/dd_rtl.cc
@@ -0,0 +1,159 @@
+//===-- dd_rtl.cc ---------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "dd_rtl.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+
+namespace __dsan {
+
+static Context *ctx;
+
+static u32 CurrentStackTrace(Thread *thr, uptr skip) {
+  BufferedStackTrace stack;
+  thr->ignore_interceptors = true;
+  stack.Unwind(1000, 0, 0, 0, 0, 0, false);
+  thr->ignore_interceptors = false;
+  if (stack.size <= skip)
+    return 0;
+  return StackDepotPut(StackTrace(stack.trace + skip, stack.size - skip));
+}
+
+static void PrintStackTrace(Thread *thr, u32 stk) {
+  StackTrace stack = StackDepotGet(stk);
+  thr->ignore_interceptors = true;
+  stack.Print();
+  thr->ignore_interceptors = false;
+}
+
+static void ReportDeadlock(Thread *thr, DDReport *rep) {
+  if (rep == 0)
+    return;
+  BlockingMutexLock lock(&ctx->report_mutex);
+  Printf("==============================\n");
+  Printf("WARNING: lock-order-inversion (potential deadlock)\n");
+  for (int i = 0; i < rep->n; i++) {
+    Printf("Thread %d locks mutex %llu while holding mutex %llu:\n",
+      rep->loop[i].thr_ctx, rep->loop[i].mtx_ctx1, rep->loop[i].mtx_ctx0);
+    PrintStackTrace(thr, rep->loop[i].stk[1]);
+    if (rep->loop[i].stk[0]) {
+      Printf("Mutex %llu was acquired here:\n",
+        rep->loop[i].mtx_ctx0);
+      PrintStackTrace(thr, rep->loop[i].stk[0]);
+    }
+  }
+  Printf("==============================\n");
+}
+
+Callback::Callback(Thread *thr)
+    : thr(thr) {
+  lt = thr->dd_lt;
+  pt = thr->dd_pt;
+}
+
+u32 Callback::Unwind() {
+  return CurrentStackTrace(thr, 3);
+}
+
+static void InitializeFlags() {
+  Flags *f = flags();
+
+  // Default values.
+  f->second_deadlock_stack = false;
+
+  SetCommonFlagsDefaults();
+  {
+    // Override some common flags defaults.
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.allow_addr2line = true;
+    OverrideCommonFlags(cf);
+  }
+
+  // Override from command line.
+  FlagParser parser;
+  RegisterFlag(&parser, "second_deadlock_stack", "", &f->second_deadlock_stack);
+  RegisterCommonFlags(&parser);
+  parser.ParseString(GetEnv("DSAN_OPTIONS"));
+  SetVerbosity(common_flags()->verbosity);
+}
+
+void Initialize() {
+  static u64 ctx_mem[sizeof(Context) / sizeof(u64) + 1];
+  ctx = new(ctx_mem) Context();
+
+  InitializeInterceptors();
+  InitializeFlags();
+  ctx->dd = DDetector::Create(flags());
+}
+
+void ThreadInit(Thread *thr) {
+  static atomic_uintptr_t id_gen;
+  uptr id = atomic_fetch_add(&id_gen, 1, memory_order_relaxed);
+  thr->dd_pt = ctx->dd->CreatePhysicalThread();
+  thr->dd_lt = ctx->dd->CreateLogicalThread(id);
+}
+
+void ThreadDestroy(Thread *thr) {
+  ctx->dd->DestroyPhysicalThread(thr->dd_pt);
+  ctx->dd->DestroyLogicalThread(thr->dd_lt);
+}
+
+void MutexBeforeLock(Thread *thr, uptr m, bool writelock) {
+  if (thr->ignore_interceptors)
+    return;
+  Callback cb(thr);
+  {
+    MutexHashMap::Handle h(&ctx->mutex_map, m);
+    if (h.created())
+      ctx->dd->MutexInit(&cb, &h->dd);
+    ctx->dd->MutexBeforeLock(&cb, &h->dd, writelock);
+  }
+  ReportDeadlock(thr, ctx->dd->GetReport(&cb));
+}
+
+void MutexAfterLock(Thread *thr, uptr m, bool writelock, bool trylock) {
+  if (thr->ignore_interceptors)
+    return;
+  Callback cb(thr);
+  {
+    MutexHashMap::Handle h(&ctx->mutex_map, m);
+    if (h.created())
+      ctx->dd->MutexInit(&cb, &h->dd);
+    ctx->dd->MutexAfterLock(&cb, &h->dd, writelock, trylock);
+  }
+  ReportDeadlock(thr, ctx->dd->GetReport(&cb));
+}
+
+void MutexBeforeUnlock(Thread *thr, uptr m, bool writelock) {
+  if (thr->ignore_interceptors)
+    return;
+  Callback cb(thr);
+  {
+    MutexHashMap::Handle h(&ctx->mutex_map, m);
+    ctx->dd->MutexBeforeUnlock(&cb, &h->dd, writelock);
+  }
+  ReportDeadlock(thr, ctx->dd->GetReport(&cb));
+}
+
+void MutexDestroy(Thread *thr, uptr m) {
+  if (thr->ignore_interceptors)
+    return;
+  Callback cb(thr);
+  MutexHashMap::Handle h(&ctx->mutex_map, m, true);
+  if (!h.exists())
+    return;
+  ctx->dd->MutexDestroy(&cb, &h->dd);
+}
+
+}  // namespace __dsan
diff --git a/compiler-rt/lib/tsan/dd/dd_rtl.h b/compiler-rt/lib/tsan/dd/dd_rtl.h
new file mode 100644
index 0000000..9abf17d
--- /dev/null
+++ b/compiler-rt/lib/tsan/dd/dd_rtl.h
@@ -0,0 +1,67 @@
+//===-- dd_rtl.h ----------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef DD_RTL_H
+#define DD_RTL_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_addrhashmap.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+
+namespace __dsan {
+
+typedef DDFlags Flags;
+
+struct Mutex {
+  DDMutex dd;
+};
+
+struct Thread {
+  DDPhysicalThread *dd_pt;
+  DDLogicalThread *dd_lt;
+
+  bool ignore_interceptors;
+};
+
+struct Callback : DDCallback {
+  Thread *thr;
+
+  Callback(Thread *thr);
+  u32 Unwind() override;
+};
+
+typedef AddrHashMap<Mutex, 31051> MutexHashMap;
+
+struct Context {
+  DDetector *dd;
+
+  BlockingMutex report_mutex;
+  MutexHashMap mutex_map;
+};
+
+inline Flags* flags() {
+  static Flags flags;
+  return &flags;
+}
+
+void Initialize();
+void InitializeInterceptors();
+
+void ThreadInit(Thread *thr);
+void ThreadDestroy(Thread *thr);
+
+void MutexBeforeLock(Thread *thr, uptr m, bool writelock);
+void MutexAfterLock(Thread *thr, uptr m, bool writelock, bool trylock);
+void MutexBeforeUnlock(Thread *thr, uptr m, bool writelock);
+void MutexDestroy(Thread *thr, uptr m);
+
+}  // namespace __dsan
+#endif  // DD_RTL_H
diff --git a/compiler-rt/lib/tsan/go/build.bat b/compiler-rt/lib/tsan/go/build.bat
new file mode 100644
index 0000000..7d393dc
--- /dev/null
+++ b/compiler-rt/lib/tsan/go/build.bat
@@ -0,0 +1,4 @@
+type tsan_go.cc ..\rtl\tsan_interface_atomic.cc ..\rtl\tsan_clock.cc ..\rtl\tsan_flags.cc ..\rtl\tsan_md5.cc ..\rtl\tsan_mutex.cc ..\rtl\tsan_report.cc ..\rtl\tsan_rtl.cc ..\rtl\tsan_rtl_mutex.cc ..\rtl\tsan_rtl_report.cc ..\rtl\tsan_rtl_thread.cc ..\rtl\tsan_stat.cc ..\rtl\tsan_suppressions.cc ..\rtl\tsan_sync.cc ..\rtl\tsan_stack_trace.cc ..\..\sanitizer_common\sanitizer_allocator.cc ..\..\sanitizer_common\sanitizer_common.cc ..\..\sanitizer_common\sanitizer_flags.cc ..\..\sanitizer_common\sanitizer_stacktrace.cc ..\..\sanitizer_common\sanitizer_libc.cc ..\..\sanitizer_common\sanitizer_printf.cc ..\..\sanitizer_common\sanitizer_suppressions.cc ..\..\sanitizer_common\sanitizer_thread_registry.cc ..\rtl\tsan_platform_windows.cc ..\..\sanitizer_common\sanitizer_win.cc ..\..\sanitizer_common\sanitizer_deadlock_detector1.cc ..\..\sanitizer_common\sanitizer_stackdepot.cc ..\..\sanitizer_common\sanitizer_persistent_allocator.cc ..\..\sanitizer_common\sanitizer_flag_parser.cc ..\..\sanitizer_common\sanitizer_symbolizer.cc > gotsan.cc
+
+gcc -c -o race_windows_amd64.syso gotsan.cc -I..\rtl -I..\.. -I..\..\sanitizer_common -I..\..\..\include -m64 -Wall -fno-exceptions -fno-rtti -DSANITIZER_GO -Wno-error=attributes -Wno-attributes -Wno-format -Wno-maybe-uninitialized -DSANITIZER_DEBUG=0 -O3 -fomit-frame-pointer -std=c++11
+
diff --git a/compiler-rt/lib/tsan/go/buildgo.sh b/compiler-rt/lib/tsan/go/buildgo.sh
new file mode 100755
index 0000000..fdbd405
--- /dev/null
+++ b/compiler-rt/lib/tsan/go/buildgo.sh
@@ -0,0 +1,132 @@
+#!/bin/sh
+
+set -e
+
+SRCS="
+	tsan_go.cc
+	../rtl/tsan_clock.cc
+	../rtl/tsan_flags.cc
+	../rtl/tsan_interface_atomic.cc
+	../rtl/tsan_md5.cc
+	../rtl/tsan_mutex.cc
+	../rtl/tsan_report.cc
+	../rtl/tsan_rtl.cc
+	../rtl/tsan_rtl_mutex.cc
+	../rtl/tsan_rtl_report.cc
+	../rtl/tsan_rtl_thread.cc
+	../rtl/tsan_stack_trace.cc
+	../rtl/tsan_stat.cc
+	../rtl/tsan_suppressions.cc
+	../rtl/tsan_sync.cc
+	../../sanitizer_common/sanitizer_allocator.cc
+	../../sanitizer_common/sanitizer_common.cc
+	../../sanitizer_common/sanitizer_common_libcdep.cc
+	../../sanitizer_common/sanitizer_deadlock_detector2.cc
+	../../sanitizer_common/sanitizer_flag_parser.cc
+	../../sanitizer_common/sanitizer_flags.cc
+	../../sanitizer_common/sanitizer_libc.cc
+	../../sanitizer_common/sanitizer_persistent_allocator.cc
+	../../sanitizer_common/sanitizer_printf.cc
+	../../sanitizer_common/sanitizer_suppressions.cc
+	../../sanitizer_common/sanitizer_thread_registry.cc
+	../../sanitizer_common/sanitizer_stackdepot.cc
+	../../sanitizer_common/sanitizer_stacktrace.cc
+	../../sanitizer_common/sanitizer_symbolizer.cc
+"
+
+if [ "`uname -a | grep Linux`" != "" ]; then
+	SUFFIX="linux_amd64"
+	OSCFLAGS="-fPIC -ffreestanding -Wno-maybe-uninitialized -Wno-unused-const-variable -Werror -Wno-unknown-warning-option"
+	OSLDFLAGS="-lpthread -fPIC -fpie"
+	SRCS="
+		$SRCS
+		../rtl/tsan_platform_linux.cc
+		../../sanitizer_common/sanitizer_posix.cc
+		../../sanitizer_common/sanitizer_posix_libcdep.cc
+		../../sanitizer_common/sanitizer_procmaps_common.cc
+		../../sanitizer_common/sanitizer_procmaps_linux.cc
+		../../sanitizer_common/sanitizer_linux.cc
+		../../sanitizer_common/sanitizer_linux_libcdep.cc
+		../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
+	"
+elif [ "`uname -a | grep FreeBSD`" != "" ]; then
+        SUFFIX="freebsd_amd64"
+        OSCFLAGS="-fno-strict-aliasing -fPIC -Werror"
+        OSLDFLAGS="-lpthread -fPIC -fpie"
+        SRCS="
+                $SRCS
+                ../rtl/tsan_platform_linux.cc
+                ../../sanitizer_common/sanitizer_posix.cc
+                ../../sanitizer_common/sanitizer_posix_libcdep.cc
+                ../../sanitizer_common/sanitizer_procmaps_common.cc
+                ../../sanitizer_common/sanitizer_procmaps_freebsd.cc
+                ../../sanitizer_common/sanitizer_linux.cc
+                ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
+        "
+elif [ "`uname -a | grep Darwin`" != "" ]; then
+	SUFFIX="darwin_amd64"
+	OSCFLAGS="-fPIC -Wno-unused-const-variable -Wno-unknown-warning-option"
+	OSLDFLAGS="-lpthread -fPIC -fpie"
+	SRCS="
+		$SRCS
+		../rtl/tsan_platform_mac.cc
+		../../sanitizer_common/sanitizer_mac.cc
+		../../sanitizer_common/sanitizer_posix.cc
+		../../sanitizer_common/sanitizer_posix_libcdep.cc
+		../../sanitizer_common/sanitizer_procmaps_mac.cc
+	"
+elif [ "`uname -a | grep MINGW`" != "" ]; then
+	SUFFIX="windows_amd64"
+	OSCFLAGS="-Wno-error=attributes -Wno-attributes -Wno-unused-const-variable -Wno-unknown-warning-option"
+	OSLDFLAGS=""
+	SRCS="
+		$SRCS
+		../rtl/tsan_platform_windows.cc
+		../../sanitizer_common/sanitizer_win.cc
+	"
+else
+	echo Unknown platform
+	exit 1
+fi
+
+CC=${CC:-gcc}
+IN_TMPDIR=${IN_TMPDIR:-0}
+SILENT=${SILENT:-0}
+
+if [ $IN_TMPDIR != "0" ]; then
+  DIR=$(mktemp -qd /tmp/gotsan.XXXXXXXXXX)
+  cleanup() {
+    rm -rf $DIR
+  }
+  trap cleanup EXIT
+else
+  DIR=.
+fi
+
+SRCS="$SRCS $ADD_SRCS"
+
+rm -f $DIR/gotsan.cc
+for F in $SRCS; do
+	cat $F >> $DIR/gotsan.cc
+done
+
+FLAGS=" -I../rtl -I../.. -I../../sanitizer_common -I../../../include -std=c++11 -m64 -Wall -fno-exceptions -fno-rtti -DSANITIZER_GO -DSANITIZER_DEADLOCK_DETECTOR_VERSION=2 $OSCFLAGS"
+if [ "$DEBUG" = "" ]; then
+	FLAGS="$FLAGS -DSANITIZER_DEBUG=0 -O3 -msse3 -fomit-frame-pointer"
+else
+	FLAGS="$FLAGS -DSANITIZER_DEBUG=1 -g"
+fi
+
+if [ "$SILENT" != "1" ]; then
+  echo $CC gotsan.cc -c -o $DIR/race_$SUFFIX.syso $FLAGS $CFLAGS
+fi
+$CC $DIR/gotsan.cc -c -o $DIR/race_$SUFFIX.syso $FLAGS $CFLAGS
+
+$CC test.c $DIR/race_$SUFFIX.syso -m64 -o $DIR/test $OSLDFLAGS
+
+export GORACE="exitcode=0 atexit_sleep_ms=0"
+if [ "$SILENT" != "1" ]; then
+  $DIR/test
+else
+  $DIR/test 2>/dev/null
+fi
diff --git a/compiler-rt/lib/tsan/go/test.c b/compiler-rt/lib/tsan/go/test.c
new file mode 100644
index 0000000..94433f1
--- /dev/null
+++ b/compiler-rt/lib/tsan/go/test.c
@@ -0,0 +1,65 @@
+//===-- test.c ------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanity test for Go runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+void __tsan_init(void **thr, void (*cb)(void*));
+void __tsan_fini();
+void __tsan_map_shadow(void *addr, unsigned long size);
+void __tsan_go_start(void *thr, void **chthr, void *pc);
+void __tsan_go_end(void *thr);
+void __tsan_read(void *thr, void *addr, void *pc);
+void __tsan_write(void *thr, void *addr, void *pc);
+void __tsan_func_enter(void *thr, void *pc);
+void __tsan_func_exit(void *thr);
+void __tsan_malloc(void *p, unsigned long sz);
+void __tsan_acquire(void *thr, void *addr);
+void __tsan_release(void *thr, void *addr);
+void __tsan_release_merge(void *thr, void *addr);
+
+void symbolize_cb(void *ctx) {}
+
+char buf0[100<<10];
+
+void foobar() {}
+void barfoo() {}
+
+int main(void) {
+  void *thr0 = 0;
+  char *buf = (char*)((unsigned long)buf0 + (64<<10) - 1 & ~((64<<10) - 1));
+  __tsan_malloc(buf, 10);
+  __tsan_init(&thr0, symbolize_cb);
+  __tsan_map_shadow(buf, 4096);
+  __tsan_func_enter(thr0, (char*)&main + 1);
+  __tsan_malloc(buf, 10);
+  __tsan_release(thr0, buf);
+  __tsan_release_merge(thr0, buf);
+  void *thr1 = 0;
+  __tsan_go_start(thr0, &thr1, (char*)&barfoo + 1);
+  void *thr2 = 0;
+  __tsan_go_start(thr0, &thr2, (char*)&barfoo + 1);
+  __tsan_func_enter(thr1, (char*)&foobar + 1);
+  __tsan_func_enter(thr1, (char*)&foobar + 1);
+  __tsan_write(thr1, buf, (char*)&barfoo + 1);
+  __tsan_acquire(thr1, buf);
+  __tsan_func_exit(thr1);
+  __tsan_func_exit(thr1);
+  __tsan_go_end(thr1);
+  __tsan_func_enter(thr2, (char*)&foobar + 1);
+  __tsan_read(thr2, buf, (char*)&barfoo + 1);
+  __tsan_func_exit(thr2);
+  __tsan_go_end(thr2);
+  __tsan_func_exit(thr0);
+  __tsan_fini();
+  return 0;
+}
diff --git a/compiler-rt/lib/tsan/go/tsan_go.cc b/compiler-rt/lib/tsan/go/tsan_go.cc
new file mode 100644
index 0000000..ea0beb7
--- /dev/null
+++ b/compiler-rt/lib/tsan/go/tsan_go.cc
@@ -0,0 +1,211 @@
+//===-- tsan_go.cc --------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// ThreadSanitizer runtime for Go language.
+//
+//===----------------------------------------------------------------------===//
+
+#include "tsan_rtl.h"
+#include "tsan_symbolize.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include <stdlib.h>
+
+namespace __tsan {
+
+void InitializeInterceptors() {
+}
+
+void InitializeDynamicAnnotations() {
+}
+
+bool IsExpectedReport(uptr addr, uptr size) {
+  return false;
+}
+
+ReportLocation *SymbolizeData(uptr addr) {
+  return 0;
+}
+
+void *internal_alloc(MBlockType typ, uptr sz) {
+  return InternalAlloc(sz);
+}
+
+void internal_free(void *p) {
+  InternalFree(p);
+}
+
+struct SymbolizeContext {
+  uptr pc;
+  char *func;
+  char *file;
+  uptr line;
+  uptr off;
+  uptr res;
+};
+
+// Callback into Go.
+static void (*symbolize_cb)(SymbolizeContext *ctx);
+
+SymbolizedStack *SymbolizeCode(uptr addr) {
+  SymbolizedStack *s = SymbolizedStack::New(addr);
+  SymbolizeContext ctx;
+  internal_memset(&ctx, 0, sizeof(ctx));
+  ctx.pc = addr;
+  symbolize_cb(&ctx);
+  if (ctx.res) {
+    AddressInfo &info = s->info;
+    info.module_offset = ctx.off;
+    info.function = internal_strdup(ctx.func ? ctx.func : "??");
+    info.file = internal_strdup(ctx.file ? ctx.file : "-");
+    info.line = ctx.line;
+    info.column = 0;
+  }
+  return s;
+}
+
+extern "C" {
+
+static ThreadState *main_thr;
+static bool inited;
+
+static ThreadState *AllocGoroutine() {
+  ThreadState *thr = (ThreadState*)internal_alloc(MBlockThreadContex,
+      sizeof(ThreadState));
+  internal_memset(thr, 0, sizeof(*thr));
+  return thr;
+}
+
+void __tsan_init(ThreadState **thrp, void (*cb)(SymbolizeContext *cb)) {
+  symbolize_cb = cb;
+  ThreadState *thr = AllocGoroutine();
+  main_thr = *thrp = thr;
+  Initialize(thr);
+  inited = true;
+}
+
+void __tsan_fini() {
+  // FIXME: Not necessary thread 0.
+  ThreadState *thr = main_thr;
+  int res = Finalize(thr);
+  exit(res);
+}
+
+void __tsan_map_shadow(uptr addr, uptr size) {
+  MapShadow(addr, size);
+}
+
+void __tsan_read(ThreadState *thr, void *addr, void *pc) {
+  MemoryRead(thr, (uptr)pc, (uptr)addr, kSizeLog1);
+}
+
+void __tsan_read_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
+  if (callpc != 0)
+    FuncEntry(thr, callpc);
+  MemoryRead(thr, (uptr)pc, (uptr)addr, kSizeLog1);
+  if (callpc != 0)
+    FuncExit(thr);
+}
+
+void __tsan_write(ThreadState *thr, void *addr, void *pc) {
+  MemoryWrite(thr, (uptr)pc, (uptr)addr, kSizeLog1);
+}
+
+void __tsan_write_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
+  if (callpc != 0)
+    FuncEntry(thr, callpc);
+  MemoryWrite(thr, (uptr)pc, (uptr)addr, kSizeLog1);
+  if (callpc != 0)
+    FuncExit(thr);
+}
+
+void __tsan_read_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
+  MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, false);
+}
+
+void __tsan_write_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
+  MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, true);
+}
+
+void __tsan_func_enter(ThreadState *thr, void *pc) {
+  FuncEntry(thr, (uptr)pc);
+}
+
+void __tsan_func_exit(ThreadState *thr) {
+  FuncExit(thr);
+}
+
+void __tsan_malloc(void *p, uptr sz) {
+  if (!inited)
+    return;
+  MemoryResetRange(0, 0, (uptr)p, sz);
+}
+
+void __tsan_go_start(ThreadState *parent, ThreadState **pthr, void *pc) {
+  ThreadState *thr = AllocGoroutine();
+  *pthr = thr;
+  int goid = ThreadCreate(parent, (uptr)pc, 0, true);
+  ThreadStart(thr, goid, 0);
+}
+
+void __tsan_go_end(ThreadState *thr) {
+  ThreadFinish(thr);
+  internal_free(thr);
+}
+
+void __tsan_acquire(ThreadState *thr, void *addr) {
+  Acquire(thr, 0, (uptr)addr);
+}
+
+void __tsan_release(ThreadState *thr, void *addr) {
+  ReleaseStore(thr, 0, (uptr)addr);
+}
+
+void __tsan_release_merge(ThreadState *thr, void *addr) {
+  Release(thr, 0, (uptr)addr);
+}
+
+void __tsan_finalizer_goroutine(ThreadState *thr) {
+  AcquireGlobal(thr, 0);
+}
+
+void __tsan_mutex_before_lock(ThreadState *thr, uptr addr, uptr write) {
+}
+
+void __tsan_mutex_after_lock(ThreadState *thr, uptr addr, uptr write) {
+  if (write)
+    MutexLock(thr, 0, addr);
+  else
+    MutexReadLock(thr, 0, addr);
+}
+
+void __tsan_mutex_before_unlock(ThreadState *thr, uptr addr, uptr write) {
+  if (write)
+    MutexUnlock(thr, 0, addr);
+  else
+    MutexReadUnlock(thr, 0, addr);
+}
+
+void __tsan_go_ignore_sync_begin(ThreadState *thr) {
+  ThreadIgnoreSyncBegin(thr, 0);
+}
+
+void __tsan_go_ignore_sync_end(ThreadState *thr) {
+  ThreadIgnoreSyncEnd(thr, 0);
+}
+
+}  // extern "C"
+}  // namespace __tsan
+
+namespace __sanitizer {
+
+void SymbolizerPrepareForSandboxing() {
+  // Nothing to do here for Go.
+}
+
+}  // namespace __sanitizer
diff --git a/compiler-rt/lib/tsan/rtl/tsan.syms.extra b/compiler-rt/lib/tsan/rtl/tsan.syms.extra
new file mode 100644
index 0000000..1bc1d93
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan.syms.extra
@@ -0,0 +1,15 @@
+__tsan_init
+__tsan_read*
+__tsan_write*
+__tsan_vptr*
+__tsan_func*
+__tsan_atomic*
+__tsan_java*
+__tsan_unaligned*
+__tsan_release
+__tsan_acquire
+__ubsan_*
+Annotate*
+WTFAnnotate*
+RunningOnValgrind
+ValgrindSlowdown
diff --git a/compiler-rt/lib/tsan/rtl/tsan_clock.cc b/compiler-rt/lib/tsan/rtl/tsan_clock.cc
new file mode 100644
index 0000000..1e2050d
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_clock.cc
@@ -0,0 +1,427 @@
+//===-- tsan_clock.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_clock.h"
+#include "tsan_rtl.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+
+// SyncClock and ThreadClock implement vector clocks for sync variables
+// (mutexes, atomic variables, file descriptors, etc) and threads, respectively.
+// ThreadClock contains fixed-size vector clock for maximum number of threads.
+// SyncClock contains growable vector clock for currently necessary number of
+// threads.
+// Together they implement very simple model of operations, namely:
+//
+//   void ThreadClock::acquire(const SyncClock *src) {
+//     for (int i = 0; i < kMaxThreads; i++)
+//       clock[i] = max(clock[i], src->clock[i]);
+//   }
+//
+//   void ThreadClock::release(SyncClock *dst) const {
+//     for (int i = 0; i < kMaxThreads; i++)
+//       dst->clock[i] = max(dst->clock[i], clock[i]);
+//   }
+//
+//   void ThreadClock::ReleaseStore(SyncClock *dst) const {
+//     for (int i = 0; i < kMaxThreads; i++)
+//       dst->clock[i] = clock[i];
+//   }
+//
+//   void ThreadClock::acq_rel(SyncClock *dst) {
+//     acquire(dst);
+//     release(dst);
+//   }
+//
+// Conformance to this model is extensively verified in tsan_clock_test.cc.
+// However, the implementation is significantly more complex. The complexity
+// allows to implement important classes of use cases in O(1) instead of O(N).
+//
+// The use cases are:
+// 1. Singleton/once atomic that has a single release-store operation followed
+//    by zillions of acquire-loads (the acquire-load is O(1)).
+// 2. Thread-local mutex (both lock and unlock can be O(1)).
+// 3. Leaf mutex (unlock is O(1)).
+// 4. A mutex shared by 2 threads (both lock and unlock can be O(1)).
+// 5. An atomic with a single writer (writes can be O(1)).
+// The implementation dynamically adopts to workload. So if an atomic is in
+// read-only phase, these reads will be O(1); if it later switches to read/write
+// phase, the implementation will correctly handle that by switching to O(N).
+//
+// Thread-safety note: all const operations on SyncClock's are conducted under
+// a shared lock; all non-const operations on SyncClock's are conducted under
+// an exclusive lock; ThreadClock's are private to respective threads and so
+// do not need any protection.
+//
+// Description of ThreadClock state:
+// clk_ - fixed size vector clock.
+// nclk_ - effective size of the vector clock (the rest is zeros).
+// tid_ - index of the thread associated with he clock ("current thread").
+// last_acquire_ - current thread time when it acquired something from
+//   other threads.
+//
+// Description of SyncClock state:
+// clk_ - variable size vector clock, low kClkBits hold timestamp,
+//   the remaining bits hold "acquired" flag (the actual value is thread's
+//   reused counter);
+//   if acquried == thr->reused_, then the respective thread has already
+//   acquired this clock (except possibly dirty_tids_).
+// dirty_tids_ - holds up to two indeces in the vector clock that other threads
+//   need to acquire regardless of "acquired" flag value;
+// release_store_tid_ - denotes that the clock state is a result of
+//   release-store operation by the thread with release_store_tid_ index.
+// release_store_reused_ - reuse count of release_store_tid_.
+
+// We don't have ThreadState in these methods, so this is an ugly hack that
+// works only in C++.
+#ifndef SANITIZER_GO
+# define CPP_STAT_INC(typ) StatInc(cur_thread(), typ)
+#else
+# define CPP_STAT_INC(typ) (void)0
+#endif
+
+namespace __tsan {
+
+ThreadClock::ThreadClock(unsigned tid, unsigned reused)
+    : tid_(tid)
+    , reused_(reused + 1) {  // 0 has special meaning
+  CHECK_LT(tid, kMaxTidInClock);
+  CHECK_EQ(reused_, ((u64)reused_ << kClkBits) >> kClkBits);
+  nclk_ = tid_ + 1;
+  last_acquire_ = 0;
+  internal_memset(clk_, 0, sizeof(clk_));
+  clk_[tid_].reused = reused_;
+}
+
+void ThreadClock::acquire(ClockCache *c, const SyncClock *src) {
+  DCHECK_LE(nclk_, kMaxTid);
+  DCHECK_LE(src->size_, kMaxTid);
+  CPP_STAT_INC(StatClockAcquire);
+
+  // Check if it's empty -> no need to do anything.
+  const uptr nclk = src->size_;
+  if (nclk == 0) {
+    CPP_STAT_INC(StatClockAcquireEmpty);
+    return;
+  }
+
+  // Check if we've already acquired src after the last release operation on src
+  bool acquired = false;
+  if (nclk > tid_) {
+    CPP_STAT_INC(StatClockAcquireLarge);
+    if (src->elem(tid_).reused == reused_) {
+      CPP_STAT_INC(StatClockAcquireRepeat);
+      for (unsigned i = 0; i < kDirtyTids; i++) {
+        unsigned tid = src->dirty_tids_[i];
+        if (tid != kInvalidTid) {
+          u64 epoch = src->elem(tid).epoch;
+          if (clk_[tid].epoch < epoch) {
+            clk_[tid].epoch = epoch;
+            acquired = true;
+          }
+        }
+      }
+      if (acquired) {
+        CPP_STAT_INC(StatClockAcquiredSomething);
+        last_acquire_ = clk_[tid_].epoch;
+      }
+      return;
+    }
+  }
+
+  // O(N) acquire.
+  CPP_STAT_INC(StatClockAcquireFull);
+  nclk_ = max(nclk_, nclk);
+  for (uptr i = 0; i < nclk; i++) {
+    u64 epoch = src->elem(i).epoch;
+    if (clk_[i].epoch < epoch) {
+      clk_[i].epoch = epoch;
+      acquired = true;
+    }
+  }
+
+  // Remember that this thread has acquired this clock.
+  if (nclk > tid_)
+    src->elem(tid_).reused = reused_;
+
+  if (acquired) {
+    CPP_STAT_INC(StatClockAcquiredSomething);
+    last_acquire_ = clk_[tid_].epoch;
+  }
+}
+
+void ThreadClock::release(ClockCache *c, SyncClock *dst) const {
+  DCHECK_LE(nclk_, kMaxTid);
+  DCHECK_LE(dst->size_, kMaxTid);
+
+  if (dst->size_ == 0) {
+    // ReleaseStore will correctly set release_store_tid_,
+    // which can be important for future operations.
+    ReleaseStore(c, dst);
+    return;
+  }
+
+  CPP_STAT_INC(StatClockRelease);
+  // Check if we need to resize dst.
+  if (dst->size_ < nclk_)
+    dst->Resize(c, nclk_);
+
+  // Check if we had not acquired anything from other threads
+  // since the last release on dst. If so, we need to update
+  // only dst->elem(tid_).
+  if (dst->elem(tid_).epoch > last_acquire_) {
+    UpdateCurrentThread(dst);
+    if (dst->release_store_tid_ != tid_ ||
+        dst->release_store_reused_ != reused_)
+      dst->release_store_tid_ = kInvalidTid;
+    return;
+  }
+
+  // O(N) release.
+  CPP_STAT_INC(StatClockReleaseFull);
+  // First, remember whether we've acquired dst.
+  bool acquired = IsAlreadyAcquired(dst);
+  if (acquired)
+    CPP_STAT_INC(StatClockReleaseAcquired);
+  // Update dst->clk_.
+  for (uptr i = 0; i < nclk_; i++) {
+    ClockElem &ce = dst->elem(i);
+    ce.epoch = max(ce.epoch, clk_[i].epoch);
+    ce.reused = 0;
+  }
+  // Clear 'acquired' flag in the remaining elements.
+  if (nclk_ < dst->size_)
+    CPP_STAT_INC(StatClockReleaseClearTail);
+  for (uptr i = nclk_; i < dst->size_; i++)
+    dst->elem(i).reused = 0;
+  for (unsigned i = 0; i < kDirtyTids; i++)
+    dst->dirty_tids_[i] = kInvalidTid;
+  dst->release_store_tid_ = kInvalidTid;
+  dst->release_store_reused_ = 0;
+  // If we've acquired dst, remember this fact,
+  // so that we don't need to acquire it on next acquire.
+  if (acquired)
+    dst->elem(tid_).reused = reused_;
+}
+
+void ThreadClock::ReleaseStore(ClockCache *c, SyncClock *dst) const {
+  DCHECK_LE(nclk_, kMaxTid);
+  DCHECK_LE(dst->size_, kMaxTid);
+  CPP_STAT_INC(StatClockStore);
+
+  // Check if we need to resize dst.
+  if (dst->size_ < nclk_)
+    dst->Resize(c, nclk_);
+
+  if (dst->release_store_tid_ == tid_ &&
+      dst->release_store_reused_ == reused_ &&
+      dst->elem(tid_).epoch > last_acquire_) {
+    CPP_STAT_INC(StatClockStoreFast);
+    UpdateCurrentThread(dst);
+    return;
+  }
+
+  // O(N) release-store.
+  CPP_STAT_INC(StatClockStoreFull);
+  for (uptr i = 0; i < nclk_; i++) {
+    ClockElem &ce = dst->elem(i);
+    ce.epoch = clk_[i].epoch;
+    ce.reused = 0;
+  }
+  // Clear the tail of dst->clk_.
+  if (nclk_ < dst->size_) {
+    for (uptr i = nclk_; i < dst->size_; i++) {
+      ClockElem &ce = dst->elem(i);
+      ce.epoch = 0;
+      ce.reused = 0;
+    }
+    CPP_STAT_INC(StatClockStoreTail);
+  }
+  for (unsigned i = 0; i < kDirtyTids; i++)
+    dst->dirty_tids_[i] = kInvalidTid;
+  dst->release_store_tid_ = tid_;
+  dst->release_store_reused_ = reused_;
+  // Rememeber that we don't need to acquire it in future.
+  dst->elem(tid_).reused = reused_;
+}
+
+void ThreadClock::acq_rel(ClockCache *c, SyncClock *dst) {
+  CPP_STAT_INC(StatClockAcquireRelease);
+  acquire(c, dst);
+  ReleaseStore(c, dst);
+}
+
+// Updates only single element related to the current thread in dst->clk_.
+void ThreadClock::UpdateCurrentThread(SyncClock *dst) const {
+  // Update the threads time, but preserve 'acquired' flag.
+  dst->elem(tid_).epoch = clk_[tid_].epoch;
+
+  for (unsigned i = 0; i < kDirtyTids; i++) {
+    if (dst->dirty_tids_[i] == tid_) {
+      CPP_STAT_INC(StatClockReleaseFast1);
+      return;
+    }
+    if (dst->dirty_tids_[i] == kInvalidTid) {
+      CPP_STAT_INC(StatClockReleaseFast2);
+      dst->dirty_tids_[i] = tid_;
+      return;
+    }
+  }
+  // Reset all 'acquired' flags, O(N).
+  CPP_STAT_INC(StatClockReleaseSlow);
+  for (uptr i = 0; i < dst->size_; i++)
+    dst->elem(i).reused = 0;
+  for (unsigned i = 0; i < kDirtyTids; i++)
+    dst->dirty_tids_[i] = kInvalidTid;
+}
+
+// Checks whether the current threads has already acquired src.
+bool ThreadClock::IsAlreadyAcquired(const SyncClock *src) const {
+  if (src->elem(tid_).reused != reused_)
+    return false;
+  for (unsigned i = 0; i < kDirtyTids; i++) {
+    unsigned tid = src->dirty_tids_[i];
+    if (tid != kInvalidTid) {
+      if (clk_[tid].epoch < src->elem(tid).epoch)
+        return false;
+    }
+  }
+  return true;
+}
+
+void SyncClock::Resize(ClockCache *c, uptr nclk) {
+  CPP_STAT_INC(StatClockReleaseResize);
+  if (RoundUpTo(nclk, ClockBlock::kClockCount) <=
+      RoundUpTo(size_, ClockBlock::kClockCount)) {
+    // Growing within the same block.
+    // Memory is already allocated, just increase the size.
+    size_ = nclk;
+    return;
+  }
+  if (nclk <= ClockBlock::kClockCount) {
+    // Grow from 0 to one-level table.
+    CHECK_EQ(size_, 0);
+    CHECK_EQ(tab_, 0);
+    CHECK_EQ(tab_idx_, 0);
+    size_ = nclk;
+    tab_idx_ = ctx->clock_alloc.Alloc(c);
+    tab_ = ctx->clock_alloc.Map(tab_idx_);
+    internal_memset(tab_, 0, sizeof(*tab_));
+    return;
+  }
+  // Growing two-level table.
+  if (size_ == 0) {
+    // Allocate first level table.
+    tab_idx_ = ctx->clock_alloc.Alloc(c);
+    tab_ = ctx->clock_alloc.Map(tab_idx_);
+    internal_memset(tab_, 0, sizeof(*tab_));
+  } else if (size_ <= ClockBlock::kClockCount) {
+    // Transform one-level table to two-level table.
+    u32 old = tab_idx_;
+    tab_idx_ = ctx->clock_alloc.Alloc(c);
+    tab_ = ctx->clock_alloc.Map(tab_idx_);
+    internal_memset(tab_, 0, sizeof(*tab_));
+    tab_->table[0] = old;
+  }
+  // At this point we have first level table allocated.
+  // Add second level tables as necessary.
+  for (uptr i = RoundUpTo(size_, ClockBlock::kClockCount);
+      i < nclk; i += ClockBlock::kClockCount) {
+    u32 idx = ctx->clock_alloc.Alloc(c);
+    ClockBlock *cb = ctx->clock_alloc.Map(idx);
+    internal_memset(cb, 0, sizeof(*cb));
+    CHECK_EQ(tab_->table[i/ClockBlock::kClockCount], 0);
+    tab_->table[i/ClockBlock::kClockCount] = idx;
+  }
+  size_ = nclk;
+}
+
+// Sets a single element in the vector clock.
+// This function is called only from weird places like AcquireGlobal.
+void ThreadClock::set(unsigned tid, u64 v) {
+  DCHECK_LT(tid, kMaxTid);
+  DCHECK_GE(v, clk_[tid].epoch);
+  clk_[tid].epoch = v;
+  if (nclk_ <= tid)
+    nclk_ = tid + 1;
+  last_acquire_ = clk_[tid_].epoch;
+}
+
+void ThreadClock::DebugDump(int(*printf)(const char *s, ...)) {
+  printf("clock=[");
+  for (uptr i = 0; i < nclk_; i++)
+    printf("%s%llu", i == 0 ? "" : ",", clk_[i].epoch);
+  printf("] reused=[");
+  for (uptr i = 0; i < nclk_; i++)
+    printf("%s%llu", i == 0 ? "" : ",", clk_[i].reused);
+  printf("] tid=%u/%u last_acq=%llu",
+      tid_, reused_, last_acquire_);
+}
+
+SyncClock::SyncClock()
+    : release_store_tid_(kInvalidTid)
+    , release_store_reused_()
+    , tab_()
+    , tab_idx_()
+    , size_() {
+  for (uptr i = 0; i < kDirtyTids; i++)
+    dirty_tids_[i] = kInvalidTid;
+}
+
+SyncClock::~SyncClock() {
+  // Reset must be called before dtor.
+  CHECK_EQ(size_, 0);
+  CHECK_EQ(tab_, 0);
+  CHECK_EQ(tab_idx_, 0);
+}
+
+void SyncClock::Reset(ClockCache *c) {
+  if (size_ == 0) {
+    // nothing
+  } else if (size_ <= ClockBlock::kClockCount) {
+    // One-level table.
+    ctx->clock_alloc.Free(c, tab_idx_);
+  } else {
+    // Two-level table.
+    for (uptr i = 0; i < size_; i += ClockBlock::kClockCount)
+      ctx->clock_alloc.Free(c, tab_->table[i / ClockBlock::kClockCount]);
+    ctx->clock_alloc.Free(c, tab_idx_);
+  }
+  tab_ = 0;
+  tab_idx_ = 0;
+  size_ = 0;
+  release_store_tid_ = kInvalidTid;
+  release_store_reused_ = 0;
+  for (uptr i = 0; i < kDirtyTids; i++)
+    dirty_tids_[i] = kInvalidTid;
+}
+
+ClockElem &SyncClock::elem(unsigned tid) const {
+  DCHECK_LT(tid, size_);
+  if (size_ <= ClockBlock::kClockCount)
+    return tab_->clock[tid];
+  u32 idx = tab_->table[tid / ClockBlock::kClockCount];
+  ClockBlock *cb = ctx->clock_alloc.Map(idx);
+  return cb->clock[tid % ClockBlock::kClockCount];
+}
+
+void SyncClock::DebugDump(int(*printf)(const char *s, ...)) {
+  printf("clock=[");
+  for (uptr i = 0; i < size_; i++)
+    printf("%s%llu", i == 0 ? "" : ",", elem(i).epoch);
+  printf("] reused=[");
+  for (uptr i = 0; i < size_; i++)
+    printf("%s%llu", i == 0 ? "" : ",", elem(i).reused);
+  printf("] release_store_tid=%d/%d dirty_tids=%d/%d",
+      release_store_tid_, release_store_reused_,
+      dirty_tids_[0], dirty_tids_[1]);
+}
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_clock.h b/compiler-rt/lib/tsan/rtl/tsan_clock.h
new file mode 100644
index 0000000..4e352cb
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_clock.h
@@ -0,0 +1,129 @@
+//===-- tsan_clock.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_CLOCK_H
+#define TSAN_CLOCK_H
+
+#include "tsan_defs.h"
+#include "tsan_dense_alloc.h"
+
+namespace __tsan {
+
+struct ClockElem {
+  u64 epoch  : kClkBits;
+  u64 reused : 64 - kClkBits;
+};
+
+struct ClockBlock {
+  static const uptr kSize = 512;
+  static const uptr kTableSize = kSize / sizeof(u32);
+  static const uptr kClockCount = kSize / sizeof(ClockElem);
+
+  union {
+    u32       table[kTableSize];
+    ClockElem clock[kClockCount];
+  };
+
+  ClockBlock() {
+  }
+};
+
+typedef DenseSlabAlloc<ClockBlock, 1<<16, 1<<10> ClockAlloc;
+typedef DenseSlabAllocCache ClockCache;
+
+// The clock that lives in sync variables (mutexes, atomics, etc).
+class SyncClock {
+ public:
+  SyncClock();
+  ~SyncClock();
+
+  uptr size() const {
+    return size_;
+  }
+
+  u64 get(unsigned tid) const {
+    return elem(tid).epoch;
+  }
+
+  void Resize(ClockCache *c, uptr nclk);
+  void Reset(ClockCache *c);
+
+  void DebugDump(int(*printf)(const char *s, ...));
+
+ private:
+  friend struct ThreadClock;
+  static const uptr kDirtyTids = 2;
+
+  unsigned release_store_tid_;
+  unsigned release_store_reused_;
+  unsigned dirty_tids_[kDirtyTids];
+  // tab_ contains indirect pointer to a 512b block using DenseSlabAlloc.
+  // If size_ <= 64, then tab_ points to an array with 64 ClockElem's.
+  // Otherwise, tab_ points to an array with 128 u32 elements,
+  // each pointing to the second-level 512b block with 64 ClockElem's.
+  ClockBlock *tab_;
+  u32 tab_idx_;
+  u32 size_;
+
+  ClockElem &elem(unsigned tid) const;
+};
+
+// The clock that lives in threads.
+struct ThreadClock {
+ public:
+  typedef DenseSlabAllocCache Cache;
+
+  explicit ThreadClock(unsigned tid, unsigned reused = 0);
+
+  u64 get(unsigned tid) const {
+    DCHECK_LT(tid, kMaxTidInClock);
+    return clk_[tid].epoch;
+  }
+
+  void set(unsigned tid, u64 v);
+
+  void set(u64 v) {
+    DCHECK_GE(v, clk_[tid_].epoch);
+    clk_[tid_].epoch = v;
+  }
+
+  void tick() {
+    clk_[tid_].epoch++;
+  }
+
+  uptr size() const {
+    return nclk_;
+  }
+
+  void acquire(ClockCache *c, const SyncClock *src);
+  void release(ClockCache *c, SyncClock *dst) const;
+  void acq_rel(ClockCache *c, SyncClock *dst);
+  void ReleaseStore(ClockCache *c, SyncClock *dst) const;
+
+  void DebugReset();
+  void DebugDump(int(*printf)(const char *s, ...));
+
+ private:
+  static const uptr kDirtyTids = SyncClock::kDirtyTids;
+  const unsigned tid_;
+  const unsigned reused_;
+  u64 last_acquire_;
+  uptr nclk_;
+  ClockElem clk_[kMaxTidInClock];
+
+  bool IsAlreadyAcquired(const SyncClock *src) const;
+  void UpdateCurrentThread(SyncClock *dst) const;
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_CLOCK_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_defs.h b/compiler-rt/lib/tsan/rtl/tsan_defs.h
new file mode 100644
index 0000000..9c7b329
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_defs.h
@@ -0,0 +1,166 @@
+//===-- tsan_defs.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAN_DEFS_H
+#define TSAN_DEFS_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "tsan_stat.h"
+#include "ubsan/ubsan_platform.h"
+
+// Setup defaults for compile definitions.
+#ifndef TSAN_NO_HISTORY
+# define TSAN_NO_HISTORY 0
+#endif
+
+#ifndef TSAN_COLLECT_STATS
+# define TSAN_COLLECT_STATS 0
+#endif
+
+#ifndef TSAN_CONTAINS_UBSAN
+# define TSAN_CONTAINS_UBSAN (CAN_SANITIZE_UB && !defined(SANITIZER_GO))
+#endif
+
+namespace __tsan {
+
+#ifdef SANITIZER_GO
+const bool kGoMode = true;
+const bool kCppMode = false;
+const char *const kTsanOptionsEnv = "GORACE";
+#else
+const bool kGoMode = false;
+const bool kCppMode = true;
+const char *const kTsanOptionsEnv = "TSAN_OPTIONS";
+#endif
+
+const int kTidBits = 13;
+const unsigned kMaxTid = 1 << kTidBits;
+#ifndef SANITIZER_GO
+const unsigned kMaxTidInClock = kMaxTid * 2;  // This includes msb 'freed' bit.
+#else
+const unsigned kMaxTidInClock = kMaxTid;  // Go does not track freed memory.
+#endif
+const int kClkBits = 42;
+const unsigned kMaxTidReuse = (1 << (64 - kClkBits)) - 1;
+const uptr kShadowStackSize = 64 * 1024;
+
+// Count of shadow values in a shadow cell.
+const uptr kShadowCnt = 4;
+
+// That many user bytes are mapped onto a single shadow cell.
+const uptr kShadowCell = 8;
+
+// Size of a single shadow value (u64).
+const uptr kShadowSize = 8;
+
+// Shadow memory is kShadowMultiplier times larger than user memory.
+const uptr kShadowMultiplier = kShadowSize * kShadowCnt / kShadowCell;
+
+// That many user bytes are mapped onto a single meta shadow cell.
+// Must be less or equal to minimal memory allocator alignment.
+const uptr kMetaShadowCell = 8;
+
+// Size of a single meta shadow value (u32).
+const uptr kMetaShadowSize = 4;
+
+#if TSAN_NO_HISTORY
+const bool kCollectHistory = false;
+#else
+const bool kCollectHistory = true;
+#endif
+
+const unsigned kInvalidTid = (unsigned)-1;
+
+// The following "build consistency" machinery ensures that all source files
+// are built in the same configuration. Inconsistent builds lead to
+// hard to debug crashes.
+#if SANITIZER_DEBUG
+void build_consistency_debug();
+#else
+void build_consistency_release();
+#endif
+
+#if TSAN_COLLECT_STATS
+void build_consistency_stats();
+#else
+void build_consistency_nostats();
+#endif
+
+static inline void USED build_consistency() {
+#if SANITIZER_DEBUG
+  build_consistency_debug();
+#else
+  build_consistency_release();
+#endif
+#if TSAN_COLLECT_STATS
+  build_consistency_stats();
+#else
+  build_consistency_nostats();
+#endif
+}
+
+template<typename T>
+T min(T a, T b) {
+  return a < b ? a : b;
+}
+
+template<typename T>
+T max(T a, T b) {
+  return a > b ? a : b;
+}
+
+template<typename T>
+T RoundUp(T p, u64 align) {
+  DCHECK_EQ(align & (align - 1), 0);
+  return (T)(((u64)p + align - 1) & ~(align - 1));
+}
+
+template<typename T>
+T RoundDown(T p, u64 align) {
+  DCHECK_EQ(align & (align - 1), 0);
+  return (T)((u64)p & ~(align - 1));
+}
+
+// Zeroizes high part, returns 'bits' lsb bits.
+template<typename T>
+T GetLsb(T v, int bits) {
+  return (T)((u64)v & ((1ull << bits) - 1));
+}
+
+struct MD5Hash {
+  u64 hash[2];
+  bool operator==(const MD5Hash &other) const;
+};
+
+MD5Hash md5_hash(const void *data, uptr size);
+
+struct ThreadState;
+class ThreadContext;
+struct Context;
+struct ReportStack;
+class ReportDesc;
+class RegionAlloc;
+
+// Descriptor of user's memory block.
+struct MBlock {
+  u64  siz;
+  u32  stk;
+  u16  tid;
+};
+
+COMPILER_CHECK(sizeof(MBlock) == 16);
+
+}  // namespace __tsan
+
+#endif  // TSAN_DEFS_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_dense_alloc.h b/compiler-rt/lib/tsan/rtl/tsan_dense_alloc.h
new file mode 100644
index 0000000..e9815c9
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_dense_alloc.h
@@ -0,0 +1,137 @@
+//===-- tsan_dense_alloc.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// A DenseSlabAlloc is a freelist-based allocator of fixed-size objects.
+// DenseSlabAllocCache is a thread-local cache for DenseSlabAlloc.
+// The only difference with traditional slab allocators is that DenseSlabAlloc
+// allocates/free indices of objects and provide a functionality to map
+// the index onto the real pointer. The index is u32, that is, 2 times smaller
+// than uptr (hense the Dense prefix).
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_DENSE_ALLOC_H
+#define TSAN_DENSE_ALLOC_H
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "tsan_defs.h"
+#include "tsan_mutex.h"
+
+namespace __tsan {
+
+class DenseSlabAllocCache {
+  static const uptr kSize = 128;
+  typedef u32 IndexT;
+  uptr pos;
+  IndexT cache[kSize];
+  template<typename T, uptr kL1Size, uptr kL2Size> friend class DenseSlabAlloc;
+};
+
+template<typename T, uptr kL1Size, uptr kL2Size>
+class DenseSlabAlloc {
+ public:
+  typedef DenseSlabAllocCache Cache;
+  typedef typename Cache::IndexT IndexT;
+
+  DenseSlabAlloc() {
+    // Check that kL1Size and kL2Size are sane.
+    CHECK_EQ(kL1Size & (kL1Size - 1), 0);
+    CHECK_EQ(kL2Size & (kL2Size - 1), 0);
+    CHECK_GE(1ull << (sizeof(IndexT) * 8), kL1Size * kL2Size);
+    // Check that it makes sense to use the dense alloc.
+    CHECK_GE(sizeof(T), sizeof(IndexT));
+    internal_memset(map_, 0, sizeof(map_));
+    freelist_ = 0;
+    fillpos_ = 0;
+  }
+
+  ~DenseSlabAlloc() {
+    for (uptr i = 0; i < kL1Size; i++) {
+      if (map_[i] != 0)
+        UnmapOrDie(map_[i], kL2Size * sizeof(T));
+    }
+  }
+
+  IndexT Alloc(Cache *c) {
+    if (c->pos == 0)
+      Refill(c);
+    return c->cache[--c->pos];
+  }
+
+  void Free(Cache *c, IndexT idx) {
+    DCHECK_NE(idx, 0);
+    if (c->pos == Cache::kSize)
+      Drain(c);
+    c->cache[c->pos++] = idx;
+  }
+
+  T *Map(IndexT idx) {
+    DCHECK_NE(idx, 0);
+    DCHECK_LE(idx, kL1Size * kL2Size);
+    return &map_[idx / kL2Size][idx % kL2Size];
+  }
+
+  void FlushCache(Cache *c) {
+    SpinMutexLock lock(&mtx_);
+    while (c->pos) {
+      IndexT idx = c->cache[--c->pos];
+      *(IndexT*)Map(idx) = freelist_;
+      freelist_ = idx;
+    }
+  }
+
+  void InitCache(Cache *c) {
+    c->pos = 0;
+    internal_memset(c->cache, 0, sizeof(c->cache));
+  }
+
+ private:
+  T *map_[kL1Size];
+  SpinMutex mtx_;
+  IndexT freelist_;
+  uptr fillpos_;
+
+  void Refill(Cache *c) {
+    SpinMutexLock lock(&mtx_);
+    if (freelist_ == 0) {
+      if (fillpos_ == kL1Size) {
+        Printf("ThreadSanitizer: DenseSlabAllocator overflow. Dying.\n");
+        Die();
+      }
+      T *batch = (T*)MmapOrDie(kL2Size * sizeof(T), "DenseSlabAllocator");
+      // Reserve 0 as invalid index.
+      IndexT start = fillpos_ == 0 ? 1 : 0;
+      for (IndexT i = start; i < kL2Size; i++) {
+        new(batch + i) T;
+        *(IndexT*)(batch + i) = i + 1 + fillpos_ * kL2Size;
+      }
+      *(IndexT*)(batch + kL2Size - 1) = 0;
+      freelist_ = fillpos_ * kL2Size + start;
+      map_[fillpos_++] = batch;
+    }
+    for (uptr i = 0; i < Cache::kSize / 2 && freelist_ != 0; i++) {
+      IndexT idx = freelist_;
+      c->cache[c->pos++] = idx;
+      freelist_ = *(IndexT*)Map(idx);
+    }
+  }
+
+  void Drain(Cache *c) {
+    SpinMutexLock lock(&mtx_);
+    for (uptr i = 0; i < Cache::kSize / 2; i++) {
+      IndexT idx = c->cache[--c->pos];
+      *(IndexT*)Map(idx) = freelist_;
+      freelist_ = idx;
+    }
+  }
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_DENSE_ALLOC_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_fd.cc b/compiler-rt/lib/tsan/rtl/tsan_fd.cc
new file mode 100644
index 0000000..d84df4a
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_fd.cc
@@ -0,0 +1,316 @@
+//===-- tsan_fd.cc --------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "tsan_fd.h"
+#include "tsan_rtl.h"
+#include <sanitizer_common/sanitizer_atomic.h>
+
+namespace __tsan {
+
+const int kTableSizeL1 = 1024;
+const int kTableSizeL2 = 1024;
+const int kTableSize = kTableSizeL1 * kTableSizeL2;
+
+struct FdSync {
+  atomic_uint64_t rc;
+};
+
+struct FdDesc {
+  FdSync *sync;
+  int creation_tid;
+  u32 creation_stack;
+};
+
+struct FdContext {
+  atomic_uintptr_t tab[kTableSizeL1];
+  // Addresses used for synchronization.
+  FdSync globsync;
+  FdSync filesync;
+  FdSync socksync;
+  u64 connectsync;
+};
+
+static FdContext fdctx;
+
+static bool bogusfd(int fd) {
+  // Apparently a bogus fd value.
+  return fd < 0 || fd >= kTableSize;
+}
+
+static FdSync *allocsync(ThreadState *thr, uptr pc) {
+  FdSync *s = (FdSync*)user_alloc(thr, pc, sizeof(FdSync), kDefaultAlignment,
+      false);
+  atomic_store(&s->rc, 1, memory_order_relaxed);
+  return s;
+}
+
+static FdSync *ref(FdSync *s) {
+  if (s && atomic_load(&s->rc, memory_order_relaxed) != (u64)-1)
+    atomic_fetch_add(&s->rc, 1, memory_order_relaxed);
+  return s;
+}
+
+static void unref(ThreadState *thr, uptr pc, FdSync *s) {
+  if (s && atomic_load(&s->rc, memory_order_relaxed) != (u64)-1) {
+    if (atomic_fetch_sub(&s->rc, 1, memory_order_acq_rel) == 1) {
+      CHECK_NE(s, &fdctx.globsync);
+      CHECK_NE(s, &fdctx.filesync);
+      CHECK_NE(s, &fdctx.socksync);
+      user_free(thr, pc, s, false);
+    }
+  }
+}
+
+static FdDesc *fddesc(ThreadState *thr, uptr pc, int fd) {
+  CHECK_GE(fd, 0);
+  CHECK_LT(fd, kTableSize);
+  atomic_uintptr_t *pl1 = &fdctx.tab[fd / kTableSizeL2];
+  uptr l1 = atomic_load(pl1, memory_order_consume);
+  if (l1 == 0) {
+    uptr size = kTableSizeL2 * sizeof(FdDesc);
+    // We need this to reside in user memory to properly catch races on it.
+    void *p = user_alloc(thr, pc, size, kDefaultAlignment, false);
+    internal_memset(p, 0, size);
+    MemoryResetRange(thr, (uptr)&fddesc, (uptr)p, size);
+    if (atomic_compare_exchange_strong(pl1, &l1, (uptr)p, memory_order_acq_rel))
+      l1 = (uptr)p;
+    else
+      user_free(thr, pc, p, false);
+  }
+  return &((FdDesc*)l1)[fd % kTableSizeL2];  // NOLINT
+}
+
+// pd must be already ref'ed.
+static void init(ThreadState *thr, uptr pc, int fd, FdSync *s,
+    bool write = true) {
+  FdDesc *d = fddesc(thr, pc, fd);
+  // As a matter of fact, we don't intercept all close calls.
+  // See e.g. libc __res_iclose().
+  if (d->sync) {
+    unref(thr, pc, d->sync);
+    d->sync = 0;
+  }
+  if (flags()->io_sync == 0) {
+    unref(thr, pc, s);
+  } else if (flags()->io_sync == 1) {
+    d->sync = s;
+  } else if (flags()->io_sync == 2) {
+    unref(thr, pc, s);
+    d->sync = &fdctx.globsync;
+  }
+  d->creation_tid = thr->tid;
+  d->creation_stack = CurrentStackId(thr, pc);
+  if (write) {
+    // To catch races between fd usage and open.
+    MemoryRangeImitateWrite(thr, pc, (uptr)d, 8);
+  } else {
+    // See the dup-related comment in FdClose.
+    MemoryRead(thr, pc, (uptr)d, kSizeLog8);
+  }
+}
+
+void FdInit() {
+  atomic_store(&fdctx.globsync.rc, (u64)-1, memory_order_relaxed);
+  atomic_store(&fdctx.filesync.rc, (u64)-1, memory_order_relaxed);
+  atomic_store(&fdctx.socksync.rc, (u64)-1, memory_order_relaxed);
+}
+
+void FdOnFork(ThreadState *thr, uptr pc) {
+  // On fork() we need to reset all fd's, because the child is going
+  // close all them, and that will cause races between previous read/write
+  // and the close.
+  for (int l1 = 0; l1 < kTableSizeL1; l1++) {
+    FdDesc *tab = (FdDesc*)atomic_load(&fdctx.tab[l1], memory_order_relaxed);
+    if (tab == 0)
+      break;
+    for (int l2 = 0; l2 < kTableSizeL2; l2++) {
+      FdDesc *d = &tab[l2];
+      MemoryResetRange(thr, pc, (uptr)d, 8);
+    }
+  }
+}
+
+bool FdLocation(uptr addr, int *fd, int *tid, u32 *stack) {
+  for (int l1 = 0; l1 < kTableSizeL1; l1++) {
+    FdDesc *tab = (FdDesc*)atomic_load(&fdctx.tab[l1], memory_order_relaxed);
+    if (tab == 0)
+      break;
+    if (addr >= (uptr)tab && addr < (uptr)(tab + kTableSizeL2)) {
+      int l2 = (addr - (uptr)tab) / sizeof(FdDesc);
+      FdDesc *d = &tab[l2];
+      *fd = l1 * kTableSizeL1 + l2;
+      *tid = d->creation_tid;
+      *stack = d->creation_stack;
+      return true;
+    }
+  }
+  return false;
+}
+
+void FdAcquire(ThreadState *thr, uptr pc, int fd) {
+  if (bogusfd(fd))
+    return;
+  FdDesc *d = fddesc(thr, pc, fd);
+  FdSync *s = d->sync;
+  DPrintf("#%d: FdAcquire(%d) -> %p\n", thr->tid, fd, s);
+  MemoryRead(thr, pc, (uptr)d, kSizeLog8);
+  if (s)
+    Acquire(thr, pc, (uptr)s);
+}
+
+void FdRelease(ThreadState *thr, uptr pc, int fd) {
+  if (bogusfd(fd))
+    return;
+  FdDesc *d = fddesc(thr, pc, fd);
+  FdSync *s = d->sync;
+  DPrintf("#%d: FdRelease(%d) -> %p\n", thr->tid, fd, s);
+  MemoryRead(thr, pc, (uptr)d, kSizeLog8);
+  if (s)
+    Release(thr, pc, (uptr)s);
+}
+
+void FdAccess(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdAccess(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  FdDesc *d = fddesc(thr, pc, fd);
+  MemoryRead(thr, pc, (uptr)d, kSizeLog8);
+}
+
+void FdClose(ThreadState *thr, uptr pc, int fd, bool write) {
+  DPrintf("#%d: FdClose(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  FdDesc *d = fddesc(thr, pc, fd);
+  if (write) {
+    // To catch races between fd usage and close.
+    MemoryWrite(thr, pc, (uptr)d, kSizeLog8);
+  } else {
+    // This path is used only by dup2/dup3 calls.
+    // We do read instead of write because there is a number of legitimate
+    // cases where write would lead to false positives:
+    // 1. Some software dups a closed pipe in place of a socket before closing
+    //    the socket (to prevent races actually).
+    // 2. Some daemons dup /dev/null in place of stdin/stdout.
+    // On the other hand we have not seen cases when write here catches real
+    // bugs.
+    MemoryRead(thr, pc, (uptr)d, kSizeLog8);
+  }
+  // We need to clear it, because if we do not intercept any call out there
+  // that creates fd, we will hit false postives.
+  MemoryResetRange(thr, pc, (uptr)d, 8);
+  unref(thr, pc, d->sync);
+  d->sync = 0;
+  d->creation_tid = 0;
+  d->creation_stack = 0;
+}
+
+void FdFileCreate(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdFileCreate(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  init(thr, pc, fd, &fdctx.filesync);
+}
+
+void FdDup(ThreadState *thr, uptr pc, int oldfd, int newfd, bool write) {
+  DPrintf("#%d: FdDup(%d, %d)\n", thr->tid, oldfd, newfd);
+  if (bogusfd(oldfd) || bogusfd(newfd))
+    return;
+  // Ignore the case when user dups not yet connected socket.
+  FdDesc *od = fddesc(thr, pc, oldfd);
+  MemoryRead(thr, pc, (uptr)od, kSizeLog8);
+  FdClose(thr, pc, newfd, write);
+  init(thr, pc, newfd, ref(od->sync), write);
+}
+
+void FdPipeCreate(ThreadState *thr, uptr pc, int rfd, int wfd) {
+  DPrintf("#%d: FdCreatePipe(%d, %d)\n", thr->tid, rfd, wfd);
+  FdSync *s = allocsync(thr, pc);
+  init(thr, pc, rfd, ref(s));
+  init(thr, pc, wfd, ref(s));
+  unref(thr, pc, s);
+}
+
+void FdEventCreate(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdEventCreate(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  init(thr, pc, fd, allocsync(thr, pc));
+}
+
+void FdSignalCreate(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdSignalCreate(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  init(thr, pc, fd, 0);
+}
+
+void FdInotifyCreate(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdInotifyCreate(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  init(thr, pc, fd, 0);
+}
+
+void FdPollCreate(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdPollCreate(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  init(thr, pc, fd, allocsync(thr, pc));
+}
+
+void FdSocketCreate(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdSocketCreate(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  // It can be a UDP socket.
+  init(thr, pc, fd, &fdctx.socksync);
+}
+
+void FdSocketAccept(ThreadState *thr, uptr pc, int fd, int newfd) {
+  DPrintf("#%d: FdSocketAccept(%d, %d)\n", thr->tid, fd, newfd);
+  if (bogusfd(fd))
+    return;
+  // Synchronize connect->accept.
+  Acquire(thr, pc, (uptr)&fdctx.connectsync);
+  init(thr, pc, newfd, &fdctx.socksync);
+}
+
+void FdSocketConnecting(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdSocketConnecting(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  // Synchronize connect->accept.
+  Release(thr, pc, (uptr)&fdctx.connectsync);
+}
+
+void FdSocketConnect(ThreadState *thr, uptr pc, int fd) {
+  DPrintf("#%d: FdSocketConnect(%d)\n", thr->tid, fd);
+  if (bogusfd(fd))
+    return;
+  init(thr, pc, fd, &fdctx.socksync);
+}
+
+uptr File2addr(const char *path) {
+  (void)path;
+  static u64 addr;
+  return (uptr)&addr;
+}
+
+uptr Dir2addr(const char *path) {
+  (void)path;
+  static u64 addr;
+  return (uptr)&addr;
+}
+
+}  //  namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_fd.h b/compiler-rt/lib/tsan/rtl/tsan_fd.h
new file mode 100644
index 0000000..64dc84f
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_fd.h
@@ -0,0 +1,65 @@
+//===-- tsan_fd.h -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// This file handles synchronization via IO.
+// People use IO for synchronization along the lines of:
+//
+// int X;
+// int client_socket;  // initialized elsewhere
+// int server_socket;  // initialized elsewhere
+//
+// Thread 1:
+// X = 42;
+// send(client_socket, ...);
+//
+// Thread 2:
+// if (recv(server_socket, ...) > 0)
+//   assert(X == 42);
+//
+// This file determines the scope of the file descriptor (pipe, socket,
+// all local files, etc) and executes acquire and release operations on
+// the scope as necessary.  Some scopes are very fine grained (e.g. pipe
+// operations synchronize only with operations on the same pipe), while
+// others are corse-grained (e.g. all operations on local files synchronize
+// with each other).
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_FD_H
+#define TSAN_FD_H
+
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+void FdInit();
+void FdAcquire(ThreadState *thr, uptr pc, int fd);
+void FdRelease(ThreadState *thr, uptr pc, int fd);
+void FdAccess(ThreadState *thr, uptr pc, int fd);
+void FdClose(ThreadState *thr, uptr pc, int fd, bool write = true);
+void FdFileCreate(ThreadState *thr, uptr pc, int fd);
+void FdDup(ThreadState *thr, uptr pc, int oldfd, int newfd, bool write);
+void FdPipeCreate(ThreadState *thr, uptr pc, int rfd, int wfd);
+void FdEventCreate(ThreadState *thr, uptr pc, int fd);
+void FdSignalCreate(ThreadState *thr, uptr pc, int fd);
+void FdInotifyCreate(ThreadState *thr, uptr pc, int fd);
+void FdPollCreate(ThreadState *thr, uptr pc, int fd);
+void FdSocketCreate(ThreadState *thr, uptr pc, int fd);
+void FdSocketAccept(ThreadState *thr, uptr pc, int fd, int newfd);
+void FdSocketConnecting(ThreadState *thr, uptr pc, int fd);
+void FdSocketConnect(ThreadState *thr, uptr pc, int fd);
+bool FdLocation(uptr addr, int *fd, int *tid, u32 *stack);
+void FdOnFork(ThreadState *thr, uptr pc);
+
+uptr File2addr(const char *path);
+uptr Dir2addr(const char *path);
+
+}  // namespace __tsan
+
+#endif  // TSAN_INTERFACE_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_flags.cc b/compiler-rt/lib/tsan/rtl/tsan_flags.cc
new file mode 100644
index 0000000..7615231
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_flags.cc
@@ -0,0 +1,130 @@
+//===-- tsan_flags.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "tsan_flags.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+#include "ubsan/ubsan_flags.h"
+
+namespace __tsan {
+
+Flags *flags() {
+  return &ctx->flags;
+}
+
+// Can be overriden in frontend.
+#ifdef TSAN_EXTERNAL_HOOKS
+extern "C" const char* __tsan_default_options();
+#else
+SANITIZER_WEAK_DEFAULT_IMPL
+const char *__tsan_default_options() {
+  return "";
+}
+#endif
+
+void Flags::SetDefaults() {
+#define TSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "tsan_flags.inc"
+#undef TSAN_FLAG
+  // DDFlags
+  second_deadlock_stack = false;
+}
+
+void RegisterTsanFlags(FlagParser *parser, Flags *f) {
+#define TSAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "tsan_flags.inc"
+#undef TSAN_FLAG
+  // DDFlags
+  RegisterFlag(parser, "second_deadlock_stack",
+      "Report where each mutex is locked in deadlock reports",
+      &f->second_deadlock_stack);
+}
+
+void InitializeFlags(Flags *f, const char *env) {
+  SetCommonFlagsDefaults();
+  {
+    // Override some common flags defaults.
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.allow_addr2line = true;
+    if (kGoMode) {
+      // Does not work as expected for Go: runtime handles SIGABRT and crashes.
+      cf.abort_on_error = false;
+      // Go does not have mutexes.
+    } else {
+      cf.detect_deadlocks = true;
+    }
+    cf.print_suppressions = false;
+    cf.stack_trace_format = "    #%n %f %S %M";
+    cf.exitcode = 66;
+    OverrideCommonFlags(cf);
+  }
+
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterTsanFlags(&parser, f);
+  RegisterCommonFlags(&parser);
+
+#if TSAN_CONTAINS_UBSAN
+  __ubsan::Flags *uf = __ubsan::flags();
+  uf->SetDefaults();
+
+  FlagParser ubsan_parser;
+  __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
+  RegisterCommonFlags(&ubsan_parser);
+#endif
+
+  // Let a frontend override.
+  parser.ParseString(__tsan_default_options());
+#if TSAN_CONTAINS_UBSAN
+  const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
+  ubsan_parser.ParseString(ubsan_default_options);
+#endif
+  // Override from command line.
+  parser.ParseString(env);
+#if TSAN_CONTAINS_UBSAN
+  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+#endif
+
+  // Sanity check.
+  if (!f->report_bugs) {
+    f->report_thread_leaks = false;
+    f->report_destroy_locked = false;
+    f->report_signal_unsafe = false;
+  }
+
+  SetVerbosity(common_flags()->verbosity);
+
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) parser.PrintFlagDescriptions();
+
+  if (f->history_size < 0 || f->history_size > 7) {
+    Printf("ThreadSanitizer: incorrect value for history_size"
+           " (must be [0..7])\n");
+    Die();
+  }
+
+  if (f->io_sync < 0 || f->io_sync > 2) {
+    Printf("ThreadSanitizer: incorrect value for io_sync"
+           " (must be [0..2])\n");
+    Die();
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_flags.h b/compiler-rt/lib/tsan/rtl/tsan_flags.h
new file mode 100644
index 0000000..e2f6b3c
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_flags.h
@@ -0,0 +1,35 @@
+//===-- tsan_flags.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+// NOTE: This file may be included into user code.
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAN_FLAGS_H
+#define TSAN_FLAGS_H
+
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
+
+namespace __tsan {
+
+struct Flags : DDFlags {
+#define TSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "tsan_flags.inc"
+#undef TSAN_FLAG
+
+  void SetDefaults();
+  void ParseFromString(const char *str);
+};
+
+Flags *flags();
+void InitializeFlags(Flags *flags, const char *env);
+}  // namespace __tsan
+
+#endif  // TSAN_FLAGS_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_flags.inc b/compiler-rt/lib/tsan/rtl/tsan_flags.inc
new file mode 100644
index 0000000..ab9ca99
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_flags.inc
@@ -0,0 +1,78 @@
+//===-- tsan_flags.inc ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// TSan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_FLAG
+# error "Define TSAN_FLAG prior to including this file!"
+#endif
+
+// TSAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+TSAN_FLAG(bool, enable_annotations, true,
+          "Enable dynamic annotations, otherwise they are no-ops.")
+// Suppress a race report if we've already output another race report
+// with the same stack.
+TSAN_FLAG(bool, suppress_equal_stacks, true,
+          "Suppress a race report if we've already output another race report "
+          "with the same stack.")
+TSAN_FLAG(bool, suppress_equal_addresses, true,
+          "Suppress a race report if we've already output another race report "
+          "on the same address.")
+
+TSAN_FLAG(bool, report_bugs, true,
+          "Turns off bug reporting entirely (useful for benchmarking).")
+TSAN_FLAG(bool, report_thread_leaks, true, "Report thread leaks at exit?")
+TSAN_FLAG(bool, report_destroy_locked, true,
+          "Report destruction of a locked mutex?")
+TSAN_FLAG(bool, report_mutex_bugs, true,
+          "Report incorrect usages of mutexes and mutex annotations?")
+TSAN_FLAG(bool, report_signal_unsafe, true,
+          "Report violations of async signal-safety "
+          "(e.g. malloc() call from a signal handler).")
+TSAN_FLAG(bool, report_atomic_races, true,
+          "Report races between atomic and plain memory accesses.")
+TSAN_FLAG(
+    bool, force_seq_cst_atomics, false,
+    "If set, all atomics are effectively sequentially consistent (seq_cst), "
+    "regardless of what user actually specified.")
+TSAN_FLAG(bool, print_benign, false, "Print matched \"benign\" races at exit.")
+TSAN_FLAG(bool, halt_on_error, false, "Exit after first reported error.")
+TSAN_FLAG(int, atexit_sleep_ms, 1000,
+          "Sleep in main thread before exiting for that many ms "
+          "(useful to catch \"at exit\" races).")
+TSAN_FLAG(const char *, profile_memory, "",
+          "If set, periodically write memory profile to that file.")
+TSAN_FLAG(int, flush_memory_ms, 0, "Flush shadow memory every X ms.")
+TSAN_FLAG(int, flush_symbolizer_ms, 5000, "Flush symbolizer caches every X ms.")
+TSAN_FLAG(
+    int, memory_limit_mb, 0,
+    "Resident memory limit in MB to aim at."
+    "If the process consumes more memory, then TSan will flush shadow memory.")
+TSAN_FLAG(bool, stop_on_start, false,
+          "Stops on start until __tsan_resume() is called (for debugging).")
+TSAN_FLAG(bool, running_on_valgrind, false,
+          "Controls whether RunningOnValgrind() returns true or false.")
+TSAN_FLAG(
+    int, history_size, kGoMode ? 1 : 3, // There are a lot of goroutines in Go.
+    "Per-thread history size, controls how many previous memory accesses "
+    "are remembered per thread.  Possible values are [0..7]. "
+    "history_size=0 amounts to 32K memory accesses.  Each next value doubles "
+    "the amount of memory accesses, up to history_size=7 that amounts to "
+    "4M memory accesses.  The default value is 2 (128K memory accesses).")
+TSAN_FLAG(int, io_sync, 1,
+          "Controls level of synchronization implied by IO operations. "
+          "0 - no synchronization "
+          "1 - reasonable level of synchronization (write->read)"
+          "2 - global synchronization of all IO operations.")
+TSAN_FLAG(bool, die_after_fork, true,
+          "Die after multi-threaded fork if the child creates new threads.")
+TSAN_FLAG(const char *, suppressions, "", "Suppressions file name.")
diff --git a/compiler-rt/lib/tsan/rtl/tsan_ignoreset.cc b/compiler-rt/lib/tsan/rtl/tsan_ignoreset.cc
new file mode 100644
index 0000000..cdb90d2
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_ignoreset.cc
@@ -0,0 +1,47 @@
+//===-- tsan_ignoreset.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_ignoreset.h"
+
+namespace __tsan {
+
+const uptr IgnoreSet::kMaxSize;
+
+IgnoreSet::IgnoreSet()
+    : size_() {
+}
+
+void IgnoreSet::Add(u32 stack_id) {
+  if (size_ == kMaxSize)
+    return;
+  for (uptr i = 0; i < size_; i++) {
+    if (stacks_[i] == stack_id)
+      return;
+  }
+  stacks_[size_++] = stack_id;
+}
+
+void IgnoreSet::Reset() {
+  size_ = 0;
+}
+
+uptr IgnoreSet::Size() const {
+  return size_;
+}
+
+u32 IgnoreSet::At(uptr i) const {
+  CHECK_LT(i, size_);
+  CHECK_LE(size_, kMaxSize);
+  return stacks_[i];
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_ignoreset.h b/compiler-rt/lib/tsan/rtl/tsan_ignoreset.h
new file mode 100644
index 0000000..e747d81
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_ignoreset.h
@@ -0,0 +1,38 @@
+//===-- tsan_ignoreset.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// IgnoreSet holds a set of stack traces where ignores were enabled.
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_IGNORESET_H
+#define TSAN_IGNORESET_H
+
+#include "tsan_defs.h"
+
+namespace __tsan {
+
+class IgnoreSet {
+ public:
+  static const uptr kMaxSize = 16;
+
+  IgnoreSet();
+  void Add(u32 stack_id);
+  void Reset();
+  uptr Size() const;
+  u32 At(uptr i) const;
+
+ private:
+  uptr size_;
+  u32 stacks_[kMaxSize];
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_IGNORESET_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interceptors.cc b/compiler-rt/lib/tsan/rtl/tsan_interceptors.cc
new file mode 100644
index 0000000..62c96cb
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interceptors.cc
@@ -0,0 +1,2765 @@
+//===-- tsan_interceptors.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// FIXME: move as many interceptors as possible into
+// sanitizer_common/sanitizer_common_interceptors.inc
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_platform_limits_posix.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "interception/interception.h"
+#include "tsan_interceptors.h"
+#include "tsan_interface.h"
+#include "tsan_platform.h"
+#include "tsan_suppressions.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+#include "tsan_fd.h"
+
+#if SANITIZER_POSIX
+#include "sanitizer_common/sanitizer_posix.h"
+#endif
+
+using namespace __tsan;  // NOLINT
+
+#if SANITIZER_FREEBSD || SANITIZER_MAC
+#define __errno_location __error
+#define stdout __stdoutp
+#define stderr __stderrp
+#endif
+
+#if SANITIZER_FREEBSD
+#define __libc_realloc __realloc
+#define __libc_calloc __calloc
+#elif SANITIZER_MAC
+#define __libc_malloc REAL(malloc)
+#define __libc_realloc REAL(realloc)
+#define __libc_calloc REAL(calloc)
+#define __libc_free REAL(free)
+#elif SANITIZER_ANDROID
+#define __errno_location __errno
+#define __libc_malloc REAL(malloc)
+#define __libc_realloc REAL(realloc)
+#define __libc_calloc REAL(calloc)
+#define __libc_free REAL(free)
+#define mallopt(a, b)
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#define PTHREAD_CREATE_DETACHED 1
+#elif SANITIZER_MAC
+#define PTHREAD_CREATE_DETACHED 2
+#endif
+
+
+#ifdef __mips__
+const int kSigCount = 129;
+#else
+const int kSigCount = 65;
+#endif
+
+struct my_siginfo_t {
+  // The size is determined by looking at sizeof of real siginfo_t on linux.
+  u64 opaque[128 / sizeof(u64)];
+};
+
+#ifdef __mips__
+struct ucontext_t {
+  u64 opaque[768 / sizeof(u64) + 1];
+};
+#else
+struct ucontext_t {
+  // The size is determined by looking at sizeof of real ucontext_t on linux.
+  u64 opaque[936 / sizeof(u64) + 1];
+};
+#endif
+
+#if defined(__x86_64__) || defined(__mips__) \
+  || (defined(__powerpc64__) && defined(__BIG_ENDIAN__))
+#define PTHREAD_ABI_BASE  "GLIBC_2.3.2"
+#elif defined(__aarch64__) || (defined(__powerpc64__) \
+  && defined(__LITTLE_ENDIAN__))
+#define PTHREAD_ABI_BASE  "GLIBC_2.17"
+#endif
+
+extern "C" int pthread_attr_init(void *attr);
+extern "C" int pthread_attr_destroy(void *attr);
+DECLARE_REAL(int, pthread_attr_getdetachstate, void *, void *)
+extern "C" int pthread_attr_setstacksize(void *attr, uptr stacksize);
+extern "C" int pthread_key_create(unsigned *key, void (*destructor)(void* v));
+extern "C" int pthread_setspecific(unsigned key, const void *v);
+DECLARE_REAL(int, pthread_mutexattr_gettype, void *, void *)
+extern "C" int pthread_sigmask(int how, const __sanitizer_sigset_t *set,
+                               __sanitizer_sigset_t *oldset);
+// REAL(sigfillset) defined in common interceptors.
+DECLARE_REAL(int, sigfillset, __sanitizer_sigset_t *set)
+DECLARE_REAL(int, fflush, __sanitizer_FILE *fp)
+DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr size)
+DECLARE_REAL_AND_INTERCEPTOR(void, free, void *ptr)
+extern "C" void *pthread_self();
+extern "C" void _exit(int status);
+extern "C" int *__errno_location();
+extern "C" int fileno_unlocked(void *stream);
+#if !SANITIZER_ANDROID
+extern "C" void *__libc_calloc(uptr size, uptr n);
+extern "C" void *__libc_realloc(void *ptr, uptr size);
+#endif
+extern "C" int dirfd(void *dirp);
+#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID
+extern "C" int mallopt(int param, int value);
+#endif
+extern __sanitizer_FILE *stdout, *stderr;
+const int PTHREAD_MUTEX_RECURSIVE = 1;
+const int PTHREAD_MUTEX_RECURSIVE_NP = 1;
+const int EINVAL = 22;
+const int EBUSY = 16;
+const int EOWNERDEAD = 130;
+#if !SANITIZER_MAC
+const int EPOLL_CTL_ADD = 1;
+#endif
+const int SIGILL = 4;
+const int SIGABRT = 6;
+const int SIGFPE = 8;
+const int SIGSEGV = 11;
+const int SIGPIPE = 13;
+const int SIGTERM = 15;
+#if defined(__mips__) || SANITIZER_MAC
+const int SIGBUS = 10;
+const int SIGSYS = 12;
+#else
+const int SIGBUS = 7;
+const int SIGSYS = 31;
+#endif
+void *const MAP_FAILED = (void*)-1;
+#if !SANITIZER_MAC
+const int PTHREAD_BARRIER_SERIAL_THREAD = -1;
+#endif
+const int MAP_FIXED = 0x10;
+typedef long long_t;  // NOLINT
+
+// From /usr/include/unistd.h
+# define F_ULOCK 0      /* Unlock a previously locked region.  */
+# define F_LOCK  1      /* Lock a region for exclusive use.  */
+# define F_TLOCK 2      /* Test and lock a region for exclusive use.  */
+# define F_TEST  3      /* Test a region for other processes locks.  */
+
+#define errno (*__errno_location())
+
+typedef void (*sighandler_t)(int sig);
+typedef void (*sigactionhandler_t)(int sig, my_siginfo_t *siginfo, void *uctx);
+
+#if SANITIZER_ANDROID
+struct sigaction_t {
+  u32 sa_flags;
+  union {
+    sighandler_t sa_handler;
+    sigactionhandler_t sa_sgiaction;
+  };
+  __sanitizer_sigset_t sa_mask;
+  void (*sa_restorer)();
+};
+#else
+struct sigaction_t {
+#ifdef __mips__
+  u32 sa_flags;
+#endif
+  union {
+    sighandler_t sa_handler;
+    sigactionhandler_t sa_sigaction;
+  };
+#if SANITIZER_FREEBSD
+  int sa_flags;
+  __sanitizer_sigset_t sa_mask;
+#elif SANITIZER_MAC
+  __sanitizer_sigset_t sa_mask;
+  int sa_flags;
+#else
+  __sanitizer_sigset_t sa_mask;
+#ifndef __mips__
+  int sa_flags;
+#endif
+  void (*sa_restorer)();
+#endif
+};
+#endif
+
+const sighandler_t SIG_DFL = (sighandler_t)0;
+const sighandler_t SIG_IGN = (sighandler_t)1;
+const sighandler_t SIG_ERR = (sighandler_t)-1;
+#if SANITIZER_FREEBSD || SANITIZER_MAC
+const int SA_SIGINFO = 0x40;
+const int SIG_SETMASK = 3;
+#elif defined(__mips__)
+const int SA_SIGINFO = 8;
+const int SIG_SETMASK = 3;
+#else
+const int SA_SIGINFO = 4;
+const int SIG_SETMASK = 2;
+#endif
+
+#define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED \
+  (!cur_thread()->is_inited)
+
+static sigaction_t sigactions[kSigCount];
+
+namespace __tsan {
+struct SignalDesc {
+  bool armed;
+  bool sigaction;
+  my_siginfo_t siginfo;
+  ucontext_t ctx;
+};
+
+struct ThreadSignalContext {
+  int int_signal_send;
+  atomic_uintptr_t in_blocking_func;
+  atomic_uintptr_t have_pending_signals;
+  SignalDesc pending_signals[kSigCount];
+  // emptyset and oldset are too big for stack.
+  __sanitizer_sigset_t emptyset;
+  __sanitizer_sigset_t oldset;
+};
+
+// The object is 64-byte aligned, because we want hot data to be located in
+// a single cache line if possible (it's accessed in every interceptor).
+static ALIGNED(64) char libignore_placeholder[sizeof(LibIgnore)];
+static LibIgnore *libignore() {
+  return reinterpret_cast<LibIgnore*>(&libignore_placeholder[0]);
+}
+
+void InitializeLibIgnore() {
+  const SuppressionContext &supp = *Suppressions();
+  const uptr n = supp.SuppressionCount();
+  for (uptr i = 0; i < n; i++) {
+    const Suppression *s = supp.SuppressionAt(i);
+    if (0 == internal_strcmp(s->type, kSuppressionLib))
+      libignore()->AddIgnoredLibrary(s->templ);
+  }
+  libignore()->OnLibraryLoaded(0);
+}
+
+}  // namespace __tsan
+
+static ThreadSignalContext *SigCtx(ThreadState *thr) {
+  ThreadSignalContext *ctx = (ThreadSignalContext*)thr->signal_ctx;
+  if (ctx == 0 && !thr->is_dead) {
+    ctx = (ThreadSignalContext*)MmapOrDie(sizeof(*ctx), "ThreadSignalContext");
+    MemoryResetRange(thr, (uptr)&SigCtx, (uptr)ctx, sizeof(*ctx));
+    thr->signal_ctx = ctx;
+  }
+  return ctx;
+}
+
+#if !SANITIZER_MAC
+static unsigned g_thread_finalize_key;
+#endif
+
+ScopedInterceptor::ScopedInterceptor(ThreadState *thr, const char *fname,
+                                     uptr pc)
+    : thr_(thr)
+    , pc_(pc)
+    , in_ignored_lib_(false) {
+  if (!thr_->ignore_interceptors) {
+    Initialize(thr);
+    FuncEntry(thr, pc);
+  }
+  DPrintf("#%d: intercept %s()\n", thr_->tid, fname);
+  if (!thr_->in_ignored_lib && libignore()->IsIgnored(pc)) {
+    in_ignored_lib_ = true;
+    thr_->in_ignored_lib = true;
+    ThreadIgnoreBegin(thr_, pc_);
+  }
+}
+
+ScopedInterceptor::~ScopedInterceptor() {
+  if (in_ignored_lib_) {
+    thr_->in_ignored_lib = false;
+    ThreadIgnoreEnd(thr_, pc_);
+  }
+  if (!thr_->ignore_interceptors) {
+    ProcessPendingSignals(thr_);
+    FuncExit(thr_);
+    CheckNoLocks(thr_);
+  }
+}
+
+void ScopedInterceptor::UserCallbackStart() {
+  if (in_ignored_lib_) {
+    thr_->in_ignored_lib = false;
+    ThreadIgnoreEnd(thr_, pc_);
+  }
+}
+
+void ScopedInterceptor::UserCallbackEnd() {
+  if (in_ignored_lib_) {
+    thr_->in_ignored_lib = true;
+    ThreadIgnoreBegin(thr_, pc_);
+  }
+}
+
+#define TSAN_INTERCEPT(func) INTERCEPT_FUNCTION(func)
+#if SANITIZER_FREEBSD
+# define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION(func)
+#else
+# define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION_VER(func, ver)
+#endif
+
+#define READ_STRING_OF_LEN(thr, pc, s, len, n)                 \
+  MemoryAccessRange((thr), (pc), (uptr)(s),                         \
+    common_flags()->strict_string_checks ? (len) + 1 : (n), false)
+
+#define READ_STRING(thr, pc, s, n)                             \
+    READ_STRING_OF_LEN((thr), (pc), (s), internal_strlen(s), (n))
+
+#define BLOCK_REAL(name) (BlockingCall(thr), REAL(name))
+
+struct BlockingCall {
+  explicit BlockingCall(ThreadState *thr)
+      : thr(thr)
+      , ctx(SigCtx(thr)) {
+    for (;;) {
+      atomic_store(&ctx->in_blocking_func, 1, memory_order_relaxed);
+      if (atomic_load(&ctx->have_pending_signals, memory_order_relaxed) == 0)
+        break;
+      atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
+      ProcessPendingSignals(thr);
+    }
+    // When we are in a "blocking call", we process signals asynchronously
+    // (right when they arrive). In this context we do not expect to be
+    // executing any user/runtime code. The known interceptor sequence when
+    // this is not true is: pthread_join -> munmap(stack). It's fine
+    // to ignore munmap in this case -- we handle stack shadow separately.
+    thr->ignore_interceptors++;
+  }
+
+  ~BlockingCall() {
+    thr->ignore_interceptors--;
+    atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
+  }
+
+  ThreadState *thr;
+  ThreadSignalContext *ctx;
+};
+
+TSAN_INTERCEPTOR(unsigned, sleep, unsigned sec) {
+  SCOPED_TSAN_INTERCEPTOR(sleep, sec);
+  unsigned res = BLOCK_REAL(sleep)(sec);
+  AfterSleep(thr, pc);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, usleep, long_t usec) {
+  SCOPED_TSAN_INTERCEPTOR(usleep, usec);
+  int res = BLOCK_REAL(usleep)(usec);
+  AfterSleep(thr, pc);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, nanosleep, void *req, void *rem) {
+  SCOPED_TSAN_INTERCEPTOR(nanosleep, req, rem);
+  int res = BLOCK_REAL(nanosleep)(req, rem);
+  AfterSleep(thr, pc);
+  return res;
+}
+
+// The sole reason tsan wraps atexit callbacks is to establish synchronization
+// between callback setup and callback execution.
+struct AtExitCtx {
+  void (*f)();
+  void *arg;
+};
+
+static void at_exit_wrapper(void *arg) {
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
+  Acquire(thr, pc, (uptr)arg);
+  AtExitCtx *ctx = (AtExitCtx*)arg;
+  ((void(*)(void *arg))ctx->f)(ctx->arg);
+  __libc_free(ctx);
+}
+
+static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
+      void *arg, void *dso);
+
+#if !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, atexit, void (*f)()) {
+  if (cur_thread()->in_symbolizer)
+    return 0;
+  // We want to setup the atexit callback even if we are in ignored lib
+  // or after fork.
+  SCOPED_INTERCEPTOR_RAW(atexit, f);
+  return setup_at_exit_wrapper(thr, pc, (void(*)())f, 0, 0);
+}
+#endif
+
+TSAN_INTERCEPTOR(int, __cxa_atexit, void (*f)(void *a), void *arg, void *dso) {
+  if (cur_thread()->in_symbolizer)
+    return 0;
+  SCOPED_TSAN_INTERCEPTOR(__cxa_atexit, f, arg, dso);
+  return setup_at_exit_wrapper(thr, pc, (void(*)())f, arg, dso);
+}
+
+static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
+      void *arg, void *dso) {
+  AtExitCtx *ctx = (AtExitCtx*)__libc_malloc(sizeof(AtExitCtx));
+  ctx->f = f;
+  ctx->arg = arg;
+  Release(thr, pc, (uptr)ctx);
+  // Memory allocation in __cxa_atexit will race with free during exit,
+  // because we do not see synchronization around atexit callback list.
+  ThreadIgnoreBegin(thr, pc);
+  int res = REAL(__cxa_atexit)(at_exit_wrapper, ctx, dso);
+  ThreadIgnoreEnd(thr, pc);
+  return res;
+}
+
+#if !SANITIZER_MAC
+static void on_exit_wrapper(int status, void *arg) {
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
+  Acquire(thr, pc, (uptr)arg);
+  AtExitCtx *ctx = (AtExitCtx*)arg;
+  ((void(*)(int status, void *arg))ctx->f)(status, ctx->arg);
+  __libc_free(ctx);
+}
+
+TSAN_INTERCEPTOR(int, on_exit, void(*f)(int, void*), void *arg) {
+  if (cur_thread()->in_symbolizer)
+    return 0;
+  SCOPED_TSAN_INTERCEPTOR(on_exit, f, arg);
+  AtExitCtx *ctx = (AtExitCtx*)__libc_malloc(sizeof(AtExitCtx));
+  ctx->f = (void(*)())f;
+  ctx->arg = arg;
+  Release(thr, pc, (uptr)ctx);
+  // Memory allocation in __cxa_atexit will race with free during exit,
+  // because we do not see synchronization around atexit callback list.
+  ThreadIgnoreBegin(thr, pc);
+  int res = REAL(on_exit)(on_exit_wrapper, ctx);
+  ThreadIgnoreEnd(thr, pc);
+  return res;
+}
+#endif
+
+// Cleanup old bufs.
+static void JmpBufGarbageCollect(ThreadState *thr, uptr sp) {
+  for (uptr i = 0; i < thr->jmp_bufs.Size(); i++) {
+    JmpBuf *buf = &thr->jmp_bufs[i];
+    if (buf->sp <= sp) {
+      uptr sz = thr->jmp_bufs.Size();
+      internal_memcpy(buf, &thr->jmp_bufs[sz - 1], sizeof(*buf));
+      thr->jmp_bufs.PopBack();
+      i--;
+    }
+  }
+}
+
+static void SetJmp(ThreadState *thr, uptr sp, uptr mangled_sp) {
+  if (!thr->is_inited)  // called from libc guts during bootstrap
+    return;
+  // Cleanup old bufs.
+  JmpBufGarbageCollect(thr, sp);
+  // Remember the buf.
+  JmpBuf *buf = thr->jmp_bufs.PushBack();
+  buf->sp = sp;
+  buf->mangled_sp = mangled_sp;
+  buf->shadow_stack_pos = thr->shadow_stack_pos;
+  ThreadSignalContext *sctx = SigCtx(thr);
+  buf->int_signal_send = sctx ? sctx->int_signal_send : 0;
+  buf->in_blocking_func = sctx ?
+      atomic_load(&sctx->in_blocking_func, memory_order_relaxed) :
+      false;
+  buf->in_signal_handler = atomic_load(&thr->in_signal_handler,
+      memory_order_relaxed);
+}
+
+static void LongJmp(ThreadState *thr, uptr *env) {
+#ifdef __powerpc__
+  uptr mangled_sp = env[0];
+#elif SANITIZER_FREEBSD || SANITIZER_MAC
+  uptr mangled_sp = env[2];
+#elif defined(SANITIZER_LINUX)
+# ifdef __aarch64__
+  uptr mangled_sp = env[13];
+# else
+  uptr mangled_sp = env[6];
+# endif
+#endif
+  // Find the saved buf by mangled_sp.
+  for (uptr i = 0; i < thr->jmp_bufs.Size(); i++) {
+    JmpBuf *buf = &thr->jmp_bufs[i];
+    if (buf->mangled_sp == mangled_sp) {
+      CHECK_GE(thr->shadow_stack_pos, buf->shadow_stack_pos);
+      // Unwind the stack.
+      while (thr->shadow_stack_pos > buf->shadow_stack_pos)
+        FuncExit(thr);
+      ThreadSignalContext *sctx = SigCtx(thr);
+      if (sctx) {
+        sctx->int_signal_send = buf->int_signal_send;
+        atomic_store(&sctx->in_blocking_func, buf->in_blocking_func,
+            memory_order_relaxed);
+      }
+      atomic_store(&thr->in_signal_handler, buf->in_signal_handler,
+          memory_order_relaxed);
+      JmpBufGarbageCollect(thr, buf->sp - 1);  // do not collect buf->sp
+      return;
+    }
+  }
+  Printf("ThreadSanitizer: can't find longjmp buf\n");
+  CHECK(0);
+}
+
+// FIXME: put everything below into a common extern "C" block?
+extern "C" void __tsan_setjmp(uptr sp, uptr mangled_sp) {
+  SetJmp(cur_thread(), sp, mangled_sp);
+}
+
+#if SANITIZER_MAC
+TSAN_INTERCEPTOR(int, setjmp, void *env);
+TSAN_INTERCEPTOR(int, _setjmp, void *env);
+TSAN_INTERCEPTOR(int, sigsetjmp, void *env);
+#else  // SANITIZER_MAC
+// Not called.  Merely to satisfy TSAN_INTERCEPT().
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+int __interceptor_setjmp(void *env);
+extern "C" int __interceptor_setjmp(void *env) {
+  CHECK(0);
+  return 0;
+}
+
+// FIXME: any reason to have a separate declaration?
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+int __interceptor__setjmp(void *env);
+extern "C" int __interceptor__setjmp(void *env) {
+  CHECK(0);
+  return 0;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+int __interceptor_sigsetjmp(void *env);
+extern "C" int __interceptor_sigsetjmp(void *env) {
+  CHECK(0);
+  return 0;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+int __interceptor___sigsetjmp(void *env);
+extern "C" int __interceptor___sigsetjmp(void *env) {
+  CHECK(0);
+  return 0;
+}
+
+extern "C" int setjmp(void *env);
+extern "C" int _setjmp(void *env);
+extern "C" int sigsetjmp(void *env);
+extern "C" int __sigsetjmp(void *env);
+DEFINE_REAL(int, setjmp, void *env)
+DEFINE_REAL(int, _setjmp, void *env)
+DEFINE_REAL(int, sigsetjmp, void *env)
+DEFINE_REAL(int, __sigsetjmp, void *env)
+#endif  // SANITIZER_MAC
+
+TSAN_INTERCEPTOR(void, longjmp, uptr *env, int val) {
+  {
+    SCOPED_TSAN_INTERCEPTOR(longjmp, env, val);
+  }
+  LongJmp(cur_thread(), env);
+  REAL(longjmp)(env, val);
+}
+
+TSAN_INTERCEPTOR(void, siglongjmp, uptr *env, int val) {
+  {
+    SCOPED_TSAN_INTERCEPTOR(siglongjmp, env, val);
+  }
+  LongJmp(cur_thread(), env);
+  REAL(siglongjmp)(env, val);
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(void*, malloc, uptr size) {
+  if (cur_thread()->in_symbolizer)
+    return __libc_malloc(size);
+  void *p = 0;
+  {
+    SCOPED_INTERCEPTOR_RAW(malloc, size);
+    p = user_alloc(thr, pc, size);
+  }
+  invoke_malloc_hook(p, size);
+  return p;
+}
+
+TSAN_INTERCEPTOR(void*, __libc_memalign, uptr align, uptr sz) {
+  SCOPED_TSAN_INTERCEPTOR(__libc_memalign, align, sz);
+  return user_alloc(thr, pc, sz, align);
+}
+
+TSAN_INTERCEPTOR(void*, calloc, uptr size, uptr n) {
+  if (cur_thread()->in_symbolizer)
+    return __libc_calloc(size, n);
+  void *p = 0;
+  {
+    SCOPED_INTERCEPTOR_RAW(calloc, size, n);
+    p = user_calloc(thr, pc, size, n);
+  }
+  invoke_malloc_hook(p, n * size);
+  return p;
+}
+
+TSAN_INTERCEPTOR(void*, realloc, void *p, uptr size) {
+  if (cur_thread()->in_symbolizer)
+    return __libc_realloc(p, size);
+  if (p)
+    invoke_free_hook(p);
+  {
+    SCOPED_INTERCEPTOR_RAW(realloc, p, size);
+    p = user_realloc(thr, pc, p, size);
+  }
+  invoke_malloc_hook(p, size);
+  return p;
+}
+
+TSAN_INTERCEPTOR(void, free, void *p) {
+  if (p == 0)
+    return;
+  if (cur_thread()->in_symbolizer)
+    return __libc_free(p);
+  invoke_free_hook(p);
+  SCOPED_INTERCEPTOR_RAW(free, p);
+  user_free(thr, pc, p);
+}
+
+TSAN_INTERCEPTOR(void, cfree, void *p) {
+  if (p == 0)
+    return;
+  if (cur_thread()->in_symbolizer)
+    return __libc_free(p);
+  invoke_free_hook(p);
+  SCOPED_INTERCEPTOR_RAW(cfree, p);
+  user_free(thr, pc, p);
+}
+
+TSAN_INTERCEPTOR(uptr, malloc_usable_size, void *p) {
+  SCOPED_INTERCEPTOR_RAW(malloc_usable_size, p);
+  return user_alloc_usable_size(p);
+}
+#endif
+
+TSAN_INTERCEPTOR(uptr, strlen, const char *s) {
+  SCOPED_TSAN_INTERCEPTOR(strlen, s);
+  uptr len = internal_strlen(s);
+  MemoryAccessRange(thr, pc, (uptr)s, len + 1, false);
+  return len;
+}
+
+TSAN_INTERCEPTOR(void*, memset, void *dst, int v, uptr size) {
+  // On FreeBSD we get here from libthr internals on thread initialization.
+  if (!COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {
+    SCOPED_TSAN_INTERCEPTOR(memset, dst, v, size);
+    MemoryAccessRange(thr, pc, (uptr)dst, size, true);
+  }
+  return internal_memset(dst, v, size);
+}
+
+TSAN_INTERCEPTOR(void*, memcpy, void *dst, const void *src, uptr size) {
+  // On FreeBSD we get here from libthr internals on thread initialization.
+  if (!COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {
+    SCOPED_TSAN_INTERCEPTOR(memcpy, dst, src, size);
+    MemoryAccessRange(thr, pc, (uptr)dst, size, true);
+    MemoryAccessRange(thr, pc, (uptr)src, size, false);
+  }
+  // On OS X, calling internal_memcpy here will cause memory corruptions,
+  // because memcpy and memmove are actually aliases of the same implementation.
+  // We need to use internal_memmove here.
+  return internal_memmove(dst, src, size);
+}
+
+TSAN_INTERCEPTOR(void*, memmove, void *dst, void *src, uptr n) {
+  if (!COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {
+    SCOPED_TSAN_INTERCEPTOR(memmove, dst, src, n);
+    MemoryAccessRange(thr, pc, (uptr)dst, n, true);
+    MemoryAccessRange(thr, pc, (uptr)src, n, false);
+  }
+  return REAL(memmove)(dst, src, n);
+}
+
+TSAN_INTERCEPTOR(char*, strchr, char *s, int c) {
+  SCOPED_TSAN_INTERCEPTOR(strchr, s, c);
+  char *res = REAL(strchr)(s, c);
+  uptr len = internal_strlen(s);
+  uptr n = res ? (char*)res - (char*)s + 1 : len + 1;
+  READ_STRING_OF_LEN(thr, pc, s, len, n);
+  return res;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(char*, strchrnul, char *s, int c) {
+  SCOPED_TSAN_INTERCEPTOR(strchrnul, s, c);
+  char *res = REAL(strchrnul)(s, c);
+  uptr len = (char*)res - (char*)s + 1;
+  READ_STRING(thr, pc, s, len);
+  return res;
+}
+#endif
+
+TSAN_INTERCEPTOR(char*, strrchr, char *s, int c) {
+  SCOPED_TSAN_INTERCEPTOR(strrchr, s, c);
+  MemoryAccessRange(thr, pc, (uptr)s, internal_strlen(s) + 1, false);
+  return REAL(strrchr)(s, c);
+}
+
+TSAN_INTERCEPTOR(char*, strcpy, char *dst, const char *src) {  // NOLINT
+  SCOPED_TSAN_INTERCEPTOR(strcpy, dst, src);  // NOLINT
+  uptr srclen = internal_strlen(src);
+  MemoryAccessRange(thr, pc, (uptr)dst, srclen + 1, true);
+  MemoryAccessRange(thr, pc, (uptr)src, srclen + 1, false);
+  return REAL(strcpy)(dst, src);  // NOLINT
+}
+
+TSAN_INTERCEPTOR(char*, strncpy, char *dst, char *src, uptr n) {
+  SCOPED_TSAN_INTERCEPTOR(strncpy, dst, src, n);
+  uptr srclen = internal_strnlen(src, n);
+  MemoryAccessRange(thr, pc, (uptr)dst, n, true);
+  MemoryAccessRange(thr, pc, (uptr)src, min(srclen + 1, n), false);
+  return REAL(strncpy)(dst, src, n);
+}
+
+TSAN_INTERCEPTOR(char*, strdup, const char *str) {
+  SCOPED_TSAN_INTERCEPTOR(strdup, str);
+  // strdup will call malloc, so no instrumentation is required here.
+  return REAL(strdup)(str);
+}
+
+static bool fix_mmap_addr(void **addr, long_t sz, int flags) {
+  if (*addr) {
+    if (!IsAppMem((uptr)*addr) || !IsAppMem((uptr)*addr + sz - 1)) {
+      if (flags & MAP_FIXED) {
+        errno = EINVAL;
+        return false;
+      } else {
+        *addr = 0;
+      }
+    }
+  }
+  return true;
+}
+
+TSAN_INTERCEPTOR(void *, mmap, void *addr, SIZE_T sz, int prot, int flags,
+                 int fd, OFF_T off) {
+  SCOPED_TSAN_INTERCEPTOR(mmap, addr, sz, prot, flags, fd, off);
+  if (!fix_mmap_addr(&addr, sz, flags))
+    return MAP_FAILED;
+  void *res = REAL(mmap)(addr, sz, prot, flags, fd, off);
+  if (res != MAP_FAILED) {
+    if (fd > 0)
+      FdAccess(thr, pc, fd);
+    MemoryRangeImitateWrite(thr, pc, (uptr)res, sz);
+  }
+  return res;
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(void *, mmap64, void *addr, SIZE_T sz, int prot, int flags,
+                 int fd, OFF64_T off) {
+  SCOPED_TSAN_INTERCEPTOR(mmap64, addr, sz, prot, flags, fd, off);
+  if (!fix_mmap_addr(&addr, sz, flags))
+    return MAP_FAILED;
+  void *res = REAL(mmap64)(addr, sz, prot, flags, fd, off);
+  if (res != MAP_FAILED) {
+    if (fd > 0)
+      FdAccess(thr, pc, fd);
+    MemoryRangeImitateWrite(thr, pc, (uptr)res, sz);
+  }
+  return res;
+}
+#define TSAN_MAYBE_INTERCEPT_MMAP64 TSAN_INTERCEPT(mmap64)
+#else
+#define TSAN_MAYBE_INTERCEPT_MMAP64
+#endif
+
+TSAN_INTERCEPTOR(int, munmap, void *addr, long_t sz) {
+  SCOPED_TSAN_INTERCEPTOR(munmap, addr, sz);
+  if (sz != 0) {
+    // If sz == 0, munmap will return EINVAL and don't unmap any memory.
+    DontNeedShadowFor((uptr)addr, sz);
+    ctx->metamap.ResetRange(thr, pc, (uptr)addr, (uptr)sz);
+  }
+  int res = REAL(munmap)(addr, sz);
+  return res;
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(void*, memalign, uptr align, uptr sz) {
+  SCOPED_INTERCEPTOR_RAW(memalign, align, sz);
+  return user_alloc(thr, pc, sz, align);
+}
+#define TSAN_MAYBE_INTERCEPT_MEMALIGN TSAN_INTERCEPT(memalign)
+#else
+#define TSAN_MAYBE_INTERCEPT_MEMALIGN
+#endif
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(void*, aligned_alloc, uptr align, uptr sz) {
+  SCOPED_INTERCEPTOR_RAW(memalign, align, sz);
+  return user_alloc(thr, pc, sz, align);
+}
+
+TSAN_INTERCEPTOR(void*, valloc, uptr sz) {
+  SCOPED_INTERCEPTOR_RAW(valloc, sz);
+  return user_alloc(thr, pc, sz, GetPageSizeCached());
+}
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(void*, pvalloc, uptr sz) {
+  SCOPED_INTERCEPTOR_RAW(pvalloc, sz);
+  sz = RoundUp(sz, GetPageSizeCached());
+  return user_alloc(thr, pc, sz, GetPageSizeCached());
+}
+#define TSAN_MAYBE_INTERCEPT_PVALLOC TSAN_INTERCEPT(pvalloc)
+#else
+#define TSAN_MAYBE_INTERCEPT_PVALLOC
+#endif
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, posix_memalign, void **memptr, uptr align, uptr sz) {
+  SCOPED_INTERCEPTOR_RAW(posix_memalign, memptr, align, sz);
+  *memptr = user_alloc(thr, pc, sz, align);
+  return 0;
+}
+#endif
+
+// __cxa_guard_acquire and friends need to be intercepted in a special way -
+// regular interceptors will break statically-linked libstdc++. Linux
+// interceptors are especially defined as weak functions (so that they don't
+// cause link errors when user defines them as well). So they silently
+// auto-disable themselves when such symbol is already present in the binary. If
+// we link libstdc++ statically, it will bring own __cxa_guard_acquire which
+// will silently replace our interceptor.  That's why on Linux we simply export
+// these interceptors with INTERFACE_ATTRIBUTE.
+// On OS X, we don't support statically linking, so we just use a regular
+// interceptor.
+#if SANITIZER_MAC
+#define STDCXX_INTERCEPTOR TSAN_INTERCEPTOR
+#else
+#define STDCXX_INTERCEPTOR(rettype, name, ...) \
+  extern "C" rettype INTERFACE_ATTRIBUTE name(__VA_ARGS__)
+#endif
+
+// Used in thread-safe function static initialization.
+STDCXX_INTERCEPTOR(int, __cxa_guard_acquire, atomic_uint32_t *g) {
+  SCOPED_INTERCEPTOR_RAW(__cxa_guard_acquire, g);
+  for (;;) {
+    u32 cmp = atomic_load(g, memory_order_acquire);
+    if (cmp == 0) {
+      if (atomic_compare_exchange_strong(g, &cmp, 1<<16, memory_order_relaxed))
+        return 1;
+    } else if (cmp == 1) {
+      Acquire(thr, pc, (uptr)g);
+      return 0;
+    } else {
+      internal_sched_yield();
+    }
+  }
+}
+
+STDCXX_INTERCEPTOR(void, __cxa_guard_release, atomic_uint32_t *g) {
+  SCOPED_INTERCEPTOR_RAW(__cxa_guard_release, g);
+  Release(thr, pc, (uptr)g);
+  atomic_store(g, 1, memory_order_release);
+}
+
+STDCXX_INTERCEPTOR(void, __cxa_guard_abort, atomic_uint32_t *g) {
+  SCOPED_INTERCEPTOR_RAW(__cxa_guard_abort, g);
+  atomic_store(g, 0, memory_order_relaxed);
+}
+
+namespace __tsan {
+void DestroyThreadState() {
+  ThreadState *thr = cur_thread();
+  ThreadFinish(thr);
+  ThreadSignalContext *sctx = thr->signal_ctx;
+  if (sctx) {
+    thr->signal_ctx = 0;
+    UnmapOrDie(sctx, sizeof(*sctx));
+  }
+  cur_thread_finalize();
+}
+}  // namespace __tsan
+
+#if !SANITIZER_MAC
+static void thread_finalize(void *v) {
+  uptr iter = (uptr)v;
+  if (iter > 1) {
+    if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
+      Printf("ThreadSanitizer: failed to set thread key\n");
+      Die();
+    }
+    return;
+  }
+  DestroyThreadState();
+}
+#endif
+
+
+struct ThreadParam {
+  void* (*callback)(void *arg);
+  void *param;
+  atomic_uintptr_t tid;
+};
+
+extern "C" void *__tsan_thread_start_func(void *arg) {
+  ThreadParam *p = (ThreadParam*)arg;
+  void* (*callback)(void *arg) = p->callback;
+  void *param = p->param;
+  int tid = 0;
+  {
+    ThreadState *thr = cur_thread();
+    // Thread-local state is not initialized yet.
+    ScopedIgnoreInterceptors ignore;
+#if !SANITIZER_MAC
+    ThreadIgnoreBegin(thr, 0);
+    if (pthread_setspecific(g_thread_finalize_key,
+                            (void *)GetPthreadDestructorIterations())) {
+      Printf("ThreadSanitizer: failed to set thread key\n");
+      Die();
+    }
+    ThreadIgnoreEnd(thr, 0);
+#endif
+    while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
+      internal_sched_yield();
+    ThreadStart(thr, tid, GetTid());
+    atomic_store(&p->tid, 0, memory_order_release);
+  }
+  void *res = callback(param);
+  // Prevent the callback from being tail called,
+  // it mixes up stack traces.
+  volatile int foo = 42;
+  foo++;
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_create,
+    void *th, void *attr, void *(*callback)(void*), void * param) {
+  SCOPED_INTERCEPTOR_RAW(pthread_create, th, attr, callback, param);
+  if (ctx->after_multithreaded_fork) {
+    if (flags()->die_after_fork) {
+      Report("ThreadSanitizer: starting new threads after multi-threaded "
+          "fork is not supported. Dying (set die_after_fork=0 to override)\n");
+      Die();
+    } else {
+      VPrintf(1, "ThreadSanitizer: starting new threads after multi-threaded "
+          "fork is not supported (pid %d). Continuing because of "
+          "die_after_fork=0, but you are on your own\n", internal_getpid());
+    }
+  }
+  __sanitizer_pthread_attr_t myattr;
+  if (attr == 0) {
+    pthread_attr_init(&myattr);
+    attr = &myattr;
+  }
+  int detached = 0;
+  REAL(pthread_attr_getdetachstate)(attr, &detached);
+  AdjustStackSize(attr);
+
+  ThreadParam p;
+  p.callback = callback;
+  p.param = param;
+  atomic_store(&p.tid, 0, memory_order_relaxed);
+  int res = -1;
+  {
+    // Otherwise we see false positives in pthread stack manipulation.
+    ScopedIgnoreInterceptors ignore;
+    ThreadIgnoreBegin(thr, pc);
+    res = REAL(pthread_create)(th, attr, __tsan_thread_start_func, &p);
+    ThreadIgnoreEnd(thr, pc);
+  }
+  if (res == 0) {
+    int tid = ThreadCreate(thr, pc, *(uptr*)th,
+                           detached == PTHREAD_CREATE_DETACHED);
+    CHECK_NE(tid, 0);
+    // Synchronization on p.tid serves two purposes:
+    // 1. ThreadCreate must finish before the new thread starts.
+    //    Otherwise the new thread can call pthread_detach, but the pthread_t
+    //    identifier is not yet registered in ThreadRegistry by ThreadCreate.
+    // 2. ThreadStart must finish before this thread continues.
+    //    Otherwise, this thread can call pthread_detach and reset thr->sync
+    //    before the new thread got a chance to acquire from it in ThreadStart.
+    atomic_store(&p.tid, tid, memory_order_release);
+    while (atomic_load(&p.tid, memory_order_acquire) != 0)
+      internal_sched_yield();
+  }
+  if (attr == &myattr)
+    pthread_attr_destroy(&myattr);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) {
+  SCOPED_INTERCEPTOR_RAW(pthread_join, th, ret);
+  int tid = ThreadTid(thr, pc, (uptr)th);
+  ThreadIgnoreBegin(thr, pc);
+  int res = BLOCK_REAL(pthread_join)(th, ret);
+  ThreadIgnoreEnd(thr, pc);
+  if (res == 0) {
+    ThreadJoin(thr, pc, tid);
+  }
+  return res;
+}
+
+DEFINE_REAL_PTHREAD_FUNCTIONS
+
+TSAN_INTERCEPTOR(int, pthread_detach, void *th) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_detach, th);
+  int tid = ThreadTid(thr, pc, (uptr)th);
+  int res = REAL(pthread_detach)(th);
+  if (res == 0) {
+    ThreadDetach(thr, pc, tid);
+  }
+  return res;
+}
+
+// Problem:
+// NPTL implementation of pthread_cond has 2 versions (2.2.5 and 2.3.2).
+// pthread_cond_t has different size in the different versions.
+// If call new REAL functions for old pthread_cond_t, they will corrupt memory
+// after pthread_cond_t (old cond is smaller).
+// If we call old REAL functions for new pthread_cond_t, we will lose  some
+// functionality (e.g. old functions do not support waiting against
+// CLOCK_REALTIME).
+// Proper handling would require to have 2 versions of interceptors as well.
+// But this is messy, in particular requires linker scripts when sanitizer
+// runtime is linked into a shared library.
+// Instead we assume we don't have dynamic libraries built against old
+// pthread (2.2.5 is dated by 2002). And provide legacy_pthread_cond flag
+// that allows to work with old libraries (but this mode does not support
+// some features, e.g. pthread_condattr_getpshared).
+static void *init_cond(void *c, bool force = false) {
+  // sizeof(pthread_cond_t) >= sizeof(uptr) in both versions.
+  // So we allocate additional memory on the side large enough to hold
+  // any pthread_cond_t object. Always call new REAL functions, but pass
+  // the aux object to them.
+  // Note: the code assumes that PTHREAD_COND_INITIALIZER initializes
+  // first word of pthread_cond_t to zero.
+  // It's all relevant only for linux.
+  if (!common_flags()->legacy_pthread_cond)
+    return c;
+  atomic_uintptr_t *p = (atomic_uintptr_t*)c;
+  uptr cond = atomic_load(p, memory_order_acquire);
+  if (!force && cond != 0)
+    return (void*)cond;
+  void *newcond = WRAP(malloc)(pthread_cond_t_sz);
+  internal_memset(newcond, 0, pthread_cond_t_sz);
+  if (atomic_compare_exchange_strong(p, &cond, (uptr)newcond,
+      memory_order_acq_rel))
+    return newcond;
+  WRAP(free)(newcond);
+  return (void*)cond;
+}
+
+struct CondMutexUnlockCtx {
+  ScopedInterceptor *si;
+  ThreadState *thr;
+  uptr pc;
+  void *m;
+};
+
+static void cond_mutex_unlock(CondMutexUnlockCtx *arg) {
+  // pthread_cond_wait interceptor has enabled async signal delivery
+  // (see BlockingCall below). Disable async signals since we are running
+  // tsan code. Also ScopedInterceptor and BlockingCall destructors won't run
+  // since the thread is cancelled, so we have to manually execute them
+  // (the thread still can run some user code due to pthread_cleanup_push).
+  ThreadSignalContext *ctx = SigCtx(arg->thr);
+  CHECK_EQ(atomic_load(&ctx->in_blocking_func, memory_order_relaxed), 1);
+  atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
+  MutexLock(arg->thr, arg->pc, (uptr)arg->m);
+  // Undo BlockingCall ctor effects.
+  arg->thr->ignore_interceptors--;
+  arg->si->~ScopedInterceptor();
+}
+
+INTERCEPTOR(int, pthread_cond_init, void *c, void *a) {
+  void *cond = init_cond(c, true);
+  SCOPED_TSAN_INTERCEPTOR(pthread_cond_init, cond, a);
+  MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true);
+  return REAL(pthread_cond_init)(cond, a);
+}
+
+INTERCEPTOR(int, pthread_cond_wait, void *c, void *m) {
+  void *cond = init_cond(c);
+  SCOPED_TSAN_INTERCEPTOR(pthread_cond_wait, cond, m);
+  MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
+  MutexUnlock(thr, pc, (uptr)m);
+  CondMutexUnlockCtx arg = {&si, thr, pc, m};
+  int res = 0;
+  // This ensures that we handle mutex lock even in case of pthread_cancel.
+  // See test/tsan/cond_cancel.cc.
+  {
+    // Enable signal delivery while the thread is blocked.
+    BlockingCall bc(thr);
+    res = call_pthread_cancel_with_cleanup(
+        (int(*)(void *c, void *m, void *abstime))REAL(pthread_cond_wait),
+        cond, m, 0, (void(*)(void *arg))cond_mutex_unlock, &arg);
+  }
+  if (res == errno_EOWNERDEAD)
+    MutexRepair(thr, pc, (uptr)m);
+  MutexLock(thr, pc, (uptr)m);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_cond_timedwait, void *c, void *m, void *abstime) {
+  void *cond = init_cond(c);
+  SCOPED_TSAN_INTERCEPTOR(pthread_cond_timedwait, cond, m, abstime);
+  MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
+  MutexUnlock(thr, pc, (uptr)m);
+  CondMutexUnlockCtx arg = {&si, thr, pc, m};
+  int res = 0;
+  // This ensures that we handle mutex lock even in case of pthread_cancel.
+  // See test/tsan/cond_cancel.cc.
+  {
+    BlockingCall bc(thr);
+    res = call_pthread_cancel_with_cleanup(
+        REAL(pthread_cond_timedwait), cond, m, abstime,
+        (void(*)(void *arg))cond_mutex_unlock, &arg);
+  }
+  if (res == errno_EOWNERDEAD)
+    MutexRepair(thr, pc, (uptr)m);
+  MutexLock(thr, pc, (uptr)m);
+  return res;
+}
+
+INTERCEPTOR(int, pthread_cond_signal, void *c) {
+  void *cond = init_cond(c);
+  SCOPED_TSAN_INTERCEPTOR(pthread_cond_signal, cond);
+  MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
+  return REAL(pthread_cond_signal)(cond);
+}
+
+INTERCEPTOR(int, pthread_cond_broadcast, void *c) {
+  void *cond = init_cond(c);
+  SCOPED_TSAN_INTERCEPTOR(pthread_cond_broadcast, cond);
+  MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
+  return REAL(pthread_cond_broadcast)(cond);
+}
+
+INTERCEPTOR(int, pthread_cond_destroy, void *c) {
+  void *cond = init_cond(c);
+  SCOPED_TSAN_INTERCEPTOR(pthread_cond_destroy, cond);
+  MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true);
+  int res = REAL(pthread_cond_destroy)(cond);
+  if (common_flags()->legacy_pthread_cond) {
+    // Free our aux cond and zero the pointer to not leave dangling pointers.
+    WRAP(free)(cond);
+    atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_mutex_init, void *m, void *a) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_mutex_init, m, a);
+  int res = REAL(pthread_mutex_init)(m, a);
+  if (res == 0) {
+    bool recursive = false;
+    if (a) {
+      int type = 0;
+      if (REAL(pthread_mutexattr_gettype)(a, &type) == 0)
+        recursive = (type == PTHREAD_MUTEX_RECURSIVE
+            || type == PTHREAD_MUTEX_RECURSIVE_NP);
+    }
+    MutexCreate(thr, pc, (uptr)m, false, recursive, false);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_mutex_destroy, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_mutex_destroy, m);
+  int res = REAL(pthread_mutex_destroy)(m);
+  if (res == 0 || res == EBUSY) {
+    MutexDestroy(thr, pc, (uptr)m);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_mutex_trylock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_mutex_trylock, m);
+  int res = REAL(pthread_mutex_trylock)(m);
+  if (res == EOWNERDEAD)
+    MutexRepair(thr, pc, (uptr)m);
+  if (res == 0 || res == EOWNERDEAD)
+    MutexLock(thr, pc, (uptr)m, /*rec=*/1, /*try_lock=*/true);
+  return res;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, pthread_mutex_timedlock, void *m, void *abstime) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_mutex_timedlock, m, abstime);
+  int res = REAL(pthread_mutex_timedlock)(m, abstime);
+  if (res == 0) {
+    MutexLock(thr, pc, (uptr)m);
+  }
+  return res;
+}
+#endif
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, pthread_spin_init, void *m, int pshared) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_spin_init, m, pshared);
+  int res = REAL(pthread_spin_init)(m, pshared);
+  if (res == 0) {
+    MutexCreate(thr, pc, (uptr)m, false, false, false);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_spin_destroy, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_spin_destroy, m);
+  int res = REAL(pthread_spin_destroy)(m);
+  if (res == 0) {
+    MutexDestroy(thr, pc, (uptr)m);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_spin_lock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_spin_lock, m);
+  int res = REAL(pthread_spin_lock)(m);
+  if (res == 0) {
+    MutexLock(thr, pc, (uptr)m);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_spin_trylock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_spin_trylock, m);
+  int res = REAL(pthread_spin_trylock)(m);
+  if (res == 0) {
+    MutexLock(thr, pc, (uptr)m, /*rec=*/1, /*try_lock=*/true);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_spin_unlock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_spin_unlock, m);
+  MutexUnlock(thr, pc, (uptr)m);
+  int res = REAL(pthread_spin_unlock)(m);
+  return res;
+}
+#endif
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_init, void *m, void *a) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_init, m, a);
+  int res = REAL(pthread_rwlock_init)(m, a);
+  if (res == 0) {
+    MutexCreate(thr, pc, (uptr)m, true, false, false);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_destroy, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_destroy, m);
+  int res = REAL(pthread_rwlock_destroy)(m);
+  if (res == 0) {
+    MutexDestroy(thr, pc, (uptr)m);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_rdlock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_rdlock, m);
+  int res = REAL(pthread_rwlock_rdlock)(m);
+  if (res == 0) {
+    MutexReadLock(thr, pc, (uptr)m);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_tryrdlock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_tryrdlock, m);
+  int res = REAL(pthread_rwlock_tryrdlock)(m);
+  if (res == 0) {
+    MutexReadLock(thr, pc, (uptr)m, /*try_lock=*/true);
+  }
+  return res;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, pthread_rwlock_timedrdlock, void *m, void *abstime) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_timedrdlock, m, abstime);
+  int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
+  if (res == 0) {
+    MutexReadLock(thr, pc, (uptr)m);
+  }
+  return res;
+}
+#endif
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_wrlock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_wrlock, m);
+  int res = REAL(pthread_rwlock_wrlock)(m);
+  if (res == 0) {
+    MutexLock(thr, pc, (uptr)m);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_trywrlock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_trywrlock, m);
+  int res = REAL(pthread_rwlock_trywrlock)(m);
+  if (res == 0) {
+    MutexLock(thr, pc, (uptr)m, /*rec=*/1, /*try_lock=*/true);
+  }
+  return res;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, pthread_rwlock_timedwrlock, void *m, void *abstime) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_timedwrlock, m, abstime);
+  int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
+  if (res == 0) {
+    MutexLock(thr, pc, (uptr)m);
+  }
+  return res;
+}
+#endif
+
+TSAN_INTERCEPTOR(int, pthread_rwlock_unlock, void *m) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_unlock, m);
+  MutexReadOrWriteUnlock(thr, pc, (uptr)m);
+  int res = REAL(pthread_rwlock_unlock)(m);
+  return res;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, pthread_barrier_init, void *b, void *a, unsigned count) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_barrier_init, b, a, count);
+  MemoryWrite(thr, pc, (uptr)b, kSizeLog1);
+  int res = REAL(pthread_barrier_init)(b, a, count);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_barrier_destroy, void *b) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_barrier_destroy, b);
+  MemoryWrite(thr, pc, (uptr)b, kSizeLog1);
+  int res = REAL(pthread_barrier_destroy)(b);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_barrier_wait, void *b) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_barrier_wait, b);
+  Release(thr, pc, (uptr)b);
+  MemoryRead(thr, pc, (uptr)b, kSizeLog1);
+  int res = REAL(pthread_barrier_wait)(b);
+  MemoryRead(thr, pc, (uptr)b, kSizeLog1);
+  if (res == 0 || res == PTHREAD_BARRIER_SERIAL_THREAD) {
+    Acquire(thr, pc, (uptr)b);
+  }
+  return res;
+}
+#endif
+
+TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) {
+  SCOPED_INTERCEPTOR_RAW(pthread_once, o, f);
+  if (o == 0 || f == 0)
+    return EINVAL;
+  atomic_uint32_t *a;
+  if (!SANITIZER_MAC)
+    a = static_cast<atomic_uint32_t*>(o);
+  else  // On OS X, pthread_once_t has a header with a long-sized signature.
+    a = static_cast<atomic_uint32_t*>((void *)((char *)o + sizeof(long_t)));
+  u32 v = atomic_load(a, memory_order_acquire);
+  if (v == 0 && atomic_compare_exchange_strong(a, &v, 1,
+                                               memory_order_relaxed)) {
+    (*f)();
+    if (!thr->in_ignored_lib)
+      Release(thr, pc, (uptr)o);
+    atomic_store(a, 2, memory_order_release);
+  } else {
+    while (v != 2) {
+      internal_sched_yield();
+      v = atomic_load(a, memory_order_acquire);
+    }
+    if (!thr->in_ignored_lib)
+      Acquire(thr, pc, (uptr)o);
+  }
+  return 0;
+}
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, __xstat, int version, const char *path, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__xstat, version, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__xstat)(version, path, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___XSTAT TSAN_INTERCEPT(__xstat)
+#else
+#define TSAN_MAYBE_INTERCEPT___XSTAT
+#endif
+
+TSAN_INTERCEPTOR(int, stat, const char *path, void *buf) {
+#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_ANDROID
+  SCOPED_TSAN_INTERCEPTOR(stat, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(stat)(path, buf);
+#else
+  SCOPED_TSAN_INTERCEPTOR(__xstat, 0, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__xstat)(0, path, buf);
+#endif
+}
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, __xstat64, int version, const char *path, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__xstat64, version, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__xstat64)(version, path, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___XSTAT64 TSAN_INTERCEPT(__xstat64)
+#else
+#define TSAN_MAYBE_INTERCEPT___XSTAT64
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, stat64, const char *path, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__xstat64, 0, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__xstat64)(0, path, buf);
+}
+#define TSAN_MAYBE_INTERCEPT_STAT64 TSAN_INTERCEPT(stat64)
+#else
+#define TSAN_MAYBE_INTERCEPT_STAT64
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, __lxstat, int version, const char *path, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__lxstat, version, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__lxstat)(version, path, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___LXSTAT TSAN_INTERCEPT(__lxstat)
+#else
+#define TSAN_MAYBE_INTERCEPT___LXSTAT
+#endif
+
+TSAN_INTERCEPTOR(int, lstat, const char *path, void *buf) {
+#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_ANDROID
+  SCOPED_TSAN_INTERCEPTOR(lstat, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(lstat)(path, buf);
+#else
+  SCOPED_TSAN_INTERCEPTOR(__lxstat, 0, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__lxstat)(0, path, buf);
+#endif
+}
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, __lxstat64, int version, const char *path, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__lxstat64, version, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__lxstat64)(version, path, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___LXSTAT64 TSAN_INTERCEPT(__lxstat64)
+#else
+#define TSAN_MAYBE_INTERCEPT___LXSTAT64
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, lstat64, const char *path, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__lxstat64, 0, path, buf);
+  READ_STRING(thr, pc, path, 0);
+  return REAL(__lxstat64)(0, path, buf);
+}
+#define TSAN_MAYBE_INTERCEPT_LSTAT64 TSAN_INTERCEPT(lstat64)
+#else
+#define TSAN_MAYBE_INTERCEPT_LSTAT64
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, __fxstat, int version, int fd, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__fxstat, version, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(__fxstat)(version, fd, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___FXSTAT TSAN_INTERCEPT(__fxstat)
+#else
+#define TSAN_MAYBE_INTERCEPT___FXSTAT
+#endif
+
+TSAN_INTERCEPTOR(int, fstat, int fd, void *buf) {
+#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_ANDROID
+  SCOPED_TSAN_INTERCEPTOR(fstat, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(fstat)(fd, buf);
+#else
+  SCOPED_TSAN_INTERCEPTOR(__fxstat, 0, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(__fxstat)(0, fd, buf);
+#endif
+}
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, __fxstat64, int version, int fd, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__fxstat64, version, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(__fxstat64)(version, fd, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___FXSTAT64 TSAN_INTERCEPT(__fxstat64)
+#else
+#define TSAN_MAYBE_INTERCEPT___FXSTAT64
+#endif
+
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(int, fstat64, int fd, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__fxstat64, 0, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(__fxstat64)(0, fd, buf);
+}
+#define TSAN_MAYBE_INTERCEPT_FSTAT64 TSAN_INTERCEPT(fstat64)
+#else
+#define TSAN_MAYBE_INTERCEPT_FSTAT64
+#endif
+
+TSAN_INTERCEPTOR(int, open, const char *name, int flags, int mode) {
+  SCOPED_TSAN_INTERCEPTOR(open, name, flags, mode);
+  READ_STRING(thr, pc, name, 0);
+  int fd = REAL(open)(name, flags, mode);
+  if (fd >= 0)
+    FdFileCreate(thr, pc, fd);
+  return fd;
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, open64, const char *name, int flags, int mode) {
+  SCOPED_TSAN_INTERCEPTOR(open64, name, flags, mode);
+  READ_STRING(thr, pc, name, 0);
+  int fd = REAL(open64)(name, flags, mode);
+  if (fd >= 0)
+    FdFileCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_OPEN64 TSAN_INTERCEPT(open64)
+#else
+#define TSAN_MAYBE_INTERCEPT_OPEN64
+#endif
+
+TSAN_INTERCEPTOR(int, creat, const char *name, int mode) {
+  SCOPED_TSAN_INTERCEPTOR(creat, name, mode);
+  READ_STRING(thr, pc, name, 0);
+  int fd = REAL(creat)(name, mode);
+  if (fd >= 0)
+    FdFileCreate(thr, pc, fd);
+  return fd;
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, creat64, const char *name, int mode) {
+  SCOPED_TSAN_INTERCEPTOR(creat64, name, mode);
+  READ_STRING(thr, pc, name, 0);
+  int fd = REAL(creat64)(name, mode);
+  if (fd >= 0)
+    FdFileCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_CREAT64 TSAN_INTERCEPT(creat64)
+#else
+#define TSAN_MAYBE_INTERCEPT_CREAT64
+#endif
+
+TSAN_INTERCEPTOR(int, dup, int oldfd) {
+  SCOPED_TSAN_INTERCEPTOR(dup, oldfd);
+  int newfd = REAL(dup)(oldfd);
+  if (oldfd >= 0 && newfd >= 0 && newfd != oldfd)
+    FdDup(thr, pc, oldfd, newfd, true);
+  return newfd;
+}
+
+TSAN_INTERCEPTOR(int, dup2, int oldfd, int newfd) {
+  SCOPED_TSAN_INTERCEPTOR(dup2, oldfd, newfd);
+  int newfd2 = REAL(dup2)(oldfd, newfd);
+  if (oldfd >= 0 && newfd2 >= 0 && newfd2 != oldfd)
+    FdDup(thr, pc, oldfd, newfd2, false);
+  return newfd2;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, dup3, int oldfd, int newfd, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(dup3, oldfd, newfd, flags);
+  int newfd2 = REAL(dup3)(oldfd, newfd, flags);
+  if (oldfd >= 0 && newfd2 >= 0 && newfd2 != oldfd)
+    FdDup(thr, pc, oldfd, newfd2, false);
+  return newfd2;
+}
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, eventfd, unsigned initval, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(eventfd, initval, flags);
+  int fd = REAL(eventfd)(initval, flags);
+  if (fd >= 0)
+    FdEventCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_EVENTFD TSAN_INTERCEPT(eventfd)
+#else
+#define TSAN_MAYBE_INTERCEPT_EVENTFD
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, signalfd, int fd, void *mask, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(signalfd, fd, mask, flags);
+  if (fd >= 0)
+    FdClose(thr, pc, fd);
+  fd = REAL(signalfd)(fd, mask, flags);
+  if (fd >= 0)
+    FdSignalCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_SIGNALFD TSAN_INTERCEPT(signalfd)
+#else
+#define TSAN_MAYBE_INTERCEPT_SIGNALFD
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, inotify_init, int fake) {
+  SCOPED_TSAN_INTERCEPTOR(inotify_init, fake);
+  int fd = REAL(inotify_init)(fake);
+  if (fd >= 0)
+    FdInotifyCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_INOTIFY_INIT TSAN_INTERCEPT(inotify_init)
+#else
+#define TSAN_MAYBE_INTERCEPT_INOTIFY_INIT
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, inotify_init1, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(inotify_init1, flags);
+  int fd = REAL(inotify_init1)(flags);
+  if (fd >= 0)
+    FdInotifyCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_INOTIFY_INIT1 TSAN_INTERCEPT(inotify_init1)
+#else
+#define TSAN_MAYBE_INTERCEPT_INOTIFY_INIT1
+#endif
+
+TSAN_INTERCEPTOR(int, socket, int domain, int type, int protocol) {
+  SCOPED_TSAN_INTERCEPTOR(socket, domain, type, protocol);
+  int fd = REAL(socket)(domain, type, protocol);
+  if (fd >= 0)
+    FdSocketCreate(thr, pc, fd);
+  return fd;
+}
+
+TSAN_INTERCEPTOR(int, socketpair, int domain, int type, int protocol, int *fd) {
+  SCOPED_TSAN_INTERCEPTOR(socketpair, domain, type, protocol, fd);
+  int res = REAL(socketpair)(domain, type, protocol, fd);
+  if (res == 0 && fd[0] >= 0 && fd[1] >= 0)
+    FdPipeCreate(thr, pc, fd[0], fd[1]);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, connect, int fd, void *addr, unsigned addrlen) {
+  SCOPED_TSAN_INTERCEPTOR(connect, fd, addr, addrlen);
+  FdSocketConnecting(thr, pc, fd);
+  int res = REAL(connect)(fd, addr, addrlen);
+  if (res == 0 && fd >= 0)
+    FdSocketConnect(thr, pc, fd);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, bind, int fd, void *addr, unsigned addrlen) {
+  SCOPED_TSAN_INTERCEPTOR(bind, fd, addr, addrlen);
+  int res = REAL(bind)(fd, addr, addrlen);
+  if (fd > 0 && res == 0)
+    FdAccess(thr, pc, fd);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, listen, int fd, int backlog) {
+  SCOPED_TSAN_INTERCEPTOR(listen, fd, backlog);
+  int res = REAL(listen)(fd, backlog);
+  if (fd > 0 && res == 0)
+    FdAccess(thr, pc, fd);
+  return res;
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, epoll_create, int size) {
+  SCOPED_TSAN_INTERCEPTOR(epoll_create, size);
+  int fd = REAL(epoll_create)(size);
+  if (fd >= 0)
+    FdPollCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_EPOLL_CREATE TSAN_INTERCEPT(epoll_create)
+#else
+#define TSAN_MAYBE_INTERCEPT_EPOLL_CREATE
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, epoll_create1, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(epoll_create1, flags);
+  int fd = REAL(epoll_create1)(flags);
+  if (fd >= 0)
+    FdPollCreate(thr, pc, fd);
+  return fd;
+}
+#define TSAN_MAYBE_INTERCEPT_EPOLL_CREATE1 TSAN_INTERCEPT(epoll_create1)
+#else
+#define TSAN_MAYBE_INTERCEPT_EPOLL_CREATE1
+#endif
+
+TSAN_INTERCEPTOR(int, close, int fd) {
+  SCOPED_TSAN_INTERCEPTOR(close, fd);
+  if (fd >= 0)
+    FdClose(thr, pc, fd);
+  return REAL(close)(fd);
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, __close, int fd) {
+  SCOPED_TSAN_INTERCEPTOR(__close, fd);
+  if (fd >= 0)
+    FdClose(thr, pc, fd);
+  return REAL(__close)(fd);
+}
+#define TSAN_MAYBE_INTERCEPT___CLOSE TSAN_INTERCEPT(__close)
+#else
+#define TSAN_MAYBE_INTERCEPT___CLOSE
+#endif
+
+// glibc guts
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+TSAN_INTERCEPTOR(void, __res_iclose, void *state, bool free_addr) {
+  SCOPED_TSAN_INTERCEPTOR(__res_iclose, state, free_addr);
+  int fds[64];
+  int cnt = ExtractResolvFDs(state, fds, ARRAY_SIZE(fds));
+  for (int i = 0; i < cnt; i++) {
+    if (fds[i] > 0)
+      FdClose(thr, pc, fds[i]);
+  }
+  REAL(__res_iclose)(state, free_addr);
+}
+#define TSAN_MAYBE_INTERCEPT___RES_ICLOSE TSAN_INTERCEPT(__res_iclose)
+#else
+#define TSAN_MAYBE_INTERCEPT___RES_ICLOSE
+#endif
+
+TSAN_INTERCEPTOR(int, pipe, int *pipefd) {
+  SCOPED_TSAN_INTERCEPTOR(pipe, pipefd);
+  int res = REAL(pipe)(pipefd);
+  if (res == 0 && pipefd[0] >= 0 && pipefd[1] >= 0)
+    FdPipeCreate(thr, pc, pipefd[0], pipefd[1]);
+  return res;
+}
+
+#if !SANITIZER_MAC
+TSAN_INTERCEPTOR(int, pipe2, int *pipefd, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(pipe2, pipefd, flags);
+  int res = REAL(pipe2)(pipefd, flags);
+  if (res == 0 && pipefd[0] >= 0 && pipefd[1] >= 0)
+    FdPipeCreate(thr, pc, pipefd[0], pipefd[1]);
+  return res;
+}
+#endif
+
+TSAN_INTERCEPTOR(long_t, send, int fd, void *buf, long_t len, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(send, fd, buf, len, flags);
+  if (fd >= 0) {
+    FdAccess(thr, pc, fd);
+    FdRelease(thr, pc, fd);
+  }
+  int res = REAL(send)(fd, buf, len, flags);
+  return res;
+}
+
+TSAN_INTERCEPTOR(long_t, sendmsg, int fd, void *msg, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(sendmsg, fd, msg, flags);
+  if (fd >= 0) {
+    FdAccess(thr, pc, fd);
+    FdRelease(thr, pc, fd);
+  }
+  int res = REAL(sendmsg)(fd, msg, flags);
+  return res;
+}
+
+TSAN_INTERCEPTOR(long_t, recv, int fd, void *buf, long_t len, int flags) {
+  SCOPED_TSAN_INTERCEPTOR(recv, fd, buf, len, flags);
+  if (fd >= 0)
+    FdAccess(thr, pc, fd);
+  int res = REAL(recv)(fd, buf, len, flags);
+  if (res >= 0 && fd >= 0) {
+    FdAcquire(thr, pc, fd);
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, unlink, char *path) {
+  SCOPED_TSAN_INTERCEPTOR(unlink, path);
+  Release(thr, pc, File2addr(path));
+  int res = REAL(unlink)(path);
+  return res;
+}
+
+TSAN_INTERCEPTOR(void*, tmpfile, int fake) {
+  SCOPED_TSAN_INTERCEPTOR(tmpfile, fake);
+  void *res = REAL(tmpfile)(fake);
+  if (res) {
+    int fd = fileno_unlocked(res);
+    if (fd >= 0)
+      FdFileCreate(thr, pc, fd);
+  }
+  return res;
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(void*, tmpfile64, int fake) {
+  SCOPED_TSAN_INTERCEPTOR(tmpfile64, fake);
+  void *res = REAL(tmpfile64)(fake);
+  if (res) {
+    int fd = fileno_unlocked(res);
+    if (fd >= 0)
+      FdFileCreate(thr, pc, fd);
+  }
+  return res;
+}
+#define TSAN_MAYBE_INTERCEPT_TMPFILE64 TSAN_INTERCEPT(tmpfile64)
+#else
+#define TSAN_MAYBE_INTERCEPT_TMPFILE64
+#endif
+
+TSAN_INTERCEPTOR(uptr, fread, void *ptr, uptr size, uptr nmemb, void *f) {
+  // libc file streams can call user-supplied functions, see fopencookie.
+  {
+    SCOPED_TSAN_INTERCEPTOR(fread, ptr, size, nmemb, f);
+    MemoryAccessRange(thr, pc, (uptr)ptr, size * nmemb, true);
+  }
+  return REAL(fread)(ptr, size, nmemb, f);
+}
+
+TSAN_INTERCEPTOR(uptr, fwrite, const void *p, uptr size, uptr nmemb, void *f) {
+  // libc file streams can call user-supplied functions, see fopencookie.
+  {
+    SCOPED_TSAN_INTERCEPTOR(fwrite, p, size, nmemb, f);
+    MemoryAccessRange(thr, pc, (uptr)p, size * nmemb, false);
+  }
+  return REAL(fwrite)(p, size, nmemb, f);
+}
+
+static void FlushStreams() {
+  // Flushing all the streams here may freeze the process if a child thread is
+  // performing file stream operations at the same time.
+  REAL(fflush)(stdout);
+  REAL(fflush)(stderr);
+}
+
+TSAN_INTERCEPTOR(void, abort, int fake) {
+  SCOPED_TSAN_INTERCEPTOR(abort, fake);
+  FlushStreams();
+  REAL(abort)(fake);
+}
+
+TSAN_INTERCEPTOR(int, puts, const char *s) {
+  SCOPED_TSAN_INTERCEPTOR(puts, s);
+  MemoryAccessRange(thr, pc, (uptr)s, internal_strlen(s), false);
+  return REAL(puts)(s);
+}
+
+TSAN_INTERCEPTOR(int, rmdir, char *path) {
+  SCOPED_TSAN_INTERCEPTOR(rmdir, path);
+  Release(thr, pc, Dir2addr(path));
+  int res = REAL(rmdir)(path);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, closedir, void *dirp) {
+  SCOPED_TSAN_INTERCEPTOR(closedir, dirp);
+  int fd = dirfd(dirp);
+  FdClose(thr, pc, fd);
+  return REAL(closedir)(dirp);
+}
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, epoll_ctl, int epfd, int op, int fd, void *ev) {
+  SCOPED_TSAN_INTERCEPTOR(epoll_ctl, epfd, op, fd, ev);
+  if (epfd >= 0)
+    FdAccess(thr, pc, epfd);
+  if (epfd >= 0 && fd >= 0)
+    FdAccess(thr, pc, fd);
+  if (op == EPOLL_CTL_ADD && epfd >= 0)
+    FdRelease(thr, pc, epfd);
+  int res = REAL(epoll_ctl)(epfd, op, fd, ev);
+  return res;
+}
+#define TSAN_MAYBE_INTERCEPT_EPOLL_CTL TSAN_INTERCEPT(epoll_ctl)
+#else
+#define TSAN_MAYBE_INTERCEPT_EPOLL_CTL
+#endif
+
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, epoll_wait, int epfd, void *ev, int cnt, int timeout) {
+  SCOPED_TSAN_INTERCEPTOR(epoll_wait, epfd, ev, cnt, timeout);
+  if (epfd >= 0)
+    FdAccess(thr, pc, epfd);
+  int res = BLOCK_REAL(epoll_wait)(epfd, ev, cnt, timeout);
+  if (res > 0 && epfd >= 0)
+    FdAcquire(thr, pc, epfd);
+  return res;
+}
+#define TSAN_MAYBE_INTERCEPT_EPOLL_WAIT TSAN_INTERCEPT(epoll_wait)
+#else
+#define TSAN_MAYBE_INTERCEPT_EPOLL_WAIT
+#endif
+
+namespace __tsan {
+
+static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
+    bool sigact, int sig, my_siginfo_t *info, void *uctx) {
+  if (acquire)
+    Acquire(thr, 0, (uptr)&sigactions[sig]);
+  // Ensure that the handler does not spoil errno.
+  const int saved_errno = errno;
+  errno = 99;
+  // This code races with sigaction. Be careful to not read sa_sigaction twice.
+  // Also need to remember pc for reporting before the call,
+  // because the handler can reset it.
+  volatile uptr pc = sigact ?
+     (uptr)sigactions[sig].sa_sigaction :
+     (uptr)sigactions[sig].sa_handler;
+  if (pc != (uptr)SIG_DFL && pc != (uptr)SIG_IGN) {
+    if (sigact)
+      ((sigactionhandler_t)pc)(sig, info, uctx);
+    else
+      ((sighandler_t)pc)(sig);
+  }
+  // We do not detect errno spoiling for SIGTERM,
+  // because some SIGTERM handlers do spoil errno but reraise SIGTERM,
+  // tsan reports false positive in such case.
+  // It's difficult to properly detect this situation (reraise),
+  // because in async signal processing case (when handler is called directly
+  // from rtl_generic_sighandler) we have not yet received the reraised
+  // signal; and it looks too fragile to intercept all ways to reraise a signal.
+  if (flags()->report_bugs && !sync && sig != SIGTERM && errno != 99) {
+    VarSizeStackTrace stack;
+    // StackTrace::GetNestInstructionPc(pc) is used because return address is
+    // expected, OutputReport() will undo this.
+    ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);
+    ThreadRegistryLock l(ctx->thread_registry);
+    ScopedReport rep(ReportTypeErrnoInSignal);
+    if (!IsFiredSuppression(ctx, ReportTypeErrnoInSignal, stack)) {
+      rep.AddStack(stack, true);
+      OutputReport(thr, rep);
+    }
+  }
+  errno = saved_errno;
+}
+
+void ProcessPendingSignals(ThreadState *thr) {
+  ThreadSignalContext *sctx = SigCtx(thr);
+  if (sctx == 0 ||
+      atomic_load(&sctx->have_pending_signals, memory_order_relaxed) == 0)
+    return;
+  atomic_store(&sctx->have_pending_signals, 0, memory_order_relaxed);
+  atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
+  CHECK_EQ(0, REAL(sigfillset)(&sctx->emptyset));
+  CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &sctx->emptyset, &sctx->oldset));
+  for (int sig = 0; sig < kSigCount; sig++) {
+    SignalDesc *signal = &sctx->pending_signals[sig];
+    if (signal->armed) {
+      signal->armed = false;
+      CallUserSignalHandler(thr, false, true, signal->sigaction, sig,
+          &signal->siginfo, &signal->ctx);
+    }
+  }
+  CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &sctx->oldset, 0));
+  atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
+}
+
+}  // namespace __tsan
+
+static bool is_sync_signal(ThreadSignalContext *sctx, int sig) {
+  return sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
+      sig == SIGABRT || sig == SIGFPE || sig == SIGPIPE || sig == SIGSYS ||
+      // If we are sending signal to ourselves, we must process it now.
+      (sctx && sig == sctx->int_signal_send);
+}
+
+void ALWAYS_INLINE rtl_generic_sighandler(bool sigact, int sig,
+    my_siginfo_t *info, void *ctx) {
+  ThreadState *thr = cur_thread();
+  ThreadSignalContext *sctx = SigCtx(thr);
+  if (sig < 0 || sig >= kSigCount) {
+    VPrintf(1, "ThreadSanitizer: ignoring signal %d\n", sig);
+    return;
+  }
+  // Don't mess with synchronous signals.
+  const bool sync = is_sync_signal(sctx, sig);
+  if (sync ||
+      // If we are in blocking function, we can safely process it now
+      // (but check if we are in a recursive interceptor,
+      // i.e. pthread_join()->munmap()).
+      (sctx && atomic_load(&sctx->in_blocking_func, memory_order_relaxed))) {
+    atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
+    if (sctx && atomic_load(&sctx->in_blocking_func, memory_order_relaxed)) {
+      // We ignore interceptors in blocking functions,
+      // temporary enbled them again while we are calling user function.
+      int const i = thr->ignore_interceptors;
+      thr->ignore_interceptors = 0;
+      atomic_store(&sctx->in_blocking_func, 0, memory_order_relaxed);
+      CallUserSignalHandler(thr, sync, true, sigact, sig, info, ctx);
+      thr->ignore_interceptors = i;
+      atomic_store(&sctx->in_blocking_func, 1, memory_order_relaxed);
+    } else {
+      // Be very conservative with when we do acquire in this case.
+      // It's unsafe to do acquire in async handlers, because ThreadState
+      // can be in inconsistent state.
+      // SIGSYS looks relatively safe -- it's synchronous and can actually
+      // need some global state.
+      bool acq = (sig == SIGSYS);
+      CallUserSignalHandler(thr, sync, acq, sigact, sig, info, ctx);
+    }
+    atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
+    return;
+  }
+
+  if (sctx == 0)
+    return;
+  SignalDesc *signal = &sctx->pending_signals[sig];
+  if (signal->armed == false) {
+    signal->armed = true;
+    signal->sigaction = sigact;
+    if (info)
+      internal_memcpy(&signal->siginfo, info, sizeof(*info));
+    if (ctx)
+      internal_memcpy(&signal->ctx, ctx, sizeof(signal->ctx));
+    atomic_store(&sctx->have_pending_signals, 1, memory_order_relaxed);
+  }
+}
+
+static void rtl_sighandler(int sig) {
+  rtl_generic_sighandler(false, sig, 0, 0);
+}
+
+static void rtl_sigaction(int sig, my_siginfo_t *info, void *ctx) {
+  rtl_generic_sighandler(true, sig, info, ctx);
+}
+
+TSAN_INTERCEPTOR(int, sigaction, int sig, sigaction_t *act, sigaction_t *old) {
+  SCOPED_TSAN_INTERCEPTOR(sigaction, sig, act, old);
+  if (old)
+    internal_memcpy(old, &sigactions[sig], sizeof(*old));
+  if (act == 0)
+    return 0;
+  // Copy act into sigactions[sig].
+  // Can't use struct copy, because compiler can emit call to memcpy.
+  // Can't use internal_memcpy, because it copies byte-by-byte,
+  // and signal handler reads the sa_handler concurrently. It it can read
+  // some bytes from old value and some bytes from new value.
+  // Use volatile to prevent insertion of memcpy.
+  sigactions[sig].sa_handler = *(volatile sighandler_t*)&act->sa_handler;
+  sigactions[sig].sa_flags = *(volatile int*)&act->sa_flags;
+  internal_memcpy(&sigactions[sig].sa_mask, &act->sa_mask,
+      sizeof(sigactions[sig].sa_mask));
+#if !SANITIZER_FREEBSD && !SANITIZER_MAC
+  sigactions[sig].sa_restorer = act->sa_restorer;
+#endif
+  sigaction_t newact;
+  internal_memcpy(&newact, act, sizeof(newact));
+  REAL(sigfillset)(&newact.sa_mask);
+  if (act->sa_handler != SIG_IGN && act->sa_handler != SIG_DFL) {
+    if (newact.sa_flags & SA_SIGINFO)
+      newact.sa_sigaction = rtl_sigaction;
+    else
+      newact.sa_handler = rtl_sighandler;
+  }
+  ReleaseStore(thr, pc, (uptr)&sigactions[sig]);
+  int res = REAL(sigaction)(sig, &newact, 0);
+  return res;
+}
+
+TSAN_INTERCEPTOR(sighandler_t, signal, int sig, sighandler_t h) {
+  sigaction_t act;
+  act.sa_handler = h;
+  REAL(memset)(&act.sa_mask, -1, sizeof(act.sa_mask));
+  act.sa_flags = 0;
+  sigaction_t old;
+  int res = sigaction(sig, &act, &old);
+  if (res)
+    return SIG_ERR;
+  return old.sa_handler;
+}
+
+TSAN_INTERCEPTOR(int, sigsuspend, const __sanitizer_sigset_t *mask) {
+  SCOPED_TSAN_INTERCEPTOR(sigsuspend, mask);
+  return REAL(sigsuspend)(mask);
+}
+
+TSAN_INTERCEPTOR(int, raise, int sig) {
+  SCOPED_TSAN_INTERCEPTOR(raise, sig);
+  ThreadSignalContext *sctx = SigCtx(thr);
+  CHECK_NE(sctx, 0);
+  int prev = sctx->int_signal_send;
+  sctx->int_signal_send = sig;
+  int res = REAL(raise)(sig);
+  CHECK_EQ(sctx->int_signal_send, sig);
+  sctx->int_signal_send = prev;
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, kill, int pid, int sig) {
+  SCOPED_TSAN_INTERCEPTOR(kill, pid, sig);
+  ThreadSignalContext *sctx = SigCtx(thr);
+  CHECK_NE(sctx, 0);
+  int prev = sctx->int_signal_send;
+  if (pid == (int)internal_getpid()) {
+    sctx->int_signal_send = sig;
+  }
+  int res = REAL(kill)(pid, sig);
+  if (pid == (int)internal_getpid()) {
+    CHECK_EQ(sctx->int_signal_send, sig);
+    sctx->int_signal_send = prev;
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, pthread_kill, void *tid, int sig) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_kill, tid, sig);
+  ThreadSignalContext *sctx = SigCtx(thr);
+  CHECK_NE(sctx, 0);
+  int prev = sctx->int_signal_send;
+  if (tid == pthread_self()) {
+    sctx->int_signal_send = sig;
+  }
+  int res = REAL(pthread_kill)(tid, sig);
+  if (tid == pthread_self()) {
+    CHECK_EQ(sctx->int_signal_send, sig);
+    sctx->int_signal_send = prev;
+  }
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, gettimeofday, void *tv, void *tz) {
+  SCOPED_TSAN_INTERCEPTOR(gettimeofday, tv, tz);
+  // It's intercepted merely to process pending signals.
+  return REAL(gettimeofday)(tv, tz);
+}
+
+TSAN_INTERCEPTOR(int, getaddrinfo, void *node, void *service,
+    void *hints, void *rv) {
+  SCOPED_TSAN_INTERCEPTOR(getaddrinfo, node, service, hints, rv);
+  // We miss atomic synchronization in getaddrinfo,
+  // and can report false race between malloc and free
+  // inside of getaddrinfo. So ignore memory accesses.
+  ThreadIgnoreBegin(thr, pc);
+  int res = REAL(getaddrinfo)(node, service, hints, rv);
+  ThreadIgnoreEnd(thr, pc);
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, fork, int fake) {
+  if (cur_thread()->in_symbolizer)
+    return REAL(fork)(fake);
+  SCOPED_INTERCEPTOR_RAW(fork, fake);
+  ForkBefore(thr, pc);
+  int pid = REAL(fork)(fake);
+  if (pid == 0) {
+    // child
+    ForkChildAfter(thr, pc);
+    FdOnFork(thr, pc);
+  } else if (pid > 0) {
+    // parent
+    ForkParentAfter(thr, pc);
+  } else {
+    // error
+    ForkParentAfter(thr, pc);
+  }
+  return pid;
+}
+
+TSAN_INTERCEPTOR(int, vfork, int fake) {
+  // Some programs (e.g. openjdk) call close for all file descriptors
+  // in the child process. Under tsan it leads to false positives, because
+  // address space is shared, so the parent process also thinks that
+  // the descriptors are closed (while they are actually not).
+  // This leads to false positives due to missed synchronization.
+  // Strictly saying this is undefined behavior, because vfork child is not
+  // allowed to call any functions other than exec/exit. But this is what
+  // openjdk does, so we want to handle it.
+  // We could disable interceptors in the child process. But it's not possible
+  // to simply intercept and wrap vfork, because vfork child is not allowed
+  // to return from the function that calls vfork, and that's exactly what
+  // we would do. So this would require some assembly trickery as well.
+  // Instead we simply turn vfork into fork.
+  return WRAP(fork)(fake);
+}
+
+#if !SANITIZER_MAC && !SANITIZER_ANDROID
+typedef int (*dl_iterate_phdr_cb_t)(__sanitizer_dl_phdr_info *info, SIZE_T size,
+                                    void *data);
+struct dl_iterate_phdr_data {
+  ThreadState *thr;
+  uptr pc;
+  dl_iterate_phdr_cb_t cb;
+  void *data;
+};
+
+static bool IsAppNotRodata(uptr addr) {
+  return IsAppMem(addr) && *(u64*)MemToShadow(addr) != kShadowRodata;
+}
+
+static int dl_iterate_phdr_cb(__sanitizer_dl_phdr_info *info, SIZE_T size,
+                              void *data) {
+  dl_iterate_phdr_data *cbdata = (dl_iterate_phdr_data *)data;
+  // dlopen/dlclose allocate/free dynamic-linker-internal memory, which is later
+  // accessible in dl_iterate_phdr callback. But we don't see synchronization
+  // inside of dynamic linker, so we "unpoison" it here in order to not
+  // produce false reports. Ignoring malloc/free in dlopen/dlclose is not enough
+  // because some libc functions call __libc_dlopen.
+  if (info && IsAppNotRodata((uptr)info->dlpi_name))
+    MemoryResetRange(cbdata->thr, cbdata->pc, (uptr)info->dlpi_name,
+                     internal_strlen(info->dlpi_name));
+  int res = cbdata->cb(info, size, cbdata->data);
+  // Perform the check one more time in case info->dlpi_name was overwritten
+  // by user callback.
+  if (info && IsAppNotRodata((uptr)info->dlpi_name))
+    MemoryResetRange(cbdata->thr, cbdata->pc, (uptr)info->dlpi_name,
+                     internal_strlen(info->dlpi_name));
+  return res;
+}
+
+TSAN_INTERCEPTOR(int, dl_iterate_phdr, dl_iterate_phdr_cb_t cb, void *data) {
+  SCOPED_TSAN_INTERCEPTOR(dl_iterate_phdr, cb, data);
+  dl_iterate_phdr_data cbdata;
+  cbdata.thr = thr;
+  cbdata.pc = pc;
+  cbdata.cb = cb;
+  cbdata.data = data;
+  int res = REAL(dl_iterate_phdr)(dl_iterate_phdr_cb, &cbdata);
+  return res;
+}
+#endif
+
+static int OnExit(ThreadState *thr) {
+  int status = Finalize(thr);
+  FlushStreams();
+  return status;
+}
+
+struct TsanInterceptorContext {
+  ThreadState *thr;
+  const uptr caller_pc;
+  const uptr pc;
+};
+
+#if !SANITIZER_MAC
+static void HandleRecvmsg(ThreadState *thr, uptr pc,
+    __sanitizer_msghdr *msg) {
+  int fds[64];
+  int cnt = ExtractRecvmsgFDs(msg, fds, ARRAY_SIZE(fds));
+  for (int i = 0; i < cnt; i++)
+    FdEventCreate(thr, pc, fds[i]);
+}
+#endif
+
+#include "sanitizer_common/sanitizer_platform_interceptors.h"
+// Causes interceptor recursion (getaddrinfo() and fopen())
+#undef SANITIZER_INTERCEPT_GETADDRINFO
+// There interceptors do not seem to be strictly necessary for tsan.
+// But we see cases where the interceptors consume 70% of execution time.
+// Memory blocks passed to fgetgrent_r are "written to" by tsan several times.
+// First, there is some recursion (getgrnam_r calls fgetgrent_r), and each
+// function "writes to" the buffer. Then, the same memory is "written to"
+// twice, first as buf and then as pwbufp (both of them refer to the same
+// addresses).
+#undef SANITIZER_INTERCEPT_GETPWENT
+#undef SANITIZER_INTERCEPT_GETPWENT_R
+#undef SANITIZER_INTERCEPT_FGETPWENT
+#undef SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS
+#undef SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS
+// __tls_get_addr can be called with mis-aligned stack due to:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58066
+// There are two potential issues:
+// 1. Sanitizer code contains a MOVDQA spill (it does not seem to be the case
+// right now). or 2. ProcessPendingSignal calls user handler which contains
+// MOVDQA spill (this happens right now).
+// Since the interceptor only initializes memory for msan, the simplest solution
+// is to disable the interceptor in tsan (other sanitizers do not call
+// signal handlers from COMMON_INTERCEPTOR_ENTER).
+#undef SANITIZER_INTERCEPT_TLS_GET_ADDR
+
+#define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
+
+#define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size)                    \
+  MemoryAccessRange(((TsanInterceptorContext *)ctx)->thr,                 \
+                    ((TsanInterceptorContext *)ctx)->pc, (uptr)ptr, size, \
+                    true)
+
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size)                       \
+  MemoryAccessRange(((TsanInterceptorContext *) ctx)->thr,                  \
+                    ((TsanInterceptorContext *) ctx)->pc, (uptr) ptr, size, \
+                    false)
+
+#define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)      \
+  SCOPED_TSAN_INTERCEPTOR(func, __VA_ARGS__);         \
+  TsanInterceptorContext _ctx = {thr, caller_pc, pc}; \
+  ctx = (void *)&_ctx;                                \
+  (void) ctx;
+
+#define COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, func, ...) \
+  SCOPED_INTERCEPTOR_RAW(func, __VA_ARGS__);              \
+  TsanInterceptorContext _ctx = {thr, caller_pc, pc};     \
+  ctx = (void *)&_ctx;                                    \
+  (void) ctx;
+
+#define COMMON_INTERCEPTOR_FILE_OPEN(ctx, file, path) \
+  Acquire(thr, pc, File2addr(path));                  \
+  if (file) {                                         \
+    int fd = fileno_unlocked(file);                   \
+    if (fd >= 0) FdFileCreate(thr, pc, fd);           \
+  }
+
+#define COMMON_INTERCEPTOR_FILE_CLOSE(ctx, file) \
+  if (file) {                                    \
+    int fd = fileno_unlocked(file);              \
+    if (fd >= 0) FdClose(thr, pc, fd);           \
+  }
+
+#define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) \
+  libignore()->OnLibraryLoaded(filename)
+
+#define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() \
+  libignore()->OnLibraryUnloaded()
+
+#define COMMON_INTERCEPTOR_ACQUIRE(ctx, u) \
+  Acquire(((TsanInterceptorContext *) ctx)->thr, pc, u)
+
+#define COMMON_INTERCEPTOR_RELEASE(ctx, u) \
+  Release(((TsanInterceptorContext *) ctx)->thr, pc, u)
+
+#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
+  Acquire(((TsanInterceptorContext *) ctx)->thr, pc, Dir2addr(path))
+
+#define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
+  FdAcquire(((TsanInterceptorContext *) ctx)->thr, pc, fd)
+
+#define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
+  FdRelease(((TsanInterceptorContext *) ctx)->thr, pc, fd)
+
+#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) \
+  FdAccess(((TsanInterceptorContext *) ctx)->thr, pc, fd)
+
+#define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
+  FdSocketAccept(((TsanInterceptorContext *) ctx)->thr, pc, fd, newfd)
+
+#define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) \
+  ThreadSetName(((TsanInterceptorContext *) ctx)->thr, name)
+
+#define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
+  __tsan::ctx->thread_registry->SetThreadNameByUserId(thread, name)
+
+#define COMMON_INTERCEPTOR_BLOCK_REAL(name) BLOCK_REAL(name)
+
+#define COMMON_INTERCEPTOR_ON_EXIT(ctx) \
+  OnExit(((TsanInterceptorContext *) ctx)->thr)
+
+#define COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m) \
+  MutexLock(((TsanInterceptorContext *)ctx)->thr, \
+            ((TsanInterceptorContext *)ctx)->pc, (uptr)m)
+
+#define COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m) \
+  MutexUnlock(((TsanInterceptorContext *)ctx)->thr, \
+            ((TsanInterceptorContext *)ctx)->pc, (uptr)m)
+
+#define COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m) \
+  MutexRepair(((TsanInterceptorContext *)ctx)->thr, \
+            ((TsanInterceptorContext *)ctx)->pc, (uptr)m)
+
+#if !SANITIZER_MAC
+#define COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg) \
+  HandleRecvmsg(((TsanInterceptorContext *)ctx)->thr, \
+      ((TsanInterceptorContext *)ctx)->pc, msg)
+#endif
+
+#define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end)                           \
+  if (TsanThread *t = GetCurrentThread()) {                                    \
+    *begin = t->tls_begin();                                                   \
+    *end = t->tls_end();                                                       \
+  } else {                                                                     \
+    *begin = *end = 0;                                                         \
+  }
+
+#include "sanitizer_common/sanitizer_common_interceptors.inc"
+
+#define TSAN_SYSCALL() \
+  ThreadState *thr = cur_thread(); \
+  if (thr->ignore_interceptors) \
+    return; \
+  ScopedSyscall scoped_syscall(thr) \
+/**/
+
+struct ScopedSyscall {
+  ThreadState *thr;
+
+  explicit ScopedSyscall(ThreadState *thr)
+      : thr(thr) {
+    Initialize(thr);
+  }
+
+  ~ScopedSyscall() {
+    ProcessPendingSignals(thr);
+  }
+};
+
+#if !SANITIZER_MAC
+static void syscall_access_range(uptr pc, uptr p, uptr s, bool write) {
+  TSAN_SYSCALL();
+  MemoryAccessRange(thr, pc, p, s, write);
+}
+
+static void syscall_acquire(uptr pc, uptr addr) {
+  TSAN_SYSCALL();
+  Acquire(thr, pc, addr);
+  DPrintf("syscall_acquire(%p)\n", addr);
+}
+
+static void syscall_release(uptr pc, uptr addr) {
+  TSAN_SYSCALL();
+  DPrintf("syscall_release(%p)\n", addr);
+  Release(thr, pc, addr);
+}
+
+static void syscall_fd_close(uptr pc, int fd) {
+  TSAN_SYSCALL();
+  FdClose(thr, pc, fd);
+}
+
+static USED void syscall_fd_acquire(uptr pc, int fd) {
+  TSAN_SYSCALL();
+  FdAcquire(thr, pc, fd);
+  DPrintf("syscall_fd_acquire(%p)\n", fd);
+}
+
+static USED void syscall_fd_release(uptr pc, int fd) {
+  TSAN_SYSCALL();
+  DPrintf("syscall_fd_release(%p)\n", fd);
+  FdRelease(thr, pc, fd);
+}
+
+static void syscall_pre_fork(uptr pc) {
+  TSAN_SYSCALL();
+  ForkBefore(thr, pc);
+}
+
+static void syscall_post_fork(uptr pc, int pid) {
+  TSAN_SYSCALL();
+  if (pid == 0) {
+    // child
+    ForkChildAfter(thr, pc);
+    FdOnFork(thr, pc);
+  } else if (pid > 0) {
+    // parent
+    ForkParentAfter(thr, pc);
+  } else {
+    // error
+    ForkParentAfter(thr, pc);
+  }
+}
+#endif
+
+#define COMMON_SYSCALL_PRE_READ_RANGE(p, s) \
+  syscall_access_range(GET_CALLER_PC(), (uptr)(p), (uptr)(s), false)
+
+#define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) \
+  syscall_access_range(GET_CALLER_PC(), (uptr)(p), (uptr)(s), true)
+
+#define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
+  do {                                       \
+    (void)(p);                               \
+    (void)(s);                               \
+  } while (false)
+
+#define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
+  do {                                        \
+    (void)(p);                                \
+    (void)(s);                                \
+  } while (false)
+
+#define COMMON_SYSCALL_ACQUIRE(addr) \
+    syscall_acquire(GET_CALLER_PC(), (uptr)(addr))
+
+#define COMMON_SYSCALL_RELEASE(addr) \
+    syscall_release(GET_CALLER_PC(), (uptr)(addr))
+
+#define COMMON_SYSCALL_FD_CLOSE(fd) syscall_fd_close(GET_CALLER_PC(), fd)
+
+#define COMMON_SYSCALL_FD_ACQUIRE(fd) syscall_fd_acquire(GET_CALLER_PC(), fd)
+
+#define COMMON_SYSCALL_FD_RELEASE(fd) syscall_fd_release(GET_CALLER_PC(), fd)
+
+#define COMMON_SYSCALL_PRE_FORK() \
+  syscall_pre_fork(GET_CALLER_PC())
+
+#define COMMON_SYSCALL_POST_FORK(res) \
+  syscall_post_fork(GET_CALLER_PC(), res)
+
+#include "sanitizer_common/sanitizer_common_syscalls.inc"
+
+namespace __tsan {
+
+static void finalize(void *arg) {
+  ThreadState *thr = cur_thread();
+  int status = Finalize(thr);
+  // Make sure the output is not lost.
+  FlushStreams();
+  if (status)
+    Die();
+}
+
+#if !SANITIZER_MAC && !SANITIZER_ANDROID
+static void unreachable() {
+  Report("FATAL: ThreadSanitizer: unreachable called\n");
+  Die();
+}
+#endif
+
+void InitializeInterceptors() {
+#if !SANITIZER_MAC
+  // We need to setup it early, because functions like dlsym() can call it.
+  REAL(memset) = internal_memset;
+  REAL(memcpy) = internal_memcpy;
+#endif
+
+  // Instruct libc malloc to consume less memory.
+#if SANITIZER_LINUX
+  mallopt(1, 0);  // M_MXFAST
+  mallopt(-3, 32*1024);  // M_MMAP_THRESHOLD
+#endif
+
+  InitializeCommonInterceptors();
+
+#if !SANITIZER_MAC
+  // We can not use TSAN_INTERCEPT to get setjmp addr,
+  // because it does &setjmp and setjmp is not present in some versions of libc.
+  using __interception::GetRealFunctionAddress;
+  GetRealFunctionAddress("setjmp", (uptr*)&REAL(setjmp), 0, 0);
+  GetRealFunctionAddress("_setjmp", (uptr*)&REAL(_setjmp), 0, 0);
+  GetRealFunctionAddress("sigsetjmp", (uptr*)&REAL(sigsetjmp), 0, 0);
+  GetRealFunctionAddress("__sigsetjmp", (uptr*)&REAL(__sigsetjmp), 0, 0);
+#endif
+
+  TSAN_INTERCEPT(longjmp);
+  TSAN_INTERCEPT(siglongjmp);
+
+  TSAN_INTERCEPT(malloc);
+  TSAN_INTERCEPT(__libc_memalign);
+  TSAN_INTERCEPT(calloc);
+  TSAN_INTERCEPT(realloc);
+  TSAN_INTERCEPT(free);
+  TSAN_INTERCEPT(cfree);
+  TSAN_INTERCEPT(mmap);
+  TSAN_MAYBE_INTERCEPT_MMAP64;
+  TSAN_INTERCEPT(munmap);
+  TSAN_MAYBE_INTERCEPT_MEMALIGN;
+  TSAN_INTERCEPT(valloc);
+  TSAN_MAYBE_INTERCEPT_PVALLOC;
+  TSAN_INTERCEPT(posix_memalign);
+
+  TSAN_INTERCEPT(strlen);
+  TSAN_INTERCEPT(memset);
+  TSAN_INTERCEPT(memcpy);
+  TSAN_INTERCEPT(memmove);
+  TSAN_INTERCEPT(strchr);
+  TSAN_INTERCEPT(strchrnul);
+  TSAN_INTERCEPT(strrchr);
+  TSAN_INTERCEPT(strcpy);  // NOLINT
+  TSAN_INTERCEPT(strncpy);
+  TSAN_INTERCEPT(strdup);
+
+  TSAN_INTERCEPT(pthread_create);
+  TSAN_INTERCEPT(pthread_join);
+  TSAN_INTERCEPT(pthread_detach);
+
+  TSAN_INTERCEPT_VER(pthread_cond_init, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_signal, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_broadcast, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_wait, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_timedwait, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_destroy, PTHREAD_ABI_BASE);
+
+  TSAN_INTERCEPT(pthread_mutex_init);
+  TSAN_INTERCEPT(pthread_mutex_destroy);
+  TSAN_INTERCEPT(pthread_mutex_trylock);
+  TSAN_INTERCEPT(pthread_mutex_timedlock);
+
+  TSAN_INTERCEPT(pthread_spin_init);
+  TSAN_INTERCEPT(pthread_spin_destroy);
+  TSAN_INTERCEPT(pthread_spin_lock);
+  TSAN_INTERCEPT(pthread_spin_trylock);
+  TSAN_INTERCEPT(pthread_spin_unlock);
+
+  TSAN_INTERCEPT(pthread_rwlock_init);
+  TSAN_INTERCEPT(pthread_rwlock_destroy);
+  TSAN_INTERCEPT(pthread_rwlock_rdlock);
+  TSAN_INTERCEPT(pthread_rwlock_tryrdlock);
+  TSAN_INTERCEPT(pthread_rwlock_timedrdlock);
+  TSAN_INTERCEPT(pthread_rwlock_wrlock);
+  TSAN_INTERCEPT(pthread_rwlock_trywrlock);
+  TSAN_INTERCEPT(pthread_rwlock_timedwrlock);
+  TSAN_INTERCEPT(pthread_rwlock_unlock);
+
+  TSAN_INTERCEPT(pthread_barrier_init);
+  TSAN_INTERCEPT(pthread_barrier_destroy);
+  TSAN_INTERCEPT(pthread_barrier_wait);
+
+  TSAN_INTERCEPT(pthread_once);
+
+  TSAN_INTERCEPT(stat);
+  TSAN_MAYBE_INTERCEPT___XSTAT;
+  TSAN_MAYBE_INTERCEPT_STAT64;
+  TSAN_MAYBE_INTERCEPT___XSTAT64;
+  TSAN_INTERCEPT(lstat);
+  TSAN_MAYBE_INTERCEPT___LXSTAT;
+  TSAN_MAYBE_INTERCEPT_LSTAT64;
+  TSAN_MAYBE_INTERCEPT___LXSTAT64;
+  TSAN_INTERCEPT(fstat);
+  TSAN_MAYBE_INTERCEPT___FXSTAT;
+  TSAN_MAYBE_INTERCEPT_FSTAT64;
+  TSAN_MAYBE_INTERCEPT___FXSTAT64;
+  TSAN_INTERCEPT(open);
+  TSAN_MAYBE_INTERCEPT_OPEN64;
+  TSAN_INTERCEPT(creat);
+  TSAN_MAYBE_INTERCEPT_CREAT64;
+  TSAN_INTERCEPT(dup);
+  TSAN_INTERCEPT(dup2);
+  TSAN_INTERCEPT(dup3);
+  TSAN_MAYBE_INTERCEPT_EVENTFD;
+  TSAN_MAYBE_INTERCEPT_SIGNALFD;
+  TSAN_MAYBE_INTERCEPT_INOTIFY_INIT;
+  TSAN_MAYBE_INTERCEPT_INOTIFY_INIT1;
+  TSAN_INTERCEPT(socket);
+  TSAN_INTERCEPT(socketpair);
+  TSAN_INTERCEPT(connect);
+  TSAN_INTERCEPT(bind);
+  TSAN_INTERCEPT(listen);
+  TSAN_MAYBE_INTERCEPT_EPOLL_CREATE;
+  TSAN_MAYBE_INTERCEPT_EPOLL_CREATE1;
+  TSAN_INTERCEPT(close);
+  TSAN_MAYBE_INTERCEPT___CLOSE;
+  TSAN_MAYBE_INTERCEPT___RES_ICLOSE;
+  TSAN_INTERCEPT(pipe);
+  TSAN_INTERCEPT(pipe2);
+
+  TSAN_INTERCEPT(send);
+  TSAN_INTERCEPT(sendmsg);
+  TSAN_INTERCEPT(recv);
+
+  TSAN_INTERCEPT(unlink);
+  TSAN_INTERCEPT(tmpfile);
+  TSAN_MAYBE_INTERCEPT_TMPFILE64;
+  TSAN_INTERCEPT(fread);
+  TSAN_INTERCEPT(fwrite);
+  TSAN_INTERCEPT(abort);
+  TSAN_INTERCEPT(puts);
+  TSAN_INTERCEPT(rmdir);
+  TSAN_INTERCEPT(closedir);
+
+  TSAN_MAYBE_INTERCEPT_EPOLL_CTL;
+  TSAN_MAYBE_INTERCEPT_EPOLL_WAIT;
+
+  TSAN_INTERCEPT(sigaction);
+  TSAN_INTERCEPT(signal);
+  TSAN_INTERCEPT(sigsuspend);
+  TSAN_INTERCEPT(raise);
+  TSAN_INTERCEPT(kill);
+  TSAN_INTERCEPT(pthread_kill);
+  TSAN_INTERCEPT(sleep);
+  TSAN_INTERCEPT(usleep);
+  TSAN_INTERCEPT(nanosleep);
+  TSAN_INTERCEPT(gettimeofday);
+  TSAN_INTERCEPT(getaddrinfo);
+
+  TSAN_INTERCEPT(fork);
+  TSAN_INTERCEPT(vfork);
+#if !SANITIZER_ANDROID
+  TSAN_INTERCEPT(dl_iterate_phdr);
+#endif
+  TSAN_INTERCEPT(on_exit);
+  TSAN_INTERCEPT(__cxa_atexit);
+  TSAN_INTERCEPT(_exit);
+
+#if !SANITIZER_MAC && !SANITIZER_ANDROID
+  // Need to setup it, because interceptors check that the function is resolved.
+  // But atexit is emitted directly into the module, so can't be resolved.
+  REAL(atexit) = (int(*)(void(*)()))unreachable;
+#endif
+
+  if (REAL(__cxa_atexit)(&finalize, 0, 0)) {
+    Printf("ThreadSanitizer: failed to setup atexit callback\n");
+    Die();
+  }
+
+#if !SANITIZER_MAC
+  if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
+    Printf("ThreadSanitizer: failed to create thread key\n");
+    Die();
+  }
+#endif
+
+  FdInit();
+}
+
+}  // namespace __tsan
+
+// Invisible barrier for tests.
+// There were several unsuccessful iterations for this functionality:
+// 1. Initially it was implemented in user code using
+//    REAL(pthread_barrier_wait). But pthread_barrier_wait is not supported on
+//    MacOS. Futexes are linux-specific for this matter.
+// 2. Then we switched to atomics+usleep(10). But usleep produced parasitic
+//    "as-if synchronized via sleep" messages in reports which failed some
+//    output tests.
+// 3. Then we switched to atomics+sched_yield. But this produced tons of tsan-
+//    visible events, which lead to "failed to restore stack trace" failures.
+// Note that no_sanitize_thread attribute does not turn off atomic interception
+// so attaching it to the function defined in user code does not help.
+// That's why we now have what we have.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_testonly_barrier_init(u64 *barrier, u32 count) {
+  if (count >= (1 << 8)) {
+      Printf("barrier_init: count is too large (%d)\n", count);
+      Die();
+  }
+  // 8 lsb is thread count, the remaining are count of entered threads.
+  *barrier = count;
+}
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_testonly_barrier_wait(u64 *barrier) {
+  unsigned old = __atomic_fetch_add(barrier, 1 << 8, __ATOMIC_RELAXED);
+  unsigned old_epoch = (old >> 8) / (old & 0xff);
+  for (;;) {
+    unsigned cur = __atomic_load_n(barrier, __ATOMIC_RELAXED);
+    unsigned cur_epoch = (cur >> 8) / (cur & 0xff);
+    if (cur_epoch != old_epoch)
+      return;
+    internal_sched_yield();
+  }
+}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interceptors.h b/compiler-rt/lib/tsan/rtl/tsan_interceptors.h
new file mode 100644
index 0000000..d831620
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interceptors.h
@@ -0,0 +1,57 @@
+#ifndef TSAN_INTERCEPTORS_H
+#define TSAN_INTERCEPTORS_H
+
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+class ScopedInterceptor {
+ public:
+  ScopedInterceptor(ThreadState *thr, const char *fname, uptr pc);
+  ~ScopedInterceptor();
+  void UserCallbackStart();
+  void UserCallbackEnd();
+ private:
+  ThreadState *const thr_;
+  const uptr pc_;
+  bool in_ignored_lib_;
+};
+
+}  // namespace __tsan
+
+#define SCOPED_INTERCEPTOR_RAW(func, ...) \
+    ThreadState *thr = cur_thread(); \
+    const uptr caller_pc = GET_CALLER_PC(); \
+    ScopedInterceptor si(thr, #func, caller_pc); \
+    const uptr pc = StackTrace::GetCurrentPc(); \
+    (void)pc; \
+/**/
+
+#define SCOPED_TSAN_INTERCEPTOR(func, ...) \
+    SCOPED_INTERCEPTOR_RAW(func, __VA_ARGS__); \
+    if (REAL(func) == 0) { \
+      Report("FATAL: ThreadSanitizer: failed to intercept %s\n", #func); \
+      Die(); \
+    }                                                    \
+    if (thr->ignore_interceptors || thr->in_ignored_lib) \
+      return REAL(func)(__VA_ARGS__); \
+/**/
+
+#define SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START() \
+    si.UserCallbackStart();
+
+#define SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END() \
+    si.UserCallbackEnd();
+
+#define TSAN_INTERCEPTOR(ret, func, ...) INTERCEPTOR(ret, func, __VA_ARGS__)
+
+#if SANITIZER_FREEBSD
+#define __libc_free __free
+#define __libc_malloc __malloc
+#endif
+
+extern "C" void __libc_free(void *ptr);
+extern "C" void *__libc_malloc(uptr size);
+
+#endif  // TSAN_INTERCEPTORS_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interceptors_mac.cc b/compiler-rt/lib/tsan/rtl/tsan_interceptors_mac.cc
new file mode 100644
index 0000000..2bf7ad9
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interceptors_mac.cc
@@ -0,0 +1,91 @@
+//===-- tsan_interceptors_mac.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Mac-specific interceptors.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "interception/interception.h"
+#include "tsan_interceptors.h"
+
+#include <libkern/OSAtomic.h>
+
+namespace __tsan {
+
+TSAN_INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
+  CHECK(!cur_thread()->is_dead);
+  if (!cur_thread()->is_inited) {
+    return REAL(OSSpinLockLock)(lock);
+  }
+  SCOPED_TSAN_INTERCEPTOR(OSSpinLockLock, lock);
+  REAL(OSSpinLockLock)(lock);
+  Acquire(thr, pc, (uptr)lock);
+}
+
+TSAN_INTERCEPTOR(bool, OSSpinLockTry, volatile OSSpinLock *lock) {
+  CHECK(!cur_thread()->is_dead);
+  if (!cur_thread()->is_inited) {
+    return REAL(OSSpinLockTry)(lock);
+  }
+  SCOPED_TSAN_INTERCEPTOR(OSSpinLockTry, lock);
+  bool result = REAL(OSSpinLockTry)(lock);
+  if (result)
+    Acquire(thr, pc, (uptr)lock);
+  return result;
+}
+
+TSAN_INTERCEPTOR(void, OSSpinLockUnlock, volatile OSSpinLock *lock) {
+  CHECK(!cur_thread()->is_dead);
+  if (!cur_thread()->is_inited) {
+    return REAL(OSSpinLockUnlock)(lock);
+  }
+  SCOPED_TSAN_INTERCEPTOR(OSSpinLockUnlock, lock);
+  Release(thr, pc, (uptr)lock);
+  REAL(OSSpinLockUnlock)(lock);
+}
+
+TSAN_INTERCEPTOR(void, os_lock_lock, void *lock) {
+  CHECK(!cur_thread()->is_dead);
+  if (!cur_thread()->is_inited) {
+    return REAL(os_lock_lock)(lock);
+  }
+  SCOPED_TSAN_INTERCEPTOR(os_lock_lock, lock);
+  REAL(os_lock_lock)(lock);
+  Acquire(thr, pc, (uptr)lock);
+}
+
+TSAN_INTERCEPTOR(bool, os_lock_trylock, void *lock) {
+  CHECK(!cur_thread()->is_dead);
+  if (!cur_thread()->is_inited) {
+    return REAL(os_lock_trylock)(lock);
+  }
+  SCOPED_TSAN_INTERCEPTOR(os_lock_trylock, lock);
+  bool result = REAL(os_lock_trylock)(lock);
+  if (result)
+    Acquire(thr, pc, (uptr)lock);
+  return result;
+}
+
+TSAN_INTERCEPTOR(void, os_lock_unlock, void *lock) {
+  CHECK(!cur_thread()->is_dead);
+  if (!cur_thread()->is_inited) {
+    return REAL(os_lock_unlock)(lock);
+  }
+  SCOPED_TSAN_INTERCEPTOR(os_lock_unlock, lock);
+  Release(thr, pc, (uptr)lock);
+  REAL(os_lock_unlock)(lock);
+}
+
+}  // namespace __tsan
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface.cc b/compiler-rt/lib/tsan/rtl/tsan_interface.cc
new file mode 100644
index 0000000..809d2ab
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface.cc
@@ -0,0 +1,131 @@
+//===-- tsan_interface.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "tsan_interface.h"
+#include "tsan_interface_ann.h"
+#include "tsan_rtl.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+#define CALLERPC ((uptr)__builtin_return_address(0))
+
+using namespace __tsan;  // NOLINT
+
+typedef u16 uint16_t;
+typedef u32 uint32_t;
+typedef u64 uint64_t;
+
+void __tsan_init() {
+  Initialize(cur_thread());
+}
+
+void __tsan_read16(void *addr) {
+  MemoryRead(cur_thread(), CALLERPC, (uptr)addr, kSizeLog8);
+  MemoryRead(cur_thread(), CALLERPC, (uptr)addr + 8, kSizeLog8);
+}
+
+void __tsan_write16(void *addr) {
+  MemoryWrite(cur_thread(), CALLERPC, (uptr)addr, kSizeLog8);
+  MemoryWrite(cur_thread(), CALLERPC, (uptr)addr + 8, kSizeLog8);
+}
+
+void __tsan_read16_pc(void *addr, void *pc) {
+  MemoryRead(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog8);
+  MemoryRead(cur_thread(), (uptr)pc, (uptr)addr + 8, kSizeLog8);
+}
+
+void __tsan_write16_pc(void *addr, void *pc) {
+  MemoryWrite(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog8);
+  MemoryWrite(cur_thread(), (uptr)pc, (uptr)addr + 8, kSizeLog8);
+}
+
+// __tsan_unaligned_read/write calls are emitted by compiler.
+
+void __tsan_unaligned_read2(const void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 2, false, false);
+}
+
+void __tsan_unaligned_read4(const void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 4, false, false);
+}
+
+void __tsan_unaligned_read8(const void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 8, false, false);
+}
+
+void __tsan_unaligned_read16(const void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 16, false, false);
+}
+
+void __tsan_unaligned_write2(void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 2, true, false);
+}
+
+void __tsan_unaligned_write4(void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 4, true, false);
+}
+
+void __tsan_unaligned_write8(void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 8, true, false);
+}
+
+void __tsan_unaligned_write16(void *addr) {
+  UnalignedMemoryAccess(cur_thread(), CALLERPC, (uptr)addr, 16, true, false);
+}
+
+// __sanitizer_unaligned_load/store are for user instrumentation.
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+u16 __sanitizer_unaligned_load16(const uu16 *addr) {
+  __tsan_unaligned_read2(addr);
+  return *addr;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+u32 __sanitizer_unaligned_load32(const uu32 *addr) {
+  __tsan_unaligned_read4(addr);
+  return *addr;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+u64 __sanitizer_unaligned_load64(const uu64 *addr) {
+  __tsan_unaligned_read8(addr);
+  return *addr;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store16(uu16 *addr, u16 v) {
+  __tsan_unaligned_write2(addr);
+  *addr = v;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store32(uu32 *addr, u32 v) {
+  __tsan_unaligned_write4(addr);
+  *addr = v;
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_unaligned_store64(uu64 *addr, u64 v) {
+  __tsan_unaligned_write8(addr);
+  *addr = v;
+}
+}  // extern "C"
+
+void __tsan_acquire(void *addr) {
+  Acquire(cur_thread(), CALLERPC, (uptr)addr);
+}
+
+void __tsan_release(void *addr) {
+  Release(cur_thread(), CALLERPC, (uptr)addr);
+}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface.h b/compiler-rt/lib/tsan/rtl/tsan_interface.h
new file mode 100644
index 0000000..41e084b
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface.h
@@ -0,0 +1,82 @@
+//===-- tsan_interface.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// The functions declared in this header will be inserted by the instrumentation
+// module.
+// This header can be included by the instrumented program or by TSan tests.
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_INTERFACE_H
+#define TSAN_INTERFACE_H
+
+#include <sanitizer_common/sanitizer_internal_defs.h>
+
+// This header should NOT include any other headers.
+// All functions in this header are extern "C" and start with __tsan_.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This function should be called at the very beginning of the process,
+// before any instrumented code is executed and before any call to malloc.
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_init();
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_vptr_update(void **vptr_p, void *new_val);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit();
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_read_range(void *addr, unsigned long size);  // NOLINT
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_write_range(void *addr, unsigned long size);  // NOLINT
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // TSAN_INTERFACE_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cc b/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cc
new file mode 100644
index 0000000..62db796
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cc
@@ -0,0 +1,461 @@
+//===-- tsan_interface_ann.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "tsan_interface_ann.h"
+#include "tsan_mutex.h"
+#include "tsan_report.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+#include "tsan_flags.h"
+#include "tsan_platform.h"
+#include "tsan_vector.h"
+
+#define CALLERPC ((uptr)__builtin_return_address(0))
+
+using namespace __tsan;  // NOLINT
+
+namespace __tsan {
+
+class ScopedAnnotation {
+ public:
+  ScopedAnnotation(ThreadState *thr, const char *aname, const char *f, int l,
+                   uptr pc)
+      : thr_(thr) {
+    FuncEntry(thr_, pc);
+    DPrintf("#%d: annotation %s() %s:%d\n", thr_->tid, aname, f, l);
+  }
+
+  ~ScopedAnnotation() {
+    FuncExit(thr_);
+    CheckNoLocks(thr_);
+  }
+ private:
+  ThreadState *const thr_;
+};
+
+#define SCOPED_ANNOTATION(typ) \
+    if (!flags()->enable_annotations) \
+      return; \
+    ThreadState *thr = cur_thread(); \
+    const uptr caller_pc = (uptr)__builtin_return_address(0); \
+    StatInc(thr, StatAnnotation); \
+    StatInc(thr, Stat##typ); \
+    ScopedAnnotation sa(thr, __func__, f, l, caller_pc); \
+    const uptr pc = StackTrace::GetCurrentPc(); \
+    (void)pc; \
+/**/
+
+static const int kMaxDescLen = 128;
+
+struct ExpectRace {
+  ExpectRace *next;
+  ExpectRace *prev;
+  atomic_uintptr_t hitcount;
+  atomic_uintptr_t addcount;
+  uptr addr;
+  uptr size;
+  char *file;
+  int line;
+  char desc[kMaxDescLen];
+};
+
+struct DynamicAnnContext {
+  Mutex mtx;
+  ExpectRace expect;
+  ExpectRace benign;
+
+  DynamicAnnContext()
+    : mtx(MutexTypeAnnotations, StatMtxAnnotations) {
+  }
+};
+
+static DynamicAnnContext *dyn_ann_ctx;
+static char dyn_ann_ctx_placeholder[sizeof(DynamicAnnContext)] ALIGNED(64);
+
+static void AddExpectRace(ExpectRace *list,
+    char *f, int l, uptr addr, uptr size, char *desc) {
+  ExpectRace *race = list->next;
+  for (; race != list; race = race->next) {
+    if (race->addr == addr && race->size == size) {
+      atomic_store_relaxed(&race->addcount,
+          atomic_load_relaxed(&race->addcount) + 1);
+      return;
+    }
+  }
+  race = (ExpectRace*)internal_alloc(MBlockExpectRace, sizeof(ExpectRace));
+  race->addr = addr;
+  race->size = size;
+  race->file = f;
+  race->line = l;
+  race->desc[0] = 0;
+  atomic_store_relaxed(&race->hitcount, 0);
+  atomic_store_relaxed(&race->addcount, 1);
+  if (desc) {
+    int i = 0;
+    for (; i < kMaxDescLen - 1 && desc[i]; i++)
+      race->desc[i] = desc[i];
+    race->desc[i] = 0;
+  }
+  race->prev = list;
+  race->next = list->next;
+  race->next->prev = race;
+  list->next = race;
+}
+
+static ExpectRace *FindRace(ExpectRace *list, uptr addr, uptr size) {
+  for (ExpectRace *race = list->next; race != list; race = race->next) {
+    uptr maxbegin = max(race->addr, addr);
+    uptr minend = min(race->addr + race->size, addr + size);
+    if (maxbegin < minend)
+      return race;
+  }
+  return 0;
+}
+
+static bool CheckContains(ExpectRace *list, uptr addr, uptr size) {
+  ExpectRace *race = FindRace(list, addr, size);
+  if (race == 0)
+    return false;
+  DPrintf("Hit expected/benign race: %s addr=%zx:%d %s:%d\n",
+      race->desc, race->addr, (int)race->size, race->file, race->line);
+  atomic_fetch_add(&race->hitcount, 1, memory_order_relaxed);
+  return true;
+}
+
+static void InitList(ExpectRace *list) {
+  list->next = list;
+  list->prev = list;
+}
+
+void InitializeDynamicAnnotations() {
+  dyn_ann_ctx = new(dyn_ann_ctx_placeholder) DynamicAnnContext;
+  InitList(&dyn_ann_ctx->expect);
+  InitList(&dyn_ann_ctx->benign);
+}
+
+bool IsExpectedReport(uptr addr, uptr size) {
+  ReadLock lock(&dyn_ann_ctx->mtx);
+  if (CheckContains(&dyn_ann_ctx->expect, addr, size))
+    return true;
+  if (CheckContains(&dyn_ann_ctx->benign, addr, size))
+    return true;
+  return false;
+}
+
+static void CollectMatchedBenignRaces(Vector<ExpectRace> *matched,
+    int *unique_count, int *hit_count, atomic_uintptr_t ExpectRace::*counter) {
+  ExpectRace *list = &dyn_ann_ctx->benign;
+  for (ExpectRace *race = list->next; race != list; race = race->next) {
+    (*unique_count)++;
+    const uptr cnt = atomic_load_relaxed(&(race->*counter));
+    if (cnt == 0)
+      continue;
+    *hit_count += cnt;
+    uptr i = 0;
+    for (; i < matched->Size(); i++) {
+      ExpectRace *race0 = &(*matched)[i];
+      if (race->line == race0->line
+          && internal_strcmp(race->file, race0->file) == 0
+          && internal_strcmp(race->desc, race0->desc) == 0) {
+        atomic_fetch_add(&(race0->*counter), cnt, memory_order_relaxed);
+        break;
+      }
+    }
+    if (i == matched->Size())
+      matched->PushBack(*race);
+  }
+}
+
+void PrintMatchedBenignRaces() {
+  Lock lock(&dyn_ann_ctx->mtx);
+  int unique_count = 0;
+  int hit_count = 0;
+  int add_count = 0;
+  Vector<ExpectRace> hit_matched(MBlockScopedBuf);
+  CollectMatchedBenignRaces(&hit_matched, &unique_count, &hit_count,
+      &ExpectRace::hitcount);
+  Vector<ExpectRace> add_matched(MBlockScopedBuf);
+  CollectMatchedBenignRaces(&add_matched, &unique_count, &add_count,
+      &ExpectRace::addcount);
+  if (hit_matched.Size()) {
+    Printf("ThreadSanitizer: Matched %d \"benign\" races (pid=%d):\n",
+        hit_count, (int)internal_getpid());
+    for (uptr i = 0; i < hit_matched.Size(); i++) {
+      Printf("%d %s:%d %s\n",
+          atomic_load_relaxed(&hit_matched[i].hitcount),
+          hit_matched[i].file, hit_matched[i].line, hit_matched[i].desc);
+    }
+  }
+  if (hit_matched.Size()) {
+    Printf("ThreadSanitizer: Annotated %d \"benign\" races, %d unique"
+           " (pid=%d):\n",
+        add_count, unique_count, (int)internal_getpid());
+    for (uptr i = 0; i < add_matched.Size(); i++) {
+      Printf("%d %s:%d %s\n",
+          atomic_load_relaxed(&add_matched[i].addcount),
+          add_matched[i].file, add_matched[i].line, add_matched[i].desc);
+    }
+  }
+}
+
+static void ReportMissedExpectedRace(ExpectRace *race) {
+  Printf("==================\n");
+  Printf("WARNING: ThreadSanitizer: missed expected data race\n");
+  Printf("  %s addr=%zx %s:%d\n",
+      race->desc, race->addr, race->file, race->line);
+  Printf("==================\n");
+}
+}  // namespace __tsan
+
+using namespace __tsan;  // NOLINT
+
+extern "C" {
+void INTERFACE_ATTRIBUTE AnnotateHappensBefore(char *f, int l, uptr addr) {
+  SCOPED_ANNOTATION(AnnotateHappensBefore);
+  Release(thr, pc, addr);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateHappensAfter(char *f, int l, uptr addr) {
+  SCOPED_ANNOTATION(AnnotateHappensAfter);
+  Acquire(thr, pc, addr);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateCondVarSignal(char *f, int l, uptr cv) {
+  SCOPED_ANNOTATION(AnnotateCondVarSignal);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateCondVarSignalAll(char *f, int l, uptr cv) {
+  SCOPED_ANNOTATION(AnnotateCondVarSignalAll);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateMutexIsNotPHB(char *f, int l, uptr mu) {
+  SCOPED_ANNOTATION(AnnotateMutexIsNotPHB);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateCondVarWait(char *f, int l, uptr cv,
+                                             uptr lock) {
+  SCOPED_ANNOTATION(AnnotateCondVarWait);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateRWLockCreate(char *f, int l, uptr m) {
+  SCOPED_ANNOTATION(AnnotateRWLockCreate);
+  MutexCreate(thr, pc, m, true, true, false);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateRWLockCreateStatic(char *f, int l, uptr m) {
+  SCOPED_ANNOTATION(AnnotateRWLockCreateStatic);
+  MutexCreate(thr, pc, m, true, true, true);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateRWLockDestroy(char *f, int l, uptr m) {
+  SCOPED_ANNOTATION(AnnotateRWLockDestroy);
+  MutexDestroy(thr, pc, m);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateRWLockAcquired(char *f, int l, uptr m,
+                                                uptr is_w) {
+  SCOPED_ANNOTATION(AnnotateRWLockAcquired);
+  if (is_w)
+    MutexLock(thr, pc, m);
+  else
+    MutexReadLock(thr, pc, m);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateRWLockReleased(char *f, int l, uptr m,
+                                                uptr is_w) {
+  SCOPED_ANNOTATION(AnnotateRWLockReleased);
+  if (is_w)
+    MutexUnlock(thr, pc, m);
+  else
+    MutexReadUnlock(thr, pc, m);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateTraceMemory(char *f, int l, uptr mem) {
+  SCOPED_ANNOTATION(AnnotateTraceMemory);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateFlushState(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateFlushState);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateNewMemory(char *f, int l, uptr mem,
+                                           uptr size) {
+  SCOPED_ANNOTATION(AnnotateNewMemory);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateNoOp(char *f, int l, uptr mem) {
+  SCOPED_ANNOTATION(AnnotateNoOp);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateFlushExpectedRaces(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateFlushExpectedRaces);
+  Lock lock(&dyn_ann_ctx->mtx);
+  while (dyn_ann_ctx->expect.next != &dyn_ann_ctx->expect) {
+    ExpectRace *race = dyn_ann_ctx->expect.next;
+    if (atomic_load_relaxed(&race->hitcount) == 0) {
+      ctx->nmissed_expected++;
+      ReportMissedExpectedRace(race);
+    }
+    race->prev->next = race->next;
+    race->next->prev = race->prev;
+    internal_free(race);
+  }
+}
+
+void INTERFACE_ATTRIBUTE AnnotateEnableRaceDetection(
+    char *f, int l, int enable) {
+  SCOPED_ANNOTATION(AnnotateEnableRaceDetection);
+  // FIXME: Reconsider this functionality later. It may be irrelevant.
+}
+
+void INTERFACE_ATTRIBUTE AnnotateMutexIsUsedAsCondVar(
+    char *f, int l, uptr mu) {
+  SCOPED_ANNOTATION(AnnotateMutexIsUsedAsCondVar);
+}
+
+void INTERFACE_ATTRIBUTE AnnotatePCQGet(
+    char *f, int l, uptr pcq) {
+  SCOPED_ANNOTATION(AnnotatePCQGet);
+}
+
+void INTERFACE_ATTRIBUTE AnnotatePCQPut(
+    char *f, int l, uptr pcq) {
+  SCOPED_ANNOTATION(AnnotatePCQPut);
+}
+
+void INTERFACE_ATTRIBUTE AnnotatePCQDestroy(
+    char *f, int l, uptr pcq) {
+  SCOPED_ANNOTATION(AnnotatePCQDestroy);
+}
+
+void INTERFACE_ATTRIBUTE AnnotatePCQCreate(
+    char *f, int l, uptr pcq) {
+  SCOPED_ANNOTATION(AnnotatePCQCreate);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateExpectRace(
+    char *f, int l, uptr mem, char *desc) {
+  SCOPED_ANNOTATION(AnnotateExpectRace);
+  Lock lock(&dyn_ann_ctx->mtx);
+  AddExpectRace(&dyn_ann_ctx->expect,
+                f, l, mem, 1, desc);
+  DPrintf("Add expected race: %s addr=%zx %s:%d\n", desc, mem, f, l);
+}
+
+static void BenignRaceImpl(
+    char *f, int l, uptr mem, uptr size, char *desc) {
+  Lock lock(&dyn_ann_ctx->mtx);
+  AddExpectRace(&dyn_ann_ctx->benign,
+                f, l, mem, size, desc);
+  DPrintf("Add benign race: %s addr=%zx %s:%d\n", desc, mem, f, l);
+}
+
+// FIXME: Turn it off later. WTF is benign race?1?? Go talk to Hans Boehm.
+void INTERFACE_ATTRIBUTE AnnotateBenignRaceSized(
+    char *f, int l, uptr mem, uptr size, char *desc) {
+  SCOPED_ANNOTATION(AnnotateBenignRaceSized);
+  BenignRaceImpl(f, l, mem, size, desc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateBenignRace(
+    char *f, int l, uptr mem, char *desc) {
+  SCOPED_ANNOTATION(AnnotateBenignRace);
+  BenignRaceImpl(f, l, mem, 1, desc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateIgnoreReadsBegin(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateIgnoreReadsBegin);
+  ThreadIgnoreBegin(thr, pc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateIgnoreReadsEnd(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateIgnoreReadsEnd);
+  ThreadIgnoreEnd(thr, pc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateIgnoreWritesBegin(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateIgnoreWritesBegin);
+  ThreadIgnoreBegin(thr, pc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateIgnoreWritesEnd(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateIgnoreWritesEnd);
+  ThreadIgnoreEnd(thr, pc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateIgnoreSyncBegin(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateIgnoreSyncBegin);
+  ThreadIgnoreSyncBegin(thr, pc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateIgnoreSyncEnd(char *f, int l) {
+  SCOPED_ANNOTATION(AnnotateIgnoreSyncEnd);
+  ThreadIgnoreSyncEnd(thr, pc);
+}
+
+void INTERFACE_ATTRIBUTE AnnotatePublishMemoryRange(
+    char *f, int l, uptr addr, uptr size) {
+  SCOPED_ANNOTATION(AnnotatePublishMemoryRange);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateUnpublishMemoryRange(
+    char *f, int l, uptr addr, uptr size) {
+  SCOPED_ANNOTATION(AnnotateUnpublishMemoryRange);
+}
+
+void INTERFACE_ATTRIBUTE AnnotateThreadName(
+    char *f, int l, char *name) {
+  SCOPED_ANNOTATION(AnnotateThreadName);
+  ThreadSetName(thr, name);
+}
+
+// We deliberately omit the implementation of WTFAnnotateHappensBefore() and
+// WTFAnnotateHappensAfter(). Those are being used by Webkit to annotate
+// atomic operations, which should be handled by ThreadSanitizer correctly.
+void INTERFACE_ATTRIBUTE WTFAnnotateHappensBefore(char *f, int l, uptr addr) {
+  SCOPED_ANNOTATION(AnnotateHappensBefore);
+}
+
+void INTERFACE_ATTRIBUTE WTFAnnotateHappensAfter(char *f, int l, uptr addr) {
+  SCOPED_ANNOTATION(AnnotateHappensAfter);
+}
+
+void INTERFACE_ATTRIBUTE WTFAnnotateBenignRaceSized(
+    char *f, int l, uptr mem, uptr sz, char *desc) {
+  SCOPED_ANNOTATION(AnnotateBenignRaceSized);
+  BenignRaceImpl(f, l, mem, sz, desc);
+}
+
+int INTERFACE_ATTRIBUTE RunningOnValgrind() {
+  return flags()->running_on_valgrind;
+}
+
+double __attribute__((weak)) INTERFACE_ATTRIBUTE ValgrindSlowdown(void) {
+  return 10.0;
+}
+
+const char INTERFACE_ATTRIBUTE* ThreadSanitizerQuery(const char *query) {
+  if (internal_strcmp(query, "pure_happens_before") == 0)
+    return "1";
+  else
+    return "0";
+}
+
+void INTERFACE_ATTRIBUTE
+AnnotateMemoryIsInitialized(char *f, int l, uptr mem, uptr sz) {}
+void INTERFACE_ATTRIBUTE
+AnnotateMemoryIsUninitialized(char *f, int l, uptr mem, uptr sz) {}
+}  // extern "C"
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_ann.h b/compiler-rt/lib/tsan/rtl/tsan_interface_ann.h
new file mode 100644
index 0000000..963bcc5
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_ann.h
@@ -0,0 +1,33 @@
+//===-- tsan_interface_ann.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Interface for dynamic annotations.
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_INTERFACE_ANN_H
+#define TSAN_INTERFACE_ANN_H
+
+#include <sanitizer_common/sanitizer_internal_defs.h>
+
+// This header should NOT include any other headers.
+// All functions in this header are extern "C" and start with __tsan_.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_acquire(void *addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_release(void *addr);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // TSAN_INTERFACE_ANN_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_atomic.cc b/compiler-rt/lib/tsan/rtl/tsan_interface_atomic.cc
new file mode 100644
index 0000000..2703199
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_atomic.cc
@@ -0,0 +1,954 @@
+//===-- tsan_interface_atomic.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+// ThreadSanitizer atomic operations are based on C++11/C1x standards.
+// For background see C++11 standard.  A slightly older, publicly
+// available draft of the standard (not entirely up-to-date, but close enough
+// for casual browsing) is available here:
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf
+// The following page contains more background information:
+// http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/
+
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "tsan_flags.h"
+#include "tsan_rtl.h"
+
+using namespace __tsan;  // NOLINT
+
+// These should match declarations from public tsan_interface_atomic.h header.
+typedef unsigned char      a8;
+typedef unsigned short     a16;  // NOLINT
+typedef unsigned int       a32;
+typedef unsigned long long a64;  // NOLINT
+#if !defined(SANITIZER_GO) && (defined(__SIZEOF_INT128__) \
+    || (__clang_major__ * 100 + __clang_minor__ >= 302)) && !defined(__mips64)
+__extension__ typedef __int128 a128;
+# define __TSAN_HAS_INT128 1
+#else
+# define __TSAN_HAS_INT128 0
+#endif
+
+#if !defined(SANITIZER_GO) && __TSAN_HAS_INT128
+// Protects emulation of 128-bit atomic operations.
+static StaticSpinMutex mutex128;
+#endif
+
+// Part of ABI, do not change.
+// http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?view=markup
+typedef enum {
+  mo_relaxed,
+  mo_consume,
+  mo_acquire,
+  mo_release,
+  mo_acq_rel,
+  mo_seq_cst
+} morder;
+
+static bool IsLoadOrder(morder mo) {
+  return mo == mo_relaxed || mo == mo_consume
+      || mo == mo_acquire || mo == mo_seq_cst;
+}
+
+static bool IsStoreOrder(morder mo) {
+  return mo == mo_relaxed || mo == mo_release || mo == mo_seq_cst;
+}
+
+static bool IsReleaseOrder(morder mo) {
+  return mo == mo_release || mo == mo_acq_rel || mo == mo_seq_cst;
+}
+
+static bool IsAcquireOrder(morder mo) {
+  return mo == mo_consume || mo == mo_acquire
+      || mo == mo_acq_rel || mo == mo_seq_cst;
+}
+
+static bool IsAcqRelOrder(morder mo) {
+  return mo == mo_acq_rel || mo == mo_seq_cst;
+}
+
+template<typename T> T func_xchg(volatile T *v, T op) {
+  T res = __sync_lock_test_and_set(v, op);
+  // __sync_lock_test_and_set does not contain full barrier.
+  __sync_synchronize();
+  return res;
+}
+
+template<typename T> T func_add(volatile T *v, T op) {
+  return __sync_fetch_and_add(v, op);
+}
+
+template<typename T> T func_sub(volatile T *v, T op) {
+  return __sync_fetch_and_sub(v, op);
+}
+
+template<typename T> T func_and(volatile T *v, T op) {
+  return __sync_fetch_and_and(v, op);
+}
+
+template<typename T> T func_or(volatile T *v, T op) {
+  return __sync_fetch_and_or(v, op);
+}
+
+template<typename T> T func_xor(volatile T *v, T op) {
+  return __sync_fetch_and_xor(v, op);
+}
+
+template<typename T> T func_nand(volatile T *v, T op) {
+  // clang does not support __sync_fetch_and_nand.
+  T cmp = *v;
+  for (;;) {
+    T newv = ~(cmp & op);
+    T cur = __sync_val_compare_and_swap(v, cmp, newv);
+    if (cmp == cur)
+      return cmp;
+    cmp = cur;
+  }
+}
+
+template<typename T> T func_cas(volatile T *v, T cmp, T xch) {
+  return __sync_val_compare_and_swap(v, cmp, xch);
+}
+
+// clang does not support 128-bit atomic ops.
+// Atomic ops are executed under tsan internal mutex,
+// here we assume that the atomic variables are not accessed
+// from non-instrumented code.
+#if !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) && !defined(SANITIZER_GO) \
+    && __TSAN_HAS_INT128
+a128 func_xchg(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = op;
+  return cmp;
+}
+
+a128 func_add(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = cmp + op;
+  return cmp;
+}
+
+a128 func_sub(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = cmp - op;
+  return cmp;
+}
+
+a128 func_and(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = cmp & op;
+  return cmp;
+}
+
+a128 func_or(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = cmp | op;
+  return cmp;
+}
+
+a128 func_xor(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = cmp ^ op;
+  return cmp;
+}
+
+a128 func_nand(volatile a128 *v, a128 op) {
+  SpinMutexLock lock(&mutex128);
+  a128 cmp = *v;
+  *v = ~(cmp & op);
+  return cmp;
+}
+
+a128 func_cas(volatile a128 *v, a128 cmp, a128 xch) {
+  SpinMutexLock lock(&mutex128);
+  a128 cur = *v;
+  if (cur == cmp)
+    *v = xch;
+  return cur;
+}
+#endif
+
+template<typename T>
+static int SizeLog() {
+  if (sizeof(T) <= 1)
+    return kSizeLog1;
+  else if (sizeof(T) <= 2)
+    return kSizeLog2;
+  else if (sizeof(T) <= 4)
+    return kSizeLog4;
+  else
+    return kSizeLog8;
+  // For 16-byte atomics we also use 8-byte memory access,
+  // this leads to false negatives only in very obscure cases.
+}
+
+#ifndef SANITIZER_GO
+static atomic_uint8_t *to_atomic(const volatile a8 *a) {
+  return reinterpret_cast<atomic_uint8_t *>(const_cast<a8 *>(a));
+}
+
+static atomic_uint16_t *to_atomic(const volatile a16 *a) {
+  return reinterpret_cast<atomic_uint16_t *>(const_cast<a16 *>(a));
+}
+#endif
+
+static atomic_uint32_t *to_atomic(const volatile a32 *a) {
+  return reinterpret_cast<atomic_uint32_t *>(const_cast<a32 *>(a));
+}
+
+static atomic_uint64_t *to_atomic(const volatile a64 *a) {
+  return reinterpret_cast<atomic_uint64_t *>(const_cast<a64 *>(a));
+}
+
+static memory_order to_mo(morder mo) {
+  switch (mo) {
+  case mo_relaxed: return memory_order_relaxed;
+  case mo_consume: return memory_order_consume;
+  case mo_acquire: return memory_order_acquire;
+  case mo_release: return memory_order_release;
+  case mo_acq_rel: return memory_order_acq_rel;
+  case mo_seq_cst: return memory_order_seq_cst;
+  }
+  CHECK(0);
+  return memory_order_seq_cst;
+}
+
+template<typename T>
+static T NoTsanAtomicLoad(const volatile T *a, morder mo) {
+  return atomic_load(to_atomic(a), to_mo(mo));
+}
+
+#if __TSAN_HAS_INT128 && !defined(SANITIZER_GO)
+static a128 NoTsanAtomicLoad(const volatile a128 *a, morder mo) {
+  SpinMutexLock lock(&mutex128);
+  return *a;
+}
+#endif
+
+template<typename T>
+static T AtomicLoad(ThreadState *thr, uptr pc, const volatile T *a,
+    morder mo) {
+  CHECK(IsLoadOrder(mo));
+  // This fast-path is critical for performance.
+  // Assume the access is atomic.
+  if (!IsAcquireOrder(mo)) {
+    MemoryReadAtomic(thr, pc, (uptr)a, SizeLog<T>());
+    return NoTsanAtomicLoad(a, mo);
+  }
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, false);
+  AcquireImpl(thr, pc, &s->clock);
+  T v = NoTsanAtomicLoad(a, mo);
+  s->mtx.ReadUnlock();
+  MemoryReadAtomic(thr, pc, (uptr)a, SizeLog<T>());
+  return v;
+}
+
+template<typename T>
+static void NoTsanAtomicStore(volatile T *a, T v, morder mo) {
+  atomic_store(to_atomic(a), v, to_mo(mo));
+}
+
+#if __TSAN_HAS_INT128 && !defined(SANITIZER_GO)
+static void NoTsanAtomicStore(volatile a128 *a, a128 v, morder mo) {
+  SpinMutexLock lock(&mutex128);
+  *a = v;
+}
+#endif
+
+template<typename T>
+static void AtomicStore(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  CHECK(IsStoreOrder(mo));
+  MemoryWriteAtomic(thr, pc, (uptr)a, SizeLog<T>());
+  // This fast-path is critical for performance.
+  // Assume the access is atomic.
+  // Strictly saying even relaxed store cuts off release sequence,
+  // so must reset the clock.
+  if (!IsReleaseOrder(mo)) {
+    NoTsanAtomicStore(a, v, mo);
+    return;
+  }
+  __sync_synchronize();
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, true);
+  thr->fast_state.IncrementEpoch();
+  // Can't increment epoch w/o writing to the trace as well.
+  TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+  ReleaseImpl(thr, pc, &s->clock);
+  NoTsanAtomicStore(a, v, mo);
+  s->mtx.Unlock();
+}
+
+template<typename T, T (*F)(volatile T *v, T op)>
+static T AtomicRMW(ThreadState *thr, uptr pc, volatile T *a, T v, morder mo) {
+  MemoryWriteAtomic(thr, pc, (uptr)a, SizeLog<T>());
+  SyncVar *s = 0;
+  if (mo != mo_relaxed) {
+    s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, true);
+    thr->fast_state.IncrementEpoch();
+    // Can't increment epoch w/o writing to the trace as well.
+    TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+    if (IsAcqRelOrder(mo))
+      AcquireReleaseImpl(thr, pc, &s->clock);
+    else if (IsReleaseOrder(mo))
+      ReleaseImpl(thr, pc, &s->clock);
+    else if (IsAcquireOrder(mo))
+      AcquireImpl(thr, pc, &s->clock);
+  }
+  v = F(a, v);
+  if (s)
+    s->mtx.Unlock();
+  return v;
+}
+
+template<typename T>
+static T NoTsanAtomicExchange(volatile T *a, T v, morder mo) {
+  return func_xchg(a, v);
+}
+
+template<typename T>
+static T NoTsanAtomicFetchAdd(volatile T *a, T v, morder mo) {
+  return func_add(a, v);
+}
+
+template<typename T>
+static T NoTsanAtomicFetchSub(volatile T *a, T v, morder mo) {
+  return func_sub(a, v);
+}
+
+template<typename T>
+static T NoTsanAtomicFetchAnd(volatile T *a, T v, morder mo) {
+  return func_and(a, v);
+}
+
+template<typename T>
+static T NoTsanAtomicFetchOr(volatile T *a, T v, morder mo) {
+  return func_or(a, v);
+}
+
+template<typename T>
+static T NoTsanAtomicFetchXor(volatile T *a, T v, morder mo) {
+  return func_xor(a, v);
+}
+
+template<typename T>
+static T NoTsanAtomicFetchNand(volatile T *a, T v, morder mo) {
+  return func_nand(a, v);
+}
+
+template<typename T>
+static T AtomicExchange(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_xchg>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static T AtomicFetchAdd(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_add>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static T AtomicFetchSub(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_sub>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static T AtomicFetchAnd(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_and>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static T AtomicFetchOr(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_or>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static T AtomicFetchXor(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_xor>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static T AtomicFetchNand(ThreadState *thr, uptr pc, volatile T *a, T v,
+    morder mo) {
+  return AtomicRMW<T, func_nand>(thr, pc, a, v, mo);
+}
+
+template<typename T>
+static bool NoTsanAtomicCAS(volatile T *a, T *c, T v, morder mo, morder fmo) {
+  return atomic_compare_exchange_strong(to_atomic(a), c, v, to_mo(mo));
+}
+
+#if __TSAN_HAS_INT128
+static bool NoTsanAtomicCAS(volatile a128 *a, a128 *c, a128 v,
+    morder mo, morder fmo) {
+  a128 old = *c;
+  a128 cur = func_cas(a, old, v);
+  if (cur == old)
+    return true;
+  *c = cur;
+  return false;
+}
+#endif
+
+template<typename T>
+static T NoTsanAtomicCAS(volatile T *a, T c, T v, morder mo, morder fmo) {
+  NoTsanAtomicCAS(a, &c, v, mo, fmo);
+  return c;
+}
+
+template<typename T>
+static bool AtomicCAS(ThreadState *thr, uptr pc,
+    volatile T *a, T *c, T v, morder mo, morder fmo) {
+  (void)fmo;  // Unused because llvm does not pass it yet.
+  MemoryWriteAtomic(thr, pc, (uptr)a, SizeLog<T>());
+  SyncVar *s = 0;
+  bool write_lock = mo != mo_acquire && mo != mo_consume;
+  if (mo != mo_relaxed) {
+    s = ctx->metamap.GetOrCreateAndLock(thr, pc, (uptr)a, write_lock);
+    thr->fast_state.IncrementEpoch();
+    // Can't increment epoch w/o writing to the trace as well.
+    TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+    if (IsAcqRelOrder(mo))
+      AcquireReleaseImpl(thr, pc, &s->clock);
+    else if (IsReleaseOrder(mo))
+      ReleaseImpl(thr, pc, &s->clock);
+    else if (IsAcquireOrder(mo))
+      AcquireImpl(thr, pc, &s->clock);
+  }
+  T cc = *c;
+  T pr = func_cas(a, cc, v);
+  if (s) {
+    if (write_lock)
+      s->mtx.Unlock();
+    else
+      s->mtx.ReadUnlock();
+  }
+  if (pr == cc)
+    return true;
+  *c = pr;
+  return false;
+}
+
+template<typename T>
+static T AtomicCAS(ThreadState *thr, uptr pc,
+    volatile T *a, T c, T v, morder mo, morder fmo) {
+  AtomicCAS(thr, pc, a, &c, v, mo, fmo);
+  return c;
+}
+
+#ifndef SANITIZER_GO
+static void NoTsanAtomicFence(morder mo) {
+  __sync_synchronize();
+}
+
+static void AtomicFence(ThreadState *thr, uptr pc, morder mo) {
+  // FIXME(dvyukov): not implemented.
+  __sync_synchronize();
+}
+#endif
+
+// Interface functions follow.
+#ifndef SANITIZER_GO
+
+// C/C++
+
+#define SCOPED_ATOMIC(func, ...) \
+    const uptr callpc = (uptr)__builtin_return_address(0); \
+    uptr pc = StackTrace::GetCurrentPc(); \
+    mo = flags()->force_seq_cst_atomics ? (morder)mo_seq_cst : mo; \
+    ThreadState *const thr = cur_thread(); \
+    if (thr->ignore_interceptors) \
+      return NoTsanAtomic##func(__VA_ARGS__); \
+    AtomicStatInc(thr, sizeof(*a), mo, StatAtomic##func); \
+    ScopedAtomic sa(thr, callpc, a, mo, __func__); \
+    return Atomic##func(thr, pc, __VA_ARGS__); \
+/**/
+
+class ScopedAtomic {
+ public:
+  ScopedAtomic(ThreadState *thr, uptr pc, const volatile void *a,
+               morder mo, const char *func)
+      : thr_(thr) {
+    FuncEntry(thr_, pc);
+    DPrintf("#%d: %s(%p, %d)\n", thr_->tid, func, a, mo);
+  }
+  ~ScopedAtomic() {
+    ProcessPendingSignals(thr_);
+    FuncExit(thr_);
+  }
+ private:
+  ThreadState *thr_;
+};
+
+static void AtomicStatInc(ThreadState *thr, uptr size, morder mo, StatType t) {
+  StatInc(thr, StatAtomic);
+  StatInc(thr, t);
+  StatInc(thr, size == 1 ? StatAtomic1
+             : size == 2 ? StatAtomic2
+             : size == 4 ? StatAtomic4
+             : size == 8 ? StatAtomic8
+             :             StatAtomic16);
+  StatInc(thr, mo == mo_relaxed ? StatAtomicRelaxed
+             : mo == mo_consume ? StatAtomicConsume
+             : mo == mo_acquire ? StatAtomicAcquire
+             : mo == mo_release ? StatAtomicRelease
+             : mo == mo_acq_rel ? StatAtomicAcq_Rel
+             :                    StatAtomicSeq_Cst);
+}
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_load(const volatile a8 *a, morder mo) {
+  SCOPED_ATOMIC(Load, a, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_load(const volatile a16 *a, morder mo) {
+  SCOPED_ATOMIC(Load, a, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_load(const volatile a32 *a, morder mo) {
+  SCOPED_ATOMIC(Load, a, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_load(const volatile a64 *a, morder mo) {
+  SCOPED_ATOMIC(Load, a, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_load(const volatile a128 *a, morder mo) {
+  SCOPED_ATOMIC(Load, a, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic8_store(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(Store, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic16_store(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(Store, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic32_store(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(Store, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic64_store(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(Store, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic128_store(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(Store, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(Exchange, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(Exchange, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(Exchange, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(Exchange, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(Exchange, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(FetchAdd, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(FetchAdd, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(FetchAdd, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(FetchAdd, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(FetchAdd, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(FetchSub, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(FetchSub, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(FetchSub, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(FetchSub, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(FetchSub, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(FetchAnd, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(FetchAnd, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(FetchAnd, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(FetchAnd, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(FetchAnd, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(FetchOr, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(FetchOr, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(FetchOr, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(FetchOr, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(FetchOr, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(FetchXor, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(FetchXor, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(FetchXor, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(FetchXor, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(FetchXor, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, morder mo) {
+  SCOPED_ATOMIC(FetchNand, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, morder mo) {
+  SCOPED_ATOMIC(FetchNand, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, morder mo) {
+  SCOPED_ATOMIC(FetchNand, a, v, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, morder mo) {
+  SCOPED_ATOMIC(FetchNand, a, v, mo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, morder mo) {
+  SCOPED_ATOMIC(FetchNand, a, v, mo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+
+#if __TSAN_HAS_INT128
+SANITIZER_INTERFACE_ATTRIBUTE
+a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v,
+    morder mo, morder fmo) {
+  SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
+}
+#endif
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic_thread_fence(morder mo) {
+  char* a = 0;
+  SCOPED_ATOMIC(Fence, mo);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_atomic_signal_fence(morder mo) {
+}
+}  // extern "C"
+
+#else  // #ifndef SANITIZER_GO
+
+// Go
+
+#define ATOMIC(func, ...) \
+    if (thr->ignore_sync) { \
+      NoTsanAtomic##func(__VA_ARGS__); \
+    } else { \
+      FuncEntry(thr, cpc); \
+      Atomic##func(thr, pc, __VA_ARGS__); \
+      FuncExit(thr); \
+    } \
+/**/
+
+#define ATOMIC_RET(func, ret, ...) \
+    if (thr->ignore_sync) { \
+      (ret) = NoTsanAtomic##func(__VA_ARGS__); \
+    } else { \
+      FuncEntry(thr, cpc); \
+      (ret) = Atomic##func(thr, pc, __VA_ARGS__); \
+      FuncExit(thr); \
+    } \
+/**/
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(Load, *(a32*)(a+8), *(a32**)a, mo_acquire);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(Load, *(a64*)(a+8), *(a64**)a, mo_acquire);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC(Store, *(a32**)a, *(a32*)(a+8), mo_release);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC(Store, *(a64**)a, *(a64*)(a+8), mo_release);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(FetchAdd, *(a32*)(a+16), *(a32**)a, *(a32*)(a+8), mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(FetchAdd, *(a64*)(a+16), *(a64**)a, *(a64*)(a+8), mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(Exchange, *(a32*)(a+16), *(a32**)a, *(a32*)(a+8), mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(Exchange, *(a64*)(a+16), *(a64**)a, *(a64*)(a+8), mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_compare_exchange(
+    ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  a32 cur = 0;
+  a32 cmp = *(a32*)(a+8);
+  ATOMIC_RET(CAS, cur, *(a32**)a, cmp, *(a32*)(a+12), mo_acq_rel, mo_acquire);
+  *(bool*)(a+16) = (cur == cmp);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_compare_exchange(
+    ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  a64 cur = 0;
+  a64 cmp = *(a64*)(a+8);
+  ATOMIC_RET(CAS, cur, *(a64**)a, cmp, *(a64*)(a+16), mo_acq_rel, mo_acquire);
+  *(bool*)(a+24) = (cur == cmp);
+}
+}  // extern "C"
+#endif  // #ifndef SANITIZER_GO
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_inl.h b/compiler-rt/lib/tsan/rtl/tsan_interface_inl.h
new file mode 100644
index 0000000..8852aa3
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_inl.h
@@ -0,0 +1,117 @@
+//===-- tsan_interface_inl.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "tsan_interface.h"
+#include "tsan_rtl.h"
+
+#define CALLERPC ((uptr)__builtin_return_address(0))
+
+using namespace __tsan;  // NOLINT
+
+void __tsan_read1(void *addr) {
+  MemoryRead(cur_thread(), CALLERPC, (uptr)addr, kSizeLog1);
+}
+
+void __tsan_read2(void *addr) {
+  MemoryRead(cur_thread(), CALLERPC, (uptr)addr, kSizeLog2);
+}
+
+void __tsan_read4(void *addr) {
+  MemoryRead(cur_thread(), CALLERPC, (uptr)addr, kSizeLog4);
+}
+
+void __tsan_read8(void *addr) {
+  MemoryRead(cur_thread(), CALLERPC, (uptr)addr, kSizeLog8);
+}
+
+void __tsan_write1(void *addr) {
+  MemoryWrite(cur_thread(), CALLERPC, (uptr)addr, kSizeLog1);
+}
+
+void __tsan_write2(void *addr) {
+  MemoryWrite(cur_thread(), CALLERPC, (uptr)addr, kSizeLog2);
+}
+
+void __tsan_write4(void *addr) {
+  MemoryWrite(cur_thread(), CALLERPC, (uptr)addr, kSizeLog4);
+}
+
+void __tsan_write8(void *addr) {
+  MemoryWrite(cur_thread(), CALLERPC, (uptr)addr, kSizeLog8);
+}
+
+void __tsan_read1_pc(void *addr, void *pc) {
+  MemoryRead(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog1);
+}
+
+void __tsan_read2_pc(void *addr, void *pc) {
+  MemoryRead(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog2);
+}
+
+void __tsan_read4_pc(void *addr, void *pc) {
+  MemoryRead(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog4);
+}
+
+void __tsan_read8_pc(void *addr, void *pc) {
+  MemoryRead(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog8);
+}
+
+void __tsan_write1_pc(void *addr, void *pc) {
+  MemoryWrite(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog1);
+}
+
+void __tsan_write2_pc(void *addr, void *pc) {
+  MemoryWrite(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog2);
+}
+
+void __tsan_write4_pc(void *addr, void *pc) {
+  MemoryWrite(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog4);
+}
+
+void __tsan_write8_pc(void *addr, void *pc) {
+  MemoryWrite(cur_thread(), (uptr)pc, (uptr)addr, kSizeLog8);
+}
+
+void __tsan_vptr_update(void **vptr_p, void *new_val) {
+  CHECK_EQ(sizeof(vptr_p), 8);
+  if (*vptr_p != new_val) {
+    ThreadState *thr = cur_thread();
+    thr->is_vptr_access = true;
+    MemoryWrite(thr, CALLERPC, (uptr)vptr_p, kSizeLog8);
+    thr->is_vptr_access = false;
+  }
+}
+
+void __tsan_vptr_read(void **vptr_p) {
+  CHECK_EQ(sizeof(vptr_p), 8);
+  ThreadState *thr = cur_thread();
+  thr->is_vptr_access = true;
+  MemoryRead(thr, CALLERPC, (uptr)vptr_p, kSizeLog8);
+  thr->is_vptr_access = false;
+}
+
+void __tsan_func_entry(void *pc) {
+  FuncEntry(cur_thread(), (uptr)pc);
+}
+
+void __tsan_func_exit() {
+  FuncExit(cur_thread());
+}
+
+void __tsan_read_range(void *addr, uptr size) {
+  MemoryAccessRange(cur_thread(), CALLERPC, (uptr)addr, size, false);
+}
+
+void __tsan_write_range(void *addr, uptr size) {
+  MemoryAccessRange(cur_thread(), CALLERPC, (uptr)addr, size, true);
+}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_java.cc b/compiler-rt/lib/tsan/rtl/tsan_interface_java.cc
new file mode 100644
index 0000000..0aea63d
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_java.cc
@@ -0,0 +1,251 @@
+//===-- tsan_interface_java.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "tsan_interface_java.h"
+#include "tsan_rtl.h"
+#include "tsan_mutex.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+
+using namespace __tsan;  // NOLINT
+
+const jptr kHeapAlignment = 8;
+
+namespace __tsan {
+
+struct JavaContext {
+  const uptr heap_begin;
+  const uptr heap_size;
+
+  JavaContext(jptr heap_begin, jptr heap_size)
+      : heap_begin(heap_begin)
+      , heap_size(heap_size) {
+  }
+};
+
+class ScopedJavaFunc {
+ public:
+  ScopedJavaFunc(ThreadState *thr, uptr pc)
+      : thr_(thr) {
+    Initialize(thr_);
+    FuncEntry(thr, pc);
+  }
+
+  ~ScopedJavaFunc() {
+    FuncExit(thr_);
+    // FIXME(dvyukov): process pending signals.
+  }
+
+ private:
+  ThreadState *thr_;
+};
+
+static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1];
+static JavaContext *jctx;
+
+}  // namespace __tsan
+
+#define SCOPED_JAVA_FUNC(func) \
+  ThreadState *thr = cur_thread(); \
+  const uptr caller_pc = GET_CALLER_PC(); \
+  const uptr pc = StackTrace::GetCurrentPc(); \
+  (void)pc; \
+  ScopedJavaFunc scoped(thr, caller_pc); \
+/**/
+
+void __tsan_java_init(jptr heap_begin, jptr heap_size) {
+  SCOPED_JAVA_FUNC(__tsan_java_init);
+  DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size);
+  CHECK_EQ(jctx, 0);
+  CHECK_GT(heap_begin, 0);
+  CHECK_GT(heap_size, 0);
+  CHECK_EQ(heap_begin % kHeapAlignment, 0);
+  CHECK_EQ(heap_size % kHeapAlignment, 0);
+  CHECK_LT(heap_begin, heap_begin + heap_size);
+  jctx = new(jctx_buf) JavaContext(heap_begin, heap_size);
+}
+
+int  __tsan_java_fini() {
+  SCOPED_JAVA_FUNC(__tsan_java_fini);
+  DPrintf("#%d: java_fini()\n", thr->tid);
+  CHECK_NE(jctx, 0);
+  // FIXME(dvyukov): this does not call atexit() callbacks.
+  int status = Finalize(thr);
+  DPrintf("#%d: java_fini() = %d\n", thr->tid, status);
+  return status;
+}
+
+void __tsan_java_alloc(jptr ptr, jptr size) {
+  SCOPED_JAVA_FUNC(__tsan_java_alloc);
+  DPrintf("#%d: java_alloc(%p, %p)\n", thr->tid, ptr, size);
+  CHECK_NE(jctx, 0);
+  CHECK_NE(size, 0);
+  CHECK_EQ(ptr % kHeapAlignment, 0);
+  CHECK_EQ(size % kHeapAlignment, 0);
+  CHECK_GE(ptr, jctx->heap_begin);
+  CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
+
+  OnUserAlloc(thr, pc, ptr, size, false);
+}
+
+void __tsan_java_free(jptr ptr, jptr size) {
+  SCOPED_JAVA_FUNC(__tsan_java_free);
+  DPrintf("#%d: java_free(%p, %p)\n", thr->tid, ptr, size);
+  CHECK_NE(jctx, 0);
+  CHECK_NE(size, 0);
+  CHECK_EQ(ptr % kHeapAlignment, 0);
+  CHECK_EQ(size % kHeapAlignment, 0);
+  CHECK_GE(ptr, jctx->heap_begin);
+  CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
+
+  ctx->metamap.FreeRange(thr, pc, ptr, size);
+}
+
+void __tsan_java_move(jptr src, jptr dst, jptr size) {
+  SCOPED_JAVA_FUNC(__tsan_java_move);
+  DPrintf("#%d: java_move(%p, %p, %p)\n", thr->tid, src, dst, size);
+  CHECK_NE(jctx, 0);
+  CHECK_NE(size, 0);
+  CHECK_EQ(src % kHeapAlignment, 0);
+  CHECK_EQ(dst % kHeapAlignment, 0);
+  CHECK_EQ(size % kHeapAlignment, 0);
+  CHECK_GE(src, jctx->heap_begin);
+  CHECK_LE(src + size, jctx->heap_begin + jctx->heap_size);
+  CHECK_GE(dst, jctx->heap_begin);
+  CHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);
+  CHECK_NE(dst, src);
+  CHECK_NE(size, 0);
+
+  // Assuming it's not running concurrently with threads that do
+  // memory accesses and mutex operations (stop-the-world phase).
+  ctx->metamap.MoveMemory(src, dst, size);
+
+  // Move shadow.
+  u64 *s = (u64*)MemToShadow(src);
+  u64 *d = (u64*)MemToShadow(dst);
+  u64 *send = (u64*)MemToShadow(src + size);
+  uptr inc = 1;
+  if (dst > src) {
+    s = (u64*)MemToShadow(src + size) - 1;
+    d = (u64*)MemToShadow(dst + size) - 1;
+    send = (u64*)MemToShadow(src) - 1;
+    inc = -1;
+  }
+  for (; s != send; s += inc, d += inc) {
+    *d = *s;
+    *s = 0;
+  }
+}
+
+void __tsan_java_finalize() {
+  SCOPED_JAVA_FUNC(__tsan_java_finalize);
+  DPrintf("#%d: java_mutex_finalize()\n", thr->tid);
+  AcquireGlobal(thr, 0);
+}
+
+void __tsan_java_mutex_lock(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_mutex_lock);
+  DPrintf("#%d: java_mutex_lock(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  MutexCreate(thr, pc, addr, true, true, true);
+  MutexLock(thr, pc, addr);
+}
+
+void __tsan_java_mutex_unlock(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock);
+  DPrintf("#%d: java_mutex_unlock(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  MutexUnlock(thr, pc, addr);
+}
+
+void __tsan_java_mutex_read_lock(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_mutex_read_lock);
+  DPrintf("#%d: java_mutex_read_lock(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  MutexCreate(thr, pc, addr, true, true, true);
+  MutexReadLock(thr, pc, addr);
+}
+
+void __tsan_java_mutex_read_unlock(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_mutex_read_unlock);
+  DPrintf("#%d: java_mutex_read_unlock(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  MutexReadUnlock(thr, pc, addr);
+}
+
+void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
+  SCOPED_JAVA_FUNC(__tsan_java_mutex_lock_rec);
+  DPrintf("#%d: java_mutex_lock_rec(%p, %d)\n", thr->tid, addr, rec);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+  CHECK_GT(rec, 0);
+
+  MutexCreate(thr, pc, addr, true, true, true);
+  MutexLock(thr, pc, addr, rec);
+}
+
+int __tsan_java_mutex_unlock_rec(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock_rec);
+  DPrintf("#%d: java_mutex_unlock_rec(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  return MutexUnlock(thr, pc, addr, true);
+}
+
+void __tsan_java_acquire(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_acquire);
+  DPrintf("#%d: java_acquire(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  Acquire(thr, caller_pc, addr);
+}
+
+void __tsan_java_release(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_release);
+  DPrintf("#%d: java_release(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  Release(thr, caller_pc, addr);
+}
+
+void __tsan_java_release_store(jptr addr) {
+  SCOPED_JAVA_FUNC(__tsan_java_release);
+  DPrintf("#%d: java_release_store(%p)\n", thr->tid, addr);
+  CHECK_NE(jctx, 0);
+  CHECK_GE(addr, jctx->heap_begin);
+  CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
+
+  ReleaseStore(thr, caller_pc, addr);
+}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_interface_java.h b/compiler-rt/lib/tsan/rtl/tsan_interface_java.h
new file mode 100644
index 0000000..30153a1
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_interface_java.h
@@ -0,0 +1,96 @@
+//===-- tsan_interface_java.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Interface for verification of Java or mixed Java/C++ programs.
+// The interface is intended to be used from within a JVM and notify TSan
+// about such events like Java locks and GC memory compaction.
+//
+// For plain memory accesses and function entry/exit a JVM is intended to use
+// C++ interfaces: __tsan_readN/writeN and __tsan_func_enter/exit.
+//
+// For volatile memory accesses and atomic operations JVM is intended to use
+// standard atomics API: __tsan_atomicN_load/store/etc.
+//
+// For usage examples see lit_tests/java_*.cc
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_INTERFACE_JAVA_H
+#define TSAN_INTERFACE_JAVA_H
+
+#ifndef INTERFACE_ATTRIBUTE
+# define INTERFACE_ATTRIBUTE __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned long jptr;  // NOLINT
+
+// Must be called before any other callback from Java.
+void __tsan_java_init(jptr heap_begin, jptr heap_size) INTERFACE_ATTRIBUTE;
+// Must be called when the application exits.
+// Not necessary the last callback (concurrently running threads are OK).
+// Returns exit status or 0 if tsan does not want to override it.
+int  __tsan_java_fini() INTERFACE_ATTRIBUTE;
+
+// Callback for memory allocations.
+// May be omitted for allocations that are not subject to data races
+// nor contain synchronization objects (e.g. String).
+void __tsan_java_alloc(jptr ptr, jptr size) INTERFACE_ATTRIBUTE;
+// Callback for memory free.
+// Can be aggregated for several objects (preferably).
+void __tsan_java_free(jptr ptr, jptr size) INTERFACE_ATTRIBUTE;
+// Callback for memory move by GC.
+// Can be aggregated for several objects (preferably).
+// The ranges can overlap.
+void __tsan_java_move(jptr src, jptr dst, jptr size) INTERFACE_ATTRIBUTE;
+// This function must be called on the finalizer thread
+// before executing a batch of finalizers.
+// It ensures necessary synchronization between
+// java object creation and finalization.
+void __tsan_java_finalize() INTERFACE_ATTRIBUTE;
+
+// Mutex lock.
+// Addr is any unique address associated with the mutex.
+// Can be called on recursive reentry.
+void __tsan_java_mutex_lock(jptr addr) INTERFACE_ATTRIBUTE;
+// Mutex unlock.
+void __tsan_java_mutex_unlock(jptr addr) INTERFACE_ATTRIBUTE;
+// Mutex read lock.
+void __tsan_java_mutex_read_lock(jptr addr) INTERFACE_ATTRIBUTE;
+// Mutex read unlock.
+void __tsan_java_mutex_read_unlock(jptr addr) INTERFACE_ATTRIBUTE;
+// Recursive mutex lock, intended for handling of Object.wait().
+// The 'rec' value must be obtained from the previous
+// __tsan_java_mutex_unlock_rec().
+void __tsan_java_mutex_lock_rec(jptr addr, int rec) INTERFACE_ATTRIBUTE;
+// Recursive mutex unlock, intended for handling of Object.wait().
+// The return value says how many times this thread called lock()
+// w/o a pairing unlock() (i.e. how many recursive levels it unlocked).
+// It must be passed back to __tsan_java_mutex_lock_rec() to restore
+// the same recursion level.
+int __tsan_java_mutex_unlock_rec(jptr addr) INTERFACE_ATTRIBUTE;
+
+// Raw acquire/release primitives.
+// Can be used to establish happens-before edges on volatile/final fields,
+// in atomic operations, etc. release_store is the same as release, but it
+// breaks release sequence on addr (see C++ standard 1.10/7 for details).
+void __tsan_java_acquire(jptr addr) INTERFACE_ATTRIBUTE;
+void __tsan_java_release(jptr addr) INTERFACE_ATTRIBUTE;
+void __tsan_java_release_store(jptr addr) INTERFACE_ATTRIBUTE;
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#undef INTERFACE_ATTRIBUTE
+
+#endif  // #ifndef TSAN_INTERFACE_JAVA_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_libdispatch_mac.cc b/compiler-rt/lib/tsan/rtl/tsan_libdispatch_mac.cc
new file mode 100644
index 0000000..617dc91
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_libdispatch_mac.cc
@@ -0,0 +1,284 @@
+//===-- tsan_libdispatch_mac.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Mac-specific libdispatch (GCD) support.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "interception/interception.h"
+#include "tsan_interceptors.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+
+#include <Block.h>
+#include <dispatch/dispatch.h>
+#include <pthread.h>
+
+typedef long long_t;  // NOLINT
+
+namespace __tsan {
+
+typedef struct {
+  dispatch_queue_t queue;
+  void *orig_context;
+  dispatch_function_t orig_work;
+  uptr object_to_acquire;
+  dispatch_object_t object_to_release;
+} tsan_block_context_t;
+
+// The offsets of different fields of the dispatch_queue_t structure, exported
+// by libdispatch.dylib.
+extern "C" struct dispatch_queue_offsets_s {
+  const uint16_t dqo_version;
+  const uint16_t dqo_label;
+  const uint16_t dqo_label_size;
+  const uint16_t dqo_flags;
+  const uint16_t dqo_flags_size;
+  const uint16_t dqo_serialnum;
+  const uint16_t dqo_serialnum_size;
+  const uint16_t dqo_width;
+  const uint16_t dqo_width_size;
+  const uint16_t dqo_running;
+  const uint16_t dqo_running_size;
+  const uint16_t dqo_suspend_cnt;
+  const uint16_t dqo_suspend_cnt_size;
+  const uint16_t dqo_target_queue;
+  const uint16_t dqo_target_queue_size;
+  const uint16_t dqo_priority;
+  const uint16_t dqo_priority_size;
+} dispatch_queue_offsets;
+
+static bool IsQueueSerial(dispatch_queue_t q) {
+  CHECK_EQ(dispatch_queue_offsets.dqo_width_size, 2);
+  uptr width = *(uint16_t *)(((uptr)q) + dispatch_queue_offsets.dqo_width);
+  CHECK_NE(width, 0);
+  return width == 1;
+}
+
+static tsan_block_context_t *AllocContext(ThreadState *thr, uptr pc,
+                                          dispatch_queue_t queue,
+                                          void *orig_context,
+                                          dispatch_function_t orig_work) {
+  tsan_block_context_t *new_context =
+      (tsan_block_context_t *)user_alloc(thr, pc, sizeof(tsan_block_context_t));
+  new_context->queue = queue;
+  new_context->orig_context = orig_context;
+  new_context->orig_work = orig_work;
+  new_context->object_to_acquire = (uptr)new_context;
+  new_context->object_to_release = nullptr;
+  return new_context;
+}
+
+static void dispatch_callback_wrap_acquire(void *param) {
+  SCOPED_INTERCEPTOR_RAW(dispatch_async_f_callback_wrap);
+  tsan_block_context_t *context = (tsan_block_context_t *)param;
+  Acquire(thr, pc, context->object_to_acquire);
+
+  // Extra retain/release is required for dispatch groups. We use the group
+  // itself to synchronize, but in a notification (dispatch_group_notify
+  // callback), it may be disposed already. To solve this, we retain the group
+  // and release it here.
+  if (context->object_to_release) dispatch_release(context->object_to_release);
+
+  // In serial queues, work items can be executed on different threads, we need
+  // to explicitly synchronize on the queue itself.
+  if (IsQueueSerial(context->queue)) Acquire(thr, pc, (uptr)context->queue);
+  SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START();
+  context->orig_work(context->orig_context);
+  SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END();
+  if (IsQueueSerial(context->queue)) Release(thr, pc, (uptr)context->queue);
+  user_free(thr, pc, context);
+}
+
+static void invoke_and_release_block(void *param) {
+  dispatch_block_t block = (dispatch_block_t)param;
+  block();
+  Block_release(block);
+}
+
+#define DISPATCH_INTERCEPT_B(name)                                           \
+  TSAN_INTERCEPTOR(void, name, dispatch_queue_t q, dispatch_block_t block) { \
+    SCOPED_TSAN_INTERCEPTOR(name, q, block);                                 \
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START(); \
+    dispatch_block_t heap_block = Block_copy(block);                         \
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END(); \
+    tsan_block_context_t *new_context =                                      \
+        AllocContext(thr, pc, q, heap_block, &invoke_and_release_block);     \
+    Release(thr, pc, (uptr)new_context);                                     \
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START(); \
+    REAL(name##_f)(q, new_context, dispatch_callback_wrap_acquire);          \
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END(); \
+  }
+
+#define DISPATCH_INTERCEPT_F(name)                                \
+  TSAN_INTERCEPTOR(void, name, dispatch_queue_t q, void *context, \
+                   dispatch_function_t work) {                    \
+    SCOPED_TSAN_INTERCEPTOR(name, q, context, work);              \
+    tsan_block_context_t *new_context =                           \
+        AllocContext(thr, pc, q, context, work);                  \
+    Release(thr, pc, (uptr)new_context);                          \
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START(); \
+    REAL(name)(q, new_context, dispatch_callback_wrap_acquire);   \
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END(); \
+  }
+
+// We wrap dispatch_async, dispatch_sync and friends where we allocate a new
+// context, which is used to synchronize (we release the context before
+// submitting, and the callback acquires it before executing the original
+// callback).
+DISPATCH_INTERCEPT_B(dispatch_async)
+DISPATCH_INTERCEPT_B(dispatch_barrier_async)
+DISPATCH_INTERCEPT_F(dispatch_async_f)
+DISPATCH_INTERCEPT_F(dispatch_barrier_async_f)
+DISPATCH_INTERCEPT_B(dispatch_sync)
+DISPATCH_INTERCEPT_B(dispatch_barrier_sync)
+DISPATCH_INTERCEPT_F(dispatch_sync_f)
+DISPATCH_INTERCEPT_F(dispatch_barrier_sync_f)
+
+// GCD's dispatch_once implementation has a fast path that contains a racy read
+// and it's inlined into user's code. Furthermore, this fast path doesn't
+// establish a proper happens-before relations between the initialization and
+// code following the call to dispatch_once. We could deal with this in
+// instrumented code, but there's not much we can do about it in system
+// libraries. Let's disable the fast path (by never storing the value ~0 to
+// predicate), so the interceptor is always called, and let's add proper release
+// and acquire semantics. Since TSan does not see its own atomic stores, the
+// race on predicate won't be reported - the only accesses to it that TSan sees
+// are the loads on the fast path. Loads don't race. Secondly, dispatch_once is
+// both a macro and a real function, we want to intercept the function, so we
+// need to undefine the macro.
+#undef dispatch_once
+TSAN_INTERCEPTOR(void, dispatch_once, dispatch_once_t *predicate,
+                 dispatch_block_t block) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_once, predicate, block);
+  atomic_uint32_t *a = reinterpret_cast<atomic_uint32_t *>(predicate);
+  u32 v = atomic_load(a, memory_order_acquire);
+  if (v == 0 &&
+      atomic_compare_exchange_strong(a, &v, 1, memory_order_relaxed)) {
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START();
+    block();
+    SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END();
+    Release(thr, pc, (uptr)a);
+    atomic_store(a, 2, memory_order_release);
+  } else {
+    while (v != 2) {
+      internal_sched_yield();
+      v = atomic_load(a, memory_order_acquire);
+    }
+    Acquire(thr, pc, (uptr)a);
+  }
+}
+
+#undef dispatch_once_f
+TSAN_INTERCEPTOR(void, dispatch_once_f, dispatch_once_t *predicate,
+                 void *context, dispatch_function_t function) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_once_f, predicate, context, function);
+  SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START();
+  WRAP(dispatch_once)(predicate, ^(void) {
+    function(context);
+  });
+  SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END();
+}
+
+TSAN_INTERCEPTOR(long_t, dispatch_semaphore_signal,
+                 dispatch_semaphore_t dsema) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_semaphore_signal, dsema);
+  Release(thr, pc, (uptr)dsema);
+  return REAL(dispatch_semaphore_signal)(dsema);
+}
+
+TSAN_INTERCEPTOR(long_t, dispatch_semaphore_wait, dispatch_semaphore_t dsema,
+                 dispatch_time_t timeout) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_semaphore_wait, dsema, timeout);
+  long_t result = REAL(dispatch_semaphore_wait)(dsema, timeout);
+  if (result == 0) Acquire(thr, pc, (uptr)dsema);
+  return result;
+}
+
+TSAN_INTERCEPTOR(long_t, dispatch_group_wait, dispatch_group_t group,
+                 dispatch_time_t timeout) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_group_wait, group, timeout);
+  long_t result = REAL(dispatch_group_wait)(group, timeout);
+  if (result == 0) Acquire(thr, pc, (uptr)group);
+  return result;
+}
+
+TSAN_INTERCEPTOR(void, dispatch_group_leave, dispatch_group_t group) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_group_leave, group);
+  Release(thr, pc, (uptr)group);
+  REAL(dispatch_group_leave)(group);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_group_async, dispatch_group_t group,
+                 dispatch_queue_t queue, dispatch_block_t block) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_group_async, group, queue, block);
+  dispatch_retain(group);
+  dispatch_group_enter(group);
+  WRAP(dispatch_async)(queue, ^(void) {
+    block();
+    WRAP(dispatch_group_leave)(group);
+    dispatch_release(group);
+  });
+}
+
+TSAN_INTERCEPTOR(void, dispatch_group_async_f, dispatch_group_t group,
+                 dispatch_queue_t queue, void *context,
+                 dispatch_function_t work) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_group_async_f, group, queue, context, work);
+  dispatch_retain(group);
+  dispatch_group_enter(group);
+  WRAP(dispatch_async)(queue, ^(void) {
+    work(context);
+    WRAP(dispatch_group_leave)(group);
+    dispatch_release(group);
+  });
+}
+
+TSAN_INTERCEPTOR(void, dispatch_group_notify, dispatch_group_t group,
+                 dispatch_queue_t q, dispatch_block_t block) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_group_notify, group, q, block);
+  SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START();
+  dispatch_block_t heap_block = Block_copy(block);
+  SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END();
+  tsan_block_context_t *new_context =
+      AllocContext(thr, pc, q, heap_block, &invoke_and_release_block);
+  new_context->object_to_acquire = (uptr)group;
+
+  // Will be released in dispatch_callback_wrap_acquire.
+  new_context->object_to_release = group;
+  dispatch_retain(group);
+
+  Release(thr, pc, (uptr)group);
+  REAL(dispatch_group_notify_f)(group, q, new_context,
+                                dispatch_callback_wrap_acquire);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_group_notify_f, dispatch_group_t group,
+                 dispatch_queue_t q, void *context, dispatch_function_t work) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_group_notify_f, group, q, context, work);
+  tsan_block_context_t *new_context = AllocContext(thr, pc, q, context, work);
+  new_context->object_to_acquire = (uptr)group;
+
+  // Will be released in dispatch_callback_wrap_acquire.
+  new_context->object_to_release = group;
+  dispatch_retain(group);
+
+  Release(thr, pc, (uptr)group);
+  REAL(dispatch_group_notify_f)(group, q, new_context,
+                                dispatch_callback_wrap_acquire);
+}
+
+}  // namespace __tsan
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/tsan/rtl/tsan_malloc_mac.cc b/compiler-rt/lib/tsan/rtl/tsan_malloc_mac.cc
new file mode 100644
index 0000000..7fd9427
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_malloc_mac.cc
@@ -0,0 +1,65 @@
+//===-- tsan_malloc_mac.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Mac-specific malloc interception.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "tsan_interceptors.h"
+#include "tsan_stack_trace.h"
+
+using namespace __tsan;
+#define COMMON_MALLOC_ZONE_NAME "tsan"
+#define COMMON_MALLOC_ENTER()
+#define COMMON_MALLOC_SANITIZER_INITIALIZED (cur_thread()->is_inited)
+#define COMMON_MALLOC_FORCE_LOCK()
+#define COMMON_MALLOC_FORCE_UNLOCK()
+#define COMMON_MALLOC_MEMALIGN(alignment, size) \
+  void *p =                                     \
+      user_alloc(cur_thread(), StackTrace::GetCurrentPc(), size, alignment)
+#define COMMON_MALLOC_MALLOC(size)      \
+  if (cur_thread()->in_symbolizer)      \
+    return REAL(malloc)(size);          \
+  SCOPED_INTERCEPTOR_RAW(malloc, size); \
+  void *p = user_alloc(thr, pc, size)
+#define COMMON_MALLOC_REALLOC(ptr, size)      \
+  if (cur_thread()->in_symbolizer)            \
+    return REAL(realloc)(ptr, size);          \
+  SCOPED_INTERCEPTOR_RAW(realloc, ptr, size); \
+  void *p = user_realloc(thr, pc, ptr, size)
+#define COMMON_MALLOC_CALLOC(count, size)      \
+  if (cur_thread()->in_symbolizer)             \
+    return REAL(calloc)(count, size);          \
+  SCOPED_INTERCEPTOR_RAW(calloc, size, count); \
+  void *p = user_calloc(thr, pc, size, count)
+#define COMMON_MALLOC_VALLOC(size)                          \
+  if (cur_thread()->in_symbolizer)                          \
+    return REAL(valloc)(size);                              \
+  SCOPED_INTERCEPTOR_RAW(valloc, size);                     \
+  void *p = user_alloc(thr, pc, size, GetPageSizeCached())
+#define COMMON_MALLOC_FREE(ptr)      \
+  if (cur_thread()->in_symbolizer)   \
+    return REAL(free)(ptr);          \
+  SCOPED_INTERCEPTOR_RAW(free, ptr); \
+  user_free(thr, pc, ptr)
+#define COMMON_MALLOC_SIZE(ptr) \
+  uptr size = user_alloc_usable_size(ptr);
+#define COMMON_MALLOC_FILL_STATS(zone, stats)
+#define COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name) \
+  (void)zone_name; \
+  Report("mz_realloc(%p) -- attempting to realloc unallocated memory.\n", ptr);
+#define COMMON_MALLOC_NAMESPACE __tsan
+
+#include "sanitizer_common/sanitizer_malloc_mac.inc"
+
+#endif
diff --git a/compiler-rt/lib/tsan/rtl/tsan_md5.cc b/compiler-rt/lib/tsan/rtl/tsan_md5.cc
new file mode 100644
index 0000000..51279c1
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_md5.cc
@@ -0,0 +1,243 @@
+//===-- tsan_md5.cc -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_defs.h"
+
+namespace __tsan {
+
+#define F(x, y, z)      ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)      ((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z)      ((x) ^ (y) ^ (z))
+#define I(x, y, z)      ((y) ^ ((x) | ~(z)))
+
+#define STEP(f, a, b, c, d, x, t, s) \
+  (a) += f((b), (c), (d)) + (x) + (t); \
+  (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+  (a) += (b);
+
+#define SET(n) \
+  (*(const MD5_u32plus *)&ptr[(n) * 4])
+#define GET(n) \
+  SET(n)
+
+typedef unsigned int MD5_u32plus;
+typedef unsigned long ulong_t;  // NOLINT
+
+typedef struct {
+  MD5_u32plus lo, hi;
+  MD5_u32plus a, b, c, d;
+  unsigned char buffer[64];
+  MD5_u32plus block[16];
+} MD5_CTX;
+
+static const void *body(MD5_CTX *ctx, const void *data, ulong_t size) {
+  const unsigned char *ptr = (const unsigned char *)data;
+  MD5_u32plus a, b, c, d;
+  MD5_u32plus saved_a, saved_b, saved_c, saved_d;
+
+  a = ctx->a;
+  b = ctx->b;
+  c = ctx->c;
+  d = ctx->d;
+
+  do {
+    saved_a = a;
+    saved_b = b;
+    saved_c = c;
+    saved_d = d;
+
+    STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
+    STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
+    STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
+    STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
+    STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
+    STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
+    STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
+    STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
+    STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
+    STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
+    STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
+    STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
+    STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
+    STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
+    STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
+    STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
+
+    STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
+    STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
+    STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
+    STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
+    STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
+    STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
+    STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
+    STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
+    STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
+    STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
+    STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
+    STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
+    STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
+    STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
+    STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
+    STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
+
+    STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
+    STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
+    STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
+    STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
+    STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
+    STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
+    STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
+    STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
+    STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
+    STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
+    STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
+    STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
+    STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
+    STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
+    STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
+    STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
+
+    STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
+    STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
+    STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
+    STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
+    STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
+    STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
+    STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
+    STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
+    STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
+    STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
+    STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
+    STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
+    STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
+    STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
+    STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
+    STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
+
+    a += saved_a;
+    b += saved_b;
+    c += saved_c;
+    d += saved_d;
+
+    ptr += 64;
+  } while (size -= 64);
+
+  ctx->a = a;
+  ctx->b = b;
+  ctx->c = c;
+  ctx->d = d;
+
+  return ptr;
+}
+
+void MD5_Init(MD5_CTX *ctx) {
+  ctx->a = 0x67452301;
+  ctx->b = 0xefcdab89;
+  ctx->c = 0x98badcfe;
+  ctx->d = 0x10325476;
+
+  ctx->lo = 0;
+  ctx->hi = 0;
+}
+
+void MD5_Update(MD5_CTX *ctx, const void *data, ulong_t size) {
+  MD5_u32plus saved_lo;
+  ulong_t used, free;
+
+  saved_lo = ctx->lo;
+  if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+    ctx->hi++;
+  ctx->hi += size >> 29;
+
+  used = saved_lo & 0x3f;
+
+  if (used) {
+    free = 64 - used;
+
+    if (size < free) {
+      internal_memcpy(&ctx->buffer[used], data, size);
+      return;
+    }
+
+    internal_memcpy(&ctx->buffer[used], data, free);
+    data = (const unsigned char *)data + free;
+    size -= free;
+    body(ctx, ctx->buffer, 64);
+  }
+
+  if (size >= 64) {
+    data = body(ctx, data, size & ~(ulong_t)0x3f);
+    size &= 0x3f;
+  }
+
+  internal_memcpy(ctx->buffer, data, size);
+}
+
+void MD5_Final(unsigned char *result, MD5_CTX *ctx) {
+  ulong_t used, free;
+
+  used = ctx->lo & 0x3f;
+
+  ctx->buffer[used++] = 0x80;
+
+  free = 64 - used;
+
+  if (free < 8) {
+    internal_memset(&ctx->buffer[used], 0, free);
+    body(ctx, ctx->buffer, 64);
+    used = 0;
+    free = 64;
+  }
+
+  internal_memset(&ctx->buffer[used], 0, free - 8);
+
+  ctx->lo <<= 3;
+  ctx->buffer[56] = ctx->lo;
+  ctx->buffer[57] = ctx->lo >> 8;
+  ctx->buffer[58] = ctx->lo >> 16;
+  ctx->buffer[59] = ctx->lo >> 24;
+  ctx->buffer[60] = ctx->hi;
+  ctx->buffer[61] = ctx->hi >> 8;
+  ctx->buffer[62] = ctx->hi >> 16;
+  ctx->buffer[63] = ctx->hi >> 24;
+
+  body(ctx, ctx->buffer, 64);
+
+  result[0] = ctx->a;
+  result[1] = ctx->a >> 8;
+  result[2] = ctx->a >> 16;
+  result[3] = ctx->a >> 24;
+  result[4] = ctx->b;
+  result[5] = ctx->b >> 8;
+  result[6] = ctx->b >> 16;
+  result[7] = ctx->b >> 24;
+  result[8] = ctx->c;
+  result[9] = ctx->c >> 8;
+  result[10] = ctx->c >> 16;
+  result[11] = ctx->c >> 24;
+  result[12] = ctx->d;
+  result[13] = ctx->d >> 8;
+  result[14] = ctx->d >> 16;
+  result[15] = ctx->d >> 24;
+
+  internal_memset(ctx, 0, sizeof(*ctx));
+}
+
+MD5Hash md5_hash(const void *data, uptr size) {
+  MD5Hash res;
+  MD5_CTX ctx;
+  MD5_Init(&ctx);
+  MD5_Update(&ctx, data, size);
+  MD5_Final((unsigned char*)&res.hash[0], &ctx);
+  return res;
+}
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mman.cc b/compiler-rt/lib/tsan/rtl/tsan_mman.cc
new file mode 100644
index 0000000..7247c6e
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_mman.cc
@@ -0,0 +1,245 @@
+//===-- tsan_mman.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_allocator_interface.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "tsan_mman.h"
+#include "tsan_rtl.h"
+#include "tsan_report.h"
+#include "tsan_flags.h"
+
+// May be overriden by front-end.
+SANITIZER_WEAK_DEFAULT_IMPL
+void __sanitizer_malloc_hook(void *ptr, uptr size) {
+  (void)ptr;
+  (void)size;
+}
+
+SANITIZER_WEAK_DEFAULT_IMPL
+void __sanitizer_free_hook(void *ptr) {
+  (void)ptr;
+}
+
+namespace __tsan {
+
+struct MapUnmapCallback {
+  void OnMap(uptr p, uptr size) const { }
+  void OnUnmap(uptr p, uptr size) const {
+    // We are about to unmap a chunk of user memory.
+    // Mark the corresponding shadow memory as not needed.
+    DontNeedShadowFor(p, size);
+    // Mark the corresponding meta shadow memory as not needed.
+    // Note the block does not contain any meta info at this point
+    // (this happens after free).
+    const uptr kMetaRatio = kMetaShadowCell / kMetaShadowSize;
+    const uptr kPageSize = GetPageSizeCached() * kMetaRatio;
+    // Block came from LargeMmapAllocator, so must be large.
+    // We rely on this in the calculations below.
+    CHECK_GE(size, 2 * kPageSize);
+    uptr diff = RoundUp(p, kPageSize) - p;
+    if (diff != 0) {
+      p += diff;
+      size -= diff;
+    }
+    diff = p + size - RoundDown(p + size, kPageSize);
+    if (diff != 0)
+      size -= diff;
+    FlushUnneededShadowMemory((uptr)MemToMeta(p), size / kMetaRatio);
+  }
+};
+
+static char allocator_placeholder[sizeof(Allocator)] ALIGNED(64);
+Allocator *allocator() {
+  return reinterpret_cast<Allocator*>(&allocator_placeholder);
+}
+
+void InitializeAllocator() {
+  allocator()->Init(common_flags()->allocator_may_return_null);
+}
+
+void AllocatorThreadStart(ThreadState *thr) {
+  allocator()->InitCache(&thr->alloc_cache);
+  internal_allocator()->InitCache(&thr->internal_alloc_cache);
+}
+
+void AllocatorThreadFinish(ThreadState *thr) {
+  allocator()->DestroyCache(&thr->alloc_cache);
+  internal_allocator()->DestroyCache(&thr->internal_alloc_cache);
+}
+
+void AllocatorPrintStats() {
+  allocator()->PrintStats();
+}
+
+static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
+  if (atomic_load_relaxed(&thr->in_signal_handler) == 0 ||
+      !flags()->report_signal_unsafe)
+    return;
+  VarSizeStackTrace stack;
+  ObtainCurrentStack(thr, pc, &stack);
+  if (IsFiredSuppression(ctx, ReportTypeSignalUnsafe, stack))
+    return;
+  ThreadRegistryLock l(ctx->thread_registry);
+  ScopedReport rep(ReportTypeSignalUnsafe);
+  rep.AddStack(stack, true);
+  OutputReport(thr, rep);
+}
+
+void *user_alloc(ThreadState *thr, uptr pc, uptr sz, uptr align, bool signal) {
+  if ((sz >= (1ull << 40)) || (align >= (1ull << 40)))
+    return allocator()->ReturnNullOrDie();
+  void *p = allocator()->Allocate(&thr->alloc_cache, sz, align);
+  if (p == 0)
+    return 0;
+  if (ctx && ctx->initialized)
+    OnUserAlloc(thr, pc, (uptr)p, sz, true);
+  if (signal)
+    SignalUnsafeCall(thr, pc);
+  return p;
+}
+
+void *user_calloc(ThreadState *thr, uptr pc, uptr size, uptr n) {
+  if (CallocShouldReturnNullDueToOverflow(size, n))
+    return allocator()->ReturnNullOrDie();
+  void *p = user_alloc(thr, pc, n * size);
+  if (p)
+    internal_memset(p, 0, n * size);
+  return p;
+}
+
+void user_free(ThreadState *thr, uptr pc, void *p, bool signal) {
+  if (ctx && ctx->initialized)
+    OnUserFree(thr, pc, (uptr)p, true);
+  allocator()->Deallocate(&thr->alloc_cache, p);
+  if (signal)
+    SignalUnsafeCall(thr, pc);
+}
+
+void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write) {
+  DPrintf("#%d: alloc(%zu) = %p\n", thr->tid, sz, p);
+  ctx->metamap.AllocBlock(thr, pc, p, sz);
+  if (write && thr->ignore_reads_and_writes == 0)
+    MemoryRangeImitateWrite(thr, pc, (uptr)p, sz);
+  else
+    MemoryResetRange(thr, pc, (uptr)p, sz);
+}
+
+void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write) {
+  CHECK_NE(p, (void*)0);
+  uptr sz = ctx->metamap.FreeBlock(thr, pc, p);
+  DPrintf("#%d: free(%p, %zu)\n", thr->tid, p, sz);
+  if (write && thr->ignore_reads_and_writes == 0)
+    MemoryRangeFreed(thr, pc, (uptr)p, sz);
+}
+
+void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
+  void *p2 = 0;
+  // FIXME: Handle "shrinking" more efficiently,
+  // it seems that some software actually does this.
+  if (sz) {
+    p2 = user_alloc(thr, pc, sz);
+    if (p2 == 0)
+      return 0;
+    if (p) {
+      uptr oldsz = user_alloc_usable_size(p);
+      internal_memcpy(p2, p, min(oldsz, sz));
+    }
+  }
+  if (p)
+    user_free(thr, pc, p);
+  return p2;
+}
+
+uptr user_alloc_usable_size(const void *p) {
+  if (p == 0)
+    return 0;
+  MBlock *b = ctx->metamap.GetBlock((uptr)p);
+  return b ? b->siz : 0;
+}
+
+void invoke_malloc_hook(void *ptr, uptr size) {
+  ThreadState *thr = cur_thread();
+  if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
+    return;
+  __sanitizer_malloc_hook(ptr, size);
+}
+
+void invoke_free_hook(void *ptr) {
+  ThreadState *thr = cur_thread();
+  if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
+    return;
+  __sanitizer_free_hook(ptr);
+}
+
+void *internal_alloc(MBlockType typ, uptr sz) {
+  ThreadState *thr = cur_thread();
+  if (thr->nomalloc) {
+    thr->nomalloc = 0;  // CHECK calls internal_malloc().
+    CHECK(0);
+  }
+  return InternalAlloc(sz, &thr->internal_alloc_cache);
+}
+
+void internal_free(void *p) {
+  ThreadState *thr = cur_thread();
+  if (thr->nomalloc) {
+    thr->nomalloc = 0;  // CHECK calls internal_malloc().
+    CHECK(0);
+  }
+  InternalFree(p, &thr->internal_alloc_cache);
+}
+
+}  // namespace __tsan
+
+using namespace __tsan;
+
+extern "C" {
+uptr __sanitizer_get_current_allocated_bytes() {
+  uptr stats[AllocatorStatCount];
+  allocator()->GetStats(stats);
+  return stats[AllocatorStatAllocated];
+}
+
+uptr __sanitizer_get_heap_size() {
+  uptr stats[AllocatorStatCount];
+  allocator()->GetStats(stats);
+  return stats[AllocatorStatMapped];
+}
+
+uptr __sanitizer_get_free_bytes() {
+  return 1;
+}
+
+uptr __sanitizer_get_unmapped_bytes() {
+  return 1;
+}
+
+uptr __sanitizer_get_estimated_allocated_size(uptr size) {
+  return size;
+}
+
+int __sanitizer_get_ownership(const void *p) {
+  return allocator()->GetBlockBegin(p) != 0;
+}
+
+uptr __sanitizer_get_allocated_size(const void *p) {
+  return user_alloc_usable_size(p);
+}
+
+void __tsan_on_thread_idle() {
+  ThreadState *thr = cur_thread();
+  allocator()->SwallowCache(&thr->alloc_cache);
+  internal_allocator()->SwallowCache(&thr->internal_alloc_cache);
+  ctx->metamap.OnThreadIdle(thr);
+}
+}  // extern "C"
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mman.h b/compiler-rt/lib/tsan/rtl/tsan_mman.h
new file mode 100644
index 0000000..b419b58
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_mman.h
@@ -0,0 +1,82 @@
+//===-- tsan_mman.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_MMAN_H
+#define TSAN_MMAN_H
+
+#include "tsan_defs.h"
+
+namespace __tsan {
+
+const uptr kDefaultAlignment = 16;
+
+void InitializeAllocator();
+void ReplaceSystemMalloc();
+void AllocatorThreadStart(ThreadState *thr);
+void AllocatorThreadFinish(ThreadState *thr);
+void AllocatorPrintStats();
+
+// For user allocations.
+void *user_alloc(ThreadState *thr, uptr pc, uptr sz,
+                 uptr align = kDefaultAlignment, bool signal = true);
+void *user_calloc(ThreadState *thr, uptr pc, uptr sz, uptr n);
+// Does not accept NULL.
+void user_free(ThreadState *thr, uptr pc, void *p, bool signal = true);
+void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz);
+void *user_alloc_aligned(ThreadState *thr, uptr pc, uptr sz, uptr align);
+uptr user_alloc_usable_size(const void *p);
+
+// Invoking malloc/free hooks that may be installed by the user.
+void invoke_malloc_hook(void *ptr, uptr size);
+void invoke_free_hook(void *ptr);
+
+enum MBlockType {
+  MBlockScopedBuf,
+  MBlockString,
+  MBlockStackTrace,
+  MBlockShadowStack,
+  MBlockSync,
+  MBlockClock,
+  MBlockThreadContex,
+  MBlockDeadInfo,
+  MBlockRacyStacks,
+  MBlockRacyAddresses,
+  MBlockAtExit,
+  MBlockFlag,
+  MBlockReport,
+  MBlockReportMop,
+  MBlockReportThread,
+  MBlockReportMutex,
+  MBlockReportLoc,
+  MBlockReportStack,
+  MBlockSuppression,
+  MBlockExpectRace,
+  MBlockSignal,
+  MBlockJmpBuf,
+
+  // This must be the last.
+  MBlockTypeCount
+};
+
+// For internal data structures.
+void *internal_alloc(MBlockType typ, uptr sz);
+void internal_free(void *p);
+
+template<typename T>
+void DestroyAndFree(T *&p) {
+  p->~T();
+  internal_free(p);
+  p = 0;
+}
+
+}  // namespace __tsan
+#endif  // TSAN_MMAN_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mutex.cc b/compiler-rt/lib/tsan/rtl/tsan_mutex.cc
new file mode 100644
index 0000000..9dd2480
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_mutex.cc
@@ -0,0 +1,289 @@
+//===-- tsan_mutex.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_libc.h"
+#include "tsan_mutex.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+// Simple reader-writer spin-mutex. Optimized for not-so-contended case.
+// Readers have preference, can possibly starvate writers.
+
+// The table fixes what mutexes can be locked under what mutexes.
+// E.g. if the row for MutexTypeThreads contains MutexTypeReport,
+// then Report mutex can be locked while under Threads mutex.
+// The leaf mutexes can be locked under any other mutexes.
+// Recursive locking is not supported.
+#if SANITIZER_DEBUG && !SANITIZER_GO
+const MutexType MutexTypeLeaf = (MutexType)-1;
+static MutexType CanLockTab[MutexTypeCount][MutexTypeCount] = {
+  /*0  MutexTypeInvalid*/     {},
+  /*1  MutexTypeTrace*/       {MutexTypeLeaf},
+  /*2  MutexTypeThreads*/     {MutexTypeReport},
+  /*3  MutexTypeReport*/      {MutexTypeSyncVar,
+                               MutexTypeMBlock, MutexTypeJavaMBlock},
+  /*4  MutexTypeSyncVar*/     {MutexTypeDDetector},
+  /*5  MutexTypeSyncTab*/     {},  // unused
+  /*6  MutexTypeSlab*/        {MutexTypeLeaf},
+  /*7  MutexTypeAnnotations*/ {},
+  /*8  MutexTypeAtExit*/      {MutexTypeSyncVar},
+  /*9  MutexTypeMBlock*/      {MutexTypeSyncVar},
+  /*10 MutexTypeJavaMBlock*/  {MutexTypeSyncVar},
+  /*11 MutexTypeDDetector*/   {},
+  /*12 MutexTypeFired*/       {MutexTypeLeaf},
+  /*13 MutexTypeRacy*/        {MutexTypeLeaf},
+};
+
+static bool CanLockAdj[MutexTypeCount][MutexTypeCount];
+#endif
+
+void InitializeMutex() {
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  // Build the "can lock" adjacency matrix.
+  // If [i][j]==true, then one can lock mutex j while under mutex i.
+  const int N = MutexTypeCount;
+  int cnt[N] = {};
+  bool leaf[N] = {};
+  for (int i = 1; i < N; i++) {
+    for (int j = 0; j < N; j++) {
+      MutexType z = CanLockTab[i][j];
+      if (z == MutexTypeInvalid)
+        continue;
+      if (z == MutexTypeLeaf) {
+        CHECK(!leaf[i]);
+        leaf[i] = true;
+        continue;
+      }
+      CHECK(!CanLockAdj[i][(int)z]);
+      CanLockAdj[i][(int)z] = true;
+      cnt[i]++;
+    }
+  }
+  for (int i = 0; i < N; i++) {
+    CHECK(!leaf[i] || cnt[i] == 0);
+  }
+  // Add leaf mutexes.
+  for (int i = 0; i < N; i++) {
+    if (!leaf[i])
+      continue;
+    for (int j = 0; j < N; j++) {
+      if (i == j || leaf[j] || j == MutexTypeInvalid)
+        continue;
+      CHECK(!CanLockAdj[j][i]);
+      CanLockAdj[j][i] = true;
+    }
+  }
+  // Build the transitive closure.
+  bool CanLockAdj2[MutexTypeCount][MutexTypeCount];
+  for (int i = 0; i < N; i++) {
+    for (int j = 0; j < N; j++) {
+      CanLockAdj2[i][j] = CanLockAdj[i][j];
+    }
+  }
+  for (int k = 0; k < N; k++) {
+    for (int i = 0; i < N; i++) {
+      for (int j = 0; j < N; j++) {
+        if (CanLockAdj2[i][k] && CanLockAdj2[k][j]) {
+          CanLockAdj2[i][j] = true;
+        }
+      }
+    }
+  }
+#if 0
+  Printf("Can lock graph:\n");
+  for (int i = 0; i < N; i++) {
+    for (int j = 0; j < N; j++) {
+      Printf("%d ", CanLockAdj[i][j]);
+    }
+    Printf("\n");
+  }
+  Printf("Can lock graph closure:\n");
+  for (int i = 0; i < N; i++) {
+    for (int j = 0; j < N; j++) {
+      Printf("%d ", CanLockAdj2[i][j]);
+    }
+    Printf("\n");
+  }
+#endif
+  // Verify that the graph is acyclic.
+  for (int i = 0; i < N; i++) {
+    if (CanLockAdj2[i][i]) {
+      Printf("Mutex %d participates in a cycle\n", i);
+      Die();
+    }
+  }
+#endif
+}
+
+InternalDeadlockDetector::InternalDeadlockDetector() {
+  // Rely on zero initialization because some mutexes can be locked before ctor.
+}
+
+#if SANITIZER_DEBUG && !SANITIZER_GO
+void InternalDeadlockDetector::Lock(MutexType t) {
+  // Printf("LOCK %d @%zu\n", t, seq_ + 1);
+  CHECK_GT(t, MutexTypeInvalid);
+  CHECK_LT(t, MutexTypeCount);
+  u64 max_seq = 0;
+  u64 max_idx = MutexTypeInvalid;
+  for (int i = 0; i != MutexTypeCount; i++) {
+    if (locked_[i] == 0)
+      continue;
+    CHECK_NE(locked_[i], max_seq);
+    if (max_seq < locked_[i]) {
+      max_seq = locked_[i];
+      max_idx = i;
+    }
+  }
+  locked_[t] = ++seq_;
+  if (max_idx == MutexTypeInvalid)
+    return;
+  // Printf("  last %d @%zu\n", max_idx, max_seq);
+  if (!CanLockAdj[max_idx][t]) {
+    Printf("ThreadSanitizer: internal deadlock detected\n");
+    Printf("ThreadSanitizer: can't lock %d while under %zu\n",
+               t, (uptr)max_idx);
+    CHECK(0);
+  }
+}
+
+void InternalDeadlockDetector::Unlock(MutexType t) {
+  // Printf("UNLO %d @%zu #%zu\n", t, seq_, locked_[t]);
+  CHECK(locked_[t]);
+  locked_[t] = 0;
+}
+
+void InternalDeadlockDetector::CheckNoLocks() {
+  for (int i = 0; i != MutexTypeCount; i++) {
+    CHECK_EQ(locked_[i], 0);
+  }
+}
+#endif
+
+void CheckNoLocks(ThreadState *thr) {
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  thr->internal_deadlock_detector.CheckNoLocks();
+#endif
+}
+
+const uptr kUnlocked = 0;
+const uptr kWriteLock = 1;
+const uptr kReadLock = 2;
+
+class Backoff {
+ public:
+  Backoff()
+    : iter_() {
+  }
+
+  bool Do() {
+    if (iter_++ < kActiveSpinIters)
+      proc_yield(kActiveSpinCnt);
+    else
+      internal_sched_yield();
+    return true;
+  }
+
+  u64 Contention() const {
+    u64 active = iter_ % kActiveSpinIters;
+    u64 passive = iter_ - active;
+    return active + 10 * passive;
+  }
+
+ private:
+  int iter_;
+  static const int kActiveSpinIters = 10;
+  static const int kActiveSpinCnt = 20;
+};
+
+Mutex::Mutex(MutexType type, StatType stat_type) {
+  CHECK_GT(type, MutexTypeInvalid);
+  CHECK_LT(type, MutexTypeCount);
+#if SANITIZER_DEBUG
+  type_ = type;
+#endif
+#if TSAN_COLLECT_STATS
+  stat_type_ = stat_type;
+#endif
+  atomic_store(&state_, kUnlocked, memory_order_relaxed);
+}
+
+Mutex::~Mutex() {
+  CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);
+}
+
+void Mutex::Lock() {
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  cur_thread()->internal_deadlock_detector.Lock(type_);
+#endif
+  uptr cmp = kUnlocked;
+  if (atomic_compare_exchange_strong(&state_, &cmp, kWriteLock,
+                                     memory_order_acquire))
+    return;
+  for (Backoff backoff; backoff.Do();) {
+    if (atomic_load(&state_, memory_order_relaxed) == kUnlocked) {
+      cmp = kUnlocked;
+      if (atomic_compare_exchange_weak(&state_, &cmp, kWriteLock,
+                                       memory_order_acquire)) {
+#if TSAN_COLLECT_STATS && !SANITIZER_GO
+        StatInc(cur_thread(), stat_type_, backoff.Contention());
+#endif
+        return;
+      }
+    }
+  }
+}
+
+void Mutex::Unlock() {
+  uptr prev = atomic_fetch_sub(&state_, kWriteLock, memory_order_release);
+  (void)prev;
+  DCHECK_NE(prev & kWriteLock, 0);
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  cur_thread()->internal_deadlock_detector.Unlock(type_);
+#endif
+}
+
+void Mutex::ReadLock() {
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  cur_thread()->internal_deadlock_detector.Lock(type_);
+#endif
+  uptr prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
+  if ((prev & kWriteLock) == 0)
+    return;
+  for (Backoff backoff; backoff.Do();) {
+    prev = atomic_load(&state_, memory_order_acquire);
+    if ((prev & kWriteLock) == 0) {
+#if TSAN_COLLECT_STATS && !SANITIZER_GO
+      StatInc(cur_thread(), stat_type_, backoff.Contention());
+#endif
+      return;
+    }
+  }
+}
+
+void Mutex::ReadUnlock() {
+  uptr prev = atomic_fetch_sub(&state_, kReadLock, memory_order_release);
+  (void)prev;
+  DCHECK_EQ(prev & kWriteLock, 0);
+  DCHECK_GT(prev & ~kWriteLock, 0);
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  cur_thread()->internal_deadlock_detector.Unlock(type_);
+#endif
+}
+
+void Mutex::CheckLocked() {
+  CHECK_NE(atomic_load(&state_, memory_order_relaxed), 0);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mutex.h b/compiler-rt/lib/tsan/rtl/tsan_mutex.h
new file mode 100644
index 0000000..27f5538
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_mutex.h
@@ -0,0 +1,90 @@
+//===-- tsan_mutex.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_MUTEX_H
+#define TSAN_MUTEX_H
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "tsan_defs.h"
+
+namespace __tsan {
+
+enum MutexType {
+  MutexTypeInvalid,
+  MutexTypeTrace,
+  MutexTypeThreads,
+  MutexTypeReport,
+  MutexTypeSyncVar,
+  MutexTypeSyncTab,
+  MutexTypeSlab,
+  MutexTypeAnnotations,
+  MutexTypeAtExit,
+  MutexTypeMBlock,
+  MutexTypeJavaMBlock,
+  MutexTypeDDetector,
+  MutexTypeFired,
+  MutexTypeRacy,
+
+  // This must be the last.
+  MutexTypeCount
+};
+
+class Mutex {
+ public:
+  explicit Mutex(MutexType type, StatType stat_type);
+  ~Mutex();
+
+  void Lock();
+  void Unlock();
+
+  void ReadLock();
+  void ReadUnlock();
+
+  void CheckLocked();
+
+ private:
+  atomic_uintptr_t state_;
+#if SANITIZER_DEBUG
+  MutexType type_;
+#endif
+#if TSAN_COLLECT_STATS
+  StatType stat_type_;
+#endif
+
+  Mutex(const Mutex&);
+  void operator = (const Mutex&);
+};
+
+typedef GenericScopedLock<Mutex> Lock;
+typedef GenericScopedReadLock<Mutex> ReadLock;
+
+class InternalDeadlockDetector {
+ public:
+  InternalDeadlockDetector();
+  void Lock(MutexType t);
+  void Unlock(MutexType t);
+  void CheckNoLocks();
+ private:
+  u64 seq_;
+  u64 locked_[MutexTypeCount];
+};
+
+void InitializeMutex();
+
+// Checks that the current thread does not hold any runtime locks
+// (e.g. when returning from an interceptor).
+void CheckNoLocks(ThreadState *thr);
+
+}  // namespace __tsan
+
+#endif  // TSAN_MUTEX_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mutexset.cc b/compiler-rt/lib/tsan/rtl/tsan_mutexset.cc
new file mode 100644
index 0000000..2158777
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_mutexset.cc
@@ -0,0 +1,89 @@
+//===-- tsan_mutexset.cc --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_mutexset.h"
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+const uptr MutexSet::kMaxSize;
+
+MutexSet::MutexSet() {
+  size_ = 0;
+  internal_memset(&descs_, 0, sizeof(descs_));
+}
+
+void MutexSet::Add(u64 id, bool write, u64 epoch) {
+  // Look up existing mutex with the same id.
+  for (uptr i = 0; i < size_; i++) {
+    if (descs_[i].id == id) {
+      descs_[i].count++;
+      descs_[i].epoch = epoch;
+      return;
+    }
+  }
+  // On overflow, find the oldest mutex and drop it.
+  if (size_ == kMaxSize) {
+    u64 minepoch = (u64)-1;
+    u64 mini = (u64)-1;
+    for (uptr i = 0; i < size_; i++) {
+      if (descs_[i].epoch < minepoch) {
+        minepoch = descs_[i].epoch;
+        mini = i;
+      }
+    }
+    RemovePos(mini);
+    CHECK_EQ(size_, kMaxSize - 1);
+  }
+  // Add new mutex descriptor.
+  descs_[size_].id = id;
+  descs_[size_].write = write;
+  descs_[size_].epoch = epoch;
+  descs_[size_].count = 1;
+  size_++;
+}
+
+void MutexSet::Del(u64 id, bool write) {
+  for (uptr i = 0; i < size_; i++) {
+    if (descs_[i].id == id) {
+      if (--descs_[i].count == 0)
+        RemovePos(i);
+      return;
+    }
+  }
+}
+
+void MutexSet::Remove(u64 id) {
+  for (uptr i = 0; i < size_; i++) {
+    if (descs_[i].id == id) {
+      RemovePos(i);
+      return;
+    }
+  }
+}
+
+void MutexSet::RemovePos(uptr i) {
+  CHECK_LT(i, size_);
+  descs_[i] = descs_[size_ - 1];
+  size_--;
+}
+
+uptr MutexSet::Size() const {
+  return size_;
+}
+
+MutexSet::Desc MutexSet::Get(uptr i) const {
+  CHECK_LT(i, size_);
+  return descs_[i];
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_mutexset.h b/compiler-rt/lib/tsan/rtl/tsan_mutexset.h
new file mode 100644
index 0000000..68f0ec2
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_mutexset.h
@@ -0,0 +1,70 @@
+//===-- tsan_mutexset.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// MutexSet holds the set of mutexes currently held by a thread.
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_MUTEXSET_H
+#define TSAN_MUTEXSET_H
+
+#include "tsan_defs.h"
+
+namespace __tsan {
+
+class MutexSet {
+ public:
+  // Holds limited number of mutexes.
+  // The oldest mutexes are discarded on overflow.
+  static const uptr kMaxSize = 16;
+  struct Desc {
+    u64 id;
+    u64 epoch;
+    int count;
+    bool write;
+  };
+
+  MutexSet();
+  // The 'id' is obtained from SyncVar::GetId().
+  void Add(u64 id, bool write, u64 epoch);
+  void Del(u64 id, bool write);
+  void Remove(u64 id);  // Removes the mutex completely (if it's destroyed).
+  uptr Size() const;
+  Desc Get(uptr i) const;
+
+  void operator=(const MutexSet &other) {
+    internal_memcpy(this, &other, sizeof(*this));
+  }
+
+ private:
+#ifndef SANITIZER_GO
+  uptr size_;
+  Desc descs_[kMaxSize];
+#endif
+
+  void RemovePos(uptr i);
+  MutexSet(const MutexSet&);
+};
+
+// Go does not have mutexes, so do not spend memory and time.
+// (Go sync.Mutex is actually a semaphore -- can be unlocked
+// in different goroutine).
+#ifdef SANITIZER_GO
+MutexSet::MutexSet() {}
+void MutexSet::Add(u64 id, bool write, u64 epoch) {}
+void MutexSet::Del(u64 id, bool write) {}
+void MutexSet::Remove(u64 id) {}
+void MutexSet::RemovePos(uptr i) {}
+uptr MutexSet::Size() const { return 0; }
+MutexSet::Desc MutexSet::Get(uptr i) const { return Desc(); }
+#endif
+
+}  // namespace __tsan
+
+#endif  // TSAN_MUTEXSET_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_new_delete.cc b/compiler-rt/lib/tsan/rtl/tsan_new_delete.cc
new file mode 100644
index 0000000..ebb422c
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_new_delete.cc
@@ -0,0 +1,96 @@
+//===-- tsan_new_delete.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Interceptors for operators new and delete.
+//===----------------------------------------------------------------------===//
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "tsan_interceptors.h"
+
+using namespace __tsan;  // NOLINT
+
+namespace std {
+struct nothrow_t {};
+}  // namespace std
+
+DECLARE_REAL(void *, malloc, uptr size)
+DECLARE_REAL(void, free, void *ptr)
+#if SANITIZER_MAC || SANITIZER_ANDROID
+#define __libc_malloc REAL(malloc)
+#define __libc_free REAL(free)
+#endif
+
+#define OPERATOR_NEW_BODY(mangled_name) \
+  if (cur_thread()->in_symbolizer) \
+    return __libc_malloc(size); \
+  void *p = 0; \
+  {  \
+    SCOPED_INTERCEPTOR_RAW(mangled_name, size); \
+    p = user_alloc(thr, pc, size); \
+  }  \
+  invoke_malloc_hook(p, size);  \
+  return p;
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *operator new(__sanitizer::uptr size);
+void *operator new(__sanitizer::uptr size) {
+  OPERATOR_NEW_BODY(_Znwm);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *operator new[](__sanitizer::uptr size);
+void *operator new[](__sanitizer::uptr size) {
+  OPERATOR_NEW_BODY(_Znam);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *operator new(__sanitizer::uptr size, std::nothrow_t const&);
+void *operator new(__sanitizer::uptr size, std::nothrow_t const&) {
+  OPERATOR_NEW_BODY(_ZnwmRKSt9nothrow_t);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void *operator new[](__sanitizer::uptr size, std::nothrow_t const&);
+void *operator new[](__sanitizer::uptr size, std::nothrow_t const&) {
+  OPERATOR_NEW_BODY(_ZnamRKSt9nothrow_t);
+}
+
+#define OPERATOR_DELETE_BODY(mangled_name) \
+  if (ptr == 0) return;  \
+  if (cur_thread()->in_symbolizer) \
+    return __libc_free(ptr); \
+  invoke_free_hook(ptr);  \
+  SCOPED_INTERCEPTOR_RAW(mangled_name, ptr);  \
+  user_free(thr, pc, ptr);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void operator delete(void *ptr) NOEXCEPT;
+void operator delete(void *ptr) NOEXCEPT {
+  OPERATOR_DELETE_BODY(_ZdlPv);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void operator delete[](void *ptr) NOEXCEPT;
+void operator delete[](void *ptr) NOEXCEPT {
+  OPERATOR_DELETE_BODY(_ZdaPv);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void operator delete(void *ptr, std::nothrow_t const&);
+void operator delete(void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY(_ZdlPvRKSt9nothrow_t);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void operator delete[](void *ptr, std::nothrow_t const&);
+void operator delete[](void *ptr, std::nothrow_t const&) {
+  OPERATOR_DELETE_BODY(_ZdaPvRKSt9nothrow_t);
+}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_platform.h b/compiler-rt/lib/tsan/rtl/tsan_platform.h
new file mode 100644
index 0000000..c2b4871
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_platform.h
@@ -0,0 +1,772 @@
+//===-- tsan_platform.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Platform-specific code.
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAN_PLATFORM_H
+#define TSAN_PLATFORM_H
+
+#if !defined(__LP64__) && !defined(_WIN64)
+# error "Only 64-bit is supported"
+#endif
+
+#include "tsan_defs.h"
+#include "tsan_trace.h"
+
+namespace __tsan {
+
+#if !defined(SANITIZER_GO)
+
+#if defined(__x86_64__)
+/*
+C/C++ on linux/x86_64 and freebsd/x86_64
+0000 0000 1000 - 0100 0000 0000: main binary and/or MAP_32BIT mappings
+0100 0000 0000 - 0200 0000 0000: -
+0200 0000 0000 - 1000 0000 0000: shadow
+1000 0000 0000 - 3000 0000 0000: -
+3000 0000 0000 - 4000 0000 0000: metainfo (memory blocks and sync objects)
+4000 0000 0000 - 6000 0000 0000: -
+6000 0000 0000 - 6200 0000 0000: traces
+6200 0000 0000 - 7d00 0000 0000: -
+7d00 0000 0000 - 7e00 0000 0000: heap
+7e00 0000 0000 - 7e80 0000 0000: -
+7e80 0000 0000 - 8000 0000 0000: modules and main thread stack
+*/
+struct Mapping {
+  static const uptr kMetaShadowBeg = 0x300000000000ull;
+  static const uptr kMetaShadowEnd = 0x400000000000ull;
+  static const uptr kTraceMemBeg   = 0x600000000000ull;
+  static const uptr kTraceMemEnd   = 0x620000000000ull;
+  static const uptr kShadowBeg     = 0x020000000000ull;
+  static const uptr kShadowEnd     = 0x100000000000ull;
+  static const uptr kHeapMemBeg    = 0x7d0000000000ull;
+  static const uptr kHeapMemEnd    = 0x7e0000000000ull;
+  static const uptr kLoAppMemBeg   = 0x000000001000ull;
+  static const uptr kLoAppMemEnd   = 0x010000000000ull;
+  static const uptr kHiAppMemBeg   = 0x7e8000000000ull;
+  static const uptr kHiAppMemEnd   = 0x800000000000ull;
+  static const uptr kAppMemMsk     = 0x7c0000000000ull;
+  static const uptr kAppMemXor     = 0x020000000000ull;
+  static const uptr kVdsoBeg       = 0xf000000000000000ull;
+};
+#elif defined(__mips64)
+/*
+C/C++ on linux/mips64
+0100 0000 00 - 0200 0000 00: main binary
+0200 0000 00 - 1400 0000 00: -
+1400 0000 00 - 2400 0000 00: shadow
+2400 0000 00 - 3000 0000 00: -
+3000 0000 00 - 4000 0000 00: metainfo (memory blocks and sync objects)
+4000 0000 00 - 6000 0000 00: -
+6000 0000 00 - 6200 0000 00: traces
+6200 0000 00 - fe00 0000 00: -
+fe00 0000 00 - ff00 0000 00: heap
+ff00 0000 00 - ff80 0000 00: -
+ff80 0000 00 - ffff ffff ff: modules and main thread stack
+*/
+struct Mapping {
+  static const uptr kMetaShadowBeg = 0x3000000000ull;
+  static const uptr kMetaShadowEnd = 0x4000000000ull;
+  static const uptr kTraceMemBeg   = 0x6000000000ull;
+  static const uptr kTraceMemEnd   = 0x6200000000ull;
+  static const uptr kShadowBeg     = 0x1400000000ull;
+  static const uptr kShadowEnd     = 0x2400000000ull;
+  static const uptr kHeapMemBeg    = 0xfe00000000ull;
+  static const uptr kHeapMemEnd    = 0xff00000000ull;
+  static const uptr kLoAppMemBeg   = 0x0100000000ull;
+  static const uptr kLoAppMemEnd   = 0x0200000000ull;
+  static const uptr kHiAppMemBeg   = 0xff80000000ull;
+  static const uptr kHiAppMemEnd   = 0xffffffffffull;
+  static const uptr kAppMemMsk     = 0xfc00000000ull;
+  static const uptr kAppMemXor     = 0x0400000000ull;
+  static const uptr kVdsoBeg       = 0xfffff00000ull;
+};
+#elif defined(__aarch64__)
+// AArch64 supports multiple VMA which leads to multiple address transformation
+// functions.  To support these multiple VMAS transformations and mappings TSAN
+// runtime for AArch64 uses an external memory read (vmaSize) to select which
+// mapping to use.  Although slower, it make a same instrumented binary run on
+// multiple kernels.
+
+/*
+C/C++ on linux/aarch64 (39-bit VMA)
+0000 0010 00 - 0100 0000 00: main binary
+0100 0000 00 - 0800 0000 00: -
+0800 0000 00 - 2000 0000 00: shadow memory
+2000 0000 00 - 3100 0000 00: -
+3100 0000 00 - 3400 0000 00: metainfo
+3400 0000 00 - 5500 0000 00: -
+5500 0000 00 - 5600 0000 00: main binary (PIE)
+5600 0000 00 - 6000 0000 00: -
+6000 0000 00 - 6200 0000 00: traces
+6200 0000 00 - 7d00 0000 00: -
+7c00 0000 00 - 7d00 0000 00: heap
+7d00 0000 00 - 7fff ffff ff: modules and main thread stack
+*/
+struct Mapping39 {
+  static const uptr kLoAppMemBeg   = 0x0000001000ull;
+  static const uptr kLoAppMemEnd   = 0x0100000000ull;
+  static const uptr kShadowBeg     = 0x0800000000ull;
+  static const uptr kShadowEnd     = 0x2000000000ull;
+  static const uptr kMetaShadowBeg = 0x3100000000ull;
+  static const uptr kMetaShadowEnd = 0x3400000000ull;
+  static const uptr kMidAppMemBeg  = 0x5500000000ull;
+  static const uptr kMidAppMemEnd  = 0x5600000000ull;
+  static const uptr kMidShadowOff  = 0x5000000000ull;
+  static const uptr kTraceMemBeg   = 0x6000000000ull;
+  static const uptr kTraceMemEnd   = 0x6200000000ull;
+  static const uptr kHeapMemBeg    = 0x7c00000000ull;
+  static const uptr kHeapMemEnd    = 0x7d00000000ull;
+  static const uptr kHiAppMemBeg   = 0x7e00000000ull;
+  static const uptr kHiAppMemEnd   = 0x7fffffffffull;
+  static const uptr kAppMemMsk     = 0x7800000000ull;
+  static const uptr kAppMemXor     = 0x0200000000ull;
+  static const uptr kVdsoBeg       = 0x7f00000000ull;
+};
+
+/*
+C/C++ on linux/aarch64 (42-bit VMA)
+00000 0010 00 - 01000 0000 00: main binary
+01000 0000 00 - 10000 0000 00: -
+10000 0000 00 - 20000 0000 00: shadow memory
+20000 0000 00 - 26000 0000 00: -
+26000 0000 00 - 28000 0000 00: metainfo
+28000 0000 00 - 2aa00 0000 00: -
+2aa00 0000 00 - 2ab00 0000 00: main binary (PIE)
+2ab00 0000 00 - 36200 0000 00: -
+36200 0000 00 - 36240 0000 00: traces
+36240 0000 00 - 3e000 0000 00: -
+3e000 0000 00 - 3f000 0000 00: heap
+3f000 0000 00 - 3ffff ffff ff: modules and main thread stack
+*/
+struct Mapping42 {
+  static const uptr kLoAppMemBeg   = 0x00000001000ull;
+  static const uptr kLoAppMemEnd   = 0x01000000000ull;
+  static const uptr kShadowBeg     = 0x10000000000ull;
+  static const uptr kShadowEnd     = 0x20000000000ull;
+  static const uptr kMetaShadowBeg = 0x26000000000ull;
+  static const uptr kMetaShadowEnd = 0x28000000000ull;
+  static const uptr kMidAppMemBeg  = 0x2aa00000000ull;
+  static const uptr kMidAppMemEnd  = 0x2ab00000000ull;
+  static const uptr kMidShadowOff  = 0x28000000000ull;
+  static const uptr kTraceMemBeg   = 0x36200000000ull;
+  static const uptr kTraceMemEnd   = 0x36400000000ull;
+  static const uptr kHeapMemBeg    = 0x3e000000000ull;
+  static const uptr kHeapMemEnd    = 0x3f000000000ull;
+  static const uptr kHiAppMemBeg   = 0x3f000000000ull;
+  static const uptr kHiAppMemEnd   = 0x3ffffffffffull;
+  static const uptr kAppMemMsk     = 0x3c000000000ull;
+  static const uptr kAppMemXor     = 0x04000000000ull;
+  static const uptr kVdsoBeg       = 0x37f00000000ull;
+};
+
+// Indicates the runtime will define the memory regions at runtime.
+#define TSAN_RUNTIME_VMA 1
+// Indicates that mapping defines a mid range memory segment.
+#define TSAN_MID_APP_RANGE 1
+#elif defined(__powerpc64__)
+// PPC64 supports multiple VMA which leads to multiple address transformation
+// functions.  To support these multiple VMAS transformations and mappings TSAN
+// runtime for PPC64 uses an external memory read (vmaSize) to select which
+// mapping to use.  Although slower, it make a same instrumented binary run on
+// multiple kernels.
+
+/*
+C/C++ on linux/powerpc64 (44-bit VMA)
+0000 0000 0100 - 0001 0000 0000: main binary
+0001 0000 0000 - 0001 0000 0000: -
+0001 0000 0000 - 0b00 0000 0000: shadow
+0b00 0000 0000 - 0b00 0000 0000: -
+0b00 0000 0000 - 0d00 0000 0000: metainfo (memory blocks and sync objects)
+0d00 0000 0000 - 0d00 0000 0000: -
+0d00 0000 0000 - 0f00 0000 0000: traces
+0f00 0000 0000 - 0f00 0000 0000: -
+0f00 0000 0000 - 0f50 0000 0000: heap
+0f50 0000 0000 - 0f60 0000 0000: -
+0f60 0000 0000 - 1000 0000 0000: modules and main thread stack
+*/
+struct Mapping44 {
+  static const uptr kMetaShadowBeg = 0x0b0000000000ull;
+  static const uptr kMetaShadowEnd = 0x0d0000000000ull;
+  static const uptr kTraceMemBeg   = 0x0d0000000000ull;
+  static const uptr kTraceMemEnd   = 0x0f0000000000ull;
+  static const uptr kShadowBeg     = 0x000100000000ull;
+  static const uptr kShadowEnd     = 0x0b0000000000ull;
+  static const uptr kLoAppMemBeg   = 0x000000000100ull;
+  static const uptr kLoAppMemEnd   = 0x000100000000ull;
+  static const uptr kHeapMemBeg    = 0x0f0000000000ull;
+  static const uptr kHeapMemEnd    = 0x0f5000000000ull;
+  static const uptr kHiAppMemBeg   = 0x0f6000000000ull;
+  static const uptr kHiAppMemEnd   = 0x100000000000ull; // 44 bits
+  static const uptr kAppMemMsk     = 0x0f0000000000ull;
+  static const uptr kAppMemXor     = 0x002100000000ull;
+  static const uptr kVdsoBeg       = 0x3c0000000000000ull;
+};
+
+/*
+C/C++ on linux/powerpc64 (46-bit VMA)
+0000 0000 1000 - 0100 0000 0000: main binary
+0100 0000 0000 - 0200 0000 0000: -
+0100 0000 0000 - 1000 0000 0000: shadow
+1000 0000 0000 - 1000 0000 0000: -
+1000 0000 0000 - 2000 0000 0000: metainfo (memory blocks and sync objects)
+2000 0000 0000 - 2000 0000 0000: -
+2000 0000 0000 - 2200 0000 0000: traces
+2200 0000 0000 - 3d00 0000 0000: -
+3d00 0000 0000 - 3e00 0000 0000: heap
+3e00 0000 0000 - 3e80 0000 0000: -
+3e80 0000 0000 - 4000 0000 0000: modules and main thread stack
+*/
+struct Mapping46 {
+  static const uptr kMetaShadowBeg = 0x100000000000ull;
+  static const uptr kMetaShadowEnd = 0x200000000000ull;
+  static const uptr kTraceMemBeg   = 0x200000000000ull;
+  static const uptr kTraceMemEnd   = 0x220000000000ull;
+  static const uptr kShadowBeg     = 0x010000000000ull;
+  static const uptr kShadowEnd     = 0x100000000000ull;
+  static const uptr kHeapMemBeg    = 0x3d0000000000ull;
+  static const uptr kHeapMemEnd    = 0x3e0000000000ull;
+  static const uptr kLoAppMemBeg   = 0x000000001000ull;
+  static const uptr kLoAppMemEnd   = 0x010000000000ull;
+  static const uptr kHiAppMemBeg   = 0x3e8000000000ull;
+  static const uptr kHiAppMemEnd   = 0x400000000000ull; // 46 bits
+  static const uptr kAppMemMsk     = 0x3c0000000000ull;
+  static const uptr kAppMemXor     = 0x020000000000ull;
+  static const uptr kVdsoBeg       = 0x7800000000000000ull;
+};
+
+// Indicates the runtime will define the memory regions at runtime.
+#define TSAN_RUNTIME_VMA 1
+#endif
+
+#elif defined(SANITIZER_GO) && !SANITIZER_WINDOWS
+
+/* Go on linux, darwin and freebsd
+0000 0000 1000 - 0000 1000 0000: executable
+0000 1000 0000 - 00c0 0000 0000: -
+00c0 0000 0000 - 00e0 0000 0000: heap
+00e0 0000 0000 - 2000 0000 0000: -
+2000 0000 0000 - 2380 0000 0000: shadow
+2380 0000 0000 - 3000 0000 0000: -
+3000 0000 0000 - 4000 0000 0000: metainfo (memory blocks and sync objects)
+4000 0000 0000 - 6000 0000 0000: -
+6000 0000 0000 - 6200 0000 0000: traces
+6200 0000 0000 - 8000 0000 0000: -
+*/
+
+struct Mapping {
+  static const uptr kMetaShadowBeg = 0x300000000000ull;
+  static const uptr kMetaShadowEnd = 0x400000000000ull;
+  static const uptr kTraceMemBeg   = 0x600000000000ull;
+  static const uptr kTraceMemEnd   = 0x620000000000ull;
+  static const uptr kShadowBeg     = 0x200000000000ull;
+  static const uptr kShadowEnd     = 0x238000000000ull;
+  static const uptr kAppMemBeg     = 0x000000001000ull;
+  static const uptr kAppMemEnd     = 0x00e000000000ull;
+};
+
+#elif defined(SANITIZER_GO) && SANITIZER_WINDOWS
+
+/* Go on windows
+0000 0000 1000 - 0000 1000 0000: executable
+0000 1000 0000 - 00f8 0000 0000: -
+00c0 0000 0000 - 00e0 0000 0000: heap
+00e0 0000 0000 - 0100 0000 0000: -
+0100 0000 0000 - 0500 0000 0000: shadow
+0500 0000 0000 - 0560 0000 0000: -
+0560 0000 0000 - 0760 0000 0000: traces
+0760 0000 0000 - 07d0 0000 0000: metainfo (memory blocks and sync objects)
+07d0 0000 0000 - 8000 0000 0000: -
+*/
+
+struct Mapping {
+  static const uptr kMetaShadowBeg = 0x076000000000ull;
+  static const uptr kMetaShadowEnd = 0x07d000000000ull;
+  static const uptr kTraceMemBeg   = 0x056000000000ull;
+  static const uptr kTraceMemEnd   = 0x076000000000ull;
+  static const uptr kShadowBeg     = 0x010000000000ull;
+  static const uptr kShadowEnd     = 0x050000000000ull;
+  static const uptr kAppMemBeg     = 0x000000001000ull;
+  static const uptr kAppMemEnd     = 0x00e000000000ull;
+}
+
+#else
+# error "Unknown platform"
+#endif
+
+
+#ifdef TSAN_RUNTIME_VMA
+extern uptr vmaSize;
+#endif
+
+
+enum MappingType {
+  MAPPING_LO_APP_BEG,
+  MAPPING_LO_APP_END,
+  MAPPING_HI_APP_BEG,
+  MAPPING_HI_APP_END,
+#ifdef TSAN_MID_APP_RANGE
+  MAPPING_MID_APP_BEG,
+  MAPPING_MID_APP_END,
+#endif
+  MAPPING_HEAP_BEG,
+  MAPPING_HEAP_END,
+  MAPPING_APP_BEG,
+  MAPPING_APP_END,
+  MAPPING_SHADOW_BEG,
+  MAPPING_SHADOW_END,
+  MAPPING_META_SHADOW_BEG,
+  MAPPING_META_SHADOW_END,
+  MAPPING_TRACE_BEG,
+  MAPPING_TRACE_END,
+  MAPPING_VDSO_BEG,
+};
+
+template<typename Mapping, int Type>
+uptr MappingImpl(void) {
+  switch (Type) {
+#ifndef SANITIZER_GO
+    case MAPPING_LO_APP_BEG: return Mapping::kLoAppMemBeg;
+    case MAPPING_LO_APP_END: return Mapping::kLoAppMemEnd;
+# ifdef TSAN_MID_APP_RANGE
+    case MAPPING_MID_APP_BEG: return Mapping::kMidAppMemBeg;
+    case MAPPING_MID_APP_END: return Mapping::kMidAppMemEnd;
+# endif
+    case MAPPING_HI_APP_BEG: return Mapping::kHiAppMemBeg;
+    case MAPPING_HI_APP_END: return Mapping::kHiAppMemEnd;
+    case MAPPING_HEAP_BEG: return Mapping::kHeapMemBeg;
+    case MAPPING_HEAP_END: return Mapping::kHeapMemEnd;
+    case MAPPING_VDSO_BEG: return Mapping::kVdsoBeg;
+#else
+    case MAPPING_APP_BEG: return Mapping::kAppMemBeg;
+    case MAPPING_APP_END: return Mapping::kAppMemEnd;
+#endif
+    case MAPPING_SHADOW_BEG: return Mapping::kShadowBeg;
+    case MAPPING_SHADOW_END: return Mapping::kShadowEnd;
+    case MAPPING_META_SHADOW_BEG: return Mapping::kMetaShadowBeg;
+    case MAPPING_META_SHADOW_END: return Mapping::kMetaShadowEnd;
+    case MAPPING_TRACE_BEG: return Mapping::kTraceMemBeg;
+    case MAPPING_TRACE_END: return Mapping::kTraceMemEnd;
+  }
+}
+
+template<int Type>
+uptr MappingArchImpl(void) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return MappingImpl<Mapping39, Type>();
+  else
+    return MappingImpl<Mapping42, Type>();
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return MappingImpl<Mapping44, Type>();
+  else
+    return MappingImpl<Mapping46, Type>();
+  DCHECK(0);
+#else
+  return MappingImpl<Mapping, Type>();
+#endif
+}
+
+#ifndef SANITIZER_GO
+ALWAYS_INLINE
+uptr LoAppMemBeg(void) {
+  return MappingArchImpl<MAPPING_LO_APP_BEG>();
+}
+ALWAYS_INLINE
+uptr LoAppMemEnd(void) {
+  return MappingArchImpl<MAPPING_LO_APP_END>();
+}
+
+#ifdef TSAN_MID_APP_RANGE
+ALWAYS_INLINE
+uptr MidAppMemBeg(void) {
+  return MappingArchImpl<MAPPING_MID_APP_BEG>();
+}
+ALWAYS_INLINE
+uptr MidAppMemEnd(void) {
+  return MappingArchImpl<MAPPING_MID_APP_END>();
+}
+#endif
+
+ALWAYS_INLINE
+uptr HeapMemBeg(void) {
+  return MappingArchImpl<MAPPING_HEAP_BEG>();
+}
+ALWAYS_INLINE
+uptr HeapMemEnd(void) {
+  return MappingArchImpl<MAPPING_HEAP_END>();
+}
+
+ALWAYS_INLINE
+uptr HiAppMemBeg(void) {
+  return MappingArchImpl<MAPPING_HI_APP_BEG>();
+}
+ALWAYS_INLINE
+uptr HiAppMemEnd(void) {
+  return MappingArchImpl<MAPPING_HI_APP_END>();
+}
+
+ALWAYS_INLINE
+uptr VdsoBeg(void) {
+  return MappingArchImpl<MAPPING_VDSO_BEG>();
+}
+
+#else
+
+ALWAYS_INLINE
+uptr AppMemBeg(void) {
+  return MappingArchImpl<MAPPING_APP_BEG>();
+}
+ALWAYS_INLINE
+uptr AppMemEnd(void) {
+  return MappingArchImpl<MAPPING_APP_END>();
+}
+
+#endif
+
+static inline
+bool GetUserRegion(int i, uptr *start, uptr *end) {
+  switch (i) {
+  default:
+    return false;
+#ifndef SANITIZER_GO
+  case 0:
+    *start = LoAppMemBeg();
+    *end = LoAppMemEnd();
+    return true;
+  case 1:
+    *start = HiAppMemBeg();
+    *end = HiAppMemEnd();
+    return true;
+  case 2:
+    *start = HeapMemBeg();
+    *end = HeapMemEnd();
+    return true;
+# ifdef TSAN_MID_APP_RANGE
+  case 3:
+    *start = MidAppMemBeg();
+    *end = MidAppMemEnd();
+    return true;
+# endif
+#else
+  case 0:
+    *start = AppMemBeg();
+    *end = AppMemEnd();
+    return true;
+#endif
+  }
+}
+
+ALWAYS_INLINE
+uptr ShadowBeg(void) {
+  return MappingArchImpl<MAPPING_SHADOW_BEG>();
+}
+ALWAYS_INLINE
+uptr ShadowEnd(void) {
+  return MappingArchImpl<MAPPING_SHADOW_END>();
+}
+
+ALWAYS_INLINE
+uptr MetaShadowBeg(void) {
+  return MappingArchImpl<MAPPING_META_SHADOW_BEG>();
+}
+ALWAYS_INLINE
+uptr MetaShadowEnd(void) {
+  return MappingArchImpl<MAPPING_META_SHADOW_END>();
+}
+
+ALWAYS_INLINE
+uptr TraceMemBeg(void) {
+  return MappingArchImpl<MAPPING_TRACE_BEG>();
+}
+ALWAYS_INLINE
+uptr TraceMemEnd(void) {
+  return MappingArchImpl<MAPPING_TRACE_END>();
+}
+
+
+template<typename Mapping>
+bool IsAppMemImpl(uptr mem) {
+#ifndef SANITIZER_GO
+  return (mem >= Mapping::kHeapMemBeg && mem < Mapping::kHeapMemEnd) ||
+# ifdef TSAN_MID_APP_RANGE
+         (mem >= Mapping::kMidAppMemBeg && mem < Mapping::kMidAppMemEnd) ||
+# endif
+         (mem >= Mapping::kLoAppMemBeg && mem < Mapping::kLoAppMemEnd) ||
+         (mem >= Mapping::kHiAppMemBeg && mem < Mapping::kHiAppMemEnd);
+#else
+  return mem >= Mapping::kAppMemBeg && mem < Mapping::kAppMemEnd;
+#endif
+}
+
+ALWAYS_INLINE
+bool IsAppMem(uptr mem) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return IsAppMemImpl<Mapping39>(mem);
+  else
+    return IsAppMemImpl<Mapping42>(mem);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return IsAppMemImpl<Mapping44>(mem);
+  else
+    return IsAppMemImpl<Mapping46>(mem);
+  DCHECK(0);
+#else
+  return IsAppMemImpl<Mapping>(mem);
+#endif
+}
+
+
+template<typename Mapping>
+bool IsShadowMemImpl(uptr mem) {
+  return mem >= Mapping::kShadowBeg && mem <= Mapping::kShadowEnd;
+}
+
+ALWAYS_INLINE
+bool IsShadowMem(uptr mem) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return IsShadowMemImpl<Mapping39>(mem);
+  else
+    return IsShadowMemImpl<Mapping42>(mem);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return IsShadowMemImpl<Mapping44>(mem);
+  else
+    return IsShadowMemImpl<Mapping46>(mem);
+  DCHECK(0);
+#else
+  return IsShadowMemImpl<Mapping>(mem);
+#endif
+}
+
+
+template<typename Mapping>
+bool IsMetaMemImpl(uptr mem) {
+  return mem >= Mapping::kMetaShadowBeg && mem <= Mapping::kMetaShadowEnd;
+}
+
+ALWAYS_INLINE
+bool IsMetaMem(uptr mem) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return IsMetaMemImpl<Mapping39>(mem);
+  else
+    return IsMetaMemImpl<Mapping42>(mem);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return IsMetaMemImpl<Mapping44>(mem);
+  else
+    return IsMetaMemImpl<Mapping46>(mem);
+  DCHECK(0);
+#else
+  return IsMetaMemImpl<Mapping>(mem);
+#endif
+}
+
+
+template<typename Mapping>
+uptr MemToShadowImpl(uptr x) {
+  DCHECK(IsAppMem(x));
+#ifndef SANITIZER_GO
+  return (((x) & ~(Mapping::kAppMemMsk | (kShadowCell - 1)))
+      ^ Mapping::kAppMemXor) * kShadowCnt;
+#else
+  return ((x & ~(kShadowCell - 1)) * kShadowCnt) | Mapping::kShadowBeg;
+#endif
+}
+
+ALWAYS_INLINE
+uptr MemToShadow(uptr x) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return MemToShadowImpl<Mapping39>(x);
+  else
+    return MemToShadowImpl<Mapping42>(x);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return MemToShadowImpl<Mapping44>(x);
+  else
+    return MemToShadowImpl<Mapping46>(x);
+  DCHECK(0);
+#else
+  return MemToShadowImpl<Mapping>(x);
+#endif
+}
+
+
+template<typename Mapping>
+u32 *MemToMetaImpl(uptr x) {
+  DCHECK(IsAppMem(x));
+#ifndef SANITIZER_GO
+  return (u32*)(((((x) & ~(Mapping::kAppMemMsk | (kMetaShadowCell - 1)))
+        ^ Mapping::kAppMemXor) / kMetaShadowCell * kMetaShadowSize)
+          | Mapping::kMetaShadowBeg);
+#else
+  return (u32*)(((x & ~(kMetaShadowCell - 1)) / \
+      kMetaShadowCell * kMetaShadowSize) | Mapping::kMetaShadowBeg);
+#endif
+}
+
+ALWAYS_INLINE
+u32 *MemToMeta(uptr x) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return MemToMetaImpl<Mapping39>(x);
+  else
+    return MemToMetaImpl<Mapping42>(x);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return MemToMetaImpl<Mapping44>(x);
+  else
+    return MemToMetaImpl<Mapping46>(x);
+  DCHECK(0);
+#else
+  return MemToMetaImpl<Mapping>(x);
+#endif
+}
+
+
+template<typename Mapping>
+uptr ShadowToMemImpl(uptr s) {
+  DCHECK(IsShadowMem(s));
+#ifndef SANITIZER_GO
+  if (s >= MemToShadow(Mapping::kLoAppMemBeg)
+      && s <= MemToShadow(Mapping::kLoAppMemEnd - 1))
+    return (s / kShadowCnt) ^ Mapping::kAppMemXor;
+# ifdef TSAN_MID_APP_RANGE
+  if (s >= MemToShadow(Mapping::kMidAppMemBeg)
+      && s <= MemToShadow(Mapping::kMidAppMemEnd - 1))
+    return ((s / kShadowCnt) ^ Mapping::kAppMemXor) + Mapping::kMidShadowOff;
+# endif
+  else
+    return ((s / kShadowCnt) ^ Mapping::kAppMemXor) | Mapping::kAppMemMsk;
+#else
+# ifndef SANITIZER_WINDOWS
+  return (s & ~Mapping::kShadowBeg) / kShadowCnt;
+# else
+  // FIXME(dvyukov): this is most likely wrong as the mapping is not bijection.
+  return (s - Mapping::kShadowBeg) / kShadowCnt;
+# endif // SANITIZER_WINDOWS
+#endif
+}
+
+ALWAYS_INLINE
+uptr ShadowToMem(uptr s) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return ShadowToMemImpl<Mapping39>(s);
+  else
+    return ShadowToMemImpl<Mapping42>(s);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return ShadowToMemImpl<Mapping44>(s);
+  else
+    return ShadowToMemImpl<Mapping46>(s);
+  DCHECK(0);
+#else
+  return ShadowToMemImpl<Mapping>(s);
+#endif
+}
+
+
+
+// The additional page is to catch shadow stack overflow as paging fault.
+// Windows wants 64K alignment for mmaps.
+const uptr kTotalTraceSize = (kTraceSize * sizeof(Event) + sizeof(Trace)
+    + (64 << 10) + (64 << 10) - 1) & ~((64 << 10) - 1);
+
+template<typename Mapping>
+uptr GetThreadTraceImpl(int tid) {
+  uptr p = Mapping::kTraceMemBeg + (uptr)tid * kTotalTraceSize;
+  DCHECK_LT(p, Mapping::kTraceMemEnd);
+  return p;
+}
+
+ALWAYS_INLINE
+uptr GetThreadTrace(int tid) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return GetThreadTraceImpl<Mapping39>(tid);
+  else
+    return GetThreadTraceImpl<Mapping42>(tid);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return GetThreadTraceImpl<Mapping44>(tid);
+  else
+    return GetThreadTraceImpl<Mapping46>(tid);
+  DCHECK(0);
+#else
+  return GetThreadTraceImpl<Mapping>(tid);
+#endif
+}
+
+
+template<typename Mapping>
+uptr GetThreadTraceHeaderImpl(int tid) {
+  uptr p = Mapping::kTraceMemBeg + (uptr)tid * kTotalTraceSize
+      + kTraceSize * sizeof(Event);
+  DCHECK_LT(p, Mapping::kTraceMemEnd);
+  return p;
+}
+
+ALWAYS_INLINE
+uptr GetThreadTraceHeader(int tid) {
+#ifdef __aarch64__
+  if (vmaSize == 39)
+    return GetThreadTraceHeaderImpl<Mapping39>(tid);
+  else
+    return GetThreadTraceHeaderImpl<Mapping42>(tid);
+  DCHECK(0);
+#elif defined(__powerpc64__)
+  if (vmaSize == 44)
+    return GetThreadTraceHeaderImpl<Mapping44>(tid);
+  else
+    return GetThreadTraceHeaderImpl<Mapping46>(tid);
+  DCHECK(0);
+#else
+  return GetThreadTraceHeaderImpl<Mapping>(tid);
+#endif
+}
+
+void InitializePlatform();
+void InitializePlatformEarly();
+void CheckAndProtect();
+void InitializeShadowMemoryPlatform();
+void FlushShadowMemory();
+void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive);
+
+// Says whether the addr relates to a global var.
+// Guesses with high probability, may yield both false positives and negatives.
+bool IsGlobalVar(uptr addr);
+int ExtractResolvFDs(void *state, int *fds, int nfd);
+int ExtractRecvmsgFDs(void *msg, int *fds, int nfd);
+
+int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
+    void *abstime), void *c, void *m, void *abstime,
+    void(*cleanup)(void *arg), void *arg);
+
+void DestroyThreadState();
+
+}  // namespace __tsan
+
+#endif  // TSAN_PLATFORM_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cc b/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cc
new file mode 100644
index 0000000..6602561
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cc
@@ -0,0 +1,366 @@
+//===-- tsan_platform_linux.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Linux- and FreeBSD-specific code.
+//===----------------------------------------------------------------------===//
+
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_posix.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include "sanitizer_common/sanitizer_stoptheworld.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "tsan_flags.h"
+
+#include <fcntl.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sched.h>
+#include <dlfcn.h>
+#if SANITIZER_LINUX
+#define __need_res_state
+#include <resolv.h>
+#endif
+
+#ifdef sa_handler
+# undef sa_handler
+#endif
+
+#ifdef sa_sigaction
+# undef sa_sigaction
+#endif
+
+#if SANITIZER_FREEBSD
+extern "C" void *__libc_stack_end;
+void *__libc_stack_end = 0;
+#endif
+
+namespace __tsan {
+
+static uptr g_data_start;
+static uptr g_data_end;
+
+#ifdef TSAN_RUNTIME_VMA
+// Runtime detected VMA size.
+uptr vmaSize;
+#endif
+
+enum {
+  MemTotal  = 0,
+  MemShadow = 1,
+  MemMeta   = 2,
+  MemFile   = 3,
+  MemMmap   = 4,
+  MemTrace  = 5,
+  MemHeap   = 6,
+  MemOther  = 7,
+  MemCount  = 8,
+};
+
+void FillProfileCallback(uptr p, uptr rss, bool file,
+                         uptr *mem, uptr stats_size) {
+  mem[MemTotal] += rss;
+  if (p >= ShadowBeg() && p < ShadowEnd())
+    mem[MemShadow] += rss;
+  else if (p >= MetaShadowBeg() && p < MetaShadowEnd())
+    mem[MemMeta] += rss;
+#ifndef SANITIZER_GO
+  else if (p >= HeapMemBeg() && p < HeapMemEnd())
+    mem[MemHeap] += rss;
+  else if (p >= LoAppMemBeg() && p < LoAppMemEnd())
+    mem[file ? MemFile : MemMmap] += rss;
+  else if (p >= HiAppMemBeg() && p < HiAppMemEnd())
+    mem[file ? MemFile : MemMmap] += rss;
+#else
+  else if (p >= AppMemBeg() && p < AppMemEnd())
+    mem[file ? MemFile : MemMmap] += rss;
+#endif
+  else if (p >= TraceMemBeg() && p < TraceMemEnd())
+    mem[MemTrace] += rss;
+  else
+    mem[MemOther] += rss;
+}
+
+void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive) {
+  uptr mem[MemCount];
+  internal_memset(mem, 0, sizeof(mem[0]) * MemCount);
+  __sanitizer::GetMemoryProfile(FillProfileCallback, mem, 7);
+  StackDepotStats *stacks = StackDepotGetStats();
+  internal_snprintf(buf, buf_size,
+      "RSS %zd MB: shadow:%zd meta:%zd file:%zd mmap:%zd"
+      " trace:%zd heap:%zd other:%zd stacks=%zd[%zd] nthr=%zd/%zd\n",
+      mem[MemTotal] >> 20, mem[MemShadow] >> 20, mem[MemMeta] >> 20,
+      mem[MemFile] >> 20, mem[MemMmap] >> 20, mem[MemTrace] >> 20,
+      mem[MemHeap] >> 20, mem[MemOther] >> 20,
+      stacks->allocated >> 20, stacks->n_uniq_ids,
+      nlive, nthread);
+}
+
+#if SANITIZER_LINUX
+void FlushShadowMemoryCallback(
+    const SuspendedThreadsList &suspended_threads_list,
+    void *argument) {
+  FlushUnneededShadowMemory(ShadowBeg(), ShadowEnd() - ShadowBeg());
+}
+#endif
+
+void FlushShadowMemory() {
+#if SANITIZER_LINUX
+  StopTheWorld(FlushShadowMemoryCallback, 0);
+#endif
+}
+
+#ifndef SANITIZER_GO
+// Mark shadow for .rodata sections with the special kShadowRodata marker.
+// Accesses to .rodata can't race, so this saves time, memory and trace space.
+static void MapRodata() {
+  // First create temp file.
+  const char *tmpdir = GetEnv("TMPDIR");
+  if (tmpdir == 0)
+    tmpdir = GetEnv("TEST_TMPDIR");
+#ifdef P_tmpdir
+  if (tmpdir == 0)
+    tmpdir = P_tmpdir;
+#endif
+  if (tmpdir == 0)
+    return;
+  char name[256];
+  internal_snprintf(name, sizeof(name), "%s/tsan.rodata.%d",
+                    tmpdir, (int)internal_getpid());
+  uptr openrv = internal_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
+  if (internal_iserror(openrv))
+    return;
+  internal_unlink(name);  // Unlink it now, so that we can reuse the buffer.
+  fd_t fd = openrv;
+  // Fill the file with kShadowRodata.
+  const uptr kMarkerSize = 512 * 1024 / sizeof(u64);
+  InternalScopedBuffer<u64> marker(kMarkerSize);
+  // volatile to prevent insertion of memset
+  for (volatile u64 *p = marker.data(); p < marker.data() + kMarkerSize; p++)
+    *p = kShadowRodata;
+  internal_write(fd, marker.data(), marker.size());
+  // Map the file into memory.
+  uptr page = internal_mmap(0, GetPageSizeCached(), PROT_READ | PROT_WRITE,
+                            MAP_PRIVATE | MAP_ANONYMOUS, fd, 0);
+  if (internal_iserror(page)) {
+    internal_close(fd);
+    return;
+  }
+  // Map the file into shadow of .rodata sections.
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  uptr start, end, offset, prot;
+  // Reusing the buffer 'name'.
+  while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name), &prot)) {
+    if (name[0] != 0 && name[0] != '['
+        && (prot & MemoryMappingLayout::kProtectionRead)
+        && (prot & MemoryMappingLayout::kProtectionExecute)
+        && !(prot & MemoryMappingLayout::kProtectionWrite)
+        && IsAppMem(start)) {
+      // Assume it's .rodata
+      char *shadow_start = (char*)MemToShadow(start);
+      char *shadow_end = (char*)MemToShadow(end);
+      for (char *p = shadow_start; p < shadow_end; p += marker.size()) {
+        internal_mmap(p, Min<uptr>(marker.size(), shadow_end - p),
+                      PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, 0);
+      }
+    }
+  }
+  internal_close(fd);
+}
+
+void InitializeShadowMemoryPlatform() {
+  MapRodata();
+}
+
+static void InitDataSeg() {
+  MemoryMappingLayout proc_maps(true);
+  uptr start, end, offset;
+  char name[128];
+#if SANITIZER_FREEBSD
+  // On FreeBSD BSS is usually the last block allocated within the
+  // low range and heap is the last block allocated within the range
+  // 0x800000000-0x8ffffffff.
+  while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name),
+                        /*protection*/ 0)) {
+    DPrintf("%p-%p %p %s\n", start, end, offset, name);
+    if ((start & 0xffff00000000ULL) == 0 && (end & 0xffff00000000ULL) == 0 &&
+        name[0] == '\0') {
+      g_data_start = start;
+      g_data_end = end;
+    }
+  }
+#else
+  bool prev_is_data = false;
+  while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name),
+                        /*protection*/ 0)) {
+    DPrintf("%p-%p %p %s\n", start, end, offset, name);
+    bool is_data = offset != 0 && name[0] != 0;
+    // BSS may get merged with [heap] in /proc/self/maps. This is not very
+    // reliable.
+    bool is_bss = offset == 0 &&
+      (name[0] == 0 || internal_strcmp(name, "[heap]") == 0) && prev_is_data;
+    if (g_data_start == 0 && is_data)
+      g_data_start = start;
+    if (is_bss)
+      g_data_end = end;
+    prev_is_data = is_data;
+  }
+#endif
+  DPrintf("guessed data_start=%p data_end=%p\n",  g_data_start, g_data_end);
+  CHECK_LT(g_data_start, g_data_end);
+  CHECK_GE((uptr)&g_data_start, g_data_start);
+  CHECK_LT((uptr)&g_data_start, g_data_end);
+}
+
+#endif  // #ifndef SANITIZER_GO
+
+void InitializePlatformEarly() {
+#ifdef TSAN_RUNTIME_VMA
+  vmaSize =
+    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
+#if defined(__aarch64__)
+  if (vmaSize != 39 && vmaSize != 42) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %d - Supported 39 and 42\n", vmaSize);
+    Die();
+  }
+#elif defined(__powerpc64__)
+  if (vmaSize != 44 && vmaSize != 46) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %d - Supported 44 and 46\n", vmaSize);
+    Die();
+  }
+#endif
+#endif
+}
+
+void InitializePlatform() {
+  DisableCoreDumperIfNecessary();
+
+  // Go maps shadow memory lazily and works fine with limited address space.
+  // Unlimited stack is not a problem as well, because the executable
+  // is not compiled with -pie.
+  if (kCppMode) {
+    bool reexec = false;
+    // TSan doesn't play well with unlimited stack size (as stack
+    // overlaps with shadow memory). If we detect unlimited stack size,
+    // we re-exec the program with limited stack size as a best effort.
+    if (StackSizeIsUnlimited()) {
+      const uptr kMaxStackSize = 32 * 1024 * 1024;
+      VReport(1, "Program is run with unlimited stack size, which wouldn't "
+                 "work with ThreadSanitizer.\n"
+                 "Re-execing with stack size limited to %zd bytes.\n",
+              kMaxStackSize);
+      SetStackSizeLimitInBytes(kMaxStackSize);
+      reexec = true;
+    }
+
+    if (!AddressSpaceIsUnlimited()) {
+      Report("WARNING: Program is run with limited virtual address space,"
+             " which wouldn't work with ThreadSanitizer.\n");
+      Report("Re-execing with unlimited virtual address space.\n");
+      SetAddressSpaceUnlimited();
+      reexec = true;
+    }
+    if (reexec)
+      ReExec();
+  }
+
+#ifndef SANITIZER_GO
+  CheckAndProtect();
+  InitTlsSize();
+  InitDataSeg();
+#endif
+}
+
+bool IsGlobalVar(uptr addr) {
+  return g_data_start && addr >= g_data_start && addr < g_data_end;
+}
+
+#ifndef SANITIZER_GO
+// Extract file descriptors passed to glibc internal __res_iclose function.
+// This is required to properly "close" the fds, because we do not see internal
+// closes within glibc. The code is a pure hack.
+int ExtractResolvFDs(void *state, int *fds, int nfd) {
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+  int cnt = 0;
+  __res_state *statp = (__res_state*)state;
+  for (int i = 0; i < MAXNS && cnt < nfd; i++) {
+    if (statp->_u._ext.nsaddrs[i] && statp->_u._ext.nssocks[i] != -1)
+      fds[cnt++] = statp->_u._ext.nssocks[i];
+  }
+  return cnt;
+#else
+  return 0;
+#endif
+}
+
+// Extract file descriptors passed via UNIX domain sockets.
+// This is requried to properly handle "open" of these fds.
+// see 'man recvmsg' and 'man 3 cmsg'.
+int ExtractRecvmsgFDs(void *msgp, int *fds, int nfd) {
+  int res = 0;
+  msghdr *msg = (msghdr*)msgp;
+  struct cmsghdr *cmsg = CMSG_FIRSTHDR(msg);
+  for (; cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
+    if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS)
+      continue;
+    int n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(fds[0]);
+    for (int i = 0; i < n; i++) {
+      fds[res++] = ((int*)CMSG_DATA(cmsg))[i];
+      if (res == nfd)
+        return res;
+    }
+  }
+  return res;
+}
+
+// Note: this function runs with async signals enabled,
+// so it must not touch any tsan state.
+int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
+    void *abstime), void *c, void *m, void *abstime,
+    void(*cleanup)(void *arg), void *arg) {
+  // pthread_cleanup_push/pop are hardcore macros mess.
+  // We can't intercept nor call them w/o including pthread.h.
+  int res;
+  pthread_cleanup_push(cleanup, arg);
+  res = fn(c, m, abstime);
+  pthread_cleanup_pop(0);
+  return res;
+}
+#endif
+
+#ifndef SANITIZER_GO
+void ReplaceSystemMalloc() { }
+#endif
+
+}  // namespace __tsan
+
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD
diff --git a/compiler-rt/lib/tsan/rtl/tsan_platform_mac.cc b/compiler-rt/lib/tsan/rtl/tsan_platform_mac.cc
new file mode 100644
index 0000000..31caf37
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_platform_mac.cc
@@ -0,0 +1,192 @@
+//===-- tsan_platform_mac.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Mac-specific code.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_MAC
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_posix.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "tsan_flags.h"
+
+#include <pthread.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sched.h>
+
+namespace __tsan {
+
+#ifndef SANITIZER_GO
+static void *SignalSafeGetOrAllocate(uptr *dst, uptr size) {
+  atomic_uintptr_t *a = (atomic_uintptr_t *)dst;
+  void *val = (void *)atomic_load_relaxed(a);
+  atomic_signal_fence(memory_order_acquire);  // Turns the previous load into
+                                              // acquire wrt signals.
+  if (UNLIKELY(val == nullptr)) {
+    val = (void *)internal_mmap(nullptr, size, PROT_READ | PROT_WRITE,
+                                MAP_PRIVATE | MAP_ANON, -1, 0);
+    CHECK(val);
+    void *cmp = nullptr;
+    if (!atomic_compare_exchange_strong(a, (uintptr_t *)&cmp, (uintptr_t)val,
+                                        memory_order_acq_rel)) {
+      internal_munmap(val, size);
+      val = cmp;
+    }
+  }
+  return val;
+}
+
+// On OS X, accessing TLVs via __thread or manually by using pthread_key_* is
+// problematic, because there are several places where interceptors are called
+// when TLVs are not accessible (early process startup, thread cleanup, ...).
+// The following provides a "poor man's TLV" implementation, where we use the
+// shadow memory of the pointer returned by pthread_self() to store a pointer to
+// the ThreadState object. The main thread's ThreadState pointer is stored
+// separately in a static variable, because we need to access it even before the
+// shadow memory is set up.
+static uptr main_thread_identity = 0;
+static ThreadState *main_thread_state = nullptr;
+
+ThreadState *cur_thread() {
+  ThreadState **fake_tls;
+  uptr thread_identity = (uptr)pthread_self();
+  if (thread_identity == main_thread_identity || main_thread_identity == 0) {
+    fake_tls = &main_thread_state;
+  } else {
+    fake_tls = (ThreadState **)MemToShadow(thread_identity);
+  }
+  ThreadState *thr = (ThreadState *)SignalSafeGetOrAllocate(
+      (uptr *)fake_tls, sizeof(ThreadState));
+  return thr;
+}
+
+// TODO(kuba.brecka): This is not async-signal-safe. In particular, we call
+// munmap first and then clear `fake_tls`; if we receive a signal in between,
+// handler will try to access the unmapped ThreadState.
+void cur_thread_finalize() {
+  uptr thread_identity = (uptr)pthread_self();
+  CHECK_NE(thread_identity, main_thread_identity);
+  ThreadState **fake_tls = (ThreadState **)MemToShadow(thread_identity);
+  internal_munmap(*fake_tls, sizeof(ThreadState));
+  *fake_tls = nullptr;
+}
+#endif
+
+uptr GetShadowMemoryConsumption() {
+  return 0;
+}
+
+void FlushShadowMemory() {
+}
+
+void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive) {
+}
+
+#ifndef SANITIZER_GO
+void InitializeShadowMemoryPlatform() { }
+
+// On OS X, GCD worker threads are created without a call to pthread_create. We
+// need to properly register these threads with ThreadCreate and ThreadStart.
+// These threads don't have a parent thread, as they are created "spuriously".
+// We're using a libpthread API that notifies us about a newly created thread.
+// The `thread == pthread_self()` check indicates this is actually a worker
+// thread. If it's just a regular thread, this hook is called on the parent
+// thread.
+typedef void (*pthread_introspection_hook_t)(unsigned int event,
+                                             pthread_t thread, void *addr,
+                                             size_t size);
+extern "C" pthread_introspection_hook_t pthread_introspection_hook_install(
+    pthread_introspection_hook_t hook);
+static const uptr PTHREAD_INTROSPECTION_THREAD_CREATE = 1;
+static const uptr PTHREAD_INTROSPECTION_THREAD_TERMINATE = 3;
+static pthread_introspection_hook_t prev_pthread_introspection_hook;
+static void my_pthread_introspection_hook(unsigned int event, pthread_t thread,
+                                          void *addr, size_t size) {
+  if (event == PTHREAD_INTROSPECTION_THREAD_CREATE) {
+    if (thread == pthread_self()) {
+      // The current thread is a newly created GCD worker thread.
+      ThreadState *parent_thread_state = nullptr;  // No parent.
+      int tid = ThreadCreate(parent_thread_state, 0, (uptr)thread, true);
+      CHECK_NE(tid, 0);
+      ThreadState *thr = cur_thread();
+      ThreadStart(thr, tid, GetTid());
+    }
+  } else if (event == PTHREAD_INTROSPECTION_THREAD_TERMINATE) {
+    if (thread == pthread_self()) {
+      ThreadState *thr = cur_thread();
+      if (thr->tctx) {
+        DestroyThreadState();
+      }
+    }
+  }
+
+  if (prev_pthread_introspection_hook != nullptr)
+    prev_pthread_introspection_hook(event, thread, addr, size);
+}
+#endif
+
+void InitializePlatformEarly() {
+}
+
+void InitializePlatform() {
+  DisableCoreDumperIfNecessary();
+#ifndef SANITIZER_GO
+  CheckAndProtect();
+
+  CHECK_EQ(main_thread_identity, 0);
+  main_thread_identity = (uptr)pthread_self();
+
+  prev_pthread_introspection_hook =
+      pthread_introspection_hook_install(&my_pthread_introspection_hook);
+#endif
+}
+
+#ifndef SANITIZER_GO
+// Note: this function runs with async signals enabled,
+// so it must not touch any tsan state.
+int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
+    void *abstime), void *c, void *m, void *abstime,
+    void(*cleanup)(void *arg), void *arg) {
+  // pthread_cleanup_push/pop are hardcore macros mess.
+  // We can't intercept nor call them w/o including pthread.h.
+  int res;
+  pthread_cleanup_push(cleanup, arg);
+  res = fn(c, m, abstime);
+  pthread_cleanup_pop(0);
+  return res;
+}
+#endif
+
+bool IsGlobalVar(uptr addr) {
+  return false;
+}
+
+}  // namespace __tsan
+
+#endif  // SANITIZER_MAC
diff --git a/compiler-rt/lib/tsan/rtl/tsan_platform_posix.cc b/compiler-rt/lib/tsan/rtl/tsan_platform_posix.cc
new file mode 100644
index 0000000..90476cb
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_platform_posix.cc
@@ -0,0 +1,151 @@
+//===-- tsan_platform_posix.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// POSIX-specific code.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_POSIX
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_procmaps.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+#ifndef SANITIZER_GO
+void InitializeShadowMemory() {
+  // Map memory shadow.
+  uptr shadow =
+      (uptr)MmapFixedNoReserve(ShadowBeg(), ShadowEnd() - ShadowBeg(),
+                               "shadow");
+  if (shadow != ShadowBeg()) {
+    Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
+    Printf("FATAL: Make sure to compile with -fPIE and "
+               "to link with -pie (%p, %p).\n", shadow, ShadowBeg());
+    Die();
+  }
+  // This memory range is used for thread stacks and large user mmaps.
+  // Frequently a thread uses only a small part of stack and similarly
+  // a program uses a small part of large mmap. On some programs
+  // we see 20% memory usage reduction without huge pages for this range.
+  // FIXME: don't use constants here.
+#if defined(__x86_64__)
+  const uptr kMadviseRangeBeg  = 0x7f0000000000ull;
+  const uptr kMadviseRangeSize = 0x010000000000ull;
+#elif defined(__mips64)
+  const uptr kMadviseRangeBeg  = 0xff00000000ull;
+  const uptr kMadviseRangeSize = 0x0100000000ull;
+#elif defined(__aarch64__)
+  uptr kMadviseRangeBeg = 0;
+  uptr kMadviseRangeSize = 0;
+  if (vmaSize == 39) {
+    kMadviseRangeBeg  = 0x7d00000000ull;
+    kMadviseRangeSize = 0x0300000000ull;
+  } else if (vmaSize == 42) {
+    kMadviseRangeBeg  = 0x3f000000000ull;
+    kMadviseRangeSize = 0x01000000000ull;
+  } else {
+    DCHECK(0);
+  }
+#elif defined(__powerpc64__)
+  uptr kMadviseRangeBeg = 0;
+  uptr kMadviseRangeSize = 0;
+  if (vmaSize == 44) {
+    kMadviseRangeBeg  = 0x0f60000000ull;
+    kMadviseRangeSize = 0x0010000000ull;
+  } else if (vmaSize == 46) {
+    kMadviseRangeBeg  = 0x3f0000000000ull;
+    kMadviseRangeSize = 0x010000000000ull;
+  } else {
+    DCHECK(0);
+  }
+#endif
+  NoHugePagesInRegion(MemToShadow(kMadviseRangeBeg),
+                      kMadviseRangeSize * kShadowMultiplier);
+  // Meta shadow is compressing and we don't flush it,
+  // so it makes sense to mark it as NOHUGEPAGE to not over-allocate memory.
+  // On one program it reduces memory consumption from 5GB to 2.5GB.
+  NoHugePagesInRegion(MetaShadowBeg(), MetaShadowEnd() - MetaShadowBeg());
+  if (common_flags()->use_madv_dontdump)
+    DontDumpShadowMemory(ShadowBeg(), ShadowEnd() - ShadowBeg());
+  DPrintf("memory shadow: %zx-%zx (%zuGB)\n",
+      ShadowBeg(), ShadowEnd(),
+      (ShadowEnd() - ShadowBeg()) >> 30);
+
+  // Map meta shadow.
+  uptr meta_size = MetaShadowEnd() - MetaShadowBeg();
+  uptr meta =
+      (uptr)MmapFixedNoReserve(MetaShadowBeg(), meta_size, "meta shadow");
+  if (meta != MetaShadowBeg()) {
+    Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
+    Printf("FATAL: Make sure to compile with -fPIE and "
+               "to link with -pie (%p, %p).\n", meta, MetaShadowBeg());
+    Die();
+  }
+  if (common_flags()->use_madv_dontdump)
+    DontDumpShadowMemory(meta, meta_size);
+  DPrintf("meta shadow: %zx-%zx (%zuGB)\n",
+      meta, meta + meta_size, meta_size >> 30);
+
+  InitializeShadowMemoryPlatform();
+}
+
+static void ProtectRange(uptr beg, uptr end) {
+  CHECK_LE(beg, end);
+  if (beg == end)
+    return;
+  if (beg != (uptr)MmapNoAccess(beg, end - beg)) {
+    Printf("FATAL: ThreadSanitizer can not protect [%zx,%zx]\n", beg, end);
+    Printf("FATAL: Make sure you are not using unlimited stack\n");
+    Die();
+  }
+}
+
+void CheckAndProtect() {
+  // Ensure that the binary is indeed compiled with -pie.
+  MemoryMappingLayout proc_maps(true);
+  uptr p, end, prot;
+  while (proc_maps.Next(&p, &end, 0, 0, 0, &prot)) {
+    if (IsAppMem(p))
+      continue;
+    if (p >= HeapMemEnd() &&
+        p < HeapEnd())
+      continue;
+    if (prot == 0)  // Zero page or mprotected.
+      continue;
+    if (p >= VdsoBeg())  // vdso
+      break;
+    Printf("FATAL: ThreadSanitizer: unexpected memory mapping %p-%p\n", p, end);
+    Die();
+  }
+
+  ProtectRange(LoAppMemEnd(), ShadowBeg());
+  ProtectRange(ShadowEnd(), MetaShadowBeg());
+#ifdef TSAN_MID_APP_RANGE
+  ProtectRange(MetaShadowEnd(), MidAppMemBeg());
+  ProtectRange(MidAppMemEnd(), TraceMemBeg());
+#else
+  ProtectRange(MetaShadowEnd(), TraceMemBeg());
+#endif
+  // Memory for traces is mapped lazily in MapThreadTrace.
+  // Protect the whole range for now, so that user does not map something here.
+  ProtectRange(TraceMemBeg(), TraceMemEnd());
+  ProtectRange(TraceMemEnd(), HeapMemBeg());
+  ProtectRange(HeapEnd(), HiAppMemBeg());
+}
+#endif
+
+}  // namespace __tsan
+
+#endif  // SANITIZER_POSIX
diff --git a/compiler-rt/lib/tsan/rtl/tsan_platform_windows.cc b/compiler-rt/lib/tsan/rtl/tsan_platform_windows.cc
new file mode 100644
index 0000000..c6d5058
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_platform_windows.cc
@@ -0,0 +1,42 @@
+//===-- tsan_platform_windows.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Windows-specific code.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_WINDOWS
+
+#include "tsan_platform.h"
+
+#include <stdlib.h>
+
+namespace __tsan {
+
+uptr GetShadowMemoryConsumption() {
+  return 0;
+}
+
+void FlushShadowMemory() {
+}
+
+void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive) {
+}
+
+void InitializePlatformEarly() {
+}
+
+void InitializePlatform() {
+}
+
+}  // namespace __tsan
+
+#endif  // SANITIZER_WINDOWS
diff --git a/compiler-rt/lib/tsan/rtl/tsan_ppc_regs.h b/compiler-rt/lib/tsan/rtl/tsan_ppc_regs.h
new file mode 100644
index 0000000..5b43f3d
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_ppc_regs.h
@@ -0,0 +1,96 @@
+#define r0 0
+#define r1 1
+#define r2 2
+#define r3 3
+#define r4 4
+#define r5 5
+#define r6 6
+#define r7 7
+#define r8 8
+#define r9 9
+#define r10 10
+#define r11 11
+#define r12 12
+#define r13 13
+#define r14 14
+#define r15 15
+#define r16 16
+#define r17 17
+#define r18 18
+#define r19 19
+#define r20 20
+#define r21 21
+#define r22 22
+#define r23 23
+#define r24 24
+#define r25 25
+#define r26 26
+#define r27 27
+#define r28 28
+#define r29 29
+#define r30 30
+#define r31 31
+#define f0 0
+#define f1 1
+#define f2 2
+#define f3 3
+#define f4 4
+#define f5 5
+#define f6 6
+#define f7 7
+#define f8 8
+#define f9 9
+#define f10 10
+#define f11 11
+#define f12 12
+#define f13 13
+#define f14 14
+#define f15 15
+#define f16 16
+#define f17 17
+#define f18 18
+#define f19 19
+#define f20 20
+#define f21 21
+#define f22 22
+#define f23 23
+#define f24 24
+#define f25 25
+#define f26 26
+#define f27 27
+#define f28 28
+#define f29 29
+#define f30 30
+#define f31 31
+#define v0 0
+#define v1 1
+#define v2 2
+#define v3 3
+#define v4 4
+#define v5 5
+#define v6 6
+#define v7 7
+#define v8 8
+#define v9 9
+#define v10 10
+#define v11 11
+#define v12 12
+#define v13 13
+#define v14 14
+#define v15 15
+#define v16 16
+#define v17 17
+#define v18 18
+#define v19 19
+#define v20 20
+#define v21 21
+#define v22 22
+#define v23 23
+#define v24 24
+#define v25 25
+#define v26 26
+#define v27 27
+#define v28 28
+#define v29 29
+#define v30 30
+#define v31 31
diff --git a/compiler-rt/lib/tsan/rtl/tsan_report.cc b/compiler-rt/lib/tsan/rtl/tsan_report.cc
new file mode 100644
index 0000000..c1d2fd0
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_report.cc
@@ -0,0 +1,428 @@
+//===-- tsan_report.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_report.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_report_decorator.h"
+#include "sanitizer_common/sanitizer_stacktrace_printer.h"
+
+namespace __tsan {
+
+ReportStack::ReportStack() : frames(nullptr), suppressable(false) {}
+
+ReportStack *ReportStack::New() {
+  void *mem = internal_alloc(MBlockReportStack, sizeof(ReportStack));
+  return new(mem) ReportStack();
+}
+
+ReportLocation::ReportLocation(ReportLocationType type)
+    : type(type), global(), heap_chunk_start(0), heap_chunk_size(0), tid(0),
+      fd(0), suppressable(false), stack(nullptr) {}
+
+ReportLocation *ReportLocation::New(ReportLocationType type) {
+  void *mem = internal_alloc(MBlockReportStack, sizeof(ReportLocation));
+  return new(mem) ReportLocation(type);
+}
+
+class Decorator: public __sanitizer::SanitizerCommonDecorator {
+ public:
+  Decorator() : SanitizerCommonDecorator() { }
+  const char *Warning()    { return Red(); }
+  const char *EndWarning() { return Default(); }
+  const char *Access()     { return Blue(); }
+  const char *EndAccess()  { return Default(); }
+  const char *ThreadDescription()    { return Cyan(); }
+  const char *EndThreadDescription() { return Default(); }
+  const char *Location()   { return Green(); }
+  const char *EndLocation() { return Default(); }
+  const char *Sleep()   { return Yellow(); }
+  const char *EndSleep() { return Default(); }
+  const char *Mutex()   { return Magenta(); }
+  const char *EndMutex() { return Default(); }
+};
+
+ReportDesc::ReportDesc()
+    : stacks(MBlockReportStack)
+    , mops(MBlockReportMop)
+    , locs(MBlockReportLoc)
+    , mutexes(MBlockReportMutex)
+    , threads(MBlockReportThread)
+    , unique_tids(MBlockReportThread)
+    , sleep()
+    , count() {
+}
+
+ReportMop::ReportMop()
+    : mset(MBlockReportMutex) {
+}
+
+ReportDesc::~ReportDesc() {
+  // FIXME(dvyukov): it must be leaking a lot of memory.
+}
+
+#ifndef SANITIZER_GO
+
+const int kThreadBufSize = 32;
+const char *thread_name(char *buf, int tid) {
+  if (tid == 0)
+    return "main thread";
+  internal_snprintf(buf, kThreadBufSize, "thread T%d", tid);
+  return buf;
+}
+
+static const char *ReportTypeString(ReportType typ) {
+  if (typ == ReportTypeRace)
+    return "data race";
+  if (typ == ReportTypeVptrRace)
+    return "data race on vptr (ctor/dtor vs virtual call)";
+  if (typ == ReportTypeUseAfterFree)
+    return "heap-use-after-free";
+  if (typ == ReportTypeVptrUseAfterFree)
+    return "heap-use-after-free (virtual call vs free)";
+  if (typ == ReportTypeThreadLeak)
+    return "thread leak";
+  if (typ == ReportTypeMutexDestroyLocked)
+    return "destroy of a locked mutex";
+  if (typ == ReportTypeMutexDoubleLock)
+    return "double lock of a mutex";
+  if (typ == ReportTypeMutexBadUnlock)
+    return "unlock of an unlocked mutex (or by a wrong thread)";
+  if (typ == ReportTypeMutexBadReadLock)
+    return "read lock of a write locked mutex";
+  if (typ == ReportTypeMutexBadReadUnlock)
+    return "read unlock of a write locked mutex";
+  if (typ == ReportTypeSignalUnsafe)
+    return "signal-unsafe call inside of a signal";
+  if (typ == ReportTypeErrnoInSignal)
+    return "signal handler spoils errno";
+  if (typ == ReportTypeDeadlock)
+    return "lock-order-inversion (potential deadlock)";
+  return "";
+}
+
+#if SANITIZER_MAC
+static const char *const kInterposedFunctionPrefix = "wrap_";
+#else
+static const char *const kInterposedFunctionPrefix = "__interceptor_";
+#endif
+
+void PrintStack(const ReportStack *ent) {
+  if (ent == 0 || ent->frames == 0) {
+    Printf("    [failed to restore the stack]\n\n");
+    return;
+  }
+  SymbolizedStack *frame = ent->frames;
+  for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
+    InternalScopedString res(2 * GetPageSizeCached());
+    RenderFrame(&res, common_flags()->stack_trace_format, i, frame->info,
+                common_flags()->symbolize_vs_style,
+                common_flags()->strip_path_prefix, kInterposedFunctionPrefix);
+    Printf("%s\n", res.data());
+  }
+  Printf("\n");
+}
+
+static void PrintMutexSet(Vector<ReportMopMutex> const& mset) {
+  for (uptr i = 0; i < mset.Size(); i++) {
+    if (i == 0)
+      Printf(" (mutexes:");
+    const ReportMopMutex m = mset[i];
+    Printf(" %s M%llu", m.write ? "write" : "read", m.id);
+    Printf(i == mset.Size() - 1 ? ")" : ",");
+  }
+}
+
+static const char *MopDesc(bool first, bool write, bool atomic) {
+  return atomic ? (first ? (write ? "Atomic write" : "Atomic read")
+                : (write ? "Previous atomic write" : "Previous atomic read"))
+                : (first ? (write ? "Write" : "Read")
+                : (write ? "Previous write" : "Previous read"));
+}
+
+static void PrintMop(const ReportMop *mop, bool first) {
+  Decorator d;
+  char thrbuf[kThreadBufSize];
+  Printf("%s", d.Access());
+  Printf("  %s of size %d at %p by %s",
+      MopDesc(first, mop->write, mop->atomic),
+      mop->size, (void*)mop->addr,
+      thread_name(thrbuf, mop->tid));
+  PrintMutexSet(mop->mset);
+  Printf(":\n");
+  Printf("%s", d.EndAccess());
+  PrintStack(mop->stack);
+}
+
+static void PrintLocation(const ReportLocation *loc) {
+  Decorator d;
+  char thrbuf[kThreadBufSize];
+  bool print_stack = false;
+  Printf("%s", d.Location());
+  if (loc->type == ReportLocationGlobal) {
+    const DataInfo &global = loc->global;
+    if (global.size != 0)
+      Printf("  Location is global '%s' of size %zu at %p (%s+%p)\n\n",
+             global.name, global.size, global.start,
+             StripModuleName(global.module), global.module_offset);
+    else
+      Printf("  Location is global '%s' at %p (%s+%p)\n\n", global.name,
+             global.start, StripModuleName(global.module),
+             global.module_offset);
+  } else if (loc->type == ReportLocationHeap) {
+    char thrbuf[kThreadBufSize];
+    Printf("  Location is heap block of size %zu at %p allocated by %s:\n",
+           loc->heap_chunk_size, loc->heap_chunk_start,
+           thread_name(thrbuf, loc->tid));
+    print_stack = true;
+  } else if (loc->type == ReportLocationStack) {
+    Printf("  Location is stack of %s.\n\n", thread_name(thrbuf, loc->tid));
+  } else if (loc->type == ReportLocationTLS) {
+    Printf("  Location is TLS of %s.\n\n", thread_name(thrbuf, loc->tid));
+  } else if (loc->type == ReportLocationFD) {
+    Printf("  Location is file descriptor %d created by %s at:\n",
+        loc->fd, thread_name(thrbuf, loc->tid));
+    print_stack = true;
+  }
+  Printf("%s", d.EndLocation());
+  if (print_stack)
+    PrintStack(loc->stack);
+}
+
+static void PrintMutexShort(const ReportMutex *rm, const char *after) {
+  Decorator d;
+  Printf("%sM%zd%s%s", d.Mutex(), rm->id, d.EndMutex(), after);
+}
+
+static void PrintMutexShortWithAddress(const ReportMutex *rm,
+                                       const char *after) {
+  Decorator d;
+  Printf("%sM%zd (%p)%s%s", d.Mutex(), rm->id, rm->addr, d.EndMutex(), after);
+}
+
+static void PrintMutex(const ReportMutex *rm) {
+  Decorator d;
+  if (rm->destroyed) {
+    Printf("%s", d.Mutex());
+    Printf("  Mutex M%llu is already destroyed.\n\n", rm->id);
+    Printf("%s", d.EndMutex());
+  } else {
+    Printf("%s", d.Mutex());
+    Printf("  Mutex M%llu (%p) created at:\n", rm->id, rm->addr);
+    Printf("%s", d.EndMutex());
+    PrintStack(rm->stack);
+  }
+}
+
+static void PrintThread(const ReportThread *rt) {
+  Decorator d;
+  if (rt->id == 0)  // Little sense in describing the main thread.
+    return;
+  Printf("%s", d.ThreadDescription());
+  Printf("  Thread T%d", rt->id);
+  if (rt->name && rt->name[0] != '\0')
+    Printf(" '%s'", rt->name);
+  char thrbuf[kThreadBufSize];
+  Printf(" (tid=%zu, %s) created by %s",
+    rt->pid, rt->running ? "running" : "finished",
+    thread_name(thrbuf, rt->parent_tid));
+  if (rt->stack)
+    Printf(" at:");
+  Printf("\n");
+  Printf("%s", d.EndThreadDescription());
+  PrintStack(rt->stack);
+}
+
+static void PrintSleep(const ReportStack *s) {
+  Decorator d;
+  Printf("%s", d.Sleep());
+  Printf("  As if synchronized via sleep:\n");
+  Printf("%s", d.EndSleep());
+  PrintStack(s);
+}
+
+static ReportStack *ChooseSummaryStack(const ReportDesc *rep) {
+  if (rep->mops.Size())
+    return rep->mops[0]->stack;
+  if (rep->stacks.Size())
+    return rep->stacks[0];
+  if (rep->mutexes.Size())
+    return rep->mutexes[0]->stack;
+  if (rep->threads.Size())
+    return rep->threads[0]->stack;
+  return 0;
+}
+
+static bool FrameIsInternal(const SymbolizedStack *frame) {
+  if (frame == 0)
+    return false;
+  const char *file = frame->info.file;
+  const char *module = frame->info.module;
+  if (file != 0 &&
+      (internal_strstr(file, "tsan_interceptors.cc") ||
+       internal_strstr(file, "sanitizer_common_interceptors.inc") ||
+       internal_strstr(file, "tsan_interface_")))
+    return true;
+  if (module != 0 && (internal_strstr(module, "libclang_rt.tsan_")))
+    return true;
+  return false;
+}
+
+static SymbolizedStack *SkipTsanInternalFrames(SymbolizedStack *frames) {
+  while (FrameIsInternal(frames) && frames->next)
+    frames = frames->next;
+  return frames;
+}
+
+void PrintReport(const ReportDesc *rep) {
+  Decorator d;
+  Printf("==================\n");
+  const char *rep_typ_str = ReportTypeString(rep->typ);
+  Printf("%s", d.Warning());
+  Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str,
+         (int)internal_getpid());
+  Printf("%s", d.EndWarning());
+
+  if (rep->typ == ReportTypeDeadlock) {
+    char thrbuf[kThreadBufSize];
+    Printf("  Cycle in lock order graph: ");
+    for (uptr i = 0; i < rep->mutexes.Size(); i++)
+      PrintMutexShortWithAddress(rep->mutexes[i], " => ");
+    PrintMutexShort(rep->mutexes[0], "\n\n");
+    CHECK_GT(rep->mutexes.Size(), 0U);
+    CHECK_EQ(rep->mutexes.Size() * (flags()->second_deadlock_stack ? 2 : 1),
+             rep->stacks.Size());
+    for (uptr i = 0; i < rep->mutexes.Size(); i++) {
+      Printf("  Mutex ");
+      PrintMutexShort(rep->mutexes[(i + 1) % rep->mutexes.Size()],
+                      " acquired here while holding mutex ");
+      PrintMutexShort(rep->mutexes[i], " in ");
+      Printf("%s", d.ThreadDescription());
+      Printf("%s:\n", thread_name(thrbuf, rep->unique_tids[i]));
+      Printf("%s", d.EndThreadDescription());
+      if (flags()->second_deadlock_stack) {
+        PrintStack(rep->stacks[2*i]);
+        Printf("  Mutex ");
+        PrintMutexShort(rep->mutexes[i],
+                        " previously acquired by the same thread here:\n");
+        PrintStack(rep->stacks[2*i+1]);
+      } else {
+        PrintStack(rep->stacks[i]);
+        if (i == 0)
+          Printf("    Hint: use TSAN_OPTIONS=second_deadlock_stack=1 "
+                 "to get more informative warning message\n\n");
+      }
+    }
+  } else {
+    for (uptr i = 0; i < rep->stacks.Size(); i++) {
+      if (i)
+        Printf("  and:\n");
+      PrintStack(rep->stacks[i]);
+    }
+  }
+
+  for (uptr i = 0; i < rep->mops.Size(); i++)
+    PrintMop(rep->mops[i], i == 0);
+
+  if (rep->sleep)
+    PrintSleep(rep->sleep);
+
+  for (uptr i = 0; i < rep->locs.Size(); i++)
+    PrintLocation(rep->locs[i]);
+
+  if (rep->typ != ReportTypeDeadlock) {
+    for (uptr i = 0; i < rep->mutexes.Size(); i++)
+      PrintMutex(rep->mutexes[i]);
+  }
+
+  for (uptr i = 0; i < rep->threads.Size(); i++)
+    PrintThread(rep->threads[i]);
+
+  if (rep->typ == ReportTypeThreadLeak && rep->count > 1)
+    Printf("  And %d more similar thread leaks.\n\n", rep->count - 1);
+
+  if (ReportStack *stack = ChooseSummaryStack(rep)) {
+    if (SymbolizedStack *frame = SkipTsanInternalFrames(stack->frames))
+      ReportErrorSummary(rep_typ_str, frame->info);
+  }
+
+  Printf("==================\n");
+}
+
+#else  // #ifndef SANITIZER_GO
+
+const int kMainThreadId = 1;
+
+void PrintStack(const ReportStack *ent) {
+  if (ent == 0 || ent->frames == 0) {
+    Printf("  [failed to restore the stack]\n");
+    return;
+  }
+  SymbolizedStack *frame = ent->frames;
+  for (int i = 0; frame; frame = frame->next, i++) {
+    const AddressInfo &info = frame->info;
+    Printf("  %s()\n      %s:%d +0x%zx\n", info.function,
+        StripPathPrefix(info.file, common_flags()->strip_path_prefix),
+        info.line, (void *)info.module_offset);
+  }
+}
+
+static void PrintMop(const ReportMop *mop, bool first) {
+  Printf("\n");
+  Printf("%s by ",
+      (first ? (mop->write ? "Write" : "Read")
+             : (mop->write ? "Previous write" : "Previous read")));
+  if (mop->tid == kMainThreadId)
+    Printf("main goroutine:\n");
+  else
+    Printf("goroutine %d:\n", mop->tid);
+  PrintStack(mop->stack);
+}
+
+static void PrintThread(const ReportThread *rt) {
+  if (rt->id == kMainThreadId)
+    return;
+  Printf("\n");
+  Printf("Goroutine %d (%s) created at:\n",
+    rt->id, rt->running ? "running" : "finished");
+  PrintStack(rt->stack);
+}
+
+void PrintReport(const ReportDesc *rep) {
+  Printf("==================\n");
+  if (rep->typ == ReportTypeRace) {
+    Printf("WARNING: DATA RACE");
+    for (uptr i = 0; i < rep->mops.Size(); i++)
+      PrintMop(rep->mops[i], i == 0);
+    for (uptr i = 0; i < rep->threads.Size(); i++)
+      PrintThread(rep->threads[i]);
+  } else if (rep->typ == ReportTypeDeadlock) {
+    Printf("WARNING: DEADLOCK\n");
+    for (uptr i = 0; i < rep->mutexes.Size(); i++) {
+      Printf("Goroutine %d lock mutex %d while holding mutex %d:\n",
+          999, rep->mutexes[i]->id,
+          rep->mutexes[(i+1) % rep->mutexes.Size()]->id);
+      PrintStack(rep->stacks[2*i]);
+      Printf("\n");
+      Printf("Mutex %d was previously locked here:\n",
+          rep->mutexes[(i+1) % rep->mutexes.Size()]->id);
+      PrintStack(rep->stacks[2*i + 1]);
+      Printf("\n");
+    }
+  }
+  Printf("==================\n");
+}
+
+#endif
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_report.h b/compiler-rt/lib/tsan/rtl/tsan_report.h
new file mode 100644
index 0000000..3e344a0
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_report.h
@@ -0,0 +1,129 @@
+//===-- tsan_report.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_REPORT_H
+#define TSAN_REPORT_H
+
+#include "sanitizer_common/sanitizer_symbolizer.h"
+#include "tsan_defs.h"
+#include "tsan_vector.h"
+
+namespace __tsan {
+
+enum ReportType {
+  ReportTypeRace,
+  ReportTypeVptrRace,
+  ReportTypeUseAfterFree,
+  ReportTypeVptrUseAfterFree,
+  ReportTypeThreadLeak,
+  ReportTypeMutexDestroyLocked,
+  ReportTypeMutexDoubleLock,
+  ReportTypeMutexBadUnlock,
+  ReportTypeMutexBadReadLock,
+  ReportTypeMutexBadReadUnlock,
+  ReportTypeSignalUnsafe,
+  ReportTypeErrnoInSignal,
+  ReportTypeDeadlock
+};
+
+struct ReportStack {
+  SymbolizedStack *frames;
+  bool suppressable;
+  static ReportStack *New();
+
+ private:
+  ReportStack();
+};
+
+struct ReportMopMutex {
+  u64 id;
+  bool write;
+};
+
+struct ReportMop {
+  int tid;
+  uptr addr;
+  int size;
+  bool write;
+  bool atomic;
+  Vector<ReportMopMutex> mset;
+  ReportStack *stack;
+
+  ReportMop();
+};
+
+enum ReportLocationType {
+  ReportLocationGlobal,
+  ReportLocationHeap,
+  ReportLocationStack,
+  ReportLocationTLS,
+  ReportLocationFD
+};
+
+struct ReportLocation {
+  ReportLocationType type;
+  DataInfo global;
+  uptr heap_chunk_start;
+  uptr heap_chunk_size;
+  int tid;
+  int fd;
+  bool suppressable;
+  ReportStack *stack;
+
+  static ReportLocation *New(ReportLocationType type);
+ private:
+  explicit ReportLocation(ReportLocationType type);
+};
+
+struct ReportThread {
+  int id;
+  uptr pid;
+  bool running;
+  char *name;
+  int parent_tid;
+  ReportStack *stack;
+};
+
+struct ReportMutex {
+  u64 id;
+  uptr addr;
+  bool destroyed;
+  ReportStack *stack;
+};
+
+class ReportDesc {
+ public:
+  ReportType typ;
+  Vector<ReportStack*> stacks;
+  Vector<ReportMop*> mops;
+  Vector<ReportLocation*> locs;
+  Vector<ReportMutex*> mutexes;
+  Vector<ReportThread*> threads;
+  Vector<int> unique_tids;
+  ReportStack *sleep;
+  int count;
+
+  ReportDesc();
+  ~ReportDesc();
+
+ private:
+  ReportDesc(const ReportDesc&);
+  void operator = (const ReportDesc&);
+};
+
+// Format and output the report to the console/log. No additional logic.
+void PrintReport(const ReportDesc *rep);
+void PrintStack(const ReportStack *stack);
+
+}  // namespace __tsan
+
+#endif  // TSAN_REPORT_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl.cc b/compiler-rt/lib/tsan/rtl/tsan_rtl.cc
new file mode 100644
index 0000000..4df4db5
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl.cc
@@ -0,0 +1,1020 @@
+//===-- tsan_rtl.cc -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Main file (entry points) for the TSan run-time.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+#include "tsan_defs.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+#include "tsan_suppressions.h"
+#include "tsan_symbolize.h"
+#include "ubsan/ubsan_init.h"
+
+#ifdef __SSE3__
+// <emmintrin.h> transitively includes <stdlib.h>,
+// and it's prohibited to include std headers into tsan runtime.
+// So we do this dirty trick.
+#define _MM_MALLOC_H_INCLUDED
+#define __MM_MALLOC_H
+#include <emmintrin.h>
+typedef __m128i m128;
+#endif
+
+volatile int __tsan_resumed = 0;
+
+extern "C" void __tsan_resume() {
+  __tsan_resumed = 1;
+}
+
+namespace __tsan {
+
+#if !defined(SANITIZER_GO) && !SANITIZER_MAC
+THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64);
+#endif
+static char ctx_placeholder[sizeof(Context)] ALIGNED(64);
+Context *ctx;
+
+// Can be overriden by a front-end.
+#ifdef TSAN_EXTERNAL_HOOKS
+bool OnFinalize(bool failed);
+void OnInitialize();
+#else
+SANITIZER_WEAK_CXX_DEFAULT_IMPL
+bool OnFinalize(bool failed) {
+  return failed;
+}
+SANITIZER_WEAK_CXX_DEFAULT_IMPL
+void OnInitialize() {}
+#endif
+
+static char thread_registry_placeholder[sizeof(ThreadRegistry)];
+
+static ThreadContextBase *CreateThreadContext(u32 tid) {
+  // Map thread trace when context is created.
+  char name[50];
+  internal_snprintf(name, sizeof(name), "trace %u", tid);
+  MapThreadTrace(GetThreadTrace(tid), TraceSize() * sizeof(Event), name);
+  const uptr hdr = GetThreadTraceHeader(tid);
+  internal_snprintf(name, sizeof(name), "trace header %u", tid);
+  MapThreadTrace(hdr, sizeof(Trace), name);
+  new((void*)hdr) Trace();
+  // We are going to use only a small part of the trace with the default
+  // value of history_size. However, the constructor writes to the whole trace.
+  // Unmap the unused part.
+  uptr hdr_end = hdr + sizeof(Trace);
+  hdr_end -= sizeof(TraceHeader) * (kTraceParts - TraceParts());
+  hdr_end = RoundUp(hdr_end, GetPageSizeCached());
+  if (hdr_end < hdr + sizeof(Trace))
+    UnmapOrDie((void*)hdr_end, hdr + sizeof(Trace) - hdr_end);
+  void *mem = internal_alloc(MBlockThreadContex, sizeof(ThreadContext));
+  return new(mem) ThreadContext(tid);
+}
+
+#ifndef SANITIZER_GO
+static const u32 kThreadQuarantineSize = 16;
+#else
+static const u32 kThreadQuarantineSize = 64;
+#endif
+
+Context::Context()
+  : initialized()
+  , report_mtx(MutexTypeReport, StatMtxReport)
+  , nreported()
+  , nmissed_expected()
+  , thread_registry(new(thread_registry_placeholder) ThreadRegistry(
+      CreateThreadContext, kMaxTid, kThreadQuarantineSize, kMaxTidReuse))
+  , racy_mtx(MutexTypeRacy, StatMtxRacy)
+  , racy_stacks(MBlockRacyStacks)
+  , racy_addresses(MBlockRacyAddresses)
+  , fired_suppressions_mtx(MutexTypeFired, StatMtxFired)
+  , fired_suppressions(8) {
+}
+
+// The objects are allocated in TLS, so one may rely on zero-initialization.
+ThreadState::ThreadState(Context *ctx, int tid, int unique_id, u64 epoch,
+                         unsigned reuse_count,
+                         uptr stk_addr, uptr stk_size,
+                         uptr tls_addr, uptr tls_size)
+  : fast_state(tid, epoch)
+  // Do not touch these, rely on zero initialization,
+  // they may be accessed before the ctor.
+  // , ignore_reads_and_writes()
+  // , ignore_interceptors()
+  , clock(tid, reuse_count)
+#ifndef SANITIZER_GO
+  , jmp_bufs(MBlockJmpBuf)
+#endif
+  , tid(tid)
+  , unique_id(unique_id)
+  , stk_addr(stk_addr)
+  , stk_size(stk_size)
+  , tls_addr(tls_addr)
+  , tls_size(tls_size)
+#ifndef SANITIZER_GO
+  , last_sleep_clock(tid)
+#endif
+{
+}
+
+#ifndef SANITIZER_GO
+static void MemoryProfiler(Context *ctx, fd_t fd, int i) {
+  uptr n_threads;
+  uptr n_running_threads;
+  ctx->thread_registry->GetNumberOfThreads(&n_threads, &n_running_threads);
+  InternalScopedBuffer<char> buf(4096);
+  WriteMemoryProfile(buf.data(), buf.size(), n_threads, n_running_threads);
+  WriteToFile(fd, buf.data(), internal_strlen(buf.data()));
+}
+
+static void BackgroundThread(void *arg) {
+  // This is a non-initialized non-user thread, nothing to see here.
+  // We don't use ScopedIgnoreInterceptors, because we want ignores to be
+  // enabled even when the thread function exits (e.g. during pthread thread
+  // shutdown code).
+  cur_thread()->ignore_interceptors++;
+  const u64 kMs2Ns = 1000 * 1000;
+
+  fd_t mprof_fd = kInvalidFd;
+  if (flags()->profile_memory && flags()->profile_memory[0]) {
+    if (internal_strcmp(flags()->profile_memory, "stdout") == 0) {
+      mprof_fd = 1;
+    } else if (internal_strcmp(flags()->profile_memory, "stderr") == 0) {
+      mprof_fd = 2;
+    } else {
+      InternalScopedString filename(kMaxPathLength);
+      filename.append("%s.%d", flags()->profile_memory, (int)internal_getpid());
+      fd_t fd = OpenFile(filename.data(), WrOnly);
+      if (fd == kInvalidFd) {
+        Printf("ThreadSanitizer: failed to open memory profile file '%s'\n",
+            &filename[0]);
+      } else {
+        mprof_fd = fd;
+      }
+    }
+  }
+
+  u64 last_flush = NanoTime();
+  uptr last_rss = 0;
+  for (int i = 0;
+      atomic_load(&ctx->stop_background_thread, memory_order_relaxed) == 0;
+      i++) {
+    SleepForMillis(100);
+    u64 now = NanoTime();
+
+    // Flush memory if requested.
+    if (flags()->flush_memory_ms > 0) {
+      if (last_flush + flags()->flush_memory_ms * kMs2Ns < now) {
+        VPrintf(1, "ThreadSanitizer: periodic memory flush\n");
+        FlushShadowMemory();
+        last_flush = NanoTime();
+      }
+    }
+    // GetRSS can be expensive on huge programs, so don't do it every 100ms.
+    if (flags()->memory_limit_mb > 0) {
+      uptr rss = GetRSS();
+      uptr limit = uptr(flags()->memory_limit_mb) << 20;
+      VPrintf(1, "ThreadSanitizer: memory flush check"
+                 " RSS=%llu LAST=%llu LIMIT=%llu\n",
+              (u64)rss >> 20, (u64)last_rss >> 20, (u64)limit >> 20);
+      if (2 * rss > limit + last_rss) {
+        VPrintf(1, "ThreadSanitizer: flushing memory due to RSS\n");
+        FlushShadowMemory();
+        rss = GetRSS();
+        VPrintf(1, "ThreadSanitizer: memory flushed RSS=%llu\n", (u64)rss>>20);
+      }
+      last_rss = rss;
+    }
+
+    // Write memory profile if requested.
+    if (mprof_fd != kInvalidFd)
+      MemoryProfiler(ctx, mprof_fd, i);
+
+    // Flush symbolizer cache if requested.
+    if (flags()->flush_symbolizer_ms > 0) {
+      u64 last = atomic_load(&ctx->last_symbolize_time_ns,
+                             memory_order_relaxed);
+      if (last != 0 && last + flags()->flush_symbolizer_ms * kMs2Ns < now) {
+        Lock l(&ctx->report_mtx);
+        SpinMutexLock l2(&CommonSanitizerReportMutex);
+        SymbolizeFlush();
+        atomic_store(&ctx->last_symbolize_time_ns, 0, memory_order_relaxed);
+      }
+    }
+  }
+}
+
+static void StartBackgroundThread() {
+  ctx->background_thread = internal_start_thread(&BackgroundThread, 0);
+}
+
+#ifndef __mips__
+static void StopBackgroundThread() {
+  atomic_store(&ctx->stop_background_thread, 1, memory_order_relaxed);
+  internal_join_thread(ctx->background_thread);
+  ctx->background_thread = 0;
+}
+#endif
+#endif
+
+void DontNeedShadowFor(uptr addr, uptr size) {
+  uptr shadow_beg = MemToShadow(addr);
+  uptr shadow_end = MemToShadow(addr + size);
+  FlushUnneededShadowMemory(shadow_beg, shadow_end - shadow_beg);
+}
+
+void MapShadow(uptr addr, uptr size) {
+  // Global data is not 64K aligned, but there are no adjacent mappings,
+  // so we can get away with unaligned mapping.
+  // CHECK_EQ(addr, addr & ~((64 << 10) - 1));  // windows wants 64K alignment
+  MmapFixedNoReserve(MemToShadow(addr), size * kShadowMultiplier, "shadow");
+
+  // Meta shadow is 2:1, so tread carefully.
+  static bool data_mapped = false;
+  static uptr mapped_meta_end = 0;
+  uptr meta_begin = (uptr)MemToMeta(addr);
+  uptr meta_end = (uptr)MemToMeta(addr + size);
+  meta_begin = RoundDownTo(meta_begin, 64 << 10);
+  meta_end = RoundUpTo(meta_end, 64 << 10);
+  if (!data_mapped) {
+    // First call maps data+bss.
+    data_mapped = true;
+    MmapFixedNoReserve(meta_begin, meta_end - meta_begin, "meta shadow");
+  } else {
+    // Mapping continous heap.
+    // Windows wants 64K alignment.
+    meta_begin = RoundDownTo(meta_begin, 64 << 10);
+    meta_end = RoundUpTo(meta_end, 64 << 10);
+    if (meta_end <= mapped_meta_end)
+      return;
+    if (meta_begin < mapped_meta_end)
+      meta_begin = mapped_meta_end;
+    MmapFixedNoReserve(meta_begin, meta_end - meta_begin, "meta shadow");
+    mapped_meta_end = meta_end;
+  }
+  VPrintf(2, "mapped meta shadow for (%p-%p) at (%p-%p)\n",
+      addr, addr+size, meta_begin, meta_end);
+}
+
+void MapThreadTrace(uptr addr, uptr size, const char *name) {
+  DPrintf("#0: Mapping trace at %p-%p(0x%zx)\n", addr, addr + size, size);
+  CHECK_GE(addr, TraceMemBeg());
+  CHECK_LE(addr + size, TraceMemEnd());
+  CHECK_EQ(addr, addr & ~((64 << 10) - 1));  // windows wants 64K alignment
+  uptr addr1 = (uptr)MmapFixedNoReserve(addr, size, name);
+  if (addr1 != addr) {
+    Printf("FATAL: ThreadSanitizer can not mmap thread trace (%p/%p->%p)\n",
+        addr, size, addr1);
+    Die();
+  }
+}
+
+static void CheckShadowMapping() {
+  uptr beg, end;
+  for (int i = 0; GetUserRegion(i, &beg, &end); i++) {
+    VPrintf(3, "checking shadow region %p-%p\n", beg, end);
+    for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) {
+      for (int x = -1; x <= 1; x++) {
+        const uptr p = p0 + x;
+        if (p < beg || p >= end)
+          continue;
+        const uptr s = MemToShadow(p);
+        const uptr m = (uptr)MemToMeta(p);
+        VPrintf(3, "  checking pointer %p: shadow=%p meta=%p\n", p, s, m);
+        CHECK(IsAppMem(p));
+        CHECK(IsShadowMem(s));
+        CHECK_EQ(p & ~(kShadowCell - 1), ShadowToMem(s));
+        CHECK(IsMetaMem(m));
+      }
+    }
+  }
+}
+
+void Initialize(ThreadState *thr) {
+  // Thread safe because done before all threads exist.
+  static bool is_initialized = false;
+  if (is_initialized)
+    return;
+  is_initialized = true;
+  // We are not ready to handle interceptors yet.
+  ScopedIgnoreInterceptors ignore;
+  SanitizerToolName = "ThreadSanitizer";
+  // Install tool-specific callbacks in sanitizer_common.
+  SetCheckFailedCallback(TsanCheckFailed);
+
+  ctx = new(ctx_placeholder) Context;
+  const char *options = GetEnv(kTsanOptionsEnv);
+  CacheBinaryName();
+  InitializeFlags(&ctx->flags, options);
+  InitializePlatformEarly();
+#ifndef SANITIZER_GO
+  // Re-exec ourselves if we need to set additional env or command line args.
+  MaybeReexec();
+
+  InitializeAllocator();
+  ReplaceSystemMalloc();
+#endif
+  InitializeInterceptors();
+  CheckShadowMapping();
+  InitializePlatform();
+  InitializeMutex();
+  InitializeDynamicAnnotations();
+#ifndef SANITIZER_GO
+  InitializeShadowMemory();
+#endif
+  // Setup correct file descriptor for error reports.
+  __sanitizer_set_report_path(common_flags()->log_path);
+  InitializeSuppressions();
+#ifndef SANITIZER_GO
+  InitializeLibIgnore();
+  Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
+  // On MIPS, TSan initialization is run before
+  // __pthread_initialize_minimal_internal() is finished, so we can not spawn
+  // new threads.
+#ifndef __mips__
+  StartBackgroundThread();
+  SetSandboxingCallback(StopBackgroundThread);
+#endif
+#endif
+  if (common_flags()->detect_deadlocks)
+    ctx->dd = DDetector::Create(flags());
+
+  VPrintf(1, "***** Running under ThreadSanitizer v2 (pid %d) *****\n",
+          (int)internal_getpid());
+
+  // Initialize thread 0.
+  int tid = ThreadCreate(thr, 0, 0, true);
+  CHECK_EQ(tid, 0);
+  ThreadStart(thr, tid, internal_getpid());
+#if TSAN_CONTAINS_UBSAN
+  __ubsan::InitAsPlugin();
+#endif
+  ctx->initialized = true;
+
+  if (flags()->stop_on_start) {
+    Printf("ThreadSanitizer is suspended at startup (pid %d)."
+           " Call __tsan_resume().\n",
+           (int)internal_getpid());
+    while (__tsan_resumed == 0) {}
+  }
+
+  OnInitialize();
+}
+
+int Finalize(ThreadState *thr) {
+  bool failed = false;
+
+  if (flags()->atexit_sleep_ms > 0 && ThreadCount(thr) > 1)
+    SleepForMillis(flags()->atexit_sleep_ms);
+
+  // Wait for pending reports.
+  ctx->report_mtx.Lock();
+  CommonSanitizerReportMutex.Lock();
+  CommonSanitizerReportMutex.Unlock();
+  ctx->report_mtx.Unlock();
+
+#ifndef SANITIZER_GO
+  if (Verbosity()) AllocatorPrintStats();
+#endif
+
+  ThreadFinalize(thr);
+
+  if (ctx->nreported) {
+    failed = true;
+#ifndef SANITIZER_GO
+    Printf("ThreadSanitizer: reported %d warnings\n", ctx->nreported);
+#else
+    Printf("Found %d data race(s)\n", ctx->nreported);
+#endif
+  }
+
+  if (ctx->nmissed_expected) {
+    failed = true;
+    Printf("ThreadSanitizer: missed %d expected races\n",
+        ctx->nmissed_expected);
+  }
+
+  if (common_flags()->print_suppressions)
+    PrintMatchedSuppressions();
+#ifndef SANITIZER_GO
+  if (flags()->print_benign)
+    PrintMatchedBenignRaces();
+#endif
+
+  failed = OnFinalize(failed);
+
+#if TSAN_COLLECT_STATS
+  StatAggregate(ctx->stat, thr->stat);
+  StatOutput(ctx->stat);
+#endif
+
+  return failed ? common_flags()->exitcode : 0;
+}
+
+#ifndef SANITIZER_GO
+void ForkBefore(ThreadState *thr, uptr pc) {
+  ctx->thread_registry->Lock();
+  ctx->report_mtx.Lock();
+}
+
+void ForkParentAfter(ThreadState *thr, uptr pc) {
+  ctx->report_mtx.Unlock();
+  ctx->thread_registry->Unlock();
+}
+
+void ForkChildAfter(ThreadState *thr, uptr pc) {
+  ctx->report_mtx.Unlock();
+  ctx->thread_registry->Unlock();
+
+  uptr nthread = 0;
+  ctx->thread_registry->GetNumberOfThreads(0, 0, &nthread /* alive threads */);
+  VPrintf(1, "ThreadSanitizer: forked new process with pid %d,"
+      " parent had %d threads\n", (int)internal_getpid(), (int)nthread);
+  if (nthread == 1) {
+    StartBackgroundThread();
+  } else {
+    // We've just forked a multi-threaded process. We cannot reasonably function
+    // after that (some mutexes may be locked before fork). So just enable
+    // ignores for everything in the hope that we will exec soon.
+    ctx->after_multithreaded_fork = true;
+    thr->ignore_interceptors++;
+    ThreadIgnoreBegin(thr, pc);
+    ThreadIgnoreSyncBegin(thr, pc);
+  }
+}
+#endif
+
+#ifdef SANITIZER_GO
+NOINLINE
+void GrowShadowStack(ThreadState *thr) {
+  const int sz = thr->shadow_stack_end - thr->shadow_stack;
+  const int newsz = 2 * sz;
+  uptr *newstack = (uptr*)internal_alloc(MBlockShadowStack,
+      newsz * sizeof(uptr));
+  internal_memcpy(newstack, thr->shadow_stack, sz * sizeof(uptr));
+  internal_free(thr->shadow_stack);
+  thr->shadow_stack = newstack;
+  thr->shadow_stack_pos = newstack + sz;
+  thr->shadow_stack_end = newstack + newsz;
+}
+#endif
+
+u32 CurrentStackId(ThreadState *thr, uptr pc) {
+  if (!thr->is_inited)  // May happen during bootstrap.
+    return 0;
+  if (pc != 0) {
+#ifndef SANITIZER_GO
+    DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end);
+#else
+    if (thr->shadow_stack_pos == thr->shadow_stack_end)
+      GrowShadowStack(thr);
+#endif
+    thr->shadow_stack_pos[0] = pc;
+    thr->shadow_stack_pos++;
+  }
+  u32 id = StackDepotPut(
+      StackTrace(thr->shadow_stack, thr->shadow_stack_pos - thr->shadow_stack));
+  if (pc != 0)
+    thr->shadow_stack_pos--;
+  return id;
+}
+
+void TraceSwitch(ThreadState *thr) {
+  thr->nomalloc++;
+  Trace *thr_trace = ThreadTrace(thr->tid);
+  Lock l(&thr_trace->mtx);
+  unsigned trace = (thr->fast_state.epoch() / kTracePartSize) % TraceParts();
+  TraceHeader *hdr = &thr_trace->headers[trace];
+  hdr->epoch0 = thr->fast_state.epoch();
+  ObtainCurrentStack(thr, 0, &hdr->stack0);
+  hdr->mset0 = thr->mset;
+  thr->nomalloc--;
+}
+
+Trace *ThreadTrace(int tid) {
+  return (Trace*)GetThreadTraceHeader(tid);
+}
+
+uptr TraceTopPC(ThreadState *thr) {
+  Event *events = (Event*)GetThreadTrace(thr->tid);
+  uptr pc = events[thr->fast_state.GetTracePos()];
+  return pc;
+}
+
+uptr TraceSize() {
+  return (uptr)(1ull << (kTracePartSizeBits + flags()->history_size + 1));
+}
+
+uptr TraceParts() {
+  return TraceSize() / kTracePartSize;
+}
+
+#ifndef SANITIZER_GO
+extern "C" void __tsan_trace_switch() {
+  TraceSwitch(cur_thread());
+}
+
+extern "C" void __tsan_report_race() {
+  ReportRace(cur_thread());
+}
+#endif
+
+ALWAYS_INLINE
+Shadow LoadShadow(u64 *p) {
+  u64 raw = atomic_load((atomic_uint64_t*)p, memory_order_relaxed);
+  return Shadow(raw);
+}
+
+ALWAYS_INLINE
+void StoreShadow(u64 *sp, u64 s) {
+  atomic_store((atomic_uint64_t*)sp, s, memory_order_relaxed);
+}
+
+ALWAYS_INLINE
+void StoreIfNotYetStored(u64 *sp, u64 *s) {
+  StoreShadow(sp, *s);
+  *s = 0;
+}
+
+ALWAYS_INLINE
+void HandleRace(ThreadState *thr, u64 *shadow_mem,
+                              Shadow cur, Shadow old) {
+  thr->racy_state[0] = cur.raw();
+  thr->racy_state[1] = old.raw();
+  thr->racy_shadow_addr = shadow_mem;
+#ifndef SANITIZER_GO
+  HACKY_CALL(__tsan_report_race);
+#else
+  ReportRace(thr);
+#endif
+}
+
+static inline bool HappensBefore(Shadow old, ThreadState *thr) {
+  return thr->clock.get(old.TidWithIgnore()) >= old.epoch();
+}
+
+ALWAYS_INLINE
+void MemoryAccessImpl1(ThreadState *thr, uptr addr,
+    int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic,
+    u64 *shadow_mem, Shadow cur) {
+  StatInc(thr, StatMop);
+  StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead);
+  StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog));
+
+  // This potentially can live in an MMX/SSE scratch register.
+  // The required intrinsics are:
+  // __m128i _mm_move_epi64(__m128i*);
+  // _mm_storel_epi64(u64*, __m128i);
+  u64 store_word = cur.raw();
+
+  // scan all the shadow values and dispatch to 4 categories:
+  // same, replace, candidate and race (see comments below).
+  // we consider only 3 cases regarding access sizes:
+  // equal, intersect and not intersect. initially I considered
+  // larger and smaller as well, it allowed to replace some
+  // 'candidates' with 'same' or 'replace', but I think
+  // it's just not worth it (performance- and complexity-wise).
+
+  Shadow old(0);
+
+  // It release mode we manually unroll the loop,
+  // because empirically gcc generates better code this way.
+  // However, we can't afford unrolling in debug mode, because the function
+  // consumes almost 4K of stack. Gtest gives only 4K of stack to death test
+  // threads, which is not enough for the unrolled loop.
+#if SANITIZER_DEBUG
+  for (int idx = 0; idx < 4; idx++) {
+#include "tsan_update_shadow_word_inl.h"
+  }
+#else
+  int idx = 0;
+#include "tsan_update_shadow_word_inl.h"
+  idx = 1;
+#include "tsan_update_shadow_word_inl.h"
+  idx = 2;
+#include "tsan_update_shadow_word_inl.h"
+  idx = 3;
+#include "tsan_update_shadow_word_inl.h"
+#endif
+
+  // we did not find any races and had already stored
+  // the current access info, so we are done
+  if (LIKELY(store_word == 0))
+    return;
+  // choose a random candidate slot and replace it
+  StoreShadow(shadow_mem + (cur.epoch() % kShadowCnt), store_word);
+  StatInc(thr, StatShadowReplace);
+  return;
+ RACE:
+  HandleRace(thr, shadow_mem, cur, old);
+  return;
+}
+
+void UnalignedMemoryAccess(ThreadState *thr, uptr pc, uptr addr,
+    int size, bool kAccessIsWrite, bool kIsAtomic) {
+  while (size) {
+    int size1 = 1;
+    int kAccessSizeLog = kSizeLog1;
+    if (size >= 8 && (addr & ~7) == ((addr + 7) & ~7)) {
+      size1 = 8;
+      kAccessSizeLog = kSizeLog8;
+    } else if (size >= 4 && (addr & ~7) == ((addr + 3) & ~7)) {
+      size1 = 4;
+      kAccessSizeLog = kSizeLog4;
+    } else if (size >= 2 && (addr & ~7) == ((addr + 1) & ~7)) {
+      size1 = 2;
+      kAccessSizeLog = kSizeLog2;
+    }
+    MemoryAccess(thr, pc, addr, kAccessSizeLog, kAccessIsWrite, kIsAtomic);
+    addr += size1;
+    size -= size1;
+  }
+}
+
+ALWAYS_INLINE
+bool ContainsSameAccessSlow(u64 *s, u64 a, u64 sync_epoch, bool is_write) {
+  Shadow cur(a);
+  for (uptr i = 0; i < kShadowCnt; i++) {
+    Shadow old(LoadShadow(&s[i]));
+    if (Shadow::Addr0AndSizeAreEqual(cur, old) &&
+        old.TidWithIgnore() == cur.TidWithIgnore() &&
+        old.epoch() > sync_epoch &&
+        old.IsAtomic() == cur.IsAtomic() &&
+        old.IsRead() <= cur.IsRead())
+      return true;
+  }
+  return false;
+}
+
+#if defined(__SSE3__)
+#define SHUF(v0, v1, i0, i1, i2, i3) _mm_castps_si128(_mm_shuffle_ps( \
+    _mm_castsi128_ps(v0), _mm_castsi128_ps(v1), \
+    (i0)*1 + (i1)*4 + (i2)*16 + (i3)*64))
+ALWAYS_INLINE
+bool ContainsSameAccessFast(u64 *s, u64 a, u64 sync_epoch, bool is_write) {
+  // This is an optimized version of ContainsSameAccessSlow.
+  // load current access into access[0:63]
+  const m128 access     = _mm_cvtsi64_si128(a);
+  // duplicate high part of access in addr0:
+  // addr0[0:31]        = access[32:63]
+  // addr0[32:63]       = access[32:63]
+  // addr0[64:95]       = access[32:63]
+  // addr0[96:127]      = access[32:63]
+  const m128 addr0      = SHUF(access, access, 1, 1, 1, 1);
+  // load 4 shadow slots
+  const m128 shadow0    = _mm_load_si128((__m128i*)s);
+  const m128 shadow1    = _mm_load_si128((__m128i*)s + 1);
+  // load high parts of 4 shadow slots into addr_vect:
+  // addr_vect[0:31]    = shadow0[32:63]
+  // addr_vect[32:63]   = shadow0[96:127]
+  // addr_vect[64:95]   = shadow1[32:63]
+  // addr_vect[96:127]  = shadow1[96:127]
+  m128 addr_vect        = SHUF(shadow0, shadow1, 1, 3, 1, 3);
+  if (!is_write) {
+    // set IsRead bit in addr_vect
+    const m128 rw_mask1 = _mm_cvtsi64_si128(1<<15);
+    const m128 rw_mask  = SHUF(rw_mask1, rw_mask1, 0, 0, 0, 0);
+    addr_vect           = _mm_or_si128(addr_vect, rw_mask);
+  }
+  // addr0 == addr_vect?
+  const m128 addr_res   = _mm_cmpeq_epi32(addr0, addr_vect);
+  // epoch1[0:63]       = sync_epoch
+  const m128 epoch1     = _mm_cvtsi64_si128(sync_epoch);
+  // epoch[0:31]        = sync_epoch[0:31]
+  // epoch[32:63]       = sync_epoch[0:31]
+  // epoch[64:95]       = sync_epoch[0:31]
+  // epoch[96:127]      = sync_epoch[0:31]
+  const m128 epoch      = SHUF(epoch1, epoch1, 0, 0, 0, 0);
+  // load low parts of shadow cell epochs into epoch_vect:
+  // epoch_vect[0:31]   = shadow0[0:31]
+  // epoch_vect[32:63]  = shadow0[64:95]
+  // epoch_vect[64:95]  = shadow1[0:31]
+  // epoch_vect[96:127] = shadow1[64:95]
+  const m128 epoch_vect = SHUF(shadow0, shadow1, 0, 2, 0, 2);
+  // epoch_vect >= sync_epoch?
+  const m128 epoch_res  = _mm_cmpgt_epi32(epoch_vect, epoch);
+  // addr_res & epoch_res
+  const m128 res        = _mm_and_si128(addr_res, epoch_res);
+  // mask[0] = res[7]
+  // mask[1] = res[15]
+  // ...
+  // mask[15] = res[127]
+  const int mask        = _mm_movemask_epi8(res);
+  return mask != 0;
+}
+#endif
+
+ALWAYS_INLINE
+bool ContainsSameAccess(u64 *s, u64 a, u64 sync_epoch, bool is_write) {
+#if defined(__SSE3__)
+  bool res = ContainsSameAccessFast(s, a, sync_epoch, is_write);
+  // NOTE: this check can fail if the shadow is concurrently mutated
+  // by other threads. But it still can be useful if you modify
+  // ContainsSameAccessFast and want to ensure that it's not completely broken.
+  // DCHECK_EQ(res, ContainsSameAccessSlow(s, a, sync_epoch, is_write));
+  return res;
+#else
+  return ContainsSameAccessSlow(s, a, sync_epoch, is_write);
+#endif
+}
+
+ALWAYS_INLINE USED
+void MemoryAccess(ThreadState *thr, uptr pc, uptr addr,
+    int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic) {
+  u64 *shadow_mem = (u64*)MemToShadow(addr);
+  DPrintf2("#%d: MemoryAccess: @%p %p size=%d"
+      " is_write=%d shadow_mem=%p {%zx, %zx, %zx, %zx}\n",
+      (int)thr->fast_state.tid(), (void*)pc, (void*)addr,
+      (int)(1 << kAccessSizeLog), kAccessIsWrite, shadow_mem,
+      (uptr)shadow_mem[0], (uptr)shadow_mem[1],
+      (uptr)shadow_mem[2], (uptr)shadow_mem[3]);
+#if SANITIZER_DEBUG
+  if (!IsAppMem(addr)) {
+    Printf("Access to non app mem %zx\n", addr);
+    DCHECK(IsAppMem(addr));
+  }
+  if (!IsShadowMem((uptr)shadow_mem)) {
+    Printf("Bad shadow addr %p (%zx)\n", shadow_mem, addr);
+    DCHECK(IsShadowMem((uptr)shadow_mem));
+  }
+#endif
+
+  if (kCppMode && *shadow_mem == kShadowRodata) {
+    // Access to .rodata section, no races here.
+    // Measurements show that it can be 10-20% of all memory accesses.
+    StatInc(thr, StatMop);
+    StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead);
+    StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog));
+    StatInc(thr, StatMopRodata);
+    return;
+  }
+
+  FastState fast_state = thr->fast_state;
+  if (fast_state.GetIgnoreBit()) {
+    StatInc(thr, StatMop);
+    StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead);
+    StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog));
+    StatInc(thr, StatMopIgnored);
+    return;
+  }
+
+  Shadow cur(fast_state);
+  cur.SetAddr0AndSizeLog(addr & 7, kAccessSizeLog);
+  cur.SetWrite(kAccessIsWrite);
+  cur.SetAtomic(kIsAtomic);
+
+  if (LIKELY(ContainsSameAccess(shadow_mem, cur.raw(),
+      thr->fast_synch_epoch, kAccessIsWrite))) {
+    StatInc(thr, StatMop);
+    StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead);
+    StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog));
+    StatInc(thr, StatMopSame);
+    return;
+  }
+
+  if (kCollectHistory) {
+    fast_state.IncrementEpoch();
+    thr->fast_state = fast_state;
+    TraceAddEvent(thr, fast_state, EventTypeMop, pc);
+    cur.IncrementEpoch();
+  }
+
+  MemoryAccessImpl1(thr, addr, kAccessSizeLog, kAccessIsWrite, kIsAtomic,
+      shadow_mem, cur);
+}
+
+// Called by MemoryAccessRange in tsan_rtl_thread.cc
+ALWAYS_INLINE USED
+void MemoryAccessImpl(ThreadState *thr, uptr addr,
+    int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic,
+    u64 *shadow_mem, Shadow cur) {
+  if (LIKELY(ContainsSameAccess(shadow_mem, cur.raw(),
+      thr->fast_synch_epoch, kAccessIsWrite))) {
+    StatInc(thr, StatMop);
+    StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead);
+    StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog));
+    StatInc(thr, StatMopSame);
+    return;
+  }
+
+  MemoryAccessImpl1(thr, addr, kAccessSizeLog, kAccessIsWrite, kIsAtomic,
+      shadow_mem, cur);
+}
+
+static void MemoryRangeSet(ThreadState *thr, uptr pc, uptr addr, uptr size,
+                           u64 val) {
+  (void)thr;
+  (void)pc;
+  if (size == 0)
+    return;
+  // FIXME: fix me.
+  uptr offset = addr % kShadowCell;
+  if (offset) {
+    offset = kShadowCell - offset;
+    if (size <= offset)
+      return;
+    addr += offset;
+    size -= offset;
+  }
+  DCHECK_EQ(addr % 8, 0);
+  // If a user passes some insane arguments (memset(0)),
+  // let it just crash as usual.
+  if (!IsAppMem(addr) || !IsAppMem(addr + size - 1))
+    return;
+  // Don't want to touch lots of shadow memory.
+  // If a program maps 10MB stack, there is no need reset the whole range.
+  size = (size + (kShadowCell - 1)) & ~(kShadowCell - 1);
+  // UnmapOrDie/MmapFixedNoReserve does not work on Windows,
+  // so we do it only for C/C++.
+  if (kGoMode || size < common_flags()->clear_shadow_mmap_threshold) {
+    u64 *p = (u64*)MemToShadow(addr);
+    CHECK(IsShadowMem((uptr)p));
+    CHECK(IsShadowMem((uptr)(p + size * kShadowCnt / kShadowCell - 1)));
+    // FIXME: may overwrite a part outside the region
+    for (uptr i = 0; i < size / kShadowCell * kShadowCnt;) {
+      p[i++] = val;
+      for (uptr j = 1; j < kShadowCnt; j++)
+        p[i++] = 0;
+    }
+  } else {
+    // The region is big, reset only beginning and end.
+    const uptr kPageSize = GetPageSizeCached();
+    u64 *begin = (u64*)MemToShadow(addr);
+    u64 *end = begin + size / kShadowCell * kShadowCnt;
+    u64 *p = begin;
+    // Set at least first kPageSize/2 to page boundary.
+    while ((p < begin + kPageSize / kShadowSize / 2) || ((uptr)p % kPageSize)) {
+      *p++ = val;
+      for (uptr j = 1; j < kShadowCnt; j++)
+        *p++ = 0;
+    }
+    // Reset middle part.
+    u64 *p1 = p;
+    p = RoundDown(end, kPageSize);
+    UnmapOrDie((void*)p1, (uptr)p - (uptr)p1);
+    MmapFixedNoReserve((uptr)p1, (uptr)p - (uptr)p1);
+    // Set the ending.
+    while (p < end) {
+      *p++ = val;
+      for (uptr j = 1; j < kShadowCnt; j++)
+        *p++ = 0;
+    }
+  }
+}
+
+void MemoryResetRange(ThreadState *thr, uptr pc, uptr addr, uptr size) {
+  MemoryRangeSet(thr, pc, addr, size, 0);
+}
+
+void MemoryRangeFreed(ThreadState *thr, uptr pc, uptr addr, uptr size) {
+  // Processing more than 1k (4k of shadow) is expensive,
+  // can cause excessive memory consumption (user does not necessary touch
+  // the whole range) and most likely unnecessary.
+  if (size > 1024)
+    size = 1024;
+  CHECK_EQ(thr->is_freeing, false);
+  thr->is_freeing = true;
+  MemoryAccessRange(thr, pc, addr, size, true);
+  thr->is_freeing = false;
+  if (kCollectHistory) {
+    thr->fast_state.IncrementEpoch();
+    TraceAddEvent(thr, thr->fast_state, EventTypeMop, pc);
+  }
+  Shadow s(thr->fast_state);
+  s.ClearIgnoreBit();
+  s.MarkAsFreed();
+  s.SetWrite(true);
+  s.SetAddr0AndSizeLog(0, 3);
+  MemoryRangeSet(thr, pc, addr, size, s.raw());
+}
+
+void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size) {
+  if (kCollectHistory) {
+    thr->fast_state.IncrementEpoch();
+    TraceAddEvent(thr, thr->fast_state, EventTypeMop, pc);
+  }
+  Shadow s(thr->fast_state);
+  s.ClearIgnoreBit();
+  s.SetWrite(true);
+  s.SetAddr0AndSizeLog(0, 3);
+  MemoryRangeSet(thr, pc, addr, size, s.raw());
+}
+
+ALWAYS_INLINE USED
+void FuncEntry(ThreadState *thr, uptr pc) {
+  StatInc(thr, StatFuncEnter);
+  DPrintf2("#%d: FuncEntry %p\n", (int)thr->fast_state.tid(), (void*)pc);
+  if (kCollectHistory) {
+    thr->fast_state.IncrementEpoch();
+    TraceAddEvent(thr, thr->fast_state, EventTypeFuncEnter, pc);
+  }
+
+  // Shadow stack maintenance can be replaced with
+  // stack unwinding during trace switch (which presumably must be faster).
+  DCHECK_GE(thr->shadow_stack_pos, thr->shadow_stack);
+#ifndef SANITIZER_GO
+  DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end);
+#else
+  if (thr->shadow_stack_pos == thr->shadow_stack_end)
+    GrowShadowStack(thr);
+#endif
+  thr->shadow_stack_pos[0] = pc;
+  thr->shadow_stack_pos++;
+}
+
+ALWAYS_INLINE USED
+void FuncExit(ThreadState *thr) {
+  StatInc(thr, StatFuncExit);
+  DPrintf2("#%d: FuncExit\n", (int)thr->fast_state.tid());
+  if (kCollectHistory) {
+    thr->fast_state.IncrementEpoch();
+    TraceAddEvent(thr, thr->fast_state, EventTypeFuncExit, 0);
+  }
+
+  DCHECK_GT(thr->shadow_stack_pos, thr->shadow_stack);
+#ifndef SANITIZER_GO
+  DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end);
+#endif
+  thr->shadow_stack_pos--;
+}
+
+void ThreadIgnoreBegin(ThreadState *thr, uptr pc) {
+  DPrintf("#%d: ThreadIgnoreBegin\n", thr->tid);
+  thr->ignore_reads_and_writes++;
+  CHECK_GT(thr->ignore_reads_and_writes, 0);
+  thr->fast_state.SetIgnoreBit();
+#ifndef SANITIZER_GO
+  if (!ctx->after_multithreaded_fork)
+    thr->mop_ignore_set.Add(CurrentStackId(thr, pc));
+#endif
+}
+
+void ThreadIgnoreEnd(ThreadState *thr, uptr pc) {
+  DPrintf("#%d: ThreadIgnoreEnd\n", thr->tid);
+  thr->ignore_reads_and_writes--;
+  CHECK_GE(thr->ignore_reads_and_writes, 0);
+  if (thr->ignore_reads_and_writes == 0) {
+    thr->fast_state.ClearIgnoreBit();
+#ifndef SANITIZER_GO
+    thr->mop_ignore_set.Reset();
+#endif
+  }
+}
+
+void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc) {
+  DPrintf("#%d: ThreadIgnoreSyncBegin\n", thr->tid);
+  thr->ignore_sync++;
+  CHECK_GT(thr->ignore_sync, 0);
+#ifndef SANITIZER_GO
+  if (!ctx->after_multithreaded_fork)
+    thr->sync_ignore_set.Add(CurrentStackId(thr, pc));
+#endif
+}
+
+void ThreadIgnoreSyncEnd(ThreadState *thr, uptr pc) {
+  DPrintf("#%d: ThreadIgnoreSyncEnd\n", thr->tid);
+  thr->ignore_sync--;
+  CHECK_GE(thr->ignore_sync, 0);
+#ifndef SANITIZER_GO
+  if (thr->ignore_sync == 0)
+    thr->sync_ignore_set.Reset();
+#endif
+}
+
+bool MD5Hash::operator==(const MD5Hash &other) const {
+  return hash[0] == other.hash[0] && hash[1] == other.hash[1];
+}
+
+#if SANITIZER_DEBUG
+void build_consistency_debug() {}
+#else
+void build_consistency_release() {}
+#endif
+
+#if TSAN_COLLECT_STATS
+void build_consistency_stats() {}
+#else
+void build_consistency_nostats() {}
+#endif
+
+}  // namespace __tsan
+
+#ifndef SANITIZER_GO
+// Must be included in this file to make sure everything is inlined.
+#include "tsan_interface_inl.h"
+#endif
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl.h b/compiler-rt/lib/tsan/rtl/tsan_rtl.h
new file mode 100644
index 0000000..04104b1
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl.h
@@ -0,0 +1,771 @@
+//===-- tsan_rtl.h ----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Main internal TSan header file.
+//
+// Ground rules:
+//   - C++ run-time should not be used (static CTORs, RTTI, exceptions, static
+//     function-scope locals)
+//   - All functions/classes/etc reside in namespace __tsan, except for those
+//     declared in tsan_interface.h.
+//   - Platform-specific files should be used instead of ifdefs (*).
+//   - No system headers included in header files (*).
+//   - Platform specific headres included only into platform-specific files (*).
+//
+//  (*) Except when inlining is critical for performance.
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAN_RTL_H
+#define TSAN_RTL_H
+
+#include "sanitizer_common/sanitizer_allocator.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_asm.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
+#include "sanitizer_common/sanitizer_libignore.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "sanitizer_common/sanitizer_thread_registry.h"
+#include "tsan_clock.h"
+#include "tsan_defs.h"
+#include "tsan_flags.h"
+#include "tsan_sync.h"
+#include "tsan_trace.h"
+#include "tsan_vector.h"
+#include "tsan_report.h"
+#include "tsan_platform.h"
+#include "tsan_mutexset.h"
+#include "tsan_ignoreset.h"
+#include "tsan_stack_trace.h"
+
+#if SANITIZER_WORDSIZE != 64
+# error "ThreadSanitizer is supported only on 64-bit platforms"
+#endif
+
+namespace __tsan {
+
+#ifndef SANITIZER_GO
+struct MapUnmapCallback;
+#if defined(__mips64) || defined(__aarch64__) || defined(__powerpc__)
+static const uptr kAllocatorSpace = 0;
+static const uptr kAllocatorSize = SANITIZER_MMAP_RANGE_SIZE;
+static const uptr kAllocatorRegionSizeLog = 20;
+static const uptr kAllocatorNumRegions =
+    kAllocatorSize >> kAllocatorRegionSizeLog;
+typedef TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
+    MapUnmapCallback> ByteMap;
+typedef SizeClassAllocator32<kAllocatorSpace, kAllocatorSize, 0,
+    CompactSizeClassMap, kAllocatorRegionSizeLog, ByteMap,
+    MapUnmapCallback> PrimaryAllocator;
+#else
+typedef SizeClassAllocator64<Mapping::kHeapMemBeg,
+    Mapping::kHeapMemEnd - Mapping::kHeapMemBeg, 0,
+    DefaultSizeClassMap, MapUnmapCallback> PrimaryAllocator;
+#endif
+typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef LargeMmapAllocator<MapUnmapCallback> SecondaryAllocator;
+typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
+    SecondaryAllocator> Allocator;
+Allocator *allocator();
+#endif
+
+void TsanCheckFailed(const char *file, int line, const char *cond,
+                     u64 v1, u64 v2);
+
+const u64 kShadowRodata = (u64)-1;  // .rodata shadow marker
+
+// FastState (from most significant bit):
+//   ignore          : 1
+//   tid             : kTidBits
+//   unused          : -
+//   history_size    : 3
+//   epoch           : kClkBits
+class FastState {
+ public:
+  FastState(u64 tid, u64 epoch) {
+    x_ = tid << kTidShift;
+    x_ |= epoch;
+    DCHECK_EQ(tid, this->tid());
+    DCHECK_EQ(epoch, this->epoch());
+    DCHECK_EQ(GetIgnoreBit(), false);
+  }
+
+  explicit FastState(u64 x)
+      : x_(x) {
+  }
+
+  u64 raw() const {
+    return x_;
+  }
+
+  u64 tid() const {
+    u64 res = (x_ & ~kIgnoreBit) >> kTidShift;
+    return res;
+  }
+
+  u64 TidWithIgnore() const {
+    u64 res = x_ >> kTidShift;
+    return res;
+  }
+
+  u64 epoch() const {
+    u64 res = x_ & ((1ull << kClkBits) - 1);
+    return res;
+  }
+
+  void IncrementEpoch() {
+    u64 old_epoch = epoch();
+    x_ += 1;
+    DCHECK_EQ(old_epoch + 1, epoch());
+    (void)old_epoch;
+  }
+
+  void SetIgnoreBit() { x_ |= kIgnoreBit; }
+  void ClearIgnoreBit() { x_ &= ~kIgnoreBit; }
+  bool GetIgnoreBit() const { return (s64)x_ < 0; }
+
+  void SetHistorySize(int hs) {
+    CHECK_GE(hs, 0);
+    CHECK_LE(hs, 7);
+    x_ = (x_ & ~(kHistoryMask << kHistoryShift)) | (u64(hs) << kHistoryShift);
+  }
+
+  ALWAYS_INLINE
+  int GetHistorySize() const {
+    return (int)((x_ >> kHistoryShift) & kHistoryMask);
+  }
+
+  void ClearHistorySize() {
+    SetHistorySize(0);
+  }
+
+  ALWAYS_INLINE
+  u64 GetTracePos() const {
+    const int hs = GetHistorySize();
+    // When hs == 0, the trace consists of 2 parts.
+    const u64 mask = (1ull << (kTracePartSizeBits + hs + 1)) - 1;
+    return epoch() & mask;
+  }
+
+ private:
+  friend class Shadow;
+  static const int kTidShift = 64 - kTidBits - 1;
+  static const u64 kIgnoreBit = 1ull << 63;
+  static const u64 kFreedBit = 1ull << 63;
+  static const u64 kHistoryShift = kClkBits;
+  static const u64 kHistoryMask = 7;
+  u64 x_;
+};
+
+// Shadow (from most significant bit):
+//   freed           : 1
+//   tid             : kTidBits
+//   is_atomic       : 1
+//   is_read         : 1
+//   size_log        : 2
+//   addr0           : 3
+//   epoch           : kClkBits
+class Shadow : public FastState {
+ public:
+  explicit Shadow(u64 x)
+      : FastState(x) {
+  }
+
+  explicit Shadow(const FastState &s)
+      : FastState(s.x_) {
+    ClearHistorySize();
+  }
+
+  void SetAddr0AndSizeLog(u64 addr0, unsigned kAccessSizeLog) {
+    DCHECK_EQ((x_ >> kClkBits) & 31, 0);
+    DCHECK_LE(addr0, 7);
+    DCHECK_LE(kAccessSizeLog, 3);
+    x_ |= ((kAccessSizeLog << 3) | addr0) << kClkBits;
+    DCHECK_EQ(kAccessSizeLog, size_log());
+    DCHECK_EQ(addr0, this->addr0());
+  }
+
+  void SetWrite(unsigned kAccessIsWrite) {
+    DCHECK_EQ(x_ & kReadBit, 0);
+    if (!kAccessIsWrite)
+      x_ |= kReadBit;
+    DCHECK_EQ(kAccessIsWrite, IsWrite());
+  }
+
+  void SetAtomic(bool kIsAtomic) {
+    DCHECK(!IsAtomic());
+    if (kIsAtomic)
+      x_ |= kAtomicBit;
+    DCHECK_EQ(IsAtomic(), kIsAtomic);
+  }
+
+  bool IsAtomic() const {
+    return x_ & kAtomicBit;
+  }
+
+  bool IsZero() const {
+    return x_ == 0;
+  }
+
+  static inline bool TidsAreEqual(const Shadow s1, const Shadow s2) {
+    u64 shifted_xor = (s1.x_ ^ s2.x_) >> kTidShift;
+    DCHECK_EQ(shifted_xor == 0, s1.TidWithIgnore() == s2.TidWithIgnore());
+    return shifted_xor == 0;
+  }
+
+  static ALWAYS_INLINE
+  bool Addr0AndSizeAreEqual(const Shadow s1, const Shadow s2) {
+    u64 masked_xor = ((s1.x_ ^ s2.x_) >> kClkBits) & 31;
+    return masked_xor == 0;
+  }
+
+  static ALWAYS_INLINE bool TwoRangesIntersect(Shadow s1, Shadow s2,
+      unsigned kS2AccessSize) {
+    bool res = false;
+    u64 diff = s1.addr0() - s2.addr0();
+    if ((s64)diff < 0) {  // s1.addr0 < s2.addr0  // NOLINT
+      // if (s1.addr0() + size1) > s2.addr0()) return true;
+      if (s1.size() > -diff)
+        res = true;
+    } else {
+      // if (s2.addr0() + kS2AccessSize > s1.addr0()) return true;
+      if (kS2AccessSize > diff)
+        res = true;
+    }
+    DCHECK_EQ(res, TwoRangesIntersectSlow(s1, s2));
+    DCHECK_EQ(res, TwoRangesIntersectSlow(s2, s1));
+    return res;
+  }
+
+  u64 ALWAYS_INLINE addr0() const { return (x_ >> kClkBits) & 7; }
+  u64 ALWAYS_INLINE size() const { return 1ull << size_log(); }
+  bool ALWAYS_INLINE IsWrite() const { return !IsRead(); }
+  bool ALWAYS_INLINE IsRead() const { return x_ & kReadBit; }
+
+  // The idea behind the freed bit is as follows.
+  // When the memory is freed (or otherwise unaccessible) we write to the shadow
+  // values with tid/epoch related to the free and the freed bit set.
+  // During memory accesses processing the freed bit is considered
+  // as msb of tid. So any access races with shadow with freed bit set
+  // (it is as if write from a thread with which we never synchronized before).
+  // This allows us to detect accesses to freed memory w/o additional
+  // overheads in memory access processing and at the same time restore
+  // tid/epoch of free.
+  void MarkAsFreed() {
+     x_ |= kFreedBit;
+  }
+
+  bool IsFreed() const {
+    return x_ & kFreedBit;
+  }
+
+  bool GetFreedAndReset() {
+    bool res = x_ & kFreedBit;
+    x_ &= ~kFreedBit;
+    return res;
+  }
+
+  bool ALWAYS_INLINE IsBothReadsOrAtomic(bool kIsWrite, bool kIsAtomic) const {
+    bool v = x_ & ((u64(kIsWrite ^ 1) << kReadShift)
+        | (u64(kIsAtomic) << kAtomicShift));
+    DCHECK_EQ(v, (!IsWrite() && !kIsWrite) || (IsAtomic() && kIsAtomic));
+    return v;
+  }
+
+  bool ALWAYS_INLINE IsRWNotWeaker(bool kIsWrite, bool kIsAtomic) const {
+    bool v = ((x_ >> kReadShift) & 3)
+        <= u64((kIsWrite ^ 1) | (kIsAtomic << 1));
+    DCHECK_EQ(v, (IsAtomic() < kIsAtomic) ||
+        (IsAtomic() == kIsAtomic && !IsWrite() <= !kIsWrite));
+    return v;
+  }
+
+  bool ALWAYS_INLINE IsRWWeakerOrEqual(bool kIsWrite, bool kIsAtomic) const {
+    bool v = ((x_ >> kReadShift) & 3)
+        >= u64((kIsWrite ^ 1) | (kIsAtomic << 1));
+    DCHECK_EQ(v, (IsAtomic() > kIsAtomic) ||
+        (IsAtomic() == kIsAtomic && !IsWrite() >= !kIsWrite));
+    return v;
+  }
+
+ private:
+  static const u64 kReadShift   = 5 + kClkBits;
+  static const u64 kReadBit     = 1ull << kReadShift;
+  static const u64 kAtomicShift = 6 + kClkBits;
+  static const u64 kAtomicBit   = 1ull << kAtomicShift;
+
+  u64 size_log() const { return (x_ >> (3 + kClkBits)) & 3; }
+
+  static bool TwoRangesIntersectSlow(const Shadow s1, const Shadow s2) {
+    if (s1.addr0() == s2.addr0()) return true;
+    if (s1.addr0() < s2.addr0() && s1.addr0() + s1.size() > s2.addr0())
+      return true;
+    if (s2.addr0() < s1.addr0() && s2.addr0() + s2.size() > s1.addr0())
+      return true;
+    return false;
+  }
+};
+
+struct ThreadSignalContext;
+
+struct JmpBuf {
+  uptr sp;
+  uptr mangled_sp;
+  int int_signal_send;
+  bool in_blocking_func;
+  uptr in_signal_handler;
+  uptr *shadow_stack_pos;
+};
+
+// This struct is stored in TLS.
+struct ThreadState {
+  FastState fast_state;
+  // Synch epoch represents the threads's epoch before the last synchronization
+  // action. It allows to reduce number of shadow state updates.
+  // For example, fast_synch_epoch=100, last write to addr X was at epoch=150,
+  // if we are processing write to X from the same thread at epoch=200,
+  // we do nothing, because both writes happen in the same 'synch epoch'.
+  // That is, if another memory access does not race with the former write,
+  // it does not race with the latter as well.
+  // QUESTION: can we can squeeze this into ThreadState::Fast?
+  // E.g. ThreadState::Fast is a 44-bit, 32 are taken by synch_epoch and 12 are
+  // taken by epoch between synchs.
+  // This way we can save one load from tls.
+  u64 fast_synch_epoch;
+  // This is a slow path flag. On fast path, fast_state.GetIgnoreBit() is read.
+  // We do not distinguish beteween ignoring reads and writes
+  // for better performance.
+  int ignore_reads_and_writes;
+  int ignore_sync;
+  // Go does not support ignores.
+#ifndef SANITIZER_GO
+  IgnoreSet mop_ignore_set;
+  IgnoreSet sync_ignore_set;
+#endif
+  // C/C++ uses fixed size shadow stack embed into Trace.
+  // Go uses malloc-allocated shadow stack with dynamic size.
+  uptr *shadow_stack;
+  uptr *shadow_stack_end;
+  uptr *shadow_stack_pos;
+  u64 *racy_shadow_addr;
+  u64 racy_state[2];
+  MutexSet mset;
+  ThreadClock clock;
+#ifndef SANITIZER_GO
+  AllocatorCache alloc_cache;
+  InternalAllocatorCache internal_alloc_cache;
+  Vector<JmpBuf> jmp_bufs;
+  int ignore_interceptors;
+#endif
+#if TSAN_COLLECT_STATS
+  u64 stat[StatCnt];
+#endif
+  const int tid;
+  const int unique_id;
+  bool in_symbolizer;
+  bool in_ignored_lib;
+  bool is_inited;
+  bool is_dead;
+  bool is_freeing;
+  bool is_vptr_access;
+  const uptr stk_addr;
+  const uptr stk_size;
+  const uptr tls_addr;
+  const uptr tls_size;
+  ThreadContext *tctx;
+
+#if SANITIZER_DEBUG && !SANITIZER_GO
+  InternalDeadlockDetector internal_deadlock_detector;
+#endif
+  DDPhysicalThread *dd_pt;
+  DDLogicalThread *dd_lt;
+
+  atomic_uintptr_t in_signal_handler;
+  ThreadSignalContext *signal_ctx;
+
+  DenseSlabAllocCache block_cache;
+  DenseSlabAllocCache sync_cache;
+  DenseSlabAllocCache clock_cache;
+
+#ifndef SANITIZER_GO
+  u32 last_sleep_stack_id;
+  ThreadClock last_sleep_clock;
+#endif
+
+  // Set in regions of runtime that must be signal-safe and fork-safe.
+  // If set, malloc must not be called.
+  int nomalloc;
+
+  explicit ThreadState(Context *ctx, int tid, int unique_id, u64 epoch,
+                       unsigned reuse_count,
+                       uptr stk_addr, uptr stk_size,
+                       uptr tls_addr, uptr tls_size);
+};
+
+#ifndef SANITIZER_GO
+#if SANITIZER_MAC
+ThreadState *cur_thread();
+void cur_thread_finalize();
+#else
+__attribute__((tls_model("initial-exec")))
+extern THREADLOCAL char cur_thread_placeholder[];
+INLINE ThreadState *cur_thread() {
+  return reinterpret_cast<ThreadState *>(&cur_thread_placeholder);
+}
+INLINE void cur_thread_finalize() { }
+#endif  // SANITIZER_MAC
+#endif  // SANITIZER_GO
+
+class ThreadContext : public ThreadContextBase {
+ public:
+  explicit ThreadContext(int tid);
+  ~ThreadContext();
+  ThreadState *thr;
+  u32 creation_stack_id;
+  SyncClock sync;
+  // Epoch at which the thread had started.
+  // If we see an event from the thread stamped by an older epoch,
+  // the event is from a dead thread that shared tid with this thread.
+  u64 epoch0;
+  u64 epoch1;
+
+  // Override superclass callbacks.
+  void OnDead() override;
+  void OnJoined(void *arg) override;
+  void OnFinished() override;
+  void OnStarted(void *arg) override;
+  void OnCreated(void *arg) override;
+  void OnReset() override;
+  void OnDetached(void *arg) override;
+};
+
+struct RacyStacks {
+  MD5Hash hash[2];
+  bool operator==(const RacyStacks &other) const {
+    if (hash[0] == other.hash[0] && hash[1] == other.hash[1])
+      return true;
+    if (hash[0] == other.hash[1] && hash[1] == other.hash[0])
+      return true;
+    return false;
+  }
+};
+
+struct RacyAddress {
+  uptr addr_min;
+  uptr addr_max;
+};
+
+struct FiredSuppression {
+  ReportType type;
+  uptr pc_or_addr;
+  Suppression *supp;
+};
+
+struct Context {
+  Context();
+
+  bool initialized;
+  bool after_multithreaded_fork;
+
+  MetaMap metamap;
+
+  Mutex report_mtx;
+  int nreported;
+  int nmissed_expected;
+  atomic_uint64_t last_symbolize_time_ns;
+
+  void *background_thread;
+  atomic_uint32_t stop_background_thread;
+
+  ThreadRegistry *thread_registry;
+
+  Mutex racy_mtx;
+  Vector<RacyStacks> racy_stacks;
+  Vector<RacyAddress> racy_addresses;
+  // Number of fired suppressions may be large enough.
+  Mutex fired_suppressions_mtx;
+  InternalMmapVector<FiredSuppression> fired_suppressions;
+  DDetector *dd;
+
+  ClockAlloc clock_alloc;
+
+  Flags flags;
+
+  u64 stat[StatCnt];
+  u64 int_alloc_cnt[MBlockTypeCount];
+  u64 int_alloc_siz[MBlockTypeCount];
+};
+
+extern Context *ctx;  // The one and the only global runtime context.
+
+struct ScopedIgnoreInterceptors {
+  ScopedIgnoreInterceptors() {
+#ifndef SANITIZER_GO
+    cur_thread()->ignore_interceptors++;
+#endif
+  }
+
+  ~ScopedIgnoreInterceptors() {
+#ifndef SANITIZER_GO
+    cur_thread()->ignore_interceptors--;
+#endif
+  }
+};
+
+class ScopedReport {
+ public:
+  explicit ScopedReport(ReportType typ);
+  ~ScopedReport();
+
+  void AddMemoryAccess(uptr addr, Shadow s, StackTrace stack,
+                       const MutexSet *mset);
+  void AddStack(StackTrace stack, bool suppressable = false);
+  void AddThread(const ThreadContext *tctx, bool suppressable = false);
+  void AddThread(int unique_tid, bool suppressable = false);
+  void AddUniqueTid(int unique_tid);
+  void AddMutex(const SyncVar *s);
+  u64 AddMutex(u64 id);
+  void AddLocation(uptr addr, uptr size);
+  void AddSleep(u32 stack_id);
+  void SetCount(int count);
+
+  const ReportDesc *GetReport() const;
+
+ private:
+  ReportDesc *rep_;
+  // Symbolizer makes lots of intercepted calls. If we try to process them,
+  // at best it will cause deadlocks on internal mutexes.
+  ScopedIgnoreInterceptors ignore_interceptors_;
+
+  void AddDeadMutex(u64 id);
+
+  ScopedReport(const ScopedReport&);
+  void operator = (const ScopedReport&);
+};
+
+void RestoreStack(int tid, const u64 epoch, VarSizeStackTrace *stk,
+                  MutexSet *mset);
+
+template<typename StackTraceTy>
+void ObtainCurrentStack(ThreadState *thr, uptr toppc, StackTraceTy *stack) {
+  uptr size = thr->shadow_stack_pos - thr->shadow_stack;
+  uptr start = 0;
+  if (size + !!toppc > kStackTraceMax) {
+    start = size + !!toppc - kStackTraceMax;
+    size = kStackTraceMax - !!toppc;
+  }
+  stack->Init(&thr->shadow_stack[start], size, toppc);
+}
+
+
+#if TSAN_COLLECT_STATS
+void StatAggregate(u64 *dst, u64 *src);
+void StatOutput(u64 *stat);
+#endif
+
+void ALWAYS_INLINE StatInc(ThreadState *thr, StatType typ, u64 n = 1) {
+#if TSAN_COLLECT_STATS
+  thr->stat[typ] += n;
+#endif
+}
+void ALWAYS_INLINE StatSet(ThreadState *thr, StatType typ, u64 n) {
+#if TSAN_COLLECT_STATS
+  thr->stat[typ] = n;
+#endif
+}
+
+void MapShadow(uptr addr, uptr size);
+void MapThreadTrace(uptr addr, uptr size, const char *name);
+void DontNeedShadowFor(uptr addr, uptr size);
+void InitializeShadowMemory();
+void InitializeInterceptors();
+void InitializeLibIgnore();
+void InitializeDynamicAnnotations();
+
+void ForkBefore(ThreadState *thr, uptr pc);
+void ForkParentAfter(ThreadState *thr, uptr pc);
+void ForkChildAfter(ThreadState *thr, uptr pc);
+
+void ReportRace(ThreadState *thr);
+bool OutputReport(ThreadState *thr, const ScopedReport &srep);
+bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace);
+bool IsExpectedReport(uptr addr, uptr size);
+void PrintMatchedBenignRaces();
+
+#if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 1
+# define DPrintf Printf
+#else
+# define DPrintf(...)
+#endif
+
+#if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 2
+# define DPrintf2 Printf
+#else
+# define DPrintf2(...)
+#endif
+
+u32 CurrentStackId(ThreadState *thr, uptr pc);
+ReportStack *SymbolizeStackId(u32 stack_id);
+void PrintCurrentStack(ThreadState *thr, uptr pc);
+void PrintCurrentStackSlow(uptr pc);  // uses libunwind
+
+void Initialize(ThreadState *thr);
+int Finalize(ThreadState *thr);
+
+void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write);
+void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write);
+
+void MemoryAccess(ThreadState *thr, uptr pc, uptr addr,
+    int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic);
+void MemoryAccessImpl(ThreadState *thr, uptr addr,
+    int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic,
+    u64 *shadow_mem, Shadow cur);
+void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr,
+    uptr size, bool is_write);
+void MemoryAccessRangeStep(ThreadState *thr, uptr pc, uptr addr,
+    uptr size, uptr step, bool is_write);
+void UnalignedMemoryAccess(ThreadState *thr, uptr pc, uptr addr,
+    int size, bool kAccessIsWrite, bool kIsAtomic);
+
+const int kSizeLog1 = 0;
+const int kSizeLog2 = 1;
+const int kSizeLog4 = 2;
+const int kSizeLog8 = 3;
+
+void ALWAYS_INLINE MemoryRead(ThreadState *thr, uptr pc,
+                                     uptr addr, int kAccessSizeLog) {
+  MemoryAccess(thr, pc, addr, kAccessSizeLog, false, false);
+}
+
+void ALWAYS_INLINE MemoryWrite(ThreadState *thr, uptr pc,
+                                      uptr addr, int kAccessSizeLog) {
+  MemoryAccess(thr, pc, addr, kAccessSizeLog, true, false);
+}
+
+void ALWAYS_INLINE MemoryReadAtomic(ThreadState *thr, uptr pc,
+                                           uptr addr, int kAccessSizeLog) {
+  MemoryAccess(thr, pc, addr, kAccessSizeLog, false, true);
+}
+
+void ALWAYS_INLINE MemoryWriteAtomic(ThreadState *thr, uptr pc,
+                                            uptr addr, int kAccessSizeLog) {
+  MemoryAccess(thr, pc, addr, kAccessSizeLog, true, true);
+}
+
+void MemoryResetRange(ThreadState *thr, uptr pc, uptr addr, uptr size);
+void MemoryRangeFreed(ThreadState *thr, uptr pc, uptr addr, uptr size);
+void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size);
+
+void ThreadIgnoreBegin(ThreadState *thr, uptr pc);
+void ThreadIgnoreEnd(ThreadState *thr, uptr pc);
+void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc);
+void ThreadIgnoreSyncEnd(ThreadState *thr, uptr pc);
+
+void FuncEntry(ThreadState *thr, uptr pc);
+void FuncExit(ThreadState *thr);
+
+int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached);
+void ThreadStart(ThreadState *thr, int tid, uptr os_id);
+void ThreadFinish(ThreadState *thr);
+int ThreadTid(ThreadState *thr, uptr pc, uptr uid);
+void ThreadJoin(ThreadState *thr, uptr pc, int tid);
+void ThreadDetach(ThreadState *thr, uptr pc, int tid);
+void ThreadFinalize(ThreadState *thr);
+void ThreadSetName(ThreadState *thr, const char *name);
+int ThreadCount(ThreadState *thr);
+void ProcessPendingSignals(ThreadState *thr);
+
+void MutexCreate(ThreadState *thr, uptr pc, uptr addr,
+                 bool rw, bool recursive, bool linker_init);
+void MutexDestroy(ThreadState *thr, uptr pc, uptr addr);
+void MutexLock(ThreadState *thr, uptr pc, uptr addr, int rec = 1,
+               bool try_lock = false);
+int  MutexUnlock(ThreadState *thr, uptr pc, uptr addr, bool all = false);
+void MutexReadLock(ThreadState *thr, uptr pc, uptr addr, bool try_lock = false);
+void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr);
+void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr);
+void MutexRepair(ThreadState *thr, uptr pc, uptr addr);  // call on EOWNERDEAD
+
+void Acquire(ThreadState *thr, uptr pc, uptr addr);
+// AcquireGlobal synchronizes the current thread with all other threads.
+// In terms of happens-before relation, it draws a HB edge from all threads
+// (where they happen to execute right now) to the current thread. We use it to
+// handle Go finalizers. Namely, finalizer goroutine executes AcquireGlobal
+// right before executing finalizers. This provides a coarse, but simple
+// approximation of the actual required synchronization.
+void AcquireGlobal(ThreadState *thr, uptr pc);
+void Release(ThreadState *thr, uptr pc, uptr addr);
+void ReleaseStore(ThreadState *thr, uptr pc, uptr addr);
+void AfterSleep(ThreadState *thr, uptr pc);
+void AcquireImpl(ThreadState *thr, uptr pc, SyncClock *c);
+void ReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c);
+void ReleaseStoreImpl(ThreadState *thr, uptr pc, SyncClock *c);
+void AcquireReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c);
+
+// The hacky call uses custom calling convention and an assembly thunk.
+// It is considerably faster that a normal call for the caller
+// if it is not executed (it is intended for slow paths from hot functions).
+// The trick is that the call preserves all registers and the compiler
+// does not treat it as a call.
+// If it does not work for you, use normal call.
+#if !SANITIZER_DEBUG && defined(__x86_64__) && !SANITIZER_MAC
+// The caller may not create the stack frame for itself at all,
+// so we create a reserve stack frame for it (1024b must be enough).
+#define HACKY_CALL(f) \
+  __asm__ __volatile__("sub $1024, %%rsp;" \
+                       CFI_INL_ADJUST_CFA_OFFSET(1024) \
+                       ".hidden " #f "_thunk;" \
+                       "call " #f "_thunk;" \
+                       "add $1024, %%rsp;" \
+                       CFI_INL_ADJUST_CFA_OFFSET(-1024) \
+                       ::: "memory", "cc");
+#else
+#define HACKY_CALL(f) f()
+#endif
+
+void TraceSwitch(ThreadState *thr);
+uptr TraceTopPC(ThreadState *thr);
+uptr TraceSize();
+uptr TraceParts();
+Trace *ThreadTrace(int tid);
+
+extern "C" void __tsan_trace_switch();
+void ALWAYS_INLINE TraceAddEvent(ThreadState *thr, FastState fs,
+                                        EventType typ, u64 addr) {
+  if (!kCollectHistory)
+    return;
+  DCHECK_GE((int)typ, 0);
+  DCHECK_LE((int)typ, 7);
+  DCHECK_EQ(GetLsb(addr, 61), addr);
+  StatInc(thr, StatEvents);
+  u64 pos = fs.GetTracePos();
+  if (UNLIKELY((pos % kTracePartSize) == 0)) {
+#ifndef SANITIZER_GO
+    HACKY_CALL(__tsan_trace_switch);
+#else
+    TraceSwitch(thr);
+#endif
+  }
+  Event *trace = (Event*)GetThreadTrace(fs.tid());
+  Event *evp = &trace[pos];
+  Event ev = (u64)addr | ((u64)typ << 61);
+  *evp = ev;
+}
+
+#ifndef SANITIZER_GO
+uptr ALWAYS_INLINE HeapEnd() {
+  return HeapMemEnd() + PrimaryAllocator::AdditionalSize();
+}
+#endif
+
+}  // namespace __tsan
+
+#endif  // TSAN_RTL_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_aarch64.S b/compiler-rt/lib/tsan/rtl/tsan_rtl_aarch64.S
new file mode 100644
index 0000000..9cea3cf
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_aarch64.S
@@ -0,0 +1,206 @@
+#include "sanitizer_common/sanitizer_asm.h"
+.section .text
+
+.hidden __tsan_setjmp
+.comm _ZN14__interception11real_setjmpE,8,8
+.type setjmp, @function
+setjmp:
+  CFI_STARTPROC
+
+  // save env parameters for function call
+  stp     x29, x30, [sp, -32]!
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (29, -32)
+  CFI_OFFSET (30, -24)
+
+  // Adjust the SP for previous frame
+  add     x29, sp, 0
+  CFI_DEF_CFA_REGISTER (29)
+
+  // Save jmp_buf
+  str     x19, [sp, 16]
+  CFI_OFFSET (19, -16)
+  mov     x19, x0
+
+  // SP pointer mangling (see glibc setjmp)
+  adrp    x2, :got:__pointer_chk_guard
+  ldr     x2, [x2, #:got_lo12:__pointer_chk_guard]
+  add     x0, x29, 32
+  ldr     x2, [x2]
+  eor     x1, x2, x0
+
+  // call tsan interceptor
+  bl      __tsan_setjmp
+
+  // restore env parameter
+  mov     x0, x19
+  ldr     x19, [sp, 16]
+  ldp     x29, x30, [sp], 32
+  CFI_RESTORE (30)
+  CFI_RESTORE (19)
+  CFI_DEF_CFA (31, 0)
+
+  // tail jump to libc setjmp
+  adrp    x1, :got:_ZN14__interception11real_setjmpE
+  ldr     x1, [x1, #:got_lo12:_ZN14__interception11real_setjmpE]
+  ldr     x1, [x1]
+  br      x1
+
+  CFI_ENDPROC
+.size setjmp, .-setjmp
+
+.comm _ZN14__interception12real__setjmpE,8,8
+.globl _setjmp
+.type _setjmp, @function
+_setjmp:
+  CFI_STARTPROC
+
+  // save env parameters for function call
+  stp     x29, x30, [sp, -32]!
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (29, -32)
+  CFI_OFFSET (30, -24)
+
+  // Adjust the SP for previous frame
+  add     x29, sp, 0
+  CFI_DEF_CFA_REGISTER (29)
+
+  // Save jmp_buf
+  str     x19, [sp, 16]
+  CFI_OFFSET (19, -16)
+  mov     x19, x0
+
+  // SP pointer mangling (see glibc setjmp)
+  adrp    x2, :got:__pointer_chk_guard
+  ldr     x2, [x2, #:got_lo12:__pointer_chk_guard]
+  add     x0, x29, 32
+  ldr     x2, [x2]
+  eor     x1, x2, x0
+
+  // call tsan interceptor
+  bl      __tsan_setjmp
+
+  // Restore jmp_buf parameter
+  mov     x0, x19
+  ldr     x19, [sp, 16]
+  ldp     x29, x30, [sp], 32
+  CFI_RESTORE (30)
+  CFI_RESTORE (19)
+  CFI_DEF_CFA (31, 0)
+
+  // tail jump to libc setjmp
+  adrp    x1, :got:_ZN14__interception12real__setjmpE
+  ldr     x1, [x1, #:got_lo12:_ZN14__interception12real__setjmpE]
+  ldr     x1, [x1]
+  br      x1
+
+  CFI_ENDPROC
+.size _setjmp, .-_setjmp
+
+.comm _ZN14__interception14real_sigsetjmpE,8,8
+.globl sigsetjmp
+.type sigsetjmp, @function
+sigsetjmp:
+  CFI_STARTPROC
+
+  // save env parameters for function call
+  stp     x29, x30, [sp, -32]!
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (29, -32)
+  CFI_OFFSET (30, -24)
+
+  // Adjust the SP for previous frame
+  add     x29, sp, 0
+  CFI_DEF_CFA_REGISTER (29)
+
+  // Save jmp_buf and savesigs
+  stp     x19, x20, [sp, 16]
+  CFI_OFFSET (19, -16)
+  CFI_OFFSET (20, -8)
+  mov     w20, w1
+  mov     x19, x0
+
+  // SP pointer mangling (see glibc setjmp)
+  adrp    x2, :got:__pointer_chk_guard
+  ldr     x2, [x2, #:got_lo12:__pointer_chk_guard]
+  add     x0, x29, 32
+  ldr     x2, [x2]
+  eor     x1, x2, x0
+
+  // call tsan interceptor
+  bl      __tsan_setjmp
+
+  // restore env parameter
+  mov     w1, w20
+  mov     x0, x19
+  ldp     x19, x20, [sp, 16]
+  ldp     x29, x30, [sp], 32
+  CFI_RESTORE (30)
+  CFI_RESTORE (29)
+  CFI_RESTORE (19)
+  CFI_RESTORE (20)
+  CFI_DEF_CFA (31, 0)
+
+  // tail jump to libc sigsetjmp
+  adrp    x2, :got:_ZN14__interception14real_sigsetjmpE
+  ldr     x2, [x2, #:got_lo12:_ZN14__interception14real_sigsetjmpE]
+  ldr     x2, [x2]
+  br      x2
+  CFI_ENDPROC
+.size sigsetjmp, .-sigsetjmp
+
+.comm _ZN14__interception16real___sigsetjmpE,8,8
+.globl __sigsetjmp
+.type __sigsetjmp, @function
+__sigsetjmp:
+  CFI_STARTPROC
+
+  // save env parameters for function call
+  stp     x29, x30, [sp, -32]!
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (29, -32)
+  CFI_OFFSET (30, -24)
+
+  // Adjust the SP for previous frame
+  add     x29, sp, 0
+  CFI_DEF_CFA_REGISTER (29)
+
+  // Save jmp_buf and savesigs
+  stp     x19, x20, [sp, 16]
+  CFI_OFFSET (19, -16)
+  CFI_OFFSET (20, -8)
+  mov     w20, w1
+  mov     x19, x0
+
+  // SP pointer mangling (see glibc setjmp)
+  adrp    x2, :got:__pointer_chk_guard
+  ldr     x2, [x2, #:got_lo12:__pointer_chk_guard]
+  add     x0, x29, 32
+  ldr     x2, [x2]
+  eor     x1, x2, x0
+
+  // call tsan interceptor
+  bl      __tsan_setjmp
+
+  mov     w1, w20
+  mov     x0, x19
+  ldp     x19, x20, [sp, 16]
+  ldp     x29, x30, [sp], 32
+  CFI_RESTORE (30)
+  CFI_RESTORE (29)
+  CFI_RESTORE (19)
+  CFI_RESTORE (20)
+  CFI_DEF_CFA (31, 0)
+
+  // tail jump to libc __sigsetjmp
+  adrp    x2, :got:_ZN14__interception16real___sigsetjmpE
+  ldr     x2, [x2, #:got_lo12:_ZN14__interception16real___sigsetjmpE]
+  ldr     x2, [x2]
+  br      x2
+  CFI_ENDPROC
+.size __sigsetjmp, .-__sigsetjmp
+
+#if defined(__linux__)
+/* We do not need executable stack.  */
+.section        .note.GNU-stack,"",@progbits
+#endif
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_amd64.S b/compiler-rt/lib/tsan/rtl/tsan_rtl_amd64.S
new file mode 100644
index 0000000..caa8323
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_amd64.S
@@ -0,0 +1,359 @@
+#include "sanitizer_common/sanitizer_asm.h"
+#if !defined(__APPLE__)
+.section .text
+#else
+.section __TEXT,__text
+#endif
+
+ASM_HIDDEN(__tsan_trace_switch)
+.globl ASM_TSAN_SYMBOL(__tsan_trace_switch_thunk)
+ASM_TSAN_SYMBOL(__tsan_trace_switch_thunk):
+  CFI_STARTPROC
+  # Save scratch registers.
+  push %rax
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rax, 0)
+  push %rcx
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rcx, 0)
+  push %rdx
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdx, 0)
+  push %rsi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rsi, 0)
+  push %rdi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdi, 0)
+  push %r8
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r8, 0)
+  push %r9
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r9, 0)
+  push %r10
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r10, 0)
+  push %r11
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r11, 0)
+  # Align stack frame.
+  push %rbx  # non-scratch
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rbx, 0)
+  mov %rsp, %rbx  # save current rsp
+  CFI_DEF_CFA_REGISTER(%rbx)
+  shr $4, %rsp  # clear 4 lsb, align to 16
+  shl $4, %rsp
+
+  call ASM_TSAN_SYMBOL(__tsan_trace_switch)
+
+  # Unalign stack frame back.
+  mov %rbx, %rsp  # restore the original rsp
+  CFI_DEF_CFA_REGISTER(%rsp)
+  pop %rbx
+  CFI_ADJUST_CFA_OFFSET(-8)
+  # Restore scratch registers.
+  pop %r11
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %r10
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %r9
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %r8
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rdi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rsi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rdx
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rcx
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rax
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rax)
+  CFI_RESTORE(%rbx)
+  CFI_RESTORE(%rcx)
+  CFI_RESTORE(%rdx)
+  CFI_RESTORE(%rsi)
+  CFI_RESTORE(%rdi)
+  CFI_RESTORE(%r8)
+  CFI_RESTORE(%r9)
+  CFI_RESTORE(%r10)
+  CFI_RESTORE(%r11)
+  ret
+  CFI_ENDPROC
+
+ASM_HIDDEN(__tsan_report_race)
+.globl ASM_TSAN_SYMBOL(__tsan_report_race_thunk)
+ASM_TSAN_SYMBOL(__tsan_report_race_thunk):
+  CFI_STARTPROC
+  # Save scratch registers.
+  push %rax
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rax, 0)
+  push %rcx
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rcx, 0)
+  push %rdx
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdx, 0)
+  push %rsi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rsi, 0)
+  push %rdi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdi, 0)
+  push %r8
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r8, 0)
+  push %r9
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r9, 0)
+  push %r10
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r10, 0)
+  push %r11
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%r11, 0)
+  # Align stack frame.
+  push %rbx  # non-scratch
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rbx, 0)
+  mov %rsp, %rbx  # save current rsp
+  CFI_DEF_CFA_REGISTER(%rbx)
+  shr $4, %rsp  # clear 4 lsb, align to 16
+  shl $4, %rsp
+
+  call ASM_TSAN_SYMBOL(__tsan_report_race)
+
+  # Unalign stack frame back.
+  mov %rbx, %rsp  # restore the original rsp
+  CFI_DEF_CFA_REGISTER(%rsp)
+  pop %rbx
+  CFI_ADJUST_CFA_OFFSET(-8)
+  # Restore scratch registers.
+  pop %r11
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %r10
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %r9
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %r8
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rdi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rsi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rdx
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rcx
+  CFI_ADJUST_CFA_OFFSET(-8)
+  pop %rax
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rax)
+  CFI_RESTORE(%rbx)
+  CFI_RESTORE(%rcx)
+  CFI_RESTORE(%rdx)
+  CFI_RESTORE(%rsi)
+  CFI_RESTORE(%rdi)
+  CFI_RESTORE(%r8)
+  CFI_RESTORE(%r9)
+  CFI_RESTORE(%r10)
+  CFI_RESTORE(%r11)
+  ret
+  CFI_ENDPROC
+
+ASM_HIDDEN(__tsan_setjmp)
+#if !defined(__APPLE__)
+.comm _ZN14__interception11real_setjmpE,8,8
+#endif
+.globl ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp)
+ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp))
+ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp):
+  CFI_STARTPROC
+  // save env parameter
+  push %rdi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdi, 0)
+  // obtain %rsp
+#if defined(__FreeBSD__)
+  lea 8(%rsp), %rdi
+  mov %rdi, %rsi
+#elif defined(__APPLE__)
+  lea 16(%rsp), %rdi
+  mov %rdi, %rsi
+#elif defined(__linux__)
+  lea 16(%rsp), %rdi
+  mov %rdi, %rsi
+  xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
+  rol $0x11, %rsi
+#else
+# error "Unknown platform"
+#endif
+  // call tsan interceptor
+  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  // restore env parameter
+  pop %rdi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rdi)
+  // tail jump to libc setjmp
+  movl $0, %eax
+#if !defined(__APPLE__)
+  movq _ZN14__interception11real_setjmpE@GOTPCREL(%rip), %rdx
+  jmp *(%rdx)
+#else
+  jmp ASM_TSAN_SYMBOL(setjmp)
+#endif
+  CFI_ENDPROC
+ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(setjmp))
+
+.comm _ZN14__interception12real__setjmpE,8,8
+.globl ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp)
+ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp):
+  CFI_STARTPROC
+  // save env parameter
+  push %rdi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdi, 0)
+  // obtain %rsp
+#if defined(__FreeBSD__)
+  lea 8(%rsp), %rdi
+  mov %rdi, %rsi
+#elif defined(__APPLE__)
+  lea 16(%rsp), %rdi
+  mov %rdi, %rsi
+#elif defined(__linux__)
+  lea 16(%rsp), %rdi
+  mov %rdi, %rsi
+  xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
+  rol $0x11, %rsi
+#else
+# error "Unknown platform"
+#endif
+  // call tsan interceptor
+  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  // restore env parameter
+  pop %rdi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rdi)
+  // tail jump to libc setjmp
+  movl $0, %eax
+#if !defined(__APPLE__)
+  movq _ZN14__interception12real__setjmpE@GOTPCREL(%rip), %rdx
+  jmp *(%rdx)
+#else
+  jmp ASM_TSAN_SYMBOL(_setjmp)
+#endif
+  CFI_ENDPROC
+ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(_setjmp))
+
+.comm _ZN14__interception14real_sigsetjmpE,8,8
+.globl ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp):
+  CFI_STARTPROC
+  // save env parameter
+  push %rdi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdi, 0)
+  // save savesigs parameter
+  push %rsi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rsi, 0)
+  // align stack frame
+  sub $8, %rsp
+  CFI_ADJUST_CFA_OFFSET(8)
+  // obtain %rsp
+#if defined(__FreeBSD__)
+  lea 24(%rsp), %rdi
+  mov %rdi, %rsi
+#elif defined(__APPLE__)
+  lea 32(%rsp), %rdi
+  mov %rdi, %rsi
+#elif defined(__linux__)
+  lea 32(%rsp), %rdi
+  mov %rdi, %rsi
+  xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
+  rol $0x11, %rsi
+#else
+# error "Unknown platform"
+#endif
+  // call tsan interceptor
+  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  // unalign stack frame
+  add $8, %rsp
+  CFI_ADJUST_CFA_OFFSET(-8)
+  // restore savesigs parameter
+  pop %rsi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rsi)
+  // restore env parameter
+  pop %rdi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rdi)
+  // tail jump to libc sigsetjmp
+  movl $0, %eax
+#if !defined(__APPLE__)
+  movq _ZN14__interception14real_sigsetjmpE@GOTPCREL(%rip), %rdx
+  jmp *(%rdx)
+#else
+  jmp ASM_TSAN_SYMBOL(sigsetjmp)
+#endif
+  CFI_ENDPROC
+ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
+
+#if !defined(__APPLE__)
+.comm _ZN14__interception16real___sigsetjmpE,8,8
+.globl ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp):
+  CFI_STARTPROC
+  // save env parameter
+  push %rdi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rdi, 0)
+  // save savesigs parameter
+  push %rsi
+  CFI_ADJUST_CFA_OFFSET(8)
+  CFI_REL_OFFSET(%rsi, 0)
+  // align stack frame
+  sub $8, %rsp
+  CFI_ADJUST_CFA_OFFSET(8)
+  // obtain %rsp
+#if defined(__FreeBSD__)
+  lea 24(%rsp), %rdi
+  mov %rdi, %rsi
+#else
+  lea 32(%rsp), %rdi
+  mov %rdi, %rsi
+  xor %fs:0x30, %rsi  // magic mangling of rsp (see libc setjmp)
+  rol $0x11, %rsi
+#endif
+  // call tsan interceptor
+  call ASM_TSAN_SYMBOL(__tsan_setjmp)
+  // unalign stack frame
+  add $8, %rsp
+  CFI_ADJUST_CFA_OFFSET(-8)
+  // restore savesigs parameter
+  pop %rsi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rsi)
+  // restore env parameter
+  pop %rdi
+  CFI_ADJUST_CFA_OFFSET(-8)
+  CFI_RESTORE(%rdi)
+  // tail jump to libc sigsetjmp
+  movl $0, %eax
+  movq _ZN14__interception16real___sigsetjmpE@GOTPCREL(%rip), %rdx
+  jmp *(%rdx)
+  CFI_ENDPROC
+ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))
+#endif  // !defined(__APPLE__)
+
+#if defined(__FreeBSD__) || defined(__linux__)
+/* We do not need executable stack.  */
+.section        .note.GNU-stack,"",@progbits
+#endif
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cc b/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cc
new file mode 100644
index 0000000..62ab7aa
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cc
@@ -0,0 +1,487 @@
+//===-- tsan_rtl_mutex.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include <sanitizer_common/sanitizer_deadlock_detector_interface.h>
+#include <sanitizer_common/sanitizer_stackdepot.h>
+
+#include "tsan_rtl.h"
+#include "tsan_flags.h"
+#include "tsan_sync.h"
+#include "tsan_report.h"
+#include "tsan_symbolize.h"
+#include "tsan_platform.h"
+
+namespace __tsan {
+
+void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r);
+
+struct Callback : DDCallback {
+  ThreadState *thr;
+  uptr pc;
+
+  Callback(ThreadState *thr, uptr pc)
+      : thr(thr)
+      , pc(pc) {
+    DDCallback::pt = thr->dd_pt;
+    DDCallback::lt = thr->dd_lt;
+  }
+
+  u32 Unwind() override { return CurrentStackId(thr, pc); }
+  int UniqueTid() override { return thr->unique_id; }
+};
+
+void DDMutexInit(ThreadState *thr, uptr pc, SyncVar *s) {
+  Callback cb(thr, pc);
+  ctx->dd->MutexInit(&cb, &s->dd);
+  s->dd.ctx = s->GetId();
+}
+
+static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ,
+    uptr addr, u64 mid) {
+  // In Go, these misuses are either impossible, or detected by std lib,
+  // or false positives (e.g. unlock in a different thread).
+  if (kGoMode)
+    return;
+  ThreadRegistryLock l(ctx->thread_registry);
+  ScopedReport rep(typ);
+  rep.AddMutex(mid);
+  VarSizeStackTrace trace;
+  ObtainCurrentStack(thr, pc, &trace);
+  rep.AddStack(trace, true);
+  rep.AddLocation(addr, 1);
+  OutputReport(thr, rep);
+}
+
+void MutexCreate(ThreadState *thr, uptr pc, uptr addr,
+                 bool rw, bool recursive, bool linker_init) {
+  DPrintf("#%d: MutexCreate %zx\n", thr->tid, addr);
+  StatInc(thr, StatMutexCreate);
+  if (!linker_init && IsAppMem(addr)) {
+    CHECK(!thr->is_freeing);
+    thr->is_freeing = true;
+    MemoryWrite(thr, pc, addr, kSizeLog1);
+    thr->is_freeing = false;
+  }
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  s->is_rw = rw;
+  s->is_recursive = recursive;
+  s->is_linker_init = linker_init;
+  if (kCppMode && s->creation_stack_id == 0)
+    s->creation_stack_id = CurrentStackId(thr, pc);
+  s->mtx.Unlock();
+}
+
+void MutexDestroy(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: MutexDestroy %zx\n", thr->tid, addr);
+  StatInc(thr, StatMutexDestroy);
+#ifndef SANITIZER_GO
+  // Global mutexes not marked as LINKER_INITIALIZED
+  // cause tons of not interesting reports, so just ignore it.
+  if (IsGlobalVar(addr))
+    return;
+#endif
+  if (IsAppMem(addr)) {
+    CHECK(!thr->is_freeing);
+    thr->is_freeing = true;
+    MemoryWrite(thr, pc, addr, kSizeLog1);
+    thr->is_freeing = false;
+  }
+  SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr);
+  if (s == 0)
+    return;
+  if (common_flags()->detect_deadlocks) {
+    Callback cb(thr, pc);
+    ctx->dd->MutexDestroy(&cb, &s->dd);
+    ctx->dd->MutexInit(&cb, &s->dd);
+  }
+  bool unlock_locked = false;
+  if (flags()->report_destroy_locked
+      && s->owner_tid != SyncVar::kInvalidTid
+      && !s->is_broken) {
+    s->is_broken = true;
+    unlock_locked = true;
+  }
+  u64 mid = s->GetId();
+  u32 last_lock = s->last_lock;
+  if (!unlock_locked)
+    s->Reset(thr);  // must not reset it before the report is printed
+  s->mtx.Unlock();
+  if (unlock_locked) {
+    ThreadRegistryLock l(ctx->thread_registry);
+    ScopedReport rep(ReportTypeMutexDestroyLocked);
+    rep.AddMutex(mid);
+    VarSizeStackTrace trace;
+    ObtainCurrentStack(thr, pc, &trace);
+    rep.AddStack(trace);
+    FastState last(last_lock);
+    RestoreStack(last.tid(), last.epoch(), &trace, 0);
+    rep.AddStack(trace, true);
+    rep.AddLocation(addr, 1);
+    OutputReport(thr, rep);
+  }
+  if (unlock_locked) {
+    SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr);
+    if (s != 0) {
+      s->Reset(thr);
+      s->mtx.Unlock();
+    }
+  }
+  thr->mset.Remove(mid);
+  // s will be destroyed and freed in MetaMap::FreeBlock.
+}
+
+void MutexLock(ThreadState *thr, uptr pc, uptr addr, int rec, bool try_lock) {
+  DPrintf("#%d: MutexLock %zx rec=%d\n", thr->tid, addr, rec);
+  CHECK_GT(rec, 0);
+  if (IsAppMem(addr))
+    MemoryReadAtomic(thr, pc, addr, kSizeLog1);
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  thr->fast_state.IncrementEpoch();
+  TraceAddEvent(thr, thr->fast_state, EventTypeLock, s->GetId());
+  bool report_double_lock = false;
+  if (s->owner_tid == SyncVar::kInvalidTid) {
+    CHECK_EQ(s->recursion, 0);
+    s->owner_tid = thr->tid;
+    s->last_lock = thr->fast_state.raw();
+  } else if (s->owner_tid == thr->tid) {
+    CHECK_GT(s->recursion, 0);
+  } else if (flags()->report_mutex_bugs && !s->is_broken) {
+    s->is_broken = true;
+    report_double_lock = true;
+  }
+  if (s->recursion == 0) {
+    StatInc(thr, StatMutexLock);
+    AcquireImpl(thr, pc, &s->clock);
+    AcquireImpl(thr, pc, &s->read_clock);
+  } else if (!s->is_recursive) {
+    StatInc(thr, StatMutexRecLock);
+  }
+  s->recursion += rec;
+  thr->mset.Add(s->GetId(), true, thr->fast_state.epoch());
+  if (common_flags()->detect_deadlocks && (s->recursion - rec) == 0) {
+    Callback cb(thr, pc);
+    if (!try_lock)
+      ctx->dd->MutexBeforeLock(&cb, &s->dd, true);
+    ctx->dd->MutexAfterLock(&cb, &s->dd, true, try_lock);
+  }
+  u64 mid = s->GetId();
+  s->mtx.Unlock();
+  // Can't touch s after this point.
+  if (report_double_lock)
+    ReportMutexMisuse(thr, pc, ReportTypeMutexDoubleLock, addr, mid);
+  if (common_flags()->detect_deadlocks) {
+    Callback cb(thr, pc);
+    ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
+  }
+}
+
+int MutexUnlock(ThreadState *thr, uptr pc, uptr addr, bool all) {
+  DPrintf("#%d: MutexUnlock %zx all=%d\n", thr->tid, addr, all);
+  if (IsAppMem(addr))
+    MemoryReadAtomic(thr, pc, addr, kSizeLog1);
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  thr->fast_state.IncrementEpoch();
+  TraceAddEvent(thr, thr->fast_state, EventTypeUnlock, s->GetId());
+  int rec = 0;
+  bool report_bad_unlock = false;
+  if (kCppMode && (s->recursion == 0 || s->owner_tid != thr->tid)) {
+    if (flags()->report_mutex_bugs && !s->is_broken) {
+      s->is_broken = true;
+      report_bad_unlock = true;
+    }
+  } else {
+    rec = all ? s->recursion : 1;
+    s->recursion -= rec;
+    if (s->recursion == 0) {
+      StatInc(thr, StatMutexUnlock);
+      s->owner_tid = SyncVar::kInvalidTid;
+      ReleaseStoreImpl(thr, pc, &s->clock);
+    } else {
+      StatInc(thr, StatMutexRecUnlock);
+    }
+  }
+  thr->mset.Del(s->GetId(), true);
+  if (common_flags()->detect_deadlocks && s->recursion == 0 &&
+      !report_bad_unlock) {
+    Callback cb(thr, pc);
+    ctx->dd->MutexBeforeUnlock(&cb, &s->dd, true);
+  }
+  u64 mid = s->GetId();
+  s->mtx.Unlock();
+  // Can't touch s after this point.
+  if (report_bad_unlock)
+    ReportMutexMisuse(thr, pc, ReportTypeMutexBadUnlock, addr, mid);
+  if (common_flags()->detect_deadlocks && !report_bad_unlock) {
+    Callback cb(thr, pc);
+    ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
+  }
+  return rec;
+}
+
+void MutexReadLock(ThreadState *thr, uptr pc, uptr addr, bool trylock) {
+  DPrintf("#%d: MutexReadLock %zx\n", thr->tid, addr);
+  StatInc(thr, StatMutexReadLock);
+  if (IsAppMem(addr))
+    MemoryReadAtomic(thr, pc, addr, kSizeLog1);
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false);
+  thr->fast_state.IncrementEpoch();
+  TraceAddEvent(thr, thr->fast_state, EventTypeRLock, s->GetId());
+  bool report_bad_lock = false;
+  if (s->owner_tid != SyncVar::kInvalidTid) {
+    if (flags()->report_mutex_bugs && !s->is_broken) {
+      s->is_broken = true;
+      report_bad_lock = true;
+    }
+  }
+  AcquireImpl(thr, pc, &s->clock);
+  s->last_lock = thr->fast_state.raw();
+  thr->mset.Add(s->GetId(), false, thr->fast_state.epoch());
+  if (common_flags()->detect_deadlocks && s->recursion == 0) {
+    Callback cb(thr, pc);
+    if (!trylock)
+      ctx->dd->MutexBeforeLock(&cb, &s->dd, false);
+    ctx->dd->MutexAfterLock(&cb, &s->dd, false, trylock);
+  }
+  u64 mid = s->GetId();
+  s->mtx.ReadUnlock();
+  // Can't touch s after this point.
+  if (report_bad_lock)
+    ReportMutexMisuse(thr, pc, ReportTypeMutexBadReadLock, addr, mid);
+  if (common_flags()->detect_deadlocks) {
+    Callback cb(thr, pc);
+    ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
+  }
+}
+
+void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: MutexReadUnlock %zx\n", thr->tid, addr);
+  StatInc(thr, StatMutexReadUnlock);
+  if (IsAppMem(addr))
+    MemoryReadAtomic(thr, pc, addr, kSizeLog1);
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  thr->fast_state.IncrementEpoch();
+  TraceAddEvent(thr, thr->fast_state, EventTypeRUnlock, s->GetId());
+  bool report_bad_unlock = false;
+  if (s->owner_tid != SyncVar::kInvalidTid) {
+    if (flags()->report_mutex_bugs && !s->is_broken) {
+      s->is_broken = true;
+      report_bad_unlock = true;
+    }
+  }
+  ReleaseImpl(thr, pc, &s->read_clock);
+  if (common_flags()->detect_deadlocks && s->recursion == 0) {
+    Callback cb(thr, pc);
+    ctx->dd->MutexBeforeUnlock(&cb, &s->dd, false);
+  }
+  u64 mid = s->GetId();
+  s->mtx.Unlock();
+  // Can't touch s after this point.
+  thr->mset.Del(mid, false);
+  if (report_bad_unlock)
+    ReportMutexMisuse(thr, pc, ReportTypeMutexBadReadUnlock, addr, mid);
+  if (common_flags()->detect_deadlocks) {
+    Callback cb(thr, pc);
+    ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
+  }
+}
+
+void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: MutexReadOrWriteUnlock %zx\n", thr->tid, addr);
+  if (IsAppMem(addr))
+    MemoryReadAtomic(thr, pc, addr, kSizeLog1);
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  bool write = true;
+  bool report_bad_unlock = false;
+  if (s->owner_tid == SyncVar::kInvalidTid) {
+    // Seems to be read unlock.
+    write = false;
+    StatInc(thr, StatMutexReadUnlock);
+    thr->fast_state.IncrementEpoch();
+    TraceAddEvent(thr, thr->fast_state, EventTypeRUnlock, s->GetId());
+    ReleaseImpl(thr, pc, &s->read_clock);
+  } else if (s->owner_tid == thr->tid) {
+    // Seems to be write unlock.
+    thr->fast_state.IncrementEpoch();
+    TraceAddEvent(thr, thr->fast_state, EventTypeUnlock, s->GetId());
+    CHECK_GT(s->recursion, 0);
+    s->recursion--;
+    if (s->recursion == 0) {
+      StatInc(thr, StatMutexUnlock);
+      s->owner_tid = SyncVar::kInvalidTid;
+      ReleaseImpl(thr, pc, &s->clock);
+    } else {
+      StatInc(thr, StatMutexRecUnlock);
+    }
+  } else if (!s->is_broken) {
+    s->is_broken = true;
+    report_bad_unlock = true;
+  }
+  thr->mset.Del(s->GetId(), write);
+  if (common_flags()->detect_deadlocks && s->recursion == 0) {
+    Callback cb(thr, pc);
+    ctx->dd->MutexBeforeUnlock(&cb, &s->dd, write);
+  }
+  u64 mid = s->GetId();
+  s->mtx.Unlock();
+  // Can't touch s after this point.
+  if (report_bad_unlock)
+    ReportMutexMisuse(thr, pc, ReportTypeMutexBadUnlock, addr, mid);
+  if (common_flags()->detect_deadlocks) {
+    Callback cb(thr, pc);
+    ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb));
+  }
+}
+
+void MutexRepair(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: MutexRepair %zx\n", thr->tid, addr);
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  s->owner_tid = SyncVar::kInvalidTid;
+  s->recursion = 0;
+  s->mtx.Unlock();
+}
+
+void Acquire(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: Acquire %zx\n", thr->tid, addr);
+  if (thr->ignore_sync)
+    return;
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false);
+  AcquireImpl(thr, pc, &s->clock);
+  s->mtx.ReadUnlock();
+}
+
+static void UpdateClockCallback(ThreadContextBase *tctx_base, void *arg) {
+  ThreadState *thr = reinterpret_cast<ThreadState*>(arg);
+  ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base);
+  if (tctx->status == ThreadStatusRunning)
+    thr->clock.set(tctx->tid, tctx->thr->fast_state.epoch());
+  else
+    thr->clock.set(tctx->tid, tctx->epoch1);
+}
+
+void AcquireGlobal(ThreadState *thr, uptr pc) {
+  DPrintf("#%d: AcquireGlobal\n", thr->tid);
+  if (thr->ignore_sync)
+    return;
+  ThreadRegistryLock l(ctx->thread_registry);
+  ctx->thread_registry->RunCallbackForEachThreadLocked(
+      UpdateClockCallback, thr);
+}
+
+void Release(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: Release %zx\n", thr->tid, addr);
+  if (thr->ignore_sync)
+    return;
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  thr->fast_state.IncrementEpoch();
+  // Can't increment epoch w/o writing to the trace as well.
+  TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+  ReleaseImpl(thr, pc, &s->clock);
+  s->mtx.Unlock();
+}
+
+void ReleaseStore(ThreadState *thr, uptr pc, uptr addr) {
+  DPrintf("#%d: ReleaseStore %zx\n", thr->tid, addr);
+  if (thr->ignore_sync)
+    return;
+  SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true);
+  thr->fast_state.IncrementEpoch();
+  // Can't increment epoch w/o writing to the trace as well.
+  TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+  ReleaseStoreImpl(thr, pc, &s->clock);
+  s->mtx.Unlock();
+}
+
+#ifndef SANITIZER_GO
+static void UpdateSleepClockCallback(ThreadContextBase *tctx_base, void *arg) {
+  ThreadState *thr = reinterpret_cast<ThreadState*>(arg);
+  ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base);
+  if (tctx->status == ThreadStatusRunning)
+    thr->last_sleep_clock.set(tctx->tid, tctx->thr->fast_state.epoch());
+  else
+    thr->last_sleep_clock.set(tctx->tid, tctx->epoch1);
+}
+
+void AfterSleep(ThreadState *thr, uptr pc) {
+  DPrintf("#%d: AfterSleep %zx\n", thr->tid);
+  if (thr->ignore_sync)
+    return;
+  thr->last_sleep_stack_id = CurrentStackId(thr, pc);
+  ThreadRegistryLock l(ctx->thread_registry);
+  ctx->thread_registry->RunCallbackForEachThreadLocked(
+      UpdateSleepClockCallback, thr);
+}
+#endif
+
+void AcquireImpl(ThreadState *thr, uptr pc, SyncClock *c) {
+  if (thr->ignore_sync)
+    return;
+  thr->clock.set(thr->fast_state.epoch());
+  thr->clock.acquire(&thr->clock_cache, c);
+  StatInc(thr, StatSyncAcquire);
+}
+
+void ReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c) {
+  if (thr->ignore_sync)
+    return;
+  thr->clock.set(thr->fast_state.epoch());
+  thr->fast_synch_epoch = thr->fast_state.epoch();
+  thr->clock.release(&thr->clock_cache, c);
+  StatInc(thr, StatSyncRelease);
+}
+
+void ReleaseStoreImpl(ThreadState *thr, uptr pc, SyncClock *c) {
+  if (thr->ignore_sync)
+    return;
+  thr->clock.set(thr->fast_state.epoch());
+  thr->fast_synch_epoch = thr->fast_state.epoch();
+  thr->clock.ReleaseStore(&thr->clock_cache, c);
+  StatInc(thr, StatSyncRelease);
+}
+
+void AcquireReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c) {
+  if (thr->ignore_sync)
+    return;
+  thr->clock.set(thr->fast_state.epoch());
+  thr->fast_synch_epoch = thr->fast_state.epoch();
+  thr->clock.acq_rel(&thr->clock_cache, c);
+  StatInc(thr, StatSyncAcquire);
+  StatInc(thr, StatSyncRelease);
+}
+
+void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r) {
+  if (r == 0)
+    return;
+  ThreadRegistryLock l(ctx->thread_registry);
+  ScopedReport rep(ReportTypeDeadlock);
+  for (int i = 0; i < r->n; i++) {
+    rep.AddMutex(r->loop[i].mtx_ctx0);
+    rep.AddUniqueTid((int)r->loop[i].thr_ctx);
+    rep.AddThread((int)r->loop[i].thr_ctx);
+  }
+  uptr dummy_pc = 0x42;
+  for (int i = 0; i < r->n; i++) {
+    for (int j = 0; j < (flags()->second_deadlock_stack ? 2 : 1); j++) {
+      u32 stk = r->loop[i].stk[j];
+      if (stk && stk != 0xffffffff) {
+        rep.AddStack(StackDepotGet(stk), true);
+      } else {
+        // Sometimes we fail to extract the stack trace (FIXME: investigate),
+        // but we should still produce some stack trace in the report.
+        rep.AddStack(StackTrace(&dummy_pc, 1), true);
+      }
+    }
+  }
+  OutputReport(thr, rep);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_ppc64.S b/compiler-rt/lib/tsan/rtl/tsan_rtl_ppc64.S
new file mode 100644
index 0000000..8285e21
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_ppc64.S
@@ -0,0 +1,288 @@
+#include "tsan_ppc_regs.h"
+
+        .section .text
+        .hidden __tsan_setjmp
+        .globl _setjmp
+        .type _setjmp, @function
+        .align 4
+#if _CALL_ELF == 2
+_setjmp:
+#else
+	.section ".opd","aw"
+	.align 3
+_setjmp:
+	.quad   .L._setjmp,.TOC.@tocbase,0
+	.previous
+#endif
+.L._setjmp:
+        mflr    r0
+        stdu    r1,-48(r1)
+        std     r2,24(r1)
+        std     r3,32(r1)
+        std     r0,40(r1)
+        // r3 is the original stack pointer.
+        addi    r3,r1,48
+        // r4 is the mangled stack pointer (see glibc)
+        ld      r4,-28696(r13)
+        xor     r4,r3,r4
+        // Materialize a TOC in case we were called from libc.
+        // For big-endian, we load the TOC from the OPD.  For little-
+        // endian, we use the .TOC. symbol to find it.
+        nop
+        bcl     20,31,0f
+0:
+        mflr    r2
+#if _CALL_ELF == 2
+        addis   r2,r2,.TOC.-0b@ha
+        addi    r2,r2,.TOC.-0b@l
+#else
+        addis   r2,r2,_setjmp-0b@ha
+        addi    r2,r2,_setjmp-0b@l
+        ld      r2,8(r2)
+#endif
+        // Call the interceptor.
+        bl      __tsan_setjmp
+        nop
+        // Restore regs needed for setjmp.
+        ld      r3,32(r1)
+        ld      r0,40(r1)
+        // Emulate the real setjmp function.  We do this because we can't
+        // perform a sibcall:  The real setjmp function trashes the TOC
+        // pointer, and with a sibcall we have no way to restore it.
+        // This way we can make sure our caller's stack pointer and
+        // link register are saved correctly in the jmpbuf.
+        ld      r6,-28696(r13)
+        addi    r5,r1,48  // original stack ptr of caller
+        xor     r5,r6,r5
+        std     r5,0(r3)  // mangled stack ptr of caller
+        ld      r5,24(r1)
+        std     r5,8(r3)  // caller's saved TOC pointer
+        xor     r0,r6,r0
+        std     r0,16(r3) // caller's mangled return address
+        mfcr    r0
+        // Nonvolatiles.
+        std     r14,24(r3)
+        stfd    f14,176(r3)
+        stw     r0,172(r3) // CR
+        std     r15,32(r3)
+        stfd    f15,184(r3)
+        std     r16,40(r3)
+        stfd    f16,192(r3)
+        std     r17,48(r3)
+        stfd    f17,200(r3)
+        std     r18,56(r3)
+        stfd    f18,208(r3)
+        std     r19,64(r3)
+        stfd    f19,216(r3)
+        std     r20,72(r3)
+        stfd    f20,224(r3)
+        std     r21,80(r3)
+        stfd    f21,232(r3)
+        std     r22,88(r3)
+        stfd    f22,240(r3)
+        std     r23,96(r3)
+        stfd    f23,248(r3)
+        std     r24,104(r3)
+        stfd    f24,256(r3)
+        std     r25,112(r3)
+        stfd    f25,264(r3)
+        std     r26,120(r3)
+        stfd    f26,272(r3)
+        std     r27,128(r3)
+        stfd    f27,280(r3)
+        std     r28,136(r3)
+        stfd    f28,288(r3)
+        std     r29,144(r3)
+        stfd    f29,296(r3)
+        std     r30,152(r3)
+        stfd    f30,304(r3)
+        std     r31,160(r3)
+        stfd    f31,312(r3)
+        addi    r5,r3,320
+        mfspr   r0,256
+        stw     r0,168(r3)  // VRSAVE
+        addi    r6,r5,16
+        stvx    v20,0,r5
+        addi    r5,r5,32
+        stvx    v21,0,r6
+        addi    r6,r6,32
+        stvx    v22,0,r5
+        addi    r5,r5,32
+        stvx    v23,0,r6
+        addi    r6,r6,32
+        stvx    v24,0,r5
+        addi    r5,r5,32
+        stvx    v25,0,r6
+        addi    r6,r6,32
+        stvx    v26,0,r5
+        addi    r5,r5,32
+        stvx    v27,0,r6
+        addi    r6,r6,32
+        stvx    v28,0,r5
+        addi    r5,r5,32
+        stvx    v29,0,r6
+        addi    r6,r6,32
+        stvx    v30,0,r5
+        stvx    v31,0,r6
+        // Clear the "mask-saved" slot.
+        li      r4,0
+        stw     r4,512(r3)
+        // Restore TOC, LR, and stack and return to caller.
+        ld      r2,24(r1)
+        ld      r0,40(r1)
+        addi    r1,r1,48
+        li      r3,0  // This is the setjmp return path
+        mtlr    r0
+        blr
+        .size _setjmp, .-.L._setjmp
+
+        .globl setjmp
+        .type setjmp, @function
+        .align 4
+setjmp:
+        b       _setjmp
+        .size setjmp, .-setjmp
+
+        // sigsetjmp is like setjmp, except that the mask in r4 needs
+        // to be saved at offset 512 of the jump buffer.
+        .globl __sigsetjmp
+        .type __sigsetjmp, @function
+        .align 4
+#if _CALL_ELF == 2
+__sigsetjmp:
+#else
+	.section ".opd","aw"
+	.align 3
+__sigsetjmp:
+	.quad   .L.__sigsetjmp,.TOC.@tocbase,0
+	.previous
+#endif
+.L.__sigsetjmp:
+        mflr    r0
+        stdu    r1,-64(r1)
+        std     r2,24(r1)
+        std     r3,32(r1)
+        std     r4,40(r1)
+        std     r0,48(r1)
+        // r3 is the original stack pointer.
+        addi    r3,r1,64
+        // r4 is the mangled stack pointer (see glibc)
+        ld      r4,-28696(r13)
+        xor     r4,r3,r4
+        // Materialize a TOC in case we were called from libc.
+        // For big-endian, we load the TOC from the OPD.  For little-
+        // endian, we use the .TOC. symbol to find it.
+        nop
+        bcl     20,31,1f
+1:
+        mflr    r2
+#if _CALL_ELF == 2
+        addis   r2,r2,.TOC.-1b@ha
+        addi    r2,r2,.TOC.-1b@l
+#else
+        addis   r2,r2,_setjmp-1b@ha
+        addi    r2,r2,_setjmp-1b@l
+        ld      r2,8(r2)
+#endif
+        // Call the interceptor.
+        bl      __tsan_setjmp
+        nop
+        // Restore regs needed for __sigsetjmp.
+        ld      r3,32(r1)
+        ld      r4,40(r1)
+        ld      r0,48(r1)
+        // Emulate the real sigsetjmp function.  We do this because we can't
+        // perform a sibcall:  The real sigsetjmp function trashes the TOC
+        // pointer, and with a sibcall we have no way to restore it.
+        // This way we can make sure our caller's stack pointer and
+        // link register are saved correctly in the jmpbuf.
+        ld      r6,-28696(r13)
+        addi    r5,r1,64  // original stack ptr of caller
+        xor     r5,r6,r5
+        std     r5,0(r3)  // mangled stack ptr of caller
+        ld      r5,24(r1)
+        std     r5,8(r3)  // caller's saved TOC pointer
+        xor     r0,r6,r0
+        std     r0,16(r3) // caller's mangled return address
+        mfcr    r0
+        // Nonvolatiles.
+        std     r14,24(r3)
+        stfd    f14,176(r3)
+        stw     r0,172(r3) // CR
+        std     r15,32(r3)
+        stfd    f15,184(r3)
+        std     r16,40(r3)
+        stfd    f16,192(r3)
+        std     r17,48(r3)
+        stfd    f17,200(r3)
+        std     r18,56(r3)
+        stfd    f18,208(r3)
+        std     r19,64(r3)
+        stfd    f19,216(r3)
+        std     r20,72(r3)
+        stfd    f20,224(r3)
+        std     r21,80(r3)
+        stfd    f21,232(r3)
+        std     r22,88(r3)
+        stfd    f22,240(r3)
+        std     r23,96(r3)
+        stfd    f23,248(r3)
+        std     r24,104(r3)
+        stfd    f24,256(r3)
+        std     r25,112(r3)
+        stfd    f25,264(r3)
+        std     r26,120(r3)
+        stfd    f26,272(r3)
+        std     r27,128(r3)
+        stfd    f27,280(r3)
+        std     r28,136(r3)
+        stfd    f28,288(r3)
+        std     r29,144(r3)
+        stfd    f29,296(r3)
+        std     r30,152(r3)
+        stfd    f30,304(r3)
+        std     r31,160(r3)
+        stfd    f31,312(r3)
+        addi    r5,r3,320
+        mfspr   r0,256
+        stw     r0,168(r3) // VRSAVE
+        addi    r6,r5,16
+        stvx    v20,0,r5
+        addi    r5,r5,32
+        stvx    v21,0,r6
+        addi    r6,r6,32
+        stvx    v22,0,r5
+        addi    r5,r5,32
+        stvx    v23,0,r6
+        addi    r6,r6,32
+        stvx    v24,0,r5
+        addi    r5,r5,32
+        stvx    v25,0,r6
+        addi    r6,r6,32
+        stvx    v26,0,r5
+        addi    r5,r5,32
+        stvx    v27,0,r6
+        addi    r6,r6,32
+        stvx    v28,0,r5
+        addi    r5,r5,32
+        stvx    v29,0,r6
+        addi    r6,r6,32
+        stvx    v30,0,r5
+        stvx    v31,0,r6
+        // Save into the "mask-saved" slot.
+        stw     r4,512(r3)
+        // Restore TOC, LR, and stack and return to caller.
+        ld      r2,24(r1)
+        ld      r0,48(r1)
+        addi    r1,r1,64
+        li      r3,0  // This is the sigsetjmp return path
+        mtlr    r0
+        blr
+        .size __sigsetjmp, .-.L.__sigsetjmp
+
+        .globl sigsetjmp
+        .type sigsetjmp, @function
+        .align 4
+sigsetjmp:
+        b       __sigsetjmp
+        .size sigsetjmp, .-sigsetjmp
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cc b/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cc
new file mode 100644
index 0000000..5aff6ca
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_report.cc
@@ -0,0 +1,696 @@
+//===-- tsan_rtl_report.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "tsan_suppressions.h"
+#include "tsan_symbolize.h"
+#include "tsan_report.h"
+#include "tsan_sync.h"
+#include "tsan_mman.h"
+#include "tsan_flags.h"
+#include "tsan_fd.h"
+
+namespace __tsan {
+
+using namespace __sanitizer;  // NOLINT
+
+static ReportStack *SymbolizeStack(StackTrace trace);
+
+void TsanCheckFailed(const char *file, int line, const char *cond,
+                     u64 v1, u64 v2) {
+  // There is high probability that interceptors will check-fail as well,
+  // on the other hand there is no sense in processing interceptors
+  // since we are going to die soon.
+  ScopedIgnoreInterceptors ignore;
+  Printf("FATAL: ThreadSanitizer CHECK failed: "
+         "%s:%d \"%s\" (0x%zx, 0x%zx)\n",
+         file, line, cond, (uptr)v1, (uptr)v2);
+  PrintCurrentStackSlow(StackTrace::GetCurrentPc());
+  Die();
+}
+
+// Can be overriden by an application/test to intercept reports.
+#ifdef TSAN_EXTERNAL_HOOKS
+bool OnReport(const ReportDesc *rep, bool suppressed);
+#else
+SANITIZER_WEAK_CXX_DEFAULT_IMPL
+bool OnReport(const ReportDesc *rep, bool suppressed) {
+  (void)rep;
+  return suppressed;
+}
+#endif
+
+static void StackStripMain(SymbolizedStack *frames) {
+  SymbolizedStack *last_frame = nullptr;
+  SymbolizedStack *last_frame2 = nullptr;
+  for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+    last_frame2 = last_frame;
+    last_frame = cur;
+  }
+
+  if (last_frame2 == 0)
+    return;
+#ifndef SANITIZER_GO
+  const char *last = last_frame->info.function;
+  const char *last2 = last_frame2->info.function;
+  // Strip frame above 'main'
+  if (last2 && 0 == internal_strcmp(last2, "main")) {
+    last_frame->ClearAll();
+    last_frame2->next = nullptr;
+  // Strip our internal thread start routine.
+  } else if (last && 0 == internal_strcmp(last, "__tsan_thread_start_func")) {
+    last_frame->ClearAll();
+    last_frame2->next = nullptr;
+  // Strip global ctors init.
+  } else if (last && 0 == internal_strcmp(last, "__do_global_ctors_aux")) {
+    last_frame->ClearAll();
+    last_frame2->next = nullptr;
+  // If both are 0, then we probably just failed to symbolize.
+  } else if (last || last2) {
+    // Ensure that we recovered stack completely. Trimmed stack
+    // can actually happen if we do not instrument some code,
+    // so it's only a debug print. However we must try hard to not miss it
+    // due to our fault.
+    DPrintf("Bottom stack frame is missed\n");
+  }
+#else
+  // The last frame always point into runtime (gosched0, goexit0, runtime.main).
+  last_frame->ClearAll();
+  last_frame2->next = nullptr;
+#endif
+}
+
+ReportStack *SymbolizeStackId(u32 stack_id) {
+  if (stack_id == 0)
+    return 0;
+  StackTrace stack = StackDepotGet(stack_id);
+  if (stack.trace == nullptr)
+    return nullptr;
+  return SymbolizeStack(stack);
+}
+
+static ReportStack *SymbolizeStack(StackTrace trace) {
+  if (trace.size == 0)
+    return 0;
+  SymbolizedStack *top = nullptr;
+  for (uptr si = 0; si < trace.size; si++) {
+    const uptr pc = trace.trace[si];
+    uptr pc1 = pc;
+    // We obtain the return address, but we're interested in the previous
+    // instruction.
+    if ((pc & kExternalPCBit) == 0)
+      pc1 = StackTrace::GetPreviousInstructionPc(pc);
+    SymbolizedStack *ent = SymbolizeCode(pc1);
+    CHECK_NE(ent, 0);
+    SymbolizedStack *last = ent;
+    while (last->next) {
+      last->info.address = pc;  // restore original pc for report
+      last = last->next;
+    }
+    last->info.address = pc;  // restore original pc for report
+    last->next = top;
+    top = ent;
+  }
+  StackStripMain(top);
+
+  ReportStack *stack = ReportStack::New();
+  stack->frames = top;
+  return stack;
+}
+
+ScopedReport::ScopedReport(ReportType typ) {
+  ctx->thread_registry->CheckLocked();
+  void *mem = internal_alloc(MBlockReport, sizeof(ReportDesc));
+  rep_ = new(mem) ReportDesc;
+  rep_->typ = typ;
+  ctx->report_mtx.Lock();
+  CommonSanitizerReportMutex.Lock();
+}
+
+ScopedReport::~ScopedReport() {
+  CommonSanitizerReportMutex.Unlock();
+  ctx->report_mtx.Unlock();
+  DestroyAndFree(rep_);
+}
+
+void ScopedReport::AddStack(StackTrace stack, bool suppressable) {
+  ReportStack **rs = rep_->stacks.PushBack();
+  *rs = SymbolizeStack(stack);
+  (*rs)->suppressable = suppressable;
+}
+
+void ScopedReport::AddMemoryAccess(uptr addr, Shadow s, StackTrace stack,
+                                   const MutexSet *mset) {
+  void *mem = internal_alloc(MBlockReportMop, sizeof(ReportMop));
+  ReportMop *mop = new(mem) ReportMop;
+  rep_->mops.PushBack(mop);
+  mop->tid = s.tid();
+  mop->addr = addr + s.addr0();
+  mop->size = s.size();
+  mop->write = s.IsWrite();
+  mop->atomic = s.IsAtomic();
+  mop->stack = SymbolizeStack(stack);
+  if (mop->stack)
+    mop->stack->suppressable = true;
+  for (uptr i = 0; i < mset->Size(); i++) {
+    MutexSet::Desc d = mset->Get(i);
+    u64 mid = this->AddMutex(d.id);
+    ReportMopMutex mtx = {mid, d.write};
+    mop->mset.PushBack(mtx);
+  }
+}
+
+void ScopedReport::AddUniqueTid(int unique_tid) {
+  rep_->unique_tids.PushBack(unique_tid);
+}
+
+void ScopedReport::AddThread(const ThreadContext *tctx, bool suppressable) {
+  for (uptr i = 0; i < rep_->threads.Size(); i++) {
+    if ((u32)rep_->threads[i]->id == tctx->tid)
+      return;
+  }
+  void *mem = internal_alloc(MBlockReportThread, sizeof(ReportThread));
+  ReportThread *rt = new(mem) ReportThread;
+  rep_->threads.PushBack(rt);
+  rt->id = tctx->tid;
+  rt->pid = tctx->os_id;
+  rt->running = (tctx->status == ThreadStatusRunning);
+  rt->name = internal_strdup(tctx->name);
+  rt->parent_tid = tctx->parent_tid;
+  rt->stack = 0;
+  rt->stack = SymbolizeStackId(tctx->creation_stack_id);
+  if (rt->stack)
+    rt->stack->suppressable = suppressable;
+}
+
+#ifndef SANITIZER_GO
+static bool FindThreadByUidLockedCallback(ThreadContextBase *tctx, void *arg) {
+  int unique_id = *(int *)arg;
+  return tctx->unique_id == (u32)unique_id;
+}
+
+static ThreadContext *FindThreadByUidLocked(int unique_id) {
+  ctx->thread_registry->CheckLocked();
+  return static_cast<ThreadContext *>(
+      ctx->thread_registry->FindThreadContextLocked(
+          FindThreadByUidLockedCallback, &unique_id));
+}
+
+static ThreadContext *FindThreadByTidLocked(int tid) {
+  ctx->thread_registry->CheckLocked();
+  return static_cast<ThreadContext*>(
+      ctx->thread_registry->GetThreadLocked(tid));
+}
+
+static bool IsInStackOrTls(ThreadContextBase *tctx_base, void *arg) {
+  uptr addr = (uptr)arg;
+  ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base);
+  if (tctx->status != ThreadStatusRunning)
+    return false;
+  ThreadState *thr = tctx->thr;
+  CHECK(thr);
+  return ((addr >= thr->stk_addr && addr < thr->stk_addr + thr->stk_size) ||
+          (addr >= thr->tls_addr && addr < thr->tls_addr + thr->tls_size));
+}
+
+ThreadContext *IsThreadStackOrTls(uptr addr, bool *is_stack) {
+  ctx->thread_registry->CheckLocked();
+  ThreadContext *tctx = static_cast<ThreadContext*>(
+      ctx->thread_registry->FindThreadContextLocked(IsInStackOrTls,
+                                                    (void*)addr));
+  if (!tctx)
+    return 0;
+  ThreadState *thr = tctx->thr;
+  CHECK(thr);
+  *is_stack = (addr >= thr->stk_addr && addr < thr->stk_addr + thr->stk_size);
+  return tctx;
+}
+#endif
+
+void ScopedReport::AddThread(int unique_tid, bool suppressable) {
+#ifndef SANITIZER_GO
+  if (const ThreadContext *tctx = FindThreadByUidLocked(unique_tid))
+    AddThread(tctx, suppressable);
+#endif
+}
+
+void ScopedReport::AddMutex(const SyncVar *s) {
+  for (uptr i = 0; i < rep_->mutexes.Size(); i++) {
+    if (rep_->mutexes[i]->id == s->uid)
+      return;
+  }
+  void *mem = internal_alloc(MBlockReportMutex, sizeof(ReportMutex));
+  ReportMutex *rm = new(mem) ReportMutex;
+  rep_->mutexes.PushBack(rm);
+  rm->id = s->uid;
+  rm->addr = s->addr;
+  rm->destroyed = false;
+  rm->stack = SymbolizeStackId(s->creation_stack_id);
+}
+
+u64 ScopedReport::AddMutex(u64 id) {
+  u64 uid = 0;
+  u64 mid = id;
+  uptr addr = SyncVar::SplitId(id, &uid);
+  SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr);
+  // Check that the mutex is still alive.
+  // Another mutex can be created at the same address,
+  // so check uid as well.
+  if (s && s->CheckId(uid)) {
+    mid = s->uid;
+    AddMutex(s);
+  } else {
+    AddDeadMutex(id);
+  }
+  if (s)
+    s->mtx.Unlock();
+  return mid;
+}
+
+void ScopedReport::AddDeadMutex(u64 id) {
+  for (uptr i = 0; i < rep_->mutexes.Size(); i++) {
+    if (rep_->mutexes[i]->id == id)
+      return;
+  }
+  void *mem = internal_alloc(MBlockReportMutex, sizeof(ReportMutex));
+  ReportMutex *rm = new(mem) ReportMutex;
+  rep_->mutexes.PushBack(rm);
+  rm->id = id;
+  rm->addr = 0;
+  rm->destroyed = true;
+  rm->stack = 0;
+}
+
+void ScopedReport::AddLocation(uptr addr, uptr size) {
+  if (addr == 0)
+    return;
+#ifndef SANITIZER_GO
+  int fd = -1;
+  int creat_tid = -1;
+  u32 creat_stack = 0;
+  if (FdLocation(addr, &fd, &creat_tid, &creat_stack)) {
+    ReportLocation *loc = ReportLocation::New(ReportLocationFD);
+    loc->fd = fd;
+    loc->tid = creat_tid;
+    loc->stack = SymbolizeStackId(creat_stack);
+    rep_->locs.PushBack(loc);
+    ThreadContext *tctx = FindThreadByUidLocked(creat_tid);
+    if (tctx)
+      AddThread(tctx);
+    return;
+  }
+  MBlock *b = 0;
+  Allocator *a = allocator();
+  if (a->PointerIsMine((void*)addr)) {
+    void *block_begin = a->GetBlockBegin((void*)addr);
+    if (block_begin)
+      b = ctx->metamap.GetBlock((uptr)block_begin);
+  }
+  if (b != 0) {
+    ThreadContext *tctx = FindThreadByTidLocked(b->tid);
+    ReportLocation *loc = ReportLocation::New(ReportLocationHeap);
+    loc->heap_chunk_start = (uptr)allocator()->GetBlockBegin((void *)addr);
+    loc->heap_chunk_size = b->siz;
+    loc->tid = tctx ? tctx->tid : b->tid;
+    loc->stack = SymbolizeStackId(b->stk);
+    rep_->locs.PushBack(loc);
+    if (tctx)
+      AddThread(tctx);
+    return;
+  }
+  bool is_stack = false;
+  if (ThreadContext *tctx = IsThreadStackOrTls(addr, &is_stack)) {
+    ReportLocation *loc =
+        ReportLocation::New(is_stack ? ReportLocationStack : ReportLocationTLS);
+    loc->tid = tctx->tid;
+    rep_->locs.PushBack(loc);
+    AddThread(tctx);
+  }
+  if (ReportLocation *loc = SymbolizeData(addr)) {
+    loc->suppressable = true;
+    rep_->locs.PushBack(loc);
+    return;
+  }
+#endif
+}
+
+#ifndef SANITIZER_GO
+void ScopedReport::AddSleep(u32 stack_id) {
+  rep_->sleep = SymbolizeStackId(stack_id);
+}
+#endif
+
+void ScopedReport::SetCount(int count) {
+  rep_->count = count;
+}
+
+const ReportDesc *ScopedReport::GetReport() const {
+  return rep_;
+}
+
+void RestoreStack(int tid, const u64 epoch, VarSizeStackTrace *stk,
+                  MutexSet *mset) {
+  // This function restores stack trace and mutex set for the thread/epoch.
+  // It does so by getting stack trace and mutex set at the beginning of
+  // trace part, and then replaying the trace till the given epoch.
+  Trace* trace = ThreadTrace(tid);
+  ReadLock l(&trace->mtx);
+  const int partidx = (epoch / kTracePartSize) % TraceParts();
+  TraceHeader* hdr = &trace->headers[partidx];
+  if (epoch < hdr->epoch0 || epoch >= hdr->epoch0 + kTracePartSize)
+    return;
+  CHECK_EQ(RoundDown(epoch, kTracePartSize), hdr->epoch0);
+  const u64 epoch0 = RoundDown(epoch, TraceSize());
+  const u64 eend = epoch % TraceSize();
+  const u64 ebegin = RoundDown(eend, kTracePartSize);
+  DPrintf("#%d: RestoreStack epoch=%zu ebegin=%zu eend=%zu partidx=%d\n",
+          tid, (uptr)epoch, (uptr)ebegin, (uptr)eend, partidx);
+  Vector<uptr> stack(MBlockReportStack);
+  stack.Resize(hdr->stack0.size + 64);
+  for (uptr i = 0; i < hdr->stack0.size; i++) {
+    stack[i] = hdr->stack0.trace[i];
+    DPrintf2("  #%02zu: pc=%zx\n", i, stack[i]);
+  }
+  if (mset)
+    *mset = hdr->mset0;
+  uptr pos = hdr->stack0.size;
+  Event *events = (Event*)GetThreadTrace(tid);
+  for (uptr i = ebegin; i <= eend; i++) {
+    Event ev = events[i];
+    EventType typ = (EventType)(ev >> 61);
+    uptr pc = (uptr)(ev & ((1ull << 61) - 1));
+    DPrintf2("  %zu typ=%d pc=%zx\n", i, typ, pc);
+    if (typ == EventTypeMop) {
+      stack[pos] = pc;
+    } else if (typ == EventTypeFuncEnter) {
+      if (stack.Size() < pos + 2)
+        stack.Resize(pos + 2);
+      stack[pos++] = pc;
+    } else if (typ == EventTypeFuncExit) {
+      if (pos > 0)
+        pos--;
+    }
+    if (mset) {
+      if (typ == EventTypeLock) {
+        mset->Add(pc, true, epoch0 + i);
+      } else if (typ == EventTypeUnlock) {
+        mset->Del(pc, true);
+      } else if (typ == EventTypeRLock) {
+        mset->Add(pc, false, epoch0 + i);
+      } else if (typ == EventTypeRUnlock) {
+        mset->Del(pc, false);
+      }
+    }
+    for (uptr j = 0; j <= pos; j++)
+      DPrintf2("      #%zu: %zx\n", j, stack[j]);
+  }
+  if (pos == 0 && stack[0] == 0)
+    return;
+  pos++;
+  stk->Init(&stack[0], pos);
+}
+
+static bool HandleRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2],
+                             uptr addr_min, uptr addr_max) {
+  bool equal_stack = false;
+  RacyStacks hash;
+  bool equal_address = false;
+  RacyAddress ra0 = {addr_min, addr_max};
+  {
+    ReadLock lock(&ctx->racy_mtx);
+    if (flags()->suppress_equal_stacks) {
+      hash.hash[0] = md5_hash(traces[0].trace, traces[0].size * sizeof(uptr));
+      hash.hash[1] = md5_hash(traces[1].trace, traces[1].size * sizeof(uptr));
+      for (uptr i = 0; i < ctx->racy_stacks.Size(); i++) {
+        if (hash == ctx->racy_stacks[i]) {
+          VPrintf(2,
+              "ThreadSanitizer: suppressing report as doubled (stack)\n");
+          equal_stack = true;
+          break;
+        }
+      }
+    }
+    if (flags()->suppress_equal_addresses) {
+      for (uptr i = 0; i < ctx->racy_addresses.Size(); i++) {
+        RacyAddress ra2 = ctx->racy_addresses[i];
+        uptr maxbeg = max(ra0.addr_min, ra2.addr_min);
+        uptr minend = min(ra0.addr_max, ra2.addr_max);
+        if (maxbeg < minend) {
+          VPrintf(2, "ThreadSanitizer: suppressing report as doubled (addr)\n");
+          equal_address = true;
+          break;
+        }
+      }
+    }
+  }
+  if (!equal_stack && !equal_address)
+    return false;
+  if (!equal_stack) {
+    Lock lock(&ctx->racy_mtx);
+    ctx->racy_stacks.PushBack(hash);
+  }
+  if (!equal_address) {
+    Lock lock(&ctx->racy_mtx);
+    ctx->racy_addresses.PushBack(ra0);
+  }
+  return true;
+}
+
+static void AddRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2],
+                          uptr addr_min, uptr addr_max) {
+  Lock lock(&ctx->racy_mtx);
+  if (flags()->suppress_equal_stacks) {
+    RacyStacks hash;
+    hash.hash[0] = md5_hash(traces[0].trace, traces[0].size * sizeof(uptr));
+    hash.hash[1] = md5_hash(traces[1].trace, traces[1].size * sizeof(uptr));
+    ctx->racy_stacks.PushBack(hash);
+  }
+  if (flags()->suppress_equal_addresses) {
+    RacyAddress ra0 = {addr_min, addr_max};
+    ctx->racy_addresses.PushBack(ra0);
+  }
+}
+
+bool OutputReport(ThreadState *thr, const ScopedReport &srep) {
+  if (!flags()->report_bugs)
+    return false;
+  atomic_store_relaxed(&ctx->last_symbolize_time_ns, NanoTime());
+  const ReportDesc *rep = srep.GetReport();
+  Suppression *supp = 0;
+  uptr pc_or_addr = 0;
+  for (uptr i = 0; pc_or_addr == 0 && i < rep->mops.Size(); i++)
+    pc_or_addr = IsSuppressed(rep->typ, rep->mops[i]->stack, &supp);
+  for (uptr i = 0; pc_or_addr == 0 && i < rep->stacks.Size(); i++)
+    pc_or_addr = IsSuppressed(rep->typ, rep->stacks[i], &supp);
+  for (uptr i = 0; pc_or_addr == 0 && i < rep->threads.Size(); i++)
+    pc_or_addr = IsSuppressed(rep->typ, rep->threads[i]->stack, &supp);
+  for (uptr i = 0; pc_or_addr == 0 && i < rep->locs.Size(); i++)
+    pc_or_addr = IsSuppressed(rep->typ, rep->locs[i], &supp);
+  if (pc_or_addr != 0) {
+    Lock lock(&ctx->fired_suppressions_mtx);
+    FiredSuppression s = {srep.GetReport()->typ, pc_or_addr, supp};
+    ctx->fired_suppressions.push_back(s);
+  }
+  {
+    bool old_is_freeing = thr->is_freeing;
+    thr->is_freeing = false;
+    bool suppressed = OnReport(rep, pc_or_addr != 0);
+    thr->is_freeing = old_is_freeing;
+    if (suppressed)
+      return false;
+  }
+  PrintReport(rep);
+  ctx->nreported++;
+  if (flags()->halt_on_error)
+    Die();
+  return true;
+}
+
+bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace) {
+  ReadLock lock(&ctx->fired_suppressions_mtx);
+  for (uptr k = 0; k < ctx->fired_suppressions.size(); k++) {
+    if (ctx->fired_suppressions[k].type != type)
+      continue;
+    for (uptr j = 0; j < trace.size; j++) {
+      FiredSuppression *s = &ctx->fired_suppressions[k];
+      if (trace.trace[j] == s->pc_or_addr) {
+        if (s->supp)
+          atomic_fetch_add(&s->supp->hit_count, 1, memory_order_relaxed);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+static bool IsFiredSuppression(Context *ctx, ReportType type, uptr addr) {
+  ReadLock lock(&ctx->fired_suppressions_mtx);
+  for (uptr k = 0; k < ctx->fired_suppressions.size(); k++) {
+    if (ctx->fired_suppressions[k].type != type)
+      continue;
+    FiredSuppression *s = &ctx->fired_suppressions[k];
+    if (addr == s->pc_or_addr) {
+      if (s->supp)
+        atomic_fetch_add(&s->supp->hit_count, 1, memory_order_relaxed);
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool RaceBetweenAtomicAndFree(ThreadState *thr) {
+  Shadow s0(thr->racy_state[0]);
+  Shadow s1(thr->racy_state[1]);
+  CHECK(!(s0.IsAtomic() && s1.IsAtomic()));
+  if (!s0.IsAtomic() && !s1.IsAtomic())
+    return true;
+  if (s0.IsAtomic() && s1.IsFreed())
+    return true;
+  if (s1.IsAtomic() && thr->is_freeing)
+    return true;
+  return false;
+}
+
+void ReportRace(ThreadState *thr) {
+  CheckNoLocks(thr);
+
+  // Symbolizer makes lots of intercepted calls. If we try to process them,
+  // at best it will cause deadlocks on internal mutexes.
+  ScopedIgnoreInterceptors ignore;
+
+  if (!flags()->report_bugs)
+    return;
+  if (!flags()->report_atomic_races && !RaceBetweenAtomicAndFree(thr))
+    return;
+
+  bool freed = false;
+  {
+    Shadow s(thr->racy_state[1]);
+    freed = s.GetFreedAndReset();
+    thr->racy_state[1] = s.raw();
+  }
+
+  uptr addr = ShadowToMem((uptr)thr->racy_shadow_addr);
+  uptr addr_min = 0;
+  uptr addr_max = 0;
+  {
+    uptr a0 = addr + Shadow(thr->racy_state[0]).addr0();
+    uptr a1 = addr + Shadow(thr->racy_state[1]).addr0();
+    uptr e0 = a0 + Shadow(thr->racy_state[0]).size();
+    uptr e1 = a1 + Shadow(thr->racy_state[1]).size();
+    addr_min = min(a0, a1);
+    addr_max = max(e0, e1);
+    if (IsExpectedReport(addr_min, addr_max - addr_min))
+      return;
+  }
+
+  ReportType typ = ReportTypeRace;
+  if (thr->is_vptr_access && freed)
+    typ = ReportTypeVptrUseAfterFree;
+  else if (thr->is_vptr_access)
+    typ = ReportTypeVptrRace;
+  else if (freed)
+    typ = ReportTypeUseAfterFree;
+
+  if (IsFiredSuppression(ctx, typ, addr))
+    return;
+
+  const uptr kMop = 2;
+  VarSizeStackTrace traces[kMop];
+  const uptr toppc = TraceTopPC(thr);
+  ObtainCurrentStack(thr, toppc, &traces[0]);
+  if (IsFiredSuppression(ctx, typ, traces[0]))
+    return;
+
+  // MutexSet is too large to live on stack.
+  Vector<u64> mset_buffer(MBlockScopedBuf);
+  mset_buffer.Resize(sizeof(MutexSet) / sizeof(u64) + 1);
+  MutexSet *mset2 = new(&mset_buffer[0]) MutexSet();
+
+  Shadow s2(thr->racy_state[1]);
+  RestoreStack(s2.tid(), s2.epoch(), &traces[1], mset2);
+  if (IsFiredSuppression(ctx, typ, traces[1]))
+    return;
+
+  if (HandleRacyStacks(thr, traces, addr_min, addr_max))
+    return;
+
+  ThreadRegistryLock l0(ctx->thread_registry);
+  ScopedReport rep(typ);
+  for (uptr i = 0; i < kMop; i++) {
+    Shadow s(thr->racy_state[i]);
+    rep.AddMemoryAccess(addr, s, traces[i], i == 0 ? &thr->mset : mset2);
+  }
+
+  for (uptr i = 0; i < kMop; i++) {
+    FastState s(thr->racy_state[i]);
+    ThreadContext *tctx = static_cast<ThreadContext*>(
+        ctx->thread_registry->GetThreadLocked(s.tid()));
+    if (s.epoch() < tctx->epoch0 || s.epoch() > tctx->epoch1)
+      continue;
+    rep.AddThread(tctx);
+  }
+
+  rep.AddLocation(addr_min, addr_max - addr_min);
+
+#ifndef SANITIZER_GO
+  {  // NOLINT
+    Shadow s(thr->racy_state[1]);
+    if (s.epoch() <= thr->last_sleep_clock.get(s.tid()))
+      rep.AddSleep(thr->last_sleep_stack_id);
+  }
+#endif
+
+  if (!OutputReport(thr, rep))
+    return;
+
+  AddRacyStacks(thr, traces, addr_min, addr_max);
+}
+
+void PrintCurrentStack(ThreadState *thr, uptr pc) {
+  VarSizeStackTrace trace;
+  ObtainCurrentStack(thr, pc, &trace);
+  PrintStack(SymbolizeStack(trace));
+}
+
+void PrintCurrentStackSlow(uptr pc) {
+#ifndef SANITIZER_GO
+  BufferedStackTrace *ptrace =
+      new(internal_alloc(MBlockStackTrace, sizeof(BufferedStackTrace)))
+          BufferedStackTrace();
+  ptrace->Unwind(kStackTraceMax, pc, 0, 0, 0, 0, false);
+  for (uptr i = 0; i < ptrace->size / 2; i++) {
+    uptr tmp = ptrace->trace_buffer[i];
+    ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1];
+    ptrace->trace_buffer[ptrace->size - i - 1] = tmp;
+  }
+  PrintStack(SymbolizeStack(*ptrace));
+#endif
+}
+
+}  // namespace __tsan
+
+using namespace __tsan;
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_print_stack_trace() {
+  PrintCurrentStackSlow(StackTrace::GetCurrentPc());
+}
+}  // extern "C"
diff --git a/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cc b/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cc
new file mode 100644
index 0000000..dcae255
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cc
@@ -0,0 +1,413 @@
+//===-- tsan_rtl_thread.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+#include "tsan_platform.h"
+#include "tsan_report.h"
+#include "tsan_sync.h"
+
+namespace __tsan {
+
+// ThreadContext implementation.
+
+ThreadContext::ThreadContext(int tid)
+  : ThreadContextBase(tid)
+  , thr()
+  , sync()
+  , epoch0()
+  , epoch1() {
+}
+
+#ifndef SANITIZER_GO
+ThreadContext::~ThreadContext() {
+}
+#endif
+
+void ThreadContext::OnDead() {
+  CHECK_EQ(sync.size(), 0);
+}
+
+void ThreadContext::OnJoined(void *arg) {
+  ThreadState *caller_thr = static_cast<ThreadState *>(arg);
+  AcquireImpl(caller_thr, 0, &sync);
+  sync.Reset(&caller_thr->clock_cache);
+}
+
+struct OnCreatedArgs {
+  ThreadState *thr;
+  uptr pc;
+};
+
+void ThreadContext::OnCreated(void *arg) {
+  thr = 0;
+  if (tid == 0)
+    return;
+  OnCreatedArgs *args = static_cast<OnCreatedArgs *>(arg);
+  if (!args->thr)  // GCD workers don't have a parent thread.
+    return;
+  args->thr->fast_state.IncrementEpoch();
+  // Can't increment epoch w/o writing to the trace as well.
+  TraceAddEvent(args->thr, args->thr->fast_state, EventTypeMop, 0);
+  ReleaseImpl(args->thr, 0, &sync);
+  creation_stack_id = CurrentStackId(args->thr, args->pc);
+  if (reuse_count == 0)
+    StatInc(args->thr, StatThreadMaxTid);
+}
+
+void ThreadContext::OnReset() {
+  CHECK_EQ(sync.size(), 0);
+  FlushUnneededShadowMemory(GetThreadTrace(tid), TraceSize() * sizeof(Event));
+  //!!! FlushUnneededShadowMemory(GetThreadTraceHeader(tid), sizeof(Trace));
+}
+
+void ThreadContext::OnDetached(void *arg) {
+  ThreadState *thr1 = static_cast<ThreadState*>(arg);
+  sync.Reset(&thr1->clock_cache);
+}
+
+struct OnStartedArgs {
+  ThreadState *thr;
+  uptr stk_addr;
+  uptr stk_size;
+  uptr tls_addr;
+  uptr tls_size;
+};
+
+void ThreadContext::OnStarted(void *arg) {
+  OnStartedArgs *args = static_cast<OnStartedArgs*>(arg);
+  thr = args->thr;
+  // RoundUp so that one trace part does not contain events
+  // from different threads.
+  epoch0 = RoundUp(epoch1 + 1, kTracePartSize);
+  epoch1 = (u64)-1;
+  new(thr) ThreadState(ctx, tid, unique_id, epoch0, reuse_count,
+      args->stk_addr, args->stk_size, args->tls_addr, args->tls_size);
+#ifndef SANITIZER_GO
+  thr->shadow_stack = &ThreadTrace(thr->tid)->shadow_stack[0];
+  thr->shadow_stack_pos = thr->shadow_stack;
+  thr->shadow_stack_end = thr->shadow_stack + kShadowStackSize;
+#else
+  // Setup dynamic shadow stack.
+  const int kInitStackSize = 8;
+  thr->shadow_stack = (uptr*)internal_alloc(MBlockShadowStack,
+      kInitStackSize * sizeof(uptr));
+  thr->shadow_stack_pos = thr->shadow_stack;
+  thr->shadow_stack_end = thr->shadow_stack + kInitStackSize;
+#endif
+#ifndef SANITIZER_GO
+  AllocatorThreadStart(thr);
+#endif
+  if (common_flags()->detect_deadlocks) {
+    thr->dd_pt = ctx->dd->CreatePhysicalThread();
+    thr->dd_lt = ctx->dd->CreateLogicalThread(unique_id);
+  }
+  thr->fast_state.SetHistorySize(flags()->history_size);
+  // Commit switch to the new part of the trace.
+  // TraceAddEvent will reset stack0/mset0 in the new part for us.
+  TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+
+  thr->fast_synch_epoch = epoch0;
+  AcquireImpl(thr, 0, &sync);
+  StatInc(thr, StatSyncAcquire);
+  sync.Reset(&thr->clock_cache);
+  thr->is_inited = true;
+  DPrintf("#%d: ThreadStart epoch=%zu stk_addr=%zx stk_size=%zx "
+          "tls_addr=%zx tls_size=%zx\n",
+          tid, (uptr)epoch0, args->stk_addr, args->stk_size,
+          args->tls_addr, args->tls_size);
+}
+
+void ThreadContext::OnFinished() {
+  if (!detached) {
+    thr->fast_state.IncrementEpoch();
+    // Can't increment epoch w/o writing to the trace as well.
+    TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
+    ReleaseImpl(thr, 0, &sync);
+  }
+  epoch1 = thr->fast_state.epoch();
+
+  if (common_flags()->detect_deadlocks) {
+    ctx->dd->DestroyPhysicalThread(thr->dd_pt);
+    ctx->dd->DestroyLogicalThread(thr->dd_lt);
+  }
+  ctx->clock_alloc.FlushCache(&thr->clock_cache);
+  ctx->metamap.OnThreadIdle(thr);
+#ifndef SANITIZER_GO
+  AllocatorThreadFinish(thr);
+#endif
+  thr->~ThreadState();
+#if TSAN_COLLECT_STATS
+  StatAggregate(ctx->stat, thr->stat);
+#endif
+  thr = 0;
+}
+
+#ifndef SANITIZER_GO
+struct ThreadLeak {
+  ThreadContext *tctx;
+  int count;
+};
+
+static void MaybeReportThreadLeak(ThreadContextBase *tctx_base, void *arg) {
+  Vector<ThreadLeak> &leaks = *(Vector<ThreadLeak>*)arg;
+  ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base);
+  if (tctx->detached || tctx->status != ThreadStatusFinished)
+    return;
+  for (uptr i = 0; i < leaks.Size(); i++) {
+    if (leaks[i].tctx->creation_stack_id == tctx->creation_stack_id) {
+      leaks[i].count++;
+      return;
+    }
+  }
+  ThreadLeak leak = {tctx, 1};
+  leaks.PushBack(leak);
+}
+#endif
+
+#ifndef SANITIZER_GO
+static void ReportIgnoresEnabled(ThreadContext *tctx, IgnoreSet *set) {
+  if (tctx->tid == 0) {
+    Printf("ThreadSanitizer: main thread finished with ignores enabled\n");
+  } else {
+    Printf("ThreadSanitizer: thread T%d %s finished with ignores enabled,"
+      " created at:\n", tctx->tid, tctx->name);
+    PrintStack(SymbolizeStackId(tctx->creation_stack_id));
+  }
+  Printf("  One of the following ignores was not ended"
+      " (in order of probability)\n");
+  for (uptr i = 0; i < set->Size(); i++) {
+    Printf("  Ignore was enabled at:\n");
+    PrintStack(SymbolizeStackId(set->At(i)));
+  }
+  Die();
+}
+
+static void ThreadCheckIgnore(ThreadState *thr) {
+  if (ctx->after_multithreaded_fork)
+    return;
+  if (thr->ignore_reads_and_writes)
+    ReportIgnoresEnabled(thr->tctx, &thr->mop_ignore_set);
+  if (thr->ignore_sync)
+    ReportIgnoresEnabled(thr->tctx, &thr->sync_ignore_set);
+}
+#else
+static void ThreadCheckIgnore(ThreadState *thr) {}
+#endif
+
+void ThreadFinalize(ThreadState *thr) {
+  ThreadCheckIgnore(thr);
+#ifndef SANITIZER_GO
+  if (!flags()->report_thread_leaks)
+    return;
+  ThreadRegistryLock l(ctx->thread_registry);
+  Vector<ThreadLeak> leaks(MBlockScopedBuf);
+  ctx->thread_registry->RunCallbackForEachThreadLocked(
+      MaybeReportThreadLeak, &leaks);
+  for (uptr i = 0; i < leaks.Size(); i++) {
+    ScopedReport rep(ReportTypeThreadLeak);
+    rep.AddThread(leaks[i].tctx, true);
+    rep.SetCount(leaks[i].count);
+    OutputReport(thr, rep);
+  }
+#endif
+}
+
+int ThreadCount(ThreadState *thr) {
+  uptr result;
+  ctx->thread_registry->GetNumberOfThreads(0, 0, &result);
+  return (int)result;
+}
+
+int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) {
+  StatInc(thr, StatThreadCreate);
+  OnCreatedArgs args = { thr, pc };
+  u32 parent_tid = thr ? thr->tid : kInvalidTid;  // No parent for GCD workers.
+  int tid =
+      ctx->thread_registry->CreateThread(uid, detached, parent_tid, &args);
+  DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", parent_tid, tid, uid);
+  StatSet(thr, StatThreadMaxAlive, ctx->thread_registry->GetMaxAliveThreads());
+  return tid;
+}
+
+void ThreadStart(ThreadState *thr, int tid, uptr os_id) {
+  uptr stk_addr = 0;
+  uptr stk_size = 0;
+  uptr tls_addr = 0;
+  uptr tls_size = 0;
+#ifndef SANITIZER_GO
+  GetThreadStackAndTls(tid == 0, &stk_addr, &stk_size, &tls_addr, &tls_size);
+
+  if (tid) {
+    if (stk_addr && stk_size)
+      MemoryRangeImitateWrite(thr, /*pc=*/ 1, stk_addr, stk_size);
+
+    if (tls_addr && tls_size) {
+      // Check that the thr object is in tls;
+      const uptr thr_beg = (uptr)thr;
+      const uptr thr_end = (uptr)thr + sizeof(*thr);
+      CHECK_GE(thr_beg, tls_addr);
+      CHECK_LE(thr_beg, tls_addr + tls_size);
+      CHECK_GE(thr_end, tls_addr);
+      CHECK_LE(thr_end, tls_addr + tls_size);
+      // Since the thr object is huge, skip it.
+      MemoryRangeImitateWrite(thr, /*pc=*/ 2, tls_addr, thr_beg - tls_addr);
+      MemoryRangeImitateWrite(thr, /*pc=*/ 2,
+          thr_end, tls_addr + tls_size - thr_end);
+    }
+  }
+#endif
+
+  ThreadRegistry *tr = ctx->thread_registry;
+  OnStartedArgs args = { thr, stk_addr, stk_size, tls_addr, tls_size };
+  tr->StartThread(tid, os_id, &args);
+
+  tr->Lock();
+  thr->tctx = (ThreadContext*)tr->GetThreadLocked(tid);
+  tr->Unlock();
+
+#ifndef SANITIZER_GO
+  if (ctx->after_multithreaded_fork) {
+    thr->ignore_interceptors++;
+    ThreadIgnoreBegin(thr, 0);
+    ThreadIgnoreSyncBegin(thr, 0);
+  }
+#endif
+}
+
+void ThreadFinish(ThreadState *thr) {
+  ThreadCheckIgnore(thr);
+  StatInc(thr, StatThreadFinish);
+  if (thr->stk_addr && thr->stk_size)
+    DontNeedShadowFor(thr->stk_addr, thr->stk_size);
+  if (thr->tls_addr && thr->tls_size)
+    DontNeedShadowFor(thr->tls_addr, thr->tls_size);
+  thr->is_dead = true;
+  ctx->thread_registry->FinishThread(thr->tid);
+}
+
+static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) {
+  uptr uid = (uptr)arg;
+  if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) {
+    tctx->user_id = 0;
+    return true;
+  }
+  return false;
+}
+
+int ThreadTid(ThreadState *thr, uptr pc, uptr uid) {
+  int res = ctx->thread_registry->FindThread(FindThreadByUid, (void*)uid);
+  DPrintf("#%d: ThreadTid uid=%zu tid=%d\n", thr->tid, uid, res);
+  return res;
+}
+
+void ThreadJoin(ThreadState *thr, uptr pc, int tid) {
+  CHECK_GT(tid, 0);
+  CHECK_LT(tid, kMaxTid);
+  DPrintf("#%d: ThreadJoin tid=%d\n", thr->tid, tid);
+  ctx->thread_registry->JoinThread(tid, thr);
+}
+
+void ThreadDetach(ThreadState *thr, uptr pc, int tid) {
+  CHECK_GT(tid, 0);
+  CHECK_LT(tid, kMaxTid);
+  ctx->thread_registry->DetachThread(tid, thr);
+}
+
+void ThreadSetName(ThreadState *thr, const char *name) {
+  ctx->thread_registry->SetThreadName(thr->tid, name);
+}
+
+void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr,
+                       uptr size, bool is_write) {
+  if (size == 0)
+    return;
+
+  u64 *shadow_mem = (u64*)MemToShadow(addr);
+  DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_write=%d\n",
+      thr->tid, (void*)pc, (void*)addr,
+      (int)size, is_write);
+
+#if SANITIZER_DEBUG
+  if (!IsAppMem(addr)) {
+    Printf("Access to non app mem %zx\n", addr);
+    DCHECK(IsAppMem(addr));
+  }
+  if (!IsAppMem(addr + size - 1)) {
+    Printf("Access to non app mem %zx\n", addr + size - 1);
+    DCHECK(IsAppMem(addr + size - 1));
+  }
+  if (!IsShadowMem((uptr)shadow_mem)) {
+    Printf("Bad shadow addr %p (%zx)\n", shadow_mem, addr);
+    DCHECK(IsShadowMem((uptr)shadow_mem));
+  }
+  if (!IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1))) {
+    Printf("Bad shadow addr %p (%zx)\n",
+               shadow_mem + size * kShadowCnt / 8 - 1, addr + size - 1);
+    DCHECK(IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1)));
+  }
+#endif
+
+  StatInc(thr, StatMopRange);
+
+  if (*shadow_mem == kShadowRodata) {
+    // Access to .rodata section, no races here.
+    // Measurements show that it can be 10-20% of all memory accesses.
+    StatInc(thr, StatMopRangeRodata);
+    return;
+  }
+
+  FastState fast_state = thr->fast_state;
+  if (fast_state.GetIgnoreBit())
+    return;
+
+  fast_state.IncrementEpoch();
+  thr->fast_state = fast_state;
+  TraceAddEvent(thr, fast_state, EventTypeMop, pc);
+
+  bool unaligned = (addr % kShadowCell) != 0;
+
+  // Handle unaligned beginning, if any.
+  for (; addr % kShadowCell && size; addr++, size--) {
+    int const kAccessSizeLog = 0;
+    Shadow cur(fast_state);
+    cur.SetWrite(is_write);
+    cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog);
+    MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false,
+        shadow_mem, cur);
+  }
+  if (unaligned)
+    shadow_mem += kShadowCnt;
+  // Handle middle part, if any.
+  for (; size >= kShadowCell; addr += kShadowCell, size -= kShadowCell) {
+    int const kAccessSizeLog = 3;
+    Shadow cur(fast_state);
+    cur.SetWrite(is_write);
+    cur.SetAddr0AndSizeLog(0, kAccessSizeLog);
+    MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false,
+        shadow_mem, cur);
+    shadow_mem += kShadowCnt;
+  }
+  // Handle ending, if any.
+  for (; size; addr++, size--) {
+    int const kAccessSizeLog = 0;
+    Shadow cur(fast_state);
+    cur.SetWrite(is_write);
+    cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog);
+    MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false,
+        shadow_mem, cur);
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_stack_trace.cc b/compiler-rt/lib/tsan/rtl/tsan_stack_trace.cc
new file mode 100644
index 0000000..ceca3f8
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_stack_trace.cc
@@ -0,0 +1,46 @@
+//===-- tsan_stack_trace.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_stack_trace.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+
+namespace __tsan {
+
+VarSizeStackTrace::VarSizeStackTrace()
+    : StackTrace(nullptr, 0), trace_buffer(nullptr) {}
+
+VarSizeStackTrace::~VarSizeStackTrace() {
+  ResizeBuffer(0);
+}
+
+void VarSizeStackTrace::ResizeBuffer(uptr new_size) {
+  if (trace_buffer) {
+    internal_free(trace_buffer);
+  }
+  trace_buffer =
+      (new_size > 0)
+          ? (uptr *)internal_alloc(MBlockStackTrace,
+                                   new_size * sizeof(trace_buffer[0]))
+          : nullptr;
+  trace = trace_buffer;
+  size = new_size;
+}
+
+void VarSizeStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
+  ResizeBuffer(cnt + !!extra_top_pc);
+  internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
+  if (extra_top_pc)
+    trace_buffer[cnt] = extra_top_pc;
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_stack_trace.h b/compiler-rt/lib/tsan/rtl/tsan_stack_trace.h
new file mode 100644
index 0000000..5bf89bb
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_stack_trace.h
@@ -0,0 +1,39 @@
+//===-- tsan_stack_trace.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_STACK_TRACE_H
+#define TSAN_STACK_TRACE_H
+
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "tsan_defs.h"
+
+namespace __tsan {
+
+// StackTrace which calls malloc/free to allocate the buffer for
+// addresses in stack traces.
+struct VarSizeStackTrace : public StackTrace {
+  uptr *trace_buffer;  // Owned.
+
+  VarSizeStackTrace();
+  ~VarSizeStackTrace();
+  void Init(const uptr *pcs, uptr cnt, uptr extra_top_pc = 0);
+
+ private:
+  void ResizeBuffer(uptr new_size);
+
+  VarSizeStackTrace(const VarSizeStackTrace &);
+  void operator=(const VarSizeStackTrace &);
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_STACK_TRACE_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_stat.cc b/compiler-rt/lib/tsan/rtl/tsan_stat.cc
new file mode 100644
index 0000000..a5cca96
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_stat.cc
@@ -0,0 +1,179 @@
+//===-- tsan_stat.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_stat.h"
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+#if TSAN_COLLECT_STATS
+
+void StatAggregate(u64 *dst, u64 *src) {
+  for (int i = 0; i < StatCnt; i++)
+    dst[i] += src[i];
+}
+
+void StatOutput(u64 *stat) {
+  stat[StatShadowNonZero] = stat[StatShadowProcessed] - stat[StatShadowZero];
+
+  static const char *name[StatCnt] = {};
+  name[StatMop]                          = "Memory accesses                   ";
+  name[StatMopRead]                      = "  Including reads                 ";
+  name[StatMopWrite]                     = "            writes                ";
+  name[StatMop1]                         = "  Including size 1                ";
+  name[StatMop2]                         = "            size 2                ";
+  name[StatMop4]                         = "            size 4                ";
+  name[StatMop8]                         = "            size 8                ";
+  name[StatMopSame]                      = "  Including same                  ";
+  name[StatMopIgnored]                   = "  Including ignored               ";
+  name[StatMopRange]                     = "  Including range                 ";
+  name[StatMopRodata]                    = "  Including .rodata               ";
+  name[StatMopRangeRodata]               = "  Including .rodata range         ";
+  name[StatShadowProcessed]              = "Shadow processed                  ";
+  name[StatShadowZero]                   = "  Including empty                 ";
+  name[StatShadowNonZero]                = "  Including non empty             ";
+  name[StatShadowSameSize]               = "  Including same size             ";
+  name[StatShadowIntersect]              = "            intersect             ";
+  name[StatShadowNotIntersect]           = "            not intersect         ";
+  name[StatShadowSameThread]             = "  Including same thread           ";
+  name[StatShadowAnotherThread]          = "            another thread        ";
+  name[StatShadowReplace]                = "  Including evicted               ";
+
+  name[StatFuncEnter]                    = "Function entries                  ";
+  name[StatFuncExit]                     = "Function exits                    ";
+  name[StatEvents]                       = "Events collected                  ";
+
+  name[StatThreadCreate]                 = "Total threads created             ";
+  name[StatThreadFinish]                 = "  threads finished                ";
+  name[StatThreadReuse]                  = "  threads reused                  ";
+  name[StatThreadMaxTid]                 = "  max tid                         ";
+  name[StatThreadMaxAlive]               = "  max alive threads               ";
+
+  name[StatMutexCreate]                  = "Mutexes created                   ";
+  name[StatMutexDestroy]                 = "  destroyed                       ";
+  name[StatMutexLock]                    = "  lock                            ";
+  name[StatMutexUnlock]                  = "  unlock                          ";
+  name[StatMutexRecLock]                 = "  recursive lock                  ";
+  name[StatMutexRecUnlock]               = "  recursive unlock                ";
+  name[StatMutexReadLock]                = "  read lock                       ";
+  name[StatMutexReadUnlock]              = "  read unlock                     ";
+
+  name[StatSyncCreated]                  = "Sync objects created              ";
+  name[StatSyncDestroyed]                = "             destroyed            ";
+  name[StatSyncAcquire]                  = "             acquired             ";
+  name[StatSyncRelease]                  = "             released             ";
+
+  name[StatClockAcquire]                 = "Clock acquire                     ";
+  name[StatClockAcquireEmpty]            = "  empty clock                     ";
+  name[StatClockAcquireFastRelease]      = "  fast from release-store         ";
+  name[StatClockAcquireLarge]            = "  contains my tid                 ";
+  name[StatClockAcquireRepeat]           = "  repeated (fast)                 ";
+  name[StatClockAcquireFull]             = "  full (slow)                     ";
+  name[StatClockAcquiredSomething]       = "  acquired something              ";
+  name[StatClockRelease]                 = "Clock release                     ";
+  name[StatClockReleaseResize]           = "  resize                          ";
+  name[StatClockReleaseFast1]            = "  fast1                           ";
+  name[StatClockReleaseFast2]            = "  fast2                           ";
+  name[StatClockReleaseSlow]             = "  dirty overflow (slow)           ";
+  name[StatClockReleaseFull]             = "  full (slow)                     ";
+  name[StatClockReleaseAcquired]         = "  was acquired                    ";
+  name[StatClockReleaseClearTail]        = "  clear tail                      ";
+  name[StatClockStore]                   = "Clock release store               ";
+  name[StatClockStoreResize]             = "  resize                          ";
+  name[StatClockStoreFast]               = "  fast                            ";
+  name[StatClockStoreFull]               = "  slow                            ";
+  name[StatClockStoreTail]               = "  clear tail                      ";
+  name[StatClockAcquireRelease]          = "Clock acquire-release             ";
+
+  name[StatAtomic]                       = "Atomic operations                 ";
+  name[StatAtomicLoad]                   = "  Including load                  ";
+  name[StatAtomicStore]                  = "            store                 ";
+  name[StatAtomicExchange]               = "            exchange              ";
+  name[StatAtomicFetchAdd]               = "            fetch_add             ";
+  name[StatAtomicFetchSub]               = "            fetch_sub             ";
+  name[StatAtomicFetchAnd]               = "            fetch_and             ";
+  name[StatAtomicFetchOr]                = "            fetch_or              ";
+  name[StatAtomicFetchXor]               = "            fetch_xor             ";
+  name[StatAtomicFetchNand]              = "            fetch_nand            ";
+  name[StatAtomicCAS]                    = "            compare_exchange      ";
+  name[StatAtomicFence]                  = "            fence                 ";
+  name[StatAtomicRelaxed]                = "  Including relaxed               ";
+  name[StatAtomicConsume]                = "            consume               ";
+  name[StatAtomicAcquire]                = "            acquire               ";
+  name[StatAtomicRelease]                = "            release               ";
+  name[StatAtomicAcq_Rel]                = "            acq_rel               ";
+  name[StatAtomicSeq_Cst]                = "            seq_cst               ";
+  name[StatAtomic1]                      = "  Including size 1                ";
+  name[StatAtomic2]                      = "            size 2                ";
+  name[StatAtomic4]                      = "            size 4                ";
+  name[StatAtomic8]                      = "            size 8                ";
+  name[StatAtomic16]                     = "            size 16               ";
+
+  name[StatAnnotation]                   = "Dynamic annotations               ";
+  name[StatAnnotateHappensBefore]        = "  HappensBefore                   ";
+  name[StatAnnotateHappensAfter]         = "  HappensAfter                    ";
+  name[StatAnnotateCondVarSignal]        = "  CondVarSignal                   ";
+  name[StatAnnotateCondVarSignalAll]     = "  CondVarSignalAll                ";
+  name[StatAnnotateMutexIsNotPHB]        = "  MutexIsNotPHB                   ";
+  name[StatAnnotateCondVarWait]          = "  CondVarWait                     ";
+  name[StatAnnotateRWLockCreate]         = "  RWLockCreate                    ";
+  name[StatAnnotateRWLockCreateStatic]   = "  StatAnnotateRWLockCreateStatic  ";
+  name[StatAnnotateRWLockDestroy]        = "  RWLockDestroy                   ";
+  name[StatAnnotateRWLockAcquired]       = "  RWLockAcquired                  ";
+  name[StatAnnotateRWLockReleased]       = "  RWLockReleased                  ";
+  name[StatAnnotateTraceMemory]          = "  TraceMemory                     ";
+  name[StatAnnotateFlushState]           = "  FlushState                      ";
+  name[StatAnnotateNewMemory]            = "  NewMemory                       ";
+  name[StatAnnotateNoOp]                 = "  NoOp                            ";
+  name[StatAnnotateFlushExpectedRaces]   = "  FlushExpectedRaces              ";
+  name[StatAnnotateEnableRaceDetection]  = "  EnableRaceDetection             ";
+  name[StatAnnotateMutexIsUsedAsCondVar] = "  MutexIsUsedAsCondVar            ";
+  name[StatAnnotatePCQGet]               = "  PCQGet                          ";
+  name[StatAnnotatePCQPut]               = "  PCQPut                          ";
+  name[StatAnnotatePCQDestroy]           = "  PCQDestroy                      ";
+  name[StatAnnotatePCQCreate]            = "  PCQCreate                       ";
+  name[StatAnnotateExpectRace]           = "  ExpectRace                      ";
+  name[StatAnnotateBenignRaceSized]      = "  BenignRaceSized                 ";
+  name[StatAnnotateBenignRace]           = "  BenignRace                      ";
+  name[StatAnnotateIgnoreReadsBegin]     = "  IgnoreReadsBegin                ";
+  name[StatAnnotateIgnoreReadsEnd]       = "  IgnoreReadsEnd                  ";
+  name[StatAnnotateIgnoreWritesBegin]    = "  IgnoreWritesBegin               ";
+  name[StatAnnotateIgnoreWritesEnd]      = "  IgnoreWritesEnd                 ";
+  name[StatAnnotateIgnoreSyncBegin]      = "  IgnoreSyncBegin                 ";
+  name[StatAnnotateIgnoreSyncEnd]        = "  IgnoreSyncEnd                   ";
+  name[StatAnnotatePublishMemoryRange]   = "  PublishMemoryRange              ";
+  name[StatAnnotateUnpublishMemoryRange] = "  UnpublishMemoryRange            ";
+  name[StatAnnotateThreadName]           = "  ThreadName                      ";
+
+  name[StatMtxTotal]                     = "Contentionz                       ";
+  name[StatMtxTrace]                     = "  Trace                           ";
+  name[StatMtxThreads]                   = "  Threads                         ";
+  name[StatMtxReport]                    = "  Report                          ";
+  name[StatMtxSyncVar]                   = "  SyncVar                         ";
+  name[StatMtxSyncTab]                   = "  SyncTab                         ";
+  name[StatMtxSlab]                      = "  Slab                            ";
+  name[StatMtxAtExit]                    = "  Atexit                          ";
+  name[StatMtxAnnotations]               = "  Annotations                     ";
+  name[StatMtxMBlock]                    = "  MBlock                          ";
+  name[StatMtxDeadlockDetector]          = "  DeadlockDetector                ";
+  name[StatMtxFired]                     = "  FiredSuppressions               ";
+  name[StatMtxRacy]                      = "  RacyStacks                      ";
+  name[StatMtxFD]                        = "  FD                              ";
+
+  Printf("Statistics:\n");
+  for (int i = 0; i < StatCnt; i++)
+    Printf("%s: %16zu\n", name[i], (uptr)stat[i]);
+}
+
+#endif
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_stat.h b/compiler-rt/lib/tsan/rtl/tsan_stat.h
new file mode 100644
index 0000000..8ea3204
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_stat.h
@@ -0,0 +1,183 @@
+//===-- tsan_stat.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAN_STAT_H
+#define TSAN_STAT_H
+
+namespace __tsan {
+
+enum StatType {
+  // Memory access processing related stuff.
+  StatMop,
+  StatMopRead,
+  StatMopWrite,
+  StatMop1,  // These must be consequtive.
+  StatMop2,
+  StatMop4,
+  StatMop8,
+  StatMopSame,
+  StatMopIgnored,
+  StatMopRange,
+  StatMopRodata,
+  StatMopRangeRodata,
+  StatShadowProcessed,
+  StatShadowZero,
+  StatShadowNonZero,  // Derived.
+  StatShadowSameSize,
+  StatShadowIntersect,
+  StatShadowNotIntersect,
+  StatShadowSameThread,
+  StatShadowAnotherThread,
+  StatShadowReplace,
+
+  // Func processing.
+  StatFuncEnter,
+  StatFuncExit,
+
+  // Trace processing.
+  StatEvents,
+
+  // Threads.
+  StatThreadCreate,
+  StatThreadFinish,
+  StatThreadReuse,
+  StatThreadMaxTid,
+  StatThreadMaxAlive,
+
+  // Mutexes.
+  StatMutexCreate,
+  StatMutexDestroy,
+  StatMutexLock,
+  StatMutexUnlock,
+  StatMutexRecLock,
+  StatMutexRecUnlock,
+  StatMutexReadLock,
+  StatMutexReadUnlock,
+
+  // Synchronization.
+  StatSyncCreated,
+  StatSyncDestroyed,
+  StatSyncAcquire,
+  StatSyncRelease,
+
+  // Clocks - acquire.
+  StatClockAcquire,
+  StatClockAcquireEmpty,
+  StatClockAcquireFastRelease,
+  StatClockAcquireLarge,
+  StatClockAcquireRepeat,
+  StatClockAcquireFull,
+  StatClockAcquiredSomething,
+  // Clocks - release.
+  StatClockRelease,
+  StatClockReleaseResize,
+  StatClockReleaseFast1,
+  StatClockReleaseFast2,
+  StatClockReleaseSlow,
+  StatClockReleaseFull,
+  StatClockReleaseAcquired,
+  StatClockReleaseClearTail,
+  // Clocks - release store.
+  StatClockStore,
+  StatClockStoreResize,
+  StatClockStoreFast,
+  StatClockStoreFull,
+  StatClockStoreTail,
+  // Clocks - acquire-release.
+  StatClockAcquireRelease,
+
+  // Atomics.
+  StatAtomic,
+  StatAtomicLoad,
+  StatAtomicStore,
+  StatAtomicExchange,
+  StatAtomicFetchAdd,
+  StatAtomicFetchSub,
+  StatAtomicFetchAnd,
+  StatAtomicFetchOr,
+  StatAtomicFetchXor,
+  StatAtomicFetchNand,
+  StatAtomicCAS,
+  StatAtomicFence,
+  StatAtomicRelaxed,
+  StatAtomicConsume,
+  StatAtomicAcquire,
+  StatAtomicRelease,
+  StatAtomicAcq_Rel,
+  StatAtomicSeq_Cst,
+  StatAtomic1,
+  StatAtomic2,
+  StatAtomic4,
+  StatAtomic8,
+  StatAtomic16,
+
+  // Dynamic annotations.
+  StatAnnotation,
+  StatAnnotateHappensBefore,
+  StatAnnotateHappensAfter,
+  StatAnnotateCondVarSignal,
+  StatAnnotateCondVarSignalAll,
+  StatAnnotateMutexIsNotPHB,
+  StatAnnotateCondVarWait,
+  StatAnnotateRWLockCreate,
+  StatAnnotateRWLockCreateStatic,
+  StatAnnotateRWLockDestroy,
+  StatAnnotateRWLockAcquired,
+  StatAnnotateRWLockReleased,
+  StatAnnotateTraceMemory,
+  StatAnnotateFlushState,
+  StatAnnotateNewMemory,
+  StatAnnotateNoOp,
+  StatAnnotateFlushExpectedRaces,
+  StatAnnotateEnableRaceDetection,
+  StatAnnotateMutexIsUsedAsCondVar,
+  StatAnnotatePCQGet,
+  StatAnnotatePCQPut,
+  StatAnnotatePCQDestroy,
+  StatAnnotatePCQCreate,
+  StatAnnotateExpectRace,
+  StatAnnotateBenignRaceSized,
+  StatAnnotateBenignRace,
+  StatAnnotateIgnoreReadsBegin,
+  StatAnnotateIgnoreReadsEnd,
+  StatAnnotateIgnoreWritesBegin,
+  StatAnnotateIgnoreWritesEnd,
+  StatAnnotateIgnoreSyncBegin,
+  StatAnnotateIgnoreSyncEnd,
+  StatAnnotatePublishMemoryRange,
+  StatAnnotateUnpublishMemoryRange,
+  StatAnnotateThreadName,
+
+  // Internal mutex contentionz.
+  StatMtxTotal,
+  StatMtxTrace,
+  StatMtxThreads,
+  StatMtxReport,
+  StatMtxSyncVar,
+  StatMtxSyncTab,
+  StatMtxSlab,
+  StatMtxAnnotations,
+  StatMtxAtExit,
+  StatMtxMBlock,
+  StatMtxDeadlockDetector,
+  StatMtxFired,
+  StatMtxRacy,
+  StatMtxFD,
+
+  // This must be the last.
+  StatCnt
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_STAT_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_suppressions.cc b/compiler-rt/lib/tsan/rtl/tsan_suppressions.cc
new file mode 100644
index 0000000..8754b61
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_suppressions.cc
@@ -0,0 +1,166 @@
+//===-- tsan_suppressions.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "tsan_suppressions.h"
+#include "tsan_rtl.h"
+#include "tsan_flags.h"
+#include "tsan_mman.h"
+#include "tsan_platform.h"
+
+#ifndef SANITIZER_GO
+// Suppressions for true/false positives in standard libraries.
+static const char *const std_suppressions =
+// Libstdc++ 4.4 has data races in std::string.
+// See http://crbug.com/181502 for an example.
+"race:^_M_rep$\n"
+"race:^_M_is_leaked$\n"
+// False positive when using std <thread>.
+// Happens because we miss atomic synchronization in libstdc++.
+// See http://llvm.org/bugs/show_bug.cgi?id=17066 for details.
+"race:std::_Sp_counted_ptr_inplace<std::thread::_Impl\n";
+
+// Can be overriden in frontend.
+SANITIZER_WEAK_DEFAULT_IMPL
+const char *__tsan_default_suppressions() {
+  return 0;
+}
+#endif
+
+namespace __tsan {
+
+ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
+static SuppressionContext *suppression_ctx = nullptr;
+static const char *kSuppressionTypes[] = {
+    kSuppressionRace,   kSuppressionRaceTop, kSuppressionMutex,
+    kSuppressionThread, kSuppressionSignal, kSuppressionLib,
+    kSuppressionDeadlock};
+
+void InitializeSuppressions() {
+  CHECK_EQ(nullptr, suppression_ctx);
+  suppression_ctx = new (suppression_placeholder) // NOLINT
+      SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
+  suppression_ctx->ParseFromFile(flags()->suppressions);
+#ifndef SANITIZER_GO
+  suppression_ctx->Parse(__tsan_default_suppressions());
+  suppression_ctx->Parse(std_suppressions);
+#endif
+}
+
+SuppressionContext *Suppressions() {
+  CHECK(suppression_ctx);
+  return suppression_ctx;
+}
+
+static const char *conv(ReportType typ) {
+  if (typ == ReportTypeRace)
+    return kSuppressionRace;
+  else if (typ == ReportTypeVptrRace)
+    return kSuppressionRace;
+  else if (typ == ReportTypeUseAfterFree)
+    return kSuppressionRace;
+  else if (typ == ReportTypeVptrUseAfterFree)
+    return kSuppressionRace;
+  else if (typ == ReportTypeThreadLeak)
+    return kSuppressionThread;
+  else if (typ == ReportTypeMutexDestroyLocked)
+    return kSuppressionMutex;
+  else if (typ == ReportTypeMutexDoubleLock)
+    return kSuppressionMutex;
+  else if (typ == ReportTypeMutexBadUnlock)
+    return kSuppressionMutex;
+  else if (typ == ReportTypeMutexBadReadLock)
+    return kSuppressionMutex;
+  else if (typ == ReportTypeMutexBadReadUnlock)
+    return kSuppressionMutex;
+  else if (typ == ReportTypeSignalUnsafe)
+    return kSuppressionSignal;
+  else if (typ == ReportTypeErrnoInSignal)
+    return kSuppressionNone;
+  else if (typ == ReportTypeDeadlock)
+    return kSuppressionDeadlock;
+  Printf("ThreadSanitizer: unknown report type %d\n", typ),
+  Die();
+}
+
+static uptr IsSuppressed(const char *stype, const AddressInfo &info,
+    Suppression **sp) {
+  if (suppression_ctx->Match(info.function, stype, sp) ||
+      suppression_ctx->Match(info.file, stype, sp) ||
+      suppression_ctx->Match(info.module, stype, sp)) {
+    VPrintf(2, "ThreadSanitizer: matched suppression '%s'\n", (*sp)->templ);
+    atomic_fetch_add(&(*sp)->hit_count, 1, memory_order_relaxed);
+    return info.address;
+  }
+  return 0;
+}
+
+uptr IsSuppressed(ReportType typ, const ReportStack *stack, Suppression **sp) {
+  CHECK(suppression_ctx);
+  if (!suppression_ctx->SuppressionCount() || stack == 0 ||
+      !stack->suppressable)
+    return 0;
+  const char *stype = conv(typ);
+  if (0 == internal_strcmp(stype, kSuppressionNone))
+    return 0;
+  for (const SymbolizedStack *frame = stack->frames; frame;
+      frame = frame->next) {
+    uptr pc = IsSuppressed(stype, frame->info, sp);
+    if (pc != 0)
+      return pc;
+  }
+  if (0 == internal_strcmp(stype, kSuppressionRace) && stack->frames != nullptr)
+    return IsSuppressed(kSuppressionRaceTop, stack->frames->info, sp);
+  return 0;
+}
+
+uptr IsSuppressed(ReportType typ, const ReportLocation *loc, Suppression **sp) {
+  CHECK(suppression_ctx);
+  if (!suppression_ctx->SuppressionCount() || loc == 0 ||
+      loc->type != ReportLocationGlobal || !loc->suppressable)
+    return 0;
+  const char *stype = conv(typ);
+  if (0 == internal_strcmp(stype, kSuppressionNone))
+    return 0;
+  Suppression *s;
+  const DataInfo &global = loc->global;
+  if (suppression_ctx->Match(global.name, stype, &s) ||
+      suppression_ctx->Match(global.module, stype, &s)) {
+      VPrintf(2, "ThreadSanitizer: matched suppression '%s'\n", s->templ);
+      atomic_fetch_add(&s->hit_count, 1, memory_order_relaxed);
+      *sp = s;
+      return global.start;
+  }
+  return 0;
+}
+
+void PrintMatchedSuppressions() {
+  InternalMmapVector<Suppression *> matched(1);
+  CHECK(suppression_ctx);
+  suppression_ctx->GetMatched(&matched);
+  if (!matched.size())
+    return;
+  int hit_count = 0;
+  for (uptr i = 0; i < matched.size(); i++)
+    hit_count += atomic_load_relaxed(&matched[i]->hit_count);
+  Printf("ThreadSanitizer: Matched %d suppressions (pid=%d):\n", hit_count,
+         (int)internal_getpid());
+  for (uptr i = 0; i < matched.size(); i++) {
+    Printf("%d %s:%s\n", matched[i]->hit_count, matched[i]->type,
+           matched[i]->templ);
+  }
+}
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_suppressions.h b/compiler-rt/lib/tsan/rtl/tsan_suppressions.h
new file mode 100644
index 0000000..526952d
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_suppressions.h
@@ -0,0 +1,38 @@
+//===-- tsan_suppressions.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_SUPPRESSIONS_H
+#define TSAN_SUPPRESSIONS_H
+
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "tsan_report.h"
+
+namespace __tsan {
+
+const char kSuppressionNone[] = "none";
+const char kSuppressionRace[] = "race";
+const char kSuppressionRaceTop[] = "race_top";
+const char kSuppressionMutex[] = "mutex";
+const char kSuppressionThread[] = "thread";
+const char kSuppressionSignal[] = "signal";
+const char kSuppressionLib[] = "called_from_lib";
+const char kSuppressionDeadlock[] = "deadlock";
+
+void InitializeSuppressions();
+SuppressionContext *Suppressions();
+void PrintMatchedSuppressions();
+uptr IsSuppressed(ReportType typ, const ReportStack *stack, Suppression **sp);
+uptr IsSuppressed(ReportType typ, const ReportLocation *loc, Suppression **sp);
+
+}  // namespace __tsan
+
+#endif  // TSAN_SUPPRESSIONS_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_symbolize.cc b/compiler-rt/lib/tsan/rtl/tsan_symbolize.cc
new file mode 100644
index 0000000..b242395
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_symbolize.cc
@@ -0,0 +1,82 @@
+//===-- tsan_symbolize.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "tsan_symbolize.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+#include "tsan_flags.h"
+#include "tsan_report.h"
+#include "tsan_rtl.h"
+
+namespace __tsan {
+
+void EnterSymbolizer() {
+  ThreadState *thr = cur_thread();
+  CHECK(!thr->in_symbolizer);
+  thr->in_symbolizer = true;
+  thr->ignore_interceptors++;
+}
+
+void ExitSymbolizer() {
+  ThreadState *thr = cur_thread();
+  CHECK(thr->in_symbolizer);
+  thr->in_symbolizer = false;
+  thr->ignore_interceptors--;
+}
+
+// May be overriden by JIT/JAVA/etc,
+// whatever produces PCs marked with kExternalPCBit.
+SANITIZER_WEAK_DEFAULT_IMPL
+bool __tsan_symbolize_external(uptr pc, char *func_buf, uptr func_siz,
+                               char *file_buf, uptr file_siz, int *line,
+                               int *col) {
+  return false;
+}
+
+SymbolizedStack *SymbolizeCode(uptr addr) {
+  // Check if PC comes from non-native land.
+  if (addr & kExternalPCBit) {
+    // Declare static to not consume too much stack space.
+    // We symbolize reports in a single thread, so this is fine.
+    static char func_buf[1024];
+    static char file_buf[1024];
+    int line, col;
+    SymbolizedStack *frame = SymbolizedStack::New(addr);
+    if (__tsan_symbolize_external(addr, func_buf, sizeof(func_buf), file_buf,
+                                  sizeof(file_buf), &line, &col)) {
+      frame->info.function = internal_strdup(func_buf);
+      frame->info.file = internal_strdup(file_buf);
+      frame->info.line = line;
+      frame->info.column = col;
+    }
+    return frame;
+  }
+  return Symbolizer::GetOrInit()->SymbolizePC(addr);
+}
+
+ReportLocation *SymbolizeData(uptr addr) {
+  DataInfo info;
+  if (!Symbolizer::GetOrInit()->SymbolizeData(addr, &info))
+    return 0;
+  ReportLocation *ent = ReportLocation::New(ReportLocationGlobal);
+  internal_memcpy(&ent->global, &info, sizeof(info));
+  return ent;
+}
+
+void SymbolizeFlush() {
+  Symbolizer::GetOrInit()->Flush();
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_symbolize.h b/compiler-rt/lib/tsan/rtl/tsan_symbolize.h
new file mode 100644
index 0000000..5a9710a
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_symbolize.h
@@ -0,0 +1,31 @@
+//===-- tsan_symbolize.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_SYMBOLIZE_H
+#define TSAN_SYMBOLIZE_H
+
+#include "tsan_defs.h"
+#include "tsan_report.h"
+
+namespace __tsan {
+
+void EnterSymbolizer();
+void ExitSymbolizer();
+SymbolizedStack *SymbolizeCode(uptr addr);
+ReportLocation *SymbolizeData(uptr addr);
+void SymbolizeFlush();
+
+ReportStack *NewReportStackEntry(uptr addr);
+
+}  // namespace __tsan
+
+#endif  // TSAN_SYMBOLIZE_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_sync.cc b/compiler-rt/lib/tsan/rtl/tsan_sync.cc
new file mode 100644
index 0000000..4202d30
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_sync.cc
@@ -0,0 +1,287 @@
+//===-- tsan_sync.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "tsan_sync.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+
+namespace __tsan {
+
+void DDMutexInit(ThreadState *thr, uptr pc, SyncVar *s);
+
+SyncVar::SyncVar()
+    : mtx(MutexTypeSyncVar, StatMtxSyncVar) {
+  Reset(0);
+}
+
+void SyncVar::Init(ThreadState *thr, uptr pc, uptr addr, u64 uid) {
+  this->addr = addr;
+  this->uid = uid;
+  this->next = 0;
+
+  creation_stack_id = 0;
+  if (kCppMode)  // Go does not use them
+    creation_stack_id = CurrentStackId(thr, pc);
+  if (common_flags()->detect_deadlocks)
+    DDMutexInit(thr, pc, this);
+}
+
+void SyncVar::Reset(ThreadState *thr) {
+  uid = 0;
+  creation_stack_id = 0;
+  owner_tid = kInvalidTid;
+  last_lock = 0;
+  recursion = 0;
+  is_rw = 0;
+  is_recursive = 0;
+  is_broken = 0;
+  is_linker_init = 0;
+
+  if (thr == 0) {
+    CHECK_EQ(clock.size(), 0);
+    CHECK_EQ(read_clock.size(), 0);
+  } else {
+    clock.Reset(&thr->clock_cache);
+    read_clock.Reset(&thr->clock_cache);
+  }
+}
+
+MetaMap::MetaMap() {
+  atomic_store(&uid_gen_, 0, memory_order_relaxed);
+}
+
+void MetaMap::AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz) {
+  u32 idx = block_alloc_.Alloc(&thr->block_cache);
+  MBlock *b = block_alloc_.Map(idx);
+  b->siz = sz;
+  b->tid = thr->tid;
+  b->stk = CurrentStackId(thr, pc);
+  u32 *meta = MemToMeta(p);
+  DCHECK_EQ(*meta, 0);
+  *meta = idx | kFlagBlock;
+}
+
+uptr MetaMap::FreeBlock(ThreadState *thr, uptr pc, uptr p) {
+  MBlock* b = GetBlock(p);
+  if (b == 0)
+    return 0;
+  uptr sz = RoundUpTo(b->siz, kMetaShadowCell);
+  FreeRange(thr, pc, p, sz);
+  return sz;
+}
+
+bool MetaMap::FreeRange(ThreadState *thr, uptr pc, uptr p, uptr sz) {
+  bool has_something = false;
+  u32 *meta = MemToMeta(p);
+  u32 *end = MemToMeta(p + sz);
+  if (end == meta)
+    end++;
+  for (; meta < end; meta++) {
+    u32 idx = *meta;
+    if (idx == 0) {
+      // Note: don't write to meta in this case -- the block can be huge.
+      continue;
+    }
+    *meta = 0;
+    has_something = true;
+    while (idx != 0) {
+      if (idx & kFlagBlock) {
+        block_alloc_.Free(&thr->block_cache, idx & ~kFlagMask);
+        break;
+      } else if (idx & kFlagSync) {
+        DCHECK(idx & kFlagSync);
+        SyncVar *s = sync_alloc_.Map(idx & ~kFlagMask);
+        u32 next = s->next;
+        s->Reset(thr);
+        sync_alloc_.Free(&thr->sync_cache, idx & ~kFlagMask);
+        idx = next;
+      } else {
+        CHECK(0);
+      }
+    }
+  }
+  return has_something;
+}
+
+// ResetRange removes all meta objects from the range.
+// It is called for large mmap-ed regions. The function is best-effort wrt
+// freeing of meta objects, because we don't want to page in the whole range
+// which can be huge. The function probes pages one-by-one until it finds a page
+// without meta objects, at this point it stops freeing meta objects. Because
+// thread stacks grow top-down, we do the same starting from end as well.
+void MetaMap::ResetRange(ThreadState *thr, uptr pc, uptr p, uptr sz) {
+  const uptr kMetaRatio = kMetaShadowCell / kMetaShadowSize;
+  const uptr kPageSize = GetPageSizeCached() * kMetaRatio;
+  if (sz <= 4 * kPageSize) {
+    // If the range is small, just do the normal free procedure.
+    FreeRange(thr, pc, p, sz);
+    return;
+  }
+  // First, round both ends of the range to page size.
+  uptr diff = RoundUp(p, kPageSize) - p;
+  if (diff != 0) {
+    FreeRange(thr, pc, p, diff);
+    p += diff;
+    sz -= diff;
+  }
+  diff = p + sz - RoundDown(p + sz, kPageSize);
+  if (diff != 0) {
+    FreeRange(thr, pc, p + sz - diff, diff);
+    sz -= diff;
+  }
+  // Now we must have a non-empty page-aligned range.
+  CHECK_GT(sz, 0);
+  CHECK_EQ(p, RoundUp(p, kPageSize));
+  CHECK_EQ(sz, RoundUp(sz, kPageSize));
+  const uptr p0 = p;
+  const uptr sz0 = sz;
+  // Probe start of the range.
+  while (sz > 0) {
+    bool has_something = FreeRange(thr, pc, p, kPageSize);
+    p += kPageSize;
+    sz -= kPageSize;
+    if (!has_something)
+      break;
+  }
+  // Probe end of the range.
+  while (sz > 0) {
+    bool has_something = FreeRange(thr, pc, p - kPageSize, kPageSize);
+    sz -= kPageSize;
+    if (!has_something)
+      break;
+  }
+  // Finally, page out the whole range (including the parts that we've just
+  // freed). Note: we can't simply madvise, because we need to leave a zeroed
+  // range (otherwise __tsan_java_move can crash if it encounters a left-over
+  // meta objects in java heap).
+  uptr metap = (uptr)MemToMeta(p0);
+  uptr metasz = sz0 / kMetaRatio;
+  UnmapOrDie((void*)metap, metasz);
+  MmapFixedNoReserve(metap, metasz);
+}
+
+MBlock* MetaMap::GetBlock(uptr p) {
+  u32 *meta = MemToMeta(p);
+  u32 idx = *meta;
+  for (;;) {
+    if (idx == 0)
+      return 0;
+    if (idx & kFlagBlock)
+      return block_alloc_.Map(idx & ~kFlagMask);
+    DCHECK(idx & kFlagSync);
+    SyncVar * s = sync_alloc_.Map(idx & ~kFlagMask);
+    idx = s->next;
+  }
+}
+
+SyncVar* MetaMap::GetOrCreateAndLock(ThreadState *thr, uptr pc,
+                              uptr addr, bool write_lock) {
+  return GetAndLock(thr, pc, addr, write_lock, true);
+}
+
+SyncVar* MetaMap::GetIfExistsAndLock(uptr addr) {
+  return GetAndLock(0, 0, addr, true, false);
+}
+
+SyncVar* MetaMap::GetAndLock(ThreadState *thr, uptr pc,
+                             uptr addr, bool write_lock, bool create) {
+  u32 *meta = MemToMeta(addr);
+  u32 idx0 = *meta;
+  u32 myidx = 0;
+  SyncVar *mys = 0;
+  for (;;) {
+    u32 idx = idx0;
+    for (;;) {
+      if (idx == 0)
+        break;
+      if (idx & kFlagBlock)
+        break;
+      DCHECK(idx & kFlagSync);
+      SyncVar * s = sync_alloc_.Map(idx & ~kFlagMask);
+      if (s->addr == addr) {
+        if (myidx != 0) {
+          mys->Reset(thr);
+          sync_alloc_.Free(&thr->sync_cache, myidx);
+        }
+        if (write_lock)
+          s->mtx.Lock();
+        else
+          s->mtx.ReadLock();
+        return s;
+      }
+      idx = s->next;
+    }
+    if (!create)
+      return 0;
+    if (*meta != idx0) {
+      idx0 = *meta;
+      continue;
+    }
+
+    if (myidx == 0) {
+      const u64 uid = atomic_fetch_add(&uid_gen_, 1, memory_order_relaxed);
+      myidx = sync_alloc_.Alloc(&thr->sync_cache);
+      mys = sync_alloc_.Map(myidx);
+      mys->Init(thr, pc, addr, uid);
+    }
+    mys->next = idx0;
+    if (atomic_compare_exchange_strong((atomic_uint32_t*)meta, &idx0,
+        myidx | kFlagSync, memory_order_release)) {
+      if (write_lock)
+        mys->mtx.Lock();
+      else
+        mys->mtx.ReadLock();
+      return mys;
+    }
+  }
+}
+
+void MetaMap::MoveMemory(uptr src, uptr dst, uptr sz) {
+  // src and dst can overlap,
+  // there are no concurrent accesses to the regions (e.g. stop-the-world).
+  CHECK_NE(src, dst);
+  CHECK_NE(sz, 0);
+  uptr diff = dst - src;
+  u32 *src_meta = MemToMeta(src);
+  u32 *dst_meta = MemToMeta(dst);
+  u32 *src_meta_end = MemToMeta(src + sz);
+  uptr inc = 1;
+  if (dst > src) {
+    src_meta = MemToMeta(src + sz) - 1;
+    dst_meta = MemToMeta(dst + sz) - 1;
+    src_meta_end = MemToMeta(src) - 1;
+    inc = -1;
+  }
+  for (; src_meta != src_meta_end; src_meta += inc, dst_meta += inc) {
+    CHECK_EQ(*dst_meta, 0);
+    u32 idx = *src_meta;
+    *src_meta = 0;
+    *dst_meta = idx;
+    // Patch the addresses in sync objects.
+    while (idx != 0) {
+      if (idx & kFlagBlock)
+        break;
+      CHECK(idx & kFlagSync);
+      SyncVar *s = sync_alloc_.Map(idx & ~kFlagMask);
+      s->addr += diff;
+      idx = s->next;
+    }
+  }
+}
+
+void MetaMap::OnThreadIdle(ThreadState *thr) {
+  block_alloc_.FlushCache(&thr->block_cache);
+  sync_alloc_.FlushCache(&thr->sync_cache);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/rtl/tsan_sync.h b/compiler-rt/lib/tsan/rtl/tsan_sync.h
new file mode 100644
index 0000000..f07ea3b
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_sync.h
@@ -0,0 +1,104 @@
+//===-- tsan_sync.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_SYNC_H
+#define TSAN_SYNC_H
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
+#include "tsan_defs.h"
+#include "tsan_clock.h"
+#include "tsan_mutex.h"
+#include "tsan_dense_alloc.h"
+
+namespace __tsan {
+
+struct SyncVar {
+  SyncVar();
+
+  static const int kInvalidTid = -1;
+
+  uptr addr;  // overwritten by DenseSlabAlloc freelist
+  Mutex mtx;
+  u64 uid;  // Globally unique id.
+  u32 creation_stack_id;
+  int owner_tid;  // Set only by exclusive owners.
+  u64 last_lock;
+  int recursion;
+  bool is_rw;
+  bool is_recursive;
+  bool is_broken;
+  bool is_linker_init;
+  u32 next;  // in MetaMap
+  DDMutex dd;
+  SyncClock read_clock;  // Used for rw mutexes only.
+  // The clock is placed last, so that it is situated on a different cache line
+  // with the mtx. This reduces contention for hot sync objects.
+  SyncClock clock;
+
+  void Init(ThreadState *thr, uptr pc, uptr addr, u64 uid);
+  void Reset(ThreadState *thr);
+
+  u64 GetId() const {
+    // 47 lsb is addr, then 14 bits is low part of uid, then 3 zero bits.
+    return GetLsb((u64)addr | (uid << 47), 61);
+  }
+  bool CheckId(u64 uid) const {
+    CHECK_EQ(uid, GetLsb(uid, 14));
+    return GetLsb(this->uid, 14) == uid;
+  }
+  static uptr SplitId(u64 id, u64 *uid) {
+    *uid = id >> 47;
+    return (uptr)GetLsb(id, 47);
+  }
+};
+
+/* MetaMap allows to map arbitrary user pointers onto various descriptors.
+   Currently it maps pointers to heap block descriptors and sync var descs.
+   It uses 1/2 direct shadow, see tsan_platform.h.
+*/
+class MetaMap {
+ public:
+  MetaMap();
+
+  void AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz);
+  uptr FreeBlock(ThreadState *thr, uptr pc, uptr p);
+  bool FreeRange(ThreadState *thr, uptr pc, uptr p, uptr sz);
+  void ResetRange(ThreadState *thr, uptr pc, uptr p, uptr sz);
+  MBlock* GetBlock(uptr p);
+
+  SyncVar* GetOrCreateAndLock(ThreadState *thr, uptr pc,
+                              uptr addr, bool write_lock);
+  SyncVar* GetIfExistsAndLock(uptr addr);
+
+  void MoveMemory(uptr src, uptr dst, uptr sz);
+
+  void OnThreadIdle(ThreadState *thr);
+
+ private:
+  static const u32 kFlagMask  = 3u << 30;
+  static const u32 kFlagBlock = 1u << 30;
+  static const u32 kFlagSync  = 2u << 30;
+  typedef DenseSlabAlloc<MBlock, 1<<16, 1<<12> BlockAlloc;
+  typedef DenseSlabAlloc<SyncVar, 1<<16, 1<<10> SyncAlloc;
+  BlockAlloc block_alloc_;
+  SyncAlloc sync_alloc_;
+  atomic_uint64_t uid_gen_;
+
+  SyncVar* GetAndLock(ThreadState *thr, uptr pc, uptr addr, bool write_lock,
+                      bool create);
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_SYNC_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_trace.h b/compiler-rt/lib/tsan/rtl/tsan_trace.h
new file mode 100644
index 0000000..2569c7e
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_trace.h
@@ -0,0 +1,74 @@
+//===-- tsan_trace.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_TRACE_H
+#define TSAN_TRACE_H
+
+#include "tsan_defs.h"
+#include "tsan_mutex.h"
+#include "tsan_stack_trace.h"
+#include "tsan_mutexset.h"
+
+namespace __tsan {
+
+const int kTracePartSizeBits = 13;
+const int kTracePartSize = 1 << kTracePartSizeBits;
+const int kTraceParts = 2 * 1024 * 1024 / kTracePartSize;
+const int kTraceSize = kTracePartSize * kTraceParts;
+
+// Must fit into 3 bits.
+enum EventType {
+  EventTypeMop,
+  EventTypeFuncEnter,
+  EventTypeFuncExit,
+  EventTypeLock,
+  EventTypeUnlock,
+  EventTypeRLock,
+  EventTypeRUnlock
+};
+
+// Represents a thread event (from most significant bit):
+// u64 typ  : 3;   // EventType.
+// u64 addr : 61;  // Associated pc.
+typedef u64 Event;
+
+struct TraceHeader {
+#ifndef SANITIZER_GO
+  BufferedStackTrace stack0;  // Start stack for the trace.
+#else
+  VarSizeStackTrace stack0;
+#endif
+  u64        epoch0;  // Start epoch for the trace.
+  MutexSet   mset0;
+
+  TraceHeader() : stack0(), epoch0() {}
+};
+
+struct Trace {
+  Mutex mtx;
+#ifndef SANITIZER_GO
+  // Must be last to catch overflow as paging fault.
+  // Go shadow stack is dynamically allocated.
+  uptr shadow_stack[kShadowStackSize];
+#endif
+  // Must be the last field, because we unmap the unused part in
+  // CreateThreadContext.
+  TraceHeader headers[kTraceParts];
+
+  Trace()
+    : mtx(MutexTypeTrace, StatMtxTrace) {
+  }
+};
+
+}  // namespace __tsan
+
+#endif  // TSAN_TRACE_H
diff --git a/compiler-rt/lib/tsan/rtl/tsan_update_shadow_word_inl.h b/compiler-rt/lib/tsan/rtl/tsan_update_shadow_word_inl.h
new file mode 100644
index 0000000..6e3ac2f
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_update_shadow_word_inl.h
@@ -0,0 +1,66 @@
+//===-- tsan_update_shadow_word_inl.h ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Body of the hottest inner loop.
+// If we wrap this body into a function, compilers (both gcc and clang)
+// produce sligtly less efficient code.
+//===----------------------------------------------------------------------===//
+do {
+  StatInc(thr, StatShadowProcessed);
+  const unsigned kAccessSize = 1 << kAccessSizeLog;
+  u64 *sp = &shadow_mem[idx];
+  old = LoadShadow(sp);
+  if (old.IsZero()) {
+    StatInc(thr, StatShadowZero);
+    if (store_word)
+      StoreIfNotYetStored(sp, &store_word);
+    // The above StoreIfNotYetStored could be done unconditionally
+    // and it even shows 4% gain on synthetic benchmarks (r4307).
+    break;
+  }
+  // is the memory access equal to the previous?
+  if (Shadow::Addr0AndSizeAreEqual(cur, old)) {
+    StatInc(thr, StatShadowSameSize);
+    // same thread?
+    if (Shadow::TidsAreEqual(old, cur)) {
+      StatInc(thr, StatShadowSameThread);
+      if (old.IsRWWeakerOrEqual(kAccessIsWrite, kIsAtomic))
+        StoreIfNotYetStored(sp, &store_word);
+      break;
+    }
+    StatInc(thr, StatShadowAnotherThread);
+    if (HappensBefore(old, thr)) {
+      if (old.IsRWWeakerOrEqual(kAccessIsWrite, kIsAtomic))
+        StoreIfNotYetStored(sp, &store_word);
+      break;
+    }
+    if (old.IsBothReadsOrAtomic(kAccessIsWrite, kIsAtomic))
+      break;
+    goto RACE;
+  }
+  // Do the memory access intersect?
+  if (Shadow::TwoRangesIntersect(old, cur, kAccessSize)) {
+    StatInc(thr, StatShadowIntersect);
+    if (Shadow::TidsAreEqual(old, cur)) {
+      StatInc(thr, StatShadowSameThread);
+      break;
+    }
+    StatInc(thr, StatShadowAnotherThread);
+    if (old.IsBothReadsOrAtomic(kAccessIsWrite, kIsAtomic))
+      break;
+    if (HappensBefore(old, thr))
+      break;
+    goto RACE;
+  }
+  // The accesses do not intersect.
+  StatInc(thr, StatShadowNotIntersect);
+  break;
+} while (0);
diff --git a/compiler-rt/lib/tsan/rtl/tsan_vector.h b/compiler-rt/lib/tsan/rtl/tsan_vector.h
new file mode 100644
index 0000000..a7fb3fa
--- /dev/null
+++ b/compiler-rt/lib/tsan/rtl/tsan_vector.h
@@ -0,0 +1,127 @@
+//===-- tsan_vector.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+
+// Low-fat STL-like vector container.
+
+#ifndef TSAN_VECTOR_H
+#define TSAN_VECTOR_H
+
+#include "tsan_defs.h"
+#include "tsan_mman.h"
+
+namespace __tsan {
+
+template<typename T>
+class Vector {
+ public:
+  explicit Vector(MBlockType typ)
+      : typ_(typ)
+      , begin_()
+      , end_()
+      , last_() {
+  }
+
+  ~Vector() {
+    if (begin_)
+      internal_free(begin_);
+  }
+
+  void Reset() {
+    if (begin_)
+      internal_free(begin_);
+    begin_ = 0;
+    end_ = 0;
+    last_ = 0;
+  }
+
+  uptr Size() const {
+    return end_ - begin_;
+  }
+
+  T &operator[](uptr i) {
+    DCHECK_LT(i, end_ - begin_);
+    return begin_[i];
+  }
+
+  const T &operator[](uptr i) const {
+    DCHECK_LT(i, end_ - begin_);
+    return begin_[i];
+  }
+
+  T *PushBack() {
+    EnsureSize(Size() + 1);
+    T *p = &end_[-1];
+    internal_memset(p, 0, sizeof(*p));
+    return p;
+  }
+
+  T *PushBack(const T& v) {
+    EnsureSize(Size() + 1);
+    T *p = &end_[-1];
+    internal_memcpy(p, &v, sizeof(*p));
+    return p;
+  }
+
+  void PopBack() {
+    DCHECK_GT(end_, begin_);
+    end_--;
+  }
+
+  void Resize(uptr size) {
+    if (size == 0) {
+      end_ = begin_;
+      return;
+    }
+    uptr old_size = Size();
+    EnsureSize(size);
+    if (old_size < size) {
+      for (uptr i = old_size; i < size; i++)
+        internal_memset(&begin_[i], 0, sizeof(begin_[i]));
+    }
+  }
+
+ private:
+  const MBlockType typ_;
+  T *begin_;
+  T *end_;
+  T *last_;
+
+  void EnsureSize(uptr size) {
+    if (size <= Size())
+      return;
+    if (size <= (uptr)(last_ - begin_)) {
+      end_ = begin_ + size;
+      return;
+    }
+    uptr cap0 = last_ - begin_;
+    uptr cap = cap0 * 5 / 4;  // 25% growth
+    if (cap == 0)
+      cap = 16;
+    if (cap < size)
+      cap = size;
+    T *p = (T*)internal_alloc(typ_, cap * sizeof(T));
+    if (cap0) {
+      internal_memcpy(p, begin_, cap0 * sizeof(T));
+      internal_free(begin_);
+    }
+    begin_ = p;
+    end_ = begin_ + size;
+    last_ = begin_ + cap;
+  }
+
+  Vector(const Vector&);
+  void operator=(const Vector&);
+};
+}  // namespace __tsan
+
+#endif  // #ifndef TSAN_VECTOR_H
diff --git a/compiler-rt/lib/tsan/tests/CMakeLists.txt b/compiler-rt/lib/tsan/tests/CMakeLists.txt
new file mode 100644
index 0000000..51181ba
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/CMakeLists.txt
@@ -0,0 +1,91 @@
+include_directories(../rtl)
+
+add_custom_target(TsanUnitTests)
+set_target_properties(TsanUnitTests PROPERTIES
+  FOLDER "TSan unittests")
+
+set(TSAN_UNITTEST_CFLAGS
+  ${TSAN_CFLAGS}
+  ${COMPILER_RT_TEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/lib
+  -I${COMPILER_RT_SOURCE_DIR}/lib/tsan/rtl
+  -DGTEST_HAS_RTTI=0)
+
+set(TSAN_RTL_HEADERS)
+foreach (header ${TSAN_HEADERS})
+  list(APPEND TSAN_RTL_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
+endforeach()
+
+# tsan_compile(obj_list, source, arch, {headers})
+macro(tsan_compile obj_list source arch)
+  get_filename_component(basename ${source} NAME)
+  set(output_obj "${basename}.${arch}.o")
+  get_target_flags_for_arch(${arch} TARGET_CFLAGS)
+  set(COMPILE_DEPS ${TSAN_RTL_HEADERS} ${ARGN})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND COMPILE_DEPS gtest tsan)
+  endif()
+  clang_compile(${output_obj} ${source}
+          CFLAGS ${TSAN_UNITTEST_CFLAGS} ${TARGET_CFLAGS}
+          DEPS ${COMPILE_DEPS})
+  list(APPEND ${obj_list} ${output_obj})
+endmacro()
+
+macro(add_tsan_unittest testname)
+  set(TSAN_TEST_ARCH ${TSAN_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(TSAN_SUPPORTED_ARCH TSAN_TEST_ARCH)
+  endif()
+  if(UNIX)
+    foreach(arch ${TSAN_TEST_ARCH})
+      cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
+      set(TEST_OBJECTS)
+      foreach(SOURCE ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE})
+        tsan_compile(TEST_OBJECTS ${SOURCE} ${arch} ${TEST_HEADERS})
+      endforeach()
+      get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
+      set(TEST_DEPS ${TEST_OBJECTS})
+      if(NOT COMPILER_RT_STANDALONE_BUILD)
+        list(APPEND TEST_DEPS tsan)
+      endif()
+      if(NOT APPLE)
+        # FIXME: Looks like we should link TSan with just-built runtime,
+        # and not rely on -fsanitize=thread, as these tests are essentially
+        # unit tests.
+        add_compiler_rt_test(TsanUnitTests ${testname}
+                OBJECTS ${TEST_OBJECTS}
+                DEPS ${TEST_DEPS}
+                LINK_FLAGS ${TARGET_LINK_FLAGS}
+                           -fsanitize=thread
+                           -lstdc++ -lm)
+      else()
+        set(TSAN_TEST_RUNTIME_OBJECTS
+          $<TARGET_OBJECTS:RTTsan_dynamic.osx>
+          $<TARGET_OBJECTS:RTInterception.osx>
+          $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+          $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+          $<TARGET_OBJECTS:RTUbsan.osx>)
+        set(TSAN_TEST_RUNTIME RTTsanTest.${testname}.${arch})
+        add_library(${TSAN_TEST_RUNTIME} STATIC ${TSAN_TEST_RUNTIME_OBJECTS})
+        set_target_properties(${TSAN_TEST_RUNTIME} PROPERTIES
+          ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+        list(APPEND TEST_OBJECTS lib${TSAN_TEST_RUNTIME}.a)
+        list(APPEND TEST_DEPS ${TSAN_TEST_RUNTIME})
+        # Intentionally do *not* link with `-fsanitize=thread`. We already link
+        # against a static version of the runtime, and we don't want the dynamic
+        # one.
+        add_compiler_rt_test(TsanUnitTests "${testname}-${arch}-Test"
+                OBJECTS ${TEST_OBJECTS}
+                DEPS ${TEST_DEPS}
+                LINK_FLAGS ${TARGET_LINK_FLAGS}
+                           -lc++)
+      endif()
+    endforeach()
+  endif()
+endmacro()
+
+if(COMPILER_RT_CAN_EXECUTE_TESTS)
+  add_subdirectory(rtl)
+  add_subdirectory(unit)
+endif()
diff --git a/compiler-rt/lib/tsan/tests/rtl/CMakeLists.txt b/compiler-rt/lib/tsan/tests/rtl/CMakeLists.txt
new file mode 100644
index 0000000..a34f08e
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/CMakeLists.txt
@@ -0,0 +1,19 @@
+set(TSAN_RTL_TEST_SOURCES
+  tsan_bench.cc
+  tsan_mop.cc
+  tsan_mutex.cc
+  tsan_posix.cc
+  tsan_string.cc
+  tsan_test.cc
+  tsan_thread.cc)
+
+if(UNIX)
+  list(APPEND TSAN_RTL_TEST_SOURCES tsan_test_util_posix.cc)
+endif()
+
+set(TSAN_RTL_TEST_HEADERS
+  tsan_test_util.h)
+
+add_tsan_unittest(TsanRtlTest
+  SOURCES ${TSAN_RTL_TEST_SOURCES}
+  HEADERS ${TSAN_RTL_TEST_HEADERS})
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_bench.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_bench.cc
new file mode 100644
index 0000000..a3cf22f
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_bench.cc
@@ -0,0 +1,105 @@
+//===-- tsan_bench.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_test_util.h"
+#include "tsan_interface.h"
+#include "tsan_defs.h"
+#include "gtest/gtest.h"
+#include <stdint.h>
+
+const int kSize = 128;
+const int kRepeat = 2*1024*1024;
+
+void noinstr(void *p) {}
+
+template<typename T, void(*__tsan_mop)(void *p)>
+static void Benchmark() {
+  volatile T data[kSize];
+  for (int i = 0; i < kRepeat; i++) {
+    for (int j = 0; j < kSize; j++) {
+      __tsan_mop((void*)&data[j]);
+      data[j]++;
+    }
+  }
+}
+
+TEST(DISABLED_BENCH, Mop1) {
+  Benchmark<uint8_t, noinstr>();
+}
+
+TEST(DISABLED_BENCH, Mop1Read) {
+  Benchmark<uint8_t, __tsan_read1>();
+}
+
+TEST(DISABLED_BENCH, Mop1Write) {
+  Benchmark<uint8_t, __tsan_write1>();
+}
+
+TEST(DISABLED_BENCH, Mop2) {
+  Benchmark<uint16_t, noinstr>();
+}
+
+TEST(DISABLED_BENCH, Mop2Read) {
+  Benchmark<uint16_t, __tsan_read2>();
+}
+
+TEST(DISABLED_BENCH, Mop2Write) {
+  Benchmark<uint16_t, __tsan_write2>();
+}
+
+TEST(DISABLED_BENCH, Mop4) {
+  Benchmark<uint32_t, noinstr>();
+}
+
+TEST(DISABLED_BENCH, Mop4Read) {
+  Benchmark<uint32_t, __tsan_read4>();
+}
+
+TEST(DISABLED_BENCH, Mop4Write) {
+  Benchmark<uint32_t, __tsan_write4>();
+}
+
+TEST(DISABLED_BENCH, Mop8) {
+  Benchmark<uint8_t, noinstr>();
+}
+
+TEST(DISABLED_BENCH, Mop8Read) {
+  Benchmark<uint64_t, __tsan_read8>();
+}
+
+TEST(DISABLED_BENCH, Mop8Write) {
+  Benchmark<uint64_t, __tsan_write8>();
+}
+
+TEST(DISABLED_BENCH, FuncCall) {
+  for (int i = 0; i < kRepeat; i++) {
+    for (int j = 0; j < kSize; j++)
+      __tsan_func_entry((void*)(uintptr_t)j);
+    for (int j = 0; j < kSize; j++)
+      __tsan_func_exit();
+  }
+}
+
+TEST(DISABLED_BENCH, MutexLocal) {
+  Mutex m;
+  ScopedThread().Create(m);
+  for (int i = 0; i < 50; i++) {
+    ScopedThread t;
+    t.Lock(m);
+    t.Unlock(m);
+  }
+  for (int i = 0; i < 16*1024*1024; i++) {
+    m.Lock();
+    m.Unlock();
+  }
+  ScopedThread().Destroy(m);
+}
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_mop.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_mop.cc
new file mode 100644
index 0000000..f217428
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_mop.cc
@@ -0,0 +1,233 @@
+//===-- tsan_mop.cc -------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_interface.h"
+#include "tsan_test_util.h"
+#include "gtest/gtest.h"
+#include <stddef.h>
+#include <stdint.h>
+
+TEST(ThreadSanitizer, SimpleWrite) {
+  ScopedThread t;
+  MemLoc l;
+  t.Write1(l);
+}
+
+TEST(ThreadSanitizer, SimpleWriteWrite) {
+  ScopedThread t1, t2;
+  MemLoc l1, l2;
+  t1.Write1(l1);
+  t2.Write1(l2);
+}
+
+TEST(ThreadSanitizer, WriteWriteRace) {
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Write1(l);
+  t2.Write1(l, true);
+}
+
+TEST(ThreadSanitizer, ReadWriteRace) {
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Read1(l);
+  t2.Write1(l, true);
+}
+
+TEST(ThreadSanitizer, WriteReadRace) {
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Write1(l);
+  t2.Read1(l, true);
+}
+
+TEST(ThreadSanitizer, ReadReadNoRace) {
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Read1(l);
+  t2.Read1(l);
+}
+
+TEST(ThreadSanitizer, WriteThenRead) {
+  MemLoc l;
+  ScopedThread t1, t2;
+  t1.Write1(l);
+  t1.Read1(l);
+  t2.Read1(l, true);
+}
+
+TEST(ThreadSanitizer, WriteThenLockedRead) {
+  Mutex m(Mutex::RW);
+  MainThread t0;
+  t0.Create(m);
+  MemLoc l;
+  {
+    ScopedThread t1, t2;
+
+    t1.Write8(l);
+
+    t1.Lock(m);
+    t1.Read8(l);
+    t1.Unlock(m);
+
+    t2.Read8(l, true);
+  }
+  t0.Destroy(m);
+}
+
+TEST(ThreadSanitizer, LockedWriteThenRead) {
+  Mutex m(Mutex::RW);
+  MainThread t0;
+  t0.Create(m);
+  MemLoc l;
+  {
+    ScopedThread t1, t2;
+
+    t1.Lock(m);
+    t1.Write8(l);
+    t1.Unlock(m);
+
+    t1.Read8(l);
+
+    t2.Read8(l, true);
+  }
+  t0.Destroy(m);
+}
+
+
+TEST(ThreadSanitizer, RaceWithOffset) {
+  ScopedThread t1, t2;
+  {
+    MemLoc l;
+    t1.Access(l.loc(), true, 8, false);
+    t2.Access((char*)l.loc() + 4, true, 4, true);
+  }
+  {
+    MemLoc l;
+    t1.Access(l.loc(), true, 8, false);
+    t2.Access((char*)l.loc() + 7, true, 1, true);
+  }
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc() + 4, true, 4, false);
+    t2.Access((char*)l.loc() + 4, true, 2, true);
+  }
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc() + 4, true, 4, false);
+    t2.Access((char*)l.loc() + 6, true, 2, true);
+  }
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc() + 3, true, 2, false);
+    t2.Access((char*)l.loc() + 4, true, 1, true);
+  }
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc() + 1, true, 8, false);
+    t2.Access((char*)l.loc() + 3, true, 1, true);
+  }
+}
+
+TEST(ThreadSanitizer, RaceWithOffset2) {
+  ScopedThread t1, t2;
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc(), true, 4, false);
+    t2.Access((char*)l.loc() + 2, true, 1, true);
+  }
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc() + 2, true, 1, false);
+    t2.Access((char*)l.loc(), true, 4, true);
+  }
+}
+
+TEST(ThreadSanitizer, NoRaceWithOffset) {
+  ScopedThread t1, t2;
+  {
+    MemLoc l;
+    t1.Access(l.loc(), true, 4, false);
+    t2.Access((char*)l.loc() + 4, true, 4, false);
+  }
+  {
+    MemLoc l;
+    t1.Access((char*)l.loc() + 3, true, 2, false);
+    t2.Access((char*)l.loc() + 1, true, 2, false);
+    t2.Access((char*)l.loc() + 5, true, 2, false);
+  }
+}
+
+TEST(ThreadSanitizer, RaceWithDeadThread) {
+  MemLoc l;
+  ScopedThread t;
+  ScopedThread().Write1(l);
+  t.Write1(l, true);
+}
+
+TEST(ThreadSanitizer, BenignRaceOnVptr) {
+  void *vptr_storage;
+  MemLoc vptr(&vptr_storage), val;
+  vptr_storage = val.loc();
+  ScopedThread t1, t2;
+  t1.VptrUpdate(vptr, val);
+  t2.Read8(vptr);
+}
+
+TEST(ThreadSanitizer, HarmfulRaceOnVptr) {
+  void *vptr_storage;
+  MemLoc vptr(&vptr_storage), val1, val2;
+  vptr_storage = val1.loc();
+  ScopedThread t1, t2;
+  t1.VptrUpdate(vptr, val2);
+  t2.Read8(vptr, true);
+}
+
+static void foo() {
+  volatile int x = 42;
+  int x2 = x;
+  (void)x2;
+}
+
+static void bar() {
+  volatile int x = 43;
+  int x2 = x;
+  (void)x2;
+}
+
+TEST(ThreadSanitizer, ReportDeadThread) {
+  MemLoc l;
+  ScopedThread t1;
+  {
+    ScopedThread t2;
+    t2.Call(&foo);
+    t2.Call(&bar);
+    t2.Write1(l);
+  }
+  t1.Write1(l, true);
+}
+
+struct ClassWithStatic {
+  static int Data[4];
+};
+
+int ClassWithStatic::Data[4];
+
+static void foobarbaz() {}
+
+TEST(ThreadSanitizer, ReportRace) {
+  ScopedThread t1;
+  MainThread().Access(&ClassWithStatic::Data, true, 4, false);
+  t1.Call(&foobarbaz);
+  t1.Access(&ClassWithStatic::Data, true, 2, true);
+  t1.Return();
+}
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_mutex.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_mutex.cc
new file mode 100644
index 0000000..4d9c779
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_mutex.cc
@@ -0,0 +1,221 @@
+//===-- tsan_mutex.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "tsan_interface.h"
+#include "tsan_interface_ann.h"
+#include "tsan_test_util.h"
+#include "gtest/gtest.h"
+#include <stdint.h>
+
+namespace __tsan {
+
+TEST(ThreadSanitizer, BasicMutex) {
+  ScopedThread t;
+  Mutex m;
+  t.Create(m);
+
+  t.Lock(m);
+  t.Unlock(m);
+
+  CHECK(t.TryLock(m));
+  t.Unlock(m);
+
+  t.Lock(m);
+  CHECK(!t.TryLock(m));
+  t.Unlock(m);
+
+  t.Destroy(m);
+}
+
+TEST(ThreadSanitizer, BasicSpinMutex) {
+  ScopedThread t;
+  Mutex m(Mutex::Spin);
+  t.Create(m);
+
+  t.Lock(m);
+  t.Unlock(m);
+
+  CHECK(t.TryLock(m));
+  t.Unlock(m);
+
+  t.Lock(m);
+  CHECK(!t.TryLock(m));
+  t.Unlock(m);
+
+  t.Destroy(m);
+}
+
+TEST(ThreadSanitizer, BasicRwMutex) {
+  ScopedThread t;
+  Mutex m(Mutex::RW);
+  t.Create(m);
+
+  t.Lock(m);
+  t.Unlock(m);
+
+  CHECK(t.TryLock(m));
+  t.Unlock(m);
+
+  t.Lock(m);
+  CHECK(!t.TryLock(m));
+  t.Unlock(m);
+
+  t.ReadLock(m);
+  t.ReadUnlock(m);
+
+  CHECK(t.TryReadLock(m));
+  t.ReadUnlock(m);
+
+  t.Lock(m);
+  CHECK(!t.TryReadLock(m));
+  t.Unlock(m);
+
+  t.ReadLock(m);
+  CHECK(!t.TryLock(m));
+  t.ReadUnlock(m);
+
+  t.ReadLock(m);
+  CHECK(t.TryReadLock(m));
+  t.ReadUnlock(m);
+  t.ReadUnlock(m);
+
+  t.Destroy(m);
+}
+
+TEST(ThreadSanitizer, Mutex) {
+  Mutex m;
+  MainThread t0;
+  t0.Create(m);
+
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Lock(m);
+  t1.Write1(l);
+  t1.Unlock(m);
+  t2.Lock(m);
+  t2.Write1(l);
+  t2.Unlock(m);
+  t2.Destroy(m);
+}
+
+TEST(ThreadSanitizer, SpinMutex) {
+  Mutex m(Mutex::Spin);
+  MainThread t0;
+  t0.Create(m);
+
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Lock(m);
+  t1.Write1(l);
+  t1.Unlock(m);
+  t2.Lock(m);
+  t2.Write1(l);
+  t2.Unlock(m);
+  t2.Destroy(m);
+}
+
+TEST(ThreadSanitizer, RwMutex) {
+  Mutex m(Mutex::RW);
+  MainThread t0;
+  t0.Create(m);
+
+  ScopedThread t1, t2, t3;
+  MemLoc l;
+  t1.Lock(m);
+  t1.Write1(l);
+  t1.Unlock(m);
+  t2.Lock(m);
+  t2.Write1(l);
+  t2.Unlock(m);
+  t1.ReadLock(m);
+  t3.ReadLock(m);
+  t1.Read1(l);
+  t3.Read1(l);
+  t1.ReadUnlock(m);
+  t3.ReadUnlock(m);
+  t2.Lock(m);
+  t2.Write1(l);
+  t2.Unlock(m);
+  t2.Destroy(m);
+}
+
+TEST(ThreadSanitizer, StaticMutex) {
+  // Emulates statically initialized mutex.
+  Mutex m;
+  m.StaticInit();
+  {
+    ScopedThread t1, t2;
+    t1.Lock(m);
+    t1.Unlock(m);
+    t2.Lock(m);
+    t2.Unlock(m);
+  }
+  MainThread().Destroy(m);
+}
+
+static void *singleton_thread(void *param) {
+  atomic_uintptr_t *singleton = (atomic_uintptr_t *)param;
+  for (int i = 0; i < 4*1024*1024; i++) {
+    int *val = (int *)atomic_load(singleton, memory_order_acquire);
+    __tsan_acquire(singleton);
+    __tsan_read4(val);
+    CHECK_EQ(*val, 42);
+  }
+  return 0;
+}
+
+TEST(DISABLED_BENCH_ThreadSanitizer, Singleton) {
+  const int kClockSize = 100;
+  const int kThreadCount = 8;
+
+  // Puff off thread's clock.
+  for (int i = 0; i < kClockSize; i++) {
+    ScopedThread t1;
+    (void)t1;
+  }
+  // Create the singleton.
+  int val = 42;
+  __tsan_write4(&val);
+  atomic_uintptr_t singleton;
+  __tsan_release(&singleton);
+  atomic_store(&singleton, (uintptr_t)&val, memory_order_release);
+  // Create reader threads.
+  pthread_t threads[kThreadCount];
+  for (int t = 0; t < kThreadCount; t++)
+    pthread_create(&threads[t], 0, singleton_thread, &singleton);
+  for (int t = 0; t < kThreadCount; t++)
+    pthread_join(threads[t], 0);
+}
+
+TEST(DISABLED_BENCH_ThreadSanitizer, StopFlag) {
+  const int kClockSize = 100;
+  const int kIters = 16*1024*1024;
+
+  // Puff off thread's clock.
+  for (int i = 0; i < kClockSize; i++) {
+    ScopedThread t1;
+    (void)t1;
+  }
+  // Create the stop flag.
+  atomic_uintptr_t flag;
+  __tsan_release(&flag);
+  atomic_store(&flag, 0, memory_order_release);
+  // Read it a lot.
+  for (int i = 0; i < kIters; i++) {
+    uptr v = atomic_load(&flag, memory_order_acquire);
+    __tsan_acquire(&flag);
+    CHECK_EQ(v, 0);
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_posix.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_posix.cc
new file mode 100644
index 0000000..e1a61b5
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_posix.cc
@@ -0,0 +1,151 @@
+//===-- tsan_posix.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_interface.h"
+#include "tsan_test_util.h"
+#include "gtest/gtest.h"
+#include <pthread.h>
+
+struct thread_key {
+  pthread_key_t key;
+  pthread_mutex_t *mtx;
+  int val;
+  int *cnt;
+  thread_key(pthread_key_t key, pthread_mutex_t *mtx, int val, int *cnt)
+    : key(key)
+    , mtx(mtx)
+    , val(val)
+    , cnt(cnt) {
+  }
+};
+
+static void thread_secific_dtor(void *v) {
+  thread_key *k = (thread_key *)v;
+  EXPECT_EQ(pthread_mutex_lock(k->mtx), 0);
+  (*k->cnt)++;
+  __tsan_write4(&k->cnt);
+  EXPECT_EQ(pthread_mutex_unlock(k->mtx), 0);
+  if (k->val == 42) {
+    // Okay.
+  } else if (k->val == 43 || k->val == 44) {
+    k->val--;
+    EXPECT_EQ(pthread_setspecific(k->key, k), 0);
+  } else {
+    ASSERT_TRUE(false);
+  }
+}
+
+static void *dtors_thread(void *p) {
+  thread_key *k = (thread_key *)p;
+  EXPECT_EQ(pthread_setspecific(k->key, k), 0);
+  return 0;
+}
+
+TEST(Posix, ThreadSpecificDtors) {
+  int cnt = 0;
+  pthread_key_t key;
+  EXPECT_EQ(pthread_key_create(&key, thread_secific_dtor), 0);
+  pthread_mutex_t mtx;
+  EXPECT_EQ(pthread_mutex_init(&mtx, 0), 0);
+  pthread_t th[3];
+  thread_key k1 = thread_key(key, &mtx, 42, &cnt);
+  thread_key k2 = thread_key(key, &mtx, 43, &cnt);
+  thread_key k3 = thread_key(key, &mtx, 44, &cnt);
+  EXPECT_EQ(pthread_create(&th[0], 0, dtors_thread, &k1), 0);
+  EXPECT_EQ(pthread_create(&th[1], 0, dtors_thread, &k2), 0);
+  EXPECT_EQ(pthread_join(th[0], 0), 0);
+  EXPECT_EQ(pthread_create(&th[2], 0, dtors_thread, &k3), 0);
+  EXPECT_EQ(pthread_join(th[1], 0), 0);
+  EXPECT_EQ(pthread_join(th[2], 0), 0);
+  EXPECT_EQ(pthread_key_delete(key), 0);
+  EXPECT_EQ(6, cnt);
+}
+
+#ifndef __aarch64__
+static __thread int local_var;
+
+static void *local_thread(void *p) {
+  __tsan_write1(&local_var);
+  __tsan_write1(&p);
+  if (p == 0)
+    return 0;
+  const int kThreads = 4;
+  pthread_t th[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    EXPECT_EQ(pthread_create(&th[i], 0, local_thread,
+              (void*)((long)p - 1)), 0);  // NOLINT
+  for (int i = 0; i < kThreads; i++)
+    EXPECT_EQ(pthread_join(th[i], 0), 0);
+  return 0;
+}
+#endif
+
+TEST(Posix, ThreadLocalAccesses) {
+// The test is failing with high thread count for aarch64.
+// FIXME: track down the issue and re-enable the test.
+#ifndef __aarch64__
+  local_thread((void*)2);
+#endif
+}
+
+struct CondContext {
+  pthread_mutex_t m;
+  pthread_cond_t c;
+  int data;
+};
+
+static void *cond_thread(void *p) {
+  CondContext &ctx = *static_cast<CondContext*>(p);
+
+  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
+  EXPECT_EQ(ctx.data, 0);
+  ctx.data = 1;
+  EXPECT_EQ(pthread_cond_signal(&ctx.c), 0);
+  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
+
+  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
+  while (ctx.data != 2)
+    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
+  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
+
+  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
+  ctx.data = 3;
+  EXPECT_EQ(pthread_cond_broadcast(&ctx.c), 0);
+  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
+
+  return 0;
+}
+
+TEST(Posix, CondBasic) {
+  CondContext ctx;
+  EXPECT_EQ(pthread_mutex_init(&ctx.m, 0), 0);
+  EXPECT_EQ(pthread_cond_init(&ctx.c, 0), 0);
+  ctx.data = 0;
+  pthread_t th;
+  EXPECT_EQ(pthread_create(&th, 0, cond_thread, &ctx), 0);
+
+  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
+  while (ctx.data != 1)
+    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
+  ctx.data = 2;
+  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
+  EXPECT_EQ(pthread_cond_broadcast(&ctx.c), 0);
+
+  EXPECT_EQ(pthread_mutex_lock(&ctx.m), 0);
+  while (ctx.data != 3)
+    EXPECT_EQ(pthread_cond_wait(&ctx.c, &ctx.m), 0);
+  EXPECT_EQ(pthread_mutex_unlock(&ctx.m), 0);
+
+  EXPECT_EQ(pthread_join(th, 0), 0);
+  EXPECT_EQ(pthread_cond_destroy(&ctx.c), 0);
+  EXPECT_EQ(pthread_mutex_destroy(&ctx.m), 0);
+}
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_string.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_string.cc
new file mode 100644
index 0000000..75adc6c
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_string.cc
@@ -0,0 +1,82 @@
+//===-- tsan_string.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_test_util.h"
+#include "gtest/gtest.h"
+#include <string.h>
+
+namespace __tsan {
+
+TEST(ThreadSanitizer, Memcpy) {
+  char data0[7] = {1, 2, 3, 4, 5, 6, 7};
+  char data[7] = {42, 42, 42, 42, 42, 42, 42};
+  MainThread().Memcpy(data+1, data0+1, 5);
+  EXPECT_EQ(data[0], 42);
+  EXPECT_EQ(data[1], 2);
+  EXPECT_EQ(data[2], 3);
+  EXPECT_EQ(data[3], 4);
+  EXPECT_EQ(data[4], 5);
+  EXPECT_EQ(data[5], 6);
+  EXPECT_EQ(data[6], 42);
+  MainThread().Memset(data+1, 13, 5);
+  EXPECT_EQ(data[0], 42);
+  EXPECT_EQ(data[1], 13);
+  EXPECT_EQ(data[2], 13);
+  EXPECT_EQ(data[3], 13);
+  EXPECT_EQ(data[4], 13);
+  EXPECT_EQ(data[5], 13);
+  EXPECT_EQ(data[6], 42);
+}
+
+TEST(ThreadSanitizer, MemcpyRace1) {
+  char *data = new char[10];
+  char *data1 = new char[10];
+  char *data2 = new char[10];
+  ScopedThread t1, t2;
+  t1.Memcpy(data, data1, 10);
+  t2.Memcpy(data, data2, 10, true);
+}
+
+TEST(ThreadSanitizer, MemcpyRace2) {
+  char *data = new char[10];
+  char *data1 = new char[10];
+  char *data2 = new char[10];
+  ScopedThread t1, t2;
+  t1.Memcpy(data+5, data1, 1);
+  t2.Memcpy(data+3, data2, 4, true);
+}
+
+TEST(ThreadSanitizer, MemcpyRace3) {
+  char *data = new char[10];
+  char *data1 = new char[10];
+  char *data2 = new char[10];
+  ScopedThread t1, t2;
+  t1.Memcpy(data, data1, 10);
+  t2.Memcpy(data1, data2, 10, true);
+}
+
+TEST(ThreadSanitizer, MemcpyStack) {
+  char *data = new char[10];
+  char *data1 = new char[10];
+  ScopedThread t1, t2;
+  t1.Memcpy(data, data1, 10);
+  t2.Memcpy(data, data1, 10, true);
+}
+
+TEST(ThreadSanitizer, MemsetRace1) {
+  char *data = new char[10];
+  ScopedThread t1, t2;
+  t1.Memset(data, 1, 10);
+  t2.Memset(data, 2, 10, true);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_test.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_test.cc
new file mode 100644
index 0000000..edfede0
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_test.cc
@@ -0,0 +1,60 @@
+//===-- tsan_test.cc ------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_interface.h"
+#include "tsan_test_util.h"
+#include "gtest/gtest.h"
+
+static void foo() {}
+static void bar() {}
+
+TEST(ThreadSanitizer, FuncCall) {
+  ScopedThread t1, t2;
+  MemLoc l;
+  t1.Write1(l);
+  t2.Call(foo);
+  t2.Call(bar);
+  t2.Write1(l, true);
+  t2.Return();
+  t2.Return();
+}
+
+// We use this function instead of main, as ISO C++ forbids taking the address
+// of main, which we need to pass inside __tsan_func_entry.
+int run_tests(int argc, char **argv) {
+  TestMutexBeforeInit();  // Mutexes must be usable before __tsan_init();
+  __tsan_init();
+  __tsan_func_entry(__builtin_return_address(0));
+  __tsan_func_entry((void*)((intptr_t)&run_tests + 1));
+
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  int res = RUN_ALL_TESTS();
+
+  __tsan_func_exit();
+  __tsan_func_exit();
+  return res;
+}
+
+const char *argv0;
+
+#ifdef __APPLE__
+// On Darwin, turns off symbolication and crash logs to make tests faster.
+extern "C" const char* __tsan_default_options() {
+  return "symbolize=false:abort_on_error=0";
+}
+#endif
+
+int main(int argc, char **argv) {
+  argv0 = argv[0];
+  return run_tests(argc, argv);
+}
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_test_util.h b/compiler-rt/lib/tsan/tests/rtl/tsan_test_util.h
new file mode 100644
index 0000000..31b1b18
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_test_util.h
@@ -0,0 +1,130 @@
+//===-- tsan_test_util.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Test utils.
+//===----------------------------------------------------------------------===//
+#ifndef TSAN_TEST_UTIL_H
+#define TSAN_TEST_UTIL_H
+
+void TestMutexBeforeInit();
+
+// A location of memory on which a race may be detected.
+class MemLoc {
+ public:
+  explicit MemLoc(int offset_from_aligned = 0);
+  explicit MemLoc(void *const real_addr) : loc_(real_addr) { }
+  ~MemLoc();
+  void *loc() const { return loc_; }
+ private:
+  void *const loc_;
+  MemLoc(const MemLoc&);
+  void operator = (const MemLoc&);
+};
+
+class Mutex {
+ public:
+  enum Type {
+    Normal,
+    RW,
+#ifndef __APPLE__
+    Spin
+#else
+    Spin = Normal
+#endif
+  };
+
+  explicit Mutex(Type type = Normal);
+  ~Mutex();
+
+  void Init();
+  void StaticInit();  // Emulates static initialization (tsan invisible).
+  void Destroy();
+  void Lock();
+  bool TryLock();
+  void Unlock();
+  void ReadLock();
+  bool TryReadLock();
+  void ReadUnlock();
+
+ private:
+  // Placeholder for pthread_mutex_t, CRITICAL_SECTION or whatever.
+  void *mtx_[128];
+  bool alive_;
+  const Type type_;
+
+  Mutex(const Mutex&);
+  void operator = (const Mutex&);
+};
+
+// A thread is started in CTOR and joined in DTOR.
+class ScopedThread {
+ public:
+  explicit ScopedThread(bool detached = false, bool main = false);
+  ~ScopedThread();
+  void Detach();
+
+  void Access(void *addr, bool is_write, int size, bool expect_race);
+  void Read(const MemLoc &ml, int size, bool expect_race = false) {
+    Access(ml.loc(), false, size, expect_race);
+  }
+  void Write(const MemLoc &ml, int size, bool expect_race = false) {
+    Access(ml.loc(), true, size, expect_race);
+  }
+  void Read1(const MemLoc &ml, bool expect_race = false) {
+    Read(ml, 1, expect_race); }
+  void Read2(const MemLoc &ml, bool expect_race = false) {
+    Read(ml, 2, expect_race); }
+  void Read4(const MemLoc &ml, bool expect_race = false) {
+    Read(ml, 4, expect_race); }
+  void Read8(const MemLoc &ml, bool expect_race = false) {
+    Read(ml, 8, expect_race); }
+  void Write1(const MemLoc &ml, bool expect_race = false) {
+    Write(ml, 1, expect_race); }
+  void Write2(const MemLoc &ml, bool expect_race = false) {
+    Write(ml, 2, expect_race); }
+  void Write4(const MemLoc &ml, bool expect_race = false) {
+    Write(ml, 4, expect_race); }
+  void Write8(const MemLoc &ml, bool expect_race = false) {
+    Write(ml, 8, expect_race); }
+
+  void VptrUpdate(const MemLoc &vptr, const MemLoc &new_val,
+                  bool expect_race = false);
+
+  void Call(void(*pc)());
+  void Return();
+
+  void Create(const Mutex &m);
+  void Destroy(const Mutex &m);
+  void Lock(const Mutex &m);
+  bool TryLock(const Mutex &m);
+  void Unlock(const Mutex &m);
+  void ReadLock(const Mutex &m);
+  bool TryReadLock(const Mutex &m);
+  void ReadUnlock(const Mutex &m);
+
+  void Memcpy(void *dst, const void *src, int size, bool expect_race = false);
+  void Memset(void *dst, int val, int size, bool expect_race = false);
+
+ private:
+  struct Impl;
+  Impl *impl_;
+  ScopedThread(const ScopedThread&);  // Not implemented.
+  void operator = (const ScopedThread&);  // Not implemented.
+};
+
+class MainThread : public ScopedThread {
+ public:
+  MainThread()
+    : ScopedThread(false, true) {
+  }
+};
+
+#endif  // #ifndef TSAN_TEST_UTIL_H
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_test_util_posix.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_test_util_posix.cc
new file mode 100644
index 0000000..c8be088
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_test_util_posix.cc
@@ -0,0 +1,523 @@
+//===-- tsan_test_util_posix.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// Test utils, Linux, FreeBSD and Darwin implementation.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "tsan_interface.h"
+#include "tsan_test_util.h"
+#include "tsan_report.h"
+
+#include "gtest/gtest.h"
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+using namespace __tsan;  // NOLINT
+
+static __thread bool expect_report;
+static __thread bool expect_report_reported;
+static __thread ReportType expect_report_type;
+
+#ifdef __APPLE__
+#define __interceptor_memcpy wrap_memcpy
+#define __interceptor_memset wrap_memset
+#define __interceptor_pthread_create wrap_pthread_create
+#define __interceptor_pthread_join wrap_pthread_join
+#define __interceptor_pthread_detach wrap_pthread_detach
+#define __interceptor_pthread_mutex_init wrap_pthread_mutex_init
+#define __interceptor_pthread_mutex_lock wrap_pthread_mutex_lock
+#define __interceptor_pthread_mutex_unlock wrap_pthread_mutex_unlock
+#define __interceptor_pthread_mutex_destroy wrap_pthread_mutex_destroy
+#define __interceptor_pthread_mutex_trylock wrap_pthread_mutex_trylock
+#define __interceptor_pthread_rwlock_init wrap_pthread_rwlock_init
+#define __interceptor_pthread_rwlock_destroy wrap_pthread_rwlock_destroy
+#define __interceptor_pthread_rwlock_trywrlock wrap_pthread_rwlock_trywrlock
+#define __interceptor_pthread_rwlock_wrlock wrap_pthread_rwlock_wrlock
+#define __interceptor_pthread_rwlock_unlock wrap_pthread_rwlock_unlock
+#define __interceptor_pthread_rwlock_rdlock wrap_pthread_rwlock_rdlock
+#define __interceptor_pthread_rwlock_tryrdlock wrap_pthread_rwlock_tryrdlock
+#endif
+
+extern "C" void *__interceptor_memcpy(void *, const void *, uptr);
+extern "C" void *__interceptor_memset(void *, int, uptr);
+extern "C" int __interceptor_pthread_create(pthread_t *thread,
+                                            const pthread_attr_t *attr,
+                                            void *(*start_routine)(void *),
+                                            void *arg);
+extern "C" int __interceptor_pthread_join(pthread_t thread, void **value_ptr);
+extern "C" int __interceptor_pthread_detach(pthread_t thread);
+
+extern "C" int __interceptor_pthread_mutex_init(
+    pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
+extern "C" int __interceptor_pthread_mutex_lock(pthread_mutex_t *mutex);
+extern "C" int __interceptor_pthread_mutex_unlock(pthread_mutex_t *mutex);
+extern "C" int __interceptor_pthread_mutex_destroy(pthread_mutex_t *mutex);
+extern "C" int __interceptor_pthread_mutex_trylock(pthread_mutex_t *mutex);
+
+extern "C" int __interceptor_pthread_rwlock_init(
+    pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
+extern "C" int __interceptor_pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
+
+
+static void *BeforeInitThread(void *param) {
+  (void)param;
+  return 0;
+}
+
+static void AtExit() {
+}
+
+void TestMutexBeforeInit() {
+  // Mutexes must be usable before __tsan_init();
+  pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
+  __interceptor_pthread_mutex_lock(&mtx);
+  __interceptor_pthread_mutex_unlock(&mtx);
+  __interceptor_pthread_mutex_destroy(&mtx);
+  pthread_t thr;
+  __interceptor_pthread_create(&thr, 0, BeforeInitThread, 0);
+  __interceptor_pthread_join(thr, 0);
+  atexit(AtExit);
+}
+
+namespace __tsan {
+bool OnReport(const ReportDesc *rep, bool suppressed) {
+  if (expect_report) {
+    if (rep->typ != expect_report_type) {
+      printf("Expected report of type %d, got type %d\n",
+             (int)expect_report_type, (int)rep->typ);
+      EXPECT_FALSE("Wrong report type");
+      return false;
+    }
+  } else {
+    EXPECT_FALSE("Unexpected report");
+    return false;
+  }
+  expect_report_reported = true;
+  return true;
+}
+}  // namespace __tsan
+
+static void* allocate_addr(int size, int offset_from_aligned = 0) {
+  static uintptr_t foo;
+  static atomic_uintptr_t uniq = {(uintptr_t)&foo};  // Some real address.
+  const int kAlign = 16;
+  CHECK(offset_from_aligned < kAlign);
+  size = (size + 2 * kAlign) & ~(kAlign - 1);
+  uintptr_t addr = atomic_fetch_add(&uniq, size, memory_order_relaxed);
+  return (void*)(addr + offset_from_aligned);
+}
+
+MemLoc::MemLoc(int offset_from_aligned)
+  : loc_(allocate_addr(16, offset_from_aligned)) {
+}
+
+MemLoc::~MemLoc() {
+}
+
+Mutex::Mutex(Type type)
+  : alive_()
+  , type_(type) {
+}
+
+Mutex::~Mutex() {
+  CHECK(!alive_);
+}
+
+void Mutex::Init() {
+  CHECK(!alive_);
+  alive_ = true;
+  if (type_ == Normal)
+    CHECK_EQ(__interceptor_pthread_mutex_init((pthread_mutex_t*)mtx_, 0), 0);
+#ifndef __APPLE__
+  else if (type_ == Spin)
+    CHECK_EQ(pthread_spin_init((pthread_spinlock_t*)mtx_, 0), 0);
+#endif
+  else if (type_ == RW)
+    CHECK_EQ(__interceptor_pthread_rwlock_init((pthread_rwlock_t*)mtx_, 0), 0);
+  else
+    CHECK(0);
+}
+
+void Mutex::StaticInit() {
+  CHECK(!alive_);
+  CHECK(type_ == Normal);
+  alive_ = true;
+  pthread_mutex_t tmp = PTHREAD_MUTEX_INITIALIZER;
+  memcpy(mtx_, &tmp, sizeof(tmp));
+}
+
+void Mutex::Destroy() {
+  CHECK(alive_);
+  alive_ = false;
+  if (type_ == Normal)
+    CHECK_EQ(__interceptor_pthread_mutex_destroy((pthread_mutex_t*)mtx_), 0);
+#ifndef __APPLE__
+  else if (type_ == Spin)
+    CHECK_EQ(pthread_spin_destroy((pthread_spinlock_t*)mtx_), 0);
+#endif
+  else if (type_ == RW)
+    CHECK_EQ(__interceptor_pthread_rwlock_destroy((pthread_rwlock_t*)mtx_), 0);
+}
+
+void Mutex::Lock() {
+  CHECK(alive_);
+  if (type_ == Normal)
+    CHECK_EQ(__interceptor_pthread_mutex_lock((pthread_mutex_t*)mtx_), 0);
+#ifndef __APPLE__
+  else if (type_ == Spin)
+    CHECK_EQ(pthread_spin_lock((pthread_spinlock_t*)mtx_), 0);
+#endif
+  else if (type_ == RW)
+    CHECK_EQ(__interceptor_pthread_rwlock_wrlock((pthread_rwlock_t*)mtx_), 0);
+}
+
+bool Mutex::TryLock() {
+  CHECK(alive_);
+  if (type_ == Normal)
+    return __interceptor_pthread_mutex_trylock((pthread_mutex_t*)mtx_) == 0;
+#ifndef __APPLE__
+  else if (type_ == Spin)
+    return pthread_spin_trylock((pthread_spinlock_t*)mtx_) == 0;
+#endif
+  else if (type_ == RW)
+    return __interceptor_pthread_rwlock_trywrlock((pthread_rwlock_t*)mtx_) == 0;
+  return false;
+}
+
+void Mutex::Unlock() {
+  CHECK(alive_);
+  if (type_ == Normal)
+    CHECK_EQ(__interceptor_pthread_mutex_unlock((pthread_mutex_t*)mtx_), 0);
+#ifndef __APPLE__
+  else if (type_ == Spin)
+    CHECK_EQ(pthread_spin_unlock((pthread_spinlock_t*)mtx_), 0);
+#endif
+  else if (type_ == RW)
+    CHECK_EQ(__interceptor_pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
+}
+
+void Mutex::ReadLock() {
+  CHECK(alive_);
+  CHECK(type_ == RW);
+  CHECK_EQ(__interceptor_pthread_rwlock_rdlock((pthread_rwlock_t*)mtx_), 0);
+}
+
+bool Mutex::TryReadLock() {
+  CHECK(alive_);
+  CHECK(type_ == RW);
+  return __interceptor_pthread_rwlock_tryrdlock((pthread_rwlock_t*)mtx_) ==  0;
+}
+
+void Mutex::ReadUnlock() {
+  CHECK(alive_);
+  CHECK(type_ == RW);
+  CHECK_EQ(__interceptor_pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
+}
+
+struct Event {
+  enum Type {
+    SHUTDOWN,
+    READ,
+    WRITE,
+    VPTR_UPDATE,
+    CALL,
+    RETURN,
+    MUTEX_CREATE,
+    MUTEX_DESTROY,
+    MUTEX_LOCK,
+    MUTEX_TRYLOCK,
+    MUTEX_UNLOCK,
+    MUTEX_READLOCK,
+    MUTEX_TRYREADLOCK,
+    MUTEX_READUNLOCK,
+    MEMCPY,
+    MEMSET
+  };
+  Type type;
+  void *ptr;
+  uptr arg;
+  uptr arg2;
+  bool res;
+  bool expect_report;
+  ReportType report_type;
+
+  Event(Type type, const void *ptr = 0, uptr arg = 0, uptr arg2 = 0)
+    : type(type)
+    , ptr(const_cast<void*>(ptr))
+    , arg(arg)
+    , arg2(arg2)
+    , res()
+    , expect_report()
+    , report_type() {
+  }
+
+  void ExpectReport(ReportType type) {
+    expect_report = true;
+    report_type = type;
+  }
+};
+
+struct ScopedThread::Impl {
+  pthread_t thread;
+  bool main;
+  bool detached;
+  atomic_uintptr_t event;  // Event*
+
+  static void *ScopedThreadCallback(void *arg);
+  void send(Event *ev);
+  void HandleEvent(Event *ev);
+};
+
+void ScopedThread::Impl::HandleEvent(Event *ev) {
+  CHECK_EQ(expect_report, false);
+  expect_report = ev->expect_report;
+  expect_report_reported = false;
+  expect_report_type = ev->report_type;
+  switch (ev->type) {
+  case Event::READ:
+  case Event::WRITE: {
+    void (*tsan_mop)(void *addr) = 0;
+    if (ev->type == Event::READ) {
+      switch (ev->arg /*size*/) {
+        case 1: tsan_mop = __tsan_read1; break;
+        case 2: tsan_mop = __tsan_read2; break;
+        case 4: tsan_mop = __tsan_read4; break;
+        case 8: tsan_mop = __tsan_read8; break;
+        case 16: tsan_mop = __tsan_read16; break;
+      }
+    } else {
+      switch (ev->arg /*size*/) {
+        case 1: tsan_mop = __tsan_write1; break;
+        case 2: tsan_mop = __tsan_write2; break;
+        case 4: tsan_mop = __tsan_write4; break;
+        case 8: tsan_mop = __tsan_write8; break;
+        case 16: tsan_mop = __tsan_write16; break;
+      }
+    }
+    CHECK_NE(tsan_mop, 0);
+#if defined(__FreeBSD__) || defined(__APPLE__)
+    const int ErrCode = ESOCKTNOSUPPORT;
+#else
+    const int ErrCode = ECHRNG;
+#endif
+    errno = ErrCode;
+    tsan_mop(ev->ptr);
+    CHECK_EQ(ErrCode, errno);  // In no case must errno be changed.
+    break;
+  }
+  case Event::VPTR_UPDATE:
+    __tsan_vptr_update((void**)ev->ptr, (void*)ev->arg);
+    break;
+  case Event::CALL:
+    __tsan_func_entry((void*)((uptr)ev->ptr));
+    break;
+  case Event::RETURN:
+    __tsan_func_exit();
+    break;
+  case Event::MUTEX_CREATE:
+    static_cast<Mutex*>(ev->ptr)->Init();
+    break;
+  case Event::MUTEX_DESTROY:
+    static_cast<Mutex*>(ev->ptr)->Destroy();
+    break;
+  case Event::MUTEX_LOCK:
+    static_cast<Mutex*>(ev->ptr)->Lock();
+    break;
+  case Event::MUTEX_TRYLOCK:
+    ev->res = static_cast<Mutex*>(ev->ptr)->TryLock();
+    break;
+  case Event::MUTEX_UNLOCK:
+    static_cast<Mutex*>(ev->ptr)->Unlock();
+    break;
+  case Event::MUTEX_READLOCK:
+    static_cast<Mutex*>(ev->ptr)->ReadLock();
+    break;
+  case Event::MUTEX_TRYREADLOCK:
+    ev->res = static_cast<Mutex*>(ev->ptr)->TryReadLock();
+    break;
+  case Event::MUTEX_READUNLOCK:
+    static_cast<Mutex*>(ev->ptr)->ReadUnlock();
+    break;
+  case Event::MEMCPY:
+    __interceptor_memcpy(ev->ptr, (void*)ev->arg, ev->arg2);
+    break;
+  case Event::MEMSET:
+    __interceptor_memset(ev->ptr, ev->arg, ev->arg2);
+    break;
+  default: CHECK(0);
+  }
+  if (expect_report && !expect_report_reported) {
+    printf("Missed expected report of type %d\n", (int)ev->report_type);
+    EXPECT_FALSE("Missed expected race");
+  }
+  expect_report = false;
+}
+
+void *ScopedThread::Impl::ScopedThreadCallback(void *arg) {
+  __tsan_func_entry(__builtin_return_address(0));
+  Impl *impl = (Impl*)arg;
+  for (;;) {
+    Event* ev = (Event*)atomic_load(&impl->event, memory_order_acquire);
+    if (ev == 0) {
+      sched_yield();
+      continue;
+    }
+    if (ev->type == Event::SHUTDOWN) {
+      atomic_store(&impl->event, 0, memory_order_release);
+      break;
+    }
+    impl->HandleEvent(ev);
+    atomic_store(&impl->event, 0, memory_order_release);
+  }
+  __tsan_func_exit();
+  return 0;
+}
+
+void ScopedThread::Impl::send(Event *e) {
+  if (main) {
+    HandleEvent(e);
+  } else {
+    CHECK_EQ(atomic_load(&event, memory_order_relaxed), 0);
+    atomic_store(&event, (uintptr_t)e, memory_order_release);
+    while (atomic_load(&event, memory_order_acquire) != 0)
+      sched_yield();
+  }
+}
+
+ScopedThread::ScopedThread(bool detached, bool main) {
+  impl_ = new Impl;
+  impl_->main = main;
+  impl_->detached = detached;
+  atomic_store(&impl_->event, 0, memory_order_relaxed);
+  if (!main) {
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(
+        &attr, detached ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE);
+    pthread_attr_setstacksize(&attr, 64*1024);
+    __interceptor_pthread_create(&impl_->thread, &attr,
+        ScopedThread::Impl::ScopedThreadCallback, impl_);
+  }
+}
+
+ScopedThread::~ScopedThread() {
+  if (!impl_->main) {
+    Event event(Event::SHUTDOWN);
+    impl_->send(&event);
+    if (!impl_->detached)
+      __interceptor_pthread_join(impl_->thread, 0);
+  }
+  delete impl_;
+}
+
+void ScopedThread::Detach() {
+  CHECK(!impl_->main);
+  CHECK(!impl_->detached);
+  impl_->detached = true;
+  __interceptor_pthread_detach(impl_->thread);
+}
+
+void ScopedThread::Access(void *addr, bool is_write,
+                          int size, bool expect_race) {
+  Event event(is_write ? Event::WRITE : Event::READ, addr, size);
+  if (expect_race)
+    event.ExpectReport(ReportTypeRace);
+  impl_->send(&event);
+}
+
+void ScopedThread::VptrUpdate(const MemLoc &vptr,
+                              const MemLoc &new_val,
+                              bool expect_race) {
+  Event event(Event::VPTR_UPDATE, vptr.loc(), (uptr)new_val.loc());
+  if (expect_race)
+    event.ExpectReport(ReportTypeRace);
+  impl_->send(&event);
+}
+
+void ScopedThread::Call(void(*pc)()) {
+  Event event(Event::CALL, (void*)((uintptr_t)pc));
+  impl_->send(&event);
+}
+
+void ScopedThread::Return() {
+  Event event(Event::RETURN);
+  impl_->send(&event);
+}
+
+void ScopedThread::Create(const Mutex &m) {
+  Event event(Event::MUTEX_CREATE, &m);
+  impl_->send(&event);
+}
+
+void ScopedThread::Destroy(const Mutex &m) {
+  Event event(Event::MUTEX_DESTROY, &m);
+  impl_->send(&event);
+}
+
+void ScopedThread::Lock(const Mutex &m) {
+  Event event(Event::MUTEX_LOCK, &m);
+  impl_->send(&event);
+}
+
+bool ScopedThread::TryLock(const Mutex &m) {
+  Event event(Event::MUTEX_TRYLOCK, &m);
+  impl_->send(&event);
+  return event.res;
+}
+
+void ScopedThread::Unlock(const Mutex &m) {
+  Event event(Event::MUTEX_UNLOCK, &m);
+  impl_->send(&event);
+}
+
+void ScopedThread::ReadLock(const Mutex &m) {
+  Event event(Event::MUTEX_READLOCK, &m);
+  impl_->send(&event);
+}
+
+bool ScopedThread::TryReadLock(const Mutex &m) {
+  Event event(Event::MUTEX_TRYREADLOCK, &m);
+  impl_->send(&event);
+  return event.res;
+}
+
+void ScopedThread::ReadUnlock(const Mutex &m) {
+  Event event(Event::MUTEX_READUNLOCK, &m);
+  impl_->send(&event);
+}
+
+void ScopedThread::Memcpy(void *dst, const void *src, int size,
+                          bool expect_race) {
+  Event event(Event::MEMCPY, dst, (uptr)src, size);
+  if (expect_race)
+    event.ExpectReport(ReportTypeRace);
+  impl_->send(&event);
+}
+
+void ScopedThread::Memset(void *dst, int val, int size,
+                          bool expect_race) {
+  Event event(Event::MEMSET, dst, val, size);
+  if (expect_race)
+    event.ExpectReport(ReportTypeRace);
+  impl_->send(&event);
+}
diff --git a/compiler-rt/lib/tsan/tests/rtl/tsan_thread.cc b/compiler-rt/lib/tsan/tests/rtl/tsan_thread.cc
new file mode 100644
index 0000000..5646415
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/rtl/tsan_thread.cc
@@ -0,0 +1,59 @@
+//===-- tsan_thread.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_test_util.h"
+#include "gtest/gtest.h"
+
+TEST(ThreadSanitizer, ThreadSync) {
+  MainThread t0;
+  MemLoc l;
+  t0.Write1(l);
+  {
+    ScopedThread t1;
+    t1.Write1(l);
+  }
+  t0.Write1(l);
+}
+
+TEST(ThreadSanitizer, ThreadDetach1) {
+  ScopedThread t1(true);
+  MemLoc l;
+  t1.Write1(l);
+}
+
+TEST(ThreadSanitizer, ThreadDetach2) {
+  ScopedThread t1;
+  MemLoc l;
+  t1.Write1(l);
+  t1.Detach();
+}
+
+static void *thread_alot_func(void *arg) {
+  (void)arg;
+  int usleep(unsigned);
+  usleep(50);
+  return 0;
+}
+
+TEST(DISABLED_SLOW_ThreadSanitizer, ThreadALot) {
+  const int kThreads = 70000;
+  const int kAlive = 1000;
+  pthread_t threads[kAlive] = {};
+  for (int i = 0; i < kThreads; i++) {
+    if (threads[i % kAlive])
+      pthread_join(threads[i % kAlive], 0);
+    pthread_create(&threads[i % kAlive], 0, thread_alot_func, 0);
+  }
+  for (int i = 0; i < kAlive; i++) {
+    pthread_join(threads[i], 0);
+  }
+}
diff --git a/compiler-rt/lib/tsan/tests/unit/CMakeLists.txt b/compiler-rt/lib/tsan/tests/unit/CMakeLists.txt
new file mode 100644
index 0000000..6898f64
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/CMakeLists.txt
@@ -0,0 +1,13 @@
+set(TSAN_UNIT_TEST_SOURCES
+  tsan_clock_test.cc
+  tsan_flags_test.cc
+  tsan_mman_test.cc
+  tsan_mutex_test.cc
+  tsan_shadow_test.cc
+  tsan_stack_test.cc
+  tsan_sync_test.cc
+  tsan_unit_test_main.cc
+  tsan_vector_test.cc)
+
+add_tsan_unittest(TsanUnitTest
+  SOURCES ${TSAN_UNIT_TEST_SOURCES})
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_clock_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_clock_test.cc
new file mode 100644
index 0000000..83e25fb
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_clock_test.cc
@@ -0,0 +1,433 @@
+//===-- tsan_clock_test.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_clock.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+#include <sys/time.h>
+#include <time.h>
+
+namespace __tsan {
+
+ClockCache cache;
+
+TEST(Clock, VectorBasic) {
+  ThreadClock clk(0);
+  ASSERT_EQ(clk.size(), 1U);
+  clk.tick();
+  ASSERT_EQ(clk.size(), 1U);
+  ASSERT_EQ(clk.get(0), 1U);
+  clk.set(3, clk.get(3) + 1);
+  ASSERT_EQ(clk.size(), 4U);
+  ASSERT_EQ(clk.get(0), 1U);
+  ASSERT_EQ(clk.get(1), 0U);
+  ASSERT_EQ(clk.get(2), 0U);
+  ASSERT_EQ(clk.get(3), 1U);
+  clk.set(3, clk.get(3) + 1);
+  ASSERT_EQ(clk.get(3), 2U);
+}
+
+TEST(Clock, ChunkedBasic) {
+  ThreadClock vector(0);
+  SyncClock chunked;
+  ASSERT_EQ(vector.size(), 1U);
+  ASSERT_EQ(chunked.size(), 0U);
+  vector.acquire(&cache, &chunked);
+  ASSERT_EQ(vector.size(), 1U);
+  ASSERT_EQ(chunked.size(), 0U);
+  vector.release(&cache, &chunked);
+  ASSERT_EQ(vector.size(), 1U);
+  ASSERT_EQ(chunked.size(), 1U);
+  vector.acq_rel(&cache, &chunked);
+  ASSERT_EQ(vector.size(), 1U);
+  ASSERT_EQ(chunked.size(), 1U);
+  chunked.Reset(&cache);
+}
+
+TEST(Clock, AcquireRelease) {
+  ThreadClock vector1(100);
+  vector1.tick();
+  SyncClock chunked;
+  vector1.release(&cache, &chunked);
+  ASSERT_EQ(chunked.size(), 101U);
+  ThreadClock vector2(0);
+  vector2.acquire(&cache, &chunked);
+  ASSERT_EQ(vector2.size(), 101U);
+  ASSERT_EQ(vector2.get(0), 0U);
+  ASSERT_EQ(vector2.get(1), 0U);
+  ASSERT_EQ(vector2.get(99), 0U);
+  ASSERT_EQ(vector2.get(100), 1U);
+  chunked.Reset(&cache);
+}
+
+TEST(Clock, RepeatedAcquire) {
+  ThreadClock thr1(1);
+  thr1.tick();
+  ThreadClock thr2(2);
+  thr2.tick();
+
+  SyncClock sync;
+  thr1.ReleaseStore(&cache, &sync);
+
+  thr2.acquire(&cache, &sync);
+  thr2.acquire(&cache, &sync);
+
+  sync.Reset(&cache);
+}
+
+TEST(Clock, ManyThreads) {
+  SyncClock chunked;
+  for (unsigned i = 0; i < 100; i++) {
+    ThreadClock vector(0);
+    vector.tick();
+    vector.set(i, 1);
+    vector.release(&cache, &chunked);
+    ASSERT_EQ(i + 1, chunked.size());
+    vector.acquire(&cache, &chunked);
+    ASSERT_EQ(i + 1, vector.size());
+  }
+
+  for (unsigned i = 0; i < 100; i++)
+    ASSERT_EQ(1U, chunked.get(i));
+
+  ThreadClock vector(1);
+  vector.acquire(&cache, &chunked);
+  ASSERT_EQ(100U, vector.size());
+  for (unsigned i = 0; i < 100; i++)
+    ASSERT_EQ(1U, vector.get(i));
+
+  chunked.Reset(&cache);
+}
+
+TEST(Clock, DifferentSizes) {
+  {
+    ThreadClock vector1(10);
+    vector1.tick();
+    ThreadClock vector2(20);
+    vector2.tick();
+    {
+      SyncClock chunked;
+      vector1.release(&cache, &chunked);
+      ASSERT_EQ(chunked.size(), 11U);
+      vector2.release(&cache, &chunked);
+      ASSERT_EQ(chunked.size(), 21U);
+      chunked.Reset(&cache);
+    }
+    {
+      SyncClock chunked;
+      vector2.release(&cache, &chunked);
+      ASSERT_EQ(chunked.size(), 21U);
+      vector1.release(&cache, &chunked);
+      ASSERT_EQ(chunked.size(), 21U);
+      chunked.Reset(&cache);
+    }
+    {
+      SyncClock chunked;
+      vector1.release(&cache, &chunked);
+      vector2.acquire(&cache, &chunked);
+      ASSERT_EQ(vector2.size(), 21U);
+      chunked.Reset(&cache);
+    }
+    {
+      SyncClock chunked;
+      vector2.release(&cache, &chunked);
+      vector1.acquire(&cache, &chunked);
+      ASSERT_EQ(vector1.size(), 21U);
+      chunked.Reset(&cache);
+    }
+  }
+}
+
+TEST(Clock, Growth) {
+  {
+    ThreadClock vector(10);
+    vector.tick();
+    vector.set(5, 42);
+    SyncClock sync;
+    vector.release(&cache, &sync);
+    ASSERT_EQ(sync.size(), 11U);
+    ASSERT_EQ(sync.get(0), 0ULL);
+    ASSERT_EQ(sync.get(1), 0ULL);
+    ASSERT_EQ(sync.get(5), 42ULL);
+    ASSERT_EQ(sync.get(9), 0ULL);
+    ASSERT_EQ(sync.get(10), 1ULL);
+    sync.Reset(&cache);
+  }
+  {
+    ThreadClock vector1(10);
+    vector1.tick();
+    ThreadClock vector2(20);
+    vector2.tick();
+    SyncClock sync;
+    vector1.release(&cache, &sync);
+    vector2.release(&cache, &sync);
+    ASSERT_EQ(sync.size(), 21U);
+    ASSERT_EQ(sync.get(0), 0ULL);
+    ASSERT_EQ(sync.get(10), 1ULL);
+    ASSERT_EQ(sync.get(19), 0ULL);
+    ASSERT_EQ(sync.get(20), 1ULL);
+    sync.Reset(&cache);
+  }
+  {
+    ThreadClock vector(100);
+    vector.tick();
+    vector.set(5, 42);
+    vector.set(90, 84);
+    SyncClock sync;
+    vector.release(&cache, &sync);
+    ASSERT_EQ(sync.size(), 101U);
+    ASSERT_EQ(sync.get(0), 0ULL);
+    ASSERT_EQ(sync.get(1), 0ULL);
+    ASSERT_EQ(sync.get(5), 42ULL);
+    ASSERT_EQ(sync.get(60), 0ULL);
+    ASSERT_EQ(sync.get(70), 0ULL);
+    ASSERT_EQ(sync.get(90), 84ULL);
+    ASSERT_EQ(sync.get(99), 0ULL);
+    ASSERT_EQ(sync.get(100), 1ULL);
+    sync.Reset(&cache);
+  }
+  {
+    ThreadClock vector1(10);
+    vector1.tick();
+    ThreadClock vector2(100);
+    vector2.tick();
+    SyncClock sync;
+    vector1.release(&cache, &sync);
+    vector2.release(&cache, &sync);
+    ASSERT_EQ(sync.size(), 101U);
+    ASSERT_EQ(sync.get(0), 0ULL);
+    ASSERT_EQ(sync.get(10), 1ULL);
+    ASSERT_EQ(sync.get(99), 0ULL);
+    ASSERT_EQ(sync.get(100), 1ULL);
+    sync.Reset(&cache);
+  }
+}
+
+const uptr kThreads = 4;
+const uptr kClocks = 4;
+
+// SimpleSyncClock and SimpleThreadClock implement the same thing as
+// SyncClock and ThreadClock, but in a very simple way.
+struct SimpleSyncClock {
+  u64 clock[kThreads];
+  uptr size;
+
+  SimpleSyncClock() {
+    Reset();
+  }
+
+  void Reset() {
+    size = 0;
+    for (uptr i = 0; i < kThreads; i++)
+      clock[i] = 0;
+  }
+
+  bool verify(const SyncClock *other) const {
+    for (uptr i = 0; i < min(size, other->size()); i++) {
+      if (clock[i] != other->get(i))
+        return false;
+    }
+    for (uptr i = min(size, other->size()); i < max(size, other->size()); i++) {
+      if (i < size && clock[i] != 0)
+        return false;
+      if (i < other->size() && other->get(i) != 0)
+        return false;
+    }
+    return true;
+  }
+};
+
+struct SimpleThreadClock {
+  u64 clock[kThreads];
+  uptr size;
+  unsigned tid;
+
+  explicit SimpleThreadClock(unsigned tid) {
+    this->tid = tid;
+    size = tid + 1;
+    for (uptr i = 0; i < kThreads; i++)
+      clock[i] = 0;
+  }
+
+  void tick() {
+    clock[tid]++;
+  }
+
+  void acquire(const SimpleSyncClock *src) {
+    if (size < src->size)
+      size = src->size;
+    for (uptr i = 0; i < kThreads; i++)
+      clock[i] = max(clock[i], src->clock[i]);
+  }
+
+  void release(SimpleSyncClock *dst) const {
+    if (dst->size < size)
+      dst->size = size;
+    for (uptr i = 0; i < kThreads; i++)
+      dst->clock[i] = max(dst->clock[i], clock[i]);
+  }
+
+  void acq_rel(SimpleSyncClock *dst) {
+    acquire(dst);
+    release(dst);
+  }
+
+  void ReleaseStore(SimpleSyncClock *dst) const {
+    if (dst->size < size)
+      dst->size = size;
+    for (uptr i = 0; i < kThreads; i++)
+      dst->clock[i] = clock[i];
+  }
+
+  bool verify(const ThreadClock *other) const {
+    for (uptr i = 0; i < min(size, other->size()); i++) {
+      if (clock[i] != other->get(i))
+        return false;
+    }
+    for (uptr i = min(size, other->size()); i < max(size, other->size()); i++) {
+      if (i < size && clock[i] != 0)
+        return false;
+      if (i < other->size() && other->get(i) != 0)
+        return false;
+    }
+    return true;
+  }
+};
+
+static bool ClockFuzzer(bool printing) {
+  // Create kThreads thread clocks.
+  SimpleThreadClock *thr0[kThreads];
+  ThreadClock *thr1[kThreads];
+  unsigned reused[kThreads];
+  for (unsigned i = 0; i < kThreads; i++) {
+    reused[i] = 0;
+    thr0[i] = new SimpleThreadClock(i);
+    thr1[i] = new ThreadClock(i, reused[i]);
+  }
+
+  // Create kClocks sync clocks.
+  SimpleSyncClock *sync0[kClocks];
+  SyncClock *sync1[kClocks];
+  for (unsigned i = 0; i < kClocks; i++) {
+    sync0[i] = new SimpleSyncClock();
+    sync1[i] = new SyncClock();
+  }
+
+  // Do N random operations (acquire, release, etc) and compare results
+  // for SimpleThread/SyncClock and real Thread/SyncClock.
+  for (int i = 0; i < 10000; i++) {
+    unsigned tid = rand() % kThreads;
+    unsigned cid = rand() % kClocks;
+    thr0[tid]->tick();
+    thr1[tid]->tick();
+
+    switch (rand() % 6) {
+    case 0:
+      if (printing)
+        printf("acquire thr%d <- clk%d\n", tid, cid);
+      thr0[tid]->acquire(sync0[cid]);
+      thr1[tid]->acquire(&cache, sync1[cid]);
+      break;
+    case 1:
+      if (printing)
+        printf("release thr%d -> clk%d\n", tid, cid);
+      thr0[tid]->release(sync0[cid]);
+      thr1[tid]->release(&cache, sync1[cid]);
+      break;
+    case 2:
+      if (printing)
+        printf("acq_rel thr%d <> clk%d\n", tid, cid);
+      thr0[tid]->acq_rel(sync0[cid]);
+      thr1[tid]->acq_rel(&cache, sync1[cid]);
+      break;
+    case 3:
+      if (printing)
+        printf("rel_str thr%d >> clk%d\n", tid, cid);
+      thr0[tid]->ReleaseStore(sync0[cid]);
+      thr1[tid]->ReleaseStore(&cache, sync1[cid]);
+      break;
+    case 4:
+      if (printing)
+        printf("reset clk%d\n", cid);
+      sync0[cid]->Reset();
+      sync1[cid]->Reset(&cache);
+      break;
+    case 5:
+      if (printing)
+        printf("reset thr%d\n", tid);
+      u64 epoch = thr0[tid]->clock[tid] + 1;
+      reused[tid]++;
+      delete thr0[tid];
+      thr0[tid] = new SimpleThreadClock(tid);
+      thr0[tid]->clock[tid] = epoch;
+      delete thr1[tid];
+      thr1[tid] = new ThreadClock(tid, reused[tid]);
+      thr1[tid]->set(epoch);
+      break;
+    }
+
+    if (printing) {
+      for (unsigned i = 0; i < kThreads; i++) {
+        printf("thr%d: ", i);
+        thr1[i]->DebugDump(printf);
+        printf("\n");
+      }
+      for (unsigned i = 0; i < kClocks; i++) {
+        printf("clk%d: ", i);
+        sync1[i]->DebugDump(printf);
+        printf("\n");
+      }
+
+      printf("\n");
+    }
+
+    if (!thr0[tid]->verify(thr1[tid]) || !sync0[cid]->verify(sync1[cid])) {
+      if (!printing)
+        return false;
+      printf("differs with model:\n");
+      for (unsigned i = 0; i < kThreads; i++) {
+        printf("thr%d: clock=[", i);
+        for (uptr j = 0; j < thr0[i]->size; j++)
+          printf("%s%llu", j == 0 ? "" : ",", thr0[i]->clock[j]);
+        printf("]\n");
+      }
+      for (unsigned i = 0; i < kClocks; i++) {
+        printf("clk%d: clock=[", i);
+        for (uptr j = 0; j < sync0[i]->size; j++)
+          printf("%s%llu", j == 0 ? "" : ",", sync0[i]->clock[j]);
+        printf("]\n");
+      }
+      return false;
+    }
+  }
+
+  for (unsigned i = 0; i < kClocks; i++) {
+    sync1[i]->Reset(&cache);
+  }
+  return true;
+}
+
+TEST(Clock, Fuzzer) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  int seed = tv.tv_sec + tv.tv_usec;
+  printf("seed=%d\n", seed);
+  srand(seed);
+  if (!ClockFuzzer(false)) {
+    // Redo the test with the same seed, but logging operations.
+    srand(seed);
+    ClockFuzzer(true);
+    ASSERT_TRUE(false);
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_dense_alloc_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_dense_alloc_test.cc
new file mode 100644
index 0000000..e848e48
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_dense_alloc_test.cc
@@ -0,0 +1,55 @@
+//===-- tsan_dense_alloc_test.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_dense_alloc.h"
+#include "tsan_rtl.h"
+#include "tsan_mman.h"
+#include "gtest/gtest.h"
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <map>
+
+namespace __tsan {
+
+TEST(DenseSlabAlloc, Basic) {
+  typedef DenseSlabAlloc<int, 128, 128> Alloc;
+  typedef Alloc::Cache Cache;
+  typedef Alloc::IndexT IndexT;
+  const int N = 1000;
+
+  Alloc alloc;
+  Cache cache;
+  alloc.InitCache(&cache);
+
+  IndexT blocks[N];
+  for (int ntry = 0; ntry < 3; ntry++) {
+    for (int i = 0; i < N; i++) {
+      IndexT idx = alloc.Alloc(&cache);
+      blocks[i] = idx;
+      EXPECT_NE(idx, 0U);
+      int *v = alloc.Map(idx);
+      *v = i;
+    }
+
+    for (int i = 0; i < N; i++) {
+      IndexT idx = blocks[i];
+      int *v = alloc.Map(idx);
+      EXPECT_EQ(*v, i);
+      alloc.Free(&cache, idx);
+    }
+
+    alloc.FlushCache(&cache);
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_flags_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_flags_test.cc
new file mode 100644
index 0000000..aa8a024
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_flags_test.cc
@@ -0,0 +1,174 @@
+//===-- tsan_flags_test.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_flags.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+#include <string>
+
+namespace __tsan {
+
+TEST(Flags, Basic) {
+  // At least should not crash.
+  Flags f;
+  InitializeFlags(&f, 0);
+  InitializeFlags(&f, "");
+}
+
+TEST(Flags, DefaultValues) {
+  Flags f;
+
+  f.enable_annotations = false;
+  InitializeFlags(&f, "");
+  EXPECT_EQ(true, f.enable_annotations);
+}
+
+static const char *options1 =
+  " enable_annotations=0"
+  " suppress_equal_stacks=0"
+  " suppress_equal_addresses=0"
+  " report_bugs=0"
+  " report_thread_leaks=0"
+  " report_destroy_locked=0"
+  " report_mutex_bugs=0"
+  " report_signal_unsafe=0"
+  " report_atomic_races=0"
+  " force_seq_cst_atomics=0"
+  " print_benign=0"
+  " halt_on_error=0"
+  " atexit_sleep_ms=222"
+  " profile_memory=qqq"
+  " flush_memory_ms=444"
+  " flush_symbolizer_ms=555"
+  " memory_limit_mb=666"
+  " stop_on_start=0"
+  " running_on_valgrind=0"
+  " history_size=5"
+  " io_sync=1"
+  " die_after_fork=true"
+  "";
+
+static const char *options2 =
+  " enable_annotations=true"
+  " suppress_equal_stacks=true"
+  " suppress_equal_addresses=true"
+  " report_bugs=true"
+  " report_thread_leaks=true"
+  " report_destroy_locked=true"
+  " report_mutex_bugs=true"
+  " report_signal_unsafe=true"
+  " report_atomic_races=true"
+  " force_seq_cst_atomics=true"
+  " print_benign=true"
+  " halt_on_error=true"
+  " atexit_sleep_ms=123"
+  " profile_memory=bbbbb"
+  " flush_memory_ms=234"
+  " flush_symbolizer_ms=345"
+  " memory_limit_mb=456"
+  " stop_on_start=true"
+  " running_on_valgrind=true"
+  " history_size=6"
+  " io_sync=2"
+  " die_after_fork=false"
+  "";
+
+void VerifyOptions1(Flags *f) {
+  EXPECT_EQ(f->enable_annotations, 0);
+  EXPECT_EQ(f->suppress_equal_stacks, 0);
+  EXPECT_EQ(f->suppress_equal_addresses, 0);
+  EXPECT_EQ(f->report_bugs, 0);
+  EXPECT_EQ(f->report_thread_leaks, 0);
+  EXPECT_EQ(f->report_destroy_locked, 0);
+  EXPECT_EQ(f->report_mutex_bugs, 0);
+  EXPECT_EQ(f->report_signal_unsafe, 0);
+  EXPECT_EQ(f->report_atomic_races, 0);
+  EXPECT_EQ(f->force_seq_cst_atomics, 0);
+  EXPECT_EQ(f->print_benign, 0);
+  EXPECT_EQ(f->halt_on_error, 0);
+  EXPECT_EQ(f->atexit_sleep_ms, 222);
+  EXPECT_EQ(f->profile_memory, std::string("qqq"));
+  EXPECT_EQ(f->flush_memory_ms, 444);
+  EXPECT_EQ(f->flush_symbolizer_ms, 555);
+  EXPECT_EQ(f->memory_limit_mb, 666);
+  EXPECT_EQ(f->stop_on_start, 0);
+  EXPECT_EQ(f->running_on_valgrind, 0);
+  EXPECT_EQ(f->history_size, 5);
+  EXPECT_EQ(f->io_sync, 1);
+  EXPECT_EQ(f->die_after_fork, true);
+}
+
+void VerifyOptions2(Flags *f) {
+  EXPECT_EQ(f->enable_annotations, true);
+  EXPECT_EQ(f->suppress_equal_stacks, true);
+  EXPECT_EQ(f->suppress_equal_addresses, true);
+  EXPECT_EQ(f->report_bugs, true);
+  EXPECT_EQ(f->report_thread_leaks, true);
+  EXPECT_EQ(f->report_destroy_locked, true);
+  EXPECT_EQ(f->report_mutex_bugs, true);
+  EXPECT_EQ(f->report_signal_unsafe, true);
+  EXPECT_EQ(f->report_atomic_races, true);
+  EXPECT_EQ(f->force_seq_cst_atomics, true);
+  EXPECT_EQ(f->print_benign, true);
+  EXPECT_EQ(f->halt_on_error, true);
+  EXPECT_EQ(f->atexit_sleep_ms, 123);
+  EXPECT_EQ(f->profile_memory, std::string("bbbbb"));
+  EXPECT_EQ(f->flush_memory_ms, 234);
+  EXPECT_EQ(f->flush_symbolizer_ms, 345);
+  EXPECT_EQ(f->memory_limit_mb, 456);
+  EXPECT_EQ(f->stop_on_start, true);
+  EXPECT_EQ(f->running_on_valgrind, true);
+  EXPECT_EQ(f->history_size, 6);
+  EXPECT_EQ(f->io_sync, 2);
+  EXPECT_EQ(f->die_after_fork, false);
+}
+
+static const char *test_default_options;
+extern "C" const char *__tsan_default_options() {
+  return test_default_options;
+}
+
+TEST(Flags, ParseDefaultOptions) {
+  Flags f;
+
+  test_default_options = options1;
+  InitializeFlags(&f, "");
+  VerifyOptions1(&f);
+
+  test_default_options = options2;
+  InitializeFlags(&f, "");
+  VerifyOptions2(&f);
+}
+
+TEST(Flags, ParseEnvOptions) {
+  Flags f;
+
+  InitializeFlags(&f, options1);
+  VerifyOptions1(&f);
+
+  InitializeFlags(&f, options2);
+  VerifyOptions2(&f);
+}
+
+TEST(Flags, ParsePriority) {
+  Flags f;
+
+  test_default_options = options2;
+  InitializeFlags(&f, options1);
+  VerifyOptions1(&f);
+
+  test_default_options = options1;
+  InitializeFlags(&f, options2);
+  VerifyOptions2(&f);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_mman_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_mman_test.cc
new file mode 100644
index 0000000..609141c
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_mman_test.cc
@@ -0,0 +1,155 @@
+//===-- tsan_mman_test.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include <limits>
+#include <sanitizer/allocator_interface.h>
+#include "tsan_mman.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+
+namespace __tsan {
+
+TEST(Mman, Internal) {
+  char *p = (char*)internal_alloc(MBlockScopedBuf, 10);
+  EXPECT_NE(p, (char*)0);
+  char *p2 = (char*)internal_alloc(MBlockScopedBuf, 20);
+  EXPECT_NE(p2, (char*)0);
+  EXPECT_NE(p2, p);
+  for (int i = 0; i < 10; i++) {
+    p[i] = 42;
+  }
+  for (int i = 0; i < 20; i++) {
+    ((char*)p2)[i] = 42;
+  }
+  internal_free(p);
+  internal_free(p2);
+}
+
+TEST(Mman, User) {
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
+  char *p = (char*)user_alloc(thr, pc, 10);
+  EXPECT_NE(p, (char*)0);
+  char *p2 = (char*)user_alloc(thr, pc, 20);
+  EXPECT_NE(p2, (char*)0);
+  EXPECT_NE(p2, p);
+  EXPECT_EQ(10U, user_alloc_usable_size(p));
+  EXPECT_EQ(20U, user_alloc_usable_size(p2));
+  user_free(thr, pc, p);
+  user_free(thr, pc, p2);
+}
+
+TEST(Mman, UserRealloc) {
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
+  {
+    void *p = user_realloc(thr, pc, 0, 0);
+    // Strictly saying this is incorrect, realloc(NULL, N) is equivalent to
+    // malloc(N), thus must return non-NULL pointer.
+    EXPECT_EQ(p, (void*)0);
+  }
+  {
+    void *p = user_realloc(thr, pc, 0, 100);
+    EXPECT_NE(p, (void*)0);
+    memset(p, 0xde, 100);
+    user_free(thr, pc, p);
+  }
+  {
+    void *p = user_alloc(thr, pc, 100);
+    EXPECT_NE(p, (void*)0);
+    memset(p, 0xde, 100);
+    void *p2 = user_realloc(thr, pc, p, 0);
+    EXPECT_EQ(p2, (void*)0);
+  }
+  {
+    void *p = user_realloc(thr, pc, 0, 100);
+    EXPECT_NE(p, (void*)0);
+    memset(p, 0xde, 100);
+    void *p2 = user_realloc(thr, pc, p, 10000);
+    EXPECT_NE(p2, (void*)0);
+    for (int i = 0; i < 100; i++)
+      EXPECT_EQ(((char*)p2)[i], (char)0xde);
+    memset(p2, 0xde, 10000);
+    user_free(thr, pc, p2);
+  }
+  {
+    void *p = user_realloc(thr, pc, 0, 10000);
+    EXPECT_NE(p, (void*)0);
+    memset(p, 0xde, 10000);
+    void *p2 = user_realloc(thr, pc, p, 10);
+    EXPECT_NE(p2, (void*)0);
+    for (int i = 0; i < 10; i++)
+      EXPECT_EQ(((char*)p2)[i], (char)0xde);
+    user_free(thr, pc, p2);
+  }
+}
+
+TEST(Mman, UsableSize) {
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
+  char *p = (char*)user_alloc(thr, pc, 10);
+  char *p2 = (char*)user_alloc(thr, pc, 20);
+  EXPECT_EQ(0U, user_alloc_usable_size(NULL));
+  EXPECT_EQ(10U, user_alloc_usable_size(p));
+  EXPECT_EQ(20U, user_alloc_usable_size(p2));
+  user_free(thr, pc, p);
+  user_free(thr, pc, p2);
+  EXPECT_EQ(0U, user_alloc_usable_size((void*)0x4123));
+}
+
+TEST(Mman, Stats) {
+  ThreadState *thr = cur_thread();
+
+  uptr alloc0 = __sanitizer_get_current_allocated_bytes();
+  uptr heap0 = __sanitizer_get_heap_size();
+  uptr free0 = __sanitizer_get_free_bytes();
+  uptr unmapped0 = __sanitizer_get_unmapped_bytes();
+
+  EXPECT_EQ(10U, __sanitizer_get_estimated_allocated_size(10));
+  EXPECT_EQ(20U, __sanitizer_get_estimated_allocated_size(20));
+  EXPECT_EQ(100U, __sanitizer_get_estimated_allocated_size(100));
+
+  char *p = (char*)user_alloc(thr, 0, 10);
+  EXPECT_TRUE(__sanitizer_get_ownership(p));
+  EXPECT_EQ(10U, __sanitizer_get_allocated_size(p));
+
+  EXPECT_EQ(alloc0 + 16, __sanitizer_get_current_allocated_bytes());
+  EXPECT_GE(__sanitizer_get_heap_size(), heap0);
+  EXPECT_EQ(free0, __sanitizer_get_free_bytes());
+  EXPECT_EQ(unmapped0, __sanitizer_get_unmapped_bytes());
+
+  user_free(thr, 0, p);
+
+  EXPECT_EQ(alloc0, __sanitizer_get_current_allocated_bytes());
+  EXPECT_GE(__sanitizer_get_heap_size(), heap0);
+  EXPECT_EQ(free0, __sanitizer_get_free_bytes());
+  EXPECT_EQ(unmapped0, __sanitizer_get_unmapped_bytes());
+}
+
+TEST(Mman, CallocOverflow) {
+#if SANITIZER_DEBUG
+  // EXPECT_DEATH clones a thread with 4K stack,
+  // which is overflown by tsan memory accesses functions in debug mode.
+  return;
+#endif
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
+  size_t kArraySize = 4096;
+  volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max();
+  volatile size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
+  volatile void *p = NULL;
+  EXPECT_DEATH(p = user_calloc(thr, pc, kArraySize, kArraySize2),
+               "allocator is terminating the process instead of returning 0");
+  EXPECT_EQ(0L, p);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_mutex_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_mutex_test.cc
new file mode 100644
index 0000000..cce7f07
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_mutex_test.cc
@@ -0,0 +1,126 @@
+//===-- tsan_mutex_test.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "tsan_mutex.h"
+#include "gtest/gtest.h"
+
+namespace __tsan {
+
+template<typename MutexType>
+class TestData {
+ public:
+  explicit TestData(MutexType *mtx)
+    : mtx_(mtx) {
+    for (int i = 0; i < kSize; i++)
+      data_[i] = 0;
+  }
+
+  void Write() {
+    Lock l(mtx_);
+    T v0 = data_[0];
+    for (int i = 0; i < kSize; i++) {
+      CHECK_EQ(data_[i], v0);
+      data_[i]++;
+    }
+  }
+
+  void Read() {
+    ReadLock l(mtx_);
+    T v0 = data_[0];
+    for (int i = 0; i < kSize; i++) {
+      CHECK_EQ(data_[i], v0);
+    }
+  }
+
+  void Backoff() {
+    volatile T data[kSize] = {};
+    for (int i = 0; i < kSize; i++) {
+      data[i]++;
+      CHECK_EQ(data[i], 1);
+    }
+  }
+
+ private:
+  typedef GenericScopedLock<MutexType> Lock;
+  static const int kSize = 64;
+  typedef u64 T;
+  MutexType *mtx_;
+  char pad_[kCacheLineSize];
+  T data_[kSize];
+};
+
+const int kThreads = 8;
+const int kWriteRate = 1024;
+#if SANITIZER_DEBUG
+const int kIters = 16*1024;
+#else
+const int kIters = 64*1024;
+#endif
+
+template<typename MutexType>
+static void *write_mutex_thread(void *param) {
+  TestData<MutexType> *data = (TestData<MutexType>*)param;
+  for (int i = 0; i < kIters; i++) {
+    data->Write();
+    data->Backoff();
+  }
+  return 0;
+}
+
+template<typename MutexType>
+static void *read_mutex_thread(void *param) {
+  TestData<MutexType> *data = (TestData<MutexType>*)param;
+  for (int i = 0; i < kIters; i++) {
+    if ((i % kWriteRate) == 0)
+      data->Write();
+    else
+      data->Read();
+    data->Backoff();
+  }
+  return 0;
+}
+
+TEST(Mutex, Write) {
+  Mutex mtx(MutexTypeAnnotations, StatMtxAnnotations);
+  TestData<Mutex> data(&mtx);
+  pthread_t threads[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    pthread_create(&threads[i], 0, write_mutex_thread<Mutex>, &data);
+  for (int i = 0; i < kThreads; i++)
+    pthread_join(threads[i], 0);
+}
+
+TEST(Mutex, ReadWrite) {
+  Mutex mtx(MutexTypeAnnotations, StatMtxAnnotations);
+  TestData<Mutex> data(&mtx);
+  pthread_t threads[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    pthread_create(&threads[i], 0, read_mutex_thread<Mutex>, &data);
+  for (int i = 0; i < kThreads; i++)
+    pthread_join(threads[i], 0);
+}
+
+TEST(Mutex, SpinWrite) {
+  SpinMutex mtx;
+  TestData<SpinMutex> data(&mtx);
+  pthread_t threads[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    pthread_create(&threads[i], 0, write_mutex_thread<SpinMutex>, &data);
+  for (int i = 0; i < kThreads; i++)
+    pthread_join(threads[i], 0);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_mutexset_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_mutexset_test.cc
new file mode 100644
index 0000000..335a774
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_mutexset_test.cc
@@ -0,0 +1,127 @@
+//===-- tsan_mutexset_test.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_mutexset.h"
+#include "gtest/gtest.h"
+
+namespace __tsan {
+
+static void Expect(const MutexSet &mset, uptr i, u64 id, bool write, u64 epoch,
+    int count) {
+  MutexSet::Desc d = mset.Get(i);
+  EXPECT_EQ(id, d.id);
+  EXPECT_EQ(write, d.write);
+  EXPECT_EQ(epoch, d.epoch);
+  EXPECT_EQ(count, d.count);
+}
+
+TEST(MutexSet, Basic) {
+  MutexSet mset;
+  EXPECT_EQ(mset.Size(), (uptr)0);
+
+  mset.Add(1, true, 2);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  Expect(mset, 0, 1, true, 2, 1);
+  mset.Del(1, true);
+  EXPECT_EQ(mset.Size(), (uptr)0);
+
+  mset.Add(3, true, 4);
+  mset.Add(5, false, 6);
+  EXPECT_EQ(mset.Size(), (uptr)2);
+  Expect(mset, 0, 3, true, 4, 1);
+  Expect(mset, 1, 5, false, 6, 1);
+  mset.Del(3, true);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  mset.Del(5, false);
+  EXPECT_EQ(mset.Size(), (uptr)0);
+}
+
+TEST(MutexSet, DoubleAdd) {
+  MutexSet mset;
+  mset.Add(1, true, 2);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  Expect(mset, 0, 1, true, 2, 1);
+
+  mset.Add(1, true, 2);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  Expect(mset, 0, 1, true, 2, 2);
+
+  mset.Del(1, true);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  Expect(mset, 0, 1, true, 2, 1);
+
+  mset.Del(1, true);
+  EXPECT_EQ(mset.Size(), (uptr)0);
+}
+
+TEST(MutexSet, DoubleDel) {
+  MutexSet mset;
+  mset.Add(1, true, 2);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  mset.Del(1, true);
+  EXPECT_EQ(mset.Size(), (uptr)0);
+  mset.Del(1, true);
+  EXPECT_EQ(mset.Size(), (uptr)0);
+}
+
+TEST(MutexSet, Remove) {
+  MutexSet mset;
+  mset.Add(1, true, 2);
+  mset.Add(1, true, 2);
+  mset.Add(3, true, 4);
+  mset.Add(3, true, 4);
+  EXPECT_EQ(mset.Size(), (uptr)2);
+
+  mset.Remove(1);
+  EXPECT_EQ(mset.Size(), (uptr)1);
+  Expect(mset, 0, 3, true, 4, 2);
+}
+
+TEST(MutexSet, Full) {
+  MutexSet mset;
+  for (uptr i = 0; i < MutexSet::kMaxSize; i++) {
+    mset.Add(i, true, i + 1);
+  }
+  EXPECT_EQ(mset.Size(), MutexSet::kMaxSize);
+  for (uptr i = 0; i < MutexSet::kMaxSize; i++) {
+    Expect(mset, i, i, true, i + 1, 1);
+  }
+
+  for (uptr i = 0; i < MutexSet::kMaxSize; i++) {
+    mset.Add(i, true, i + 1);
+  }
+  EXPECT_EQ(mset.Size(), MutexSet::kMaxSize);
+  for (uptr i = 0; i < MutexSet::kMaxSize; i++) {
+    Expect(mset, i, i, true, i + 1, 2);
+  }
+}
+
+TEST(MutexSet, Overflow) {
+  MutexSet mset;
+  for (uptr i = 0; i < MutexSet::kMaxSize; i++) {
+    mset.Add(i, true, i + 1);
+    mset.Add(i, true, i + 1);
+  }
+  mset.Add(100, true, 200);
+  EXPECT_EQ(mset.Size(), MutexSet::kMaxSize);
+  for (uptr i = 0; i < MutexSet::kMaxSize; i++) {
+    if (i == 0)
+      Expect(mset, i, MutexSet::kMaxSize - 1,
+             true, MutexSet::kMaxSize, 2);
+    else if (i == MutexSet::kMaxSize - 1)
+      Expect(mset, i, 100, true, 200, 1);
+    else
+      Expect(mset, i, i, true, i + 1, 2);
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_shadow_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_shadow_test.cc
new file mode 100644
index 0000000..17b1797
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_shadow_test.cc
@@ -0,0 +1,78 @@
+//===-- tsan_shadow_test.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+
+namespace __tsan {
+
+TEST(Shadow, FastState) {
+  Shadow s(FastState(11, 22));
+  EXPECT_EQ(s.tid(), (u64)11);
+  EXPECT_EQ(s.epoch(), (u64)22);
+  EXPECT_EQ(s.GetIgnoreBit(), false);
+  EXPECT_EQ(s.GetFreedAndReset(), false);
+  EXPECT_EQ(s.GetHistorySize(), 0);
+  EXPECT_EQ(s.addr0(), (u64)0);
+  EXPECT_EQ(s.size(), (u64)1);
+  EXPECT_EQ(s.IsWrite(), true);
+
+  s.IncrementEpoch();
+  EXPECT_EQ(s.epoch(), (u64)23);
+  s.IncrementEpoch();
+  EXPECT_EQ(s.epoch(), (u64)24);
+
+  s.SetIgnoreBit();
+  EXPECT_EQ(s.GetIgnoreBit(), true);
+  s.ClearIgnoreBit();
+  EXPECT_EQ(s.GetIgnoreBit(), false);
+
+  for (int i = 0; i < 8; i++) {
+    s.SetHistorySize(i);
+    EXPECT_EQ(s.GetHistorySize(), i);
+  }
+  s.SetHistorySize(2);
+  s.ClearHistorySize();
+  EXPECT_EQ(s.GetHistorySize(), 0);
+}
+
+TEST(Shadow, Mapping) {
+  static int global;
+  int stack;
+  void *heap = malloc(0);
+  free(heap);
+
+  CHECK(IsAppMem((uptr)&global));
+  CHECK(IsAppMem((uptr)&stack));
+  CHECK(IsAppMem((uptr)heap));
+
+  CHECK(IsShadowMem(MemToShadow((uptr)&global)));
+  CHECK(IsShadowMem(MemToShadow((uptr)&stack)));
+  CHECK(IsShadowMem(MemToShadow((uptr)heap)));
+}
+
+TEST(Shadow, Celling) {
+  u64 aligned_data[4];
+  char *data = (char*)aligned_data;
+  CHECK_EQ((uptr)data % kShadowSize, 0);
+  uptr s0 = MemToShadow((uptr)&data[0]);
+  CHECK_EQ(s0 % kShadowSize, 0);
+  for (unsigned i = 1; i < kShadowCell; i++)
+    CHECK_EQ(s0, MemToShadow((uptr)&data[i]));
+  for (unsigned i = kShadowCell; i < 2*kShadowCell; i++)
+    CHECK_EQ(s0 + kShadowSize*kShadowCnt, MemToShadow((uptr)&data[i]));
+  for (unsigned i = 2*kShadowCell; i < 3*kShadowCell; i++)
+    CHECK_EQ(s0 + 2*kShadowSize*kShadowCnt, MemToShadow((uptr)&data[i]));
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_stack_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_stack_test.cc
new file mode 100644
index 0000000..92e035d
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_stack_test.cc
@@ -0,0 +1,95 @@
+//===-- tsan_stack_test.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_sync.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+#include <string.h>
+
+namespace __tsan {
+
+template <typename StackTraceTy>
+static void TestStackTrace(StackTraceTy *trace) {
+  ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0, 0);
+  uptr stack[128];
+  thr.shadow_stack = &stack[0];
+  thr.shadow_stack_pos = &stack[0];
+  thr.shadow_stack_end = &stack[128];
+
+  ObtainCurrentStack(&thr, 0, trace);
+  EXPECT_EQ(0U, trace->size);
+
+  ObtainCurrentStack(&thr, 42, trace);
+  EXPECT_EQ(1U, trace->size);
+  EXPECT_EQ(42U, trace->trace[0]);
+
+  *thr.shadow_stack_pos++ = 100;
+  *thr.shadow_stack_pos++ = 101;
+  ObtainCurrentStack(&thr, 0, trace);
+  EXPECT_EQ(2U, trace->size);
+  EXPECT_EQ(100U, trace->trace[0]);
+  EXPECT_EQ(101U, trace->trace[1]);
+
+  ObtainCurrentStack(&thr, 42, trace);
+  EXPECT_EQ(3U, trace->size);
+  EXPECT_EQ(100U, trace->trace[0]);
+  EXPECT_EQ(101U, trace->trace[1]);
+  EXPECT_EQ(42U, trace->trace[2]);
+}
+
+template<typename StackTraceTy>
+static void TestTrim(StackTraceTy *trace) {
+  ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0, 0);
+  const uptr kShadowStackSize = 2 * kStackTraceMax;
+  uptr stack[kShadowStackSize];
+  thr.shadow_stack = &stack[0];
+  thr.shadow_stack_pos = &stack[0];
+  thr.shadow_stack_end = &stack[kShadowStackSize];
+
+  for (uptr i = 0; i < kShadowStackSize; ++i)
+    *thr.shadow_stack_pos++ = 100 + i;
+
+  ObtainCurrentStack(&thr, 0, trace);
+  EXPECT_EQ(kStackTraceMax, trace->size);
+  for (uptr i = 0; i < kStackTraceMax; i++) {
+    EXPECT_EQ(100 + kStackTraceMax + i, trace->trace[i]);
+  }
+
+  ObtainCurrentStack(&thr, 42, trace);
+  EXPECT_EQ(kStackTraceMax, trace->size);
+  for (uptr i = 0; i < kStackTraceMax - 1; i++) {
+    EXPECT_EQ(101 + kStackTraceMax + i, trace->trace[i]);
+  }
+  EXPECT_EQ(42U, trace->trace[kStackTraceMax - 1]);
+}
+
+TEST(StackTrace, BasicVarSize) {
+  VarSizeStackTrace trace;
+  TestStackTrace(&trace);
+}
+
+TEST(StackTrace, BasicBuffered) {
+  BufferedStackTrace trace;
+  TestStackTrace(&trace);
+}
+
+TEST(StackTrace, TrimVarSize) {
+  VarSizeStackTrace trace;
+  TestTrim(&trace);
+}
+
+TEST(StackTrace, TrimBuffered) {
+  BufferedStackTrace trace;
+  TestTrim(&trace);
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_sync_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_sync_test.cc
new file mode 100644
index 0000000..d3616a1
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_sync_test.cc
@@ -0,0 +1,123 @@
+//===-- tsan_sync_test.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_sync.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+
+namespace __tsan {
+
+TEST(MetaMap, Basic) {
+  ThreadState *thr = cur_thread();
+  MetaMap *m = &ctx->metamap;
+  u64 block[1] = {};  // fake malloc block
+  m->AllocBlock(thr, 0, (uptr)&block[0], 1 * sizeof(u64));
+  MBlock *mb = m->GetBlock((uptr)&block[0]);
+  EXPECT_NE(mb, (MBlock*)0);
+  EXPECT_EQ(mb->siz, 1 * sizeof(u64));
+  EXPECT_EQ(mb->tid, thr->tid);
+  uptr sz = m->FreeBlock(thr, 0, (uptr)&block[0]);
+  EXPECT_EQ(sz, 1 * sizeof(u64));
+  mb = m->GetBlock((uptr)&block[0]);
+  EXPECT_EQ(mb, (MBlock*)0);
+}
+
+TEST(MetaMap, FreeRange) {
+  ThreadState *thr = cur_thread();
+  MetaMap *m = &ctx->metamap;
+  u64 block[4] = {};  // fake malloc block
+  m->AllocBlock(thr, 0, (uptr)&block[0], 1 * sizeof(u64));
+  m->AllocBlock(thr, 0, (uptr)&block[1], 3 * sizeof(u64));
+  MBlock *mb1 = m->GetBlock((uptr)&block[0]);
+  EXPECT_EQ(mb1->siz, 1 * sizeof(u64));
+  MBlock *mb2 = m->GetBlock((uptr)&block[1]);
+  EXPECT_EQ(mb2->siz, 3 * sizeof(u64));
+  m->FreeRange(thr, 0, (uptr)&block[0], 4 * sizeof(u64));
+  mb1 = m->GetBlock((uptr)&block[0]);
+  EXPECT_EQ(mb1, (MBlock*)0);
+  mb2 = m->GetBlock((uptr)&block[1]);
+  EXPECT_EQ(mb2, (MBlock*)0);
+}
+
+TEST(MetaMap, Sync) {
+  ThreadState *thr = cur_thread();
+  MetaMap *m = &ctx->metamap;
+  u64 block[4] = {};  // fake malloc block
+  m->AllocBlock(thr, 0, (uptr)&block[0], 4 * sizeof(u64));
+  SyncVar *s1 = m->GetIfExistsAndLock((uptr)&block[0]);
+  EXPECT_EQ(s1, (SyncVar*)0);
+  s1 = m->GetOrCreateAndLock(thr, 0, (uptr)&block[0], true);
+  EXPECT_NE(s1, (SyncVar*)0);
+  EXPECT_EQ(s1->addr, (uptr)&block[0]);
+  s1->mtx.Unlock();
+  SyncVar *s2 = m->GetOrCreateAndLock(thr, 0, (uptr)&block[1], false);
+  EXPECT_NE(s2, (SyncVar*)0);
+  EXPECT_EQ(s2->addr, (uptr)&block[1]);
+  s2->mtx.ReadUnlock();
+  m->FreeBlock(thr, 0, (uptr)&block[0]);
+  s1 = m->GetIfExistsAndLock((uptr)&block[0]);
+  EXPECT_EQ(s1, (SyncVar*)0);
+  s2 = m->GetIfExistsAndLock((uptr)&block[1]);
+  EXPECT_EQ(s2, (SyncVar*)0);
+  m->OnThreadIdle(thr);
+}
+
+TEST(MetaMap, MoveMemory) {
+  ThreadState *thr = cur_thread();
+  MetaMap *m = &ctx->metamap;
+  u64 block1[4] = {};  // fake malloc block
+  u64 block2[4] = {};  // fake malloc block
+  m->AllocBlock(thr, 0, (uptr)&block1[0], 3 * sizeof(u64));
+  m->AllocBlock(thr, 0, (uptr)&block1[3], 1 * sizeof(u64));
+  SyncVar *s1 = m->GetOrCreateAndLock(thr, 0, (uptr)&block1[0], true);
+  s1->mtx.Unlock();
+  SyncVar *s2 = m->GetOrCreateAndLock(thr, 0, (uptr)&block1[1], true);
+  s2->mtx.Unlock();
+  m->MoveMemory((uptr)&block1[0], (uptr)&block2[0], 4 * sizeof(u64));
+  MBlock *mb1 = m->GetBlock((uptr)&block1[0]);
+  EXPECT_EQ(mb1, (MBlock*)0);
+  MBlock *mb2 = m->GetBlock((uptr)&block1[3]);
+  EXPECT_EQ(mb2, (MBlock*)0);
+  mb1 = m->GetBlock((uptr)&block2[0]);
+  EXPECT_NE(mb1, (MBlock*)0);
+  EXPECT_EQ(mb1->siz, 3 * sizeof(u64));
+  mb2 = m->GetBlock((uptr)&block2[3]);
+  EXPECT_NE(mb2, (MBlock*)0);
+  EXPECT_EQ(mb2->siz, 1 * sizeof(u64));
+  s1 = m->GetIfExistsAndLock((uptr)&block1[0]);
+  EXPECT_EQ(s1, (SyncVar*)0);
+  s2 = m->GetIfExistsAndLock((uptr)&block1[1]);
+  EXPECT_EQ(s2, (SyncVar*)0);
+  s1 = m->GetIfExistsAndLock((uptr)&block2[0]);
+  EXPECT_NE(s1, (SyncVar*)0);
+  EXPECT_EQ(s1->addr, (uptr)&block2[0]);
+  s1->mtx.Unlock();
+  s2 = m->GetIfExistsAndLock((uptr)&block2[1]);
+  EXPECT_NE(s2, (SyncVar*)0);
+  EXPECT_EQ(s2->addr, (uptr)&block2[1]);
+  s2->mtx.Unlock();
+  m->FreeRange(thr, 0, (uptr)&block2[0], 4 * sizeof(u64));
+}
+
+TEST(MetaMap, ResetSync) {
+  ThreadState *thr = cur_thread();
+  MetaMap *m = &ctx->metamap;
+  u64 block[1] = {};  // fake malloc block
+  m->AllocBlock(thr, 0, (uptr)&block[0], 1 * sizeof(u64));
+  SyncVar *s = m->GetOrCreateAndLock(thr, 0, (uptr)&block[0], true);
+  s->Reset(thr);
+  s->mtx.Unlock();
+  uptr sz = m->FreeBlock(thr, 0, (uptr)&block[0]);
+  EXPECT_EQ(sz, 1 * sizeof(u64));
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_unit_test_main.cc b/compiler-rt/lib/tsan/tests/unit/tsan_unit_test_main.cc
new file mode 100644
index 0000000..84d94dd
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_unit_test_main.cc
@@ -0,0 +1,19 @@
+//===-- tsan_unit_test_main.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "gtest/gtest.h"
+
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/compiler-rt/lib/tsan/tests/unit/tsan_vector_test.cc b/compiler-rt/lib/tsan/tests/unit/tsan_vector_test.cc
new file mode 100644
index 0000000..c54ac1e
--- /dev/null
+++ b/compiler-rt/lib/tsan/tests/unit/tsan_vector_test.cc
@@ -0,0 +1,43 @@
+//===-- tsan_vector_test.cc -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+//===----------------------------------------------------------------------===//
+#include "tsan_vector.h"
+#include "tsan_rtl.h"
+#include "gtest/gtest.h"
+
+namespace __tsan {
+
+TEST(Vector, Basic) {
+  Vector<int> v(MBlockScopedBuf);
+  EXPECT_EQ(v.Size(), (uptr)0);
+  v.PushBack(42);
+  EXPECT_EQ(v.Size(), (uptr)1);
+  EXPECT_EQ(v[0], 42);
+  v.PushBack(43);
+  EXPECT_EQ(v.Size(), (uptr)2);
+  EXPECT_EQ(v[0], 42);
+  EXPECT_EQ(v[1], 43);
+}
+
+TEST(Vector, Stride) {
+  Vector<int> v(MBlockScopedBuf);
+  for (int i = 0; i < 1000; i++) {
+    v.PushBack(i);
+    EXPECT_EQ(v.Size(), (uptr)(i + 1));
+    EXPECT_EQ(v[i], i);
+  }
+  for (int i = 0; i < 1000; i++) {
+    EXPECT_EQ(v[i], i);
+  }
+}
+
+}  // namespace __tsan
diff --git a/compiler-rt/lib/ubsan/Android.bp b/compiler-rt/lib/ubsan/Android.bp
new file mode 100644
index 0000000..b8834fb
--- /dev/null
+++ b/compiler-rt/lib/ubsan/Android.bp
@@ -0,0 +1,120 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+ubsan_rtl_files = [
+    "ubsan_diag.cc",
+    "ubsan_init.cc",
+    "ubsan_flags.cc",
+    "ubsan_handlers.cc",
+    "ubsan_value.cc",
+]
+
+ubsan_cxx_rtl_files = [
+    "ubsan_handlers_cxx.cc",
+    "ubsan_type_hash.cc",
+    "ubsan_type_hash_itanium.cc",
+    "ubsan_type_hash_win.cc",
+]
+
+ubsan_rtl_cppflags = [
+    "-fvisibility=hidden",
+    "-fno-exceptions",
+    "-std=c++11",
+    "-Wall",
+    "-Werror",
+    "-Wno-unused-parameter",
+    "-Wno-non-virtual-dtor",
+]
+
+ubsan_rtl_c_includes = ["external/compiler-rt/lib"]
+
+cc_library_static {
+    name: "libubsan",
+    host_supported: true,
+    defaults: ["asan_arch_defaults"],
+
+    include_dirs: ubsan_rtl_c_includes,
+    cppflags: ubsan_rtl_cppflags,
+    srcs: ubsan_rtl_files,
+    sdk_version: "19",
+    stl: "none",
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+    target: {
+        host: {
+            cflags: ["-fno-rtti"],
+        },
+    },
+}
+
+//###############################################################################
+// Host modules
+
+cc_library_host_static {
+    name: "libubsan_standalone",
+
+    include_dirs: ubsan_rtl_c_includes,
+    cppflags: ubsan_rtl_cppflags + ["-fno-rtti"],
+    srcs: ubsan_rtl_files,
+    whole_static_libs: ["libsan"],
+    stl: "none",
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_library_host_static {
+    name: "libubsan_cxx",
+
+    include_dirs: ubsan_rtl_c_includes,
+    cppflags: ubsan_rtl_cppflags,
+    srcs: ubsan_cxx_rtl_files,
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
+
+cc_library_host_static {
+    name: "libubsan_standalone_cxx",
+
+    include_dirs: ubsan_rtl_c_includes,
+    cppflags: ubsan_rtl_cppflags,
+    srcs: ubsan_cxx_rtl_files,
+    sanitize: {
+        never: true,
+    },
+    compile_multilib: "both",
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
+}
diff --git a/compiler-rt/lib/ubsan/CMakeLists.txt b/compiler-rt/lib/ubsan/CMakeLists.txt
new file mode 100644
index 0000000..5ece9a6
--- /dev/null
+++ b/compiler-rt/lib/ubsan/CMakeLists.txt
@@ -0,0 +1,113 @@
+# Build for the undefined behavior sanitizer runtime support library.
+
+set(UBSAN_SOURCES
+  ubsan_diag.cc
+  ubsan_init.cc
+  ubsan_flags.cc
+  ubsan_handlers.cc
+  ubsan_value.cc
+  )
+
+set(UBSAN_STANDALONE_SOURCES
+  ubsan_init_standalone.cc
+  )
+
+set(UBSAN_CXX_SOURCES
+  ubsan_handlers_cxx.cc
+  ubsan_type_hash.cc
+  ubsan_type_hash_itanium.cc
+  ubsan_type_hash_win.cc
+  )
+
+include_directories(..)
+
+set(UBSAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(UBSAN_CFLAGS)
+set(UBSAN_STANDALONE_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_no_rtti_flag(UBSAN_STANDALONE_CFLAGS)
+set(UBSAN_CXXFLAGS ${SANITIZER_COMMON_CFLAGS})
+
+add_custom_target(ubsan)
+
+if(APPLE)
+  set(UBSAN_COMMON_SOURCES ${UBSAN_SOURCES})
+  if(SANITIZER_CAN_USE_CXXABI)
+    list(APPEND UBSAN_COMMON_SOURCES ${UBSAN_CXX_SOURCES})
+  endif()
+
+  # Common parts of UBSan runtime.
+  add_compiler_rt_object_libraries(RTUbsan
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
+    SOURCES ${UBSAN_COMMON_SOURCES}
+    CFLAGS ${UBSAN_CXXFLAGS})
+
+  if(COMPILER_RT_HAS_UBSAN)
+    # Initializer of standalone UBSan runtime.
+    add_compiler_rt_object_libraries(RTUbsan_standalone
+      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      ARCHS ${UBSAN_SUPPORTED_ARCH}
+      SOURCES ${UBSAN_STANDALONE_SOURCES}
+      CFLAGS ${UBSAN_STANDALONE_CFLAGS})
+
+    add_compiler_rt_runtime(clang_rt.ubsan
+      SHARED
+      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      ARCHS ${UBSAN_SUPPORTED_ARCH}
+      OBJECT_LIBS RTUbsan
+                  RTUbsan_standalone
+                  RTSanitizerCommon
+                  RTSanitizerCommonLibc
+      PARENT_TARGET ubsan)
+  endif()
+
+else()
+  # Common parts of UBSan runtime.
+  add_compiler_rt_object_libraries(RTUbsan
+    ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
+    SOURCES ${UBSAN_SOURCES} CFLAGS ${UBSAN_CFLAGS})
+  # C++-specific parts of UBSan runtime. Requires a C++ ABI library.
+  add_compiler_rt_object_libraries(RTUbsan_cxx
+    ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
+    SOURCES ${UBSAN_CXX_SOURCES} CFLAGS ${UBSAN_CXXFLAGS})
+
+  if(COMPILER_RT_HAS_UBSAN)
+    # Initializer of standalone UBSan runtime.
+    add_compiler_rt_object_libraries(RTUbsan_standalone
+      ARCHS ${UBSAN_SUPPORTED_ARCH}
+      SOURCES ${UBSAN_STANDALONE_SOURCES} CFLAGS ${UBSAN_STANDALONE_CFLAGS})
+    
+    # Standalone UBSan runtimes.
+    add_compiler_rt_runtime(clang_rt.ubsan_standalone
+      STATIC
+      ARCHS ${UBSAN_SUPPORTED_ARCH}
+      OBJECT_LIBS RTSanitizerCommon
+              RTSanitizerCommonLibc
+              RTUbsan
+              RTUbsan_standalone
+      CFLAGS ${UBSAN_CFLAGS}
+      PARENT_TARGET ubsan)
+    
+    add_compiler_rt_runtime(clang_rt.ubsan_standalone_cxx
+      STATIC
+      ARCHS ${UBSAN_SUPPORTED_ARCH}
+      OBJECT_LIBS RTUbsan_cxx
+      CFLAGS ${UBSAN_CXXFLAGS}
+      PARENT_TARGET ubsan)
+
+    if (UNIX)
+      set(ARCHS_FOR_SYMBOLS ${UBSAN_SUPPORTED_ARCH})
+      list(REMOVE_ITEM ARCHS_FOR_SYMBOLS i386 i686)
+      add_sanitizer_rt_symbols(clang_rt.ubsan_standalone
+        ARCHS ${ARCHS_FOR_SYMBOLS}
+        PARENT_TARGET ubsan
+        EXTRA ubsan.syms.extra)
+      add_sanitizer_rt_symbols(clang_rt.ubsan_standalone_cxx
+        ARCHS ${ARCHS_FOR_SYMBOLS}
+        PARENT_TARGET ubsan
+        EXTRA ubsan.syms.extra)
+    endif()
+  endif()
+endif()
+
+add_dependencies(compiler-rt ubsan)
diff --git a/compiler-rt/lib/ubsan/Makefile.mk b/compiler-rt/lib/ubsan/Makefile.mk
new file mode 100644
index 0000000..ec3f5c5
--- /dev/null
+++ b/compiler-rt/lib/ubsan/Makefile.mk
@@ -0,0 +1,28 @@
+#===- lib/ubsan/Makefile.mk ---------------------------------*- Makefile -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+ModuleName := ubsan
+SubDirs :=
+
+Sources := $(foreach file,$(wildcard $(Dir)/*.cc),$(notdir $(file)))
+StandaloneSources := ubsan_init_standalone.cc
+CXXSources := ubsan_type_hash.cc ubsan_handlers_cxx.cc
+CSources := $(filter-out $(StandaloneSources),$(filter-out $(CXXSources),$(Sources)))
+ObjNames := $(Sources:%.cc=%.o)
+
+Implementation := Generic
+
+# FIXME: use automatic dependencies?
+Dependencies := $(wildcard $(Dir)/*.h)
+Dependencies += $(wildcard $(Dir)/../sanitizer_common/*.h)
+
+# Define a convenience variable for all the ubsan functions.
+UbsanFunctions := $(CSources:%.cc=%)
+UbsanCXXFunctions := $(CXXSources:%.cc=%)
+UbsanStandaloneFunctions := $(StandaloneSources:%.cc=%)
diff --git a/compiler-rt/lib/ubsan/ubsan.syms.extra b/compiler-rt/lib/ubsan/ubsan.syms.extra
new file mode 100644
index 0000000..7f8be69
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan.syms.extra
@@ -0,0 +1 @@
+__ubsan_*
diff --git a/compiler-rt/lib/ubsan/ubsan_checks.inc b/compiler-rt/lib/ubsan/ubsan_checks.inc
new file mode 100644
index 0000000..6e08641
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_checks.inc
@@ -0,0 +1,45 @@
+//===-- ubsan_checks.inc ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// List of checks handled by UBSan runtime.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_CHECK
+# error "Define UBSAN_CHECK prior to including this file!"
+#endif
+
+// UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)
+// SummaryKind and FSanitizeFlagName should be string literals.
+
+UBSAN_CHECK(GenericUB, "undefined-behavior", "undefined")
+UBSAN_CHECK(NullPointerUse, "null-pointer-use", "null")
+UBSAN_CHECK(MisalignedPointerUse, "misaligned-pointer-use", "alignment")
+UBSAN_CHECK(InsufficientObjectSize, "insufficient-object-size", "object-size")
+UBSAN_CHECK(SignedIntegerOverflow, "signed-integer-overflow",
+            "signed-integer-overflow")
+UBSAN_CHECK(UnsignedIntegerOverflow, "unsigned-integer-overflow",
+            "unsigned-integer-overflow")
+UBSAN_CHECK(IntegerDivideByZero, "integer-divide-by-zero",
+            "integer-divide-by-zero")
+UBSAN_CHECK(FloatDivideByZero, "float-divide-by-zero", "float-divide-by-zero")
+UBSAN_CHECK(InvalidShiftBase, "invalid-shift-base", "shift-base")
+UBSAN_CHECK(InvalidShiftExponent, "invalid-shift-exponent", "shift-exponent")
+UBSAN_CHECK(OutOfBoundsIndex, "out-of-bounds-index", "bounds")
+UBSAN_CHECK(UnreachableCall, "unreachable-call", "unreachable")
+UBSAN_CHECK(MissingReturn, "missing-return", "return")
+UBSAN_CHECK(NonPositiveVLAIndex, "non-positive-vla-index", "vla-bound")
+UBSAN_CHECK(FloatCastOverflow, "float-cast-overflow", "float-cast-overflow")
+UBSAN_CHECK(InvalidBoolLoad, "invalid-bool-load", "bool")
+UBSAN_CHECK(InvalidEnumLoad, "invalid-enum-load", "enum")
+UBSAN_CHECK(FunctionTypeMismatch, "function-type-mismatch", "function")
+UBSAN_CHECK(InvalidNullReturn, "invalid-null-return",
+            "returns-nonnull-attribute")
+UBSAN_CHECK(InvalidNullArgument, "invalid-null-argument", "nonnull-attribute")
+UBSAN_CHECK(DynamicTypeMismatch, "dynamic-type-mismatch", "vptr")
+UBSAN_CHECK(CFIBadType, "cfi-bad-type", "cfi")
diff --git a/compiler-rt/lib/ubsan/ubsan_diag.cc b/compiler-rt/lib/ubsan/ubsan_diag.cc
new file mode 100644
index 0000000..2476947
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_diag.cc
@@ -0,0 +1,431 @@
+//===-- ubsan_diag.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Diagnostic reporting for the UBSan runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_diag.h"
+#include "ubsan_init.h"
+#include "ubsan_flags.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_report_decorator.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_stacktrace_printer.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+#include <stdio.h>
+
+using namespace __ubsan;
+
+static void MaybePrintStackTrace(uptr pc, uptr bp) {
+  // We assume that flags are already parsed, as UBSan runtime
+  // will definitely be called when we print the first diagnostics message.
+  if (!flags()->print_stacktrace)
+    return;
+  // We can only use slow unwind, as we don't have any information about stack
+  // top/bottom.
+  // FIXME: It's better to respect "fast_unwind_on_fatal" runtime flag and
+  // fetch stack top/bottom information if we have it (e.g. if we're running
+  // under ASan).
+  if (StackTrace::WillUseFastUnwind(false))
+    return;
+  BufferedStackTrace stack;
+  stack.Unwind(kStackTraceMax, pc, bp, 0, 0, 0, false);
+  stack.Print();
+}
+
+static const char *ConvertTypeToString(ErrorType Type) {
+  switch (Type) {
+#define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)                      \
+  case ErrorType::Name:                                                        \
+    return SummaryKind;
+#include "ubsan_checks.inc"
+#undef UBSAN_CHECK
+  }
+  UNREACHABLE("unknown ErrorType!");
+}
+
+static const char *ConvertTypeToFlagName(ErrorType Type) {
+  switch (Type) {
+#define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)                      \
+  case ErrorType::Name:                                                        \
+    return FSanitizeFlagName;
+#include "ubsan_checks.inc"
+#undef UBSAN_CHECK
+  }
+  UNREACHABLE("unknown ErrorType!");
+}
+
+static void MaybeReportErrorSummary(Location Loc, ErrorType Type) {
+  if (!common_flags()->print_summary)
+    return;
+  if (!flags()->report_error_type)
+    Type = ErrorType::GenericUB;
+  const char *ErrorKind = ConvertTypeToString(Type);
+  if (Loc.isSourceLocation()) {
+    SourceLocation SLoc = Loc.getSourceLocation();
+    if (!SLoc.isInvalid()) {
+      AddressInfo AI;
+      AI.file = internal_strdup(SLoc.getFilename());
+      AI.line = SLoc.getLine();
+      AI.column = SLoc.getColumn();
+      AI.function = internal_strdup("");  // Avoid printing ?? as function name.
+      ReportErrorSummary(ErrorKind, AI);
+      AI.Clear();
+      return;
+    }
+  } else if (Loc.isSymbolizedStack()) {
+    const AddressInfo &AI = Loc.getSymbolizedStack()->info;
+    ReportErrorSummary(ErrorKind, AI);
+    return;
+  }
+  ReportErrorSummary(ErrorKind);
+}
+
+namespace {
+class Decorator : public SanitizerCommonDecorator {
+ public:
+  Decorator() : SanitizerCommonDecorator() {}
+  const char *Highlight() const { return Green(); }
+  const char *EndHighlight() const { return Default(); }
+  const char *Note() const { return Black(); }
+  const char *EndNote() const { return Default(); }
+};
+}
+
+SymbolizedStack *__ubsan::getSymbolizedLocation(uptr PC) {
+  InitAsStandaloneIfNecessary();
+  return Symbolizer::GetOrInit()->SymbolizePC(PC);
+}
+
+Diag &Diag::operator<<(const TypeDescriptor &V) {
+  return AddArg(V.getTypeName());
+}
+
+Diag &Diag::operator<<(const Value &V) {
+  if (V.getType().isSignedIntegerTy())
+    AddArg(V.getSIntValue());
+  else if (V.getType().isUnsignedIntegerTy())
+    AddArg(V.getUIntValue());
+  else if (V.getType().isFloatTy())
+    AddArg(V.getFloatValue());
+  else
+    AddArg("<unknown>");
+  return *this;
+}
+
+/// Hexadecimal printing for numbers too large for Printf to handle directly.
+static void PrintHex(UIntMax Val) {
+#if HAVE_INT128_T
+  Printf("0x%08x%08x%08x%08x",
+          (unsigned int)(Val >> 96),
+          (unsigned int)(Val >> 64),
+          (unsigned int)(Val >> 32),
+          (unsigned int)(Val));
+#else
+  UNREACHABLE("long long smaller than 64 bits?");
+#endif
+}
+
+static void renderLocation(Location Loc) {
+  InternalScopedString LocBuffer(1024);
+  switch (Loc.getKind()) {
+  case Location::LK_Source: {
+    SourceLocation SLoc = Loc.getSourceLocation();
+    if (SLoc.isInvalid())
+      LocBuffer.append("<unknown>");
+    else
+      RenderSourceLocation(&LocBuffer, SLoc.getFilename(), SLoc.getLine(),
+                           SLoc.getColumn(), common_flags()->symbolize_vs_style,
+                           common_flags()->strip_path_prefix);
+    break;
+  }
+  case Location::LK_Memory:
+    LocBuffer.append("%p", Loc.getMemoryLocation());
+    break;
+  case Location::LK_Symbolized: {
+    const AddressInfo &Info = Loc.getSymbolizedStack()->info;
+    if (Info.file) {
+      RenderSourceLocation(&LocBuffer, Info.file, Info.line, Info.column,
+                           common_flags()->symbolize_vs_style,
+                           common_flags()->strip_path_prefix);
+    } else if (Info.module) {
+      RenderModuleLocation(&LocBuffer, Info.module, Info.module_offset,
+                           common_flags()->strip_path_prefix);
+    } else {
+      LocBuffer.append("%p", Info.address);
+    }
+    break;
+  }
+  case Location::LK_Null:
+    LocBuffer.append("<unknown>");
+    break;
+  }
+  Printf("%s:", LocBuffer.data());
+}
+
+static void renderText(const char *Message, const Diag::Arg *Args) {
+  for (const char *Msg = Message; *Msg; ++Msg) {
+    if (*Msg != '%') {
+      char Buffer[64];
+      unsigned I;
+      for (I = 0; Msg[I] && Msg[I] != '%' && I != 63; ++I)
+        Buffer[I] = Msg[I];
+      Buffer[I] = '\0';
+      Printf(Buffer);
+      Msg += I - 1;
+    } else {
+      const Diag::Arg &A = Args[*++Msg - '0'];
+      switch (A.Kind) {
+      case Diag::AK_String:
+        Printf("%s", A.String);
+        break;
+      case Diag::AK_TypeName: {
+        if (SANITIZER_WINDOWS)
+          // The Windows implementation demangles names early.
+          Printf("'%s'", A.String);
+        else
+          Printf("'%s'", Symbolizer::GetOrInit()->Demangle(A.String));
+        break;
+      }
+      case Diag::AK_SInt:
+        // 'long long' is guaranteed to be at least 64 bits wide.
+        if (A.SInt >= INT64_MIN && A.SInt <= INT64_MAX)
+          Printf("%lld", (long long)A.SInt);
+        else
+          PrintHex(A.SInt);
+        break;
+      case Diag::AK_UInt:
+        if (A.UInt <= UINT64_MAX)
+          Printf("%llu", (unsigned long long)A.UInt);
+        else
+          PrintHex(A.UInt);
+        break;
+      case Diag::AK_Float: {
+        // FIXME: Support floating-point formatting in sanitizer_common's
+        //        printf, and stop using snprintf here.
+        char Buffer[32];
+#if SANITIZER_WINDOWS
+        sprintf_s(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
+#else
+        snprintf(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
+#endif
+        Printf("%s", Buffer);
+        break;
+      }
+      case Diag::AK_Pointer:
+        Printf("%p", A.Pointer);
+        break;
+      }
+    }
+  }
+}
+
+/// Find the earliest-starting range in Ranges which ends after Loc.
+static Range *upperBound(MemoryLocation Loc, Range *Ranges,
+                         unsigned NumRanges) {
+  Range *Best = 0;
+  for (unsigned I = 0; I != NumRanges; ++I)
+    if (Ranges[I].getEnd().getMemoryLocation() > Loc &&
+        (!Best ||
+         Best->getStart().getMemoryLocation() >
+         Ranges[I].getStart().getMemoryLocation()))
+      Best = &Ranges[I];
+  return Best;
+}
+
+static inline uptr subtractNoOverflow(uptr LHS, uptr RHS) {
+  return (LHS < RHS) ? 0 : LHS - RHS;
+}
+
+static inline uptr addNoOverflow(uptr LHS, uptr RHS) {
+  const uptr Limit = (uptr)-1;
+  return (LHS > Limit - RHS) ? Limit : LHS + RHS;
+}
+
+/// Render a snippet of the address space near a location.
+static void renderMemorySnippet(const Decorator &Decor, MemoryLocation Loc,
+                                Range *Ranges, unsigned NumRanges,
+                                const Diag::Arg *Args) {
+  // Show at least the 8 bytes surrounding Loc.
+  const unsigned MinBytesNearLoc = 4;
+  MemoryLocation Min = subtractNoOverflow(Loc, MinBytesNearLoc);
+  MemoryLocation Max = addNoOverflow(Loc, MinBytesNearLoc);
+  MemoryLocation OrigMin = Min;
+  for (unsigned I = 0; I < NumRanges; ++I) {
+    Min = __sanitizer::Min(Ranges[I].getStart().getMemoryLocation(), Min);
+    Max = __sanitizer::Max(Ranges[I].getEnd().getMemoryLocation(), Max);
+  }
+
+  // If we have too many interesting bytes, prefer to show bytes after Loc.
+  const unsigned BytesToShow = 32;
+  if (Max - Min > BytesToShow)
+    Min = __sanitizer::Min(Max - BytesToShow, OrigMin);
+  Max = addNoOverflow(Min, BytesToShow);
+
+  if (!IsAccessibleMemoryRange(Min, Max - Min)) {
+    Printf("<memory cannot be printed>\n");
+    return;
+  }
+
+  // Emit data.
+  for (uptr P = Min; P != Max; ++P) {
+    unsigned char C = *reinterpret_cast<const unsigned char*>(P);
+    Printf("%s%02x", (P % 8 == 0) ? "  " : " ", C);
+  }
+  Printf("\n");
+
+  // Emit highlights.
+  Printf(Decor.Highlight());
+  Range *InRange = upperBound(Min, Ranges, NumRanges);
+  for (uptr P = Min; P != Max; ++P) {
+    char Pad = ' ', Byte = ' ';
+    if (InRange && InRange->getEnd().getMemoryLocation() == P)
+      InRange = upperBound(P, Ranges, NumRanges);
+    if (!InRange && P > Loc)
+      break;
+    if (InRange && InRange->getStart().getMemoryLocation() < P)
+      Pad = '~';
+    if (InRange && InRange->getStart().getMemoryLocation() <= P)
+      Byte = '~';
+    char Buffer[] = { Pad, Pad, P == Loc ? '^' : Byte, Byte, 0 };
+    Printf((P % 8 == 0) ? Buffer : &Buffer[1]);
+  }
+  Printf("%s\n", Decor.EndHighlight());
+
+  // Go over the line again, and print names for the ranges.
+  InRange = 0;
+  unsigned Spaces = 0;
+  for (uptr P = Min; P != Max; ++P) {
+    if (!InRange || InRange->getEnd().getMemoryLocation() == P)
+      InRange = upperBound(P, Ranges, NumRanges);
+    if (!InRange)
+      break;
+
+    Spaces += (P % 8) == 0 ? 2 : 1;
+
+    if (InRange && InRange->getStart().getMemoryLocation() == P) {
+      while (Spaces--)
+        Printf(" ");
+      renderText(InRange->getText(), Args);
+      Printf("\n");
+      // FIXME: We only support naming one range for now!
+      break;
+    }
+
+    Spaces += 2;
+  }
+
+  // FIXME: Print names for anything we can identify within the line:
+  //
+  //  * If we can identify the memory itself as belonging to a particular
+  //    global, stack variable, or dynamic allocation, then do so.
+  //
+  //  * If we have a pointer-size, pointer-aligned range highlighted,
+  //    determine whether the value of that range is a pointer to an
+  //    entity which we can name, and if so, print that name.
+  //
+  // This needs an external symbolizer, or (preferably) ASan instrumentation.
+}
+
+Diag::~Diag() {
+  // All diagnostics should be printed under report mutex.
+  CommonSanitizerReportMutex.CheckLocked();
+  Decorator Decor;
+  Printf(Decor.Bold());
+
+  renderLocation(Loc);
+
+  switch (Level) {
+  case DL_Error:
+    Printf("%s runtime error: %s%s",
+           Decor.Warning(), Decor.EndWarning(), Decor.Bold());
+    break;
+
+  case DL_Note:
+    Printf("%s note: %s", Decor.Note(), Decor.EndNote());
+    break;
+  }
+
+  renderText(Message, Args);
+
+  Printf("%s\n", Decor.Default());
+
+  if (Loc.isMemoryLocation())
+    renderMemorySnippet(Decor, Loc.getMemoryLocation(), Ranges,
+                        NumRanges, Args);
+}
+
+ScopedReport::ScopedReport(ReportOptions Opts, Location SummaryLoc,
+                           ErrorType Type)
+    : Opts(Opts), SummaryLoc(SummaryLoc), Type(Type) {
+  InitAsStandaloneIfNecessary();
+  CommonSanitizerReportMutex.Lock();
+}
+
+ScopedReport::~ScopedReport() {
+  MaybePrintStackTrace(Opts.pc, Opts.bp);
+  MaybeReportErrorSummary(SummaryLoc, Type);
+  CommonSanitizerReportMutex.Unlock();
+  if (flags()->halt_on_error)
+    Die();
+}
+
+ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
+static SuppressionContext *suppression_ctx = nullptr;
+static const char kVptrCheck[] = "vptr_check";
+static const char *kSuppressionTypes[] = {
+#define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName) FSanitizeFlagName,
+#include "ubsan_checks.inc"
+#undef UBSAN_CHECK
+    kVptrCheck,
+};
+
+void __ubsan::InitializeSuppressions() {
+  CHECK_EQ(nullptr, suppression_ctx);
+  suppression_ctx = new (suppression_placeholder) // NOLINT
+      SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
+  suppression_ctx->ParseFromFile(flags()->suppressions);
+}
+
+bool __ubsan::IsVptrCheckSuppressed(const char *TypeName) {
+  InitAsStandaloneIfNecessary();
+  CHECK(suppression_ctx);
+  Suppression *s;
+  return suppression_ctx->Match(TypeName, kVptrCheck, &s);
+}
+
+bool __ubsan::IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename) {
+  InitAsStandaloneIfNecessary();
+  CHECK(suppression_ctx);
+  const char *SuppType = ConvertTypeToFlagName(ET);
+  // Fast path: don't symbolize PC if there is no suppressions for given UB
+  // type.
+  if (!suppression_ctx->HasSuppressionType(SuppType))
+    return false;
+  Suppression *s = nullptr;
+  // Suppress by file name known to runtime.
+  if (Filename != nullptr && suppression_ctx->Match(Filename, SuppType, &s))
+    return true;
+  // Suppress by module name.
+  if (const char *Module = Symbolizer::GetOrInit()->GetModuleNameForPc(PC)) {
+    if (suppression_ctx->Match(Module, SuppType, &s))
+      return true;
+  }
+  // Suppress by function or source file name from debug info.
+  SymbolizedStackHolder Stack(Symbolizer::GetOrInit()->SymbolizePC(PC));
+  const AddressInfo &AI = Stack.get()->info;
+  return suppression_ctx->Match(AI.function, SuppType, &s) ||
+         suppression_ctx->Match(AI.file, SuppType, &s);
+}
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_diag.h b/compiler-rt/lib/ubsan/ubsan_diag.h
new file mode 100644
index 0000000..3edb67a
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_diag.h
@@ -0,0 +1,255 @@
+//===-- ubsan_diag.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Diagnostics emission for Clang's undefined behavior sanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_DIAG_H
+#define UBSAN_DIAG_H
+
+#include "ubsan_value.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+namespace __ubsan {
+
+class SymbolizedStackHolder {
+  SymbolizedStack *Stack;
+
+  void clear() {
+    if (Stack)
+      Stack->ClearAll();
+  }
+
+public:
+  explicit SymbolizedStackHolder(SymbolizedStack *Stack = nullptr)
+      : Stack(Stack) {}
+  ~SymbolizedStackHolder() { clear(); }
+  void reset(SymbolizedStack *S) {
+    if (Stack != S)
+      clear();
+    Stack = S;
+  }
+  const SymbolizedStack *get() const { return Stack; }
+};
+
+SymbolizedStack *getSymbolizedLocation(uptr PC);
+
+inline SymbolizedStack *getCallerLocation(uptr CallerPC) {
+  CHECK(CallerPC);
+  uptr PC = StackTrace::GetPreviousInstructionPc(CallerPC);
+  return getSymbolizedLocation(PC);
+}
+
+/// A location of some data within the program's address space.
+typedef uptr MemoryLocation;
+
+/// \brief Location at which a diagnostic can be emitted. Either a
+/// SourceLocation, a MemoryLocation, or a SymbolizedStack.
+class Location {
+public:
+  enum LocationKind { LK_Null, LK_Source, LK_Memory, LK_Symbolized };
+
+private:
+  LocationKind Kind;
+  // FIXME: In C++11, wrap these in an anonymous union.
+  SourceLocation SourceLoc;
+  MemoryLocation MemoryLoc;
+  const SymbolizedStack *SymbolizedLoc;  // Not owned.
+
+public:
+  Location() : Kind(LK_Null) {}
+  Location(SourceLocation Loc) :
+    Kind(LK_Source), SourceLoc(Loc) {}
+  Location(MemoryLocation Loc) :
+    Kind(LK_Memory), MemoryLoc(Loc) {}
+  // SymbolizedStackHolder must outlive Location object.
+  Location(const SymbolizedStackHolder &Stack) :
+    Kind(LK_Symbolized), SymbolizedLoc(Stack.get()) {}
+
+  LocationKind getKind() const { return Kind; }
+
+  bool isSourceLocation() const { return Kind == LK_Source; }
+  bool isMemoryLocation() const { return Kind == LK_Memory; }
+  bool isSymbolizedStack() const { return Kind == LK_Symbolized; }
+
+  SourceLocation getSourceLocation() const {
+    CHECK(isSourceLocation());
+    return SourceLoc;
+  }
+  MemoryLocation getMemoryLocation() const {
+    CHECK(isMemoryLocation());
+    return MemoryLoc;
+  }
+  const SymbolizedStack *getSymbolizedStack() const {
+    CHECK(isSymbolizedStack());
+    return SymbolizedLoc;
+  }
+};
+
+/// A diagnostic severity level.
+enum DiagLevel {
+  DL_Error, ///< An error.
+  DL_Note   ///< A note, attached to a prior diagnostic.
+};
+
+/// \brief Annotation for a range of locations in a diagnostic.
+class Range {
+  Location Start, End;
+  const char *Text;
+
+public:
+  Range() : Start(), End(), Text() {}
+  Range(MemoryLocation Start, MemoryLocation End, const char *Text)
+    : Start(Start), End(End), Text(Text) {}
+  Location getStart() const { return Start; }
+  Location getEnd() const { return End; }
+  const char *getText() const { return Text; }
+};
+
+/// \brief A C++ type name. Really just a strong typedef for 'const char*'.
+class TypeName {
+  const char *Name;
+public:
+  TypeName(const char *Name) : Name(Name) {}
+  const char *getName() const { return Name; }
+};
+
+/// \brief Representation of an in-flight diagnostic.
+///
+/// Temporary \c Diag instances are created by the handler routines to
+/// accumulate arguments for a diagnostic. The destructor emits the diagnostic
+/// message.
+class Diag {
+  /// The location at which the problem occurred.
+  Location Loc;
+
+  /// The diagnostic level.
+  DiagLevel Level;
+
+  /// The message which will be emitted, with %0, %1, ... placeholders for
+  /// arguments.
+  const char *Message;
+
+public:
+  /// Kinds of arguments, corresponding to members of \c Arg's union.
+  enum ArgKind {
+    AK_String, ///< A string argument, displayed as-is.
+    AK_TypeName,///< A C++ type name, possibly demangled before display.
+    AK_UInt,   ///< An unsigned integer argument.
+    AK_SInt,   ///< A signed integer argument.
+    AK_Float,  ///< A floating-point argument.
+    AK_Pointer ///< A pointer argument, displayed in hexadecimal.
+  };
+
+  /// An individual diagnostic message argument.
+  struct Arg {
+    Arg() {}
+    Arg(const char *String) : Kind(AK_String), String(String) {}
+    Arg(TypeName TN) : Kind(AK_TypeName), String(TN.getName()) {}
+    Arg(UIntMax UInt) : Kind(AK_UInt), UInt(UInt) {}
+    Arg(SIntMax SInt) : Kind(AK_SInt), SInt(SInt) {}
+    Arg(FloatMax Float) : Kind(AK_Float), Float(Float) {}
+    Arg(const void *Pointer) : Kind(AK_Pointer), Pointer(Pointer) {}
+
+    ArgKind Kind;
+    union {
+      const char *String;
+      UIntMax UInt;
+      SIntMax SInt;
+      FloatMax Float;
+      const void *Pointer;
+    };
+  };
+
+private:
+  static const unsigned MaxArgs = 5;
+  static const unsigned MaxRanges = 1;
+
+  /// The arguments which have been added to this diagnostic so far.
+  Arg Args[MaxArgs];
+  unsigned NumArgs;
+
+  /// The ranges which have been added to this diagnostic so far.
+  Range Ranges[MaxRanges];
+  unsigned NumRanges;
+
+  Diag &AddArg(Arg A) {
+    CHECK(NumArgs != MaxArgs);
+    Args[NumArgs++] = A;
+    return *this;
+  }
+
+  Diag &AddRange(Range A) {
+    CHECK(NumRanges != MaxRanges);
+    Ranges[NumRanges++] = A;
+    return *this;
+  }
+
+  /// \c Diag objects are not copyable.
+  Diag(const Diag &); // NOT IMPLEMENTED
+  Diag &operator=(const Diag &);
+
+public:
+  Diag(Location Loc, DiagLevel Level, const char *Message)
+    : Loc(Loc), Level(Level), Message(Message), NumArgs(0), NumRanges(0) {}
+  ~Diag();
+
+  Diag &operator<<(const char *Str) { return AddArg(Str); }
+  Diag &operator<<(TypeName TN) { return AddArg(TN); }
+  Diag &operator<<(unsigned long long V) { return AddArg(UIntMax(V)); }
+  Diag &operator<<(const void *V) { return AddArg(V); }
+  Diag &operator<<(const TypeDescriptor &V);
+  Diag &operator<<(const Value &V);
+  Diag &operator<<(const Range &R) { return AddRange(R); }
+};
+
+struct ReportOptions {
+  // If FromUnrecoverableHandler is specified, UBSan runtime handler is not
+  // expected to return.
+  bool FromUnrecoverableHandler;
+  /// pc/bp are used to unwind the stack trace.
+  uptr pc;
+  uptr bp;
+};
+
+enum class ErrorType {
+#define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName) Name,
+#include "ubsan_checks.inc"
+#undef UBSAN_CHECK
+};
+
+bool ignoreReport(SourceLocation SLoc, ReportOptions Opts, ErrorType ET);
+
+#define GET_REPORT_OPTIONS(unrecoverable_handler) \
+    GET_CALLER_PC_BP; \
+    ReportOptions Opts = {unrecoverable_handler, pc, bp}
+
+/// \brief Instantiate this class before printing diagnostics in the error
+/// report. This class ensures that reports from different threads and from
+/// different sanitizers won't be mixed.
+class ScopedReport {
+  ReportOptions Opts;
+  Location SummaryLoc;
+  ErrorType Type;
+
+public:
+  ScopedReport(ReportOptions Opts, Location SummaryLoc, ErrorType Type);
+  ~ScopedReport();
+};
+
+void InitializeSuppressions();
+bool IsVptrCheckSuppressed(const char *TypeName);
+// Sometimes UBSan runtime can know filename from handlers arguments, even if
+// debug info is missing.
+bool IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename);
+
+} // namespace __ubsan
+
+#endif // UBSAN_DIAG_H
diff --git a/compiler-rt/lib/ubsan/ubsan_flags.cc b/compiler-rt/lib/ubsan/ubsan_flags.cc
new file mode 100644
index 0000000..20087b9
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_flags.cc
@@ -0,0 +1,88 @@
+//===-- ubsan_flags.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Runtime flags for UndefinedBehaviorSanitizer.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_flags.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+
+namespace __ubsan {
+
+const char *MaybeCallUbsanDefaultOptions() {
+  return (&__ubsan_default_options) ? __ubsan_default_options() : "";
+}
+
+Flags ubsan_flags;
+
+void Flags::SetDefaults() {
+#define UBSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "ubsan_flags.inc"
+#undef UBSAN_FLAG
+}
+
+void RegisterUbsanFlags(FlagParser *parser, Flags *f) {
+#define UBSAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "ubsan_flags.inc"
+#undef UBSAN_FLAG
+}
+
+void InitializeFlags() {
+  SetCommonFlagsDefaults();
+  {
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.print_summary = false;
+    OverrideCommonFlags(cf);
+  }
+
+  Flags *f = flags();
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterCommonFlags(&parser);
+  RegisterUbsanFlags(&parser, f);
+
+  // Override from user-specified string.
+  parser.ParseString(MaybeCallUbsanDefaultOptions());
+  // Override from environment variable.
+  parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  SetVerbosity(common_flags()->verbosity);
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) parser.PrintFlagDescriptions();
+}
+
+}  // namespace __ubsan
+
+extern "C" {
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+const char *__ubsan_default_options() { return ""; }
+#endif
+
+#if SANITIZER_WINDOWS
+const char *__ubsan_default_default_options() { return ""; }
+# ifdef _WIN64
+#  pragma comment(linker, "/alternatename:__ubsan_default_options=__ubsan_default_default_options")
+# else
+#  pragma comment(linker, "/alternatename:___ubsan_default_options=___ubsan_default_default_options")
+# endif
+#endif
+
+}  // extern "C"
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_flags.h b/compiler-rt/lib/ubsan/ubsan_flags.h
new file mode 100644
index 0000000..18aed9b
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_flags.h
@@ -0,0 +1,49 @@
+//===-- ubsan_flags.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Runtime flags for UndefinedBehaviorSanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_FLAGS_H
+#define UBSAN_FLAGS_H
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+namespace __sanitizer {
+class FlagParser;
+}
+
+namespace __ubsan {
+
+struct Flags {
+#define UBSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "ubsan_flags.inc"
+#undef UBSAN_FLAG
+
+  void SetDefaults();
+};
+
+extern Flags ubsan_flags;
+inline Flags *flags() { return &ubsan_flags; }
+
+void InitializeFlags();
+void RegisterUbsanFlags(FlagParser *parser, Flags *f);
+
+const char *MaybeCallUbsanDefaultOptions();
+
+}  // namespace __ubsan
+
+extern "C" {
+// Users may provide their own implementation of __ubsan_default_options to
+// override the default flag values.
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+const char *__ubsan_default_options();
+}  // extern "C"
+
+#endif  // UBSAN_FLAGS_H
diff --git a/compiler-rt/lib/ubsan/ubsan_flags.inc b/compiler-rt/lib/ubsan/ubsan_flags.inc
new file mode 100644
index 0000000..d171a98
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_flags.inc
@@ -0,0 +1,26 @@
+//===-- ubsan_flags.inc -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// UBSan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_FLAG
+# error "Define UBSAN_FLAG prior to including this file!"
+#endif
+
+// UBSAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+UBSAN_FLAG(bool, halt_on_error, false,
+           "Crash the program after printing the first error report")
+UBSAN_FLAG(bool, print_stacktrace, false,
+           "Include full stacktrace into an error report")
+UBSAN_FLAG(const char *, suppressions, "", "Suppressions file name.")
+UBSAN_FLAG(bool, report_error_type, false,
+        "Print specific error type instead of 'undefined-behavior' in summary.")
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers.cc b/compiler-rt/lib/ubsan/ubsan_handlers.cc
new file mode 100644
index 0000000..5d82e9a
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_handlers.cc
@@ -0,0 +1,560 @@
+//===-- ubsan_handlers.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Error logging entry points for the UBSan runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_handlers.h"
+#include "ubsan_diag.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+
+using namespace __sanitizer;
+using namespace __ubsan;
+
+namespace __ubsan {
+bool ignoreReport(SourceLocation SLoc, ReportOptions Opts, ErrorType ET) {
+  // We are not allowed to skip error report: if we are in unrecoverable
+  // handler, we have to terminate the program right now, and therefore
+  // have to print some diagnostic.
+  //
+  // Even if source location is disabled, it doesn't mean that we have
+  // already report an error to the user: some concurrently running
+  // thread could have acquired it, but not yet printed the report.
+  if (Opts.FromUnrecoverableHandler)
+    return false;
+  return SLoc.isDisabled() || IsPCSuppressed(ET, Opts.pc, SLoc.getFilename());
+}
+
+const char *TypeCheckKinds[] = {
+    "load of", "store to", "reference binding to", "member access within",
+    "member call on", "constructor call on", "downcast of", "downcast of",
+    "upcast of", "cast to virtual base of"};
+}
+
+static void handleTypeMismatchImpl(TypeMismatchData *Data, ValueHandle Pointer,
+                                   ReportOptions Opts) {
+  Location Loc = Data->Loc.acquire();
+
+  ErrorType ET;
+  if (!Pointer)
+    ET = ErrorType::NullPointerUse;
+  else if (Data->Alignment && (Pointer & (Data->Alignment - 1)))
+    ET = ErrorType::MisalignedPointerUse;
+  else
+    ET = ErrorType::InsufficientObjectSize;
+
+  // Use the SourceLocation from Data to track deduplication, even if it's
+  // invalid.
+  if (ignoreReport(Loc.getSourceLocation(), Opts, ET))
+    return;
+
+  SymbolizedStackHolder FallbackLoc;
+  if (Data->Loc.isInvalid()) {
+    FallbackLoc.reset(getCallerLocation(Opts.pc));
+    Loc = FallbackLoc;
+  }
+
+  ScopedReport R(Opts, Loc, ET);
+
+  switch (ET) {
+  case ErrorType::NullPointerUse:
+    Diag(Loc, DL_Error, "%0 null pointer of type %1")
+        << TypeCheckKinds[Data->TypeCheckKind] << Data->Type;
+    break;
+  case ErrorType::MisalignedPointerUse:
+    Diag(Loc, DL_Error, "%0 misaligned address %1 for type %3, "
+                        "which requires %2 byte alignment")
+        << TypeCheckKinds[Data->TypeCheckKind] << (void *)Pointer
+        << Data->Alignment << Data->Type;
+    break;
+  case ErrorType::InsufficientObjectSize:
+    Diag(Loc, DL_Error, "%0 address %1 with insufficient space "
+                        "for an object of type %2")
+        << TypeCheckKinds[Data->TypeCheckKind] << (void *)Pointer << Data->Type;
+    break;
+  default:
+    UNREACHABLE("unexpected error type!");
+  }
+
+  if (Pointer)
+    Diag(Pointer, DL_Note, "pointer points here");
+}
+
+void __ubsan::__ubsan_handle_type_mismatch(TypeMismatchData *Data,
+                                           ValueHandle Pointer) {
+  GET_REPORT_OPTIONS(false);
+  handleTypeMismatchImpl(Data, Pointer, Opts);
+}
+void __ubsan::__ubsan_handle_type_mismatch_abort(TypeMismatchData *Data,
+                                                 ValueHandle Pointer) {
+  GET_REPORT_OPTIONS(true);
+  handleTypeMismatchImpl(Data, Pointer, Opts);
+  Die();
+}
+
+/// \brief Common diagnostic emission for various forms of integer overflow.
+template <typename T>
+static void handleIntegerOverflowImpl(OverflowData *Data, ValueHandle LHS,
+                                      const char *Operator, T RHS,
+                                      ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  bool IsSigned = Data->Type.isSignedIntegerTy();
+  ErrorType ET = IsSigned ? ErrorType::SignedIntegerOverflow
+                          : ErrorType::UnsignedIntegerOverflow;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error, "%0 integer overflow: "
+                      "%1 %2 %3 cannot be represented in type %4")
+    << (IsSigned ? "signed" : "unsigned")
+    << Value(Data->Type, LHS) << Operator << RHS << Data->Type;
+}
+
+#define UBSAN_OVERFLOW_HANDLER(handler_name, op, unrecoverable)                \
+  void __ubsan::handler_name(OverflowData *Data, ValueHandle LHS,              \
+                             ValueHandle RHS) {                                \
+    GET_REPORT_OPTIONS(unrecoverable);                                         \
+    handleIntegerOverflowImpl(Data, LHS, op, Value(Data->Type, RHS), Opts);    \
+    if (unrecoverable)                                                         \
+      Die();                                                                   \
+  }
+
+UBSAN_OVERFLOW_HANDLER(__ubsan_handle_add_overflow, "+", false)
+UBSAN_OVERFLOW_HANDLER(__ubsan_handle_add_overflow_abort, "+", true)
+UBSAN_OVERFLOW_HANDLER(__ubsan_handle_sub_overflow, "-", false)
+UBSAN_OVERFLOW_HANDLER(__ubsan_handle_sub_overflow_abort, "-", true)
+UBSAN_OVERFLOW_HANDLER(__ubsan_handle_mul_overflow, "*", false)
+UBSAN_OVERFLOW_HANDLER(__ubsan_handle_mul_overflow_abort, "*", true)
+
+static void handleNegateOverflowImpl(OverflowData *Data, ValueHandle OldVal,
+                                     ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  bool IsSigned = Data->Type.isSignedIntegerTy();
+  ErrorType ET = IsSigned ? ErrorType::SignedIntegerOverflow
+                          : ErrorType::UnsignedIntegerOverflow;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  if (IsSigned)
+    Diag(Loc, DL_Error,
+         "negation of %0 cannot be represented in type %1; "
+         "cast to an unsigned type to negate this value to itself")
+        << Value(Data->Type, OldVal) << Data->Type;
+  else
+    Diag(Loc, DL_Error, "negation of %0 cannot be represented in type %1")
+        << Value(Data->Type, OldVal) << Data->Type;
+}
+
+void __ubsan::__ubsan_handle_negate_overflow(OverflowData *Data,
+                                             ValueHandle OldVal) {
+  GET_REPORT_OPTIONS(false);
+  handleNegateOverflowImpl(Data, OldVal, Opts);
+}
+void __ubsan::__ubsan_handle_negate_overflow_abort(OverflowData *Data,
+                                                    ValueHandle OldVal) {
+  GET_REPORT_OPTIONS(true);
+  handleNegateOverflowImpl(Data, OldVal, Opts);
+  Die();
+}
+
+static void handleDivremOverflowImpl(OverflowData *Data, ValueHandle LHS,
+                                     ValueHandle RHS, ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  Value LHSVal(Data->Type, LHS);
+  Value RHSVal(Data->Type, RHS);
+
+  ErrorType ET;
+  if (RHSVal.isMinusOne())
+    ET = ErrorType::SignedIntegerOverflow;
+  else if (Data->Type.isIntegerTy())
+    ET = ErrorType::IntegerDivideByZero;
+  else
+    ET = ErrorType::FloatDivideByZero;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  switch (ET) {
+  case ErrorType::SignedIntegerOverflow:
+    Diag(Loc, DL_Error, "division of %0 by -1 cannot be represented in type %1")
+        << LHSVal << Data->Type;
+    break;
+  default:
+    Diag(Loc, DL_Error, "division by zero");
+    break;
+  }
+}
+
+void __ubsan::__ubsan_handle_divrem_overflow(OverflowData *Data,
+                                             ValueHandle LHS, ValueHandle RHS) {
+  GET_REPORT_OPTIONS(false);
+  handleDivremOverflowImpl(Data, LHS, RHS, Opts);
+}
+void __ubsan::__ubsan_handle_divrem_overflow_abort(OverflowData *Data,
+                                                    ValueHandle LHS,
+                                                    ValueHandle RHS) {
+  GET_REPORT_OPTIONS(true);
+  handleDivremOverflowImpl(Data, LHS, RHS, Opts);
+  Die();
+}
+
+static void handleShiftOutOfBoundsImpl(ShiftOutOfBoundsData *Data,
+                                       ValueHandle LHS, ValueHandle RHS,
+                                       ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  Value LHSVal(Data->LHSType, LHS);
+  Value RHSVal(Data->RHSType, RHS);
+
+  ErrorType ET;
+  if (RHSVal.isNegative() ||
+      RHSVal.getPositiveIntValue() >= Data->LHSType.getIntegerBitWidth())
+    ET = ErrorType::InvalidShiftExponent;
+  else
+    ET = ErrorType::InvalidShiftBase;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  if (ET == ErrorType::InvalidShiftExponent) {
+    if (RHSVal.isNegative())
+      Diag(Loc, DL_Error, "shift exponent %0 is negative") << RHSVal;
+    else
+      Diag(Loc, DL_Error, "shift exponent %0 is too large for %1-bit type %2")
+          << RHSVal << Data->LHSType.getIntegerBitWidth() << Data->LHSType;
+  } else {
+    if (LHSVal.isNegative())
+      Diag(Loc, DL_Error, "left shift of negative value %0") << LHSVal;
+    else
+      Diag(Loc, DL_Error,
+           "left shift of %0 by %1 places cannot be represented in type %2")
+          << LHSVal << RHSVal << Data->LHSType;
+  }
+}
+
+void __ubsan::__ubsan_handle_shift_out_of_bounds(ShiftOutOfBoundsData *Data,
+                                                 ValueHandle LHS,
+                                                 ValueHandle RHS) {
+  GET_REPORT_OPTIONS(false);
+  handleShiftOutOfBoundsImpl(Data, LHS, RHS, Opts);
+}
+void __ubsan::__ubsan_handle_shift_out_of_bounds_abort(
+                                                     ShiftOutOfBoundsData *Data,
+                                                     ValueHandle LHS,
+                                                     ValueHandle RHS) {
+  GET_REPORT_OPTIONS(true);
+  handleShiftOutOfBoundsImpl(Data, LHS, RHS, Opts);
+  Die();
+}
+
+static void handleOutOfBoundsImpl(OutOfBoundsData *Data, ValueHandle Index,
+                                  ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::OutOfBoundsIndex;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Value IndexVal(Data->IndexType, Index);
+  Diag(Loc, DL_Error, "index %0 out of bounds for type %1")
+    << IndexVal << Data->ArrayType;
+}
+
+void __ubsan::__ubsan_handle_out_of_bounds(OutOfBoundsData *Data,
+                                           ValueHandle Index) {
+  GET_REPORT_OPTIONS(false);
+  handleOutOfBoundsImpl(Data, Index, Opts);
+}
+void __ubsan::__ubsan_handle_out_of_bounds_abort(OutOfBoundsData *Data,
+                                                 ValueHandle Index) {
+  GET_REPORT_OPTIONS(true);
+  handleOutOfBoundsImpl(Data, Index, Opts);
+  Die();
+}
+
+static void handleBuiltinUnreachableImpl(UnreachableData *Data,
+                                         ReportOptions Opts) {
+  ScopedReport R(Opts, Data->Loc, ErrorType::UnreachableCall);
+  Diag(Data->Loc, DL_Error, "execution reached a __builtin_unreachable() call");
+}
+
+void __ubsan::__ubsan_handle_builtin_unreachable(UnreachableData *Data) {
+  GET_REPORT_OPTIONS(true);
+  handleBuiltinUnreachableImpl(Data, Opts);
+  Die();
+}
+
+static void handleMissingReturnImpl(UnreachableData *Data, ReportOptions Opts) {
+  ScopedReport R(Opts, Data->Loc, ErrorType::MissingReturn);
+  Diag(Data->Loc, DL_Error,
+       "execution reached the end of a value-returning function "
+       "without returning a value");
+}
+
+void __ubsan::__ubsan_handle_missing_return(UnreachableData *Data) {
+  GET_REPORT_OPTIONS(true);
+  handleMissingReturnImpl(Data, Opts);
+  Die();
+}
+
+static void handleVLABoundNotPositive(VLABoundData *Data, ValueHandle Bound,
+                                      ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::NonPositiveVLAIndex;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error, "variable length array bound evaluates to "
+                      "non-positive value %0")
+    << Value(Data->Type, Bound);
+}
+
+void __ubsan::__ubsan_handle_vla_bound_not_positive(VLABoundData *Data,
+                                                    ValueHandle Bound) {
+  GET_REPORT_OPTIONS(false);
+  handleVLABoundNotPositive(Data, Bound, Opts);
+}
+void __ubsan::__ubsan_handle_vla_bound_not_positive_abort(VLABoundData *Data,
+                                                          ValueHandle Bound) {
+  GET_REPORT_OPTIONS(true);
+  handleVLABoundNotPositive(Data, Bound, Opts);
+  Die();
+}
+
+static bool looksLikeFloatCastOverflowDataV1(void *Data) {
+  // First field is either a pointer to filename or a pointer to a
+  // TypeDescriptor.
+  u8 *FilenameOrTypeDescriptor;
+  internal_memcpy(&FilenameOrTypeDescriptor, Data,
+                  sizeof(FilenameOrTypeDescriptor));
+
+  // Heuristic: For float_cast_overflow, the TypeKind will be either TK_Integer
+  // (0x0), TK_Float (0x1) or TK_Unknown (0xff). If both types are known,
+  // adding both bytes will be 0 or 1 (for BE or LE). If it were a filename,
+  // adding two printable characters will not yield such a value. Otherwise,
+  // if one of them is 0xff, this is most likely TK_Unknown type descriptor.
+  u16 MaybeFromTypeKind =
+      FilenameOrTypeDescriptor[0] + FilenameOrTypeDescriptor[1];
+  return MaybeFromTypeKind < 2 || FilenameOrTypeDescriptor[0] == 0xff ||
+         FilenameOrTypeDescriptor[1] == 0xff;
+}
+
+static void handleFloatCastOverflow(void *DataPtr, ValueHandle From,
+                                    ReportOptions Opts) {
+  SymbolizedStackHolder CallerLoc;
+  Location Loc;
+  const TypeDescriptor *FromType, *ToType;
+  ErrorType ET = ErrorType::FloatCastOverflow;
+
+  if (looksLikeFloatCastOverflowDataV1(DataPtr)) {
+    auto Data = reinterpret_cast<FloatCastOverflowData *>(DataPtr);
+    CallerLoc.reset(getCallerLocation(Opts.pc));
+    Loc = CallerLoc;
+    FromType = &Data->FromType;
+    ToType = &Data->ToType;
+  } else {
+    auto Data = reinterpret_cast<FloatCastOverflowDataV2 *>(DataPtr);
+    SourceLocation SLoc = Data->Loc.acquire();
+    if (ignoreReport(SLoc, Opts, ET))
+      return;
+    Loc = SLoc;
+    FromType = &Data->FromType;
+    ToType = &Data->ToType;
+  }
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error,
+       "value %0 is outside the range of representable values of type %2")
+      << Value(*FromType, From) << *FromType << *ToType;
+}
+
+void __ubsan::__ubsan_handle_float_cast_overflow(void *Data, ValueHandle From) {
+  GET_REPORT_OPTIONS(false);
+  handleFloatCastOverflow(Data, From, Opts);
+}
+void __ubsan::__ubsan_handle_float_cast_overflow_abort(void *Data,
+                                                       ValueHandle From) {
+  GET_REPORT_OPTIONS(true);
+  handleFloatCastOverflow(Data, From, Opts);
+  Die();
+}
+
+static void handleLoadInvalidValue(InvalidValueData *Data, ValueHandle Val,
+                                   ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  // This check could be more precise if we used different handlers for
+  // -fsanitize=bool and -fsanitize=enum.
+  bool IsBool = (0 == internal_strcmp(Data->Type.getTypeName(), "'bool'"));
+  ErrorType ET =
+      IsBool ? ErrorType::InvalidBoolLoad : ErrorType::InvalidEnumLoad;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error,
+       "load of value %0, which is not a valid value for type %1")
+    << Value(Data->Type, Val) << Data->Type;
+}
+
+void __ubsan::__ubsan_handle_load_invalid_value(InvalidValueData *Data,
+                                                ValueHandle Val) {
+  GET_REPORT_OPTIONS(false);
+  handleLoadInvalidValue(Data, Val, Opts);
+}
+void __ubsan::__ubsan_handle_load_invalid_value_abort(InvalidValueData *Data,
+                                                      ValueHandle Val) {
+  GET_REPORT_OPTIONS(true);
+  handleLoadInvalidValue(Data, Val, Opts);
+  Die();
+}
+
+static void handleFunctionTypeMismatch(FunctionTypeMismatchData *Data,
+                                       ValueHandle Function,
+                                       ReportOptions Opts) {
+  SourceLocation CallLoc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::FunctionTypeMismatch;
+
+  if (ignoreReport(CallLoc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, CallLoc, ET);
+
+  SymbolizedStackHolder FLoc(getSymbolizedLocation(Function));
+  const char *FName = FLoc.get()->info.function;
+  if (!FName)
+    FName = "(unknown)";
+
+  Diag(CallLoc, DL_Error,
+       "call to function %0 through pointer to incorrect function type %1")
+      << FName << Data->Type;
+  Diag(FLoc, DL_Note, "%0 defined here") << FName;
+}
+
+void
+__ubsan::__ubsan_handle_function_type_mismatch(FunctionTypeMismatchData *Data,
+                                               ValueHandle Function) {
+  GET_REPORT_OPTIONS(false);
+  handleFunctionTypeMismatch(Data, Function, Opts);
+}
+
+void __ubsan::__ubsan_handle_function_type_mismatch_abort(
+    FunctionTypeMismatchData *Data, ValueHandle Function) {
+  GET_REPORT_OPTIONS(true);
+  handleFunctionTypeMismatch(Data, Function, Opts);
+  Die();
+}
+
+static void handleNonNullReturn(NonNullReturnData *Data, ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::InvalidNullReturn;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error, "null pointer returned from function declared to never "
+                      "return null");
+  if (!Data->AttrLoc.isInvalid())
+    Diag(Data->AttrLoc, DL_Note, "returns_nonnull attribute specified here");
+}
+
+void __ubsan::__ubsan_handle_nonnull_return(NonNullReturnData *Data) {
+  GET_REPORT_OPTIONS(false);
+  handleNonNullReturn(Data, Opts);
+}
+
+void __ubsan::__ubsan_handle_nonnull_return_abort(NonNullReturnData *Data) {
+  GET_REPORT_OPTIONS(true);
+  handleNonNullReturn(Data, Opts);
+  Die();
+}
+
+static void handleNonNullArg(NonNullArgData *Data, ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::InvalidNullArgument;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error, "null pointer passed as argument %0, which is declared to "
+       "never be null") << Data->ArgIndex;
+  if (!Data->AttrLoc.isInvalid())
+    Diag(Data->AttrLoc, DL_Note, "nonnull attribute specified here");
+}
+
+void __ubsan::__ubsan_handle_nonnull_arg(NonNullArgData *Data) {
+  GET_REPORT_OPTIONS(false);
+  handleNonNullArg(Data, Opts);
+}
+
+void __ubsan::__ubsan_handle_nonnull_arg_abort(NonNullArgData *Data) {
+  GET_REPORT_OPTIONS(true);
+  handleNonNullArg(Data, Opts);
+  Die();
+}
+
+static void handleCFIBadIcall(CFIBadIcallData *Data, ValueHandle Function,
+                              ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::CFIBadType;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error, "control flow integrity check for type %0 failed during "
+                      "indirect function call")
+      << Data->Type;
+
+  SymbolizedStackHolder FLoc(getSymbolizedLocation(Function));
+  const char *FName = FLoc.get()->info.function;
+  if (!FName)
+    FName = "(unknown)";
+  Diag(FLoc, DL_Note, "%0 defined here") << FName;
+}
+
+void __ubsan::__ubsan_handle_cfi_bad_icall(CFIBadIcallData *Data,
+                                           ValueHandle Function) {
+  GET_REPORT_OPTIONS(false);
+  handleCFIBadIcall(Data, Function, Opts);
+}
+
+void __ubsan::__ubsan_handle_cfi_bad_icall_abort(CFIBadIcallData *Data,
+                                                 ValueHandle Function) {
+  GET_REPORT_OPTIONS(true);
+  handleCFIBadIcall(Data, Function, Opts);
+  Die();
+}
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers.h b/compiler-rt/lib/ubsan/ubsan_handlers.h
new file mode 100644
index 0000000..6f309cf
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_handlers.h
@@ -0,0 +1,161 @@
+//===-- ubsan_handlers.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Entry points to the runtime library for Clang's undefined behavior sanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_HANDLERS_H
+#define UBSAN_HANDLERS_H
+
+#include "ubsan_value.h"
+
+namespace __ubsan {
+
+struct TypeMismatchData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+  uptr Alignment;
+  unsigned char TypeCheckKind;
+};
+
+#define UNRECOVERABLE(checkname, ...) \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
+    void __ubsan_handle_ ## checkname( __VA_ARGS__ );
+
+#define RECOVERABLE(checkname, ...) \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE \
+    void __ubsan_handle_ ## checkname( __VA_ARGS__ ); \
+  extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
+    void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ );
+
+/// \brief Handle a runtime type check failure, caused by either a misaligned
+/// pointer, a null pointer, or a pointer to insufficient storage for the
+/// type.
+RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer)
+
+struct OverflowData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+};
+
+/// \brief Handle an integer addition overflow.
+RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
+
+/// \brief Handle an integer subtraction overflow.
+RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
+
+/// \brief Handle an integer multiplication overflow.
+RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
+
+/// \brief Handle a signed integer overflow for a unary negate operator.
+RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)
+
+/// \brief Handle an INT_MIN/-1 overflow or division by zero.
+RECOVERABLE(divrem_overflow, OverflowData *Data,
+            ValueHandle LHS, ValueHandle RHS)
+
+struct ShiftOutOfBoundsData {
+  SourceLocation Loc;
+  const TypeDescriptor &LHSType;
+  const TypeDescriptor &RHSType;
+};
+
+/// \brief Handle a shift where the RHS is out of bounds or a left shift where
+/// the LHS is negative or overflows.
+RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
+            ValueHandle LHS, ValueHandle RHS)
+
+struct OutOfBoundsData {
+  SourceLocation Loc;
+  const TypeDescriptor &ArrayType;
+  const TypeDescriptor &IndexType;
+};
+
+/// \brief Handle an array index out of bounds error.
+RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)
+
+struct UnreachableData {
+  SourceLocation Loc;
+};
+
+/// \brief Handle a __builtin_unreachable which is reached.
+UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
+/// \brief Handle reaching the end of a value-returning function.
+UNRECOVERABLE(missing_return, UnreachableData *Data)
+
+struct VLABoundData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+};
+
+/// \brief Handle a VLA with a non-positive bound.
+RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)
+
+// Keeping this around for binary compatibility with (sanitized) programs
+// compiled with older compilers.
+struct FloatCastOverflowData {
+  const TypeDescriptor &FromType;
+  const TypeDescriptor &ToType;
+};
+
+struct FloatCastOverflowDataV2 {
+  SourceLocation Loc;
+  const TypeDescriptor &FromType;
+  const TypeDescriptor &ToType;
+};
+
+/// Handle overflow in a conversion to or from a floating-point type.
+/// void *Data is one of FloatCastOverflowData* or FloatCastOverflowDataV2*
+RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From)
+
+struct InvalidValueData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+};
+
+/// \brief Handle a load of an invalid value for the type.
+RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
+
+struct FunctionTypeMismatchData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+};
+
+RECOVERABLE(function_type_mismatch,
+            FunctionTypeMismatchData *Data,
+            ValueHandle Val)
+
+struct NonNullReturnData {
+  SourceLocation Loc;
+  SourceLocation AttrLoc;
+};
+
+/// \brief Handle returning null from function with returns_nonnull attribute.
+RECOVERABLE(nonnull_return, NonNullReturnData *Data)
+
+struct NonNullArgData {
+  SourceLocation Loc;
+  SourceLocation AttrLoc;
+  int ArgIndex;
+};
+
+/// \brief Handle passing null pointer to function with nonnull attribute.
+RECOVERABLE(nonnull_arg, NonNullArgData *Data)
+
+struct CFIBadIcallData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+};
+
+/// \brief Handle control flow integrity failure for indirect function calls.
+RECOVERABLE(cfi_bad_icall, CFIBadIcallData *Data, ValueHandle Function)
+
+}
+
+#endif // UBSAN_HANDLERS_H
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers_cxx.cc b/compiler-rt/lib/ubsan/ubsan_handlers_cxx.cc
new file mode 100644
index 0000000..3e81be6
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_handlers_cxx.cc
@@ -0,0 +1,133 @@
+//===-- ubsan_handlers_cxx.cc ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Error logging entry points for the UBSan runtime, which are only used for C++
+// compilations. This file is permitted to use language features which require
+// linking against a C++ ABI library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_handlers_cxx.h"
+#include "ubsan_diag.h"
+#include "ubsan_type_hash.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+
+using namespace __sanitizer;
+using namespace __ubsan;
+
+namespace __ubsan {
+  extern const char *TypeCheckKinds[];
+}
+
+// Returns true if UBSan has printed an error report.
+static bool HandleDynamicTypeCacheMiss(
+    DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash,
+    ReportOptions Opts) {
+  if (checkDynamicType((void*)Pointer, Data->TypeInfo, Hash))
+    // Just a cache miss. The type matches after all.
+    return false;
+
+  // Check if error report should be suppressed.
+  DynamicTypeInfo DTI = getDynamicTypeInfoFromObject((void*)Pointer);
+  if (DTI.isValid() && IsVptrCheckSuppressed(DTI.getMostDerivedTypeName()))
+    return false;
+
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::DynamicTypeMismatch;
+  if (ignoreReport(Loc, Opts, ET))
+    return false;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  Diag(Loc, DL_Error,
+       "%0 address %1 which does not point to an object of type %2")
+    << TypeCheckKinds[Data->TypeCheckKind] << (void*)Pointer << Data->Type;
+
+  // If possible, say what type it actually points to.
+  if (!DTI.isValid())
+    Diag(Pointer, DL_Note, "object has invalid vptr")
+        << TypeName(DTI.getMostDerivedTypeName())
+        << Range(Pointer, Pointer + sizeof(uptr), "invalid vptr");
+  else if (!DTI.getOffset())
+    Diag(Pointer, DL_Note, "object is of type %0")
+        << TypeName(DTI.getMostDerivedTypeName())
+        << Range(Pointer, Pointer + sizeof(uptr), "vptr for %0");
+  else
+    // FIXME: Find the type at the specified offset, and include that
+    //        in the note.
+    Diag(Pointer - DTI.getOffset(), DL_Note,
+         "object is base class subobject at offset %0 within object of type %1")
+        << DTI.getOffset() << TypeName(DTI.getMostDerivedTypeName())
+        << TypeName(DTI.getSubobjectTypeName())
+        << Range(Pointer, Pointer + sizeof(uptr),
+                 "vptr for %2 base class of %1");
+  return true;
+}
+
+void __ubsan::__ubsan_handle_dynamic_type_cache_miss(
+    DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash) {
+  GET_REPORT_OPTIONS(false);
+  HandleDynamicTypeCacheMiss(Data, Pointer, Hash, Opts);
+}
+void __ubsan::__ubsan_handle_dynamic_type_cache_miss_abort(
+    DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash) {
+  // Note: -fsanitize=vptr is always recoverable.
+  GET_REPORT_OPTIONS(false);
+  if (HandleDynamicTypeCacheMiss(Data, Pointer, Hash, Opts))
+    Die();
+}
+
+static void HandleCFIBadType(CFIBadTypeData *Data, ValueHandle Vtable,
+                             ReportOptions Opts) {
+  SourceLocation Loc = Data->Loc.acquire();
+  ErrorType ET = ErrorType::CFIBadType;
+
+  if (ignoreReport(Loc, Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+  DynamicTypeInfo DTI = getDynamicTypeInfoFromVtable((void*)Vtable);
+
+  static const char *TypeCheckKinds[] = {
+    "virtual call",
+    "non-virtual call",
+    "base-to-derived cast",
+    "cast to unrelated type",
+  };
+
+  Diag(Loc, DL_Error, "control flow integrity check for type %0 failed during "
+                      "%1 (vtable address %2)")
+      << Data->Type << TypeCheckKinds[Data->TypeCheckKind] << (void *)Vtable;
+
+  // If possible, say what type it actually points to.
+  if (!DTI.isValid())
+    Diag(Vtable, DL_Note, "invalid vtable");
+  else
+    Diag(Vtable, DL_Note, "vtable is of type %0")
+        << TypeName(DTI.getMostDerivedTypeName());
+}
+
+void __ubsan::__ubsan_handle_cfi_bad_type(CFIBadTypeData *Data,
+                                          ValueHandle Vtable) {
+  GET_REPORT_OPTIONS(false);
+  HandleCFIBadType(Data, Vtable, Opts);
+}
+
+void __ubsan::__ubsan_handle_cfi_bad_type_abort(CFIBadTypeData *Data,
+                                                ValueHandle Vtable) {
+  GET_REPORT_OPTIONS(true);
+  HandleCFIBadType(Data, Vtable, Opts);
+  Die();
+}
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers_cxx.h b/compiler-rt/lib/ubsan/ubsan_handlers_cxx.h
new file mode 100644
index 0000000..92050d9
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_handlers_cxx.h
@@ -0,0 +1,53 @@
+//===-- ubsan_handlers_cxx.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Entry points to the runtime library for Clang's undefined behavior sanitizer,
+// for C++-specific checks. This code is not linked into C binaries.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_HANDLERS_CXX_H
+#define UBSAN_HANDLERS_CXX_H
+
+#include "ubsan_value.h"
+
+namespace __ubsan {
+
+struct DynamicTypeCacheMissData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+  void *TypeInfo;
+  unsigned char TypeCheckKind;
+};
+
+struct CFIBadTypeData {
+  SourceLocation Loc;
+  const TypeDescriptor &Type;
+  unsigned char TypeCheckKind;
+};
+
+/// \brief Handle a runtime type check failure, caused by an incorrect vptr.
+/// When this handler is called, all we know is that the type was not in the
+/// cache; this does not necessarily imply the existence of a bug.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __ubsan_handle_dynamic_type_cache_miss(
+  DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash);
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+void __ubsan_handle_dynamic_type_cache_miss_abort(
+  DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash);
+
+/// \brief Handle a control flow integrity check failure by printing a
+/// diagnostic.
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
+__ubsan_handle_cfi_bad_type(CFIBadTypeData *Data, ValueHandle Vtable);
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
+__ubsan_handle_cfi_bad_type_abort(CFIBadTypeData *Data, ValueHandle Vtable);
+
+}
+
+#endif // UBSAN_HANDLERS_H
diff --git a/compiler-rt/lib/ubsan/ubsan_init.cc b/compiler-rt/lib/ubsan/ubsan_init.cc
new file mode 100644
index 0000000..73398ce
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_init.cc
@@ -0,0 +1,78 @@
+//===-- ubsan_init.cc -----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Initialization of UBSan runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_diag.h"
+#include "ubsan_init.h"
+#include "ubsan_flags.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_mutex.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+using namespace __ubsan;
+
+static enum {
+  UBSAN_MODE_UNKNOWN = 0,
+  UBSAN_MODE_STANDALONE,
+  UBSAN_MODE_PLUGIN
+} ubsan_mode;
+static StaticSpinMutex ubsan_init_mu;
+
+static void CommonInit() {
+  InitializeSuppressions();
+}
+
+static void CommonStandaloneInit() {
+  SanitizerToolName = "UndefinedBehaviorSanitizer";
+  InitializeFlags();
+  CacheBinaryName();
+  __sanitizer_set_report_path(common_flags()->log_path);
+  InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
+  CommonInit();
+  ubsan_mode = UBSAN_MODE_STANDALONE;
+}
+
+void __ubsan::InitAsStandalone() {
+  if (SANITIZER_CAN_USE_PREINIT_ARRAY) {
+    CHECK_EQ(UBSAN_MODE_UNKNOWN, ubsan_mode);
+    CommonStandaloneInit();
+    return;
+  }
+  SpinMutexLock l(&ubsan_init_mu);
+  CHECK_NE(UBSAN_MODE_PLUGIN, ubsan_mode);
+  if (ubsan_mode == UBSAN_MODE_UNKNOWN)
+    CommonStandaloneInit();
+}
+
+void __ubsan::InitAsStandaloneIfNecessary() {
+  if (SANITIZER_CAN_USE_PREINIT_ARRAY) {
+    CHECK_NE(UBSAN_MODE_UNKNOWN, ubsan_mode);
+    return;
+  }
+  SpinMutexLock l(&ubsan_init_mu);
+  if (ubsan_mode == UBSAN_MODE_UNKNOWN)
+    CommonStandaloneInit();
+}
+
+void __ubsan::InitAsPlugin() {
+#if !SANITIZER_CAN_USE_PREINIT_ARRAY
+  SpinMutexLock l(&ubsan_init_mu);
+#endif
+  CHECK_EQ(UBSAN_MODE_UNKNOWN, ubsan_mode);
+  CommonInit();
+  ubsan_mode = UBSAN_MODE_PLUGIN;
+}
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_init.h b/compiler-rt/lib/ubsan/ubsan_init.h
new file mode 100644
index 0000000..103ae24
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_init.h
@@ -0,0 +1,31 @@
+//===-- ubsan_init.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Initialization function for UBSan runtime.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_INIT_H
+#define UBSAN_INIT_H
+
+namespace __ubsan {
+
+// Initialize UBSan as a standalone tool. Typically should be called early
+// during initialization.
+void InitAsStandalone();
+
+// Initialize UBSan as a standalone tool, if it hasn't been initialized before.
+void InitAsStandaloneIfNecessary();
+
+// Initializes UBSan as a plugin tool. This function should be called once
+// from "parent tool" (e.g. ASan) initialization.
+void InitAsPlugin();
+
+}  // namespace __ubsan
+
+#endif  // UBSAN_INIT_H
diff --git a/compiler-rt/lib/ubsan/ubsan_init_standalone.cc b/compiler-rt/lib/ubsan/ubsan_init_standalone.cc
new file mode 100644
index 0000000..ff1a20e
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_init_standalone.cc
@@ -0,0 +1,35 @@
+//===-- ubsan_init_standalone.cc ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Initialization of standalone UBSan runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if !CAN_SANITIZE_UB
+# error "UBSan is not supported on this platform!"
+#endif
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "ubsan_init.h"
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+__attribute__((section(".preinit_array"), used))
+void (*__local_ubsan_preinit)(void) = __ubsan::InitAsStandalone;
+#else
+// Use a dynamic initializer.
+class UbsanStandaloneInitializer {
+ public:
+  UbsanStandaloneInitializer() {
+    __ubsan::InitAsStandalone();
+  }
+};
+static UbsanStandaloneInitializer ubsan_standalone_initializer;
+#endif  // SANITIZER_CAN_USE_PREINIT_ARRAY
+
diff --git a/compiler-rt/lib/ubsan/ubsan_platform.h b/compiler-rt/lib/ubsan/ubsan_platform.h
new file mode 100644
index 0000000..002ecf3
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_platform.h
@@ -0,0 +1,27 @@
+//===-- ubsan_platform.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the platforms which UBSan is supported at.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_PLATFORM_H
+#define UBSAN_PLATFORM_H
+
+// Other platforms should be easy to add, and probably work as-is.
+#if (defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)) && \
+    (defined(__x86_64__) || defined(__i386__) || defined(__arm__) || \
+     defined(__aarch64__) || defined(__mips__) || defined(__powerpc64__))
+# define CAN_SANITIZE_UB 1
+#elif defined(_WIN32)
+# define CAN_SANITIZE_UB 1
+#else
+# define CAN_SANITIZE_UB 0
+#endif
+
+#endif
diff --git a/compiler-rt/lib/ubsan/ubsan_type_hash.cc b/compiler-rt/lib/ubsan/ubsan_type_hash.cc
new file mode 100644
index 0000000..a217c86
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_type_hash.cc
@@ -0,0 +1,34 @@
+//===-- ubsan_type_hash.cc ------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of a hash table for fast checking of inheritance
+// relationships. This file is only linked into C++ compilations, and is
+// permitted to use language features which require a C++ ABI library.
+//
+// Most of the implementation lives in an ABI-specific source file
+// (ubsan_type_hash_{itanium,win}.cc).
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_type_hash.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+
+/// A cache of recently-checked hashes. Mini hash table with "random" evictions.
+__ubsan::HashValue
+__ubsan::__ubsan_vptr_type_cache[__ubsan::VptrTypeCacheSize];
+
+__ubsan::DynamicTypeInfo __ubsan::getDynamicTypeInfoFromObject(void *Object) {
+  void *VtablePtr = *reinterpret_cast<void **>(Object);
+  return getDynamicTypeInfoFromVtable(VtablePtr);
+}
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_type_hash.h b/compiler-rt/lib/ubsan/ubsan_type_hash.h
new file mode 100644
index 0000000..695fed9
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_type_hash.h
@@ -0,0 +1,66 @@
+//===-- ubsan_type_hash.h ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Hashing of types for Clang's undefined behavior checker.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_TYPE_HASH_H
+#define UBSAN_TYPE_HASH_H
+
+#include "sanitizer_common/sanitizer_common.h"
+
+namespace __ubsan {
+
+typedef uptr HashValue;
+
+/// \brief Information about the dynamic type of an object (extracted from its
+/// vptr).
+class DynamicTypeInfo {
+  const char *MostDerivedTypeName;
+  sptr Offset;
+  const char *SubobjectTypeName;
+
+public:
+  DynamicTypeInfo(const char *MDTN, sptr Offset, const char *STN)
+    : MostDerivedTypeName(MDTN), Offset(Offset), SubobjectTypeName(STN) {}
+
+  /// Determine whether the object had a valid dynamic type.
+  bool isValid() const { return MostDerivedTypeName; }
+  /// Get the name of the most-derived type of the object.
+  const char *getMostDerivedTypeName() const { return MostDerivedTypeName; }
+  /// Get the offset from the most-derived type to this base class.
+  sptr getOffset() const { return Offset; }
+  /// Get the name of the most-derived type at the specified offset.
+  const char *getSubobjectTypeName() const { return SubobjectTypeName; }
+};
+
+/// \brief Get information about the dynamic type of an object.
+DynamicTypeInfo getDynamicTypeInfoFromObject(void *Object);
+
+/// \brief Get information about the dynamic type of an object from its vtable.
+DynamicTypeInfo getDynamicTypeInfoFromVtable(void *Vtable);
+
+/// \brief Check whether the dynamic type of \p Object has a \p Type subobject
+/// at offset 0.
+/// \return \c true if the type matches, \c false if not.
+bool checkDynamicType(void *Object, void *Type, HashValue Hash);
+
+const unsigned VptrTypeCacheSize = 128;
+
+/// \brief A cache of the results of checkDynamicType. \c checkDynamicType would
+/// return \c true (modulo hash collisions) if
+/// \code
+///   __ubsan_vptr_type_cache[Hash % VptrTypeCacheSize] == Hash
+/// \endcode
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE
+HashValue __ubsan_vptr_type_cache[VptrTypeCacheSize];
+
+} // namespace __ubsan
+
+#endif // UBSAN_TYPE_HASH_H
diff --git a/compiler-rt/lib/ubsan/ubsan_type_hash_itanium.cc b/compiler-rt/lib/ubsan/ubsan_type_hash_itanium.cc
new file mode 100644
index 0000000..b84e88d
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_type_hash_itanium.cc
@@ -0,0 +1,251 @@
+//===-- ubsan_type_hash_itanium.cc ----------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of type hashing/lookup for Itanium C++ ABI.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB && !SANITIZER_WINDOWS
+#include "ubsan_type_hash.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+
+// The following are intended to be binary compatible with the definitions
+// given in the Itanium ABI. We make no attempt to be ODR-compatible with
+// those definitions, since existing ABI implementations aren't.
+
+namespace std {
+  class type_info {
+  public:
+    virtual ~type_info();
+
+    const char *__type_name;
+  };
+}
+
+namespace __cxxabiv1 {
+
+/// Type info for classes with no bases, and base class for type info for
+/// classes with bases.
+class __class_type_info : public std::type_info {
+  ~__class_type_info() override;
+};
+
+/// Type info for classes with simple single public inheritance.
+class __si_class_type_info : public __class_type_info {
+public:
+  ~__si_class_type_info() override;
+
+  const __class_type_info *__base_type;
+};
+
+class __base_class_type_info {
+public:
+  const __class_type_info *__base_type;
+  long __offset_flags;
+
+  enum __offset_flags_masks {
+    __virtual_mask = 0x1,
+    __public_mask = 0x2,
+    __offset_shift = 8
+  };
+};
+
+/// Type info for classes with multiple, virtual, or non-public inheritance.
+class __vmi_class_type_info : public __class_type_info {
+public:
+  ~__vmi_class_type_info() override;
+
+  unsigned int flags;
+  unsigned int base_count;
+  __base_class_type_info base_info[1];
+};
+
+}
+
+namespace abi = __cxxabiv1;
+
+// We implement a simple two-level cache for type-checking results. For each
+// (vptr,type) pair, a hash is computed. This hash is assumed to be globally
+// unique; if it collides, we will get false negatives, but:
+//  * such a collision would have to occur on the *first* bad access,
+//  * the probability of such a collision is low (and for a 64-bit target, is
+//    negligible), and
+//  * the vptr, and thus the hash, can be affected by ASLR, so multiple runs
+//    give better coverage.
+//
+// The first caching layer is a small hash table with no chaining; buckets are
+// reused as needed. The second caching layer is a large hash table with open
+// chaining. We can freely evict from either layer since this is just a cache.
+//
+// FIXME: Make these hash table accesses thread-safe. The races here are benign:
+//        assuming the unsequenced loads and stores don't misbehave too badly,
+//        the worst case is false negatives or poor cache behavior, not false
+//        positives or crashes.
+
+/// Find a bucket to store the given hash value in.
+static __ubsan::HashValue *getTypeCacheHashTableBucket(__ubsan::HashValue V) {
+  static const unsigned HashTableSize = 65537;
+  static __ubsan::HashValue __ubsan_vptr_hash_set[HashTableSize];
+
+  unsigned First = (V & 65535) ^ 1;
+  unsigned Probe = First;
+  for (int Tries = 5; Tries; --Tries) {
+    if (!__ubsan_vptr_hash_set[Probe] || __ubsan_vptr_hash_set[Probe] == V)
+      return &__ubsan_vptr_hash_set[Probe];
+    Probe += ((V >> 16) & 65535) + 1;
+    if (Probe >= HashTableSize)
+      Probe -= HashTableSize;
+  }
+  // FIXME: Pick a random entry from the probe sequence to evict rather than
+  //        just taking the first.
+  return &__ubsan_vptr_hash_set[First];
+}
+
+/// \brief Determine whether \p Derived has a \p Base base class subobject at
+/// offset \p Offset.
+static bool isDerivedFromAtOffset(const abi::__class_type_info *Derived,
+                                  const abi::__class_type_info *Base,
+                                  sptr Offset) {
+  if (Derived->__type_name == Base->__type_name)
+    return Offset == 0;
+
+  if (const abi::__si_class_type_info *SI =
+        dynamic_cast<const abi::__si_class_type_info*>(Derived))
+    return isDerivedFromAtOffset(SI->__base_type, Base, Offset);
+
+  const abi::__vmi_class_type_info *VTI =
+    dynamic_cast<const abi::__vmi_class_type_info*>(Derived);
+  if (!VTI)
+    // No base class subobjects.
+    return false;
+
+  // Look for a base class which is derived from \p Base at the right offset.
+  for (unsigned int base = 0; base != VTI->base_count; ++base) {
+    // FIXME: Curtail the recursion if this base can't possibly contain the
+    //        given offset.
+    sptr OffsetHere = VTI->base_info[base].__offset_flags >>
+                      abi::__base_class_type_info::__offset_shift;
+    if (VTI->base_info[base].__offset_flags &
+          abi::__base_class_type_info::__virtual_mask)
+      // For now, just punt on virtual bases and say 'yes'.
+      // FIXME: OffsetHere is the offset in the vtable of the virtual base
+      //        offset. Read the vbase offset out of the vtable and use it.
+      return true;
+    if (isDerivedFromAtOffset(VTI->base_info[base].__base_type,
+                              Base, Offset - OffsetHere))
+      return true;
+  }
+
+  return false;
+}
+
+/// \brief Find the derived-most dynamic base class of \p Derived at offset
+/// \p Offset.
+static const abi::__class_type_info *findBaseAtOffset(
+    const abi::__class_type_info *Derived, sptr Offset) {
+  if (!Offset)
+    return Derived;
+
+  if (const abi::__si_class_type_info *SI =
+        dynamic_cast<const abi::__si_class_type_info*>(Derived))
+    return findBaseAtOffset(SI->__base_type, Offset);
+
+  const abi::__vmi_class_type_info *VTI =
+    dynamic_cast<const abi::__vmi_class_type_info*>(Derived);
+  if (!VTI)
+    // No base class subobjects.
+    return 0;
+
+  for (unsigned int base = 0; base != VTI->base_count; ++base) {
+    sptr OffsetHere = VTI->base_info[base].__offset_flags >>
+                      abi::__base_class_type_info::__offset_shift;
+    if (VTI->base_info[base].__offset_flags &
+          abi::__base_class_type_info::__virtual_mask)
+      // FIXME: Can't handle virtual bases yet.
+      continue;
+    if (const abi::__class_type_info *Base =
+          findBaseAtOffset(VTI->base_info[base].__base_type,
+                           Offset - OffsetHere))
+      return Base;
+  }
+
+  return 0;
+}
+
+namespace {
+
+struct VtablePrefix {
+  /// The offset from the vptr to the start of the most-derived object.
+  /// This will only be greater than zero in some virtual base class vtables
+  /// used during object con-/destruction, and will usually be exactly zero.
+  sptr Offset;
+  /// The type_info object describing the most-derived class type.
+  std::type_info *TypeInfo;
+};
+VtablePrefix *getVtablePrefix(void *Vtable) {
+  VtablePrefix *Vptr = reinterpret_cast<VtablePrefix*>(Vtable);
+  if (!Vptr)
+    return 0;
+  VtablePrefix *Prefix = Vptr - 1;
+  if (!Prefix->TypeInfo)
+    // This can't possibly be a valid vtable.
+    return 0;
+  return Prefix;
+}
+
+}
+
+bool __ubsan::checkDynamicType(void *Object, void *Type, HashValue Hash) {
+  // A crash anywhere within this function probably means the vptr is corrupted.
+  // FIXME: Perform these checks more cautiously.
+
+  // Check whether this is something we've evicted from the cache.
+  HashValue *Bucket = getTypeCacheHashTableBucket(Hash);
+  if (*Bucket == Hash) {
+    __ubsan_vptr_type_cache[Hash % VptrTypeCacheSize] = Hash;
+    return true;
+  }
+
+  void *VtablePtr = *reinterpret_cast<void **>(Object);
+  VtablePrefix *Vtable = getVtablePrefix(VtablePtr);
+  if (!Vtable)
+    return false;
+
+  // Check that this is actually a type_info object for a class type.
+  abi::__class_type_info *Derived =
+    dynamic_cast<abi::__class_type_info*>(Vtable->TypeInfo);
+  if (!Derived)
+    return false;
+
+  abi::__class_type_info *Base = (abi::__class_type_info*)Type;
+  if (!isDerivedFromAtOffset(Derived, Base, -Vtable->Offset))
+    return false;
+
+  // Success. Cache this result.
+  __ubsan_vptr_type_cache[Hash % VptrTypeCacheSize] = Hash;
+  *Bucket = Hash;
+  return true;
+}
+
+__ubsan::DynamicTypeInfo
+__ubsan::getDynamicTypeInfoFromVtable(void *VtablePtr) {
+  VtablePrefix *Vtable = getVtablePrefix(VtablePtr);
+  if (!Vtable)
+    return DynamicTypeInfo(0, 0, 0);
+  const abi::__class_type_info *ObjectType = findBaseAtOffset(
+    static_cast<const abi::__class_type_info*>(Vtable->TypeInfo),
+    -Vtable->Offset);
+  return DynamicTypeInfo(Vtable->TypeInfo->__type_name, -Vtable->Offset,
+                         ObjectType ? ObjectType->__type_name : "<unknown>");
+}
+
+#endif  // CAN_SANITIZE_UB && !SANITIZER_WINDOWS
diff --git a/compiler-rt/lib/ubsan/ubsan_type_hash_win.cc b/compiler-rt/lib/ubsan/ubsan_type_hash_win.cc
new file mode 100644
index 0000000..271c4aa
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_type_hash_win.cc
@@ -0,0 +1,81 @@
+//===-- ubsan_type_hash_win.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of type hashing/lookup for Microsoft C++ ABI.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB && SANITIZER_WINDOWS
+#include "ubsan_type_hash.h"
+
+#include "sanitizer_common/sanitizer_common.h"
+
+#include <typeinfo>
+
+struct CompleteObjectLocator {
+  int is_image_relative;
+  int offset_to_top;
+  int vfptr_offset;
+  int rtti_addr;
+  int chd_addr;
+  int obj_locator_addr;
+};
+
+struct CompleteObjectLocatorAbs {
+  int is_image_relative;
+  int offset_to_top;
+  int vfptr_offset;
+  std::type_info *rtti_addr;
+  void *chd_addr;
+  CompleteObjectLocator *obj_locator_addr;
+};
+
+bool __ubsan::checkDynamicType(void *Object, void *Type, HashValue Hash) {
+  // FIXME: Implement.
+  return false;
+}
+
+__ubsan::DynamicTypeInfo
+__ubsan::getDynamicTypeInfoFromVtable(void *VtablePtr) {
+  // The virtual table may not have a complete object locator if the object
+  // was compiled without RTTI (i.e. we might be reading from some other global
+  // laid out before the virtual table), so we need to carefully validate each
+  // pointer dereference and perform sanity checks.
+  CompleteObjectLocator **obj_locator_ptr =
+    ((CompleteObjectLocator**)VtablePtr)-1;
+  if (!IsAccessibleMemoryRange((uptr)obj_locator_ptr, sizeof(void*)))
+    return DynamicTypeInfo(0, 0, 0);
+
+  CompleteObjectLocator *obj_locator = *obj_locator_ptr;
+  if (!IsAccessibleMemoryRange((uptr)obj_locator,
+                               sizeof(CompleteObjectLocator)))
+    return DynamicTypeInfo(0, 0, 0);
+
+  std::type_info *tinfo;
+  if (obj_locator->is_image_relative == 1) {
+    char *image_base = ((char *)obj_locator) - obj_locator->obj_locator_addr;
+    tinfo = (std::type_info *)(image_base + obj_locator->rtti_addr);
+  } else if (obj_locator->is_image_relative == 0)
+    tinfo = ((CompleteObjectLocatorAbs *)obj_locator)->rtti_addr;
+  else
+    // Probably not a complete object locator.
+    return DynamicTypeInfo(0, 0, 0);
+
+  if (!IsAccessibleMemoryRange((uptr)tinfo, sizeof(std::type_info)))
+    return DynamicTypeInfo(0, 0, 0);
+
+  // Okay, this is probably a std::type_info. Request its name.
+  // FIXME: Implement a base class search like we do for Itanium.
+  return DynamicTypeInfo(tinfo->name(), obj_locator->offset_to_top,
+                         "<unknown>");
+}
+
+#endif  // CAN_SANITIZE_UB && SANITIZER_WINDOWS
diff --git a/compiler-rt/lib/ubsan/ubsan_value.cc b/compiler-rt/lib/ubsan/ubsan_value.cc
new file mode 100644
index 0000000..79dc4c8
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_value.cc
@@ -0,0 +1,113 @@
+//===-- ubsan_value.cc ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Representation of a runtime value, as marshaled from the generated code to
+// the ubsan runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ubsan_platform.h"
+#if CAN_SANITIZE_UB
+#include "ubsan_value.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+
+using namespace __ubsan;
+
+SIntMax Value::getSIntValue() const {
+  CHECK(getType().isSignedIntegerTy());
+  if (isInlineInt()) {
+    // Val was zero-extended to ValueHandle. Sign-extend from original width
+    // to SIntMax.
+    const unsigned ExtraBits =
+      sizeof(SIntMax) * 8 - getType().getIntegerBitWidth();
+    return SIntMax(Val) << ExtraBits >> ExtraBits;
+  }
+  if (getType().getIntegerBitWidth() == 64)
+    return *reinterpret_cast<s64*>(Val);
+#if HAVE_INT128_T
+  if (getType().getIntegerBitWidth() == 128)
+    return *reinterpret_cast<s128*>(Val);
+#else
+  if (getType().getIntegerBitWidth() == 128)
+    UNREACHABLE("libclang_rt.ubsan was built without __int128 support");
+#endif
+  UNREACHABLE("unexpected bit width");
+}
+
+UIntMax Value::getUIntValue() const {
+  CHECK(getType().isUnsignedIntegerTy());
+  if (isInlineInt())
+    return Val;
+  if (getType().getIntegerBitWidth() == 64)
+    return *reinterpret_cast<u64*>(Val);
+#if HAVE_INT128_T
+  if (getType().getIntegerBitWidth() == 128)
+    return *reinterpret_cast<u128*>(Val);
+#else
+  if (getType().getIntegerBitWidth() == 128)
+    UNREACHABLE("libclang_rt.ubsan was built without __int128 support");
+#endif
+  UNREACHABLE("unexpected bit width");
+}
+
+UIntMax Value::getPositiveIntValue() const {
+  if (getType().isUnsignedIntegerTy())
+    return getUIntValue();
+  SIntMax Val = getSIntValue();
+  CHECK(Val >= 0);
+  return Val;
+}
+
+/// Get the floating-point value of this object, extended to a long double.
+/// These are always passed by address (our calling convention doesn't allow
+/// them to be passed in floating-point registers, so this has little cost).
+FloatMax Value::getFloatValue() const {
+  CHECK(getType().isFloatTy());
+  if (isInlineFloat()) {
+    switch (getType().getFloatBitWidth()) {
+#if 0
+      // FIXME: OpenCL / NEON 'half' type. LLVM can't lower the conversion
+      //        from '__fp16' to 'long double'.
+      case 16: {
+        __fp16 Value;
+        internal_memcpy(&Value, &Val, 4);
+        return Value;
+      }
+#endif
+      case 32: {
+        float Value;
+#if defined(__BIG_ENDIAN__)
+       // For big endian the float value is in the last 4 bytes.
+       // On some targets we may only have 4 bytes so we count backwards from
+       // the end of Val to account for both the 32-bit and 64-bit cases.
+       internal_memcpy(&Value, ((const char*)(&Val + 1)) - 4, 4);
+#else 
+       internal_memcpy(&Value, &Val, 4);
+#endif
+        return Value;
+      }
+      case 64: {
+        double Value;
+        internal_memcpy(&Value, &Val, 8);
+        return Value;
+      }
+    }
+  } else {
+    switch (getType().getFloatBitWidth()) {
+    case 64: return *reinterpret_cast<double*>(Val);
+    case 80: return *reinterpret_cast<long double*>(Val);
+    case 96: return *reinterpret_cast<long double*>(Val);
+    case 128: return *reinterpret_cast<long double*>(Val);
+    }
+  }
+  UNREACHABLE("unexpected floating point bit width");
+}
+
+#endif  // CAN_SANITIZE_UB
diff --git a/compiler-rt/lib/ubsan/ubsan_value.h b/compiler-rt/lib/ubsan/ubsan_value.h
new file mode 100644
index 0000000..72eee15
--- /dev/null
+++ b/compiler-rt/lib/ubsan/ubsan_value.h
@@ -0,0 +1,197 @@
+//===-- ubsan_value.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Representation of data which is passed from the compiler-generated calls into
+// the ubsan runtime.
+//
+//===----------------------------------------------------------------------===//
+#ifndef UBSAN_VALUE_H
+#define UBSAN_VALUE_H
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+// FIXME: Move this out to a config header.
+#if __SIZEOF_INT128__
+__extension__ typedef __int128 s128;
+__extension__ typedef unsigned __int128 u128;
+#define HAVE_INT128_T 1
+#else
+#define HAVE_INT128_T 0
+#endif
+
+namespace __ubsan {
+
+/// \brief Largest integer types we support.
+#if HAVE_INT128_T
+typedef s128 SIntMax;
+typedef u128 UIntMax;
+#else
+typedef s64 SIntMax;
+typedef u64 UIntMax;
+#endif
+
+/// \brief Largest floating-point type we support.
+typedef long double FloatMax;
+
+/// \brief A description of a source location. This corresponds to Clang's
+/// \c PresumedLoc type.
+class SourceLocation {
+  const char *Filename;
+  u32 Line;
+  u32 Column;
+
+public:
+  SourceLocation() : Filename(), Line(), Column() {}
+  SourceLocation(const char *Filename, unsigned Line, unsigned Column)
+    : Filename(Filename), Line(Line), Column(Column) {}
+
+  /// \brief Determine whether the source location is known.
+  bool isInvalid() const { return !Filename; }
+
+  /// \brief Atomically acquire a copy, disabling original in-place.
+  /// Exactly one call to acquire() returns a copy that isn't disabled.
+  SourceLocation acquire() {
+    u32 OldColumn = __sanitizer::atomic_exchange(
+                        (__sanitizer::atomic_uint32_t *)&Column, ~u32(0),
+                        __sanitizer::memory_order_relaxed);
+    return SourceLocation(Filename, Line, OldColumn);
+  }
+
+  /// \brief Determine if this Location has been disabled.
+  /// Disabled SourceLocations are invalid to use.
+  bool isDisabled() {
+    return Column == ~u32(0);
+  }
+
+  /// \brief Get the presumed filename for the source location.
+  const char *getFilename() const { return Filename; }
+  /// \brief Get the presumed line number.
+  unsigned getLine() const { return Line; }
+  /// \brief Get the column within the presumed line.
+  unsigned getColumn() const { return Column; }
+};
+
+
+/// \brief A description of a type.
+class TypeDescriptor {
+  /// A value from the \c Kind enumeration, specifying what flavor of type we
+  /// have.
+  u16 TypeKind;
+
+  /// A \c Type-specific value providing information which allows us to
+  /// interpret the meaning of a ValueHandle of this type.
+  u16 TypeInfo;
+
+  /// The name of the type follows, in a format suitable for including in
+  /// diagnostics.
+  char TypeName[1];
+
+public:
+  enum Kind {
+    /// An integer type. Lowest bit is 1 for a signed value, 0 for an unsigned
+    /// value. Remaining bits are log_2(bit width). The value representation is
+    /// the integer itself if it fits into a ValueHandle, and a pointer to the
+    /// integer otherwise.
+    TK_Integer = 0x0000,
+    /// A floating-point type. Low 16 bits are bit width. The value
+    /// representation is that of bitcasting the floating-point value to an
+    /// integer type.
+    TK_Float = 0x0001,
+    /// Any other type. The value representation is unspecified.
+    TK_Unknown = 0xffff
+  };
+
+  const char *getTypeName() const { return TypeName; }
+
+  Kind getKind() const {
+    return static_cast<Kind>(TypeKind);
+  }
+
+  bool isIntegerTy() const { return getKind() == TK_Integer; }
+  bool isSignedIntegerTy() const {
+    return isIntegerTy() && (TypeInfo & 1);
+  }
+  bool isUnsignedIntegerTy() const {
+    return isIntegerTy() && !(TypeInfo & 1);
+  }
+  unsigned getIntegerBitWidth() const {
+    CHECK(isIntegerTy());
+    return 1 << (TypeInfo >> 1);
+  }
+
+  bool isFloatTy() const { return getKind() == TK_Float; }
+  unsigned getFloatBitWidth() const {
+    CHECK(isFloatTy());
+    return TypeInfo;
+  }
+};
+
+/// \brief An opaque handle to a value.
+typedef uptr ValueHandle;
+
+
+/// \brief Representation of an operand value provided by the instrumented code.
+///
+/// This is a combination of a TypeDescriptor (which is emitted as constant data
+/// as an operand to a handler function) and a ValueHandle (which is passed at
+/// runtime when a check failure occurs).
+class Value {
+  /// The type of the value.
+  const TypeDescriptor &Type;
+  /// The encoded value itself.
+  ValueHandle Val;
+
+  /// Is \c Val a (zero-extended) integer?
+  bool isInlineInt() const {
+    CHECK(getType().isIntegerTy());
+    const unsigned InlineBits = sizeof(ValueHandle) * 8;
+    const unsigned Bits = getType().getIntegerBitWidth();
+    return Bits <= InlineBits;
+  }
+
+  /// Is \c Val a (zero-extended) integer representation of a float?
+  bool isInlineFloat() const {
+    CHECK(getType().isFloatTy());
+    const unsigned InlineBits = sizeof(ValueHandle) * 8;
+    const unsigned Bits = getType().getFloatBitWidth();
+    return Bits <= InlineBits;
+  }
+
+public:
+  Value(const TypeDescriptor &Type, ValueHandle Val) : Type(Type), Val(Val) {}
+
+  const TypeDescriptor &getType() const { return Type; }
+
+  /// \brief Get this value as a signed integer.
+  SIntMax getSIntValue() const;
+
+  /// \brief Get this value as an unsigned integer.
+  UIntMax getUIntValue() const;
+
+  /// \brief Decode this value, which must be a positive or unsigned integer.
+  UIntMax getPositiveIntValue() const;
+
+  /// Is this an integer with value -1?
+  bool isMinusOne() const {
+    return getType().isSignedIntegerTy() && getSIntValue() == -1;
+  }
+
+  /// Is this a negative integer?
+  bool isNegative() const {
+    return getType().isSignedIntegerTy() && getSIntValue() < 0;
+  }
+
+  /// \brief Get this value as a floating-point quantity.
+  FloatMax getFloatValue() const;
+};
+
+} // namespace __ubsan
+
+#endif // UBSAN_VALUE_H
diff --git a/compiler-rt/make/AppleBI.mk b/compiler-rt/make/AppleBI.mk
new file mode 100644
index 0000000..b236152
--- /dev/null
+++ b/compiler-rt/make/AppleBI.mk
@@ -0,0 +1,149 @@
+
+#
+# Make rules to build compiler_rt in Apple B&I infrastructure
+#
+
+# set ProjSrcRoot appropriately
+ProjSrcRoot := $(SRCROOT)
+# set ProjObjRoot appropriately
+ifdef OBJROOT
+  ProjObjRoot := $(OBJROOT)
+else
+  ProjObjRoot := $(ProjSrcRoot)
+endif
+
+ifeq (,$(RC_PURPLE))
+	INSTALL_TARGET = install-MacOSX
+else
+  ifeq (,$(RC_INDIGO))
+    INSTALL_TARGET = install-iOS
+  else
+    INSTALL_TARGET = install-iOS-Simulator
+  endif
+endif
+
+
+
+# Log full compile lines in B&I logs and omit summary lines.
+Verb :=
+Summary := @true
+
+# List of functions needed for each architecture.
+
+# Copies any public headers to DSTROOT.
+installhdrs:
+
+
+# Copies source code to SRCROOT.
+installsrc:
+	cp -r . $(SRCROOT)
+
+
+install:  $(INSTALL_TARGET)
+
+# Copy results to DSTROOT.
+install-MacOSX : $(SYMROOT)/libcompiler_rt.dylib \
+                 $(SYMROOT)/libcompiler_rt-dyld.a 
+	mkdir -p $(DSTROOT)/usr/local/lib/dyld
+	cp $(SYMROOT)/libcompiler_rt-dyld.a  \
+				    $(DSTROOT)/usr/local/lib/dyld/libcompiler_rt.a
+	mkdir -p $(DSTROOT)/usr/lib/system
+	$(call GetCNAVar,STRIP,Platform.darwin_bni,Release,) -S $(SYMROOT)/libcompiler_rt.dylib \
+	    -o $(DSTROOT)/usr/lib/system/libcompiler_rt.dylib
+	cd $(DSTROOT)/usr/lib/system; \
+	    ln -s libcompiler_rt.dylib libcompiler_rt_profile.dylib; \
+	    ln -s libcompiler_rt.dylib libcompiler_rt_debug.dylib
+
+# Rule to make each dylib slice
+$(OBJROOT)/libcompiler_rt-%.dylib : $(OBJROOT)/darwin_bni/Release/%/libcompiler_rt.a
+	echo "const char vers[] = \"@(#) $(RC_ProjectName)-$(RC_ProjectSourceVersion)\"; " > $(OBJROOT)/version.c
+	$(call GetCNAVar,CC,Platform.darwin_bni,Release,$*) \
+	   $(OBJROOT)/version.c -arch $* -dynamiclib \
+	   -install_name /usr/lib/system/libcompiler_rt.dylib \
+	   -compatibility_version 1 -current_version $(RC_ProjectSourceVersion) \
+	   -nodefaultlibs -umbrella System -dead_strip \
+	   -Wl,-upward-lunwind \
+	   -Wl,-upward-lsystem_m \
+	   -Wl,-upward-lsystem_c \
+	   -Wl,-upward-lsystem_kernel \
+	   -Wl,-upward-lsystem_platform \
+	   -Wl,-ldyld \
+	   -L$(SDKROOT)/usr/lib/system \
+	   $(DYLIB_FLAGS) -Wl,-force_load,$^ -o $@ 
+
+# Rule to make fat dylib
+$(SYMROOT)/libcompiler_rt.dylib: $(foreach arch,$(filter-out armv4t,$(RC_ARCHS)), \
+                                        $(OBJROOT)/libcompiler_rt-$(arch).dylib)
+	$(call GetCNAVar,LIPO,Platform.darwin_bni,Release,) -create $^ -o  $@
+	$(call GetCNAVar,DSYMUTIL,Platform.darwin_bni,Release,) $@
+
+
+# Copy results to DSTROOT.
+install-iOS: $(SYMROOT)/libcompiler_rt-static.a \
+             $(SYMROOT)/libcompiler_rt-dyld.a \
+             $(SYMROOT)/libcompiler_rt.dylib
+	mkdir -p $(DSTROOT)/usr/local/lib
+	cp $(SYMROOT)/libcompiler_rt-static.a  \
+				    $(DSTROOT)/usr/local/lib/libcompiler_rt-static.a
+	mkdir -p $(DSTROOT)/usr/local/lib/dyld
+	cp $(SYMROOT)/libcompiler_rt-dyld.a  \
+				    $(DSTROOT)/usr/local/lib/dyld/libcompiler_rt.a
+	mkdir -p $(DSTROOT)/usr/lib/system
+	$(call GetCNAVar,STRIP,Platform.darwin_bni,Release,) -S $(SYMROOT)/libcompiler_rt.dylib \
+	    -o $(DSTROOT)/usr/lib/system/libcompiler_rt.dylib
+
+# Rule to make fat archive
+$(SYMROOT)/libcompiler_rt-static.a : $(foreach arch,$(RC_ARCHS), \
+                         $(OBJROOT)/darwin_bni/Static/$(arch)/libcompiler_rt.a)
+	$(call GetCNAVar,LIPO,Platform.darwin_bni,Release,) -create $^ -o  $@
+
+# rule to make each archive slice for dyld (which removes a few archive members)
+$(OBJROOT)/libcompiler_rt-dyld-%.a : $(OBJROOT)/darwin_bni/Release/%/libcompiler_rt.a
+	cp $^ $@
+	DEL_LIST=`$(AR)  -t $@ | egrep 'apple_versioning|gcc_personality_v0|eprintf' | xargs echo` ; \
+	if [ -n "$${DEL_LIST}" ] ; \
+	then  \
+		$(call GetCNAVar,AR,Platform.darwin_bni,Release,) -d $@ $${DEL_LIST}; \
+		$(call GetCNAVar,RANLIB,Platform.darwin_bni,Release,) $@ ; \
+	fi
+
+# rule to make make archive for dyld
+$(SYMROOT)/libcompiler_rt-dyld.a : $(foreach arch,$(RC_ARCHS), \
+                         $(OBJROOT)/libcompiler_rt-dyld-$(arch).a)
+	$(call GetCNAVar,LIPO,Platform.darwin_bni,Release,) -create $^ -o  $@
+
+
+
+# Copy results to DSTROOT.
+install-iOS-Simulator: $(SYMROOT)/libcompiler_rt_sim.dylib \
+                       $(SYMROOT)/libcompiler_rt-dyld.a
+	mkdir -p $(DSTROOT)/$(SDKROOT)/usr/lib/system
+	$(call GetCNAVar,STRIP,Platform.darwin_bni,Release,) -S $(SYMROOT)/libcompiler_rt_sim.dylib \
+	    -o $(DSTROOT)/$(SDKROOT)/usr/lib/system/libcompiler_rt_sim.dylib
+	mkdir -p $(DSTROOT)/$(SDKROOT)/usr/local/lib/dyld
+	cp $(SYMROOT)/libcompiler_rt-dyld.a  \
+				    $(DSTROOT)/$(SDKROOT)/usr/local/lib/dyld/libcompiler_rt.a
+  
+# Rule to make fat dylib
+$(SYMROOT)/libcompiler_rt_sim.dylib: $(foreach arch,$(RC_ARCHS), \
+                                        $(OBJROOT)/libcompiler_rt_sim-$(arch).dylib)
+	$(call GetCNAVar,LIPO,Platform.darwin_bni,Release,) -create $^ -o  $@
+	$(call GetCNAVar,DSYMUTIL,Platform.darwin_bni,Release,) $@
+
+# Rule to make each dylib slice
+$(OBJROOT)/libcompiler_rt_sim-%.dylib : $(OBJROOT)/darwin_bni/Release/%/libcompiler_rt.a
+	echo "const char vers[] = \"@(#) $(RC_ProjectName)-$(RC_ProjectSourceVersion)\"; " > $(OBJROOT)/version.c
+	$(call GetCNAVar,CC,Platform.darwin_bni,Release,$*) \
+	   $(OBJROOT)/version.c -arch $* -dynamiclib \
+	   -install_name /usr/lib/system/libcompiler_rt_sim.dylib \
+	   -compatibility_version 1 -current_version $(RC_ProjectSourceVersion) \
+     -Wl,-unexported_symbol,___enable_execute_stack \
+	   -nostdlib \
+	   -Wl,-upward-lunwind_sim \
+	   -Wl,-upward-lsystem_sim_m \
+	   -Wl,-upward-lsystem_sim_c \
+	   -ldyld_sim \
+	   -Wl,-upward-lSystem \
+	   -umbrella System -Wl,-no_implicit_dylibs -L$(SDKROOT)/usr/lib/system -dead_strip \
+	   $(DYLIB_FLAGS) -Wl,-force_load,$^ -o $@ 
+
diff --git a/compiler-rt/make/config.mk b/compiler-rt/make/config.mk
new file mode 100644
index 0000000..094fd16
--- /dev/null
+++ b/compiler-rt/make/config.mk
@@ -0,0 +1,49 @@
+###
+# Configuration variables.
+
+OS := $(shell uname)
+
+# Assume make is always run from top-level of source directory. Note than an
+# Apple style build overrides these variables later in the makefile.
+ProjSrcRoot := $(shell pwd)
+ProjObjRoot := $(ProjSrcRoot)
+
+# The list of modules which are required to be built into every library. This
+# should only be used for internal utilities which could be used in any other
+# module. Any other cases the platform should be allowed to opt-in to.
+AlwaysRequiredModules := int_util
+
+###
+# Tool configuration variables.
+
+# FIXME: LLVM uses autoconf/mkinstalldirs ?
+MKDIR := mkdir -p
+DATE := date
+LIPO := lipo
+CP := cp
+DSYMUTIL := dsymutil
+
+VERBOSE := 0
+DEBUGMAKE :=
+
+###
+# Automatic and derived variables.
+
+# Adjust settings for verbose mode
+ifneq ($(VERBOSE),1)
+  Verb := @
+else
+  Verb :=
+endif
+
+Echo := @echo
+ifndef Summary
+  Summary = $(Echo)
+endif
+
+###
+# Common compiler options
+COMMON_INCLUDES=-I${ProjSrcRoot}/lib -I${ProjSrcRoot}/include
+COMMON_CXXFLAGS=-std=c++11 -fno-exceptions -fPIC -funwind-tables $(COMMON_INCLUDES)
+COMMON_CFLAGS=-fPIC $(COMMON_INCLUDES)
+COMMON_ASMFLAGS=$(COMMON_INCLUDES)
diff --git a/compiler-rt/make/filter-inputs b/compiler-rt/make/filter-inputs
new file mode 100755
index 0000000..8a6bbe2
--- /dev/null
+++ b/compiler-rt/make/filter-inputs
@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+
+#===- make/filter-inputs ---------------------------------------------------===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+# Given a list of files, return a new list of files taking only the
+# first file for any particular filename.
+def main():
+    import os,sys
+    
+    seen = set()
+    for file in sys.argv[1:]:
+        base = os.path.basename(file)
+        if base not in seen:
+            seen.add(base)
+            print file
+
+if __name__ == '__main__':
+    main()
diff --git a/compiler-rt/make/lib_info.mk b/compiler-rt/make/lib_info.mk
new file mode 100644
index 0000000..31850f7
--- /dev/null
+++ b/compiler-rt/make/lib_info.mk
@@ -0,0 +1,59 @@
+# compiler-rt Library Info
+#
+# This should be included once the subdirectory information has been loaded, and
+# uses the utilities in 'util.mk'.
+#
+# This defines the following variables describing compiler-rt:
+#   AvailableFunctions   - The entire list of function names (unmangled) the
+#                          library can provide.
+#   CommonFunctions      - The list of generic functions available.
+#   ArchFunctions.<arch> - The list of functions commonly available for
+#                          'arch'. This does not include any config specific
+#                          functions.
+#
+#   AvailableIn.<function> - The list of subdir keys where 'function' is
+#                            defined.
+
+# Determine the set of available modules.
+AvailableModules := $(sort $(foreach key,$(SubDirKeys),\
+	$($(key).ModuleName)))
+
+# Build a per-module map of subdir keys.
+$(foreach key,$(SubDirKeys),\
+	$(call Append,ModuleSubDirKeys.$($(key).ModuleName),$(key)))
+
+AvailableArchs := $(sort $(foreach key,$(SubDirKeys),\
+	$($(key).OnlyArchs)))
+
+AvailableFunctions := $(sort $(foreach key,$(SubDirKeys),\
+	$(basename $($(key).ObjNames))))
+
+CommonFunctions := $(sort\
+  $(foreach key,$(ModuleSubDirKeys.builtins),\
+    $(if $(call strneq,,$(strip $($(key).OnlyArchs) $($(key).OnlyConfigs))),,\
+         $(basename $($(key).ObjNames)))))
+
+# Compute common arch functions.
+$(foreach key,$(ModuleSubDirKeys.builtins),\
+  $(if $(call strneq,,$($(key).OnlyConfigs)),,\
+    $(foreach arch,$($(key).OnlyArchs),\
+      $(call Append,ArchFunctions.$(arch),$(sort \
+        $(basename $($(key).ObjNames)))))))
+
+# Compute arch only functions.
+$(foreach arch,$(AvailableArchs),\
+  $(call Set,ArchFunctions.$(arch),$(sort $(ArchFunctions.$(arch))))\
+  $(call Set,ArchOnlyFunctions.$(arch),\
+    $(call set_difference,$(ArchFunctions.$(arch)),$(CommonFunctions))))
+
+# Compute lists of where each function is available.
+$(foreach key,$(SubDirKeys),\
+  $(foreach fn,$(basename $($(key).ObjNames)),\
+    $(call Append,AvailableIn.$(fn),$(key))))
+
+# The names of all the available options.
+AvailableOptions := AR ARFLAGS \
+                    CC CFLAGS LDFLAGS FUNCTIONS OPTIMIZED \
+                    RANLIB RANLIBFLAGS \
+                    VISIBILITY_HIDDEN KERNEL_USE \
+                    SHARED_LIBRARY SHARED_LIBRARY_SUFFIX STRIP LIPO DSYMUTIL
diff --git a/compiler-rt/make/lib_platforms.mk b/compiler-rt/make/lib_platforms.mk
new file mode 100644
index 0000000..9cf9704
--- /dev/null
+++ b/compiler-rt/make/lib_platforms.mk
@@ -0,0 +1,82 @@
+# compiler-rt Configuration Support
+#
+# This should be included following 'lib_util.mk'.
+
+# The simple variables configurations can define.
+PlainConfigVariables := Configs Description
+PerConfigVariables := UniversalArchs Arch $(AvailableOptions)
+RequiredConfigVariables := Configs Description
+
+###
+# Load Platforms
+
+# Template: subdir_traverse_template subdir
+define load_platform_template
+$(call Set,PlatformName,$(basename $(notdir $(1))))
+ifneq ($(DEBUGMAKE),)
+  $$(info MAKE: $(PlatformName): Loading platform)
+endif
+
+# Construct the variable key for this directory.
+$(call Set,PlatformKey,Platform.$(PlatformName))
+$(call Append,PlatformKeys,$(PlatformKey))
+$(call Set,$(PlatformKey).Name,$(PlatformName))
+$(call Set,$(PlatformKey).Path,$(1))
+
+# Reset platform specific variables to sentinel value.
+$$(foreach var,$(PlainConfigVariables) $(PerConfigVariables),\
+  $$(call Set,$$(var),UNDEFINED))
+$$(foreach var,$(PerConfigVariables),\
+  $$(foreach config,$$(Configs),\
+    $$(call Set,$$(var).$$(config),UNDEFINED)))
+$$(foreach var,$(PerConfigVariables),\
+  $$(foreach arch,$(AvailableArchs),\
+    $$(call Set,$$(var).$$(arch),UNDEFINED)))
+
+# Get the platform variables.
+include make/options.mk
+include $(1)
+
+# Check for undefined required variables.
+$$(foreach var,$(RequiredConfigVariables),\
+  $$(if $$(call strneq,UNDEFINED,$$($$(var))),, \
+	$$(error $(Dir): variable '$$(var)' was not undefined)))
+
+# Check that exactly one of UniversalArchs or Arch was defined.
+$$(if $$(and $$(call strneq,UNDEFINED,$$(UniversalArchs)),\
+             $$(call strneq,UNDEFINED,$$(Arch))),\
+    $$(error '$(1)': cannot define both 'UniversalArchs' and 'Arch'))
+$$(if $$(or $$(call strneq,UNDEFINED,$$(UniversalArchs)),\
+            $$(call strneq,UNDEFINED,$$(Arch))),,\
+    $$(error '$(1)': must define one of 'UniversalArchs' and 'Arch'))
+
+# Collect all the platform variables for subsequent use.
+$$(foreach var,$(PlainConfigVariables) $(PerConfigVariables),\
+  $$(if $$(call strneq,UNDEFINED,$$($$(var))),\
+    $$(call CopyVariable,$$(var),$(PlatformKey).$$(var))))
+$$(foreach var,$(PerConfigVariables),\
+  $$(foreach config,$$(Configs),\
+    $$(if $$(call strneq,UNDEFINED,$$($$(var).$$(config))),\
+      $$(call CopyVariable,$$(var).$$(config),$(PlatformKey).$$(var).$$(config))))\
+  $$(foreach arch,$(AvailableArchs),\
+    $$(if $$(call strneq,UNDEFINED,$$($$(var).$$(arch))),\
+      $$(call CopyVariable,$$(var).$$(arch),$(PlatformKey).$$(var).$$(arch))))\
+  $$(foreach config,$$(Configs),\
+    $$(foreach arch,$(AvailableArchs),\
+      $$(if $$(call strneq,UNDEFINED,$$($$(var).$$(config).$$(arch))),\
+        $$(call CopyVariable,$$(var).$$(config).$$(arch),\
+                $(PlatformKey).$$(var).$$(config).$$(arch))))))
+
+ifneq ($(DEBUGMAKE),)
+  $$(info MAKE: $(PlatformName): Done loading platform)
+endif
+endef
+
+# Evaluate this now so we do not have to worry about order of evaluation.
+PlatformFiles := $(wildcard make/platform/*.mk)
+ifneq ($(DEBUGMAKE),)
+ $(info MAKE: Loading platforms: $(PlatformFiles))
+endif
+
+$(foreach file,$(PlatformFiles),\
+  $(eval $(call load_platform_template,$(file))))
diff --git a/compiler-rt/make/lib_util.mk b/compiler-rt/make/lib_util.mk
new file mode 100644
index 0000000..089a0e2
--- /dev/null
+++ b/compiler-rt/make/lib_util.mk
@@ -0,0 +1,65 @@
+# Library Utility Functions
+#
+# This should be included following 'lib_info.mk'.
+
+# Function: GetCNAVar variable-name platform-key config arch
+#
+# Get a per-config-and-arch variable value.
+GetCNAVar = $(strip \
+  $(or $($(2).$(1).$(3).$(4)), \
+       $($(2).$(1).$(3)), \
+       $($(2).$(1).$(4)), \
+       $($(2).$(1))))
+
+# Function: SelectFunctionDir config arch function-name optimized
+#
+# Choose the appropriate implementation directory to use for 'function-name' in
+# the configuration 'config' and on given arch.
+SelectFunctionDir = $(strip \
+  $(call Set,Tmp.SelectFunctionDir,$(call SelectFunctionDirs,$(1),$(2),$(3),$(4)))\
+  $(if $(call streq,1,$(words $(Tmp.SelectFunctionDir))),\
+       $(Tmp.SelectFunctionDir),\
+       $(error SelectFunctionDir: invalid function name "$(3)" ($(strip\
+               $(if $(call streq,0,$(words $(Tmp.SelectFunctionDir))),\
+                    no such function,\
+                    function implemented in multiple directories!!!))))))
+
+# Helper functions that select the entire list of subdirs where a function is
+# defined with a certain specificity.
+SelectFunctionDirs_Opt_ConfigAndArch = $(strip \
+  $(foreach key,$(AvailableIn.$(3)),\
+    $(if $(and $(call streq,Optimized,$($(key).Implementation)),\
+               $(call contains,$($(key).OnlyConfigs),$(1)),\
+               $(call contains,$($(key).OnlyArchs),$(2))),$(key),)))
+SelectFunctionDirs_Opt_Config = $(strip \
+  $(foreach key,$(AvailableIn.$(3)),\
+    $(if $(and $(call streq,Optimized,$($(key).Implementation)),\
+               $(call contains,$($(key).OnlyConfigs),$(1))),$(key),)))
+SelectFunctionDirs_Opt_Arch = $(strip \
+  $(foreach key,$(AvailableIn.$(3)),\
+    $(if $(and $(call streq,Optimized,$($(key).Implementation)),\
+               $(call contains,$($(key).OnlyArchs),$(2))),$(key),)))
+SelectFunctionDirs_Gen = $(strip \
+  $(foreach key,$(AvailableIn.$(3)),\
+    $(if $(call streq,Generic,$($(key).Implementation)),$(key))))
+
+# Helper function to select the right set of dirs in generic priority order.
+SelectFunctions_Gen = \
+  $(or $(call SelectFunctionDirs_Gen,$(1),$(2),$(3)),\
+       $(call SelectFunctionDirs_Opt_ConfigAndArch,$(1),$(2),$(3)), \
+       $(call SelectFunctionDirs_Opt_Config,$(1),$(2),$(3)), \
+       $(call SelectFunctionDirs_Opt_Arch,$(1),$(2),$(3)))
+
+# Helper function to select the right set of dirs in optimized priority order.
+SelectFunctions_Opt = \
+  $(or $(call SelectFunctionDirs_Opt_ConfigAndArch,$(1),$(2),$(3)), \
+       $(call SelectFunctionDirs_Opt_Config,$(1),$(2),$(3)), \
+       $(call SelectFunctionDirs_Opt_Arch,$(1),$(2),$(3)), \
+       $(call SelectFunctionDirs_Gen,$(1),$(2),$(3)))
+
+# Helper function to select the right set of dirs (which should be exactly one)
+# for a function.
+SelectFunctionDirs = \
+  $(if $(call streq,1,$(4)),\
+       $(call SelectFunctions_Opt,$(1),$(2),$(3)),\
+       $(call SelectFunctions_Gen,$(1),$(2),$(3)))
diff --git a/compiler-rt/make/options.mk b/compiler-rt/make/options.mk
new file mode 100644
index 0000000..67197de
--- /dev/null
+++ b/compiler-rt/make/options.mk
@@ -0,0 +1,48 @@
+# Options which may be overriden for platforms, etc.
+#
+# This list of such variables should be kept up to date with AvailableOptions in
+# 'make/lib_info.mk'.
+
+# The compiler to use.
+CC := gcc
+
+# The compiler flags to use.
+CFLAGS := -Wall -Werror
+
+# The list of functions to include in the library.
+FUNCTIONS :=
+
+# Whether optimized function implementations should be used.
+OPTIMIZED := 1
+
+# Whether function definitions should use hidden visibility. This adds the
+# -fvisibility=hidden compiler option and uses .private_extern annotations in
+# assembly files.
+#
+# FIXME: Make this more portable. When that is done, it should probably be the
+# default.
+VISIBILITY_HIDDEN := 0
+
+# Whether the library is being built for kernel use.
+KERNEL_USE := 0
+
+# Whether the library should be built as a shared object.
+SHARED_LIBRARY := 0
+
+# Miscellaneous tools.
+
+AR := ar
+# FIXME: Remove these pipes once ranlib errors are fixed.
+ARFLAGS := cru 2> /dev/null
+
+LDFLAGS :=
+
+RANLIB := ranlib
+# FIXME: Remove these pipes once ranlib errors are fixed.
+RANLIBFLAGS := 2> /dev/null
+
+STRIP := strip
+LIPO := lipo
+DSYMUTIL := dsymutil
+
+SHARED_LIBRARY_SUFFIX := so
diff --git a/compiler-rt/make/platform/clang_darwin.mk b/compiler-rt/make/platform/clang_darwin.mk
new file mode 100644
index 0000000..9944481
--- /dev/null
+++ b/compiler-rt/make/platform/clang_darwin.mk
@@ -0,0 +1,567 @@
+# These are the functions which clang needs when it is targeting a previous
+# version of the OS. The issue is that the backend may use functions which were
+# not present in the libgcc that shipped on the platform. In such cases, we link
+# with a version of the library which contains private_extern definitions of all
+# the extra functions which might be referenced.
+
+Description := Static runtime libraries for clang/Darwin.
+
+# A function that ensures we don't try to build for architectures and SDKs
+# that we don't have working toolchains for. Arguments:
+# (1): List of architectures
+# (2): Library name
+# (3): SDK path
+# The result is a possibly empty subset of the architectures from argument 1.
+CheckArches = \
+  $(shell \
+    result=""; \
+    if [ "X$(3)" != X ]; then \
+      for arch in $(1); do \
+        if $(LD) -v 2>&1 | grep "configured to support" \
+             | tr ' ' '\n' | grep "^$$arch$$" >/dev/null 2>/dev/null; then \
+          if $(CC) -arch $$arch \
+            -integrated-as \
+            $(ProjSrcRoot)/make/platform/clang_darwin_test_input.c \
+            -isysroot $(3) \
+            -o /dev/null > /dev/null 2> /dev/null; then \
+              result="$$result$$arch "; \
+          else \
+            printf 1>&2 \
+             "warning: clang_darwin.mk: dropping arch '$$arch' from lib '$(2)'"; \
+            printf 1>&2 " (clang or system libraries do not support it)\n"; \
+          fi; \
+        else \
+          printf 1>&2 \
+            "warning: clang_darwin.mk: dropping arch '$$arch' from lib '$(2)'";\
+          printf 1>&2 " (ld does not support it)\n"; \
+        fi; \
+      done; \
+    fi; \
+    echo $$result)
+
+XCRun = \
+  $(shell \
+    result=`xcrun -find $(1) 2> /dev/null`; \
+    if [ "$$?" != "0" ]; then result=$(1); fi; \
+    echo $$result)
+# Prefer building with the internal SDKs.
+XCRunSdkPath = \
+  $(shell \
+    result=`xcrun --sdk $(1).internal --show-sdk-path 2> /dev/null`; \
+    if [ "$$?" != "0" ]; then \
+      result=`xcrun --sdk $(1) --show-sdk-path 2> /dev/null`; \
+      if [ "$$?" != "0" ]; then result=""; fi; \
+    fi; \
+    echo $$result)
+###
+
+CC       := $(call XCRun,clang)
+LD       := $(shell $(CC) -print-prog-name=ld)
+AR       := $(call XCRun,ar)
+RANLIB   := $(call XCRun,ranlib)
+STRIP    := $(call XCRun,strip)
+LIPO     := $(call XCRun,lipo)
+DSYMUTIL := $(call XCRun,dsymutil)
+
+OSX_SDK := $(call XCRunSdkPath,macosx)
+IOS_SDK := $(call XCRunSdkPath,iphoneos)
+IOSSIM_SDK := $(call XCRunSdkPath,iphonesimulator)
+
+Configs :=
+UniversalArchs :=
+
+# Configuration solely for providing access to an eprintf symbol, which may
+# still be referenced from Darwin system headers. This symbol is only ever
+# needed on i386.
+Configs += eprintf
+UniversalArchs.eprintf := $(call CheckArches,i386,eprintf,$(OSX_SDK))
+
+# Configuration for targeting 10.4. We need a few functions missing from
+# libgcc_s.10.4.dylib. We only build x86 slices since clang doesn't really
+# support targeting PowerPC.
+Configs += 10.4
+UniversalArchs.10.4 := $(call CheckArches,i386 x86_64,10.4,$(OSX_SDK))
+
+# Configuration for targeting iOS for a couple of functions that didn't
+# make it into libSystem.
+Configs += ios
+UniversalArchs.ios := $(call CheckArches,i386 x86_64,ios,$(IOSSIM_SDK))
+UniversalArchs.ios += $(call CheckArches,armv7 arm64,ios,$(IOS_SDK))
+
+# Configuration for targeting OSX. These functions may not be in libSystem
+# so we should provide our own.
+Configs += osx
+UniversalArchs.osx := $(call CheckArches,i386 x86_64 x86_64h,osx,$(OSX_SDK))
+
+# Configuration for use with kernel/kexts.
+Configs += cc_kext
+UniversalArchs.cc_kext := $(call CheckArches,i386 x86_64 x86_64h,cc_kext,$(OSX_SDK))
+
+# Configuration for use with iOS kernel/kexts
+Configs += cc_kext_ios
+UniversalArchs.cc_kext_ios += $(call CheckArches,armv7,cc_kext_ios,$(IOS_SDK))
+
+# Configurations which define the profiling support functions.
+Configs += profile_osx
+UniversalArchs.profile_osx := $(call CheckArches,i386 x86_64 x86_64h,profile_osx,$(OSX_SDK))
+Configs += profile_ios
+UniversalArchs.profile_ios := $(call CheckArches,i386 x86_64,profile_ios,$(IOSSIM_SDK))
+UniversalArchs.profile_ios += $(call CheckArches,armv7 arm64,profile_ios,$(IOS_SDK))
+
+# Configurations which define the ASAN support functions.
+Configs += asan_osx_dynamic
+UniversalArchs.asan_osx_dynamic := $(call CheckArches,i386 x86_64 x86_64h,asan_osx_dynamic,$(OSX_SDK))
+
+Configs += asan_iossim_dynamic
+UniversalArchs.asan_iossim_dynamic := $(call CheckArches,i386 x86_64,asan_iossim_dynamic,$(IOSSIM_SDK))
+
+Configs += ubsan_osx_dynamic
+UniversalArchs.ubsan_osx_dynamic := $(call CheckArches,i386 x86_64 x86_64h,ubsan_osx_dynamic,$(OSX_SDK))
+
+Configs += ubsan_iossim_dynamic
+UniversalArchs.ubsan_iossim_dynamic := $(call CheckArches,i386 x86_64,ubsan_iossim_dynamic,$(IOSSIM_SDK))
+
+# Darwin 10.6 has a bug in cctools that makes it unable to use ranlib on our ARM
+# object files. If we are on that platform, strip out all ARM archs. We still
+# build the libraries themselves so that Clang can find them where it expects
+# them, even though they might not have an expected slice.
+ifneq ($(shell test -x /usr/bin/sw_vers && sw_vers -productVersion | grep 10.6),)
+UniversalArchs.ios := $(filter-out armv7, $(UniversalArchs.ios))
+UniversalArchs.cc_kext_ios := $(filter-out armv7, $(UniversalArchs.cc_kext_ios))
+UniversalArchs.profile_ios := $(filter-out armv7, $(UniversalArchs.profile_ios))
+endif
+
+# If RC_SUPPORTED_ARCHS is defined, treat it as a list of the architectures we
+# are intended to support and limit what we try to build to that.
+ifneq ($(RC_SUPPORTED_ARCHS),)
+$(foreach config,$(Configs),\
+  $(call Set,UniversalArchs.$(config),\
+	$(filter $(RC_SUPPORTED_ARCHS),$(UniversalArchs.$(config)))))
+endif
+
+# Remove empty configs if we end up dropping all the requested
+# archs for a particular config.
+$(foreach config,$(Configs),\
+  $(if $(strip $(UniversalArchs.$(config))),,\
+	$(call Set,Configs,$(filter-out $(config),$(Configs)))))
+
+###
+
+# Forcibly strip off any -arch, as that totally breaks our universal support.
+override CC := $(subst -arch ,-arch_,$(CC))
+override CC := $(patsubst -arch_%,,$(CC))
+
+CFLAGS := -Wall -Werror -O3 -fomit-frame-pointer
+
+# Always set deployment target arguments for every build, these libraries should
+# never depend on the environmental overrides. We simply set them to minimum
+# supported deployment target -- nothing in the compiler-rt libraries should
+# actually depend on the deployment target.
+OSX_DEPLOYMENT_ARGS := -mmacosx-version-min=10.4
+IOS_DEPLOYMENT_ARGS := -mios-version-min=1.0
+IOS6_DEPLOYMENT_ARGS := -mios-version-min=6.0
+IOSSIM_DEPLOYMENT_ARGS := -mios-simulator-version-min=1.0
+
+OSX_DEPLOYMENT_ARGS += -isysroot $(OSX_SDK)
+IOS_DEPLOYMENT_ARGS += -isysroot $(IOS_SDK)
+IOS6_DEPLOYMENT_ARGS += -isysroot $(IOS_SDK)
+IOSSIM_DEPLOYMENT_ARGS += -isysroot $(IOSSIM_SDK)
+
+CFLAGS.eprintf		:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.10.4		:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+
+SANITIZER_MACOSX_DEPLOYMENT_ARGS := -mmacosx-version-min=10.7
+SANITIZER_IOSSIM_DEPLOYMENT_ARGS := -mios-simulator-version-min=7.0 \
+  -isysroot $(IOSSIM_SDK)
+SANITIZER_CFLAGS := -fno-builtin -gline-tables-only -stdlib=libc++
+
+CFLAGS.asan_osx_dynamic := \
+	$(CFLAGS) $(SANITIZER_MACOSX_DEPLOYMENT_ARGS) \
+	$(SANITIZER_CFLAGS) \
+	-DMAC_INTERPOSE_FUNCTIONS=1 \
+	-DASAN_DYNAMIC=1
+
+CFLAGS.asan_iossim_dynamic := \
+	$(CFLAGS) $(SANITIZER_IOSSIM_DEPLOYMENT_ARGS) \
+	$(SANITIZER_CFLAGS) \
+	-DMAC_INTERPOSE_FUNCTIONS=1 \
+	-DASAN_DYNAMIC=1
+
+CFLAGS.ubsan_osx_dynamic := \
+	$(CFLAGS) $(SANITIZER_MACOSX_DEPLOYMENT_ARGS) \
+	$(SANITIZER_CFLAGS)
+
+CFLAGS.ubsan_iossim_dynamic := \
+	$(CFLAGS) $(SANITIZER_IOSSIM_DEPLOYMENT_ARGS) \
+	$(SANITIZER_CFLAGS)
+
+
+CFLAGS.ios.i386		:= $(CFLAGS) $(IOSSIM_DEPLOYMENT_ARGS)
+CFLAGS.ios.x86_64	:= $(CFLAGS) $(IOSSIM_DEPLOYMENT_ARGS)
+CFLAGS.ios.armv7	:= $(CFLAGS) $(IOS_DEPLOYMENT_ARGS)
+CFLAGS.ios.armv7k	:= $(CFLAGS) $(IOS_DEPLOYMENT_ARGS)
+CFLAGS.ios.armv7s	:= $(CFLAGS) $(IOS_DEPLOYMENT_ARGS)
+CFLAGS.ios.arm64	:= $(CFLAGS) $(IOS6_DEPLOYMENT_ARGS)
+CFLAGS.osx.i386		:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.osx.x86_64	:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.osx.x86_64h	:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext.i386	:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext.x86_64	:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext.x86_64h	:= $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext_ios.armv7	:= $(CFLAGS) $(IOS6_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext_ios.armv7k	:= $(CFLAGS) $(IOS6_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext_ios.armv7s	:= $(CFLAGS) $(IOS6_DEPLOYMENT_ARGS)
+CFLAGS.cc_kext_ios.arm64	:= $(CFLAGS) $(IOS6_DEPLOYMENT_ARGS)
+CFLAGS.profile_osx.i386    := $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.profile_osx.x86_64  := $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.profile_osx.x86_64h := $(CFLAGS) $(OSX_DEPLOYMENT_ARGS)
+CFLAGS.profile_ios.i386    := $(CFLAGS) $(IOSSIM_DEPLOYMENT_ARGS)
+CFLAGS.profile_ios.x86_64  := $(CFLAGS) $(IOSSIM_DEPLOYMENT_ARGS)
+CFLAGS.profile_ios.armv7  := $(CFLAGS) $(IOS_DEPLOYMENT_ARGS)
+CFLAGS.profile_ios.armv7k := $(CFLAGS) $(IOS_DEPLOYMENT_ARGS)
+CFLAGS.profile_ios.armv7s := $(CFLAGS) $(IOS_DEPLOYMENT_ARGS)
+CFLAGS.profile_ios.arm64  := $(CFLAGS) $(IOS6_DEPLOYMENT_ARGS)
+
+SANITIZER_LDFLAGS := -stdlib=libc++ -lc++ -lc++abi
+
+SHARED_LIBRARY.asan_osx_dynamic := 1
+LDFLAGS.asan_osx_dynamic := $(SANITIZER_LDFLAGS) -install_name @rpath/libclang_rt.asan_osx_dynamic.dylib \
+  $(SANITIZER_MACOSX_DEPLOYMENT_ARGS)
+
+SHARED_LIBRARY.asan_iossim_dynamic := 1
+LDFLAGS.asan_iossim_dynamic := $(SANITIZER_LDFLAGS) -install_name @rpath/libclang_rt.asan_iossim_dynamic.dylib \
+  -Wl,-ios_simulator_version_min,7.0.0 $(SANITIZER_IOSSIM_DEPLOYMENT_ARGS)
+
+SHARED_LIBRARY.ubsan_osx_dynamic := 1
+LDFLAGS.ubsan_osx_dynamic := $(SANITIZER_LDFLAGS) -install_name @rpath/libclang_rt.ubsan_osx_dynamic.dylib \
+  $(SANITIZER_MACOSX_DEPLOYMENT_ARGS)
+
+SHARED_LIBRARY.ubsan_iossim_dynamic := 1
+LDFLAGS.ubsan_iossim_dynamic := $(SANITIZER_LDFLAGS) -install_name @rpath/libclang_rt.ubsan_iossim_dynamic.dylib \
+  -Wl,-ios_simulator_version_min,7.0.0 $(SANITIZER_IOSSIM_DEPLOYMENT_ARGS)
+
+ifneq ($(OSX_SDK),)
+CFLAGS.asan_osx_dynamic += -isysroot $(OSX_SDK)
+LDFLAGS.asan_osx_dynamic += -isysroot $(OSX_SDK)
+CFLAGS.ubsan_osx_dynamic += -isysroot $(OSX_SDK)
+LDFLAGS.ubsan_osx_dynamic += -isysroot $(OSX_SDK)
+endif
+
+ATOMIC_FUNCTIONS := \
+	atomic_flag_clear \
+	atomic_flag_clear_explicit \
+	atomic_flag_test_and_set \
+	atomic_flag_test_and_set_explicit \
+	atomic_signal_fence \
+	atomic_thread_fence
+
+FP16_FUNCTIONS := \
+	extendhfsf2 \
+	truncdfhf2 \
+	truncsfhf2
+
+FUNCTIONS.eprintf := eprintf
+FUNCTIONS.10.4 := eprintf floatundidf floatundisf floatundixf
+
+FUNCTIONS.ios	    := divmodsi4 udivmodsi4 mulosi4 mulodi4 muloti4 \
+                       $(ATOMIC_FUNCTIONS) $(FP16_FUNCTIONS)
+# On x86, the divmod functions reference divsi.
+FUNCTIONS.ios.i386    := $(FUNCTIONS.ios) \
+                         divsi3 udivsi3
+FUNCTIONS.ios.x86_64  := $(FUNCTIONS.ios.i386)
+FUNCTIONS.ios.arm64   := mulsc3 muldc3 divsc3 divdc3 udivti3 umodti3 \
+                         $(ATOMIC_FUNCTIONS)
+
+FUNCTIONS.osx	:= mulosi4 mulodi4 muloti4 $(ATOMIC_FUNCTIONS) $(FP16_FUNCTIONS)
+
+FUNCTIONS.profile_osx := GCDAProfiling InstrProfiling InstrProfilingBuffer \
+                         InstrProfilingFile InstrProfilingPlatformDarwin \
+                         InstrProfilingRuntime InstrProfilingUtil \
+                         InstrProfilingWriter InstrProfilingValue
+FUNCTIONS.profile_ios := $(FUNCTIONS.profile_osx)
+
+FUNCTIONS.asan_osx_dynamic := $(AsanFunctions) $(AsanCXXFunctions) \
+                              $(InterceptionFunctions) \
+                              $(SanitizerCommonFunctions) \
+                              $(AsanDynamicFunctions) \
+                              $(UbsanFunctions) $(UbsanCXXFunctions)
+
+FUNCTIONS.asan_iossim_dynamic := $(AsanFunctions) $(AsanCXXFunctions) \
+                                 $(InterceptionFunctions) \
+                                 $(SanitizerCommonFunctions) \
+                                 $(AsanDynamicFunctions) \
+                                 $(UbsanFunctions) $(UbsanCXXFunctions)
+
+FUNCTIONS.ubsan_osx_dynamic := $(UbsanFunctions) $(UbsanCXXFunctions) \
+                               $(SanitizerCommonFunctions) \
+                               $(UbsanStandaloneFunctions)
+
+FUNCTIONS.ubsan_iossim_dynamic := $(UbsanFunctions) $(UbsanCXXFunctions) \
+                                  $(SanitizerCommonFunctions) \
+                                  $(UbsanStandaloneFunctions)
+
+CCKEXT_PROFILE_FUNCTIONS := \
+	InstrProfiling \
+	InstrProfilingBuffer \
+	InstrProfilingPlatformDarwin
+
+CCKEXT_COMMON_FUNCTIONS := \
+	$(CCKEXT_PROFILE_FUNCTIONS) \
+	absvdi2 \
+	absvsi2 \
+	addvdi3 \
+	addvsi3 \
+	ashldi3 \
+	ashrdi3 \
+	bswapdi2 \
+	bswapsi2 \
+	clzdi2 \
+	clzsi2 \
+	cmpdi2 \
+	ctzdi2 \
+	ctzsi2 \
+	divdc3 \
+	divdi3 \
+	divsc3 \
+	divmodsi4 \
+	udivmodsi4 \
+	do_global_dtors \
+	eprintf \
+	extendhfsf2 \
+	ffsdi2 \
+	fixdfdi \
+	fixsfdi \
+	fixunsdfdi \
+	fixunsdfsi \
+	fixunssfdi \
+	fixunssfsi \
+	floatdidf \
+	floatdisf \
+	floatundidf \
+	floatundisf \
+	gcc_bcmp \
+	lshrdi3 \
+	moddi3 \
+	muldc3 \
+	muldi3 \
+	mulsc3 \
+	mulvdi3 \
+	mulvsi3 \
+	negdi2 \
+	negvdi2 \
+	negvsi2 \
+	paritydi2 \
+	paritysi2 \
+	popcountdi2 \
+	popcountsi2 \
+	powidf2 \
+	powisf2 \
+	subvdi3 \
+	subvsi3 \
+	truncdfhf2 \
+	truncsfhf2 \
+	ucmpdi2 \
+	udiv_w_sdiv \
+	udivdi3 \
+	udivmoddi4 \
+	umoddi3
+
+CCKEXT_ARM_FUNCTIONS := $(CCKEXT_COMMON_FUNCTIONS) \
+	adddf3 \
+	addsf3 \
+	aeabi_cdcmpeq \
+	aeabi_cdrcmple \
+	aeabi_cfcmpeq \
+	aeabi_cfrcmple \
+	aeabi_dcmpeq \
+	aeabi_dcmpge \
+	aeabi_dcmpgt \
+	aeabi_dcmple \
+	aeabi_dcmplt \
+	aeabi_drsub \
+	aeabi_fcmpeq \
+	aeabi_fcmpge \
+	aeabi_fcmpgt \
+	aeabi_fcmple \
+	aeabi_fcmplt \
+	aeabi_frsub \
+	aeabi_idivmod \
+	aeabi_uidivmod \
+	cmpdf2 \
+	cmpsf2 \
+	div0 \
+	divdf3 \
+	divsf3 \
+	divsi3 \
+	extendsfdf2 \
+	ffssi2 \
+	fixdfsi \
+	fixsfsi \
+	floatsidf \
+	floatsisf \
+	floatunsidf \
+	floatunsisf \
+	comparedf2 \
+	comparesf2 \
+	modsi3 \
+	muldf3 \
+	mulsf3 \
+	mulodi4 \
+	negdf2 \
+	negsf2 \
+	subdf3 \
+	subsf3 \
+	switch16 \
+	switch32 \
+	switch8 \
+	switchu8 \
+	truncdfsf2 \
+	udivsi3 \
+	umodsi3 \
+	unorddf2 \
+	unordsf2
+
+CCKEXT_ARMVFP_FUNCTIONS := $(CCKEXT_ARM_FUNCTIONS) \
+	adddf3vfp \
+	addsf3vfp \
+	divdf3vfp \
+	divsf3vfp \
+	eqdf2vfp \
+	eqsf2vfp \
+	extendsfdf2vfp \
+	fixdfsivfp \
+	fixsfsivfp \
+	fixunsdfsivfp \
+	fixunssfsivfp \
+	floatsidfvfp \
+	floatsisfvfp \
+	floatunssidfvfp \
+	floatunssisfvfp \
+	gedf2vfp \
+	gesf2vfp \
+	gtdf2vfp \
+	gtsf2vfp \
+	ledf2vfp \
+	lesf2vfp \
+	ltdf2vfp \
+	ltsf2vfp \
+	muldf3vfp \
+	mulsf3vfp \
+	nedf2vfp \
+	nesf2vfp \
+	subdf3vfp \
+	subsf3vfp \
+	truncdfsf2vfp \
+	unorddf2vfp \
+	unordsf2vfp
+
+CCKEXT_ARM64_FUNCTIONS := \
+	$(CCKEXT_PROFILE_FUNCTIONS) \
+	divdc3 \
+	divsc3 \
+	muldc3 \
+	mulsc3 \
+	udivti3 \
+	umodti3
+
+FUNCTIONS.cc_kext_ios.armv7 := $(CCKEXT_ARMVFP_FUNCTIONS)
+FUNCTIONS.cc_kext_ios.armv7k := $(CCKEXT_ARMVFP_FUNCTIONS)
+FUNCTIONS.cc_kext_ios.armv7s := $(CCKEXT_ARMVFP_FUNCTIONS)
+FUNCTIONS.cc_kext_ios.arm64 := $(CCKEXT_ARM64_FUNCTIONS)
+
+CCKEXT_X86_FUNCTIONS := $(CCKEXT_COMMON_FUNCTIONS) \
+	divxc3 \
+	fixunsxfdi \
+	fixunsxfsi \
+	fixxfdi \
+	floatdixf \
+	floatundixf \
+	mulxc3 \
+	powixf2
+
+FUNCTIONS.cc_kext.i386 := $(CCKEXT_X86_FUNCTIONS) \
+	ffssi2 \
+	i686.get_pc_thunk.eax \
+	i686.get_pc_thunk.ebp \
+	i686.get_pc_thunk.ebx \
+	i686.get_pc_thunk.ecx \
+	i686.get_pc_thunk.edi \
+	i686.get_pc_thunk.edx \
+	i686.get_pc_thunk.esi
+
+FUNCTIONS.cc_kext.x86_64 := $(CCKEXT_X86_FUNCTIONS) \
+	absvti2 \
+	addvti3 \
+	ashlti3 \
+	ashrti3 \
+	clzti2 \
+	cmpti2 \
+	ctzti2 \
+	divti3 \
+	ffsti2 \
+	fixdfti \
+	fixsfti \
+	fixunsdfti \
+	fixunssfti \
+	fixunsxfti \
+	fixxfti \
+	floattidf \
+	floattisf \
+	floattixf \
+	floatuntidf \
+	floatuntisf \
+	floatuntixf \
+	lshrti3 \
+	modti3 \
+	multi3 \
+	mulvti3 \
+	negti2 \
+	negvti2 \
+	parityti2 \
+	popcountti2 \
+	subvti3 \
+	ucmpti2 \
+	udivmodti4 \
+	udivti3 \
+	umodti3
+
+FUNCTIONS.cc_kext.x86_64h := $(FUNCTIONS.cc_kext.x86_64)
+
+# FIXME: Currently, compiler-rt is missing implementations for a number of the
+# functions that need to go into libcc_kext.a. Filter them out for now.
+CCKEXT_MISSING_FUNCTIONS := \
+	cmpdf2 cmpsf2 div0 \
+	ffssi2 \
+	udiv_w_sdiv unorddf2 unordsf2 bswapdi2 \
+	bswapsi2 \
+	gcc_bcmp \
+	do_global_dtors \
+	i686.get_pc_thunk.eax i686.get_pc_thunk.ebp i686.get_pc_thunk.ebx \
+	i686.get_pc_thunk.ecx i686.get_pc_thunk.edi i686.get_pc_thunk.edx \
+	i686.get_pc_thunk.esi \
+	aeabi_cdcmpeq aeabi_cdrcmple aeabi_cfcmpeq aeabi_cfrcmple aeabi_dcmpeq \
+	aeabi_dcmpge aeabi_dcmpgt aeabi_dcmple aeabi_dcmplt aeabi_drsub aeabi_fcmpeq \
+	aeabi_fcmpge aeabi_fcmpgt aeabi_fcmple aeabi_fcmplt aeabi_frsub aeabi_idivmod \
+	aeabi_uidivmod
+
+FUNCTIONS.cc_kext_ios.armv7 := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext_ios.armv7))
+FUNCTIONS.cc_kext_ios.armv7k := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext_ios.armv7k))
+FUNCTIONS.cc_kext_ios.armv7s := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext_ios.armv7s))
+FUNCTIONS.cc_kext_ios.arm64 := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext_ios.arm64))
+FUNCTIONS.cc_kext.i386 := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext.i386))
+FUNCTIONS.cc_kext.x86_64 := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext.x86_64))
+FUNCTIONS.cc_kext.x86_64h := \
+	$(filter-out $(CCKEXT_MISSING_FUNCTIONS),$(FUNCTIONS.cc_kext.x86_64h))
+
+KERNEL_USE.cc_kext := 1
+KERNEL_USE.cc_kext_ios := 1
+
+VISIBILITY_HIDDEN := 1
+
+SHARED_LIBRARY_SUFFIX := dylib
diff --git a/compiler-rt/make/platform/clang_darwin_test_input.c b/compiler-rt/make/platform/clang_darwin_test_input.c
new file mode 100644
index 0000000..b406a28
--- /dev/null
+++ b/compiler-rt/make/platform/clang_darwin_test_input.c
@@ -0,0 +1,15 @@
+/* Include the headers we use in int_lib.h, to verify that they work. */
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Force us to link at least one symbol in a system library
+// to detect systems where we don't have those for a given
+// architecture.
+int main(int argc, const char **argv) {
+    int x;
+    memcpy(&x,&argc,sizeof(int));
+}
diff --git a/compiler-rt/make/platform/clang_linux.mk b/compiler-rt/make/platform/clang_linux.mk
new file mode 100644
index 0000000..bf5ee4a
--- /dev/null
+++ b/compiler-rt/make/platform/clang_linux.mk
@@ -0,0 +1,91 @@
+Description := Static runtime libraries for clang/Linux.
+
+###
+
+CC := clang
+Arch := unknown
+Configs :=
+
+# We don't currently have any general purpose way to target architectures other
+# than the compiler defaults (because there is no generalized way to invoke
+# cross compilers). For now, we just find the target architecture of the
+# compiler and only define configurations we know that compiler can generate.
+CompilerTargetTriple := $(shell \
+	LANG=C $(CC) -v 2>&1 | grep 'Target:' | cut -d' ' -f2)
+ifeq ($(CompilerTargetTriple),)
+$(error "unable to infer compiler target triple for $(CC)")
+endif
+
+# Only define configs if we detected a linux target.
+ifneq ($(findstring -linux-,$(CompilerTargetTriple)),)
+
+# Define configs only if arch in triple is i386 or x86_64
+CompilerTargetArch := $(firstword $(subst -, ,$(CompilerTargetTriple)))
+ifeq ($(call contains,i386 x86_64,$(CompilerTargetArch)),true)
+
+# TryCompile compiler source flags
+# Returns exit code of running a compiler invocation.
+TryCompile = \
+  $(shell \
+    cflags=""; \
+    for flag in $(3); do \
+      cflags="$$cflags $$flag"; \
+    done; \
+    $(1) $$cflags $(2) -o /dev/null > /dev/null 2> /dev/null ; \
+    echo $$?)
+
+test_source = $(ProjSrcRoot)/make/platform/clang_linux_test_input.c
+ifeq ($(CompilerTargetArch),i386)
+  SupportedArches := i386
+  ifeq ($(call TryCompile,$(CC),$(test_source),-m64),0)
+    SupportedArches += x86_64
+  endif
+else
+  SupportedArches := x86_64
+  ifeq ($(call TryCompile,$(CC),$(test_source),-m32),0)
+    SupportedArches += i386
+  endif
+endif
+
+# Build runtime libraries for i386.
+ifeq ($(call contains,$(SupportedArches),i386),true)
+Configs += builtins-i386 profile-i386
+Arch.builtins-i386 := i386
+Arch.profile-i386 := i386
+endif
+
+# Build runtime libraries for x86_64.
+ifeq ($(call contains,$(SupportedArches),x86_64),true)
+Configs += builtins-x86_64 profile-x86_64
+Arch.builtins-x86_64 := x86_64
+Arch.profile-x86_64 := x86_64
+endif
+
+endif
+
+endif
+
+###
+
+CFLAGS := -Wall -Werror -O3 -fomit-frame-pointer
+
+CFLAGS.builtins-i386 := $(CFLAGS) -m32
+CFLAGS.builtins-x86_64 := $(CFLAGS) -m64
+CFLAGS.profile-i386 := $(CFLAGS) -m32
+CFLAGS.profile-x86_64 := $(CFLAGS) -m64
+
+FUNCTIONS.builtins-i386 := $(CommonFunctions) $(ArchFunctions.i386)
+FUNCTIONS.builtins-x86_64 := $(CommonFunctions) $(ArchFunctions.x86_64)
+FUNCTIONS.profile-i386 := GCDAProfiling InstrProfiling InstrProfilingBuffer \
+                          InstrProfilingFile InstrProfilingPlatformOther \
+                          InstrProfilingRuntime InstrProfilingUtil \
+                          InstrProfilingWriter InstrProfilingValue
+FUNCTIONS.profile-x86_64 := $(FUNCTIONS.profile-i386)
+
+# Always use optimized variants.
+OPTIMIZED := 1
+
+# We don't need to use visibility hidden on Linux.
+VISIBILITY_HIDDEN := 0
+
+SHARED_LIBRARY_SUFFIX := so
diff --git a/compiler-rt/make/platform/clang_linux_test_input.c b/compiler-rt/make/platform/clang_linux_test_input.c
new file mode 100644
index 0000000..e65ce98
--- /dev/null
+++ b/compiler-rt/make/platform/clang_linux_test_input.c
@@ -0,0 +1,4 @@
+// This file is used to check if we can produce working executables
+// for i386 and x86_64 archs on Linux.
+#include <stdlib.h>
+int main(){}
diff --git a/compiler-rt/make/platform/clang_macho_embedded.mk b/compiler-rt/make/platform/clang_macho_embedded.mk
new file mode 100644
index 0000000..d7870d4
--- /dev/null
+++ b/compiler-rt/make/platform/clang_macho_embedded.mk
@@ -0,0 +1,297 @@
+# These are the functions which clang needs when it is targeting a previous
+# version of the OS. The issue is that the backend may use functions which were
+# not present in the libgcc that shipped on the platform. In such cases, we link
+# with a version of the library which contains private_extern definitions of all
+# the extra functions which might be referenced.
+
+Description := Static runtime libraries for embedded clang/Darwin
+
+# A function that ensures we don't try to build for architectures that we
+# don't have working toolchains for.
+CheckArches = \
+  $(shell \
+    result=""; \
+    for arch in $(1); do \
+      if $(CC) -arch $$arch -c \
+	  -integrated-as \
+	  $(ProjSrcRoot)/make/platform/clang_macho_embedded_test_input.c \
+	  -o /dev/null > /dev/null 2> /dev/null; then \
+        result="$$result$$arch "; \
+      else \
+	printf 1>&2 \
+	  "warning: clang_macho_embedded.mk: dropping arch '$$arch' from lib '$(2)'\n"; \
+      fi; \
+    done; \
+    echo $$result)
+
+XCRun = \
+  $(shell \
+    result=`xcrun -find $(1) 2> /dev/null`; \
+    if [ "$$?" != "0" ]; then result=$(1); fi; \
+    echo $$result)
+
+###
+
+CC       := $(call XCRun,clang)
+AR       := $(call XCRun,ar)
+RANLIB   := $(call XCRun,ranlib)
+STRIP    := $(call XCRun,strip)
+LIPO     := $(call XCRun,lipo)
+DSYMUTIL := $(call XCRun,dsymutil)
+
+Configs :=
+UniversalArchs :=
+
+# Soft-float version of the runtime. No floating-point instructions will be used
+# and the ABI (out of necessity) passes floating values in normal registers:
+# non-VFP variant of the AAPCS.
+UniversalArchs.soft_static := $(call CheckArches,armv6m armv7m armv7em armv7,soft_static)
+Configs += $(if $(UniversalArchs.soft_static),soft_static)
+
+# Hard-float version of the runtime. On ARM VFP instructions and registers are
+# allowed, and floating point values get passed in them. VFP variant of the
+# AAPCS.
+UniversalArchs.hard_static := $(call CheckArches,armv7em armv7 i386 x86_64,hard_static)
+Configs += $(if $(UniversalArchs.hard_static),hard_static)
+
+UniversalArchs.soft_pic := $(call CheckArches,armv6m armv7m armv7em armv7,soft_pic)
+Configs += $(if $(UniversalArchs.soft_pic),soft_pic)
+
+UniversalArchs.hard_pic := $(call CheckArches,armv7em armv7 i386 x86_64,hard_pic)
+Configs += $(if $(UniversalArchs.hard_pic),hard_pic)
+
+CFLAGS := -Wall -Werror -Oz -fomit-frame-pointer -ffreestanding
+
+PIC_CFLAGS := -fPIC
+STATIC_CFLAGS := -static
+
+CFLAGS_SOFT := -mfloat-abi=soft
+CFLAGS_HARD := -mfloat-abi=hard
+
+CFLAGS_ARMV7 := -target thumbv7-apple-darwin-eabi
+CFLAGS_I386  := -march=pentium
+
+CFLAGS.soft_static := $(CFLAGS) $(STATIC_CFLAGS) $(CFLAGS_SOFT)
+CFLAGS.hard_static := $(CFLAGS) $(STATIC_CFLAGS) $(CFLAGS_HARD)
+CFLAGS.soft_pic    := $(CFLAGS) $(PIC_CFLAGS) $(CFLAGS_SOFT)
+CFLAGS.hard_pic    := $(CFLAGS) $(PIC_CFLAGS) $(CFLAGS_HARD)
+
+CFLAGS.soft_static.armv7 := $(CFLAGS.soft_static) $(CFLAGS_ARMV7)
+CFLAGS.hard_static.armv7 := $(CFLAGS.hard_static) $(CFLAGS_ARMV7)
+CFLAGS.soft_pic.armv7    := $(CFLAGS.soft_pic) $(CFLAGS_ARMV7)
+CFLAGS.hard_pic.armv7    := $(CFLAGS.hard_pic) $(CFLAGS_ARMV7)
+
+# x86 platforms ignore -mfloat-abi options and complain about doing so. Despite
+# this they're hard-float.
+CFLAGS.hard_static.i386   := $(CFLAGS) $(STATIC_CFLAGS) $(CFLAGS_I386)
+CFLAGS.hard_pic.i386      := $(CFLAGS) $(PIC_CFLAGS) $(CFLAGS_I386)
+CFLAGS.hard_static.x86_64 := $(CFLAGS) $(STATIC_CFLAGS)
+CFLAGS.hard_pic.x86_64    := $(CFLAGS) $(PIC_CFLAGS)
+
+# Functions not wanted:
+#   + eprintf is obsolete anyway
+#   + *vfp: designed for Thumb1 CPUs with VFPv2
+
+COMMON_FUNCTIONS := \
+	absvdi2 \
+	absvsi2 \
+	addvdi3 \
+	addvsi3 \
+	ashldi3 \
+	ashrdi3 \
+	bswapdi2 \
+	bswapsi2 \
+	clzdi2 \
+	clzsi2 \
+	cmpdi2 \
+	ctzdi2 \
+	ctzsi2 \
+	divdc3 \
+	divdi3 \
+	divsc3 \
+	divmodsi4 \
+	udivmodsi4 \
+	do_global_dtors \
+	ffsdi2 \
+	fixdfdi \
+	fixsfdi \
+	fixunsdfdi \
+	fixunsdfsi \
+	fixunssfdi \
+	fixunssfsi \
+	floatdidf \
+	floatdisf \
+	floatundidf \
+	floatundisf \
+	gcc_bcmp \
+	lshrdi3 \
+	moddi3 \
+	muldc3 \
+	muldi3 \
+	mulsc3 \
+	mulvdi3 \
+	mulvsi3 \
+	negdi2 \
+	negvdi2 \
+	negvsi2 \
+	paritydi2 \
+	paritysi2 \
+	popcountdi2 \
+	popcountsi2 \
+	powidf2 \
+	powisf2 \
+	subvdi3 \
+	subvsi3 \
+	ucmpdi2 \
+	udiv_w_sdiv \
+	udivdi3 \
+	udivmoddi4 \
+	umoddi3 \
+	adddf3 \
+	addsf3 \
+	cmpdf2 \
+	cmpsf2 \
+	div0 \
+	divdf3 \
+	divsf3 \
+	divsi3 \
+	extendsfdf2 \
+	extendhfsf2 \
+	ffssi2 \
+	fixdfsi \
+	fixsfsi \
+	floatsidf \
+	floatsisf \
+	floatunsidf \
+	floatunsisf \
+	comparedf2 \
+	comparesf2 \
+	modsi3 \
+	muldf3 \
+	mulsf3 \
+	negdf2 \
+	negsf2 \
+	subdf3 \
+	subsf3 \
+	truncdfhf2 \
+	truncdfsf2 \
+	truncsfhf2 \
+	udivsi3 \
+	umodsi3 \
+	unorddf2 \
+	unordsf2 \
+	atomic_flag_clear \
+	atomic_flag_clear_explicit \
+	atomic_flag_test_and_set \
+	atomic_flag_test_and_set_explicit \
+	atomic_signal_fence \
+	atomic_thread_fence
+
+ARM_FUNCTIONS := \
+	aeabi_cdcmpeq \
+	aeabi_cdrcmple \
+	aeabi_cfcmpeq \
+	aeabi_cfrcmple \
+	aeabi_dcmpeq \
+	aeabi_dcmpge \
+	aeabi_dcmpgt \
+	aeabi_dcmple \
+	aeabi_dcmplt \
+	aeabi_drsub \
+	aeabi_fcmpeq \
+	aeabi_fcmpge \
+	aeabi_fcmpgt \
+	aeabi_fcmple \
+	aeabi_fcmplt \
+	aeabi_frsub \
+	aeabi_idivmod \
+	aeabi_uidivmod \
+
+# ARM Assembly implementation which requires Thumb2 (i.e. won't work on v6M).
+THUMB2_FUNCTIONS := \
+	switch16 \
+	switch32 \
+	switch8 \
+	switchu8 \
+	sync_fetch_and_add_4 \
+	sync_fetch_and_sub_4 \
+	sync_fetch_and_and_4 \
+	sync_fetch_and_or_4 \
+	sync_fetch_and_xor_4 \
+	sync_fetch_and_nand_4 \
+	sync_fetch_and_max_4 \
+	sync_fetch_and_umax_4 \
+	sync_fetch_and_min_4 \
+	sync_fetch_and_umin_4 \
+	sync_fetch_and_add_8 \
+	sync_fetch_and_sub_8 \
+	sync_fetch_and_and_8 \
+	sync_fetch_and_or_8 \
+	sync_fetch_and_xor_8 \
+	sync_fetch_and_nand_8 \
+	sync_fetch_and_max_8 \
+	sync_fetch_and_umax_8 \
+	sync_fetch_and_min_8 \
+	sync_fetch_and_umin_8
+
+I386_FUNCTIONS :=  \
+	i686.get_pc_thunk.eax \
+	i686.get_pc_thunk.ebp \
+	i686.get_pc_thunk.ebx \
+	i686.get_pc_thunk.ecx \
+	i686.get_pc_thunk.edi \
+	i686.get_pc_thunk.edx \
+	i686.get_pc_thunk.esi
+
+# FIXME: Currently, compiler-rt is missing implementations for a number of the
+# functions. Filter them out for now.
+MISSING_FUNCTIONS := \
+	cmpdf2 cmpsf2 div0 \
+	ffssi2 \
+	udiv_w_sdiv unorddf2 unordsf2 bswapdi2 \
+	bswapsi2 \
+	gcc_bcmp \
+	do_global_dtors \
+	i686.get_pc_thunk.eax i686.get_pc_thunk.ebp i686.get_pc_thunk.ebx \
+	i686.get_pc_thunk.ecx i686.get_pc_thunk.edi i686.get_pc_thunk.edx \
+	i686.get_pc_thunk.esi \
+	aeabi_cdcmpeq aeabi_cdrcmple aeabi_cfcmpeq aeabi_cfrcmple aeabi_dcmpeq \
+	aeabi_dcmpge aeabi_dcmpgt aeabi_dcmple aeabi_dcmplt aeabi_drsub \
+	aeabi_fcmpeq \ aeabi_fcmpge aeabi_fcmpgt aeabi_fcmple aeabi_fcmplt \
+	aeabi_frsub aeabi_idivmod aeabi_uidivmod
+
+FUNCTIONS_ARMV6M  := $(COMMON_FUNCTIONS) $(ARM_FUNCTIONS)
+FUNCTIONS_ARM_ALL := $(COMMON_FUNCTIONS) $(ARM_FUNCTIONS) $(THUMB2_FUNCTIONS)
+FUNCTIONS_I386    := $(COMMON_FUNCTIONS) $(I386_FUNCTIONS)
+FUNCTIONS_X86_64  := $(COMMON_FUNCTIONS)
+
+FUNCTIONS_ARMV6M := \
+	$(filter-out $(MISSING_FUNCTIONS),$(FUNCTIONS_ARMV6M))
+FUNCTIONS_ARM_ALL := \
+	$(filter-out $(MISSING_FUNCTIONS),$(FUNCTIONS_ARM_ALL))
+FUNCTIONS_I386 := \
+	$(filter-out $(MISSING_FUNCTIONS),$(FUNCTIONS_I386))
+FUNCTIONS_X86_64 := \
+	$(filter-out $(MISSING_FUNCTIONS),$(FUNCTIONS_X86_64))
+
+FUNCTIONS.soft_static.armv6m := $(FUNCTIONS_ARMV6M)
+FUNCTIONS.soft_pic.armv6m    := $(FUNCTIONS_ARMV6M)
+
+FUNCTIONS.soft_static.armv7m := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.soft_pic.armv7m    := $(FUNCTIONS_ARM_ALL)
+
+FUNCTIONS.soft_static.armv7em := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.hard_static.armv7em := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.soft_pic.armv7em    := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.hard_pic.armv7em    := $(FUNCTIONS_ARM_ALL)
+
+FUNCTIONS.soft_static.armv7 := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.hard_static.armv7 := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.soft_pic.armv7    := $(FUNCTIONS_ARM_ALL)
+FUNCTIONS.hard_pic.armv7    := $(FUNCTIONS_ARM_ALL)
+
+FUNCTIONS.hard_static.i386 := $(FUNCTIONS_I386)
+FUNCTIONS.hard_pic.i386    := $(FUNCTIONS_I386)
+
+FUNCTIONS.hard_static.x86_64 := $(FUNCTIONS_X86_64)
+FUNCTIONS.hard_pic.x86_64    := $(FUNCTIONS_X86_64)
diff --git a/compiler-rt/make/platform/clang_macho_embedded_test_input.c b/compiler-rt/make/platform/clang_macho_embedded_test_input.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/make/platform/clang_macho_embedded_test_input.c
diff --git a/compiler-rt/make/platform/clang_mingw.mk b/compiler-rt/make/platform/clang_mingw.mk
new file mode 100644
index 0000000..2aedbc3
--- /dev/null
+++ b/compiler-rt/make/platform/clang_mingw.mk
@@ -0,0 +1,30 @@
+Description := Static runtime libraries for mingw-w64
+
+###
+
+CC ?= cc
+AR ?= ar
+
+Arch := unknown
+Configs :=
+
+SupportedArches := x86_64 i386 arm
+
+Configs += builtins-x86_64 builtins-i386 builtins-arm
+Arch.builtins-x86_64 := x86_64
+Arch.builtins-i386 := i386
+Arch.builtins-arm := arm
+
+###
+
+CFLAGS := -Wall -O3 -fomit-frame-pointer
+CFLAGS.builtins-x86_64 := -target x86_64-windows-gnu $(CFLAGS)
+CFLAGS.builtins-i386 := -target i686-windows-gnu $(CFLAGS)
+CFLAGS.builtins-arm := -target armv7-windows-gnu $(CFLAGS)
+
+FUNCTIONS.builtins-x86_64 := $(CommonFunctions) $(ArchFunctions.x86_64)
+FUNCTIONS.builtins-i386 := $(CommonFunctions) $(ArchFunctions.i386)
+FUNCTIONS.builtins-arm := $(CommonFunctions) $(ArchFunctions.arm)
+
+# Always use optimized variants.
+OPTIMIZED := 1
diff --git a/compiler-rt/make/platform/darwin_bni.mk b/compiler-rt/make/platform/darwin_bni.mk
new file mode 100644
index 0000000..8e066e8
--- /dev/null
+++ b/compiler-rt/make/platform/darwin_bni.mk
@@ -0,0 +1,135 @@
+
+Description := Target for Darwin using an Apple-style build.
+
+Configs := Debug Release Profile Static
+
+# We override this with RC_ARCHS because B&I may want to build on an ARCH we
+# haven't explicitly defined support for. If all goes well, this will just work
+# and the resulting lib will just have generic versions for anything unknown.
+UniversalArchs := $(RC_ARCHS)
+
+ifneq (,$(SDKROOT))
+	override CC := $(shell xcrun -sdk $(SDKROOT) -find clang || echo "false") 
+	AR := $(shell xcrun -sdk $(SDKROOT) -find ar || echo "false") 
+	RANLIB := $(shell xcrun -sdk $(SDKROOT) -find ranlib || echo "false") 
+	STRIP := $(shell xcrun -sdk $(SDKROOT) -find strip || echo "false") 
+	LIPO := $(shell xcrun -sdk $(SDKROOT) -find lipo || echo "false")
+	DSYMUTIL := $(shell xcrun -sdk $(SDKROOT) -find dsymutil || echo "false")
+endif
+
+ifneq ($(IPHONEOS_DEPLOYMENT_TARGET),)
+	DEPLOYMENT_FLAGS := -miphoneos-version-min=$(IPHONEOS_DEPLOYMENT_TARGET) 
+else
+	ifneq ($(MACOSX_DEPLOYMENT_TARGET),)
+		DEPLOYMENT_FLAGS := -mmacosx-version-min=$(MACOSX_DEPLOYMENT_TARGET) 
+	endif
+endif
+
+ifneq (,$(SDKROOT))
+	DEPLOYMENT_FLAGS += -isysroot $(SDKROOT)
+endif
+
+CFLAGS := -Wall -Os -fomit-frame-pointer -g $(DEPLOYMENT_FLAGS)
+CFLAGS.Static := $(CFLAGS) -static  
+DYLIB_FLAGS := $(DEPLOYMENT_FLAGS) \
+		-Xarch_arm -Wl,-alias_list,$(SRCROOT)/lib/builtins/arm/softfloat-alias.list
+
+VISIBILITY_HIDDEN := 0
+VISIBILITY_HIDDEN.Static  := 1
+
+
+FUNCTIONS := absvdi2 absvsi2 addvdi3 addvsi3 ashldi3 ashrdi3 \
+             clzdi2 clzsi2 cmpdi2 ctzdi2 ctzsi2 \
+             divdc3 divdi3 divsc3 ffsdi2 \
+             fixdfdi fixsfdi fixunsdfdi fixunsdfsi fixunssfdi \
+             fixunssfsi floatdidf floatdisf floatundidf floatundisf \
+             gcc_personality_v0 lshrdi3 moddi3 muldc3 muldi3 mulosi4 \
+             mulodi4 muloti4 mulsc3 mulvdi3 mulvsi3 negdi2 negvdi2 negvsi2 \
+             paritydi2 paritysi2 popcountdi2 popcountsi2 powidf2 \
+             powisf2 subvdi3 subvsi3 ucmpdi2 udivdi3 \
+             udivmoddi4 umoddi3 apple_versioning eprintf atomic \
+             atomic_flag_clear atomic_flag_clear_explicit \
+             atomic_flag_test_and_set atomic_flag_test_and_set_explicit \
+             atomic_signal_fence atomic_thread_fence \
+             extendhfsf2 truncdfhf2 truncsfhf2 
+
+FUNCTIONS.i386 := $(FUNCTIONS) \
+                divxc3 fixunsxfdi fixunsxfsi fixxfdi floatdixf \
+                floatundixf mulxc3 powixf2 clear_cache \
+                enable_execute_stack
+FUNCTIONS.ppc := $(FUNCTIONS) \
+                divtc3 fixtfdi fixunstfdi floatditf floatunditf \
+                gcc_qadd gcc_qdiv gcc_qmul gcc_qsub multc3 \
+                powitf2 restFP saveFP trampoline_setup \
+                clear_cache enable_execute_stack
+FUNCTIONS.x86_64 := $(FUNCTIONS) \
+                absvti2 addvti3 ashlti3 ashrti3 clzti2 cmpti2 \
+                ctzti2 divti3 divxc3 ffsti2 fixdfti fixsfti \
+                fixunsdfti fixunssfti fixunsxfdi fixunsxfsi \
+                fixunsxfti fixxfdi fixxfti floatdixf floattidf \
+                floattisf floattixf floatundixf floatuntidf \
+                floatuntisf floatuntixf lshrti3 modti3 multi3 \
+                muloti4 mulvti3 mulxc3 negti2 negvti2 parityti2 \
+                popcountti2 powixf2 subvti3 ucmpti2 udivmodti4 \
+                udivti3 umodti3 clear_cache enable_execute_stack
+
+FUNCTIONS.armv4t := $(FUNCTIONS) 
+
+FUNCTIONS.armv5 := $(FUNCTIONS) \
+                adddf3 addsf3 bswapdi2 bswapsi2  \
+                comparedf2 comparesf2 extendsfdf2 \
+                divdf3 divsf3 \
+                fixdfsi fixsfsi fixunsdfsi fixunssfsi \
+                floatsidf floatsisf floatunsidf floatunsisf \
+                muldf3 mulsf3 \
+                negdf2 negsf2 \
+                truncdfsf2  \
+                modsi3 umodsi3 udivsi3 divsi3 udivmodsi4 divmodsi4 \
+                switch8 switchu8 switch16 switch32 \
+                sync_synchronize
+
+FUNCTIONS.armv6 := $(FUNCTIONS) \
+				comparedf2 comparesf2 \
+                adddf3vfp addsf3vfp bswapdi2 bswapsi2 divdf3vfp \
+                divsf3vfp eqdf2vfp eqsf2vfp extendsfdf2vfp \
+                fixdfsivfp fixsfsivfp fixunsdfsivfp fixunssfsivfp \
+                floatsidfvfp floatsisfvfp floatunssidfvfp floatunssisfvfp \
+                gedf2vfp gesf2vfp gtdf2vfp gtsf2vfp \
+                ledf2vfp lesf2vfp ltdf2vfp ltsf2vfp \
+                muldf3vfp mulsf3vfp \
+                nedf2vfp nesf2vfp \
+                subdf3vfp subsf3vfp truncdfsf2vfp unorddf2vfp unordsf2vfp \
+                modsi3 umodsi3 udivsi3 divsi3 udivmodsi4 divmodsi4 \
+                switch8 switchu8 switch16 switch32 \
+                restore_vfp_d8_d15_regs save_vfp_d8_d15_regs \
+                sync_synchronize
+
+FUNCTIONS.armv7 := $(FUNCTIONS) \
+				comparedf2 comparesf2 \
+                adddf3vfp addsf3vfp bswapdi2 bswapsi2 divdf3vfp \
+                divsf3vfp eqdf2vfp eqsf2vfp extendsfdf2vfp \
+                fixdfsivfp fixsfsivfp fixunsdfsivfp fixunssfsivfp \
+                floatsidfvfp floatsisfvfp floatunssidfvfp floatunssisfvfp \
+                gedf2vfp gesf2vfp gtdf2vfp gtsf2vfp \
+                ledf2vfp lesf2vfp ltdf2vfp ltsf2vfp \
+                muldf3vfp mulsf3vfp \
+                nedf2vfp nesf2vfp \
+                subdf3vfp subsf3vfp truncdfsf2vfp unorddf2vfp unordsf2vfp \
+                modsi3 umodsi3 udivsi3 divsi3 udivmodsi4 divmodsi4
+
+FUNCTIONS.armv7s := $(FUNCTIONS.armv7)
+
+FUNCTIONS.arm64 :=  divti3 modti3 \
+					udivmodti4 \
+					udivti3 umodti3 \
+					mulsc3 muldc3 \
+					powisf2 powidf2 \
+					clzti2 \
+					fixdfti fixsfti \
+					fixunsdfti fixunssfti fixunssfti \
+					floattidf floattisf floatuntidf floatuntisf \
+					gcc_personality_v0 atomic \
+					atomic_flag_clear atomic_flag_clear_explicit \
+					atomic_flag_test_and_set \
+					atomic_flag_test_and_set_explicit \
+					atomic_signal_fence atomic_thread_fence
diff --git a/compiler-rt/make/platform/multi_arch.mk b/compiler-rt/make/platform/multi_arch.mk
new file mode 100644
index 0000000..fe6ac4b
--- /dev/null
+++ b/compiler-rt/make/platform/multi_arch.mk
@@ -0,0 +1,15 @@
+Description := Example configuration for build two libraries for separate \
+architectures.
+
+Configs := m32 m64
+Arch := i386
+Arch.m64 := x86_64
+
+CC := clang
+
+CFLAGS := -Wall -Werror
+CFLAGS.m32 := $(CFLAGS) -m32 -O3
+CFLAGS.m64 := $(CFLAGS) -m64 -O3
+
+FUNCTIONS := moddi3 floatundixf udivdi3
+FUNCTIONS.m64 := $(FUNCTIONS) lshrdi3
diff --git a/compiler-rt/make/subdir.mk b/compiler-rt/make/subdir.mk
new file mode 100644
index 0000000..f81c25f
--- /dev/null
+++ b/compiler-rt/make/subdir.mk
@@ -0,0 +1,92 @@
+# This file is intended to be included from each subdirectory makefile.
+#
+# Subdirectory makefiles must define:
+#   SubDirs - The subdirectories to traverse.
+#
+# Subdirectory makefiles may define:
+#   ModuleName - The library name for objects in that directory.
+#   ObjNames - The objects available in that directory.
+#   Implementation - The library configuration the objects should go in (Generic
+#                    or Optimized)
+#   Dependencies - Any dependences for the object files.
+#   OnlyArchs - Only build the objects for the listed archs.
+#   OnlyConfigs - Only build the objects for the listed configurations.
+
+ifeq ($(Dir),)
+  $(error "No Dir variable defined.")
+endif
+
+###
+# Include child makefile fragments
+
+# The list of variables which are intended to be overridden in a subdirectory
+# makefile.
+RequiredSubdirVariables := SubDirs 
+OptionalSubdirVariables := ModuleName OnlyArchs OnlyConfigs \
+	ObjNames Implementation Dependencies
+
+# Template: subdir_traverse_template subdir
+define subdir_traverse_template
+$(call Set,Dir,$(1))
+ifneq ($(DEBUGMAKE),)
+  $$(info MAKE: $(Dir): Processing subdirectory)
+endif
+
+# Construct the variable key for this directory.
+$(call Set,DirKey,SubDir.$(subst .,,$(subst /,__,$(1))))
+$(call Append,SubDirKeys,$(DirKey))
+$(call Set,$(DirKey).Dir,$(Dir))
+
+# Reset subdirectory specific variables to sentinel value.
+$$(foreach var,$$(RequiredSubdirVariables) $$(OptionalSubdirVariables),\
+  $$(call Set,$$(var),UNDEFINED))
+
+# Get the subdirectory variables.
+include $(1)/Makefile.mk
+
+ifeq ($(DEBUGMAKE),2)
+$$(foreach var,$(RequiredSubdirVariables) $(OptionalSubdirVariables),\
+  $$(if $$(call strneq,UNDEFINED,$$($$(var))), \
+	$$(info MAKE: $(Dir): $$(var) is defined), \
+	$$(info MAKE: $(Dir): $$(var) is undefined)))
+endif
+
+# Check for undefined required variables, and unset sentinel value from optional
+# variables.
+$$(foreach var,$(RequiredSubdirVariables),\
+  $$(if $$(call strneq,UNDEFINED,$$($$(var))),, \
+	$$(error $(Dir): variable '$$(var)' was not undefined)))
+$$(foreach var,$(OptionalSubdirVariables),\
+  $$(if $$(call strneq,UNDEFINED,$$($$(var))),, \
+	$$(call Set,$$(var),)))
+
+# Collect all subdirectory variables for subsequent use.
+$$(foreach var,$(RequiredSubdirVariables) $(OptionalSubdirVariables),\
+  $$(call Set,$(DirKey).$$(var),$$($$(var))))
+
+# Recurse.
+include make/subdir.mk
+
+# Restore directory variable, for cleanliness.
+$$(call Set,Dir,$(1))
+
+ifneq ($(DEBUGMAKE),)
+  $$(info MAKE: $$(Dir): Done processing subdirectory)
+endif
+endef
+
+# Evaluate this now so we do not have to worry about order of evaluation.
+
+SubDirsList := $(strip \
+  $(if $(call streq,.,$(Dir)),\
+       $(SubDirs),\
+       $(SubDirs:%=$(Dir)/%)))
+ifeq ($(SubDirsList),)
+else
+  ifneq ($(DEBUGMAKE),)
+    $(info MAKE: Descending into subdirs: $(SubDirsList))
+  endif
+
+  $(foreach subdir,$(SubDirsList),\
+	$(eval $(call subdir_traverse_template,$(subdir))))
+endif
diff --git a/compiler-rt/make/test/test-util.mk b/compiler-rt/make/test/test-util.mk
new file mode 100644
index 0000000..c80c28d
--- /dev/null
+++ b/compiler-rt/make/test/test-util.mk
@@ -0,0 +1,66 @@
+include make/util.mk
+
+streq_t0 = $(call streq,,)
+$(call AssertEqual,streq_t0,true)
+streq_t1 = $(call streq,b,)
+$(call AssertEqual,streq_t1,)
+streq_t2 = $(call streq,,b)
+$(call AssertEqual,streq_t2,)
+streq_t3 = $(call streq,b,b)
+$(call AssertEqual,streq_t3,true)
+streq_t4 = $(call streq,bb,b)
+$(call AssertEqual,streq_t4,)
+streq_t5 = $(call streq,b,bb)
+$(call AssertEqual,streq_t5,)
+streq_t6 = $(call streq,bb,bb)
+$(call AssertEqual,streq_t6,true)
+
+strneq_t7 = $(call strneq,,)
+$(call AssertEqual,strneq_t7,)
+strneq_t8 = $(call strneq,b,)
+$(call AssertEqual,strneq_t8,true)
+strneq_t9 = $(call strneq,,b)
+$(call AssertEqual,strneq_t9,true)
+strneq_t10 = $(call strneq,b,b)
+$(call AssertEqual,strneq_t10,)
+strneq_t11 = $(call strneq,bb,b)
+$(call AssertEqual,strneq_t11,true)
+strneq_t12 = $(call strneq,b,bb)
+$(call AssertEqual,strneq_t12,true)
+strneq_t13 = $(call strneq,bb,bb)
+$(call AssertEqual,strneq_t13,)
+
+contains_t0 = $(call contains,a b b c,a)
+$(call AssertEqual,contains_t0,true)
+contains_t1 = $(call contains,a b b c,b)
+$(call AssertEqual,contains_t1,true)
+contains_t2 = $(call contains,a b b c,c)
+$(call AssertEqual,contains_t2,true)
+contains_t3 = $(call contains,a b b c,d)
+$(call AssertEqual,contains_t3,)
+
+isdefined_t0_defined_var := 0
+isdefined_t0 = $(call IsDefined,isdefined_t0_defined_var)
+$(call AssertEqual,isdefined_t0,true)
+isdefined_t1 = $(call IsDefined,isdefined_t1_never_defined_var)
+$(call AssertEqual,isdefined_t1,)
+
+varordefault_t0_var := 1
+varordefault_t0 = $(call VarOrDefault,varordefault_t0_var.opt,$(varordefault_t0_var))
+$(call AssertEqual,varordefault_t0,1)
+varordefault_t1_var := 1
+varordefault_t1_var.opt := 2
+varordefault_t1 = $(call VarOrDefault,varordefault_t1_var.opt,$(varordefault_t1_var))
+$(call AssertEqual,varordefault_t1,2)
+
+$(call CopyVariable,copyvariable_t0_src,copyvariable_t0_dst)
+copyvariable_t0 = $(call IsUndefined,copyvariable_t0_dst)
+$(call AssertEqual,copyvariable_t0,true)
+copyvariable_t1_src = 1
+$(call CopyVariable,copyvariable_t1_src,copyvariable_t1)
+$(call AssertEqual,copyvariable_t1,1)
+
+all:
+	@true
+.PHONY: all
+
diff --git a/compiler-rt/make/util.mk b/compiler-rt/make/util.mk
new file mode 100644
index 0000000..0687755
--- /dev/null
+++ b/compiler-rt/make/util.mk
@@ -0,0 +1,114 @@
+# Generic Makefile Utilities
+
+###
+# Utility functions
+
+# Function: streq LHS RHS
+#
+# Return "true" if LHS == RHS, otherwise "".
+#
+# LHS == RHS <=> (LHS subst RHS is empty) and (RHS subst LHS is empty)
+streq = $(if $(1),$(if $(subst $(1),,$(2))$(subst $(2),,$(1)),,true),$(if $(2),,true))
+
+# Function: strneq LHS RHS
+#
+# Return "true" if LHS != RHS, otherwise "".
+strneq = $(if $(call streq,$(1),$(2)),,true)
+
+# Function: contains list item
+#
+# Return "true" if 'list' contains the value 'item'.
+contains = $(if $(strip $(foreach i,$(1),$(if $(call streq,$(2),$(i)),T,))),true,)
+
+# Function: is_subset a b
+# Return "true" if 'a' is a subset of 'b'.
+is_subset = $(if $(strip $(set_difference $(1),$(2))),,true)
+
+# Function: set_difference a b
+# Return a - b.
+set_difference = $(foreach i,$(1),$(if $(call contains,$(2),$(i)),,$(i)))
+
+# Function: Set variable value
+#
+# Set the given make variable to the given value.
+Set = $(eval $(1) := $(2))
+
+# Function: Append variable value
+#
+# Append the given value to the given make variable.
+Append = $(eval $(1) += $(2))
+
+# Function: IsDefined variable
+#
+# Check whether the given variable is defined.
+IsDefined = $(call strneq,undefined,$(flavor $(1)))
+
+# Function: IsUndefined variable
+#
+# Check whether the given variable is undefined.
+IsUndefined = $(call streq,undefined,$(flavor $(1)))
+
+# Function: VarOrDefault variable default-value
+#
+# Get the value of the given make variable, or the default-value if the variable
+# is undefined.
+VarOrDefault = $(if $(call IsDefined,$(1)),$($(1)),$(2))
+
+# Function: CheckValue variable
+#
+# Print the name, definition, and value of a variable, for testing make
+# utilities.
+#
+# Example:
+#   foo = $(call streq,a,a)
+#   $(call CheckValue,foo)
+# Example Output:
+#   CHECKVALUE: foo: $(call streq,,) - true
+CheckValue = $(info CHECKVALUE: $(1): $(value $(1)) - $($(1)))
+
+# Function: CopyVariable src dst
+#
+# Copy the value of the variable 'src' to 'dst', taking care to not define 'dst'
+# if 'src' is undefined. The destination variable must be undefined.
+CopyVariable = \
+  $(call AssertValue,$(call IsUndefined,$(2)),destination is already defined)\
+  $(if $(call IsUndefined,$(1)),,\
+       $(call Set,$(2),$($(1))))
+
+# Function: Assert value message
+#
+# Check that a value is true, or give an error including the given message
+Assert = $(if $(1),,\
+           $(error Assertion failed: $(2)))
+
+# Function: AssertEqual variable expected-value
+#
+# Check that the value of a variable is 'expected-value'.
+AssertEqual = \
+  $(if $(call streq,$($(1)),$(2)),,\
+       $(error Assertion failed: $(1): $(value $(1)) - $($(1)) != $(2)))
+
+# Function: CheckCommandLineOverrides list
+#
+# Check that all command line variables are in the given list. This routine is
+# useful for validating that users aren't trying to override something which
+# will not work.
+CheckCommandLineOverrides = \
+  $(foreach arg,$(MAKEOVERRIDES),\
+    $(call Set,varname,$(firstword $(subst =, ,$(arg)))) \
+    $(if $(call contains,$(1),$(varname)),,\
+      $(error "Invalid command line override: $(1) $(varname) (not supported)")))
+
+###
+# Clean up make behavior
+
+# Cancel all suffix rules. We don't want no stinking suffix rules.
+.SUFFIXES:
+
+###
+# Debugging
+
+# General debugging rule, use 'make print-XXX' to print the definition, value
+# and origin of XXX.
+make-print-%:
+	$(error PRINT: $(value $*) = "$($*)" (from $(origin $*)))
diff --git a/compiler-rt/test/BlocksRuntime/block-static.c b/compiler-rt/test/BlocksRuntime/block-static.c
new file mode 100644
index 0000000..d38c816
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/block-static.c
@@ -0,0 +1,25 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// testfilerunner CONFIG
+
+#include <stdio.h>
+
+
+int main(int argc, char **argv) {
+  static int numberOfSquesals = 5;
+
+  ^{ numberOfSquesals = 6; }();
+
+  if (numberOfSquesals == 6) {
+    printf("%s: success\n", argv[0]);
+    return 0;
+   }
+   printf("**** did not update static local, rdar://6177162\n");
+   return 1;
+
+}
+
diff --git a/compiler-rt/test/BlocksRuntime/blockimport.c b/compiler-rt/test/BlocksRuntime/blockimport.c
new file mode 100644
index 0000000..178fce4
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/blockimport.c
@@ -0,0 +1,51 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  blockimport.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 10/13/08.
+ *
+ */
+
+
+//
+// pure C nothing more needed
+// CONFIG  rdar://6289344
+
+#include <stdio.h>
+#include <Block.h>
+#include <Block_private.h>
+
+
+
+
+int main(int argc, char *argv[]) {
+    int i = 1;
+    int (^intblock)(void) = ^{ return i*10; };
+    
+    void (^vv)(void) = ^{
+        if (argc > 0) {
+            printf("intblock returns %d\n", intblock());
+        }
+    };
+
+#if 0    
+    //printf("Block dump %s\n", _Block_dump(vv));
+    {
+        struct Block_layout *layout = (struct Block_layout *)(void *)vv;
+        printf("isa %p\n", layout->isa);
+        printf("flags %x\n", layout->flags);
+        printf("descriptor %p\n", layout->descriptor);
+        printf("descriptor->size %d\n", layout->descriptor->size);
+    }
+#endif
+    void (^vvcopy)(void) = Block_copy(vv);
+    Block_release(vvcopy);
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefaccess.c b/compiler-rt/test/BlocksRuntime/byrefaccess.c
new file mode 100644
index 0000000..4565553
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefaccess.c
@@ -0,0 +1,34 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  byrefaccess.m
+//  test that byref access to locals is accurate
+//  testObjects
+//
+//  Created by Blaine Garst on 5/13/08.
+//
+// CONFIG
+
+#include <stdio.h>
+
+
+void callVoidVoid(void (^closure)(void)) {
+    closure();
+}
+
+int main(int argc, char *argv[]) {
+    __block int i = 10;
+    
+    callVoidVoid(^{ ++i; });
+    
+    if (i != 11) {
+        printf("*** %s didn't update i\n", argv[0]);
+        return 1;
+    }
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefcopy.c b/compiler-rt/test/BlocksRuntime/byrefcopy.c
new file mode 100644
index 0000000..513b63c
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefcopy.c
@@ -0,0 +1,41 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  byrefcopy.m
+//  testObjects
+//
+//  Created by Blaine Garst on 5/13/08.
+//
+
+#include <stdio.h>
+#include <Block.h>
+#include <Block_private.h>
+
+// CONFIG
+
+void callVoidVoid(void (^closure)(void)) {
+    closure();
+}
+
+int main(int argc, char *argv[]) {
+    int __block i = 10;
+    
+    void (^block)(void) = ^{ ++i; };
+    //printf("original (old style) is  %s\n", _Block_dump_old(block));
+    //printf("original (new style) is %s\n", _Block_dump(block));
+    void (^blockcopy)(void) = Block_copy(block);
+    //printf("copy is %s\n", _Block_dump(blockcopy));
+    // use a copy & see that it updates i
+    callVoidVoid(block);
+    
+    if (i != 11) {
+        printf("*** %s didn't update i\n", argv[0]);
+        return 1;
+    }
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefcopycopy.c b/compiler-rt/test/BlocksRuntime/byrefcopycopy.c
new file mode 100644
index 0000000..d6fafc1
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefcopycopy.c
@@ -0,0 +1,46 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG rdar://6255170
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <Block.h>
+#include <Block_private.h>
+#include <assert.h>
+
+
+int
+main(int argc, char *argv[])
+{
+    __block int var = 0;
+    int shouldbe = 0;
+    void (^b)(void) = ^{ var++; /*printf("var is at %p with value %d\n", &var, var);*/ };
+    __typeof(b) _b;
+    //printf("before copy...\n");
+    b(); ++shouldbe;
+    size_t i;
+
+    for (i = 0; i < 10; i++) {
+            _b = Block_copy(b); // make a new copy each time
+            assert(_b);
+            ++shouldbe;
+            _b();               // should still update the stack
+            Block_release(_b);
+    }
+
+    //printf("after...\n");
+    b(); ++shouldbe;
+
+    if (var != shouldbe) {
+        printf("Hmm, var is %d but should be %d\n", var, shouldbe);
+        return 1;
+    }
+    printf("%s: Success!!\n", argv[0]);
+
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefcopyinner.c b/compiler-rt/test/BlocksRuntime/byrefcopyinner.c
new file mode 100644
index 0000000..0777093
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefcopyinner.c
@@ -0,0 +1,32 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include <Block.h>
+#include <stdio.h>
+
+// CONFIG rdar://6225809
+// fixed in 5623
+
+int main(int argc, char *argv[]) {
+    __block int a = 42;
+    int* ap = &a; // just to keep the address on the stack.
+
+    void (^b)(void) = ^{
+        //a;              // workaround, a should be implicitly imported
+        Block_copy(^{
+            a = 2;
+        });
+    };
+
+    Block_copy(b);
+
+    if(&a == ap) {
+        printf("**** __block heap storage should have been created at this point\n");
+        return 1;
+    }
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefcopyint.c b/compiler-rt/test/BlocksRuntime/byrefcopyint.c
new file mode 100644
index 0000000..d632f88
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefcopyint.c
@@ -0,0 +1,69 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  byrefcopyint.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 12/1/08.
+ *
+ */
+
+//
+//  byrefcopyid.m
+//  testObjects
+//
+//  Created by Blaine Garst on 5/13/08.
+//
+
+// Tests copying of blocks with byref ints
+// CONFIG rdar://6414583 -C99
+
+#include <stdio.h>
+#include <string.h>
+#include <Block.h>
+#include <Block_private.h>
+
+
+
+
+typedef void (^voidVoid)(void);
+
+voidVoid dummy;
+
+void callVoidVoid(voidVoid closure) {
+    closure();
+}
+
+
+voidVoid testRoutine(const char *whoami) {
+    __block int  dumbo = strlen(whoami);
+    dummy = ^{
+        //printf("incring dumbo from %d\n", dumbo);
+        ++dumbo;
+    };
+    
+    
+    voidVoid copy = Block_copy(dummy);
+    
+
+    return copy;
+}
+
+int main(int argc, char *argv[]) {
+    voidVoid array[100];
+    for (int i = 0; i <  100; ++i) {
+        array[i] = testRoutine(argv[0]);
+        array[i]();
+    }
+    for (int i = 0; i <  100; ++i) {
+        Block_release(array[i]);
+    }
+    
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefcopystack.c b/compiler-rt/test/BlocksRuntime/byrefcopystack.c
new file mode 100644
index 0000000..d119afa
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefcopystack.c
@@ -0,0 +1,41 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  byrefcopystack.m
+//  testObjects
+//
+//  Created by Blaine Garst on 5/13/08.
+//
+
+
+
+#include <stdio.h>
+#include <Block.h>
+
+// CONFIG rdar://6255170
+
+void (^bumpi)(void);
+int (^geti)(void);
+
+void setClosures() {
+    int __block i = 10;
+    bumpi = Block_copy(^{ ++i; });
+    geti = Block_copy(^{ return i; });
+}
+
+int main(int argc, char *argv[]) {
+    setClosures();
+    bumpi();
+    int i = geti();
+    
+    if (i != 11) {
+        printf("*** %s didn't update i\n", argv[0]);
+        return 1;
+    }
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/byrefsanity.c b/compiler-rt/test/BlocksRuntime/byrefsanity.c
new file mode 100644
index 0000000..dfa16b0
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefsanity.c
@@ -0,0 +1,73 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG
+
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <Block.h>
+
+int
+main(int argc, char *argv[])
+{
+    __block int var = 0;
+    void (^b)(void) = ^{ var++; };
+    
+    //sanity(b);
+    b();
+    printf("%s: success!\n", argv[0]);
+    return 0;
+}
+
+
+#if 1
+/* replicated internal data structures: BEWARE, MAY CHANGE!!! */
+
+enum {
+    BLOCK_REFCOUNT_MASK =     (0xffff),
+    BLOCK_NEEDS_FREE =        (1 << 24),
+    BLOCK_HAS_COPY_DISPOSE =  (1 << 25),
+    BLOCK_NO_COPY =           (1 << 26), // interim byref: no copies allowed
+    BLOCK_IS_GC =             (1 << 27),
+    BLOCK_IS_GLOBAL =         (1 << 28),
+};
+
+struct byref_id {
+    struct byref_id *forwarding;
+    int flags;//refcount;
+    int size;
+    void (*byref_keep)(struct byref_id *dst, struct byref_id *src);
+    void (*byref_destroy)(struct byref_id *);
+    int var;
+};
+struct Block_basic2 {
+    void *isa;
+    int Block_flags;  // int32_t
+    int Block_size; // XXX should be packed into Block_flags
+    void (*Block_invoke)(void *);
+    void (*Block_copy)(void *dst, void *src);
+    void (*Block_dispose)(void *);
+    struct byref_id *ref;
+};
+
+void sanity(void *arg) {
+    struct Block_basic2 *bb = (struct Block_basic2 *)arg;
+    if ( ! (bb->Block_flags & BLOCK_HAS_COPY_DISPOSE)) {
+        printf("missing copy/dispose helpers for byref data\n");
+        exit(1);
+    }
+    struct byref_id *ref = bb->ref;
+    if (ref->forwarding != ref) {
+        printf("forwarding pointer should be %p but is %p\n", ref, ref->forwarding);
+        exit(1);
+    }
+}
+#endif
+
+
+        
diff --git a/compiler-rt/test/BlocksRuntime/byrefstruct.c b/compiler-rt/test/BlocksRuntime/byrefstruct.c
new file mode 100644
index 0000000..a3dc44e
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/byrefstruct.c
@@ -0,0 +1,57 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//  -*- mode:C; c-basic-offset:4; tab-width:4; intent-tabs-mode:nil;  -*-
+// CONFIG
+
+#import <stdio.h>
+#import <stdlib.h>
+#import <string.h>
+
+typedef struct {
+    unsigned long ps[30];
+    int qs[30];
+} BobTheStruct;
+
+int main (int argc, const char * argv[]) {
+    __block BobTheStruct fiddly;
+    BobTheStruct copy;
+
+    void (^incrementFiddly)() = ^{
+        int i;
+        for(i=0; i<30; i++) {
+            fiddly.ps[i]++;
+            fiddly.qs[i]++;
+        }
+    };
+    
+    memset(&fiddly, 0xA5, sizeof(fiddly));
+    memset(&copy, 0x2A, sizeof(copy));    
+    
+    int i;
+    for(i=0; i<30; i++) {
+        fiddly.ps[i] = i * i * i;
+        fiddly.qs[i] = -i * i * i;
+    }
+    
+    copy = fiddly;
+    incrementFiddly();
+
+    if ( &copy == &fiddly ) {
+        printf("%s: struct wasn't copied.", argv[0]);
+        exit(1);
+    }
+    for(i=0; i<30; i++) {
+        //printf("[%d]: fiddly.ps: %lu, copy.ps: %lu, fiddly.qs: %d, copy.qs: %d\n", i, fiddly.ps[i], copy.ps[i], fiddly.qs[i], copy.qs[i]);
+        if ( (fiddly.ps[i] != copy.ps[i] + 1) || (fiddly.qs[i] != copy.qs[i] + 1) ) {
+            printf("%s: struct contents were not incremented.", argv[0]);
+            exit(1);
+        }
+    }
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/c99.c b/compiler-rt/test/BlocksRuntime/c99.c
new file mode 100644
index 0000000..8f31ab3
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/c99.c
@@ -0,0 +1,20 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  c99.m
+//
+// CONFIG C99 rdar://problem/6399225
+
+#import <stdio.h>
+#import <stdlib.h>
+
+int main(int argc, char *argv[]) {
+    void (^blockA)(void) = ^ { ; };
+    blockA();
+    printf("%s: success\n", argv[0]);
+    exit(0);
+}
diff --git a/compiler-rt/test/BlocksRuntime/cast.c b/compiler-rt/test/BlocksRuntime/cast.c
new file mode 100644
index 0000000..5bef2c1
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/cast.c
@@ -0,0 +1,37 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  cast.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 2/17/09.
+ *
+ */
+
+// PURPOSE should allow casting of a Block reference to an arbitrary pointer and back
+// CONFIG open
+
+#include <stdio.h>
+
+
+
+int main(int argc, char *argv[]) {
+
+    void (^aBlock)(void);
+    int *ip;
+    char *cp;
+    double *dp;
+
+    ip = (int *)aBlock;
+    cp = (char *)aBlock;
+    dp = (double *)aBlock;
+    aBlock = (void (^)(void))ip;
+    aBlock = (void (^)(void))cp;
+    aBlock = (void (^)(void))dp;
+    printf("%s: success", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/constassign.c b/compiler-rt/test/BlocksRuntime/constassign.c
new file mode 100644
index 0000000..537cb2d
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/constassign.c
@@ -0,0 +1,28 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  constassign.c
+//  bocktest
+//
+//  Created by Blaine Garst on 3/21/08.
+//
+// shouldn't be able to assign to a const pointer
+// CONFIG error: assignment of read-only
+
+#import <stdio.h>
+
+void foo(void) { printf("I'm in foo\n"); }
+void bar(void) { printf("I'm in bar\n"); }
+
+int main(int argc, char *argv[]) {
+    void (*const fptr)(void) = foo;
+    void (^const  blockA)(void) = ^ { printf("hello\n"); };
+    blockA = ^ { printf("world\n"); } ;
+    fptr = bar;
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/copy-block-literal-rdar6439600.c b/compiler-rt/test/BlocksRuntime/copy-block-literal-rdar6439600.c
new file mode 100644
index 0000000..6fa488e
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/copy-block-literal-rdar6439600.c
@@ -0,0 +1,29 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG open rdar://6439600
+
+#import <stdio.h>
+#import <stdlib.h>
+
+#define NUMBER_OF_BLOCKS 100
+int main (int argc, const char * argv[]) {
+    int (^x[NUMBER_OF_BLOCKS])();
+    int i;
+    
+    for(i=0; i<NUMBER_OF_BLOCKS; i++) x[i] = ^{ return i; };
+
+    for(i=0; i<NUMBER_OF_BLOCKS; i++) {
+        if (x[i]() != i) {
+            printf("%s: failure, %d != %d\n", argv[0], x[i](), i);
+            exit(1);
+        }
+    }
+    
+    printf("%s: success\n", argv[0]);
+    
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/copyconstructor.C b/compiler-rt/test/BlocksRuntime/copyconstructor.C
new file mode 100644
index 0000000..626d33e
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/copyconstructor.C
@@ -0,0 +1,85 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include <stdio.h>
+#include <Block.h>
+
+// CONFIG C++ rdar://6243400,rdar://6289367
+
+
+int constructors = 0;
+int destructors = 0;
+
+
+#define CONST const
+
+class TestObject
+{
+public:
+	TestObject(CONST TestObject& inObj);
+	TestObject();
+	~TestObject();
+	
+	TestObject& operator=(CONST TestObject& inObj);
+
+	int version() CONST { return _version; }
+private:
+	mutable int _version;
+};
+
+TestObject::TestObject(CONST TestObject& inObj)
+	
+{
+        ++constructors;
+        _version = inObj._version;
+	//printf("%p (%d) -- TestObject(const TestObject&) called\n", this, _version); 
+}
+
+
+TestObject::TestObject()
+{
+        _version = ++constructors;
+	//printf("%p (%d) -- TestObject() called\n", this, _version); 
+}
+
+
+TestObject::~TestObject()
+{
+	//printf("%p -- ~TestObject() called\n", this);
+        ++destructors;
+}
+
+
+TestObject& TestObject::operator=(CONST TestObject& inObj)
+{
+	//printf("%p -- operator= called\n", this);
+        _version = inObj._version;
+	return *this;
+}
+
+
+
+void testRoutine() {
+    TestObject one;
+    
+    void (^b)(void) = ^{ printf("my const copy of one is %d\n", one.version()); };
+}
+    
+    
+
+int main(int argc, char *argv[]) {
+    testRoutine();
+    if (constructors == 0) {
+        printf("No copy constructors!!!\n");
+        return 1;
+    }
+    if (constructors != destructors) {
+        printf("%d constructors but only %d destructors\n", constructors, destructors);
+        return 1;
+    }
+    printf("%s:success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/copynull.c b/compiler-rt/test/BlocksRuntime/copynull.c
new file mode 100644
index 0000000..c49e499
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/copynull.c
@@ -0,0 +1,37 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  copynull.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 10/15/08.
+ *
+ */
+ 
+#import <stdio.h>
+#import <Block.h>
+#import <Block_private.h>
+ 
+// CONFIG rdar://6295848
+
+int main(int argc, char *argv[]) {
+    
+    void (^block)(void) = (void (^)(void))0;
+    void (^blockcopy)(void) = Block_copy(block);
+    
+    if (blockcopy != (void (^)(void))0) {
+        printf("whoops, somehow we copied NULL!\n");
+        return 1;
+    }
+    // make sure we can also
+    Block_release(blockcopy);
+    // and more secretly
+    //_Block_destroy(blockcopy);
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/dispatch_async.c b/compiler-rt/test/BlocksRuntime/dispatch_async.c
new file mode 100644
index 0000000..e3e517c
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/dispatch_async.c
@@ -0,0 +1,57 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <dispatch/dispatch.h>
+#include <unistd.h>
+//#import <Foundation/Foundation.h>
+#include <Block.h>
+
+// CONFIG rdar://problem/6371811
+
+const char *whoami = "nobody";
+
+void EnqueueStuff(dispatch_queue_t q)
+{
+    __block CFIndex counter;
+    
+    // above call has a side effect: it works around:
+    // <rdar://problem/6225809> __block variables not implicitly imported into intermediate scopes
+    dispatch_async(q, ^{
+        counter = 0;
+    });
+    
+    
+    dispatch_async(q, ^{
+        //printf("outer block.\n");
+        counter++;
+        dispatch_async(q, ^{
+            //printf("inner block.\n");
+            counter--;
+            if(counter == 0) {
+                printf("%s: success\n", whoami);
+                exit(0);
+            }
+        });
+        if(counter == 0) {
+            printf("already done? inconceivable!\n");
+            exit(1);
+        }
+    });        
+}
+
+int main (int argc, const char * argv[]) {
+    dispatch_queue_t q = dispatch_queue_create("queue", NULL);
+
+    whoami = argv[0];
+    
+    EnqueueStuff(q);
+    
+    dispatch_main();
+    printf("shouldn't get here\n");
+    return 1;
+}
diff --git a/compiler-rt/test/BlocksRuntime/dispatch_call_Block_with_release.c b/compiler-rt/test/BlocksRuntime/dispatch_call_Block_with_release.c
new file mode 100644
index 0000000..9e06f69
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/dispatch_call_Block_with_release.c
@@ -0,0 +1,31 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include <stdio.h>
+#include <Block.h>
+
+// CONFIG
+
+void callsomething(const char *format, int argument) {
+}
+
+void
+dispatch_call_Block_with_release2(void *block)
+{
+        void (^b)(void) = (void (^)(void))block;
+        b();
+        Block_release(b);
+}
+
+int main(int argc, char *argv[]) {
+     void (^b1)(void) = ^{ callsomething("argc is %d\n", argc); };
+     void (^b2)(void) = ^{ callsomething("hellow world\n", 0); }; // global block now
+
+     dispatch_call_Block_with_release2(Block_copy(b1));
+     dispatch_call_Block_with_release2(Block_copy(b2));
+     printf("%s: Success\n", argv[0]);
+     return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/fail.c b/compiler-rt/test/BlocksRuntime/fail.c
new file mode 100644
index 0000000..28dbc2d
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/fail.c
@@ -0,0 +1,107 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  fail.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 9/16/08.
+ *
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+
+bool readfile(char *buffer, const char *from) {
+    int fd = open(from, 0);
+    if (fd < 0) return false;
+    int count = read(fd, buffer, 512);
+    if (count < 0) return false;
+    buffer[count] = 0; // zap newline
+    return true;
+}
+
+// basic idea, take compiler args, run compiler, and verify that expected failure matches any existing one
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) return 0;
+    char *copy[argc+1];   // make a copy
+    // find and strip off -e "errorfile"
+    char *errorfile = NULL;
+    int counter = 0, i = 0;
+    for (i = 1; i < argc; ++i) {    // skip 0 arg which is "fail"
+        if (!strncmp(argv[i], "-e", 2)) {
+            errorfile = argv[++i];
+        }
+        else {
+            copy[counter++] = argv[i];
+        }
+    }
+    copy[counter] = NULL;
+    pid_t child = fork();
+    char buffer[512];
+    if (child == 0) {
+        // in child
+        sprintf(buffer, "/tmp/errorfile_%d", getpid());
+        close(1);
+        int fd = creat(buffer, 0777);
+        if (fd != 1) {
+            fprintf(stderr, "didn't open custom error file %s as 1, got %d\n", buffer, fd);
+            exit(1);
+        }
+        close(2);
+        dup(1);
+        int result = execv(copy[0], copy);
+        exit(10);
+    }
+    if (child < 0) {
+        printf("fork failed\n");
+        exit(1);
+    }
+    int status = 0;
+    pid_t deadchild = wait(&status);
+    if (deadchild != child) {
+        printf("wait got %d instead of %d\n", deadchild, child);
+        exit(1);
+    }
+    if (WEXITSTATUS(status) == 0) {
+        printf("compiler exited normally, not good under these circumstances\n");
+        exit(1);
+    }
+    //printf("exit status of child %d was %d\n", child, WEXITSTATUS(status));
+    sprintf(buffer, "/tmp/errorfile_%d", child);
+    if (errorfile) {
+        //printf("ignoring error file: %s\n", errorfile);
+        char desired[512];
+        char got[512];
+        bool gotErrorFile = readfile(desired, errorfile);
+        bool gotOutput = readfile(got, buffer);
+        if (!gotErrorFile && gotOutput) {
+            printf("didn't read errorfile %s, it should have something from\n*****\n%s\n*****\nin it.\n",
+                errorfile, got);
+            exit(1);
+        }
+        else if (gotErrorFile && gotOutput) {
+            char *where = strstr(got, desired);
+            if (!where) {
+                printf("didn't find contents of %s in %s\n", errorfile, buffer);
+                exit(1);
+            }
+        }
+        else {
+            printf("errorfile %s and output %s inconsistent\n", errorfile, buffer);
+            exit(1);
+        }
+    }
+    unlink(buffer);
+    printf("success\n");
+    exit(0);
+}
+        
diff --git a/compiler-rt/test/BlocksRuntime/flagsisa.c b/compiler-rt/test/BlocksRuntime/flagsisa.c
new file mode 100644
index 0000000..5d4b2dc
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/flagsisa.c
@@ -0,0 +1,21 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include <stdio.h>
+
+/* CONFIG rdar://6310599
+ */
+
+int main(int argc, char *argv[])
+{
+ 	__block int flags;
+ 	__block void *isa;
+ 	
+ 	^{ flags=1; isa = (void *)isa; };
+        printf("%s: success\n", argv[0]);
+ 	return 0;
+}
+
diff --git a/compiler-rt/test/BlocksRuntime/globalexpression.c b/compiler-rt/test/BlocksRuntime/globalexpression.c
new file mode 100644
index 0000000..eeedd75
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/globalexpression.c
@@ -0,0 +1,42 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// testfilerunner CONFIG
+
+#import <stdio.h>
+#import <Block.h>
+
+int global;
+
+void (^gblock)(int) = ^(int x){ global = x; };
+
+int main(int argc, char *argv[]) {
+    gblock(1);
+    if (global != 1) {
+        printf("%s: *** did not set global to 1\n", argv[0]);
+        return 1;
+    }
+    void (^gblockcopy)(int) = Block_copy(gblock);
+    if (gblockcopy != gblock) {
+        printf("global copy %p not a no-op %p\n", (void *)gblockcopy, (void *)gblock);
+        return 1;
+    }
+    Block_release(gblockcopy);
+    gblock(3);
+    if (global != 3) {
+        printf("%s: *** did not set global to 3\n", argv[0]);
+        return 1;
+    }
+    gblockcopy = Block_copy(gblock);
+    gblockcopy(5);
+    if (global != 5) {
+        printf("%s: *** did not set global to 5\n", argv[0]);
+        return 1;
+    }
+    printf("%s: Success!\n", argv[0]);
+    return 0;
+}
+
diff --git a/compiler-rt/test/BlocksRuntime/goto.c b/compiler-rt/test/BlocksRuntime/goto.c
new file mode 100644
index 0000000..7e5b08a
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/goto.c
@@ -0,0 +1,34 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  goto.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 10/17/08.
+ *
+ */
+ 
+// CONFIG rdar://6289031
+
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+	__block int val = 0;
+
+	^{ val = 1; }();
+
+	if (val == 0) {
+		goto out_bad; // error: local byref variable val is in the scope of this goto
+	}
+
+        printf("%s: Success!\n", argv[0]);
+	return 0;
+out_bad:
+        printf("%s: val not updated!\n", argv[0]);
+	return 1;
+}
diff --git a/compiler-rt/test/BlocksRuntime/hasdescriptor.c b/compiler-rt/test/BlocksRuntime/hasdescriptor.c
new file mode 100644
index 0000000..429adb9
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/hasdescriptor.c
@@ -0,0 +1,29 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+
+
+// CONFIG C
+
+#include <stdio.h>
+#include <Block_private.h>
+
+
+int main(int argc, char *argv[]) {
+    void (^inner)(void) = ^ { printf("argc was %d\n", argc); };
+    void (^outer)(void) = ^{
+          inner();
+          inner();
+     };
+     //printf("size of inner is %ld\n", Block_size(inner));
+     //printf("size of outer is %ld\n", Block_size(outer));
+     if (Block_size(inner) != Block_size(outer)) {
+        printf("not the same size, using old compiler??\n");
+        return 1;
+    }
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/josh.C b/compiler-rt/test/BlocksRuntime/josh.C
new file mode 100644
index 0000000..dbc7369
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/josh.C
@@ -0,0 +1,32 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG C++ GC RR open rdar://6347910
+
+
+
+struct MyStruct {
+    int something;
+};
+
+struct TestObject {
+
+        void test(void){
+            {
+                MyStruct first;   // works
+            }
+            void (^b)(void) = ^{ 
+                MyStruct inner;  // fails to compile!
+            };
+        }
+};
+
+    
+
+int main(int argc, char *argv[]) {
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/k-and-r.c b/compiler-rt/test/BlocksRuntime/k-and-r.c
new file mode 100644
index 0000000..16b9cc6
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/k-and-r.c
@@ -0,0 +1,33 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//  -*- mode:C; c-basic-offset:4; tab-width:4; intent-tabs-mode:nil;  -*-
+// CONFIG error: incompatible block pointer types assigning
+
+#import <stdio.h>
+#import <stdlib.h>
+
+int main(int argc, char *argv[]) {
+#ifndef __cplusplus
+    char (^rot13)();
+    rot13 = ^(char c) { return (char)(((c - 'a' + 13) % 26) + 'a'); };
+    char n = rot13('a');
+    char c = rot13('p');
+    if ( n != 'n' || c != 'c' ) {
+        printf("%s: rot13('a') returned %c, rot13('p') returns %c\n", argv[0], n, c);
+        exit(1);
+    }
+#else
+// yield characteristic error message for C++
+#error incompatible block pointer types assigning
+#endif
+#ifndef __clang__
+// yield characteristic error message for C++
+#error incompatible block pointer types assigning
+#endif
+    printf("%s: success\n", argv[0]);
+    exit(0);
+}
diff --git a/compiler-rt/test/BlocksRuntime/large-struct.c b/compiler-rt/test/BlocksRuntime/large-struct.c
new file mode 100644
index 0000000..1867bd0
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/large-struct.c
@@ -0,0 +1,51 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//  -*- mode:C; c-basic-offset:4; tab-width:4; intent-tabs-mode:nil;  -*-
+// CONFIG
+
+#import <stdio.h>
+#import <stdlib.h>
+#import <string.h>
+
+typedef struct {
+    unsigned long ps[30];
+    int qs[30];
+} BobTheStruct;
+
+int main (int argc, const char * argv[]) {
+    BobTheStruct inny;
+    BobTheStruct outty;
+    BobTheStruct (^copyStruct)(BobTheStruct);
+    int i;
+    
+    memset(&inny, 0xA5, sizeof(inny));
+    memset(&outty, 0x2A, sizeof(outty));    
+    
+    for(i=0; i<30; i++) {
+        inny.ps[i] = i * i * i;
+        inny.qs[i] = -i * i * i;
+    }
+    
+    copyStruct = ^(BobTheStruct aBigStruct){ return aBigStruct; };  // pass-by-value intrinsically copies the argument
+    
+    outty = copyStruct(inny);
+
+    if ( &inny == &outty ) {
+        printf("%s: struct wasn't copied.", argv[0]);
+        exit(1);
+    }
+    for(i=0; i<30; i++) {
+        if ( (inny.ps[i] != outty.ps[i]) || (inny.qs[i] != outty.qs[i]) ) {
+            printf("%s: struct contents did not match.", argv[0]);
+            exit(1);
+        }
+    }
+    
+    printf("%s: success\n", argv[0]);
+    
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/localisglobal.c b/compiler-rt/test/BlocksRuntime/localisglobal.c
new file mode 100644
index 0000000..75a79df
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/localisglobal.c
@@ -0,0 +1,42 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  localisglobal.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 9/29/08.
+ *
+ *  works in all configurations
+ *  CONFIG   rdar://6230297
+ */
+
+#include <stdio.h>
+
+void (^global)(void) = ^{ printf("hello world\n"); };
+
+int aresame(void *first, void *second) {
+    long *f = (long *)first;
+    long *s = (long *)second;
+    return *f == *s;
+}
+int main(int argc, char *argv[]) {
+    int i = 10;
+    void (^local)(void) = ^ { printf("hi %d\n", i); };
+    void (^localisglobal)(void) = ^ { printf("hi\n"); };
+    
+    if (aresame(local, localisglobal)) {
+        printf("local block could be global, but isn't\n");
+        return 1;
+    }
+    if (!aresame(global, localisglobal)) {
+        printf("local block is not global, not stack, what is it??\n");
+        return 1;
+    }
+    printf("%s: success\n", argv[0]);
+    return 0;
+    
+}
diff --git a/compiler-rt/test/BlocksRuntime/macro.c b/compiler-rt/test/BlocksRuntime/macro.c
new file mode 100644
index 0000000..988c068
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/macro.c
@@ -0,0 +1,14 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG open rdar://6718399
+#include <Block.h>
+
+void foo() {
+    void (^bbb)(void)  = Block_copy(^ {
+        int j, cnt;
+    });
+}
diff --git a/compiler-rt/test/BlocksRuntime/makefile b/compiler-rt/test/BlocksRuntime/makefile
new file mode 100644
index 0000000..2734bca
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/makefile
@@ -0,0 +1,70 @@
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+CCDIR=/usr/bin
+#CCDIR=/Volumes/Keep/gcc/usr/bin
+
+all: std
+
+clean:
+	rm -fr *.dSYM *.o *-bin testfilerunner
+
+TFR = ~public/bin/testfilerunner
+
+testfilerunner: testfilerunner.h testfilerunner.m
+	gcc -fobjc-gc-only -g -arch x86_64 -arch i386 -std=gnu99 testfilerunner.m -o testfilerunner -framework Foundation
+
+tests:
+	grep CONFIG *.[cmCM] | $(TFR) $(CCDIR) --
+
+open:
+	grep CONFIG *.[cmCM] | $(TFR) $(CCDIR) -open --
+
+fast:
+	grep CONFIG *.[cmCM] | $(TFR) -fast $(CCDIR) --
+
+std:
+	grep CONFIG *.[cmCM] | $(TFR) --
+
+clang:
+	grep CONFIG *.[cmCM] | $(TFR) -clang -fast --
+
+fastd:
+	grep CONFIG *.[cmCM] | $(TFR) -fast --
+
+
+# Hack Alert: arguably most of the following belongs in libclosure's Makefile; sticking it here until I get around to grokking what goes on in that file.
+sudid:
+	@echo Enabling sudo:  # Hack Alert: enable sudo first thing so we don't hang at the password prompt later
+	@sudo echo Thanks
+
+
+RootsDirectory ?= /tmp/
+# Note: the libsystem project (built by the libsystemroot target below) uses the ALTUSRLOCALLIBSYSTEM variable, so we use it here to maintain parity
+ALTUSRLOCALLIBSYSTEM ?= $(RootsDirectory)/alt-usr-local-lib-system/
+altusrlocallibsystem:
+	ditto /usr/local/lib/system $(ALTUSRLOCALLIBSYSTEM)  # FIXME: conditionalize this copy
+
+
+# <rdar://problem/6456031> ER: option to not require extra privileges (-nosudo or somesuch)
+Buildit ?= ~rc/bin/buildit -rootsDirectory $(RootsDirectory) -arch i386 -arch ppc -arch x86_64
+blocksroot: sudid clean altusrlocallibsystem
+	sudo $(Buildit) ..
+	ditto $(RootsDirectory)/libclosure.roots/libclosure~dst/usr/local/lib/system $(ALTUSRLOCALLIBSYSTEM)
+
+
+LibsystemVersion ?= 121
+LibsystemPath ?= ~rc/Software/SnowLeopard/Projects/Libsystem/Libsystem-$(LibsystemVersion)
+LibsystemTmpPath ?= $(RootsDirectory)/Libsystem-$(LibsystemVersion)
+libsystemroot: blocksroot
+	ditto $(LibsystemPath) $(LibsystemTmpPath)  # FIXME: conditionalize this copy
+	sudo ALTUSRLOCALLIBSYSTEM=$(ALTUSRLOCALLIBSYSTEM) $(Buildit) $(LibsystemTmpPath)
+
+
+# Defaults to product of the libsystemroot target but does not automatically rebuild that, make both targets if you want a fresh root
+LibsystemRootPath ?= $(RootsDirectory)/Libsystem-$(LibsystemVersion).roots/Libsystem-$(LibsystemVersion)~dst/usr/lib/
+roottests: 
+	grep CONFIG *.[cmCM] | $(TFR) -dyld $(LibsystemRootPath) --  # FIXME: figure out if I can "call" the std target instead of duplicating it
+
diff --git a/compiler-rt/test/BlocksRuntime/modglobal.c b/compiler-rt/test/BlocksRuntime/modglobal.c
new file mode 100644
index 0000000..562d5a5
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/modglobal.c
@@ -0,0 +1,18 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+#include <stdio.h>
+
+// CONFIG
+
+int AGlobal;
+
+int main(int argc, char *argv[]) {
+    void (^f)(void) = ^ { AGlobal++; };
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+
+}
diff --git a/compiler-rt/test/BlocksRuntime/nestedimport.c b/compiler-rt/test/BlocksRuntime/nestedimport.c
new file mode 100644
index 0000000..e806692
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/nestedimport.c
@@ -0,0 +1,44 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  nestedimport.m
+//  testObjects
+//
+//  Created by Blaine Garst on 6/24/08.
+//
+// pure C nothing more needed
+// CONFIG 
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+int Global = 0;
+
+void callVoidVoid(void (^closure)(void)) {
+    closure();
+}
+
+int main(int argc, char *argv[]) {
+    int i = 1;
+    
+    void (^vv)(void) = ^{
+        if (argc > 0) {
+            callVoidVoid(^{ Global = i; });
+        }
+    };
+    
+    i = 2;
+    vv();
+    if (Global != 1) {
+        printf("%s: error, Global not set to captured value\n", argv[0]);
+        exit(1);
+    }
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/nullblockisa.c b/compiler-rt/test/BlocksRuntime/nullblockisa.c
new file mode 100644
index 0000000..ba0282e
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/nullblockisa.c
@@ -0,0 +1,43 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  nullblockisa.m
+//  testObjects
+//
+//  Created by Blaine Garst on 9/24/08.
+//
+// CONFIG rdar://6244520
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <Block_private.h>
+
+
+void check(void (^b)(void)) {
+    struct _custom {
+        struct Block_layout layout;
+        struct Block_byref *innerp;
+    } *custom  = (struct _custom *)(void *)(b);
+    //printf("block is at %p, size is %lx, inner is %p\n", (void *)b, Block_size(b), innerp);
+    if (custom->innerp->isa != (void *)NULL) {
+        printf("not a NULL __block isa\n");
+        exit(1);
+    }
+    return;
+}
+        
+int main(int argc, char *argv[]) {
+
+   __block int i;
+   
+   check(^{ printf("%d\n", ++i); });
+   printf("%s: success\n", argv[0]);
+   return 0;
+}
+   
diff --git a/compiler-rt/test/BlocksRuntime/objectRRGC.c b/compiler-rt/test/BlocksRuntime/objectRRGC.c
new file mode 100644
index 0000000..2cefea2
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/objectRRGC.c
@@ -0,0 +1,77 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  objectRRGC.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 10/31/08.
+ *
+ * Test that the runtime honors the new callouts properly for retain/release and GC
+ * CON FIG C  rdar://6175959
+ */
+
+
+
+#include <stdio.h>
+#include <Block_private.h>
+
+
+int AssignCalled = 0;
+int DisposeCalled = 0;
+
+// local copy instead of libSystem.B.dylib copy
+void _Block_object_assign(void *destAddr, const void *object, const int isWeak) {
+    //printf("_Block_object_assign(%p, %p, %d) called\n", destAddr, object, isWeak);
+    AssignCalled = 1;
+}
+
+void _Block_object_dispose(const void *object, const int isWeak) {
+    //printf("_Block_object_dispose(%p, %d) called\n", object, isWeak);
+    DisposeCalled = 1;
+}
+
+struct MyStruct {
+    long isa;
+    long field;
+};
+
+typedef struct MyStruct *__attribute__((NSObject)) MyStruct_t;
+
+int main(int argc, char *argv[]) {
+    // create a block
+    struct MyStruct X;
+    MyStruct_t xp = (MyStruct_t)&X;
+    xp->field = 10;
+    void (^myBlock)(void) = ^{ printf("field is %ld\n", xp->field); };
+    // should be a copy helper generated with a calls to above routines
+    // Lets find out!
+    struct Block_layout *bl = (struct Block_layout *)(void *)myBlock;
+    if ((bl->flags & BLOCK_HAS_DESCRIPTOR) != BLOCK_HAS_DESCRIPTOR) {
+        printf("using old runtime layout!\n");
+        return 1;
+    }
+    if ((bl->flags & BLOCK_HAS_COPY_DISPOSE) != BLOCK_HAS_COPY_DISPOSE) {
+        printf("no copy dispose!!!!\n");
+        return 1;
+    }
+    // call helper routines directly.  These will, in turn, we hope, call the stubs above
+    long destBuffer[256];
+    //printf("destbuffer is at %p, block at %p\n", destBuffer, (void *)bl);
+    //printf("dump is %s\n", _Block_dump(myBlock));
+    bl->descriptor->copy(destBuffer, bl);
+    bl->descriptor->dispose(bl);
+    if (AssignCalled == 0) {
+        printf("did not call assign helper!\n");
+        return 1;
+    }
+    if (DisposeCalled == 0) {
+        printf("did not call dispose helper\n");
+        return 1;
+    }
+    printf("%s: Success!\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/objectassign.c b/compiler-rt/test/BlocksRuntime/objectassign.c
new file mode 100644
index 0000000..1c4f484
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/objectassign.c
@@ -0,0 +1,76 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  objectassign.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 10/28/08.
+ *
+ * This just tests that the compiler is issuing the proper helper routines
+ * CONFIG C rdar://6175959
+ */
+
+
+#include <stdio.h>
+#include <Block_private.h>
+
+
+int AssignCalled = 0;
+int DisposeCalled = 0;
+
+// local copy instead of libSystem.B.dylib copy
+void _Block_object_assign(void *destAddr, const void *object, const int isWeak) {
+    //printf("_Block_object_assign(%p, %p, %d) called\n", destAddr, object, isWeak);
+    AssignCalled = 1;
+}
+
+void _Block_object_dispose(const void *object, const int isWeak) {
+    //printf("_Block_object_dispose(%p, %d) called\n", object, isWeak);
+    DisposeCalled = 1;
+}
+
+struct MyStruct {
+    long isa;
+    long field;
+};
+
+typedef struct MyStruct *__attribute__((NSObject)) MyStruct_t;
+
+int main(int argc, char *argv[]) {
+    if (__APPLE_CC__ < 5627) {
+        printf("need compiler version %d, have %d\n", 5627, __APPLE_CC__);
+        return 0;
+    }
+    // create a block
+    struct MyStruct X;
+    MyStruct_t xp = (MyStruct_t)&X;
+    xp->field = 10;
+    void (^myBlock)(void) = ^{ printf("field is %ld\n", xp->field); };
+    // should be a copy helper generated with a calls to above routines
+    // Lets find out!
+    struct Block_layout *bl = (struct Block_layout *)(void *)myBlock;
+    if ((bl->flags & BLOCK_HAS_COPY_DISPOSE) != BLOCK_HAS_COPY_DISPOSE) {
+        printf("no copy dispose!!!!\n");
+        return 1;
+    }
+    // call helper routines directly.  These will, in turn, we hope, call the stubs above
+    long destBuffer[256];
+    //printf("destbuffer is at %p, block at %p\n", destBuffer, (void *)bl);
+    //printf("dump is %s\n", _Block_dump(myBlock));
+    bl->descriptor->copy(destBuffer, bl);
+    bl->descriptor->dispose(bl);
+    if (AssignCalled == 0) {
+        printf("did not call assign helper!\n");
+        return 1;
+    }
+    if (DisposeCalled == 0) {
+        printf("did not call dispose helper\n");
+        return 1;
+    }
+    printf("%s: Success!\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/orbars.c b/compiler-rt/test/BlocksRuntime/orbars.c
new file mode 100644
index 0000000..18a9244
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/orbars.c
@@ -0,0 +1,23 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  orbars.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 9/17/08.
+ *
+ *  CONFIG rdar://6276695 error: before ‘|’ token
+ */
+
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+    int i = 10;
+    void (^b)(void) = ^(void){ | i | printf("hello world, %d\n", ++i); };
+    printf("%s: success :-(\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/rdar6396238.c b/compiler-rt/test/BlocksRuntime/rdar6396238.c
new file mode 100644
index 0000000..2804156
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/rdar6396238.c
@@ -0,0 +1,32 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG rdar://6396238
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static int count = 0;
+
+void (^mkblock(void))(void)
+{
+    count++;
+    return ^{
+        count++;
+    };
+}
+
+int main (int argc, const char * argv[]) {
+    mkblock()();
+    if (count != 2) {
+        printf("%s: failure, 2 != %d\n", argv[0], count);
+        exit(1);
+    } else {
+        printf("%s: success\n", argv[0]);
+        exit(0);
+    }
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/rdar6405500.c b/compiler-rt/test/BlocksRuntime/rdar6405500.c
new file mode 100644
index 0000000..1ab4624
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/rdar6405500.c
@@ -0,0 +1,29 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG rdar://6405500
+
+#include <stdio.h>
+#include <stdlib.h>
+#import <dispatch/dispatch.h>
+#import <objc/objc-auto.h>
+
+int main (int argc, const char * argv[]) {
+    __block void (^blockFu)(size_t t);
+    blockFu = ^(size_t t){
+        if (t == 20) {
+            printf("%s: success\n", argv[0]);
+            exit(0);
+        } else
+            dispatch_async(dispatch_get_main_queue(), ^{ blockFu(20); });
+    };
+    
+    dispatch_apply(10, dispatch_get_concurrent_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT), blockFu);
+
+    dispatch_main();
+    printf("shouldn't get here\n");
+    return 1;
+}
diff --git a/compiler-rt/test/BlocksRuntime/rdar6414583.c b/compiler-rt/test/BlocksRuntime/rdar6414583.c
new file mode 100644
index 0000000..2ada04d
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/rdar6414583.c
@@ -0,0 +1,31 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG rdar://6414583
+
+// a smaller case of byrefcopyint
+
+#include <Block.h>
+#include <dispatch/dispatch.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+    __block int c = 1;
+
+    //printf("&c = %p - c = %i\n", &c, c);
+
+    int i;
+    for(i =0; i < 2; i++) {
+        dispatch_block_t block = Block_copy(^{ c = i; });
+
+        block();
+//        printf("%i: &c = %p - c = %i\n", i, &c, c);
+
+        Block_release(block);
+    }
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/recursive-block.c b/compiler-rt/test/BlocksRuntime/recursive-block.c
new file mode 100644
index 0000000..454ad48
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/recursive-block.c
@@ -0,0 +1,55 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include <stdio.h>
+#include <Block.h>
+#include <Block_private.h>
+#include <stdlib.h>
+
+// CONFIG
+
+
+int cumulation = 0;
+
+int doSomething(int i) {
+    cumulation += i;
+    return cumulation;
+}
+
+void dirtyStack() {
+    int i = random();
+    int j = doSomething(i);
+    int k = doSomething(j);
+    doSomething(i + j + k);
+}
+
+typedef void (^voidVoid)(void);
+
+voidVoid testFunction() {
+    int i = random();
+    __block voidVoid inner = ^{ doSomething(i); };
+    //printf("inner, on stack, is %p\n", (void*)inner);
+    /*__block*/ voidVoid outer = ^{
+        //printf("will call inner block %p\n", (void *)inner);
+        inner();
+    };
+    //printf("outer looks like: %s\n", _Block_dump(outer));
+    voidVoid result = Block_copy(outer);
+    //Block_release(inner);
+    return result;
+}
+
+
+int main(int argc, char **argv) {
+    voidVoid block = testFunction();
+    dirtyStack();
+    block();
+    Block_release(block);
+
+    printf("%s: success\n", argv[0]);
+
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/recursive-test.c b/compiler-rt/test/BlocksRuntime/recursive-test.c
new file mode 100644
index 0000000..f799148
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/recursive-test.c
@@ -0,0 +1,74 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// CONFIG open rdar://6416474
+// was  rdar://5847976
+// was  rdar://6348320 
+
+#include <stdio.h>
+#include <Block.h>
+
+int verbose = 0;
+
+int main(int argc, char* argv[]) {
+	
+        if (argc > 1) verbose = 1;
+        
+	__block void (^recursive_local_block)(int);
+		
+	if (verbose) printf("recursive_local_block is a local recursive block\n");
+	recursive_local_block = ^(int i) {
+		if (verbose) printf("%d\n", i);
+		if (i > 0) {
+			recursive_local_block(i - 1);
+		}
+    };
+
+	if (verbose) printf("recursive_local_block's address is %p, running it:\n", (void*)recursive_local_block);
+	recursive_local_block(5);
+
+	if (verbose) printf("Creating other_local_block: a local block that calls recursive_local_block\n");
+
+	void (^other_local_block)(int) = ^(int i) {
+		if (verbose) printf("other_local_block running\n");
+		recursive_local_block(i);
+    };
+
+	if (verbose) printf("other_local_block's address is %p, running it:\n", (void*)other_local_block);
+		
+	other_local_block(5);
+	
+#if __APPLE_CC__ >= 5627
+	if (verbose) printf("Creating other_copied_block: a Block_copy of a block that will call recursive_local_block\n");
+
+	void (^other_copied_block)(int) = Block_copy(^(int i) {
+		if (verbose) printf("other_copied_block running\n");
+		recursive_local_block(i);
+    });
+		
+	if (verbose) printf("other_copied_block's address is %p, running it:\n", (void*)other_copied_block);
+	
+	other_copied_block(5);
+#endif
+
+	__block void (^recursive_copy_block)(int);
+
+	if (verbose) printf("Creating recursive_copy_block: a Block_copy of a block that will call recursive_copy_block recursively\n");
+
+	recursive_copy_block = Block_copy(^(int i) {
+		if (verbose) printf("%d\n", i);
+		if (i > 0) {
+			recursive_copy_block(i - 1);
+		}
+    });
+		
+	if (verbose) printf("recursive_copy_block's address is %p, running it:\n", (void*)recursive_copy_block);
+
+	recursive_copy_block(5);
+        
+        printf("%s: Success\n", argv[0]);
+	return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/recursiveassign.c b/compiler-rt/test/BlocksRuntime/recursiveassign.c
new file mode 100644
index 0000000..f0070cb
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/recursiveassign.c
@@ -0,0 +1,44 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  recursiveassign.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 12/3/08.
+ *
+ */
+
+// CONFIG  rdar://6639533
+
+// The compiler is prefetching x->forwarding before evaluting code that recomputes forwarding and so the value goes to a place that is never seen again.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <Block.h>
+
+
+int main(int argc, char* argv[]) {
+    
+    __block void (^recursive_copy_block)(int) = ^(int arg) { printf("got wrong Block\n"); exit(1); };
+    
+    
+    recursive_copy_block = Block_copy(^(int i) {
+        if (i > 0) {
+            recursive_copy_block(i - 1);
+        }
+        else {
+            printf("done!\n");
+        }
+    });
+    
+    
+    recursive_copy_block(5);
+    
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
+
diff --git a/compiler-rt/test/BlocksRuntime/reference.C b/compiler-rt/test/BlocksRuntime/reference.C
new file mode 100644
index 0000000..f86f11e
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/reference.C
@@ -0,0 +1,95 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#import <Block.h>
+#import <stdio.h>
+#import <stdlib.h>
+
+// CONFIG C++
+
+int recovered = 0;
+
+
+
+int constructors = 0;
+int destructors = 0;
+
+#define CONST const
+
+class TestObject
+{
+public:
+	TestObject(CONST TestObject& inObj);
+	TestObject();
+	~TestObject();
+	
+	TestObject& operator=(CONST TestObject& inObj);
+        
+        void test(void);
+
+	int version() CONST { return _version; }
+private:
+	mutable int _version;
+};
+
+TestObject::TestObject(CONST TestObject& inObj)
+	
+{
+        ++constructors;
+        _version = inObj._version;
+	//printf("%p (%d) -- TestObject(const TestObject&) called", this, _version); 
+}
+
+
+TestObject::TestObject()
+{
+        _version = ++constructors;
+	//printf("%p (%d) -- TestObject() called\n", this, _version); 
+}
+
+
+TestObject::~TestObject()
+{
+	//printf("%p -- ~TestObject() called\n", this);
+        ++destructors;
+}
+
+#if 1
+TestObject& TestObject::operator=(CONST TestObject& inObj)
+{
+	//printf("%p -- operator= called", this);
+        _version = inObj._version;
+	return *this;
+}
+#endif
+
+void TestObject::test(void)  {
+    void (^b)(void) = ^{ recovered = _version; };
+    void (^b2)(void) = Block_copy(b);
+    b2();
+    Block_release(b2);
+}
+
+
+
+void testRoutine() {
+    TestObject one;
+
+    
+    one.test();
+}
+    
+    
+
+int main(int argc, char *argv[]) {
+    testRoutine();
+    if (recovered == 1) {
+        printf("%s: success\n", argv[0]);
+        exit(0);
+    }
+    printf("%s: *** didn't recover byref block variable\n", argv[0]);
+    exit(1);
+}
diff --git a/compiler-rt/test/BlocksRuntime/rettypepromotion.c b/compiler-rt/test/BlocksRuntime/rettypepromotion.c
new file mode 100644
index 0000000..597eafe
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/rettypepromotion.c
@@ -0,0 +1,36 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  rettypepromotion.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 11/3/08.
+ *
+ */
+ 
+// CONFIG error:
+// C++ and C give different errors so we don't check for an exact match.
+// The error is that enum's are defined to be ints, always, even if defined with explicit long values
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+enum { LESS = -1, EQUAL, GREATER };
+
+void sortWithBlock(long (^comp)(void *arg1, void *arg2)) {
+}
+
+int main(int argc, char *argv[]) {
+    sortWithBlock(^(void *arg1, void *arg2) {
+        if (random()) return LESS;
+        if (random()) return EQUAL;
+        if (random()) return GREATER;
+    });
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/returnfunctionptr.c b/compiler-rt/test/BlocksRuntime/returnfunctionptr.c
new file mode 100644
index 0000000..6c7df63
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/returnfunctionptr.c
@@ -0,0 +1,23 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+
+// CONFIG  rdar://6339747 but wasn't
+
+#include <stdio.h>
+
+int (*funcptr)(long);
+
+int (*(^b)(char))(long);
+
+int main(int argc, char *argv[])  {
+	// implicit is fine
+	b = ^(char x) { return funcptr; };
+	// explicit never parses
+	b = ^int (*(char x))(long) { return funcptr; };
+        printf("%s: Success\n", argv[0]);
+        return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/shorthandexpression.c b/compiler-rt/test/BlocksRuntime/shorthandexpression.c
new file mode 100644
index 0000000..bf45820
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/shorthandexpression.c
@@ -0,0 +1,24 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  shorthandexpression.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 9/16/08.
+ *
+ *  CONFIG error:
+ */
+
+
+void foo() {
+    void (^b)(void) = ^(void)printf("hello world\n");
+}
+
+int main(int argc, char *argv[]) {
+    printf("%s: this shouldn't compile\n", argv[0]);
+    return 1;
+}
diff --git a/compiler-rt/test/BlocksRuntime/sizeof.c b/compiler-rt/test/BlocksRuntime/sizeof.c
new file mode 100644
index 0000000..1f84fc1
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/sizeof.c
@@ -0,0 +1,26 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  sizeof.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 2/17/09.
+ *
+ */
+
+#include <stdio.h>
+
+// CONFIG error:
+
+int main(int argc, char *argv[]) {
+
+    void (^aBlock)(void) = ^{ printf("hellow world\n"); };
+
+    printf("the size of a block is %ld\n", sizeof(*aBlock));
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/small-struct.c b/compiler-rt/test/BlocksRuntime/small-struct.c
new file mode 100644
index 0000000..434f3c1
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/small-struct.c
@@ -0,0 +1,45 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//  -*- mode:C; c-basic-offset:4; tab-width:4; intent-tabs-mode:nil;  -*-
+// CONFIG
+
+#import <stdio.h>
+#import <stdlib.h>
+#import <string.h>
+
+typedef struct {
+  int a;
+  int b;
+} MiniStruct;
+
+int main (int argc, const char * argv[]) {
+    MiniStruct inny;
+    MiniStruct outty;
+    MiniStruct (^copyStruct)(MiniStruct);
+    
+    memset(&inny, 0xA5, sizeof(inny));
+    memset(&outty, 0x2A, sizeof(outty));    
+    
+    inny.a = 12;
+    inny.b = 42;
+
+    copyStruct = ^(MiniStruct aTinyStruct){ return aTinyStruct; };  // pass-by-value intrinsically copies the argument
+    
+    outty = copyStruct(inny);
+
+    if ( &inny == &outty ) {
+        printf("%s: struct wasn't copied.", argv[0]);
+        exit(1);
+    }
+    if ( (inny.a != outty.a) || (inny.b != outty.b) ) {
+        printf("%s: struct contents did not match.", argv[0]);
+        exit(1);
+    }
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/structmember.c b/compiler-rt/test/BlocksRuntime/structmember.c
new file mode 100644
index 0000000..c451d3f
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/structmember.c
@@ -0,0 +1,45 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  structmember.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 9/30/08.
+ *  CONFIG
+ */
+#include <Block.h>
+#include <Block_private.h>
+#include <stdio.h>
+
+// CONFIG
+
+int main(int argc, char *argv[]) {
+    struct stuff {
+        long int a;
+        long int b;
+        long int c;
+    } localStuff = { 10, 20, 30 };
+    int d;
+    
+    void (^a)(void) = ^ { printf("d is %d", d); };
+    void (^b)(void) = ^ { printf("d is %d, localStuff.a is %lu", d, localStuff.a); };
+
+    unsigned nominalsize = Block_size(b) - Block_size(a);
+#if __cplusplus__
+    // need copy+dispose helper for C++ structures
+    nominalsize += 2*sizeof(void*);
+#endif
+    if ((Block_size(b) - Block_size(a)) != nominalsize) {
+        printf("sizeof a is %ld, sizeof b is %ld, expected %d\n", Block_size(a), Block_size(b), nominalsize);
+        printf("dump of b is %s\n", _Block_dump(b));
+        return 1;
+    }
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
+
+
diff --git a/compiler-rt/test/BlocksRuntime/testfilerunner.h b/compiler-rt/test/BlocksRuntime/testfilerunner.h
new file mode 100644
index 0000000..d4e54f0
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/testfilerunner.h
@@ -0,0 +1,110 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  testfilerunner.h
+//  testObjects
+//
+//  Created by Blaine Garst on 9/24/08.
+//
+
+#import <Cocoa/Cocoa.h>
+
+/*
+    variations:
+        four source types:  C, ObjC, C++, ObjC++,
+          and for ObjC or ObjC++ we have
+             RR and GC capabilities
+        we assume C++ friendly includes for C/ObjC even if C++ isn't used
+             
+             
+        four compilers: C, ObjC, C++, ObjC++
+          and for ObjC or ObjC++ we can compile
+              RR, RR+GC, GC+RR, GC
+          although to test RR+GC we need to build a shell "main" in both modes
+          and/or run with GC disabled if possible.
+              
+    To maximize coverage we mark files with capabilities and then ask them to be
+    compiled with each variation of compiler and option.
+    If the file doesn't have the capability it politely refuses.
+*/
+
+enum options {
+    Do64   = (1 << 0),
+    DoCPP  = (1 << 1),
+    DoOBJC = (1 << 3),
+    DoGC   = (1 << 4),
+    DoRR   = (1 << 5),
+    DoRRGC = (1 << 6),  // -fobjc-gc but main w/o so it runs in RR mode
+    DoGCRR = (1 << 7),  // -fobjc-gc & run GC mode
+
+    //DoDashG = (1 << 8),
+    DoDashO = (1 << 9),
+    DoDashOs = (1 << 10),
+    DoDashO2 = (1 << 11),
+    
+    DoC99 = (1 << 12), // -std=c99
+};
+
+
+@class TestFileExeGenerator;
+
+// this class will actually compile and/or run a target binary
+// XXX we don't track which dynamic libraries requested/used nor set them up
+@interface TestFileExe : NSObject {
+    NSPointerArray *compileLine;
+    int options;
+    bool shouldFail;
+    TestFileExeGenerator *generator;
+    __strong char *binaryName;
+    __strong char *sourceName;
+    __strong char *libraryPath;
+    __strong char *frameworkPath;
+}
+@property int options;
+@property(assign) NSPointerArray *compileLine;
+@property(assign) TestFileExeGenerator *generator;
+@property bool shouldFail;
+@property __strong char *binaryName;
+@property __strong char *sourceName;
+@property __strong char *libraryPath;
+@property __strong char *frameworkPath;
+- (bool) compileUnlessExists:(bool)skip;
+- (bool) run;
+@property(readonly) __strong char *radar;
+@end
+
+// this class generates an appropriate set of configurations to compile
+// we don't track which gcc we use but we should XXX
+@interface TestFileExeGenerator : NSObject {
+    bool hasObjC;
+    bool hasRR;
+    bool hasGC;
+    bool hasCPlusPlus;
+    bool wantsC99;
+    bool wants64;
+    bool wants32;
+    bool supposedToNotCompile;
+    bool open;              // this problem is still open - e.g. unresolved
+    __strong char *radar; // for things already known to go wrong
+    __strong char *filename;
+    __strong char *compilerPath;
+    __strong char *errorString;
+    __strong char *warningString;
+    NSPointerArray *extraLibraries;
+}
+@property bool hasObjC, hasRR, hasGC, hasCPlusPlus, wantsC99, supposedToNotCompile, open, wants32, wants64;
+@property(assign) __strong char *radar;
+@property __strong char *filename;
+@property __strong char *compilerPath;
+@property __strong char *errorString;
+@property __strong char *warningString;
+- (TestFileExe *)lineForOptions:(int)options; // nil if no can do
++ (NSArray *)generatorsFromFILE:(FILE *)fd;
++ (NSArray *)generatorsFromPath:(NSString *)path;
+@end
+
+
diff --git a/compiler-rt/test/BlocksRuntime/testfilerunner.m b/compiler-rt/test/BlocksRuntime/testfilerunner.m
new file mode 100644
index 0000000..459adf8
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/testfilerunner.m
@@ -0,0 +1,805 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//
+//  testfilerunner.m
+//  testObjects
+//
+//  Created by Blaine Garst on 9/24/08.
+//
+
+#import "testfilerunner.h"
+#import <Foundation/Foundation.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+bool Everything = false; // do it also with 3 levels of optimization
+bool DoClang = false;
+
+static bool isDirectory(char *path);
+static bool isExecutable(char *path);
+static bool isYounger(char *source, char *binary);
+static bool readErrorFile(char *buffer, const char *from);
+
+__strong char *gcstrcpy2(__strong const char *arg, char *endp) {
+    unsigned size = endp - arg + 1;
+    __strong char *result = NSAllocateCollectable(size, 0);
+    strncpy(result, arg, size);
+    result[size-1] = 0;
+    return result;
+}
+__strong char *gcstrcpy1(__strong char *arg) {
+    unsigned size = strlen(arg) + 1;
+    __strong char *result = NSAllocateCollectable(size, 0);
+    strncpy(result, arg, size);
+    result[size-1] = 0;
+    return result;
+}
+
+@implementation TestFileExe
+
+@synthesize options, compileLine, shouldFail, binaryName, sourceName;
+@synthesize generator;
+@synthesize libraryPath, frameworkPath;
+
+- (NSString *)description {
+    NSMutableString *result = [NSMutableString new];
+    if (shouldFail) [result appendString:@"fail"];
+    for (id x  in compileLine) {
+        [result appendString:[NSString stringWithFormat:@" %s", (char *)x]];
+    }
+    return result;
+}
+
+- (__strong char *)radar {
+    return generator.radar;
+}
+  
+- (bool) compileUnlessExists:(bool)skip {
+    if (shouldFail) {
+        printf("don't use this to compile anymore!\n");
+        return false;
+    }
+    if (skip && isExecutable(binaryName) && !isYounger(sourceName, binaryName)) return true;
+    int argc = [compileLine count];
+    char *argv[argc+1];
+    for (int i = 0; i < argc; ++i)
+        argv[i] = (char *)[compileLine pointerAtIndex:i];
+    argv[argc] = NULL;
+    pid_t child = fork();
+    if (child == 0) {
+        execv(argv[0], argv);
+        exit(10); // shouldn't happen
+    }
+    if (child < 0) {
+        printf("fork failed\n");
+        return false;
+    }
+    int status = 0;
+    pid_t deadchild = wait(&status);
+    if (deadchild != child) {
+        printf("wait got %d instead of %d\n", deadchild, child);
+        exit(1);
+    }
+    if (WEXITSTATUS(status) == 0) {
+        return true;
+    }
+    printf("run failed\n");
+    return false;
+}
+
+bool lookforIn(char *lookfor, const char *format, pid_t child) {
+    char buffer[512];
+    char got[512];
+    sprintf(buffer, format, child);    
+    bool gotOutput = readErrorFile(got, buffer);
+    if (!gotOutput) {
+        printf("**** didn't get an output file %s to analyze!!??\n", buffer);
+        return false;
+    }
+    char *where = strstr(got, lookfor);
+    if (!where) {
+        printf("didn't find '%s' in output file %s\n", lookfor, buffer);
+        return false;
+    }
+    unlink(buffer);
+    return true;
+}
+
+- (bool) compileWithExpectedFailure {
+    if (!shouldFail) {
+        printf("Why am I being called?\n");
+        return false;
+    }
+    int argc = [compileLine count];
+    char *argv[argc+1];
+    for (int i = 0; i < argc; ++i)
+        argv[i] = (char *)[compileLine pointerAtIndex:i];
+    argv[argc] = NULL;
+    pid_t child = fork();
+    char buffer[512];
+    if (child == 0) {
+        // in child
+        sprintf(buffer, "/tmp/errorfile_%d", getpid());
+        close(1);
+        int fd = creat(buffer, 0777);
+        if (fd != 1) {
+            fprintf(stderr, "didn't open custom error file %s as 1, got %d\n", buffer, fd);
+            exit(1);
+        }
+        close(2);
+        dup(1);
+        int result = execv(argv[0], argv);
+        exit(10);
+    }
+    if (child < 0) {
+        printf("fork failed\n");
+        return false;
+    }
+    int status = 0;
+    pid_t deadchild = wait(&status);
+    if (deadchild != child) {
+        printf("wait got %d instead of %d\n", deadchild, child);
+        exit(11);
+    }
+    if (WIFEXITED(status)) {
+        if (WEXITSTATUS(status) == 0) {
+            return false;
+        }
+    }
+    else {
+        printf("***** compiler borked/ICEd/died unexpectedly (status %x)\n", status);
+        return false;
+    }
+    char *error = generator.errorString;
+    
+    if (!error) return true;
+#if 0
+    char got[512];
+    sprintf(buffer, "/tmp/errorfile_%d", child);    
+    bool gotOutput = readErrorFile(got, buffer);
+    if (!gotOutput) {
+        printf("**** didn't get an error file %s to analyze!!??\n", buffer);
+        return false;
+    }
+    char *where = strstr(got, error);
+    if (!where) {
+        printf("didn't find '%s' in error file %s\n", error, buffer);
+        return false;
+    }
+    unlink(buffer);
+#else
+    if (!lookforIn(error, "/tmp/errorfile_%d", child)) return false;
+#endif
+    return true;
+}
+
+- (bool) run {
+    if (shouldFail) return true;
+    if (sizeof(long) == 4 && options & Do64) {
+        return true;    // skip 64-bit tests
+    }
+    int argc = 1;
+    char *argv[argc+1];
+    argv[0] = binaryName;
+    argv[argc] = NULL;
+    pid_t child = fork();
+    if (child == 0) {
+        // set up environment
+        char lpath[1024];
+        char fpath[1024];
+        char *myenv[3];
+        int counter = 0;
+        if (libraryPath) {
+            sprintf(lpath, "DYLD_LIBRARY_PATH=%s", libraryPath);
+            myenv[counter++] = lpath;
+        }
+        if (frameworkPath) {
+            sprintf(fpath, "DYLD_FRAMEWORK_PATH=%s", frameworkPath);
+            myenv[counter++] = fpath;
+        }
+        myenv[counter] = NULL;
+        if (generator.warningString) {
+            // set up stdout/stderr
+            char outfile[1024];
+            sprintf(outfile, "/tmp/stdout_%d", getpid());
+            close(2);
+            close(1);
+            creat(outfile, 0700);
+            dup(1);
+        }
+        execve(argv[0], argv, myenv);
+        exit(10); // shouldn't happen
+    }
+    if (child < 0) {
+        printf("fork failed\n");
+        return false;
+    }
+    int status = 0;
+    pid_t deadchild = wait(&status);
+    if (deadchild != child) {
+        printf("wait got %d instead of %d\n", deadchild, child);
+        exit(1);
+    }
+    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
+        if (generator.warningString) {
+            if (!lookforIn(generator.warningString, "/tmp/stdout_%d", child)) return false;
+        }
+        return true;
+    }
+    printf("**** run failed for %s\n", binaryName);
+    return false;
+}
+
+@end
+
+@implementation TestFileExeGenerator
+@synthesize filename, compilerPath, errorString;
+@synthesize hasObjC, hasRR, hasGC, hasCPlusPlus, wantsC99, supposedToNotCompile, open, wants32, wants64;
+@synthesize radar;
+@synthesize warningString;
+
+- (void)setFilename:(__strong char *)name {
+    filename = gcstrcpy1(name);
+}
+- (void)setCompilerPath:(__strong char *)name {
+    compilerPath = gcstrcpy1(name);
+}
+
+- (void)forMostThings:(NSMutableArray *)lines options:(int)options {
+    TestFileExe *item = nil;
+    item = [self lineForOptions:options];
+    if (item) [lines addObject:item];
+    item = [self lineForOptions:options|Do64];
+    if (item) [lines addObject:item];
+    item = [self lineForOptions:options|DoCPP];
+    if (item) [lines addObject:item];
+    item = [self lineForOptions:options|Do64|DoCPP];
+    if (item) [lines addObject:item];
+}
+
+/*
+    DoDashG = (1 << 8),
+    DoDashO = (1 << 9),
+    DoDashOs = (1 << 10),
+    DoDashO2 = (1 << 11),
+*/
+
+- (void)forAllThings:(NSMutableArray *)lines options:(int)options {
+    [self forMostThings:lines options:options];
+    if (!Everything) {
+        return;
+    }
+    // now do it with three explicit optimization flags
+    [self forMostThings:lines options:options | DoDashO];
+    [self forMostThings:lines options:options | DoDashOs];
+    [self forMostThings:lines options:options | DoDashO2];
+}
+
+- (NSArray *)allLines {
+    NSMutableArray *result = [NSMutableArray new];
+    TestFileExe *item = nil;
+    
+    int options = 0;
+    [self forAllThings:result options:0];
+    [self forAllThings:result options:DoOBJC | DoRR];
+    [self forAllThings:result options:DoOBJC | DoGC];
+    [self forAllThings:result options:DoOBJC | DoGCRR];
+    //[self forAllThings:result options:DoOBJC | DoRRGC];
+    
+    return result;
+}
+
+- (void)addLibrary:(const char *)dashLSomething {
+    if (!extraLibraries) {
+        extraLibraries = [NSPointerArray pointerArrayWithOptions:
+            NSPointerFunctionsStrongMemory |
+            NSPointerFunctionsCStringPersonality];
+    }
+    [extraLibraries addPointer:(void *)dashLSomething];
+}
+
+- (TestFileExe *)lineForOptions:(int)options { // nil if no can do
+    if (hasObjC && !(options & DoOBJC)) return nil;
+    if (hasCPlusPlus && !(options & DoCPP)) return nil;
+    if (hasObjC) {
+        if (!hasGC && (options & (DoGC|DoGCRR))) return nil; // not smart enough
+        if (!hasRR && (options & (DoRR|DoRRGC))) return nil;
+    }
+    NSPointerArray *pa = [NSPointerArray pointerArrayWithOptions:
+        NSPointerFunctionsStrongMemory |
+        NSPointerFunctionsCStringPersonality];
+    // construct path
+    char path[512];
+    path[0] = 0;
+    if (!compilerPath) compilerPath = "/usr/bin";
+    if (compilerPath) {
+        strcat(path, compilerPath);
+        strcat(path, "/");
+    }
+    if (options & DoCPP) {
+        strcat(path, DoClang ? "clang++" : "g++-4.2");
+    }
+    else {
+        strcat(path, DoClang ? "clang" : "gcc-4.2");
+    }
+    [pa addPointer:gcstrcpy1(path)];
+    if (options & DoOBJC) {
+        if (options & DoCPP) {
+            [pa addPointer:"-ObjC++"];
+        }
+        else {
+            [pa addPointer:"-ObjC"];
+        }
+    }
+    [pa addPointer:"-g"];
+    if (options & DoDashO) [pa addPointer:"-O"];
+    else if (options & DoDashO2) [pa addPointer:"-O2"];
+    else if (options & DoDashOs) [pa addPointer:"-Os"];
+    if (wantsC99 && (! (options & DoCPP))) {
+        [pa addPointer:"-std=c99"];
+        [pa addPointer:"-fblocks"];
+    }
+    [pa addPointer:"-arch"];
+    [pa addPointer: (options & Do64) ? "x86_64" : "i386"];
+    
+    if (options & DoOBJC) {
+        switch (options & (DoRR|DoGC|DoGCRR|DoRRGC)) {
+        case DoRR:
+            break;
+        case DoGC:
+            [pa addPointer:"-fobjc-gc-only"];
+            break;
+        case DoGCRR:
+            [pa addPointer:"-fobjc-gc"];
+            break;
+        case DoRRGC:
+            printf("DoRRGC unsupported right now\n");
+            [pa addPointer:"-c"];
+            return nil;
+        }
+        [pa addPointer:"-framework"];
+        [pa addPointer:"Foundation"];
+    }
+    [pa addPointer:gcstrcpy1(filename)];
+    [pa addPointer:"-o"];
+    
+    path[0] = 0;
+    strcat(path, filename);
+    strcat(path, ".");
+    strcat(path, (options & Do64) ? "64" : "32");
+    if (options & DoOBJC) {
+        switch (options & (DoRR|DoGC|DoGCRR|DoRRGC)) {
+        case DoRR: strcat(path, "-rr"); break;
+        case DoGC: strcat(path, "-gconly"); break;
+        case DoGCRR: strcat(path, "-gcrr"); break;
+        case DoRRGC: strcat(path, "-rrgc"); break;
+        }
+    }
+    if (options & DoCPP) strcat(path, "++");
+    if (options & DoDashO) strcat(path, "-O");
+    else if (options & DoDashO2) strcat(path, "-O2");
+    else if (options & DoDashOs) strcat(path, "-Os");
+    if (wantsC99) strcat(path, "-C99");
+    strcat(path, DoClang ? "-clang" : "-gcc");
+    strcat(path, "-bin");
+    TestFileExe *result = [TestFileExe new];
+    result.binaryName = gcstrcpy1(path); // could snarf copy in pa
+    [pa addPointer:result.binaryName];
+    for (id cString in extraLibraries) {
+        [pa addPointer:cString];
+    }
+    
+    result.sourceName = gcstrcpy1(filename); // could snarf copy in pa
+    result.compileLine = pa;
+    result.options = options;
+    result.shouldFail = supposedToNotCompile;
+    result.generator = self;
+    return result;
+}
+
++ (NSArray *)generatorsFromPath:(NSString *)path {
+    FILE *fp = fopen([path fileSystemRepresentation], "r");
+    if (fp == NULL) return nil;
+    NSArray *result = [self generatorsFromFILE:fp];
+    fclose(fp);
+    return result;
+}
+
+#define LOOKFOR "CON" "FIG"
+
+char *__strong parseRadar(char *line) {
+    line = strstr(line, "rdar:");   // returns beginning
+    char *endp = line + strlen("rdar:");
+    while (*endp && *endp != ' ' && *endp != '\n')
+        ++endp;
+    return gcstrcpy2(line, endp);
+}
+
+- (void)parseLibraries:(const char *)line {
+  start:
+    line = strstr(line, "-l");
+    char *endp = (char *)line + 2;
+    while (*endp && *endp != ' ' && *endp != '\n')
+        ++endp;
+    [self addLibrary:gcstrcpy2(line, endp)];
+    if (strstr(endp, "-l")) {
+        line = endp;
+        goto start;
+    }
+}
+
++ (TestFileExeGenerator *)generatorFromLine:(char *)line filename:(char *)filename {
+    TestFileExeGenerator *item = [TestFileExeGenerator new];
+    item.filename = gcstrcpy1(filename);
+    if (strstr(line, "GC")) item.hasGC = true;
+    if (strstr(line, "RR")) item.hasRR = true;
+    if (strstr(line, "C++")) item.hasCPlusPlus = true;
+    if (strstr(line, "-C99")) {
+        item.wantsC99 = true;
+    }
+    if (strstr(line, "64")) item.wants64 = true;
+    if (strstr(line, "32")) item.wants32 = true;
+    if (strstr(line, "-l")) [item parseLibraries:line];
+    if (strstr(line, "open")) item.open = true;
+    if (strstr(line, "FAIL")) item.supposedToNotCompile = true; // old
+    // compile time error
+    if (strstr(line, "error:")) {
+        item.supposedToNotCompile = true;
+        // zap newline
+        char *error = strstr(line, "error:") + strlen("error:");
+        // make sure we have something before the newline
+        char *newline = strstr(error, "\n");
+        if (newline && ((newline-error) > 1)) {
+            *newline = 0;
+            item.errorString = gcstrcpy1(strstr(line, "error:") + strlen("error: "));
+        }
+    }
+    // run time warning
+    if (strstr(line, "runtime:")) {
+        // zap newline
+        char *error = strstr(line, "runtime:") + strlen("runtime:");
+        // make sure we have something before the newline
+        char *newline = strstr(error, "\n");
+        if (newline && ((newline-error) > 1)) {
+            *newline = 0;
+            item.warningString = gcstrcpy1(strstr(line, "runtime:") + strlen("runtime:"));
+        }
+    }
+    if (strstr(line, "rdar:")) item.radar = parseRadar(line);
+    if (item.hasGC || item.hasRR) item.hasObjC = true;
+    if (!item.wants32 && !item.wants64) { // give them both if they ask for neither
+        item.wants32 = item.wants64 = true;
+    }
+    return item;
+}
+
++ (NSArray *)generatorsFromFILE:(FILE *)fp {
+    NSMutableArray *result = [NSMutableArray new];
+    // pretend this is a grep LOOKFOR *.[cmCM][cmCM] input
+    // look for
+    // filename: ... LOOKFOR [GC] [RR] [C++] [FAIL ...]
+    char buf[512];
+    while (fgets(buf, 512, fp)) {
+        char *config = strstr(buf, LOOKFOR);
+        if (!config) continue;
+        char *filename = buf;
+        char *end = strchr(buf, ':');
+        *end = 0;
+        [result addObject:[self generatorFromLine:config filename:filename]];
+    }
+    return result;
+}
+
++ (TestFileExeGenerator *)generatorFromFilename:(char *)filename {
+    FILE *fp = fopen(filename, "r");
+    if (!fp) {
+        printf("didn't open %s!!\n", filename);
+        return nil;
+    }
+    char buf[512];
+    while (fgets(buf, 512, fp)) {
+        char *config = strstr(buf, LOOKFOR);
+        if (!config) continue;
+        fclose(fp);
+        return [self generatorFromLine:config filename:filename];
+    }
+    fclose(fp);
+    // guess from filename
+    char *ext = strrchr(filename, '.');
+    if (!ext) return nil;
+    TestFileExeGenerator *result = [TestFileExeGenerator new];
+    result.filename = gcstrcpy1(filename);
+    if (!strncmp(ext, ".m", 2)) {
+        result.hasObjC = true;
+        result.hasRR = true;
+        result.hasGC = true;
+    }
+    else if (!strcmp(ext, ".c")) {
+        ;
+    }
+    else if (!strcmp(ext, ".M") || !strcmp(ext, ".mm")) {
+        result.hasObjC = true;
+        result.hasRR = true;
+        result.hasGC = true;
+        result.hasCPlusPlus = true;
+    }
+    else if (!strcmp(ext, ".cc")
+        || !strcmp(ext, ".cp")
+        || !strcmp(ext, ".cxx")
+        || !strcmp(ext, ".cpp")
+        || !strcmp(ext, ".CPP")
+        || !strcmp(ext, ".c++")
+        || !strcmp(ext, ".C")) {
+        result.hasCPlusPlus = true;
+    }
+    else {
+        printf("unknown extension, file %s ignored\n", filename);
+        result = nil;
+    }
+    return result;
+        
+}
+
+- (NSString *)description {
+    return [NSString stringWithFormat:@"%s: %s%s%s%s%s%s",
+        filename,
+        LOOKFOR,
+        hasGC ? " GC" : "",
+        hasRR ? " RR" : "",
+        hasCPlusPlus ? " C++" : "",
+        wantsC99 ? "C99" : "",
+        supposedToNotCompile ? " FAIL" : ""];
+}
+
+@end
+
+void printDetails(NSArray *failures, const char *whatAreThey) {
+    if ([failures count]) {
+        NSMutableString *output = [NSMutableString new];
+        printf("%s:\n", whatAreThey);
+        for (TestFileExe *line in failures) {
+            printf("%s", line.binaryName);
+            char *radar = line.generator.radar;
+            if (radar)
+                printf(" (due to %s?),", radar);
+            printf(" recompile via:\n%s\n\n", line.description.UTF8String);
+        }
+        printf("\n");
+    }
+}
+
+void help(const char *whoami) {
+    printf("Usage: %s [-fast] [-e] [-dyld librarypath] [gcc4.2dir] [-- | source1 ...]\n", whoami);
+    printf("     -fast              don't recompile if binary younger than source\n");
+    printf("     -open              only run tests that are thought to still be unresolved\n");
+    printf("     -clang             use the clang and clang++ compilers\n");
+    printf("     -e                 compile all variations also with -Os, -O2, -O3\n");
+    printf("     -dyld p            override DYLD_LIBRARY_PATH and DYLD_FRAMEWORK_PATH to p when running tests\n");
+    printf("     <compilerpath>     directory containing gcc-4.2 (or clang) that you wish to use to compile the tests\n");
+    printf("     --                 assume stdin is a grep CON" "FIG across the test sources\n");
+    printf("     otherwise treat each remaining argument as a single test file source\n");
+    printf("%s will compile and run individual test files under a variety of compilers, c, obj-c, c++, and objc++\n", whoami);
+    printf("  .c files are compiled with all four compilers\n");
+    printf("  .m files are compiled with objc and objc++ compilers\n");
+    printf("  .C files are compiled with c++ and objc++ compilers\n");
+    printf("  .M files are compiled only with the objc++ compiler\n");
+    printf("(actually all forms of extensions recognized by the compilers are honored, .cc, .c++ etc.)\n");
+    printf("\nTest files should run to completion with no output and exit (return) 0 on success.\n");
+    printf("Further they should be able to be compiled and run with GC on or off and by the C++ compilers\n");
+    printf("A line containing the string CON" "FIG within the source enables restrictions to the above assumptions\n");
+    printf("and other options.\n");
+    printf("Following CON" "FIG the string\n");
+    printf("    C++ restricts the test to only be run by c++ and objc++ compilers\n");
+    printf("    GC  restricts the test to only be compiled and run with GC on\n");
+    printf("    RR  (retain/release) restricts the test to only be compiled and run with GC off\n");
+    printf("Additionally,\n");
+    printf("    -C99 restricts the C versions of the test to -fstd=c99 -fblocks\n");
+    printf("    -O   adds the -O optimization level\n");
+    printf("    -O2  adds the -O2 optimization level\n");
+    printf("    -Os  adds the -Os optimization level\n");
+    printf("Files that are known to exhibit unresolved problems can provide the term \"open\" and this can");
+    printf("in turn allow highlighting of fixes that have regressed as well as identify that fixes are now available.\n");
+    printf("Files that exhibit known bugs may provide\n");
+    printf("    rdar://whatever such that if they fail the rdar will get cited\n");
+    printf("Files that are expected to fail to compile should provide, as their last token sequence,\n");
+    printf("    error:\n");
+    printf(" or error: substring to match.\n");
+    printf("Files that are expected to produce a runtime error message should provide, as their last token sequence,\n");
+    printf("    warning: string to match\n");
+    printf("\n%s will compile and run all configurations of the test files and report a summary at the end. Good luck.\n", whoami);
+    printf("       Blaine Garst blaine@apple.com\n");
+}
+
+int main(int argc, char *argv[]) {
+    printf("running on %s-bit architecture\n", sizeof(long) == 4 ? "32" : "64");
+    char *compilerDir = "/usr/bin";
+    NSMutableArray *generators = [NSMutableArray new];
+    bool doFast = false;
+    bool doStdin = false;
+    bool onlyOpen = false;
+    char *libraryPath = getenv("DYLD_LIBRARY_PATH");
+    char *frameworkPath = getenv("DYLD_FRAMEWORK_PATH");
+    // process options
+    while (argc > 1) {
+        if (!strcmp(argv[1], "-fast")) {
+            doFast = true;
+            --argc;
+            ++argv;
+        }
+        else if (!strcmp(argv[1], "-dyld")) {
+            doFast = true;
+            --argc;
+            ++argv;
+            frameworkPath = argv[1];
+            libraryPath = argv[1];
+            --argc;
+            ++argv;
+        }
+        else if (!strcmp(argv[1], "-open")) {
+            onlyOpen = true;
+            --argc;
+            ++argv;
+        }
+        else if (!strcmp(argv[1], "-clang")) {
+            DoClang = true;
+            --argc;
+            ++argv;
+        }
+        else if (!strcmp(argv[1], "-e")) {
+            Everything = true;
+            --argc;
+            ++argv;
+        }
+        else if (!strcmp(argv[1], "--")) {
+            doStdin = true;
+            --argc;
+            ++argv;
+        }
+        else if (!strcmp(argv[1], "-")) {
+            help(argv[0]);
+            return 1;
+        }
+        else if (argc > 1 && isDirectory(argv[1])) {
+            compilerDir = argv[1];
+            ++argv;
+            --argc;
+        }
+        else
+            break;
+    }
+    // process remaining arguments, or stdin
+    if (argc == 1) {
+        if (doStdin)
+            generators = (NSMutableArray *)[TestFileExeGenerator generatorsFromFILE:stdin];
+        else {
+            help(argv[0]);
+            return 1;
+        }
+    }
+    else while (argc > 1) {
+        TestFileExeGenerator *generator = [TestFileExeGenerator generatorFromFilename:argv[1]];
+        if (generator) [generators addObject:generator];
+        ++argv;
+        --argc;
+    }
+    // see if we can generate all possibilities
+    NSMutableArray *failureToCompile = [NSMutableArray new];
+    NSMutableArray *failureToFailToCompile = [NSMutableArray new];
+    NSMutableArray *failureToRun = [NSMutableArray new];
+    NSMutableArray *successes = [NSMutableArray new];
+    for (TestFileExeGenerator *generator in generators) {
+        //NSLog(@"got %@", generator);
+        if (onlyOpen && !generator.open) {
+            //printf("skipping resolved test %s\n", generator.filename);
+            continue;  // skip closed if onlyOpen
+        }
+        if (!onlyOpen && generator.open) {
+            //printf("skipping open test %s\n", generator.filename);
+            continue;  // skip open if not asked for onlyOpen
+        }
+        generator.compilerPath = compilerDir;
+        NSArray *tests = [generator allLines];
+        for (TestFileExe *line in tests) {
+            line.frameworkPath = frameworkPath;   // tell generators about it instead XXX
+            line.libraryPath = libraryPath;   // tell generators about it instead XXX
+            if ([line shouldFail]) {
+                if (doFast) continue; // don't recompile & don't count as success
+                if ([line compileWithExpectedFailure]) {
+                    [successes addObject:line];
+                }
+                else
+                    [failureToFailToCompile addObject:line];
+            }
+            else if ([line compileUnlessExists:doFast]) {
+                if ([line run]) {
+                    printf("%s ran successfully\n", line.binaryName);
+                    [successes addObject:line];
+                }
+                else {
+                    [failureToRun addObject:line];
+                }
+            }
+            else {
+                [failureToCompile addObject:line];
+            }
+        }
+    }
+    printf("\n--- results ---\n\n%lu successes\n%lu unexpected compile failures\n%lu failure to fail to compile errors\n%lu run failures\n",
+        [successes count], [failureToCompile count], [failureToFailToCompile count], [failureToRun count]);
+    printDetails(failureToCompile, "unexpected compile failures");
+    printDetails(failureToFailToCompile, "should have failed to compile but didn't failures");
+    printDetails(failureToRun, "run failures");
+    
+    if (onlyOpen && [successes count]) {
+        NSMutableSet *radars = [NSMutableSet new];
+        printf("The following tests ran successfully suggesting that they are now resolved:\n");
+        for (TestFileExe *line in successes) {
+            printf("%s\n", line.binaryName);
+            if (line.radar) [radars addObject:line.generator];
+        }
+        if ([radars count]) {
+            printf("The following radars may be resolved:\n");
+            for (TestFileExeGenerator *line in radars) {
+                printf("%s\n", line.radar);
+            }
+        }
+    }
+            
+    return [failureToCompile count] + [failureToRun count];
+}
+
+#include <sys/stat.h>
+
+static bool isDirectory(char *path) {
+    struct stat statb;
+    int retval = stat(path, &statb);
+    if (retval != 0) return false;
+    if (statb.st_mode & S_IFDIR) return true;
+    return false;
+}
+
+static bool isExecutable(char *path) {
+    struct stat statb;
+    int retval = stat(path, &statb);
+    if (retval != 0) return false;
+    if (!(statb.st_mode & S_IFREG)) return false;
+    if (statb.st_mode & S_IXUSR) return true;
+    return false;
+}
+
+static bool isYounger(char *source, char *binary) {
+    struct stat statb;
+    int retval = stat(binary, &statb);
+    if (retval != 0) return true;  // if doesn't exit, lie
+    
+    struct stat stata;
+    retval = stat(source, &stata);
+    if (retval != 0) return true; // we're hosed
+    // the greater the timeval the younger it is
+    if (stata.st_mtimespec.tv_sec > statb.st_mtimespec.tv_sec) return true;
+    if (stata.st_mtimespec.tv_nsec > statb.st_mtimespec.tv_nsec) return true;
+    return false;
+}
+
+static bool readErrorFile(char *buffer, const char *from) {
+    int fd = open(from, 0);
+    if (fd < 0) {
+        printf("didn't open %s, (might not have been created?)\n", buffer);
+        return false;
+    }
+    int count = read(fd, buffer, 512);
+    if (count < 1) {
+        printf("read error on %s\n", buffer);
+        return false;
+    }
+    buffer[count-1] = 0; // zap newline
+    return true;
+}
diff --git a/compiler-rt/test/BlocksRuntime/varargs-bad-assign.c b/compiler-rt/test/BlocksRuntime/varargs-bad-assign.c
new file mode 100644
index 0000000..b978668
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/varargs-bad-assign.c
@@ -0,0 +1,44 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//  -*- mode:C; c-basic-offset:4; tab-width:4; intent-tabs-mode:nil;  -*-
+// HACK ALERT: gcc and g++ give different errors, referencing the line number to ensure that it checks for the right error; MUST KEEP IN SYNC WITH THE TEST
+// CONFIG 27: error:
+
+#import <stdio.h>
+#import <stdlib.h>
+#import <string.h>
+#import <stdarg.h>
+
+
+int main (int argc, const char * argv[]) {
+    int (^sumn)(int n, ...);
+    int six = 0;
+    
+    sumn = ^(int a, int b, int n, ...){
+        int result = 0;
+        va_list numbers;
+        int i;
+
+        va_start(numbers, n);
+        for (i = 0 ; i < n ; i++) {
+            result += va_arg(numbers, int);
+        }
+        va_end(numbers);
+
+        return result;
+    };
+
+    six = sumn(3, 1, 2, 3);
+
+    if ( six != 6 ) {
+        printf("%s: Expected 6 but got %d\n", argv[0], six);
+        exit(1);
+    }
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/varargs.c b/compiler-rt/test/BlocksRuntime/varargs.c
new file mode 100644
index 0000000..01affc7
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/varargs.c
@@ -0,0 +1,39 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+//  -*- mode:C; c-basic-offset:4; tab-width:4; intent-tabs-mode:nil;  -*-
+// CONFIG
+
+#import <stdio.h>
+#import <stdlib.h>
+#import <string.h>
+#import <stdarg.h>
+
+
+int main (int argc, const char * argv[]) {
+    int (^sumn)(int n, ...) = ^(int n, ...){
+        int result = 0;
+        va_list numbers;
+        int i;
+
+        va_start(numbers, n);
+        for (i = 0 ; i < n ; i++) {
+            result += va_arg(numbers, int);
+        }
+        va_end(numbers);
+
+        return result;
+    };
+    int six = sumn(3, 1, 2, 3);
+    
+    if ( six != 6 ) {
+        printf("%s: Expected 6 but got %d\n", argv[0], six);
+        exit(1);
+    }
+    
+    printf("%s: success\n", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/BlocksRuntime/variadic.c b/compiler-rt/test/BlocksRuntime/variadic.c
new file mode 100644
index 0000000..1d80657
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/variadic.c
@@ -0,0 +1,66 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  variadic.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 2/17/09.
+ *
+ */
+
+// PURPOSE Test that variadic arguments compile and work for Blocks
+// CONFIG
+
+#include <stdarg.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+    
+    long (^addthem)(const char *, ...) = ^long (const char *format, ...){
+        va_list argp;
+        const char *p;
+        int i;
+        char c;
+        double d;
+        long result = 0;
+        va_start(argp, format);
+        //printf("starting...\n");
+        for (p = format; *p; p++) switch (*p) {
+            case 'i':
+                i = va_arg(argp, int);
+                //printf("i: %d\n", i);
+                result += i;
+                break;
+            case 'd':
+                d = va_arg(argp, double);
+                //printf("d: %g\n", d);
+                result += (int)d;
+                break;
+            case 'c':
+                c = va_arg(argp, int);
+                //printf("c: '%c'\n", c);
+                result += c;
+                break;
+        }
+        //printf("...done\n\n");
+        return result;
+    };
+    long testresult = addthem("ii", 10, 20);
+    if (testresult != 30) {
+        printf("got wrong result: %ld\n", testresult);
+        return 1;
+    }
+    testresult = addthem("idc", 30, 40.0, 'a');
+    if (testresult != (70+'a')) {
+        printf("got different wrong result: %ld\n", testresult);
+        return 1;
+    }
+    printf("%s: Success\n", argv[0]);
+    return 0;
+}
+
+
diff --git a/compiler-rt/test/BlocksRuntime/voidarg.c b/compiler-rt/test/BlocksRuntime/voidarg.c
new file mode 100644
index 0000000..a8f034b
--- /dev/null
+++ b/compiler-rt/test/BlocksRuntime/voidarg.c
@@ -0,0 +1,27 @@
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+/*
+ *  voidarg.c
+ *  testObjects
+ *
+ *  Created by Blaine Garst on 2/17/09.
+ *
+ */
+
+// PURPOSE should complain about missing 'void' but both GCC and clang are supporting K&R instead
+// CONFIG open error:
+
+#include <stdio.h>
+
+int Global;
+
+void (^globalBlock)() = ^{ ++Global; };         // should be void (^gb)(void) = ...
+
+int main(int argc, char *argv[]) {
+    printf("%s: success", argv[0]);
+    return 0;
+}
diff --git a/compiler-rt/test/CMakeLists.txt b/compiler-rt/test/CMakeLists.txt
new file mode 100644
index 0000000..e5c51c8
--- /dev/null
+++ b/compiler-rt/test/CMakeLists.txt
@@ -0,0 +1,81 @@
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.common.configured.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.common.configured)
+
+# BlocksRuntime and builtins testsuites are not yet ported to lit.
+# add_subdirectory(BlocksRuntime)
+# add_subdirectory(builtins)
+
+set(SANITIZER_COMMON_LIT_TEST_DEPS)
+if(COMPILER_RT_STANDALONE_BUILD)
+  add_executable(FileCheck IMPORTED GLOBAL)
+  set_property(TARGET FileCheck PROPERTY IMPORTED_LOCATION ${LLVM_TOOLS_BINARY_DIR}/FileCheck)
+  list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS FileCheck)
+endif()
+
+# When ANDROID, we build tests with the host compiler (i.e. CMAKE_C_COMPILER),
+# and run tests with tools from the host toolchain.
+if(NOT ANDROID)
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    # Use LLVM utils and Clang from the same build tree.
+    list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS
+      clang clang-headers FileCheck count not llvm-config llvm-nm llvm-objdump
+      llvm-symbolizer compiler-rt-headers)
+    if (COMPILER_RT_HAS_PROFILE)
+      list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS profile)
+    endif()
+    if (WIN32)
+      list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS KillTheDoctor)
+    endif()
+  endif()
+  if(UNIX)
+    list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS SanitizerLintCheck)
+  endif()
+endif()
+
+# Run sanitizer tests only if we're sure that clang would produce
+# working binaries.
+if(COMPILER_RT_CAN_EXECUTE_TESTS)
+  if(COMPILER_RT_HAS_ASAN)
+    add_subdirectory(asan)
+  endif()
+  if(COMPILER_RT_HAS_DFSAN)
+    add_subdirectory(dfsan)
+  endif()
+  if(COMPILER_RT_HAS_LSAN)
+    add_subdirectory(lsan)
+  endif()
+  if(COMPILER_RT_HAS_MSAN)
+    add_subdirectory(msan)
+  endif()
+  if(COMPILER_RT_HAS_PROFILE)
+    add_subdirectory(profile)
+  endif()
+  if(COMPILER_RT_HAS_SANITIZER_COMMON)
+    add_subdirectory(sanitizer_common)
+  endif()
+  if(COMPILER_RT_HAS_TSAN)
+    add_subdirectory(tsan)
+  endif()
+  if(COMPILER_RT_HAS_UBSAN)
+    add_subdirectory(ubsan)
+  endif()
+  # CFI tests require diagnostic mode, which is implemented in UBSan.
+  if(COMPILER_RT_HAS_UBSAN)
+    add_subdirectory(cfi)
+  endif()
+  if(COMPILER_RT_HAS_SAFESTACK)
+    add_subdirectory(safestack)
+  endif()
+endif()
+
+if(COMPILER_RT_STANDALONE_BUILD)
+  # Now that we've traversed all the directories and know all the lit testsuites,
+  # introduce a rule to run to run all of them.
+  get_property(LLVM_LIT_TESTSUITES GLOBAL PROPERTY LLVM_LIT_TESTSUITES)
+  get_property(LLVM_LIT_DEPENDS GLOBAL PROPERTY LLVM_LIT_DEPENDS)
+  add_lit_target(check-all
+    "Running all regression tests"
+    ${LLVM_LIT_TESTSUITES}
+    DEPENDS ${LLVM_LIT_DEPENDS})
+endif()
diff --git a/compiler-rt/test/asan/CMakeLists.txt b/compiler-rt/test/asan/CMakeLists.txt
new file mode 100644
index 0000000..b2be957
--- /dev/null
+++ b/compiler-rt/test/asan/CMakeLists.txt
@@ -0,0 +1,117 @@
+set(ASAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(ASAN_TESTSUITES)
+set(ASAN_DYNAMIC_TESTSUITES)
+
+macro(get_bits_for_arch arch bits)
+  if (${arch} MATCHES "i386|i686|arm|mips|mipsel")
+    set(${bits} 32)
+  elseif (${arch} MATCHES "x86_64|powerpc64|powerpc64le|aarch64|mips64|mips64el")
+    set(${bits} 64)
+  else()
+    message(FATAL_ERROR "Unknown target architecture: ${arch}")
+  endif()
+endmacro()
+
+set(ASAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND ASAN_TEST_DEPS asan)
+  if(WIN32 AND COMPILER_RT_HAS_LLD_SOURCES)
+    list(APPEND ASAN_TEST_DEPS
+      lld
+    )
+  endif()
+endif()
+set(ASAN_DYNAMIC_TEST_DEPS ${ASAN_TEST_DEPS})
+
+set(ASAN_TEST_ARCH ${ASAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(ASAN_SUPPORTED_ARCH ASAN_TEST_ARCH)
+endif()
+
+foreach(arch ${ASAN_TEST_ARCH})
+  if(ANDROID)
+    set(ASAN_TEST_TARGET_ARCH ${arch}-android)
+  else()
+    set(ASAN_TEST_TARGET_ARCH ${arch})
+  endif()
+  string(TOLOWER "-${arch}-${OS_NAME}" ASAN_TEST_CONFIG_SUFFIX)
+  get_bits_for_arch(${arch} ASAN_TEST_BITS)
+  if(ANDROID OR ${arch} MATCHES "arm|aarch64")
+    # This is only true if we are cross-compiling.
+    # Build all tests with host compiler and use host tools.
+    set(ASAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
+    set(ASAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
+  else()
+    get_target_flags_for_arch(${arch} ASAN_TEST_TARGET_CFLAGS)
+    string(REPLACE ";" " " ASAN_TEST_TARGET_CFLAGS "${ASAN_TEST_TARGET_CFLAGS}")
+  endif()
+  if(ANDROID)
+    set(ASAN_TEST_DYNAMIC True)
+  else()
+    set(ASAN_TEST_DYNAMIC False)
+  endif()
+  string(TOUPPER ${arch} ARCH_UPPER_CASE)
+  set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
+    )
+  list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+
+  if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
+    string(TOLOWER "-${arch}-${OS_NAME}-dynamic" ASAN_TEST_CONFIG_SUFFIX)
+    set(ASAN_TEST_DYNAMIC True)
+    set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}DynamicConfig)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg)
+    list(APPEND ASAN_DYNAMIC_TESTSUITES
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  endif()
+endforeach()
+
+# Add unit tests.
+if(COMPILER_RT_INCLUDE_TESTS)
+  set(ASAN_TEST_DYNAMIC False)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
+  if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
+    set(ASAN_TEST_DYNAMIC True)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic/lit.site.cfg)
+  endif()
+  # FIXME: support unit test in the android test runner
+  if (NOT ANDROID)
+    list(APPEND ASAN_TEST_DEPS AsanUnitTests)
+    list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
+    if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
+      list(APPEND ASAN_DYNAMIC_TEST_DEPS AsanDynamicUnitTests)
+      list(APPEND ASAN_DYNAMIC_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic)
+    endif()
+  endif()
+endif()
+
+add_lit_testsuite(check-asan "Running the AddressSanitizer tests"
+  ${ASAN_TESTSUITES}
+  DEPENDS ${ASAN_TEST_DEPS})
+set_target_properties(check-asan PROPERTIES FOLDER "ASan tests")
+
+if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
+  # Add check-dynamic-asan target. It is a part of check-all only on Windows,
+  # where we want to always test both dynamic and static runtime.
+  if(NOT OS_NAME MATCHES "Windows")
+    set(EXCLUDE_FROM_ALL TRUE)
+  endif()
+  add_lit_testsuite(check-asan-dynamic
+                    "Running the AddressSanitizer tests with dynamic runtime"
+                    ${ASAN_DYNAMIC_TESTSUITES}
+                    DEPENDS ${ASAN_DYNAMIC_TEST_DEPS})
+  set_target_properties(check-asan-dynamic
+                        PROPERTIES FOLDER "ASan dynamic tests")
+  if(NOT OS_NAME MATCHES "Windows")
+    set(EXCLUDE_FROM_ALL FALSE)
+  endif()
+endif()
diff --git a/compiler-rt/test/asan/TestCases/Android/coverage-android.cc b/compiler-rt/test/asan/TestCases/Android/coverage-android.cc
new file mode 100644
index 0000000..16a6e1f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Android/coverage-android.cc
@@ -0,0 +1,143 @@
+// Test for direct coverage writing with dlopen.
+
+// Test normal exit, coverage level 1.
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %T/libcoverage_android_test_1.so -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSO_DIR=\"%device\" %s -o %t
+
+// RUN: adb shell rm -rf %device/coverage-android
+// RUN: rm -rf %T/coverage-android
+
+// RUN: adb shell mkdir -p %device/coverage-android/direct
+// RUN: mkdir -p %T/coverage-android/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t
+// RUN: adb pull %device/coverage-android/direct %T/coverage-android/direct
+// RUN: ls; pwd
+// RUN: cd %T/coverage-android/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK1 %s
+
+
+// Test sudden death, coverage level 1.
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED -DKILL %s -shared -o %T/libcoverage_android_test_1.so -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSO_DIR=\"%device\" %s -o %t
+
+// RUN: adb shell rm -rf %device/coverage-android-kill
+// RUN: rm -rf %T/coverage-android-kill
+
+// RUN: adb shell mkdir -p %device/coverage-android-kill/direct
+// RUN: mkdir -p %T/coverage-android-kill/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t
+// RUN: adb pull %device/coverage-android-kill/direct %T/coverage-android-kill/direct
+// RUN: ls; pwd
+// RUN: cd %T/coverage-android-kill/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK1 %s
+
+
+// Test normal exit, coverage level 2.
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED %s -shared -o %T/libcoverage_android_test_1.so -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%device\" %s -o %t
+
+// RUN: adb shell rm -rf %device/coverage-android
+// RUN: rm -rf %T/coverage-android
+
+// RUN: adb shell mkdir -p %device/coverage-android/direct
+// RUN: mkdir -p %T/coverage-android/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t
+// RUN: adb pull %device/coverage-android/direct %T/coverage-android/direct
+// RUN: ls; pwd
+// RUN: cd %T/coverage-android/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK2 %s
+
+
+// Test sudden death, coverage level 2.
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED -DKILL %s -shared -o %T/libcoverage_android_test_1.so -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%device\" %s -o %t
+
+// RUN: adb shell rm -rf %device/coverage-android-kill
+// RUN: rm -rf %T/coverage-android-kill
+
+// RUN: adb shell mkdir -p %device/coverage-android-kill/direct
+// RUN: mkdir -p %T/coverage-android-kill/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t
+// RUN: adb pull %device/coverage-android-kill/direct %T/coverage-android-kill/direct
+// RUN: ls; pwd
+// RUN: cd %T/coverage-android-kill/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK2 %s
+
+
+// Test normal exit, coverage level 3.
+// RUN: %clangxx_asan -fsanitize-coverage=edge -DSHARED %s -shared -o %T/libcoverage_android_test_1.so -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%device\" %s -o %t
+
+// RUN: adb shell rm -rf %device/coverage-android
+// RUN: rm -rf %T/coverage-android
+
+// RUN: adb shell mkdir -p %device/coverage-android/direct
+// RUN: mkdir -p %T/coverage-android/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t
+// RUN: adb pull %device/coverage-android/direct %T/coverage-android/direct
+// RUN: ls; pwd
+// RUN: cd %T/coverage-android/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK3 %s
+
+
+// Test sudden death, coverage level 3.
+// RUN: %clangxx_asan -fsanitize-coverage=edge -DSHARED -DKILL %s -shared -o %T/libcoverage_android_test_1.so -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%device\" %s -o %t
+
+// RUN: adb shell rm -rf %device/coverage-android-kill
+// RUN: rm -rf %T/coverage-android-kill
+
+// RUN: adb shell mkdir -p %device/coverage-android-kill/direct
+// RUN: mkdir -p %T/coverage-android-kill/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t
+// RUN: adb pull %device/coverage-android-kill/direct %T/coverage-android-kill/direct
+// RUN: ls; pwd
+// RUN: cd %T/coverage-android-kill/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK3 %s
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <signal.h>
+
+#ifdef SHARED
+extern "C" {
+void bar() {
+  printf("bar\n");
+#ifdef KILL
+  kill(getpid(), SIGKILL);
+#endif
+}
+}
+#else
+
+volatile int sink;
+
+int main(int argc, char **argv) {
+  fprintf(stderr, "PID: %d\n", getpid());
+  void *handle1 =
+      dlopen(SO_DIR "/libcoverage_android_test_1.so", RTLD_LAZY);
+  assert(handle1);
+
+  if (argc == 0)
+    sink = 0;
+
+  void (*bar1)() = (void (*)())dlsym(handle1, "bar");
+  assert(bar1);
+  bar1();
+
+  return 0;
+}
+#endif
+
+// CHECK1: 2 PCs total
+// CHECK2: 7 PCs total
+// CHECK3: 8 PCs total
diff --git a/compiler-rt/test/asan/TestCases/Android/lit.local.cfg b/compiler-rt/test/asan/TestCases/Android/lit.local.cfg
new file mode 100644
index 0000000..63a6e52
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Android/lit.local.cfg
@@ -0,0 +1,11 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.android != "1":
+  config.unsupported = True
+
+config.substitutions.append( ("%device", "/data/local/tmp/Output") )
diff --git a/compiler-rt/test/asan/TestCases/Darwin/abort_on_error.cc b/compiler-rt/test/asan/TestCases/Darwin/abort_on_error.cc
new file mode 100644
index 0000000..f09718b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/abort_on_error.cc
@@ -0,0 +1,17 @@
+// Check that with empty ASAN_OPTIONS, ASan reports on OS X actually crash
+// the process (abort_on_error=1). See also Linux/abort_on_error.cc.
+
+// RUN: %clangxx_asan %s -o %t
+
+// Intentionally don't inherit the default ASAN_OPTIONS.
+// RUN: ASAN_OPTIONS="" not --crash %run %t 2>&1 | FileCheck %s
+// When we use lit's default ASAN_OPTIONS, we shouldn't crash.
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/address-range-limit.mm b/compiler-rt/test/asan/TestCases/Darwin/address-range-limit.mm
new file mode 100644
index 0000000..a690676
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/address-range-limit.mm
@@ -0,0 +1,38 @@
+// Regression test for https://code.google.com/p/address-sanitizer/issues/detail?id=368.
+
+// RUN: %clang_asan %s -Wno-deprecated-declarations -flat_namespace -bundle -undefined suppress -o %t.bundle
+// RUN: %clang_asan %s -Wno-deprecated-declarations -o %t -framework Foundation && not %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+#import <mach-o/dyld.h>
+
+#include <string>
+
+int main(int argc, char *argv[]) {
+  for (int i = 0; i < 10; i++) {
+    NSObjectFileImage im;
+
+	std::string path = std::string(argv[0]) + ".bundle";
+    NSObjectFileImageReturnCode rc =
+        NSCreateObjectFileImageFromFile(path.c_str(), &im);
+    if (rc != NSObjectFileImageSuccess) {
+      fprintf(stderr, "Could not load bundle.\n");
+      exit(-1);
+    }
+
+    NSModule handle = NSLinkModule(im, "a.bundle", 0);
+    if (handle == 0) {
+      fprintf(stderr, "Could not load bundle.\n");
+      exit(-1);
+    }
+    printf("h: %p\n", handle);
+  }
+
+  char *ptr = (char *)malloc(10);
+  ptr[10] = 'x';  // BOOM
+}
+
+// CHECK: AddressSanitizer: heap-buffer-overflow
+// CHECK: WRITE of size 1
+// CHECK: {{#0 .* in main}}
+// CHECK: is located 0 bytes to the right of 10-byte region
diff --git a/compiler-rt/test/asan/TestCases/Darwin/asan_gen_prefixes.cc b/compiler-rt/test/asan/TestCases/Darwin/asan_gen_prefixes.cc
new file mode 100644
index 0000000..13363ac
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/asan_gen_prefixes.cc
@@ -0,0 +1,14 @@
+// Make sure __asan_gen_* strings have the correct prefixes on Darwin
+// ("L" in __TEXT,__cstring, "l" in __TEXT,__const
+
+// RUN: %clang_asan %s -S -o %t.s
+// RUN: cat %t.s | FileCheck %s || exit 1
+
+int x, y, z;
+int main() { return 0; }
+// CHECK: .section{{.*}}__TEXT,__const
+// CHECK: l___asan_gen_
+// CHECK: .section{{.*}}__TEXT,__cstring,cstring_literals
+// CHECK: L___asan_gen_
+// CHECK: L___asan_gen_
+// CHECK: L___asan_gen_
diff --git a/compiler-rt/test/asan/TestCases/Darwin/atos-symbolizer-dyld-root-path.cc b/compiler-rt/test/asan/TestCases/Darwin/atos-symbolizer-dyld-root-path.cc
new file mode 100644
index 0000000..4595fb5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/atos-symbolizer-dyld-root-path.cc
@@ -0,0 +1,27 @@
+// Check that when having a DYLD_ROOT_PATH set, the symbolizer still works.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %env_asan_opts=verbosity=2 DYLD_ROOT_PATH="/" ASAN_SYMBOLIZER_PATH=$(which atos) \
+// RUN:   not %run %t 2>&1 | FileCheck %s
+//
+// Due to a bug in atos, this only works on x86_64.
+// REQUIRES: asan-64-bits
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char*)malloc(10 * sizeof(char));
+  memset(x, 0, 10);
+  int res = x[argc];
+  free(x);
+  free(x + argc - 1);  // BOOM
+  // CHECK: AddressSanitizer: attempting double-free{{.*}}in thread T0
+  // CHECK: Using atos at user-specified path:
+  // CHECK: #0 0x{{.*}} in {{.*}}free
+  // CHECK: #1 0x{{.*}} in main {{.*}}atos-symbolizer-dyld-root-path.cc:[[@LINE-4]]
+  // CHECK: freed by thread T0 here:
+  // CHECK: #0 0x{{.*}} in {{.*}}free
+  // CHECK: #1 0x{{.*}} in main {{.*}}atos-symbolizer-dyld-root-path.cc:[[@LINE-8]]
+  // CHECK: allocated by thread T0 here:
+  // CHECK: atos-symbolizer-dyld-root-path.cc:[[@LINE-13]]
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/atos-symbolizer.cc b/compiler-rt/test/asan/TestCases/Darwin/atos-symbolizer.cc
new file mode 100644
index 0000000..2a9ffbc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/atos-symbolizer.cc
@@ -0,0 +1,24 @@
+// Check that the `atos` symbolizer works.
+
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %env_asan_opts=verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char*)malloc(10 * sizeof(char));
+  memset(x, 0, 10);
+  int res = x[argc];
+  free(x);
+  free(x + argc - 1);  // BOOM
+  // CHECK: AddressSanitizer: attempting double-free{{.*}}in thread T0
+  // CHECK: Using atos at user-specified path:
+  // CHECK: #0 0x{{.*}} in {{.*}}free
+  // CHECK: #1 0x{{.*}} in main {{.*}}atos-symbolizer.cc:[[@LINE-4]]
+  // CHECK: freed by thread T0 here:
+  // CHECK: #0 0x{{.*}} in {{.*}}free
+  // CHECK: #1 0x{{.*}} in main {{.*}}atos-symbolizer.cc:[[@LINE-8]]
+  // CHECK: allocated by thread T0 here:
+  // CHECK: atos-symbolizer.cc:[[@LINE-13]]
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/crashlog-stacktraces.c b/compiler-rt/test/asan/TestCases/Darwin/crashlog-stacktraces.c
new file mode 100644
index 0000000..9151614
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/crashlog-stacktraces.c
@@ -0,0 +1,48 @@
+// RUN: %clang_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+// Since ASan is built with -fomit-frame-pointer, backtrace is not able to
+// symbolicate the trace past ASan runtime on i386. (This is fixed in
+// latest OS X.)
+// REQUIRES: asan-64-bits
+
+#include <execinfo.h>
+#include <sanitizer/common_interface_defs.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void death_function() {
+  fprintf(stderr, "DEATH CALLBACK\n");
+
+  void* callstack[128];
+  int i, frames = backtrace(callstack, 128);
+  char** strs = backtrace_symbols(callstack, frames);
+  for (i = 0; i < frames; ++i) {
+    fprintf(stderr, "%s\n", strs[i]);
+  }
+  free(strs);
+
+  fprintf(stderr, "END OF BACKTRACE\n");
+}
+
+int fault_function() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];  // BOOM
+}
+
+int main() {
+  __sanitizer_set_death_callback(death_function);
+  fault_function();
+  return 0;
+}
+
+// CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+// CHECK: {{READ of size 1 at 0x.* thread T0}}
+// CHECK: {{    #0 0x.* in fault_function}}
+
+// CHECK: DEATH CALLBACK
+// CHECK: death_function
+// CHECK: fault_function
+// CHECK: main
+// CHECK: END OF BACKTRACE
diff --git a/compiler-rt/test/asan/TestCases/Darwin/cstring_literals_regtest.mm b/compiler-rt/test/asan/TestCases/Darwin/cstring_literals_regtest.mm
new file mode 100644
index 0000000..bcb15d8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/cstring_literals_regtest.mm
@@ -0,0 +1,23 @@
+// Regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=274.
+
+// RUN: %clang_asan %s -framework Foundation -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+#import <Foundation/Foundation.h>
+
+#include <stdio.h>
+
+int main() {
+  NSString* version_file = @"MAJOR=35\n";
+  int major = 0, minor = 0, build = 0, patch = 0;
+  NSScanner* scanner = [NSScanner scannerWithString:version_file];
+  NSString *res = nil;
+  if ([scanner scanString:@"MAJOR=" intoString:nil] &&
+      [scanner scanInt:&major]) {
+    res = [NSString stringWithFormat:@"%d.%d.%d.%d",
+           major, minor, build, patch];
+  }
+  printf("%s\n", [res UTF8String]);
+  // CHECK: 35.0.0.0
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/dladdr-demangling.cc b/compiler-rt/test/asan/TestCases/Darwin/dladdr-demangling.cc
new file mode 100644
index 0000000..d773659
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/dladdr-demangling.cc
@@ -0,0 +1,33 @@
+// In a non-forking sandbox, we fallback to dladdr(). Test that we provide
+// properly demangled C++ names in that case.
+
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=verbosity=2 not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-DLADDR
+
+#include <stdlib.h>
+
+class MyClass {
+ public:
+  int my_function(int n) {
+    char *x = (char*)malloc(n * sizeof(char));
+    free(x);
+    return x[5];
+    // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+    // CHECK: {{READ of size 1 at 0x.* thread T0}}
+    // CHECK-DLADDR: Using dladdr symbolizer
+    // CHECK-DLADDR: failed to fork external symbolizer
+    // CHECK: {{    #0 0x.* in MyClass::my_function\(int\)}}
+    // CHECK: {{freed by thread T0 here:}}
+    // CHECK: {{    #0 0x.* in wrap_free}}
+    // CHECK: {{    #1 0x.* in MyClass::my_function\(int\)}}
+    // CHECK: {{previously allocated by thread T0 here:}}
+    // CHECK: {{    #0 0x.* in wrap_malloc}}
+    // CHECK: {{    #1 0x.* in MyClass::my_function\(int\)}}
+  }
+};
+
+int main() {
+  MyClass o;
+  return o.my_function(10);
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/dyld_insert_libraries_reexec.cc b/compiler-rt/test/asan/TestCases/Darwin/dyld_insert_libraries_reexec.cc
new file mode 100644
index 0000000..b22036a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/dyld_insert_libraries_reexec.cc
@@ -0,0 +1,46 @@
+// When DYLD-inserting the ASan dylib from a different location than the
+// original, make sure we don't try to reexec.
+
+// RUN: mkdir -p %T/dyld_insert_libraries_reexec
+// RUN: cp `%clang_asan %s -fsanitize=address -### 2>&1 \
+// RUN:   | grep "libclang_rt.asan_osx_dynamic.dylib" \
+// RUN:   | sed -e 's/.*"\(.*libclang_rt.asan_osx_dynamic.dylib\)".*/\1/'` \
+// RUN:   %T/dyld_insert_libraries_reexec/libclang_rt.asan_osx_dynamic.dylib
+// RUN: %clangxx_asan %s -o %T/dyld_insert_libraries_reexec/a.out
+
+// RUN:   %env_asan_opts=verbosity=1 \
+// RUN:       DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib \
+// RUN:       %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
+// RUN:   | FileCheck %s
+
+// RUN: IS_OSX_10_11_OR_HIGHER=$([ `sw_vers -productVersion | cut -d'.' -f2` -lt 11 ]; echo $?)
+
+// On OS X 10.10 and lower, if the dylib is not DYLD-inserted, ASan will re-exec.
+// RUN: if [ $IS_OSX_10_11_OR_HIGHER == 0 ]; then \
+// RUN:   %env_asan_opts=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-NOINSERT %s; \
+// RUN:   fi
+
+// On OS X 10.11 and higher, we don't need to DYLD-insert anymore, and the interceptors
+// still installed correctly. Let's just check that things work and we don't try to re-exec.
+// RUN: if [ $IS_OSX_10_11_OR_HIGHER == 1 ]; then \
+// RUN:   %env_asan_opts=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
+// RUN:   | FileCheck %s; \
+// RUN:   fi
+
+#include <stdio.h>
+
+int main() {
+  printf("Passed\n");
+  return 0;
+}
+
+// CHECK-NOINSERT: exec()-ing the program with
+// CHECK-NOINSERT: DYLD_INSERT_LIBRARIES
+// CHECK-NOINSERT: to enable wrappers.
+// CHECK-NOINSERT: Passed
+
+// CHECK-NOT: exec()-ing the program with
+// CHECK-NOT: DYLD_INSERT_LIBRARIES
+// CHECK-NOT: to enable wrappers.
+// CHECK: Passed
diff --git a/compiler-rt/test/asan/TestCases/Darwin/dyld_insert_libraries_remove.cc b/compiler-rt/test/asan/TestCases/Darwin/dyld_insert_libraries_remove.cc
new file mode 100644
index 0000000..a3af8c1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/dyld_insert_libraries_remove.cc
@@ -0,0 +1,39 @@
+// Check that when launching with DYLD_INSERT_LIBRARIES, we properly remove
+// the ASan dylib from the environment variable (both when using an absolute
+// or relative path) and also that the other dylibs are left untouched.
+
+// RUN: mkdir -p %T/dyld_insert_libraries_remove
+// RUN: cp `%clang_asan %s -fsanitize=address -### 2>&1 \
+// RUN:   | grep "libclang_rt.asan_osx_dynamic.dylib" \
+// RUN:   | sed -e 's/.*"\(.*libclang_rt.asan_osx_dynamic.dylib\)".*/\1/'` \
+// RUN:   %T/dyld_insert_libraries_remove/libclang_rt.asan_osx_dynamic.dylib
+
+// RUN: %clangxx_asan %s -o %T/dyld_insert_libraries_remove/a.out
+// RUN: %clangxx -DSHARED_LIB %s \
+// RUN:     -dynamiclib -o %T/dyld_insert_libraries_remove/dummy-so.dylib
+
+// RUN: ( cd %T/dyld_insert_libraries_remove && \
+// RUN:   DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib:dummy-so.dylib \
+// RUN:   %run ./a.out 2>&1 ) | FileCheck %s || exit 1
+
+// RUN: ( cd %T/dyld_insert_libraries_remove && \
+// RUN:   DYLD_INSERT_LIBRARIES=libclang_rt.asan_osx_dynamic.dylib:dummy-so.dylib \
+// RUN:   %run ./a.out 2>&1 ) | FileCheck %s || exit 1
+
+// RUN: ( cd %T/dyld_insert_libraries_remove && \
+// RUN:   DYLD_INSERT_LIBRARIES=%T/dyld_insert_libraries_remove/libclang_rt.asan_osx_dynamic.dylib:dummy-so.dylib \
+// RUN:   %run ./a.out 2>&1 ) | FileCheck %s || exit 1
+
+#if !defined(SHARED_LIB)
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  const char kEnvName[] = "DYLD_INSERT_LIBRARIES";
+  printf("%s=%s\n", kEnvName, getenv(kEnvName));
+  // CHECK: {{DYLD_INSERT_LIBRARIES=dummy-so.dylib}}
+  return 0;
+}
+#else  // SHARED_LIB
+void foo() {}
+#endif  // SHARED_LIB
diff --git a/compiler-rt/test/asan/TestCases/Darwin/empty-section.cc b/compiler-rt/test/asan/TestCases/Darwin/empty-section.cc
new file mode 100644
index 0000000..5b006b5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/empty-section.cc
@@ -0,0 +1,12 @@
+// Regression test with an empty (length = 0) custom section.
+
+// RUN: %clangxx_asan -g -O0 %s -c -o %t.o
+// RUN: %clangxx_asan -g -O0 %t.o -o %t -sectcreate mysegment mysection /dev/null
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+int main() {
+  printf("Hello, world!\n");
+  // CHECK: Hello, world!
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.c b/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.c
new file mode 100644
index 0000000..ed5779e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.c
@@ -0,0 +1,64 @@
+// Check the presence of interface symbols in the ASan runtime dylib.
+// If you're changing this file, please also change
+// ../Linux/interface_symbols.c
+
+// RUN: %clang_asan -dead_strip -O2 %s -o %t.exe
+// RUN: rm -f %t.symbols %t.interface
+
+// RUN: nm -g `%clang_asan %s -fsanitize=address -### 2>&1 | grep "libclang_rt.asan_osx_dynamic.dylib" | sed -e 's/.*"\(.*libclang_rt.asan_osx_dynamic.dylib\)".*/\1/'` \
+// RUN:   | grep " T " | sed "s/.* T //" \
+// RUN:   | grep "__asan_" | sed "s/___asan_/__asan_/" \
+// RUN:   | sed -E "s/__asan_version_mismatch_check_v[0-9]+/__asan_version_mismatch_check/" \
+// RUN:   | grep -v "__asan_default_options" \
+// RUN:   | grep -v "__asan_on_error" > %t.symbols
+
+// RUN: cat %p/../../../../lib/asan/asan_interface_internal.h \
+// RUN:    | sed "s/\/\/.*//" | sed "s/typedef.*//" \
+// RUN:    | grep -v "OPTIONAL" \
+// RUN:    | grep "__asan_.*(" | sed "s/.* __asan_/__asan_/;s/(.*//" \
+// RUN:    > %t.interface
+// RUN: echo __asan_report_load1 >> %t.interface
+// RUN: echo __asan_report_load2 >> %t.interface
+// RUN: echo __asan_report_load4 >> %t.interface
+// RUN: echo __asan_report_load8 >> %t.interface
+// RUN: echo __asan_report_load16 >> %t.interface
+// RUN: echo __asan_report_store1 >> %t.interface
+// RUN: echo __asan_report_store2 >> %t.interface
+// RUN: echo __asan_report_store4 >> %t.interface
+// RUN: echo __asan_report_store8 >> %t.interface
+// RUN: echo __asan_report_store16 >> %t.interface
+// RUN: echo __asan_report_load_n >> %t.interface
+// RUN: echo __asan_report_store_n >> %t.interface
+// RUN: echo __asan_report_load1_noabort >> %t.interface
+// RUN: echo __asan_report_load2_noabort >> %t.interface
+// RUN: echo __asan_report_load4_noabort >> %t.interface
+// RUN: echo __asan_report_load8_noabort >> %t.interface
+// RUN: echo __asan_report_load16_noabort >> %t.interface
+// RUN: echo __asan_report_store1_noabort >> %t.interface
+// RUN: echo __asan_report_store2_noabort >> %t.interface
+// RUN: echo __asan_report_store4_noabort >> %t.interface
+// RUN: echo __asan_report_store8_noabort >> %t.interface
+// RUN: echo __asan_report_store16_noabort >> %t.interface
+// RUN: echo __asan_report_load_n_noabort >> %t.interface
+// RUN: echo __asan_report_store_n_noabort >> %t.interface
+// RUN: echo __asan_report_exp_load1 >> %t.interface
+// RUN: echo __asan_report_exp_load2 >> %t.interface
+// RUN: echo __asan_report_exp_load4 >> %t.interface
+// RUN: echo __asan_report_exp_load8 >> %t.interface
+// RUN: echo __asan_report_exp_load16 >> %t.interface
+// RUN: echo __asan_report_exp_store1 >> %t.interface
+// RUN: echo __asan_report_exp_store2 >> %t.interface
+// RUN: echo __asan_report_exp_store4 >> %t.interface
+// RUN: echo __asan_report_exp_store8 >> %t.interface
+// RUN: echo __asan_report_exp_store16 >> %t.interface
+// RUN: echo __asan_report_exp_load_n >> %t.interface
+// RUN: echo __asan_report_exp_store_n >> %t.interface
+// RUN: echo __asan_get_current_fake_stack >> %t.interface
+// RUN: echo __asan_addr_is_in_fake_stack >> %t.interface
+
+// RUN: for i in `jot - 0 10`; do echo __asan_stack_malloc_$i >> %t.interface; done
+// RUN: for i in `jot - 0 10`; do echo __asan_stack_free_$i >> %t.interface; done
+
+// RUN: cat %t.interface | sort -u | diff %t.symbols -
+
+int main() { return 0; }
diff --git a/compiler-rt/test/asan/TestCases/Darwin/linked-only.cc b/compiler-rt/test/asan/TestCases/Darwin/linked-only.cc
new file mode 100644
index 0000000..bb19ea8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/linked-only.cc
@@ -0,0 +1,33 @@
+// Main executable is uninstrumented, but linked to ASan runtime.
+// Regression test for https://code.google.com/p/address-sanitizer/issues/detail?id=357.
+
+// RUN: %clangxx -g -O0 %s -c -o %t.o
+// RUN: %clangxx_asan -g -O0 %t.o -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sanitizer/asan_interface.h"
+
+void test_shadow(char *p, size_t size) {
+  fprintf(stderr, "p = %p\n", p);
+  char *q = (char *)__asan_region_is_poisoned(p, size);
+  fprintf(stderr, "=%zd=\n", q ? q - p : -1);
+}
+
+int main(int argc, char *argv[]) {
+  char *p = (char *)malloc(10000);
+  test_shadow(p, 100);
+  free(p);
+  // CHECK: =-1=
+
+  test_shadow((char *)&main, 1);
+  // CHECK: =-1=
+
+  test_shadow((char *)&p, 1);
+  // CHECK: =-1=
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/lit.local.cfg b/compiler-rt/test/asan/TestCases/Darwin/lit.local.cfg
new file mode 100644
index 0000000..a85dfcd
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Darwin']:
+  config.unsupported = True
diff --git a/compiler-rt/test/asan/TestCases/Darwin/malloc_set_zone_name-mprotect.cc b/compiler-rt/test/asan/TestCases/Darwin/malloc_set_zone_name-mprotect.cc
new file mode 100644
index 0000000..2c643bc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/malloc_set_zone_name-mprotect.cc
@@ -0,0 +1,51 @@
+// Regression test for a bug in malloc_create_zone()
+// (https://code.google.com/p/address-sanitizer/issues/detail?id=203)
+// The old implementation of malloc_create_zone() didn't always return a
+// page-aligned address, so we can only test on a best-effort basis.
+
+// RUN: %clangxx_asan %s -o %t
+// RUN: %run %t 2>&1
+
+#include <malloc/malloc.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+const int kNumIter = 4096;
+const int kNumZones = 100;
+int main() {
+  char *mem[kNumIter * 2];
+  // Allocate memory chunks from different size classes up to 1 page.
+  // (For the case malloc() returns memory chunks in descending order)
+  for (int i = 0; i < kNumIter; i++) {
+    mem[i] = (char*)malloc(8 * i);
+  }
+  // Try to allocate a page-aligned malloc zone. Otherwise the mprotect() call
+  // in malloc_set_zone_name() will silently fail.
+  malloc_zone_t *zone = NULL;
+  bool aligned = false;
+  for (int i = 0; i < kNumZones; i++) {
+    zone = malloc_create_zone(0, 0);
+    if (((uintptr_t)zone & (~0xfff)) == (uintptr_t)zone) {
+      aligned = true;
+      break;
+    }
+  }
+  if (!aligned) {
+    printf("Warning: couldn't allocate a page-aligned zone.");
+    return 0;
+  }
+  // malloc_set_zone_name() calls mprotect(zone, 4096, PROT_READ | PROT_WRITE),
+  // modifies the zone contents and then calls mprotect(zone, 4096, PROT_READ).
+  malloc_set_zone_name(zone, "foobar");
+  // Allocate memory chunks from different size classes again.
+  for (int i = 0; i < kNumIter; i++) {
+    mem[i + kNumIter] = (char*)malloc(8 * i);
+  }
+  // Access the allocated memory chunks and free them.
+  for (int i = 0; i < kNumIter * 2; i++) {
+    memset(mem[i], 'a', 8 * (i % kNumIter));
+    free(mem[i]);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/malloc_zone-protected.cc b/compiler-rt/test/asan/TestCases/Darwin/malloc_zone-protected.cc
new file mode 100644
index 0000000..362b60e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/malloc_zone-protected.cc
@@ -0,0 +1,20 @@
+// Make sure the zones created by malloc_create_zone() are write-protected.
+#include <malloc/malloc.h>
+#include <stdio.h>
+
+// RUN: %clangxx_asan %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+
+void *pwn(malloc_zone_t *unused_zone, size_t unused_size) {
+  printf("PWNED\n");
+  return NULL;
+}
+
+int main() {
+  malloc_zone_t *zone = malloc_create_zone(0, 0);
+  zone->malloc = pwn;
+  void *v = malloc_zone_malloc(zone, 1);
+  // CHECK-NOT: PWNED
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/mixing-global-constructors.cc b/compiler-rt/test/asan/TestCases/Darwin/mixing-global-constructors.cc
new file mode 100644
index 0000000..0b0f15c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/mixing-global-constructors.cc
@@ -0,0 +1,42 @@
+// A global constructor from a non-instrumented part calls a function
+// in an instrumented part.
+// Regression test for https://code.google.com/p/address-sanitizer/issues/detail?id=363.
+
+// RUN: %clangxx      -DINSTRUMENTED_PART=0 -c %s -o %t-uninst.o
+// RUN: %clangxx_asan -DINSTRUMENTED_PART=1 -c %s -o %t-inst.o
+// RUN: %clangxx_asan %t-uninst.o %t-inst.o -o %t
+
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void func(char *ptr);
+
+#if INSTRUMENTED_PART == 1
+
+void func(char *ptr) {
+  *ptr = 'X';
+}
+
+#else // INSTRUMENTED_PART == 1
+
+struct C1 {
+  C1() {
+    printf("Hello ");
+    char buffer[10] = "world";
+    func(buffer);
+    printf("%s\n", buffer);
+  }
+};
+
+C1 *obj = new C1();
+
+int main(int argc, const char *argv[]) {
+  return 0;
+}
+
+#endif // INSTRUMENTED_PART == 1
+
+// CHECK: Hello Xorld
diff --git a/compiler-rt/test/asan/TestCases/Darwin/objc-odr.mm b/compiler-rt/test/asan/TestCases/Darwin/objc-odr.mm
new file mode 100644
index 0000000..72bc39c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/objc-odr.mm
@@ -0,0 +1,23 @@
+// Regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=360.
+
+// RUN: %clang_asan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+void f() {
+    int y = 7;
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            printf("num = %d\n", y);
+        });
+    });
+}
+
+int main() {
+  NSLog(@"Hello world");
+}
+
+// CHECK-NOT: AddressSanitizer: odr-violation
+// CHECK: Hello world
diff --git a/compiler-rt/test/asan/TestCases/Darwin/reexec-insert-libraries-env.cc b/compiler-rt/test/asan/TestCases/Darwin/reexec-insert-libraries-env.cc
new file mode 100644
index 0000000..aa4d92b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/reexec-insert-libraries-env.cc
@@ -0,0 +1,25 @@
+// Make sure ASan doesn't hang in an exec loop if DYLD_INSERT_LIBRARIES is set.
+// This is a regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=159
+
+// RUN: %clangxx_asan %s -o %t
+// RUN: %clangxx -DSHARED_LIB %s \
+// RUN:     -dynamiclib -o darwin-dummy-shared-lib-so.dylib
+
+// FIXME: the following command line may hang in the case of a regression.
+// RUN: env DYLD_INSERT_LIBRARIES=darwin-dummy-shared-lib-so.dylib \
+// RUN:     %run %t 2>&1 | FileCheck %s || exit 1
+
+#if !defined(SHARED_LIB)
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  const char kEnvName[] = "DYLD_INSERT_LIBRARIES";
+  printf("%s=%s\n", kEnvName, getenv(kEnvName));
+  // CHECK: {{DYLD_INSERT_LIBRARIES=.*darwin-dummy-shared-lib-so.dylib.*}}
+  return 0;
+}
+#else  // SHARED_LIB
+void foo() {}
+#endif  // SHARED_LIB
diff --git a/compiler-rt/test/asan/TestCases/Darwin/sandbox-symbolizer.cc b/compiler-rt/test/asan/TestCases/Darwin/sandbox-symbolizer.cc
new file mode 100644
index 0000000..4310f9c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/sandbox-symbolizer.cc
@@ -0,0 +1,29 @@
+// In a non-forking sandbox, we can't spawn an external symbolizer, but dladdr()
+// should still work and provide function names. No line numbers though.
+// Second, `atos` symbolizer can't inspect a process that has an inaccessible
+// task port, in which case we should again fallback to dladdr gracefully.
+
+// RUN: %clangxx_asan -O0 %s -o %t 
+// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s
+// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
+// RUN: env ASAN_SYMBOLIZER_PATH="" not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t 
+// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s
+// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
+// RUN: env ASAN_SYMBOLIZER_PATH="" not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+  // CHECK: {{READ of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main}}
+  // CHECK: {{freed by thread T0 here:}}
+  // CHECK: {{    #0 0x.* in wrap_free}}
+  // CHECK: {{    #1 0x.* in main}}
+  // CHECK: {{previously allocated by thread T0 here:}}
+  // CHECK: {{    #0 0x.* in wrap_malloc}}
+  // CHECK: {{    #1 0x.* in main}}
+}
diff --git a/compiler-rt/test/asan/TestCases/Darwin/suppressions-darwin.cc b/compiler-rt/test/asan/TestCases/Darwin/suppressions-darwin.cc
new file mode 100644
index 0000000..403d819
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/suppressions-darwin.cc
@@ -0,0 +1,34 @@
+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t -framework Foundation
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// Check that suppressing the interceptor by name works.
+// RUN: echo "interceptor_name:memmove" > %t.supp
+// RUN: %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// Check that suppressing by interceptor name works even without the symbolizer
+// RUN: %env_asan_opts=suppressions='"%t.supp"':symbolize=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// Check that suppressing all reports from a library works.
+// RUN: echo "interceptor_via_lib:CoreFoundation" > %t.supp
+// RUN: %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// Check that suppressing library works even without the symbolizer.
+// RUN: %env_asan_opts=suppressions='"%t.supp"':symbolize=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+#include <CoreFoundation/CoreFoundation.h>
+
+int main() {
+  char *a = (char *)malloc(6);
+  strcpy(a, "hello");
+  CFStringRef str =
+      CFStringCreateWithBytes(kCFAllocatorDefault, (unsigned char *)a, 10,
+                              kCFStringEncodingUTF8, FALSE); // BOOM
+  fprintf(stderr, "Ignored.\n");
+  free(a);
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-buffer-overflow
+// CHECK-CRASH-NOT: Ignored.
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-buffer-overflow
+// CHECK-IGNORE: Ignored.
diff --git a/compiler-rt/test/asan/TestCases/Darwin/suppressions-sandbox.cc b/compiler-rt/test/asan/TestCases/Darwin/suppressions-sandbox.cc
new file mode 100644
index 0000000..ddbad46
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/suppressions-sandbox.cc
@@ -0,0 +1,26 @@
+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t -framework Foundation
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// Check that suppressing a function name works within a no-fork sandbox
+// RUN: echo "interceptor_via_fun:CFStringCreateWithBytes" > %t.supp
+// RUN: %env_asan_opts=suppressions='"%t.supp"' \
+// RUN:   sandbox-exec -p '(version 1)(allow default)(deny process-fork)' \
+// RUN:   %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+#include <CoreFoundation/CoreFoundation.h>
+
+int main() {
+  char *a = (char *)malloc(6);
+  strcpy(a, "hello");
+  CFStringRef str =
+      CFStringCreateWithBytes(kCFAllocatorDefault, (unsigned char *)a, 10,
+                              kCFStringEncodingUTF8, FALSE);  // BOOM
+  fprintf(stderr, "Ignored.\n");
+  free(a);
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-buffer-overflow
+// CHECK-CRASH-NOT: Ignored.
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-buffer-overflow
+// CHECK-IGNORE: Ignored.
diff --git a/compiler-rt/test/asan/TestCases/Darwin/unset-insert-libraries-on-exec.cc b/compiler-rt/test/asan/TestCases/Darwin/unset-insert-libraries-on-exec.cc
new file mode 100644
index 0000000..f8a330a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Darwin/unset-insert-libraries-on-exec.cc
@@ -0,0 +1,25 @@
+// Make sure ASan removes the runtime library from DYLD_INSERT_LIBRARIES before
+// executing other programs.
+
+// RUN: %clangxx_asan %s -o %t
+// RUN: %clangxx %p/../Helpers/echo-env.cc -o %T/echo-env
+// RUN: %clangxx -DSHARED_LIB %s \
+// RUN:     -dynamiclib -o %t-darwin-dummy-shared-lib-so.dylib
+
+// Make sure DYLD_INSERT_LIBRARIES doesn't contain the runtime library before
+// execl().
+
+// RUN: %run %t %T/echo-env >/dev/null 2>&1
+// RUN: env DYLD_INSERT_LIBRARIES=%t-darwin-dummy-shared-lib-so.dylib \
+// RUN:     %run %t %T/echo-env 2>&1 | FileCheck %s || exit 1
+
+#if !defined(SHARED_LIB)
+#include <unistd.h>
+int main(int argc, char *argv[]) {
+  execl(argv[1], argv[1], "DYLD_INSERT_LIBRARIES", NULL);
+  // CHECK:  {{DYLD_INSERT_LIBRARIES = .*darwin-dummy-shared-lib-so.dylib.*}}
+  return 0;
+}
+#else  // SHARED_LIB
+void foo() {}
+#endif  // SHARED_LIB
diff --git a/compiler-rt/test/asan/TestCases/Helpers/blacklist-extra.cc b/compiler-rt/test/asan/TestCases/Helpers/blacklist-extra.cc
new file mode 100644
index 0000000..627115c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/blacklist-extra.cc
@@ -0,0 +1,5 @@
+// This function is broken, but this file is blacklisted
+int externalBrokenFunction(int argc) {
+  char x[10] = {0};
+  return x[argc * 10];  // BOOM
+}
diff --git a/compiler-rt/test/asan/TestCases/Helpers/echo-env.cc b/compiler-rt/test/asan/TestCases/Helpers/echo-env.cc
new file mode 100644
index 0000000..65e91c1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/echo-env.cc
@@ -0,0 +1,19 @@
+// Helper binary for
+// lit_tests/TestCases/Darwin/unset-insert-libraries-on-exec.cc
+// Prints the environment variable with the given name.
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  if (argc != 2) {
+    printf("Usage: %s ENVNAME\n", argv[0]);
+    exit(1);
+  }
+  const char *value = getenv(argv[1]);
+  if (value) {
+    printf("%s = %s\n", argv[1], value);
+  } else {
+    printf("%s not set.\n", argv[1]);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Helpers/init-order-atexit-extra.cc b/compiler-rt/test/asan/TestCases/Helpers/init-order-atexit-extra.cc
new file mode 100644
index 0000000..e4189d1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/init-order-atexit-extra.cc
@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+class C {
+ public:
+  C() { value = 42; }
+  ~C() { }
+  int value;
+};
+
+C c;
+
+void AccessC() {
+  printf("C value: %d\n", c.value);
+}
+
+int main() { return 0; }
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist-extra.cc b/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist-extra.cc
new file mode 100644
index 0000000..09aed21
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist-extra.cc
@@ -0,0 +1,15 @@
+int zero_init() { return 0; }
+int badGlobal = zero_init();
+int readBadGlobal() { return badGlobal; }
+
+namespace badNamespace {
+class BadClass {
+ public:
+  BadClass() { value = 0; }
+  int value;
+};
+// Global object with non-trivial constructor.
+BadClass bad_object;
+}  // namespace badNamespace
+
+int accessBadObject() { return badNamespace::bad_object.value; }
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist-extra2.cc b/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist-extra2.cc
new file mode 100644
index 0000000..69455a0
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist-extra2.cc
@@ -0,0 +1,4 @@
+int zero_init();
+int badSrcGlobal = zero_init();
+int readBadSrcGlobal() { return badSrcGlobal; }
+
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist.txt b/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist.txt
new file mode 100644
index 0000000..8329463
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-blacklist.txt
@@ -0,0 +1,3 @@
+global:*badGlobal*=init
+type:*badNamespace::BadClass*=init
+src:*initialization-blacklist-extra2.cc=init
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-bug-extra.cc b/compiler-rt/test/asan/TestCases/Helpers/initialization-bug-extra.cc
new file mode 100644
index 0000000..3c4cb41
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-bug-extra.cc
@@ -0,0 +1,5 @@
+// This file simply declares a dynamically initialized var by the name of 'y'.
+int initY() {
+  return 5;
+}
+int y = initY();
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-bug-extra2.cc b/compiler-rt/test/asan/TestCases/Helpers/initialization-bug-extra2.cc
new file mode 100644
index 0000000..a3d8f19
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-bug-extra2.cc
@@ -0,0 +1,6 @@
+// 'z' is dynamically initialized global from different TU.
+extern int z;
+int __attribute__((noinline)) initY() {
+  return z + 1;
+}
+int y = initY();
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-constexpr-extra.cc b/compiler-rt/test/asan/TestCases/Helpers/initialization-constexpr-extra.cc
new file mode 100644
index 0000000..b32466a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-constexpr-extra.cc
@@ -0,0 +1,3 @@
+// Constexpr:
+int getCoolestInteger();
+static int coolest_integer = getCoolestInteger();
diff --git a/compiler-rt/test/asan/TestCases/Helpers/initialization-nobug-extra.cc b/compiler-rt/test/asan/TestCases/Helpers/initialization-nobug-extra.cc
new file mode 100644
index 0000000..886165a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/initialization-nobug-extra.cc
@@ -0,0 +1,9 @@
+// Linker initialized:
+int getAB();
+static int ab = getAB();
+// Function local statics:
+int countCalls();
+static int one = countCalls();
+// Trivial constructor, non-trivial destructor:
+int getStructWithDtorValue();
+static int val = getStructWithDtorValue();
diff --git a/compiler-rt/test/asan/TestCases/Helpers/lit.local.cfg b/compiler-rt/test/asan/TestCases/Helpers/lit.local.cfg
new file mode 100644
index 0000000..2fc4d99
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Helpers/lit.local.cfg
@@ -0,0 +1,3 @@
+# Sources in this directory are helper files for tests which test functionality
+# involving multiple translation units.
+config.suffixes = []
diff --git a/compiler-rt/test/asan/TestCases/Linux/abort_on_error.cc b/compiler-rt/test/asan/TestCases/Linux/abort_on_error.cc
new file mode 100644
index 0000000..406d98b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/abort_on_error.cc
@@ -0,0 +1,18 @@
+// Check that with empty ASAN_OPTIONS, ASan reports on Linux don't crash
+// the process (abort_on_error=0). See also Darwin/abort_on_error.cc.
+
+// RUN: %clangxx_asan %s -o %t
+
+// Intentionally don't inherit the default ASAN_OPTIONS.
+// RUN: ASAN_OPTIONS="" not %run %t 2>&1 | FileCheck %s
+// When we use lit's default ASAN_OPTIONS, we shouldn't crash either. On Linux
+// lit doesn't set ASAN_OPTIONS anyway.
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/activation-options.cc b/compiler-rt/test/asan/TestCases/Linux/activation-options.cc
new file mode 100644
index 0000000..1a1ad3f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/activation-options.cc
@@ -0,0 +1,71 @@
+// Test for ASAN_OPTIONS=start_deactivated=1 mode.
+// Main executable is uninstrumented, but linked to ASan runtime. The shared
+// library is instrumented.
+
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx -O0 %s -c -o %t.o
+// RUN: %clangxx_asan -O0 %t.o %libdl -o %t
+
+// RUN: rm -f %t.asan.options.activation-options.cc.tmp
+// RUN: rm -f %t.asan.options.ABCDE
+// RUN: echo "help=1" >%t.asan.options.activation-options.cc.tmp
+
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b %run %t 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=CHECK-HELP --check-prefix=CHECK-FOUND
+
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=include=%t.asan.options not %run %t 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=CHECK-NO-HELP --check-prefix=CHECK-MISSING
+
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b not %run %t --fix-name 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=CHECK-NO-HELP --check-prefix=CHECK-MISSING
+
+// RUN: echo "help=1" >%t.asan.options.ABCDE
+
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b %run %t --fix-name 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=CHECK-HELP --check-prefix=CHECK-FOUND
+
+// XFAIL: arm-linux-gnueabi
+// XFAIL: android
+
+#if !defined(SHARED_LIB)
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <string>
+
+#include "sanitizer/asan_interface.h"
+
+typedef void (*Fn)();
+
+int main(int argc, char *argv[]) {
+  std::string path = std::string(argv[0]) + "-so.so";
+
+  if (argc > 1 && strcmp(argv[1], "--fix-name") == 0) {
+    assert(strlen(argv[0]) > 5);
+    strcpy(argv[0], "ABCDE");
+  }
+
+  void *dso = dlopen(path.c_str(), RTLD_NOW);
+  if (!dso) {
+    fprintf(stderr, "dlopen failed: %s\n", dlerror());
+    return 1;
+  }
+
+  return 0;
+}
+#else  // SHARED_LIB
+// Empty: all we need is an ASan shared library constructor.
+#endif  // SHARED_LIB
+
+// CHECK-HELP: Available flags for {{.*}}Sanitizer:
+// CHECK-NO-HELP-NOT: Available flags for {{.*}}Sanitizer:
+// CHECK-FOUND-NOT: Failed to read options
+// CHECK-MISSING: Failed to read options
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan-asm-stacktrace-test.cc b/compiler-rt/test/asan/TestCases/Linux/asan-asm-stacktrace-test.cc
new file mode 100644
index 0000000..5332c99
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan-asm-stacktrace-test.cc
@@ -0,0 +1,33 @@
+// Check that a stack unwinding algorithm works corretly even with the assembly
+// instrumentation.
+
+// REQUIRES: x86_64-supported-target
+// RUN: %clangxx_asan -g -O1 %s -fno-inline-functions -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -mllvm -asan-instrument-assembly -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -g -O1 %s -fno-inline-functions -fomit-frame-pointer -momit-leaf-frame-pointer -mllvm -asan-instrument-assembly -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -g0 -O1 %s -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-exceptions -fno-inline-functions -fomit-frame-pointer -momit-leaf-frame-pointer -mllvm -asan-instrument-assembly -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-nounwind
+
+#include <cstddef>
+
+// CHECK: READ of size 4
+// CHECK-NEXT: {{#0 0x[0-9a-fA-F]+ in foo}}
+// CHECK-NEXT: {{#1 0x[0-9a-fA-F]+ in main}}
+
+// CHECK-nounwind: READ of size 4
+// CHECK-nounwind-NEXT: {{#0 0x[0-9a-fA-F]+ in foo}}
+
+__attribute__((noinline)) int foo(size_t n, int *buffer) {
+  int r;
+  __asm__("movl (%[buffer], %[n], 4), %[r]  \n\t"
+          : [r] "=r"(r)
+          : [buffer] "r"(buffer), [n] "r"(n)
+          : "memory");
+  return r;
+}
+
+int main() {
+  const size_t n = 16;
+  int *buffer = new int[n];
+  foo(n, buffer);
+  delete[] buffer;
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_default_suppressions.cc b/compiler-rt/test/asan/TestCases/Linux/asan_default_suppressions.cc
new file mode 100644
index 0000000..5ff59c1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_default_suppressions.cc
@@ -0,0 +1,7 @@
+// Test that we use the suppressions from __asan_default_suppressions.
+// RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
+extern "C" {
+  const char *__asan_default_suppressions() { return "FooBar"; }
+}
+// CHECK: AddressSanitizer: failed to parse suppressions
+int main() {}
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_dlopen_test.cc b/compiler-rt/test/asan/TestCases/Linux/asan_dlopen_test.cc
new file mode 100644
index 0000000..f1e31b0
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_dlopen_test.cc
@@ -0,0 +1,15 @@
+// Test that dlopen of dynamic runtime is prohibited.
+//
+// RUN: %clangxx %s -DRT=\"%shared_libasan\" -o %t -ldl
+// RUN: not %run %t 2>&1 | FileCheck %s
+// REQUIRES: asan-dynamic-runtime
+// XFAIL: android
+
+#include <dlfcn.h>
+
+int main(int argc, char **argv) {
+  dlopen(RT, RTLD_LAZY);
+  return 0;
+}
+
+// CHECK: ASan runtime does not come first in initial library list
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_prelink_test.cc b/compiler-rt/test/asan/TestCases/Linux/asan_prelink_test.cc
new file mode 100644
index 0000000..d67d945
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_prelink_test.cc
@@ -0,0 +1,29 @@
+// Test if asan works with prelink.
+// It does not actually use prelink, but relies on ld's flag -Ttext-segment
+// or gold's flag -Ttext (we try the first flag first, if that fails we
+// try the second flag).
+//
+// RUN: %clangxx_asan -c %s -o %t.o
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -Wl,-Ttext-segment=0x3600000000 ||\
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -Wl,-Ttext=0x3600000000
+// RUN: %clangxx_asan %t.o %t.so -Wl,-R. -o %t
+// RUN: %env_asan_opts=verbosity=1 %run %t 2>&1 | FileCheck %s
+
+// GNU driver doesn't handle .so files properly.
+// REQUIRES: x86_64-supported-target, asan-64-bits, Clang
+#if BUILD_SO
+int G;
+int *getG() {
+  return &G;
+}
+#else
+#include <stdio.h>
+extern int *getG();
+int main(int argc, char **argv) {
+  long p = (long)getG();
+  printf("SO mapped at %lx\n", p & ~0xffffffffUL);
+  *getG() = 0;
+}
+#endif
+// CHECK: 0x003000000000, 0x004fffffffff{{.*}} MidMem
+// CHECK: SO mapped at 3600000000
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_preload_test-1.cc b/compiler-rt/test/asan/TestCases/Linux/asan_preload_test-1.cc
new file mode 100644
index 0000000..4e365b5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_preload_test-1.cc
@@ -0,0 +1,30 @@
+// Test that non-sanitized executables work with sanitized shared libs
+// and preloaded runtime.
+//
+// RUN: %clangxx -DBUILD_SO=1 -fPIC -shared %s -o %t.so
+// RUN: %clangxx %s %t.so -o %t
+//
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so
+// RUN: env LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: asan-dynamic-runtime
+
+// This way of setting LD_PRELOAD does not work with Android test runner.
+// REQUIRES: not-android
+
+#if BUILD_SO
+char dummy;
+void do_access(const void *p) {
+  // CHECK: AddressSanitizer: heap-buffer-overflow
+  dummy = ((const char *)p)[1];
+}
+#else
+#include <stdlib.h>
+extern void do_access(const void *p);
+int main(int argc, char **argv) {
+  void *p = malloc(1);
+  do_access(p);
+  free(p);
+  return 0;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_preload_test-2.cc b/compiler-rt/test/asan/TestCases/Linux/asan_preload_test-2.cc
new file mode 100644
index 0000000..488fd52
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_preload_test-2.cc
@@ -0,0 +1,24 @@
+// Test that preloaded runtime works with unsanitized executables.
+//
+// RUN: %clangxx %s -o %t
+// RUN: env LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: asan-dynamic-runtime
+
+// This way of setting LD_PRELOAD does not work with Android test runner.
+// REQUIRES: not-android
+
+#include <stdlib.h>
+
+extern "C" ssize_t write(int fd, const void *buf, size_t count);
+
+void do_access(void *p) {
+  // CHECK: AddressSanitizer: heap-buffer-overflow
+  write(1, p, 2);
+}
+
+int main(int argc, char **argv) {
+  void *p = malloc(1);
+  do_access(p);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_rt_confict_test-1.cc b/compiler-rt/test/asan/TestCases/Linux/asan_rt_confict_test-1.cc
new file mode 100644
index 0000000..8cf761c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_rt_confict_test-1.cc
@@ -0,0 +1,13 @@
+// Test that preloading dynamic runtime to statically sanitized
+// executable is prohibited.
+//
+// RUN: %clangxx_asan_static %s -o %t
+// RUN: env LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: asan-dynamic-runtime
+// XFAIL: android
+
+#include <stdlib.h>
+int main(int argc, char **argv) { return 0; }
+
+// CHECK: Your application is linked against incompatible ASan runtimes
diff --git a/compiler-rt/test/asan/TestCases/Linux/asan_rt_confict_test-2.cc b/compiler-rt/test/asan/TestCases/Linux/asan_rt_confict_test-2.cc
new file mode 100644
index 0000000..4c935e2
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/asan_rt_confict_test-2.cc
@@ -0,0 +1,25 @@
+// Test that mixed static/dynamic sanitization of program objects
+// is prohibited.
+//
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so
+// RUN: %clangxx_asan_static %s %t.so -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: asan-dynamic-runtime
+// XFAIL: android
+
+#if BUILD_SO
+char dummy;
+void do_access(const void *p) { dummy = ((const char *)p)[1]; }
+#else
+#include <stdlib.h>
+extern void do_access(const void *p);
+int main(int argc, char **argv) {
+  void *p = malloc(1);
+  do_access(p);
+  free(p);
+  return 0;
+}
+#endif
+
+// CHECK: Your application is linked against incompatible ASan runtimes
diff --git a/compiler-rt/test/asan/TestCases/Linux/calloc-preload.c b/compiler-rt/test/asan/TestCases/Linux/calloc-preload.c
new file mode 100644
index 0000000..eb1c673
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/calloc-preload.c
@@ -0,0 +1,36 @@
+// Test that initially callocked memory is properly freed
+// (see https://github.com/google/sanitizers/issues/626).
+// 
+// RUN: %clang %s -o %t
+// RUN: env LD_PRELOAD=%shared_libasan %run %t
+//
+// REQUIRES: asan-dynamic-runtime
+//
+// This way of setting LD_PRELOAD does not work with Android test runner.
+// REQUIRES: not-android
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static void *ptr;
+
+// This constructor will run before __asan_init
+// so calloc will allocate memory from special pool.
+static void init() {
+  ptr = calloc(10, 1);
+}
+
+__attribute__((section(".preinit_array"), used))
+void *dummy = init;
+
+void free_memory() {
+  // This used to abort because
+  // Asan's free didn't recognize ptr.
+  free(ptr);
+}
+
+int main() {
+  free_memory();
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Linux/clang_gcc_abi.cc b/compiler-rt/test/asan/TestCases/Linux/clang_gcc_abi.cc
new file mode 100644
index 0000000..669d152
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/clang_gcc_abi.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_asan -O0 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: arm-supported-target
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+
+__attribute__((noinline))
+int boom() {
+  volatile int three = 3;
+  char * volatile s = (char *)malloc(three);
+// CHECK: #1 0x{{.*}} in boom {{.*}}clang_gcc_abi.cc:[[@LINE-1]]
+  return s[three]; //BOOM
+}
+
+__attribute__((naked, noinline)) void gcc_abi() {
+// CHECK: #2 0x{{.*}} in gcc_abi {{.*}}clang_gcc_abi.cc:[[@LINE+1]]
+  asm volatile("str fp, [sp, #-8]!\n\t"
+               "str lr, [sp, #4]\n\t"
+               "add fp, sp, #4\n\t"
+               "bl  boom\n\t"
+               "sub sp, fp, #4\n\t"
+               "ldr fp, [sp]\n\t"
+               "add sp, sp, #4\n\t"
+               "ldr pc, [sp], #4\n\t"
+              );
+}
+
+__attribute__((naked, noinline)) void clang_abi() {
+// CHECK: #3 0x{{.*}} in clang_abi {{.*}}clang_gcc_abi.cc:[[@LINE+1]]
+  asm volatile("push {r11, lr}\n\t"
+               "mov r11, sp\n\t"
+               "bl  gcc_abi\n\t"
+               "add r0, r0, #1\n\t"
+               "pop {r11, pc}\n\t"
+              );
+}
+
+int main() {
+  clang_abi();
+// CHECK: #4 0x{{.*}} in main {{.*}}clang_gcc_abi.cc:[[@LINE-1]]
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/clone_test.cc b/compiler-rt/test/asan/TestCases/Linux/clone_test.cc
new file mode 100644
index 0000000..e9c1f16
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/clone_test.cc
@@ -0,0 +1,45 @@
+// Regression test for:
+// http://code.google.com/p/address-sanitizer/issues/detail?id=37
+
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && %run %t | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+
+#include <stdio.h>
+#include <sched.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int Child(void *arg) {
+  char x[32] = {0};  // Stack gets poisoned.
+  printf("Child:  %p\n", x);
+  _exit(1);  // NoReturn, stack will remain unpoisoned unless we do something.
+}
+
+int main(int argc, char **argv) {
+  const int kStackSize = 1 << 20;
+  char child_stack[kStackSize + 1];
+  char *sp = child_stack + kStackSize;  // Stack grows down.
+  printf("Parent: %p\n", sp);
+  pid_t clone_pid = clone(Child, sp, CLONE_FILES | CLONE_VM, NULL);
+  int status;
+  pid_t wait_result = waitpid(clone_pid, &status, __WCLONE);
+  if (wait_result < 0) {
+    perror("waitpid");
+    return 0;
+  }
+  if (wait_result == clone_pid && WIFEXITED(status)) {
+    // Make sure the child stack was indeed unpoisoned.
+    for (int i = 0; i < kStackSize; i++)
+      child_stack[i] = i;
+    int ret = child_stack[argc - 1];
+    printf("PASSED\n");
+    // CHECK: PASSED
+    return ret;
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/coverage-missing.cc b/compiler-rt/test/asan/TestCases/Linux/coverage-missing.cc
new file mode 100644
index 0000000..6cd3201
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/coverage-missing.cc
@@ -0,0 +1,82 @@
+// Test for "sancov.py missing ...".
+
+// First case: coverage from executable. main() is called on every code path.
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t -DFOOBAR -DMAIN
+// RUN: rm -rf %T/coverage-missing
+// RUN: mkdir -p %T/coverage-missing
+// RUN: cd %T/coverage-missing
+// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t
+// RUN: %sancov print *.sancov > main.txt
+// RUN: rm *.sancov
+// RUN: [ $(cat main.txt | wc -l) == 1 ]
+// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x
+// RUN: %sancov print *.sancov > foo.txt
+// RUN: rm *.sancov
+// RUN: [ $(cat foo.txt | wc -l) == 3 ]
+// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x x
+// RUN: %sancov print *.sancov > bar.txt
+// RUN: rm *.sancov
+// RUN: [ $(cat bar.txt | wc -l) == 4 ]
+// RUN: %sancov missing %t < foo.txt > foo-missing.txt
+// RUN: sort main.txt foo-missing.txt -o foo-missing-with-main.txt
+// The "missing from foo" set may contain a few bogus PCs from the sanitizer
+// runtime, but it must include the entire "bar" code path as a subset. Sorted
+// lists can be tested for set inclusion with diff + grep.
+// RUN: ( diff bar.txt foo-missing-with-main.txt || true ) | not grep "^<"
+
+// Second case: coverage from DSO.
+// cd %T
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %dynamiclib -DFOOBAR -shared -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func %s %dynamiclib -o %t -DMAIN
+// RUN: export LIBNAME=`basename %dynamiclib`
+// RUN: rm -rf %T/coverage-missing
+// RUN: mkdir -p %T/coverage-missing
+// RUN: cd %T/coverage-missing
+// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x
+// RUN: %sancov print $LIBNAME.*.sancov > foo.txt
+// RUN: rm *.sancov
+// RUN: [ $(cat foo.txt | wc -l) == 2 ]
+// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x x
+// RUN: %sancov print $LIBNAME.*.sancov > bar.txt
+// RUN: rm *.sancov
+// RUN: [ $(cat bar.txt | wc -l) == 3 ]
+// RUN: %sancov missing %dynamiclib < foo.txt > foo-missing.txt
+// RUN: ( diff bar.txt foo-missing.txt || true ) | not grep "^<"
+
+// REQUIRES: x86_64-supported-target, i386-supported-target
+// XFAIL: android
+
+#include <stdio.h>
+
+void foo1();
+void foo2();
+void bar1();
+void bar2();
+void bar3();
+
+#if defined(FOOBAR)
+void foo1() { fprintf(stderr, "foo1\n"); }
+void foo2() { fprintf(stderr, "foo2\n"); }
+
+void bar1() { fprintf(stderr, "bar1\n"); }
+void bar2() { fprintf(stderr, "bar2\n"); }
+void bar3() { fprintf(stderr, "bar3\n"); }
+#endif
+
+#if defined(MAIN)
+int main(int argc, char **argv) {
+  switch (argc) {
+    case 1:
+      break;
+    case 2:
+      foo1();
+      foo2();
+      break;
+    case 3:
+      bar1();
+      bar2();
+      bar3();
+      break;
+  }
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Linux/function-sections-are-bad.cc b/compiler-rt/test/asan/TestCases/Linux/function-sections-are-bad.cc
new file mode 100644
index 0000000..15aaccb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/function-sections-are-bad.cc
@@ -0,0 +1,41 @@
+// Check that --gc-sections does not throw away (or localize) parts of sanitizer
+// interface.
+// RUN: %clang_asan %s -Wl,--gc-sections -ldl -o %t
+// RUN: %clang_asan %s -DBUILD_SO -fPIC -o %t-so.so -shared
+// RUN: %run %t 2>&1
+
+// REQUIRES: asan-64-bits
+
+#ifndef BUILD_SO
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  char path[4096];
+  snprintf(path, sizeof(path), "%s-so.so", argv[0]);
+
+  void *handle = dlopen(path, RTLD_LAZY);
+  if (!handle) fprintf(stderr, "%s\n", dlerror());
+  assert(handle != 0);
+
+  typedef void (*F)();
+  F f = (F)dlsym(handle, "call_rtl_from_dso");
+  printf("%s\n", dlerror());
+  assert(dlerror() == 0);
+  f();
+  
+  dlclose(handle);
+  return 0;
+}
+
+#else // BUILD_SO
+
+#include <sanitizer/asan_interface.h>
+extern "C" void call_rtl_from_dso() {
+  volatile int32_t x;
+  volatile int32_t y = __sanitizer_unaligned_load32((void *)&x);
+}
+
+#endif // BUILD_SO
diff --git a/compiler-rt/test/asan/TestCases/Linux/globals-gc-sections.cc b/compiler-rt/test/asan/TestCases/Linux/globals-gc-sections.cc
new file mode 100644
index 0000000..72a9e94
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/globals-gc-sections.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx_asan %s -o %t -Wl,--gc-sections -ffunction-sections -mllvm -asan-globals=0
+// RUN: %clangxx_asan %s -o %t -Wl,--gc-sections -ffunction-sections -mllvm -asan-globals=1
+
+// https://code.google.com/p/address-sanitizer/issues/detail?id=260
+// XFAIL: *
+
+int undefined();
+
+int (*unused)() = undefined;
+
+int main() {
+        return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/init-order-dlopen.cc b/compiler-rt/test/asan/TestCases/Linux/init-order-dlopen.cc
new file mode 100644
index 0000000..d469b98
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/init-order-dlopen.cc
@@ -0,0 +1,47 @@
+// Regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=178
+
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O0 %s %libdl -Wl,--export-dynamic -o %t
+// RUN: %env_asan_opts=strict_init_order=true %run %t 2>&1
+
+// dlopen() can not be intercepted on Android, making strict_init_order nearly
+// useless there.
+// UNSUPPORTED: android
+
+#if defined(SHARED_LIB)
+#include <stdio.h>
+
+struct Bar {
+  Bar(int val) : val(val) { printf("Bar::Bar(%d)\n", val); }
+  int val;
+};
+
+int get_foo_val();
+Bar global_bar(get_foo_val());
+#else  // SHARED LIB
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string>
+struct Foo {
+  Foo() : val(42) { printf("Foo::Foo()\n"); }
+  int val;
+};
+
+Foo global_foo;
+
+int get_foo_val() {
+  return global_foo.val;
+}
+
+int main(int argc, char *argv[]) {
+  std::string path = std::string(argv[0]) + "-so.so";
+  void *handle = dlopen(path.c_str(), RTLD_NOW);
+  if (!handle) {
+    printf("error in dlopen(): %s\n", dlerror());
+    return 1;
+  }
+  printf("%d\n", get_foo_val());
+  return 0;
+}
+#endif  // SHARED_LIB
diff --git a/compiler-rt/test/asan/TestCases/Linux/init_fini_sections.cc b/compiler-rt/test/asan/TestCases/Linux/init_fini_sections.cc
new file mode 100644
index 0000000..c7234ee
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/init_fini_sections.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_asan %s -o %t && %run %t | FileCheck %s
+
+#include <stdio.h>
+
+static void foo() {
+  printf("foo\n");
+}
+
+int main() {
+  return 0;
+}
+
+__attribute__((section(".preinit_array")))
+void (*call_foo)(void) = &foo;
+
+__attribute__((section(".init_array")))
+void (*call_foo_2)(void) = &foo;
+
+__attribute__((section(".fini_array")))
+void (*call_foo_3)(void) = &foo;
+
+// CHECK: foo
+// CHECK: foo
+// CHECK: foo
diff --git a/compiler-rt/test/asan/TestCases/Linux/initialization-bug-any-order.cc b/compiler-rt/test/asan/TestCases/Linux/initialization-bug-any-order.cc
new file mode 100644
index 0000000..85fefd4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/initialization-bug-any-order.cc
@@ -0,0 +1,36 @@
+// Test to make sure basic initialization order errors are caught.
+// Check that on Linux initialization order bugs are caught
+// independently on order in which we list source files (if we specify
+// strict init-order checking).
+
+// RUN: %clangxx_asan -O0 %s %p/../Helpers/initialization-bug-extra.cc -o %t
+// RUN: %env_asan_opts=strict_init_order=true not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %p/../Helpers/initialization-bug-extra.cc %s -o %t
+// RUN: %env_asan_opts=strict_init_order=true not %run %t 2>&1 | FileCheck %s
+
+// Do not test with optimization -- the error may be optimized away.
+
+#include <cstdio>
+
+// 'y' is a dynamically initialized global residing in a different TU.  This
+// dynamic initializer will read the value of 'y' before main starts.  The
+// result is undefined behavior, which should be caught by initialization order
+// checking.
+extern int y;
+int __attribute__((noinline)) initX() {
+  return y + 1;
+  // CHECK: {{AddressSanitizer: initialization-order-fiasco}}
+  // CHECK: {{READ of size .* at 0x.* thread T0}}
+  // CHECK: {{#0 0x.* in .*initX.* .*initialization-bug-any-order.cc:}}[[@LINE-3]]
+  // CHECK: {{0x.* is located 0 bytes inside of global variable .*y.*}}
+}
+
+// This initializer begins our initialization order problems.
+static int x = initX();
+
+int main() {
+  // ASan should have caused an exit before main runs.
+  printf("PASS\n");
+  // CHECK-NOT: PASS
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/interception_malloc_test.cc b/compiler-rt/test/asan/TestCases/Linux/interception_malloc_test.cc
new file mode 100644
index 0000000..f6d6d34
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/interception_malloc_test.cc
@@ -0,0 +1,23 @@
+// ASan interceptor can be accessed with __interceptor_ prefix.
+
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+extern "C" void *__interceptor_malloc(size_t size);
+extern "C" void *malloc(size_t size) {
+  write(2, "malloc call\n", sizeof("malloc call\n") - 1);
+  return __interceptor_malloc(size);
+}
+
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return (int)strtol(x, 0, 10);
+  // CHECK: malloc call
+  // CHECK: heap-use-after-free
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/interception_readdir_r_test.cc b/compiler-rt/test/asan/TestCases/Linux/interception_readdir_r_test.cc
new file mode 100644
index 0000000..93b553c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/interception_readdir_r_test.cc
@@ -0,0 +1,62 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx_asan -O0 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+//
+// RUN: %clangxx_asan -O0 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <dirent.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+int main() {
+  // Ensure the readdir_r interceptor doesn't erroneously mark the entire dirent
+  // as written when the end of the directory pointer is reached.
+  fputs("test1: reading the " TEMP_DIR " directory...\n", stderr);
+  DIR *d = opendir(TEMP_DIR);
+  struct dirent *result = (struct dirent *)(0xfeedbeef);
+  // We assume the temp dir for this test doesn't have crazy long file names.
+  char entry_buffer[4096];
+  memset(entry_buffer, 0xab, sizeof(entry_buffer));
+  unsigned count = 0;
+  do {
+    // Stamp the entry struct to try to trick the interceptor.
+    ((struct dirent *)entry_buffer)->d_reclen = 9999;
+    if (readdir_r(d, (struct dirent *)entry_buffer, &result) != 0)
+      abort();
+    ++count;
+  } while (result != NULL);
+  fprintf(stderr, "read %d entries\n", count);
+  closedir(d);
+  // CHECK: test1: reading the {{.*}} directory...
+  // CHECK-NOT: stack-buffer-overflow
+  // CHECK: read {{.*}} entries
+
+  // Ensure the readdir64_r interceptor doesn't have the bug either.
+  fputs("test2: reading the " TEMP_DIR " directory...\n", stderr);
+  d = opendir(TEMP_DIR);
+  struct dirent64 *result64;
+  memset(entry_buffer, 0xab, sizeof(entry_buffer));
+  count = 0;
+  do {
+    // Stamp the entry struct to try to trick the interceptor.
+    ((struct dirent64 *)entry_buffer)->d_reclen = 9999;
+    if (readdir64_r(d, (struct dirent64 *)entry_buffer, &result64) != 0)
+      abort();
+    ++count;
+  } while (result64 != NULL);
+  fprintf(stderr, "read %d entries\n", count);
+  closedir(d);
+  // CHECK: test2: reading the {{.*}} directory...
+  // CHECK-NOT: stack-buffer-overflow
+  // CHECK: read {{.*}} entries
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/interception_test.cc b/compiler-rt/test/asan/TestCases/Linux/interception_test.cc
new file mode 100644
index 0000000..fb9d01c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/interception_test.cc
@@ -0,0 +1,22 @@
+// ASan interceptor can be accessed with __interceptor_ prefix.
+
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+#include <stdlib.h>
+#include <stdio.h>
+
+extern "C" long __interceptor_strtol(const char *nptr, char **endptr, int base);
+extern "C" long strtol(const char *nptr, char **endptr, int base) {
+  fprintf(stderr, "my_strtol_interceptor\n");
+  return __interceptor_strtol(nptr, endptr, base);
+}
+
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return (int)strtol(x, 0, 10);
+  // CHECK: my_strtol_interceptor
+  // CHECK: heap-use-after-free
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.c b/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.c
new file mode 100644
index 0000000..971feb5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.c
@@ -0,0 +1,61 @@
+// Check the presence of interface symbols in compiled file.
+
+// RUN: %clang_asan -O2 %s -o %t.exe
+// RUN: nm -D %t.exe | grep " T " | sed "s/.* T //" \
+// RUN:    | grep "__asan_" | sed "s/___asan_/__asan_/" \
+// RUN:    | sed -E "s/__asan_version_mismatch_check_v[0-9]+/__asan_version_mismatch_check/" \
+// RUN:    | grep -v "__asan_default_options" \
+// RUN:    | grep -v "__asan_stack_" \
+// RUN:    | grep -v "__asan_on_error" > %t.symbols
+// RUN: cat %p/../../../../lib/asan/asan_interface_internal.h \
+// RUN:    | sed "s/\/\/.*//" | sed "s/typedef.*//" \
+// RUN:    | grep -v "OPTIONAL" \
+// RUN:    | grep "__asan_.*(" | sed "s/.* __asan_/__asan_/;s/(.*//" \
+// RUN:    > %t.interface
+// RUN: echo __asan_report_load1 >> %t.interface
+// RUN: echo __asan_report_load2 >> %t.interface
+// RUN: echo __asan_report_load4 >> %t.interface
+// RUN: echo __asan_report_load8 >> %t.interface
+// RUN: echo __asan_report_load16 >> %t.interface
+// RUN: echo __asan_report_store1 >> %t.interface
+// RUN: echo __asan_report_store2 >> %t.interface
+// RUN: echo __asan_report_store4 >> %t.interface
+// RUN: echo __asan_report_store8 >> %t.interface
+// RUN: echo __asan_report_store16 >> %t.interface
+// RUN: echo __asan_report_load_n >> %t.interface
+// RUN: echo __asan_report_store_n >> %t.interface
+// RUN: echo __asan_report_load1_noabort >> %t.interface
+// RUN: echo __asan_report_load2_noabort >> %t.interface
+// RUN: echo __asan_report_load4_noabort >> %t.interface
+// RUN: echo __asan_report_load8_noabort >> %t.interface
+// RUN: echo __asan_report_load16_noabort >> %t.interface
+// RUN: echo __asan_report_store1_noabort >> %t.interface
+// RUN: echo __asan_report_store2_noabort >> %t.interface
+// RUN: echo __asan_report_store4_noabort >> %t.interface
+// RUN: echo __asan_report_store8_noabort >> %t.interface
+// RUN: echo __asan_report_store16_noabort >> %t.interface
+// RUN: echo __asan_report_load_n_noabort >> %t.interface
+// RUN: echo __asan_report_store_n_noabort >> %t.interface
+// RUN: echo __asan_report_exp_load1 >> %t.interface
+// RUN: echo __asan_report_exp_load2 >> %t.interface
+// RUN: echo __asan_report_exp_load4 >> %t.interface
+// RUN: echo __asan_report_exp_load8 >> %t.interface
+// RUN: echo __asan_report_exp_load16 >> %t.interface
+// RUN: echo __asan_report_exp_store1 >> %t.interface
+// RUN: echo __asan_report_exp_store2 >> %t.interface
+// RUN: echo __asan_report_exp_store4 >> %t.interface
+// RUN: echo __asan_report_exp_store8 >> %t.interface
+// RUN: echo __asan_report_exp_store16 >> %t.interface
+// RUN: echo __asan_report_exp_load_n >> %t.interface
+// RUN: echo __asan_report_exp_store_n >> %t.interface
+// RUN: echo __asan_get_current_fake_stack >> %t.interface
+// RUN: echo __asan_addr_is_in_fake_stack >> %t.interface
+// RUN: echo __asan_alloca_poison >> %t.interface
+// RUN: echo __asan_allocas_unpoison >> %t.interface
+// RUN: cat %t.interface | sort -u | diff %t.symbols -
+
+// FIXME: nm -D on powerpc somewhy shows ASan interface symbols residing
+// in "initialized data section".
+// REQUIRES: x86_64-supported-target,i386-supported-target,asan-static-runtime
+
+int main() { return 0; }
diff --git a/compiler-rt/test/asan/TestCases/Linux/kernel-area.cc b/compiler-rt/test/asan/TestCases/Linux/kernel-area.cc
new file mode 100644
index 0000000..c0f1727
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/kernel-area.cc
@@ -0,0 +1,24 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// Test that kernel area is not sanitized on 32-bit machines.
+//
+// RUN: %clangxx_asan %s -o %t
+// RUN: %env_asan_opts=verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
+// RUN: %env_asan_opts=verbosity=1:full_address_space=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
+// RUN: %env_asan_opts=verbosity=1:full_address_space=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-kernel-64-bits
+//
+// CHECK-kernel-32-bits: || `[0x38{{0+}}, 0xb{{f+}}]` || HighMem    ||
+// CHECK-kernel-32-bits: || `[0x27{{0+}}, 0x37{{f+}}]` || HighShadow ||
+// CHECK-kernel-32-bits: || `[0x24{{0+}}, 0x26{{f+}}]` || ShadowGap  ||
+//
+// CHECK-kernel-64-bits: || `[0x4{{0+}}, 0x{{f+}}]` || HighMem    ||
+// CHECK-kernel-64-bits: || `[0x28{{0+}}, 0x3{{f+}}]` || HighShadow ||
+// CHECK-kernel-64-bits: || `[0x24{{0+}}, 0x27{{f+}}]` || ShadowGap  ||
+//
+// REQUIRES: asan-32-bits,i386-supported-target
+
+int main() {
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Linux/leak.cc b/compiler-rt/test/asan/TestCases/Linux/leak.cc
new file mode 100644
index 0000000..e22cd6e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/leak.cc
@@ -0,0 +1,16 @@
+// Minimal test for LeakSanitizer+AddressSanitizer.
+// REQUIRES: leak-detection
+//
+// RUN: %clangxx_asan  %s -o %t
+// RUN: %env_asan_opts=detect_leaks=1 not %run %t  2>&1 | FileCheck %s
+// RUN: not %run %t  2>&1 | FileCheck %s
+// RUN: %env_asan_opts=detect_leaks=0     %run %t
+#include <stdio.h>
+int *t;
+
+int main(int argc, char **argv) {
+  t = new int[argc - 1];
+  printf("t: %p\n", t);
+  t = 0;
+}
+// CHECK: LeakSanitizer: detected memory leaks
diff --git a/compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cc b/compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cc
new file mode 100644
index 0000000..8160d5f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cc
@@ -0,0 +1,23 @@
+// Test that SIGSEGV during leak checking does not crash the process.
+// RUN: %clangxx_asan -O1 %s -o %t && LSAN_OPTIONS="verbosity=1" not %run %t 2>&1
+// REQUIRES: leak-detection
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sanitizer/lsan_interface.h>
+
+char data[10 * 1024 * 1024];
+
+int main() {
+  void *p = malloc(10 * 1024 * 1024);
+  // surprise-surprise!
+  mprotect((void*)(((unsigned long)p + 4095) & ~4095), 16 * 1024, PROT_NONE); 
+  mprotect((void*)(((unsigned long)data + 4095) & ~4095), 16 * 1024, PROT_NONE);
+  __lsan_do_leak_check();
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: Tracer caught signal 11
+// CHECK: LeakSanitizer has encountered a fatal error
+// CHECK-NOT: DONE
+
diff --git a/compiler-rt/test/asan/TestCases/Linux/lit.local.cfg b/compiler-rt/test/asan/TestCases/Linux/lit.local.cfg
new file mode 100644
index 0000000..57271b8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/asan/TestCases/Linux/malloc-in-qsort.cc b/compiler-rt/test/asan/TestCases/Linux/malloc-in-qsort.cc
new file mode 100644
index 0000000..e8c9b74
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/malloc-in-qsort.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %env_asan_opts=fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
+
+// Test how well we unwind in presence of qsort in the stack
+// (i.e. if we can unwind through a function compiled w/o frame pointers).
+// https://code.google.com/p/address-sanitizer/issues/detail?id=137
+
+// Fast unwinder is only available on x86_64 and i386.
+// REQUIRES: x86_64-supported-target
+
+// REQUIRES: compiler-rt-optimized
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int *GlobalPtr;
+
+extern "C" {
+int QsortCallback(const void *a, const void *b) {
+  char *x = (char*)a;
+  char *y = (char*)b;
+  printf("Calling QsortCallback\n");
+  GlobalPtr = new int[10];
+  return (int)*x - (int)*y;
+}
+
+__attribute__((noinline))
+void MyQsort(char *a, size_t size) {
+  printf("Calling qsort\n");
+  qsort(a, size, sizeof(char), QsortCallback);
+  printf("Done\n");  // Avoid tail call.
+}
+}  // extern "C"
+
+int main() {
+  char a[2] = {1, 2};
+  MyQsort(a, 2);
+  return GlobalPtr[10];
+}
+
+// Fast unwind may not unwind through qsort.
+// CHECK-FAST: ERROR: AddressSanitizer: heap-buffer-overflow
+// CHECK-FAST: is located 0 bytes to the right
+// CHECK-FAST: #0{{.*}}operator new
+// CHECK-FAST-NEXT: #1{{.*}}QsortCallback
+
+// CHECK-SLOW: ERROR: AddressSanitizer: heap-buffer-overflow
+// CHECK-SLOW: is located 0 bytes to the right
+// CHECK-SLOW: #0{{.*}}operator new
+// CHECK-SLOW-NEXT: #1{{.*}}QsortCallback
+// CHECK-SLOW: #{{.*}}MyQsort
+// CHECK-SLOW-NEXT: #{{.*}}main
diff --git a/compiler-rt/test/asan/TestCases/Linux/malloc_delete_mismatch.cc b/compiler-rt/test/asan/TestCases/Linux/malloc_delete_mismatch.cc
new file mode 100644
index 0000000..66eed33
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/malloc_delete_mismatch.cc
@@ -0,0 +1,33 @@
+// Check that we detect malloc/delete mismatch only if the approptiate flag
+// is set.
+
+// RUN: %clangxx_asan -g %s -o %t 2>&1
+
+// Find error and provide malloc context.
+// RUN: %env_asan_opts=alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK
+
+// No error here.
+// RUN: %env_asan_opts=alloc_dealloc_mismatch=0 %run %t
+
+// Also works if no malloc context is available.
+// RUN: %env_asan_opts=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+#include <stdlib.h>
+
+static volatile char *x;
+
+int main() {
+  x = (char*)malloc(10);
+  x[0] = 0;
+  delete x;
+}
+// CHECK: ERROR: AddressSanitizer: alloc-dealloc-mismatch (malloc vs operator delete) on 0x
+// CHECK-NEXT: #0{{.*}}operator delete
+// CHECK: #{{.*}}main
+// CHECK: is located 0 bytes inside of 10-byte region
+// CHECK-NEXT: allocated by thread T0 here:
+// ALLOC-STACK-NEXT: #0{{.*}}malloc
+// ALLOC-STACK: #{{.*}}main
+// CHECK: HINT: {{.*}} you may set ASAN_OPTIONS=alloc_dealloc_mismatch=0
diff --git a/compiler-rt/test/asan/TestCases/Linux/mincore.cc b/compiler-rt/test/asan/TestCases/Linux/mincore.cc
new file mode 100644
index 0000000..30f4508
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/mincore.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_asan -std=c++11 -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+int main(void) {
+  unsigned char vec[20];
+  int res;
+  size_t PS = sysconf(_SC_PAGESIZE);
+  void *addr = mmap(nullptr, 20 * PS, PROT_READ | PROT_WRITE,
+                    MAP_NORESERVE | MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+
+  res = mincore(addr, 10 * PS, vec);
+  assert(res == 0);
+  for (int i = 0; i < 10; ++i)
+    assert((vec[i] & 1) == 0);
+
+  for (int i = 0; i < 5; ++i)
+    ((char *)addr)[i * PS] = 1;
+  res = mincore(addr, 10 * PS, vec);
+  assert(res == 0);
+  for (int i = 0; i < 10; ++i)
+    assert((vec[i] & 1) == (i < 5));
+
+  for (int i = 5; i < 10; ++i)
+    ((char *)addr)[i * PS] = 1;
+  res = mincore(addr, 10 * PS, vec);
+  assert(res == 0);
+  for (int i = 0; i < 10; ++i)
+    assert((vec[i] & 1) == 1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/nohugepage_test.cc b/compiler-rt/test/asan/TestCases/Linux/nohugepage_test.cc
new file mode 100644
index 0000000..2758f0a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/nohugepage_test.cc
@@ -0,0 +1,107 @@
+// Regression test for
+// https://code.google.com/p/chromium/issues/detail?id=446692
+// where asan consumed too much RAM due to transparent hugetables.
+//
+// RUN: %clangxx_asan -g %s -o %t
+// RUN: %env_asan_opts=no_huge_pages_for_shadow=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
+//
+// Would be great to run the test with no_huge_pages_for_shadow=0, but
+// the result will depend on the OS version and settings...
+//
+// REQUIRES: x86_64-supported-target, asan-64-bits
+//
+// WARNING: this test is very subtle and may nto work on some systems.
+// If this is the case we'll need to futher improve it or disable it.
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sanitizer/asan_interface.h>
+
+char FileContents[1 << 16];
+
+void FileToString(const char *path) {
+  FileContents[0] = 0;
+  int fd = open(path, 0);
+  if (fd < 0) return;
+  char *p = FileContents;
+  ssize_t size = sizeof(FileContents) - 1;
+  ssize_t res = 0;
+  do {
+    ssize_t got = read (fd, p, size);
+    if (got == 0)
+      break;
+    else if (got > 0)
+      {
+        p += got;
+        res += got;
+        size -= got;
+      }
+    else if (errno != EINTR)
+      break;
+  } while (size > 0 && res < sizeof(FileContents));
+  if (res >= 0)
+    FileContents[res] = 0;
+}
+
+long ReadShadowRss() {
+  const char *path = "/proc/self/smaps";
+  FileToString(path);
+  char *s = strstr(FileContents, "2008fff7000-10007fff8000");
+  if (!s) return 0;
+
+  s = strstr(s, "Rss:");
+  if (!s) return 0;
+  s = s + 4;
+  return atol(s);
+}
+
+const int kAllocSize = 1 << 28;  // 256Mb
+const int kTwoMb = 1 << 21;
+const int kAsanShadowGranularity = 8;
+
+char *x;
+
+__attribute__((no_sanitize_address)) void TouchNoAsan(size_t i) { x[i] = 0; }
+
+int main() {
+  long rss[5];
+  rss[0] = ReadShadowRss();
+  // use mmap directly to avoid asan touching the shadow.
+  x = (char *)mmap(0, kAllocSize, PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANON, 0, 0);
+  fprintf(stderr, "X: %p-%p\n", x, x + kAllocSize);
+  rss[1] = ReadShadowRss();
+
+  // Touch the allocated region, but not the shadow.
+  for (size_t i = 0; i < kAllocSize; i += kTwoMb * kAsanShadowGranularity)
+    TouchNoAsan(i);
+  rss[2] = ReadShadowRss();
+
+  // Touch the shadow just a bit, in 2Mb*Granularity steps.
+  for (size_t i = 0; i < kAllocSize; i += kTwoMb * kAsanShadowGranularity)
+    __asan_poison_memory_region(x + i, kAsanShadowGranularity);
+  rss[3] = ReadShadowRss();
+
+  // Touch all the shadow.
+  __asan_poison_memory_region(x, kAllocSize);
+  rss[4] = ReadShadowRss();
+
+  // Print the differences.
+  for (int i = 0; i < 4; i++) {
+    assert(rss[i] > 0);
+    assert(rss[i+1] >= rss[i]);
+    long diff = rss[i+1] / rss[i];
+    fprintf(stderr, "RSS CHANGE IS %d => %d: %s (%ld vs %ld)\n", i, i + 1,
+            diff < 10 ? "SMALL" : "LARGE", rss[i], rss[i + 1]);
+  }
+}
+// CHECK: RSS CHANGE IS 2 => 3: SMALL
+// CHECK: RSS CHANGE IS 3 => 4: LARGE
diff --git a/compiler-rt/test/asan/TestCases/Linux/odr-violation.cc b/compiler-rt/test/asan/TestCases/Linux/odr-violation.cc
new file mode 100644
index 0000000..bc76116
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/odr-violation.cc
@@ -0,0 +1,50 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// We use fast_unwind_on_malloc=0 to have full unwinding even w/o frame
+// pointers. This setting is not on by default because it's too expensive.
+//
+// Different size: detect a bug if detect_odr_violation>=1
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t-ODR-SO.so
+// RUN: %clangxx_asan %s %t-ODR-SO.so -Wl,-R. -o %t-ODR-EXE
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=1 not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=0     %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0                        not %run %t-ODR-EXE 2>&1 | FileCheck %s
+//
+// Same size: report a bug only if detect_odr_violation>=2.
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t-ODR-SO.so -DSZ=100
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=1     %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0                        not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: echo "odr_violation:foo::ZZZ" > %t.supp
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp  not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: echo "odr_violation:foo::G" > %t.supp
+// RUN: %env_asan_opts=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp      %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: rm -f %t.supp
+
+// GNU driver doesn't handle .so files properly.
+// REQUIRES: Clang
+
+#ifndef SZ
+# define SZ 4
+#endif
+
+#if BUILD_SO
+namespace foo { char G[SZ]; }
+#else
+#include <stdio.h>
+namespace foo { char G[100]; }
+// CHECK: ERROR: AddressSanitizer: odr-violation
+// CHECK: size=100 'foo::G' {{.*}}odr-violation.cc:[[@LINE-2]]:22
+// CHECK: size={{4|100}} 'foo::G'
+int main(int argc, char **argv) {
+  printf("PASS: %p\n", &foo::G);
+}
+#endif
+
+// CHECK: These globals were registered at these points:
+// CHECK: ODR-EXE
+// CHECK: ODR-SO
+// CHECK: SUMMARY: AddressSanitizer: odr-violation: global 'foo::G' at {{.*}}odr-violation.cc
+// DISABLED: PASS
diff --git a/compiler-rt/test/asan/TestCases/Linux/overflow-in-qsort.cc b/compiler-rt/test/asan/TestCases/Linux/overflow-in-qsort.cc
new file mode 100644
index 0000000..dc3918e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/overflow-in-qsort.cc
@@ -0,0 +1,49 @@
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %env_asan_opts=fast_unwind_on_fatal=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
+// RUN: %env_asan_opts=fast_unwind_on_fatal=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
+
+// Test how well we unwind in presence of qsort in the stack
+// (i.e. if we can unwind through a function compiled w/o frame pointers).
+// https://code.google.com/p/address-sanitizer/issues/detail?id=137
+
+// Fast unwinder is only available on x86_64 and i386.
+// REQUIRES: x86_64-supported-target
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int global_array[10];
+volatile int one = 1;
+
+extern "C" {
+int QsortCallback(const void *a, const void *b) {
+  char *x = (char*)a;
+  char *y = (char*)b;
+  printf("Calling QsortCallback\n");
+  global_array[one * 10] = 0;  // BOOM
+  return (int)*x - (int)*y;
+}
+
+__attribute__((noinline))
+void MyQsort(char *a, size_t size) {
+  printf("Calling qsort\n");
+  qsort(a, size, sizeof(char), QsortCallback);
+  printf("Done\n");  // Avoid tail call.
+}
+}  // extern "C"
+
+int main() {
+  char a[2] = {1, 2};
+  MyQsort(a, 2);
+}
+
+// Fast unwind may not unwind through qsort.
+// CHECK-FAST: ERROR: AddressSanitizer: global-buffer-overflow
+// CHECK-FAST: #0{{.*}} in QsortCallback
+// CHECK-FAST: is located 0 bytes to the right of global variable 'global_array
+
+// CHECK-SLOW: ERROR: AddressSanitizer: global-buffer-overflow
+// CHECK-SLOW: #0{{.*}} in QsortCallback
+// CHECK-SLOW: #{{.*}} in MyQsort
+// CHECK-SLOW: #{{.*}} in main
+// CHECK-SLOW: is located 0 bytes to the right of global variable 'global_array
diff --git a/compiler-rt/test/asan/TestCases/Linux/preinit_test.cc b/compiler-rt/test/asan/TestCases/Linux/preinit_test.cc
new file mode 100644
index 0000000..10dde67
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/preinit_test.cc
@@ -0,0 +1,33 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx      -DFUNC=zzzz %s -shared -o %t.so -fPIC
+// RUN: %clangxx_asan -DFUNC=main %s         -o %t    -Wl,-R. %t.so
+// RUN: %run %t
+
+// GNU driver doesn't handle .so files properly.
+// REQUIRES: Clang
+
+// This test ensures that we call __asan_init early enough.
+// We build a shared library w/o asan instrumentation
+// and the binary with asan instrumentation.
+// Both files include the same header (emulated by -DFUNC here)
+// with C++ template magic which runs global initializer at library load time.
+// The function get() is instrumented with asan, but called
+// before the usual constructors are run.
+// So, we must make sure that __asan_init is executed even earlier.
+//
+// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56393
+
+struct A {
+  int foo() const { return 0; }
+};
+A get () { return A(); }
+template <class> struct O {
+  static A const e;
+};
+template <class T> A const O <T>::e = get();
+int FUNC() {
+  return O<int>::e.foo();
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cc b/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cc
new file mode 100644
index 0000000..efdb8ca
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_asan -std=c++11 -pthread %s -o %t && %run %t 2>&1
+// Regression test for the versioned pthread_create interceptor on linux/i386.
+// pthread_attr_init is not intercepted and binds to the new abi
+// pthread_create is intercepted; dlsym always returns the oldest version.
+// This results in a crash inside pthread_create in libc.
+
+#include <pthread.h>
+#include <stdlib.h>
+
+void *ThreadFunc(void *) { return nullptr; }
+
+int main() {
+  pthread_t t;
+  const size_t sz = 1024 * 1024;
+  void *p = malloc(sz);
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  pthread_attr_setstack(&attr, p, sz);
+  pthread_create(&t, &attr, ThreadFunc, nullptr);
+  pthread_join(t, nullptr);
+  free(p);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/ptrace.cc b/compiler-rt/test/asan/TestCases/Linux/ptrace.cc
new file mode 100644
index 0000000..d87d90b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/ptrace.cc
@@ -0,0 +1,125 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+// XFAIL: mips
+//
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t
+// RUN: %clangxx_asan -DPOSITIVE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdio.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/uio.h> // for iovec
+#include <elf.h> // for NT_PRSTATUS
+#ifdef __aarch64__
+# include <asm/ptrace.h>
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+typedef user_regs_struct   regs_struct;
+typedef user_fpregs_struct fpregs_struct;
+#if defined(__i386__)
+#define REG_IP  eip
+#else
+#define REG_IP  rip
+#endif
+#define PRINT_REG_PC(__regs)    printf ("%lx\n", (unsigned long) (__regs.REG_IP))
+#define PRINT_REG_FP(__fpregs)  printf ("%lx\n", (unsigned long) (__fpregs.cwd))
+#define __PTRACE_FPREQUEST PTRACE_GETFPREGS
+
+#elif defined(__aarch64__)
+typedef struct user_pt_regs      regs_struct;
+typedef struct user_fpsimd_state fpregs_struct;
+#define PRINT_REG_PC(__regs)    printf ("%x\n", (unsigned) (__regs.pc))
+#define PRINT_REG_FP(__fpregs)  printf ("%x\n", (unsigned) (__fpregs.fpsr))
+#define ARCH_IOVEC_FOR_GETREGSET
+
+#elif defined(__powerpc64__)
+typedef struct pt_regs regs_struct;
+typedef elf_fpregset_t fpregs_struct;
+#define PRINT_REG_PC(__regs)    printf ("%lx\n", (unsigned long) (__regs.nip))
+#define PRINT_REG_FP(__fpregs)  printf ("%lx\n", (elf_greg_t)fpregs[32])
+#define ARCH_IOVEC_FOR_GETREGSET
+
+#elif defined(__mips__)
+typedef struct pt_regs regs_struct;
+typedef elf_fpregset_t fpregs_struct;
+#define PRINT_REG_PC(__regs)    printf ("%lx\n", (unsigned long) (__regs.cp0_epc))
+#define PRINT_REG_FP(__fpregs)  printf ("%lx\n", (elf_greg_t) (__fpregs[32]))
+#define __PTRACE_FPREQUEST PTRACE_GETFPREGS
+
+#elif defined(__arm__)
+# include <asm/ptrace.h>
+# include <sys/procfs.h>
+typedef struct pt_regs regs_struct;
+typedef char fpregs_struct[ARM_VFPREGS_SIZE];
+#define PRINT_REG_PC(__regs)    printf ("%x\n", (unsigned) (__regs.ARM_pc))
+#define PRINT_REG_FP(__fpregs)  printf ("%x\n", (unsigned) (__fpregs + 32 * 8))
+#define __PTRACE_FPREQUEST PTRACE_GETVFPREGS
+#endif
+
+
+int main(void) {
+  pid_t pid;
+  pid = fork();
+  if (pid == 0) { // child
+    ptrace(PTRACE_TRACEME, 0, NULL, NULL);
+    execl("/bin/true", "true", NULL);
+  } else {
+    wait(NULL);
+    regs_struct regs;
+    regs_struct* volatile pregs = &regs;
+#ifdef ARCH_IOVEC_FOR_GETREGSET
+    struct iovec regset_io;
+#endif
+    int res;
+
+#ifdef POSITIVE
+    ++pregs;
+#endif
+
+#ifdef ARCH_IOVEC_FOR_GETREGSET
+# define __PTRACE_REQUEST  PTRACE_GETREGSET
+# define __PTRACE_ARGS     (void*)NT_PRSTATUS, (void*)&regset_io
+    regset_io.iov_base = pregs;
+    regset_io.iov_len = sizeof(regs_struct);
+#else
+# define __PTRACE_REQUEST  PTRACE_GETREGS
+# define __PTRACE_ARGS     NULL, pregs
+#endif
+    res = ptrace((enum __ptrace_request)__PTRACE_REQUEST, pid, __PTRACE_ARGS);
+    // CHECK: AddressSanitizer: stack-buffer-overflow
+    // CHECK: {{.*ptrace.cc:}}[[@LINE-2]]
+    assert(!res);
+    PRINT_REG_PC(regs);
+
+    fpregs_struct fpregs;
+#ifdef ARCH_IOVEC_FOR_GETREGSET
+# define __PTRACE_FPREQUEST  PTRACE_GETREGSET
+# define __PTRACE_FPARGS     (void*)NT_PRSTATUS, (void*)&regset_io
+    regset_io.iov_base = &fpregs;
+    regset_io.iov_len = sizeof(fpregs_struct);
+    res = ptrace((enum __ptrace_request)PTRACE_GETREGSET, pid, (void*)NT_FPREGSET,
+                 (void*)&regset_io);
+#else
+# define __PTRACE_FPARGS     NULL, &fpregs
+#endif
+    res = ptrace((enum __ptrace_request)__PTRACE_FPREQUEST, pid, __PTRACE_FPARGS);
+    assert(!res);
+    PRINT_REG_FP(fpregs);
+
+#ifdef __i386__
+    user_fpxregs_struct fpxregs;
+    res = ptrace(PTRACE_GETFPXREGS, pid, NULL, &fpxregs);
+    assert(!res);
+    printf("%lx\n", (unsigned long)fpxregs.mxcsr);
+#endif
+
+    ptrace(PTRACE_CONT, pid, NULL, NULL);
+    wait(NULL);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/quarantine_size_mb.cc b/compiler-rt/test/asan/TestCases/Linux/quarantine_size_mb.cc
new file mode 100644
index 0000000..cbacec2
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/quarantine_size_mb.cc
@@ -0,0 +1,24 @@
+// Test quarantine_size_mb (and the deprecated quarantine_size)
+// RUN: %clangxx_asan  %s -o %t
+// RUN: %env_asan_opts=quarantine_size=10485760:verbosity=1:hard_rss_limit_mb=50 %run %t  2>&1 | FileCheck %s  --check-prefix=Q10
+// RUN: %env_asan_opts=quarantine_size_mb=10:verbosity=1:hard_rss_limit_mb=50    %run %t  2>&1 | FileCheck %s  --check-prefix=Q10
+// RUN: %env_asan_opts=quarantine_size_mb=10:quarantine_size=20:verbosity=1  not %run %t  2>&1 | FileCheck %s  --check-prefix=BOTH
+// RUN: %env_asan_opts=quarantine_size_mb=1000:hard_rss_limit_mb=50 not  %run %t          2>&1 | FileCheck %s  --check-prefix=RSS_LIMIT
+// RUN: %env_asan_opts=hard_rss_limit_mb=50                         not  %run %t          2>&1 | FileCheck %s  --check-prefix=RSS_LIMIT
+#include <string.h>
+char *g;
+
+static const int kNumAllocs = 1 << 11;
+static const int kAllocSize = 1 << 20;
+
+int main() {
+  for (int i = 0; i < kNumAllocs; i++) {
+    g = new char[kAllocSize];
+    memset(g, -1, kAllocSize);
+    delete [] (g);
+  }
+}
+
+// Q10: quarantine_size_mb=10M
+// BOTH: please use either 'quarantine_size' (deprecated) or quarantine_size_mb, but not both
+// RSS_LIMIT: AddressSanitizer: hard rss limit exhausted
diff --git a/compiler-rt/test/asan/TestCases/Linux/read_binary_name_regtest.c b/compiler-rt/test/asan/TestCases/Linux/read_binary_name_regtest.c
new file mode 100644
index 0000000..b09096c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/read_binary_name_regtest.c
@@ -0,0 +1,54 @@
+// Regression test for https://crbug.com/502974, where ASan was unable to read
+// the binary name because of sandbox restrictions.
+// This test uses seccomp-BPF to restrict the readlink() system call and makes
+// sure ASan is still able to
+// RUN: not ls /usr/include/linux/seccomp.h || ( %clang_asan %s -o %t && not %run %t 2>&1 | FileCheck %s )
+// UNSUPPORTED: android
+
+#include <errno.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/prctl.h>
+#include <sys/syscall.h>
+#include <linux/filter.h>
+#include <linux/seccomp.h>
+
+#ifndef __NR_readlink
+# define __NR_readlink __NR_readlinkat
+#endif
+
+#define syscall_nr (offsetof(struct seccomp_data, nr))
+
+void corrupt() {
+  void *p = malloc(10);
+  free(p);
+  free(p);
+}
+
+int main() {
+  prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
+
+  struct sock_filter filter[] = {
+    /* Grab the system call number */
+    BPF_STMT(BPF_LD + BPF_W + BPF_ABS, syscall_nr),
+    // If this is __NR_readlink,
+    BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, __NR_readlink, 0, 1),
+    // return with EPERM,
+    BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | EPERM),
+    // otherwise allow the syscall.
+    BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW)
+  };
+  struct sock_fprog prog;
+  prog.len = (unsigned short)(sizeof(filter)/sizeof(filter[0]));
+  prog.filter = filter;
+
+  int res = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);
+  if (res != 0) {
+    fprintf(stderr, "PR_SET_SECCOMP unsupported!\n");
+  }
+  corrupt();
+  // CHECK: AddressSanitizer
+  // CHECK-NOT: reading executable name failed
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/rlimit_mmap_test.cc b/compiler-rt/test/asan/TestCases/Linux/rlimit_mmap_test.cc
new file mode 100644
index 0000000..7f37727
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/rlimit_mmap_test.cc
@@ -0,0 +1,16 @@
+// Check that we properly report mmap failure.
+// RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
+#include <stdlib.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+static volatile void *x;
+
+int main(int argc, char **argv) {
+  struct rlimit mmap_resource_limit = { 0, 0 };
+  assert(0 == setrlimit(RLIMIT_AS, &mmap_resource_limit));
+  x = malloc(10000000);
+// CHECK: ERROR: Failed to mmap
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/shmctl.cc b/compiler-rt/test/asan/TestCases/Linux/shmctl.cc
new file mode 100644
index 0000000..e1752bc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/shmctl.cc
@@ -0,0 +1,27 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1
+// Regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=250
+#include <stdio.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <assert.h>
+
+int main() {
+  int id = shmget(IPC_PRIVATE, 4096, 0644 | IPC_CREAT);
+  assert(id > -1);
+  struct shmid_ds ds;
+  int res = shmctl(id, IPC_STAT, &ds);
+  assert(res > -1);
+  printf("shm_segsz: %zd\n", ds.shm_segsz);
+  assert(ds.shm_segsz == 4096);
+  assert(-1 != shmctl(id, IPC_RMID, 0));
+
+  struct shm_info shmInfo;
+  res = shmctl(0, SHM_INFO, (struct shmid_ds *)&shmInfo);
+  assert(res > -1);
+  
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/signal_during_stop_the_world.cc b/compiler-rt/test/asan/TestCases/Linux/signal_during_stop_the_world.cc
new file mode 100644
index 0000000..b1a41fe
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/signal_during_stop_the_world.cc
@@ -0,0 +1,60 @@
+// Test StopTheWorld behavior during signal storm.
+// Historically StopTheWorld crashed because did not handle EINTR properly.
+// The test is somewhat convoluted, but that's what caused crashes previously.
+
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/prctl.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <pthread.h>
+#include <sanitizer/lsan_interface.h>
+
+static void handler(int signo);
+static void *thr(void *arg);
+
+int main() {
+  struct sigaction act = {};
+  act.sa_handler = handler;
+  sigaction(SIGPROF, &act, 0);
+
+  pid_t pid = fork();
+  if (pid < 0) {
+    fprintf(stderr, "failed to fork\n");
+    exit(1);
+  }
+  if (pid == 0) {
+    // Child constantly sends signals to parent to cause spurious return from
+    // waitpid in StopTheWorld.
+    prctl(PR_SET_PDEATHSIG, SIGTERM, 0, 0, 0);
+    pid_t parent = getppid();
+    for (;;) {
+      // There is no strong reason for these two particular signals,
+      // but at least one of them ought to unblock waitpid.
+      kill(parent, SIGCHLD);
+      kill(parent, SIGPROF);
+    }
+  }
+  usleep(10000);  // Let the child start.
+  __lsan_do_leak_check();
+  // Kill and join the child.
+  kill(pid, SIGTERM);
+  waitpid(pid, 0, 0);
+  sleep(1);  // If the tracer thread still runs, give it time to crash.
+  fprintf(stderr, "DONE\n");
+// CHECK: DONE
+}
+
+static void handler(int signo) {
+}
+
+static void *thr(void *arg) {
+  for (;;)
+    sleep(1);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/sized_delete_test.cc b/compiler-rt/test/asan/TestCases/Linux/sized_delete_test.cc
new file mode 100644
index 0000000..5d8c701
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/sized_delete_test.cc
@@ -0,0 +1,89 @@
+// RUN: %clangxx_asan -fsized-deallocation -O0 %s -o %t
+// RUN:                                                                  not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
+// RUN: %env_asan_opts=new_delete_type_mismatch=1 not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
+// RUN:                                                                  not %run %t array  2>&1 | FileCheck %s -check-prefix=ARRAY
+// RUN: %env_asan_opts=new_delete_type_mismatch=1 not %run %t array  2>&1 | FileCheck %s -check-prefix=ARRAY
+// RUN: %env_asan_opts=new_delete_type_mismatch=0     %run %t scalar
+// RUN: %env_asan_opts=new_delete_type_mismatch=0     %run %t array
+
+#include <new>
+#include <stdio.h>
+#include <string>
+
+inline void break_optimization(void *arg) {
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+}
+
+struct S12 {
+  int a, b, c;
+};
+
+struct S20 {
+  int a, b, c, d, e;
+};
+
+struct D1 {
+  int a, b, c;
+  ~D1() { fprintf(stderr, "D1::~D1\n"); }
+};
+
+struct D2 {
+  int a, b, c, d, e;
+  ~D2() { fprintf(stderr, "D2::~D2\n"); }
+};
+
+void Del12(S12 *x) {
+  break_optimization(x);
+  delete x;
+}
+void Del12NoThrow(S12 *x) {
+  break_optimization(x);
+  operator delete(x, std::nothrow);
+}
+void Del12Ar(S12 *x) {
+  break_optimization(x);
+  delete [] x;
+}
+void Del12ArNoThrow(S12 *x) {
+  break_optimization(x);
+  operator delete[](x, std::nothrow);
+}
+
+int main(int argc, char **argv) {
+  if (argc != 2) return 1;
+  std::string flag = argv[1];
+  // These are correct.
+  Del12(new S12);
+  Del12NoThrow(new S12);
+  Del12Ar(new S12[100]);
+  Del12ArNoThrow(new S12[100]);
+
+  // Here we pass wrong type of pointer to delete,
+  // but [] and nothrow variants of delete are not sized.
+  Del12Ar(reinterpret_cast<S12*>(new S20[100]));
+  Del12NoThrow(reinterpret_cast<S12*>(new S20));
+  Del12ArNoThrow(reinterpret_cast<S12*>(new S20[100]));
+  fprintf(stderr, "OK SO FAR\n");
+  // SCALAR: OK SO FAR
+  // ARRAY: OK SO FAR
+  if (flag == "scalar") {
+    // Here asan should bark as we are passing a wrong type of pointer
+    // to sized delete.
+    Del12(reinterpret_cast<S12*>(new S20));
+    // SCALAR: AddressSanitizer: new-delete-type-mismatch
+    // SCALAR:  object passed to delete has wrong type:
+    // SCALAR:  size of the allocated type:   20 bytes;
+    // SCALAR:  size of the deallocated type: 12 bytes.
+    // SCALAR: is located 0 bytes inside of 20-byte region
+    // SCALAR: SUMMARY: AddressSanitizer: new-delete-type-mismatch
+  } else if (flag == "array") {
+    D1 *d1 = reinterpret_cast<D1*>(new D2[10]);
+    break_optimization(d1);
+    delete [] d1;
+    // ARRAY-NOT: D2::~D2
+    // ARRAY: D1::~D1
+    // ARRAY: AddressSanitizer: new-delete-type-mismatch
+    // ARRAY:  size of the allocated type:   20{{4|8}} bytes;
+    // ARRAY:  size of the deallocated type: 12{{4|8}} bytes.
+  }
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/stack-overflow-sigbus.cc b/compiler-rt/test/asan/TestCases/Linux/stack-overflow-sigbus.cc
new file mode 100644
index 0000000..8c9599c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/stack-overflow-sigbus.cc
@@ -0,0 +1,64 @@
+// Test ASan detection of stack-overflow condition when Linux sends SIGBUS.
+
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+
+const int BS = 1024;
+volatile char x;
+volatile int y = 1;
+
+void recursive_func(char *p) {
+  char buf[BS];
+  buf[rand() % BS] = 1;
+  buf[rand() % BS] = 2;
+  x = buf[rand() % BS];
+  if (y)
+    recursive_func(buf);
+  x = 1; // prevent tail call optimization
+  // CHECK: {{stack-overflow on address 0x.* \(pc 0x.* bp 0x.* sp 0x.* T.*\)}}
+}
+
+void LimitStackAndReexec(int argc, char **argv) {
+  struct rlimit rlim;
+  int res = getrlimit(RLIMIT_STACK, &rlim);
+  assert(res == 0);
+  if (rlim.rlim_cur == RLIM_INFINITY) {
+    rlim.rlim_cur = 256 * 1024;
+    res = setrlimit(RLIMIT_STACK, &rlim);
+    assert(res == 0);
+
+    execv(argv[0], argv);
+    assert(0 && "unreachable");
+  }
+}
+
+int main(int argc, char **argv) {
+  LimitStackAndReexec(argc, argv);
+
+  // Map some memory just before the start of the current stack vma.
+  // When the stack grows down and crashes into it, Linux can send
+  // SIGBUS instead of SIGSEGV. See:
+  // http://lkml.iu.edu/hypermail/linux/kernel/1008.1/02299.html
+  const long pagesize = sysconf(_SC_PAGESIZE);
+  FILE *f = fopen("/proc/self/maps", "r");
+  char a[1000];
+  void *p = 0;
+  while (fgets(a, sizeof a, f)) {
+    if (strstr(a, "[stack]")) {
+      unsigned long addr;
+      if (sscanf(a, "%lx", &addr) == 1)
+        p = mmap((void *)(addr - 4 * pagesize), pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    }
+  }
+  assert(p);
+
+  recursive_func(0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/stack-trace-dlclose.cc b/compiler-rt/test/asan/TestCases/Linux/stack-trace-dlclose.cc
new file mode 100644
index 0000000..49c2089
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/stack-trace-dlclose.cc
@@ -0,0 +1,45 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx_asan -DSHARED %s -shared -o %T/stack_trace_dlclose.so -fPIC
+// RUN: %clangxx_asan -DSO_DIR=\"%T\" %s %libdl -o %t
+// RUN: %env_asan_opts=exitcode=0 %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef SHARED
+extern "C" {
+void *foo() {
+  return malloc(1);
+}
+}
+#else
+void *handle;
+
+int main(int argc, char **argv) {
+  void *handle = dlopen(SO_DIR "/stack_trace_dlclose.so", RTLD_LAZY);
+  assert(handle);
+  void *(*foo)() = (void *(*)())dlsym(handle, "foo");
+  assert(foo);
+  void *p = foo();
+  assert(p);
+  dlclose(handle);
+
+  free(p);
+  free(p);  // double-free
+
+  return 0;
+}
+#endif
+
+// CHECK: {{    #0 0x.* in (__interceptor_)?malloc}}
+// CHECK: {{    #1 0x.* \(<unknown module>\)}}
+// CHECK: {{    #2 0x.* in main}}
diff --git a/compiler-rt/test/asan/TestCases/Linux/static_tls.cc b/compiler-rt/test/asan/TestCases/Linux/static_tls.cc
new file mode 100644
index 0000000..11bb1a4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/static_tls.cc
@@ -0,0 +1,29 @@
+// REQUIRES: asan-64-bits
+// Regression test: __tls_get_addr interceptor must recognize static TLS.
+//
+// RUN: %clangxx_asan -DSHARED %s -shared -o %t-so.so -fPIC
+// RUN: %clangxx_asan %s -ldl -pthread -o %t %t-so.so
+// RUN: %env_asan_opts=verbosity=2 %run %t 2>&1 | FileCheck %s
+
+// CHECK: before
+// CHECK: __tls_get_addr: static tls
+// CHECK: after
+
+// XFAIL: aarch64
+
+#ifndef SHARED
+#include <stdio.h>
+
+unsigned *f();
+int main(int argc, char *argv[]) {
+  fprintf(stderr, "before\n");
+  f();
+  fprintf(stderr, "after\n");
+  return 0;
+}
+#else  // SHARED
+static __thread unsigned ThreadLocal;
+unsigned *f() {
+  return &ThreadLocal;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Linux/stress_dtls.c b/compiler-rt/test/asan/TestCases/Linux/stress_dtls.c
new file mode 100644
index 0000000..fd1ce0c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/stress_dtls.c
@@ -0,0 +1,117 @@
+// REQUIRES: asan-64-bits
+// UNSUPPORTED: android
+// Stress test dynamic TLS + dlopen + threads.
+//
+// Note that glibc 2.15 seems utterly broken on this test,
+// it fails with ~17 DSOs dlopen-ed.
+// glibc 2.19 seems fine.
+//
+//
+// RUN: %clangxx_asan -x c -DSO_NAME=f0 %s -shared -o %t-f0.so -fPIC
+// RUN: %clangxx_asan -x c -DSO_NAME=f1 %s -shared -o %t-f1.so -fPIC
+// RUN: %clangxx_asan -x c -DSO_NAME=f2 %s -shared -o %t-f2.so -fPIC
+// RUN: %clangxx_asan %s -ldl -pthread -o %t
+// RUN: %run %t 0 3
+// RUN: %run %t 2 3
+// RUN: %env_asan_opts=verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0
+// CHECK: __tls_get_addr
+// CHECK: Creating thread 0
+// CHECK: __tls_get_addr
+// CHECK: Creating thread 1
+// CHECK: __tls_get_addr
+// CHECK: Creating thread 2
+// CHECK: __tls_get_addr
+// CHECK: Creating thread 3
+// CHECK: __tls_get_addr
+// Make sure that TLS slots don't leak
+// CHECK-NOT: num_live_dtls 5
+//
+// CHECK0-NOT: __tls_get_addr
+/*
+cc=your-compiler
+
+$cc stress_dtls.c -pthread -ldl
+for((i=0;i<100;i++)); do
+  $cc -fPIC -shared -DSO_NAME=f$i -o a.out-f$i.so stress_dtls.c;
+done
+./a.out 2 4  # <<<<<< 2 threads, 4 libs
+./a.out 3 50 # <<<<<< 3 threads, 50 libs
+*/
+#ifndef SO_NAME
+#define _GNU_SOURCE
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <stdint.h>
+
+typedef void **(*f_t)();
+
+__thread int my_tls;
+
+#define MAX_N_FUNCTIONS 1000
+f_t Functions[MAX_N_FUNCTIONS];
+
+void *PrintStuff(void *unused) {
+  uintptr_t stack;
+  // fprintf(stderr, "STACK: %p TLS: %p SELF: %p\n", &stack, &my_tls,
+  //        (void *)pthread_self());
+  int i;
+  for (i = 0; i < MAX_N_FUNCTIONS; i++) {
+    if (!Functions[i]) break;
+    uintptr_t dtls = (uintptr_t)Functions[i]();
+    fprintf(stderr, "  dtls[%03d]: %lx\n", i, dtls);
+    *(long*)dtls = 42;  // check that this is writable.
+  }
+  return NULL;
+}
+
+int main(int argc, char *argv[]) {
+  int num_threads = 1;
+  int num_libs = 1;
+  if (argc >= 2)
+    num_threads = atoi(argv[1]);
+  if (argc >= 3)
+    num_libs = atoi(argv[2]);
+  assert(num_libs <= MAX_N_FUNCTIONS);
+
+  int lib;
+  for (lib = 0; lib < num_libs; lib++) {
+    char buf[4096];
+    snprintf(buf, sizeof(buf), "%s-f%d.so", argv[0], lib);
+    void *handle = dlopen(buf, RTLD_LAZY);
+    if (!handle) {
+      fprintf(stderr, "%s\n", dlerror());
+      exit(1);
+    }
+    snprintf(buf, sizeof(buf), "f%d", lib);
+    Functions[lib] = (f_t)dlsym(handle, buf);
+    if (!Functions[lib]) {
+      fprintf(stderr, "%s\n", dlerror());
+      exit(1);
+    }
+    fprintf(stderr, "LIB[%03d] %s: %p\n", lib, buf, Functions[lib]);
+    PrintStuff(0);
+
+    int i;
+    for (i = 0; i < num_threads; i++) {
+      pthread_t t;
+      fprintf(stderr, "Creating thread %d\n", i);
+      pthread_create(&t, 0, PrintStuff, 0);
+      pthread_join(t, 0);
+    }
+  }
+  return 0;
+}
+#else  // SO_NAME
+#ifndef DTLS_SIZE
+# define DTLS_SIZE (1 << 17)
+#endif
+__thread void *huge_thread_local_array[DTLS_SIZE];
+void **SO_NAME() {
+  return &huge_thread_local_array[0];
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Linux/swapcontext_test.cc b/compiler-rt/test/asan/TestCases/Linux/swapcontext_test.cc
new file mode 100644
index 0000000..86ed593
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/swapcontext_test.cc
@@ -0,0 +1,90 @@
+// Check that ASan plays well with easy cases of makecontext/swapcontext.
+
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
+//
+// This test is too sublte to try on non-x86 arch for now.
+// REQUIRES: x86_64-supported-target,i386-supported-target
+
+#include <stdio.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+ucontext_t orig_context;
+ucontext_t child_context;
+
+const int kStackSize = 1 << 20;
+
+__attribute__((noinline))
+void Throw() {
+  throw 1;
+}
+
+__attribute__((noinline))
+void ThrowAndCatch() {
+  try {
+    Throw();
+  } catch(int a) {
+    printf("ThrowAndCatch: %d\n", a);
+  }
+}
+
+void Child(int mode) {
+  char x[32] = {0};  // Stack gets poisoned.
+  printf("Child: %p\n", x);
+  ThrowAndCatch();  // Simulate __asan_handle_no_return().
+  // (a) Do nothing, just return to parent function.
+  // (b) Jump into the original function. Stack remains poisoned unless we do
+  //     something.
+  if (mode == 1) {
+    if (swapcontext(&child_context, &orig_context) < 0) {
+      perror("swapcontext");
+      _exit(0);
+    }
+  }
+}
+
+int Run(int arg, int mode, char *child_stack) {
+  printf("Child stack: %p\n", child_stack);
+  // Setup child context.
+  getcontext(&child_context);
+  child_context.uc_stack.ss_sp = child_stack;
+  child_context.uc_stack.ss_size = kStackSize / 2;
+  if (mode == 0) {
+    child_context.uc_link = &orig_context;
+  }
+  makecontext(&child_context, (void (*)())Child, 1, mode);
+  if (swapcontext(&orig_context, &child_context) < 0) {
+    perror("swapcontext");
+    return 0;
+  }
+  // Touch childs's stack to make sure it's unpoisoned.
+  for (int i = 0; i < kStackSize; i++) {
+    child_stack[i] = i;
+  }
+  return child_stack[arg];
+}
+
+int main(int argc, char **argv) {
+  char stack[kStackSize + 1];
+  // CHECK: WARNING: ASan doesn't fully support makecontext/swapcontext
+  int ret = 0;
+  ret += Run(argc - 1, 0, stack);
+  printf("Test1 passed\n");
+  // CHECK: Test1 passed
+  ret += Run(argc - 1, 1, stack);
+  printf("Test2 passed\n");
+  // CHECK: Test2 passed
+  char *heap = new char[kStackSize + 1];
+  ret += Run(argc - 1, 0, heap);
+  printf("Test3 passed\n");
+  // CHECK: Test3 passed
+  ret += Run(argc - 1, 1, heap);
+  printf("Test4 passed\n");
+  // CHECK: Test4 passed
+
+  delete [] heap;
+  return ret;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/syscalls.cc b/compiler-rt/test/asan/TestCases/Linux/syscalls.cc
new file mode 100644
index 0000000..bcdd5bc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/syscalls.cc
@@ -0,0 +1,25 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <errno.h>
+#include <glob.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <sanitizer/linux_syscall_hooks.h>
+
+/* Test the presence of __sanitizer_syscall_ in the tool runtime, and general
+   sanity of their behaviour. */
+
+int main(int argc, char *argv[]) {
+  char buf[1000];
+  __sanitizer_syscall_pre_recvmsg(0, buf - 1, 0);
+  // CHECK: AddressSanitizer: stack-buffer-{{.*}}erflow
+  // CHECK: READ of size {{.*}} at {{.*}} thread T0
+  // CHECK: #0 {{.*}} in __sanitizer_syscall{{.*}}recvmsg
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/uar_signals.cc b/compiler-rt/test/asan/TestCases/Linux/uar_signals.cc
new file mode 100644
index 0000000..f42c3f6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/uar_signals.cc
@@ -0,0 +1,70 @@
+// This test checks that the implementation of use-after-return
+// is async-signal-safe.
+// RUN: %clangxx_asan -O1 %s -o %t -pthread && %run %t
+// REQUIRES: stable-runtime
+#include <signal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <pthread.h>
+
+int *g;
+int n_signals;
+
+typedef void (*Sigaction)(int, siginfo_t *, void *);
+
+void SignalHandler(int, siginfo_t*, void*) {
+  int local;
+  g = &local;
+  n_signals++;
+  // printf("s: %p\n", &local);
+}
+
+static void EnableSigprof(Sigaction SignalHandler) {
+  struct sigaction sa;
+  sa.sa_sigaction = SignalHandler;
+  sa.sa_flags = SA_RESTART | SA_SIGINFO;
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGPROF, &sa, NULL) != 0) {
+    perror("sigaction");
+    abort();
+  }
+  struct itimerval timer;
+  timer.it_interval.tv_sec = 0;
+  timer.it_interval.tv_usec = 1;
+  timer.it_value = timer.it_interval;
+  if (setitimer(ITIMER_PROF, &timer, 0) != 0) {
+    perror("setitimer");
+    abort();
+  }
+}
+
+void RecursiveFunction(int depth) {
+  if (depth == 0) return;
+  int local;
+  g = &local;
+  // printf("r: %p\n", &local);
+  // printf("[%2d] n_signals: %d\n", depth, n_signals);
+  RecursiveFunction(depth - 1);
+  RecursiveFunction(depth - 1);
+}
+
+void *Thread(void *) {
+  RecursiveFunction(18);
+  return NULL;
+}
+
+int main(int argc, char **argv) {
+  EnableSigprof(SignalHandler);
+
+  for (int i = 0; i < 4; i++) {
+    fprintf(stderr, ".");
+    const int kNumThread = sizeof(void*) == 8 ? 16 : 8;
+    pthread_t t[kNumThread];
+    for (int i = 0; i < kNumThread; i++)
+      pthread_create(&t[i], 0, Thread, 0);
+    for (int i = 0; i < kNumThread; i++)
+      pthread_join(t[i], 0);
+  }
+  fprintf(stderr, "\n");
+}
diff --git a/compiler-rt/test/asan/TestCases/Linux/unpoison_tls.cc b/compiler-rt/test/asan/TestCases/Linux/unpoison_tls.cc
new file mode 100644
index 0000000..9c1d74b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/unpoison_tls.cc
@@ -0,0 +1,35 @@
+// Test that TLS is unpoisoned on thread death.
+// REQUIRES: x86_64-supported-target,i386-supported-target
+
+// RUN: %clangxx_asan -O1 %s -pthread -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+
+#include <sanitizer/asan_interface.h>
+
+__thread int64_t tls_var[2];
+
+volatile int64_t *p_tls_var;
+
+void *first(void *arg) {
+  ASAN_POISON_MEMORY_REGION(&tls_var, sizeof(tls_var));
+  p_tls_var = tls_var;
+  return 0;
+}
+
+void *second(void *arg) {
+  assert(tls_var == p_tls_var);
+  *p_tls_var = 1;
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  pthread_t p;
+  assert(0 == pthread_create(&p, 0, first, 0));
+  assert(0 == pthread_join(p, 0));
+  assert(0 == pthread_create(&p, 0, second, 0));
+  assert(0 == pthread_join(p, 0));
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/allow_user_segv.cc b/compiler-rt/test/asan/TestCases/Posix/allow_user_segv.cc
new file mode 100644
index 0000000..69c1df9
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/allow_user_segv.cc
@@ -0,0 +1,59 @@
+// Regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=180
+
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && %env_asan_opts=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+struct sigaction original_sigaction_sigbus;
+struct sigaction original_sigaction_sigsegv;
+
+void User_OnSIGSEGV(int signum, siginfo_t *siginfo, void *context) {
+  fprintf(stderr, "User sigaction called\n");
+  struct sigaction original_sigaction;
+  if (signum == SIGBUS)
+    original_sigaction = original_sigaction_sigbus;
+  else if (signum == SIGSEGV)
+    original_sigaction = original_sigaction_sigsegv;
+  else {
+    printf("Invalid signum");
+    exit(1);
+  }
+  if (original_sigaction.sa_flags | SA_SIGINFO)
+    original_sigaction.sa_sigaction(signum, siginfo, context);
+  else
+    original_sigaction.sa_handler(signum);
+}
+
+int DoSEGV() {
+  volatile int *x = 0;
+  return *x;
+}
+
+int InstallHandler(int signum, struct sigaction *original_sigaction) {
+  struct sigaction user_sigaction;
+  user_sigaction.sa_sigaction = User_OnSIGSEGV;
+  user_sigaction.sa_flags = SA_SIGINFO;
+  if (sigaction(signum, &user_sigaction, original_sigaction)) {
+    perror("sigaction");
+    return 1;
+  }
+  return 0;
+}
+
+int main() {
+  // Let's install handlers for both SIGSEGV and SIGBUS, since pre-Yosemite
+  // 32-bit Darwin triggers SIGBUS instead.
+  if (InstallHandler(SIGSEGV, &original_sigaction_sigsegv)) return 1;
+  if (InstallHandler(SIGBUS, &original_sigaction_sigbus)) return 1;
+  fprintf(stderr, "User sigaction installed\n");
+  return DoSEGV();
+}
+
+// CHECK: User sigaction installed
+// CHECK-NEXT: User sigaction called
+// CHECK-NEXT: ASAN:DEADLYSIGNAL
+// CHECK: AddressSanitizer: SEGV on unknown address
diff --git a/compiler-rt/test/asan/TestCases/Posix/asan-symbolize-bad-path.cc b/compiler-rt/test/asan/TestCases/Posix/asan-symbolize-bad-path.cc
new file mode 100644
index 0000000..22c03e8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/asan-symbolize-bad-path.cc
@@ -0,0 +1,4 @@
+// Test that asan_symbolize does not hang when provided with an non-existing
+// path.
+// RUN: echo '#0 0xabcdabcd (%T/bad/path+0x1234)' | %asan_symbolize | FileCheck %s
+// CHECK: #0 0xabcdabcd
diff --git a/compiler-rt/test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc b/compiler-rt/test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc
new file mode 100644
index 0000000..dd59e4a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc
@@ -0,0 +1,63 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// Check that asan_symbolize.py script works (for binaries, ASan RTL and
+// shared object files.
+
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O0 %s %libdl -o %t
+// RUN: %env_asan_opts=symbolize=0 not %run %t 2>&1 | %asan_symbolize | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#if !defined(SHARED_LIB)
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string>
+
+using std::string;
+
+typedef void (fun_t)(int*, int);
+
+int main(int argc, char *argv[]) {
+  string path = string(argv[0]) + "-so.so";
+  printf("opening %s ... \n", path.c_str());
+  void *lib = dlopen(path.c_str(), RTLD_NOW);
+  if (!lib) {
+    printf("error in dlopen(): %s\n", dlerror());
+    return 1;
+  }
+  fun_t *inc2 = (fun_t*)dlsym(lib, "inc2");
+  if (!inc2) return 1;
+  printf("ok\n");
+  int *array = (int*)malloc(40);
+  inc2(array, 1);
+  inc2(array, -1);  // BOOM
+  // CHECK: ERROR: AddressSanitizer: heap-buffer-overflow
+  // CHECK: READ of size 4 at 0x{{.*}}
+  // CHECK: #0 {{.*}} in inc2 {{.*}}asan-symbolize-sanity-test.cc:[[@LINE+21]]
+  // CHECK: #1 {{.*}} in main {{.*}}asan-symbolize-sanity-test.cc:[[@LINE-4]]
+  // CHECK: allocated by thread T{{.*}} here:
+  // CHECK: #{{.*}} in {{(wrap_|__interceptor_)?}}malloc
+  // CHECK: #{{.*}} in main {{.*}}asan-symbolize-sanity-test.cc:[[@LINE-9]]
+  return 0;
+}
+#else  // SHARED_LIBS
+#include <stdio.h>
+#include <string.h>
+
+int pad[10];
+int GLOB[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+extern "C"
+void inc(int index) {
+  GLOB[index]++;
+}
+
+extern "C"
+void inc2(int *a, int index) {
+  a[index]++;
+}
+#endif  // SHARED_LIBS
diff --git a/compiler-rt/test/asan/TestCases/Posix/asprintf.cc b/compiler-rt/test/asan/TestCases/Posix/asprintf.cc
new file mode 100644
index 0000000..6946e50
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/asprintf.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+  char *p;
+  int res = asprintf(&p, "%d", argc);
+  fprintf(stderr, "x%d %sx\n", res, p);
+  // CHECK: x1 1x
+  free(p);
+  fprintf(stderr, "DONE\n");
+  // CHECK: DONE
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/assign_large_valloc_to_global.cc b/compiler-rt/test/asan/TestCases/Posix/assign_large_valloc_to_global.cc
new file mode 100644
index 0000000..8031d04
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/assign_large_valloc_to_global.cc
@@ -0,0 +1,6 @@
+// Make sure we don't report a leak nor hang.
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t
+#include <stdlib.h>
+#include <unistd.h>
+int *p;
+int main() { posix_memalign((void **)&p, 4096, 1 << 20); }
diff --git a/compiler-rt/test/asan/TestCases/Posix/closed-fds.cc b/compiler-rt/test/asan/TestCases/Posix/closed-fds.cc
new file mode 100644
index 0000000..3bbe3d8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/closed-fds.cc
@@ -0,0 +1,33 @@
+// Check that when the program closed its std(in|out|err), running the external
+// symbolizer still works.
+
+// RUN: rm -f %t.log.*
+// RUN: %clangxx_asan -O0 %s -o %t 2>&1 && %env_asan_opts=log_path=%t.log:verbosity=2 not %run %t 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-FILE < %t.log.*
+
+// FIXME: copy %t.log back from the device and re-enable on Android.
+// UNSUPPORTED: android
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  int result = fprintf(stderr, "Closing streams.\n");
+  assert(result > 0);
+  close(STDIN_FILENO);
+  close(STDOUT_FILENO);
+  close(STDERR_FILENO);
+  result = fprintf(stderr, "Can you hear me now?\n");
+  assert(result < 0);
+  char *x = (char *)malloc(10 * sizeof(char));
+  free(x);
+  x[argc] = 'X';  // BOOM
+  // CHECK-FILE: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+  // CHECK-FILE:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}
+  // CHECK-FILE: {{WRITE of size 1 at 0x.* thread T0}}
+  // CHECK-FILE: {{    #0 0x.* in main .*closed-fds.cc:}}[[@LINE-4]]
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-caller-callee.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-caller-callee.cc
new file mode 100644
index 0000000..fb8b9bf
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-caller-callee.cc
@@ -0,0 +1,75 @@
+// Test caller-callee coverage with large number of threads
+// and various numbers of callers and callees.
+
+// RUN: %clangxx_asan -fsanitize-coverage=edge,indirect-calls %s -o %t
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 10 1 2>&1 | FileCheck %s --check-prefix=CHECK-10-1
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 9  2 2>&1 | FileCheck %s --check-prefix=CHECK-9-2
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 7  3 2>&1 | FileCheck %s --check-prefix=CHECK-7-3
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 17 1 2>&1 | FileCheck %s --check-prefix=CHECK-17-1
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 15 2 2>&1 | FileCheck %s --check-prefix=CHECK-15-2
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 18 3 2>&1 | FileCheck %s --check-prefix=CHECK-18-3
+// RUN: rm -f caller-callee*.sancov
+//
+// REQUIRES: asan-64-bits
+// UNSUPPORTED: android
+//
+// CHECK-10-1: CovDump: 10 caller-callee pairs written
+// CHECK-9-2: CovDump: 18 caller-callee pairs written
+// CHECK-7-3: CovDump: 21 caller-callee pairs written
+// CHECK-17-1: CovDump: 14 caller-callee pairs written
+// CHECK-15-2: CovDump: 28 caller-callee pairs written
+// CHECK-18-3: CovDump: 42 caller-callee pairs written
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+int P = 0;
+struct Foo {virtual void f() {if (P) printf("Foo::f()\n");}};
+struct Foo1 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo2 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo3 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo4 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo5 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo6 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo7 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo8 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo9 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo10 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo11 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo12 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo13 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo14 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo15 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo16 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo17 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo18 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo19 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+
+Foo *foo[20] = {
+    new Foo,   new Foo1,  new Foo2,  new Foo3,  new Foo4,  new Foo5,  new Foo6,
+    new Foo7,  new Foo8,  new Foo9,  new Foo10, new Foo11, new Foo12, new Foo13,
+    new Foo14, new Foo15, new Foo16, new Foo17, new Foo18, new Foo19,
+};
+
+int n_functions = 10;
+int n_callers = 2;
+
+void *Thread(void *arg) {
+  if (n_callers >= 1) for (int i = 0; i < 2000; i++) foo[i % n_functions]->f();
+  if (n_callers >= 2) for (int i = 0; i < 2000; i++) foo[i % n_functions]->f();
+  if (n_callers >= 3) for (int i = 0; i < 2000; i++) foo[i % n_functions]->f();
+  return arg;
+}
+
+int main(int argc, char **argv) {
+  if (argc >= 2)
+    n_functions = atoi(argv[1]);
+  if (argc >= 3)
+    n_callers = atoi(argv[2]);
+  const int kNumThreads = 16;
+  pthread_t t[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++)
+    pthread_create(&t[i], 0, Thread, 0);
+  for (int i = 0; i < kNumThreads; i++)
+    pthread_join(t[i], 0);
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-direct-activation.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-direct-activation.cc
new file mode 100644
index 0000000..0af3296
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-direct-activation.cc
@@ -0,0 +1,59 @@
+// Test for direct coverage writing enabled at activation time.
+
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC
+// RUN: %clangxx -c -DSO_DIR=\"%T\" %s -o %t.o
+// RUN: %clangxx_asan -fsanitize-coverage=func %t.o %libdl -o %t
+
+// RUN: rm -rf %T/coverage-direct-activation
+
+// RUN: mkdir -p %T/coverage-direct-activation/normal
+// RUN: %env_asan_opts=coverage=1,coverage_direct=0,coverage_dir=%T/coverage-direct-activation/normal:verbosity=1 %run %t %dynamiclib
+// RUN: %sancov print %T/coverage-direct-activation/normal/*.sancov >%T/coverage-direct-activation/normal/out.txt
+
+// RUN: mkdir -p %T/coverage-direct-activation/direct
+// RUN: %env_asan_opts=start_deactivated=1,coverage_direct=1,verbosity=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=coverage=1,coverage_dir=%T/coverage-direct-activation/direct %run %t %dynamiclib
+// RUN: cd %T/coverage-direct-activation/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// Test start_deactivated=1,coverage=1 in ASAN_OPTIONS.
+
+// RUN: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct/out.txt
+
+// RUN: mkdir -p %T/coverage-direct-activation/direct2
+// RUN: %env_asan_opts=start_deactivated=1,coverage=1,coverage_direct=1,verbosity=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=coverage_dir=%T/coverage-direct-activation/direct2 %run %t %dynamiclib
+// RUN: cd %T/coverage-direct-activation/direct2
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// RUN: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct2/out.txt
+
+// XFAIL: android
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#ifdef SHARED
+extern "C" {
+void bar() { printf("bar\n"); }
+}
+#else
+
+int main(int argc, char **argv) {
+  fprintf(stderr, "PID: %d\n", getpid());
+  assert(argc > 1);
+  void *handle1 = dlopen(argv[1], RTLD_LAZY);  // %dynamiclib
+  assert(handle1);
+  void (*bar1)() = (void (*)())dlsym(handle1, "bar");
+  assert(bar1);
+  bar1();
+
+  return 0;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-direct-large.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-direct-large.cc
new file mode 100644
index 0000000..367a566
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-direct-large.cc
@@ -0,0 +1,65 @@
+// Test for direct coverage writing with lots of data.
+// Current implementation maps output file in chunks of 64K. This test overflows
+// 1 chunk.
+
+// RUN: %clangxx_asan -fsanitize-coverage=func -O0 -DSHARED %s -shared -o %dynamiclib -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func -O0 %s %libdl -o %t
+
+// RUN: rm -rf %T/coverage-direct-large
+
+// RUN: mkdir -p %T/coverage-direct-large/normal && cd %T/coverage-direct-large/normal
+// RUN: %env_asan_opts=coverage=1:coverage_direct=0:verbosity=1 %run %t %dynamiclib
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// RUN: mkdir -p %T/coverage-direct-large/direct && cd %T/coverage-direct-large/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:verbosity=1 %run %t %dynamiclib
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// RUN: diff -u coverage-direct-large/normal/out.txt coverage-direct-large/direct/out.txt
+//
+// XFAIL: android
+
+#define F0(Q, x) Q(x)
+#define F1(Q, x)                                                          \
+  F0(Q, x##0) F0(Q, x##1) F0(Q, x##2) F0(Q, x##3) F0(Q, x##4) F0(Q, x##5) \
+      F0(Q, x##6) F0(Q, x##7) F0(Q, x##8) F0(Q, x##9)
+#define F2(Q, x)                                                          \
+  F1(Q, x##0) F1(Q, x##1) F1(Q, x##2) F1(Q, x##3) F1(Q, x##4) F1(Q, x##5) \
+      F1(Q, x##6) F1(Q, x##7) F1(Q, x##8) F1(Q, x##9)
+#define F3(Q, x)                                                          \
+  F2(Q, x##0) F2(Q, x##1) F2(Q, x##2) F2(Q, x##3) F2(Q, x##4) F2(Q, x##5) \
+      F2(Q, x##6) F2(Q, x##7) F2(Q, x##8) F2(Q, x##9)
+#define F4(Q, x)                                                          \
+  F3(Q, x##0) F3(Q, x##1) F3(Q, x##2) F3(Q, x##3) F3(Q, x##4) F3(Q, x##5) \
+      F3(Q, x##6) F3(Q, x##7) F3(Q, x##8) F3(Q, x##9)
+
+#define DECL(x) __attribute__((noinline)) static void x() {}
+#define CALL(x) x();
+
+F4(DECL, f)
+
+#ifdef SHARED
+extern "C" void so_entry() {
+  F4(CALL, f)
+}  
+#else
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+int main(int argc, char **argv) {
+  F4(CALL, f)
+  assert(argc > 1);
+  void *handle1 = dlopen(argv[1], RTLD_LAZY);  // %dynamiclib
+  assert(handle1);
+  void (*so_entry)() = (void (*)())dlsym(handle1, "so_entry");
+  assert(so_entry);
+  so_entry();
+
+  return 0;
+}
+
+#endif // SHARED
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-direct.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-direct.cc
new file mode 100644
index 0000000..8caa9c5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-direct.cc
@@ -0,0 +1,83 @@
+// Test for direct coverage writing with dlopen at coverage level 1 to 3.
+
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t
+
+// RUN: rm -rf %T/coverage-direct
+
+// RUN: mkdir -p %T/coverage-direct/normal
+// RUN: %env_asan_opts=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
+// RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
+
+// RUN: mkdir -p %T/coverage-direct/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
+// RUN: cd %T/coverage-direct/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
+
+
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED %s -shared -o %dynamiclib -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%T\" %s %libdl -o %t
+
+// RUN: rm -rf %T/coverage-direct
+
+// RUN: mkdir -p %T/coverage-direct/normal
+// RUN: %env_asan_opts=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
+// RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
+
+// RUN: mkdir -p %T/coverage-direct/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
+// RUN: cd %T/coverage-direct/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
+
+
+// RUN: %clangxx_asan -fsanitize-coverage=edge -DSHARED %s -shared -o %dynamiclib -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%T\" %s %libdl -o %t
+
+// RUN: rm -rf %T/coverage-direct
+
+// RUN: mkdir -p %T/coverage-direct/normal
+// RUN: %env_asan_opts=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
+// RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
+
+// RUN: mkdir -p %T/coverage-direct/direct
+// RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
+// RUN: cd %T/coverage-direct/direct
+// RUN: %sancov rawunpack *.sancov.raw
+// RUN: %sancov print *.sancov >out.txt
+// RUN: cd ../..
+
+// RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
+
+// XFAIL: android
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#ifdef SHARED
+extern "C" {
+void bar() { printf("bar\n"); }
+}
+#else
+
+int main(int argc, char **argv) {
+  fprintf(stderr, "PID: %d\n", getpid());
+  assert(argc > 1);
+  void *handle1 = dlopen(argv[1], RTLD_LAZY);
+  assert(handle1);
+  void (*bar1)() = (void (*)())dlsym(handle1, "bar");
+  assert(bar1);
+  bar1();
+
+  return 0;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-fork-direct.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-fork-direct.cc
new file mode 100644
index 0000000..c196719
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-fork-direct.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+// RUN: rm -rf %T/coverage-fork-direct
+// RUN: mkdir -p %T/coverage-fork-direct && cd %T/coverage-fork-direct
+// RUN: (%env_asan_opts=coverage=1:coverage_direct=1:verbosity=1 %run %t; \
+// RUN:  %sancov rawunpack *.sancov.raw; %sancov print *.sancov) 2>&1
+//
+// XFAIL: android
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+__attribute__((noinline))
+void foo() { printf("foo\n"); }
+
+__attribute__((noinline))
+void bar() { printf("bar\n"); }
+
+__attribute__((noinline))
+void baz() { printf("baz\n"); }
+
+int main(int argc, char **argv) {
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    fprintf(stderr, "Child PID: %d\n", getpid());
+    baz();
+  } else {
+    fprintf(stderr, "Parent PID: %d\n", getpid());
+    foo();
+    bar();
+  }
+  return 0;
+}
+
+// CHECK-DAG: Child PID: [[ChildPID:[0-9]+]]
+// CHECK-DAG: Parent PID: [[ParentPID:[0-9]+]]
+// CHECK-DAG: read 3 PCs from {{.*}}.[[ParentPID]].sancov
+// CHECK-DAG: read 1 PCs from {{.*}}.[[ChildPID]].sancov
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-fork.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-fork.cc
new file mode 100644
index 0000000..799d716
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-fork.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+// RUN: rm -rf %T/coverage-fork
+// RUN: mkdir -p %T/coverage-fork && cd %T/coverage-fork
+// RUN: %env_asan_opts=coverage=1:coverage_direct=0:verbosity=1 %run %t 2>&1 | FileCheck %s
+//
+// XFAIL: android
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+__attribute__((noinline))
+void foo() { printf("foo\n"); }
+
+__attribute__((noinline))
+void bar() { printf("bar\n"); }
+
+__attribute__((noinline))
+void baz() { printf("baz\n"); }
+
+int main(int argc, char **argv) {
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    fprintf(stderr, "Child PID: %d\n", getpid());
+    baz();
+  } else {
+    fprintf(stderr, "Parent PID: %d\n", getpid());
+    foo();
+    bar();
+  }
+  return 0;
+}
+
+// CHECK-DAG: Child PID: [[ChildPID:[0-9]+]]
+// CHECK-DAG: [[ChildPID]].sancov: 1 PCs written
+// CHECK-DAG: Parent PID: [[ParentPID:[0-9]+]]
+// CHECK-DAG: [[ParentPID]].sancov: 3 PCs written
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-maybe-open-file.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-maybe-open-file.cc
new file mode 100644
index 0000000..cab3d57
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-maybe-open-file.cc
@@ -0,0 +1,32 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+// RUN: rm -rf %T/coverage-maybe-open-file
+// RUN: mkdir -p %T/coverage-maybe-open-file && cd %T/coverage-maybe-open-file
+// RUN: %env_asan_opts=coverage=1 %run %t | FileCheck %s --check-prefix=CHECK-success
+// RUN: %env_asan_opts=coverage=0 %run %t | FileCheck %s --check-prefix=CHECK-fail
+// RUN: [ "$(cat test.sancov.packed)" == "test" ]
+// RUN: cd .. && rm -rf %T/coverage-maybe-open-file
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sanitizer/coverage_interface.h>
+
+// FIXME: the code below might not work on Windows.
+int main(int argc, char **argv) {
+  int fd = __sanitizer_maybe_open_cov_file("test");
+  if (fd > 0) {
+    printf("SUCCESS\n");
+    const char s[] = "test\n";
+    write(fd, s, strlen(s));
+    close(fd);
+  } else {
+    printf("FAIL\n");
+  }
+}
+
+// CHECK-success: SUCCESS
+// CHECK-fail: FAIL
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-module-unloaded.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-module-unloaded.cc
new file mode 100644
index 0000000..d492af6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-module-unloaded.cc
@@ -0,0 +1,54 @@
+// Check that unloading a module doesn't break coverage dumping for remaining
+// modules.
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib1 -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib2 -fPIC
+// RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t
+// RUN: mkdir -p %T/coverage-module-unloaded && cd %T/coverage-module-unloaded
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t %dynamiclib1 %dynamiclib2 2>&1        | FileCheck %s
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t %dynamiclib1 %dynamiclib2 foo 2>&1    | FileCheck %s
+// RUN: rm -r %T/coverage-module-unloaded
+//
+// https://code.google.com/p/address-sanitizer/issues/detail?id=263
+// XFAIL: android
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#ifdef SHARED
+extern "C" {
+void bar() { printf("bar\n"); }
+}
+#else
+
+int main(int argc, char **argv) {
+  fprintf(stderr, "PID: %d\n", getpid());
+  assert(argc > 2);
+  void *handle1 = dlopen(argv[1], RTLD_LAZY);  // %dynamiclib1
+  assert(handle1);
+  void (*bar1)() = (void (*)())dlsym(handle1, "bar");
+  assert(bar1);
+  bar1();
+  void *handle2 = dlopen(argv[2], RTLD_LAZY);  // %dynamiclib2
+  assert(handle2);
+  void (*bar2)() = (void (*)())dlsym(handle2, "bar");
+  assert(bar2);
+  bar2();
+
+  // It matters whether the unloaded module has a higher or lower address range
+  // than the remaining one. Make sure to test both cases.
+  if (argc < 2)
+    dlclose(bar1 < bar2 ? handle1 : handle2);
+  else
+    dlclose(bar1 < bar2 ? handle2 : handle1);
+  return 0;
+}
+#endif
+
+// CHECK: PID: [[PID:[0-9]+]]
+// CHECK: [[PID]].sancov: 1 PCs written
+// CHECK: coverage-module-unloaded{{.*}}1.[[PID]]
+// CHECK: coverage-module-unloaded{{.*}}2.[[PID]]
+// Even though we've unloaded one of the libs we still dump the coverage file
+// for that lib (although the data will be inaccurate, if at all useful)
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-sandboxing.cc b/compiler-rt/test/asan/TestCases/Posix/coverage-sandboxing.cc
new file mode 100644
index 0000000..f6fc526
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-sandboxing.cc
@@ -0,0 +1,86 @@
+// RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED %s -shared -o %dynamiclib -fPIC %ld_flags_rpath_so
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t %ld_flags_rpath_exe
+
+// RUN: rm -rf %T/coverage_sandboxing_test
+// RUN: mkdir %T/coverage_sandboxing_test && cd %T/coverage_sandboxing_test
+// RUN: mkdir vanilla && cd vanilla
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 2>&1  | FileCheck %s --check-prefix=CHECK-vanilla
+// RUN: mkdir ../sandbox1 && cd ../sandbox1
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t a 2>&1 | FileCheck %s --check-prefix=CHECK-sandbox
+// RUN: %sancov unpack coverage_sandboxing_test.sancov.packed
+// RUN: mkdir ../sandbox2 && cd ../sandbox2
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t a b 2>&1 | FileCheck %s --check-prefix=CHECK-sandbox
+// RUN: %sancov unpack coverage_sandboxing_test.sancov.packed
+// RUN: cd ..
+// RUN: %sancov print vanilla/`basename %dynamiclib`*.sancov > vanilla.txt
+// RUN: %sancov print sandbox1/`basename %dynamiclib`*.sancov > sandbox1.txt
+// RUN: %sancov print sandbox2/`basename %dynamiclib`*.sancov > sandbox2.txt
+// RUN: diff vanilla.txt sandbox1.txt
+// RUN: diff vanilla.txt sandbox2.txt
+// RUN: rm -r %T/coverage_sandboxing_test
+
+// https://code.google.com/p/address-sanitizer/issues/detail?id=263
+// XFAIL: android
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sanitizer/coverage_interface.h>
+
+#define bb0(n)                        \
+  case n:                             \
+    fprintf(stderr, "foo: %d\n", n);  \
+    break;
+
+#define bb1(n) bb0(n) bb0(n + 1)
+#define bb2(n) bb1(n) bb1(n + 2)
+#define bb3(n) bb2(n) bb2(n + 4)
+#define bb4(n) bb3(n) bb3(n + 8)
+#define bb5(n) bb4(n) bb4(n + 16)
+#define bb6(n) bb5(n) bb5(n + 32)
+#define bb7(n) bb6(n) bb6(n + 64)
+#define bb8(n) bb7(n) bb7(n + 128)
+
+#ifdef SHARED
+void foo(int i) {
+  switch(i) {
+    // 256 basic blocks
+    bb8(0)
+  }
+}
+#else
+extern void foo(int i);
+
+int main(int argc, char **argv) {
+  assert(argc <= 3);
+  for (int i = 0; i < 256; i++) foo(i);
+  fprintf(stderr, "PID: %d\n", getpid());
+  if (argc == 1) {
+    // Vanilla mode, dump to individual files.
+    return 0;
+  }
+  // Dump to packed file.
+  int fd = creat("coverage_sandboxing_test.sancov.packed", 0660);
+  __sanitizer_sandbox_arguments args = {0};
+  args.coverage_sandboxed = 1;
+  args.coverage_fd = fd;
+  if (argc == 2)
+    // Write to packed file, do not split into blocks.
+    args.coverage_max_block_size = 0;
+  else if (argc == 3)
+    // Write to packed file, split into blocks (as if writing to a socket).
+    args.coverage_max_block_size = 100;
+  __sanitizer_sandbox_on_notify(&args);
+  return 0;
+}
+#endif
+
+// CHECK-vanilla: PID: [[PID:[0-9]+]]
+// CHECK-vanilla: .so.[[PID]].sancov: 258 PCs written
+// CHECK-vanilla: [[PID]].sancov: 1 PCs written
+
+// CHECK-sandbox: PID: [[PID:[0-9]+]]
+// CHECK-sandbox: 258 PCs written to packed file
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage.cc b/compiler-rt/test/asan/TestCases/Posix/coverage.cc
new file mode 100644
index 0000000..7c1c494
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage.cc
@@ -0,0 +1,80 @@
+// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC %ld_flags_rpath_so
+// RUN: %clangxx_asan -fsanitize-coverage=func %s %ld_flags_rpath_exe -o %t
+// RUN: rm -rf %T/coverage && mkdir -p %T/coverage && cd %T/coverage
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 2>&1         | FileCheck %s --check-prefix=CHECK-main
+// RUN: %sancov print `ls coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV1
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t foo 2>&1     | FileCheck %s --check-prefix=CHECK-foo
+// RUN: %sancov print `ls coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t bar 2>&1     | FileCheck %s --check-prefix=CHECK-bar
+// RUN: %sancov print `ls *coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t foo bar 2>&1 | FileCheck %s --check-prefix=CHECK-foo-bar
+// RUN: %sancov print `ls *coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
+// RUN: %sancov print `ls *coverage.*sancov | grep '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV1
+// RUN: %sancov merge `ls *coverage.*sancov | grep -v '.so'` > merged-cov
+// RUN: %sancov print merged-cov 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
+// RUN: %env_asan_opts=coverage=1:verbosity=1 not %run %t foo bar 4    2>&1 | FileCheck %s --check-prefix=CHECK-report
+// RUN: %env_asan_opts=coverage=1:verbosity=1 not %run %t foo bar 4 5  2>&1 | FileCheck %s --check-prefix=CHECK-segv
+// RUN: rm -r %T/coverage
+//
+// https://code.google.com/p/address-sanitizer/issues/detail?id=263
+// XFAIL: android
+
+#include <sanitizer/coverage_interface.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef SHARED
+void bar() { printf("bar\n"); }
+#else
+__attribute__((noinline))
+void foo() { printf("foo\n"); }
+extern void bar();
+
+int G[4];
+
+int main(int argc, char **argv) {
+  fprintf(stderr, "PID: %d\n", getpid());
+  for (int i = 1; i < argc; i++) {
+    if (!strcmp(argv[i], "foo")) {
+      uintptr_t old_coverage = __sanitizer_get_total_unique_coverage();
+      foo();
+      uintptr_t new_coverage = __sanitizer_get_total_unique_coverage();
+      assert(new_coverage > old_coverage);
+    }
+    if (!strcmp(argv[i], "bar"))
+      bar();
+  }
+  if (argc == 5) {
+    static volatile char *zero = 0;
+    *zero = 0;  // SEGV if argc == 5.
+  }
+  return G[argc];  // Buffer overflow if argc >= 4.
+}
+#endif
+
+// CHECK-main: PID: [[PID:[0-9]+]]
+// CHECK-main: [[PID]].sancov: 1 PCs written
+// CHECK-main-NOT: .so.[[PID]]
+//
+// CHECK-foo: PID: [[PID:[0-9]+]]
+// CHECK-foo: [[PID]].sancov: 2 PCs written
+// CHECK-foo-NOT: .so.[[PID]]
+//
+// CHECK-bar: PID: [[PID:[0-9]+]]
+// CHECK-bar: .so.[[PID]].sancov: 1 PCs written
+// CHECK-bar: [[PID]].sancov: 1 PCs written
+//
+// CHECK-foo-bar: PID: [[PID:[0-9]+]]
+// CHECK-foo-bar: so.[[PID]].sancov: 1 PCs written
+// CHECK-foo-bar: [[PID]].sancov: 2 PCs written
+//
+// CHECK-report: AddressSanitizer: global-buffer-overflow
+// CHECK-report: PCs written
+//
+// CHECK-segv: AddressSanitizer: SEGV
+// CHECK-segv: PCs written
+//
+// CHECK-SANCOV1: 1 PCs total
+// CHECK-SANCOV2: 2 PCs total
diff --git a/compiler-rt/test/asan/TestCases/Posix/current_allocated_bytes.cc b/compiler-rt/test/asan/TestCases/Posix/current_allocated_bytes.cc
new file mode 100644
index 0000000..c49e433
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/current_allocated_bytes.cc
@@ -0,0 +1,44 @@
+// RUN: %clangxx_asan -O0 %s -pthread -o %t && %run %t
+// RUN: %clangxx_asan -O2 %s -pthread -o %t && %run %t
+// REQUIRES: stable-runtime
+
+#include <assert.h>
+#include <pthread.h>
+#include <sanitizer/allocator_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+const size_t kLargeAlloc = 1UL << 20;
+
+void* allocate(void *arg) {
+  volatile void *ptr = malloc(kLargeAlloc);
+  free((void*)ptr);
+  return 0;
+}
+
+void* check_stats(void *arg) {
+  assert(__sanitizer_get_current_allocated_bytes() > 0);
+  return 0;
+}
+
+int main() {
+  size_t used_mem = __sanitizer_get_current_allocated_bytes();
+  printf("Before: %zu\n", used_mem);
+  const int kNumIterations = 1000;
+  for (int iter = 0; iter < kNumIterations; iter++) {
+    pthread_t thr[4];
+    for (int j = 0; j < 4; j++) {
+      assert(0 ==
+             pthread_create(&thr[j], 0, (j < 2) ? allocate : check_stats, 0));
+    }
+    for (int j = 0; j < 4; j++)
+      assert(0 == pthread_join(thr[j], 0));
+    used_mem = __sanitizer_get_current_allocated_bytes();
+    if (used_mem > kLargeAlloc) {
+      printf("After iteration %d: %zu\n", iter, used_mem);
+      return 1;
+    }
+  }
+  printf("Success after %d iterations\n", kNumIterations);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/deep_call_stack.cc b/compiler-rt/test/asan/TestCases/Posix/deep_call_stack.cc
new file mode 100644
index 0000000..18ba563
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/deep_call_stack.cc
@@ -0,0 +1,25 @@
+// Check that UAR mode can handle very deep recusrion.
+// RUN: %clangxx_asan -O2 %s -o %t && \
+// RUN:   (ulimit -s 4096; %env_asan_opts=detect_stack_use_after_return=1 %run %t) 2>&1 | FileCheck %s
+
+// Also check that use_sigaltstack+verbosity doesn't crash.
+// RUN: %env_asan_opts=verbosity=1:use_sigaltstack=1:detect_stack_use_after_return=1 %run %t  | FileCheck %s
+#include <stdio.h>
+
+__attribute__((noinline))
+void RecursiveFunc(int depth, int *ptr) {
+  if ((depth % 1000) == 0)
+    printf("[%05d] ptr: %p\n", depth, ptr);
+  if (depth == 0)
+    return;
+  int local;
+  RecursiveFunc(depth - 1, &local);
+}
+
+int main(int argc, char **argv) {
+  RecursiveFunc(15000, 0);
+  return 0;
+}
+// CHECK: [15000] ptr:
+// CHECK: [07000] ptr:
+// CHECK: [00000] ptr:
diff --git a/compiler-rt/test/asan/TestCases/Posix/deep_thread_stack.cc b/compiler-rt/test/asan/TestCases/Posix/deep_thread_stack.cc
new file mode 100644
index 0000000..535da79
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/deep_thread_stack.cc
@@ -0,0 +1,58 @@
+// RUN: %clangxx_asan -O0 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
+// REQUIRES: stable-runtime
+
+#include <pthread.h>
+
+int *x;
+
+void *AllocThread(void *arg) {
+  x = new int;
+  *x = 42;
+  return NULL;
+}
+
+void *FreeThread(void *arg) {
+  delete x;
+  return NULL;
+}
+
+void *AccessThread(void *arg) {
+  *x = 43;  // BOOM
+  return NULL;
+}
+
+typedef void* (*callback_type)(void* arg);
+
+void *RunnerThread(void *function) {
+  pthread_t thread;
+  pthread_create(&thread, NULL, (callback_type)function, NULL);
+  pthread_join(thread, NULL);
+  return NULL;
+}
+
+void RunThread(callback_type function) {
+  pthread_t runner;
+  pthread_create(&runner, NULL, RunnerThread, (void*)function);
+  pthread_join(runner, NULL);
+}
+
+int main(int argc, char *argv[]) {
+  RunThread(AllocThread);
+  RunThread(FreeThread);
+  RunThread(AccessThread);
+  return (x != 0);
+}
+
+// CHECK: AddressSanitizer: heap-use-after-free
+// CHECK: WRITE of size 4 at 0x{{.*}} thread T[[ACCESS_THREAD:[0-9]+]]
+// CHECK: freed by thread T[[FREE_THREAD:[0-9]+]] here:
+// CHECK: previously allocated by thread T[[ALLOC_THREAD:[0-9]+]] here:
+// CHECK: Thread T[[ACCESS_THREAD]] created by T[[ACCESS_RUNNER:[0-9]+]] here:
+// CHECK: Thread T[[ACCESS_RUNNER]] created by T0 here:
+// CHECK: Thread T[[FREE_THREAD]] created by T[[FREE_RUNNER:[0-9]+]] here:
+// CHECK: Thread T[[FREE_RUNNER]] created by T0 here:
+// CHECK: Thread T[[ALLOC_THREAD]] created by T[[ALLOC_RUNNER:[0-9]+]] here:
+// CHECK: Thread T[[ALLOC_RUNNER]] created by T0 here:
diff --git a/compiler-rt/test/asan/TestCases/Posix/dlclose-test.cc b/compiler-rt/test/asan/TestCases/Posix/dlclose-test.cc
new file mode 100644
index 0000000..369abd3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/dlclose-test.cc
@@ -0,0 +1,106 @@
+// Regression test for
+// http://code.google.com/p/address-sanitizer/issues/detail?id=19
+// Bug description:
+// 1. application dlopens foo.so
+// 2. asan registers all globals from foo.so
+// 3. application dlcloses foo.so
+// 4. application mmaps some memory to the location where foo.so was before
+// 5. application starts using this mmaped memory, but asan still thinks there
+// are globals.
+// 6. BOOM
+
+// This sublte test assumes that after a foo.so is dlclose-d
+// we can mmap the region of memory that has been occupied by the library.
+// It works on i368/x86_64 Linux, but not necessary anywhere else.
+// REQUIRES: x86_64-supported-target,i386-supported-target
+
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O0 %s %libdl -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O1 %s %libdl -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O2 %s %libdl -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O3 %s %libdl -o %t && %run %t 2>&1 | FileCheck %s
+
+#if !defined(SHARED_LIB)
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <string>
+
+#if defined(__FreeBSD__)
+// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
+// that, it was never implemented. So just define it to zero.
+#undef MAP_NORESERVE
+#define MAP_NORESERVE 0
+#endif
+
+using std::string;
+
+typedef int *(fun_t)();
+
+int main(int argc, char *argv[]) {
+  string path = string(argv[0]) + "-so.so";
+  size_t PageSize = sysconf(_SC_PAGESIZE);
+  printf("opening %s ... \n", path.c_str());
+  void *lib = dlopen(path.c_str(), RTLD_NOW);
+  if (!lib) {
+    printf("error in dlopen(): %s\n", dlerror());
+    return 1;
+  }
+  fun_t *get = (fun_t*)dlsym(lib, "get_address_of_static_var");
+  if (!get) {
+    printf("failed dlsym\n");
+    return 1;
+  }
+  int *addr = get();
+  assert(((size_t)addr % 32) == 0);  // should be 32-byte aligned.
+  printf("addr: %p\n", addr);
+  addr[0] = 1;  // make sure we can write there.
+
+  // Now dlclose the shared library.
+  printf("attempting to dlclose\n");
+  if (dlclose(lib)) {
+    printf("failed to dlclose\n");
+    return 1;
+  }
+  // Now, the page where 'addr' is unmapped. Map it.
+  size_t page_beg = ((size_t)addr) & ~(PageSize - 1);
+  void *res = mmap((void*)(page_beg), PageSize,
+                   PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANON | MAP_FIXED | MAP_NORESERVE, -1, 0);
+  if (res == (char*)-1L) {
+    printf("failed to mmap\n");
+    return 1;
+  }
+  addr[1] = 2;  // BOOM (if the bug is not fixed).
+  printf("PASS\n");
+  // CHECK: PASS
+  return 0;
+}
+#else  // SHARED_LIB
+#include <stdio.h>
+
+static int pad1;
+static int static_var;
+static int pad2;
+
+extern "C"
+int *get_address_of_static_var() {
+  return &static_var;
+}
+
+__attribute__((constructor))
+void at_dlopen() {
+  printf("%s: I am being dlopened\n", __FILE__);
+}
+__attribute__((destructor))
+void at_dlclose() {
+  printf("%s: I am being dlclosed\n", __FILE__);
+}
+#endif  // SHARED_LIB
diff --git a/compiler-rt/test/asan/TestCases/Posix/free_hook_realloc.cc b/compiler-rt/test/asan/TestCases/Posix/free_hook_realloc.cc
new file mode 100644
index 0000000..cbc5d6f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/free_hook_realloc.cc
@@ -0,0 +1,34 @@
+// Check that free hook doesn't conflict with Realloc.
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sanitizer/allocator_interface.h>
+
+static void *glob_ptr;
+
+extern "C" {
+void __sanitizer_free_hook(const volatile void *ptr) {
+  if (ptr == glob_ptr) {
+    *(int*)ptr = 0;
+    write(1, "FreeHook\n", sizeof("FreeHook\n"));
+  }
+}
+}
+
+int main() {
+  int *x = (int*)malloc(100);
+  x[0] = 42;
+  glob_ptr = x;
+  int *y = (int*)realloc(x, 200);
+  // Verify that free hook was called and didn't spoil the memory.
+  if (y[0] != 42) {
+    _exit(1);
+  }
+  write(1, "Passed\n", sizeof("Passed\n"));
+  free(y);
+  // CHECK: FreeHook
+  // CHECK: Passed
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/freopen.cc b/compiler-rt/test/asan/TestCases/Posix/freopen.cc
new file mode 100644
index 0000000..c137abb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/freopen.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t
+
+// This fails on i386 Linux due to a glibc versioned symbols mixup.
+// REQUIRES: asan-64-bits
+
+#include <assert.h>
+#include <stdio.h>
+
+int main() {
+  FILE *fp = fopen("/dev/null", "w");
+  assert(fp);
+  freopen(NULL, "a", fp);
+  fclose(fp);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/gc-test.cc b/compiler-rt/test/asan/TestCases/Posix/gc-test.cc
new file mode 100644
index 0000000..56d8c39
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/gc-test.cc
@@ -0,0 +1,54 @@
+// RUN: %clangxx_asan %s -pthread -o %t
+// RUN: %env_asan_opts=detect_stack_use_after_return=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %env_asan_opts=detect_stack_use_after_return=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
+// RUN: %clangxx_asan -O3 %s -pthread -o %t
+// RUN: %env_asan_opts=detect_stack_use_after_return=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %env_asan_opts=detect_stack_use_after_return=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
+// REQUIRES: stable-runtime
+
+#include <assert.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <sanitizer/asan_interface.h>
+
+static const int kNumThreads = 2;
+static const int kLeftRedzoneSize = sizeof(void *) * 4;
+
+void *Thread(void *unused)  {
+  void *fake_stack = __asan_get_current_fake_stack();
+  char var[15];
+  if (fake_stack) {
+    fprintf(stderr, "fake stack found: %p; var: %p\n", fake_stack, var);
+    // CHECK1: fake stack found
+    // CHECK1: fake stack found
+    void *beg, *end;
+    void *real_stack =
+        __asan_addr_is_in_fake_stack(fake_stack, &var[0], &beg, &end);
+    assert(real_stack);
+    assert((char*)beg <= (char*)&var[0]);
+    assert((char*)end > (char*)&var[0]);
+    for (int i = -kLeftRedzoneSize; i < 15; i++) {
+      void *beg1, *end1;
+      char *ptr = &var[0] + i;
+      void *real_stack1 =
+          __asan_addr_is_in_fake_stack(fake_stack, ptr, &beg1, &end1);
+      assert(real_stack == real_stack1);
+      assert(beg == beg1);
+      assert(end == end1);
+    }
+  } else {
+    fprintf(stderr, "no fake stack\n");
+    // CHECK0: no fake stack
+    // CHECK0: no fake stack
+  }
+  return NULL;
+}
+
+int main(int argc, char **argv) {
+  pthread_t t[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++)
+    pthread_create(&t[i], 0, Thread, 0);
+  for (int i = 0; i < kNumThreads; i++)
+    pthread_join(t[i], 0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/glob.cc b/compiler-rt/test/asan/TestCases/Posix/glob.cc
new file mode 100644
index 0000000..e0eeb33
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/glob.cc
@@ -0,0 +1,33 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <string>
+
+
+int main(int argc, char *argv[]) {
+  std::string path = argv[1];
+  std::string pattern = path + "/glob_test_root/*a";
+  printf("pattern: %s\n", pattern.c_str());
+
+  glob_t globbuf;
+  int res = glob(pattern.c_str(), 0, 0, &globbuf);
+
+  printf("%d %s\n", errno, strerror(errno));
+  assert(res == 0);
+  assert(globbuf.gl_pathc == 2);
+  printf("%zu\n", strlen(globbuf.gl_pathv[0]));
+  printf("%zu\n", strlen(globbuf.gl_pathv[1]));
+  globfree(&globbuf);
+  printf("PASS\n");
+  // CHECK: PASS
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/glob_test_root/aa b/compiler-rt/test/asan/TestCases/Posix/glob_test_root/aa
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/glob_test_root/aa
diff --git a/compiler-rt/test/asan/TestCases/Posix/glob_test_root/ab b/compiler-rt/test/asan/TestCases/Posix/glob_test_root/ab
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/glob_test_root/ab
diff --git a/compiler-rt/test/asan/TestCases/Posix/glob_test_root/ba b/compiler-rt/test/asan/TestCases/Posix/glob_test_root/ba
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/glob_test_root/ba
diff --git a/compiler-rt/test/asan/TestCases/Posix/halt_on_error-signals.c b/compiler-rt/test/asan/TestCases/Posix/halt_on_error-signals.c
new file mode 100644
index 0000000..60916f6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/halt_on_error-signals.c
@@ -0,0 +1,102 @@
+// Test interaction of Asan recovery mode with asynch signals.
+//
+// RUN: %clang_asan -fsanitize-recover=address -pthread %s -o %t
+//
+// RUN: rm -f %t.log
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false %run %t 100 >%t.log 2>&1 || true
+// Collision will almost always get triggered but we still need to check the unlikely case:
+// RUN: FileCheck --check-prefix=CHECK-COLLISION %s < %t.log || FileCheck --check-prefix=CHECK-NO-COLLISION %s < %t.log
+
+#define _SVID_SOURCE 1  // SA_NODEFER
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <time.h>
+#include <signal.h>
+
+#include <sanitizer/asan_interface.h>
+
+void random_delay(unsigned *seed) {
+  *seed = 1664525 * *seed + 1013904223;
+  struct timespec delay = { 0, (*seed % 1000) * 1000 };
+  nanosleep(&delay, 0);
+}
+
+volatile char bad[2] = {1, };
+
+void error() {
+  // CHECK-COLLISION: AddressSanitizer: nested bug in the same thread, aborting
+  // CHECK-NO-COLLISION: AddressSanitizer: use-after-poison
+  volatile int idx = 0;
+  bad[idx] = 0;
+}
+
+#define CHECK_CALL(e, msg) do {             \
+  if (0 != (e)) {                           \
+    fprintf(stderr, "Failed to " msg "\n"); \
+    exit(1);                                \
+  }                                         \
+} while (0)
+
+size_t niter = 10;
+pthread_t sender_tid, receiver_tid;
+
+pthread_mutex_t keep_alive_mu = PTHREAD_MUTEX_INITIALIZER;
+
+void *sender(void *arg) {
+  unsigned seed = 0;
+  for (size_t i = 0; i < niter; ++i) {
+    random_delay(&seed);
+    CHECK_CALL(pthread_kill(receiver_tid, SIGUSR1), "send signal");
+  }
+  return 0;
+}
+
+void handler(int sig) {
+  // Expect error collisions here
+  error();
+}
+
+void *receiver(void *arg) {
+  unsigned seed = 1;
+  for (size_t i = 0; i < niter; ++i) {
+    random_delay(&seed);
+    // And here
+    error();
+  }
+  // Parent will release this when it's ok to terminate
+  CHECK_CALL(pthread_mutex_lock(&keep_alive_mu), "unlock mutex");
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  if (argc != 2) {
+    fprintf(stderr, "Syntax: %s niter\n", argv[0]);
+    exit(1);
+  }
+
+  niter = (size_t)strtoul(argv[1], 0, 0);
+
+  struct sigaction sa;
+  memset(&sa, 0, sizeof(sa));
+  sa.sa_handler = handler;
+  sa.sa_flags = SA_NODEFER; // Enable nested handlers to add more stress
+  CHECK_CALL(sigaction(SIGUSR1, &sa, 0), "set sighandler");
+
+  __asan_poison_memory_region(&bad, sizeof(bad));
+
+  CHECK_CALL(pthread_mutex_lock(&keep_alive_mu), "lock mutex");
+  CHECK_CALL(pthread_create(&receiver_tid, 0, receiver, 0), "start thread");
+  CHECK_CALL(pthread_create(&sender_tid, 0, sender, 0), "start thread");
+  CHECK_CALL(pthread_join(sender_tid, 0), "join thread");
+  // Now allow receiver to die
+  CHECK_CALL(pthread_mutex_unlock(&keep_alive_mu), "unlock mutex");
+  CHECK_CALL(pthread_join(receiver_tid, 0), "join thread");
+
+  // CHECK-NO-COLLISION: All threads terminated
+  printf("All threads terminated\n");
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/halt_on_error-torture.cc b/compiler-rt/test/asan/TestCases/Posix/halt_on_error-torture.cc
new file mode 100644
index 0000000..019f7d1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/halt_on_error-torture.cc
@@ -0,0 +1,87 @@
+// Stress test recovery mode with many threads.
+//
+// RUN: %clangxx_asan -fsanitize-recover=address -pthread %s -o %t
+//
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false %run %t 1 10 >1.txt 2>&1
+// RUN: FileCheck %s < 1.txt
+// RUN: [ $(grep -c 'ERROR: AddressSanitizer: use-after-poison' 1.txt) -eq 10 ]
+// RUN: FileCheck --check-prefix=CHECK-NO-COLLISION %s < 1.txt
+//
+// Collisions are unlikely but still possible so we need the ||.
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false %run %t 10 20 >10.txt 2>&1 || true
+// This one is racy although _very_ unlikely to fail:
+// RUN: FileCheck %s < 10.txt
+// RUN: FileCheck --check-prefix=CHECK-COLLISION %s < 1.txt || FileCheck --check-prefix=CHECK-NO-COLLISION %s < 1.txt
+//
+// Collisions are unlikely but still possible so we need the ||.
+// RUN: %env_asan_opts=halt_on_error=false %run %t 10 20 >10.txt 2>&1 || true
+// This one is racy although _very_ unlikely to fail:
+// RUN: FileCheck %s < 10.txt
+// RUN: FileCheck --check-prefix=CHECK-COLLISION %s < 1.txt || FileCheck --check-prefix=CHECK-NO-COLLISION %s < 1.txt
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <time.h>
+
+#include <sanitizer/asan_interface.h>
+
+size_t nthreads = 10;
+size_t niter = 10;
+
+void random_delay(unsigned *seed) {
+  *seed = 1664525 * *seed + 1013904223;
+  struct timespec delay = { 0, (*seed % 1000) * 1000 };
+  nanosleep(&delay, 0);
+}
+
+void *run(void *arg) {
+  unsigned seed = (unsigned)(size_t)arg;
+
+  volatile char tmp[2];
+  __asan_poison_memory_region(&tmp, sizeof(tmp)); 
+
+  for (size_t i = 0; i < niter; ++i) {
+    random_delay(&seed);
+    // Expect error collisions here
+    // CHECK: ERROR: AddressSanitizer: use-after-poison
+    volatile int idx = 0;
+    tmp[idx] = 0;
+  }
+
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  if (argc != 3) {
+    fprintf(stderr, "Syntax: %s nthreads niter\n", argv[0]);
+    exit(1);
+  }
+
+  nthreads = (size_t)strtoul(argv[1], 0, 0);
+  niter = (size_t)strtoul(argv[2], 0, 0);
+
+  pthread_t *tids = new pthread_t[nthreads];
+
+  for (size_t i = 0; i < nthreads; ++i) {
+    if (0 != pthread_create(&tids[i], 0, run, (void *)i)) {
+      fprintf(stderr, "Failed to create thread\n");
+      exit(1);
+    }
+  }
+
+  for (size_t i = 0; i < nthreads; ++i) {
+    if (0 != pthread_join(tids[i], 0)) {
+      fprintf(stderr, "Failed to join thread\n");
+      exit(1);
+    }
+  }
+
+  // CHECK-COLLISION: AddressSanitizer: nested bug in the same thread, aborting
+  // CHECK-NO-COLLISION: All threads terminated
+  printf("All threads terminated\n");
+
+  delete [] tids;
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/halt_on_error_suppress_equal_pcs.cc b/compiler-rt/test/asan/TestCases/Posix/halt_on_error_suppress_equal_pcs.cc
new file mode 100644
index 0000000..98b0348
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/halt_on_error_suppress_equal_pcs.cc
@@ -0,0 +1,55 @@
+// Test reports dedupication for recovery mode.
+//
+// RUN: %clang_asan -fsanitize-recover=address %s -o %t
+//
+// Check for reports dedupication.
+// RUN: %env_asan_opts=halt_on_error=false %run %t 2>&1 | FileCheck %s
+//
+// Check that we die after reaching different reports number threshold.
+// RUN: %env_asan_opts=halt_on_error=false not %run %t 1 > %t1.log 2>&1
+// RUN: [ $(grep -c 'ERROR: AddressSanitizer: stack-buffer-overflow' %t1.log) -eq 25 ]
+//
+// Check suppress_equal_pcs=true behavior is equal to default one.
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=true %run %t 2>&1 | FileCheck %s
+//
+// Check suppress_equal_pcs=false behavior isn't equal to default one.
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false %run %t > %t2.log 2>&1
+// RUN: [ $(grep -c 'ERROR: AddressSanitizer: stack-buffer-overflow' %t2.log) -eq 30 ]
+
+#define ACCESS_ARRAY_FIVE_ELEMENTS(array, i)     \
+  array[i] = i;                                  \
+  array[i + 1] = i + 1;                          \
+  array[i + 2] = i + 2;                          \
+  array[i + 3] = i + 3;                          \
+  array[i + 4] = i + 4;                          \
+
+volatile int ten = 10;
+unsigned kNumIterations = 10;
+
+int main(int argc, char **argv) {
+  char a[10];
+  char b[10];
+
+  if (argc == 1) {
+    for (int i = 0; i < kNumIterations; ++i) {
+      // CHECK: READ of size 1
+      volatile int res = a[ten + i];
+      // CHECK: WRITE of size 1
+      a[i + ten] = res + 3;
+      // CHECK: READ of size 1
+      res = a[ten + i];
+      // CHECK-NOT: ERROR
+    }
+  } else {
+    for (int i = 0; i < kNumIterations; ++i) {
+      ACCESS_ARRAY_FIVE_ELEMENTS(a, ten);
+      ACCESS_ARRAY_FIVE_ELEMENTS(a, ten + 5);
+      ACCESS_ARRAY_FIVE_ELEMENTS(a, ten + 10);
+      ACCESS_ARRAY_FIVE_ELEMENTS(b, ten);
+      ACCESS_ARRAY_FIVE_ELEMENTS(b, ten + 5);
+      ACCESS_ARRAY_FIVE_ELEMENTS(b, ten + 10);
+    }
+  }
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Posix/init-order-pthread-create.cc b/compiler-rt/test/asan/TestCases/Posix/init-order-pthread-create.cc
new file mode 100644
index 0000000..19c000f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/init-order-pthread-create.cc
@@ -0,0 +1,54 @@
+// Check that init-order checking is properly disabled if pthread_create is
+// called.
+
+// RUN: %clangxx_asan -c -DCONFIG1 %s -o %t1.o
+// RUN: %clangxx_asan -c           %s -o %t2.o
+// RUN: %clangxx_asan -pthread %t1.o %t2.o -o %t
+// RUN: %env_asan_opts=strict_init_order=true %run %t
+
+#ifdef CONFIG1
+
+#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+
+void *bar(void *input, bool sleep_before_init) {
+  if (sleep_before_init)
+    usleep(500000);
+  return input;
+}
+
+void *glob = bar((void*)0x1234, false);
+extern void *glob2;
+
+void *poll(void *arg) {
+  void **glob = (void**)arg;
+  while (true) {
+    usleep(100000);
+    printf("glob is now: %p\n", *glob);
+  }
+}
+
+struct GlobalPollerStarter {
+  GlobalPollerStarter() {
+    pthread_t p;
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    pthread_create(&p, 0, poll, &glob);
+    pthread_attr_destroy(&attr);
+    printf("glob poller is started");
+  }
+} global_poller;
+
+int main() {
+  printf("%p %p\n", glob, glob2);
+  return 0;
+}
+
+#else // CONFIG1
+
+void *bar(void *input, bool sleep_before_init);
+void *glob2 = bar((void*)0x2345, true);
+
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Posix/interception-in-shared-lib-test.cc b/compiler-rt/test/asan/TestCases/Posix/interception-in-shared-lib-test.cc
new file mode 100644
index 0000000..a7d2bfb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/interception-in-shared-lib-test.cc
@@ -0,0 +1,27 @@
+// Check that memset() call from a shared library gets intercepted.
+
+// RUN: %clangxx_asan -O0 %s -DSHARED_LIB \
+// RUN:     -shared -o %dynamiclib -fPIC %ld_flags_rpath_so
+// RUN: %clangxx_asan -O0 %s -o %t %ld_flags_rpath_exe && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+#if defined(SHARED_LIB)
+extern "C"
+void my_memset(void *p, size_t sz) {
+  memset(p, 0, sz);
+}
+#else
+extern "C" void my_memset(void *p, size_t sz);
+
+int main(int argc, char *argv[]) {
+  char buf[10];
+  my_memset(buf, 11);
+  // CHECK: {{.*ERROR: AddressSanitizer: stack-buffer-overflow}}
+  // CHECK: {{WRITE of size 11 at 0x.* thread T0}}
+  // CHECK: {{0x.* in my_memset .*interception-in-shared-lib-test.cc:}}[[@LINE-10]]
+  return 0;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Posix/ioctl.cc b/compiler-rt/test/asan/TestCases/Posix/ioctl.cc
new file mode 100644
index 0000000..6cf9fa8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/ioctl.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_asan -O0 -g %s -o %t && %env_asan_opts=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 -g %s -o %t && %env_asan_opts=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s
+
+// RUN: %clangxx_asan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_asan -O3 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  int fd = socket(AF_INET, SOCK_DGRAM, 0);
+
+  int nonblock;
+  int res = ioctl(fd, FIONBIO, &nonblock + 1);
+  // CHECK: AddressSanitizer: stack-buffer-overflow
+  // CHECK: READ of size 4 at
+  // CHECK: {{#.* in main .*ioctl.cc:}}[[@LINE-3]]
+  assert(res == 0);
+  close(fd);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/large_allocator_unpoisons_on_free.cc b/compiler-rt/test/asan/TestCases/Posix/large_allocator_unpoisons_on_free.cc
new file mode 100644
index 0000000..b39fa74
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/large_allocator_unpoisons_on_free.cc
@@ -0,0 +1,39 @@
+// Test that LargeAllocator unpoisons memory before releasing it to the OS.
+// RUN: %clangxx_asan %s -o %t
+// The memory is released only when the deallocated chunk leaves the quarantine,
+// otherwise the mmap(p, ...) call overwrites the malloc header.
+// RUN: %env_asan_opts=quarantine_size_mb=0 %run %t
+
+#include <assert.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#ifdef __ANDROID__
+#include <malloc.h>
+void *my_memalign(size_t boundary, size_t size) {
+  return memalign(boundary, size);
+}
+#else
+void *my_memalign(size_t boundary, size_t size) {
+  void *p;
+  posix_memalign(&p, boundary, size);
+  return p;
+}
+#endif
+
+int main() {
+  const long kPageSize = sysconf(_SC_PAGESIZE);
+  void *p = my_memalign(kPageSize, 1024 * 1024);
+  free(p);
+
+  char *q = (char *)mmap(p, kPageSize, PROT_READ | PROT_WRITE,
+                         MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
+  assert(q == p);
+
+  memset(q, 42, kPageSize);
+
+  munmap(q, kPageSize);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/lit.local.cfg b/compiler-rt/test/asan/TestCases/Posix/lit.local.cfg
new file mode 100644
index 0000000..60a9460
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os in ['Windows']:
+  config.unsupported = True
diff --git a/compiler-rt/test/asan/TestCases/Posix/log_path_fork_test.cc.disabled b/compiler-rt/test/asan/TestCases/Posix/log_path_fork_test.cc.disabled
new file mode 100644
index 0000000..029bdd1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/log_path_fork_test.cc.disabled
@@ -0,0 +1,22 @@
+// RUN: %clangxx_asan  %s -o %t
+// RUN: rm -f %t.log.*
+// Set verbosity to 1 so that the log files are opened prior to fork().
+// RUN: %env_asan_opts=log_path='"%t.log"':verbosity=1 not %run %t 2> %t.out
+// RUN: for f in %t.log.* ; do FileCheck %s < $f; done
+// RUN: [ `ls %t.log.* | wc -l` == 2 ]
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  void *x = malloc(10);
+  free(x);
+  if (fork() == -1) return 1;
+  // There are two processes at this point, thus there should be two distinct
+  // error logs.
+  free(x);
+  return 0;
+}
+
+// CHECK: ERROR: AddressSanitizer
diff --git a/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_test.cc b/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_test.cc
new file mode 100644
index 0000000..dd50bf7
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_test.cc
@@ -0,0 +1,24 @@
+// REQUIRES: asan-64-bits
+// RUN: %clangxx_asan -O3 %s -o %t
+// RUN:                                    not %run %t 2>&1  | FileCheck %s
+// RUN: %env_asan_opts=poison_array_cookie=1 not %run %t 2>&1  | FileCheck %s
+// RUN: %env_asan_opts=poison_array_cookie=0 not %run %t 2>&1  | FileCheck %s --check-prefix=NO_COOKIE
+#include <stdio.h>
+#include <stdlib.h>
+struct C {
+  int x;
+  ~C() {
+    fprintf(stderr, "ZZZZZZZZ\n");
+    exit(1);
+  }
+};
+
+int main(int argc, char **argv) {
+  C *buffer = new C[argc];
+  buffer[-2].x = 10;
+// CHECK: AddressSanitizer: heap-buffer-overflow
+// CHECK: in main {{.*}}new_array_cookie_test.cc:[[@LINE-2]]
+// CHECK: is located 0 bytes inside of 12-byte region
+// NO_COOKIE: ZZZZZZZZ
+  delete [] buffer;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_uaf_test.cc b/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_uaf_test.cc
new file mode 100644
index 0000000..f36da2b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_uaf_test.cc
@@ -0,0 +1,38 @@
+// REQUIRES: asan-64-bits
+// RUN: %clangxx_asan -O3 %s -o %t
+// RUN: %env_asan_opts=poison_array_cookie=1 not %run %t 2>&1  | FileCheck %s --check-prefix=COOKIE
+// RUN: %env_asan_opts=poison_array_cookie=0 not %run %t 2>&1  | FileCheck %s --check-prefix=NO_COOKIE
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+int dtor_counter;
+struct C {
+  int x;
+  ~C() {
+    dtor_counter++;
+    fprintf(stderr, "DTOR %d\n", dtor_counter);
+  }
+};
+
+__attribute__((noinline)) void Delete(C *c) { delete[] c; }
+__attribute__((no_sanitize_address)) void Write42ToCookie(C *c) {
+  long *p = reinterpret_cast<long*>(c);
+  p[-1] = 42;
+}
+
+int main(int argc, char **argv) {
+  C *buffer = new C[argc];
+  delete [] buffer;
+  Write42ToCookie(buffer);
+  delete [] buffer;
+// COOKIE: DTOR 1
+// COOKIE-NOT: DTOR 2
+// COOKIE: AddressSanitizer: loaded array cookie from free-d memory
+// COOKIE: AddressSanitizer: attempting double-free
+// NO_COOKIE: DTOR 1
+// NO_COOKIE: DTOR 43
+// NO_COOKIE-NOT: DTOR 44
+// NO_COOKIE-NOT: AddressSanitizer: loaded array cookie from free-d memory
+// NO_COOKIE: AddressSanitizer: attempting double-free
+
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_with_new_from_class.cc b/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_with_new_from_class.cc
new file mode 100644
index 0000000..0683e39
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/new_array_cookie_with_new_from_class.cc
@@ -0,0 +1,37 @@
+// Test that we do not poison the array cookie if the operator new is defined
+// inside the class.
+// RUN: %clangxx_asan  %s -o %t && %run %t
+//
+// XFAIL: arm
+#include <new>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <assert.h>
+struct Foo {
+  void *operator new(size_t s) { return Allocate(s); }
+  void *operator new[] (size_t s) { return Allocate(s); }
+  ~Foo();
+  static void *allocated;
+  static void *Allocate(size_t s) {
+    assert(!allocated);
+    return allocated = ::new char[s];
+  }
+};
+
+Foo::~Foo() {}
+void *Foo::allocated;
+
+Foo *getFoo(size_t n) {
+  return new Foo[n];
+}
+
+int main() {
+  Foo *foo = getFoo(10);
+  fprintf(stderr, "foo  : %p\n", foo);
+  fprintf(stderr, "alloc: %p\n", Foo::allocated);
+  assert(reinterpret_cast<uintptr_t>(foo) ==
+         reinterpret_cast<uintptr_t>(Foo::allocated) + sizeof(void*));
+  *reinterpret_cast<uintptr_t*>(Foo::allocated) = 42;
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/readv.cc b/compiler-rt/test/asan/TestCases/Posix/readv.cc
new file mode 100644
index 0000000..27436a1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/readv.cc
@@ -0,0 +1,32 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t
+// RUN: %clangxx_asan -O0 %s -DPOSITIVE -o %t && not %run %t 2>&1 | FileCheck %s
+
+// Test the readv() interceptor.
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/uio.h>
+#include <time.h>
+
+int main() {
+  char buf[2011];
+  struct iovec iov[2];
+#ifdef POSITIVE
+  char * volatile buf_ = buf;
+  iov[0].iov_base = buf_ - 1;
+#else
+  iov[0].iov_base = buf + 1;
+#endif
+  iov[0].iov_len = 5;
+  iov[1].iov_base = buf + 10;
+  iov[1].iov_len = 2000;
+  int fd = open("/etc/hosts", O_RDONLY);
+  assert(fd > 0);
+  readv(fd, iov, 2);
+  // CHECK: WRITE of size 5 at
+  close(fd);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/shared-lib-test.cc b/compiler-rt/test/asan/TestCases/Posix/shared-lib-test.cc
new file mode 100644
index 0000000..305942a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/shared-lib-test.cc
@@ -0,0 +1,57 @@
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O0 %s %libdl -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O1 %s %libdl -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O2 %s %libdl -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O3 %s %libdl -o %t && not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+
+#if !defined(SHARED_LIB)
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <string>
+
+using std::string;
+
+typedef void (fun_t)(int x);
+
+int main(int argc, char *argv[]) {
+  string path = string(argv[0]) + "-so.so";
+  printf("opening %s ... \n", path.c_str());
+  void *lib = dlopen(path.c_str(), RTLD_NOW);
+  if (!lib) {
+    printf("error in dlopen(): %s\n", dlerror());
+    return 1;
+  }
+  fun_t *inc = (fun_t*)dlsym(lib, "inc");
+  if (!inc) return 1;
+  printf("ok\n");
+  inc(1);
+  inc(-1);  // BOOM
+  // CHECK: {{.*ERROR: AddressSanitizer: global-buffer-overflow}}
+  // CHECK: {{READ of size 4 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.*}}
+  // CHECK: {{    #1 0x.* in main .*shared-lib-test.cc:}}[[@LINE-4]]
+  return 0;
+}
+#else  // SHARED_LIB
+#include <stdio.h>
+#include <string.h>
+
+int pad[10];
+int GLOB[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+extern "C"
+void inc(int index) {
+  GLOB[index]++;
+}
+
+extern "C"
+void inc2(int *a, int index) {
+  a[index]++;
+}
+#endif  // SHARED_LIB
diff --git a/compiler-rt/test/asan/TestCases/Posix/stack-overflow.cc b/compiler-rt/test/asan/TestCases/Posix/stack-overflow.cc
new file mode 100644
index 0000000..8ef1618
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/stack-overflow.cc
@@ -0,0 +1,114 @@
+// Test ASan detection of stack-overflow condition.
+
+// RUN: %clangxx_asan -O0 %s -DSMALL_FRAME -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+
+// RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DTHREAD -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTHREAD -pthread -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: not %run %t 2>&1 | FileCheck %s
+// REQUIRES: stable-runtime
+
+#include <assert.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sanitizer/asan_interface.h>
+
+const int BS = 1024;
+volatile char x;
+volatile int y = 1;
+volatile int z0, z1, z2, z3, z4, z5, z6, z7, z8, z9, z10, z11, z12, z13;
+
+void recursive_func(char *p) {
+#if defined(SMALL_FRAME)
+  char *buf = 0;
+#elif defined(SAVE_ALL_THE_REGISTERS)
+  char *buf = 0;
+  int t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13;
+  t0 = z0;
+  t1 = z1;
+  t2 = z2;
+  t3 = z3;
+  t4 = z4;
+  t5 = z5;
+  t6 = z6;
+  t7 = z7;
+  t8 = z8;
+  t9 = z9;
+  t10 = z10;
+  t11 = z11;
+  t12 = z12;
+  t13 = z13;
+
+  z0 = t0;
+  z1 = t1;
+  z2 = t2;
+  z3 = t3;
+  z4 = t4;
+  z5 = t5;
+  z6 = t6;
+  z7 = t7;
+  z8 = t8;
+  z9 = t9;
+  z10 = t10;
+  z11 = t11;
+  z12 = t12;
+  z13 = t13;
+#else
+  char buf[BS];
+  // Check that the stack grows in the righ direction, unless we use fake stack.
+  if (p && !__asan_get_current_fake_stack())
+    assert(p - buf >= BS);
+  buf[rand() % BS] = 1;
+  buf[rand() % BS] = 2;
+  x = buf[rand() % BS];
+#endif
+  if (y)
+    recursive_func(buf);
+  x = 1; // prevent tail call optimization
+  // CHECK: {{stack-overflow on address 0x.* \(pc 0x.* bp 0x.* sp 0x.* T.*\)}}
+  // If stack overflow happens during function prologue, stack trace may be
+  // corrupted. Unwind tables are not always 100% exact there.
+  // For this reason, we don't do any further checks.
+}
+
+void *ThreadFn(void* unused) {
+  recursive_func(0);
+  return 0;
+}
+
+void LimitStackAndReexec(int argc, char **argv) {
+  struct rlimit rlim;
+  int res = getrlimit(RLIMIT_STACK, &rlim);
+  assert(res == 0);
+  if (rlim.rlim_cur == RLIM_INFINITY) {
+    rlim.rlim_cur = 256 * 1024;
+    res = setrlimit(RLIMIT_STACK, &rlim);
+    assert(res == 0);
+
+    execv(argv[0], argv);
+    assert(0 && "unreachable");
+  }
+}
+
+int main(int argc, char **argv) {
+  LimitStackAndReexec(argc, argv);
+#ifdef THREAD
+  pthread_t t;
+  pthread_create(&t, 0, ThreadFn, 0);
+  pthread_join(t, 0);
+#else
+  recursive_func(0);
+#endif
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/stack-use-after-return.cc b/compiler-rt/test/asan/TestCases/Posix/stack-use-after-return.cc
new file mode 100644
index 0000000..cf114be
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/stack-use-after-return.cc
@@ -0,0 +1,79 @@
+// RUN: %clangxx_asan  -O0 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan  -O1 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan  -O2 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan  -O3 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=detect_stack_use_after_return=0 %run %t
+// Regression test for a CHECK failure with small stack size and large frame.
+// RUN: %clangxx_asan  -O3 %s -pthread -o %t -DkSize=10000 -DUseThread -DkStackSize=65536 && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck --check-prefix=THREAD %s
+//
+// Test that we can find UAR in a thread other than main:
+// RUN: %clangxx_asan  -DUseThread -O2 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck --check-prefix=THREAD %s
+//
+// Test the max_uar_stack_size_log/min_uar_stack_size_log flag.
+//
+// RUN: %env_asan_opts=detect_stack_use_after_return=1:max_uar_stack_size_log=20:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s
+// RUN: %env_asan_opts=detect_stack_use_after_return=1:min_uar_stack_size_log=24:max_uar_stack_size_log=24:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-24 %s
+
+#include <stdio.h>
+#include <pthread.h>
+
+#ifndef kSize
+# define kSize 1
+#endif
+
+#ifndef UseThread
+# define UseThread 0
+#endif
+
+#ifndef kStackSize
+# define kStackSize 0
+#endif
+
+__attribute__((noinline))
+char *Ident(char *x) {
+  fprintf(stderr, "1: %p\n", x);
+  return x;
+}
+
+__attribute__((noinline))
+char *Func1() {
+  char local[kSize];
+  return Ident(local);
+}
+
+__attribute__((noinline))
+void Func2(char *x) {
+  fprintf(stderr, "2: %p\n", x);
+  *x = 1;
+  // CHECK: WRITE of size 1 {{.*}} thread T0
+  // CHECK:     #0{{.*}}Func2{{.*}}stack-use-after-return.cc:[[@LINE-2]]
+  // CHECK: is located in stack of thread T0 at offset
+  // CHECK: 'local' <== Memory access at offset {{16|32}} is inside this variable
+  // THREAD: WRITE of size 1 {{.*}} thread T{{[1-9]}}
+  // THREAD:     #0{{.*}}Func2{{.*}}stack-use-after-return.cc:[[@LINE-6]]
+  // THREAD: is located in stack of thread T{{[1-9]}} at offset
+  // THREAD: 'local' <== Memory access at offset {{16|32}} is inside this variable
+  // CHECK-20: T0: FakeStack created:{{.*}} stack_size_log: 20
+  // CHECK-24: T0: FakeStack created:{{.*}} stack_size_log: 24
+}
+
+void *Thread(void *unused)  {
+  Func2(Func1());
+  return NULL;
+}
+
+int main(int argc, char **argv) {
+#if UseThread
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  if (kStackSize > 0)
+    pthread_attr_setstacksize(&attr, kStackSize);
+  pthread_t t;
+  pthread_create(&t, &attr, Thread, 0);
+  pthread_attr_destroy(&attr);
+  pthread_join(t, 0);
+#else
+  Func2(Func1());
+#endif
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/start-deactivated.cc b/compiler-rt/test/asan/TestCases/Posix/start-deactivated.cc
new file mode 100644
index 0000000..b301415
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/start-deactivated.cc
@@ -0,0 +1,100 @@
+// Test for ASAN_OPTIONS=start_deactivated=1 mode.
+// Main executable is uninstrumented, but linked to ASan runtime. The shared
+// library is instrumented. Memory errors before dlopen are not detected.
+
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx -O0 %s -c -o %t.o
+// RUN: %clangxx_asan -O0 %t.o %libdl -o %t
+// RUN: %env_asan_opts=start_deactivated=1,allocator_may_return_null=0 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=allocator_may_return_null=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=help=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-HELP
+// RUN: %env_asan_opts=start_deactivated=1,verbosity=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED-V0
+
+// Check that verbosity=1 in activation flags affects reporting of unrecognized activation flags.
+// RUN: %env_asan_opts=start_deactivated=1 \
+// RUN:   ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0,verbosity=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED
+
+// XFAIL: arm-linux-gnueabi
+
+#if !defined(SHARED_LIB)
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <string>
+
+#include "sanitizer/asan_interface.h"
+
+void test_malloc_shadow() {
+  char *p = (char *)malloc(100);
+  char *q = (char *)__asan_region_is_poisoned(p + 95, 8);
+  fprintf(stderr, "=%zd=\n", q ? q - (p + 95) : -1);
+  free(p);
+}
+
+typedef void (*Fn)();
+
+int main(int argc, char *argv[]) {
+  test_malloc_shadow();
+  // CHECK: =-1=
+
+  std::string path = std::string(argv[0]) + "-so.so";
+  void *dso = dlopen(path.c_str(), RTLD_NOW);
+  if (!dso) {
+    fprintf(stderr, "dlopen failed: %s\n", dlerror());
+    return 1;
+  }
+
+  test_malloc_shadow();
+  // CHECK: =5=
+
+  // After this line ASan is activated and starts detecting errors.
+  void *fn = dlsym(dso, "do_another_bad_thing");
+  if (!fn) {
+    fprintf(stderr, "dlsym failed: %s\n", dlerror());
+    return 1;
+  }
+
+  // Test that ASAN_ACTIVATION_OPTIONS=allocator_may_return_null=1 has effect.
+  void *p = malloc((unsigned long)-2);
+  assert(!p);
+  // CHECK: WARNING: AddressSanitizer failed to allocate 0xfff{{.*}} bytes
+
+  ((Fn)fn)();
+  // CHECK: AddressSanitizer: heap-buffer-overflow
+  // CHECK: READ of size 1
+  // CHECK: {{#0 .* in do_another_bad_thing}}
+  // CHECK: is located 5 bytes to the right of 100-byte region
+  // CHECK: in do_another_bad_thing
+
+  return 0;
+}
+#else  // SHARED_LIB
+#include <stdio.h>
+#include <stdlib.h>
+
+extern "C" void do_another_bad_thing() {
+  char *volatile p = (char *)malloc(100);
+  printf("%hhx\n", p[105]);
+}
+#endif  // SHARED_LIB
+
+// help=1 in activation flags lists only flags are are supported at activation
+// CHECK-HELP: Available flags for {{.*}}Sanitizer:
+// CHECK-HELP-NOT: handle_segv
+// CHECK-HELP: max_redzone
+// CHECK-HELP-NOT: handle_segv
+
+// unsupported activation flags produce a warning ...
+// CHECK-UNSUPPORTED: WARNING: found 1 unrecognized
+// CHECK-UNSUPPORTED:   handle_segv
+
+// ... but not at verbosity=0
+// CHECK-UNSUPPORTED-V0-NOT: WARNING: found {{.*}} unrecognized
diff --git a/compiler-rt/test/asan/TestCases/Posix/strerror_r_test.cc b/compiler-rt/test/asan/TestCases/Posix/strerror_r_test.cc
new file mode 100644
index 0000000..e6df441
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/strerror_r_test.cc
@@ -0,0 +1,14 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t
+
+// Regression test for PR17138.
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+int main() {
+  char buf[1024];
+  char *res = (char *)strerror_r(300, buf, sizeof(buf));
+  printf("%p\n", res);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/tsd_dtor_leak.cc b/compiler-rt/test/asan/TestCases/Posix/tsd_dtor_leak.cc
new file mode 100644
index 0000000..9e71ff6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/tsd_dtor_leak.cc
@@ -0,0 +1,41 @@
+// Regression test for a leak in tsd:
+// https://code.google.com/p/address-sanitizer/issues/detail?id=233
+// RUN: %clangxx_asan -O1 %s -pthread -o %t
+// RUN: %env_asan_opts=quarantine_size_mb=0 %run %t
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <sanitizer/allocator_interface.h>
+
+static pthread_key_t tsd_key;
+
+void *Thread(void *) {
+  pthread_setspecific(tsd_key, malloc(10));
+  return 0;
+}
+
+static volatile void *v;
+
+void Dtor(void *tsd) {
+  v = malloc(10000);
+  free(tsd);
+  free((void*)v);  // The bug was that this was leaking.
+}
+
+int main() {
+  assert(0 == pthread_key_create(&tsd_key, Dtor));
+  pthread_t t;
+  for (int i = 0; i < 3; i++) {
+    pthread_create(&t, 0, Thread, 0);
+    pthread_join(t, 0);
+  }
+  size_t old_heap_size = __sanitizer_get_heap_size();
+  for (int i = 0; i < 10; i++) {
+    pthread_create(&t, 0, Thread, 0);
+    pthread_join(t, 0);
+    size_t new_heap_size = __sanitizer_get_heap_size();
+    fprintf(stderr, "heap size: new: %zd old: %zd\n", new_heap_size, old_heap_size);
+    assert(old_heap_size == new_heap_size);
+  }
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/wait.cc b/compiler-rt/test/asan/TestCases/Posix/wait.cc
new file mode 100644
index 0000000..ed6f326
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/wait.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_asan -DWAIT -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -DWAIT -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// RUN: %clangxx_asan -DWAITPID -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -DWAITPID -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+
+#include <assert.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  pid_t pid = fork();
+  if (pid) { // parent
+    int x[3];
+    int *status = x + argc * 3;
+    int res;
+#if defined(WAIT)
+    res = wait(status);
+#elif defined(WAITPID)
+    res = waitpid(pid, status, WNOHANG);
+#endif
+    // CHECK: stack-buffer-overflow
+    // CHECK: {{WRITE of size .* at 0x.* thread T0}}
+    // CHECK: {{in .*wait}}
+    // CHECK: {{in main .*wait.cc:}}
+    // CHECK: is located in stack of thread T0 at offset
+    // CHECK: {{in main}}
+    return res == -1 ? 1 : 0;
+  }
+  // child
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/wait3.cc b/compiler-rt/test/asan/TestCases/Posix/wait3.cc
new file mode 100644
index 0000000..2da816f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/wait3.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_asan -DWAIT3 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -DWAIT3 -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// RUN: %clangxx_asan -DWAIT3_RUSAGE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -DWAIT3_RUSAGE -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// UNSUPPORTED: android
+
+#include <assert.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  pid_t pid = fork();
+  if (pid) { // parent
+    int x[3];
+    int *status = x + argc * 3;
+    int res;
+#if defined(WAIT3)
+    res = wait3(status, WNOHANG, NULL);
+#elif defined(WAIT3_RUSAGE)
+    struct rusage *ru = (struct rusage*)(x + argc * 3);
+    int good_status;
+    res = wait3(&good_status, WNOHANG, ru);
+#endif
+    // CHECK: stack-buffer-overflow
+    // CHECK: {{WRITE of size .* at 0x.* thread T0}}
+    // CHECK: {{in .*wait}}
+    // CHECK: {{in main .*wait3.cc:}}
+    // CHECK: is located in stack of thread T0 at offset
+    // CHECK: {{in main}}
+    return res == -1 ? 1 : 0;
+  }
+  // child
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/wait4.cc b/compiler-rt/test/asan/TestCases/Posix/wait4.cc
new file mode 100644
index 0000000..b95246e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/wait4.cc
@@ -0,0 +1,43 @@
+// RUN: %clangxx_asan -DWAIT4 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -DWAIT4 -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// RUN: %clangxx_asan -DWAIT4_RUSAGE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -DWAIT4_RUSAGE -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// XFAIL: android
+
+#include <assert.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  // This test passes on some versions of Android NDK and fails on other.
+  // https://code.google.com/p/memory-sanitizer/issues/detail?id=64
+  // Make it fail unconditionally on Android.
+#ifdef __ANDROID__
+  return 0;
+#endif
+
+  pid_t pid = fork();
+  if (pid) { // parent
+    int x[3];
+    int *status = x + argc * 3;
+    int res;
+#if defined(WAIT4)
+    res = wait4(pid, status, WNOHANG, NULL);
+#elif defined(WAIT4_RUSAGE)
+    struct rusage *ru = (struct rusage*)(x + argc * 3);
+    int good_status;
+    res = wait4(pid, &good_status, WNOHANG, ru);
+#endif
+    // CHECK: stack-buffer-overflow
+    // CHECK: {{WRITE of size .* at 0x.* thread T0}}
+    // CHECK: {{in .*wait}}
+    // CHECK: {{in main .*wait4.cc:}}
+    // CHECK: is located in stack of thread T0 at offset
+    // CHECK: {{in main}}
+    return res == -1 ? 1 : 0;
+  }
+  // child
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Posix/waitid.cc b/compiler-rt/test/asan/TestCases/Posix/waitid.cc
new file mode 100644
index 0000000..8b516dc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Posix/waitid.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <signal.h>
+
+int main(int argc, char **argv) {
+  pid_t pid = fork();
+  if (pid) { // parent
+    int x[3];
+    int *status = x + argc * 3;
+    int res;
+
+    siginfo_t *si = (siginfo_t*)(x + argc * 3);
+    res = waitid(P_ALL, 0, si, WEXITED | WNOHANG);
+    // CHECK: stack-buffer-overflow
+    // CHECK: {{WRITE of size .* at 0x.* thread T0}}
+    // CHECK: {{in .*waitid}}
+    // CHECK: {{in main .*waitid.cc:}}
+    // CHECK: is located in stack of thread T0 at offset
+    // CHECK: {{in main}}
+    return res != -1;
+  }
+  // child
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/aligned_mallocs.cc b/compiler-rt/test/asan/TestCases/Windows/aligned_mallocs.cc
new file mode 100644
index 0000000..df740b6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/aligned_mallocs.cc
@@ -0,0 +1,29 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+
+#define CHECK_ALIGNED(ptr,alignment) \
+  do { \
+    if (((uintptr_t)(ptr) % (alignment)) != 0) \
+      return __LINE__; \
+    } \
+  while(0)
+
+int main(void) {
+  int *p = (int*)_aligned_malloc(1024 * sizeof(int), 32);
+  CHECK_ALIGNED(p, 32);
+  p[512] = 0;
+  _aligned_free(p);
+
+  p = (int*)_aligned_malloc(128, 128);
+  CHECK_ALIGNED(p, 128);
+  p = (int*)_aligned_realloc(p, 2048 * sizeof(int), 128);
+  CHECK_ALIGNED(p, 128);
+  p[1024] = 0;
+  if (_aligned_msize(p, 128, 0) != 2048 * sizeof(int))
+    return __LINE__;
+  _aligned_free(p);
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/allocators_sanity.cc b/compiler-rt/test/asan/TestCases/Windows/allocators_sanity.cc
new file mode 100644
index 0000000..66a862d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/allocators_sanity.cc
@@ -0,0 +1,37 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t | FileCheck %s
+
+#include <malloc.h>
+#include <stdio.h>
+
+int main() {
+  int *p = (int*)malloc(1024 * sizeof(int));
+  p[512] = 0;
+  free(p);
+
+  p = (int*)malloc(128);
+  p = (int*)realloc(p, 2048 * sizeof(int));
+  p[1024] = 0;
+  free(p);
+
+  p = (int*)calloc(16, sizeof(int));
+  if (p[8] != 0)
+    return 1;
+  p[15]++;
+  if (16 * sizeof(int) != _msize(p))
+    return 2;
+  free(p);
+
+  p = new int;
+  *p = 42;
+  delete p;
+
+  p = new int[42];
+  p[15]++;
+  delete [] p;
+
+  printf("All ok\n");
+// CHECK: All ok
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/beginthreadex.cc b/compiler-rt/test/asan/TestCases/Windows/beginthreadex.cc
new file mode 100644
index 0000000..f2b2b45
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/beginthreadex.cc
@@ -0,0 +1,21 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+#include <process.h>
+
+unsigned WINAPI thread_proc(void *) {
+  volatile char stack_buffer[42];
+  for (int i = 0; i < sizeof(stack_buffer); ++i)
+    stack_buffer[i] = 42;
+  return 0;
+}
+
+int main() {
+  HANDLE thr = (HANDLE)_beginthreadex(NULL, 0, thread_proc, NULL, 0, NULL);
+  if (thr == 0)
+    return 1;
+  if (WAIT_OBJECT_0 != WaitForSingleObject(thr, INFINITE))
+    return 2;
+  CloseHandle(thr);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/bind_io_completion_callback.cc b/compiler-rt/test/asan/TestCases/Windows/bind_io_completion_callback.cc
new file mode 100644
index 0000000..c062a79
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/bind_io_completion_callback.cc
@@ -0,0 +1,70 @@
+// Make sure we can throw exceptions from work items executed via
+// BindIoCompletionCallback.
+//
+// Clang doesn't support exceptions on Windows yet, so for the time being we
+// build this program in two parts: the code with exceptions is built with CL,
+// the rest is built with Clang.  This represents the typical scenario when we
+// build a large project using "clang-cl -fallback -fsanitize=address".
+//
+// RUN: cl -c %s -Fo%t.obj
+// RUN: %clangxx_asan -o %t.exe %s %t.obj
+// RUN: %run %t.exe 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <stdio.h>
+
+void ThrowAndCatch();
+
+#if !defined(__clang__)
+__declspec(noinline)
+void Throw() {
+  fprintf(stderr, "Throw\n");
+// CHECK: Throw
+  throw 1;
+}
+
+void ThrowAndCatch() {
+  int local;
+  try {
+    Throw();
+  } catch(...) {
+    fprintf(stderr, "Catch\n");
+// CHECK: Catch
+  }
+}
+#else
+
+char buffer[65536];
+HANDLE done;
+OVERLAPPED ov;
+
+void CALLBACK completion_callback(DWORD error, DWORD bytesRead,
+                                  LPOVERLAPPED pov) {
+  ThrowAndCatch();
+  SetEvent(done);
+}
+
+int main(int argc, char **argv) {
+  done = CreateEvent(0, false, false, "job is done");
+  if (!done)
+    return 1;
+  HANDLE file = CreateFile(
+      argv[0], GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+      OPEN_EXISTING,
+      FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED,
+      NULL);
+  if (!file)
+    return 2;
+  if (!BindIoCompletionCallback(file, completion_callback, 0))
+    return 3;
+
+  if (!ReadFile(file, buffer, sizeof(buffer), NULL, &ov) &&
+      GetLastError() != ERROR_IO_PENDING)
+    return 4;
+
+  if (WAIT_OBJECT_0 != WaitForSingleObject(done, INFINITE))
+    return 5;
+  fprintf(stderr, "Done!\n");
+// CHECK: Done!
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Windows/bitfield.cc b/compiler-rt/test/asan/TestCases/Windows/bitfield.cc
new file mode 100644
index 0000000..253a759
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/bitfield.cc
@@ -0,0 +1,21 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+
+typedef struct _S {
+  unsigned int bf1:1;
+  unsigned int bf2:2;
+  unsigned int bf3:3;
+  unsigned int bf4:4;
+} S;
+
+int main(void) {
+  S *s = (S*)malloc(sizeof(S));
+  s->bf1 = 1;
+  s->bf2 = 2;
+  s->bf3 = 3;
+  s->bf4 = 4;
+  free(s);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/bitfield_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/bitfield_uaf.cc
new file mode 100644
index 0000000..a1a2657
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/bitfield_uaf.cc
@@ -0,0 +1,34 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+typedef struct _S {
+  unsigned int bf1:1;
+  unsigned int bf2:2;
+  unsigned int bf3:3;
+  unsigned int bf4:4;
+} S;
+
+void make_access(S *s) {
+  s->bf2 = 2;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: READ of size {{[124]}} at [[ADDR]]
+// CHECK:   {{#0 .* make_access.*bitfield_uaf.cc}}:[[@LINE-3]]
+// CHECK:   {{#1 .* main}}
+}
+
+int main(void) {
+  S *s = (S*)malloc(sizeof(S));
+  free(s);
+// CHECK: [[ADDR]] is located 0 bytes inside of 4-byte region
+// CHECK-LABEL: freed by thread T0 here:
+// CHECK:   {{#0 .* free }}
+// CHECK:   {{#1 .* main .*bitfield_uaf.cc}}:[[@LINE-4]]
+// CHECK-LABEL: previously allocated by thread T0 here:
+// CHECK:   {{#0 .* malloc }}
+// CHECK:   {{#1 .* main .*bitfield_uaf.cc}}:[[@LINE-8]]
+  make_access(s);
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cc
new file mode 100644
index 0000000..459025b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  int *buffer = (int*)calloc(42, sizeof(int));
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*calloc_left_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 4 bytes to the left of 168-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* calloc }}
+// CHECK-NEXT: {{#1 .* main .*calloc_left_oob.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cc
new file mode 100644
index 0000000..c976b87
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  int *buffer = (int*)calloc(42, sizeof(int));
+  buffer[42] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*calloc_right_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes to the right of 168-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* calloc }}
+// CHECK-NEXT: {{#1 .* main .*calloc_right_oob.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/calloc_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/calloc_uaf.cc
new file mode 100644
index 0000000..db5e707
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/calloc_uaf.cc
@@ -0,0 +1,20 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  int *buffer = (int*)calloc(42, sizeof(int));
+  free(buffer);
+  buffer[0] = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*calloc_uaf.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 168-byte region
+// CHECK: freed by thread T0 here:
+// CHECK-NEXT: {{#0 .* free }}
+// CHECK-NEXT: {{#1 .* main .*calloc_uaf.cc}}:[[@LINE-8]]
+// CHECK: previously allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* calloc }}
+// CHECK-NEXT: {{#1 .* main .*calloc_uaf.cc}}:[[@LINE-12]]
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/coverage-basic.cc b/compiler-rt/test/asan/TestCases/Windows/coverage-basic.cc
new file mode 100644
index 0000000..0ff105d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/coverage-basic.cc
@@ -0,0 +1,25 @@
+// RUN: rm -rf %T/coverage-basic
+// RUN: mkdir %T/coverage-basic && cd %T/coverage-basic
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o test.exe
+// RUN: %env_asan_opts=coverage=1 %run ./test.exe
+//
+// RUN: %sancov print *.sancov | FileCheck %s
+#include <stdio.h>
+
+void foo() { fprintf(stderr, "FOO\n"); }
+void bar() { fprintf(stderr, "BAR\n"); }
+
+int main(int argc, char **argv) {
+  if (argc == 2) {
+    foo();
+    bar();
+  } else {
+    bar();
+    foo();
+  }
+}
+
+// CHECK: 0x{{[0-9a-f]*}}
+// CHECK: 0x{{[0-9a-f]*}}
+// CHECK: 0x{{[0-9a-f]*}}
+// CHECK-NOT: 0x{{[0-9a-f]*}}
diff --git a/compiler-rt/test/asan/TestCases/Windows/crt_initializers.cc b/compiler-rt/test/asan/TestCases/Windows/crt_initializers.cc
new file mode 100644
index 0000000..084f8a4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/crt_initializers.cc
@@ -0,0 +1,31 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t | FileCheck %s
+
+// This is a test for http://code.google.com/p/address-sanitizer/issues/detail?id=305
+
+#include <stdio.h>
+
+typedef void (*FPTR)();
+
+// __xi_a and __xi_z are defined in VC/crt/src/crt0dat.c
+// and are located in .CRT$XIA and .CRT$XIZ respectively.
+extern "C" FPTR __xi_a, __xi_z;
+
+int main() {
+  unsigned count = 0;
+
+  // Iterate through CRT initializers.
+  for (FPTR* it = &__xi_a; it < &__xi_z; ++it) {
+    if (*it)
+      count++;
+  }
+
+  printf("Number of nonzero CRT initializers: %u\n", count);
+// CHECK: Number of nonzero CRT initializers
+}
+
+void call_me_maybe() {}
+
+#pragma data_seg(".CRT$XIB")
+// Add an initializer that shouldn't get its own redzone.
+FPTR run_on_startup = call_me_maybe;
diff --git a/compiler-rt/test/asan/TestCases/Windows/default_options.cc b/compiler-rt/test/asan/TestCases/Windows/default_options.cc
new file mode 100644
index 0000000..6e0a28f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/default_options.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// FIXME: merge this with the common default_options test when we can run common
+// tests on Windows.
+
+const char *kAsanDefaultOptions="verbosity=1 help=1";
+
+extern "C"
+__attribute__((no_sanitize_address))
+const char *__asan_default_options() {
+  // CHECK: Available flags for AddressSanitizer:
+  return kAsanDefaultOptions;
+}
+
+int main() {
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/demangled_names.cc b/compiler-rt/test/asan/TestCases/Windows/demangled_names.cc
new file mode 100644
index 0000000..0e5939e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/demangled_names.cc
@@ -0,0 +1,50 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+// This test makes sure ASan symbolizes stack traces the way they are typically
+// symbolized on Windows.
+#include <malloc.h>
+
+namespace foo {
+// A template function in a namespace.
+template<int x>
+void bar(char *p) {
+  *p = x;
+}
+
+// A regular function in a namespace.
+void spam(char *p) {
+  bar<42>(p);
+}
+}
+
+// A multi-argument template with a bool template parameter.
+template<typename T, bool U>
+void baz(T t) {
+  if (U)
+    foo::spam(t);
+}
+
+template<typename T>
+struct A {
+  A(T v) { v_ = v; }
+  ~A();
+  char *v_;
+};
+
+// A destructor of a template class.
+template<>
+A<char*>::~A() {
+  baz<char*, true>(v_);
+}
+
+int main() {
+  char *buffer = (char*)malloc(42);
+  free(buffer);
+  A<char*> a(buffer);
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: foo::bar<42>{{.*}}demangled_names.cc
+// CHECK: foo::spam{{.*}}demangled_names.cc
+// CHECK: baz<char *,1>{{.*}}demangled_names.cc
+// CHECK: A<char *>::~A<char *>{{.*}}demangled_names.cc
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_aligned_mallocs.cc b/compiler-rt/test/asan/TestCases/Windows/dll_aligned_mallocs.cc
new file mode 100644
index 0000000..8b2c4d6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_aligned_mallocs.cc
@@ -0,0 +1,34 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: %run %t %t.dll | FileCheck %s
+
+#include <malloc.h>
+#include <stdio.h>
+
+#define CHECK_ALIGNED(ptr,alignment) \
+  do { \
+    if (((uintptr_t)(ptr) % (alignment)) != 0) \
+      return __LINE__; \
+    } \
+  while(0)
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  int *p = (int*)_aligned_malloc(1024 * sizeof(int), 32);
+  CHECK_ALIGNED(p, 32);
+  p[512] = 0;
+  _aligned_free(p);
+
+  p = (int*)_aligned_malloc(128, 128);
+  CHECK_ALIGNED(p, 128);
+  p = (int*)_aligned_realloc(p, 2048 * sizeof(int), 128);
+  CHECK_ALIGNED(p, 128);
+  p[1024] = 0;
+  if (_aligned_msize(p, 128, 0) != 2048 * sizeof(int))
+    return __LINE__;
+  _aligned_free(p);
+
+  printf("All ok\n");
+// CHECK: All ok
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_allocators_sanity.cc b/compiler-rt/test/asan/TestCases/Windows/dll_allocators_sanity.cc
new file mode 100644
index 0000000..1d31f37
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_allocators_sanity.cc
@@ -0,0 +1,39 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: %run %t %t.dll | FileCheck %s
+
+#include <malloc.h>
+#include <stdio.h>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  int *p = (int*)malloc(1024 * sizeof(int));
+  p[512] = 0;
+  free(p);
+
+  p = (int*)malloc(128);
+  p = (int*)realloc(p, 2048 * sizeof(int));
+  p[1024] = 0;
+  free(p);
+
+  p = (int*)calloc(16, sizeof(int));
+  if (p[8] != 0)
+    return 1;
+  p[15]++;
+  if (16 * sizeof(int) != _msize(p))
+    return 2;
+  free(p);
+
+  p = new int;
+  *p = 42;
+  delete p;
+
+  p = new int[42];
+  p[15]++;
+  delete [] p;
+
+  printf("All ok\n");
+// CHECK: All ok
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_and_lib.cc b/compiler-rt/test/asan/TestCases/Windows/dll_and_lib.cc
new file mode 100644
index 0000000..bddaa32
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_and_lib.cc
@@ -0,0 +1,19 @@
+// Just make sure we can link an implib into another DLL
+// This used to fail between r212699 and r212814.
+// RUN: %clang_cl_asan -DCONFIG=1 %s -c -Fo%t.1.obj
+// RUN: link /nologo /DLL /OUT:%t.1.dll %t.1.obj %asan_dll_thunk
+// RUN: %clang_cl_asan -DCONFIG=2 %s -c -Fo%t.2.obj
+// RUN: link /nologo /DLL /OUT:%t.2.dll %t.2.obj %t.1.lib %asan_dll_thunk
+// REQUIRES: asan-static-runtime
+
+#if CONFIG==1
+extern "C" __declspec(dllexport) int f1() {
+  int x = 0;
+  return 1;
+}
+#else
+extern "C" __declspec(dllexport) int f2() {
+  int x = 0;
+  return 2;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_cerr.cc b/compiler-rt/test/asan/TestCases/Windows/dll_cerr.cc
new file mode 100644
index 0000000..8f1a699
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_cerr.cc
@@ -0,0 +1,23 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: %run %t %t.dll 2>&1 | FileCheck %s
+
+// Test that it works correctly even with ICF enabled.
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll -link /OPT:REF /OPT:ICF
+// RUN: %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <iostream>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  // Just make sure we can use cout.
+  std::cout << "All ok\n";
+// CHECK: All ok
+
+  // This line forces a declaration of some global basic_ostream internal object that
+  // calls memcpy() in its constructor.  This doesn't work if __asan_init is not
+  // called early enough.
+  std::cout << 42;
+// CHECK: 42
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_control_c.cc b/compiler-rt/test/asan/TestCases/Windows/dll_control_c.cc
new file mode 100644
index 0000000..b53cb3f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_control_c.cc
@@ -0,0 +1,130 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O2 %s -Fe%t.dll
+// RUNX: %run %t %t.dll 2>&1 | FileCheck %s
+
+// Check that ASan does not CHECK fail when SEH is used around a crash from a
+// thread injected by control C.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+
+static void __declspec(noinline) CrashOnProcessDetach() {
+  printf("CrashOnProcessDetach\n");
+  fflush(stdout);
+  *static_cast<volatile int *>(0) = 0x356;
+}
+
+bool g_is_child = false;
+
+BOOL WINAPI DllMain(PVOID h, DWORD reason, PVOID reserved) {
+  if (reason == DLL_PROCESS_DETACH && g_is_child) {
+    printf("in DllMain DLL_PROCESS_DETACH\n");
+    fflush(stdout);
+    __try {
+      CrashOnProcessDetach();
+    } __except (1) {
+      printf("caught crash\n");
+      fflush(stdout);
+    }
+  }
+  return true;
+}
+
+static void run_child() {
+  // Send this process group Ctrl+C. That should only be this process.
+  printf("GenerateConsoleCtrlEvent\n");
+  fflush(stdout);
+  GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0);
+  Sleep(10 * 1000); // Wait 10 seconds, and the process should die.
+  printf("unexpected execution after interrupt\n");
+  fflush(stdout);
+  exit(0x42);
+}
+
+static int WINAPI ignore_control_c(DWORD ctrl_type) {
+  // Don't interrupt the parent.
+  return ctrl_type == CTRL_C_EVENT;
+}
+
+static int run_parent() {
+  // Set an environment variable to tell the child process to interrupt itself.
+  if (!SetEnvironmentVariableW(L"DO_CONTROL_C", L"1")) {
+    printf("SetEnvironmentVariableW failed (0x%8lx).\n", GetLastError());
+    fflush(stdout);
+    return 2;
+  }
+
+  // Launch a new process using the current executable with a new console.
+  // Ctrl-C events are console-wide, so we need a new console.
+  STARTUPINFOW si;
+  memset(&si, 0, sizeof(si));
+  si.cb = sizeof(si);
+  // Hides the new console window that we are creating.
+  si.dwFlags |= STARTF_USESHOWWINDOW;
+  si.wShowWindow = SW_HIDE;
+  // Ensures that stdout still goes to the parent despite the new console.
+  si.dwFlags |= STARTF_USESTDHANDLES;
+  si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+  si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+  si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+
+  PROCESS_INFORMATION pi;
+  memset(&pi, 0, sizeof(pi));
+  int flags = CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE;
+  if (!CreateProcessW(nullptr,           // No module name (use command line)
+                      GetCommandLineW(), // Command line
+                      nullptr,           // Process handle not inheritable
+                      nullptr,           // Thread handle not inheritable
+                      TRUE,              // Set handle inheritance to TRUE
+                      flags,             // Flags to give the child a console
+                      nullptr,           // Use parent's environment block
+                      nullptr,           // Use parent's starting directory
+                      &si, &pi)) {
+    printf("CreateProcess failed (0x%08lx).\n", GetLastError());
+    fflush(stdout);
+    return 2;
+  }
+
+  // Wait until child process exits.
+  if (WaitForSingleObject(pi.hProcess, INFINITE) == WAIT_FAILED) {
+    printf("WaitForSingleObject failed (0x%08lx).\n", GetLastError());
+    fflush(stdout);
+    return 2;
+  }
+
+  // Get the exit code. It should be the one for ctrl-c events.
+  DWORD rc;
+  if (!GetExitCodeProcess(pi.hProcess, &rc)) {
+    printf("GetExitCodeProcess failed (0x%08lx).\n", GetLastError());
+    fflush(stdout);
+    return 2;
+  }
+  if (rc == STATUS_CONTROL_C_EXIT)
+    printf("child quit with STATUS_CONTROL_C_EXIT\n");
+  else
+    printf("unexpected exit code: 0x%08lx\n", rc);
+  fflush(stdout);
+
+  // Close process and thread handles.
+  CloseHandle(pi.hProcess);
+  CloseHandle(pi.hThread);
+  return 0;
+}
+
+// CHECK: in DllMain DLL_PROCESS_DETACH
+// CHECK: CrashOnProcessDetach
+// CHECK: caught crash
+// CHECK: child quit with STATUS_CONTROL_C_EXIT
+
+extern "C" int __declspec(dllexport) test_function() {
+  wchar_t buf[260];
+  int len = GetEnvironmentVariableW(L"DO_CONTROL_C", buf, 260);
+  if (len > 0) {
+    g_is_child = true;
+    run_child();
+  } else {
+    exit(run_parent());
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_host.cc b/compiler-rt/test/asan/TestCases/Windows/dll_host.cc
new file mode 100644
index 0000000..71721fe
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_host.cc
@@ -0,0 +1,54 @@
+// This is a host program for DLL tests.
+//
+// Just make sure we can compile this.
+// The actual compile&run sequence is to be done by the DLL tests.
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+//
+// Get the list of ASan wrappers exported by the main module RTL:
+// RUN: dumpbin /EXPORTS %t | grep -o "__asan_wrap[^ ]*" | grep -v @ | sort | uniq > %t.exported_wrappers
+// FIXME: we should really check the other __asan exports too.
+// RUN: dumpbin /EXPORTS %t | grep -o "__sanitizer_[^ ]*" | grep -v @ | sort | uniq >> %t.exported_wrappers
+//
+// Get the list of ASan wrappers imported by the DLL RTL:
+// [BEWARE: be really careful with the sed commands, as this test can be run
+//  from different environemnts with different shells and seds]
+// RUN: grep INTERCEPT_LIBRARY_FUNCTION %p/../../../../lib/asan/asan_win_dll_thunk.cc | grep -v define | sed -e s/.*(/__asan_wrap_/ | sed -e s/).*// | sort | uniq > %t.dll_imports
+// RUN: grep "^INTERFACE_FUNCTION.*sanitizer" %p/../../../../lib/asan/asan_win_dll_thunk.cc | grep -v define | sed -e s/.*(// | sed -e s/).*// | sort | uniq >> %t.dll_imports
+//
+// Now make sure the DLL thunk imports everything:
+// RUN: echo
+// RUN: echo "=== NOTE === If you see a mismatch below, please update asan_win_dll_thunk.cc"
+// RUN: diff %t.dll_imports %t.exported_wrappers
+// REQUIRES: asan-static-runtime
+
+#include <stdio.h>
+#include <windows.h>
+
+int main(int argc, char **argv) {
+  if (argc != 2) {
+    printf("Usage: %s [client].dll\n", argv[0]);
+    return 101;
+  }
+
+  const char *dll_name = argv[1];
+
+  HMODULE h = LoadLibrary(dll_name);
+  if (!h) {
+    printf("Could not load DLL: %s (code: %lu)!\n",
+           dll_name, GetLastError());
+    return 102;
+  }
+
+  typedef int (*test_function)();
+  test_function gf = (test_function)GetProcAddress(h, "test_function");
+  if (!gf) {
+    printf("Could not locate test_function in the DLL!\n");
+    FreeLibrary(h);
+    return 103;
+  }
+
+  int ret = gf();
+
+  FreeLibrary(h);
+  return ret;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memchr.cc b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memchr.cc
new file mode 100644
index 0000000..1435bdc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memchr.cc
@@ -0,0 +1,21 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <string.h>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char buff[6] = "Hello";
+
+  memchr(buff, 'z', 7);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: READ of size 7 at [[ADDR]] thread T0
+// CHECK-NEXT:  __asan_wrap_memchr
+// CHECK-NEXT:  memchr
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memchr.cc:[[@LINE-5]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memchr.cc
+// CHECK: 'buff' <== Memory access at offset {{.*}} overflows this variable
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy.cc b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy.cc
new file mode 100644
index 0000000..736e696
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy.cc
@@ -0,0 +1,32 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+// Test that it works correctly even with ICF enabled.
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll -link /OPT:REF /OPT:ICF
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char buff1[6] = "Hello", buff2[5];
+
+  memcpy(buff2, buff1, 5);
+  if (buff1[2] != buff2[2])
+    return 2;
+  printf("Initial test OK\n");
+  fflush(0);
+// CHECK: Initial test OK
+
+  memcpy(buff2, buff1, 6);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 6 at [[ADDR]] thread T0
+// CHECK-NEXT:  __asan_{{.*}}memcpy
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy.cc:[[@LINE-4]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy.cc
+// CHECK: 'buff2' <== Memory access at offset {{.*}} overflows this variable
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy_indirect.cc b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy_indirect.cc
new file mode 100644
index 0000000..c5f44df
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy_indirect.cc
@@ -0,0 +1,34 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+void call_memcpy(void* (*f)(void *, const void *, size_t),
+                 void *a, const void *b, size_t c) {
+  f(a, b, c);
+}
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char buff1[6] = "Hello", buff2[5];
+
+  call_memcpy(&memcpy, buff2, buff1, 5);
+  if (buff1[2] != buff2[2])
+    return 2;
+  printf("Initial test OK\n");
+  fflush(0);
+// CHECK: Initial test OK
+
+  call_memcpy(&memcpy, buff2, buff1, 6);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 6 at [[ADDR]] thread T0
+// CHECK-NEXT:  __asan_{{.*}}memcpy
+// CHECK-NEXT:  call_memcpy
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy_indirect.cc:[[@LINE-5]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memcpy_indirect.cc
+// CHECK: 'buff2' <== Memory access at offset {{.*}} overflows this variable
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memset.cc b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memset.cc
new file mode 100644
index 0000000..d4be376
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_memset.cc
@@ -0,0 +1,32 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+// Test that it works correctly even with ICF enabled.
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll -link /OPT:REF /OPT:ICF
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char buff[5] = "aaaa";
+
+  memset(buff, 'b', 5);
+  if (buff[2] != 'b')
+    return 2;
+  printf("Initial test OK\n");
+  fflush(0);
+// CHECK: Initial test OK
+
+  memset(buff, 'c', 6);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 6 at [[ADDR]] thread T0
+// CHECK-NEXT:  __asan_memset
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memset.cc:[[@LINE-4]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT:  test_function {{.*}}dll_intercept_memset.cc
+// CHECK: 'buff' <== Memory access at offset {{.*}} overflows this variable
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_intercept_strlen.cc b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_strlen.cc
new file mode 100644
index 0000000..f41d478
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_intercept_strlen.cc
@@ -0,0 +1,28 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char str[] = "Hello!";
+  if (6 != strlen(str))
+    return 1;
+  printf("Initial test OK\n");
+  fflush(0);
+// CHECK: Initial test OK
+
+  str[6] = '!';  // Removes '\0' at the end!
+  int len = strlen(str);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// FIXME: Should be READ of size 1, see issue 155.
+// CHECK: READ of size {{[0-9]+}} at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .*}}strlen
+// CHECK-NEXT: {{#1 .* test_function .*}}dll_intercept_strlen.cc:[[@LINE-5]]
+//
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT: test_function {{.*}}dll_intercept_strlen.cc:
+  return len > 42;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_large_function.cc b/compiler-rt/test/asan/TestCases/Windows/dll_large_function.cc
new file mode 100644
index 0000000..039d01f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_large_function.cc
@@ -0,0 +1,12 @@
+// Make sure we can link a DLL with large functions which would mean
+// functions such as __asan_loadN and __asan_storeN will be called
+// from the DLL.  We simulate the large function with
+// -mllvm -asan-instrumentation-with-call-threshold=0.
+// RUN: %clang_cl_asan %s -c -Fo%t.obj -mllvm -asan-instrumentation-with-call-threshold=0
+// RUN: link /nologo /DLL /OUT:%t.dll %t.obj %asan_dll_thunk
+// REQUIRES: asan-static-runtime
+
+void f(long* foo, long* bar) {
+  // One load and one store
+  *foo = *bar;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_malloc_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/dll_malloc_left_oob.cc
new file mode 100644
index 0000000..0653ea4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_malloc_left_oob.cc
@@ -0,0 +1,23 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <malloc.h>
+extern "C" __declspec(dllexport)
+int test_function() {
+  char *buffer = (char*)malloc(42);
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: test_function {{.*}}dll_malloc_left_oob.cc:[[@LINE-3]]
+// CHECK-NEXT: main {{.*}}dll_host.cc
+//
+// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK-LABEL: allocated by thread T0 here:
+// CHECK-NEXT:   malloc
+// CHECK-NEXT:   test_function {{.*}}dll_malloc_left_oob.cc:[[@LINE-10]]
+// CHECK-NEXT:   main {{.*}}dll_host.cc
+// CHECK-LABEL: SUMMARY
+  free(buffer);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_malloc_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/dll_malloc_uaf.cc
new file mode 100644
index 0000000..b286380
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_malloc_uaf.cc
@@ -0,0 +1,28 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  int *buffer = (int*)malloc(42);
+  free(buffer);
+  buffer[0] = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT:  test_function {{.*}}dll_malloc_uaf.cc:[[@LINE-3]]
+// CHECK-NEXT:  main {{.*}}dll_host
+//
+// CHECK: [[ADDR]] is located 0 bytes inside of 42-byte region
+// CHECK-LABEL: freed by thread T0 here:
+// CHECK-NEXT:  free
+// CHECK-NEXT:  test_function {{.*}}dll_malloc_uaf.cc:[[@LINE-10]]
+// CHECK-NEXT:  main {{.*}}dll_host
+//
+// CHECK-LABEL: previously allocated by thread T0 here:
+// CHECK-NEXT:  malloc
+// CHECK-NEXT:  test_function {{.*}}dll_malloc_uaf.cc:[[@LINE-16]]
+// CHECK-NEXT:  main {{.*}}dll_host
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_noreturn.cc b/compiler-rt/test/asan/TestCases/Windows/dll_noreturn.cc
new file mode 100644
index 0000000..8b5e3d0
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_noreturn.cc
@@ -0,0 +1,28 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <process.h>
+
+void noreturn_f() {
+  int subscript = -1;
+  char buffer[42];
+  buffer[subscript] = 42;
+  _exit(1);
+// CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT:  noreturn_f{{.*}}dll_noreturn.cc:[[@LINE-4]]
+// CHECK-NEXT:  test_function{{.*}}dll_noreturn.cc
+// CHECK-NEXT:  main{{.*}}dll_host.cc
+//
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT:  noreturn_f{{.*}}dll_noreturn.cc
+// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] underflows this variable
+// CHECK-LABEL: SUMMARY
+}
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  noreturn_f();
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_null_deref.cc b/compiler-rt/test/asan/TestCases/Windows/dll_null_deref.cc
new file mode 100644
index 0000000..0fb18de
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_null_deref.cc
@@ -0,0 +1,18 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+__attribute__((noinline))
+static void NullDeref(int *ptr) {
+  // CHECK: ERROR: AddressSanitizer: access-violation on unknown address
+  // CHECK:   {{0x0*000.. .*pc 0x.*}}
+  ptr[10]++;  // BOOM
+}
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  NullDeref((int*)0);
+  // CHECK: {{    #1 0x.* in test_function .*\dll_null_deref.cc:}}[[@LINE-1]]
+  // CHECK: AddressSanitizer can not provide additional info.
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_left_oob.cc
new file mode 100644
index 0000000..736ce80
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_left_oob.cc
@@ -0,0 +1,25 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char *buffer = new char[42];
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: test_function {{.*}}dll_operator_array_new_left_oob.cc:[[@LINE-3]]
+// CHECK-NEXT: main {{.*}}dll_host.cc
+//
+// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK-LABEL: allocated by thread T0 here:
+// FIXME: Should get rid of the malloc/free frames called from the inside of
+// operator new/delete in DLLs when using -MT CRT.
+// FIXME: The 'operator new' frame should have [].
+// CHECK:        operator new
+// CHECK-NEXT:   test_function {{.*}}dll_operator_array_new_left_oob.cc:[[@LINE-13]]
+// CHECK-NEXT:   main {{.*}}dll_host.cc
+// CHECK-LABEL: SUMMARY
+  delete [] buffer;
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_with_dtor_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_with_dtor_left_oob.cc
new file mode 100644
index 0000000..8306a73
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_with_dtor_left_oob.cc
@@ -0,0 +1,33 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+struct C {
+  int x;
+  ~C() {}
+};
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  C *buffer = new C[42];
+  buffer[-2].x = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT: test_function {{.*}}dll_operator_array_new_with_dtor_left_oob.cc:[[@LINE-3]]
+// CHECK-NEXT: main {{.*}}dll_host.cc
+//
+// FIXME: Currently it says "4 bytes ... left of 172-byte region",
+//        should be "8 bytes ... left of 168-byte region", see
+//        https://code.google.com/p/address-sanitizer/issues/detail?id=314
+// CHECK: [[ADDR]] is located {{.*}} bytes to the left of 172-byte region
+// FIXME: Should get rid of the malloc/free frames called from the inside of
+// operator new/delete in DLLs when using -MT CRT.
+// FIXME: The operator new frame should have [].
+// CHECK-LABEL: allocated by thread T0 here:
+// CHECK:        operator new
+// CHECK-NEXT:   test_function {{.*}}dll_operator_array_new_with_dtor_left_oob.cc:[[@LINE-16]]
+// CHECK-NEXT:   main {{.*}}dll_host.cc
+// CHECK-LABEL: SUMMARY
+  delete [] buffer;
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_poison_unpoison.cc b/compiler-rt/test/asan/TestCases/Windows/dll_poison_unpoison.cc
new file mode 100644
index 0000000..9b25a12
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_poison_unpoison.cc
@@ -0,0 +1,35 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <sanitizer/asan_interface.h>
+
+void should_not_crash(volatile char *c) {
+  *c = 42;
+}
+
+void should_crash(volatile char *c) {
+  *c = 42;
+}
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char buffer[256];
+  should_not_crash(&buffer[0]);
+  __asan_poison_memory_region(buffer, 128);
+  should_not_crash(&buffer[192]);
+  __asan_unpoison_memory_region(buffer, 64);
+  should_not_crash(&buffer[32]);
+
+  should_crash(&buffer[96]);
+// CHECK: AddressSanitizer: use-after-poison on address [[ADDR:0x[0-9a-f]+]]
+// CHECK-NEXT: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: should_crash{{.*}}\dll_poison_unpoison.cc
+// CHECK-NEXT: test_function{{.*}}\dll_poison_unpoison.cc:[[@LINE-4]]
+// CHECK-NEXT: main
+//
+// CHECK: [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT: test_function{{.*}}\dll_poison_unpoison.cc
+// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] is inside this variable
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_report_globals_symbolization_at_startup.cc b/compiler-rt/test/asan/TestCases/Windows/dll_report_globals_symbolization_at_startup.cc
new file mode 100644
index 0000000..e07f26f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_report_globals_symbolization_at_startup.cc
@@ -0,0 +1,40 @@
+// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
+// RUN: %clang_cl_asan -O0 -DEXE %s %t.lib -Fe%te.exe
+// RUN: %env_asan_opts=report_globals=2 %run %te.exe 2>&1 | FileCheck %s
+
+// FIXME: Currently, the MT runtime build crashes on startup due to dbghelp.dll
+// initialization failure.
+// REQUIRES: asan-dynamic-runtime
+
+#include <windows.h>
+#include <stdio.h>
+
+extern "C" {
+#if defined(EXE)
+__declspec(dllimport) int foo_from_dll();
+
+// CHECK: in DLL(reason=1)
+int main(int argc, char **argv) {
+  foo_from_dll();
+// CHECK: hello!
+  printf("hello!\n");
+  fflush(0);
+// CHECK: in DLL(reason=0)
+}
+#elif defined(DLL)
+// This global is registered at startup.
+int x[42];
+
+__declspec(dllexport) int foo_from_dll() {
+  return x[2];
+}
+
+BOOL WINAPI DllMain(HMODULE, DWORD reason, LPVOID) {
+  printf("in DLL(reason=%d)\n", (int)reason);
+  fflush(0);
+  return TRUE;
+}
+#else
+# error oops!
+#endif
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_seh.cc b/compiler-rt/test/asan/TestCases/Windows/dll_seh.cc
new file mode 100644
index 0000000..6e4c724
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_seh.cc
@@ -0,0 +1,60 @@
+// Clang doesn't support SEH on Windows yet, so for the time being we
+// build this program in two parts: the code with SEH is built with CL,
+// the rest is built with Clang.  This represents the typical scenario when we
+// build a large project using "clang-cl -fallback -fsanitize=address".
+//
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+//
+// Check both -GS and -GS- builds:
+// RUN: cl -LD -c %s -Fo%t.obj
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll %t.obj
+// RUN: %run %t %t.dll
+//
+// RUN: cl -LD -GS- -c %s -Fo%t.obj
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll %t.obj
+// RUN: %run %t %t.dll
+
+#include <windows.h>
+#include <assert.h>
+#include <stdio.h>
+
+// Should just "#include <sanitizer/asan_interface.h>" when C++ exceptions are
+// supported and we don't need to use CL.
+extern "C" bool __asan_address_is_poisoned(void *p);
+
+void ThrowAndCatch();
+
+#if !defined(__clang__)
+__declspec(noinline)
+void Throw() {
+  int local, zero = 0;
+  fprintf(stderr, "Throw:  %p\n", &local);
+  local = 5 / zero;
+}
+
+__declspec(noinline)
+void ThrowAndCatch() {
+  int local;
+  __try {
+    Throw();
+  } __except(EXCEPTION_EXECUTE_HANDLER) {
+    fprintf(stderr, "__except:  %p\n", &local);
+  }
+}
+#else
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  char x[32];
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  ThrowAndCatch();
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  assert(!__asan_address_is_poisoned(x + 32));
+  return 0;
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_stack_use_after_return.cc b/compiler-rt/test/asan/TestCases/Windows/dll_stack_use_after_return.cc
new file mode 100644
index 0000000..6428718
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_stack_use_after_return.cc
@@ -0,0 +1,28 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+char *x;
+
+void foo() {
+  char stack_buffer[42];
+  x = &stack_buffer[13];
+}
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  foo();
+  *x = 42;
+// CHECK: AddressSanitizer: stack-use-after-return
+// CHECK: WRITE of size 1 at [[ADDR:.*]] thread T0
+// CHECK-NEXT:  test_function{{.*}}dll_stack_use_after_return.cc:[[@LINE-3]]
+// CHECK-NEXT:  main
+//
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT: #0 {{.*}} foo{{.*}}dll_stack_use_after_return.cc
+// CHECK: 'stack_buffer' <== Memory access at offset [[OFFSET]] is inside this variable
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/dll_thread_stack_array_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/dll_thread_stack_array_left_oob.cc
new file mode 100644
index 0000000..dc7c7c6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/dll_thread_stack_array_left_oob.cc
@@ -0,0 +1,36 @@
+// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
+// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
+// RUN: not %run %t %t.dll 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <malloc.h>
+
+DWORD WINAPI thread_proc(void *context) {
+  int subscript = -1;
+  char stack_buffer[42];
+  stack_buffer[subscript] = 42;
+// CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T1
+// CHECK-NEXT:  thread_proc{{.*}}dll_thread_stack_array_left_oob.cc:[[@LINE-3]]
+//
+// CHECK: Address [[ADDR]] is located in stack of thread T1 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT:  thread_proc{{.*}}dll_thread_stack_array_left_oob.cc
+//
+// CHECK: 'stack_buffer' <== Memory access at offset [[OFFSET]] underflows this variable
+
+  return 0;
+}
+
+extern "C" __declspec(dllexport)
+int test_function() {
+  HANDLE thr = CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
+// CHECK-LABEL: Thread T1 created by T0 here:
+// CHECK:         test_function{{.*}}dll_thread_stack_array_left_oob.cc:[[@LINE-2]]
+// CHECK-NEXT:    main{{.*}}dll_host.cc
+// CHECK-LABEL: SUMMARY
+  if (thr == 0)
+    return 1;
+  if (WAIT_OBJECT_0 != WaitForSingleObject(thr, INFINITE))
+    return 2;
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/double_free.cc b/compiler-rt/test/asan/TestCases/Windows/double_free.cc
new file mode 100644
index 0000000..18a9fcb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/double_free.cc
@@ -0,0 +1,21 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  int *x = (int*)malloc(42 * sizeof(int));
+  free(x);
+  free(x);
+// CHECK: AddressSanitizer: attempting double-free on [[ADDR:0x[0-9a-f]+]]
+// CHECK-NEXT: {{#0 .* free }}
+// CHECK-NEXT: {{#1 .* main .*double_free.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 168-byte region
+// CHECK-LABEL: freed by thread T0 here:
+// CHECK-NEXT: {{#0 .* free }}
+// CHECK-NEXT: {{#1 .* main .*double_free.cc}}:[[@LINE-8]]
+// CHECK-LABEL: previously allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* malloc }}
+// CHECK-NEXT: {{#1 .* main .*double_free.cc}}:[[@LINE-12]]
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cc b/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cc
new file mode 100644
index 0000000..eae4a64
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cc
@@ -0,0 +1,25 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  int *x = new int[42];
+  delete [] x;
+  delete [] x;
+// CHECK: AddressSanitizer: attempting double-free on [[ADDR:0x[0-9a-f]+]]
+// FIXME: The 'operator delete' frame should have [].
+// CHECK-NEXT: {{#0 .* operator delete}}
+// CHECK-NEXT: {{#1 .* main .*double_operator_delete.cc}}:[[@LINE-4]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 168-byte region
+// CHECK-LABEL: freed by thread T0 here:
+// FIXME: The 'operator delete' frame should have [].
+// CHECK-NEXT: {{#0 .* operator delete}}
+// CHECK-NEXT: {{#1 .* main .*double_operator_delete.cc}}:[[@LINE-10]]
+// CHECK-LABEL: previously allocated by thread T0 here:
+// FIXME: The 'operator new' frame should have [].
+// CHECK-NEXT: {{#0 .* operator new}}
+// CHECK-NEXT: {{#1 .* main .*double_operator_delete.cc}}:[[@LINE-15]]
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/free_hook_realloc.cc b/compiler-rt/test/asan/TestCases/Windows/free_hook_realloc.cc
new file mode 100644
index 0000000..297218b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/free_hook_realloc.cc
@@ -0,0 +1,37 @@
+// Check that free hook doesn't conflict with Realloc.
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// FIXME: merge this with the common free_hook_realloc test when we can run
+// common tests on Windows.
+
+#include <stdlib.h>
+#include <io.h>
+#include <sanitizer/allocator_interface.h>
+
+static void *glob_ptr;
+
+extern "C" {
+void __sanitizer_free_hook(const volatile void *ptr) {
+  if (ptr == glob_ptr) {
+    *(int*)ptr = 0;
+    write(1, "FreeHook\n", sizeof("FreeHook\n"));
+  }
+}
+}
+
+int main() {
+  int *x = (int*)malloc(100);
+  x[0] = 42;
+  glob_ptr = x;
+  int *y = (int*)realloc(x, 200);
+  // Verify that free hook was called and didn't spoil the memory.
+  if (y[0] != 42) {
+    _exit(1);
+  }
+  write(1, "Passed\n", sizeof("Passed\n"));
+  free(y);
+  // CHECK: FreeHook
+  // CHECK: Passed
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/fuse-lld.cc b/compiler-rt/test/asan/TestCases/Windows/fuse-lld.cc
new file mode 100644
index 0000000..76c36d8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/fuse-lld.cc
@@ -0,0 +1,23 @@
+// If we have LLD, see that things more or less work.
+//
+// REQUIRES: lld
+//
+// FIXME: Use -fuse-ld=lld after the old COFF linker is removed.
+// FIXME: Test will fail until we add flags for requesting dwarf or cv.
+// RUNX: %clangxx_asan -O2 %s -o %t.exe -fuse-ld=lld -Wl,-debug
+// RUN: %clangxx_asan -c -O2 %s -o %t.o -gdwarf
+// RUN: lld-link %t.o -out:%t.exe -debug -defaultlib:libcmt %asan_lib %asan_cxx_lib
+// RUN: not %run %t.exe 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: heap-use-after-free
+  // CHECK: free
+  // CHECK: main{{.*}}fuse-lld.cc:[[@LINE-4]]:3
+  // CHECK: malloc
+  // CHECK: main{{.*}}fuse-lld.cc:[[@LINE-7]]:20
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/global_const_string.cc b/compiler-rt/test/asan/TestCases/Windows/global_const_string.cc
new file mode 100644
index 0000000..8c147c9
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/global_const_string.cc
@@ -0,0 +1,12 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t | FileCheck %s
+
+#include <windows.h>
+#include <stdio.h>
+
+int main(void) {
+  static const char *foo = "foobarspam";
+  printf("Global string is `%s`\n", foo);
+// CHECK: Global string is `foobarspam`
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/global_const_string_oob.cc b/compiler-rt/test/asan/TestCases/Windows/global_const_string_oob.cc
new file mode 100644
index 0000000..b39e3db
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/global_const_string_oob.cc
@@ -0,0 +1,20 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <stdio.h>
+
+extern "C" const char *foo = "foobarspam";
+
+int main(void) {
+  if (foo[16])
+    printf("Boo\n");
+// CHECK-NOT: Boo
+// CHECK: AddressSanitizer: global-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: READ of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT:   {{#0 .* main .*global_const_string_oob.cc:}}[[@LINE-5]]
+// CHECK: [[ADDR]] is located 5 bytes to the right of global variable [[STR:.*]] defined in {{'.*global_const_string_oob.cc:7:.*' .*}} of size 11
+// CHECK:   [[STR]] is ascii string 'foobarspam'
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/hello_world.cc b/compiler-rt/test/asan/TestCases/Windows/hello_world.cc
new file mode 100644
index 0000000..400ca1b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/hello_world.cc
@@ -0,0 +1,9 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t | FileCheck %s
+
+#include <stdio.h>
+
+int main() {
+  printf("Hello, world!\n");
+// CHECK: Hello, world!
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/intercept_memcpy.cc b/compiler-rt/test/asan/TestCases/Windows/intercept_memcpy.cc
new file mode 100644
index 0000000..9ee984b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/intercept_memcpy.cc
@@ -0,0 +1,31 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+void call_memcpy(void* (*f)(void *, const void *, size_t),
+                 void *a, const void *b, size_t c) {
+  f(a, b, c);
+}
+
+int main() {
+  char buff1[6] = "Hello", buff2[5];
+
+  call_memcpy(&memcpy, buff2, buff1, 5);
+  if (buff1[2] != buff2[2])
+    return 2;
+  printf("Initial test OK\n");
+  fflush(0);
+// CHECK: Initial test OK
+
+  call_memcpy(&memcpy, buff2, buff1, 6);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 6 at [[ADDR]] thread T0
+// CHECK-NEXT:  __asan_{{.*}}memcpy
+// CHECK-NEXT:  call_memcpy
+// CHECK-NEXT:  main {{.*}}intercept_memcpy.cc:[[@LINE-5]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT:   #0 {{.*}} main
+// CHECK: 'buff2' <== Memory access at offset {{.*}} overflows this variable
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/intercept_strdup.cc b/compiler-rt/test/asan/TestCases/Windows/intercept_strdup.cc
new file mode 100644
index 0000000..3710534
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/intercept_strdup.cc
@@ -0,0 +1,28 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+#include <malloc.h>
+
+int main() {
+  char *ptr = _strdup("Hello");
+  int subscript = 1;
+  ptr[subscript] = '3';
+  printf("%s\n", ptr);
+  fflush(0);
+// CHECK: H3llo
+
+  subscript = -1;
+  ptr[subscript] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK:   {{#0 .* main .*}}intercept_strdup.cc:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 1 bytes to the left of 6-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK:   {{#0 .* malloc }}
+// FIXME: llvm-symbolizer can't find strdup in the CRT.
+// CHECKX:   {{#1 .*strdup}}
+// CHECK:   {{#2 .* main .*}}intercept_strdup.cc:[[@LINE-17]]
+  free(ptr);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/intercept_strlen.cc b/compiler-rt/test/asan/TestCases/Windows/intercept_strlen.cc
new file mode 100644
index 0000000..928a286
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/intercept_strlen.cc
@@ -0,0 +1,27 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+
+int main() {
+  char str[] = "Hello";
+  if (5 != strlen(str))
+    return 1;
+
+  printf("Initial test OK\n");
+  fflush(0);
+// CHECK: Initial test OK
+
+  str[5] = '!';  // Losing '\0' at the end.
+  int len = strlen(str);
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// FIXME: Should be READ of size 1, see issue 155.
+// CHECK: READ of size {{[0-9]+}} at [[ADDR]] thread T0
+// CHECK:      strlen 
+// CHECK-NEXT: main {{.*}}intercept_strlen.cc:[[@LINE-5]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset {{.*}} in frame
+// CHECK-NEXT: main {{.*}}intercept_strlen.cc
+// CHECK: 'str' <== Memory access at offset {{.*}} overflows this variable
+  return len < 6;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/iostream_sbo.cc b/compiler-rt/test/asan/TestCases/Windows/iostream_sbo.cc
new file mode 100644
index 0000000..ffcd530
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/iostream_sbo.cc
@@ -0,0 +1,18 @@
+// First, check this works with the default blacklist:
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: echo "42" | %run %t 2>&1 | FileCheck %s
+//
+// Then, make sure it still works when a user uses his own blacklist file:
+// RUN: %clang_cl_asan -O0 %s -fsanitize-blacklist=%p/../Helpers/initialization-blacklist.txt -Fe%t2
+// RUN: echo "42" | %run %t2 2>&1 | FileCheck %s
+
+#include <iostream>
+
+int main() {
+  int i;
+  std::cout << "Type i: ";
+  std::cin >> i;
+  return 0;
+// CHECK: Type i:
+// CHECK-NOT: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/lit.local.cfg b/compiler-rt/test/asan/TestCases/Windows/lit.local.cfg
new file mode 100644
index 0000000..13ef6d4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/lit.local.cfg
@@ -0,0 +1,14 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+# We only run a small set of tests on Windows for now.
+# Override the parent directory's "unsupported" decision until we can handle
+# all of its tests.
+if root.host_os in ['Windows']:
+  config.unsupported = False
+else:
+  config.unsupported = True
diff --git a/compiler-rt/test/asan/TestCases/Windows/longjmp.cc b/compiler-rt/test/asan/TestCases/Windows/longjmp.cc
new file mode 100644
index 0000000..443933e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/longjmp.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_asan -O %s -o %t && %run %t
+
+// FIXME: merge this with the common longjmp test when we can run common
+// tests on Windows.
+
+#include <assert.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+static jmp_buf buf;
+
+int main() {
+  char x[32];
+  fprintf(stderr, "\nTestLongJmp\n");
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  if (0 == setjmp(buf))
+    longjmp(buf, 1);
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  assert(!__asan_address_is_poisoned(x + 32));
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/malloc_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/malloc_left_oob.cc
new file mode 100644
index 0000000..ec133c3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/malloc_left_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)malloc(42);
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*malloc_left_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* malloc }}
+// CHECK-NEXT: {{#1 .* main .*malloc_left_oob.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/malloc_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/malloc_right_oob.cc
new file mode 100644
index 0000000..9975316
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/malloc_right_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)malloc(42);
+  buffer[42] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*malloc_right_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* malloc }}
+// CHECK-NEXT: {{#1 .* main .*malloc_right_oob.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/malloc_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/malloc_uaf.cc
new file mode 100644
index 0000000..f584789
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/malloc_uaf.cc
@@ -0,0 +1,20 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)malloc(42);
+  free(buffer);
+  buffer[0] = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*malloc_uaf.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 42-byte region
+// CHECK: freed by thread T0 here:
+// CHECK-NEXT: {{#0 .* free }}
+// CHECK-NEXT: {{#1 .* main .*malloc_uaf.cc}}:[[@LINE-8]]
+// CHECK: previously allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* malloc }}
+// CHECK-NEXT: {{#1 .* main .*malloc_uaf.cc}}:[[@LINE-12]]
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/null_deref.cc b/compiler-rt/test/asan/TestCases/Windows/null_deref.cc
new file mode 100644
index 0000000..9515602
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/null_deref.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// FIXME: merge this with the common null_deref test when we can run common
+// tests on Windows.
+
+__attribute__((noinline))
+static void NullDeref(int *ptr) {
+  // CHECK: ERROR: AddressSanitizer: access-violation on unknown address
+  // CHECK:   {{0x0*000.. .*pc 0x.*}}
+  ptr[10]++;  // BOOM
+}
+int main() {
+  NullDeref((int*)0);
+  // CHECK: {{    #1 0x.* in main.*null_deref.cc:}}[[@LINE-1]]:3
+  // CHECK: AddressSanitizer can not provide additional info.
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/null_deref_multiple_dlls.cc b/compiler-rt/test/asan/TestCases/Windows/null_deref_multiple_dlls.cc
new file mode 100644
index 0000000..62fe544
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/null_deref_multiple_dlls.cc
@@ -0,0 +1,40 @@
+// Make sure everything works even if the main module doesn't have any stack
+// variables, thus doesn't explicitly reference any symbol exported by the
+// runtime thunk.
+//
+// RUN: %clang_cl_asan -LD -O0 -DDLL1 %s -Fe%t1.dll
+// RUN: %clang_cl_asan -LD -O0 -DDLL2 %s -Fe%t2.dll
+// RUN: %clang_cl_asan -O0 -DEXE %s %t1.lib %t2.lib -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+#include <string.h>
+
+extern "C" {
+#if defined(EXE)
+__declspec(dllimport) void foo1();
+__declspec(dllimport) void foo2();
+
+int main() {
+  foo1();
+  foo2();
+}
+#elif defined(DLL1)
+__declspec(dllexport) void foo1() {}
+#elif defined(DLL2)
+__attribute__((noinline))
+static void NullDeref(int *ptr) {
+  // CHECK: ERROR: AddressSanitizer: access-violation on unknown address
+  // CHECK:   {{0x0*000.. .*pc 0x.*}}
+  ptr[10]++;  // BOOM
+}
+
+__declspec(dllexport) void foo2() {
+  NullDeref((int*)0);
+  // CHECK: {{    #1 0x.* in foo2.*null_deref_multiple_dlls.cc:}}[[@LINE-1]]
+  // CHECK: AddressSanitizer can not provide additional info.
+}
+#else
+# error oops!
+#endif
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/on_error_callback.cc b/compiler-rt/test/asan/TestCases/Windows/on_error_callback.cc
new file mode 100644
index 0000000..9e690a3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/on_error_callback.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// FIXME: merge this with the common on_error_callback test when we can run
+// common tests on Windows.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+extern "C"
+void __asan_on_error() {
+  fprintf(stderr, "__asan_on_error called");
+  fflush(0);
+}
+
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: __asan_on_error called
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/oom.cc b/compiler-rt/test/asan/TestCases/Windows/oom.cc
new file mode 100644
index 0000000..b24cddf
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/oom.cc
@@ -0,0 +1,12 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  while (true) {
+    void *ptr = malloc(200 * 1024 * 1024);  // 200MB
+    free(ptr);
+  }
+// CHECK: failed to allocate
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cc
new file mode 100644
index 0000000..20a0f19
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+int main() {
+  char *buffer = new char[42];
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-3]]
+//
+// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK-LABEL: allocated by thread T0 here:
+// FIXME: The 'operator new' frame should have [].
+// CHECK-NEXT: {{#0 .* operator new}}
+// CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-10]]
+  delete [] buffer;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cc
new file mode 100644
index 0000000..23775ef
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cc
@@ -0,0 +1,18 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer = new char[42];
+  buffer[42] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK:   {{#0 .* main .*operator_array_new_right_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
+// CHECK: allocated by thread T0 here:
+// FIXME: The 'operator new' frame should have [].
+// CHECK:   {{#0 .* operator new}}
+// CHECK:   {{#1 .* main .*operator_array_new_right_oob.cc}}:[[@LINE-9]]
+  delete [] buffer;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cc
new file mode 100644
index 0000000..b638ef1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cc
@@ -0,0 +1,24 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer = new char[42];
+  delete [] buffer;
+  buffer[0] = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK:   {{#0 .* main .*operator_array_new_uaf.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 42-byte region
+// CHECK-LABEL: freed by thread T0 here:
+// FIXME: The 'operator delete' frame should have [].
+// CHECK:   {{#0 .* operator delete}}
+// CHECK:   {{#1 .* main .*operator_array_new_uaf.cc}}:[[@LINE-9]]
+// CHECK-LABEL: previously allocated by thread T0 here:
+// FIXME: The 'operator new' frame should have [].
+// CHECK:   {{#0 .* operator new}}
+// CHECK:   {{#1 .* main .*operator_array_new_uaf.cc}}:[[@LINE-14]]
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cc
new file mode 100644
index 0000000..63f2929
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cc
@@ -0,0 +1,25 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+struct C {
+  int x;
+  ~C() {}
+};
+
+int main() {
+  C *buffer = new C[42];
+  buffer[-2].x = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*operator_array_new_with_dtor_left_oob.cc}}:[[@LINE-3]]
+//
+// FIXME: Currently it says "4 bytes ... left of 172-byte region",
+//        should be "8 bytes ... left of 168-byte region", see
+//        https://code.google.com/p/address-sanitizer/issues/detail?id=314
+// CHECK: [[ADDR]] is located {{.*}} bytes to the left of 172-byte region
+// CHECK-LABEL: allocated by thread T0 here:
+// FIXME: The 'operator new' frame should have [].
+// CHECK-NEXT: {{#0 .* operator new}}
+// CHECK-NEXT: {{#1 .* main .*operator_array_new_with_dtor_left_oob.cc}}:[[@LINE-13]]
+  delete [] buffer;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cc b/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cc
new file mode 100644
index 0000000..4687592
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cc
@@ -0,0 +1,12 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  int *x = new int[42];
+  delete (x + 1);
+// CHECK: AddressSanitizer: attempting free on address which was not malloc()-ed
+// CHECK:   {{#0 0x.* operator delete}}
+// CHECK:   {{#1 .* main .*operator_delete_wrong_argument.cc}}:[[@LINE-3]]
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cc
new file mode 100644
index 0000000..a12db9b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer = new char;
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK:   {{#0 .* main .*operator_new_left_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 1 bytes to the left of 1-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK:   {{#0 .* operator new}}
+// CHECK:   {{#1 .* main .*operator_new_left_oob.cc}}:[[@LINE-8]]
+  delete buffer;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cc
new file mode 100644
index 0000000..7edee54
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer = new char;
+  buffer[1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK:   {{#0 .* main .*operator_new_right_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes to the right of 1-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK:   {{#0 .* operator new}}
+// CHECK:   {{#1 .* main .*operator_new_right_oob.cc}}:[[@LINE-8]]
+  delete buffer;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cc
new file mode 100644
index 0000000..9d5a407
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cc
@@ -0,0 +1,22 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+int main() {
+  char *buffer = new char;
+  delete buffer;
+  *buffer = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK:   {{#0 .* main .*operator_new_uaf.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 1-byte region
+// CHECK-LABEL: freed by thread T0 here:
+// CHECK:   {{#0 .* operator delete}}
+// CHECK:   {{#1 .* main .*operator_new_uaf.cc}}:[[@LINE-8]]
+// CHECK-LABEL: previously allocated by thread T0 here:
+// CHECK:   {{#0 .* operator new}}
+// CHECK:   {{#1 .* main .*operator_new_uaf.cc}}:[[@LINE-12]]
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/queue_user_work_item.cc b/compiler-rt/test/asan/TestCases/Windows/queue_user_work_item.cc
new file mode 100644
index 0000000..d99ea6f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/queue_user_work_item.cc
@@ -0,0 +1,55 @@
+// Make sure we can throw exceptions from work items executed via
+// QueueUserWorkItem.
+//
+// Clang doesn't support exceptions on Windows yet, so for the time being we
+// build this program in two parts: the code with exceptions is built with CL,
+// the rest is built with Clang.  This represents the typical scenario when we
+// build a large project using "clang-cl -fallback -fsanitize=address".
+//
+// RUN: cl -c %s -Fo%t.obj
+// RUN: %clangxx_asan -o %t.exe %s %t.obj
+// RUN: %run %t.exe 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <stdio.h>
+
+void ThrowAndCatch();
+
+#if !defined(__clang__)
+__declspec(noinline)
+void Throw() {
+  fprintf(stderr, "Throw\n");
+// CHECK: Throw
+  throw 1;
+}
+
+void ThrowAndCatch() {
+  int local;
+  try {
+    Throw();
+  } catch(...) {
+    fprintf(stderr, "Catch\n");
+// CHECK: Catch
+  }
+}
+#else
+
+HANDLE done;
+
+DWORD CALLBACK work_item(LPVOID) {
+  ThrowAndCatch();
+  SetEvent(done);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  done = CreateEvent(0, false, false, "job is done");
+  if (!done)
+    return 1;
+  QueueUserWorkItem(&work_item, nullptr, 0);
+  if (WAIT_OBJECT_0 != WaitForSingleObject(done, INFINITE))
+    return 2;
+  fprintf(stderr, "Done!\n");
+// CHECK: Done!
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Windows/queue_user_work_item_report.cc b/compiler-rt/test/asan/TestCases/Windows/queue_user_work_item_report.cc
new file mode 100644
index 0000000..f0d3d3e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/queue_user_work_item_report.cc
@@ -0,0 +1,29 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+HANDLE done;
+
+DWORD CALLBACK work_item(LPVOID) {
+  int subscript = -1;
+  volatile char stack_buffer[42];
+  stack_buffer[subscript] = 42;
+// CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T1
+// CHECK:   {{#0 .* work_item.*queue_user_work_item_report.cc}}:[[@LINE-3]]
+// CHECK: Address [[ADDR]] is located in stack of thread T1 at offset {{.*}} in frame
+// CHECK:   work_item
+  SetEvent(done);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  done = CreateEvent(0, false, false, "job is done");
+  if (!done)
+    return 1;
+// CHECK-NOT: Thread T1 created
+  QueueUserWorkItem(&work_item, nullptr, 0);
+  if (WAIT_OBJECT_0 != WaitForSingleObject(done, INFINITE))
+    return 2;
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/realloc_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/realloc_left_oob.cc
new file mode 100644
index 0000000..7d30e1d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/realloc_left_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)realloc(0, 42);
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*realloc_left_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* realloc }}
+// CHECK-NEXT: {{#1 .* main .*realloc_left_oob.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/realloc_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/realloc_right_oob.cc
new file mode 100644
index 0000000..f741390
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/realloc_right_oob.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)realloc(0, 42);
+  buffer[42] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*realloc_right_oob.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* realloc }}
+// CHECK-NEXT: {{#1 .* main .*realloc_right_oob.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/realloc_uaf.cc b/compiler-rt/test/asan/TestCases/Windows/realloc_uaf.cc
new file mode 100644
index 0000000..c5b6953
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/realloc_uaf.cc
@@ -0,0 +1,20 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)realloc(0, 42);
+  free(buffer);
+  buffer[0] = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*realloc_uaf.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 42-byte region
+// CHECK: freed by thread T0 here:
+// CHECK-NEXT: {{#0 .* free }}
+// CHECK-NEXT: {{#1 .* main .*realloc_uaf.cc}}:[[@LINE-8]]
+// CHECK: previously allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* realloc }}
+// CHECK-NEXT: {{#1 .* main .*realloc_uaf.cc}}:[[@LINE-12]]
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cc b/compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cc
new file mode 100644
index 0000000..d83d7dc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %env_asan_opts=external_symbolizer_path=asdf not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <dbghelp.h>
+
+int main() {
+  // Make sure the RTL recovers from "no options enabled" dbghelp setup.
+  SymSetOptions(0);
+
+  // Make sure the RTL recovers from "fInvadeProcess=FALSE".
+  if (!SymInitialize(GetCurrentProcess(), 0, FALSE))
+    return 42;
+
+  *(volatile int*)0 = 42;
+  // CHECK: ERROR: AddressSanitizer: access-violation on unknown address
+  // CHECK-NEXT: {{WARNING: Failed to use and restart external symbolizer}}
+  // CHECK-NEXT: {{WARNING: .*DbgHelp}}
+  // CHECK: {{#0 0x.* in main.*report_after_syminitialize.cc:}}[[@LINE-4]]
+  // CHECK: AddressSanitizer can not provide additional info.
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/report_globals_reload_dll.cc b/compiler-rt/test/asan/TestCases/Windows/report_globals_reload_dll.cc
new file mode 100644
index 0000000..4adbcc3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/report_globals_reload_dll.cc
@@ -0,0 +1,51 @@
+// Make sure we can handle reloading the same DLL multiple times.
+// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
+// RUN: %clang_cl_asan -O0 -DEXE %s -Fe%te.exe
+// RUN: %env_asan_opts=report_globals=1 %run %te.exe %t.dll 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+
+extern "C" {
+#if defined(EXE)
+int main(int argc, char **argv) {
+  if (argc != 2) {
+    printf("Usage: %s [client].dll\n", argv[0]);
+    return 101;
+  }
+  const char *dll_name = argv[1];
+
+// CHECK: time to load DLL
+  printf("time to load DLL\n");
+  fflush(0);
+
+// CHECK: in DLL(reason=1)
+// CHECK: in DLL(reason=0)
+// CHECK: in DLL(reason=1)
+// CHECK: in DLL(reason=0)
+// CHECK: in DLL(reason=1)
+// CHECK: in DLL(reason=0)
+  for (int i = 0; i < 30; ++i) {
+    HMODULE dll = LoadLibrary(dll_name);
+    if (dll == NULL)
+      return 3;
+
+    if (!FreeLibrary(dll))
+      return 4;
+  }
+
+// CHECK: All OK!
+  printf("All OK!\n");
+  fflush(0);
+}
+#elif defined(DLL)
+BOOL WINAPI DllMain(HMODULE, DWORD reason, LPVOID) {
+  printf("in DLL(reason=%d)\n", (int)reason);
+  fflush(0);
+  return TRUE;
+}
+#else
+# error oops!
+#endif
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/report_globals_vs_freelibrary.cc b/compiler-rt/test/asan/TestCases/Windows/report_globals_vs_freelibrary.cc
new file mode 100644
index 0000000..94b97f5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/report_globals_vs_freelibrary.cc
@@ -0,0 +1,47 @@
+// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
+// RUN: %clang_cl_asan -O0 -DEXE %s -Fe%te.exe
+// RUN: %env_asan_opts=report_globals=2 %run %te.exe %t.dll 2>&1 | FileCheck %s
+
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+
+extern "C" {
+#if defined(EXE)
+int main(int argc, char **argv) {
+  if (argc != 2) {
+    printf("Usage: %s [client].dll\n", argv[0]);
+    return 101;
+  }
+  const char *dll_name = argv[1];
+
+// CHECK: time to load DLL
+  printf("time to load DLL\n");
+  fflush(0);
+
+// On DLL load, the "in DLL\n" string is registered:
+// CHECK: Added Global{{.*}} size=19
+// CHECK: in DLL(reason=1)
+  HMODULE dll = LoadLibrary(dll_name);
+  if (dll == NULL)
+    return 3;
+
+// CHECK: in DLL(reason=0)
+// CHECK-NEXT: Removed Global{{.*}} size=19
+  if (!FreeLibrary(dll))
+    return 4;
+
+// CHECK: bye!
+  printf("bye!\n");
+  fflush(0);
+}
+#elif defined(DLL)
+BOOL WINAPI DllMain(HMODULE, DWORD reason, LPVOID) {
+  printf("in DLL(reason=%d)\n", (int)reason);
+  fflush(0);
+  return TRUE;
+}
+#else
+# error oops!
+#endif
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/seh.cc b/compiler-rt/test/asan/TestCases/Windows/seh.cc
new file mode 100644
index 0000000..4cb0c55
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/seh.cc
@@ -0,0 +1,58 @@
+// Make sure that ASan works with SEH in both Clang and MSVC. MSVC uses a
+// different EH personality depending on the -GS setting, so test both -GS+ and
+// -GS-.
+//
+// RUN: cl -c %s -Fo%t.obj -DCOMPILE_SEH
+// RUN: %clangxx_asan -o %t.exe %s %t.obj
+// RUN: %run %t.exe
+//
+// RUN: cl -GS- -c %s -Fo%t.obj -DCOMPILE_SEH
+// RUN: %clangxx_asan -o %t.exe %s %t.obj
+// RUN: %run %t.exe
+//
+// RUN: %clang_cl_asan %s -DCOMPILE_SEH -Fe%t.exe
+// RUN: %run %t.exe
+
+#include <windows.h>
+#include <assert.h>
+#include <stdio.h>
+
+// Should just "#include <sanitizer/asan_interface.h>" when C++ exceptions are
+// supported and we don't need to use CL.
+extern "C" bool __asan_address_is_poisoned(void *p);
+
+void ThrowAndCatch();
+
+#if defined(COMPILE_SEH)
+__declspec(noinline)
+void Throw() {
+  int local, zero = 0;
+  fprintf(stderr, "Throw:  %p\n", &local);
+  local = 5 / zero;
+}
+
+__declspec(noinline)
+void ThrowAndCatch() {
+  int local;
+  __try {
+    Throw();
+  } __except(EXCEPTION_EXECUTE_HANDLER) {
+    fprintf(stderr, "__except:  %p\n", &local);
+  }
+}
+#endif
+
+#if defined(__clang__)
+int main() {
+  char x[32];
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  ThrowAndCatch();
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  assert(!__asan_address_is_poisoned(x + 32));
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Windows/shadow_mapping_failure.cc b/compiler-rt/test/asan/TestCases/Windows/shadow_mapping_failure.cc
new file mode 100644
index 0000000..9b83947
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/shadow_mapping_failure.cc
@@ -0,0 +1,17 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+char bigchunk[1 << 30];
+
+int main() {
+  printf("Hello, world!\n");
+  scanf("%s", bigchunk);
+// CHECK-NOT: Hello, world!
+// CHECK: Shadow memory range interleaves with an existing memory mapping.
+// CHECK: ASan shadow was supposed to be located in the [0x2fff0000-0x{{.*}}ffff] range.
+// CHECK: Dumping process modules:
+// CHECK-DAG: 0x{{[0-9a-f]*}}-0x{{[0-9a-f]*}} {{.*}}shadow_mapping_failure
+// CHECK-DAG: 0x{{[0-9a-f]*}}-0x{{[0-9a-f]*}} {{.*}}ntdll.dll
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/stack_array_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/stack_array_left_oob.cc
new file mode 100644
index 0000000..845a1f3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/stack_array_left_oob.cc
@@ -0,0 +1,16 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+int main() {
+  int subscript = -1;
+  char buffer[42];
+  buffer[subscript] = 42;
+// CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cc}}:[[@LINE-3]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cc}}
+// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] underflows this variable
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/stack_array_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/stack_array_right_oob.cc
new file mode 100644
index 0000000..a370246
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/stack_array_right_oob.cc
@@ -0,0 +1,16 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+int main() {
+  int subscript = 42;
+  char buffer[42];
+  buffer[subscript] = 42;
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cc}}:[[@LINE-3]]
+// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cc}}
+// CHECK: 'buffer' <== Memory access at offset [[OFFSET]] overflows this variable
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/stack_array_sanity.cc b/compiler-rt/test/asan/TestCases/Windows/stack_array_sanity.cc
new file mode 100644
index 0000000..1aef1a9
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/stack_array_sanity.cc
@@ -0,0 +1,12 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t | FileCheck %s
+
+#include <stdio.h>
+
+int main() {
+  int subscript = 1;
+  char buffer[42];
+  buffer[subscript] = 42;
+  printf("OK\n");
+// CHECK: OK
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/stack_use_after_return.cc b/compiler-rt/test/asan/TestCases/Windows/stack_use_after_return.cc
new file mode 100644
index 0000000..9c31922
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/stack_use_after_return.cc
@@ -0,0 +1,22 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+
+char *x;
+
+void foo() {
+  char stack_buffer[42];
+  x = &stack_buffer[13];
+}
+
+int main() {
+  foo();
+  *x = 42;
+// CHECK: AddressSanitizer: stack-use-after-return
+// CHECK: WRITE of size 1 at {{.*}} thread T0
+// CHECK-NEXT: {{#0 0x.* in main .*stack_use_after_return.cc}}:[[@LINE-3]]
+//
+// CHECK: is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
+// CHECK-NEXT: {{#0 0x.* in foo.*stack_use_after_return.cc}}
+//
+// CHECK: 'stack_buffer' <== Memory access at offset [[OFFSET]] is inside this variable
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/symbols_path.cc b/compiler-rt/test/asan/TestCases/Windows/symbols_path.cc
new file mode 100644
index 0000000..81ead05
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/symbols_path.cc
@@ -0,0 +1,22 @@
+// Make sure symbolization works even if the path to the .exe file changes.
+// RUN: mkdir %t || true
+// RUN: %clang_cl_asan -O0 %s -Fe%t/symbols_path.exe
+// RUN: not %run %t/symbols_path.exe 2>&1 | FileCheck %s
+// RUN: mkdir %t2 || true
+// RUN: mv %t/* %t2
+// RUN: not %run %t2/symbols_path.exe 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)malloc(42);
+  buffer[-1] = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*symbols_path.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* malloc}}
+// CHECK-NEXT: {{#1 .* main .*symbols_path.cc}}:[[@LINE-8]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/thread_simple.cc b/compiler-rt/test/asan/TestCases/Windows/thread_simple.cc
new file mode 100644
index 0000000..14bb82f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/thread_simple.cc
@@ -0,0 +1,26 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+
+DWORD WINAPI thread_proc(void *) {
+  volatile char stack_buffer[42];
+  for (int i = 0; i < sizeof(stack_buffer); ++i)
+    stack_buffer[i] = 42;
+  return 0x42;
+}
+
+int main() {
+  DWORD exitcode;
+  HANDLE thr = CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
+  if (thr == 0)
+    return 1;
+  if (WAIT_OBJECT_0 != WaitForSingleObject(thr, INFINITE))
+    return 2;
+
+  GetExitCodeThread(thr, &exitcode);
+  if (exitcode != 0x42)
+    return 3;
+  CloseHandle(thr);
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/thread_stack_array_left_oob.cc b/compiler-rt/test/asan/TestCases/Windows/thread_stack_array_left_oob.cc
new file mode 100644
index 0000000..aac9ecf
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/thread_stack_array_left_oob.cc
@@ -0,0 +1,27 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+DWORD WINAPI thread_proc(void *) {
+  int subscript = -1;
+  volatile char stack_buffer[42];
+  stack_buffer[subscript] = 42;
+// CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T1
+// CHECK:   {{#0 .* thread_proc.*thread_stack_array_left_oob.cc}}:[[@LINE-3]]
+// CHECK: Address [[ADDR]] is located in stack of thread T1 at offset {{.*}} in frame
+// CHECK:   thread_proc
+  return 0;
+}
+
+int main() {
+  HANDLE thr = CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
+// CHECK: Thread T1 created by T0 here:
+// CHECK:   {{#[01] .* main .*thread_stack_array_left_oob.cc}}:[[@LINE-2]]
+
+  // A failure to create a thread should fail the test!
+  if (thr == 0) return 0;
+
+  WaitForSingleObject(thr, INFINITE);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/thread_stack_array_right_oob.cc b/compiler-rt/test/asan/TestCases/Windows/thread_stack_array_right_oob.cc
new file mode 100644
index 0000000..2982e48
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/thread_stack_array_right_oob.cc
@@ -0,0 +1,27 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <windows.h>
+
+DWORD WINAPI thread_proc(void *) {
+  int subscript = 42;
+  volatile char stack_buffer[42];
+  stack_buffer[subscript] = 42;
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T1
+// CHECK:   {{#0 .* thread_proc.*thread_stack_array_right_oob.cc}}:[[@LINE-3]]
+// CHECK: Address [[ADDR]] is located in stack of thread T1 at offset {{.*}} in frame
+// CHECK:   thread_proc
+  return 0;
+}
+
+int main(void) {
+  HANDLE thr = CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
+// CHECK: Thread T1 created by T0 here:
+// CHECK:   {{#[01] .* main .*thread_stack_array_right_oob.cc}}:[[@LINE-2]]
+
+  // A failure to create a thread should fail the test!
+  if (thr == 0) return 0;
+
+  WaitForSingleObject(thr, INFINITE);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/thread_stack_reuse.cc b/compiler-rt/test/asan/TestCases/Windows/thread_stack_reuse.cc
new file mode 100644
index 0000000..7da3a80
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/thread_stack_reuse.cc
@@ -0,0 +1,37 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+
+DWORD WINAPI thread_proc_1(void *) {
+  volatile int x, y, z;
+  x = 1;
+  y = 2;
+  z = 3;
+  return 0;
+}
+
+DWORD WINAPI thread_proc_2(void *) {
+  volatile char stack_buffer[42];
+  for (int i = 0; i < sizeof(stack_buffer); ++i)
+    stack_buffer[i] = 42;
+  return 0;
+}
+
+int main(void) {
+  HANDLE thr = NULL;
+
+  thr = CreateThread(NULL, 0, thread_proc_1, NULL, 0, NULL);
+  if (thr == 0)
+    return 1;
+  if (WAIT_OBJECT_0 != WaitForSingleObject(thr, INFINITE))
+    return 2;
+
+  thr = CreateThread(NULL, 0, thread_proc_2, NULL, 0, NULL);
+  if (thr == 0)
+    return 3;
+  if (WAIT_OBJECT_0 != WaitForSingleObject(thr, INFINITE))
+    return 4;
+  CloseHandle(thr);
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/thread_stress.cc b/compiler-rt/test/asan/TestCases/Windows/thread_stress.cc
new file mode 100644
index 0000000..74be8d8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/thread_stress.cc
@@ -0,0 +1,30 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+
+DWORD WINAPI thread_proc(void *) {
+  volatile char stack_buffer[42];
+  for (int i = 0; i < sizeof(stack_buffer); ++i)
+    stack_buffer[i] = 42;
+  return 0;
+}
+
+int main(void) {
+  for (int iter = 0; iter < 1024; ++iter) {
+    const int NUM_THREADS = 8;
+    HANDLE thr[NUM_THREADS];
+    for (int i = 0; i < NUM_THREADS; ++i) {
+      thr[i] = CreateThread(NULL, 0, thread_proc, NULL, 0, NULL);
+      if (thr[i] == 0)
+        return 1;
+    }
+    for (int i = 0; i < NUM_THREADS; ++i) {
+      if (WAIT_OBJECT_0 != WaitForSingleObject(thr[i], INFINITE))
+        return 2;
+      CloseHandle(thr[i]);
+    }
+  }
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/thread_suspended.cc b/compiler-rt/test/asan/TestCases/Windows/thread_suspended.cc
new file mode 100644
index 0000000..47e4f9d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/thread_suspended.cc
@@ -0,0 +1,27 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+#include <windows.h>
+
+DWORD WINAPI thread_proc(void *) {
+  volatile char stack_buffer[42];
+  for (int i = 0; i < sizeof(stack_buffer); ++i)
+    stack_buffer[i] = 42;
+  return 0x42;
+}
+
+int main() {
+  DWORD exitcode;
+  HANDLE thr = CreateThread(NULL, 0, thread_proc, NULL, CREATE_SUSPENDED, NULL);
+  ResumeThread(thr);
+  if (thr == 0)
+    return 1;
+  if (WAIT_OBJECT_0 != WaitForSingleObject(thr, INFINITE))
+    return 2;
+
+  GetExitCodeThread(thr, &exitcode);
+  if (exitcode != 0x42)
+    return 3;
+  CloseHandle(thr);
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/throw_catch.cc b/compiler-rt/test/asan/TestCases/Windows/throw_catch.cc
new file mode 100644
index 0000000..5313d25
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/throw_catch.cc
@@ -0,0 +1,73 @@
+// Clang doesn't support exceptions on Windows yet, so for the time being we
+// build this program in two parts: the code with exceptions is built with CL,
+// the rest is built with Clang.  This represents the typical scenario when we
+// build a large project using "clang-cl -fallback -fsanitize=address".
+//
+// RUN: cl -c %s -Fo%t.obj
+// RUN: %clangxx_asan -o %t.exe %s %t.obj
+// RUN: %run %t.exe
+
+#include <assert.h>
+#include <stdio.h>
+
+// Should just "#include <sanitizer/asan_interface.h>" when C++ exceptions are
+// supported and we don't need to use CL.
+extern "C" bool __asan_address_is_poisoned(void *p);
+
+void ThrowAndCatch();
+void TestThrowInline();
+
+#if !defined(__clang__)
+__declspec(noinline)
+void Throw() {
+  int local;
+  fprintf(stderr, "Throw:  %p\n", &local);
+  throw 1;
+}
+
+__declspec(noinline)
+void ThrowAndCatch() {
+  int local;
+  try {
+    Throw();
+  } catch(...) {
+    fprintf(stderr, "Catch:  %p\n", &local);
+  }
+}
+
+void TestThrowInline() {
+  char x[32];
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  try {
+    Throw();
+  } catch(...) {
+    fprintf(stderr, "Catch\n");
+  }
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  assert(!__asan_address_is_poisoned(x + 32));
+}
+
+#else
+
+void TestThrow() {
+  char x[32];
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  ThrowAndCatch();
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  assert(!__asan_address_is_poisoned(x + 32));
+}
+
+int main(int argc, char **argv) {
+  TestThrowInline();
+  TestThrow();
+}
+#endif
diff --git a/compiler-rt/test/asan/TestCases/Windows/unsymbolized.cc b/compiler-rt/test/asan/TestCases/Windows/unsymbolized.cc
new file mode 100644
index 0000000..e44b4bb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/unsymbolized.cc
@@ -0,0 +1,25 @@
+// When we link a binary without the -debug flag, ASan should print out VAs
+// instead of RVAs. The frames for main and do_uaf should be above 0x400000,
+// which is the default image base of an executable.
+
+// RUN: rm -f %t.pdb
+// RUN: %clangxx_asan -c -O2 %s -o %t.obj
+// RUN: link /nologo /OUT:%t.exe %t.obj %asan_lib %asan_cxx_lib
+// RUN: not %run %t.exe 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+#include <stdio.h>
+int __attribute__((noinline)) do_uaf(void);
+int main() {
+  int r = do_uaf();
+  printf("r: %d\n", r);
+  return r;
+}
+int do_uaf(void) {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: AddressSanitizer: heap-use-after-free
+  // CHECK: #0 {{0x[a-f0-9]+ \(.*[\\/]unsymbolized.cc.*.exe\+0x40[a-f0-9]{4}\)}}
+  // CHECK: #1 {{0x[a-f0-9]+ \(.*[\\/]unsymbolized.cc.*.exe\+0x40[a-f0-9]{4}\)}}
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/use_after_realloc.cc b/compiler-rt/test/asan/TestCases/Windows/use_after_realloc.cc
new file mode 100644
index 0000000..9d2c025
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/use_after_realloc.cc
@@ -0,0 +1,23 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <malloc.h>
+
+int main() {
+  char *buffer = (char*)realloc(0, 32),
+       *stale = buffer;
+  buffer = (char*)realloc(buffer, 64);
+  // The 'stale' may now point to a free'd memory.
+  stale[0] = 42;
+// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+// CHECK-NEXT: {{#0 .* main .*use_after_realloc.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes inside of 32-byte region
+// CHECK: freed by thread T0 here:
+// CHECK-NEXT: {{#0 .* realloc }}
+// CHECK-NEXT: {{#1 .* main .*use_after_realloc.cc}}:[[@LINE-9]]
+// CHECK: previously allocated by thread T0 here:
+// CHECK-NEXT: {{#0 .* realloc }}
+// CHECK-NEXT: {{#1 .* main .*use_after_realloc.cc}}:[[@LINE-14]]
+  free(buffer);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/use_after_return_linkage.cc b/compiler-rt/test/asan/TestCases/Windows/use_after_return_linkage.cc
new file mode 100644
index 0000000..48c5065
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/use_after_return_linkage.cc
@@ -0,0 +1,12 @@
+// Make sure LIBCMT doesn't accidentally get added to the list of DEFAULTLIB
+// directives.  REQUIRES: asan-dynamic-runtime
+// RUN: %clang_cl_asan -LD %s | FileCheck %s
+// CHECK: Creating library
+// CHECK-NOT: LIBCMT
+
+void foo(int *p) { *p = 42; }
+
+__declspec(dllexport) void bar() {
+  int x;
+  foo(&x);
+}
diff --git a/compiler-rt/test/asan/TestCases/Windows/windows_h.cc b/compiler-rt/test/asan/TestCases/Windows/windows_h.cc
new file mode 100644
index 0000000..40cf5a1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/windows_h.cc
@@ -0,0 +1,7 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: %run %t
+
+// Just make sure we can parse <windows.h>
+#include <windows.h>
+
+int main() {}
diff --git a/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cc b/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cc
new file mode 100644
index 0000000..112dd53
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cc
@@ -0,0 +1,26 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+class Parent {
+ public:
+  int field;
+};
+
+class Child : public Parent {
+ public:
+  int extra_field;
+};
+
+int main(void) {
+  Parent *p = new Parent;
+  Child *c = (Child*)p;  // Intentional error here!
+  c->extra_field = 42;
+// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK:   {{#0 0x[0-9a-f]* in main .*wrong_downcast_on_heap.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located 0 bytes to the right of 4-byte region
+// CHECK: allocated by thread T0 here:
+// CHECK:   #0 {{.*}} operator new
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_stack.cc b/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_stack.cc
new file mode 100644
index 0000000..2859ecc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_stack.cc
@@ -0,0 +1,26 @@
+// RUN: %clang_cl_asan -O0 %s -Fe%t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+class Parent {
+ public:
+  int field;
+};
+
+class Child : public Parent {
+ public:
+  int extra_field;
+};
+
+int main(void) {
+  Parent p;
+  Child *c = (Child*)&p;  // Intentional error here!
+  c->extra_field = 42;
+// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+// CHECK-NEXT:  {{#0 0x[0-9a-f]* in main .*wrong_downcast_on_stack.cc}}:[[@LINE-3]]
+// CHECK: [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:[0-9]+]] in frame
+// CHECK-NEXT:  {{#0 0x[0-9a-f]* in main }}
+// CHECK:  'p' <== Memory access at offset [[OFFSET]] overflows this variable
+  return 0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/alloca_big_alignment.cc b/compiler-rt/test/asan/TestCases/alloca_big_alignment.cc
new file mode 100644
index 0000000..2ede3f9
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_big_alignment.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+
+#include <assert.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile char str[len] __attribute__((aligned(128)));
+  assert(!(reinterpret_cast<long>(str) & 127L));
+  str[index] = '1'; // BOOM
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}
+
+int main(int argc, char **argv) {
+  foo(10, 10);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_detect_custom_size_.cc b/compiler-rt/test/asan/TestCases/alloca_detect_custom_size_.cc
new file mode 100644
index 0000000..2b0f573
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_detect_custom_size_.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+
+#include <assert.h>
+
+struct A {
+  char a[3];
+  int b[3];
+};
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile struct A str[len] __attribute__((aligned(32)));
+  assert(!(reinterpret_cast<long>(str) & 31L));
+  str[index].a[0] = '1'; // BOOM
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}
+
+int main(int argc, char **argv) {
+  foo(10, 10);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_instruments_all_paddings.cc b/compiler-rt/test/asan/TestCases/alloca_instruments_all_paddings.cc
new file mode 100644
index 0000000..e2c7faf
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_instruments_all_paddings.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: %clangxx_asan -O3 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: %run %t 2>&1
+//
+
+#include "sanitizer/asan_interface.h"
+#include <assert.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile char str[len] __attribute__((aligned(32)));
+  assert(!(reinterpret_cast<long>(str) & 31L));
+  char *q = (char *)__asan_region_is_poisoned((char *)str, 64);
+  assert(q && ((q - str) == index));
+}
+
+int main(int argc, char **argv) {
+  for (int i = 1; i < 33; ++i)
+    foo(i, i);
+
+  for (int i = 1; i < 33; ++i)
+    foo(i, i);
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_loop_unpoisoning.cc b/compiler-rt/test/asan/TestCases/alloca_loop_unpoisoning.cc
new file mode 100644
index 0000000..5392792
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_loop_unpoisoning.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: %run %t 2>&1
+//
+// REQUIRES: stable-runtime
+
+// This testcase checks that allocas and VLAs inside loop are correctly unpoisoned.
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "sanitizer/asan_interface.h"
+
+// MSVC provides _alloca instead of alloca.
+#if defined(_MSC_VER) && !defined(alloca)
+# define alloca _alloca
+#endif
+
+void *top, *bot;
+
+__attribute__((noinline)) void foo(int len) {
+  char x;
+  top = &x;
+  char array[len];  // NOLINT
+  assert(!(reinterpret_cast<uintptr_t>(array) & 31L));
+  alloca(len);
+  for (int i = 0; i < 32; ++i) {
+    char array[i];  // NOLINT
+    bot = alloca(i);
+    assert(!(reinterpret_cast<uintptr_t>(bot) & 31L));
+  }
+}
+
+int main(int argc, char **argv) {
+  foo(32);
+  void *q = __asan_region_is_poisoned(bot, (char *)top - (char *)bot);
+  assert(!q);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_overflow_partial.cc b/compiler-rt/test/asan/TestCases/alloca_overflow_partial.cc
new file mode 100644
index 0000000..590f354
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_overflow_partial.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+
+#include <assert.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile char str[len] __attribute__((aligned(32)));
+  assert(!(reinterpret_cast<long>(str) & 31L));
+  str[index] = '1'; // BOOM
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}
+
+int main(int argc, char **argv) {
+  foo(10, 10);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_overflow_right.cc b/compiler-rt/test/asan/TestCases/alloca_overflow_right.cc
new file mode 100644
index 0000000..caec846
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_overflow_right.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+
+#include <assert.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile char str[len] __attribute__((aligned(32)));
+  assert(!(reinterpret_cast<long>(str) & 31L));
+  str[index] = '1'; // BOOM
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}
+
+int main(int argc, char **argv) {
+  foo(33, 10);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_safe_access.cc b/compiler-rt/test/asan/TestCases/alloca_safe_access.cc
new file mode 100644
index 0000000..240454f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_safe_access.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: %run %t 2>&1
+//
+
+#include <assert.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile char str[len] __attribute__((aligned(32)));
+  assert(!(reinterpret_cast<long>(str) & 31L));
+  str[index] = '1';
+}
+
+int main(int argc, char **argv) {
+  foo(4, 5);
+  foo(39, 40);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_underflow_left.cc b/compiler-rt/test/asan/TestCases/alloca_underflow_left.cc
new file mode 100644
index 0000000..6e7061f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_underflow_left.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+
+#include <assert.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  volatile char str[len] __attribute__((aligned(32)));
+  assert(!(reinterpret_cast<long>(str) & 31L));
+  str[index] = '1'; // BOOM
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+}
+
+int main(int argc, char **argv) {
+  foo(-1, 10);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/alloca_vla_interact.cc b/compiler-rt/test/asan/TestCases/alloca_vla_interact.cc
new file mode 100644
index 0000000..3873c3f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/alloca_vla_interact.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: %run %t 2>&1
+//
+// REQUIRES: stable-runtime
+
+// This testcase checks correct interaction between VLAs and allocas.
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "sanitizer/asan_interface.h"
+
+// MSVC provides _alloca instead of alloca.
+#if defined(_MSC_VER) && !defined(alloca)
+# define alloca _alloca
+#endif
+
+#define RZ 32
+
+__attribute__((noinline)) void foo(int len) {
+  char *top, *bot;
+  // This alloca call should live until the end of foo.
+  char *alloca1 = (char *)alloca(len);
+  assert(!(reinterpret_cast<uintptr_t>(alloca1) & 31L));
+  // This should be first poisoned address after loop.
+  top = alloca1 - RZ;
+  for (int i = 0; i < 32; ++i) {
+    // Check that previous alloca was unpoisoned at the end of iteration.
+    if (i) assert(!__asan_region_is_poisoned(bot, 96));
+    // VLA is unpoisoned at the end of iteration.
+    volatile char array[i];
+    assert(!(reinterpret_cast<uintptr_t>(array) & 31L));
+    // Alloca is unpoisoned at the end of iteration,
+    // because dominated by VLA.
+    bot = (char *)alloca(i) - RZ;
+  }
+  // Check that all allocas from loop were unpoisoned correctly.
+  void *q = __asan_region_is_poisoned(bot, (char *)top - (char *)bot + 1);
+  assert(q == top);
+}
+
+int main(int argc, char **argv) {
+  foo(32);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/allocator_returns_null.cc b/compiler-rt/test/asan/TestCases/allocator_returns_null.cc
new file mode 100644
index 0000000..cdfcd90
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/allocator_returns_null.cc
@@ -0,0 +1,86 @@
+// Test the behavior of malloc/calloc/realloc when the allocation size is huge.
+// By default (allocator_may_return_null=0) the process should crash.
+// With allocator_may_return_null=1 the allocator should return 0.
+//
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: %env_asan_opts=allocator_may_return_null=1     %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL
+// RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
+// RUN: %env_asan_opts=allocator_may_return_null=1     %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL
+// RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
+// RUN: %env_asan_opts=allocator_may_return_null=1     %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL
+// RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
+// RUN: %env_asan_opts=allocator_may_return_null=1     %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL
+// RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
+// RUN: %env_asan_opts=allocator_may_return_null=1     %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrNULL
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <limits>
+int main(int argc, char **argv) {
+  // Disable stderr buffering. Needed on Windows.
+  setvbuf(stderr, NULL, _IONBF, 0);
+
+  volatile size_t size = std::numeric_limits<size_t>::max() - 10000;
+  assert(argc == 2);
+  void *x = 0;
+  if (!strcmp(argv[1], "malloc")) {
+    fprintf(stderr, "malloc:\n");
+    x = malloc(size);
+  }
+  if (!strcmp(argv[1], "calloc")) {
+    fprintf(stderr, "calloc:\n");
+    x = calloc(size / 4, 4);
+  }
+
+  if (!strcmp(argv[1], "calloc-overflow")) {
+    fprintf(stderr, "calloc-overflow:\n");
+    volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max();
+    size_t kArraySize = 4096;
+    volatile size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
+    x = calloc(kArraySize, kArraySize2);
+  }
+
+  if (!strcmp(argv[1], "realloc")) {
+    fprintf(stderr, "realloc:\n");
+    x = realloc(0, size);
+  }
+  if (!strcmp(argv[1], "realloc-after-malloc")) {
+    fprintf(stderr, "realloc-after-malloc:\n");
+    char *t = (char*)malloc(100);
+    *t = 42;
+    x = realloc(t, size);
+    assert(*t == 42);
+    free(t);
+  }
+  // The NULL pointer is printed differently on different systems, while (long)0
+  // is always the same.
+  fprintf(stderr, "x: %lx\n", (long)x);
+  free(x);
+  return x != 0;
+}
+// CHECK-mCRASH: malloc:
+// CHECK-mCRASH: AddressSanitizer's allocator is terminating the process
+// CHECK-cCRASH: calloc:
+// CHECK-cCRASH: AddressSanitizer's allocator is terminating the process
+// CHECK-coCRASH: calloc-overflow:
+// CHECK-coCRASH: AddressSanitizer's allocator is terminating the process
+// CHECK-rCRASH: realloc:
+// CHECK-rCRASH: AddressSanitizer's allocator is terminating the process
+// CHECK-mrCRASH: realloc-after-malloc:
+// CHECK-mrCRASH: AddressSanitizer's allocator is terminating the process
+
+// CHECK-mNULL: malloc:
+// CHECK-mNULL: x: 0
+// CHECK-cNULL: calloc:
+// CHECK-cNULL: x: 0
+// CHECK-coNULL: calloc-overflow:
+// CHECK-coNULL: x: 0
+// CHECK-rNULL: realloc:
+// CHECK-rNULL: x: 0
+// CHECK-mrNULL: realloc-after-malloc:
+// CHECK-mrNULL: x: 0
diff --git a/compiler-rt/test/asan/TestCases/asan_and_llvm_coverage_test.cc b/compiler-rt/test/asan/TestCases/asan_and_llvm_coverage_test.cc
new file mode 100644
index 0000000..4748481
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/asan_and_llvm_coverage_test.cc
@@ -0,0 +1,10 @@
+// RUN: %clangxx_asan -coverage -O0 %s -o %t
+// RUN: %env_asan_opts=check_initialization_order=1 %run %t 2>&1 | FileCheck %s
+// XFAIL: android,win32
+#include <stdio.h>
+int foo() { return 1; }
+int XXX = foo();
+int main() {
+  printf("PASS\n");
+// CHECK: PASS
+}
diff --git a/compiler-rt/test/asan/TestCases/asan_options-help.cc b/compiler-rt/test/asan/TestCases/asan_options-help.cc
new file mode 100644
index 0000000..96a9cd9
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/asan_options-help.cc
@@ -0,0 +1,9 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %env_asan_opts=help=1 %run %t 2>&1 | FileCheck %s
+
+int main() {
+}
+
+// CHECK: Available flags for AddressSanitizer:
+// CHECK-DAG: handle_segv
+// CHECK-DAG: check_initialization_order
diff --git a/compiler-rt/test/asan/TestCases/atexit_stats.cc b/compiler-rt/test/asan/TestCases/atexit_stats.cc
new file mode 100644
index 0000000..42a3fbf
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/atexit_stats.cc
@@ -0,0 +1,18 @@
+// Make sure we report atexit stats.
+// RUN: %clangxx_asan -O3 %s -o %t
+// RUN: %env_asan_opts=atexit=1:print_stats=1 %run %t 2>&1 | FileCheck %s
+//
+// No atexit output on Android due to
+// https://code.google.com/p/address-sanitizer/issues/detail?id=263
+// XFAIL: android
+
+#include <stdlib.h>
+#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#include <malloc.h>
+#endif
+int *p1 = (int*)malloc(900);
+int *p2 = (int*)malloc(90000);
+int *p3 = (int*)malloc(9000000);
+int main() { }
+
+// CHECK: AddressSanitizer exit stats:
diff --git a/compiler-rt/test/asan/TestCases/atoi_strict.c b/compiler-rt/test/asan/TestCases/atoi_strict.c
new file mode 100644
index 0000000..6081b2c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/atoi_strict.c
@@ -0,0 +1,55 @@
+// Test strict_string_checks option in atoi function
+// RUN: %clang_asan %s -o %t
+// RUN: %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1(char *array) {
+  // Last symbol is non-digit
+  memset(array, '1', 10);
+  array[9] = 'a';
+  int r = atoi(array);
+  assert(r == 111111111);
+}
+
+void test2(char *array) {
+  // Single non-digit symbol
+  array[9] = 'a';
+  int r = atoi(array + 9);
+  assert(r == 0);
+}
+
+void test3(char *array) {
+  // Incorrect number format
+  memset(array, ' ', 10);
+  array[9] = '-';
+  array[8] = '-';
+  int r = atoi(array);
+  assert(r == 0);
+}
+
+int main(int argc, char **argv) {
+  char *array = (char*)malloc(10);
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(array);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1: READ of size 11
+  if (!strcmp(argv[1], "test2")) test2(array);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2: READ of size 2
+  if (!strcmp(argv[1], "test3")) test3(array);
+  // CHECK3: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK3: READ of size 11
+  free(array);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/atol_strict.c b/compiler-rt/test/asan/TestCases/atol_strict.c
new file mode 100644
index 0000000..40d0524
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/atol_strict.c
@@ -0,0 +1,55 @@
+// Test strict_string_checks option in atol function
+// RUN: %clang_asan %s -o %t
+// RUN: %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1(char *array) {
+  // Last symbol is non-digit
+  memset(array, '1', 10);
+  array[9] = 'a';
+  long r = atol(array);
+  assert(r == 111111111);
+}
+
+void test2(char *array) {
+  // Single non-digit symbol
+  array[9] = 'a';
+  long r = atol(array + 9);
+  assert(r == 0);
+}
+
+void test3(char *array) {
+  // Incorrect number format
+  memset(array, ' ', 10);
+  array[9] = '-';
+  array[8] = '-';
+  long r = atol(array);
+  assert(r == 0);
+}
+
+int main(int argc, char **argv) {
+  char *array = (char*)malloc(10);
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(array);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1: READ of size 11
+  if (!strcmp(argv[1], "test2")) test2(array);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2: READ of size 2
+  if (!strcmp(argv[1], "test3")) test3(array);
+  // CHECK3: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK3: READ of size 11
+  free(array);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/atoll_strict.c b/compiler-rt/test/asan/TestCases/atoll_strict.c
new file mode 100644
index 0000000..2b02354
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/atoll_strict.c
@@ -0,0 +1,58 @@
+// Test strict_string_checks option in atoll function
+// RUN: %clang_asan %s -o %t
+// RUN: %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
+
+// FIXME: Needs Windows interceptor.
+// XFAIL: win32
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1(char *array) {
+  // Last symbol is non-digit
+  memset(array, '1', 10);
+  array[9] = 'a';
+  long long r = atoll(array);
+  assert(r == 111111111);
+}
+
+void test2(char *array) {
+  // Single non-digit symbol
+  array[9] = 'a';
+  long long r = atoll(array + 9);
+  assert(r == 0);
+}
+
+void test3(char *array) {
+  // Incorrect number format
+  memset(array, ' ', 10);
+  array[9] = '-';
+  array[8] = '-';
+  long long r = atoll(array);
+  assert(r == 0);
+}
+
+int main(int argc, char **argv) {
+  char *array = (char*)malloc(10);
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(array);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1: READ of size 11
+  if (!strcmp(argv[1], "test2")) test2(array);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2: READ of size 2
+  if (!strcmp(argv[1], "test3")) test3(array);
+  // CHECK3: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK3: READ of size 11
+  free(array);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/blacklist.cc b/compiler-rt/test/asan/TestCases/blacklist.cc
new file mode 100644
index 0000000..7c31484
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/blacklist.cc
@@ -0,0 +1,38 @@
+// Test the blacklist functionality of ASan
+
+// RUN: echo "fun:*brokenFunction*" > %tmp
+// RUN: echo "global:*badGlobal*" >> %tmp
+// RUN: echo "src:*blacklist-extra.cc" >> %tmp
+// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O0 %s -o %t \
+// RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
+// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O1 %s -o %t \
+// RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
+// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O2 %s -o %t \
+// RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
+// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O3 %s -o %t \
+// RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
+
+// badGlobal is accessed improperly, but we blacklisted it. Align
+// it to make sure memory past the end of badGlobal will be in
+// the same page.
+__attribute__((aligned(16))) int badGlobal;
+int readBadGlobal() {
+  return (&badGlobal)[1];
+}
+
+// A function which is broken, but excluded in the blacklist.
+int brokenFunction(int argc) {
+  char x[10] = {0};
+  return x[argc * 10];  // BOOM
+}
+
+// This function is defined in Helpers/blacklist-extra.cc, a source file which
+// is blacklisted by name
+int externalBrokenFunction(int x);
+
+int main(int argc, char **argv) {
+  brokenFunction(argc);
+  int x = readBadGlobal();
+  externalBrokenFunction(argc);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/contiguous_container.cc b/compiler-rt/test/asan/TestCases/contiguous_container.cc
new file mode 100644
index 0000000..3f75456
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/contiguous_container.cc
@@ -0,0 +1,83 @@
+// RUN: %clangxx_asan -fexceptions -O %s -o %t && %run %t
+//
+// Test __sanitizer_annotate_contiguous_container.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <sanitizer/asan_interface.h>
+
+void TestContainer(size_t capacity) {
+  char *beg = new char[capacity];
+  char *end = beg + capacity;
+  char *mid = beg + capacity;
+  char *old_mid = 0;
+
+  for (int i = 0; i < 10000; i++) {
+    size_t size = rand() % (capacity + 1);
+    assert(size <= capacity);
+    old_mid = mid;
+    mid = beg + size;
+    __sanitizer_annotate_contiguous_container(beg, end, old_mid, mid);
+
+    for (size_t idx = 0; idx < size; idx++)
+        assert(!__asan_address_is_poisoned(beg + idx));
+    for (size_t idx = size; idx < capacity; idx++)
+        assert(__asan_address_is_poisoned(beg + idx));
+    assert(__sanitizer_verify_contiguous_container(beg, mid, end));
+    assert(NULL ==
+           __sanitizer_contiguous_container_find_bad_address(beg, mid, end));
+    if (mid != beg) {
+      assert(!__sanitizer_verify_contiguous_container(beg, mid - 1, end));
+      assert(mid - 1 == __sanitizer_contiguous_container_find_bad_address(
+                            beg, mid - 1, end));
+    }
+    if (mid != end) {
+      assert(!__sanitizer_verify_contiguous_container(beg, mid + 1, end));
+      assert(mid == __sanitizer_contiguous_container_find_bad_address(
+                        beg, mid + 1, end));
+    }
+  }
+
+  // Don't forget to unpoison the whole thing before destroing/reallocating.
+  __sanitizer_annotate_contiguous_container(beg, end, mid, end);
+  for (size_t idx = 0; idx < capacity; idx++)
+    assert(!__asan_address_is_poisoned(beg + idx));
+  delete[] beg;
+}
+
+__attribute__((noinline))
+void Throw() { throw 1; }
+
+__attribute__((noinline))
+void ThrowAndCatch() {
+  try {
+    Throw();
+  } catch(...) {
+  }
+}
+
+void TestThrow() {
+  char x[32];
+  __sanitizer_annotate_contiguous_container(x, x + 32, x + 32, x + 14);
+  assert(!__asan_address_is_poisoned(x + 13));
+  assert(__asan_address_is_poisoned(x + 14));
+  ThrowAndCatch();
+  assert(!__asan_address_is_poisoned(x + 13));
+  // FIXME: invert the assertion below once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  // This assertion works only w/o UAR.
+  if (!__asan_get_current_fake_stack())
+    assert(!__asan_address_is_poisoned(x + 14));
+  __sanitizer_annotate_contiguous_container(x, x + 32, x + 14, x + 32);
+  assert(!__asan_address_is_poisoned(x + 13));
+  assert(!__asan_address_is_poisoned(x + 14));
+}
+
+int main(int argc, char **argv) {
+  int n = argc == 1 ? 128 : atoi(argv[1]);
+  for (int i = 0; i <= n; i++)
+    TestContainer(i);
+  TestThrow();
+}
diff --git a/compiler-rt/test/asan/TestCases/contiguous_container_crash.cc b/compiler-rt/test/asan/TestCases/contiguous_container_crash.cc
new file mode 100644
index 0000000..5b999c0
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/contiguous_container_crash.cc
@@ -0,0 +1,52 @@
+// RUN: %clangxx_asan -O %s -o %t
+// RUN: not %run %t crash 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+// RUN: not %run %t bad-bounds 2>&1 | FileCheck --check-prefix=CHECK-BAD-BOUNDS %s
+// RUN: not %run %t bad-alignment 2>&1 | FileCheck --check-prefix=CHECK-BAD-ALIGNMENT %s
+// RUN: %env_asan_opts=detect_container_overflow=0 %run %t crash
+//
+// Test crash due to __sanitizer_annotate_contiguous_container.
+
+#include <assert.h>
+#include <string.h>
+
+extern "C" {
+void __sanitizer_annotate_contiguous_container(const void *beg, const void *end,
+                                               const void *old_mid,
+                                               const void *new_mid);
+}  // extern "C"
+
+static volatile int one = 1;
+
+int TestCrash() {
+  long t[100];
+  t[60] = 0;
+  __sanitizer_annotate_contiguous_container(&t[0], &t[0] + 100, &t[0] + 100,
+                                            &t[0] + 50);
+// CHECK-CRASH: AddressSanitizer: container-overflow
+  return (int)t[60 * one];  // Touches the poisoned memory.
+}
+
+void BadBounds() {
+  long t[100];
+// CHECK-BAD-BOUNDS: ERROR: AddressSanitizer: bad parameters to __sanitizer_annotate_contiguous_container
+  __sanitizer_annotate_contiguous_container(&t[0], &t[0] + 100, &t[0] + 101,
+                                            &t[0] + 50);
+}
+
+void BadAlignment() {
+  int t[100];
+// CHECK-BAD-ALIGNMENT: ERROR: AddressSanitizer: bad parameters to __sanitizer_annotate_contiguous_container
+// CHECK-BAD-ALIGNMENT: ERROR: beg is not aligned by 8
+  __sanitizer_annotate_contiguous_container(&t[1], &t[0] + 100, &t[1] + 10,
+                                            &t[0] + 50);
+}
+
+int main(int argc, char **argv) {
+  assert(argc == 2);
+  if (!strcmp(argv[1], "crash"))
+    return TestCrash();
+  else if (!strcmp(argv[1], "bad-bounds"))
+    BadBounds();
+  else if (!strcmp(argv[1], "bad-alignment"))
+    BadAlignment();
+}
diff --git a/compiler-rt/test/asan/TestCases/coverage-and-lsan.cc b/compiler-rt/test/asan/TestCases/coverage-and-lsan.cc
new file mode 100644
index 0000000..081f493
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-and-lsan.cc
@@ -0,0 +1,20 @@
+// Make sure coverage is dumped even if there are reported leaks.
+//
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+//
+// RUN: rm -rf %T/coverage-and-lsan
+//
+// RUN: mkdir -p %T/coverage-and-lsan/normal
+// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-and-lsan:verbosity=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %sancov print %T/coverage-and-lsan/*.sancov 2>&1
+//
+// REQUIRES: leak-detection
+
+int *g = new int;
+int main(int argc, char **argv) {
+  g = 0;
+  return 0;
+}
+
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: CovDump:
diff --git a/compiler-rt/test/asan/TestCases/coverage-caller-callee-total-count.cc b/compiler-rt/test/asan/TestCases/coverage-caller-callee-total-count.cc
new file mode 100644
index 0000000..955ffe5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-caller-callee-total-count.cc
@@ -0,0 +1,42 @@
+// Test __sanitizer_get_total_unique_coverage for caller-callee coverage
+
+// RUN: %clangxx_asan -fsanitize-coverage=edge,indirect-calls %s -o %t
+// RUN: %env_asan_opts=coverage=1 %run %t
+// RUN: rm -f caller-callee*.sancov
+//
+// REQUIRES: asan-64-bits
+
+#include <sanitizer/coverage_interface.h>
+#include <stdio.h>
+#include <assert.h>
+int P = 0;
+struct Foo {virtual void f() {if (P) printf("Foo::f()\n");}};
+struct Foo1 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+struct Foo2 : Foo {virtual void f() {if (P) printf("%d\n", __LINE__);}};
+
+Foo *foo[3] = {new Foo, new Foo1, new Foo2};
+
+uintptr_t CheckNewTotalUniqueCoverageIsLargerAndReturnIt(uintptr_t old_total) {
+  uintptr_t new_total = __sanitizer_get_total_unique_caller_callee_pairs();
+  fprintf(stderr, "Caller-Callee: old %zd new %zd\n", old_total, new_total);
+  assert(new_total > old_total);
+  return new_total;
+}
+
+int main(int argc, char **argv) {
+  uintptr_t total = __sanitizer_get_total_unique_caller_callee_pairs();
+  foo[0]->f();
+  total = CheckNewTotalUniqueCoverageIsLargerAndReturnIt(total);
+  foo[1]->f();
+  total = CheckNewTotalUniqueCoverageIsLargerAndReturnIt(total);
+  foo[2]->f();
+  total = CheckNewTotalUniqueCoverageIsLargerAndReturnIt(total);
+  // Ok, called every function once.
+  // Now call them again from another call site. Should get new coverage.
+  foo[0]->f();
+  total = CheckNewTotalUniqueCoverageIsLargerAndReturnIt(total);
+  foo[1]->f();
+  total = CheckNewTotalUniqueCoverageIsLargerAndReturnIt(total);
+  foo[2]->f();
+  total = CheckNewTotalUniqueCoverageIsLargerAndReturnIt(total);
+}
diff --git a/compiler-rt/test/asan/TestCases/coverage-disabled.cc b/compiler-rt/test/asan/TestCases/coverage-disabled.cc
new file mode 100644
index 0000000..490f2b2
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-disabled.cc
@@ -0,0 +1,20 @@
+// Test that no data is collected without a runtime flag.
+//
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+//
+// RUN: rm -rf %T/coverage-disabled
+//
+// RUN: mkdir -p %T/coverage-disabled/normal
+// RUN: %env_asan_opts=coverage_direct=0:coverage_dir='"%T/coverage-disabled/normal"':verbosity=1 %run %t
+// RUN: not %sancov print %T/coverage-disabled/normal/*.sancov 2>&1
+//
+// RUN: mkdir -p %T/coverage-disabled/direct
+// RUN: %env_asan_opts=coverage_direct=1:coverage_dir='"%T/coverage-disabled/direct"':verbosity=1 %run %t
+// RUN: cd %T/coverage-disabled/direct
+// RUN: not %sancov rawunpack *.sancov
+//
+// UNSUPPORTED: android
+
+int main(int argc, char **argv) {
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/coverage-levels.cc b/compiler-rt/test/asan/TestCases/coverage-levels.cc
new file mode 100644
index 0000000..612bbd8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-levels.cc
@@ -0,0 +1,34 @@
+// Test various levels of coverage
+//
+// RUN: %clangxx_asan -O1 -fsanitize-coverage=func  %s -o %t
+// RUN: %env_asan_opts=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %clangxx_asan -O1 -fsanitize-coverage=bb  %s -o %t
+// RUN: %env_asan_opts=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: %clangxx_asan -O1 -fsanitize-coverage=edge  %s -o %t
+// RUN: %env_asan_opts=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3
+// RUN: %clangxx_asan -O1 -fsanitize-coverage=edge -mllvm -sanitizer-coverage-block-threshold=0 %s -o %t
+// RUN: %env_asan_opts=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3
+// RUN: %clangxx_asan -O1 -fsanitize-coverage=edge,8bit-counters %s -o %t
+// RUN: %env_asan_opts=coverage=1:coverage_counters=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK_COUNTERS
+
+// RUN: %env_asan_opts=coverage=1:coverage_bitset=0:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOBITSET
+// RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOBITSET
+// RUN: %env_asan_opts=coverage=1:coverage_pcs=0:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOPCS
+//
+// REQUIRES: asan-64-bits
+// UNSUPPORTED: android
+volatile int sink;
+int main(int argc, char **argv) {
+  if (argc == 0)
+    sink = 0;
+}
+
+// CHECK1: CovDump: bitset of 1 bits written for '{{.*}}', 1 bits are set
+// CHECK1:  1 PCs written
+// CHECK2: CovDump: bitset of 3 bits written for '{{.*}}', 2 bits are set
+// CHECK2:  2 PCs written
+// CHECK3: CovDump: bitset of 4 bits written for '{{.*}}', 3 bits are set
+// CHECK3:  3 PCs written
+// CHECK3_NOBITSET-NOT: bitset of
+// CHECK3_NOPCS-NOT: PCs written
+// CHECK_COUNTERS: CovDump: 4 counters written for
diff --git a/compiler-rt/test/asan/TestCases/coverage-order-pcs.cc b/compiler-rt/test/asan/TestCases/coverage-order-pcs.cc
new file mode 100644
index 0000000..dcab694
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-order-pcs.cc
@@ -0,0 +1,57 @@
+// Test coverage_order_pcs=1 flag which orders the PCs by their appearance.
+// RUN: DIR=%T/coverage-order-pcs
+// RUN: rm -rf $DIR
+// RUN: mkdir $DIR
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+// RUN: %env_asan_opts=coverage_dir=$DIR:coverage=1:coverage_order_pcs=0 %run %t
+// RUN: mv $DIR/*sancov $DIR/A
+
+// RUN: %env_asan_opts=coverage_dir=$DIR:coverage=1:coverage_order_pcs=0 %run %t 1
+// RUN: mv $DIR/*sancov $DIR/B
+
+// RUN: %env_asan_opts=coverage_dir=$DIR:coverage=1:coverage_order_pcs=1 %run %t
+// RUN: mv $DIR/*sancov $DIR/C
+
+// RUN: %env_asan_opts=coverage_dir=$DIR:coverage=1:coverage_order_pcs=1 %run %t 1
+// RUN: mv $DIR/*sancov $DIR/D
+//
+// RUN: (%sancov print $DIR/A; %sancov print $DIR/B; %sancov print $DIR/C; %sancov print $DIR/D) | FileCheck %s
+//
+// RUN: rm -rf $DIR
+// Ordering works only in 64-bit mode for now.
+// REQUIRES: asan-64-bits
+// UNSUPPORTED: android
+#include <stdio.h>
+
+void foo() { fprintf(stderr, "FOO\n"); }
+void bar() { fprintf(stderr, "BAR\n"); }
+
+int main(int argc, char **argv) {
+  if (argc == 2) {
+    foo();
+    bar();
+  } else {
+    bar();
+    foo();
+  }
+}
+
+// Run A: no ordering
+// CHECK: [[FOO:0x[0-9a-f]*]]
+// CHECK-NEXT: [[BAR:0x[0-9a-f]*]]
+// CHECK-NEXT: [[MAIN:0x[0-9a-f]*]]
+//
+// Run B: still no ordering
+// CHECK-NEXT: [[FOO]]
+// CHECK-NEXT: [[BAR]]
+// CHECK-NEXT: [[MAIN]]
+//
+// Run C: MAIN, BAR, FOO
+// CHECK-NEXT: [[MAIN]]
+// CHECK-NEXT: [[BAR]]
+// CHECK-NEXT: [[FOO]]
+//
+// Run D: MAIN, FOO, BAR
+// CHECK-NEXT: [[MAIN]]
+// CHECK-NEXT: [[FOO]]
+// CHECK-NEXT: [[BAR]]
diff --git a/compiler-rt/test/asan/TestCases/coverage-reset.cc b/compiler-rt/test/asan/TestCases/coverage-reset.cc
new file mode 100644
index 0000000..eb8da8c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-reset.cc
@@ -0,0 +1,56 @@
+// Test __sanitizer_reset_coverage().
+
+// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
+// RUN: %env_asan_opts=coverage=1 %run %t
+
+// https://github.com/google/sanitizers/issues/618
+// UNSUPPORTED: android
+
+#include <sanitizer/coverage_interface.h>
+#include <stdio.h>
+#include <assert.h>
+static volatile int sink;
+__attribute__((noinline)) void bar() { sink = 2; }
+__attribute__((noinline)) void foo() { sink = 1; }
+
+#define GET_AND_PRINT_COVERAGE()                                       \
+  bitset = 0;                                                  \
+  for (size_t i = 0; i < n_guards; i++)                        \
+    if (guards[i]) bitset |= 1U << i;                          \
+  printf("line %d: bitset %zd total: %zd\n", __LINE__, bitset, \
+         __sanitizer_get_total_unique_coverage());
+
+#define IS_POWER_OF_TWO(a) ((a & ((a) - 1)) == 0)
+
+int main() {
+  size_t *guards = 0;
+  size_t bitset;
+  size_t n_guards = __sanitizer_get_coverage_guards(&guards);
+
+  GET_AND_PRINT_COVERAGE();
+  size_t main_bit = bitset;
+  assert(IS_POWER_OF_TWO(main_bit));
+
+  foo();
+  GET_AND_PRINT_COVERAGE();
+  size_t foo_bit = bitset & ~main_bit;
+  assert(IS_POWER_OF_TWO(foo_bit));
+
+  bar();
+  GET_AND_PRINT_COVERAGE();
+  size_t bar_bit = bitset & ~(main_bit | foo_bit);
+  assert(IS_POWER_OF_TWO(bar_bit));
+
+  __sanitizer_reset_coverage();
+  assert(__sanitizer_get_total_unique_coverage() == 0);
+  GET_AND_PRINT_COVERAGE();
+  assert(bitset == 0);
+
+  foo();
+  GET_AND_PRINT_COVERAGE();
+  assert(bitset == foo_bit);
+
+  bar();
+  GET_AND_PRINT_COVERAGE();
+  assert(bitset == (foo_bit | bar_bit));
+}
diff --git a/compiler-rt/test/asan/TestCases/coverage-tracing.cc b/compiler-rt/test/asan/TestCases/coverage-tracing.cc
new file mode 100644
index 0000000..b7755f8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/coverage-tracing.cc
@@ -0,0 +1,51 @@
+// Test -fsanitize-coverage=trace-bb
+//
+// RUN: %clangxx_asan -O1 -fsanitize-coverage=func,trace-bb %s -o %t
+// RUN: rm -rf   %T/coverage-tracing
+// RUN: mkdir %T/coverage-tracing
+// RUN: cd %T/coverage-tracing
+// RUN:  A=x;   %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK1; mv trace-points.*.sancov $A.points
+// RUN:  A=f;   %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK2; mv trace-points.*.sancov $A.points
+// RUN:  A=b;   %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK2; mv trace-points.*.sancov $A.points
+// RUN:  A=bf;  %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK3; mv trace-points.*.sancov $A.points
+// RUN:  A=fb;  %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK3; mv trace-points.*.sancov $A.points
+// RUN:  A=ffb; %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK4; mv trace-points.*.sancov $A.points
+// RUN:  A=fff; %env_asan_opts=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK4; mv trace-points.*.sancov $A.points
+// RUN:  A=bbf; %env_asan_opts=coverage=1:verbosity=1 %run %t $A 100 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK301; mv trace-points.*.sancov $A.points
+// RUN: diff f.points fff.points
+// RUN: diff bf.points fb.points
+// RUN: diff bf.points ffb.points
+// RUN: diff bf.points bbf.points
+// RUN: not diff x.points f.points
+// RUN: not diff x.points b.points
+// RUN: not diff x.points bf.points
+// RUN: not diff f.points b.points
+// RUN: not diff f.points bf.points
+// RUN: not diff b.points bf.points
+// RUN: rm -rf   %T/coverage-tracing
+//
+// REQUIRES: asan-64-bits
+// UNSUPPORTED: android
+
+#include <stdlib.h>
+volatile int sink;
+__attribute__((noinline)) void foo() { sink++; }
+__attribute__((noinline)) void bar() { sink++; }
+
+int main(int argc, char **argv) {
+  if (argc != 3) return 0;
+  int n = strtol(argv[2], 0, 10);
+  while (n-- > 0) {
+    for (int i = 0; argv[1][i]; i++) {
+      if (argv[1][i] == 'f') foo();
+      else if (argv[1][i] == 'b') bar();
+    }
+  }
+}
+
+// CHECK: CovDump: Trace: 3 PCs written
+// CHECK1: CovDump: Trace: 1 Events written
+// CHECK2: CovDump: Trace: 2 Events written
+// CHECK3: CovDump: Trace: 3 Events written
+// CHECK4: CovDump: Trace: 4 Events written
+// CHECK301: CovDump: Trace: 301 Events written
diff --git a/compiler-rt/test/asan/TestCases/debug_locate.cc b/compiler-rt/test/asan/TestCases/debug_locate.cc
new file mode 100644
index 0000000..5971a77
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/debug_locate.cc
@@ -0,0 +1,80 @@
+// Checks the ASan memory address type debugging API, makes sure it returns
+// the correct memory type for heap, stack, global and shadow addresses and
+// that it correctly finds out which region (and name and size) the address
+// belongs to.
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <sanitizer/asan_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int global_var;
+
+int main() {
+  int local_var;
+  char *heap_ptr = (char *)malloc(10);
+
+  char name[100];
+  void *region_address;
+  size_t region_size;
+  const char *type;
+
+  type = __asan_locate_address(&global_var, name, 100,
+                               &region_address, &region_size);
+  assert(0 == strcmp(name, "global_var"));
+  assert(0 == strcmp(type, "global"));
+  assert(region_address == &global_var);
+  assert(region_size == sizeof(global_var));
+
+  type = __asan_locate_address((char *)(&global_var)+1, name, 100,
+                               &region_address, &region_size);
+  assert(0 == strcmp(name, "global_var"));
+  assert(0 == strcmp(type, "global"));
+  assert(region_address == &global_var);
+  assert(region_size == sizeof(global_var));
+
+  type = __asan_locate_address(&local_var, name, 100,
+                               &region_address, &region_size);
+  assert(0 == strcmp(name, "local_var"));
+  assert(0 == strcmp(type, "stack"));
+  assert(region_address == &local_var);
+  assert(region_size == sizeof(local_var));
+
+  type = __asan_locate_address((char *)(&local_var)+1, name, 100,
+                               &region_address, &region_size);
+  assert(0 == strcmp(name, "local_var"));
+  assert(0 == strcmp(type, "stack"));
+  assert(region_address == &local_var);
+  assert(region_size == sizeof(local_var));
+
+  type = __asan_locate_address(heap_ptr, name, 100,
+                               &region_address, &region_size);
+  assert(0 == strcmp(type, "heap"));
+  assert(region_address == heap_ptr);
+  assert(10 == region_size);
+
+  type = __asan_locate_address(heap_ptr+1, name, 100,
+                               &region_address, &region_size);
+  assert(0 == strcmp(type, "heap"));
+  assert(region_address == heap_ptr);
+  assert(10 == region_size);
+
+  size_t shadow_scale;
+  size_t shadow_offset;
+  __asan_get_shadow_mapping(&shadow_scale, &shadow_offset);
+
+  uintptr_t shadow_ptr = (((uintptr_t)heap_ptr) >> shadow_scale)
+                         + shadow_offset;
+  type = __asan_locate_address((void *)shadow_ptr, NULL, 0, NULL, NULL);
+  assert((0 == strcmp(type, "high shadow")) || 0 == strcmp(type, "low shadow"));
+
+  uintptr_t shadow_gap = (shadow_ptr >> shadow_scale) + shadow_offset;
+  type = __asan_locate_address((void *)shadow_gap, NULL, 0, NULL, NULL);
+  assert(0 == strcmp(type, "shadow gap"));
+
+  free(heap_ptr);
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/debug_mapping.cc b/compiler-rt/test/asan/TestCases/debug_mapping.cc
new file mode 100644
index 0000000..bd05f6a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/debug_mapping.cc
@@ -0,0 +1,24 @@
+// Checks that the debugging API returns correct shadow scale and offset.
+// RUN: %clangxx_asan -O %s -o %t
+// RUN: %env_asan_opts=verbosity=1 %run %t 2>&1 | FileCheck %s
+
+#include <sanitizer/asan_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// printed because of verbosity=1
+// CHECK: SHADOW_SCALE: [[SCALE:[0-9]+]]
+// CHECK: SHADOW_OFFSET: [[OFFSET:0x[0-9a-f]+]]
+
+int main() {
+  size_t scale, offset;
+  __asan_get_shadow_mapping(&scale, &offset);
+
+  fprintf(stderr, "scale: %d\n", (int)scale);
+  fprintf(stderr, "offset: 0x%lx\n", offset);
+
+  // CHECK: scale: [[SCALE]]
+  // CHECK: offset: [[OFFSET]]
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/debug_ppc64_mapping.cc b/compiler-rt/test/asan/TestCases/debug_ppc64_mapping.cc
new file mode 100644
index 0000000..753a636
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/debug_ppc64_mapping.cc
@@ -0,0 +1,37 @@
+// RUN: %clang_asan -O0 %s -o %t
+// RUN: %env_asan_opts=verbosity=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PPC64-V0
+// RUN: %env_asan_opts=verbosity=2 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PPC64
+// REQUIRES: powerpc64-supported-target
+
+#include <stdio.h>
+
+int main() {
+// CHECK-PPC64: || `[{{0x0a0|0x040}}000000000, {{0x3ff|0x0ff}}fffffffff]` || HighMem    ||
+// CHECK-PPC64: || `[{{0x034|0x028}}000000000, {{0x09f|0x03f}}fffffffff]` || HighShadow ||
+// CHECK-PPC64: || `[{{0x024|0x024}}000000000, {{0x033|0x027}}fffffffff]` || ShadowGap  ||
+// CHECK-PPC64: || `[0x020000000000, 0x023fffffffff]`       || LowShadow  ||
+// CHECK-PPC64: || `[0x000000000000, 0x01ffffffffff]`       || LowMem     ||
+//
+  printf("ppc64 eyecatcher \n");
+// CHECK-PPC64-V0: ppc64 eyecatcher
+
+  return 0;
+}
+
+/*
+ * Two different signatures noted at the time of writing.
+Newish kernel: (64TB address range support, starting with kernel version 3.7)
+|| `[0x0a0000000000, 0x3fffffffffff]` || HighMem    ||
+|| `[0x034000000000, 0x09ffffffffff]` || HighShadow ||
+|| `[0x024000000000, 0x033fffffffff]` || ShadowGap  ||
+|| `[0x020000000000, 0x023fffffffff]` || LowShadow  ||
+|| `[0x000000000000, 0x01ffffffffff]` || LowMem     ||
+
+Oldish kernel:
+|| `[0x040000000000, 0x0fffffffffff]` || HighMem    ||
+|| `[0x028000000000, 0x03ffffffffff]` || HighShadow ||
+|| `[0x024000000000, 0x027fffffffff]` || ShadowGap  ||
+|| `[0x020000000000, 0x023fffffffff]` || LowShadow  ||
+|| `[0x000000000000, 0x01ffffffffff]` || LowMem     ||
+*/
+
diff --git a/compiler-rt/test/asan/TestCases/debug_report.cc b/compiler-rt/test/asan/TestCases/debug_report.cc
new file mode 100644
index 0000000..124ae5d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/debug_report.cc
@@ -0,0 +1,63 @@
+// Checks that the ASan debugging API for getting report information
+// returns correct values.
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <sanitizer/asan_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  // Disable stderr buffering. Needed on Windows.
+  setvbuf(stderr, NULL, _IONBF, 0);
+
+  char *heap_ptr = (char *)malloc(10);
+  free(heap_ptr);
+  int present = __asan_report_present();
+  fprintf(stderr, "%s\n", (present == 0) ? "no report" : "");
+  // CHECK: no report
+  heap_ptr[0] = 'A'; // BOOM
+  return 0;
+}
+
+// If we use %p with MSVC, it comes out all upper case. Use %08x to get
+// lowercase hex.
+#ifdef _MSC_VER
+# ifdef _WIN64
+#  define PTR_FMT "0x%08llx"
+# else
+#  define PTR_FMT "0x%08x"
+# endif
+#else
+# define PTR_FMT "%p"
+#endif
+
+void __asan_on_error() {
+  int present = __asan_report_present();
+  void *pc = __asan_get_report_pc();
+  void *bp = __asan_get_report_bp();
+  void *sp = __asan_get_report_sp();
+  void *addr = __asan_get_report_address();
+  int is_write = __asan_get_report_access_type();
+  size_t access_size = __asan_get_report_access_size();
+  const char *description = __asan_get_report_description();
+
+  fprintf(stderr, "%s\n", (present == 1) ? "report" : "");
+  // CHECK: report
+  fprintf(stderr, "pc: " PTR_FMT "\n", pc);
+  // CHECK: pc: 0x[[PC:[0-9a-f]+]]
+  fprintf(stderr, "bp: " PTR_FMT "\n", bp);
+  // CHECK: bp: 0x[[BP:[0-9a-f]+]]
+  fprintf(stderr, "sp: " PTR_FMT "\n", sp);
+  // CHECK: sp: 0x[[SP:[0-9a-f]+]]
+  fprintf(stderr, "addr: " PTR_FMT "\n", addr);
+  // CHECK: addr: 0x[[ADDR:[0-9a-f]+]]
+  fprintf(stderr, "type: %s\n", (is_write ? "write" : "read"));
+  // CHECK: type: write
+  fprintf(stderr, "access_size: %ld\n", access_size);
+  // CHECK: access_size: 1
+  fprintf(stderr, "description: %s\n", description);
+  // CHECK: description: heap-use-after-free
+}
+
+// CHECK: AddressSanitizer: heap-use-after-free on address {{0x0*}}[[ADDR]] at pc {{0x0*}}[[PC]] bp {{0x0*}}[[BP]] sp {{0x0*}}[[SP]]
+// CHECK: WRITE of size 1 at {{0x0*}}[[ADDR]] thread T0
diff --git a/compiler-rt/test/asan/TestCases/debug_stacks.cc b/compiler-rt/test/asan/TestCases/debug_stacks.cc
new file mode 100644
index 0000000..857e905
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/debug_stacks.cc
@@ -0,0 +1,68 @@
+// Check that the stack trace debugging API works and returns correct
+// malloc and free stacks.
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// FIXME: Figure out why allocation/free stack traces may be too short on ARM.
+// REQUIRES: stable-runtime
+
+#include <sanitizer/asan_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+char *mem;
+void func1() {
+  mem = (char *)malloc(10);
+}
+
+void func2() {
+  free(mem);
+}
+
+int main() {
+  // Disable stderr buffering. Needed on Windows.
+  setvbuf(stderr, NULL, _IONBF, 0);
+
+  func1();
+  func2();
+
+  void *trace[100];
+  size_t num_frames = 100;
+  int thread_id;
+  num_frames = __asan_get_alloc_stack(mem, trace, num_frames, &thread_id);
+
+  fprintf(stderr, "alloc stack retval %s\n", (num_frames > 0 && num_frames < 10)
+          ? "ok" : "");
+  // CHECK: alloc stack retval ok
+  fprintf(stderr, "thread id = %d\n", thread_id);
+  // CHECK: thread id = 0
+  fprintf(stderr, "0x%lx\n", trace[0]);
+  // CHECK: [[ALLOC_FRAME_0:0x[0-9a-f]+]]
+  fprintf(stderr, "0x%lx\n", trace[1]);
+  // CHECK: [[ALLOC_FRAME_1:0x[0-9a-f]+]]
+
+  num_frames = 100;
+  num_frames = __asan_get_free_stack(mem, trace, num_frames, &thread_id);
+
+  fprintf(stderr, "free stack retval %s\n", (num_frames > 0 && num_frames < 10)
+          ? "ok" : "");
+  // CHECK: free stack retval ok
+  fprintf(stderr, "thread id = %d\n", thread_id);
+  // CHECK: thread id = 0
+  fprintf(stderr, "0x%lx\n", trace[0]);
+  // CHECK: [[FREE_FRAME_0:0x[0-9a-f]+]]
+  fprintf(stderr, "0x%lx\n", trace[1]);
+  // CHECK: [[FREE_FRAME_1:0x[0-9a-f]+]]
+
+  mem[0] = 'A'; // BOOM
+
+  // CHECK: ERROR: AddressSanitizer: heap-use-after-free
+  // CHECK: WRITE of size 1 at 0x{{.*}}
+  // CHECK: freed by thread T0 here:
+  // CHECK: #0 [[FREE_FRAME_0]]
+  // CHECK: #1 [[FREE_FRAME_1]]
+  // CHECK: previously allocated by thread T0 here:
+  // CHECK: #0 [[ALLOC_FRAME_0]]
+  // CHECK: #1 [[ALLOC_FRAME_1]]
+
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/deep_stack_uaf.cc b/compiler-rt/test/asan/TestCases/deep_stack_uaf.cc
new file mode 100644
index 0000000..95032f2
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/deep_stack_uaf.cc
@@ -0,0 +1,36 @@
+// Check that we can store lots of stack frames if asked to.
+
+// RUN: %clangxx_asan -O0 %s -o %t 2>&1
+// RUN: %env_asan_opts=malloc_context_size=120:redzone=512 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+#include <stdlib.h>
+#include <stdio.h>
+
+template <int depth>
+struct DeepFree {
+  static void free(char *x) {
+    DeepFree<depth - 1>::free(x);
+  }
+};
+
+template<>
+struct DeepFree<0> {
+  static void free(char *x) {
+    ::free(x);
+  }
+};
+
+int main() {
+  char *x = (char*)malloc(10);
+  // deep_free(x);
+  DeepFree<200>::free(x);
+  return x[5];
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+  // The libcxxrt demangling procedure on FreeBSD 9.2 incorrectly appends
+  // extra 'E' characters to the end of template arguments; see:
+  // https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=192115
+  // CHECK: {{DeepFree<36>|DeepFree<36E>}}
+  // CHECK: {{DeepFree<98>|DeepFree<98E>}}
+  // CHECK: {{DeepFree<115>|DeepFree<115E>}}
+}
diff --git a/compiler-rt/test/asan/TestCases/deep_tail_call.cc b/compiler-rt/test/asan/TestCases/deep_tail_call.cc
new file mode 100644
index 0000000..628ef06
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/deep_tail_call.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// CHECK: AddressSanitizer: global-buffer-overflow
+int global[10];
+// CHECK: {{#0.*call4}}
+void __attribute__((noinline)) call4(int i) { global[i+10]++; }
+// CHECK: {{#1.*call3}}
+void __attribute__((noinline)) call3(int i) { call4(i); }
+// CHECK: {{#2.*call2}}
+void __attribute__((noinline)) call2(int i) { call3(i); }
+// CHECK: {{#3.*call1}}
+void __attribute__((noinline)) call1(int i) { call2(i); }
+// CHECK: {{#4.*main}}
+int main(int argc, char **argv) {
+  call1(argc);
+  return global[0];
+}
diff --git a/compiler-rt/test/asan/TestCases/default_blacklist.cc b/compiler-rt/test/asan/TestCases/default_blacklist.cc
new file mode 100644
index 0000000..9358cc4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/default_blacklist.cc
@@ -0,0 +1,6 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// Test that ASan uses the default blacklist from resource directory.
+// RUN: %clangxx_asan -### %s 2>&1 | FileCheck %s
+// CHECK: fsanitize-blacklist={{.*}}asan_blacklist.txt
diff --git a/compiler-rt/test/asan/TestCases/default_options.cc b/compiler-rt/test/asan/TestCases/default_options.cc
new file mode 100644
index 0000000..a3aa663
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/default_options.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+const char *kAsanDefaultOptions="verbosity=1 help=1";
+
+extern "C"
+__attribute__((no_sanitize_address))
+const char *__asan_default_options() {
+  // CHECK: Available flags for AddressSanitizer:
+  return kAsanDefaultOptions;
+}
+
+int main() {
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/describe_address.cc b/compiler-rt/test/asan/TestCases/describe_address.cc
new file mode 100644
index 0000000..868c0eb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/describe_address.cc
@@ -0,0 +1,19 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <sanitizer/asan_interface.h>
+
+int global;
+
+int main(int argc, char *argv[]) {
+  int stack;
+  int *heap = new int[100];
+  __asan_describe_address(heap);
+  // CHECK: {{.*}} is located 0 bytes inside of 400-byte region
+  // CHECK: allocated by thread T{{.*}} here
+  __asan_describe_address(&stack);
+  // CHECK: Address {{.*}} is located in stack of thread T{{.*}} at offset {{.*}}
+  __asan_describe_address(&global);
+  // CHECK: {{.*}} is located 0 bytes inside of global variable 'global'
+  delete[] heap;
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/double-free.cc b/compiler-rt/test/asan/TestCases/double-free.cc
new file mode 100644
index 0000000..3297b43
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/double-free.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_asan -O0 %s -o %t 2>&1
+// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
+
+// Also works if no malloc context is available.
+// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char*)malloc(10 * sizeof(char));
+  memset(x, 0, 10);
+  int res = x[argc];
+  free(x);
+  free(x + argc - 1);  // BOOM
+  // CHECK: AddressSanitizer: attempting double-free{{.*}}in thread T0
+  // CHECK: #0 0x{{.*}} in {{.*}}free
+  // CHECK: #1 0x{{.*}} in main {{.*}}double-free.cc:[[@LINE-3]]
+  // CHECK: freed by thread T0 here:
+  // MALLOC-CTX: #0 0x{{.*}} in {{.*}}free
+  // MALLOC-CTX: #1 0x{{.*}} in main {{.*}}double-free.cc:[[@LINE-7]]
+  // CHECK: allocated by thread T0 here:
+  // MALLOC-CTX: double-free.cc:[[@LINE-12]]
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/dump_instruction_bytes.cc b/compiler-rt/test/asan/TestCases/dump_instruction_bytes.cc
new file mode 100644
index 0000000..da86a0f
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/dump_instruction_bytes.cc
@@ -0,0 +1,20 @@
+// Check that ASan prints the faulting instruction bytes on
+// dump_instruction_bytes=1
+// RUN: %clangxx_asan  %s -o %t
+// RUN: %env_asan_opts=dump_instruction_bytes=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-DUMP
+// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NODUMP
+//
+// REQUIRES: x86_64-supported-target,i386-supported-target
+
+int main() {
+#if defined(__x86_64__)
+  asm("movq $0, %rax");
+  asm("movl $0xcafebabe, 0x0(%rax)");
+#elif defined(i386)
+  asm("movl $0, %eax");
+  asm("movl $0xcafebabe, 0x0(%eax)");
+#endif
+  // CHECK-DUMP: First 16 instruction bytes at pc: c7 00 be ba fe ca
+  // CHECK-NODUMP-NOT: First 16 instruction bytes
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/force_inline_opt0.cc b/compiler-rt/test/asan/TestCases/force_inline_opt0.cc
new file mode 100644
index 0000000..e6e5d26
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/force_inline_opt0.cc
@@ -0,0 +1,14 @@
+// This test checks that we are no instrumenting a memory access twice
+// (before and after inlining)
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t
+__attribute__((always_inline))
+void foo(int *x) {
+  *x = 0;
+}
+
+int main() {
+  int x;
+  foo(&x);
+  return x;
+}
diff --git a/compiler-rt/test/asan/TestCases/frexp_interceptor.cc b/compiler-rt/test/asan/TestCases/frexp_interceptor.cc
new file mode 100644
index 0000000..d75ba99
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/frexp_interceptor.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// Test the frexp() interceptor.
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+int main() {
+  double x = 3.14;
+  int *exp = (int*)malloc(sizeof(int));
+  free(exp);
+  double y = frexp(x, exp);
+  // CHECK: use-after-free
+  // CHECK: SUMMARY
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/global-demangle.cc b/compiler-rt/test/asan/TestCases/global-demangle.cc
new file mode 100644
index 0000000..5f7ff91
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/global-demangle.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+namespace XXX {
+class YYY {
+ public:
+  static char ZZZ[];
+};
+char YYY::ZZZ[] = "abc";
+}
+
+int main(int argc, char **argv) {
+  return (int)XXX::YYY::ZZZ[argc + 5];  // BOOM
+  // CHECK: {{READ of size 1 at 0x.*}}
+  // CHECK: {{0x.* is located 2 bytes to the right of global variable}}
+  // CHECK: 'XXX::YYY::ZZZ' {{.*}} of size 4
+  // CHECK: 'XXX::YYY::ZZZ' is ascii string 'abc'
+}
diff --git a/compiler-rt/test/asan/TestCases/global-location.cc b/compiler-rt/test/asan/TestCases/global-location.cc
new file mode 100644
index 0000000..795e50b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/global-location.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: not %run %t g 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=GLOB
+// RUN: not %run %t c 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CLASS_STATIC
+// RUN: not %run %t f 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=FUNC_STATIC
+// RUN: not %run %t l 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=LITERAL
+
+// CHECK: AddressSanitizer: global-buffer-overflow
+
+#include <string.h>
+
+struct C {
+  static int array[10];
+};
+
+int global[10];
+// GLOB: 0x{{.*}} is located 4 bytes to the right of global variable 'global' defined in '{{.*}}global-location.cc:[[@LINE-1]]:5' {{.*}} of size 40
+int C::array[10];
+// CLASS_STATIC: 0x{{.*}} is located 4 bytes to the right of global variable 'C::array' defined in '{{.*}}global-location.cc:[[@LINE-1]]:8' {{.*}} of size 40
+
+int main(int argc, char **argv) {
+  int one = argc - 1;
+  switch (argv[1][0]) {
+  case 'g': return global[one * 11];
+  case 'c': return C::array[one * 11];
+  case 'f':
+    static int array[10];
+    // FUNC_STATIC: 0x{{.*}} is located 4 bytes to the right of global variable 'array' defined in '{{.*}}global-location.cc:[[@LINE-1]]:16' {{.*}} of size 40
+    memset(array, 0, 10);
+    return array[one * 11];
+  case 'l':
+    const char *str = "0123456789";
+    // LITERAL: 0x{{.*}} is located 0 bytes to the right of global variable {{.*}} defined in '{{.*}}global-location.cc:[[@LINE-1]]:23' {{.*}} of size 11
+    return str[one * 11];
+  }
+  return 0;
+}
+
+// CHECK: SUMMARY: AddressSanitizer: global-buffer-overflow
diff --git a/compiler-rt/test/asan/TestCases/global-overflow.cc b/compiler-rt/test/asan/TestCases/global-overflow.cc
new file mode 100644
index 0000000..a39a953
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/global-overflow.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <string.h>
+int main(int argc, char **argv) {
+  static char XXX[10];
+  static char YYY[10];
+  static char ZZZ[10];
+  memset(XXX, 0, 10);
+  memset(YYY, 0, 10);
+  memset(ZZZ, 0, 10);
+  int res = YYY[argc * 10];  // BOOOM
+  // CHECK: {{READ of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main .*global-overflow.cc:}}[[@LINE-2]]
+  // CHECK: {{0x.* is located 0 bytes to the right of global variable}}
+  // CHECK:   {{.*YYY.* of size 10}}
+  res += XXX[argc] + ZZZ[argc];
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/halt_on_error-1.c b/compiler-rt/test/asan/TestCases/halt_on_error-1.c
new file mode 100644
index 0000000..63c65e5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/halt_on_error-1.c
@@ -0,0 +1,29 @@
+// Test recovery mode.
+//
+// RUN: %clang_asan -fsanitize-recover=address %s -o %t
+//
+// RUN: env not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=halt_on_error=true not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=halt_on_error=false %run %t 2>&1 | FileCheck %s --check-prefix CHECK-RECOVER
+
+#include <string.h>
+
+volatile int ten = 10;
+
+int main() {
+  char x[10];
+  // CHECK: WRITE of size 11
+  // CHECK-RECOVER: WRITE of size 11
+  memset(x, 0, 11);
+  // CHECK-NOT: READ of size 1
+  // CHECK-RECOVER: READ of size 1
+  volatile int res = x[ten];
+  // CHECK-NOT: WRITE of size 1
+  // CHECK-RECOVER: WRITE of size 1
+  x[ten] = res + 3;
+  // CHECK-NOT: READ of size 1
+  // CHECK-RECOVER: READ of size 1
+  res = x[ten];
+  return  0;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/heap-overflow-large.cc b/compiler-rt/test/asan/TestCases/heap-overflow-large.cc
new file mode 100644
index 0000000..566b115
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/heap-overflow-large.cc
@@ -0,0 +1,23 @@
+// Regression test for
+// https://code.google.com/p/address-sanitizer/issues/detail?id=183
+
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: not %run %t 12 2>&1 | FileCheck %s
+// RUN: not %run %t 100 2>&1 | FileCheck %s
+// RUN: not %run %t 10000 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  fprintf(stderr, "main\n");
+  int *x = new int[5];
+  memset(x, 0, sizeof(x[0]) * 5);
+  int index = atoi(argv[1]);
+  unsigned res = x[index];
+  // CHECK: main
+  // CHECK-NOT: CHECK failed
+  delete[] x;
+  return (res % 10) + 1;
+}
diff --git a/compiler-rt/test/asan/TestCases/heap-overflow.cc b/compiler-rt/test/asan/TestCases/heap-overflow.cc
new file mode 100644
index 0000000..3ddb243
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/heap-overflow.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=print_stats=1 not %run %t 2>&1 | FileCheck %s
+
+// FIXME: Fix this test under GCC.
+// REQUIRES: Clang
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char*)malloc(10 * sizeof(char));
+  memset(x, 0, 10);
+  int res = x[argc * 10];  // BOOOM
+  // CHECK: {{READ of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main .*heap-overflow.cc:}}[[@LINE-2]]
+  // CHECK: {{0x.* is located 0 bytes to the right of 10-byte region}}
+  // CHECK: {{allocated by thread T0 here:}}
+
+  // CHECK: {{    #0 0x.* in .*malloc}}
+  free(x);
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/heavy_uar_test.cc b/compiler-rt/test/asan/TestCases/heavy_uar_test.cc
new file mode 100644
index 0000000..8338f80
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/heavy_uar_test.cc
@@ -0,0 +1,65 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi,win32
+
+// FIXME: Fix this test under GCC.
+// REQUIRES: Clang
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+__attribute__((noinline))
+char *pretend_to_do_something(char *x) {
+  __asm__ __volatile__("" : : "r" (x) : "memory");
+  return x;
+}
+
+__attribute__((noinline))
+char *LeakStack() {
+  char x[1024];
+  memset(x, 0, sizeof(x));
+  return pretend_to_do_something(x);
+}
+
+template<size_t kFrameSize>
+__attribute__((noinline))
+void RecursiveFunctionWithStackFrame(int depth) {
+  if (depth <= 0) return;
+  char x[kFrameSize];
+  x[0] = depth;
+  pretend_to_do_something(x);
+  RecursiveFunctionWithStackFrame<kFrameSize>(depth - 1);
+}
+
+int main(int argc, char **argv) {
+#ifdef _MSC_VER
+  // FIXME: This test crashes on Windows and raises a dialog. Avoid running it
+  // in addition to XFAILing it.
+  return 42;
+#endif
+
+  int n_iter = argc >= 2 ? atoi(argv[1]) : 1000;
+  int depth  = argc >= 3 ? atoi(argv[2]) : 500;
+  for (int i = 0; i < n_iter; i++) {
+    RecursiveFunctionWithStackFrame<10>(depth);
+    RecursiveFunctionWithStackFrame<100>(depth);
+    RecursiveFunctionWithStackFrame<500>(depth);
+    RecursiveFunctionWithStackFrame<1024>(depth);
+    RecursiveFunctionWithStackFrame<2000>(depth);
+    // The stack size is tight for the main thread in multithread
+    // environment on FreeBSD.
+#if !defined(__FreeBSD__)
+    RecursiveFunctionWithStackFrame<5000>(depth);
+    RecursiveFunctionWithStackFrame<10000>(depth);
+#endif
+  }
+  char *stale_stack = LeakStack();
+  RecursiveFunctionWithStackFrame<1024>(10);
+  stale_stack[100]++;
+  // CHECK: ERROR: AddressSanitizer: stack-use-after-return on address
+  // CHECK: is located in stack of thread T0 at offset {{116|132}} in frame
+  // CHECK:  in LeakStack{{.*}}heavy_uar_test.cc:
+  // CHECK: [{{16|32}}, {{1040|1056}}) 'x'
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/huge_negative_hea_oob.cc b/compiler-rt/test/asan/TestCases/huge_negative_hea_oob.cc
new file mode 100644
index 0000000..96e7e61
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/huge_negative_hea_oob.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O %s -o %t && not %run %t 2>&1 | FileCheck %s
+// Check that we can find huge buffer overflows to the left.
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char*)malloc(1 << 20);
+  memset(x, 0, 10);
+  int res = x[-argc * 4000];  // BOOOM
+  // CHECK: is located 4000 bytes to the left of
+  free(x);
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/init-order-atexit.cc b/compiler-rt/test/asan/TestCases/init-order-atexit.cc
new file mode 100644
index 0000000..021b2bd
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/init-order-atexit.cc
@@ -0,0 +1,31 @@
+// Test for the following situation:
+// (1) global A is constructed.
+// (2) exit() is called during construction of global B.
+// (3) destructor of A reads uninitialized global C from another module.
+// We do *not* want to report init-order bug in this case.
+
+// RUN: %clangxx_asan -O0 %s %p/Helpers/init-order-atexit-extra.cc -o %t
+// RUN: %env_asan_opts=strict_init_order=true not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void AccessC();
+
+class A {
+ public:
+  A() { }
+  ~A() { AccessC(); printf("PASSED\n"); }
+  // CHECK-NOT: AddressSanitizer
+  // CHECK: PASSED
+};
+
+A a;
+
+class B {
+ public:
+  B() { exit(1); }
+  ~B() { }
+};
+
+B b;
diff --git a/compiler-rt/test/asan/TestCases/initialization-blacklist.cc b/compiler-rt/test/asan/TestCases/initialization-blacklist.cc
new file mode 100644
index 0000000..3a98fc6
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/initialization-blacklist.cc
@@ -0,0 +1,29 @@
+// Test for blacklist functionality of initialization-order checker.
+
+// RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-blacklist-extra.cc\
+// RUN:   %p/Helpers/initialization-blacklist-extra2.cc \
+// RUN:   -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-blacklist-extra.cc\
+// RUN:   %p/Helpers/initialization-blacklist-extra2.cc \
+// RUN:   -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-blacklist-extra.cc\
+// RUN:   %p/Helpers/initialization-blacklist-extra2.cc \
+// RUN:   -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+
+// Function is defined in another TU.
+int readBadGlobal();
+int x = readBadGlobal();  // init-order bug.
+
+// Function is defined in another TU.
+int accessBadObject();
+int y = accessBadObject();  // init-order bug.
+
+int readBadSrcGlobal();
+int z = readBadSrcGlobal();  // init-order bug.
+
+int main(int argc, char **argv) {
+  return argc + x + y + z - 1;
+}
diff --git a/compiler-rt/test/asan/TestCases/initialization-bug.cc b/compiler-rt/test/asan/TestCases/initialization-bug.cc
new file mode 100644
index 0000000..f549725
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/initialization-bug.cc
@@ -0,0 +1,47 @@
+// Test to make sure basic initialization order errors are caught.
+
+// RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-bug-extra2.cc -o %t-INIT-ORDER-EXE
+// RUN: %env_asan_opts=check_initialization_order=true not %run %t-INIT-ORDER-EXE 2>&1 | FileCheck %s
+
+// Do not test with optimization -- the error may be optimized away.
+
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=186
+// XFAIL: darwin,win32
+
+#include <cstdio>
+
+// The structure of the test is:
+// "x", "y", "z" are dynamically initialized globals.
+// Value of "x" depends on "y", value of "y" depends on "z".
+// "x" and "z" are defined in this TU, "y" is defined in another one.
+// Thus we shoud stably report initialization order fiasco independently of
+// the translation unit order.
+
+int initZ() {
+  return 5;
+}
+int z = initZ();
+
+// 'y' is a dynamically initialized global residing in a different TU.  This
+// dynamic initializer will read the value of 'y' before main starts.  The
+// result is undefined behavior, which should be caught by initialization order
+// checking.
+extern int y;
+int __attribute__((noinline)) initX() {
+  return y + 1;
+  // CHECK: {{AddressSanitizer: initialization-order-fiasco}}
+  // CHECK: {{READ of size .* at 0x.* thread T0}}
+  // CHECK: {{0x.* is located 0 bytes inside of global variable .*(y|z).*}}
+  // CHECK: registered at:
+  // CHECK: 0x{{.*}} in __asan_register_globals
+}
+
+// This initializer begins our initialization order problems.
+static int x = initX();
+
+int main() {
+  // ASan should have caused an exit before main runs.
+  printf("PASS\n");
+  // CHECK-NOT: PASS
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/initialization-constexpr.cc b/compiler-rt/test/asan/TestCases/initialization-constexpr.cc
new file mode 100644
index 0000000..53619ea
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/initialization-constexpr.cc
@@ -0,0 +1,27 @@
+// Constexpr:
+// We need to check that a global variable initialized with a constexpr
+// constructor can be accessed during dynamic initialization (as a constexpr
+// constructor implies that it was initialized during constant initialization,
+// not dynamic initialization).
+
+// RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+
+class Integer {
+  private:
+  int value;
+
+  public:
+  constexpr Integer(int x = 0) : value(x) {}
+  int getValue() {return value;}
+};
+Integer coolestInteger(42);
+int getCoolestInteger() { return coolestInteger.getValue(); }
+
+int main() { return 0; }
diff --git a/compiler-rt/test/asan/TestCases/initialization-nobug.cc b/compiler-rt/test/asan/TestCases/initialization-nobug.cc
new file mode 100644
index 0000000..783c789
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/initialization-nobug.cc
@@ -0,0 +1,48 @@
+// A collection of various initializers which shouldn't trip up initialization
+// order checking.  If successful, this will just return 0.
+
+// RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-nobug-extra.cc -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-nobug-extra.cc -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-nobug-extra.cc -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+// RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-nobug-extra.cc -o %t
+// RUN: %env_asan_opts=check_initialization_order=true %run %t 2>&1
+
+// Simple access:
+// Make sure that accessing a global in the same TU is safe
+
+bool condition = true;
+int initializeSameTU() {
+  return condition ? 0x2a : 052;
+}
+int sameTU = initializeSameTU();
+
+// Linker initialized:
+// Check that access to linker initialized globals originating from a different
+// TU's initializer is safe.
+
+int A = (1 << 1) + (1 << 3) + (1 << 5), B;
+int getAB() {
+  return A * B;
+}
+
+// Function local statics:
+// Check that access to function local statics originating from a different
+// TU's initializer is safe.
+
+int countCalls() {
+  static int calls;
+  return ++calls;
+}
+
+// Trivial constructor, non-trivial destructor.
+struct StructWithDtor {
+  ~StructWithDtor() { }
+  int value;
+};
+StructWithDtor struct_with_dtor;
+int getStructWithDtorValue() { return struct_with_dtor.value; }
+
+int main() { return 0; }
diff --git a/compiler-rt/test/asan/TestCases/inline.cc b/compiler-rt/test/asan/TestCases/inline.cc
new file mode 100644
index 0000000..daeb7b4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/inline.cc
@@ -0,0 +1,19 @@
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t
+
+// Test that no_sanitize_address attribute applies even when the function would
+// be normally inlined.
+
+#include <stdlib.h>
+
+__attribute__((no_sanitize_address))
+int f(int *p) {
+  return *p; // BOOOM?? Nope!
+}
+
+int main(int argc, char **argv) {
+  int * volatile x = (int*)malloc(2*sizeof(int) + 2);
+  int res = f(x + 2);
+  if (res)
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/interception_failure_test.cc b/compiler-rt/test/asan/TestCases/interception_failure_test.cc
new file mode 100644
index 0000000..63d8746
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/interception_failure_test.cc
@@ -0,0 +1,24 @@
+// If user provides his own libc functions, ASan doesn't
+// intercept these functions.
+
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
+// On Windows, defining strtoll results in linker errors.
+// XFAIL: freebsd,win32
+#include <stdlib.h>
+#include <stdio.h>
+
+extern "C" long strtol(const char *nptr, char **endptr, int base) {
+  fprintf(stderr, "my_strtol_interceptor\n");
+  return 0;
+}
+
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return (int)strtol(x, 0, 10);
+  // CHECK: my_strtol_interceptor
+  // CHECK-NOT: heap-use-after-free
+}
diff --git a/compiler-rt/test/asan/TestCases/interface_test.cc b/compiler-rt/test/asan/TestCases/interface_test.cc
new file mode 100644
index 0000000..9419f07
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/interface_test.cc
@@ -0,0 +1,10 @@
+// Check that user may include ASan interface header.
+// RUN: %clang_asan %s -o %t && %run %t
+// RUN: %clang_asan -x c %s -o %t && %run %t
+// RUN: %clang %s -pie -o %t && %run %t
+// RUN: %clang -x c %s -pie -o %t && %run %t
+#include <sanitizer/asan_interface.h>
+
+int main() {
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/intra-object-overflow.cc b/compiler-rt/test/asan/TestCases/intra-object-overflow.cc
new file mode 100644
index 0000000..e48a261
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/intra-object-overflow.cc
@@ -0,0 +1,31 @@
+// RUN: %clangxx_asan -O0 -fsanitize-address-field-padding=1  %s -o %t
+// RUN: not %run %t 11 2>&1 | FileCheck %s
+// RUN: %run %t 10
+//
+// FIXME: fix 32-bits.
+// REQUIRES: asan-64-bits
+#include <stdio.h>
+#include <stdlib.h>
+class Foo {
+ public:
+  Foo() : pre1(1), pre2(2), post1(3), post2(4) {
+  }
+  virtual ~Foo() {
+  }
+  void set(int i, int val) { a[i] = val; }
+// CHECK: ERROR: AddressSanitizer: intra-object-overflow
+// CHECK: #0 {{.*}}Foo::set{{.*}}intra-object-overflow.cc:[[@LINE-2]]
+ private:
+  int pre1, pre2;
+  int a[11];
+  int post1, post2;
+};
+
+int main(int argc, char **argv) {
+  int idx = argc == 2 ? atoi(argv[1]) : 0;
+  Foo *foo = new Foo;
+  foo->set(idx, 42);
+// CHECK: #1 {{.*}}main{{.*}}intra-object-overflow.cc:[[@LINE-1]]
+// CHECK: is located 84 bytes inside of 128-byte region
+  delete foo;
+}
diff --git a/compiler-rt/test/asan/TestCases/invalid-free.cc b/compiler-rt/test/asan/TestCases/invalid-free.cc
new file mode 100644
index 0000000..dd59f5a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/invalid-free.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
+
+// Also works if no malloc context is available.
+// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char*)malloc(10 * sizeof(char));
+  memset(x, 0, 10);
+  int res = x[argc];
+  free(x + 5);  // BOOM
+  // CHECK: AddressSanitizer: attempting free on address{{.*}}in thread T0
+  // CHECK: invalid-free.cc:[[@LINE-2]]
+  // CHECK: is located 5 bytes inside of 10-byte region
+  // CHECK: allocated by thread T0 here:
+  // MALLOC-CTX: invalid-free.cc:[[@LINE-8]]
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/large_func_test.cc b/compiler-rt/test/asan/TestCases/large_func_test.cc
new file mode 100644
index 0000000..6b592f8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/large_func_test.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+__attribute__((noinline))
+static void LargeFunction(int *x, int zero) {
+  x[0]++;
+  x[1]++;
+  x[2]++;
+  x[3]++;
+  x[4]++;
+  x[5]++;
+  x[6]++;
+  x[7]++;
+  x[8]++;
+  x[9]++;
+
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}
+  // CHECK: {{READ of size 4 at 0x.* thread T0}}
+  x[zero + 103]++;  // we should report this exact line
+  // atos incorrectly extracts the symbol name for the static functions on
+  // Darwin.
+  // CHECK-Linux:  {{#0 0x.* in LargeFunction.*large_func_test.cc:}}[[@LINE-3]]
+  // CHECK-Darwin: {{#0 0x.* in .*LargeFunction.*large_func_test.cc}}:[[@LINE-4]]
+
+  x[10]++;
+  x[11]++;
+  x[12]++;
+  x[13]++;
+  x[14]++;
+  x[15]++;
+  x[16]++;
+  x[17]++;
+  x[18]++;
+  x[19]++;
+}
+
+int main(int argc, char **argv) {
+  int *x = new int[100];
+  LargeFunction(x, argc - 1);
+  // CHECK: {{    #1 0x.* in main .*large_func_test.cc:}}[[@LINE-1]]
+  // CHECK: {{0x.* is located 12 bytes to the right of 400-byte region}}
+  // CHECK: {{allocated by thread T0 here:}}
+  // CHECK-Linux: {{    #0 0x.* in operator new.*}}
+  // CHECK-Darwin: {{    #0 0x.* in .*_Zna.*}}
+  // CHECK: {{    #1 0x.* in main .*large_func_test.cc:}}[[@LINE-7]]
+  delete x;
+}
diff --git a/compiler-rt/test/asan/TestCases/log-path_test.cc b/compiler-rt/test/asan/TestCases/log-path_test.cc
new file mode 100644
index 0000000..b4218ad
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/log-path_test.cc
@@ -0,0 +1,47 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+//
+// The for loop in the backticks below requires bash.
+// REQUIRES: shell
+//
+// RUN: %clangxx_asan  %s -o %t
+
+// Regular run.
+// RUN: not %run %t 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.out
+
+// Good log_path.
+// RUN: rm -f %t.log.*
+// RUN: %env_asan_opts=log_path=%t.log not %run %t 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.log.*
+
+// Invalid log_path.
+// RUN: %env_asan_opts=log_path=/dev/null/INVALID not %run %t 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-INVALID < %t.out
+
+// Too long log_path.
+// RUN: %env_asan_opts=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \
+// RUN:   not %run %t 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-LONG < %t.out
+
+// Run w/o errors should not produce any log.
+// RUN: rm -f %t.log.*
+// RUN: %env_asan_opts=log_path=%t.log  %run %t ARG ARG ARG
+// RUN: not cat %t.log.*
+
+// FIXME: log_path is not supported on Windows yet.
+// XFAIL: win32
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  if (argc > 2) return 0;
+  char *x = (char*)malloc(10);
+  memset(x, 0, 10);
+  int res = x[argc * 10];  // BOOOM
+  free(x);
+  return res;
+}
+// CHECK-ERROR: ERROR: AddressSanitizer
+// CHECK-INVALID: ERROR: Can't open file: /dev/null/INVALID
+// CHECK-LONG: ERROR: Path is too long: 01234
diff --git a/compiler-rt/test/asan/TestCases/longjmp.cc b/compiler-rt/test/asan/TestCases/longjmp.cc
new file mode 100644
index 0000000..8e9f2ae
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/longjmp.cc
@@ -0,0 +1,25 @@
+// RUN: %clangxx_asan -O %s -o %t && %run %t
+
+#include <assert.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+static jmp_buf buf;
+
+int main() {
+  char x[32];
+  fprintf(stderr, "\nTestLongJmp\n");
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  if (0 == setjmp(buf))
+    longjmp(buf, 1);
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  // This assertion works only w/o UAR.
+  if (!__asan_get_current_fake_stack())
+    assert(!__asan_address_is_poisoned(x + 32));
+}
diff --git a/compiler-rt/test/asan/TestCases/lsan_annotations.cc b/compiler-rt/test/asan/TestCases/lsan_annotations.cc
new file mode 100644
index 0000000..f52b0ff
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/lsan_annotations.cc
@@ -0,0 +1,16 @@
+// Check that LSan annotations work fine.
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t
+
+#include <sanitizer/lsan_interface.h>
+#include <stdlib.h>
+
+int main() {
+  int *x = new int;
+  __lsan_ignore_object(x);
+  {
+    __lsan::ScopedDisabler disabler;
+    double *y = new double;
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/malloc_context_size.cc b/compiler-rt/test/asan/TestCases/malloc_context_size.cc
new file mode 100644
index 0000000..c753a3a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/malloc_context_size.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=malloc_context_size=1:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=malloc_context_size=1:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=malloc_context_size=2 not %run %t 2>&1 | FileCheck %s --check-prefix=TWO
+
+int main() {
+  char *x = new char[20];
+  delete[] x;
+  return x[0];
+
+  // CHECK: freed by thread T{{.*}} here:
+  // CHECK-NEXT: #0 0x{{.*}} in {{operator delete( )?\[\]|wrap__ZdaPv}}
+  // CHECK-NOT: #1 0x{{.*}}
+
+  // CHECK: previously allocated by thread T{{.*}} here:
+  // CHECK-NEXT: #0 0x{{.*}} in {{operator new( )?\[\]|wrap__Znam}}
+  // CHECK-NOT: #1 0x{{.*}}
+
+  // CHECK: SUMMARY: AddressSanitizer: heap-use-after-free
+
+  // TWO: previously allocated by thread T{{.*}} here:
+  // TWO-NEXT: #0 0x{{.*}}
+  // TWO-NEXT: #1 0x{{.*}} in main {{.*}}malloc_context_size.cc
+  // TWO: SUMMARY: AddressSanitizer: heap-use-after-free
+}
diff --git a/compiler-rt/test/asan/TestCases/malloc_fill.cc b/compiler-rt/test/asan/TestCases/malloc_fill.cc
new file mode 100644
index 0000000..c897bbb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/malloc_fill.cc
@@ -0,0 +1,22 @@
+// Check that we fill malloc-ed memory correctly.
+// RUN: %clangxx_asan %s -o %t
+// RUN: %run %t | FileCheck %s
+// RUN: %env_asan_opts=max_malloc_fill_size=10:malloc_fill_byte=8 %run %t | FileCheck %s --check-prefix=CHECK-10-8
+// RUN: %env_asan_opts=max_malloc_fill_size=20:malloc_fill_byte=171 %run %t | FileCheck %s --check-prefix=CHECK-20-ab
+
+#include <stdio.h>
+int main(int argc, char **argv) {
+  // With asan allocator this makes sure we get memory from mmap.
+  static const int kSize = 1 << 25;
+  unsigned char *x = new unsigned char[kSize];
+  printf("-");
+  for (int i = 0; i <= 32; i++) {
+    printf("%02x", x[i]);
+  }
+  printf("-\n");
+  delete [] x;
+}
+
+// CHECK: -bebebebebebebebebebebebebebebebebebebebebebebebebebebebebebebebebe-
+// CHECK-10-8: -080808080808080808080000000000000000000000000000000000000000000000-
+// CHECK-20-ab: -abababababababababababababababababababab00000000000000000000000000-
diff --git a/compiler-rt/test/asan/TestCases/max_redzone.cc b/compiler-rt/test/asan/TestCases/max_redzone.cc
new file mode 100644
index 0000000..e2a0a2b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/max_redzone.cc
@@ -0,0 +1,26 @@
+// Test max_redzone runtime option.
+
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=max_redzone=16 %run %t 0 2>&1
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 1 2>&1
+// RUN: %clangxx_asan -O3 %s -o %t && %env_asan_opts=max_redzone=16 %run %t 0 2>&1
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t 1 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sanitizer/allocator_interface.h>
+
+int main(int argc, char **argv) {
+  if (argc < 2)
+    return 1;
+  bool large_redzone = atoi(argv[1]);
+  size_t before = __sanitizer_get_heap_size();
+  void *pp[10000];
+  for (int i = 0; i < 10000; ++i)
+    pp[i] = malloc(4096 - 64);
+  size_t after = __sanitizer_get_heap_size();
+  for (int i = 0; i < 10000; ++i)
+    free(pp[i]);
+  size_t diff = after - before;
+  return !(large_redzone ? diff > 46000000 : diff < 46000000);
+}
diff --git a/compiler-rt/test/asan/TestCases/memcmp_strict_test.cc b/compiler-rt/test/asan/TestCases/memcmp_strict_test.cc
new file mode 100644
index 0000000..61ffe8b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/memcmp_strict_test.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=strict_memcmp=0 %run %t
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=strict_memcmp=1 not %run %t 2>&1 | FileCheck %s
+// Default to strict_memcmp=1.
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <string.h>
+int main() {
+  char kFoo[] = "foo";
+  char kFubar[] = "fubar";
+  int res = memcmp(kFoo, kFubar, strlen(kFubar));
+  printf("res: %d\n", res);
+  // CHECK: AddressSanitizer: stack-buffer-overflow
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/memcmp_test.cc b/compiler-rt/test/asan/TestCases/memcmp_test.cc
new file mode 100644
index 0000000..3b3b889
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/memcmp_test.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: compiler-rt-optimized
+
+#include <string.h>
+int main(int argc, char **argv) {
+  char a1[] = {argc, 2, 3, 4};
+  char a2[] = {1, 2*argc, 3, 4};
+  int res = memcmp(a1, a2, 4 + argc);  // BOOM
+  // CHECK: AddressSanitizer: stack-buffer-overflow
+  // CHECK: {{#0.*memcmp}}
+  // CHECK: {{#1.*main}}
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/memset_test.cc b/compiler-rt/test/asan/TestCases/memset_test.cc
new file mode 100644
index 0000000..e244d54
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/memset_test.cc
@@ -0,0 +1,71 @@
+// Test that large memset/memcpy/memmove check the entire range.
+
+// RUN: %clangxx_asan -O0 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMSET
+// RUN: %clangxx_asan -O1 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMSET
+// RUN: %clangxx_asan -O2 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMSET
+// RUN: %clangxx_asan -O3 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMSET
+
+// RUN: %clangxx_asan -O0 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMCPY
+// RUN: %clangxx_asan -O1 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMCPY
+// RUN: %clangxx_asan -O2 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMCPY
+// RUN: %clangxx_asan -O3 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMCPY
+
+// RUN: %clangxx_asan -O0 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMMOVE
+// RUN: %clangxx_asan -O1 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMMOVE
+// RUN: %clangxx_asan -O2 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMMOVE
+// RUN: %clangxx_asan -O3 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMMOVE
+
+// RUN: %clangxx_asan -O2 -DTEST_MEMCPY_SIZE_OVERFLOW %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-MEMCPY_SIZE_OVERFLOW
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <sanitizer/asan_interface.h>
+
+typedef void *(*memcpy_t)(void *, const void *, size_t);
+
+int main(int argc, char **argv) {
+  char * volatile p = (char *)malloc(3000);
+  __asan_poison_memory_region(p + 512, 16);
+#if defined(TEST_MEMSET)
+  memset(p, 0, 3000);
+  assert(p[1] == 0);
+  // CHECK-MEMSET: AddressSanitizer: use-after-poison on address
+  // CHECK-MEMSET: in {{.*}}memset
+#else
+  char * volatile q = (char *)malloc(3000);
+#if defined(TEST_MEMCPY)
+  memcpy(q, p, 3000);
+  // CHECK-MEMCPY: AddressSanitizer: use-after-poison on address
+  // On Mac, memmove and memcpy are the same. Accept either one.
+  // CHECK-MEMCPY: in {{.*(memmove|memcpy)}}
+#elif defined(TEST_MEMMOVE)
+  memmove(q, p, 3000);
+  // CHECK-MEMMOVE: AddressSanitizer: use-after-poison on address
+  // CHECK-MEMMOVE: in {{.*(memmove|memcpy)}}
+#elif defined(TEST_MEMCPY_SIZE_OVERFLOW)
+  volatile memcpy_t my_memcpy = &memcpy;
+  my_memcpy(p, q, -argc);
+  // CHECK-MEMCPY_SIZE_OVERFLOW: AddressSanitizer: negative-size-param: (size=-1)
+#endif
+  assert(q[1] == 0);
+  free(q);
+#endif
+  free(p);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/mmap_limit_mb.cc b/compiler-rt/test/asan/TestCases/mmap_limit_mb.cc
new file mode 100644
index 0000000..3795241
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/mmap_limit_mb.cc
@@ -0,0 +1,35 @@
+// Test the mmap_limit_mb flag.
+//
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: %run %t 20 16
+// RUN: %run %t 30 1000000
+// RUN: %env_asan_opts=mmap_limit_mb=300 %run %t 20 16
+// RUN: %env_asan_opts=mmap_limit_mb=300 %run %t 20 1000000
+// RUN: %env_asan_opts=mmap_limit_mb=300 not %run %t 500 16 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=mmap_limit_mb=300 not %run %t 500 1000000 2>&1 | FileCheck %s
+//
+// FIXME: Windows doesn't implement mmap_limit_mb.
+// XFAIL: arm-linux-gnueabi,win32
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <algorithm>
+#include <vector>
+
+int main(int argc, char **argv) {
+  assert(argc == 3);
+  long total_mb = atoi(argv[1]);
+  long allocation_size = atoi(argv[2]);
+  fprintf(stderr, "total_mb: %zd allocation_size: %zd\n", total_mb,
+          allocation_size);
+  std::vector<char *> v;
+  for (long total = total_mb << 20; total > 0; total -= allocation_size)
+    v.push_back(new char[allocation_size]);
+  for (std::vector<char *>::const_iterator it = v.begin(); it != v.end(); ++it)
+    delete[](*it);
+  fprintf(stderr, "PASS\n");
+  // CHECK: total_mmaped{{.*}}mmap_limit_mb
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/no_asan_gen_globals.c b/compiler-rt/test/asan/TestCases/no_asan_gen_globals.c
new file mode 100644
index 0000000..2b13dea
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/no_asan_gen_globals.c
@@ -0,0 +1,13 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+// FIXME: http://llvm.org/bugs/show_bug.cgi?id=22682
+// REQUIRES: asan-64-bits
+//
+// Make sure __asan_gen_* strings do not end up in the symbol table.
+
+// RUN: %clang_asan %s -o %t.exe
+// RUN: nm %t.exe | FileCheck %s
+
+int x, y, z;
+int main() { return 0; }
+// CHECK-NOT: __asan_gen_
diff --git a/compiler-rt/test/asan/TestCases/null_deref.cc b/compiler-rt/test/asan/TestCases/null_deref.cc
new file mode 100644
index 0000000..04576b4
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/null_deref.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+__attribute__((noinline))
+// FIXME: Static symbols don't show up in PDBs. We can remove this once we start
+// using DWARF.
+#ifndef _MSC_VER
+static
+#endif
+void NullDeref(int *ptr) {
+  // CHECK: ERROR: AddressSanitizer: {{SEGV|access-violation}} on unknown address
+  // CHECK:   {{0x0*000.. .*pc 0x.*}}
+  ptr[10]++;  // BOOM
+  // atos on Mac cannot extract the symbol name correctly. Also, on FreeBSD 9.2
+  // the demangling function rejects local names with 'L' in front of them.
+  // CHECK: {{    #0 0x.* in .*NullDeref.*null_deref.cc:}}[[@LINE-3]]
+}
+int main() {
+  NullDeref((int*)0);
+  // CHECK: {{    #1 0x.* in main.*null_deref.cc:}}[[@LINE-1]]
+  // CHECK: AddressSanitizer can not provide additional info.
+}
diff --git a/compiler-rt/test/asan/TestCases/on_error_callback.cc b/compiler-rt/test/asan/TestCases/on_error_callback.cc
new file mode 100644
index 0000000..88a4d2d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/on_error_callback.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+extern "C"
+void __asan_on_error() {
+  fprintf(stderr, "__asan_on_error called\n");
+  fflush(stderr);
+}
+
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: __asan_on_error called
+}
diff --git a/compiler-rt/test/asan/TestCases/partial_right.cc b/compiler-rt/test/asan/TestCases/partial_right.cc
new file mode 100644
index 0000000..b60c1a5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/partial_right.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  volatile int *x = (int*)malloc(2*sizeof(int) + 2);
+  int res = x[2];  // BOOOM
+  // CHECK: {{READ of size 4 at 0x.* thread T0}}
+  // CHECK: [[ADDR:0x[01-9a-fa-f]+]] is located 0 bytes to the right of {{.*}}-byte region [{{.*}},{{.*}}[[ADDR]])
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/poison_partial.cc b/compiler-rt/test/asan/TestCases/poison_partial.cc
new file mode 100644
index 0000000..3a1b419
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/poison_partial.cc
@@ -0,0 +1,19 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t      2>&1 | FileCheck %s
+// RUN: not %run %t heap 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=poison_partial=0 %run %t
+// RUN: %env_asan_opts=poison_partial=0 %run %t heap
+#include <string.h>
+char g[21];
+char *x;
+
+int main(int argc, char **argv) {
+  if (argc >= 2)
+    x = new char[21];
+  else
+    x = &g[0];
+  memset(x, 0, 21);
+  int *y = (int*)x;
+  return y[5];
+}
+// CHECK: 0 bytes to the right
diff --git a/compiler-rt/test/asan/TestCases/print_summary.cc b/compiler-rt/test/asan/TestCases/print_summary.cc
new file mode 100644
index 0000000..3983ebc
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/print_summary.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=SOURCE
+// RUN: %env_asan_opts=symbolize=false not %run %t 2>&1 | FileCheck %s --check-prefix=MODULE
+// RUN: %env_asan_opts=print_summary=false not %run %t 2>&1 | FileCheck %s --check-prefix=MISSING
+
+int main() {
+  char *x = new char[20];
+  delete[] x;
+  return x[0];
+  // SOURCE: ERROR: AddressSanitizer: heap-use-after-free
+  // SOURCE: SUMMARY: AddressSanitizer: heap-use-after-free {{.*}}print_summary.cc:[[@LINE-2]]{{.*}} main
+  // MODULE: ERROR: AddressSanitizer: heap-use-after-free
+  // MODULE: SUMMARY: AddressSanitizer: heap-use-after-free ({{.*}}+0x{{.*}})
+  // MISSING: ERROR: AddressSanitizer: heap-use-after-free
+  // MISSING-NOT: SUMMARY
+}
diff --git a/compiler-rt/test/asan/TestCases/printf-1.c b/compiler-rt/test/asan/TestCases/printf-1.c
new file mode 100644
index 0000000..fd009d1
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/printf-1.c
@@ -0,0 +1,25 @@
+// RUN: %clang_asan -O2 %s -o %t
+// RUN: %env_asan_opts=check_printf=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=check_printf=0 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#if defined(_WIN32)
+# define snprintf _snprintf
+#endif
+
+int main() {
+  volatile char c = '0';
+  volatile int x = 12;
+  volatile float f = 1.239;
+  volatile char s[] = "34";
+  // Check that printf works fine under Asan.
+  printf("%c %d %.3f %s\n", c, x, f, s);
+  // CHECK: 0 12 1.239 34
+  // Check that snprintf works fine under Asan.
+  char buf[4];
+  snprintf(buf, 1000, "qwe");
+  printf("%s\n", buf);
+  // CHECK: qwe
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/printf-2.c b/compiler-rt/test/asan/TestCases/printf-2.c
new file mode 100644
index 0000000..4b5ae13
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/printf-2.c
@@ -0,0 +1,27 @@
+// RUN: %clang_asan -O2 %s -o %t
+// We need replace_str=0 and replace_intrin=0 to avoid reporting errors in
+// strlen() and memcpy() called by printf().
+// RUN: %env_asan_opts=replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+// RUN: %env_asan_opts=replace_str=0:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
+// RUN: %env_asan_opts=replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+
+// FIXME: printf is not intercepted on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main() {
+  volatile char c = '0';
+  volatile int x = 12;
+  volatile float f = 1.239;
+  volatile char s[] = "34";
+  char *p = strdup((const char *)s);
+  free(p);
+  printf("%c %d %.3f %s\n", c, x, f, p);
+  return 0;
+  // Check that %s is sanitized.
+  // CHECK-ON: heap-use-after-free
+  // CHECK-ON-NOT: 0 12 1.239 34
+  // CHECK-OFF: 0 12 1.239 
+}
diff --git a/compiler-rt/test/asan/TestCases/printf-3.c b/compiler-rt/test/asan/TestCases/printf-3.c
new file mode 100644
index 0000000..010e6c8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/printf-3.c
@@ -0,0 +1,26 @@
+// RUN: %clang_asan -O2 %s -o %t
+// RUN: %env_asan_opts=check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+// RUN: %env_asan_opts=check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+
+// FIXME: printf is not intercepted on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+int main() {
+#ifdef _MSC_VER
+  // FIXME: The test raises a dialog even though it's XFAILd.
+  return 42;
+#endif
+  volatile char c = '0';
+  volatile int x = 12;
+  volatile float f = 1.239;
+  volatile char s[] = "34";
+  volatile int n[1];
+  printf("%c %d %.3f %s%n\n", c, x, f, s, &n[1]);
+  return 0;
+  // Check that %n is sanitized.
+  // CHECK-ON: stack-buffer-overflow
+  // CHECK-ON-NOT: 0 12 1.239 34
+  // CHECK-OFF: 0 12 1.239 34
+}
diff --git a/compiler-rt/test/asan/TestCases/printf-4.c b/compiler-rt/test/asan/TestCases/printf-4.c
new file mode 100644
index 0000000..13bfc87
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/printf-4.c
@@ -0,0 +1,23 @@
+// RUN: %clang_asan -O2 %s -o %t
+// We need replace_str=0 and replace_intrin=0 to avoid reporting errors in
+// strlen() and memcpy() called by puts().
+// RUN: %env_asan_opts=replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+// RUN: %env_asan_opts=replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+
+// FIXME: printf is not intercepted on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+int main() {
+  volatile char c = '0';
+  volatile int x = 12;
+  volatile float f = 1.239;
+  volatile char s[] = "34";
+  volatile char buf[2];
+  sprintf((char *)buf, "%c %d %.3f %s\n", c, x, f, s);
+  puts((const char *)buf);
+  return 0;
+  // Check that size of output buffer is sanitized.
+  // CHECK-ON: stack-buffer-overflow
+  // CHECK-ON-NOT: 0 12 1.239 34
+}
diff --git a/compiler-rt/test/asan/TestCases/printf-5.c b/compiler-rt/test/asan/TestCases/printf-5.c
new file mode 100644
index 0000000..a614462
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/printf-5.c
@@ -0,0 +1,25 @@
+// RUN: %clang_asan -O2 %s -o %t
+// We need replace_intrin=0 to avoid reporting errors in memcpy.
+// RUN: %env_asan_opts=replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+// RUN: %env_asan_opts=replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
+// RUN: %env_asan_opts=replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
+
+// FIXME: printf is not intercepted on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+#include <string.h>
+int main() {
+  volatile char c = '0';
+  volatile int x = 12;
+  volatile float f = 1.239;
+  volatile char s[] = "34";
+  volatile char fmt[2];
+  memcpy((char *)fmt, "%c %d %f %s\n", sizeof(fmt));
+  printf((char *)fmt, c, x, f, s);
+  return 0;
+  // Check that format string is sanitized.
+  // CHECK-ON: stack-buffer-overflow
+  // CHECK-ON-NOT: 0 12 1.239 34
+  // CHECK-OFF: 0
+}
diff --git a/compiler-rt/test/asan/TestCases/sanity_check_pure_c.c b/compiler-rt/test/asan/TestCases/sanity_check_pure_c.c
new file mode 100644
index 0000000..c3a43c8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/sanity_check_pure_c.c
@@ -0,0 +1,21 @@
+// Sanity checking a test in pure C.
+// RUN: %clang_asan -O2 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+// Sanity checking a test in pure C with -pie.
+// RUN: %clang_asan -O2 %s -pie -fPIE -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: heap-use-after-free
+  // CHECK: free
+  // CHECK: main{{.*}}sanity_check_pure_c.c:[[@LINE-4]]
+  // CHECK: malloc
+  // CHECK: main{{.*}}sanity_check_pure_c.c:[[@LINE-7]]
+}
diff --git a/compiler-rt/test/asan/TestCases/sleep_before_dying.c b/compiler-rt/test/asan/TestCases/sleep_before_dying.c
new file mode 100644
index 0000000..8a50218
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/sleep_before_dying.c
@@ -0,0 +1,10 @@
+// RUN: %clang_asan -O2 %s -o %t
+// RUN: %env_asan_opts=sleep_before_dying=1 not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: Sleeping for 1 second
+}
diff --git a/compiler-rt/test/asan/TestCases/speculative_load.cc b/compiler-rt/test/asan/TestCases/speculative_load.cc
new file mode 100644
index 0000000..2409d7a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/speculative_load.cc
@@ -0,0 +1,50 @@
+// Verifies that speculative loads from unions do not happen under asan.
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_asan -O2 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1
+
+#include <sanitizer/asan_interface.h>
+
+struct S {
+  struct _long {
+      void* _pad;
+      const char* _ptr;
+  };
+
+  struct _short {
+    unsigned char _size;
+    char _ch[23];
+  };
+
+  union {
+    _short _s;
+    _long _l;
+  } _data;
+
+  S() {
+    _data._s._size = 0;
+    __asan_poison_memory_region(_data._s._ch, 23);
+  }
+
+  bool is_long() const {
+    return _data._s._size & 1;
+  }
+
+  const char* get_pointer() const {
+    return is_long() ? _data._l._ptr : _data._s._ch;
+  }
+};
+
+
+inline void side_effect(const void *arg) {
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+}
+
+int main(int argc, char **argv) {
+  S s;
+  side_effect(&s); // optimizer is too smart otherwise
+  const char *ptr = s.get_pointer();
+  side_effect(ptr); // force use ptr
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/speculative_load2.cc b/compiler-rt/test/asan/TestCases/speculative_load2.cc
new file mode 100644
index 0000000..51051eb
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/speculative_load2.cc
@@ -0,0 +1,24 @@
+// Verifies that speculative loads from unions do not happen under asan.
+// RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_asan -O2 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1
+
+typedef union {
+  short q;
+  struct {
+    short x;
+    short y;
+    int for_alignment;
+  } w;
+} U;
+
+int main() {
+  char *buf = new char[2];
+  buf[0] = buf[1] = 0x0;
+  U *u = (U *)buf;
+  short result = u->q == 0 ? 0 : u->w.y;
+  delete[] buf;
+  return result;
+}
+
diff --git a/compiler-rt/test/asan/TestCases/stack-buffer-overflow-with-position.cc b/compiler-rt/test/asan/TestCases/stack-buffer-overflow-with-position.cc
new file mode 100644
index 0000000..88f5825
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/stack-buffer-overflow-with-position.cc
@@ -0,0 +1,44 @@
+// RUN: %clangxx_asan -O2 %s -o %t
+// RUN: not %run %t -2 2>&1 | FileCheck --check-prefix=CHECK-m2 %s
+// RUN: not %run %t -1 2>&1 | FileCheck --check-prefix=CHECK-m1 %s
+// RUN: %run %t 0
+// RUN: %run %t 8
+// RUN: not %run %t 9  2>&1 | FileCheck --check-prefix=CHECK-9  %s
+// RUN: not %run %t 10 2>&1 | FileCheck --check-prefix=CHECK-10 %s
+// RUN: not %run %t 30 2>&1 | FileCheck --check-prefix=CHECK-30 %s
+// RUN: not %run %t 31 2>&1 | FileCheck --check-prefix=CHECK-31 %s
+// RUN: not %run %t 41 2>&1 | FileCheck --check-prefix=CHECK-41 %s
+// RUN: not %run %t 42 2>&1 | FileCheck --check-prefix=CHECK-42 %s
+// RUN: not %run %t 62 2>&1 | FileCheck --check-prefix=CHECK-62 %s
+// RUN: not %run %t 63 2>&1 | FileCheck --check-prefix=CHECK-63 %s
+// RUN: not %run %t 73 2>&1 | FileCheck --check-prefix=CHECK-73 %s
+// RUN: not %run %t 74 2>&1 | FileCheck --check-prefix=CHECK-74 %s
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+int main(int argc, char **argv) {
+  assert(argc >= 2);
+  int idx = atoi(argv[1]);
+  char AAA[10], BBB[10], CCC[10];
+  memset(AAA, 0, sizeof(AAA));
+  memset(BBB, 0, sizeof(BBB));
+  memset(CCC, 0, sizeof(CCC));
+  int res = 0;
+  char *p = AAA + idx;
+  printf("AAA: %p\ny: %p\nz: %p\np: %p\n", AAA, BBB, CCC, p);
+  // make sure BBB and CCC are not removed;
+  return *(short*)(p) + BBB[argc % 2] + CCC[argc % 2];
+}
+// CHECK-m2: 'AAA' <== {{.*}}underflows this variable
+// CHECK-m1: 'AAA' <== {{.*}}partially underflows this variable
+// CHECK-9:  'AAA' <== {{.*}}partially overflows this variable
+// CHECK-10: 'AAA' <== {{.*}}overflows this variable
+// CHECK-30: 'BBB' <== {{.*}}underflows this variable
+// CHECK-31: 'BBB' <== {{.*}}partially underflows this variable
+// CHECK-41: 'BBB' <== {{.*}}partially overflows this variable
+// CHECK-42: 'BBB' <== {{.*}}overflows this variable
+// CHECK-62: 'CCC' <== {{.*}}underflows this variable
+// CHECK-63: 'CCC' <== {{.*}}partially underflows this variable
+// CHECK-73: 'CCC' <== {{.*}}partially overflows this variable
+// CHECK-74: 'CCC' <== {{.*}}overflows this variable
diff --git a/compiler-rt/test/asan/TestCases/stack-buffer-overflow.cc b/compiler-rt/test/asan/TestCases/stack-buffer-overflow.cc
new file mode 100644
index 0000000..bd0c477
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/stack-buffer-overflow.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <string.h>
+int main(int argc, char **argv) {
+  char x[10];
+  memset(x, 0, 10);
+  int res = x[argc * 10];  // BOOOM
+  // CHECK: {{READ of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main .*stack-buffer-overflow.cc:}}[[@LINE-2]]
+  // CHECK: {{Address 0x.* is located in stack of thread T0 at offset}}
+  // CHECK-NEXT: in{{.*}}main{{.*}}stack-buffer-overflow.cc
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/stack-frame-demangle.cc b/compiler-rt/test/asan/TestCases/stack-frame-demangle.cc
new file mode 100644
index 0000000..11a8b38
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/stack-frame-demangle.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <string.h>
+
+namespace XXX {
+struct YYY {
+  static int ZZZ(int x) {
+    char array[10];
+    memset(array, 0, 10);
+    return array[x];  // BOOOM
+    // CHECK: ERROR: AddressSanitizer: stack-buffer-overflow
+    // CHECK: READ of size 1 at
+    // CHECK: is located in stack of thread T0 at offset
+    // CHECK: XXX::YYY::ZZZ
+  }
+};
+}  // namespace XXX
+
+int main(int argc, char **argv) {
+  int res = XXX::YYY::ZZZ(argc + 10);
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/stack-oob-frames.cc b/compiler-rt/test/asan/TestCases/stack-oob-frames.cc
new file mode 100644
index 0000000..00db4b3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/stack-oob-frames.cc
@@ -0,0 +1,62 @@
+// RUN: %clangxx_asan -O1 %s -o %t
+// RUN: not %run %t 0 2>&1 | FileCheck %s --check-prefix=CHECK0
+// RUN: not %run %t 1 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: not %run %t 2 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: not %run %t 3 2>&1 | FileCheck %s --check-prefix=CHECK3
+
+// FIXME: Symbolization problems.
+// XFAIL: win32
+
+#define NOINLINE __attribute__((noinline))
+inline void break_optimization(void *arg) {
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+}
+
+NOINLINE static void Frame0(int frame, char *a, char *b, char *c) {
+  char s[4] = {0};
+  char *d = s;
+  break_optimization(&d);
+  switch (frame) {
+    case 3: a[5]++; break;
+    case 2: b[5]++; break;
+    case 1: c[5]++; break;
+    case 0: d[5]++; break;
+  }
+}
+NOINLINE static void Frame1(int frame, char *a, char *b) {
+  char c[4] = {0}; Frame0(frame, a, b, c);
+  break_optimization(0);
+}
+NOINLINE static void Frame2(int frame, char *a) {
+  char b[4] = {0}; Frame1(frame, a, b);
+  break_optimization(0);
+}
+NOINLINE static void Frame3(int frame) {
+  char a[4] = {0}; Frame2(frame, a);
+  break_optimization(0);
+}
+
+int main(int argc, char **argv) {
+  if (argc != 2) return 1;
+  Frame3(argv[1][0] - '0');
+}
+
+// CHECK0: AddressSanitizer: stack-buffer-overflow
+// CHECK0: #0{{.*}}Frame0
+// CHECK0: #1{{.*}}Frame1
+// CHECK0: #2{{.*}}Frame2
+// CHECK0: #3{{.*}}Frame3
+// CHECK0: is located in stack of thread T0 at offset
+// CHECK0-NEXT: #0{{.*}}Frame0
+//
+// CHECK1: AddressSanitizer: stack-buffer-overflow
+// CHECK1: is located in stack of thread T0 at offset
+// CHECK1-NEXT: #0{{.*}}Frame1
+//
+// CHECK2: AddressSanitizer: stack-buffer-overflow
+// CHECK2: is located in stack of thread T0 at offset
+// CHECK2-NEXT: #0{{.*}}Frame2
+//
+// CHECK3: AddressSanitizer: stack-buffer-overflow
+// CHECK3: is located in stack of thread T0 at offset
+// CHECK3-NEXT: #0{{.*}}Frame3
diff --git a/compiler-rt/test/asan/TestCases/strcasestr-1.c b/compiler-rt/test/asan/TestCases/strcasestr-1.c
new file mode 100644
index 0000000..c38871e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcasestr-1.c
@@ -0,0 +1,25 @@
+// Test haystack overflow in strcasestr function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strstr asan option
+// Disable other interceptors because strlen may be called inside strcasestr
+// RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
+
+// There's no interceptor for strcasestr on Windows
+// XFAIL: win32
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s2[] = "c";
+  char s1[4] = "abC";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
+  r = strcasestr(s1, s2);
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == s1 + 2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcasestr-2.c b/compiler-rt/test/asan/TestCases/strcasestr-2.c
new file mode 100644
index 0000000..cca6d20
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcasestr-2.c
@@ -0,0 +1,25 @@
+// Test needle overflow in strcasestr function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strstr asan option
+// Disable other interceptors because strlen may be called inside strcasestr
+// RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
+
+// There's no interceptor for strcasestr on Windows
+// XFAIL: win32
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s1[] = "ab";
+  char s2[4] = "cba";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
+  r = strcasestr(s1, s2);
+  assert(r == 0);
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcasestr_strict.c b/compiler-rt/test/asan/TestCases/strcasestr_strict.c
new file mode 100644
index 0000000..956bee7
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcasestr_strict.c
@@ -0,0 +1,28 @@
+// Test strict_string_checks option in strcasestr function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// There's no interceptor for strcasestr on Windows
+// XFAIL: win32
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char *s1 = (char*)malloc(size);
+  char *s2 = (char*)malloc(size);
+  memset(s1, 'o', size);
+  memset(s2, 'O', size);
+  s2[size - 1]='\0';
+  char* r = strcasestr(s1, s2);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == s1);
+  free(s1);
+  free(s2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcat_strict.c b/compiler-rt/test/asan/TestCases/strcat_strict.c
new file mode 100644
index 0000000..6e9bd8e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcat_strict.c
@@ -0,0 +1,44 @@
+// Test strict_string_checks option in strcat function
+// RUN: %clang_asan %s -o %t
+// RUN: not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
+// RUN: %env_asan_opts=strict_string_checks=false not  %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-STRICT --check-prefix=CHECK1
+// RUN: not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
+// RUN: %env_asan_opts=strict_string_checks=false not  %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-STRICT --check-prefix=CHECK2
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1(char *to, int to_size, char *from) {
+  // One of arguments points to not allocated memory.
+  char* r = strcat(to + to_size, from);
+}
+
+void test2(char *to, int to_size, char *from) {
+  // "to" is not zero-terminated.
+  memset(to, 'z', to_size);
+  char* r = strcat(to, from);
+}
+
+int main(int argc, char **argv) {
+  size_t to_size = 100;
+  char *to = (char*)malloc(to_size);
+  size_t from_size = 20;
+  char *from = (char*)malloc(from_size);
+  memset(from, 'z', from_size);
+  from[from_size - 1] = '\0';
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(to, to_size, from);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1-STRICT: READ of size 1
+  // CHECK1-NONSTRICT: WRITE of size 20
+  if (!strcmp(argv[1], "test2")) test2(to, to_size, from);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2-STRICT: READ of size 101
+  // CHECK2-NONSTRICT: WRITE of size 20
+  free(to);
+  free(from);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strchr_strict.c b/compiler-rt/test/asan/TestCases/strchr_strict.c
new file mode 100644
index 0000000..b2dbaa5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strchr_strict.c
@@ -0,0 +1,22 @@
+// Test strict_string_checks option in strchr function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char fill = 'o';
+  char *s = (char*)malloc(size);
+  memset(s, fill, size);
+  char c = 'o';
+  char* r = strchr(s, c);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == s);
+  free(s);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcmp_strict.c b/compiler-rt/test/asan/TestCases/strcmp_strict.c
new file mode 100644
index 0000000..e168923
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcmp_strict.c
@@ -0,0 +1,26 @@
+// Test strict_string_checks option in strcmp function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char fill = 'o';
+  char *s1 = (char*)malloc(size);
+  memset(s1, fill, size);
+  char *s2 = (char*)malloc(size);
+  memset(s2, fill, size);
+  s1[size - 1] = 'z';
+  s2[size - 1] = 'x';
+  int r = strcmp(s1, s2);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == 1);
+  free(s1);
+  free(s2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcspn-1.c b/compiler-rt/test/asan/TestCases/strcspn-1.c
new file mode 100644
index 0000000..6cda2e2
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcspn-1.c
@@ -0,0 +1,20 @@
+// Test string s1 overflow in strcspn function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strspn asan option
+// RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  size_t r;
+  char s2[] = "ab";
+  char s1[4] = "caB";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
+  r = strcspn(s1, s2);
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == 1);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcspn-2.c b/compiler-rt/test/asan/TestCases/strcspn-2.c
new file mode 100644
index 0000000..8bb4b8a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcspn-2.c
@@ -0,0 +1,20 @@
+// Test stopset overflow in strcspn function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strcspn asan option
+// RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  size_t r;
+  char s1[] = "ab";
+  char s2[4] = "abc";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
+  r = strcspn(s1, s2);
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == 0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strcspn_strict.c b/compiler-rt/test/asan/TestCases/strcspn_strict.c
new file mode 100644
index 0000000..e7c1e6a
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strcspn_strict.c
@@ -0,0 +1,26 @@
+// Test strict_string_checks option in strcspn function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char fill = 'o';
+  char *s1 = (char*)malloc(size);
+  char *s2 = (char*)malloc(size);
+  memset(s1, fill, size);
+  s1[0] = 'z';
+  memset(s2, fill, size);
+  s2[size-1] = '\0';
+  size_t r = strcspn(s1, s2);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == 1);
+  free(s1);
+  free(s2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strdup_oob_test.cc b/compiler-rt/test/asan/TestCases/strdup_oob_test.cc
new file mode 100644
index 0000000..a039568
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strdup_oob_test.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <string.h>
+
+char kString[] = "foo";
+
+int main(int argc, char **argv) {
+  char *copy = strdup(kString);
+  int x = copy[4 + argc];  // BOOM
+  // CHECK: AddressSanitizer: heap-buffer-overflow
+  // CHECK: #0 {{.*}}main {{.*}}strdup_oob_test.cc:[[@LINE-2]]
+  // CHECK-LABEL: allocated by thread T{{.*}} here:
+  // CHECK: #{{[01]}} {{.*}}strdup
+  // CHECK-LABEL: SUMMARY
+  // CHECK: strdup_oob_test.cc:[[@LINE-6]]
+  return x;
+}
diff --git a/compiler-rt/test/asan/TestCases/strip_path_prefix.c b/compiler-rt/test/asan/TestCases/strip_path_prefix.c
new file mode 100644
index 0000000..e77f1d5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strip_path_prefix.c
@@ -0,0 +1,12 @@
+// RUN: %clang_asan -O2 %s -o %t
+// RUN: %env_asan_opts=strip_path_prefix='"%S/"' not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // Check that paths in error report don't start with slash.
+  // CHECK: heap-use-after-free
+  // CHECK: #0 0x{{.*}} in main {{.*}}strip_path_prefix.c:[[@LINE-3]]
+}
diff --git a/compiler-rt/test/asan/TestCases/strncat_strict.c b/compiler-rt/test/asan/TestCases/strncat_strict.c
new file mode 100644
index 0000000..2b44b56
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strncat_strict.c
@@ -0,0 +1,44 @@
+// Test strict_string_checks option in strncat function
+// RUN: %clang_asan %s -o %t
+// RUN: not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
+// RUN: %env_asan_opts=strict_string_checks=false not  %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-STRICT --check-prefix=CHECK1
+// RUN: not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
+// RUN: %env_asan_opts=strict_string_checks=false not  %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-STRICT --check-prefix=CHECK2
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1(char *to, int to_size, char *from) {
+  // One of arguments points to not allocated memory.
+  char* r = strncat(to + to_size, from, 2);
+}
+
+void test2(char *to, int to_size, char *from) {
+  // "to" is not zero-terminated.
+  memset(to, 'z', to_size);
+  char* r = strncat(to, from, 1);
+}
+
+int main(int argc, char **argv) {
+  size_t to_size = 100;
+  char *to = (char*)malloc(to_size);
+  size_t from_size = 20;
+  char *from = (char*)malloc(from_size);
+  memset(from, 'z', from_size);
+  from[from_size - 1] = '\0';
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(to, to_size, from);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1-STRICT: READ of size 1
+  // CHECK1-NONSTRICT: WRITE of size 3
+  if (!strcmp(argv[1], "test2")) test2(to, to_size, from);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2-STRICT: READ of size 101
+  // CHECK2-NONSTRICT: WRITE of size 2
+  free(to);
+  free(from);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strncpy-overflow.cc b/compiler-rt/test/asan/TestCases/strncpy-overflow.cc
new file mode 100644
index 0000000..651ae22
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strncpy-overflow.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+
+// REQUIRES: compiler-rt-optimized
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <string.h>
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  char *hello = (char*)malloc(6);
+  strcpy(hello, "hello");
+  char *short_buffer = (char*)malloc(9);
+  strncpy(short_buffer, hello, 10);  // BOOM
+  // CHECK: {{WRITE of size 10 at 0x.* thread T0}}
+  // CHECK-Linux: {{    #0 0x.* in .*strncpy}}
+  // CHECK-Darwin: {{    #0 0x.* in wrap_strncpy}}
+  // CHECK: {{    #1 0x.* in main .*strncpy-overflow.cc:}}[[@LINE-4]]
+  // CHECK: {{0x.* is located 0 bytes to the right of 9-byte region}}
+  // CHECK: {{allocated by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in .*malloc}}
+  // CHECK-Linux: {{    #1 0x.* in main .*strncpy-overflow.cc:}}[[@LINE-10]]
+
+  // CHECK-Darwin: {{    #0 0x.* in wrap_malloc.*}}
+  // CHECK-Darwin: {{    #1 0x.* in main .*strncpy-overflow.cc:}}[[@LINE-13]]
+  return short_buffer[8];
+}
diff --git a/compiler-rt/test/asan/TestCases/strpbrk-1.c b/compiler-rt/test/asan/TestCases/strpbrk-1.c
new file mode 100644
index 0000000..626e877
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strpbrk-1.c
@@ -0,0 +1,20 @@
+// Test string s1 overflow in strpbrk function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strpbrk asan option
+// RUN: %env_asan_opts=intercept_strpbrk=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  char *r;
+  char s2[] = "ab";
+  char s1[4] = "cab";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
+  r = strpbrk(s1, s2);
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == s1 + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strpbrk-2.c b/compiler-rt/test/asan/TestCases/strpbrk-2.c
new file mode 100644
index 0000000..29f3150
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strpbrk-2.c
@@ -0,0 +1,20 @@
+// Test stopset overflow in strpbrk function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strpbrk asan option
+// RUN: %env_asan_opts=intercept_strpbrk=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  char *r;
+  char s1[] = "c";
+  char s2[4] = "bca";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
+  r = strpbrk(s1, s2);
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == s1);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strpbrk_strict.c b/compiler-rt/test/asan/TestCases/strpbrk_strict.c
new file mode 100644
index 0000000..131886e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strpbrk_strict.c
@@ -0,0 +1,25 @@
+// Test strict_string_checks option in strpbrk function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char fill = 'o';
+  char *s1 = (char*)malloc(size);
+  char *s2 = (char*)malloc(2);
+  memset(s1, fill, size);
+  s2[0] = fill;
+  s2[1]='\0';
+  char* r = strpbrk(s1, s2);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == s1);
+  free(s1);
+  free(s2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strspn-1.c b/compiler-rt/test/asan/TestCases/strspn-1.c
new file mode 100644
index 0000000..b0c40ea
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strspn-1.c
@@ -0,0 +1,20 @@
+// Test string s1 overflow in strspn function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strspn asan option
+// RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  size_t r;
+  char s2[] = "ab";
+  char s1[4] = "acb";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
+  r = strspn(s1, s2);
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == 1);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strspn-2.c b/compiler-rt/test/asan/TestCases/strspn-2.c
new file mode 100644
index 0000000..4c89910
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strspn-2.c
@@ -0,0 +1,20 @@
+// Test stopset overflow in strspn function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strspn asan option
+// RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  size_t r;
+  char s1[] = "bbc";
+  char s2[5] = "abcd";
+  __asan_poison_memory_region ((char *)&s2[3], 2);
+  r = strspn(s1, s2);
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r >= 2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strspn_strict.c b/compiler-rt/test/asan/TestCases/strspn_strict.c
new file mode 100644
index 0000000..eee1925
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strspn_strict.c
@@ -0,0 +1,25 @@
+// Test strict_str`ing_checks option in strspn function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char fill = 'o';
+  char *s1 = (char*)malloc(size);
+  char *s2 = (char*)malloc(2);
+  memset(s1, fill, size);
+  s1[0] = s2[0] = 'z';
+  s2[1] = '\0';
+  size_t r = strspn(s1, s2);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == 1);
+  free(s1);
+  free(s2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strstr-1.c b/compiler-rt/test/asan/TestCases/strstr-1.c
new file mode 100644
index 0000000..d0fa25b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strstr-1.c
@@ -0,0 +1,21 @@
+// Test haystack overflow in strstr function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strstr asan option
+// Disable other interceptors because strlen may be called inside strstr
+// RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s2[] = "c";
+  char s1[4] = "acb";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
+  r = strstr(s1, s2);
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == s1 + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strstr-2.c b/compiler-rt/test/asan/TestCases/strstr-2.c
new file mode 100644
index 0000000..edb7008
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strstr-2.c
@@ -0,0 +1,21 @@
+// Test needle overflow in strstr function
+// RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+// Test intercept_strstr asan option
+// Disable other interceptors because strlen may be called inside strstr
+// RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s1[] = "ab";
+  char s2[4] = "cab";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
+  r = strstr(s1, s2);
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == 0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strstr_strict.c b/compiler-rt/test/asan/TestCases/strstr_strict.c
new file mode 100644
index 0000000..35ad93c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strstr_strict.c
@@ -0,0 +1,25 @@
+// Test strict_string_checks option in strstr function
+// RUN: %clang_asan %s -o %t && %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t size = 100;
+  char fill = 'o';
+  char *s1 = (char*)malloc(size);
+  char *s2 = (char*)malloc(size);
+  memset(s1, fill, size);
+  memset(s2, fill, size);
+  s2[size - 1]='\0';
+  char* r = strstr(s1, s2);
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK: READ of size 101
+  assert(r == s1);
+  free(s1);
+  free(s2);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strtol_strict.c b/compiler-rt/test/asan/TestCases/strtol_strict.c
new file mode 100644
index 0000000..999067e
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strtol_strict.c
@@ -0,0 +1,135 @@
+// Test strict_string_checks option in strtol function
+// RUN: %clang_asan -D_CRT_SECURE_NO_WARNINGS -DTEST1 %s -o %t
+// RUN: %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
+// RUN: %run %t test4 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test4 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test4 2>&1 | FileCheck %s --check-prefix=CHECK4
+// RUN: %run %t test5 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test5 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5
+// RUN: %run %t test6 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test6 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
+// RUN: %run %t test7 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test7 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+void test1(char *array, char *endptr) {
+  // Buffer overflow if there is no terminating null (depends on base)
+  long r = strtol(array, &endptr, 3);
+  assert(array + 2 == endptr);
+  assert(r == 5);
+}
+
+void test2(char *array, char *endptr) {
+  // Buffer overflow if there is no terminating null (depends on base)
+  array[2] = 'z';
+  long r = strtol(array, &endptr, 35);
+  assert(array + 2 == endptr);
+  assert(r == 37);
+}
+
+void test3(char *array, char *endptr) {
+#ifdef _MSC_VER
+  // Using -1 for a strtol base causes MSVC to abort. Print the expected lines
+  // to make the test pass.
+  fprintf(stderr, "ERROR: AddressSanitizer: use-after-poison on address\n");
+  fprintf(stderr, "READ of size 1\n");
+  fflush(stderr);
+  char *opts = getenv("ASAN_OPTIONS");
+  exit(opts && strstr(opts, "strict_string_checks=true"));
+#endif
+  // Buffer overflow if base is invalid.
+  memset(array, 0, 8);
+  ASAN_POISON_MEMORY_REGION(array, 8);
+  long r = strtol(array + 1, NULL, -1);
+  assert(r == 0);
+  ASAN_UNPOISON_MEMORY_REGION(array, 8);
+}
+
+void test4(char *array, char *endptr) {
+#ifdef _MSC_VER
+  // Using -1 for a strtol base causes MSVC to abort. Print the expected lines
+  // to make the test pass.
+  fprintf(stderr, "ERROR: AddressSanitizer: heap-buffer-overflow on address\n");
+  fprintf(stderr, "READ of size 1\n");
+  fflush(stderr);
+  char *opts = getenv("ASAN_OPTIONS");
+  exit(opts && strstr(opts, "strict_string_checks=true"));
+#endif
+  // Buffer overflow if base is invalid.
+  long r = strtol(array + 3, NULL, 1);
+  assert(r == 0);
+}
+
+void test5(char *array, char *endptr) {
+  // Overflow if no digits are found.
+  array[0] = ' ';
+  array[1] = '+';
+  array[2] = '-';
+  long r = strtol(array, NULL, 0);
+  assert(r == 0);
+}
+
+void test6(char *array, char *endptr) {
+  // Overflow if no digits are found.
+  array[0] = ' ';
+  array[1] = array[2] = 'z';
+  long r = strtol(array, &endptr, 0);
+  assert(array == endptr);
+  assert(r == 0);
+}
+
+void test7(char *array, char *endptr) {
+  // Overflow if no digits are found.
+  array[2] = 'z';
+  long r = strtol(array + 2, NULL, 0);
+  assert(r == 0);
+}
+
+int main(int argc, char **argv) {
+  char *array0 = (char*)malloc(11);
+  char* array = array0 + 8;
+  char *endptr = NULL;
+  array[0] = '1';
+  array[1] = '2';
+  array[2] = '3';
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(array, endptr);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1: READ of size 4
+  if (!strcmp(argv[1], "test2")) test2(array, endptr);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2: READ of size 4
+  if (!strcmp(argv[1], "test3")) test3(array0, endptr);
+  // CHECK3: {{.*ERROR: AddressSanitizer: use-after-poison on address}}
+  // CHECK3: READ of size 1
+  if (!strcmp(argv[1], "test4")) test4(array, endptr);
+  // CHECK4: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK4: READ of size 1
+  if (!strcmp(argv[1], "test5")) test5(array, endptr);
+  // CHECK5: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK5: READ of size 4
+  if (!strcmp(argv[1], "test6")) test6(array, endptr);
+  // CHECK6: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK6: READ of size 4
+  if (!strcmp(argv[1], "test7")) test7(array, endptr);
+  // CHECK7: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK7: READ of size 2
+  free(array0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/strtoll_strict.c b/compiler-rt/test/asan/TestCases/strtoll_strict.c
new file mode 100644
index 0000000..f6a1716
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/strtoll_strict.c
@@ -0,0 +1,119 @@
+// Test strict_string_checks option in strtoll function
+// RUN: %clang_asan %s -o %t
+// RUN: %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test1 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test2 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test3 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
+// RUN: %run %t test4 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test4 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test4 2>&1 | FileCheck %s --check-prefix=CHECK4
+// RUN: %run %t test5 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test5 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5
+// RUN: %run %t test6 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test6 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
+// RUN: %run %t test7 2>&1
+// RUN: %env_asan_opts=strict_string_checks=false %run %t test7 2>&1
+// RUN: %env_asan_opts=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
+
+// FIXME: Enable strtoll interceptor.
+// XFAIL: win32
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sanitizer/asan_interface.h>
+
+void test1(char *array, char *endptr) {
+  // Buffer overflow if there is no terminating null (depends on base)
+  long long r = strtoll(array, &endptr, 3);
+  assert(array + 2 == endptr);
+  assert(r == 5);
+}
+
+void test2(char *array, char *endptr) {
+  // Buffer overflow if there is no terminating null (depends on base)
+  array[2] = 'z';
+  long long r = strtoll(array, &endptr, 35);
+  assert(array + 2 == endptr);
+  assert(r == 37);
+}
+
+void test3(char *array, char *endptr) {
+  // Buffer overflow if base is invalid.
+  memset(array, 0, 8);
+  ASAN_POISON_MEMORY_REGION(array, 8);
+  long long r = strtoll(array + 1, NULL, -1);
+  assert(r == 0);
+  ASAN_UNPOISON_MEMORY_REGION(array, 8);
+}
+
+void test4(char *array, char *endptr) {
+  // Buffer overflow if base is invalid.
+  long long r = strtoll(array + 3, NULL, 1);
+  assert(r == 0);
+}
+
+void test5(char *array, char *endptr) {
+  // Overflow if no digits are found.
+  array[0] = ' ';
+  array[1] = '+';
+  array[2] = '-';
+  long long r = strtoll(array, NULL, 0);
+  assert(r == 0);
+}
+
+void test6(char *array, char *endptr) {
+  // Overflow if no digits are found.
+  array[0] = ' ';
+  array[1] = array[2] = 'z';
+  long long r = strtoll(array, &endptr, 0);
+  assert(array == endptr);
+  assert(r == 0);
+}
+
+void test7(char *array, char *endptr) {
+  // Overflow if no digits are found.
+  array[2] = 'z';
+  long long r = strtoll(array + 2, NULL, 0);
+  assert(r == 0);
+}
+
+int main(int argc, char **argv) {
+  char *array0 = (char*)malloc(11);
+  char* array = array0 + 8;
+  char *endptr = NULL;
+  array[0] = '1';
+  array[1] = '2';
+  array[2] = '3';
+  if (argc != 2) return 1;
+  if (!strcmp(argv[1], "test1")) test1(array, endptr);
+  // CHECK1: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK1: READ of size 4
+  if (!strcmp(argv[1], "test2")) test2(array, endptr);
+  // CHECK2: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK2: READ of size 4
+  if (!strcmp(argv[1], "test3")) test3(array0, endptr);
+  // CHECK3: {{.*ERROR: AddressSanitizer: use-after-poison on address}}
+  // CHECK3: READ of size 1
+  if (!strcmp(argv[1], "test4")) test4(array, endptr);
+  // CHECK4: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK4: READ of size 1
+  if (!strcmp(argv[1], "test5")) test5(array, endptr);
+  // CHECK5: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK5: READ of size 4
+  if (!strcmp(argv[1], "test6")) test6(array, endptr);
+  // CHECK6: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK6: READ of size 4
+  if (!strcmp(argv[1], "test7")) test7(array, endptr);
+  // CHECK7: {{.*ERROR: AddressSanitizer: heap-buffer-overflow on address}}
+  // CHECK7: READ of size 2
+  free(array0);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/suppressions-exec-relative-location.cc b/compiler-rt/test/asan/TestCases/suppressions-exec-relative-location.cc
new file mode 100644
index 0000000..740cece
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/suppressions-exec-relative-location.cc
@@ -0,0 +1,47 @@
+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// If the executable is started from a different location, we should still
+// find the suppression file located relative to the location of the executable.
+// RUN: rm -rf %T/suppressions-exec-relative-location
+// RUN: mkdir -p %T/suppressions-exec-relative-location
+// RUN: %clangxx_asan -O0 %s -o %T/suppressions-exec-relative-location/exec
+// RUN: echo "interceptor_via_fun:crash_function" > \
+// RUN:   %T/suppressions-exec-relative-location/supp.txt
+// RUN: %env_asan_opts=suppressions='"supp.txt"' \
+// RUN:   %run %T/suppressions-exec-relative-location/exec 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: rm -rf %T/suppressions-exec-relative-location
+
+// If the wrong absolute path is given, we don't try to construct
+// a relative path with it.
+// RUN: %env_asan_opts=suppressions='"/absolute/path"' not %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-WRONG-FILE-NAME %s
+
+// Test that we reject directory as filename.
+// RUN: %env_asan_opts=suppressions='"folder/only/"' not %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-WRONG-FILE-NAME %s
+
+// XFAIL: android
+// XFAIL: win32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void crash_function() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, len = %zu\n", len);
+}
+
+int main() {
+  crash_function();
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-buffer-overflow
+// CHECK-IGNORE: ignored
+// CHECK-WRONG-FILE-NAME: failed to read suppressions file
diff --git a/compiler-rt/test/asan/TestCases/suppressions-function.cc b/compiler-rt/test/asan/TestCases/suppressions-function.cc
new file mode 100644
index 0000000..d5ac9f7
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/suppressions-function.cc
@@ -0,0 +1,30 @@
+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// RUN: echo "interceptor_via_fun:crash_function" > %t.supp
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: %clangxx_asan -O3 %s -o %t && %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// FIXME: Windows symbolizer needs work to make this pass.
+// XFAIL: android,win32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void crash_function() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, len = %zu\n", len);
+}
+
+int main() {
+  crash_function();
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-CRASH-NOT: strlen ignored
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free
+// CHECK-IGNORE: strlen ignored
diff --git a/compiler-rt/test/asan/TestCases/suppressions-interceptor.cc b/compiler-rt/test/asan/TestCases/suppressions-interceptor.cc
new file mode 100644
index 0000000..e44ccb8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/suppressions-interceptor.cc
@@ -0,0 +1,24 @@
+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// RUN: echo "interceptor_name:strlen" > %t.supp
+// RUN: %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// XFAIL: android
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, len = %zu\n", len);
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-CRASH-NOT: strlen ignored
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free
+// CHECK-IGNORE: strlen ignored
diff --git a/compiler-rt/test/asan/TestCases/suppressions-library.cc b/compiler-rt/test/asan/TestCases/suppressions-library.cc
new file mode 100644
index 0000000..ad6e092
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/suppressions-library.cc
@@ -0,0 +1,42 @@
+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %dynamiclib %ld_flags_rpath_so
+// RUN: %clangxx_asan -O0 %s -o %t %ld_flags_rpath_exe
+
+// Check that without suppressions, we catch the issue.
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// FIXME: Remove usage of backticks around basename below.
+// REQUIRES: shell
+
+// RUN: echo "interceptor_via_lib:"`basename %dynamiclib` > %t.supp
+// RUN: %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// XFAIL: android
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(SHARED_LIB)
+
+void crash_function();
+
+int main(int argc, char *argv[]) {
+  crash_function();
+  return 0;
+}
+
+#else // SHARED_LIB
+
+void crash_function() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, %zu\n", len);
+}
+
+#endif // SHARED_LIB
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-CRASH-NOT: strlen ignored
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free
+// CHECK-IGNORE: strlen ignored
diff --git a/compiler-rt/test/asan/TestCases/throw_call_test.cc b/compiler-rt/test/asan/TestCases/throw_call_test.cc
new file mode 100644
index 0000000..4b3910d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/throw_call_test.cc
@@ -0,0 +1,55 @@
+// RUN: %clangxx_asan %s -o %t && %run %t
+// http://code.google.com/p/address-sanitizer/issues/detail?id=147 (not fixed).
+// BROKEN: %clangxx_asan %s -o %t -static-libstdc++ && %run %t
+//
+// Android builds with static libstdc++ by default.
+// XFAIL: android
+
+// Clang doesn't support exceptions on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+static volatile int zero = 0;
+inline void pretend_to_do_something(void *x) {
+  __asm__ __volatile__("" : : "r" (x) : "memory");
+}
+
+__attribute__((noinline, no_sanitize_address))
+void ReallyThrow() {
+  fprintf(stderr, "ReallyThrow\n");
+  if (zero == 0)
+    throw 42;
+}
+
+__attribute__((noinline))
+void Throw() {
+  int a, b, c, d, e, f, g, h;
+  pretend_to_do_something(&a);
+  pretend_to_do_something(&b);
+  pretend_to_do_something(&c);
+  pretend_to_do_something(&d);
+  pretend_to_do_something(&e);
+  pretend_to_do_something(&f);
+  pretend_to_do_something(&g);
+  pretend_to_do_something(&h);
+  fprintf(stderr, "Throw stack = %p\n", &a);
+  ReallyThrow();
+}
+
+__attribute__((noinline))
+void CheckStack() {
+  int ar[100];
+  pretend_to_do_something(ar);
+  fprintf(stderr, "CheckStack stack = %p, %p\n", ar, ar + 100);
+  for (int i = 0; i < 100; i++)
+    ar[i] = i;
+}
+
+int main(int argc, char** argv) {
+  try {
+    Throw();
+  } catch(int a) {
+    fprintf(stderr, "a = %d\n", a);
+  }
+  CheckStack();
+}
diff --git a/compiler-rt/test/asan/TestCases/throw_catch.cc b/compiler-rt/test/asan/TestCases/throw_catch.cc
new file mode 100644
index 0000000..bce4819
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/throw_catch.cc
@@ -0,0 +1,64 @@
+// RUN: %clangxx_asan -O %s -o %t && %run %t
+
+// Clang doesn't support exceptions on Windows yet.
+// XFAIL: win32
+
+#include <assert.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+__attribute__((noinline))
+void Throw() {
+  int local;
+  fprintf(stderr, "Throw:  %p\n", &local);
+  throw 1;
+}
+
+__attribute__((noinline))
+void ThrowAndCatch() {
+  int local;
+  try {
+    Throw();
+  } catch(...) {
+    fprintf(stderr, "Catch:  %p\n", &local);
+  }
+}
+
+void TestThrow() {
+  char x[32];
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  ThrowAndCatch();
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  // This assertion works only w/o UAR.
+  if (!__asan_get_current_fake_stack())
+    assert(!__asan_address_is_poisoned(x + 32));
+}
+
+void TestThrowInline() {
+  char x[32];
+  fprintf(stderr, "Before: %p poisoned: %d\n", &x,
+          __asan_address_is_poisoned(x + 32));
+  assert(__asan_address_is_poisoned(x + 32));
+  try {
+    Throw();
+  } catch(...) {
+    fprintf(stderr, "Catch\n");
+  }
+  fprintf(stderr, "After:  %p poisoned: %d\n",  &x,
+          __asan_address_is_poisoned(x + 32));
+  // FIXME: Invert this assertion once we fix
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=258
+  // This assertion works only w/o UAR.
+  if (!__asan_get_current_fake_stack())
+    assert(!__asan_address_is_poisoned(x + 32));
+}
+
+int main(int argc, char **argv) {
+  TestThrowInline();
+  TestThrow();
+}
diff --git a/compiler-rt/test/asan/TestCases/throw_invoke_test.cc b/compiler-rt/test/asan/TestCases/throw_invoke_test.cc
new file mode 100644
index 0000000..ec48fc7
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/throw_invoke_test.cc
@@ -0,0 +1,54 @@
+// RUN: %clangxx_asan %s -o %t && %run %t
+// RUN: %clangxx_asan %s -o %t -static-libstdc++ && %run %t
+
+// Clang doesn't support exceptions on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+static volatile int zero = 0;
+inline void pretend_to_do_something(void *x) {
+  __asm__ __volatile__("" : : "r" (x) : "memory");
+}
+
+__attribute__((noinline))
+void ReallyThrow() {
+  fprintf(stderr, "ReallyThrow\n");
+  try {
+    if (zero == 0)
+      throw 42;
+    else if (zero == 1)
+      throw 1.;
+  } catch(double x) {
+  }
+}
+
+__attribute__((noinline))
+void Throw() {
+  int a, b, c, d, e;
+  pretend_to_do_something(&a);
+  pretend_to_do_something(&b);
+  pretend_to_do_something(&c);
+  pretend_to_do_something(&d);
+  pretend_to_do_something(&e);
+  fprintf(stderr, "Throw stack = %p\n", &a);
+  ReallyThrow();
+}
+
+__attribute__((noinline))
+void CheckStack() {
+  int ar[100];
+  pretend_to_do_something(ar);
+  for (int i = 0; i < 100; i++)
+    ar[i] = i;
+  fprintf(stderr, "CheckStack stack = %p, %p\n", ar, ar + 100);
+}
+
+int main(int argc, char** argv) {
+  try {
+    Throw();
+  } catch(int a) {
+    fprintf(stderr, "a = %d\n", a);
+  }
+  CheckStack();
+}
+
diff --git a/compiler-rt/test/asan/TestCases/time_interceptor.cc b/compiler-rt/test/asan/TestCases/time_interceptor.cc
new file mode 100644
index 0000000..89b2183
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/time_interceptor.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// Test the time() interceptor.
+
+// There's no interceptor for time() on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main() {
+  time_t *tm = (time_t*)malloc(sizeof(time_t));
+  free(tm);
+  time_t t = time(tm);
+  printf("Time: %s\n", ctime(&t));  // NOLINT
+  // CHECK: use-after-free
+  // Regression check for
+  // https://code.google.com/p/address-sanitizer/issues/detail?id=321
+  // CHECK: SUMMARY
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/uar_and_exceptions.cc b/compiler-rt/test/asan/TestCases/uar_and_exceptions.cc
new file mode 100644
index 0000000..324e8a5
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/uar_and_exceptions.cc
@@ -0,0 +1,43 @@
+// Test that use-after-return works with exceptions.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: %env_asan_opts=detect_stack_use_after_return=1 %run %t
+
+// Clang doesn't support exceptions on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+
+volatile char *g;
+
+#ifndef FRAME_SIZE
+# define FRAME_SIZE 100
+#endif
+
+#ifndef NUM_ITER
+# define NUM_ITER 4000
+#endif
+
+#ifndef DO_THROW
+# define DO_THROW 1
+#endif
+
+void Func(int depth) {
+  char frame[FRAME_SIZE];
+  g = &frame[0];
+  if (depth)
+    Func(depth - 1);
+  else if (DO_THROW)
+    throw 1;
+}
+
+int main(int argc, char **argv) {
+  for (int i = 0; i < NUM_ITER; i++) {
+    try {
+      Func(argc * 100);
+    } catch(...) {
+    }
+    if ((i % (NUM_ITER / 10)) == 0)
+      fprintf(stderr, "done [%d]\n", i);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/unaligned_loads_and_stores.cc b/compiler-rt/test/asan/TestCases/unaligned_loads_and_stores.cc
new file mode 100644
index 0000000..f1b1d0d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/unaligned_loads_and_stores.cc
@@ -0,0 +1,52 @@
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t A 2>&1 | FileCheck --check-prefix=CHECK-A %s
+// RUN: not %run %t B 2>&1 | FileCheck --check-prefix=CHECK-B %s
+// RUN: not %run %t C 2>&1 | FileCheck --check-prefix=CHECK-C %s
+// RUN: not %run %t D 2>&1 | FileCheck --check-prefix=CHECK-D %s
+// RUN: not %run %t E 2>&1 | FileCheck --check-prefix=CHECK-E %s
+
+// RUN: not %run %t K 2>&1 | FileCheck --check-prefix=CHECK-K %s
+// RUN: not %run %t L 2>&1 | FileCheck --check-prefix=CHECK-L %s
+// RUN: not %run %t M 2>&1 | FileCheck --check-prefix=CHECK-M %s
+// RUN: not %run %t N 2>&1 | FileCheck --check-prefix=CHECK-N %s
+// RUN: not %run %t O 2>&1 | FileCheck --check-prefix=CHECK-O %s
+
+#include <sanitizer/asan_interface.h>
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  if (argc != 2) return 1;
+  char *x = new char[16];
+  memset(x, 0xab, 16);
+  int res = 1;
+  switch (argv[1][0]) {
+    case 'A': res = __sanitizer_unaligned_load16(x + 15); break;
+//  CHECK-A ERROR: AddressSanitizer: heap-buffer-overflow on address
+//  CHECK-A: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-2]]
+//  CHECK-A: is located 0 bytes to the right of 16-byte region
+    case 'B': res = __sanitizer_unaligned_load32(x + 14); break;
+//  CHECK-B: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+    case 'C': res = __sanitizer_unaligned_load32(x + 13); break;
+//  CHECK-C: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+    case 'D': res = __sanitizer_unaligned_load64(x + 15); break;
+//  CHECK-D: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+    case 'E': res = __sanitizer_unaligned_load64(x + 9); break;
+//  CHECK-E: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+
+    case 'K': __sanitizer_unaligned_store16(x + 15, 0); break;
+//  CHECK-K ERROR: AddressSanitizer: heap-buffer-overflow on address
+//  CHECK-K: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-2]]
+//  CHECK-K: is located 0 bytes to the right of 16-byte region
+    case 'L': __sanitizer_unaligned_store32(x + 15, 0); break;
+//  CHECK-L: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+    case 'M': __sanitizer_unaligned_store32(x + 13, 0); break;
+//  CHECK-M: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+    case 'N': __sanitizer_unaligned_store64(x + 10, 0); break;
+//  CHECK-N: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+    case 'O': __sanitizer_unaligned_store64(x + 14, 0); break;
+//  CHECK-O: main{{.*}}unaligned_loads_and_stores.cc:[[@LINE-1]]
+  }
+  delete x;
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-delete.cc b/compiler-rt/test/asan/TestCases/use-after-delete.cc
new file mode 100644
index 0000000..8fdec8d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-delete.cc
@@ -0,0 +1,31 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+int main() {
+  char * volatile x = new char[10];
+  delete[] x;
+  return x[5];
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+  // CHECK:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}
+  // CHECK: {{READ of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main .*use-after-delete.cc:}}[[@LINE-4]]
+  // CHECK: {{0x.* is located 5 bytes inside of 10-byte region .0x.*,0x.*}}
+  // CHECK: {{freed by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in operator delete\[\]}}
+  // CHECK-Linux: {{    #1 0x.* in main .*use-after-delete.cc:}}[[@LINE-10]]
+
+  // CHECK: {{previously allocated by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in operator new\[\]}}
+  // CHECK-Linux: {{    #1 0x.* in main .*use-after-delete.cc:}}[[@LINE-16]]
+
+  // CHECK: Shadow byte legend (one shadow byte represents 8 application bytes):
+  // CHECK: Global redzone:
+  // CHECK: ASan internal:
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-free-right.cc b/compiler-rt/test/asan/TestCases/use-after-free-right.cc
new file mode 100644
index 0000000..f714b44
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-free-right.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+// Test use-after-free report in the case when access is at the right border of
+// the allocation.
+
+#include <stdlib.h>
+int main() {
+  volatile char *x = (char*)malloc(sizeof(char));
+  free((void*)x);
+  *x = 42;
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+  // CHECK:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}
+  // CHECK: {{WRITE of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main .*use-after-free-right.cc:}}[[@LINE-4]]
+  // CHECK: {{0x.* is located 0 bytes inside of 1-byte region .0x.*,0x.*}}
+  // CHECK: {{freed by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in .*free}}
+  // CHECK-Linux: {{    #1 0x.* in main .*use-after-free-right.cc:}}[[@LINE-10]]
+
+  // CHECK-Darwin: {{    #0 0x.* in wrap_free}}
+  // CHECK-Darwin: {{    #1 0x.* in main .*use-after-free-right.cc:}}[[@LINE-13]]
+
+  // CHECK: {{previously allocated by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in .*malloc}}
+  // CHECK-Linux: {{    #1 0x.* in main .*use-after-free-right.cc:}}[[@LINE-19]]
+
+  // CHECK-Darwin: {{    #0 0x.* in wrap_malloc.*}}
+  // CHECK-Darwin: {{    #1 0x.* in main .*use-after-free-right.cc:}}[[@LINE-22]]
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-free.cc b/compiler-rt/test/asan/TestCases/use-after-free.cc
new file mode 100644
index 0000000..7bc225b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-free.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+// XFAIL: arm-linux-gnueabi
+// XFAIL: armv7l-unknown-linux-gnueabihf
+
+#include <stdlib.h>
+int main() {
+  char *x = (char*)malloc(10 * sizeof(char));
+  free(x);
+  return x[5];
+  // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
+  // CHECK:   {{0x.* at pc 0x.* bp 0x.* sp 0x.*}}
+  // CHECK: {{READ of size 1 at 0x.* thread T0}}
+  // CHECK: {{    #0 0x.* in main .*use-after-free.cc:}}[[@LINE-4]]
+  // CHECK: {{0x.* is located 5 bytes inside of 10-byte region .0x.*,0x.*}}
+  // CHECK: {{freed by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in .*free}}
+  // CHECK-Linux: {{    #1 0x.* in main .*use-after-free.cc:}}[[@LINE-10]]
+
+  // CHECK-Darwin: {{    #0 0x.* in wrap_free}}
+  // CHECK-Darwin: {{    #1 0x.* in main .*use-after-free.cc:}}[[@LINE-13]]
+
+  // CHECK: {{previously allocated by thread T0 here:}}
+
+  // CHECK-Linux: {{    #0 0x.* in .*malloc}}
+  // CHECK-Linux: {{    #1 0x.* in main .*use-after-free.cc:}}[[@LINE-19]]
+
+  // CHECK-Darwin: {{    #0 0x.* in wrap_malloc.*}}
+  // CHECK-Darwin: {{    #1 0x.* in main .*use-after-free.cc:}}[[@LINE-22]]
+  // CHECK: Shadow byte legend (one shadow byte represents 8 application bytes):
+  // CHECK: Global redzone:
+  // CHECK: ASan internal:
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-poison.cc b/compiler-rt/test/asan/TestCases/use-after-poison.cc
new file mode 100644
index 0000000..9df042b
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-poison.cc
@@ -0,0 +1,20 @@
+// Check that __asan_poison_memory_region works.
+// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+//
+// Check that we can disable it
+// RUN: %env_asan_opts=allow_user_poisoning=0 %run %t
+
+#include <stdlib.h>
+
+extern "C" void __asan_poison_memory_region(void *, size_t);
+
+int main(int argc, char **argv) {
+  char *x = new char[16];
+  x[10] = 0;
+  __asan_poison_memory_region(x, 16);
+  int res = x[argc * 10];  // BOOOM
+  // CHECK: ERROR: AddressSanitizer: use-after-poison
+  // CHECK: main{{.*}}use-after-poison.cc:[[@LINE-2]]
+  delete [] x;
+  return res;
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-scope-dtor-order.cc b/compiler-rt/test/asan/TestCases/use-after-scope-dtor-order.cc
new file mode 100644
index 0000000..7896dd3
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-scope-dtor-order.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+// XFAIL: *
+#include <stdio.h>
+
+struct IntHolder {
+  explicit IntHolder(int *val = 0) : val_(val) { }
+  ~IntHolder() {
+    printf("Value: %d\n", *val_);  // BOOM
+    // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
+    // CHECK:  #0 0x{{.*}} in IntHolder::~IntHolder{{.*}}use-after-scope-dtor-order.cc:[[@LINE-2]]
+  }
+  void set(int *val) { val_ = val; }
+  int *get() { return val_; }
+
+  int *val_;
+};
+
+int main(int argc, char *argv[]) {
+  // It is incorrect to use "x" int IntHolder destructor, because "x" is
+  // "destroyed" earlier as it's declared later.
+  IntHolder holder;
+  int x = argc;
+  holder.set(&x);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-scope-inlined.cc b/compiler-rt/test/asan/TestCases/use-after-scope-inlined.cc
new file mode 100644
index 0000000..a0a0d94
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-scope-inlined.cc
@@ -0,0 +1,28 @@
+// Test with "-O2" only to make sure inlining (leading to use-after-scope)
+// happens. "always_inline" is not enough, as Clang doesn't emit
+// llvm.lifetime intrinsics at -O0.
+//
+// RUN: %clangxx_asan -O2 -fsanitize=use-after-scope %s -o %t && not %run %t 2>&1 | FileCheck %s
+// XFAIL: *
+
+int *arr;
+
+__attribute__((always_inline))
+void inlined(int arg) {
+  int x[5];
+  for (int i = 0; i < arg; i++) x[i] = i;
+  arr = x;
+}
+
+int main(int argc, char *argv[]) {
+  inlined(argc);
+  return arr[argc - 1];  // BOOM
+  // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
+  // CHECK: READ of size 4 at 0x{{.*}} thread T0
+  // CHECK:   #0 0x{{.*}} in main
+  // CHECK:      {{.*}}use-after-scope-inlined.cc:[[@LINE-4]]
+  // CHECK: Address 0x{{.*}} is located in stack of thread T0 at offset
+  // CHECK:      [[OFFSET:[^ ]*]] in frame
+  // CHECK: main
+  // CHECK:   {{\[}}[[OFFSET]], {{.*}}) 'x.i'
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-scope-nobug.cc b/compiler-rt/test/asan/TestCases/use-after-scope-nobug.cc
new file mode 100644
index 0000000..21b085c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-scope-nobug.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && %run %t
+// XFAIL: *
+
+#include <stdio.h>
+
+int main() {
+  int *p = 0;
+  // Variable goes in and out of scope.
+  for (int i = 0; i < 3; i++) {
+    int x = 0;
+    p = &x;
+  }
+  printf("PASSED\n");
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-scope-temp.cc b/compiler-rt/test/asan/TestCases/use-after-scope-temp.cc
new file mode 100644
index 0000000..f9bd779
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-scope-temp.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && \
+// RUN:     %run %t 2>&1 | FileCheck %s
+//
+// Lifetime for temporaries is not emitted yet.
+// XFAIL: *
+
+#include <stdio.h>
+
+struct IntHolder {
+  explicit IntHolder(int val) : val(val) {
+    printf("IntHolder: %d\n", val);
+  }
+  int val;
+};
+
+const IntHolder *saved;
+
+void save(const IntHolder &holder) {
+  saved = &holder;
+}
+
+int main(int argc, char *argv[]) {
+  save(IntHolder(10));
+  int x = saved->val;  // BOOM
+  // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
+  // CHECK:  #0 0x{{.*}} in main {{.*}}use-after-scope-temp.cc:[[@LINE-2]]
+  printf("saved value: %d\n", x);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/use-after-scope.cc b/compiler-rt/test/asan/TestCases/use-after-scope.cc
new file mode 100644
index 0000000..59a0e0c
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/use-after-scope.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && \
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// XFAIL: *
+
+int main() {
+  int *p = 0;
+  {
+    int x = 0;
+    p = &x;
+  }
+  return *p;  // BOOM
+  // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
+  // CHECK:  #0 0x{{.*}} in main {{.*}}use-after-scope.cc:[[@LINE-2]]
+  // CHECK: Address 0x{{.*}} is located in stack of thread T{{.*}} at offset [[OFFSET:[^ ]+]] in frame
+  // {{\[}}[[OFFSET]], {{[0-9]+}}) 'x'
+}
diff --git a/compiler-rt/test/asan/TestCases/verbose-log-path_test.cc b/compiler-rt/test/asan/TestCases/verbose-log-path_test.cc
new file mode 100644
index 0000000..47a5c22
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/verbose-log-path_test.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_asan %s -o %T/verbose-log-path_test-binary
+
+// The glob below requires bash.
+// REQUIRES: shell
+
+// Good log_path.
+// RUN: rm -f %T/asan.log.*
+// RUN: %env_asan_opts=log_path=%T/asan.log:log_exe_name=1 not %run %T/verbose-log-path_test-binary 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %T/asan.log.verbose-log-path_test-binary.*
+
+// FIXME: only FreeBSD and Linux have verbose log paths now.
+// XFAIL: win32,android
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  if (argc > 2) return 0;
+  char *x = (char*)malloc(10);
+  memset(x, 0, 10);
+  int res = x[argc * 10];  // BOOOM
+  free(x);
+  return res;
+}
+// CHECK-ERROR: ERROR: AddressSanitizer
diff --git a/compiler-rt/test/asan/TestCases/vla_chrome_testcase.cc b/compiler-rt/test/asan/TestCases/vla_chrome_testcase.cc
new file mode 100644
index 0000000..8ee0401
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/vla_chrome_testcase.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+
+// This is reduced testcase based on Chromium code.
+// See http://reviews.llvm.org/D6055?vs=on&id=15616&whitespace=ignore-all#toc.
+
+#include <stdint.h>
+#include <assert.h>
+
+int a = 7;
+int b;
+int c;
+int *p;
+
+__attribute__((noinline)) void fn3(int *first, int second) {
+}
+
+int main() {
+  int d = b && c;
+  int e[a]; // NOLINT
+  assert(!(reinterpret_cast<uintptr_t>(e) & 31L));
+  int f;
+  if (d)
+    fn3(&f, sizeof 0 * (&c - e));
+  e[a] = 0;
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 4 at [[ADDR]] thread T0
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/vla_condition_overflow.cc b/compiler-rt/test/asan/TestCases/vla_condition_overflow.cc
new file mode 100644
index 0000000..17f28d8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/vla_condition_overflow.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+// REQUIRES: stable-runtime
+
+#include <assert.h>
+#include <stdint.h>
+
+__attribute__((noinline)) void foo(int index, int len) {
+  if (index > len) {
+    char str[len]; //NOLINT
+    assert(!(reinterpret_cast<uintptr_t>(str) & 31L));
+    str[index] = '1'; // BOOM
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+  }
+}
+
+int main(int argc, char **argv) {
+  foo(33, 10);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/vla_loop_overfow.cc b/compiler-rt/test/asan/TestCases/vla_loop_overfow.cc
new file mode 100644
index 0000000..4f20c8d
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/vla_loop_overfow.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_asan -O0 -mllvm -asan-instrument-allocas %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+//
+// REQUIRES: stable-runtime
+
+#include <assert.h>
+#include <stdint.h>
+
+void foo(int index, int len) {
+  for (int i = 1; i < len; ++i) {
+    char array[len]; // NOLINT
+    assert(!(reinterpret_cast<uintptr_t>(array) & 31L));
+    array[index + i] = 0;
+// CHECK: ERROR: AddressSanitizer: dynamic-stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
+// CHECK: WRITE of size 1 at [[ADDR]] thread T0
+  }
+}
+
+int main(int argc, char **argv) {
+  foo(9, 21);
+  return 0;
+}
diff --git a/compiler-rt/test/asan/TestCases/zero_page_pc.cc b/compiler-rt/test/asan/TestCases/zero_page_pc.cc
new file mode 100644
index 0000000..ba35df8
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/zero_page_pc.cc
@@ -0,0 +1,16 @@
+// Check that ASan correctly detects SEGV on the zero page.
+// RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+typedef void void_f();
+int main() {
+  void_f *func = (void_f *)0x4;
+  func();
+  // x86 reports the SEGV with both address=4 and pc=4.
+  // On PowerPC64 ELFv1, the pointer is taken to be a function-descriptor
+  // pointer out of which three 64-bit quantities are read. This will SEGV, but
+  // the compiler is free to choose the order. As a result, the address is
+  // either 0x4, 0xc or 0x14. The pc is still in main() because it has not
+  // actually made the call when the faulting access occurs.
+  // CHECK: {{AddressSanitizer: (SEGV|access-violation).*(address|pc) 0x0*[4c]}}
+  return 0;
+}
diff --git a/compiler-rt/test/asan/Unit/lit.site.cfg.in b/compiler-rt/test/asan/Unit/lit.site.cfg.in
new file mode 100644
index 0000000..b599102
--- /dev/null
+++ b/compiler-rt/test/asan/Unit/lit.site.cfg.in
@@ -0,0 +1,30 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+import os
+
+# Load common config for all compiler-rt unit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
+
+def push_ld_library_path(config, new_path):
+  new_ld_library_path = os.path.pathsep.join(
+    (new_path, config.environment.get('LD_LIBRARY_PATH', '')))
+  config.environment['LD_LIBRARY_PATH'] = new_ld_library_path
+
+# Setup config name.
+config.name = 'AddressSanitizer-Unit'
+
+# Setup test source and exec root. For unit tests, we define
+# it as build directory with ASan unit tests.
+# FIXME: De-hardcode this path.
+if @ASAN_TEST_DYNAMIC@:
+  test_dir = "dynamic"
+else:
+  test_dir = "default"
+config.test_exec_root = os.path.join("@COMPILER_RT_BINARY_DIR@",
+                                     "lib", "asan", "tests", test_dir)
+
+config.test_source_root = config.test_exec_root
+
+# Set LD_LIBRARY_PATH to pick dynamic runtime up properly.
+push_ld_library_path(config, config.compiler_rt_libdir)
diff --git a/compiler-rt/test/asan/android_commands/android_common.py b/compiler-rt/test/asan/android_commands/android_common.py
new file mode 100644
index 0000000..43ac7b4
--- /dev/null
+++ b/compiler-rt/test/asan/android_commands/android_common.py
@@ -0,0 +1,29 @@
+import os, subprocess, tempfile
+import time
+
+ANDROID_TMPDIR = '/data/local/tmp/Output'
+ADB = os.environ.get('ADB', 'adb')
+
+verbose = False
+if os.environ.get('ANDROID_RUN_VERBOSE') == '1':
+    verbose = True
+
+def adb(args):
+    if verbose:
+        print args
+    devnull = open(os.devnull, 'w')
+    return subprocess.call([ADB] + args, stdout=devnull, stderr=subprocess.STDOUT)
+
+def pull_from_device(path):
+    tmp = tempfile.mktemp()
+    adb(['pull', path, tmp])
+    text = open(tmp, 'r').read()
+    os.unlink(tmp)
+    return text
+
+def push_to_device(path):
+    # Workaround for https://code.google.com/p/android/issues/detail?id=65857
+    dst_path = os.path.join(ANDROID_TMPDIR, os.path.basename(path))
+    tmp_path = dst_path + '.push'
+    adb(['push', path, tmp_path])
+    adb(['shell', 'cp "%s" "%s" 2>&1' % (tmp_path, dst_path)])
diff --git a/compiler-rt/test/asan/android_commands/android_compile.py b/compiler-rt/test/asan/android_commands/android_compile.py
new file mode 100755
index 0000000..4b88088
--- /dev/null
+++ b/compiler-rt/test/asan/android_commands/android_compile.py
@@ -0,0 +1,36 @@
+#!/usr/bin/python
+
+import os, sys, subprocess
+from android_common import *
+
+
+here = os.path.abspath(os.path.dirname(sys.argv[0]))
+android_run = os.path.join(here, 'android_run.py')
+
+output = None
+output_type = 'executable'
+
+args = sys.argv[1:]
+while args:
+    arg = args.pop(0)
+    if arg == '-shared':
+        output_type = 'shared'
+    elif arg == '-c':
+        output_type = 'object'
+    elif arg == '-o':
+        output = args.pop(0)
+
+if output == None:
+    print "No output file name!"
+    sys.exit(1)
+
+ret = subprocess.call(sys.argv[1:])
+if ret != 0:
+    sys.exit(ret)
+
+if output_type in ['executable', 'shared']:
+    push_to_device(output)
+
+if output_type == 'executable':
+    os.rename(output, output + '.real')
+    os.symlink(android_run, output)
diff --git a/compiler-rt/test/asan/android_commands/android_run.py b/compiler-rt/test/asan/android_commands/android_run.py
new file mode 100755
index 0000000..272d211
--- /dev/null
+++ b/compiler-rt/test/asan/android_commands/android_run.py
@@ -0,0 +1,37 @@
+#!/usr/bin/python
+
+import os, sys, subprocess, tempfile
+from android_common import *
+
+ANDROID_TMPDIR = '/data/local/tmp/Output'
+
+here = os.path.abspath(os.path.dirname(sys.argv[0]))
+device_binary = os.path.join(ANDROID_TMPDIR, os.path.basename(sys.argv[0]))
+
+def build_env():
+    args = []
+    # Android linker ignores RPATH. Set LD_LIBRARY_PATH to Output dir.
+    args.append('LD_LIBRARY_PATH=%s:%s' %
+                (ANDROID_TMPDIR, os.environ.get('LD_LIBRARY_PATH', '')))
+    for (key, value) in os.environ.items():
+        if key in ['ASAN_OPTIONS', 'ASAN_ACTIVATION_OPTIONS']:
+            args.append('%s="%s"' % (key, value))
+    return ' '.join(args)
+
+is_64bit = (subprocess.check_output(['file', sys.argv[0] + '.real']).find('64-bit') != -1)
+asanwrapper = "" if is_64bit else "asanwrapper "
+
+device_env = build_env()
+device_args = ' '.join(sys.argv[1:]) # FIXME: escape?
+device_stdout = device_binary + '.stdout'
+device_stderr = device_binary + '.stderr'
+device_exitcode = device_binary + '.exitcode'
+ret = adb(['shell', 'cd %s && %s %s%s %s >%s 2>%s ; echo $? >%s' %
+           (ANDROID_TMPDIR, device_env, asanwrapper, device_binary, device_args,
+            device_stdout, device_stderr, device_exitcode)])
+if ret != 0:
+    sys.exit(ret)
+
+sys.stdout.write(pull_from_device(device_stdout))
+sys.stderr.write(pull_from_device(device_stderr))
+sys.exit(int(pull_from_device(device_exitcode)))
diff --git a/compiler-rt/test/asan/lit.cfg b/compiler-rt/test/asan/lit.cfg
new file mode 100644
index 0000000..8355470
--- /dev/null
+++ b/compiler-rt/test/asan/lit.cfg
@@ -0,0 +1,195 @@
+# -*- Python -*-
+
+import os
+import platform
+
+import lit.formats
+
+def get_required_attr(config, attr_name):
+  attr_value = getattr(config, attr_name, None)
+  if attr_value == None:
+    lit_config.fatal(
+      "No attribute %r in test configuration! You may need to run "
+      "tests from your build directory or add this attribute "
+      "to lit.site.cfg " % attr_name)
+  return attr_value
+
+def push_dynamic_library_lookup_path(config, new_path):
+  if platform.system() == 'Windows':
+    dynamic_library_lookup_var = 'PATH'
+  elif platform.system() == 'Darwin':
+    dynamic_library_lookup_var = 'DYLD_LIBRARY_PATH'
+  else:
+    dynamic_library_lookup_var = 'LD_LIBRARY_PATH'
+
+  new_ld_library_path = os.path.pathsep.join(
+    (new_path, config.environment.get(dynamic_library_lookup_var, '')))
+  config.environment[dynamic_library_lookup_var] = new_ld_library_path
+
+# Setup config name.
+config.name = 'AddressSanitizer' + config.name_suffix
+
+# Platform-specific default ASAN_OPTIONS for lit tests.
+default_asan_opts = ''
+if config.host_os == 'Darwin':
+  # On Darwin, we default to `abort_on_error=1`, which would make tests run
+  # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
+  # Also, make sure we do not overwhelm the syslog while testing.
+  default_asan_opts = 'abort_on_error=0'
+  default_asan_opts += ':log_to_syslog=0'
+if default_asan_opts:
+  config.environment['ASAN_OPTIONS'] = default_asan_opts
+  default_asan_opts += ':'
+config.substitutions.append(('%env_asan_opts=',
+                             'env ASAN_OPTIONS=' + default_asan_opts))
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# There is no libdl on FreeBSD.
+if config.host_os != 'FreeBSD':
+  libdl_flag = "-ldl"
+else:
+  libdl_flag = ""
+
+# GCC-ASan doesn't link in all the necessary libraries automatically, so
+# we have to do it ourselves.
+if config.compiler_id == 'GNU':
+  extra_linkflags = ["-pthread", "-lstdc++", libdl_flag]
+else:
+  extra_linkflags = []
+
+# BFD linker in 64-bit android toolchains fails to find libm.so, which is a
+# transitive shared library dependency (via asan runtime).
+if config.android:
+  extra_linkflags += ["-lm"]
+
+# Setup default compiler flags used with -fsanitize=address option.
+# FIXME: Review the set of required flags and check if it can be reduced.
+target_cflags = [get_required_attr(config, "target_cflags")] + extra_linkflags
+target_cxxflags = config.cxx_mode_flags + target_cflags
+clang_asan_static_cflags = (["-fsanitize=address",
+                            "-mno-omit-leaf-frame-pointer",
+                            "-fno-omit-frame-pointer",
+                            "-fno-optimize-sibling-calls"] +
+                            config.debug_info_flags + target_cflags)
+clang_asan_static_cxxflags = config.cxx_mode_flags + clang_asan_static_cflags
+
+if config.asan_dynamic:
+  clang_asan_cflags = clang_asan_static_cflags + ['-shared-libasan']
+  clang_asan_cxxflags = clang_asan_static_cxxflags + ['-shared-libasan']
+  config.available_features.add("asan-dynamic-runtime")
+else:
+  clang_asan_cflags = clang_asan_static_cflags
+  clang_asan_cxxflags = clang_asan_static_cxxflags
+  config.available_features.add("asan-static-runtime")
+
+asan_lit_source_dir = get_required_attr(config, "asan_lit_source_dir")
+if config.android == "1":
+  config.available_features.add('android')
+  clang_wrapper = os.path.join(asan_lit_source_dir,
+                               "android_commands", "android_compile.py") + " "
+else:
+  config.available_features.add('not-android')
+  clang_wrapper = ""
+
+def build_invocation(compile_flags):
+  return " " + " ".join([clang_wrapper, config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang ", build_invocation(target_cflags)) )
+config.substitutions.append( ("%clangxx ", build_invocation(target_cxxflags)) )
+config.substitutions.append( ("%clang_asan ", build_invocation(clang_asan_cflags)) )
+config.substitutions.append( ("%clangxx_asan ", build_invocation(clang_asan_cxxflags)) )
+config.substitutions.append( ("%shared_libasan", "libclang_rt.asan-%s.so" % config.target_arch))
+if config.asan_dynamic:
+  config.substitutions.append( ("%clang_asan_static ", build_invocation(clang_asan_static_cflags)) )
+  config.substitutions.append( ("%clangxx_asan_static ", build_invocation(clang_asan_static_cxxflags)) )
+
+# Windows-specific tests might also use the clang-cl.exe driver.
+if platform.system() == 'Windows':
+  clang_cl_asan_cxxflags = ["-fsanitize=address",
+                            "-Wno-deprecated-declarations",
+                            "-WX",
+                            "-D_HAS_EXCEPTIONS=0",
+                            "-Zi"] + target_cflags
+  if config.asan_dynamic:
+    clang_cl_asan_cxxflags.append("-MD")
+  clang_invocation = build_invocation(clang_cl_asan_cxxflags)
+  clang_cl_invocation = clang_invocation.replace("clang.exe","clang-cl.exe")
+  config.substitutions.append( ("%clang_cl_asan ", clang_cl_invocation) )
+  base_lib = os.path.join(config.compiler_rt_libdir, "clang_rt.asan%%s-%s.lib" % config.target_arch)
+  config.substitutions.append( ("%asan_lib", base_lib % "") )
+  config.substitutions.append( ("%asan_cxx_lib", base_lib % "_cxx") )
+  config.substitutions.append( ("%asan_dll_thunk", base_lib % "_dll_thunk") )
+
+# FIXME: De-hardcode this path.
+asan_source_dir = os.path.join(
+  get_required_attr(config, "compiler_rt_src_root"), "lib", "asan")
+# Setup path to asan_symbolize.py script.
+asan_symbolize = os.path.join(asan_source_dir, "scripts", "asan_symbolize.py")
+if not os.path.exists(asan_symbolize):
+  lit_config.fatal("Can't find script on path %r" % asan_symbolize)
+python_exec = get_required_attr(config, "python_executable")
+config.substitutions.append( ("%asan_symbolize", python_exec + " " + asan_symbolize + " ") )
+# Setup path to sancov.py script.
+sanitizer_common_source_dir = os.path.join(
+  get_required_attr(config, "compiler_rt_src_root"), "lib", "sanitizer_common")
+sancov = os.path.join(sanitizer_common_source_dir, "scripts", "sancov.py")
+if not os.path.exists(sancov):
+  lit_config.fatal("Can't find script on path %r" % sancov)
+python_exec = get_required_attr(config, "python_executable")
+config.substitutions.append( ("%sancov", python_exec + " " + sancov + " ") )
+
+# Determine kernel bitness
+if config.host_arch.find('64') != -1 and config.android != "1":
+  kernel_bits = '64'
+else:
+  kernel_bits = '32'
+
+config.substitutions.append( ('CHECK-%kernel_bits', ("CHECK-kernel-" + kernel_bits + "-bits")))
+
+config.substitutions.append( ("%libdl", libdl_flag) )
+
+config.available_features.add("asan-" + config.bits + "-bits")
+
+if config.host_os == 'Darwin':
+  config.substitutions.append( ("%ld_flags_rpath_exe", '-Wl,-rpath,@executable_path/ %dynamiclib') )
+  config.substitutions.append( ("%ld_flags_rpath_so", '-install_name @rpath/`basename %dynamiclib`') )
+elif config.host_os == 'FreeBSD':
+  config.substitutions.append( ("%ld_flags_rpath_exe", "-Wl,-z,origin -Wl,-rpath,\$ORIGIN -L%T -l%xdynamiclib_namespec") )
+  config.substitutions.append( ("%ld_flags_rpath_so", '') )
+elif config.host_os == 'Linux':
+  config.substitutions.append( ("%ld_flags_rpath_exe", "-Wl,-rpath,\$ORIGIN -L%T -l%xdynamiclib_namespec") )
+  config.substitutions.append( ("%ld_flags_rpath_so", '') )
+
+# Must be defined after the substitutions that use %dynamiclib.
+config.substitutions.append( ("%dynamiclib", '%T/lib%xdynamiclib_namespec.so') )
+config.substitutions.append( ("%xdynamiclib_namespec", '$(basename %t).dynamic') )
+
+# Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
+# because the test hangs. Adding armhf as we now have two modes.
+if config.target_arch != 'arm' and config.target_arch != 'armhf' and config.target_arch != 'aarch64':
+  config.available_features.add('stable-runtime')
+
+# Turn on leak detection on 64-bit Linux.
+if config.host_os == 'Linux' and config.target_arch == 'x86_64':
+  config.available_features.add('leak-detection')
+
+# Set LD_LIBRARY_PATH to pick dynamic runtime up properly.
+push_dynamic_library_lookup_path(config, config.compiler_rt_libdir)
+
+# GCC-ASan uses dynamic runtime by default.
+if config.compiler_id == 'GNU':
+  gcc_dir = os.path.dirname(config.clang)
+  libasan_dir = os.path.join(gcc_dir, "..", "lib" + config.bits)
+  push_dynamic_library_lookup_path(config, libasan_dir)
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp']
+
+if config.host_os == 'Darwin':
+  config.suffixes.append('.mm')
+
+# Only run the tests on supported OSs.
+if config.host_os not in ['Linux', 'Darwin', 'FreeBSD', 'Windows']:
+  config.unsupported = True
diff --git a/compiler-rt/test/asan/lit.site.cfg.in b/compiler-rt/test/asan/lit.site.cfg.in
new file mode 100644
index 0000000..332f9ad
--- /dev/null
+++ b/compiler-rt/test/asan/lit.site.cfg.in
@@ -0,0 +1,19 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Tool-specific config options.
+config.name_suffix = "@ASAN_TEST_CONFIG_SUFFIX@"
+config.asan_lit_source_dir = "@ASAN_LIT_SOURCE_DIR@"
+config.target_cflags = "@ASAN_TEST_TARGET_CFLAGS@"
+config.clang = "@ASAN_TEST_TARGET_CC@"
+config.llvm_tools_dir = "@LLVM_TOOLS_BINARY_DIR@"
+config.bits = "@ASAN_TEST_BITS@"
+config.android = "@ANDROID@"
+config.asan_dynamic = @ASAN_TEST_DYNAMIC@
+config.target_arch = "@ASAN_TEST_TARGET_ARCH@"
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@ASAN_LIT_SOURCE_DIR@/lit.cfg")
diff --git a/compiler-rt/test/builtins/Unit/absvdi2_test.c b/compiler-rt/test/builtins/Unit/absvdi2_test.c
new file mode 100644
index 0000000..f69ae41
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/absvdi2_test.c
@@ -0,0 +1,65 @@
+//===-- absvdi2_test.c - Test __absvdi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __absvdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: absolute value
+
+// Effects: aborts if abs(x) < 0
+
+COMPILER_RT_ABI di_int __absvdi2(di_int a);
+
+int test__absvdi2(di_int a)
+{
+    di_int x = __absvdi2(a);
+    di_int expected = a;
+    if (expected < 0)
+        expected = -expected;
+    if (x != expected || expected < 0)
+        printf("error in __absvdi2(0x%llX) = %lld, expected positive %lld\n",
+               a, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     if (test__absvdi2(0x8000000000000000LL))  // should abort
+//         return 1;
+    if (test__absvdi2(0x0000000000000000LL))
+        return 1;
+    if (test__absvdi2(0x0000000000000001LL))
+        return 1;
+    if (test__absvdi2(0x0000000000000002LL))
+        return 1;
+    if (test__absvdi2(0x7FFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__absvdi2(0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__absvdi2(0x8000000000000001LL))
+        return 1;
+    if (test__absvdi2(0x8000000000000002LL))
+        return 1;
+    if (test__absvdi2(0xFFFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__absvdi2(0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__absvdi2(((di_int)rand() << 32) | rand()))
+            return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/absvsi2_test.c b/compiler-rt/test/builtins/Unit/absvsi2_test.c
new file mode 100644
index 0000000..c395cca
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/absvsi2_test.c
@@ -0,0 +1,65 @@
+//===-- absvsi2_test.c - Test __absvsi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __absvsi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: absolute value
+
+// Effects: aborts if abs(x) < 0
+
+COMPILER_RT_ABI si_int __absvsi2(si_int a);
+
+int test__absvsi2(si_int a)
+{
+    si_int x = __absvsi2(a);
+    si_int expected = a;
+    if (expected < 0)
+        expected = -expected;
+    if (x != expected || expected < 0)
+        printf("error in __absvsi2(0x%X) = %d, expected positive %d\n",
+               a, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     if (test__absvsi2(0x80000000))  // should abort
+//         return 1;
+    if (test__absvsi2(0x00000000))
+        return 1;
+    if (test__absvsi2(0x00000001))
+        return 1;
+    if (test__absvsi2(0x00000002))
+        return 1;
+    if (test__absvsi2(0x7FFFFFFE))
+        return 1;
+    if (test__absvsi2(0x7FFFFFFF))
+        return 1;
+    if (test__absvsi2(0x80000001))
+        return 1;
+    if (test__absvsi2(0x80000002))
+        return 1;
+    if (test__absvsi2(0xFFFFFFFE))
+        return 1;
+    if (test__absvsi2(0xFFFFFFFF))
+        return 1;
+
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__absvsi2(rand()))
+            return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/absvti2_test.c b/compiler-rt/test/builtins/Unit/absvti2_test.c
new file mode 100644
index 0000000..6c626e9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/absvti2_test.c
@@ -0,0 +1,84 @@
+//===-- absvti2_test.c - Test __absvti2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __absvti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: absolute value
+
+// Effects: aborts if abs(x) < 0
+
+COMPILER_RT_ABI ti_int __absvti2(ti_int a);
+
+int test__absvti2(ti_int a)
+{
+    ti_int x = __absvti2(a);
+    ti_int expected = a;
+    if (expected < 0)
+        expected = -expected;
+    if (x != expected || expected < 0)
+    {
+        twords at;
+        at.all = a;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __absvti2(0x%llX%.16llX) = "
+               "0x%llX%.16llX, expected positive 0x%llX%.16llX\n",
+               at.s.high, at.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+
+//     if (test__absvti2(make_ti(0x8000000000000000LL, 0)))  // should abort
+//         return 1;
+    if (test__absvti2(0x0000000000000000LL))
+        return 1;
+    if (test__absvti2(0x0000000000000001LL))
+        return 1;
+    if (test__absvti2(0x0000000000000002LL))
+        return 1;
+    if (test__absvti2(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFELL)))
+        return 1;
+    if (test__absvti2(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__absvti2(make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+    if (test__absvti2(make_ti(0x8000000000000000LL, 0x0000000000000002LL)))
+        return 1;
+    if (test__absvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFELL)))
+        return 1;
+    if (test__absvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__absvti2(make_ti(((ti_int)rand() << 32) | rand(),
+                                  ((ti_int)rand() << 32) | rand())))
+            return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/adddf3vfp_test.c b/compiler-rt/test/builtins/Unit/adddf3vfp_test.c
new file mode 100644
index 0000000..7395152
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/adddf3vfp_test.c
@@ -0,0 +1,49 @@
+//===-- adddf3vfp_test.c - Test __adddf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __adddf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern COMPILER_RT_ABI double __adddf3vfp(double a, double b);
+
+int test__adddf3vfp(double a, double b)
+{
+    double actual = __adddf3vfp(a, b);
+    double expected = a + b;
+    if (actual != expected)
+        printf("error in test__adddf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__adddf3vfp(1.0, 1.0))
+        return 1;
+    if (test__adddf3vfp(HUGE_VAL, HUGE_VAL))
+        return 1;
+    if (test__adddf3vfp(0.0, HUGE_VAL))
+        return 1;
+    if (test__adddf3vfp(0.0, -0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/addsf3vfp_test.c b/compiler-rt/test/builtins/Unit/addsf3vfp_test.c
new file mode 100644
index 0000000..4b3dccc
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/addsf3vfp_test.c
@@ -0,0 +1,49 @@
+//===-- addsf3vfp_test.c - Test __addsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __addsf3vfp(float a, float b);
+
+#if __arm__
+int test__addsf3vfp(float a, float b)
+{
+    float actual = __addsf3vfp(a, b);
+    float expected = a + b;
+    if (actual != expected)
+        printf("error in test__addsf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__addsf3vfp(1.0, 1.0))
+        return 1;
+    if (test__addsf3vfp(HUGE_VALF, HUGE_VALF))
+        return 1;
+    if (test__addsf3vfp(0.0, HUGE_VALF))
+        return 1;
+    if (test__addsf3vfp(0.0, -0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/addtf3_test.c b/compiler-rt/test/builtins/Unit/addtf3_test.c
new file mode 100644
index 0000000..7b92cce
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/addtf3_test.c
@@ -0,0 +1,82 @@
+//===--------------- addtf3_test.c - Test __addtf3 ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addtf3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: a + b
+COMPILER_RT_ABI long double __addtf3(long double a, long double b);
+
+int test__addtf3(long double a, long double b,
+                 uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __addtf3(a, b);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__addtf3(%.20Lf, %.20Lf) = %.20Lf, "
+               "expected %.20Lf\n", a, b, x,
+               fromRep128(expectedHi, expectedLo));
+    }
+
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN + any = qNaN
+    if (test__addtf3(makeQNaN128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // NaN + any = NaN
+    if (test__addtf3(makeNaN128(UINT64_C(0x800030000000)),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf + inf = inf
+    if (test__addtf3(makeInf128(),
+                     makeInf128(),
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf + any = inf
+    if (test__addtf3(makeInf128(),
+                     0x1.2335653452436234723489432abcdefp+5L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any + any
+    if (test__addtf3(0x1.23456734245345543849abcdefp+5L,
+                     0x1.edcba52449872455634654321fp-1L,
+                     UINT64_C(0x40042afc95c8b579),
+                     UINT64_C(0x61e58dd6c51eb77c)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/addvdi3_test.c b/compiler-rt/test/builtins/Unit/addvdi3_test.c
new file mode 100644
index 0000000..5f8729a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/addvdi3_test.c
@@ -0,0 +1,58 @@
+//===-- addvdi3_test.c - Test __addvdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addvdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a + b
+
+// Effects: aborts if a + b overflows
+
+COMPILER_RT_ABI di_int __addvdi3(di_int a, di_int b);
+
+int test__addvdi3(di_int a, di_int b)
+{
+    di_int x = __addvdi3(a, b);
+    di_int expected = a + b;
+    if (x != expected)
+        printf("error in test__addvdi3(0x%llX, 0x%llX) = %lld, expected %lld\n",
+                a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     test__addvdi3(0x8000000000000000LL, -1);  // should abort
+//     test__addvdi3(-1, 0x8000000000000000LL);  // should abort
+//     test__addvdi3(1, 0x7FFFFFFFFFFFFFFFLL);  // should abort
+//     test__addvdi3(0x7FFFFFFFFFFFFFFFLL, 1);  // should abort
+
+    if (test__addvdi3(0x8000000000000000LL, 1))
+        return 1;
+    if (test__addvdi3(1, 0x8000000000000000LL))
+        return 1;
+    if (test__addvdi3(0x8000000000000000LL, 0))
+        return 1;
+    if (test__addvdi3(0, 0x8000000000000000LL))
+        return 1;
+    if (test__addvdi3(0x7FFFFFFFFFFFFFFLL, -1))
+        return 1;
+    if (test__addvdi3(-1, 0x7FFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__addvdi3(0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+    if (test__addvdi3(0, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/addvsi3_test.c b/compiler-rt/test/builtins/Unit/addvsi3_test.c
new file mode 100644
index 0000000..b5358d0
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/addvsi3_test.c
@@ -0,0 +1,58 @@
+//===-- addvsi3_test.c - Test __addvsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addvsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a + b
+
+// Effects: aborts if a + b overflows
+
+COMPILER_RT_ABI si_int __addvsi3(si_int a, si_int b);
+
+int test__addvsi3(si_int a, si_int b)
+{
+    si_int x = __addvsi3(a, b);
+    si_int expected = a + b;
+    if (x != expected)
+        printf("error in test__addvsi3(0x%X, 0x%X) = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     test__addvsi3(0x80000000, -1);  // should abort
+//     test__addvsi3(-1, 0x80000000);  // should abort
+//     test__addvsi3(1, 0x7FFFFFFF);  // should abort
+//     test__addvsi3(0x7FFFFFFF, 1);  // should abort
+
+    if (test__addvsi3(0x80000000, 1))
+        return 1;
+    if (test__addvsi3(1, 0x80000000))
+        return 1;
+    if (test__addvsi3(0x80000000, 0))
+        return 1;
+    if (test__addvsi3(0, 0x80000000))
+        return 1;
+    if (test__addvsi3(0x7FFFFFFF, -1))
+        return 1;
+    if (test__addvsi3(-1, 0x7FFFFFFF))
+        return 1;
+    if (test__addvsi3(0x7FFFFFFF, 0))
+        return 1;
+    if (test__addvsi3(0, 0x7FFFFFFF))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/addvti3_test.c b/compiler-rt/test/builtins/Unit/addvti3_test.c
new file mode 100644
index 0000000..e2f75cf
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/addvti3_test.c
@@ -0,0 +1,94 @@
+//===-- addvti3_test.c - Test __addvti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addvti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a + b
+
+// Effects: aborts if a + b overflows
+
+COMPILER_RT_ABI ti_int __addvti3(ti_int a, ti_int b);
+
+int test__addvti3(ti_int a, ti_int b)
+{
+    ti_int x = __addvti3(a, b);
+    ti_int expected = a + b;
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in test__addvti3(0x%llX%.16llX, 0x%llX%.16llX) = "
+               "0x%llX%.16llX, expected 0x%llX%.16llX\n",
+                at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+                expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+// should abort
+//     test__addvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                   make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL));
+// should abort
+//     test__addvti3(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+//                   make_ti(0x8000000000000000LL, 0x0000000000000000LL));
+// should abort
+//     test__addvti3(make_ti(0x0000000000000000LL, 0x0000000000000001LL),
+//                   make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL));
+// should abort
+//     test__addvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+//                   make_ti(0x0000000000000000LL, 0x0000000000000001LL));
+
+    if (test__addvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      make_ti(0x0000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+    if (test__addvti3(make_ti(0x0000000000000000LL, 0x0000000000000001LL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__addvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      make_ti(0x0000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__addvti3(make_ti(0x0000000000000000LL, 0x0000000000000000LL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__addvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__addvti3(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__addvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0x0000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__addvti3(make_ti(0x0000000000000000LL, 0x0000000000000000LL),
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/aeabi_cdcmpeq_test.c b/compiler-rt/test/builtins/Unit/arm/aeabi_cdcmpeq_test.c
new file mode 100644
index 0000000..ce8b0a4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/aeabi_cdcmpeq_test.c
@@ -0,0 +1,70 @@
+//===-- aeabi_cdcmpeq.c - Test __aeabi_cdcmpeq ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __aeabi_cdcmpeq for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#if __arm__
+#include "call_apsr.h"
+
+extern __attribute__((pcs("aapcs"))) void __aeabi_cdcmpeq(double a, double b);
+
+int test__aeabi_cdcmpeq(double a, double b, int expected)
+{
+    uint32_t cpsr_value = call_apsr_d(a, b, __aeabi_cdcmpeq);
+    union cpsr cpsr = { .value = cpsr_value };
+    if (expected != cpsr.flags.z) {
+        printf("error in __aeabi_cdcmpeq(%f, %f) => Z = %d, expected %d\n",
+               a, b, cpsr.flags.z, expected);
+        return 1;
+    }
+    return 0;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__aeabi_cdcmpeq(1.0, 1.0, 1))
+        return 1;
+    if (test__aeabi_cdcmpeq(1234.567, 765.4321, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(-123.0, -678.0, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(0.0, -0.0, 1))
+        return 1;
+    if (test__aeabi_cdcmpeq(1.0, NAN, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(NAN, 1.0, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(NAN, NAN, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(INFINITY, 1.0, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(0.0, INFINITY, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(-INFINITY, 0.0, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(0.0, -INFINITY, 0))
+        return 1;
+    if (test__aeabi_cdcmpeq(INFINITY, INFINITY, 1))
+        return 1;
+    if (test__aeabi_cdcmpeq(-INFINITY, -INFINITY, 1))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/aeabi_cdcmple_test.c b/compiler-rt/test/builtins/Unit/arm/aeabi_cdcmple_test.c
new file mode 100644
index 0000000..afc7014
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/aeabi_cdcmple_test.c
@@ -0,0 +1,92 @@
+//===-- aeabi_cdcmple.c - Test __aeabi_cdcmple and __aeabi_cdrcmple -------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __aeabi_cdcmple and __aeabi_cdrcmple for the compiler_rt
+// library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "call_apsr.h"
+
+#if __arm__
+
+extern __attribute__((pcs("aapcs"))) void __aeabi_cdcmple(double a, double b);
+extern __attribute__((pcs("aapcs"))) void __aeabi_cdrcmple(double a, double b);
+
+int test__aeabi_cdcmple(double a, double b, int expected)
+{
+    int32_t cpsr_value = call_apsr_d(a, b, __aeabi_cdcmple);
+    int32_t r_cpsr_value = call_apsr_d(b, a, __aeabi_cdrcmple);
+
+    if (cpsr_value != r_cpsr_value) {
+        printf("error: __aeabi_cdcmple(%f, %f) != __aeabi_cdrcmple(%f, %f)\n", a, b, b, a);
+        return 1;
+    }
+
+    int expected_z, expected_c;
+    if (expected == -1) {
+        expected_z = 0;
+        expected_c = 0;
+    } else if (expected == 0) {
+        expected_z = 1;
+        expected_c = 1;
+    } else {
+        // a or b is NaN, or a > b
+        expected_z = 0;
+        expected_c = 1;
+    }
+
+    union cpsr cpsr = { .value = cpsr_value };
+    if (expected_z != cpsr.flags.z || expected_c != cpsr.flags.c) {
+        printf("error in __aeabi_cdcmple(%f, %f) => (Z = %d, C = %d), expected (Z = %d, C = %d)\n",
+               a, b, cpsr.flags.z, cpsr.flags.c, expected_z, expected_c);
+        return 1;
+    }
+
+    cpsr.value = r_cpsr_value;
+    if (expected_z != cpsr.flags.z || expected_c != cpsr.flags.c) {
+        printf("error in __aeabi_cdrcmple(%f, %f) => (Z = %d, C = %d), expected (Z = %d, C = %d)\n",
+               a, b, cpsr.flags.z, cpsr.flags.c, expected_z, expected_c);
+        return 1;
+    }
+    return 0;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__aeabi_cdcmple(1.0, 1.0, 0))
+        return 1;
+    if (test__aeabi_cdcmple(1234.567, 765.4321, 1))
+        return 1;
+    if (test__aeabi_cdcmple(765.4321, 1234.567, -1))
+        return 1;
+    if (test__aeabi_cdcmple(-123.0, -678.0, 1))
+        return 1;
+    if (test__aeabi_cdcmple(-678.0, -123.0, -1))
+        return 1;
+    if (test__aeabi_cdcmple(0.0, -0.0, 0))
+        return 1;
+    if (test__aeabi_cdcmple(1.0, NAN, 1))
+        return 1;
+    if (test__aeabi_cdcmple(NAN, 1.0, 1))
+        return 1;
+    if (test__aeabi_cdcmple(NAN, NAN, 1))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/aeabi_cfcmpeq_test.c b/compiler-rt/test/builtins/Unit/arm/aeabi_cfcmpeq_test.c
new file mode 100644
index 0000000..fe01664
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/aeabi_cfcmpeq_test.c
@@ -0,0 +1,70 @@
+//===-- aeabi_cfcmpeq.c - Test __aeabi_cfcmpeq ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __aeabi_cfcmpeq for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#if __arm__
+#include "call_apsr.h"
+
+extern __attribute__((pcs("aapcs"))) void __aeabi_cfcmpeq(float a, float b);
+
+int test__aeabi_cfcmpeq(float a, float b, int expected)
+{
+    uint32_t cpsr_value = call_apsr_f(a, b, __aeabi_cfcmpeq);
+    union cpsr cpsr = { .value = cpsr_value };
+    if (expected != cpsr.flags.z) {
+        printf("error in __aeabi_cfcmpeq(%f, %f) => Z = %d, expected %d\n",
+               a, b, cpsr.flags.z, expected);
+        return 1;
+    }
+    return 0;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__aeabi_cfcmpeq(1.0, 1.0, 1))
+        return 1;
+    if (test__aeabi_cfcmpeq(1234.567, 765.4321, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(-123.0, -678.0, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(0.0, -0.0, 1))
+        return 1;
+    if (test__aeabi_cfcmpeq(1.0, NAN, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(NAN, 1.0, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(NAN, NAN, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(INFINITY, 1.0, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(0.0, INFINITY, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(-INFINITY, 0.0, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(0.0, -INFINITY, 0))
+        return 1;
+    if (test__aeabi_cfcmpeq(INFINITY, INFINITY, 1))
+        return 1;
+    if (test__aeabi_cfcmpeq(-INFINITY, -INFINITY, 1))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/aeabi_cfcmple_test.c b/compiler-rt/test/builtins/Unit/arm/aeabi_cfcmple_test.c
new file mode 100644
index 0000000..aebe425
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/aeabi_cfcmple_test.c
@@ -0,0 +1,92 @@
+//===-- aeabi_cfcmple.c - Test __aeabi_cfcmple and __aeabi_cfrcmple -------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __aeabi_cfcmple and __aeabi_cfrcmple for the compiler_rt
+// library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "call_apsr.h"
+
+#if __arm__
+
+extern __attribute__((pcs("aapcs"))) void __aeabi_cfcmple(float a, float b);
+extern __attribute__((pcs("aapcs"))) void __aeabi_cfrcmple(float a, float b);
+
+int test__aeabi_cfcmple(float a, float b, int expected)
+{
+    int32_t cpsr_value = call_apsr_f(a, b, __aeabi_cfcmple);
+    int32_t r_cpsr_value = call_apsr_f(b, a, __aeabi_cfrcmple);
+
+    if (cpsr_value != r_cpsr_value) {
+        printf("error: __aeabi_cfcmple(%f, %f) != __aeabi_cfrcmple(%f, %f)\n", a, b, b, a);
+        return 1;
+    }
+
+    int expected_z, expected_c;
+    if (expected == -1) {
+        expected_z = 0;
+        expected_c = 0;
+    } else if (expected == 0) {
+        expected_z = 1;
+        expected_c = 1;
+    } else {
+        // a or b is NaN, or a > b
+        expected_z = 0;
+        expected_c = 1;
+    }
+
+    union cpsr cpsr = { .value = cpsr_value };
+    if (expected_z != cpsr.flags.z || expected_c != cpsr.flags.c) {
+        printf("error in __aeabi_cfcmple(%f, %f) => (Z = %d, C = %d), expected (Z = %d, C = %d)\n",
+               a, b, cpsr.flags.z, cpsr.flags.c, expected_z, expected_c);
+        return 1;
+    }
+
+    cpsr.value = r_cpsr_value;
+    if (expected_z != cpsr.flags.z || expected_c != cpsr.flags.c) {
+        printf("error in __aeabi_cfrcmple(%f, %f) => (Z = %d, C = %d), expected (Z = %d, C = %d)\n",
+               a, b, cpsr.flags.z, cpsr.flags.c, expected_z, expected_c);
+        return 1;
+    }
+    return 0;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__aeabi_cfcmple(1.0, 1.0, 0))
+        return 1;
+    if (test__aeabi_cfcmple(1234.567, 765.4321, 1))
+        return 1;
+    if (test__aeabi_cfcmple(765.4321, 1234.567, -1))
+        return 1;
+    if (test__aeabi_cfcmple(-123.0, -678.0, 1))
+        return 1;
+    if (test__aeabi_cfcmple(-678.0, -123.0, -1))
+        return 1;
+    if (test__aeabi_cfcmple(0.0, -0.0, 0))
+        return 1;
+    if (test__aeabi_cfcmple(1.0, NAN, 1))
+        return 1;
+    if (test__aeabi_cfcmple(NAN, 1.0, 1))
+        return 1;
+    if (test__aeabi_cfcmple(NAN, NAN, 1))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/aeabi_drsub_test.c b/compiler-rt/test/builtins/Unit/arm/aeabi_drsub_test.c
new file mode 100644
index 0000000..7d867ef
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/aeabi_drsub_test.c
@@ -0,0 +1,47 @@
+//===-- aeabi_drsub.c - Test __aeabi_drsub --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __aeabi_drsub for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern __attribute__((pcs("aapcs"))) double __aeabi_drsub(double a, double b);
+
+int test__aeabi_drsub(double a, double b, double expected)
+{
+    double actual = __aeabi_drsub(a, b);
+    if (actual != expected)
+        printf("error in __aeabi_drsub(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__aeabi_drsub(1.0, 1.0, 0.0))
+        return 1;
+    if (test__aeabi_drsub(1234.567, 765.4321, -469.134900))
+        return 1;
+    if (test__aeabi_drsub(-123.0, -678.0, -555.0))
+        return 1;
+    if (test__aeabi_drsub(0.0, -0.0, 0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/aeabi_frsub_test.c b/compiler-rt/test/builtins/Unit/arm/aeabi_frsub_test.c
new file mode 100644
index 0000000..b8b21b9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/aeabi_frsub_test.c
@@ -0,0 +1,47 @@
+//===-- aeabi_frsub.c - Test __aeabi_frsub --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __aeabi_frsub for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern __attribute__((pcs("aapcs"))) float __aeabi_frsub(float a, float b);
+
+int test__aeabi_frsub(float a, float b, float expected)
+{
+    float actual = __aeabi_frsub(a, b);
+    if (actual != expected)
+        printf("error in __aeabi_frsub(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__aeabi_frsub(1.0, 1.0, 0.0))
+        return 1;
+    if (test__aeabi_frsub(1234.567, 765.4321, -469.134900))
+        return 1;
+    if (test__aeabi_frsub(-123.0, -678.0, -555.0))
+        return 1;
+    if (test__aeabi_frsub(0.0, -0.0, 0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/arm/call_apsr.S b/compiler-rt/test/builtins/Unit/arm/call_apsr.S
new file mode 100644
index 0000000..b5e154c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/call_apsr.S
@@ -0,0 +1,43 @@
+//===-- call_apsr.S - Helpers for ARM EABI floating point tests -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements helpers for ARM EABI floating point tests for the
+// compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../../../../lib/builtins/assembly.h"
+
+.syntax unified
+// __attribute__((pcs("aapcs")))
+// int32_t call_apsr_d(double a, double b, void(*fn)(double, double)) {
+//   fn(a, b);
+//   return apsr;
+// }
+
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(call_apsr_d)
+    push {lr}
+    ldr ip, [sp, #4]
+    blx ip
+    mrs r0, apsr
+    pop {pc}
+END_COMPILERRT_FUNCTION(call_apsr_d)
+
+// __attribute__((pcs("aapcs")))
+// int32_t call_apsr_f(float a, float b, void(*fn)(float, float)) {
+//   fn(a, b);
+//   return apsr;
+// }
+
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(call_apsr_f)
+    push {lr}
+    blx r2
+    mrs r0, apsr
+    pop {pc}
+END_COMPILERRT_FUNCTION(call_apsr_f)
diff --git a/compiler-rt/test/builtins/Unit/arm/call_apsr.h b/compiler-rt/test/builtins/Unit/arm/call_apsr.h
new file mode 100644
index 0000000..5443841
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/arm/call_apsr.h
@@ -0,0 +1,39 @@
+//===-- call_apsr.h - Helpers for ARM EABI floating point tests -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares helpers for ARM EABI floating point tests for the
+// compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CALL_APSR_H
+#define CALL_APSR_H
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+#error big endian support not implemented
+#endif
+
+union cpsr {
+    struct {
+        uint32_t filler: 28;
+        uint32_t v: 1;
+        uint32_t c: 1;
+        uint32_t z: 1;
+        uint32_t n: 1;
+    } flags;
+    uint32_t value;
+};
+
+extern __attribute__((pcs("aapcs")))
+uint32_t call_apsr_f(float a, float b, __attribute__((pcs("aapcs"))) void (*fn)(float, float));
+
+extern __attribute__((pcs("aapcs")))
+uint32_t call_apsr_d(double a, double b, __attribute__((pcs("aapcs"))) void (*fn)(double, double));
+
+#endif // CALL_APSR_H
diff --git a/compiler-rt/test/builtins/Unit/ashldi3_test.c b/compiler-rt/test/builtins/Unit/ashldi3_test.c
new file mode 100644
index 0000000..398fb69
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ashldi3_test.c
@@ -0,0 +1,77 @@
+//===-- ashldi3_test.c - Test __ashldi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ashldi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a << b
+
+// Precondition:  0 <= b < bits_in_dword
+
+COMPILER_RT_ABI di_int __ashldi3(di_int a, si_int b);
+
+int test__ashldi3(di_int a, si_int b, di_int expected)
+{
+    di_int x = __ashldi3(a, b);
+    if (x != expected)
+        printf("error in __ashldi3: %llX << %d = %llX, expected %llX\n",
+               a, b, __ashldi3(a, b), expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__ashldi3(0x0123456789ABCDEFLL, 0, 0x123456789ABCDEFLL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 1, 0x2468ACF13579BDELL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 2, 0x48D159E26AF37BCLL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 3, 0x91A2B3C4D5E6F78LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 4, 0x123456789ABCDEF0LL))
+        return 1;
+
+    if (test__ashldi3(0x0123456789ABCDEFLL, 28, 0x789ABCDEF0000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 29, 0xF13579BDE0000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 30, 0xE26AF37BC0000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 31, 0xC4D5E6F780000000LL))
+        return 1;
+
+    if (test__ashldi3(0x0123456789ABCDEFLL, 32, 0x89ABCDEF00000000LL))
+        return 1;
+
+    if (test__ashldi3(0x0123456789ABCDEFLL, 33, 0x13579BDE00000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 34, 0x26AF37BC00000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 35, 0x4D5E6F7800000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 36, 0x9ABCDEF000000000LL))
+        return 1;
+
+    if (test__ashldi3(0x0123456789ABCDEFLL, 60, 0xF000000000000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 61, 0xE000000000000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 62, 0xC000000000000000LL))
+        return 1;
+    if (test__ashldi3(0x0123456789ABCDEFLL, 63, 0x8000000000000000LL))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ashlti3_test.c b/compiler-rt/test/builtins/Unit/ashlti3_test.c
new file mode 100644
index 0000000..595e353
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ashlti3_test.c
@@ -0,0 +1,175 @@
+//===-- ashlti3_test.c - Test __ashlti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ashlti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a << b
+
+// Precondition:  0 <= b < bits_in_tword
+
+COMPILER_RT_ABI ti_int __ashlti3(ti_int a, si_int b);
+
+int test__ashlti3(ti_int a, si_int b, ti_int expected)
+{
+    ti_int x = __ashlti3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __ashlti3: 0x%llX%.16llX << %d = 0x%llX%.16llX,"
+               " expected 0x%llX%.16llX\n",
+                at.s.high, at.s.low, b, xt.s.high, xt.s.low,
+                expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 0,
+                      make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 1,
+                      make_ti(0xFDB97530ECA8642BLL, 0xFDB97530ECA8642ALL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 2,
+                      make_ti(0xFB72EA61D950C857LL, 0XFB72EA61D950C854LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 3,
+                      make_ti(0xF6E5D4C3B2A190AFLL, 0xF6E5D4C3B2A190A8LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 4,
+                      make_ti(0xEDCBA9876543215FLL, 0xEDCBA98765432150LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 28,
+                      make_ti(0x876543215FEDCBA9LL, 0x8765432150000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 29,
+                      make_ti(0x0ECA8642BFDB9753LL, 0x0ECA8642A0000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 30,
+                      make_ti(0x1D950C857FB72EA6LL, 0x1D950C8540000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 31,
+                      make_ti(0x3B2A190AFF6E5D4CLL, 0x3B2A190A80000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 32,
+                      make_ti(0x76543215FEDCBA98LL, 0x7654321500000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 33,
+                      make_ti(0xECA8642BFDB97530LL, 0xECA8642A00000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 34,
+                      make_ti(0xD950C857FB72EA61LL, 0xD950C85400000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 35,
+                      make_ti(0xB2A190AFF6E5D4C3LL, 0xB2A190A800000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 36,
+                      make_ti(0x6543215FEDCBA987LL, 0x6543215000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 60,
+                      make_ti(0x5FEDCBA987654321LL, 0x5000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 61,
+                      make_ti(0xBFDB97530ECA8642LL, 0xA000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 62,
+                      make_ti(0x7FB72EA61D950C85LL, 0x4000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 63,
+                      make_ti(0xFF6E5D4C3B2A190ALL, 0x8000000000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 64,
+                      make_ti(0xFEDCBA9876543215LL, 0x0000000000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 65,
+                      make_ti(0xFDB97530ECA8642ALL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 66,
+                      make_ti(0xFB72EA61D950C854LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 67,
+                      make_ti(0xF6E5D4C3B2A190A8LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 68,
+                      make_ti(0xEDCBA98765432150LL, 0x0000000000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 92,
+                      make_ti(0x8765432150000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 93,
+                      make_ti(0x0ECA8642A0000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 94,
+                      make_ti(0x1D950C8540000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 95,
+                      make_ti(0x3B2A190A80000000LL, 0x0000000000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 96,
+                      make_ti(0x7654321500000000LL, 0x0000000000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 97,
+                      make_ti(0xECA8642A00000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 98,
+                      make_ti(0xD950C85400000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 99,
+                      make_ti(0xB2A190A800000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 100,
+                      make_ti(0x6543215000000000LL, 0x0000000000000000LL)))
+        return 1;
+
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 124,
+                      make_ti(0x5000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 125,
+                      make_ti(0xA000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 126,
+                      make_ti(0x4000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__ashlti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 127,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ashrdi3_test.c b/compiler-rt/test/builtins/Unit/ashrdi3_test.c
new file mode 100644
index 0000000..ee6409c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ashrdi3_test.c
@@ -0,0 +1,118 @@
+//===-- ashrdi3_test.c - Test __ashrdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ashrdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: arithmetic a >> b
+
+// Precondition:  0 <= b < bits_in_dword
+
+COMPILER_RT_ABI di_int __ashrdi3(di_int a, si_int b);
+
+int test__ashrdi3(di_int a, si_int b, di_int expected)
+{
+    di_int x = __ashrdi3(a, b);
+    if (x != expected)
+        printf("error in __ashrdi3: %llX >> %d = %llX, expected %llX\n",
+               a, b, __ashrdi3(a, b), expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 0, 0x123456789ABCDEFLL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 1, 0x91A2B3C4D5E6F7LL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 2, 0x48D159E26AF37BLL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 3, 0x2468ACF13579BDLL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 4, 0x123456789ABCDELL))
+        return 1;
+
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 28, 0x12345678LL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 29, 0x91A2B3CLL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 30, 0x48D159ELL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 31, 0x2468ACFLL))
+        return 1;
+
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 32, 0x1234567LL))
+        return 1;
+
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 33, 0x91A2B3LL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 34, 0x48D159LL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 35, 0x2468ACLL))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 36, 0x123456LL))
+        return 1;
+
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 60, 0))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 61, 0))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 62, 0))
+        return 1;
+    if (test__ashrdi3(0x0123456789ABCDEFLL, 63, 0))
+        return 1;
+
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 0, 0xFEDCBA9876543210LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 1, 0xFF6E5D4C3B2A1908LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 2, 0xFFB72EA61D950C84LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 3, 0xFFDB97530ECA8642LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 4, 0xFFEDCBA987654321LL))
+        return 1;
+
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 28, 0xFFFFFFFFEDCBA987LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 29, 0xFFFFFFFFF6E5D4C3LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 30, 0xFFFFFFFFFB72EA61LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 31, 0xFFFFFFFFFDB97530LL))
+        return 1;
+
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 32, 0xFFFFFFFFFEDCBA98LL))
+        return 1;
+
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 33, 0xFFFFFFFFFF6E5D4CLL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 34, 0xFFFFFFFFFFB72EA6LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 35, 0xFFFFFFFFFFDB9753LL))
+        return 1;
+    if (test__ashrdi3(0xFEDCBA9876543210LL, 36, 0xFFFFFFFFFFEDCBA9LL))
+        return 1;
+
+    if (test__ashrdi3(0xAEDCBA9876543210LL, 60, 0xFFFFFFFFFFFFFFFALL))
+        return 1;
+    if (test__ashrdi3(0xAEDCBA9876543210LL, 61, 0xFFFFFFFFFFFFFFFDLL))
+        return 1;
+    if (test__ashrdi3(0xAEDCBA9876543210LL, 62, 0xFFFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__ashrdi3(0xAEDCBA9876543210LL, 63, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ashrti3_test.c b/compiler-rt/test/builtins/Unit/ashrti3_test.c
new file mode 100644
index 0000000..201582d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ashrti3_test.c
@@ -0,0 +1,173 @@
+//===-- ashrti3_test.c - Test __ashrti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ashrti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: arithmetic a >> b
+
+// Precondition:  0 <= b < bits_in_tword
+
+COMPILER_RT_ABI ti_int __ashrti3(ti_int a, si_int b);
+
+int test__ashrti3(ti_int a, si_int b, ti_int expected)
+{
+    ti_int x = __ashrti3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __ashrti3: 0x%llX%.16llX >> %d = 0x%llX%.16llX,"
+               " expected 0x%llX%.16llX\n",
+                at.s.high, at.s.low, b, xt.s.high, xt.s.low,
+                expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 0,
+                      make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 1,
+                      make_ti(0xFF6E5D4C3B2A190ALL, 0xFF6E5D4C3B2A190ALL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 2,
+                      make_ti(0xFFB72EA61D950C85LL, 0x7FB72EA61D950C85LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 3,
+                      make_ti(0xFFDB97530ECA8642LL, 0xBFDB97530ECA8642LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 4,
+                      make_ti(0xFFEDCBA987654321LL, 0x5FEDCBA987654321LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 28,
+                      make_ti(0xFFFFFFFFEDCBA987LL, 0x6543215FEDCBA987LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 29,
+                      make_ti(0xFFFFFFFFF6E5D4C3LL, 0xB2A190AFF6E5D4C3LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 30,
+                      make_ti(0xFFFFFFFFFB72EA61LL, 0xD950C857FB72EA61LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 31,
+                      make_ti(0xFFFFFFFFFDB97530LL, 0xECA8642BFDB97530LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 32,
+                      make_ti(0xFFFFFFFFFEDCBA98LL, 0x76543215FEDCBA98LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 33,
+                      make_ti(0xFFFFFFFFFF6E5D4CLL, 0x3B2A190AFF6E5D4CLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 34,
+                      make_ti(0xFFFFFFFFFFB72EA6LL, 0x1D950C857FB72EA6LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 35,
+                      make_ti(0xFFFFFFFFFFDB9753LL, 0x0ECA8642BFDB9753LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 36,
+                      make_ti(0xFFFFFFFFFFEDCBA9LL, 0x876543215FEDCBA9LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 60,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xEDCBA9876543215FLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 61,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xF6E5D4C3B2A190AFLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 62,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFB72EA61D950C857LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 63,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFDB97530ECA8642BLL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 64,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFEDCBA9876543215LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 65,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFF6E5D4C3B2A190ALL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 66,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFB72EA61D950C85LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 67,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFDB97530ECA8642LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 68,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFEDCBA987654321LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 92,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFEDCBA987LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 93,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFF6E5D4C3LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 94,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFB72EA61LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 95,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFDB97530LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 96,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFEDCBA98LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 97,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFF6E5D4CLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 98,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFB72EA6LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 99,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFDB9753LL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 100,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFEDCBA9LL)))
+        return 1;
+
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 124,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 125,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 126,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__ashrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 127,
+                      make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/bswapdi2_test.c b/compiler-rt/test/builtins/Unit/bswapdi2_test.c
new file mode 100644
index 0000000..2d830cf
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/bswapdi2_test.c
@@ -0,0 +1,44 @@
+//===-- bswapdi2_test.c - Test __bswapdi2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __bswapdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern uint64_t __bswapdi2(uint64_t);
+
+#if __arm__
+int test__bswapdi2(uint64_t a, uint64_t expected)
+{
+    uint64_t actual = __bswapdi2(a);
+    if (actual != expected)
+        printf("error in test__bswapsi2(0x%0llX) = 0x%0llX, expected 0x%0llX\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__bswapdi2(0x123456789ABCDEF0LL, 0xF0DEBC9A78563412LL))
+        return 1;
+    if (test__bswapdi2(0x0000000100000002LL, 0x0200000001000000LL))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/bswapsi2_test.c b/compiler-rt/test/builtins/Unit/bswapsi2_test.c
new file mode 100644
index 0000000..4488a88
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/bswapsi2_test.c
@@ -0,0 +1,44 @@
+//===-- bswapsi2_test.c - Test __bswapsi2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __bswapsi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern uint32_t __bswapsi2(uint32_t);
+
+#if __arm__
+int test__bswapsi2(uint32_t a, uint32_t expected)
+{
+    uint32_t actual = __bswapsi2(a);
+    if (actual != expected)
+        printf("error in test__bswapsi2(0x%0X) = 0x%0X, expected 0x%0X\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__bswapsi2(0x12345678, 0x78563412))
+        return 1;
+    if (test__bswapsi2(0x00000001, 0x01000000))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/clear_cache_test.c b/compiler-rt/test/builtins/Unit/clear_cache_test.c
new file mode 100644
index 0000000..3c89301
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/clear_cache_test.c
@@ -0,0 +1,85 @@
+//===-- clear_cache_test.c - Test clear_cache -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#if defined(_WIN32)
+#include <windows.h>
+void __clear_cache(void* start, void* end)
+{
+    if (!FlushInstructionCache(GetCurrentProcess(), start, end-start))
+        exit(1);
+}
+#else
+#include <sys/mman.h>
+extern void __clear_cache(void* start, void* end);
+#endif
+
+
+
+
+typedef int (*pfunc)(void);
+
+int func1() 
+{
+    return 1;
+}
+
+int func2() 
+{
+    return 2;
+}
+
+void *__attribute__((noinline))
+memcpy_f(void *dst, const void *src, size_t n) {
+// ARM and MIPS nartually align functions, but use the LSB for ISA selection
+// (THUMB, MIPS16/uMIPS respectively).  Ensure that the ISA bit is ignored in
+// the memcpy
+#if defined(__arm__) || defined(__mips__)
+  return (void *)((uintptr_t)memcpy(dst, (void *)((uintptr_t)src & ~1), n) |
+                  ((uintptr_t)src & 1));
+#else
+  return memcpy(dst, (void *)((uintptr_t)src), n);
+#endif
+}
+
+unsigned char execution_buffer[128];
+
+int main()
+{
+    // make executable the page containing execution_buffer 
+    char* start = (char*)((uintptr_t)execution_buffer & (-4095));
+    char* end = (char*)((uintptr_t)(&execution_buffer[128+4096]) & (-4095));
+#if defined(_WIN32)
+    DWORD dummy_oldProt;
+    MEMORY_BASIC_INFORMATION b;
+    if (!VirtualQuery(start, &b, sizeof(b)))
+        return 1;
+    if (!VirtualProtect(b.BaseAddress, b.RegionSize, PAGE_EXECUTE_READWRITE, &b.Protect))
+#else
+    if (mprotect(start, end-start, PROT_READ|PROT_WRITE|PROT_EXEC) != 0)
+#endif
+        return 1;
+
+    // verify you can copy and execute a function
+    pfunc f1 = (pfunc)memcpy_f(execution_buffer, func1, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    if ((*f1)() != 1)
+        return 1;
+
+    // verify you can overwrite a function with another
+    pfunc f2 = (pfunc)memcpy_f(execution_buffer, func2, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    if ((*f2)() != 2)
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/clzdi2_test.c b/compiler-rt/test/builtins/Unit/clzdi2_test.c
new file mode 100644
index 0000000..41e1209
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/clzdi2_test.c
@@ -0,0 +1,68 @@
+//===-- clzdi2_test.c - Test __clzdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __clzdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the number of leading 0-bits
+
+// Precondition: a != 0
+
+COMPILER_RT_ABI si_int __clzdi2(di_int a);
+
+int test__clzdi2(di_int a, si_int expected)
+{
+    si_int x = __clzdi2(a);
+    if (x != expected)
+        printf("error in __clzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    const int N = (int)(sizeof(di_int) * CHAR_BIT);
+//    if (test__clzdi2(0x00000000, N))  // undefined
+//        return 1;
+    if (test__clzdi2(0x00000001, N-1))
+        return 1;
+    if (test__clzdi2(0x00000002, N-2))
+        return 1;
+    if (test__clzdi2(0x00000003, N-2))
+        return 1;
+    if (test__clzdi2(0x00000004, N-3))
+        return 1;
+    if (test__clzdi2(0x00000005, N-3))
+        return 1;
+    if (test__clzdi2(0x0000000A, N-4))
+        return 1;
+    if (test__clzdi2(0x1000000A, N/2+3))
+        return 1;
+    if (test__clzdi2(0x2000000A, N/2+2))
+        return 1;
+    if (test__clzdi2(0x6000000A, N/2+1))
+        return 1;
+    if (test__clzdi2(0x8000000AuLL, N/2))
+        return 1;
+    if (test__clzdi2(0x000005008000000AuLL, 21))
+        return 1;
+    if (test__clzdi2(0x020005008000000AuLL, 6))
+        return 1;
+    if (test__clzdi2(0x720005008000000AuLL, 1))
+        return 1;
+    if (test__clzdi2(0x820005008000000AuLL, 0))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/clzsi2_test.c b/compiler-rt/test/builtins/Unit/clzsi2_test.c
new file mode 100644
index 0000000..80b300f
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/clzsi2_test.c
@@ -0,0 +1,599 @@
+//===-- clzsi2_test.c - Test __clzsi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __clzsi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the number of leading 0-bits
+
+// Precondition: a != 0
+
+COMPILER_RT_ABI si_int __clzsi2(si_int a);
+
+int test__clzsi2(si_int a, si_int expected)
+{
+    si_int x = __clzsi2(a);
+    if (x != expected)
+        printf("error in __clzsi2(0x%X) = %d, expected %d\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+//    if (test__clzsi2(0x00000000, 32))  // undefined
+//        return 1;
+    if (test__clzsi2(0x00800000, 8))
+        return 1;
+    if (test__clzsi2(0x01000000, 7))
+        return 1;
+    if (test__clzsi2(0x02000000, 6))
+        return 1;
+    if (test__clzsi2(0x03000000, 6))
+        return 1;
+    if (test__clzsi2(0x04000000, 5))
+        return 1;
+    if (test__clzsi2(0x05000000, 5))
+        return 1;
+    if (test__clzsi2(0x06000000, 5))
+        return 1;
+    if (test__clzsi2(0x07000000, 5))
+        return 1;
+    if (test__clzsi2(0x08000000, 4))
+        return 1;
+    if (test__clzsi2(0x09000000, 4))
+        return 1;
+    if (test__clzsi2(0x0A000000, 4))
+        return 1;
+    if (test__clzsi2(0x0B000000, 4))
+        return 1;
+    if (test__clzsi2(0x0C000000, 4))
+        return 1;
+    if (test__clzsi2(0x0D000000, 4))
+        return 1;
+    if (test__clzsi2(0x0E000000, 4))
+        return 1;
+    if (test__clzsi2(0x0F000000, 4))
+        return 1;
+    if (test__clzsi2(0x10000000, 3))
+        return 1;
+    if (test__clzsi2(0x11000000, 3))
+        return 1;
+    if (test__clzsi2(0x12000000, 3))
+        return 1;
+    if (test__clzsi2(0x13000000, 3))
+        return 1;
+    if (test__clzsi2(0x14000000, 3))
+        return 1;
+    if (test__clzsi2(0x15000000, 3))
+        return 1;
+    if (test__clzsi2(0x16000000, 3))
+        return 1;
+    if (test__clzsi2(0x17000000, 3))
+        return 1;
+    if (test__clzsi2(0x18000000, 3))
+        return 1;
+    if (test__clzsi2(0x19000000, 3))
+        return 1;
+    if (test__clzsi2(0x1A000000, 3))
+        return 1;
+    if (test__clzsi2(0x1B000000, 3))
+        return 1;
+    if (test__clzsi2(0x1C000000, 3))
+        return 1;
+    if (test__clzsi2(0x1D000000, 3))
+        return 1;
+    if (test__clzsi2(0x1E000000, 3))
+        return 1;
+    if (test__clzsi2(0x1F000000, 3))
+        return 1;
+    if (test__clzsi2(0x20000000, 2))
+        return 1;
+    if (test__clzsi2(0x21000000, 2))
+        return 1;
+    if (test__clzsi2(0x22000000, 2))
+        return 1;
+    if (test__clzsi2(0x23000000, 2))
+        return 1;
+    if (test__clzsi2(0x24000000, 2))
+        return 1;
+    if (test__clzsi2(0x25000000, 2))
+        return 1;
+    if (test__clzsi2(0x26000000, 2))
+        return 1;
+    if (test__clzsi2(0x27000000, 2))
+        return 1;
+    if (test__clzsi2(0x28000000, 2))
+        return 1;
+    if (test__clzsi2(0x29000000, 2))
+        return 1;
+    if (test__clzsi2(0x2A000000, 2))
+        return 1;
+    if (test__clzsi2(0x2B000000, 2))
+        return 1;
+    if (test__clzsi2(0x2C000000, 2))
+        return 1;
+    if (test__clzsi2(0x2D000000, 2))
+        return 1;
+    if (test__clzsi2(0x2E000000, 2))
+        return 1;
+    if (test__clzsi2(0x2F000000, 2))
+        return 1;
+    if (test__clzsi2(0x30000000, 2))
+        return 1;
+    if (test__clzsi2(0x31000000, 2))
+        return 1;
+    if (test__clzsi2(0x32000000, 2))
+        return 1;
+    if (test__clzsi2(0x33000000, 2))
+        return 1;
+    if (test__clzsi2(0x34000000, 2))
+        return 1;
+    if (test__clzsi2(0x35000000, 2))
+        return 1;
+    if (test__clzsi2(0x36000000, 2))
+        return 1;
+    if (test__clzsi2(0x37000000, 2))
+        return 1;
+    if (test__clzsi2(0x38000000, 2))
+        return 1;
+    if (test__clzsi2(0x39000000, 2))
+        return 1;
+    if (test__clzsi2(0x3A000000, 2))
+        return 1;
+    if (test__clzsi2(0x3B000000, 2))
+        return 1;
+    if (test__clzsi2(0x3C000000, 2))
+        return 1;
+    if (test__clzsi2(0x3D000000, 2))
+        return 1;
+    if (test__clzsi2(0x3E000000, 2))
+        return 1;
+    if (test__clzsi2(0x3F000000, 2))
+        return 1;
+    if (test__clzsi2(0x40000000, 1))
+        return 1;
+    if (test__clzsi2(0x41000000, 1))
+        return 1;
+    if (test__clzsi2(0x42000000, 1))
+        return 1;
+    if (test__clzsi2(0x43000000, 1))
+        return 1;
+    if (test__clzsi2(0x44000000, 1))
+        return 1;
+    if (test__clzsi2(0x45000000, 1))
+        return 1;
+    if (test__clzsi2(0x46000000, 1))
+        return 1;
+    if (test__clzsi2(0x47000000, 1))
+        return 1;
+    if (test__clzsi2(0x48000000, 1))
+        return 1;
+    if (test__clzsi2(0x49000000, 1))
+        return 1;
+    if (test__clzsi2(0x4A000000, 1))
+        return 1;
+    if (test__clzsi2(0x4B000000, 1))
+        return 1;
+    if (test__clzsi2(0x4C000000, 1))
+        return 1;
+    if (test__clzsi2(0x4D000000, 1))
+        return 1;
+    if (test__clzsi2(0x4E000000, 1))
+        return 1;
+    if (test__clzsi2(0x4F000000, 1))
+        return 1;
+    if (test__clzsi2(0x50000000, 1))
+        return 1;
+    if (test__clzsi2(0x51000000, 1))
+        return 1;
+    if (test__clzsi2(0x52000000, 1))
+        return 1;
+    if (test__clzsi2(0x53000000, 1))
+        return 1;
+    if (test__clzsi2(0x54000000, 1))
+        return 1;
+    if (test__clzsi2(0x55000000, 1))
+        return 1;
+    if (test__clzsi2(0x56000000, 1))
+        return 1;
+    if (test__clzsi2(0x57000000, 1))
+        return 1;
+    if (test__clzsi2(0x58000000, 1))
+        return 1;
+    if (test__clzsi2(0x59000000, 1))
+        return 1;
+    if (test__clzsi2(0x5A000000, 1))
+        return 1;
+    if (test__clzsi2(0x5B000000, 1))
+        return 1;
+    if (test__clzsi2(0x5C000000, 1))
+        return 1;
+    if (test__clzsi2(0x5D000000, 1))
+        return 1;
+    if (test__clzsi2(0x5E000000, 1))
+        return 1;
+    if (test__clzsi2(0x5F000000, 1))
+        return 1;
+    if (test__clzsi2(0x60000000, 1))
+        return 1;
+    if (test__clzsi2(0x61000000, 1))
+        return 1;
+    if (test__clzsi2(0x62000000, 1))
+        return 1;
+    if (test__clzsi2(0x63000000, 1))
+        return 1;
+    if (test__clzsi2(0x64000000, 1))
+        return 1;
+    if (test__clzsi2(0x65000000, 1))
+        return 1;
+    if (test__clzsi2(0x66000000, 1))
+        return 1;
+    if (test__clzsi2(0x67000000, 1))
+        return 1;
+    if (test__clzsi2(0x68000000, 1))
+        return 1;
+    if (test__clzsi2(0x69000000, 1))
+        return 1;
+    if (test__clzsi2(0x6A000000, 1))
+        return 1;
+    if (test__clzsi2(0x6B000000, 1))
+        return 1;
+    if (test__clzsi2(0x6C000000, 1))
+        return 1;
+    if (test__clzsi2(0x6D000000, 1))
+        return 1;
+    if (test__clzsi2(0x6E000000, 1))
+        return 1;
+    if (test__clzsi2(0x6F000000, 1))
+        return 1;
+    if (test__clzsi2(0x70000000, 1))
+        return 1;
+    if (test__clzsi2(0x71000000, 1))
+        return 1;
+    if (test__clzsi2(0x72000000, 1))
+        return 1;
+    if (test__clzsi2(0x73000000, 1))
+        return 1;
+    if (test__clzsi2(0x74000000, 1))
+        return 1;
+    if (test__clzsi2(0x75000000, 1))
+        return 1;
+    if (test__clzsi2(0x76000000, 1))
+        return 1;
+    if (test__clzsi2(0x77000000, 1))
+        return 1;
+    if (test__clzsi2(0x78000000, 1))
+        return 1;
+    if (test__clzsi2(0x79000000, 1))
+        return 1;
+    if (test__clzsi2(0x7A000000, 1))
+        return 1;
+    if (test__clzsi2(0x7B000000, 1))
+        return 1;
+    if (test__clzsi2(0x7C000000, 1))
+        return 1;
+    if (test__clzsi2(0x7D000000, 1))
+        return 1;
+    if (test__clzsi2(0x7E000000, 1))
+        return 1;
+    if (test__clzsi2(0x7F000000, 1))
+        return 1;
+    if (test__clzsi2(0x80000000, 0))
+        return 1;
+    if (test__clzsi2(0x81000000, 0))
+        return 1;
+    if (test__clzsi2(0x82000000, 0))
+        return 1;
+    if (test__clzsi2(0x83000000, 0))
+        return 1;
+    if (test__clzsi2(0x84000000, 0))
+        return 1;
+    if (test__clzsi2(0x85000000, 0))
+        return 1;
+    if (test__clzsi2(0x86000000, 0))
+        return 1;
+    if (test__clzsi2(0x87000000, 0))
+        return 1;
+    if (test__clzsi2(0x88000000, 0))
+        return 1;
+    if (test__clzsi2(0x89000000, 0))
+        return 1;
+    if (test__clzsi2(0x8A000000, 0))
+        return 1;
+    if (test__clzsi2(0x8B000000, 0))
+        return 1;
+    if (test__clzsi2(0x8C000000, 0))
+        return 1;
+    if (test__clzsi2(0x8D000000, 0))
+        return 1;
+    if (test__clzsi2(0x8E000000, 0))
+        return 1;
+    if (test__clzsi2(0x8F000000, 0))
+        return 1;
+    if (test__clzsi2(0x90000000, 0))
+        return 1;
+    if (test__clzsi2(0x91000000, 0))
+        return 1;
+    if (test__clzsi2(0x92000000, 0))
+        return 1;
+    if (test__clzsi2(0x93000000, 0))
+        return 1;
+    if (test__clzsi2(0x94000000, 0))
+        return 1;
+    if (test__clzsi2(0x95000000, 0))
+        return 1;
+    if (test__clzsi2(0x96000000, 0))
+        return 1;
+    if (test__clzsi2(0x97000000, 0))
+        return 1;
+    if (test__clzsi2(0x98000000, 0))
+        return 1;
+    if (test__clzsi2(0x99000000, 0))
+        return 1;
+    if (test__clzsi2(0x9A000000, 0))
+        return 1;
+    if (test__clzsi2(0x9B000000, 0))
+        return 1;
+    if (test__clzsi2(0x9C000000, 0))
+        return 1;
+    if (test__clzsi2(0x9D000000, 0))
+        return 1;
+    if (test__clzsi2(0x9E000000, 0))
+        return 1;
+    if (test__clzsi2(0x9F000000, 0))
+        return 1;
+    if (test__clzsi2(0xA0000000, 0))
+        return 1;
+    if (test__clzsi2(0xA1000000, 0))
+        return 1;
+    if (test__clzsi2(0xA2000000, 0))
+        return 1;
+    if (test__clzsi2(0xA3000000, 0))
+        return 1;
+    if (test__clzsi2(0xA4000000, 0))
+        return 1;
+    if (test__clzsi2(0xA5000000, 0))
+        return 1;
+    if (test__clzsi2(0xA6000000, 0))
+        return 1;
+    if (test__clzsi2(0xA7000000, 0))
+        return 1;
+    if (test__clzsi2(0xA8000000, 0))
+        return 1;
+    if (test__clzsi2(0xA9000000, 0))
+        return 1;
+    if (test__clzsi2(0xAA000000, 0))
+        return 1;
+    if (test__clzsi2(0xAB000000, 0))
+        return 1;
+    if (test__clzsi2(0xAC000000, 0))
+        return 1;
+    if (test__clzsi2(0xAD000000, 0))
+        return 1;
+    if (test__clzsi2(0xAE000000, 0))
+        return 1;
+    if (test__clzsi2(0xAF000000, 0))
+        return 1;
+    if (test__clzsi2(0xB0000000, 0))
+        return 1;
+    if (test__clzsi2(0xB1000000, 0))
+        return 1;
+    if (test__clzsi2(0xB2000000, 0))
+        return 1;
+    if (test__clzsi2(0xB3000000, 0))
+        return 1;
+    if (test__clzsi2(0xB4000000, 0))
+        return 1;
+    if (test__clzsi2(0xB5000000, 0))
+        return 1;
+    if (test__clzsi2(0xB6000000, 0))
+        return 1;
+    if (test__clzsi2(0xB7000000, 0))
+        return 1;
+    if (test__clzsi2(0xB8000000, 0))
+        return 1;
+    if (test__clzsi2(0xB9000000, 0))
+        return 1;
+    if (test__clzsi2(0xBA000000, 0))
+        return 1;
+    if (test__clzsi2(0xBB000000, 0))
+        return 1;
+    if (test__clzsi2(0xBC000000, 0))
+        return 1;
+    if (test__clzsi2(0xBD000000, 0))
+        return 1;
+    if (test__clzsi2(0xBE000000, 0))
+        return 1;
+    if (test__clzsi2(0xBF000000, 0))
+        return 1;
+    if (test__clzsi2(0xC0000000, 0))
+        return 1;
+    if (test__clzsi2(0xC1000000, 0))
+        return 1;
+    if (test__clzsi2(0xC2000000, 0))
+        return 1;
+    if (test__clzsi2(0xC3000000, 0))
+        return 1;
+    if (test__clzsi2(0xC4000000, 0))
+        return 1;
+    if (test__clzsi2(0xC5000000, 0))
+        return 1;
+    if (test__clzsi2(0xC6000000, 0))
+        return 1;
+    if (test__clzsi2(0xC7000000, 0))
+        return 1;
+    if (test__clzsi2(0xC8000000, 0))
+        return 1;
+    if (test__clzsi2(0xC9000000, 0))
+        return 1;
+    if (test__clzsi2(0xCA000000, 0))
+        return 1;
+    if (test__clzsi2(0xCB000000, 0))
+        return 1;
+    if (test__clzsi2(0xCC000000, 0))
+        return 1;
+    if (test__clzsi2(0xCD000000, 0))
+        return 1;
+    if (test__clzsi2(0xCE000000, 0))
+        return 1;
+    if (test__clzsi2(0xCF000000, 0))
+        return 1;
+    if (test__clzsi2(0xD0000000, 0))
+        return 1;
+    if (test__clzsi2(0xD1000000, 0))
+        return 1;
+    if (test__clzsi2(0xD2000000, 0))
+        return 1;
+    if (test__clzsi2(0xD3000000, 0))
+        return 1;
+    if (test__clzsi2(0xD4000000, 0))
+        return 1;
+    if (test__clzsi2(0xD5000000, 0))
+        return 1;
+    if (test__clzsi2(0xD6000000, 0))
+        return 1;
+    if (test__clzsi2(0xD7000000, 0))
+        return 1;
+    if (test__clzsi2(0xD8000000, 0))
+        return 1;
+    if (test__clzsi2(0xD9000000, 0))
+        return 1;
+    if (test__clzsi2(0xDA000000, 0))
+        return 1;
+    if (test__clzsi2(0xDB000000, 0))
+        return 1;
+    if (test__clzsi2(0xDC000000, 0))
+        return 1;
+    if (test__clzsi2(0xDD000000, 0))
+        return 1;
+    if (test__clzsi2(0xDE000000, 0))
+        return 1;
+    if (test__clzsi2(0xDF000000, 0))
+        return 1;
+    if (test__clzsi2(0xE0000000, 0))
+        return 1;
+    if (test__clzsi2(0xE1000000, 0))
+        return 1;
+    if (test__clzsi2(0xE2000000, 0))
+        return 1;
+    if (test__clzsi2(0xE3000000, 0))
+        return 1;
+    if (test__clzsi2(0xE4000000, 0))
+        return 1;
+    if (test__clzsi2(0xE5000000, 0))
+        return 1;
+    if (test__clzsi2(0xE6000000, 0))
+        return 1;
+    if (test__clzsi2(0xE7000000, 0))
+        return 1;
+    if (test__clzsi2(0xE8000000, 0))
+        return 1;
+    if (test__clzsi2(0xE9000000, 0))
+        return 1;
+    if (test__clzsi2(0xEA000000, 0))
+        return 1;
+    if (test__clzsi2(0xEB000000, 0))
+        return 1;
+    if (test__clzsi2(0xEC000000, 0))
+        return 1;
+    if (test__clzsi2(0xED000000, 0))
+        return 1;
+    if (test__clzsi2(0xEE000000, 0))
+        return 1;
+    if (test__clzsi2(0xEF000000, 0))
+        return 1;
+    if (test__clzsi2(0xF0000000, 0))
+        return 1;
+    if (test__clzsi2(0xF1000000, 0))
+        return 1;
+    if (test__clzsi2(0xF2000000, 0))
+        return 1;
+    if (test__clzsi2(0xF3000000, 0))
+        return 1;
+    if (test__clzsi2(0xF4000000, 0))
+        return 1;
+    if (test__clzsi2(0xF5000000, 0))
+        return 1;
+    if (test__clzsi2(0xF6000000, 0))
+        return 1;
+    if (test__clzsi2(0xF7000000, 0))
+        return 1;
+    if (test__clzsi2(0xF8000000, 0))
+        return 1;
+    if (test__clzsi2(0xF9000000, 0))
+        return 1;
+    if (test__clzsi2(0xFA000000, 0))
+        return 1;
+    if (test__clzsi2(0xFB000000, 0))
+        return 1;
+    if (test__clzsi2(0xFC000000, 0))
+        return 1;
+    if (test__clzsi2(0xFD000000, 0))
+        return 1;
+    if (test__clzsi2(0xFE000000, 0))
+        return 1;
+    if (test__clzsi2(0xFF000000, 0))
+        return 1;
+
+    if (test__clzsi2(0x00000001, 31))
+        return 1;
+    if (test__clzsi2(0x00000002, 30))
+        return 1;
+    if (test__clzsi2(0x00000004, 29))
+        return 1;
+    if (test__clzsi2(0x00000008, 28))
+        return 1;
+    if (test__clzsi2(0x00000010, 27))
+        return 1;
+    if (test__clzsi2(0x00000020, 26))
+        return 1;
+    if (test__clzsi2(0x00000040, 25))
+        return 1;
+    if (test__clzsi2(0x00000080, 24))
+        return 1;
+    if (test__clzsi2(0x00000100, 23))
+        return 1;
+    if (test__clzsi2(0x00000200, 22))
+        return 1;
+    if (test__clzsi2(0x00000400, 21))
+        return 1;
+    if (test__clzsi2(0x00000800, 20))
+        return 1;
+    if (test__clzsi2(0x00001000, 19))
+        return 1;
+    if (test__clzsi2(0x00002000, 18))
+        return 1;
+    if (test__clzsi2(0x00004000, 17))
+        return 1;
+    if (test__clzsi2(0x00008000, 16))
+        return 1;
+    if (test__clzsi2(0x00010000, 15))
+        return 1;
+    if (test__clzsi2(0x00020000, 14))
+        return 1;
+    if (test__clzsi2(0x00040000, 13))
+        return 1;
+    if (test__clzsi2(0x00080000, 12))
+        return 1;
+    if (test__clzsi2(0x00100000, 11))
+        return 1;
+    if (test__clzsi2(0x00200000, 10))
+        return 1;
+    if (test__clzsi2(0x00400000, 9))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/clzti2_test.c b/compiler-rt/test/builtins/Unit/clzti2_test.c
new file mode 100644
index 0000000..3a2c6fa
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/clzti2_test.c
@@ -0,0 +1,90 @@
+//===-- clzti2_test.c - Test __clzti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __clzti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: the number of leading 0-bits
+
+// Precondition: a != 0
+
+COMPILER_RT_ABI si_int __clzti2(ti_int a);
+
+int test__clzti2(ti_int a, si_int expected)
+{
+    si_int x = __clzti2(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __clzti2(0x%llX%.16llX) = %d, expected %d\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    const int N = (int)(sizeof(ti_int) * CHAR_BIT);
+
+    if (test__clzti2(0x00000001, N-1))
+        return 1;
+    if (test__clzti2(0x00000002, N-2))
+        return 1;
+    if (test__clzti2(0x00000003, N-2))
+        return 1;
+    if (test__clzti2(0x00000004, N-3))
+        return 1;
+    if (test__clzti2(0x00000005, N-3))
+        return 1;
+    if (test__clzti2(0x0000000A, N-4))
+        return 1;
+    if (test__clzti2(0x1000000A, N*3/4+3))
+        return 1;
+    if (test__clzti2(0x2000000A, N*3/4+2))
+        return 1;
+    if (test__clzti2(0x6000000A, N*3/4+1))
+        return 1;
+    if (test__clzti2(0x8000000AuLL, N*3/4))
+        return 1;
+    if (test__clzti2(0x000005008000000AuLL, 85))
+        return 1;
+    if (test__clzti2(0x020005008000000AuLL, 70))
+        return 1;
+    if (test__clzti2(0x720005008000000AuLL, 65))
+        return 1;
+    if (test__clzti2(0x820005008000000AuLL, 64))
+        return 1;
+
+    if (test__clzti2(make_ti(0x0000000080000000LL, 0x8000000800000000LL), 32))
+        return 1;
+    if (test__clzti2(make_ti(0x0000000100000000LL, 0x8000000800000000LL), 31))
+        return 1;
+    if (test__clzti2(make_ti(0x1000000100000000LL, 0x8000000800000000LL), 3))
+        return 1;
+    if (test__clzti2(make_ti(0x7000000100000000LL, 0x8000000800000000LL), 1))
+        return 1;
+    if (test__clzti2(make_ti(0x8000000100000000LL, 0x8000000800000000LL), 0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/cmpdi2_test.c b/compiler-rt/test/builtins/Unit/cmpdi2_test.c
new file mode 100644
index 0000000..33a12a0
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/cmpdi2_test.c
@@ -0,0 +1,77 @@
+//===-- cmpdi2_test.c - Test __cmpdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __cmpdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns:  if (a <  b) returns 0
+//           if (a == b) returns 1
+//           if (a >  b) returns 2
+
+COMPILER_RT_ABI si_int __cmpdi2(di_int a, di_int b);
+
+int test__cmpdi2(di_int a, di_int b, si_int expected)
+{
+    si_int x = __cmpdi2(a, b);
+    if (x != expected)
+        printf("error in __cmpdi2(0x%llX, 0x%llX) = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__cmpdi2(0, 0, 1))
+        return 1;
+    if (test__cmpdi2(1, 1, 1))
+        return 1;
+    if (test__cmpdi2(2, 2, 1))
+        return 1;
+    if (test__cmpdi2(0x7FFFFFFF, 0x7FFFFFFF, 1))
+        return 1;
+    if (test__cmpdi2(0x80000000, 0x80000000, 1))
+        return 1;
+    if (test__cmpdi2(0x80000001, 0x80000001, 1))
+        return 1;
+    if (test__cmpdi2(0xFFFFFFFF, 0xFFFFFFFF, 1))
+        return 1;
+    if (test__cmpdi2(0x000000010000000LL, 0x000000010000000LL, 1))
+        return 1;
+    if (test__cmpdi2(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL, 1))
+        return 1;
+
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000300000001LL, 0))
+        return 1;
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000300000002LL, 0))
+        return 1;
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000300000003LL, 0))
+        return 1;
+
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000100000001LL, 2))
+        return 1;
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000100000002LL, 2))
+        return 1;
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000100000003LL, 2))
+        return 1;
+
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000200000001LL, 2))
+        return 1;
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000200000002LL, 1))
+        return 1;
+    if (test__cmpdi2(0x0000000200000002LL, 0x0000000200000003LL, 0))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/cmpti2_test.c b/compiler-rt/test/builtins/Unit/cmpti2_test.c
new file mode 100644
index 0000000..d951923
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/cmpti2_test.c
@@ -0,0 +1,112 @@
+//===-- cmpti2_test.c - Test __cmpti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __cmpti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns:  if (a <  b) returns 0
+//           if (a == b) returns 1
+//           if (a >  b) returns 2
+
+COMPILER_RT_ABI si_int __cmpti2(ti_int a, ti_int b);
+
+int test__cmpti2(ti_int a, ti_int b, si_int expected)
+{
+    si_int x = __cmpti2(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        printf("error in __cmpti2(0x%llX%.16llX, 0x%llX%.16llX) = %d, expected %d\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__cmpti2(0, 0, 1))
+        return 1;
+    if (test__cmpti2(1, 1, 1))
+        return 1;
+    if (test__cmpti2(2, 2, 1))
+        return 1;
+    if (test__cmpti2(0x7FFFFFFF, 0x7FFFFFFF, 1))
+        return 1;
+    if (test__cmpti2(0x80000000, 0x80000000, 1))
+        return 1;
+    if (test__cmpti2(0x80000001, 0x80000001, 1))
+        return 1;
+    if (test__cmpti2(0xFFFFFFFF, 0xFFFFFFFF, 1))
+        return 1;
+    if (test__cmpti2(0x000000010000000LL, 0x000000010000000LL, 1))
+        return 1;
+    if (test__cmpti2(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL, 1))
+        return 1;
+
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000300000001LL, 0))
+        return 1;
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000300000002LL, 0))
+        return 1;
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000300000003LL, 0))
+        return 1;
+
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000100000001LL, 2))
+        return 1;
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000100000002LL, 2))
+        return 1;
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000100000003LL, 2))
+        return 1;
+
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000200000001LL, 2))
+        return 1;
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000200000002LL, 1))
+        return 1;
+    if (test__cmpti2(0x0000000200000002LL, 0x0000000200000003LL, 0))
+        return 1;
+
+    if (test__cmpti2(make_ti(2, 2), make_ti(3, 1), 0))
+        return 1;
+    if (test__cmpti2(make_ti(2, 2), make_ti(3, 2), 0))
+        return 1;
+    if (test__cmpti2(make_ti(2, 2), make_ti(3, 3), 0))
+        return 1;
+
+    if (test__cmpti2(make_ti(2, 2), make_ti(1, 1), 2))
+        return 1;
+    if (test__cmpti2(make_ti(2, 2), make_ti(1, 2), 2))
+        return 1;
+    if (test__cmpti2(make_ti(2, 2), make_ti(1, 3), 2))
+        return 1;
+
+    if (test__cmpti2(make_ti(2, 2), make_ti(2, 1), 2))
+        return 1;
+    if (test__cmpti2(make_ti(2, 2), make_ti(2, 2), 1))
+        return 1;
+    if (test__cmpti2(make_ti(2, 2), make_ti(2, 3), 0))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/comparedf2_test.c b/compiler-rt/test/builtins/Unit/comparedf2_test.c
new file mode 100644
index 0000000..6623722
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/comparedf2_test.c
@@ -0,0 +1,479 @@
+//===-- cmpdf2_test.c - Test __cmpdf2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests single-precision soft-double comparisons for the compiler-rt
+// library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+int __eqdf2(double, double);
+int __gedf2(double, double);
+int __gtdf2(double, double);
+int __ledf2(double, double);
+int __ltdf2(double, double);
+int __nedf2(double, double);
+int __unorddf2(double, double);
+
+struct TestVector {
+    double a;
+    double b;
+    int eqReference;
+    int geReference;
+    int gtReference;
+    int leReference;
+    int ltReference;
+    int neReference;
+    int unReference;
+};
+
+int test__cmpdf2(const struct TestVector *vector) {
+    
+    if (__eqdf2(vector->a, vector->b) != vector->eqReference) {
+        printf("error in __eqdf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __eqdf2(vector->a, vector->b),
+               vector->eqReference);
+        return 1;
+    }
+    
+    if (__gedf2(vector->a, vector->b) != vector->geReference) {
+        printf("error in __gedf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __gedf2(vector->a, vector->b),
+               vector->geReference);
+        return 1;
+    }
+    
+    if (__gtdf2(vector->a, vector->b) != vector->gtReference) {
+        printf("error in __gtdf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __gtdf2(vector->a, vector->b),
+               vector->gtReference);
+        return 1;
+    }
+    
+    if (__ledf2(vector->a, vector->b) != vector->leReference) {
+        printf("error in __ledf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __ledf2(vector->a, vector->b),
+               vector->leReference);
+        return 1;
+    }
+    
+    if (__ltdf2(vector->a, vector->b) != vector->ltReference) {
+        printf("error in __ltdf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __ltdf2(vector->a, vector->b),
+               vector->ltReference);
+        return 1;
+    }
+    
+    if (__nedf2(vector->a, vector->b) != vector->neReference) {
+        printf("error in __nedf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __nedf2(vector->a, vector->b),
+               vector->neReference);
+        return 1;
+    }
+    
+    if (__unorddf2(vector->a, vector->b) != vector->unReference) {
+        printf("error in __unorddf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __unorddf2(vector->a, vector->b),
+               vector->unReference);
+        return 1;
+    }
+    
+    return 0;
+}
+
+/*
+void generateVectors() {
+    
+    const double arguments[] = {
+        __builtin_nan(""),
+        -__builtin_inf(),
+        -0x1.fffffffffffffp1023,
+        -0x1.0000000000001p0
+        -0x1.0000000000000p0,
+        -0x1.fffffffffffffp-1,
+        -0x1.0000000000000p-1022,
+        -0x0.fffffffffffffp-1022,
+        -0x0.0000000000001p-1022,
+        -0.0,
+         0.0,
+         0x0.0000000000001p-1022,
+         0x0.fffffffffffffp-1022,
+         0x1.0000000000000p-1022,
+         0x1.fffffffffffffp-1,
+         0x1.0000000000000p0,
+         0x1.0000000000001p0,
+         0x1.fffffffffffffp1023,
+         __builtin_inf()
+    };
+    
+    int numArguments = sizeof arguments / sizeof arguments[0];
+    
+    for (int i=0; i<numArguments; ++i) {
+        for (int j=0; j<numArguments; ++j) {
+            const double a = arguments[i];
+            const double b = arguments[j];
+            const int leResult = a < b ? -1 : a == b ? 0 :  1;
+            const int geResult = a > b ?  1 : a == b ? 0 : -1;
+            const int unResult = a != a || b != b ? 1 : 0;
+            printf("{%a,%a,%d,%d,%d,%d,%d,%d,%d},\n",
+                   a, b, 
+                   leResult,
+                   geResult,
+                   geResult,
+                   leResult,
+                   leResult,
+                   leResult,
+                   unResult);
+        }
+    }
+} */
+
+static const struct TestVector vectors[] = {
+    {__builtin_nan(""),__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-__builtin_inf(),1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x1.fffffffffffffp+1023,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x1p+1,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x1.fffffffffffffp-1,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x1p-1022,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x1.fffffcp-1023,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x1p-1074,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),-0x0p+0,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x0p+0,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1p-1074,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1.fffffcp-1023,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1p-1022,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1.fffffffffffffp-1,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1p+0,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1.0000000000001p+0,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),0x1.fffffffffffffp+1023,1,-1,-1,1,1,1,1},
+    {__builtin_nan(""),__builtin_inf(),1,-1,-1,1,1,1,1},
+    {-__builtin_inf(),__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-__builtin_inf(),-__builtin_inf(),0,0,0,0,0,0,0},
+    {-__builtin_inf(),-0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),-0x1p+1,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),-0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),-0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),-0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),-0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inf(),__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x1.fffffffffffffp+1023,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023,0,0,0,0,0,0,0},
+    {-0x1.fffffffffffffp+1023,-0x1p+1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,-0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,-0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,-0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp+1023,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x1p+1,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x1p+1,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {-0x1p+1,-0x1p+1,0,0,0,0,0,0,0},
+    {-0x1p+1,-0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,-0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,-0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,-0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p+1,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x1.fffffffffffffp-1,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x1.fffffffffffffp-1,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {-0x1.fffffffffffffp-1,-0x1p+1,1,1,1,1,1,1,0},
+    {-0x1.fffffffffffffp-1,-0x1.fffffffffffffp-1,0,0,0,0,0,0,0},
+    {-0x1.fffffffffffffp-1,-0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,-0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,-0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffffffffffp-1,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x1p-1022,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x1p-1022,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {-0x1p-1022,-0x1p+1,1,1,1,1,1,1,0},
+    {-0x1p-1022,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {-0x1p-1022,-0x1p-1022,0,0,0,0,0,0,0},
+    {-0x1p-1022,-0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,-0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1022,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x1.fffffcp-1023,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x1.fffffcp-1023,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-1023,-0x1p+1,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-1023,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-1023,-0x1p-1022,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-1023,-0x1.fffffcp-1023,0,0,0,0,0,0,0},
+    {-0x1.fffffcp-1023,-0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-1023,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x1p-1074,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x1p-1074,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {-0x1p-1074,-0x1p+1,1,1,1,1,1,1,0},
+    {-0x1p-1074,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {-0x1p-1074,-0x1p-1022,1,1,1,1,1,1,0},
+    {-0x1p-1074,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {-0x1p-1074,-0x1p-1074,0,0,0,0,0,0,0},
+    {-0x1p-1074,-0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x0p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-1074,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {-0x0p+0,-__builtin_inf(),1,1,1,1,1,1,0},
+    {-0x0p+0,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {-0x0p+0,-0x1p+1,1,1,1,1,1,1,0},
+    {-0x0p+0,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {-0x0p+0,-0x1p-1022,1,1,1,1,1,1,0},
+    {-0x0p+0,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {-0x0p+0,-0x1p-1074,1,1,1,1,1,1,0},
+    {-0x0p+0,-0x0p+0,0,0,0,0,0,0,0},
+    {-0x0p+0,0x0p+0,0,0,0,0,0,0,0},
+    {-0x0p+0,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p+0,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x0p+0,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x0p+0,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x0p+0,-0x1p+1,1,1,1,1,1,1,0},
+    {0x0p+0,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x0p+0,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x0p+0,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x0p+0,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x0p+0,-0x0p+0,0,0,0,0,0,0,0},
+    {0x0p+0,0x0p+0,0,0,0,0,0,0,0},
+    {0x0p+0,0x1p-1074,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x0p+0,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1p-1074,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1p-1074,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1p-1074,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1p-1074,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1p-1074,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1p-1074,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1p-1074,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1p-1074,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1p-1074,0x0p+0,1,1,1,1,1,1,0},
+    {0x1p-1074,0x1p-1074,0,0,0,0,0,0,0},
+    {0x1p-1074,0x1.fffffcp-1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1074,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-1023,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1.fffffcp-1023,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,0x0p+0,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.fffffcp-1023,0x1.fffffcp-1023,0,0,0,0,0,0,0},
+    {0x1.fffffcp-1023,0x1p-1022,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-1023,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-1023,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-1023,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-1023,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-1023,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1022,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1p-1022,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1p-1022,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1p-1022,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1p-1022,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1p-1022,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1p-1022,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1p-1022,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1p-1022,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1p-1022,0x0p+0,1,1,1,1,1,1,0},
+    {0x1p-1022,0x1p-1074,1,1,1,1,1,1,0},
+    {0x1p-1022,0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1p-1022,0x1p-1022,0,0,0,0,0,0,0},
+    {0x1p-1022,0x1.fffffffffffffp-1,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1022,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1022,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1022,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-1022,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffffffffffp-1,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1.fffffffffffffp-1,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,0x0p+0,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp-1,0x1.fffffffffffffp-1,0,0,0,0,0,0,0},
+    {0x1.fffffffffffffp-1,0x1p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffffffffffp-1,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffffffffffp-1,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffffffffffp-1,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1p+0,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1p+0,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1p+0,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1p+0,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1p+0,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1p+0,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1p+0,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1p+0,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1p+0,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1p+0,0x0p+0,1,1,1,1,1,1,0},
+    {0x1p+0,0x1p-1074,1,1,1,1,1,1,0},
+    {0x1p+0,0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1p+0,0x1p-1022,1,1,1,1,1,1,0},
+    {0x1p+0,0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1p+0,0x1p+0,0,0,0,0,0,0,0},
+    {0x1p+0,0x1.0000000000001p+0,-1,-1,-1,-1,-1,-1,0},
+    {0x1p+0,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1p+0,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.0000000000001p+0,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1.0000000000001p+0,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x0p+0,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x1p+0,1,1,1,1,1,1,0},
+    {0x1.0000000000001p+0,0x1.0000000000001p+0,0,0,0,0,0,0,0},
+    {0x1.0000000000001p+0,0x1.fffffffffffffp+1023,-1,-1,-1,-1,-1,-1,0},
+    {0x1.0000000000001p+0,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffffffffffp+1023,__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {0x1.fffffffffffffp+1023,-__builtin_inf(),1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x1p+1,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,-0x0p+0,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x0p+0,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1p-1074,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1p-1022,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1p+0,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1.0000000000001p+0,1,1,1,1,1,1,0},
+    {0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023,0,0,0,0,0,0,0},
+    {0x1.fffffffffffffp+1023,__builtin_inf(),-1,-1,-1,-1,-1,-1,0},
+    {__builtin_inf(),__builtin_nan(""),1,-1,-1,1,1,1,1},
+    {__builtin_inf(),-__builtin_inf(),1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x1p+1,1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x1p-1022,1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x1p-1074,1,1,1,1,1,1,0},
+    {__builtin_inf(),-0x0p+0,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x0p+0,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1p-1074,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1.fffffcp-1023,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1p-1022,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1.fffffffffffffp-1,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1p+0,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1.0000000000001p+0,1,1,1,1,1,1,0},
+    {__builtin_inf(),0x1.fffffffffffffp+1023,1,1,1,1,1,1,0},
+    {__builtin_inf(),__builtin_inf(),0,0,0,0,0,0,0},
+};    
+
+int main(int argc, char *argv[]) {
+    const int numVectors = sizeof vectors / sizeof vectors[0];
+    int i;
+    for (i = 0; i<numVectors; ++i) {
+        if (test__cmpdf2(&vectors[i])) return 1;
+    }
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/comparesf2_test.c b/compiler-rt/test/builtins/Unit/comparesf2_test.c
new file mode 100644
index 0000000..026e900
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/comparesf2_test.c
@@ -0,0 +1,479 @@
+//===-- cmpsf2_test.c - Test __cmpsf2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests single-precision soft-float comparisons for the compiler-rt
+// library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+int __eqsf2(float, float);
+int __gesf2(float, float);
+int __gtsf2(float, float);
+int __lesf2(float, float);
+int __ltsf2(float, float);
+int __nesf2(float, float);
+int __unordsf2(float, float);
+
+struct TestVector {
+    float a;
+    float b;
+    int eqReference;
+    int geReference;
+    int gtReference;
+    int leReference;
+    int ltReference;
+    int neReference;
+    int unReference;
+};
+
+int test__cmpsf2(const struct TestVector *vector) {
+    
+    if (__eqsf2(vector->a, vector->b) != vector->eqReference) {
+        printf("error in __eqsf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __eqsf2(vector->a, vector->b),
+               vector->eqReference);
+        return 1;
+    }
+    
+    if (__gesf2(vector->a, vector->b) != vector->geReference) {
+        printf("error in __gesf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __gesf2(vector->a, vector->b),
+               vector->geReference);
+        return 1;
+    }
+    
+    if (__gtsf2(vector->a, vector->b) != vector->gtReference) {
+        printf("error in __gtsf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __gtsf2(vector->a, vector->b),
+               vector->gtReference);
+        return 1;
+    }
+    
+    if (__lesf2(vector->a, vector->b) != vector->leReference) {
+        printf("error in __lesf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __lesf2(vector->a, vector->b),
+               vector->leReference);
+        return 1;
+    }
+    
+    if (__ltsf2(vector->a, vector->b) != vector->ltReference) {
+        printf("error in __ltsf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __ltsf2(vector->a, vector->b),
+               vector->ltReference);
+        return 1;
+    }
+    
+    if (__nesf2(vector->a, vector->b) != vector->neReference) {
+        printf("error in __nesf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __nesf2(vector->a, vector->b),
+               vector->neReference);
+        return 1;
+    }
+    
+    if (__unordsf2(vector->a, vector->b) != vector->unReference) {
+        printf("error in __unordsf2(%a, %a) = %d, expected %d\n",
+               vector->a, vector->b,
+               __unordsf2(vector->a, vector->b),
+               vector->unReference);
+        return 1;
+    }
+    
+    return 0;
+}
+
+/*
+void generateVectors() {
+    
+    const float arguments[] = {
+        __builtin_nanf(""),
+        -__builtin_inff(),
+        -0x1.fffffep127,
+        -0x1.000002p0
+        -0x1.000000p0,
+        -0x1.fffffep-1f,
+        -0x1.000000p-126f,
+        -0x0.fffffep-126f,
+        -0x0.000002p-126f,
+        -0.0,
+         0.0,
+         0x0.000002p-126f,
+         0x0.fffffep-126f,
+         0x1.000000p-126f,
+         0x1.fffffep-1f,
+         0x1.000000p0,
+         0x1.000002p0,
+         0x1.fffffep127,
+         __builtin_inff()
+    };
+    
+    int numArguments = sizeof arguments / sizeof arguments[0];
+    
+    for (int i=0; i<numArguments; ++i) {
+        for (int j=0; j<numArguments; ++j) {
+            const float a = arguments[i];
+            const float b = arguments[j];
+            const int leResult = a < b ? -1 : a == b ? 0 :  1;
+            const int geResult = a > b ?  1 : a == b ? 0 : -1;
+            const int unResult = a != a || b != b ? 1 : 0;
+            printf("{%a,%a,%d,%d,%d,%d,%d,%d,%d},\n",
+                   a, b, 
+                   leResult,
+                   geResult,
+                   geResult,
+                   leResult,
+                   leResult,
+                   leResult,
+                   unResult);
+        }
+    }
+} */
+
+static const struct TestVector vectors[] = {
+    {__builtin_nanf(""),__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-__builtin_inff(),1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x1.fffffep+127f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x1p0f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x1.fffffep-1f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x1p-126f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x1.fffffcp-127,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x1p-149f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),-0x0p0f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x0p0f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1p-149f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1.fffffcp-127,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1p-126f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1.fffffep-1f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1p0f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1.000002p0f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),0x1.fffffep+127f,1,-1,-1,1,1,1,1},
+    {__builtin_nanf(""),__builtin_inff(),1,-1,-1,1,1,1,1},
+    {-__builtin_inff(),__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-__builtin_inff(),-__builtin_inff(),0,0,0,0,0,0,0},
+    {-__builtin_inff(),-0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),-0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),-0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),-0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),-0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),-0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-__builtin_inff(),__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x1.fffffep+127f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x1.fffffep+127f,-0x1.fffffep+127f,0,0,0,0,0,0,0},
+    {-0x1.fffffep+127f,-0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,-0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,-0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,-0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,-0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep+127f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x1p0f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x1p0f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {-0x1p0f,-0x1p0f,0,0,0,0,0,0,0},
+    {-0x1p0f,-0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,-0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,-0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,-0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p0f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x1.fffffep-1f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x1.fffffep-1f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {-0x1.fffffep-1f,-0x1p0f,1,1,1,1,1,1,0},
+    {-0x1.fffffep-1f,-0x1.fffffep-1f,0,0,0,0,0,0,0},
+    {-0x1.fffffep-1f,-0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,-0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,-0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffep-1f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x1p-126f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x1p-126f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {-0x1p-126f,-0x1p0f,1,1,1,1,1,1,0},
+    {-0x1p-126f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {-0x1p-126f,-0x1p-126f,0,0,0,0,0,0,0},
+    {-0x1p-126f,-0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,-0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-126f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x1.fffffcp-127,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x1.fffffcp-127,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-127,-0x1p0f,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-127,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-127,-0x1p-126f,1,1,1,1,1,1,0},
+    {-0x1.fffffcp-127,-0x1.fffffcp-127,0,0,0,0,0,0,0},
+    {-0x1.fffffcp-127,-0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1.fffffcp-127,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x1p-149f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x1p-149f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {-0x1p-149f,-0x1p0f,1,1,1,1,1,1,0},
+    {-0x1p-149f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {-0x1p-149f,-0x1p-126f,1,1,1,1,1,1,0},
+    {-0x1p-149f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {-0x1p-149f,-0x1p-149f,0,0,0,0,0,0,0},
+    {-0x1p-149f,-0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x0p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x1p-149f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {-0x0p0f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {-0x0p0f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {-0x0p0f,-0x1p0f,1,1,1,1,1,1,0},
+    {-0x0p0f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {-0x0p0f,-0x1p-126f,1,1,1,1,1,1,0},
+    {-0x0p0f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {-0x0p0f,-0x1p-149f,1,1,1,1,1,1,0},
+    {-0x0p0f,-0x0p0f,0,0,0,0,0,0,0},
+    {-0x0p0f,0x0p0f,0,0,0,0,0,0,0},
+    {-0x0p0f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {-0x0p0f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x0p0f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x0p0f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x0p0f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x0p0f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x0p0f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x0p0f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x0p0f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x0p0f,-0x0p0f,0,0,0,0,0,0,0},
+    {0x0p0f,0x0p0f,0,0,0,0,0,0,0},
+    {0x0p0f,0x1p-149f,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x0p0f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1p-149f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1p-149f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1p-149f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1p-149f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1p-149f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1p-149f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1p-149f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1p-149f,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1p-149f,0x0p0f,1,1,1,1,1,1,0},
+    {0x1p-149f,0x1p-149f,0,0,0,0,0,0,0},
+    {0x1p-149f,0x1.fffffcp-127,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-149f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-127,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1.fffffcp-127,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,0x0p0f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.fffffcp-127,0x1.fffffcp-127,0,0,0,0,0,0,0},
+    {0x1.fffffcp-127,0x1p-126f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-127,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-127,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-127,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-127,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffcp-127,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1p-126f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1p-126f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1p-126f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1p-126f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1p-126f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1p-126f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1p-126f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1p-126f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1p-126f,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1p-126f,0x0p0f,1,1,1,1,1,1,0},
+    {0x1p-126f,0x1p-149f,1,1,1,1,1,1,0},
+    {0x1p-126f,0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1p-126f,0x1p-126f,0,0,0,0,0,0,0},
+    {0x1p-126f,0x1.fffffep-1f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-126f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-126f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-126f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p-126f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffep-1f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1.fffffep-1f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,0x0p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.fffffep-1f,0x1.fffffep-1f,0,0,0,0,0,0,0},
+    {0x1.fffffep-1f,0x1p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffep-1f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffep-1f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffep-1f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1p0f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1p0f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1p0f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1p0f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1p0f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1p0f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1p0f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1p0f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1p0f,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1p0f,0x0p0f,1,1,1,1,1,1,0},
+    {0x1p0f,0x1p-149f,1,1,1,1,1,1,0},
+    {0x1p0f,0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1p0f,0x1p-126f,1,1,1,1,1,1,0},
+    {0x1p0f,0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1p0f,0x1p0f,0,0,0,0,0,0,0},
+    {0x1p0f,0x1.000002p0f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p0f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x1p0f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.000002p0f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1.000002p0f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x0p0f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x1p0f,1,1,1,1,1,1,0},
+    {0x1.000002p0f,0x1.000002p0f,0,0,0,0,0,0,0},
+    {0x1.000002p0f,0x1.fffffep+127f,-1,-1,-1,-1,-1,-1,0},
+    {0x1.000002p0f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {0x1.fffffep+127f,__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {0x1.fffffep+127f,-__builtin_inff(),1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x1p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,-0x0p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x0p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1p-149f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1p-126f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1.000002p0f,1,1,1,1,1,1,0},
+    {0x1.fffffep+127f,0x1.fffffep+127f,0,0,0,0,0,0,0},
+    {0x1.fffffep+127f,__builtin_inff(),-1,-1,-1,-1,-1,-1,0},
+    {__builtin_inff(),__builtin_nanf(""),1,-1,-1,1,1,1,1},
+    {__builtin_inff(),-__builtin_inff(),1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x1p0f,1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x1p-126f,1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x1p-149f,1,1,1,1,1,1,0},
+    {__builtin_inff(),-0x0p0f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x0p0f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1p-149f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1.fffffcp-127,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1p-126f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1.fffffep-1f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1p0f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1.000002p0f,1,1,1,1,1,1,0},
+    {__builtin_inff(),0x1.fffffep+127f,1,1,1,1,1,1,0},
+    {__builtin_inff(),__builtin_inff(),0,0,0,0,0,0,0},
+};    
+
+int main(int argc, char *argv[]) {
+    const int numVectors = sizeof vectors / sizeof vectors[0];
+    int i;
+    for (i = 0; i<numVectors; ++i) {
+        if (test__cmpsf2(&vectors[i])) return 1;
+    }
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ctzdi2_test.c b/compiler-rt/test/builtins/Unit/ctzdi2_test.c
new file mode 100644
index 0000000..bde66b1
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ctzdi2_test.c
@@ -0,0 +1,67 @@
+//===-- ctzdi2_test.c - Test __ctzdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ctzdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the number of trailing 0-bits
+
+// Precondition: a != 0
+
+COMPILER_RT_ABI si_int __ctzdi2(di_int a);
+
+int test__ctzdi2(di_int a, si_int expected)
+{
+    si_int x = __ctzdi2(a);
+    if (x != expected)
+        printf("error in __ctzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+//    if (test__ctzdi2(0x00000000, N))  // undefined
+//        return 1;
+    if (test__ctzdi2(0x00000001, 0))
+        return 1;
+    if (test__ctzdi2(0x00000002, 1))
+        return 1;
+    if (test__ctzdi2(0x00000003, 0))
+        return 1;
+    if (test__ctzdi2(0x00000004, 2))
+        return 1;
+    if (test__ctzdi2(0x00000005, 0))
+        return 1;
+    if (test__ctzdi2(0x0000000A, 1))
+        return 1;
+    if (test__ctzdi2(0x10000000, 28))
+        return 1;
+    if (test__ctzdi2(0x20000000, 29))
+        return 1;
+    if (test__ctzdi2(0x60000000, 29))
+        return 1;
+    if (test__ctzdi2(0x80000000uLL, 31))
+        return 1;
+    if (test__ctzdi2(0x0000050000000000uLL, 40))
+        return 1;
+    if (test__ctzdi2(0x0200080000000000uLL, 43))
+        return 1;
+    if (test__ctzdi2(0x7200000000000000uLL, 57))
+        return 1;
+    if (test__ctzdi2(0x8000000000000000uLL, 63))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ctzsi2_test.c b/compiler-rt/test/builtins/Unit/ctzsi2_test.c
new file mode 100644
index 0000000..cbc101f
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ctzsi2_test.c
@@ -0,0 +1,569 @@
+//===-- ctzsi2_test.c - Test __ctzsi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ctzsi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the number of trailing 0-bits
+
+// Precondition: a != 0
+
+COMPILER_RT_ABI si_int __ctzsi2(si_int a);
+
+int test__ctzsi2(si_int a, si_int expected)
+{
+    si_int x = __ctzsi2(a);
+    if (x != expected)
+        printf("error in __ctzsi2(0x%X) = %d, expected %d\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+//     if (test__ctzsi2(0x00000000, 32))  // undefined
+//         return 1;
+    if (test__ctzsi2(0x00000001, 0))
+        return 1;
+    if (test__ctzsi2(0x00000002, 1))
+        return 1;
+    if (test__ctzsi2(0x00000003, 0))
+        return 1;
+    if (test__ctzsi2(0x00000004, 2))
+        return 1;
+    if (test__ctzsi2(0x00000005, 0))
+        return 1;
+    if (test__ctzsi2(0x00000006, 1))
+        return 1;
+    if (test__ctzsi2(0x00000007, 0))
+        return 1;
+    if (test__ctzsi2(0x00000008, 3))
+        return 1;
+    if (test__ctzsi2(0x00000009, 0))
+        return 1;
+    if (test__ctzsi2(0x0000000A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000000B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000000C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000000D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000000E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000000F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000010, 4))
+        return 1;
+    if (test__ctzsi2(0x00000012, 1))
+        return 1;
+    if (test__ctzsi2(0x00000013, 0))
+        return 1;
+    if (test__ctzsi2(0x00000014, 2))
+        return 1;
+    if (test__ctzsi2(0x00000015, 0))
+        return 1;
+    if (test__ctzsi2(0x00000016, 1))
+        return 1;
+    if (test__ctzsi2(0x00000017, 0))
+        return 1;
+    if (test__ctzsi2(0x00000018, 3))
+        return 1;
+    if (test__ctzsi2(0x00000019, 0))
+        return 1;
+    if (test__ctzsi2(0x0000001A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000001B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000001C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000001D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000001E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000001F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000020, 5))
+        return 1;
+    if (test__ctzsi2(0x00000022, 1))
+        return 1;
+    if (test__ctzsi2(0x00000023, 0))
+        return 1;
+    if (test__ctzsi2(0x00000024, 2))
+        return 1;
+    if (test__ctzsi2(0x00000025, 0))
+        return 1;
+    if (test__ctzsi2(0x00000026, 1))
+        return 1;
+    if (test__ctzsi2(0x00000027, 0))
+        return 1;
+    if (test__ctzsi2(0x00000028, 3))
+        return 1;
+    if (test__ctzsi2(0x00000029, 0))
+        return 1;
+    if (test__ctzsi2(0x0000002A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000002B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000002C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000002D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000002E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000002F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000030, 4))
+        return 1;
+    if (test__ctzsi2(0x00000032, 1))
+        return 1;
+    if (test__ctzsi2(0x00000033, 0))
+        return 1;
+    if (test__ctzsi2(0x00000034, 2))
+        return 1;
+    if (test__ctzsi2(0x00000035, 0))
+        return 1;
+    if (test__ctzsi2(0x00000036, 1))
+        return 1;
+    if (test__ctzsi2(0x00000037, 0))
+        return 1;
+    if (test__ctzsi2(0x00000038, 3))
+        return 1;
+    if (test__ctzsi2(0x00000039, 0))
+        return 1;
+    if (test__ctzsi2(0x0000003A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000003B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000003C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000003D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000003E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000003F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000040, 6))
+        return 1;
+    if (test__ctzsi2(0x00000042, 1))
+        return 1;
+    if (test__ctzsi2(0x00000043, 0))
+        return 1;
+    if (test__ctzsi2(0x00000044, 2))
+        return 1;
+    if (test__ctzsi2(0x00000045, 0))
+        return 1;
+    if (test__ctzsi2(0x00000046, 1))
+        return 1;
+    if (test__ctzsi2(0x00000047, 0))
+        return 1;
+    if (test__ctzsi2(0x00000048, 3))
+        return 1;
+    if (test__ctzsi2(0x00000049, 0))
+        return 1;
+    if (test__ctzsi2(0x0000004A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000004B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000004C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000004D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000004E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000004F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000050, 4))
+        return 1;
+    if (test__ctzsi2(0x00000052, 1))
+        return 1;
+    if (test__ctzsi2(0x00000053, 0))
+        return 1;
+    if (test__ctzsi2(0x00000054, 2))
+        return 1;
+    if (test__ctzsi2(0x00000055, 0))
+        return 1;
+    if (test__ctzsi2(0x00000056, 1))
+        return 1;
+    if (test__ctzsi2(0x00000057, 0))
+        return 1;
+    if (test__ctzsi2(0x00000058, 3))
+        return 1;
+    if (test__ctzsi2(0x00000059, 0))
+        return 1;
+    if (test__ctzsi2(0x0000005A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000005B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000005C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000005D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000005E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000005F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000060, 5))
+        return 1;
+    if (test__ctzsi2(0x00000062, 1))
+        return 1;
+    if (test__ctzsi2(0x00000063, 0))
+        return 1;
+    if (test__ctzsi2(0x00000064, 2))
+        return 1;
+    if (test__ctzsi2(0x00000065, 0))
+        return 1;
+    if (test__ctzsi2(0x00000066, 1))
+        return 1;
+    if (test__ctzsi2(0x00000067, 0))
+        return 1;
+    if (test__ctzsi2(0x00000068, 3))
+        return 1;
+    if (test__ctzsi2(0x00000069, 0))
+        return 1;
+    if (test__ctzsi2(0x0000006A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000006B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000006C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000006D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000006E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000006F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000070, 4))
+        return 1;
+    if (test__ctzsi2(0x00000072, 1))
+        return 1;
+    if (test__ctzsi2(0x00000073, 0))
+        return 1;
+    if (test__ctzsi2(0x00000074, 2))
+        return 1;
+    if (test__ctzsi2(0x00000075, 0))
+        return 1;
+    if (test__ctzsi2(0x00000076, 1))
+        return 1;
+    if (test__ctzsi2(0x00000077, 0))
+        return 1;
+    if (test__ctzsi2(0x00000078, 3))
+        return 1;
+    if (test__ctzsi2(0x00000079, 0))
+        return 1;
+    if (test__ctzsi2(0x0000007A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000007B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000007C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000007D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000007E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000007F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000080, 7))
+        return 1;
+    if (test__ctzsi2(0x00000082, 1))
+        return 1;
+    if (test__ctzsi2(0x00000083, 0))
+        return 1;
+    if (test__ctzsi2(0x00000084, 2))
+        return 1;
+    if (test__ctzsi2(0x00000085, 0))
+        return 1;
+    if (test__ctzsi2(0x00000086, 1))
+        return 1;
+    if (test__ctzsi2(0x00000087, 0))
+        return 1;
+    if (test__ctzsi2(0x00000088, 3))
+        return 1;
+    if (test__ctzsi2(0x00000089, 0))
+        return 1;
+    if (test__ctzsi2(0x0000008A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000008B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000008C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000008D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000008E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000008F, 0))
+        return 1;
+    if (test__ctzsi2(0x00000090, 4))
+        return 1;
+    if (test__ctzsi2(0x00000092, 1))
+        return 1;
+    if (test__ctzsi2(0x00000093, 0))
+        return 1;
+    if (test__ctzsi2(0x00000094, 2))
+        return 1;
+    if (test__ctzsi2(0x00000095, 0))
+        return 1;
+    if (test__ctzsi2(0x00000096, 1))
+        return 1;
+    if (test__ctzsi2(0x00000097, 0))
+        return 1;
+    if (test__ctzsi2(0x00000098, 3))
+        return 1;
+    if (test__ctzsi2(0x00000099, 0))
+        return 1;
+    if (test__ctzsi2(0x0000009A, 1))
+        return 1;
+    if (test__ctzsi2(0x0000009B, 0))
+        return 1;
+    if (test__ctzsi2(0x0000009C, 2))
+        return 1;
+    if (test__ctzsi2(0x0000009D, 0))
+        return 1;
+    if (test__ctzsi2(0x0000009E, 1))
+        return 1;
+    if (test__ctzsi2(0x0000009F, 0))
+        return 1;
+    if (test__ctzsi2(0x000000A0, 5))
+        return 1;
+    if (test__ctzsi2(0x000000A2, 1))
+        return 1;
+    if (test__ctzsi2(0x000000A3, 0))
+        return 1;
+    if (test__ctzsi2(0x000000A4, 2))
+        return 1;
+    if (test__ctzsi2(0x000000A5, 0))
+        return 1;
+    if (test__ctzsi2(0x000000A6, 1))
+        return 1;
+    if (test__ctzsi2(0x000000A7, 0))
+        return 1;
+    if (test__ctzsi2(0x000000A8, 3))
+        return 1;
+    if (test__ctzsi2(0x000000A9, 0))
+        return 1;
+    if (test__ctzsi2(0x000000AA, 1))
+        return 1;
+    if (test__ctzsi2(0x000000AB, 0))
+        return 1;
+    if (test__ctzsi2(0x000000AC, 2))
+        return 1;
+    if (test__ctzsi2(0x000000AD, 0))
+        return 1;
+    if (test__ctzsi2(0x000000AE, 1))
+        return 1;
+    if (test__ctzsi2(0x000000AF, 0))
+        return 1;
+    if (test__ctzsi2(0x000000B0, 4))
+        return 1;
+    if (test__ctzsi2(0x000000B2, 1))
+        return 1;
+    if (test__ctzsi2(0x000000B3, 0))
+        return 1;
+    if (test__ctzsi2(0x000000B4, 2))
+        return 1;
+    if (test__ctzsi2(0x000000B5, 0))
+        return 1;
+    if (test__ctzsi2(0x000000B6, 1))
+        return 1;
+    if (test__ctzsi2(0x000000B7, 0))
+        return 1;
+    if (test__ctzsi2(0x000000B8, 3))
+        return 1;
+    if (test__ctzsi2(0x000000B9, 0))
+        return 1;
+    if (test__ctzsi2(0x000000BA, 1))
+        return 1;
+    if (test__ctzsi2(0x000000BB, 0))
+        return 1;
+    if (test__ctzsi2(0x000000BC, 2))
+        return 1;
+    if (test__ctzsi2(0x000000BD, 0))
+        return 1;
+    if (test__ctzsi2(0x000000BE, 1))
+        return 1;
+    if (test__ctzsi2(0x000000BF, 0))
+        return 1;
+    if (test__ctzsi2(0x000000C0, 6))
+        return 1;
+    if (test__ctzsi2(0x000000C2, 1))
+        return 1;
+    if (test__ctzsi2(0x000000C3, 0))
+        return 1;
+    if (test__ctzsi2(0x000000C4, 2))
+        return 1;
+    if (test__ctzsi2(0x000000C5, 0))
+        return 1;
+    if (test__ctzsi2(0x000000C6, 1))
+        return 1;
+    if (test__ctzsi2(0x000000C7, 0))
+        return 1;
+    if (test__ctzsi2(0x000000C8, 3))
+        return 1;
+    if (test__ctzsi2(0x000000C9, 0))
+        return 1;
+    if (test__ctzsi2(0x000000CA, 1))
+        return 1;
+    if (test__ctzsi2(0x000000CB, 0))
+        return 1;
+    if (test__ctzsi2(0x000000CC, 2))
+        return 1;
+    if (test__ctzsi2(0x000000CD, 0))
+        return 1;
+    if (test__ctzsi2(0x000000CE, 1))
+        return 1;
+    if (test__ctzsi2(0x000000CF, 0))
+        return 1;
+    if (test__ctzsi2(0x000000D0, 4))
+        return 1;
+    if (test__ctzsi2(0x000000D2, 1))
+        return 1;
+    if (test__ctzsi2(0x000000D3, 0))
+        return 1;
+    if (test__ctzsi2(0x000000D4, 2))
+        return 1;
+    if (test__ctzsi2(0x000000D5, 0))
+        return 1;
+    if (test__ctzsi2(0x000000D6, 1))
+        return 1;
+    if (test__ctzsi2(0x000000D7, 0))
+        return 1;
+    if (test__ctzsi2(0x000000D8, 3))
+        return 1;
+    if (test__ctzsi2(0x000000D9, 0))
+        return 1;
+    if (test__ctzsi2(0x000000DA, 1))
+        return 1;
+    if (test__ctzsi2(0x000000DB, 0))
+        return 1;
+    if (test__ctzsi2(0x000000DC, 2))
+        return 1;
+    if (test__ctzsi2(0x000000DD, 0))
+        return 1;
+    if (test__ctzsi2(0x000000DE, 1))
+        return 1;
+    if (test__ctzsi2(0x000000DF, 0))
+        return 1;
+    if (test__ctzsi2(0x000000E0, 5))
+        return 1;
+    if (test__ctzsi2(0x000000E2, 1))
+        return 1;
+    if (test__ctzsi2(0x000000E3, 0))
+        return 1;
+    if (test__ctzsi2(0x000000E4, 2))
+        return 1;
+    if (test__ctzsi2(0x000000E5, 0))
+        return 1;
+    if (test__ctzsi2(0x000000E6, 1))
+        return 1;
+    if (test__ctzsi2(0x000000E7, 0))
+        return 1;
+    if (test__ctzsi2(0x000000E8, 3))
+        return 1;
+    if (test__ctzsi2(0x000000E9, 0))
+        return 1;
+    if (test__ctzsi2(0x000000EA, 1))
+        return 1;
+    if (test__ctzsi2(0x000000EB, 0))
+        return 1;
+    if (test__ctzsi2(0x000000EC, 2))
+        return 1;
+    if (test__ctzsi2(0x000000ED, 0))
+        return 1;
+    if (test__ctzsi2(0x000000EE, 1))
+        return 1;
+    if (test__ctzsi2(0x000000EF, 0))
+        return 1;
+    if (test__ctzsi2(0x000000F0, 4))
+        return 1;
+    if (test__ctzsi2(0x000000F2, 1))
+        return 1;
+    if (test__ctzsi2(0x000000F3, 0))
+        return 1;
+    if (test__ctzsi2(0x000000F4, 2))
+        return 1;
+    if (test__ctzsi2(0x000000F5, 0))
+        return 1;
+    if (test__ctzsi2(0x000000F6, 1))
+        return 1;
+    if (test__ctzsi2(0x000000F7, 0))
+        return 1;
+    if (test__ctzsi2(0x000000F8, 3))
+        return 1;
+    if (test__ctzsi2(0x000000F9, 0))
+        return 1;
+    if (test__ctzsi2(0x000000FA, 1))
+        return 1;
+    if (test__ctzsi2(0x000000FB, 0))
+        return 1;
+    if (test__ctzsi2(0x000000FC, 2))
+        return 1;
+    if (test__ctzsi2(0x000000FD, 0))
+        return 1;
+    if (test__ctzsi2(0x000000FE, 1))
+        return 1;
+    if (test__ctzsi2(0x000000FF, 0))
+        return 1;
+
+    if (test__ctzsi2(0x00000100, 8))
+        return 1;
+    if (test__ctzsi2(0x00000200, 9))
+        return 1;
+    if (test__ctzsi2(0x00000400, 10))
+        return 1;
+    if (test__ctzsi2(0x00000800, 11))
+        return 1;
+    if (test__ctzsi2(0x00001000, 12))
+        return 1;
+    if (test__ctzsi2(0x00002000, 13))
+        return 1;
+    if (test__ctzsi2(0x00004000, 14))
+        return 1;
+    if (test__ctzsi2(0x00008000, 15))
+        return 1;
+    if (test__ctzsi2(0x00010000, 16))
+        return 1;
+    if (test__ctzsi2(0x00020000, 17))
+        return 1;
+    if (test__ctzsi2(0x00040000, 18))
+        return 1;
+    if (test__ctzsi2(0x00080000, 19))
+        return 1;
+    if (test__ctzsi2(0x00100000, 20))
+        return 1;
+    if (test__ctzsi2(0x00200000, 21))
+        return 1;
+    if (test__ctzsi2(0x00400000, 22))
+        return 1;
+    if (test__ctzsi2(0x00800000, 23))
+        return 1;
+    if (test__ctzsi2(0x01000000, 24))
+        return 1;
+    if (test__ctzsi2(0x02000000, 25))
+        return 1;
+    if (test__ctzsi2(0x04000000, 26))
+        return 1;
+    if (test__ctzsi2(0x08000000, 27))
+        return 1;
+    if (test__ctzsi2(0x10000000, 28))
+        return 1;
+    if (test__ctzsi2(0x20000000, 29))
+        return 1;
+    if (test__ctzsi2(0x40000000, 30))
+        return 1;
+    if (test__ctzsi2(0x80000000, 31))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ctzti2_test.c b/compiler-rt/test/builtins/Unit/ctzti2_test.c
new file mode 100644
index 0000000..0ca1920
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ctzti2_test.c
@@ -0,0 +1,84 @@
+//===-- ctzti2_test.c - Test __ctzti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ctzti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: the number of trailing 0-bits
+
+// Precondition: a != 0
+
+COMPILER_RT_ABI si_int __ctzti2(ti_int a);
+
+int test__ctzti2(ti_int a, si_int expected)
+{
+    si_int x = __ctzti2(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __ctzti2(0x%llX%.16llX) = %d, expected %d\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__ctzti2(0x00000001, 0))
+        return 1;
+    if (test__ctzti2(0x00000002, 1))
+        return 1;
+    if (test__ctzti2(0x00000003, 0))
+        return 1;
+    if (test__ctzti2(0x00000004, 2))
+        return 1;
+    if (test__ctzti2(0x00000005, 0))
+        return 1;
+    if (test__ctzti2(0x0000000A, 1))
+        return 1;
+    if (test__ctzti2(0x10000000, 28))
+        return 1;
+    if (test__ctzti2(0x20000000, 29))
+        return 1;
+    if (test__ctzti2(0x60000000, 29))
+        return 1;
+    if (test__ctzti2(0x80000000uLL, 31))
+        return 1;
+    if (test__ctzti2(0x0000050000000000uLL, 40))
+        return 1;
+    if (test__ctzti2(0x0200080000000000uLL, 43))
+        return 1;
+    if (test__ctzti2(0x7200000000000000uLL, 57))
+        return 1;
+    if (test__ctzti2(0x8000000000000000uLL, 63))
+        return 1;
+    if (test__ctzti2(make_ti(0x00000000A0000000LL, 0x0000000000000000LL), 93))
+        return 1;
+    if (test__ctzti2(make_ti(0xF000000000000000LL, 0x0000000000000000LL), 124))
+        return 1;
+    if (test__ctzti2(make_ti(0x8000000000000000LL, 0x0000000000000000LL), 127))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divdc3_test.c b/compiler-rt/test/builtins/Unit/divdc3_test.c
new file mode 100644
index 0000000..80b9e86
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divdc3_test.c
@@ -0,0 +1,371 @@
+//===-- divdc3_test.c - Test __divdc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divdc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+// Returns: the quotient of (a + ib) / (c + id)
+
+COMPILER_RT_ABI double _Complex
+__divdc3(double __a, double __b, double __c, double __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(double _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(creal(x)) || isinf(cimag(x)))
+        return inf;
+    if (isnan(creal(x)) && isnan(cimag(x)))
+        return NaN;
+    if (isnan(creal(x)))
+    {
+        if (cimag(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimag(x)))
+    {
+        if (creal(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__divdc3(double a, double b, double c, double d)
+{
+    double _Complex r = __divdc3(a, b, c, d);
+//     printf("test__divdc3(%f, %f, %f, %f) = %f + I%f\n",
+//             a, b, c, d, creal(r), cimag(r));
+	double _Complex dividend;
+	double _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            {
+            double _Complex z = (a * c + b * d) / (c * c + d * d)
+                             + (b * c - a * d) / (c * c + d * d) * _Complex_I;
+            if (cabs((r-z)/r) > 1.e-6)
+                return 1;
+            }
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+double x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+int main()
+{
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__divdc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divdf3vfp_test.c b/compiler-rt/test/builtins/Unit/divdf3vfp_test.c
new file mode 100644
index 0000000..6f0808a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divdf3vfp_test.c
@@ -0,0 +1,49 @@
+//===-- divdf3vfp_test.c - Test __divdf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divdf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern COMPILER_RT_ABI double __divdf3vfp(double a, double b);
+
+int test__divdf3vfp(double a, double b)
+{
+    double actual = __divdf3vfp(a, b);
+    double expected = a / b;
+    if (actual != expected)
+        printf("error in test__divdf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__divdf3vfp(1.0, 1.0))
+        return 1;
+    if (test__divdf3vfp(12345.678, 1.23))
+        return 1;
+    if (test__divdf3vfp(-10.0, 0.25))
+        return 1;
+    if (test__divdf3vfp(10.0, -2.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divdi3_test.c b/compiler-rt/test/builtins/Unit/divdi3_test.c
new file mode 100644
index 0000000..1d45980
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divdi3_test.c
@@ -0,0 +1,58 @@
+//===-- divdi3_test.c - Test __divdi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
+
+int test__divdi3(di_int a, di_int b, di_int expected)
+{
+    di_int x = __divdi3(a, b);
+    if (x != expected)
+        printf("error in __divdi3: %lld / %lld = %lld, expected %lld\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__divdi3(0, 1, 0))
+        return 1;
+    if (test__divdi3(0, -1, 0))
+        return 1;
+
+    if (test__divdi3(2, 1, 2))
+        return 1;
+    if (test__divdi3(2, -1, -2))
+        return 1;
+    if (test__divdi3(-2, 1, -2))
+        return 1;
+    if (test__divdi3(-2, -1, 2))
+        return 1;
+
+    if (test__divdi3(0x8000000000000000LL, 1, 0x8000000000000000LL))
+        return 1;
+    if (test__divdi3(0x8000000000000000LL, -1, 0x8000000000000000LL))
+        return 1;
+    if (test__divdi3(0x8000000000000000LL, -2, 0x4000000000000000LL))
+        return 1;
+    if (test__divdi3(0x8000000000000000LL, 2, 0xC000000000000000LL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divmodsi4_test.c b/compiler-rt/test/builtins/Unit/divmodsi4_test.c
new file mode 100644
index 0000000..6fb1c98
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divmodsi4_test.c
@@ -0,0 +1,73 @@
+//===-- divmodsi4_test.c - Test __divmodsi4 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divmodsi4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+extern COMPILER_RT_ABI si_int __divmodsi4(si_int a, si_int b, si_int* rem);
+
+
+int test__divmodsi4(si_int a, si_int b, 
+						si_int expected_result, si_int expected_rem)
+{
+	si_int rem;
+    si_int result = __divmodsi4(a, b, &rem);
+    if (result != expected_result) {
+        printf("error in __divmodsi4: %d / %d = %d, expected %d\n",
+               a, b, result, expected_result);
+		return 1;
+	}
+    if (rem != expected_rem) {
+        printf("error in __divmodsi4: %d mod %d = %d, expected %d\n",
+               a, b, rem, expected_rem);
+		return 1;
+	}
+	
+    return 0;
+}
+
+
+int main()
+{
+    if (test__divmodsi4(0, 1, 0, 0))
+        return 1;
+    if (test__divmodsi4(0, -1, 0, 0))
+        return 1;
+
+    if (test__divmodsi4(2, 1, 2, 0))
+        return 1;
+    if (test__divmodsi4(2, -1, -2, 0))
+        return 1;
+    if (test__divmodsi4(-2, 1, -2, 0))
+        return 1;
+    if (test__divmodsi4(-2, -1, 2, 0))
+        return 1;
+
+	if (test__divmodsi4(7, 5, 1, 2))
+        return 1;
+	if (test__divmodsi4(-7, 5, -1, -2))
+        return 1;
+	if (test__divmodsi4(19, 5, 3, 4))
+        return 1;
+	if (test__divmodsi4(19, -5, -3, 4))
+        return 1;
+  	
+	if (test__divmodsi4(0x80000000, 8, 0xf0000000, 0))
+        return 1;
+	if (test__divmodsi4(0x80000007, 8, 0xf0000001, -1))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divsc3_test.c b/compiler-rt/test/builtins/Unit/divsc3_test.c
new file mode 100644
index 0000000..2d7c659
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divsc3_test.c
@@ -0,0 +1,371 @@
+//===-- divsc3_test.c - Test __divsc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divsc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+// Returns: the quotient of (a + ib) / (c + id)
+
+COMPILER_RT_ABI float _Complex
+__divsc3(float __a, float __b, float __c, float __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(float _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(crealf(x)) || isinf(cimagf(x)))
+        return inf;
+    if (isnan(crealf(x)) && isnan(cimagf(x)))
+        return NaN;
+    if (isnan(crealf(x)))
+    {
+        if (cimagf(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimagf(x)))
+    {
+        if (crealf(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__divsc3(float a, float b, float c, float d)
+{
+    float _Complex r = __divsc3(a, b, c, d);
+//     printf("test__divsc3(%f, %f, %f, %f) = %f + I%f\n",
+//             a, b, c, d, crealf(r), cimagf(r));
+	float _Complex dividend;
+	float _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            {
+            float _Complex z = (a * c + b * d) / (c * c + d * d)
+                             + (b * c - a * d) / (c * c + d * d) * _Complex_I;
+            if (r != z)
+                return 1;
+            }
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+float x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+int main()
+{
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__divsc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divsf3vfp_test.c b/compiler-rt/test/builtins/Unit/divsf3vfp_test.c
new file mode 100644
index 0000000..f742441
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divsf3vfp_test.c
@@ -0,0 +1,49 @@
+//===-- divsf3vfp_test.c - Test __divsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __divsf3vfp(float a, float b);
+
+#if __arm__
+int test__divsf3vfp(float a, float b)
+{
+    float actual = __divsf3vfp(a, b);
+    float expected = a / b;
+    if (actual != expected)
+        printf("error in test__divsf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__divsf3vfp(1.0, 1.0))
+        return 1;
+    if (test__divsf3vfp(12345.678, 1.23))
+        return 1;
+    if (test__divsf3vfp(0.0, HUGE_VALF))
+        return 1;
+    if (test__divsf3vfp(10.0, -2.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divsi3_test.c b/compiler-rt/test/builtins/Unit/divsi3_test.c
new file mode 100644
index 0000000..c523367
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divsi3_test.c
@@ -0,0 +1,56 @@
+//===-- divsi3_test.c - Test __divsi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
+
+int test__divsi3(si_int a, si_int b, si_int expected)
+{
+    si_int x = __divsi3(a, b);
+    if (x != expected)
+        printf("error in __divsi3: %d / %d = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+    if (test__divsi3(0, 1, 0))
+        return 1;
+    if (test__divsi3(0, -1, 0))
+        return 1;
+
+    if (test__divsi3(2, 1, 2))
+        return 1;
+    if (test__divsi3(2, -1, -2))
+        return 1;
+    if (test__divsi3(-2, 1, -2))
+        return 1;
+    if (test__divsi3(-2, -1, 2))
+        return 1;
+
+    if (test__divsi3(0x80000000, 1, 0x80000000))
+        return 1;
+    if (test__divsi3(0x80000000, -1, 0x80000000))
+        return 1;
+    if (test__divsi3(0x80000000, -2, 0x40000000))
+        return 1;
+    if (test__divsi3(0x80000000, 2, 0xC0000000))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divtc3_test.c b/compiler-rt/test/builtins/Unit/divtc3_test.c
new file mode 100644
index 0000000..a1f0613
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divtc3_test.c
@@ -0,0 +1,374 @@
+//===-- divtc3_test.c - Test __divtc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divtc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+// Returns: the quotient of (a + ib) / (c + id)
+
+COMPILER_RT_ABI long double _Complex
+__divtc3(long double __a, long double __b, long double __c, long double __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(long double _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(creall(x)) || isinf(cimagl(x)))
+        return inf;
+    if (isnan(creall(x)) && isnan(cimagl(x)))
+        return NaN;
+    if (isnan(creall(x)))
+    {
+        if (cimagl(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimagl(x)))
+    {
+        if (creall(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__divtc3(long double a, long double b, long double c, long double d)
+{
+    long double _Complex r = __divtc3(a, b, c, d);
+//      printf("test__divtc3(%Lf, %Lf, %Lf, %Lf) = %Lf + I%Lf\n",
+//              a, b, c, d, creall(r), cimagl(r));
+	
+	long double _Complex dividend;
+	long double _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            {
+            long double _Complex z = (a * c + b * d) / (c * c + d * d)
+                                   + (b * c - a * d) / (c * c + d * d) * _Complex_I;
+            if (cabsl((r - z)/r) > 1.e-6)
+                return 1;
+            }
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+long double x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+int main()
+{
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__divtc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+//	printf("No errors found.\n");
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divtf3_test.c b/compiler-rt/test/builtins/Unit/divtf3_test.c
new file mode 100644
index 0000000..e0def45
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divtf3_test.c
@@ -0,0 +1,95 @@
+//===--------------- divtf3_test.c - Test __divtf3 ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divtf3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: a / b
+COMPILER_RT_ABI long double __divtf3(long double a, long double b);
+
+int test__divtf3(long double a, long double b,
+                 uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __divtf3(a, b);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__divtf3(%.20Lf, %.20Lf) = %.20Lf, "
+               "expected %.20Lf\n", a, b, x,
+               fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN / any = qNaN
+    if (test__divtf3(makeQNaN128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // NaN / any = NaN
+    if (test__divtf3(makeNaN128(UINT64_C(0x800030000000)),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf / any = inf
+    if (test__divtf3(makeInf128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any / any
+    if (test__divtf3(0x1.a23b45362464523375893ab4cdefp+5L,
+                     0x1.eedcbaba3a94546558237654321fp-1L,
+                     UINT64_C(0x4004b0b72924d407),
+                     UINT64_C(0x0717e84356c6eba2)))
+        return 1;
+    if (test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50L,
+                     0x1.ed2c3ba15935332532287654321fp-9L,
+                     UINT64_C(0x3fd5b2af3f828c9b),
+                     UINT64_C(0x40e51f64cde8b1f2)))
+        return 15;
+    if (test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456L,
+                     0x1.edacbba9874f765463544dd3621fp+6400L,
+                     UINT64_C(0x28c62e15dc464466),
+                     UINT64_C(0xb5a07586348557ac)))
+        return 1;
+    if (test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234L,
+                     0x1.eddcdba39f3c8b7a36564354321fp-4455L,
+                     UINT64_C(0x507b38442b539266),
+                     UINT64_C(0x22ce0f1d024e1252)))
+        return 1;
+    if (test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234L,
+                     0x1.edcba987d6bb3aa467754354321fp-4055L,
+                     UINT64_C(0x50bf2e02f0798d36),
+                     UINT64_C(0x5e6fcb6b60044078)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divti3_test.c b/compiler-rt/test/builtins/Unit/divti3_test.c
new file mode 100644
index 0000000..3a94dab
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divti3_test.c
@@ -0,0 +1,78 @@
+//===-- divti3_test.c - Test __divti3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a / b
+
+COMPILER_RT_ABI ti_int __divti3(ti_int a, ti_int b);
+
+int test__divti3(ti_int a, ti_int b, ti_int expected)
+{
+    ti_int x = __divti3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __divti3: 0x%llX%.16llX / 0x%llX%.16llX = "
+               "0x%llX%.16llX, expected 0x%llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__divti3(0, 1, 0))
+        return 1;
+    if (test__divti3(0, -1, 0))
+        return 1;
+
+    if (test__divti3(2, 1, 2))
+        return 1;
+    if (test__divti3(2, -1, -2))
+        return 1;
+    if (test__divti3(-2, 1, -2))
+        return 1;
+    if (test__divti3(-2, -1, 2))
+        return 1;
+
+    if (test__divti3(make_ti(0x8000000000000000LL, 0), 1, make_ti(0x8000000000000000LL, 0)))
+        return 1;
+    if (test__divti3(make_ti(0x8000000000000000LL, 0), -1, make_ti(0x8000000000000000LL, 0)))
+        return 1;
+    if (test__divti3(make_ti(0x8000000000000000LL, 0), -2, make_ti(0x4000000000000000LL, 0)))
+        return 1;
+    if (test__divti3(make_ti(0x8000000000000000LL, 0), 2, make_ti(0xC000000000000000LL, 0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/divxc3_test.c b/compiler-rt/test/builtins/Unit/divxc3_test.c
new file mode 100644
index 0000000..509b4b1
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/divxc3_test.c
@@ -0,0 +1,379 @@
+//===-- divxc3_test.c - Test __divxc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divxc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+// Returns: the quotient of (a + ib) / (c + id)
+
+COMPILER_RT_ABI long double _Complex
+__divxc3(long double __a, long double __b, long double __c, long double __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(long double _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(creall(x)) || isinf(cimagl(x)))
+        return inf;
+    if (isnan(creall(x)) && isnan(cimagl(x)))
+        return NaN;
+    if (isnan(creall(x)))
+    {
+        if (cimagl(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimagl(x)))
+    {
+        if (creall(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__divxc3(long double a, long double b, long double c, long double d)
+{
+    long double _Complex r = __divxc3(a, b, c, d);
+//     printf("test__divxc3(%Lf, %Lf, %Lf, %Lf) = %Lf + I%Lf\n",
+//             a, b, c, d, creall(r), cimagl(r));
+	long double _Complex dividend;
+	long double _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            {
+            long double _Complex z = (a * c + b * d) / (c * c + d * d)
+                                   + (b * c - a * d) / (c * c + d * d) * _Complex_I;
+            if (cabs((r - z)/r) > 1.e-6)
+                return 1;
+            }
+            break;
+        case inf:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+long double x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+#endif
+
+int main()
+{
+#if !_ARCH_PPC
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__divxc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/enable_execute_stack_test.c b/compiler-rt/test/builtins/Unit/enable_execute_stack_test.c
new file mode 100644
index 0000000..38a142a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/enable_execute_stack_test.c
@@ -0,0 +1,80 @@
+//===-- enable_execute_stack_test.c - Test __enable_execute_stack ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#if defined(_WIN32)
+#include <windows.h>
+void __clear_cache(void* start, void* end)
+{
+    if (!FlushInstructionCache(GetCurrentProcess(), start, end-start))
+        exit(1);
+}
+void __enable_execute_stack(void *addr)
+{
+    MEMORY_BASIC_INFORMATION b;
+
+    if (!VirtualQuery(addr, &b, sizeof(b)))
+        exit(1);
+    if (!VirtualProtect(b.BaseAddress, b.RegionSize, PAGE_EXECUTE_READWRITE, &b.Protect))
+        exit(1);
+}
+#else
+#include <sys/mman.h>
+extern void __clear_cache(void* start, void* end);
+extern void __enable_execute_stack(void* addr);
+#endif
+
+typedef int (*pfunc)(void);
+
+int func1() 
+{
+    return 1;
+}
+
+int func2() 
+{
+    return 2;
+}
+
+void *__attribute__((noinline))
+memcpy_f(void *dst, const void *src, size_t n) {
+// ARM and MIPS nartually align functions, but use the LSB for ISA selection
+// (THUMB, MIPS16/uMIPS respectively).  Ensure that the ISA bit is ignored in
+// the memcpy
+#if defined(__arm__) || defined(__mips__)
+  return (void *)((uintptr_t)memcpy(dst, (void *)((uintptr_t)src & ~1), n) |
+                  ((uintptr_t)src & 1));
+#else
+  return memcpy(dst, (void *)((uintptr_t)src), n);
+#endif
+}
+
+int main()
+{
+    unsigned char execution_buffer[128];
+    // mark stack page containing execution_buffer to be executable
+    __enable_execute_stack(execution_buffer);
+	
+    // verify you can copy and execute a function
+    pfunc f1 = (pfunc)memcpy_f(execution_buffer, func1, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    if ((*f1)() != 1)
+        return 1;
+
+    // verify you can overwrite a function with another
+    pfunc f2 = (pfunc)memcpy_f(execution_buffer, func2, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    if ((*f2)() != 2)
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/endianness.h b/compiler-rt/test/builtins/Unit/endianness.h
new file mode 100644
index 0000000..06c53de
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/endianness.h
@@ -0,0 +1,109 @@
+/* ===-- endianness.h - configuration header for libgcc replacement --------===
+ *
+ *		       The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file is a configuration header for libgcc replacement.
+ * This file is not part of the interface of this library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifndef ENDIANNESS_H
+#define ENDIANNESS_H
+
+/*
+ * Known limitations:
+ *   Middle endian systems are not handled currently.
+ */
+
+#if defined(__SVR4) && defined(__sun)
+#include <sys/byteorder.h>
+
+#if _BYTE_ORDER == _BIG_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif _BYTE_ORDER == _LITTLE_ENDIAN 
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* _BYTE_ORDER */
+
+#endif /* Solaris and AuroraUX. */
+
+/* .. */
+
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonflyBSD__) || defined(__minix)
+#include <sys/endian.h>
+
+#if _BYTE_ORDER == _BIG_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif _BYTE_ORDER == _LITTLE_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* _BYTE_ORDER */
+
+#endif /* *BSD */
+
+/* .. */
+
+#if defined(__OpenBSD__) || defined(__Bitrig__)
+#include <machine/endian.h>
+
+#if _BYTE_ORDER == _BIG_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif _BYTE_ORDER == _LITTLE_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* _BYTE_ORDER */
+
+#endif /* OpenBSD and Bitrig. */
+
+/* .. */
+
+/* Mac OSX has __BIG_ENDIAN__ or __LITTLE_ENDIAN__ automatically set by the compiler (at least with GCC) */
+#if defined(__APPLE__) && defined(__MACH__) || defined(__ellcc__ )
+
+#ifdef __BIG_ENDIAN__
+#if __BIG_ENDIAN__
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#endif
+#endif /* __BIG_ENDIAN__ */
+
+#ifdef __LITTLE_ENDIAN__
+#if __LITTLE_ENDIAN__
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif
+#endif /* __LITTLE_ENDIAN__ */
+
+#endif /* Mac OSX */
+
+/* .. */
+
+#if defined(__linux__)
+#include <endian.h>
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 0
+#define _YUGA_BIG_ENDIAN    1
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+#define _YUGA_LITTLE_ENDIAN 1
+#define _YUGA_BIG_ENDIAN    0
+#endif /* __BYTE_ORDER */
+
+#endif /* GNU/Linux */
+
+/* . */
+
+#if !defined(_YUGA_LITTLE_ENDIAN) || !defined(_YUGA_BIG_ENDIAN)
+#error Unable to determine endian
+#endif /* Check we found an endianness correctly. */
+
+#endif /* ENDIANNESS_H */
diff --git a/compiler-rt/test/builtins/Unit/eqdf2vfp_test.c b/compiler-rt/test/builtins/Unit/eqdf2vfp_test.c
new file mode 100644
index 0000000..585bd08
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/eqdf2vfp_test.c
@@ -0,0 +1,55 @@
+//===-- eqdf2vfp_test.c - Test __eqdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __eqdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __eqdf2vfp(double a, double b);
+
+#if __arm__
+int test__eqdf2vfp(double a, double b)
+{
+    int actual = __eqdf2vfp(a, b);
+	int expected = (a == b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __eqdf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__eqdf2vfp(0.0, 0.0))
+        return 1;
+    if (test__eqdf2vfp(1.0, 1.0))
+        return 1;
+    if (test__eqdf2vfp(0.0, 1.0))
+        return 1;
+    if (test__eqdf2vfp(-1.0, -1.0))
+        return 1;
+    if (test__eqdf2vfp(-1.0, 0.0))
+        return 1;
+    if (test__eqdf2vfp(HUGE_VAL, 1.0))
+        return 1;
+    if (test__eqdf2vfp(1.0, HUGE_VAL))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/eqsf2vfp_test.c b/compiler-rt/test/builtins/Unit/eqsf2vfp_test.c
new file mode 100644
index 0000000..b0eed94
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/eqsf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- eqsf2vfp_test.c - Test __eqsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __eqsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __eqsf2vfp(float a, float b);
+
+#if __arm__
+int test__eqsf2vfp(float a, float b)
+{
+    int actual = __eqsf2vfp(a, b);
+	int expected = (a == b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __eqsf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__eqsf2vfp(0.0, 0.0))
+        return 1;
+    if (test__eqsf2vfp(1.0, 1.0))
+        return 1;
+    if (test__eqsf2vfp(-1.0, -1.0))
+        return 1;
+    if (test__eqsf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__eqsf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/eqtf2_test.c b/compiler-rt/test/builtins/Unit/eqtf2_test.c
new file mode 100644
index 0000000..0385835
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/eqtf2_test.c
@@ -0,0 +1,89 @@
+//===------------ eqtf2_test.c - Test __eqtf2------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __eqtf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __eqtf2(long double a, long double b);
+
+int test__eqtf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __eqtf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__eqtf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__eqtf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__eqtf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // ==
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__eqtf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/extebdsfdf2vfp_test.c b/compiler-rt/test/builtins/Unit/extebdsfdf2vfp_test.c
new file mode 100644
index 0000000..53c7282
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/extebdsfdf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- extendsfdf2vfp_test.c - Test __extendsfdf2vfp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __extendsfdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI double __extendsfdf2vfp(float a);
+
+#if __arm__
+int test__extendsfdf2vfp(float a)
+{
+    double actual = __extendsfdf2vfp(a);
+    double expected = a;
+    if (actual != expected)
+        printf("error in test__extendsfdf2vfp(%f) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__extendsfdf2vfp(0.0))
+        return 1;
+    if (test__extendsfdf2vfp(1.0))
+        return 1;
+    if (test__extendsfdf2vfp(-1.0))
+        return 1;
+    if (test__extendsfdf2vfp(3.1415926535))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/extenddftf2_test.c b/compiler-rt/test/builtins/Unit/extenddftf2_test.c
new file mode 100644
index 0000000..2cfb32b
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/extenddftf2_test.c
@@ -0,0 +1,83 @@
+//===--------------- extenddftf2_test.c - Test __extenddftf2 --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __extenddftf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI long double __extenddftf2(double a);
+
+int test__extenddftf2(double a, uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __extenddftf2(a);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__extenddftf2(%f) = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN
+    if (test__extenddftf2(makeQNaN64(),
+                          UINT64_C(0x7fff800000000000),
+                          UINT64_C(0x0)))
+        return 1;
+    // NaN
+    if (test__extenddftf2(makeNaN64(UINT64_C(0x7100000000000)),
+                          UINT64_C(0x7fff710000000000),
+                          UINT64_C(0x0)))
+        return 1;
+    // inf
+    if (test__extenddftf2(makeInf64(),
+                          UINT64_C(0x7fff000000000000),
+                          UINT64_C(0x0)))
+        return 1;
+    // zero
+    if (test__extenddftf2(0.0, UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+
+    if (test__extenddftf2(0x1.23456789abcdefp+5,
+                          UINT64_C(0x400423456789abcd),
+                          UINT64_C(0xf000000000000000)))
+        return 1;
+    if (test__extenddftf2(0x1.edcba987654321fp-9,
+                          UINT64_C(0x3ff6edcba9876543),
+                          UINT64_C(0x2000000000000000)))
+        return 1;
+    if (test__extenddftf2(0x1.23456789abcdefp+45,
+                          UINT64_C(0x402c23456789abcd),
+                          UINT64_C(0xf000000000000000)))
+        return 1;
+    if (test__extenddftf2(0x1.edcba987654321fp-45,
+                          UINT64_C(0x3fd2edcba9876543),
+                          UINT64_C(0x2000000000000000)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/extendhfsf2_test.c b/compiler-rt/test/builtins/Unit/extendhfsf2_test.c
new file mode 100644
index 0000000..5dd994c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/extendhfsf2_test.c
@@ -0,0 +1,113 @@
+//===--------------- extendhfsf2_test.c - Test __extendhfsf2 --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __extendhfsf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#include "fp_test.h"
+
+float __extendhfsf2(uint16_t a);
+
+int test__extendhfsf2(uint16_t a, float expected)
+{
+    float x = __extendhfsf2(a);
+    int ret = compareResultH(x, expected);
+
+    if (ret){
+        printf("error in test__extendhfsf2(%#.4x) = %f, "
+               "expected %f\n", a, x, expected);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
+
+int main()
+{
+    // qNaN
+    if (test__extendhfsf2(UINT16_C(0x7e00),
+                          makeQNaN32()))
+        return 1;
+    // NaN
+    if (test__extendhfsf2(UINT16_C(0x7e00),
+                          makeNaN32(UINT32_C(0x8000))))
+        return 1;
+    // inf
+    if (test__extendhfsf2(UINT16_C(0x7c00),
+                          makeInf32()))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0xfc00),
+                          -makeInf32()))
+        return 1;
+    // zero
+    if (test__extendhfsf2(UINT16_C(0x0),
+                          0.0f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x8000),
+                          -0.0f))
+        return 1;
+
+    if (test__extendhfsf2(UINT16_C(0x4248),
+                          3.1415926535f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0xc248),
+                          -3.1415926535f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x7c00),
+                          0x1.987124876876324p+100f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x6e62),
+                          0x1.988p+12f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x3c00),
+                          0x1.0p+0f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x0400),
+                          0x1.0p-14f))
+        return 1;
+    // denormal
+    if (test__extendhfsf2(UINT16_C(0x0010),
+                          0x1.0p-20f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x0001),
+                          0x1.0p-24f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x8001),
+                          -0x1.0p-24f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x0001),
+                          0x1.5p-25f))
+        return 1;
+    // and back to zero
+    if (test__extendhfsf2(UINT16_C(0x0000),
+                          0x1.0p-25f))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0x8000),
+                          -0x1.0p-25f))
+        return 1;
+    // max (precise)
+    if (test__extendhfsf2(UINT16_C(0x7bff),
+                          65504.0f))
+        return 1;
+    // max (rounded)
+    if (test__extendhfsf2(UINT16_C(0x7bff),
+                          65504.0f))
+        return 1;
+    // max (to +inf)
+    if (test__extendhfsf2(UINT16_C(0x7c00),
+                          makeInf32()))
+        return 1;
+    if (test__extendhfsf2(UINT16_C(0xfc00),
+                          -makeInf32()))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/extendsftf2_test.c b/compiler-rt/test/builtins/Unit/extendsftf2_test.c
new file mode 100644
index 0000000..7dff5b6
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/extendsftf2_test.c
@@ -0,0 +1,84 @@
+//===--------------- extendsftf2_test.c - Test __extendsftf2 --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __extendsftf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI long double __extendsftf2(float a);
+
+int test__extendsftf2(float a, uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __extendsftf2(a);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret)
+    {
+        printf("error in test__extendsftf2(%f) = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN
+    if (test__extendsftf2(makeQNaN32(),
+                          UINT64_C(0x7fff800000000000),
+                          UINT64_C(0x0)))
+        return 1;
+    // NaN
+    if (test__extendsftf2(makeNaN32(UINT32_C(0x410000)),
+                          UINT64_C(0x7fff820000000000),
+                          UINT64_C(0x0)))
+        return 1;
+    // inf
+    if (test__extendsftf2(makeInf32(),
+                          UINT64_C(0x7fff000000000000),
+                          UINT64_C(0x0)))
+        return 1;
+    // zero
+    if (test__extendsftf2(0.0f, UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+
+    if (test__extendsftf2(0x1.23456p+5f,
+                          UINT64_C(0x4004234560000000),
+                          UINT64_C(0x0)))
+        return 1;
+    if (test__extendsftf2(0x1.edcbap-9f,
+                          UINT64_C(0x3ff6edcba0000000),
+                          UINT64_C(0x0)))
+        return 1;
+    if (test__extendsftf2(0x1.23456p+45f,
+                          UINT64_C(0x402c234560000000),
+                          UINT64_C(0x0)))
+        return 1;
+    if (test__extendsftf2(0x1.edcbap-45f,
+                          UINT64_C(0x3fd2edcba0000000),
+                          UINT64_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ffsdi2_test.c b/compiler-rt/test/builtins/Unit/ffsdi2_test.c
new file mode 100644
index 0000000..a27d154
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ffsdi2_test.c
@@ -0,0 +1,66 @@
+//===-- ffsdi2_test.c - Test __ffsdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ffsdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the index of the least significant 1-bit in a, or
+// the value zero if a is zero. The least significant bit is index one.
+
+COMPILER_RT_ABI si_int __ffsdi2(di_int a);
+
+int test__ffsdi2(di_int a, si_int expected)
+{
+    si_int x = __ffsdi2(a);
+    if (x != expected)
+        printf("error in __ffsdi2(0x%llX) = %d, expected %d\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__ffsdi2(0x00000000, 0))
+        return 1;
+    if (test__ffsdi2(0x00000001, 1))
+        return 1;
+    if (test__ffsdi2(0x00000002, 2))
+        return 1;
+    if (test__ffsdi2(0x00000003, 1))
+        return 1;
+    if (test__ffsdi2(0x00000004, 3))
+        return 1;
+    if (test__ffsdi2(0x00000005, 1))
+        return 1;
+    if (test__ffsdi2(0x0000000A, 2))
+        return 1;
+    if (test__ffsdi2(0x10000000, 29))
+        return 1;
+    if (test__ffsdi2(0x20000000, 30))
+        return 1;
+    if (test__ffsdi2(0x60000000, 30))
+        return 1;
+    if (test__ffsdi2(0x80000000uLL, 32))
+        return 1;
+    if (test__ffsdi2(0x0000050000000000uLL, 41))
+        return 1;
+    if (test__ffsdi2(0x0200080000000000uLL, 44))
+        return 1;
+    if (test__ffsdi2(0x7200000000000000uLL, 58))
+        return 1;
+    if (test__ffsdi2(0x8000000000000000uLL, 64))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ffsti2_test.c b/compiler-rt/test/builtins/Unit/ffsti2_test.c
new file mode 100644
index 0000000..396269d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ffsti2_test.c
@@ -0,0 +1,83 @@
+//===-- ffsti2_test.c - Test __ffsti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ffsti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: the index of the least significant 1-bit in a, or
+// the value zero if a is zero. The least significant bit is index one.
+
+COMPILER_RT_ABI si_int __ffsti2(ti_int a);
+
+int test__ffsti2(ti_int a, si_int expected)
+{
+    si_int x = __ffsti2(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __ffsti2(0x%llX%.16llX) = %d, expected %d\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__ffsti2(0x00000000, 0))
+        return 1;
+    if (test__ffsti2(0x00000001, 1))
+        return 1;
+    if (test__ffsti2(0x00000002, 2))
+        return 1;
+    if (test__ffsti2(0x00000003, 1))
+        return 1;
+    if (test__ffsti2(0x00000004, 3))
+        return 1;
+    if (test__ffsti2(0x00000005, 1))
+        return 1;
+    if (test__ffsti2(0x0000000A, 2))
+        return 1;
+    if (test__ffsti2(0x10000000, 29))
+        return 1;
+    if (test__ffsti2(0x20000000, 30))
+        return 1;
+    if (test__ffsti2(0x60000000, 30))
+        return 1;
+    if (test__ffsti2(0x80000000uLL, 32))
+        return 1;
+    if (test__ffsti2(0x0000050000000000uLL, 41))
+        return 1;
+    if (test__ffsti2(0x0200080000000000uLL, 44))
+        return 1;
+    if (test__ffsti2(0x7200000000000000uLL, 58))
+        return 1;
+    if (test__ffsti2(0x8000000000000000uLL, 64))
+        return 1;
+    if (test__ffsti2(make_ti(0x8000000800000000uLL, 0), 100))
+        return 1;
+    if (test__ffsti2(make_ti(0x8000000000000000uLL, 0), 128))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixdfdi_test.c b/compiler-rt/test/builtins/Unit/fixdfdi_test.c
new file mode 100644
index 0000000..4a7cfa3
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixdfdi_test.c
@@ -0,0 +1,94 @@
+//===-- fixdfdi_test.c - Test __fixdfdi -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixdfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a signed long long, rounding toward zero.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             su_int is a 32 bit integral type
+//             value in double is representable in di_int (no range checking performed)
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI di_int __fixdfdi(double a);
+
+int test__fixdfdi(double a, di_int expected)
+{
+    di_int x = __fixdfdi(a);
+    if (x != expected)
+        printf("error in __fixdfdi(%A) = %llX, expected %llX\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+int main()
+{
+    if (test__fixdfdi(0.0, 0))
+        return 1;
+
+    if (test__fixdfdi(0.5, 0))
+        return 1;
+    if (test__fixdfdi(0.99, 0))
+        return 1;
+    if (test__fixdfdi(1.0, 1))
+        return 1;
+    if (test__fixdfdi(1.5, 1))
+        return 1;
+    if (test__fixdfdi(1.99, 1))
+        return 1;
+    if (test__fixdfdi(2.0, 2))
+        return 1;
+    if (test__fixdfdi(2.01, 2))
+        return 1;
+    if (test__fixdfdi(-0.5, 0))
+        return 1;
+    if (test__fixdfdi(-0.99, 0))
+        return 1;
+    if (test__fixdfdi(-1.0, -1))
+        return 1;
+    if (test__fixdfdi(-1.5, -1))
+        return 1;
+    if (test__fixdfdi(-1.99, -1))
+        return 1;
+    if (test__fixdfdi(-2.0, -2))
+        return 1;
+    if (test__fixdfdi(-2.01, -2))
+        return 1;
+
+    if (test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixdfdi(-0x1.FFFFFEp+62, 0x8000008000000000LL))
+        return 1;
+    if (test__fixdfdi(-0x1.FFFFFCp+62, 0x8000010000000000LL))
+        return 1;
+
+    if (test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, 0x8000000000000400LL))
+        return 1;
+    if (test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, 0x8000000000000800LL))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixdfsivfp_test.c b/compiler-rt/test/builtins/Unit/fixdfsivfp_test.c
new file mode 100644
index 0000000..c6102e2
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixdfsivfp_test.c
@@ -0,0 +1,50 @@
+//===-- fixdfsivfp_test.c - Test __fixdfsivfp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixdfsivfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern int __fixdfsivfp(double a);
+
+#if __arm__
+int test__fixdfsivfp(double a)
+{
+	int actual = __fixdfsivfp(a);
+	int expected = a;
+    if (actual != expected)
+        printf("error in test__fixdfsivfp(%f) = %d, expected %d\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__fixdfsivfp(0.0))
+        return 1;
+    if (test__fixdfsivfp(1.0))
+        return 1;
+    if (test__fixdfsivfp(-1.0))
+        return 1;
+    if (test__fixdfsivfp(2147483647))
+        return 1;
+    if (test__fixdfsivfp(-2147483648.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixdfti_test.c b/compiler-rt/test/builtins/Unit/fixdfti_test.c
new file mode 100644
index 0000000..b5da456
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixdfti_test.c
@@ -0,0 +1,123 @@
+//===-- fixdfti_test.c - Test __fixdfti -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixdfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a signed long long, rounding toward zero.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             su_int is a 32 bit integral type
+//             value in double is representable in ti_int (no range checking performed)
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI ti_int __fixdfti(double a);
+
+int test__fixdfti(double a, ti_int expected)
+{
+    ti_int x = __fixdfti(a);
+    if (x != expected)
+    {
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __fixdfti(%A) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+        a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__fixdfti(0.0, 0))
+        return 1;
+
+    if (test__fixdfti(0.5, 0))
+        return 1;
+    if (test__fixdfti(0.99, 0))
+        return 1;
+    if (test__fixdfti(1.0, 1))
+        return 1;
+    if (test__fixdfti(1.5, 1))
+        return 1;
+    if (test__fixdfti(1.99, 1))
+        return 1;
+    if (test__fixdfti(2.0, 2))
+        return 1;
+    if (test__fixdfti(2.01, 2))
+        return 1;
+    if (test__fixdfti(-0.5, 0))
+        return 1;
+    if (test__fixdfti(-0.99, 0))
+        return 1;
+    if (test__fixdfti(-1.0, -1))
+        return 1;
+    if (test__fixdfti(-1.5, -1))
+        return 1;
+    if (test__fixdfti(-1.99, -1))
+        return 1;
+    if (test__fixdfti(-2.0, -2))
+        return 1;
+    if (test__fixdfti(-2.01, -2))
+        return 1;
+
+    if (test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixdfti(-0x1.FFFFFEp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                               0x8000008000000000LL)))
+        return 1;
+    if (test__fixdfti(-0x1.FFFFFCp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                               0x8000010000000000LL)))
+        return 1;
+
+    if (test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                      0x8000000000000400LL)))
+        return 1;
+    if (test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                      0x8000000000000800LL)))
+        return 1;
+
+    if (test__fixdfti(0x1.FFFFFFFFFFFFFp+126, make_ti(0x7FFFFFFFFFFFFC00LL, 0)))
+        return 1;
+    if (test__fixdfti(0x1.FFFFFFFFFFFFEp+126, make_ti(0x7FFFFFFFFFFFF800LL, 0)))
+        return 1;
+
+    if (test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, make_ti(0x8000000000000400LL, 0)))
+        return 1;
+    if (test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, make_ti(0x8000000000000800LL, 0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixsfdi_test.c b/compiler-rt/test/builtins/Unit/fixsfdi_test.c
new file mode 100644
index 0000000..f37ecef
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixsfdi_test.c
@@ -0,0 +1,84 @@
+//===-- fixsfdi_test.c - Test __fixsfdi -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixsfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a signed long long, rounding toward zero.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             su_int is a 32 bit integral type
+//             value in float is representable in di_int (no range checking performed)
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI di_int __fixsfdi(float a);
+
+int test__fixsfdi(float a, di_int expected)
+{
+    di_int x = __fixsfdi(a);
+    if (x != expected)
+        printf("error in __fixsfdi(%A) = %llX, expected %llX\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__fixsfdi(0.0F, 0))
+        return 1;
+
+    if (test__fixsfdi(0.5F, 0))
+        return 1;
+    if (test__fixsfdi(0.99F, 0))
+        return 1;
+    if (test__fixsfdi(1.0F, 1))
+        return 1;
+    if (test__fixsfdi(1.5F, 1))
+        return 1;
+    if (test__fixsfdi(1.99F, 1))
+        return 1;
+    if (test__fixsfdi(2.0F, 2))
+        return 1;
+    if (test__fixsfdi(2.01F, 2))
+        return 1;
+    if (test__fixsfdi(-0.5F, 0))
+        return 1;
+    if (test__fixsfdi(-0.99F, 0))
+        return 1;
+    if (test__fixsfdi(-1.0F, -1))
+        return 1;
+    if (test__fixsfdi(-1.5F, -1))
+        return 1;
+    if (test__fixsfdi(-1.99F, -1))
+        return 1;
+    if (test__fixsfdi(-2.0F, -2))
+        return 1;
+    if (test__fixsfdi(-2.01F, -2))
+        return 1;
+
+    if (test__fixsfdi(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixsfdi(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixsfdi(-0x1.FFFFFEp+62F, 0x8000008000000000LL))
+        return 1;
+    if (test__fixsfdi(-0x1.FFFFFCp+62F, 0x8000010000000000LL))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixsfsivfp_test.c b/compiler-rt/test/builtins/Unit/fixsfsivfp_test.c
new file mode 100644
index 0000000..9abf5e8
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixsfsivfp_test.c
@@ -0,0 +1,52 @@
+//===-- fixsfsivfp_test.c - Test __fixsfsivfp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixsfsivfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern int __fixsfsivfp(float a);
+
+#if __arm__
+int test__fixsfsivfp(float a)
+{
+	int actual = __fixsfsivfp(a);
+	int expected = a;
+    if (actual != expected)
+        printf("error in test__fixsfsivfp(%f) = %u, expected %u\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__fixsfsivfp(0.0))
+        return 1;
+    if (test__fixsfsivfp(1.0))
+        return 1;
+    if (test__fixsfsivfp(-1.0))
+        return 1;
+    if (test__fixsfsivfp(2147483647.0))
+        return 1;
+    if (test__fixsfsivfp(-2147483648.0))
+        return 1;
+    if (test__fixsfsivfp(65536.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixsfti_test.c b/compiler-rt/test/builtins/Unit/fixsfti_test.c
new file mode 100644
index 0000000..38748aa
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixsfti_test.c
@@ -0,0 +1,111 @@
+//===-- fixsfti_test.c - Test __fixsfti -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixsfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a signed long long, rounding toward zero.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             su_int is a 32 bit integral type
+//             value in float is representable in ti_int (no range checking performed)
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI ti_int __fixsfti(float a);
+
+int test__fixsfti(float a, ti_int expected)
+{
+    ti_int x = __fixsfti(a);
+    if (x != expected)
+    {
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __fixsfti(%A) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+        a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__fixsfti(0.0F, 0))
+        return 1;
+
+    if (test__fixsfti(0.5F, 0))
+        return 1;
+    if (test__fixsfti(0.99F, 0))
+        return 1;
+    if (test__fixsfti(1.0F, 1))
+        return 1;
+    if (test__fixsfti(1.5F, 1))
+        return 1;
+    if (test__fixsfti(1.99F, 1))
+        return 1;
+    if (test__fixsfti(2.0F, 2))
+        return 1;
+    if (test__fixsfti(2.01F, 2))
+        return 1;
+    if (test__fixsfti(-0.5F, 0))
+        return 1;
+    if (test__fixsfti(-0.99F, 0))
+        return 1;
+    if (test__fixsfti(-1.0F, -1))
+        return 1;
+    if (test__fixsfti(-1.5F, -1))
+        return 1;
+    if (test__fixsfti(-1.99F, -1))
+        return 1;
+    if (test__fixsfti(-2.0F, -2))
+        return 1;
+    if (test__fixsfti(-2.01F, -2))
+        return 1;
+
+    if (test__fixsfti(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixsfti(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixsfti(-0x1.FFFFFEp+62F, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                0x8000008000000000LL)))
+        return 1;
+    if (test__fixsfti(-0x1.FFFFFCp+62F, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                0x8000010000000000LL)))
+        return 1;
+
+    if (test__fixsfti(0x1.FFFFFEp+126F, make_ti(0x7FFFFF8000000000LL, 0)))
+        return 1;
+    if (test__fixsfti(0x1.FFFFFCp+126F, make_ti(0x7FFFFF0000000000LL, 0)))
+        return 1;
+
+    if (test__fixsfti(-0x1.FFFFFEp+126F, make_ti(0x8000008000000000LL, 0)))
+        return 1;
+    if (test__fixsfti(-0x1.FFFFFCp+126F, make_ti(0x8000010000000000LL, 0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixtfdi_test.c b/compiler-rt/test/builtins/Unit/fixtfdi_test.c
new file mode 100644
index 0000000..cc25bec
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixtfdi_test.c
@@ -0,0 +1,71 @@
+//===--------------- fixtfdi_test.c - Test __fixtfdi ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixtfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+di_int __fixtfdi(long double a);
+
+int test__fixtfdi(long double a, di_int expected)
+{
+    di_int x = __fixtfdi(a);
+    int ret = (x != expected);
+
+    if (ret)
+    {
+        printf("error in test__fixtfdi(%.20Lf) = %llX, "
+               "expected %llX\n", a, x, expected);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixtfdi(makeInf128(), 0x7fffffffffffffffLL))
+        return 1;
+    if (test__fixtfdi(0, 0x0))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdefp+5L, 0x24LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdefp-3L, 0x0LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdef12345678p+20L, 0x123456LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdef12345678p+40L, 0x123456789abLL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdef12345678p+60L, 0x123456789abcdef1LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdefp+256L, 0x7fffffffffffffffLL))
+        return 1;
+    if (test__fixtfdi(-0x1.23456789abcdefp+20L, 0xffffffffffedcbaaLL))
+        return 1;
+    if (test__fixtfdi(-0x1.23456789abcdefp+40L, 0xfffffedcba987655LL))
+        return 1;
+    if (test__fixtfdi(-0x1.23456789abcdefp+256L, 0x8000000000000000LL))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixtfsi_test.c b/compiler-rt/test/builtins/Unit/fixtfsi_test.c
new file mode 100644
index 0000000..1da516b
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixtfsi_test.c
@@ -0,0 +1,65 @@
+//===--------------- fixtfsi_test.c - Test __fixtfsi ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixtfsi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __fixtfsi(long double a);
+
+int test__fixtfsi(long double a, int expected)
+{
+    int x = __fixtfsi(a);
+    int ret = (x != expected);
+
+    if (ret){
+        printf("error in test__fixtfsi(%.20Lf) = %d, "
+               "expected %d\n", a, x, expected);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixtfsi(makeInf128(), 0x7fffffff))
+        return 1;
+    if (test__fixtfsi(0, 0x0))
+        return 1;
+    if (test__fixtfsi(0x1.23456789abcdefp+5, 0x24))
+        return 1;
+    if (test__fixtfsi(0x1.23456789abcdefp-3, 0x0))
+        return 1;
+    if (test__fixtfsi(0x1.23456789abcdefp+20, 0x123456))
+        return 1;
+    if (test__fixtfsi(0x1.23456789abcdefp+40, 0x7fffffff))
+        return 1;
+    if (test__fixtfsi(0x1.23456789abcdefp+256, 0x7fffffff))
+        return 1;
+    if (test__fixtfsi(-0x1.23456789abcdefp+20, 0xffedcbaa))
+        return 1;
+    if (test__fixtfsi(-0x1.23456789abcdefp+40, 0x80000000))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixtfti_test.c b/compiler-rt/test/builtins/Unit/fixtfti_test.c
new file mode 100644
index 0000000..52184ca
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixtfti_test.c
@@ -0,0 +1,83 @@
+//===--------------- fixtfti_test.c - Test __fixtfti ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixtfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+ti_int __fixtfti(long double a);
+
+int test__fixtfti(long double a, ti_int expected)
+{
+    ti_int x = __fixtfti(a);
+    int ret = (x != expected);
+
+    if (ret)
+    {
+        twords xt;
+        xt.all = x;
+
+        twords expectedt;
+        expectedt.all = expected;
+
+        printf("error in test__fixtfti(%.20Lf) = 0x%.16llX%.16llX, "
+               "expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixtfti(makeInf128(), make_ti(0x7fffffffffffffffLL,
+                                            0xffffffffffffffffLL)))
+        return 1;
+    if (test__fixtfti(0, make_ti(0x0LL, 0x0LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdefp+5L, make_ti(0x0LL, 0x24LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdefp-3L, make_ti(0x0LL, 0x0LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdef12345678p+20L,
+                      make_ti(0x0LL, 0x123456LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdef123456789abcdep+112L,
+                      make_ti(0x123456789abcdLL, 0xef123456789abcdeLL)))
+        return 1;
+    if (test__fixtfti(-0x1.23456789abcdef123456789abcdep+112L,
+                      make_ti(0xFFFEDCBA98765432LL, 0x10EDCBA987654322LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdefp+256L, make_ti(0x7fffffffffffffffLL,
+                                                        0xffffffffffffffffLL)))
+        return 1;
+    if (test__fixtfti(-0x1.23456789abcdefp+20L, make_ti(0xffffffffffffffffLL,
+                                                        0xffffffffffedcbaaLL)))
+        return 1;
+    if (test__fixtfti(-0x1.23456789abcdefp+256L, make_ti(0x8000000000000000LL,
+                                                         0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsdfdi_test.c b/compiler-rt/test/builtins/Unit/fixunsdfdi_test.c
new file mode 100644
index 0000000..1ddc534
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsdfdi_test.c
@@ -0,0 +1,109 @@
+//===-- fixunsdfdi_test.c - Test __fixunsdfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsdfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             du_int is a 64 bit integral type
+//             value in double is representable in du_int or is negative 
+//                 (no range checking performed)
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI du_int __fixunsdfdi(double a);
+
+int test__fixunsdfdi(double a, du_int expected)
+{
+    du_int x = __fixunsdfdi(a);
+    if (x != expected)
+        printf("error in __fixunsdfdi(%A) = %llX, expected %llX\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(du_int) == 2*sizeof(su_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+int main()
+{
+    if (test__fixunsdfdi(0.0, 0))
+        return 1;
+
+    if (test__fixunsdfdi(0.5, 0))
+        return 1;
+    if (test__fixunsdfdi(0.99, 0))
+        return 1;
+    if (test__fixunsdfdi(1.0, 1))
+        return 1;
+    if (test__fixunsdfdi(1.5, 1))
+        return 1;
+    if (test__fixunsdfdi(1.99, 1))
+        return 1;
+    if (test__fixunsdfdi(2.0, 2))
+        return 1;
+    if (test__fixunsdfdi(2.01, 2))
+        return 1;
+    if (test__fixunsdfdi(-0.5, 0))
+        return 1;
+    if (test__fixunsdfdi(-0.99, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunsdfdi(-1.0, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunsdfdi(-1.5, 0))
+        return 1;
+    if (test__fixunsdfdi(-1.99, 0))
+        return 1;
+    if (test__fixunsdfdi(-2.0, 0))
+        return 1;
+    if (test__fixunsdfdi(-2.01, 0))
+        return 1;
+#endif
+
+    if (test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunsdfdi(-0x1.FFFFFEp+62, 0))
+        return 1;
+    if (test__fixunsdfdi(-0x1.FFFFFCp+62, 0))
+        return 1;
+#endif
+
+    if (test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800LL))
+        return 1;
+    if (test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixunsdfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0))
+        return 1;
+    if (test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0))
+        return 1;
+#endif
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsdfsi_test.c b/compiler-rt/test/builtins/Unit/fixunsdfsi_test.c
new file mode 100644
index 0000000..8d3d630
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsdfsi_test.c
@@ -0,0 +1,102 @@
+//===-- fixunsdfsi_test.c - Test __fixunsdfsi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsdfsi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a unsigned int, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             su_int is a 32 bit integral type
+//             value in double is representable in su_int or is negative 
+//                 (no range checking performed)
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI su_int __fixunsdfsi(double a);
+
+int test__fixunsdfsi(double a, su_int expected)
+{
+    su_int x = __fixunsdfsi(a);
+    if (x != expected)
+        printf("error in __fixunsdfsi(%A) = %X, expected %X\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+int main()
+{
+    if (test__fixunsdfsi(0.0, 0))
+        return 1;
+
+    if (test__fixunsdfsi(0.5, 0))
+        return 1;
+    if (test__fixunsdfsi(0.99, 0))
+        return 1;
+    if (test__fixunsdfsi(1.0, 1))
+        return 1;
+    if (test__fixunsdfsi(1.5, 1))
+        return 1;
+    if (test__fixunsdfsi(1.99, 1))
+        return 1;
+    if (test__fixunsdfsi(2.0, 2))
+        return 1;
+    if (test__fixunsdfsi(2.01, 2))
+        return 1;
+    if (test__fixunsdfsi(-0.5, 0))
+        return 1;
+    if (test__fixunsdfsi(-0.99, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunsdfsi(-1.0, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunsdfsi(-1.5, 0))
+        return 1;
+    if (test__fixunsdfsi(-1.99, 0))
+        return 1;
+    if (test__fixunsdfsi(-2.0, 0))
+        return 1;
+    if (test__fixunsdfsi(-2.01, 0))
+        return 1;
+#endif
+
+    if (test__fixunsdfsi(0x1.000000p+31, 0x80000000))
+        return 1;
+    if (test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF))
+        return 1;
+    if (test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00))
+        return 1;
+    if (test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80))
+        return 1;
+    if (test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunsdfsi(-0x1.FFFFFEp+30, 0))
+        return 1;
+    if (test__fixunsdfsi(-0x1.FFFFFCp+30, 0))
+        return 1;
+#endif
+
+    if (test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF))
+        return 1;
+    if (test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF))
+        return 1;
+    if (test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsdfsivfp_test.c b/compiler-rt/test/builtins/Unit/fixunsdfsivfp_test.c
new file mode 100644
index 0000000..ebd0be2
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsdfsivfp_test.c
@@ -0,0 +1,51 @@
+//===-- fixunsdfsivfp_test.c - Test __fixunsdfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsdfsivfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI unsigned int __fixunsdfsivfp(double a);
+
+#if __arm__
+int test__fixunsdfsivfp(double a)
+{
+    unsigned int actual = __fixunsdfsivfp(a);
+    unsigned int expected = a;
+    if (actual != expected)
+        printf("error in test__fixunsdfsivfp(%f) = %u, expected %u\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__fixunsdfsivfp(0.0))
+        return 1;
+    if (test__fixunsdfsivfp(1.0))
+        return 1;
+    if (test__fixunsdfsivfp(-1.0))
+        return 1;
+    if (test__fixunsdfsivfp(4294967295.0))
+        return 1;
+    if (test__fixunsdfsivfp(65536.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsdfti_test.c b/compiler-rt/test/builtins/Unit/fixunsdfti_test.c
new file mode 100644
index 0000000..0298fb9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsdfti_test.c
@@ -0,0 +1,131 @@
+//===-- fixunsdfti_test.c - Test __fixunsdfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsdfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             tu_int is a 64 bit integral type
+//             value in double is representable in tu_int or is negative 
+//                 (no range checking performed)
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+#ifdef CRT_HAS_128BIT
+
+COMPILER_RT_ABI tu_int __fixunsdfti(double a);
+
+int test__fixunsdfti(double a, tu_int expected)
+{
+    tu_int x = __fixunsdfti(a);
+    if (x != expected)
+    {
+        utwords xt;
+        xt.all = x;
+        utwords expectedt;
+        expectedt.all = expected;
+        printf("error in __fixunsdfti(%A) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__fixunsdfti(0.0, 0))
+        return 1;
+
+    if (test__fixunsdfti(0.5, 0))
+        return 1;
+    if (test__fixunsdfti(0.99, 0))
+        return 1;
+    if (test__fixunsdfti(1.0, 1))
+        return 1;
+    if (test__fixunsdfti(1.5, 1))
+        return 1;
+    if (test__fixunsdfti(1.99, 1))
+        return 1;
+    if (test__fixunsdfti(2.0, 2))
+        return 1;
+    if (test__fixunsdfti(2.01, 2))
+        return 1;
+    if (test__fixunsdfti(-0.5, 0))
+        return 1;
+    if (test__fixunsdfti(-0.99, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunsdfti(-1.0, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunsdfti(-1.5, 0))
+        return 1;
+    if (test__fixunsdfti(-1.99, 0))
+        return 1;
+    if (test__fixunsdfti(-2.0, 0))
+        return 1;
+    if (test__fixunsdfti(-2.01, 0))
+        return 1;
+#endif
+
+    if (test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunsdfti(-0x1.FFFFFEp+62, 0))
+        return 1;
+    if (test__fixunsdfti(-0x1.FFFFFCp+62, 0))
+        return 1;
+#endif
+
+    if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800LL))
+        return 1;
+    if (test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, make_ti(0xFFFFFFFFFFFFF800LL, 0)))
+        return 1;
+    if (test__fixunsdfti(0x1.0000000000000p+127, make_ti(0x8000000000000000LL, 0)))
+        return 1;
+    if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, make_ti(0x7FFFFFFFFFFFFC00LL, 0)))
+        return 1;
+    if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, make_ti(0x7FFFFFFFFFFFF800LL, 0)))
+        return 1;
+    if (test__fixunsdfti(0x1.0000000000000p+128, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                         0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0))
+        return 1;
+    if (test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0))
+        return 1;
+#endif
+
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunssfdi_test.c b/compiler-rt/test/builtins/Unit/fixunssfdi_test.c
new file mode 100644
index 0000000..166153c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunssfdi_test.c
@@ -0,0 +1,97 @@
+//===-- fixunssfdi_test.c - Test __fixunssfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunssfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             du_int is a 64 bit integral type
+//             value in float is representable in du_int or is negative 
+//                 (no range checking performed)
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI du_int __fixunssfdi(float a);
+
+int test__fixunssfdi(float a, du_int expected)
+{
+    du_int x = __fixunssfdi(a);
+    if (x != expected)
+        printf("error in __fixunssfdi(%A) = %llX, expected %llX\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(du_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__fixunssfdi(0.0F, 0))
+        return 1;
+
+    if (test__fixunssfdi(0.5F, 0))
+        return 1;
+    if (test__fixunssfdi(0.99F, 0))
+        return 1;
+    if (test__fixunssfdi(1.0F, 1))
+        return 1;
+    if (test__fixunssfdi(1.5F, 1))
+        return 1;
+    if (test__fixunssfdi(1.99F, 1))
+        return 1;
+    if (test__fixunssfdi(2.0F, 2))
+        return 1;
+    if (test__fixunssfdi(2.01F, 2))
+        return 1;
+    if (test__fixunssfdi(-0.5F, 0))
+        return 1;
+    if (test__fixunssfdi(-0.99F, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunssfdi(-1.0F, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunssfdi(-1.5F, 0))
+        return 1;
+    if (test__fixunssfdi(-1.99F, 0))
+        return 1;
+    if (test__fixunssfdi(-2.0F, 0))
+        return 1;
+    if (test__fixunssfdi(-2.01F, 0))
+        return 1;
+#endif
+
+    if (test__fixunssfdi(0x1.FFFFFEp+63F, 0xFFFFFF0000000000LL))
+        return 1;
+    if (test__fixunssfdi(0x1.000000p+63F, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunssfdi(0x1.000000p+64F, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunssfdi(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunssfdi(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunssfdi(-0x1.FFFFFEp+62F, 0x0000000000000000LL))
+        return 1;
+    if (test__fixunssfdi(-0x1.FFFFFCp+62F, 0x0000000000000000LL))
+        return 1;
+#endif
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunssfsi_test.c b/compiler-rt/test/builtins/Unit/fixunssfsi_test.c
new file mode 100644
index 0000000..17293e4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunssfsi_test.c
@@ -0,0 +1,95 @@
+//===-- fixunssfsi_test.c - Test __fixunssfsi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunssfsi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a unsigned int, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             su_int is a 32 bit integral type
+//             value in float is representable in su_int or is negative 
+//                 (no range checking performed)
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI su_int __fixunssfsi(float a);
+
+int test__fixunssfsi(float a, su_int expected)
+{
+    su_int x = __fixunssfsi(a);
+    if (x != expected)
+        printf("error in __fixunssfsi(%A) = %X, expected %X\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__fixunssfsi(0.0F, 0))
+        return 1;
+
+    if (test__fixunssfsi(0.5F, 0))
+        return 1;
+    if (test__fixunssfsi(0.99F, 0))
+        return 1;
+    if (test__fixunssfsi(1.0F, 1))
+        return 1;
+    if (test__fixunssfsi(1.5F, 1))
+        return 1;
+    if (test__fixunssfsi(1.99F, 1))
+        return 1;
+    if (test__fixunssfsi(2.0F, 2))
+        return 1;
+    if (test__fixunssfsi(2.01F, 2))
+        return 1;
+    if (test__fixunssfsi(-0.5F, 0))
+        return 1;
+    if (test__fixunssfsi(-0.99F, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunssfsi(-1.0F, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunssfsi(-1.5F, 0))
+        return 1;
+    if (test__fixunssfsi(-1.99F, 0))
+        return 1;
+    if (test__fixunssfsi(-2.0F, 0))
+        return 1;
+    if (test__fixunssfsi(-2.01F, 0))
+        return 1;
+#endif
+
+    if (test__fixunssfsi(0x1.000000p+31F, 0x80000000))
+        return 1;
+    if (test__fixunssfsi(0x1.000000p+32F, 0xFFFFFFFF))
+        return 1;
+    if (test__fixunssfsi(0x1.FFFFFEp+31F, 0xFFFFFF00))
+        return 1;
+    if (test__fixunssfsi(0x1.FFFFFEp+30F, 0x7FFFFF80))
+        return 1;
+    if (test__fixunssfsi(0x1.FFFFFCp+30F, 0x7FFFFF00))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunssfsi(-0x1.FFFFFEp+30F, 0))
+        return 1;
+    if (test__fixunssfsi(-0x1.FFFFFCp+30F, 0))
+        return 1;
+#endif
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunssfsivfp_test.c b/compiler-rt/test/builtins/Unit/fixunssfsivfp_test.c
new file mode 100644
index 0000000..c8e45f4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunssfsivfp_test.c
@@ -0,0 +1,50 @@
+//===-- fixunssfsivfp_test.c - Test __fixunssfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunssfsivfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern unsigned int __fixunssfsivfp(float a);
+
+#if __arm__
+int test__fixunssfsivfp(float a)
+{
+    unsigned int actual = __fixunssfsivfp(a);
+    unsigned int expected = a;
+    if (actual != expected)
+        printf("error in test__fixunssfsivfp(%f) = %u, expected %u\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__fixunssfsivfp(0.0))
+        return 1;
+    if (test__fixunssfsivfp(1.0))
+        return 1;
+    if (test__fixunssfsivfp(-1.0))
+        return 1;
+    if (test__fixunssfsivfp(4294967295.0))
+        return 1;
+    if (test__fixunssfsivfp(65536.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunssfti_test.c b/compiler-rt/test/builtins/Unit/fixunssfti_test.c
new file mode 100644
index 0000000..979d661
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunssfti_test.c
@@ -0,0 +1,120 @@
+//===-- fixunssfti_test.c - Test __fixunssfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunssfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             tu_int is a 64 bit integral type
+//             value in float is representable in tu_int or is negative 
+//                 (no range checking performed)
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI tu_int __fixunssfti(float a);
+
+int test__fixunssfti(float a, tu_int expected)
+{
+    tu_int x = __fixunssfti(a);
+    if (x != expected)
+    {
+        utwords xt;
+        xt.all = x;
+        utwords expectedt;
+        expectedt.all = expected;
+        printf("error in __fixunssfti(%A) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__fixunssfti(0.0F, 0))
+        return 1;
+
+    if (test__fixunssfti(0.5F, 0))
+        return 1;
+    if (test__fixunssfti(0.99F, 0))
+        return 1;
+    if (test__fixunssfti(1.0F, 1))
+        return 1;
+    if (test__fixunssfti(1.5F, 1))
+        return 1;
+    if (test__fixunssfti(1.99F, 1))
+        return 1;
+    if (test__fixunssfti(2.0F, 2))
+        return 1;
+    if (test__fixunssfti(2.01F, 2))
+        return 1;
+    if (test__fixunssfti(-0.5F, 0))
+        return 1;
+    if (test__fixunssfti(-0.99F, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunssfti(-1.0F, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunssfti(-1.5F, 0))
+        return 1;
+    if (test__fixunssfti(-1.99F, 0))
+        return 1;
+    if (test__fixunssfti(-2.0F, 0))
+        return 1;
+    if (test__fixunssfti(-2.01F, 0))
+        return 1;
+#endif
+
+    if (test__fixunssfti(0x1.FFFFFEp+63F, 0xFFFFFF0000000000LL))
+        return 1;
+    if (test__fixunssfti(0x1.000000p+63F, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunssfti(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunssfti(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixunssfti(0x1.FFFFFEp+127F, make_ti(0xFFFFFF0000000000LL, 0)))
+        return 1;
+    if (test__fixunssfti(0x1.000000p+127F, make_ti(0x8000000000000000LL, 0)))
+        return 1;
+    if (test__fixunssfti(0x1.FFFFFEp+126F, make_ti(0x7FFFFF8000000000LL, 0)))
+        return 1;
+    if (test__fixunssfti(0x1.FFFFFCp+126F, make_ti(0x7FFFFF0000000000LL, 0)))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunssfti(-0x1.FFFFFEp+62F, 0x0000000000000000LL))
+        return 1;
+    if (test__fixunssfti(-0x1.FFFFFCp+62F, 0x0000000000000000LL))
+        return 1;
+    if (test__fixunssfti(-0x1.FFFFFEp+126F, 0x0000000000000000LL))
+        return 1;
+    if (test__fixunssfti(-0x1.FFFFFCp+126F, 0x0000000000000000LL))
+        return 1;
+#endif
+
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunstfdi_test.c b/compiler-rt/test/builtins/Unit/fixunstfdi_test.c
new file mode 100644
index 0000000..817c59b
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunstfdi_test.c
@@ -0,0 +1,124 @@
+//===-- fixunstfdi_test.c - Test __fixunstfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunstfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if _ARCH_PPC || __aarch64__
+
+#include "int_lib.h"
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is a 128 bit floating point type
+//             du_int is a 64 bit integral type
+//             value in long double is representable in du_int or is negative 
+//                 (no range checking performed)
+
+COMPILER_RT_ABI du_int __fixunstfdi(long double a);
+
+int test__fixunstfdi(long double a, du_int expected)
+{
+    du_int x = __fixunstfdi(a);
+    if (x != expected)
+        printf("error in __fixunstfdi(%LA) = %llX, expected %llX\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(du_int) == 2*sizeof(su_int)] = {0};
+char assumption_2[sizeof(du_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if _ARCH_PPC || __aarch64__
+    if (test__fixunstfdi(0.0, 0))
+        return 1;
+
+    if (test__fixunstfdi(0.5, 0))
+        return 1;
+    if (test__fixunstfdi(0.99, 0))
+        return 1;
+    if (test__fixunstfdi(1.0, 1))
+        return 1;
+    if (test__fixunstfdi(1.5, 1))
+        return 1;
+    if (test__fixunstfdi(1.99, 1))
+        return 1;
+    if (test__fixunstfdi(2.0, 2))
+        return 1;
+    if (test__fixunstfdi(2.01, 2))
+        return 1;
+    if (test__fixunstfdi(-0.5, 0))
+        return 1;
+    if (test__fixunstfdi(-0.99, 0))
+        return 1;
+    if (test__fixunstfdi(-1.0, 0))
+        return 1;
+    if (test__fixunstfdi(-1.5, 0))
+        return 1;
+    if (test__fixunstfdi(-1.99, 0))
+        return 1;
+    if (test__fixunstfdi(-2.0, 0))
+        return 1;
+    if (test__fixunstfdi(-2.01, 0))
+        return 1;
+
+    if (test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixunstfdi(-0x1.FFFFFEp+62, 0))
+        return 1;
+    if (test__fixunstfdi(-0x1.FFFFFCp+62, 0))
+        return 1;
+
+    if (test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0))
+        return 1;
+    if (test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0))
+        return 1;
+
+    if (test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63L, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunstfdi(0x1.0000000000000002p+63L, 0x8000000000000001LL))
+        return 1;
+    if (test__fixunstfdi(0x1.0000000000000000p+63L, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62L, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62L, 0x7FFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__fixunstfdi(0x1.p+64L, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+
+    if (test__fixunstfdi(-0x1.0000000000000000p+63L, 0))
+        return 1;
+    if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62L, 0))
+        return 1;
+    if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62L, 0))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunstfsi_test.c b/compiler-rt/test/builtins/Unit/fixunstfsi_test.c
new file mode 100644
index 0000000..13ed779
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunstfsi_test.c
@@ -0,0 +1,67 @@
+//===--------------- fixunstfsi_test.c - Test __fixunstfsi ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunstfsi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+unsigned int __fixunstfsi(long double a);
+
+int test__fixunstfsi(long double a, unsigned int expected)
+{
+    unsigned int x = __fixunstfsi(a);
+    int ret = (x != expected);
+
+    if (ret)
+    {
+        printf("error in test__fixunstfsi(%.20Lf) = %u, "
+               "expected %u\n", a, x, expected);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixunstfsi(makeInf128(), UINT32_C(0xffffffff)))
+        return 1;
+    if (test__fixunstfsi(0, UINT32_C(0x0)))
+        return 1;
+    if (test__fixunstfsi(0x1.23456789abcdefp+5, UINT32_C(0x24)))
+        return 1;
+    if (test__fixunstfsi(0x1.23456789abcdefp-3, UINT32_C(0x0)))
+        return 1;
+    if (test__fixunstfsi(0x1.23456789abcdefp+20, UINT32_C(0x123456)))
+        return 1;
+    if (test__fixunstfsi(0x1.23456789abcdefp+40, UINT32_C(0xffffffff)))
+        return 1;
+    if (test__fixunstfsi(0x1.23456789abcdefp+256, UINT32_C(0xffffffff)))
+        return 1;
+    if (test__fixunstfsi(-0x1.23456789abcdefp+3, UINT32_C(0x0)))
+        return 1;
+
+    if (test__fixunstfsi(0x1.p+32, 0xFFFFFFFFLL))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunstfti_test.c b/compiler-rt/test/builtins/Unit/fixunstfti_test.c
new file mode 100644
index 0000000..60a0982
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunstfti_test.c
@@ -0,0 +1,103 @@
+//===-- fixunstfti_test.c - Test __fixunstfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunstfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+#include "int_lib.h"
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is a 128 bit floating point type
+//             tu_int is a 128 bit integral type
+//             value in long double is representable in tu_int or is negative 
+//                 (no range checking performed)
+
+COMPILER_RT_ABI tu_int __fixunstfti(long double a);
+
+int test__fixunstfti(long double a, tu_int expected)
+{
+    tu_int x = __fixunstfti(a);
+    if (x != expected)
+    {
+        twords xt;
+        xt.all = x;
+
+        twords expectedt;
+        expectedt.all = expected;
+
+        printf("error in __fixunstfti(%.20Lf) = 0x%.16llX%.16llX, "
+               "expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 4*sizeof(su_int)] = {0};
+char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixunstfti(makeInf128(), make_ti(0xffffffffffffffffLL,
+                                               0xffffffffffffffffLL)))
+        return 1;
+
+    if (test__fixunstfti(0.0, 0))
+        return 1;
+
+    if (test__fixunstfti(0.5, 0))
+        return 1;
+    if (test__fixunstfti(0.99, 0))
+        return 1;
+    if (test__fixunstfti(1.0, 1))
+        return 1;
+    if (test__fixunstfti(1.5, 1))
+        return 1;
+    if (test__fixunstfti(1.99, 1))
+        return 1;
+    if (test__fixunstfti(2.0, 2))
+        return 1;
+    if (test__fixunstfti(2.01, 2))
+        return 1;
+    if (test__fixunstfti(-0.01, 0))
+        return 1;
+    if (test__fixunstfti(-0.99, 0))
+        return 1;
+
+    if (test__fixunstfti(0x1.p+128, make_ti(0xffffffffffffffffLL,
+                                            0xffffffffffffffffLL)))
+        return 1;
+
+    if (test__fixunstfti(0x1.FFFFFEp+126, make_ti(0x7fffff8000000000LL, 0x0)))
+        return 1;
+    if (test__fixunstfti(0x1.FFFFFEp+127, make_ti(0xffffff0000000000LL, 0x0)))
+        return 1;
+    if (test__fixunstfti(0x1.FFFFFEp+128, make_ti(0xffffffffffffffffLL,
+                                                  0xffffffffffffffffLL)))
+        return 1;
+    if (test__fixunstfti(0x1.FFFFFEp+129, make_ti(0xffffffffffffffffLL,
+                                                  0xffffffffffffffffLL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsxfdi_test.c b/compiler-rt/test/builtins/Unit/fixunsxfdi_test.c
new file mode 100644
index 0000000..6f42079
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsxfdi_test.c
@@ -0,0 +1,124 @@
+//===-- fixunsxfdi_test.c - Test __fixunsxfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsxfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <limits.h>
+
+
+#if HAS_80_BIT_LONG_DOUBLE
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+//             du_int is a 64 bit integral type
+//             value in long double is representable in du_int or is negative 
+//                 (no range checking performed)
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI du_int __fixunsxfdi(long double a);
+
+int test__fixunsxfdi(long double a, du_int expected)
+{
+    du_int x = __fixunsxfdi(a);
+    if (x != expected)
+        printf("error in __fixunsxfdi(%LA) = %llX, expected %llX\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(du_int) == 2*sizeof(su_int)] = {0};
+char assumption_2[sizeof(du_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+#endif
+
+int main()
+{
+#if HAS_80_BIT_LONG_DOUBLE
+    if (test__fixunsxfdi(0.0, 0))
+        return 1;
+
+    if (test__fixunsxfdi(0.5, 0))
+        return 1;
+    if (test__fixunsxfdi(0.99, 0))
+        return 1;
+    if (test__fixunsxfdi(1.0, 1))
+        return 1;
+    if (test__fixunsxfdi(1.5, 1))
+        return 1;
+    if (test__fixunsxfdi(1.99, 1))
+        return 1;
+    if (test__fixunsxfdi(2.0, 2))
+        return 1;
+    if (test__fixunsxfdi(2.01, 2))
+        return 1;
+    if (test__fixunsxfdi(-0.5, 0))
+        return 1;
+    if (test__fixunsxfdi(-0.99, 0))
+        return 1;
+    if (test__fixunsxfdi(-1.0, 0))
+        return 1;
+    if (test__fixunsxfdi(-1.5, 0))
+        return 1;
+    if (test__fixunsxfdi(-1.99, 0))
+        return 1;
+    if (test__fixunsxfdi(-2.0, 0))
+        return 1;
+    if (test__fixunsxfdi(-2.01, 0))
+        return 1;
+
+    if (test__fixunsxfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunsxfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixunsxfdi(-0x1.FFFFFEp+62, 0))
+        return 1;
+    if (test__fixunsxfdi(-0x1.FFFFFCp+62, 0))
+        return 1;
+
+    if (test__fixunsxfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixunsxfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixunsxfdi(-0x1.FFFFFFFFFFFFFp+62, 0))
+        return 1;
+    if (test__fixunsxfdi(-0x1.FFFFFFFFFFFFEp+62, 0))
+        return 1;
+
+    if (test__fixunsxfdi(0x1.FFFFFFFFFFFFFFFEp+63L, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunsxfdi(0x1.0000000000000002p+63L, 0x8000000000000001LL))
+        return 1;
+    if (test__fixunsxfdi(0x1.0000000000000000p+63L, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunsxfdi(0x1.FFFFFFFFFFFFFFFCp+62L, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunsxfdi(0x1.FFFFFFFFFFFFFFF8p+62L, 0x7FFFFFFFFFFFFFFELL))
+        return 1;
+
+    if (test__fixunsxfdi(-0x1.0000000000000000p+63L, 0))
+        return 1;
+    if (test__fixunsxfdi(-0x1.FFFFFFFFFFFFFFFCp+62L, 0))
+        return 1;
+    if (test__fixunsxfdi(-0x1.FFFFFFFFFFFFFFF8p+62L, 0))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsxfsi_test.c b/compiler-rt/test/builtins/Unit/fixunsxfsi_test.c
new file mode 100644
index 0000000..0d78dcb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsxfsi_test.c
@@ -0,0 +1,105 @@
+//===-- fixunsxfsi_test.c - Test __fixunsxfsi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsxfsi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if HAS_80_BIT_LONG_DOUBLE
+// Returns: convert a to a unsigned int, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+//             su_int is a 32 bit integral type
+//             value in long double is representable in su_int or is negative 
+//                 (no range checking performed)
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI su_int __fixunsxfsi(long double a);
+
+int test__fixunsxfsi(long double a, su_int expected)
+{
+    su_int x = __fixunsxfsi(a);
+    if (x != expected)
+        printf("error in __fixunsxfsi(%LA) = %X, expected %X\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+#endif
+
+int main()
+{
+#if HAS_80_BIT_LONG_DOUBLE
+    if (test__fixunsxfsi(0.0, 0))
+        return 1;
+
+    if (test__fixunsxfsi(0.5, 0))
+        return 1;
+    if (test__fixunsxfsi(0.99, 0))
+        return 1;
+    if (test__fixunsxfsi(1.0, 1))
+        return 1;
+    if (test__fixunsxfsi(1.5, 1))
+        return 1;
+    if (test__fixunsxfsi(1.99, 1))
+        return 1;
+    if (test__fixunsxfsi(2.0, 2))
+        return 1;
+    if (test__fixunsxfsi(2.01, 2))
+        return 1;
+    if (test__fixunsxfsi(-0.5, 0))
+        return 1;
+    if (test__fixunsxfsi(-0.99, 0))
+        return 1;
+#if !TARGET_LIBGCC
+    if (test__fixunsxfsi(-1.0, 0))  // libgcc ignores "returns 0 for negative input" spec
+        return 1;
+    if (test__fixunsxfsi(-1.5, 0))
+        return 1;
+    if (test__fixunsxfsi(-1.99, 0))
+        return 1;
+    if (test__fixunsxfsi(-2.0, 0))
+        return 1;
+    if (test__fixunsxfsi(-2.01, 0))
+        return 1;
+#endif
+
+    if (test__fixunsxfsi(0x1.000000p+31, 0x80000000))
+        return 1;
+    if (test__fixunsxfsi(0x1.FFFFFEp+31, 0xFFFFFF00))
+        return 1;
+    if (test__fixunsxfsi(0x1.FFFFFEp+30, 0x7FFFFF80))
+        return 1;
+    if (test__fixunsxfsi(0x1.FFFFFCp+30, 0x7FFFFF00))
+        return 1;
+
+#if !TARGET_LIBGCC
+    if (test__fixunsxfsi(-0x1.FFFFFEp+30, 0))
+        return 1;
+    if (test__fixunsxfsi(-0x1.FFFFFCp+30, 0))
+        return 1;
+#endif
+
+    if (test__fixunsxfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF))
+        return 1;
+    if (test__fixunsxfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF))
+        return 1;
+    if (test__fixunsxfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE))
+        return 1;
+
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixunsxfti_test.c b/compiler-rt/test/builtins/Unit/fixunsxfti_test.c
new file mode 100644
index 0000000..94b5aeb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixunsxfti_test.c
@@ -0,0 +1,141 @@
+//===-- fixunsxfti_test.c - Test __fixunsxfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsxfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+//             tu_int is a 64 bit integral type
+//             value in long double is representable in tu_int or is negative 
+//                 (no range checking performed)
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI tu_int __fixunsxfti(long double a);
+
+int test__fixunsxfti(long double a, tu_int expected)
+{
+    tu_int x = __fixunsxfti(a);
+    if (x != expected)
+    {
+        utwords xt;
+        xt.all = x;
+        utwords expectedt;
+        expectedt.all = expected;
+        printf("error in __fixunsxfti(%LA) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
+char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__fixunsxfti(0.0, 0))
+        return 1;
+
+    if (test__fixunsxfti(0.5, 0))
+        return 1;
+    if (test__fixunsxfti(0.99, 0))
+        return 1;
+    if (test__fixunsxfti(1.0, 1))
+        return 1;
+    if (test__fixunsxfti(1.5, 1))
+        return 1;
+    if (test__fixunsxfti(1.99, 1))
+        return 1;
+    if (test__fixunsxfti(2.0, 2))
+        return 1;
+    if (test__fixunsxfti(2.01, 2))
+        return 1;
+    if (test__fixunsxfti(-0.5, 0))
+        return 1;
+    if (test__fixunsxfti(-0.99, 0))
+        return 1;
+    if (test__fixunsxfti(-1.0, 0))
+        return 1;
+    if (test__fixunsxfti(-1.5, 0))
+        return 1;
+    if (test__fixunsxfti(-1.99, 0))
+        return 1;
+    if (test__fixunsxfti(-2.0, 0))
+        return 1;
+    if (test__fixunsxfti(-2.01, 0))
+        return 1;
+
+    if (test__fixunsxfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixunsxfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixunsxfti(-0x1.FFFFFEp+62, 0))
+        return 1;
+    if (test__fixunsxfti(-0x1.FFFFFCp+62, 0))
+        return 1;
+
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixunsxfti(-0x1.FFFFFFFFFFFFFp+62, 0))
+        return 1;
+    if (test__fixunsxfti(-0x1.FFFFFFFFFFFFEp+62, 0))
+        return 1;
+
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFFFEp+63L, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunsxfti(0x1.0000000000000002p+63L, 0x8000000000000001LL))
+        return 1;
+    if (test__fixunsxfti(0x1.0000000000000000p+63L, 0x8000000000000000LL))
+        return 1;
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFFFCp+62L, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFFF8p+62L, 0x7FFFFFFFFFFFFFFELL))
+        return 1;
+
+    if (test__fixunsxfti(-0x1.0000000000000000p+63L, 0))
+        return 1;
+    if (test__fixunsxfti(-0x1.FFFFFFFFFFFFFFFCp+62L, 0))
+        return 1;
+    if (test__fixunsxfti(-0x1.FFFFFFFFFFFFFFF8p+62L, 0))
+        return 1;
+
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFFFEp+127L, make_ti(0xFFFFFFFFFFFFFFFFLL, 0)))
+        return 1;
+    if (test__fixunsxfti(0x1.0000000000000002p+127L, make_ti(0x8000000000000001LL, 0)))
+        return 1;
+    if (test__fixunsxfti(0x1.0000000000000000p+127L, make_ti(0x8000000000000000LL, 0)))
+        return 1;
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFFFCp+126L, make_ti(0x7FFFFFFFFFFFFFFFLL, 0)))
+        return 1;
+    if (test__fixunsxfti(0x1.FFFFFFFFFFFFFFF8p+126L, make_ti(0x7FFFFFFFFFFFFFFELL, 0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixxfdi_test.c b/compiler-rt/test/builtins/Unit/fixxfdi_test.c
new file mode 100644
index 0000000..0a90a56
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixxfdi_test.c
@@ -0,0 +1,115 @@
+//===-- fixxfdi_test.c - Test __fixxfdi -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixxfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+
+#if HAS_80_BIT_LONG_DOUBLE
+// Returns: convert a to a signed long long, rounding toward zero.
+
+// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+//             su_int is a 32 bit integral type
+//             value in long double is representable in di_int (no range checking performed)
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI di_int __sfixxfdi(long double a);
+
+int test__fixxfdi(long double a, di_int expected)
+{
+    di_int x = __fixxfdi(a);
+    if (x != expected)
+        printf("error in __fixxfdi(%LA) = %llX, expected %llX\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+#endif
+
+int main()
+{
+#if HAS_80_BIT_LONG_DOUBLE
+    if (test__fixxfdi(0.0, 0))
+        return 1;
+
+    if (test__fixxfdi(0.5, 0))
+        return 1;
+    if (test__fixxfdi(0.99, 0))
+        return 1;
+    if (test__fixxfdi(1.0, 1))
+        return 1;
+    if (test__fixxfdi(1.5, 1))
+        return 1;
+    if (test__fixxfdi(1.99, 1))
+        return 1;
+    if (test__fixxfdi(2.0, 2))
+        return 1;
+    if (test__fixxfdi(2.01, 2))
+        return 1;
+    if (test__fixxfdi(-0.5, 0))
+        return 1;
+    if (test__fixxfdi(-0.99, 0))
+        return 1;
+    if (test__fixxfdi(-1.0, -1))
+        return 1;
+    if (test__fixxfdi(-1.5, -1))
+        return 1;
+    if (test__fixxfdi(-1.99, -1))
+        return 1;
+    if (test__fixxfdi(-2.0, -2))
+        return 1;
+    if (test__fixxfdi(-2.01, -2))
+        return 1;
+
+    if (test__fixxfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixxfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixxfdi(-0x1.FFFFFEp+62, 0x8000008000000000LL))
+        return 1;
+    if (test__fixxfdi(-0x1.FFFFFCp+62, 0x8000010000000000LL))
+        return 1;
+
+    if (test__fixxfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixxfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixxfdi(-0x1.FFFFFFFFFFFFFp+62, 0x8000000000000400LL))
+        return 1;
+    if (test__fixxfdi(-0x1.FFFFFFFFFFFFEp+62, 0x8000000000000800LL))
+        return 1;
+
+    if (test__fixxfdi(0x1.FFFFFFFFFFFFFFFCp+62L, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixxfdi(0x1.FFFFFFFFFFFFFFF8p+62L, 0x7FFFFFFFFFFFFFFELL))
+        return 1;
+
+    if (test__fixxfdi(-0x1.0000000000000000p+63L, 0x8000000000000000LL))
+        return 1;
+    if (test__fixxfdi(-0x1.FFFFFFFFFFFFFFFCp+62L, 0x8000000000000001LL))
+        return 1;
+    if (test__fixxfdi(-0x1.FFFFFFFFFFFFFFF8p+62L, 0x8000000000000002LL))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fixxfti_test.c b/compiler-rt/test/builtins/Unit/fixxfti_test.c
new file mode 100644
index 0000000..b8573cc
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fixxfti_test.c
@@ -0,0 +1,146 @@
+//===-- fixxfti_test.c - Test __fixxfti -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixxfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a signed long long, rounding toward zero.
+
+// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
+//             su_int is a 32 bit integral type
+//             value in long double is representable in ti_int (no range checking performed)
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI ti_int __fixxfti(long double a);
+
+int test__fixxfti(long double a, ti_int expected)
+{
+    ti_int x = __fixxfti(a);
+    if (x != expected)
+    {
+        utwords xt;
+        xt.all = x;
+        utwords expectedt;
+        expectedt.all = expected;
+        printf("error in __fixxfti(%LA) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__fixxfti(0.0, 0))
+        return 1;
+
+    if (test__fixxfti(0.5, 0))
+        return 1;
+    if (test__fixxfti(0.99, 0))
+        return 1;
+    if (test__fixxfti(1.0, 1))
+        return 1;
+    if (test__fixxfti(1.5, 1))
+        return 1;
+    if (test__fixxfti(1.99, 1))
+        return 1;
+    if (test__fixxfti(2.0, 2))
+        return 1;
+    if (test__fixxfti(2.01, 2))
+        return 1;
+    if (test__fixxfti(-0.5, 0))
+        return 1;
+    if (test__fixxfti(-0.99, 0))
+        return 1;
+    if (test__fixxfti(-1.0, -1))
+        return 1;
+    if (test__fixxfti(-1.5, -1))
+        return 1;
+    if (test__fixxfti(-1.99, -1))
+        return 1;
+    if (test__fixxfti(-2.0, -2))
+        return 1;
+    if (test__fixxfti(-2.01, -2))
+        return 1;
+
+    if (test__fixxfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000LL))
+        return 1;
+    if (test__fixxfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000LL))
+        return 1;
+
+    if (test__fixxfti(-0x1.FFFFFEp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                               0x8000008000000000LL)))
+        return 1;
+    if (test__fixxfti(-0x1.FFFFFCp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                               0x8000010000000000LL)))
+        return 1;
+
+    if (test__fixxfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
+        return 1;
+    if (test__fixxfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
+        return 1;
+
+    if (test__fixxfti(-0x1.FFFFFFFFFFFFFp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                      0x8000000000000400LL)))
+        return 1;
+    if (test__fixxfti(-0x1.FFFFFFFFFFFFEp+62, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                      0x8000000000000800LL)))
+        return 1;
+
+    if (test__fixxfti(0x1.FFFFFFFFFFFFFFFCp+62L, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__fixxfti(0x1.FFFFFFFFFFFFFFF8p+62L, 0x7FFFFFFFFFFFFFFELL))
+        return 1;
+
+    if (test__fixxfti(-0x1.0000000000000000p+63L, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                          0x8000000000000000LL)))
+        return 1;
+    if (test__fixxfti(-0x1.FFFFFFFFFFFFFFFCp+62L, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                          0x8000000000000001LL)))
+        return 1;
+    if (test__fixxfti(-0x1.FFFFFFFFFFFFFFF8p+62L, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                          0x8000000000000002LL)))
+        return 1;
+
+    if (test__fixxfti(0x1.FFFFFFFFFFFFFFFEp+126L, make_ti(0x7FFFFFFFFFFFFFFFLL,
+                                                          0x8000000000000000LL)))
+        return 1;
+    if (test__fixxfti(0x1.FFFFFFFFFFFFFFFCp+126L, make_ti(0x7FFFFFFFFFFFFFFFLL,
+                                                          0x0000000000000000LL)))
+
+        return 1;
+
+    if (test__fixxfti(-0x1.0000000000000000p+127L, make_ti(0x8000000000000000LL,
+                                                           0x0000000000000000LL)))
+        return 1;
+    if (test__fixxfti(-0x1.FFFFFFFFFFFFFFFEp+126L, make_ti(0x8000000000000000LL,
+                                                           0x8000000000000000LL)))
+        return 1;
+    if (test__fixxfti(-0x1.FFFFFFFFFFFFFFFCp+126L, make_ti(0x8000000000000001LL,
+                                                           0x0000000000000000LL)))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatdidf_test.c b/compiler-rt/test/builtins/Unit/floatdidf_test.c
new file mode 100644
index 0000000..9bf2be9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatdidf_test.c
@@ -0,0 +1,137 @@
+//===-- floatdidf.c - Test __floatdidf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatdidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+// Returns: convert a to a double, rounding toward even.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             di_int is a 64 bit integral type
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI double __floatdidf(di_int a);
+
+int test__floatdidf(di_int a, double expected)
+{
+    double x = __floatdidf(a);
+    if (x != expected)
+        printf("error in __floatdidf(%llX) = %a, expected %a\n", a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(di_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+int main()
+{
+    if (test__floatdidf(0, 0.0))
+        return 1;
+
+    if (test__floatdidf(1, 1.0))
+        return 1;
+    if (test__floatdidf(2, 2.0))
+        return 1;
+    if (test__floatdidf(20, 20.0))
+        return 1;
+    if (test__floatdidf(-1, -1.0))
+        return 1;
+    if (test__floatdidf(-2, -2.0))
+        return 1;
+    if (test__floatdidf(-20, -20.0))
+        return 1;
+
+    if (test__floatdidf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatdidf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatdidf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatdidf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floatdidf(0x8000008000000000LL, -0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatdidf(0x8000000000000800LL, -0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatdidf(0x8000010000000000LL, -0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatdidf(0x8000000000001000LL, -0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floatdidf(0x8000000000000000LL, -0x1.000000p+63))
+        return 1;
+    if (test__floatdidf(0x8000000000000001LL, -0x1.000000p+63))
+        return 1;
+
+    if (test__floatdidf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatdidf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatdidf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatdidf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatdidf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496Dp+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatdidf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatdisf_test.c b/compiler-rt/test/builtins/Unit/floatdisf_test.c
new file mode 100644
index 0000000..a55c6a9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatdisf_test.c
@@ -0,0 +1,95 @@
+//===-- floatdisf_test.c - Test __floatdisf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatdisf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+// Returns: convert a to a float, rounding toward even.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             di_int is a 64 bit integral type
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI float __floatdisf(di_int a);
+
+int test__floatdisf(di_int a, float expected)
+{
+    float x = __floatdisf(a);
+    if (x != expected)
+        printf("error in __floatdisf(%llX) = %a, expected %a\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(di_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__floatdisf(0, 0.0F))
+        return 1;
+
+    if (test__floatdisf(1, 1.0F))
+        return 1;
+    if (test__floatdisf(2, 2.0F))
+        return 1;
+    if (test__floatdisf(-1, -1.0F))
+        return 1;
+    if (test__floatdisf(-2, -2.0F))
+        return 1;
+
+    if (test__floatdisf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62F))
+        return 1;
+    if (test__floatdisf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62F))
+        return 1;
+
+    if (test__floatdisf(0x8000008000000000LL, -0x1.FFFFFEp+62F))
+        return 1;
+    if (test__floatdisf(0x8000010000000000LL, -0x1.FFFFFCp+62F))
+        return 1;
+
+    if (test__floatdisf(0x8000000000000000LL, -0x1.000000p+63F))
+        return 1;
+    if (test__floatdisf(0x8000000000000001LL, -0x1.000000p+63F))
+        return 1;
+
+    if (test__floatdisf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatdisf(0x0007FB72EA000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72EB000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72EC000000LL, 0x1.FEDCBCp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72E8000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatdisf(0x0007FB72E6000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72E7000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72E7FFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72E4000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatdisf(0x0007FB72E4000000LL, 0x1.FEDCB8p+50F))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatditf_test.c b/compiler-rt/test/builtins/Unit/floatditf_test.c
new file mode 100644
index 0000000..8cf8a08
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatditf_test.c
@@ -0,0 +1,69 @@
+//===-- floatditf_test.c - Test __floatditf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatditf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: long integer converted to long double
+
+COMPILER_RT_ABI long double __floatditf(long long a);
+
+int test__floatditf(long long a, uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __floatditf(a);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret)
+        printf("error in __floatditf(%Ld) = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__floatditf(0x7fffffffffffffff, UINT64_C(0x403dffffffffffff), UINT64_C(0xfffc000000000000)))
+        return 1;
+    if (test__floatditf(0x123456789abcdef1, UINT64_C(0x403b23456789abcd), UINT64_C(0xef10000000000000)))
+        return 1;
+    if (test__floatditf(0x2, UINT64_C(0x4000000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatditf(0x1, UINT64_C(0x3fff000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatditf(0x0, UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+    if (test__floatditf(0xffffffffffffffff, UINT64_C(0xbfff000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatditf(0xfffffffffffffffe, UINT64_C(0xc000000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatditf(-0x123456789abcdef1, UINT64_C(0xc03b23456789abcd), UINT64_C(0xef10000000000000)))
+        return 1;
+    if (test__floatditf(0x8000000000000000, UINT64_C(0xc03e000000000000), UINT64_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatdixf_test.c b/compiler-rt/test/builtins/Unit/floatdixf_test.c
new file mode 100644
index 0000000..f6ab5a4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatdixf_test.c
@@ -0,0 +1,144 @@
+//===-- floatdixf_test.c - Test __floatdixf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatdixf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if HAS_80_BIT_LONG_DOUBLE
+// Returns: convert a to a long double, rounding toward even.
+
+// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+//             di_int is a 64 bit integral type
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+long COMPILER_RT_ABI double __floatdixf(di_int a);
+
+int test__floatdixf(di_int a, long double expected)
+{
+    long double x = __floatdixf(a);
+    if (x != expected)
+        printf("error in __floatdixf(%llX) = %LA, expected %LA\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(di_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+#endif
+
+int main()
+{
+#if HAS_80_BIT_LONG_DOUBLE
+    if (test__floatdixf(0, 0.0))
+        return 1;
+
+    if (test__floatdixf(1, 1.0))
+        return 1;
+    if (test__floatdixf(2, 2.0))
+        return 1;
+    if (test__floatdixf(20, 20.0))
+        return 1;
+    if (test__floatdixf(-1, -1.0))
+        return 1;
+    if (test__floatdixf(-2, -2.0))
+        return 1;
+    if (test__floatdixf(-20, -20.0))
+        return 1;
+
+    if (test__floatdixf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatdixf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatdixf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatdixf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floatdixf(0x8000008000000000LL, -0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatdixf(0x8000000000000800LL, -0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatdixf(0x8000010000000000LL, -0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatdixf(0x8000000000001000LL, -0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floatdixf(0x8000000000000000LL, -0x1.000000p+63))
+        return 1;
+    if (test__floatdixf(0x8000000000000001LL, -0x1.FFFFFFFFFFFFFFFCp+62L))
+        return 1;
+
+    if (test__floatdixf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatdixf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatdixf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatdixf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatdixf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DA1LL, 0x8.D1E7F43824B684p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DB0LL, 0x8.D1E7f43824B6Cp+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DB8LL, 0x8.D1E7F43824B6Ep+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DB6LL, 0x8.D1E7F43824B6D8p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DBFLL, 0x8.D1E7F43824B6FCp+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DC1LL, 0x8.D1E7F43824B704p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DC7LL, 0x8.D1E7F43824B71Cp+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DC8LL, 0x8.D1E7F43824B72p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DCFLL, 0x8.D1E7F43824B73Cp+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DD0LL, 0x8.D1E7F43824B74p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DD1LL, 0x8.D1E7F43824B744p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DD8LL, 0x8.D1E7F43824B76p+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DDFLL, 0x8.D1E7F43824B77Cp+54L))
+        return 1;
+    if (test__floatdixf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatsidfvfp_test.c b/compiler-rt/test/builtins/Unit/floatsidfvfp_test.c
new file mode 100644
index 0000000..e5ea3a4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatsidfvfp_test.c
@@ -0,0 +1,51 @@
+//===-- floatsidfvfp_test.c - Test __floatsidfvfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatsidfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI double __floatsidfvfp(int a);
+
+#if __arm__
+int test__floatsidfvfp(int a)
+{
+    double actual = __floatsidfvfp(a);
+    double expected = a;
+    if (actual != expected)
+        printf("error in test__ floatsidfvfp(%d) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__floatsidfvfp(0))
+        return 1;
+    if (test__floatsidfvfp(1))
+        return 1;
+    if (test__floatsidfvfp(-1))
+        return 1;
+    if (test__floatsidfvfp(0x7FFFFFFF))
+        return 1;
+    if (test__floatsidfvfp(0x80000000))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatsisfvfp_test.c b/compiler-rt/test/builtins/Unit/floatsisfvfp_test.c
new file mode 100644
index 0000000..ab21e2e
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatsisfvfp_test.c
@@ -0,0 +1,51 @@
+//===-- floatsisfvfp_test.c - Test __floatsisfvfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatsisfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __floatsisfvfp(int a);
+
+#if __arm__
+int test__floatsisfvfp(int a)
+{
+    float actual = __floatsisfvfp(a);
+    float expected = a;
+    if (actual != expected)
+        printf("error in test__floatsisfvfp(%d) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__floatsisfvfp(0))
+        return 1;
+    if (test__floatsisfvfp(1))
+        return 1;
+    if (test__floatsisfvfp(-1))
+        return 1;
+    if (test__floatsisfvfp(0x7FFFFFFF))
+        return 1;
+    if (test__floatsisfvfp(0x80000000))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatsitf_test.c b/compiler-rt/test/builtins/Unit/floatsitf_test.c
new file mode 100644
index 0000000..6f98721
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatsitf_test.c
@@ -0,0 +1,61 @@
+//===--------------- floatsitf_test.c - Test __floatsitf ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatsitf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+long COMPILER_RT_ABI double __floatsitf(int a);
+
+int test__floatsitf(int a, uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __floatsitf(a);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret)
+    {
+        printf("error in test__floatsitf(%d) = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__floatsitf(0x80000000, UINT64_C(0xc01e000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatsitf(0x7fffffff, UINT64_C(0x401dfffffffc0000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatsitf(0, UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+    if (test__floatsitf(0xffffffff, UINT64_C(0xbfff000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatsitf(0x12345678, UINT64_C(0x401b234567800000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatsitf(-0x12345678, UINT64_C(0xc01b234567800000), UINT64_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floattidf_test.c b/compiler-rt/test/builtins/Unit/floattidf_test.c
new file mode 100644
index 0000000..3af382a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floattidf_test.c
@@ -0,0 +1,180 @@
+//===-- floattidf.c - Test __floattidf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a double, rounding toward even.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             ti_int is a 64 bit integral type
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI double __floattidf(ti_int a);
+
+int test__floattidf(ti_int a, double expected)
+{
+    double x = __floattidf(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __floattidf(0x%.16llX%.16llX) = %a, expected %a\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__floattidf(0, 0.0))
+        return 1;
+
+    if (test__floattidf(1, 1.0))
+        return 1;
+    if (test__floattidf(2, 2.0))
+        return 1;
+    if (test__floattidf(20, 20.0))
+        return 1;
+    if (test__floattidf(-1, -1.0))
+        return 1;
+    if (test__floattidf(-2, -2.0))
+        return 1;
+    if (test__floattidf(-20, -20.0))
+        return 1;
+
+    if (test__floattidf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floattidf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floattidf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floattidf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floattidf(make_ti(0x8000008000000000LL, 0), -0x1.FFFFFEp+126))
+        return 1;
+    if (test__floattidf(make_ti(0x8000000000000800LL, 0), -0x1.FFFFFFFFFFFFEp+126))
+        return 1;
+    if (test__floattidf(make_ti(0x8000010000000000LL, 0), -0x1.FFFFFCp+126))
+        return 1;
+    if (test__floattidf(make_ti(0x8000000000001000LL, 0), -0x1.FFFFFFFFFFFFCp+126))
+        return 1;
+
+    if (test__floattidf(make_ti(0x8000000000000000LL, 0), -0x1.000000p+127))
+        return 1;
+    if (test__floattidf(make_ti(0x8000000000000001LL, 0), -0x1.000000p+127))
+        return 1;
+
+    if (test__floattidf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floattidf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floattidf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floattidf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floattidf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floattidf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floattidf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floattidf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floattidf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floattidf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floattidf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floattidf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496Dp+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floattidf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+    if (test__floattidf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496Dp+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496Fp+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496Fp+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496Fp+121))
+        return 1;
+    if (test__floattidf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floattisf_test.c b/compiler-rt/test/builtins/Unit/floattisf_test.c
new file mode 100644
index 0000000..0f5dc54
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floattisf_test.c
@@ -0,0 +1,136 @@
+//===-- floattisf_test.c - Test __floattisf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattisf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a float, rounding toward even.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             ti_int is a 64 bit integral type
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI float __floattisf(ti_int a);
+
+int test__floattisf(ti_int a, float expected)
+{
+    float x = __floattisf(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __floattisf(0x%.16llX%.16llX) = %a, expected %a\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__floattisf(0, 0.0F))
+        return 1;
+
+    if (test__floattisf(1, 1.0F))
+        return 1;
+    if (test__floattisf(2, 2.0F))
+        return 1;
+    if (test__floattisf(-1, -1.0F))
+        return 1;
+    if (test__floattisf(-2, -2.0F))
+        return 1;
+
+    if (test__floattisf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62F))
+        return 1;
+    if (test__floattisf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62F))
+        return 1;
+
+    if (test__floattisf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000008000000000LL),
+                        -0x1.FFFFFEp+62F))
+        return 1;
+    if (test__floattisf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000010000000000LL),
+                        -0x1.FFFFFCp+62F))
+        return 1;
+
+    if (test__floattisf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000000000000000LL),
+                        -0x1.000000p+63F))
+        return 1;
+    if (test__floattisf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000000000000001LL),
+                        -0x1.000000p+63F))
+        return 1;
+
+    if (test__floattisf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floattisf(0x0007FB72EA000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72EB000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72EC000000LL, 0x1.FEDCBCp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72E8000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floattisf(0x0007FB72E6000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72E7000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72E7FFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72E4000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floattisf(0x0007FB72E4000000LL, 0x1.FEDCB8p+50F))
+        return 1;
+
+    if (test__floattisf(make_ti(0x0007FB72E8000000LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+
+    if (test__floattisf(make_ti(0x0007FB72EA000000LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72EB000000LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72EBFFFFFFLL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72EC000000LL, 0), 0x1.FEDCBCp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72E8000001LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+
+    if (test__floattisf(make_ti(0x0007FB72E6000000LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72E7000000LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72E7FFFFFFLL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72E4000001LL, 0), 0x1.FEDCBAp+114F))
+        return 1;
+    if (test__floattisf(make_ti(0x0007FB72E4000000LL, 0), 0x1.FEDCB8p+114F))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floattixf_test.c b/compiler-rt/test/builtins/Unit/floattixf_test.c
new file mode 100644
index 0000000..d281deb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floattixf_test.c
@@ -0,0 +1,212 @@
+//===-- floattixf.c - Test __floattixf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattixf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a long double, rounding toward even.
+
+// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+//             ti_int is a 128 bit integral type
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI long double __floattixf(ti_int a);
+
+int test__floattixf(ti_int a, long double expected)
+{
+    long double x = __floattixf(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __floattixf(0x%.16llX%.16llX) = %LA, expected %LA\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__floattixf(0, 0.0))
+        return 1;
+
+    if (test__floattixf(1, 1.0))
+        return 1;
+    if (test__floattixf(2, 2.0))
+        return 1;
+    if (test__floattixf(20, 20.0))
+        return 1;
+    if (test__floattixf(-1, -1.0))
+        return 1;
+    if (test__floattixf(-2, -2.0))
+        return 1;
+    if (test__floattixf(-20, -20.0))
+        return 1;
+
+    if (test__floattixf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floattixf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floattixf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floattixf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floattixf(make_ti(0x8000008000000000LL, 0), -0x1.FFFFFEp+126))
+        return 1;
+    if (test__floattixf(make_ti(0x8000000000000800LL, 0), -0x1.FFFFFFFFFFFFEp+126))
+        return 1;
+    if (test__floattixf(make_ti(0x8000010000000000LL, 0), -0x1.FFFFFCp+126))
+        return 1;
+    if (test__floattixf(make_ti(0x8000000000001000LL, 0), -0x1.FFFFFFFFFFFFCp+126))
+        return 1;
+
+    if (test__floattixf(make_ti(0x8000000000000000LL, 0), -0x1.000000p+127))
+        return 1;
+    if (test__floattixf(make_ti(0x8000000000000001LL, 0), -0x1.FFFFFFFFFFFFFFFCp+126L))
+        return 1;
+
+    if (test__floattixf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floattixf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floattixf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floattixf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floattixf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floattixf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floattixf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floattixf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floattixf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floattixf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floattixf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floattixf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496D08p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496D8p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496DCp+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496DBp+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496DF8p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496E08p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496E38p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496E4p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496E78p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496E8p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496E88p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496ECp+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496EF8p+57L))
+        return 1;
+    if (test__floattixf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+    if (test__floattixf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496D08p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496D8p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496DCp+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496DBp+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496DF8p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496E08p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496E38p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496E4p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496E78p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496E8p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496E88p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496ECp+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496EF8p+121L))
+        return 1;
+    if (test__floattixf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121L))
+        return 1;
+
+    if (test__floattixf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL), 0x1.FFFFFFFFFFFFFFFEp+63L))
+        return 1;
+
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x3456100000000001LL),
+                        0x1.2345678901234562p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x3456200000000000LL),
+                        0x1.2345678901234562p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x34562FFFFFFFFFFFLL),
+                        0x1.2345678901234562p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x3456300000000000LL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x3456400000000000LL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x34564FFFFFFFFFFFLL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x3456500000000000LL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x3456500000000001LL),
+                        0x1.2345678901234566p+108L))
+        return 1;
+    if (test__floattixf(make_ti(0x0000123456789012LL, 0x34566FFFFFFFFFFFLL),
+                        0x1.2345678901234566p+108L))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatundidf_test.c b/compiler-rt/test/builtins/Unit/floatundidf_test.c
new file mode 100644
index 0000000..97fb1e5
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatundidf_test.c
@@ -0,0 +1,132 @@
+//===-- floatundidf_test.c - Test __floatundidf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatundidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+// Returns: convert a to a double, rounding toward even.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             du_int is a 64 bit integral type
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI double __floatundidf(du_int a);
+
+int test__floatundidf(di_int a, double expected)
+{
+    double x = __floatundidf(a);
+    if (x != expected)
+        printf("error in __floatundidf(%llX) = %a, expected %a\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(di_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+int main()
+{
+    if (test__floatundidf(0, 0.0))
+        return 1;
+
+    if (test__floatundidf(1, 1.0))
+        return 1;
+    if (test__floatundidf(2, 2.0))
+        return 1;
+    if (test__floatundidf(20, 20.0))
+        return 1;
+
+    if (test__floatundidf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatundidf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatundidf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatundidf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floatundidf(0x8000008000000000LL, 0x1.000001p+63))
+        return 1;
+    if (test__floatundidf(0x8000000000000800LL, 0x1.0000000000001p+63))
+        return 1;
+    if (test__floatundidf(0x8000010000000000LL, 0x1.000002p+63))
+        return 1;
+    if (test__floatundidf(0x8000000000001000LL, 0x1.0000000000002p+63))
+        return 1;
+
+    if (test__floatundidf(0x8000000000000000LL, 0x1p+63))
+        return 1;
+    if (test__floatundidf(0x8000000000000001LL, 0x1p+63))
+        return 1;
+
+    if (test__floatundidf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatundidf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatundidf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatundidf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatundidf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496Dp+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatundidf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatundisf_test.c b/compiler-rt/test/builtins/Unit/floatundisf_test.c
new file mode 100644
index 0000000..40b6bcc
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatundisf_test.c
@@ -0,0 +1,96 @@
+//===-- floatundisf_test.c - Test __floatundisf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatundisf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+// Returns: convert a to a float, rounding toward even.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             du_int is a 64 bit integral type
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI float __floatundisf(du_int a);
+
+int test__floatundisf(du_int a, float expected)
+{
+    float x = __floatundisf(a);
+    if (x != expected)
+        printf("error in __floatundisf(%llX) = %a, expected %a\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(du_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(du_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__floatundisf(0, 0.0F))
+        return 1;
+
+    if (test__floatundisf(1, 1.0F))
+        return 1;
+    if (test__floatundisf(2, 2.0F))
+        return 1;
+
+    if (test__floatundisf(0x7FFFFF8000000000ULL, 0x1.FFFFFEp+62F))
+        return 1;
+    if (test__floatundisf(0x7FFFFF0000000000ULL, 0x1.FFFFFCp+62F))
+        return 1;
+
+    if (test__floatundisf(0x8000008000000000ULL, 0x1p+63F))
+        return 1;
+    if (test__floatundisf(0x8000010000000000LL, 0x1.000002p+63F))
+        return 1;
+
+    if (test__floatundisf(0x8000000000000000LL, 0x1p+63F))
+        return 1;
+    if (test__floatundisf(0x8000000000000001LL, 0x1p+63F))
+        return 1;
+
+    if (test__floatundisf(0xFFFFFFFFFFFFFFFELL, 0x1p+64F))
+        return 1;
+    if (test__floatundisf(0xFFFFFFFFFFFFFFFFLL, 0x1p+64F))
+        return 1;
+
+    if (test__floatundisf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatundisf(0x0007FB72EA000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72EB000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72EC000000LL, 0x1.FEDCBCp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72E8000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatundisf(0x0007FB72E6000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72E7000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72E7FFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72E4000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatundisf(0x0007FB72E4000000LL, 0x1.FEDCB8p+50F))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatunditf_test.c b/compiler-rt/test/builtins/Unit/floatunditf_test.c
new file mode 100644
index 0000000..b66a174
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatunditf_test.c
@@ -0,0 +1,67 @@
+//===-- floatunditf_test.c - Test __floatunditf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatunditf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: long integer converted to long double
+
+COMPILER_RT_ABI long double __floatunditf(unsigned long long a);
+
+int test__floatunditf(unsigned long long a, uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __floatunditf(a);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret)
+        printf("error in __floatunditf(%Lu) = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__floatunditf(0xffffffffffffffffULL, UINT64_C(0x403effffffffffff), UINT64_C(0xfffe000000000000)))
+        return 1;
+    if (test__floatunditf(0xfffffffffffffffeULL, UINT64_C(0x403effffffffffff), UINT64_C(0xfffc000000000000)))
+        return 1;
+    if (test__floatunditf(0x8000000000000000ULL, UINT64_C(0x403e000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatunditf(0x7fffffffffffffffULL, UINT64_C(0x403dffffffffffff), UINT64_C(0xfffc000000000000)))
+        return 1;
+    if (test__floatunditf(0x123456789abcdef1ULL, UINT64_C(0x403b23456789abcd), UINT64_C(0xef10000000000000)))
+        return 1;
+    if (test__floatunditf(0x2ULL, UINT64_C(0x4000000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatunditf(0x1ULL, UINT64_C(0x3fff000000000000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatunditf(0x0ULL, UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatundixf_test.c b/compiler-rt/test/builtins/Unit/floatundixf_test.c
new file mode 100644
index 0000000..690dce1
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatundixf_test.c
@@ -0,0 +1,145 @@
+//===-- floatundixf_test.c - Test __floatundixf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatundixf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+
+#if HAS_80_BIT_LONG_DOUBLE
+// Returns: convert a to a long double, rounding toward even.
+
+// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+//             du_int is a 64 bit integral type
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI long double __floatundixf(du_int a);
+
+int test__floatundixf(du_int a, long double expected)
+{
+    long double x = __floatundixf(a);
+    if (x != expected)
+        printf("error in __floatundixf(%llX) = %LA, expected %LA\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(du_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(du_int)*CHAR_BIT == 64] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+#endif
+
+int main()
+{
+#if HAS_80_BIT_LONG_DOUBLE
+    if (test__floatundixf(0, 0.0))
+        return 1;
+
+    if (test__floatundixf(1, 1.0))
+        return 1;
+    if (test__floatundixf(2, 2.0))
+        return 1;
+    if (test__floatundixf(20, 20.0))
+        return 1;
+
+    if (test__floatundixf(0x7FFFFF8000000000ULL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatundixf(0x7FFFFFFFFFFFF800ULL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatundixf(0x7FFFFF0000000000ULL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatundixf(0x7FFFFFFFFFFFF000ULL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+    if (test__floatundixf(0x7FFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFEp+59L))
+        return 1;
+    if (test__floatundixf(0xFFFFFFFFFFFFFFFEULL, 0xF.FFFFFFFFFFFFFFEp+60L))
+        return 1;
+    if (test__floatundixf(0xFFFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFFp+60L))
+        return 1;
+
+    if (test__floatundixf(0x8000008000000000ULL, 0x8.000008p+60))
+        return 1;
+    if (test__floatundixf(0x8000000000000800ULL, 0x8.0000000000008p+60))
+        return 1;
+    if (test__floatundixf(0x8000010000000000ULL, 0x8.00001p+60))
+        return 1;
+    if (test__floatundixf(0x8000000000001000ULL, 0x8.000000000001p+60))
+        return 1;
+
+    if (test__floatundixf(0x8000000000000000ULL, 0x8p+60))
+        return 1;
+    if (test__floatundixf(0x8000000000000001ULL, 0x8.000000000000001p+60L))
+        return 1;
+
+    if (test__floatundixf(0x0007FB72E8000000ULL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatundixf(0x0007FB72EA000000ULL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72EB000000ULL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72EBFFFFFFULL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72EC000000ULL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72E8000001ULL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatundixf(0x0007FB72E6000000ULL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72E7000000ULL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72E7FFFFFFULL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72E4000001ULL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatundixf(0x0007FB72E4000000ULL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatundixf(0x023479FD0E092DC0ULL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DA1ULL, 0x8.D1E7F43824B684p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DB0ULL, 0x8.D1E7f43824B6Cp+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DB8ULL, 0x8.D1E7F43824B6Ep+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DB6ULL, 0x8.D1E7F43824B6D8p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DBFULL, 0x8.D1E7F43824B6FCp+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DC1ULL, 0x8.D1E7F43824B704p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DC7ULL, 0x8.D1E7F43824B71Cp+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DC8ULL, 0x8.D1E7F43824B72p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DCFULL, 0x8.D1E7F43824B73Cp+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DD0ULL, 0x8.D1E7F43824B74p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DD1ULL, 0x8.D1E7F43824B744p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DD8ULL, 0x8.D1E7F43824B76p+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DDFULL, 0x8.D1E7F43824B77Cp+54L))
+        return 1;
+    if (test__floatundixf(0x023479FD0E092DE0ULL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatunsitf_test.c b/compiler-rt/test/builtins/Unit/floatunsitf_test.c
new file mode 100644
index 0000000..c3d3fe9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatunsitf_test.c
@@ -0,0 +1,56 @@
+//===--------------- floatunsitf_test.c - Test __floatunsitf --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatunsitf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI long double __floatunsitf(unsigned int a);
+
+int test__floatunsitf(unsigned int a, uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __floatunsitf(a);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__floatunsitf(%u) = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__floatunsitf(0x7fffffff, UINT64_C(0x401dfffffffc0000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatunsitf(0, UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+    if (test__floatunsitf(0xffffffff, UINT64_C(0x401efffffffe0000), UINT64_C(0x0)))
+        return 1;
+    if (test__floatunsitf(0x12345678, UINT64_C(0x401b234567800000), UINT64_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatunssidfvfp_test.c b/compiler-rt/test/builtins/Unit/floatunssidfvfp_test.c
new file mode 100644
index 0000000..75e4bbd
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatunssidfvfp_test.c
@@ -0,0 +1,51 @@
+//===-- floatunssidfvfp_test.c - Test __floatunssidfvfp -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatunssidfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI double __floatunssidfvfp(unsigned int a);
+
+#if __arm__
+int test__floatunssidfvfp(unsigned int a)
+{
+    double actual = __floatunssidfvfp(a);
+    double expected = a;
+    if (actual != expected)
+        printf("error in test__floatunssidfvfp(%u) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__floatunssidfvfp(0))
+        return 1;
+    if (test__floatunssidfvfp(1))
+        return 1;
+    if (test__floatunssidfvfp(0x7FFFFFFF))
+        return 1;
+    if (test__floatunssidfvfp(0x80000000))
+        return 1;
+    if (test__floatunssidfvfp(0xFFFFFFFF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatunssisfvfp_test.c b/compiler-rt/test/builtins/Unit/floatunssisfvfp_test.c
new file mode 100644
index 0000000..47f837c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatunssisfvfp_test.c
@@ -0,0 +1,50 @@
+//===-- floatunssisfvfp_test.c - Test __floatunssisfvfp -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatunssisfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "int_lib.h"
+
+extern COMPILER_RT_ABI float __floatunssisfvfp(unsigned int a);
+
+#if __arm__
+int test__floatunssisfvfp(unsigned int a)
+{
+    float actual = __floatunssisfvfp(a);
+    float expected = a;
+    if (actual != expected)
+        printf("error in test__floatunssisfvfp(%u) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__floatunssisfvfp(0))
+        return 1;
+    if (test__floatunssisfvfp(1))
+        return 1;
+    if (test__floatunssisfvfp(0x7FFFFFFF))
+        return 1;
+    if (test__floatunssisfvfp(0x80000000))
+        return 1;
+    if (test__floatunssisfvfp(0xFFFFFFFF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatuntidf_test.c b/compiler-rt/test/builtins/Unit/floatuntidf_test.c
new file mode 100644
index 0000000..9855ff7
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatuntidf_test.c
@@ -0,0 +1,174 @@
+//===-- floatuntidf.c - Test __floatuntidf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a double, rounding toward even.
+
+// Assumption: double is a IEEE 64 bit floating point type 
+//             tu_int is a 64 bit integral type
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI double __floatuntidf(tu_int a);
+
+int test__floatuntidf(tu_int a, double expected)
+{
+    double x = __floatuntidf(a);
+    if (x != expected)
+    {
+        utwords at;
+        at.all = a;
+        printf("error in __floatuntidf(0x%.16llX%.16llX) = %a, expected %a\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(double)*CHAR_BIT == 64] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__floatuntidf(0, 0.0))
+        return 1;
+
+    if (test__floatuntidf(1, 1.0))
+        return 1;
+    if (test__floatuntidf(2, 2.0))
+        return 1;
+    if (test__floatuntidf(20, 20.0))
+        return 1;
+
+    if (test__floatuntidf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatuntidf(0x7FFFFFFFFFFFF800LL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatuntidf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatuntidf(0x7FFFFFFFFFFFF000LL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+
+    if (test__floatuntidf(make_ti(0x8000008000000000LL, 0), 0x1.000001p+127))
+        return 1;
+    if (test__floatuntidf(make_ti(0x8000000000000800LL, 0), 0x1.0000000000001p+127))
+        return 1;
+    if (test__floatuntidf(make_ti(0x8000010000000000LL, 0), 0x1.000002p+127))
+        return 1;
+    if (test__floatuntidf(make_ti(0x8000000000001000LL, 0), 0x1.0000000000002p+127))
+        return 1;
+
+    if (test__floatuntidf(make_ti(0x8000000000000000LL, 0), 0x1.000000p+127))
+        return 1;
+    if (test__floatuntidf(make_ti(0x8000000000000001LL, 0), 0x1.0000000000000002p+127))
+        return 1;
+
+    if (test__floatuntidf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatuntidf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatuntidf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatuntidf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatuntidf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496Dp+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+    if (test__floatuntidf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+    if (test__floatuntidf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496Dp+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496Ep+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496Fp+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496Fp+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496Fp+121))
+        return 1;
+    if (test__floatuntidf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatuntisf_test.c b/compiler-rt/test/builtins/Unit/floatuntisf_test.c
new file mode 100644
index 0000000..9b5ff79
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatuntisf_test.c
@@ -0,0 +1,165 @@
+//===-- floatuntisf.c - Test __floatuntisf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntisf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a float, rounding toward even.
+
+// Assumption: float is a IEEE 32 bit floating point type 
+//             tu_int is a 128 bit integral type
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI float __floatuntisf(tu_int a);
+
+int test__floatuntisf(tu_int a, float expected)
+{
+    float x = __floatuntisf(a);
+    if (x != expected)
+    {
+        utwords at;
+        at.all = a;
+        printf("error in __floatuntisf(0x%.16llX%.16llX) = %a, expected %a\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
+char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__floatuntisf(0, 0.0F))
+        return 1;
+
+    if (test__floatuntisf(1, 1.0F))
+        return 1;
+    if (test__floatuntisf(2, 2.0F))
+        return 1;
+    if (test__floatuntisf(20, 20.0F))
+        return 1;
+
+    if (test__floatuntisf(0x7FFFFF8000000000LL, 0x1.FFFFFEp+62F))
+        return 1;
+    if (test__floatuntisf(0x7FFFFF0000000000LL, 0x1.FFFFFCp+62F))
+        return 1;
+
+    if (test__floatuntisf(make_ti(0x8000008000000000LL, 0), 0x1.000001p+127F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x8000000000000800LL, 0), 0x1.0p+127F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x8000010000000000LL, 0), 0x1.000002p+127F))
+        return 1;
+
+    if (test__floatuntisf(make_ti(0x8000000000000000LL, 0), 0x1.000000p+127F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50F))
+        return 1;
+
+    if (test__floatuntisf(0xFFFFFFFFFFFFFFFELL, 0x1p+64F))
+        return 1;
+    if (test__floatuntisf(0xFFFFFFFFFFFFFFFFLL, 0x1p+64F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72EA000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72EB000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72EC000000LL, 0x1.FEDCBCp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E8000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+
+    if (test__floatuntisf(0x0007FB72E6000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E7000000LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E7FFFFFFLL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E4000001LL, 0x1.FEDCBAp+50F))
+        return 1;
+    if (test__floatuntisf(0x0007FB72E4000000LL, 0x1.FEDCB8p+50F))
+        return 1;
+
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCB90000000000001LL),
+                          0x1.FEDCBAp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBA0000000000000LL),
+                          0x1.FEDCBAp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBAFFFFFFFFFFFFFLL),
+                          0x1.FEDCBAp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBB0000000000000LL),
+                          0x1.FEDCBCp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBB0000000000001LL),
+                          0x1.FEDCBCp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBBFFFFFFFFFFFFFLL),
+                          0x1.FEDCBCp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBC0000000000000LL),
+                          0x1.FEDCBCp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBC0000000000001LL),
+                          0x1.FEDCBCp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBD0000000000000LL),
+                          0x1.FEDCBCp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBD0000000000001LL),
+                          0x1.FEDCBEp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBDFFFFFFFFFFFFFLL),
+                          0x1.FEDCBEp+76F))
+        return 1;
+    if (test__floatuntisf(make_ti(0x0000000000001FEDLL, 0xCBE0000000000000LL),
+                          0x1.FEDCBEp+76F))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/floatuntixf_test.c b/compiler-rt/test/builtins/Unit/floatuntixf_test.c
new file mode 100644
index 0000000..c58b55d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/floatuntixf_test.c
@@ -0,0 +1,219 @@
+//===-- floatuntixf.c - Test __floatuntixf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntixf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: convert a to a long double, rounding toward even.
+
+// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
+//             tu_int is a 128 bit integral type
+
+// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
+// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+COMPILER_RT_ABI long double __floatuntixf(tu_int a);
+
+int test__floatuntixf(tu_int a, long double expected)
+{
+    long double x = __floatuntixf(a);
+    if (x != expected)
+    {
+        utwords at;
+        at.all = a;
+        printf("error in __floatuntixf(0x%.16llX%.16llX) = %LA, expected %LA\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
+char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__floatuntixf(0, 0.0))
+        return 1;
+
+    if (test__floatuntixf(1, 1.0))
+        return 1;
+    if (test__floatuntixf(2, 2.0))
+        return 1;
+    if (test__floatuntixf(20, 20.0))
+        return 1;
+
+    if (test__floatuntixf(0x7FFFFF8000000000ULL, 0x1.FFFFFEp+62))
+        return 1;
+    if (test__floatuntixf(0x7FFFFFFFFFFFF800ULL, 0x1.FFFFFFFFFFFFEp+62))
+        return 1;
+    if (test__floatuntixf(0x7FFFFF0000000000ULL, 0x1.FFFFFCp+62))
+        return 1;
+    if (test__floatuntixf(0x7FFFFFFFFFFFF000ULL, 0x1.FFFFFFFFFFFFCp+62))
+        return 1;
+    if (test__floatuntixf(0x7FFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFEp+59L))
+        return 1;
+    if (test__floatuntixf(0xFFFFFFFFFFFFFFFEULL, 0xF.FFFFFFFFFFFFFFEp+60L))
+        return 1;
+    if (test__floatuntixf(0xFFFFFFFFFFFFFFFFULL, 0xF.FFFFFFFFFFFFFFFp+60L))
+        return 1;
+
+    if (test__floatuntixf(0x8000008000000000ULL, 0x8.000008p+60))
+        return 1;
+    if (test__floatuntixf(0x8000000000000800ULL, 0x8.0000000000008p+60))
+        return 1;
+    if (test__floatuntixf(0x8000010000000000ULL, 0x8.00001p+60))
+        return 1;
+    if (test__floatuntixf(0x8000000000001000ULL, 0x8.000000000001p+60))
+        return 1;
+
+    if (test__floatuntixf(0x8000000000000000ULL, 0x8p+60))
+        return 1;
+    if (test__floatuntixf(0x8000000000000001ULL, 0x8.000000000000001p+60L))
+        return 1;
+
+    if (test__floatuntixf(0x0007FB72E8000000LL, 0x1.FEDCBAp+50))
+        return 1;
+
+    if (test__floatuntixf(0x0007FB72EA000000LL, 0x1.FEDCBA8p+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72EB000000LL, 0x1.FEDCBACp+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72EBFFFFFFLL, 0x1.FEDCBAFFFFFFCp+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72EC000000LL, 0x1.FEDCBBp+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72E8000001LL, 0x1.FEDCBA0000004p+50))
+        return 1;
+
+    if (test__floatuntixf(0x0007FB72E6000000LL, 0x1.FEDCB98p+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72E7000000LL, 0x1.FEDCB9Cp+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72E7FFFFFFLL, 0x1.FEDCB9FFFFFFCp+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72E4000001LL, 0x1.FEDCB90000004p+50))
+        return 1;
+    if (test__floatuntixf(0x0007FB72E4000000LL, 0x1.FEDCB9p+50))
+        return 1;
+
+    if (test__floatuntixf(0x023479FD0E092DC0LL, 0x1.1A3CFE870496Ep+57))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DA1LL, 0x1.1A3CFE870496D08p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DB0LL, 0x1.1A3CFE870496D8p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DB8LL, 0x1.1A3CFE870496DCp+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DB6LL, 0x1.1A3CFE870496DBp+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DBFLL, 0x1.1A3CFE870496DF8p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DC1LL, 0x1.1A3CFE870496E08p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DC7LL, 0x1.1A3CFE870496E38p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DC8LL, 0x1.1A3CFE870496E4p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DCFLL, 0x1.1A3CFE870496E78p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DD0LL, 0x1.1A3CFE870496E8p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DD1LL, 0x1.1A3CFE870496E88p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DD8LL, 0x1.1A3CFE870496ECp+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DDFLL, 0x1.1A3CFE870496EF8p+57L))
+        return 1;
+    if (test__floatuntixf(0x023479FD0E092DE0LL, 0x1.1A3CFE870496Fp+57))
+        return 1;
+
+    if (test__floatuntixf(make_ti(0x023479FD0E092DC0LL, 0), 0x1.1A3CFE870496Ep+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DA1LL, 1), 0x1.1A3CFE870496D08p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DB0LL, 2), 0x1.1A3CFE870496D8p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DB8LL, 3), 0x1.1A3CFE870496DCp+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DB6LL, 4), 0x1.1A3CFE870496DBp+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DBFLL, 5), 0x1.1A3CFE870496DF8p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DC1LL, 6), 0x1.1A3CFE870496E08p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DC7LL, 7), 0x1.1A3CFE870496E38p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DC8LL, 8), 0x1.1A3CFE870496E4p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DCFLL, 9), 0x1.1A3CFE870496E78p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DD0LL, 0), 0x1.1A3CFE870496E8p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DD1LL, 11), 0x1.1A3CFE870496E88p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DD8LL, 12), 0x1.1A3CFE870496ECp+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DDFLL, 13), 0x1.1A3CFE870496EF8p+121L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x023479FD0E092DE0LL, 14), 0x1.1A3CFE870496Fp+121L))
+        return 1;
+
+    if (test__floatuntixf(make_ti(0, 0xFFFFFFFFFFFFFFFFLL), 0x1.FFFFFFFFFFFFFFFEp+63L))
+        return 1;
+
+    if (test__floatuntixf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x0000000000000000LL),
+                          0x1.FFFFFFFFFFFFFFFEp+127L))
+        return 1;
+    if (test__floatuntixf(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                          0x1.0000000000000000p+128L))
+        return 1;
+
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x3456100000000001LL),
+                        0x1.2345678901234562p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x3456200000000000LL),
+                        0x1.2345678901234562p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x34562FFFFFFFFFFFLL),
+                        0x1.2345678901234562p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x3456300000000000LL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x3456400000000000LL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x34564FFFFFFFFFFFLL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x3456500000000000LL),
+                        0x1.2345678901234564p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x3456500000000001LL),
+                        0x1.2345678901234566p+108L))
+        return 1;
+    if (test__floatuntixf(make_ti(0x0000123456789012LL, 0x34566FFFFFFFFFFFLL),
+                        0x1.2345678901234566p+108L))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/fp_test.h b/compiler-rt/test/builtins/Unit/fp_test.h
new file mode 100644
index 0000000..ea101cc
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/fp_test.h
@@ -0,0 +1,312 @@
+//===--------------------------- fp_test.h - ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines shared functions for the test.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <stdint.h>
+
+enum EXPECTED_RESULT {
+    LESS_0, LESS_EQUAL_0, EQUAL_0, GREATER_0, GREATER_EQUAL_0, NEQUAL_0
+};
+
+static inline uint16_t fromRep16(uint16_t x)
+{
+    return x;
+}
+
+static inline float fromRep32(uint32_t x)
+{
+    float ret;
+    memcpy(&ret, &x, 4);
+    return ret;
+}
+
+static inline double fromRep64(uint64_t x)
+{
+    double ret;
+    memcpy(&ret, &x, 8);
+    return ret;
+}
+
+#if __LDBL_MANT_DIG__ == 113
+static inline long double fromRep128(uint64_t hi, uint64_t lo)
+{
+    __uint128_t x = ((__uint128_t)hi << 64) + lo;
+    long double ret;
+    memcpy(&ret, &x, 16);
+    return ret;
+}
+#endif
+
+static inline uint16_t toRep16(uint16_t x)
+{
+    return x;
+}
+
+static inline uint16_t toRep16(uint16_t x)
+{
+    return x;
+}
+
+static inline uint32_t toRep32(float x)
+{
+    uint32_t ret;
+    memcpy(&ret, &x, 4);
+    return ret;
+}
+
+static inline uint64_t toRep64(double x)
+{
+    uint64_t ret;
+    memcpy(&ret, &x, 8);
+    return ret;
+}
+
+#if __LDBL_MANT_DIG__ == 113
+static inline __uint128_t toRep128(long double x)
+{
+    __uint128_t ret;
+    memcpy(&ret, &x, 16);
+    return ret;
+}
+#endif
+
+static inline int compareResultH(uint16_t result,
+                                 uint16_t expected)
+{
+    uint16_t rep = toRep16(result);
+
+    if (rep == expected){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expected == 0x7e00U){
+        if ((rep & 0x7c00U) == 0x7c00U &&
+            (rep & 0x3ffU) > 0){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static inline int compareResultH(uint16_t result,
+                                 uint16_t expected)
+{
+    uint16_t rep = toRep16(result);
+
+    if (rep == expected){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expected == 0x7e00U){
+        if ((rep & 0x7c00U) == 0x7c00U &&
+            (rep & 0x3ffU) > 0){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static inline int compareResultF(float result,
+                                 uint32_t expected)
+{
+    uint32_t rep = toRep32(result);
+
+    if (rep == expected){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expected == 0x7fc00000U){
+        if ((rep & 0x7f800000U) == 0x7f800000U &&
+            (rep & 0x7fffffU) > 0){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static inline int compareResultD(double result,
+                                 uint64_t expected)
+{
+    uint64_t rep = toRep64(result);
+
+    if (rep == expected){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expected == 0x7ff8000000000000UL){
+        if ((rep & 0x7ff0000000000000UL) == 0x7ff0000000000000UL &&
+            (rep & 0xfffffffffffffUL) > 0){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+#if __LDBL_MANT_DIG__ == 113
+// return 0 if equal
+// use two 64-bit integers intead of one 128-bit integer
+// because 128-bit integer constant can't be assigned directly
+static inline int compareResultLD(long double result,
+                                  uint64_t expectedHi,
+                                  uint64_t expectedLo)
+{
+    __uint128_t rep = toRep128(result);
+    uint64_t hi = rep >> 64;
+    uint64_t lo = rep;
+
+    if (hi == expectedHi && lo == expectedLo){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expectedHi == 0x7fff800000000000UL && expectedLo == 0x0UL){
+        if ((hi & 0x7fff000000000000UL) == 0x7fff000000000000UL &&
+            ((hi & 0xffffffffffffUL) > 0 || lo > 0)){
+            return 0;
+        }
+    }
+    return 1;
+}
+#endif
+
+static inline int compareResultCMP(int result,
+                                   enum EXPECTED_RESULT expected)
+{
+    switch(expected){
+        case LESS_0:
+            if (result < 0)
+                return 0;
+            break;
+        case LESS_EQUAL_0:
+            if (result <= 0)
+                return 0;
+            break;
+        case EQUAL_0:
+            if (result == 0)
+                return 0;
+            break;
+        case NEQUAL_0:
+            if (result != 0)
+                return 0;
+            break;
+        case GREATER_EQUAL_0:
+            if (result >= 0)
+                return 0;
+            break;
+        case GREATER_0:
+            if (result > 0)
+                return 0;
+            break;
+        default:
+            return 1;
+    }
+    return 1;
+}
+
+static inline char *expectedStr(enum EXPECTED_RESULT expected)
+{
+    switch(expected){
+        case LESS_0:
+            return "<0";
+        case LESS_EQUAL_0:
+            return "<=0";
+        case EQUAL_0:
+            return "=0";
+        case NEQUAL_0:
+            return "!=0";
+        case GREATER_EQUAL_0:
+            return ">=0";
+        case GREATER_0:
+            return ">0";
+        default:
+            return "";
+    }
+    return "";
+}
+
+static inline uint16_t makeQNaN16()
+{
+    return fromRep16(0x7e00U);
+}
+
+static inline float makeQNaN32()
+{
+    return fromRep32(0x7fc00000U);
+}
+
+static inline double makeQNaN64()
+{
+    return fromRep64(0x7ff8000000000000UL);
+}
+
+#if __LDBL_MANT_DIG__ == 113
+static inline long double makeQNaN128()
+{
+    return fromRep128(0x7fff800000000000UL, 0x0UL);
+}
+#endif
+
+static inline uint16_t makeNaN16(uint16_t rand)
+{
+    return fromRep16(0x7c00U | (rand & 0x7fffU));
+}
+
+static inline uint16_t makeNaN16(uint16_t rand)
+{
+    return fromRep16(0x7c00U | (rand & 0x7fffU));
+}
+
+static inline float makeNaN32(uint32_t rand)
+{
+    return fromRep32(0x7f800000U | (rand & 0x7fffffU));
+}
+
+static inline double makeNaN64(uint64_t rand)
+{
+    return fromRep64(0x7ff0000000000000UL | (rand & 0xfffffffffffffUL));
+}
+
+#if __LDBL_MANT_DIG__ == 113
+static inline long double makeNaN128(uint64_t rand)
+{
+    return fromRep128(0x7fff000000000000UL | (rand & 0xffffffffffffUL), 0x0UL);
+}
+#endif
+
+static inline uint16_t makeInf16()
+{
+    return fromRep16(0x7c00U);
+}
+
+static inline uint16_t makeInf16()
+{
+    return fromRep16(0x7c00U);
+}
+
+static inline float makeInf32()
+{
+    return fromRep32(0x7f800000U);
+}
+
+static inline double makeInf64()
+{
+    return fromRep64(0x7ff0000000000000UL);
+}
+
+#if __LDBL_MANT_DIG__ == 113
+static inline long double makeInf128()
+{
+    return fromRep128(0x7fff000000000000UL, 0x0UL);
+}
+#endif
diff --git a/compiler-rt/test/builtins/Unit/gcc_personality_test.c b/compiler-rt/test/builtins/Unit/gcc_personality_test.c
new file mode 100644
index 0000000..f9598c6
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gcc_personality_test.c
@@ -0,0 +1,42 @@
+/* ===-- gcc_personality_test.c - Tests __gcc_personality_v0 -------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+
+extern void foo_clean(void* x);
+extern void bar_clean(void* x);
+extern void register_foo_local(int* x);
+extern void register_bar_local(int* x);
+extern void done_foo();
+extern void done_bar();
+
+
+/*
+ * foo() is called by main() in gcc_personality_test_helper.cxx.
+ * done_bar() is implemented in C++ and will throw an exception.
+ * main() will catch the exception and verify that the cleanup
+ * routines for foo() and bar() were called by the personality
+ * function.
+ */
+
+void bar() {
+    int x __attribute__((cleanup(bar_clean))) = 0;
+    register_bar_local(&x);
+    done_bar();
+}
+
+void foo() {
+    int x __attribute__((cleanup(foo_clean))) = 0;
+    register_foo_local(&x);
+    bar();
+    done_foo();
+}
diff --git a/compiler-rt/test/builtins/Unit/gcc_personality_test_helper.cxx b/compiler-rt/test/builtins/Unit/gcc_personality_test_helper.cxx
new file mode 100644
index 0000000..7d1ddfb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gcc_personality_test_helper.cxx
@@ -0,0 +1,85 @@
+//===-- gcc_personality_test_helper.cxx -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdio.h>
+
+extern "C" {
+    extern void foo_clean(void* x);
+    extern void bar_clean(void* x);
+    extern void register_foo_local(int* x);
+    extern void register_bar_local(int* x);
+    extern void done_foo();
+    extern void done_bar();
+    extern void foo();
+}
+
+static int* foo_x = NULL;
+void register_foo_local(int* x)
+{
+    foo_x = x;
+}
+
+static int* bar_x = NULL;
+void register_bar_local(int* x)
+{
+    bar_x = x;
+}
+
+static bool foo_clean_called = false;
+void foo_clean(void* x)
+{
+    if  ( foo_x == NULL )
+        abort();
+    if ( foo_x != (int*)x) 
+        abort();
+    foo_clean_called = true;
+}
+
+static bool bar_clean_called = false;
+void bar_clean(void* x)
+{
+    if  ( bar_x == NULL )
+        abort();
+    if ( bar_x != (int*)x) 
+        abort();
+    bar_clean_called = true;
+}
+
+void done_foo()
+{
+}
+
+void done_bar()
+{    
+    throw "done";
+}
+
+
+//
+// foo() is in gcc_personality_test.c and calls bar() which 
+// calls done_bar() which throws an exception.
+// main() will catch the exception and verify that the cleanup
+// routines for foo() and bar() were called by the personality
+// function.
+//
+int main()
+{
+    try {
+        foo();
+    }
+    catch(...) {
+        if ( !foo_clean_called )
+            abort();
+        if ( !bar_clean_called )
+            abort();
+		return 0;
+    }
+	abort();
+}
diff --git a/compiler-rt/test/builtins/Unit/gedf2vfp_test.c b/compiler-rt/test/builtins/Unit/gedf2vfp_test.c
new file mode 100644
index 0000000..e280ce0
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gedf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- gedf2vfp_test.c - Test __gedf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __gedf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __gedf2vfp(double a, double b);
+
+#if __arm__
+int test__gedf2vfp(double a, double b)
+{
+    int actual = __gedf2vfp(a, b);
+	int expected = (a >= b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __gedf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__gedf2vfp(0.0, 0.0))
+        return 1;
+    if (test__gedf2vfp(1.0, 0.0))
+        return 1;
+    if (test__gedf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__gedf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__gedf2vfp(HUGE_VAL, 1.0))
+        return 1;
+    if (test__gedf2vfp(1.0, HUGE_VAL))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/gesf2vfp_test.c b/compiler-rt/test/builtins/Unit/gesf2vfp_test.c
new file mode 100644
index 0000000..aa53eb7
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gesf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- gesf2vfp_test.c - Test __gesf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __gesf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __gesf2vfp(float a, float b);
+
+#if __arm__
+int test__gesf2vfp(float a, float b)
+{
+    int actual = __gesf2vfp(a, b);
+	int expected = (a >= b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __gesf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__gesf2vfp(0.0, 0.0))
+        return 1;
+    if (test__gesf2vfp(1.1, 1.0))
+        return 1;
+    if (test__gesf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__gesf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__gesf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__gesf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/getf2_test.c b/compiler-rt/test/builtins/Unit/getf2_test.c
new file mode 100644
index 0000000..9796b8a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/getf2_test.c
@@ -0,0 +1,89 @@
+//===------------ getf2_test.c - Test __getf2------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __getf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __getf2(long double a, long double b);
+
+int test__getf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __getf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__getf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__getf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // <
+    // exp
+    if (test__getf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // mantissa
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // sign
+    if (test__getf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // ==
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__getf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // sign
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/gtdf2vfp_test.c b/compiler-rt/test/builtins/Unit/gtdf2vfp_test.c
new file mode 100644
index 0000000..fd54e0b
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gtdf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- gtdf2vfp_test.c - Test __gtdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __gtdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __gtdf2vfp(double a, double b);
+
+#if __arm__
+int test__gtdf2vfp(double a, double b)
+{
+    int actual = __gtdf2vfp(a, b);
+	int expected = (a > b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __gtdf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__gtdf2vfp(0.0, 0.0))
+        return 1;
+    if (test__gtdf2vfp(1.0, 0.0))
+        return 1;
+    if (test__gtdf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__gtdf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__gtdf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__gtdf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/gtsf2vfp_test.c b/compiler-rt/test/builtins/Unit/gtsf2vfp_test.c
new file mode 100644
index 0000000..2f4ad99
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gtsf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- gtsf2vfp_test.c - Test __gtsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __gtsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __gtsf2vfp(float a, float b);
+
+#if __arm__
+int test__gtsf2vfp(float a, float b)
+{
+    int actual = __gtsf2vfp(a, b);
+	int expected = (a > b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __gtsf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__gtsf2vfp(0.0, 0.0))
+        return 1;
+    if (test__gtsf2vfp(1.0, 0.0))
+        return 1;
+    if (test__gtsf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__gtsf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__gtsf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__gtsf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/gttf2_test.c b/compiler-rt/test/builtins/Unit/gttf2_test.c
new file mode 100644
index 0000000..6508d4b
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/gttf2_test.c
@@ -0,0 +1,89 @@
+//===------------ gttf2_test.c - Test __gttf2------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __gttf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __gttf2(long double a, long double b);
+
+int test__gttf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __gttf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__gttf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__gttf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // sign
+    if (test__gttf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // ==
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_0))
+        return 1;
+    // mantissa
+    if (test__gttf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+    // sign
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ledf2vfp_test.c b/compiler-rt/test/builtins/Unit/ledf2vfp_test.c
new file mode 100644
index 0000000..5683590
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ledf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- ledf2vfp_test.c - Test __ledf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ledf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __ledf2vfp(double a, double b);
+
+#if __arm__
+int test__ledf2vfp(double a, double b)
+{
+    int actual = __ledf2vfp(a, b);
+	int expected = (a <= b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __ledf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__ledf2vfp(0.0, 0.0))
+        return 1;
+    if (test__ledf2vfp(1.0, 1.0))
+        return 1;
+    if (test__ledf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__ledf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__ledf2vfp(HUGE_VAL, 1.0))
+        return 1;
+    if (test__ledf2vfp(1.0, HUGE_VAL))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/lesf2vfp_test.c b/compiler-rt/test/builtins/Unit/lesf2vfp_test.c
new file mode 100644
index 0000000..b5c20f6
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/lesf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- lesf2vfp_test.c - Test __lesf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __lesf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __lesf2vfp(float a, float b);
+
+#if __arm__
+int test__lesf2vfp(float a, float b)
+{
+    int actual = __lesf2vfp(a, b);
+	int expected = (a <= b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __lesf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__lesf2vfp(0.0, 0.0))
+        return 1;
+    if (test__lesf2vfp(1.0, 1.0))
+        return 1;
+    if (test__lesf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__lesf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__lesf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__lesf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/letf2_test.c b/compiler-rt/test/builtins/Unit/letf2_test.c
new file mode 100644
index 0000000..1842e3c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/letf2_test.c
@@ -0,0 +1,89 @@
+//===------------ letf2_test.c - Test __letf2------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __letf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __letf2(long double a, long double b);
+
+int test__letf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __letf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__letf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__letf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+    // <
+    // exp
+    if (test__letf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // sign
+    if (test__letf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // ==
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_0))
+        return 1;
+    // mantissa
+    if (test__letf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+    // sign
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/lshrdi3_test.c b/compiler-rt/test/builtins/Unit/lshrdi3_test.c
new file mode 100644
index 0000000..d48ae4d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/lshrdi3_test.c
@@ -0,0 +1,118 @@
+//===-- lshrdi3_test.c - Test __lshrdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __lshrdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: logical a >> b
+
+// Precondition:  0 <= b < bits_in_dword
+
+COMPILER_RT_ABI di_int __lshrdi3(di_int a, si_int b);
+
+int test__lshrdi3(di_int a, si_int b, di_int expected)
+{
+    di_int x = __lshrdi3(a, b);
+    if (x != expected)
+        printf("error in __lshrdi3: %llX >> %d = %llX, expected %llX\n",
+               a, b, __lshrdi3(a, b), expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 0, 0x123456789ABCDEFLL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 1, 0x91A2B3C4D5E6F7LL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 2, 0x48D159E26AF37BLL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 3, 0x2468ACF13579BDLL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 4, 0x123456789ABCDELL))
+        return 1;
+
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 28, 0x12345678LL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 29, 0x91A2B3CLL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 30, 0x48D159ELL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 31, 0x2468ACFLL))
+        return 1;
+
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 32, 0x1234567LL))
+        return 1;
+
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 33, 0x91A2B3LL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 34, 0x48D159LL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 35, 0x2468ACLL))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 36, 0x123456LL))
+        return 1;
+
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 60, 0))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 61, 0))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 62, 0))
+        return 1;
+    if (test__lshrdi3(0x0123456789ABCDEFLL, 63, 0))
+        return 1;
+
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 0, 0xFEDCBA9876543210LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 1, 0x7F6E5D4C3B2A1908LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 2, 0x3FB72EA61D950C84LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 3, 0x1FDB97530ECA8642LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 4, 0xFEDCBA987654321LL))
+        return 1;
+
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 28, 0xFEDCBA987LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 29, 0x7F6E5D4C3LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 30, 0x3FB72EA61LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 31, 0x1FDB97530LL))
+        return 1;
+
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 32, 0xFEDCBA98LL))
+        return 1;
+
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 33, 0x7F6E5D4CLL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 34, 0x3FB72EA6LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 35, 0x1FDB9753LL))
+        return 1;
+    if (test__lshrdi3(0xFEDCBA9876543210LL, 36, 0xFEDCBA9LL))
+        return 1;
+
+    if (test__lshrdi3(0xAEDCBA9876543210LL, 60, 0xALL))
+        return 1;
+    if (test__lshrdi3(0xAEDCBA9876543210LL, 61, 0x5LL))
+        return 1;
+    if (test__lshrdi3(0xAEDCBA9876543210LL, 62, 0x2LL))
+        return 1;
+    if (test__lshrdi3(0xAEDCBA9876543210LL, 63, 0x1LL))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/lshrti3_test.c b/compiler-rt/test/builtins/Unit/lshrti3_test.c
new file mode 100644
index 0000000..f5a0dd6
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/lshrti3_test.c
@@ -0,0 +1,173 @@
+//===-- lshrti3_test.c - Test __lshrti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __lshrti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: logical a >> b
+
+// Precondition:  0 <= b < bits_in_dword
+
+COMPILER_RT_ABI ti_int __lshrti3(ti_int a, si_int b);
+
+int test__lshrti3(ti_int a, si_int b, ti_int expected)
+{
+    ti_int x = __lshrti3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __lshrti3: 0x%llX%.16llX >> %d = 0x%llX%.16llX,"
+               " expected 0x%llX%.16llX\n",
+                at.s.high, at.s.low, b, xt.s.high, xt.s.low,
+                expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 0,
+                      make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 1,
+                      make_ti(0x7F6E5D4C3B2A190ALL, 0xFF6E5D4C3B2A190ALL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 2,
+                      make_ti(0x3FB72EA61D950C85LL, 0x7FB72EA61D950C85LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 3,
+                      make_ti(0x1FDB97530ECA8642LL, 0xBFDB97530ECA8642LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 4,
+                      make_ti(0x0FEDCBA987654321LL, 0x5FEDCBA987654321LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 28,
+                      make_ti(0x0000000FEDCBA987LL, 0x6543215FEDCBA987LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 29,
+                      make_ti(0x00000007F6E5D4C3LL, 0xB2A190AFF6E5D4C3LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 30,
+                      make_ti(0x00000003FB72EA61LL, 0xD950C857FB72EA61LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 31,
+                      make_ti(0x00000001FDB97530LL, 0xECA8642BFDB97530LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 32,
+                      make_ti(0x00000000FEDCBA98LL, 0x76543215FEDCBA98LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 33,
+                      make_ti(0x000000007F6E5D4CLL, 0x3B2A190AFF6E5D4CLL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 34,
+                      make_ti(0x000000003FB72EA6LL, 0x1D950C857FB72EA6LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 35,
+                      make_ti(0x000000001FDB9753LL, 0x0ECA8642BFDB9753LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 36,
+                      make_ti(0x000000000FEDCBA9LL, 0x876543215FEDCBA9LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 60,
+                      make_ti(0x000000000000000FLL, 0xEDCBA9876543215FLL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 61,
+                      make_ti(0x0000000000000007LL, 0xF6E5D4C3B2A190AFLL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 62,
+                      make_ti(0x0000000000000003LL, 0xFB72EA61D950C857LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 63,
+                      make_ti(0x0000000000000001LL, 0xFDB97530ECA8642BLL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 64,
+                      make_ti(0x0000000000000000LL, 0xFEDCBA9876543215LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 65,
+                      make_ti(0x0000000000000000LL, 0x7F6E5D4C3B2A190ALL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 66,
+                      make_ti(0x0000000000000000LL, 0x3FB72EA61D950C85LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 67,
+                      make_ti(0x0000000000000000LL, 0x1FDB97530ECA8642LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 68,
+                      make_ti(0x0000000000000000LL, 0x0FEDCBA987654321LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 92,
+                      make_ti(0x0000000000000000LL, 0x0000000FEDCBA987LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 93,
+                      make_ti(0x0000000000000000LL, 0x00000007F6E5D4C3LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 94,
+                      make_ti(0x0000000000000000LL, 0x00000003FB72EA61LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 95,
+                      make_ti(0x0000000000000000LL, 0x00000001FDB97530LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 96,
+                      make_ti(0x0000000000000000LL, 0x00000000FEDCBA98LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 97,
+                      make_ti(0x0000000000000000LL, 0x000000007F6E5D4CLL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 98,
+                      make_ti(0x0000000000000000LL, 0x000000003FB72EA6LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 99,
+                      make_ti(0x0000000000000000LL, 0x000000001FDB9753LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 100,
+                      make_ti(0x0000000000000000LL, 0x000000000FEDCBA9LL)))
+        return 1;
+
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 124,
+                      make_ti(0x0000000000000000LL, 0x000000000000000FLL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 125,
+                      make_ti(0x0000000000000000LL, 0x0000000000000007LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 126,
+                      make_ti(0x0000000000000000LL, 0x0000000000000003LL)))
+        return 1;
+    if (test__lshrti3(make_ti(0xFEDCBA9876543215LL, 0xFEDCBA9876543215LL), 127,
+                      make_ti(0x0000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ltdf2vfp_test.c b/compiler-rt/test/builtins/Unit/ltdf2vfp_test.c
new file mode 100644
index 0000000..7319397
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ltdf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- ltdf2vfp_test.c - Test __ltdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ltdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __ltdf2vfp(double a, double b);
+
+#if __arm__
+int test__ltdf2vfp(double a, double b)
+{
+    int actual = __ltdf2vfp(a, b);
+	int expected = (a < b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __ltdf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__ltdf2vfp(0.0, 0.0))
+        return 1;
+    if (test__ltdf2vfp(1.0, 1.0))
+        return 1;
+    if (test__ltdf2vfp(-1.0, -1.0))
+        return 1;
+    if (test__ltdf2vfp(HUGE_VAL, 1.0))
+        return 1;
+    if (test__ltdf2vfp(1.0, HUGE_VAL))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ltsf2vfp_test.c b/compiler-rt/test/builtins/Unit/ltsf2vfp_test.c
new file mode 100644
index 0000000..2d920c9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ltsf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- ltsf2vfp_test.c - Test __ltsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ltsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __ltsf2vfp(float a, float b);
+
+#if __arm__
+int test__ltsf2vfp(float a, float b)
+{
+    int actual = __ltsf2vfp(a, b);
+	int expected = (a < b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __ltsf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__ltsf2vfp(0.0, 0.0))
+        return 1;
+    if (test__ltsf2vfp(-1.0, 1.0))
+        return 1;
+    if (test__ltsf2vfp(-1.0, -2.0))
+        return 1;
+    if (test__ltsf2vfp(-2.0, -1.0))
+        return 1;
+    if (test__ltsf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__ltsf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/lttf2_test.c b/compiler-rt/test/builtins/Unit/lttf2_test.c
new file mode 100644
index 0000000..e8f9dc1
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/lttf2_test.c
@@ -0,0 +1,89 @@
+//===------------ lttf2_test.c - Test __lttf2------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __lttf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __lttf2(long double a, long double b);
+
+int test__lttf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __lttf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__lttf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__lttf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // mantissa
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // sign
+    if (test__lttf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // ==
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__lttf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // sign
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/moddi3_test.c b/compiler-rt/test/builtins/Unit/moddi3_test.c
new file mode 100644
index 0000000..62e8f22
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/moddi3_test.c
@@ -0,0 +1,62 @@
+//===-- moddi3_test.c - Test __moddi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __moddi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+COMPILER_RT_ABI di_int __moddi3(di_int a, di_int b);
+
+int test__moddi3(di_int a, di_int b, di_int expected)
+{
+    di_int x = __moddi3(a, b);
+    if (x != expected)
+        printf("error in __moddi3: %lld %% %lld = %lld, expected %lld\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__moddi3(0, 1, 0))
+        return 1;
+    if (test__moddi3(0, -1, 0))
+        return 1;
+
+    if (test__moddi3(5, 3, 2))
+        return 1;
+    if (test__moddi3(5, -3, 2))
+        return 1;
+    if (test__moddi3(-5, 3, -2))
+        return 1;
+    if (test__moddi3(-5, -3, -2))
+        return 1;
+
+    if (test__moddi3(0x8000000000000000LL, 1, 0x0LL))
+        return 1;
+    if (test__moddi3(0x8000000000000000LL, -1, 0x0LL))
+        return 1;
+    if (test__moddi3(0x8000000000000000LL, 2, 0x0LL))
+        return 1;
+    if (test__moddi3(0x8000000000000000LL, -2, 0x0LL))
+        return 1;
+    if (test__moddi3(0x8000000000000000LL, 3, -2))
+        return 1;
+    if (test__moddi3(0x8000000000000000LL, -3, -2))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/modsi3_test.c b/compiler-rt/test/builtins/Unit/modsi3_test.c
new file mode 100644
index 0000000..8c9f588
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/modsi3_test.c
@@ -0,0 +1,57 @@
+/* ===-- modsi3_test.c - Test __modsi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file tests __modsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdio.h>
+
+/* Returns: a % b */
+
+COMPILER_RT_ABI si_int __modsi3(si_int a, si_int b);
+
+int test__modsi3(si_int a, si_int b, si_int expected) {
+    si_int x = __modsi3(a, b);
+    if (x != expected)
+        fprintf(stderr, "error in __modsi3: %d %% %d = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main() {
+    if (test__modsi3(0, 1, 0))
+        return 1;
+    if (test__modsi3(0, -1, 0))
+        return 1;
+
+    if (test__modsi3(5, 3, 2))
+        return 1;
+    if (test__modsi3(5, -3, 2))
+        return 1;
+    if (test__modsi3(-5, 3, -2))
+        return 1;
+    if (test__modsi3(-5, -3, -2))
+        return 1;
+
+    if (test__modsi3(0x80000000, 1, 0x0))
+        return 1;
+    if (test__modsi3(0x80000000, 2, 0x0))
+        return 1;
+    if (test__modsi3(0x80000000, -2, 0x0))
+        return 1;
+    if (test__modsi3(0x80000000, 3, -2))
+        return 1;
+    if (test__modsi3(0x80000000, -3, -2))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/modti3_test.c b/compiler-rt/test/builtins/Unit/modti3_test.c
new file mode 100644
index 0000000..99413aa
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/modti3_test.c
@@ -0,0 +1,95 @@
+//===-- modti3_test.c - Test __modti3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __modti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a % b
+
+COMPILER_RT_ABI ti_int __modti3(ti_int a, ti_int b);
+
+int test__modti3(ti_int a, ti_int b, ti_int expected)
+{
+    ti_int x = __modti3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __modti3: 0x%.16llX%.16llX %% 0x%.16llX%.16llX = "
+               "0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__modti3(0, 1, 0))
+        return 1;
+    if (test__modti3(0, -1, 0))
+        return 1;
+
+    if (test__modti3(5, 3, 2))
+        return 1;
+    if (test__modti3(5, -3, 2))
+        return 1;
+    if (test__modti3(-5, 3, -2))
+        return 1;
+    if (test__modti3(-5, -3, -2))
+        return 1;
+
+    if (test__modti3(0x8000000000000000LL, 1, 0x0LL))
+        return 1;
+    if (test__modti3(0x8000000000000000LL, -1, 0x0LL))
+        return 1;
+    if (test__modti3(0x8000000000000000LL, 2, 0x0LL))
+        return 1;
+    if (test__modti3(0x8000000000000000LL, -2, 0x0LL))
+        return 1;
+    if (test__modti3(0x8000000000000000LL, 3, 2))
+        return 1;
+    if (test__modti3(0x8000000000000000LL, -3, 2))
+        return 1;
+
+    if (test__modti3(make_ti(0x8000000000000000LL, 0), 1, 0x0LL))
+        return 1;
+    if (test__modti3(make_ti(0x8000000000000000LL, 0), -1, 0x0LL))
+        return 1;
+    if (test__modti3(make_ti(0x8000000000000000LL, 0), 2, 0x0LL))
+        return 1;
+    if (test__modti3(make_ti(0x8000000000000000LL, 0), -2, 0x0LL))
+        return 1;
+    if (test__modti3(make_ti(0x8000000000000000LL, 0), 3, -2))
+        return 1;
+    if (test__modti3(make_ti(0x8000000000000000LL, 0), -3, -2))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/muldc3_test.c b/compiler-rt/test/builtins/Unit/muldc3_test.c
new file mode 100644
index 0000000..6902ef3
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/muldc3_test.c
@@ -0,0 +1,367 @@
+//===-- muldc3_test.c - Test __muldc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __muldc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+// Returns: the product of a + ib and c + id
+
+COMPILER_RT_ABI double _Complex
+__muldc3(double __a, double __b, double __c, double __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(double _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(creal(x)) || isinf(cimag(x)))
+        return inf;
+    if (isnan(creal(x)) && isnan(cimag(x)))
+        return NaN;
+    if (isnan(creal(x)))
+    {
+        if (cimag(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimag(x)))
+    {
+        if (creal(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__muldc3(double a, double b, double c, double d)
+{
+    double _Complex r = __muldc3(a, b, c, d);
+//     printf("test__muldc3(%f, %f, %f, %f) = %f + I%f\n",
+//             a, b, c, d, creal(r), cimag(r));
+	double _Complex dividend;
+	double _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            if (r != a * c - b * d + _Complex_I*(a * d + b * c))
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+double x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+int main()
+{
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__muldc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/muldf3vfp_test.c b/compiler-rt/test/builtins/Unit/muldf3vfp_test.c
new file mode 100644
index 0000000..766972d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/muldf3vfp_test.c
@@ -0,0 +1,51 @@
+//===-- muldf3vfp_test.c - Test __muldf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __muldf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern COMPILER_RT_ABI double __muldf3vfp(double a, double b);
+
+int test__muldf3vfp(double a, double b)
+{
+    double actual = __muldf3vfp(a, b);
+    double expected = a * b;
+    if (actual != expected)
+        printf("error in test__muldf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__muldf3vfp(0.5, 10.0))
+        return 1;
+    if (test__muldf3vfp(-0.5, -2.0))
+        return 1;
+    if (test__muldf3vfp(HUGE_VALF, 0.25))
+        return 1;
+    if (test__muldf3vfp(-0.125, HUGE_VALF))
+        return 1;
+    if (test__muldf3vfp(0.0, -0.0))
+		return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/muldi3_test.c b/compiler-rt/test/builtins/Unit/muldi3_test.c
new file mode 100644
index 0000000..651dd01
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/muldi3_test.c
@@ -0,0 +1,110 @@
+//===-- muldi3_test.c - Test __muldi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __muldi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+COMPILER_RT_ABI di_int __muldi3(di_int a, di_int b);
+
+int test__muldi3(di_int a, di_int b, di_int expected)
+{
+    di_int x = __muldi3(a, b);
+    if (x != expected)
+        printf("error in __muldi3: %lld * %lld = %lld, expected %lld\n",
+               a, b, __muldi3(a, b), expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__muldi3(0, 0, 0))
+        return 1;
+    if (test__muldi3(0, 1, 0))
+        return 1;
+    if (test__muldi3(1, 0, 0))
+        return 1;
+    if (test__muldi3(0, 10, 0))
+        return 1;
+    if (test__muldi3(10, 0, 0))
+        return 1;
+    if (test__muldi3(0, 81985529216486895LL, 0))
+        return 1;
+    if (test__muldi3(81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__muldi3(0, -1, 0))
+        return 1;
+    if (test__muldi3(-1, 0, 0))
+        return 1;
+    if (test__muldi3(0, -10, 0))
+        return 1;
+    if (test__muldi3(-10, 0, 0))
+        return 1;
+    if (test__muldi3(0, -81985529216486895LL, 0))
+        return 1;
+    if (test__muldi3(-81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__muldi3(1, 1, 1))
+        return 1;
+    if (test__muldi3(1, 10, 10))
+        return 1;
+    if (test__muldi3(10, 1, 10))
+        return 1;
+    if (test__muldi3(1, 81985529216486895LL, 81985529216486895LL))
+        return 1;
+    if (test__muldi3(81985529216486895LL, 1, 81985529216486895LL))
+        return 1;
+
+    if (test__muldi3(1, -1, -1))
+        return 1;
+    if (test__muldi3(1, -10, -10))
+        return 1;
+    if (test__muldi3(-10, 1, -10))
+        return 1;
+    if (test__muldi3(1, -81985529216486895LL, -81985529216486895LL))
+        return 1;
+    if (test__muldi3(-81985529216486895LL, 1, -81985529216486895LL))
+        return 1;
+
+    if (test__muldi3(3037000499LL, 3037000499LL, 9223372030926249001LL))
+        return 1;
+    if (test__muldi3(-3037000499LL, 3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__muldi3(3037000499LL, -3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__muldi3(-3037000499LL, -3037000499LL, 9223372030926249001LL))
+        return 1;
+
+    if (test__muldi3(4398046511103LL, 2097152LL, 9223372036852678656LL))
+        return 1;
+    if (test__muldi3(-4398046511103LL, 2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__muldi3(4398046511103LL, -2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__muldi3(-4398046511103LL, -2097152LL, 9223372036852678656LL))
+        return 1;
+
+    if (test__muldi3(2097152LL, 4398046511103LL, 9223372036852678656LL))
+        return 1;
+    if (test__muldi3(-2097152LL, 4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__muldi3(2097152LL, -4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__muldi3(-2097152LL, -4398046511103LL, 9223372036852678656LL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulodi4_test.c b/compiler-rt/test/builtins/Unit/mulodi4_test.c
new file mode 100644
index 0000000..4546609
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulodi4_test.c
@@ -0,0 +1,178 @@
+//===-- mulodi4_test.c - Test __mulodi4 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulodi4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+extern COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int* overflow);
+
+int test__mulodi4(di_int a, di_int b, di_int expected, int expected_overflow)
+{
+    int ov;
+    di_int x = __mulodi4(a, b, &ov);
+    if (ov != expected_overflow)
+      printf("error in __mulodi4: overflow=%d expected=%d\n",
+	     ov, expected_overflow);
+    else if (!expected_overflow && x != expected) {
+        printf("error in __mulodi4: 0x%llX * 0x%llX = 0x%llX (overflow=%d), "
+			   "expected 0x%llX (overflow=%d)\n",
+               a, b, x, ov, expected, expected_overflow);
+		return 1;
+    }
+    return 0;
+}
+
+int main()
+{
+    if (test__mulodi4(0, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, 1, 0, 0))
+        return 1;
+    if (test__mulodi4(1, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, 10, 0, 0))
+        return 1;
+    if (test__mulodi4(10, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, 81985529216486895LL, 0, 0))
+        return 1;
+    if (test__mulodi4(81985529216486895LL, 0, 0, 0))
+        return 1;
+
+    if (test__mulodi4(0, -1, 0, 0))
+        return 1;
+    if (test__mulodi4(-1, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, -10, 0, 0))
+        return 1;
+    if (test__mulodi4(-10, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, -81985529216486895LL, 0, 0))
+        return 1;
+    if (test__mulodi4(-81985529216486895LL, 0, 0, 0))
+        return 1;
+
+    if (test__mulodi4(1, 1, 1, 0))
+        return 1;
+    if (test__mulodi4(1, 10, 10, 0))
+        return 1;
+    if (test__mulodi4(10, 1, 10, 0))
+        return 1;
+    if (test__mulodi4(1, 81985529216486895LL, 81985529216486895LL, 0))
+        return 1;
+    if (test__mulodi4(81985529216486895LL, 1, 81985529216486895LL, 0))
+        return 1;
+
+    if (test__mulodi4(1, -1, -1, 0))
+        return 1;
+    if (test__mulodi4(1, -10, -10, 0))
+        return 1;
+    if (test__mulodi4(-10, 1, -10, 0))
+        return 1;
+    if (test__mulodi4(1, -81985529216486895LL, -81985529216486895LL, 0))
+        return 1;
+    if (test__mulodi4(-81985529216486895LL, 1, -81985529216486895LL, 0))
+        return 1;
+
+    if (test__mulodi4(3037000499LL, 3037000499LL, 9223372030926249001LL, 0))
+        return 1;
+    if (test__mulodi4(-3037000499LL, 3037000499LL, -9223372030926249001LL, 0))
+        return 1;
+    if (test__mulodi4(3037000499LL, -3037000499LL, -9223372030926249001LL, 0))
+        return 1;
+    if (test__mulodi4(-3037000499LL, -3037000499LL, 9223372030926249001LL, 0))
+        return 1;
+
+    if (test__mulodi4(4398046511103LL, 2097152LL, 9223372036852678656LL, 0))
+        return 1;
+    if (test__mulodi4(-4398046511103LL, 2097152LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__mulodi4(4398046511103LL, -2097152LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__mulodi4(-4398046511103LL, -2097152LL, 9223372036852678656LL, 0))
+        return 1;
+
+    if (test__mulodi4(2097152LL, 4398046511103LL, 9223372036852678656LL, 0))
+        return 1;
+    if (test__mulodi4(-2097152LL, 4398046511103LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__mulodi4(2097152LL, -4398046511103LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__mulodi4(-2097152LL, -4398046511103LL, 9223372036852678656LL, 0))
+        return 1;
+
+     if (test__mulodi4(0x7FFFFFFFFFFFFFFFLL, -2, 2, 1))
+         return 1;
+     if (test__mulodi4(-2, 0x7FFFFFFFFFFFFFFFLL, 2, 1))
+         return 1;
+    if (test__mulodi4(0x7FFFFFFFFFFFFFFFLL, -1, 0x8000000000000001LL, 0))
+        return 1;
+    if (test__mulodi4(-1, 0x7FFFFFFFFFFFFFFFLL, 0x8000000000000001LL, 0))
+        return 1;
+    if (test__mulodi4(0x7FFFFFFFFFFFFFFFLL, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, 0x7FFFFFFFFFFFFFFFLL, 0, 0))
+        return 1;
+    if (test__mulodi4(0x7FFFFFFFFFFFFFFFLL, 1, 0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+    if (test__mulodi4(1, 0x7FFFFFFFFFFFFFFFLL, 0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+     if (test__mulodi4(0x7FFFFFFFFFFFFFFFLL, 2, 0x8000000000000001LL, 1))
+         return 1;
+     if (test__mulodi4(2, 0x7FFFFFFFFFFFFFFFLL, 0x8000000000000001LL, 1))
+         return 1;
+
+     if (test__mulodi4(0x8000000000000000LL, -2, 0x8000000000000000LL, 1))
+         return 1;
+     if (test__mulodi4(-2, 0x8000000000000000LL, 0x8000000000000000LL, 1))
+         return 1;
+     if (test__mulodi4(0x8000000000000000LL, -1, 0x8000000000000000LL, 1))
+         return 1;
+     if (test__mulodi4(-1, 0x8000000000000000LL, 0x8000000000000000LL, 1))
+         return 1;
+    if (test__mulodi4(0x8000000000000000LL, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, 0x8000000000000000LL, 0, 0))
+        return 1;
+    if (test__mulodi4(0x8000000000000000LL, 1, 0x8000000000000000LL, 0))
+        return 1;
+    if (test__mulodi4(1, 0x8000000000000000LL, 0x8000000000000000LL, 0))
+        return 1;
+     if (test__mulodi4(0x8000000000000000LL, 2, 0x8000000000000000LL, 1))
+         return 1;
+     if (test__mulodi4(2, 0x8000000000000000LL, 0x8000000000000000LL, 1))
+         return 1;
+
+     if (test__mulodi4(0x8000000000000001LL, -2, 0x8000000000000001LL, 1))
+         return 1;
+     if (test__mulodi4(-2, 0x8000000000000001LL, 0x8000000000000001LL, 1))
+         return 1;
+    if (test__mulodi4(0x8000000000000001LL, -1, 0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+    if (test__mulodi4(-1, 0x8000000000000001LL, 0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+    if (test__mulodi4(0x8000000000000001LL, 0, 0, 0))
+        return 1;
+    if (test__mulodi4(0, 0x8000000000000001LL, 0, 0))
+        return 1;
+    if (test__mulodi4(0x8000000000000001LL, 1, 0x8000000000000001LL, 0))
+        return 1;
+    if (test__mulodi4(1, 0x8000000000000001LL, 0x8000000000000001LL, 0))
+        return 1;
+     if (test__mulodi4(0x8000000000000001LL, 2, 0x8000000000000000LL, 1))
+         return 1;
+     if (test__mulodi4(2, 0x8000000000000001LL, 0x8000000000000000LL, 1))
+         return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulosi4_test.c b/compiler-rt/test/builtins/Unit/mulosi4_test.c
new file mode 100644
index 0000000..6a27d69
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulosi4_test.c
@@ -0,0 +1,156 @@
+//===-- mulosi4_test.c - Test __mulosi4 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulosi4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a * b
+
+// Effects: aborts if a * b overflows
+
+COMPILER_RT_ABI si_int __mulosi4(si_int a, si_int b, int *overflow);
+
+int test__mulosi4(si_int a, si_int b, si_int expected, int expected_overflow)
+{
+  int ov;
+  si_int x = __mulosi4(a, b, &ov);
+  if (ov != expected_overflow)
+    printf("error in __mulosi4: overflow=%d expected=%d\n",
+	   ov, expected_overflow);
+  else if (!expected_overflow && x != expected) {
+    printf("error in __mulosi4: 0x%X * 0x%X = 0x%X (overflow=%d), "
+	   "expected 0x%X (overflow=%d)\n",
+	   a, b, x, ov, expected, expected_overflow);
+    return 1;
+  }
+  return 0;
+}
+
+
+int main()
+{
+    if (test__mulosi4(0, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, 1, 0, 0))
+        return 1;
+    if (test__mulosi4(1, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, 10, 0, 0))
+        return 1;
+    if (test__mulosi4(10, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, 0x1234567, 0, 0))
+        return 1;
+    if (test__mulosi4(0x1234567, 0, 0, 0))
+        return 1;
+
+    if (test__mulosi4(0, -1, 0, 0))
+        return 1;
+    if (test__mulosi4(-1, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, -10, 0, 0))
+        return 1;
+    if (test__mulosi4(-10, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, -0x1234567, 0, 0))
+        return 1;
+    if (test__mulosi4(-0x1234567, 0, 0, 0))
+        return 1;
+
+    if (test__mulosi4(1, 1, 1, 0))
+        return 1;
+    if (test__mulosi4(1, 10, 10, 0))
+        return 1;
+    if (test__mulosi4(10, 1, 10, 0))
+        return 1;
+    if (test__mulosi4(1, 0x1234567, 0x1234567, 0))
+        return 1;
+    if (test__mulosi4(0x1234567, 1, 0x1234567, 0))
+        return 1;
+
+    if (test__mulosi4(1, -1, -1, 0))
+        return 1;
+    if (test__mulosi4(1, -10, -10, 0))
+        return 1;
+    if (test__mulosi4(-10, 1, -10, 0))
+        return 1;
+    if (test__mulosi4(1, -0x1234567, -0x1234567, 0))
+        return 1;
+    if (test__mulosi4(-0x1234567, 1, -0x1234567, 0))
+        return 1;
+
+     if (test__mulosi4(0x7FFFFFFF, -2, 0x80000001, 1))
+         return 1;
+     if (test__mulosi4(-2, 0x7FFFFFFF, 0x80000001, 1))
+         return 1;
+    if (test__mulosi4(0x7FFFFFFF, -1, 0x80000001, 0))
+        return 1;
+    if (test__mulosi4(-1, 0x7FFFFFFF, 0x80000001, 0))
+        return 1;
+    if (test__mulosi4(0x7FFFFFFF, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, 0x7FFFFFFF, 0, 0))
+        return 1;
+    if (test__mulosi4(0x7FFFFFFF, 1, 0x7FFFFFFF, 0))
+        return 1;
+    if (test__mulosi4(1, 0x7FFFFFFF, 0x7FFFFFFF, 0))
+        return 1;
+     if (test__mulosi4(0x7FFFFFFF, 2, 0x80000001, 1))
+         return 1;
+     if (test__mulosi4(2, 0x7FFFFFFF, 0x80000001, 1))
+         return 1;
+
+     if (test__mulosi4(0x80000000, -2, 0x80000000, 1))
+         return 1;
+     if (test__mulosi4(-2, 0x80000000, 0x80000000, 1))
+         return 1;
+     if (test__mulosi4(0x80000000, -1, 0x80000000, 1))
+         return 1;
+     if (test__mulosi4(-1, 0x80000000, 0x80000000, 1))
+         return 1;
+    if (test__mulosi4(0x80000000, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, 0x80000000, 0, 0))
+        return 1;
+    if (test__mulosi4(0x80000000, 1, 0x80000000, 0))
+        return 1;
+    if (test__mulosi4(1, 0x80000000, 0x80000000, 0))
+        return 1;
+     if (test__mulosi4(0x80000000, 2, 0x80000000, 1))
+         return 1;
+     if (test__mulosi4(2, 0x80000000, 0x80000000, 1))
+         return 1;
+
+     if (test__mulosi4(0x80000001, -2, 0x80000001, 1))
+         return 1;
+     if (test__mulosi4(-2, 0x80000001, 0x80000001, 1))
+         return 1;
+    if (test__mulosi4(0x80000001, -1, 0x7FFFFFFF, 0))
+        return 1;
+    if (test__mulosi4(-1, 0x80000001, 0x7FFFFFFF, 0))
+        return 1;
+    if (test__mulosi4(0x80000001, 0, 0, 0))
+        return 1;
+    if (test__mulosi4(0, 0x80000001, 0, 0))
+        return 1;
+    if (test__mulosi4(0x80000001, 1, 0x80000001, 0))
+        return 1;
+    if (test__mulosi4(1, 0x80000001, 0x80000001, 0))
+        return 1;
+     if (test__mulosi4(0x80000001, 2, 0x80000000, 1))
+         return 1;
+     if (test__mulosi4(2, 0x80000001, 0x80000000, 1))
+         return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/muloti4_test.c b/compiler-rt/test/builtins/Unit/muloti4_test.c
new file mode 100644
index 0000000..d00e7bb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/muloti4_test.c
@@ -0,0 +1,280 @@
+//===-- muloti4_test.c - Test __muloti4 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __muloti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a * b
+
+// Effects: sets overflow if a * b overflows
+
+COMPILER_RT_ABI ti_int __muloti4(ti_int a, ti_int b, int *overflow);
+
+int test__muloti4(ti_int a, ti_int b, ti_int expected, int expected_overflow)
+{
+    int ov;
+    ti_int x = __muloti4(a, b, &ov);
+    if (ov != expected_overflow) {
+      twords at;
+      at.all = a;
+      twords bt;
+      bt.all = b;
+      twords xt;
+      xt.all = x;
+      twords expectedt;
+      expectedt.all = expected;
+
+      printf("error in __muloti4: overflow=%d expected=%d\n",
+	     ov, expected_overflow);
+      printf("error in __muloti4: 0x%.16llX%.16llX * 0x%.16llX%.16llX = "
+	     "0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+	     at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+	     expectedt.s.high, expectedt.s.low);
+      return 1;
+    }
+    else if (!expected_overflow && x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __muloti4: 0x%.16llX%.16llX * 0x%.16llX%.16llX = "
+               "0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+	return 1;
+    }
+    return 0;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__muloti4(0, 0, 0, 0))
+        return 1;
+    if (test__muloti4(0, 1, 0, 0))
+        return 1;
+    if (test__muloti4(1, 0, 0, 0))
+        return 1;
+    if (test__muloti4(0, 10, 0, 0))
+        return 1;
+    if (test__muloti4(10, 0, 0, 0))
+        return 1;
+    if (test__muloti4(0, 81985529216486895LL, 0, 0))
+        return 1;
+    if (test__muloti4(81985529216486895LL, 0, 0, 0))
+        return 1;
+
+    if (test__muloti4(0, -1, 0, 0))
+        return 1;
+    if (test__muloti4(-1, 0, 0, 0))
+        return 1;
+    if (test__muloti4(0, -10, 0, 0))
+        return 1;
+    if (test__muloti4(-10, 0, 0, 0))
+        return 1;
+    if (test__muloti4(0, -81985529216486895LL, 0, 0))
+        return 1;
+    if (test__muloti4(-81985529216486895LL, 0, 0, 0))
+        return 1;
+
+    if (test__muloti4(1, 1, 1, 0))
+        return 1;
+    if (test__muloti4(1, 10, 10, 0))
+        return 1;
+    if (test__muloti4(10, 1, 10, 0))
+        return 1;
+    if (test__muloti4(1, 81985529216486895LL, 81985529216486895LL, 0))
+        return 1;
+    if (test__muloti4(81985529216486895LL, 1, 81985529216486895LL, 0))
+        return 1;
+
+    if (test__muloti4(1, -1, -1, 0))
+        return 1;
+    if (test__muloti4(1, -10, -10, 0))
+        return 1;
+    if (test__muloti4(-10, 1, -10, 0))
+        return 1;
+    if (test__muloti4(1, -81985529216486895LL, -81985529216486895LL, 0))
+        return 1;
+    if (test__muloti4(-81985529216486895LL, 1, -81985529216486895LL, 0))
+        return 1;
+
+    if (test__muloti4(3037000499LL, 3037000499LL, 9223372030926249001LL, 0))
+        return 1;
+    if (test__muloti4(-3037000499LL, 3037000499LL, -9223372030926249001LL, 0))
+        return 1;
+    if (test__muloti4(3037000499LL, -3037000499LL, -9223372030926249001LL, 0))
+        return 1;
+    if (test__muloti4(-3037000499LL, -3037000499LL, 9223372030926249001LL, 0))
+        return 1;
+
+    if (test__muloti4(4398046511103LL, 2097152LL, 9223372036852678656LL, 0))
+        return 1;
+    if (test__muloti4(-4398046511103LL, 2097152LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__muloti4(4398046511103LL, -2097152LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__muloti4(-4398046511103LL, -2097152LL, 9223372036852678656LL, 0))
+        return 1;
+
+    if (test__muloti4(2097152LL, 4398046511103LL, 9223372036852678656LL, 0))
+        return 1;
+    if (test__muloti4(-2097152LL, 4398046511103LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__muloti4(2097152LL, -4398046511103LL, -9223372036852678656LL, 0))
+        return 1;
+    if (test__muloti4(-2097152LL, -4398046511103LL, 9223372036852678656LL, 0))
+        return 1;
+
+    if (test__muloti4(make_ti(0x00000000000000B5LL, 0x04F333F9DE5BE000LL),
+                      make_ti(0x0000000000000000LL, 0x00B504F333F9DE5BLL),
+                      make_ti(0x7FFFFFFFFFFFF328LL, 0xDF915DA296E8A000LL), 0))
+        return 1;
+
+     if (test__muloti4(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                       -2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL), 1))
+       return 1;
+     if (test__muloti4(-2,
+                       make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL), 1))
+         return 1;
+    if (test__muloti4(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      -1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL), 0))
+        return 1;
+    if (test__muloti4(-1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL), 0))
+        return 1;
+    if (test__muloti4(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      0,
+                      0, 0))
+        return 1;
+    if (test__muloti4(0,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      0, 0))
+        return 1;
+    if (test__muloti4(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), 0))
+        return 1;
+    if (test__muloti4(1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), 0))
+        return 1;
+     if (test__muloti4(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                       2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL), 1))
+         return 1;
+     if (test__muloti4(2,
+                       make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL), 1))
+         return 1;
+
+     if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                       -2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+     if (test__muloti4(-2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+     if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                       -1,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+     if (test__muloti4(-1,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+    if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      0,
+                      0, 0))
+        return 1;
+    if (test__muloti4(0,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      0, 0))
+        return 1;
+    if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL), 0))
+        return 1;
+    if (test__muloti4(1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL), 0))
+        return 1;
+     if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                       2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+     if (test__muloti4(2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+
+     if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                       -2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL), 1))
+         return 1;
+     if (test__muloti4(-2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL), 1))
+         return 1;
+    if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      -1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), 0))
+        return 1;
+    if (test__muloti4(-1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), 0))
+        return 1;
+    if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      0,
+                      0, 0))
+        return 1;
+    if (test__muloti4(0,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      0, 0))
+        return 1;
+    if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL), 0))
+        return 1;
+    if (test__muloti4(1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL), 0))
+        return 1;
+     if (test__muloti4(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                       2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+     if (test__muloti4(2,
+                       make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                       make_ti(0x8000000000000000LL, 0x0000000000000000LL), 1))
+         return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulsc3_test.c b/compiler-rt/test/builtins/Unit/mulsc3_test.c
new file mode 100644
index 0000000..eeb537a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulsc3_test.c
@@ -0,0 +1,371 @@
+//===-- mulsc3_test.c - Test __mulsc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulsc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+// Returns: the product of a + ib and c + id
+
+COMPILER_RT_ABI float _Complex
+__mulsc3(float __a, float __b, float __c, float __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(float _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(crealf(x)) || isinf(cimagf(x)))
+        return inf;
+    if (isnan(crealf(x)) && isnan(cimagf(x)))
+        return NaN;
+    if (isnan(crealf(x)))
+    {
+        if (cimagf(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimagf(x)))
+    {
+        if (crealf(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__mulsc3(float a, float b, float c, float d)
+{
+    float _Complex r = __mulsc3(a, b, c, d);
+//     printf("test__mulsc3(%f, %f, %f, %f) = %f + I%f\n",
+//             a, b, c, d, crealf(r), cimagf(r));
+	float _Complex dividend;
+	float _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            {
+            float _Complex z = a * c - b * d + _Complex_I*(a * d + b * c);
+            // relaxed tolerance to arbitrary (1.e-6) amount.
+            if (cabsf((r-z)/r) > 1.e-6)
+                return 1;
+            }
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+float x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+int main()
+{
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__mulsc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulsf3vfp_test.c b/compiler-rt/test/builtins/Unit/mulsf3vfp_test.c
new file mode 100644
index 0000000..5b0f6c1
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulsf3vfp_test.c
@@ -0,0 +1,51 @@
+//===-- mulsf3vfp_test.c - Test __mulsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __mulsf3vfp(float a, float b);
+
+#if __arm__
+int test__mulsf3vfp(float a, float b)
+{
+    float actual = __mulsf3vfp(a, b);
+    float expected = a * b;
+    if (actual != expected)
+        printf("error in test__mulsf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__mulsf3vfp(0.5, 10.0))
+        return 1;
+    if (test__mulsf3vfp(-0.5, -2.0))
+        return 1;
+    if (test__mulsf3vfp(HUGE_VALF, 0.25))
+        return 1;
+    if (test__mulsf3vfp(-0.125, HUGE_VALF))
+        return 1;
+    if (test__mulsf3vfp(0.0, -0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/multc3_test.c b/compiler-rt/test/builtins/Unit/multc3_test.c
new file mode 100644
index 0000000..f6cf4ca
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/multc3_test.c
@@ -0,0 +1,375 @@
+//===-- multc3_test.c - Test __multc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __multc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if _ARCH_PPC || __aarch64__
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+// Returns: the product of a + ib and c + id
+
+COMPILER_RT_ABI long double _Complex
+__multc3(long double __a, long double __b, long double __c, long double __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(long double _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(creall(x)) || isinf(cimagl(x)))
+        return inf;
+    if (isnan(creall(x)) && isnan(cimagl(x)))
+        return NaN;
+    if (isnan(creall(x)))
+    {
+        if (cimagl(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimagl(x)))
+    {
+        if (creall(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__multc3(long double a, long double b, long double c, long double d)
+{
+    long double _Complex r = __multc3(a, b, c, d);
+//     printf("test__multc3(%Lf, %Lf, %Lf, %Lf) = %Lf + I%Lf\n",
+//             a, b, c, d, creall(r), cimagl(r));
+	long double _Complex dividend;
+	long double _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            if (r != a * c - b * d + _Complex_I*(a * d + b * c))
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+long double x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+#endif
+
+int main()
+{
+#if _ARCH_PPC || __aarch64__
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__multc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/multf3_test.c b/compiler-rt/test/builtins/Unit/multf3_test.c
new file mode 100644
index 0000000..4214755
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/multf3_test.c
@@ -0,0 +1,95 @@
+//===--------------- multf3_test.c - Test __multf3 ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __multf3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: a * b
+COMPILER_RT_ABI long double __multf3(long double a, long double b);
+
+int test__multf3(long double a, long double b,
+                 uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __multf3(a, b);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__multf3(%.20Lf, %.20Lf) = %.20Lf, "
+               "expected %.20Lf\n", a, b, x,
+               fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN * any = qNaN
+    if (test__multf3(makeQNaN128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // NaN * any = NaN
+    if (test__multf3(makeNaN128(UINT64_C(0x800030000000)),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf * any = inf
+    if (test__multf3(makeInf128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any * any
+    if (test__multf3(0x1.2eab345678439abcdefea56782346p+5L,
+                     0x1.edcb34a235253948765432134674fp-1L,
+                     UINT64_C(0x400423e7f9e3c9fc),
+                     UINT64_C(0xd906c2c2a85777c4)))
+        return 1;
+    if (test__multf3(0x1.353e45674d89abacc3a2ebf3ff4ffp-50L,
+                     0x1.ed8764648369535adf4be3214567fp-9L,
+                     UINT64_C(0x3fc52a163c6223fc),
+                     UINT64_C(0xc94c4bf0430768b4)))
+        return 1;
+    if (test__multf3(0x1.234425696abcad34a35eeffefdcbap+456L,
+                     0x451.ed98d76e5d46e5f24323dff21ffp+600L,
+                     UINT64_C(0x44293a91de5e0e94),
+                     UINT64_C(0xe8ed17cc2cdf64ac)))
+        return 1;
+    if (test__multf3(0x1.4356473c82a9fabf2d22ace345defp-234L,
+                     0x1.eda98765476743ab21da23d45678fp-455L,
+                     UINT64_C(0x3d4f37c1a3137cae),
+                     UINT64_C(0xfc6807048bc2836a)))
+        return 1;
+    // underflow
+    if (test__multf3(0x1.23456734245345p-10000L,
+                     0x1.edcba524498724p-6497L,
+                     UINT64_C(0x0),
+                     UINT64_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/multi3_test.c b/compiler-rt/test/builtins/Unit/multi3_test.c
new file mode 100644
index 0000000..04b1b8a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/multi3_test.c
@@ -0,0 +1,134 @@
+//===-- multi3_test.c - Test __multi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __multi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+COMPILER_RT_ABI ti_int __multi3(ti_int a, ti_int b);
+
+int test__multi3(ti_int a, ti_int b, ti_int expected)
+{
+    ti_int x = __multi3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __multi3: 0x%.16llX%.16llX * 0x%.16llX%.16llX = "
+               "0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__multi3(0, 0, 0))
+        return 1;
+    if (test__multi3(0, 1, 0))
+        return 1;
+    if (test__multi3(1, 0, 0))
+        return 1;
+    if (test__multi3(0, 10, 0))
+        return 1;
+    if (test__multi3(10, 0, 0))
+        return 1;
+    if (test__multi3(0, 81985529216486895LL, 0))
+        return 1;
+    if (test__multi3(81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__multi3(0, -1, 0))
+        return 1;
+    if (test__multi3(-1, 0, 0))
+        return 1;
+    if (test__multi3(0, -10, 0))
+        return 1;
+    if (test__multi3(-10, 0, 0))
+        return 1;
+    if (test__multi3(0, -81985529216486895LL, 0))
+        return 1;
+    if (test__multi3(-81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__multi3(1, 1, 1))
+        return 1;
+    if (test__multi3(1, 10, 10))
+        return 1;
+    if (test__multi3(10, 1, 10))
+        return 1;
+    if (test__multi3(1, 81985529216486895LL, 81985529216486895LL))
+        return 1;
+    if (test__multi3(81985529216486895LL, 1, 81985529216486895LL))
+        return 1;
+
+    if (test__multi3(1, -1, -1))
+        return 1;
+    if (test__multi3(1, -10, -10))
+        return 1;
+    if (test__multi3(-10, 1, -10))
+        return 1;
+    if (test__multi3(1, -81985529216486895LL, -81985529216486895LL))
+        return 1;
+    if (test__multi3(-81985529216486895LL, 1, -81985529216486895LL))
+        return 1;
+
+    if (test__multi3(3037000499LL, 3037000499LL, 9223372030926249001LL))
+        return 1;
+    if (test__multi3(-3037000499LL, 3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__multi3(3037000499LL, -3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__multi3(-3037000499LL, -3037000499LL, 9223372030926249001LL))
+        return 1;
+
+    if (test__multi3(4398046511103LL, 2097152LL, 9223372036852678656LL))
+        return 1;
+    if (test__multi3(-4398046511103LL, 2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__multi3(4398046511103LL, -2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__multi3(-4398046511103LL, -2097152LL, 9223372036852678656LL))
+        return 1;
+
+    if (test__multi3(2097152LL, 4398046511103LL, 9223372036852678656LL))
+        return 1;
+    if (test__multi3(-2097152LL, 4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__multi3(2097152LL, -4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__multi3(-2097152LL, -4398046511103LL, 9223372036852678656LL))
+        return 1;
+
+    if (test__multi3(make_ti(0x00000000000000B5LL, 0x04F333F9DE5BE000LL),
+                     make_ti(0x0000000000000000LL, 0x00B504F333F9DE5BLL),
+                     make_ti(0x7FFFFFFFFFFFF328LL, 0xDF915DA296E8A000LL)))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulvdi3_test.c b/compiler-rt/test/builtins/Unit/mulvdi3_test.c
new file mode 100644
index 0000000..7f16c4c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulvdi3_test.c
@@ -0,0 +1,175 @@
+//===-- mulvdi3_test.c - Test __mulvdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulvdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a * b
+
+// Effects: aborts if a * b overflows
+
+COMPILER_RT_ABI di_int __mulvdi3(di_int a, di_int b);
+
+int test__mulvdi3(di_int a, di_int b, di_int expected)
+{
+    di_int x = __mulvdi3(a, b);
+    if (x != expected)
+        printf("error in __mulvdi3: %lld * %lld = %lld, expected %lld\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+    if (test__mulvdi3(0, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, 1, 0))
+        return 1;
+    if (test__mulvdi3(1, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, 10, 0))
+        return 1;
+    if (test__mulvdi3(10, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, 81985529216486895LL, 0))
+        return 1;
+    if (test__mulvdi3(81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__mulvdi3(0, -1, 0))
+        return 1;
+    if (test__mulvdi3(-1, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, -10, 0))
+        return 1;
+    if (test__mulvdi3(-10, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, -81985529216486895LL, 0))
+        return 1;
+    if (test__mulvdi3(-81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__mulvdi3(1, 1, 1))
+        return 1;
+    if (test__mulvdi3(1, 10, 10))
+        return 1;
+    if (test__mulvdi3(10, 1, 10))
+        return 1;
+    if (test__mulvdi3(1, 81985529216486895LL, 81985529216486895LL))
+        return 1;
+    if (test__mulvdi3(81985529216486895LL, 1, 81985529216486895LL))
+        return 1;
+
+    if (test__mulvdi3(1, -1, -1))
+        return 1;
+    if (test__mulvdi3(1, -10, -10))
+        return 1;
+    if (test__mulvdi3(-10, 1, -10))
+        return 1;
+    if (test__mulvdi3(1, -81985529216486895LL, -81985529216486895LL))
+        return 1;
+    if (test__mulvdi3(-81985529216486895LL, 1, -81985529216486895LL))
+        return 1;
+
+    if (test__mulvdi3(3037000499LL, 3037000499LL, 9223372030926249001LL))
+        return 1;
+    if (test__mulvdi3(-3037000499LL, 3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__mulvdi3(3037000499LL, -3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__mulvdi3(-3037000499LL, -3037000499LL, 9223372030926249001LL))
+        return 1;
+
+    if (test__mulvdi3(4398046511103LL, 2097152LL, 9223372036852678656LL))
+        return 1;
+    if (test__mulvdi3(-4398046511103LL, 2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvdi3(4398046511103LL, -2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvdi3(-4398046511103LL, -2097152LL, 9223372036852678656LL))
+        return 1;
+
+    if (test__mulvdi3(2097152LL, 4398046511103LL, 9223372036852678656LL))
+        return 1;
+    if (test__mulvdi3(-2097152LL, 4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvdi3(2097152LL, -4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvdi3(-2097152LL, -4398046511103LL, 9223372036852678656LL))
+        return 1;
+
+//     if (test__mulvdi3(0x7FFFFFFFFFFFFFFFLL, -2, 0x8000000000000001LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(-2, 0x7FFFFFFFFFFFFFFFLL, 0x8000000000000001LL))  // abort
+//         return 1;
+    if (test__mulvdi3(0x7FFFFFFFFFFFFFFFLL, -1, 0x8000000000000001LL))
+        return 1;
+    if (test__mulvdi3(-1, 0x7FFFFFFFFFFFFFFFLL, 0x8000000000000001LL))
+        return 1;
+    if (test__mulvdi3(0x7FFFFFFFFFFFFFFFLL, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, 0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+    if (test__mulvdi3(0x7FFFFFFFFFFFFFFFLL, 1, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__mulvdi3(1, 0x7FFFFFFFFFFFFFFFLL, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+//     if (test__mulvdi3(0x7FFFFFFFFFFFFFFFLL, 2, 0x8000000000000001LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(2, 0x7FFFFFFFFFFFFFFFLL, 0x8000000000000001LL))  // abort
+//         return 1;
+
+//     if (test__mulvdi3(0x8000000000000000LL, -2, 0x8000000000000000LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(-2, 0x8000000000000000LL, 0x8000000000000000LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(0x8000000000000000LL, -1, 0x8000000000000000LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(-1, 0x8000000000000000LL, 0x8000000000000000LL))  // abort
+//         return 1;
+    if (test__mulvdi3(0x8000000000000000LL, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, 0x8000000000000000LL, 0))
+        return 1;
+    if (test__mulvdi3(0x8000000000000000LL, 1, 0x8000000000000000LL))
+        return 1;
+    if (test__mulvdi3(1, 0x8000000000000000LL, 0x8000000000000000LL))
+        return 1;
+//     if (test__mulvdi3(0x8000000000000000LL, 2, 0x8000000000000000LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(2, 0x8000000000000000LL, 0x8000000000000000LL))  // abort
+//         return 1;
+
+//     if (test__mulvdi3(0x8000000000000001LL, -2, 0x8000000000000001LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(-2, 0x8000000000000001LL, 0x8000000000000001LL))  // abort
+//         return 1;
+    if (test__mulvdi3(0x8000000000000001LL, -1, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__mulvdi3(-1, 0x8000000000000001LL, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__mulvdi3(0x8000000000000001LL, 0, 0))
+        return 1;
+    if (test__mulvdi3(0, 0x8000000000000001LL, 0))
+        return 1;
+    if (test__mulvdi3(0x8000000000000001LL, 1, 0x8000000000000001LL))
+        return 1;
+    if (test__mulvdi3(1, 0x8000000000000001LL, 0x8000000000000001LL))
+        return 1;
+//     if (test__mulvdi3(0x8000000000000001LL, 2, 0x8000000000000000LL))  // abort
+//         return 1;
+//     if (test__mulvdi3(2, 0x8000000000000001LL, 0x8000000000000000LL))  // abort
+//         return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulvsi3_test.c b/compiler-rt/test/builtins/Unit/mulvsi3_test.c
new file mode 100644
index 0000000..64df4fe
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulvsi3_test.c
@@ -0,0 +1,148 @@
+//===-- mulvsi3_test.c - Test __mulvsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulvsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a * b
+
+// Effects: aborts if a * b overflows
+
+COMPILER_RT_ABI si_int __mulvsi3(si_int a, si_int b);
+
+int test__mulvsi3(si_int a, si_int b, si_int expected)
+{
+    si_int x = __mulvsi3(a, b);
+    if (x != expected)
+        printf("error in __mulvsi3: %d * %d = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+    if (test__mulvsi3(0, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, 1, 0))
+        return 1;
+    if (test__mulvsi3(1, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, 10, 0))
+        return 1;
+    if (test__mulvsi3(10, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, 0x1234567, 0))
+        return 1;
+    if (test__mulvsi3(0x1234567, 0, 0))
+        return 1;
+
+    if (test__mulvsi3(0, -1, 0))
+        return 1;
+    if (test__mulvsi3(-1, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, -10, 0))
+        return 1;
+    if (test__mulvsi3(-10, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, -0x1234567, 0))
+        return 1;
+    if (test__mulvsi3(-0x1234567, 0, 0))
+        return 1;
+
+    if (test__mulvsi3(1, 1, 1))
+        return 1;
+    if (test__mulvsi3(1, 10, 10))
+        return 1;
+    if (test__mulvsi3(10, 1, 10))
+        return 1;
+    if (test__mulvsi3(1, 0x1234567, 0x1234567))
+        return 1;
+    if (test__mulvsi3(0x1234567, 1, 0x1234567))
+        return 1;
+
+    if (test__mulvsi3(1, -1, -1))
+        return 1;
+    if (test__mulvsi3(1, -10, -10))
+        return 1;
+    if (test__mulvsi3(-10, 1, -10))
+        return 1;
+    if (test__mulvsi3(1, -0x1234567, -0x1234567))
+        return 1;
+    if (test__mulvsi3(-0x1234567, 1, -0x1234567))
+        return 1;
+
+//     if (test__mulvsi3(0x7FFFFFFF, -2, 0x80000001))  // abort
+//         return 1;
+//     if (test__mulvsi3(-2, 0x7FFFFFFF, 0x80000001))  // abort
+//         return 1;
+    if (test__mulvsi3(0x7FFFFFFF, -1, 0x80000001))
+        return 1;
+    if (test__mulvsi3(-1, 0x7FFFFFFF, 0x80000001))
+        return 1;
+    if (test__mulvsi3(0x7FFFFFFF, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, 0x7FFFFFFF, 0))
+        return 1;
+    if (test__mulvsi3(0x7FFFFFFF, 1, 0x7FFFFFFF))
+        return 1;
+    if (test__mulvsi3(1, 0x7FFFFFFF, 0x7FFFFFFF))
+        return 1;
+//     if (test__mulvsi3(0x7FFFFFFF, 2, 0x80000001))  // abort
+//         return 1;
+//     if (test__mulvsi3(2, 0x7FFFFFFF, 0x80000001))  // abort
+//         return 1;
+
+//     if (test__mulvsi3(0x80000000, -2, 0x80000000))  // abort
+//         return 1;
+//     if (test__mulvsi3(-2, 0x80000000, 0x80000000))  // abort
+//         return 1;
+//     if (test__mulvsi3(0x80000000, -1, 0x80000000))  // abort
+//         return 1;
+//     if (test__mulvsi3(-1, 0x80000000, 0x80000000))  // abort
+//         return 1;
+    if (test__mulvsi3(0x80000000, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, 0x80000000, 0))
+        return 1;
+    if (test__mulvsi3(0x80000000, 1, 0x80000000))
+        return 1;
+    if (test__mulvsi3(1, 0x80000000, 0x80000000))
+        return 1;
+//     if (test__mulvsi3(0x80000000, 2, 0x80000000))  // abort
+//         return 1;
+//     if (test__mulvsi3(2, 0x80000000, 0x80000000))  // abort
+//         return 1;
+
+//     if (test__mulvsi3(0x80000001, -2, 0x80000001))  // abort
+//         return 1;
+//     if (test__mulvsi3(-2, 0x80000001, 0x80000001))  // abort
+//         return 1;
+    if (test__mulvsi3(0x80000001, -1, 0x7FFFFFFF))
+        return 1;
+    if (test__mulvsi3(-1, 0x80000001, 0x7FFFFFFF))
+        return 1;
+    if (test__mulvsi3(0x80000001, 0, 0))
+        return 1;
+    if (test__mulvsi3(0, 0x80000001, 0))
+        return 1;
+    if (test__mulvsi3(0x80000001, 1, 0x80000001))
+        return 1;
+    if (test__mulvsi3(1, 0x80000001, 0x80000001))
+        return 1;
+//     if (test__mulvsi3(0x80000001, 2, 0x80000000))  // abort
+//         return 1;
+//     if (test__mulvsi3(2, 0x80000001, 0x80000000))  // abort
+//         return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulvti3_test.c b/compiler-rt/test/builtins/Unit/mulvti3_test.c
new file mode 100644
index 0000000..bf2f731
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulvti3_test.c
@@ -0,0 +1,260 @@
+//===-- mulvti3_test.c - Test __mulvti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulvti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a * b
+
+// Effects: aborts if a * b overflows
+
+COMPILER_RT_ABI ti_int __mulvti3(ti_int a, ti_int b);
+
+int test__mulvti3(ti_int a, ti_int b, ti_int expected)
+{
+    ti_int x = __mulvti3(a, b);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __mulvti3: 0x%.16llX%.16llX * 0x%.16llX%.16llX = "
+               "0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__mulvti3(0, 0, 0))
+        return 1;
+    if (test__mulvti3(0, 1, 0))
+        return 1;
+    if (test__mulvti3(1, 0, 0))
+        return 1;
+    if (test__mulvti3(0, 10, 0))
+        return 1;
+    if (test__mulvti3(10, 0, 0))
+        return 1;
+    if (test__mulvti3(0, 81985529216486895LL, 0))
+        return 1;
+    if (test__mulvti3(81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__mulvti3(0, -1, 0))
+        return 1;
+    if (test__mulvti3(-1, 0, 0))
+        return 1;
+    if (test__mulvti3(0, -10, 0))
+        return 1;
+    if (test__mulvti3(-10, 0, 0))
+        return 1;
+    if (test__mulvti3(0, -81985529216486895LL, 0))
+        return 1;
+    if (test__mulvti3(-81985529216486895LL, 0, 0))
+        return 1;
+
+    if (test__mulvti3(1, 1, 1))
+        return 1;
+    if (test__mulvti3(1, 10, 10))
+        return 1;
+    if (test__mulvti3(10, 1, 10))
+        return 1;
+    if (test__mulvti3(1, 81985529216486895LL, 81985529216486895LL))
+        return 1;
+    if (test__mulvti3(81985529216486895LL, 1, 81985529216486895LL))
+        return 1;
+
+    if (test__mulvti3(1, -1, -1))
+        return 1;
+    if (test__mulvti3(1, -10, -10))
+        return 1;
+    if (test__mulvti3(-10, 1, -10))
+        return 1;
+    if (test__mulvti3(1, -81985529216486895LL, -81985529216486895LL))
+        return 1;
+    if (test__mulvti3(-81985529216486895LL, 1, -81985529216486895LL))
+        return 1;
+
+    if (test__mulvti3(3037000499LL, 3037000499LL, 9223372030926249001LL))
+        return 1;
+    if (test__mulvti3(-3037000499LL, 3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__mulvti3(3037000499LL, -3037000499LL, -9223372030926249001LL))
+        return 1;
+    if (test__mulvti3(-3037000499LL, -3037000499LL, 9223372030926249001LL))
+        return 1;
+
+    if (test__mulvti3(4398046511103LL, 2097152LL, 9223372036852678656LL))
+        return 1;
+    if (test__mulvti3(-4398046511103LL, 2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvti3(4398046511103LL, -2097152LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvti3(-4398046511103LL, -2097152LL, 9223372036852678656LL))
+        return 1;
+
+    if (test__mulvti3(2097152LL, 4398046511103LL, 9223372036852678656LL))
+        return 1;
+    if (test__mulvti3(-2097152LL, 4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvti3(2097152LL, -4398046511103LL, -9223372036852678656LL))
+        return 1;
+    if (test__mulvti3(-2097152LL, -4398046511103LL, 9223372036852678656LL))
+        return 1;
+
+    if (test__mulvti3(make_ti(0x00000000000000B5LL, 0x04F333F9DE5BE000LL),
+                      make_ti(0x0000000000000000LL, 0x00B504F333F9DE5BLL),
+                      make_ti(0x7FFFFFFFFFFFF328LL, 0xDF915DA296E8A000LL)))
+        return 1;
+
+//     if (test__mulvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+//                       -2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(-2,
+//                       make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL)))  // abort
+//         return 1;
+    if (test__mulvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      -1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+    if (test__mulvti3(-1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+    if (test__mulvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      0,
+                      0))
+        return 1;
+    if (test__mulvti3(0,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      0))
+        return 1;
+    if (test__mulvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__mulvti3(1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+//     if (test__mulvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+//                       2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(2,
+//                       make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL)))  // abort
+//         return 1;
+
+//     if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                       -2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(-2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                       -1,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(-1,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+    if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      0,
+                      0))
+        return 1;
+    if (test__mulvti3(0,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      0))
+        return 1;
+    if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__mulvti3(1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+//     if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                       2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+
+//     if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+//                       -2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(-2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL)))  // abort
+//         return 1;
+    if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      -1,
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__mulvti3(-1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      0,
+                      0))
+        return 1;
+    if (test__mulvti3(0,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      0))
+        return 1;
+    if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+    if (test__mulvti3(1,
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                      make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+//     if (test__mulvti3(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+//                       2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+//     if (test__mulvti3(2,
+//                       make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+//                       make_ti(0x8000000000000000LL, 0x0000000000000000LL)))  // abort
+//         return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/mulxc3_test.c b/compiler-rt/test/builtins/Unit/mulxc3_test.c
new file mode 100644
index 0000000..e77e94f
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/mulxc3_test.c
@@ -0,0 +1,375 @@
+//===-- mulxc3_test.c - Test __mulxc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulxc3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+#include <stdio.h>
+
+// Returns: the product of a + ib and c + id
+
+COMPILER_RT_ABI long double _Complex
+__mulxc3(long double __a, long double __b, long double __c, long double __d);
+
+enum {zero, non_zero, inf, NaN, non_zero_nan};
+
+int
+classify(long double _Complex x)
+{
+    if (x == 0)
+        return zero;
+    if (isinf(creall(x)) || isinf(cimagl(x)))
+        return inf;
+    if (isnan(creall(x)) && isnan(cimagl(x)))
+        return NaN;
+    if (isnan(creall(x)))
+    {
+        if (cimagl(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    if (isnan(cimagl(x)))
+    {
+        if (creall(x) == 0)
+            return NaN;
+        return non_zero_nan;
+    }
+    return non_zero;
+}
+
+int test__mulxc3(long double a, long double b, long double c, long double d)
+{
+    long double _Complex r = __mulxc3(a, b, c, d);
+//     printf("test__mulxc3(%Lf, %Lf, %Lf, %Lf) = %Lf + I%Lf\n",
+//             a, b, c, d, creall(r), cimagl(r));
+	long double _Complex dividend;
+	long double _Complex divisor;
+	
+	__real__ dividend = a;
+	__imag__ dividend = b;
+	__real__ divisor = c;
+	__imag__ divisor = d;
+	
+    switch (classify(dividend))
+    {
+    case zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != zero)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != non_zero)
+                return 1;
+            if (r != a * c - b * d + _Complex_I*(a * d + b * c))
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case inf:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        }
+        break;
+    case NaN:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    case non_zero_nan:
+        switch (classify(divisor))
+        {
+        case zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case inf:
+            if (classify(r) != inf)
+                return 1;
+            break;
+        case NaN:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        case non_zero_nan:
+            if (classify(r) != NaN)
+                return 1;
+            break;
+        }
+        break;
+    }
+    
+    return 0;
+}
+
+long double x[][2] =
+{
+    { 1.e-6,  1.e-6},
+    {-1.e-6,  1.e-6},
+    {-1.e-6, -1.e-6},
+    { 1.e-6, -1.e-6},
+
+    { 1.e+6,  1.e-6},
+    {-1.e+6,  1.e-6},
+    {-1.e+6, -1.e-6},
+    { 1.e+6, -1.e-6},
+
+    { 1.e-6,  1.e+6},
+    {-1.e-6,  1.e+6},
+    {-1.e-6, -1.e+6},
+    { 1.e-6, -1.e+6},
+
+    { 1.e+6,  1.e+6},
+    {-1.e+6,  1.e+6},
+    {-1.e+6, -1.e+6},
+    { 1.e+6, -1.e+6},
+
+    {NAN, NAN},
+    {-INFINITY, NAN},
+    {-2, NAN},
+    {-1, NAN},
+    {-0.5, NAN},
+    {-0., NAN},
+    {+0., NAN},
+    {0.5, NAN},
+    {1, NAN},
+    {2, NAN},
+    {INFINITY, NAN},
+
+    {NAN, -INFINITY},
+    {-INFINITY, -INFINITY},
+    {-2, -INFINITY},
+    {-1, -INFINITY},
+    {-0.5, -INFINITY},
+    {-0., -INFINITY},
+    {+0., -INFINITY},
+    {0.5, -INFINITY},
+    {1, -INFINITY},
+    {2, -INFINITY},
+    {INFINITY, -INFINITY},
+
+    {NAN, -2},
+    {-INFINITY, -2},
+    {-2, -2},
+    {-1, -2},
+    {-0.5, -2},
+    {-0., -2},
+    {+0., -2},
+    {0.5, -2},
+    {1, -2},
+    {2, -2},
+    {INFINITY, -2},
+
+    {NAN, -1},
+    {-INFINITY, -1},
+    {-2, -1},
+    {-1, -1},
+    {-0.5, -1},
+    {-0., -1},
+    {+0., -1},
+    {0.5, -1},
+    {1, -1},
+    {2, -1},
+    {INFINITY, -1},
+
+    {NAN, -0.5},
+    {-INFINITY, -0.5},
+    {-2, -0.5},
+    {-1, -0.5},
+    {-0.5, -0.5},
+    {-0., -0.5},
+    {+0., -0.5},
+    {0.5, -0.5},
+    {1, -0.5},
+    {2, -0.5},
+    {INFINITY, -0.5},
+
+    {NAN, -0.},
+    {-INFINITY, -0.},
+    {-2, -0.},
+    {-1, -0.},
+    {-0.5, -0.},
+    {-0., -0.},
+    {+0., -0.},
+    {0.5, -0.},
+    {1, -0.},
+    {2, -0.},
+    {INFINITY, -0.},
+
+    {NAN, 0.},
+    {-INFINITY, 0.},
+    {-2, 0.},
+    {-1, 0.},
+    {-0.5, 0.},
+    {-0., 0.},
+    {+0., 0.},
+    {0.5, 0.},
+    {1, 0.},
+    {2, 0.},
+    {INFINITY, 0.},
+
+    {NAN, 0.5},
+    {-INFINITY, 0.5},
+    {-2, 0.5},
+    {-1, 0.5},
+    {-0.5, 0.5},
+    {-0., 0.5},
+    {+0., 0.5},
+    {0.5, 0.5},
+    {1, 0.5},
+    {2, 0.5},
+    {INFINITY, 0.5},
+
+    {NAN, 1},
+    {-INFINITY, 1},
+    {-2, 1},
+    {-1, 1},
+    {-0.5, 1},
+    {-0., 1},
+    {+0., 1},
+    {0.5, 1},
+    {1, 1},
+    {2, 1},
+    {INFINITY, 1},
+
+    {NAN, 2},
+    {-INFINITY, 2},
+    {-2, 2},
+    {-1, 2},
+    {-0.5, 2},
+    {-0., 2},
+    {+0., 2},
+    {0.5, 2},
+    {1, 2},
+    {2, 2},
+    {INFINITY, 2},
+
+    {NAN, INFINITY},
+    {-INFINITY, INFINITY},
+    {-2, INFINITY},
+    {-1, INFINITY},
+    {-0.5, INFINITY},
+    {-0., INFINITY},
+    {+0., INFINITY},
+    {0.5, INFINITY},
+    {1, INFINITY},
+    {2, INFINITY},
+    {INFINITY, INFINITY}
+
+};
+
+#endif
+
+int main()
+{
+#if !_ARCH_PPC
+    const unsigned N = sizeof(x) / sizeof(x[0]);
+    unsigned i, j;
+    for (i = 0; i < N; ++i)
+    {
+        for (j = 0; j < N; ++j)
+        {
+            if (test__mulxc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/nedf2vfp_test.c b/compiler-rt/test/builtins/Unit/nedf2vfp_test.c
new file mode 100644
index 0000000..2c44043
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/nedf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- nedf2vfp_test.c - Test __nedf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __nedf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __nedf2vfp(double a, double b);
+
+#if __arm__
+int test__nedf2vfp(double a, double b)
+{
+    int actual = __nedf2vfp(a, b);
+	int expected = (a != b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __nedf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__nedf2vfp(0.0, 0.0))
+        return 1;
+    if (test__nedf2vfp(1.0, 1.0))
+        return 1;
+    if (test__nedf2vfp(-1.0, -1.0))
+        return 1;
+    if (test__nedf2vfp(HUGE_VAL, 1.0))
+        return 1;
+    if (test__nedf2vfp(1.0, HUGE_VAL))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negdf2vfp_test.c b/compiler-rt/test/builtins/Unit/negdf2vfp_test.c
new file mode 100644
index 0000000..f0e6677
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negdf2vfp_test.c
@@ -0,0 +1,48 @@
+//===-- negdf2vfp_test.c - Test __negdf2vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI double __negdf2vfp(double a);
+
+#if __arm__
+int test__negdf2vfp(double a)
+{
+    double actual = __negdf2vfp(a);
+    double expected = -a;
+    if (actual != expected)
+        printf("error in test__negdf2vfp(%f) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__negdf2vfp(1.0))
+        return 1;
+    if (test__negdf2vfp(HUGE_VALF))
+        return 1;
+    if (test__negdf2vfp(0.0))
+        return 1;
+    if (test__negdf2vfp(-1.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negdi2_test.c b/compiler-rt/test/builtins/Unit/negdi2_test.c
new file mode 100644
index 0000000..beccd71
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negdi2_test.c
@@ -0,0 +1,84 @@
+//===-- negdi2_test.c - Test __negdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: -a
+
+COMPILER_RT_ABI di_int __negdi2(di_int a);
+
+int test__negdi2(di_int a, di_int expected)
+{
+    di_int x = __negdi2(a);
+    if (x != expected)
+        printf("error in __negdi2: -0x%llX = 0x%llX, expected 0x%llX\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+int main()
+{
+    if (test__negdi2(0, 0))
+        return 1;
+    if (test__negdi2(1, -1))
+        return 1;
+    if (test__negdi2(-1, 1))
+        return 1;
+    if (test__negdi2(2, -2))
+        return 1;
+    if (test__negdi2(-2, 2))
+        return 1;
+    if (test__negdi2(3, -3))
+        return 1;
+    if (test__negdi2(-3, 3))
+        return 1;
+    if (test__negdi2(0x00000000FFFFFFFELL, 0xFFFFFFFF00000002LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFF00000002LL, 0x00000000FFFFFFFELL))
+        return 1;
+    if (test__negdi2(0x00000000FFFFFFFFLL, 0xFFFFFFFF00000001LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFF00000001LL, 0x00000000FFFFFFFFLL))
+        return 1;
+    if (test__negdi2(0x0000000100000000LL, 0xFFFFFFFF00000000LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFF00000000LL, 0x0000000100000000LL))
+        return 1;
+    if (test__negdi2(0x0000000200000000LL, 0xFFFFFFFE00000000LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFE00000000LL, 0x0000000200000000LL))
+        return 1;
+    if (test__negdi2(0x0000000300000000LL, 0xFFFFFFFD00000000LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFD00000000LL, 0x0000000300000000LL))
+        return 1;
+    if (test__negdi2(0x8000000000000000LL, 0x8000000000000000LL))
+        return 1;
+    if (test__negdi2(0x8000000000000001LL, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__negdi2(0x7FFFFFFFFFFFFFFFLL, 0x8000000000000001LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFE00000000LL, 0x0000000200000000LL))
+        return 1;
+    if (test__negdi2(0x0000000200000000LL, 0xFFFFFFFE00000000LL))
+        return 1;
+    if (test__negdi2(0xFFFFFFFF00000000LL, 0x0000000100000000LL))
+        return 1;
+    if (test__negdi2(0x0000000100000000LL, 0xFFFFFFFF00000000LL))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negsf2vfp_test.c b/compiler-rt/test/builtins/Unit/negsf2vfp_test.c
new file mode 100644
index 0000000..9e47d89
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negsf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- negsf2vfp_test.c - Test __negsf2vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __negsf2vfp(float a);
+
+#if __arm__
+int test__negsf2vfp(float a)
+{
+    float actual = __negsf2vfp(a);
+    float expected = -a;
+    if (actual != expected)
+        printf("error in test__negsf2vfp(%f) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__negsf2vfp(1.0))
+        return 1;
+    if (test__negsf2vfp(HUGE_VALF))
+        return 1;
+    if (test__negsf2vfp(0.0))
+        return 1;
+    if (test__negsf2vfp(-1.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negti2_test.c b/compiler-rt/test/builtins/Unit/negti2_test.c
new file mode 100644
index 0000000..b075978
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negti2_test.c
@@ -0,0 +1,127 @@
+//===-- negti2_test.c - Test __negti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: -a
+
+COMPILER_RT_ABI ti_int __negti2(ti_int a);
+
+int test__negti2(ti_int a, ti_int expected)
+{
+    ti_int x = __negti2(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __negti2: -0x%.16llX%.16llX = 0x%.16llX%.16llX, "
+               "expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__negti2(0, 0))
+        return 1;
+    if (test__negti2(1, -1))
+        return 1;
+    if (test__negti2(-1, 1))
+        return 1;
+    if (test__negti2(2, -2))
+        return 1;
+    if (test__negti2(-2, 2))
+        return 1;
+    if (test__negti2(3, -3))
+        return 1;
+    if (test__negti2(-3, 3))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x00000000FFFFFFFELL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000002LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000002LL),
+                     make_ti(0x0000000000000000LL, 0x00000000FFFFFFFELL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x00000000FFFFFFFFLL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000001LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000001LL),
+                     make_ti(0x0000000000000000LL, 0x00000000FFFFFFFFLL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x0000000100000000LL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000000LL),
+                     make_ti(0x0000000000000000LL, 0x0000000100000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x0000000200000000LL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFE00000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFE00000000LL),
+                     make_ti(0x0000000000000000LL, 0x0000000200000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x0000000300000000LL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFD00000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFD00000000LL),
+                     make_ti(0x0000000000000000LL, 0x0000000300000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x7FFFFFFFFFFFFFFFLL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000000000000001LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000000000000001LL),
+                     make_ti(0x0000000000000000LL, 0x7FFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x7FFFFFFFFFFFFFFFLL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000000000000001LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFE00000000LL),
+                     make_ti(0x0000000000000000LL, 0x0000000200000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x0000000200000000LL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFE00000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000000LL),
+                     make_ti(0x0000000000000000LL, 0x0000000100000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x0000000000000000LL, 0x0000000100000000LL),
+                     make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x8000000000000000LL, 0x0000000000000000LL),
+                     make_ti(0x8000000000000000LL, 0x0000000000000000LL)))
+        return 1;
+    if (test__negti2(make_ti(0x8000000000000000LL, 0x0000000000000001LL),
+                     make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__negti2(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL),
+                     make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negvdi2_test.c b/compiler-rt/test/builtins/Unit/negvdi2_test.c
new file mode 100644
index 0000000..5c202e5
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negvdi2_test.c
@@ -0,0 +1,57 @@
+//===-- negvdi2_test.c - Test __negvdi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negvdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: -a
+
+// Effects: aborts if -a overflows
+
+COMPILER_RT_ABI di_int __negvdi2(di_int a);
+
+int test__negvdi2(di_int a)
+{
+    di_int x = __negvdi2(a);
+    di_int expected = -a;
+    if (x != expected)
+        printf("error in __negvdi2(0x%llX) = %lld, expected %lld\n",
+               a, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     if (test__negvdi2(0x8000000000000000LL))  // should abort
+//         return 1;
+    if (test__negvdi2(0x0000000000000000LL))
+        return 1;
+    if (test__negvdi2(0x0000000000000001LL))
+        return 1;
+    if (test__negvdi2(0x0000000000000002LL))
+        return 1;
+    if (test__negvdi2(0x7FFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__negvdi2(0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__negvdi2(0x8000000000000001LL))
+        return 1;
+    if (test__negvdi2(0x8000000000000002LL))
+        return 1;
+    if (test__negvdi2(0xFFFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__negvdi2(0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negvsi2_test.c b/compiler-rt/test/builtins/Unit/negvsi2_test.c
new file mode 100644
index 0000000..6330803
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negvsi2_test.c
@@ -0,0 +1,56 @@
+//===-- negvsi2_test.c - Test __negvsi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negvsi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: -a
+
+// Effects: aborts if -a overflows
+
+COMPILER_RT_ABI si_int __negvsi2(si_int a);
+
+int test__negvsi2(si_int a)
+{
+    si_int x = __negvsi2(a);
+    si_int expected = -a;
+    if (x != expected)
+        printf("error in __negvsi2(0x%X) = %d, expected %d\n", a, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     if (test__negvsi2(0x80000000))  // should abort
+//         return 1;
+    if (test__negvsi2(0x00000000))
+        return 1;
+    if (test__negvsi2(0x00000001))
+        return 1;
+    if (test__negvsi2(0x00000002))
+        return 1;
+    if (test__negvsi2(0x7FFFFFFE))
+        return 1;
+    if (test__negvsi2(0x7FFFFFFF))
+        return 1;
+    if (test__negvsi2(0x80000001))
+        return 1;
+    if (test__negvsi2(0x80000002))
+        return 1;
+    if (test__negvsi2(0xFFFFFFFE))
+        return 1;
+    if (test__negvsi2(0xFFFFFFFF))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/negvti2_test.c b/compiler-rt/test/builtins/Unit/negvti2_test.c
new file mode 100644
index 0000000..005f8a8
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/negvti2_test.c
@@ -0,0 +1,109 @@
+//===-- negvti2_test.c - Test __negvti2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negvti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: -a
+
+// Effects: aborts if -a overflows
+
+COMPILER_RT_ABI ti_int __negvti2(ti_int a);
+COMPILER_RT_ABI ti_int __negti2(ti_int a);
+
+int test__negvti2(ti_int a)
+{
+    ti_int x = __negvti2(a);
+    ti_int expected = __negti2(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in __negvti2(0x%.16llX%.16llX) = 0x%.16llX%.16llX, "
+               "expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__negvti2(0))
+        return 1;
+    if (test__negvti2(1))
+        return 1;
+    if (test__negvti2(-1))
+        return 1;
+    if (test__negvti2(2))
+        return 1;
+    if (test__negvti2(-2))
+        return 1;
+    if (test__negvti2(3))
+        return 1;
+    if (test__negvti2(-3))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x00000000FFFFFFFELL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000002LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x00000000FFFFFFFFLL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000001LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x0000000100000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x0000000200000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFE00000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x0000000300000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFD00000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x7FFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0x8000000000000001LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x7FFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFE00000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x0000000200000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFF00000000LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x0000000000000000LL, 0x0000000100000000LL)))
+        return 1;
+//     if (test__negvti2(make_ti(0x8000000000000000LL, 0x0000000000000000LL))) // abort
+//         return 1;
+    if (test__negvti2(make_ti(0x8000000000000000LL, 0x0000000000000001LL)))
+        return 1;
+    if (test__negvti2(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/nesf2vfp_test.c b/compiler-rt/test/builtins/Unit/nesf2vfp_test.c
new file mode 100644
index 0000000..c085bf8
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/nesf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- nesf2vfp_test.c - Test __nesf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __nesf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __nesf2vfp(float a, float b);
+
+#if __arm__
+int test__nesf2vfp(float a, float b)
+{
+    int actual = __nesf2vfp(a, b);
+	int expected = (a != b) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __nesf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__nesf2vfp(0.0, 0.0))
+        return 1;
+    if (test__nesf2vfp(1.0, 1.0))
+        return 1;
+    if (test__nesf2vfp(-1.0, -1.0))
+        return 1;
+    if (test__nesf2vfp(HUGE_VALF, 1.0))
+        return 1;
+    if (test__nesf2vfp(1.0, HUGE_VALF))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/netf2_test.c b/compiler-rt/test/builtins/Unit/netf2_test.c
new file mode 100644
index 0000000..bbd953a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/netf2_test.c
@@ -0,0 +1,89 @@
+//===------------ netf2_test.c - Test __netf2------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __netf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __netf2(long double a, long double b);
+
+int test__netf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __netf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__netf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__netf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__netf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__netf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // ==
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__netf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/paritydi2_test.c b/compiler-rt/test/builtins/Unit/paritydi2_test.c
new file mode 100644
index 0000000..98220bd
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/paritydi2_test.c
@@ -0,0 +1,51 @@
+//===-- paritydi2_test.c - Test __paritydi2 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __paritydi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: 1 if number of bits is odd else returns 0
+
+COMPILER_RT_ABI si_int __paritydi2(di_int a);
+
+int naive_parity(di_int a)
+{
+    int r = 0;
+    for (; a; a = a & (a - 1))
+        r = ~r;
+    return r & 1;
+}
+
+int test__paritydi2(di_int a)
+{
+    si_int x = __paritydi2(a);
+    si_int expected = naive_parity(a);
+    if (x != expected)
+        printf("error in __paritydi2(0x%llX) = %d, expected %d\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__paritydi2(((di_int)rand() << 32) + rand()))
+            return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/paritysi2_test.c b/compiler-rt/test/builtins/Unit/paritysi2_test.c
new file mode 100644
index 0000000..175aeb2
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/paritysi2_test.c
@@ -0,0 +1,50 @@
+//===-- paritysi2_test.c - Test __paritysi2 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __paritysi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: 1 if number of bits is odd else returns 0
+
+COMPILER_RT_ABI si_int __paritysi2(si_int a);
+
+int naive_parity(si_int a)
+{
+    int r = 0;
+    for (; a; a = a & (a - 1))
+        r = ~r;
+    return r & 1;
+}
+
+int test__paritysi2(si_int a)
+{
+    si_int x = __paritysi2(a);
+    si_int expected = naive_parity(a);
+    if (x != expected)
+        printf("error in __paritysi2(0x%X) = %d, expected %d\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__paritysi2(rand()))
+            return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/parityti2_test.c b/compiler-rt/test/builtins/Unit/parityti2_test.c
new file mode 100644
index 0000000..cc1e999
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/parityti2_test.c
@@ -0,0 +1,64 @@
+//===-- parityti2_test.c - Test __parityti2 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __parityti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: 1 if number of bits is odd else returns 0
+
+COMPILER_RT_ABI si_int __parityti2(ti_int a);
+
+int naive_parity(ti_int a)
+{
+    int r = 0;
+    for (; a; a = a & (a - 1))
+        r = ~r;
+    return r & 1;
+}
+
+int test__parityti2(ti_int a)
+{
+    si_int x = __parityti2(a);
+    si_int expected = naive_parity(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __parityti2(0x%.16llX%.16llX) = %d, expected %d\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(di_int)*CHAR_BIT == 64] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__parityti2(((ti_int)rand() << 96) + ((ti_int)rand() << 64) +
+                            ((ti_int)rand() << 32) + rand()))
+            return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/popcountdi2_test.c b/compiler-rt/test/builtins/Unit/popcountdi2_test.c
new file mode 100644
index 0000000..bfd4977
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/popcountdi2_test.c
@@ -0,0 +1,63 @@
+//===-- popcountdi2_test.c - Test __popcountdi2 ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __popcountdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: count of 1 bits
+
+COMPILER_RT_ABI si_int __popcountdi2(di_int a);
+
+int naive_popcount(di_int a)
+{
+    int r = 0;
+    for (; a; a = (du_int)a >> 1)
+        r += a & 1;
+    return r;
+}
+
+int test__popcountdi2(di_int a)
+{
+    si_int x = __popcountdi2(a);
+    si_int expected = naive_popcount(a);
+    if (x != expected)
+        printf("error in __popcountdi2(0x%llX) = %d, expected %d\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__popcountdi2(0))
+        return 1;
+    if (test__popcountdi2(1))
+        return 1;
+    if (test__popcountdi2(2))
+        return 1;
+    if (test__popcountdi2(0xFFFFFFFFFFFFFFFDLL))
+        return 1;
+    if (test__popcountdi2(0xFFFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__popcountdi2(0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__popcountdi2(((di_int)rand() << 32) | rand()))
+            return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/popcountsi2_test.c b/compiler-rt/test/builtins/Unit/popcountsi2_test.c
new file mode 100644
index 0000000..10b757d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/popcountsi2_test.c
@@ -0,0 +1,62 @@
+//===-- popcountsi2_test.c - Test __popcountsi2 ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __popcountsi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: count of 1 bits
+
+COMPILER_RT_ABI si_int __popcountsi2(si_int a);
+
+int naive_popcount(si_int a)
+{
+    int r = 0;
+    for (; a; a = (su_int)a >> 1)
+        r += a & 1;
+    return r;
+}
+
+int test__popcountsi2(si_int a)
+{
+    si_int x = __popcountsi2(a);
+    si_int expected = naive_popcount(a);
+    if (x != expected)
+        printf("error in __popcountsi2(0x%X) = %d, expected %d\n",
+               a, x, expected);
+    return x != expected;
+}
+
+char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
+
+int main()
+{
+    if (test__popcountsi2(0))
+        return 1;
+    if (test__popcountsi2(1))
+        return 1;
+    if (test__popcountsi2(2))
+        return 1;
+    if (test__popcountsi2(0xFFFFFFFD))
+        return 1;
+    if (test__popcountsi2(0xFFFFFFFE))
+        return 1;
+    if (test__popcountsi2(0xFFFFFFFF))
+        return 1;
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__popcountsi2(rand()))
+            return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/popcountti2_test.c b/compiler-rt/test/builtins/Unit/popcountti2_test.c
new file mode 100644
index 0000000..3a3c3cb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/popcountti2_test.c
@@ -0,0 +1,82 @@
+//===-- popcountti2_test.c - Test __popcountti2 ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __popcountti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: count of 1 bits
+
+COMPILER_RT_ABI si_int __popcountti2(ti_int a);
+
+int naive_popcount(ti_int a)
+{
+    int r = 0;
+    for (; a; a = (tu_int)a >> 1)
+        r += a & 1;
+    return r;
+}
+
+int test__popcountti2(ti_int a)
+{
+    si_int x = __popcountti2(a);
+    si_int expected = naive_popcount(a);
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        printf("error in __popcountti2(0x%.16llX%.16llX) = %d, expected %d\n",
+               at.s.high, at.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+char assumption_2[sizeof(di_int)*CHAR_BIT == 64] = {0};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__popcountti2(0))
+        return 1;
+    if (test__popcountti2(1))
+        return 1;
+    if (test__popcountti2(2))
+        return 1;
+    if (test__popcountti2(0xFFFFFFFFFFFFFFFDLL))
+        return 1;
+    if (test__popcountti2(0xFFFFFFFFFFFFFFFELL))
+        return 1;
+    if (test__popcountti2(0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__popcountti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFDLL)))
+        return 1;
+    if (test__popcountti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFELL)))
+        return 1;
+    if (test__popcountti2(make_ti(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    int i;
+    for (i = 0; i < 10000; ++i)
+        if (test__popcountti2(((ti_int)rand() << 96) | ((ti_int)rand() << 64) |
+                              ((ti_int)rand() << 32) | rand()))
+            return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/powidf2_test.c b/compiler-rt/test/builtins/Unit/powidf2_test.c
new file mode 100644
index 0000000..c499d9a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/powidf2_test.c
@@ -0,0 +1,224 @@
+//===-- powidf2_test.cpp - Test __powidf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __powidf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <math.h>
+
+// Returns: a ^ b
+
+COMPILER_RT_ABI double __powidf2(double a, si_int b);
+
+int test__powidf2(double a, si_int b, double expected)
+{
+    double x = __powidf2(a, b);
+    int correct = (x == expected) && (signbit(x) == signbit(expected));
+    if (!correct)
+        printf("error in __powidf2(%f, %d) = %f, expected %f\n",
+               a, b, x, expected);
+    return !correct;
+}
+
+int main()
+{
+    if (test__powidf2(0, 0, 1))
+        return 1;
+    if (test__powidf2(1, 0, 1))
+        return 1;
+    if (test__powidf2(1.5, 0, 1))
+        return 1;
+    if (test__powidf2(2, 0, 1))
+        return 1;
+    if (test__powidf2(INFINITY, 0, 1))
+        return 1;
+
+    if (test__powidf2(-0., 0, 1))
+        return 1;
+    if (test__powidf2(-1, 0, 1))
+        return 1;
+    if (test__powidf2(-1.5, 0, 1))
+        return 1;
+    if (test__powidf2(-2, 0, 1))
+        return 1;
+    if (test__powidf2(-INFINITY, 0, 1))
+        return 1;
+
+    if (test__powidf2(0, 1, 0))
+        return 1;
+    if (test__powidf2(0, 2, 0))
+        return 1;
+    if (test__powidf2(0, 3, 0))
+        return 1;
+    if (test__powidf2(0, 4, 0))
+        return 1;
+    if (test__powidf2(0, 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powidf2(0, 0x7FFFFFFF, 0))
+        return 1;
+
+    if (test__powidf2(-0., 1, -0.))
+        return 1;
+    if (test__powidf2(-0., 2, 0))
+        return 1;
+    if (test__powidf2(-0., 3, -0.))
+        return 1;
+    if (test__powidf2(-0., 4, 0))
+        return 1;
+    if (test__powidf2(-0., 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powidf2(-0., 0x7FFFFFFF, -0.))
+        return 1;
+
+    if (test__powidf2(1, 1, 1))
+        return 1;
+    if (test__powidf2(1, 2, 1))
+        return 1;
+    if (test__powidf2(1, 3, 1))
+        return 1;
+    if (test__powidf2(1, 4, 1))
+        return 1;
+    if (test__powidf2(1, 0x7FFFFFFE, 1))
+        return 1;
+    if (test__powidf2(1, 0x7FFFFFFF, 1))
+        return 1;
+
+    if (test__powidf2(INFINITY, 1, INFINITY))
+        return 1;
+    if (test__powidf2(INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powidf2(INFINITY, 3, INFINITY))
+        return 1;
+    if (test__powidf2(INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powidf2(INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powidf2(INFINITY, 0x7FFFFFFF, INFINITY))
+        return 1;
+
+    if (test__powidf2(-INFINITY, 1, -INFINITY))
+        return 1;
+    if (test__powidf2(-INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powidf2(-INFINITY, 3, -INFINITY))
+        return 1;
+    if (test__powidf2(-INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powidf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powidf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+        return 1;
+
+    if (test__powidf2(0, -1, INFINITY))
+        return 1;
+    if (test__powidf2(0, -2, INFINITY))
+        return 1;
+    if (test__powidf2(0, -3, INFINITY))
+        return 1;
+    if (test__powidf2(0, -4, INFINITY))
+        return 1;
+    if (test__powidf2(0, 0x80000002, INFINITY))
+        return 1;
+    if (test__powidf2(0, 0x80000001, INFINITY))
+        return 1;
+    if (test__powidf2(0, 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powidf2(-0., -1, -INFINITY))
+        return 1;
+    if (test__powidf2(-0., -2, INFINITY))
+        return 1;
+    if (test__powidf2(-0., -3, -INFINITY))
+        return 1;
+    if (test__powidf2(-0., -4, INFINITY))
+        return 1;
+    if (test__powidf2(-0., 0x80000002, INFINITY))
+        return 1;
+    if (test__powidf2(-0., 0x80000001, -INFINITY))
+        return 1;
+    if (test__powidf2(-0., 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powidf2(1, -1, 1))
+        return 1;
+    if (test__powidf2(1, -2, 1))
+        return 1;
+    if (test__powidf2(1, -3, 1))
+        return 1;
+    if (test__powidf2(1, -4, 1))
+        return 1;
+    if (test__powidf2(1, 0x80000002, 1))
+        return 1;
+    if (test__powidf2(1, 0x80000001, 1))
+        return 1;
+    if (test__powidf2(1, 0x80000000, 1))
+        return 1;
+
+    if (test__powidf2(INFINITY, -1, 0))
+        return 1;
+    if (test__powidf2(INFINITY, -2, 0))
+        return 1;
+    if (test__powidf2(INFINITY, -3, 0))
+        return 1;
+    if (test__powidf2(INFINITY, -4, 0))
+        return 1;
+    if (test__powidf2(INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powidf2(INFINITY, 0x80000001, 0))
+        return 1;
+    if (test__powidf2(INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powidf2(-INFINITY, -1, -0.))
+        return 1;
+    if (test__powidf2(-INFINITY, -2, 0))
+        return 1;
+    if (test__powidf2(-INFINITY, -3, -0.))
+        return 1;
+    if (test__powidf2(-INFINITY, -4, 0))
+        return 1;
+    if (test__powidf2(-INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powidf2(-INFINITY, 0x80000001, -0.))
+        return 1;
+    if (test__powidf2(-INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powidf2(2, 10, 1024.))
+        return 1;
+    if (test__powidf2(-2, 10, 1024.))
+        return 1;
+    if (test__powidf2(2, -10, 1/1024.))
+        return 1;
+    if (test__powidf2(-2, -10, 1/1024.))
+        return 1;
+
+    if (test__powidf2(2, 19, 524288.))
+        return 1;
+    if (test__powidf2(-2, 19, -524288.))
+        return 1;
+    if (test__powidf2(2, -19, 1/524288.))
+        return 1;
+    if (test__powidf2(-2, -19, -1/524288.))
+        return 1;
+
+    if (test__powidf2(2, 31, 2147483648.))
+        return 1;
+    if (test__powidf2(-2, 31, -2147483648.))
+        return 1;
+    if (test__powidf2(2, -31, 1/2147483648.))
+        return 1;
+    if (test__powidf2(-2, -31, -1/2147483648.))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/powisf2_test.c b/compiler-rt/test/builtins/Unit/powisf2_test.c
new file mode 100644
index 0000000..1186ef4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/powisf2_test.c
@@ -0,0 +1,224 @@
+//===-- powisf2_test.cpp - Test __powisf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __powisf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <math.h>
+
+// Returns: a ^ b
+
+COMPILER_RT_ABI float __powisf2(float a, si_int b);
+
+int test__powisf2(float a, si_int b, float expected)
+{
+    float x = __powisf2(a, b);
+    int correct = (x == expected) && (signbit(x) == signbit(expected));
+    if (!correct)
+        printf("error in __powisf2(%f, %d) = %f, expected %f\n",
+               a, b, x, expected);
+    return !correct;
+}
+
+int main()
+{
+    if (test__powisf2(0, 0, 1))
+        return 1;
+    if (test__powisf2(1, 0, 1))
+        return 1;
+    if (test__powisf2(1.5, 0, 1))
+        return 1;
+    if (test__powisf2(2, 0, 1))
+        return 1;
+    if (test__powisf2(INFINITY, 0, 1))
+        return 1;
+
+    if (test__powisf2(-0., 0, 1))
+        return 1;
+    if (test__powisf2(-1, 0, 1))
+        return 1;
+    if (test__powisf2(-1.5, 0, 1))
+        return 1;
+    if (test__powisf2(-2, 0, 1))
+        return 1;
+    if (test__powisf2(-INFINITY, 0, 1))
+        return 1;
+
+    if (test__powisf2(0, 1, 0))
+        return 1;
+    if (test__powisf2(0, 2, 0))
+        return 1;
+    if (test__powisf2(0, 3, 0))
+        return 1;
+    if (test__powisf2(0, 4, 0))
+        return 1;
+    if (test__powisf2(0, 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powisf2(0, 0x7FFFFFFF, 0))
+        return 1;
+
+    if (test__powisf2(-0., 1, -0.))
+        return 1;
+    if (test__powisf2(-0., 2, 0))
+        return 1;
+    if (test__powisf2(-0., 3, -0.))
+        return 1;
+    if (test__powisf2(-0., 4, 0))
+        return 1;
+    if (test__powisf2(-0., 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powisf2(-0., 0x7FFFFFFF, -0.))
+        return 1;
+
+    if (test__powisf2(1, 1, 1))
+        return 1;
+    if (test__powisf2(1, 2, 1))
+        return 1;
+    if (test__powisf2(1, 3, 1))
+        return 1;
+    if (test__powisf2(1, 4, 1))
+        return 1;
+    if (test__powisf2(1, 0x7FFFFFFE, 1))
+        return 1;
+    if (test__powisf2(1, 0x7FFFFFFF, 1))
+        return 1;
+
+    if (test__powisf2(INFINITY, 1, INFINITY))
+        return 1;
+    if (test__powisf2(INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powisf2(INFINITY, 3, INFINITY))
+        return 1;
+    if (test__powisf2(INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powisf2(INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powisf2(INFINITY, 0x7FFFFFFF, INFINITY))
+        return 1;
+
+    if (test__powisf2(-INFINITY, 1, -INFINITY))
+        return 1;
+    if (test__powisf2(-INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powisf2(-INFINITY, 3, -INFINITY))
+        return 1;
+    if (test__powisf2(-INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powisf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powisf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+        return 1;
+
+    if (test__powisf2(0, -1, INFINITY))
+        return 1;
+    if (test__powisf2(0, -2, INFINITY))
+        return 1;
+    if (test__powisf2(0, -3, INFINITY))
+        return 1;
+    if (test__powisf2(0, -4, INFINITY))
+        return 1;
+    if (test__powisf2(0, 0x80000002, INFINITY))
+        return 1;
+    if (test__powisf2(0, 0x80000001, INFINITY))
+        return 1;
+    if (test__powisf2(0, 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powisf2(-0., -1, -INFINITY))
+        return 1;
+    if (test__powisf2(-0., -2, INFINITY))
+        return 1;
+    if (test__powisf2(-0., -3, -INFINITY))
+        return 1;
+    if (test__powisf2(-0., -4, INFINITY))
+        return 1;
+    if (test__powisf2(-0., 0x80000002, INFINITY))
+        return 1;
+    if (test__powisf2(-0., 0x80000001, -INFINITY))
+        return 1;
+    if (test__powisf2(-0., 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powisf2(1, -1, 1))
+        return 1;
+    if (test__powisf2(1, -2, 1))
+        return 1;
+    if (test__powisf2(1, -3, 1))
+        return 1;
+    if (test__powisf2(1, -4, 1))
+        return 1;
+    if (test__powisf2(1, 0x80000002, 1))
+        return 1;
+    if (test__powisf2(1, 0x80000001, 1))
+        return 1;
+    if (test__powisf2(1, 0x80000000, 1))
+        return 1;
+
+    if (test__powisf2(INFINITY, -1, 0))
+        return 1;
+    if (test__powisf2(INFINITY, -2, 0))
+        return 1;
+    if (test__powisf2(INFINITY, -3, 0))
+        return 1;
+    if (test__powisf2(INFINITY, -4, 0))
+        return 1;
+    if (test__powisf2(INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powisf2(INFINITY, 0x80000001, 0))
+        return 1;
+    if (test__powisf2(INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powisf2(-INFINITY, -1, -0.))
+        return 1;
+    if (test__powisf2(-INFINITY, -2, 0))
+        return 1;
+    if (test__powisf2(-INFINITY, -3, -0.))
+        return 1;
+    if (test__powisf2(-INFINITY, -4, 0))
+        return 1;
+    if (test__powisf2(-INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powisf2(-INFINITY, 0x80000001, -0.))
+        return 1;
+    if (test__powisf2(-INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powisf2(2, 10, 1024.))
+        return 1;
+    if (test__powisf2(-2, 10, 1024.))
+        return 1;
+    if (test__powisf2(2, -10, 1/1024.))
+        return 1;
+    if (test__powisf2(-2, -10, 1/1024.))
+        return 1;
+
+    if (test__powisf2(2, 19, 524288.))
+        return 1;
+    if (test__powisf2(-2, 19, -524288.))
+        return 1;
+    if (test__powisf2(2, -19, 1/524288.))
+        return 1;
+    if (test__powisf2(-2, -19, -1/524288.))
+        return 1;
+
+    if (test__powisf2(2, 31, 2147483648.))
+        return 1;
+    if (test__powisf2(-2, 31, -2147483648.))
+        return 1;
+    if (test__powisf2(2, -31, 1/2147483648.))
+        return 1;
+    if (test__powisf2(-2, -31, -1/2147483648.))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/powitf2_test.c b/compiler-rt/test/builtins/Unit/powitf2_test.c
new file mode 100644
index 0000000..13c890a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/powitf2_test.c
@@ -0,0 +1,233 @@
+//===-- powitf2_test.cpp - Test __powitf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __powitf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if _ARCH_PPC
+
+#include "int_lib.h"
+#include <math.h>
+
+// Returns: a ^ b
+
+COMPILER_RT_ABI long double __powitf2(long double a, si_int b);
+
+int test__powitf2(long double a, si_int b, long double expected)
+{
+    long double x = __powitf2(a, b);
+    int correct = (x == expected) && (signbit(x) == signbit(expected));
+    if (!correct)
+        printf("error in __powitf2(%Lf, %d) = %Lf, expected %Lf\n",
+               a, b, x, expected);
+    return !correct;
+}
+
+#endif
+
+int main()
+{
+#if _ARCH_PPC
+    if (test__powitf2(0, 0, 1))
+        return 1;
+    if (test__powitf2(1, 0, 1))
+        return 1;
+    if (test__powitf2(1.5, 0, 1))
+        return 1;
+    if (test__powitf2(2, 0, 1))
+        return 1;
+    if (test__powitf2(INFINITY, 0, 1))
+        return 1;
+
+    if (test__powitf2(-0., 0, 1))
+        return 1;
+    if (test__powitf2(-1, 0, 1))
+        return 1;
+    if (test__powitf2(-1.5, 0, 1))
+        return 1;
+    if (test__powitf2(-2, 0, 1))
+        return 1;
+    if (test__powitf2(-INFINITY, 0, 1))
+        return 1;
+
+    if (test__powitf2(0, 1, 0))
+        return 1;
+    if (test__powitf2(0, 2, 0))
+        return 1;
+    if (test__powitf2(0, 3, 0))
+        return 1;
+    if (test__powitf2(0, 4, 0))
+        return 1;
+    if (test__powitf2(0, 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powitf2(0, 0x7FFFFFFF, 0))
+        return 1;
+
+    if (test__powitf2(-0., 1, -0.))
+        return 1;
+    if (test__powitf2(-0., 2, 0))
+        return 1;
+    if (test__powitf2(-0., 3, -0.))
+        return 1;
+    if (test__powitf2(-0., 4, 0))
+        return 1;
+    if (test__powitf2(-0., 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powitf2(-0., 0x7FFFFFFF, -0.))
+        return 1;
+
+    if (test__powitf2(1, 1, 1))
+        return 1;
+    if (test__powitf2(1, 2, 1))
+        return 1;
+    if (test__powitf2(1, 3, 1))
+        return 1;
+    if (test__powitf2(1, 4, 1))
+        return 1;
+    if (test__powitf2(1, 0x7FFFFFFE, 1))
+        return 1;
+    if (test__powitf2(1, 0x7FFFFFFF, 1))
+        return 1;
+
+    if (test__powitf2(INFINITY, 1, INFINITY))
+        return 1;
+    if (test__powitf2(INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powitf2(INFINITY, 3, INFINITY))
+        return 1;
+    if (test__powitf2(INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powitf2(INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powitf2(INFINITY, 0x7FFFFFFF, INFINITY))
+        return 1;
+
+    if (test__powitf2(-INFINITY, 1, -INFINITY))
+        return 1;
+    if (test__powitf2(-INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powitf2(-INFINITY, 3, -INFINITY))
+        return 1;
+    if (test__powitf2(-INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powitf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powitf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+        return 1;
+
+    if (test__powitf2(0, -1, INFINITY))
+        return 1;
+    if (test__powitf2(0, -2, INFINITY))
+        return 1;
+    if (test__powitf2(0, -3, INFINITY))
+        return 1;
+    if (test__powitf2(0, -4, INFINITY))
+        return 1;
+    if (test__powitf2(0, 0x80000002, INFINITY))
+        return 1;
+    if (test__powitf2(0, 0x80000001, INFINITY))
+        return 1;
+    if (test__powitf2(0, 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powitf2(-0., -1, -INFINITY))
+        return 1;
+    if (test__powitf2(-0., -2, INFINITY))
+        return 1;
+    if (test__powitf2(-0., -3, -INFINITY))
+        return 1;
+    if (test__powitf2(-0., -4, INFINITY))
+        return 1;
+    if (test__powitf2(-0., 0x80000002, INFINITY))
+        return 1;
+    if (test__powitf2(-0., 0x80000001, -INFINITY))
+        return 1;
+    if (test__powitf2(-0., 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powitf2(1, -1, 1))
+        return 1;
+    if (test__powitf2(1, -2, 1))
+        return 1;
+    if (test__powitf2(1, -3, 1))
+        return 1;
+    if (test__powitf2(1, -4, 1))
+        return 1;
+    if (test__powitf2(1, 0x80000002, 1))
+        return 1;
+    if (test__powitf2(1, 0x80000001, 1))
+        return 1;
+    if (test__powitf2(1, 0x80000000, 1))
+        return 1;
+
+    if (test__powitf2(INFINITY, -1, 0))
+        return 1;
+    if (test__powitf2(INFINITY, -2, 0))
+        return 1;
+    if (test__powitf2(INFINITY, -3, 0))
+        return 1;
+    if (test__powitf2(INFINITY, -4, 0))
+        return 1;
+    if (test__powitf2(INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powitf2(INFINITY, 0x80000001, 0))
+        return 1;
+    if (test__powitf2(INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powitf2(-INFINITY, -1, -0.))
+        return 1;
+    if (test__powitf2(-INFINITY, -2, 0))
+        return 1;
+    if (test__powitf2(-INFINITY, -3, -0.))
+        return 1;
+    if (test__powitf2(-INFINITY, -4, 0))
+        return 1;
+    if (test__powitf2(-INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powitf2(-INFINITY, 0x80000001, -0.))
+        return 1;
+    if (test__powitf2(-INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powitf2(2, 10, 1024.))
+        return 1;
+    if (test__powitf2(-2, 10, 1024.))
+        return 1;
+    if (test__powitf2(2, -10, 1/1024.))
+        return 1;
+    if (test__powitf2(-2, -10, 1/1024.))
+        return 1;
+
+    if (test__powitf2(2, 19, 524288.))
+        return 1;
+    if (test__powitf2(-2, 19, -524288.))
+        return 1;
+    if (test__powitf2(2, -19, 1/524288.))
+        return 1;
+    if (test__powitf2(-2, -19, -1/524288.))
+        return 1;
+
+    if (test__powitf2(2, 31, 2147483648.))
+        return 1;
+    if (test__powitf2(-2, 31, -2147483648.))
+        return 1;
+    if (test__powitf2(2, -31, 1/2147483648.))
+        return 1;
+    if (test__powitf2(-2, -31, -1/2147483648.))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/powixf2_test.c b/compiler-rt/test/builtins/Unit/powixf2_test.c
new file mode 100644
index 0000000..a28f1f9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/powixf2_test.c
@@ -0,0 +1,232 @@
+//===-- powixf2_test.cpp - Test __powixf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __powixf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <math.h>
+
+// Returns: a ^ b
+
+COMPILER_RT_ABI long double __powixf2(long double a, si_int b);
+
+int test__powixf2(long double a, si_int b, long double expected)
+{
+    long double x = __powixf2(a, b);
+    int correct = (x == expected) && (signbit(x) == signbit(expected));
+    if (!correct)
+        printf("error in __powixf2(%Lf, %d) = %Lf, expected %Lf\n",
+               a, b, x, expected);
+    return !correct;
+}
+
+#endif
+
+int main()
+{
+#if !_ARCH_PPC
+    if (test__powixf2(0, 0, 1))
+        return 1;
+    if (test__powixf2(1, 0, 1))
+        return 1;
+    if (test__powixf2(1.5, 0, 1))
+        return 1;
+    if (test__powixf2(2, 0, 1))
+        return 1;
+    if (test__powixf2(INFINITY, 0, 1))
+        return 1;
+
+    if (test__powixf2(-0., 0, 1))
+        return 1;
+    if (test__powixf2(-1, 0, 1))
+        return 1;
+    if (test__powixf2(-1.5, 0, 1))
+        return 1;
+    if (test__powixf2(-2, 0, 1))
+        return 1;
+    if (test__powixf2(-INFINITY, 0, 1))
+        return 1;
+
+    if (test__powixf2(0, 1, 0))
+        return 1;
+    if (test__powixf2(0, 2, 0))
+        return 1;
+    if (test__powixf2(0, 3, 0))
+        return 1;
+    if (test__powixf2(0, 4, 0))
+        return 1;
+    if (test__powixf2(0, 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powixf2(0, 0x7FFFFFFF, 0))
+        return 1;
+
+    if (test__powixf2(-0., 1, -0.))
+        return 1;
+    if (test__powixf2(-0., 2, 0))
+        return 1;
+    if (test__powixf2(-0., 3, -0.))
+        return 1;
+    if (test__powixf2(-0., 4, 0))
+        return 1;
+    if (test__powixf2(-0., 0x7FFFFFFE, 0))
+        return 1;
+    if (test__powixf2(-0., 0x7FFFFFFF, -0.))
+        return 1;
+
+    if (test__powixf2(1, 1, 1))
+        return 1;
+    if (test__powixf2(1, 2, 1))
+        return 1;
+    if (test__powixf2(1, 3, 1))
+        return 1;
+    if (test__powixf2(1, 4, 1))
+        return 1;
+    if (test__powixf2(1, 0x7FFFFFFE, 1))
+        return 1;
+    if (test__powixf2(1, 0x7FFFFFFF, 1))
+        return 1;
+
+    if (test__powixf2(INFINITY, 1, INFINITY))
+        return 1;
+    if (test__powixf2(INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powixf2(INFINITY, 3, INFINITY))
+        return 1;
+    if (test__powixf2(INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powixf2(INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powixf2(INFINITY, 0x7FFFFFFF, INFINITY))
+        return 1;
+
+    if (test__powixf2(-INFINITY, 1, -INFINITY))
+        return 1;
+    if (test__powixf2(-INFINITY, 2, INFINITY))
+        return 1;
+    if (test__powixf2(-INFINITY, 3, -INFINITY))
+        return 1;
+    if (test__powixf2(-INFINITY, 4, INFINITY))
+        return 1;
+    if (test__powixf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+        return 1;
+    if (test__powixf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+        return 1;
+
+    if (test__powixf2(0, -1, INFINITY))
+        return 1;
+    if (test__powixf2(0, -2, INFINITY))
+        return 1;
+    if (test__powixf2(0, -3, INFINITY))
+        return 1;
+    if (test__powixf2(0, -4, INFINITY))
+        return 1;
+    if (test__powixf2(0, 0x80000002, INFINITY))
+        return 1;
+    if (test__powixf2(0, 0x80000001, INFINITY))
+        return 1;
+    if (test__powixf2(0, 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powixf2(-0., -1, -INFINITY))
+        return 1;
+    if (test__powixf2(-0., -2, INFINITY))
+        return 1;
+    if (test__powixf2(-0., -3, -INFINITY))
+        return 1;
+    if (test__powixf2(-0., -4, INFINITY))
+        return 1;
+    if (test__powixf2(-0., 0x80000002, INFINITY))
+        return 1;
+    if (test__powixf2(-0., 0x80000001, -INFINITY))
+        return 1;
+    if (test__powixf2(-0., 0x80000000, INFINITY))
+        return 1;
+
+    if (test__powixf2(1, -1, 1))
+        return 1;
+    if (test__powixf2(1, -2, 1))
+        return 1;
+    if (test__powixf2(1, -3, 1))
+        return 1;
+    if (test__powixf2(1, -4, 1))
+        return 1;
+    if (test__powixf2(1, 0x80000002, 1))
+        return 1;
+    if (test__powixf2(1, 0x80000001, 1))
+        return 1;
+    if (test__powixf2(1, 0x80000000, 1))
+        return 1;
+
+    if (test__powixf2(INFINITY, -1, 0))
+        return 1;
+    if (test__powixf2(INFINITY, -2, 0))
+        return 1;
+    if (test__powixf2(INFINITY, -3, 0))
+        return 1;
+    if (test__powixf2(INFINITY, -4, 0))
+        return 1;
+    if (test__powixf2(INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powixf2(INFINITY, 0x80000001, 0))
+        return 1;
+    if (test__powixf2(INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powixf2(-INFINITY, -1, -0.))
+        return 1;
+    if (test__powixf2(-INFINITY, -2, 0))
+        return 1;
+    if (test__powixf2(-INFINITY, -3, -0.))
+        return 1;
+    if (test__powixf2(-INFINITY, -4, 0))
+        return 1;
+    if (test__powixf2(-INFINITY, 0x80000002, 0))
+        return 1;
+    if (test__powixf2(-INFINITY, 0x80000001, -0.))
+        return 1;
+    if (test__powixf2(-INFINITY, 0x80000000, 0))
+        return 1;
+
+    if (test__powixf2(2, 10, 1024.))
+        return 1;
+    if (test__powixf2(-2, 10, 1024.))
+        return 1;
+    if (test__powixf2(2, -10, 1/1024.))
+        return 1;
+    if (test__powixf2(-2, -10, 1/1024.))
+        return 1;
+
+    if (test__powixf2(2, 19, 524288.))
+        return 1;
+    if (test__powixf2(-2, 19, -524288.))
+        return 1;
+    if (test__powixf2(2, -19, 1/524288.))
+        return 1;
+    if (test__powixf2(-2, -19, -1/524288.))
+        return 1;
+
+    if (test__powixf2(2, 31, 2147483648.))
+        return 1;
+    if (test__powixf2(-2, 31, -2147483648.))
+        return 1;
+    if (test__powixf2(2, -31, 1/2147483648.))
+        return 1;
+    if (test__powixf2(-2, -31, -1/2147483648.))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ppc/DD.h b/compiler-rt/test/builtins/Unit/ppc/DD.h
new file mode 100644
index 0000000..fd62dae
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/DD.h
@@ -0,0 +1,14 @@
+#ifndef __DD_HEADER
+#define __DD_HEADER
+
+#include <stdint.h>
+
+typedef union {
+	long double ld;
+	struct {
+		double hi;
+		double lo;
+	};
+} DD;
+
+#endif // __DD_HEADER
diff --git a/compiler-rt/test/builtins/Unit/ppc/fixtfdi_test.c b/compiler-rt/test/builtins/Unit/ppc/fixtfdi_test.c
new file mode 100644
index 0000000..b4865fb
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/fixtfdi_test.c
@@ -0,0 +1,477 @@
+#include <stdio.h>
+#include <limits.h>
+#include <stdint.h>
+#include "DD.h"
+
+struct testVector { double xhi; double xlo; int64_t result; };
+
+#define INFINITY __builtin_inf()
+#define HUGE 0x1.fffffffffffffp1023
+#define QNAN __builtin_nan("")
+
+const struct testVector testCases[] = {
+// Edge cases
+// {	HUGE,					0.0,					INT64_MAX	},
+// {	INFINITY,				0.0,					INT64_MAX	},
+// {  -HUGE,					0.0,					INT64_MIN	},
+// {  -INFINITY,				0.0,					INT64_MIN	},
+// {	QNAN,					0.0,					INT64_MIN	},
+
+// Exact cases:
+{   0.0,					0.0,					0LL			},
+{  -0.0,					0.0,					0LL			},
+{   1.0,					0.0,					1LL			},
+{  -1.0,					0.0,				   -1LL			},
+{   2.0,					0.0,					2LL			},
+{  -2.0,					0.0,				   -2LL			},
+{   3.0,					0.0,					3LL			},
+{  -3.0,					0.0,				   -3LL			},
+{   4.0,					0.0,					4LL			},
+{  -4.0,					0.0,				   -4LL			},
+{   5.0,					0.0,					5LL			},
+{  -5.0,					0.0,				   -5LL			},
+{   6.0,					0.0,					6LL			},
+{  -6.0,					0.0,				   -6LL			},
+{   7.0,					0.0,					7LL			},
+{  -7.0,					0.0,				   -7LL			},
+{   8.0,					0.0,					8LL			},
+{  -8.0,					0.0,				   -8LL			},
+{   9.0,					0.0,					9LL			},
+{  -9.0,					0.0,				   -9LL			},
+
+// Near integer cases:
+{	1.0,				   -0x1.0p-54,				0LL			},
+{	1.0,				   -0.0,					1LL			},
+{	1.0,					0x1.0p-54,				1LL			},
+{	0x1.0000000000001p0,   -0x1.0p-54,				1LL			},
+{	0x1.0000000000001p0,   -0.0,					1LL			},
+{	0x1.0000000000001p0,    0.0,					1LL			},
+{	0x1.0000000000001p0,    0x1.0p-54,				1LL			},
+{  -1.0,				    0x1.0p-54,				0LL			},
+{  -1.0,				    0.0,				   -1LL			},
+{  -1.0,				    0.0,				   -1LL			},
+{  -1.0,				   -0x1.0p-54,			   -1LL			},
+{  -0x1.0000000000001p0,    0x1.0p-54,			   -1LL			},
+{  -0x1.0000000000001p0,   -0.0,				   -1LL			},
+{  -0x1.0000000000001p0,   -0x1.0p-54,			   -1LL			},
+
+// Close to 32-bit overflow boundaries:
+{   0x1.fffffffcp30,	   -0x1.0p-24,				INT64_C(0x7ffffffe)		},
+{   0x1.fffffffcp30,		0.0,					INT64_C(0x7fffffff)		},
+{   0x1.fffffffcp30,		0x1.0p-24,				INT64_C(0x7fffffff)		},
+{   0x1.fffffffffffffp30,  -0x1.0p-24,				INT64_C(0x7fffffff)		},
+{   0x1.fffffffffffffp30,   0.0,					INT64_C(0x7fffffff)		},
+{   0x1.fffffffffffffp30,   0x1.fffffffffffffp-24,	INT64_C(0x7fffffff)		},
+{   0x1.0p31,			   -0x1.fffffffffffffp-24,	INT64_C(0x7fffffff)		},
+{   0x1.0p31,			    0.0,					INT64_C(0x80000000)		},
+{   0x1.0p31,			    0x1.fffffffffffffp-24,	INT64_C(0x80000000)		},
+{   0x1.0000000000001p31,  -0x1.fffffffffffffp-24,	INT64_C(0x80000000)		},
+{   0x1.0000000000001p31,	0.0,					INT64_C(0x80000000)		},
+{   0x1.0000000000001p31,	0x1.fffffffffffffp-24,	INT64_C(0x80000000)		},
+{	0x1.00000002p31,	   -0x1.fffffffffffffp-24,	INT64_C(0x80000000)		},
+{	0x1.00000002p31,	    0.0,					INT64_C(0x80000001)		},
+{	0x1.00000002p31,	    0x1.fffffffffffffp-24,	INT64_C(0x80000001)		},
+
+{   0x1.fffffffep31,	   -0x1.0p-24,				INT64_C(0xfffffffe)		},
+{   0x1.fffffffep31,		0.0,					INT64_C(0xffffffff)		},
+{   0x1.fffffffep31,		0x1.0p-24,				INT64_C(0xffffffff)		},
+{   0x1.fffffffffffffp31,  -0x1.0p-24,				INT64_C(0xffffffff)		},
+{   0x1.fffffffffffffp31,   0.0,					INT64_C(0xffffffff)		},
+{   0x1.fffffffffffffp31,   0x1.fffffffffffffp-24,	INT64_C(0xffffffff)		},
+{   0x1.0p32,			   -0x1.fffffffffffffp-24,	INT64_C(0xffffffff)		},
+{   0x1.0p32,			    0.0,					INT64_C(0x100000000)	},
+{   0x1.0p32,			    0x1.fffffffffffffp-24,	INT64_C(0x100000000)	},
+{   0x1.0000000000001p32,  -0x1.fffffffffffffp-24,	INT64_C(0x100000000)	},
+{   0x1.0000000000001p32,	0.0,					INT64_C(0x100000000)	},
+{   0x1.0000000000001p32,	0x1.fffffffffffffp-24,	INT64_C(0x100000000)	},
+{	0x1.00000001p32,	   -0x1.fffffffffffffp-24,	INT64_C(0x100000000)	},
+{	0x1.00000001p32,	    0.0,					INT64_C(0x100000001)	},
+{	0x1.00000001p32,	    0x1.fffffffffffffp-24,	INT64_C(0x100000001)	},
+
+{  -0x1.fffffffcp30,	    0x1.0p-24,				INT64_C(0xffffffff80000002)	},
+{  -0x1.fffffffcp30,		0.0,					INT64_C(0xffffffff80000001)	},
+{  -0x1.fffffffcp30,	   -0x1.0p-24,				INT64_C(0xffffffff80000001)	},
+{  -0x1.fffffffffffffp30,   0x1.0p-24,				INT64_C(0xffffffff80000001)	},
+{  -0x1.fffffffffffffp30,   0.0,					INT64_C(0xffffffff80000001)	},
+{  -0x1.fffffffffffffp30,  -0x1.fffffffffffffp-24,	INT64_C(0xffffffff80000001)	},
+{  -0x1.0p31,			    0x1.fffffffffffffp-24,	INT64_C(0xffffffff80000001)	},
+{  -0x1.0p31,			    0.0,					INT64_C(0xffffffff80000000)	},
+{  -0x1.0p31,			   -0x1.fffffffffffffp-24,	INT64_C(0xffffffff80000000)	},
+{  -0x1.0000000000001p31,   0x1.fffffffffffffp-24,	INT64_C(0xffffffff80000000)	},
+{  -0x1.0000000000001p31,	0.0,					INT64_C(0xffffffff80000000)	},
+{  -0x1.0000000000001p31,  -0x1.fffffffffffffp-24,	INT64_C(0xffffffff80000000)	},
+{  -0x1.00000002p31,	    0x1.fffffffffffffp-24,	INT64_C(0xffffffff80000000)	},
+{  -0x1.00000002p31,	    0.0,					INT64_C(0xffffffff7fffffff)	},
+{  -0x1.00000002p31,	   -0x1.fffffffffffffp-24,	INT64_C(0xffffffff7fffffff)	},
+
+{  -0x1.fffffffep31,	    0x1.0p-24,				INT64_C(0xffffffff00000002)	},
+{  -0x1.fffffffep31,		0.0,					INT64_C(0xffffffff00000001)	},
+{  -0x1.fffffffep31,	   -0x1.0p-24,				INT64_C(0xffffffff00000001)	},
+{  -0x1.fffffffffffffp31,   0x1.0p-24,				INT64_C(0xffffffff00000001)	},
+{  -0x1.fffffffffffffp31,   0.0,					INT64_C(0xffffffff00000001)	},
+{  -0x1.fffffffffffffp31,  -0x1.fffffffffffffp-24,	INT64_C(0xffffffff00000001)	},
+{  -0x1.0p32,			    0x1.fffffffffffffp-24,	INT64_C(0xffffffff00000001)	},
+{  -0x1.0p32,			    0.0,					INT64_C(0xffffffff00000000)	},
+{  -0x1.0p32,			   -0x1.fffffffffffffp-24,	INT64_C(0xffffffff00000000)	},
+{  -0x1.0000000000001p32,   0x1.fffffffffffffp-24,	INT64_C(0xffffffff00000000)	},
+{  -0x1.0000000000001p32,	0.0,					INT64_C(0xffffffff00000000)	},
+{  -0x1.0000000000001p32,  -0x1.fffffffffffffp-24,	INT64_C(0xffffffff00000000)	},
+{  -0x1.00000001p32,	    0x1.fffffffffffffp-24,	INT64_C(0xffffffff00000000)	},
+{  -0x1.00000001p32,	    0.0,					INT64_C(0xfffffffeffffffff)	},
+{  -0x1.00000001p32,	   -0x1.fffffffffffffp-24,	INT64_C(0xfffffffeffffffff)	},
+
+// Randomly generated in-range values:
+{0x1.00ffc00ffff00p+11, 0x1.fe0007fffff00p-45, INT64_C(0x0000000000000807)},
+{-0x1.00001fffff800p+38, -0x1.fffffffe00000p-36, INT64_C(0xffffffbffff80001)},
+{0x1.000003fffc002p+48, -0x1.0000000000000p-57, INT64_C(0x0001000003fffc00)},
+{-0x1.000003ffffffep+3, 0x1.ffe0080000000p-81, INT64_C(0xfffffffffffffff8)},
+{0x1.0800000000000p+21, -0x1.0000000000000p-75, INT64_C(0x000000000020ffff)},
+{-0x1.007fffffe0000p+61, 0x0.0000000000000p+0, INT64_C(0xdff0000004000000)},
+{0x1.3fe0000100000p+33, -0x1.0000000000000p-40, INT64_C(0x000000027fc00001)},
+{-0x1.0001fff800000p+1, -0x1.ffffff0000ffep-53, INT64_C(0xfffffffffffffffe)},
+{0x1.0000800000000p+54, -0x1.ffffffe400000p-9, INT64_C(0x0040001fffffffff)},
+{-0x1.007fffffffc00p+15, -0x1.fffffc0000000p-56, INT64_C(0xffffffffffff7fc1)},
+{0x1.0080000000000p+13, -0x1.0000000000000p-60, INT64_C(0x000000000000200f)},
+{-0x1.00f3ffffff000p+56, -0x1.fff8000000000p-12, INT64_C(0xfeff0c0000010000)},
+{0x1.3dfffffffc000p+47, 0x1.ff000003ffe00p-14, INT64_C(0x00009efffffffe00)},
+{-0x1.0000001ffff80p+12, -0x1.fffffdfffff8ep-42, INT64_C(0xfffffffffffff000)},
+{0x1.0000000000000p+4, -0x1.0000000000000p-66, INT64_C(0x000000000000000f)},
+{-0x1.001fffffffe00p+39, 0x0.0000000000000p+0, INT64_C(0xffffff7ff0000001)},
+{0x1.00000007ff800p+5, 0x1.ffff800000000p-83, INT64_C(0x0000000000000020)},
+{-0x1.000ffffff8000p+57, -0x1.ffffffffffc00p+2, INT64_C(0xfdffe000000ffff9)},
+{0x1.007fbfffffcf0p+43, 0x1.ffff803ffe000p-12, INT64_C(0x00000803fdfffffe)},
+{-0x1.01ffffffc0004p+24, 0x1.fffc100000000p-37, INT64_C(0xfffffffffefe0001)},
+{0x1.0000001000000p+19, -0x1.ffffff0000800p-45, INT64_C(0x0000000000080000)},
+{-0x1.00000003ff800p+25, -0x1.ffffe00000000p-61, INT64_C(0xfffffffffe000000)},
+{0x1.0000001000000p+23, -0x1.fffffff804000p-44, INT64_C(0x0000000000800000)},
+{-0x1.0008000000000p+20, 0x1.0000000000000p-48, INT64_C(0xffffffffffefff81)},
+{0x1.0000183ffffc0p+60, 0x1.fff07fcfffffcp+6, INT64_C(0x10000183ffffc07f)},
+{-0x1.0001000000000p+42, 0x1.fffffff800400p-21, INT64_C(0xfffffbfffc000001)},
+{0x1.0000800000000p+11, -0x1.fffff80100000p-62, INT64_C(0x0000000000000800)},
+{-0x1.1fffffff00000p+28, -0x1.fffffff000000p-49, INT64_C(0xffffffffee000001)},
+{0x1.fffffc0000100p+59, -0x1.fffe000040000p-12, INT64_C(0x0fffffe000007fff)},
+{-0x1.0000800000000p+39, 0x1.c000fffffffd0p-18, INT64_C(0xffffff7fffc00001)},
+{0x1.3ff8007ffffc0p+61, 0x1.e0007ff000000p-5, INT64_C(0x27ff000fffff8000)},
+{-0x1.ffffffe000000p+13, 0x1.ff80000020000p-43, INT64_C(0xffffffffffffc001)},
+{0x1.7fffe00800000p+35, -0x1.0000000000000p-70, INT64_C(0x0000000bffff003f)},
+{-0x1.0000400000000p+62, 0x1.0000000000000p-29, INT64_C(0xbffff00000000001)},
+{0x1.4000000000000p+31, -0x1.ffffffff00020p-27, INT64_C(0x000000009fffffff)},
+{-0x1.0000010000000p+29, 0x1.8000000000020p-29, INT64_C(0xffffffffdfffffe1)},
+{0x1.7fffffffc0000p+45, 0x1.fffc000000000p-25, INT64_C(0x00002ffffffff800)},
+{-0x1.0000001fe0000p+46, -0x1.fffffc0001f00p-15, INT64_C(0xffffbffffff80800)},
+{0x1.0000004000000p+54, -0x1.0000000000000p-4, INT64_C(0x004000000fffffff)},
+{-0x1.8000000000000p+48, 0x1.ffe7ffc001000p-17, INT64_C(0xfffe800000000001)},
+{0x1.007fc00007800p+34, 0x1.e0000f80001e0p-24, INT64_C(0x0000000401ff0000)},
+{-0x1.3fffff0000000p+8, -0x1.fffffe0000000p-55, INT64_C(0xfffffffffffffec1)},
+{0x1.0000200000000p+14, -0x1.0000000000000p-91, INT64_C(0x0000000000004000)},
+{-0x1.00000fffffff8p+1, -0x1.fffffffc00000p-58, INT64_C(0xfffffffffffffffe)},
+{0x1.001fffc000400p+34, -0x1.e000000001000p-31, INT64_C(0x00000004007fff00)},
+{-0x1.0200000000000p+41, 0x1.0000000000000p-62, INT64_C(0xfffffdfc00000001)},
+{0x1.03ffffffe0000p+55, 0x1.ff80000000000p-34, INT64_C(0x0081fffffff00000)},
+{-0x1.0010000000000p+45, 0x1.0000000000000p-32, INT64_C(0xffffdffe00000001)},
+{0x1.0000008000000p+31, -0x1.fff0000000100p-28, INT64_C(0x000000008000003f)},
+{-0x1.0000c00400000p+26, 0x1.ff80800000000p-55, INT64_C(0xfffffffffbfffd00)},
+{0x1.0000007fff000p+48, 0x1.ffffff8000000p-27, INT64_C(0x00010000007fff00)},
+{-0x1.3ffffff800200p+60, 0x1.0000000000000p-17, INT64_C(0xec0000007ffe0001)},
+{0x1.0000200000000p+8, -0x1.ffffffffffc40p-51, INT64_C(0x0000000000000100)},
+{-0x1.007ffffffff80p+54, -0x1.fffffffe00000p-20, INT64_C(0xffbfe00000000200)},
+{0x1.00003ffffff00p+25, 0x1.ffc003ffffe00p-30, INT64_C(0x000000000200007f)},
+{-0x1.0200000000000p+26, 0x1.c000000000008p-30, INT64_C(0xfffffffffbf80001)},
+{0x1.1fffffc000000p+8, 0x1.ffffffffffff0p-49, INT64_C(0x000000000000011f)},
+{-0x1.007fc00000800p+2, 0x1.fffff03fff000p-58, INT64_C(0xfffffffffffffffc)},
+{0x1.00007fffff000p+31, 0x1.ffffffff00000p-41, INT64_C(0x0000000080003fff)},
+{-0x1.0000003ffff80p+54, -0x1.fffffefff8000p-14, INT64_C(0xffbffffff0000200)},
+{0x1.00007ffc00000p+46, 0x1.ffffe00000000p-23, INT64_C(0x000040001fff0000)},
+{-0x1.3fffffc004000p+8, 0x1.ffffe00010000p-56, INT64_C(0xfffffffffffffec1)},
+{0x1.01fffffffe000p+49, 0x1.fffc000000000p-39, INT64_C(0x000203fffffffc00)},
+{-0x1.07ffffff80000p+54, -0x1.8007ffffc0000p-17, INT64_C(0xffbe000000200000)},
+{0x1.00003ff810000p+56, -0x1.fffffffc00800p-8, INT64_C(0x0100003ff80fffff)},
+{-0x1.01ffffff00004p+25, 0x1.0000000000000p-65, INT64_C(0xfffffffffdfc0001)},
+{0x1.000000ffffff8p+11, 0x1.ffe0000000000p-61, INT64_C(0x0000000000000800)},
+{-0x1.001f03f07ff00p+10, -0x1.ffffff8000000p-63, INT64_C(0xfffffffffffffc00)},
+{0x1.00003fffffffcp+9, 0x1.ffe0000700000p-64, INT64_C(0x0000000000000200)},
+{-0x1.0000100000000p+27, 0x1.0000000000000p-55, INT64_C(0xfffffffff7ffff81)},
+{0x1.0000020000000p+62, -0x1.0000000000000p-30, INT64_C(0x4000007fffffffff)},
+{-0x1.00001fffcffc0p+52, 0x1.fffe000000004p-3, INT64_C(0xffeffffe00030041)},
+{0x1.03fffff800000p+47, 0x1.fffffe0000000p-21, INT64_C(0x000081fffffc0000)},
+{-0x1.000fff8000000p+0, -0x1.fffffe0000000p-62, INT64_C(0xffffffffffffffff)},
+{0x1.0003fc0000000p+57, 0x1.ffff80ffffc00p+0, INT64_C(0x020007f800000001)},
+{-0x1.0300000001f00p+61, -0x1.fffffff800000p-15, INT64_C(0xdf9fffffffc20000)},
+{0x1.fffff1ff80000p+43, 0x1.ffffc000fe000p-12, INT64_C(0x00000fffff8ffc00)},
+{-0x1.000001d000000p+33, 0x1.ff80000200000p-22, INT64_C(0xfffffffdfffffc61)},
+{0x1.000007fffffc0p+24, 0x1.fc0003fc00000p-36, INT64_C(0x0000000001000007)},
+{-0x1.0000004000000p+23, 0x1.fff0000004000p-44, INT64_C(0xffffffffff800000)},
+{0x1.0fc007c004000p+9, -0x1.fffe100000000p-55, INT64_C(0x000000000000021f)},
+{-0x1.00007fffffe00p+13, -0x1.ffffffc003f00p-48, INT64_C(0xffffffffffffe000)},
+{0x1.0080000000000p+24, -0x1.0000000000000p-34, INT64_C(0x0000000001007fff)},
+{-0x1.00000ffffff80p+60, -0x1.ffffff0007ff8p+4, INT64_C(0xefffff0000007fe1)},
+{0x1.01e0000000002p+44, -0x1.fffffffffc200p-15, INT64_C(0x0000101e00000000)},
+{-0x1.0000080000000p+35, 0x1.0000000000000p-70, INT64_C(0xfffffff7ffffc001)},
+{0x1.000000f1fe001p+23, -0x1.0000000000000p-60, INT64_C(0x0000000000800000)},
+{-0x1.00003fffffff0p+40, -0x1.fc00000000000p-37, INT64_C(0xfffffeffffc00001)},
+{0x1.00001ffff0000p+16, 0x1.ffff80001f000p-41, INT64_C(0x0000000000010000)},
+{-0x1.0000100000000p+12, 0x1.0000000000000p-93, INT64_C(0xfffffffffffff000)},
+{0x1.0038000800000p+41, -0x1.fffffe0000080p-19, INT64_C(0x0000020070000fff)},
+{-0x1.00003fe008000p+14, 0x1.fffdff0000080p-45, INT64_C(0xffffffffffffc000)},
+{0x1.0000100000000p+42, -0x1.0000000000000p-52, INT64_C(0x00000400003fffff)},
+{-0x1.00003ff002010p+17, 0x1.0000020000000p-48, INT64_C(0xfffffffffffe0000)},
+{0x1.00ffffffc0000p+8, 0x1.fffffe00003f0p-47, INT64_C(0x0000000000000100)},
+{-0x1.1fffffffff020p+39, 0x1.ffff000400000p-36, INT64_C(0xffffff7000000001)},
+{0x1.0200000000000p+33, -0x1.0000000000000p-20, INT64_C(0x0000000203ffffff)},
+{-0x1.0000700000000p+0, -0x1.ffffffe000000p-71, INT64_C(0xffffffffffffffff)},
+{0x1.00000ffffffd0p+33, -0x1.ffffff8200000p-33, INT64_C(0x0000000200001fff)},
+{-0x1.00000c0000004p+59, 0x1.ff80000800000p-9, INT64_C(0xf7ffff9ffffffe01)},
+{0x1.1ffff80000040p+5, -0x1.0000000000000p-85, INT64_C(0x0000000000000023)},
+{-0x1.0ffffff9ffff0p+58, -0x1.f800008200000p-12, INT64_C(0xfbc0000018000400)},
+{0x1.000000ffffff8p+13, 0x1.ff0000007ffc0p-46, INT64_C(0x0000000000002000)},
+{-0x1.0000008000000p+6, 0x1.fffffc0000008p-50, INT64_C(0xffffffffffffffc0)},
+{0x1.0000200000000p+25, -0x1.fffffff804000p-42, INT64_C(0x000000000200003f)},
+{-0x1.0000080000000p+61, 0x1.0000000000000p-34, INT64_C(0xdfffff0000000001)},
+{0x1.03ffff0000010p+42, -0x1.fffc010000000p-34, INT64_C(0x0000040ffffc0000)},
+{-0x1.7ffffffc00000p+38, -0x1.fff80000fc000p-23, INT64_C(0xffffffa000000100)},
+{0x1.0010000000000p+23, -0x1.ffffffffc4000p-44, INT64_C(0x00000000008007ff)},
+{-0x1.000007fffc004p+7, 0x1.8000004000000p-52, INT64_C(0xffffffffffffff80)},
+{0x1.7fe000001ff00p+11, 0x1.f000000000000p-90, INT64_C(0x0000000000000bff)},
+{-0x1.0ffffff000000p+0, -0x1.fffffff000000p-70, INT64_C(0xffffffffffffffff)},
+{0x1.0000010000000p+45, -0x1.ffffffffe4000p-17, INT64_C(0x00002000001fffff)},
+{-0x1.0000020000000p+50, 0x1.ff80000100000p-23, INT64_C(0xfffbfffff8000001)},
+{0x1.1ffffffff8000p+8, 0x1.fe001ffffffe0p-48, INT64_C(0x000000000000011f)},
+{-0x1.0000000fffe00p+44, -0x1.3fffff87fc000p-16, INT64_C(0xffffefffffff0002)},
+{0x1.0000000800000p+3, -0x1.0000000000000p-102, INT64_C(0x0000000000000008)},
+{-0x1.00fffffff8000p+3, -0x1.fffe000000000p-71, INT64_C(0xfffffffffffffff8)},
+{0x1.0007ffffffff0p+60, 0x1.fffffc0000000p-23, INT64_C(0x10007ffffffff000)},
+{-0x1.0003800000080p+32, 0x1.0000000000000p-73, INT64_C(0xfffffffefffc8000)},
+{0x1.000001fffff80p+14, 0x1.ff00000000000p-70, INT64_C(0x0000000000004000)},
+{-0x1.000007ffffe00p+52, 0x1.fe0c000004000p-6, INT64_C(0xffefffff80000201)},
+{0x1.00000003f0000p+56, 0x1.ffffffe000000p-22, INT64_C(0x0100000003f00000)},
+{-0x1.0100000000000p+5, 0x1.fffffff000080p-55, INT64_C(0xffffffffffffffe0)},
+{0x1.007fffffffc00p+16, 0x1.fffffe0000000p-66, INT64_C(0x000000000001007f)},
+{-0x1.007ffffffc000p+11, -0x1.ffffff8000000p-56, INT64_C(0xfffffffffffff7fd)},
+{0x1.0003fffffffe0p+61, 0x1.fffffff000780p+1, INT64_C(0x20007fffffffc003)},
+{-0x1.1ffff00800000p+3, 0x1.0000000000000p-94, INT64_C(0xfffffffffffffff8)},
+{0x1.000003fff8000p+9, 0x1.ffff00000003cp-46, INT64_C(0x0000000000000200)},
+{-0x1.000001ffff020p+48, 0x1.fff0000200000p-22, INT64_C(0xfffefffffe0000ff)},
+{0x1.00ffe00000000p+43, 0x1.fe00000000000p-17, INT64_C(0x00000807ff000000)},
+{-0x1.0000100000000p+29, 0x1.ffff800010000p-40, INT64_C(0xffffffffdffffe01)},
+{0x1.0100000000000p+52, -0x1.0000000000000p-35, INT64_C(0x00100fffffffffff)},
+{-0x1.000003fff8001p+19, 0x1.0000000000000p-64, INT64_C(0xfffffffffff80000)},
+{0x1.00f8000200000p+40, -0x1.ff80000100000p-33, INT64_C(0x00000100f80001ff)},
+{-0x1.003ffffffe000p+23, -0x1.f007fffffc000p-36, INT64_C(0xffffffffff7fe001)},
+{0x1.0000080000000p+55, -0x1.0000000000000p-50, INT64_C(0x00800003ffffffff)},
+{-0x1.0200000000000p+52, 0x1.0000000000000p-18, INT64_C(0xffefe00000000001)},
+{0x1.03fffffc00000p+6, 0x1.fe0000c000000p-54, INT64_C(0x0000000000000040)},
+{-0x1.7ff0000040000p+38, 0x1.0000000000000p-37, INT64_C(0xffffffa003fffff1)},
+{0x1.0000018000010p+16, -0x1.fffffe0200000p-58, INT64_C(0x0000000000010000)},
+{-0x1.001ffffffff00p+30, -0x1.ffffffe000000p-25, INT64_C(0xffffffffbff80001)},
+{0x1.07fc000007ffep+52, 0x1.8000000010000p-17, INT64_C(0x00107fc000007ffe)},
+{-0x1.0007fffffff00p+11, -0x1.fffe000000000p-79, INT64_C(0xfffffffffffff800)},
+{0x1.0000003fffffcp+31, 0x1.fffff8007fff0p-26, INT64_C(0x000000008000001f)},
+{-0x1.0000003f000f8p+4, -0x1.fffc03fffe000p-54, INT64_C(0xfffffffffffffff0)},
+{0x1.00000007ffe00p+2, 0x1.ffffe000007f8p-54, INT64_C(0x0000000000000004)},
+{-0x1.00001fffc0000p+12, -0x1.fffffffffe1f0p-45, INT64_C(0xfffffffffffff000)},
+{0x1.00001fffff801p+23, -0x1.80003f0000040p-36, INT64_C(0x000000000080000f)},
+{-0x1.00001ffffe000p+23, -0x1.f00001f000000p-41, INT64_C(0xffffffffff7ffff1)},
+{0x1.0000007007f80p+38, 0x1.c00ffffffe000p-27, INT64_C(0x0000004000001c01)},
+{-0x1.0000010000000p+26, 0x1.0000000000000p-79, INT64_C(0xfffffffffbfffffd)},
+{0x1.0000002000000p+7, -0x1.0000000000000p-98, INT64_C(0x0000000000000080)},
+{-0x1.00001ffe00010p+13, 0x1.0000000000000p-69, INT64_C(0xffffffffffffe000)},
+{0x1.0fe0000008000p+30, -0x1.c00007fffc100p-31, INT64_C(0x0000000043f80000)},
+{-0x1.0000001fc0000p+0, -0x1.ffc003ffff000p-65, INT64_C(0xffffffffffffffff)},
+{0x1.00007e3fffff0p+44, 0x1.ffff000000000p-28, INT64_C(0x0000100007e3ffff)},
+{-0x1.ffffff0002000p+56, 0x1.ffffc00000040p+2, INT64_C(0xfe000000fffe0008)},
+{0x1.0000ffffffc00p+21, 0x1.ffffffffffe00p-41, INT64_C(0x000000000020001f)},
+{-0x1.07ffff0000000p+35, -0x1.ffff0003ffffep-19, INT64_C(0xfffffff7c0000800)},
+{0x1.0000040000000p+18, -0x1.0000000000000p-74, INT64_C(0x0000000000040000)},
+{-0x1.0003ffffffe00p+55, -0x1.ffff800000000p-13, INT64_C(0xff7ffe0000001000)},
+{0x1.001fc00000300p+30, -0x1.ffff000040000p-41, INT64_C(0x000000004007f000)},
+{-0x1.07fffffc01000p+11, 0x1.ffffffe002000p-46, INT64_C(0xfffffffffffff7c1)},
+{0x1.03ffff81f8001p+55, -0x1.f800800000000p-22, INT64_C(0x0081ffffc0fc0007)},
+{-0x1.0040000000000p+4, 0x1.fffffffffffe0p-54, INT64_C(0xfffffffffffffff0)},
+{0x1.0008000000000p+47, -0x1.ffffffff01000p-18, INT64_C(0x00008003ffffffff)},
+{-0x1.0000010000000p+23, 0x1.0000000000000p-82, INT64_C(0xffffffffff800000)},
+{0x1.0000007fffff4p+62, -0x1.f800003ffffe0p+4, INT64_C(0x4000001fffffcfe0)},
+{-0x1.0000001ff8000p+12, -0x1.8003fffff0c00p-51, INT64_C(0xfffffffffffff000)},
+{0x1.00000007ffff8p+62, 0x1.ffffffffff000p+7, INT64_C(0x40000001ffffe0ff)},
+{-0x1.03ffffffffff8p+5, -0x1.fffffffc00000p-70, INT64_C(0xffffffffffffffe0)},
+{0x1.0003f00000040p+58, -0x1.fffffe0800000p-18, INT64_C(0x04000fc000000fff)},
+{-0x1.07fffffc00100p+55, 0x1.0000000000000p-27, INT64_C(0xff7c000001fff801)},
+{0x1.fffffe0000000p+57, 0x1.ffffffff00000p-16, INT64_C(0x03fffffc00000000)},
+{-0x1.0000000ffffe0p+53, -0x1.fffffff000000p-16, INT64_C(0xffdffffffe000040)},
+{0x1.0001fffff8000p-1, 0x1.fffffff800000p-69, INT64_C(0x0000000000000000)},
+{-0x1.001fffffff000p+45, -0x1.fffffc0000000p-13, INT64_C(0xffffdffc00000020)},
+{0x1.000f00007fff8p+2, 0x1.ffffff8000000p-60, INT64_C(0x0000000000000004)},
+{-0x1.0080000000000p+46, 0x1.0000000000000p-37, INT64_C(0xffffbfe000000001)},
+{0x1.7fffffffffffep+34, 0x0.0000000000000p+0, INT64_C(0x00000005ffffffff)},
+{-0x1.00000007ffffep+2, -0x1.ff003f8000380p-53, INT64_C(0xfffffffffffffffc)},
+{0x1.0067ffffe0000p+19, 0x1.fffffff800000p-52, INT64_C(0x000000000008033f)},
+{-0x1.1ff1000000000p+12, 0x1.fff0000100000p-61, INT64_C(0xffffffffffffee01)},
+{0x1.0000100000000p+46, -0x1.0000000000000p-33, INT64_C(0x0000400003ffffff)},
+{-0x1.0000ffe000080p+14, 0x1.fffffe0002000p-50, INT64_C(0xffffffffffffc000)},
+{0x1.0000100000000p+22, -0x1.ffffff0020000p-36, INT64_C(0x0000000000400003)},
+{-0x1.001fffff01f00p+22, -0x1.fffffff800000p-44, INT64_C(0xffffffffffbff801)},
+{0x1.0000ffc000000p+35, 0x1.ff003fffffe00p-27, INT64_C(0x000000080007fe00)},
+{-0x1.07c0000001ff8p+54, -0x1.fffff00000000p-26, INT64_C(0xffbe0fffffff8020)},
+{0x1.0000400000000p+12, -0x1.8000000400000p-60, INT64_C(0x0000000000001000)},
+{-0x1.0000000300000p+30, 0x0.0000000000000p+0, INT64_C(0xffffffffc0000000)},
+{0x1.00ff000008000p+29, -0x1.fffff02000000p-38, INT64_C(0x00000000201fe000)},
+{-0x1.000fffff80000p+29, -0x1.3ffffffc00000p-46, INT64_C(0xffffffffdffe0001)},
+{0x1.007f8000007fcp+9, 0x1.fffffe0000000p-58, INT64_C(0x0000000000000200)},
+{-0x1.1ffffffffc004p+23, 0x1.0000000000000p-75, INT64_C(0xffffffffff700001)},
+{0x1.0000001f00010p+29, -0x1.0000000000000p-45, INT64_C(0x0000000020000003)},
+{-0x1.0007fffffe000p+5, -0x1.fffff80000300p-56, INT64_C(0xffffffffffffffe0)},
+{0x1.00003f0000800p+41, -0x1.ffffff8000080p-13, INT64_C(0x00000200007e0000)},
+{-0x1.000001ffffff0p+0, -0x1.fffc000000000p-80, INT64_C(0xffffffffffffffff)},
+{0x1.00007ffc00080p+24, -0x1.ffffffc000100p-30, INT64_C(0x000000000100007f)},
+{-0x1.0ffe000100000p+38, 0x1.fff8200000000p-48, INT64_C(0xffffffbc007fffc1)},
+{0x1.fffffff000008p+5, -0x1.8001000000000p-67, INT64_C(0x000000000000003f)},
+{-0x1.0000000800000p+32, 0x1.ffffc00200000p-24, INT64_C(0xfffffffefffffff9)},
+{0x1.7fffc00000000p+58, 0x1.ffffe00000000p-28, INT64_C(0x05ffff0000000000)},
+{-0x1.00fffffffff80p+40, 0x0.0000000000000p+0, INT64_C(0xfffffeff00000001)},
+{0x1.0010000000000p+28, -0x1.0000000000000p-61, INT64_C(0x000000001000ffff)},
+{-0x1.00ffffe07fc00p+30, -0x1.fffffc3000000p-24, INT64_C(0xffffffffbfc00008)},
+{0x1.000ffe0fffffep+38, 0x1.ffffc00000000p-49, INT64_C(0x0000004003ff83ff)},
+{-0x1.0000003ff0000p+24, -0x1.fffffff080000p-42, INT64_C(0xffffffffff000000)},
+{0x1.0000e00003ff8p+34, 0x1.ffffff8ffc000p-33, INT64_C(0x0000000400038000)},
+{-0x1.0080000000000p+47, 0x1.0000000000000p-58, INT64_C(0xffff7fc000000001)},
+{0x1.0008000000000p+19, 0x0.0000000000000p+0, INT64_C(0x0000000000080040)},
+{-0x1.0001fe0000002p+49, 0x1.fff0000080008p-7, INT64_C(0xfffdfffc04000000)},
+{0x1.03c03c0000020p+39, -0x1.0000000000000p-40, INT64_C(0x00000081e01e0000)},
+{-0x1.0001fff9c0008p+0, 0x1.ffffff0002000p-56, INT64_C(0xffffffffffffffff)},
+{0x1.ffffffff80000p+49, 0x1.fffffffffe000p-17, INT64_C(0x0003ffffffff0000)},
+{-0x1.0000fffc00000p+3, -0x1.1ffffe0000000p-60, INT64_C(0xfffffffffffffff8)},
+{0x1.0000020000000p+56, -0x1.0000000000000p-40, INT64_C(0x01000001ffffffff)},
+{-0x1.007fffffffffcp+41, -0x1.fffefffffff80p-19, INT64_C(0xfffffdff00000001)},
+{0x1.007ffffffffc0p+15, 0x1.ffffff8000000p-52, INT64_C(0x000000000000803f)},
+{-0x1.ffffff0000000p+60, -0x1.fffffffff0000p-2, INT64_C(0xe000001000000000)},
+{0x1.00000003f81ffp+0, 0x1.ffc0000000000p-82, INT64_C(0x0000000000000001)},
+{-0x1.0000001ff8039p+45, 0x1.ffff800080000p-27, INT64_C(0xffffdffffffc0100)},
+{0x1.0008000000000p+32, -0x1.f000000000080p-28, INT64_C(0x000000010007ffff)},
+{-0x1.00c1fffc00000p+21, -0x1.ffff800000000p-67, INT64_C(0xffffffffffdfe7c1)},
+{0x1.1fe0000080000p+15, -0x1.fffffe0000008p-39, INT64_C(0x0000000000008ff0)},
+{-0x1.01ffffff00000p+55, -0x1.ffffffe000000p-22, INT64_C(0xff7f000000800000)},
+{0x1.0000003ffffe0p+45, 0x0.0000000000000p+0, INT64_C(0x000020000007ffff)},
+{-0x1.003ffffe00000p+21, 0x0.0000000000000p+0, INT64_C(0xffffffffffdff801)},
+{0x1.00007fc000000p+54, 0x1.fffffff000000p-3, INT64_C(0x0040001ff0000000)},
+{-0x1.0000000000000p+58, 0x1.0000000000000p-14, INT64_C(0xfc00000000000001)},
+{0x1.0400000000000p+23, -0x1.0000000000000p-39, INT64_C(0x000000000081ffff)},
+{-0x1.000003fffff00p+32, -0x1.ffc00003c0000p-39, INT64_C(0xfffffffefffffc01)},
+{0x1.7ffffffffffe0p+9, 0x0.0000000000000p+0, INT64_C(0x00000000000002ff)},
+{-0x1.0000fffff0400p+59, 0x1.f000000fe0020p+1, INT64_C(0xf7fff800007e0004)},
+{0x1.0000000400000p+45, -0x1.fffe000010200p-17, INT64_C(0x0000200000007fff)},
+{-0x1.0ffe000008000p+41, 0x1.ffffffff80100p-20, INT64_C(0xfffffde003fffff1)},
+{0x1.4000000000000p+34, -0x1.0000000000000p-71, INT64_C(0x00000004ffffffff)},
+{-0x1.0000010000000p+54, 0x1.0000000000000p-16, INT64_C(0xffbfffffc0000001)},
+{0x1.fffffffc00000p+21, 0x1.fffff801ffffep-33, INT64_C(0x00000000003fffff)},
+{-0x1.00001ff7fc000p+60, -0x1.8000000001f80p+0, INT64_C(0xeffffe00803fffff)},
+{0x1.3e00001000000p+52, -0x1.e07ff80001000p-6, INT64_C(0x0013e00000ffffff)},
+{-0x1.0000000400000p+38, 0x1.0000000000000p-67, INT64_C(0xffffffbfffffff01)},
+{0x1.0000010000000p+62, -0x1.0000000000000p-12, INT64_C(0x4000003fffffffff)},
+{-0x1.000000ffc0008p+59, 0x1.0000000000000p-23, INT64_C(0xf7fffff801fffc01)},
+{0x1.0000002000000p+55, -0x1.ffffffffff004p+0, INT64_C(0x008000000ffffffe)},
+{-0x1.000001fffc000p+62, -0x1.fffffffffe000p+1, INT64_C(0xbfffff8000fffffd)},
+{0x1.001ffff800002p+36, -0x1.c3fe800000000p-33, INT64_C(0x0000001001ffff80)},
+{-0x1.00000ffffffe0p+26, -0x1.fff8000000000p-61, INT64_C(0xfffffffffbffffc1)},
+{0x1.00007fe080000p+59, -0x1.ff00040000000p-1, INT64_C(0x080003ff03ffffff)},
+{-0x1.0000001000000p+39, 0x1.0000000000000p-60, INT64_C(0xffffff7ffffff801)},
+{0x1.0000003f80002p+48, -0x1.0000000000000p-52, INT64_C(0x00010000003f8000)},
+{-0x1.0800000000000p+28, 0x1.0000000000000p-26, INT64_C(0xffffffffef800001)},
+{0x1.0000004000000p+4, -0x1.fc000000fff08p-52, INT64_C(0x0000000000000010)},
+{-0x1.0000ff8000000p+55, -0x1.f803ff0000000p-26, INT64_C(0xff7fff8040000000)},
+
+// Out-of-range values:
+{0x1.3fffffff80000p+666, 0x1.ffffffff00000p+593, INT64_C(0x7fffffffffffffff)},
+{-0x1.007fffffe0000p+756, 0x0.0000000000000p+0, INT64_C(0x8000000000000000)},
+{0x1.00001ffff8000p+939, 0x1.00007f001e000p+884, INT64_C(0x7fffffffffffffff)},
+{-0x1.3dfffffffc000p+294, -0x1.ff000003ffe00p+233, INT64_C(0x8000000000000000)},
+{0x1.0000000000000p+1023, -0x1.0000000000000p+953, INT64_C(0x7fffffffffffffff)},
+{-0x1.001fffffffe00p+730, 0x0.0000000000000p+0, INT64_C(0x8000000000000000)},
+{0x1.0000002000000p+702, -0x1.0000000000000p+602, INT64_C(0x7fffffffffffffff)},
+{-0x1.01ffffffe0000p+902, -0x1.c000000200000p+841, INT64_C(0x8000000000000000)},
+{0x1.00003fe0c4000p+973, -0x1.fffc032000000p+910, INT64_C(0x7fffffffffffffff)},
+{-0x1.000ffffff8000p+593, -0x1.ffffffffffc00p+538, INT64_C(0x8000000000000000)},
+{0x1.0007ffff00000p+383, 0x1.fffff80000000p+313, INT64_C(0x7fffffffffffffff)},
+{-0x1.01ffffffc0004p+997, 0x1.fffc100000000p+936, INT64_C(0x8000000000000000)},
+{0x1.0000001000000p+62, -0x1.ffffff0000800p-2, INT64_C(0x40000003ffffffff)},
+{-0x1.00000003ff800p+64, -0x1.ffffe00000000p-22, INT64_C(0x8000000000000000)},
+{0x1.003ffffff8000p+696, 0x1.f00000007fc00p+638, INT64_C(0x7fffffffffffffff)},
+{-0x1.1ffff80000000p+591, -0x1.ffffff7ff8000p+532, INT64_C(0x8000000000000000)},
+{0x1.00ff000000004p+69, -0x1.ffffff0000400p+6, INT64_C(0x7fffffffffffffff)},
+{-0x1.0008000000000p+75, 0x1.0000000000000p+7, INT64_C(0x8000000000000000)},
+{0x1.0000183ffffc0p+670, 0x1.fff07fcfffffcp+616, INT64_C(0x7fffffffffffffff)},
+{-0x1.0000010000000p+363, 0x1.0000000000000p+288, INT64_C(0x8000000000000000)},
+{0x1.1fffffff00000p+890, 0x1.fffffff000000p+813, INT64_C(0x7fffffffffffffff)},
+{-0x1.0000ffffff000p+38, -0x1.ffe000003ffe0p-20, INT64_C(0xffffffbfffc00001)},
+{0x1.000003fffff80p+967, 0x1.f007ffe00fc00p+904, INT64_C(0x7fffffffffffffff)},
+{-0x1.0000ffffff81fp+121, -0x1.ffc7fff800000p+57, INT64_C(0x8000000000000000)},
+{0x1.0000400000000p+600, -0x1.0000000000000p+509, INT64_C(0x7fffffffffffffff)},
+{-0x1.0000004000000p+707, 0x1.0000000000000p+649, INT64_C(0x8000000000000000)},
+{0x1.8000000000000p+850, -0x1.ffe7ffc001000p+785, INT64_C(0x7fffffffffffffff)},
+{-0x1.0000000800000p+842, 0x1.fffffff400000p+767, INT64_C(0x8000000000000000)},
+{0x1.007fc00007800p+448, 0x1.e0000f80001e0p+390, INT64_C(0x7fffffffffffffff)},
+{-0x1.3fffff0000000p+131, -0x1.fffffe0000000p+68, INT64_C(0x8000000000000000)},
+{0x1.0000200000000p+733, -0x1.0000000000000p+628, INT64_C(0x7fffffffffffffff)},
+{-0x1.7fe0000000008p+383, 0x1.fffff3ff80200p+321, INT64_C(0x8000000000000000)},
+
+// Values smaller than one:
+{0x1.00001ffffff00p-784, 0x1.fffff83ff8000p-839, INT64_C(0x0000000000000000)},
+{-0x1.00ffc00ffff00p-771, -0x1.fe0007fffff00p-827, INT64_C(0x0000000000000000)},
+{0x1.00001fffff800p-705, 0x1.fffffffe00000p-779, INT64_C(0x0000000000000000)},
+{-0x1.0000000800000p-800, 0x1.0000000000000p-872, INT64_C(0x0000000000000000)},
+{0x1.000003fffc002p-916, -0x1.0000000000000p-1021, INT64_C(0x0000000000000000)},
+{-0x1.000003ffffffep-19, 0x1.ffe0080000000p-103, INT64_C(0x0000000000000000)},
+{0x1.0800000000000p-211, -0x1.0000000000000p-307, INT64_C(0x0000000000000000)},
+{-0x1.0000007fffc00p-464, -0x1.efe0000000000p-558, INT64_C(0x0000000000000000)},
+{0x1.3fe0000100000p-20, -0x1.0000000000000p-93, INT64_C(0x0000000000000000)},
+{-0x1.3fffffffffe00p-397, -0x1.fe00040000000p-472, INT64_C(0x0000000000000000)},
+{0x1.0001fff800000p-371, 0x1.ffffff0000ffep-425, INT64_C(0x0000000000000000)},
+{-0x1.00ff000000800p-806, 0x1.0000000800000p-872, INT64_C(0x0000000000000000)},
+{0x1.0000800000000p-723, -0x1.ffffffe400000p-786, INT64_C(0x0000000000000000)},
+{-0x1.000001ffffffap-94, 0x1.ffe1f80400000p-169, INT64_C(0x0000000000000000)},
+{0x1.0000010000000p-343, -0x1.0000000000000p-448, INT64_C(0x0000000000000000)},
+{-0x1.007fffffffc00p-425, -0x1.fffffc0000000p-496, INT64_C(0x0000000000000000)},
+{0x1.0080000000000p-417, -0x1.0000000000000p-490, INT64_C(0x0000000000000000)},
+{-0x1.001ffffffc000p-985, -0x1.0000000000000p-1039, INT64_C(0x0000000000000000)},
+{0x1.000001fffff80p-758, 0x1.fffffc001fffcp-813, INT64_C(0x0000000000000000)},
+{-0x1.00f3ffffff000p-189, -0x1.fff8000000000p-257, INT64_C(0x0000000000000000)},
+{0x1.0000001ffff80p-98, 0x1.fffffdfffff8ep-152, INT64_C(0x0000000000000000)},
+{-0x1.0001fff800ffep-251, -0x1.c000000000000p-354, INT64_C(0x0000000000000000)},
+{0x1.00000007ff800p-179, 0x1.ffff800000000p-267, INT64_C(0x0000000000000000)},
+{-0x1.000001fff8008p-475, 0x1.0000000000000p-557, INT64_C(0x0000000000000000)},
+{0x1.007fbfffffcf0p-964, 0x1.ffff803ffe000p-1019, INT64_C(0x0000000000000000)},
+{-0x1.0000001fc4000p-493, 0x1.fe003ffe00000p-549, INT64_C(0x0000000000000000)},
+{0x1.0007e3ffe0000p-845, 0x1.fe0ffffffe000p-909, INT64_C(0x0000000000000000)},
+{-0x1.0000200000000p-1021, 0x0.0000000000000p+0, INT64_C(0x0000000000000000)},
+{0x1.0000001000000p-487, -0x1.fffffff804000p-554, INT64_C(0x0000000000000000)},
+{-0x1.000000ffff800p-309, -0x1.fffffc0000000p-392, INT64_C(0x0000000000000000)},
+{0x1.0001000000000p-455, -0x1.fffffff800400p-518, INT64_C(0x0000000000000000)},
+{-0x1.0000800000000p-998, 0x1.0000000000000p-1070, INT64_C(0x0000000000000000)},
+};
+
+const int numTestCases = sizeof(testCases) / sizeof(struct testVector);
+
+int64_t __fixtfdi(long double x);
+
+int main(int argc, char *argv[]) {
+	
+	int i;
+	DD input;
+	int64_t expected_result, computed_result;
+	
+	for (i=0; i<numTestCases; ++i) {
+		input.hi = testCases[i].xhi;
+		input.lo = testCases[i].xlo;
+		expected_result = testCases[i].result;
+		
+		computed_result = __fixtfdi(input.ld);
+		
+		if (computed_result != expected_result) {
+			printf("Error for __fixtfdi at %La = ( %a , %a ):\n", input.ld, input.hi, input.lo);
+			printf("\tExpected %016llx ( %lld )\n", expected_result, expected_result);
+			printf("\tComputed %016llx ( %lld )\n", computed_result, computed_result);
+			
+			return 1;
+		}
+	}
+	
+	return 0;
+}
\ No newline at end of file
diff --git a/compiler-rt/test/builtins/Unit/ppc/floatditf_test.c b/compiler-rt/test/builtins/Unit/ppc/floatditf_test.c
new file mode 100644
index 0000000..71ecf7c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/floatditf_test.c
@@ -0,0 +1,30 @@
+#include <stdint.h>
+#include <stdio.h>
+
+COMPILER_RT_ABI long double __floatditf(int64_t);
+
+#include "floatunditf_test.h"
+#include "DD.h"
+
+int main(int argc, char *argv[]) {
+	int i;
+	
+	DD expected;
+	DD computed;
+	
+	for (i=0; i<numTests; ++i) {
+		expected.hi = tests[i].hi;
+		expected.lo = tests[i].lo;
+		computed.ld = __floatditf(tests[i].input);
+		
+		if ((computed.hi != expected.hi) || (computed.lo != expected.lo))
+		{
+			printf("Error on __floatunditf( 0x%016llx ):\n", tests[i].input);
+			printf("\tExpected %La = ( %a , %a )\n", expected.ld, expected.hi, expected.lo);
+			printf("\tComputed %La = ( %a , %a )\n", computed.ld, computed.hi, computed.lo);
+			return 1;
+		}
+	}
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ppc/floatditf_test.h b/compiler-rt/test/builtins/Unit/ppc/floatditf_test.h
new file mode 100644
index 0000000..8b47e17
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/floatditf_test.h
@@ -0,0 +1,38018 @@
+struct testCase {
+	uint64_t input;
+	double hi;
+	double lo;
+};
+
+struct testCase tests[] = {
+{ INT64_C(0x0000000000000061), 0x1.84p+6, 0x0p+0 },
+{ INT64_C(0xffffffffffffff9e), -0x1.88p+6, 0x0p+0 },
+{ INT64_C(0x0000000000000062), 0x1.88p+6, 0x0p+0 },
+{ INT64_C(0xffffffffffffff9d), -0x1.8cp+6, 0x0p+0 },
+{ INT64_C(0x0000000000000403), 0x1.00cp+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffbfc), -0x1.01p+10, 0x0p+0 },
+{ INT64_C(0x000000000000040a), 0x1.028p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffbf5), -0x1.02cp+10, 0x0p+0 },
+{ INT64_C(0x000000000000040c), 0x1.03p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffbf3), -0x1.034p+10, 0x0p+0 },
+{ INT64_C(0x000000000000040e), 0x1.038p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffbf1), -0x1.03cp+10, 0x0p+0 },
+{ INT64_C(0x0000000000000418), 0x1.06p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffbe7), -0x1.064p+10, 0x0p+0 },
+{ INT64_C(0x000000000000041a), 0x1.068p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffbe5), -0x1.06cp+10, 0x0p+0 },
+{ INT64_C(0x0000000000000504), 0x1.41p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffafb), -0x1.414p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000506), 0x1.418p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffaf9), -0x1.41cp+10, 0x0p+0 },
+{ INT64_C(0x0000000000000510), 0x1.44p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffaef), -0x1.444p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000518), 0x1.46p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffffae7), -0x1.464p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000602), 0x1.808p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9fd), -0x1.80cp+10, 0x0p+0 },
+{ INT64_C(0x0000000000000603), 0x1.80cp+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9fc), -0x1.81p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000608), 0x1.82p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9f7), -0x1.824p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000609), 0x1.824p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9f6), -0x1.828p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000640), 0x1.9p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9bf), -0x1.904p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000642), 0x1.908p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9bd), -0x1.90cp+10, 0x0p+0 },
+{ INT64_C(0x0000000000000648), 0x1.92p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff9b7), -0x1.924p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000660), 0x1.98p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff99f), -0x1.984p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000680), 0x1.ap+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff97f), -0x1.a04p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000681), 0x1.a04p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff97e), -0x1.a08p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000688), 0x1.a2p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff977), -0x1.a24p+10, 0x0p+0 },
+{ INT64_C(0x0000000000000690), 0x1.a4p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff96f), -0x1.a44p+10, 0x0p+0 },
+{ INT64_C(0x00000000000006a0), 0x1.a8p+10, 0x0p+0 },
+{ INT64_C(0xfffffffffffff95f), -0x1.a84p+10, 0x0p+0 },
+{ INT64_C(0x0000000000002003), 0x1.0018p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdffc), -0x1.002p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002009), 0x1.0048p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdff6), -0x1.005p+13, 0x0p+0 },
+{ INT64_C(0x000000000000200c), 0x1.006p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdff3), -0x1.0068p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002082), 0x1.041p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdf7d), -0x1.0418p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002090), 0x1.048p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdf6f), -0x1.0488p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002098), 0x1.04cp+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdf67), -0x1.04c8p+13, 0x0p+0 },
+{ INT64_C(0x00000000000020c0), 0x1.06p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdf3f), -0x1.0608p+13, 0x0p+0 },
+{ INT64_C(0x00000000000020c2), 0x1.061p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdf3d), -0x1.0618p+13, 0x0p+0 },
+{ INT64_C(0x00000000000020e0), 0x1.07p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdf1f), -0x1.0708p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002202), 0x1.101p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffddfd), -0x1.1018p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002208), 0x1.104p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffddf7), -0x1.1048p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002209), 0x1.1048p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffddf6), -0x1.105p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002240), 0x1.12p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffddbf), -0x1.1208p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002241), 0x1.1208p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffddbe), -0x1.121p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002250), 0x1.128p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffddaf), -0x1.1288p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002404), 0x1.202p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbfb), -0x1.2028p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002405), 0x1.2028p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbfa), -0x1.203p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002420), 0x1.21p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbdf), -0x1.2108p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002421), 0x1.2108p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbde), -0x1.211p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002424), 0x1.212p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbdb), -0x1.2128p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002430), 0x1.218p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbcf), -0x1.2188p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002440), 0x1.22p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbbf), -0x1.2208p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002442), 0x1.221p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbbd), -0x1.2218p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002450), 0x1.228p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdbaf), -0x1.2288p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002500), 0x1.28p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdaff), -0x1.2808p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002504), 0x1.282p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdafb), -0x1.2828p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002508), 0x1.284p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdaf7), -0x1.2848p+13, 0x0p+0 },
+{ INT64_C(0x0000000000002520), 0x1.29p+13, 0x0p+0 },
+{ INT64_C(0xffffffffffffdadf), -0x1.2908p+13, 0x0p+0 },
+{ INT64_C(0x0000000000020041), 0x1.00208p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdffbe), -0x1.0021p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020042), 0x1.0021p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdffbd), -0x1.00218p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020050), 0x1.0028p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdffaf), -0x1.00288p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020051), 0x1.00288p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdffae), -0x1.0029p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020060), 0x1.003p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdff9f), -0x1.00308p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020062), 0x1.0031p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdff9d), -0x1.00318p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020070), 0x1.0038p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdff8f), -0x1.00388p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020202), 0x1.0101p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfdfd), -0x1.01018p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020204), 0x1.0102p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfdfb), -0x1.01028p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020210), 0x1.0108p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfdef), -0x1.01088p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020218), 0x1.010cp+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfde7), -0x1.010c8p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020300), 0x1.018p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfcff), -0x1.01808p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020302), 0x1.0181p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfcfd), -0x1.01818p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020310), 0x1.0188p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdfcef), -0x1.01888p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020801), 0x1.04008p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf7fe), -0x1.0401p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020802), 0x1.0401p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf7fd), -0x1.04018p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020820), 0x1.041p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf7df), -0x1.04108p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020824), 0x1.0412p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf7db), -0x1.04128p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020828), 0x1.0414p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf7d7), -0x1.04148p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020a00), 0x1.05p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf5ff), -0x1.05008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020a08), 0x1.0504p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf5f7), -0x1.05048p+17, 0x0p+0 },
+{ INT64_C(0x0000000000020a40), 0x1.052p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdf5bf), -0x1.05208p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021002), 0x1.0801p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdeffd), -0x1.08018p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021020), 0x1.081p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdefdf), -0x1.08108p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021024), 0x1.0812p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdefdb), -0x1.08128p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021030), 0x1.0818p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdefcf), -0x1.08188p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021100), 0x1.088p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdeeff), -0x1.08808p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021104), 0x1.0882p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdeefb), -0x1.08828p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021108), 0x1.0884p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdeef7), -0x1.08848p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021110), 0x1.0888p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdeeef), -0x1.08888p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021180), 0x1.08cp+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffdee7f), -0x1.08c08p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021800), 0x1.0cp+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffde7ff), -0x1.0c008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021804), 0x1.0c02p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffde7fb), -0x1.0c028p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021840), 0x1.0c2p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffde7bf), -0x1.0c208p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021a00), 0x1.0dp+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffde5ff), -0x1.0d008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000021c00), 0x1.0ep+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffde3ff), -0x1.0e008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030008), 0x1.8004p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfff7), -0x1.80048p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030020), 0x1.801p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcffdf), -0x1.80108p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030022), 0x1.8011p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcffdd), -0x1.80118p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030024), 0x1.8012p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcffdb), -0x1.80128p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030200), 0x1.81p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfdff), -0x1.81008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030202), 0x1.8101p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfdfd), -0x1.81018p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030204), 0x1.8102p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfdfb), -0x1.81028p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030210), 0x1.8108p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfdef), -0x1.81088p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030300), 0x1.818p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfcff), -0x1.81808p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030400), 0x1.82p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfbff), -0x1.82008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030401), 0x1.82008p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfbfe), -0x1.8201p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030410), 0x1.8208p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfbef), -0x1.82088p+17, 0x0p+0 },
+{ INT64_C(0x0000000000030500), 0x1.828p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcfaff), -0x1.82808p+17, 0x0p+0 },
+{ INT64_C(0x0000000000032000), 0x1.9p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcdfff), -0x1.90008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000032004), 0x1.9002p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcdffb), -0x1.90028p+17, 0x0p+0 },
+{ INT64_C(0x0000000000032040), 0x1.902p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcdfbf), -0x1.90208p+17, 0x0p+0 },
+{ INT64_C(0x0000000000032400), 0x1.92p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcdbff), -0x1.92008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000032800), 0x1.94p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffcd7ff), -0x1.94008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000033000), 0x1.98p+17, 0x0p+0 },
+{ INT64_C(0xfffffffffffccfff), -0x1.98008p+17, 0x0p+0 },
+{ INT64_C(0x0000000000040022), 0x1.00088p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbffdd), -0x1.0008cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000040028), 0x1.000ap+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbffd7), -0x1.000a4p+18, 0x0p+0 },
+{ INT64_C(0x0000000000040104), 0x1.0041p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfefb), -0x1.00414p+18, 0x0p+0 },
+{ INT64_C(0x0000000000040108), 0x1.0042p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfef7), -0x1.00424p+18, 0x0p+0 },
+{ INT64_C(0x000000000004010a), 0x1.00428p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfef5), -0x1.0042cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000040120), 0x1.0048p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfedf), -0x1.00484p+18, 0x0p+0 },
+{ INT64_C(0x0000000000040128), 0x1.004ap+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfed7), -0x1.004a4p+18, 0x0p+0 },
+{ INT64_C(0x0000000000040130), 0x1.004cp+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfecf), -0x1.004c4p+18, 0x0p+0 },
+{ INT64_C(0x0000000000040140), 0x1.005p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfebf), -0x1.00504p+18, 0x0p+0 },
+{ INT64_C(0x0000000000040148), 0x1.0052p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbfeb7), -0x1.00524p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041001), 0x1.04004p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbeffe), -0x1.04008p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041002), 0x1.04008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbeffd), -0x1.0400cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000041003), 0x1.0400cp+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbeffc), -0x1.0401p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041004), 0x1.0401p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbeffb), -0x1.04014p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041010), 0x1.0404p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbefef), -0x1.04044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041018), 0x1.0406p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbefe7), -0x1.04064p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041040), 0x1.041p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbefbf), -0x1.04104p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041042), 0x1.04108p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbefbd), -0x1.0410cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000041044), 0x1.0411p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbefbb), -0x1.04114p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041400), 0x1.05p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbebff), -0x1.05004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041404), 0x1.0501p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbebfb), -0x1.05014p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041440), 0x1.051p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbebbf), -0x1.05104p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041600), 0x1.058p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe9ff), -0x1.05804p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041800), 0x1.06p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe7ff), -0x1.06004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041802), 0x1.06008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe7fd), -0x1.0600cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000041820), 0x1.0608p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe7df), -0x1.06084p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041840), 0x1.061p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe7bf), -0x1.06104p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041a00), 0x1.068p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe5ff), -0x1.06804p+18, 0x0p+0 },
+{ INT64_C(0x0000000000041c00), 0x1.07p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbe3ff), -0x1.07004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044008), 0x1.1002p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbff7), -0x1.10024p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044080), 0x1.102p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbf7f), -0x1.10204p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044084), 0x1.1021p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbf7b), -0x1.10214p+18, 0x0p+0 },
+{ INT64_C(0x00000000000440c0), 0x1.103p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbf3f), -0x1.10304p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044200), 0x1.108p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbdff), -0x1.10804p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044201), 0x1.10804p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbdfe), -0x1.10808p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044204), 0x1.1081p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbdfb), -0x1.10814p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044240), 0x1.109p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbdbf), -0x1.10904p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044400), 0x1.11p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbbff), -0x1.11004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044402), 0x1.11008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbbfd), -0x1.1100cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000044408), 0x1.1102p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbbf7), -0x1.11024p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044420), 0x1.1108p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbbdf), -0x1.11084p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044480), 0x1.112p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbb7f), -0x1.11204p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044500), 0x1.114p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbbaff), -0x1.11404p+18, 0x0p+0 },
+{ INT64_C(0x0000000000044600), 0x1.118p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbb9ff), -0x1.11804p+18, 0x0p+0 },
+{ INT64_C(0x0000000000045000), 0x1.14p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbafff), -0x1.14004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000045001), 0x1.14004p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbaffe), -0x1.14008p+18, 0x0p+0 },
+{ INT64_C(0x0000000000045002), 0x1.14008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbaffd), -0x1.1400cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000045010), 0x1.1404p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbafef), -0x1.14044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000045080), 0x1.142p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbaf7f), -0x1.14204p+18, 0x0p+0 },
+{ INT64_C(0x0000000000045100), 0x1.144p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbaeff), -0x1.14404p+18, 0x0p+0 },
+{ INT64_C(0x0000000000045200), 0x1.148p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffbadff), -0x1.14804p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048002), 0x1.20008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7ffd), -0x1.2000cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000048003), 0x1.2000cp+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7ffc), -0x1.2001p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048010), 0x1.2004p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7fef), -0x1.20044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048018), 0x1.2006p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7fe7), -0x1.20064p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048040), 0x1.201p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7fbf), -0x1.20104p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048042), 0x1.20108p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7fbd), -0x1.2010cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000048060), 0x1.2018p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7f9f), -0x1.20184p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048400), 0x1.21p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7bff), -0x1.21004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048402), 0x1.21008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7bfd), -0x1.2100cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000048410), 0x1.2104p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7bef), -0x1.21044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048440), 0x1.211p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7bbf), -0x1.21104p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048480), 0x1.212p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb7b7f), -0x1.21204p+18, 0x0p+0 },
+{ INT64_C(0x0000000000048600), 0x1.218p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb79ff), -0x1.21804p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a000), 0x1.28p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5fff), -0x1.28004p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a004), 0x1.2801p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5ffb), -0x1.28014p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a008), 0x1.2802p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5ff7), -0x1.28024p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a010), 0x1.2804p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5fef), -0x1.28044p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a080), 0x1.282p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5f7f), -0x1.28204p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a200), 0x1.288p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5dff), -0x1.28804p+18, 0x0p+0 },
+{ INT64_C(0x000000000004a400), 0x1.29p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffffb5bff), -0x1.29004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060002), 0x1.80008p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9fffd), -0x1.8000cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000060003), 0x1.8000cp+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9fffc), -0x1.8001p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060010), 0x1.8004p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9ffef), -0x1.80044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060012), 0x1.80048p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9ffed), -0x1.8004cp+18, 0x0p+0 },
+{ INT64_C(0x0000000000060080), 0x1.802p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9ff7f), -0x1.80204p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060084), 0x1.8021p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9ff7b), -0x1.80214p+18, 0x0p+0 },
+{ INT64_C(0x00000000000600c0), 0x1.803p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9ff3f), -0x1.80304p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060200), 0x1.808p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9fdff), -0x1.80804p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060208), 0x1.8082p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9fdf7), -0x1.80824p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060210), 0x1.8084p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9fdef), -0x1.80844p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060280), 0x1.80ap+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9fd7f), -0x1.80a04p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060800), 0x1.82p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9f7ff), -0x1.82004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060808), 0x1.8202p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9f7f7), -0x1.82024p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060810), 0x1.8204p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9f7ef), -0x1.82044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060840), 0x1.821p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9f7bf), -0x1.82104p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060900), 0x1.824p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9f6ff), -0x1.82404p+18, 0x0p+0 },
+{ INT64_C(0x0000000000060c00), 0x1.83p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9f3ff), -0x1.83004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000064000), 0x1.9p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9bfff), -0x1.90004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000064001), 0x1.90004p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9bffe), -0x1.90008p+18, 0x0p+0 },
+{ INT64_C(0x0000000000064008), 0x1.9002p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9bff7), -0x1.90024p+18, 0x0p+0 },
+{ INT64_C(0x0000000000064010), 0x1.9004p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9bfef), -0x1.90044p+18, 0x0p+0 },
+{ INT64_C(0x0000000000064100), 0x1.904p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9beff), -0x1.90404p+18, 0x0p+0 },
+{ INT64_C(0x0000000000065000), 0x1.94p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff9afff), -0x1.94004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000066000), 0x1.98p+18, 0x0p+0 },
+{ INT64_C(0xfffffffffff99fff), -0x1.98004p+18, 0x0p+0 },
+{ INT64_C(0x0000000000400005), 0x1.000014p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbffffa), -0x1.000018p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400012), 0x1.000048p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfffed), -0x1.00004cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000400018), 0x1.00006p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfffe7), -0x1.000064p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400019), 0x1.000064p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfffe6), -0x1.000068p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400042), 0x1.000108p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfffbd), -0x1.00010cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000400060), 0x1.00018p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfff9f), -0x1.000184p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400068), 0x1.0001ap+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfff97), -0x1.0001a4p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400408), 0x1.00102p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbffbf7), -0x1.001024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400480), 0x1.0012p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbffb7f), -0x1.001204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400482), 0x1.001208p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbffb7d), -0x1.00120cp+22, 0x0p+0 },
+{ INT64_C(0x00000000004004a0), 0x1.00128p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbffb5f), -0x1.001284p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400600), 0x1.0018p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbff9ff), -0x1.001804p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400608), 0x1.00182p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbff9f7), -0x1.001824p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400610), 0x1.00184p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbff9ef), -0x1.001844p+22, 0x0p+0 },
+{ INT64_C(0x0000000000400640), 0x1.0019p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbff9bf), -0x1.001904p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402004), 0x1.00801p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdffb), -0x1.008014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402005), 0x1.008014p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdffa), -0x1.008018p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402006), 0x1.008018p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdff9), -0x1.00801cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000402040), 0x1.0081p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdfbf), -0x1.008104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402042), 0x1.008108p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdfbd), -0x1.00810cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000402044), 0x1.00811p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdfbb), -0x1.008114p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402060), 0x1.00818p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdf9f), -0x1.008184p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402080), 0x1.0082p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdf7f), -0x1.008204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402088), 0x1.00822p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdf77), -0x1.008224p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402090), 0x1.00824p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdf6f), -0x1.008244p+22, 0x0p+0 },
+{ INT64_C(0x00000000004020a0), 0x1.00828p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdf5f), -0x1.008284p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402400), 0x1.009p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdbff), -0x1.009004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402408), 0x1.00902p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdbf7), -0x1.009024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402410), 0x1.00904p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdbef), -0x1.009044p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402480), 0x1.0092p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfdb7f), -0x1.009204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402800), 0x1.00ap+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfd7ff), -0x1.00a004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402808), 0x1.00a02p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfd7f7), -0x1.00a024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402810), 0x1.00a04p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfd7ef), -0x1.00a044p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402880), 0x1.00a2p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfd77f), -0x1.00a204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000402a00), 0x1.00a8p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbfd5ff), -0x1.00a804p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420004), 0x1.08001p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdfffb), -0x1.080014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420040), 0x1.0801p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdffbf), -0x1.080104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420044), 0x1.08011p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdffbb), -0x1.080114p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420048), 0x1.08012p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdffb7), -0x1.080124p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420200), 0x1.0808p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdfdff), -0x1.080804p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420208), 0x1.08082p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdfdf7), -0x1.080824p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420220), 0x1.08088p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdfddf), -0x1.080884p+22, 0x0p+0 },
+{ INT64_C(0x0000000000420300), 0x1.080cp+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdfcff), -0x1.080c04p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422000), 0x1.088p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddfff), -0x1.088004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422004), 0x1.08801p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddffb), -0x1.088014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422010), 0x1.08804p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddfef), -0x1.088044p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422020), 0x1.08808p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddfdf), -0x1.088084p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422040), 0x1.0881p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddfbf), -0x1.088104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422080), 0x1.0882p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddf7f), -0x1.088204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422400), 0x1.089p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbddbff), -0x1.089004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000422800), 0x1.08ap+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdd7ff), -0x1.08a004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000424000), 0x1.09p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdbfff), -0x1.090004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000424001), 0x1.090004p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdbffe), -0x1.090008p+22, 0x0p+0 },
+{ INT64_C(0x0000000000424008), 0x1.09002p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdbff7), -0x1.090024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000424080), 0x1.0902p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdbf7f), -0x1.090204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000424100), 0x1.0904p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdbeff), -0x1.090404p+22, 0x0p+0 },
+{ INT64_C(0x0000000000425000), 0x1.094p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbdafff), -0x1.094004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000430000), 0x1.0cp+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcffff), -0x1.0c0004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000430002), 0x1.0c0008p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcfffd), -0x1.0c000cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000430004), 0x1.0c001p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcfffb), -0x1.0c0014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000430020), 0x1.0c008p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcffdf), -0x1.0c0084p+22, 0x0p+0 },
+{ INT64_C(0x0000000000430100), 0x1.0c04p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcfeff), -0x1.0c0404p+22, 0x0p+0 },
+{ INT64_C(0x0000000000430400), 0x1.0c1p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcfbff), -0x1.0c1004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000431000), 0x1.0c4p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcefff), -0x1.0c4004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000432000), 0x1.0c8p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbcdfff), -0x1.0c8004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000438000), 0x1.0ep+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbc7fff), -0x1.0e0004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440002), 0x1.100008p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfffd), -0x1.10000cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000440003), 0x1.10000cp+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfffc), -0x1.10001p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440004), 0x1.10001p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfffb), -0x1.100014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440010), 0x1.10004p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbffef), -0x1.100044p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440018), 0x1.10006p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbffe7), -0x1.100064p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440080), 0x1.1002p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbff7f), -0x1.100204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440084), 0x1.10021p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbff7b), -0x1.100214p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440090), 0x1.10024p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbff6f), -0x1.100244p+22, 0x0p+0 },
+{ INT64_C(0x00000000004400c0), 0x1.1003p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbff3f), -0x1.100304p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440100), 0x1.1004p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfeff), -0x1.100404p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440104), 0x1.10041p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfefb), -0x1.100414p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440140), 0x1.1005p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfebf), -0x1.100504p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440180), 0x1.1006p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfe7f), -0x1.100604p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440400), 0x1.101p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfbff), -0x1.101004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440404), 0x1.10101p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfbfb), -0x1.101014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440408), 0x1.10102p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfbf7), -0x1.101024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000440480), 0x1.1012p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbfb7f), -0x1.101204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000444000), 0x1.11p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbbfff), -0x1.110004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000444008), 0x1.11002p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbbff7), -0x1.110024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000444040), 0x1.1101p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbbfbf), -0x1.110104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000444100), 0x1.1104p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbbeff), -0x1.110404p+22, 0x0p+0 },
+{ INT64_C(0x0000000000444400), 0x1.111p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbbbff), -0x1.111004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000445000), 0x1.114p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbbafff), -0x1.114004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000446000), 0x1.118p+22, 0x0p+0 },
+{ INT64_C(0xffffffffffbb9fff), -0x1.118004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600002), 0x1.800008p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffffd), -0x1.80000cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000600004), 0x1.80001p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffffb), -0x1.800014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600040), 0x1.8001p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fffbf), -0x1.800104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600044), 0x1.80011p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fffbb), -0x1.800114p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600050), 0x1.80014p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fffaf), -0x1.800144p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600100), 0x1.8004p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffeff), -0x1.800404p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600102), 0x1.800408p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffefd), -0x1.80040cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000600110), 0x1.80044p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffeef), -0x1.800444p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600120), 0x1.80048p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffedf), -0x1.800484p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600140), 0x1.8005p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffebf), -0x1.800504p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600180), 0x1.8006p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffe7f), -0x1.800604p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600200), 0x1.8008p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffdff), -0x1.800804p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600201), 0x1.800804p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffdfe), -0x1.800808p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600202), 0x1.800808p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffdfd), -0x1.80080cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000600204), 0x1.80081p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffdfb), -0x1.800814p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600240), 0x1.8009p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffdbf), -0x1.800904p+22, 0x0p+0 },
+{ INT64_C(0x0000000000600280), 0x1.800ap+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ffd7f), -0x1.800a04p+22, 0x0p+0 },
+{ INT64_C(0x0000000000601000), 0x1.804p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fefff), -0x1.804004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000601002), 0x1.804008p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9feffd), -0x1.80400cp+22, 0x0p+0 },
+{ INT64_C(0x0000000000601020), 0x1.80408p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fefdf), -0x1.804084p+22, 0x0p+0 },
+{ INT64_C(0x0000000000601040), 0x1.8041p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fefbf), -0x1.804104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000601400), 0x1.805p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9febff), -0x1.805004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000602000), 0x1.808p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fdfff), -0x1.808004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000602008), 0x1.80802p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fdff7), -0x1.808024p+22, 0x0p+0 },
+{ INT64_C(0x0000000000602020), 0x1.80808p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fdfdf), -0x1.808084p+22, 0x0p+0 },
+{ INT64_C(0x0000000000602080), 0x1.8082p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fdf7f), -0x1.808204p+22, 0x0p+0 },
+{ INT64_C(0x0000000000602100), 0x1.8084p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fdeff), -0x1.808404p+22, 0x0p+0 },
+{ INT64_C(0x0000000000602200), 0x1.8088p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fddff), -0x1.808804p+22, 0x0p+0 },
+{ INT64_C(0x0000000000603000), 0x1.80cp+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9fcfff), -0x1.80c004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000620000), 0x1.88p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9dffff), -0x1.880004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000620004), 0x1.88001p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9dfffb), -0x1.880014p+22, 0x0p+0 },
+{ INT64_C(0x0000000000620040), 0x1.8801p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9dffbf), -0x1.880104p+22, 0x0p+0 },
+{ INT64_C(0x0000000000620400), 0x1.881p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9dfbff), -0x1.881004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000622000), 0x1.888p+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9ddfff), -0x1.888004p+22, 0x0p+0 },
+{ INT64_C(0x0000000000628000), 0x1.8ap+22, 0x0p+0 },
+{ INT64_C(0xffffffffff9d7fff), -0x1.8a0004p+22, 0x0p+0 },
+{ INT64_C(0x0000000004000005), 0x1.0000014p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffffa), -0x1.0000018p+26, 0x0p+0 },
+{ INT64_C(0x000000000400000a), 0x1.0000028p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffff5), -0x1.000002cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004000081), 0x1.0000204p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffff7e), -0x1.0000208p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000082), 0x1.0000208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffff7d), -0x1.000020cp+26, 0x0p+0 },
+{ INT64_C(0x00000000040000a0), 0x1.000028p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffff5f), -0x1.0000284p+26, 0x0p+0 },
+{ INT64_C(0x00000000040000a4), 0x1.000029p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffff5b), -0x1.0000294p+26, 0x0p+0 },
+{ INT64_C(0x00000000040000a8), 0x1.00002ap+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffff57), -0x1.00002a4p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000201), 0x1.0000804p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffdfe), -0x1.0000808p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000204), 0x1.000081p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffdfb), -0x1.0000814p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000206), 0x1.0000818p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffdf9), -0x1.000081cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004000208), 0x1.000082p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffdf7), -0x1.0000824p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000209), 0x1.0000824p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffdf6), -0x1.0000828p+26, 0x0p+0 },
+{ INT64_C(0x000000000400020c), 0x1.000083p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffdf3), -0x1.0000834p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000280), 0x1.0000ap+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffd7f), -0x1.0000a04p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000282), 0x1.0000a08p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffd7d), -0x1.0000a0cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004000284), 0x1.0000a1p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffd7b), -0x1.0000a14p+26, 0x0p+0 },
+{ INT64_C(0x00000000040002a0), 0x1.0000a8p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffd5f), -0x1.0000a84p+26, 0x0p+0 },
+{ INT64_C(0x00000000040002c0), 0x1.0000bp+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffd3f), -0x1.0000b04p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000401), 0x1.0001004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffbfe), -0x1.0001008p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000408), 0x1.000102p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffbf7), -0x1.0001024p+26, 0x0p+0 },
+{ INT64_C(0x000000000400040c), 0x1.000103p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffbf3), -0x1.0001034p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000410), 0x1.000104p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffbef), -0x1.0001044p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000414), 0x1.000105p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffbeb), -0x1.0001054p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000480), 0x1.00012p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffb7f), -0x1.0001204p+26, 0x0p+0 },
+{ INT64_C(0x0000000004000482), 0x1.0001208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffb7d), -0x1.000120cp+26, 0x0p+0 },
+{ INT64_C(0x00000000040004a0), 0x1.000128p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfffb5f), -0x1.0001284p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002002), 0x1.0008008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdffd), -0x1.000800cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004002004), 0x1.000801p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdffb), -0x1.0008014p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002006), 0x1.0008018p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdff9), -0x1.000801cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004002040), 0x1.00081p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdfbf), -0x1.0008104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002041), 0x1.0008104p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdfbe), -0x1.0008108p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002048), 0x1.000812p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdfb7), -0x1.0008124p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002050), 0x1.000814p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdfaf), -0x1.0008144p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002060), 0x1.000818p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdf9f), -0x1.0008184p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002400), 0x1.0009p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdbff), -0x1.0009004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002401), 0x1.0009004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdbfe), -0x1.0009008p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002404), 0x1.000901p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdbfb), -0x1.0009014p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002440), 0x1.00091p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdbbf), -0x1.0009104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002480), 0x1.00092p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdb7f), -0x1.0009204p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002500), 0x1.00094p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffdaff), -0x1.0009404p+26, 0x0p+0 },
+{ INT64_C(0x0000000004002600), 0x1.00098p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbffd9ff), -0x1.0009804p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008004), 0x1.002001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7ffb), -0x1.0020014p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008008), 0x1.002002p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7ff7), -0x1.0020024p+26, 0x0p+0 },
+{ INT64_C(0x000000000400800c), 0x1.002003p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7ff3), -0x1.0020034p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008020), 0x1.002008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7fdf), -0x1.0020084p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008028), 0x1.00200ap+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7fd7), -0x1.00200a4p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008200), 0x1.00208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7dff), -0x1.0020804p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008202), 0x1.0020808p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7dfd), -0x1.002080cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004008220), 0x1.002088p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7ddf), -0x1.0020884p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008280), 0x1.0020ap+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7d7f), -0x1.0020a04p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008300), 0x1.0020cp+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff7cff), -0x1.0020c04p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008800), 0x1.0022p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff77ff), -0x1.0022004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008802), 0x1.0022008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff77fd), -0x1.002200cp+26, 0x0p+0 },
+{ INT64_C(0x0000000004008808), 0x1.002202p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff77f7), -0x1.0022024p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008840), 0x1.00221p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff77bf), -0x1.0022104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008900), 0x1.00224p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff76ff), -0x1.0022404p+26, 0x0p+0 },
+{ INT64_C(0x0000000004008a00), 0x1.00228p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff75ff), -0x1.0022804p+26, 0x0p+0 },
+{ INT64_C(0x000000000400c000), 0x1.003p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff3fff), -0x1.0030004p+26, 0x0p+0 },
+{ INT64_C(0x000000000400c002), 0x1.0030008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff3ffd), -0x1.003000cp+26, 0x0p+0 },
+{ INT64_C(0x000000000400c010), 0x1.003004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff3fef), -0x1.0030044p+26, 0x0p+0 },
+{ INT64_C(0x000000000400c080), 0x1.00302p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff3f7f), -0x1.0030204p+26, 0x0p+0 },
+{ INT64_C(0x000000000400c800), 0x1.0032p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbff37ff), -0x1.0032004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020008), 0x1.008002p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfff7), -0x1.0080024p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020009), 0x1.0080024p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfff6), -0x1.0080028p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020010), 0x1.008004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdffef), -0x1.0080044p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020018), 0x1.008006p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdffe7), -0x1.0080064p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020100), 0x1.00804p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfeff), -0x1.0080404p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020108), 0x1.008042p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfef7), -0x1.0080424p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020110), 0x1.008044p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfeef), -0x1.0080444p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020120), 0x1.008048p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfedf), -0x1.0080484p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020180), 0x1.00806p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdfe7f), -0x1.0080604p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020800), 0x1.0082p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdf7ff), -0x1.0082004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020808), 0x1.008202p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdf7f7), -0x1.0082024p+26, 0x0p+0 },
+{ INT64_C(0x0000000004020880), 0x1.00822p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdf77f), -0x1.0082204p+26, 0x0p+0 },
+{ INT64_C(0x0000000004022000), 0x1.0088p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfddfff), -0x1.0088004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004022001), 0x1.0088004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfddffe), -0x1.0088008p+26, 0x0p+0 },
+{ INT64_C(0x0000000004022004), 0x1.008801p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfddffb), -0x1.0088014p+26, 0x0p+0 },
+{ INT64_C(0x0000000004022010), 0x1.008804p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfddfef), -0x1.0088044p+26, 0x0p+0 },
+{ INT64_C(0x0000000004022100), 0x1.00884p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfddeff), -0x1.0088404p+26, 0x0p+0 },
+{ INT64_C(0x0000000004023000), 0x1.008cp+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfdcfff), -0x1.008c004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004030000), 0x1.00cp+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfcffff), -0x1.00c0004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004030004), 0x1.00c001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfcfffb), -0x1.00c0014p+26, 0x0p+0 },
+{ INT64_C(0x0000000004030040), 0x1.00c01p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfcffbf), -0x1.00c0104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004030080), 0x1.00c02p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfcff7f), -0x1.00c0204p+26, 0x0p+0 },
+{ INT64_C(0x0000000004030800), 0x1.00c2p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfcf7ff), -0x1.00c2004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004038000), 0x1.00ep+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbfc7fff), -0x1.00e0004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200001), 0x1.0800004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdffffe), -0x1.0800008p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200004), 0x1.080001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdffffb), -0x1.0800014p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200020), 0x1.080008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdfffdf), -0x1.0800084p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200024), 0x1.080009p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdfffdb), -0x1.0800094p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200040), 0x1.08001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdfffbf), -0x1.0800104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200041), 0x1.0800104p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdfffbe), -0x1.0800108p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200044), 0x1.080011p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdfffbb), -0x1.0800114p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200060), 0x1.080018p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdfff9f), -0x1.0800184p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200100), 0x1.08004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdffeff), -0x1.0800404p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200101), 0x1.0800404p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdffefe), -0x1.0800408p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200104), 0x1.080041p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdffefb), -0x1.0800414p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200110), 0x1.080044p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdffeef), -0x1.0800444p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200800), 0x1.0802p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdff7ff), -0x1.0802004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200808), 0x1.080202p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdff7f7), -0x1.0802024p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200820), 0x1.080208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdff7df), -0x1.0802084p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200840), 0x1.08021p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdff7bf), -0x1.0802104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200880), 0x1.08022p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdff77f), -0x1.0802204p+26, 0x0p+0 },
+{ INT64_C(0x0000000004200c00), 0x1.0803p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdff3ff), -0x1.0803004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004208000), 0x1.082p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf7fff), -0x1.0820004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004208001), 0x1.0820004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf7ffe), -0x1.0820008p+26, 0x0p+0 },
+{ INT64_C(0x0000000004208010), 0x1.082004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf7fef), -0x1.0820044p+26, 0x0p+0 },
+{ INT64_C(0x0000000004208040), 0x1.08201p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf7fbf), -0x1.0820104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004208100), 0x1.08204p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf7eff), -0x1.0820404p+26, 0x0p+0 },
+{ INT64_C(0x0000000004208200), 0x1.08208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf7dff), -0x1.0820804p+26, 0x0p+0 },
+{ INT64_C(0x0000000004209000), 0x1.0824p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf6fff), -0x1.0824004p+26, 0x0p+0 },
+{ INT64_C(0x000000000420c000), 0x1.083p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdf3fff), -0x1.0830004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004210000), 0x1.084p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdeffff), -0x1.0840004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004210008), 0x1.084002p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdefff7), -0x1.0840024p+26, 0x0p+0 },
+{ INT64_C(0x0000000004210040), 0x1.08401p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdeffbf), -0x1.0840104p+26, 0x0p+0 },
+{ INT64_C(0x0000000004210200), 0x1.08408p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdefdff), -0x1.0840804p+26, 0x0p+0 },
+{ INT64_C(0x0000000004212000), 0x1.0848p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdedfff), -0x1.0848004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004218000), 0x1.086p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbde7fff), -0x1.0860004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004240000), 0x1.09p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbffff), -0x1.0900004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004240008), 0x1.090002p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbfff7), -0x1.0900024p+26, 0x0p+0 },
+{ INT64_C(0x0000000004240010), 0x1.090004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbffef), -0x1.0900044p+26, 0x0p+0 },
+{ INT64_C(0x0000000004240020), 0x1.090008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbffdf), -0x1.0900084p+26, 0x0p+0 },
+{ INT64_C(0x0000000004240200), 0x1.09008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbfdff), -0x1.0900804p+26, 0x0p+0 },
+{ INT64_C(0x0000000004241000), 0x1.0904p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbefff), -0x1.0904004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004242000), 0x1.0908p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbdfff), -0x1.0908004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004244000), 0x1.091p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbdbbfff), -0x1.0910004p+26, 0x0p+0 },
+{ INT64_C(0x0000000004260000), 0x1.098p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffbd9ffff), -0x1.0980004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000008), 0x1.400002p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafffff7), -0x1.4000024p+26, 0x0p+0 },
+{ INT64_C(0x000000000500000c), 0x1.400003p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafffff3), -0x1.4000034p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000020), 0x1.400008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffffdf), -0x1.4000084p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000028), 0x1.40000ap+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffffd7), -0x1.40000a4p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000030), 0x1.40000cp+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffffcf), -0x1.40000c4p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000200), 0x1.40008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafffdff), -0x1.4000804p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000204), 0x1.400081p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafffdfb), -0x1.4000814p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000220), 0x1.400088p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafffddf), -0x1.4000884p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000800), 0x1.4002p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafff7ff), -0x1.4002004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000802), 0x1.4002008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafff7fd), -0x1.400200cp+26, 0x0p+0 },
+{ INT64_C(0x0000000005000820), 0x1.400208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafff7df), -0x1.4002084p+26, 0x0p+0 },
+{ INT64_C(0x0000000005000a00), 0x1.40028p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafff5ff), -0x1.4002804p+26, 0x0p+0 },
+{ INT64_C(0x0000000005001000), 0x1.4004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffefff), -0x1.4004004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005001001), 0x1.4004004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffeffe), -0x1.4004008p+26, 0x0p+0 },
+{ INT64_C(0x0000000005001010), 0x1.400404p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffefef), -0x1.4004044p+26, 0x0p+0 },
+{ INT64_C(0x0000000005001100), 0x1.40044p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaffeeff), -0x1.4004404p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008000), 0x1.402p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff7fff), -0x1.4020004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008001), 0x1.4020004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff7ffe), -0x1.4020008p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008010), 0x1.402004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff7fef), -0x1.4020044p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008040), 0x1.40201p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff7fbf), -0x1.4020104p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008100), 0x1.40204p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff7eff), -0x1.4020404p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008200), 0x1.40208p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff7dff), -0x1.4020804p+26, 0x0p+0 },
+{ INT64_C(0x0000000005008800), 0x1.4022p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff77ff), -0x1.4022004p+26, 0x0p+0 },
+{ INT64_C(0x000000000500c000), 0x1.403p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaff3fff), -0x1.4030004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005010000), 0x1.404p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafeffff), -0x1.4040004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005010002), 0x1.4040008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafefffd), -0x1.404000cp+26, 0x0p+0 },
+{ INT64_C(0x0000000005010020), 0x1.404008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafeffdf), -0x1.4040084p+26, 0x0p+0 },
+{ INT64_C(0x0000000005010100), 0x1.40404p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafefeff), -0x1.4040404p+26, 0x0p+0 },
+{ INT64_C(0x0000000005011000), 0x1.4044p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafeefff), -0x1.4044004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005012000), 0x1.4048p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffafedfff), -0x1.4048004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005100000), 0x1.44p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaefffff), -0x1.4400004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005100004), 0x1.440001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaeffffb), -0x1.4400014p+26, 0x0p+0 },
+{ INT64_C(0x0000000005100020), 0x1.440008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaefffdf), -0x1.4400084p+26, 0x0p+0 },
+{ INT64_C(0x0000000005100040), 0x1.44001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaefffbf), -0x1.4400104p+26, 0x0p+0 },
+{ INT64_C(0x0000000005100200), 0x1.44008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaeffdff), -0x1.4400804p+26, 0x0p+0 },
+{ INT64_C(0x0000000005100400), 0x1.4401p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaeffbff), -0x1.4401004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005101000), 0x1.4404p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaefefff), -0x1.4404004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005104000), 0x1.441p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaefbfff), -0x1.4410004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005140000), 0x1.45p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffaebffff), -0x1.4500004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005200000), 0x1.48p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadfffff), -0x1.4800004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005200002), 0x1.4800008p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadffffd), -0x1.480000cp+26, 0x0p+0 },
+{ INT64_C(0x0000000005200010), 0x1.480004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadfffef), -0x1.4800044p+26, 0x0p+0 },
+{ INT64_C(0x0000000005200040), 0x1.48001p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadfffbf), -0x1.4800104p+26, 0x0p+0 },
+{ INT64_C(0x0000000005200100), 0x1.48004p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadffeff), -0x1.4800404p+26, 0x0p+0 },
+{ INT64_C(0x0000000005200400), 0x1.4801p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadffbff), -0x1.4801004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005202000), 0x1.4808p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadfdfff), -0x1.4808004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005204000), 0x1.481p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadfbfff), -0x1.4810004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005208000), 0x1.482p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadf7fff), -0x1.4820004p+26, 0x0p+0 },
+{ INT64_C(0x0000000005240000), 0x1.49p+26, 0x0p+0 },
+{ INT64_C(0xfffffffffadbffff), -0x1.4900004p+26, 0x0p+0 },
+{ INT64_C(0x0000000020000022), 0x1.0000011p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffdd), -0x1.00000118p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000024), 0x1.0000012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffdb), -0x1.00000128p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000025), 0x1.00000128p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffda), -0x1.0000013p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000028), 0x1.0000014p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffd7), -0x1.00000148p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000030), 0x1.0000018p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffcf), -0x1.00000188p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000034), 0x1.000001ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffcb), -0x1.000001a8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000038), 0x1.000001cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffc7), -0x1.000001c8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000044), 0x1.0000022p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffbb), -0x1.00000228p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000050), 0x1.0000028p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffaf), -0x1.00000288p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000058), 0x1.000002cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfffffa7), -0x1.000002c8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000102), 0x1.0000081p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffefd), -0x1.00000818p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000108), 0x1.0000084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffef7), -0x1.00000848p+29, 0x0p+0 },
+{ INT64_C(0x000000002000010c), 0x1.0000086p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffef3), -0x1.00000868p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000120), 0x1.000009p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffedf), -0x1.00000908p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000122), 0x1.0000091p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffedd), -0x1.00000918p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000128), 0x1.0000094p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffed7), -0x1.00000948p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000140), 0x1.00000ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffebf), -0x1.00000a08p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000148), 0x1.00000a4p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffeb7), -0x1.00000a48p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000160), 0x1.00000bp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffe9f), -0x1.00000b08p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000202), 0x1.0000101p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffdfd), -0x1.00001018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000210), 0x1.0000108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffdef), -0x1.00001088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000218), 0x1.000010cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffde7), -0x1.000010c8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000240), 0x1.000012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffdbf), -0x1.00001208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000244), 0x1.0000122p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffdbb), -0x1.00001228p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000404), 0x1.0000202p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbfb), -0x1.00002028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000420), 0x1.000021p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbdf), -0x1.00002108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000421), 0x1.00002108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbde), -0x1.0000211p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000422), 0x1.0000211p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbdd), -0x1.00002118p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000424), 0x1.0000212p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbdb), -0x1.00002128p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000440), 0x1.000022p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbbf), -0x1.00002208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000441), 0x1.00002208p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbbe), -0x1.0000221p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000448), 0x1.0000224p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbb7), -0x1.00002248p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000450), 0x1.0000228p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffffbaf), -0x1.00002288p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000808), 0x1.0000404p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff7f7), -0x1.00004048p+29, 0x0p+0 },
+{ INT64_C(0x000000002000080a), 0x1.0000405p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff7f5), -0x1.00004058p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000810), 0x1.0000408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff7ef), -0x1.00004088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000818), 0x1.000040cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff7e7), -0x1.000040c8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000900), 0x1.000048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff6ff), -0x1.00004808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000902), 0x1.0000481p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff6fd), -0x1.00004818p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000920), 0x1.000049p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff6df), -0x1.00004908p+29, 0x0p+0 },
+{ INT64_C(0x0000000020000980), 0x1.00004cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffff67f), -0x1.00004c08p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008001), 0x1.00040008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7ffe), -0x1.0004001p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008010), 0x1.0004008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7fef), -0x1.00040088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008014), 0x1.000400ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7feb), -0x1.000400a8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008020), 0x1.000401p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7fdf), -0x1.00040108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008022), 0x1.0004011p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7fdd), -0x1.00040118p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008030), 0x1.0004018p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7fcf), -0x1.00040188p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008100), 0x1.000408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7eff), -0x1.00040808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008101), 0x1.00040808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7efe), -0x1.0004081p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008102), 0x1.0004081p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7efd), -0x1.00040818p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008108), 0x1.0004084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7ef7), -0x1.00040848p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008180), 0x1.00040cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7e7f), -0x1.00040c08p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008200), 0x1.00041p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7dff), -0x1.00041008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008201), 0x1.00041008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7dfe), -0x1.0004101p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008210), 0x1.0004108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7def), -0x1.00041088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020008280), 0x1.000414p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff7d7f), -0x1.00041408p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a000), 0x1.0005p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5fff), -0x1.00050008p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a002), 0x1.0005001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5ffd), -0x1.00050018p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a004), 0x1.0005002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5ffb), -0x1.00050028p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a010), 0x1.0005008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5fef), -0x1.00050088p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a020), 0x1.000501p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5fdf), -0x1.00050108p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a040), 0x1.000502p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5fbf), -0x1.00050208p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a080), 0x1.000504p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5f7f), -0x1.00050408p+29, 0x0p+0 },
+{ INT64_C(0x000000002000a400), 0x1.00052p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff5bff), -0x1.00052008p+29, 0x0p+0 },
+{ INT64_C(0x000000002000b000), 0x1.00058p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfff4fff), -0x1.00058008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040002), 0x1.0020001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfffd), -0x1.00200018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040008), 0x1.0020004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfff7), -0x1.00200048p+29, 0x0p+0 },
+{ INT64_C(0x000000002004000c), 0x1.0020006p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfff3), -0x1.00200068p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040040), 0x1.002002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbffbf), -0x1.00200208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040044), 0x1.0020022p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbffbb), -0x1.00200228p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040400), 0x1.00202p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfbff), -0x1.00202008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040408), 0x1.0020204p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfbf7), -0x1.00202048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040420), 0x1.002021p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfbdf), -0x1.00202108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020040500), 0x1.002028p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbfaff), -0x1.00202808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020041000), 0x1.00208p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbefff), -0x1.00208008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020041008), 0x1.0020804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbeff7), -0x1.00208048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020041040), 0x1.002082p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbefbf), -0x1.00208208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020041400), 0x1.0020ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffbebff), -0x1.0020a008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020050000), 0x1.0028p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffaffff), -0x1.00280008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020050004), 0x1.0028002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffafffb), -0x1.00280028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020050010), 0x1.0028008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffaffef), -0x1.00280088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020050100), 0x1.002808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffafeff), -0x1.00280808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020050800), 0x1.00284p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffaf7ff), -0x1.00284008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020051000), 0x1.00288p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffaefff), -0x1.00288008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020054000), 0x1.002ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdffabfff), -0x1.002a0008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080004), 0x1.0040002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fffb), -0x1.00400028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080008), 0x1.0040004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fff7), -0x1.00400048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080010), 0x1.0040008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ffef), -0x1.00400088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080018), 0x1.004000cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ffe7), -0x1.004000c8p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080020), 0x1.004001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ffdf), -0x1.00400108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080024), 0x1.0040012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ffdb), -0x1.00400128p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080080), 0x1.004004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ff7f), -0x1.00400408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080084), 0x1.0040042p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ff7b), -0x1.00400428p+29, 0x0p+0 },
+{ INT64_C(0x00000000200800c0), 0x1.004006p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7ff3f), -0x1.00400608p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080200), 0x1.00401p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fdff), -0x1.00401008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080202), 0x1.0040101p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fdfd), -0x1.00401018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080210), 0x1.0040108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fdef), -0x1.00401088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080220), 0x1.004011p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fddf), -0x1.00401108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020080300), 0x1.004018p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7fcff), -0x1.00401808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020081000), 0x1.00408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7efff), -0x1.00408008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020081008), 0x1.0040804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7eff7), -0x1.00408048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020081010), 0x1.0040808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7efef), -0x1.00408088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020081100), 0x1.004088p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7eeff), -0x1.00408808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020081800), 0x1.0040cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7e7ff), -0x1.0040c008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082000), 0x1.0041p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7dfff), -0x1.00410008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082008), 0x1.0041004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7dff7), -0x1.00410048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082010), 0x1.0041008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7dfef), -0x1.00410088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082020), 0x1.004101p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7dfdf), -0x1.00410108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082040), 0x1.004102p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7dfbf), -0x1.00410208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082080), 0x1.004104p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7df7f), -0x1.00410408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020082400), 0x1.00412p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff7dbff), -0x1.00412008p+29, 0x0p+0 },
+{ INT64_C(0x00000000200a0000), 0x1.005p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff5ffff), -0x1.00500008p+29, 0x0p+0 },
+{ INT64_C(0x00000000200a0001), 0x1.00500008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff5fffe), -0x1.0050001p+29, 0x0p+0 },
+{ INT64_C(0x00000000200a0010), 0x1.0050008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff5ffef), -0x1.00500088p+29, 0x0p+0 },
+{ INT64_C(0x00000000200a0080), 0x1.005004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff5ff7f), -0x1.00500408p+29, 0x0p+0 },
+{ INT64_C(0x00000000200a0800), 0x1.00504p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff5f7ff), -0x1.00504008p+29, 0x0p+0 },
+{ INT64_C(0x00000000200a8000), 0x1.0054p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff57fff), -0x1.00540008p+29, 0x0p+0 },
+{ INT64_C(0x00000000200b0000), 0x1.0058p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdff4ffff), -0x1.00580008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100002), 0x1.0080001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffffd), -0x1.00800018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100003), 0x1.00800018p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffffc), -0x1.0080002p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100020), 0x1.008001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfefffdf), -0x1.00800108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100028), 0x1.0080014p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfefffd7), -0x1.00800148p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100200), 0x1.00801p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffdff), -0x1.00801008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100201), 0x1.00801008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffdfe), -0x1.0080101p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100204), 0x1.0080102p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffdfb), -0x1.00801028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100240), 0x1.008012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffdbf), -0x1.00801208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100300), 0x1.008018p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffcff), -0x1.00801808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100400), 0x1.00802p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffbff), -0x1.00802008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100401), 0x1.00802008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffbfe), -0x1.0080201p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100402), 0x1.0080201p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffbfd), -0x1.00802018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100410), 0x1.0080208p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffbef), -0x1.00802088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100500), 0x1.008028p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeffaff), -0x1.00802808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100800), 0x1.00804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeff7ff), -0x1.00804008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100802), 0x1.0080401p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeff7fd), -0x1.00804018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100820), 0x1.008041p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeff7df), -0x1.00804108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020100900), 0x1.008048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfeff6ff), -0x1.00804808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020101000), 0x1.00808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfefefff), -0x1.00808008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020101008), 0x1.0080804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfefeff7), -0x1.00808048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020101020), 0x1.008081p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfefefdf), -0x1.00808108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020101100), 0x1.008088p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfefeeff), -0x1.00808808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020108000), 0x1.0084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef7fff), -0x1.00840008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020108002), 0x1.0084001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef7ffd), -0x1.00840018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020108020), 0x1.008401p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef7fdf), -0x1.00840108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020108080), 0x1.008404p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef7f7f), -0x1.00840408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020108200), 0x1.00841p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef7dff), -0x1.00841008p+29, 0x0p+0 },
+{ INT64_C(0x000000002010a000), 0x1.0085p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef5fff), -0x1.00850008p+29, 0x0p+0 },
+{ INT64_C(0x000000002010c000), 0x1.0086p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfef3fff), -0x1.00860008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020180000), 0x1.00cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe7ffff), -0x1.00c00008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020180008), 0x1.00c0004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe7fff7), -0x1.00c00048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020180010), 0x1.00c0008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe7ffef), -0x1.00c00088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020180020), 0x1.00c001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe7ffdf), -0x1.00c00108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020180100), 0x1.00c008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe7feff), -0x1.00c00808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020180800), 0x1.00c04p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe7f7ff), -0x1.00c04008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020188000), 0x1.00c4p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe77fff), -0x1.00c40008p+29, 0x0p+0 },
+{ INT64_C(0x00000000201a0000), 0x1.00dp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdfe5ffff), -0x1.00d00008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800008), 0x1.0400004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ffff7), -0x1.04000048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800009), 0x1.04000048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ffff6), -0x1.0400005p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800010), 0x1.0400008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fffef), -0x1.04000088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800012), 0x1.0400009p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fffed), -0x1.04000098p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800080), 0x1.040004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fff7f), -0x1.04000408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800082), 0x1.0400041p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fff7d), -0x1.04000418p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800088), 0x1.0400044p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fff77), -0x1.04000448p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800090), 0x1.0400048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fff6f), -0x1.04000488p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800100), 0x1.040008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ffeff), -0x1.04000808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800108), 0x1.0400084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ffef7), -0x1.04000848p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800140), 0x1.04000ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ffebf), -0x1.04000a08p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800180), 0x1.04000cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ffe7f), -0x1.04000c08p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800800), 0x1.04004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ff7ff), -0x1.04004008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800801), 0x1.04004008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ff7fe), -0x1.0400401p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800810), 0x1.0400408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ff7ef), -0x1.04004088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800840), 0x1.040042p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ff7bf), -0x1.04004208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020800c00), 0x1.04006p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ff3ff), -0x1.04006008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020801000), 0x1.04008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fefff), -0x1.04008008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020801008), 0x1.0400804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7feff7), -0x1.04008048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020801020), 0x1.040081p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fefdf), -0x1.04008108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020801080), 0x1.040084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fef7f), -0x1.04008408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020801400), 0x1.0400ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7febff), -0x1.0400a008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802000), 0x1.0401p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fdfff), -0x1.04010008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802004), 0x1.0401002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fdffb), -0x1.04010028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802040), 0x1.040102p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fdfbf), -0x1.04010208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802080), 0x1.040104p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fdf7f), -0x1.04010408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802100), 0x1.040108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fdeff), -0x1.04010808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802200), 0x1.04011p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fddff), -0x1.04011008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020802400), 0x1.04012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7fdbff), -0x1.04012008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020808000), 0x1.0404p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f7fff), -0x1.04040008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020808001), 0x1.04040008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f7ffe), -0x1.0404001p+29, 0x0p+0 },
+{ INT64_C(0x0000000020808010), 0x1.0404008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f7fef), -0x1.04040088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020808080), 0x1.040404p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f7f7f), -0x1.04040408p+29, 0x0p+0 },
+{ INT64_C(0x0000000020808100), 0x1.040408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f7eff), -0x1.04040808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020809000), 0x1.04048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f6fff), -0x1.04048008p+29, 0x0p+0 },
+{ INT64_C(0x000000002080a000), 0x1.0405p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7f5fff), -0x1.04050008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810000), 0x1.0408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7effff), -0x1.04080008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810001), 0x1.04080008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7efffe), -0x1.0408001p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810002), 0x1.0408001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7efffd), -0x1.04080018p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810004), 0x1.0408002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7efffb), -0x1.04080028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810020), 0x1.040801p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7effdf), -0x1.04080108p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810040), 0x1.040802p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7effbf), -0x1.04080208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810100), 0x1.040808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7efeff), -0x1.04080808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020810400), 0x1.04082p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7efbff), -0x1.04082008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020814000), 0x1.040ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf7ebfff), -0x1.040a0008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020900000), 0x1.048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6fffff), -0x1.04800008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020900004), 0x1.0480002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6ffffb), -0x1.04800028p+29, 0x0p+0 },
+{ INT64_C(0x0000000020900040), 0x1.048002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6fffbf), -0x1.04800208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020900100), 0x1.048008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6ffeff), -0x1.04800808p+29, 0x0p+0 },
+{ INT64_C(0x0000000020900800), 0x1.04804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6ff7ff), -0x1.04804008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020901000), 0x1.04808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6fefff), -0x1.04808008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020908000), 0x1.0484p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6f7fff), -0x1.04840008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020910000), 0x1.0488p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6effff), -0x1.04880008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020940000), 0x1.04ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf6bffff), -0x1.04a00008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a00000), 0x1.05p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5fffff), -0x1.05000008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a00008), 0x1.0500004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5ffff7), -0x1.05000048p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a00010), 0x1.0500008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5fffef), -0x1.05000088p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a00040), 0x1.050002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5fffbf), -0x1.05000208p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a00400), 0x1.05002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5ffbff), -0x1.05002008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a01000), 0x1.05008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5fefff), -0x1.05008008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a08000), 0x1.0504p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5f7fff), -0x1.05040008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020a10000), 0x1.0508p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf5effff), -0x1.05080008p+29, 0x0p+0 },
+{ INT64_C(0x0000000020b00000), 0x1.058p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdf4fffff), -0x1.05800008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000008), 0x1.2000004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffff7), -0x1.20000048p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000040), 0x1.200002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffffbf), -0x1.20000208p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000042), 0x1.2000021p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffffbd), -0x1.20000218p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000050), 0x1.2000028p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffffaf), -0x1.20000288p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000200), 0x1.20001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffdff), -0x1.20001008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000201), 0x1.20001008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffdfe), -0x1.2000101p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000202), 0x1.2000101p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffdfd), -0x1.20001018p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000204), 0x1.2000102p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffdfb), -0x1.20001028p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000210), 0x1.2000108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffdef), -0x1.20001088p+29, 0x0p+0 },
+{ INT64_C(0x0000000024000300), 0x1.200018p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfffcff), -0x1.20001808p+29, 0x0p+0 },
+{ INT64_C(0x0000000024001000), 0x1.20008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffefff), -0x1.20008008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024001002), 0x1.2000801p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffeffd), -0x1.20008018p+29, 0x0p+0 },
+{ INT64_C(0x0000000024001008), 0x1.2000804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffeff7), -0x1.20008048p+29, 0x0p+0 },
+{ INT64_C(0x0000000024001040), 0x1.200082p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffefbf), -0x1.20008208p+29, 0x0p+0 },
+{ INT64_C(0x0000000024001100), 0x1.200088p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffeeff), -0x1.20008808p+29, 0x0p+0 },
+{ INT64_C(0x0000000024001800), 0x1.2000cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffe7ff), -0x1.2000c008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002000), 0x1.2001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffdfff), -0x1.20010008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002002), 0x1.2001001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffdffd), -0x1.20010018p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002004), 0x1.2001002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffdffb), -0x1.20010028p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002020), 0x1.200101p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffdfdf), -0x1.20010108p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002080), 0x1.200104p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffdf7f), -0x1.20010408p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002400), 0x1.20012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffdbff), -0x1.20012008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024002800), 0x1.20014p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbffd7ff), -0x1.20014008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024010000), 0x1.2008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfeffff), -0x1.20080008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024010008), 0x1.2008004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfefff7), -0x1.20080048p+29, 0x0p+0 },
+{ INT64_C(0x0000000024010020), 0x1.200801p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfeffdf), -0x1.20080108p+29, 0x0p+0 },
+{ INT64_C(0x0000000024010080), 0x1.200804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfeff7f), -0x1.20080408p+29, 0x0p+0 },
+{ INT64_C(0x0000000024010100), 0x1.200808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfefeff), -0x1.20080808p+29, 0x0p+0 },
+{ INT64_C(0x0000000024010800), 0x1.20084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfef7ff), -0x1.20084008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024011000), 0x1.20088p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfeefff), -0x1.20088008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040000), 0x1.202p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbffff), -0x1.20200008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040008), 0x1.2020004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbfff7), -0x1.20200048p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040010), 0x1.2020008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbffef), -0x1.20200088p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040040), 0x1.202002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbffbf), -0x1.20200208p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040080), 0x1.202004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbff7f), -0x1.20200408p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040100), 0x1.202008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbfeff), -0x1.20200808p+29, 0x0p+0 },
+{ INT64_C(0x0000000024040800), 0x1.20204p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbf7ff), -0x1.20204008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024041000), 0x1.20208p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbefff), -0x1.20208008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024042000), 0x1.2021p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbfbdfff), -0x1.20210008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024060000), 0x1.203p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbf9ffff), -0x1.20300008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024400000), 0x1.22p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbfffff), -0x1.22000008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024400001), 0x1.22000008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbffffe), -0x1.2200001p+29, 0x0p+0 },
+{ INT64_C(0x0000000024400010), 0x1.2200008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbfffef), -0x1.22000088p+29, 0x0p+0 },
+{ INT64_C(0x0000000024400100), 0x1.220008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbffeff), -0x1.22000808p+29, 0x0p+0 },
+{ INT64_C(0x0000000024400200), 0x1.22001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbffdff), -0x1.22001008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024400800), 0x1.22004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbff7ff), -0x1.22004008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024408000), 0x1.2204p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbf7fff), -0x1.22040008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024420000), 0x1.221p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbbdffff), -0x1.22100008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024500000), 0x1.228p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdbafffff), -0x1.22800008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024800000), 0x1.24p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7fffff), -0x1.24000008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024800002), 0x1.2400001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7ffffd), -0x1.24000018p+29, 0x0p+0 },
+{ INT64_C(0x0000000024800004), 0x1.2400002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7ffffb), -0x1.24000028p+29, 0x0p+0 },
+{ INT64_C(0x0000000024800010), 0x1.2400008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7fffef), -0x1.24000088p+29, 0x0p+0 },
+{ INT64_C(0x0000000024800040), 0x1.240002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7fffbf), -0x1.24000208p+29, 0x0p+0 },
+{ INT64_C(0x0000000024800100), 0x1.240008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7ffeff), -0x1.24000808p+29, 0x0p+0 },
+{ INT64_C(0x0000000024801000), 0x1.24008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7fefff), -0x1.24008008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024810000), 0x1.2408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb7effff), -0x1.24080008p+29, 0x0p+0 },
+{ INT64_C(0x0000000024900000), 0x1.248p+29, 0x0p+0 },
+{ INT64_C(0xffffffffdb6fffff), -0x1.24800008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000004), 0x1.4000002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffffb), -0x1.40000028p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000006), 0x1.4000003p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffff9), -0x1.40000038p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000020), 0x1.400001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffffdf), -0x1.40000108p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000021), 0x1.40000108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffffde), -0x1.4000011p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000024), 0x1.4000012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffffdb), -0x1.40000128p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000040), 0x1.400002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffffbf), -0x1.40000208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000041), 0x1.40000208p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffffbe), -0x1.4000021p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000048), 0x1.4000024p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffffb7), -0x1.40000248p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000060), 0x1.400003p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffff9f), -0x1.40000308p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000080), 0x1.400004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffff7f), -0x1.40000408p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000081), 0x1.40000408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffff7e), -0x1.4000041p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000090), 0x1.4000048p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffff6f), -0x1.40000488p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000100), 0x1.400008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffeff), -0x1.40000808p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000108), 0x1.4000084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffef7), -0x1.40000848p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000140), 0x1.40000ap+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffebf), -0x1.40000a08p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000200), 0x1.40001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffdff), -0x1.40001008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000208), 0x1.4000104p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffdf7), -0x1.40001048p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000210), 0x1.4000108p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffdef), -0x1.40001088p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000220), 0x1.400011p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffddf), -0x1.40001108p+29, 0x0p+0 },
+{ INT64_C(0x0000000028000240), 0x1.400012p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fffdbf), -0x1.40001208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001000), 0x1.40008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffefff), -0x1.40008008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001001), 0x1.40008008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffeffe), -0x1.4000801p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001004), 0x1.4000802p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffeffb), -0x1.40008028p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001008), 0x1.4000804p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffeff7), -0x1.40008048p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001010), 0x1.4000808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffefef), -0x1.40008088p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001100), 0x1.400088p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffeeff), -0x1.40008808p+29, 0x0p+0 },
+{ INT64_C(0x0000000028001200), 0x1.40009p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7ffedff), -0x1.40009008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010000), 0x1.4008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7feffff), -0x1.40080008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010001), 0x1.40080008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fefffe), -0x1.4008001p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010004), 0x1.4008002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fefffb), -0x1.40080028p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010010), 0x1.4008008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7feffef), -0x1.40080088p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010040), 0x1.400802p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7feffbf), -0x1.40080208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010200), 0x1.40081p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fefdff), -0x1.40081008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028010800), 0x1.40084p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fef7ff), -0x1.40084008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028012000), 0x1.4009p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fedfff), -0x1.40090008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028040000), 0x1.402p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbffff), -0x1.40200008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028040008), 0x1.4020004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbfff7), -0x1.40200048p+29, 0x0p+0 },
+{ INT64_C(0x0000000028040040), 0x1.402002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbffbf), -0x1.40200208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028040080), 0x1.402004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbff7f), -0x1.40200408p+29, 0x0p+0 },
+{ INT64_C(0x0000000028040100), 0x1.402008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbfeff), -0x1.40200808p+29, 0x0p+0 },
+{ INT64_C(0x0000000028040800), 0x1.40204p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbf7ff), -0x1.40204008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028044000), 0x1.4022p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7fbbfff), -0x1.40220008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028060000), 0x1.403p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7f9ffff), -0x1.40300008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028100000), 0x1.408p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7efffff), -0x1.40800008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028100004), 0x1.4080002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7effffb), -0x1.40800028p+29, 0x0p+0 },
+{ INT64_C(0x0000000028100010), 0x1.4080008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7efffef), -0x1.40800088p+29, 0x0p+0 },
+{ INT64_C(0x0000000028100040), 0x1.408002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7efffbf), -0x1.40800208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028100080), 0x1.408004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7efff7f), -0x1.40800408p+29, 0x0p+0 },
+{ INT64_C(0x0000000028100100), 0x1.408008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7effeff), -0x1.40800808p+29, 0x0p+0 },
+{ INT64_C(0x0000000028101000), 0x1.40808p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7efefff), -0x1.40808008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028110000), 0x1.4088p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7eeffff), -0x1.40880008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028180000), 0x1.40cp+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7e7ffff), -0x1.40c00008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028400000), 0x1.42p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bfffff), -0x1.42000008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028400001), 0x1.42000008p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bffffe), -0x1.4200001p+29, 0x0p+0 },
+{ INT64_C(0x0000000028400002), 0x1.4200001p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bffffd), -0x1.42000018p+29, 0x0p+0 },
+{ INT64_C(0x0000000028400008), 0x1.4200004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bffff7), -0x1.42000048p+29, 0x0p+0 },
+{ INT64_C(0x0000000028400040), 0x1.420002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bfffbf), -0x1.42000208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028400400), 0x1.42002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bffbff), -0x1.42002008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028404000), 0x1.4202p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bfbfff), -0x1.42020008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028410000), 0x1.4208p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7beffff), -0x1.42080008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028440000), 0x1.422p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7bbffff), -0x1.42200008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028480000), 0x1.424p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7b7ffff), -0x1.42400008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028500000), 0x1.428p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd7afffff), -0x1.42800008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028800000), 0x1.44p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd77fffff), -0x1.44000008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028800008), 0x1.4400004p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd77ffff7), -0x1.44000048p+29, 0x0p+0 },
+{ INT64_C(0x0000000028800040), 0x1.440002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd77fffbf), -0x1.44000208p+29, 0x0p+0 },
+{ INT64_C(0x0000000028800400), 0x1.44002p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd77ffbff), -0x1.44002008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028804000), 0x1.4402p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd77fbfff), -0x1.44020008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028808000), 0x1.4404p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd77f7fff), -0x1.44040008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028880000), 0x1.444p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd777ffff), -0x1.44400008p+29, 0x0p+0 },
+{ INT64_C(0x0000000028c00000), 0x1.46p+29, 0x0p+0 },
+{ INT64_C(0xffffffffd73fffff), -0x1.46000008p+29, 0x0p+0 },
+{ INT64_C(0x0000000080000006), 0x1.0000000cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffff9), -0x1.0000000ep+31, 0x0p+0 },
+{ INT64_C(0x0000000080000048), 0x1.0000009p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffffb7), -0x1.00000092p+31, 0x0p+0 },
+{ INT64_C(0x0000000080000049), 0x1.00000092p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffffb6), -0x1.00000094p+31, 0x0p+0 },
+{ INT64_C(0x000000008000004a), 0x1.00000094p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffffb5), -0x1.00000096p+31, 0x0p+0 },
+{ INT64_C(0x0000000080000088), 0x1.0000011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffff77), -0x1.00000112p+31, 0x0p+0 },
+{ INT64_C(0x000000008000008a), 0x1.00000114p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffff75), -0x1.00000116p+31, 0x0p+0 },
+{ INT64_C(0x000000008000008c), 0x1.00000118p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffff73), -0x1.0000011ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080000090), 0x1.0000012p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffff6f), -0x1.00000122p+31, 0x0p+0 },
+{ INT64_C(0x0000000080000092), 0x1.00000124p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffff6d), -0x1.00000126p+31, 0x0p+0 },
+{ INT64_C(0x0000000080000401), 0x1.00000802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffbfe), -0x1.00000804p+31, 0x0p+0 },
+{ INT64_C(0x0000000080000408), 0x1.0000081p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffbf7), -0x1.00000812p+31, 0x0p+0 },
+{ INT64_C(0x000000008000040a), 0x1.00000814p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffbf5), -0x1.00000816p+31, 0x0p+0 },
+{ INT64_C(0x000000008000040c), 0x1.00000818p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffbf3), -0x1.0000081ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080000480), 0x1.000009p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffb7f), -0x1.00000902p+31, 0x0p+0 },
+{ INT64_C(0x0000000080000488), 0x1.0000091p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffb77), -0x1.00000912p+31, 0x0p+0 },
+{ INT64_C(0x00000000800004a0), 0x1.0000094p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffb5f), -0x1.00000942p+31, 0x0p+0 },
+{ INT64_C(0x00000000800004c0), 0x1.0000098p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ffffb3f), -0x1.00000982p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001008), 0x1.0000201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffeff7), -0x1.00002012p+31, 0x0p+0 },
+{ INT64_C(0x000000008000100c), 0x1.00002018p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffeff3), -0x1.0000201ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080001020), 0x1.0000204p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffefdf), -0x1.00002042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001024), 0x1.00002048p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffefdb), -0x1.0000204ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080001028), 0x1.0000205p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffefd7), -0x1.00002052p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001200), 0x1.000024p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffedff), -0x1.00002402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001208), 0x1.0000241p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffedf7), -0x1.00002412p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001220), 0x1.0000244p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffeddf), -0x1.00002442p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001240), 0x1.0000248p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffedbf), -0x1.00002482p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001280), 0x1.000025p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffed7f), -0x1.00002502p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001300), 0x1.000026p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffecff), -0x1.00002602p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001400), 0x1.000028p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffebff), -0x1.00002802p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001402), 0x1.00002804p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffebfd), -0x1.00002806p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001404), 0x1.00002808p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffebfb), -0x1.0000280ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080001420), 0x1.0000284p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffebdf), -0x1.00002842p+31, 0x0p+0 },
+{ INT64_C(0x0000000080001600), 0x1.00002cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffe9ff), -0x1.00002c02p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002001), 0x1.00004002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdffe), -0x1.00004004p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002010), 0x1.0000402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdfef), -0x1.00004022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002014), 0x1.00004028p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdfeb), -0x1.0000402ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080002080), 0x1.000041p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdf7f), -0x1.00004102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002082), 0x1.00004104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdf7d), -0x1.00004106p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002090), 0x1.0000412p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdf6f), -0x1.00004122p+31, 0x0p+0 },
+{ INT64_C(0x00000000800020a0), 0x1.0000414p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffdf5f), -0x1.00004142p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002800), 0x1.00005p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffd7ff), -0x1.00005002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002804), 0x1.00005008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffd7fb), -0x1.0000500ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080002808), 0x1.0000501p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffd7f7), -0x1.00005012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002810), 0x1.0000502p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffd7ef), -0x1.00005022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080002900), 0x1.000052p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fffd6ff), -0x1.00005202p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008001), 0x1.00010002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7ffe), -0x1.00010004p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008008), 0x1.0001001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7ff7), -0x1.00010012p+31, 0x0p+0 },
+{ INT64_C(0x000000008000800a), 0x1.00010014p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7ff5), -0x1.00010016p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008080), 0x1.000101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7f7f), -0x1.00010102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008088), 0x1.0001011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7f77), -0x1.00010112p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008090), 0x1.0001012p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7f6f), -0x1.00010122p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008100), 0x1.000102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7eff), -0x1.00010202p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008108), 0x1.0001021p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7ef7), -0x1.00010212p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008180), 0x1.000103p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7e7f), -0x1.00010302p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008200), 0x1.000104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7dff), -0x1.00010402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008201), 0x1.00010402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7dfe), -0x1.00010404p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008208), 0x1.0001041p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7df7), -0x1.00010412p+31, 0x0p+0 },
+{ INT64_C(0x0000000080008240), 0x1.0001048p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff7dbf), -0x1.00010482p+31, 0x0p+0 },
+{ INT64_C(0x0000000080009000), 0x1.00012p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff6fff), -0x1.00012002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080009002), 0x1.00012004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff6ffd), -0x1.00012006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080009008), 0x1.0001201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff6ff7), -0x1.00012012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080009080), 0x1.000121p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff6f7f), -0x1.00012102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080009800), 0x1.00013p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fff67ff), -0x1.00013002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080002), 0x1.00100004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7fffd), -0x1.00100006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080010), 0x1.0010002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffef), -0x1.00100022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080018), 0x1.0010003p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffe7), -0x1.00100032p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080020), 0x1.0010004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffdf), -0x1.00100042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080028), 0x1.0010005p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffd7), -0x1.00100052p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080030), 0x1.0010006p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffcf), -0x1.00100062p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080040), 0x1.0010008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffbf), -0x1.00100082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080042), 0x1.00100084p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffbd), -0x1.00100086p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080050), 0x1.001000ap+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ffaf), -0x1.001000a2p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080080), 0x1.001001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ff7f), -0x1.00100102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080088), 0x1.0010011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ff77), -0x1.00100112p+31, 0x0p+0 },
+{ INT64_C(0x00000000800800c0), 0x1.0010018p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ff3f), -0x1.00100182p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080800), 0x1.00101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7f7ff), -0x1.00101002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080802), 0x1.00101004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7f7fd), -0x1.00101006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080810), 0x1.0010102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7f7ef), -0x1.00101022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080880), 0x1.001011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7f77f), -0x1.00101102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080080a00), 0x1.001014p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7f5ff), -0x1.00101402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080081000), 0x1.00102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7efff), -0x1.00102002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080081002), 0x1.00102004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7effd), -0x1.00102006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080081008), 0x1.0010201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7eff7), -0x1.00102012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080081080), 0x1.001021p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ef7f), -0x1.00102102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080081400), 0x1.001028p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ebff), -0x1.00102802p+31, 0x0p+0 },
+{ INT64_C(0x0000000080081800), 0x1.00103p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7e7ff), -0x1.00103002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080082000), 0x1.00104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7dfff), -0x1.00104002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080082008), 0x1.0010401p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7dff7), -0x1.00104012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080082040), 0x1.0010408p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7dfbf), -0x1.00104082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080082100), 0x1.001042p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7deff), -0x1.00104202p+31, 0x0p+0 },
+{ INT64_C(0x0000000080082200), 0x1.001044p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7ddff), -0x1.00104402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080082800), 0x1.00105p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7d7ff), -0x1.00105002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080084000), 0x1.00108p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7bfff), -0x1.00108002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080084001), 0x1.00108002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7bffe), -0x1.00108004p+31, 0x0p+0 },
+{ INT64_C(0x0000000080084002), 0x1.00108004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7bffd), -0x1.00108006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080084010), 0x1.0010802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7bfef), -0x1.00108022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080084020), 0x1.0010804p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7bfdf), -0x1.00108042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080084200), 0x1.001084p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff7bdff), -0x1.00108402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080086000), 0x1.0010cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff79fff), -0x1.0010c002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080088000), 0x1.0011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff77fff), -0x1.00110002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080088008), 0x1.0011001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff77ff7), -0x1.00110012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080088020), 0x1.0011004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff77fdf), -0x1.00110042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080088040), 0x1.0011008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff77fbf), -0x1.00110082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080088200), 0x1.001104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff77dff), -0x1.00110402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080088800), 0x1.00111p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff777ff), -0x1.00111002p+31, 0x0p+0 },
+{ INT64_C(0x000000008008c000), 0x1.00118p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff73fff), -0x1.00118002p+31, 0x0p+0 },
+{ INT64_C(0x00000000800a0000), 0x1.0014p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff5ffff), -0x1.00140002p+31, 0x0p+0 },
+{ INT64_C(0x00000000800a0004), 0x1.00140008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff5fffb), -0x1.0014000ap+31, 0x0p+0 },
+{ INT64_C(0x00000000800a0040), 0x1.0014008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff5ffbf), -0x1.00140082p+31, 0x0p+0 },
+{ INT64_C(0x00000000800a0100), 0x1.001402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff5feff), -0x1.00140202p+31, 0x0p+0 },
+{ INT64_C(0x00000000800a1000), 0x1.00142p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff5efff), -0x1.00142002p+31, 0x0p+0 },
+{ INT64_C(0x00000000800b0000), 0x1.0016p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7ff4ffff), -0x1.00160002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400004), 0x1.00800008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbffffb), -0x1.0080000ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080400040), 0x1.0080008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfffbf), -0x1.00800082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400044), 0x1.00800088p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfffbb), -0x1.0080008ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080400100), 0x1.008002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbffeff), -0x1.00800202p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400104), 0x1.00800208p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbffefb), -0x1.0080020ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080400108), 0x1.0080021p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbffef7), -0x1.00800212p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400180), 0x1.008003p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbffe7f), -0x1.00800302p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400800), 0x1.00801p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbff7ff), -0x1.00801002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400808), 0x1.0080101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbff7f7), -0x1.00801012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400810), 0x1.0080102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbff7ef), -0x1.00801022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400820), 0x1.0080104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbff7df), -0x1.00801042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400840), 0x1.0080108p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbff7bf), -0x1.00801082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080400880), 0x1.008011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbff77f), -0x1.00801102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080401000), 0x1.00802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfefff), -0x1.00802002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080401008), 0x1.0080201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfeff7), -0x1.00802012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080401020), 0x1.0080204p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfefdf), -0x1.00802042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080401040), 0x1.0080208p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfefbf), -0x1.00802082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080401200), 0x1.008024p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfedff), -0x1.00802402p+31, 0x0p+0 },
+{ INT64_C(0x0000000080401400), 0x1.008028p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfebff), -0x1.00802802p+31, 0x0p+0 },
+{ INT64_C(0x0000000080404000), 0x1.00808p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfbfff), -0x1.00808002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080404002), 0x1.00808004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfbffd), -0x1.00808006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080404010), 0x1.0080802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfbfef), -0x1.00808022p+31, 0x0p+0 },
+{ INT64_C(0x0000000080404100), 0x1.008082p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfbeff), -0x1.00808202p+31, 0x0p+0 },
+{ INT64_C(0x0000000080404800), 0x1.00809p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbfb7ff), -0x1.00809002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080406000), 0x1.0080cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf9fff), -0x1.0080c002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080408000), 0x1.0081p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf7fff), -0x1.00810002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080408004), 0x1.00810008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf7ffb), -0x1.0081000ap+31, 0x0p+0 },
+{ INT64_C(0x0000000080408020), 0x1.0081004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf7fdf), -0x1.00810042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080408080), 0x1.008101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf7f7f), -0x1.00810102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080408200), 0x1.008104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf7dff), -0x1.00810402p+31, 0x0p+0 },
+{ INT64_C(0x000000008040a000), 0x1.00814p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf5fff), -0x1.00814002p+31, 0x0p+0 },
+{ INT64_C(0x000000008040c000), 0x1.00818p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbf3fff), -0x1.00818002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440000), 0x1.0088p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbffff), -0x1.00880002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440002), 0x1.00880004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbfffd), -0x1.00880006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440020), 0x1.0088004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbffdf), -0x1.00880042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440080), 0x1.008801p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbff7f), -0x1.00880102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440100), 0x1.008802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbfeff), -0x1.00880202p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440400), 0x1.008808p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbfbff), -0x1.00880802p+31, 0x0p+0 },
+{ INT64_C(0x0000000080440800), 0x1.00881p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbbf7ff), -0x1.00881002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080448000), 0x1.0089p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fbb7fff), -0x1.00890002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080480000), 0x1.009p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb7ffff), -0x1.00900002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080480002), 0x1.00900004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb7fffd), -0x1.00900006p+31, 0x0p+0 },
+{ INT64_C(0x0000000080480020), 0x1.0090004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb7ffdf), -0x1.00900042p+31, 0x0p+0 },
+{ INT64_C(0x0000000080480040), 0x1.0090008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb7ffbf), -0x1.00900082p+31, 0x0p+0 },
+{ INT64_C(0x0000000080480400), 0x1.009008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb7fbff), -0x1.00900802p+31, 0x0p+0 },
+{ INT64_C(0x0000000080484000), 0x1.00908p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb7bfff), -0x1.00908002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080490000), 0x1.0092p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb6ffff), -0x1.00920002p+31, 0x0p+0 },
+{ INT64_C(0x00000000804a0000), 0x1.0094p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fb5ffff), -0x1.00940002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080500000), 0x1.00ap+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fafffff), -0x1.00a00002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080500008), 0x1.00a0001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7faffff7), -0x1.00a00012p+31, 0x0p+0 },
+{ INT64_C(0x0000000080500080), 0x1.00a001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fafff7f), -0x1.00a00102p+31, 0x0p+0 },
+{ INT64_C(0x0000000080500400), 0x1.00a008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7faffbff), -0x1.00a00802p+31, 0x0p+0 },
+{ INT64_C(0x0000000080502000), 0x1.00a04p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fafdfff), -0x1.00a04002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080520000), 0x1.00a4p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fadffff), -0x1.00a40002p+31, 0x0p+0 },
+{ INT64_C(0x0000000080580000), 0x1.00bp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7fa7ffff), -0x1.00b00002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000004), 0x1.08000008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffffb), -0x1.0800000ap+31, 0x0p+0 },
+{ INT64_C(0x0000000084000006), 0x1.0800000cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffff9), -0x1.0800000ep+31, 0x0p+0 },
+{ INT64_C(0x0000000084000040), 0x1.0800008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffffbf), -0x1.08000082p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000044), 0x1.08000088p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffffbb), -0x1.0800008ap+31, 0x0p+0 },
+{ INT64_C(0x0000000084000060), 0x1.080000cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffff9f), -0x1.080000c2p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000200), 0x1.080004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffdff), -0x1.08000402p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000201), 0x1.08000402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffdfe), -0x1.08000404p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000204), 0x1.08000408p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffdfb), -0x1.0800040ap+31, 0x0p+0 },
+{ INT64_C(0x0000000084000208), 0x1.0800041p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffdf7), -0x1.08000412p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000240), 0x1.0800048p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfffdbf), -0x1.08000482p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000800), 0x1.08001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfff7ff), -0x1.08001002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000801), 0x1.08001002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfff7fe), -0x1.08001004p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000810), 0x1.0800102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfff7ef), -0x1.08001022p+31, 0x0p+0 },
+{ INT64_C(0x0000000084000880), 0x1.080011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfff77f), -0x1.08001102p+31, 0x0p+0 },
+{ INT64_C(0x0000000084001000), 0x1.08002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffefff), -0x1.08002002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084001004), 0x1.08002008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffeffb), -0x1.0800200ap+31, 0x0p+0 },
+{ INT64_C(0x0000000084001008), 0x1.0800201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffeff7), -0x1.08002012p+31, 0x0p+0 },
+{ INT64_C(0x0000000084001010), 0x1.0800202p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffefef), -0x1.08002022p+31, 0x0p+0 },
+{ INT64_C(0x0000000084001100), 0x1.080022p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffeeff), -0x1.08002202p+31, 0x0p+0 },
+{ INT64_C(0x0000000084001800), 0x1.08003p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bffe7ff), -0x1.08003002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008000), 0x1.0801p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff7fff), -0x1.08010002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008001), 0x1.08010002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff7ffe), -0x1.08010004p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008002), 0x1.08010004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff7ffd), -0x1.08010006p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008008), 0x1.0801001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff7ff7), -0x1.08010012p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008020), 0x1.0801004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff7fdf), -0x1.08010042p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008080), 0x1.080101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff7f7f), -0x1.08010102p+31, 0x0p+0 },
+{ INT64_C(0x0000000084008800), 0x1.08011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff77ff), -0x1.08011002p+31, 0x0p+0 },
+{ INT64_C(0x000000008400a000), 0x1.08014p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bff5fff), -0x1.08014002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084010000), 0x1.0802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfeffff), -0x1.08020002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084010002), 0x1.08020004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfefffd), -0x1.08020006p+31, 0x0p+0 },
+{ INT64_C(0x0000000084010020), 0x1.0802004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfeffdf), -0x1.08020042p+31, 0x0p+0 },
+{ INT64_C(0x0000000084010200), 0x1.080204p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfefdff), -0x1.08020402p+31, 0x0p+0 },
+{ INT64_C(0x0000000084012000), 0x1.08024p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bfedfff), -0x1.08024002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084100000), 0x1.082p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7befffff), -0x1.08200002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084100001), 0x1.08200002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7beffffe), -0x1.08200004p+31, 0x0p+0 },
+{ INT64_C(0x0000000084100010), 0x1.0820002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7befffef), -0x1.08200022p+31, 0x0p+0 },
+{ INT64_C(0x0000000084100040), 0x1.0820008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7befffbf), -0x1.08200082p+31, 0x0p+0 },
+{ INT64_C(0x0000000084100200), 0x1.082004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7beffdff), -0x1.08200402p+31, 0x0p+0 },
+{ INT64_C(0x0000000084101000), 0x1.08202p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7befefff), -0x1.08202002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084102000), 0x1.08204p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7befdfff), -0x1.08204002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084108000), 0x1.0821p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bef7fff), -0x1.08210002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084120000), 0x1.0824p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bedffff), -0x1.08240002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400000), 0x1.088p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbfffff), -0x1.08800002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400001), 0x1.08800002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbffffe), -0x1.08800004p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400008), 0x1.0880001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbffff7), -0x1.08800012p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400020), 0x1.0880004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbfffdf), -0x1.08800042p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400100), 0x1.088002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbffeff), -0x1.08800202p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400400), 0x1.088008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbffbff), -0x1.08800802p+31, 0x0p+0 },
+{ INT64_C(0x0000000084400800), 0x1.08801p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbff7ff), -0x1.08801002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084401000), 0x1.08802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbfefff), -0x1.08802002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084408000), 0x1.0881p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbf7fff), -0x1.08810002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084420000), 0x1.0884p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bbdffff), -0x1.08840002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084480000), 0x1.089p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7bb7ffff), -0x1.08900002p+31, 0x0p+0 },
+{ INT64_C(0x0000000084600000), 0x1.08cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff7b9fffff), -0x1.08c00002p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000000), 0x1.0ap+31, 0x0p+0 },
+{ INT64_C(0xffffffff7affffff), -0x1.0a000002p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000001), 0x1.0a000002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7afffffe), -0x1.0a000004p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000002), 0x1.0a000004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7afffffd), -0x1.0a000006p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000020), 0x1.0a00004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7affffdf), -0x1.0a000042p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000080), 0x1.0a0001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7affff7f), -0x1.0a000102p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000400), 0x1.0a0008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7afffbff), -0x1.0a000802p+31, 0x0p+0 },
+{ INT64_C(0x0000000085000800), 0x1.0a001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7afff7ff), -0x1.0a001002p+31, 0x0p+0 },
+{ INT64_C(0x0000000085008000), 0x1.0a01p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7aff7fff), -0x1.0a010002p+31, 0x0p+0 },
+{ INT64_C(0x0000000085080000), 0x1.0a1p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7af7ffff), -0x1.0a100002p+31, 0x0p+0 },
+{ INT64_C(0x0000000085100000), 0x1.0a2p+31, 0x0p+0 },
+{ INT64_C(0xffffffff7aefffff), -0x1.0a200002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000002), 0x1.20000004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffffd), -0x1.20000006p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000020), 0x1.2000004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffffdf), -0x1.20000042p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000024), 0x1.20000048p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffffdb), -0x1.2000004ap+31, 0x0p+0 },
+{ INT64_C(0x0000000090000028), 0x1.2000005p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffffd7), -0x1.20000052p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000200), 0x1.200004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffdff), -0x1.20000402p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000204), 0x1.20000408p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffdfb), -0x1.2000040ap+31, 0x0p+0 },
+{ INT64_C(0x0000000090000208), 0x1.2000041p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffdf7), -0x1.20000412p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000210), 0x1.2000042p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffdef), -0x1.20000422p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000240), 0x1.2000048p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffdbf), -0x1.20000482p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000400), 0x1.200008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffbff), -0x1.20000802p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000401), 0x1.20000802p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffbfe), -0x1.20000804p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000410), 0x1.2000082p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffbef), -0x1.20000822p+31, 0x0p+0 },
+{ INT64_C(0x0000000090000500), 0x1.20000ap+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ffffaff), -0x1.20000a02p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002000), 0x1.20004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdfff), -0x1.20004002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002001), 0x1.20004002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdffe), -0x1.20004004p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002010), 0x1.2000402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdfef), -0x1.20004022p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002020), 0x1.2000404p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdfdf), -0x1.20004042p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002080), 0x1.200041p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdf7f), -0x1.20004102p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002100), 0x1.200042p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdeff), -0x1.20004202p+31, 0x0p+0 },
+{ INT64_C(0x0000000090002400), 0x1.200048p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fffdbff), -0x1.20004802p+31, 0x0p+0 },
+{ INT64_C(0x0000000090008000), 0x1.2001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fff7fff), -0x1.20010002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090008008), 0x1.2001001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fff7ff7), -0x1.20010012p+31, 0x0p+0 },
+{ INT64_C(0x0000000090008010), 0x1.2001002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fff7fef), -0x1.20010022p+31, 0x0p+0 },
+{ INT64_C(0x0000000090008080), 0x1.200101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fff7f7f), -0x1.20010102p+31, 0x0p+0 },
+{ INT64_C(0x0000000090008400), 0x1.200108p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fff7bff), -0x1.20010802p+31, 0x0p+0 },
+{ INT64_C(0x0000000090008800), 0x1.20011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fff77ff), -0x1.20011002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090080000), 0x1.201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff7ffff), -0x1.20100002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090080004), 0x1.20100008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff7fffb), -0x1.2010000ap+31, 0x0p+0 },
+{ INT64_C(0x0000000090080040), 0x1.2010008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff7ffbf), -0x1.20100082p+31, 0x0p+0 },
+{ INT64_C(0x0000000090080200), 0x1.201004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff7fdff), -0x1.20100402p+31, 0x0p+0 },
+{ INT64_C(0x0000000090082000), 0x1.20104p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff7dfff), -0x1.20104002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090084000), 0x1.20108p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff7bfff), -0x1.20108002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090090000), 0x1.2012p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff6ffff), -0x1.20120002p+31, 0x0p+0 },
+{ INT64_C(0x00000000900a0000), 0x1.2014p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ff5ffff), -0x1.20140002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090200000), 0x1.204p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fdfffff), -0x1.20400002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090200008), 0x1.2040001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fdffff7), -0x1.20400012p+31, 0x0p+0 },
+{ INT64_C(0x0000000090200020), 0x1.2040004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fdfffdf), -0x1.20400042p+31, 0x0p+0 },
+{ INT64_C(0x0000000090200100), 0x1.204002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fdffeff), -0x1.20400202p+31, 0x0p+0 },
+{ INT64_C(0x0000000090201000), 0x1.20402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fdfefff), -0x1.20402002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090208000), 0x1.2041p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fdf7fff), -0x1.20410002p+31, 0x0p+0 },
+{ INT64_C(0x0000000090280000), 0x1.205p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6fd7ffff), -0x1.20500002p+31, 0x0p+0 },
+{ INT64_C(0x0000000091000000), 0x1.22p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6effffff), -0x1.22000002p+31, 0x0p+0 },
+{ INT64_C(0x0000000091000004), 0x1.22000008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6efffffb), -0x1.2200000ap+31, 0x0p+0 },
+{ INT64_C(0x0000000091000010), 0x1.2200002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6effffef), -0x1.22000022p+31, 0x0p+0 },
+{ INT64_C(0x0000000091000080), 0x1.220001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6effff7f), -0x1.22000102p+31, 0x0p+0 },
+{ INT64_C(0x0000000091000400), 0x1.220008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6efffbff), -0x1.22000802p+31, 0x0p+0 },
+{ INT64_C(0x0000000091000800), 0x1.22001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6efff7ff), -0x1.22001002p+31, 0x0p+0 },
+{ INT64_C(0x0000000091008000), 0x1.2201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6eff7fff), -0x1.22010002p+31, 0x0p+0 },
+{ INT64_C(0x0000000091080000), 0x1.221p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6ef7ffff), -0x1.22100002p+31, 0x0p+0 },
+{ INT64_C(0x0000000091200000), 0x1.224p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6edfffff), -0x1.22400002p+31, 0x0p+0 },
+{ INT64_C(0x0000000091800000), 0x1.23p+31, 0x0p+0 },
+{ INT64_C(0xffffffff6e7fffff), -0x1.23000002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000004), 0x1.80000008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffffffb), -0x1.8000000ap+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000006), 0x1.8000000cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffffff9), -0x1.8000000ep+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000040), 0x1.8000008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fffffbf), -0x1.80000082p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000041), 0x1.80000082p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fffffbe), -0x1.80000084p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000042), 0x1.80000084p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fffffbd), -0x1.80000086p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000048), 0x1.8000009p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fffffb7), -0x1.80000092p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000400), 0x1.800008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffffbff), -0x1.80000802p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000408), 0x1.8000081p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffffbf7), -0x1.80000812p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000420), 0x1.8000084p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffffbdf), -0x1.80000842p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000480), 0x1.800009p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffffb7f), -0x1.80000902p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000800), 0x1.80001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffff7ff), -0x1.80001002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000801), 0x1.80001002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffff7fe), -0x1.80001004p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000808), 0x1.8000101p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffff7f7), -0x1.80001012p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000840), 0x1.8000108p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffff7bf), -0x1.80001082p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0000c00), 0x1.800018p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffff3ff), -0x1.80001802p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0008000), 0x1.8001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff7fff), -0x1.80010002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0008001), 0x1.80010002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff7ffe), -0x1.80010004p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0008008), 0x1.8001001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff7ff7), -0x1.80010012p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0008040), 0x1.8001008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff7fbf), -0x1.80010082p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0008100), 0x1.800102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff7eff), -0x1.80010202p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0008800), 0x1.80011p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff77ff), -0x1.80011002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c000a000), 0x1.80014p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fff5fff), -0x1.80014002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0040000), 0x1.8008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffbffff), -0x1.80080002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0040004), 0x1.80080008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffbfffb), -0x1.8008000ap+31, 0x0p+0 },
+{ INT64_C(0x00000000c0040040), 0x1.8008008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffbffbf), -0x1.80080082p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0040200), 0x1.800804p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffbfdff), -0x1.80080402p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0042000), 0x1.80084p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ffbdfff), -0x1.80084002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0060000), 0x1.800cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ff9ffff), -0x1.800c0002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0200000), 0x1.804p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdfffff), -0x1.80400002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0200008), 0x1.8040001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdffff7), -0x1.80400012p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0200020), 0x1.8040004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdfffdf), -0x1.80400042p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0200200), 0x1.804004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdffdff), -0x1.80400402p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0200400), 0x1.804008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdffbff), -0x1.80400802p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0201000), 0x1.80402p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdfefff), -0x1.80402002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0210000), 0x1.8042p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fdeffff), -0x1.80420002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0280000), 0x1.805p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fd7ffff), -0x1.80500002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0400000), 0x1.808p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fbfffff), -0x1.80800002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0400004), 0x1.80800008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fbffffb), -0x1.8080000ap+31, 0x0p+0 },
+{ INT64_C(0x00000000c0400040), 0x1.8080008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fbfffbf), -0x1.80800082p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0400400), 0x1.808008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fbffbff), -0x1.80800802p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0404000), 0x1.80808p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fbfbfff), -0x1.80808002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0420000), 0x1.8084p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fbdffff), -0x1.80840002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0480000), 0x1.809p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3fb7ffff), -0x1.80900002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0600000), 0x1.80cp+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f9fffff), -0x1.80c00002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0800000), 0x1.81p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7fffff), -0x1.81000002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0800001), 0x1.81000002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7ffffe), -0x1.81000004p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0800010), 0x1.8100002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7fffef), -0x1.81000022p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0800100), 0x1.810002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7ffeff), -0x1.81000202p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0800800), 0x1.81001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7ff7ff), -0x1.81001002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0802000), 0x1.81004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7fdfff), -0x1.81004002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0810000), 0x1.8102p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f7effff), -0x1.81020002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0880000), 0x1.811p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f77ffff), -0x1.81100002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0a00000), 0x1.814p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f5fffff), -0x1.81400002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c0c00000), 0x1.818p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3f3fffff), -0x1.81800002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1000000), 0x1.82p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3effffff), -0x1.82000002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1000004), 0x1.82000008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3efffffb), -0x1.8200000ap+31, 0x0p+0 },
+{ INT64_C(0x00000000c1000020), 0x1.8200004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3effffdf), -0x1.82000042p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1000100), 0x1.820002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3efffeff), -0x1.82000202p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1000800), 0x1.82001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3efff7ff), -0x1.82001002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1004000), 0x1.82008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3effbfff), -0x1.82008002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1008000), 0x1.8201p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3eff7fff), -0x1.82010002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1080000), 0x1.821p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3ef7ffff), -0x1.82100002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1200000), 0x1.824p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3edfffff), -0x1.82400002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c1800000), 0x1.83p+31, 0x0p+0 },
+{ INT64_C(0xffffffff3e7fffff), -0x1.83000002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8000000), 0x1.9p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37ffffff), -0x1.90000002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8000004), 0x1.90000008p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37fffffb), -0x1.9000000ap+31, 0x0p+0 },
+{ INT64_C(0x00000000c8000008), 0x1.9000001p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37fffff7), -0x1.90000012p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8000020), 0x1.9000004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37ffffdf), -0x1.90000042p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8000200), 0x1.900004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37fffdff), -0x1.90000402p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8002000), 0x1.90004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37ffdfff), -0x1.90004002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8010000), 0x1.9002p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37feffff), -0x1.90020002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8020000), 0x1.9004p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37fdffff), -0x1.90040002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8080000), 0x1.901p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37f7ffff), -0x1.90100002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8100000), 0x1.902p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37efffff), -0x1.90200002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c8400000), 0x1.908p+31, 0x0p+0 },
+{ INT64_C(0xffffffff37bfffff), -0x1.90800002p+31, 0x0p+0 },
+{ INT64_C(0x00000000c9000000), 0x1.92p+31, 0x0p+0 },
+{ INT64_C(0xffffffff36ffffff), -0x1.92000002p+31, 0x0p+0 },
+{ INT64_C(0x000000080000000a), 0x1.000000014p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffff5), -0x1.000000016p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000022), 0x1.000000044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffdd), -0x1.000000046p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000024), 0x1.000000048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffdb), -0x1.00000004ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800000025), 0x1.00000004ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffda), -0x1.00000004cp+35, 0x0p+0 },
+{ INT64_C(0x0000000800000026), 0x1.00000004cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffd9), -0x1.00000004ep+35, 0x0p+0 },
+{ INT64_C(0x0000000800000041), 0x1.000000082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffbe), -0x1.000000084p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000048), 0x1.00000009p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffb7), -0x1.000000092p+35, 0x0p+0 },
+{ INT64_C(0x000000080000004c), 0x1.000000098p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffffb3), -0x1.00000009ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800000102), 0x1.000000204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffefd), -0x1.000000206p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000120), 0x1.00000024p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffedf), -0x1.000000242p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000121), 0x1.000000242p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffede), -0x1.000000244p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000130), 0x1.00000026p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffecf), -0x1.000000262p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000140), 0x1.00000028p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffebf), -0x1.000000282p+35, 0x0p+0 },
+{ INT64_C(0x0000000800000144), 0x1.000000288p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffebb), -0x1.00000028ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800000160), 0x1.0000002cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffffe9f), -0x1.0000002c2p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001002), 0x1.000002004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffeffd), -0x1.000002006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001020), 0x1.00000204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffefdf), -0x1.000002042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001022), 0x1.000002044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffefdd), -0x1.000002046p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001024), 0x1.000002048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffefdb), -0x1.00000204ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800001028), 0x1.00000205p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffefd7), -0x1.000002052p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001030), 0x1.00000206p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffefcf), -0x1.000002062p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001200), 0x1.0000024p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffedff), -0x1.000002402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001208), 0x1.00000241p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffedf7), -0x1.000002412p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001220), 0x1.00000244p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffeddf), -0x1.000002442p+35, 0x0p+0 },
+{ INT64_C(0x0000000800001300), 0x1.0000026p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffecff), -0x1.000002602p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004001), 0x1.000008002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbffe), -0x1.000008004p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004008), 0x1.00000801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbff7), -0x1.000008012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004009), 0x1.000008012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbff6), -0x1.000008014p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004080), 0x1.0000081p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbf7f), -0x1.000008102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004081), 0x1.000008102p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbf7e), -0x1.000008104p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004088), 0x1.00000811p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbf77), -0x1.000008112p+35, 0x0p+0 },
+{ INT64_C(0x00000008000040c0), 0x1.00000818p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffbf3f), -0x1.000008182p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004800), 0x1.000009p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb7ff), -0x1.000009002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004801), 0x1.000009002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb7fe), -0x1.000009004p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004802), 0x1.000009004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb7fd), -0x1.000009006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004808), 0x1.00000901p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb7f7), -0x1.000009012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004820), 0x1.00000904p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb7df), -0x1.000009042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004880), 0x1.0000091p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb77f), -0x1.000009102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800004a00), 0x1.0000094p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffb5ff), -0x1.000009402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800005000), 0x1.00000ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffafff), -0x1.00000a002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800005001), 0x1.00000a002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffaffe), -0x1.00000a004p+35, 0x0p+0 },
+{ INT64_C(0x0000000800005002), 0x1.00000a004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffaffd), -0x1.00000a006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800005020), 0x1.00000a04p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffafdf), -0x1.00000a042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800005080), 0x1.00000a1p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffaf7f), -0x1.00000a102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800005400), 0x1.00000a8p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffffabff), -0x1.00000a802p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040002), 0x1.000080004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbfffd), -0x1.000080006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040010), 0x1.00008002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbffef), -0x1.000080022p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040018), 0x1.00008003p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbffe7), -0x1.000080032p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040040), 0x1.00008008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbffbf), -0x1.000080082p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040042), 0x1.000080084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbffbd), -0x1.000080086p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040060), 0x1.0000800cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbff9f), -0x1.0000800c2p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040200), 0x1.0000804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbfdff), -0x1.000080402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040204), 0x1.000080408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbfdfb), -0x1.00008040ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800040220), 0x1.00008044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbfddf), -0x1.000080442p+35, 0x0p+0 },
+{ INT64_C(0x0000000800040280), 0x1.0000805p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbfd7f), -0x1.000080502p+35, 0x0p+0 },
+{ INT64_C(0x0000000800041000), 0x1.000082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbefff), -0x1.000082002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800041002), 0x1.000082004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbeffd), -0x1.000082006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800041020), 0x1.00008204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbefdf), -0x1.000082042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800041200), 0x1.0000824p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffbedff), -0x1.000082402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800050000), 0x1.0000ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffaffff), -0x1.0000a0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800050008), 0x1.0000a001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffafff7), -0x1.0000a0012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800050020), 0x1.0000a004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffaffdf), -0x1.0000a0042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800050100), 0x1.0000a02p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffafeff), -0x1.0000a0202p+35, 0x0p+0 },
+{ INT64_C(0x0000000800050800), 0x1.0000a1p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffaf7ff), -0x1.0000a1002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800058000), 0x1.0000bp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fffa7fff), -0x1.0000b0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800060000), 0x1.0000cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff9ffff), -0x1.0000c0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800060008), 0x1.0000c001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff9fff7), -0x1.0000c0012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800060080), 0x1.0000c01p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff9ff7f), -0x1.0000c0102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800060400), 0x1.0000c08p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff9fbff), -0x1.0000c0802p+35, 0x0p+0 },
+{ INT64_C(0x0000000800061000), 0x1.0000c2p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff9efff), -0x1.0000c2002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800068000), 0x1.0000dp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff97fff), -0x1.0000d0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800070000), 0x1.0000ep+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fff8ffff), -0x1.0000e0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800100008), 0x1.00020001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeffff7), -0x1.000200012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800100009), 0x1.000200012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeffff6), -0x1.000200014p+35, 0x0p+0 },
+{ INT64_C(0x0000000800100040), 0x1.00020008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefffbf), -0x1.000200082p+35, 0x0p+0 },
+{ INT64_C(0x0000000800100044), 0x1.000200088p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefffbb), -0x1.00020008ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800100200), 0x1.0002004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeffdff), -0x1.000200402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800100204), 0x1.000200408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeffdfb), -0x1.00020040ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800100220), 0x1.00020044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeffddf), -0x1.000200442p+35, 0x0p+0 },
+{ INT64_C(0x0000000800100300), 0x1.0002006p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeffcff), -0x1.000200602p+35, 0x0p+0 },
+{ INT64_C(0x0000000800101000), 0x1.000202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefefff), -0x1.000202002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800101001), 0x1.000202002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefeffe), -0x1.000202004p+35, 0x0p+0 },
+{ INT64_C(0x0000000800101002), 0x1.000202004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefeffd), -0x1.000202006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800101020), 0x1.00020204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefefdf), -0x1.000202042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800101080), 0x1.0002021p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefef7f), -0x1.000202102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800101400), 0x1.0002028p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefebff), -0x1.000202802p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102000), 0x1.000204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdfff), -0x1.000204002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102001), 0x1.000204002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdffe), -0x1.000204004p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102002), 0x1.000204004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdffd), -0x1.000204006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102008), 0x1.00020401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdff7), -0x1.000204012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102010), 0x1.00020402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdfef), -0x1.000204022p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102020), 0x1.00020404p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdfdf), -0x1.000204042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102040), 0x1.00020408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdfbf), -0x1.000204082p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102100), 0x1.0002042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdeff), -0x1.000204202p+35, 0x0p+0 },
+{ INT64_C(0x0000000800102400), 0x1.0002048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffefdbff), -0x1.000204802p+35, 0x0p+0 },
+{ INT64_C(0x0000000800120000), 0x1.00024p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffedffff), -0x1.000240002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800120002), 0x1.000240004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffedfffd), -0x1.000240006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800120008), 0x1.00024001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffedfff7), -0x1.000240012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800120080), 0x1.0002401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffedff7f), -0x1.000240102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800120800), 0x1.000241p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffedf7ff), -0x1.000241002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800122000), 0x1.000244p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffeddfff), -0x1.000244002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800128000), 0x1.00025p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffed7fff), -0x1.000250002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800140000), 0x1.00028p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebffff), -0x1.000280002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800140004), 0x1.000280008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebfffb), -0x1.00028000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800140010), 0x1.00028002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebffef), -0x1.000280022p+35, 0x0p+0 },
+{ INT64_C(0x0000000800140020), 0x1.00028004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebffdf), -0x1.000280042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800140200), 0x1.0002804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebfdff), -0x1.000280402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800141000), 0x1.000282p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebefff), -0x1.000282002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800142000), 0x1.000284p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebdfff), -0x1.000284002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800144000), 0x1.000288p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffebbfff), -0x1.000288002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800160000), 0x1.0002cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffe9ffff), -0x1.0002c0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200002), 0x1.000400004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffffd), -0x1.000400006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200003), 0x1.000400006p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffffc), -0x1.000400008p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200004), 0x1.000400008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffffb), -0x1.00040000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800200008), 0x1.00040001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffff7), -0x1.000400012p+35, 0x0p+0 },
+{ INT64_C(0x000000080020000c), 0x1.000400018p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffff3), -0x1.00040001ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800200020), 0x1.00040004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfffdf), -0x1.000400042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200024), 0x1.000400048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfffdb), -0x1.00040004ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800200030), 0x1.00040006p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfffcf), -0x1.000400062p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200200), 0x1.0004004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffdff), -0x1.000400402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200204), 0x1.000400408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffdfb), -0x1.00040040ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800200210), 0x1.00040042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffdef), -0x1.000400422p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200280), 0x1.0004005p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdffd7f), -0x1.000400502p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200800), 0x1.000401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdff7ff), -0x1.000401002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200802), 0x1.000401004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdff7fd), -0x1.000401006p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200810), 0x1.00040102p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdff7ef), -0x1.000401022p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200820), 0x1.00040104p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdff7df), -0x1.000401042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800200900), 0x1.0004012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdff6ff), -0x1.000401202p+35, 0x0p+0 },
+{ INT64_C(0x0000000800204000), 0x1.000408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfbfff), -0x1.000408002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800204008), 0x1.00040801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfbff7), -0x1.000408012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800204020), 0x1.00040804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfbfdf), -0x1.000408042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800204080), 0x1.0004081p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfbf7f), -0x1.000408102p+35, 0x0p+0 },
+{ INT64_C(0x0000000800204200), 0x1.0004084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdfbdff), -0x1.000408402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800206000), 0x1.00040cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdf9fff), -0x1.00040c002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800208000), 0x1.00041p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdf7fff), -0x1.000410002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800208004), 0x1.000410008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdf7ffb), -0x1.00041000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800208040), 0x1.00041008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdf7fbf), -0x1.000410082p+35, 0x0p+0 },
+{ INT64_C(0x0000000800208100), 0x1.0004102p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdf7eff), -0x1.000410202p+35, 0x0p+0 },
+{ INT64_C(0x0000000800208800), 0x1.000411p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdf77ff), -0x1.000411002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800240000), 0x1.00048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdbffff), -0x1.000480002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800240004), 0x1.000480008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdbfffb), -0x1.00048000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000800240020), 0x1.00048004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdbffdf), -0x1.000480042p+35, 0x0p+0 },
+{ INT64_C(0x0000000800240100), 0x1.0004802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdbfeff), -0x1.000480202p+35, 0x0p+0 },
+{ INT64_C(0x0000000800241000), 0x1.000482p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdbefff), -0x1.000482002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800250000), 0x1.0004ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffdaffff), -0x1.0004a0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800300000), 0x1.0006p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcfffff), -0x1.000600002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800300008), 0x1.00060001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcffff7), -0x1.000600012p+35, 0x0p+0 },
+{ INT64_C(0x0000000800300040), 0x1.00060008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcfffbf), -0x1.000600082p+35, 0x0p+0 },
+{ INT64_C(0x0000000800300200), 0x1.0006004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcffdff), -0x1.000600402p+35, 0x0p+0 },
+{ INT64_C(0x0000000800300400), 0x1.0006008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcffbff), -0x1.000600802p+35, 0x0p+0 },
+{ INT64_C(0x0000000800304000), 0x1.000608p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcfbfff), -0x1.000608002p+35, 0x0p+0 },
+{ INT64_C(0x0000000800340000), 0x1.00068p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7ffcbffff), -0x1.000680002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000004), 0x1.002000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffffb), -0x1.00200000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801000008), 0x1.00200001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffff7), -0x1.002000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000009), 0x1.002000012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffff6), -0x1.002000014p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000040), 0x1.00200008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffffbf), -0x1.002000082p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000041), 0x1.002000082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffffbe), -0x1.002000084p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000044), 0x1.002000088p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffffbb), -0x1.00200008ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801000048), 0x1.00200009p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffffb7), -0x1.002000092p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000200), 0x1.0020004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffdff), -0x1.002000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000201), 0x1.002000402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffdfe), -0x1.002000404p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000202), 0x1.002000404p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffdfd), -0x1.002000406p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000220), 0x1.00200044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefffddf), -0x1.002000442p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000800), 0x1.002001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefff7ff), -0x1.002001002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000804), 0x1.002001008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefff7fb), -0x1.00200100ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801000820), 0x1.00200104p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefff7df), -0x1.002001042p+35, 0x0p+0 },
+{ INT64_C(0x0000000801000900), 0x1.0020012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefff6ff), -0x1.002001202p+35, 0x0p+0 },
+{ INT64_C(0x0000000801004000), 0x1.002008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffbfff), -0x1.002008002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801004008), 0x1.00200801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffbff7), -0x1.002008012p+35, 0x0p+0 },
+{ INT64_C(0x0000000801004010), 0x1.00200802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffbfef), -0x1.002008022p+35, 0x0p+0 },
+{ INT64_C(0x0000000801004100), 0x1.0020082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffbeff), -0x1.002008202p+35, 0x0p+0 },
+{ INT64_C(0x0000000801004200), 0x1.0020084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffbdff), -0x1.002008402p+35, 0x0p+0 },
+{ INT64_C(0x0000000801005000), 0x1.00200ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feffafff), -0x1.00200a002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801006000), 0x1.00200cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feff9fff), -0x1.00200c002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801020000), 0x1.00204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdffff), -0x1.002040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801020004), 0x1.002040008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdfffb), -0x1.00204000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801020020), 0x1.00204004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdffdf), -0x1.002040042p+35, 0x0p+0 },
+{ INT64_C(0x0000000801020080), 0x1.0020401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdff7f), -0x1.002040102p+35, 0x0p+0 },
+{ INT64_C(0x0000000801020200), 0x1.0020404p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdfdff), -0x1.002040402p+35, 0x0p+0 },
+{ INT64_C(0x0000000801020400), 0x1.0020408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdfbff), -0x1.002040802p+35, 0x0p+0 },
+{ INT64_C(0x0000000801020800), 0x1.002041p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefdf7ff), -0x1.002041002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801022000), 0x1.002044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefddfff), -0x1.002044002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801028000), 0x1.00205p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefd7fff), -0x1.002050002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801040000), 0x1.00208p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbffff), -0x1.002080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801040004), 0x1.002080008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbfffb), -0x1.00208000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801040008), 0x1.00208001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbfff7), -0x1.002080012p+35, 0x0p+0 },
+{ INT64_C(0x0000000801040010), 0x1.00208002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbffef), -0x1.002080022p+35, 0x0p+0 },
+{ INT64_C(0x0000000801040100), 0x1.0020802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbfeff), -0x1.002080202p+35, 0x0p+0 },
+{ INT64_C(0x0000000801040200), 0x1.0020804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbfdff), -0x1.002080402p+35, 0x0p+0 },
+{ INT64_C(0x0000000801040400), 0x1.0020808p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbfbff), -0x1.002080802p+35, 0x0p+0 },
+{ INT64_C(0x0000000801044000), 0x1.002088p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefbbfff), -0x1.002088002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801048000), 0x1.00209p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fefb7fff), -0x1.002090002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801060000), 0x1.0020cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fef9ffff), -0x1.0020c0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801100000), 0x1.0022p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feefffff), -0x1.002200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801100004), 0x1.002200008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feeffffb), -0x1.00220000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801100010), 0x1.00220002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feefffef), -0x1.002200022p+35, 0x0p+0 },
+{ INT64_C(0x0000000801100040), 0x1.00220008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feefffbf), -0x1.002200082p+35, 0x0p+0 },
+{ INT64_C(0x0000000801100400), 0x1.0022008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feeffbff), -0x1.002200802p+35, 0x0p+0 },
+{ INT64_C(0x0000000801101000), 0x1.002202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feefefff), -0x1.002202002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801110000), 0x1.00222p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7feeeffff), -0x1.002220002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801800000), 0x1.003p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7fffff), -0x1.003000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801800001), 0x1.003000002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7ffffe), -0x1.003000004p+35, 0x0p+0 },
+{ INT64_C(0x0000000801800004), 0x1.003000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7ffffb), -0x1.00300000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000801800010), 0x1.00300002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7fffef), -0x1.003000022p+35, 0x0p+0 },
+{ INT64_C(0x0000000801800100), 0x1.0030002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7ffeff), -0x1.003000202p+35, 0x0p+0 },
+{ INT64_C(0x0000000801801000), 0x1.003002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7fefff), -0x1.003002002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801804000), 0x1.003008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7fbfff), -0x1.003008002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801810000), 0x1.00302p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7effff), -0x1.003020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801840000), 0x1.00308p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe7bffff), -0x1.003080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000801900000), 0x1.0032p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fe6fffff), -0x1.003200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000008), 0x1.00800001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfffff7), -0x1.008000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000009), 0x1.008000012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfffff6), -0x1.008000014p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000010), 0x1.00800002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffffef), -0x1.008000022p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000018), 0x1.00800003p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffffe7), -0x1.008000032p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000080), 0x1.0080001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffff7f), -0x1.008000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000081), 0x1.008000102p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffff7e), -0x1.008000104p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000082), 0x1.008000104p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffff7d), -0x1.008000106p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000088), 0x1.00800011p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffff77), -0x1.008000112p+35, 0x0p+0 },
+{ INT64_C(0x00000008040000c0), 0x1.00800018p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffff3f), -0x1.008000182p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000200), 0x1.0080004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfffdff), -0x1.008000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000202), 0x1.008000404p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfffdfd), -0x1.008000406p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000210), 0x1.00800042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfffdef), -0x1.008000422p+35, 0x0p+0 },
+{ INT64_C(0x0000000804000300), 0x1.0080006p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfffcff), -0x1.008000602p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002000), 0x1.008004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffdfff), -0x1.008004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002002), 0x1.008004004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffdffd), -0x1.008004006p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002010), 0x1.00800402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffdfef), -0x1.008004022p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002100), 0x1.0080042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffdeff), -0x1.008004202p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002200), 0x1.0080044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffddff), -0x1.008004402p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002400), 0x1.0080048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffdbff), -0x1.008004802p+35, 0x0p+0 },
+{ INT64_C(0x0000000804002800), 0x1.008005p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbffd7ff), -0x1.008005002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804020000), 0x1.00804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdffff), -0x1.008040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804020002), 0x1.008040004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdfffd), -0x1.008040006p+35, 0x0p+0 },
+{ INT64_C(0x0000000804020020), 0x1.00804004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdffdf), -0x1.008040042p+35, 0x0p+0 },
+{ INT64_C(0x0000000804020200), 0x1.0080404p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdfdff), -0x1.008040402p+35, 0x0p+0 },
+{ INT64_C(0x0000000804020400), 0x1.0080408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdfbff), -0x1.008040802p+35, 0x0p+0 },
+{ INT64_C(0x0000000804020800), 0x1.008041p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdf7ff), -0x1.008041002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804024000), 0x1.008048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfdbfff), -0x1.008048002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804030000), 0x1.00806p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbfcffff), -0x1.008060002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804080000), 0x1.0081p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf7ffff), -0x1.008100002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804080004), 0x1.008100008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf7fffb), -0x1.00810000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000804080008), 0x1.00810001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf7fff7), -0x1.008100012p+35, 0x0p+0 },
+{ INT64_C(0x0000000804080080), 0x1.0081001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf7ff7f), -0x1.008100102p+35, 0x0p+0 },
+{ INT64_C(0x0000000804080800), 0x1.008101p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf7f7ff), -0x1.008101002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804082000), 0x1.008104p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf7dfff), -0x1.008104002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804090000), 0x1.00812p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf6ffff), -0x1.008120002p+35, 0x0p+0 },
+{ INT64_C(0x00000008040c0000), 0x1.00818p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbf3ffff), -0x1.008180002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804400000), 0x1.0088p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbfffff), -0x1.008800002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804400004), 0x1.008800008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbffffb), -0x1.00880000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000804400020), 0x1.00880004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbfffdf), -0x1.008800042p+35, 0x0p+0 },
+{ INT64_C(0x0000000804400040), 0x1.00880008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbfffbf), -0x1.008800082p+35, 0x0p+0 },
+{ INT64_C(0x0000000804400080), 0x1.0088001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbfff7f), -0x1.008800102p+35, 0x0p+0 },
+{ INT64_C(0x0000000804400200), 0x1.0088004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbffdff), -0x1.008800402p+35, 0x0p+0 },
+{ INT64_C(0x0000000804401000), 0x1.008802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbfefff), -0x1.008802002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804408000), 0x1.00881p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbf7fff), -0x1.008810002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804420000), 0x1.00884p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fbbdffff), -0x1.008840002p+35, 0x0p+0 },
+{ INT64_C(0x0000000804600000), 0x1.008cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7fb9fffff), -0x1.008c00002p+35, 0x0p+0 },
+{ INT64_C(0x0000000806000000), 0x1.00cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9ffffff), -0x1.00c000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000806000002), 0x1.00c000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9fffffd), -0x1.00c000006p+35, 0x0p+0 },
+{ INT64_C(0x0000000806000020), 0x1.00c00004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9ffffdf), -0x1.00c000042p+35, 0x0p+0 },
+{ INT64_C(0x0000000806000040), 0x1.00c00008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9ffffbf), -0x1.00c000082p+35, 0x0p+0 },
+{ INT64_C(0x0000000806000200), 0x1.00c0004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9fffdff), -0x1.00c000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000806002000), 0x1.00c004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9ffdfff), -0x1.00c004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000806010000), 0x1.00c02p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9feffff), -0x1.00c020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000806100000), 0x1.00c2p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f9efffff), -0x1.00c200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000807000000), 0x1.00ep+35, 0x0p+0 },
+{ INT64_C(0xfffffff7f8ffffff), -0x1.00e000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000004), 0x1.080000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffffb), -0x1.08000000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000840000006), 0x1.08000000cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffff9), -0x1.08000000ep+35, 0x0p+0 },
+{ INT64_C(0x0000000840000020), 0x1.08000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffffdf), -0x1.080000042p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000021), 0x1.080000042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffffde), -0x1.080000044p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000030), 0x1.08000006p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffffcf), -0x1.080000062p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000200), 0x1.0800004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffdff), -0x1.080000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000201), 0x1.080000402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffdfe), -0x1.080000404p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000210), 0x1.08000042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffdef), -0x1.080000422p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000220), 0x1.08000044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffddf), -0x1.080000442p+35, 0x0p+0 },
+{ INT64_C(0x0000000840000280), 0x1.0800005p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffffd7f), -0x1.080000502p+35, 0x0p+0 },
+{ INT64_C(0x0000000840002000), 0x1.080004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffdfff), -0x1.080004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840002002), 0x1.080004004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffdffd), -0x1.080004006p+35, 0x0p+0 },
+{ INT64_C(0x0000000840002020), 0x1.08000404p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffdfdf), -0x1.080004042p+35, 0x0p+0 },
+{ INT64_C(0x0000000840002100), 0x1.0800042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffdeff), -0x1.080004202p+35, 0x0p+0 },
+{ INT64_C(0x0000000840002800), 0x1.080005p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffd7ff), -0x1.080005002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004000), 0x1.080008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbfff), -0x1.080008002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004001), 0x1.080008002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbffe), -0x1.080008004p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004008), 0x1.08000801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbff7), -0x1.080008012p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004020), 0x1.08000804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbfdf), -0x1.080008042p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004080), 0x1.0800081p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbf7f), -0x1.080008102p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004100), 0x1.0800082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbeff), -0x1.080008202p+35, 0x0p+0 },
+{ INT64_C(0x0000000840004200), 0x1.0800084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffbdff), -0x1.080008402p+35, 0x0p+0 },
+{ INT64_C(0x0000000840005000), 0x1.08000ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfffafff), -0x1.08000a002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840040000), 0x1.08008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffbffff), -0x1.080080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840040008), 0x1.08008001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffbfff7), -0x1.080080012p+35, 0x0p+0 },
+{ INT64_C(0x0000000840040040), 0x1.08008008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffbffbf), -0x1.080080082p+35, 0x0p+0 },
+{ INT64_C(0x0000000840040080), 0x1.0800801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffbff7f), -0x1.080080102p+35, 0x0p+0 },
+{ INT64_C(0x0000000840040800), 0x1.080081p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffbf7ff), -0x1.080081002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840048000), 0x1.08009p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffb7fff), -0x1.080090002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840050000), 0x1.0800ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bffaffff), -0x1.0800a0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840060000), 0x1.0800cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bff9ffff), -0x1.0800c0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840100000), 0x1.0802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfefffff), -0x1.080200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840100002), 0x1.080200004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfeffffd), -0x1.080200006p+35, 0x0p+0 },
+{ INT64_C(0x0000000840100008), 0x1.08020001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfeffff7), -0x1.080200012p+35, 0x0p+0 },
+{ INT64_C(0x0000000840100080), 0x1.0802001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfefff7f), -0x1.080200102p+35, 0x0p+0 },
+{ INT64_C(0x0000000840100400), 0x1.0802008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfeffbff), -0x1.080200802p+35, 0x0p+0 },
+{ INT64_C(0x0000000840101000), 0x1.080202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfefefff), -0x1.080202002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840110000), 0x1.08022p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfeeffff), -0x1.080220002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200000), 0x1.0804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdfffff), -0x1.080400002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200001), 0x1.080400002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdffffe), -0x1.080400004p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200002), 0x1.080400004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdffffd), -0x1.080400006p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200008), 0x1.08040001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdffff7), -0x1.080400012p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200010), 0x1.08040002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdfffef), -0x1.080400022p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200020), 0x1.08040004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdfffdf), -0x1.080400042p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200080), 0x1.0804001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdfff7f), -0x1.080400102p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200200), 0x1.0804004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdffdff), -0x1.080400402p+35, 0x0p+0 },
+{ INT64_C(0x0000000840200800), 0x1.080401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdff7ff), -0x1.080401002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840208000), 0x1.08041p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdf7fff), -0x1.080410002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840210000), 0x1.08042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfdeffff), -0x1.080420002p+35, 0x0p+0 },
+{ INT64_C(0x0000000840280000), 0x1.0805p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bfd7ffff), -0x1.080500002p+35, 0x0p+0 },
+{ INT64_C(0x0000000842000000), 0x1.084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdffffff), -0x1.084000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000842000004), 0x1.084000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdfffffb), -0x1.08400000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000842000010), 0x1.08400002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdffffef), -0x1.084000022p+35, 0x0p+0 },
+{ INT64_C(0x0000000842000080), 0x1.0840001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdffff7f), -0x1.084000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000842000200), 0x1.0840004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdfffdff), -0x1.084000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000842000800), 0x1.084001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdfff7ff), -0x1.084001002p+35, 0x0p+0 },
+{ INT64_C(0x0000000842002000), 0x1.084004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdffdfff), -0x1.084004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000842010000), 0x1.08402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdfeffff), -0x1.084020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000842040000), 0x1.08408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdfbffff), -0x1.084080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000842400000), 0x1.0848p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bdbfffff), -0x1.084800002p+35, 0x0p+0 },
+{ INT64_C(0x0000000843000000), 0x1.086p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bcffffff), -0x1.086000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000000), 0x1.088p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbffffff), -0x1.088000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000001), 0x1.088000002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbfffffe), -0x1.088000004p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000002), 0x1.088000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbfffffd), -0x1.088000006p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000008), 0x1.08800001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbfffff7), -0x1.088000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000020), 0x1.08800004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbffffdf), -0x1.088000042p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000200), 0x1.0880004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbfffdff), -0x1.088000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000844000800), 0x1.088001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbfff7ff), -0x1.088001002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844008000), 0x1.08801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbff7fff), -0x1.088010002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844040000), 0x1.08808p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbfbffff), -0x1.088080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844080000), 0x1.0881p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbf7ffff), -0x1.088100002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844200000), 0x1.0884p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbdfffff), -0x1.088400002p+35, 0x0p+0 },
+{ INT64_C(0x0000000844400000), 0x1.0888p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7bbbfffff), -0x1.088800002p+35, 0x0p+0 },
+{ INT64_C(0x0000000846000000), 0x1.08cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b9ffffff), -0x1.08c000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000848000000), 0x1.09p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7ffffff), -0x1.090000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000848000008), 0x1.09000001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7fffff7), -0x1.090000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000848000080), 0x1.0900001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7ffff7f), -0x1.090000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000848000800), 0x1.090001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7fff7ff), -0x1.090001002p+35, 0x0p+0 },
+{ INT64_C(0x0000000848004000), 0x1.090008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7ffbfff), -0x1.090008002p+35, 0x0p+0 },
+{ INT64_C(0x0000000848010000), 0x1.09002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7feffff), -0x1.090020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000848100000), 0x1.0902p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b7efffff), -0x1.090200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000848800000), 0x1.091p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7b77fffff), -0x1.091000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000000), 0x1.0ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff7afffffff), -0x1.0a0000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000002), 0x1.0a0000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7affffffd), -0x1.0a0000006p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000008), 0x1.0a000001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7affffff7), -0x1.0a0000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000010), 0x1.0a000002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7afffffef), -0x1.0a0000022p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000080), 0x1.0a00001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7afffff7f), -0x1.0a0000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000200), 0x1.0a00004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7affffdff), -0x1.0a0000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000850000400), 0x1.0a00008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7affffbff), -0x1.0a0000802p+35, 0x0p+0 },
+{ INT64_C(0x0000000850002000), 0x1.0a0004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7afffdfff), -0x1.0a0004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000850020000), 0x1.0a004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7affdffff), -0x1.0a0040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000850080000), 0x1.0a01p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7aff7ffff), -0x1.0a0100002p+35, 0x0p+0 },
+{ INT64_C(0x0000000850400000), 0x1.0a08p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7afbfffff), -0x1.0a0800002p+35, 0x0p+0 },
+{ INT64_C(0x0000000852000000), 0x1.0a4p+35, 0x0p+0 },
+{ INT64_C(0xfffffff7adffffff), -0x1.0a4000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000858000000), 0x1.0bp+35, 0x0p+0 },
+{ INT64_C(0xfffffff7a7ffffff), -0x1.0b0000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000002), 0x1.100000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffffd), -0x1.100000006p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000008), 0x1.10000001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffff7), -0x1.100000012p+35, 0x0p+0 },
+{ INT64_C(0x000000088000000c), 0x1.100000018p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffff3), -0x1.10000001ap+35, 0x0p+0 },
+{ INT64_C(0x0000000880000040), 0x1.10000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffffbf), -0x1.100000082p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000041), 0x1.100000082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffffbe), -0x1.100000084p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000048), 0x1.10000009p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffffb7), -0x1.100000092p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000200), 0x1.1000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffdff), -0x1.100000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000201), 0x1.100000402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffdfe), -0x1.100000404p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000210), 0x1.10000042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffdef), -0x1.100000422p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000220), 0x1.10000044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffddf), -0x1.100000442p+35, 0x0p+0 },
+{ INT64_C(0x0000000880000280), 0x1.1000005p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffffd7f), -0x1.100000502p+35, 0x0p+0 },
+{ INT64_C(0x0000000880002000), 0x1.100004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffdfff), -0x1.100004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880002001), 0x1.100004002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffdffe), -0x1.100004004p+35, 0x0p+0 },
+{ INT64_C(0x0000000880002004), 0x1.100004008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffdffb), -0x1.10000400ap+35, 0x0p+0 },
+{ INT64_C(0x0000000880002008), 0x1.10000401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffdff7), -0x1.100004012p+35, 0x0p+0 },
+{ INT64_C(0x0000000880002040), 0x1.10000408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffdfbf), -0x1.100004082p+35, 0x0p+0 },
+{ INT64_C(0x0000000880002200), 0x1.1000044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffddff), -0x1.100004402p+35, 0x0p+0 },
+{ INT64_C(0x0000000880004000), 0x1.100008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffbfff), -0x1.100008002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880004004), 0x1.100008008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffbffb), -0x1.10000800ap+35, 0x0p+0 },
+{ INT64_C(0x0000000880004010), 0x1.10000802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffbfef), -0x1.100008022p+35, 0x0p+0 },
+{ INT64_C(0x0000000880004020), 0x1.10000804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffbfdf), -0x1.100008042p+35, 0x0p+0 },
+{ INT64_C(0x0000000880004200), 0x1.1000084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffbdff), -0x1.100008402p+35, 0x0p+0 },
+{ INT64_C(0x0000000880005000), 0x1.10000ap+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fffafff), -0x1.10000a002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880020000), 0x1.10004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffdffff), -0x1.100040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880020008), 0x1.10004001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffdfff7), -0x1.100040012p+35, 0x0p+0 },
+{ INT64_C(0x0000000880020080), 0x1.1000401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffdff7f), -0x1.100040102p+35, 0x0p+0 },
+{ INT64_C(0x0000000880020400), 0x1.1000408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffdfbff), -0x1.100040802p+35, 0x0p+0 },
+{ INT64_C(0x0000000880022000), 0x1.100044p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ffddfff), -0x1.100044002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880080000), 0x1.1001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff7ffff), -0x1.100100002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880080008), 0x1.10010001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff7fff7), -0x1.100100012p+35, 0x0p+0 },
+{ INT64_C(0x0000000880080080), 0x1.1001001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff7ff7f), -0x1.100100102p+35, 0x0p+0 },
+{ INT64_C(0x0000000880080400), 0x1.1001008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff7fbff), -0x1.100100802p+35, 0x0p+0 },
+{ INT64_C(0x0000000880084000), 0x1.100108p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff7bfff), -0x1.100108002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880088000), 0x1.10011p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff77fff), -0x1.100110002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880090000), 0x1.10012p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff6ffff), -0x1.100120002p+35, 0x0p+0 },
+{ INT64_C(0x00000008800a0000), 0x1.10014p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77ff5ffff), -0x1.100140002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200000), 0x1.1004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdfffff), -0x1.100400002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200001), 0x1.100400002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdffffe), -0x1.100400004p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200004), 0x1.100400008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdffffb), -0x1.10040000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000880200008), 0x1.10040001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdffff7), -0x1.100400012p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200020), 0x1.10040004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdfffdf), -0x1.100400042p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200040), 0x1.10040008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdfffbf), -0x1.100400082p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200080), 0x1.1004001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdfff7f), -0x1.100400102p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200200), 0x1.1004004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdffdff), -0x1.100400402p+35, 0x0p+0 },
+{ INT64_C(0x0000000880200800), 0x1.100401p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdff7ff), -0x1.100401002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880208000), 0x1.10041p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdf7fff), -0x1.100410002p+35, 0x0p+0 },
+{ INT64_C(0x0000000880240000), 0x1.10048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77fdbffff), -0x1.100480002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881000000), 0x1.102p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77effffff), -0x1.102000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881000004), 0x1.102000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77efffffb), -0x1.10200000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000881000008), 0x1.10200001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77efffff7), -0x1.102000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000881000080), 0x1.1020001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77effff7f), -0x1.102000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000881000200), 0x1.1020004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77efffdff), -0x1.102000402p+35, 0x0p+0 },
+{ INT64_C(0x0000000881000800), 0x1.102001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77efff7ff), -0x1.102001002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881001000), 0x1.102002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77effefff), -0x1.102002002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881010000), 0x1.10202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77efeffff), -0x1.102020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881020000), 0x1.10204p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77efdffff), -0x1.102040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881100000), 0x1.1022p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77eefffff), -0x1.102200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881200000), 0x1.1024p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77edfffff), -0x1.102400002p+35, 0x0p+0 },
+{ INT64_C(0x0000000881800000), 0x1.103p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77e7fffff), -0x1.103000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000884000000), 0x1.108p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bffffff), -0x1.108000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000884000008), 0x1.10800001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bfffff7), -0x1.108000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000884000010), 0x1.10800002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bffffef), -0x1.108000022p+35, 0x0p+0 },
+{ INT64_C(0x0000000884000080), 0x1.1080001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bffff7f), -0x1.108000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000884000400), 0x1.1080008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bfffbff), -0x1.108000802p+35, 0x0p+0 },
+{ INT64_C(0x0000000884001000), 0x1.108002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bffefff), -0x1.108002002p+35, 0x0p+0 },
+{ INT64_C(0x0000000884010000), 0x1.10802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77bfeffff), -0x1.108020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000884100000), 0x1.1082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77befffff), -0x1.108200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000884800000), 0x1.109p+35, 0x0p+0 },
+{ INT64_C(0xfffffff77b7fffff), -0x1.109000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000888000000), 0x1.11p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777ffffff), -0x1.110000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000888000008), 0x1.11000001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777fffff7), -0x1.110000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000888000080), 0x1.1100001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777ffff7f), -0x1.110000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000888000400), 0x1.1100008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777fffbff), -0x1.110000802p+35, 0x0p+0 },
+{ INT64_C(0x0000000888004000), 0x1.110008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777ffbfff), -0x1.110008002p+35, 0x0p+0 },
+{ INT64_C(0x0000000888010000), 0x1.11002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777feffff), -0x1.110020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000888100000), 0x1.1102p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777efffff), -0x1.110200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000888200000), 0x1.1104p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777dfffff), -0x1.110400002p+35, 0x0p+0 },
+{ INT64_C(0x0000000888400000), 0x1.1108p+35, 0x0p+0 },
+{ INT64_C(0xfffffff777bfffff), -0x1.110800002p+35, 0x0p+0 },
+{ INT64_C(0x0000000889000000), 0x1.112p+35, 0x0p+0 },
+{ INT64_C(0xfffffff776ffffff), -0x1.112000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000004), 0x1.400000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffffffb), -0x1.40000000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000020), 0x1.40000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffffdf), -0x1.400000042p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000021), 0x1.400000042p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffffde), -0x1.400000044p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000024), 0x1.400000048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffffdb), -0x1.40000004ap+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000028), 0x1.40000005p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffffd7), -0x1.400000052p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000100), 0x1.4000002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffffeff), -0x1.400000202p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000108), 0x1.40000021p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffffef7), -0x1.400000212p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00000140), 0x1.40000028p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffffebf), -0x1.400000282p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00001000), 0x1.400002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffefff), -0x1.400002002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00001004), 0x1.400002008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffeffb), -0x1.40000200ap+35, 0x0p+0 },
+{ INT64_C(0x0000000a00001008), 0x1.40000201p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffeff7), -0x1.400002012p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00001010), 0x1.40000202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffefef), -0x1.400002022p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00001080), 0x1.4000021p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffef7f), -0x1.400002102p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00001200), 0x1.4000024p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffedff), -0x1.400002402p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00002000), 0x1.400004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffdfff), -0x1.400004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00002004), 0x1.400004008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffdffb), -0x1.40000400ap+35, 0x0p+0 },
+{ INT64_C(0x0000000a00002040), 0x1.40000408p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffdfbf), -0x1.400004082p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00002080), 0x1.4000041p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffdf7f), -0x1.400004102p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00002400), 0x1.4000048p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffffdbff), -0x1.400004802p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00010000), 0x1.40002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffeffff), -0x1.400020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00010004), 0x1.400020008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffefffb), -0x1.40002000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000a00010020), 0x1.40002004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffeffdf), -0x1.400020042p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00010100), 0x1.4000202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffefeff), -0x1.400020202p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00010800), 0x1.400021p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffef7ff), -0x1.400021002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00018000), 0x1.40003p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffe7fff), -0x1.400030002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00040000), 0x1.40008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbffff), -0x1.400080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00040004), 0x1.400080008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbfffb), -0x1.40008000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000a00040040), 0x1.40008008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbffbf), -0x1.400080082p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00040200), 0x1.4000804p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbfdff), -0x1.400080402p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00040400), 0x1.4000808p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbfbff), -0x1.400080802p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00042000), 0x1.400084p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbdfff), -0x1.400084002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00044000), 0x1.400088p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fffbbfff), -0x1.400088002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00060000), 0x1.4000cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fff9ffff), -0x1.4000c0002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00400000), 0x1.4008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbfffff), -0x1.400800002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00400001), 0x1.400800002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbffffe), -0x1.400800004p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00400010), 0x1.40080002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbfffef), -0x1.400800022p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00400080), 0x1.4008001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbfff7f), -0x1.400800102p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00400800), 0x1.400801p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbff7ff), -0x1.400801002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00401000), 0x1.400802p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbfefff), -0x1.400802002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00410000), 0x1.40082p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffbeffff), -0x1.400820002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00480000), 0x1.4009p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ffb7ffff), -0x1.400900002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a00600000), 0x1.400cp+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ff9fffff), -0x1.400c00002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01000000), 0x1.402p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5feffffff), -0x1.402000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01000008), 0x1.40200001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fefffff7), -0x1.402000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01000080), 0x1.4020001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5feffff7f), -0x1.402000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01000800), 0x1.402001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fefff7ff), -0x1.402001002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01001000), 0x1.402002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5feffefff), -0x1.402002002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01010000), 0x1.40202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fefeffff), -0x1.402020002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01080000), 0x1.4021p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fef7ffff), -0x1.402100002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a01800000), 0x1.403p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5fe7fffff), -0x1.403000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10000000), 0x1.42p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5efffffff), -0x1.420000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10000002), 0x1.420000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5effffffd), -0x1.420000006p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10000020), 0x1.42000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5efffffdf), -0x1.420000042p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10000080), 0x1.4200001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5efffff7f), -0x1.420000102p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10000400), 0x1.4200008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5effffbff), -0x1.420000802p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10002000), 0x1.420004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5efffdfff), -0x1.420004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10020000), 0x1.42004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5effdffff), -0x1.420040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10040000), 0x1.42008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5effbffff), -0x1.420080002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a10100000), 0x1.4202p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5efefffff), -0x1.420200002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a11000000), 0x1.422p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5eeffffff), -0x1.422000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000a14000000), 0x1.428p+35, 0x0p+0 },
+{ INT64_C(0xfffffff5ebffffff), -0x1.428000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00000000), 0x1.6p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4ffffffff), -0x1.600000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00000004), 0x1.600000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4fffffffb), -0x1.60000000ap+35, 0x0p+0 },
+{ INT64_C(0x0000000b00000008), 0x1.60000001p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4fffffff7), -0x1.600000012p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00000020), 0x1.60000004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4ffffffdf), -0x1.600000042p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00000100), 0x1.6000002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4fffffeff), -0x1.600000202p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00000400), 0x1.6000008p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4fffffbff), -0x1.600000802p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00001000), 0x1.600002p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4ffffefff), -0x1.600002002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00002000), 0x1.600004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4ffffdfff), -0x1.600004002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00020000), 0x1.60004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4fffdffff), -0x1.600040002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b00200000), 0x1.6004p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4ffdfffff), -0x1.600400002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b01000000), 0x1.602p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4feffffff), -0x1.602000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b08000000), 0x1.61p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4f7ffffff), -0x1.610000002p+35, 0x0p+0 },
+{ INT64_C(0x0000000b20000000), 0x1.64p+35, 0x0p+0 },
+{ INT64_C(0xfffffff4dfffffff), -0x1.640000002p+35, 0x0p+0 },
+{ INT64_C(0x000000200000000c), 0x1.000000006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffff3), -0x1.0000000068p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000044), 0x1.000000022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffffbb), -0x1.0000000228p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000060), 0x1.00000003p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffff9f), -0x1.0000000308p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000064), 0x1.000000032p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffff9b), -0x1.0000000328p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000408), 0x1.000000204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbf7), -0x1.0000002048p+37, 0x0p+0 },
+{ INT64_C(0x000000200000040a), 0x1.000000205p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbf5), -0x1.0000002058p+37, 0x0p+0 },
+{ INT64_C(0x000000200000040c), 0x1.000000206p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbf3), -0x1.0000002068p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000410), 0x1.000000208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbef), -0x1.0000002088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000411), 0x1.0000002088p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbee), -0x1.000000209p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000440), 0x1.00000022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbbf), -0x1.0000002208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000442), 0x1.000000221p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbbd), -0x1.0000002218p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000448), 0x1.000000224p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffbb7), -0x1.0000002248p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000480), 0x1.00000024p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffb7f), -0x1.0000002408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000488), 0x1.000000244p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffb77), -0x1.0000002448p+37, 0x0p+0 },
+{ INT64_C(0x00000020000004a0), 0x1.00000025p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffb5f), -0x1.0000002508p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000500), 0x1.00000028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffaff), -0x1.0000002808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000508), 0x1.000000284p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffaf7), -0x1.0000002848p+37, 0x0p+0 },
+{ INT64_C(0x0000002000000510), 0x1.000000288p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffffaef), -0x1.0000002888p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001001), 0x1.0000008008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffeffe), -0x1.000000801p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001002), 0x1.000000801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffeffd), -0x1.0000008018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001003), 0x1.0000008018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffeffc), -0x1.000000802p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001004), 0x1.000000802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffeffb), -0x1.0000008028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001040), 0x1.00000082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffefbf), -0x1.0000008208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001042), 0x1.000000821p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffefbd), -0x1.0000008218p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001044), 0x1.000000822p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffefbb), -0x1.0000008228p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001050), 0x1.000000828p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffefaf), -0x1.0000008288p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001060), 0x1.00000083p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffef9f), -0x1.0000008308p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001200), 0x1.0000009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffedff), -0x1.0000009008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001208), 0x1.000000904p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffedf7), -0x1.0000009048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001220), 0x1.00000091p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffeddf), -0x1.0000009108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001300), 0x1.00000098p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffecff), -0x1.0000009808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001800), 0x1.000000cp+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffe7ff), -0x1.000000c008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001802), 0x1.000000c01p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffe7fd), -0x1.000000c018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001804), 0x1.000000c02p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffe7fb), -0x1.000000c028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001810), 0x1.000000c08p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffe7ef), -0x1.000000c088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001820), 0x1.000000c1p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffe7df), -0x1.000000c108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000001880), 0x1.000000c4p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffffe77f), -0x1.000000c408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000008004), 0x1.000004002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff7ffb), -0x1.0000040028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000008020), 0x1.00000401p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff7fdf), -0x1.0000040108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000008028), 0x1.000004014p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff7fd7), -0x1.0000040148p+37, 0x0p+0 },
+{ INT64_C(0x0000002000008100), 0x1.00000408p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff7eff), -0x1.0000040808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000008108), 0x1.000004084p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff7ef7), -0x1.0000040848p+37, 0x0p+0 },
+{ INT64_C(0x0000002000008180), 0x1.0000040cp+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff7e7f), -0x1.0000040c08p+37, 0x0p+0 },
+{ INT64_C(0x0000002000009000), 0x1.0000048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff6fff), -0x1.0000048008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000009001), 0x1.0000048008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff6ffe), -0x1.000004801p+37, 0x0p+0 },
+{ INT64_C(0x0000002000009002), 0x1.000004801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff6ffd), -0x1.0000048018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000009008), 0x1.000004804p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff6ff7), -0x1.0000048048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000009020), 0x1.00000481p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff6fdf), -0x1.0000048108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000009200), 0x1.0000049p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffff6dff), -0x1.0000049008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020001), 0x1.0000100008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfffe), -0x1.000010001p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020002), 0x1.000010001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfffd), -0x1.0000100018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020008), 0x1.000010004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfff7), -0x1.0000100048p+37, 0x0p+0 },
+{ INT64_C(0x000000200002000c), 0x1.000010006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfff3), -0x1.0000100068p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020040), 0x1.00001002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdffbf), -0x1.0000100208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020044), 0x1.000010022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdffbb), -0x1.0000100228p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020050), 0x1.000010028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdffaf), -0x1.0000100288p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020080), 0x1.00001004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdff7f), -0x1.0000100408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020081), 0x1.0000100408p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdff7e), -0x1.000010041p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020084), 0x1.000010042p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdff7b), -0x1.0000100428p+37, 0x0p+0 },
+{ INT64_C(0x00000020000200a0), 0x1.00001005p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdff5f), -0x1.0000100508p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020100), 0x1.00001008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfeff), -0x1.0000100808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020102), 0x1.000010081p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfefd), -0x1.0000100818p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020120), 0x1.00001009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfedf), -0x1.0000100908p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020180), 0x1.0000100cp+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdfe7f), -0x1.0000100c08p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020800), 0x1.0000104p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdf7ff), -0x1.0000104008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020808), 0x1.000010404p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdf7f7), -0x1.0000104048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020810), 0x1.000010408p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdf7ef), -0x1.0000104088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020820), 0x1.00001041p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdf7df), -0x1.0000104108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020880), 0x1.00001044p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdf77f), -0x1.0000104408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000020900), 0x1.00001048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdf6ff), -0x1.0000104808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000024000), 0x1.000012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdbfff), -0x1.0000120008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000024008), 0x1.000012004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdbff7), -0x1.0000120048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000024020), 0x1.00001201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdbfdf), -0x1.0000120108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000024040), 0x1.00001202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdbfbf), -0x1.0000120208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000024080), 0x1.00001204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdbf7f), -0x1.0000120408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000024800), 0x1.0000124p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffdb7ff), -0x1.0000124008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000026000), 0x1.000013p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffd9fff), -0x1.0000130008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000028000), 0x1.000014p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffd7fff), -0x1.0000140008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000028004), 0x1.000014002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffd7ffb), -0x1.0000140028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000028040), 0x1.00001402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffd7fbf), -0x1.0000140208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000028400), 0x1.0000142p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffd7bff), -0x1.0000142008p+37, 0x0p+0 },
+{ INT64_C(0x000000200002c000), 0x1.000016p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffd3fff), -0x1.0000160008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000030000), 0x1.000018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcffff), -0x1.0000180008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000030008), 0x1.000018004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcfff7), -0x1.0000180048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000030010), 0x1.000018008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcffef), -0x1.0000180088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000030040), 0x1.00001802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcffbf), -0x1.0000180208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000030200), 0x1.0000181p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcfdff), -0x1.0000181008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000031000), 0x1.0000188p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcefff), -0x1.0000188008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000034000), 0x1.00001ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdffffcbfff), -0x1.00001a0008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200002), 0x1.000100001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffffd), -0x1.0001000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200010), 0x1.000100008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfffef), -0x1.0001000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200011), 0x1.0001000088p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfffee), -0x1.000100009p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200012), 0x1.000100009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfffed), -0x1.0001000098p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200100), 0x1.00010008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffeff), -0x1.0001000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200108), 0x1.000100084p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffef7), -0x1.0001000848p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200120), 0x1.00010009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffedf), -0x1.0001000908p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200180), 0x1.0001000cp+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffe7f), -0x1.0001000c08p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200200), 0x1.0001001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffdff), -0x1.0001001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200204), 0x1.000100102p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffdfb), -0x1.0001001028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000200240), 0x1.00010012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdffdbf), -0x1.0001001208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000201000), 0x1.0001008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfefff), -0x1.0001008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000201001), 0x1.0001008008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfeffe), -0x1.000100801p+37, 0x0p+0 },
+{ INT64_C(0x0000002000201002), 0x1.000100801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfeffd), -0x1.0001008018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000201010), 0x1.000100808p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfefef), -0x1.0001008088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000201040), 0x1.00010082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfefbf), -0x1.0001008208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000201400), 0x1.000100ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfebff), -0x1.000100a008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000204000), 0x1.000102p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfbfff), -0x1.0001020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000204002), 0x1.000102001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfbffd), -0x1.0001020018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000204010), 0x1.000102008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfbfef), -0x1.0001020088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000204080), 0x1.00010204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfbf7f), -0x1.0001020408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000204200), 0x1.0001021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfbdff), -0x1.0001021008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000204800), 0x1.0001024p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdfb7ff), -0x1.0001024008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000206000), 0x1.000103p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdf9fff), -0x1.0001030008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000240000), 0x1.00012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdbffff), -0x1.0001200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000240008), 0x1.000120004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdbfff7), -0x1.0001200048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000240020), 0x1.00012001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdbffdf), -0x1.0001200108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000240200), 0x1.0001201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdbfdff), -0x1.0001201008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000240800), 0x1.0001204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdbf7ff), -0x1.0001204008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000242000), 0x1.000121p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdbdfff), -0x1.0001210008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000248000), 0x1.000124p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffdb7fff), -0x1.0001240008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300000), 0x1.00018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcfffff), -0x1.0001800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300001), 0x1.0001800008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcffffe), -0x1.000180001p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300010), 0x1.000180008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcfffef), -0x1.0001800088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300040), 0x1.00018002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcfffbf), -0x1.0001800208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300100), 0x1.00018008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcffeff), -0x1.0001800808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300200), 0x1.0001801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcffdff), -0x1.0001801008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000300400), 0x1.0001802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcffbff), -0x1.0001802008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000301000), 0x1.0001808p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcfefff), -0x1.0001808008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000304000), 0x1.000182p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcfbfff), -0x1.0001820008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000308000), 0x1.000184p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffcf7fff), -0x1.0001840008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000310000), 0x1.000188p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffceffff), -0x1.0001880008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400001), 0x1.0002000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbffffe), -0x1.000200001p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400002), 0x1.000200001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbffffd), -0x1.0002000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400004), 0x1.000200002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbffffb), -0x1.0002000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400020), 0x1.00020001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfffdf), -0x1.0002000108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400024), 0x1.000200012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfffdb), -0x1.0002000128p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400100), 0x1.00020008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbffeff), -0x1.0002000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400102), 0x1.000200081p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbffefd), -0x1.0002000818p+37, 0x0p+0 },
+{ INT64_C(0x0000002000400120), 0x1.00020009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbffedf), -0x1.0002000908p+37, 0x0p+0 },
+{ INT64_C(0x0000002000401000), 0x1.0002008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfefff), -0x1.0002008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000401002), 0x1.000200801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfeffd), -0x1.0002008018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000401008), 0x1.000200804p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfeff7), -0x1.0002008048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000401040), 0x1.00020082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfefbf), -0x1.0002008208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000401400), 0x1.000200ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfebff), -0x1.000200a008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000404000), 0x1.000202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfbfff), -0x1.0002020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000404002), 0x1.000202001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfbffd), -0x1.0002020018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000404004), 0x1.000202002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfbffb), -0x1.0002020028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000404008), 0x1.000202004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfbff7), -0x1.0002020048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000404080), 0x1.00020204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfbf7f), -0x1.0002020408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000404400), 0x1.0002022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbfbbff), -0x1.0002022008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000420000), 0x1.00021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdffff), -0x1.0002100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000420008), 0x1.000210004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdfff7), -0x1.0002100048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000420010), 0x1.000210008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdffef), -0x1.0002100088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000420020), 0x1.00021001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdffdf), -0x1.0002100108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000420200), 0x1.0002101p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdfdff), -0x1.0002101008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000421000), 0x1.0002108p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdefff), -0x1.0002108008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000424000), 0x1.000212p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbdbfff), -0x1.0002120008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440000), 0x1.00022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbffff), -0x1.0002200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440001), 0x1.0002200008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbfffe), -0x1.000220001p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440010), 0x1.000220008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbffef), -0x1.0002200088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440040), 0x1.00022002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbffbf), -0x1.0002200208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440080), 0x1.00022004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbff7f), -0x1.0002200408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440100), 0x1.00022008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbfeff), -0x1.0002200808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000440200), 0x1.0002201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbfdff), -0x1.0002201008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000442000), 0x1.000221p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbbdfff), -0x1.0002210008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000448000), 0x1.000224p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffbb7fff), -0x1.0002240008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000460000), 0x1.00023p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb9ffff), -0x1.0002300008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000480000), 0x1.00024p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7ffff), -0x1.0002400008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000480002), 0x1.000240001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7fffd), -0x1.0002400018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000480008), 0x1.000240004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7fff7), -0x1.0002400048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000480010), 0x1.000240008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7ffef), -0x1.0002400088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000480040), 0x1.00024002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7ffbf), -0x1.0002400208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000480400), 0x1.0002402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7fbff), -0x1.0002402008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000481000), 0x1.0002408p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb7efff), -0x1.0002408008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000490000), 0x1.000248p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb6ffff), -0x1.0002480008p+37, 0x0p+0 },
+{ INT64_C(0x00000020004a0000), 0x1.00025p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfffb5ffff), -0x1.0002500008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800001), 0x1.0004000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7ffffe), -0x1.000400001p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800010), 0x1.000400008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fffef), -0x1.0004000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800012), 0x1.000400009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fffed), -0x1.0004000098p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800040), 0x1.00040002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fffbf), -0x1.0004000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800041), 0x1.0004000208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fffbe), -0x1.000400021p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800044), 0x1.000400022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fffbb), -0x1.0004000228p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800060), 0x1.00040003p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fff9f), -0x1.0004000308p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800400), 0x1.0004002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7ffbff), -0x1.0004002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800408), 0x1.000400204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7ffbf7), -0x1.0004002048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800420), 0x1.00040021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7ffbdf), -0x1.0004002108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000800600), 0x1.0004003p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7ff9ff), -0x1.0004003008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000804000), 0x1.000402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fbfff), -0x1.0004020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000804002), 0x1.000402001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fbffd), -0x1.0004020018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000804020), 0x1.00040201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fbfdf), -0x1.0004020108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000804080), 0x1.00040204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fbf7f), -0x1.0004020408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000804200), 0x1.0004021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fbdff), -0x1.0004021008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000804800), 0x1.0004024p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7fb7ff), -0x1.0004024008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000806000), 0x1.000403p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7f9fff), -0x1.0004030008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000810000), 0x1.000408p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7effff), -0x1.0004080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000810001), 0x1.0004080008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7efffe), -0x1.000408001p+37, 0x0p+0 },
+{ INT64_C(0x0000002000810010), 0x1.000408008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7effef), -0x1.0004080088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000810040), 0x1.00040802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7effbf), -0x1.0004080208p+37, 0x0p+0 },
+{ INT64_C(0x0000002000810400), 0x1.0004082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7efbff), -0x1.0004082008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000811000), 0x1.0004088p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7eefff), -0x1.0004088008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000812000), 0x1.000409p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7edfff), -0x1.0004090008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820000), 0x1.00041p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dffff), -0x1.0004100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820008), 0x1.000410004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dfff7), -0x1.0004100048p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820010), 0x1.000410008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dffef), -0x1.0004100088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820080), 0x1.00041004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dff7f), -0x1.0004100408p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820100), 0x1.00041008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dfeff), -0x1.0004100808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820200), 0x1.0004101p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dfdff), -0x1.0004101008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000820800), 0x1.0004104p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7df7ff), -0x1.0004104008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000822000), 0x1.000411p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7ddfff), -0x1.0004110008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000824000), 0x1.000412p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7dbfff), -0x1.0004120008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000828000), 0x1.000414p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7d7fff), -0x1.0004140008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000830000), 0x1.000418p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7cffff), -0x1.0004180008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000840000), 0x1.00042p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7bffff), -0x1.0004200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000840002), 0x1.000420001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7bfffd), -0x1.0004200018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000840010), 0x1.000420008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7bffef), -0x1.0004200088p+37, 0x0p+0 },
+{ INT64_C(0x0000002000840100), 0x1.00042008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7bfeff), -0x1.0004200808p+37, 0x0p+0 },
+{ INT64_C(0x0000002000841000), 0x1.0004208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7befff), -0x1.0004208008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000850000), 0x1.000428p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff7affff), -0x1.0004280008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000900000), 0x1.00048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6fffff), -0x1.0004800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000900004), 0x1.000480002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6ffffb), -0x1.0004800028p+37, 0x0p+0 },
+{ INT64_C(0x0000002000900020), 0x1.00048001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6fffdf), -0x1.0004800108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000900200), 0x1.0004801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6ffdff), -0x1.0004801008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000900400), 0x1.0004802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6ffbff), -0x1.0004802008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000904000), 0x1.000482p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6fbfff), -0x1.0004820008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000910000), 0x1.000488p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff6effff), -0x1.0004880008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c00000), 0x1.0006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3fffff), -0x1.0006000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c00002), 0x1.000600001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3ffffd), -0x1.0006000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c00020), 0x1.00060001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3fffdf), -0x1.0006000108p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c00200), 0x1.0006001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3ffdff), -0x1.0006001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c01000), 0x1.0006008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3fefff), -0x1.0006008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c02000), 0x1.000601p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3fdfff), -0x1.0006010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c04000), 0x1.000602p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3fbfff), -0x1.0006020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c08000), 0x1.000604p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3f7fff), -0x1.0006040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000c20000), 0x1.00061p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff3dffff), -0x1.0006100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002000e00000), 0x1.0007p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfff1fffff), -0x1.0007000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000002), 0x1.002000001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfffffd), -0x1.0020000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000004), 0x1.002000002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfffffb), -0x1.0020000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000006), 0x1.002000003p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfffff9), -0x1.0020000038p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000010), 0x1.002000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffffef), -0x1.0020000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000012), 0x1.002000009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffffed), -0x1.0020000098p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000018), 0x1.00200000cp+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffffe7), -0x1.00200000c8p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000100), 0x1.00200008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfffeff), -0x1.0020000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000104), 0x1.002000082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfffefb), -0x1.0020000828p+37, 0x0p+0 },
+{ INT64_C(0x0000002004000140), 0x1.0020000ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfffebf), -0x1.0020000a08p+37, 0x0p+0 },
+{ INT64_C(0x0000002004001000), 0x1.0020008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffefff), -0x1.0020008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004001002), 0x1.002000801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffeffd), -0x1.0020008018p+37, 0x0p+0 },
+{ INT64_C(0x0000002004001008), 0x1.002000804p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffeff7), -0x1.0020008048p+37, 0x0p+0 },
+{ INT64_C(0x0000002004001020), 0x1.00200081p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffefdf), -0x1.0020008108p+37, 0x0p+0 },
+{ INT64_C(0x0000002004001200), 0x1.0020009p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbffedff), -0x1.0020009008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004008000), 0x1.002004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff7fff), -0x1.0020040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004008002), 0x1.002004001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff7ffd), -0x1.0020040018p+37, 0x0p+0 },
+{ INT64_C(0x0000002004008020), 0x1.00200401p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff7fdf), -0x1.0020040108p+37, 0x0p+0 },
+{ INT64_C(0x0000002004008080), 0x1.00200404p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff7f7f), -0x1.0020040408p+37, 0x0p+0 },
+{ INT64_C(0x0000002004008800), 0x1.0020044p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff77ff), -0x1.0020044008p+37, 0x0p+0 },
+{ INT64_C(0x000000200400a000), 0x1.002005p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff5fff), -0x1.0020050008p+37, 0x0p+0 },
+{ INT64_C(0x000000200400c000), 0x1.002006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbff3fff), -0x1.0020060008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004040000), 0x1.00202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbffff), -0x1.0020200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004040001), 0x1.0020200008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbfffe), -0x1.002020001p+37, 0x0p+0 },
+{ INT64_C(0x0000002004040002), 0x1.002020001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbfffd), -0x1.0020200018p+37, 0x0p+0 },
+{ INT64_C(0x0000002004040004), 0x1.002020002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbfffb), -0x1.0020200028p+37, 0x0p+0 },
+{ INT64_C(0x0000002004040020), 0x1.00202001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbffdf), -0x1.0020200108p+37, 0x0p+0 },
+{ INT64_C(0x0000002004040200), 0x1.0020201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbfdff), -0x1.0020201008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004042000), 0x1.002021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbdfff), -0x1.0020210008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004044000), 0x1.002022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfbbfff), -0x1.0020220008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004050000), 0x1.002028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbfaffff), -0x1.0020280008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004060000), 0x1.00203p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbf9ffff), -0x1.0020300008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004200000), 0x1.0021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdfffff), -0x1.0021000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004200004), 0x1.002100002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdffffb), -0x1.0021000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002004200040), 0x1.00210002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdfffbf), -0x1.0021000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002004200080), 0x1.00210004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdfff7f), -0x1.0021000408p+37, 0x0p+0 },
+{ INT64_C(0x0000002004200200), 0x1.0021001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdffdff), -0x1.0021001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004200400), 0x1.0021002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdffbff), -0x1.0021002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004201000), 0x1.0021008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdfefff), -0x1.0021008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004202000), 0x1.002101p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbdfdfff), -0x1.0021010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002004220000), 0x1.00211p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffbddffff), -0x1.0021100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005000000), 0x1.0028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaffffff), -0x1.0028000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005000001), 0x1.0028000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffafffffe), -0x1.002800001p+37, 0x0p+0 },
+{ INT64_C(0x0000002005000008), 0x1.002800004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffafffff7), -0x1.0028000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002005000040), 0x1.00280002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaffffbf), -0x1.0028000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002005000200), 0x1.0028001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffafffdff), -0x1.0028001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005001000), 0x1.0028008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaffefff), -0x1.0028008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005004000), 0x1.002802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaffbfff), -0x1.0028020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005008000), 0x1.002804p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaff7fff), -0x1.0028040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005080000), 0x1.00284p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaf7ffff), -0x1.0028400008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005100000), 0x1.00288p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffaefffff), -0x1.0028800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002005200000), 0x1.0029p+37, 0x0p+0 },
+{ INT64_C(0xffffffdffadfffff), -0x1.0029000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000002), 0x1.004000001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffffd), -0x1.0040000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000003), 0x1.0040000018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffffc), -0x1.004000002p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000008), 0x1.004000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffff7), -0x1.0040000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000009), 0x1.0040000048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffff6), -0x1.004000005p+37, 0x0p+0 },
+{ INT64_C(0x000000200800000a), 0x1.004000005p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffff5), -0x1.0040000058p+37, 0x0p+0 },
+{ INT64_C(0x000000200800000c), 0x1.004000006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffff3), -0x1.0040000068p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000020), 0x1.00400001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffffdf), -0x1.0040000108p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000022), 0x1.004000011p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffffdd), -0x1.0040000118p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000030), 0x1.004000018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffffcf), -0x1.0040000188p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000200), 0x1.0040001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffdff), -0x1.0040001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000204), 0x1.004000102p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffdfb), -0x1.0040001028p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000210), 0x1.004000108p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffdef), -0x1.0040001088p+37, 0x0p+0 },
+{ INT64_C(0x0000002008000300), 0x1.00400018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fffcff), -0x1.0040001808p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002000), 0x1.004001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdfff), -0x1.0040010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002004), 0x1.004001002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdffb), -0x1.0040010028p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002010), 0x1.004001008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdfef), -0x1.0040010088p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002020), 0x1.00400101p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdfdf), -0x1.0040010108p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002040), 0x1.00400102p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdfbf), -0x1.0040010208p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002100), 0x1.00400108p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdeff), -0x1.0040010808p+37, 0x0p+0 },
+{ INT64_C(0x0000002008002400), 0x1.0040012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7ffdbff), -0x1.0040012008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008010000), 0x1.004008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7feffff), -0x1.0040080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008010004), 0x1.004008002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fefffb), -0x1.0040080028p+37, 0x0p+0 },
+{ INT64_C(0x0000002008010040), 0x1.00400802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7feffbf), -0x1.0040080208p+37, 0x0p+0 },
+{ INT64_C(0x0000002008010080), 0x1.00400804p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7feff7f), -0x1.0040080408p+37, 0x0p+0 },
+{ INT64_C(0x0000002008010800), 0x1.0040084p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fef7ff), -0x1.0040084008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008018000), 0x1.00400cp+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fe7fff), -0x1.00400c0008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040000), 0x1.00402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbffff), -0x1.0040200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040001), 0x1.0040200008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbfffe), -0x1.004020001p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040002), 0x1.004020001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbfffd), -0x1.0040200018p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040020), 0x1.00402001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbffdf), -0x1.0040200108p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040040), 0x1.00402002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbffbf), -0x1.0040200208p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040080), 0x1.00402004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbff7f), -0x1.0040200408p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040200), 0x1.0040201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbfdff), -0x1.0040201008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008040400), 0x1.0040202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbfbff), -0x1.0040202008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008044000), 0x1.004022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7fbbfff), -0x1.0040220008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008400000), 0x1.0042p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bfffff), -0x1.0042000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008400002), 0x1.004200001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bffffd), -0x1.0042000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002008400010), 0x1.004200008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bfffef), -0x1.0042000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002008400040), 0x1.00420002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bfffbf), -0x1.0042000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002008400400), 0x1.0042002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bffbff), -0x1.0042002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008402000), 0x1.004201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bfdfff), -0x1.0042010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008408000), 0x1.004204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bf7fff), -0x1.0042040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008440000), 0x1.00422p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7bbffff), -0x1.0042200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008500000), 0x1.00428p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff7afffff), -0x1.0042800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008800000), 0x1.0044p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77fffff), -0x1.0044000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008800004), 0x1.004400002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77ffffb), -0x1.0044000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002008800008), 0x1.004400004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77ffff7), -0x1.0044000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002008800040), 0x1.00440002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77fffbf), -0x1.0044000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002008800100), 0x1.00440008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77ffeff), -0x1.0044000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002008801000), 0x1.0044008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77fefff), -0x1.0044008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008802000), 0x1.004401p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77fdfff), -0x1.0044010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008804000), 0x1.004402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77fbfff), -0x1.0044020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008820000), 0x1.00441p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77dffff), -0x1.0044100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008840000), 0x1.00442p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff77bffff), -0x1.0044200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002008c00000), 0x1.0046p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff73fffff), -0x1.0046000008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000000), 0x1.006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3ffffff), -0x1.0060000008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000001), 0x1.0060000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3fffffe), -0x1.006000001p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000010), 0x1.006000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3ffffef), -0x1.0060000088p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000040), 0x1.00600002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3ffffbf), -0x1.0060000208p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000080), 0x1.00600004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3ffff7f), -0x1.0060000408p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000200), 0x1.0060001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3fffdff), -0x1.0060001008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c000800), 0x1.0060004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3fff7ff), -0x1.0060004008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c004000), 0x1.006002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3ffbfff), -0x1.0060020008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c008000), 0x1.006004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3ff7fff), -0x1.0060040008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c080000), 0x1.00604p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff3f7ffff), -0x1.0060400008p+37, 0x0p+0 },
+{ INT64_C(0x000000200c800000), 0x1.0064p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff37fffff), -0x1.0064000008p+37, 0x0p+0 },
+{ INT64_C(0x000000200e000000), 0x1.007p+37, 0x0p+0 },
+{ INT64_C(0xffffffdff1ffffff), -0x1.0070000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000002), 0x1.008000001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffffd), -0x1.0080000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000003), 0x1.0080000018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffffc), -0x1.008000002p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000020), 0x1.00800001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffffdf), -0x1.0080000108p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000021), 0x1.0080000108p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffffde), -0x1.008000011p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000030), 0x1.008000018p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffffcf), -0x1.0080000188p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000200), 0x1.0080001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffdff), -0x1.0080001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000208), 0x1.008000104p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffdf7), -0x1.0080001048p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000220), 0x1.00800011p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffddf), -0x1.0080001108p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000400), 0x1.0080002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffbff), -0x1.0080002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000404), 0x1.008000202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffbfb), -0x1.0080002028p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000420), 0x1.00800021p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffbdf), -0x1.0080002108p+37, 0x0p+0 },
+{ INT64_C(0x0000002010000500), 0x1.00800028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffffaff), -0x1.0080002808p+37, 0x0p+0 },
+{ INT64_C(0x0000002010002000), 0x1.008001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffdfff), -0x1.0080010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010002002), 0x1.008001001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffdffd), -0x1.0080010018p+37, 0x0p+0 },
+{ INT64_C(0x0000002010002004), 0x1.008001002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffdffb), -0x1.0080010028p+37, 0x0p+0 },
+{ INT64_C(0x0000002010002020), 0x1.00800101p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffdfdf), -0x1.0080010108p+37, 0x0p+0 },
+{ INT64_C(0x0000002010002200), 0x1.0080011p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffddff), -0x1.0080011008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010002800), 0x1.0080014p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefffd7ff), -0x1.0080014008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008000), 0x1.008004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7fff), -0x1.0080040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008002), 0x1.008004001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7ffd), -0x1.0080040018p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008004), 0x1.008004002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7ffb), -0x1.0080040028p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008020), 0x1.00800401p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7fdf), -0x1.0080040108p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008040), 0x1.00800402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7fbf), -0x1.0080040208p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008080), 0x1.00800404p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7f7f), -0x1.0080040408p+37, 0x0p+0 },
+{ INT64_C(0x0000002010008200), 0x1.0080041p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff7dff), -0x1.0080041008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010009000), 0x1.0080048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefff6fff), -0x1.0080048008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040000), 0x1.00802p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbffff), -0x1.0080200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040008), 0x1.008020004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbfff7), -0x1.0080200048p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040040), 0x1.00802002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbffbf), -0x1.0080200208p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040100), 0x1.00802008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbfeff), -0x1.0080200808p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040200), 0x1.0080201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbfdff), -0x1.0080201008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040400), 0x1.0080202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbfbff), -0x1.0080202008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010040800), 0x1.0080204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbf7ff), -0x1.0080204008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010041000), 0x1.0080208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffbefff), -0x1.0080208008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010048000), 0x1.008024p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeffb7fff), -0x1.0080240008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010060000), 0x1.00803p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeff9ffff), -0x1.0080300008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010100000), 0x1.00808p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefefffff), -0x1.0080800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010100001), 0x1.0080800008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefeffffe), -0x1.008080001p+37, 0x0p+0 },
+{ INT64_C(0x0000002010100008), 0x1.008080004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefeffff7), -0x1.0080800048p+37, 0x0p+0 },
+{ INT64_C(0x0000002010100020), 0x1.00808001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefefffdf), -0x1.0080800108p+37, 0x0p+0 },
+{ INT64_C(0x0000002010100100), 0x1.00808008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefeffeff), -0x1.0080800808p+37, 0x0p+0 },
+{ INT64_C(0x0000002010101000), 0x1.0080808p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefefefff), -0x1.0080808008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010104000), 0x1.008082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefefbfff), -0x1.0080820008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010120000), 0x1.00809p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefedffff), -0x1.0080900008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010400000), 0x1.0082p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbfffff), -0x1.0082000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010400004), 0x1.008200002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbffffb), -0x1.0082000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002010400008), 0x1.008200004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbffff7), -0x1.0082000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002010400080), 0x1.00820004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbfff7f), -0x1.0082000408p+37, 0x0p+0 },
+{ INT64_C(0x0000002010400400), 0x1.0082002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbffbff), -0x1.0082002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010402000), 0x1.008201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbfdfff), -0x1.0082010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010408000), 0x1.008204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefbf7fff), -0x1.0082040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002010480000), 0x1.00824p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfefb7ffff), -0x1.0082400008p+37, 0x0p+0 },
+{ INT64_C(0x0000002014000000), 0x1.00ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebffffff), -0x1.00a0000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002014000008), 0x1.00a000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebfffff7), -0x1.00a0000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002014000010), 0x1.00a000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebffffef), -0x1.00a0000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002014000100), 0x1.00a00008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebfffeff), -0x1.00a0000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002014000400), 0x1.00a0002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebfffbff), -0x1.00a0002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002014004000), 0x1.00a002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebffbfff), -0x1.00a0020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002014008000), 0x1.00a004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebff7fff), -0x1.00a0040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002014020000), 0x1.00a01p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebfdffff), -0x1.00a0100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002014100000), 0x1.00a08p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfebefffff), -0x1.00a0800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002015000000), 0x1.00a8p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfeaffffff), -0x1.00a8000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002016000000), 0x1.00bp+37, 0x0p+0 },
+{ INT64_C(0xffffffdfe9ffffff), -0x1.00b0000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000004), 0x1.010000002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffffffb), -0x1.0100000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000006), 0x1.010000003p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffffff9), -0x1.0100000038p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000040), 0x1.01000002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffffbf), -0x1.0100000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000041), 0x1.0100000208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffffbe), -0x1.010000021p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000044), 0x1.010000022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffffbb), -0x1.0100000228p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000050), 0x1.010000028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffffaf), -0x1.0100000288p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000400), 0x1.0100002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffffbff), -0x1.0100002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000401), 0x1.0100002008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffffbfe), -0x1.010000201p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000410), 0x1.010000208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffffbef), -0x1.0100002088p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000440), 0x1.01000022p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffffbbf), -0x1.0100002208p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000800), 0x1.0100004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff7ff), -0x1.0100004008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000801), 0x1.0100004008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff7fe), -0x1.010000401p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000804), 0x1.010000402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff7fb), -0x1.0100004028p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000808), 0x1.010000404p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff7f7), -0x1.0100004048p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000820), 0x1.01000041p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff7df), -0x1.0100004108p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000880), 0x1.01000044p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff77f), -0x1.0100004408p+37, 0x0p+0 },
+{ INT64_C(0x0000002020000900), 0x1.01000048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffff6ff), -0x1.0100004808p+37, 0x0p+0 },
+{ INT64_C(0x0000002020004000), 0x1.010002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffbfff), -0x1.0100020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020004002), 0x1.010002001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffbffd), -0x1.0100020018p+37, 0x0p+0 },
+{ INT64_C(0x0000002020004010), 0x1.010002008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffbfef), -0x1.0100020088p+37, 0x0p+0 },
+{ INT64_C(0x0000002020004020), 0x1.01000201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffbfdf), -0x1.0100020108p+37, 0x0p+0 },
+{ INT64_C(0x0000002020004100), 0x1.01000208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffbeff), -0x1.0100020808p+37, 0x0p+0 },
+{ INT64_C(0x0000002020005000), 0x1.0100028p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfffafff), -0x1.0100028008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020008000), 0x1.010004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfff7fff), -0x1.0100040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020008008), 0x1.010004004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfff7ff7), -0x1.0100040048p+37, 0x0p+0 },
+{ INT64_C(0x0000002020008040), 0x1.01000402p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfff7fbf), -0x1.0100040208p+37, 0x0p+0 },
+{ INT64_C(0x0000002020008400), 0x1.0100042p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfff7bff), -0x1.0100042008p+37, 0x0p+0 },
+{ INT64_C(0x000000202000a000), 0x1.010005p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfff5fff), -0x1.0100050008p+37, 0x0p+0 },
+{ INT64_C(0x000000202000c000), 0x1.010006p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfff3fff), -0x1.0100060008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020020000), 0x1.01001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffdffff), -0x1.0100100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020020004), 0x1.010010002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffdfffb), -0x1.0100100028p+37, 0x0p+0 },
+{ INT64_C(0x0000002020020020), 0x1.01001001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffdffdf), -0x1.0100100108p+37, 0x0p+0 },
+{ INT64_C(0x0000002020020200), 0x1.0100101p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffdfdff), -0x1.0100101008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020022000), 0x1.010011p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffddfff), -0x1.0100110008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020024000), 0x1.010012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffdbfff), -0x1.0100120008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020040000), 0x1.01002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbffff), -0x1.0100200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020040008), 0x1.010020004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbfff7), -0x1.0100200048p+37, 0x0p+0 },
+{ INT64_C(0x0000002020040020), 0x1.01002001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbffdf), -0x1.0100200108p+37, 0x0p+0 },
+{ INT64_C(0x0000002020040080), 0x1.01002004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbff7f), -0x1.0100200408p+37, 0x0p+0 },
+{ INT64_C(0x0000002020040400), 0x1.0100202p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbfbff), -0x1.0100202008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020040800), 0x1.0100204p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbf7ff), -0x1.0100204008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020041000), 0x1.0100208p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffbefff), -0x1.0100208008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020048000), 0x1.010024p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdffb7fff), -0x1.0100240008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020060000), 0x1.01003p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdff9ffff), -0x1.0100300008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020100000), 0x1.01008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfefffff), -0x1.0100800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020100002), 0x1.010080001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfeffffd), -0x1.0100800018p+37, 0x0p+0 },
+{ INT64_C(0x0000002020100008), 0x1.010080004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfeffff7), -0x1.0100800048p+37, 0x0p+0 },
+{ INT64_C(0x0000002020100080), 0x1.01008004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfefff7f), -0x1.0100800408p+37, 0x0p+0 },
+{ INT64_C(0x0000002020100100), 0x1.01008008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfeffeff), -0x1.0100800808p+37, 0x0p+0 },
+{ INT64_C(0x0000002020100200), 0x1.0100801p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfeffdff), -0x1.0100801008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020101000), 0x1.0100808p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfefefff), -0x1.0100808008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020102000), 0x1.010081p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfefdfff), -0x1.0100810008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020108000), 0x1.010084p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfef7fff), -0x1.0100840008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020140000), 0x1.0100ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdfebffff), -0x1.0100a00008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020800000), 0x1.0104p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7fffff), -0x1.0104000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020800001), 0x1.0104000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7ffffe), -0x1.010400001p+37, 0x0p+0 },
+{ INT64_C(0x0000002020800004), 0x1.010400002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7ffffb), -0x1.0104000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002020800040), 0x1.01040002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7fffbf), -0x1.0104000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002020800080), 0x1.01040004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7fff7f), -0x1.0104000408p+37, 0x0p+0 },
+{ INT64_C(0x0000002020800400), 0x1.0104002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7ffbff), -0x1.0104002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020802000), 0x1.010401p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7fdfff), -0x1.0104010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020808000), 0x1.010404p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7f7fff), -0x1.0104040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020810000), 0x1.010408p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf7effff), -0x1.0104080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002020900000), 0x1.01048p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdf6fffff), -0x1.0104800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002021000000), 0x1.0108p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdeffffff), -0x1.0108000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002021000001), 0x1.0108000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdefffffe), -0x1.010800001p+37, 0x0p+0 },
+{ INT64_C(0x0000002021000004), 0x1.010800002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdefffffb), -0x1.0108000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002021000020), 0x1.01080001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdeffffdf), -0x1.0108000108p+37, 0x0p+0 },
+{ INT64_C(0x0000002021000040), 0x1.01080002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdeffffbf), -0x1.0108000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002021000400), 0x1.0108002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdefffbff), -0x1.0108002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002021001000), 0x1.0108008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdeffefff), -0x1.0108008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002021010000), 0x1.010808p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdefeffff), -0x1.0108080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002021100000), 0x1.01088p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdeefffff), -0x1.0108800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002021400000), 0x1.010ap+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdebfffff), -0x1.010a000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002024000000), 0x1.012p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbffffff), -0x1.0120000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002024000001), 0x1.0120000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbfffffe), -0x1.012000001p+37, 0x0p+0 },
+{ INT64_C(0x0000002024000002), 0x1.012000001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbfffffd), -0x1.0120000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002024000008), 0x1.012000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbfffff7), -0x1.0120000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002024000080), 0x1.01200004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbffff7f), -0x1.0120000408p+37, 0x0p+0 },
+{ INT64_C(0x0000002024000200), 0x1.0120001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbfffdff), -0x1.0120001008p+37, 0x0p+0 },
+{ INT64_C(0x0000002024002000), 0x1.012001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbffdfff), -0x1.0120010008p+37, 0x0p+0 },
+{ INT64_C(0x0000002024020000), 0x1.01201p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbfdffff), -0x1.0120100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002024200000), 0x1.0121p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbdfffff), -0x1.0121000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002024400000), 0x1.0122p+37, 0x0p+0 },
+{ INT64_C(0xffffffdfdbbfffff), -0x1.0122000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000008), 0x1.100000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffffff7), -0x1.1000000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000009), 0x1.1000000048p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffffff6), -0x1.100000005p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000010), 0x1.100000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffffffef), -0x1.1000000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000012), 0x1.100000009p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffffffed), -0x1.1000000098p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000014), 0x1.10000000ap+37, 0x0p+0 },
+{ INT64_C(0xffffffddffffffeb), -0x1.10000000a8p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000040), 0x1.10000002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffffffbf), -0x1.1000000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000048), 0x1.100000024p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffffffb7), -0x1.1000000248p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000060), 0x1.10000003p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffffff9f), -0x1.1000000308p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000100), 0x1.10000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffffeff), -0x1.1000000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000101), 0x1.1000000808p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffffefe), -0x1.100000081p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000104), 0x1.100000082p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffffefb), -0x1.1000000828p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000140), 0x1.1000000ap+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffffebf), -0x1.1000000a08p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000800), 0x1.1000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffff7ff), -0x1.1000004008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000802), 0x1.100000401p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffff7fd), -0x1.1000004018p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000820), 0x1.10000041p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffff7df), -0x1.1000004108p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000840), 0x1.10000042p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffff7bf), -0x1.1000004208p+37, 0x0p+0 },
+{ INT64_C(0x0000002200000c00), 0x1.1000006p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffff3ff), -0x1.1000006008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200008000), 0x1.100004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff7fff), -0x1.1000040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200008001), 0x1.1000040008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff7ffe), -0x1.100004001p+37, 0x0p+0 },
+{ INT64_C(0x0000002200008008), 0x1.100004004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff7ff7), -0x1.1000040048p+37, 0x0p+0 },
+{ INT64_C(0x0000002200008010), 0x1.100004008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff7fef), -0x1.1000040088p+37, 0x0p+0 },
+{ INT64_C(0x0000002200008100), 0x1.10000408p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff7eff), -0x1.1000040808p+37, 0x0p+0 },
+{ INT64_C(0x0000002200008800), 0x1.1000044p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff77ff), -0x1.1000044008p+37, 0x0p+0 },
+{ INT64_C(0x000000220000c000), 0x1.100006p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffff3fff), -0x1.1000060008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200040000), 0x1.10002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffbffff), -0x1.1000200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200040008), 0x1.100020004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffbfff7), -0x1.1000200048p+37, 0x0p+0 },
+{ INT64_C(0x0000002200040080), 0x1.10002004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffbff7f), -0x1.1000200408p+37, 0x0p+0 },
+{ INT64_C(0x0000002200040200), 0x1.1000201p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffbfdff), -0x1.1000201008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200041000), 0x1.1000208p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffbefff), -0x1.1000208008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200050000), 0x1.100028p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfffaffff), -0x1.1000280008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200060000), 0x1.10003p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfff9ffff), -0x1.1000300008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200100000), 0x1.10008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffefffff), -0x1.1000800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200100004), 0x1.100080002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffeffffb), -0x1.1000800028p+37, 0x0p+0 },
+{ INT64_C(0x0000002200100020), 0x1.10008001p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffefffdf), -0x1.1000800108p+37, 0x0p+0 },
+{ INT64_C(0x0000002200100080), 0x1.10008004p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffefff7f), -0x1.1000800408p+37, 0x0p+0 },
+{ INT64_C(0x0000002200100200), 0x1.1000801p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffeffdff), -0x1.1000801008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200102000), 0x1.100081p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffefdfff), -0x1.1000810008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200104000), 0x1.100082p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffefbfff), -0x1.1000820008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200120000), 0x1.10009p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffedffff), -0x1.1000900008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400000), 0x1.1002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbfffff), -0x1.1002000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400001), 0x1.1002000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbffffe), -0x1.100200001p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400002), 0x1.100200001p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbffffd), -0x1.1002000018p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400010), 0x1.100200008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbfffef), -0x1.1002000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400020), 0x1.10020001p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbfffdf), -0x1.1002000108p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400100), 0x1.10020008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbffeff), -0x1.1002000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002200400400), 0x1.1002002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbffbff), -0x1.1002002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200404000), 0x1.100202p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbfbfff), -0x1.1002020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200408000), 0x1.100204p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbf7fff), -0x1.1002040008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200410000), 0x1.100208p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffbeffff), -0x1.1002080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002200500000), 0x1.10028p+37, 0x0p+0 },
+{ INT64_C(0xffffffddffafffff), -0x1.1002800008p+37, 0x0p+0 },
+{ INT64_C(0x0000002204000000), 0x1.102p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbffffff), -0x1.1020000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002204000004), 0x1.102000002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbfffffb), -0x1.1020000028p+37, 0x0p+0 },
+{ INT64_C(0x0000002204000010), 0x1.102000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbffffef), -0x1.1020000088p+37, 0x0p+0 },
+{ INT64_C(0x0000002204000040), 0x1.10200002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbffffbf), -0x1.1020000208p+37, 0x0p+0 },
+{ INT64_C(0x0000002204000400), 0x1.1020002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbfffbff), -0x1.1020002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002204004000), 0x1.102002p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbffbfff), -0x1.1020020008p+37, 0x0p+0 },
+{ INT64_C(0x0000002204010000), 0x1.102008p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbfeffff), -0x1.1020080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002204080000), 0x1.10204p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfbf7ffff), -0x1.1020400008p+37, 0x0p+0 },
+{ INT64_C(0x0000002204800000), 0x1.1024p+37, 0x0p+0 },
+{ INT64_C(0xffffffddfb7fffff), -0x1.1024000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220000000), 0x1.11p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddfffffff), -0x1.1100000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220000008), 0x1.110000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffffff7), -0x1.1100000048p+37, 0x0p+0 },
+{ INT64_C(0x0000002220000080), 0x1.11000004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddfffff7f), -0x1.1100000408p+37, 0x0p+0 },
+{ INT64_C(0x0000002220000100), 0x1.11000008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffffeff), -0x1.1100000808p+37, 0x0p+0 },
+{ INT64_C(0x0000002220000400), 0x1.1100002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffffbff), -0x1.1100002008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220000800), 0x1.1100004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffff7ff), -0x1.1100004008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220001000), 0x1.1100008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddfffefff), -0x1.1100008008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220010000), 0x1.110008p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffeffff), -0x1.1100080008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220020000), 0x1.11001p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffdffff), -0x1.1100100008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220040000), 0x1.11002p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddffbffff), -0x1.1100200008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220080000), 0x1.11004p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddff7ffff), -0x1.1100400008p+37, 0x0p+0 },
+{ INT64_C(0x0000002220400000), 0x1.1102p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddfbfffff), -0x1.1102000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002224000000), 0x1.112p+37, 0x0p+0 },
+{ INT64_C(0xffffffdddbffffff), -0x1.1120000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002228000000), 0x1.114p+37, 0x0p+0 },
+{ INT64_C(0xffffffddd7ffffff), -0x1.1140000008p+37, 0x0p+0 },
+{ INT64_C(0x0000002230000000), 0x1.118p+37, 0x0p+0 },
+{ INT64_C(0xffffffddcfffffff), -0x1.1180000008p+37, 0x0p+0 },
+{ INT64_C(0x0000004000000005), 0x1.0000000014p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffffa), -0x1.0000000018p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000006), 0x1.0000000018p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffff9), -0x1.000000001cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000000021), 0x1.0000000084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffffde), -0x1.0000000088p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000022), 0x1.0000000088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffffdd), -0x1.000000008cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000000023), 0x1.000000008cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffffdc), -0x1.000000009p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000048), 0x1.000000012p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffffb7), -0x1.0000000124p+38, 0x0p+0 },
+{ INT64_C(0x000000400000004c), 0x1.000000013p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffffb3), -0x1.0000000134p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000084), 0x1.000000021p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffff7b), -0x1.0000000214p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000086), 0x1.0000000218p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffff79), -0x1.000000021cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000000090), 0x1.000000024p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffff6f), -0x1.0000000244p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000098), 0x1.000000026p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffffff67), -0x1.0000000264p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000108), 0x1.000000042p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffef7), -0x1.0000000424p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000109), 0x1.0000000424p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffef6), -0x1.0000000428p+38, 0x0p+0 },
+{ INT64_C(0x000000400000010a), 0x1.0000000428p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffef5), -0x1.000000042cp+38, 0x0p+0 },
+{ INT64_C(0x000000400000010c), 0x1.000000043p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffef3), -0x1.0000000434p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000120), 0x1.000000048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffedf), -0x1.0000000484p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000121), 0x1.0000000484p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffede), -0x1.0000000488p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000128), 0x1.00000004ap+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffed7), -0x1.00000004a4p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000130), 0x1.00000004cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffecf), -0x1.00000004c4p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000180), 0x1.00000006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffe7f), -0x1.0000000604p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000188), 0x1.000000062p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffffe77), -0x1.0000000624p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000808), 0x1.000000202p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7f7), -0x1.0000002024p+38, 0x0p+0 },
+{ INT64_C(0x000000400000080a), 0x1.0000002028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7f5), -0x1.000000202cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000000820), 0x1.000000208p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7df), -0x1.0000002084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000822), 0x1.0000002088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7dd), -0x1.000000208cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000000828), 0x1.00000020ap+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7d7), -0x1.00000020a4p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000830), 0x1.00000020cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7cf), -0x1.00000020c4p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000840), 0x1.00000021p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7bf), -0x1.0000002104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000844), 0x1.000000211p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff7bb), -0x1.0000002114p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000a00), 0x1.00000028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff5ff), -0x1.0000002804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000a02), 0x1.0000002808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff5fd), -0x1.000000280cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000000a04), 0x1.000000281p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff5fb), -0x1.0000002814p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000a40), 0x1.00000029p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff5bf), -0x1.0000002904p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000c00), 0x1.0000003p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff3ff), -0x1.0000003004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000c08), 0x1.000000302p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff3f7), -0x1.0000003024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000c20), 0x1.000000308p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff3df), -0x1.0000003084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000c40), 0x1.00000031p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff3bf), -0x1.0000003104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000000d00), 0x1.00000034p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffff2ff), -0x1.0000003404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008004), 0x1.000002001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7ffb), -0x1.0000020014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008006), 0x1.0000020018p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7ff9), -0x1.000002001cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000008040), 0x1.00000201p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7fbf), -0x1.0000020104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008048), 0x1.000002012p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7fb7), -0x1.0000020124p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008060), 0x1.000002018p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7f9f), -0x1.0000020184p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008100), 0x1.00000204p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7eff), -0x1.0000020404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008104), 0x1.000002041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7efb), -0x1.0000020414p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008110), 0x1.000002044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7eef), -0x1.0000020444p+38, 0x0p+0 },
+{ INT64_C(0x0000004000008120), 0x1.000002048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff7edf), -0x1.0000020484p+38, 0x0p+0 },
+{ INT64_C(0x0000004000009000), 0x1.0000024p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff6fff), -0x1.0000024004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000009002), 0x1.0000024008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff6ffd), -0x1.000002400cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000009020), 0x1.000002408p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff6fdf), -0x1.0000024084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000009080), 0x1.00000242p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff6f7f), -0x1.0000024204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000009200), 0x1.00000248p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff6dff), -0x1.0000024804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000009400), 0x1.0000025p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff6bff), -0x1.0000025004p+38, 0x0p+0 },
+{ INT64_C(0x000000400000c000), 0x1.000003p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff3fff), -0x1.0000030004p+38, 0x0p+0 },
+{ INT64_C(0x000000400000c004), 0x1.000003001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff3ffb), -0x1.0000030014p+38, 0x0p+0 },
+{ INT64_C(0x000000400000c020), 0x1.000003008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff3fdf), -0x1.0000030084p+38, 0x0p+0 },
+{ INT64_C(0x000000400000c100), 0x1.00000304p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff3eff), -0x1.0000030404p+38, 0x0p+0 },
+{ INT64_C(0x000000400000c400), 0x1.0000031p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff3bff), -0x1.0000031004p+38, 0x0p+0 },
+{ INT64_C(0x000000400000d000), 0x1.0000034p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffff2fff), -0x1.0000034004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010004), 0x1.000004001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefffb), -0x1.0000040014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010005), 0x1.0000040014p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefffa), -0x1.0000040018p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010006), 0x1.0000040018p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefff9), -0x1.000004001cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000010010), 0x1.000004004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffeffef), -0x1.0000040044p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010018), 0x1.000004006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffeffe7), -0x1.0000040064p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010100), 0x1.00000404p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefeff), -0x1.0000040404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010108), 0x1.000004042p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefef7), -0x1.0000040424p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010110), 0x1.000004044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefeef), -0x1.0000040444p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010400), 0x1.0000041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefbff), -0x1.0000041004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010404), 0x1.000004101p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefbfb), -0x1.0000041014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010410), 0x1.000004104p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefbef), -0x1.0000041044p+38, 0x0p+0 },
+{ INT64_C(0x0000004000010480), 0x1.00000412p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffefb7f), -0x1.0000041204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000012000), 0x1.0000048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffedfff), -0x1.0000048004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000012004), 0x1.000004801p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffedffb), -0x1.0000048014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000012040), 0x1.00000481p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffedfbf), -0x1.0000048104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000012400), 0x1.0000049p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffedbff), -0x1.0000049004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000014000), 0x1.000005p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffebfff), -0x1.0000050004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000014002), 0x1.0000050008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffebffd), -0x1.000005000cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000014020), 0x1.000005008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffebfdf), -0x1.0000050084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000014040), 0x1.00000501p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffebfbf), -0x1.0000050104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000014100), 0x1.00000504p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffebeff), -0x1.0000050404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000015000), 0x1.0000054p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffeafff), -0x1.0000054004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000018000), 0x1.000006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffe7fff), -0x1.0000060004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000018001), 0x1.0000060004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffe7ffe), -0x1.0000060008p+38, 0x0p+0 },
+{ INT64_C(0x0000004000018010), 0x1.000006004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffe7fef), -0x1.0000060044p+38, 0x0p+0 },
+{ INT64_C(0x0000004000018080), 0x1.00000602p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffe7f7f), -0x1.0000060204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000018400), 0x1.0000061p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffe7bff), -0x1.0000061004p+38, 0x0p+0 },
+{ INT64_C(0x000000400001a000), 0x1.0000068p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffffe5fff), -0x1.0000068004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080008), 0x1.000020002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fff7), -0x1.0000200024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080009), 0x1.0000200024p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fff6), -0x1.0000200028p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080080), 0x1.00002002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7ff7f), -0x1.0000200204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080088), 0x1.000020022p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7ff77), -0x1.0000200224p+38, 0x0p+0 },
+{ INT64_C(0x00000040000800a0), 0x1.000020028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7ff5f), -0x1.0000200284p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080100), 0x1.00002004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7feff), -0x1.0000200404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080104), 0x1.000020041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fefb), -0x1.0000200414p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080110), 0x1.000020044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7feef), -0x1.0000200444p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080120), 0x1.000020048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fedf), -0x1.0000200484p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080200), 0x1.00002008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fdff), -0x1.0000200804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080201), 0x1.0000200804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fdfe), -0x1.0000200808p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080202), 0x1.0000200808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fdfd), -0x1.000020080cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000080220), 0x1.000020088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7fddf), -0x1.0000200884p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080800), 0x1.0000202p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7f7ff), -0x1.0000202004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080808), 0x1.000020202p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7f7f7), -0x1.0000202024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080840), 0x1.00002021p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7f7bf), -0x1.0000202104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080880), 0x1.00002022p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7f77f), -0x1.0000202204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000080900), 0x1.00002024p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7f6ff), -0x1.0000202404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000081000), 0x1.0000204p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7efff), -0x1.0000204004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000081008), 0x1.000020402p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7eff7), -0x1.0000204024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000081080), 0x1.00002042p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7ef7f), -0x1.0000204204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000081200), 0x1.00002048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7edff), -0x1.0000204804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000084000), 0x1.000021p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7bfff), -0x1.0000210004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000084008), 0x1.000021002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7bff7), -0x1.0000210024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000084040), 0x1.00002101p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7bfbf), -0x1.0000210104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000084400), 0x1.0000211p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff7bbff), -0x1.0000211004p+38, 0x0p+0 },
+{ INT64_C(0x00000040000a0000), 0x1.000028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff5ffff), -0x1.0000280004p+38, 0x0p+0 },
+{ INT64_C(0x00000040000a0004), 0x1.000028001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff5fffb), -0x1.0000280014p+38, 0x0p+0 },
+{ INT64_C(0x00000040000a0010), 0x1.000028004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff5ffef), -0x1.0000280044p+38, 0x0p+0 },
+{ INT64_C(0x00000040000a0080), 0x1.00002802p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff5ff7f), -0x1.0000280204p+38, 0x0p+0 },
+{ INT64_C(0x00000040000a0800), 0x1.0000282p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff5f7ff), -0x1.0000282004p+38, 0x0p+0 },
+{ INT64_C(0x00000040000a8000), 0x1.00002ap+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff57fff), -0x1.00002a0004p+38, 0x0p+0 },
+{ INT64_C(0x00000040000b0000), 0x1.00002cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbffff4ffff), -0x1.00002c0004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200001), 0x1.0000800004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffffe), -0x1.0000800008p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200004), 0x1.000080001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffffb), -0x1.0000800014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200006), 0x1.0000800018p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffff9), -0x1.000080001cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000200020), 0x1.000080008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfffdf), -0x1.0000800084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200024), 0x1.000080009p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfffdb), -0x1.0000800094p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200200), 0x1.00008008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffdff), -0x1.0000800804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200202), 0x1.0000800808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffdfd), -0x1.000080080cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000200204), 0x1.000080081p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffdfb), -0x1.0000800814p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200220), 0x1.000080088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffddf), -0x1.0000800884p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200400), 0x1.0000801p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffbff), -0x1.0000801004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200401), 0x1.0000801004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffbfe), -0x1.0000801008p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200404), 0x1.000080101p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffbfb), -0x1.0000801014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200420), 0x1.000080108p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffbdf), -0x1.0000801084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000200480), 0x1.00008012p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdffb7f), -0x1.0000801204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000201000), 0x1.0000804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfefff), -0x1.0000804004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000201004), 0x1.000080401p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfeffb), -0x1.0000804014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000201040), 0x1.00008041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfefbf), -0x1.0000804104p+38, 0x0p+0 },
+{ INT64_C(0x0000004000201200), 0x1.00008048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfedff), -0x1.0000804804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000202000), 0x1.0000808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfdfff), -0x1.0000808004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000202002), 0x1.0000808008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfdffd), -0x1.000080800cp+38, 0x0p+0 },
+{ INT64_C(0x0000004000202020), 0x1.000080808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfdfdf), -0x1.0000808084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000202100), 0x1.00008084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfdeff), -0x1.0000808404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000203000), 0x1.000080cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdfcfff), -0x1.000080c004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000210000), 0x1.000084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdeffff), -0x1.0000840004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000210008), 0x1.000084002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdefff7), -0x1.0000840024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000210080), 0x1.00008402p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdeff7f), -0x1.0000840204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000210200), 0x1.00008408p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdefdff), -0x1.0000840804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000210400), 0x1.0000841p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdefbff), -0x1.0000841004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000211000), 0x1.0000844p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdeefff), -0x1.0000844004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000212000), 0x1.0000848p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdedfff), -0x1.0000848004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000218000), 0x1.000086p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffde7fff), -0x1.0000860004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000220000), 0x1.000088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffddffff), -0x1.0000880004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000220008), 0x1.000088002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffddfff7), -0x1.0000880024p+38, 0x0p+0 },
+{ INT64_C(0x0000004000220020), 0x1.000088008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffddffdf), -0x1.0000880084p+38, 0x0p+0 },
+{ INT64_C(0x0000004000220100), 0x1.00008804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffddfeff), -0x1.0000880404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000220200), 0x1.00008808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffddfdff), -0x1.0000880804p+38, 0x0p+0 },
+{ INT64_C(0x0000004000220400), 0x1.0000881p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffddfbff), -0x1.0000881004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000222000), 0x1.0000888p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdddfff), -0x1.0000888004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000230000), 0x1.00008cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffdcffff), -0x1.00008c0004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300000), 0x1.0000cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcfffff), -0x1.0000c00004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300004), 0x1.0000c0001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcffffb), -0x1.0000c00014p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300010), 0x1.0000c0004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcfffef), -0x1.0000c00044p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300080), 0x1.0000c002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcfff7f), -0x1.0000c00204p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300100), 0x1.0000c004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcffeff), -0x1.0000c00404p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300400), 0x1.0000c01p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcffbff), -0x1.0000c01004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000300800), 0x1.0000c02p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcff7ff), -0x1.0000c02004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000301000), 0x1.0000c04p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcfefff), -0x1.0000c04004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000310000), 0x1.0000c4p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffceffff), -0x1.0000c40004p+38, 0x0p+0 },
+{ INT64_C(0x0000004000340000), 0x1.0000dp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfffcbffff), -0x1.0000d00004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000001), 0x1.0008000004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffffe), -0x1.0008000008p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000010), 0x1.000800004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffffef), -0x1.0008000044p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000014), 0x1.000800005p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffffeb), -0x1.0008000054p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000100), 0x1.00080004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffeff), -0x1.0008000404p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000108), 0x1.000800042p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffef7), -0x1.0008000424p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000110), 0x1.000800044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffeef), -0x1.0008000444p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000200), 0x1.00080008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffdff), -0x1.0008000804p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000208), 0x1.000800082p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffdf7), -0x1.0008000824p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000210), 0x1.000800084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffdef), -0x1.0008000844p+38, 0x0p+0 },
+{ INT64_C(0x0000004002000240), 0x1.00080009p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfffdbf), -0x1.0008000904p+38, 0x0p+0 },
+{ INT64_C(0x0000004002001000), 0x1.0008004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffefff), -0x1.0008004004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002001008), 0x1.000800402p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffeff7), -0x1.0008004024p+38, 0x0p+0 },
+{ INT64_C(0x0000004002001010), 0x1.000800404p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffefef), -0x1.0008004044p+38, 0x0p+0 },
+{ INT64_C(0x0000004002001100), 0x1.00080044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffeeff), -0x1.0008004404p+38, 0x0p+0 },
+{ INT64_C(0x0000004002001800), 0x1.0008006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdffe7ff), -0x1.0008006004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002010000), 0x1.000804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfeffff), -0x1.0008040004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002010001), 0x1.0008040004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfefffe), -0x1.0008040008p+38, 0x0p+0 },
+{ INT64_C(0x0000004002010008), 0x1.000804002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfefff7), -0x1.0008040024p+38, 0x0p+0 },
+{ INT64_C(0x0000004002010010), 0x1.000804004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfeffef), -0x1.0008040044p+38, 0x0p+0 },
+{ INT64_C(0x0000004002010040), 0x1.00080401p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfeffbf), -0x1.0008040104p+38, 0x0p+0 },
+{ INT64_C(0x0000004002010200), 0x1.00080408p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfefdff), -0x1.0008040804p+38, 0x0p+0 },
+{ INT64_C(0x0000004002011000), 0x1.0008044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfeefff), -0x1.0008044004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002018000), 0x1.000806p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdfe7fff), -0x1.0008060004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002100000), 0x1.00084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdefffff), -0x1.0008400004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002100004), 0x1.000840001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdeffffb), -0x1.0008400014p+38, 0x0p+0 },
+{ INT64_C(0x0000004002100040), 0x1.00084001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdefffbf), -0x1.0008400104p+38, 0x0p+0 },
+{ INT64_C(0x0000004002100200), 0x1.00084008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdeffdff), -0x1.0008400804p+38, 0x0p+0 },
+{ INT64_C(0x0000004002102000), 0x1.0008408p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdefdfff), -0x1.0008408004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002104000), 0x1.000841p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdefbfff), -0x1.0008410004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002108000), 0x1.000842p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdef7fff), -0x1.0008420004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002120000), 0x1.000848p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdedffff), -0x1.0008480004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002200000), 0x1.00088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddfffff), -0x1.0008800004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002200001), 0x1.0008800004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddffffe), -0x1.0008800008p+38, 0x0p+0 },
+{ INT64_C(0x0000004002200004), 0x1.000880001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddffffb), -0x1.0008800014p+38, 0x0p+0 },
+{ INT64_C(0x0000004002200010), 0x1.000880004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddfffef), -0x1.0008800044p+38, 0x0p+0 },
+{ INT64_C(0x0000004002200100), 0x1.00088004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddffeff), -0x1.0008800404p+38, 0x0p+0 },
+{ INT64_C(0x0000004002201000), 0x1.0008804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddfefff), -0x1.0008804004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002202000), 0x1.0008808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddfdfff), -0x1.0008808004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002204000), 0x1.000881p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddfbfff), -0x1.0008810004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002208000), 0x1.000882p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddf7fff), -0x1.0008820004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002240000), 0x1.00089p+38, 0x0p+0 },
+{ INT64_C(0xffffffbffddbffff), -0x1.0008900004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002280000), 0x1.0008ap+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdd7ffff), -0x1.0008a00004p+38, 0x0p+0 },
+{ INT64_C(0x0000004002300000), 0x1.0008cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbffdcfffff), -0x1.0008c00004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000008), 0x1.008000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffffff7), -0x1.0080000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000040), 0x1.00800001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffffbf), -0x1.0080000104p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000041), 0x1.0080000104p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffffbe), -0x1.0080000108p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000048), 0x1.008000012p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffffb7), -0x1.0080000124p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000080), 0x1.00800002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffff7f), -0x1.0080000204p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000084), 0x1.008000021p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffff7b), -0x1.0080000214p+38, 0x0p+0 },
+{ INT64_C(0x00000040200000a0), 0x1.008000028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffff5f), -0x1.0080000284p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000200), 0x1.00800008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffffdff), -0x1.0080000804p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000202), 0x1.0080000808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffffdfd), -0x1.008000080cp+38, 0x0p+0 },
+{ INT64_C(0x0000004020000210), 0x1.008000084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffffdef), -0x1.0080000844p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000220), 0x1.008000088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffffddf), -0x1.0080000884p+38, 0x0p+0 },
+{ INT64_C(0x0000004020000300), 0x1.0080000cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffffcff), -0x1.0080000c04p+38, 0x0p+0 },
+{ INT64_C(0x0000004020001000), 0x1.0080004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffefff), -0x1.0080004004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020001004), 0x1.008000401p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffeffb), -0x1.0080004014p+38, 0x0p+0 },
+{ INT64_C(0x0000004020001010), 0x1.008000404p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffefef), -0x1.0080004044p+38, 0x0p+0 },
+{ INT64_C(0x0000004020001040), 0x1.00800041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffefbf), -0x1.0080004104p+38, 0x0p+0 },
+{ INT64_C(0x0000004020001400), 0x1.0080005p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffebff), -0x1.0080005004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020002000), 0x1.0080008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdfff), -0x1.0080008004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020002001), 0x1.0080008004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdffe), -0x1.0080008008p+38, 0x0p+0 },
+{ INT64_C(0x0000004020002002), 0x1.0080008008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdffd), -0x1.008000800cp+38, 0x0p+0 },
+{ INT64_C(0x0000004020002004), 0x1.008000801p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdffb), -0x1.0080008014p+38, 0x0p+0 },
+{ INT64_C(0x0000004020002008), 0x1.008000802p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdff7), -0x1.0080008024p+38, 0x0p+0 },
+{ INT64_C(0x0000004020002040), 0x1.00800081p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdfbf), -0x1.0080008104p+38, 0x0p+0 },
+{ INT64_C(0x0000004020002400), 0x1.0080009p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfffdbff), -0x1.0080009004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020000), 0x1.008008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdffff), -0x1.0080080004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020008), 0x1.008008002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdfff7), -0x1.0080080024p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020010), 0x1.008008004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdffef), -0x1.0080080044p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020080), 0x1.00800802p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdff7f), -0x1.0080080204p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020100), 0x1.00800804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdfeff), -0x1.0080080404p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020400), 0x1.0080081p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdfbff), -0x1.0080081004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020020800), 0x1.0080082p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdf7ff), -0x1.0080082004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020024000), 0x1.008009p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffdbfff), -0x1.0080090004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020030000), 0x1.00800cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdffcffff), -0x1.00800c0004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020200000), 0x1.00808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdfffff), -0x1.0080800004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020200008), 0x1.008080002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdffff7), -0x1.0080800024p+38, 0x0p+0 },
+{ INT64_C(0x0000004020200010), 0x1.008080004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdfffef), -0x1.0080800044p+38, 0x0p+0 },
+{ INT64_C(0x0000004020200080), 0x1.00808002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdfff7f), -0x1.0080800204p+38, 0x0p+0 },
+{ INT64_C(0x0000004020200400), 0x1.0080801p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdffbff), -0x1.0080801004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020201000), 0x1.0080804p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdfefff), -0x1.0080804004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020202000), 0x1.0080808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdfdfff), -0x1.0080808004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020210000), 0x1.008084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdeffff), -0x1.0080840004p+38, 0x0p+0 },
+{ INT64_C(0x0000004020240000), 0x1.00809p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdfdbffff), -0x1.0080900004p+38, 0x0p+0 },
+{ INT64_C(0x0000004022000000), 0x1.0088p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddffffff), -0x1.0088000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004022000004), 0x1.008800001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddfffffb), -0x1.0088000014p+38, 0x0p+0 },
+{ INT64_C(0x0000004022000008), 0x1.008800002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddfffff7), -0x1.0088000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004022000020), 0x1.008800008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddffffdf), -0x1.0088000084p+38, 0x0p+0 },
+{ INT64_C(0x0000004022000080), 0x1.00880002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddffff7f), -0x1.0088000204p+38, 0x0p+0 },
+{ INT64_C(0x0000004022000800), 0x1.0088002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddfff7ff), -0x1.0088002004p+38, 0x0p+0 },
+{ INT64_C(0x0000004022002000), 0x1.0088008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddffdfff), -0x1.0088008004p+38, 0x0p+0 },
+{ INT64_C(0x0000004022020000), 0x1.008808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfddfdffff), -0x1.0088080004p+38, 0x0p+0 },
+{ INT64_C(0x0000004022200000), 0x1.00888p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdddfffff), -0x1.0088800004p+38, 0x0p+0 },
+{ INT64_C(0x0000004023000000), 0x1.008cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdcffffff), -0x1.008c000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024000000), 0x1.009p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbffffff), -0x1.0090000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024000002), 0x1.0090000008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbfffffd), -0x1.009000000cp+38, 0x0p+0 },
+{ INT64_C(0x0000004024000008), 0x1.009000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbfffff7), -0x1.0090000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004024000020), 0x1.009000008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbffffdf), -0x1.0090000084p+38, 0x0p+0 },
+{ INT64_C(0x0000004024000200), 0x1.00900008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbfffdff), -0x1.0090000804p+38, 0x0p+0 },
+{ INT64_C(0x0000004024000800), 0x1.0090002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbfff7ff), -0x1.0090002004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024001000), 0x1.0090004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbffefff), -0x1.0090004004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024004000), 0x1.009001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbffbfff), -0x1.0090010004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024020000), 0x1.009008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbfdffff), -0x1.0090080004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024100000), 0x1.00904p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdbefffff), -0x1.0090400004p+38, 0x0p+0 },
+{ INT64_C(0x0000004024800000), 0x1.0092p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdb7fffff), -0x1.0092000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004025000000), 0x1.0094p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfdaffffff), -0x1.0094000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004026000000), 0x1.0098p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd9ffffff), -0x1.0098000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004028000000), 0x1.00ap+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7ffffff), -0x1.00a0000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004028000001), 0x1.00a0000004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7fffffe), -0x1.00a0000008p+38, 0x0p+0 },
+{ INT64_C(0x0000004028000008), 0x1.00a000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7fffff7), -0x1.00a0000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004028000040), 0x1.00a00001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7ffffbf), -0x1.00a0000104p+38, 0x0p+0 },
+{ INT64_C(0x0000004028000200), 0x1.00a00008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7fffdff), -0x1.00a0000804p+38, 0x0p+0 },
+{ INT64_C(0x0000004028002000), 0x1.00a0008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7ffdfff), -0x1.00a0008004p+38, 0x0p+0 },
+{ INT64_C(0x0000004028010000), 0x1.00a004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7feffff), -0x1.00a0040004p+38, 0x0p+0 },
+{ INT64_C(0x0000004028080000), 0x1.00a02p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd7f7ffff), -0x1.00a0200004p+38, 0x0p+0 },
+{ INT64_C(0x0000004028800000), 0x1.00a2p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd77fffff), -0x1.00a2000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004029000000), 0x1.00a4p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd6ffffff), -0x1.00a4000004p+38, 0x0p+0 },
+{ INT64_C(0x000000402a000000), 0x1.00a8p+38, 0x0p+0 },
+{ INT64_C(0xffffffbfd5ffffff), -0x1.00a8000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000008), 0x1.080000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffffff7), -0x1.0800000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000080), 0x1.08000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffff7f), -0x1.0800000204p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000081), 0x1.0800000204p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffff7e), -0x1.0800000208p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000084), 0x1.080000021p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffff7b), -0x1.0800000214p+38, 0x0p+0 },
+{ INT64_C(0x00000042000000a0), 0x1.080000028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffff5f), -0x1.0800000284p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000100), 0x1.08000004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffffeff), -0x1.0800000404p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000104), 0x1.080000041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffffefb), -0x1.0800000414p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000110), 0x1.080000044p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffffeef), -0x1.0800000444p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000180), 0x1.08000006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffffe7f), -0x1.0800000604p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000800), 0x1.0800002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffff7ff), -0x1.0800002004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000801), 0x1.0800002004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffff7fe), -0x1.0800002008p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000808), 0x1.080000202p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffff7f7), -0x1.0800002024p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000820), 0x1.080000208p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffff7df), -0x1.0800002084p+38, 0x0p+0 },
+{ INT64_C(0x0000004200000880), 0x1.08000022p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffff77f), -0x1.0800002204p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001000), 0x1.0800004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffefff), -0x1.0800004004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001001), 0x1.0800004004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffeffe), -0x1.0800004008p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001002), 0x1.0800004008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffeffd), -0x1.080000400cp+38, 0x0p+0 },
+{ INT64_C(0x0000004200001008), 0x1.080000402p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffeff7), -0x1.0800004024p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001040), 0x1.08000041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffefbf), -0x1.0800004104p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001080), 0x1.08000042p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffef7f), -0x1.0800004204p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001400), 0x1.0800005p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffebff), -0x1.0800005004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200001800), 0x1.0800006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffe7ff), -0x1.0800006004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200004000), 0x1.080001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffbfff), -0x1.0800010004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200004004), 0x1.080001001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffbffb), -0x1.0800010014p+38, 0x0p+0 },
+{ INT64_C(0x0000004200004040), 0x1.08000101p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffbfbf), -0x1.0800010104p+38, 0x0p+0 },
+{ INT64_C(0x0000004200004100), 0x1.08000104p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffbeff), -0x1.0800010404p+38, 0x0p+0 },
+{ INT64_C(0x0000004200004800), 0x1.0800012p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffb7ff), -0x1.0800012004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200005000), 0x1.0800014p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffffafff), -0x1.0800014004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200008000), 0x1.080002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff7fff), -0x1.0800020004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200008008), 0x1.080002002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff7ff7), -0x1.0800020024p+38, 0x0p+0 },
+{ INT64_C(0x0000004200008020), 0x1.080002008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff7fdf), -0x1.0800020084p+38, 0x0p+0 },
+{ INT64_C(0x0000004200008100), 0x1.08000204p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff7eff), -0x1.0800020404p+38, 0x0p+0 },
+{ INT64_C(0x0000004200008200), 0x1.08000208p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff7dff), -0x1.0800020804p+38, 0x0p+0 },
+{ INT64_C(0x0000004200008800), 0x1.0800022p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff77ff), -0x1.0800022004p+38, 0x0p+0 },
+{ INT64_C(0x000000420000c000), 0x1.080003p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffff3fff), -0x1.0800030004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200010000), 0x1.080004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffeffff), -0x1.0800040004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200010001), 0x1.0800040004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffefffe), -0x1.0800040008p+38, 0x0p+0 },
+{ INT64_C(0x0000004200010002), 0x1.0800040008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffefffd), -0x1.080004000cp+38, 0x0p+0 },
+{ INT64_C(0x0000004200010020), 0x1.080004008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffeffdf), -0x1.0800040084p+38, 0x0p+0 },
+{ INT64_C(0x0000004200010200), 0x1.08000408p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffefdff), -0x1.0800040804p+38, 0x0p+0 },
+{ INT64_C(0x0000004200012000), 0x1.0800048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffedfff), -0x1.0800048004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200018000), 0x1.080006p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfffe7fff), -0x1.0800060004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200100000), 0x1.08004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffefffff), -0x1.0800400004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200100001), 0x1.0800400004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffeffffe), -0x1.0800400008p+38, 0x0p+0 },
+{ INT64_C(0x0000004200100002), 0x1.0800400008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffeffffd), -0x1.080040000cp+38, 0x0p+0 },
+{ INT64_C(0x0000004200100010), 0x1.080040004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffefffef), -0x1.0800400044p+38, 0x0p+0 },
+{ INT64_C(0x0000004200100040), 0x1.08004001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffefffbf), -0x1.0800400104p+38, 0x0p+0 },
+{ INT64_C(0x0000004200100080), 0x1.08004002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffefff7f), -0x1.0800400204p+38, 0x0p+0 },
+{ INT64_C(0x0000004200100800), 0x1.0800402p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffeff7ff), -0x1.0800402004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200104000), 0x1.080041p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffefbfff), -0x1.0800410004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200120000), 0x1.080048p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffedffff), -0x1.0800480004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200140000), 0x1.08005p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffebffff), -0x1.0800500004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200200000), 0x1.08008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdfffff), -0x1.0800800004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200200004), 0x1.080080001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdffffb), -0x1.0800800014p+38, 0x0p+0 },
+{ INT64_C(0x0000004200200040), 0x1.08008001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdfffbf), -0x1.0800800104p+38, 0x0p+0 },
+{ INT64_C(0x0000004200200080), 0x1.08008002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdfff7f), -0x1.0800800204p+38, 0x0p+0 },
+{ INT64_C(0x0000004200200200), 0x1.08008008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdffdff), -0x1.0800800804p+38, 0x0p+0 },
+{ INT64_C(0x0000004200202000), 0x1.0800808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdfdfff), -0x1.0800808004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200210000), 0x1.080084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdeffff), -0x1.0800840004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200240000), 0x1.08009p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffdbffff), -0x1.0800900004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200300000), 0x1.0800cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbdffcfffff), -0x1.0800c00004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200800000), 0x1.0802p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7fffff), -0x1.0802000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200800008), 0x1.080200002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7ffff7), -0x1.0802000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004200800080), 0x1.08020002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7fff7f), -0x1.0802000204p+38, 0x0p+0 },
+{ INT64_C(0x0000004200800100), 0x1.08020004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7ffeff), -0x1.0802000404p+38, 0x0p+0 },
+{ INT64_C(0x0000004200800800), 0x1.0802002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7ff7ff), -0x1.0802002004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200808000), 0x1.080202p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7f7fff), -0x1.0802020004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200810000), 0x1.080204p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7effff), -0x1.0802040004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200820000), 0x1.080208p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff7dffff), -0x1.0802080004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200880000), 0x1.08022p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff77ffff), -0x1.0802200004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200900000), 0x1.08024p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff6fffff), -0x1.0802400004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200a00000), 0x1.08028p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff5fffff), -0x1.0802800004p+38, 0x0p+0 },
+{ INT64_C(0x0000004200c00000), 0x1.0803p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdff3fffff), -0x1.0803000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202000000), 0x1.0808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdffffff), -0x1.0808000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202000004), 0x1.080800001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdfffffb), -0x1.0808000014p+38, 0x0p+0 },
+{ INT64_C(0x0000004202000010), 0x1.080800004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdffffef), -0x1.0808000044p+38, 0x0p+0 },
+{ INT64_C(0x0000004202000100), 0x1.08080004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdfffeff), -0x1.0808000404p+38, 0x0p+0 },
+{ INT64_C(0x0000004202000800), 0x1.0808002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdfff7ff), -0x1.0808002004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202001000), 0x1.0808004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdffefff), -0x1.0808004004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202002000), 0x1.0808008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdffdfff), -0x1.0808008004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202004000), 0x1.080801p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdffbfff), -0x1.0808010004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202020000), 0x1.080808p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdfdffff), -0x1.0808080004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202040000), 0x1.08081p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdfbffff), -0x1.0808100004p+38, 0x0p+0 },
+{ INT64_C(0x0000004202400000), 0x1.0809p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdfdbfffff), -0x1.0809000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004210000000), 0x1.084p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdefffffff), -0x1.0840000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004210000004), 0x1.084000001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdeffffffb), -0x1.0840000014p+38, 0x0p+0 },
+{ INT64_C(0x0000004210000020), 0x1.084000008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdefffffdf), -0x1.0840000084p+38, 0x0p+0 },
+{ INT64_C(0x0000004210000080), 0x1.08400002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdefffff7f), -0x1.0840000204p+38, 0x0p+0 },
+{ INT64_C(0x0000004210000800), 0x1.0840002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdeffff7ff), -0x1.0840002004p+38, 0x0p+0 },
+{ INT64_C(0x0000004210008000), 0x1.084002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdefff7fff), -0x1.0840020004p+38, 0x0p+0 },
+{ INT64_C(0x0000004210080000), 0x1.08402p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdeff7ffff), -0x1.0840200004p+38, 0x0p+0 },
+{ INT64_C(0x0000004210800000), 0x1.0842p+38, 0x0p+0 },
+{ INT64_C(0xffffffbdef7fffff), -0x1.0842000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004218000000), 0x1.086p+38, 0x0p+0 },
+{ INT64_C(0xffffffbde7ffffff), -0x1.0860000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300000000), 0x1.0cp+38, 0x0p+0 },
+{ INT64_C(0xffffffbcffffffff), -0x1.0c00000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300000008), 0x1.0c0000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcfffffff7), -0x1.0c00000024p+38, 0x0p+0 },
+{ INT64_C(0x0000004300000080), 0x1.0c000002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcffffff7f), -0x1.0c00000204p+38, 0x0p+0 },
+{ INT64_C(0x0000004300000200), 0x1.0c000008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcfffffdff), -0x1.0c00000804p+38, 0x0p+0 },
+{ INT64_C(0x0000004300002000), 0x1.0c00008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcffffdfff), -0x1.0c00008004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300008000), 0x1.0c0002p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcffff7fff), -0x1.0c00020004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300010000), 0x1.0c0004p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcfffeffff), -0x1.0c00040004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300040000), 0x1.0c001p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcfffbffff), -0x1.0c00100004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300200000), 0x1.0c008p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcffdfffff), -0x1.0c00800004p+38, 0x0p+0 },
+{ INT64_C(0x0000004300400000), 0x1.0c01p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcffbfffff), -0x1.0c01000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004301000000), 0x1.0c04p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcfeffffff), -0x1.0c04000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004308000000), 0x1.0c2p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcf7ffffff), -0x1.0c20000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004320000000), 0x1.0c8p+38, 0x0p+0 },
+{ INT64_C(0xffffffbcdfffffff), -0x1.0c80000004p+38, 0x0p+0 },
+{ INT64_C(0x0000004340000000), 0x1.0dp+38, 0x0p+0 },
+{ INT64_C(0xffffffbcbfffffff), -0x1.0d00000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000000008), 0x1.800000002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffffff7), -0x1.8000000024p+38, 0x0p+0 },
+{ INT64_C(0x000000600000000c), 0x1.800000003p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffffff3), -0x1.8000000034p+38, 0x0p+0 },
+{ INT64_C(0x0000006000000040), 0x1.80000001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffffbf), -0x1.8000000104p+38, 0x0p+0 },
+{ INT64_C(0x0000006000000044), 0x1.800000011p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffffbb), -0x1.8000000114p+38, 0x0p+0 },
+{ INT64_C(0x0000006000000060), 0x1.800000018p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffff9f), -0x1.8000000184p+38, 0x0p+0 },
+{ INT64_C(0x0000006000000100), 0x1.80000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffffeff), -0x1.8000000404p+38, 0x0p+0 },
+{ INT64_C(0x0000006000000102), 0x1.8000000408p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffffefd), -0x1.800000040cp+38, 0x0p+0 },
+{ INT64_C(0x0000006000000120), 0x1.800000048p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffffedf), -0x1.8000000484p+38, 0x0p+0 },
+{ INT64_C(0x0000006000001000), 0x1.8000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffefff), -0x1.8000004004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000001004), 0x1.800000401p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffeffb), -0x1.8000004014p+38, 0x0p+0 },
+{ INT64_C(0x0000006000001010), 0x1.800000404p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffefef), -0x1.8000004044p+38, 0x0p+0 },
+{ INT64_C(0x0000006000001080), 0x1.80000042p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffef7f), -0x1.8000004204p+38, 0x0p+0 },
+{ INT64_C(0x0000006000001200), 0x1.80000048p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffffedff), -0x1.8000004804p+38, 0x0p+0 },
+{ INT64_C(0x0000006000010000), 0x1.800004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffeffff), -0x1.8000040004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000010008), 0x1.800004002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffefff7), -0x1.8000040024p+38, 0x0p+0 },
+{ INT64_C(0x0000006000010010), 0x1.800004004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffeffef), -0x1.8000040044p+38, 0x0p+0 },
+{ INT64_C(0x0000006000010100), 0x1.80000404p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffefeff), -0x1.8000040404p+38, 0x0p+0 },
+{ INT64_C(0x0000006000010800), 0x1.8000042p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffef7ff), -0x1.8000042004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000011000), 0x1.8000044p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffeefff), -0x1.8000044004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000012000), 0x1.8000048p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffedfff), -0x1.8000048004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000020000), 0x1.800008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdffff), -0x1.8000080004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000020002), 0x1.8000080008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdfffd), -0x1.800008000cp+38, 0x0p+0 },
+{ INT64_C(0x0000006000020020), 0x1.800008008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdffdf), -0x1.8000080084p+38, 0x0p+0 },
+{ INT64_C(0x0000006000020080), 0x1.80000802p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdff7f), -0x1.8000080204p+38, 0x0p+0 },
+{ INT64_C(0x0000006000020200), 0x1.80000808p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdfdff), -0x1.8000080804p+38, 0x0p+0 },
+{ INT64_C(0x0000006000020400), 0x1.8000081p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdfbff), -0x1.8000081004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000022000), 0x1.8000088p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffddfff), -0x1.8000088004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000024000), 0x1.800009p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffdbfff), -0x1.8000090004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000030000), 0x1.80000cp+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffffcffff), -0x1.80000c0004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000200000), 0x1.80008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdfffff), -0x1.8000800004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000200004), 0x1.800080001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdffffb), -0x1.8000800014p+38, 0x0p+0 },
+{ INT64_C(0x0000006000200020), 0x1.800080008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdfffdf), -0x1.8000800084p+38, 0x0p+0 },
+{ INT64_C(0x0000006000200080), 0x1.80008002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdfff7f), -0x1.8000800204p+38, 0x0p+0 },
+{ INT64_C(0x0000006000200800), 0x1.8000802p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdff7ff), -0x1.8000802004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000202000), 0x1.8000808p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdfdfff), -0x1.8000808004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000210000), 0x1.800084p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdeffff), -0x1.8000840004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000220000), 0x1.800088p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffddffff), -0x1.8000880004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000240000), 0x1.80009p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffdbffff), -0x1.8000900004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000280000), 0x1.8000ap+38, 0x0p+0 },
+{ INT64_C(0xffffff9fffd7ffff), -0x1.8000a00004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000800000), 0x1.8002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7fffff), -0x1.8002000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000800004), 0x1.800200001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7ffffb), -0x1.8002000014p+38, 0x0p+0 },
+{ INT64_C(0x0000006000800010), 0x1.800200004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7fffef), -0x1.8002000044p+38, 0x0p+0 },
+{ INT64_C(0x0000006000800020), 0x1.800200008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7fffdf), -0x1.8002000084p+38, 0x0p+0 },
+{ INT64_C(0x0000006000800200), 0x1.80020008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7ffdff), -0x1.8002000804p+38, 0x0p+0 },
+{ INT64_C(0x0000006000802000), 0x1.8002008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7fdfff), -0x1.8002008004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000804000), 0x1.800201p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7fbfff), -0x1.8002010004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000810000), 0x1.800204p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7effff), -0x1.8002040004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000840000), 0x1.80021p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff7bffff), -0x1.8002100004p+38, 0x0p+0 },
+{ INT64_C(0x0000006000a00000), 0x1.80028p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fff5fffff), -0x1.8002800004p+38, 0x0p+0 },
+{ INT64_C(0x0000006004000000), 0x1.801p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbffffff), -0x1.8010000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006004000008), 0x1.801000002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbfffff7), -0x1.8010000024p+38, 0x0p+0 },
+{ INT64_C(0x0000006004000080), 0x1.80100002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbffff7f), -0x1.8010000204p+38, 0x0p+0 },
+{ INT64_C(0x0000006004000200), 0x1.80100008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbfffdff), -0x1.8010000804p+38, 0x0p+0 },
+{ INT64_C(0x0000006004001000), 0x1.8010004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbffefff), -0x1.8010004004p+38, 0x0p+0 },
+{ INT64_C(0x0000006004010000), 0x1.801004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbfeffff), -0x1.8010040004p+38, 0x0p+0 },
+{ INT64_C(0x0000006004040000), 0x1.80101p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbfbffff), -0x1.8010100004p+38, 0x0p+0 },
+{ INT64_C(0x0000006004100000), 0x1.80104p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffbefffff), -0x1.8010400004p+38, 0x0p+0 },
+{ INT64_C(0x0000006005000000), 0x1.8014p+38, 0x0p+0 },
+{ INT64_C(0xffffff9ffaffffff), -0x1.8014000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040000000), 0x1.81p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfffffff), -0x1.8100000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040000001), 0x1.8100000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbffffffe), -0x1.8100000008p+38, 0x0p+0 },
+{ INT64_C(0x0000006040000002), 0x1.8100000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbffffffd), -0x1.810000000cp+38, 0x0p+0 },
+{ INT64_C(0x0000006040000020), 0x1.810000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfffffdf), -0x1.8100000084p+38, 0x0p+0 },
+{ INT64_C(0x0000006040000080), 0x1.81000002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfffff7f), -0x1.8100000204p+38, 0x0p+0 },
+{ INT64_C(0x0000006040000100), 0x1.81000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbffffeff), -0x1.8100000404p+38, 0x0p+0 },
+{ INT64_C(0x0000006040000200), 0x1.81000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbffffdff), -0x1.8100000804p+38, 0x0p+0 },
+{ INT64_C(0x0000006040002000), 0x1.8100008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfffdfff), -0x1.8100008004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040004000), 0x1.810001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfffbfff), -0x1.8100010004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040008000), 0x1.810002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfff7fff), -0x1.8100020004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040040000), 0x1.81001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbffbffff), -0x1.8100100004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040200000), 0x1.81008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbfdfffff), -0x1.8100800004p+38, 0x0p+0 },
+{ INT64_C(0x0000006040800000), 0x1.8102p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbf7fffff), -0x1.8102000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006042000000), 0x1.8108p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fbdffffff), -0x1.8108000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006050000000), 0x1.814p+38, 0x0p+0 },
+{ INT64_C(0xffffff9fafffffff), -0x1.8140000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000000), 0x1.9p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bffffffff), -0x1.9000000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000001), 0x1.9000000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bfffffffe), -0x1.9000000008p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000010), 0x1.900000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bffffffef), -0x1.9000000044p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000020), 0x1.900000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bffffffdf), -0x1.9000000084p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000040), 0x1.90000001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bffffffbf), -0x1.9000000104p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000400), 0x1.9000001p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bfffffbff), -0x1.9000001004p+38, 0x0p+0 },
+{ INT64_C(0x0000006400000800), 0x1.9000002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bfffff7ff), -0x1.9000002004p+38, 0x0p+0 },
+{ INT64_C(0x0000006400008000), 0x1.900002p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bffff7fff), -0x1.9000020004p+38, 0x0p+0 },
+{ INT64_C(0x0000006400020000), 0x1.900008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bfffdffff), -0x1.9000080004p+38, 0x0p+0 },
+{ INT64_C(0x0000006400200000), 0x1.90008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bffdfffff), -0x1.9000800004p+38, 0x0p+0 },
+{ INT64_C(0x0000006402000000), 0x1.9008p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bfdffffff), -0x1.9008000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006420000000), 0x1.908p+38, 0x0p+0 },
+{ INT64_C(0xffffff9bdfffffff), -0x1.9080000004p+38, 0x0p+0 },
+{ INT64_C(0x0000006600000000), 0x1.98p+38, 0x0p+0 },
+{ INT64_C(0xffffff99ffffffff), -0x1.9800000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007000000000), 0x1.cp+38, 0x0p+0 },
+{ INT64_C(0xffffff8fffffffff), -0x1.c000000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007000000002), 0x1.c000000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffffffffd), -0x1.c00000000cp+38, 0x0p+0 },
+{ INT64_C(0x0000007000000010), 0x1.c00000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff8fffffffef), -0x1.c000000044p+38, 0x0p+0 },
+{ INT64_C(0x0000007000000040), 0x1.c0000001p+38, 0x0p+0 },
+{ INT64_C(0xffffff8fffffffbf), -0x1.c000000104p+38, 0x0p+0 },
+{ INT64_C(0x0000007000000100), 0x1.c0000004p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffffffeff), -0x1.c000000404p+38, 0x0p+0 },
+{ INT64_C(0x0000007000000200), 0x1.c0000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffffffdff), -0x1.c000000804p+38, 0x0p+0 },
+{ INT64_C(0x0000007000002000), 0x1.c000008p+38, 0x0p+0 },
+{ INT64_C(0xffffff8fffffdfff), -0x1.c000008004p+38, 0x0p+0 },
+{ INT64_C(0x0000007000020000), 0x1.c00008p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffffdffff), -0x1.c000080004p+38, 0x0p+0 },
+{ INT64_C(0x0000007000200000), 0x1.c0008p+38, 0x0p+0 },
+{ INT64_C(0xffffff8fffdfffff), -0x1.c000800004p+38, 0x0p+0 },
+{ INT64_C(0x0000007000400000), 0x1.c001p+38, 0x0p+0 },
+{ INT64_C(0xffffff8fffbfffff), -0x1.c001000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007001000000), 0x1.c004p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffeffffff), -0x1.c004000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007002000000), 0x1.c008p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffdffffff), -0x1.c008000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007004000000), 0x1.c01p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ffbffffff), -0x1.c010000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007008000000), 0x1.c02p+38, 0x0p+0 },
+{ INT64_C(0xffffff8ff7ffffff), -0x1.c020000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007040000000), 0x1.c1p+38, 0x0p+0 },
+{ INT64_C(0xffffff8fbfffffff), -0x1.c100000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007080000000), 0x1.c2p+38, 0x0p+0 },
+{ INT64_C(0xffffff8f7fffffff), -0x1.c200000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007200000000), 0x1.c8p+38, 0x0p+0 },
+{ INT64_C(0xffffff8dffffffff), -0x1.c800000004p+38, 0x0p+0 },
+{ INT64_C(0x0000007800000000), 0x1.ep+38, 0x0p+0 },
+{ INT64_C(0xffffff87ffffffff), -0x1.e000000004p+38, 0x0p+0 },
+{ INT64_C(0x0000010000000012), 0x1.0000000012p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffffed), -0x1.0000000013p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000014), 0x1.0000000014p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffffeb), -0x1.0000000015p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000016), 0x1.0000000016p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffffe9), -0x1.0000000017p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000024), 0x1.0000000024p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffffdb), -0x1.0000000025p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000026), 0x1.0000000026p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffffd9), -0x1.0000000027p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000081), 0x1.0000000081p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffff7e), -0x1.0000000082p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000090), 0x1.000000009p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffff6f), -0x1.0000000091p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000092), 0x1.0000000092p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffff6d), -0x1.0000000093p+40, 0x0p+0 },
+{ INT64_C(0x00000100000000c0), 0x1.00000000cp+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffff3f), -0x1.00000000c1p+40, 0x0p+0 },
+{ INT64_C(0x00000100000000c2), 0x1.00000000c2p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffff3d), -0x1.00000000c3p+40, 0x0p+0 },
+{ INT64_C(0x00000100000000c8), 0x1.00000000c8p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffff37), -0x1.00000000c9p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000404), 0x1.0000000404p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffbfb), -0x1.0000000405p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000440), 0x1.000000044p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffbbf), -0x1.0000000441p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000441), 0x1.0000000441p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffbbe), -0x1.0000000442p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000442), 0x1.0000000442p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffbbd), -0x1.0000000443p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000444), 0x1.0000000444p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffbbb), -0x1.0000000445p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000448), 0x1.0000000448p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffbb7), -0x1.0000000449p+40, 0x0p+0 },
+{ INT64_C(0x0000010000000460), 0x1.000000046p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffffb9f), -0x1.0000000461p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001008), 0x1.0000001008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffeff7), -0x1.0000001009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001009), 0x1.0000001009p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffeff6), -0x1.000000100ap+40, 0x0p+0 },
+{ INT64_C(0x0000010000001080), 0x1.000000108p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffef7f), -0x1.0000001081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001088), 0x1.0000001088p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffef77), -0x1.0000001089p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001200), 0x1.00000012p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffedff), -0x1.0000001201p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001202), 0x1.0000001202p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffedfd), -0x1.0000001203p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001204), 0x1.0000001204p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffedfb), -0x1.0000001205p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001208), 0x1.0000001208p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffedf7), -0x1.0000001209p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001280), 0x1.000000128p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffed7f), -0x1.0000001281p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001300), 0x1.00000013p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffecff), -0x1.0000001301p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001400), 0x1.00000014p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffebff), -0x1.0000001401p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001402), 0x1.0000001402p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffebfd), -0x1.0000001403p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001408), 0x1.0000001408p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffebf7), -0x1.0000001409p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001480), 0x1.000000148p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffeb7f), -0x1.0000001481p+40, 0x0p+0 },
+{ INT64_C(0x0000010000001600), 0x1.00000016p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffe9ff), -0x1.0000001601p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004004), 0x1.0000004004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffbffb), -0x1.0000004005p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004040), 0x1.000000404p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffbfbf), -0x1.0000004041p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004044), 0x1.0000004044p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffbfbb), -0x1.0000004045p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004050), 0x1.000000405p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffbfaf), -0x1.0000004051p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004080), 0x1.000000408p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffbf7f), -0x1.0000004081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004088), 0x1.0000004088p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffbf77), -0x1.0000004089p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004800), 0x1.00000048p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffb7ff), -0x1.0000004801p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004804), 0x1.0000004804p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffb7fb), -0x1.0000004805p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004820), 0x1.000000482p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffb7df), -0x1.0000004821p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004840), 0x1.000000484p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffb7bf), -0x1.0000004841p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004900), 0x1.00000049p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffb6ff), -0x1.0000004901p+40, 0x0p+0 },
+{ INT64_C(0x0000010000004c00), 0x1.0000004cp+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffffb3ff), -0x1.0000004c01p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040001), 0x1.0000040001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfffe), -0x1.0000040002p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040008), 0x1.0000040008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfff7), -0x1.0000040009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040009), 0x1.0000040009p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfff6), -0x1.000004000ap+40, 0x0p+0 },
+{ INT64_C(0x0000010000040010), 0x1.000004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbffef), -0x1.0000040011p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040011), 0x1.0000040011p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbffee), -0x1.0000040012p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040014), 0x1.0000040014p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbffeb), -0x1.0000040015p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040040), 0x1.000004004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbffbf), -0x1.0000040041p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040041), 0x1.0000040041p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbffbe), -0x1.0000040042p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040048), 0x1.0000040048p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbffb7), -0x1.0000040049p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040200), 0x1.00000402p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfdff), -0x1.0000040201p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040208), 0x1.0000040208p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfdf7), -0x1.0000040209p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040220), 0x1.000004022p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfddf), -0x1.0000040221p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040300), 0x1.00000403p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbfcff), -0x1.0000040301p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040800), 0x1.00000408p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf7ff), -0x1.0000040801p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040801), 0x1.0000040801p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf7fe), -0x1.0000040802p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040808), 0x1.0000040808p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf7f7), -0x1.0000040809p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040820), 0x1.000004082p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf7df), -0x1.0000040821p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040840), 0x1.000004084p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf7bf), -0x1.0000040841p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040880), 0x1.000004088p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf77f), -0x1.0000040881p+40, 0x0p+0 },
+{ INT64_C(0x0000010000040c00), 0x1.0000040cp+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbf3ff), -0x1.0000040c01p+40, 0x0p+0 },
+{ INT64_C(0x0000010000044000), 0x1.0000044p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbbfff), -0x1.0000044001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000044008), 0x1.0000044008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbbff7), -0x1.0000044009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000044020), 0x1.000004402p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbbfdf), -0x1.0000044021p+40, 0x0p+0 },
+{ INT64_C(0x0000010000044100), 0x1.00000441p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbbeff), -0x1.0000044101p+40, 0x0p+0 },
+{ INT64_C(0x0000010000044400), 0x1.00000444p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbbbff), -0x1.0000044401p+40, 0x0p+0 },
+{ INT64_C(0x0000010000044800), 0x1.00000448p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffbb7ff), -0x1.0000044801p+40, 0x0p+0 },
+{ INT64_C(0x0000010000046000), 0x1.0000046p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb9fff), -0x1.0000046001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000048000), 0x1.0000048p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb7fff), -0x1.0000048001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000048004), 0x1.0000048004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb7ffb), -0x1.0000048005p+40, 0x0p+0 },
+{ INT64_C(0x0000010000048010), 0x1.000004801p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb7fef), -0x1.0000048011p+40, 0x0p+0 },
+{ INT64_C(0x0000010000048040), 0x1.000004804p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb7fbf), -0x1.0000048041p+40, 0x0p+0 },
+{ INT64_C(0x0000010000048100), 0x1.00000481p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb7eff), -0x1.0000048101p+40, 0x0p+0 },
+{ INT64_C(0x0000010000049000), 0x1.0000049p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffffb6fff), -0x1.0000049001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000060000), 0x1.000006p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9ffff), -0x1.0000060001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000060004), 0x1.0000060004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9fffb), -0x1.0000060005p+40, 0x0p+0 },
+{ INT64_C(0x0000010000060020), 0x1.000006002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9ffdf), -0x1.0000060021p+40, 0x0p+0 },
+{ INT64_C(0x0000010000060080), 0x1.000006008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9ff7f), -0x1.0000060081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000060800), 0x1.00000608p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9f7ff), -0x1.0000060801p+40, 0x0p+0 },
+{ INT64_C(0x0000010000061000), 0x1.0000061p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9efff), -0x1.0000061001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000064000), 0x1.0000064p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff9bfff), -0x1.0000064001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000068000), 0x1.0000068p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffff97fff), -0x1.0000068001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100008), 0x1.0000100008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeffff7), -0x1.0000100009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100080), 0x1.000010008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefff7f), -0x1.0000100081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100082), 0x1.0000100082p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefff7d), -0x1.0000100083p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100088), 0x1.0000100088p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefff77), -0x1.0000100089p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100090), 0x1.000010009p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefff6f), -0x1.0000100091p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100100), 0x1.00001001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeffeff), -0x1.0000100101p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100104), 0x1.0000100104p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeffefb), -0x1.0000100105p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100108), 0x1.0000100108p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeffef7), -0x1.0000100109p+40, 0x0p+0 },
+{ INT64_C(0x0000010000100180), 0x1.000010018p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeffe7f), -0x1.0000100181p+40, 0x0p+0 },
+{ INT64_C(0x0000010000101000), 0x1.0000101p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefefff), -0x1.0000101001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000101008), 0x1.0000101008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefeff7), -0x1.0000101009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000101080), 0x1.000010108p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefef7f), -0x1.0000101081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000101400), 0x1.00001014p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffefebff), -0x1.0000101401p+40, 0x0p+0 },
+{ INT64_C(0x0000010000110000), 0x1.000011p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeeffff), -0x1.0000110001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000110002), 0x1.0000110002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeefffd), -0x1.0000110003p+40, 0x0p+0 },
+{ INT64_C(0x0000010000110020), 0x1.000011002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeeffdf), -0x1.0000110021p+40, 0x0p+0 },
+{ INT64_C(0x0000010000110100), 0x1.00001101p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeefeff), -0x1.0000110101p+40, 0x0p+0 },
+{ INT64_C(0x0000010000111000), 0x1.0000111p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeeefff), -0x1.0000111001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000114000), 0x1.0000114p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffeebfff), -0x1.0000114001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400008), 0x1.0000400008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffff7), -0x1.0000400009p+40, 0x0p+0 },
+{ INT64_C(0x000001000040000c), 0x1.000040000cp+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffff3), -0x1.000040000dp+40, 0x0p+0 },
+{ INT64_C(0x0000010000400020), 0x1.000040002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfffdf), -0x1.0000400021p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400022), 0x1.0000400022p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfffdd), -0x1.0000400023p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400028), 0x1.0000400028p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfffd7), -0x1.0000400029p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400100), 0x1.00004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffeff), -0x1.0000400101p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400104), 0x1.0000400104p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffefb), -0x1.0000400105p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400108), 0x1.0000400108p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffef7), -0x1.0000400109p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400120), 0x1.000040012p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffedf), -0x1.0000400121p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400400), 0x1.00004004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffbff), -0x1.0000400401p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400401), 0x1.0000400401p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffbfe), -0x1.0000400402p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400408), 0x1.0000400408p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffbf7), -0x1.0000400409p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400410), 0x1.000040041p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffbef), -0x1.0000400411p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400500), 0x1.00004005p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbffaff), -0x1.0000400501p+40, 0x0p+0 },
+{ INT64_C(0x0000010000400600), 0x1.00004006p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbff9ff), -0x1.0000400601p+40, 0x0p+0 },
+{ INT64_C(0x0000010000404000), 0x1.0000404p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfbfff), -0x1.0000404001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000404004), 0x1.0000404004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfbffb), -0x1.0000404005p+40, 0x0p+0 },
+{ INT64_C(0x0000010000404008), 0x1.0000404008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfbff7), -0x1.0000404009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000404040), 0x1.000040404p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfbfbf), -0x1.0000404041p+40, 0x0p+0 },
+{ INT64_C(0x0000010000404080), 0x1.000040408p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfbf7f), -0x1.0000404081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000404400), 0x1.00004044p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfbbff), -0x1.0000404401p+40, 0x0p+0 },
+{ INT64_C(0x0000010000405000), 0x1.0000405p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbfafff), -0x1.0000405001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000406000), 0x1.0000406p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbf9fff), -0x1.0000406001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000408000), 0x1.0000408p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbf7fff), -0x1.0000408001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000408008), 0x1.0000408008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbf7ff7), -0x1.0000408009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000408040), 0x1.000040804p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbf7fbf), -0x1.0000408041p+40, 0x0p+0 },
+{ INT64_C(0x0000010000408400), 0x1.00004084p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbf7bff), -0x1.0000408401p+40, 0x0p+0 },
+{ INT64_C(0x0000010000409000), 0x1.0000409p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffbf6fff), -0x1.0000409001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000480000), 0x1.000048p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7ffff), -0x1.0000480001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000480004), 0x1.0000480004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7fffb), -0x1.0000480005p+40, 0x0p+0 },
+{ INT64_C(0x0000010000480008), 0x1.0000480008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7fff7), -0x1.0000480009p+40, 0x0p+0 },
+{ INT64_C(0x0000010000480020), 0x1.000048002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7ffdf), -0x1.0000480021p+40, 0x0p+0 },
+{ INT64_C(0x0000010000480080), 0x1.000048008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7ff7f), -0x1.0000480081p+40, 0x0p+0 },
+{ INT64_C(0x0000010000480200), 0x1.00004802p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7fdff), -0x1.0000480201p+40, 0x0p+0 },
+{ INT64_C(0x0000010000481000), 0x1.0000481p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb7efff), -0x1.0000481001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000488000), 0x1.0000488p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb77fff), -0x1.0000488001p+40, 0x0p+0 },
+{ INT64_C(0x00000100004a0000), 0x1.00004ap+40, 0x0p+0 },
+{ INT64_C(0xfffffeffffb5ffff), -0x1.00004a0001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000600000), 0x1.00006p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9fffff), -0x1.0000600001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000600004), 0x1.0000600004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9ffffb), -0x1.0000600005p+40, 0x0p+0 },
+{ INT64_C(0x0000010000600010), 0x1.000060001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9fffef), -0x1.0000600011p+40, 0x0p+0 },
+{ INT64_C(0x0000010000600020), 0x1.000060002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9fffdf), -0x1.0000600021p+40, 0x0p+0 },
+{ INT64_C(0x0000010000600040), 0x1.000060004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9fffbf), -0x1.0000600041p+40, 0x0p+0 },
+{ INT64_C(0x0000010000600200), 0x1.00006002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9ffdff), -0x1.0000600201p+40, 0x0p+0 },
+{ INT64_C(0x0000010000601000), 0x1.0000601p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9fefff), -0x1.0000601001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000608000), 0x1.0000608p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9f7fff), -0x1.0000608001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000620000), 0x1.000062p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff9dffff), -0x1.0000620001p+40, 0x0p+0 },
+{ INT64_C(0x0000010000680000), 0x1.000068p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffff97ffff), -0x1.0000680001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000001), 0x1.0004000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffffe), -0x1.0004000002p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000010), 0x1.000400001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffffef), -0x1.0004000011p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000012), 0x1.0004000012p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffffed), -0x1.0004000013p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000040), 0x1.000400004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffffbf), -0x1.0004000041p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000048), 0x1.0004000048p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffffb7), -0x1.0004000049p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000100), 0x1.00040001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffeff), -0x1.0004000101p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000108), 0x1.0004000108p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffef7), -0x1.0004000109p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000110), 0x1.000400011p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffeef), -0x1.0004000111p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000180), 0x1.000400018p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffe7f), -0x1.0004000181p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000400), 0x1.00040004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffbff), -0x1.0004000401p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000401), 0x1.0004000401p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffbfe), -0x1.0004000402p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000402), 0x1.0004000402p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffbfd), -0x1.0004000403p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000420), 0x1.000400042p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffbdf), -0x1.0004000421p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000440), 0x1.000400044p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffbbf), -0x1.0004000441p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000480), 0x1.000400048p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfffb7f), -0x1.0004000481p+40, 0x0p+0 },
+{ INT64_C(0x0000010004000600), 0x1.00040006p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfff9ff), -0x1.0004000601p+40, 0x0p+0 },
+{ INT64_C(0x0000010004001000), 0x1.0004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffefff), -0x1.0004001001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004001001), 0x1.0004001001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffeffe), -0x1.0004001002p+40, 0x0p+0 },
+{ INT64_C(0x0000010004001002), 0x1.0004001002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffeffd), -0x1.0004001003p+40, 0x0p+0 },
+{ INT64_C(0x0000010004001008), 0x1.0004001008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffeff7), -0x1.0004001009p+40, 0x0p+0 },
+{ INT64_C(0x0000010004001080), 0x1.000400108p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffef7f), -0x1.0004001081p+40, 0x0p+0 },
+{ INT64_C(0x0000010004001400), 0x1.00040014p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffebff), -0x1.0004001401p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002000), 0x1.0004002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdfff), -0x1.0004002001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002001), 0x1.0004002001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdffe), -0x1.0004002002p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002002), 0x1.0004002002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdffd), -0x1.0004002003p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002004), 0x1.0004002004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdffb), -0x1.0004002005p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002010), 0x1.000400201p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdfef), -0x1.0004002011p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002100), 0x1.00040021p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdeff), -0x1.0004002101p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002400), 0x1.00040024p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffdbff), -0x1.0004002401p+40, 0x0p+0 },
+{ INT64_C(0x0000010004002800), 0x1.00040028p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbffd7ff), -0x1.0004002801p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020000), 0x1.000402p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdffff), -0x1.0004020001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020001), 0x1.0004020001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdfffe), -0x1.0004020002p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020002), 0x1.0004020002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdfffd), -0x1.0004020003p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020008), 0x1.0004020008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdfff7), -0x1.0004020009p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020010), 0x1.000402001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdffef), -0x1.0004020011p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020080), 0x1.000402008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdff7f), -0x1.0004020081p+40, 0x0p+0 },
+{ INT64_C(0x0000010004020400), 0x1.00040204p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfdfbff), -0x1.0004020401p+40, 0x0p+0 },
+{ INT64_C(0x0000010004022000), 0x1.0004022p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfddfff), -0x1.0004022001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004030000), 0x1.000403p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbfcffff), -0x1.0004030001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004200000), 0x1.00042p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdfffff), -0x1.0004200001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004200001), 0x1.0004200001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdffffe), -0x1.0004200002p+40, 0x0p+0 },
+{ INT64_C(0x0000010004200002), 0x1.0004200002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdffffd), -0x1.0004200003p+40, 0x0p+0 },
+{ INT64_C(0x0000010004200008), 0x1.0004200008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdffff7), -0x1.0004200009p+40, 0x0p+0 },
+{ INT64_C(0x0000010004200080), 0x1.000420008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdfff7f), -0x1.0004200081p+40, 0x0p+0 },
+{ INT64_C(0x0000010004200800), 0x1.00042008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdff7ff), -0x1.0004200801p+40, 0x0p+0 },
+{ INT64_C(0x0000010004202000), 0x1.0004202p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdfdfff), -0x1.0004202001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004208000), 0x1.0004208p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbdf7fff), -0x1.0004208001p+40, 0x0p+0 },
+{ INT64_C(0x0000010004280000), 0x1.000428p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffbd7ffff), -0x1.0004280001p+40, 0x0p+0 },
+{ INT64_C(0x0000010005000000), 0x1.0005p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffaffffff), -0x1.0005000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010005000001), 0x1.0005000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffafffffe), -0x1.0005000002p+40, 0x0p+0 },
+{ INT64_C(0x0000010005000002), 0x1.0005000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffafffffd), -0x1.0005000003p+40, 0x0p+0 },
+{ INT64_C(0x0000010005000010), 0x1.000500001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffaffffef), -0x1.0005000011p+40, 0x0p+0 },
+{ INT64_C(0x0000010005000080), 0x1.000500008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffaffff7f), -0x1.0005000081p+40, 0x0p+0 },
+{ INT64_C(0x0000010005000200), 0x1.00050002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffafffdff), -0x1.0005000201p+40, 0x0p+0 },
+{ INT64_C(0x0000010005002000), 0x1.0005002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffaffdfff), -0x1.0005002001p+40, 0x0p+0 },
+{ INT64_C(0x0000010005020000), 0x1.000502p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffafdffff), -0x1.0005020001p+40, 0x0p+0 },
+{ INT64_C(0x0000010005040000), 0x1.000504p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffafbffff), -0x1.0005040001p+40, 0x0p+0 },
+{ INT64_C(0x0000010005400000), 0x1.00054p+40, 0x0p+0 },
+{ INT64_C(0xfffffefffabfffff), -0x1.0005400001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000008), 0x1.0040000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffffff7), -0x1.0040000009p+40, 0x0p+0 },
+{ INT64_C(0x000001004000000c), 0x1.004000000cp+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffffff3), -0x1.004000000dp+40, 0x0p+0 },
+{ INT64_C(0x0000010040000020), 0x1.004000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffffdf), -0x1.0040000021p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000028), 0x1.0040000028p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffffd7), -0x1.0040000029p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000030), 0x1.004000003p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffffcf), -0x1.0040000031p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000040), 0x1.004000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffffbf), -0x1.0040000041p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000042), 0x1.0040000042p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffffbd), -0x1.0040000043p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000048), 0x1.0040000048p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffffb7), -0x1.0040000049p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000060), 0x1.004000006p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffff9f), -0x1.0040000061p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000080), 0x1.004000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffff7f), -0x1.0040000081p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000088), 0x1.0040000088p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffff77), -0x1.0040000089p+40, 0x0p+0 },
+{ INT64_C(0x00000100400000a0), 0x1.00400000ap+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffff5f), -0x1.00400000a1p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000800), 0x1.00400008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffff7ff), -0x1.0040000801p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000801), 0x1.0040000801p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffff7fe), -0x1.0040000802p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000808), 0x1.0040000808p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffff7f7), -0x1.0040000809p+40, 0x0p+0 },
+{ INT64_C(0x0000010040000880), 0x1.004000088p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffff77f), -0x1.0040000881p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001000), 0x1.0040001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffefff), -0x1.0040001001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001002), 0x1.0040001002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffeffd), -0x1.0040001003p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001008), 0x1.0040001008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffeff7), -0x1.0040001009p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001040), 0x1.004000104p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffefbf), -0x1.0040001041p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001080), 0x1.004000108p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffef7f), -0x1.0040001081p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001100), 0x1.00400011p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffeeff), -0x1.0040001101p+40, 0x0p+0 },
+{ INT64_C(0x0000010040001200), 0x1.00400012p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfffedff), -0x1.0040001201p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010000), 0x1.004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffeffff), -0x1.0040010001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010001), 0x1.0040010001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffefffe), -0x1.0040010002p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010008), 0x1.0040010008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffefff7), -0x1.0040010009p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010010), 0x1.004001001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffeffef), -0x1.0040010011p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010020), 0x1.004001002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffeffdf), -0x1.0040010021p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010040), 0x1.004001004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffeffbf), -0x1.0040010041p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010080), 0x1.004001008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffeff7f), -0x1.0040010081p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010200), 0x1.00400102p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffefdff), -0x1.0040010201p+40, 0x0p+0 },
+{ INT64_C(0x0000010040010800), 0x1.00400108p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffef7ff), -0x1.0040010801p+40, 0x0p+0 },
+{ INT64_C(0x0000010040011000), 0x1.0040011p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffeefff), -0x1.0040011001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040014000), 0x1.0040014p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbffebfff), -0x1.0040014001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040080000), 0x1.004008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7ffff), -0x1.0040080001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040080002), 0x1.0040080002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7fffd), -0x1.0040080003p+40, 0x0p+0 },
+{ INT64_C(0x0000010040080020), 0x1.004008002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7ffdf), -0x1.0040080021p+40, 0x0p+0 },
+{ INT64_C(0x0000010040080040), 0x1.004008004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7ffbf), -0x1.0040080041p+40, 0x0p+0 },
+{ INT64_C(0x0000010040080400), 0x1.00400804p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7fbff), -0x1.0040080401p+40, 0x0p+0 },
+{ INT64_C(0x0000010040080800), 0x1.00400808p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7f7ff), -0x1.0040080801p+40, 0x0p+0 },
+{ INT64_C(0x0000010040081000), 0x1.0040081p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff7efff), -0x1.0040081001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040090000), 0x1.004009p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff6ffff), -0x1.0040090001p+40, 0x0p+0 },
+{ INT64_C(0x00000100400c0000), 0x1.00400cp+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbff3ffff), -0x1.00400c0001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040400000), 0x1.00404p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbfffff), -0x1.0040400001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040400008), 0x1.0040400008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbffff7), -0x1.0040400009p+40, 0x0p+0 },
+{ INT64_C(0x0000010040400010), 0x1.004040001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbfffef), -0x1.0040400011p+40, 0x0p+0 },
+{ INT64_C(0x0000010040400100), 0x1.00404001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbffeff), -0x1.0040400101p+40, 0x0p+0 },
+{ INT64_C(0x0000010040400200), 0x1.00404002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbffdff), -0x1.0040400201p+40, 0x0p+0 },
+{ INT64_C(0x0000010040402000), 0x1.0040402p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbfdfff), -0x1.0040402001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040404000), 0x1.0040404p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbfbfff), -0x1.0040404001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040410000), 0x1.004041p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfbeffff), -0x1.0040410001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040480000), 0x1.004048p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfb7ffff), -0x1.0040480001p+40, 0x0p+0 },
+{ INT64_C(0x0000010040500000), 0x1.00405p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbfafffff), -0x1.0040500001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042000000), 0x1.0042p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdffffff), -0x1.0042000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042000004), 0x1.0042000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdfffffb), -0x1.0042000005p+40, 0x0p+0 },
+{ INT64_C(0x0000010042000010), 0x1.004200001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdffffef), -0x1.0042000011p+40, 0x0p+0 },
+{ INT64_C(0x0000010042000020), 0x1.004200002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdffffdf), -0x1.0042000021p+40, 0x0p+0 },
+{ INT64_C(0x0000010042000200), 0x1.00420002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdfffdff), -0x1.0042000201p+40, 0x0p+0 },
+{ INT64_C(0x0000010042001000), 0x1.0042001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdffefff), -0x1.0042001001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042004000), 0x1.0042004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdffbfff), -0x1.0042004001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042008000), 0x1.0042008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdff7fff), -0x1.0042008001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042040000), 0x1.004204p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdfbffff), -0x1.0042040001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042080000), 0x1.004208p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdf7ffff), -0x1.0042080001p+40, 0x0p+0 },
+{ INT64_C(0x0000010042400000), 0x1.00424p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbdbfffff), -0x1.0042400001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044000000), 0x1.0044p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbffffff), -0x1.0044000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044000001), 0x1.0044000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbfffffe), -0x1.0044000002p+40, 0x0p+0 },
+{ INT64_C(0x0000010044000002), 0x1.0044000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbfffffd), -0x1.0044000003p+40, 0x0p+0 },
+{ INT64_C(0x0000010044000020), 0x1.004400002p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbffffdf), -0x1.0044000021p+40, 0x0p+0 },
+{ INT64_C(0x0000010044000100), 0x1.00440001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbfffeff), -0x1.0044000101p+40, 0x0p+0 },
+{ INT64_C(0x0000010044001000), 0x1.0044001p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbffefff), -0x1.0044001001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044004000), 0x1.0044004p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbffbfff), -0x1.0044004001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044008000), 0x1.0044008p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbff7fff), -0x1.0044008001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044010000), 0x1.004401p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbfeffff), -0x1.0044010001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044020000), 0x1.004402p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbfdffff), -0x1.0044020001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044040000), 0x1.004404p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbfbffff), -0x1.0044040001p+40, 0x0p+0 },
+{ INT64_C(0x0000010044200000), 0x1.00442p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffbbdfffff), -0x1.0044200001p+40, 0x0p+0 },
+{ INT64_C(0x0000010046000000), 0x1.0046p+40, 0x0p+0 },
+{ INT64_C(0xfffffeffb9ffffff), -0x1.0046000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000008), 0x1.0400000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffff7), -0x1.0400000009p+40, 0x0p+0 },
+{ INT64_C(0x000001040000000a), 0x1.040000000ap+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffff5), -0x1.040000000bp+40, 0x0p+0 },
+{ INT64_C(0x0000010400000020), 0x1.040000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffffdf), -0x1.0400000021p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000024), 0x1.0400000024p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffffdb), -0x1.0400000025p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000028), 0x1.0400000028p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffffd7), -0x1.0400000029p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000200), 0x1.04000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffdff), -0x1.0400000201p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000201), 0x1.0400000201p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffdfe), -0x1.0400000202p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000202), 0x1.0400000202p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffdfd), -0x1.0400000203p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000208), 0x1.0400000208p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffdf7), -0x1.0400000209p+40, 0x0p+0 },
+{ INT64_C(0x0000010400000280), 0x1.040000028p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffffd7f), -0x1.0400000281p+40, 0x0p+0 },
+{ INT64_C(0x0000010400002000), 0x1.0400002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffdfff), -0x1.0400002001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400002004), 0x1.0400002004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffdffb), -0x1.0400002005p+40, 0x0p+0 },
+{ INT64_C(0x0000010400002008), 0x1.0400002008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffdff7), -0x1.0400002009p+40, 0x0p+0 },
+{ INT64_C(0x0000010400002040), 0x1.040000204p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffdfbf), -0x1.0400002041p+40, 0x0p+0 },
+{ INT64_C(0x0000010400002400), 0x1.04000024p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffdbff), -0x1.0400002401p+40, 0x0p+0 },
+{ INT64_C(0x0000010400002800), 0x1.04000028p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffd7ff), -0x1.0400002801p+40, 0x0p+0 },
+{ INT64_C(0x0000010400004000), 0x1.0400004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffbfff), -0x1.0400004001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400004001), 0x1.0400004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffbffe), -0x1.0400004002p+40, 0x0p+0 },
+{ INT64_C(0x0000010400004010), 0x1.040000401p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffbfef), -0x1.0400004011p+40, 0x0p+0 },
+{ INT64_C(0x0000010400004100), 0x1.04000041p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffbeff), -0x1.0400004101p+40, 0x0p+0 },
+{ INT64_C(0x0000010400005000), 0x1.0400005p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffffafff), -0x1.0400005001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010000), 0x1.040001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffeffff), -0x1.0400010001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010001), 0x1.0400010001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffefffe), -0x1.0400010002p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010002), 0x1.0400010002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffefffd), -0x1.0400010003p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010008), 0x1.0400010008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffefff7), -0x1.0400010009p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010010), 0x1.040001001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffeffef), -0x1.0400010011p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010040), 0x1.040001004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffeffbf), -0x1.0400010041p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010400), 0x1.04000104p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffefbff), -0x1.0400010401p+40, 0x0p+0 },
+{ INT64_C(0x0000010400010800), 0x1.04000108p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffef7ff), -0x1.0400010801p+40, 0x0p+0 },
+{ INT64_C(0x0000010400012000), 0x1.0400012p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffedfff), -0x1.0400012001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400020000), 0x1.040002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdffff), -0x1.0400020001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400020001), 0x1.0400020001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdfffe), -0x1.0400020002p+40, 0x0p+0 },
+{ INT64_C(0x0000010400020004), 0x1.0400020004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdfffb), -0x1.0400020005p+40, 0x0p+0 },
+{ INT64_C(0x0000010400020040), 0x1.040002004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdffbf), -0x1.0400020041p+40, 0x0p+0 },
+{ INT64_C(0x0000010400020080), 0x1.040002008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdff7f), -0x1.0400020081p+40, 0x0p+0 },
+{ INT64_C(0x0000010400020400), 0x1.04000204p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdfbff), -0x1.0400020401p+40, 0x0p+0 },
+{ INT64_C(0x0000010400021000), 0x1.0400021p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffdefff), -0x1.0400021001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400030000), 0x1.040003p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffcffff), -0x1.0400030001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040000), 0x1.040004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbffff), -0x1.0400040001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040001), 0x1.0400040001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbfffe), -0x1.0400040002p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040008), 0x1.0400040008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbfff7), -0x1.0400040009p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040010), 0x1.040004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbffef), -0x1.0400040011p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040040), 0x1.040004004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbffbf), -0x1.0400040041p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040200), 0x1.04000402p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbfdff), -0x1.0400040201p+40, 0x0p+0 },
+{ INT64_C(0x0000010400040800), 0x1.04000408p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbf7ff), -0x1.0400040801p+40, 0x0p+0 },
+{ INT64_C(0x0000010400044000), 0x1.0400044p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbfffbbfff), -0x1.0400044001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400100000), 0x1.04001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffefffff), -0x1.0400100001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400100004), 0x1.0400100004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffeffffb), -0x1.0400100005p+40, 0x0p+0 },
+{ INT64_C(0x0000010400100040), 0x1.040010004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffefffbf), -0x1.0400100041p+40, 0x0p+0 },
+{ INT64_C(0x0000010400100080), 0x1.040010008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffefff7f), -0x1.0400100081p+40, 0x0p+0 },
+{ INT64_C(0x0000010400100800), 0x1.04001008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffeff7ff), -0x1.0400100801p+40, 0x0p+0 },
+{ INT64_C(0x0000010400101000), 0x1.0400101p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffefefff), -0x1.0400101001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400108000), 0x1.0400108p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffef7fff), -0x1.0400108001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400180000), 0x1.040018p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffe7ffff), -0x1.0400180001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200000), 0x1.04002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdfffff), -0x1.0400200001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200001), 0x1.0400200001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdffffe), -0x1.0400200002p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200010), 0x1.040020001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdfffef), -0x1.0400200011p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200020), 0x1.040020002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdfffdf), -0x1.0400200021p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200080), 0x1.040020008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdfff7f), -0x1.0400200081p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200400), 0x1.04002004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdffbff), -0x1.0400200401p+40, 0x0p+0 },
+{ INT64_C(0x0000010400200800), 0x1.04002008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdff7ff), -0x1.0400200801p+40, 0x0p+0 },
+{ INT64_C(0x0000010400208000), 0x1.0400208p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffdf7fff), -0x1.0400208001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400220000), 0x1.040022p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbffddffff), -0x1.0400220001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400800000), 0x1.04008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7fffff), -0x1.0400800001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400800002), 0x1.0400800002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7ffffd), -0x1.0400800003p+40, 0x0p+0 },
+{ INT64_C(0x0000010400800008), 0x1.0400800008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7ffff7), -0x1.0400800009p+40, 0x0p+0 },
+{ INT64_C(0x0000010400800080), 0x1.040080008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7fff7f), -0x1.0400800081p+40, 0x0p+0 },
+{ INT64_C(0x0000010400800800), 0x1.04008008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7ff7ff), -0x1.0400800801p+40, 0x0p+0 },
+{ INT64_C(0x0000010400801000), 0x1.0400801p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7fefff), -0x1.0400801001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400802000), 0x1.0400802p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7fdfff), -0x1.0400802001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400820000), 0x1.040082p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff7dffff), -0x1.0400820001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400900000), 0x1.04009p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff6fffff), -0x1.0400900001p+40, 0x0p+0 },
+{ INT64_C(0x0000010400a00000), 0x1.0400ap+40, 0x0p+0 },
+{ INT64_C(0xfffffefbff5fffff), -0x1.0400a00001p+40, 0x0p+0 },
+{ INT64_C(0x0000010408000000), 0x1.0408p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7ffffff), -0x1.0408000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010408000008), 0x1.0408000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7fffff7), -0x1.0408000009p+40, 0x0p+0 },
+{ INT64_C(0x0000010408000010), 0x1.040800001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7ffffef), -0x1.0408000011p+40, 0x0p+0 },
+{ INT64_C(0x0000010408000100), 0x1.04080001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7fffeff), -0x1.0408000101p+40, 0x0p+0 },
+{ INT64_C(0x0000010408000200), 0x1.04080002p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7fffdff), -0x1.0408000201p+40, 0x0p+0 },
+{ INT64_C(0x0000010408000800), 0x1.04080008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7fff7ff), -0x1.0408000801p+40, 0x0p+0 },
+{ INT64_C(0x0000010408004000), 0x1.0408004p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7ffbfff), -0x1.0408004001p+40, 0x0p+0 },
+{ INT64_C(0x0000010408010000), 0x1.040801p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7feffff), -0x1.0408010001p+40, 0x0p+0 },
+{ INT64_C(0x0000010408040000), 0x1.040804p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7fbffff), -0x1.0408040001p+40, 0x0p+0 },
+{ INT64_C(0x0000010408080000), 0x1.040808p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf7f7ffff), -0x1.0408080001p+40, 0x0p+0 },
+{ INT64_C(0x0000010408800000), 0x1.04088p+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf77fffff), -0x1.0408800001p+40, 0x0p+0 },
+{ INT64_C(0x000001040c000000), 0x1.040cp+40, 0x0p+0 },
+{ INT64_C(0xfffffefbf3ffffff), -0x1.040c000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010480000000), 0x1.048p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7fffffff), -0x1.0480000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010480000008), 0x1.0480000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7ffffff7), -0x1.0480000009p+40, 0x0p+0 },
+{ INT64_C(0x0000010480000010), 0x1.048000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7fffffef), -0x1.0480000011p+40, 0x0p+0 },
+{ INT64_C(0x0000010480000100), 0x1.04800001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7ffffeff), -0x1.0480000101p+40, 0x0p+0 },
+{ INT64_C(0x0000010480001000), 0x1.0480001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7fffefff), -0x1.0480001001p+40, 0x0p+0 },
+{ INT64_C(0x0000010480010000), 0x1.048001p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7ffeffff), -0x1.0480010001p+40, 0x0p+0 },
+{ INT64_C(0x0000010480080000), 0x1.048008p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7ff7ffff), -0x1.0480080001p+40, 0x0p+0 },
+{ INT64_C(0x0000010480800000), 0x1.04808p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7f7fffff), -0x1.0480800001p+40, 0x0p+0 },
+{ INT64_C(0x0000010484000000), 0x1.0484p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb7bffffff), -0x1.0484000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010488000000), 0x1.0488p+40, 0x0p+0 },
+{ INT64_C(0xfffffefb77ffffff), -0x1.0488000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000000), 0x1.06p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffffffff), -0x1.0600000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000001), 0x1.0600000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fffffffe), -0x1.0600000002p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000002), 0x1.0600000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fffffffd), -0x1.0600000003p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000004), 0x1.0600000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fffffffb), -0x1.0600000005p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000010), 0x1.060000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffffffef), -0x1.0600000011p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000020), 0x1.060000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffffffdf), -0x1.0600000021p+40, 0x0p+0 },
+{ INT64_C(0x0000010600000200), 0x1.06000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fffffdff), -0x1.0600000201p+40, 0x0p+0 },
+{ INT64_C(0x0000010600001000), 0x1.0600001p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffffefff), -0x1.0600001001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600002000), 0x1.0600002p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffffdfff), -0x1.0600002001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600010000), 0x1.060001p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fffeffff), -0x1.0600010001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600020000), 0x1.060002p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fffdffff), -0x1.0600020001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600080000), 0x1.060008p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fff7ffff), -0x1.0600080001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600100000), 0x1.06001p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffefffff), -0x1.0600100001p+40, 0x0p+0 },
+{ INT64_C(0x0000010600400000), 0x1.06004p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9ffbfffff), -0x1.0600400001p+40, 0x0p+0 },
+{ INT64_C(0x0000010604000000), 0x1.0604p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9fbffffff), -0x1.0604000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010610000000), 0x1.061p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9efffffff), -0x1.0610000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010620000000), 0x1.062p+40, 0x0p+0 },
+{ INT64_C(0xfffffef9dfffffff), -0x1.0620000001p+40, 0x0p+0 },
+{ INT64_C(0x0000010700000000), 0x1.07p+40, 0x0p+0 },
+{ INT64_C(0xfffffef8ffffffff), -0x1.0700000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000002), 0x1.2000000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffffd), -0x1.2000000003p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000008), 0x1.2000000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffff7), -0x1.2000000009p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000020), 0x1.200000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffffdf), -0x1.2000000021p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000024), 0x1.2000000024p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffffdb), -0x1.2000000025p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000040), 0x1.200000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffffbf), -0x1.2000000041p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000048), 0x1.2000000048p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffffb7), -0x1.2000000049p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000060), 0x1.200000006p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffff9f), -0x1.2000000061p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000100), 0x1.20000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffeff), -0x1.2000000101p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000102), 0x1.2000000102p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffefd), -0x1.2000000103p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000120), 0x1.200000012p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffedf), -0x1.2000000121p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000200), 0x1.20000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffdff), -0x1.2000000201p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000201), 0x1.2000000201p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffdfe), -0x1.2000000202p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000210), 0x1.200000021p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffdef), -0x1.2000000211p+40, 0x0p+0 },
+{ INT64_C(0x0000012000000280), 0x1.200000028p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffffd7f), -0x1.2000000281p+40, 0x0p+0 },
+{ INT64_C(0x0000012000002000), 0x1.2000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffdfff), -0x1.2000002001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000002004), 0x1.2000002004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffdffb), -0x1.2000002005p+40, 0x0p+0 },
+{ INT64_C(0x0000012000002040), 0x1.200000204p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffdfbf), -0x1.2000002041p+40, 0x0p+0 },
+{ INT64_C(0x0000012000002400), 0x1.20000024p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffdbff), -0x1.2000002401p+40, 0x0p+0 },
+{ INT64_C(0x0000012000004000), 0x1.2000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffbfff), -0x1.2000004001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000004004), 0x1.2000004004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffbffb), -0x1.2000004005p+40, 0x0p+0 },
+{ INT64_C(0x0000012000004040), 0x1.200000404p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffbfbf), -0x1.2000004041p+40, 0x0p+0 },
+{ INT64_C(0x0000012000004100), 0x1.20000041p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffbeff), -0x1.2000004101p+40, 0x0p+0 },
+{ INT64_C(0x0000012000004400), 0x1.20000044p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffffbbff), -0x1.2000004401p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040000), 0x1.200004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbffff), -0x1.2000040001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040002), 0x1.2000040002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbfffd), -0x1.2000040003p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040008), 0x1.2000040008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbfff7), -0x1.2000040009p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040010), 0x1.200004001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbffef), -0x1.2000040011p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040020), 0x1.200004002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbffdf), -0x1.2000040021p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040080), 0x1.200004008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbff7f), -0x1.2000040081p+40, 0x0p+0 },
+{ INT64_C(0x0000012000040200), 0x1.20000402p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbfdff), -0x1.2000040201p+40, 0x0p+0 },
+{ INT64_C(0x0000012000042000), 0x1.2000042p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffffbdfff), -0x1.2000042001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000060000), 0x1.200006p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffff9ffff), -0x1.2000060001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000100000), 0x1.20001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffefffff), -0x1.2000100001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000100008), 0x1.2000100008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffeffff7), -0x1.2000100009p+40, 0x0p+0 },
+{ INT64_C(0x0000012000100010), 0x1.200010001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffefffef), -0x1.2000100011p+40, 0x0p+0 },
+{ INT64_C(0x0000012000100100), 0x1.20001001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffeffeff), -0x1.2000100101p+40, 0x0p+0 },
+{ INT64_C(0x0000012000101000), 0x1.2000101p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffefefff), -0x1.2000101001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000108000), 0x1.2000108p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffef7fff), -0x1.2000108001p+40, 0x0p+0 },
+{ INT64_C(0x0000012000180000), 0x1.200018p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfffe7ffff), -0x1.2000180001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001000000), 0x1.2001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffeffffff), -0x1.2001000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001000002), 0x1.2001000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffefffffd), -0x1.2001000003p+40, 0x0p+0 },
+{ INT64_C(0x0000012001000004), 0x1.2001000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffefffffb), -0x1.2001000005p+40, 0x0p+0 },
+{ INT64_C(0x0000012001000040), 0x1.200100004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffeffffbf), -0x1.2001000041p+40, 0x0p+0 },
+{ INT64_C(0x0000012001000400), 0x1.20010004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffefffbff), -0x1.2001000401p+40, 0x0p+0 },
+{ INT64_C(0x0000012001000800), 0x1.20010008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffefff7ff), -0x1.2001000801p+40, 0x0p+0 },
+{ INT64_C(0x0000012001004000), 0x1.2001004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffeffbfff), -0x1.2001004001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001010000), 0x1.200101p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffefeffff), -0x1.2001010001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001100000), 0x1.20011p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffeefffff), -0x1.2001100001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001200000), 0x1.20012p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffedfffff), -0x1.2001200001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001400000), 0x1.20014p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffebfffff), -0x1.2001400001p+40, 0x0p+0 },
+{ INT64_C(0x0000012001800000), 0x1.20018p+40, 0x0p+0 },
+{ INT64_C(0xfffffedffe7fffff), -0x1.2001800001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008000000), 0x1.2008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffffff), -0x1.2008000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008000008), 0x1.2008000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7fffff7), -0x1.2008000009p+40, 0x0p+0 },
+{ INT64_C(0x0000012008000010), 0x1.200800001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffffef), -0x1.2008000011p+40, 0x0p+0 },
+{ INT64_C(0x0000012008000020), 0x1.200800002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffffdf), -0x1.2008000021p+40, 0x0p+0 },
+{ INT64_C(0x0000012008000040), 0x1.200800004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffffbf), -0x1.2008000041p+40, 0x0p+0 },
+{ INT64_C(0x0000012008000400), 0x1.20080004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7fffbff), -0x1.2008000401p+40, 0x0p+0 },
+{ INT64_C(0x0000012008001000), 0x1.2008001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffefff), -0x1.2008001001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008002000), 0x1.2008002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffdfff), -0x1.2008002001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008004000), 0x1.2008004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7ffbfff), -0x1.2008004001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008020000), 0x1.200802p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7fdffff), -0x1.2008020001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008080000), 0x1.200808p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7f7ffff), -0x1.2008080001p+40, 0x0p+0 },
+{ INT64_C(0x0000012008400000), 0x1.20084p+40, 0x0p+0 },
+{ INT64_C(0xfffffedff7bfffff), -0x1.2008400001p+40, 0x0p+0 },
+{ INT64_C(0x000001200c000000), 0x1.200cp+40, 0x0p+0 },
+{ INT64_C(0xfffffedff3ffffff), -0x1.200c000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040000000), 0x1.204p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfffffff), -0x1.2040000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040000001), 0x1.2040000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbffffffe), -0x1.2040000002p+40, 0x0p+0 },
+{ INT64_C(0x0000012040000002), 0x1.2040000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbffffffd), -0x1.2040000003p+40, 0x0p+0 },
+{ INT64_C(0x0000012040000010), 0x1.204000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfffffef), -0x1.2040000011p+40, 0x0p+0 },
+{ INT64_C(0x0000012040000040), 0x1.204000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfffffbf), -0x1.2040000041p+40, 0x0p+0 },
+{ INT64_C(0x0000012040000200), 0x1.20400002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbffffdff), -0x1.2040000201p+40, 0x0p+0 },
+{ INT64_C(0x0000012040002000), 0x1.2040002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfffdfff), -0x1.2040002001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040008000), 0x1.2040008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfff7fff), -0x1.2040008001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040020000), 0x1.204002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbffdffff), -0x1.2040020001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040100000), 0x1.20401p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfefffff), -0x1.2040100001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040200000), 0x1.20402p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfdfffff), -0x1.2040200001p+40, 0x0p+0 },
+{ INT64_C(0x0000012040400000), 0x1.20404p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbfbfffff), -0x1.2040400001p+40, 0x0p+0 },
+{ INT64_C(0x0000012044000000), 0x1.2044p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfbbffffff), -0x1.2044000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012050000000), 0x1.205p+40, 0x0p+0 },
+{ INT64_C(0xfffffedfafffffff), -0x1.2050000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012080000000), 0x1.208p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7fffffff), -0x1.2080000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012080000002), 0x1.2080000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7ffffffd), -0x1.2080000003p+40, 0x0p+0 },
+{ INT64_C(0x0000012080000010), 0x1.208000001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7fffffef), -0x1.2080000011p+40, 0x0p+0 },
+{ INT64_C(0x0000012080000040), 0x1.208000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7fffffbf), -0x1.2080000041p+40, 0x0p+0 },
+{ INT64_C(0x0000012080000200), 0x1.20800002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7ffffdff), -0x1.2080000201p+40, 0x0p+0 },
+{ INT64_C(0x0000012080000800), 0x1.20800008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7ffff7ff), -0x1.2080000801p+40, 0x0p+0 },
+{ INT64_C(0x0000012080004000), 0x1.2080004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7fffbfff), -0x1.2080004001p+40, 0x0p+0 },
+{ INT64_C(0x0000012080010000), 0x1.208001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7ffeffff), -0x1.2080010001p+40, 0x0p+0 },
+{ INT64_C(0x0000012080040000), 0x1.208004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7ffbffff), -0x1.2080040001p+40, 0x0p+0 },
+{ INT64_C(0x0000012080080000), 0x1.208008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7ff7ffff), -0x1.2080080001p+40, 0x0p+0 },
+{ INT64_C(0x0000012080200000), 0x1.20802p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7fdfffff), -0x1.2080200001p+40, 0x0p+0 },
+{ INT64_C(0x0000012082000000), 0x1.2082p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf7dffffff), -0x1.2082000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012088000000), 0x1.2088p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf77ffffff), -0x1.2088000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012090000000), 0x1.209p+40, 0x0p+0 },
+{ INT64_C(0xfffffedf6fffffff), -0x1.2090000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012100000000), 0x1.21p+40, 0x0p+0 },
+{ INT64_C(0xfffffedeffffffff), -0x1.2100000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012100000008), 0x1.2100000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefffffff7), -0x1.2100000009p+40, 0x0p+0 },
+{ INT64_C(0x0000012100000020), 0x1.210000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedeffffffdf), -0x1.2100000021p+40, 0x0p+0 },
+{ INT64_C(0x0000012100000200), 0x1.21000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefffffdff), -0x1.2100000201p+40, 0x0p+0 },
+{ INT64_C(0x0000012100000800), 0x1.21000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefffff7ff), -0x1.2100000801p+40, 0x0p+0 },
+{ INT64_C(0x0000012100008000), 0x1.2100008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedeffff7fff), -0x1.2100008001p+40, 0x0p+0 },
+{ INT64_C(0x0000012100010000), 0x1.210001p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefffeffff), -0x1.2100010001p+40, 0x0p+0 },
+{ INT64_C(0x0000012100020000), 0x1.210002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefffdffff), -0x1.2100020001p+40, 0x0p+0 },
+{ INT64_C(0x0000012100200000), 0x1.21002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedeffdfffff), -0x1.2100200001p+40, 0x0p+0 },
+{ INT64_C(0x0000012102000000), 0x1.2102p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefdffffff), -0x1.2102000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012104000000), 0x1.2104p+40, 0x0p+0 },
+{ INT64_C(0xfffffedefbffffff), -0x1.2104000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012140000000), 0x1.214p+40, 0x0p+0 },
+{ INT64_C(0xfffffedebfffffff), -0x1.2140000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012400000000), 0x1.24p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbffffffff), -0x1.2400000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012400000004), 0x1.2400000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbfffffffb), -0x1.2400000005p+40, 0x0p+0 },
+{ INT64_C(0x0000012400000008), 0x1.2400000008p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbfffffff7), -0x1.2400000009p+40, 0x0p+0 },
+{ INT64_C(0x0000012400000040), 0x1.240000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbffffffbf), -0x1.2400000041p+40, 0x0p+0 },
+{ INT64_C(0x0000012400000200), 0x1.24000002p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbfffffdff), -0x1.2400000201p+40, 0x0p+0 },
+{ INT64_C(0x0000012400000400), 0x1.24000004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbfffffbff), -0x1.2400000401p+40, 0x0p+0 },
+{ INT64_C(0x0000012400004000), 0x1.2400004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbffffbfff), -0x1.2400004001p+40, 0x0p+0 },
+{ INT64_C(0x0000012400040000), 0x1.240004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbfffbffff), -0x1.2400040001p+40, 0x0p+0 },
+{ INT64_C(0x0000012400400000), 0x1.24004p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbffbfffff), -0x1.2400400001p+40, 0x0p+0 },
+{ INT64_C(0x0000012402000000), 0x1.2402p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbfdffffff), -0x1.2402000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012410000000), 0x1.241p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbefffffff), -0x1.2410000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012440000000), 0x1.244p+40, 0x0p+0 },
+{ INT64_C(0xfffffedbbfffffff), -0x1.2440000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012480000000), 0x1.248p+40, 0x0p+0 },
+{ INT64_C(0xfffffedb7fffffff), -0x1.2480000001p+40, 0x0p+0 },
+{ INT64_C(0x0000012500000000), 0x1.25p+40, 0x0p+0 },
+{ INT64_C(0xfffffedaffffffff), -0x1.2500000001p+40, 0x0p+0 },
+{ INT64_C(0x0000080000000011), 0x1.00000000022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffffee), -0x1.00000000024p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000022), 0x1.00000000044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffffdd), -0x1.00000000046p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000024), 0x1.00000000048p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffffdb), -0x1.0000000004ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000000102), 0x1.00000000204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffefd), -0x1.00000000206p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000108), 0x1.0000000021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffef7), -0x1.00000000212p+43, 0x0p+0 },
+{ INT64_C(0x000008000000010a), 0x1.00000000214p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffef5), -0x1.00000000216p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000110), 0x1.0000000022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffeef), -0x1.00000000222p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000111), 0x1.00000000222p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffeee), -0x1.00000000224p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000112), 0x1.00000000224p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffeed), -0x1.00000000226p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000118), 0x1.0000000023p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffee7), -0x1.00000000232p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000120), 0x1.0000000024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffedf), -0x1.00000000242p+43, 0x0p+0 },
+{ INT64_C(0x0000080000000122), 0x1.00000000244p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffffedd), -0x1.00000000246p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001001), 0x1.00000002002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffeffe), -0x1.00000002004p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001008), 0x1.0000000201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffeff7), -0x1.00000002012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001010), 0x1.0000000202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffefef), -0x1.00000002022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001014), 0x1.00000002028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffefeb), -0x1.0000000202ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000001020), 0x1.0000000204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffefdf), -0x1.00000002042p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001022), 0x1.00000002044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffefdd), -0x1.00000002046p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001080), 0x1.000000021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffef7f), -0x1.00000002102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001084), 0x1.00000002108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffef7b), -0x1.0000000210ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000001090), 0x1.0000000212p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffef6f), -0x1.00000002122p+43, 0x0p+0 },
+{ INT64_C(0x00000800000010c0), 0x1.0000000218p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffef3f), -0x1.00000002182p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001400), 0x1.000000028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffebff), -0x1.00000002802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001404), 0x1.00000002808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffebfb), -0x1.0000000280ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000001420), 0x1.0000000284p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffebdf), -0x1.00000002842p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001480), 0x1.000000029p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffeb7f), -0x1.00000002902p+43, 0x0p+0 },
+{ INT64_C(0x0000080000001600), 0x1.00000002cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffffe9ff), -0x1.00000002c02p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010004), 0x1.00000020008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefffb), -0x1.0000002000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000010010), 0x1.0000002002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffeffef), -0x1.00000020022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010018), 0x1.0000002003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffeffe7), -0x1.00000020032p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010100), 0x1.000000202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefeff), -0x1.00000020202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010102), 0x1.00000020204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefefd), -0x1.00000020206p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010120), 0x1.0000002024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefedf), -0x1.00000020242p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010400), 0x1.000000208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefbff), -0x1.00000020802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010401), 0x1.00000020802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefbfe), -0x1.00000020804p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010410), 0x1.0000002082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefbef), -0x1.00000020822p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010480), 0x1.000000209p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffefb7f), -0x1.00000020902p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010600), 0x1.00000020cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef9ff), -0x1.00000020c02p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010800), 0x1.00000021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef7ff), -0x1.00000021002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010801), 0x1.00000021002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef7fe), -0x1.00000021004p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010810), 0x1.0000002102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef7ef), -0x1.00000021022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010840), 0x1.0000002108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef7bf), -0x1.00000021082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010880), 0x1.000000211p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef77f), -0x1.00000021102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000010c00), 0x1.000000218p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffef3ff), -0x1.00000021802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000012000), 0x1.00000024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffedfff), -0x1.00000024002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000012004), 0x1.00000024008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffedffb), -0x1.0000002400ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000012040), 0x1.0000002408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffedfbf), -0x1.00000024082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000012200), 0x1.000000244p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffeddff), -0x1.00000024402p+43, 0x0p+0 },
+{ INT64_C(0x0000080000012400), 0x1.000000248p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffedbff), -0x1.00000024802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000012800), 0x1.00000025p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffed7ff), -0x1.00000025002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000013000), 0x1.00000026p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffecfff), -0x1.00000026002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020002), 0x1.00000040004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdfffd), -0x1.00000040006p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020008), 0x1.0000004001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdfff7), -0x1.00000040012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020080), 0x1.000000401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdff7f), -0x1.00000040102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020088), 0x1.0000004011p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdff77), -0x1.00000040112p+43, 0x0p+0 },
+{ INT64_C(0x00000800000200a0), 0x1.0000004014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdff5f), -0x1.00000040142p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020800), 0x1.00000041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdf7ff), -0x1.00000041002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020802), 0x1.00000041004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdf7fd), -0x1.00000041006p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020808), 0x1.0000004101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdf7f7), -0x1.00000041012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000020880), 0x1.000000411p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdf77f), -0x1.00000041102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000021000), 0x1.00000042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdefff), -0x1.00000042002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000021002), 0x1.00000042004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdeffd), -0x1.00000042006p+43, 0x0p+0 },
+{ INT64_C(0x0000080000021010), 0x1.0000004202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdefef), -0x1.00000042022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000021040), 0x1.0000004208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdefbf), -0x1.00000042082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000021100), 0x1.000000422p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffdeeff), -0x1.00000042202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000030000), 0x1.0000006p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffcffff), -0x1.00000060002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000030001), 0x1.00000060002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffcfffe), -0x1.00000060004p+43, 0x0p+0 },
+{ INT64_C(0x0000080000030004), 0x1.00000060008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffcfffb), -0x1.0000006000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000030020), 0x1.0000006004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffcffdf), -0x1.00000060042p+43, 0x0p+0 },
+{ INT64_C(0x0000080000030200), 0x1.000000604p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffcfdff), -0x1.00000060402p+43, 0x0p+0 },
+{ INT64_C(0x0000080000030800), 0x1.00000061p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffcf7ff), -0x1.00000061002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000038000), 0x1.0000007p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffc7fff), -0x1.00000070002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040008), 0x1.0000008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfff7), -0x1.00000080012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040009), 0x1.00000080012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfff6), -0x1.00000080014p+43, 0x0p+0 },
+{ INT64_C(0x000008000004000c), 0x1.00000080018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfff3), -0x1.0000008001ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000040040), 0x1.0000008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbffbf), -0x1.00000080082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040044), 0x1.00000080088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbffbb), -0x1.0000008008ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000040048), 0x1.0000008009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbffb7), -0x1.00000080092p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040100), 0x1.000000802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfeff), -0x1.00000080202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040101), 0x1.00000080202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfefe), -0x1.00000080204p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040102), 0x1.00000080204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfefd), -0x1.00000080206p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040110), 0x1.0000008022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbfeef), -0x1.00000080222p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040800), 0x1.00000081p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbf7ff), -0x1.00000081002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040802), 0x1.00000081004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbf7fd), -0x1.00000081006p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040820), 0x1.0000008104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbf7df), -0x1.00000081042p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040840), 0x1.0000008108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbf7bf), -0x1.00000081082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000040c00), 0x1.000000818p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffbf3ff), -0x1.00000081802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048000), 0x1.0000009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7fff), -0x1.00000090002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048001), 0x1.00000090002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7ffe), -0x1.00000090004p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048004), 0x1.00000090008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7ffb), -0x1.0000009000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000048008), 0x1.0000009001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7ff7), -0x1.00000090012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048010), 0x1.0000009002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7fef), -0x1.00000090022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048080), 0x1.000000901p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7f7f), -0x1.00000090102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048100), 0x1.000000902p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7eff), -0x1.00000090202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000048400), 0x1.000000908p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb7bff), -0x1.00000090802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000049000), 0x1.00000092p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb6fff), -0x1.00000092002p+43, 0x0p+0 },
+{ INT64_C(0x000008000004a000), 0x1.00000094p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb5fff), -0x1.00000094002p+43, 0x0p+0 },
+{ INT64_C(0x000008000004c000), 0x1.00000098p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffffb3fff), -0x1.00000098002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080001), 0x1.00000100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7fffe), -0x1.00000100004p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080002), 0x1.00000100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7fffd), -0x1.00000100006p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080003), 0x1.00000100006p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7fffc), -0x1.00000100008p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080010), 0x1.0000010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffef), -0x1.00000100022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080012), 0x1.00000100024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffed), -0x1.00000100026p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080014), 0x1.00000100028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffeb), -0x1.0000010002ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000080020), 0x1.0000010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffdf), -0x1.00000100042p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080021), 0x1.00000100042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffde), -0x1.00000100044p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080022), 0x1.00000100044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffdd), -0x1.00000100046p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080030), 0x1.0000010006p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffcf), -0x1.00000100062p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080040), 0x1.0000010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffbf), -0x1.00000100082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080042), 0x1.00000100084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ffbd), -0x1.00000100086p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080060), 0x1.000001000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7ff9f), -0x1.000001000c2p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080100), 0x1.000001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7feff), -0x1.00000100202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080104), 0x1.00000100208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7fefb), -0x1.0000010020ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000080140), 0x1.0000010028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7febf), -0x1.00000100282p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080800), 0x1.00000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7f7ff), -0x1.00000101002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080808), 0x1.0000010101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7f7f7), -0x1.00000101012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080810), 0x1.0000010102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7f7ef), -0x1.00000101022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080840), 0x1.0000010108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7f7bf), -0x1.00000101082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000080900), 0x1.000001012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff7f6ff), -0x1.00000101202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000088000), 0x1.0000011p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff77fff), -0x1.00000110002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000088004), 0x1.00000110008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff77ffb), -0x1.0000011000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000088040), 0x1.0000011008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff77fbf), -0x1.00000110082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000088200), 0x1.000001104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff77dff), -0x1.00000110402p+43, 0x0p+0 },
+{ INT64_C(0x000008000008a000), 0x1.00000114p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff75fff), -0x1.00000114002p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c0000), 0x1.0000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3ffff), -0x1.00000180002p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c0001), 0x1.00000180002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3fffe), -0x1.00000180004p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c0004), 0x1.00000180008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3fffb), -0x1.0000018000ap+43, 0x0p+0 },
+{ INT64_C(0x00000800000c0020), 0x1.0000018004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3ffdf), -0x1.00000180042p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c0040), 0x1.0000018008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3ffbf), -0x1.00000180082p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c0100), 0x1.000001802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3feff), -0x1.00000180202p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c1000), 0x1.00000182p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3efff), -0x1.00000182002p+43, 0x0p+0 },
+{ INT64_C(0x00000800000c2000), 0x1.00000184p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff3dfff), -0x1.00000184002p+43, 0x0p+0 },
+{ INT64_C(0x00000800000e0000), 0x1.000001cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffff1ffff), -0x1.000001c0002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100008), 0x1.0000020001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeffff7), -0x1.00000200012p+43, 0x0p+0 },
+{ INT64_C(0x000008000010000a), 0x1.00000200014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeffff5), -0x1.00000200016p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100040), 0x1.0000020008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefffbf), -0x1.00000200082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100042), 0x1.00000200084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefffbd), -0x1.00000200086p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100048), 0x1.0000020009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefffb7), -0x1.00000200092p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100060), 0x1.000002000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefff9f), -0x1.000002000c2p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100100), 0x1.000002002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeffeff), -0x1.00000200202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100108), 0x1.0000020021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeffef7), -0x1.00000200212p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100110), 0x1.0000020022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeffeef), -0x1.00000200222p+43, 0x0p+0 },
+{ INT64_C(0x0000080000100140), 0x1.0000020028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeffebf), -0x1.00000200282p+43, 0x0p+0 },
+{ INT64_C(0x0000080000101000), 0x1.00000202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefefff), -0x1.00000202002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000101001), 0x1.00000202002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefeffe), -0x1.00000202004p+43, 0x0p+0 },
+{ INT64_C(0x0000080000101002), 0x1.00000202004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefeffd), -0x1.00000202006p+43, 0x0p+0 },
+{ INT64_C(0x0000080000101010), 0x1.0000020202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefefef), -0x1.00000202022p+43, 0x0p+0 },
+{ INT64_C(0x0000080000101100), 0x1.000002022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefeeff), -0x1.00000202202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000101200), 0x1.000002024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefedff), -0x1.00000202402p+43, 0x0p+0 },
+{ INT64_C(0x0000080000102000), 0x1.00000204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefdfff), -0x1.00000204002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000102008), 0x1.0000020401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefdff7), -0x1.00000204012p+43, 0x0p+0 },
+{ INT64_C(0x0000080000102080), 0x1.000002041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefdf7f), -0x1.00000204102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000102200), 0x1.000002044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefddff), -0x1.00000204402p+43, 0x0p+0 },
+{ INT64_C(0x0000080000102800), 0x1.00000205p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffefd7ff), -0x1.00000205002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000110000), 0x1.0000022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeeffff), -0x1.00000220002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000110004), 0x1.00000220008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeefffb), -0x1.0000022000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000110020), 0x1.0000022004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeeffdf), -0x1.00000220042p+43, 0x0p+0 },
+{ INT64_C(0x0000080000110080), 0x1.000002201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeeff7f), -0x1.00000220102p+43, 0x0p+0 },
+{ INT64_C(0x0000080000110100), 0x1.000002202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeefeff), -0x1.00000220202p+43, 0x0p+0 },
+{ INT64_C(0x0000080000110200), 0x1.000002204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeefdff), -0x1.00000220402p+43, 0x0p+0 },
+{ INT64_C(0x0000080000112000), 0x1.00000224p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffeedfff), -0x1.00000224002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000118000), 0x1.0000023p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffee7fff), -0x1.00000230002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000180000), 0x1.000003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7ffff), -0x1.00000300002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000180004), 0x1.00000300008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7fffb), -0x1.0000030000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080000180020), 0x1.0000030004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7ffdf), -0x1.00000300042p+43, 0x0p+0 },
+{ INT64_C(0x0000080000180040), 0x1.0000030008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7ffbf), -0x1.00000300082p+43, 0x0p+0 },
+{ INT64_C(0x0000080000180200), 0x1.000003004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7fdff), -0x1.00000300402p+43, 0x0p+0 },
+{ INT64_C(0x0000080000180400), 0x1.000003008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7fbff), -0x1.00000300802p+43, 0x0p+0 },
+{ INT64_C(0x0000080000182000), 0x1.00000304p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe7dfff), -0x1.00000304002p+43, 0x0p+0 },
+{ INT64_C(0x0000080000188000), 0x1.0000031p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe77fff), -0x1.00000310002p+43, 0x0p+0 },
+{ INT64_C(0x00000800001a0000), 0x1.0000034p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffffe5ffff), -0x1.00000340002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001000001), 0x1.00002000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefffffe), -0x1.00002000004p+43, 0x0p+0 },
+{ INT64_C(0x0000080001000010), 0x1.0000200002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffffef), -0x1.00002000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080001000012), 0x1.00002000024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffffed), -0x1.00002000026p+43, 0x0p+0 },
+{ INT64_C(0x0000080001000100), 0x1.000020002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefffeff), -0x1.00002000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080001000108), 0x1.0000200021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefffef7), -0x1.00002000212p+43, 0x0p+0 },
+{ INT64_C(0x0000080001000180), 0x1.000020003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefffe7f), -0x1.00002000302p+43, 0x0p+0 },
+{ INT64_C(0x0000080001001000), 0x1.00002002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffefff), -0x1.00002002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001001002), 0x1.00002002004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffeffd), -0x1.00002002006p+43, 0x0p+0 },
+{ INT64_C(0x0000080001001008), 0x1.0000200201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffeff7), -0x1.00002002012p+43, 0x0p+0 },
+{ INT64_C(0x0000080001001040), 0x1.0000200208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffefbf), -0x1.00002002082p+43, 0x0p+0 },
+{ INT64_C(0x0000080001001200), 0x1.000020024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeffedff), -0x1.00002002402p+43, 0x0p+0 },
+{ INT64_C(0x0000080001010000), 0x1.0000202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefeffff), -0x1.00002020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001010008), 0x1.0000202001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefefff7), -0x1.00002020012p+43, 0x0p+0 },
+{ INT64_C(0x0000080001010010), 0x1.0000202002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefeffef), -0x1.00002020022p+43, 0x0p+0 },
+{ INT64_C(0x0000080001010080), 0x1.000020201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefeff7f), -0x1.00002020102p+43, 0x0p+0 },
+{ INT64_C(0x0000080001010800), 0x1.00002021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefef7ff), -0x1.00002021002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001012000), 0x1.00002024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffefedfff), -0x1.00002024002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001100000), 0x1.000022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeefffff), -0x1.00002200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001100008), 0x1.0000220001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeeffff7), -0x1.00002200012p+43, 0x0p+0 },
+{ INT64_C(0x0000080001100020), 0x1.0000220004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeefffdf), -0x1.00002200042p+43, 0x0p+0 },
+{ INT64_C(0x0000080001100200), 0x1.000022004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeeffdff), -0x1.00002200402p+43, 0x0p+0 },
+{ INT64_C(0x0000080001100400), 0x1.000022008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeeffbff), -0x1.00002200802p+43, 0x0p+0 },
+{ INT64_C(0x0000080001104000), 0x1.00002208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeefbfff), -0x1.00002208002p+43, 0x0p+0 },
+{ INT64_C(0x0000080001120000), 0x1.0000224p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fffeedffff), -0x1.00002240002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000001), 0x1.00010000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffffe), -0x1.00010000004p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000004), 0x1.00010000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffffb), -0x1.0001000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080008000040), 0x1.0001000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffffbf), -0x1.00010000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000042), 0x1.00010000084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffffbd), -0x1.00010000086p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000060), 0x1.000100000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffff9f), -0x1.000100000c2p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000200), 0x1.000100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffdff), -0x1.00010000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000204), 0x1.00010000408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffdfb), -0x1.0001000040ap+43, 0x0p+0 },
+{ INT64_C(0x0000080008000208), 0x1.0001000041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffdf7), -0x1.00010000412p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000210), 0x1.0001000042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffdef), -0x1.00010000422p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000280), 0x1.000100005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffd7f), -0x1.00010000502p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000300), 0x1.000100006p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffcff), -0x1.00010000602p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000400), 0x1.000100008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffbff), -0x1.00010000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000404), 0x1.00010000808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffbfb), -0x1.0001000080ap+43, 0x0p+0 },
+{ INT64_C(0x0000080008000440), 0x1.0001000088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fffbbf), -0x1.00010000882p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000600), 0x1.00010000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fff9ff), -0x1.00010000c02p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000800), 0x1.00010001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fff7ff), -0x1.00010001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000801), 0x1.00010001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fff7fe), -0x1.00010001004p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000808), 0x1.0001000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fff7f7), -0x1.00010001012p+43, 0x0p+0 },
+{ INT64_C(0x0000080008000880), 0x1.000100011p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fff77f), -0x1.00010001102p+43, 0x0p+0 },
+{ INT64_C(0x0000080008004000), 0x1.00010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffbfff), -0x1.00010008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008004008), 0x1.0001000801p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffbff7), -0x1.00010008012p+43, 0x0p+0 },
+{ INT64_C(0x0000080008004080), 0x1.000100081p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffbf7f), -0x1.00010008102p+43, 0x0p+0 },
+{ INT64_C(0x0000080008004200), 0x1.000100084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffbdff), -0x1.00010008402p+43, 0x0p+0 },
+{ INT64_C(0x0000080008004400), 0x1.000100088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffbbff), -0x1.00010008802p+43, 0x0p+0 },
+{ INT64_C(0x0000080008004800), 0x1.00010009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7ffb7ff), -0x1.00010009002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010000), 0x1.0001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7feffff), -0x1.00010020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010001), 0x1.00010020002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fefffe), -0x1.00010020004p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010004), 0x1.00010020008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fefffb), -0x1.0001002000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080008010020), 0x1.0001002004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7feffdf), -0x1.00010020042p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010040), 0x1.0001002008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7feffbf), -0x1.00010020082p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010080), 0x1.000100201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7feff7f), -0x1.00010020102p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010200), 0x1.000100204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fefdff), -0x1.00010020402p+43, 0x0p+0 },
+{ INT64_C(0x0000080008010400), 0x1.000100208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fefbff), -0x1.00010020802p+43, 0x0p+0 },
+{ INT64_C(0x0000080008012000), 0x1.00010024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fedfff), -0x1.00010024002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008040000), 0x1.0001008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fbffff), -0x1.00010080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008040008), 0x1.0001008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fbfff7), -0x1.00010080012p+43, 0x0p+0 },
+{ INT64_C(0x0000080008040020), 0x1.0001008004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fbffdf), -0x1.00010080042p+43, 0x0p+0 },
+{ INT64_C(0x0000080008040040), 0x1.0001008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fbffbf), -0x1.00010080082p+43, 0x0p+0 },
+{ INT64_C(0x0000080008040200), 0x1.000100804p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fbfdff), -0x1.00010080402p+43, 0x0p+0 },
+{ INT64_C(0x0000080008041000), 0x1.00010082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fbefff), -0x1.00010082002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008048000), 0x1.0001009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7fb7fff), -0x1.00010090002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008080000), 0x1.000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7ffff), -0x1.00010100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008080008), 0x1.0001010001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7fff7), -0x1.00010100012p+43, 0x0p+0 },
+{ INT64_C(0x0000080008080010), 0x1.0001010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7ffef), -0x1.00010100022p+43, 0x0p+0 },
+{ INT64_C(0x0000080008080020), 0x1.0001010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7ffdf), -0x1.00010100042p+43, 0x0p+0 },
+{ INT64_C(0x0000080008080080), 0x1.000101001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7ff7f), -0x1.00010100102p+43, 0x0p+0 },
+{ INT64_C(0x0000080008080400), 0x1.000101008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7fbff), -0x1.00010100802p+43, 0x0p+0 },
+{ INT64_C(0x0000080008082000), 0x1.00010104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f7dfff), -0x1.00010104002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008090000), 0x1.0001012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7f6ffff), -0x1.00010120002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008100000), 0x1.000102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7efffff), -0x1.00010200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008100004), 0x1.00010200008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7effffb), -0x1.0001020000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080008100020), 0x1.0001020004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7efffdf), -0x1.00010200042p+43, 0x0p+0 },
+{ INT64_C(0x0000080008100080), 0x1.000102001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7efff7f), -0x1.00010200102p+43, 0x0p+0 },
+{ INT64_C(0x0000080008100200), 0x1.000102004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7effdff), -0x1.00010200402p+43, 0x0p+0 },
+{ INT64_C(0x0000080008100800), 0x1.00010201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7eff7ff), -0x1.00010201002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008102000), 0x1.00010204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7efdfff), -0x1.00010204002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008120000), 0x1.0001024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7edffff), -0x1.00010240002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008400000), 0x1.000108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bfffff), -0x1.00010800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008400008), 0x1.0001080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bffff7), -0x1.00010800012p+43, 0x0p+0 },
+{ INT64_C(0x0000080008400020), 0x1.0001080004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bfffdf), -0x1.00010800042p+43, 0x0p+0 },
+{ INT64_C(0x0000080008400080), 0x1.000108001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bfff7f), -0x1.00010800102p+43, 0x0p+0 },
+{ INT64_C(0x0000080008400800), 0x1.00010801p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bff7ff), -0x1.00010801002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008404000), 0x1.00010808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bfbfff), -0x1.00010808002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008440000), 0x1.0001088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7bbffff), -0x1.00010880002p+43, 0x0p+0 },
+{ INT64_C(0x0000080008480000), 0x1.000109p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff7b7ffff), -0x1.00010900002p+43, 0x0p+0 },
+{ INT64_C(0x000008000c000000), 0x1.00018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3ffffff), -0x1.00018000002p+43, 0x0p+0 },
+{ INT64_C(0x000008000c000008), 0x1.0001800001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3fffff7), -0x1.00018000012p+43, 0x0p+0 },
+{ INT64_C(0x000008000c000040), 0x1.0001800008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3ffffbf), -0x1.00018000082p+43, 0x0p+0 },
+{ INT64_C(0x000008000c000100), 0x1.000180002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3fffeff), -0x1.00018000202p+43, 0x0p+0 },
+{ INT64_C(0x000008000c000400), 0x1.000180008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3fffbff), -0x1.00018000802p+43, 0x0p+0 },
+{ INT64_C(0x000008000c004000), 0x1.00018008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3ffbfff), -0x1.00018008002p+43, 0x0p+0 },
+{ INT64_C(0x000008000c040000), 0x1.0001808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3fbffff), -0x1.00018080002p+43, 0x0p+0 },
+{ INT64_C(0x000008000c100000), 0x1.000182p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff3efffff), -0x1.00018200002p+43, 0x0p+0 },
+{ INT64_C(0x000008000c800000), 0x1.00019p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fff37fffff), -0x1.00019000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000002), 0x1.00080000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbffffffd), -0x1.00080000006p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000010), 0x1.0008000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffffef), -0x1.00080000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000018), 0x1.0008000003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffffe7), -0x1.00080000032p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000040), 0x1.0008000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffffbf), -0x1.00080000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000041), 0x1.00080000082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffffbe), -0x1.00080000084p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000044), 0x1.00080000088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffffbb), -0x1.0008000008ap+43, 0x0p+0 },
+{ INT64_C(0x0000080040000060), 0x1.000800000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffff9f), -0x1.000800000c2p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000400), 0x1.000800008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbffffbff), -0x1.00080000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000404), 0x1.00080000808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbffffbfb), -0x1.0008000080ap+43, 0x0p+0 },
+{ INT64_C(0x0000080040000408), 0x1.0008000081p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbffffbf7), -0x1.00080000812p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000420), 0x1.0008000084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbffffbdf), -0x1.00080000842p+43, 0x0p+0 },
+{ INT64_C(0x0000080040000600), 0x1.00080000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbffff9ff), -0x1.00080000c02p+43, 0x0p+0 },
+{ INT64_C(0x0000080040001000), 0x1.00080002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffefff), -0x1.00080002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040001008), 0x1.0008000201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffeff7), -0x1.00080002012p+43, 0x0p+0 },
+{ INT64_C(0x0000080040001020), 0x1.0008000204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffefdf), -0x1.00080002042p+43, 0x0p+0 },
+{ INT64_C(0x0000080040001040), 0x1.0008000208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffefbf), -0x1.00080002082p+43, 0x0p+0 },
+{ INT64_C(0x0000080040001400), 0x1.000800028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffebff), -0x1.00080002802p+43, 0x0p+0 },
+{ INT64_C(0x0000080040001800), 0x1.00080003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffe7ff), -0x1.00080003002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040004000), 0x1.00080008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffbfff), -0x1.00080008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040004004), 0x1.00080008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffbffb), -0x1.0008000800ap+43, 0x0p+0 },
+{ INT64_C(0x0000080040004010), 0x1.0008000802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffbfef), -0x1.00080008022p+43, 0x0p+0 },
+{ INT64_C(0x0000080040004100), 0x1.000800082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffbeff), -0x1.00080008202p+43, 0x0p+0 },
+{ INT64_C(0x0000080040005000), 0x1.0008000ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfffafff), -0x1.0008000a002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040008000), 0x1.0008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff7fff), -0x1.00080010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040008008), 0x1.0008001001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff7ff7), -0x1.00080010012p+43, 0x0p+0 },
+{ INT64_C(0x0000080040008020), 0x1.0008001004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff7fdf), -0x1.00080010042p+43, 0x0p+0 },
+{ INT64_C(0x0000080040008040), 0x1.0008001008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff7fbf), -0x1.00080010082p+43, 0x0p+0 },
+{ INT64_C(0x0000080040008100), 0x1.000800102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff7eff), -0x1.00080010202p+43, 0x0p+0 },
+{ INT64_C(0x0000080040009000), 0x1.00080012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff6fff), -0x1.00080012002p+43, 0x0p+0 },
+{ INT64_C(0x000008004000c000), 0x1.00080018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfff3fff), -0x1.00080018002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040080000), 0x1.000801p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7ffff), -0x1.00080100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040080002), 0x1.00080100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7fffd), -0x1.00080100006p+43, 0x0p+0 },
+{ INT64_C(0x0000080040080010), 0x1.0008010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7ffef), -0x1.00080100022p+43, 0x0p+0 },
+{ INT64_C(0x0000080040080080), 0x1.000801001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7ff7f), -0x1.00080100102p+43, 0x0p+0 },
+{ INT64_C(0x0000080040080100), 0x1.000801002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7feff), -0x1.00080100202p+43, 0x0p+0 },
+{ INT64_C(0x0000080040080400), 0x1.000801008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7fbff), -0x1.00080100802p+43, 0x0p+0 },
+{ INT64_C(0x0000080040084000), 0x1.00080108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff7bfff), -0x1.00080108002p+43, 0x0p+0 },
+{ INT64_C(0x00000800400a0000), 0x1.0008014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbff5ffff), -0x1.00080140002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040100000), 0x1.000802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfefffff), -0x1.00080200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040100001), 0x1.00080200002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfeffffe), -0x1.00080200004p+43, 0x0p+0 },
+{ INT64_C(0x0000080040100008), 0x1.0008020001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfeffff7), -0x1.00080200012p+43, 0x0p+0 },
+{ INT64_C(0x0000080040100080), 0x1.000802001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfefff7f), -0x1.00080200102p+43, 0x0p+0 },
+{ INT64_C(0x0000080040100200), 0x1.000802004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfeffdff), -0x1.00080200402p+43, 0x0p+0 },
+{ INT64_C(0x0000080040100400), 0x1.000802008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfeffbff), -0x1.00080200802p+43, 0x0p+0 },
+{ INT64_C(0x0000080040101000), 0x1.00080202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfefefff), -0x1.00080202002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040102000), 0x1.00080204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfefdfff), -0x1.00080204002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040104000), 0x1.00080208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfefbfff), -0x1.00080208002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040110000), 0x1.0008022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfeeffff), -0x1.00080220002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040180000), 0x1.000803p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfe7ffff), -0x1.00080300002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040400000), 0x1.000808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbfffff), -0x1.00080800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040400001), 0x1.00080800002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbffffe), -0x1.00080800004p+43, 0x0p+0 },
+{ INT64_C(0x0000080040400008), 0x1.0008080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbffff7), -0x1.00080800012p+43, 0x0p+0 },
+{ INT64_C(0x0000080040400080), 0x1.000808001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbfff7f), -0x1.00080800102p+43, 0x0p+0 },
+{ INT64_C(0x0000080040400400), 0x1.000808008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbffbff), -0x1.00080800802p+43, 0x0p+0 },
+{ INT64_C(0x0000080040404000), 0x1.00080808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbfbfff), -0x1.00080808002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040408000), 0x1.0008081p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbf7fff), -0x1.00080810002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040410000), 0x1.0008082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbeffff), -0x1.00080820002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040420000), 0x1.0008084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfbdffff), -0x1.00080840002p+43, 0x0p+0 },
+{ INT64_C(0x0000080040500000), 0x1.00080ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbfafffff), -0x1.00080a00002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042000000), 0x1.00084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdffffff), -0x1.00084000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042000001), 0x1.00084000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdfffffe), -0x1.00084000004p+43, 0x0p+0 },
+{ INT64_C(0x0000080042000010), 0x1.0008400002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdffffef), -0x1.00084000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080042000100), 0x1.000840002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdfffeff), -0x1.00084000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080042000200), 0x1.000840004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdfffdff), -0x1.00084000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080042000400), 0x1.000840008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdfffbff), -0x1.00084000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080042004000), 0x1.00084008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdffbfff), -0x1.00084008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042008000), 0x1.0008401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdff7fff), -0x1.00084010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042040000), 0x1.0008408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdfbffff), -0x1.00084080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042080000), 0x1.000841p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdf7ffff), -0x1.00084100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042100000), 0x1.000842p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdefffff), -0x1.00084200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042400000), 0x1.000848p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbdbfffff), -0x1.00084800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080042800000), 0x1.00085p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffbd7fffff), -0x1.00085000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080048000000), 0x1.0009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7ffffff), -0x1.00090000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080048000004), 0x1.00090000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7fffffb), -0x1.0009000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080048000010), 0x1.0009000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7ffffef), -0x1.00090000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080048000080), 0x1.000900001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7ffff7f), -0x1.00090000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080048000400), 0x1.000900008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7fffbff), -0x1.00090000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080048002000), 0x1.00090004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7ffdfff), -0x1.00090004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080048008000), 0x1.0009001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7ff7fff), -0x1.00090010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080048080000), 0x1.000901p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb7f7ffff), -0x1.00090100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080048800000), 0x1.00091p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ffb77fffff), -0x1.00091000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000004), 0x1.00100000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffffffb), -0x1.0010000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080080000040), 0x1.0010000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffffbf), -0x1.00100000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000041), 0x1.00100000082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffffbe), -0x1.00100000084p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000048), 0x1.0010000009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffffb7), -0x1.00100000092p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000060), 0x1.001000000cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffff9f), -0x1.001000000c2p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000400), 0x1.001000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffffbff), -0x1.00100000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000404), 0x1.00100000808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffffbfb), -0x1.0010000080ap+43, 0x0p+0 },
+{ INT64_C(0x0000080080000420), 0x1.0010000084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffffbdf), -0x1.00100000842p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000500), 0x1.00100000ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffffaff), -0x1.00100000a02p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000800), 0x1.00100001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffff7ff), -0x1.00100001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000804), 0x1.00100001008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffff7fb), -0x1.0010000100ap+43, 0x0p+0 },
+{ INT64_C(0x0000080080000808), 0x1.0010000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffff7f7), -0x1.00100001012p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000820), 0x1.0010000104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffff7df), -0x1.00100001042p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000900), 0x1.001000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffff6ff), -0x1.00100001202p+43, 0x0p+0 },
+{ INT64_C(0x0000080080000c00), 0x1.001000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffff3ff), -0x1.00100001802p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002000), 0x1.00100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffdfff), -0x1.00100004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002001), 0x1.00100004002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffdffe), -0x1.00100004004p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002008), 0x1.0010000401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffdff7), -0x1.00100004012p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002080), 0x1.001000041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffdf7f), -0x1.00100004102p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002100), 0x1.001000042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffdeff), -0x1.00100004202p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002400), 0x1.001000048p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffdbff), -0x1.00100004802p+43, 0x0p+0 },
+{ INT64_C(0x0000080080002800), 0x1.00100005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fffd7ff), -0x1.00100005002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080010000), 0x1.0010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffeffff), -0x1.00100020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080010004), 0x1.00100020008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffefffb), -0x1.0010002000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080080010010), 0x1.0010002002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffeffef), -0x1.00100020022p+43, 0x0p+0 },
+{ INT64_C(0x0000080080010040), 0x1.0010002008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffeffbf), -0x1.00100020082p+43, 0x0p+0 },
+{ INT64_C(0x0000080080010080), 0x1.001000201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffeff7f), -0x1.00100020102p+43, 0x0p+0 },
+{ INT64_C(0x0000080080010100), 0x1.001000202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffefeff), -0x1.00100020202p+43, 0x0p+0 },
+{ INT64_C(0x0000080080011000), 0x1.00100022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffeefff), -0x1.00100022002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080012000), 0x1.00100024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffedfff), -0x1.00100024002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080018000), 0x1.0010003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffe7fff), -0x1.00100030002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080020000), 0x1.0010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffdffff), -0x1.00100040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080020008), 0x1.0010004001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffdfff7), -0x1.00100040012p+43, 0x0p+0 },
+{ INT64_C(0x0000080080020010), 0x1.0010004002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffdffef), -0x1.00100040022p+43, 0x0p+0 },
+{ INT64_C(0x0000080080020100), 0x1.001000402p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffdfeff), -0x1.00100040202p+43, 0x0p+0 },
+{ INT64_C(0x0000080080020400), 0x1.001000408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffdfbff), -0x1.00100040802p+43, 0x0p+0 },
+{ INT64_C(0x0000080080022000), 0x1.00100044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffddfff), -0x1.00100044002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080028000), 0x1.0010005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ffd7fff), -0x1.00100050002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080080000), 0x1.001001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7ffff), -0x1.00100100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080080001), 0x1.00100100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7fffe), -0x1.00100100004p+43, 0x0p+0 },
+{ INT64_C(0x0000080080080004), 0x1.00100100008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7fffb), -0x1.0010010000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080080080020), 0x1.0010010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7ffdf), -0x1.00100100042p+43, 0x0p+0 },
+{ INT64_C(0x0000080080080040), 0x1.0010010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7ffbf), -0x1.00100100082p+43, 0x0p+0 },
+{ INT64_C(0x0000080080080080), 0x1.001001001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7ff7f), -0x1.00100100102p+43, 0x0p+0 },
+{ INT64_C(0x0000080080080200), 0x1.001001004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7fdff), -0x1.00100100402p+43, 0x0p+0 },
+{ INT64_C(0x0000080080082000), 0x1.00100104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7dfff), -0x1.00100104002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080084000), 0x1.00100108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff7bfff), -0x1.00100108002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080090000), 0x1.0010012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff6ffff), -0x1.00100120002p+43, 0x0p+0 },
+{ INT64_C(0x00000800800c0000), 0x1.0010018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ff3ffff), -0x1.00100180002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080400000), 0x1.001008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbfffff), -0x1.00100800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080400008), 0x1.0010080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbffff7), -0x1.00100800012p+43, 0x0p+0 },
+{ INT64_C(0x0000080080400020), 0x1.0010080004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbfffdf), -0x1.00100800042p+43, 0x0p+0 },
+{ INT64_C(0x0000080080400080), 0x1.001008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbfff7f), -0x1.00100800102p+43, 0x0p+0 },
+{ INT64_C(0x0000080080400100), 0x1.001008002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbffeff), -0x1.00100800202p+43, 0x0p+0 },
+{ INT64_C(0x0000080080400200), 0x1.001008004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbffdff), -0x1.00100800402p+43, 0x0p+0 },
+{ INT64_C(0x0000080080401000), 0x1.00100802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbfefff), -0x1.00100802002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080402000), 0x1.00100804p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbfdfff), -0x1.00100804002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080420000), 0x1.0010084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fbdffff), -0x1.00100840002p+43, 0x0p+0 },
+{ INT64_C(0x0000080080500000), 0x1.00100ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7fafffff), -0x1.00100a00002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081000000), 0x1.00102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7effffff), -0x1.00102000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081000008), 0x1.0010200001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7efffff7), -0x1.00102000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080081000080), 0x1.001020001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7effff7f), -0x1.00102000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080081000200), 0x1.001020004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7efffdff), -0x1.00102000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080081001000), 0x1.00102002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7effefff), -0x1.00102002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081002000), 0x1.00102004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7effdfff), -0x1.00102004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081020000), 0x1.0010204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7efdffff), -0x1.00102040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081100000), 0x1.001022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7eefffff), -0x1.00102200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081200000), 0x1.001024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7edfffff), -0x1.00102400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080081400000), 0x1.001028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7ebfffff), -0x1.00102800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082000000), 0x1.00104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dffffff), -0x1.00104000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082000008), 0x1.0010400001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dfffff7), -0x1.00104000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080082000080), 0x1.001040001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dffff7f), -0x1.00104000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080082000800), 0x1.00104001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dfff7ff), -0x1.00104001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082002000), 0x1.00104004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dffdfff), -0x1.00104004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082004000), 0x1.00104008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dffbfff), -0x1.00104008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082010000), 0x1.0010402p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dfeffff), -0x1.00104020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082040000), 0x1.0010408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7dfbffff), -0x1.00104080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080082100000), 0x1.001042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7defffff), -0x1.00104200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080083000000), 0x1.00106p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff7cffffff), -0x1.00106000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088000000), 0x1.0011p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77ffffff), -0x1.00110000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088000001), 0x1.00110000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77fffffe), -0x1.00110000004p+43, 0x0p+0 },
+{ INT64_C(0x0000080088000008), 0x1.0011000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77fffff7), -0x1.00110000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080088000080), 0x1.001100001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77ffff7f), -0x1.00110000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080088000400), 0x1.001100008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77fffbff), -0x1.00110000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080088000800), 0x1.00110001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77fff7ff), -0x1.00110001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088008000), 0x1.0011001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77ff7fff), -0x1.00110010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088010000), 0x1.0011002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77feffff), -0x1.00110020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088100000), 0x1.001102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77efffff), -0x1.00110200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088400000), 0x1.001108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff77bfffff), -0x1.00110800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080088800000), 0x1.00111p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff777fffff), -0x1.00111000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080089000000), 0x1.00112p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff76ffffff), -0x1.00112000002p+43, 0x0p+0 },
+{ INT64_C(0x000008008a000000), 0x1.00114p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff75ffffff), -0x1.00114000002p+43, 0x0p+0 },
+{ INT64_C(0x000008008c000000), 0x1.00118p+43, 0x0p+0 },
+{ INT64_C(0xfffff7ff73ffffff), -0x1.00118000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000008), 0x1.0040000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffff7), -0x1.00400000012p+43, 0x0p+0 },
+{ INT64_C(0x000008020000000a), 0x1.00400000014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffff5), -0x1.00400000016p+43, 0x0p+0 },
+{ INT64_C(0x000008020000000c), 0x1.00400000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffff3), -0x1.0040000001ap+43, 0x0p+0 },
+{ INT64_C(0x0000080200000010), 0x1.0040000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffffef), -0x1.00400000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000014), 0x1.00400000028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffffeb), -0x1.0040000002ap+43, 0x0p+0 },
+{ INT64_C(0x0000080200000040), 0x1.0040000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffffbf), -0x1.00400000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000042), 0x1.00400000084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffffbd), -0x1.00400000086p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000048), 0x1.0040000009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffffb7), -0x1.00400000092p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000080), 0x1.004000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffff7f), -0x1.00400000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000082), 0x1.00400000104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffff7d), -0x1.00400000106p+43, 0x0p+0 },
+{ INT64_C(0x00000802000000a0), 0x1.0040000014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffff5f), -0x1.00400000142p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000200), 0x1.004000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffdff), -0x1.00400000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000202), 0x1.00400000404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffdfd), -0x1.00400000406p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000220), 0x1.0040000044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffddf), -0x1.00400000442p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000240), 0x1.0040000048p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffdbf), -0x1.00400000482p+43, 0x0p+0 },
+{ INT64_C(0x0000080200000280), 0x1.004000005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffffd7f), -0x1.00400000502p+43, 0x0p+0 },
+{ INT64_C(0x0000080200002000), 0x1.00400004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffdfff), -0x1.00400004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200002002), 0x1.00400004004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffdffd), -0x1.00400004006p+43, 0x0p+0 },
+{ INT64_C(0x0000080200002020), 0x1.0040000404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffdfdf), -0x1.00400004042p+43, 0x0p+0 },
+{ INT64_C(0x0000080200002080), 0x1.004000041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffdf7f), -0x1.00400004102p+43, 0x0p+0 },
+{ INT64_C(0x0000080200002800), 0x1.00400005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffffd7ff), -0x1.00400005002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200008000), 0x1.0040001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffff7fff), -0x1.00400010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200008001), 0x1.00400010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffff7ffe), -0x1.00400010004p+43, 0x0p+0 },
+{ INT64_C(0x0000080200008010), 0x1.0040001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffff7fef), -0x1.00400010022p+43, 0x0p+0 },
+{ INT64_C(0x0000080200008100), 0x1.004000102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffff7eff), -0x1.00400010202p+43, 0x0p+0 },
+{ INT64_C(0x0000080200008400), 0x1.004000108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffff7bff), -0x1.00400010802p+43, 0x0p+0 },
+{ INT64_C(0x000008020000a000), 0x1.00400014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffff5fff), -0x1.00400014002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200040000), 0x1.0040008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffbffff), -0x1.00400080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200040001), 0x1.00400080002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffbfffe), -0x1.00400080004p+43, 0x0p+0 },
+{ INT64_C(0x0000080200040004), 0x1.00400080008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffbfffb), -0x1.0040008000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080200040040), 0x1.0040008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffbffbf), -0x1.00400080082p+43, 0x0p+0 },
+{ INT64_C(0x0000080200040400), 0x1.004000808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffbfbff), -0x1.00400080802p+43, 0x0p+0 },
+{ INT64_C(0x0000080200044000), 0x1.00400088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffbbfff), -0x1.00400088002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200048000), 0x1.0040009p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfffb7fff), -0x1.00400090002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200200000), 0x1.004004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffdfffff), -0x1.00400400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200200004), 0x1.00400400008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffdffffb), -0x1.0040040000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080200200040), 0x1.0040040008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffdfffbf), -0x1.00400400082p+43, 0x0p+0 },
+{ INT64_C(0x0000080200200400), 0x1.004004008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffdffbff), -0x1.00400400802p+43, 0x0p+0 },
+{ INT64_C(0x0000080200202000), 0x1.00400404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffdfdfff), -0x1.00400404002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200220000), 0x1.0040044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffddffff), -0x1.00400440002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200280000), 0x1.004005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffd7ffff), -0x1.00400500002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200400000), 0x1.004008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbfffff), -0x1.00400800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200400004), 0x1.00400800008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbffffb), -0x1.0040080000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080200400008), 0x1.0040080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbffff7), -0x1.00400800012p+43, 0x0p+0 },
+{ INT64_C(0x0000080200400040), 0x1.0040080008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbfffbf), -0x1.00400800082p+43, 0x0p+0 },
+{ INT64_C(0x0000080200400080), 0x1.004008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbfff7f), -0x1.00400800102p+43, 0x0p+0 },
+{ INT64_C(0x0000080200400800), 0x1.00400801p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbff7ff), -0x1.00400801002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200408000), 0x1.0040081p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbf7fff), -0x1.00400810002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200440000), 0x1.0040088p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffbbffff), -0x1.00400880002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200500000), 0x1.00400ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdffafffff), -0x1.00400a00002p+43, 0x0p+0 },
+{ INT64_C(0x0000080200600000), 0x1.00400cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdff9fffff), -0x1.00400c00002p+43, 0x0p+0 },
+{ INT64_C(0x0000080202000000), 0x1.00404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdffffff), -0x1.00404000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080202000002), 0x1.00404000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdfffffd), -0x1.00404000006p+43, 0x0p+0 },
+{ INT64_C(0x0000080202000008), 0x1.0040400001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdfffff7), -0x1.00404000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080202000080), 0x1.004040001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdffff7f), -0x1.00404000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080202000200), 0x1.004040004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdfffdff), -0x1.00404000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080202002000), 0x1.00404004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdffdfff), -0x1.00404004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080202008000), 0x1.0040401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdff7fff), -0x1.00404010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080202010000), 0x1.0040402p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdfeffff), -0x1.00404020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080202080000), 0x1.004041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdf7ffff), -0x1.00404100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080202100000), 0x1.004042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfdefffff), -0x1.00404200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080203000000), 0x1.00406p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfcffffff), -0x1.00406000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080204000000), 0x1.00408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbffffff), -0x1.00408000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080204000004), 0x1.00408000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbfffffb), -0x1.0040800000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080204000010), 0x1.0040800002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbffffef), -0x1.00408000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080204000040), 0x1.0040800008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbffffbf), -0x1.00408000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080204000400), 0x1.004080008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbfffbff), -0x1.00408000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080204004000), 0x1.00408008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbffbfff), -0x1.00408008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080204020000), 0x1.0040804p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbfdffff), -0x1.00408040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080204040000), 0x1.0040808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbfbffff), -0x1.00408080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080204100000), 0x1.004082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfbefffff), -0x1.00408200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080205000000), 0x1.0040ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdfaffffff), -0x1.0040a000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080220000000), 0x1.0044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddfffffff), -0x1.00440000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080220000008), 0x1.0044000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddffffff7), -0x1.00440000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080220000020), 0x1.0044000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddfffffdf), -0x1.00440000042p+43, 0x0p+0 },
+{ INT64_C(0x0000080220000100), 0x1.004400002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddffffeff), -0x1.00440000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080220001000), 0x1.00440002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddfffefff), -0x1.00440002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080220010000), 0x1.0044002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddffeffff), -0x1.00440020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080220020000), 0x1.0044004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddffdffff), -0x1.00440040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080220200000), 0x1.004404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddfdfffff), -0x1.00440400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080220800000), 0x1.00441p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddf7fffff), -0x1.00441000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080224000000), 0x1.00448p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fddbffffff), -0x1.00448000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240000000), 0x1.0048p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbfffffff), -0x1.00480000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240000008), 0x1.0048000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbffffff7), -0x1.00480000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080240000040), 0x1.0048000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbfffffbf), -0x1.00480000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080240000100), 0x1.004800002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbffffeff), -0x1.00480000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080240000200), 0x1.004800004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbffffdff), -0x1.00480000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080240000800), 0x1.00480001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbffff7ff), -0x1.00480001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240008000), 0x1.0048001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbfff7fff), -0x1.00480010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240020000), 0x1.0048004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbffdffff), -0x1.00480040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240100000), 0x1.004802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbfefffff), -0x1.00480200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240200000), 0x1.004804p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbfdfffff), -0x1.00480400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080240800000), 0x1.00481p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbf7fffff), -0x1.00481000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080242000000), 0x1.00484p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fdbdffffff), -0x1.00484000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080260000000), 0x1.004cp+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd9fffffff), -0x1.004c0000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080280000000), 0x1.005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7fffffff), -0x1.00500000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080280000004), 0x1.00500000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7ffffffb), -0x1.0050000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080280000008), 0x1.0050000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7ffffff7), -0x1.00500000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080280000040), 0x1.0050000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7fffffbf), -0x1.00500000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080280000200), 0x1.005000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7ffffdff), -0x1.00500000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080280000400), 0x1.005000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7ffffbff), -0x1.00500000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080280002000), 0x1.00500004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7fffdfff), -0x1.00500004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080280004000), 0x1.00500008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7fffbfff), -0x1.00500008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080280040000), 0x1.0050008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7ffbffff), -0x1.00500080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080280080000), 0x1.005001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7ff7ffff), -0x1.00500100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080280800000), 0x1.00501p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7f7fffff), -0x1.00501000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080281000000), 0x1.00502p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd7effffff), -0x1.00502000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080290000000), 0x1.0052p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fd6fffffff), -0x1.00520000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000008), 0x1.0080000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfffffff7), -0x1.00800000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000009), 0x1.00800000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfffffff6), -0x1.00800000014p+43, 0x0p+0 },
+{ INT64_C(0x000008040000000c), 0x1.00800000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfffffff3), -0x1.0080000001ap+43, 0x0p+0 },
+{ INT64_C(0x0000080400000010), 0x1.0080000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffef), -0x1.00800000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000011), 0x1.00800000022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffee), -0x1.00800000024p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000012), 0x1.00800000024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffed), -0x1.00800000026p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000018), 0x1.0080000003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffe7), -0x1.00800000032p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000020), 0x1.0080000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffdf), -0x1.00800000042p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000022), 0x1.00800000044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffdd), -0x1.00800000046p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000028), 0x1.0080000005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffffd7), -0x1.00800000052p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000080), 0x1.008000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffff7f), -0x1.00800000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000084), 0x1.00800000108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffff7b), -0x1.0080000010ap+43, 0x0p+0 },
+{ INT64_C(0x0000080400000090), 0x1.0080000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffff6f), -0x1.00800000122p+43, 0x0p+0 },
+{ INT64_C(0x00000804000000c0), 0x1.0080000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffff3f), -0x1.00800000182p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000200), 0x1.008000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfffffdff), -0x1.00800000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000208), 0x1.0080000041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfffffdf7), -0x1.00800000412p+43, 0x0p+0 },
+{ INT64_C(0x0000080400000240), 0x1.0080000048p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfffffdbf), -0x1.00800000482p+43, 0x0p+0 },
+{ INT64_C(0x0000080400002000), 0x1.00800004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffdfff), -0x1.00800004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400002008), 0x1.0080000401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffdff7), -0x1.00800004012p+43, 0x0p+0 },
+{ INT64_C(0x0000080400002040), 0x1.0080000408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffdfbf), -0x1.00800004082p+43, 0x0p+0 },
+{ INT64_C(0x0000080400002200), 0x1.008000044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffddff), -0x1.00800004402p+43, 0x0p+0 },
+{ INT64_C(0x0000080400002800), 0x1.00800005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffffd7ff), -0x1.00800005002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008000), 0x1.0080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7fff), -0x1.00800010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008008), 0x1.0080001001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7ff7), -0x1.00800010012p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008010), 0x1.0080001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7fef), -0x1.00800010022p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008020), 0x1.0080001004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7fdf), -0x1.00800010042p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008040), 0x1.0080001008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7fbf), -0x1.00800010082p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008100), 0x1.008000102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7eff), -0x1.00800010202p+43, 0x0p+0 },
+{ INT64_C(0x0000080400008400), 0x1.008000108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff7bff), -0x1.00800010802p+43, 0x0p+0 },
+{ INT64_C(0x0000080400009000), 0x1.00800012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffff6fff), -0x1.00800012002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400080000), 0x1.008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7ffff), -0x1.00800100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400080001), 0x1.00800100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7fffe), -0x1.00800100004p+43, 0x0p+0 },
+{ INT64_C(0x0000080400080002), 0x1.00800100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7fffd), -0x1.00800100006p+43, 0x0p+0 },
+{ INT64_C(0x0000080400080020), 0x1.0080010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7ffdf), -0x1.00800100042p+43, 0x0p+0 },
+{ INT64_C(0x0000080400080100), 0x1.008001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7feff), -0x1.00800100202p+43, 0x0p+0 },
+{ INT64_C(0x0000080400080200), 0x1.008001004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7fdff), -0x1.00800100402p+43, 0x0p+0 },
+{ INT64_C(0x0000080400081000), 0x1.00800102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff7efff), -0x1.00800102002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400090000), 0x1.0080012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff6ffff), -0x1.00800120002p+43, 0x0p+0 },
+{ INT64_C(0x00000804000a0000), 0x1.0080014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfff5ffff), -0x1.00800140002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400100000), 0x1.008002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffefffff), -0x1.00800200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400100002), 0x1.00800200004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffeffffd), -0x1.00800200006p+43, 0x0p+0 },
+{ INT64_C(0x0000080400100004), 0x1.00800200008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffeffffb), -0x1.0080020000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080400100020), 0x1.0080020004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffefffdf), -0x1.00800200042p+43, 0x0p+0 },
+{ INT64_C(0x0000080400100200), 0x1.008002004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffeffdff), -0x1.00800200402p+43, 0x0p+0 },
+{ INT64_C(0x0000080400100800), 0x1.00800201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffeff7ff), -0x1.00800201002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400108000), 0x1.0080021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffef7fff), -0x1.00800210002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400180000), 0x1.008003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffe7ffff), -0x1.00800300002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400200000), 0x1.008004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdfffff), -0x1.00800400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400200008), 0x1.0080040001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdffff7), -0x1.00800400012p+43, 0x0p+0 },
+{ INT64_C(0x0000080400200020), 0x1.0080040004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdfffdf), -0x1.00800400042p+43, 0x0p+0 },
+{ INT64_C(0x0000080400200080), 0x1.008004001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdfff7f), -0x1.00800400102p+43, 0x0p+0 },
+{ INT64_C(0x0000080400200100), 0x1.008004002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdffeff), -0x1.00800400202p+43, 0x0p+0 },
+{ INT64_C(0x0000080400200800), 0x1.00800401p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdff7ff), -0x1.00800401002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400201000), 0x1.00800402p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdfefff), -0x1.00800402002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400210000), 0x1.0080042p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffdeffff), -0x1.00800420002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400300000), 0x1.008006p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbffcfffff), -0x1.00800600002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400800000), 0x1.00801p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7fffff), -0x1.00801000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400800004), 0x1.00801000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7ffffb), -0x1.0080100000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080400800010), 0x1.0080100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7fffef), -0x1.00801000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080400800020), 0x1.0080100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7fffdf), -0x1.00801000042p+43, 0x0p+0 },
+{ INT64_C(0x0000080400800200), 0x1.008010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7ffdff), -0x1.00801000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080400801000), 0x1.00801002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7fefff), -0x1.00801002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400810000), 0x1.0080102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7effff), -0x1.00801020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400840000), 0x1.0080108p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff7bffff), -0x1.00801080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400900000), 0x1.008012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff6fffff), -0x1.00801200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080400c00000), 0x1.008018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbff3fffff), -0x1.00801800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401000000), 0x1.00802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfeffffff), -0x1.00802000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401000001), 0x1.00802000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfefffffe), -0x1.00802000004p+43, 0x0p+0 },
+{ INT64_C(0x0000080401000010), 0x1.0080200002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfeffffef), -0x1.00802000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080401000100), 0x1.008020002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfefffeff), -0x1.00802000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080401000800), 0x1.00802001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfefff7ff), -0x1.00802001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401008000), 0x1.0080201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfeff7fff), -0x1.00802010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401020000), 0x1.0080204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfefdffff), -0x1.00802040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401040000), 0x1.0080208p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfefbffff), -0x1.00802080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401080000), 0x1.008021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfef7ffff), -0x1.00802100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401200000), 0x1.008024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfedfffff), -0x1.00802400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080401800000), 0x1.00803p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfe7fffff), -0x1.00803000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080402000000), 0x1.00804p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdffffff), -0x1.00804000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080402000002), 0x1.00804000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdfffffd), -0x1.00804000006p+43, 0x0p+0 },
+{ INT64_C(0x0000080402000020), 0x1.0080400004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdffffdf), -0x1.00804000042p+43, 0x0p+0 },
+{ INT64_C(0x0000080402000200), 0x1.008040004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdfffdff), -0x1.00804000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080402000400), 0x1.008040008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdfffbff), -0x1.00804000802p+43, 0x0p+0 },
+{ INT64_C(0x0000080402004000), 0x1.00804008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdffbfff), -0x1.00804008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080402020000), 0x1.0080404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfdfdffff), -0x1.00804040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080402200000), 0x1.008044p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfddfffff), -0x1.00804400002p+43, 0x0p+0 },
+{ INT64_C(0x0000080403000000), 0x1.00806p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfcffffff), -0x1.00806000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080404000000), 0x1.00808p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbffffff), -0x1.00808000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080404000002), 0x1.00808000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbfffffd), -0x1.00808000006p+43, 0x0p+0 },
+{ INT64_C(0x0000080404000010), 0x1.0080800002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbffffef), -0x1.00808000022p+43, 0x0p+0 },
+{ INT64_C(0x0000080404000020), 0x1.0080800004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbffffdf), -0x1.00808000042p+43, 0x0p+0 },
+{ INT64_C(0x0000080404000200), 0x1.008080004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbfffdff), -0x1.00808000402p+43, 0x0p+0 },
+{ INT64_C(0x0000080404001000), 0x1.00808002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbffefff), -0x1.00808002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080404010000), 0x1.0080802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbfeffff), -0x1.00808020002p+43, 0x0p+0 },
+{ INT64_C(0x0000080404100000), 0x1.008082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfbefffff), -0x1.00808200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080405000000), 0x1.0080ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbfaffffff), -0x1.0080a000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420000000), 0x1.0084p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdfffffff), -0x1.00840000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420000002), 0x1.00840000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdffffffd), -0x1.00840000006p+43, 0x0p+0 },
+{ INT64_C(0x0000080420000008), 0x1.0084000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdffffff7), -0x1.00840000012p+43, 0x0p+0 },
+{ INT64_C(0x0000080420000080), 0x1.008400001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdfffff7f), -0x1.00840000102p+43, 0x0p+0 },
+{ INT64_C(0x0000080420000100), 0x1.008400002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdffffeff), -0x1.00840000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080420000800), 0x1.00840001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdffff7ff), -0x1.00840001002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420002000), 0x1.00840004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdfffdfff), -0x1.00840004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420008000), 0x1.0084001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdfff7fff), -0x1.00840010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420040000), 0x1.0084008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdffbffff), -0x1.00840080002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420100000), 0x1.008402p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdfefffff), -0x1.00840200002p+43, 0x0p+0 },
+{ INT64_C(0x0000080420400000), 0x1.008408p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdfbfffff), -0x1.00840800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080421000000), 0x1.00842p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbdeffffff), -0x1.00842000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080428000000), 0x1.0085p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbd7ffffff), -0x1.00850000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080430000000), 0x1.0086p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fbcfffffff), -0x1.00860000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500000000), 0x1.00ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffffffff), -0x1.00a00000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500000004), 0x1.00a00000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafffffffb), -0x1.00a0000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000080500000040), 0x1.00a0000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffffffbf), -0x1.00a00000082p+43, 0x0p+0 },
+{ INT64_C(0x0000080500000100), 0x1.00a000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafffffeff), -0x1.00a00000202p+43, 0x0p+0 },
+{ INT64_C(0x0000080500001000), 0x1.00a00002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffffefff), -0x1.00a00002002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500002000), 0x1.00a00004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffffdfff), -0x1.00a00004002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500004000), 0x1.00a00008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffffbfff), -0x1.00a00008002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500008000), 0x1.00a0001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffff7fff), -0x1.00a00010002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500020000), 0x1.00a0004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafffdffff), -0x1.00a00040002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500080000), 0x1.00a001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafff7ffff), -0x1.00a00100002p+43, 0x0p+0 },
+{ INT64_C(0x0000080500400000), 0x1.00a008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7faffbfffff), -0x1.00a00800002p+43, 0x0p+0 },
+{ INT64_C(0x0000080501000000), 0x1.00a02p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafeffffff), -0x1.00a02000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080502000000), 0x1.00a04p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafdffffff), -0x1.00a04000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080504000000), 0x1.00a08p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fafbffffff), -0x1.00a08000002p+43, 0x0p+0 },
+{ INT64_C(0x0000080520000000), 0x1.00a4p+43, 0x0p+0 },
+{ INT64_C(0xfffff7fadfffffff), -0x1.00a40000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000001), 0x1.08000000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffffe), -0x1.08000000004p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000010), 0x1.0800000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffffef), -0x1.08000000022p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000011), 0x1.08000000022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffffee), -0x1.08000000024p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000100), 0x1.080000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffeff), -0x1.08000000202p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000108), 0x1.0800000021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffef7), -0x1.08000000212p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000120), 0x1.0800000024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffedf), -0x1.08000000242p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000180), 0x1.080000003p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffe7f), -0x1.08000000302p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000200), 0x1.080000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffdff), -0x1.08000000402p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000202), 0x1.08000000404p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffdfd), -0x1.08000000406p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000208), 0x1.0800000041p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffdf7), -0x1.08000000412p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000280), 0x1.080000005p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffd7f), -0x1.08000000502p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000300), 0x1.080000006p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffffcff), -0x1.08000000602p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000800), 0x1.08000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffff7ff), -0x1.08000001002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000801), 0x1.08000001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffff7fe), -0x1.08000001004p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000808), 0x1.0800000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffff7f7), -0x1.08000001012p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000880), 0x1.080000011p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffff77f), -0x1.08000001102p+43, 0x0p+0 },
+{ INT64_C(0x0000084000000900), 0x1.080000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffff6ff), -0x1.08000001202p+43, 0x0p+0 },
+{ INT64_C(0x0000084000004000), 0x1.08000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffbfff), -0x1.08000008002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000004002), 0x1.08000008004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffbffd), -0x1.08000008006p+43, 0x0p+0 },
+{ INT64_C(0x0000084000004004), 0x1.08000008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffbffb), -0x1.0800000800ap+43, 0x0p+0 },
+{ INT64_C(0x0000084000004010), 0x1.0800000802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffbfef), -0x1.08000008022p+43, 0x0p+0 },
+{ INT64_C(0x0000084000004100), 0x1.080000082p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffbeff), -0x1.08000008202p+43, 0x0p+0 },
+{ INT64_C(0x0000084000005000), 0x1.0800000ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffffafff), -0x1.0800000a002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000010000), 0x1.0800002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffeffff), -0x1.08000020002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000010004), 0x1.08000020008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffefffb), -0x1.0800002000ap+43, 0x0p+0 },
+{ INT64_C(0x0000084000010008), 0x1.0800002001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffefff7), -0x1.08000020012p+43, 0x0p+0 },
+{ INT64_C(0x0000084000010080), 0x1.080000201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffeff7f), -0x1.08000020102p+43, 0x0p+0 },
+{ INT64_C(0x0000084000010200), 0x1.080000204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffefdff), -0x1.08000020402p+43, 0x0p+0 },
+{ INT64_C(0x0000084000012000), 0x1.08000024p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffffedfff), -0x1.08000024002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000080000), 0x1.080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff7ffff), -0x1.08000100002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000080008), 0x1.0800010001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff7fff7), -0x1.08000100012p+43, 0x0p+0 },
+{ INT64_C(0x0000084000080010), 0x1.0800010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff7ffef), -0x1.08000100022p+43, 0x0p+0 },
+{ INT64_C(0x0000084000080080), 0x1.080001001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff7ff7f), -0x1.08000100102p+43, 0x0p+0 },
+{ INT64_C(0x0000084000080800), 0x1.08000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff7f7ff), -0x1.08000101002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000088000), 0x1.0800011p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff77fff), -0x1.08000110002p+43, 0x0p+0 },
+{ INT64_C(0x00000840000a0000), 0x1.0800014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff5ffff), -0x1.08000140002p+43, 0x0p+0 },
+{ INT64_C(0x00000840000c0000), 0x1.0800018p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bffff3ffff), -0x1.08000180002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100000), 0x1.080002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffefffff), -0x1.08000200002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100008), 0x1.0800020001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffeffff7), -0x1.08000200012p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100020), 0x1.0800020004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffefffdf), -0x1.08000200042p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100040), 0x1.0800020008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffefffbf), -0x1.08000200082p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100080), 0x1.080002001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffefff7f), -0x1.08000200102p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100400), 0x1.080002008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffeffbff), -0x1.08000200802p+43, 0x0p+0 },
+{ INT64_C(0x0000084000100800), 0x1.08000201p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffeff7ff), -0x1.08000201002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000101000), 0x1.08000202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffefefff), -0x1.08000202002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000108000), 0x1.0800021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffef7fff), -0x1.08000210002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000110000), 0x1.0800022p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffeeffff), -0x1.08000220002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000140000), 0x1.0800028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfffebffff), -0x1.08000280002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000800000), 0x1.08001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7fffff), -0x1.08001000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000800004), 0x1.08001000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7ffffb), -0x1.0800100000ap+43, 0x0p+0 },
+{ INT64_C(0x0000084000800040), 0x1.0800100008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7fffbf), -0x1.08001000082p+43, 0x0p+0 },
+{ INT64_C(0x0000084000800080), 0x1.080010001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7fff7f), -0x1.08001000102p+43, 0x0p+0 },
+{ INT64_C(0x0000084000800400), 0x1.080010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7ffbff), -0x1.08001000802p+43, 0x0p+0 },
+{ INT64_C(0x0000084000801000), 0x1.08001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7fefff), -0x1.08001002002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000802000), 0x1.08001004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7fdfff), -0x1.08001004002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000810000), 0x1.0800102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff7effff), -0x1.08001020002p+43, 0x0p+0 },
+{ INT64_C(0x0000084000900000), 0x1.080012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfff6fffff), -0x1.08001200002p+43, 0x0p+0 },
+{ INT64_C(0x0000084008000000), 0x1.0801p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7ffffff), -0x1.08010000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084008000004), 0x1.08010000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7fffffb), -0x1.0801000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000084008000040), 0x1.0801000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7ffffbf), -0x1.08010000082p+43, 0x0p+0 },
+{ INT64_C(0x0000084008000200), 0x1.080100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7fffdff), -0x1.08010000402p+43, 0x0p+0 },
+{ INT64_C(0x0000084008002000), 0x1.08010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7ffdfff), -0x1.08010004002p+43, 0x0p+0 },
+{ INT64_C(0x0000084008004000), 0x1.08010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7ffbfff), -0x1.08010008002p+43, 0x0p+0 },
+{ INT64_C(0x0000084008020000), 0x1.0801004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7fdffff), -0x1.08010040002p+43, 0x0p+0 },
+{ INT64_C(0x0000084008040000), 0x1.0801008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7fbffff), -0x1.08010080002p+43, 0x0p+0 },
+{ INT64_C(0x0000084008200000), 0x1.080104p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff7dfffff), -0x1.08010400002p+43, 0x0p+0 },
+{ INT64_C(0x0000084009000000), 0x1.08012p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff6ffffff), -0x1.08012000002p+43, 0x0p+0 },
+{ INT64_C(0x000008400a000000), 0x1.08014p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bff5ffffff), -0x1.08014000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084010000000), 0x1.0802p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfefffffff), -0x1.08020000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084010000002), 0x1.08020000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfeffffffd), -0x1.08020000006p+43, 0x0p+0 },
+{ INT64_C(0x0000084010000008), 0x1.0802000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfeffffff7), -0x1.08020000012p+43, 0x0p+0 },
+{ INT64_C(0x0000084010000040), 0x1.0802000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfefffffbf), -0x1.08020000082p+43, 0x0p+0 },
+{ INT64_C(0x0000084010000100), 0x1.080200002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfeffffeff), -0x1.08020000202p+43, 0x0p+0 },
+{ INT64_C(0x0000084010001000), 0x1.08020002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfefffefff), -0x1.08020002002p+43, 0x0p+0 },
+{ INT64_C(0x0000084010010000), 0x1.0802002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfeffeffff), -0x1.08020020002p+43, 0x0p+0 },
+{ INT64_C(0x0000084010100000), 0x1.080202p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfefefffff), -0x1.08020200002p+43, 0x0p+0 },
+{ INT64_C(0x0000084010200000), 0x1.080204p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfefdfffff), -0x1.08020400002p+43, 0x0p+0 },
+{ INT64_C(0x0000084010800000), 0x1.08021p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfef7fffff), -0x1.08021000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084014000000), 0x1.08028p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bfebffffff), -0x1.08028000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084080000000), 0x1.081p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7fffffff), -0x1.08100000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084080000002), 0x1.08100000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7ffffffd), -0x1.08100000006p+43, 0x0p+0 },
+{ INT64_C(0x0000084080000010), 0x1.0810000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7fffffef), -0x1.08100000022p+43, 0x0p+0 },
+{ INT64_C(0x0000084080000100), 0x1.081000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7ffffeff), -0x1.08100000202p+43, 0x0p+0 },
+{ INT64_C(0x0000084080001000), 0x1.08100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7fffefff), -0x1.08100002002p+43, 0x0p+0 },
+{ INT64_C(0x0000084080008000), 0x1.0810001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7fff7fff), -0x1.08100010002p+43, 0x0p+0 },
+{ INT64_C(0x0000084080020000), 0x1.0810004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7ffdffff), -0x1.08100040002p+43, 0x0p+0 },
+{ INT64_C(0x0000084080100000), 0x1.081002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7fefffff), -0x1.08100200002p+43, 0x0p+0 },
+{ INT64_C(0x0000084081000000), 0x1.08102p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf7effffff), -0x1.08102000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084088000000), 0x1.0811p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf77ffffff), -0x1.08110000002p+43, 0x0p+0 },
+{ INT64_C(0x00000840a0000000), 0x1.0814p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf5fffffff), -0x1.08140000002p+43, 0x0p+0 },
+{ INT64_C(0x00000840c0000000), 0x1.0818p+43, 0x0p+0 },
+{ INT64_C(0xfffff7bf3fffffff), -0x1.08180000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800000000), 0x1.09p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7ffffffff), -0x1.09000000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800000004), 0x1.09000000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7fffffffb), -0x1.0900000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000084800000008), 0x1.0900000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7fffffff7), -0x1.09000000012p+43, 0x0p+0 },
+{ INT64_C(0x0000084800000040), 0x1.0900000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7ffffffbf), -0x1.09000000082p+43, 0x0p+0 },
+{ INT64_C(0x0000084800000200), 0x1.090000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7fffffdff), -0x1.09000000402p+43, 0x0p+0 },
+{ INT64_C(0x0000084800000800), 0x1.09000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7fffff7ff), -0x1.09000001002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800001000), 0x1.09000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7ffffefff), -0x1.09000002002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800004000), 0x1.09000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7ffffbfff), -0x1.09000008002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800040000), 0x1.0900008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7fffbffff), -0x1.09000080002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800200000), 0x1.090004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7ffdfffff), -0x1.09000400002p+43, 0x0p+0 },
+{ INT64_C(0x0000084800800000), 0x1.09001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7ff7fffff), -0x1.09001000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084801000000), 0x1.09002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7feffffff), -0x1.09002000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084804000000), 0x1.09008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7fbffffff), -0x1.09008000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084808000000), 0x1.0901p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7f7ffffff), -0x1.09010000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084820000000), 0x1.0904p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7dfffffff), -0x1.09040000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084840000000), 0x1.0908p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b7bfffffff), -0x1.09080000002p+43, 0x0p+0 },
+{ INT64_C(0x0000084c00000000), 0x1.098p+43, 0x0p+0 },
+{ INT64_C(0xfffff7b3ffffffff), -0x1.09800000002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000000), 0x1.0ap+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffffffff), -0x1.0a000000002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000002), 0x1.0a000000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7affffffffd), -0x1.0a000000006p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000008), 0x1.0a00000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7affffffff7), -0x1.0a000000012p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000010), 0x1.0a00000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffffffef), -0x1.0a000000022p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000040), 0x1.0a00000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffffffbf), -0x1.0a000000082p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000100), 0x1.0a0000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff7affffffeff), -0x1.0a000000202p+43, 0x0p+0 },
+{ INT64_C(0x0000085000000400), 0x1.0a0000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7affffffbff), -0x1.0a000000802p+43, 0x0p+0 },
+{ INT64_C(0x0000085000002000), 0x1.0a000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffffdfff), -0x1.0a000004002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000004000), 0x1.0a000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffffbfff), -0x1.0a000008002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000008000), 0x1.0a00001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffff7fff), -0x1.0a000010002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000080000), 0x1.0a0001p+43, 0x0p+0 },
+{ INT64_C(0xfffff7affff7ffff), -0x1.0a000100002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000200000), 0x1.0a0004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffdfffff), -0x1.0a000400002p+43, 0x0p+0 },
+{ INT64_C(0x0000085000400000), 0x1.0a0008p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afffbfffff), -0x1.0a000800002p+43, 0x0p+0 },
+{ INT64_C(0x0000085002000000), 0x1.0a004p+43, 0x0p+0 },
+{ INT64_C(0xfffff7affdffffff), -0x1.0a004000002p+43, 0x0p+0 },
+{ INT64_C(0x0000085020000000), 0x1.0a04p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afdfffffff), -0x1.0a040000002p+43, 0x0p+0 },
+{ INT64_C(0x0000085040000000), 0x1.0a08p+43, 0x0p+0 },
+{ INT64_C(0xfffff7afbfffffff), -0x1.0a080000002p+43, 0x0p+0 },
+{ INT64_C(0x0000085080000000), 0x1.0a1p+43, 0x0p+0 },
+{ INT64_C(0xfffff7af7fffffff), -0x1.0a100000002p+43, 0x0p+0 },
+{ INT64_C(0x0000085400000000), 0x1.0a8p+43, 0x0p+0 },
+{ INT64_C(0xfffff7abffffffff), -0x1.0a800000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000008), 0x1.2000000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffff7), -0x1.20000000012p+43, 0x0p+0 },
+{ INT64_C(0x000009000000000c), 0x1.20000000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffff3), -0x1.2000000001ap+43, 0x0p+0 },
+{ INT64_C(0x0000090000000020), 0x1.2000000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffffffdf), -0x1.20000000042p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000024), 0x1.20000000048p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffffffdb), -0x1.2000000004ap+43, 0x0p+0 },
+{ INT64_C(0x0000090000000030), 0x1.2000000006p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffffffcf), -0x1.20000000062p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000200), 0x1.200000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffdff), -0x1.20000000402p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000204), 0x1.20000000408p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffdfb), -0x1.2000000040ap+43, 0x0p+0 },
+{ INT64_C(0x0000090000000210), 0x1.2000000042p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffdef), -0x1.20000000422p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000240), 0x1.2000000048p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffdbf), -0x1.20000000482p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000280), 0x1.200000005p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffd7f), -0x1.20000000502p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000300), 0x1.200000006p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffffcff), -0x1.20000000602p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000800), 0x1.20000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffff7ff), -0x1.20000001002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000801), 0x1.20000001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffff7fe), -0x1.20000001004p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000810), 0x1.2000000102p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffff7ef), -0x1.20000001022p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000900), 0x1.200000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffff6ff), -0x1.20000001202p+43, 0x0p+0 },
+{ INT64_C(0x0000090000000a00), 0x1.200000014p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffffff5ff), -0x1.20000001402p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008000), 0x1.2000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7fff), -0x1.20000010002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008002), 0x1.20000010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7ffd), -0x1.20000010006p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008008), 0x1.2000001001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7ff7), -0x1.20000010012p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008010), 0x1.2000001002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7fef), -0x1.20000010022p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008080), 0x1.200000101p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7f7f), -0x1.20000010102p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008100), 0x1.200000102p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7eff), -0x1.20000010202p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008200), 0x1.200000104p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff7dff), -0x1.20000010402p+43, 0x0p+0 },
+{ INT64_C(0x0000090000008800), 0x1.20000011p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff77ff), -0x1.20000011002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000009000), 0x1.20000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff6fff), -0x1.20000012002p+43, 0x0p+0 },
+{ INT64_C(0x000009000000a000), 0x1.20000014p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffff5fff), -0x1.20000014002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000080000), 0x1.200001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff7ffff), -0x1.20000100002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000080004), 0x1.20000100008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff7fffb), -0x1.2000010000ap+43, 0x0p+0 },
+{ INT64_C(0x0000090000080010), 0x1.2000010002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff7ffef), -0x1.20000100022p+43, 0x0p+0 },
+{ INT64_C(0x0000090000080040), 0x1.2000010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff7ffbf), -0x1.20000100082p+43, 0x0p+0 },
+{ INT64_C(0x0000090000080200), 0x1.200001004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff7fdff), -0x1.20000100402p+43, 0x0p+0 },
+{ INT64_C(0x0000090000081000), 0x1.20000102p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff7efff), -0x1.20000102002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000090000), 0x1.2000012p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff6ffff), -0x1.20000120002p+43, 0x0p+0 },
+{ INT64_C(0x00000900000c0000), 0x1.2000018p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffff3ffff), -0x1.20000180002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000100000), 0x1.200002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffefffff), -0x1.20000200002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000100002), 0x1.20000200004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffeffffd), -0x1.20000200006p+43, 0x0p+0 },
+{ INT64_C(0x0000090000100020), 0x1.2000020004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffefffdf), -0x1.20000200042p+43, 0x0p+0 },
+{ INT64_C(0x0000090000100080), 0x1.200002001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffefff7f), -0x1.20000200102p+43, 0x0p+0 },
+{ INT64_C(0x0000090000100200), 0x1.200002004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffeffdff), -0x1.20000200402p+43, 0x0p+0 },
+{ INT64_C(0x0000090000102000), 0x1.20000204p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffefdfff), -0x1.20000204002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000104000), 0x1.20000208p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffefbfff), -0x1.20000208002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000108000), 0x1.2000021p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffef7fff), -0x1.20000210002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000140000), 0x1.2000028p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffebffff), -0x1.20000280002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000180000), 0x1.200003p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffe7ffff), -0x1.20000300002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400000), 0x1.200008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbfffff), -0x1.20000800002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400002), 0x1.20000800004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbffffd), -0x1.20000800006p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400008), 0x1.2000080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbffff7), -0x1.20000800012p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400020), 0x1.2000080004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbfffdf), -0x1.20000800042p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400080), 0x1.200008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbfff7f), -0x1.20000800102p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400400), 0x1.200008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbffbff), -0x1.20000800802p+43, 0x0p+0 },
+{ INT64_C(0x0000090000400800), 0x1.20000801p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbff7ff), -0x1.20000801002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000402000), 0x1.20000804p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbfdfff), -0x1.20000804002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000410000), 0x1.2000082p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffbeffff), -0x1.20000820002p+43, 0x0p+0 },
+{ INT64_C(0x0000090000500000), 0x1.20000ap+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffffafffff), -0x1.20000a00002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002000000), 0x1.20004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdffffff), -0x1.20004000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002000004), 0x1.20004000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdfffffb), -0x1.2000400000ap+43, 0x0p+0 },
+{ INT64_C(0x0000090002000008), 0x1.2000400001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdfffff7), -0x1.20004000012p+43, 0x0p+0 },
+{ INT64_C(0x0000090002000010), 0x1.2000400002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdffffef), -0x1.20004000022p+43, 0x0p+0 },
+{ INT64_C(0x0000090002000080), 0x1.200040001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdffff7f), -0x1.20004000102p+43, 0x0p+0 },
+{ INT64_C(0x0000090002000800), 0x1.20004001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdfff7ff), -0x1.20004001002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002002000), 0x1.20004004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdffdfff), -0x1.20004004002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002004000), 0x1.20004008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdffbfff), -0x1.20004008002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002040000), 0x1.2000408p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdfbffff), -0x1.20004080002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002100000), 0x1.200042p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffdefffff), -0x1.20004200002p+43, 0x0p+0 },
+{ INT64_C(0x0000090002800000), 0x1.20005p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffd7fffff), -0x1.20005000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004000000), 0x1.20008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbffffff), -0x1.20008000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004000004), 0x1.20008000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbfffffb), -0x1.2000800000ap+43, 0x0p+0 },
+{ INT64_C(0x0000090004000008), 0x1.2000800001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbfffff7), -0x1.20008000012p+43, 0x0p+0 },
+{ INT64_C(0x0000090004000080), 0x1.200080001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbffff7f), -0x1.20008000102p+43, 0x0p+0 },
+{ INT64_C(0x0000090004000800), 0x1.20008001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbfff7ff), -0x1.20008001002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004004000), 0x1.20008008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbffbfff), -0x1.20008008002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004008000), 0x1.2000801p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbff7fff), -0x1.20008010002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004020000), 0x1.2000804p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbfdffff), -0x1.20008040002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004040000), 0x1.2000808p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbfbffff), -0x1.20008080002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004080000), 0x1.200081p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbf7ffff), -0x1.20008100002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004100000), 0x1.200082p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffbefffff), -0x1.20008200002p+43, 0x0p+0 },
+{ INT64_C(0x0000090004800000), 0x1.20009p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fffb7fffff), -0x1.20009000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090008000000), 0x1.2001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7ffffff), -0x1.20010000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090008000004), 0x1.20010000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7fffffb), -0x1.2001000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000090008000040), 0x1.2001000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7ffffbf), -0x1.20010000082p+43, 0x0p+0 },
+{ INT64_C(0x0000090008000200), 0x1.200100004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7fffdff), -0x1.20010000402p+43, 0x0p+0 },
+{ INT64_C(0x0000090008002000), 0x1.20010004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7ffdfff), -0x1.20010004002p+43, 0x0p+0 },
+{ INT64_C(0x0000090008004000), 0x1.20010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7ffbfff), -0x1.20010008002p+43, 0x0p+0 },
+{ INT64_C(0x0000090008040000), 0x1.2001008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7fbffff), -0x1.20010080002p+43, 0x0p+0 },
+{ INT64_C(0x0000090008080000), 0x1.200101p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7f7ffff), -0x1.20010100002p+43, 0x0p+0 },
+{ INT64_C(0x0000090008400000), 0x1.200108p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff7bfffff), -0x1.20010800002p+43, 0x0p+0 },
+{ INT64_C(0x000009000a000000), 0x1.20014p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff5ffffff), -0x1.20014000002p+43, 0x0p+0 },
+{ INT64_C(0x000009000c000000), 0x1.20018p+43, 0x0p+0 },
+{ INT64_C(0xfffff6fff3ffffff), -0x1.20018000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010000000), 0x1.2002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffefffffff), -0x1.20020000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010000004), 0x1.20020000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffeffffffb), -0x1.2002000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000090010000040), 0x1.2002000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffefffffbf), -0x1.20020000082p+43, 0x0p+0 },
+{ INT64_C(0x0000090010000100), 0x1.200200002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffeffffeff), -0x1.20020000202p+43, 0x0p+0 },
+{ INT64_C(0x0000090010000200), 0x1.200200004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffeffffdff), -0x1.20020000402p+43, 0x0p+0 },
+{ INT64_C(0x0000090010001000), 0x1.20020002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffefffefff), -0x1.20020002002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010010000), 0x1.2002002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffeffeffff), -0x1.20020020002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010020000), 0x1.2002004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffeffdffff), -0x1.20020040002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010100000), 0x1.200202p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffefefffff), -0x1.20020200002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010400000), 0x1.200208p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffefbfffff), -0x1.20020800002p+43, 0x0p+0 },
+{ INT64_C(0x0000090010800000), 0x1.20021p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffef7fffff), -0x1.20021000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090014000000), 0x1.20028p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ffebffffff), -0x1.20028000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090080000000), 0x1.201p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7fffffff), -0x1.20100000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090080000001), 0x1.20100000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7ffffffe), -0x1.20100000004p+43, 0x0p+0 },
+{ INT64_C(0x0000090080000002), 0x1.20100000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7ffffffd), -0x1.20100000006p+43, 0x0p+0 },
+{ INT64_C(0x0000090080000008), 0x1.2010000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7ffffff7), -0x1.20100000012p+43, 0x0p+0 },
+{ INT64_C(0x0000090080000080), 0x1.201000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7fffff7f), -0x1.20100000102p+43, 0x0p+0 },
+{ INT64_C(0x0000090080000100), 0x1.201000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7ffffeff), -0x1.20100000202p+43, 0x0p+0 },
+{ INT64_C(0x0000090080001000), 0x1.20100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7fffefff), -0x1.20100002002p+43, 0x0p+0 },
+{ INT64_C(0x0000090080008000), 0x1.2010001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7fff7fff), -0x1.20100010002p+43, 0x0p+0 },
+{ INT64_C(0x0000090080040000), 0x1.2010008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7ffbffff), -0x1.20100080002p+43, 0x0p+0 },
+{ INT64_C(0x0000090080100000), 0x1.201002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7fefffff), -0x1.20100200002p+43, 0x0p+0 },
+{ INT64_C(0x0000090080400000), 0x1.201008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7fbfffff), -0x1.20100800002p+43, 0x0p+0 },
+{ INT64_C(0x0000090084000000), 0x1.20108p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff7bffffff), -0x1.20108000002p+43, 0x0p+0 },
+{ INT64_C(0x00000900a0000000), 0x1.2014p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff5fffffff), -0x1.20140000002p+43, 0x0p+0 },
+{ INT64_C(0x00000900c0000000), 0x1.2018p+43, 0x0p+0 },
+{ INT64_C(0xfffff6ff3fffffff), -0x1.20180000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800000000), 0x1.21p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7ffffffff), -0x1.21000000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800000004), 0x1.21000000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7fffffffb), -0x1.2100000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000090800000020), 0x1.2100000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7ffffffdf), -0x1.21000000042p+43, 0x0p+0 },
+{ INT64_C(0x0000090800000100), 0x1.210000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7fffffeff), -0x1.21000000202p+43, 0x0p+0 },
+{ INT64_C(0x0000090800001000), 0x1.21000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7ffffefff), -0x1.21000002002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800010000), 0x1.2100002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7fffeffff), -0x1.21000020002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800040000), 0x1.2100008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7fffbffff), -0x1.21000080002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800100000), 0x1.210002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7ffefffff), -0x1.21000200002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800400000), 0x1.210008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7ffbfffff), -0x1.21000800002p+43, 0x0p+0 },
+{ INT64_C(0x0000090800800000), 0x1.21001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7ff7fffff), -0x1.21001000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090804000000), 0x1.21008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7fbffffff), -0x1.21008000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090820000000), 0x1.2104p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f7dfffffff), -0x1.21040000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090900000000), 0x1.212p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f6ffffffff), -0x1.21200000002p+43, 0x0p+0 },
+{ INT64_C(0x0000090c00000000), 0x1.218p+43, 0x0p+0 },
+{ INT64_C(0xfffff6f3ffffffff), -0x1.21800000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000000000), 0x1.24p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfffffffff), -0x1.24000000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000000001), 0x1.24000000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffffffffe), -0x1.24000000004p+43, 0x0p+0 },
+{ INT64_C(0x0000092000000004), 0x1.24000000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffffffffb), -0x1.2400000000ap+43, 0x0p+0 },
+{ INT64_C(0x0000092000000040), 0x1.2400000008p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfffffffbf), -0x1.24000000082p+43, 0x0p+0 },
+{ INT64_C(0x0000092000000100), 0x1.240000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffffffeff), -0x1.24000000202p+43, 0x0p+0 },
+{ INT64_C(0x0000092000000800), 0x1.24000001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffffff7ff), -0x1.24000001002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000001000), 0x1.24000002p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfffffefff), -0x1.24000002002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000002000), 0x1.24000004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfffffdfff), -0x1.24000004002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000020000), 0x1.2400004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffffdffff), -0x1.24000040002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000080000), 0x1.240001p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffff7ffff), -0x1.24000100002p+43, 0x0p+0 },
+{ INT64_C(0x0000092000200000), 0x1.240004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfffdfffff), -0x1.24000400002p+43, 0x0p+0 },
+{ INT64_C(0x0000092002000000), 0x1.24004p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dffdffffff), -0x1.24004000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092020000000), 0x1.2404p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfdfffffff), -0x1.24040000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092040000000), 0x1.2408p+43, 0x0p+0 },
+{ INT64_C(0xfffff6dfbfffffff), -0x1.24080000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092080000000), 0x1.241p+43, 0x0p+0 },
+{ INT64_C(0xfffff6df7fffffff), -0x1.24100000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092100000000), 0x1.242p+43, 0x0p+0 },
+{ INT64_C(0xfffff6deffffffff), -0x1.24200000002p+43, 0x0p+0 },
+{ INT64_C(0x0000092800000000), 0x1.25p+43, 0x0p+0 },
+{ INT64_C(0xfffff6d7ffffffff), -0x1.25000000002p+43, 0x0p+0 },
+{ INT64_C(0x0000100000000003), 0x1.00000000003p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffffc), -0x1.00000000004p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000028), 0x1.00000000028p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffd7), -0x1.00000000029p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000029), 0x1.00000000029p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffd6), -0x1.0000000002ap+44, 0x0p+0 },
+{ INT64_C(0x0000100000000030), 0x1.0000000003p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffcf), -0x1.00000000031p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000034), 0x1.00000000034p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffcb), -0x1.00000000035p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000038), 0x1.00000000038p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffc7), -0x1.00000000039p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000041), 0x1.00000000041p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffbe), -0x1.00000000042p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000050), 0x1.0000000005p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffaf), -0x1.00000000051p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000058), 0x1.00000000058p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffffa7), -0x1.00000000059p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000408), 0x1.00000000408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffbf7), -0x1.00000000409p+44, 0x0p+0 },
+{ INT64_C(0x000010000000040a), 0x1.0000000040ap+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffbf5), -0x1.0000000040bp+44, 0x0p+0 },
+{ INT64_C(0x0000100000000410), 0x1.0000000041p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffbef), -0x1.00000000411p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000414), 0x1.00000000414p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffbeb), -0x1.00000000415p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000418), 0x1.00000000418p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffbe7), -0x1.00000000419p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000480), 0x1.0000000048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffb7f), -0x1.00000000481p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000484), 0x1.00000000484p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffb7b), -0x1.00000000485p+44, 0x0p+0 },
+{ INT64_C(0x0000100000000488), 0x1.00000000488p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffffb77), -0x1.00000000489p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004002), 0x1.00000004002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbffd), -0x1.00000004003p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004010), 0x1.0000000401p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbfef), -0x1.00000004011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004012), 0x1.00000004012p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbfed), -0x1.00000004013p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004040), 0x1.0000000404p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbfbf), -0x1.00000004041p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004042), 0x1.00000004042p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbfbd), -0x1.00000004043p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004048), 0x1.00000004048p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbfb7), -0x1.00000004049p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004060), 0x1.0000000406p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbf9f), -0x1.00000004061p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004100), 0x1.000000041p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbeff), -0x1.00000004101p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004101), 0x1.00000004101p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbefe), -0x1.00000004102p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004110), 0x1.0000000411p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbeef), -0x1.00000004111p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004180), 0x1.0000000418p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbe7f), -0x1.00000004181p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004400), 0x1.000000044p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbbff), -0x1.00000004401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004401), 0x1.00000004401p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbbfe), -0x1.00000004402p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004404), 0x1.00000004404p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbbfb), -0x1.00000004405p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004410), 0x1.0000000441p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbbef), -0x1.00000004411p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004480), 0x1.0000000448p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffbb7f), -0x1.00000004481p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004800), 0x1.000000048p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffb7ff), -0x1.00000004801p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004802), 0x1.00000004802p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffb7fd), -0x1.00000004803p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004808), 0x1.00000004808p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffb7f7), -0x1.00000004809p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004820), 0x1.0000000482p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffb7df), -0x1.00000004821p+44, 0x0p+0 },
+{ INT64_C(0x0000100000004a00), 0x1.00000004ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffffffb5ff), -0x1.00000004a01p+44, 0x0p+0 },
+{ INT64_C(0x0000100000006000), 0x1.00000006p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffff9fff), -0x1.00000006001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000006001), 0x1.00000006001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffff9ffe), -0x1.00000006002p+44, 0x0p+0 },
+{ INT64_C(0x0000100000006002), 0x1.00000006002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffff9ffd), -0x1.00000006003p+44, 0x0p+0 },
+{ INT64_C(0x0000100000006020), 0x1.0000000602p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffff9fdf), -0x1.00000006021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000006100), 0x1.000000061p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffff9eff), -0x1.00000006101p+44, 0x0p+0 },
+{ INT64_C(0x0000100000006400), 0x1.000000064p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffff9bff), -0x1.00000006401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040001), 0x1.00000040001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfffe), -0x1.00000040002p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040010), 0x1.0000004001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbffef), -0x1.00000040011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040011), 0x1.00000040011p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbffee), -0x1.00000040012p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040018), 0x1.00000040018p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbffe7), -0x1.00000040019p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040100), 0x1.000000401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfeff), -0x1.00000040101p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040108), 0x1.00000040108p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfef7), -0x1.00000040109p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040180), 0x1.0000004018p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfe7f), -0x1.00000040181p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040200), 0x1.000000402p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfdff), -0x1.00000040201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040208), 0x1.00000040208p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfdf7), -0x1.00000040209p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040240), 0x1.0000004024p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfdbf), -0x1.00000040241p+44, 0x0p+0 },
+{ INT64_C(0x0000100000040300), 0x1.000000403p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbfcff), -0x1.00000040301p+44, 0x0p+0 },
+{ INT64_C(0x0000100000041000), 0x1.00000041p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbefff), -0x1.00000041001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000041001), 0x1.00000041001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbeffe), -0x1.00000041002p+44, 0x0p+0 },
+{ INT64_C(0x0000100000041002), 0x1.00000041002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbeffd), -0x1.00000041003p+44, 0x0p+0 },
+{ INT64_C(0x0000100000041020), 0x1.0000004102p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbefdf), -0x1.00000041021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000041080), 0x1.0000004108p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbef7f), -0x1.00000041081p+44, 0x0p+0 },
+{ INT64_C(0x0000100000041200), 0x1.000000412p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbedff), -0x1.00000041201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000042000), 0x1.00000042p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbdfff), -0x1.00000042001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000042001), 0x1.00000042001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbdffe), -0x1.00000042002p+44, 0x0p+0 },
+{ INT64_C(0x0000100000042010), 0x1.0000004201p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbdfef), -0x1.00000042011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000042040), 0x1.0000004204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbdfbf), -0x1.00000042041p+44, 0x0p+0 },
+{ INT64_C(0x0000100000042400), 0x1.000000424p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffbdbff), -0x1.00000042401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000048000), 0x1.00000048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffb7fff), -0x1.00000048001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000048008), 0x1.00000048008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffb7ff7), -0x1.00000048009p+44, 0x0p+0 },
+{ INT64_C(0x0000100000048040), 0x1.0000004804p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffb7fbf), -0x1.00000048041p+44, 0x0p+0 },
+{ INT64_C(0x0000100000048080), 0x1.0000004808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffb7f7f), -0x1.00000048081p+44, 0x0p+0 },
+{ INT64_C(0x0000100000048800), 0x1.000000488p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffffb77ff), -0x1.00000048801p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080001), 0x1.00000080001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7fffe), -0x1.00000080002p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080010), 0x1.0000008001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7ffef), -0x1.00000080011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080018), 0x1.00000080018p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7ffe7), -0x1.00000080019p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080020), 0x1.0000008002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7ffdf), -0x1.00000080021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080022), 0x1.00000080022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7ffdd), -0x1.00000080023p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080028), 0x1.00000080028p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7ffd7), -0x1.00000080029p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080200), 0x1.000000802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7fdff), -0x1.00000080201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080208), 0x1.00000080208p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7fdf7), -0x1.00000080209p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080220), 0x1.0000008022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7fddf), -0x1.00000080221p+44, 0x0p+0 },
+{ INT64_C(0x0000100000080300), 0x1.000000803p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7fcff), -0x1.00000080301p+44, 0x0p+0 },
+{ INT64_C(0x0000100000082000), 0x1.00000082p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7dfff), -0x1.00000082001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000082004), 0x1.00000082004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7dffb), -0x1.00000082005p+44, 0x0p+0 },
+{ INT64_C(0x0000100000082020), 0x1.0000008202p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7dfdf), -0x1.00000082021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000082040), 0x1.0000008204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7dfbf), -0x1.00000082041p+44, 0x0p+0 },
+{ INT64_C(0x0000100000082080), 0x1.0000008208p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7df7f), -0x1.00000082081p+44, 0x0p+0 },
+{ INT64_C(0x0000100000082400), 0x1.000000824p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff7dbff), -0x1.00000082401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000088000), 0x1.00000088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff77fff), -0x1.00000088001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000088004), 0x1.00000088004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff77ffb), -0x1.00000088005p+44, 0x0p+0 },
+{ INT64_C(0x0000100000088010), 0x1.0000008801p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff77fef), -0x1.00000088011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000088020), 0x1.0000008802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff77fdf), -0x1.00000088021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000088200), 0x1.000000882p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff77dff), -0x1.00000088201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000088400), 0x1.000000884p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff77bff), -0x1.00000088401p+44, 0x0p+0 },
+{ INT64_C(0x000010000008a000), 0x1.0000008ap+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff75fff), -0x1.0000008a001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a0000), 0x1.000000ap+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5ffff), -0x1.000000a0001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a0002), 0x1.000000a0002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5fffd), -0x1.000000a0003p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a0004), 0x1.000000a0004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5fffb), -0x1.000000a0005p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a0020), 0x1.000000a002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5ffdf), -0x1.000000a0021p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a0100), 0x1.000000a01p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5feff), -0x1.000000a0101p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a0800), 0x1.000000a08p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5f7ff), -0x1.000000a0801p+44, 0x0p+0 },
+{ INT64_C(0x00001000000a4000), 0x1.000000a4p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff5bfff), -0x1.000000a4001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000c0000), 0x1.000000cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff3ffff), -0x1.000000c0001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000c0008), 0x1.000000c0008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff3fff7), -0x1.000000c0009p+44, 0x0p+0 },
+{ INT64_C(0x00001000000c0020), 0x1.000000c002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff3ffdf), -0x1.000000c0021p+44, 0x0p+0 },
+{ INT64_C(0x00001000000c0100), 0x1.000000c01p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff3feff), -0x1.000000c0101p+44, 0x0p+0 },
+{ INT64_C(0x00001000000c1000), 0x1.000000c1p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff3efff), -0x1.000000c1001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000c4000), 0x1.000000c4p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff3bfff), -0x1.000000c4001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000d0000), 0x1.000000dp+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff2ffff), -0x1.000000d0001p+44, 0x0p+0 },
+{ INT64_C(0x00001000000e0000), 0x1.000000ep+44, 0x0p+0 },
+{ INT64_C(0xffffeffffff1ffff), -0x1.000000e0001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400008), 0x1.00000400008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbffff7), -0x1.00000400009p+44, 0x0p+0 },
+{ INT64_C(0x000010000040000c), 0x1.0000040000cp+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbffff3), -0x1.0000040000dp+44, 0x0p+0 },
+{ INT64_C(0x0000100000400010), 0x1.0000040001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfffef), -0x1.00000400011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400018), 0x1.00000400018p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfffe7), -0x1.00000400019p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400080), 0x1.0000040008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfff7f), -0x1.00000400081p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400084), 0x1.00000400084p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfff7b), -0x1.00000400085p+44, 0x0p+0 },
+{ INT64_C(0x00001000004000a0), 0x1.000004000ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfff5f), -0x1.000004000a1p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400400), 0x1.000004004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbffbff), -0x1.00000400401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400401), 0x1.00000400401p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbffbfe), -0x1.00000400402p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400404), 0x1.00000400404p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbffbfb), -0x1.00000400405p+44, 0x0p+0 },
+{ INT64_C(0x0000100000400440), 0x1.0000040044p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbffbbf), -0x1.00000400441p+44, 0x0p+0 },
+{ INT64_C(0x0000100000404000), 0x1.00000404p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfbfff), -0x1.00000404001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000404004), 0x1.00000404004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfbffb), -0x1.00000404005p+44, 0x0p+0 },
+{ INT64_C(0x0000100000404010), 0x1.0000040401p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfbfef), -0x1.00000404011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000404100), 0x1.000004041p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfbeff), -0x1.00000404101p+44, 0x0p+0 },
+{ INT64_C(0x0000100000404200), 0x1.000004042p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfbdff), -0x1.00000404201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000404400), 0x1.000004044p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfbbff), -0x1.00000404401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000405000), 0x1.00000405p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbfafff), -0x1.00000405001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000408000), 0x1.00000408p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf7fff), -0x1.00000408001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000408008), 0x1.00000408008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf7ff7), -0x1.00000408009p+44, 0x0p+0 },
+{ INT64_C(0x0000100000408040), 0x1.0000040804p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf7fbf), -0x1.00000408041p+44, 0x0p+0 },
+{ INT64_C(0x0000100000408080), 0x1.0000040808p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf7f7f), -0x1.00000408081p+44, 0x0p+0 },
+{ INT64_C(0x0000100000408100), 0x1.000004081p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf7eff), -0x1.00000408101p+44, 0x0p+0 },
+{ INT64_C(0x0000100000408400), 0x1.000004084p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf7bff), -0x1.00000408401p+44, 0x0p+0 },
+{ INT64_C(0x000010000040c000), 0x1.0000040cp+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbf3fff), -0x1.0000040c001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000410000), 0x1.0000041p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbeffff), -0x1.00000410001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000410002), 0x1.00000410002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbefffd), -0x1.00000410003p+44, 0x0p+0 },
+{ INT64_C(0x0000100000410020), 0x1.0000041002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbeffdf), -0x1.00000410021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000410100), 0x1.000004101p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbefeff), -0x1.00000410101p+44, 0x0p+0 },
+{ INT64_C(0x0000100000410800), 0x1.000004108p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbef7ff), -0x1.00000410801p+44, 0x0p+0 },
+{ INT64_C(0x0000100000411000), 0x1.00000411p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbeefff), -0x1.00000411001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000418000), 0x1.00000418p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbe7fff), -0x1.00000418001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440000), 0x1.0000044p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbffff), -0x1.00000440001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440004), 0x1.00000440004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbfffb), -0x1.00000440005p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440008), 0x1.00000440008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbfff7), -0x1.00000440009p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440010), 0x1.0000044001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbffef), -0x1.00000440011p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440020), 0x1.0000044002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbffdf), -0x1.00000440021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440200), 0x1.000004402p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbfdff), -0x1.00000440201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000440400), 0x1.000004404p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbfbff), -0x1.00000440401p+44, 0x0p+0 },
+{ INT64_C(0x0000100000441000), 0x1.00000441p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbefff), -0x1.00000441001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000444000), 0x1.00000444p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbbbfff), -0x1.00000444001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000448000), 0x1.00000448p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbb7fff), -0x1.00000448001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000450000), 0x1.0000045p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffbaffff), -0x1.00000450001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000480000), 0x1.0000048p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7ffff), -0x1.00000480001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000480002), 0x1.00000480002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7fffd), -0x1.00000480003p+44, 0x0p+0 },
+{ INT64_C(0x0000100000480008), 0x1.00000480008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7fff7), -0x1.00000480009p+44, 0x0p+0 },
+{ INT64_C(0x0000100000480020), 0x1.0000048002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7ffdf), -0x1.00000480021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000480200), 0x1.000004802p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7fdff), -0x1.00000480201p+44, 0x0p+0 },
+{ INT64_C(0x0000100000481000), 0x1.00000481p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7efff), -0x1.00000481001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000484000), 0x1.00000484p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb7bfff), -0x1.00000484001p+44, 0x0p+0 },
+{ INT64_C(0x00001000004a0000), 0x1.000004ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffffb5ffff), -0x1.000004a0001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000500000), 0x1.000005p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffafffff), -0x1.00000500001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000500008), 0x1.00000500008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffaffff7), -0x1.00000500009p+44, 0x0p+0 },
+{ INT64_C(0x0000100000500020), 0x1.0000050002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffafffdf), -0x1.00000500021p+44, 0x0p+0 },
+{ INT64_C(0x0000100000500080), 0x1.0000050008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffafff7f), -0x1.00000500081p+44, 0x0p+0 },
+{ INT64_C(0x0000100000500800), 0x1.000005008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffaff7ff), -0x1.00000500801p+44, 0x0p+0 },
+{ INT64_C(0x0000100000502000), 0x1.00000502p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffafdfff), -0x1.00000502001p+44, 0x0p+0 },
+{ INT64_C(0x0000100000520000), 0x1.0000052p+44, 0x0p+0 },
+{ INT64_C(0xffffefffffadffff), -0x1.00000520001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000002), 0x1.00004000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfffffd), -0x1.00004000003p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000008), 0x1.00004000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfffff7), -0x1.00004000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000040), 0x1.0000400004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffffbf), -0x1.00004000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000041), 0x1.00004000041p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffffbe), -0x1.00004000042p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000050), 0x1.0000400005p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffffaf), -0x1.00004000051p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000060), 0x1.0000400006p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffff9f), -0x1.00004000061p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000200), 0x1.000040002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfffdff), -0x1.00004000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000202), 0x1.00004000202p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfffdfd), -0x1.00004000203p+44, 0x0p+0 },
+{ INT64_C(0x0000100004000220), 0x1.0000400022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfffddf), -0x1.00004000221p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001000), 0x1.00004001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffefff), -0x1.00004001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001002), 0x1.00004001002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffeffd), -0x1.00004001003p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001004), 0x1.00004001004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffeffb), -0x1.00004001005p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001008), 0x1.00004001008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffeff7), -0x1.00004001009p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001040), 0x1.0000400104p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffefbf), -0x1.00004001041p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001080), 0x1.0000400108p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffef7f), -0x1.00004001081p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001400), 0x1.000040014p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffebff), -0x1.00004001401p+44, 0x0p+0 },
+{ INT64_C(0x0000100004001800), 0x1.000040018p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffe7ff), -0x1.00004001801p+44, 0x0p+0 },
+{ INT64_C(0x0000100004004000), 0x1.00004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffbfff), -0x1.00004004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004004001), 0x1.00004004001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffbffe), -0x1.00004004002p+44, 0x0p+0 },
+{ INT64_C(0x0000100004004004), 0x1.00004004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffbffb), -0x1.00004004005p+44, 0x0p+0 },
+{ INT64_C(0x0000100004004040), 0x1.0000400404p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffbfbf), -0x1.00004004041p+44, 0x0p+0 },
+{ INT64_C(0x0000100004004400), 0x1.000040044p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffbbff), -0x1.00004004401p+44, 0x0p+0 },
+{ INT64_C(0x0000100004004800), 0x1.000040048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbffb7ff), -0x1.00004004801p+44, 0x0p+0 },
+{ INT64_C(0x0000100004020000), 0x1.0000402p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfdffff), -0x1.00004020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004020004), 0x1.00004020004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfdfffb), -0x1.00004020005p+44, 0x0p+0 },
+{ INT64_C(0x0000100004020020), 0x1.0000402002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfdffdf), -0x1.00004020021p+44, 0x0p+0 },
+{ INT64_C(0x0000100004020080), 0x1.0000402008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfdff7f), -0x1.00004020081p+44, 0x0p+0 },
+{ INT64_C(0x0000100004020400), 0x1.000040204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfdfbff), -0x1.00004020401p+44, 0x0p+0 },
+{ INT64_C(0x0000100004022000), 0x1.00004022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfddfff), -0x1.00004022001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004024000), 0x1.00004024p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfdbfff), -0x1.00004024001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004028000), 0x1.00004028p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbfd7fff), -0x1.00004028001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004080000), 0x1.0000408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7ffff), -0x1.00004080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004080008), 0x1.00004080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7fff7), -0x1.00004080009p+44, 0x0p+0 },
+{ INT64_C(0x0000100004080020), 0x1.0000408002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7ffdf), -0x1.00004080021p+44, 0x0p+0 },
+{ INT64_C(0x0000100004080040), 0x1.0000408004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7ffbf), -0x1.00004080041p+44, 0x0p+0 },
+{ INT64_C(0x0000100004080400), 0x1.000040804p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7fbff), -0x1.00004080401p+44, 0x0p+0 },
+{ INT64_C(0x0000100004080800), 0x1.000040808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7f7ff), -0x1.00004080801p+44, 0x0p+0 },
+{ INT64_C(0x0000100004084000), 0x1.00004084p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf7bfff), -0x1.00004084001p+44, 0x0p+0 },
+{ INT64_C(0x00001000040c0000), 0x1.000040cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffffbf3ffff), -0x1.000040c0001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004800000), 0x1.000048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7fffff), -0x1.00004800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004800008), 0x1.00004800008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7ffff7), -0x1.00004800009p+44, 0x0p+0 },
+{ INT64_C(0x0000100004800040), 0x1.0000480004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7fffbf), -0x1.00004800041p+44, 0x0p+0 },
+{ INT64_C(0x0000100004800100), 0x1.000048001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7ffeff), -0x1.00004800101p+44, 0x0p+0 },
+{ INT64_C(0x0000100004800400), 0x1.000048004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7ffbff), -0x1.00004800401p+44, 0x0p+0 },
+{ INT64_C(0x0000100004802000), 0x1.00004802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7fdfff), -0x1.00004802001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004808000), 0x1.00004808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7f7fff), -0x1.00004808001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004810000), 0x1.0000481p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb7effff), -0x1.00004810001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004900000), 0x1.000049p+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb6fffff), -0x1.00004900001p+44, 0x0p+0 },
+{ INT64_C(0x0000100004a00000), 0x1.00004ap+44, 0x0p+0 },
+{ INT64_C(0xffffeffffb5fffff), -0x1.00004a00001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000004), 0x1.00008000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fffffb), -0x1.00008000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000040), 0x1.0000800004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffffbf), -0x1.00008000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000048), 0x1.00008000048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffffb7), -0x1.00008000049p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000050), 0x1.0000800005p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffffaf), -0x1.00008000051p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000080), 0x1.0000800008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffff7f), -0x1.00008000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000081), 0x1.00008000081p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffff7e), -0x1.00008000082p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000088), 0x1.00008000088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffff77), -0x1.00008000089p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000800), 0x1.000080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fff7ff), -0x1.00008000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000802), 0x1.00008000802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fff7fd), -0x1.00008000803p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000810), 0x1.0000800081p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fff7ef), -0x1.00008000811p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000820), 0x1.0000800082p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fff7df), -0x1.00008000821p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000840), 0x1.0000800084p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fff7bf), -0x1.00008000841p+44, 0x0p+0 },
+{ INT64_C(0x0000100008000a00), 0x1.00008000ap+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fff5ff), -0x1.00008000a01p+44, 0x0p+0 },
+{ INT64_C(0x0000100008004000), 0x1.00008004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffbfff), -0x1.00008004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008004004), 0x1.00008004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffbffb), -0x1.00008004005p+44, 0x0p+0 },
+{ INT64_C(0x0000100008004010), 0x1.0000800401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffbfef), -0x1.00008004011p+44, 0x0p+0 },
+{ INT64_C(0x0000100008004040), 0x1.0000800404p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffbfbf), -0x1.00008004041p+44, 0x0p+0 },
+{ INT64_C(0x0000100008004080), 0x1.0000800408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffbf7f), -0x1.00008004081p+44, 0x0p+0 },
+{ INT64_C(0x0000100008004200), 0x1.000080042p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffbdff), -0x1.00008004201p+44, 0x0p+0 },
+{ INT64_C(0x0000100008005000), 0x1.00008005p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7ffafff), -0x1.00008005001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008020000), 0x1.0000802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdffff), -0x1.00008020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008020001), 0x1.00008020001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdfffe), -0x1.00008020002p+44, 0x0p+0 },
+{ INT64_C(0x0000100008020008), 0x1.00008020008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdfff7), -0x1.00008020009p+44, 0x0p+0 },
+{ INT64_C(0x0000100008020080), 0x1.0000802008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdff7f), -0x1.00008020081p+44, 0x0p+0 },
+{ INT64_C(0x0000100008020200), 0x1.000080202p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdfdff), -0x1.00008020201p+44, 0x0p+0 },
+{ INT64_C(0x0000100008021000), 0x1.00008021p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdefff), -0x1.00008021001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008022000), 0x1.00008022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fddfff), -0x1.00008022001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008024000), 0x1.00008024p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fdbfff), -0x1.00008024001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008028000), 0x1.00008028p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7fd7fff), -0x1.00008028001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008080000), 0x1.0000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f7ffff), -0x1.00008080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008080008), 0x1.00008080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f7fff7), -0x1.00008080009p+44, 0x0p+0 },
+{ INT64_C(0x0000100008080040), 0x1.0000808004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f7ffbf), -0x1.00008080041p+44, 0x0p+0 },
+{ INT64_C(0x0000100008080100), 0x1.000080801p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f7feff), -0x1.00008080101p+44, 0x0p+0 },
+{ INT64_C(0x0000100008080800), 0x1.000080808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f7f7ff), -0x1.00008080801p+44, 0x0p+0 },
+{ INT64_C(0x0000100008084000), 0x1.00008084p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f7bfff), -0x1.00008084001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008088000), 0x1.00008088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f77fff), -0x1.00008088001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008090000), 0x1.0000809p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f6ffff), -0x1.00008090001p+44, 0x0p+0 },
+{ INT64_C(0x00001000080c0000), 0x1.000080cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7f3ffff), -0x1.000080c0001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008400000), 0x1.000084p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bfffff), -0x1.00008400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008400002), 0x1.00008400002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bffffd), -0x1.00008400003p+44, 0x0p+0 },
+{ INT64_C(0x0000100008400008), 0x1.00008400008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bffff7), -0x1.00008400009p+44, 0x0p+0 },
+{ INT64_C(0x0000100008400010), 0x1.0000840001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bfffef), -0x1.00008400011p+44, 0x0p+0 },
+{ INT64_C(0x0000100008400100), 0x1.000084001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bffeff), -0x1.00008400101p+44, 0x0p+0 },
+{ INT64_C(0x0000100008400400), 0x1.000084004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bffbff), -0x1.00008400401p+44, 0x0p+0 },
+{ INT64_C(0x0000100008401000), 0x1.00008401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bfefff), -0x1.00008401001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008404000), 0x1.00008404p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bfbfff), -0x1.00008404001p+44, 0x0p+0 },
+{ INT64_C(0x0000100008440000), 0x1.0000844p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff7bbffff), -0x1.00008440001p+44, 0x0p+0 },
+{ INT64_C(0x0000100009000000), 0x1.00009p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6ffffff), -0x1.00009000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100009000002), 0x1.00009000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6fffffd), -0x1.00009000003p+44, 0x0p+0 },
+{ INT64_C(0x0000100009000004), 0x1.00009000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6fffffb), -0x1.00009000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100009000020), 0x1.0000900002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6ffffdf), -0x1.00009000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100009000200), 0x1.000090002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6fffdff), -0x1.00009000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100009000800), 0x1.000090008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6fff7ff), -0x1.00009000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100009004000), 0x1.00009004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6ffbfff), -0x1.00009004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100009040000), 0x1.0000904p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6fbffff), -0x1.00009040001p+44, 0x0p+0 },
+{ INT64_C(0x0000100009100000), 0x1.000091p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6efffff), -0x1.00009100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100009200000), 0x1.000092p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff6dfffff), -0x1.00009200001p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000000), 0x1.0000cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3ffffff), -0x1.0000c000001p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000002), 0x1.0000c000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3fffffd), -0x1.0000c000003p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000020), 0x1.0000c00002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3ffffdf), -0x1.0000c000021p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000040), 0x1.0000c00004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3ffffbf), -0x1.0000c000041p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000080), 0x1.0000c00008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3ffff7f), -0x1.0000c000081p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000100), 0x1.0000c0001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3fffeff), -0x1.0000c000101p+44, 0x0p+0 },
+{ INT64_C(0x000010000c000400), 0x1.0000c0004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3fffbff), -0x1.0000c000401p+44, 0x0p+0 },
+{ INT64_C(0x000010000c002000), 0x1.0000c002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3ffdfff), -0x1.0000c002001p+44, 0x0p+0 },
+{ INT64_C(0x000010000c008000), 0x1.0000c008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3ff7fff), -0x1.0000c008001p+44, 0x0p+0 },
+{ INT64_C(0x000010000c080000), 0x1.0000c08p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3f7ffff), -0x1.0000c080001p+44, 0x0p+0 },
+{ INT64_C(0x000010000c400000), 0x1.0000c4p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff3bfffff), -0x1.0000c400001p+44, 0x0p+0 },
+{ INT64_C(0x000010000c800000), 0x1.0000c8p+44, 0x0p+0 },
+{ INT64_C(0xffffeffff37fffff), -0x1.0000c800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000002), 0x1.00020000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffffffd), -0x1.00020000003p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000020), 0x1.0002000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfffffdf), -0x1.00020000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000024), 0x1.00020000024p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfffffdb), -0x1.00020000025p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000040), 0x1.0002000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfffffbf), -0x1.00020000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000048), 0x1.00020000048p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfffffb7), -0x1.00020000049p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000050), 0x1.0002000005p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfffffaf), -0x1.00020000051p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000100), 0x1.000200001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffffeff), -0x1.00020000101p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000104), 0x1.00020000104p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffffefb), -0x1.00020000105p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000140), 0x1.0002000014p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffffebf), -0x1.00020000141p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000800), 0x1.000200008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffff7ff), -0x1.00020000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000808), 0x1.00020000808p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffff7f7), -0x1.00020000809p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000840), 0x1.0002000084p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffff7bf), -0x1.00020000841p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000900), 0x1.000200009p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffff6ff), -0x1.00020000901p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000a00), 0x1.00020000ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffff5ff), -0x1.00020000a01p+44, 0x0p+0 },
+{ INT64_C(0x0000100020000c00), 0x1.00020000cp+44, 0x0p+0 },
+{ INT64_C(0xffffefffdffff3ff), -0x1.00020000c01p+44, 0x0p+0 },
+{ INT64_C(0x0000100020008000), 0x1.00020008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfff7fff), -0x1.00020008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020008002), 0x1.00020008002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfff7ffd), -0x1.00020008003p+44, 0x0p+0 },
+{ INT64_C(0x0000100020008010), 0x1.0002000801p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfff7fef), -0x1.00020008011p+44, 0x0p+0 },
+{ INT64_C(0x0000100020008040), 0x1.0002000804p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfff7fbf), -0x1.00020008041p+44, 0x0p+0 },
+{ INT64_C(0x0000100020008080), 0x1.0002000808p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfff7f7f), -0x1.00020008081p+44, 0x0p+0 },
+{ INT64_C(0x0000100020008800), 0x1.000200088p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdfff77ff), -0x1.00020008801p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080000), 0x1.0002008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7ffff), -0x1.00020080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080001), 0x1.00020080001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7fffe), -0x1.00020080002p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080008), 0x1.00020080008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7fff7), -0x1.00020080009p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080010), 0x1.0002008001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7ffef), -0x1.00020080011p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080020), 0x1.0002008002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7ffdf), -0x1.00020080021p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080100), 0x1.000200801p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7feff), -0x1.00020080101p+44, 0x0p+0 },
+{ INT64_C(0x0000100020080200), 0x1.000200802p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7fdff), -0x1.00020080201p+44, 0x0p+0 },
+{ INT64_C(0x0000100020082000), 0x1.00020082p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff7dfff), -0x1.00020082001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020090000), 0x1.0002009p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff6ffff), -0x1.00020090001p+44, 0x0p+0 },
+{ INT64_C(0x00001000200a0000), 0x1.000200ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffdff5ffff), -0x1.000200a0001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800000), 0x1.000208p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7fffff), -0x1.00020800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800001), 0x1.00020800001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7ffffe), -0x1.00020800002p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800008), 0x1.00020800008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7ffff7), -0x1.00020800009p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800020), 0x1.0002080002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7fffdf), -0x1.00020800021p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800100), 0x1.000208001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7ffeff), -0x1.00020800101p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800200), 0x1.000208002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7ffdff), -0x1.00020800201p+44, 0x0p+0 },
+{ INT64_C(0x0000100020800400), 0x1.000208004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7ffbff), -0x1.00020800401p+44, 0x0p+0 },
+{ INT64_C(0x0000100020804000), 0x1.00020804p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7fbfff), -0x1.00020804001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020810000), 0x1.0002081p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf7effff), -0x1.00020810001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020900000), 0x1.000209p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf6fffff), -0x1.00020900001p+44, 0x0p+0 },
+{ INT64_C(0x0000100020a00000), 0x1.00020ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffdf5fffff), -0x1.00020a00001p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000000), 0x1.00021p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdeffffff), -0x1.00021000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000002), 0x1.00021000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdefffffd), -0x1.00021000003p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000004), 0x1.00021000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdefffffb), -0x1.00021000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000020), 0x1.0002100002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdeffffdf), -0x1.00021000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000040), 0x1.0002100004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdeffffbf), -0x1.00021000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000080), 0x1.0002100008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdeffff7f), -0x1.00021000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100021000800), 0x1.000210008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdefff7ff), -0x1.00021000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100021002000), 0x1.00021002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdeffdfff), -0x1.00021002001p+44, 0x0p+0 },
+{ INT64_C(0x0000100021020000), 0x1.0002102p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdefdffff), -0x1.00021020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100021100000), 0x1.000211p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdeefffff), -0x1.00021100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100021200000), 0x1.000212p+44, 0x0p+0 },
+{ INT64_C(0xffffefffdedfffff), -0x1.00021200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028000000), 0x1.00028p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7ffffff), -0x1.00028000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028000008), 0x1.00028000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7fffff7), -0x1.00028000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100028000020), 0x1.0002800002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7ffffdf), -0x1.00028000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100028000040), 0x1.0002800004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7ffffbf), -0x1.00028000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100028000200), 0x1.000280002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7fffdff), -0x1.00028000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100028000400), 0x1.000280004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7fffbff), -0x1.00028000401p+44, 0x0p+0 },
+{ INT64_C(0x0000100028001000), 0x1.00028001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7ffefff), -0x1.00028001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028010000), 0x1.0002801p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7feffff), -0x1.00028010001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028020000), 0x1.0002802p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7fdffff), -0x1.00028020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028040000), 0x1.0002804p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7fbffff), -0x1.00028040001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028100000), 0x1.000281p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7efffff), -0x1.00028100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100028400000), 0x1.000284p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd7bfffff), -0x1.00028400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100029000000), 0x1.00029p+44, 0x0p+0 },
+{ INT64_C(0xffffefffd6ffffff), -0x1.00029000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000004), 0x1.00040000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffffb), -0x1.00040000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000005), 0x1.00040000005p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffffa), -0x1.00040000006p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000006), 0x1.00040000006p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffff9), -0x1.00040000007p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000008), 0x1.00040000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffff7), -0x1.00040000009p+44, 0x0p+0 },
+{ INT64_C(0x000010004000000a), 0x1.0004000000ap+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffff5), -0x1.0004000000bp+44, 0x0p+0 },
+{ INT64_C(0x0000100040000020), 0x1.0004000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffffdf), -0x1.00040000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000021), 0x1.00040000021p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffffde), -0x1.00040000022p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000030), 0x1.0004000003p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffffcf), -0x1.00040000031p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000200), 0x1.000400002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffdff), -0x1.00040000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000208), 0x1.00040000208p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffdf7), -0x1.00040000209p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000280), 0x1.0004000028p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffd7f), -0x1.00040000281p+44, 0x0p+0 },
+{ INT64_C(0x0000100040000300), 0x1.000400003p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffffcff), -0x1.00040000301p+44, 0x0p+0 },
+{ INT64_C(0x0000100040002000), 0x1.00040002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffdfff), -0x1.00040002001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040002008), 0x1.00040002008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffdff7), -0x1.00040002009p+44, 0x0p+0 },
+{ INT64_C(0x0000100040002020), 0x1.0004000202p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffdfdf), -0x1.00040002021p+44, 0x0p+0 },
+{ INT64_C(0x0000100040002040), 0x1.0004000204p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffdfbf), -0x1.00040002041p+44, 0x0p+0 },
+{ INT64_C(0x0000100040002080), 0x1.0004000208p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffdf7f), -0x1.00040002081p+44, 0x0p+0 },
+{ INT64_C(0x0000100040002200), 0x1.000400022p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffddff), -0x1.00040002201p+44, 0x0p+0 },
+{ INT64_C(0x0000100040003000), 0x1.00040003p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfffcfff), -0x1.00040003001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040020000), 0x1.0004002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffdffff), -0x1.00040020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040020001), 0x1.00040020001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffdfffe), -0x1.00040020002p+44, 0x0p+0 },
+{ INT64_C(0x0000100040020008), 0x1.00040020008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffdfff7), -0x1.00040020009p+44, 0x0p+0 },
+{ INT64_C(0x0000100040020080), 0x1.0004002008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffdff7f), -0x1.00040020081p+44, 0x0p+0 },
+{ INT64_C(0x0000100040020100), 0x1.000400201p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffdfeff), -0x1.00040020101p+44, 0x0p+0 },
+{ INT64_C(0x0000100040021000), 0x1.00040021p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffdefff), -0x1.00040021001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040028000), 0x1.00040028p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbffd7fff), -0x1.00040028001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200000), 0x1.000402p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdfffff), -0x1.00040200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200004), 0x1.00040200004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdffffb), -0x1.00040200005p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200008), 0x1.00040200008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdffff7), -0x1.00040200009p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200010), 0x1.0004020001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdfffef), -0x1.00040200011p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200080), 0x1.0004020008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdfff7f), -0x1.00040200081p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200100), 0x1.000402001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdffeff), -0x1.00040200101p+44, 0x0p+0 },
+{ INT64_C(0x0000100040200800), 0x1.000402008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdff7ff), -0x1.00040200801p+44, 0x0p+0 },
+{ INT64_C(0x0000100040201000), 0x1.00040201p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdfefff), -0x1.00040201001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040202000), 0x1.00040202p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfdfdfff), -0x1.00040202001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040220000), 0x1.0004022p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfddffff), -0x1.00040220001p+44, 0x0p+0 },
+{ INT64_C(0x0000100040300000), 0x1.000403p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbfcfffff), -0x1.00040300001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041000000), 0x1.00041p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbeffffff), -0x1.00041000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041000004), 0x1.00041000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbefffffb), -0x1.00041000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100041000020), 0x1.0004100002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbeffffdf), -0x1.00041000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100041000100), 0x1.000410001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbefffeff), -0x1.00041000101p+44, 0x0p+0 },
+{ INT64_C(0x0000100041000800), 0x1.000410008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbefff7ff), -0x1.00041000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100041001000), 0x1.00041001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbeffefff), -0x1.00041001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041002000), 0x1.00041002p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbeffdfff), -0x1.00041002001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041020000), 0x1.0004102p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbefdffff), -0x1.00041020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041200000), 0x1.000412p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbedfffff), -0x1.00041200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041400000), 0x1.000414p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbebfffff), -0x1.00041400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100041800000), 0x1.000418p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbe7fffff), -0x1.00041800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100044000000), 0x1.00044p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbffffff), -0x1.00044000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100044000008), 0x1.00044000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbfffff7), -0x1.00044000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100044000010), 0x1.0004400001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbffffef), -0x1.00044000011p+44, 0x0p+0 },
+{ INT64_C(0x0000100044000040), 0x1.0004400004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbffffbf), -0x1.00044000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100044000400), 0x1.000440004p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbfffbff), -0x1.00044000401p+44, 0x0p+0 },
+{ INT64_C(0x0000100044001000), 0x1.00044001p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbffefff), -0x1.00044001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100044010000), 0x1.0004401p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbfeffff), -0x1.00044010001p+44, 0x0p+0 },
+{ INT64_C(0x0000100044100000), 0x1.000441p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbbefffff), -0x1.00044100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100045000000), 0x1.00045p+44, 0x0p+0 },
+{ INT64_C(0xffffefffbaffffff), -0x1.00045000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000004), 0x1.00200000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffffffb), -0x1.00200000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000010), 0x1.0020000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffffef), -0x1.00200000011p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000012), 0x1.00200000012p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffffed), -0x1.00200000013p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000018), 0x1.00200000018p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffffe7), -0x1.00200000019p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000080), 0x1.0020000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffff7f), -0x1.00200000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000088), 0x1.00200000088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffff77), -0x1.00200000089p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000200), 0x1.002000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffffdff), -0x1.00200000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000208), 0x1.00200000208p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffffdf7), -0x1.00200000209p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000240), 0x1.0020000024p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffffdbf), -0x1.00200000241p+44, 0x0p+0 },
+{ INT64_C(0x0000100200000280), 0x1.0020000028p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffffd7f), -0x1.00200000281p+44, 0x0p+0 },
+{ INT64_C(0x0000100200002000), 0x1.00200002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffdfff), -0x1.00200002001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200002002), 0x1.00200002002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffdffd), -0x1.00200002003p+44, 0x0p+0 },
+{ INT64_C(0x0000100200002020), 0x1.0020000202p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffdfdf), -0x1.00200002021p+44, 0x0p+0 },
+{ INT64_C(0x0000100200002200), 0x1.002000022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffddff), -0x1.00200002201p+44, 0x0p+0 },
+{ INT64_C(0x0000100200004000), 0x1.00200004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffbfff), -0x1.00200004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200004002), 0x1.00200004002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffbffd), -0x1.00200004003p+44, 0x0p+0 },
+{ INT64_C(0x0000100200004004), 0x1.00200004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffbffb), -0x1.00200004005p+44, 0x0p+0 },
+{ INT64_C(0x0000100200004008), 0x1.00200004008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffbff7), -0x1.00200004009p+44, 0x0p+0 },
+{ INT64_C(0x0000100200004080), 0x1.0020000408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffbf7f), -0x1.00200004081p+44, 0x0p+0 },
+{ INT64_C(0x0000100200004400), 0x1.002000044p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffffbbff), -0x1.00200004401p+44, 0x0p+0 },
+{ INT64_C(0x0000100200006000), 0x1.00200006p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff9fff), -0x1.00200006001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200008000), 0x1.00200008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff7fff), -0x1.00200008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200008001), 0x1.00200008001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff7ffe), -0x1.00200008002p+44, 0x0p+0 },
+{ INT64_C(0x0000100200008008), 0x1.00200008008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff7ff7), -0x1.00200008009p+44, 0x0p+0 },
+{ INT64_C(0x0000100200008080), 0x1.0020000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff7f7f), -0x1.00200008081p+44, 0x0p+0 },
+{ INT64_C(0x0000100200008200), 0x1.002000082p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff7dff), -0x1.00200008201p+44, 0x0p+0 },
+{ INT64_C(0x0000100200008800), 0x1.002000088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff77ff), -0x1.00200008801p+44, 0x0p+0 },
+{ INT64_C(0x0000100200009000), 0x1.00200009p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff6fff), -0x1.00200009001p+44, 0x0p+0 },
+{ INT64_C(0x000010020000c000), 0x1.0020000cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffff3fff), -0x1.0020000c001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020000), 0x1.0020002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdffff), -0x1.00200020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020001), 0x1.00200020001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdfffe), -0x1.00200020002p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020002), 0x1.00200020002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdfffd), -0x1.00200020003p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020008), 0x1.00200020008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdfff7), -0x1.00200020009p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020010), 0x1.0020002001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdffef), -0x1.00200020011p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020040), 0x1.0020002004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdffbf), -0x1.00200020041p+44, 0x0p+0 },
+{ INT64_C(0x0000100200020400), 0x1.002000204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffdfbff), -0x1.00200020401p+44, 0x0p+0 },
+{ INT64_C(0x0000100200022000), 0x1.00200022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffddfff), -0x1.00200022001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200030000), 0x1.0020003p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfffcffff), -0x1.00200030001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200100000), 0x1.002001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffefffff), -0x1.00200100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200100001), 0x1.00200100001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffeffffe), -0x1.00200100002p+44, 0x0p+0 },
+{ INT64_C(0x0000100200100004), 0x1.00200100004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffeffffb), -0x1.00200100005p+44, 0x0p+0 },
+{ INT64_C(0x0000100200100008), 0x1.00200100008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffeffff7), -0x1.00200100009p+44, 0x0p+0 },
+{ INT64_C(0x0000100200100080), 0x1.0020010008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffefff7f), -0x1.00200100081p+44, 0x0p+0 },
+{ INT64_C(0x0000100200100800), 0x1.002001008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffeff7ff), -0x1.00200100801p+44, 0x0p+0 },
+{ INT64_C(0x0000100200108000), 0x1.00200108p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffef7fff), -0x1.00200108001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200120000), 0x1.0020012p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffedffff), -0x1.00200120001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200400000), 0x1.002004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbfffff), -0x1.00200400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200400004), 0x1.00200400004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbffffb), -0x1.00200400005p+44, 0x0p+0 },
+{ INT64_C(0x0000100200400020), 0x1.0020040002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbfffdf), -0x1.00200400021p+44, 0x0p+0 },
+{ INT64_C(0x0000100200400100), 0x1.002004001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbffeff), -0x1.00200400101p+44, 0x0p+0 },
+{ INT64_C(0x0000100200400400), 0x1.002004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbffbff), -0x1.00200400401p+44, 0x0p+0 },
+{ INT64_C(0x0000100200401000), 0x1.00200401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbfefff), -0x1.00200401001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200410000), 0x1.0020041p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffbeffff), -0x1.00200410001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200480000), 0x1.0020048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffb7ffff), -0x1.00200480001p+44, 0x0p+0 },
+{ INT64_C(0x0000100200500000), 0x1.002005p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdffafffff), -0x1.00200500001p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000000), 0x1.00204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbffffff), -0x1.00204000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000002), 0x1.00204000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbfffffd), -0x1.00204000003p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000020), 0x1.0020400002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbffffdf), -0x1.00204000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000080), 0x1.0020400008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbffff7f), -0x1.00204000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000100), 0x1.002040001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbfffeff), -0x1.00204000101p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000200), 0x1.002040002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbfffdff), -0x1.00204000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100204000400), 0x1.002040004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbfffbff), -0x1.00204000401p+44, 0x0p+0 },
+{ INT64_C(0x0000100204004000), 0x1.00204004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbffbfff), -0x1.00204004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100204010000), 0x1.0020401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbfeffff), -0x1.00204010001p+44, 0x0p+0 },
+{ INT64_C(0x0000100204100000), 0x1.002041p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbefffff), -0x1.00204100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100204400000), 0x1.002044p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfbbfffff), -0x1.00204400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100205000000), 0x1.00205p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdfaffffff), -0x1.00205000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100208000000), 0x1.00208p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7ffffff), -0x1.00208000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100208000008), 0x1.00208000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7fffff7), -0x1.00208000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100208000080), 0x1.0020800008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7ffff7f), -0x1.00208000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100208000100), 0x1.002080001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7fffeff), -0x1.00208000101p+44, 0x0p+0 },
+{ INT64_C(0x0000100208000800), 0x1.002080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7fff7ff), -0x1.00208000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100208004000), 0x1.00208004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7ffbfff), -0x1.00208004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100208040000), 0x1.0020804p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7fbffff), -0x1.00208040001p+44, 0x0p+0 },
+{ INT64_C(0x0000100208200000), 0x1.002082p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf7dfffff), -0x1.00208200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100208800000), 0x1.002088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf77fffff), -0x1.00208800001p+44, 0x0p+0 },
+{ INT64_C(0x000010020c000000), 0x1.0020cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffdf3ffffff), -0x1.0020c000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100220000000), 0x1.0022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfffffff), -0x1.00220000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100220000004), 0x1.00220000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddffffffb), -0x1.00220000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100220000008), 0x1.00220000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddffffff7), -0x1.00220000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100220000010), 0x1.0022000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfffffef), -0x1.00220000011p+44, 0x0p+0 },
+{ INT64_C(0x0000100220000080), 0x1.0022000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfffff7f), -0x1.00220000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100220000100), 0x1.002200001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddffffeff), -0x1.00220000101p+44, 0x0p+0 },
+{ INT64_C(0x0000100220001000), 0x1.00220001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfffefff), -0x1.00220001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100220008000), 0x1.00220008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfff7fff), -0x1.00220008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100220010000), 0x1.0022001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddffeffff), -0x1.00220010001p+44, 0x0p+0 },
+{ INT64_C(0x0000100220100000), 0x1.002201p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfefffff), -0x1.00220100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100220400000), 0x1.002204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddfbfffff), -0x1.00220400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100224000000), 0x1.00224p+44, 0x0p+0 },
+{ INT64_C(0xffffeffddbffffff), -0x1.00224000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100228000000), 0x1.00228p+44, 0x0p+0 },
+{ INT64_C(0xffffeffdd7ffffff), -0x1.00228000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000004), 0x1.00400000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffffffb), -0x1.00400000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000040), 0x1.0040000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffffbf), -0x1.00400000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000048), 0x1.00400000048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffffb7), -0x1.00400000049p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000050), 0x1.0040000005p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffffaf), -0x1.00400000051p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000200), 0x1.004000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffffdff), -0x1.00400000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000204), 0x1.00400000204p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffffdfb), -0x1.00400000205p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000220), 0x1.0040000022p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffffddf), -0x1.00400000221p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000300), 0x1.004000003p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffffcff), -0x1.00400000301p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000800), 0x1.004000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffff7ff), -0x1.00400000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000801), 0x1.00400000801p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffff7fe), -0x1.00400000802p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000808), 0x1.00400000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffff7f7), -0x1.00400000809p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000840), 0x1.0040000084p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffff7bf), -0x1.00400000841p+44, 0x0p+0 },
+{ INT64_C(0x0000100400000c00), 0x1.00400000cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffff3ff), -0x1.00400000c01p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001000), 0x1.00400001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffefff), -0x1.00400001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001004), 0x1.00400001004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffeffb), -0x1.00400001005p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001010), 0x1.0040000101p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffefef), -0x1.00400001011p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001040), 0x1.0040000104p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffefbf), -0x1.00400001041p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001080), 0x1.0040000108p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffef7f), -0x1.00400001081p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001200), 0x1.004000012p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffedff), -0x1.00400001201p+44, 0x0p+0 },
+{ INT64_C(0x0000100400001400), 0x1.004000014p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffebff), -0x1.00400001401p+44, 0x0p+0 },
+{ INT64_C(0x0000100400004000), 0x1.00400004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffbfff), -0x1.00400004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400004008), 0x1.00400004008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffbff7), -0x1.00400004009p+44, 0x0p+0 },
+{ INT64_C(0x0000100400004080), 0x1.0040000408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffbf7f), -0x1.00400004081p+44, 0x0p+0 },
+{ INT64_C(0x0000100400004400), 0x1.004000044p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffbbff), -0x1.00400004401p+44, 0x0p+0 },
+{ INT64_C(0x0000100400005000), 0x1.00400005p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffffafff), -0x1.00400005001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400010000), 0x1.0040001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffeffff), -0x1.00400010001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400010002), 0x1.00400010002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffefffd), -0x1.00400010003p+44, 0x0p+0 },
+{ INT64_C(0x0000100400010004), 0x1.00400010004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffefffb), -0x1.00400010005p+44, 0x0p+0 },
+{ INT64_C(0x0000100400010010), 0x1.0040001001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffeffef), -0x1.00400010011p+44, 0x0p+0 },
+{ INT64_C(0x0000100400010100), 0x1.004000101p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffefeff), -0x1.00400010101p+44, 0x0p+0 },
+{ INT64_C(0x0000100400011000), 0x1.00400011p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfffeefff), -0x1.00400011001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400080000), 0x1.0040008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7ffff), -0x1.00400080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400080008), 0x1.00400080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7fff7), -0x1.00400080009p+44, 0x0p+0 },
+{ INT64_C(0x0000100400080040), 0x1.0040008004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7ffbf), -0x1.00400080041p+44, 0x0p+0 },
+{ INT64_C(0x0000100400080080), 0x1.0040008008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7ff7f), -0x1.00400080081p+44, 0x0p+0 },
+{ INT64_C(0x0000100400080400), 0x1.004000804p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7fbff), -0x1.00400080401p+44, 0x0p+0 },
+{ INT64_C(0x0000100400080800), 0x1.004000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7f7ff), -0x1.00400080801p+44, 0x0p+0 },
+{ INT64_C(0x0000100400081000), 0x1.00400081p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff7efff), -0x1.00400081001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400088000), 0x1.00400088p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff77fff), -0x1.00400088001p+44, 0x0p+0 },
+{ INT64_C(0x00001004000c0000), 0x1.004000cp+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfff3ffff), -0x1.004000c0001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400000), 0x1.004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbfffff), -0x1.00400400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400002), 0x1.00400400002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbffffd), -0x1.00400400003p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400008), 0x1.00400400008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbffff7), -0x1.00400400009p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400010), 0x1.0040040001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbfffef), -0x1.00400400011p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400040), 0x1.0040040004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbfffbf), -0x1.00400400041p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400080), 0x1.0040040008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbfff7f), -0x1.00400400081p+44, 0x0p+0 },
+{ INT64_C(0x0000100400400800), 0x1.004004008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbff7ff), -0x1.00400400801p+44, 0x0p+0 },
+{ INT64_C(0x0000100400401000), 0x1.00400401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbfefff), -0x1.00400401001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400408000), 0x1.00400408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbf7fff), -0x1.00400408001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400420000), 0x1.0040042p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbffbdffff), -0x1.00400420001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400600000), 0x1.004006p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff9fffff), -0x1.00400600001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400800000), 0x1.004008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7fffff), -0x1.00400800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400800008), 0x1.00400800008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7ffff7), -0x1.00400800009p+44, 0x0p+0 },
+{ INT64_C(0x0000100400800080), 0x1.0040080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7fff7f), -0x1.00400800081p+44, 0x0p+0 },
+{ INT64_C(0x0000100400800400), 0x1.004008004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7ffbff), -0x1.00400800401p+44, 0x0p+0 },
+{ INT64_C(0x0000100400800800), 0x1.004008008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7ff7ff), -0x1.00400800801p+44, 0x0p+0 },
+{ INT64_C(0x0000100400802000), 0x1.00400802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7fdfff), -0x1.00400802001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400804000), 0x1.00400804p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7fbfff), -0x1.00400804001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400808000), 0x1.00400808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7f7fff), -0x1.00400808001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400810000), 0x1.0040081p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7effff), -0x1.00400810001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400820000), 0x1.0040082p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff7dffff), -0x1.00400820001p+44, 0x0p+0 },
+{ INT64_C(0x0000100400a00000), 0x1.00400ap+44, 0x0p+0 },
+{ INT64_C(0xffffeffbff5fffff), -0x1.00400a00001p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000000), 0x1.00401p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfeffffff), -0x1.00401000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000001), 0x1.00401000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfefffffe), -0x1.00401000002p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000004), 0x1.00401000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfefffffb), -0x1.00401000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000008), 0x1.00401000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfefffff7), -0x1.00401000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000020), 0x1.0040100002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfeffffdf), -0x1.00401000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000080), 0x1.0040100008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfeffff7f), -0x1.00401000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000200), 0x1.004010002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfefffdff), -0x1.00401000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100401000800), 0x1.004010008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfefff7ff), -0x1.00401000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100401001000), 0x1.00401001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfeffefff), -0x1.00401001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100401008000), 0x1.00401008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfeff7fff), -0x1.00401008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100401020000), 0x1.0040102p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfefdffff), -0x1.00401020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100401080000), 0x1.0040108p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfef7ffff), -0x1.00401080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100401400000), 0x1.004014p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfebfffff), -0x1.00401400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100404000000), 0x1.00404p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbffffff), -0x1.00404000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100404000001), 0x1.00404000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbfffffe), -0x1.00404000002p+44, 0x0p+0 },
+{ INT64_C(0x0000100404000008), 0x1.00404000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbfffff7), -0x1.00404000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100404000010), 0x1.0040400001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbffffef), -0x1.00404000011p+44, 0x0p+0 },
+{ INT64_C(0x0000100404000080), 0x1.0040400008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbffff7f), -0x1.00404000081p+44, 0x0p+0 },
+{ INT64_C(0x0000100404000200), 0x1.004040002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbfffdff), -0x1.00404000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100404001000), 0x1.00404001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbffefff), -0x1.00404001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100404004000), 0x1.00404004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbffbfff), -0x1.00404004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100404040000), 0x1.0040404p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbfbffff), -0x1.00404040001p+44, 0x0p+0 },
+{ INT64_C(0x0000100404080000), 0x1.0040408p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbf7ffff), -0x1.00404080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100404400000), 0x1.004044p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbfbbfffff), -0x1.00404400001p+44, 0x0p+0 },
+{ INT64_C(0x0000100420000000), 0x1.0042p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdfffffff), -0x1.00420000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100420000004), 0x1.00420000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdffffffb), -0x1.00420000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100420000008), 0x1.00420000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdffffff7), -0x1.00420000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100420000010), 0x1.0042000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdfffffef), -0x1.00420000011p+44, 0x0p+0 },
+{ INT64_C(0x0000100420000040), 0x1.0042000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdfffffbf), -0x1.00420000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100420000400), 0x1.004200004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdffffbff), -0x1.00420000401p+44, 0x0p+0 },
+{ INT64_C(0x0000100420004000), 0x1.00420004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdfffbfff), -0x1.00420004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100420008000), 0x1.00420008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdfff7fff), -0x1.00420008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100420080000), 0x1.0042008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdff7ffff), -0x1.00420080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100420800000), 0x1.004208p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdf7fffff), -0x1.00420800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100424000000), 0x1.00424p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbdbffffff), -0x1.00424000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100428000000), 0x1.00428p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbd7ffffff), -0x1.00428000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100430000000), 0x1.0043p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbcfffffff), -0x1.00430000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100440000000), 0x1.0044p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbfffffff), -0x1.00440000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100440000002), 0x1.00440000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbffffffd), -0x1.00440000003p+44, 0x0p+0 },
+{ INT64_C(0x0000100440000004), 0x1.00440000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbffffffb), -0x1.00440000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100440000040), 0x1.0044000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbfffffbf), -0x1.00440000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100440000400), 0x1.004400004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbffffbff), -0x1.00440000401p+44, 0x0p+0 },
+{ INT64_C(0x0000100440001000), 0x1.00440001p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbfffefff), -0x1.00440001001p+44, 0x0p+0 },
+{ INT64_C(0x0000100440008000), 0x1.00440008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbfff7fff), -0x1.00440008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100440080000), 0x1.0044008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbff7ffff), -0x1.00440080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100440200000), 0x1.004402p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbfdfffff), -0x1.00440200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100441000000), 0x1.00441p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbbeffffff), -0x1.00441000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100450000000), 0x1.0045p+44, 0x0p+0 },
+{ INT64_C(0xffffeffbafffffff), -0x1.00450000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000000), 0x1.0048p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7fffffff), -0x1.00480000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000004), 0x1.00480000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ffffffb), -0x1.00480000005p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000008), 0x1.00480000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ffffff7), -0x1.00480000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000020), 0x1.0048000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7fffffdf), -0x1.00480000021p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000200), 0x1.004800002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ffffdff), -0x1.00480000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000400), 0x1.004800004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ffffbff), -0x1.00480000401p+44, 0x0p+0 },
+{ INT64_C(0x0000100480000800), 0x1.004800008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ffff7ff), -0x1.00480000801p+44, 0x0p+0 },
+{ INT64_C(0x0000100480004000), 0x1.00480004p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7fffbfff), -0x1.00480004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480008000), 0x1.00480008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7fff7fff), -0x1.00480008001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480020000), 0x1.0048002p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ffdffff), -0x1.00480020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480080000), 0x1.0048008p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7ff7ffff), -0x1.00480080001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480100000), 0x1.004801p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7fefffff), -0x1.00480100001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480200000), 0x1.004802p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7fdfffff), -0x1.00480200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100480800000), 0x1.004808p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb7f7fffff), -0x1.00480800001p+44, 0x0p+0 },
+{ INT64_C(0x0000100488000000), 0x1.00488p+44, 0x0p+0 },
+{ INT64_C(0xffffeffb77ffffff), -0x1.00488000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100600000000), 0x1.006p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9ffffffff), -0x1.00600000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100600000008), 0x1.00600000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9fffffff7), -0x1.00600000009p+44, 0x0p+0 },
+{ INT64_C(0x0000100600000040), 0x1.0060000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9ffffffbf), -0x1.00600000041p+44, 0x0p+0 },
+{ INT64_C(0x0000100600000200), 0x1.006000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9fffffdff), -0x1.00600000201p+44, 0x0p+0 },
+{ INT64_C(0x0000100600002000), 0x1.00600002p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9ffffdfff), -0x1.00600002001p+44, 0x0p+0 },
+{ INT64_C(0x0000100600004000), 0x1.00600004p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9ffffbfff), -0x1.00600004001p+44, 0x0p+0 },
+{ INT64_C(0x0000100600020000), 0x1.0060002p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9fffdffff), -0x1.00600020001p+44, 0x0p+0 },
+{ INT64_C(0x0000100600200000), 0x1.006002p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9ffdfffff), -0x1.00600200001p+44, 0x0p+0 },
+{ INT64_C(0x0000100601000000), 0x1.00601p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9feffffff), -0x1.00601000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100610000000), 0x1.0061p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9efffffff), -0x1.00610000001p+44, 0x0p+0 },
+{ INT64_C(0x0000100640000000), 0x1.0064p+44, 0x0p+0 },
+{ INT64_C(0xffffeff9bfffffff), -0x1.00640000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000004), 0x1.02000000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffffffb), -0x1.02000000005p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000006), 0x1.02000000006p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffffff9), -0x1.02000000007p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000040), 0x1.0200000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffffbf), -0x1.02000000041p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000044), 0x1.02000000044p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffffbb), -0x1.02000000045p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000100), 0x1.020000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffffeff), -0x1.02000000101p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000104), 0x1.02000000104p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffffefb), -0x1.02000000105p+44, 0x0p+0 },
+{ INT64_C(0x0000102000000140), 0x1.0200000014p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffffebf), -0x1.02000000141p+44, 0x0p+0 },
+{ INT64_C(0x0000102000001000), 0x1.02000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffefff), -0x1.02000001001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000001004), 0x1.02000001004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffeffb), -0x1.02000001005p+44, 0x0p+0 },
+{ INT64_C(0x0000102000001008), 0x1.02000001008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffeff7), -0x1.02000001009p+44, 0x0p+0 },
+{ INT64_C(0x0000102000001080), 0x1.0200000108p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffef7f), -0x1.02000001081p+44, 0x0p+0 },
+{ INT64_C(0x0000102000001800), 0x1.020000018p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffffe7ff), -0x1.02000001801p+44, 0x0p+0 },
+{ INT64_C(0x0000102000010000), 0x1.0200001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffeffff), -0x1.02000010001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000010001), 0x1.02000010001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffefffe), -0x1.02000010002p+44, 0x0p+0 },
+{ INT64_C(0x0000102000010008), 0x1.02000010008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffefff7), -0x1.02000010009p+44, 0x0p+0 },
+{ INT64_C(0x0000102000010020), 0x1.0200001002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffeffdf), -0x1.02000010021p+44, 0x0p+0 },
+{ INT64_C(0x0000102000010200), 0x1.020000102p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffefdff), -0x1.02000010201p+44, 0x0p+0 },
+{ INT64_C(0x0000102000010800), 0x1.020000108p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffef7ff), -0x1.02000010801p+44, 0x0p+0 },
+{ INT64_C(0x0000102000018000), 0x1.02000018p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffffe7fff), -0x1.02000018001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000100000), 0x1.020001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffefffff), -0x1.02000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000100004), 0x1.02000100004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffeffffb), -0x1.02000100005p+44, 0x0p+0 },
+{ INT64_C(0x0000102000100020), 0x1.0200010002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffefffdf), -0x1.02000100021p+44, 0x0p+0 },
+{ INT64_C(0x0000102000100080), 0x1.0200010008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffefff7f), -0x1.02000100081p+44, 0x0p+0 },
+{ INT64_C(0x0000102000100800), 0x1.020001008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffeff7ff), -0x1.02000100801p+44, 0x0p+0 },
+{ INT64_C(0x0000102000104000), 0x1.02000104p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffefbfff), -0x1.02000104001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000120000), 0x1.0200012p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffedffff), -0x1.02000120001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000140000), 0x1.0200014p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfffebffff), -0x1.02000140001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000800000), 0x1.020008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7fffff), -0x1.02000800001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000800001), 0x1.02000800001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7ffffe), -0x1.02000800002p+44, 0x0p+0 },
+{ INT64_C(0x0000102000800010), 0x1.0200080001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7fffef), -0x1.02000800011p+44, 0x0p+0 },
+{ INT64_C(0x0000102000800100), 0x1.020008001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7ffeff), -0x1.02000800101p+44, 0x0p+0 },
+{ INT64_C(0x0000102000800800), 0x1.020008008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7ff7ff), -0x1.02000800801p+44, 0x0p+0 },
+{ INT64_C(0x0000102000802000), 0x1.02000802p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7fdfff), -0x1.02000802001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000804000), 0x1.02000804p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7fbfff), -0x1.02000804001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000810000), 0x1.0200081p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff7effff), -0x1.02000810001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000880000), 0x1.0200088p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff77ffff), -0x1.02000880001p+44, 0x0p+0 },
+{ INT64_C(0x0000102000a00000), 0x1.02000ap+44, 0x0p+0 },
+{ INT64_C(0xffffefdfff5fffff), -0x1.02000a00001p+44, 0x0p+0 },
+{ INT64_C(0x0000102004000000), 0x1.02004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbffffff), -0x1.02004000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102004000008), 0x1.02004000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbfffff7), -0x1.02004000009p+44, 0x0p+0 },
+{ INT64_C(0x0000102004000020), 0x1.0200400002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbffffdf), -0x1.02004000021p+44, 0x0p+0 },
+{ INT64_C(0x0000102004000080), 0x1.0200400008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbffff7f), -0x1.02004000081p+44, 0x0p+0 },
+{ INT64_C(0x0000102004000200), 0x1.020040002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbfffdff), -0x1.02004000201p+44, 0x0p+0 },
+{ INT64_C(0x0000102004000800), 0x1.020040008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbfff7ff), -0x1.02004000801p+44, 0x0p+0 },
+{ INT64_C(0x0000102004008000), 0x1.02004008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbff7fff), -0x1.02004008001p+44, 0x0p+0 },
+{ INT64_C(0x0000102004040000), 0x1.0200404p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbfbffff), -0x1.02004040001p+44, 0x0p+0 },
+{ INT64_C(0x0000102004200000), 0x1.020042p+44, 0x0p+0 },
+{ INT64_C(0xffffefdffbdfffff), -0x1.02004200001p+44, 0x0p+0 },
+{ INT64_C(0x0000102006000000), 0x1.02006p+44, 0x0p+0 },
+{ INT64_C(0xffffefdff9ffffff), -0x1.02006000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000000), 0x1.0201p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfefffffff), -0x1.02010000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000004), 0x1.02010000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeffffffb), -0x1.02010000005p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000008), 0x1.02010000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeffffff7), -0x1.02010000009p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000040), 0x1.0201000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfefffffbf), -0x1.02010000041p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000100), 0x1.020100001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeffffeff), -0x1.02010000101p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000200), 0x1.020100002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeffffdff), -0x1.02010000201p+44, 0x0p+0 },
+{ INT64_C(0x0000102010000800), 0x1.020100008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeffff7ff), -0x1.02010000801p+44, 0x0p+0 },
+{ INT64_C(0x0000102010004000), 0x1.02010004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfefffbfff), -0x1.02010004001p+44, 0x0p+0 },
+{ INT64_C(0x0000102010040000), 0x1.0201004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeffbffff), -0x1.02010040001p+44, 0x0p+0 },
+{ INT64_C(0x0000102010400000), 0x1.020104p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfefbfffff), -0x1.02010400001p+44, 0x0p+0 },
+{ INT64_C(0x0000102011000000), 0x1.02011p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfeeffffff), -0x1.02011000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102020000000), 0x1.0202p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdfffffff), -0x1.02020000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102020000008), 0x1.02020000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdffffff7), -0x1.02020000009p+44, 0x0p+0 },
+{ INT64_C(0x0000102020000010), 0x1.0202000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdfffffef), -0x1.02020000011p+44, 0x0p+0 },
+{ INT64_C(0x0000102020000040), 0x1.0202000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdfffffbf), -0x1.02020000041p+44, 0x0p+0 },
+{ INT64_C(0x0000102020000080), 0x1.0202000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdfffff7f), -0x1.02020000081p+44, 0x0p+0 },
+{ INT64_C(0x0000102020000800), 0x1.020200008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdffff7ff), -0x1.02020000801p+44, 0x0p+0 },
+{ INT64_C(0x0000102020008000), 0x1.02020008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdfff7fff), -0x1.02020008001p+44, 0x0p+0 },
+{ INT64_C(0x0000102020020000), 0x1.0202002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdffdffff), -0x1.02020020001p+44, 0x0p+0 },
+{ INT64_C(0x0000102020200000), 0x1.020202p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdfdfffff), -0x1.02020200001p+44, 0x0p+0 },
+{ INT64_C(0x0000102021000000), 0x1.02021p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfdeffffff), -0x1.02021000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102028000000), 0x1.02028p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfd7ffffff), -0x1.02028000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102030000000), 0x1.0203p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfcfffffff), -0x1.02030000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000000), 0x1.0204p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffffff), -0x1.02040000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000001), 0x1.02040000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbffffffe), -0x1.02040000002p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000010), 0x1.0204000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffffef), -0x1.02040000011p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000020), 0x1.0204000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffffdf), -0x1.02040000021p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000040), 0x1.0204000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffffbf), -0x1.02040000041p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000080), 0x1.0204000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffff7f), -0x1.02040000081p+44, 0x0p+0 },
+{ INT64_C(0x0000102040000800), 0x1.020400008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbffff7ff), -0x1.02040000801p+44, 0x0p+0 },
+{ INT64_C(0x0000102040001000), 0x1.02040001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffefff), -0x1.02040001001p+44, 0x0p+0 },
+{ INT64_C(0x0000102040002000), 0x1.02040002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfffdfff), -0x1.02040002001p+44, 0x0p+0 },
+{ INT64_C(0x0000102040020000), 0x1.0204002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbffdffff), -0x1.02040020001p+44, 0x0p+0 },
+{ INT64_C(0x0000102040100000), 0x1.020401p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbfefffff), -0x1.02040100001p+44, 0x0p+0 },
+{ INT64_C(0x0000102041000000), 0x1.02041p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbeffffff), -0x1.02041000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102042000000), 0x1.02042p+44, 0x0p+0 },
+{ INT64_C(0xffffefdfbdffffff), -0x1.02042000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102060000000), 0x1.0206p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf9fffffff), -0x1.02060000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102080000000), 0x1.0208p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7fffffff), -0x1.02080000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102080000004), 0x1.02080000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7ffffffb), -0x1.02080000005p+44, 0x0p+0 },
+{ INT64_C(0x0000102080000010), 0x1.0208000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7fffffef), -0x1.02080000011p+44, 0x0p+0 },
+{ INT64_C(0x0000102080000020), 0x1.0208000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7fffffdf), -0x1.02080000021p+44, 0x0p+0 },
+{ INT64_C(0x0000102080000100), 0x1.020800001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7ffffeff), -0x1.02080000101p+44, 0x0p+0 },
+{ INT64_C(0x0000102080000800), 0x1.020800008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7ffff7ff), -0x1.02080000801p+44, 0x0p+0 },
+{ INT64_C(0x0000102080008000), 0x1.02080008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7fff7fff), -0x1.02080008001p+44, 0x0p+0 },
+{ INT64_C(0x0000102080020000), 0x1.0208002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7ffdffff), -0x1.02080020001p+44, 0x0p+0 },
+{ INT64_C(0x0000102080200000), 0x1.020802p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7fdfffff), -0x1.02080200001p+44, 0x0p+0 },
+{ INT64_C(0x0000102080800000), 0x1.020808p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7f7fffff), -0x1.02080800001p+44, 0x0p+0 },
+{ INT64_C(0x0000102081000000), 0x1.02081p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf7effffff), -0x1.02081000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102090000000), 0x1.0209p+44, 0x0p+0 },
+{ INT64_C(0xffffefdf6fffffff), -0x1.02090000001p+44, 0x0p+0 },
+{ INT64_C(0x00001020a0000000), 0x1.020ap+44, 0x0p+0 },
+{ INT64_C(0xffffefdf5fffffff), -0x1.020a0000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000000), 0x1.021p+44, 0x0p+0 },
+{ INT64_C(0xffffefdeffffffff), -0x1.02100000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000002), 0x1.02100000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefffffffd), -0x1.02100000003p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000008), 0x1.02100000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefffffff7), -0x1.02100000009p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000020), 0x1.0210000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdeffffffdf), -0x1.02100000021p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000100), 0x1.021000001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefffffeff), -0x1.02100000101p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000400), 0x1.021000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefffffbff), -0x1.02100000401p+44, 0x0p+0 },
+{ INT64_C(0x0000102100000800), 0x1.021000008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefffff7ff), -0x1.02100000801p+44, 0x0p+0 },
+{ INT64_C(0x0000102100004000), 0x1.02100004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdeffffbfff), -0x1.02100004001p+44, 0x0p+0 },
+{ INT64_C(0x0000102100010000), 0x1.0210001p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefffeffff), -0x1.02100010001p+44, 0x0p+0 },
+{ INT64_C(0x0000102100080000), 0x1.0210008p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefff7ffff), -0x1.02100080001p+44, 0x0p+0 },
+{ INT64_C(0x0000102100200000), 0x1.021002p+44, 0x0p+0 },
+{ INT64_C(0xffffefdeffdfffff), -0x1.02100200001p+44, 0x0p+0 },
+{ INT64_C(0x0000102100400000), 0x1.021004p+44, 0x0p+0 },
+{ INT64_C(0xffffefdeffbfffff), -0x1.02100400001p+44, 0x0p+0 },
+{ INT64_C(0x0000102102000000), 0x1.02102p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefdffffff), -0x1.02102000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102104000000), 0x1.02104p+44, 0x0p+0 },
+{ INT64_C(0xffffefdefbffffff), -0x1.02104000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102140000000), 0x1.0214p+44, 0x0p+0 },
+{ INT64_C(0xffffefdebfffffff), -0x1.02140000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102800000000), 0x1.028p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7ffffffff), -0x1.02800000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102800000002), 0x1.02800000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fffffffd), -0x1.02800000003p+44, 0x0p+0 },
+{ INT64_C(0x0000102800000004), 0x1.02800000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fffffffb), -0x1.02800000005p+44, 0x0p+0 },
+{ INT64_C(0x0000102800000040), 0x1.0280000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7ffffffbf), -0x1.02800000041p+44, 0x0p+0 },
+{ INT64_C(0x0000102800000200), 0x1.028000002p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fffffdff), -0x1.02800000201p+44, 0x0p+0 },
+{ INT64_C(0x0000102800000400), 0x1.028000004p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fffffbff), -0x1.02800000401p+44, 0x0p+0 },
+{ INT64_C(0x0000102800004000), 0x1.02800004p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7ffffbfff), -0x1.02800004001p+44, 0x0p+0 },
+{ INT64_C(0x0000102800040000), 0x1.0280004p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fffbffff), -0x1.02800040001p+44, 0x0p+0 },
+{ INT64_C(0x0000102800080000), 0x1.0280008p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fff7ffff), -0x1.02800080001p+44, 0x0p+0 },
+{ INT64_C(0x0000102800800000), 0x1.028008p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7ff7fffff), -0x1.02800800001p+44, 0x0p+0 },
+{ INT64_C(0x0000102804000000), 0x1.02804p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7fbffffff), -0x1.02804000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102810000000), 0x1.0281p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7efffffff), -0x1.02810000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102840000000), 0x1.0284p+44, 0x0p+0 },
+{ INT64_C(0xffffefd7bfffffff), -0x1.02840000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102900000000), 0x1.029p+44, 0x0p+0 },
+{ INT64_C(0xffffefd6ffffffff), -0x1.02900000001p+44, 0x0p+0 },
+{ INT64_C(0x0000102c00000000), 0x1.02cp+44, 0x0p+0 },
+{ INT64_C(0xffffefd3ffffffff), -0x1.02c00000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000004), 0x1.10000000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffffb), -0x1.10000000005p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000005), 0x1.10000000005p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffffa), -0x1.10000000006p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000006), 0x1.10000000006p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffff9), -0x1.10000000007p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000010), 0x1.1000000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffffef), -0x1.10000000011p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000014), 0x1.10000000014p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffffeb), -0x1.10000000015p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000018), 0x1.10000000018p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffffe7), -0x1.10000000019p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000100), 0x1.100000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffeff), -0x1.10000000101p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000104), 0x1.10000000104p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffefb), -0x1.10000000105p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000110), 0x1.1000000011p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffeef), -0x1.10000000111p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000140), 0x1.1000000014p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffebf), -0x1.10000000141p+44, 0x0p+0 },
+{ INT64_C(0x0000110000000180), 0x1.1000000018p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffffffe7f), -0x1.10000000181p+44, 0x0p+0 },
+{ INT64_C(0x0000110000001000), 0x1.10000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffefff), -0x1.10000001001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000001001), 0x1.10000001001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffeffe), -0x1.10000001002p+44, 0x0p+0 },
+{ INT64_C(0x0000110000001008), 0x1.10000001008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffeff7), -0x1.10000001009p+44, 0x0p+0 },
+{ INT64_C(0x0000110000001040), 0x1.1000000104p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffefbf), -0x1.10000001041p+44, 0x0p+0 },
+{ INT64_C(0x0000110000001400), 0x1.100000014p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffffebff), -0x1.10000001401p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008000), 0x1.10000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7fff), -0x1.10000008001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008002), 0x1.10000008002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7ffd), -0x1.10000008003p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008020), 0x1.1000000802p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7fdf), -0x1.10000008021p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008040), 0x1.1000000804p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7fbf), -0x1.10000008041p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008080), 0x1.1000000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7f7f), -0x1.10000008081p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008100), 0x1.100000081p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7eff), -0x1.10000008101p+44, 0x0p+0 },
+{ INT64_C(0x0000110000008400), 0x1.100000084p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff7bff), -0x1.10000008401p+44, 0x0p+0 },
+{ INT64_C(0x0000110000009000), 0x1.10000009p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffff6fff), -0x1.10000009001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000080000), 0x1.1000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff7ffff), -0x1.10000080001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000080001), 0x1.10000080001p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff7fffe), -0x1.10000080002p+44, 0x0p+0 },
+{ INT64_C(0x0000110000080010), 0x1.1000008001p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff7ffef), -0x1.10000080011p+44, 0x0p+0 },
+{ INT64_C(0x0000110000080100), 0x1.100000801p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff7feff), -0x1.10000080101p+44, 0x0p+0 },
+{ INT64_C(0x0000110000080800), 0x1.100000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff7f7ff), -0x1.10000080801p+44, 0x0p+0 },
+{ INT64_C(0x0000110000082000), 0x1.10000082p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff7dfff), -0x1.10000082001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000090000), 0x1.1000009p+44, 0x0p+0 },
+{ INT64_C(0xffffeefffff6ffff), -0x1.10000090001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000100000), 0x1.100001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffefffff), -0x1.10000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000100002), 0x1.10000100002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffeffffd), -0x1.10000100003p+44, 0x0p+0 },
+{ INT64_C(0x0000110000100020), 0x1.1000010002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffefffdf), -0x1.10000100021p+44, 0x0p+0 },
+{ INT64_C(0x0000110000100200), 0x1.100001002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffeffdff), -0x1.10000100201p+44, 0x0p+0 },
+{ INT64_C(0x0000110000101000), 0x1.10000101p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffefefff), -0x1.10000101001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000108000), 0x1.10000108p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffef7fff), -0x1.10000108001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000140000), 0x1.1000014p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffffebffff), -0x1.10000140001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000800000), 0x1.100008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7fffff), -0x1.10000800001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000800001), 0x1.10000800001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7ffffe), -0x1.10000800002p+44, 0x0p+0 },
+{ INT64_C(0x0000110000800010), 0x1.1000080001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7fffef), -0x1.10000800011p+44, 0x0p+0 },
+{ INT64_C(0x0000110000800100), 0x1.100008001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7ffeff), -0x1.10000800101p+44, 0x0p+0 },
+{ INT64_C(0x0000110000801000), 0x1.10000801p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7fefff), -0x1.10000801001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000802000), 0x1.10000802p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7fdfff), -0x1.10000802001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000820000), 0x1.1000082p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff7dffff), -0x1.10000820001p+44, 0x0p+0 },
+{ INT64_C(0x0000110000a00000), 0x1.10000ap+44, 0x0p+0 },
+{ INT64_C(0xffffeeffff5fffff), -0x1.10000a00001p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000000), 0x1.10008p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7ffffff), -0x1.10008000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000001), 0x1.10008000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7fffffe), -0x1.10008000002p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000002), 0x1.10008000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7fffffd), -0x1.10008000003p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000008), 0x1.10008000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7fffff7), -0x1.10008000009p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000040), 0x1.1000800004p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7ffffbf), -0x1.10008000041p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000200), 0x1.100080002p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7fffdff), -0x1.10008000201p+44, 0x0p+0 },
+{ INT64_C(0x0000110008000800), 0x1.100080008p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7fff7ff), -0x1.10008000801p+44, 0x0p+0 },
+{ INT64_C(0x0000110008002000), 0x1.10008002p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7ffdfff), -0x1.10008002001p+44, 0x0p+0 },
+{ INT64_C(0x0000110008004000), 0x1.10008004p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7ffbfff), -0x1.10008004001p+44, 0x0p+0 },
+{ INT64_C(0x0000110008010000), 0x1.1000801p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7feffff), -0x1.10008010001p+44, 0x0p+0 },
+{ INT64_C(0x0000110008080000), 0x1.1000808p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff7f7ffff), -0x1.10008080001p+44, 0x0p+0 },
+{ INT64_C(0x0000110008800000), 0x1.100088p+44, 0x0p+0 },
+{ INT64_C(0xffffeefff77fffff), -0x1.10008800001p+44, 0x0p+0 },
+{ INT64_C(0x000011000c000000), 0x1.1000cp+44, 0x0p+0 },
+{ INT64_C(0xffffeefff3ffffff), -0x1.1000c000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110010000000), 0x1.1001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffefffffff), -0x1.10010000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110010000008), 0x1.10010000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffeffffff7), -0x1.10010000009p+44, 0x0p+0 },
+{ INT64_C(0x0000110010000010), 0x1.1001000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffefffffef), -0x1.10010000011p+44, 0x0p+0 },
+{ INT64_C(0x0000110010000080), 0x1.1001000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffefffff7f), -0x1.10010000081p+44, 0x0p+0 },
+{ INT64_C(0x0000110010000200), 0x1.100100002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffeffffdff), -0x1.10010000201p+44, 0x0p+0 },
+{ INT64_C(0x0000110010002000), 0x1.10010002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffefffdfff), -0x1.10010002001p+44, 0x0p+0 },
+{ INT64_C(0x0000110010020000), 0x1.1001002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffeffdffff), -0x1.10010020001p+44, 0x0p+0 },
+{ INT64_C(0x0000110010100000), 0x1.100101p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffefefffff), -0x1.10010100001p+44, 0x0p+0 },
+{ INT64_C(0x0000110010400000), 0x1.100104p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffefbfffff), -0x1.10010400001p+44, 0x0p+0 },
+{ INT64_C(0x0000110012000000), 0x1.10012p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffedffffff), -0x1.10012000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110018000000), 0x1.10018p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffe7ffffff), -0x1.10018000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110040000000), 0x1.1004p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbfffffff), -0x1.10040000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110040000008), 0x1.10040000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbffffff7), -0x1.10040000009p+44, 0x0p+0 },
+{ INT64_C(0x0000110040000020), 0x1.1004000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbfffffdf), -0x1.10040000021p+44, 0x0p+0 },
+{ INT64_C(0x0000110040000040), 0x1.1004000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbfffffbf), -0x1.10040000041p+44, 0x0p+0 },
+{ INT64_C(0x0000110040000200), 0x1.100400002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbffffdff), -0x1.10040000201p+44, 0x0p+0 },
+{ INT64_C(0x0000110040002000), 0x1.10040002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbfffdfff), -0x1.10040002001p+44, 0x0p+0 },
+{ INT64_C(0x0000110040008000), 0x1.10040008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbfff7fff), -0x1.10040008001p+44, 0x0p+0 },
+{ INT64_C(0x0000110040040000), 0x1.1004004p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbffbffff), -0x1.10040040001p+44, 0x0p+0 },
+{ INT64_C(0x0000110040080000), 0x1.1004008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbff7ffff), -0x1.10040080001p+44, 0x0p+0 },
+{ INT64_C(0x0000110040800000), 0x1.100408p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbf7fffff), -0x1.10040800001p+44, 0x0p+0 },
+{ INT64_C(0x0000110044000000), 0x1.10044p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffbbffffff), -0x1.10044000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110048000000), 0x1.10048p+44, 0x0p+0 },
+{ INT64_C(0xffffeeffb7ffffff), -0x1.10048000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110060000000), 0x1.1006p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff9fffffff), -0x1.10060000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110080000000), 0x1.1008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7fffffff), -0x1.10080000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110080000001), 0x1.10080000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7ffffffe), -0x1.10080000002p+44, 0x0p+0 },
+{ INT64_C(0x0000110080000008), 0x1.10080000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7ffffff7), -0x1.10080000009p+44, 0x0p+0 },
+{ INT64_C(0x0000110080000040), 0x1.1008000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7fffffbf), -0x1.10080000041p+44, 0x0p+0 },
+{ INT64_C(0x0000110080000080), 0x1.1008000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7fffff7f), -0x1.10080000081p+44, 0x0p+0 },
+{ INT64_C(0x0000110080000200), 0x1.100800002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7ffffdff), -0x1.10080000201p+44, 0x0p+0 },
+{ INT64_C(0x0000110080002000), 0x1.10080002p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7fffdfff), -0x1.10080002001p+44, 0x0p+0 },
+{ INT64_C(0x0000110080010000), 0x1.1008001p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7ffeffff), -0x1.10080010001p+44, 0x0p+0 },
+{ INT64_C(0x0000110080100000), 0x1.100801p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7fefffff), -0x1.10080100001p+44, 0x0p+0 },
+{ INT64_C(0x0000110080400000), 0x1.100804p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7fbfffff), -0x1.10080400001p+44, 0x0p+0 },
+{ INT64_C(0x0000110081000000), 0x1.10081p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff7effffff), -0x1.10081000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110088000000), 0x1.10088p+44, 0x0p+0 },
+{ INT64_C(0xffffeeff77ffffff), -0x1.10088000001p+44, 0x0p+0 },
+{ INT64_C(0x00001100c0000000), 0x1.100cp+44, 0x0p+0 },
+{ INT64_C(0xffffeeff3fffffff), -0x1.100c0000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110400000000), 0x1.104p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbffffffff), -0x1.10400000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110400000004), 0x1.10400000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbfffffffb), -0x1.10400000005p+44, 0x0p+0 },
+{ INT64_C(0x0000110400000040), 0x1.1040000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbffffffbf), -0x1.10400000041p+44, 0x0p+0 },
+{ INT64_C(0x0000110400000080), 0x1.1040000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbffffff7f), -0x1.10400000081p+44, 0x0p+0 },
+{ INT64_C(0x0000110400000200), 0x1.104000002p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbfffffdff), -0x1.10400000201p+44, 0x0p+0 },
+{ INT64_C(0x0000110400002000), 0x1.10400002p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbffffdfff), -0x1.10400002001p+44, 0x0p+0 },
+{ INT64_C(0x0000110400010000), 0x1.1040001p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbfffeffff), -0x1.10400010001p+44, 0x0p+0 },
+{ INT64_C(0x0000110400100000), 0x1.104001p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbffefffff), -0x1.10400100001p+44, 0x0p+0 },
+{ INT64_C(0x0000110400400000), 0x1.104004p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbffbfffff), -0x1.10400400001p+44, 0x0p+0 },
+{ INT64_C(0x0000110400800000), 0x1.104008p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbff7fffff), -0x1.10400800001p+44, 0x0p+0 },
+{ INT64_C(0x0000110404000000), 0x1.10404p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbfbffffff), -0x1.10404000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110420000000), 0x1.1042p+44, 0x0p+0 },
+{ INT64_C(0xffffeefbdfffffff), -0x1.10420000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110480000000), 0x1.1048p+44, 0x0p+0 },
+{ INT64_C(0xffffeefb7fffffff), -0x1.10480000001p+44, 0x0p+0 },
+{ INT64_C(0x0000110600000000), 0x1.106p+44, 0x0p+0 },
+{ INT64_C(0xffffeef9ffffffff), -0x1.10600000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000000), 0x1.12p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffffffff), -0x1.12000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000001), 0x1.12000000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffffffffe), -0x1.12000000002p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000004), 0x1.12000000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffffffffb), -0x1.12000000005p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000010), 0x1.1200000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffffffef), -0x1.12000000011p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000080), 0x1.1200000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffffff7f), -0x1.12000000081p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000100), 0x1.120000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffffffeff), -0x1.12000000101p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000400), 0x1.120000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffffffbff), -0x1.12000000401p+44, 0x0p+0 },
+{ INT64_C(0x0000112000000800), 0x1.120000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffffff7ff), -0x1.12000000801p+44, 0x0p+0 },
+{ INT64_C(0x0000112000001000), 0x1.12000001p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffffefff), -0x1.12000001001p+44, 0x0p+0 },
+{ INT64_C(0x0000112000004000), 0x1.12000004p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffffbfff), -0x1.12000004001p+44, 0x0p+0 },
+{ INT64_C(0x0000112000008000), 0x1.12000008p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffff7fff), -0x1.12000008001p+44, 0x0p+0 },
+{ INT64_C(0x0000112000020000), 0x1.1200002p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffffdffff), -0x1.12000020001p+44, 0x0p+0 },
+{ INT64_C(0x0000112000100000), 0x1.120001p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfffefffff), -0x1.12000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000112001000000), 0x1.12001p+44, 0x0p+0 },
+{ INT64_C(0xffffeedffeffffff), -0x1.12001000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112008000000), 0x1.12008p+44, 0x0p+0 },
+{ INT64_C(0xffffeedff7ffffff), -0x1.12008000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112010000000), 0x1.1201p+44, 0x0p+0 },
+{ INT64_C(0xffffeedfefffffff), -0x1.12010000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112100000000), 0x1.121p+44, 0x0p+0 },
+{ INT64_C(0xffffeedeffffffff), -0x1.12100000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112400000000), 0x1.124p+44, 0x0p+0 },
+{ INT64_C(0xffffeedbffffffff), -0x1.12400000001p+44, 0x0p+0 },
+{ INT64_C(0x0000112800000000), 0x1.128p+44, 0x0p+0 },
+{ INT64_C(0xffffeed7ffffffff), -0x1.12800000001p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000000), 0x1.18p+44, 0x0p+0 },
+{ INT64_C(0xffffee7fffffffff), -0x1.18000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000001), 0x1.18000000001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffffffe), -0x1.18000000002p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000002), 0x1.18000000002p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffffffd), -0x1.18000000003p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000004), 0x1.18000000004p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffffffb), -0x1.18000000005p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000008), 0x1.18000000008p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffffff7), -0x1.18000000009p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000010), 0x1.1800000001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7fffffffef), -0x1.18000000011p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000020), 0x1.1800000002p+44, 0x0p+0 },
+{ INT64_C(0xffffee7fffffffdf), -0x1.18000000021p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000100), 0x1.180000001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffffeff), -0x1.18000000101p+44, 0x0p+0 },
+{ INT64_C(0x0000118000000400), 0x1.180000004p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffffbff), -0x1.18000000401p+44, 0x0p+0 },
+{ INT64_C(0x0000118000001000), 0x1.18000001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7fffffefff), -0x1.18000001001p+44, 0x0p+0 },
+{ INT64_C(0x0000118000010000), 0x1.1800001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffeffff), -0x1.18000010001p+44, 0x0p+0 },
+{ INT64_C(0x0000118000040000), 0x1.1800004p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffffbffff), -0x1.18000040001p+44, 0x0p+0 },
+{ INT64_C(0x0000118000100000), 0x1.180001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7fffefffff), -0x1.18000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000118000200000), 0x1.180002p+44, 0x0p+0 },
+{ INT64_C(0xffffee7fffdfffff), -0x1.18000200001p+44, 0x0p+0 },
+{ INT64_C(0x0000118001000000), 0x1.18001p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ffeffffff), -0x1.18001000001p+44, 0x0p+0 },
+{ INT64_C(0x0000118008000000), 0x1.18008p+44, 0x0p+0 },
+{ INT64_C(0xffffee7ff7ffffff), -0x1.18008000001p+44, 0x0p+0 },
+{ INT64_C(0x0000118080000000), 0x1.1808p+44, 0x0p+0 },
+{ INT64_C(0xffffee7f7fffffff), -0x1.18080000001p+44, 0x0p+0 },
+{ INT64_C(0x0000118800000000), 0x1.188p+44, 0x0p+0 },
+{ INT64_C(0xffffee77ffffffff), -0x1.18800000001p+44, 0x0p+0 },
+{ INT64_C(0x000011a000000000), 0x1.1ap+44, 0x0p+0 },
+{ INT64_C(0xffffee5fffffffff), -0x1.1a000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000008), 0x1.80000000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffff7), -0x1.80000000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000010), 0x1.8000000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffffef), -0x1.80000000011p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000018), 0x1.80000000018p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffffe7), -0x1.80000000019p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000020), 0x1.8000000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffffdf), -0x1.80000000021p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000028), 0x1.80000000028p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffffd7), -0x1.80000000029p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000200), 0x1.800000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffdff), -0x1.80000000201p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000208), 0x1.80000000208p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffdf7), -0x1.80000000209p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000280), 0x1.8000000028p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffd7f), -0x1.80000000281p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000400), 0x1.800000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffbff), -0x1.80000000401p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000401), 0x1.80000000401p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffbfe), -0x1.80000000402p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000408), 0x1.80000000408p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffbf7), -0x1.80000000409p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000410), 0x1.8000000041p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffbef), -0x1.80000000411p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000500), 0x1.800000005p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffffaff), -0x1.80000000501p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000600), 0x1.800000006p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffff9ff), -0x1.80000000601p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000800), 0x1.800000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffff7ff), -0x1.80000000801p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000808), 0x1.80000000808p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffff7f7), -0x1.80000000809p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000880), 0x1.8000000088p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffff77f), -0x1.80000000881p+44, 0x0p+0 },
+{ INT64_C(0x0000180000000a00), 0x1.80000000ap+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffff5ff), -0x1.80000000a01p+44, 0x0p+0 },
+{ INT64_C(0x0000180000002000), 0x1.80000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffdfff), -0x1.80000002001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000002004), 0x1.80000002004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffdffb), -0x1.80000002005p+44, 0x0p+0 },
+{ INT64_C(0x0000180000002008), 0x1.80000002008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffdff7), -0x1.80000002009p+44, 0x0p+0 },
+{ INT64_C(0x0000180000002080), 0x1.8000000208p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffdf7f), -0x1.80000002081p+44, 0x0p+0 },
+{ INT64_C(0x0000180000002400), 0x1.800000024p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffdbff), -0x1.80000002401p+44, 0x0p+0 },
+{ INT64_C(0x0000180000002800), 0x1.800000028p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffffd7ff), -0x1.80000002801p+44, 0x0p+0 },
+{ INT64_C(0x0000180000010000), 0x1.8000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffeffff), -0x1.80000010001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000010004), 0x1.80000010004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffefffb), -0x1.80000010005p+44, 0x0p+0 },
+{ INT64_C(0x0000180000010010), 0x1.8000001001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffeffef), -0x1.80000010011p+44, 0x0p+0 },
+{ INT64_C(0x0000180000010040), 0x1.8000001004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffeffbf), -0x1.80000010041p+44, 0x0p+0 },
+{ INT64_C(0x0000180000010400), 0x1.800000104p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffefbff), -0x1.80000010401p+44, 0x0p+0 },
+{ INT64_C(0x0000180000011000), 0x1.80000011p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffeefff), -0x1.80000011001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000014000), 0x1.80000014p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffffebfff), -0x1.80000014001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100000), 0x1.800001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffefffff), -0x1.80000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100004), 0x1.80000100004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffeffffb), -0x1.80000100005p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100008), 0x1.80000100008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffeffff7), -0x1.80000100009p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100010), 0x1.8000010001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffefffef), -0x1.80000100011p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100020), 0x1.8000010002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffefffdf), -0x1.80000100021p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100040), 0x1.8000010004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffefffbf), -0x1.80000100041p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100200), 0x1.800001002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffeffdff), -0x1.80000100201p+44, 0x0p+0 },
+{ INT64_C(0x0000180000100800), 0x1.800001008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffeff7ff), -0x1.80000100801p+44, 0x0p+0 },
+{ INT64_C(0x0000180000101000), 0x1.80000101p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffefefff), -0x1.80000101001p+44, 0x0p+0 },
+{ INT64_C(0x0000180000110000), 0x1.8000011p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffffeeffff), -0x1.80000110001p+44, 0x0p+0 },
+{ INT64_C(0x0000180001000000), 0x1.80001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffeffffff), -0x1.80001000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180001000008), 0x1.80001000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffefffff7), -0x1.80001000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180001000040), 0x1.8000100004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffeffffbf), -0x1.80001000041p+44, 0x0p+0 },
+{ INT64_C(0x0000180001000400), 0x1.800010004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffefffbff), -0x1.80001000401p+44, 0x0p+0 },
+{ INT64_C(0x0000180001000800), 0x1.800010008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffefff7ff), -0x1.80001000801p+44, 0x0p+0 },
+{ INT64_C(0x0000180001004000), 0x1.80001004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffeffbfff), -0x1.80001004001p+44, 0x0p+0 },
+{ INT64_C(0x0000180001008000), 0x1.80001008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffeff7fff), -0x1.80001008001p+44, 0x0p+0 },
+{ INT64_C(0x0000180001040000), 0x1.8000104p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffefbffff), -0x1.80001040001p+44, 0x0p+0 },
+{ INT64_C(0x0000180001080000), 0x1.8000108p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffef7ffff), -0x1.80001080001p+44, 0x0p+0 },
+{ INT64_C(0x0000180001800000), 0x1.800018p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffe7fffff), -0x1.80001800001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004000000), 0x1.80004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbffffff), -0x1.80004000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004000008), 0x1.80004000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbfffff7), -0x1.80004000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180004000010), 0x1.8000400001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbffffef), -0x1.80004000011p+44, 0x0p+0 },
+{ INT64_C(0x0000180004000040), 0x1.8000400004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbffffbf), -0x1.80004000041p+44, 0x0p+0 },
+{ INT64_C(0x0000180004000400), 0x1.800040004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbfffbff), -0x1.80004000401p+44, 0x0p+0 },
+{ INT64_C(0x0000180004000800), 0x1.800040008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbfff7ff), -0x1.80004000801p+44, 0x0p+0 },
+{ INT64_C(0x0000180004001000), 0x1.80004001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbffefff), -0x1.80004001001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004008000), 0x1.80004008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbff7fff), -0x1.80004008001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004020000), 0x1.8000402p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbfdffff), -0x1.80004020001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004040000), 0x1.8000404p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbfbffff), -0x1.80004040001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004100000), 0x1.800041p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbefffff), -0x1.80004100001p+44, 0x0p+0 },
+{ INT64_C(0x0000180004200000), 0x1.800042p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fffbdfffff), -0x1.80004200001p+44, 0x0p+0 },
+{ INT64_C(0x0000180006000000), 0x1.80006p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff9ffffff), -0x1.80006000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180008000000), 0x1.80008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7ffffff), -0x1.80008000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180008000008), 0x1.80008000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7fffff7), -0x1.80008000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180008000020), 0x1.8000800002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7ffffdf), -0x1.80008000021p+44, 0x0p+0 },
+{ INT64_C(0x0000180008000100), 0x1.800080001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7fffeff), -0x1.80008000101p+44, 0x0p+0 },
+{ INT64_C(0x0000180008000400), 0x1.800080004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7fffbff), -0x1.80008000401p+44, 0x0p+0 },
+{ INT64_C(0x0000180008004000), 0x1.80008004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7ffbfff), -0x1.80008004001p+44, 0x0p+0 },
+{ INT64_C(0x0000180008008000), 0x1.80008008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7ff7fff), -0x1.80008008001p+44, 0x0p+0 },
+{ INT64_C(0x0000180008020000), 0x1.8000802p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7fdffff), -0x1.80008020001p+44, 0x0p+0 },
+{ INT64_C(0x0000180008200000), 0x1.800082p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff7dfffff), -0x1.80008200001p+44, 0x0p+0 },
+{ INT64_C(0x000018000a000000), 0x1.8000ap+44, 0x0p+0 },
+{ INT64_C(0xffffe7fff5ffffff), -0x1.8000a000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180040000000), 0x1.8004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbfffffff), -0x1.80040000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180040000001), 0x1.80040000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbffffffe), -0x1.80040000002p+44, 0x0p+0 },
+{ INT64_C(0x0000180040000008), 0x1.80040000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbffffff7), -0x1.80040000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180040000010), 0x1.8004000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbfffffef), -0x1.80040000011p+44, 0x0p+0 },
+{ INT64_C(0x0000180040000040), 0x1.8004000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbfffffbf), -0x1.80040000041p+44, 0x0p+0 },
+{ INT64_C(0x0000180040000100), 0x1.800400001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbffffeff), -0x1.80040000101p+44, 0x0p+0 },
+{ INT64_C(0x0000180040001000), 0x1.80040001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbfffefff), -0x1.80040001001p+44, 0x0p+0 },
+{ INT64_C(0x0000180040010000), 0x1.8004001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbffeffff), -0x1.80040010001p+44, 0x0p+0 },
+{ INT64_C(0x0000180040100000), 0x1.800401p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbfefffff), -0x1.80040100001p+44, 0x0p+0 },
+{ INT64_C(0x0000180041000000), 0x1.80041p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffbeffffff), -0x1.80041000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180050000000), 0x1.8005p+44, 0x0p+0 },
+{ INT64_C(0xffffe7ffafffffff), -0x1.80050000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180100000000), 0x1.801p+44, 0x0p+0 },
+{ INT64_C(0xffffe7feffffffff), -0x1.80100000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180100000008), 0x1.80100000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefffffff7), -0x1.80100000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180100000040), 0x1.8010000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7feffffffbf), -0x1.80100000041p+44, 0x0p+0 },
+{ INT64_C(0x0000180100000400), 0x1.801000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefffffbff), -0x1.80100000401p+44, 0x0p+0 },
+{ INT64_C(0x0000180100000800), 0x1.801000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefffff7ff), -0x1.80100000801p+44, 0x0p+0 },
+{ INT64_C(0x0000180100001000), 0x1.80100001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7feffffefff), -0x1.80100001001p+44, 0x0p+0 },
+{ INT64_C(0x0000180100002000), 0x1.80100002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7feffffdfff), -0x1.80100002001p+44, 0x0p+0 },
+{ INT64_C(0x0000180100010000), 0x1.8010001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefffeffff), -0x1.80100010001p+44, 0x0p+0 },
+{ INT64_C(0x0000180100040000), 0x1.8010004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefffbffff), -0x1.80100040001p+44, 0x0p+0 },
+{ INT64_C(0x0000180100200000), 0x1.801002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7feffdfffff), -0x1.80100200001p+44, 0x0p+0 },
+{ INT64_C(0x0000180101000000), 0x1.80101p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefeffffff), -0x1.80101000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180104000000), 0x1.80104p+44, 0x0p+0 },
+{ INT64_C(0xffffe7fefbffffff), -0x1.80104000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180140000000), 0x1.8014p+44, 0x0p+0 },
+{ INT64_C(0xffffe7febfffffff), -0x1.80140000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180800000000), 0x1.808p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7ffffffff), -0x1.80800000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180800000001), 0x1.80800000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7fffffffe), -0x1.80800000002p+44, 0x0p+0 },
+{ INT64_C(0x0000180800000004), 0x1.80800000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7fffffffb), -0x1.80800000005p+44, 0x0p+0 },
+{ INT64_C(0x0000180800000008), 0x1.80800000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7fffffff7), -0x1.80800000009p+44, 0x0p+0 },
+{ INT64_C(0x0000180800000080), 0x1.8080000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7ffffff7f), -0x1.80800000081p+44, 0x0p+0 },
+{ INT64_C(0x0000180800000200), 0x1.808000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7fffffdff), -0x1.80800000201p+44, 0x0p+0 },
+{ INT64_C(0x0000180800001000), 0x1.80800001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7ffffefff), -0x1.80800001001p+44, 0x0p+0 },
+{ INT64_C(0x0000180800004000), 0x1.80800004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7ffffbfff), -0x1.80800004001p+44, 0x0p+0 },
+{ INT64_C(0x0000180800040000), 0x1.8080004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7fffbffff), -0x1.80800040001p+44, 0x0p+0 },
+{ INT64_C(0x0000180800200000), 0x1.808002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7ffdfffff), -0x1.80800200001p+44, 0x0p+0 },
+{ INT64_C(0x0000180802000000), 0x1.80802p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7fdffffff), -0x1.80802000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180808000000), 0x1.80808p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7f7ffffff), -0x1.80808000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180810000000), 0x1.8081p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f7efffffff), -0x1.80810000001p+44, 0x0p+0 },
+{ INT64_C(0x0000180880000000), 0x1.8088p+44, 0x0p+0 },
+{ INT64_C(0xffffe7f77fffffff), -0x1.80880000001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000000000), 0x1.84p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffffffff), -0x1.84000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000000002), 0x1.84000000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bffffffffd), -0x1.84000000003p+44, 0x0p+0 },
+{ INT64_C(0x0000184000000004), 0x1.84000000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bffffffffb), -0x1.84000000005p+44, 0x0p+0 },
+{ INT64_C(0x0000184000000020), 0x1.8400000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffffffdf), -0x1.84000000021p+44, 0x0p+0 },
+{ INT64_C(0x0000184000000100), 0x1.840000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bffffffeff), -0x1.84000000101p+44, 0x0p+0 },
+{ INT64_C(0x0000184000001000), 0x1.84000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffffefff), -0x1.84000001001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000004000), 0x1.84000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffffbfff), -0x1.84000004001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000008000), 0x1.84000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffff7fff), -0x1.84000008001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000010000), 0x1.8400001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bffffeffff), -0x1.84000010001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000100000), 0x1.840001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffefffff), -0x1.84000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000200000), 0x1.840002p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfffdfffff), -0x1.84000200001p+44, 0x0p+0 },
+{ INT64_C(0x0000184000800000), 0x1.840008p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfff7fffff), -0x1.84000800001p+44, 0x0p+0 },
+{ INT64_C(0x0000184001000000), 0x1.84001p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bffeffffff), -0x1.84001000001p+44, 0x0p+0 },
+{ INT64_C(0x0000184010000000), 0x1.8401p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfefffffff), -0x1.84010000001p+44, 0x0p+0 },
+{ INT64_C(0x0000184040000000), 0x1.8404p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bfbfffffff), -0x1.84040000001p+44, 0x0p+0 },
+{ INT64_C(0x0000184200000000), 0x1.842p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bdffffffff), -0x1.84200000001p+44, 0x0p+0 },
+{ INT64_C(0x0000184400000000), 0x1.844p+44, 0x0p+0 },
+{ INT64_C(0xffffe7bbffffffff), -0x1.84400000001p+44, 0x0p+0 },
+{ INT64_C(0x0000190000000000), 0x1.9p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ffffffffff), -0x1.90000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000190000000004), 0x1.90000000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe6fffffffffb), -0x1.90000000005p+44, 0x0p+0 },
+{ INT64_C(0x0000190000000020), 0x1.9000000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ffffffffdf), -0x1.90000000021p+44, 0x0p+0 },
+{ INT64_C(0x0000190000000080), 0x1.9000000008p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ffffffff7f), -0x1.90000000081p+44, 0x0p+0 },
+{ INT64_C(0x0000190000000200), 0x1.900000002p+44, 0x0p+0 },
+{ INT64_C(0xffffe6fffffffdff), -0x1.90000000201p+44, 0x0p+0 },
+{ INT64_C(0x0000190000001000), 0x1.90000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ffffffefff), -0x1.90000001001p+44, 0x0p+0 },
+{ INT64_C(0x0000190000010000), 0x1.9000001p+44, 0x0p+0 },
+{ INT64_C(0xffffe6fffffeffff), -0x1.90000010001p+44, 0x0p+0 },
+{ INT64_C(0x0000190000040000), 0x1.9000004p+44, 0x0p+0 },
+{ INT64_C(0xffffe6fffffbffff), -0x1.90000040001p+44, 0x0p+0 },
+{ INT64_C(0x0000190000100000), 0x1.900001p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ffffefffff), -0x1.90000100001p+44, 0x0p+0 },
+{ INT64_C(0x0000190000800000), 0x1.900008p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ffff7fffff), -0x1.90000800001p+44, 0x0p+0 },
+{ INT64_C(0x0000190008000000), 0x1.90008p+44, 0x0p+0 },
+{ INT64_C(0xffffe6fff7ffffff), -0x1.90008000001p+44, 0x0p+0 },
+{ INT64_C(0x0000190080000000), 0x1.9008p+44, 0x0p+0 },
+{ INT64_C(0xffffe6ff7fffffff), -0x1.90080000001p+44, 0x0p+0 },
+{ INT64_C(0x0000190200000000), 0x1.902p+44, 0x0p+0 },
+{ INT64_C(0xffffe6fdffffffff), -0x1.90200000001p+44, 0x0p+0 },
+{ INT64_C(0x0000191000000000), 0x1.91p+44, 0x0p+0 },
+{ INT64_C(0xffffe6efffffffff), -0x1.91000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000192000000000), 0x1.92p+44, 0x0p+0 },
+{ INT64_C(0xffffe6dfffffffff), -0x1.92000000001p+44, 0x0p+0 },
+{ INT64_C(0x0000800000000011), 0x1.000000000022p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffffffee), -0x1.000000000024p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000012), 0x1.000000000024p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffffffed), -0x1.000000000026p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000018), 0x1.00000000003p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffffffe7), -0x1.000000000032p+47, 0x0p+0 },
+{ INT64_C(0x000080000000001a), 0x1.000000000034p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffffffe5), -0x1.000000000036p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000104), 0x1.000000000208p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffffefb), -0x1.00000000020ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000000105), 0x1.00000000020ap+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffffefa), -0x1.00000000020cp+47, 0x0p+0 },
+{ INT64_C(0x0000800000000140), 0x1.00000000028p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffffebf), -0x1.000000000282p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000144), 0x1.000000000288p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffffebb), -0x1.00000000028ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000000160), 0x1.0000000002cp+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffffe9f), -0x1.0000000002c2p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000802), 0x1.000000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff7fd), -0x1.000000001006p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000804), 0x1.000000001008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff7fb), -0x1.00000000100ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000000820), 0x1.00000000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff7df), -0x1.000000001042p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000821), 0x1.000000001042p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff7de), -0x1.000000001044p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000824), 0x1.000000001048p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff7db), -0x1.00000000104ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000000830), 0x1.00000000106p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff7cf), -0x1.000000001062p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000880), 0x1.0000000011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff77f), -0x1.000000001102p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000882), 0x1.000000001104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff77d), -0x1.000000001106p+47, 0x0p+0 },
+{ INT64_C(0x00008000000008a0), 0x1.00000000114p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff75f), -0x1.000000001142p+47, 0x0p+0 },
+{ INT64_C(0x00008000000008c0), 0x1.00000000118p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff73f), -0x1.000000001182p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000a00), 0x1.0000000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff5ff), -0x1.000000001402p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000a04), 0x1.000000001408p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff5fb), -0x1.00000000140ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000000a10), 0x1.00000000142p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff5ef), -0x1.000000001422p+47, 0x0p+0 },
+{ INT64_C(0x0000800000000a40), 0x1.00000000148p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffff5bf), -0x1.000000001482p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008008), 0x1.00000001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7ff7), -0x1.000000010012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008020), 0x1.00000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7fdf), -0x1.000000010042p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008024), 0x1.000000010048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7fdb), -0x1.00000001004ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000008030), 0x1.00000001006p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7fcf), -0x1.000000010062p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008100), 0x1.0000000102p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7eff), -0x1.000000010202p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008102), 0x1.000000010204p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7efd), -0x1.000000010206p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008110), 0x1.00000001022p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7eef), -0x1.000000010222p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008180), 0x1.0000000103p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7e7f), -0x1.000000010302p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008200), 0x1.0000000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7dff), -0x1.000000010402p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008202), 0x1.000000010404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7dfd), -0x1.000000010406p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008208), 0x1.00000001041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7df7), -0x1.000000010412p+47, 0x0p+0 },
+{ INT64_C(0x0000800000008280), 0x1.0000000105p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff7d7f), -0x1.000000010502p+47, 0x0p+0 },
+{ INT64_C(0x000080000000a000), 0x1.000000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff5fff), -0x1.000000014002p+47, 0x0p+0 },
+{ INT64_C(0x000080000000a008), 0x1.00000001401p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff5ff7), -0x1.000000014012p+47, 0x0p+0 },
+{ INT64_C(0x000080000000a020), 0x1.00000001404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff5fdf), -0x1.000000014042p+47, 0x0p+0 },
+{ INT64_C(0x000080000000a040), 0x1.00000001408p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff5fbf), -0x1.000000014082p+47, 0x0p+0 },
+{ INT64_C(0x000080000000a080), 0x1.0000000141p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff5f7f), -0x1.000000014102p+47, 0x0p+0 },
+{ INT64_C(0x000080000000a400), 0x1.0000000148p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffffff5bff), -0x1.000000014802p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040002), 0x1.000000080004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfffd), -0x1.000000080006p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040008), 0x1.00000008001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfff7), -0x1.000000080012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040080), 0x1.0000000801p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbff7f), -0x1.000000080102p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040082), 0x1.000000080104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbff7d), -0x1.000000080106p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040084), 0x1.000000080108p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbff7b), -0x1.00000008010ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000040088), 0x1.00000008011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbff77), -0x1.000000080112p+47, 0x0p+0 },
+{ INT64_C(0x00008000000400a0), 0x1.00000008014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbff5f), -0x1.000000080142p+47, 0x0p+0 },
+{ INT64_C(0x00008000000400c0), 0x1.00000008018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbff3f), -0x1.000000080182p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040100), 0x1.0000000802p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfeff), -0x1.000000080202p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040101), 0x1.000000080202p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfefe), -0x1.000000080204p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040104), 0x1.000000080208p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfefb), -0x1.00000008020ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000040120), 0x1.00000008024p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfedf), -0x1.000000080242p+47, 0x0p+0 },
+{ INT64_C(0x0000800000040180), 0x1.0000000803p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbfe7f), -0x1.000000080302p+47, 0x0p+0 },
+{ INT64_C(0x0000800000041000), 0x1.000000082p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbefff), -0x1.000000082002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000041004), 0x1.000000082008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbeffb), -0x1.00000008200ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000041008), 0x1.00000008201p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbeff7), -0x1.000000082012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000041080), 0x1.0000000821p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbef7f), -0x1.000000082102p+47, 0x0p+0 },
+{ INT64_C(0x0000800000041400), 0x1.0000000828p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbebff), -0x1.000000082802p+47, 0x0p+0 },
+{ INT64_C(0x0000800000044000), 0x1.000000088p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbbfff), -0x1.000000088002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000044004), 0x1.000000088008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbbffb), -0x1.00000008800ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000044008), 0x1.00000008801p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbbff7), -0x1.000000088012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000044010), 0x1.00000008802p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbbfef), -0x1.000000088022p+47, 0x0p+0 },
+{ INT64_C(0x0000800000044100), 0x1.0000000882p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbbeff), -0x1.000000088202p+47, 0x0p+0 },
+{ INT64_C(0x0000800000044200), 0x1.0000000884p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbbdff), -0x1.000000088402p+47, 0x0p+0 },
+{ INT64_C(0x0000800000044800), 0x1.000000089p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffbb7ff), -0x1.000000089002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000046000), 0x1.00000008cp+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffffb9fff), -0x1.00000008c002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080001), 0x1.000000100002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fffe), -0x1.000000100004p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080010), 0x1.00000010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7ffef), -0x1.000000100022p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080018), 0x1.00000010003p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7ffe7), -0x1.000000100032p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080020), 0x1.00000010004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7ffdf), -0x1.000000100042p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080028), 0x1.00000010005p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7ffd7), -0x1.000000100052p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080030), 0x1.00000010006p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7ffcf), -0x1.000000100062p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080200), 0x1.0000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fdff), -0x1.000000100402p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080201), 0x1.000000100402p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fdfe), -0x1.000000100404p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080202), 0x1.000000100404p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fdfd), -0x1.000000100406p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080204), 0x1.000000100408p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fdfb), -0x1.00000010040ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000080220), 0x1.00000010044p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fddf), -0x1.000000100442p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080300), 0x1.0000001006p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7fcff), -0x1.000000100602p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080800), 0x1.000000101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7f7ff), -0x1.000000101002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080808), 0x1.00000010101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7f7f7), -0x1.000000101012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080810), 0x1.00000010102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7f7ef), -0x1.000000101022p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080900), 0x1.0000001012p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7f6ff), -0x1.000000101202p+47, 0x0p+0 },
+{ INT64_C(0x0000800000080c00), 0x1.0000001018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7f3ff), -0x1.000000101802p+47, 0x0p+0 },
+{ INT64_C(0x0000800000084000), 0x1.000000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7bfff), -0x1.000000108002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000084004), 0x1.000000108008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7bffb), -0x1.00000010800ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000084020), 0x1.00000010804p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7bfdf), -0x1.000000108042p+47, 0x0p+0 },
+{ INT64_C(0x0000800000084100), 0x1.0000001082p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7beff), -0x1.000000108202p+47, 0x0p+0 },
+{ INT64_C(0x0000800000084800), 0x1.000000109p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7b7ff), -0x1.000000109002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000085000), 0x1.00000010ap+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff7afff), -0x1.00000010a002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000088000), 0x1.00000011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff77fff), -0x1.000000110002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000088001), 0x1.000000110002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff77ffe), -0x1.000000110004p+47, 0x0p+0 },
+{ INT64_C(0x0000800000088008), 0x1.00000011001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff77ff7), -0x1.000000110012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000088010), 0x1.00000011002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff77fef), -0x1.000000110022p+47, 0x0p+0 },
+{ INT64_C(0x0000800000088020), 0x1.00000011004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff77fdf), -0x1.000000110042p+47, 0x0p+0 },
+{ INT64_C(0x0000800000088200), 0x1.0000001104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff77dff), -0x1.000000110402p+47, 0x0p+0 },
+{ INT64_C(0x000080000008a000), 0x1.000000114p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff75fff), -0x1.000000114002p+47, 0x0p+0 },
+{ INT64_C(0x00008000000c0000), 0x1.00000018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff3ffff), -0x1.000000180002p+47, 0x0p+0 },
+{ INT64_C(0x00008000000c0004), 0x1.000000180008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff3fffb), -0x1.00000018000ap+47, 0x0p+0 },
+{ INT64_C(0x00008000000c0020), 0x1.00000018004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff3ffdf), -0x1.000000180042p+47, 0x0p+0 },
+{ INT64_C(0x00008000000c0080), 0x1.0000001801p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff3ff7f), -0x1.000000180102p+47, 0x0p+0 },
+{ INT64_C(0x00008000000c0200), 0x1.0000001804p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff3fdff), -0x1.000000180402p+47, 0x0p+0 },
+{ INT64_C(0x00008000000c1000), 0x1.000000182p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff3efff), -0x1.000000182002p+47, 0x0p+0 },
+{ INT64_C(0x00008000000d0000), 0x1.0000001ap+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff2ffff), -0x1.0000001a0002p+47, 0x0p+0 },
+{ INT64_C(0x00008000000e0000), 0x1.0000001cp+47, 0x0p+0 },
+{ INT64_C(0xffff7ffffff1ffff), -0x1.0000001c0002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800002), 0x1.000001000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffffd), -0x1.000001000006p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800003), 0x1.000001000006p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffffc), -0x1.000001000008p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800020), 0x1.00000100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fffdf), -0x1.000001000042p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800022), 0x1.000001000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fffdd), -0x1.000001000046p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800030), 0x1.00000100006p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fffcf), -0x1.000001000062p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800080), 0x1.0000010001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fff7f), -0x1.000001000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800084), 0x1.000001000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fff7b), -0x1.00000100010ap+47, 0x0p+0 },
+{ INT64_C(0x00008000008000c0), 0x1.00000100018p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fff3f), -0x1.000001000182p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800400), 0x1.0000010008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffbff), -0x1.000001000802p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800401), 0x1.000001000802p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffbfe), -0x1.000001000804p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800404), 0x1.000001000808p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffbfb), -0x1.00000100080ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000800420), 0x1.00000100084p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffbdf), -0x1.000001000842p+47, 0x0p+0 },
+{ INT64_C(0x0000800000800480), 0x1.0000010009p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7ffb7f), -0x1.000001000902p+47, 0x0p+0 },
+{ INT64_C(0x0000800000802000), 0x1.000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fdfff), -0x1.000001004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000802004), 0x1.000001004008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fdffb), -0x1.00000100400ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000802010), 0x1.00000100402p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fdfef), -0x1.000001004022p+47, 0x0p+0 },
+{ INT64_C(0x0000800000802040), 0x1.00000100408p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fdfbf), -0x1.000001004082p+47, 0x0p+0 },
+{ INT64_C(0x0000800000802200), 0x1.0000010044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fddff), -0x1.000001004402p+47, 0x0p+0 },
+{ INT64_C(0x0000800000802800), 0x1.000001005p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7fd7ff), -0x1.000001005002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000820000), 0x1.00000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7dffff), -0x1.000001040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000820004), 0x1.000001040008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7dfffb), -0x1.00000104000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000820008), 0x1.00000104001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7dfff7), -0x1.000001040012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000820040), 0x1.00000104008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7dffbf), -0x1.000001040082p+47, 0x0p+0 },
+{ INT64_C(0x0000800000820100), 0x1.0000010402p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7dfeff), -0x1.000001040202p+47, 0x0p+0 },
+{ INT64_C(0x0000800000820800), 0x1.000001041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7df7ff), -0x1.000001041002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000824000), 0x1.000001048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff7dbfff), -0x1.000001048002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000900000), 0x1.0000012p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6fffff), -0x1.000001200002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000900004), 0x1.000001200008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6ffffb), -0x1.00000120000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800000900008), 0x1.00000120001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6ffff7), -0x1.000001200012p+47, 0x0p+0 },
+{ INT64_C(0x0000800000900080), 0x1.0000012001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6fff7f), -0x1.000001200102p+47, 0x0p+0 },
+{ INT64_C(0x0000800000900200), 0x1.0000012004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6ffdff), -0x1.000001200402p+47, 0x0p+0 },
+{ INT64_C(0x0000800000900400), 0x1.0000012008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6ffbff), -0x1.000001200802p+47, 0x0p+0 },
+{ INT64_C(0x0000800000904000), 0x1.000001208p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6fbfff), -0x1.000001208002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000908000), 0x1.00000121p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6f7fff), -0x1.000001210002p+47, 0x0p+0 },
+{ INT64_C(0x0000800000940000), 0x1.00000128p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffff6bffff), -0x1.000001280002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000008), 0x1.00001000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7fffff7), -0x1.000010000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000010), 0x1.00001000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffffef), -0x1.000010000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000011), 0x1.000010000022p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffffee), -0x1.000010000024p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000014), 0x1.000010000028p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffffeb), -0x1.00001000002ap+47, 0x0p+0 },
+{ INT64_C(0x0000800008000080), 0x1.0000100001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffff7f), -0x1.000010000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000082), 0x1.000010000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffff7d), -0x1.000010000106p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000088), 0x1.00001000011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffff77), -0x1.000010000112p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000200), 0x1.0000100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7fffdff), -0x1.000010000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000204), 0x1.000010000408p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7fffdfb), -0x1.00001000040ap+47, 0x0p+0 },
+{ INT64_C(0x0000800008000240), 0x1.00001000048p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7fffdbf), -0x1.000010000482p+47, 0x0p+0 },
+{ INT64_C(0x0000800008000280), 0x1.0000100005p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7fffd7f), -0x1.000010000502p+47, 0x0p+0 },
+{ INT64_C(0x0000800008001000), 0x1.000010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffefff), -0x1.000010002002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008001004), 0x1.000010002008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffeffb), -0x1.00001000200ap+47, 0x0p+0 },
+{ INT64_C(0x0000800008001040), 0x1.00001000208p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffefbf), -0x1.000010002082p+47, 0x0p+0 },
+{ INT64_C(0x0000800008001100), 0x1.0000100022p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ffeeff), -0x1.000010002202p+47, 0x0p+0 },
+{ INT64_C(0x0000800008008000), 0x1.00001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff7fff), -0x1.000010010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008008001), 0x1.000010010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff7ffe), -0x1.000010010004p+47, 0x0p+0 },
+{ INT64_C(0x0000800008008004), 0x1.000010010008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff7ffb), -0x1.00001001000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800008008008), 0x1.00001001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff7ff7), -0x1.000010010012p+47, 0x0p+0 },
+{ INT64_C(0x0000800008008080), 0x1.0000100101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff7f7f), -0x1.000010010102p+47, 0x0p+0 },
+{ INT64_C(0x0000800008008100), 0x1.0000100102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff7eff), -0x1.000010010202p+47, 0x0p+0 },
+{ INT64_C(0x0000800008009000), 0x1.000010012p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff6fff), -0x1.000010012002p+47, 0x0p+0 },
+{ INT64_C(0x000080000800c000), 0x1.000010018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7ff3fff), -0x1.000010018002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008080000), 0x1.0000101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7ffff), -0x1.000010100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008080008), 0x1.00001010001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7fff7), -0x1.000010100012p+47, 0x0p+0 },
+{ INT64_C(0x0000800008080010), 0x1.00001010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7ffef), -0x1.000010100022p+47, 0x0p+0 },
+{ INT64_C(0x0000800008080100), 0x1.0000101002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7feff), -0x1.000010100202p+47, 0x0p+0 },
+{ INT64_C(0x0000800008080400), 0x1.0000101008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7fbff), -0x1.000010100802p+47, 0x0p+0 },
+{ INT64_C(0x0000800008080800), 0x1.000010101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7f7ff), -0x1.000010101002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008082000), 0x1.000010104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f7dfff), -0x1.000010104002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008088000), 0x1.00001011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f77fff), -0x1.000010110002p+47, 0x0p+0 },
+{ INT64_C(0x00008000080a0000), 0x1.00001014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f5ffff), -0x1.000010140002p+47, 0x0p+0 },
+{ INT64_C(0x00008000080c0000), 0x1.00001018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff7f3ffff), -0x1.000010180002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008800000), 0x1.000011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77fffff), -0x1.000011000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008800008), 0x1.00001100001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77ffff7), -0x1.000011000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800008800040), 0x1.00001100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77fffbf), -0x1.000011000082p+47, 0x0p+0 },
+{ INT64_C(0x0000800008800200), 0x1.0000110004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77ffdff), -0x1.000011000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800008800800), 0x1.000011001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77ff7ff), -0x1.000011001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008808000), 0x1.00001101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77f7fff), -0x1.000011010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008810000), 0x1.00001102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff77effff), -0x1.000011020002p+47, 0x0p+0 },
+{ INT64_C(0x0000800008880000), 0x1.0000111p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff777ffff), -0x1.000011100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009000000), 0x1.000012p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6ffffff), -0x1.000012000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009000001), 0x1.000012000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6fffffe), -0x1.000012000004p+47, 0x0p+0 },
+{ INT64_C(0x0000800009000010), 0x1.00001200002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6ffffef), -0x1.000012000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800009000080), 0x1.0000120001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6ffff7f), -0x1.000012000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800009000800), 0x1.000012001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6fff7ff), -0x1.000012001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009001000), 0x1.000012002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6ffefff), -0x1.000012002002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009008000), 0x1.00001201p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6ff7fff), -0x1.000012010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009020000), 0x1.00001204p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6fdffff), -0x1.000012040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009200000), 0x1.0000124p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff6dfffff), -0x1.000012400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800009800000), 0x1.000013p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff67fffff), -0x1.000013000002p+47, 0x0p+0 },
+{ INT64_C(0x000080000a000000), 0x1.000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5ffffff), -0x1.000014000002p+47, 0x0p+0 },
+{ INT64_C(0x000080000a000001), 0x1.000014000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5fffffe), -0x1.000014000004p+47, 0x0p+0 },
+{ INT64_C(0x000080000a000004), 0x1.000014000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5fffffb), -0x1.00001400000ap+47, 0x0p+0 },
+{ INT64_C(0x000080000a000040), 0x1.00001400008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5ffffbf), -0x1.000014000082p+47, 0x0p+0 },
+{ INT64_C(0x000080000a000400), 0x1.0000140008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5fffbff), -0x1.000014000802p+47, 0x0p+0 },
+{ INT64_C(0x000080000a000800), 0x1.000014001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5fff7ff), -0x1.000014001002p+47, 0x0p+0 },
+{ INT64_C(0x000080000a001000), 0x1.000014002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5ffefff), -0x1.000014002002p+47, 0x0p+0 },
+{ INT64_C(0x000080000a010000), 0x1.00001402p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5feffff), -0x1.000014020002p+47, 0x0p+0 },
+{ INT64_C(0x000080000a100000), 0x1.0000142p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5efffff), -0x1.000014200002p+47, 0x0p+0 },
+{ INT64_C(0x000080000a400000), 0x1.0000148p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff5bfffff), -0x1.000014800002p+47, 0x0p+0 },
+{ INT64_C(0x000080000c000000), 0x1.000018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3ffffff), -0x1.000018000002p+47, 0x0p+0 },
+{ INT64_C(0x000080000c000008), 0x1.00001800001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3fffff7), -0x1.000018000012p+47, 0x0p+0 },
+{ INT64_C(0x000080000c000080), 0x1.0000180001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3ffff7f), -0x1.000018000102p+47, 0x0p+0 },
+{ INT64_C(0x000080000c000200), 0x1.0000180004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3fffdff), -0x1.000018000402p+47, 0x0p+0 },
+{ INT64_C(0x000080000c000400), 0x1.0000180008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3fffbff), -0x1.000018000802p+47, 0x0p+0 },
+{ INT64_C(0x000080000c004000), 0x1.000018008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3ffbfff), -0x1.000018008002p+47, 0x0p+0 },
+{ INT64_C(0x000080000c020000), 0x1.00001804p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3fdffff), -0x1.000018040002p+47, 0x0p+0 },
+{ INT64_C(0x000080000c100000), 0x1.0000182p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3efffff), -0x1.000018200002p+47, 0x0p+0 },
+{ INT64_C(0x000080000c200000), 0x1.0000184p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3dfffff), -0x1.000018400002p+47, 0x0p+0 },
+{ INT64_C(0x000080000c400000), 0x1.0000188p+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff3bfffff), -0x1.000018800002p+47, 0x0p+0 },
+{ INT64_C(0x000080000e000000), 0x1.00001cp+47, 0x0p+0 },
+{ INT64_C(0xffff7ffff1ffffff), -0x1.00001c000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000001), 0x1.000040000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffffe), -0x1.000040000004p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000002), 0x1.000040000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffffd), -0x1.000040000006p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000003), 0x1.000040000006p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffffc), -0x1.000040000008p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000004), 0x1.000040000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffffb), -0x1.00004000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800020000010), 0x1.00004000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffffef), -0x1.000040000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000018), 0x1.00004000003p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffffe7), -0x1.000040000032p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000100), 0x1.0000400002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffeff), -0x1.000040000202p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000108), 0x1.00004000021p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffef7), -0x1.000040000212p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000110), 0x1.00004000022p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffeef), -0x1.000040000222p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000140), 0x1.00004000028p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffebf), -0x1.000040000282p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000180), 0x1.0000400003p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffe7f), -0x1.000040000302p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000200), 0x1.0000400004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffdff), -0x1.000040000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000202), 0x1.000040000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffdfd), -0x1.000040000406p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000208), 0x1.00004000041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffdf7), -0x1.000040000412p+47, 0x0p+0 },
+{ INT64_C(0x0000800020000280), 0x1.0000400005p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffffd7f), -0x1.000040000502p+47, 0x0p+0 },
+{ INT64_C(0x0000800020002000), 0x1.000040004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffdfff), -0x1.000040004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020002004), 0x1.000040004008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffdffb), -0x1.00004000400ap+47, 0x0p+0 },
+{ INT64_C(0x0000800020002020), 0x1.00004000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffdfdf), -0x1.000040004042p+47, 0x0p+0 },
+{ INT64_C(0x0000800020002100), 0x1.0000400042p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffdeff), -0x1.000040004202p+47, 0x0p+0 },
+{ INT64_C(0x0000800020002200), 0x1.0000400044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdfffddff), -0x1.000040004402p+47, 0x0p+0 },
+{ INT64_C(0x0000800020020000), 0x1.00004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdffff), -0x1.000040040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020020001), 0x1.000040040002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdfffe), -0x1.000040040004p+47, 0x0p+0 },
+{ INT64_C(0x0000800020020004), 0x1.000040040008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdfffb), -0x1.00004004000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800020020040), 0x1.00004004008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdffbf), -0x1.000040040082p+47, 0x0p+0 },
+{ INT64_C(0x0000800020020100), 0x1.0000400402p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdfeff), -0x1.000040040202p+47, 0x0p+0 },
+{ INT64_C(0x0000800020020200), 0x1.0000400404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdfdff), -0x1.000040040402p+47, 0x0p+0 },
+{ INT64_C(0x0000800020020400), 0x1.0000400408p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdfbff), -0x1.000040040802p+47, 0x0p+0 },
+{ INT64_C(0x0000800020024000), 0x1.000040048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffdbfff), -0x1.000040048002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020028000), 0x1.00004005p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdffd7fff), -0x1.000040050002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080000), 0x1.0000401p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7ffff), -0x1.000040100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080002), 0x1.000040100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7fffd), -0x1.000040100006p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080008), 0x1.00004010001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7fff7), -0x1.000040100012p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080010), 0x1.00004010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7ffef), -0x1.000040100022p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080080), 0x1.0000401001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7ff7f), -0x1.000040100102p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080100), 0x1.0000401002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7feff), -0x1.000040100202p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080200), 0x1.0000401004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7fdff), -0x1.000040100402p+47, 0x0p+0 },
+{ INT64_C(0x0000800020080800), 0x1.000040101p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7f7ff), -0x1.000040101002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020081000), 0x1.000040102p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff7efff), -0x1.000040102002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020088000), 0x1.00004011p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdff77fff), -0x1.000040110002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020800000), 0x1.000041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7fffff), -0x1.000041000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020800008), 0x1.00004100001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7ffff7), -0x1.000041000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800020800080), 0x1.0000410001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7fff7f), -0x1.000041000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800020800100), 0x1.0000410002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7ffeff), -0x1.000041000202p+47, 0x0p+0 },
+{ INT64_C(0x0000800020800800), 0x1.000041001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7ff7ff), -0x1.000041001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020802000), 0x1.000041004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7fdfff), -0x1.000041004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020808000), 0x1.00004101p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7f7fff), -0x1.000041010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020840000), 0x1.00004108p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf7bffff), -0x1.000041080002p+47, 0x0p+0 },
+{ INT64_C(0x0000800020a00000), 0x1.0000414p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdf5fffff), -0x1.000041400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800024000000), 0x1.000048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbffffff), -0x1.000048000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800024000004), 0x1.000048000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbfffffb), -0x1.00004800000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800024000010), 0x1.00004800002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbffffef), -0x1.000048000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800024000040), 0x1.00004800008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbffffbf), -0x1.000048000082p+47, 0x0p+0 },
+{ INT64_C(0x0000800024000400), 0x1.0000480008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbfffbff), -0x1.000048000802p+47, 0x0p+0 },
+{ INT64_C(0x0000800024000800), 0x1.000048001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbfff7ff), -0x1.000048001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800024004000), 0x1.000048008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbffbfff), -0x1.000048008002p+47, 0x0p+0 },
+{ INT64_C(0x0000800024010000), 0x1.00004802p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbfeffff), -0x1.000048020002p+47, 0x0p+0 },
+{ INT64_C(0x0000800024100000), 0x1.0000482p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbefffff), -0x1.000048200002p+47, 0x0p+0 },
+{ INT64_C(0x0000800024400000), 0x1.0000488p+47, 0x0p+0 },
+{ INT64_C(0xffff7fffdbbfffff), -0x1.000048800002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000001), 0x1.000100000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffffe), -0x1.000100000004p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000008), 0x1.00010000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffff7), -0x1.000100000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000009), 0x1.000100000012p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffff6), -0x1.000100000014p+47, 0x0p+0 },
+{ INT64_C(0x000080008000000c), 0x1.000100000018p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffff3), -0x1.00010000001ap+47, 0x0p+0 },
+{ INT64_C(0x0000800080000080), 0x1.0001000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffff7f), -0x1.000100000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000084), 0x1.000100000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffff7b), -0x1.00010000010ap+47, 0x0p+0 },
+{ INT64_C(0x0000800080000090), 0x1.00010000012p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffff6f), -0x1.000100000122p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000200), 0x1.0001000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffdff), -0x1.000100000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000202), 0x1.000100000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffdfd), -0x1.000100000406p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000204), 0x1.000100000408p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffdfb), -0x1.00010000040ap+47, 0x0p+0 },
+{ INT64_C(0x0000800080000220), 0x1.00010000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffddf), -0x1.000100000442p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000400), 0x1.0001000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffbff), -0x1.000100000802p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000404), 0x1.000100000808p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffbfb), -0x1.00010000080ap+47, 0x0p+0 },
+{ INT64_C(0x0000800080000440), 0x1.00010000088p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffbbf), -0x1.000100000882p+47, 0x0p+0 },
+{ INT64_C(0x0000800080000500), 0x1.000100000ap+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffffaff), -0x1.000100000a02p+47, 0x0p+0 },
+{ INT64_C(0x0000800080004000), 0x1.000100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffbfff), -0x1.000100008002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080004008), 0x1.00010000801p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffbff7), -0x1.000100008012p+47, 0x0p+0 },
+{ INT64_C(0x0000800080004010), 0x1.00010000802p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffbfef), -0x1.000100008022p+47, 0x0p+0 },
+{ INT64_C(0x0000800080004100), 0x1.0001000082p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffbeff), -0x1.000100008202p+47, 0x0p+0 },
+{ INT64_C(0x0000800080005000), 0x1.00010000ap+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fffafff), -0x1.00010000a002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080020000), 0x1.00010004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffdffff), -0x1.000100040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080020008), 0x1.00010004001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffdfff7), -0x1.000100040012p+47, 0x0p+0 },
+{ INT64_C(0x0000800080020080), 0x1.0001000401p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffdff7f), -0x1.000100040102p+47, 0x0p+0 },
+{ INT64_C(0x0000800080020800), 0x1.000100041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffdf7ff), -0x1.000100041002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080022000), 0x1.000100044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffddfff), -0x1.000100044002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080028000), 0x1.00010005p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ffd7fff), -0x1.000100050002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080080000), 0x1.0001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7ffff), -0x1.000100100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080080001), 0x1.000100100002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7fffe), -0x1.000100100004p+47, 0x0p+0 },
+{ INT64_C(0x0000800080080004), 0x1.000100100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7fffb), -0x1.00010010000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800080080010), 0x1.00010010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7ffef), -0x1.000100100022p+47, 0x0p+0 },
+{ INT64_C(0x0000800080080040), 0x1.00010010008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7ffbf), -0x1.000100100082p+47, 0x0p+0 },
+{ INT64_C(0x0000800080080100), 0x1.0001001002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7feff), -0x1.000100100202p+47, 0x0p+0 },
+{ INT64_C(0x0000800080080800), 0x1.000100101p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7f7ff), -0x1.000100101002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080081000), 0x1.000100102p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff7efff), -0x1.000100102002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080088000), 0x1.00010011p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff77fff), -0x1.000100110002p+47, 0x0p+0 },
+{ INT64_C(0x00008000800a0000), 0x1.00010014p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7ff5ffff), -0x1.000100140002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080400000), 0x1.0001008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbfffff), -0x1.000100800002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080400008), 0x1.00010080001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbffff7), -0x1.000100800012p+47, 0x0p+0 },
+{ INT64_C(0x0000800080400040), 0x1.00010080008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbfffbf), -0x1.000100800082p+47, 0x0p+0 },
+{ INT64_C(0x0000800080400400), 0x1.0001008008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbffbff), -0x1.000100800802p+47, 0x0p+0 },
+{ INT64_C(0x0000800080400800), 0x1.000100801p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbff7ff), -0x1.000100801002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080404000), 0x1.000100808p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbfbfff), -0x1.000100808002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080410000), 0x1.00010082p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fbeffff), -0x1.000100820002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080500000), 0x1.000100ap+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7fafffff), -0x1.000100a00002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080600000), 0x1.000100cp+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f9fffff), -0x1.000100c00002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080800000), 0x1.000101p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7fffff), -0x1.000101000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080800002), 0x1.000101000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7ffffd), -0x1.000101000006p+47, 0x0p+0 },
+{ INT64_C(0x0000800080800020), 0x1.00010100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7fffdf), -0x1.000101000042p+47, 0x0p+0 },
+{ INT64_C(0x0000800080800040), 0x1.00010100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7fffbf), -0x1.000101000082p+47, 0x0p+0 },
+{ INT64_C(0x0000800080800080), 0x1.0001010001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7fff7f), -0x1.000101000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800080800400), 0x1.0001010008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7ffbff), -0x1.000101000802p+47, 0x0p+0 },
+{ INT64_C(0x0000800080801000), 0x1.000101002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7fefff), -0x1.000101002002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080804000), 0x1.000101008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7fbfff), -0x1.000101008002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080820000), 0x1.00010104p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7dffff), -0x1.000101040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080840000), 0x1.00010108p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f7bffff), -0x1.000101080002p+47, 0x0p+0 },
+{ INT64_C(0x0000800080900000), 0x1.0001012p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7f6fffff), -0x1.000101200002p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000000), 0x1.000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bffffff), -0x1.000108000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000008), 0x1.00010800001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bfffff7), -0x1.000108000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000010), 0x1.00010800002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bffffef), -0x1.000108000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000080), 0x1.0001080001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bffff7f), -0x1.000108000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000100), 0x1.0001080002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bfffeff), -0x1.000108000202p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000200), 0x1.0001080004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bfffdff), -0x1.000108000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800084000800), 0x1.000108001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bfff7ff), -0x1.000108001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800084002000), 0x1.000108004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bffdfff), -0x1.000108004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800084020000), 0x1.00010804p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bfdffff), -0x1.000108040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800084080000), 0x1.0001081p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7bf7ffff), -0x1.000108100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800084100000), 0x1.0001082p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7befffff), -0x1.000108200002p+47, 0x0p+0 },
+{ INT64_C(0x0000800085000000), 0x1.00010ap+47, 0x0p+0 },
+{ INT64_C(0xffff7fff7affffff), -0x1.00010a000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800090000000), 0x1.00012p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6fffffff), -0x1.000120000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800090000008), 0x1.00012000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6ffffff7), -0x1.000120000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800090000020), 0x1.00012000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6fffffdf), -0x1.000120000042p+47, 0x0p+0 },
+{ INT64_C(0x0000800090000200), 0x1.0001200004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6ffffdff), -0x1.000120000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800090002000), 0x1.000120004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6fffdfff), -0x1.000120004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800090008000), 0x1.00012001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6fff7fff), -0x1.000120010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800090040000), 0x1.00012008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6ffbffff), -0x1.000120080002p+47, 0x0p+0 },
+{ INT64_C(0x0000800090080000), 0x1.0001201p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6ff7ffff), -0x1.000120100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800090400000), 0x1.0001208p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6fbfffff), -0x1.000120800002p+47, 0x0p+0 },
+{ INT64_C(0x0000800091000000), 0x1.000122p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff6effffff), -0x1.000122000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800098000000), 0x1.00013p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff67ffffff), -0x1.000130000002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0000000), 0x1.00018p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3fffffff), -0x1.000180000002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0000008), 0x1.00018000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3ffffff7), -0x1.000180000012p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0000010), 0x1.00018000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3fffffef), -0x1.000180000022p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0000080), 0x1.0001800001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3fffff7f), -0x1.000180000102p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0000100), 0x1.0001800002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3ffffeff), -0x1.000180000202p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0000800), 0x1.000180001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3ffff7ff), -0x1.000180001002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0004000), 0x1.000180008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3fffbfff), -0x1.000180008002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0008000), 0x1.00018001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3fff7fff), -0x1.000180010002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0020000), 0x1.00018004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3ffdffff), -0x1.000180040002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0100000), 0x1.0001802p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3fefffff), -0x1.000180200002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c0800000), 0x1.000181p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3f7fffff), -0x1.000181000002p+47, 0x0p+0 },
+{ INT64_C(0x00008000c4000000), 0x1.000188p+47, 0x0p+0 },
+{ INT64_C(0xffff7fff3bffffff), -0x1.000188000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000004), 0x1.001000000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffffffb), -0x1.00100000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800800000010), 0x1.00100000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffef), -0x1.001000000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000012), 0x1.001000000024p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffed), -0x1.001000000026p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000014), 0x1.001000000028p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffeb), -0x1.00100000002ap+47, 0x0p+0 },
+{ INT64_C(0x0000800800000018), 0x1.00100000003p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffe7), -0x1.001000000032p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000020), 0x1.00100000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffdf), -0x1.001000000042p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000022), 0x1.001000000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffdd), -0x1.001000000046p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000030), 0x1.00100000006p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffffcf), -0x1.001000000062p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000080), 0x1.0010000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffff7f), -0x1.001000000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000082), 0x1.001000000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffff7d), -0x1.001000000106p+47, 0x0p+0 },
+{ INT64_C(0x00008008000000a0), 0x1.00100000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffffff5f), -0x1.001000000142p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000400), 0x1.0010000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffffbff), -0x1.001000000802p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000402), 0x1.001000000804p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffffbfd), -0x1.001000000806p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000420), 0x1.00100000084p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffffbdf), -0x1.001000000842p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000500), 0x1.001000000ap+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffffaff), -0x1.001000000a02p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000600), 0x1.001000000cp+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffff9ff), -0x1.001000000c02p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000800), 0x1.001000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffff7ff), -0x1.001000001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000802), 0x1.001000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffff7fd), -0x1.001000001006p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000820), 0x1.00100000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffff7df), -0x1.001000001042p+47, 0x0p+0 },
+{ INT64_C(0x0000800800000a00), 0x1.0010000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffff5ff), -0x1.001000001402p+47, 0x0p+0 },
+{ INT64_C(0x0000800800008000), 0x1.00100001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffff7fff), -0x1.001000010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800008008), 0x1.00100001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffff7ff7), -0x1.001000010012p+47, 0x0p+0 },
+{ INT64_C(0x0000800800008020), 0x1.00100001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffff7fdf), -0x1.001000010042p+47, 0x0p+0 },
+{ INT64_C(0x0000800800008100), 0x1.0010000102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffff7eff), -0x1.001000010202p+47, 0x0p+0 },
+{ INT64_C(0x0000800800008200), 0x1.0010000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffff7dff), -0x1.001000010402p+47, 0x0p+0 },
+{ INT64_C(0x000080080000a000), 0x1.001000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffff5fff), -0x1.001000014002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800020000), 0x1.00100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffdffff), -0x1.001000040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800020002), 0x1.001000040004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffdfffd), -0x1.001000040006p+47, 0x0p+0 },
+{ INT64_C(0x0000800800020004), 0x1.001000040008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffdfffb), -0x1.00100004000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800800020040), 0x1.00100004008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffdffbf), -0x1.001000040082p+47, 0x0p+0 },
+{ INT64_C(0x0000800800020200), 0x1.0010000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffdfdff), -0x1.001000040402p+47, 0x0p+0 },
+{ INT64_C(0x0000800800021000), 0x1.001000042p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffdefff), -0x1.001000042002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800028000), 0x1.00100005p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fffd7fff), -0x1.001000050002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800200000), 0x1.0010004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdfffff), -0x1.001000400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800200008), 0x1.00100040001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdffff7), -0x1.001000400012p+47, 0x0p+0 },
+{ INT64_C(0x0000800800200020), 0x1.00100040004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdfffdf), -0x1.001000400042p+47, 0x0p+0 },
+{ INT64_C(0x0000800800200040), 0x1.00100040008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdfffbf), -0x1.001000400082p+47, 0x0p+0 },
+{ INT64_C(0x0000800800200080), 0x1.0010004001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdfff7f), -0x1.001000400102p+47, 0x0p+0 },
+{ INT64_C(0x0000800800200200), 0x1.0010004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdffdff), -0x1.001000400402p+47, 0x0p+0 },
+{ INT64_C(0x0000800800202000), 0x1.001000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdfdfff), -0x1.001000404002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800208000), 0x1.00100041p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffdf7fff), -0x1.001000410002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800220000), 0x1.00100044p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffddffff), -0x1.001000440002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800300000), 0x1.0010006p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ffcfffff), -0x1.001000600002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800800000), 0x1.001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7fffff), -0x1.001001000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800800004), 0x1.001001000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7ffffb), -0x1.00100100000ap+47, 0x0p+0 },
+{ INT64_C(0x0000800800800010), 0x1.00100100002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7fffef), -0x1.001001000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800800800040), 0x1.00100100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7fffbf), -0x1.001001000082p+47, 0x0p+0 },
+{ INT64_C(0x0000800800800100), 0x1.0010010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7ffeff), -0x1.001001000202p+47, 0x0p+0 },
+{ INT64_C(0x0000800800800800), 0x1.001001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7ff7ff), -0x1.001001001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800801000), 0x1.001001002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7fefff), -0x1.001001002002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800810000), 0x1.00100102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7effff), -0x1.001001020002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800840000), 0x1.00100108p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff7bffff), -0x1.001001080002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800880000), 0x1.0010011p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff77ffff), -0x1.001001100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800800a00000), 0x1.0010014p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ff5fffff), -0x1.001001400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800804000000), 0x1.001008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbffffff), -0x1.001008000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800804000008), 0x1.00100800001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbfffff7), -0x1.001008000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800804000040), 0x1.00100800008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbffffbf), -0x1.001008000082p+47, 0x0p+0 },
+{ INT64_C(0x0000800804000100), 0x1.0010080002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbfffeff), -0x1.001008000202p+47, 0x0p+0 },
+{ INT64_C(0x0000800804000200), 0x1.0010080004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbfffdff), -0x1.001008000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800804002000), 0x1.001008004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbffdfff), -0x1.001008004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800804020000), 0x1.00100804p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbfdffff), -0x1.001008040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800804100000), 0x1.0010082p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fbefffff), -0x1.001008200002p+47, 0x0p+0 },
+{ INT64_C(0x0000800804800000), 0x1.001009p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7fb7fffff), -0x1.001009000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800808000000), 0x1.00101p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7ffffff), -0x1.001010000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800808000008), 0x1.00101000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7fffff7), -0x1.001010000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800808000080), 0x1.0010100001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7ffff7f), -0x1.001010000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800808000400), 0x1.0010100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7fffbff), -0x1.001010000802p+47, 0x0p+0 },
+{ INT64_C(0x0000800808000800), 0x1.001010001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7fff7ff), -0x1.001010001002p+47, 0x0p+0 },
+{ INT64_C(0x0000800808008000), 0x1.00101001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7ff7fff), -0x1.001010010002p+47, 0x0p+0 },
+{ INT64_C(0x0000800808020000), 0x1.00101004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7fdffff), -0x1.001010040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800808200000), 0x1.0010104p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7dfffff), -0x1.001010400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800808400000), 0x1.0010108p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f7bfffff), -0x1.001010800002p+47, 0x0p+0 },
+{ INT64_C(0x0000800809000000), 0x1.001012p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f6ffffff), -0x1.001012000002p+47, 0x0p+0 },
+{ INT64_C(0x000080080c000000), 0x1.001018p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7f3ffffff), -0x1.001018000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810000000), 0x1.00102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7efffffff), -0x1.001020000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810000008), 0x1.00102000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7effffff7), -0x1.001020000012p+47, 0x0p+0 },
+{ INT64_C(0x0000800810000080), 0x1.0010200001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7efffff7f), -0x1.001020000102p+47, 0x0p+0 },
+{ INT64_C(0x0000800810000100), 0x1.0010200002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7effffeff), -0x1.001020000202p+47, 0x0p+0 },
+{ INT64_C(0x0000800810001000), 0x1.001020002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7efffefff), -0x1.001020002002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810002000), 0x1.001020004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7efffdfff), -0x1.001020004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810020000), 0x1.00102004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7effdffff), -0x1.001020040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810040000), 0x1.00102008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7effbffff), -0x1.001020080002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810200000), 0x1.0010204p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7efdfffff), -0x1.001020400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800810800000), 0x1.001021p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ef7fffff), -0x1.001021000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800814000000), 0x1.001028p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff7ebffffff), -0x1.001028000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900000000), 0x1.0012p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6ffffffff), -0x1.001200000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900000001), 0x1.001200000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fffffffe), -0x1.001200000004p+47, 0x0p+0 },
+{ INT64_C(0x0000800900000010), 0x1.00120000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6ffffffef), -0x1.001200000022p+47, 0x0p+0 },
+{ INT64_C(0x0000800900000040), 0x1.00120000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6ffffffbf), -0x1.001200000082p+47, 0x0p+0 },
+{ INT64_C(0x0000800900000200), 0x1.0012000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fffffdff), -0x1.001200000402p+47, 0x0p+0 },
+{ INT64_C(0x0000800900002000), 0x1.001200004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6ffffdfff), -0x1.001200004002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900020000), 0x1.00120004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fffdffff), -0x1.001200040002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900040000), 0x1.00120008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fffbffff), -0x1.001200080002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900080000), 0x1.0012001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fff7ffff), -0x1.001200100002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900200000), 0x1.0012004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6ffdfffff), -0x1.001200400002p+47, 0x0p+0 },
+{ INT64_C(0x0000800900800000), 0x1.001201p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6ff7fffff), -0x1.001201000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800901000000), 0x1.001202p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6feffffff), -0x1.001202000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800902000000), 0x1.001204p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fdffffff), -0x1.001204000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800904000000), 0x1.001208p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6fbffffff), -0x1.001208000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800908000000), 0x1.00121p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6f7ffffff), -0x1.001210000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800920000000), 0x1.00124p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6dfffffff), -0x1.001240000002p+47, 0x0p+0 },
+{ INT64_C(0x0000800940000000), 0x1.00128p+47, 0x0p+0 },
+{ INT64_C(0xffff7ff6bfffffff), -0x1.001280000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000001), 0x1.004000000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffffffe), -0x1.004000000004p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000002), 0x1.004000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffffffd), -0x1.004000000006p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000020), 0x1.00400000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffffdf), -0x1.004000000042p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000022), 0x1.004000000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffffdd), -0x1.004000000046p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000024), 0x1.004000000048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffffdb), -0x1.00400000004ap+47, 0x0p+0 },
+{ INT64_C(0x0000802000000030), 0x1.00400000006p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffffcf), -0x1.004000000062p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000200), 0x1.0040000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffffdff), -0x1.004000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000208), 0x1.00400000041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffffdf7), -0x1.004000000412p+47, 0x0p+0 },
+{ INT64_C(0x0000802000000220), 0x1.00400000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffffddf), -0x1.004000000442p+47, 0x0p+0 },
+{ INT64_C(0x0000802000001000), 0x1.004000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffefff), -0x1.004000002002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000001001), 0x1.004000002002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffeffe), -0x1.004000002004p+47, 0x0p+0 },
+{ INT64_C(0x0000802000001004), 0x1.004000002008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffeffb), -0x1.00400000200ap+47, 0x0p+0 },
+{ INT64_C(0x0000802000001020), 0x1.00400000204p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffefdf), -0x1.004000002042p+47, 0x0p+0 },
+{ INT64_C(0x0000802000001040), 0x1.00400000208p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffefbf), -0x1.004000002082p+47, 0x0p+0 },
+{ INT64_C(0x0000802000001400), 0x1.0040000028p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffebff), -0x1.004000002802p+47, 0x0p+0 },
+{ INT64_C(0x0000802000002000), 0x1.004000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffdfff), -0x1.004000004002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000002002), 0x1.004000004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffdffd), -0x1.004000004006p+47, 0x0p+0 },
+{ INT64_C(0x0000802000002004), 0x1.004000004008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffdffb), -0x1.00400000400ap+47, 0x0p+0 },
+{ INT64_C(0x0000802000002040), 0x1.00400000408p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffdfbf), -0x1.004000004082p+47, 0x0p+0 },
+{ INT64_C(0x0000802000002200), 0x1.0040000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffddff), -0x1.004000004402p+47, 0x0p+0 },
+{ INT64_C(0x0000802000002400), 0x1.0040000048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffffdbff), -0x1.004000004802p+47, 0x0p+0 },
+{ INT64_C(0x0000802000010000), 0x1.00400002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffeffff), -0x1.004000020002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000010001), 0x1.004000020002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffefffe), -0x1.004000020004p+47, 0x0p+0 },
+{ INT64_C(0x0000802000010010), 0x1.00400002002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffeffef), -0x1.004000020022p+47, 0x0p+0 },
+{ INT64_C(0x0000802000010020), 0x1.00400002004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffeffdf), -0x1.004000020042p+47, 0x0p+0 },
+{ INT64_C(0x0000802000010040), 0x1.00400002008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffeffbf), -0x1.004000020082p+47, 0x0p+0 },
+{ INT64_C(0x0000802000010200), 0x1.0040000204p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffefdff), -0x1.004000020402p+47, 0x0p+0 },
+{ INT64_C(0x0000802000012000), 0x1.004000024p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffedfff), -0x1.004000024002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000014000), 0x1.004000028p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffffebfff), -0x1.004000028002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000080000), 0x1.0040001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff7ffff), -0x1.004000100002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000080002), 0x1.004000100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff7fffd), -0x1.004000100006p+47, 0x0p+0 },
+{ INT64_C(0x0000802000080020), 0x1.00400010004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff7ffdf), -0x1.004000100042p+47, 0x0p+0 },
+{ INT64_C(0x0000802000080080), 0x1.0040001001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff7ff7f), -0x1.004000100102p+47, 0x0p+0 },
+{ INT64_C(0x0000802000080400), 0x1.0040001008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff7fbff), -0x1.004000100802p+47, 0x0p+0 },
+{ INT64_C(0x0000802000084000), 0x1.004000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff7bfff), -0x1.004000108002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000090000), 0x1.00400012p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffff6ffff), -0x1.004000120002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000400000), 0x1.0040008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbfffff), -0x1.004000800002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000400008), 0x1.00400080001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbffff7), -0x1.004000800012p+47, 0x0p+0 },
+{ INT64_C(0x0000802000400080), 0x1.0040008001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbfff7f), -0x1.004000800102p+47, 0x0p+0 },
+{ INT64_C(0x0000802000400100), 0x1.0040008002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbffeff), -0x1.004000800202p+47, 0x0p+0 },
+{ INT64_C(0x0000802000400800), 0x1.004000801p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbff7ff), -0x1.004000801002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000401000), 0x1.004000802p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbfefff), -0x1.004000802002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000410000), 0x1.00400082p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbeffff), -0x1.004000820002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000420000), 0x1.00400084p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffbdffff), -0x1.004000840002p+47, 0x0p+0 },
+{ INT64_C(0x0000802000480000), 0x1.0040009p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfffb7ffff), -0x1.004000900002p+47, 0x0p+0 },
+{ INT64_C(0x0000802002000000), 0x1.004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdffffff), -0x1.004004000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802002000002), 0x1.004004000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdfffffd), -0x1.004004000006p+47, 0x0p+0 },
+{ INT64_C(0x0000802002000020), 0x1.00400400004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdffffdf), -0x1.004004000042p+47, 0x0p+0 },
+{ INT64_C(0x0000802002000040), 0x1.00400400008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdffffbf), -0x1.004004000082p+47, 0x0p+0 },
+{ INT64_C(0x0000802002000100), 0x1.0040040002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdfffeff), -0x1.004004000202p+47, 0x0p+0 },
+{ INT64_C(0x0000802002000200), 0x1.0040040004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdfffdff), -0x1.004004000402p+47, 0x0p+0 },
+{ INT64_C(0x0000802002002000), 0x1.004004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdffdfff), -0x1.004004004002p+47, 0x0p+0 },
+{ INT64_C(0x0000802002008000), 0x1.00400401p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdff7fff), -0x1.004004010002p+47, 0x0p+0 },
+{ INT64_C(0x0000802002080000), 0x1.0040041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffdf7ffff), -0x1.004004100002p+47, 0x0p+0 },
+{ INT64_C(0x0000802002200000), 0x1.0040044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdffddfffff), -0x1.004004400002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020000000), 0x1.00404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdfffffff), -0x1.004040000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020000008), 0x1.00404000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdffffff7), -0x1.004040000012p+47, 0x0p+0 },
+{ INT64_C(0x0000802020000080), 0x1.0040400001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdfffff7f), -0x1.004040000102p+47, 0x0p+0 },
+{ INT64_C(0x0000802020000200), 0x1.0040400004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdffffdff), -0x1.004040000402p+47, 0x0p+0 },
+{ INT64_C(0x0000802020001000), 0x1.004040002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdfffefff), -0x1.004040002002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020004000), 0x1.004040008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdfffbfff), -0x1.004040008002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020010000), 0x1.00404002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdffeffff), -0x1.004040020002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020080000), 0x1.0040401p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdff7ffff), -0x1.004040100002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020100000), 0x1.0040402p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdfefffff), -0x1.004040200002p+47, 0x0p+0 },
+{ INT64_C(0x0000802020800000), 0x1.004041p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfdf7fffff), -0x1.004041000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802028000000), 0x1.00405p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdfd7ffffff), -0x1.004050000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802100000000), 0x1.0042p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffffffff), -0x1.004200000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802100000008), 0x1.00420000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdefffffff7), -0x1.004200000012p+47, 0x0p+0 },
+{ INT64_C(0x0000802100000010), 0x1.00420000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffffffef), -0x1.004200000022p+47, 0x0p+0 },
+{ INT64_C(0x0000802100000040), 0x1.00420000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffffffbf), -0x1.004200000082p+47, 0x0p+0 },
+{ INT64_C(0x0000802100000200), 0x1.0042000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdefffffdff), -0x1.004200000402p+47, 0x0p+0 },
+{ INT64_C(0x0000802100001000), 0x1.004200002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffffefff), -0x1.004200002002p+47, 0x0p+0 },
+{ INT64_C(0x0000802100004000), 0x1.004200008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffffbfff), -0x1.004200008002p+47, 0x0p+0 },
+{ INT64_C(0x0000802100040000), 0x1.00420008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdefffbffff), -0x1.004200080002p+47, 0x0p+0 },
+{ INT64_C(0x0000802100200000), 0x1.0042004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffdfffff), -0x1.004200400002p+47, 0x0p+0 },
+{ INT64_C(0x0000802100400000), 0x1.0042008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeffbfffff), -0x1.004200800002p+47, 0x0p+0 },
+{ INT64_C(0x0000802104000000), 0x1.004208p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdefbffffff), -0x1.004208000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802110000000), 0x1.00422p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdeefffffff), -0x1.004220000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802120000000), 0x1.00424p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdedfffffff), -0x1.004240000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802200000000), 0x1.0044p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddffffffff), -0x1.004400000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802200000001), 0x1.004400000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddfffffffe), -0x1.004400000004p+47, 0x0p+0 },
+{ INT64_C(0x0000802200000010), 0x1.00440000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddffffffef), -0x1.004400000022p+47, 0x0p+0 },
+{ INT64_C(0x0000802200000100), 0x1.0044000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddfffffeff), -0x1.004400000202p+47, 0x0p+0 },
+{ INT64_C(0x0000802200000200), 0x1.0044000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddfffffdff), -0x1.004400000402p+47, 0x0p+0 },
+{ INT64_C(0x0000802200001000), 0x1.004400002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddffffefff), -0x1.004400002002p+47, 0x0p+0 },
+{ INT64_C(0x0000802200004000), 0x1.004400008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddffffbfff), -0x1.004400008002p+47, 0x0p+0 },
+{ INT64_C(0x0000802200008000), 0x1.00440001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddffff7fff), -0x1.004400010002p+47, 0x0p+0 },
+{ INT64_C(0x0000802200040000), 0x1.00440008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddfffbffff), -0x1.004400080002p+47, 0x0p+0 },
+{ INT64_C(0x0000802200200000), 0x1.0044004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddffdfffff), -0x1.004400400002p+47, 0x0p+0 },
+{ INT64_C(0x0000802201000000), 0x1.004402p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddfeffffff), -0x1.004402000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802202000000), 0x1.004404p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddfdffffff), -0x1.004404000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802210000000), 0x1.00442p+47, 0x0p+0 },
+{ INT64_C(0xffff7fddefffffff), -0x1.004420000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802280000000), 0x1.0045p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdd7fffffff), -0x1.004500000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802300000000), 0x1.0046p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdcffffffff), -0x1.004600000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400000000), 0x1.0048p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffffffff), -0x1.004800000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400000002), 0x1.004800000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbfffffffd), -0x1.004800000006p+47, 0x0p+0 },
+{ INT64_C(0x0000802400000020), 0x1.00480000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffffffdf), -0x1.004800000042p+47, 0x0p+0 },
+{ INT64_C(0x0000802400000100), 0x1.0048000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbfffffeff), -0x1.004800000202p+47, 0x0p+0 },
+{ INT64_C(0x0000802400001000), 0x1.004800002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffffefff), -0x1.004800002002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400002000), 0x1.004800004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffffdfff), -0x1.004800004002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400004000), 0x1.004800008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffffbfff), -0x1.004800008002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400008000), 0x1.00480001p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffff7fff), -0x1.004800010002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400010000), 0x1.00480002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbfffeffff), -0x1.004800020002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400100000), 0x1.0048002p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffefffff), -0x1.004800200002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400200000), 0x1.0048004p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffdfffff), -0x1.004800400002p+47, 0x0p+0 },
+{ INT64_C(0x0000802400400000), 0x1.0048008p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbffbfffff), -0x1.004800800002p+47, 0x0p+0 },
+{ INT64_C(0x0000802404000000), 0x1.004808p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbfbffffff), -0x1.004808000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802440000000), 0x1.00488p+47, 0x0p+0 },
+{ INT64_C(0xffff7fdbbfffffff), -0x1.004880000002p+47, 0x0p+0 },
+{ INT64_C(0x0000802600000000), 0x1.004cp+47, 0x0p+0 },
+{ INT64_C(0xffff7fd9ffffffff), -0x1.004c00000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000002), 0x1.020000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffffd), -0x1.020000000006p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000003), 0x1.020000000006p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffffc), -0x1.020000000008p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000004), 0x1.020000000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffffb), -0x1.02000000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000810000000006), 0x1.02000000000cp+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffff9), -0x1.02000000000ep+47, 0x0p+0 },
+{ INT64_C(0x0000810000000040), 0x1.02000000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffffbf), -0x1.020000000082p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000041), 0x1.020000000082p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffffbe), -0x1.020000000084p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000044), 0x1.020000000088p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffffbb), -0x1.02000000008ap+47, 0x0p+0 },
+{ INT64_C(0x0000810000000048), 0x1.02000000009p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffffb7), -0x1.020000000092p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000080), 0x1.0200000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffff7f), -0x1.020000000102p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000084), 0x1.020000000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffff7b), -0x1.02000000010ap+47, 0x0p+0 },
+{ INT64_C(0x00008100000000a0), 0x1.02000000014p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffff5f), -0x1.020000000142p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000200), 0x1.0200000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffdff), -0x1.020000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000201), 0x1.020000000402p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffdfe), -0x1.020000000404p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000202), 0x1.020000000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffdfd), -0x1.020000000406p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000210), 0x1.02000000042p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffdef), -0x1.020000000422p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000240), 0x1.02000000048p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffffdbf), -0x1.020000000482p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000800), 0x1.020000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff7ff), -0x1.020000001002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000801), 0x1.020000001002p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff7fe), -0x1.020000001004p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000802), 0x1.020000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff7fd), -0x1.020000001006p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000810), 0x1.02000000102p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff7ef), -0x1.020000001022p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000820), 0x1.02000000104p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff7df), -0x1.020000001042p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000840), 0x1.02000000108p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff7bf), -0x1.020000001082p+47, 0x0p+0 },
+{ INT64_C(0x0000810000000900), 0x1.0200000012p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffff6ff), -0x1.020000001202p+47, 0x0p+0 },
+{ INT64_C(0x0000810000001000), 0x1.020000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffefff), -0x1.020000002002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000001004), 0x1.020000002008p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffeffb), -0x1.02000000200ap+47, 0x0p+0 },
+{ INT64_C(0x0000810000001010), 0x1.02000000202p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffefef), -0x1.020000002022p+47, 0x0p+0 },
+{ INT64_C(0x0000810000001100), 0x1.0200000022p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffeeff), -0x1.020000002202p+47, 0x0p+0 },
+{ INT64_C(0x0000810000004000), 0x1.020000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffbfff), -0x1.020000008002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000004008), 0x1.02000000801p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffbff7), -0x1.020000008012p+47, 0x0p+0 },
+{ INT64_C(0x0000810000004020), 0x1.02000000804p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffbfdf), -0x1.020000008042p+47, 0x0p+0 },
+{ INT64_C(0x0000810000004200), 0x1.0200000084p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffffbdff), -0x1.020000008402p+47, 0x0p+0 },
+{ INT64_C(0x0000810000006000), 0x1.02000000cp+47, 0x0p+0 },
+{ INT64_C(0xffff7effffff9fff), -0x1.02000000c002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000020000), 0x1.02000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdffff), -0x1.020000040002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000020008), 0x1.02000004001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdfff7), -0x1.020000040012p+47, 0x0p+0 },
+{ INT64_C(0x0000810000020020), 0x1.02000004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdffdf), -0x1.020000040042p+47, 0x0p+0 },
+{ INT64_C(0x0000810000020040), 0x1.02000004008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdffbf), -0x1.020000040082p+47, 0x0p+0 },
+{ INT64_C(0x0000810000020100), 0x1.0200000402p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdfeff), -0x1.020000040202p+47, 0x0p+0 },
+{ INT64_C(0x0000810000020800), 0x1.020000041p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdf7ff), -0x1.020000041002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000021000), 0x1.020000042p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffdefff), -0x1.020000042002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000030000), 0x1.02000006p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffcffff), -0x1.020000060002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000040000), 0x1.02000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbffff), -0x1.020000080002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000040008), 0x1.02000008001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbfff7), -0x1.020000080012p+47, 0x0p+0 },
+{ INT64_C(0x0000810000040040), 0x1.02000008008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbffbf), -0x1.020000080082p+47, 0x0p+0 },
+{ INT64_C(0x0000810000040100), 0x1.0200000802p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbfeff), -0x1.020000080202p+47, 0x0p+0 },
+{ INT64_C(0x0000810000041000), 0x1.020000082p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbefff), -0x1.020000082002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000042000), 0x1.020000084p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbdfff), -0x1.020000084002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000044000), 0x1.020000088p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffbbfff), -0x1.020000088002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000048000), 0x1.02000009p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffffb7fff), -0x1.020000090002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000200000), 0x1.0200004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffdfffff), -0x1.020000400002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000200002), 0x1.020000400004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffdffffd), -0x1.020000400006p+47, 0x0p+0 },
+{ INT64_C(0x0000810000200020), 0x1.02000040004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffdfffdf), -0x1.020000400042p+47, 0x0p+0 },
+{ INT64_C(0x0000810000200100), 0x1.0200004002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffdffeff), -0x1.020000400202p+47, 0x0p+0 },
+{ INT64_C(0x0000810000200200), 0x1.0200004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffdffdff), -0x1.020000400402p+47, 0x0p+0 },
+{ INT64_C(0x0000810000202000), 0x1.020000404p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffdfdfff), -0x1.020000404002p+47, 0x0p+0 },
+{ INT64_C(0x0000810000220000), 0x1.02000044p+47, 0x0p+0 },
+{ INT64_C(0xffff7effffddffff), -0x1.020000440002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000000), 0x1.020002p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffeffffff), -0x1.020002000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000008), 0x1.02000200001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffefffff7), -0x1.020002000012p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000040), 0x1.02000200008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffeffffbf), -0x1.020002000082p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000080), 0x1.0200020001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffeffff7f), -0x1.020002000102p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000100), 0x1.0200020002p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffefffeff), -0x1.020002000202p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000200), 0x1.0200020004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffefffdff), -0x1.020002000402p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000400), 0x1.0200020008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffefffbff), -0x1.020002000802p+47, 0x0p+0 },
+{ INT64_C(0x0000810001000800), 0x1.020002001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffefff7ff), -0x1.020002001002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001001000), 0x1.020002002p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffeffefff), -0x1.020002002002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001002000), 0x1.020002004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffeffdfff), -0x1.020002004002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001010000), 0x1.02000202p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffefeffff), -0x1.020002020002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001100000), 0x1.0200022p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffeefffff), -0x1.020002200002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001200000), 0x1.0200024p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffedfffff), -0x1.020002400002p+47, 0x0p+0 },
+{ INT64_C(0x0000810001400000), 0x1.0200028p+47, 0x0p+0 },
+{ INT64_C(0xffff7efffebfffff), -0x1.020002800002p+47, 0x0p+0 },
+{ INT64_C(0x0000810010000000), 0x1.02002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effefffffff), -0x1.020020000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810010000001), 0x1.020020000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effeffffffe), -0x1.020020000004p+47, 0x0p+0 },
+{ INT64_C(0x0000810010000010), 0x1.02002000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effefffffef), -0x1.020020000022p+47, 0x0p+0 },
+{ INT64_C(0x0000810010000020), 0x1.02002000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effefffffdf), -0x1.020020000042p+47, 0x0p+0 },
+{ INT64_C(0x0000810010000200), 0x1.0200200004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effeffffdff), -0x1.020020000402p+47, 0x0p+0 },
+{ INT64_C(0x0000810010001000), 0x1.020020002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effefffefff), -0x1.020020002002p+47, 0x0p+0 },
+{ INT64_C(0x0000810010002000), 0x1.020020004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effefffdfff), -0x1.020020004002p+47, 0x0p+0 },
+{ INT64_C(0x0000810010010000), 0x1.02002002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effeffeffff), -0x1.020020020002p+47, 0x0p+0 },
+{ INT64_C(0x0000810010020000), 0x1.02002004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effeffdffff), -0x1.020020040002p+47, 0x0p+0 },
+{ INT64_C(0x0000810010200000), 0x1.0200204p+47, 0x0p+0 },
+{ INT64_C(0xffff7effefdfffff), -0x1.020020400002p+47, 0x0p+0 },
+{ INT64_C(0x0000810012000000), 0x1.020024p+47, 0x0p+0 },
+{ INT64_C(0xffff7effedffffff), -0x1.020024000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810018000000), 0x1.02003p+47, 0x0p+0 },
+{ INT64_C(0xffff7effe7ffffff), -0x1.020030000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810020000000), 0x1.02004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdfffffff), -0x1.020040000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810020000002), 0x1.020040000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdffffffd), -0x1.020040000006p+47, 0x0p+0 },
+{ INT64_C(0x0000810020000020), 0x1.02004000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdfffffdf), -0x1.020040000042p+47, 0x0p+0 },
+{ INT64_C(0x0000810020000080), 0x1.0200400001p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdfffff7f), -0x1.020040000102p+47, 0x0p+0 },
+{ INT64_C(0x0000810020000100), 0x1.0200400002p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdffffeff), -0x1.020040000202p+47, 0x0p+0 },
+{ INT64_C(0x0000810020000400), 0x1.0200400008p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdffffbff), -0x1.020040000802p+47, 0x0p+0 },
+{ INT64_C(0x0000810020002000), 0x1.020040004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdfffdfff), -0x1.020040004002p+47, 0x0p+0 },
+{ INT64_C(0x0000810020020000), 0x1.02004004p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdffdffff), -0x1.020040040002p+47, 0x0p+0 },
+{ INT64_C(0x0000810020100000), 0x1.0200402p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdfefffff), -0x1.020040200002p+47, 0x0p+0 },
+{ INT64_C(0x0000810021000000), 0x1.020042p+47, 0x0p+0 },
+{ INT64_C(0xffff7effdeffffff), -0x1.020042000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810030000000), 0x1.02006p+47, 0x0p+0 },
+{ INT64_C(0xffff7effcfffffff), -0x1.020060000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080000000), 0x1.0201p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fffffff), -0x1.020100000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080000002), 0x1.020100000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7ffffffd), -0x1.020100000006p+47, 0x0p+0 },
+{ INT64_C(0x0000810080000010), 0x1.02010000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fffffef), -0x1.020100000022p+47, 0x0p+0 },
+{ INT64_C(0x0000810080000080), 0x1.0201000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fffff7f), -0x1.020100000102p+47, 0x0p+0 },
+{ INT64_C(0x0000810080000400), 0x1.0201000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7ffffbff), -0x1.020100000802p+47, 0x0p+0 },
+{ INT64_C(0x0000810080002000), 0x1.020100004p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fffdfff), -0x1.020100004002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080004000), 0x1.020100008p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fffbfff), -0x1.020100008002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080010000), 0x1.02010002p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7ffeffff), -0x1.020100020002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080020000), 0x1.02010004p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7ffdffff), -0x1.020100040002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080040000), 0x1.02010008p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7ffbffff), -0x1.020100080002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080080000), 0x1.0201001p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7ff7ffff), -0x1.020100100002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080100000), 0x1.0201002p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fefffff), -0x1.020100200002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080400000), 0x1.0201008p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7fbfffff), -0x1.020100800002p+47, 0x0p+0 },
+{ INT64_C(0x0000810080800000), 0x1.020101p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7f7fffff), -0x1.020101000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810084000000), 0x1.020108p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff7bffffff), -0x1.020108000002p+47, 0x0p+0 },
+{ INT64_C(0x00008100a0000000), 0x1.02014p+47, 0x0p+0 },
+{ INT64_C(0xffff7eff5fffffff), -0x1.020140000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810100000000), 0x1.0202p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeffffffff), -0x1.020200000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810100000001), 0x1.020200000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7efefffffffe), -0x1.020200000004p+47, 0x0p+0 },
+{ INT64_C(0x0000810100000010), 0x1.02020000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeffffffef), -0x1.020200000022p+47, 0x0p+0 },
+{ INT64_C(0x0000810100000040), 0x1.02020000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeffffffbf), -0x1.020200000082p+47, 0x0p+0 },
+{ INT64_C(0x0000810100000080), 0x1.0202000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeffffff7f), -0x1.020200000102p+47, 0x0p+0 },
+{ INT64_C(0x0000810100000200), 0x1.0202000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efefffffdff), -0x1.020200000402p+47, 0x0p+0 },
+{ INT64_C(0x0000810100002000), 0x1.020200004p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeffffdfff), -0x1.020200004002p+47, 0x0p+0 },
+{ INT64_C(0x0000810100008000), 0x1.02020001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeffff7fff), -0x1.020200010002p+47, 0x0p+0 },
+{ INT64_C(0x0000810100080000), 0x1.0202001p+47, 0x0p+0 },
+{ INT64_C(0xffff7efefff7ffff), -0x1.020200100002p+47, 0x0p+0 },
+{ INT64_C(0x0000810100800000), 0x1.020201p+47, 0x0p+0 },
+{ INT64_C(0xffff7efeff7fffff), -0x1.020201000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810108000000), 0x1.02021p+47, 0x0p+0 },
+{ INT64_C(0xffff7efef7ffffff), -0x1.020210000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810180000000), 0x1.0203p+47, 0x0p+0 },
+{ INT64_C(0xffff7efe7fffffff), -0x1.020300000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800000000), 0x1.021p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffffffff), -0x1.021000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800000004), 0x1.021000000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7fffffffb), -0x1.02100000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000810800000020), 0x1.02100000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffffffdf), -0x1.021000000042p+47, 0x0p+0 },
+{ INT64_C(0x0000810800000200), 0x1.0210000004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7fffffdff), -0x1.021000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000810800001000), 0x1.021000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffffefff), -0x1.021000002002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800004000), 0x1.021000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffffbfff), -0x1.021000008002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800008000), 0x1.02100001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffff7fff), -0x1.021000010002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800010000), 0x1.02100002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7fffeffff), -0x1.021000020002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800080000), 0x1.0210001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7fff7ffff), -0x1.021000100002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800100000), 0x1.0210002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffefffff), -0x1.021000200002p+47, 0x0p+0 },
+{ INT64_C(0x0000810800400000), 0x1.0210008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7ffbfffff), -0x1.021000800002p+47, 0x0p+0 },
+{ INT64_C(0x0000810801000000), 0x1.021002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7feffffff), -0x1.021002000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810810000000), 0x1.02102p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7efffffff), -0x1.021020000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810840000000), 0x1.02108p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef7bfffffff), -0x1.021080000002p+47, 0x0p+0 },
+{ INT64_C(0x0000810a00000000), 0x1.0214p+47, 0x0p+0 },
+{ INT64_C(0xffff7ef5ffffffff), -0x1.021400000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000000000), 0x1.028p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfffffffff), -0x1.028000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000000008), 0x1.02800000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffffffff7), -0x1.028000000012p+47, 0x0p+0 },
+{ INT64_C(0x0000814000000040), 0x1.02800000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfffffffbf), -0x1.028000000082p+47, 0x0p+0 },
+{ INT64_C(0x0000814000000100), 0x1.0280000002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffffffeff), -0x1.028000000202p+47, 0x0p+0 },
+{ INT64_C(0x0000814000000800), 0x1.028000001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffffff7ff), -0x1.028000001002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000004000), 0x1.028000008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfffffbfff), -0x1.028000008002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000020000), 0x1.02800004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffffdffff), -0x1.028000040002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000040000), 0x1.02800008p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffffbffff), -0x1.028000080002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000200000), 0x1.0280004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfffdfffff), -0x1.028000400002p+47, 0x0p+0 },
+{ INT64_C(0x0000814000800000), 0x1.028001p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfff7fffff), -0x1.028001000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814001000000), 0x1.028002p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffeffffff), -0x1.028002000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814002000000), 0x1.028004p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebffdffffff), -0x1.028004000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814008000000), 0x1.02801p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebff7ffffff), -0x1.028010000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814020000000), 0x1.02804p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfdfffffff), -0x1.028040000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814040000000), 0x1.02808p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebfbfffffff), -0x1.028080000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814080000000), 0x1.0281p+47, 0x0p+0 },
+{ INT64_C(0xffff7ebf7fffffff), -0x1.028100000002p+47, 0x0p+0 },
+{ INT64_C(0x0000814800000000), 0x1.029p+47, 0x0p+0 },
+{ INT64_C(0xffff7eb7ffffffff), -0x1.029000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000002), 0x1.200000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffffd), -0x1.200000000006p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000003), 0x1.200000000006p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffffc), -0x1.200000000008p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000008), 0x1.20000000001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffff7), -0x1.200000000012p+47, 0x0p+0 },
+{ INT64_C(0x000090000000000a), 0x1.200000000014p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffff5), -0x1.200000000016p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000020), 0x1.20000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffffdf), -0x1.200000000042p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000021), 0x1.200000000042p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffffde), -0x1.200000000044p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000024), 0x1.200000000048p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffffdb), -0x1.20000000004ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000000200), 0x1.2000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffdff), -0x1.200000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000202), 0x1.200000000404p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffdfd), -0x1.200000000406p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000204), 0x1.200000000408p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffdfb), -0x1.20000000040ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000000208), 0x1.20000000041p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffdf7), -0x1.200000000412p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000210), 0x1.20000000042p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffdef), -0x1.200000000422p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000280), 0x1.2000000005p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffffd7f), -0x1.200000000502p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000800), 0x1.200000001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffff7ff), -0x1.200000001002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000804), 0x1.200000001008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffff7fb), -0x1.20000000100ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000000840), 0x1.20000000108p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffff7bf), -0x1.200000001082p+47, 0x0p+0 },
+{ INT64_C(0x0000900000000c00), 0x1.2000000018p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffff3ff), -0x1.200000001802p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001000), 0x1.200000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffefff), -0x1.200000002002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001001), 0x1.200000002002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffeffe), -0x1.200000002004p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001008), 0x1.20000000201p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffeff7), -0x1.200000002012p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001010), 0x1.20000000202p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffefef), -0x1.200000002022p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001020), 0x1.20000000204p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffefdf), -0x1.200000002042p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001040), 0x1.20000000208p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffefbf), -0x1.200000002082p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001080), 0x1.2000000021p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffef7f), -0x1.200000002102p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001100), 0x1.2000000022p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffeeff), -0x1.200000002202p+47, 0x0p+0 },
+{ INT64_C(0x0000900000001200), 0x1.2000000024p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffedff), -0x1.200000002402p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004000), 0x1.200000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbfff), -0x1.200000008002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004001), 0x1.200000008002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbffe), -0x1.200000008004p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004002), 0x1.200000008004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbffd), -0x1.200000008006p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004004), 0x1.200000008008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbffb), -0x1.20000000800ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000004010), 0x1.20000000802p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbfef), -0x1.200000008022p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004100), 0x1.2000000082p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbeff), -0x1.200000008202p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004200), 0x1.2000000084p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffbdff), -0x1.200000008402p+47, 0x0p+0 },
+{ INT64_C(0x0000900000004800), 0x1.200000009p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffffb7ff), -0x1.200000009002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000006000), 0x1.20000000cp+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffff9fff), -0x1.20000000c002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000020000), 0x1.20000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdffff), -0x1.200000040002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000020004), 0x1.200000040008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdfffb), -0x1.20000004000ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000020008), 0x1.20000004001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdfff7), -0x1.200000040012p+47, 0x0p+0 },
+{ INT64_C(0x0000900000020010), 0x1.20000004002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdffef), -0x1.200000040022p+47, 0x0p+0 },
+{ INT64_C(0x0000900000020040), 0x1.20000004008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdffbf), -0x1.200000040082p+47, 0x0p+0 },
+{ INT64_C(0x0000900000020200), 0x1.2000000404p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdfdff), -0x1.200000040402p+47, 0x0p+0 },
+{ INT64_C(0x0000900000020400), 0x1.2000000408p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffdfbff), -0x1.200000040802p+47, 0x0p+0 },
+{ INT64_C(0x0000900000022000), 0x1.200000044p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffffddfff), -0x1.200000044002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080000), 0x1.2000001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7ffff), -0x1.200000100002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080004), 0x1.200000100008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7fffb), -0x1.20000010000ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000080020), 0x1.20000010004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7ffdf), -0x1.200000100042p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080040), 0x1.20000010008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7ffbf), -0x1.200000100082p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080100), 0x1.2000001002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7feff), -0x1.200000100202p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080200), 0x1.2000001004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7fdff), -0x1.200000100402p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080400), 0x1.2000001008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7fbff), -0x1.200000100802p+47, 0x0p+0 },
+{ INT64_C(0x0000900000080800), 0x1.200000101p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff7f7ff), -0x1.200000101002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000088000), 0x1.20000011p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff77fff), -0x1.200000110002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000090000), 0x1.20000012p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff6ffff), -0x1.200000120002p+47, 0x0p+0 },
+{ INT64_C(0x00009000000c0000), 0x1.20000018p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffff3ffff), -0x1.200000180002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000100000), 0x1.2000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffefffff), -0x1.200000200002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000100002), 0x1.200000200004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffeffffd), -0x1.200000200006p+47, 0x0p+0 },
+{ INT64_C(0x0000900000100004), 0x1.200000200008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffeffffb), -0x1.20000020000ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000100020), 0x1.20000020004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffefffdf), -0x1.200000200042p+47, 0x0p+0 },
+{ INT64_C(0x0000900000100080), 0x1.2000002001p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffefff7f), -0x1.200000200102p+47, 0x0p+0 },
+{ INT64_C(0x0000900000100400), 0x1.2000002008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffeffbff), -0x1.200000200802p+47, 0x0p+0 },
+{ INT64_C(0x0000900000100800), 0x1.200000201p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffeff7ff), -0x1.200000201002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000102000), 0x1.200000204p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffefdfff), -0x1.200000204002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000104000), 0x1.200000208p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffefbfff), -0x1.200000208002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000120000), 0x1.20000024p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffedffff), -0x1.200000240002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000400000), 0x1.2000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbfffff), -0x1.200000800002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000400001), 0x1.200000800002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbffffe), -0x1.200000800004p+47, 0x0p+0 },
+{ INT64_C(0x0000900000400004), 0x1.200000800008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbffffb), -0x1.20000080000ap+47, 0x0p+0 },
+{ INT64_C(0x0000900000400010), 0x1.20000080002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbfffef), -0x1.200000800022p+47, 0x0p+0 },
+{ INT64_C(0x0000900000400100), 0x1.2000008002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbffeff), -0x1.200000800202p+47, 0x0p+0 },
+{ INT64_C(0x0000900000400400), 0x1.2000008008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbffbff), -0x1.200000800802p+47, 0x0p+0 },
+{ INT64_C(0x0000900000401000), 0x1.200000802p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbfefff), -0x1.200000802002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000408000), 0x1.20000081p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffbf7fff), -0x1.200000810002p+47, 0x0p+0 },
+{ INT64_C(0x0000900000480000), 0x1.2000009p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffffb7ffff), -0x1.200000900002p+47, 0x0p+0 },
+{ INT64_C(0x0000900001000000), 0x1.200002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffeffffff), -0x1.200002000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900001000008), 0x1.20000200001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffefffff7), -0x1.200002000012p+47, 0x0p+0 },
+{ INT64_C(0x0000900001000040), 0x1.20000200008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffeffffbf), -0x1.200002000082p+47, 0x0p+0 },
+{ INT64_C(0x0000900001000080), 0x1.2000020001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffeffff7f), -0x1.200002000102p+47, 0x0p+0 },
+{ INT64_C(0x0000900001000100), 0x1.2000020002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffefffeff), -0x1.200002000202p+47, 0x0p+0 },
+{ INT64_C(0x0000900001001000), 0x1.200002002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffeffefff), -0x1.200002002002p+47, 0x0p+0 },
+{ INT64_C(0x0000900001010000), 0x1.20000202p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffefeffff), -0x1.200002020002p+47, 0x0p+0 },
+{ INT64_C(0x0000900001040000), 0x1.20000208p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffefbffff), -0x1.200002080002p+47, 0x0p+0 },
+{ INT64_C(0x0000900001400000), 0x1.2000028p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffebfffff), -0x1.200002800002p+47, 0x0p+0 },
+{ INT64_C(0x0000900004000000), 0x1.200008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbffffff), -0x1.200008000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900004000002), 0x1.200008000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbfffffd), -0x1.200008000006p+47, 0x0p+0 },
+{ INT64_C(0x0000900004000020), 0x1.20000800004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbffffdf), -0x1.200008000042p+47, 0x0p+0 },
+{ INT64_C(0x0000900004000040), 0x1.20000800008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbffffbf), -0x1.200008000082p+47, 0x0p+0 },
+{ INT64_C(0x0000900004000080), 0x1.2000080001p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbffff7f), -0x1.200008000102p+47, 0x0p+0 },
+{ INT64_C(0x0000900004000200), 0x1.2000080004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbfffdff), -0x1.200008000402p+47, 0x0p+0 },
+{ INT64_C(0x0000900004002000), 0x1.200008004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbffdfff), -0x1.200008004002p+47, 0x0p+0 },
+{ INT64_C(0x0000900004008000), 0x1.20000801p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbff7fff), -0x1.200008010002p+47, 0x0p+0 },
+{ INT64_C(0x0000900004080000), 0x1.2000081p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffbf7ffff), -0x1.200008100002p+47, 0x0p+0 },
+{ INT64_C(0x0000900004800000), 0x1.200009p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffffb7fffff), -0x1.200009000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000000), 0x1.20004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdfffffff), -0x1.200040000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000002), 0x1.200040000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdffffffd), -0x1.200040000006p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000008), 0x1.20004000001p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdffffff7), -0x1.200040000012p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000020), 0x1.20004000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdfffffdf), -0x1.200040000042p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000040), 0x1.20004000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdfffffbf), -0x1.200040000082p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000400), 0x1.2000400008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdffffbff), -0x1.200040000802p+47, 0x0p+0 },
+{ INT64_C(0x0000900020000800), 0x1.200040001p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdffff7ff), -0x1.200040001002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020002000), 0x1.200040004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdfffdfff), -0x1.200040004002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020008000), 0x1.20004001p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdfff7fff), -0x1.200040010002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020010000), 0x1.20004002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdffeffff), -0x1.200040020002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020080000), 0x1.2000401p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdff7ffff), -0x1.200040100002p+47, 0x0p+0 },
+{ INT64_C(0x0000900020200000), 0x1.2000404p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffdfdfffff), -0x1.200040400002p+47, 0x0p+0 },
+{ INT64_C(0x0000900022000000), 0x1.200044p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffddffffff), -0x1.200044000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900030000000), 0x1.20006p+47, 0x0p+0 },
+{ INT64_C(0xffff6fffcfffffff), -0x1.200060000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900200000000), 0x1.2004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdffffffff), -0x1.200400000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900200000001), 0x1.200400000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfffffffe), -0x1.200400000004p+47, 0x0p+0 },
+{ INT64_C(0x0000900200000004), 0x1.200400000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfffffffb), -0x1.20040000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000900200000020), 0x1.20040000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdffffffdf), -0x1.200400000042p+47, 0x0p+0 },
+{ INT64_C(0x0000900200000100), 0x1.2004000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfffffeff), -0x1.200400000202p+47, 0x0p+0 },
+{ INT64_C(0x0000900200000200), 0x1.2004000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfffffdff), -0x1.200400000402p+47, 0x0p+0 },
+{ INT64_C(0x0000900200000400), 0x1.2004000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfffffbff), -0x1.200400000802p+47, 0x0p+0 },
+{ INT64_C(0x0000900200004000), 0x1.200400008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdffffbfff), -0x1.200400008002p+47, 0x0p+0 },
+{ INT64_C(0x0000900200040000), 0x1.20040008p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfffbffff), -0x1.200400080002p+47, 0x0p+0 },
+{ INT64_C(0x0000900200100000), 0x1.2004002p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdffefffff), -0x1.200400200002p+47, 0x0p+0 },
+{ INT64_C(0x0000900201000000), 0x1.200402p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfeffffff), -0x1.200402000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900202000000), 0x1.200404p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfdffffff), -0x1.200404000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900204000000), 0x1.200408p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdfbffffff), -0x1.200408000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900210000000), 0x1.20042p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdefffffff), -0x1.200420000002p+47, 0x0p+0 },
+{ INT64_C(0x0000900240000000), 0x1.20048p+47, 0x0p+0 },
+{ INT64_C(0xffff6ffdbfffffff), -0x1.200480000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902000000000), 0x1.204p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdfffffffff), -0x1.204000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902000000004), 0x1.204000000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdffffffffb), -0x1.20400000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000902000000040), 0x1.20400000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdfffffffbf), -0x1.204000000082p+47, 0x0p+0 },
+{ INT64_C(0x0000902000000200), 0x1.2040000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdffffffdff), -0x1.204000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000902000002000), 0x1.204000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdfffffdfff), -0x1.204000004002p+47, 0x0p+0 },
+{ INT64_C(0x0000902000004000), 0x1.204000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdfffffbfff), -0x1.204000008002p+47, 0x0p+0 },
+{ INT64_C(0x0000902000020000), 0x1.20400004p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdffffdffff), -0x1.204000040002p+47, 0x0p+0 },
+{ INT64_C(0x0000902000100000), 0x1.2040002p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdfffefffff), -0x1.204000200002p+47, 0x0p+0 },
+{ INT64_C(0x0000902000800000), 0x1.204001p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdfff7fffff), -0x1.204001000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902004000000), 0x1.204008p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdffbffffff), -0x1.204008000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902008000000), 0x1.20401p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdff7ffffff), -0x1.204010000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902080000000), 0x1.2041p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdf7fffffff), -0x1.204100000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902100000000), 0x1.2042p+47, 0x0p+0 },
+{ INT64_C(0xffff6fdeffffffff), -0x1.204200000002p+47, 0x0p+0 },
+{ INT64_C(0x0000902200000000), 0x1.2044p+47, 0x0p+0 },
+{ INT64_C(0xffff6fddffffffff), -0x1.204400000002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000000000), 0x1.21p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7fffffffff), -0x1.210000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000000004), 0x1.210000000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffffffffb), -0x1.21000000000ap+47, 0x0p+0 },
+{ INT64_C(0x0000908000000010), 0x1.21000000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7fffffffef), -0x1.210000000022p+47, 0x0p+0 },
+{ INT64_C(0x0000908000000020), 0x1.21000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7fffffffdf), -0x1.210000000042p+47, 0x0p+0 },
+{ INT64_C(0x0000908000000100), 0x1.2100000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffffffeff), -0x1.210000000202p+47, 0x0p+0 },
+{ INT64_C(0x0000908000000200), 0x1.2100000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffffffdff), -0x1.210000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000908000000800), 0x1.210000001p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffffff7ff), -0x1.210000001002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000002000), 0x1.210000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7fffffdfff), -0x1.210000004002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000010000), 0x1.21000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffffeffff), -0x1.210000020002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000040000), 0x1.21000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffffbffff), -0x1.210000080002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000080000), 0x1.2100001p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffff7ffff), -0x1.210000100002p+47, 0x0p+0 },
+{ INT64_C(0x0000908000800000), 0x1.210001p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7fff7fffff), -0x1.210001000002p+47, 0x0p+0 },
+{ INT64_C(0x0000908002000000), 0x1.210004p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7ffdffffff), -0x1.210004000002p+47, 0x0p+0 },
+{ INT64_C(0x0000908020000000), 0x1.21004p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7fdfffffff), -0x1.210040000002p+47, 0x0p+0 },
+{ INT64_C(0x0000908200000000), 0x1.2104p+47, 0x0p+0 },
+{ INT64_C(0xffff6f7dffffffff), -0x1.210400000002p+47, 0x0p+0 },
+{ INT64_C(0x000090a000000000), 0x1.214p+47, 0x0p+0 },
+{ INT64_C(0xffff6f5fffffffff), -0x1.214000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000000), 0x1.24p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffffffff), -0x1.240000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000001), 0x1.240000000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfffffffffe), -0x1.240000000004p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000002), 0x1.240000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfffffffffd), -0x1.240000000006p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000010), 0x1.24000000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffffffef), -0x1.240000000022p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000020), 0x1.24000000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffffffdf), -0x1.240000000042p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000200), 0x1.2400000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfffffffdff), -0x1.240000000402p+47, 0x0p+0 },
+{ INT64_C(0x0000920000000400), 0x1.2400000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfffffffbff), -0x1.240000000802p+47, 0x0p+0 },
+{ INT64_C(0x0000920000001000), 0x1.240000002p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffffefff), -0x1.240000002002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000002000), 0x1.240000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffffdfff), -0x1.240000004002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000004000), 0x1.240000008p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffffbfff), -0x1.240000008002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000020000), 0x1.24000004p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfffffdffff), -0x1.240000040002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000200000), 0x1.2400004p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffdfffff), -0x1.240000400002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000400000), 0x1.2400008p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffffbfffff), -0x1.240000800002p+47, 0x0p+0 },
+{ INT64_C(0x0000920000800000), 0x1.240001p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffff7fffff), -0x1.240001000002p+47, 0x0p+0 },
+{ INT64_C(0x0000920004000000), 0x1.240008p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfffbffffff), -0x1.240008000002p+47, 0x0p+0 },
+{ INT64_C(0x0000920040000000), 0x1.24008p+47, 0x0p+0 },
+{ INT64_C(0xffff6dffbfffffff), -0x1.240080000002p+47, 0x0p+0 },
+{ INT64_C(0x0000920400000000), 0x1.2408p+47, 0x0p+0 },
+{ INT64_C(0xffff6dfbffffffff), -0x1.240800000002p+47, 0x0p+0 },
+{ INT64_C(0x0000920800000000), 0x1.241p+47, 0x0p+0 },
+{ INT64_C(0xffff6df7ffffffff), -0x1.241000000002p+47, 0x0p+0 },
+{ INT64_C(0x0000928000000000), 0x1.25p+47, 0x0p+0 },
+{ INT64_C(0xffff6d7fffffffff), -0x1.250000000002p+47, 0x0p+0 },
+{ INT64_C(0x0001000000000005), 0x1.000000000005p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffffffa), -0x1.000000000006p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000018), 0x1.000000000018p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffffe7), -0x1.000000000019p+48, 0x0p+0 },
+{ INT64_C(0x000100000000001a), 0x1.00000000001ap+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffffe5), -0x1.00000000001bp+48, 0x0p+0 },
+{ INT64_C(0x0001000000000042), 0x1.000000000042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffffbd), -0x1.000000000043p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000050), 0x1.00000000005p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffffaf), -0x1.000000000051p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000058), 0x1.000000000058p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffffa7), -0x1.000000000059p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000101), 0x1.000000000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffffefe), -0x1.000000000102p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000102), 0x1.000000000102p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffffefd), -0x1.000000000103p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000110), 0x1.00000000011p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffffeef), -0x1.000000000111p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000111), 0x1.000000000111p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffffeee), -0x1.000000000112p+48, 0x0p+0 },
+{ INT64_C(0x0001000000000112), 0x1.000000000112p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffffeed), -0x1.000000000113p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001001), 0x1.000000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffeffe), -0x1.000000001002p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001004), 0x1.000000001004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffeffb), -0x1.000000001005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001020), 0x1.00000000102p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffefdf), -0x1.000000001021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001028), 0x1.000000001028p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffefd7), -0x1.000000001029p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001030), 0x1.00000000103p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffefcf), -0x1.000000001031p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001080), 0x1.00000000108p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffef7f), -0x1.000000001081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001082), 0x1.000000001082p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffef7d), -0x1.000000001083p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001088), 0x1.000000001088p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffef77), -0x1.000000001089p+48, 0x0p+0 },
+{ INT64_C(0x00010000000010a0), 0x1.0000000010ap+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffef5f), -0x1.0000000010a1p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001200), 0x1.0000000012p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffedff), -0x1.000000001201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001204), 0x1.000000001204p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffedfb), -0x1.000000001205p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001208), 0x1.000000001208p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffedf7), -0x1.000000001209p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001240), 0x1.00000000124p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffedbf), -0x1.000000001241p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001400), 0x1.0000000014p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffebff), -0x1.000000001401p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001408), 0x1.000000001408p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffebf7), -0x1.000000001409p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001410), 0x1.00000000141p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffebef), -0x1.000000001411p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001420), 0x1.00000000142p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffebdf), -0x1.000000001421p+48, 0x0p+0 },
+{ INT64_C(0x0001000000001500), 0x1.0000000015p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffeaff), -0x1.000000001501p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004001), 0x1.000000004001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbffe), -0x1.000000004002p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004002), 0x1.000000004002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbffd), -0x1.000000004003p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004010), 0x1.00000000401p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbfef), -0x1.000000004011p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004012), 0x1.000000004012p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbfed), -0x1.000000004013p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004018), 0x1.000000004018p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbfe7), -0x1.000000004019p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004080), 0x1.00000000408p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbf7f), -0x1.000000004081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004084), 0x1.000000004084p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbf7b), -0x1.000000004085p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004088), 0x1.000000004088p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbf77), -0x1.000000004089p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004100), 0x1.0000000041p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbeff), -0x1.000000004101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004101), 0x1.000000004101p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbefe), -0x1.000000004102p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004102), 0x1.000000004102p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbefd), -0x1.000000004103p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004120), 0x1.00000000412p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffbedf), -0x1.000000004121p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004800), 0x1.0000000048p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffb7ff), -0x1.000000004801p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004808), 0x1.000000004808p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffb7f7), -0x1.000000004809p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004810), 0x1.00000000481p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffb7ef), -0x1.000000004811p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004840), 0x1.00000000484p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffb7bf), -0x1.000000004841p+48, 0x0p+0 },
+{ INT64_C(0x0001000000004a00), 0x1.000000004ap+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffb5ff), -0x1.000000004a01p+48, 0x0p+0 },
+{ INT64_C(0x0001000000005000), 0x1.000000005p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffafff), -0x1.000000005001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000005004), 0x1.000000005004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffaffb), -0x1.000000005005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000005020), 0x1.00000000502p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffafdf), -0x1.000000005021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000005100), 0x1.0000000051p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffffaeff), -0x1.000000005101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040004), 0x1.000000040004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfffb), -0x1.000000040005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040005), 0x1.000000040005p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfffa), -0x1.000000040006p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040020), 0x1.00000004002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbffdf), -0x1.000000040021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040024), 0x1.000000040024p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbffdb), -0x1.000000040025p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040040), 0x1.00000004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbffbf), -0x1.000000040041p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040044), 0x1.000000040044p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbffbb), -0x1.000000040045p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040060), 0x1.00000004006p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbff9f), -0x1.000000040061p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040080), 0x1.00000004008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbff7f), -0x1.000000040081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040088), 0x1.000000040088p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbff77), -0x1.000000040089p+48, 0x0p+0 },
+{ INT64_C(0x00010000000400c0), 0x1.0000000400cp+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbff3f), -0x1.0000000400c1p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040400), 0x1.0000000404p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfbff), -0x1.000000040401p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040404), 0x1.000000040404p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfbfb), -0x1.000000040405p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040410), 0x1.00000004041p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfbef), -0x1.000000040411p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040420), 0x1.00000004042p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfbdf), -0x1.000000040421p+48, 0x0p+0 },
+{ INT64_C(0x0001000000040440), 0x1.00000004044p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbfbbf), -0x1.000000040441p+48, 0x0p+0 },
+{ INT64_C(0x0001000000042000), 0x1.000000042p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbdfff), -0x1.000000042001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000042008), 0x1.000000042008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbdff7), -0x1.000000042009p+48, 0x0p+0 },
+{ INT64_C(0x0001000000042080), 0x1.00000004208p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbdf7f), -0x1.000000042081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000042100), 0x1.0000000421p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbdeff), -0x1.000000042101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000043000), 0x1.000000043p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbcfff), -0x1.000000043001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044000), 0x1.000000044p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbbfff), -0x1.000000044001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044001), 0x1.000000044001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbbffe), -0x1.000000044002p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044010), 0x1.00000004401p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbbfef), -0x1.000000044011p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044080), 0x1.00000004408p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbbf7f), -0x1.000000044081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044200), 0x1.0000000442p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbbdff), -0x1.000000044201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044400), 0x1.0000000444p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbbbff), -0x1.000000044401p+48, 0x0p+0 },
+{ INT64_C(0x0001000000044800), 0x1.0000000448p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffbb7ff), -0x1.000000044801p+48, 0x0p+0 },
+{ INT64_C(0x0001000000046000), 0x1.000000046p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffffb9fff), -0x1.000000046001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080004), 0x1.000000080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7fffb), -0x1.000000080005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080006), 0x1.000000080006p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7fff9), -0x1.000000080007p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080008), 0x1.000000080008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7fff7), -0x1.000000080009p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080040), 0x1.00000008004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7ffbf), -0x1.000000080041p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080048), 0x1.000000080048p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7ffb7), -0x1.000000080049p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080050), 0x1.00000008005p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7ffaf), -0x1.000000080051p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080060), 0x1.00000008006p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7ff9f), -0x1.000000080061p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080200), 0x1.0000000802p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7fdff), -0x1.000000080201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080202), 0x1.000000080202p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7fdfd), -0x1.000000080203p+48, 0x0p+0 },
+{ INT64_C(0x0001000000080220), 0x1.00000008022p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7fddf), -0x1.000000080221p+48, 0x0p+0 },
+{ INT64_C(0x0001000000081000), 0x1.000000081p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7efff), -0x1.000000081001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000081004), 0x1.000000081004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7effb), -0x1.000000081005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000081020), 0x1.00000008102p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7efdf), -0x1.000000081021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000081100), 0x1.0000000811p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7eeff), -0x1.000000081101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000081800), 0x1.0000000818p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff7e7ff), -0x1.000000081801p+48, 0x0p+0 },
+{ INT64_C(0x0001000000090000), 0x1.00000009p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6ffff), -0x1.000000090001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000090001), 0x1.000000090001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6fffe), -0x1.000000090002p+48, 0x0p+0 },
+{ INT64_C(0x0001000000090004), 0x1.000000090004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6fffb), -0x1.000000090005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000090040), 0x1.00000009004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6ffbf), -0x1.000000090041p+48, 0x0p+0 },
+{ INT64_C(0x0001000000090080), 0x1.00000009008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6ff7f), -0x1.000000090081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000090200), 0x1.0000000902p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6fdff), -0x1.000000090201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000092000), 0x1.000000092p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff6dfff), -0x1.000000092001p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0000), 0x1.0000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5ffff), -0x1.0000000a0001p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0001), 0x1.0000000a0001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5fffe), -0x1.0000000a0002p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0002), 0x1.0000000a0002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5fffd), -0x1.0000000a0003p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0020), 0x1.0000000a002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5ffdf), -0x1.0000000a0021p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0080), 0x1.0000000a008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5ff7f), -0x1.0000000a0081p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0400), 0x1.0000000a04p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5fbff), -0x1.0000000a0401p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a0800), 0x1.0000000a08p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5f7ff), -0x1.0000000a0801p+48, 0x0p+0 },
+{ INT64_C(0x00010000000a4000), 0x1.0000000a4p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff5bfff), -0x1.0000000a4001p+48, 0x0p+0 },
+{ INT64_C(0x00010000000b0000), 0x1.0000000bp+48, 0x0p+0 },
+{ INT64_C(0xfffefffffff4ffff), -0x1.0000000b0001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100002), 0x1.000000100002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffffd), -0x1.000000100003p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100003), 0x1.000000100003p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffffc), -0x1.000000100004p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100020), 0x1.00000010002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffefffdf), -0x1.000000100021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100021), 0x1.000000100021p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffefffde), -0x1.000000100022p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100024), 0x1.000000100024p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffefffdb), -0x1.000000100025p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100028), 0x1.000000100028p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffefffd7), -0x1.000000100029p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100100), 0x1.0000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffeff), -0x1.000000100101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100108), 0x1.000000100108p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffef7), -0x1.000000100109p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100180), 0x1.00000010018p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffe7f), -0x1.000000100181p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100400), 0x1.0000001004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffbff), -0x1.000000100401p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100408), 0x1.000000100408p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffbf7), -0x1.000000100409p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100420), 0x1.00000010042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffbdf), -0x1.000000100421p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100440), 0x1.00000010044p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeffbbf), -0x1.000000100441p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100800), 0x1.0000001008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeff7ff), -0x1.000000100801p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100804), 0x1.000000100804p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeff7fb), -0x1.000000100805p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100810), 0x1.00000010081p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeff7ef), -0x1.000000100811p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100840), 0x1.00000010084p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeff7bf), -0x1.000000100841p+48, 0x0p+0 },
+{ INT64_C(0x0001000000100a00), 0x1.000000100ap+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffeff5ff), -0x1.000000100a01p+48, 0x0p+0 },
+{ INT64_C(0x0001000000108000), 0x1.000000108p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffef7fff), -0x1.000000108001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000108001), 0x1.000000108001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffef7ffe), -0x1.000000108002p+48, 0x0p+0 },
+{ INT64_C(0x0001000000108002), 0x1.000000108002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffef7ffd), -0x1.000000108003p+48, 0x0p+0 },
+{ INT64_C(0x0001000000108010), 0x1.00000010801p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffef7fef), -0x1.000000108011p+48, 0x0p+0 },
+{ INT64_C(0x0001000000108100), 0x1.0000001081p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffef7eff), -0x1.000000108101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000109000), 0x1.000000109p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffef6fff), -0x1.000000109001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000120000), 0x1.00000012p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffedffff), -0x1.000000120001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000120004), 0x1.000000120004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffedfffb), -0x1.000000120005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000120008), 0x1.000000120008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffedfff7), -0x1.000000120009p+48, 0x0p+0 },
+{ INT64_C(0x0001000000120040), 0x1.00000012004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffedffbf), -0x1.000000120041p+48, 0x0p+0 },
+{ INT64_C(0x0001000000120200), 0x1.0000001202p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffedfdff), -0x1.000000120201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000120800), 0x1.0000001208p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffedf7ff), -0x1.000000120801p+48, 0x0p+0 },
+{ INT64_C(0x0001000000128000), 0x1.000000128p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffed7fff), -0x1.000000128001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200004), 0x1.000000200004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdffffb), -0x1.000000200005p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200008), 0x1.000000200008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdffff7), -0x1.000000200009p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200020), 0x1.00000020002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfffdf), -0x1.000000200021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200028), 0x1.000000200028p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfffd7), -0x1.000000200029p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200030), 0x1.00000020003p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfffcf), -0x1.000000200031p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200100), 0x1.0000002001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdffeff), -0x1.000000200101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200101), 0x1.000000200101p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdffefe), -0x1.000000200102p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200108), 0x1.000000200108p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdffef7), -0x1.000000200109p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200120), 0x1.00000020012p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdffedf), -0x1.000000200121p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200800), 0x1.0000002008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdff7ff), -0x1.000000200801p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200804), 0x1.000000200804p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdff7fb), -0x1.000000200805p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200810), 0x1.00000020081p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdff7ef), -0x1.000000200811p+48, 0x0p+0 },
+{ INT64_C(0x0001000000200880), 0x1.00000020088p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdff77f), -0x1.000000200881p+48, 0x0p+0 },
+{ INT64_C(0x0001000000201000), 0x1.000000201p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfefff), -0x1.000000201001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000201008), 0x1.000000201008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfeff7), -0x1.000000201009p+48, 0x0p+0 },
+{ INT64_C(0x0001000000201080), 0x1.00000020108p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfef7f), -0x1.000000201081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000201200), 0x1.0000002012p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfedff), -0x1.000000201201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000204000), 0x1.000000204p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfbfff), -0x1.000000204001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000204002), 0x1.000000204002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfbffd), -0x1.000000204003p+48, 0x0p+0 },
+{ INT64_C(0x0001000000204010), 0x1.00000020401p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfbfef), -0x1.000000204011p+48, 0x0p+0 },
+{ INT64_C(0x0001000000204020), 0x1.00000020402p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfbfdf), -0x1.000000204021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000204040), 0x1.00000020404p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfbfbf), -0x1.000000204041p+48, 0x0p+0 },
+{ INT64_C(0x0001000000204200), 0x1.0000002042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfbdff), -0x1.000000204201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000205000), 0x1.000000205p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdfafff), -0x1.000000205001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000210000), 0x1.00000021p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdeffff), -0x1.000000210001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000210001), 0x1.000000210001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdefffe), -0x1.000000210002p+48, 0x0p+0 },
+{ INT64_C(0x0001000000210010), 0x1.00000021001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdeffef), -0x1.000000210011p+48, 0x0p+0 },
+{ INT64_C(0x0001000000210080), 0x1.00000021008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdeff7f), -0x1.000000210081p+48, 0x0p+0 },
+{ INT64_C(0x0001000000210100), 0x1.0000002101p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdefeff), -0x1.000000210101p+48, 0x0p+0 },
+{ INT64_C(0x0001000000211000), 0x1.000000211p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdeefff), -0x1.000000211001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000240000), 0x1.00000024p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdbffff), -0x1.000000240001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000240008), 0x1.000000240008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdbfff7), -0x1.000000240009p+48, 0x0p+0 },
+{ INT64_C(0x0001000000240020), 0x1.00000024002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdbffdf), -0x1.000000240021p+48, 0x0p+0 },
+{ INT64_C(0x0001000000240200), 0x1.0000002402p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdbfdff), -0x1.000000240201p+48, 0x0p+0 },
+{ INT64_C(0x0001000000241000), 0x1.000000241p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdbefff), -0x1.000000241001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000244000), 0x1.000000244p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdbbfff), -0x1.000000244001p+48, 0x0p+0 },
+{ INT64_C(0x0001000000250000), 0x1.00000025p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffffdaffff), -0x1.000000250001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000002), 0x1.000001000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffffd), -0x1.000001000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000020), 0x1.00000100002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeffffdf), -0x1.000001000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000022), 0x1.000001000022p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeffffdd), -0x1.000001000023p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000030), 0x1.00000100003p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeffffcf), -0x1.000001000031p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000100), 0x1.0000010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffeff), -0x1.000001000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000101), 0x1.000001000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffefe), -0x1.000001000102p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000104), 0x1.000001000104p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffefb), -0x1.000001000105p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000120), 0x1.00000100012p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffedf), -0x1.000001000121p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000200), 0x1.0000010002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffdff), -0x1.000001000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000201), 0x1.000001000201p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffdfe), -0x1.000001000202p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000208), 0x1.000001000208p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffdf7), -0x1.000001000209p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000210), 0x1.00000100021p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffdef), -0x1.000001000211p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000240), 0x1.00000100024p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffdbf), -0x1.000001000241p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000300), 0x1.0000010003p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefffcff), -0x1.000001000301p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000800), 0x1.0000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefff7ff), -0x1.000001000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000802), 0x1.000001000802p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefff7fd), -0x1.000001000803p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000820), 0x1.00000100082p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefff7df), -0x1.000001000821p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000840), 0x1.00000100084p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefff7bf), -0x1.000001000841p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000880), 0x1.00000100088p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefff77f), -0x1.000001000881p+48, 0x0p+0 },
+{ INT64_C(0x0001000001000a00), 0x1.000001000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefff5ff), -0x1.000001000a01p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008000), 0x1.000001008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff7fff), -0x1.000001008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008002), 0x1.000001008002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff7ffd), -0x1.000001008003p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008010), 0x1.00000100801p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff7fef), -0x1.000001008011p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008040), 0x1.00000100804p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff7fbf), -0x1.000001008041p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008080), 0x1.00000100808p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff7f7f), -0x1.000001008081p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008100), 0x1.0000010081p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff7eff), -0x1.000001008101p+48, 0x0p+0 },
+{ INT64_C(0x0001000001008800), 0x1.0000010088p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeff77ff), -0x1.000001008801p+48, 0x0p+0 },
+{ INT64_C(0x0001000001020000), 0x1.00000102p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefdffff), -0x1.000001020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001020008), 0x1.000001020008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefdfff7), -0x1.000001020009p+48, 0x0p+0 },
+{ INT64_C(0x0001000001020040), 0x1.00000102004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefdffbf), -0x1.000001020041p+48, 0x0p+0 },
+{ INT64_C(0x0001000001020400), 0x1.0000010204p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefdfbff), -0x1.000001020401p+48, 0x0p+0 },
+{ INT64_C(0x0001000001024000), 0x1.000001024p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffefdbfff), -0x1.000001024001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001100000), 0x1.0000011p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeefffff), -0x1.000001100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001100001), 0x1.000001100001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeeffffe), -0x1.000001100002p+48, 0x0p+0 },
+{ INT64_C(0x0001000001100008), 0x1.000001100008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeeffff7), -0x1.000001100009p+48, 0x0p+0 },
+{ INT64_C(0x0001000001100080), 0x1.00000110008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeefff7f), -0x1.000001100081p+48, 0x0p+0 },
+{ INT64_C(0x0001000001100200), 0x1.0000011002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeeffdff), -0x1.000001100201p+48, 0x0p+0 },
+{ INT64_C(0x0001000001100800), 0x1.0000011008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeeff7ff), -0x1.000001100801p+48, 0x0p+0 },
+{ INT64_C(0x0001000001104000), 0x1.000001104p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeefbfff), -0x1.000001104001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001110000), 0x1.00000111p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffeeeffff), -0x1.000001110001p+48, 0x0p+0 },
+{ INT64_C(0x0001000001180000), 0x1.00000118p+48, 0x0p+0 },
+{ INT64_C(0xfffefffffee7ffff), -0x1.000001180001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000004), 0x1.000010000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffffb), -0x1.000010000005p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000005), 0x1.000010000005p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffffa), -0x1.000010000006p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000006), 0x1.000010000006p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffff9), -0x1.000010000007p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000008), 0x1.000010000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffff7), -0x1.000010000009p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000080), 0x1.00001000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffff7f), -0x1.000010000081p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000084), 0x1.000010000084p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffff7b), -0x1.000010000085p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000090), 0x1.00001000009p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffff6f), -0x1.000010000091p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000400), 0x1.0000100004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffbff), -0x1.000010000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000401), 0x1.000010000401p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffbfe), -0x1.000010000402p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000402), 0x1.000010000402p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffbfd), -0x1.000010000403p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000408), 0x1.000010000408p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffbf7), -0x1.000010000409p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000410), 0x1.00001000041p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffbef), -0x1.000010000411p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000420), 0x1.00001000042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffbdf), -0x1.000010000421p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000480), 0x1.00001000048p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffffb7f), -0x1.000010000481p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000600), 0x1.0000100006p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffff9ff), -0x1.000010000601p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000800), 0x1.0000100008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffff7ff), -0x1.000010000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000804), 0x1.000010000804p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffff7fb), -0x1.000010000805p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000820), 0x1.00001000082p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffff7df), -0x1.000010000821p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000840), 0x1.00001000084p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffff7bf), -0x1.000010000841p+48, 0x0p+0 },
+{ INT64_C(0x0001000010000c00), 0x1.000010000cp+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffff3ff), -0x1.000010000c01p+48, 0x0p+0 },
+{ INT64_C(0x0001000010002000), 0x1.000010002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffdfff), -0x1.000010002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010002002), 0x1.000010002002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffdffd), -0x1.000010002003p+48, 0x0p+0 },
+{ INT64_C(0x0001000010002010), 0x1.00001000201p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffdfef), -0x1.000010002011p+48, 0x0p+0 },
+{ INT64_C(0x0001000010002080), 0x1.00001000208p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffdf7f), -0x1.000010002081p+48, 0x0p+0 },
+{ INT64_C(0x0001000010002400), 0x1.0000100024p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffdbff), -0x1.000010002401p+48, 0x0p+0 },
+{ INT64_C(0x0001000010004000), 0x1.000010004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffbfff), -0x1.000010004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010004008), 0x1.000010004008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffbff7), -0x1.000010004009p+48, 0x0p+0 },
+{ INT64_C(0x0001000010004010), 0x1.00001000401p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffbfef), -0x1.000010004011p+48, 0x0p+0 },
+{ INT64_C(0x0001000010004040), 0x1.00001000404p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffbfbf), -0x1.000010004041p+48, 0x0p+0 },
+{ INT64_C(0x0001000010004200), 0x1.0000100042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffbdff), -0x1.000010004201p+48, 0x0p+0 },
+{ INT64_C(0x0001000010004400), 0x1.0000100044p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefffbbff), -0x1.000010004401p+48, 0x0p+0 },
+{ INT64_C(0x0001000010040000), 0x1.00001004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbffff), -0x1.000010040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010040008), 0x1.000010040008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbfff7), -0x1.000010040009p+48, 0x0p+0 },
+{ INT64_C(0x0001000010040010), 0x1.00001004001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbffef), -0x1.000010040011p+48, 0x0p+0 },
+{ INT64_C(0x0001000010040040), 0x1.00001004004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbffbf), -0x1.000010040041p+48, 0x0p+0 },
+{ INT64_C(0x0001000010040200), 0x1.0000100402p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbfdff), -0x1.000010040201p+48, 0x0p+0 },
+{ INT64_C(0x0001000010040800), 0x1.0000100408p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbf7ff), -0x1.000010040801p+48, 0x0p+0 },
+{ INT64_C(0x0001000010041000), 0x1.000010041p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffbefff), -0x1.000010041001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010048000), 0x1.000010048p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeffb7fff), -0x1.000010048001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010080000), 0x1.00001008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff7ffff), -0x1.000010080001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010080004), 0x1.000010080004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff7fffb), -0x1.000010080005p+48, 0x0p+0 },
+{ INT64_C(0x0001000010080008), 0x1.000010080008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff7fff7), -0x1.000010080009p+48, 0x0p+0 },
+{ INT64_C(0x0001000010080040), 0x1.00001008004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff7ffbf), -0x1.000010080041p+48, 0x0p+0 },
+{ INT64_C(0x0001000010080400), 0x1.0000100804p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff7fbff), -0x1.000010080401p+48, 0x0p+0 },
+{ INT64_C(0x0001000010084000), 0x1.000010084p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff7bfff), -0x1.000010084001p+48, 0x0p+0 },
+{ INT64_C(0x00010000100a0000), 0x1.0000100ap+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeff5ffff), -0x1.0000100a0001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010400000), 0x1.0000104p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbfffff), -0x1.000010400001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010400004), 0x1.000010400004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbffffb), -0x1.000010400005p+48, 0x0p+0 },
+{ INT64_C(0x0001000010400040), 0x1.00001040004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbfffbf), -0x1.000010400041p+48, 0x0p+0 },
+{ INT64_C(0x0001000010400400), 0x1.0000104004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbffbff), -0x1.000010400401p+48, 0x0p+0 },
+{ INT64_C(0x0001000010401000), 0x1.000010401p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbfefff), -0x1.000010401001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010404000), 0x1.000010404p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbfbfff), -0x1.000010404001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010420000), 0x1.00001042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffefbdffff), -0x1.000010420001p+48, 0x0p+0 },
+{ INT64_C(0x0001000010600000), 0x1.0000106p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffef9fffff), -0x1.000010600001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011000000), 0x1.000011p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeeffffff), -0x1.000011000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011000008), 0x1.000011000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeefffff7), -0x1.000011000009p+48, 0x0p+0 },
+{ INT64_C(0x0001000011000040), 0x1.00001100004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeeffffbf), -0x1.000011000041p+48, 0x0p+0 },
+{ INT64_C(0x0001000011000100), 0x1.0000110001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeefffeff), -0x1.000011000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000011000400), 0x1.0000110004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeefffbff), -0x1.000011000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000011001000), 0x1.000011001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeeffefff), -0x1.000011001001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011004000), 0x1.000011004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeeffbfff), -0x1.000011004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011020000), 0x1.00001102p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeefdffff), -0x1.000011020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011040000), 0x1.00001104p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeefbffff), -0x1.000011040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011080000), 0x1.00001108p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeef7ffff), -0x1.000011080001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011400000), 0x1.0000114p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffeebfffff), -0x1.000011400001p+48, 0x0p+0 },
+{ INT64_C(0x0001000011800000), 0x1.0000118p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffee7fffff), -0x1.000011800001p+48, 0x0p+0 },
+{ INT64_C(0x0001000018000000), 0x1.000018p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7ffffff), -0x1.000018000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000018000002), 0x1.000018000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7fffffd), -0x1.000018000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000018000008), 0x1.000018000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7fffff7), -0x1.000018000009p+48, 0x0p+0 },
+{ INT64_C(0x0001000018000010), 0x1.00001800001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7ffffef), -0x1.000018000011p+48, 0x0p+0 },
+{ INT64_C(0x0001000018000100), 0x1.0000180001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7fffeff), -0x1.000018000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000018000200), 0x1.0000180002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7fffdff), -0x1.000018000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000018002000), 0x1.000018002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7ffdfff), -0x1.000018002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000018004000), 0x1.000018004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7ffbfff), -0x1.000018004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000018010000), 0x1.00001801p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7feffff), -0x1.000018010001p+48, 0x0p+0 },
+{ INT64_C(0x0001000018100000), 0x1.0000181p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7efffff), -0x1.000018100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000018200000), 0x1.0000182p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe7dfffff), -0x1.000018200001p+48, 0x0p+0 },
+{ INT64_C(0x000100001a000000), 0x1.00001ap+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe5ffffff), -0x1.00001a000001p+48, 0x0p+0 },
+{ INT64_C(0x000100001c000000), 0x1.00001cp+48, 0x0p+0 },
+{ INT64_C(0xfffeffffe3ffffff), -0x1.00001c000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000004), 0x1.000040000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffffffb), -0x1.000040000005p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000040), 0x1.00004000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffffbf), -0x1.000040000041p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000042), 0x1.000040000042p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffffbd), -0x1.000040000043p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000044), 0x1.000040000044p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffffbb), -0x1.000040000045p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000048), 0x1.000040000048p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffffb7), -0x1.000040000049p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000050), 0x1.00004000005p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffffaf), -0x1.000040000051p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000200), 0x1.0000400002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffffdff), -0x1.000040000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000202), 0x1.000040000202p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffffdfd), -0x1.000040000203p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000208), 0x1.000040000208p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffffdf7), -0x1.000040000209p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000210), 0x1.00004000021p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffffdef), -0x1.000040000211p+48, 0x0p+0 },
+{ INT64_C(0x0001000040000280), 0x1.00004000028p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffffd7f), -0x1.000040000281p+48, 0x0p+0 },
+{ INT64_C(0x0001000040002000), 0x1.000040002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffdfff), -0x1.000040002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040002008), 0x1.000040002008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffdff7), -0x1.000040002009p+48, 0x0p+0 },
+{ INT64_C(0x0001000040002020), 0x1.00004000202p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffdfdf), -0x1.000040002021p+48, 0x0p+0 },
+{ INT64_C(0x0001000040002200), 0x1.0000400022p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfffddff), -0x1.000040002201p+48, 0x0p+0 },
+{ INT64_C(0x0001000040020000), 0x1.00004002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffdffff), -0x1.000040020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040020008), 0x1.000040020008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffdfff7), -0x1.000040020009p+48, 0x0p+0 },
+{ INT64_C(0x0001000040020020), 0x1.00004002002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffdffdf), -0x1.000040020021p+48, 0x0p+0 },
+{ INT64_C(0x0001000040020200), 0x1.0000400202p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffdfdff), -0x1.000040020201p+48, 0x0p+0 },
+{ INT64_C(0x0001000040022000), 0x1.000040022p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffddfff), -0x1.000040022001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040028000), 0x1.000040028p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbffd7fff), -0x1.000040028001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040100000), 0x1.0000401p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfefffff), -0x1.000040100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040100004), 0x1.000040100004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfeffffb), -0x1.000040100005p+48, 0x0p+0 },
+{ INT64_C(0x0001000040100010), 0x1.00004010001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfefffef), -0x1.000040100011p+48, 0x0p+0 },
+{ INT64_C(0x0001000040100100), 0x1.0000401001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfeffeff), -0x1.000040100101p+48, 0x0p+0 },
+{ INT64_C(0x0001000040101000), 0x1.000040101p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfefefff), -0x1.000040101001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040104000), 0x1.000040104p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfefbfff), -0x1.000040104001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040120000), 0x1.00004012p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfedffff), -0x1.000040120001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040200000), 0x1.0000402p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdfffff), -0x1.000040200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040200001), 0x1.000040200001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdffffe), -0x1.000040200002p+48, 0x0p+0 },
+{ INT64_C(0x0001000040200004), 0x1.000040200004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdffffb), -0x1.000040200005p+48, 0x0p+0 },
+{ INT64_C(0x0001000040200010), 0x1.00004020001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdfffef), -0x1.000040200011p+48, 0x0p+0 },
+{ INT64_C(0x0001000040200100), 0x1.0000402001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdffeff), -0x1.000040200101p+48, 0x0p+0 },
+{ INT64_C(0x0001000040200400), 0x1.0000402004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdffbff), -0x1.000040200401p+48, 0x0p+0 },
+{ INT64_C(0x0001000040204000), 0x1.000040204p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdfbfff), -0x1.000040204001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040208000), 0x1.000040208p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdf7fff), -0x1.000040208001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040210000), 0x1.00004021p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfdeffff), -0x1.000040210001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040220000), 0x1.00004022p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfddffff), -0x1.000040220001p+48, 0x0p+0 },
+{ INT64_C(0x0001000040280000), 0x1.00004028p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbfd7ffff), -0x1.000040280001p+48, 0x0p+0 },
+{ INT64_C(0x0001000041000000), 0x1.000041p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbeffffff), -0x1.000041000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000041000002), 0x1.000041000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbefffffd), -0x1.000041000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000041000010), 0x1.00004100001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbeffffef), -0x1.000041000011p+48, 0x0p+0 },
+{ INT64_C(0x0001000041000100), 0x1.0000410001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbefffeff), -0x1.000041000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000041000400), 0x1.0000410004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbefffbff), -0x1.000041000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000041002000), 0x1.000041002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbeffdfff), -0x1.000041002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000041020000), 0x1.00004102p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbefdffff), -0x1.000041020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000041100000), 0x1.0000411p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbeefffff), -0x1.000041100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000041200000), 0x1.0000412p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffbedfffff), -0x1.000041200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000000), 0x1.000048p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7ffffff), -0x1.000048000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000001), 0x1.000048000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fffffe), -0x1.000048000002p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000004), 0x1.000048000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fffffb), -0x1.000048000005p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000008), 0x1.000048000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fffff7), -0x1.000048000009p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000020), 0x1.00004800002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7ffffdf), -0x1.000048000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000200), 0x1.0000480002p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fffdff), -0x1.000048000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000048000800), 0x1.0000480008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fff7ff), -0x1.000048000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000048008000), 0x1.000048008p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7ff7fff), -0x1.000048008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000048020000), 0x1.00004802p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fdffff), -0x1.000048020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000048040000), 0x1.00004804p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7fbffff), -0x1.000048040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000048100000), 0x1.0000481p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb7efffff), -0x1.000048100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000049000000), 0x1.000049p+48, 0x0p+0 },
+{ INT64_C(0xfffeffffb6ffffff), -0x1.000049000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000001), 0x1.000100000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffffffe), -0x1.000100000002p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000008), 0x1.000100000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffffff7), -0x1.000100000009p+48, 0x0p+0 },
+{ INT64_C(0x000100010000000a), 0x1.00010000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffffff5), -0x1.00010000000bp+48, 0x0p+0 },
+{ INT64_C(0x0001000100000020), 0x1.00010000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffffdf), -0x1.000100000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000022), 0x1.000100000022p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffffdd), -0x1.000100000023p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000030), 0x1.00010000003p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffffcf), -0x1.000100000031p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000080), 0x1.00010000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffff7f), -0x1.000100000081p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000088), 0x1.000100000088p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffff77), -0x1.000100000089p+48, 0x0p+0 },
+{ INT64_C(0x00010001000000a0), 0x1.0001000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffff5f), -0x1.0001000000a1p+48, 0x0p+0 },
+{ INT64_C(0x00010001000000c0), 0x1.0001000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffff3f), -0x1.0001000000c1p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000400), 0x1.0001000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffffbff), -0x1.000100000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000408), 0x1.000100000408p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffffbf7), -0x1.000100000409p+48, 0x0p+0 },
+{ INT64_C(0x0001000100000440), 0x1.00010000044p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffffbbf), -0x1.000100000441p+48, 0x0p+0 },
+{ INT64_C(0x0001000100001000), 0x1.000100001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffefff), -0x1.000100001001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100001008), 0x1.000100001008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffeff7), -0x1.000100001009p+48, 0x0p+0 },
+{ INT64_C(0x0001000100001040), 0x1.00010000104p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffefbf), -0x1.000100001041p+48, 0x0p+0 },
+{ INT64_C(0x0001000100001100), 0x1.0001000011p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffeeff), -0x1.000100001101p+48, 0x0p+0 },
+{ INT64_C(0x0001000100001200), 0x1.0001000012p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffedff), -0x1.000100001201p+48, 0x0p+0 },
+{ INT64_C(0x0001000100001800), 0x1.0001000018p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffe7ff), -0x1.000100001801p+48, 0x0p+0 },
+{ INT64_C(0x0001000100004000), 0x1.000100004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffbfff), -0x1.000100004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100004004), 0x1.000100004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffbffb), -0x1.000100004005p+48, 0x0p+0 },
+{ INT64_C(0x0001000100004020), 0x1.00010000402p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffbfdf), -0x1.000100004021p+48, 0x0p+0 },
+{ INT64_C(0x0001000100004100), 0x1.0001000041p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffbeff), -0x1.000100004101p+48, 0x0p+0 },
+{ INT64_C(0x0001000100004200), 0x1.0001000042p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffffbdff), -0x1.000100004201p+48, 0x0p+0 },
+{ INT64_C(0x0001000100006000), 0x1.000100006p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffff9fff), -0x1.000100006001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100020000), 0x1.00010002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdffff), -0x1.000100020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100020008), 0x1.000100020008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdfff7), -0x1.000100020009p+48, 0x0p+0 },
+{ INT64_C(0x0001000100020010), 0x1.00010002001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdffef), -0x1.000100020011p+48, 0x0p+0 },
+{ INT64_C(0x0001000100020020), 0x1.00010002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdffdf), -0x1.000100020021p+48, 0x0p+0 },
+{ INT64_C(0x0001000100020040), 0x1.00010002004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdffbf), -0x1.000100020041p+48, 0x0p+0 },
+{ INT64_C(0x0001000100020400), 0x1.0001000204p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdfbff), -0x1.000100020401p+48, 0x0p+0 },
+{ INT64_C(0x0001000100021000), 0x1.000100021p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffdefff), -0x1.000100021001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100022000), 0x1.000100022p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffddfff), -0x1.000100022001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100028000), 0x1.000100028p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefffd7fff), -0x1.000100028001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100080000), 0x1.00010008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff7ffff), -0x1.000100080001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100080004), 0x1.000100080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff7fffb), -0x1.000100080005p+48, 0x0p+0 },
+{ INT64_C(0x0001000100080008), 0x1.000100080008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff7fff7), -0x1.000100080009p+48, 0x0p+0 },
+{ INT64_C(0x0001000100080080), 0x1.00010008008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff7ff7f), -0x1.000100080081p+48, 0x0p+0 },
+{ INT64_C(0x0001000100080400), 0x1.0001000804p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff7fbff), -0x1.000100080401p+48, 0x0p+0 },
+{ INT64_C(0x0001000100082000), 0x1.000100082p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff7dfff), -0x1.000100082001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100088000), 0x1.000100088p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff77fff), -0x1.000100088001p+48, 0x0p+0 },
+{ INT64_C(0x00010001000c0000), 0x1.0001000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefffefff3ffff), -0x1.0001000c0001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100100000), 0x1.0001001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffefffff), -0x1.000100100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100100001), 0x1.000100100001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffeffffe), -0x1.000100100002p+48, 0x0p+0 },
+{ INT64_C(0x0001000100100010), 0x1.00010010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffefffef), -0x1.000100100011p+48, 0x0p+0 },
+{ INT64_C(0x0001000100100100), 0x1.0001001001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffeffeff), -0x1.000100100101p+48, 0x0p+0 },
+{ INT64_C(0x0001000100100800), 0x1.0001001008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffeff7ff), -0x1.000100100801p+48, 0x0p+0 },
+{ INT64_C(0x0001000100101000), 0x1.000100101p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffefefff), -0x1.000100101001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100110000), 0x1.00010011p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffeeffff), -0x1.000100110001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100120000), 0x1.00010012p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffedffff), -0x1.000100120001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100400000), 0x1.0001004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbfffff), -0x1.000100400001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100400001), 0x1.000100400001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbffffe), -0x1.000100400002p+48, 0x0p+0 },
+{ INT64_C(0x0001000100400004), 0x1.000100400004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbffffb), -0x1.000100400005p+48, 0x0p+0 },
+{ INT64_C(0x0001000100400040), 0x1.00010040004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbfffbf), -0x1.000100400041p+48, 0x0p+0 },
+{ INT64_C(0x0001000100400400), 0x1.0001004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbffbff), -0x1.000100400401p+48, 0x0p+0 },
+{ INT64_C(0x0001000100400800), 0x1.0001004008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbff7ff), -0x1.000100400801p+48, 0x0p+0 },
+{ INT64_C(0x0001000100402000), 0x1.000100402p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbfdfff), -0x1.000100402001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100410000), 0x1.00010041p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbeffff), -0x1.000100410001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100420000), 0x1.00010042p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffbdffff), -0x1.000100420001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100480000), 0x1.00010048p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffb7ffff), -0x1.000100480001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100500000), 0x1.0001005p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeffafffff), -0x1.000100500001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100800000), 0x1.0001008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7fffff), -0x1.000100800001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100800004), 0x1.000100800004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7ffffb), -0x1.000100800005p+48, 0x0p+0 },
+{ INT64_C(0x0001000100800020), 0x1.00010080002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7fffdf), -0x1.000100800021p+48, 0x0p+0 },
+{ INT64_C(0x0001000100800040), 0x1.00010080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7fffbf), -0x1.000100800041p+48, 0x0p+0 },
+{ INT64_C(0x0001000100800080), 0x1.00010080008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7fff7f), -0x1.000100800081p+48, 0x0p+0 },
+{ INT64_C(0x0001000100800200), 0x1.0001008002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7ffdff), -0x1.000100800201p+48, 0x0p+0 },
+{ INT64_C(0x0001000100802000), 0x1.000100802p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7fdfff), -0x1.000100802001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100808000), 0x1.000100808p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7f7fff), -0x1.000100808001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100810000), 0x1.00010081p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff7effff), -0x1.000100810001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100880000), 0x1.00010088p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff77ffff), -0x1.000100880001p+48, 0x0p+0 },
+{ INT64_C(0x0001000100a00000), 0x1.000100ap+48, 0x0p+0 },
+{ INT64_C(0xfffefffeff5fffff), -0x1.000100a00001p+48, 0x0p+0 },
+{ INT64_C(0x0001000101000000), 0x1.000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefeffffff), -0x1.000101000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000101000002), 0x1.000101000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefefffffd), -0x1.000101000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000101000020), 0x1.00010100002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefeffffdf), -0x1.000101000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000101000100), 0x1.0001010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefefffeff), -0x1.000101000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000101001000), 0x1.000101001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefeffefff), -0x1.000101001001p+48, 0x0p+0 },
+{ INT64_C(0x0001000101004000), 0x1.000101004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefeffbfff), -0x1.000101004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000101020000), 0x1.00010102p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefefdffff), -0x1.000101020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000101080000), 0x1.00010108p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefef7ffff), -0x1.000101080001p+48, 0x0p+0 },
+{ INT64_C(0x0001000101800000), 0x1.0001018p+48, 0x0p+0 },
+{ INT64_C(0xfffefffefe7fffff), -0x1.000101800001p+48, 0x0p+0 },
+{ INT64_C(0x0001000110000000), 0x1.00011p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeefffffff), -0x1.000110000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000110000002), 0x1.000110000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeeffffffd), -0x1.000110000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000110000020), 0x1.00011000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeefffffdf), -0x1.000110000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000110000080), 0x1.00011000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeefffff7f), -0x1.000110000081p+48, 0x0p+0 },
+{ INT64_C(0x0001000110000800), 0x1.0001100008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeeffff7ff), -0x1.000110000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000110001000), 0x1.000110001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeefffefff), -0x1.000110001001p+48, 0x0p+0 },
+{ INT64_C(0x0001000110008000), 0x1.000110008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeefff7fff), -0x1.000110008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000110020000), 0x1.00011002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeeffdffff), -0x1.000110020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000110200000), 0x1.0001102p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeefdfffff), -0x1.000110200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000112000000), 0x1.000112p+48, 0x0p+0 },
+{ INT64_C(0xfffefffeedffffff), -0x1.000112000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000140000000), 0x1.00014p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebfffffff), -0x1.000140000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000140000008), 0x1.000140000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebffffff7), -0x1.000140000009p+48, 0x0p+0 },
+{ INT64_C(0x0001000140000020), 0x1.00014000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebfffffdf), -0x1.000140000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000140000100), 0x1.0001400001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebffffeff), -0x1.000140000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000140000800), 0x1.0001400008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebffff7ff), -0x1.000140000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000140008000), 0x1.000140008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebfff7fff), -0x1.000140008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000140010000), 0x1.00014001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebffeffff), -0x1.000140010001p+48, 0x0p+0 },
+{ INT64_C(0x0001000140040000), 0x1.00014004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebffbffff), -0x1.000140040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000140400000), 0x1.0001404p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebfbfffff), -0x1.000140400001p+48, 0x0p+0 },
+{ INT64_C(0x0001000144000000), 0x1.000144p+48, 0x0p+0 },
+{ INT64_C(0xfffefffebbffffff), -0x1.000144000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000160000000), 0x1.00016p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe9fffffff), -0x1.000160000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000000), 0x1.00018p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fffffff), -0x1.000180000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000002), 0x1.000180000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7ffffffd), -0x1.000180000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000010), 0x1.00018000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fffffef), -0x1.000180000011p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000020), 0x1.00018000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fffffdf), -0x1.000180000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000040), 0x1.00018000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fffffbf), -0x1.000180000041p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000200), 0x1.0001800002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7ffffdff), -0x1.000180000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000180000800), 0x1.0001800008p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7ffff7ff), -0x1.000180000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000180002000), 0x1.000180002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fffdfff), -0x1.000180002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000180020000), 0x1.00018002p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7ffdffff), -0x1.000180020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000180100000), 0x1.0001801p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fefffff), -0x1.000180100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000180400000), 0x1.0001804p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7fbfffff), -0x1.000180400001p+48, 0x0p+0 },
+{ INT64_C(0x0001000182000000), 0x1.000182p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe7dffffff), -0x1.000182000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000190000000), 0x1.00019p+48, 0x0p+0 },
+{ INT64_C(0xfffefffe6fffffff), -0x1.000190000001p+48, 0x0p+0 },
+{ INT64_C(0x00010001c0000000), 0x1.0001cp+48, 0x0p+0 },
+{ INT64_C(0xfffefffe3fffffff), -0x1.0001c0000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000008), 0x1.000800000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffff7), -0x1.000800000009p+48, 0x0p+0 },
+{ INT64_C(0x000100080000000a), 0x1.00080000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffff5), -0x1.00080000000bp+48, 0x0p+0 },
+{ INT64_C(0x0001000800000040), 0x1.00080000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffffbf), -0x1.000800000041p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000042), 0x1.000800000042p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffffbd), -0x1.000800000043p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000060), 0x1.00080000006p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffff9f), -0x1.000800000061p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000100), 0x1.0008000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffeff), -0x1.000800000101p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000101), 0x1.000800000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffefe), -0x1.000800000102p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000108), 0x1.000800000108p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffef7), -0x1.000800000109p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000110), 0x1.00080000011p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffeef), -0x1.000800000111p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000180), 0x1.00080000018p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffe7f), -0x1.000800000181p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000400), 0x1.0008000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffbff), -0x1.000800000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000408), 0x1.000800000408p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffbf7), -0x1.000800000409p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000420), 0x1.00080000042p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffffbdf), -0x1.000800000421p+48, 0x0p+0 },
+{ INT64_C(0x0001000800000600), 0x1.0008000006p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffff9ff), -0x1.000800000601p+48, 0x0p+0 },
+{ INT64_C(0x0001000800004000), 0x1.000800004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffbfff), -0x1.000800004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800004004), 0x1.000800004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffbffb), -0x1.000800004005p+48, 0x0p+0 },
+{ INT64_C(0x0001000800004020), 0x1.00080000402p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffbfdf), -0x1.000800004021p+48, 0x0p+0 },
+{ INT64_C(0x0001000800004040), 0x1.00080000404p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffbfbf), -0x1.000800004041p+48, 0x0p+0 },
+{ INT64_C(0x0001000800004100), 0x1.0008000041p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffbeff), -0x1.000800004101p+48, 0x0p+0 },
+{ INT64_C(0x0001000800004400), 0x1.0008000044p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffbbff), -0x1.000800004401p+48, 0x0p+0 },
+{ INT64_C(0x0001000800005000), 0x1.000800005p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffffafff), -0x1.000800005001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800006000), 0x1.000800006p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffff9fff), -0x1.000800006001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800040000), 0x1.00080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffbffff), -0x1.000800040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800040008), 0x1.000800040008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffbfff7), -0x1.000800040009p+48, 0x0p+0 },
+{ INT64_C(0x0001000800040020), 0x1.00080004002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffbffdf), -0x1.000800040021p+48, 0x0p+0 },
+{ INT64_C(0x0001000800040100), 0x1.0008000401p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffbfeff), -0x1.000800040101p+48, 0x0p+0 },
+{ INT64_C(0x0001000800040200), 0x1.0008000402p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffbfdff), -0x1.000800040201p+48, 0x0p+0 },
+{ INT64_C(0x0001000800042000), 0x1.000800042p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fffbdfff), -0x1.000800042001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800060000), 0x1.00080006p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fff9ffff), -0x1.000800060001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800200000), 0x1.0008002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdfffff), -0x1.000800200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800200004), 0x1.000800200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdffffb), -0x1.000800200005p+48, 0x0p+0 },
+{ INT64_C(0x0001000800200040), 0x1.00080020004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdfffbf), -0x1.000800200041p+48, 0x0p+0 },
+{ INT64_C(0x0001000800200080), 0x1.00080020008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdfff7f), -0x1.000800200081p+48, 0x0p+0 },
+{ INT64_C(0x0001000800200200), 0x1.0008002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdffdff), -0x1.000800200201p+48, 0x0p+0 },
+{ INT64_C(0x0001000800202000), 0x1.000800202p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdfdfff), -0x1.000800202001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800204000), 0x1.000800204p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdfbfff), -0x1.000800204001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800210000), 0x1.00080021p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffdeffff), -0x1.000800210001p+48, 0x0p+0 },
+{ INT64_C(0x0001000800300000), 0x1.0008003p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7ffcfffff), -0x1.000800300001p+48, 0x0p+0 },
+{ INT64_C(0x0001000802000000), 0x1.000802p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdffffff), -0x1.000802000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000802000001), 0x1.000802000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdfffffe), -0x1.000802000002p+48, 0x0p+0 },
+{ INT64_C(0x0001000802000002), 0x1.000802000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdfffffd), -0x1.000802000003p+48, 0x0p+0 },
+{ INT64_C(0x0001000802000008), 0x1.000802000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdfffff7), -0x1.000802000009p+48, 0x0p+0 },
+{ INT64_C(0x0001000802000040), 0x1.00080200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdffffbf), -0x1.000802000041p+48, 0x0p+0 },
+{ INT64_C(0x0001000802000200), 0x1.0008020002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdfffdff), -0x1.000802000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000802002000), 0x1.000802002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdffdfff), -0x1.000802002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000802020000), 0x1.00080202p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fdfdffff), -0x1.000802020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000802200000), 0x1.0008022p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7fddfffff), -0x1.000802200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000808000000), 0x1.000808p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7ffffff), -0x1.000808000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000808000004), 0x1.000808000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7fffffb), -0x1.000808000005p+48, 0x0p+0 },
+{ INT64_C(0x0001000808000040), 0x1.00080800004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7ffffbf), -0x1.000808000041p+48, 0x0p+0 },
+{ INT64_C(0x0001000808000400), 0x1.0008080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7fffbff), -0x1.000808000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000808004000), 0x1.000808004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7ffbfff), -0x1.000808004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000808008000), 0x1.000808008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7ff7fff), -0x1.000808008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000808010000), 0x1.00080801p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7feffff), -0x1.000808010001p+48, 0x0p+0 },
+{ INT64_C(0x0001000808100000), 0x1.0008081p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f7efffff), -0x1.000808100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000808800000), 0x1.0008088p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f77fffff), -0x1.000808800001p+48, 0x0p+0 },
+{ INT64_C(0x0001000809000000), 0x1.000809p+48, 0x0p+0 },
+{ INT64_C(0xfffefff7f6ffffff), -0x1.000809000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880000000), 0x1.00088p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fffffff), -0x1.000880000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880000004), 0x1.000880000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77ffffffb), -0x1.000880000005p+48, 0x0p+0 },
+{ INT64_C(0x0001000880000020), 0x1.00088000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fffffdf), -0x1.000880000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000880000200), 0x1.0008800002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77ffffdff), -0x1.000880000201p+48, 0x0p+0 },
+{ INT64_C(0x0001000880000400), 0x1.0008800004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77ffffbff), -0x1.000880000401p+48, 0x0p+0 },
+{ INT64_C(0x0001000880001000), 0x1.000880001p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fffefff), -0x1.000880001001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880004000), 0x1.000880004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fffbfff), -0x1.000880004001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880008000), 0x1.000880008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fff7fff), -0x1.000880008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880040000), 0x1.00088004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77ffbffff), -0x1.000880040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880100000), 0x1.0008801p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fefffff), -0x1.000880100001p+48, 0x0p+0 },
+{ INT64_C(0x0001000880200000), 0x1.0008802p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77fdfffff), -0x1.000880200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000881000000), 0x1.000881p+48, 0x0p+0 },
+{ INT64_C(0xfffefff77effffff), -0x1.000881000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000890000000), 0x1.00089p+48, 0x0p+0 },
+{ INT64_C(0xfffefff76fffffff), -0x1.000890000001p+48, 0x0p+0 },
+{ INT64_C(0x00010008a0000000), 0x1.0008ap+48, 0x0p+0 },
+{ INT64_C(0xfffefff75fffffff), -0x1.0008a0000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00000000), 0x1.000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ffffffff), -0x1.000c00000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00000004), 0x1.000c00000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3fffffffb), -0x1.000c00000005p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00000020), 0x1.000c0000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ffffffdf), -0x1.000c00000021p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00000080), 0x1.000c0000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ffffff7f), -0x1.000c00000081p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00000800), 0x1.000c000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3fffff7ff), -0x1.000c00000801p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00002000), 0x1.000c00002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ffffdfff), -0x1.000c00002001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00008000), 0x1.000c00008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ffff7fff), -0x1.000c00008001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00010000), 0x1.000c0001p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3fffeffff), -0x1.000c00010001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00020000), 0x1.000c0002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3fffdffff), -0x1.000c00020001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00040000), 0x1.000c0004p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3fffbffff), -0x1.000c00040001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00200000), 0x1.000c002p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ffdfffff), -0x1.000c00200001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c00800000), 0x1.000c008p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3ff7fffff), -0x1.000c00800001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c01000000), 0x1.000c01p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3feffffff), -0x1.000c01000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c08000000), 0x1.000c08p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3f7ffffff), -0x1.000c08000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c20000000), 0x1.000c2p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3dfffffff), -0x1.000c20000001p+48, 0x0p+0 },
+{ INT64_C(0x0001000c40000000), 0x1.000c4p+48, 0x0p+0 },
+{ INT64_C(0xfffefff3bfffffff), -0x1.000c40000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000008), 0x1.008000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffffff7), -0x1.008000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000020), 0x1.00800000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffffdf), -0x1.008000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000028), 0x1.008000000028p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffffd7), -0x1.008000000029p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000080), 0x1.00800000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffff7f), -0x1.008000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000082), 0x1.008000000082p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffff7d), -0x1.008000000083p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000090), 0x1.00800000009p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffff6f), -0x1.008000000091p+48, 0x0p+0 },
+{ INT64_C(0x00010080000000a0), 0x1.0080000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffff5f), -0x1.0080000000a1p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000800), 0x1.0080000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffff7ff), -0x1.008000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000802), 0x1.008000000802p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffff7fd), -0x1.008000000803p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000808), 0x1.008000000808p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffff7f7), -0x1.008000000809p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000810), 0x1.00800000081p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffff7ef), -0x1.008000000811p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000820), 0x1.00800000082p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffff7df), -0x1.008000000821p+48, 0x0p+0 },
+{ INT64_C(0x0001008000000900), 0x1.0080000009p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffff6ff), -0x1.008000000901p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001000), 0x1.008000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffefff), -0x1.008000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001001), 0x1.008000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffeffe), -0x1.008000001002p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001004), 0x1.008000001004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffeffb), -0x1.008000001005p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001010), 0x1.00800000101p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffefef), -0x1.008000001011p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001020), 0x1.00800000102p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffefdf), -0x1.008000001021p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001080), 0x1.00800000108p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffef7f), -0x1.008000001081p+48, 0x0p+0 },
+{ INT64_C(0x0001008000001800), 0x1.0080000018p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffe7ff), -0x1.008000001801p+48, 0x0p+0 },
+{ INT64_C(0x0001008000002000), 0x1.008000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffdfff), -0x1.008000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000002004), 0x1.008000002004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffdffb), -0x1.008000002005p+48, 0x0p+0 },
+{ INT64_C(0x0001008000002040), 0x1.00800000204p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffdfbf), -0x1.008000002041p+48, 0x0p+0 },
+{ INT64_C(0x0001008000002100), 0x1.0080000021p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffdeff), -0x1.008000002101p+48, 0x0p+0 },
+{ INT64_C(0x0001008000003000), 0x1.008000003p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffffcfff), -0x1.008000003001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008000), 0x1.008000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff7fff), -0x1.008000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008004), 0x1.008000008004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff7ffb), -0x1.008000008005p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008010), 0x1.00800000801p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff7fef), -0x1.008000008011p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008040), 0x1.00800000804p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff7fbf), -0x1.008000008041p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008100), 0x1.0080000081p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff7eff), -0x1.008000008101p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008400), 0x1.0080000084p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff7bff), -0x1.008000008401p+48, 0x0p+0 },
+{ INT64_C(0x0001008000008800), 0x1.0080000088p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffff77ff), -0x1.008000008801p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020000), 0x1.00800002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdffff), -0x1.008000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020001), 0x1.008000020001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdfffe), -0x1.008000020002p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020002), 0x1.008000020002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdfffd), -0x1.008000020003p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020004), 0x1.008000020004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdfffb), -0x1.008000020005p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020020), 0x1.00800002002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdffdf), -0x1.008000020021p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020100), 0x1.0080000201p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdfeff), -0x1.008000020101p+48, 0x0p+0 },
+{ INT64_C(0x0001008000020400), 0x1.0080000204p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdfbff), -0x1.008000020401p+48, 0x0p+0 },
+{ INT64_C(0x0001008000021000), 0x1.008000021p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdefff), -0x1.008000021001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000022000), 0x1.008000022p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffddfff), -0x1.008000022001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000024000), 0x1.008000024p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffffdbfff), -0x1.008000024001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000080000), 0x1.00800008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff7ffff), -0x1.008000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000080008), 0x1.008000080008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff7fff7), -0x1.008000080009p+48, 0x0p+0 },
+{ INT64_C(0x0001008000080020), 0x1.00800008002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff7ffdf), -0x1.008000080021p+48, 0x0p+0 },
+{ INT64_C(0x0001008000080200), 0x1.0080000802p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff7fdff), -0x1.008000080201p+48, 0x0p+0 },
+{ INT64_C(0x0001008000080400), 0x1.0080000804p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff7fbff), -0x1.008000080401p+48, 0x0p+0 },
+{ INT64_C(0x0001008000081000), 0x1.008000081p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff7efff), -0x1.008000081001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000090000), 0x1.00800009p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff6ffff), -0x1.008000090001p+48, 0x0p+0 },
+{ INT64_C(0x00010080000a0000), 0x1.0080000ap+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffff5ffff), -0x1.0080000a0001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200000), 0x1.0080002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdfffff), -0x1.008000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200001), 0x1.008000200001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdffffe), -0x1.008000200002p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200002), 0x1.008000200002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdffffd), -0x1.008000200003p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200020), 0x1.00800020002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdfffdf), -0x1.008000200021p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200080), 0x1.00800020008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdfff7f), -0x1.008000200081p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200100), 0x1.0080002001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdffeff), -0x1.008000200101p+48, 0x0p+0 },
+{ INT64_C(0x0001008000200800), 0x1.0080002008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdff7ff), -0x1.008000200801p+48, 0x0p+0 },
+{ INT64_C(0x0001008000208000), 0x1.008000208p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdf7fff), -0x1.008000208001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000240000), 0x1.00800024p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffdbffff), -0x1.008000240001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000280000), 0x1.00800028p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fffd7ffff), -0x1.008000280001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800000), 0x1.0080008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7fffff), -0x1.008000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800001), 0x1.008000800001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7ffffe), -0x1.008000800002p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800004), 0x1.008000800004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7ffffb), -0x1.008000800005p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800020), 0x1.00800080002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7fffdf), -0x1.008000800021p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800080), 0x1.00800080008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7fff7f), -0x1.008000800081p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800200), 0x1.0080008002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7ffdff), -0x1.008000800201p+48, 0x0p+0 },
+{ INT64_C(0x0001008000800800), 0x1.0080008008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7ff7ff), -0x1.008000800801p+48, 0x0p+0 },
+{ INT64_C(0x0001008000802000), 0x1.008000802p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7fdfff), -0x1.008000802001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000804000), 0x1.008000804p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7fbfff), -0x1.008000804001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000810000), 0x1.00800081p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7effff), -0x1.008000810001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000840000), 0x1.00800084p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff7bffff), -0x1.008000840001p+48, 0x0p+0 },
+{ INT64_C(0x0001008000c00000), 0x1.008000cp+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fff3fffff), -0x1.008000c00001p+48, 0x0p+0 },
+{ INT64_C(0x0001008002000000), 0x1.008002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdffffff), -0x1.008002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008002000002), 0x1.008002000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdfffffd), -0x1.008002000003p+48, 0x0p+0 },
+{ INT64_C(0x0001008002000004), 0x1.008002000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdfffffb), -0x1.008002000005p+48, 0x0p+0 },
+{ INT64_C(0x0001008002000020), 0x1.00800200002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdffffdf), -0x1.008002000021p+48, 0x0p+0 },
+{ INT64_C(0x0001008002000080), 0x1.00800200008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdffff7f), -0x1.008002000081p+48, 0x0p+0 },
+{ INT64_C(0x0001008002000800), 0x1.0080020008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdfff7ff), -0x1.008002000801p+48, 0x0p+0 },
+{ INT64_C(0x0001008002004000), 0x1.008002004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdffbfff), -0x1.008002004001p+48, 0x0p+0 },
+{ INT64_C(0x0001008002040000), 0x1.00800204p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdfbffff), -0x1.008002040001p+48, 0x0p+0 },
+{ INT64_C(0x0001008002080000), 0x1.00800208p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdf7ffff), -0x1.008002080001p+48, 0x0p+0 },
+{ INT64_C(0x0001008002400000), 0x1.0080024p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ffdbfffff), -0x1.008002400001p+48, 0x0p+0 },
+{ INT64_C(0x0001008010000000), 0x1.00801p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fefffffff), -0x1.008010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008010000001), 0x1.008010000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7feffffffe), -0x1.008010000002p+48, 0x0p+0 },
+{ INT64_C(0x0001008010000010), 0x1.00801000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fefffffef), -0x1.008010000011p+48, 0x0p+0 },
+{ INT64_C(0x0001008010000040), 0x1.00801000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fefffffbf), -0x1.008010000041p+48, 0x0p+0 },
+{ INT64_C(0x0001008010000200), 0x1.0080100002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7feffffdff), -0x1.008010000201p+48, 0x0p+0 },
+{ INT64_C(0x0001008010000800), 0x1.0080100008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7feffff7ff), -0x1.008010000801p+48, 0x0p+0 },
+{ INT64_C(0x0001008010004000), 0x1.008010004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fefffbfff), -0x1.008010004001p+48, 0x0p+0 },
+{ INT64_C(0x0001008010040000), 0x1.00801004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7feffbffff), -0x1.008010040001p+48, 0x0p+0 },
+{ INT64_C(0x0001008010400000), 0x1.0080104p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7fefbfffff), -0x1.008010400001p+48, 0x0p+0 },
+{ INT64_C(0x0001008011000000), 0x1.008011p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7feeffffff), -0x1.008011000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008080000000), 0x1.00808p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7fffffff), -0x1.008080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008080000002), 0x1.008080000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7ffffffd), -0x1.008080000003p+48, 0x0p+0 },
+{ INT64_C(0x0001008080000010), 0x1.00808000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7fffffef), -0x1.008080000011p+48, 0x0p+0 },
+{ INT64_C(0x0001008080000080), 0x1.00808000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7fffff7f), -0x1.008080000081p+48, 0x0p+0 },
+{ INT64_C(0x0001008080000200), 0x1.0080800002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7ffffdff), -0x1.008080000201p+48, 0x0p+0 },
+{ INT64_C(0x0001008080000800), 0x1.0080800008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7ffff7ff), -0x1.008080000801p+48, 0x0p+0 },
+{ INT64_C(0x0001008080002000), 0x1.008080002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7fffdfff), -0x1.008080002001p+48, 0x0p+0 },
+{ INT64_C(0x0001008080020000), 0x1.00808002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7ffdffff), -0x1.008080020001p+48, 0x0p+0 },
+{ INT64_C(0x0001008080100000), 0x1.0080801p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7fefffff), -0x1.008080100001p+48, 0x0p+0 },
+{ INT64_C(0x0001008080400000), 0x1.0080804p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7fbfffff), -0x1.008080400001p+48, 0x0p+0 },
+{ INT64_C(0x0001008080800000), 0x1.0080808p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7f7fffff), -0x1.008080800001p+48, 0x0p+0 },
+{ INT64_C(0x0001008084000000), 0x1.008084p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f7bffffff), -0x1.008084000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008088000000), 0x1.008088p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f77ffffff), -0x1.008088000001p+48, 0x0p+0 },
+{ INT64_C(0x00010080a0000000), 0x1.0080ap+48, 0x0p+0 },
+{ INT64_C(0xfffeff7f5fffffff), -0x1.0080a0000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100000000), 0x1.0081p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7effffffff), -0x1.008100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100000004), 0x1.008100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7efffffffb), -0x1.008100000005p+48, 0x0p+0 },
+{ INT64_C(0x0001008100000020), 0x1.00810000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7effffffdf), -0x1.008100000021p+48, 0x0p+0 },
+{ INT64_C(0x0001008100000100), 0x1.0081000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7efffffeff), -0x1.008100000101p+48, 0x0p+0 },
+{ INT64_C(0x0001008100001000), 0x1.008100001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7effffefff), -0x1.008100001001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100002000), 0x1.008100002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7effffdfff), -0x1.008100002001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100010000), 0x1.00810001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7efffeffff), -0x1.008100010001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100080000), 0x1.00810008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7efff7ffff), -0x1.008100080001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100200000), 0x1.0081002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7effdfffff), -0x1.008100200001p+48, 0x0p+0 },
+{ INT64_C(0x0001008100400000), 0x1.0081004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7effbfffff), -0x1.008100400001p+48, 0x0p+0 },
+{ INT64_C(0x0001008102000000), 0x1.008102p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7efdffffff), -0x1.008102000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008120000000), 0x1.00812p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7edfffffff), -0x1.008120000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008140000000), 0x1.00814p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7ebfffffff), -0x1.008140000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008180000000), 0x1.00818p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7e7fffffff), -0x1.008180000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008400000000), 0x1.0084p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bffffffff), -0x1.008400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008400000002), 0x1.008400000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bfffffffd), -0x1.008400000003p+48, 0x0p+0 },
+{ INT64_C(0x0001008400000010), 0x1.00840000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bffffffef), -0x1.008400000011p+48, 0x0p+0 },
+{ INT64_C(0x0001008400000040), 0x1.00840000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bffffffbf), -0x1.008400000041p+48, 0x0p+0 },
+{ INT64_C(0x0001008400000100), 0x1.0084000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bfffffeff), -0x1.008400000101p+48, 0x0p+0 },
+{ INT64_C(0x0001008400000800), 0x1.0084000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bfffff7ff), -0x1.008400000801p+48, 0x0p+0 },
+{ INT64_C(0x0001008400004000), 0x1.008400004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bffffbfff), -0x1.008400004001p+48, 0x0p+0 },
+{ INT64_C(0x0001008400008000), 0x1.008400008p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bffff7fff), -0x1.008400008001p+48, 0x0p+0 },
+{ INT64_C(0x0001008400020000), 0x1.00840002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bfffdffff), -0x1.008400020001p+48, 0x0p+0 },
+{ INT64_C(0x0001008400200000), 0x1.0084002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bffdfffff), -0x1.008400200001p+48, 0x0p+0 },
+{ INT64_C(0x0001008402000000), 0x1.008402p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bfdffffff), -0x1.008402000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008408000000), 0x1.008408p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7bf7ffffff), -0x1.008408000001p+48, 0x0p+0 },
+{ INT64_C(0x0001008480000000), 0x1.00848p+48, 0x0p+0 },
+{ INT64_C(0xfffeff7b7fffffff), -0x1.008480000001p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000000), 0x1.00ap+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fffffffff), -0x1.00a000000001p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000002), 0x1.00a000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffffffffd), -0x1.00a000000003p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000010), 0x1.00a00000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fffffffef), -0x1.00a000000011p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000020), 0x1.00a00000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fffffffdf), -0x1.00a000000021p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000100), 0x1.00a0000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffffffeff), -0x1.00a000000101p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000200), 0x1.00a0000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffffffdff), -0x1.00a000000201p+48, 0x0p+0 },
+{ INT64_C(0x000100a000000400), 0x1.00a0000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffffffbff), -0x1.00a000000401p+48, 0x0p+0 },
+{ INT64_C(0x000100a000004000), 0x1.00a000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fffffbfff), -0x1.00a000004001p+48, 0x0p+0 },
+{ INT64_C(0x000100a000010000), 0x1.00a00001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffffeffff), -0x1.00a000010001p+48, 0x0p+0 },
+{ INT64_C(0x000100a000020000), 0x1.00a00002p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffffdffff), -0x1.00a000020001p+48, 0x0p+0 },
+{ INT64_C(0x000100a000100000), 0x1.00a0001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fffefffff), -0x1.00a000100001p+48, 0x0p+0 },
+{ INT64_C(0x000100a000400000), 0x1.00a0004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fffbfffff), -0x1.00a000400001p+48, 0x0p+0 },
+{ INT64_C(0x000100a001000000), 0x1.00a001p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffeffffff), -0x1.00a001000001p+48, 0x0p+0 },
+{ INT64_C(0x000100a004000000), 0x1.00a004p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5ffbffffff), -0x1.00a004000001p+48, 0x0p+0 },
+{ INT64_C(0x000100a020000000), 0x1.00a02p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5fdfffffff), -0x1.00a020000001p+48, 0x0p+0 },
+{ INT64_C(0x000100a200000000), 0x1.00a2p+48, 0x0p+0 },
+{ INT64_C(0xfffeff5dffffffff), -0x1.00a200000001p+48, 0x0p+0 },
+{ INT64_C(0x000100b000000000), 0x1.00bp+48, 0x0p+0 },
+{ INT64_C(0xfffeff4fffffffff), -0x1.00b000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000008), 0x1.010000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffff7), -0x1.010000000009p+48, 0x0p+0 },
+{ INT64_C(0x000101000000000a), 0x1.01000000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffff5), -0x1.01000000000bp+48, 0x0p+0 },
+{ INT64_C(0x0001010000000080), 0x1.01000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffff7f), -0x1.010000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000084), 0x1.010000000084p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffff7b), -0x1.010000000085p+48, 0x0p+0 },
+{ INT64_C(0x00010100000000c0), 0x1.0100000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffff3f), -0x1.0100000000c1p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000100), 0x1.0100000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffeff), -0x1.010000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000104), 0x1.010000000104p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffefb), -0x1.010000000105p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000140), 0x1.01000000014p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffebf), -0x1.010000000141p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000400), 0x1.0100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffbff), -0x1.010000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000404), 0x1.010000000404p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffbfb), -0x1.010000000405p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000408), 0x1.010000000408p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffbf7), -0x1.010000000409p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000440), 0x1.01000000044p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffbbf), -0x1.010000000441p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000480), 0x1.01000000048p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffffb7f), -0x1.010000000481p+48, 0x0p+0 },
+{ INT64_C(0x0001010000000600), 0x1.0100000006p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffff9ff), -0x1.010000000601p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001000), 0x1.010000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffefff), -0x1.010000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001001), 0x1.010000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffeffe), -0x1.010000001002p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001008), 0x1.010000001008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffeff7), -0x1.010000001009p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001010), 0x1.01000000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffefef), -0x1.010000001011p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001020), 0x1.01000000102p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffefdf), -0x1.010000001021p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001040), 0x1.01000000104p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffefbf), -0x1.010000001041p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001080), 0x1.01000000108p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffef7f), -0x1.010000001081p+48, 0x0p+0 },
+{ INT64_C(0x0001010000001800), 0x1.0100000018p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffe7ff), -0x1.010000001801p+48, 0x0p+0 },
+{ INT64_C(0x0001010000004000), 0x1.010000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffbfff), -0x1.010000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000004001), 0x1.010000004001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffbffe), -0x1.010000004002p+48, 0x0p+0 },
+{ INT64_C(0x0001010000004002), 0x1.010000004002p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffbffd), -0x1.010000004003p+48, 0x0p+0 },
+{ INT64_C(0x0001010000004010), 0x1.01000000401p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffbfef), -0x1.010000004011p+48, 0x0p+0 },
+{ INT64_C(0x0001010000004080), 0x1.01000000408p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffbf7f), -0x1.010000004081p+48, 0x0p+0 },
+{ INT64_C(0x0001010000004200), 0x1.0100000042p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffffbdff), -0x1.010000004201p+48, 0x0p+0 },
+{ INT64_C(0x0001010000006000), 0x1.010000006p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffffff9fff), -0x1.010000006001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010000), 0x1.01000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffeffff), -0x1.010000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010001), 0x1.010000010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffefffe), -0x1.010000010002p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010008), 0x1.010000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffefff7), -0x1.010000010009p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010020), 0x1.01000001002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffeffdf), -0x1.010000010021p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010040), 0x1.01000001004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffeffbf), -0x1.010000010041p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010100), 0x1.0100000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffefeff), -0x1.010000010101p+48, 0x0p+0 },
+{ INT64_C(0x0001010000010800), 0x1.0100000108p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffef7ff), -0x1.010000010801p+48, 0x0p+0 },
+{ INT64_C(0x0001010000018000), 0x1.010000018p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffffe7fff), -0x1.010000018001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000080000), 0x1.01000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff7ffff), -0x1.010000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000080001), 0x1.010000080001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff7fffe), -0x1.010000080002p+48, 0x0p+0 },
+{ INT64_C(0x0001010000080010), 0x1.01000008001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff7ffef), -0x1.010000080011p+48, 0x0p+0 },
+{ INT64_C(0x0001010000080080), 0x1.01000008008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff7ff7f), -0x1.010000080081p+48, 0x0p+0 },
+{ INT64_C(0x0001010000080400), 0x1.0100000804p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff7fbff), -0x1.010000080401p+48, 0x0p+0 },
+{ INT64_C(0x0001010000082000), 0x1.010000082p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff7dfff), -0x1.010000082001p+48, 0x0p+0 },
+{ INT64_C(0x00010100000a0000), 0x1.0100000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefefffff5ffff), -0x1.0100000a0001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000800000), 0x1.0100008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7fffff), -0x1.010000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000800002), 0x1.010000800002p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7ffffd), -0x1.010000800003p+48, 0x0p+0 },
+{ INT64_C(0x0001010000800010), 0x1.01000080001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7fffef), -0x1.010000800011p+48, 0x0p+0 },
+{ INT64_C(0x0001010000800020), 0x1.01000080002p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7fffdf), -0x1.010000800021p+48, 0x0p+0 },
+{ INT64_C(0x0001010000800040), 0x1.01000080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7fffbf), -0x1.010000800041p+48, 0x0p+0 },
+{ INT64_C(0x0001010000800100), 0x1.0100008001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7ffeff), -0x1.010000800101p+48, 0x0p+0 },
+{ INT64_C(0x0001010000801000), 0x1.010000801p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7fefff), -0x1.010000801001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000808000), 0x1.010000808p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7f7fff), -0x1.010000808001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000840000), 0x1.01000084p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff7bffff), -0x1.010000840001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000880000), 0x1.01000088p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff77ffff), -0x1.010000880001p+48, 0x0p+0 },
+{ INT64_C(0x0001010000a00000), 0x1.010000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefeffff5fffff), -0x1.010000a00001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002000000), 0x1.010002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdffffff), -0x1.010002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002000001), 0x1.010002000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdfffffe), -0x1.010002000002p+48, 0x0p+0 },
+{ INT64_C(0x0001010002000008), 0x1.010002000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdfffff7), -0x1.010002000009p+48, 0x0p+0 },
+{ INT64_C(0x0001010002000080), 0x1.01000200008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdffff7f), -0x1.010002000081p+48, 0x0p+0 },
+{ INT64_C(0x0001010002000400), 0x1.0100020004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdfffbff), -0x1.010002000401p+48, 0x0p+0 },
+{ INT64_C(0x0001010002001000), 0x1.010002001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdffefff), -0x1.010002001001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002002000), 0x1.010002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdffdfff), -0x1.010002002001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002010000), 0x1.01000201p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdfeffff), -0x1.010002010001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002040000), 0x1.01000204p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdfbffff), -0x1.010002040001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002080000), 0x1.01000208p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdf7ffff), -0x1.010002080001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002100000), 0x1.0100021p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffdefffff), -0x1.010002100001p+48, 0x0p+0 },
+{ INT64_C(0x0001010002800000), 0x1.0100028p+48, 0x0p+0 },
+{ INT64_C(0xfffefefffd7fffff), -0x1.010002800001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010000000), 0x1.01001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffefffffff), -0x1.010010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010000004), 0x1.010010000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffeffffffb), -0x1.010010000005p+48, 0x0p+0 },
+{ INT64_C(0x0001010010000040), 0x1.01001000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffefffffbf), -0x1.010010000041p+48, 0x0p+0 },
+{ INT64_C(0x0001010010000100), 0x1.0100100001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffeffffeff), -0x1.010010000101p+48, 0x0p+0 },
+{ INT64_C(0x0001010010001000), 0x1.010010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffefffefff), -0x1.010010001001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010004000), 0x1.010010004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffefffbfff), -0x1.010010004001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010008000), 0x1.010010008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffefff7fff), -0x1.010010008001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010020000), 0x1.01001002p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffeffdffff), -0x1.010010020001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010040000), 0x1.01001004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffeffbffff), -0x1.010010040001p+48, 0x0p+0 },
+{ INT64_C(0x0001010010100000), 0x1.0100101p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffefefffff), -0x1.010010100001p+48, 0x0p+0 },
+{ INT64_C(0x0001010011000000), 0x1.010011p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffeeffffff), -0x1.010011000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010014000000), 0x1.010014p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffebffffff), -0x1.010014000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010040000000), 0x1.01004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbfffffff), -0x1.010040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010040000008), 0x1.010040000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbffffff7), -0x1.010040000009p+48, 0x0p+0 },
+{ INT64_C(0x0001010040000080), 0x1.01004000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbfffff7f), -0x1.010040000081p+48, 0x0p+0 },
+{ INT64_C(0x0001010040000800), 0x1.0100400008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbffff7ff), -0x1.010040000801p+48, 0x0p+0 },
+{ INT64_C(0x0001010040002000), 0x1.010040002p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbfffdfff), -0x1.010040002001p+48, 0x0p+0 },
+{ INT64_C(0x0001010040008000), 0x1.010040008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbfff7fff), -0x1.010040008001p+48, 0x0p+0 },
+{ INT64_C(0x0001010040080000), 0x1.01004008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbff7ffff), -0x1.010040080001p+48, 0x0p+0 },
+{ INT64_C(0x0001010040800000), 0x1.0100408p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbf7fffff), -0x1.010040800001p+48, 0x0p+0 },
+{ INT64_C(0x0001010042000000), 0x1.010042p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbdffffff), -0x1.010042000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010044000000), 0x1.010044p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffbbffffff), -0x1.010044000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010048000000), 0x1.010048p+48, 0x0p+0 },
+{ INT64_C(0xfffefeffb7ffffff), -0x1.010048000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000000), 0x1.0101p+48, 0x0p+0 },
+{ INT64_C(0xfffefefeffffffff), -0x1.010100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000001), 0x1.010100000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffffffe), -0x1.010100000002p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000004), 0x1.010100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffffffb), -0x1.010100000005p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000040), 0x1.01010000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefeffffffbf), -0x1.010100000041p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000200), 0x1.0101000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffffdff), -0x1.010100000201p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000400), 0x1.0101000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffffbff), -0x1.010100000401p+48, 0x0p+0 },
+{ INT64_C(0x0001010100000800), 0x1.0101000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffff7ff), -0x1.010100000801p+48, 0x0p+0 },
+{ INT64_C(0x0001010100001000), 0x1.010100001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefeffffefff), -0x1.010100001001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100010000), 0x1.01010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffeffff), -0x1.010100010001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100020000), 0x1.01010002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefffdffff), -0x1.010100020001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100100000), 0x1.0101001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefeffefffff), -0x1.010100100001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100400000), 0x1.0101004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefeffbfffff), -0x1.010100400001p+48, 0x0p+0 },
+{ INT64_C(0x0001010100800000), 0x1.0101008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefeff7fffff), -0x1.010100800001p+48, 0x0p+0 },
+{ INT64_C(0x0001010102000000), 0x1.010102p+48, 0x0p+0 },
+{ INT64_C(0xfffefefefdffffff), -0x1.010102000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010120000000), 0x1.01012p+48, 0x0p+0 },
+{ INT64_C(0xfffefefedfffffff), -0x1.010120000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010180000000), 0x1.01018p+48, 0x0p+0 },
+{ INT64_C(0xfffefefe7fffffff), -0x1.010180000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400000000), 0x1.0104p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffffffff), -0x1.010400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400000004), 0x1.010400000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfffffffb), -0x1.010400000005p+48, 0x0p+0 },
+{ INT64_C(0x0001010400000010), 0x1.01040000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffffffef), -0x1.010400000011p+48, 0x0p+0 },
+{ INT64_C(0x0001010400000020), 0x1.01040000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffffffdf), -0x1.010400000021p+48, 0x0p+0 },
+{ INT64_C(0x0001010400000100), 0x1.0104000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfffffeff), -0x1.010400000101p+48, 0x0p+0 },
+{ INT64_C(0x0001010400000200), 0x1.0104000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfffffdff), -0x1.010400000201p+48, 0x0p+0 },
+{ INT64_C(0x0001010400001000), 0x1.010400001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffffefff), -0x1.010400001001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400004000), 0x1.010400004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffffbfff), -0x1.010400004001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400008000), 0x1.010400008p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffff7fff), -0x1.010400008001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400010000), 0x1.01040001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfffeffff), -0x1.010400010001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400020000), 0x1.01040002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfffdffff), -0x1.010400020001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400100000), 0x1.0104001p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffefffff), -0x1.010400100001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400200000), 0x1.0104002p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffdfffff), -0x1.010400200001p+48, 0x0p+0 },
+{ INT64_C(0x0001010400400000), 0x1.0104004p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbffbfffff), -0x1.010400400001p+48, 0x0p+0 },
+{ INT64_C(0x0001010401000000), 0x1.010401p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfeffffff), -0x1.010401000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010404000000), 0x1.010404p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbfbffffff), -0x1.010404000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010410000000), 0x1.01041p+48, 0x0p+0 },
+{ INT64_C(0xfffefefbefffffff), -0x1.010410000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010480000000), 0x1.01048p+48, 0x0p+0 },
+{ INT64_C(0xfffefefb7fffffff), -0x1.010480000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010600000000), 0x1.0106p+48, 0x0p+0 },
+{ INT64_C(0xfffefef9ffffffff), -0x1.010600000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010800000000), 0x1.0108p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7ffffffff), -0x1.010800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010800000001), 0x1.010800000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7fffffffe), -0x1.010800000002p+48, 0x0p+0 },
+{ INT64_C(0x0001010800000004), 0x1.010800000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7fffffffb), -0x1.010800000005p+48, 0x0p+0 },
+{ INT64_C(0x0001010800000020), 0x1.01080000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7ffffffdf), -0x1.010800000021p+48, 0x0p+0 },
+{ INT64_C(0x0001010800000100), 0x1.0108000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7fffffeff), -0x1.010800000101p+48, 0x0p+0 },
+{ INT64_C(0x0001010800000800), 0x1.0108000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7fffff7ff), -0x1.010800000801p+48, 0x0p+0 },
+{ INT64_C(0x0001010800002000), 0x1.010800002p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7ffffdfff), -0x1.010800002001p+48, 0x0p+0 },
+{ INT64_C(0x0001010800004000), 0x1.010800004p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7ffffbfff), -0x1.010800004001p+48, 0x0p+0 },
+{ INT64_C(0x0001010800020000), 0x1.01080002p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7fffdffff), -0x1.010800020001p+48, 0x0p+0 },
+{ INT64_C(0x0001010800200000), 0x1.0108002p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7ffdfffff), -0x1.010800200001p+48, 0x0p+0 },
+{ INT64_C(0x0001010800800000), 0x1.0108008p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7ff7fffff), -0x1.010800800001p+48, 0x0p+0 },
+{ INT64_C(0x0001010808000000), 0x1.010808p+48, 0x0p+0 },
+{ INT64_C(0xfffefef7f7ffffff), -0x1.010808000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010880000000), 0x1.01088p+48, 0x0p+0 },
+{ INT64_C(0xfffefef77fffffff), -0x1.010880000001p+48, 0x0p+0 },
+{ INT64_C(0x0001010a00000000), 0x1.010ap+48, 0x0p+0 },
+{ INT64_C(0xfffefef5ffffffff), -0x1.010a00000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011000000000), 0x1.011p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefffffffff), -0x1.011000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011000000004), 0x1.011000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeeffffffffb), -0x1.011000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001011000000010), 0x1.01100000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefffffffef), -0x1.011000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001011000000040), 0x1.01100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefffffffbf), -0x1.011000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001011000000400), 0x1.0110000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeeffffffbff), -0x1.011000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001011000001000), 0x1.011000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefffffefff), -0x1.011000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001011000008000), 0x1.011000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefffff7fff), -0x1.011000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001011000040000), 0x1.01100004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeeffffbffff), -0x1.011000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001011000100000), 0x1.0110001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefffefffff), -0x1.011000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001011001000000), 0x1.011001p+48, 0x0p+0 },
+{ INT64_C(0xfffefeeffeffffff), -0x1.011001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011004000000), 0x1.011004p+48, 0x0p+0 },
+{ INT64_C(0xfffefeeffbffffff), -0x1.011004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011008000000), 0x1.011008p+48, 0x0p+0 },
+{ INT64_C(0xfffefeeff7ffffff), -0x1.011008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011010000000), 0x1.01101p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefefffffff), -0x1.011010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011040000000), 0x1.01104p+48, 0x0p+0 },
+{ INT64_C(0xfffefeefbfffffff), -0x1.011040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001011400000000), 0x1.0114p+48, 0x0p+0 },
+{ INT64_C(0xfffefeebffffffff), -0x1.011400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000002), 0x1.020000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffffd), -0x1.020000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000003), 0x1.020000000003p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffffc), -0x1.020000000004p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000008), 0x1.020000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffff7), -0x1.020000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000009), 0x1.020000000009p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffff6), -0x1.02000000000ap+48, 0x0p+0 },
+{ INT64_C(0x0001020000000040), 0x1.02000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffffbf), -0x1.020000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000044), 0x1.020000000044p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffffbb), -0x1.020000000045p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000048), 0x1.020000000048p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffffb7), -0x1.020000000049p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000060), 0x1.02000000006p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffff9f), -0x1.020000000061p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000080), 0x1.02000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffff7f), -0x1.020000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000084), 0x1.020000000084p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffff7b), -0x1.020000000085p+48, 0x0p+0 },
+{ INT64_C(0x00010200000000a0), 0x1.0200000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffff5f), -0x1.0200000000a1p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000100), 0x1.0200000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffeff), -0x1.020000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000101), 0x1.020000000101p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffefe), -0x1.020000000102p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000102), 0x1.020000000102p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffefd), -0x1.020000000103p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000108), 0x1.020000000108p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffef7), -0x1.020000000109p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000110), 0x1.02000000011p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffeef), -0x1.020000000111p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000180), 0x1.02000000018p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffe7f), -0x1.020000000181p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000200), 0x1.0200000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffdff), -0x1.020000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000201), 0x1.020000000201p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffdfe), -0x1.020000000202p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000208), 0x1.020000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffdf7), -0x1.020000000209p+48, 0x0p+0 },
+{ INT64_C(0x0001020000000240), 0x1.02000000024p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffffdbf), -0x1.020000000241p+48, 0x0p+0 },
+{ INT64_C(0x0001020000002000), 0x1.020000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffdfff), -0x1.020000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000002002), 0x1.020000002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffdffd), -0x1.020000002003p+48, 0x0p+0 },
+{ INT64_C(0x0001020000002020), 0x1.02000000202p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffdfdf), -0x1.020000002021p+48, 0x0p+0 },
+{ INT64_C(0x0001020000002080), 0x1.02000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffdf7f), -0x1.020000002081p+48, 0x0p+0 },
+{ INT64_C(0x0001020000002100), 0x1.0200000021p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffdeff), -0x1.020000002101p+48, 0x0p+0 },
+{ INT64_C(0x0001020000003000), 0x1.020000003p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffffcfff), -0x1.020000003001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010000), 0x1.02000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffeffff), -0x1.020000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010002), 0x1.020000010002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffefffd), -0x1.020000010003p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010004), 0x1.020000010004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffefffb), -0x1.020000010005p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010010), 0x1.02000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffeffef), -0x1.020000010011p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010040), 0x1.02000001004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffeffbf), -0x1.020000010041p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010080), 0x1.02000001008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffeff7f), -0x1.020000010081p+48, 0x0p+0 },
+{ INT64_C(0x0001020000010400), 0x1.0200000104p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffefbff), -0x1.020000010401p+48, 0x0p+0 },
+{ INT64_C(0x0001020000011000), 0x1.020000011p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffffeefff), -0x1.020000011001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000100000), 0x1.0200001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffefffff), -0x1.020000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000100002), 0x1.020000100002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffeffffd), -0x1.020000100003p+48, 0x0p+0 },
+{ INT64_C(0x0001020000100010), 0x1.02000010001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffefffef), -0x1.020000100011p+48, 0x0p+0 },
+{ INT64_C(0x0001020000100080), 0x1.02000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffefff7f), -0x1.020000100081p+48, 0x0p+0 },
+{ INT64_C(0x0001020000100400), 0x1.0200001004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffeffbff), -0x1.020000100401p+48, 0x0p+0 },
+{ INT64_C(0x0001020000104000), 0x1.020000104p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffefbfff), -0x1.020000104001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000120000), 0x1.02000012p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffedffff), -0x1.020000120001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000140000), 0x1.02000014p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffebffff), -0x1.020000140001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200000), 0x1.0200002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdfffff), -0x1.020000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200001), 0x1.020000200001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdffffe), -0x1.020000200002p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200004), 0x1.020000200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdffffb), -0x1.020000200005p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200020), 0x1.02000020002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdfffdf), -0x1.020000200021p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200100), 0x1.0200002001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdffeff), -0x1.020000200101p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200200), 0x1.0200002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdffdff), -0x1.020000200201p+48, 0x0p+0 },
+{ INT64_C(0x0001020000200400), 0x1.0200002004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdffbff), -0x1.020000200401p+48, 0x0p+0 },
+{ INT64_C(0x0001020000202000), 0x1.020000202p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdfdfff), -0x1.020000202001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000210000), 0x1.02000021p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdeffff), -0x1.020000210001p+48, 0x0p+0 },
+{ INT64_C(0x0001020000240000), 0x1.02000024p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffffdbffff), -0x1.020000240001p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000000), 0x1.020002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdffffff), -0x1.020002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000004), 0x1.020002000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdfffffb), -0x1.020002000005p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000010), 0x1.02000200001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdffffef), -0x1.020002000011p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000040), 0x1.02000200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdffffbf), -0x1.020002000041p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000080), 0x1.02000200008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdffff7f), -0x1.020002000081p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000100), 0x1.0200020001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdfffeff), -0x1.020002000101p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000400), 0x1.0200020004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdfffbff), -0x1.020002000401p+48, 0x0p+0 },
+{ INT64_C(0x0001020002000800), 0x1.0200020008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdfff7ff), -0x1.020002000801p+48, 0x0p+0 },
+{ INT64_C(0x0001020002002000), 0x1.020002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdffdfff), -0x1.020002002001p+48, 0x0p+0 },
+{ INT64_C(0x0001020002008000), 0x1.020002008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdff7fff), -0x1.020002008001p+48, 0x0p+0 },
+{ INT64_C(0x0001020002080000), 0x1.02000208p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffdf7ffff), -0x1.020002080001p+48, 0x0p+0 },
+{ INT64_C(0x0001020002800000), 0x1.0200028p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfffd7fffff), -0x1.020002800001p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000000), 0x1.02002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdfffffff), -0x1.020020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000002), 0x1.020020000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdffffffd), -0x1.020020000003p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000004), 0x1.020020000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdffffffb), -0x1.020020000005p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000010), 0x1.02002000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdfffffef), -0x1.020020000011p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000040), 0x1.02002000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdfffffbf), -0x1.020020000041p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000200), 0x1.0200200002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdffffdff), -0x1.020020000201p+48, 0x0p+0 },
+{ INT64_C(0x0001020020000400), 0x1.0200200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdffffbff), -0x1.020020000401p+48, 0x0p+0 },
+{ INT64_C(0x0001020020004000), 0x1.020020004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdfffbfff), -0x1.020020004001p+48, 0x0p+0 },
+{ INT64_C(0x0001020020008000), 0x1.020020008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdfff7fff), -0x1.020020008001p+48, 0x0p+0 },
+{ INT64_C(0x0001020020010000), 0x1.02002001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdffeffff), -0x1.020020010001p+48, 0x0p+0 },
+{ INT64_C(0x0001020020020000), 0x1.02002002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdffdffff), -0x1.020020020001p+48, 0x0p+0 },
+{ INT64_C(0x0001020020200000), 0x1.0200202p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdfdfffff), -0x1.020020200001p+48, 0x0p+0 },
+{ INT64_C(0x0001020021000000), 0x1.020021p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdeffffff), -0x1.020021000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020024000000), 0x1.020024p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffdbffffff), -0x1.020024000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020030000000), 0x1.02003p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffcfffffff), -0x1.020030000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040000000), 0x1.02004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbfffffff), -0x1.020040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040000002), 0x1.020040000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbffffffd), -0x1.020040000003p+48, 0x0p+0 },
+{ INT64_C(0x0001020040000020), 0x1.02004000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbfffffdf), -0x1.020040000021p+48, 0x0p+0 },
+{ INT64_C(0x0001020040000200), 0x1.0200400002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbffffdff), -0x1.020040000201p+48, 0x0p+0 },
+{ INT64_C(0x0001020040002000), 0x1.020040002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbfffdfff), -0x1.020040002001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040008000), 0x1.020040008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbfff7fff), -0x1.020040008001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040040000), 0x1.02004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbffbffff), -0x1.020040040001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040080000), 0x1.02004008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbff7ffff), -0x1.020040080001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040100000), 0x1.0200401p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbfefffff), -0x1.020040100001p+48, 0x0p+0 },
+{ INT64_C(0x0001020040200000), 0x1.0200402p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbfdfffff), -0x1.020040200001p+48, 0x0p+0 },
+{ INT64_C(0x0001020041000000), 0x1.020041p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffbeffffff), -0x1.020041000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020048000000), 0x1.020048p+48, 0x0p+0 },
+{ INT64_C(0xfffefdffb7ffffff), -0x1.020048000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020200000000), 0x1.0202p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdffffffff), -0x1.020200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020200000004), 0x1.020200000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdfffffffb), -0x1.020200000005p+48, 0x0p+0 },
+{ INT64_C(0x0001020200000020), 0x1.02020000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdffffffdf), -0x1.020200000021p+48, 0x0p+0 },
+{ INT64_C(0x0001020200000080), 0x1.02020000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdffffff7f), -0x1.020200000081p+48, 0x0p+0 },
+{ INT64_C(0x0001020200000200), 0x1.0202000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdfffffdff), -0x1.020200000201p+48, 0x0p+0 },
+{ INT64_C(0x0001020200000400), 0x1.0202000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdfffffbff), -0x1.020200000401p+48, 0x0p+0 },
+{ INT64_C(0x0001020200001000), 0x1.020200001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdffffefff), -0x1.020200001001p+48, 0x0p+0 },
+{ INT64_C(0x0001020200010000), 0x1.02020001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdfffeffff), -0x1.020200010001p+48, 0x0p+0 },
+{ INT64_C(0x0001020200100000), 0x1.0202001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdffefffff), -0x1.020200100001p+48, 0x0p+0 },
+{ INT64_C(0x0001020200400000), 0x1.0202004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdffbfffff), -0x1.020200400001p+48, 0x0p+0 },
+{ INT64_C(0x0001020200800000), 0x1.0202008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdff7fffff), -0x1.020200800001p+48, 0x0p+0 },
+{ INT64_C(0x0001020204000000), 0x1.020204p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdfbffffff), -0x1.020204000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020240000000), 0x1.02024p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfdbfffffff), -0x1.020240000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020300000000), 0x1.0203p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfcffffffff), -0x1.020300000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000000), 0x1.0204p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbffffffff), -0x1.020400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000001), 0x1.020400000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffffffe), -0x1.020400000002p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000004), 0x1.020400000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffffffb), -0x1.020400000005p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000008), 0x1.020400000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffffff7), -0x1.020400000009p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000020), 0x1.02040000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbffffffdf), -0x1.020400000021p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000200), 0x1.0204000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffffdff), -0x1.020400000201p+48, 0x0p+0 },
+{ INT64_C(0x0001020400000400), 0x1.0204000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffffbff), -0x1.020400000401p+48, 0x0p+0 },
+{ INT64_C(0x0001020400004000), 0x1.020400004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbffffbfff), -0x1.020400004001p+48, 0x0p+0 },
+{ INT64_C(0x0001020400010000), 0x1.02040001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffeffff), -0x1.020400010001p+48, 0x0p+0 },
+{ INT64_C(0x0001020400040000), 0x1.02040004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfffbffff), -0x1.020400040001p+48, 0x0p+0 },
+{ INT64_C(0x0001020400200000), 0x1.0204002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbffdfffff), -0x1.020400200001p+48, 0x0p+0 },
+{ INT64_C(0x0001020402000000), 0x1.020402p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbfdffffff), -0x1.020402000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020408000000), 0x1.020408p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfbf7ffffff), -0x1.020408000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020480000000), 0x1.02048p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfb7fffffff), -0x1.020480000001p+48, 0x0p+0 },
+{ INT64_C(0x0001020500000000), 0x1.0205p+48, 0x0p+0 },
+{ INT64_C(0xfffefdfaffffffff), -0x1.020500000001p+48, 0x0p+0 },
+{ INT64_C(0x0001021000000000), 0x1.021p+48, 0x0p+0 },
+{ INT64_C(0xfffefdefffffffff), -0x1.021000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001021000000008), 0x1.021000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdeffffffff7), -0x1.021000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001021000000040), 0x1.02100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefdefffffffbf), -0x1.021000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001021000000200), 0x1.0210000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdeffffffdff), -0x1.021000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001021000002000), 0x1.021000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdefffffdfff), -0x1.021000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001021000010000), 0x1.02100001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdeffffeffff), -0x1.021000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001021000020000), 0x1.02100002p+48, 0x0p+0 },
+{ INT64_C(0xfffefdeffffdffff), -0x1.021000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001021000100000), 0x1.0210001p+48, 0x0p+0 },
+{ INT64_C(0xfffefdefffefffff), -0x1.021000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001021000800000), 0x1.0210008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdefff7fffff), -0x1.021000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001021008000000), 0x1.021008p+48, 0x0p+0 },
+{ INT64_C(0xfffefdeff7ffffff), -0x1.021008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001021040000000), 0x1.02104p+48, 0x0p+0 },
+{ INT64_C(0xfffefdefbfffffff), -0x1.021040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001021100000000), 0x1.0211p+48, 0x0p+0 },
+{ INT64_C(0xfffefdeeffffffff), -0x1.021100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000000), 0x1.022p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfffffffff), -0x1.022000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000002), 0x1.022000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffffffd), -0x1.022000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000004), 0x1.022000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffffffb), -0x1.022000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000008), 0x1.022000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffffff7), -0x1.022000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000020), 0x1.02200000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfffffffdf), -0x1.022000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000100), 0x1.0220000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffffeff), -0x1.022000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000400), 0x1.0220000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffffbff), -0x1.022000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001022000000800), 0x1.0220000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffff7ff), -0x1.022000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001022000002000), 0x1.022000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfffffdfff), -0x1.022000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001022000008000), 0x1.022000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfffff7fff), -0x1.022000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001022000040000), 0x1.02200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefddffffbffff), -0x1.022000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001022000200000), 0x1.0220002p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfffdfffff), -0x1.022000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001022000800000), 0x1.0220008p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfff7fffff), -0x1.022000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001022008000000), 0x1.022008p+48, 0x0p+0 },
+{ INT64_C(0xfffefddff7ffffff), -0x1.022008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001022040000000), 0x1.02204p+48, 0x0p+0 },
+{ INT64_C(0xfffefddfbfffffff), -0x1.022040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001022400000000), 0x1.0224p+48, 0x0p+0 },
+{ INT64_C(0xfffefddbffffffff), -0x1.022400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001022800000000), 0x1.0228p+48, 0x0p+0 },
+{ INT64_C(0xfffefdd7ffffffff), -0x1.022800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001028000000000), 0x1.028p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7fffffffff), -0x1.028000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001028000000008), 0x1.028000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7ffffffff7), -0x1.028000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001028000000080), 0x1.02800000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7fffffff7f), -0x1.028000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001028000000800), 0x1.0280000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7ffffff7ff), -0x1.028000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001028000004000), 0x1.028000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7fffffbfff), -0x1.028000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001028000020000), 0x1.02800002p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7ffffdffff), -0x1.028000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001028000080000), 0x1.02800008p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7ffff7ffff), -0x1.028000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001028000800000), 0x1.0280008p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7fff7fffff), -0x1.028000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001028002000000), 0x1.028002p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7ffdffffff), -0x1.028002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001028010000000), 0x1.02801p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7fefffffff), -0x1.028010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001028080000000), 0x1.02808p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7f7fffffff), -0x1.028080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001028200000000), 0x1.0282p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7dffffffff), -0x1.028200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001028400000000), 0x1.0284p+48, 0x0p+0 },
+{ INT64_C(0xfffefd7bffffffff), -0x1.028400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001029000000000), 0x1.029p+48, 0x0p+0 },
+{ INT64_C(0xfffefd6fffffffff), -0x1.029000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000001), 0x1.040000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffffe), -0x1.040000000002p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000008), 0x1.040000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffff7), -0x1.040000000009p+48, 0x0p+0 },
+{ INT64_C(0x000104000000000a), 0x1.04000000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffff5), -0x1.04000000000bp+48, 0x0p+0 },
+{ INT64_C(0x000104000000000c), 0x1.04000000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffff3), -0x1.04000000000dp+48, 0x0p+0 },
+{ INT64_C(0x0001040000000040), 0x1.04000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffffffbf), -0x1.040000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000044), 0x1.040000000044p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffffffbb), -0x1.040000000045p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000200), 0x1.0400000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffdff), -0x1.040000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000208), 0x1.040000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffdf7), -0x1.040000000209p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000280), 0x1.04000000028p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffffd7f), -0x1.040000000281p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000800), 0x1.0400000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffff7ff), -0x1.040000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000808), 0x1.040000000808p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffff7f7), -0x1.040000000809p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000810), 0x1.04000000081p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffff7ef), -0x1.040000000811p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000820), 0x1.04000000082p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffff7df), -0x1.040000000821p+48, 0x0p+0 },
+{ INT64_C(0x0001040000000900), 0x1.0400000009p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffff6ff), -0x1.040000000901p+48, 0x0p+0 },
+{ INT64_C(0x0001040000008000), 0x1.040000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff7fff), -0x1.040000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000008008), 0x1.040000008008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff7ff7), -0x1.040000008009p+48, 0x0p+0 },
+{ INT64_C(0x0001040000008010), 0x1.04000000801p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff7fef), -0x1.040000008011p+48, 0x0p+0 },
+{ INT64_C(0x0001040000008100), 0x1.0400000081p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff7eff), -0x1.040000008101p+48, 0x0p+0 },
+{ INT64_C(0x0001040000008200), 0x1.0400000082p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff7dff), -0x1.040000008201p+48, 0x0p+0 },
+{ INT64_C(0x0001040000009000), 0x1.040000009p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff6fff), -0x1.040000009001p+48, 0x0p+0 },
+{ INT64_C(0x000104000000a000), 0x1.04000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff5fff), -0x1.04000000a001p+48, 0x0p+0 },
+{ INT64_C(0x000104000000c000), 0x1.04000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffff3fff), -0x1.04000000c001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000040000), 0x1.04000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffbffff), -0x1.040000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000040004), 0x1.040000040004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffbfffb), -0x1.040000040005p+48, 0x0p+0 },
+{ INT64_C(0x0001040000040008), 0x1.040000040008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffbfff7), -0x1.040000040009p+48, 0x0p+0 },
+{ INT64_C(0x0001040000040040), 0x1.04000004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffbffbf), -0x1.040000040041p+48, 0x0p+0 },
+{ INT64_C(0x0001040000040100), 0x1.0400000401p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffbfeff), -0x1.040000040101p+48, 0x0p+0 },
+{ INT64_C(0x0001040000040800), 0x1.0400000408p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffbf7ff), -0x1.040000040801p+48, 0x0p+0 },
+{ INT64_C(0x0001040000048000), 0x1.040000048p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffffb7fff), -0x1.040000048001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000060000), 0x1.04000006p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff9ffff), -0x1.040000060001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080000), 0x1.04000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7ffff), -0x1.040000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080002), 0x1.040000080002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7fffd), -0x1.040000080003p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080004), 0x1.040000080004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7fffb), -0x1.040000080005p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080008), 0x1.040000080008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7fff7), -0x1.040000080009p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080020), 0x1.04000008002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7ffdf), -0x1.040000080021p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080100), 0x1.0400000801p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7feff), -0x1.040000080101p+48, 0x0p+0 },
+{ INT64_C(0x0001040000080800), 0x1.0400000808p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7f7ff), -0x1.040000080801p+48, 0x0p+0 },
+{ INT64_C(0x0001040000081000), 0x1.040000081p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7efff), -0x1.040000081001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000082000), 0x1.040000082p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff7dfff), -0x1.040000082001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000088000), 0x1.040000088p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff77fff), -0x1.040000088001p+48, 0x0p+0 },
+{ INT64_C(0x00010400000c0000), 0x1.0400000cp+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffff3ffff), -0x1.0400000c0001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000400000), 0x1.0400004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbfffff), -0x1.040000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000400008), 0x1.040000400008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbffff7), -0x1.040000400009p+48, 0x0p+0 },
+{ INT64_C(0x0001040000400010), 0x1.04000040001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbfffef), -0x1.040000400011p+48, 0x0p+0 },
+{ INT64_C(0x0001040000400100), 0x1.0400004001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbffeff), -0x1.040000400101p+48, 0x0p+0 },
+{ INT64_C(0x0001040000400400), 0x1.0400004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbffbff), -0x1.040000400401p+48, 0x0p+0 },
+{ INT64_C(0x0001040000402000), 0x1.040000402p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbfdfff), -0x1.040000402001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000420000), 0x1.04000042p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffffbdffff), -0x1.040000420001p+48, 0x0p+0 },
+{ INT64_C(0x0001040000600000), 0x1.0400006p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffff9fffff), -0x1.040000600001p+48, 0x0p+0 },
+{ INT64_C(0x0001040004000000), 0x1.040004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbffffff), -0x1.040004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040004000002), 0x1.040004000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbfffffd), -0x1.040004000003p+48, 0x0p+0 },
+{ INT64_C(0x0001040004000020), 0x1.04000400002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbffffdf), -0x1.040004000021p+48, 0x0p+0 },
+{ INT64_C(0x0001040004000080), 0x1.04000400008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbffff7f), -0x1.040004000081p+48, 0x0p+0 },
+{ INT64_C(0x0001040004000800), 0x1.0400040008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbfff7ff), -0x1.040004000801p+48, 0x0p+0 },
+{ INT64_C(0x0001040004004000), 0x1.040004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbffbfff), -0x1.040004004001p+48, 0x0p+0 },
+{ INT64_C(0x0001040004040000), 0x1.04000404p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbfbffff), -0x1.040004040001p+48, 0x0p+0 },
+{ INT64_C(0x0001040004100000), 0x1.0400041p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbefffff), -0x1.040004100001p+48, 0x0p+0 },
+{ INT64_C(0x0001040004200000), 0x1.0400042p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffbdfffff), -0x1.040004200001p+48, 0x0p+0 },
+{ INT64_C(0x0001040004800000), 0x1.0400048p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfffb7fffff), -0x1.040004800001p+48, 0x0p+0 },
+{ INT64_C(0x0001040006000000), 0x1.040006p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfff9ffffff), -0x1.040006000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040020000000), 0x1.04002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdfffffff), -0x1.040020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040020000001), 0x1.040020000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdffffffe), -0x1.040020000002p+48, 0x0p+0 },
+{ INT64_C(0x0001040020000008), 0x1.040020000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdffffff7), -0x1.040020000009p+48, 0x0p+0 },
+{ INT64_C(0x0001040020000080), 0x1.04002000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdfffff7f), -0x1.040020000081p+48, 0x0p+0 },
+{ INT64_C(0x0001040020000400), 0x1.0400200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdffffbff), -0x1.040020000401p+48, 0x0p+0 },
+{ INT64_C(0x0001040020002000), 0x1.040020002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdfffdfff), -0x1.040020002001p+48, 0x0p+0 },
+{ INT64_C(0x0001040020004000), 0x1.040020004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdfffbfff), -0x1.040020004001p+48, 0x0p+0 },
+{ INT64_C(0x0001040020040000), 0x1.04002004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdffbffff), -0x1.040020040001p+48, 0x0p+0 },
+{ INT64_C(0x0001040020400000), 0x1.0400204p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdfbfffff), -0x1.040020400001p+48, 0x0p+0 },
+{ INT64_C(0x0001040020800000), 0x1.0400208p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffdf7fffff), -0x1.040020800001p+48, 0x0p+0 },
+{ INT64_C(0x0001040028000000), 0x1.040028p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffd7ffffff), -0x1.040028000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040030000000), 0x1.04003p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffcfffffff), -0x1.040030000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040040000000), 0x1.04004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbfffffff), -0x1.040040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040040000004), 0x1.040040000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbffffffb), -0x1.040040000005p+48, 0x0p+0 },
+{ INT64_C(0x0001040040000040), 0x1.04004000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbfffffbf), -0x1.040040000041p+48, 0x0p+0 },
+{ INT64_C(0x0001040040000200), 0x1.0400400002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbffffdff), -0x1.040040000201p+48, 0x0p+0 },
+{ INT64_C(0x0001040040000800), 0x1.0400400008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbffff7ff), -0x1.040040000801p+48, 0x0p+0 },
+{ INT64_C(0x0001040040002000), 0x1.040040002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbfffdfff), -0x1.040040002001p+48, 0x0p+0 },
+{ INT64_C(0x0001040040020000), 0x1.04004002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbffdffff), -0x1.040040020001p+48, 0x0p+0 },
+{ INT64_C(0x0001040040040000), 0x1.04004004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbffbffff), -0x1.040040040001p+48, 0x0p+0 },
+{ INT64_C(0x0001040040200000), 0x1.0400402p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbfdfffff), -0x1.040040200001p+48, 0x0p+0 },
+{ INT64_C(0x0001040041000000), 0x1.040041p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffbeffffff), -0x1.040041000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040048000000), 0x1.040048p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffb7ffffff), -0x1.040048000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040050000000), 0x1.04005p+48, 0x0p+0 },
+{ INT64_C(0xfffefbffafffffff), -0x1.040050000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040400000000), 0x1.0404p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbffffffff), -0x1.040400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040400000008), 0x1.040400000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbfffffff7), -0x1.040400000009p+48, 0x0p+0 },
+{ INT64_C(0x0001040400000040), 0x1.04040000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbffffffbf), -0x1.040400000041p+48, 0x0p+0 },
+{ INT64_C(0x0001040400000080), 0x1.04040000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbffffff7f), -0x1.040400000081p+48, 0x0p+0 },
+{ INT64_C(0x0001040400000200), 0x1.0404000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbfffffdff), -0x1.040400000201p+48, 0x0p+0 },
+{ INT64_C(0x0001040400002000), 0x1.040400002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbffffdfff), -0x1.040400002001p+48, 0x0p+0 },
+{ INT64_C(0x0001040400004000), 0x1.040400004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbffffbfff), -0x1.040400004001p+48, 0x0p+0 },
+{ INT64_C(0x0001040400020000), 0x1.04040002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbfffdffff), -0x1.040400020001p+48, 0x0p+0 },
+{ INT64_C(0x0001040400040000), 0x1.04040004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbfffbffff), -0x1.040400040001p+48, 0x0p+0 },
+{ INT64_C(0x0001040400400000), 0x1.0404004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbffbfffff), -0x1.040400400001p+48, 0x0p+0 },
+{ INT64_C(0x0001040404000000), 0x1.040404p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbfbffffff), -0x1.040404000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040410000000), 0x1.04041p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbefffffff), -0x1.040410000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040440000000), 0x1.04044p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfbbfffffff), -0x1.040440000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040500000000), 0x1.0405p+48, 0x0p+0 },
+{ INT64_C(0xfffefbfaffffffff), -0x1.040500000001p+48, 0x0p+0 },
+{ INT64_C(0x0001040600000000), 0x1.0406p+48, 0x0p+0 },
+{ INT64_C(0xfffefbf9ffffffff), -0x1.040600000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041000000000), 0x1.041p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefffffffff), -0x1.041000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041000000008), 0x1.041000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeffffffff7), -0x1.041000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001041000000080), 0x1.04100000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefffffff7f), -0x1.041000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001041000000800), 0x1.0410000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeffffff7ff), -0x1.041000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001041000001000), 0x1.041000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefffffefff), -0x1.041000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001041000002000), 0x1.041000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefffffdfff), -0x1.041000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001041000004000), 0x1.041000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefffffbfff), -0x1.041000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001041000040000), 0x1.04100004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeffffbffff), -0x1.041000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001041000400000), 0x1.0410004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefffbfffff), -0x1.041000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001041001000000), 0x1.041001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeffeffffff), -0x1.041001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041002000000), 0x1.041002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeffdffffff), -0x1.041002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041004000000), 0x1.041004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeffbffffff), -0x1.041004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041010000000), 0x1.04101p+48, 0x0p+0 },
+{ INT64_C(0xfffefbefefffffff), -0x1.041010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041080000000), 0x1.04108p+48, 0x0p+0 },
+{ INT64_C(0xfffefbef7fffffff), -0x1.041080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041100000000), 0x1.0411p+48, 0x0p+0 },
+{ INT64_C(0xfffefbeeffffffff), -0x1.041100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001041200000000), 0x1.0412p+48, 0x0p+0 },
+{ INT64_C(0xfffefbedffffffff), -0x1.041200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001042000000000), 0x1.042p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdfffffffff), -0x1.042000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001042000000008), 0x1.042000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffffffff7), -0x1.042000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001042000000020), 0x1.04200000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdfffffffdf), -0x1.042000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001042000000200), 0x1.0420000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffffffdff), -0x1.042000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001042000000400), 0x1.0420000004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffffffbff), -0x1.042000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001042000000800), 0x1.0420000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffffff7ff), -0x1.042000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001042000002000), 0x1.042000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdfffffdfff), -0x1.042000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001042000020000), 0x1.04200002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffffdffff), -0x1.042000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001042000040000), 0x1.04200004p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffffbffff), -0x1.042000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001042000200000), 0x1.0420002p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdfffdfffff), -0x1.042000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001042001000000), 0x1.042001p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdffeffffff), -0x1.042001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001042008000000), 0x1.042008p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdff7ffffff), -0x1.042008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001042080000000), 0x1.04208p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdf7fffffff), -0x1.042080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001042100000000), 0x1.0421p+48, 0x0p+0 },
+{ INT64_C(0xfffefbdeffffffff), -0x1.042100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001042800000000), 0x1.0428p+48, 0x0p+0 },
+{ INT64_C(0xfffefbd7ffffffff), -0x1.042800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000000000), 0x1.05p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffffffff), -0x1.050000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000000008), 0x1.050000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefafffffffff7), -0x1.050000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001050000000080), 0x1.05000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffffff7f), -0x1.050000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001050000000100), 0x1.0500000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefafffffffeff), -0x1.050000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001050000000800), 0x1.0500000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefafffffff7ff), -0x1.050000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001050000001000), 0x1.050000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffffefff), -0x1.050000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000002000), 0x1.050000002p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffffdfff), -0x1.050000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000008000), 0x1.050000008p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffff7fff), -0x1.050000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000010000), 0x1.05000001p+48, 0x0p+0 },
+{ INT64_C(0xfffefafffffeffff), -0x1.050000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000100000), 0x1.0500001p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffefffff), -0x1.050000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001050000400000), 0x1.0500004p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffffbfffff), -0x1.050000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001050001000000), 0x1.050001p+48, 0x0p+0 },
+{ INT64_C(0xfffefafffeffffff), -0x1.050001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001050010000000), 0x1.05001p+48, 0x0p+0 },
+{ INT64_C(0xfffefaffefffffff), -0x1.050010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001050100000000), 0x1.0501p+48, 0x0p+0 },
+{ INT64_C(0xfffefafeffffffff), -0x1.050100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001051000000000), 0x1.051p+48, 0x0p+0 },
+{ INT64_C(0xfffefaefffffffff), -0x1.051000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001058000000000), 0x1.058p+48, 0x0p+0 },
+{ INT64_C(0xfffefa7fffffffff), -0x1.058000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001060000000000), 0x1.06p+48, 0x0p+0 },
+{ INT64_C(0xfffef9ffffffffff), -0x1.060000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001060000000004), 0x1.060000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fffffffffb), -0x1.060000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001060000000010), 0x1.06000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffef9ffffffffef), -0x1.060000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001060000000080), 0x1.06000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffef9ffffffff7f), -0x1.060000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001060000000200), 0x1.0600000002p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fffffffdff), -0x1.060000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001060000001000), 0x1.060000001p+48, 0x0p+0 },
+{ INT64_C(0xfffef9ffffffefff), -0x1.060000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001060000010000), 0x1.06000001p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fffffeffff), -0x1.060000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001060000020000), 0x1.06000002p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fffffdffff), -0x1.060000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001060000200000), 0x1.0600002p+48, 0x0p+0 },
+{ INT64_C(0xfffef9ffffdfffff), -0x1.060000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001060001000000), 0x1.060001p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fffeffffff), -0x1.060001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001060004000000), 0x1.060004p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fffbffffff), -0x1.060004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001060008000000), 0x1.060008p+48, 0x0p+0 },
+{ INT64_C(0xfffef9fff7ffffff), -0x1.060008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001060020000000), 0x1.06002p+48, 0x0p+0 },
+{ INT64_C(0xfffef9ffdfffffff), -0x1.060020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001060100000000), 0x1.0601p+48, 0x0p+0 },
+{ INT64_C(0xfffef9feffffffff), -0x1.060100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001061000000000), 0x1.061p+48, 0x0p+0 },
+{ INT64_C(0xfffef9efffffffff), -0x1.061000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001062000000000), 0x1.062p+48, 0x0p+0 },
+{ INT64_C(0xfffef9dfffffffff), -0x1.062000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000001), 0x1.200000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffffffe), -0x1.200000000002p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000010), 0x1.20000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffffef), -0x1.200000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000014), 0x1.200000000014p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffffeb), -0x1.200000000015p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000080), 0x1.20000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffff7f), -0x1.200000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000088), 0x1.200000000088p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffff77), -0x1.200000000089p+48, 0x0p+0 },
+{ INT64_C(0x00012000000000c0), 0x1.2000000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffff3f), -0x1.2000000000c1p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000200), 0x1.2000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffffdff), -0x1.200000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000201), 0x1.200000000201p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffffdfe), -0x1.200000000202p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000208), 0x1.200000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffffdf7), -0x1.200000000209p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000280), 0x1.20000000028p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffffd7f), -0x1.200000000281p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000800), 0x1.2000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffff7ff), -0x1.200000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000801), 0x1.200000000801p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffff7fe), -0x1.200000000802p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000808), 0x1.200000000808p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffff7f7), -0x1.200000000809p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000880), 0x1.20000000088p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffff77f), -0x1.200000000881p+48, 0x0p+0 },
+{ INT64_C(0x0001200000000a00), 0x1.200000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffff5ff), -0x1.200000000a01p+48, 0x0p+0 },
+{ INT64_C(0x0001200000004000), 0x1.200000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffbfff), -0x1.200000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000004002), 0x1.200000004002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffbffd), -0x1.200000004003p+48, 0x0p+0 },
+{ INT64_C(0x0001200000004010), 0x1.20000000401p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffbfef), -0x1.200000004011p+48, 0x0p+0 },
+{ INT64_C(0x0001200000004080), 0x1.20000000408p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffbf7f), -0x1.200000004081p+48, 0x0p+0 },
+{ INT64_C(0x0001200000004400), 0x1.2000000044p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffffbbff), -0x1.200000004401p+48, 0x0p+0 },
+{ INT64_C(0x0001200000020000), 0x1.20000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdffff), -0x1.200000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000020004), 0x1.200000020004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdfffb), -0x1.200000020005p+48, 0x0p+0 },
+{ INT64_C(0x0001200000020008), 0x1.200000020008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdfff7), -0x1.200000020009p+48, 0x0p+0 },
+{ INT64_C(0x0001200000020080), 0x1.20000002008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdff7f), -0x1.200000020081p+48, 0x0p+0 },
+{ INT64_C(0x0001200000020100), 0x1.2000000201p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdfeff), -0x1.200000020101p+48, 0x0p+0 },
+{ INT64_C(0x0001200000020800), 0x1.2000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdf7ff), -0x1.200000020801p+48, 0x0p+0 },
+{ INT64_C(0x0001200000021000), 0x1.200000021p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffdefff), -0x1.200000021001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000022000), 0x1.200000022p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffddfff), -0x1.200000022001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000028000), 0x1.200000028p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffffd7fff), -0x1.200000028001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000080000), 0x1.20000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff7ffff), -0x1.200000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000080002), 0x1.200000080002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff7fffd), -0x1.200000080003p+48, 0x0p+0 },
+{ INT64_C(0x0001200000080020), 0x1.20000008002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff7ffdf), -0x1.200000080021p+48, 0x0p+0 },
+{ INT64_C(0x0001200000080080), 0x1.20000008008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff7ff7f), -0x1.200000080081p+48, 0x0p+0 },
+{ INT64_C(0x0001200000080800), 0x1.2000000808p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff7f7ff), -0x1.200000080801p+48, 0x0p+0 },
+{ INT64_C(0x0001200000084000), 0x1.200000084p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff7bfff), -0x1.200000084001p+48, 0x0p+0 },
+{ INT64_C(0x00012000000c0000), 0x1.2000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffedffffff3ffff), -0x1.2000000c0001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000200000), 0x1.2000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdfffff), -0x1.200000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000200004), 0x1.200000200004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdffffb), -0x1.200000200005p+48, 0x0p+0 },
+{ INT64_C(0x0001200000200010), 0x1.20000020001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdfffef), -0x1.200000200011p+48, 0x0p+0 },
+{ INT64_C(0x0001200000200080), 0x1.20000020008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdfff7f), -0x1.200000200081p+48, 0x0p+0 },
+{ INT64_C(0x0001200000200400), 0x1.2000002004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdffbff), -0x1.200000200401p+48, 0x0p+0 },
+{ INT64_C(0x0001200000204000), 0x1.200000204p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdfbfff), -0x1.200000204001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000210000), 0x1.20000021p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdeffff), -0x1.200000210001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000240000), 0x1.20000024p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffdbffff), -0x1.200000240001p+48, 0x0p+0 },
+{ INT64_C(0x0001200000300000), 0x1.2000003p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffffcfffff), -0x1.200000300001p+48, 0x0p+0 },
+{ INT64_C(0x0001200001000000), 0x1.200001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffeffffff), -0x1.200001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200001000001), 0x1.200001000001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffefffffe), -0x1.200001000002p+48, 0x0p+0 },
+{ INT64_C(0x0001200001000004), 0x1.200001000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffefffffb), -0x1.200001000005p+48, 0x0p+0 },
+{ INT64_C(0x0001200001000040), 0x1.20000100004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffeffffbf), -0x1.200001000041p+48, 0x0p+0 },
+{ INT64_C(0x0001200001000080), 0x1.20000100008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffeffff7f), -0x1.200001000081p+48, 0x0p+0 },
+{ INT64_C(0x0001200001000800), 0x1.2000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffefff7ff), -0x1.200001000801p+48, 0x0p+0 },
+{ INT64_C(0x0001200001001000), 0x1.200001001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffeffefff), -0x1.200001001001p+48, 0x0p+0 },
+{ INT64_C(0x0001200001010000), 0x1.20000101p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffefeffff), -0x1.200001010001p+48, 0x0p+0 },
+{ INT64_C(0x0001200001040000), 0x1.20000104p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffefbffff), -0x1.200001040001p+48, 0x0p+0 },
+{ INT64_C(0x0001200001200000), 0x1.2000012p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffedfffff), -0x1.200001200001p+48, 0x0p+0 },
+{ INT64_C(0x0001200001800000), 0x1.2000018p+48, 0x0p+0 },
+{ INT64_C(0xfffedffffe7fffff), -0x1.200001800001p+48, 0x0p+0 },
+{ INT64_C(0x0001200008000000), 0x1.200008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7ffffff), -0x1.200008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200008000004), 0x1.200008000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7fffffb), -0x1.200008000005p+48, 0x0p+0 },
+{ INT64_C(0x0001200008000040), 0x1.20000800004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7ffffbf), -0x1.200008000041p+48, 0x0p+0 },
+{ INT64_C(0x0001200008000080), 0x1.20000800008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7ffff7f), -0x1.200008000081p+48, 0x0p+0 },
+{ INT64_C(0x0001200008000200), 0x1.2000080002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7fffdff), -0x1.200008000201p+48, 0x0p+0 },
+{ INT64_C(0x0001200008001000), 0x1.200008001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7ffefff), -0x1.200008001001p+48, 0x0p+0 },
+{ INT64_C(0x0001200008008000), 0x1.200008008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7ff7fff), -0x1.200008008001p+48, 0x0p+0 },
+{ INT64_C(0x0001200008010000), 0x1.20000801p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7feffff), -0x1.200008010001p+48, 0x0p+0 },
+{ INT64_C(0x0001200008020000), 0x1.20000802p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7fdffff), -0x1.200008020001p+48, 0x0p+0 },
+{ INT64_C(0x0001200008200000), 0x1.2000082p+48, 0x0p+0 },
+{ INT64_C(0xfffedffff7dfffff), -0x1.200008200001p+48, 0x0p+0 },
+{ INT64_C(0x000120000a000000), 0x1.20000ap+48, 0x0p+0 },
+{ INT64_C(0xfffedffff5ffffff), -0x1.20000a000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000000), 0x1.20001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffefffffff), -0x1.200010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000002), 0x1.200010000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeffffffd), -0x1.200010000003p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000004), 0x1.200010000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeffffffb), -0x1.200010000005p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000008), 0x1.200010000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeffffff7), -0x1.200010000009p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000080), 0x1.20001000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffefffff7f), -0x1.200010000081p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000100), 0x1.2000100001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeffffeff), -0x1.200010000101p+48, 0x0p+0 },
+{ INT64_C(0x0001200010000400), 0x1.2000100004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeffffbff), -0x1.200010000401p+48, 0x0p+0 },
+{ INT64_C(0x0001200010001000), 0x1.200010001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffefffefff), -0x1.200010001001p+48, 0x0p+0 },
+{ INT64_C(0x0001200010004000), 0x1.200010004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffefffbfff), -0x1.200010004001p+48, 0x0p+0 },
+{ INT64_C(0x0001200010040000), 0x1.20001004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeffbffff), -0x1.200010040001p+48, 0x0p+0 },
+{ INT64_C(0x0001200010400000), 0x1.2000104p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffefbfffff), -0x1.200010400001p+48, 0x0p+0 },
+{ INT64_C(0x0001200011000000), 0x1.200011p+48, 0x0p+0 },
+{ INT64_C(0xfffedfffeeffffff), -0x1.200011000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200080000000), 0x1.20008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7fffffff), -0x1.200080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200080000002), 0x1.200080000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7ffffffd), -0x1.200080000003p+48, 0x0p+0 },
+{ INT64_C(0x0001200080000020), 0x1.20008000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7fffffdf), -0x1.200080000021p+48, 0x0p+0 },
+{ INT64_C(0x0001200080000200), 0x1.2000800002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7ffffdff), -0x1.200080000201p+48, 0x0p+0 },
+{ INT64_C(0x0001200080001000), 0x1.200080001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7fffefff), -0x1.200080001001p+48, 0x0p+0 },
+{ INT64_C(0x0001200080010000), 0x1.20008001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7ffeffff), -0x1.200080010001p+48, 0x0p+0 },
+{ INT64_C(0x0001200080020000), 0x1.20008002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7ffdffff), -0x1.200080020001p+48, 0x0p+0 },
+{ INT64_C(0x0001200080100000), 0x1.2000801p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7fefffff), -0x1.200080100001p+48, 0x0p+0 },
+{ INT64_C(0x0001200080200000), 0x1.2000802p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7fdfffff), -0x1.200080200001p+48, 0x0p+0 },
+{ INT64_C(0x0001200082000000), 0x1.200082p+48, 0x0p+0 },
+{ INT64_C(0xfffedfff7dffffff), -0x1.200082000001p+48, 0x0p+0 },
+{ INT64_C(0x00012000a0000000), 0x1.2000ap+48, 0x0p+0 },
+{ INT64_C(0xfffedfff5fffffff), -0x1.2000a0000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200100000000), 0x1.2001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffeffffffff), -0x1.200100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200100000008), 0x1.200100000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffefffffff7), -0x1.200100000009p+48, 0x0p+0 },
+{ INT64_C(0x0001200100000040), 0x1.20010000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffeffffffbf), -0x1.200100000041p+48, 0x0p+0 },
+{ INT64_C(0x0001200100000200), 0x1.2001000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffefffffdff), -0x1.200100000201p+48, 0x0p+0 },
+{ INT64_C(0x0001200100002000), 0x1.200100002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffeffffdfff), -0x1.200100002001p+48, 0x0p+0 },
+{ INT64_C(0x0001200100010000), 0x1.20010001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffefffeffff), -0x1.200100010001p+48, 0x0p+0 },
+{ INT64_C(0x0001200100100000), 0x1.2001001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffeffefffff), -0x1.200100100001p+48, 0x0p+0 },
+{ INT64_C(0x0001200100800000), 0x1.2001008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffeff7fffff), -0x1.200100800001p+48, 0x0p+0 },
+{ INT64_C(0x0001200104000000), 0x1.200104p+48, 0x0p+0 },
+{ INT64_C(0xfffedffefbffffff), -0x1.200104000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200120000000), 0x1.20012p+48, 0x0p+0 },
+{ INT64_C(0xfffedffedfffffff), -0x1.200120000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200000000), 0x1.2002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffffffff), -0x1.200200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200000002), 0x1.200200000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfffffffd), -0x1.200200000003p+48, 0x0p+0 },
+{ INT64_C(0x0001200200000008), 0x1.200200000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfffffff7), -0x1.200200000009p+48, 0x0p+0 },
+{ INT64_C(0x0001200200000040), 0x1.20020000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffffffbf), -0x1.200200000041p+48, 0x0p+0 },
+{ INT64_C(0x0001200200000080), 0x1.20020000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffffff7f), -0x1.200200000081p+48, 0x0p+0 },
+{ INT64_C(0x0001200200000400), 0x1.2002000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfffffbff), -0x1.200200000401p+48, 0x0p+0 },
+{ INT64_C(0x0001200200002000), 0x1.200200002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffffdfff), -0x1.200200002001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200004000), 0x1.200200004p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffffbfff), -0x1.200200004001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200008000), 0x1.200200008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffff7fff), -0x1.200200008001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200020000), 0x1.20020002p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfffdffff), -0x1.200200020001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200100000), 0x1.2002001p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdffefffff), -0x1.200200100001p+48, 0x0p+0 },
+{ INT64_C(0x0001200200800000), 0x1.2002008p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdff7fffff), -0x1.200200800001p+48, 0x0p+0 },
+{ INT64_C(0x0001200201000000), 0x1.200201p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfeffffff), -0x1.200201000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200202000000), 0x1.200202p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfdffffff), -0x1.200202000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200204000000), 0x1.200204p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdfbffffff), -0x1.200204000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200240000000), 0x1.20024p+48, 0x0p+0 },
+{ INT64_C(0xfffedffdbfffffff), -0x1.200240000001p+48, 0x0p+0 },
+{ INT64_C(0x0001200300000000), 0x1.2003p+48, 0x0p+0 },
+{ INT64_C(0xfffedffcffffffff), -0x1.200300000001p+48, 0x0p+0 },
+{ INT64_C(0x0001202000000000), 0x1.202p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfffffffff), -0x1.202000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001202000000002), 0x1.202000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdffffffffd), -0x1.202000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001202000000010), 0x1.20200000001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfffffffef), -0x1.202000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001202000000080), 0x1.20200000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfffffff7f), -0x1.202000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001202000000800), 0x1.2020000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdffffff7ff), -0x1.202000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001202000008000), 0x1.202000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfffff7fff), -0x1.202000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001202000080000), 0x1.20200008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdffff7ffff), -0x1.202000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001202000400000), 0x1.2020004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfffbfffff), -0x1.202000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001202001000000), 0x1.202001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdffeffffff), -0x1.202001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001202010000000), 0x1.20201p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfefffffff), -0x1.202010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001202040000000), 0x1.20204p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdfbfffffff), -0x1.202040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001202200000000), 0x1.2022p+48, 0x0p+0 },
+{ INT64_C(0xfffedfddffffffff), -0x1.202200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001202400000000), 0x1.2024p+48, 0x0p+0 },
+{ INT64_C(0xfffedfdbffffffff), -0x1.202400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000000000), 0x1.204p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfffffffff), -0x1.204000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000000004), 0x1.204000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbffffffffb), -0x1.204000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001204000000020), 0x1.20400000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfffffffdf), -0x1.204000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001204000000200), 0x1.2040000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbffffffdff), -0x1.204000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001204000001000), 0x1.204000001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfffffefff), -0x1.204000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000002000), 0x1.204000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfffffdfff), -0x1.204000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000004000), 0x1.204000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfffffbfff), -0x1.204000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000010000), 0x1.20400001p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbffffeffff), -0x1.204000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000080000), 0x1.20400008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbffff7ffff), -0x1.204000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001204000800000), 0x1.2040008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfff7fffff), -0x1.204000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001204008000000), 0x1.204008p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbff7ffffff), -0x1.204008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001204040000000), 0x1.20404p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbfbfffffff), -0x1.204040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001204080000000), 0x1.20408p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbf7fffffff), -0x1.204080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001204100000000), 0x1.2041p+48, 0x0p+0 },
+{ INT64_C(0xfffedfbeffffffff), -0x1.204100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001205000000000), 0x1.205p+48, 0x0p+0 },
+{ INT64_C(0xfffedfafffffffff), -0x1.205000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001206000000000), 0x1.206p+48, 0x0p+0 },
+{ INT64_C(0xfffedf9fffffffff), -0x1.206000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001220000000000), 0x1.22p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffffffffff), -0x1.220000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001220000000004), 0x1.220000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfffffffffb), -0x1.220000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001220000000020), 0x1.22000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffffffffdf), -0x1.220000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001220000000040), 0x1.22000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffffffffbf), -0x1.220000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001220000000400), 0x1.2200000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfffffffbff), -0x1.220000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001220000002000), 0x1.220000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffffffdfff), -0x1.220000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001220000008000), 0x1.220000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffffff7fff), -0x1.220000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001220000020000), 0x1.22000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfffffdffff), -0x1.220000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001220000080000), 0x1.22000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfffff7ffff), -0x1.220000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001220000100000), 0x1.2200001p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffffefffff), -0x1.220000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001220001000000), 0x1.220001p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfffeffffff), -0x1.220001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001220008000000), 0x1.220008p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfff7ffffff), -0x1.220008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001220020000000), 0x1.22002p+48, 0x0p+0 },
+{ INT64_C(0xfffeddffdfffffff), -0x1.220020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001220100000000), 0x1.2201p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfeffffffff), -0x1.220100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001220200000000), 0x1.2202p+48, 0x0p+0 },
+{ INT64_C(0xfffeddfdffffffff), -0x1.220200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001222000000000), 0x1.222p+48, 0x0p+0 },
+{ INT64_C(0xfffedddfffffffff), -0x1.222000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001224000000000), 0x1.224p+48, 0x0p+0 },
+{ INT64_C(0xfffeddbfffffffff), -0x1.224000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001240000000000), 0x1.24p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffffffffff), -0x1.240000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001240000000008), 0x1.240000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedbfffffffff7), -0x1.240000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001240000000040), 0x1.24000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffffffffbf), -0x1.240000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001240000000200), 0x1.2400000002p+48, 0x0p+0 },
+{ INT64_C(0xfffedbfffffffdff), -0x1.240000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001240000001000), 0x1.240000001p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffffffefff), -0x1.240000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001240000008000), 0x1.240000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffffff7fff), -0x1.240000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001240000080000), 0x1.24000008p+48, 0x0p+0 },
+{ INT64_C(0xfffedbfffff7ffff), -0x1.240000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001240000200000), 0x1.2400002p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffffdfffff), -0x1.240000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001240002000000), 0x1.240002p+48, 0x0p+0 },
+{ INT64_C(0xfffedbfffdffffff), -0x1.240002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001240020000000), 0x1.24002p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffdfffffff), -0x1.240020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001240040000000), 0x1.24004p+48, 0x0p+0 },
+{ INT64_C(0xfffedbffbfffffff), -0x1.240040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001240400000000), 0x1.2404p+48, 0x0p+0 },
+{ INT64_C(0xfffedbfbffffffff), -0x1.240400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001244000000000), 0x1.244p+48, 0x0p+0 },
+{ INT64_C(0xfffedbbfffffffff), -0x1.244000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001248000000000), 0x1.248p+48, 0x0p+0 },
+{ INT64_C(0xfffedb7fffffffff), -0x1.248000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000004), 0x1.400000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffffffb), -0x1.400000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000008), 0x1.400000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffffff7), -0x1.400000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000009), 0x1.400000000009p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffffff6), -0x1.40000000000ap+48, 0x0p+0 },
+{ INT64_C(0x0001400000000040), 0x1.40000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffffbf), -0x1.400000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000048), 0x1.400000000048p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffffb7), -0x1.400000000049p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000050), 0x1.40000000005p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffffaf), -0x1.400000000051p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000080), 0x1.40000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffff7f), -0x1.400000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000088), 0x1.400000000088p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffff77), -0x1.400000000089p+48, 0x0p+0 },
+{ INT64_C(0x00014000000000c0), 0x1.4000000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffff3f), -0x1.4000000000c1p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000800), 0x1.4000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff7ff), -0x1.400000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000801), 0x1.400000000801p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff7fe), -0x1.400000000802p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000802), 0x1.400000000802p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff7fd), -0x1.400000000803p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000804), 0x1.400000000804p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff7fb), -0x1.400000000805p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000808), 0x1.400000000808p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff7f7), -0x1.400000000809p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000840), 0x1.40000000084p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff7bf), -0x1.400000000841p+48, 0x0p+0 },
+{ INT64_C(0x0001400000000c00), 0x1.400000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffff3ff), -0x1.400000000c01p+48, 0x0p+0 },
+{ INT64_C(0x0001400000002000), 0x1.400000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffdfff), -0x1.400000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000002002), 0x1.400000002002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffdffd), -0x1.400000002003p+48, 0x0p+0 },
+{ INT64_C(0x0001400000002004), 0x1.400000002004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffdffb), -0x1.400000002005p+48, 0x0p+0 },
+{ INT64_C(0x0001400000002010), 0x1.40000000201p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffdfef), -0x1.400000002011p+48, 0x0p+0 },
+{ INT64_C(0x0001400000002080), 0x1.40000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffdf7f), -0x1.400000002081p+48, 0x0p+0 },
+{ INT64_C(0x0001400000002200), 0x1.4000000022p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffffddff), -0x1.400000002201p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020000), 0x1.40000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdffff), -0x1.400000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020002), 0x1.400000020002p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdfffd), -0x1.400000020003p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020008), 0x1.400000020008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdfff7), -0x1.400000020009p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020010), 0x1.40000002001p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdffef), -0x1.400000020011p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020080), 0x1.40000002008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdff7f), -0x1.400000020081p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020400), 0x1.4000000204p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdfbff), -0x1.400000020401p+48, 0x0p+0 },
+{ INT64_C(0x0001400000020800), 0x1.4000000208p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffdf7ff), -0x1.400000020801p+48, 0x0p+0 },
+{ INT64_C(0x0001400000022000), 0x1.400000022p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffffddfff), -0x1.400000022001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000100000), 0x1.4000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffefffff), -0x1.400000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000100004), 0x1.400000100004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffeffffb), -0x1.400000100005p+48, 0x0p+0 },
+{ INT64_C(0x0001400000100008), 0x1.400000100008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffeffff7), -0x1.400000100009p+48, 0x0p+0 },
+{ INT64_C(0x0001400000100080), 0x1.40000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffefff7f), -0x1.400000100081p+48, 0x0p+0 },
+{ INT64_C(0x0001400000100100), 0x1.4000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffeffeff), -0x1.400000100101p+48, 0x0p+0 },
+{ INT64_C(0x0001400000100400), 0x1.4000001004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffeffbff), -0x1.400000100401p+48, 0x0p+0 },
+{ INT64_C(0x0001400000102000), 0x1.400000102p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffefdfff), -0x1.400000102001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000110000), 0x1.40000011p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffeeffff), -0x1.400000110001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000120000), 0x1.40000012p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffedffff), -0x1.400000120001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000140000), 0x1.40000014p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffebffff), -0x1.400000140001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200000), 0x1.4000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdfffff), -0x1.400000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200002), 0x1.400000200002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdffffd), -0x1.400000200003p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200008), 0x1.400000200008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdffff7), -0x1.400000200009p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200020), 0x1.40000020002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdfffdf), -0x1.400000200021p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200040), 0x1.40000020004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdfffbf), -0x1.400000200041p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200080), 0x1.40000020008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdfff7f), -0x1.400000200081p+48, 0x0p+0 },
+{ INT64_C(0x0001400000200400), 0x1.4000002004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdffbff), -0x1.400000200401p+48, 0x0p+0 },
+{ INT64_C(0x0001400000201000), 0x1.400000201p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdfefff), -0x1.400000201001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000202000), 0x1.400000202p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdfdfff), -0x1.400000202001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000210000), 0x1.40000021p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdeffff), -0x1.400000210001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000240000), 0x1.40000024p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffdbffff), -0x1.400000240001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000280000), 0x1.40000028p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffd7ffff), -0x1.400000280001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000400000), 0x1.4000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbfffff), -0x1.400000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000400004), 0x1.400000400004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbffffb), -0x1.400000400005p+48, 0x0p+0 },
+{ INT64_C(0x0001400000400020), 0x1.40000040002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbfffdf), -0x1.400000400021p+48, 0x0p+0 },
+{ INT64_C(0x0001400000400080), 0x1.40000040008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbfff7f), -0x1.400000400081p+48, 0x0p+0 },
+{ INT64_C(0x0001400000400400), 0x1.4000004004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbffbff), -0x1.400000400401p+48, 0x0p+0 },
+{ INT64_C(0x0001400000404000), 0x1.400000404p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbfbfff), -0x1.400000404001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000408000), 0x1.400000408p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbf7fff), -0x1.400000408001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000420000), 0x1.40000042p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbdffff), -0x1.400000420001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000440000), 0x1.40000044p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffbbffff), -0x1.400000440001p+48, 0x0p+0 },
+{ INT64_C(0x0001400000500000), 0x1.4000005p+48, 0x0p+0 },
+{ INT64_C(0xfffebfffffafffff), -0x1.400000500001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001000000), 0x1.400001p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffeffffff), -0x1.400001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001000008), 0x1.400001000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffefffff7), -0x1.400001000009p+48, 0x0p+0 },
+{ INT64_C(0x0001400001000040), 0x1.40000100004p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffeffffbf), -0x1.400001000041p+48, 0x0p+0 },
+{ INT64_C(0x0001400001000100), 0x1.4000010001p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffefffeff), -0x1.400001000101p+48, 0x0p+0 },
+{ INT64_C(0x0001400001000800), 0x1.4000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffefff7ff), -0x1.400001000801p+48, 0x0p+0 },
+{ INT64_C(0x0001400001001000), 0x1.400001001p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffeffefff), -0x1.400001001001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001004000), 0x1.400001004p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffeffbfff), -0x1.400001004001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001020000), 0x1.40000102p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffefdffff), -0x1.400001020001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001040000), 0x1.40000104p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffefbffff), -0x1.400001040001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001100000), 0x1.4000011p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffeefffff), -0x1.400001100001p+48, 0x0p+0 },
+{ INT64_C(0x0001400001800000), 0x1.4000018p+48, 0x0p+0 },
+{ INT64_C(0xfffebffffe7fffff), -0x1.400001800001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008000000), 0x1.400008p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7ffffff), -0x1.400008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008000004), 0x1.400008000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7fffffb), -0x1.400008000005p+48, 0x0p+0 },
+{ INT64_C(0x0001400008000040), 0x1.40000800004p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7ffffbf), -0x1.400008000041p+48, 0x0p+0 },
+{ INT64_C(0x0001400008000200), 0x1.4000080002p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7fffdff), -0x1.400008000201p+48, 0x0p+0 },
+{ INT64_C(0x0001400008002000), 0x1.400008002p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7ffdfff), -0x1.400008002001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008004000), 0x1.400008004p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7ffbfff), -0x1.400008004001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008020000), 0x1.40000802p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7fdffff), -0x1.400008020001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008100000), 0x1.4000081p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7efffff), -0x1.400008100001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008400000), 0x1.4000084p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff7bfffff), -0x1.400008400001p+48, 0x0p+0 },
+{ INT64_C(0x0001400008800000), 0x1.4000088p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff77fffff), -0x1.400008800001p+48, 0x0p+0 },
+{ INT64_C(0x0001400009000000), 0x1.400009p+48, 0x0p+0 },
+{ INT64_C(0xfffebffff6ffffff), -0x1.400009000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000000), 0x1.40008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7fffffff), -0x1.400080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000001), 0x1.400080000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7ffffffe), -0x1.400080000002p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000008), 0x1.400080000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7ffffff7), -0x1.400080000009p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000020), 0x1.40008000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7fffffdf), -0x1.400080000021p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000040), 0x1.40008000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7fffffbf), -0x1.400080000041p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000200), 0x1.4000800002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7ffffdff), -0x1.400080000201p+48, 0x0p+0 },
+{ INT64_C(0x0001400080000800), 0x1.4000800008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7ffff7ff), -0x1.400080000801p+48, 0x0p+0 },
+{ INT64_C(0x0001400080004000), 0x1.400080004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7fffbfff), -0x1.400080004001p+48, 0x0p+0 },
+{ INT64_C(0x0001400080010000), 0x1.40008001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7ffeffff), -0x1.400080010001p+48, 0x0p+0 },
+{ INT64_C(0x0001400080020000), 0x1.40008002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7ffdffff), -0x1.400080020001p+48, 0x0p+0 },
+{ INT64_C(0x0001400080100000), 0x1.4000801p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7fefffff), -0x1.400080100001p+48, 0x0p+0 },
+{ INT64_C(0x0001400080400000), 0x1.4000804p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7fbfffff), -0x1.400080400001p+48, 0x0p+0 },
+{ INT64_C(0x0001400081000000), 0x1.400081p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7effffff), -0x1.400081000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400084000000), 0x1.400084p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff7bffffff), -0x1.400084000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400090000000), 0x1.40009p+48, 0x0p+0 },
+{ INT64_C(0xfffebfff6fffffff), -0x1.400090000001p+48, 0x0p+0 },
+{ INT64_C(0x00014000a0000000), 0x1.4000ap+48, 0x0p+0 },
+{ INT64_C(0xfffebfff5fffffff), -0x1.4000a0000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400800000000), 0x1.4008p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7ffffffff), -0x1.400800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400800000004), 0x1.400800000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7fffffffb), -0x1.400800000005p+48, 0x0p+0 },
+{ INT64_C(0x0001400800000010), 0x1.40080000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7ffffffef), -0x1.400800000011p+48, 0x0p+0 },
+{ INT64_C(0x0001400800000080), 0x1.40080000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7ffffff7f), -0x1.400800000081p+48, 0x0p+0 },
+{ INT64_C(0x0001400800000100), 0x1.4008000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7fffffeff), -0x1.400800000101p+48, 0x0p+0 },
+{ INT64_C(0x0001400800000200), 0x1.4008000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7fffffdff), -0x1.400800000201p+48, 0x0p+0 },
+{ INT64_C(0x0001400800002000), 0x1.400800002p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7ffffdfff), -0x1.400800002001p+48, 0x0p+0 },
+{ INT64_C(0x0001400800020000), 0x1.40080002p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7fffdffff), -0x1.400800020001p+48, 0x0p+0 },
+{ INT64_C(0x0001400800080000), 0x1.40080008p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7fff7ffff), -0x1.400800080001p+48, 0x0p+0 },
+{ INT64_C(0x0001400800800000), 0x1.4008008p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7ff7fffff), -0x1.400800800001p+48, 0x0p+0 },
+{ INT64_C(0x0001400804000000), 0x1.400804p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7fbffffff), -0x1.400804000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400810000000), 0x1.40081p+48, 0x0p+0 },
+{ INT64_C(0xfffebff7efffffff), -0x1.400810000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400880000000), 0x1.40088p+48, 0x0p+0 },
+{ INT64_C(0xfffebff77fffffff), -0x1.400880000001p+48, 0x0p+0 },
+{ INT64_C(0x0001400c00000000), 0x1.400cp+48, 0x0p+0 },
+{ INT64_C(0xfffebff3ffffffff), -0x1.400c00000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000000), 0x1.404p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbfffffffff), -0x1.404000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000001), 0x1.404000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffffffe), -0x1.404000000002p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000002), 0x1.404000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffffffd), -0x1.404000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000010), 0x1.40400000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbfffffffef), -0x1.404000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000100), 0x1.4040000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffffeff), -0x1.404000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000200), 0x1.4040000002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffffdff), -0x1.404000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001404000000800), 0x1.4040000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffff7ff), -0x1.404000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001404000001000), 0x1.404000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbfffffefff), -0x1.404000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001404000010000), 0x1.40400001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffeffff), -0x1.404000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001404000020000), 0x1.40400002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffdffff), -0x1.404000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001404000040000), 0x1.40400004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffffbffff), -0x1.404000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001404000100000), 0x1.4040001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbfffefffff), -0x1.404000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001404001000000), 0x1.404001p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffeffffff), -0x1.404001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404002000000), 0x1.404002p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffdffffff), -0x1.404002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404004000000), 0x1.404004p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbffbffffff), -0x1.404004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404040000000), 0x1.40404p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbfbfffffff), -0x1.404040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404080000000), 0x1.40408p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbf7fffffff), -0x1.404080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001404400000000), 0x1.4044p+48, 0x0p+0 },
+{ INT64_C(0xfffebfbbffffffff), -0x1.404400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001406000000000), 0x1.406p+48, 0x0p+0 },
+{ INT64_C(0xfffebf9fffffffff), -0x1.406000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001410000000000), 0x1.41p+48, 0x0p+0 },
+{ INT64_C(0xfffebeffffffffff), -0x1.410000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001410000000004), 0x1.410000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebefffffffffb), -0x1.410000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001410000000010), 0x1.41000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebeffffffffef), -0x1.410000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001410000000080), 0x1.41000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebeffffffff7f), -0x1.410000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001410000000400), 0x1.4100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffebefffffffbff), -0x1.410000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001410000000800), 0x1.4100000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebefffffff7ff), -0x1.410000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001410000001000), 0x1.410000001p+48, 0x0p+0 },
+{ INT64_C(0xfffebeffffffefff), -0x1.410000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001410000008000), 0x1.410000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebeffffff7fff), -0x1.410000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001410000080000), 0x1.41000008p+48, 0x0p+0 },
+{ INT64_C(0xfffebefffff7ffff), -0x1.410000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001410000800000), 0x1.4100008p+48, 0x0p+0 },
+{ INT64_C(0xfffebeffff7fffff), -0x1.410000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001410008000000), 0x1.410008p+48, 0x0p+0 },
+{ INT64_C(0xfffebefff7ffffff), -0x1.410008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001410080000000), 0x1.41008p+48, 0x0p+0 },
+{ INT64_C(0xfffebeff7fffffff), -0x1.410080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001410200000000), 0x1.4102p+48, 0x0p+0 },
+{ INT64_C(0xfffebefdffffffff), -0x1.410200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001410400000000), 0x1.4104p+48, 0x0p+0 },
+{ INT64_C(0xfffebefbffffffff), -0x1.410400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001411000000000), 0x1.411p+48, 0x0p+0 },
+{ INT64_C(0xfffebeefffffffff), -0x1.411000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000000), 0x1.48p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffffffffff), -0x1.480000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000002), 0x1.480000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fffffffffd), -0x1.480000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000004), 0x1.480000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fffffffffb), -0x1.480000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000010), 0x1.48000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffffffffef), -0x1.480000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000020), 0x1.48000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffffffffdf), -0x1.480000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000080), 0x1.48000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffffffff7f), -0x1.480000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000200), 0x1.4800000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fffffffdff), -0x1.480000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001480000000400), 0x1.4800000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fffffffbff), -0x1.480000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001480000004000), 0x1.480000004p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffffffbfff), -0x1.480000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001480000020000), 0x1.48000002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fffffdffff), -0x1.480000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001480000200000), 0x1.4800002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffffdfffff), -0x1.480000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001480002000000), 0x1.480002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fffdffffff), -0x1.480002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001480020000000), 0x1.48002p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7ffdfffffff), -0x1.480020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001480200000000), 0x1.4802p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fdffffffff), -0x1.480200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001480400000000), 0x1.4804p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7fbffffffff), -0x1.480400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001480800000000), 0x1.4808p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7f7ffffffff), -0x1.480800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001482000000000), 0x1.482p+48, 0x0p+0 },
+{ INT64_C(0xfffeb7dfffffffff), -0x1.482000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001488000000000), 0x1.488p+48, 0x0p+0 },
+{ INT64_C(0xfffeb77fffffffff), -0x1.488000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001490000000000), 0x1.49p+48, 0x0p+0 },
+{ INT64_C(0xfffeb6ffffffffff), -0x1.490000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600000000000), 0x1.6p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffffffff), -0x1.600000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600000000008), 0x1.600000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffffffffff7), -0x1.600000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001600000000020), 0x1.60000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffffffdf), -0x1.600000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001600000000040), 0x1.60000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffffffbf), -0x1.600000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001600000000100), 0x1.6000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffffffffeff), -0x1.600000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001600000001000), 0x1.600000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffffefff), -0x1.600000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001600000002000), 0x1.600000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffffdfff), -0x1.600000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001600000008000), 0x1.600000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffff7fff), -0x1.600000008001p+48, 0x0p+0 },
+{ INT64_C(0x0001600000040000), 0x1.60000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffffffbffff), -0x1.600000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001600000400000), 0x1.6000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffffbfffff), -0x1.600000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001600001000000), 0x1.600001p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffffeffffff), -0x1.600001000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600002000000), 0x1.600002p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffffdffffff), -0x1.600002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600008000000), 0x1.600008p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffff7ffffff), -0x1.600008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600020000000), 0x1.60002p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffdfffffff), -0x1.600020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600040000000), 0x1.60004p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fffbfffffff), -0x1.600040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600200000000), 0x1.6002p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ffdffffffff), -0x1.600200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001600800000000), 0x1.6008p+48, 0x0p+0 },
+{ INT64_C(0xfffe9ff7ffffffff), -0x1.600800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001601000000000), 0x1.601p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fefffffffff), -0x1.601000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001604000000000), 0x1.604p+48, 0x0p+0 },
+{ INT64_C(0xfffe9fbfffffffff), -0x1.604000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001610000000000), 0x1.61p+48, 0x0p+0 },
+{ INT64_C(0xfffe9effffffffff), -0x1.610000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001680000000000), 0x1.68p+48, 0x0p+0 },
+{ INT64_C(0xfffe97ffffffffff), -0x1.680000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001700000000000), 0x1.7p+48, 0x0p+0 },
+{ INT64_C(0xfffe8fffffffffff), -0x1.700000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000004), 0x1.800000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffffffb), -0x1.800000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000010), 0x1.80000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffffef), -0x1.800000000011p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000018), 0x1.800000000018p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffffe7), -0x1.800000000019p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000100), 0x1.8000000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffffeff), -0x1.800000000101p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000104), 0x1.800000000104p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffffefb), -0x1.800000000105p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000110), 0x1.80000000011p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffffeef), -0x1.800000000111p+48, 0x0p+0 },
+{ INT64_C(0x0001800000000120), 0x1.80000000012p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffffedf), -0x1.800000000121p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001000), 0x1.800000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffefff), -0x1.800000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001002), 0x1.800000001002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffeffd), -0x1.800000001003p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001020), 0x1.80000000102p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffefdf), -0x1.800000001021p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001080), 0x1.80000000108p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffef7f), -0x1.800000001081p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001100), 0x1.8000000011p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffeeff), -0x1.800000001101p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001200), 0x1.8000000012p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffedff), -0x1.800000001201p+48, 0x0p+0 },
+{ INT64_C(0x0001800000001800), 0x1.8000000018p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffffe7ff), -0x1.800000001801p+48, 0x0p+0 },
+{ INT64_C(0x0001800000010000), 0x1.80000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffeffff), -0x1.800000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000010008), 0x1.800000010008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffefff7), -0x1.800000010009p+48, 0x0p+0 },
+{ INT64_C(0x0001800000010010), 0x1.80000001001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffeffef), -0x1.800000010011p+48, 0x0p+0 },
+{ INT64_C(0x0001800000010080), 0x1.80000001008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffeff7f), -0x1.800000010081p+48, 0x0p+0 },
+{ INT64_C(0x0001800000010800), 0x1.8000000108p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffef7ff), -0x1.800000010801p+48, 0x0p+0 },
+{ INT64_C(0x0001800000011000), 0x1.800000011p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffeefff), -0x1.800000011001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000018000), 0x1.800000018p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffffe7fff), -0x1.800000018001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000080000), 0x1.80000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff7ffff), -0x1.800000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000080002), 0x1.800000080002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff7fffd), -0x1.800000080003p+48, 0x0p+0 },
+{ INT64_C(0x0001800000080020), 0x1.80000008002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff7ffdf), -0x1.800000080021p+48, 0x0p+0 },
+{ INT64_C(0x0001800000080040), 0x1.80000008004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff7ffbf), -0x1.800000080041p+48, 0x0p+0 },
+{ INT64_C(0x0001800000080200), 0x1.8000000802p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff7fdff), -0x1.800000080201p+48, 0x0p+0 },
+{ INT64_C(0x0001800000082000), 0x1.800000082p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff7dfff), -0x1.800000082001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000090000), 0x1.80000009p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff6ffff), -0x1.800000090001p+48, 0x0p+0 },
+{ INT64_C(0x00018000000a0000), 0x1.8000000ap+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff5ffff), -0x1.8000000a0001p+48, 0x0p+0 },
+{ INT64_C(0x00018000000c0000), 0x1.8000000cp+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffff3ffff), -0x1.8000000c0001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000400000), 0x1.8000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbfffff), -0x1.800000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000400002), 0x1.800000400002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbffffd), -0x1.800000400003p+48, 0x0p+0 },
+{ INT64_C(0x0001800000400004), 0x1.800000400004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbffffb), -0x1.800000400005p+48, 0x0p+0 },
+{ INT64_C(0x0001800000400020), 0x1.80000040002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbfffdf), -0x1.800000400021p+48, 0x0p+0 },
+{ INT64_C(0x0001800000400040), 0x1.80000040004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbfffbf), -0x1.800000400041p+48, 0x0p+0 },
+{ INT64_C(0x0001800000400100), 0x1.8000004001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbffeff), -0x1.800000400101p+48, 0x0p+0 },
+{ INT64_C(0x0001800000401000), 0x1.800000401p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbfefff), -0x1.800000401001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000404000), 0x1.800000404p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbfbfff), -0x1.800000404001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000440000), 0x1.80000044p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffffbbffff), -0x1.800000440001p+48, 0x0p+0 },
+{ INT64_C(0x0001800000600000), 0x1.8000006p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffff9fffff), -0x1.800000600001p+48, 0x0p+0 },
+{ INT64_C(0x0001800004000000), 0x1.800004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbffffff), -0x1.800004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800004000008), 0x1.800004000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbfffff7), -0x1.800004000009p+48, 0x0p+0 },
+{ INT64_C(0x0001800004000080), 0x1.80000400008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbffff7f), -0x1.800004000081p+48, 0x0p+0 },
+{ INT64_C(0x0001800004000400), 0x1.8000040004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbfffbff), -0x1.800004000401p+48, 0x0p+0 },
+{ INT64_C(0x0001800004004000), 0x1.800004004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbffbfff), -0x1.800004004001p+48, 0x0p+0 },
+{ INT64_C(0x0001800004040000), 0x1.80000404p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbfbffff), -0x1.800004040001p+48, 0x0p+0 },
+{ INT64_C(0x0001800004400000), 0x1.8000044p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffffbbfffff), -0x1.800004400001p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000000), 0x1.800008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7ffffff), -0x1.800008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000001), 0x1.800008000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7fffffe), -0x1.800008000002p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000004), 0x1.800008000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7fffffb), -0x1.800008000005p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000020), 0x1.80000800002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7ffffdf), -0x1.800008000021p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000100), 0x1.8000080001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7fffeff), -0x1.800008000101p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000400), 0x1.8000080004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7fffbff), -0x1.800008000401p+48, 0x0p+0 },
+{ INT64_C(0x0001800008000800), 0x1.8000080008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7fff7ff), -0x1.800008000801p+48, 0x0p+0 },
+{ INT64_C(0x0001800008004000), 0x1.800008004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7ffbfff), -0x1.800008004001p+48, 0x0p+0 },
+{ INT64_C(0x0001800008010000), 0x1.80000801p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7feffff), -0x1.800008010001p+48, 0x0p+0 },
+{ INT64_C(0x0001800008080000), 0x1.80000808p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7f7ffff), -0x1.800008080001p+48, 0x0p+0 },
+{ INT64_C(0x0001800008200000), 0x1.8000082p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff7dfffff), -0x1.800008200001p+48, 0x0p+0 },
+{ INT64_C(0x000180000a000000), 0x1.80000ap+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffff5ffffff), -0x1.80000a000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800020000000), 0x1.80002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdfffffff), -0x1.800020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800020000008), 0x1.800020000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdffffff7), -0x1.800020000009p+48, 0x0p+0 },
+{ INT64_C(0x0001800020000020), 0x1.80002000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdfffffdf), -0x1.800020000021p+48, 0x0p+0 },
+{ INT64_C(0x0001800020000040), 0x1.80002000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdfffffbf), -0x1.800020000041p+48, 0x0p+0 },
+{ INT64_C(0x0001800020000080), 0x1.80002000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdfffff7f), -0x1.800020000081p+48, 0x0p+0 },
+{ INT64_C(0x0001800020000200), 0x1.8000200002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdffffdff), -0x1.800020000201p+48, 0x0p+0 },
+{ INT64_C(0x0001800020002000), 0x1.800020002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdfffdfff), -0x1.800020002001p+48, 0x0p+0 },
+{ INT64_C(0x0001800020010000), 0x1.80002001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdffeffff), -0x1.800020010001p+48, 0x0p+0 },
+{ INT64_C(0x0001800020080000), 0x1.80002008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdff7ffff), -0x1.800020080001p+48, 0x0p+0 },
+{ INT64_C(0x0001800020400000), 0x1.8000204p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdfbfffff), -0x1.800020400001p+48, 0x0p+0 },
+{ INT64_C(0x0001800021000000), 0x1.800021p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffdeffffff), -0x1.800021000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800028000000), 0x1.800028p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fffd7ffffff), -0x1.800028000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800100000000), 0x1.8001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeffffffff), -0x1.800100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800100000004), 0x1.800100000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffefffffffb), -0x1.800100000005p+48, 0x0p+0 },
+{ INT64_C(0x0001800100000010), 0x1.80010000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeffffffef), -0x1.800100000011p+48, 0x0p+0 },
+{ INT64_C(0x0001800100000080), 0x1.80010000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeffffff7f), -0x1.800100000081p+48, 0x0p+0 },
+{ INT64_C(0x0001800100000200), 0x1.8001000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffefffffdff), -0x1.800100000201p+48, 0x0p+0 },
+{ INT64_C(0x0001800100002000), 0x1.800100002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeffffdfff), -0x1.800100002001p+48, 0x0p+0 },
+{ INT64_C(0x0001800100008000), 0x1.800100008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeffff7fff), -0x1.800100008001p+48, 0x0p+0 },
+{ INT64_C(0x0001800100020000), 0x1.80010002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffefffdffff), -0x1.800100020001p+48, 0x0p+0 },
+{ INT64_C(0x0001800100200000), 0x1.8001002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeffdfffff), -0x1.800100200001p+48, 0x0p+0 },
+{ INT64_C(0x0001800102000000), 0x1.800102p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffefdffffff), -0x1.800102000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800108000000), 0x1.800108p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffef7ffffff), -0x1.800108000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800110000000), 0x1.80011p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffeefffffff), -0x1.800110000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800120000000), 0x1.80012p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffedfffffff), -0x1.800120000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800140000000), 0x1.80014p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffebfffffff), -0x1.800140000001p+48, 0x0p+0 },
+{ INT64_C(0x0001800180000000), 0x1.80018p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ffe7fffffff), -0x1.800180000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801000000000), 0x1.801p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefffffffff), -0x1.801000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801000000002), 0x1.801000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7feffffffffd), -0x1.801000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001801000000008), 0x1.801000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7feffffffff7), -0x1.801000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001801000000020), 0x1.80100000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefffffffdf), -0x1.801000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001801000000200), 0x1.8010000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7feffffffdff), -0x1.801000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001801000002000), 0x1.801000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefffffdfff), -0x1.801000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001801000020000), 0x1.80100002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7feffffdffff), -0x1.801000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001801000200000), 0x1.8010002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefffdfffff), -0x1.801000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001801000400000), 0x1.8010004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefffbfffff), -0x1.801000400001p+48, 0x0p+0 },
+{ INT64_C(0x0001801002000000), 0x1.801002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7feffdffffff), -0x1.801002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801010000000), 0x1.80101p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefefffffff), -0x1.801010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801020000000), 0x1.80102p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefdfffffff), -0x1.801020000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801040000000), 0x1.80104p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fefbfffffff), -0x1.801040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801080000000), 0x1.80108p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fef7fffffff), -0x1.801080000001p+48, 0x0p+0 },
+{ INT64_C(0x0001801200000000), 0x1.8012p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fedffffffff), -0x1.801200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001802000000000), 0x1.802p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdfffffffff), -0x1.802000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001802000000008), 0x1.802000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdffffffff7), -0x1.802000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001802000000080), 0x1.80200000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdfffffff7f), -0x1.802000000081p+48, 0x0p+0 },
+{ INT64_C(0x0001802000000800), 0x1.8020000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdffffff7ff), -0x1.802000000801p+48, 0x0p+0 },
+{ INT64_C(0x0001802000001000), 0x1.802000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdfffffefff), -0x1.802000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001802000010000), 0x1.80200001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdffffeffff), -0x1.802000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001802000020000), 0x1.80200002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdffffdffff), -0x1.802000020001p+48, 0x0p+0 },
+{ INT64_C(0x0001802000100000), 0x1.8020001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdfffefffff), -0x1.802000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001802000800000), 0x1.8020008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdfff7fffff), -0x1.802000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001802008000000), 0x1.802008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdff7ffffff), -0x1.802008000001p+48, 0x0p+0 },
+{ INT64_C(0x0001802010000000), 0x1.80201p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdfefffffff), -0x1.802010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001802100000000), 0x1.8021p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fdeffffffff), -0x1.802100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001802200000000), 0x1.8022p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fddffffffff), -0x1.802200000001p+48, 0x0p+0 },
+{ INT64_C(0x0001803000000000), 0x1.803p+48, 0x0p+0 },
+{ INT64_C(0xfffe7fcfffffffff), -0x1.803000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001820000000000), 0x1.82p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffffffffff), -0x1.820000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001820000000002), 0x1.820000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfffffffffd), -0x1.820000000003p+48, 0x0p+0 },
+{ INT64_C(0x0001820000000004), 0x1.820000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfffffffffb), -0x1.820000000005p+48, 0x0p+0 },
+{ INT64_C(0x0001820000000008), 0x1.820000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfffffffff7), -0x1.820000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001820000000040), 0x1.82000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffffffffbf), -0x1.820000000041p+48, 0x0p+0 },
+{ INT64_C(0x0001820000000400), 0x1.8200000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfffffffbff), -0x1.820000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001820000001000), 0x1.820000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffffffefff), -0x1.820000001001p+48, 0x0p+0 },
+{ INT64_C(0x0001820000002000), 0x1.820000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffffffdfff), -0x1.820000002001p+48, 0x0p+0 },
+{ INT64_C(0x0001820000010000), 0x1.82000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfffffeffff), -0x1.820000010001p+48, 0x0p+0 },
+{ INT64_C(0x0001820000100000), 0x1.8200001p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffffefffff), -0x1.820000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001820000800000), 0x1.8200008p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffff7fffff), -0x1.820000800001p+48, 0x0p+0 },
+{ INT64_C(0x0001820004000000), 0x1.820004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfffbffffff), -0x1.820004000001p+48, 0x0p+0 },
+{ INT64_C(0x0001820040000000), 0x1.82004p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dffbfffffff), -0x1.820040000001p+48, 0x0p+0 },
+{ INT64_C(0x0001820400000000), 0x1.8204p+48, 0x0p+0 },
+{ INT64_C(0xfffe7dfbffffffff), -0x1.820400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001822000000000), 0x1.822p+48, 0x0p+0 },
+{ INT64_C(0xfffe7ddfffffffff), -0x1.822000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000000000), 0x1.ap+48, 0x0p+0 },
+{ INT64_C(0xfffe5fffffffffff), -0x1.a00000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000000008), 0x1.a00000000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffffffffff7), -0x1.a00000000009p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000000020), 0x1.a0000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe5fffffffffdf), -0x1.a00000000021p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000000200), 0x1.a000000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffffffffdff), -0x1.a00000000201p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000000400), 0x1.a000000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffffffffbff), -0x1.a00000000401p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000004000), 0x1.a00000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe5fffffffbfff), -0x1.a00000004001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000040000), 0x1.a0000004p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffffffbffff), -0x1.a00000040001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000080000), 0x1.a0000008p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffffff7ffff), -0x1.a00000080001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000100000), 0x1.a000001p+48, 0x0p+0 },
+{ INT64_C(0xfffe5fffffefffff), -0x1.a00000100001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00000200000), 0x1.a000002p+48, 0x0p+0 },
+{ INT64_C(0xfffe5fffffdfffff), -0x1.a00000200001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00002000000), 0x1.a00002p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffffdffffff), -0x1.a00002000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00010000000), 0x1.a0001p+48, 0x0p+0 },
+{ INT64_C(0xfffe5fffefffffff), -0x1.a00010000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00100000000), 0x1.a001p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffeffffffff), -0x1.a00100000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00400000000), 0x1.a004p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ffbffffffff), -0x1.a00400000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a00800000000), 0x1.a008p+48, 0x0p+0 },
+{ INT64_C(0xfffe5ff7ffffffff), -0x1.a00800000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a04000000000), 0x1.a04p+48, 0x0p+0 },
+{ INT64_C(0xfffe5fbfffffffff), -0x1.a04000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a10000000000), 0x1.a1p+48, 0x0p+0 },
+{ INT64_C(0xfffe5effffffffff), -0x1.a10000000001p+48, 0x0p+0 },
+{ INT64_C(0x0001a80000000000), 0x1.a8p+48, 0x0p+0 },
+{ INT64_C(0xfffe57ffffffffff), -0x1.a80000000001p+48, 0x0p+0 },
+{ INT64_C(0x0002000000000022), 0x1.000000000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffffdd), -0x1.0000000000118p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000024), 0x1.000000000012p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffffdb), -0x1.0000000000128p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000028), 0x1.000000000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffffd7), -0x1.0000000000148p+49, 0x0p+0 },
+{ INT64_C(0x000200000000002c), 0x1.000000000016p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffffd3), -0x1.0000000000168p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000082), 0x1.000000000041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffff7d), -0x1.0000000000418p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000090), 0x1.000000000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffff6f), -0x1.0000000000488p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000091), 0x1.0000000000488p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffff6e), -0x1.000000000049p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000092), 0x1.000000000049p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffff6d), -0x1.0000000000498p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000094), 0x1.00000000004ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffffff6b), -0x1.00000000004a8p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000202), 0x1.000000000101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffdfd), -0x1.0000000001018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000220), 0x1.00000000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffddf), -0x1.0000000001108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000228), 0x1.000000000114p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffdd7), -0x1.0000000001148p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000230), 0x1.000000000118p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffdcf), -0x1.0000000001188p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000280), 0x1.00000000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffd7f), -0x1.0000000001408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000281), 0x1.0000000001408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffd7e), -0x1.000000000141p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000284), 0x1.000000000142p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffd7b), -0x1.0000000001428p+49, 0x0p+0 },
+{ INT64_C(0x00020000000002c0), 0x1.00000000016p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffffd3f), -0x1.0000000001608p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000801), 0x1.0000000004008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7fe), -0x1.000000000401p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000802), 0x1.000000000401p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7fd), -0x1.0000000004018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000803), 0x1.0000000004018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7fc), -0x1.000000000402p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000804), 0x1.000000000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7fb), -0x1.0000000004028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000810), 0x1.000000000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7ef), -0x1.0000000004088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000814), 0x1.00000000040ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7eb), -0x1.00000000040a8p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000840), 0x1.00000000042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7bf), -0x1.0000000004208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000842), 0x1.000000000421p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7bd), -0x1.0000000004218p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000848), 0x1.000000000424p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff7b7), -0x1.0000000004248p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000860), 0x1.00000000043p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff79f), -0x1.0000000004308p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000c00), 0x1.0000000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff3ff), -0x1.0000000006008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000c08), 0x1.000000000604p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff3f7), -0x1.0000000006048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000000c40), 0x1.00000000062p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffff3bf), -0x1.0000000006208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008004), 0x1.000000004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7ffb), -0x1.0000000040028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008005), 0x1.0000000040028p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7ffa), -0x1.000000004003p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008006), 0x1.000000004003p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7ff9), -0x1.0000000040038p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008010), 0x1.000000004008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7fef), -0x1.0000000040088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008012), 0x1.000000004009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7fed), -0x1.0000000040098p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008100), 0x1.00000000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7eff), -0x1.0000000040808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008104), 0x1.000000004082p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7efb), -0x1.0000000040828p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008110), 0x1.000000004088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7eef), -0x1.0000000040888p+49, 0x0p+0 },
+{ INT64_C(0x0002000000008180), 0x1.0000000040cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff7e7f), -0x1.0000000040c08p+49, 0x0p+0 },
+{ INT64_C(0x0002000000009000), 0x1.0000000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff6fff), -0x1.0000000048008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000009008), 0x1.000000004804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff6ff7), -0x1.0000000048048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000009040), 0x1.00000000482p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff6fbf), -0x1.0000000048208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000009400), 0x1.000000004ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff6bff), -0x1.000000004a008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000009800), 0x1.000000004cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffff67ff), -0x1.000000004c008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010004), 0x1.000000008002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefffb), -0x1.0000000080028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010010), 0x1.000000008008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffeffef), -0x1.0000000080088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010014), 0x1.00000000800ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffeffeb), -0x1.00000000800a8p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010080), 0x1.00000000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffeff7f), -0x1.0000000080408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010084), 0x1.000000008042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffeff7b), -0x1.0000000080428p+49, 0x0p+0 },
+{ INT64_C(0x00020000000100a0), 0x1.00000000805p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffeff5f), -0x1.0000000080508p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010200), 0x1.0000000081p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefdff), -0x1.0000000081008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010201), 0x1.0000000081008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefdfe), -0x1.000000008101p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010202), 0x1.000000008101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefdfd), -0x1.0000000081018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010208), 0x1.000000008104p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefdf7), -0x1.0000000081048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010280), 0x1.00000000814p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefd7f), -0x1.0000000081408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010300), 0x1.00000000818p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefcff), -0x1.0000000081808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010400), 0x1.0000000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefbff), -0x1.0000000082008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010401), 0x1.0000000082008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefbfe), -0x1.000000008201p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010408), 0x1.000000008204p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefbf7), -0x1.0000000082048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010420), 0x1.00000000821p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefbdf), -0x1.0000000082108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010480), 0x1.00000000824p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffefb7f), -0x1.0000000082408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010800), 0x1.0000000084p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef7ff), -0x1.0000000084008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010801), 0x1.0000000084008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef7fe), -0x1.000000008401p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010802), 0x1.000000008401p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef7fd), -0x1.0000000084018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010808), 0x1.000000008404p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef7f7), -0x1.0000000084048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010810), 0x1.000000008408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef7ef), -0x1.0000000084088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010880), 0x1.00000000844p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef77f), -0x1.0000000084408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000010c00), 0x1.0000000086p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffef3ff), -0x1.0000000086008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018000), 0x1.00000000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe7fff), -0x1.00000000c0008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018001), 0x1.00000000c0008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe7ffe), -0x1.00000000c001p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018008), 0x1.00000000c004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe7ff7), -0x1.00000000c0048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018010), 0x1.00000000c008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe7fef), -0x1.00000000c0088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018100), 0x1.00000000c08p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe7eff), -0x1.00000000c0808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018400), 0x1.00000000c2p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe7bff), -0x1.00000000c2008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000018800), 0x1.00000000c4p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe77ff), -0x1.00000000c4008p+49, 0x0p+0 },
+{ INT64_C(0x000200000001c000), 0x1.00000000ep+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffe3fff), -0x1.00000000e0008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020004), 0x1.000000010002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfffb), -0x1.0000000100028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020005), 0x1.0000000100028p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfffa), -0x1.000000010003p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020006), 0x1.000000010003p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfff9), -0x1.0000000100038p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020020), 0x1.00000001001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdffdf), -0x1.0000000100108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020021), 0x1.0000000100108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdffde), -0x1.000000010011p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020028), 0x1.000000010014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdffd7), -0x1.0000000100148p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020040), 0x1.00000001002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdffbf), -0x1.0000000100208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020041), 0x1.0000000100208p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdffbe), -0x1.000000010021p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020048), 0x1.000000010024p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdffb7), -0x1.0000000100248p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020060), 0x1.00000001003p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdff9f), -0x1.0000000100308p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020200), 0x1.0000000101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfdff), -0x1.0000000101008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020202), 0x1.000000010101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfdfd), -0x1.0000000101018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020208), 0x1.000000010104p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfdf7), -0x1.0000000101048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020210), 0x1.000000010108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfdef), -0x1.0000000101088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020300), 0x1.00000001018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfcff), -0x1.0000000101808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020400), 0x1.0000000102p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfbff), -0x1.0000000102008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020404), 0x1.000000010202p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfbfb), -0x1.0000000102028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020440), 0x1.00000001022p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdfbbf), -0x1.0000000102208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000020600), 0x1.0000000103p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdf9ff), -0x1.0000000103008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000024000), 0x1.000000012p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdbfff), -0x1.0000000120008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000024008), 0x1.000000012004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdbff7), -0x1.0000000120048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000024020), 0x1.00000001201p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdbfdf), -0x1.0000000120108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000024200), 0x1.0000000121p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdbdff), -0x1.0000000121008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000025000), 0x1.0000000128p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffdafff), -0x1.0000000128008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000028000), 0x1.000000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffd7fff), -0x1.0000000140008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000028002), 0x1.000000014001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffd7ffd), -0x1.0000000140018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000028010), 0x1.000000014008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffd7fef), -0x1.0000000140088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000028080), 0x1.00000001404p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffd7f7f), -0x1.0000000140408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000028200), 0x1.0000000141p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffd7dff), -0x1.0000000141008p+49, 0x0p+0 },
+{ INT64_C(0x000200000002a000), 0x1.000000015p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffffd5fff), -0x1.0000000150008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200008), 0x1.000000100004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdffff7), -0x1.0000001000048p+49, 0x0p+0 },
+{ INT64_C(0x000200000020000c), 0x1.000000100006p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdffff3), -0x1.0000001000068p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200080), 0x1.00000010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfff7f), -0x1.0000001000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200088), 0x1.000000100044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfff77), -0x1.0000001000448p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200090), 0x1.000000100048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfff6f), -0x1.0000001000488p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200400), 0x1.0000001002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdffbff), -0x1.0000001002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200404), 0x1.000000100202p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdffbfb), -0x1.0000001002028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200410), 0x1.000000100208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdffbef), -0x1.0000001002088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200500), 0x1.00000010028p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdffaff), -0x1.0000001002808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000200600), 0x1.0000001003p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdff9ff), -0x1.0000001003008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000201000), 0x1.0000001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfefff), -0x1.0000001008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000201002), 0x1.000000100801p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfeffd), -0x1.0000001008018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000201020), 0x1.00000010081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfefdf), -0x1.0000001008108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000201040), 0x1.00000010082p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfefbf), -0x1.0000001008208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000201100), 0x1.00000010088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfeeff), -0x1.0000001008808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000204000), 0x1.000000102p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfbfff), -0x1.0000001020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000204001), 0x1.0000001020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfbffe), -0x1.000000102001p+49, 0x0p+0 },
+{ INT64_C(0x0002000000204008), 0x1.000000102004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfbff7), -0x1.0000001020048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000204040), 0x1.00000010202p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfbfbf), -0x1.0000001020208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000204200), 0x1.0000001021p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfbdff), -0x1.0000001021008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000204400), 0x1.0000001022p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdfbbff), -0x1.0000001022008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000206000), 0x1.000000103p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdf9fff), -0x1.0000001030008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000240000), 0x1.00000012p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdbffff), -0x1.0000001200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000240002), 0x1.000000120001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdbfffd), -0x1.0000001200018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000240020), 0x1.00000012001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdbffdf), -0x1.0000001200108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000240040), 0x1.00000012002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdbffbf), -0x1.0000001200208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000240080), 0x1.00000012004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdbff7f), -0x1.0000001200408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000240800), 0x1.0000001204p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdbf7ff), -0x1.0000001204008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000248000), 0x1.000000124p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdb7fff), -0x1.0000001240008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000250000), 0x1.000000128p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffdaffff), -0x1.0000001280008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000260000), 0x1.00000013p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffd9ffff), -0x1.0000001300008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000300000), 0x1.00000018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcfffff), -0x1.0000001800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000300001), 0x1.0000001800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcffffe), -0x1.000000180001p+49, 0x0p+0 },
+{ INT64_C(0x0002000000300002), 0x1.000000180001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcffffd), -0x1.0000001800018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000300010), 0x1.000000180008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcfffef), -0x1.0000001800088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000300100), 0x1.00000018008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcffeff), -0x1.0000001800808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000300800), 0x1.0000001804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcff7ff), -0x1.0000001804008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000308000), 0x1.000000184p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcf7fff), -0x1.0000001840008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000320000), 0x1.00000019p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffffcdffff), -0x1.0000001900008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800008), 0x1.000000400004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ffff7), -0x1.0000004000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800010), 0x1.000000400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fffef), -0x1.0000004000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800012), 0x1.000000400009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fffed), -0x1.0000004000098p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800014), 0x1.00000040000ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fffeb), -0x1.00000040000a8p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800020), 0x1.00000040001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fffdf), -0x1.0000004000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800022), 0x1.000000400011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fffdd), -0x1.0000004000118p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800024), 0x1.000000400012p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fffdb), -0x1.0000004000128p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800080), 0x1.00000040004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fff7f), -0x1.0000004000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800082), 0x1.000000400041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fff7d), -0x1.0000004000418p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800088), 0x1.000000400044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fff77), -0x1.0000004000448p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800200), 0x1.0000004001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ffdff), -0x1.0000004001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800202), 0x1.000000400101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ffdfd), -0x1.0000004001018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800204), 0x1.000000400102p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ffdfb), -0x1.0000004001028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800220), 0x1.00000040011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ffddf), -0x1.0000004001108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000800300), 0x1.00000040018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ffcff), -0x1.0000004001808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000801000), 0x1.0000004008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fefff), -0x1.0000004008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000801001), 0x1.0000004008008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7feffe), -0x1.000000400801p+49, 0x0p+0 },
+{ INT64_C(0x0002000000801004), 0x1.000000400802p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7feffb), -0x1.0000004008028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000801020), 0x1.00000040081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fefdf), -0x1.0000004008108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000801200), 0x1.0000004009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fedff), -0x1.0000004009008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804000), 0x1.000000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbfff), -0x1.0000004020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804002), 0x1.000000402001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbffd), -0x1.0000004020018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804004), 0x1.000000402002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbffb), -0x1.0000004020028p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804008), 0x1.000000402004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbff7), -0x1.0000004020048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804020), 0x1.00000040201p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbfdf), -0x1.0000004020108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804080), 0x1.00000040204p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbf7f), -0x1.0000004020408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804100), 0x1.00000040208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbeff), -0x1.0000004020808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000804400), 0x1.0000004022p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7fbbff), -0x1.0000004022008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810000), 0x1.000000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7effff), -0x1.0000004080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810002), 0x1.000000408001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7efffd), -0x1.0000004080018p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810008), 0x1.000000408004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7efff7), -0x1.0000004080048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810010), 0x1.000000408008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7effef), -0x1.0000004080088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810040), 0x1.00000040802p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7effbf), -0x1.0000004080208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810100), 0x1.00000040808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7efeff), -0x1.0000004080808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810400), 0x1.0000004082p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7efbff), -0x1.0000004082008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000810800), 0x1.0000004084p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ef7ff), -0x1.0000004084008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000812000), 0x1.000000409p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7edfff), -0x1.0000004090008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000814000), 0x1.00000040ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff7ebfff), -0x1.00000040a0008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000880000), 0x1.00000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77ffff), -0x1.0000004400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000880001), 0x1.0000004400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77fffe), -0x1.000000440001p+49, 0x0p+0 },
+{ INT64_C(0x0002000000880008), 0x1.000000440004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77fff7), -0x1.0000004400048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000880010), 0x1.000000440008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77ffef), -0x1.0000004400088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000880080), 0x1.00000044004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77ff7f), -0x1.0000004400408p+49, 0x0p+0 },
+{ INT64_C(0x0002000000880400), 0x1.0000004402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77fbff), -0x1.0000004402008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000884000), 0x1.000000442p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff77bfff), -0x1.0000004420008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000888000), 0x1.000000444p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff777fff), -0x1.0000004440008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a00000), 0x1.0000005p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5fffff), -0x1.0000005000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a00008), 0x1.000000500004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5ffff7), -0x1.0000005000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a00040), 0x1.00000050002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5fffbf), -0x1.0000005000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a00400), 0x1.0000005002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5ffbff), -0x1.0000005002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a00800), 0x1.0000005004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5ff7ff), -0x1.0000005004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a04000), 0x1.000000502p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5fbfff), -0x1.0000005020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000a20000), 0x1.00000051p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff5dffff), -0x1.0000005100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000b00000), 0x1.00000058p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff4fffff), -0x1.0000005800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c00000), 0x1.0000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3fffff), -0x1.0000006000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c00001), 0x1.0000006000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3ffffe), -0x1.000000600001p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c00010), 0x1.000000600008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3fffef), -0x1.0000006000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c00020), 0x1.00000060001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3fffdf), -0x1.0000006000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c00100), 0x1.00000060008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3ffeff), -0x1.0000006000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c01000), 0x1.0000006008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3fefff), -0x1.0000006008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c02000), 0x1.000000601p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3fdfff), -0x1.0000006010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000c20000), 0x1.00000061p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff3dffff), -0x1.0000006100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000000e00000), 0x1.0000007p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffff1fffff), -0x1.0000007000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000002), 0x1.000000800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefffffd), -0x1.0000008000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000008), 0x1.000000800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefffff7), -0x1.0000008000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000009), 0x1.0000008000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefffff6), -0x1.000000800005p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000020), 0x1.00000080001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffffdf), -0x1.0000008000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000028), 0x1.000000800014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffffd7), -0x1.0000008000148p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000100), 0x1.00000080008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefffeff), -0x1.0000008000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000102), 0x1.000000800081p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefffefd), -0x1.0000008000818p+49, 0x0p+0 },
+{ INT64_C(0x0002000001000110), 0x1.000000800088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefffeef), -0x1.0000008000888p+49, 0x0p+0 },
+{ INT64_C(0x0002000001001000), 0x1.0000008008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffefff), -0x1.0000008008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001001004), 0x1.000000800802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffeffb), -0x1.0000008008028p+49, 0x0p+0 },
+{ INT64_C(0x0002000001001010), 0x1.000000800808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffefef), -0x1.0000008008088p+49, 0x0p+0 },
+{ INT64_C(0x0002000001001040), 0x1.00000080082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffefbf), -0x1.0000008008208p+49, 0x0p+0 },
+{ INT64_C(0x0002000001001400), 0x1.000000800ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeffebff), -0x1.000000800a008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001008000), 0x1.000000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeff7fff), -0x1.0000008040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001008001), 0x1.0000008040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeff7ffe), -0x1.000000804001p+49, 0x0p+0 },
+{ INT64_C(0x0002000001008004), 0x1.000000804002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeff7ffb), -0x1.0000008040028p+49, 0x0p+0 },
+{ INT64_C(0x0002000001008010), 0x1.000000804008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeff7fef), -0x1.0000008040088p+49, 0x0p+0 },
+{ INT64_C(0x0002000001008100), 0x1.00000080408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeff7eff), -0x1.0000008040808p+49, 0x0p+0 },
+{ INT64_C(0x0002000001008800), 0x1.0000008044p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeff77ff), -0x1.0000008044008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001010000), 0x1.000000808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefeffff), -0x1.0000008080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001010008), 0x1.000000808004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefefff7), -0x1.0000008080048p+49, 0x0p+0 },
+{ INT64_C(0x0002000001010010), 0x1.000000808008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefeffef), -0x1.0000008080088p+49, 0x0p+0 },
+{ INT64_C(0x0002000001010020), 0x1.00000080801p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefeffdf), -0x1.0000008080108p+49, 0x0p+0 },
+{ INT64_C(0x0002000001010100), 0x1.00000080808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefefeff), -0x1.0000008080808p+49, 0x0p+0 },
+{ INT64_C(0x0002000001010800), 0x1.0000008084p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefef7ff), -0x1.0000008084008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001012000), 0x1.000000809p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefedfff), -0x1.0000008090008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001040000), 0x1.00000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefbffff), -0x1.0000008200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001040001), 0x1.0000008200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefbfffe), -0x1.000000820001p+49, 0x0p+0 },
+{ INT64_C(0x0002000001040010), 0x1.000000820008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefbffef), -0x1.0000008200088p+49, 0x0p+0 },
+{ INT64_C(0x0002000001040100), 0x1.00000082008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefbfeff), -0x1.0000008200808p+49, 0x0p+0 },
+{ INT64_C(0x0002000001040800), 0x1.0000008204p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefbf7ff), -0x1.0000008204008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001048000), 0x1.000000824p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffefb7fff), -0x1.0000008240008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100000), 0x1.00000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeefffff), -0x1.0000008800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100008), 0x1.000000880004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeeffff7), -0x1.0000008800048p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100010), 0x1.000000880008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeefffef), -0x1.0000008800088p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100020), 0x1.00000088001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeefffdf), -0x1.0000008800108p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100040), 0x1.00000088002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeefffbf), -0x1.0000008800208p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100080), 0x1.00000088004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeefff7f), -0x1.0000008800408p+49, 0x0p+0 },
+{ INT64_C(0x0002000001100800), 0x1.0000008804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeeff7ff), -0x1.0000008804008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001104000), 0x1.000000882p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeefbfff), -0x1.0000008820008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001108000), 0x1.000000884p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeef7fff), -0x1.0000008840008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001120000), 0x1.00000089p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffeedffff), -0x1.0000008900008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001180000), 0x1.0000008cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffee7ffff), -0x1.0000008c00008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800000), 0x1.000000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7fffff), -0x1.000000c000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800001), 0x1.000000c000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7ffffe), -0x1.000000c00001p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800004), 0x1.000000c00002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7ffffb), -0x1.000000c000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800008), 0x1.000000c00004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7ffff7), -0x1.000000c000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800020), 0x1.000000c0001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7fffdf), -0x1.000000c000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800080), 0x1.000000c0004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7fff7f), -0x1.000000c000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800400), 0x1.000000c002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7ffbff), -0x1.000000c002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001800800), 0x1.000000c004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7ff7ff), -0x1.000000c004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001804000), 0x1.000000c02p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7fbfff), -0x1.000000c020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001820000), 0x1.000000c1p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe7dffff), -0x1.000000c100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000001a00000), 0x1.000000dp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffe5fffff), -0x1.000000d000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000002), 0x1.000001000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffffd), -0x1.0000010000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000008), 0x1.000001000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffff7), -0x1.0000010000048p+49, 0x0p+0 },
+{ INT64_C(0x000200000200000a), 0x1.000001000005p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffff5), -0x1.0000010000058p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000010), 0x1.000001000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffffef), -0x1.0000010000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000014), 0x1.00000100000ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffffeb), -0x1.00000100000a8p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000018), 0x1.00000100000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffffe7), -0x1.00000100000c8p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000020), 0x1.00000100001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffffdf), -0x1.0000010000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000022), 0x1.000001000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffffdd), -0x1.0000010000118p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000028), 0x1.000001000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffffd7), -0x1.0000010000148p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000080), 0x1.00000100004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffff7f), -0x1.0000010000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000082), 0x1.000001000041p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffff7d), -0x1.0000010000418p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000084), 0x1.000001000042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffff7b), -0x1.0000010000428p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000088), 0x1.000001000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffff77), -0x1.0000010000448p+49, 0x0p+0 },
+{ INT64_C(0x00020000020000a0), 0x1.00000100005p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffff5f), -0x1.0000010000508p+49, 0x0p+0 },
+{ INT64_C(0x00020000020000c0), 0x1.00000100006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffff3f), -0x1.0000010000608p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000100), 0x1.00000100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffeff), -0x1.0000010000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000101), 0x1.0000010000808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffefe), -0x1.000001000081p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000110), 0x1.000001000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffeef), -0x1.0000010000888p+49, 0x0p+0 },
+{ INT64_C(0x0002000002000180), 0x1.0000010000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfffe7f), -0x1.0000010000c08p+49, 0x0p+0 },
+{ INT64_C(0x0002000002001000), 0x1.0000010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffefff), -0x1.0000010008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002001004), 0x1.000001000802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffeffb), -0x1.0000010008028p+49, 0x0p+0 },
+{ INT64_C(0x0002000002001040), 0x1.00000100082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffefbf), -0x1.0000010008208p+49, 0x0p+0 },
+{ INT64_C(0x0002000002001100), 0x1.00000100088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffeeff), -0x1.0000010008808p+49, 0x0p+0 },
+{ INT64_C(0x0002000002001800), 0x1.000001000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdffe7ff), -0x1.000001000c008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010000), 0x1.000001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfeffff), -0x1.0000010080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010001), 0x1.0000010080008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfefffe), -0x1.000001008001p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010002), 0x1.000001008001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfefffd), -0x1.0000010080018p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010004), 0x1.000001008002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfefffb), -0x1.0000010080028p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010020), 0x1.00000100801p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfeffdf), -0x1.0000010080108p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010040), 0x1.00000100802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfeffbf), -0x1.0000010080208p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010200), 0x1.0000010081p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfefdff), -0x1.0000010081008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002010400), 0x1.0000010082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfefbff), -0x1.0000010082008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002012000), 0x1.000001009p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfedfff), -0x1.0000010090008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002014000), 0x1.00000100ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfebfff), -0x1.00000100a0008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002018000), 0x1.00000100cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdfe7fff), -0x1.00000100c0008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100000), 0x1.00000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefffff), -0x1.0000010800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100004), 0x1.000001080002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdeffffb), -0x1.0000010800028p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100010), 0x1.000001080008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefffef), -0x1.0000010800088p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100040), 0x1.00000108002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefffbf), -0x1.0000010800208p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100080), 0x1.00000108004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefff7f), -0x1.0000010800408p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100100), 0x1.00000108008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdeffeff), -0x1.0000010800808p+49, 0x0p+0 },
+{ INT64_C(0x0002000002100800), 0x1.0000010804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdeff7ff), -0x1.0000010804008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002101000), 0x1.0000010808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefefff), -0x1.0000010808008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002102000), 0x1.000001081p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefdfff), -0x1.0000010810008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002104000), 0x1.000001082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdefbfff), -0x1.0000010820008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002140000), 0x1.0000010ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdebffff), -0x1.0000010a00008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002400000), 0x1.0000012p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbfffff), -0x1.0000012000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002400004), 0x1.000001200002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbffffb), -0x1.0000012000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000002400010), 0x1.000001200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbfffef), -0x1.0000012000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000002400040), 0x1.00000120002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbfffbf), -0x1.0000012000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000002400080), 0x1.00000120004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbfff7f), -0x1.0000012000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000002400800), 0x1.0000012004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbff7ff), -0x1.0000012004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002402000), 0x1.000001201p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbfdfff), -0x1.0000012010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002404000), 0x1.000001202p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbfbfff), -0x1.0000012020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000002440000), 0x1.00000122p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffdbbffff), -0x1.0000012200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000003000000), 0x1.0000018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcffffff), -0x1.0000018000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000003000008), 0x1.000001800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcfffff7), -0x1.0000018000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000003000020), 0x1.00000180001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcffffdf), -0x1.0000018000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000003000100), 0x1.00000180008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcfffeff), -0x1.0000018000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000003001000), 0x1.0000018008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcffefff), -0x1.0000018008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000003004000), 0x1.000001802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcffbfff), -0x1.0000018020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000003020000), 0x1.00000181p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcfdffff), -0x1.0000018100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000003200000), 0x1.0000019p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcdfffff), -0x1.0000019000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000003400000), 0x1.000001ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffffcbfffff), -0x1.000001a000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000004), 0x1.000004000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffffb), -0x1.0000040000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000006), 0x1.000004000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffff9), -0x1.0000040000038p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000008), 0x1.000004000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffff7), -0x1.0000040000048p+49, 0x0p+0 },
+{ INT64_C(0x000200000800000c), 0x1.000004000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffff3), -0x1.0000040000068p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000020), 0x1.00000400001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffffdf), -0x1.0000040000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000022), 0x1.000004000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffffdd), -0x1.0000040000118p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000028), 0x1.000004000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffffd7), -0x1.0000040000148p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000200), 0x1.0000040001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffdff), -0x1.0000040001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000201), 0x1.0000040001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffdfe), -0x1.000004000101p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000210), 0x1.000004000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffdef), -0x1.0000040001088p+49, 0x0p+0 },
+{ INT64_C(0x0002000008000280), 0x1.00000400014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fffd7f), -0x1.0000040001408p+49, 0x0p+0 },
+{ INT64_C(0x0002000008002000), 0x1.000004001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffdfff), -0x1.0000040010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008002002), 0x1.000004001001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffdffd), -0x1.0000040010018p+49, 0x0p+0 },
+{ INT64_C(0x0002000008002020), 0x1.00000400101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffdfdf), -0x1.0000040010108p+49, 0x0p+0 },
+{ INT64_C(0x0002000008002200), 0x1.0000040011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffddff), -0x1.0000040011008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008003000), 0x1.0000040018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7ffcfff), -0x1.0000040018008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008020000), 0x1.00000401p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fdffff), -0x1.0000040100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008020008), 0x1.000004010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fdfff7), -0x1.0000040100048p+49, 0x0p+0 },
+{ INT64_C(0x0002000008020080), 0x1.00000401004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fdff7f), -0x1.0000040100408p+49, 0x0p+0 },
+{ INT64_C(0x0002000008020400), 0x1.0000040102p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fdfbff), -0x1.0000040102008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008022000), 0x1.000004011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fddfff), -0x1.0000040110008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008028000), 0x1.000004014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fd7fff), -0x1.0000040140008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008030000), 0x1.000004018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fcffff), -0x1.0000040180008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008040000), 0x1.00000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbffff), -0x1.0000040200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008040004), 0x1.000004020002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbfffb), -0x1.0000040200028p+49, 0x0p+0 },
+{ INT64_C(0x0002000008040040), 0x1.00000402002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbffbf), -0x1.0000040200208p+49, 0x0p+0 },
+{ INT64_C(0x0002000008040100), 0x1.00000402008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbfeff), -0x1.0000040200808p+49, 0x0p+0 },
+{ INT64_C(0x0002000008040200), 0x1.0000040201p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbfdff), -0x1.0000040201008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008040400), 0x1.0000040202p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbfbff), -0x1.0000040202008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008044000), 0x1.000004022p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7fbbfff), -0x1.0000040220008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008060000), 0x1.00000403p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7f9ffff), -0x1.0000040300008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008400000), 0x1.0000042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bfffff), -0x1.0000042000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008400002), 0x1.000004200001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bffffd), -0x1.0000042000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000008400010), 0x1.000004200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bfffef), -0x1.0000042000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000008400020), 0x1.00000420001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bfffdf), -0x1.0000042000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000008400100), 0x1.00000420008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bffeff), -0x1.0000042000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000008400800), 0x1.0000042004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bff7ff), -0x1.0000042004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008404000), 0x1.000004202p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bfbfff), -0x1.0000042020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008440000), 0x1.00000422p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7bbffff), -0x1.0000042200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008500000), 0x1.00000428p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff7afffff), -0x1.0000042800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008600000), 0x1.0000043p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff79fffff), -0x1.0000043000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800000), 0x1.0000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77fffff), -0x1.0000044000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800001), 0x1.0000044000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77ffffe), -0x1.000004400001p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800008), 0x1.000004400004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77ffff7), -0x1.0000044000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800010), 0x1.000004400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77fffef), -0x1.0000044000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800040), 0x1.00000440002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77fffbf), -0x1.0000044000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800100), 0x1.00000440008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77ffeff), -0x1.0000044000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800200), 0x1.0000044001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77ffdff), -0x1.0000044001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800400), 0x1.0000044002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77ffbff), -0x1.0000044002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008800800), 0x1.0000044004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77ff7ff), -0x1.0000044004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008802000), 0x1.000004401p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77fdfff), -0x1.0000044010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008810000), 0x1.000004408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff77effff), -0x1.0000044080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000008900000), 0x1.00000448p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff76fffff), -0x1.0000044800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000009000000), 0x1.0000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6ffffff), -0x1.0000048000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000009000008), 0x1.000004800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6fffff7), -0x1.0000048000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000009000010), 0x1.000004800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6ffffef), -0x1.0000048000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000009000100), 0x1.00000480008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6fffeff), -0x1.0000048000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000009001000), 0x1.0000048008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6ffefff), -0x1.0000048008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000009008000), 0x1.000004804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6ff7fff), -0x1.0000048040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000009080000), 0x1.00000484p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6f7ffff), -0x1.0000048400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000009200000), 0x1.0000049p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6dfffff), -0x1.0000049000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000009400000), 0x1.000004ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff6bfffff), -0x1.000004a000008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a000000), 0x1.000005p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5ffffff), -0x1.0000050000008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a000004), 0x1.000005000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5fffffb), -0x1.0000050000028p+49, 0x0p+0 },
+{ INT64_C(0x000200000a000040), 0x1.00000500002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5ffffbf), -0x1.0000050000208p+49, 0x0p+0 },
+{ INT64_C(0x000200000a000400), 0x1.0000050002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5fffbff), -0x1.0000050002008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a002000), 0x1.000005001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5ffdfff), -0x1.0000050010008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a010000), 0x1.000005008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5feffff), -0x1.0000050080008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a040000), 0x1.00000502p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5fbffff), -0x1.0000050200008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a080000), 0x1.00000504p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff5f7ffff), -0x1.0000050400008p+49, 0x0p+0 },
+{ INT64_C(0x000200000a800000), 0x1.0000054p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffff57fffff), -0x1.0000054000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000002), 0x1.000008000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffffd), -0x1.0000080000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000003), 0x1.0000080000018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffffc), -0x1.000008000002p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000020), 0x1.00000800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefffffdf), -0x1.0000080000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000021), 0x1.0000080000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefffffde), -0x1.000008000011p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000028), 0x1.000008000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefffffd7), -0x1.0000080000148p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000100), 0x1.00000800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffeff), -0x1.0000080000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000102), 0x1.000008000081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffefd), -0x1.0000080000818p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000110), 0x1.000008000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffeef), -0x1.0000080000888p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000180), 0x1.0000080000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffe7f), -0x1.0000080000c08p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000200), 0x1.0000080001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffdff), -0x1.0000080001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000204), 0x1.000008000102p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffdfb), -0x1.0000080001028p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000240), 0x1.00000800012p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffdbf), -0x1.0000080001208p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000280), 0x1.00000800014p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffd7f), -0x1.0000080001408p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000300), 0x1.00000800018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffffcff), -0x1.0000080001808p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000800), 0x1.0000080004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffff7ff), -0x1.0000080004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000804), 0x1.000008000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffff7fb), -0x1.0000080004028p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000810), 0x1.000008000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffff7ef), -0x1.0000080004088p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000900), 0x1.00000800048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffff6ff), -0x1.0000080004808p+49, 0x0p+0 },
+{ INT64_C(0x0002000010000a00), 0x1.0000080005p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeffff5ff), -0x1.0000080005008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010008000), 0x1.000008004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff7fff), -0x1.0000080040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010008008), 0x1.000008004004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff7ff7), -0x1.0000080040048p+49, 0x0p+0 },
+{ INT64_C(0x0002000010008040), 0x1.00000800402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff7fbf), -0x1.0000080040208p+49, 0x0p+0 },
+{ INT64_C(0x0002000010008100), 0x1.00000800408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff7eff), -0x1.0000080040808p+49, 0x0p+0 },
+{ INT64_C(0x0002000010008200), 0x1.0000080041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff7dff), -0x1.0000080041008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010009000), 0x1.0000080048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff6fff), -0x1.0000080048008p+49, 0x0p+0 },
+{ INT64_C(0x000200001000a000), 0x1.000008005p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefff5fff), -0x1.0000080050008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010080000), 0x1.00000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff7ffff), -0x1.0000080400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010080001), 0x1.0000080400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff7fffe), -0x1.000008040001p+49, 0x0p+0 },
+{ INT64_C(0x0002000010080010), 0x1.000008040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff7ffef), -0x1.0000080400088p+49, 0x0p+0 },
+{ INT64_C(0x0002000010080100), 0x1.00000804008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff7feff), -0x1.0000080400808p+49, 0x0p+0 },
+{ INT64_C(0x0002000010081000), 0x1.0000080408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff7efff), -0x1.0000080408008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010084000), 0x1.000008042p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff7bfff), -0x1.0000080420008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010090000), 0x1.000008048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff6ffff), -0x1.0000080480008p+49, 0x0p+0 },
+{ INT64_C(0x00020000100c0000), 0x1.00000806p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeff3ffff), -0x1.0000080600008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010200000), 0x1.0000081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefdfffff), -0x1.0000081000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010200004), 0x1.000008100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefdffffb), -0x1.0000081000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000010200020), 0x1.00000810001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefdfffdf), -0x1.0000081000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000010200200), 0x1.0000081001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefdffdff), -0x1.0000081001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010202000), 0x1.000008101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefdfdfff), -0x1.0000081010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010208000), 0x1.000008104p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefdf7fff), -0x1.0000081040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010220000), 0x1.00000811p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffefddffff), -0x1.0000081100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010800000), 0x1.0000084p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7fffff), -0x1.0000084000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010800004), 0x1.000008400002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7ffffb), -0x1.0000084000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000010800040), 0x1.00000840002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7fffbf), -0x1.0000084000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000010800080), 0x1.00000840004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7fff7f), -0x1.0000084000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000010800100), 0x1.00000840008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7ffeff), -0x1.0000084000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000010800400), 0x1.0000084002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7ffbff), -0x1.0000084002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010804000), 0x1.000008402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7fbfff), -0x1.0000084020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010808000), 0x1.000008404p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7f7fff), -0x1.0000084040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010820000), 0x1.00000841p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef7dffff), -0x1.0000084100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010880000), 0x1.00000844p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef77ffff), -0x1.0000084400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010a00000), 0x1.0000085p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef5fffff), -0x1.0000085000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000010c00000), 0x1.0000086p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffef3fffff), -0x1.0000086000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000000), 0x1.0000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeeffffff), -0x1.0000088000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000001), 0x1.0000088000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeefffffe), -0x1.000008800001p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000002), 0x1.000008800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeefffffd), -0x1.0000088000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000010), 0x1.000008800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeeffffef), -0x1.0000088000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000020), 0x1.00000880001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeeffffdf), -0x1.0000088000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000080), 0x1.00000880004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeeffff7f), -0x1.0000088000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000011000200), 0x1.0000088001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeefffdff), -0x1.0000088001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011002000), 0x1.000008801p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeeffdfff), -0x1.0000088010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011008000), 0x1.000008804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeeff7fff), -0x1.0000088040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011040000), 0x1.00000882p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeefbffff), -0x1.0000088200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011200000), 0x1.0000089p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeedfffff), -0x1.0000089000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000011400000), 0x1.000008ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeebfffff), -0x1.000008a000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012000000), 0x1.000009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedffffff), -0x1.0000090000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012000001), 0x1.0000090000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedfffffe), -0x1.000009000001p+49, 0x0p+0 },
+{ INT64_C(0x0002000012000008), 0x1.000009000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedfffff7), -0x1.0000090000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000012000020), 0x1.00000900001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedffffdf), -0x1.0000090000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000012000200), 0x1.0000090001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedfffdff), -0x1.0000090001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012001000), 0x1.0000090008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedffefff), -0x1.0000090008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012002000), 0x1.000009001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedffdfff), -0x1.0000090010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012008000), 0x1.000009004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedff7fff), -0x1.0000090040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012020000), 0x1.00000901p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedfdffff), -0x1.0000090100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012100000), 0x1.00000908p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffedefffff), -0x1.0000090800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000012200000), 0x1.0000091p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffeddfffff), -0x1.0000091000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000013000000), 0x1.0000098p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffecffffff), -0x1.0000098000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000014000000), 0x1.00000ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebffffff), -0x1.00000a0000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000014000002), 0x1.00000a000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebfffffd), -0x1.00000a0000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000014000010), 0x1.00000a000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebffffef), -0x1.00000a0000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000014000040), 0x1.00000a00002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebffffbf), -0x1.00000a0000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000014000080), 0x1.00000a00004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebffff7f), -0x1.00000a0000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000014000400), 0x1.00000a0002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebfffbff), -0x1.00000a0002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000014004000), 0x1.00000a002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebffbfff), -0x1.00000a0020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000014040000), 0x1.00000a02p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebfbffff), -0x1.00000a0200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000014080000), 0x1.00000a04p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebf7ffff), -0x1.00000a0400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000014200000), 0x1.00000a1p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffebdfffff), -0x1.00000a1000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000016000000), 0x1.00000bp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffe9ffffff), -0x1.00000b0000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000001), 0x1.0000100000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffffffe), -0x1.000010000001p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000010), 0x1.000010000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffffef), -0x1.0000100000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000011), 0x1.0000100000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffffee), -0x1.000010000009p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000080), 0x1.00001000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffff7f), -0x1.0000100000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000082), 0x1.000010000041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffff7d), -0x1.0000100000418p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000090), 0x1.000010000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffff6f), -0x1.0000100000488p+49, 0x0p+0 },
+{ INT64_C(0x00020000200000c0), 0x1.00001000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffff3f), -0x1.0000100000608p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000400), 0x1.0000100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffffbff), -0x1.0000100002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000401), 0x1.0000100002008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffffbfe), -0x1.000010000201p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000404), 0x1.000010000202p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffffbfb), -0x1.0000100002028p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000410), 0x1.000010000208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffffbef), -0x1.0000100002088p+49, 0x0p+0 },
+{ INT64_C(0x0002000020000480), 0x1.00001000024p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffffb7f), -0x1.0000100002408p+49, 0x0p+0 },
+{ INT64_C(0x0002000020001000), 0x1.0000100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffefff), -0x1.0000100008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020001002), 0x1.000010000801p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffeffd), -0x1.0000100008018p+49, 0x0p+0 },
+{ INT64_C(0x0002000020001020), 0x1.00001000081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffefdf), -0x1.0000100008108p+49, 0x0p+0 },
+{ INT64_C(0x0002000020001100), 0x1.00001000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffeeff), -0x1.0000100008808p+49, 0x0p+0 },
+{ INT64_C(0x0002000020001800), 0x1.000010000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfffe7ff), -0x1.000010000c008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020008000), 0x1.000010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfff7fff), -0x1.0000100040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020008004), 0x1.000010004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfff7ffb), -0x1.0000100040028p+49, 0x0p+0 },
+{ INT64_C(0x0002000020008020), 0x1.00001000401p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfff7fdf), -0x1.0000100040108p+49, 0x0p+0 },
+{ INT64_C(0x0002000020008040), 0x1.00001000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfff7fbf), -0x1.0000100040208p+49, 0x0p+0 },
+{ INT64_C(0x0002000020008200), 0x1.0000100041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfff7dff), -0x1.0000100041008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020008800), 0x1.0000100044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfff77ff), -0x1.0000100044008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010000), 0x1.000010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffeffff), -0x1.0000100080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010002), 0x1.000010008001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffefffd), -0x1.0000100080018p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010008), 0x1.000010008004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffefff7), -0x1.0000100080048p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010010), 0x1.000010008008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffeffef), -0x1.0000100080088p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010020), 0x1.00001000801p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffeffdf), -0x1.0000100080108p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010200), 0x1.0000100081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffefdff), -0x1.0000100081008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020010400), 0x1.0000100082p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffefbff), -0x1.0000100082008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020012000), 0x1.000010009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffedfff), -0x1.0000100090008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020040000), 0x1.00001002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbffff), -0x1.0000100200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020040001), 0x1.0000100200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbfffe), -0x1.000010020001p+49, 0x0p+0 },
+{ INT64_C(0x0002000020040004), 0x1.000010020002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbfffb), -0x1.0000100200028p+49, 0x0p+0 },
+{ INT64_C(0x0002000020040008), 0x1.000010020004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbfff7), -0x1.0000100200048p+49, 0x0p+0 },
+{ INT64_C(0x0002000020040080), 0x1.00001002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbff7f), -0x1.0000100200408p+49, 0x0p+0 },
+{ INT64_C(0x0002000020040400), 0x1.0000100202p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbfbff), -0x1.0000100202008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020041000), 0x1.0000100208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbefff), -0x1.0000100208008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020044000), 0x1.000010022p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffbbfff), -0x1.0000100220008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020048000), 0x1.000010024p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdffb7fff), -0x1.0000100240008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020100000), 0x1.00001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfefffff), -0x1.0000100800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020100002), 0x1.000010080001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfeffffd), -0x1.0000100800018p+49, 0x0p+0 },
+{ INT64_C(0x0002000020100008), 0x1.000010080004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfeffff7), -0x1.0000100800048p+49, 0x0p+0 },
+{ INT64_C(0x0002000020100080), 0x1.00001008004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfefff7f), -0x1.0000100800408p+49, 0x0p+0 },
+{ INT64_C(0x0002000020100800), 0x1.0000100804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfeff7ff), -0x1.0000100804008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020102000), 0x1.000010081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfefdfff), -0x1.0000100810008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020120000), 0x1.00001009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfedffff), -0x1.0000100900008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020180000), 0x1.0000100cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdfe7ffff), -0x1.0000100c00008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020800000), 0x1.0000104p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7fffff), -0x1.0000104000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020800001), 0x1.0000104000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7ffffe), -0x1.000010400001p+49, 0x0p+0 },
+{ INT64_C(0x0002000020800002), 0x1.000010400001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7ffffd), -0x1.0000104000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000020800020), 0x1.00001040001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7fffdf), -0x1.0000104000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000020800100), 0x1.00001040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7ffeff), -0x1.0000104000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000020800400), 0x1.0000104002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7ffbff), -0x1.0000104002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020801000), 0x1.0000104008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7fefff), -0x1.0000104008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020808000), 0x1.000010404p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7f7fff), -0x1.0000104040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020810000), 0x1.000010408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf7effff), -0x1.0000104080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000020900000), 0x1.00001048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdf6fffff), -0x1.0000104800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000000), 0x1.0000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdeffffff), -0x1.0000108000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000002), 0x1.000010800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdefffffd), -0x1.0000108000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000008), 0x1.000010800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdefffff7), -0x1.0000108000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000020), 0x1.00001080001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdeffffdf), -0x1.0000108000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000040), 0x1.00001080002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdeffffbf), -0x1.0000108000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000080), 0x1.00001080004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdeffff7f), -0x1.0000108000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000021000400), 0x1.0000108002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdefffbff), -0x1.0000108002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000021001000), 0x1.0000108008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdeffefff), -0x1.0000108008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000021010000), 0x1.000010808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdefeffff), -0x1.0000108080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000021100000), 0x1.00001088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdeefffff), -0x1.0000108800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000021400000), 0x1.000010ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdebfffff), -0x1.000010a000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022000000), 0x1.000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddffffff), -0x1.0000110000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022000004), 0x1.000011000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddfffffb), -0x1.0000110000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000022000020), 0x1.00001100001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddffffdf), -0x1.0000110000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000022000040), 0x1.00001100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddffffbf), -0x1.0000110000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000022000200), 0x1.0000110001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddfffdff), -0x1.0000110001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022002000), 0x1.000011001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddffdfff), -0x1.0000110010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022008000), 0x1.000011004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddff7fff), -0x1.0000110040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022020000), 0x1.00001101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddfdffff), -0x1.0000110100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022080000), 0x1.00001104p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddf7ffff), -0x1.0000110400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022400000), 0x1.0000112p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffddbfffff), -0x1.0000112000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000022800000), 0x1.0000114p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdd7fffff), -0x1.0000114000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024000000), 0x1.000012p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbffffff), -0x1.0000120000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024000004), 0x1.000012000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbfffffb), -0x1.0000120000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000024000020), 0x1.00001200001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbffffdf), -0x1.0000120000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000024000100), 0x1.00001200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbfffeff), -0x1.0000120000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000024000400), 0x1.0000120002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbfffbff), -0x1.0000120002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024000800), 0x1.0000120004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbfff7ff), -0x1.0000120004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024004000), 0x1.000012002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbffbfff), -0x1.0000120020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024008000), 0x1.000012004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbff7fff), -0x1.0000120040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024010000), 0x1.000012008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbfeffff), -0x1.0000120080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024020000), 0x1.00001201p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbfdffff), -0x1.0000120100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024080000), 0x1.00001204p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbf7ffff), -0x1.0000120400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000024100000), 0x1.00001208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdbefffff), -0x1.0000120800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000025000000), 0x1.0000128p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffdaffffff), -0x1.0000128000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000008), 0x1.000020000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffffff7), -0x1.0000200000048p+49, 0x0p+0 },
+{ INT64_C(0x000200004000000a), 0x1.000020000005p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffffff5), -0x1.0000200000058p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000020), 0x1.00002000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffffdf), -0x1.0000200000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000021), 0x1.0000200000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffffde), -0x1.000020000011p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000030), 0x1.000020000018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffffcf), -0x1.0000200000188p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000080), 0x1.00002000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffff7f), -0x1.0000200000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000088), 0x1.000020000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffff77), -0x1.0000200000448p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000090), 0x1.000020000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffff6f), -0x1.0000200000488p+49, 0x0p+0 },
+{ INT64_C(0x00020000400000c0), 0x1.00002000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffff3f), -0x1.0000200000608p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000800), 0x1.0000200004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffff7ff), -0x1.0000200004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000801), 0x1.0000200004008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffff7fe), -0x1.000020000401p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000810), 0x1.000020000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffff7ef), -0x1.0000200004088p+49, 0x0p+0 },
+{ INT64_C(0x0002000040000880), 0x1.00002000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffff77f), -0x1.0000200004408p+49, 0x0p+0 },
+{ INT64_C(0x0002000040002000), 0x1.000020001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffdfff), -0x1.0000200010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040002004), 0x1.000020001002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffdffb), -0x1.0000200010028p+49, 0x0p+0 },
+{ INT64_C(0x0002000040002020), 0x1.00002000101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffdfdf), -0x1.0000200010108p+49, 0x0p+0 },
+{ INT64_C(0x0002000040002200), 0x1.0000200011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffddff), -0x1.0000200011008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040003000), 0x1.0000200018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbfffcfff), -0x1.0000200018008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010000), 0x1.000020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffeffff), -0x1.0000200080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010001), 0x1.0000200080008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffefffe), -0x1.000020008001p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010002), 0x1.000020008001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffefffd), -0x1.0000200080018p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010004), 0x1.000020008002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffefffb), -0x1.0000200080028p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010040), 0x1.00002000802p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffeffbf), -0x1.0000200080208p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010100), 0x1.00002000808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffefeff), -0x1.0000200080808p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010200), 0x1.0000200081p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffefdff), -0x1.0000200081008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040010800), 0x1.0000200084p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffef7ff), -0x1.0000200084008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040012000), 0x1.000020009p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffedfff), -0x1.0000200090008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040018000), 0x1.00002000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffe7fff), -0x1.00002000c0008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040040000), 0x1.00002002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbffff), -0x1.0000200200008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040040008), 0x1.000020020004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbfff7), -0x1.0000200200048p+49, 0x0p+0 },
+{ INT64_C(0x0002000040040010), 0x1.000020020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbffef), -0x1.0000200200088p+49, 0x0p+0 },
+{ INT64_C(0x0002000040040040), 0x1.00002002002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbffbf), -0x1.0000200200208p+49, 0x0p+0 },
+{ INT64_C(0x0002000040040080), 0x1.00002002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbff7f), -0x1.0000200200408p+49, 0x0p+0 },
+{ INT64_C(0x0002000040040800), 0x1.0000200204p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbf7ff), -0x1.0000200204008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040041000), 0x1.0000200208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffbefff), -0x1.0000200208008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040048000), 0x1.000020024p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbffb7fff), -0x1.0000200240008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040080000), 0x1.00002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff7ffff), -0x1.0000200400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040080001), 0x1.0000200400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff7fffe), -0x1.000020040001p+49, 0x0p+0 },
+{ INT64_C(0x0002000040080010), 0x1.000020040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff7ffef), -0x1.0000200400088p+49, 0x0p+0 },
+{ INT64_C(0x0002000040080040), 0x1.00002004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff7ffbf), -0x1.0000200400208p+49, 0x0p+0 },
+{ INT64_C(0x0002000040080400), 0x1.0000200402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff7fbff), -0x1.0000200402008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040084000), 0x1.000020042p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff7bfff), -0x1.0000200420008p+49, 0x0p+0 },
+{ INT64_C(0x00020000400a0000), 0x1.00002005p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbff5ffff), -0x1.0000200500008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800000), 0x1.0000204p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7fffff), -0x1.0000204000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800002), 0x1.000020400001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7ffffd), -0x1.0000204000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800004), 0x1.000020400002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7ffffb), -0x1.0000204000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800008), 0x1.000020400004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7ffff7), -0x1.0000204000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800020), 0x1.00002040001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7fffdf), -0x1.0000204000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800040), 0x1.00002040002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7fffbf), -0x1.0000204000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800080), 0x1.00002040004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7fff7f), -0x1.0000204000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000040800800), 0x1.0000204004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7ff7ff), -0x1.0000204004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040801000), 0x1.0000204008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7fefff), -0x1.0000204008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040808000), 0x1.000020404p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7f7fff), -0x1.0000204040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040810000), 0x1.000020408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf7effff), -0x1.0000204080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000040900000), 0x1.00002048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbf6fffff), -0x1.0000204800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000041000000), 0x1.0000208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbeffffff), -0x1.0000208000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000041000002), 0x1.000020800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbefffffd), -0x1.0000208000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000041000008), 0x1.000020800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbefffff7), -0x1.0000208000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000041000010), 0x1.000020800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbeffffef), -0x1.0000208000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000041000020), 0x1.00002080001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbeffffdf), -0x1.0000208000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000041000100), 0x1.00002080008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbefffeff), -0x1.0000208000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000041001000), 0x1.0000208008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbeffefff), -0x1.0000208008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000041004000), 0x1.000020802p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbeffbfff), -0x1.0000208020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000041010000), 0x1.000020808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbefeffff), -0x1.0000208080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000041080000), 0x1.00002084p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbef7ffff), -0x1.0000208400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000041400000), 0x1.000020ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffffbebfffff), -0x1.000020a000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050000000), 0x1.000028p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffafffffff), -0x1.0000280000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050000001), 0x1.0000280000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffaffffffe), -0x1.000028000001p+49, 0x0p+0 },
+{ INT64_C(0x0002000050000010), 0x1.000028000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffafffffef), -0x1.0000280000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000050000080), 0x1.00002800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffafffff7f), -0x1.0000280000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000050000400), 0x1.0000280002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffaffffbff), -0x1.0000280002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050000800), 0x1.0000280004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffaffff7ff), -0x1.0000280004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050008000), 0x1.000028004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffafff7fff), -0x1.0000280040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050080000), 0x1.00002804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffaff7ffff), -0x1.0000280400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050100000), 0x1.00002808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffafefffff), -0x1.0000280800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050200000), 0x1.0000281p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffafdfffff), -0x1.0000281000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000050800000), 0x1.0000284p+49, 0x0p+0 },
+{ INT64_C(0xfffdffffaf7fffff), -0x1.0000284000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000058000000), 0x1.00002cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffffa7ffffff), -0x1.00002c0000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000004), 0x1.000200000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfffffffb), -0x1.0002000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000010), 0x1.000200000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffffef), -0x1.0002000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000011), 0x1.0002000000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffffee), -0x1.000200000009p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000018), 0x1.00020000000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffffe7), -0x1.00020000000c8p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000020), 0x1.00020000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffffdf), -0x1.0002000000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000021), 0x1.0002000000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffffde), -0x1.000200000011p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000028), 0x1.000200000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffffd7), -0x1.0002000000148p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000100), 0x1.00020000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfffffeff), -0x1.0002000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000104), 0x1.000200000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfffffefb), -0x1.0002000000828p+49, 0x0p+0 },
+{ INT64_C(0x0002000400000140), 0x1.0002000000ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfffffebf), -0x1.0002000000a08p+49, 0x0p+0 },
+{ INT64_C(0x0002000400001000), 0x1.0002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffefff), -0x1.0002000008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400001008), 0x1.000200000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffeff7), -0x1.0002000008048p+49, 0x0p+0 },
+{ INT64_C(0x0002000400001040), 0x1.00020000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffefbf), -0x1.0002000008208p+49, 0x0p+0 },
+{ INT64_C(0x0002000400001200), 0x1.0002000009p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffedff), -0x1.0002000009008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400001800), 0x1.000200000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffffe7ff), -0x1.000200000c008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400008000), 0x1.000200004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff7fff), -0x1.0002000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400008001), 0x1.0002000040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff7ffe), -0x1.000200004001p+49, 0x0p+0 },
+{ INT64_C(0x0002000400008008), 0x1.000200004004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff7ff7), -0x1.0002000040048p+49, 0x0p+0 },
+{ INT64_C(0x0002000400008040), 0x1.00020000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff7fbf), -0x1.0002000040208p+49, 0x0p+0 },
+{ INT64_C(0x0002000400008400), 0x1.0002000042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff7bff), -0x1.0002000042008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400009000), 0x1.0002000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff6fff), -0x1.0002000048008p+49, 0x0p+0 },
+{ INT64_C(0x000200040000a000), 0x1.000200005p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbffff5fff), -0x1.0002000050008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080000), 0x1.00020004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7ffff), -0x1.0002000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080001), 0x1.0002000400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7fffe), -0x1.000200040001p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080002), 0x1.000200040001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7fffd), -0x1.0002000400018p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080008), 0x1.000200040004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7fff7), -0x1.0002000400048p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080020), 0x1.00020004001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7ffdf), -0x1.0002000400108p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080040), 0x1.00020004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7ffbf), -0x1.0002000400208p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080400), 0x1.0002000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7fbff), -0x1.0002000402008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400080800), 0x1.0002000404p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7f7ff), -0x1.0002000404008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400081000), 0x1.0002000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff7efff), -0x1.0002000408008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400090000), 0x1.000200048p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff6ffff), -0x1.0002000480008p+49, 0x0p+0 },
+{ INT64_C(0x00020004000c0000), 0x1.00020006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfff3ffff), -0x1.0002000600008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400800000), 0x1.0002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7fffff), -0x1.0002004000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400800002), 0x1.000200400001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7ffffd), -0x1.0002004000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000400800008), 0x1.000200400004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7ffff7), -0x1.0002004000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000400800010), 0x1.000200400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7fffef), -0x1.0002004000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000400800080), 0x1.00020040004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7fff7f), -0x1.0002004000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000400800800), 0x1.0002004004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7ff7ff), -0x1.0002004004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400808000), 0x1.000200404p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7f7fff), -0x1.0002004040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400820000), 0x1.00020041p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff7dffff), -0x1.0002004100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000400880000), 0x1.00020044p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbff77ffff), -0x1.0002004400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000000), 0x1.000201p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdffffff), -0x1.0002010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000002), 0x1.000201000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdfffffd), -0x1.0002010000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000008), 0x1.000201000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdfffff7), -0x1.0002010000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000020), 0x1.00020100001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdffffdf), -0x1.0002010000108p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000200), 0x1.0002010001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdfffdff), -0x1.0002010001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000400), 0x1.0002010002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdfffbff), -0x1.0002010002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402000800), 0x1.0002010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdfff7ff), -0x1.0002010004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402002000), 0x1.000201001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdffdfff), -0x1.0002010010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402020000), 0x1.00020101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfdfdffff), -0x1.0002010100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000402200000), 0x1.0002011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbfddfffff), -0x1.0002011000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408000000), 0x1.000204p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7ffffff), -0x1.0002040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408000008), 0x1.000204000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7fffff7), -0x1.0002040000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000408000040), 0x1.00020400002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7ffffbf), -0x1.0002040000208p+49, 0x0p+0 },
+{ INT64_C(0x0002000408000400), 0x1.0002040002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7fffbff), -0x1.0002040002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408000800), 0x1.0002040004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7fff7ff), -0x1.0002040004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408004000), 0x1.000204002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7ffbfff), -0x1.0002040020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408008000), 0x1.000204004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7ff7fff), -0x1.0002040040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408080000), 0x1.00020404p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf7f7ffff), -0x1.0002040400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000408800000), 0x1.0002044p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf77fffff), -0x1.0002044000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000409000000), 0x1.0002048p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf6ffffff), -0x1.0002048000008p+49, 0x0p+0 },
+{ INT64_C(0x000200040a000000), 0x1.000205p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf5ffffff), -0x1.0002050000008p+49, 0x0p+0 },
+{ INT64_C(0x000200040c000000), 0x1.000206p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbf3ffffff), -0x1.0002060000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440000000), 0x1.00022p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbfffffff), -0x1.0002200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440000004), 0x1.000220000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbffffffb), -0x1.0002200000028p+49, 0x0p+0 },
+{ INT64_C(0x0002000440000008), 0x1.000220000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbffffff7), -0x1.0002200000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000440000080), 0x1.00022000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbfffff7f), -0x1.0002200000408p+49, 0x0p+0 },
+{ INT64_C(0x0002000440000200), 0x1.0002200001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbffffdff), -0x1.0002200001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440000800), 0x1.0002200004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbffff7ff), -0x1.0002200004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440004000), 0x1.000220002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbfffbfff), -0x1.0002200020008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440010000), 0x1.000220008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbffeffff), -0x1.0002200080008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440020000), 0x1.00022001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbffdffff), -0x1.0002200100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000440200000), 0x1.0002201p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbfdfffff), -0x1.0002201000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000441000000), 0x1.0002208p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbeffffff), -0x1.0002208000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000444000000), 0x1.000222p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbbbffffff), -0x1.0002220000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000448000000), 0x1.000224p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffbb7ffffff), -0x1.0002240000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000460000000), 0x1.00023p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb9fffffff), -0x1.0002300000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000000), 0x1.00024p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7fffffff), -0x1.0002400000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000002), 0x1.000240000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7ffffffd), -0x1.0002400000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000008), 0x1.000240000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7ffffff7), -0x1.0002400000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000010), 0x1.000240000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7fffffef), -0x1.0002400000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000100), 0x1.00024000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7ffffeff), -0x1.0002400000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000200), 0x1.0002400001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7ffffdff), -0x1.0002400001008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480000800), 0x1.0002400004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7ffff7ff), -0x1.0002400004008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480001000), 0x1.0002400008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7fffefff), -0x1.0002400008008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480008000), 0x1.000240004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7fff7fff), -0x1.0002400040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480080000), 0x1.00024004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7ff7ffff), -0x1.0002400400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480100000), 0x1.00024008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7fefffff), -0x1.0002400800008p+49, 0x0p+0 },
+{ INT64_C(0x0002000480800000), 0x1.0002404p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7f7fffff), -0x1.0002404000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000481000000), 0x1.0002408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7effffff), -0x1.0002408000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000484000000), 0x1.000242p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb7bffffff), -0x1.0002420000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000488000000), 0x1.000244p+49, 0x0p+0 },
+{ INT64_C(0xfffdfffb77ffffff), -0x1.0002440000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600000000), 0x1.0003p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9ffffffff), -0x1.0003000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600000002), 0x1.000300000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fffffffd), -0x1.0003000000018p+49, 0x0p+0 },
+{ INT64_C(0x0002000600000008), 0x1.000300000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fffffff7), -0x1.0003000000048p+49, 0x0p+0 },
+{ INT64_C(0x0002000600000010), 0x1.000300000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9ffffffef), -0x1.0003000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002000600000100), 0x1.00030000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fffffeff), -0x1.0003000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002000600000400), 0x1.0003000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fffffbff), -0x1.0003000002008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600002000), 0x1.000300001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9ffffdfff), -0x1.0003000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600008000), 0x1.000300004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9ffff7fff), -0x1.0003000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600020000), 0x1.00030001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fffdffff), -0x1.0003000100008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600080000), 0x1.00030004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fff7ffff), -0x1.0003000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002000600400000), 0x1.0003002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9ffbfffff), -0x1.0003002000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000601000000), 0x1.0003008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9feffffff), -0x1.0003008000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000602000000), 0x1.000301p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9fdffffff), -0x1.0003010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000608000000), 0x1.000304p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9f7ffffff), -0x1.0003040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002000640000000), 0x1.00032p+49, 0x0p+0 },
+{ INT64_C(0xfffdfff9bfffffff), -0x1.0003200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000001), 0x1.0010000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffffe), -0x1.001000000001p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000010), 0x1.001000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffef), -0x1.0010000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000011), 0x1.0010000000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffee), -0x1.001000000009p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000014), 0x1.00100000000ap+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffeb), -0x1.00100000000a8p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000018), 0x1.00100000000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffe7), -0x1.00100000000c8p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000020), 0x1.00100000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffdf), -0x1.0010000000108p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000021), 0x1.0010000000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffde), -0x1.001000000011p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000028), 0x1.001000000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffd7), -0x1.0010000000148p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000030), 0x1.001000000018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffffcf), -0x1.0010000000188p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000100), 0x1.00100000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffeff), -0x1.0010000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000104), 0x1.001000000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffefb), -0x1.0010000000828p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000110), 0x1.001000000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffeef), -0x1.0010000000888p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000180), 0x1.0010000000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffe7f), -0x1.0010000000c08p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000200), 0x1.0010000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffdff), -0x1.0010000001008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000202), 0x1.001000000101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffdfd), -0x1.0010000001018p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000204), 0x1.001000000102p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffdfb), -0x1.0010000001028p+49, 0x0p+0 },
+{ INT64_C(0x0002002000000220), 0x1.00100000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffffffddf), -0x1.0010000001108p+49, 0x0p+0 },
+{ INT64_C(0x0002002000002000), 0x1.001000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffdfff), -0x1.0010000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000002001), 0x1.0010000010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffdffe), -0x1.001000001001p+49, 0x0p+0 },
+{ INT64_C(0x0002002000002004), 0x1.001000001002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffdffb), -0x1.0010000010028p+49, 0x0p+0 },
+{ INT64_C(0x0002002000002040), 0x1.00100000102p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffdfbf), -0x1.0010000010208p+49, 0x0p+0 },
+{ INT64_C(0x0002002000002100), 0x1.00100000108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffdeff), -0x1.0010000010808p+49, 0x0p+0 },
+{ INT64_C(0x0002002000003000), 0x1.0010000018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffffcfff), -0x1.0010000018008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008000), 0x1.001000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff7fff), -0x1.0010000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008002), 0x1.001000004001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff7ffd), -0x1.0010000040018p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008004), 0x1.001000004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff7ffb), -0x1.0010000040028p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008010), 0x1.001000004008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff7fef), -0x1.0010000040088p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008080), 0x1.00100000404p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff7f7f), -0x1.0010000040408p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008200), 0x1.0010000041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff7dff), -0x1.0010000041008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000008800), 0x1.0010000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff77ff), -0x1.0010000044008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000009000), 0x1.0010000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffff6fff), -0x1.0010000048008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000080000), 0x1.00100004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7ffff), -0x1.0010000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000080004), 0x1.001000040002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7fffb), -0x1.0010000400028p+49, 0x0p+0 },
+{ INT64_C(0x0002002000080010), 0x1.001000040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7ffef), -0x1.0010000400088p+49, 0x0p+0 },
+{ INT64_C(0x0002002000080100), 0x1.00100004008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7feff), -0x1.0010000400808p+49, 0x0p+0 },
+{ INT64_C(0x0002002000080400), 0x1.0010000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7fbff), -0x1.0010000402008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000080800), 0x1.0010000404p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7f7ff), -0x1.0010000404008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000081000), 0x1.0010000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7efff), -0x1.0010000408008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000082000), 0x1.001000041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff7dfff), -0x1.0010000410008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000090000), 0x1.001000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff6ffff), -0x1.0010000480008p+49, 0x0p+0 },
+{ INT64_C(0x00020020000a0000), 0x1.00100005p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffff5ffff), -0x1.0010000500008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400000), 0x1.0010002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbfffff), -0x1.0010002000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400001), 0x1.0010002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbffffe), -0x1.001000200001p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400002), 0x1.001000200001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbffffd), -0x1.0010002000018p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400008), 0x1.001000200004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbffff7), -0x1.0010002000048p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400010), 0x1.001000200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbfffef), -0x1.0010002000088p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400080), 0x1.00100020004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbfff7f), -0x1.0010002000408p+49, 0x0p+0 },
+{ INT64_C(0x0002002000400200), 0x1.0010002001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbffdff), -0x1.0010002001008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000402000), 0x1.001000201p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbfdfff), -0x1.0010002010008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000404000), 0x1.001000202p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbfbfff), -0x1.0010002020008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000410000), 0x1.001000208p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbeffff), -0x1.0010002080008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000440000), 0x1.00100022p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffbbffff), -0x1.0010002200008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000500000), 0x1.00100028p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfffafffff), -0x1.0010002800008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000800000), 0x1.0010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7fffff), -0x1.0010004000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000800004), 0x1.001000400002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7ffffb), -0x1.0010004000028p+49, 0x0p+0 },
+{ INT64_C(0x0002002000800020), 0x1.00100040001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7fffdf), -0x1.0010004000108p+49, 0x0p+0 },
+{ INT64_C(0x0002002000800040), 0x1.00100040002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7fffbf), -0x1.0010004000208p+49, 0x0p+0 },
+{ INT64_C(0x0002002000800100), 0x1.00100040008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7ffeff), -0x1.0010004000808p+49, 0x0p+0 },
+{ INT64_C(0x0002002000800800), 0x1.0010004004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7ff7ff), -0x1.0010004004008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000804000), 0x1.001000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7fbfff), -0x1.0010004020008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000820000), 0x1.00100041p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff7dffff), -0x1.0010004100008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000900000), 0x1.00100048p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff6fffff), -0x1.0010004800008p+49, 0x0p+0 },
+{ INT64_C(0x0002002000c00000), 0x1.0010006p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfff3fffff), -0x1.0010006000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002002000000), 0x1.001001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdffffff), -0x1.0010010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002002000004), 0x1.001001000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdfffffb), -0x1.0010010000028p+49, 0x0p+0 },
+{ INT64_C(0x0002002002000010), 0x1.001001000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdffffef), -0x1.0010010000088p+49, 0x0p+0 },
+{ INT64_C(0x0002002002000100), 0x1.00100100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdfffeff), -0x1.0010010000808p+49, 0x0p+0 },
+{ INT64_C(0x0002002002001000), 0x1.0010010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdffefff), -0x1.0010010008008p+49, 0x0p+0 },
+{ INT64_C(0x0002002002008000), 0x1.001001004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdff7fff), -0x1.0010010040008p+49, 0x0p+0 },
+{ INT64_C(0x0002002002020000), 0x1.00100101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdfdffff), -0x1.0010010100008p+49, 0x0p+0 },
+{ INT64_C(0x0002002002100000), 0x1.00100108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffdefffff), -0x1.0010010800008p+49, 0x0p+0 },
+{ INT64_C(0x0002002002200000), 0x1.0010011p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffddfffff), -0x1.0010011000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002003000000), 0x1.0010018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdffcffffff), -0x1.0010018000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020000000), 0x1.00101p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdfffffff), -0x1.0010100000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020000008), 0x1.001010000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdffffff7), -0x1.0010100000048p+49, 0x0p+0 },
+{ INT64_C(0x0002002020000080), 0x1.00101000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdfffff7f), -0x1.0010100000408p+49, 0x0p+0 },
+{ INT64_C(0x0002002020000100), 0x1.00101000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdffffeff), -0x1.0010100000808p+49, 0x0p+0 },
+{ INT64_C(0x0002002020000200), 0x1.0010100001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdffffdff), -0x1.0010100001008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020001000), 0x1.0010100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdfffefff), -0x1.0010100008008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020008000), 0x1.001010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdfff7fff), -0x1.0010100040008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020020000), 0x1.00101001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdffdffff), -0x1.0010100100008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020040000), 0x1.00101002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdffbffff), -0x1.0010100200008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020100000), 0x1.00101008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdfefffff), -0x1.0010100800008p+49, 0x0p+0 },
+{ INT64_C(0x0002002020400000), 0x1.0010102p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdfbfffff), -0x1.0010102000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002024000000), 0x1.001012p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdfdbffffff), -0x1.0010120000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100000000), 0x1.00108p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeffffffff), -0x1.0010800000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100000008), 0x1.001080000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdefffffff7), -0x1.0010800000048p+49, 0x0p+0 },
+{ INT64_C(0x0002002100000040), 0x1.00108000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeffffffbf), -0x1.0010800000208p+49, 0x0p+0 },
+{ INT64_C(0x0002002100000080), 0x1.00108000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeffffff7f), -0x1.0010800000408p+49, 0x0p+0 },
+{ INT64_C(0x0002002100000800), 0x1.0010800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdefffff7ff), -0x1.0010800004008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100001000), 0x1.0010800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeffffefff), -0x1.0010800008008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100008000), 0x1.001080004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeffff7fff), -0x1.0010800040008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100040000), 0x1.00108002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdefffbffff), -0x1.0010800200008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100080000), 0x1.00108004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdefff7ffff), -0x1.0010800400008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100200000), 0x1.0010801p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeffdfffff), -0x1.0010801000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002100800000), 0x1.0010804p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdeff7fffff), -0x1.0010804000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002101000000), 0x1.0010808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdefeffffff), -0x1.0010808000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002104000000), 0x1.001082p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdefbffffff), -0x1.0010820000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002108000000), 0x1.001084p+49, 0x0p+0 },
+{ INT64_C(0xfffdffdef7ffffff), -0x1.0010840000008p+49, 0x0p+0 },
+{ INT64_C(0x0002002180000000), 0x1.0010cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffde7fffffff), -0x1.0010c00000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003000000000), 0x1.0018p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcfffffffff), -0x1.0018000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003000000004), 0x1.001800000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcffffffffb), -0x1.0018000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002003000000020), 0x1.00180000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcfffffffdf), -0x1.0018000000108p+49, 0x0p+0 },
+{ INT64_C(0x0002003000000040), 0x1.00180000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcfffffffbf), -0x1.0018000000208p+49, 0x0p+0 },
+{ INT64_C(0x0002003000000100), 0x1.00180000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcffffffeff), -0x1.0018000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002003000000800), 0x1.0018000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcffffff7ff), -0x1.0018000004008p+49, 0x0p+0 },
+{ INT64_C(0x0002003000008000), 0x1.001800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcfffff7fff), -0x1.0018000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002003000040000), 0x1.00180002p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcffffbffff), -0x1.0018000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002003000080000), 0x1.00180004p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcffff7ffff), -0x1.0018000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002003000200000), 0x1.0018001p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcfffdfffff), -0x1.0018001000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003002000000), 0x1.001801p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcffdffffff), -0x1.0018010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003010000000), 0x1.001808p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcfefffffff), -0x1.0018080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003080000000), 0x1.00184p+49, 0x0p+0 },
+{ INT64_C(0xfffdffcf7fffffff), -0x1.0018400000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003100000000), 0x1.00188p+49, 0x0p+0 },
+{ INT64_C(0xfffdffceffffffff), -0x1.0018800000008p+49, 0x0p+0 },
+{ INT64_C(0x0002003800000000), 0x1.001cp+49, 0x0p+0 },
+{ INT64_C(0xfffdffc7ffffffff), -0x1.001c000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000008), 0x1.010000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffffff7), -0x1.0100000000048p+49, 0x0p+0 },
+{ INT64_C(0x000202000000000c), 0x1.010000000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffffff3), -0x1.0100000000068p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000040), 0x1.01000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffffbf), -0x1.0100000000208p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000048), 0x1.010000000024p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffffb7), -0x1.0100000000248p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000050), 0x1.010000000028p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffffaf), -0x1.0100000000288p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000400), 0x1.0100000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffffbff), -0x1.0100000002008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000404), 0x1.010000000202p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffffbfb), -0x1.0100000002028p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000420), 0x1.01000000021p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffffbdf), -0x1.0100000002108p+49, 0x0p+0 },
+{ INT64_C(0x0002020000000600), 0x1.0100000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffff9ff), -0x1.0100000003008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000002000), 0x1.010000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffdfff), -0x1.0100000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000002004), 0x1.010000001002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffdffb), -0x1.0100000010028p+49, 0x0p+0 },
+{ INT64_C(0x0002020000002040), 0x1.01000000102p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffdfbf), -0x1.0100000010208p+49, 0x0p+0 },
+{ INT64_C(0x0002020000002200), 0x1.0100000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffffddff), -0x1.0100000011008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000008000), 0x1.010000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff7fff), -0x1.0100000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000008004), 0x1.010000004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff7ffb), -0x1.0100000040028p+49, 0x0p+0 },
+{ INT64_C(0x0002020000008008), 0x1.010000004004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff7ff7), -0x1.0100000040048p+49, 0x0p+0 },
+{ INT64_C(0x0002020000008040), 0x1.01000000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff7fbf), -0x1.0100000040208p+49, 0x0p+0 },
+{ INT64_C(0x0002020000008200), 0x1.0100000041p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff7dff), -0x1.0100000041008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000008400), 0x1.0100000042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff7bff), -0x1.0100000042008p+49, 0x0p+0 },
+{ INT64_C(0x000202000000c000), 0x1.010000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffff3fff), -0x1.0100000060008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040000), 0x1.01000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbffff), -0x1.0100000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040001), 0x1.0100000200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbfffe), -0x1.010000020001p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040002), 0x1.010000020001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbfffd), -0x1.0100000200018p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040004), 0x1.010000020002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbfffb), -0x1.0100000200028p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040010), 0x1.010000020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbffef), -0x1.0100000200088p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040080), 0x1.01000002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbff7f), -0x1.0100000200408p+49, 0x0p+0 },
+{ INT64_C(0x0002020000040800), 0x1.0100000204p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbf7ff), -0x1.0100000204008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000044000), 0x1.010000022p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffbbfff), -0x1.0100000220008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000048000), 0x1.010000024p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffffb7fff), -0x1.0100000240008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000060000), 0x1.01000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff9ffff), -0x1.0100000300008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000080000), 0x1.01000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7ffff), -0x1.0100000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000080008), 0x1.010000040004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7fff7), -0x1.0100000400048p+49, 0x0p+0 },
+{ INT64_C(0x0002020000080040), 0x1.01000004002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7ffbf), -0x1.0100000400208p+49, 0x0p+0 },
+{ INT64_C(0x0002020000080200), 0x1.0100000401p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7fdff), -0x1.0100000401008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000080400), 0x1.0100000402p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7fbff), -0x1.0100000402008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000081000), 0x1.0100000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7efff), -0x1.0100000408008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000084000), 0x1.010000042p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff7bfff), -0x1.0100000420008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000088000), 0x1.010000044p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff77fff), -0x1.0100000440008p+49, 0x0p+0 },
+{ INT64_C(0x00020200000c0000), 0x1.01000006p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffff3ffff), -0x1.0100000600008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000100000), 0x1.01000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffefffff), -0x1.0100000800008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000100001), 0x1.0100000800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffeffffe), -0x1.010000080001p+49, 0x0p+0 },
+{ INT64_C(0x0002020000100008), 0x1.010000080004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffeffff7), -0x1.0100000800048p+49, 0x0p+0 },
+{ INT64_C(0x0002020000100080), 0x1.01000008004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffefff7f), -0x1.0100000800408p+49, 0x0p+0 },
+{ INT64_C(0x0002020000100100), 0x1.01000008008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffeffeff), -0x1.0100000800808p+49, 0x0p+0 },
+{ INT64_C(0x0002020000100400), 0x1.0100000802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffeffbff), -0x1.0100000802008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000104000), 0x1.010000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffefbfff), -0x1.0100000820008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000110000), 0x1.010000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffeeffff), -0x1.0100000880008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000200000), 0x1.0100001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffdfffff), -0x1.0100001000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000200008), 0x1.010000100004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffdffff7), -0x1.0100001000048p+49, 0x0p+0 },
+{ INT64_C(0x0002020000200080), 0x1.01000010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffdfff7f), -0x1.0100001000408p+49, 0x0p+0 },
+{ INT64_C(0x0002020000200800), 0x1.0100001004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffdff7ff), -0x1.0100001004008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000201000), 0x1.0100001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffdfefff), -0x1.0100001008008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000202000), 0x1.010000101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffdfdfff), -0x1.0100001010008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000220000), 0x1.01000011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffddffff), -0x1.0100001100008p+49, 0x0p+0 },
+{ INT64_C(0x0002020000280000), 0x1.01000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffffd7ffff), -0x1.0100001400008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001000000), 0x1.0100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffeffffff), -0x1.0100008000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001000002), 0x1.010000800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffefffffd), -0x1.0100008000018p+49, 0x0p+0 },
+{ INT64_C(0x0002020001000010), 0x1.010000800008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffeffffef), -0x1.0100008000088p+49, 0x0p+0 },
+{ INT64_C(0x0002020001000040), 0x1.01000080002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffeffffbf), -0x1.0100008000208p+49, 0x0p+0 },
+{ INT64_C(0x0002020001000400), 0x1.0100008002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffefffbff), -0x1.0100008002008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001000800), 0x1.0100008004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffefff7ff), -0x1.0100008004008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001001000), 0x1.0100008008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffeffefff), -0x1.0100008008008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001008000), 0x1.010000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffeff7fff), -0x1.0100008040008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001010000), 0x1.010000808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffefeffff), -0x1.0100008080008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001040000), 0x1.01000082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffefbffff), -0x1.0100008200008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001100000), 0x1.01000088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffeefffff), -0x1.0100008800008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001200000), 0x1.0100009p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffedfffff), -0x1.0100009000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020001800000), 0x1.010000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffe7fffff), -0x1.010000c000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004000000), 0x1.010002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbffffff), -0x1.0100020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004000004), 0x1.010002000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbfffffb), -0x1.0100020000028p+49, 0x0p+0 },
+{ INT64_C(0x0002020004000010), 0x1.010002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbffffef), -0x1.0100020000088p+49, 0x0p+0 },
+{ INT64_C(0x0002020004000020), 0x1.01000200001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbffffdf), -0x1.0100020000108p+49, 0x0p+0 },
+{ INT64_C(0x0002020004000200), 0x1.0100020001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbfffdff), -0x1.0100020001008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004001000), 0x1.0100020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbffefff), -0x1.0100020008008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004008000), 0x1.010002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbff7fff), -0x1.0100020040008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004010000), 0x1.010002008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbfeffff), -0x1.0100020080008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004100000), 0x1.01000208p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffbefffff), -0x1.0100020800008p+49, 0x0p+0 },
+{ INT64_C(0x0002020004800000), 0x1.0100024p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfffb7fffff), -0x1.0100024000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020010000000), 0x1.010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffefffffff), -0x1.0100080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020010000002), 0x1.010008000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffeffffffd), -0x1.0100080000018p+49, 0x0p+0 },
+{ INT64_C(0x0002020010000004), 0x1.010008000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffeffffffb), -0x1.0100080000028p+49, 0x0p+0 },
+{ INT64_C(0x0002020010000040), 0x1.01000800002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffefffffbf), -0x1.0100080000208p+49, 0x0p+0 },
+{ INT64_C(0x0002020010000400), 0x1.0100080002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffeffffbff), -0x1.0100080002008p+49, 0x0p+0 },
+{ INT64_C(0x0002020010004000), 0x1.010008002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffefffbfff), -0x1.0100080020008p+49, 0x0p+0 },
+{ INT64_C(0x0002020010040000), 0x1.01000802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffeffbffff), -0x1.0100080200008p+49, 0x0p+0 },
+{ INT64_C(0x0002020010080000), 0x1.01000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffeff7ffff), -0x1.0100080400008p+49, 0x0p+0 },
+{ INT64_C(0x0002020010800000), 0x1.0100084p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffef7fffff), -0x1.0100084000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020018000000), 0x1.01000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffe7ffffff), -0x1.01000c0000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020020000000), 0x1.01001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdfffffff), -0x1.0100100000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020020000002), 0x1.010010000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdffffffd), -0x1.0100100000018p+49, 0x0p+0 },
+{ INT64_C(0x0002020020000004), 0x1.010010000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdffffffb), -0x1.0100100000028p+49, 0x0p+0 },
+{ INT64_C(0x0002020020000010), 0x1.010010000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdfffffef), -0x1.0100100000088p+49, 0x0p+0 },
+{ INT64_C(0x0002020020000040), 0x1.01001000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdfffffbf), -0x1.0100100000208p+49, 0x0p+0 },
+{ INT64_C(0x0002020020000100), 0x1.01001000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdffffeff), -0x1.0100100000808p+49, 0x0p+0 },
+{ INT64_C(0x0002020020001000), 0x1.0100100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdfffefff), -0x1.0100100008008p+49, 0x0p+0 },
+{ INT64_C(0x0002020020008000), 0x1.010010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdfff7fff), -0x1.0100100040008p+49, 0x0p+0 },
+{ INT64_C(0x0002020020010000), 0x1.010010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdffeffff), -0x1.0100100080008p+49, 0x0p+0 },
+{ INT64_C(0x0002020020100000), 0x1.01001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdfefffff), -0x1.0100100800008p+49, 0x0p+0 },
+{ INT64_C(0x0002020021000000), 0x1.0100108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffdeffffff), -0x1.0100108000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020030000000), 0x1.010018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdffcfffffff), -0x1.0100180000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200000000), 0x1.0101p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdffffffff), -0x1.0101000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200000008), 0x1.010100000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdfffffff7), -0x1.0101000000048p+49, 0x0p+0 },
+{ INT64_C(0x0002020200000040), 0x1.01010000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdffffffbf), -0x1.0101000000208p+49, 0x0p+0 },
+{ INT64_C(0x0002020200000100), 0x1.01010000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdfffffeff), -0x1.0101000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002020200001000), 0x1.0101000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdffffefff), -0x1.0101000008008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200002000), 0x1.010100001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdffffdfff), -0x1.0101000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200004000), 0x1.010100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdffffbfff), -0x1.0101000020008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200020000), 0x1.01010001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdfffdffff), -0x1.0101000100008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200080000), 0x1.01010004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdfff7ffff), -0x1.0101000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002020200800000), 0x1.0101004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdff7fffff), -0x1.0101004000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020204000000), 0x1.010102p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdfbffffff), -0x1.0101020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020210000000), 0x1.010108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfdefffffff), -0x1.0101080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002020220000000), 0x1.01011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdfddfffffff), -0x1.0101100000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000000), 0x1.0108p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefffffffff), -0x1.0108000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000001), 0x1.0108000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeffffffffe), -0x1.010800000001p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000002), 0x1.010800000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeffffffffd), -0x1.0108000000018p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000004), 0x1.010800000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeffffffffb), -0x1.0108000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000010), 0x1.010800000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefffffffef), -0x1.0108000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000080), 0x1.01080000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefffffff7f), -0x1.0108000000408p+49, 0x0p+0 },
+{ INT64_C(0x0002021000000800), 0x1.0108000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeffffff7ff), -0x1.0108000004008p+49, 0x0p+0 },
+{ INT64_C(0x0002021000002000), 0x1.010800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefffffdfff), -0x1.0108000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002021000008000), 0x1.010800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefffff7fff), -0x1.0108000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002021000080000), 0x1.01080004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeffff7ffff), -0x1.0108000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002021000400000), 0x1.0108002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefffbfffff), -0x1.0108002000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021004000000), 0x1.010802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeffbffffff), -0x1.0108020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021008000000), 0x1.010804p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeff7ffffff), -0x1.0108040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021010000000), 0x1.010808p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefefffffff), -0x1.0108080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021040000000), 0x1.01082p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdefbfffffff), -0x1.0108200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002021100000000), 0x1.01088p+49, 0x0p+0 },
+{ INT64_C(0xfffdfdeeffffffff), -0x1.0108800000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000000000), 0x1.011p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddfffffffff), -0x1.0110000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000000001), 0x1.0110000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffffffffe), -0x1.011000000001p+49, 0x0p+0 },
+{ INT64_C(0x0002022000000004), 0x1.011000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffffffffb), -0x1.0110000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002022000000020), 0x1.01100000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddfffffffdf), -0x1.0110000000108p+49, 0x0p+0 },
+{ INT64_C(0x0002022000000200), 0x1.0110000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffffffdff), -0x1.0110000001008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000000800), 0x1.0110000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffffff7ff), -0x1.0110000004008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000008000), 0x1.011000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddfffff7fff), -0x1.0110000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000010000), 0x1.011000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffffeffff), -0x1.0110000080008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000040000), 0x1.01100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffffbffff), -0x1.0110000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002022000200000), 0x1.0110001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddfffdfffff), -0x1.0110001000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022002000000), 0x1.011001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddffdffffff), -0x1.0110010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022008000000), 0x1.011004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddff7ffffff), -0x1.0110040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022010000000), 0x1.011008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddfefffffff), -0x1.0110080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022040000000), 0x1.01102p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddfbfffffff), -0x1.0110200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022080000000), 0x1.01104p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddf7fffffff), -0x1.0110400000008p+49, 0x0p+0 },
+{ INT64_C(0x0002022400000000), 0x1.0112p+49, 0x0p+0 },
+{ INT64_C(0xfffdfddbffffffff), -0x1.0112000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000000000), 0x1.018p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffffffffff), -0x1.0180000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000000002), 0x1.018000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffffffffd), -0x1.0180000000018p+49, 0x0p+0 },
+{ INT64_C(0x0002030000000010), 0x1.018000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffffffffef), -0x1.0180000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002030000000040), 0x1.01800000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffffffffbf), -0x1.0180000000208p+49, 0x0p+0 },
+{ INT64_C(0x0002030000000400), 0x1.0180000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffffffbff), -0x1.0180000002008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000000800), 0x1.0180000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffffff7ff), -0x1.0180000004008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000002000), 0x1.018000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffffffdfff), -0x1.0180000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000004000), 0x1.018000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffffffbfff), -0x1.0180000020008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000040000), 0x1.01800002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffffbffff), -0x1.0180000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002030000400000), 0x1.0180002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffffbfffff), -0x1.0180002000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030001000000), 0x1.0180008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffeffffff), -0x1.0180008000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030002000000), 0x1.018001p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffdffffff), -0x1.0180010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030004000000), 0x1.018002p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfffbffffff), -0x1.0180020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030010000000), 0x1.018008p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffefffffff), -0x1.0180080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030040000000), 0x1.01802p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcffbfffffff), -0x1.0180200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002030400000000), 0x1.0182p+49, 0x0p+0 },
+{ INT64_C(0xfffdfcfbffffffff), -0x1.0182000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002034000000000), 0x1.01ap+49, 0x0p+0 },
+{ INT64_C(0xfffdfcbfffffffff), -0x1.01a0000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000004), 0x1.080000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffffffb), -0x1.0800000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000006), 0x1.080000000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffffff9), -0x1.0800000000038p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000040), 0x1.08000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffffbf), -0x1.0800000000208p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000042), 0x1.080000000021p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffffbd), -0x1.0800000000218p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000044), 0x1.080000000022p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffffbb), -0x1.0800000000228p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000400), 0x1.0800000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffffbff), -0x1.0800000002008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000401), 0x1.0800000002008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffffbfe), -0x1.080000000201p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000408), 0x1.080000000204p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffffbf7), -0x1.0800000002048p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000420), 0x1.08000000021p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffffbdf), -0x1.0800000002108p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000600), 0x1.0800000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffff9ff), -0x1.0800000003008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000800), 0x1.0800000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffff7ff), -0x1.0800000004008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000808), 0x1.080000000404p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffff7f7), -0x1.0800000004048p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000810), 0x1.080000000408p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffff7ef), -0x1.0800000004088p+49, 0x0p+0 },
+{ INT64_C(0x0002100000000900), 0x1.08000000048p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffff6ff), -0x1.0800000004808p+49, 0x0p+0 },
+{ INT64_C(0x0002100000004000), 0x1.080000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffbfff), -0x1.0800000020008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000004004), 0x1.080000002002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffbffb), -0x1.0800000020028p+49, 0x0p+0 },
+{ INT64_C(0x0002100000004020), 0x1.08000000201p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffbfdf), -0x1.0800000020108p+49, 0x0p+0 },
+{ INT64_C(0x0002100000004100), 0x1.08000000208p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffbeff), -0x1.0800000020808p+49, 0x0p+0 },
+{ INT64_C(0x0002100000004400), 0x1.0800000022p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffffbbff), -0x1.0800000022008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000006000), 0x1.080000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffff9fff), -0x1.0800000030008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000010000), 0x1.080000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffeffff), -0x1.0800000080008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000010008), 0x1.080000008004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffefff7), -0x1.0800000080048p+49, 0x0p+0 },
+{ INT64_C(0x0002100000010080), 0x1.08000000804p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffeff7f), -0x1.0800000080408p+49, 0x0p+0 },
+{ INT64_C(0x0002100000010200), 0x1.0800000081p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffefdff), -0x1.0800000081008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000010800), 0x1.0800000084p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffef7ff), -0x1.0800000084008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000018000), 0x1.08000000cp+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffe7fff), -0x1.08000000c0008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000040000), 0x1.08000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbffff), -0x1.0800000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000040004), 0x1.080000020002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbfffb), -0x1.0800000200028p+49, 0x0p+0 },
+{ INT64_C(0x0002100000040010), 0x1.080000020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbffef), -0x1.0800000200088p+49, 0x0p+0 },
+{ INT64_C(0x0002100000040100), 0x1.08000002008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbfeff), -0x1.0800000200808p+49, 0x0p+0 },
+{ INT64_C(0x0002100000040400), 0x1.0800000202p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbfbff), -0x1.0800000202008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000040800), 0x1.0800000204p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbf7ff), -0x1.0800000204008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000042000), 0x1.080000021p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffbdfff), -0x1.0800000210008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000048000), 0x1.080000024p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffffb7fff), -0x1.0800000240008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000060000), 0x1.08000003p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffff9ffff), -0x1.0800000300008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000200000), 0x1.0800001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdfffff), -0x1.0800001000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000200004), 0x1.080000100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdffffb), -0x1.0800001000028p+49, 0x0p+0 },
+{ INT64_C(0x0002100000200010), 0x1.080000100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdfffef), -0x1.0800001000088p+49, 0x0p+0 },
+{ INT64_C(0x0002100000200100), 0x1.08000010008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdffeff), -0x1.0800001000808p+49, 0x0p+0 },
+{ INT64_C(0x0002100000200200), 0x1.0800001001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdffdff), -0x1.0800001001008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000201000), 0x1.0800001008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdfefff), -0x1.0800001008008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000208000), 0x1.080000104p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffdf7fff), -0x1.0800001040008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000280000), 0x1.08000014p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffd7ffff), -0x1.0800001400008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000400000), 0x1.0800002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbfffff), -0x1.0800002000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000400004), 0x1.080000200002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbffffb), -0x1.0800002000028p+49, 0x0p+0 },
+{ INT64_C(0x0002100000400008), 0x1.080000200004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbffff7), -0x1.0800002000048p+49, 0x0p+0 },
+{ INT64_C(0x0002100000400010), 0x1.080000200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbfffef), -0x1.0800002000088p+49, 0x0p+0 },
+{ INT64_C(0x0002100000400080), 0x1.08000020004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbfff7f), -0x1.0800002000408p+49, 0x0p+0 },
+{ INT64_C(0x0002100000400800), 0x1.0800002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbff7ff), -0x1.0800002004008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000402000), 0x1.080000201p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbfdfff), -0x1.0800002010008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000408000), 0x1.080000204p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbf7fff), -0x1.0800002040008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000420000), 0x1.08000021p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffbdffff), -0x1.0800002100008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000480000), 0x1.08000024p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffffb7ffff), -0x1.0800002400008p+49, 0x0p+0 },
+{ INT64_C(0x0002100000600000), 0x1.0800003p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffff9fffff), -0x1.0800003000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004000000), 0x1.080002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbffffff), -0x1.0800020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004000001), 0x1.0800020000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbfffffe), -0x1.080002000001p+49, 0x0p+0 },
+{ INT64_C(0x0002100004000010), 0x1.080002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbffffef), -0x1.0800020000088p+49, 0x0p+0 },
+{ INT64_C(0x0002100004000040), 0x1.08000200002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbffffbf), -0x1.0800020000208p+49, 0x0p+0 },
+{ INT64_C(0x0002100004000100), 0x1.08000200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbfffeff), -0x1.0800020000808p+49, 0x0p+0 },
+{ INT64_C(0x0002100004000200), 0x1.0800020001p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbfffdff), -0x1.0800020001008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004001000), 0x1.0800020008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbffefff), -0x1.0800020008008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004008000), 0x1.080002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbff7fff), -0x1.0800020040008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004040000), 0x1.08000202p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbfbffff), -0x1.0800020200008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004400000), 0x1.0800022p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffbbfffff), -0x1.0800022000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100004800000), 0x1.0800024p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffffb7fffff), -0x1.0800024000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040000000), 0x1.08002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbfffffff), -0x1.0800200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040000008), 0x1.080020000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbffffff7), -0x1.0800200000048p+49, 0x0p+0 },
+{ INT64_C(0x0002100040000020), 0x1.08002000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbfffffdf), -0x1.0800200000108p+49, 0x0p+0 },
+{ INT64_C(0x0002100040000080), 0x1.08002000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbfffff7f), -0x1.0800200000408p+49, 0x0p+0 },
+{ INT64_C(0x0002100040000400), 0x1.0800200002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbffffbff), -0x1.0800200002008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040004000), 0x1.080020002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbfffbfff), -0x1.0800200020008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040008000), 0x1.080020004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbfff7fff), -0x1.0800200040008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040020000), 0x1.08002001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbffdffff), -0x1.0800200100008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040080000), 0x1.08002004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbff7ffff), -0x1.0800200400008p+49, 0x0p+0 },
+{ INT64_C(0x0002100040800000), 0x1.0800204p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbf7fffff), -0x1.0800204000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100044000000), 0x1.080022p+49, 0x0p+0 },
+{ INT64_C(0xfffdefffbbffffff), -0x1.0800220000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100100000000), 0x1.08008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffeffffffff), -0x1.0800800000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100100000001), 0x1.0800800000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefffffffe), -0x1.080080000001p+49, 0x0p+0 },
+{ INT64_C(0x0002100100000004), 0x1.080080000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefffffffb), -0x1.0800800000028p+49, 0x0p+0 },
+{ INT64_C(0x0002100100000008), 0x1.080080000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefffffff7), -0x1.0800800000048p+49, 0x0p+0 },
+{ INT64_C(0x0002100100000080), 0x1.08008000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffeffffff7f), -0x1.0800800000408p+49, 0x0p+0 },
+{ INT64_C(0x0002100100000800), 0x1.0800800004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefffff7ff), -0x1.0800800004008p+49, 0x0p+0 },
+{ INT64_C(0x0002100100004000), 0x1.080080002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffeffffbfff), -0x1.0800800020008p+49, 0x0p+0 },
+{ INT64_C(0x0002100100020000), 0x1.08008001p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefffdffff), -0x1.0800800100008p+49, 0x0p+0 },
+{ INT64_C(0x0002100100040000), 0x1.08008002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefffbffff), -0x1.0800800200008p+49, 0x0p+0 },
+{ INT64_C(0x0002100100400000), 0x1.0800802p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffeffbfffff), -0x1.0800802000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100101000000), 0x1.0800808p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffefeffffff), -0x1.0800808000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100110000000), 0x1.080088p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffeefffffff), -0x1.0800880000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100120000000), 0x1.08009p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffedfffffff), -0x1.0800900000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000000), 0x1.0802p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbffffffff), -0x1.0802000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000001), 0x1.0802000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbfffffffe), -0x1.080200000001p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000008), 0x1.080200000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbfffffff7), -0x1.0802000000048p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000010), 0x1.080200000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbffffffef), -0x1.0802000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000040), 0x1.08020000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbffffffbf), -0x1.0802000000208p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000200), 0x1.0802000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbfffffdff), -0x1.0802000001008p+49, 0x0p+0 },
+{ INT64_C(0x0002100400000800), 0x1.0802000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbfffff7ff), -0x1.0802000004008p+49, 0x0p+0 },
+{ INT64_C(0x0002100400008000), 0x1.080200004p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbffff7fff), -0x1.0802000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002100400040000), 0x1.08020002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbfffbffff), -0x1.0802000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002100400400000), 0x1.0802002p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbffbfffff), -0x1.0802002000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100404000000), 0x1.080202p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbfbffffff), -0x1.0802020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100420000000), 0x1.08021p+49, 0x0p+0 },
+{ INT64_C(0xfffdeffbdfffffff), -0x1.0802100000008p+49, 0x0p+0 },
+{ INT64_C(0x0002100600000000), 0x1.0803p+49, 0x0p+0 },
+{ INT64_C(0xfffdeff9ffffffff), -0x1.0803000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000000000), 0x1.081p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfffffffff), -0x1.0810000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000000004), 0x1.081000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdffffffffb), -0x1.0810000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002102000000020), 0x1.08100000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfffffffdf), -0x1.0810000000108p+49, 0x0p+0 },
+{ INT64_C(0x0002102000000200), 0x1.0810000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdffffffdff), -0x1.0810000001008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000001000), 0x1.0810000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfffffefff), -0x1.0810000008008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000004000), 0x1.081000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfffffbfff), -0x1.0810000020008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000040000), 0x1.08100002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdffffbffff), -0x1.0810000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000100000), 0x1.08100008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfffefffff), -0x1.0810000800008p+49, 0x0p+0 },
+{ INT64_C(0x0002102000800000), 0x1.0810004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfff7fffff), -0x1.0810004000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102002000000), 0x1.081001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdffdffffff), -0x1.0810010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102008000000), 0x1.081004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdff7ffffff), -0x1.0810040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102010000000), 0x1.081008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfefffffff), -0x1.0810080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102020000000), 0x1.08101p+49, 0x0p+0 },
+{ INT64_C(0xfffdefdfdfffffff), -0x1.0810100000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102200000000), 0x1.0811p+49, 0x0p+0 },
+{ INT64_C(0xfffdefddffffffff), -0x1.0811000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002102800000000), 0x1.0814p+49, 0x0p+0 },
+{ INT64_C(0xfffdefd7ffffffff), -0x1.0814000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002103000000000), 0x1.0818p+49, 0x0p+0 },
+{ INT64_C(0xfffdefcfffffffff), -0x1.0818000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104000000000), 0x1.082p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfffffffff), -0x1.0820000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104000000008), 0x1.082000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbffffffff7), -0x1.0820000000048p+49, 0x0p+0 },
+{ INT64_C(0x0002104000000010), 0x1.082000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfffffffef), -0x1.0820000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002104000000080), 0x1.08200000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfffffff7f), -0x1.0820000000408p+49, 0x0p+0 },
+{ INT64_C(0x0002104000000100), 0x1.08200000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbffffffeff), -0x1.0820000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002104000000200), 0x1.0820000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbffffffdff), -0x1.0820000001008p+49, 0x0p+0 },
+{ INT64_C(0x0002104000002000), 0x1.082000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfffffdfff), -0x1.0820000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002104000008000), 0x1.082000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfffff7fff), -0x1.0820000040008p+49, 0x0p+0 },
+{ INT64_C(0x0002104000040000), 0x1.08200002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbffffbffff), -0x1.0820000200008p+49, 0x0p+0 },
+{ INT64_C(0x0002104000100000), 0x1.08200008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfffefffff), -0x1.0820000800008p+49, 0x0p+0 },
+{ INT64_C(0x0002104001000000), 0x1.0820008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbffeffffff), -0x1.0820008000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104004000000), 0x1.082002p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbffbffffff), -0x1.0820020000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104008000000), 0x1.082004p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbff7ffffff), -0x1.0820040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104010000000), 0x1.082008p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfefffffff), -0x1.0820080000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104040000000), 0x1.08202p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbfbfffffff), -0x1.0820200000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104400000000), 0x1.0822p+49, 0x0p+0 },
+{ INT64_C(0xfffdefbbffffffff), -0x1.0822000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002104800000000), 0x1.0824p+49, 0x0p+0 },
+{ INT64_C(0xfffdefb7ffffffff), -0x1.0824000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000000), 0x1.09p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffffffffff), -0x1.0900000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000002), 0x1.090000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffffffffd), -0x1.0900000000018p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000004), 0x1.090000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffffffffb), -0x1.0900000000028p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000010), 0x1.090000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffffffffef), -0x1.0900000000088p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000020), 0x1.09000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffffffffdf), -0x1.0900000000108p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000100), 0x1.09000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffffffeff), -0x1.0900000000808p+49, 0x0p+0 },
+{ INT64_C(0x0002120000000400), 0x1.0900000002p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffffffbff), -0x1.0900000002008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000002000), 0x1.090000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffffffdfff), -0x1.0900000010008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000020000), 0x1.09000001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffffdffff), -0x1.0900000100008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000080000), 0x1.09000004p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffff7ffff), -0x1.0900000400008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000200000), 0x1.0900001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffffdfffff), -0x1.0900001000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120000800000), 0x1.0900004p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffff7fffff), -0x1.0900004000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120002000000), 0x1.090001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfffdffffff), -0x1.0900010000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120008000000), 0x1.090004p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfff7ffffff), -0x1.0900040000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120020000000), 0x1.09001p+49, 0x0p+0 },
+{ INT64_C(0xfffdedffdfffffff), -0x1.0900100000008p+49, 0x0p+0 },
+{ INT64_C(0x0002120100000000), 0x1.09008p+49, 0x0p+0 },
+{ INT64_C(0xfffdedfeffffffff), -0x1.0900800000008p+49, 0x0p+0 },
+{ INT64_C(0x0002121000000000), 0x1.0908p+49, 0x0p+0 },
+{ INT64_C(0xfffdedefffffffff), -0x1.0908000000008p+49, 0x0p+0 },
+{ INT64_C(0x0002130000000000), 0x1.098p+49, 0x0p+0 },
+{ INT64_C(0xfffdecffffffffff), -0x1.0980000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000002), 0x1.800000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffffd), -0x1.8000000000018p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000003), 0x1.8000000000018p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffffc), -0x1.800000000002p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000008), 0x1.800000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffff7), -0x1.8000000000048p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000009), 0x1.8000000000048p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffff6), -0x1.800000000005p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000020), 0x1.80000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffffdf), -0x1.8000000000108p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000024), 0x1.800000000012p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffffdb), -0x1.8000000000128p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000200), 0x1.8000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffdff), -0x1.8000000001008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000202), 0x1.800000000101p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffdfd), -0x1.8000000001018p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000208), 0x1.800000000104p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffdf7), -0x1.8000000001048p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000220), 0x1.80000000011p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffffddf), -0x1.8000000001108p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000800), 0x1.8000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffff7ff), -0x1.8000000004008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000808), 0x1.800000000404p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffff7f7), -0x1.8000000004048p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000840), 0x1.80000000042p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffff7bf), -0x1.8000000004208p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000880), 0x1.80000000044p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffff77f), -0x1.8000000004408p+49, 0x0p+0 },
+{ INT64_C(0x0003000000000c00), 0x1.8000000006p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffff3ff), -0x1.8000000006008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000001000), 0x1.8000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffefff), -0x1.8000000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000001002), 0x1.800000000801p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffeffd), -0x1.8000000008018p+49, 0x0p+0 },
+{ INT64_C(0x0003000000001010), 0x1.800000000808p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffefef), -0x1.8000000008088p+49, 0x0p+0 },
+{ INT64_C(0x0003000000001080), 0x1.80000000084p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffef7f), -0x1.8000000008408p+49, 0x0p+0 },
+{ INT64_C(0x0003000000001400), 0x1.800000000ap+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffffebff), -0x1.800000000a008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000008000), 0x1.800000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffff7fff), -0x1.8000000040008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000008002), 0x1.800000004001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffff7ffd), -0x1.8000000040018p+49, 0x0p+0 },
+{ INT64_C(0x0003000000008008), 0x1.800000004004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffff7ff7), -0x1.8000000040048p+49, 0x0p+0 },
+{ INT64_C(0x0003000000008040), 0x1.80000000402p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffff7fbf), -0x1.8000000040208p+49, 0x0p+0 },
+{ INT64_C(0x0003000000008400), 0x1.8000000042p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffff7bff), -0x1.8000000042008p+49, 0x0p+0 },
+{ INT64_C(0x000300000000c000), 0x1.800000006p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffff3fff), -0x1.8000000060008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000040000), 0x1.80000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffbffff), -0x1.8000000200008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000040002), 0x1.800000020001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffbfffd), -0x1.8000000200018p+49, 0x0p+0 },
+{ INT64_C(0x0003000000040010), 0x1.800000020008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffbffef), -0x1.8000000200088p+49, 0x0p+0 },
+{ INT64_C(0x0003000000040040), 0x1.80000002002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffbffbf), -0x1.8000000200208p+49, 0x0p+0 },
+{ INT64_C(0x0003000000040400), 0x1.8000000202p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffbfbff), -0x1.8000000202008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000044000), 0x1.800000022p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffffbbfff), -0x1.8000000220008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000060000), 0x1.80000003p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff9ffff), -0x1.8000000300008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000080000), 0x1.80000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7ffff), -0x1.8000000400008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000080001), 0x1.8000000400008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7fffe), -0x1.800000040001p+49, 0x0p+0 },
+{ INT64_C(0x0003000000080002), 0x1.800000040001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7fffd), -0x1.8000000400018p+49, 0x0p+0 },
+{ INT64_C(0x0003000000080010), 0x1.800000040008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7ffef), -0x1.8000000400088p+49, 0x0p+0 },
+{ INT64_C(0x0003000000080080), 0x1.80000004004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7ff7f), -0x1.8000000400408p+49, 0x0p+0 },
+{ INT64_C(0x0003000000080200), 0x1.8000000401p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7fdff), -0x1.8000000401008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000081000), 0x1.8000000408p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7efff), -0x1.8000000408008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000082000), 0x1.800000041p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff7dfff), -0x1.8000000410008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000090000), 0x1.800000048p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff6ffff), -0x1.8000000480008p+49, 0x0p+0 },
+{ INT64_C(0x00030000000c0000), 0x1.80000006p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffff3ffff), -0x1.8000000600008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000400000), 0x1.8000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbfffff), -0x1.8000002000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000400001), 0x1.8000002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbffffe), -0x1.800000200001p+49, 0x0p+0 },
+{ INT64_C(0x0003000000400008), 0x1.800000200004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbffff7), -0x1.8000002000048p+49, 0x0p+0 },
+{ INT64_C(0x0003000000400020), 0x1.80000020001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbfffdf), -0x1.8000002000108p+49, 0x0p+0 },
+{ INT64_C(0x0003000000400100), 0x1.80000020008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbffeff), -0x1.8000002000808p+49, 0x0p+0 },
+{ INT64_C(0x0003000000400400), 0x1.8000002002p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbffbff), -0x1.8000002002008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000402000), 0x1.800000201p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbfdfff), -0x1.8000002010008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000408000), 0x1.800000204p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbf7fff), -0x1.8000002040008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000420000), 0x1.80000021p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbdffff), -0x1.8000002100008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000440000), 0x1.80000022p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffffbbffff), -0x1.8000002200008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000800000), 0x1.8000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7fffff), -0x1.8000004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000800008), 0x1.800000400004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7ffff7), -0x1.8000004000048p+49, 0x0p+0 },
+{ INT64_C(0x0003000000800020), 0x1.80000040001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7fffdf), -0x1.8000004000108p+49, 0x0p+0 },
+{ INT64_C(0x0003000000800040), 0x1.80000040002p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7fffbf), -0x1.8000004000208p+49, 0x0p+0 },
+{ INT64_C(0x0003000000800100), 0x1.80000040008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7ffeff), -0x1.8000004000808p+49, 0x0p+0 },
+{ INT64_C(0x0003000000800200), 0x1.8000004001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7ffdff), -0x1.8000004001008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000802000), 0x1.800000401p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7fdfff), -0x1.8000004010008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000804000), 0x1.800000402p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7fbfff), -0x1.8000004020008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000808000), 0x1.800000404p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7f7fff), -0x1.8000004040008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000810000), 0x1.800000408p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff7effff), -0x1.8000004080008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000880000), 0x1.80000044p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff77ffff), -0x1.8000004400008p+49, 0x0p+0 },
+{ INT64_C(0x0003000000c00000), 0x1.8000006p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffff3fffff), -0x1.8000006000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004000000), 0x1.800002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbffffff), -0x1.8000020000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004000002), 0x1.800002000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbfffffd), -0x1.8000020000018p+49, 0x0p+0 },
+{ INT64_C(0x0003000004000004), 0x1.800002000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbfffffb), -0x1.8000020000028p+49, 0x0p+0 },
+{ INT64_C(0x0003000004000010), 0x1.800002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbffffef), -0x1.8000020000088p+49, 0x0p+0 },
+{ INT64_C(0x0003000004000100), 0x1.80000200008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbfffeff), -0x1.8000020000808p+49, 0x0p+0 },
+{ INT64_C(0x0003000004001000), 0x1.8000020008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbffefff), -0x1.8000020008008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004004000), 0x1.800002002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbffbfff), -0x1.8000020020008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004010000), 0x1.800002008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbfeffff), -0x1.8000020080008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004020000), 0x1.80000201p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbfdffff), -0x1.8000020100008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004080000), 0x1.80000204p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbf7ffff), -0x1.8000020400008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004400000), 0x1.8000022p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffbbfffff), -0x1.8000022000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000004800000), 0x1.8000024p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffffb7fffff), -0x1.8000024000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000006000000), 0x1.800003p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffff9ffffff), -0x1.8000030000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040000000), 0x1.80002p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbfffffff), -0x1.8000200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040000004), 0x1.800020000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbffffffb), -0x1.8000200000028p+49, 0x0p+0 },
+{ INT64_C(0x0003000040000040), 0x1.80002000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbfffffbf), -0x1.8000200000208p+49, 0x0p+0 },
+{ INT64_C(0x0003000040000200), 0x1.8000200001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbffffdff), -0x1.8000200001008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040001000), 0x1.8000200008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbfffefff), -0x1.8000200008008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040002000), 0x1.800020001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbfffdfff), -0x1.8000200010008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040008000), 0x1.800020004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbfff7fff), -0x1.8000200040008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040080000), 0x1.80002004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbff7ffff), -0x1.8000200400008p+49, 0x0p+0 },
+{ INT64_C(0x0003000040200000), 0x1.8000201p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbfdfffff), -0x1.8000201000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000042000000), 0x1.800021p+49, 0x0p+0 },
+{ INT64_C(0xfffcffffbdffffff), -0x1.8000210000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000060000000), 0x1.80003p+49, 0x0p+0 },
+{ INT64_C(0xfffcffff9fffffff), -0x1.8000300000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200000000), 0x1.8001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdffffffff), -0x1.8001000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200000008), 0x1.800100000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdfffffff7), -0x1.8001000000048p+49, 0x0p+0 },
+{ INT64_C(0x0003000200000080), 0x1.80010000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdffffff7f), -0x1.8001000000408p+49, 0x0p+0 },
+{ INT64_C(0x0003000200000400), 0x1.8001000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdfffffbff), -0x1.8001000002008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200002000), 0x1.800100001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdffffdfff), -0x1.8001000010008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200004000), 0x1.800100002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdffffbfff), -0x1.8001000020008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200020000), 0x1.80010001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdfffdffff), -0x1.8001000100008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200100000), 0x1.80010008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdffefffff), -0x1.8001000800008p+49, 0x0p+0 },
+{ INT64_C(0x0003000200400000), 0x1.8001002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdffbfffff), -0x1.8001002000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000204000000), 0x1.800102p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdfbffffff), -0x1.8001020000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000210000000), 0x1.800108p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffdefffffff), -0x1.8001080000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000280000000), 0x1.80014p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffd7fffffff), -0x1.8001400000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400000000), 0x1.8002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbffffffff), -0x1.8002000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400000004), 0x1.800200000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfffffffb), -0x1.8002000000028p+49, 0x0p+0 },
+{ INT64_C(0x0003000400000008), 0x1.800200000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfffffff7), -0x1.8002000000048p+49, 0x0p+0 },
+{ INT64_C(0x0003000400000010), 0x1.800200000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbffffffef), -0x1.8002000000088p+49, 0x0p+0 },
+{ INT64_C(0x0003000400000080), 0x1.80020000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbffffff7f), -0x1.8002000000408p+49, 0x0p+0 },
+{ INT64_C(0x0003000400000400), 0x1.8002000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfffffbff), -0x1.8002000002008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400001000), 0x1.8002000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbffffefff), -0x1.8002000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400010000), 0x1.800200008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfffeffff), -0x1.8002000080008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400020000), 0x1.80020001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfffdffff), -0x1.8002000100008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400040000), 0x1.80020002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfffbffff), -0x1.8002000200008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400080000), 0x1.80020004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfff7ffff), -0x1.8002000400008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400400000), 0x1.8002002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbffbfffff), -0x1.8002002000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000400800000), 0x1.8002004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbff7fffff), -0x1.8002004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000404000000), 0x1.800202p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbfbffffff), -0x1.8002020000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000408000000), 0x1.800204p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbf7ffffff), -0x1.8002040000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000440000000), 0x1.80022p+49, 0x0p+0 },
+{ INT64_C(0xfffcfffbbfffffff), -0x1.8002200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003000600000000), 0x1.8003p+49, 0x0p+0 },
+{ INT64_C(0xfffcfff9ffffffff), -0x1.8003000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000000000), 0x1.802p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffffffff), -0x1.8020000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000000001), 0x1.8020000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbffffffffe), -0x1.802000000001p+49, 0x0p+0 },
+{ INT64_C(0x0003004000000002), 0x1.802000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbffffffffd), -0x1.8020000000018p+49, 0x0p+0 },
+{ INT64_C(0x0003004000000010), 0x1.802000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffffffef), -0x1.8020000000088p+49, 0x0p+0 },
+{ INT64_C(0x0003004000000020), 0x1.80200000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffffffdf), -0x1.8020000000108p+49, 0x0p+0 },
+{ INT64_C(0x0003004000000200), 0x1.8020000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbffffffdff), -0x1.8020000001008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000001000), 0x1.8020000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffffefff), -0x1.8020000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000002000), 0x1.802000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffffdfff), -0x1.8020000010008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000008000), 0x1.802000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffff7fff), -0x1.8020000040008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000020000), 0x1.80200001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbffffdffff), -0x1.8020000100008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000200000), 0x1.8020001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfffdfffff), -0x1.8020001000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004000800000), 0x1.8020004p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfff7fffff), -0x1.8020004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004001000000), 0x1.8020008p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbffeffffff), -0x1.8020008000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004002000000), 0x1.802001p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbffdffffff), -0x1.8020010000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004020000000), 0x1.80201p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfdfffffff), -0x1.8020100000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004040000000), 0x1.80202p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbfbfffffff), -0x1.8020200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003004100000000), 0x1.80208p+49, 0x0p+0 },
+{ INT64_C(0xfffcffbeffffffff), -0x1.8020800000008p+49, 0x0p+0 },
+{ INT64_C(0x0003005000000000), 0x1.8028p+49, 0x0p+0 },
+{ INT64_C(0xfffcffafffffffff), -0x1.8028000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003006000000000), 0x1.803p+49, 0x0p+0 },
+{ INT64_C(0xfffcff9fffffffff), -0x1.8030000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000000000), 0x1.804p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fffffffff), -0x1.8040000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000000008), 0x1.804000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ffffffff7), -0x1.8040000000048p+49, 0x0p+0 },
+{ INT64_C(0x0003008000000020), 0x1.80400000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fffffffdf), -0x1.8040000000108p+49, 0x0p+0 },
+{ INT64_C(0x0003008000000100), 0x1.80400000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ffffffeff), -0x1.8040000000808p+49, 0x0p+0 },
+{ INT64_C(0x0003008000000200), 0x1.8040000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ffffffdff), -0x1.8040000001008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000000400), 0x1.8040000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ffffffbff), -0x1.8040000002008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000001000), 0x1.8040000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fffffefff), -0x1.8040000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000010000), 0x1.804000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ffffeffff), -0x1.8040000080008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000100000), 0x1.80400008p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fffefffff), -0x1.8040000800008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000200000), 0x1.8040001p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fffdfffff), -0x1.8040001000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008000800000), 0x1.8040004p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fff7fffff), -0x1.8040004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008002000000), 0x1.804001p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ffdffffff), -0x1.8040010000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008008000000), 0x1.804004p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7ff7ffffff), -0x1.8040040000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008020000000), 0x1.80401p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7fdfffffff), -0x1.8040100000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008080000000), 0x1.80404p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7f7fffffff), -0x1.8040400000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008100000000), 0x1.80408p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7effffffff), -0x1.8040800000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008200000000), 0x1.8041p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7dffffffff), -0x1.8041000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003008400000000), 0x1.8042p+49, 0x0p+0 },
+{ INT64_C(0xfffcff7bffffffff), -0x1.8042000000008p+49, 0x0p+0 },
+{ INT64_C(0x000300a000000000), 0x1.805p+49, 0x0p+0 },
+{ INT64_C(0xfffcff5fffffffff), -0x1.8050000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003010000000000), 0x1.808p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeffffffffff), -0x1.8080000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003010000000001), 0x1.8080000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfefffffffffe), -0x1.808000000001p+49, 0x0p+0 },
+{ INT64_C(0x0003010000000010), 0x1.808000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeffffffffef), -0x1.8080000000088p+49, 0x0p+0 },
+{ INT64_C(0x0003010000000080), 0x1.80800000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeffffffff7f), -0x1.8080000000408p+49, 0x0p+0 },
+{ INT64_C(0x0003010000000800), 0x1.8080000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfefffffff7ff), -0x1.8080000004008p+49, 0x0p+0 },
+{ INT64_C(0x0003010000004000), 0x1.808000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeffffffbfff), -0x1.8080000020008p+49, 0x0p+0 },
+{ INT64_C(0x0003010000040000), 0x1.80800002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfefffffbffff), -0x1.8080000200008p+49, 0x0p+0 },
+{ INT64_C(0x0003010000400000), 0x1.8080002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeffffbfffff), -0x1.8080002000008p+49, 0x0p+0 },
+{ INT64_C(0x0003010004000000), 0x1.808002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfefffbffffff), -0x1.8080020000008p+49, 0x0p+0 },
+{ INT64_C(0x0003010040000000), 0x1.80802p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeffbfffffff), -0x1.8080200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003010200000000), 0x1.8081p+49, 0x0p+0 },
+{ INT64_C(0xfffcfefdffffffff), -0x1.8081000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003010800000000), 0x1.8084p+49, 0x0p+0 },
+{ INT64_C(0xfffcfef7ffffffff), -0x1.8084000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003011000000000), 0x1.8088p+49, 0x0p+0 },
+{ INT64_C(0xfffcfeefffffffff), -0x1.8088000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003014000000000), 0x1.80ap+49, 0x0p+0 },
+{ INT64_C(0xfffcfebfffffffff), -0x1.80a0000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040000000000), 0x1.82p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffffffffff), -0x1.8200000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040000000004), 0x1.820000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbfffffffffb), -0x1.8200000000028p+49, 0x0p+0 },
+{ INT64_C(0x0003040000000010), 0x1.820000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffffffffef), -0x1.8200000000088p+49, 0x0p+0 },
+{ INT64_C(0x0003040000000020), 0x1.82000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffffffffdf), -0x1.8200000000108p+49, 0x0p+0 },
+{ INT64_C(0x0003040000000100), 0x1.82000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbfffffffeff), -0x1.8200000000808p+49, 0x0p+0 },
+{ INT64_C(0x0003040000001000), 0x1.8200000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffffffefff), -0x1.8200000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003040000010000), 0x1.820000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbfffffeffff), -0x1.8200000080008p+49, 0x0p+0 },
+{ INT64_C(0x0003040000080000), 0x1.82000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbfffff7ffff), -0x1.8200000400008p+49, 0x0p+0 },
+{ INT64_C(0x0003040000800000), 0x1.8200004p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffff7fffff), -0x1.8200004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040004000000), 0x1.820002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbfffbffffff), -0x1.8200020000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040010000000), 0x1.820008p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffefffffff), -0x1.8200080000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040040000000), 0x1.82002p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbffbfffffff), -0x1.8200200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040400000000), 0x1.8202p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbfbffffffff), -0x1.8202000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003040800000000), 0x1.8204p+49, 0x0p+0 },
+{ INT64_C(0xfffcfbf7ffffffff), -0x1.8204000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003048000000000), 0x1.824p+49, 0x0p+0 },
+{ INT64_C(0xfffcfb7fffffffff), -0x1.8240000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003050000000000), 0x1.828p+49, 0x0p+0 },
+{ INT64_C(0xfffcfaffffffffff), -0x1.8280000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000000000), 0x1.84p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7ffffffffff), -0x1.8400000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000000004), 0x1.840000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fffffffffb), -0x1.8400000000028p+49, 0x0p+0 },
+{ INT64_C(0x0003080000000040), 0x1.84000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7ffffffffbf), -0x1.8400000000208p+49, 0x0p+0 },
+{ INT64_C(0x0003080000000100), 0x1.84000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fffffffeff), -0x1.8400000000808p+49, 0x0p+0 },
+{ INT64_C(0x0003080000000800), 0x1.8400000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fffffff7ff), -0x1.8400000004008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000008000), 0x1.840000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7ffffff7fff), -0x1.8400000040008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000020000), 0x1.84000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fffffdffff), -0x1.8400000100008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000080000), 0x1.84000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fffff7ffff), -0x1.8400000400008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000400000), 0x1.8400002p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7ffffbfffff), -0x1.8400002000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080000800000), 0x1.8400004p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7ffff7fffff), -0x1.8400004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080008000000), 0x1.840004p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fff7ffffff), -0x1.8400040000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080010000000), 0x1.840008p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7ffefffffff), -0x1.8400080000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080100000000), 0x1.84008p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7feffffffff), -0x1.8400800000008p+49, 0x0p+0 },
+{ INT64_C(0x0003080200000000), 0x1.8401p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7fdffffffff), -0x1.8401000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003082000000000), 0x1.841p+49, 0x0p+0 },
+{ INT64_C(0xfffcf7dfffffffff), -0x1.8410000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003090000000000), 0x1.848p+49, 0x0p+0 },
+{ INT64_C(0xfffcf6ffffffffff), -0x1.8480000000008p+49, 0x0p+0 },
+{ INT64_C(0x00030a0000000000), 0x1.85p+49, 0x0p+0 },
+{ INT64_C(0xfffcf5ffffffffff), -0x1.8500000000008p+49, 0x0p+0 },
+{ INT64_C(0x00030c0000000000), 0x1.86p+49, 0x0p+0 },
+{ INT64_C(0xfffcf3ffffffffff), -0x1.8600000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003200000000000), 0x1.9p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffffffffff), -0x1.9000000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003200000000002), 0x1.900000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcdffffffffffd), -0x1.9000000000018p+49, 0x0p+0 },
+{ INT64_C(0x0003200000000010), 0x1.900000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffffffffef), -0x1.9000000000088p+49, 0x0p+0 },
+{ INT64_C(0x0003200000000040), 0x1.90000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffffffffbf), -0x1.9000000000208p+49, 0x0p+0 },
+{ INT64_C(0x0003200000000100), 0x1.90000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcdffffffffeff), -0x1.9000000000808p+49, 0x0p+0 },
+{ INT64_C(0x0003200000001000), 0x1.9000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffffffefff), -0x1.9000000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003200000008000), 0x1.900000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffffff7fff), -0x1.9000000040008p+49, 0x0p+0 },
+{ INT64_C(0x0003200000010000), 0x1.900000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcdffffffeffff), -0x1.9000000080008p+49, 0x0p+0 },
+{ INT64_C(0x0003200000100000), 0x1.90000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffffefffff), -0x1.9000000800008p+49, 0x0p+0 },
+{ INT64_C(0x0003200000800000), 0x1.9000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffff7fffff), -0x1.9000004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003200001000000), 0x1.9000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcdffffeffffff), -0x1.9000008000008p+49, 0x0p+0 },
+{ INT64_C(0x0003200008000000), 0x1.900004p+49, 0x0p+0 },
+{ INT64_C(0xfffcdffff7ffffff), -0x1.9000040000008p+49, 0x0p+0 },
+{ INT64_C(0x0003200040000000), 0x1.90002p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfffbfffffff), -0x1.9000200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003200400000000), 0x1.9002p+49, 0x0p+0 },
+{ INT64_C(0xfffcdffbffffffff), -0x1.9002000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003204000000000), 0x1.902p+49, 0x0p+0 },
+{ INT64_C(0xfffcdfbfffffffff), -0x1.9020000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003210000000000), 0x1.908p+49, 0x0p+0 },
+{ INT64_C(0xfffcdeffffffffff), -0x1.9080000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003220000000000), 0x1.91p+49, 0x0p+0 },
+{ INT64_C(0xfffcddffffffffff), -0x1.9100000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003300000000000), 0x1.98p+49, 0x0p+0 },
+{ INT64_C(0xfffccfffffffffff), -0x1.9800000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000000000), 0x1.ap+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffffffffff), -0x1.a000000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000000002), 0x1.a00000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffffffffffd), -0x1.a000000000018p+49, 0x0p+0 },
+{ INT64_C(0x0003400000000008), 0x1.a00000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffffffffff7), -0x1.a000000000048p+49, 0x0p+0 },
+{ INT64_C(0x0003400000000040), 0x1.a0000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffffffffbf), -0x1.a000000000208p+49, 0x0p+0 },
+{ INT64_C(0x0003400000000400), 0x1.a000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffffffffbff), -0x1.a000000002008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000004000), 0x1.a00000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffffffbfff), -0x1.a000000020008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000020000), 0x1.a0000001p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffffffdffff), -0x1.a000000100008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000040000), 0x1.a0000002p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffffffbffff), -0x1.a000000200008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000100000), 0x1.a0000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffffefffff), -0x1.a000000800008p+49, 0x0p+0 },
+{ INT64_C(0x0003400000800000), 0x1.a000004p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffff7fffff), -0x1.a000004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400001000000), 0x1.a000008p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffffeffffff), -0x1.a000008000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400008000000), 0x1.a00004p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffff7ffffff), -0x1.a000040000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400010000000), 0x1.a00008p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffefffffff), -0x1.a000080000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400040000000), 0x1.a0002p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfffbfffffff), -0x1.a000200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003400400000000), 0x1.a002p+49, 0x0p+0 },
+{ INT64_C(0xfffcbffbffffffff), -0x1.a002000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003404000000000), 0x1.a02p+49, 0x0p+0 },
+{ INT64_C(0xfffcbfbfffffffff), -0x1.a020000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003408000000000), 0x1.a04p+49, 0x0p+0 },
+{ INT64_C(0xfffcbf7fffffffff), -0x1.a040000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003410000000000), 0x1.a08p+49, 0x0p+0 },
+{ INT64_C(0xfffcbeffffffffff), -0x1.a080000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003440000000000), 0x1.a2p+49, 0x0p+0 },
+{ INT64_C(0xfffcbbffffffffff), -0x1.a200000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003600000000000), 0x1.bp+49, 0x0p+0 },
+{ INT64_C(0xfffc9fffffffffff), -0x1.b000000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000000), 0x1.cp+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffffffffff), -0x1.c000000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000002), 0x1.c00000000001p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffffffffd), -0x1.c000000000018p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000004), 0x1.c00000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffffffffb), -0x1.c000000000028p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000010), 0x1.c00000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffffffffef), -0x1.c000000000088p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000080), 0x1.c0000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffffffff7f), -0x1.c000000000408p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000400), 0x1.c000000002p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffffffbff), -0x1.c000000002008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000000800), 0x1.c000000004p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffffff7ff), -0x1.c000000004008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000001000), 0x1.c000000008p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffffffefff), -0x1.c000000008008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000002000), 0x1.c00000001p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffffffdfff), -0x1.c000000010008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000010000), 0x1.c00000008p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffffeffff), -0x1.c000000080008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000080000), 0x1.c0000004p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffff7ffff), -0x1.c000000400008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000100000), 0x1.c0000008p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffffefffff), -0x1.c000000800008p+49, 0x0p+0 },
+{ INT64_C(0x0003800000800000), 0x1.c000004p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffff7fffff), -0x1.c000004000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800004000000), 0x1.c00002p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffffbffffff), -0x1.c000020000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800008000000), 0x1.c00004p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffff7ffffff), -0x1.c000040000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800010000000), 0x1.c00008p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffefffffff), -0x1.c000080000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800020000000), 0x1.c0001p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffdfffffff), -0x1.c000100000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800040000000), 0x1.c0002p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fffbfffffff), -0x1.c000200000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800400000000), 0x1.c002p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ffbffffffff), -0x1.c002000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003800800000000), 0x1.c004p+49, 0x0p+0 },
+{ INT64_C(0xfffc7ff7ffffffff), -0x1.c004000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003802000000000), 0x1.c01p+49, 0x0p+0 },
+{ INT64_C(0xfffc7fdfffffffff), -0x1.c010000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003820000000000), 0x1.c1p+49, 0x0p+0 },
+{ INT64_C(0xfffc7dffffffffff), -0x1.c100000000008p+49, 0x0p+0 },
+{ INT64_C(0x0003900000000000), 0x1.c8p+49, 0x0p+0 },
+{ INT64_C(0xfffc6fffffffffff), -0x1.c800000000008p+49, 0x0p+0 },
+{ INT64_C(0x000400000000000c), 0x1.000000000003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffffff3), -0x1.0000000000034p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000028), 0x1.00000000000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffffd7), -0x1.00000000000a4p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000044), 0x1.000000000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffffbb), -0x1.0000000000114p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000046), 0x1.0000000000118p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffffb9), -0x1.000000000011cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000000050), 0x1.000000000014p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffffaf), -0x1.0000000000144p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000058), 0x1.000000000016p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffffa7), -0x1.0000000000164p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000408), 0x1.000000000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffffbf7), -0x1.0000000001024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000410), 0x1.000000000104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffffbef), -0x1.0000000001044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000414), 0x1.000000000105p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffffbeb), -0x1.0000000001054p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000440), 0x1.00000000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffffbbf), -0x1.0000000001104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000000448), 0x1.000000000112p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffffbb7), -0x1.0000000001124p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001001), 0x1.0000000004004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffeffe), -0x1.0000000004008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001010), 0x1.000000000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffefef), -0x1.0000000004044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001011), 0x1.0000000004044p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffefee), -0x1.0000000004048p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001012), 0x1.0000000004048p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffefed), -0x1.000000000404cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000001018), 0x1.000000000406p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffefe7), -0x1.0000000004064p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001040), 0x1.00000000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffefbf), -0x1.0000000004104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001044), 0x1.000000000411p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffefbb), -0x1.0000000004114p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001080), 0x1.00000000042p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffef7f), -0x1.0000000004204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001082), 0x1.0000000004208p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffef7d), -0x1.000000000420cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000001090), 0x1.000000000424p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffef6f), -0x1.0000000004244p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001200), 0x1.00000000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffedff), -0x1.0000000004804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001202), 0x1.0000000004808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffedfd), -0x1.000000000480cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000001208), 0x1.000000000482p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffedf7), -0x1.0000000004824p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001220), 0x1.000000000488p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffeddf), -0x1.0000000004884p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001280), 0x1.0000000004ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffed7f), -0x1.0000000004a04p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001300), 0x1.0000000004cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffecff), -0x1.0000000004c04p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001400), 0x1.0000000005p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffebff), -0x1.0000000005004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001404), 0x1.000000000501p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffebfb), -0x1.0000000005014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001440), 0x1.00000000051p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffebbf), -0x1.0000000005104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000001480), 0x1.00000000052p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffffeb7f), -0x1.0000000005204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010004), 0x1.000000004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffefffb), -0x1.0000000040014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010040), 0x1.00000000401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeffbf), -0x1.0000000040104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010042), 0x1.0000000040108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeffbd), -0x1.000000004010cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000010048), 0x1.000000004012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeffb7), -0x1.0000000040124p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010050), 0x1.000000004014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeffaf), -0x1.0000000040144p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010100), 0x1.00000000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffefeff), -0x1.0000000040404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010104), 0x1.000000004041p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffefefb), -0x1.0000000040414p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010110), 0x1.000000004044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffefeef), -0x1.0000000040444p+50, 0x0p+0 },
+{ INT64_C(0x0004000000010180), 0x1.00000000406p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffefe7f), -0x1.0000000040604p+50, 0x0p+0 },
+{ INT64_C(0x0004000000011000), 0x1.0000000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeefff), -0x1.0000000044004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000011001), 0x1.0000000044004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeeffe), -0x1.0000000044008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000011002), 0x1.0000000044008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeeffd), -0x1.000000004400cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000011004), 0x1.000000004401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeeffb), -0x1.0000000044014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000011040), 0x1.00000000441p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeefbf), -0x1.0000000044104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000011100), 0x1.00000000444p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffeeeff), -0x1.0000000044404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000018000), 0x1.000000006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffe7fff), -0x1.0000000060004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000018008), 0x1.000000006002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffe7ff7), -0x1.0000000060024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000018020), 0x1.000000006008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffe7fdf), -0x1.0000000060084p+50, 0x0p+0 },
+{ INT64_C(0x0004000000018080), 0x1.00000000602p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffe7f7f), -0x1.0000000060204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000018400), 0x1.0000000061p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffe7bff), -0x1.0000000061004p+50, 0x0p+0 },
+{ INT64_C(0x000400000001a000), 0x1.0000000068p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffe5fff), -0x1.0000000068004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040008), 0x1.000000010002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbfff7), -0x1.0000000100024p+50, 0x0p+0 },
+{ INT64_C(0x000400000004000a), 0x1.0000000100028p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbfff5), -0x1.000000010002cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000040010), 0x1.000000010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffef), -0x1.0000000100044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040018), 0x1.000000010006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffe7), -0x1.0000000100064p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040040), 0x1.00000001001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffbf), -0x1.0000000100104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040042), 0x1.0000000100108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffbd), -0x1.000000010010cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000040044), 0x1.000000010011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffbb), -0x1.0000000100114p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040048), 0x1.000000010012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffb7), -0x1.0000000100124p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040050), 0x1.000000010014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbffaf), -0x1.0000000100144p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040100), 0x1.00000001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbfeff), -0x1.0000000100404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040108), 0x1.000000010042p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbfef7), -0x1.0000000100424p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040180), 0x1.00000001006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbfe7f), -0x1.0000000100604p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040800), 0x1.0000000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbf7ff), -0x1.0000000102004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040802), 0x1.0000000102008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbf7fd), -0x1.000000010200cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000040808), 0x1.000000010202p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbf7f7), -0x1.0000000102024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040820), 0x1.000000010208p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbf7df), -0x1.0000000102084p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040900), 0x1.00000001024p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbf6ff), -0x1.0000000102404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000040c00), 0x1.0000000103p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbf3ff), -0x1.0000000103004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000044000), 0x1.000000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbbfff), -0x1.0000000110004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000044001), 0x1.0000000110004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbbffe), -0x1.0000000110008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000044004), 0x1.000000011001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbbffb), -0x1.0000000110014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000044008), 0x1.000000011002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbbff7), -0x1.0000000110024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000044040), 0x1.00000001101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbbfbf), -0x1.0000000110104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000044100), 0x1.00000001104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbbeff), -0x1.0000000110404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000045000), 0x1.0000000114p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffbafff), -0x1.0000000114004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000048000), 0x1.000000012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffb7fff), -0x1.0000000120004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000048002), 0x1.0000000120008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffb7ffd), -0x1.000000012000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000048008), 0x1.000000012002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffb7ff7), -0x1.0000000120024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000048080), 0x1.00000001202p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffb7f7f), -0x1.0000000120204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000048200), 0x1.00000001208p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffb7dff), -0x1.0000000120804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000049000), 0x1.0000000124p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffffb6fff), -0x1.0000000124004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060000), 0x1.000000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9ffff), -0x1.0000000180004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060001), 0x1.0000000180004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9fffe), -0x1.0000000180008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060004), 0x1.000000018001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9fffb), -0x1.0000000180014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060008), 0x1.000000018002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9fff7), -0x1.0000000180024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060040), 0x1.00000001801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9ffbf), -0x1.0000000180104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060400), 0x1.0000000181p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9fbff), -0x1.0000000181004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000060800), 0x1.0000000182p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9f7ff), -0x1.0000000182004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000064000), 0x1.000000019p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff9bfff), -0x1.0000000190004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000070000), 0x1.00000001cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff8ffff), -0x1.00000001c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080002), 0x1.0000000200008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fffd), -0x1.000000020000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000080004), 0x1.000000020001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fffb), -0x1.0000000200014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080010), 0x1.000000020004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7ffef), -0x1.0000000200044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080012), 0x1.0000000200048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7ffed), -0x1.000000020004cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000080040), 0x1.00000002001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7ffbf), -0x1.0000000200104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080041), 0x1.0000000200104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7ffbe), -0x1.0000000200108p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080042), 0x1.0000000200108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7ffbd), -0x1.000000020010cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000080050), 0x1.000000020014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7ffaf), -0x1.0000000200144p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080200), 0x1.00000002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fdff), -0x1.0000000200804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080201), 0x1.0000000200804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fdfe), -0x1.0000000200808p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080208), 0x1.000000020082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fdf7), -0x1.0000000200824p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080280), 0x1.0000000200ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fd7f), -0x1.0000000200a04p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080400), 0x1.0000000201p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fbff), -0x1.0000000201004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080401), 0x1.0000000201004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fbfe), -0x1.0000000201008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080404), 0x1.000000020101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fbfb), -0x1.0000000201014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080440), 0x1.00000002011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7fbbf), -0x1.0000000201104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000080600), 0x1.00000002018p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7f9ff), -0x1.0000000201804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000082000), 0x1.0000000208p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7dfff), -0x1.0000000208004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000082004), 0x1.000000020801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7dffb), -0x1.0000000208014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000082010), 0x1.000000020804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7dfef), -0x1.0000000208044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000082040), 0x1.00000002081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7dfbf), -0x1.0000000208104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000082400), 0x1.0000000209p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff7dbff), -0x1.0000000209004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000088000), 0x1.000000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff77fff), -0x1.0000000220004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000088002), 0x1.0000000220008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff77ffd), -0x1.000000022000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000088010), 0x1.000000022004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff77fef), -0x1.0000000220044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000088080), 0x1.00000002202p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff77f7f), -0x1.0000000220204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000088400), 0x1.0000000221p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff77bff), -0x1.0000000221004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000089000), 0x1.0000000224p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff76fff), -0x1.0000000224004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090000), 0x1.000000024p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6ffff), -0x1.0000000240004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090001), 0x1.0000000240004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6fffe), -0x1.0000000240008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090004), 0x1.000000024001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6fffb), -0x1.0000000240014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090008), 0x1.000000024002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6fff7), -0x1.0000000240024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090040), 0x1.00000002401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6ffbf), -0x1.0000000240104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090200), 0x1.00000002408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6fdff), -0x1.0000000240804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000090400), 0x1.0000000241p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6fbff), -0x1.0000000241004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000092000), 0x1.0000000248p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff6dfff), -0x1.0000000248004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000098000), 0x1.000000026p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff67fff), -0x1.0000000260004p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c0000), 0x1.00000003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff3ffff), -0x1.0000000300004p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c0004), 0x1.000000030001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff3fffb), -0x1.0000000300014p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c0020), 0x1.000000030008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff3ffdf), -0x1.0000000300084p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c0040), 0x1.00000003001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff3ffbf), -0x1.0000000300104p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c0400), 0x1.0000000301p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff3fbff), -0x1.0000000301004p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c4000), 0x1.000000031p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff3bfff), -0x1.0000000310004p+50, 0x0p+0 },
+{ INT64_C(0x00040000000c8000), 0x1.000000032p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffff37fff), -0x1.0000000320004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400001), 0x1.0000001000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbffffe), -0x1.0000001000008p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400008), 0x1.000000100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbffff7), -0x1.0000001000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400010), 0x1.000000100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfffef), -0x1.0000001000044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400014), 0x1.000000100005p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfffeb), -0x1.0000001000054p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400040), 0x1.00000010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfffbf), -0x1.0000001000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400044), 0x1.000000100011p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfffbb), -0x1.0000001000114p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400048), 0x1.000000100012p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfffb7), -0x1.0000001000124p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400060), 0x1.000000100018p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfff9f), -0x1.0000001000184p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400080), 0x1.00000010002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfff7f), -0x1.0000001000204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400082), 0x1.0000001000208p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfff7d), -0x1.000000100020cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000400084), 0x1.000000100021p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfff7b), -0x1.0000001000214p+50, 0x0p+0 },
+{ INT64_C(0x00040000004000c0), 0x1.00000010003p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfff3f), -0x1.0000001000304p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400800), 0x1.0000001002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbff7ff), -0x1.0000001002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400802), 0x1.0000001002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbff7fd), -0x1.000000100200cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000400820), 0x1.000000100208p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbff7df), -0x1.0000001002084p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400840), 0x1.00000010021p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbff7bf), -0x1.0000001002104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000400c00), 0x1.0000001003p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbff3ff), -0x1.0000001003004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000402000), 0x1.0000001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfdfff), -0x1.0000001008004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000402002), 0x1.0000001008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfdffd), -0x1.000000100800cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000402004), 0x1.000000100801p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfdffb), -0x1.0000001008014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000402040), 0x1.00000010081p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfdfbf), -0x1.0000001008104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000402080), 0x1.00000010082p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfdf7f), -0x1.0000001008204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000402800), 0x1.000000100ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbfd7ff), -0x1.000000100a004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000420000), 0x1.000000108p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbdffff), -0x1.0000001080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000420008), 0x1.000000108002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbdfff7), -0x1.0000001080024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000420080), 0x1.00000010802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbdff7f), -0x1.0000001080204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000420100), 0x1.00000010804p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbdfeff), -0x1.0000001080404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000420200), 0x1.00000010808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbdfdff), -0x1.0000001080804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000420800), 0x1.0000001082p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbdf7ff), -0x1.0000001082004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000428000), 0x1.00000010ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffffffbd7fff), -0x1.00000010a0004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000600000), 0x1.00000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9fffff), -0x1.0000001800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000600002), 0x1.0000001800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9ffffd), -0x1.000000180000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000600020), 0x1.000000180008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9fffdf), -0x1.0000001800084p+50, 0x0p+0 },
+{ INT64_C(0x0004000000600100), 0x1.00000018004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9ffeff), -0x1.0000001800404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000600200), 0x1.00000018008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9ffdff), -0x1.0000001800804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000600800), 0x1.0000001802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9ff7ff), -0x1.0000001802004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000602000), 0x1.0000001808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9fdfff), -0x1.0000001808004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000608000), 0x1.000000182p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9f7fff), -0x1.0000001820004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000620000), 0x1.000000188p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff9dffff), -0x1.0000001880004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000700000), 0x1.0000001cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff8fffff), -0x1.0000001c00004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800008), 0x1.000000200002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ffff7), -0x1.0000002000024p+50, 0x0p+0 },
+{ INT64_C(0x000400000080000c), 0x1.000000200003p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ffff3), -0x1.0000002000034p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800040), 0x1.00000020001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fffbf), -0x1.0000002000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800048), 0x1.000000200012p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fffb7), -0x1.0000002000124p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800060), 0x1.000000200018p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fff9f), -0x1.0000002000184p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800080), 0x1.00000020002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fff7f), -0x1.0000002000204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800081), 0x1.0000002000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fff7e), -0x1.0000002000208p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800088), 0x1.000000200022p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fff77), -0x1.0000002000224p+50, 0x0p+0 },
+{ INT64_C(0x00040000008000a0), 0x1.000000200028p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7fff5f), -0x1.0000002000284p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800800), 0x1.0000002002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ff7ff), -0x1.0000002002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800804), 0x1.000000200201p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ff7fb), -0x1.0000002002014p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800820), 0x1.000000200208p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ff7df), -0x1.0000002002084p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800900), 0x1.00000020024p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ff6ff), -0x1.0000002002404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800a00), 0x1.00000020028p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ff5ff), -0x1.0000002002804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000800c00), 0x1.0000002003p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7ff3ff), -0x1.0000002003004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000808000), 0x1.000000202p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f7fff), -0x1.0000002020004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000808008), 0x1.000000202002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f7ff7), -0x1.0000002020024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000808040), 0x1.00000020201p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f7fbf), -0x1.0000002020104p+50, 0x0p+0 },
+{ INT64_C(0x0004000000808100), 0x1.00000020204p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f7eff), -0x1.0000002020404p+50, 0x0p+0 },
+{ INT64_C(0x0004000000808200), 0x1.00000020208p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f7dff), -0x1.0000002020804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000809000), 0x1.0000002024p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f6fff), -0x1.0000002024004p+50, 0x0p+0 },
+{ INT64_C(0x000400000080c000), 0x1.000000203p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7f3fff), -0x1.0000002030004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000820000), 0x1.000000208p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dffff), -0x1.0000002080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000820002), 0x1.0000002080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dfffd), -0x1.000000208000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000000820008), 0x1.000000208002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dfff7), -0x1.0000002080024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000820010), 0x1.000000208004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dffef), -0x1.0000002080044p+50, 0x0p+0 },
+{ INT64_C(0x0004000000820080), 0x1.00000020802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dff7f), -0x1.0000002080204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000820200), 0x1.00000020808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dfdff), -0x1.0000002080804p+50, 0x0p+0 },
+{ INT64_C(0x0004000000820400), 0x1.0000002081p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dfbff), -0x1.0000002081004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000821000), 0x1.0000002084p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7defff), -0x1.0000002084004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000824000), 0x1.000000209p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7dbfff), -0x1.0000002090004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000830000), 0x1.00000020cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff7cffff), -0x1.00000020c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000a00000), 0x1.00000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff5fffff), -0x1.0000002800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000a00008), 0x1.000000280002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff5ffff7), -0x1.0000002800024p+50, 0x0p+0 },
+{ INT64_C(0x0004000000a00080), 0x1.00000028002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff5fff7f), -0x1.0000002800204p+50, 0x0p+0 },
+{ INT64_C(0x0004000000a00800), 0x1.0000002802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff5ff7ff), -0x1.0000002802004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000a08000), 0x1.000000282p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff5f7fff), -0x1.0000002820004p+50, 0x0p+0 },
+{ INT64_C(0x0004000000a80000), 0x1.0000002ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffffff57ffff), -0x1.0000002a00004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000001), 0x1.0000008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfffffe), -0x1.0000008000008p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000002), 0x1.0000008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfffffd), -0x1.000000800000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000002000010), 0x1.000000800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffffef), -0x1.0000008000044p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000014), 0x1.000000800005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffffeb), -0x1.0000008000054p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000020), 0x1.000000800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffffdf), -0x1.0000008000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000028), 0x1.00000080000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffffd7), -0x1.00000080000a4p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000030), 0x1.00000080000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffffcf), -0x1.00000080000c4p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000100), 0x1.00000080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfffeff), -0x1.0000008000404p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000108), 0x1.000000800042p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfffef7), -0x1.0000008000424p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000120), 0x1.000000800048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfffedf), -0x1.0000008000484p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000140), 0x1.00000080005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfffebf), -0x1.0000008000504p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000800), 0x1.0000008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfff7ff), -0x1.0000008002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000802), 0x1.0000008002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfff7fd), -0x1.000000800200cp+50, 0x0p+0 },
+{ INT64_C(0x0004000002000810), 0x1.000000800204p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfff7ef), -0x1.0000008002044p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000900), 0x1.00000080024p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfff6ff), -0x1.0000008002404p+50, 0x0p+0 },
+{ INT64_C(0x0004000002000c00), 0x1.0000008003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfff3ff), -0x1.0000008003004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002004000), 0x1.000000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbfff), -0x1.0000008010004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002004002), 0x1.0000008010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbffd), -0x1.000000801000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000002004020), 0x1.000000801008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbfdf), -0x1.0000008010084p+50, 0x0p+0 },
+{ INT64_C(0x0004000002004080), 0x1.00000080102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbf7f), -0x1.0000008010204p+50, 0x0p+0 },
+{ INT64_C(0x0004000002004100), 0x1.00000080104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbeff), -0x1.0000008010404p+50, 0x0p+0 },
+{ INT64_C(0x0004000002004200), 0x1.00000080108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbdff), -0x1.0000008010804p+50, 0x0p+0 },
+{ INT64_C(0x0004000002004400), 0x1.0000008011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffbbff), -0x1.0000008011004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002005000), 0x1.0000008014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdffafff), -0x1.0000008014004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002040000), 0x1.00000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfbffff), -0x1.0000008100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002040008), 0x1.000000810002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfbfff7), -0x1.0000008100024p+50, 0x0p+0 },
+{ INT64_C(0x0004000002040080), 0x1.00000081002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfbff7f), -0x1.0000008100204p+50, 0x0p+0 },
+{ INT64_C(0x0004000002040800), 0x1.0000008102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfbf7ff), -0x1.0000008102004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002041000), 0x1.0000008104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfbefff), -0x1.0000008104004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002042000), 0x1.0000008108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfbdfff), -0x1.0000008108004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002050000), 0x1.000000814p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdfaffff), -0x1.0000008140004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002060000), 0x1.000000818p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdf9ffff), -0x1.0000008180004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002100000), 0x1.00000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdefffff), -0x1.0000008400004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002100001), 0x1.0000008400004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdeffffe), -0x1.0000008400008p+50, 0x0p+0 },
+{ INT64_C(0x0004000002100008), 0x1.000000840002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdeffff7), -0x1.0000008400024p+50, 0x0p+0 },
+{ INT64_C(0x0004000002100010), 0x1.000000840004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdefffef), -0x1.0000008400044p+50, 0x0p+0 },
+{ INT64_C(0x0004000002100100), 0x1.00000084004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdeffeff), -0x1.0000008400404p+50, 0x0p+0 },
+{ INT64_C(0x0004000002101000), 0x1.0000008404p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdefefff), -0x1.0000008404004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002102000), 0x1.0000008408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdefdfff), -0x1.0000008408004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002110000), 0x1.000000844p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdeeffff), -0x1.0000008440004p+50, 0x0p+0 },
+{ INT64_C(0x0004000002140000), 0x1.00000085p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffdebffff), -0x1.0000008500004p+50, 0x0p+0 },
+{ INT64_C(0x0004000003000000), 0x1.000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcffffff), -0x1.000000c000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000003000008), 0x1.000000c00002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcfffff7), -0x1.000000c000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000003000020), 0x1.000000c00008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcffffdf), -0x1.000000c000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000003000200), 0x1.000000c0008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcfffdff), -0x1.000000c000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000003001000), 0x1.000000c004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcffefff), -0x1.000000c004004p+50, 0x0p+0 },
+{ INT64_C(0x0004000003002000), 0x1.000000c008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcffdfff), -0x1.000000c008004p+50, 0x0p+0 },
+{ INT64_C(0x0004000003008000), 0x1.000000c02p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcff7fff), -0x1.000000c020004p+50, 0x0p+0 },
+{ INT64_C(0x0004000003080000), 0x1.000000c2p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcf7ffff), -0x1.000000c200004p+50, 0x0p+0 },
+{ INT64_C(0x0004000003400000), 0x1.000000dp+50, 0x0p+0 },
+{ INT64_C(0xfffbfffffcbfffff), -0x1.000000d000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000008), 0x1.000008000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffff7), -0x1.0000080000024p+50, 0x0p+0 },
+{ INT64_C(0x000400002000000c), 0x1.000008000003p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffff3), -0x1.0000080000034p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000020), 0x1.000008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffffdf), -0x1.0000080000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000021), 0x1.0000080000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffffde), -0x1.0000080000088p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000022), 0x1.0000080000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffffdd), -0x1.000008000008cp+50, 0x0p+0 },
+{ INT64_C(0x0004000020000030), 0x1.00000800000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffffcf), -0x1.00000800000c4p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000100), 0x1.00000800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffeff), -0x1.0000080000404p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000104), 0x1.000008000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffefb), -0x1.0000080000414p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000120), 0x1.000008000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffedf), -0x1.0000080000484p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000200), 0x1.00000800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffdff), -0x1.0000080000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000201), 0x1.0000080000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffdfe), -0x1.0000080000808p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000202), 0x1.0000080000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffdfd), -0x1.000008000080cp+50, 0x0p+0 },
+{ INT64_C(0x0004000020000204), 0x1.000008000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffdfb), -0x1.0000080000814p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000208), 0x1.000008000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffdf7), -0x1.0000080000824p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000220), 0x1.000008000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffddf), -0x1.0000080000884p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000280), 0x1.0000080000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffd7f), -0x1.0000080000a04p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000300), 0x1.0000080000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffcff), -0x1.0000080000c04p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000400), 0x1.0000080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffbff), -0x1.0000080001004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000401), 0x1.0000080001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffbfe), -0x1.0000080001008p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000408), 0x1.000008000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffbf7), -0x1.0000080001024p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000410), 0x1.000008000104p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffbef), -0x1.0000080001044p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000440), 0x1.00000800011p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffbbf), -0x1.0000080001104p+50, 0x0p+0 },
+{ INT64_C(0x0004000020000480), 0x1.00000800012p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffffb7f), -0x1.0000080001204p+50, 0x0p+0 },
+{ INT64_C(0x0004000020002000), 0x1.0000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffdfff), -0x1.0000080008004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020002008), 0x1.000008000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffdff7), -0x1.0000080008024p+50, 0x0p+0 },
+{ INT64_C(0x0004000020002010), 0x1.000008000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffdfef), -0x1.0000080008044p+50, 0x0p+0 },
+{ INT64_C(0x0004000020002100), 0x1.00000800084p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffdeff), -0x1.0000080008404p+50, 0x0p+0 },
+{ INT64_C(0x0004000020003000), 0x1.000008000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfffcfff), -0x1.000008000c004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020008000), 0x1.000008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfff7fff), -0x1.0000080020004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020008001), 0x1.0000080020004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfff7ffe), -0x1.0000080020008p+50, 0x0p+0 },
+{ INT64_C(0x0004000020008010), 0x1.000008002004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfff7fef), -0x1.0000080020044p+50, 0x0p+0 },
+{ INT64_C(0x0004000020008080), 0x1.00000800202p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfff7f7f), -0x1.0000080020204p+50, 0x0p+0 },
+{ INT64_C(0x0004000020008400), 0x1.0000080021p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfff7bff), -0x1.0000080021004p+50, 0x0p+0 },
+{ INT64_C(0x000400002000c000), 0x1.000008003p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfff3fff), -0x1.0000080030004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020000), 0x1.000008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdffff), -0x1.0000080080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020001), 0x1.0000080080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdfffe), -0x1.0000080080008p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020010), 0x1.000008008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdffef), -0x1.0000080080044p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020020), 0x1.000008008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdffdf), -0x1.0000080080084p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020040), 0x1.00000800801p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdffbf), -0x1.0000080080104p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020080), 0x1.00000800802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdff7f), -0x1.0000080080204p+50, 0x0p+0 },
+{ INT64_C(0x0004000020020200), 0x1.00000800808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffdfdff), -0x1.0000080080804p+50, 0x0p+0 },
+{ INT64_C(0x0004000020022000), 0x1.0000080088p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffddfff), -0x1.0000080088004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020030000), 0x1.00000800cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdffcffff), -0x1.00000800c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020080000), 0x1.00000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff7ffff), -0x1.0000080200004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020080008), 0x1.000008020002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff7fff7), -0x1.0000080200024p+50, 0x0p+0 },
+{ INT64_C(0x0004000020080040), 0x1.00000802001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff7ffbf), -0x1.0000080200104p+50, 0x0p+0 },
+{ INT64_C(0x0004000020080200), 0x1.00000802008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff7fdff), -0x1.0000080200804p+50, 0x0p+0 },
+{ INT64_C(0x0004000020081000), 0x1.0000080204p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff7efff), -0x1.0000080204004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020088000), 0x1.000008022p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff77fff), -0x1.0000080220004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020090000), 0x1.000008024p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdff6ffff), -0x1.0000080240004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400000), 0x1.0000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbfffff), -0x1.0000081000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400004), 0x1.000008100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbffffb), -0x1.0000081000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400008), 0x1.000008100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbffff7), -0x1.0000081000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400010), 0x1.000008100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbfffef), -0x1.0000081000044p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400020), 0x1.000008100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbfffdf), -0x1.0000081000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400080), 0x1.00000810002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbfff7f), -0x1.0000081000204p+50, 0x0p+0 },
+{ INT64_C(0x0004000020400200), 0x1.00000810008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbffdff), -0x1.0000081000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000020401000), 0x1.0000081004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbfefff), -0x1.0000081004004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020408000), 0x1.000008102p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbf7fff), -0x1.0000081020004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020410000), 0x1.000008104p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbeffff), -0x1.0000081040004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020420000), 0x1.000008108p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfbdffff), -0x1.0000081080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000020500000), 0x1.00000814p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdfafffff), -0x1.0000081400004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021000000), 0x1.0000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdeffffff), -0x1.0000084000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021000004), 0x1.000008400001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdefffffb), -0x1.0000084000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000021000040), 0x1.00000840001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdeffffbf), -0x1.0000084000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000021000400), 0x1.0000084001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdefffbff), -0x1.0000084001004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021000800), 0x1.0000084002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdefff7ff), -0x1.0000084002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021008000), 0x1.000008402p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdeff7fff), -0x1.0000084020004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021020000), 0x1.000008408p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdefdffff), -0x1.0000084080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021080000), 0x1.00000842p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdef7ffff), -0x1.0000084200004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021100000), 0x1.00000844p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdeefffff), -0x1.0000084400004p+50, 0x0p+0 },
+{ INT64_C(0x0004000021400000), 0x1.0000085p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdebfffff), -0x1.0000085000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000024000000), 0x1.000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbffffff), -0x1.0000090000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000024000008), 0x1.000009000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbfffff7), -0x1.0000090000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000024000040), 0x1.00000900001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbffffbf), -0x1.0000090000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000024000080), 0x1.00000900002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbffff7f), -0x1.0000090000204p+50, 0x0p+0 },
+{ INT64_C(0x0004000024000400), 0x1.0000090001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbfffbff), -0x1.0000090001004p+50, 0x0p+0 },
+{ INT64_C(0x0004000024004000), 0x1.000009001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbffbfff), -0x1.0000090010004p+50, 0x0p+0 },
+{ INT64_C(0x0004000024020000), 0x1.000009008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbfdffff), -0x1.0000090080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000024200000), 0x1.00000908p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbdfffff), -0x1.0000090800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000024400000), 0x1.0000091p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffdbbfffff), -0x1.0000091000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000030000000), 0x1.00000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcfffffff), -0x1.00000c0000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000030000004), 0x1.00000c000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcffffffb), -0x1.00000c0000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000030000008), 0x1.00000c000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcffffff7), -0x1.00000c0000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000030000020), 0x1.00000c000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcfffffdf), -0x1.00000c0000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000030000200), 0x1.00000c00008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcffffdff), -0x1.00000c0000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000030001000), 0x1.00000c0004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcfffefff), -0x1.00000c0004004p+50, 0x0p+0 },
+{ INT64_C(0x0004000030010000), 0x1.00000c004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcffeffff), -0x1.00000c0040004p+50, 0x0p+0 },
+{ INT64_C(0x0004000030040000), 0x1.00000c01p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcffbffff), -0x1.00000c0100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000030400000), 0x1.00000c1p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcfbfffff), -0x1.00000c1000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000030800000), 0x1.00000c2p+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcf7fffff), -0x1.00000c2000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000034000000), 0x1.00000dp+50, 0x0p+0 },
+{ INT64_C(0xfffbffffcbffffff), -0x1.00000d0000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000004), 0x1.000040000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffffffb), -0x1.0000400000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000006), 0x1.0000400000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffffff9), -0x1.000040000001cp+50, 0x0p+0 },
+{ INT64_C(0x0004000100000020), 0x1.000040000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffffdf), -0x1.0000400000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000021), 0x1.0000400000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffffde), -0x1.0000400000088p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000024), 0x1.000040000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffffdb), -0x1.0000400000094p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000200), 0x1.00004000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffffdff), -0x1.0000400000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000204), 0x1.000040000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffffdfb), -0x1.0000400000814p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000210), 0x1.000040000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffffdef), -0x1.0000400000844p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000220), 0x1.000040000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffffddf), -0x1.0000400000884p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000800), 0x1.0000400002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffff7ff), -0x1.0000400002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000802), 0x1.0000400002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffff7fd), -0x1.000040000200cp+50, 0x0p+0 },
+{ INT64_C(0x0004000100000804), 0x1.000040000201p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffff7fb), -0x1.0000400002014p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000820), 0x1.000040000208p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffff7df), -0x1.0000400002084p+50, 0x0p+0 },
+{ INT64_C(0x0004000100000a00), 0x1.00004000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffff5ff), -0x1.0000400002804p+50, 0x0p+0 },
+{ INT64_C(0x0004000100001000), 0x1.0000400004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffefff), -0x1.0000400004004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100001002), 0x1.0000400004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffeffd), -0x1.000040000400cp+50, 0x0p+0 },
+{ INT64_C(0x0004000100001010), 0x1.000040000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffefef), -0x1.0000400004044p+50, 0x0p+0 },
+{ INT64_C(0x0004000100001100), 0x1.00004000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffeeff), -0x1.0000400004404p+50, 0x0p+0 },
+{ INT64_C(0x0004000100001400), 0x1.0000400005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffebff), -0x1.0000400005004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100004000), 0x1.000040001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbfff), -0x1.0000400010004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100004002), 0x1.0000400010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbffd), -0x1.000040001000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000100004010), 0x1.000040001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbfef), -0x1.0000400010044p+50, 0x0p+0 },
+{ INT64_C(0x0004000100004040), 0x1.00004000101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbfbf), -0x1.0000400010104p+50, 0x0p+0 },
+{ INT64_C(0x0004000100004080), 0x1.00004000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbf7f), -0x1.0000400010204p+50, 0x0p+0 },
+{ INT64_C(0x0004000100004200), 0x1.00004000108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbdff), -0x1.0000400010804p+50, 0x0p+0 },
+{ INT64_C(0x0004000100004400), 0x1.0000400011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffbbff), -0x1.0000400011004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100005000), 0x1.0000400014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffffafff), -0x1.0000400014004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040000), 0x1.00004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbffff), -0x1.0000400100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040001), 0x1.0000400100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbfffe), -0x1.0000400100008p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040002), 0x1.0000400100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbfffd), -0x1.000040010000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000100040008), 0x1.000040010002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbfff7), -0x1.0000400100024p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040010), 0x1.000040010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbffef), -0x1.0000400100044p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040040), 0x1.00004001001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbffbf), -0x1.0000400100104p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040080), 0x1.00004001002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbff7f), -0x1.0000400100204p+50, 0x0p+0 },
+{ INT64_C(0x0004000100040100), 0x1.00004001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbfeff), -0x1.0000400100404p+50, 0x0p+0 },
+{ INT64_C(0x0004000100041000), 0x1.0000400104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffbefff), -0x1.0000400104004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100048000), 0x1.000040012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffb7fff), -0x1.0000400120004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100050000), 0x1.000040014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefffaffff), -0x1.0000400140004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100400000), 0x1.0000401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbfffff), -0x1.0000401000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100400004), 0x1.000040100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbffffb), -0x1.0000401000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000100400040), 0x1.00004010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbfffbf), -0x1.0000401000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000100400100), 0x1.00004010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbffeff), -0x1.0000401000404p+50, 0x0p+0 },
+{ INT64_C(0x0004000100400200), 0x1.00004010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbffdff), -0x1.0000401000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000100400400), 0x1.0000401001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbffbff), -0x1.0000401001004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100401000), 0x1.0000401004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbfefff), -0x1.0000401004004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100410000), 0x1.000040104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbeffff), -0x1.0000401040004p+50, 0x0p+0 },
+{ INT64_C(0x0004000100440000), 0x1.00004011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeffbbffff), -0x1.0000401100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102000000), 0x1.0000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdffffff), -0x1.0000408000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102000002), 0x1.0000408000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdfffffd), -0x1.000040800000cp+50, 0x0p+0 },
+{ INT64_C(0x0004000102000020), 0x1.000040800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdffffdf), -0x1.0000408000084p+50, 0x0p+0 },
+{ INT64_C(0x0004000102000080), 0x1.00004080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdffff7f), -0x1.0000408000204p+50, 0x0p+0 },
+{ INT64_C(0x0004000102000800), 0x1.0000408002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdfff7ff), -0x1.0000408002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102001000), 0x1.0000408004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdffefff), -0x1.0000408004004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102004000), 0x1.000040801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdffbfff), -0x1.0000408010004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102010000), 0x1.000040804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdfeffff), -0x1.0000408040004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102040000), 0x1.00004081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdfbffff), -0x1.0000408100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102080000), 0x1.00004082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefdf7ffff), -0x1.0000408200004p+50, 0x0p+0 },
+{ INT64_C(0x0004000102200000), 0x1.00004088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefddfffff), -0x1.0000408800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104000000), 0x1.000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbffffff), -0x1.0000410000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104000001), 0x1.0000410000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbfffffe), -0x1.0000410000008p+50, 0x0p+0 },
+{ INT64_C(0x0004000104000008), 0x1.000041000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbfffff7), -0x1.0000410000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000104000080), 0x1.00004100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbffff7f), -0x1.0000410000204p+50, 0x0p+0 },
+{ INT64_C(0x0004000104000800), 0x1.0000410002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbfff7ff), -0x1.0000410002004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104002000), 0x1.0000410008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbffdfff), -0x1.0000410008004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104008000), 0x1.000041002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbff7fff), -0x1.0000410020004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104020000), 0x1.000041008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbfdffff), -0x1.0000410080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104040000), 0x1.00004101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbfbffff), -0x1.0000410100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104200000), 0x1.00004108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefbdfffff), -0x1.0000410800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000104800000), 0x1.0000412p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffefb7fffff), -0x1.0000412000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000106000000), 0x1.0000418p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffef9ffffff), -0x1.0000418000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000110000000), 0x1.000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeefffffff), -0x1.0000440000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000110000004), 0x1.000044000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeeffffffb), -0x1.0000440000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000110000008), 0x1.000044000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeeffffff7), -0x1.0000440000024p+50, 0x0p+0 },
+{ INT64_C(0x0004000110000040), 0x1.00004400001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeefffffbf), -0x1.0000440000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000110000100), 0x1.00004400004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeeffffeff), -0x1.0000440000404p+50, 0x0p+0 },
+{ INT64_C(0x0004000110000200), 0x1.00004400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeeffffdff), -0x1.0000440000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000110002000), 0x1.0000440008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeefffdfff), -0x1.0000440008004p+50, 0x0p+0 },
+{ INT64_C(0x0004000110004000), 0x1.000044001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeefffbfff), -0x1.0000440010004p+50, 0x0p+0 },
+{ INT64_C(0x0004000110020000), 0x1.000044008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeeffdffff), -0x1.0000440080004p+50, 0x0p+0 },
+{ INT64_C(0x0004000110200000), 0x1.00004408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeefdfffff), -0x1.0000440800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000110800000), 0x1.0000442p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeef7fffff), -0x1.0000442000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000112000000), 0x1.0000448p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeedffffff), -0x1.0000448000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140000000), 0x1.00005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebfffffff), -0x1.0000500000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140000004), 0x1.000050000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebffffffb), -0x1.0000500000014p+50, 0x0p+0 },
+{ INT64_C(0x0004000140000010), 0x1.000050000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebfffffef), -0x1.0000500000044p+50, 0x0p+0 },
+{ INT64_C(0x0004000140000040), 0x1.00005000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebfffffbf), -0x1.0000500000104p+50, 0x0p+0 },
+{ INT64_C(0x0004000140000200), 0x1.00005000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebffffdff), -0x1.0000500000804p+50, 0x0p+0 },
+{ INT64_C(0x0004000140000400), 0x1.0000500001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebffffbff), -0x1.0000500001004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140002000), 0x1.0000500008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebfffdfff), -0x1.0000500008004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140004000), 0x1.000050001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebfffbfff), -0x1.0000500010004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140010000), 0x1.000050004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebffeffff), -0x1.0000500040004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140040000), 0x1.00005001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebffbffff), -0x1.0000500100004p+50, 0x0p+0 },
+{ INT64_C(0x0004000140200000), 0x1.00005008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebfdfffff), -0x1.0000500800004p+50, 0x0p+0 },
+{ INT64_C(0x0004000142000000), 0x1.0000508p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebdffffff), -0x1.0000508000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000144000000), 0x1.000051p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffebbffffff), -0x1.0000510000004p+50, 0x0p+0 },
+{ INT64_C(0x0004000148000000), 0x1.000052p+50, 0x0p+0 },
+{ INT64_C(0xfffbfffeb7ffffff), -0x1.0000520000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000008), 0x1.000400000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffff7), -0x1.0004000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000009), 0x1.0004000000024p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffff6), -0x1.0004000000028p+50, 0x0p+0 },
+{ INT64_C(0x000400100000000a), 0x1.0004000000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffff5), -0x1.000400000002cp+50, 0x0p+0 },
+{ INT64_C(0x0004001000000080), 0x1.00040000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffff7f), -0x1.0004000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000088), 0x1.000400000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffff77), -0x1.0004000000224p+50, 0x0p+0 },
+{ INT64_C(0x00040010000000a0), 0x1.000400000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffff5f), -0x1.0004000000284p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000200), 0x1.00040000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffdff), -0x1.0004000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000201), 0x1.0004000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffdfe), -0x1.0004000000808p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000202), 0x1.0004000000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffdfd), -0x1.000400000080cp+50, 0x0p+0 },
+{ INT64_C(0x0004001000000220), 0x1.000400000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffddf), -0x1.0004000000884p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000400), 0x1.0004000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffbff), -0x1.0004000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000401), 0x1.0004000001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffbfe), -0x1.0004000001008p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000402), 0x1.0004000001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffbfd), -0x1.000400000100cp+50, 0x0p+0 },
+{ INT64_C(0x0004001000000404), 0x1.000400000101p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffbfb), -0x1.0004000001014p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000408), 0x1.000400000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffbf7), -0x1.0004000001024p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000410), 0x1.000400000104p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffbef), -0x1.0004000001044p+50, 0x0p+0 },
+{ INT64_C(0x0004001000000500), 0x1.00040000014p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffffaff), -0x1.0004000001404p+50, 0x0p+0 },
+{ INT64_C(0x0004001000002000), 0x1.0004000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffdfff), -0x1.0004000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000002008), 0x1.000400000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffdff7), -0x1.0004000008024p+50, 0x0p+0 },
+{ INT64_C(0x0004001000002080), 0x1.00040000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffdf7f), -0x1.0004000008204p+50, 0x0p+0 },
+{ INT64_C(0x0004001000002800), 0x1.000400000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffffd7ff), -0x1.000400000a004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000020000), 0x1.000400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffdffff), -0x1.0004000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000020002), 0x1.0004000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffdfffd), -0x1.000400008000cp+50, 0x0p+0 },
+{ INT64_C(0x0004001000020010), 0x1.000400008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffdffef), -0x1.0004000080044p+50, 0x0p+0 },
+{ INT64_C(0x0004001000020080), 0x1.00040000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffdff7f), -0x1.0004000080204p+50, 0x0p+0 },
+{ INT64_C(0x0004001000020200), 0x1.00040000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffdfdff), -0x1.0004000080804p+50, 0x0p+0 },
+{ INT64_C(0x0004001000022000), 0x1.0004000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffddfff), -0x1.0004000088004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000030000), 0x1.00040000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffffcffff), -0x1.00040000c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200000), 0x1.00040008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdfffff), -0x1.0004000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200004), 0x1.000400080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdffffb), -0x1.0004000800014p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200008), 0x1.000400080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdffff7), -0x1.0004000800024p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200020), 0x1.000400080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdfffdf), -0x1.0004000800084p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200080), 0x1.00040008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdfff7f), -0x1.0004000800204p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200100), 0x1.00040008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdffeff), -0x1.0004000800404p+50, 0x0p+0 },
+{ INT64_C(0x0004001000200800), 0x1.0004000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdff7ff), -0x1.0004000802004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000201000), 0x1.0004000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdfefff), -0x1.0004000804004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000208000), 0x1.000400082p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffdf7fff), -0x1.0004000820004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000220000), 0x1.000400088p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffddffff), -0x1.0004000880004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000400000), 0x1.0004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbfffff), -0x1.0004001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000400004), 0x1.000400100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbffffb), -0x1.0004001000014p+50, 0x0p+0 },
+{ INT64_C(0x0004001000400010), 0x1.000400100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbfffef), -0x1.0004001000044p+50, 0x0p+0 },
+{ INT64_C(0x0004001000400040), 0x1.00040010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbfffbf), -0x1.0004001000104p+50, 0x0p+0 },
+{ INT64_C(0x0004001000400400), 0x1.0004001001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbffbff), -0x1.0004001001004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000400800), 0x1.0004001002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbff7ff), -0x1.0004001002004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000402000), 0x1.0004001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbfdfff), -0x1.0004001008004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000404000), 0x1.000400101p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbfbfff), -0x1.0004001010004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000410000), 0x1.000400104p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbeffff), -0x1.0004001040004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000420000), 0x1.000400108p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffbdffff), -0x1.0004001080004p+50, 0x0p+0 },
+{ INT64_C(0x0004001000480000), 0x1.00040012p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefffb7ffff), -0x1.0004001200004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004000000), 0x1.000401p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbffffff), -0x1.0004010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004000002), 0x1.0004010000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbfffffd), -0x1.000401000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004001004000004), 0x1.000401000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbfffffb), -0x1.0004010000014p+50, 0x0p+0 },
+{ INT64_C(0x0004001004000040), 0x1.00040100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbffffbf), -0x1.0004010000104p+50, 0x0p+0 },
+{ INT64_C(0x0004001004000200), 0x1.00040100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbfffdff), -0x1.0004010000804p+50, 0x0p+0 },
+{ INT64_C(0x0004001004000400), 0x1.0004010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbfffbff), -0x1.0004010001004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004002000), 0x1.0004010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbffdfff), -0x1.0004010008004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004010000), 0x1.000401004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbfeffff), -0x1.0004010040004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004040000), 0x1.00040101p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbfbffff), -0x1.0004010100004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004080000), 0x1.00040102p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbf7ffff), -0x1.0004010200004p+50, 0x0p+0 },
+{ INT64_C(0x0004001004400000), 0x1.0004011p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeffbbfffff), -0x1.0004011000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040000000), 0x1.00041p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbfffffff), -0x1.0004100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040000002), 0x1.0004100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbffffffd), -0x1.000410000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004001040000020), 0x1.000410000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbfffffdf), -0x1.0004100000084p+50, 0x0p+0 },
+{ INT64_C(0x0004001040000080), 0x1.00041000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbfffff7f), -0x1.0004100000204p+50, 0x0p+0 },
+{ INT64_C(0x0004001040000200), 0x1.00041000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbffffdff), -0x1.0004100000804p+50, 0x0p+0 },
+{ INT64_C(0x0004001040000800), 0x1.0004100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbffff7ff), -0x1.0004100002004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040002000), 0x1.0004100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbfffdfff), -0x1.0004100008004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040008000), 0x1.000410002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbfff7fff), -0x1.0004100020004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040020000), 0x1.000410008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbffdffff), -0x1.0004100080004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040040000), 0x1.00041001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbffbffff), -0x1.0004100100004p+50, 0x0p+0 },
+{ INT64_C(0x0004001040200000), 0x1.00041008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbfdfffff), -0x1.0004100800004p+50, 0x0p+0 },
+{ INT64_C(0x0004001041000000), 0x1.0004104p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefbeffffff), -0x1.0004104000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001048000000), 0x1.000412p+50, 0x0p+0 },
+{ INT64_C(0xfffbffefb7ffffff), -0x1.0004120000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001060000000), 0x1.000418p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef9fffffff), -0x1.0004180000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001080000000), 0x1.00042p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7fffffff), -0x1.0004200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001080000002), 0x1.0004200000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7ffffffd), -0x1.000420000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004001080000010), 0x1.000420000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7fffffef), -0x1.0004200000044p+50, 0x0p+0 },
+{ INT64_C(0x0004001080000080), 0x1.00042000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7fffff7f), -0x1.0004200000204p+50, 0x0p+0 },
+{ INT64_C(0x0004001080000200), 0x1.00042000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7ffffdff), -0x1.0004200000804p+50, 0x0p+0 },
+{ INT64_C(0x0004001080001000), 0x1.0004200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7fffefff), -0x1.0004200004004p+50, 0x0p+0 },
+{ INT64_C(0x0004001080010000), 0x1.000420004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7ffeffff), -0x1.0004200040004p+50, 0x0p+0 },
+{ INT64_C(0x0004001080020000), 0x1.000420008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7ffdffff), -0x1.0004200080004p+50, 0x0p+0 },
+{ INT64_C(0x0004001080100000), 0x1.00042004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7fefffff), -0x1.0004200400004p+50, 0x0p+0 },
+{ INT64_C(0x0004001080800000), 0x1.0004202p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7f7fffff), -0x1.0004202000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001084000000), 0x1.000421p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef7bffffff), -0x1.0004210000004p+50, 0x0p+0 },
+{ INT64_C(0x00040010a0000000), 0x1.000428p+50, 0x0p+0 },
+{ INT64_C(0xfffbffef5fffffff), -0x1.0004280000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200000000), 0x1.00048p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedffffffff), -0x1.0004800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200000004), 0x1.000480000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedfffffffb), -0x1.0004800000014p+50, 0x0p+0 },
+{ INT64_C(0x0004001200000020), 0x1.000480000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedffffffdf), -0x1.0004800000084p+50, 0x0p+0 },
+{ INT64_C(0x0004001200000200), 0x1.00048000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedfffffdff), -0x1.0004800000804p+50, 0x0p+0 },
+{ INT64_C(0x0004001200000800), 0x1.0004800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedfffff7ff), -0x1.0004800002004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200002000), 0x1.0004800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedffffdfff), -0x1.0004800008004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200008000), 0x1.000480002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedffff7fff), -0x1.0004800020004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200010000), 0x1.000480004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedfffeffff), -0x1.0004800040004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200100000), 0x1.00048004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedffefffff), -0x1.0004800400004p+50, 0x0p+0 },
+{ INT64_C(0x0004001200800000), 0x1.0004802p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedff7fffff), -0x1.0004802000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001208000000), 0x1.000482p+50, 0x0p+0 },
+{ INT64_C(0xfffbffedf7ffffff), -0x1.0004820000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001220000000), 0x1.000488p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeddfffffff), -0x1.0004880000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400000000), 0x1.0005p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebffffffff), -0x1.0005000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400000001), 0x1.0005000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfffffffe), -0x1.0005000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004001400000002), 0x1.0005000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfffffffd), -0x1.000500000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004001400000020), 0x1.000500000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebffffffdf), -0x1.0005000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004001400000100), 0x1.00050000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfffffeff), -0x1.0005000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004001400000800), 0x1.0005000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfffff7ff), -0x1.0005000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400001000), 0x1.0005000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebffffefff), -0x1.0005000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400008000), 0x1.000500002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebffff7fff), -0x1.0005000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400010000), 0x1.000500004p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfffeffff), -0x1.0005000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400080000), 0x1.00050002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfff7ffff), -0x1.0005000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004001400800000), 0x1.0005002p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebff7fffff), -0x1.0005002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001402000000), 0x1.0005008p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebfdffffff), -0x1.0005008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001420000000), 0x1.000508p+50, 0x0p+0 },
+{ INT64_C(0xfffbffebdfffffff), -0x1.0005080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001500000000), 0x1.00054p+50, 0x0p+0 },
+{ INT64_C(0xfffbffeaffffffff), -0x1.0005400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004001600000000), 0x1.00058p+50, 0x0p+0 },
+{ INT64_C(0xfffbffe9ffffffff), -0x1.0005800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000001), 0x1.0040000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffffe), -0x1.0040000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000008), 0x1.004000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffff7), -0x1.0040000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000009), 0x1.0040000000024p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffff6), -0x1.0040000000028p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000010), 0x1.004000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffffef), -0x1.0040000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000018), 0x1.004000000006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffffe7), -0x1.0040000000064p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000100), 0x1.00400000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffeff), -0x1.0040000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000102), 0x1.0040000000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffefd), -0x1.004000000040cp+50, 0x0p+0 },
+{ INT64_C(0x0004010000000108), 0x1.004000000042p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffef7), -0x1.0040000000424p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000140), 0x1.00400000005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffebf), -0x1.0040000000504p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000400), 0x1.0040000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffbff), -0x1.0040000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000404), 0x1.004000000101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffbfb), -0x1.0040000001014p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000408), 0x1.004000000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffbf7), -0x1.0040000001024p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000440), 0x1.00400000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffbbf), -0x1.0040000001104p+50, 0x0p+0 },
+{ INT64_C(0x0004010000000480), 0x1.00400000012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffffb7f), -0x1.0040000001204p+50, 0x0p+0 },
+{ INT64_C(0x0004010000001000), 0x1.0040000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffefff), -0x1.0040000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000001004), 0x1.004000000401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffeffb), -0x1.0040000004014p+50, 0x0p+0 },
+{ INT64_C(0x0004010000001008), 0x1.004000000402p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffeff7), -0x1.0040000004024p+50, 0x0p+0 },
+{ INT64_C(0x0004010000001020), 0x1.004000000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffefdf), -0x1.0040000004084p+50, 0x0p+0 },
+{ INT64_C(0x0004010000001200), 0x1.00400000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffedff), -0x1.0040000004804p+50, 0x0p+0 },
+{ INT64_C(0x0004010000002000), 0x1.0040000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffdfff), -0x1.0040000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000002002), 0x1.0040000008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffdffd), -0x1.004000000800cp+50, 0x0p+0 },
+{ INT64_C(0x0004010000002004), 0x1.004000000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffdffb), -0x1.0040000008014p+50, 0x0p+0 },
+{ INT64_C(0x0004010000002010), 0x1.004000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffdfef), -0x1.0040000008044p+50, 0x0p+0 },
+{ INT64_C(0x0004010000002100), 0x1.00400000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffdeff), -0x1.0040000008404p+50, 0x0p+0 },
+{ INT64_C(0x0004010000002200), 0x1.00400000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffddff), -0x1.0040000008804p+50, 0x0p+0 },
+{ INT64_C(0x0004010000002400), 0x1.0040000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffffdbff), -0x1.0040000009004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008000), 0x1.004000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7fff), -0x1.0040000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008008), 0x1.004000002002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7ff7), -0x1.0040000020024p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008010), 0x1.004000002004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7fef), -0x1.0040000020044p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008040), 0x1.00400000201p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7fbf), -0x1.0040000020104p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008080), 0x1.00400000202p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7f7f), -0x1.0040000020204p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008100), 0x1.00400000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7eff), -0x1.0040000020404p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008200), 0x1.00400000208p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7dff), -0x1.0040000020804p+50, 0x0p+0 },
+{ INT64_C(0x0004010000008400), 0x1.0040000021p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff7bff), -0x1.0040000021004p+50, 0x0p+0 },
+{ INT64_C(0x000401000000c000), 0x1.004000003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffff3fff), -0x1.0040000030004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000020000), 0x1.004000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffdffff), -0x1.0040000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000020004), 0x1.004000008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffdfffb), -0x1.0040000080014p+50, 0x0p+0 },
+{ INT64_C(0x0004010000020040), 0x1.00400000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffdffbf), -0x1.0040000080104p+50, 0x0p+0 },
+{ INT64_C(0x0004010000020400), 0x1.0040000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffdfbff), -0x1.0040000081004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000022000), 0x1.0040000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffffddfff), -0x1.0040000088004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000200000), 0x1.00400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdfffff), -0x1.0040000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000200002), 0x1.0040000800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdffffd), -0x1.004000080000cp+50, 0x0p+0 },
+{ INT64_C(0x0004010000200020), 0x1.004000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdfffdf), -0x1.0040000800084p+50, 0x0p+0 },
+{ INT64_C(0x0004010000200100), 0x1.00400008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdffeff), -0x1.0040000800404p+50, 0x0p+0 },
+{ INT64_C(0x0004010000200800), 0x1.0040000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdff7ff), -0x1.0040000802004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000204000), 0x1.004000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdfbfff), -0x1.0040000810004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000208000), 0x1.004000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffdf7fff), -0x1.0040000820004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000280000), 0x1.0040000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffd7ffff), -0x1.0040000a00004p+50, 0x0p+0 },
+{ INT64_C(0x0004010000300000), 0x1.0040000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffffcfffff), -0x1.0040000c00004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002000000), 0x1.0040008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdffffff), -0x1.0040008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002000004), 0x1.004000800001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdfffffb), -0x1.0040008000014p+50, 0x0p+0 },
+{ INT64_C(0x0004010002000040), 0x1.00400080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdffffbf), -0x1.0040008000104p+50, 0x0p+0 },
+{ INT64_C(0x0004010002000200), 0x1.00400080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdfffdff), -0x1.0040008000804p+50, 0x0p+0 },
+{ INT64_C(0x0004010002000800), 0x1.0040008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdfff7ff), -0x1.0040008002004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002001000), 0x1.0040008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdffefff), -0x1.0040008004004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002004000), 0x1.004000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdffbfff), -0x1.0040008010004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002008000), 0x1.004000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdff7fff), -0x1.0040008020004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002010000), 0x1.004000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdfeffff), -0x1.0040008040004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002020000), 0x1.004000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdfdffff), -0x1.0040008080004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002100000), 0x1.00400084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffdefffff), -0x1.0040008400004p+50, 0x0p+0 },
+{ INT64_C(0x0004010002800000), 0x1.004000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfefffd7fffff), -0x1.004000a000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000000), 0x1.004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdfffffff), -0x1.0040080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000004), 0x1.004008000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdffffffb), -0x1.0040080000014p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000010), 0x1.004008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdfffffef), -0x1.0040080000044p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000020), 0x1.004008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdfffffdf), -0x1.0040080000084p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000040), 0x1.00400800001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdfffffbf), -0x1.0040080000104p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000100), 0x1.00400800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdffffeff), -0x1.0040080000404p+50, 0x0p+0 },
+{ INT64_C(0x0004010020000800), 0x1.0040080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdffff7ff), -0x1.0040080002004p+50, 0x0p+0 },
+{ INT64_C(0x0004010020001000), 0x1.0040080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdfffefff), -0x1.0040080004004p+50, 0x0p+0 },
+{ INT64_C(0x0004010020010000), 0x1.004008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdffeffff), -0x1.0040080040004p+50, 0x0p+0 },
+{ INT64_C(0x0004010020100000), 0x1.00400804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdfefffff), -0x1.0040080400004p+50, 0x0p+0 },
+{ INT64_C(0x0004010021000000), 0x1.0040084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffdeffffff), -0x1.0040084000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010022000000), 0x1.0040088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffddffffff), -0x1.0040088000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010040000000), 0x1.00401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbfffffff), -0x1.0040100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010040000004), 0x1.004010000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbffffffb), -0x1.0040100000014p+50, 0x0p+0 },
+{ INT64_C(0x0004010040000020), 0x1.004010000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbfffffdf), -0x1.0040100000084p+50, 0x0p+0 },
+{ INT64_C(0x0004010040000100), 0x1.00401000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbffffeff), -0x1.0040100000404p+50, 0x0p+0 },
+{ INT64_C(0x0004010040000200), 0x1.00401000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbffffdff), -0x1.0040100000804p+50, 0x0p+0 },
+{ INT64_C(0x0004010040001000), 0x1.0040100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbfffefff), -0x1.0040100004004p+50, 0x0p+0 },
+{ INT64_C(0x0004010040002000), 0x1.0040100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbfffdfff), -0x1.0040100008004p+50, 0x0p+0 },
+{ INT64_C(0x0004010040010000), 0x1.004010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbffeffff), -0x1.0040100040004p+50, 0x0p+0 },
+{ INT64_C(0x0004010040100000), 0x1.00401004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbfefffff), -0x1.0040100400004p+50, 0x0p+0 },
+{ INT64_C(0x0004010040200000), 0x1.00401008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbfdfffff), -0x1.0040100800004p+50, 0x0p+0 },
+{ INT64_C(0x0004010041000000), 0x1.0040104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffbeffffff), -0x1.0040104000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010048000000), 0x1.004012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffb7ffffff), -0x1.0040120000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010050000000), 0x1.004014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeffafffffff), -0x1.0040140000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100000000), 0x1.00404p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefeffffffff), -0x1.0040400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100000002), 0x1.0040400000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefffffffd), -0x1.004040000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004010100000008), 0x1.004040000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefffffff7), -0x1.0040400000024p+50, 0x0p+0 },
+{ INT64_C(0x0004010100000080), 0x1.00404000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefeffffff7f), -0x1.0040400000204p+50, 0x0p+0 },
+{ INT64_C(0x0004010100000200), 0x1.00404000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefffffdff), -0x1.0040400000804p+50, 0x0p+0 },
+{ INT64_C(0x0004010100000800), 0x1.0040400002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefffff7ff), -0x1.0040400002004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100001000), 0x1.0040400004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefeffffefff), -0x1.0040400004004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100010000), 0x1.004040004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefffeffff), -0x1.0040400040004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100020000), 0x1.004040008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefffdffff), -0x1.0040400080004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100100000), 0x1.00404004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefeffefffff), -0x1.0040400400004p+50, 0x0p+0 },
+{ INT64_C(0x0004010100400000), 0x1.0040401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefeffbfffff), -0x1.0040401000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010104000000), 0x1.004041p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefefbffffff), -0x1.0040410000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010110000000), 0x1.004044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefeefffffff), -0x1.0040440000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010140000000), 0x1.00405p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefebfffffff), -0x1.0040500000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010400000000), 0x1.0041p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbffffffff), -0x1.0041000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010400000001), 0x1.0041000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbfffffffe), -0x1.0041000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004010400000004), 0x1.004100000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbfffffffb), -0x1.0041000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004010400000020), 0x1.004100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbffffffdf), -0x1.0041000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004010400000040), 0x1.00410000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbffffffbf), -0x1.0041000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004010400000400), 0x1.0041000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbfffffbff), -0x1.0041000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004010400002000), 0x1.0041000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbffffdfff), -0x1.0041000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004010400020000), 0x1.004100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbfffdffff), -0x1.0041000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004010400100000), 0x1.00410004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbffefffff), -0x1.0041000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004010400800000), 0x1.0041002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbff7fffff), -0x1.0041002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010402000000), 0x1.0041008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbfdffffff), -0x1.0041008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010404000000), 0x1.004101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbfbffffff), -0x1.0041010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010410000000), 0x1.004104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefbefffffff), -0x1.0041040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004010500000000), 0x1.00414p+50, 0x0p+0 },
+{ INT64_C(0xfffbfefaffffffff), -0x1.0041400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014000000000), 0x1.005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebfffffffff), -0x1.0050000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014000000004), 0x1.005000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffffffffb), -0x1.0050000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004014000000020), 0x1.005000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebfffffffdf), -0x1.0050000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004014000000200), 0x1.00500000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffffffdff), -0x1.0050000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004014000000400), 0x1.0050000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffffffbff), -0x1.0050000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004014000000800), 0x1.0050000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffffff7ff), -0x1.0050000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004014000008000), 0x1.005000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebfffff7fff), -0x1.0050000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004014000080000), 0x1.00500002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffff7ffff), -0x1.0050000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004014000800000), 0x1.0050002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebfff7fffff), -0x1.0050002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014001000000), 0x1.0050004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffeffffff), -0x1.0050004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014002000000), 0x1.0050008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebffdffffff), -0x1.0050008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014008000000), 0x1.005002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebff7ffffff), -0x1.0050020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014020000000), 0x1.005008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebfdfffffff), -0x1.0050080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004014200000000), 0x1.00508p+50, 0x0p+0 },
+{ INT64_C(0xfffbfebdffffffff), -0x1.0050800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004015000000000), 0x1.0054p+50, 0x0p+0 },
+{ INT64_C(0xfffbfeafffffffff), -0x1.0054000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004016000000000), 0x1.0058p+50, 0x0p+0 },
+{ INT64_C(0xfffbfe9fffffffff), -0x1.0058000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000002), 0x1.0080000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffffd), -0x1.008000000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004020000000003), 0x1.008000000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffffc), -0x1.008000000001p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000008), 0x1.008000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffff7), -0x1.0080000000024p+50, 0x0p+0 },
+{ INT64_C(0x000402000000000a), 0x1.0080000000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffff5), -0x1.008000000002cp+50, 0x0p+0 },
+{ INT64_C(0x0004020000000040), 0x1.00800000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffffbf), -0x1.0080000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000048), 0x1.008000000012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffffb7), -0x1.0080000000124p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000100), 0x1.00800000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffeff), -0x1.0080000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000101), 0x1.0080000000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffefe), -0x1.0080000000408p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000104), 0x1.008000000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffefb), -0x1.0080000000414p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000108), 0x1.008000000042p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffef7), -0x1.0080000000424p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000110), 0x1.008000000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffeef), -0x1.0080000000444p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000140), 0x1.00800000005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffebf), -0x1.0080000000504p+50, 0x0p+0 },
+{ INT64_C(0x0004020000000180), 0x1.00800000006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffffe7f), -0x1.0080000000604p+50, 0x0p+0 },
+{ INT64_C(0x0004020000001000), 0x1.0080000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffefff), -0x1.0080000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000001002), 0x1.0080000004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffeffd), -0x1.008000000400cp+50, 0x0p+0 },
+{ INT64_C(0x0004020000001020), 0x1.008000000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffefdf), -0x1.0080000004084p+50, 0x0p+0 },
+{ INT64_C(0x0004020000001100), 0x1.00800000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffeeff), -0x1.0080000004404p+50, 0x0p+0 },
+{ INT64_C(0x0004020000002000), 0x1.0080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffdfff), -0x1.0080000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000002002), 0x1.0080000008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffdffd), -0x1.008000000800cp+50, 0x0p+0 },
+{ INT64_C(0x0004020000002008), 0x1.008000000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffdff7), -0x1.0080000008024p+50, 0x0p+0 },
+{ INT64_C(0x0004020000002010), 0x1.008000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffdfef), -0x1.0080000008044p+50, 0x0p+0 },
+{ INT64_C(0x0004020000002100), 0x1.00800000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffdeff), -0x1.0080000008404p+50, 0x0p+0 },
+{ INT64_C(0x0004020000002400), 0x1.0080000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffdbff), -0x1.0080000009004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000004000), 0x1.008000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffbfff), -0x1.0080000010004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000004001), 0x1.0080000010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffbffe), -0x1.0080000010008p+50, 0x0p+0 },
+{ INT64_C(0x0004020000004004), 0x1.008000001001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffbffb), -0x1.0080000010014p+50, 0x0p+0 },
+{ INT64_C(0x0004020000004020), 0x1.008000001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffbfdf), -0x1.0080000010084p+50, 0x0p+0 },
+{ INT64_C(0x0004020000004200), 0x1.00800000108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffffbdff), -0x1.0080000010804p+50, 0x0p+0 },
+{ INT64_C(0x0004020000006000), 0x1.0080000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff9fff), -0x1.0080000018004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000008000), 0x1.008000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff7fff), -0x1.0080000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000008008), 0x1.008000002002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff7ff7), -0x1.0080000020024p+50, 0x0p+0 },
+{ INT64_C(0x0004020000008020), 0x1.008000002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff7fdf), -0x1.0080000020084p+50, 0x0p+0 },
+{ INT64_C(0x0004020000008100), 0x1.00800000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff7eff), -0x1.0080000020404p+50, 0x0p+0 },
+{ INT64_C(0x0004020000008400), 0x1.0080000021p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff7bff), -0x1.0080000021004p+50, 0x0p+0 },
+{ INT64_C(0x000402000000c000), 0x1.008000003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffff3fff), -0x1.0080000030004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000010000), 0x1.008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffeffff), -0x1.0080000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000010001), 0x1.0080000040004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffefffe), -0x1.0080000040008p+50, 0x0p+0 },
+{ INT64_C(0x0004020000010004), 0x1.008000004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffefffb), -0x1.0080000040014p+50, 0x0p+0 },
+{ INT64_C(0x0004020000010020), 0x1.008000004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffeffdf), -0x1.0080000040084p+50, 0x0p+0 },
+{ INT64_C(0x0004020000010200), 0x1.00800000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffefdff), -0x1.0080000040804p+50, 0x0p+0 },
+{ INT64_C(0x0004020000012000), 0x1.0080000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffedfff), -0x1.0080000048004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000020000), 0x1.008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffdffff), -0x1.0080000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000020002), 0x1.0080000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffdfffd), -0x1.008000008000cp+50, 0x0p+0 },
+{ INT64_C(0x0004020000020020), 0x1.008000008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffdffdf), -0x1.0080000080084p+50, 0x0p+0 },
+{ INT64_C(0x0004020000020040), 0x1.00800000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffdffbf), -0x1.0080000080104p+50, 0x0p+0 },
+{ INT64_C(0x0004020000020080), 0x1.00800000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffdff7f), -0x1.0080000080204p+50, 0x0p+0 },
+{ INT64_C(0x0004020000020400), 0x1.0080000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffdfbff), -0x1.0080000081004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000022000), 0x1.0080000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffddfff), -0x1.0080000088004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000030000), 0x1.00800000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffffcffff), -0x1.00800000c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000200000), 0x1.00800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdfffff), -0x1.0080000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000200001), 0x1.0080000800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdffffe), -0x1.0080000800008p+50, 0x0p+0 },
+{ INT64_C(0x0004020000200010), 0x1.008000080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdfffef), -0x1.0080000800044p+50, 0x0p+0 },
+{ INT64_C(0x0004020000200100), 0x1.00800008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdffeff), -0x1.0080000800404p+50, 0x0p+0 },
+{ INT64_C(0x0004020000201000), 0x1.0080000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdfefff), -0x1.0080000804004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000208000), 0x1.008000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdf7fff), -0x1.0080000820004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000240000), 0x1.00800009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffdbffff), -0x1.0080000900004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000280000), 0x1.0080000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffd7ffff), -0x1.0080000a00004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000400000), 0x1.0080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbfffff), -0x1.0080001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000400001), 0x1.0080001000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbffffe), -0x1.0080001000008p+50, 0x0p+0 },
+{ INT64_C(0x0004020000400008), 0x1.008000100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbffff7), -0x1.0080001000024p+50, 0x0p+0 },
+{ INT64_C(0x0004020000400010), 0x1.008000100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbfffef), -0x1.0080001000044p+50, 0x0p+0 },
+{ INT64_C(0x0004020000400040), 0x1.00800010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbfffbf), -0x1.0080001000104p+50, 0x0p+0 },
+{ INT64_C(0x0004020000400400), 0x1.0080001001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbffbff), -0x1.0080001001004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000402000), 0x1.0080001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbfdfff), -0x1.0080001008004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000404000), 0x1.008000101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbfbfff), -0x1.0080001010004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000440000), 0x1.00800011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffbbffff), -0x1.0080001100004p+50, 0x0p+0 },
+{ INT64_C(0x0004020000480000), 0x1.00800012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffffb7ffff), -0x1.0080001200004p+50, 0x0p+0 },
+{ INT64_C(0x0004020004000000), 0x1.008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbffffff), -0x1.0080010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020004000002), 0x1.0080010000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbfffffd), -0x1.008001000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004020004000004), 0x1.008001000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbfffffb), -0x1.0080010000014p+50, 0x0p+0 },
+{ INT64_C(0x0004020004000040), 0x1.00800100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbffffbf), -0x1.0080010000104p+50, 0x0p+0 },
+{ INT64_C(0x0004020004000100), 0x1.00800100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbfffeff), -0x1.0080010000404p+50, 0x0p+0 },
+{ INT64_C(0x0004020004001000), 0x1.0080010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbffefff), -0x1.0080010004004p+50, 0x0p+0 },
+{ INT64_C(0x0004020004002000), 0x1.0080010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbffdfff), -0x1.0080010008004p+50, 0x0p+0 },
+{ INT64_C(0x0004020004020000), 0x1.008001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbfdffff), -0x1.0080010080004p+50, 0x0p+0 },
+{ INT64_C(0x0004020004100000), 0x1.00800104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffbefffff), -0x1.0080010400004p+50, 0x0p+0 },
+{ INT64_C(0x0004020004800000), 0x1.0080012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffb7fffff), -0x1.0080012000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020005000000), 0x1.0080014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfffaffffff), -0x1.0080014000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040000000), 0x1.00801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbfffffff), -0x1.0080100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040000002), 0x1.0080100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbffffffd), -0x1.008010000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004020040000004), 0x1.008010000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbffffffb), -0x1.0080100000014p+50, 0x0p+0 },
+{ INT64_C(0x0004020040000008), 0x1.008010000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbffffff7), -0x1.0080100000024p+50, 0x0p+0 },
+{ INT64_C(0x0004020040000080), 0x1.00801000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbfffff7f), -0x1.0080100000204p+50, 0x0p+0 },
+{ INT64_C(0x0004020040000800), 0x1.0080100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbffff7ff), -0x1.0080100002004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040002000), 0x1.0080100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbfffdfff), -0x1.0080100008004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040020000), 0x1.008010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbffdffff), -0x1.0080100080004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040080000), 0x1.00801002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbff7ffff), -0x1.0080100200004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040400000), 0x1.0080101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbfbfffff), -0x1.0080101000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020040800000), 0x1.0080102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbf7fffff), -0x1.0080102000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020042000000), 0x1.0080108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdffbdffffff), -0x1.0080108000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020060000000), 0x1.008018p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdff9fffffff), -0x1.0080180000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020400000000), 0x1.0081p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbffffffff), -0x1.0081000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020400000004), 0x1.008100000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbfffffffb), -0x1.0081000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004020400000020), 0x1.008100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbffffffdf), -0x1.0081000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004020400000200), 0x1.00810000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbfffffdff), -0x1.0081000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004020400001000), 0x1.0081000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbffffefff), -0x1.0081000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004020400010000), 0x1.008100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbfffeffff), -0x1.0081000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004020400080000), 0x1.00810002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbfff7ffff), -0x1.0081000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004020400800000), 0x1.0081002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbff7fffff), -0x1.0081002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020401000000), 0x1.0081004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbfeffffff), -0x1.0081004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020410000000), 0x1.008104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfbefffffff), -0x1.0081040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020500000000), 0x1.00814p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdfaffffffff), -0x1.0081400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020800000000), 0x1.0082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7ffffffff), -0x1.0082000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020800000001), 0x1.0082000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7fffffffe), -0x1.0082000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004020800000008), 0x1.008200000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7fffffff7), -0x1.0082000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004020800000080), 0x1.00820000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7ffffff7f), -0x1.0082000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004020800000800), 0x1.0082000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7fffff7ff), -0x1.0082000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004020800001000), 0x1.0082000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7ffffefff), -0x1.0082000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004020800008000), 0x1.008200002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7ffff7fff), -0x1.0082000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004020800080000), 0x1.00820002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7fff7ffff), -0x1.0082000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004020800200000), 0x1.00820008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7ffdfffff), -0x1.0082000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004020802000000), 0x1.0082008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7fdffffff), -0x1.0082008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020804000000), 0x1.008201p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7fbffffff), -0x1.0082010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020840000000), 0x1.00821p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf7bfffffff), -0x1.0082100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020880000000), 0x1.00822p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf77fffffff), -0x1.0082200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004020c00000000), 0x1.0083p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdf3ffffffff), -0x1.0083000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024000000000), 0x1.009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfffffffff), -0x1.0090000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024000000001), 0x1.0090000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbffffffffe), -0x1.0090000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004024000000002), 0x1.0090000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbffffffffd), -0x1.009000000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004024000000020), 0x1.009000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfffffffdf), -0x1.0090000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004024000000200), 0x1.00900000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbffffffdff), -0x1.0090000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004024000002000), 0x1.0090000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfffffdfff), -0x1.0090000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004024000008000), 0x1.009000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfffff7fff), -0x1.0090000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004024000080000), 0x1.00900002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbffff7ffff), -0x1.0090000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004024000100000), 0x1.00900004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfffefffff), -0x1.0090000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004024000800000), 0x1.0090002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfff7fffff), -0x1.0090002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024001000000), 0x1.0090004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbffeffffff), -0x1.0090004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024008000000), 0x1.009002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbff7ffffff), -0x1.0090020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024040000000), 0x1.00901p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbfbfffffff), -0x1.0090100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024200000000), 0x1.00908p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdbdffffffff), -0x1.0090800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004024800000000), 0x1.0092p+50, 0x0p+0 },
+{ INT64_C(0xfffbfdb7ffffffff), -0x1.0092000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000000), 0x1.00ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fffffffff), -0x1.00a0000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000002), 0x1.00a0000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffffffd), -0x1.00a000000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004028000000004), 0x1.00a000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffffffb), -0x1.00a0000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000010), 0x1.00a000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fffffffef), -0x1.00a0000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000020), 0x1.00a000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fffffffdf), -0x1.00a0000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000100), 0x1.00a00000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffffeff), -0x1.00a0000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000200), 0x1.00a00000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffffdff), -0x1.00a0000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000400), 0x1.00a0000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffffbff), -0x1.00a0000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000000800), 0x1.00a0000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffff7ff), -0x1.00a0000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000002000), 0x1.00a0000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fffffdfff), -0x1.00a0000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000010000), 0x1.00a000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffeffff), -0x1.00a0000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000040000), 0x1.00a00001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffffbffff), -0x1.00a0000100004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000080000), 0x1.00a00002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffff7ffff), -0x1.00a0000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000100000), 0x1.00a00004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fffefffff), -0x1.00a0000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004028000800000), 0x1.00a0002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fff7fffff), -0x1.00a0002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028002000000), 0x1.00a0008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffdffffff), -0x1.00a0008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028004000000), 0x1.00a001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ffbffffff), -0x1.00a0010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028008000000), 0x1.00a002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7ff7ffffff), -0x1.00a0020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028020000000), 0x1.00a008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fdfffffff), -0x1.00a0080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028040000000), 0x1.00a01p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7fbfffffff), -0x1.00a0100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028200000000), 0x1.00a08p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7dffffffff), -0x1.00a0800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028400000000), 0x1.00a1p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd7bffffffff), -0x1.00a1000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004028800000000), 0x1.00a2p+50, 0x0p+0 },
+{ INT64_C(0xfffbfd77ffffffff), -0x1.00a2000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000008), 0x1.010000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffff7), -0x1.0100000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000010), 0x1.010000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffffef), -0x1.0100000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000012), 0x1.0100000000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffffed), -0x1.010000000004cp+50, 0x0p+0 },
+{ INT64_C(0x0004040000000014), 0x1.010000000005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffffeb), -0x1.0100000000054p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000100), 0x1.01000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffeff), -0x1.0100000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000104), 0x1.010000000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffefb), -0x1.0100000000414p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000120), 0x1.010000000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffedf), -0x1.0100000000484p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000180), 0x1.01000000006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffe7f), -0x1.0100000000604p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000400), 0x1.0100000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffbff), -0x1.0100000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000402), 0x1.0100000001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffbfd), -0x1.010000000100cp+50, 0x0p+0 },
+{ INT64_C(0x0004040000000404), 0x1.010000000101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffbfb), -0x1.0100000001014p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000410), 0x1.010000000104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffbef), -0x1.0100000001044p+50, 0x0p+0 },
+{ INT64_C(0x0004040000000480), 0x1.01000000012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffffb7f), -0x1.0100000001204p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002000), 0x1.0100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdfff), -0x1.0100000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002001), 0x1.0100000008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdffe), -0x1.0100000008008p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002002), 0x1.0100000008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdffd), -0x1.010000000800cp+50, 0x0p+0 },
+{ INT64_C(0x0004040000002004), 0x1.010000000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdffb), -0x1.0100000008014p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002020), 0x1.010000000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdfdf), -0x1.0100000008084p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002080), 0x1.01000000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdf7f), -0x1.0100000008204p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002100), 0x1.01000000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffdeff), -0x1.0100000008404p+50, 0x0p+0 },
+{ INT64_C(0x0004040000002800), 0x1.010000000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffd7ff), -0x1.010000000a004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000003000), 0x1.010000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffffcfff), -0x1.010000000c004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000010000), 0x1.010000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffeffff), -0x1.0100000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000010004), 0x1.010000004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffefffb), -0x1.0100000040014p+50, 0x0p+0 },
+{ INT64_C(0x0004040000010008), 0x1.010000004002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffefff7), -0x1.0100000040024p+50, 0x0p+0 },
+{ INT64_C(0x0004040000010020), 0x1.010000004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffeffdf), -0x1.0100000040084p+50, 0x0p+0 },
+{ INT64_C(0x0004040000010200), 0x1.01000000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffefdff), -0x1.0100000040804p+50, 0x0p+0 },
+{ INT64_C(0x0004040000012000), 0x1.0100000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffedfff), -0x1.0100000048004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000018000), 0x1.010000006p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffe7fff), -0x1.0100000060004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000020000), 0x1.010000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffdffff), -0x1.0100000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000020008), 0x1.010000008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffdfff7), -0x1.0100000080024p+50, 0x0p+0 },
+{ INT64_C(0x0004040000020040), 0x1.01000000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffdffbf), -0x1.0100000080104p+50, 0x0p+0 },
+{ INT64_C(0x0004040000020100), 0x1.01000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffdfeff), -0x1.0100000080404p+50, 0x0p+0 },
+{ INT64_C(0x0004040000021000), 0x1.0100000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffdefff), -0x1.0100000084004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000024000), 0x1.010000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffdbfff), -0x1.0100000090004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000028000), 0x1.01000000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffd7fff), -0x1.01000000a0004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000030000), 0x1.01000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffcffff), -0x1.01000000c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000040000), 0x1.01000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffbffff), -0x1.0100000100004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000040004), 0x1.010000010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffbfffb), -0x1.0100000100014p+50, 0x0p+0 },
+{ INT64_C(0x0004040000040010), 0x1.010000010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffbffef), -0x1.0100000100044p+50, 0x0p+0 },
+{ INT64_C(0x0004040000040080), 0x1.01000001002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffbff7f), -0x1.0100000100204p+50, 0x0p+0 },
+{ INT64_C(0x0004040000040100), 0x1.01000001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffbfeff), -0x1.0100000100404p+50, 0x0p+0 },
+{ INT64_C(0x0004040000041000), 0x1.0100000104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffbefff), -0x1.0100000104004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000050000), 0x1.010000014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfffffaffff), -0x1.0100000140004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000400000), 0x1.0100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbfffff), -0x1.0100001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000400001), 0x1.0100001000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbffffe), -0x1.0100001000008p+50, 0x0p+0 },
+{ INT64_C(0x0004040000400008), 0x1.010000100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbffff7), -0x1.0100001000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040000400010), 0x1.010000100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbfffef), -0x1.0100001000044p+50, 0x0p+0 },
+{ INT64_C(0x0004040000400100), 0x1.01000010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbffeff), -0x1.0100001000404p+50, 0x0p+0 },
+{ INT64_C(0x0004040000400800), 0x1.0100001002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbff7ff), -0x1.0100001002004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000408000), 0x1.010000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbf7fff), -0x1.0100001020004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000420000), 0x1.010000108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbdffff), -0x1.0100001080004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000440000), 0x1.01000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffbbffff), -0x1.0100001100004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000500000), 0x1.01000014p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffffafffff), -0x1.0100001400004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000800000), 0x1.0100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7fffff), -0x1.0100002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000800008), 0x1.010000200002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7ffff7), -0x1.0100002000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040000800010), 0x1.010000200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7fffef), -0x1.0100002000044p+50, 0x0p+0 },
+{ INT64_C(0x0004040000800080), 0x1.01000020002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7fff7f), -0x1.0100002000204p+50, 0x0p+0 },
+{ INT64_C(0x0004040000800400), 0x1.0100002001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7ffbff), -0x1.0100002001004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000801000), 0x1.0100002004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7fefff), -0x1.0100002004004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000810000), 0x1.010000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff7effff), -0x1.0100002040004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000880000), 0x1.01000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff77ffff), -0x1.0100002200004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000a00000), 0x1.01000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff5fffff), -0x1.0100002800004p+50, 0x0p+0 },
+{ INT64_C(0x0004040000c00000), 0x1.0100003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffff3fffff), -0x1.0100003000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008000000), 0x1.010002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7ffffff), -0x1.0100020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008000002), 0x1.0100020000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7fffffd), -0x1.010002000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004040008000008), 0x1.010002000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7fffff7), -0x1.0100020000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040008000010), 0x1.010002000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7ffffef), -0x1.0100020000044p+50, 0x0p+0 },
+{ INT64_C(0x0004040008000100), 0x1.01000200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7fffeff), -0x1.0100020000404p+50, 0x0p+0 },
+{ INT64_C(0x0004040008001000), 0x1.0100020004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7ffefff), -0x1.0100020004004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008002000), 0x1.0100020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7ffdfff), -0x1.0100020008004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008004000), 0x1.010002001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7ffbfff), -0x1.0100020010004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008020000), 0x1.010002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7fdffff), -0x1.0100020080004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008200000), 0x1.01000208p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7dfffff), -0x1.0100020800004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008400000), 0x1.0100021p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff7bfffff), -0x1.0100021000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040008800000), 0x1.0100022p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff77fffff), -0x1.0100022000004p+50, 0x0p+0 },
+{ INT64_C(0x000404000a000000), 0x1.0100028p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfff5ffffff), -0x1.0100028000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040010000000), 0x1.010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffefffffff), -0x1.0100040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040010000008), 0x1.010004000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffeffffff7), -0x1.0100040000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040010000040), 0x1.01000400001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffefffffbf), -0x1.0100040000104p+50, 0x0p+0 },
+{ INT64_C(0x0004040010000200), 0x1.01000400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffeffffdff), -0x1.0100040000804p+50, 0x0p+0 },
+{ INT64_C(0x0004040010000400), 0x1.0100040001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffeffffbff), -0x1.0100040001004p+50, 0x0p+0 },
+{ INT64_C(0x0004040010001000), 0x1.0100040004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffefffefff), -0x1.0100040004004p+50, 0x0p+0 },
+{ INT64_C(0x0004040010008000), 0x1.010004002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffefff7fff), -0x1.0100040020004p+50, 0x0p+0 },
+{ INT64_C(0x0004040010040000), 0x1.01000401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffeffbffff), -0x1.0100040100004p+50, 0x0p+0 },
+{ INT64_C(0x0004040010200000), 0x1.01000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffefdfffff), -0x1.0100040800004p+50, 0x0p+0 },
+{ INT64_C(0x0004040012000000), 0x1.0100048p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbffedffffff), -0x1.0100048000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040080000000), 0x1.01002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7fffffff), -0x1.0100200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040080000004), 0x1.010020000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7ffffffb), -0x1.0100200000014p+50, 0x0p+0 },
+{ INT64_C(0x0004040080000008), 0x1.010020000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7ffffff7), -0x1.0100200000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040080000020), 0x1.010020000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7fffffdf), -0x1.0100200000084p+50, 0x0p+0 },
+{ INT64_C(0x0004040080000080), 0x1.01002000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7fffff7f), -0x1.0100200000204p+50, 0x0p+0 },
+{ INT64_C(0x0004040080000400), 0x1.0100200001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7ffffbff), -0x1.0100200001004p+50, 0x0p+0 },
+{ INT64_C(0x0004040080002000), 0x1.0100200008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7fffdfff), -0x1.0100200008004p+50, 0x0p+0 },
+{ INT64_C(0x0004040080020000), 0x1.010020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7ffdffff), -0x1.0100200080004p+50, 0x0p+0 },
+{ INT64_C(0x0004040080100000), 0x1.01002004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7fefffff), -0x1.0100200400004p+50, 0x0p+0 },
+{ INT64_C(0x0004040081000000), 0x1.0100204p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff7effffff), -0x1.0100204000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040088000000), 0x1.010022p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff77ffffff), -0x1.0100220000004p+50, 0x0p+0 },
+{ INT64_C(0x00040400c0000000), 0x1.01003p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbff3fffffff), -0x1.0100300000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100000000), 0x1.01004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeffffffff), -0x1.0100400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100000001), 0x1.0100400000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfefffffffe), -0x1.0100400000008p+50, 0x0p+0 },
+{ INT64_C(0x0004040100000008), 0x1.010040000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfefffffff7), -0x1.0100400000024p+50, 0x0p+0 },
+{ INT64_C(0x0004040100000040), 0x1.01004000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeffffffbf), -0x1.0100400000104p+50, 0x0p+0 },
+{ INT64_C(0x0004040100000200), 0x1.01004000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfefffffdff), -0x1.0100400000804p+50, 0x0p+0 },
+{ INT64_C(0x0004040100002000), 0x1.0100400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeffffdfff), -0x1.0100400008004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100004000), 0x1.010040001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeffffbfff), -0x1.0100400010004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100020000), 0x1.010040008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfefffdffff), -0x1.0100400080004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100100000), 0x1.01004004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeffefffff), -0x1.0100400400004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100400000), 0x1.0100401p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeffbfffff), -0x1.0100401000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040100800000), 0x1.0100402p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeff7fffff), -0x1.0100402000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040108000000), 0x1.010042p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfef7ffffff), -0x1.0100420000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040110000000), 0x1.010044p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfeefffffff), -0x1.0100440000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040140000000), 0x1.01005p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfebfffffff), -0x1.0100500000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200000000), 0x1.01008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffffffff), -0x1.0100800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200000001), 0x1.0100800000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdfffffffe), -0x1.0100800000008p+50, 0x0p+0 },
+{ INT64_C(0x0004040200000010), 0x1.010080000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffffffef), -0x1.0100800000044p+50, 0x0p+0 },
+{ INT64_C(0x0004040200000020), 0x1.010080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffffffdf), -0x1.0100800000084p+50, 0x0p+0 },
+{ INT64_C(0x0004040200000040), 0x1.01008000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffffffbf), -0x1.0100800000104p+50, 0x0p+0 },
+{ INT64_C(0x0004040200000200), 0x1.01008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdfffffdff), -0x1.0100800000804p+50, 0x0p+0 },
+{ INT64_C(0x0004040200002000), 0x1.0100800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffffdfff), -0x1.0100800008004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200004000), 0x1.010080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffffbfff), -0x1.0100800010004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200020000), 0x1.010080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdfffdffff), -0x1.0100800080004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200040000), 0x1.01008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdfffbffff), -0x1.0100800100004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200100000), 0x1.01008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdffefffff), -0x1.0100800400004p+50, 0x0p+0 },
+{ INT64_C(0x0004040200800000), 0x1.0100802p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdff7fffff), -0x1.0100802000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040208000000), 0x1.010082p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdf7ffffff), -0x1.0100820000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040240000000), 0x1.01009p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfdbfffffff), -0x1.0100900000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040280000000), 0x1.0100ap+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfd7fffffff), -0x1.0100a00000004p+50, 0x0p+0 },
+{ INT64_C(0x0004040300000000), 0x1.0100cp+50, 0x0p+0 },
+{ INT64_C(0xfffbfbfcffffffff), -0x1.0100c00000004p+50, 0x0p+0 },
+{ INT64_C(0x0004042000000000), 0x1.0108p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdfffffffff), -0x1.0108000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004042000000001), 0x1.0108000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffffffffe), -0x1.0108000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004042000000010), 0x1.010800000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdfffffffef), -0x1.0108000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004042000000100), 0x1.01080000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffffffeff), -0x1.0108000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004042000000200), 0x1.01080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffffffdff), -0x1.0108000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004042000000800), 0x1.0108000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffffff7ff), -0x1.0108000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004042000004000), 0x1.010800001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdfffffbfff), -0x1.0108000010004p+50, 0x0p+0 },
+{ INT64_C(0x0004042000040000), 0x1.01080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffffbffff), -0x1.0108000100004p+50, 0x0p+0 },
+{ INT64_C(0x0004042000100000), 0x1.01080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdfffefffff), -0x1.0108000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004042001000000), 0x1.0108004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffeffffff), -0x1.0108004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004042002000000), 0x1.0108008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdffdffffff), -0x1.0108008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004042020000000), 0x1.010808p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdfdfffffff), -0x1.0108080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004042100000000), 0x1.01084p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbdeffffffff), -0x1.0108400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004042200000000), 0x1.01088p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbddffffffff), -0x1.0108800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000000000), 0x1.011p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfffffffff), -0x1.0110000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000000001), 0x1.0110000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbffffffffe), -0x1.0110000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004044000000008), 0x1.011000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbffffffff7), -0x1.0110000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004044000000080), 0x1.01100000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfffffff7f), -0x1.0110000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004044000000800), 0x1.0110000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbffffff7ff), -0x1.0110000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000001000), 0x1.0110000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfffffefff), -0x1.0110000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000008000), 0x1.011000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfffff7fff), -0x1.0110000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000020000), 0x1.011000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbffffdffff), -0x1.0110000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000100000), 0x1.01100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfffefffff), -0x1.0110000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004044000400000), 0x1.0110001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfffbfffff), -0x1.0110001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044002000000), 0x1.0110008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbffdffffff), -0x1.0110008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044008000000), 0x1.011002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbff7ffffff), -0x1.0110020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044010000000), 0x1.011004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfefffffff), -0x1.0110040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044040000000), 0x1.01101p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbfbfffffff), -0x1.0110100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044100000000), 0x1.01104p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbbeffffffff), -0x1.0110400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004044800000000), 0x1.0112p+50, 0x0p+0 },
+{ INT64_C(0xfffbfbb7ffffffff), -0x1.0112000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000000), 0x1.012p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fffffffff), -0x1.0120000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000004), 0x1.012000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffffffffb), -0x1.0120000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000008), 0x1.012000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffffffff7), -0x1.0120000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000020), 0x1.012000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fffffffdf), -0x1.0120000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000040), 0x1.01200000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fffffffbf), -0x1.0120000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000080), 0x1.01200000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fffffff7f), -0x1.0120000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000100), 0x1.01200000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffffffeff), -0x1.0120000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000200), 0x1.01200000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffffffdff), -0x1.0120000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004048000000800), 0x1.0120000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffffff7ff), -0x1.0120000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004048000001000), 0x1.0120000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fffffefff), -0x1.0120000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004048000010000), 0x1.012000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffffeffff), -0x1.0120000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004048000100000), 0x1.01200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fffefffff), -0x1.0120000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004048001000000), 0x1.0120004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffeffffff), -0x1.0120004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048002000000), 0x1.0120008p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffdffffff), -0x1.0120008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048004000000), 0x1.012001p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7ffbffffff), -0x1.0120010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048010000000), 0x1.012004p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7fefffffff), -0x1.0120040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048100000000), 0x1.01204p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7effffffff), -0x1.0120400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004048400000000), 0x1.0121p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb7bffffffff), -0x1.0121000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004049000000000), 0x1.0124p+50, 0x0p+0 },
+{ INT64_C(0xfffbfb6fffffffff), -0x1.0124000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004060000000000), 0x1.018p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9ffffffffff), -0x1.0180000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004060000000008), 0x1.018000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9fffffffff7), -0x1.0180000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004060000000080), 0x1.01800000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9ffffffff7f), -0x1.0180000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004060000000400), 0x1.0180000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9fffffffbff), -0x1.0180000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004060000004000), 0x1.018000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9ffffffbfff), -0x1.0180000010004p+50, 0x0p+0 },
+{ INT64_C(0x0004060000020000), 0x1.018000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9fffffdffff), -0x1.0180000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004060000200000), 0x1.01800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9ffffdfffff), -0x1.0180000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004060000800000), 0x1.0180002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9ffff7fffff), -0x1.0180002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004060002000000), 0x1.0180008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9fffdffffff), -0x1.0180008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004060020000000), 0x1.018008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9ffdfffffff), -0x1.0180080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004060200000000), 0x1.01808p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9fdffffffff), -0x1.0180800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004062000000000), 0x1.0188p+50, 0x0p+0 },
+{ INT64_C(0xfffbf9dfffffffff), -0x1.0188000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000008), 0x1.020000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffffffff7), -0x1.0200000000024p+50, 0x0p+0 },
+{ INT64_C(0x000408000000000a), 0x1.0200000000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffffffff5), -0x1.020000000002cp+50, 0x0p+0 },
+{ INT64_C(0x0004080000000020), 0x1.020000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffffdf), -0x1.0200000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000021), 0x1.0200000000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffffde), -0x1.0200000000088p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000022), 0x1.0200000000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffffdd), -0x1.020000000008cp+50, 0x0p+0 },
+{ INT64_C(0x0004080000000024), 0x1.020000000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffffdb), -0x1.0200000000094p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000028), 0x1.02000000000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffffd7), -0x1.02000000000a4p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000100), 0x1.02000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffffffeff), -0x1.0200000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000101), 0x1.0200000000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffffffefe), -0x1.0200000000408p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000108), 0x1.020000000042p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffffffef7), -0x1.0200000000424p+50, 0x0p+0 },
+{ INT64_C(0x0004080000000180), 0x1.02000000006p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffffffe7f), -0x1.0200000000604p+50, 0x0p+0 },
+{ INT64_C(0x0004080000001000), 0x1.0200000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffefff), -0x1.0200000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000001001), 0x1.0200000004004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffeffe), -0x1.0200000004008p+50, 0x0p+0 },
+{ INT64_C(0x0004080000001004), 0x1.020000000401p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffeffb), -0x1.0200000004014p+50, 0x0p+0 },
+{ INT64_C(0x0004080000001010), 0x1.020000000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffefef), -0x1.0200000004044p+50, 0x0p+0 },
+{ INT64_C(0x0004080000001020), 0x1.020000000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffefdf), -0x1.0200000004084p+50, 0x0p+0 },
+{ INT64_C(0x0004080000001100), 0x1.02000000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffffeeff), -0x1.0200000004404p+50, 0x0p+0 },
+{ INT64_C(0x0004080000008000), 0x1.020000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffff7fff), -0x1.0200000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000008008), 0x1.020000002002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffff7ff7), -0x1.0200000020024p+50, 0x0p+0 },
+{ INT64_C(0x0004080000008020), 0x1.020000002008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffff7fdf), -0x1.0200000020084p+50, 0x0p+0 },
+{ INT64_C(0x0004080000008100), 0x1.02000000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffff7eff), -0x1.0200000020404p+50, 0x0p+0 },
+{ INT64_C(0x0004080000008800), 0x1.0200000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffff77ff), -0x1.0200000022004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000080000), 0x1.02000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff7ffff), -0x1.0200000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000080002), 0x1.0200000200008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff7fffd), -0x1.020000020000cp+50, 0x0p+0 },
+{ INT64_C(0x0004080000080020), 0x1.020000020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff7ffdf), -0x1.0200000200084p+50, 0x0p+0 },
+{ INT64_C(0x0004080000080080), 0x1.02000002002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff7ff7f), -0x1.0200000200204p+50, 0x0p+0 },
+{ INT64_C(0x0004080000080400), 0x1.0200000201p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff7fbff), -0x1.0200000201004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000081000), 0x1.0200000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff7efff), -0x1.0200000204004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000090000), 0x1.020000024p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff6ffff), -0x1.0200000240004p+50, 0x0p+0 },
+{ INT64_C(0x00040800000c0000), 0x1.02000003p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffff3ffff), -0x1.0200000300004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000400000), 0x1.0200001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbfffff), -0x1.0200001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000400008), 0x1.020000100002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbffff7), -0x1.0200001000024p+50, 0x0p+0 },
+{ INT64_C(0x0004080000400010), 0x1.020000100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbfffef), -0x1.0200001000044p+50, 0x0p+0 },
+{ INT64_C(0x0004080000400040), 0x1.02000010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbfffbf), -0x1.0200001000104p+50, 0x0p+0 },
+{ INT64_C(0x0004080000400100), 0x1.02000010004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbffeff), -0x1.0200001000404p+50, 0x0p+0 },
+{ INT64_C(0x0004080000401000), 0x1.0200001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbfefff), -0x1.0200001004004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000402000), 0x1.0200001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbfdfff), -0x1.0200001008004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000420000), 0x1.020000108p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffffbdffff), -0x1.0200001080004p+50, 0x0p+0 },
+{ INT64_C(0x0004080000600000), 0x1.02000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffff9fffff), -0x1.0200001800004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002000000), 0x1.0200008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdffffff), -0x1.0200008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002000002), 0x1.0200008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdfffffd), -0x1.020000800000cp+50, 0x0p+0 },
+{ INT64_C(0x0004080002000010), 0x1.020000800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdffffef), -0x1.0200008000044p+50, 0x0p+0 },
+{ INT64_C(0x0004080002000080), 0x1.02000080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdffff7f), -0x1.0200008000204p+50, 0x0p+0 },
+{ INT64_C(0x0004080002000200), 0x1.02000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdfffdff), -0x1.0200008000804p+50, 0x0p+0 },
+{ INT64_C(0x0004080002000400), 0x1.0200008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdfffbff), -0x1.0200008001004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002000800), 0x1.0200008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdfff7ff), -0x1.0200008002004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002004000), 0x1.020000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdffbfff), -0x1.0200008010004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002010000), 0x1.020000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdfeffff), -0x1.0200008040004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002100000), 0x1.02000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffdefffff), -0x1.0200008400004p+50, 0x0p+0 },
+{ INT64_C(0x0004080002200000), 0x1.02000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffddfffff), -0x1.0200008800004p+50, 0x0p+0 },
+{ INT64_C(0x0004080003000000), 0x1.020000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fffcffffff), -0x1.020000c000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080020000000), 0x1.020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdfffffff), -0x1.0200080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080020000008), 0x1.020008000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdffffff7), -0x1.0200080000024p+50, 0x0p+0 },
+{ INT64_C(0x0004080020000020), 0x1.020008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdfffffdf), -0x1.0200080000084p+50, 0x0p+0 },
+{ INT64_C(0x0004080020000080), 0x1.02000800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdfffff7f), -0x1.0200080000204p+50, 0x0p+0 },
+{ INT64_C(0x0004080020000800), 0x1.0200080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdffff7ff), -0x1.0200080002004p+50, 0x0p+0 },
+{ INT64_C(0x0004080020002000), 0x1.0200080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdfffdfff), -0x1.0200080008004p+50, 0x0p+0 },
+{ INT64_C(0x0004080020010000), 0x1.020008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdffeffff), -0x1.0200080040004p+50, 0x0p+0 },
+{ INT64_C(0x0004080020100000), 0x1.02000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdfefffff), -0x1.0200080400004p+50, 0x0p+0 },
+{ INT64_C(0x0004080020800000), 0x1.0200082p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdf7fffff), -0x1.0200082000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080024000000), 0x1.020009p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffdbffffff), -0x1.0200090000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080040000000), 0x1.02001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfffffff), -0x1.0200100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080040000002), 0x1.0200100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbffffffd), -0x1.020010000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004080040000020), 0x1.020010000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfffffdf), -0x1.0200100000084p+50, 0x0p+0 },
+{ INT64_C(0x0004080040000040), 0x1.02001000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfffffbf), -0x1.0200100000104p+50, 0x0p+0 },
+{ INT64_C(0x0004080040000080), 0x1.02001000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfffff7f), -0x1.0200100000204p+50, 0x0p+0 },
+{ INT64_C(0x0004080040000400), 0x1.0200100001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbffffbff), -0x1.0200100001004p+50, 0x0p+0 },
+{ INT64_C(0x0004080040004000), 0x1.020010001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfffbfff), -0x1.0200100010004p+50, 0x0p+0 },
+{ INT64_C(0x0004080040020000), 0x1.020010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbffdffff), -0x1.0200100080004p+50, 0x0p+0 },
+{ INT64_C(0x0004080040100000), 0x1.02001004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfefffff), -0x1.0200100400004p+50, 0x0p+0 },
+{ INT64_C(0x0004080040200000), 0x1.02001008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbfdfffff), -0x1.0200100800004p+50, 0x0p+0 },
+{ INT64_C(0x0004080042000000), 0x1.0200108p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffbdffffff), -0x1.0200108000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080048000000), 0x1.020012p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffb7ffffff), -0x1.0200120000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080050000000), 0x1.020014p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ffafffffff), -0x1.0200140000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080060000000), 0x1.020018p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ff9fffffff), -0x1.0200180000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200000000), 0x1.02008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdffffffff), -0x1.0200800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200000002), 0x1.0200800000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdfffffffd), -0x1.020080000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004080200000020), 0x1.020080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdffffffdf), -0x1.0200800000084p+50, 0x0p+0 },
+{ INT64_C(0x0004080200000100), 0x1.02008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdfffffeff), -0x1.0200800000404p+50, 0x0p+0 },
+{ INT64_C(0x0004080200000400), 0x1.0200800001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdfffffbff), -0x1.0200800001004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200000800), 0x1.0200800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdfffff7ff), -0x1.0200800002004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200004000), 0x1.020080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdffffbfff), -0x1.0200800010004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200020000), 0x1.020080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdfffdffff), -0x1.0200800080004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200040000), 0x1.02008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdfffbffff), -0x1.0200800100004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200200000), 0x1.02008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdffdfffff), -0x1.0200800800004p+50, 0x0p+0 },
+{ INT64_C(0x0004080200800000), 0x1.0200802p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdff7fffff), -0x1.0200802000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080208000000), 0x1.020082p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fdf7ffffff), -0x1.0200820000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080220000000), 0x1.020088p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fddfffffff), -0x1.0200880000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080300000000), 0x1.0200cp+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fcffffffff), -0x1.0200c00000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400000000), 0x1.0201p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbffffffff), -0x1.0201000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400000001), 0x1.0201000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbfffffffe), -0x1.0201000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004080400000010), 0x1.020100000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbffffffef), -0x1.0201000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004080400000040), 0x1.02010000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbffffffbf), -0x1.0201000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004080400000400), 0x1.0201000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbfffffbff), -0x1.0201000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400002000), 0x1.0201000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbffffdfff), -0x1.0201000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400010000), 0x1.020100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbfffeffff), -0x1.0201000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400020000), 0x1.020100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbfffdffff), -0x1.0201000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400200000), 0x1.02010008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbffdfffff), -0x1.0201000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004080400800000), 0x1.0201002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbff7fffff), -0x1.0201002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080408000000), 0x1.020102p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbf7ffffff), -0x1.0201020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080420000000), 0x1.020108p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7fbdfffffff), -0x1.0201080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004080600000000), 0x1.02018p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7f9ffffffff), -0x1.0201800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000000000), 0x1.0204p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efffffffff), -0x1.0204000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000000002), 0x1.0204000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7effffffffd), -0x1.020400000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004081000000020), 0x1.020400000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efffffffdf), -0x1.0204000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004081000000040), 0x1.02040000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efffffffbf), -0x1.0204000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004081000000400), 0x1.0204000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7effffffbff), -0x1.0204000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000001000), 0x1.0204000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efffffefff), -0x1.0204000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000010000), 0x1.020400004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7effffeffff), -0x1.0204000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000080000), 0x1.02040002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7effff7ffff), -0x1.0204000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000100000), 0x1.02040004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efffefffff), -0x1.0204000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004081000800000), 0x1.0204002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efff7fffff), -0x1.0204002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081004000000), 0x1.020401p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7effbffffff), -0x1.0204010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081040000000), 0x1.02041p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7efbfffffff), -0x1.0204100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081080000000), 0x1.02042p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ef7fffffff), -0x1.0204200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081200000000), 0x1.02048p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7edffffffff), -0x1.0204800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004081400000000), 0x1.0205p+50, 0x0p+0 },
+{ INT64_C(0xfffbf7ebffffffff), -0x1.0205000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000000000), 0x1.022p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fffffffff), -0x1.0220000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000000008), 0x1.022000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77ffffffff7), -0x1.0220000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004088000000010), 0x1.022000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fffffffef), -0x1.0220000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004088000000040), 0x1.02200000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fffffffbf), -0x1.0220000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004088000000400), 0x1.0220000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77ffffffbff), -0x1.0220000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000001000), 0x1.0220000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fffffefff), -0x1.0220000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000004000), 0x1.022000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fffffbfff), -0x1.0220000010004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000008000), 0x1.022000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fffff7fff), -0x1.0220000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000040000), 0x1.02200001p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77ffffbffff), -0x1.0220000100004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000080000), 0x1.02200002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77ffff7ffff), -0x1.0220000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004088000800000), 0x1.0220002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fff7fffff), -0x1.0220002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004088001000000), 0x1.0220004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77ffeffffff), -0x1.0220004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004088010000000), 0x1.022004p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fefffffff), -0x1.0220040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004088020000000), 0x1.022008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77fdfffffff), -0x1.0220080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004088200000000), 0x1.02208p+50, 0x0p+0 },
+{ INT64_C(0xfffbf77dffffffff), -0x1.0220800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004089000000000), 0x1.0224p+50, 0x0p+0 },
+{ INT64_C(0xfffbf76fffffffff), -0x1.0224000000004p+50, 0x0p+0 },
+{ INT64_C(0x000408a000000000), 0x1.0228p+50, 0x0p+0 },
+{ INT64_C(0xfffbf75fffffffff), -0x1.0228000000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000000000), 0x1.028p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5ffffffffff), -0x1.0280000000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000000008), 0x1.028000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fffffffff7), -0x1.0280000000024p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000000020), 0x1.028000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5ffffffffdf), -0x1.0280000000084p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000000200), 0x1.02800000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fffffffdff), -0x1.0280000000804p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000000800), 0x1.0280000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fffffff7ff), -0x1.0280000002004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000008000), 0x1.028000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5ffffff7fff), -0x1.0280000020004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000080000), 0x1.02800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fffff7ffff), -0x1.0280000200004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000200000), 0x1.02800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5ffffdfffff), -0x1.0280000800004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0000800000), 0x1.0280002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5ffff7fffff), -0x1.0280002000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0002000000), 0x1.0280008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fffdffffff), -0x1.0280008000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0008000000), 0x1.028002p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fff7ffffff), -0x1.0280020000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0020000000), 0x1.028008p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5ffdfffffff), -0x1.0280080000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0100000000), 0x1.02804p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5feffffffff), -0x1.0280400000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a0400000000), 0x1.0281p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5fbffffffff), -0x1.0281000000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a4000000000), 0x1.029p+50, 0x0p+0 },
+{ INT64_C(0xfffbf5bfffffffff), -0x1.0290000000004p+50, 0x0p+0 },
+{ INT64_C(0x00040a8000000000), 0x1.02ap+50, 0x0p+0 },
+{ INT64_C(0xfffbf57fffffffff), -0x1.02a0000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000001), 0x1.0800000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffffffe), -0x1.0800000000008p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000002), 0x1.0800000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffffffd), -0x1.080000000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004200000000010), 0x1.080000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffffef), -0x1.0800000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000014), 0x1.080000000005p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffffeb), -0x1.0800000000054p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000020), 0x1.080000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffffdf), -0x1.0800000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000022), 0x1.0800000000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffffdd), -0x1.080000000008cp+50, 0x0p+0 },
+{ INT64_C(0x0004200000000028), 0x1.08000000000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffffd7), -0x1.08000000000a4p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000030), 0x1.08000000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffffcf), -0x1.08000000000c4p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000200), 0x1.08000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffffdff), -0x1.0800000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000204), 0x1.080000000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffffdfb), -0x1.0800000000814p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000210), 0x1.080000000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffffdef), -0x1.0800000000844p+50, 0x0p+0 },
+{ INT64_C(0x0004200000000300), 0x1.0800000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffffcff), -0x1.0800000000c04p+50, 0x0p+0 },
+{ INT64_C(0x0004200000001000), 0x1.0800000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffefff), -0x1.0800000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000001008), 0x1.080000000402p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffeff7), -0x1.0800000004024p+50, 0x0p+0 },
+{ INT64_C(0x0004200000001040), 0x1.08000000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffefbf), -0x1.0800000004104p+50, 0x0p+0 },
+{ INT64_C(0x0004200000001100), 0x1.08000000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffffeeff), -0x1.0800000004404p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008000), 0x1.080000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7fff), -0x1.0800000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008002), 0x1.0800000020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7ffd), -0x1.080000002000cp+50, 0x0p+0 },
+{ INT64_C(0x0004200000008004), 0x1.080000002001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7ffb), -0x1.0800000020014p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008040), 0x1.08000000201p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7fbf), -0x1.0800000020104p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008080), 0x1.08000000202p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7f7f), -0x1.0800000020204p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008100), 0x1.08000000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7eff), -0x1.0800000020404p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008400), 0x1.0800000021p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff7bff), -0x1.0800000021004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000008800), 0x1.0800000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff77ff), -0x1.0800000022004p+50, 0x0p+0 },
+{ INT64_C(0x000420000000a000), 0x1.0800000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffff5fff), -0x1.0800000028004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000020000), 0x1.080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdffff), -0x1.0800000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000020002), 0x1.0800000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdfffd), -0x1.080000008000cp+50, 0x0p+0 },
+{ INT64_C(0x0004200000020010), 0x1.080000008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdffef), -0x1.0800000080044p+50, 0x0p+0 },
+{ INT64_C(0x0004200000020100), 0x1.08000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdfeff), -0x1.0800000080404p+50, 0x0p+0 },
+{ INT64_C(0x0004200000020200), 0x1.08000000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdfdff), -0x1.0800000080804p+50, 0x0p+0 },
+{ INT64_C(0x0004200000020800), 0x1.0800000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdf7ff), -0x1.0800000082004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000024000), 0x1.080000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffdbfff), -0x1.0800000090004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000030000), 0x1.08000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffffcffff), -0x1.08000000c0004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000080000), 0x1.08000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff7ffff), -0x1.0800000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000080004), 0x1.080000020001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff7fffb), -0x1.0800000200014p+50, 0x0p+0 },
+{ INT64_C(0x0004200000080020), 0x1.080000020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff7ffdf), -0x1.0800000200084p+50, 0x0p+0 },
+{ INT64_C(0x0004200000080100), 0x1.08000002004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff7feff), -0x1.0800000200404p+50, 0x0p+0 },
+{ INT64_C(0x0004200000080400), 0x1.0800000201p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff7fbff), -0x1.0800000201004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000084000), 0x1.080000021p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff7bfff), -0x1.0800000210004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000088000), 0x1.080000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff77fff), -0x1.0800000220004p+50, 0x0p+0 },
+{ INT64_C(0x00042000000a0000), 0x1.080000028p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffff5ffff), -0x1.0800000280004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000200000), 0x1.08000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffdfffff), -0x1.0800000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000200008), 0x1.080000080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffdffff7), -0x1.0800000800024p+50, 0x0p+0 },
+{ INT64_C(0x0004200000200040), 0x1.08000008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffdfffbf), -0x1.0800000800104p+50, 0x0p+0 },
+{ INT64_C(0x0004200000200400), 0x1.0800000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffdffbff), -0x1.0800000801004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000200800), 0x1.0800000802p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffdff7ff), -0x1.0800000802004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000204000), 0x1.080000081p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffdfbfff), -0x1.0800000810004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000220000), 0x1.080000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffddffff), -0x1.0800000880004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000280000), 0x1.0800000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffd7ffff), -0x1.0800000a00004p+50, 0x0p+0 },
+{ INT64_C(0x0004200000300000), 0x1.0800000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffffcfffff), -0x1.0800000c00004p+50, 0x0p+0 },
+{ INT64_C(0x0004200001000000), 0x1.0800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffeffffff), -0x1.0800004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200001000002), 0x1.0800004000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffefffffd), -0x1.080000400000cp+50, 0x0p+0 },
+{ INT64_C(0x0004200001000020), 0x1.080000400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffeffffdf), -0x1.0800004000084p+50, 0x0p+0 },
+{ INT64_C(0x0004200001000040), 0x1.08000040001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffeffffbf), -0x1.0800004000104p+50, 0x0p+0 },
+{ INT64_C(0x0004200001000100), 0x1.08000040004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffefffeff), -0x1.0800004000404p+50, 0x0p+0 },
+{ INT64_C(0x0004200001000800), 0x1.0800004002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffefff7ff), -0x1.0800004002004p+50, 0x0p+0 },
+{ INT64_C(0x0004200001008000), 0x1.080000402p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffeff7fff), -0x1.0800004020004p+50, 0x0p+0 },
+{ INT64_C(0x0004200001080000), 0x1.08000042p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffef7ffff), -0x1.0800004200004p+50, 0x0p+0 },
+{ INT64_C(0x0004200001800000), 0x1.0800006p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffffe7fffff), -0x1.0800006000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000000), 0x1.080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefffffff), -0x1.0800040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000002), 0x1.0800040000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffeffffffd), -0x1.080004000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004200010000008), 0x1.080004000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffeffffff7), -0x1.0800040000024p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000010), 0x1.080004000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefffffef), -0x1.0800040000044p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000020), 0x1.080004000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefffffdf), -0x1.0800040000084p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000040), 0x1.08000400001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefffffbf), -0x1.0800040000104p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000080), 0x1.08000400002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefffff7f), -0x1.0800040000204p+50, 0x0p+0 },
+{ INT64_C(0x0004200010000200), 0x1.08000400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffeffffdff), -0x1.0800040000804p+50, 0x0p+0 },
+{ INT64_C(0x0004200010002000), 0x1.0800040008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefffdfff), -0x1.0800040008004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010008000), 0x1.080004002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefff7fff), -0x1.0800040020004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010010000), 0x1.080004004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffeffeffff), -0x1.0800040040004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010020000), 0x1.080004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffeffdffff), -0x1.0800040080004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010200000), 0x1.08000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefdfffff), -0x1.0800040800004p+50, 0x0p+0 },
+{ INT64_C(0x0004200010400000), 0x1.0800041p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffefbfffff), -0x1.0800041000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200014000000), 0x1.080005p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffebffffff), -0x1.0800050000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020000000), 0x1.080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdfffffff), -0x1.0800080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020000001), 0x1.0800080000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdffffffe), -0x1.0800080000008p+50, 0x0p+0 },
+{ INT64_C(0x0004200020000010), 0x1.080008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdfffffef), -0x1.0800080000044p+50, 0x0p+0 },
+{ INT64_C(0x0004200020000100), 0x1.08000800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdffffeff), -0x1.0800080000404p+50, 0x0p+0 },
+{ INT64_C(0x0004200020000800), 0x1.0800080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdffff7ff), -0x1.0800080002004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020002000), 0x1.0800080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdfffdfff), -0x1.0800080008004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020004000), 0x1.080008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdfffbfff), -0x1.0800080010004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020040000), 0x1.08000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdffbffff), -0x1.0800080100004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020100000), 0x1.08000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdfefffff), -0x1.0800080400004p+50, 0x0p+0 },
+{ INT64_C(0x0004200020400000), 0x1.0800081p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdfbfffff), -0x1.0800081000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200024000000), 0x1.080009p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfffdbffffff), -0x1.0800090000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200000000), 0x1.08008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffffffff), -0x1.0800800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200000002), 0x1.0800800000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfffffffd), -0x1.080080000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004200200000020), 0x1.080080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffffffdf), -0x1.0800800000084p+50, 0x0p+0 },
+{ INT64_C(0x0004200200000080), 0x1.08008000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffffff7f), -0x1.0800800000204p+50, 0x0p+0 },
+{ INT64_C(0x0004200200000100), 0x1.08008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfffffeff), -0x1.0800800000404p+50, 0x0p+0 },
+{ INT64_C(0x0004200200000400), 0x1.0800800001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfffffbff), -0x1.0800800001004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200000800), 0x1.0800800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfffff7ff), -0x1.0800800002004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200001000), 0x1.0800800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffffefff), -0x1.0800800004004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200008000), 0x1.080080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffff7fff), -0x1.0800800020004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200020000), 0x1.080080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfffdffff), -0x1.0800800080004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200040000), 0x1.08008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfffbffff), -0x1.0800800100004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200100000), 0x1.08008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffefffff), -0x1.0800800400004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200200000), 0x1.08008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffdfffff), -0x1.0800800800004p+50, 0x0p+0 },
+{ INT64_C(0x0004200200400000), 0x1.0800801p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdffbfffff), -0x1.0800801000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200201000000), 0x1.0800804p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfeffffff), -0x1.0800804000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200204000000), 0x1.080081p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdfbffffff), -0x1.0800810000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200220000000), 0x1.080088p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffddfffffff), -0x1.0800880000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200240000000), 0x1.08009p+50, 0x0p+0 },
+{ INT64_C(0xfffbdffdbfffffff), -0x1.0800900000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200280000000), 0x1.0800ap+50, 0x0p+0 },
+{ INT64_C(0xfffbdffd7fffffff), -0x1.0800a00000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200800000000), 0x1.0802p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7ffffffff), -0x1.0802000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200800000008), 0x1.080200000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7fffffff7), -0x1.0802000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004200800000080), 0x1.08020000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7ffffff7f), -0x1.0802000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004200800000200), 0x1.08020000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7fffffdff), -0x1.0802000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004200800000400), 0x1.0802000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7fffffbff), -0x1.0802000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004200800002000), 0x1.0802000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7ffffdfff), -0x1.0802000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004200800004000), 0x1.080200001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7ffffbfff), -0x1.0802000010004p+50, 0x0p+0 },
+{ INT64_C(0x0004200800040000), 0x1.08020001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7fffbffff), -0x1.0802000100004p+50, 0x0p+0 },
+{ INT64_C(0x0004200800400000), 0x1.0802001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7ffbfffff), -0x1.0802001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200804000000), 0x1.080201p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7fbffffff), -0x1.0802010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200840000000), 0x1.08021p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff7bfffffff), -0x1.0802100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004200a00000000), 0x1.08028p+50, 0x0p+0 },
+{ INT64_C(0xfffbdff5ffffffff), -0x1.0802800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202000000000), 0x1.0808p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdfffffffff), -0x1.0808000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202000000008), 0x1.080800000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdffffffff7), -0x1.0808000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004202000000020), 0x1.080800000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdfffffffdf), -0x1.0808000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004202000000200), 0x1.08080000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdffffffdff), -0x1.0808000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004202000001000), 0x1.0808000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdfffffefff), -0x1.0808000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004202000010000), 0x1.080800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdffffeffff), -0x1.0808000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004202000080000), 0x1.08080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdffff7ffff), -0x1.0808000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004202000400000), 0x1.0808001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdfffbfffff), -0x1.0808001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202004000000), 0x1.080801p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdffbffffff), -0x1.0808010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202008000000), 0x1.080802p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdff7ffffff), -0x1.0808020000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202020000000), 0x1.080808p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdfdfffffff), -0x1.0808080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202040000000), 0x1.08081p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdfbfffffff), -0x1.0808100000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202100000000), 0x1.08084p+50, 0x0p+0 },
+{ INT64_C(0xfffbdfdeffffffff), -0x1.0808400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004202800000000), 0x1.080ap+50, 0x0p+0 },
+{ INT64_C(0xfffbdfd7ffffffff), -0x1.080a000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004203000000000), 0x1.080cp+50, 0x0p+0 },
+{ INT64_C(0xfffbdfcfffffffff), -0x1.080c000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208000000000), 0x1.082p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffffffff), -0x1.0820000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208000000002), 0x1.0820000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7ffffffffd), -0x1.082000000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004208000000008), 0x1.082000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7ffffffff7), -0x1.0820000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004208000000020), 0x1.082000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffffffdf), -0x1.0820000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004208000000040), 0x1.08200000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffffffbf), -0x1.0820000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004208000000080), 0x1.08200000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffffff7f), -0x1.0820000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004208000000800), 0x1.0820000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7ffffff7ff), -0x1.0820000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004208000008000), 0x1.082000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffff7fff), -0x1.0820000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004208000010000), 0x1.082000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7ffffeffff), -0x1.0820000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004208000100000), 0x1.08200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffefffff), -0x1.0820000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004208000400000), 0x1.0820001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fffbfffff), -0x1.0820001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208002000000), 0x1.0820008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7ffdffffff), -0x1.0820008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208004000000), 0x1.082001p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7ffbffffff), -0x1.0820010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208010000000), 0x1.082004p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fefffffff), -0x1.0820040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208020000000), 0x1.082008p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7fdfffffff), -0x1.0820080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208080000000), 0x1.08202p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7f7fffffff), -0x1.0820200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208100000000), 0x1.08204p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7effffffff), -0x1.0820400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004208200000000), 0x1.08208p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf7dffffffff), -0x1.0820800000004p+50, 0x0p+0 },
+{ INT64_C(0x000420a000000000), 0x1.0828p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf5fffffffff), -0x1.0828000000004p+50, 0x0p+0 },
+{ INT64_C(0x000420c000000000), 0x1.083p+50, 0x0p+0 },
+{ INT64_C(0xfffbdf3fffffffff), -0x1.0830000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004280000000000), 0x1.0ap+50, 0x0p+0 },
+{ INT64_C(0xfffbd7ffffffffff), -0x1.0a00000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004280000000004), 0x1.0a0000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7fffffffffb), -0x1.0a00000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004280000000040), 0x1.0a000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7ffffffffbf), -0x1.0a00000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004280000000400), 0x1.0a00000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7fffffffbff), -0x1.0a00000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004280000002000), 0x1.0a00000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7ffffffdfff), -0x1.0a00000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004280000020000), 0x1.0a0000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7fffffdffff), -0x1.0a00000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004280000200000), 0x1.0a000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7ffffdfffff), -0x1.0a00000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004280002000000), 0x1.0a00008p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7fffdffffff), -0x1.0a00008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004280010000000), 0x1.0a0004p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7ffefffffff), -0x1.0a00040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004280100000000), 0x1.0a004p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7feffffffff), -0x1.0a00400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004280800000000), 0x1.0a02p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7f7ffffffff), -0x1.0a02000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004281000000000), 0x1.0a04p+50, 0x0p+0 },
+{ INT64_C(0xfffbd7efffffffff), -0x1.0a04000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004290000000000), 0x1.0a4p+50, 0x0p+0 },
+{ INT64_C(0xfffbd6ffffffffff), -0x1.0a40000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000004), 0x1.100000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffffb), -0x1.1000000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000006), 0x1.1000000000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffff9), -0x1.100000000001cp+50, 0x0p+0 },
+{ INT64_C(0x0004400000000040), 0x1.10000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffffbf), -0x1.1000000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000048), 0x1.100000000012p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffffb7), -0x1.1000000000124p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000100), 0x1.10000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffeff), -0x1.1000000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000104), 0x1.100000000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffefb), -0x1.1000000000414p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000110), 0x1.100000000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffeef), -0x1.1000000000444p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000400), 0x1.1000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffbff), -0x1.1000000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000408), 0x1.100000000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffbf7), -0x1.1000000001024p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000440), 0x1.10000000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffbbf), -0x1.1000000001104p+50, 0x0p+0 },
+{ INT64_C(0x0004400000000500), 0x1.10000000014p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffffaff), -0x1.1000000001404p+50, 0x0p+0 },
+{ INT64_C(0x0004400000004000), 0x1.100000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffbfff), -0x1.1000000010004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000004008), 0x1.100000001002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffbff7), -0x1.1000000010024p+50, 0x0p+0 },
+{ INT64_C(0x0004400000004080), 0x1.10000000102p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffbf7f), -0x1.1000000010204p+50, 0x0p+0 },
+{ INT64_C(0x0004400000004400), 0x1.1000000011p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffbbff), -0x1.1000000011004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000004800), 0x1.1000000012p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffb7ff), -0x1.1000000012004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000005000), 0x1.1000000014p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffffafff), -0x1.1000000014004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000006000), 0x1.1000000018p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffff9fff), -0x1.1000000018004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010000), 0x1.100000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffeffff), -0x1.1000000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010001), 0x1.1000000040004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffefffe), -0x1.1000000040008p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010004), 0x1.100000004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffefffb), -0x1.1000000040014p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010010), 0x1.100000004004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffeffef), -0x1.1000000040044p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010080), 0x1.10000000402p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffeff7f), -0x1.1000000040204p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010200), 0x1.10000000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffefdff), -0x1.1000000040804p+50, 0x0p+0 },
+{ INT64_C(0x0004400000010400), 0x1.1000000041p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffefbff), -0x1.1000000041004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000012000), 0x1.1000000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffedfff), -0x1.1000000048004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000020000), 0x1.100000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdffff), -0x1.1000000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000020008), 0x1.100000008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdfff7), -0x1.1000000080024p+50, 0x0p+0 },
+{ INT64_C(0x0004400000020010), 0x1.100000008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdffef), -0x1.1000000080044p+50, 0x0p+0 },
+{ INT64_C(0x0004400000020100), 0x1.10000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdfeff), -0x1.1000000080404p+50, 0x0p+0 },
+{ INT64_C(0x0004400000020800), 0x1.1000000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdf7ff), -0x1.1000000082004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000021000), 0x1.1000000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdefff), -0x1.1000000084004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000024000), 0x1.100000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffdbfff), -0x1.1000000090004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000028000), 0x1.10000000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffffd7fff), -0x1.10000000a0004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000200000), 0x1.10000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdfffff), -0x1.1000000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000200001), 0x1.1000000800004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdffffe), -0x1.1000000800008p+50, 0x0p+0 },
+{ INT64_C(0x0004400000200002), 0x1.1000000800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdffffd), -0x1.100000080000cp+50, 0x0p+0 },
+{ INT64_C(0x0004400000200008), 0x1.100000080002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdffff7), -0x1.1000000800024p+50, 0x0p+0 },
+{ INT64_C(0x0004400000200040), 0x1.10000008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdfffbf), -0x1.1000000800104p+50, 0x0p+0 },
+{ INT64_C(0x0004400000200100), 0x1.10000008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdffeff), -0x1.1000000800404p+50, 0x0p+0 },
+{ INT64_C(0x0004400000201000), 0x1.1000000804p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdfefff), -0x1.1000000804004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000210000), 0x1.100000084p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdeffff), -0x1.1000000840004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000240000), 0x1.10000009p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffdbffff), -0x1.1000000900004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000300000), 0x1.1000000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffffcfffff), -0x1.1000000c00004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000800000), 0x1.1000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7fffff), -0x1.1000002000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000800002), 0x1.1000002000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7ffffd), -0x1.100000200000cp+50, 0x0p+0 },
+{ INT64_C(0x0004400000800010), 0x1.100000200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7fffef), -0x1.1000002000044p+50, 0x0p+0 },
+{ INT64_C(0x0004400000800100), 0x1.10000020004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7ffeff), -0x1.1000002000404p+50, 0x0p+0 },
+{ INT64_C(0x0004400000800800), 0x1.1000002002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7ff7ff), -0x1.1000002002004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000808000), 0x1.100000202p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7f7fff), -0x1.1000002020004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000810000), 0x1.100000204p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff7effff), -0x1.1000002040004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000880000), 0x1.10000022p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff77ffff), -0x1.1000002200004p+50, 0x0p+0 },
+{ INT64_C(0x0004400000900000), 0x1.10000024p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffff6fffff), -0x1.1000002400004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000000), 0x1.1000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdffffff), -0x1.1000008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000001), 0x1.1000008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdfffffe), -0x1.1000008000008p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000008), 0x1.100000800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdfffff7), -0x1.1000008000024p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000040), 0x1.10000080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdffffbf), -0x1.1000008000104p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000100), 0x1.10000080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdfffeff), -0x1.1000008000404p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000400), 0x1.1000008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdfffbff), -0x1.1000008001004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002000800), 0x1.1000008002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdfff7ff), -0x1.1000008002004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002002000), 0x1.1000008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdffdfff), -0x1.1000008008004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002004000), 0x1.100000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdffbfff), -0x1.1000008010004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002020000), 0x1.100000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdfdffff), -0x1.1000008080004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002080000), 0x1.10000082p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffdf7ffff), -0x1.1000008200004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002200000), 0x1.10000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffddfffff), -0x1.1000008800004p+50, 0x0p+0 },
+{ INT64_C(0x0004400002800000), 0x1.100000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbbffffd7fffff), -0x1.100000a000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400010000000), 0x1.100004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffefffffff), -0x1.1000040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400010000004), 0x1.100004000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffeffffffb), -0x1.1000040000014p+50, 0x0p+0 },
+{ INT64_C(0x0004400010000040), 0x1.10000400001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffefffffbf), -0x1.1000040000104p+50, 0x0p+0 },
+{ INT64_C(0x0004400010000100), 0x1.10000400004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffeffffeff), -0x1.1000040000404p+50, 0x0p+0 },
+{ INT64_C(0x0004400010000200), 0x1.10000400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffeffffdff), -0x1.1000040000804p+50, 0x0p+0 },
+{ INT64_C(0x0004400010002000), 0x1.1000040008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffefffdfff), -0x1.1000040008004p+50, 0x0p+0 },
+{ INT64_C(0x0004400010008000), 0x1.100004002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffefff7fff), -0x1.1000040020004p+50, 0x0p+0 },
+{ INT64_C(0x0004400010010000), 0x1.100004004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffeffeffff), -0x1.1000040040004p+50, 0x0p+0 },
+{ INT64_C(0x0004400010100000), 0x1.10000404p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffefefffff), -0x1.1000040400004p+50, 0x0p+0 },
+{ INT64_C(0x0004400011000000), 0x1.1000044p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffeeffffff), -0x1.1000044000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400012000000), 0x1.1000048p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffedffffff), -0x1.1000048000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400020000000), 0x1.100008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdfffffff), -0x1.1000080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400020000008), 0x1.100008000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdffffff7), -0x1.1000080000024p+50, 0x0p+0 },
+{ INT64_C(0x0004400020000020), 0x1.100008000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdfffffdf), -0x1.1000080000084p+50, 0x0p+0 },
+{ INT64_C(0x0004400020000080), 0x1.10000800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdfffff7f), -0x1.1000080000204p+50, 0x0p+0 },
+{ INT64_C(0x0004400020000200), 0x1.10000800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdffffdff), -0x1.1000080000804p+50, 0x0p+0 },
+{ INT64_C(0x0004400020001000), 0x1.1000080004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdfffefff), -0x1.1000080004004p+50, 0x0p+0 },
+{ INT64_C(0x0004400020002000), 0x1.1000080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdfffdfff), -0x1.1000080008004p+50, 0x0p+0 },
+{ INT64_C(0x0004400020010000), 0x1.100008004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdffeffff), -0x1.1000080040004p+50, 0x0p+0 },
+{ INT64_C(0x0004400020020000), 0x1.100008008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdffdffff), -0x1.1000080080004p+50, 0x0p+0 },
+{ INT64_C(0x0004400020200000), 0x1.10000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffdfdfffff), -0x1.1000080800004p+50, 0x0p+0 },
+{ INT64_C(0x0004400022000000), 0x1.1000088p+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffddffffff), -0x1.1000088000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400028000000), 0x1.10000ap+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffd7ffffff), -0x1.10000a0000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400030000000), 0x1.10000cp+50, 0x0p+0 },
+{ INT64_C(0xfffbbfffcfffffff), -0x1.10000c0000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400100000000), 0x1.10004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffeffffffff), -0x1.1000400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400100000008), 0x1.100040000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffefffffff7), -0x1.1000400000024p+50, 0x0p+0 },
+{ INT64_C(0x0004400100000080), 0x1.10004000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffeffffff7f), -0x1.1000400000204p+50, 0x0p+0 },
+{ INT64_C(0x0004400100000800), 0x1.1000400002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffefffff7ff), -0x1.1000400002004p+50, 0x0p+0 },
+{ INT64_C(0x0004400100008000), 0x1.100040002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffeffff7fff), -0x1.1000400020004p+50, 0x0p+0 },
+{ INT64_C(0x0004400100040000), 0x1.10004001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffefffbffff), -0x1.1000400100004p+50, 0x0p+0 },
+{ INT64_C(0x0004400100200000), 0x1.10004008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffeffdfffff), -0x1.1000400800004p+50, 0x0p+0 },
+{ INT64_C(0x0004400100800000), 0x1.1000402p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffeff7fffff), -0x1.1000402000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400102000000), 0x1.1000408p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffefdffffff), -0x1.1000408000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400110000000), 0x1.100044p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffeefffffff), -0x1.1000440000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400120000000), 0x1.100048p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffedfffffff), -0x1.1000480000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200000000), 0x1.10008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdffffffff), -0x1.1000800000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200000001), 0x1.1000800000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffffffe), -0x1.1000800000008p+50, 0x0p+0 },
+{ INT64_C(0x0004400200000002), 0x1.1000800000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffffffd), -0x1.100080000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004400200000010), 0x1.100080000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdffffffef), -0x1.1000800000044p+50, 0x0p+0 },
+{ INT64_C(0x0004400200000100), 0x1.10008000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffffeff), -0x1.1000800000404p+50, 0x0p+0 },
+{ INT64_C(0x0004400200000400), 0x1.1000800001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffffbff), -0x1.1000800001004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200000800), 0x1.1000800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffff7ff), -0x1.1000800002004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200004000), 0x1.100080001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdffffbfff), -0x1.1000800010004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200020000), 0x1.100080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffdffff), -0x1.1000800080004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200040000), 0x1.10008001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfffbffff), -0x1.1000800100004p+50, 0x0p+0 },
+{ INT64_C(0x0004400200400000), 0x1.1000801p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdffbfffff), -0x1.1000801000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400202000000), 0x1.1000808p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfdffffff), -0x1.1000808000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400204000000), 0x1.100081p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdfbffffff), -0x1.1000810000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400208000000), 0x1.100082p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdf7ffffff), -0x1.1000820000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400240000000), 0x1.10009p+50, 0x0p+0 },
+{ INT64_C(0xfffbbffdbfffffff), -0x1.1000900000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800000000), 0x1.1002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffffffff), -0x1.1002000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800000002), 0x1.1002000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7fffffffd), -0x1.100200000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004400800000010), 0x1.100200000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffffffef), -0x1.1002000000044p+50, 0x0p+0 },
+{ INT64_C(0x0004400800000040), 0x1.10020000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffffffbf), -0x1.1002000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004400800000200), 0x1.10020000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7fffffdff), -0x1.1002000000804p+50, 0x0p+0 },
+{ INT64_C(0x0004400800000400), 0x1.1002000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7fffffbff), -0x1.1002000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800001000), 0x1.1002000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffffefff), -0x1.1002000004004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800008000), 0x1.100200002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffff7fff), -0x1.1002000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800080000), 0x1.10020002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7fff7ffff), -0x1.1002000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800100000), 0x1.10020004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffefffff), -0x1.1002000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004400800200000), 0x1.10020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7ffdfffff), -0x1.1002000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004400801000000), 0x1.1002004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7feffffff), -0x1.1002004000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400804000000), 0x1.100201p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7fbffffff), -0x1.1002010000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400820000000), 0x1.100208p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff7dfffffff), -0x1.1002080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004400900000000), 0x1.10024p+50, 0x0p+0 },
+{ INT64_C(0xfffbbff6ffffffff), -0x1.1002400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000000000), 0x1.102p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffffffff), -0x1.1020000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000000004), 0x1.102000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7ffffffffb), -0x1.1020000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004408000000020), 0x1.102000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffffffdf), -0x1.1020000000084p+50, 0x0p+0 },
+{ INT64_C(0x0004408000000080), 0x1.10200000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffffff7f), -0x1.1020000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004408000000400), 0x1.1020000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7ffffffbff), -0x1.1020000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000002000), 0x1.1020000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffffdfff), -0x1.1020000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000008000), 0x1.102000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffff7fff), -0x1.1020000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000020000), 0x1.102000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7ffffdffff), -0x1.1020000080004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000100000), 0x1.10200004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffefffff), -0x1.1020000400004p+50, 0x0p+0 },
+{ INT64_C(0x0004408000200000), 0x1.10200008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fffdfffff), -0x1.1020000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004408002000000), 0x1.1020008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7ffdffffff), -0x1.1020008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004408020000000), 0x1.102008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7fdfffffff), -0x1.1020080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004408080000000), 0x1.10202p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf7f7fffffff), -0x1.1020200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004408800000000), 0x1.1022p+50, 0x0p+0 },
+{ INT64_C(0xfffbbf77ffffffff), -0x1.1022000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004420000000000), 0x1.108p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdffffffffff), -0x1.1080000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004420000000008), 0x1.108000000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfffffffff7), -0x1.1080000000024p+50, 0x0p+0 },
+{ INT64_C(0x0004420000000040), 0x1.10800000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdffffffffbf), -0x1.1080000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004420000000080), 0x1.10800000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdffffffff7f), -0x1.1080000000204p+50, 0x0p+0 },
+{ INT64_C(0x0004420000000800), 0x1.1080000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfffffff7ff), -0x1.1080000002004p+50, 0x0p+0 },
+{ INT64_C(0x0004420000008000), 0x1.108000002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdffffff7fff), -0x1.1080000020004p+50, 0x0p+0 },
+{ INT64_C(0x0004420000010000), 0x1.108000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfffffeffff), -0x1.1080000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004420000080000), 0x1.10800002p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfffff7ffff), -0x1.1080000200004p+50, 0x0p+0 },
+{ INT64_C(0x0004420000200000), 0x1.10800008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdffffdfffff), -0x1.1080000800004p+50, 0x0p+0 },
+{ INT64_C(0x0004420002000000), 0x1.1080008p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfffdffffff), -0x1.1080008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004420010000000), 0x1.108004p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdffefffffff), -0x1.1080040000004p+50, 0x0p+0 },
+{ INT64_C(0x0004420100000000), 0x1.10804p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfeffffffff), -0x1.1080400000004p+50, 0x0p+0 },
+{ INT64_C(0x0004420400000000), 0x1.1081p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdfbffffffff), -0x1.1081000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004420800000000), 0x1.1082p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdf7ffffffff), -0x1.1082000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004421000000000), 0x1.1084p+50, 0x0p+0 },
+{ INT64_C(0xfffbbdefffffffff), -0x1.1084000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004428000000000), 0x1.10ap+50, 0x0p+0 },
+{ INT64_C(0xfffbbd7fffffffff), -0x1.10a0000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004430000000000), 0x1.10cp+50, 0x0p+0 },
+{ INT64_C(0xfffbbcffffffffff), -0x1.10c0000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004500000000000), 0x1.14p+50, 0x0p+0 },
+{ INT64_C(0xfffbafffffffffff), -0x1.1400000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004500000000002), 0x1.1400000000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffffffffd), -0x1.140000000000cp+50, 0x0p+0 },
+{ INT64_C(0x0004500000000004), 0x1.140000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffffffffb), -0x1.1400000000014p+50, 0x0p+0 },
+{ INT64_C(0x0004500000000040), 0x1.14000000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbafffffffffbf), -0x1.1400000000104p+50, 0x0p+0 },
+{ INT64_C(0x0004500000000100), 0x1.14000000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffffffeff), -0x1.1400000000404p+50, 0x0p+0 },
+{ INT64_C(0x0004500000000400), 0x1.1400000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffffffbff), -0x1.1400000001004p+50, 0x0p+0 },
+{ INT64_C(0x0004500000002000), 0x1.1400000008p+50, 0x0p+0 },
+{ INT64_C(0xfffbafffffffdfff), -0x1.1400000008004p+50, 0x0p+0 },
+{ INT64_C(0x0004500000010000), 0x1.140000004p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffffeffff), -0x1.1400000040004p+50, 0x0p+0 },
+{ INT64_C(0x0004500000040000), 0x1.14000001p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffffbffff), -0x1.1400000100004p+50, 0x0p+0 },
+{ INT64_C(0x0004500000400000), 0x1.1400001p+50, 0x0p+0 },
+{ INT64_C(0xfffbafffffbfffff), -0x1.1400001000004p+50, 0x0p+0 },
+{ INT64_C(0x0004500002000000), 0x1.1400008p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffffdffffff), -0x1.1400008000004p+50, 0x0p+0 },
+{ INT64_C(0x0004500020000000), 0x1.140008p+50, 0x0p+0 },
+{ INT64_C(0xfffbafffdfffffff), -0x1.1400080000004p+50, 0x0p+0 },
+{ INT64_C(0x0004500080000000), 0x1.14002p+50, 0x0p+0 },
+{ INT64_C(0xfffbafff7fffffff), -0x1.1400200000004p+50, 0x0p+0 },
+{ INT64_C(0x0004500400000000), 0x1.1401p+50, 0x0p+0 },
+{ INT64_C(0xfffbaffbffffffff), -0x1.1401000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004502000000000), 0x1.1408p+50, 0x0p+0 },
+{ INT64_C(0xfffbafdfffffffff), -0x1.1408000000004p+50, 0x0p+0 },
+{ INT64_C(0x0004510000000000), 0x1.144p+50, 0x0p+0 },
+{ INT64_C(0xfffbaeffffffffff), -0x1.1440000000004p+50, 0x0p+0 },
+{ INT64_C(0x002000000000000a), 0x1.0000000000005p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffff5), -0x1.0000000000006p+53, 0x1p+0 },
+{ INT64_C(0x0020000000000084), 0x1.0000000000042p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffff7b), -0x1.0000000000042p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000085), 0x1.0000000000042p+53, 0x1p+0 },
+{ INT64_C(0xffdfffffffffff7a), -0x1.0000000000043p+53, 0x0p+0 },
+{ INT64_C(0x00200000000000c0), 0x1.000000000006p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffff3f), -0x1.000000000006p+53, -0x1p+0 },
+{ INT64_C(0x00200000000000c4), 0x1.0000000000062p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffff3b), -0x1.0000000000062p+53, -0x1p+0 },
+{ INT64_C(0x00200000000000d0), 0x1.0000000000068p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffff2f), -0x1.0000000000068p+53, -0x1p+0 },
+{ INT64_C(0x00200000000000e0), 0x1.000000000007p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffff1f), -0x1.000000000007p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000202), 0x1.0000000000101p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffdfd), -0x1.0000000000102p+53, 0x1p+0 },
+{ INT64_C(0x0020000000000210), 0x1.0000000000108p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffdef), -0x1.0000000000108p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000214), 0x1.000000000010ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffdeb), -0x1.000000000010ap+53, -0x1p+0 },
+{ INT64_C(0x0020000000000240), 0x1.000000000012p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffdbf), -0x1.000000000012p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000244), 0x1.0000000000122p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffdbb), -0x1.0000000000122p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000250), 0x1.0000000000128p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffdaf), -0x1.0000000000128p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000260), 0x1.000000000013p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffffd9f), -0x1.000000000013p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000808), 0x1.0000000000404p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff7f7), -0x1.0000000000404p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000809), 0x1.0000000000404p+53, 0x1p+0 },
+{ INT64_C(0xffdffffffffff7f6), -0x1.0000000000405p+53, 0x0p+0 },
+{ INT64_C(0x0020000000000880), 0x1.000000000044p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff77f), -0x1.000000000044p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000882), 0x1.0000000000441p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff77d), -0x1.0000000000442p+53, 0x1p+0 },
+{ INT64_C(0x0020000000000884), 0x1.0000000000442p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff77b), -0x1.0000000000442p+53, -0x1p+0 },
+{ INT64_C(0x00200000000008a0), 0x1.000000000045p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff75f), -0x1.000000000045p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000900), 0x1.000000000048p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff6ff), -0x1.000000000048p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000902), 0x1.0000000000481p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff6fd), -0x1.0000000000482p+53, 0x1p+0 },
+{ INT64_C(0x0020000000000920), 0x1.000000000049p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff6df), -0x1.000000000049p+53, -0x1p+0 },
+{ INT64_C(0x0020000000000940), 0x1.00000000004ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff6bf), -0x1.00000000004ap+53, -0x1p+0 },
+{ INT64_C(0x0020000000000980), 0x1.00000000004cp+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffff67f), -0x1.00000000004cp+53, -0x1p+0 },
+{ INT64_C(0x0020000000002008), 0x1.0000000001004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdff7), -0x1.0000000001004p+53, -0x1p+0 },
+{ INT64_C(0x002000000000200c), 0x1.0000000001006p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdff3), -0x1.0000000001006p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002040), 0x1.000000000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdfbf), -0x1.000000000102p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002048), 0x1.0000000001024p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdfb7), -0x1.0000000001024p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002060), 0x1.000000000103p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdf9f), -0x1.000000000103p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002100), 0x1.000000000108p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdeff), -0x1.000000000108p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002108), 0x1.0000000001084p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdef7), -0x1.0000000001084p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002140), 0x1.00000000010ap+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffdebf), -0x1.00000000010ap+53, -0x1p+0 },
+{ INT64_C(0x0020000000002800), 0x1.00000000014p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffd7ff), -0x1.00000000014p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002801), 0x1.00000000014p+53, 0x1p+0 },
+{ INT64_C(0xffdfffffffffd7fe), -0x1.0000000001401p+53, 0x0p+0 },
+{ INT64_C(0x0020000000002804), 0x1.0000000001402p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffd7fb), -0x1.0000000001402p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002820), 0x1.000000000141p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffd7df), -0x1.000000000141p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002840), 0x1.000000000142p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffd7bf), -0x1.000000000142p+53, -0x1p+0 },
+{ INT64_C(0x0020000000002880), 0x1.000000000144p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffd77f), -0x1.000000000144p+53, -0x1p+0 },
+{ INT64_C(0x0020000000003000), 0x1.00000000018p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffcfff), -0x1.00000000018p+53, -0x1p+0 },
+{ INT64_C(0x0020000000003001), 0x1.00000000018p+53, 0x1p+0 },
+{ INT64_C(0xffdfffffffffcffe), -0x1.0000000001801p+53, 0x0p+0 },
+{ INT64_C(0x0020000000003008), 0x1.0000000001804p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffcff7), -0x1.0000000001804p+53, -0x1p+0 },
+{ INT64_C(0x0020000000003080), 0x1.000000000184p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffcf7f), -0x1.000000000184p+53, -0x1p+0 },
+{ INT64_C(0x0020000000003200), 0x1.00000000019p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffcdff), -0x1.00000000019p+53, -0x1p+0 },
+{ INT64_C(0x0020000000003800), 0x1.0000000001cp+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffffc7ff), -0x1.0000000001cp+53, -0x1p+0 },
+{ INT64_C(0x0020000000020008), 0x1.0000000010004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfff7), -0x1.0000000010004p+53, -0x1p+0 },
+{ INT64_C(0x002000000002000c), 0x1.0000000010006p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfff3), -0x1.0000000010006p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020020), 0x1.000000001001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdffdf), -0x1.000000001001p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020021), 0x1.000000001001p+53, 0x1p+0 },
+{ INT64_C(0xffdffffffffdffde), -0x1.0000000010011p+53, 0x0p+0 },
+{ INT64_C(0x0020000000020024), 0x1.0000000010012p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdffdb), -0x1.0000000010012p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020080), 0x1.000000001004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdff7f), -0x1.000000001004p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020088), 0x1.0000000010044p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdff77), -0x1.0000000010044p+53, -0x1p+0 },
+{ INT64_C(0x00200000000200a0), 0x1.000000001005p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdff5f), -0x1.000000001005p+53, -0x1p+0 },
+{ INT64_C(0x00200000000200c0), 0x1.000000001006p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdff3f), -0x1.000000001006p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020100), 0x1.000000001008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfeff), -0x1.000000001008p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020108), 0x1.0000000010084p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfef7), -0x1.0000000010084p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020140), 0x1.00000000100ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfebf), -0x1.00000000100ap+53, -0x1p+0 },
+{ INT64_C(0x0020000000020200), 0x1.00000000101p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfdff), -0x1.00000000101p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020201), 0x1.00000000101p+53, 0x1p+0 },
+{ INT64_C(0xffdffffffffdfdfe), -0x1.0000000010101p+53, 0x0p+0 },
+{ INT64_C(0x0020000000020210), 0x1.0000000010108p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfdef), -0x1.0000000010108p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020280), 0x1.000000001014p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdfd7f), -0x1.000000001014p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020800), 0x1.00000000104p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdf7ff), -0x1.00000000104p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020801), 0x1.00000000104p+53, 0x1p+0 },
+{ INT64_C(0xffdffffffffdf7fe), -0x1.0000000010401p+53, 0x0p+0 },
+{ INT64_C(0x0020000000020804), 0x1.0000000010402p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdf7fb), -0x1.0000000010402p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020810), 0x1.0000000010408p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdf7ef), -0x1.0000000010408p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020880), 0x1.000000001044p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdf77f), -0x1.000000001044p+53, -0x1p+0 },
+{ INT64_C(0x0020000000020c00), 0x1.00000000106p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdf3ff), -0x1.00000000106p+53, -0x1p+0 },
+{ INT64_C(0x0020000000024000), 0x1.0000000012p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdbfff), -0x1.0000000012p+53, -0x1p+0 },
+{ INT64_C(0x0020000000024004), 0x1.0000000012002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdbffb), -0x1.0000000012002p+53, -0x1p+0 },
+{ INT64_C(0x0020000000024040), 0x1.000000001202p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdbfbf), -0x1.000000001202p+53, -0x1p+0 },
+{ INT64_C(0x0020000000024080), 0x1.000000001204p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdbf7f), -0x1.000000001204p+53, -0x1p+0 },
+{ INT64_C(0x0020000000024200), 0x1.00000000121p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdbdff), -0x1.00000000121p+53, -0x1p+0 },
+{ INT64_C(0x0020000000025000), 0x1.00000000128p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffdafff), -0x1.00000000128p+53, -0x1p+0 },
+{ INT64_C(0x0020000000026000), 0x1.0000000013p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd9fff), -0x1.0000000013p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028000), 0x1.0000000014p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7fff), -0x1.0000000014p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028008), 0x1.0000000014004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7ff7), -0x1.0000000014004p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028010), 0x1.0000000014008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7fef), -0x1.0000000014008p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028040), 0x1.000000001402p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7fbf), -0x1.000000001402p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028080), 0x1.000000001404p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7f7f), -0x1.000000001404p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028200), 0x1.00000000141p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7dff), -0x1.00000000141p+53, -0x1p+0 },
+{ INT64_C(0x0020000000028400), 0x1.00000000142p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd7bff), -0x1.00000000142p+53, -0x1p+0 },
+{ INT64_C(0x0020000000029000), 0x1.00000000148p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd6fff), -0x1.00000000148p+53, -0x1p+0 },
+{ INT64_C(0x002000000002a000), 0x1.0000000015p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffd5fff), -0x1.0000000015p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030000), 0x1.0000000018p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcffff), -0x1.0000000018p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030001), 0x1.0000000018p+53, 0x1p+0 },
+{ INT64_C(0xffdffffffffcfffe), -0x1.0000000018001p+53, 0x0p+0 },
+{ INT64_C(0x0020000000030004), 0x1.0000000018002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcfffb), -0x1.0000000018002p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030008), 0x1.0000000018004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcfff7), -0x1.0000000018004p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030040), 0x1.000000001802p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcffbf), -0x1.000000001802p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030080), 0x1.000000001804p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcff7f), -0x1.000000001804p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030100), 0x1.000000001808p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcfeff), -0x1.000000001808p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030400), 0x1.00000000182p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcfbff), -0x1.00000000182p+53, -0x1p+0 },
+{ INT64_C(0x0020000000030800), 0x1.00000000184p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffcf7ff), -0x1.00000000184p+53, -0x1p+0 },
+{ INT64_C(0x0020000000038000), 0x1.000000001cp+53, 0x0p+0 },
+{ INT64_C(0xffdffffffffc7fff), -0x1.000000001cp+53, -0x1p+0 },
+{ INT64_C(0x0020000000200002), 0x1.0000000100001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdffffd), -0x1.0000000100002p+53, 0x1p+0 },
+{ INT64_C(0x0020000000200020), 0x1.000000010001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfffdf), -0x1.000000010001p+53, -0x1p+0 },
+{ INT64_C(0x0020000000200028), 0x1.0000000100014p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfffd7), -0x1.0000000100014p+53, -0x1p+0 },
+{ INT64_C(0x0020000000200200), 0x1.00000001001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdffdff), -0x1.00000001001p+53, -0x1p+0 },
+{ INT64_C(0x0020000000200204), 0x1.0000000100102p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdffdfb), -0x1.0000000100102p+53, -0x1p+0 },
+{ INT64_C(0x0020000000200208), 0x1.0000000100104p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdffdf7), -0x1.0000000100104p+53, -0x1p+0 },
+{ INT64_C(0x0020000000200280), 0x1.000000010014p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdffd7f), -0x1.000000010014p+53, -0x1p+0 },
+{ INT64_C(0x0020000000202000), 0x1.0000000101p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfdfff), -0x1.0000000101p+53, -0x1p+0 },
+{ INT64_C(0x0020000000202008), 0x1.0000000101004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfdff7), -0x1.0000000101004p+53, -0x1p+0 },
+{ INT64_C(0x0020000000202010), 0x1.0000000101008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfdfef), -0x1.0000000101008p+53, -0x1p+0 },
+{ INT64_C(0x0020000000202080), 0x1.000000010104p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfdf7f), -0x1.000000010104p+53, -0x1p+0 },
+{ INT64_C(0x0020000000202400), 0x1.00000001012p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfdbff), -0x1.00000001012p+53, -0x1p+0 },
+{ INT64_C(0x0020000000202800), 0x1.00000001014p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfd7ff), -0x1.00000001014p+53, -0x1p+0 },
+{ INT64_C(0x0020000000204000), 0x1.0000000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfbfff), -0x1.0000000102p+53, -0x1p+0 },
+{ INT64_C(0x0020000000204002), 0x1.0000000102001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfbffd), -0x1.0000000102002p+53, 0x1p+0 },
+{ INT64_C(0x0020000000204004), 0x1.0000000102002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfbffb), -0x1.0000000102002p+53, -0x1p+0 },
+{ INT64_C(0x0020000000204040), 0x1.000000010202p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfbfbf), -0x1.000000010202p+53, -0x1p+0 },
+{ INT64_C(0x0020000000204400), 0x1.00000001022p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdfbbff), -0x1.00000001022p+53, -0x1p+0 },
+{ INT64_C(0x0020000000206000), 0x1.0000000103p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdf9fff), -0x1.0000000103p+53, -0x1p+0 },
+{ INT64_C(0x0020000000220000), 0x1.000000011p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddffff), -0x1.000000011p+53, -0x1p+0 },
+{ INT64_C(0x0020000000220002), 0x1.0000000110001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddfffd), -0x1.0000000110002p+53, 0x1p+0 },
+{ INT64_C(0x0020000000220010), 0x1.0000000110008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddffef), -0x1.0000000110008p+53, -0x1p+0 },
+{ INT64_C(0x0020000000220100), 0x1.000000011008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddfeff), -0x1.000000011008p+53, -0x1p+0 },
+{ INT64_C(0x0020000000220200), 0x1.00000001101p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddfdff), -0x1.00000001101p+53, -0x1p+0 },
+{ INT64_C(0x0020000000220800), 0x1.00000001104p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddf7ff), -0x1.00000001104p+53, -0x1p+0 },
+{ INT64_C(0x0020000000222000), 0x1.0000000111p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdddfff), -0x1.0000000111p+53, -0x1p+0 },
+{ INT64_C(0x0020000000224000), 0x1.0000000112p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffddbfff), -0x1.0000000112p+53, -0x1p+0 },
+{ INT64_C(0x0020000000230000), 0x1.0000000118p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffffdcffff), -0x1.0000000118p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000001), 0x1.00000008p+53, 0x1p+0 },
+{ INT64_C(0xffdffffffefffffe), -0x1.0000000800001p+53, 0x0p+0 },
+{ INT64_C(0x0020000001000004), 0x1.0000000800002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefffffb), -0x1.0000000800002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000020), 0x1.000000080001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffffdf), -0x1.000000080001p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000028), 0x1.0000000800014p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffffd7), -0x1.0000000800014p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000040), 0x1.000000080002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffffbf), -0x1.000000080002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000044), 0x1.0000000800022p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffffbb), -0x1.0000000800022p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000048), 0x1.0000000800024p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffffb7), -0x1.0000000800024p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000050), 0x1.0000000800028p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffffaf), -0x1.0000000800028p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000080), 0x1.000000080004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffff7f), -0x1.000000080004p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000082), 0x1.0000000800041p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffff7d), -0x1.0000000800042p+53, 0x1p+0 },
+{ INT64_C(0x00200000010000a0), 0x1.000000080005p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffff5f), -0x1.000000080005p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000400), 0x1.00000008002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefffbff), -0x1.00000008002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000402), 0x1.0000000800201p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefffbfd), -0x1.0000000800202p+53, 0x1p+0 },
+{ INT64_C(0x0020000001000404), 0x1.0000000800202p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefffbfb), -0x1.0000000800202p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000410), 0x1.0000000800208p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefffbef), -0x1.0000000800208p+53, -0x1p+0 },
+{ INT64_C(0x0020000001000500), 0x1.000000080028p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefffaff), -0x1.000000080028p+53, -0x1p+0 },
+{ INT64_C(0x0020000001001000), 0x1.00000008008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffefff), -0x1.00000008008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001001002), 0x1.0000000800801p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffeffd), -0x1.0000000800802p+53, 0x1p+0 },
+{ INT64_C(0x0020000001001010), 0x1.0000000800808p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffefef), -0x1.0000000800808p+53, -0x1p+0 },
+{ INT64_C(0x0020000001001100), 0x1.000000080088p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffeeff), -0x1.000000080088p+53, -0x1p+0 },
+{ INT64_C(0x0020000001001400), 0x1.0000000800ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffebff), -0x1.0000000800ap+53, -0x1p+0 },
+{ INT64_C(0x0020000001004000), 0x1.0000000802p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffbfff), -0x1.0000000802p+53, -0x1p+0 },
+{ INT64_C(0x0020000001004002), 0x1.0000000802001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffbffd), -0x1.0000000802002p+53, 0x1p+0 },
+{ INT64_C(0x0020000001004010), 0x1.0000000802008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffbfef), -0x1.0000000802008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001004080), 0x1.000000080204p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffbf7f), -0x1.000000080204p+53, -0x1p+0 },
+{ INT64_C(0x0020000001004400), 0x1.00000008022p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeffbbff), -0x1.00000008022p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008000), 0x1.0000000804p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7fff), -0x1.0000000804p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008004), 0x1.0000000804002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7ffb), -0x1.0000000804002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008010), 0x1.0000000804008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7fef), -0x1.0000000804008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008040), 0x1.000000080402p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7fbf), -0x1.000000080402p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008080), 0x1.000000080404p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7f7f), -0x1.000000080404p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008200), 0x1.00000008041p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7dff), -0x1.00000008041p+53, -0x1p+0 },
+{ INT64_C(0x0020000001008400), 0x1.00000008042p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff7bff), -0x1.00000008042p+53, -0x1p+0 },
+{ INT64_C(0x002000000100a000), 0x1.0000000805p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff5fff), -0x1.0000000805p+53, -0x1p+0 },
+{ INT64_C(0x002000000100c000), 0x1.0000000806p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeff3fff), -0x1.0000000806p+53, -0x1p+0 },
+{ INT64_C(0x0020000001020000), 0x1.000000081p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefdffff), -0x1.000000081p+53, -0x1p+0 },
+{ INT64_C(0x0020000001020008), 0x1.0000000810004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefdfff7), -0x1.0000000810004p+53, -0x1p+0 },
+{ INT64_C(0x0020000001020020), 0x1.000000081001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefdffdf), -0x1.000000081001p+53, -0x1p+0 },
+{ INT64_C(0x0020000001020200), 0x1.00000008101p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefdfdff), -0x1.00000008101p+53, -0x1p+0 },
+{ INT64_C(0x0020000001020800), 0x1.00000008104p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefdf7ff), -0x1.00000008104p+53, -0x1p+0 },
+{ INT64_C(0x0020000001024000), 0x1.0000000812p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefdbfff), -0x1.0000000812p+53, -0x1p+0 },
+{ INT64_C(0x0020000001030000), 0x1.0000000818p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffefcffff), -0x1.0000000818p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080000), 0x1.000000084p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7ffff), -0x1.000000084p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080004), 0x1.0000000840002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7fffb), -0x1.0000000840002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080008), 0x1.0000000840004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7fff7), -0x1.0000000840004p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080080), 0x1.000000084004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7ff7f), -0x1.000000084004p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080100), 0x1.000000084008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7feff), -0x1.000000084008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080200), 0x1.00000008401p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7fdff), -0x1.00000008401p+53, -0x1p+0 },
+{ INT64_C(0x0020000001080400), 0x1.00000008402p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7fbff), -0x1.00000008402p+53, -0x1p+0 },
+{ INT64_C(0x0020000001082000), 0x1.0000000841p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef7dfff), -0x1.0000000841p+53, -0x1p+0 },
+{ INT64_C(0x0020000001090000), 0x1.0000000848p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffef6ffff), -0x1.0000000848p+53, -0x1p+0 },
+{ INT64_C(0x0020000001100000), 0x1.000000088p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeefffff), -0x1.000000088p+53, -0x1p+0 },
+{ INT64_C(0x0020000001100004), 0x1.0000000880002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeeffffb), -0x1.0000000880002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001100010), 0x1.0000000880008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeefffef), -0x1.0000000880008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001100080), 0x1.000000088004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeefff7f), -0x1.000000088004p+53, -0x1p+0 },
+{ INT64_C(0x0020000001100100), 0x1.000000088008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeeffeff), -0x1.000000088008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001100400), 0x1.00000008802p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeeffbff), -0x1.00000008802p+53, -0x1p+0 },
+{ INT64_C(0x0020000001102000), 0x1.0000000881p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeefdfff), -0x1.0000000881p+53, -0x1p+0 },
+{ INT64_C(0x0020000001108000), 0x1.0000000884p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeef7fff), -0x1.0000000884p+53, -0x1p+0 },
+{ INT64_C(0x0020000001140000), 0x1.00000008ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffffeebffff), -0x1.00000008ap+53, -0x1p+0 },
+{ INT64_C(0x0020000001400000), 0x1.0000000ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebfffff), -0x1.0000000ap+53, -0x1p+0 },
+{ INT64_C(0x0020000001400004), 0x1.0000000a00002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebffffb), -0x1.0000000a00002p+53, -0x1p+0 },
+{ INT64_C(0x0020000001400010), 0x1.0000000a00008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebfffef), -0x1.0000000a00008p+53, -0x1p+0 },
+{ INT64_C(0x0020000001400020), 0x1.0000000a0001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebfffdf), -0x1.0000000a0001p+53, -0x1p+0 },
+{ INT64_C(0x0020000001400200), 0x1.0000000a001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebffdff), -0x1.0000000a001p+53, -0x1p+0 },
+{ INT64_C(0x0020000001400800), 0x1.0000000a004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebff7ff), -0x1.0000000a004p+53, -0x1p+0 },
+{ INT64_C(0x0020000001404000), 0x1.0000000a02p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebfbfff), -0x1.0000000a02p+53, -0x1p+0 },
+{ INT64_C(0x0020000001440000), 0x1.0000000a2p+53, 0x0p+0 },
+{ INT64_C(0xffdffffffebbffff), -0x1.0000000a2p+53, -0x1p+0 },
+{ INT64_C(0x0020000001600000), 0x1.0000000bp+53, 0x0p+0 },
+{ INT64_C(0xffdffffffe9fffff), -0x1.0000000bp+53, -0x1p+0 },
+{ INT64_C(0x0020000008000002), 0x1.0000004000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffffd), -0x1.0000004000002p+53, 0x1p+0 },
+{ INT64_C(0x0020000008000003), 0x1.0000004000002p+53, -0x1p+0 },
+{ INT64_C(0xffdffffff7fffffc), -0x1.0000004000002p+53, 0x0p+0 },
+{ INT64_C(0x0020000008000008), 0x1.0000004000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffff7), -0x1.0000004000004p+53, -0x1p+0 },
+{ INT64_C(0x0020000008000009), 0x1.0000004000004p+53, 0x1p+0 },
+{ INT64_C(0xffdffffff7fffff6), -0x1.0000004000005p+53, 0x0p+0 },
+{ INT64_C(0x002000000800000a), 0x1.0000004000005p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffff5), -0x1.0000004000006p+53, 0x1p+0 },
+{ INT64_C(0x0020000008000040), 0x1.000000400002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffffbf), -0x1.000000400002p+53, -0x1p+0 },
+{ INT64_C(0x0020000008000042), 0x1.0000004000021p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffffbd), -0x1.0000004000022p+53, 0x1p+0 },
+{ INT64_C(0x0020000008000048), 0x1.0000004000024p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffffb7), -0x1.0000004000024p+53, -0x1p+0 },
+{ INT64_C(0x0020000008000400), 0x1.00000040002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffbff), -0x1.00000040002p+53, -0x1p+0 },
+{ INT64_C(0x0020000008000402), 0x1.0000004000201p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffbfd), -0x1.0000004000202p+53, 0x1p+0 },
+{ INT64_C(0x0020000008000404), 0x1.0000004000202p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffbfb), -0x1.0000004000202p+53, -0x1p+0 },
+{ INT64_C(0x0020000008000420), 0x1.000000400021p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffbdf), -0x1.000000400021p+53, -0x1p+0 },
+{ INT64_C(0x0020000008000440), 0x1.000000400022p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fffbbf), -0x1.000000400022p+53, -0x1p+0 },
+{ INT64_C(0x0020000008002000), 0x1.0000004001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffdfff), -0x1.0000004001p+53, -0x1p+0 },
+{ INT64_C(0x0020000008002008), 0x1.0000004001004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffdff7), -0x1.0000004001004p+53, -0x1p+0 },
+{ INT64_C(0x0020000008002040), 0x1.000000400102p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffdfbf), -0x1.000000400102p+53, -0x1p+0 },
+{ INT64_C(0x0020000008002080), 0x1.000000400104p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffdf7f), -0x1.000000400104p+53, -0x1p+0 },
+{ INT64_C(0x0020000008002100), 0x1.000000400108p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffdeff), -0x1.000000400108p+53, -0x1p+0 },
+{ INT64_C(0x0020000008002200), 0x1.00000040011p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ffddff), -0x1.00000040011p+53, -0x1p+0 },
+{ INT64_C(0x0020000008010000), 0x1.0000004008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7feffff), -0x1.0000004008p+53, -0x1p+0 },
+{ INT64_C(0x0020000008010004), 0x1.0000004008002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fefffb), -0x1.0000004008002p+53, -0x1p+0 },
+{ INT64_C(0x0020000008010020), 0x1.000000400801p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7feffdf), -0x1.000000400801p+53, -0x1p+0 },
+{ INT64_C(0x0020000008010080), 0x1.000000400804p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7feff7f), -0x1.000000400804p+53, -0x1p+0 },
+{ INT64_C(0x0020000008010100), 0x1.000000400808p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fefeff), -0x1.000000400808p+53, -0x1p+0 },
+{ INT64_C(0x0020000008011000), 0x1.00000040088p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7feefff), -0x1.00000040088p+53, -0x1p+0 },
+{ INT64_C(0x0020000008012000), 0x1.0000004009p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fedfff), -0x1.0000004009p+53, -0x1p+0 },
+{ INT64_C(0x0020000008018000), 0x1.000000400cp+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7fe7fff), -0x1.000000400cp+53, -0x1p+0 },
+{ INT64_C(0x0020000008080000), 0x1.000000404p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f7ffff), -0x1.000000404p+53, -0x1p+0 },
+{ INT64_C(0x0020000008080001), 0x1.000000404p+53, 0x1p+0 },
+{ INT64_C(0xffdffffff7f7fffe), -0x1.0000004040001p+53, 0x0p+0 },
+{ INT64_C(0x0020000008080002), 0x1.0000004040001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f7fffd), -0x1.0000004040002p+53, 0x1p+0 },
+{ INT64_C(0x0020000008080004), 0x1.0000004040002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f7fffb), -0x1.0000004040002p+53, -0x1p+0 },
+{ INT64_C(0x0020000008080020), 0x1.000000404001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f7ffdf), -0x1.000000404001p+53, -0x1p+0 },
+{ INT64_C(0x0020000008080200), 0x1.00000040401p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f7fdff), -0x1.00000040401p+53, -0x1p+0 },
+{ INT64_C(0x0020000008080800), 0x1.00000040404p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f7f7ff), -0x1.00000040404p+53, -0x1p+0 },
+{ INT64_C(0x0020000008088000), 0x1.0000004044p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7f77fff), -0x1.0000004044p+53, -0x1p+0 },
+{ INT64_C(0x0020000008200000), 0x1.00000041p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7dfffff), -0x1.00000041p+53, -0x1p+0 },
+{ INT64_C(0x0020000008200002), 0x1.0000004100001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7dffffd), -0x1.0000004100002p+53, 0x1p+0 },
+{ INT64_C(0x0020000008200020), 0x1.000000410001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7dfffdf), -0x1.000000410001p+53, -0x1p+0 },
+{ INT64_C(0x0020000008200200), 0x1.00000041001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7dffdff), -0x1.00000041001p+53, -0x1p+0 },
+{ INT64_C(0x0020000008200400), 0x1.00000041002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7dffbff), -0x1.00000041002p+53, -0x1p+0 },
+{ INT64_C(0x0020000008204000), 0x1.0000004102p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7dfbfff), -0x1.0000004102p+53, -0x1p+0 },
+{ INT64_C(0x0020000008208000), 0x1.0000004104p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7df7fff), -0x1.0000004104p+53, -0x1p+0 },
+{ INT64_C(0x0020000008220000), 0x1.000000411p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7ddffff), -0x1.000000411p+53, -0x1p+0 },
+{ INT64_C(0x0020000008300000), 0x1.000000418p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff7cfffff), -0x1.000000418p+53, -0x1p+0 },
+{ INT64_C(0x0020000008800000), 0x1.00000044p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77fffff), -0x1.00000044p+53, -0x1p+0 },
+{ INT64_C(0x0020000008800008), 0x1.0000004400004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77ffff7), -0x1.0000004400004p+53, -0x1p+0 },
+{ INT64_C(0x0020000008800020), 0x1.000000440001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77fffdf), -0x1.000000440001p+53, -0x1p+0 },
+{ INT64_C(0x0020000008800100), 0x1.000000440008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77ffeff), -0x1.000000440008p+53, -0x1p+0 },
+{ INT64_C(0x0020000008801000), 0x1.00000044008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77fefff), -0x1.00000044008p+53, -0x1p+0 },
+{ INT64_C(0x0020000008804000), 0x1.0000004402p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77fbfff), -0x1.0000004402p+53, -0x1p+0 },
+{ INT64_C(0x0020000008820000), 0x1.000000441p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77dffff), -0x1.000000441p+53, -0x1p+0 },
+{ INT64_C(0x0020000008840000), 0x1.000000442p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff77bffff), -0x1.000000442p+53, -0x1p+0 },
+{ INT64_C(0x0020000008a00000), 0x1.00000045p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff75fffff), -0x1.00000045p+53, -0x1p+0 },
+{ INT64_C(0x0020000008c00000), 0x1.00000046p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff73fffff), -0x1.00000046p+53, -0x1p+0 },
+{ INT64_C(0x002000000a000000), 0x1.0000005p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5ffffff), -0x1.0000005p+53, -0x1p+0 },
+{ INT64_C(0x002000000a000001), 0x1.0000005p+53, 0x1p+0 },
+{ INT64_C(0xffdffffff5fffffe), -0x1.0000005000001p+53, 0x0p+0 },
+{ INT64_C(0x002000000a000002), 0x1.0000005000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5fffffd), -0x1.0000005000002p+53, 0x1p+0 },
+{ INT64_C(0x002000000a000008), 0x1.0000005000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5fffff7), -0x1.0000005000004p+53, -0x1p+0 },
+{ INT64_C(0x002000000a000080), 0x1.000000500004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5ffff7f), -0x1.000000500004p+53, -0x1p+0 },
+{ INT64_C(0x002000000a000800), 0x1.00000050004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5fff7ff), -0x1.00000050004p+53, -0x1p+0 },
+{ INT64_C(0x002000000a004000), 0x1.0000005002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5ffbfff), -0x1.0000005002p+53, -0x1p+0 },
+{ INT64_C(0x002000000a040000), 0x1.000000502p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5fbffff), -0x1.000000502p+53, -0x1p+0 },
+{ INT64_C(0x002000000a400000), 0x1.00000052p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff5bfffff), -0x1.00000052p+53, -0x1p+0 },
+{ INT64_C(0x002000000a800000), 0x1.00000054p+53, 0x0p+0 },
+{ INT64_C(0xffdffffff57fffff), -0x1.00000054p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000008), 0x1.0000010000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffff7), -0x1.0000010000004p+53, -0x1p+0 },
+{ INT64_C(0x002000002000000a), 0x1.0000010000005p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffff5), -0x1.0000010000006p+53, 0x1p+0 },
+{ INT64_C(0x0020000020000080), 0x1.000001000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffff7f), -0x1.000001000004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000084), 0x1.0000010000042p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffff7b), -0x1.0000010000042p+53, -0x1p+0 },
+{ INT64_C(0x00200000200000c0), 0x1.000001000006p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffff3f), -0x1.000001000006p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000200), 0x1.00000100001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffdff), -0x1.00000100001p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000204), 0x1.0000010000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffdfb), -0x1.0000010000102p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000208), 0x1.0000010000104p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffdf7), -0x1.0000010000104p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000240), 0x1.000001000012p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffdbf), -0x1.000001000012p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000400), 0x1.00000100002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffbff), -0x1.00000100002p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000402), 0x1.0000010000201p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffbfd), -0x1.0000010000202p+53, 0x1p+0 },
+{ INT64_C(0x0020000020000410), 0x1.0000010000208p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffbef), -0x1.0000010000208p+53, -0x1p+0 },
+{ INT64_C(0x0020000020000440), 0x1.000001000022p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffffbbf), -0x1.000001000022p+53, -0x1p+0 },
+{ INT64_C(0x0020000020004000), 0x1.0000010002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffbfff), -0x1.0000010002p+53, -0x1p+0 },
+{ INT64_C(0x0020000020004001), 0x1.0000010002p+53, 0x1p+0 },
+{ INT64_C(0xffdfffffdfffbffe), -0x1.0000010002001p+53, 0x0p+0 },
+{ INT64_C(0x0020000020004002), 0x1.0000010002001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffbffd), -0x1.0000010002002p+53, 0x1p+0 },
+{ INT64_C(0x0020000020004008), 0x1.0000010002004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffbff7), -0x1.0000010002004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020004040), 0x1.000001000202p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffbfbf), -0x1.000001000202p+53, -0x1p+0 },
+{ INT64_C(0x0020000020004400), 0x1.00000100022p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfffbbff), -0x1.00000100022p+53, -0x1p+0 },
+{ INT64_C(0x0020000020006000), 0x1.0000010003p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfff9fff), -0x1.0000010003p+53, -0x1p+0 },
+{ INT64_C(0x0020000020040000), 0x1.000001002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffbffff), -0x1.000001002p+53, -0x1p+0 },
+{ INT64_C(0x0020000020040001), 0x1.000001002p+53, 0x1p+0 },
+{ INT64_C(0xffdfffffdffbfffe), -0x1.0000010020001p+53, 0x0p+0 },
+{ INT64_C(0x0020000020040010), 0x1.0000010020008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffbffef), -0x1.0000010020008p+53, -0x1p+0 },
+{ INT64_C(0x0020000020040080), 0x1.000001002004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffbff7f), -0x1.000001002004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020040100), 0x1.000001002008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffbfeff), -0x1.000001002008p+53, -0x1p+0 },
+{ INT64_C(0x0020000020040800), 0x1.00000100204p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffbf7ff), -0x1.00000100204p+53, -0x1p+0 },
+{ INT64_C(0x0020000020048000), 0x1.0000010024p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffb7fff), -0x1.0000010024p+53, -0x1p+0 },
+{ INT64_C(0x0020000020050000), 0x1.0000010028p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdffaffff), -0x1.0000010028p+53, -0x1p+0 },
+{ INT64_C(0x0020000020400000), 0x1.00000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbfffff), -0x1.00000102p+53, -0x1p+0 },
+{ INT64_C(0x0020000020400002), 0x1.0000010200001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbffffd), -0x1.0000010200002p+53, 0x1p+0 },
+{ INT64_C(0x0020000020400020), 0x1.000001020001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbfffdf), -0x1.000001020001p+53, -0x1p+0 },
+{ INT64_C(0x0020000020400080), 0x1.000001020004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbfff7f), -0x1.000001020004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020400100), 0x1.000001020008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbffeff), -0x1.000001020008p+53, -0x1p+0 },
+{ INT64_C(0x0020000020400800), 0x1.00000102004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbff7ff), -0x1.00000102004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020402000), 0x1.0000010201p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbfdfff), -0x1.0000010201p+53, -0x1p+0 },
+{ INT64_C(0x0020000020410000), 0x1.0000010208p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfbeffff), -0x1.0000010208p+53, -0x1p+0 },
+{ INT64_C(0x0020000020500000), 0x1.000001028p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdfafffff), -0x1.000001028p+53, -0x1p+0 },
+{ INT64_C(0x0020000020800000), 0x1.00000104p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7fffff), -0x1.00000104p+53, -0x1p+0 },
+{ INT64_C(0x0020000020800004), 0x1.0000010400002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7ffffb), -0x1.0000010400002p+53, -0x1p+0 },
+{ INT64_C(0x0020000020800008), 0x1.0000010400004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7ffff7), -0x1.0000010400004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020800040), 0x1.000001040002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7fffbf), -0x1.000001040002p+53, -0x1p+0 },
+{ INT64_C(0x0020000020800400), 0x1.00000104002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7ffbff), -0x1.00000104002p+53, -0x1p+0 },
+{ INT64_C(0x0020000020800800), 0x1.00000104004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7ff7ff), -0x1.00000104004p+53, -0x1p+0 },
+{ INT64_C(0x0020000020801000), 0x1.00000104008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7fefff), -0x1.00000104008p+53, -0x1p+0 },
+{ INT64_C(0x0020000020808000), 0x1.0000010404p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7f7fff), -0x1.0000010404p+53, -0x1p+0 },
+{ INT64_C(0x0020000020820000), 0x1.000001041p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7dffff), -0x1.000001041p+53, -0x1p+0 },
+{ INT64_C(0x0020000020840000), 0x1.000001042p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf7bffff), -0x1.000001042p+53, -0x1p+0 },
+{ INT64_C(0x0020000020c00000), 0x1.00000106p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffdf3fffff), -0x1.00000106p+53, -0x1p+0 },
+{ INT64_C(0x0020000028000000), 0x1.0000014p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7ffffff), -0x1.0000014p+53, -0x1p+0 },
+{ INT64_C(0x0020000028000002), 0x1.0000014000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7fffffd), -0x1.0000014000002p+53, 0x1p+0 },
+{ INT64_C(0x0020000028000020), 0x1.000001400001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7ffffdf), -0x1.000001400001p+53, -0x1p+0 },
+{ INT64_C(0x0020000028000200), 0x1.00000140001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7fffdff), -0x1.00000140001p+53, -0x1p+0 },
+{ INT64_C(0x0020000028001000), 0x1.00000140008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7ffefff), -0x1.00000140008p+53, -0x1p+0 },
+{ INT64_C(0x0020000028008000), 0x1.0000014004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7ff7fff), -0x1.0000014004p+53, -0x1p+0 },
+{ INT64_C(0x0020000028010000), 0x1.0000014008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7feffff), -0x1.0000014008p+53, -0x1p+0 },
+{ INT64_C(0x0020000028100000), 0x1.000001408p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd7efffff), -0x1.000001408p+53, -0x1p+0 },
+{ INT64_C(0x0020000028800000), 0x1.00000144p+53, 0x0p+0 },
+{ INT64_C(0xffdfffffd77fffff), -0x1.00000144p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000004), 0x1.0000080000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffffb), -0x1.0000080000002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000008), 0x1.0000080000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffff7), -0x1.0000080000004p+53, -0x1p+0 },
+{ INT64_C(0x002000010000000c), 0x1.0000080000006p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffff3), -0x1.0000080000006p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000020), 0x1.000008000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffffdf), -0x1.000008000001p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000028), 0x1.0000080000014p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffffd7), -0x1.0000080000014p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000200), 0x1.00000800001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffdff), -0x1.00000800001p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000202), 0x1.0000080000101p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffdfd), -0x1.0000080000102p+53, 0x1p+0 },
+{ INT64_C(0x0020000100000210), 0x1.0000080000108p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffdef), -0x1.0000080000108p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000220), 0x1.000008000011p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffddf), -0x1.000008000011p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000280), 0x1.000008000014p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffd7f), -0x1.000008000014p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000400), 0x1.00000800002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffbff), -0x1.00000800002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000404), 0x1.0000080000202p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffbfb), -0x1.0000080000202p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000410), 0x1.0000080000208p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffbef), -0x1.0000080000208p+53, -0x1p+0 },
+{ INT64_C(0x0020000100000500), 0x1.000008000028p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffffaff), -0x1.000008000028p+53, -0x1p+0 },
+{ INT64_C(0x0020000100002000), 0x1.0000080001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffdfff), -0x1.0000080001p+53, -0x1p+0 },
+{ INT64_C(0x0020000100002004), 0x1.0000080001002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffdffb), -0x1.0000080001002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100002020), 0x1.000008000101p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffdfdf), -0x1.000008000101p+53, -0x1p+0 },
+{ INT64_C(0x0020000100002040), 0x1.000008000102p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffdfbf), -0x1.000008000102p+53, -0x1p+0 },
+{ INT64_C(0x0020000100002200), 0x1.00000800011p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffddff), -0x1.00000800011p+53, -0x1p+0 },
+{ INT64_C(0x0020000100003000), 0x1.00000800018p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeffffcfff), -0x1.00000800018p+53, -0x1p+0 },
+{ INT64_C(0x0020000100010000), 0x1.0000080008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffeffff), -0x1.0000080008p+53, -0x1p+0 },
+{ INT64_C(0x0020000100010001), 0x1.0000080008p+53, 0x1p+0 },
+{ INT64_C(0xffdffffefffefffe), -0x1.0000080008001p+53, 0x0p+0 },
+{ INT64_C(0x0020000100010008), 0x1.0000080008004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffefff7), -0x1.0000080008004p+53, -0x1p+0 },
+{ INT64_C(0x0020000100010010), 0x1.0000080008008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffeffef), -0x1.0000080008008p+53, -0x1p+0 },
+{ INT64_C(0x0020000100010020), 0x1.000008000801p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffeffdf), -0x1.000008000801p+53, -0x1p+0 },
+{ INT64_C(0x0020000100010200), 0x1.00000800081p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffefdff), -0x1.00000800081p+53, -0x1p+0 },
+{ INT64_C(0x0020000100012000), 0x1.0000080009p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffedfff), -0x1.0000080009p+53, -0x1p+0 },
+{ INT64_C(0x0020000100018000), 0x1.000008000cp+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffe7fff), -0x1.000008000cp+53, -0x1p+0 },
+{ INT64_C(0x0020000100040000), 0x1.000008002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbffff), -0x1.000008002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100040004), 0x1.0000080020002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbfffb), -0x1.0000080020002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100040040), 0x1.000008002002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbffbf), -0x1.000008002002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100040080), 0x1.000008002004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbff7f), -0x1.000008002004p+53, -0x1p+0 },
+{ INT64_C(0x0020000100040800), 0x1.00000800204p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbf7ff), -0x1.00000800204p+53, -0x1p+0 },
+{ INT64_C(0x0020000100041000), 0x1.00000800208p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbefff), -0x1.00000800208p+53, -0x1p+0 },
+{ INT64_C(0x0020000100044000), 0x1.0000080022p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefffbbfff), -0x1.0000080022p+53, -0x1p+0 },
+{ INT64_C(0x0020000100060000), 0x1.000008003p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff9ffff), -0x1.000008003p+53, -0x1p+0 },
+{ INT64_C(0x0020000100080000), 0x1.000008004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff7ffff), -0x1.000008004p+53, -0x1p+0 },
+{ INT64_C(0x0020000100080004), 0x1.0000080040002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff7fffb), -0x1.0000080040002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100080040), 0x1.000008004002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff7ffbf), -0x1.000008004002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100080100), 0x1.000008004008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff7feff), -0x1.000008004008p+53, -0x1p+0 },
+{ INT64_C(0x0020000100080200), 0x1.00000800401p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff7fdff), -0x1.00000800401p+53, -0x1p+0 },
+{ INT64_C(0x0020000100082000), 0x1.0000080041p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff7dfff), -0x1.0000080041p+53, -0x1p+0 },
+{ INT64_C(0x0020000100088000), 0x1.0000080044p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff77fff), -0x1.0000080044p+53, -0x1p+0 },
+{ INT64_C(0x00200001000c0000), 0x1.000008006p+53, 0x0p+0 },
+{ INT64_C(0xffdffffefff3ffff), -0x1.000008006p+53, -0x1p+0 },
+{ INT64_C(0x0020000100800000), 0x1.00000804p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7fffff), -0x1.00000804p+53, -0x1p+0 },
+{ INT64_C(0x0020000100800001), 0x1.00000804p+53, 0x1p+0 },
+{ INT64_C(0xffdffffeff7ffffe), -0x1.0000080400001p+53, 0x0p+0 },
+{ INT64_C(0x0020000100800002), 0x1.0000080400001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7ffffd), -0x1.0000080400002p+53, 0x1p+0 },
+{ INT64_C(0x0020000100800004), 0x1.0000080400002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7ffffb), -0x1.0000080400002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100800008), 0x1.0000080400004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7ffff7), -0x1.0000080400004p+53, -0x1p+0 },
+{ INT64_C(0x0020000100800080), 0x1.000008040004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7fff7f), -0x1.000008040004p+53, -0x1p+0 },
+{ INT64_C(0x0020000100800400), 0x1.00000804002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7ffbff), -0x1.00000804002p+53, -0x1p+0 },
+{ INT64_C(0x0020000100804000), 0x1.0000080402p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7fbfff), -0x1.0000080402p+53, -0x1p+0 },
+{ INT64_C(0x0020000100840000), 0x1.000008042p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff7bffff), -0x1.000008042p+53, -0x1p+0 },
+{ INT64_C(0x0020000100c00000), 0x1.00000806p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeff3fffff), -0x1.00000806p+53, -0x1p+0 },
+{ INT64_C(0x0020000108000000), 0x1.0000084p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7ffffff), -0x1.0000084p+53, -0x1p+0 },
+{ INT64_C(0x0020000108000002), 0x1.0000084000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7fffffd), -0x1.0000084000002p+53, 0x1p+0 },
+{ INT64_C(0x0020000108000010), 0x1.0000084000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7ffffef), -0x1.0000084000008p+53, -0x1p+0 },
+{ INT64_C(0x0020000108000100), 0x1.000008400008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7fffeff), -0x1.000008400008p+53, -0x1p+0 },
+{ INT64_C(0x0020000108001000), 0x1.00000840008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7ffefff), -0x1.00000840008p+53, -0x1p+0 },
+{ INT64_C(0x0020000108002000), 0x1.0000084001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7ffdfff), -0x1.0000084001p+53, -0x1p+0 },
+{ INT64_C(0x0020000108010000), 0x1.0000084008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7feffff), -0x1.0000084008p+53, -0x1p+0 },
+{ INT64_C(0x0020000108080000), 0x1.000008404p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef7f7ffff), -0x1.000008404p+53, -0x1p+0 },
+{ INT64_C(0x0020000108800000), 0x1.00000844p+53, 0x0p+0 },
+{ INT64_C(0xffdffffef77fffff), -0x1.00000844p+53, -0x1p+0 },
+{ INT64_C(0x0020000120000000), 0x1.000009p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedfffffff), -0x1.000009p+53, -0x1p+0 },
+{ INT64_C(0x0020000120000001), 0x1.000009p+53, 0x1p+0 },
+{ INT64_C(0xffdffffedffffffe), -0x1.0000090000001p+53, 0x0p+0 },
+{ INT64_C(0x0020000120000002), 0x1.0000090000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedffffffd), -0x1.0000090000002p+53, 0x1p+0 },
+{ INT64_C(0x0020000120000004), 0x1.0000090000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedffffffb), -0x1.0000090000002p+53, -0x1p+0 },
+{ INT64_C(0x0020000120000040), 0x1.000009000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedfffffbf), -0x1.000009000002p+53, -0x1p+0 },
+{ INT64_C(0x0020000120000100), 0x1.000009000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedffffeff), -0x1.000009000008p+53, -0x1p+0 },
+{ INT64_C(0x0020000120000400), 0x1.00000900002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedffffbff), -0x1.00000900002p+53, -0x1p+0 },
+{ INT64_C(0x0020000120004000), 0x1.0000090002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedfffbfff), -0x1.0000090002p+53, -0x1p+0 },
+{ INT64_C(0x0020000120040000), 0x1.000009002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedffbffff), -0x1.000009002p+53, -0x1p+0 },
+{ INT64_C(0x0020000120100000), 0x1.000009008p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedfefffff), -0x1.000009008p+53, -0x1p+0 },
+{ INT64_C(0x0020000120400000), 0x1.00000902p+53, 0x0p+0 },
+{ INT64_C(0xffdffffedfbfffff), -0x1.00000902p+53, -0x1p+0 },
+{ INT64_C(0x0020000122000000), 0x1.0000091p+53, 0x0p+0 },
+{ INT64_C(0xffdffffeddffffff), -0x1.0000091p+53, -0x1p+0 },
+{ INT64_C(0x0020000130000000), 0x1.0000098p+53, 0x0p+0 },
+{ INT64_C(0xffdffffecfffffff), -0x1.0000098p+53, -0x1p+0 },
+{ INT64_C(0x0020000140000000), 0x1.00000ap+53, 0x0p+0 },
+{ INT64_C(0xffdffffebfffffff), -0x1.00000ap+53, -0x1p+0 },
+{ INT64_C(0x0020000140000008), 0x1.00000a0000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebffffff7), -0x1.00000a0000004p+53, -0x1p+0 },
+{ INT64_C(0x0020000140000080), 0x1.00000a000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebfffff7f), -0x1.00000a000004p+53, -0x1p+0 },
+{ INT64_C(0x0020000140000800), 0x1.00000a00004p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebffff7ff), -0x1.00000a00004p+53, -0x1p+0 },
+{ INT64_C(0x0020000140004000), 0x1.00000a0002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebfffbfff), -0x1.00000a0002p+53, -0x1p+0 },
+{ INT64_C(0x0020000140040000), 0x1.00000a002p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebffbffff), -0x1.00000a002p+53, -0x1p+0 },
+{ INT64_C(0x0020000140400000), 0x1.00000a02p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebfbfffff), -0x1.00000a02p+53, -0x1p+0 },
+{ INT64_C(0x0020000142000000), 0x1.00000a1p+53, 0x0p+0 },
+{ INT64_C(0xffdffffebdffffff), -0x1.00000a1p+53, -0x1p+0 },
+{ INT64_C(0x0020000160000000), 0x1.00000bp+53, 0x0p+0 },
+{ INT64_C(0xffdffffe9fffffff), -0x1.00000bp+53, -0x1p+0 },
+{ INT64_C(0x0020001000000008), 0x1.0000800000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffffff7), -0x1.0000800000004p+53, -0x1p+0 },
+{ INT64_C(0x002000100000000a), 0x1.0000800000005p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffffff5), -0x1.0000800000006p+53, 0x1p+0 },
+{ INT64_C(0x0020001000000080), 0x1.000080000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffff7f), -0x1.000080000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000088), 0x1.0000800000044p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffff77), -0x1.0000800000044p+53, -0x1p+0 },
+{ INT64_C(0x00200010000000c0), 0x1.000080000006p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffff3f), -0x1.000080000006p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000800), 0x1.00008000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff7ff), -0x1.00008000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000802), 0x1.0000800000401p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff7fd), -0x1.0000800000402p+53, 0x1p+0 },
+{ INT64_C(0x0020001000000804), 0x1.0000800000402p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff7fb), -0x1.0000800000402p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000808), 0x1.0000800000404p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff7f7), -0x1.0000800000404p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000820), 0x1.000080000041p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff7df), -0x1.000080000041p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000900), 0x1.000080000048p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff6ff), -0x1.000080000048p+53, -0x1p+0 },
+{ INT64_C(0x0020001000000a00), 0x1.00008000005p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffff5ff), -0x1.00008000005p+53, -0x1p+0 },
+{ INT64_C(0x0020001000004000), 0x1.0000800002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffbfff), -0x1.0000800002p+53, -0x1p+0 },
+{ INT64_C(0x0020001000004008), 0x1.0000800002004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffbff7), -0x1.0000800002004p+53, -0x1p+0 },
+{ INT64_C(0x0020001000004010), 0x1.0000800002008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffbfef), -0x1.0000800002008p+53, -0x1p+0 },
+{ INT64_C(0x0020001000004100), 0x1.000080000208p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffbeff), -0x1.000080000208p+53, -0x1p+0 },
+{ INT64_C(0x0020001000005000), 0x1.00008000028p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffffafff), -0x1.00008000028p+53, -0x1p+0 },
+{ INT64_C(0x0020001000010000), 0x1.0000800008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffeffff), -0x1.0000800008p+53, -0x1p+0 },
+{ INT64_C(0x0020001000010004), 0x1.0000800008002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffefffb), -0x1.0000800008002p+53, -0x1p+0 },
+{ INT64_C(0x0020001000010040), 0x1.000080000802p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffeffbf), -0x1.000080000802p+53, -0x1p+0 },
+{ INT64_C(0x0020001000010100), 0x1.000080000808p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffefeff), -0x1.000080000808p+53, -0x1p+0 },
+{ INT64_C(0x0020001000011000), 0x1.00008000088p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffeefff), -0x1.00008000088p+53, -0x1p+0 },
+{ INT64_C(0x0020001000012000), 0x1.0000800009p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffffedfff), -0x1.0000800009p+53, -0x1p+0 },
+{ INT64_C(0x0020001000100000), 0x1.000080008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffefffff), -0x1.000080008p+53, -0x1p+0 },
+{ INT64_C(0x0020001000100001), 0x1.000080008p+53, 0x1p+0 },
+{ INT64_C(0xffdfffefffeffffe), -0x1.0000800080001p+53, 0x0p+0 },
+{ INT64_C(0x0020001000100010), 0x1.0000800080008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffefffef), -0x1.0000800080008p+53, -0x1p+0 },
+{ INT64_C(0x0020001000100040), 0x1.000080008002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffefffbf), -0x1.000080008002p+53, -0x1p+0 },
+{ INT64_C(0x0020001000100400), 0x1.00008000802p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffeffbff), -0x1.00008000802p+53, -0x1p+0 },
+{ INT64_C(0x0020001000101000), 0x1.00008000808p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffefefff), -0x1.00008000808p+53, -0x1p+0 },
+{ INT64_C(0x0020001000102000), 0x1.0000800081p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffefdfff), -0x1.0000800081p+53, -0x1p+0 },
+{ INT64_C(0x0020001000108000), 0x1.0000800084p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffef7fff), -0x1.0000800084p+53, -0x1p+0 },
+{ INT64_C(0x0020001000140000), 0x1.00008000ap+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffebffff), -0x1.00008000ap+53, -0x1p+0 },
+{ INT64_C(0x0020001000180000), 0x1.00008000cp+53, 0x0p+0 },
+{ INT64_C(0xffdfffefffe7ffff), -0x1.00008000cp+53, -0x1p+0 },
+{ INT64_C(0x0020001000800000), 0x1.00008004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7fffff), -0x1.00008004p+53, -0x1p+0 },
+{ INT64_C(0x0020001000800004), 0x1.0000800400002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7ffffb), -0x1.0000800400002p+53, -0x1p+0 },
+{ INT64_C(0x0020001000800040), 0x1.000080040002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7fffbf), -0x1.000080040002p+53, -0x1p+0 },
+{ INT64_C(0x0020001000800100), 0x1.000080040008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7ffeff), -0x1.000080040008p+53, -0x1p+0 },
+{ INT64_C(0x0020001000800800), 0x1.00008004004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7ff7ff), -0x1.00008004004p+53, -0x1p+0 },
+{ INT64_C(0x0020001000801000), 0x1.00008004008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7fefff), -0x1.00008004008p+53, -0x1p+0 },
+{ INT64_C(0x0020001000810000), 0x1.0000800408p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff7effff), -0x1.0000800408p+53, -0x1p+0 },
+{ INT64_C(0x0020001000880000), 0x1.000080044p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff77ffff), -0x1.000080044p+53, -0x1p+0 },
+{ INT64_C(0x0020001000c00000), 0x1.00008006p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefff3fffff), -0x1.00008006p+53, -0x1p+0 },
+{ INT64_C(0x0020001004000000), 0x1.0000802p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbffffff), -0x1.0000802p+53, -0x1p+0 },
+{ INT64_C(0x0020001004000004), 0x1.0000802000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbfffffb), -0x1.0000802000002p+53, -0x1p+0 },
+{ INT64_C(0x0020001004000040), 0x1.000080200002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbffffbf), -0x1.000080200002p+53, -0x1p+0 },
+{ INT64_C(0x0020001004000080), 0x1.000080200004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbffff7f), -0x1.000080200004p+53, -0x1p+0 },
+{ INT64_C(0x0020001004000400), 0x1.00008020002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbfffbff), -0x1.00008020002p+53, -0x1p+0 },
+{ INT64_C(0x0020001004002000), 0x1.0000802001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbffdfff), -0x1.0000802001p+53, -0x1p+0 },
+{ INT64_C(0x0020001004004000), 0x1.0000802002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbffbfff), -0x1.0000802002p+53, -0x1p+0 },
+{ INT64_C(0x0020001004020000), 0x1.000080201p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbfdffff), -0x1.000080201p+53, -0x1p+0 },
+{ INT64_C(0x0020001004100000), 0x1.000080208p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffbefffff), -0x1.000080208p+53, -0x1p+0 },
+{ INT64_C(0x0020001004800000), 0x1.00008024p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeffb7fffff), -0x1.00008024p+53, -0x1p+0 },
+{ INT64_C(0x0020001020000000), 0x1.000081p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdfffffff), -0x1.000081p+53, -0x1p+0 },
+{ INT64_C(0x0020001020000002), 0x1.0000810000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdffffffd), -0x1.0000810000002p+53, 0x1p+0 },
+{ INT64_C(0x0020001020000010), 0x1.0000810000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdfffffef), -0x1.0000810000008p+53, -0x1p+0 },
+{ INT64_C(0x0020001020000040), 0x1.000081000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdfffffbf), -0x1.000081000002p+53, -0x1p+0 },
+{ INT64_C(0x0020001020000100), 0x1.000081000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdffffeff), -0x1.000081000008p+53, -0x1p+0 },
+{ INT64_C(0x0020001020000200), 0x1.00008100001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdffffdff), -0x1.00008100001p+53, -0x1p+0 },
+{ INT64_C(0x0020001020000800), 0x1.00008100004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdffff7ff), -0x1.00008100004p+53, -0x1p+0 },
+{ INT64_C(0x0020001020008000), 0x1.0000810004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdfff7fff), -0x1.0000810004p+53, -0x1p+0 },
+{ INT64_C(0x0020001020080000), 0x1.000081004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdff7ffff), -0x1.000081004p+53, -0x1p+0 },
+{ INT64_C(0x0020001020200000), 0x1.00008101p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdfdfffff), -0x1.00008101p+53, -0x1p+0 },
+{ INT64_C(0x0020001020400000), 0x1.00008102p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefdfbfffff), -0x1.00008102p+53, -0x1p+0 },
+{ INT64_C(0x0020001022000000), 0x1.0000811p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefddffffff), -0x1.0000811p+53, -0x1p+0 },
+{ INT64_C(0x0020001030000000), 0x1.0000818p+53, 0x0p+0 },
+{ INT64_C(0xffdfffefcfffffff), -0x1.0000818p+53, -0x1p+0 },
+{ INT64_C(0x0020001100000000), 0x1.000088p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeeffffffff), -0x1.000088p+53, -0x1p+0 },
+{ INT64_C(0x0020001100000008), 0x1.0000880000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeefffffff7), -0x1.0000880000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001100000080), 0x1.000088000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeeffffff7f), -0x1.000088000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001100000800), 0x1.00008800004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeefffff7ff), -0x1.00008800004p+53, -0x1p+0 },
+{ INT64_C(0x0020001100008000), 0x1.0000880004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeeffff7fff), -0x1.0000880004p+53, -0x1p+0 },
+{ INT64_C(0x0020001100080000), 0x1.000088004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeefff7ffff), -0x1.000088004p+53, -0x1p+0 },
+{ INT64_C(0x0020001100400000), 0x1.00008802p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeeffbfffff), -0x1.00008802p+53, -0x1p+0 },
+{ INT64_C(0x0020001104000000), 0x1.0000882p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeefbffffff), -0x1.0000882p+53, -0x1p+0 },
+{ INT64_C(0x0020001140000000), 0x1.00008ap+53, 0x0p+0 },
+{ INT64_C(0xffdfffeebfffffff), -0x1.00008ap+53, -0x1p+0 },
+{ INT64_C(0x0020001180000000), 0x1.00008cp+53, 0x0p+0 },
+{ INT64_C(0xffdfffee7fffffff), -0x1.00008cp+53, -0x1p+0 },
+{ INT64_C(0x0020001200000000), 0x1.00009p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedffffffff), -0x1.00009p+53, -0x1p+0 },
+{ INT64_C(0x0020001200000008), 0x1.0000900000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedfffffff7), -0x1.0000900000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001200000080), 0x1.000090000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedffffff7f), -0x1.000090000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001200000800), 0x1.00009000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedfffff7ff), -0x1.00009000004p+53, -0x1p+0 },
+{ INT64_C(0x0020001200004000), 0x1.0000900002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedffffbfff), -0x1.0000900002p+53, -0x1p+0 },
+{ INT64_C(0x0020001200020000), 0x1.000090001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedfffdffff), -0x1.000090001p+53, -0x1p+0 },
+{ INT64_C(0x0020001200040000), 0x1.000090002p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedfffbffff), -0x1.000090002p+53, -0x1p+0 },
+{ INT64_C(0x0020001200200000), 0x1.00009001p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedffdfffff), -0x1.00009001p+53, -0x1p+0 },
+{ INT64_C(0x0020001202000000), 0x1.0000901p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedfdffffff), -0x1.0000901p+53, -0x1p+0 },
+{ INT64_C(0x0020001204000000), 0x1.0000902p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedfbffffff), -0x1.0000902p+53, -0x1p+0 },
+{ INT64_C(0x0020001220000000), 0x1.000091p+53, 0x0p+0 },
+{ INT64_C(0xffdfffeddfffffff), -0x1.000091p+53, -0x1p+0 },
+{ INT64_C(0x0020001240000000), 0x1.000092p+53, 0x0p+0 },
+{ INT64_C(0xffdfffedbfffffff), -0x1.000092p+53, -0x1p+0 },
+{ INT64_C(0x0020001280000000), 0x1.000094p+53, 0x0p+0 },
+{ INT64_C(0xffdfffed7fffffff), -0x1.000094p+53, -0x1p+0 },
+{ INT64_C(0x0020001300000000), 0x1.000098p+53, 0x0p+0 },
+{ INT64_C(0xffdfffecffffffff), -0x1.000098p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000001), 0x1.0008p+53, 0x1p+0 },
+{ INT64_C(0xffdffefffffffffe), -0x1.0008000000001p+53, 0x0p+0 },
+{ INT64_C(0x0020010000000004), 0x1.0008000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffffffb), -0x1.0008000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000006), 0x1.0008000000003p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffffff9), -0x1.0008000000004p+53, 0x1p+0 },
+{ INT64_C(0x0020010000000008), 0x1.0008000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffffff7), -0x1.0008000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000009), 0x1.0008000000004p+53, 0x1p+0 },
+{ INT64_C(0xffdffefffffffff6), -0x1.0008000000005p+53, 0x0p+0 },
+{ INT64_C(0x0020010000000010), 0x1.0008000000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffffef), -0x1.0008000000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000014), 0x1.000800000000ap+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffffeb), -0x1.000800000000ap+53, -0x1p+0 },
+{ INT64_C(0x0020010000000100), 0x1.000800000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffffeff), -0x1.000800000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000101), 0x1.000800000008p+53, 0x1p+0 },
+{ INT64_C(0xffdffefffffffefe), -0x1.0008000000081p+53, 0x0p+0 },
+{ INT64_C(0x0020010000000110), 0x1.0008000000088p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffffeef), -0x1.0008000000088p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000180), 0x1.00080000000cp+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffffe7f), -0x1.00080000000cp+53, -0x1p+0 },
+{ INT64_C(0x0020010000000800), 0x1.00080000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffff7ff), -0x1.00080000004p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000802), 0x1.0008000000401p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffff7fd), -0x1.0008000000402p+53, 0x1p+0 },
+{ INT64_C(0x0020010000000804), 0x1.0008000000402p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffff7fb), -0x1.0008000000402p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000840), 0x1.000800000042p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffff7bf), -0x1.000800000042p+53, -0x1p+0 },
+{ INT64_C(0x0020010000000a00), 0x1.00080000005p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffff5ff), -0x1.00080000005p+53, -0x1p+0 },
+{ INT64_C(0x0020010000001000), 0x1.00080000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffefff), -0x1.00080000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010000001002), 0x1.0008000000801p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffeffd), -0x1.0008000000802p+53, 0x1p+0 },
+{ INT64_C(0x0020010000001020), 0x1.000800000081p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffefdf), -0x1.000800000081p+53, -0x1p+0 },
+{ INT64_C(0x0020010000001200), 0x1.00080000009p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffedff), -0x1.00080000009p+53, -0x1p+0 },
+{ INT64_C(0x0020010000004000), 0x1.0008000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffbfff), -0x1.0008000002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000004008), 0x1.0008000002004p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffbff7), -0x1.0008000002004p+53, -0x1p+0 },
+{ INT64_C(0x0020010000004080), 0x1.000800000204p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffbf7f), -0x1.000800000204p+53, -0x1p+0 },
+{ INT64_C(0x0020010000004400), 0x1.00080000022p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffffbbff), -0x1.00080000022p+53, -0x1p+0 },
+{ INT64_C(0x0020010000006000), 0x1.0008000003p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffff9fff), -0x1.0008000003p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040000), 0x1.000800002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbffff), -0x1.000800002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040004), 0x1.0008000020002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbfffb), -0x1.0008000020002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040008), 0x1.0008000020004p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbfff7), -0x1.0008000020004p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040010), 0x1.0008000020008p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbffef), -0x1.0008000020008p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040040), 0x1.000800002002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbffbf), -0x1.000800002002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040100), 0x1.000800002008p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbfeff), -0x1.000800002008p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040200), 0x1.00080000201p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbfdff), -0x1.00080000201p+53, -0x1p+0 },
+{ INT64_C(0x0020010000040800), 0x1.00080000204p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbf7ff), -0x1.00080000204p+53, -0x1p+0 },
+{ INT64_C(0x0020010000044000), 0x1.0008000022p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffffbbfff), -0x1.0008000022p+53, -0x1p+0 },
+{ INT64_C(0x0020010000400000), 0x1.00080002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbfffff), -0x1.00080002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000400004), 0x1.0008000200002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbffffb), -0x1.0008000200002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000400020), 0x1.000800020001p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbfffdf), -0x1.000800020001p+53, -0x1p+0 },
+{ INT64_C(0x0020010000400100), 0x1.000800020008p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbffeff), -0x1.000800020008p+53, -0x1p+0 },
+{ INT64_C(0x0020010000400200), 0x1.00080002001p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbffdff), -0x1.00080002001p+53, -0x1p+0 },
+{ INT64_C(0x0020010000400400), 0x1.00080002002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbffbff), -0x1.00080002002p+53, -0x1p+0 },
+{ INT64_C(0x0020010000404000), 0x1.0008000202p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbfbfff), -0x1.0008000202p+53, -0x1p+0 },
+{ INT64_C(0x0020010000420000), 0x1.000800021p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbdffff), -0x1.000800021p+53, -0x1p+0 },
+{ INT64_C(0x0020010000440000), 0x1.000800022p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffbbffff), -0x1.000800022p+53, -0x1p+0 },
+{ INT64_C(0x0020010000480000), 0x1.000800024p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffffb7ffff), -0x1.000800024p+53, -0x1p+0 },
+{ INT64_C(0x0020010002000000), 0x1.0008001p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdffffff), -0x1.0008001p+53, -0x1p+0 },
+{ INT64_C(0x0020010002000008), 0x1.0008001000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdfffff7), -0x1.0008001000004p+53, -0x1p+0 },
+{ INT64_C(0x0020010002000040), 0x1.000800100002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdffffbf), -0x1.000800100002p+53, -0x1p+0 },
+{ INT64_C(0x0020010002000100), 0x1.000800100008p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdfffeff), -0x1.000800100008p+53, -0x1p+0 },
+{ INT64_C(0x0020010002000400), 0x1.00080010002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdfffbff), -0x1.00080010002p+53, -0x1p+0 },
+{ INT64_C(0x0020010002002000), 0x1.0008001001p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdffdfff), -0x1.0008001001p+53, -0x1p+0 },
+{ INT64_C(0x0020010002020000), 0x1.000800101p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdfdffff), -0x1.000800101p+53, -0x1p+0 },
+{ INT64_C(0x0020010002040000), 0x1.000800102p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdfbffff), -0x1.000800102p+53, -0x1p+0 },
+{ INT64_C(0x0020010002100000), 0x1.000800108p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffdefffff), -0x1.000800108p+53, -0x1p+0 },
+{ INT64_C(0x0020010003000000), 0x1.00080018p+53, 0x0p+0 },
+{ INT64_C(0xffdffefffcffffff), -0x1.00080018p+53, -0x1p+0 },
+{ INT64_C(0x0020010020000000), 0x1.000801p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdfffffff), -0x1.000801p+53, -0x1p+0 },
+{ INT64_C(0x0020010020000002), 0x1.0008010000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdffffffd), -0x1.0008010000002p+53, 0x1p+0 },
+{ INT64_C(0x0020010020000008), 0x1.0008010000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdffffff7), -0x1.0008010000004p+53, -0x1p+0 },
+{ INT64_C(0x0020010020000010), 0x1.0008010000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdfffffef), -0x1.0008010000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010020000040), 0x1.000801000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdfffffbf), -0x1.000801000002p+53, -0x1p+0 },
+{ INT64_C(0x0020010020000400), 0x1.00080100002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdffffbff), -0x1.00080100002p+53, -0x1p+0 },
+{ INT64_C(0x0020010020004000), 0x1.0008010002p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdfffbfff), -0x1.0008010002p+53, -0x1p+0 },
+{ INT64_C(0x0020010020010000), 0x1.0008010008p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdffeffff), -0x1.0008010008p+53, -0x1p+0 },
+{ INT64_C(0x0020010020020000), 0x1.000801001p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdffdffff), -0x1.000801001p+53, -0x1p+0 },
+{ INT64_C(0x0020010020200000), 0x1.00080101p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdfdfffff), -0x1.00080101p+53, -0x1p+0 },
+{ INT64_C(0x0020010020800000), 0x1.00080104p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffdf7fffff), -0x1.00080104p+53, -0x1p+0 },
+{ INT64_C(0x0020010028000000), 0x1.0008014p+53, 0x0p+0 },
+{ INT64_C(0xffdffeffd7ffffff), -0x1.0008014p+53, -0x1p+0 },
+{ INT64_C(0x0020010100000000), 0x1.000808p+53, 0x0p+0 },
+{ INT64_C(0xffdffefeffffffff), -0x1.000808p+53, -0x1p+0 },
+{ INT64_C(0x0020010100000002), 0x1.0008080000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefffffffd), -0x1.0008080000002p+53, 0x1p+0 },
+{ INT64_C(0x0020010100000010), 0x1.0008080000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffefeffffffef), -0x1.0008080000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010100000020), 0x1.000808000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffefeffffffdf), -0x1.000808000001p+53, -0x1p+0 },
+{ INT64_C(0x0020010100000100), 0x1.000808000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefffffeff), -0x1.000808000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010100000200), 0x1.00080800001p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefffffdff), -0x1.00080800001p+53, -0x1p+0 },
+{ INT64_C(0x0020010100000800), 0x1.00080800004p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefffff7ff), -0x1.00080800004p+53, -0x1p+0 },
+{ INT64_C(0x0020010100008000), 0x1.0008080004p+53, 0x0p+0 },
+{ INT64_C(0xffdffefeffff7fff), -0x1.0008080004p+53, -0x1p+0 },
+{ INT64_C(0x0020010100020000), 0x1.000808001p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefffdffff), -0x1.000808001p+53, -0x1p+0 },
+{ INT64_C(0x0020010100040000), 0x1.000808002p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefffbffff), -0x1.000808002p+53, -0x1p+0 },
+{ INT64_C(0x0020010100200000), 0x1.00080801p+53, 0x0p+0 },
+{ INT64_C(0xffdffefeffdfffff), -0x1.00080801p+53, -0x1p+0 },
+{ INT64_C(0x0020010101000000), 0x1.00080808p+53, 0x0p+0 },
+{ INT64_C(0xffdffefefeffffff), -0x1.00080808p+53, -0x1p+0 },
+{ INT64_C(0x0020010108000000), 0x1.0008084p+53, 0x0p+0 },
+{ INT64_C(0xffdffefef7ffffff), -0x1.0008084p+53, -0x1p+0 },
+{ INT64_C(0x0020010180000000), 0x1.00080cp+53, 0x0p+0 },
+{ INT64_C(0xffdffefe7fffffff), -0x1.00080cp+53, -0x1p+0 },
+{ INT64_C(0x0020010800000000), 0x1.00084p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7ffffffff), -0x1.00084p+53, -0x1p+0 },
+{ INT64_C(0x0020010800000001), 0x1.00084p+53, 0x1p+0 },
+{ INT64_C(0xffdffef7fffffffe), -0x1.0008400000001p+53, 0x0p+0 },
+{ INT64_C(0x0020010800000010), 0x1.0008400000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7ffffffef), -0x1.0008400000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010800000100), 0x1.000840000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7fffffeff), -0x1.000840000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010800001000), 0x1.00084000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7ffffefff), -0x1.00084000008p+53, -0x1p+0 },
+{ INT64_C(0x0020010800008000), 0x1.0008400004p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7ffff7fff), -0x1.0008400004p+53, -0x1p+0 },
+{ INT64_C(0x0020010800010000), 0x1.0008400008p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7fffeffff), -0x1.0008400008p+53, -0x1p+0 },
+{ INT64_C(0x0020010800020000), 0x1.000840001p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7fffdffff), -0x1.000840001p+53, -0x1p+0 },
+{ INT64_C(0x0020010800080000), 0x1.000840004p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7fff7ffff), -0x1.000840004p+53, -0x1p+0 },
+{ INT64_C(0x0020010800800000), 0x1.00084004p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7ff7fffff), -0x1.00084004p+53, -0x1p+0 },
+{ INT64_C(0x0020010804000000), 0x1.0008402p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7fbffffff), -0x1.0008402p+53, -0x1p+0 },
+{ INT64_C(0x0020010840000000), 0x1.000842p+53, 0x0p+0 },
+{ INT64_C(0xffdffef7bfffffff), -0x1.000842p+53, -0x1p+0 },
+{ INT64_C(0x0020010880000000), 0x1.000844p+53, 0x0p+0 },
+{ INT64_C(0xffdffef77fffffff), -0x1.000844p+53, -0x1p+0 },
+{ INT64_C(0x0020010900000000), 0x1.000848p+53, 0x0p+0 },
+{ INT64_C(0xffdffef6ffffffff), -0x1.000848p+53, -0x1p+0 },
+{ INT64_C(0x0020012000000000), 0x1.0009p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfffffffff), -0x1.0009p+53, -0x1p+0 },
+{ INT64_C(0x0020012000000004), 0x1.0009000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdffedffffffffb), -0x1.0009000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020012000000008), 0x1.0009000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffedffffffff7), -0x1.0009000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020012000000080), 0x1.000900000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfffffff7f), -0x1.000900000004p+53, -0x1p+0 },
+{ INT64_C(0x0020012000000100), 0x1.000900000008p+53, 0x0p+0 },
+{ INT64_C(0xffdffedffffffeff), -0x1.000900000008p+53, -0x1p+0 },
+{ INT64_C(0x0020012000000800), 0x1.00090000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffedffffff7ff), -0x1.00090000004p+53, -0x1p+0 },
+{ INT64_C(0x0020012000002000), 0x1.0009000001p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfffffdfff), -0x1.0009000001p+53, -0x1p+0 },
+{ INT64_C(0x0020012000008000), 0x1.0009000004p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfffff7fff), -0x1.0009000004p+53, -0x1p+0 },
+{ INT64_C(0x0020012000080000), 0x1.000900004p+53, 0x0p+0 },
+{ INT64_C(0xffdffedffff7ffff), -0x1.000900004p+53, -0x1p+0 },
+{ INT64_C(0x0020012000100000), 0x1.000900008p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfffefffff), -0x1.000900008p+53, -0x1p+0 },
+{ INT64_C(0x0020012000400000), 0x1.00090002p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfffbfffff), -0x1.00090002p+53, -0x1p+0 },
+{ INT64_C(0x0020012002000000), 0x1.0009001p+53, 0x0p+0 },
+{ INT64_C(0xffdffedffdffffff), -0x1.0009001p+53, -0x1p+0 },
+{ INT64_C(0x0020012010000000), 0x1.0009008p+53, 0x0p+0 },
+{ INT64_C(0xffdffedfefffffff), -0x1.0009008p+53, -0x1p+0 },
+{ INT64_C(0x0020012100000000), 0x1.000908p+53, 0x0p+0 },
+{ INT64_C(0xffdffedeffffffff), -0x1.000908p+53, -0x1p+0 },
+{ INT64_C(0x0020012200000000), 0x1.00091p+53, 0x0p+0 },
+{ INT64_C(0xffdffeddffffffff), -0x1.00091p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000008), 0x1.0080000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffff7), -0x1.0080000000004p+53, -0x1p+0 },
+{ INT64_C(0x002010000000000a), 0x1.0080000000005p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffff5), -0x1.0080000000006p+53, 0x1p+0 },
+{ INT64_C(0x0020100000000020), 0x1.008000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffffdf), -0x1.008000000001p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000028), 0x1.0080000000014p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffffd7), -0x1.0080000000014p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000200), 0x1.00800000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffdff), -0x1.00800000001p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000204), 0x1.0080000000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffdfb), -0x1.0080000000102p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000210), 0x1.0080000000108p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffdef), -0x1.0080000000108p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000240), 0x1.008000000012p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffdbf), -0x1.008000000012p+53, -0x1p+0 },
+{ INT64_C(0x0020100000000280), 0x1.008000000014p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffffd7f), -0x1.008000000014p+53, -0x1p+0 },
+{ INT64_C(0x0020100000001000), 0x1.00800000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffefff), -0x1.00800000008p+53, -0x1p+0 },
+{ INT64_C(0x0020100000001004), 0x1.0080000000802p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffeffb), -0x1.0080000000802p+53, -0x1p+0 },
+{ INT64_C(0x0020100000001020), 0x1.008000000081p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffefdf), -0x1.008000000081p+53, -0x1p+0 },
+{ INT64_C(0x0020100000001200), 0x1.00800000009p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffedff), -0x1.00800000009p+53, -0x1p+0 },
+{ INT64_C(0x0020100000001800), 0x1.0080000000cp+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffffe7ff), -0x1.0080000000cp+53, -0x1p+0 },
+{ INT64_C(0x0020100000008000), 0x1.0080000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffff7fff), -0x1.0080000004p+53, -0x1p+0 },
+{ INT64_C(0x0020100000008008), 0x1.0080000004004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffff7ff7), -0x1.0080000004004p+53, -0x1p+0 },
+{ INT64_C(0x0020100000008040), 0x1.008000000402p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffff7fbf), -0x1.008000000402p+53, -0x1p+0 },
+{ INT64_C(0x0020100000008080), 0x1.008000000404p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffff7f7f), -0x1.008000000404p+53, -0x1p+0 },
+{ INT64_C(0x0020100000008100), 0x1.008000000408p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffff7eff), -0x1.008000000408p+53, -0x1p+0 },
+{ INT64_C(0x0020100000009000), 0x1.00800000048p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffff6fff), -0x1.00800000048p+53, -0x1p+0 },
+{ INT64_C(0x0020100000020000), 0x1.008000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffdffff), -0x1.008000001p+53, -0x1p+0 },
+{ INT64_C(0x0020100000020002), 0x1.0080000010001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffdfffd), -0x1.0080000010002p+53, 0x1p+0 },
+{ INT64_C(0x0020100000020020), 0x1.008000001001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffdffdf), -0x1.008000001001p+53, -0x1p+0 },
+{ INT64_C(0x0020100000020200), 0x1.00800000101p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffdfdff), -0x1.00800000101p+53, -0x1p+0 },
+{ INT64_C(0x0020100000020400), 0x1.00800000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffdfbff), -0x1.00800000102p+53, -0x1p+0 },
+{ INT64_C(0x0020100000022000), 0x1.0080000011p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffddfff), -0x1.0080000011p+53, -0x1p+0 },
+{ INT64_C(0x0020100000030000), 0x1.0080000018p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffffcffff), -0x1.0080000018p+53, -0x1p+0 },
+{ INT64_C(0x0020100000080000), 0x1.008000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff7ffff), -0x1.008000004p+53, -0x1p+0 },
+{ INT64_C(0x0020100000080001), 0x1.008000004p+53, 0x1p+0 },
+{ INT64_C(0xffdfeffffff7fffe), -0x1.0080000040001p+53, 0x0p+0 },
+{ INT64_C(0x0020100000080004), 0x1.0080000040002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff7fffb), -0x1.0080000040002p+53, -0x1p+0 },
+{ INT64_C(0x0020100000080040), 0x1.008000004002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff7ffbf), -0x1.008000004002p+53, -0x1p+0 },
+{ INT64_C(0x0020100000080200), 0x1.00800000401p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff7fdff), -0x1.00800000401p+53, -0x1p+0 },
+{ INT64_C(0x0020100000080800), 0x1.00800000404p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff7f7ff), -0x1.00800000404p+53, -0x1p+0 },
+{ INT64_C(0x0020100000084000), 0x1.0080000042p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff7bfff), -0x1.0080000042p+53, -0x1p+0 },
+{ INT64_C(0x00201000000c0000), 0x1.008000006p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffff3ffff), -0x1.008000006p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400000), 0x1.00800002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbfffff), -0x1.00800002p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400004), 0x1.0080000200002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbffffb), -0x1.0080000200002p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400008), 0x1.0080000200004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbffff7), -0x1.0080000200004p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400080), 0x1.008000020004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbfff7f), -0x1.008000020004p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400200), 0x1.00800002001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbffdff), -0x1.00800002001p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400400), 0x1.00800002002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbffbff), -0x1.00800002002p+53, -0x1p+0 },
+{ INT64_C(0x0020100000400800), 0x1.00800002004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbff7ff), -0x1.00800002004p+53, -0x1p+0 },
+{ INT64_C(0x0020100000404000), 0x1.0080000202p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbfbfff), -0x1.0080000202p+53, -0x1p+0 },
+{ INT64_C(0x0020100000408000), 0x1.0080000204p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbf7fff), -0x1.0080000204p+53, -0x1p+0 },
+{ INT64_C(0x0020100000420000), 0x1.008000021p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffbdffff), -0x1.008000021p+53, -0x1p+0 },
+{ INT64_C(0x0020100000500000), 0x1.008000028p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffffafffff), -0x1.008000028p+53, -0x1p+0 },
+{ INT64_C(0x0020100000600000), 0x1.00800003p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffff9fffff), -0x1.00800003p+53, -0x1p+0 },
+{ INT64_C(0x0020100001000000), 0x1.00800008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffeffffff), -0x1.00800008p+53, -0x1p+0 },
+{ INT64_C(0x0020100001000002), 0x1.0080000800001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffefffffd), -0x1.0080000800002p+53, 0x1p+0 },
+{ INT64_C(0x0020100001000004), 0x1.0080000800002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffefffffb), -0x1.0080000800002p+53, -0x1p+0 },
+{ INT64_C(0x0020100001000020), 0x1.008000080001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffeffffdf), -0x1.008000080001p+53, -0x1p+0 },
+{ INT64_C(0x0020100001000040), 0x1.008000080002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffeffffbf), -0x1.008000080002p+53, -0x1p+0 },
+{ INT64_C(0x0020100001000200), 0x1.00800008001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffefffdff), -0x1.00800008001p+53, -0x1p+0 },
+{ INT64_C(0x0020100001000400), 0x1.00800008002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffefffbff), -0x1.00800008002p+53, -0x1p+0 },
+{ INT64_C(0x0020100001002000), 0x1.0080000801p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffeffdfff), -0x1.0080000801p+53, -0x1p+0 },
+{ INT64_C(0x0020100001004000), 0x1.0080000802p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffeffbfff), -0x1.0080000802p+53, -0x1p+0 },
+{ INT64_C(0x0020100001020000), 0x1.008000081p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffefdffff), -0x1.008000081p+53, -0x1p+0 },
+{ INT64_C(0x0020100001200000), 0x1.00800009p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffedfffff), -0x1.00800009p+53, -0x1p+0 },
+{ INT64_C(0x0020100001800000), 0x1.0080000cp+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffe7fffff), -0x1.0080000cp+53, -0x1p+0 },
+{ INT64_C(0x0020100004000000), 0x1.0080002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbffffff), -0x1.0080002p+53, -0x1p+0 },
+{ INT64_C(0x0020100004000002), 0x1.0080002000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbfffffd), -0x1.0080002000002p+53, 0x1p+0 },
+{ INT64_C(0x0020100004000008), 0x1.0080002000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbfffff7), -0x1.0080002000004p+53, -0x1p+0 },
+{ INT64_C(0x0020100004000020), 0x1.008000200001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbffffdf), -0x1.008000200001p+53, -0x1p+0 },
+{ INT64_C(0x0020100004000100), 0x1.008000200008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbfffeff), -0x1.008000200008p+53, -0x1p+0 },
+{ INT64_C(0x0020100004001000), 0x1.00800020008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbffefff), -0x1.00800020008p+53, -0x1p+0 },
+{ INT64_C(0x0020100004010000), 0x1.0080002008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbfeffff), -0x1.0080002008p+53, -0x1p+0 },
+{ INT64_C(0x0020100004020000), 0x1.008000201p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbfdffff), -0x1.008000201p+53, -0x1p+0 },
+{ INT64_C(0x0020100004080000), 0x1.008000204p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbf7ffff), -0x1.008000204p+53, -0x1p+0 },
+{ INT64_C(0x0020100004100000), 0x1.008000208p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffbefffff), -0x1.008000208p+53, -0x1p+0 },
+{ INT64_C(0x0020100004800000), 0x1.00800024p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffffb7fffff), -0x1.00800024p+53, -0x1p+0 },
+{ INT64_C(0x0020100040000000), 0x1.008002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfffffff), -0x1.008002p+53, -0x1p+0 },
+{ INT64_C(0x0020100040000001), 0x1.008002p+53, 0x1p+0 },
+{ INT64_C(0xffdfefffbffffffe), -0x1.0080020000001p+53, 0x0p+0 },
+{ INT64_C(0x0020100040000010), 0x1.0080020000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfffffef), -0x1.0080020000008p+53, -0x1p+0 },
+{ INT64_C(0x0020100040000040), 0x1.008002000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfffffbf), -0x1.008002000002p+53, -0x1p+0 },
+{ INT64_C(0x0020100040000100), 0x1.008002000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbffffeff), -0x1.008002000008p+53, -0x1p+0 },
+{ INT64_C(0x0020100040000800), 0x1.00800200004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbffff7ff), -0x1.00800200004p+53, -0x1p+0 },
+{ INT64_C(0x0020100040002000), 0x1.0080020001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfffdfff), -0x1.0080020001p+53, -0x1p+0 },
+{ INT64_C(0x0020100040004000), 0x1.0080020002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfffbfff), -0x1.0080020002p+53, -0x1p+0 },
+{ INT64_C(0x0020100040008000), 0x1.0080020004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfff7fff), -0x1.0080020004p+53, -0x1p+0 },
+{ INT64_C(0x0020100040040000), 0x1.008002002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbffbffff), -0x1.008002002p+53, -0x1p+0 },
+{ INT64_C(0x0020100040200000), 0x1.00800201p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfdfffff), -0x1.00800201p+53, -0x1p+0 },
+{ INT64_C(0x0020100040400000), 0x1.00800202p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbfbfffff), -0x1.00800202p+53, -0x1p+0 },
+{ INT64_C(0x0020100042000000), 0x1.0080021p+53, 0x0p+0 },
+{ INT64_C(0xffdfefffbdffffff), -0x1.0080021p+53, -0x1p+0 },
+{ INT64_C(0x0020100060000000), 0x1.008003p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff9fffffff), -0x1.008003p+53, -0x1p+0 },
+{ INT64_C(0x0020100080000000), 0x1.008004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7fffffff), -0x1.008004p+53, -0x1p+0 },
+{ INT64_C(0x0020100080000002), 0x1.0080040000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7ffffffd), -0x1.0080040000002p+53, 0x1p+0 },
+{ INT64_C(0x0020100080000020), 0x1.008004000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7fffffdf), -0x1.008004000001p+53, -0x1p+0 },
+{ INT64_C(0x0020100080000100), 0x1.008004000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7ffffeff), -0x1.008004000008p+53, -0x1p+0 },
+{ INT64_C(0x0020100080000200), 0x1.00800400001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7ffffdff), -0x1.00800400001p+53, -0x1p+0 },
+{ INT64_C(0x0020100080000400), 0x1.00800400002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7ffffbff), -0x1.00800400002p+53, -0x1p+0 },
+{ INT64_C(0x0020100080004000), 0x1.0080040002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7fffbfff), -0x1.0080040002p+53, -0x1p+0 },
+{ INT64_C(0x0020100080020000), 0x1.008004001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7ffdffff), -0x1.008004001p+53, -0x1p+0 },
+{ INT64_C(0x0020100080080000), 0x1.008004004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7ff7ffff), -0x1.008004004p+53, -0x1p+0 },
+{ INT64_C(0x0020100080400000), 0x1.00800402p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7fbfffff), -0x1.00800402p+53, -0x1p+0 },
+{ INT64_C(0x0020100082000000), 0x1.0080041p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff7dffffff), -0x1.0080041p+53, -0x1p+0 },
+{ INT64_C(0x00201000a0000000), 0x1.008005p+53, 0x0p+0 },
+{ INT64_C(0xffdfefff5fffffff), -0x1.008005p+53, -0x1p+0 },
+{ INT64_C(0x0020100100000000), 0x1.008008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffeffffffff), -0x1.008008p+53, -0x1p+0 },
+{ INT64_C(0x0020100100000004), 0x1.0080080000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffefffffffb), -0x1.0080080000002p+53, -0x1p+0 },
+{ INT64_C(0x0020100100000040), 0x1.008008000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffeffffffbf), -0x1.008008000002p+53, -0x1p+0 },
+{ INT64_C(0x0020100100000100), 0x1.008008000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffefffffeff), -0x1.008008000008p+53, -0x1p+0 },
+{ INT64_C(0x0020100100001000), 0x1.00800800008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffeffffefff), -0x1.00800800008p+53, -0x1p+0 },
+{ INT64_C(0x0020100100004000), 0x1.0080080002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffeffffbfff), -0x1.0080080002p+53, -0x1p+0 },
+{ INT64_C(0x0020100100040000), 0x1.008008002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffefffbffff), -0x1.008008002p+53, -0x1p+0 },
+{ INT64_C(0x0020100100400000), 0x1.00800802p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffeffbfffff), -0x1.00800802p+53, -0x1p+0 },
+{ INT64_C(0x0020100104000000), 0x1.0080082p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffefbffffff), -0x1.0080082p+53, -0x1p+0 },
+{ INT64_C(0x0020100110000000), 0x1.0080088p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffeefffffff), -0x1.0080088p+53, -0x1p+0 },
+{ INT64_C(0x0020100400000000), 0x1.00802p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbffffffff), -0x1.00802p+53, -0x1p+0 },
+{ INT64_C(0x0020100400000008), 0x1.0080200000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbfffffff7), -0x1.0080200000004p+53, -0x1p+0 },
+{ INT64_C(0x0020100400000040), 0x1.008020000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbffffffbf), -0x1.008020000002p+53, -0x1p+0 },
+{ INT64_C(0x0020100400000200), 0x1.00802000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbfffffdff), -0x1.00802000001p+53, -0x1p+0 },
+{ INT64_C(0x0020100400001000), 0x1.00802000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbffffefff), -0x1.00802000008p+53, -0x1p+0 },
+{ INT64_C(0x0020100400002000), 0x1.0080200001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbffffdfff), -0x1.0080200001p+53, -0x1p+0 },
+{ INT64_C(0x0020100400008000), 0x1.0080200004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbffff7fff), -0x1.0080200004p+53, -0x1p+0 },
+{ INT64_C(0x0020100400020000), 0x1.008020001p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbfffdffff), -0x1.008020001p+53, -0x1p+0 },
+{ INT64_C(0x0020100400040000), 0x1.008020002p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbfffbffff), -0x1.008020002p+53, -0x1p+0 },
+{ INT64_C(0x0020100400080000), 0x1.008020004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbfff7ffff), -0x1.008020004p+53, -0x1p+0 },
+{ INT64_C(0x0020100400800000), 0x1.00802004p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbff7fffff), -0x1.00802004p+53, -0x1p+0 },
+{ INT64_C(0x0020100401000000), 0x1.00802008p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbfeffffff), -0x1.00802008p+53, -0x1p+0 },
+{ INT64_C(0x0020100410000000), 0x1.0080208p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbefffffff), -0x1.0080208p+53, -0x1p+0 },
+{ INT64_C(0x0020100420000000), 0x1.008021p+53, 0x0p+0 },
+{ INT64_C(0xffdfeffbdfffffff), -0x1.008021p+53, -0x1p+0 },
+{ INT64_C(0x0020100600000000), 0x1.00803p+53, 0x0p+0 },
+{ INT64_C(0xffdfeff9ffffffff), -0x1.00803p+53, -0x1p+0 },
+{ INT64_C(0x0020102000000000), 0x1.0081p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfffffffff), -0x1.0081p+53, -0x1p+0 },
+{ INT64_C(0x0020102000000004), 0x1.0081000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffffffffb), -0x1.0081000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020102000000008), 0x1.0081000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffffffff7), -0x1.0081000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020102000000020), 0x1.008100000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfffffffdf), -0x1.008100000001p+53, -0x1p+0 },
+{ INT64_C(0x0020102000000080), 0x1.008100000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfffffff7f), -0x1.008100000004p+53, -0x1p+0 },
+{ INT64_C(0x0020102000000800), 0x1.00810000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffffff7ff), -0x1.00810000004p+53, -0x1p+0 },
+{ INT64_C(0x0020102000002000), 0x1.0081000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfffffdfff), -0x1.0081000001p+53, -0x1p+0 },
+{ INT64_C(0x0020102000004000), 0x1.0081000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfffffbfff), -0x1.0081000002p+53, -0x1p+0 },
+{ INT64_C(0x0020102000010000), 0x1.0081000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffffeffff), -0x1.0081000008p+53, -0x1p+0 },
+{ INT64_C(0x0020102000020000), 0x1.008100001p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffffdffff), -0x1.008100001p+53, -0x1p+0 },
+{ INT64_C(0x0020102000040000), 0x1.008100002p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffffbffff), -0x1.008100002p+53, -0x1p+0 },
+{ INT64_C(0x0020102000080000), 0x1.008100004p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffff7ffff), -0x1.008100004p+53, -0x1p+0 },
+{ INT64_C(0x0020102000100000), 0x1.008100008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfffefffff), -0x1.008100008p+53, -0x1p+0 },
+{ INT64_C(0x0020102001000000), 0x1.00810008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdffeffffff), -0x1.00810008p+53, -0x1p+0 },
+{ INT64_C(0x0020102010000000), 0x1.0081008p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfefffffff), -0x1.0081008p+53, -0x1p+0 },
+{ INT64_C(0x0020102020000000), 0x1.008101p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdfdfffffff), -0x1.008101p+53, -0x1p+0 },
+{ INT64_C(0x0020102080000000), 0x1.008104p+53, 0x0p+0 },
+{ INT64_C(0xffdfefdf7fffffff), -0x1.008104p+53, -0x1p+0 },
+{ INT64_C(0x0020102800000000), 0x1.00814p+53, 0x0p+0 },
+{ INT64_C(0xffdfefd7ffffffff), -0x1.00814p+53, -0x1p+0 },
+{ INT64_C(0x0020108000000000), 0x1.0084p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fffffffff), -0x1.0084p+53, -0x1p+0 },
+{ INT64_C(0x0020108000000002), 0x1.0084000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7ffffffffd), -0x1.0084000000002p+53, 0x1p+0 },
+{ INT64_C(0x0020108000000004), 0x1.0084000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7ffffffffb), -0x1.0084000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020108000000020), 0x1.008400000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fffffffdf), -0x1.008400000001p+53, -0x1p+0 },
+{ INT64_C(0x0020108000000200), 0x1.00840000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7ffffffdff), -0x1.00840000001p+53, -0x1p+0 },
+{ INT64_C(0x0020108000002000), 0x1.0084000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fffffdfff), -0x1.0084000001p+53, -0x1p+0 },
+{ INT64_C(0x0020108000004000), 0x1.0084000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fffffbfff), -0x1.0084000002p+53, -0x1p+0 },
+{ INT64_C(0x0020108000020000), 0x1.008400001p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7ffffdffff), -0x1.008400001p+53, -0x1p+0 },
+{ INT64_C(0x0020108000040000), 0x1.008400002p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7ffffbffff), -0x1.008400002p+53, -0x1p+0 },
+{ INT64_C(0x0020108000400000), 0x1.00840002p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fffbfffff), -0x1.00840002p+53, -0x1p+0 },
+{ INT64_C(0x0020108004000000), 0x1.0084002p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7ffbffffff), -0x1.0084002p+53, -0x1p+0 },
+{ INT64_C(0x0020108020000000), 0x1.008401p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fdfffffff), -0x1.008401p+53, -0x1p+0 },
+{ INT64_C(0x0020108040000000), 0x1.008402p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7fbfffffff), -0x1.008402p+53, -0x1p+0 },
+{ INT64_C(0x0020108080000000), 0x1.008404p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7f7fffffff), -0x1.008404p+53, -0x1p+0 },
+{ INT64_C(0x0020108100000000), 0x1.008408p+53, 0x0p+0 },
+{ INT64_C(0xffdfef7effffffff), -0x1.008408p+53, -0x1p+0 },
+{ INT64_C(0x0020108800000000), 0x1.00844p+53, 0x0p+0 },
+{ INT64_C(0xffdfef77ffffffff), -0x1.00844p+53, -0x1p+0 },
+{ INT64_C(0x0020180000000000), 0x1.00cp+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffffffffff), -0x1.00cp+53, -0x1p+0 },
+{ INT64_C(0x0020180000000008), 0x1.00c0000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fffffffff7), -0x1.00c0000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020180000000020), 0x1.00c000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffffffffdf), -0x1.00c000000001p+53, -0x1p+0 },
+{ INT64_C(0x0020180000000100), 0x1.00c000000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fffffffeff), -0x1.00c000000008p+53, -0x1p+0 },
+{ INT64_C(0x0020180000000400), 0x1.00c00000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fffffffbff), -0x1.00c00000002p+53, -0x1p+0 },
+{ INT64_C(0x0020180000002000), 0x1.00c0000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffffffdfff), -0x1.00c0000001p+53, -0x1p+0 },
+{ INT64_C(0x0020180000004000), 0x1.00c0000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffffffbfff), -0x1.00c0000002p+53, -0x1p+0 },
+{ INT64_C(0x0020180000008000), 0x1.00c0000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffffff7fff), -0x1.00c0000004p+53, -0x1p+0 },
+{ INT64_C(0x0020180000040000), 0x1.00c000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fffffbffff), -0x1.00c000002p+53, -0x1p+0 },
+{ INT64_C(0x0020180000400000), 0x1.00c00002p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffffbfffff), -0x1.00c00002p+53, -0x1p+0 },
+{ INT64_C(0x0020180001000000), 0x1.00c00008p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fffeffffff), -0x1.00c00008p+53, -0x1p+0 },
+{ INT64_C(0x0020180002000000), 0x1.00c0001p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fffdffffff), -0x1.00c0001p+53, -0x1p+0 },
+{ INT64_C(0x0020180010000000), 0x1.00c0008p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffefffffff), -0x1.00c0008p+53, -0x1p+0 },
+{ INT64_C(0x0020180020000000), 0x1.00c001p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffdfffffff), -0x1.00c001p+53, -0x1p+0 },
+{ INT64_C(0x0020180040000000), 0x1.00c002p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7ffbfffffff), -0x1.00c002p+53, -0x1p+0 },
+{ INT64_C(0x0020180200000000), 0x1.00c01p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7fdffffffff), -0x1.00c01p+53, -0x1p+0 },
+{ INT64_C(0x0020182000000000), 0x1.00c1p+53, 0x0p+0 },
+{ INT64_C(0xffdfe7dfffffffff), -0x1.00c1p+53, -0x1p+0 },
+{ INT64_C(0x0020190000000000), 0x1.00c8p+53, 0x0p+0 },
+{ INT64_C(0xffdfe6ffffffffff), -0x1.00c8p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000004), 0x1.0100000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffffffb), -0x1.0100000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000005), 0x1.0100000000002p+53, 0x1p+0 },
+{ INT64_C(0xffdfdffffffffffa), -0x1.0100000000003p+53, 0x0p+0 },
+{ INT64_C(0x0020200000000020), 0x1.010000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffffdf), -0x1.010000000001p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000022), 0x1.0100000000011p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffffdd), -0x1.0100000000012p+53, 0x1p+0 },
+{ INT64_C(0x0020200000000040), 0x1.010000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffffbf), -0x1.010000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000044), 0x1.0100000000022p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffffbb), -0x1.0100000000022p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000100), 0x1.010000000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffffeff), -0x1.010000000008p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000102), 0x1.0100000000081p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffffefd), -0x1.0100000000082p+53, 0x1p+0 },
+{ INT64_C(0x0020200000000110), 0x1.0100000000088p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffffeef), -0x1.0100000000088p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000180), 0x1.01000000000cp+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffffe7f), -0x1.01000000000cp+53, -0x1p+0 },
+{ INT64_C(0x0020200000000800), 0x1.01000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffff7ff), -0x1.01000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000802), 0x1.0100000000401p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffff7fd), -0x1.0100000000402p+53, 0x1p+0 },
+{ INT64_C(0x0020200000000808), 0x1.0100000000404p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffff7f7), -0x1.0100000000404p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000880), 0x1.010000000044p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffff77f), -0x1.010000000044p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000a00), 0x1.01000000005p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffff5ff), -0x1.01000000005p+53, -0x1p+0 },
+{ INT64_C(0x0020200000000c00), 0x1.01000000006p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffff3ff), -0x1.01000000006p+53, -0x1p+0 },
+{ INT64_C(0x0020200000002000), 0x1.0100000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffdfff), -0x1.0100000001p+53, -0x1p+0 },
+{ INT64_C(0x0020200000002008), 0x1.0100000001004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffdff7), -0x1.0100000001004p+53, -0x1p+0 },
+{ INT64_C(0x0020200000002080), 0x1.010000000104p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffdf7f), -0x1.010000000104p+53, -0x1p+0 },
+{ INT64_C(0x0020200000002100), 0x1.010000000108p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffdeff), -0x1.010000000108p+53, -0x1p+0 },
+{ INT64_C(0x0020200000003000), 0x1.01000000018p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffffcfff), -0x1.01000000018p+53, -0x1p+0 },
+{ INT64_C(0x0020200000020000), 0x1.010000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffdffff), -0x1.010000001p+53, -0x1p+0 },
+{ INT64_C(0x0020200000020008), 0x1.0100000010004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffdfff7), -0x1.0100000010004p+53, -0x1p+0 },
+{ INT64_C(0x0020200000020080), 0x1.010000001004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffdff7f), -0x1.010000001004p+53, -0x1p+0 },
+{ INT64_C(0x0020200000020800), 0x1.01000000104p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffdf7ff), -0x1.01000000104p+53, -0x1p+0 },
+{ INT64_C(0x0020200000024000), 0x1.0100000012p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffdbfff), -0x1.0100000012p+53, -0x1p+0 },
+{ INT64_C(0x0020200000040000), 0x1.010000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbffff), -0x1.010000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000040008), 0x1.0100000020004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbfff7), -0x1.0100000020004p+53, -0x1p+0 },
+{ INT64_C(0x0020200000040010), 0x1.0100000020008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbffef), -0x1.0100000020008p+53, -0x1p+0 },
+{ INT64_C(0x0020200000040020), 0x1.010000002001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbffdf), -0x1.010000002001p+53, -0x1p+0 },
+{ INT64_C(0x0020200000040200), 0x1.01000000201p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbfdff), -0x1.01000000201p+53, -0x1p+0 },
+{ INT64_C(0x0020200000041000), 0x1.01000000208p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbefff), -0x1.01000000208p+53, -0x1p+0 },
+{ INT64_C(0x0020200000044000), 0x1.0100000022p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffffbbfff), -0x1.0100000022p+53, -0x1p+0 },
+{ INT64_C(0x0020200000100000), 0x1.010000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffefffff), -0x1.010000008p+53, -0x1p+0 },
+{ INT64_C(0x0020200000100004), 0x1.0100000080002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffeffffb), -0x1.0100000080002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000100040), 0x1.010000008002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffefffbf), -0x1.010000008002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000100400), 0x1.01000000802p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffeffbff), -0x1.01000000802p+53, -0x1p+0 },
+{ INT64_C(0x0020200000101000), 0x1.01000000808p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffefefff), -0x1.01000000808p+53, -0x1p+0 },
+{ INT64_C(0x0020200000102000), 0x1.0100000081p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffefdfff), -0x1.0100000081p+53, -0x1p+0 },
+{ INT64_C(0x0020200000108000), 0x1.0100000084p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffef7fff), -0x1.0100000084p+53, -0x1p+0 },
+{ INT64_C(0x0020200000110000), 0x1.0100000088p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffeeffff), -0x1.0100000088p+53, -0x1p+0 },
+{ INT64_C(0x0020200000120000), 0x1.010000009p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffedffff), -0x1.010000009p+53, -0x1p+0 },
+{ INT64_C(0x0020200000180000), 0x1.01000000cp+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffe7ffff), -0x1.01000000cp+53, -0x1p+0 },
+{ INT64_C(0x0020200000400000), 0x1.01000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbfffff), -0x1.01000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000400002), 0x1.0100000200001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbffffd), -0x1.0100000200002p+53, 0x1p+0 },
+{ INT64_C(0x0020200000400010), 0x1.0100000200008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbfffef), -0x1.0100000200008p+53, -0x1p+0 },
+{ INT64_C(0x0020200000400080), 0x1.010000020004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbfff7f), -0x1.010000020004p+53, -0x1p+0 },
+{ INT64_C(0x0020200000400400), 0x1.01000002002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbffbff), -0x1.01000002002p+53, -0x1p+0 },
+{ INT64_C(0x0020200000404000), 0x1.0100000202p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbfbfff), -0x1.0100000202p+53, -0x1p+0 },
+{ INT64_C(0x0020200000420000), 0x1.010000021p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffbdffff), -0x1.010000021p+53, -0x1p+0 },
+{ INT64_C(0x0020200000480000), 0x1.010000024p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffffb7ffff), -0x1.010000024p+53, -0x1p+0 },
+{ INT64_C(0x0020200000600000), 0x1.01000003p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffff9fffff), -0x1.01000003p+53, -0x1p+0 },
+{ INT64_C(0x0020200002000000), 0x1.0100001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdffffff), -0x1.0100001p+53, -0x1p+0 },
+{ INT64_C(0x0020200002000001), 0x1.0100001p+53, 0x1p+0 },
+{ INT64_C(0xffdfdffffdfffffe), -0x1.0100001000001p+53, 0x0p+0 },
+{ INT64_C(0x0020200002000004), 0x1.0100001000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdfffffb), -0x1.0100001000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200002000008), 0x1.0100001000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdfffff7), -0x1.0100001000004p+53, -0x1p+0 },
+{ INT64_C(0x0020200002000010), 0x1.0100001000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdffffef), -0x1.0100001000008p+53, -0x1p+0 },
+{ INT64_C(0x0020200002000100), 0x1.010000100008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdfffeff), -0x1.010000100008p+53, -0x1p+0 },
+{ INT64_C(0x0020200002000400), 0x1.01000010002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdfffbff), -0x1.01000010002p+53, -0x1p+0 },
+{ INT64_C(0x0020200002004000), 0x1.0100001002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdffbfff), -0x1.0100001002p+53, -0x1p+0 },
+{ INT64_C(0x0020200002010000), 0x1.0100001008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdfeffff), -0x1.0100001008p+53, -0x1p+0 },
+{ INT64_C(0x0020200002040000), 0x1.010000102p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdfbffff), -0x1.010000102p+53, -0x1p+0 },
+{ INT64_C(0x0020200002400000), 0x1.01000012p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffdbfffff), -0x1.01000012p+53, -0x1p+0 },
+{ INT64_C(0x0020200003000000), 0x1.01000018p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffffcffffff), -0x1.01000018p+53, -0x1p+0 },
+{ INT64_C(0x0020200010000000), 0x1.0100008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffefffffff), -0x1.0100008p+53, -0x1p+0 },
+{ INT64_C(0x0020200010000001), 0x1.0100008p+53, 0x1p+0 },
+{ INT64_C(0xffdfdfffeffffffe), -0x1.0100008000001p+53, 0x0p+0 },
+{ INT64_C(0x0020200010000008), 0x1.0100008000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffeffffff7), -0x1.0100008000004p+53, -0x1p+0 },
+{ INT64_C(0x0020200010000080), 0x1.010000800004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffefffff7f), -0x1.010000800004p+53, -0x1p+0 },
+{ INT64_C(0x0020200010000100), 0x1.010000800008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffeffffeff), -0x1.010000800008p+53, -0x1p+0 },
+{ INT64_C(0x0020200010000200), 0x1.01000080001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffeffffdff), -0x1.01000080001p+53, -0x1p+0 },
+{ INT64_C(0x0020200010002000), 0x1.0100008001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffefffdfff), -0x1.0100008001p+53, -0x1p+0 },
+{ INT64_C(0x0020200010008000), 0x1.0100008004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffefff7fff), -0x1.0100008004p+53, -0x1p+0 },
+{ INT64_C(0x0020200010080000), 0x1.010000804p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffeff7ffff), -0x1.010000804p+53, -0x1p+0 },
+{ INT64_C(0x0020200010200000), 0x1.01000081p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffefdfffff), -0x1.01000081p+53, -0x1p+0 },
+{ INT64_C(0x0020200010400000), 0x1.01000082p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffefbfffff), -0x1.01000082p+53, -0x1p+0 },
+{ INT64_C(0x0020200010800000), 0x1.01000084p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffef7fffff), -0x1.01000084p+53, -0x1p+0 },
+{ INT64_C(0x0020200012000000), 0x1.0100009p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfffedffffff), -0x1.0100009p+53, -0x1p+0 },
+{ INT64_C(0x0020200080000000), 0x1.010004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7fffffff), -0x1.010004p+53, -0x1p+0 },
+{ INT64_C(0x0020200080000004), 0x1.0100040000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7ffffffb), -0x1.0100040000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200080000040), 0x1.010004000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7fffffbf), -0x1.010004000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200080000100), 0x1.010004000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7ffffeff), -0x1.010004000008p+53, -0x1p+0 },
+{ INT64_C(0x0020200080001000), 0x1.01000400008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7fffefff), -0x1.01000400008p+53, -0x1p+0 },
+{ INT64_C(0x0020200080010000), 0x1.0100040008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7ffeffff), -0x1.0100040008p+53, -0x1p+0 },
+{ INT64_C(0x0020200080040000), 0x1.010004002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7ffbffff), -0x1.010004002p+53, -0x1p+0 },
+{ INT64_C(0x0020200080200000), 0x1.01000401p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7fdfffff), -0x1.01000401p+53, -0x1p+0 },
+{ INT64_C(0x0020200081000000), 0x1.01000408p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7effffff), -0x1.01000408p+53, -0x1p+0 },
+{ INT64_C(0x0020200082000000), 0x1.0100041p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff7dffffff), -0x1.0100041p+53, -0x1p+0 },
+{ INT64_C(0x00202000a0000000), 0x1.010005p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfff5fffffff), -0x1.010005p+53, -0x1p+0 },
+{ INT64_C(0x0020200200000000), 0x1.01001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdffffffff), -0x1.01001p+53, -0x1p+0 },
+{ INT64_C(0x0020200200000001), 0x1.01001p+53, 0x1p+0 },
+{ INT64_C(0xffdfdffdfffffffe), -0x1.0100100000001p+53, 0x0p+0 },
+{ INT64_C(0x0020200200000010), 0x1.0100100000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdffffffef), -0x1.0100100000008p+53, -0x1p+0 },
+{ INT64_C(0x0020200200000080), 0x1.010010000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdffffff7f), -0x1.010010000004p+53, -0x1p+0 },
+{ INT64_C(0x0020200200000400), 0x1.01001000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdfffffbff), -0x1.01001000002p+53, -0x1p+0 },
+{ INT64_C(0x0020200200004000), 0x1.0100100002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdffffbfff), -0x1.0100100002p+53, -0x1p+0 },
+{ INT64_C(0x0020200200020000), 0x1.010010001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdfffdffff), -0x1.010010001p+53, -0x1p+0 },
+{ INT64_C(0x0020200200040000), 0x1.010010002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdfffbffff), -0x1.010010002p+53, -0x1p+0 },
+{ INT64_C(0x0020200200400000), 0x1.01001002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdffbfffff), -0x1.01001002p+53, -0x1p+0 },
+{ INT64_C(0x0020200202000000), 0x1.0100101p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffdfdffffff), -0x1.0100101p+53, -0x1p+0 },
+{ INT64_C(0x0020200220000000), 0x1.010011p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffddfffffff), -0x1.010011p+53, -0x1p+0 },
+{ INT64_C(0x0020200300000000), 0x1.010018p+53, 0x0p+0 },
+{ INT64_C(0xffdfdffcffffffff), -0x1.010018p+53, -0x1p+0 },
+{ INT64_C(0x0020201000000000), 0x1.01008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfefffffffff), -0x1.01008p+53, -0x1p+0 },
+{ INT64_C(0x0020201000000008), 0x1.0100800000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeffffffff7), -0x1.0100800000004p+53, -0x1p+0 },
+{ INT64_C(0x0020201000000010), 0x1.0100800000008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfefffffffef), -0x1.0100800000008p+53, -0x1p+0 },
+{ INT64_C(0x0020201000000080), 0x1.010080000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfefffffff7f), -0x1.010080000004p+53, -0x1p+0 },
+{ INT64_C(0x0020201000000200), 0x1.01008000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeffffffdff), -0x1.01008000001p+53, -0x1p+0 },
+{ INT64_C(0x0020201000000400), 0x1.01008000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeffffffbff), -0x1.01008000002p+53, -0x1p+0 },
+{ INT64_C(0x0020201000004000), 0x1.0100800002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfefffffbfff), -0x1.0100800002p+53, -0x1p+0 },
+{ INT64_C(0x0020201000020000), 0x1.010080001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeffffdffff), -0x1.010080001p+53, -0x1p+0 },
+{ INT64_C(0x0020201000080000), 0x1.010080004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeffff7ffff), -0x1.010080004p+53, -0x1p+0 },
+{ INT64_C(0x0020201000200000), 0x1.01008001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfefffdfffff), -0x1.01008001p+53, -0x1p+0 },
+{ INT64_C(0x0020201002000000), 0x1.0100801p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeffdffffff), -0x1.0100801p+53, -0x1p+0 },
+{ INT64_C(0x0020201008000000), 0x1.0100804p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfeff7ffffff), -0x1.0100804p+53, -0x1p+0 },
+{ INT64_C(0x0020201020000000), 0x1.010081p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfefdfffffff), -0x1.010081p+53, -0x1p+0 },
+{ INT64_C(0x0020201200000000), 0x1.01009p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfedffffffff), -0x1.01009p+53, -0x1p+0 },
+{ INT64_C(0x0020204000000000), 0x1.0102p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbfffffffff), -0x1.0102p+53, -0x1p+0 },
+{ INT64_C(0x0020204000000004), 0x1.0102000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffffffffb), -0x1.0102000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020204000000040), 0x1.010200000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbfffffffbf), -0x1.010200000002p+53, -0x1p+0 },
+{ INT64_C(0x0020204000000400), 0x1.01020000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffffffbff), -0x1.01020000002p+53, -0x1p+0 },
+{ INT64_C(0x0020204000000800), 0x1.01020000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffffff7ff), -0x1.01020000004p+53, -0x1p+0 },
+{ INT64_C(0x0020204000004000), 0x1.0102000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbfffffbfff), -0x1.0102000002p+53, -0x1p+0 },
+{ INT64_C(0x0020204000008000), 0x1.0102000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbfffff7fff), -0x1.0102000004p+53, -0x1p+0 },
+{ INT64_C(0x0020204000020000), 0x1.010200001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffffdffff), -0x1.010200001p+53, -0x1p+0 },
+{ INT64_C(0x0020204000040000), 0x1.010200002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffffbffff), -0x1.010200002p+53, -0x1p+0 },
+{ INT64_C(0x0020204000200000), 0x1.01020001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbfffdfffff), -0x1.01020001p+53, -0x1p+0 },
+{ INT64_C(0x0020204001000000), 0x1.01020008p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffeffffff), -0x1.01020008p+53, -0x1p+0 },
+{ INT64_C(0x0020204002000000), 0x1.0102001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbffdffffff), -0x1.0102001p+53, -0x1p+0 },
+{ INT64_C(0x0020204020000000), 0x1.010201p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbfdfffffff), -0x1.010201p+53, -0x1p+0 },
+{ INT64_C(0x0020204080000000), 0x1.010204p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbf7fffffff), -0x1.010204p+53, -0x1p+0 },
+{ INT64_C(0x0020204100000000), 0x1.010208p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfbeffffffff), -0x1.010208p+53, -0x1p+0 },
+{ INT64_C(0x0020204800000000), 0x1.01024p+53, 0x0p+0 },
+{ INT64_C(0xffdfdfb7ffffffff), -0x1.01024p+53, -0x1p+0 },
+{ INT64_C(0x0020206000000000), 0x1.0103p+53, 0x0p+0 },
+{ INT64_C(0xffdfdf9fffffffff), -0x1.0103p+53, -0x1p+0 },
+{ INT64_C(0x0020240000000000), 0x1.012p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffffffffff), -0x1.012p+53, -0x1p+0 },
+{ INT64_C(0x0020240000000004), 0x1.0120000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfffffffffb), -0x1.0120000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020240000000040), 0x1.012000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffffffffbf), -0x1.012000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020240000000080), 0x1.012000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffffffff7f), -0x1.012000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020240000000200), 0x1.01200000001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfffffffdff), -0x1.01200000001p+53, -0x1p+0 },
+{ INT64_C(0x0020240000000800), 0x1.01200000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfffffff7ff), -0x1.01200000004p+53, -0x1p+0 },
+{ INT64_C(0x0020240000008000), 0x1.0120000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffffff7fff), -0x1.0120000004p+53, -0x1p+0 },
+{ INT64_C(0x0020240000080000), 0x1.012000004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfffff7ffff), -0x1.012000004p+53, -0x1p+0 },
+{ INT64_C(0x0020240000200000), 0x1.01200001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffffdfffff), -0x1.01200001p+53, -0x1p+0 },
+{ INT64_C(0x0020240002000000), 0x1.0120001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfffdffffff), -0x1.0120001p+53, -0x1p+0 },
+{ INT64_C(0x0020240020000000), 0x1.012001p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffdfffffff), -0x1.012001p+53, -0x1p+0 },
+{ INT64_C(0x0020240040000000), 0x1.012002p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbffbfffffff), -0x1.012002p+53, -0x1p+0 },
+{ INT64_C(0x0020240080000000), 0x1.012004p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbff7fffffff), -0x1.012004p+53, -0x1p+0 },
+{ INT64_C(0x0020240200000000), 0x1.01201p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfdffffffff), -0x1.01201p+53, -0x1p+0 },
+{ INT64_C(0x0020240400000000), 0x1.01202p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbfbffffffff), -0x1.01202p+53, -0x1p+0 },
+{ INT64_C(0x0020244000000000), 0x1.0122p+53, 0x0p+0 },
+{ INT64_C(0xffdfdbbfffffffff), -0x1.0122p+53, -0x1p+0 },
+{ INT64_C(0x0020260000000000), 0x1.013p+53, 0x0p+0 },
+{ INT64_C(0xffdfd9ffffffffff), -0x1.013p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000002), 0x1.0400000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffffd), -0x1.0400000000002p+53, 0x1p+0 },
+{ INT64_C(0x0020800000000010), 0x1.0400000000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffffef), -0x1.0400000000008p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000014), 0x1.040000000000ap+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffffeb), -0x1.040000000000ap+53, -0x1p+0 },
+{ INT64_C(0x0020800000000020), 0x1.040000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffffdf), -0x1.040000000001p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000028), 0x1.0400000000014p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffffd7), -0x1.0400000000014p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000080), 0x1.040000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffff7f), -0x1.040000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000084), 0x1.0400000000042p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffff7b), -0x1.0400000000042p+53, -0x1p+0 },
+{ INT64_C(0x00208000000000a0), 0x1.040000000005p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffff5f), -0x1.040000000005p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000400), 0x1.04000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffbff), -0x1.04000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000401), 0x1.04000000002p+53, 0x1p+0 },
+{ INT64_C(0xffdf7ffffffffbfe), -0x1.0400000000201p+53, 0x0p+0 },
+{ INT64_C(0x0020800000000402), 0x1.0400000000201p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffbfd), -0x1.0400000000202p+53, 0x1p+0 },
+{ INT64_C(0x0020800000000408), 0x1.0400000000204p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffbf7), -0x1.0400000000204p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000420), 0x1.040000000021p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffbdf), -0x1.040000000021p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000480), 0x1.040000000024p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffb7f), -0x1.040000000024p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000500), 0x1.040000000028p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffffaff), -0x1.040000000028p+53, -0x1p+0 },
+{ INT64_C(0x0020800000000600), 0x1.04000000003p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffffff9ff), -0x1.04000000003p+53, -0x1p+0 },
+{ INT64_C(0x0020800000002000), 0x1.0400000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffdfff), -0x1.0400000001p+53, -0x1p+0 },
+{ INT64_C(0x0020800000002004), 0x1.0400000001002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffdffb), -0x1.0400000001002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000002010), 0x1.0400000001008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffdfef), -0x1.0400000001008p+53, -0x1p+0 },
+{ INT64_C(0x0020800000002040), 0x1.040000000102p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffdfbf), -0x1.040000000102p+53, -0x1p+0 },
+{ INT64_C(0x0020800000002100), 0x1.040000000108p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffdeff), -0x1.040000000108p+53, -0x1p+0 },
+{ INT64_C(0x0020800000002400), 0x1.04000000012p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffdbff), -0x1.04000000012p+53, -0x1p+0 },
+{ INT64_C(0x0020800000003000), 0x1.04000000018p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffffcfff), -0x1.04000000018p+53, -0x1p+0 },
+{ INT64_C(0x0020800000008000), 0x1.0400000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff7fff), -0x1.0400000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800000008001), 0x1.0400000004p+53, 0x1p+0 },
+{ INT64_C(0xffdf7fffffff7ffe), -0x1.0400000004001p+53, 0x0p+0 },
+{ INT64_C(0x0020800000008008), 0x1.0400000004004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff7ff7), -0x1.0400000004004p+53, -0x1p+0 },
+{ INT64_C(0x0020800000008020), 0x1.040000000401p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff7fdf), -0x1.040000000401p+53, -0x1p+0 },
+{ INT64_C(0x0020800000008040), 0x1.040000000402p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff7fbf), -0x1.040000000402p+53, -0x1p+0 },
+{ INT64_C(0x0020800000008100), 0x1.040000000408p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff7eff), -0x1.040000000408p+53, -0x1p+0 },
+{ INT64_C(0x0020800000008400), 0x1.04000000042p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff7bff), -0x1.04000000042p+53, -0x1p+0 },
+{ INT64_C(0x0020800000009000), 0x1.04000000048p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffff6fff), -0x1.04000000048p+53, -0x1p+0 },
+{ INT64_C(0x0020800000080000), 0x1.040000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff7ffff), -0x1.040000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800000080004), 0x1.0400000040002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff7fffb), -0x1.0400000040002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000080010), 0x1.0400000040008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff7ffef), -0x1.0400000040008p+53, -0x1p+0 },
+{ INT64_C(0x0020800000080100), 0x1.040000004008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff7feff), -0x1.040000004008p+53, -0x1p+0 },
+{ INT64_C(0x0020800000080400), 0x1.04000000402p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff7fbff), -0x1.04000000402p+53, -0x1p+0 },
+{ INT64_C(0x0020800000082000), 0x1.0400000041p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff7dfff), -0x1.0400000041p+53, -0x1p+0 },
+{ INT64_C(0x0020800000090000), 0x1.0400000048p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff6ffff), -0x1.0400000048p+53, -0x1p+0 },
+{ INT64_C(0x00208000000a0000), 0x1.040000005p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffff5ffff), -0x1.040000005p+53, -0x1p+0 },
+{ INT64_C(0x0020800000400000), 0x1.04000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffbfffff), -0x1.04000002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000400001), 0x1.04000002p+53, 0x1p+0 },
+{ INT64_C(0xffdf7fffffbffffe), -0x1.0400000200001p+53, 0x0p+0 },
+{ INT64_C(0x0020800000400004), 0x1.0400000200002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffbffffb), -0x1.0400000200002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000400010), 0x1.0400000200008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffbfffef), -0x1.0400000200008p+53, -0x1p+0 },
+{ INT64_C(0x0020800000400100), 0x1.040000020008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffbffeff), -0x1.040000020008p+53, -0x1p+0 },
+{ INT64_C(0x0020800000400800), 0x1.04000002004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffbff7ff), -0x1.04000002004p+53, -0x1p+0 },
+{ INT64_C(0x0020800000408000), 0x1.0400000204p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffbf7fff), -0x1.0400000204p+53, -0x1p+0 },
+{ INT64_C(0x0020800000480000), 0x1.040000024p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffb7ffff), -0x1.040000024p+53, -0x1p+0 },
+{ INT64_C(0x0020800000500000), 0x1.040000028p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffffafffff), -0x1.040000028p+53, -0x1p+0 },
+{ INT64_C(0x0020800000800000), 0x1.04000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7fffff), -0x1.04000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800000800001), 0x1.04000004p+53, 0x1p+0 },
+{ INT64_C(0xffdf7fffff7ffffe), -0x1.0400000400001p+53, 0x0p+0 },
+{ INT64_C(0x0020800000800004), 0x1.0400000400002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7ffffb), -0x1.0400000400002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000800020), 0x1.040000040001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7fffdf), -0x1.040000040001p+53, -0x1p+0 },
+{ INT64_C(0x0020800000800040), 0x1.040000040002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7fffbf), -0x1.040000040002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000800400), 0x1.04000004002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7ffbff), -0x1.04000004002p+53, -0x1p+0 },
+{ INT64_C(0x0020800000802000), 0x1.0400000401p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7fdfff), -0x1.0400000401p+53, -0x1p+0 },
+{ INT64_C(0x0020800000804000), 0x1.0400000402p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7fbfff), -0x1.0400000402p+53, -0x1p+0 },
+{ INT64_C(0x0020800000840000), 0x1.040000042p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff7bffff), -0x1.040000042p+53, -0x1p+0 },
+{ INT64_C(0x0020800000a00000), 0x1.04000005p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffff5fffff), -0x1.04000005p+53, -0x1p+0 },
+{ INT64_C(0x0020800001000000), 0x1.04000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffeffffff), -0x1.04000008p+53, -0x1p+0 },
+{ INT64_C(0x0020800001000004), 0x1.0400000800002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffefffffb), -0x1.0400000800002p+53, -0x1p+0 },
+{ INT64_C(0x0020800001000020), 0x1.040000080001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffeffffdf), -0x1.040000080001p+53, -0x1p+0 },
+{ INT64_C(0x0020800001000040), 0x1.040000080002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffeffffbf), -0x1.040000080002p+53, -0x1p+0 },
+{ INT64_C(0x0020800001000080), 0x1.040000080004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffeffff7f), -0x1.040000080004p+53, -0x1p+0 },
+{ INT64_C(0x0020800001000400), 0x1.04000008002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffefffbff), -0x1.04000008002p+53, -0x1p+0 },
+{ INT64_C(0x0020800001001000), 0x1.04000008008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffeffefff), -0x1.04000008008p+53, -0x1p+0 },
+{ INT64_C(0x0020800001010000), 0x1.0400000808p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffefeffff), -0x1.0400000808p+53, -0x1p+0 },
+{ INT64_C(0x0020800001100000), 0x1.040000088p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffeefffff), -0x1.040000088p+53, -0x1p+0 },
+{ INT64_C(0x0020800001200000), 0x1.04000009p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffedfffff), -0x1.04000009p+53, -0x1p+0 },
+{ INT64_C(0x0020800001800000), 0x1.0400000cp+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffffe7fffff), -0x1.0400000cp+53, -0x1p+0 },
+{ INT64_C(0x0020800008000000), 0x1.0400004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7ffffff), -0x1.0400004p+53, -0x1p+0 },
+{ INT64_C(0x0020800008000008), 0x1.0400004000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7fffff7), -0x1.0400004000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800008000080), 0x1.040000400004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7ffff7f), -0x1.040000400004p+53, -0x1p+0 },
+{ INT64_C(0x0020800008000100), 0x1.040000400008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7fffeff), -0x1.040000400008p+53, -0x1p+0 },
+{ INT64_C(0x0020800008001000), 0x1.04000040008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7ffefff), -0x1.04000040008p+53, -0x1p+0 },
+{ INT64_C(0x0020800008010000), 0x1.0400004008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7feffff), -0x1.0400004008p+53, -0x1p+0 },
+{ INT64_C(0x0020800008080000), 0x1.040000404p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7f7ffff), -0x1.040000404p+53, -0x1p+0 },
+{ INT64_C(0x0020800008200000), 0x1.04000041p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7dfffff), -0x1.04000041p+53, -0x1p+0 },
+{ INT64_C(0x0020800008400000), 0x1.04000042p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff7bfffff), -0x1.04000042p+53, -0x1p+0 },
+{ INT64_C(0x002080000c000000), 0x1.0400006p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffff3ffffff), -0x1.0400006p+53, -0x1p+0 },
+{ INT64_C(0x0020800010000000), 0x1.0400008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffefffffff), -0x1.0400008p+53, -0x1p+0 },
+{ INT64_C(0x0020800010000004), 0x1.0400008000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffeffffffb), -0x1.0400008000002p+53, -0x1p+0 },
+{ INT64_C(0x0020800010000010), 0x1.0400008000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffefffffef), -0x1.0400008000008p+53, -0x1p+0 },
+{ INT64_C(0x0020800010000100), 0x1.040000800008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffeffffeff), -0x1.040000800008p+53, -0x1p+0 },
+{ INT64_C(0x0020800010000400), 0x1.04000080002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffeffffbff), -0x1.04000080002p+53, -0x1p+0 },
+{ INT64_C(0x0020800010000800), 0x1.04000080004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffeffff7ff), -0x1.04000080004p+53, -0x1p+0 },
+{ INT64_C(0x0020800010004000), 0x1.0400008002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffefffbfff), -0x1.0400008002p+53, -0x1p+0 },
+{ INT64_C(0x0020800010010000), 0x1.0400008008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffeffeffff), -0x1.0400008008p+53, -0x1p+0 },
+{ INT64_C(0x0020800010100000), 0x1.040000808p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffefefffff), -0x1.040000808p+53, -0x1p+0 },
+{ INT64_C(0x0020800010400000), 0x1.04000082p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffefbfffff), -0x1.04000082p+53, -0x1p+0 },
+{ INT64_C(0x0020800011000000), 0x1.04000088p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffeeffffff), -0x1.04000088p+53, -0x1p+0 },
+{ INT64_C(0x0020800020000000), 0x1.040001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdfffffff), -0x1.040001p+53, -0x1p+0 },
+{ INT64_C(0x0020800020000008), 0x1.0400010000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdffffff7), -0x1.0400010000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800020000020), 0x1.040001000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdfffffdf), -0x1.040001000001p+53, -0x1p+0 },
+{ INT64_C(0x0020800020000200), 0x1.04000100001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdffffdff), -0x1.04000100001p+53, -0x1p+0 },
+{ INT64_C(0x0020800020000400), 0x1.04000100002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdffffbff), -0x1.04000100002p+53, -0x1p+0 },
+{ INT64_C(0x0020800020001000), 0x1.04000100008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdfffefff), -0x1.04000100008p+53, -0x1p+0 },
+{ INT64_C(0x0020800020002000), 0x1.0400010001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdfffdfff), -0x1.0400010001p+53, -0x1p+0 },
+{ INT64_C(0x0020800020020000), 0x1.040001001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdffdffff), -0x1.040001001p+53, -0x1p+0 },
+{ INT64_C(0x0020800020100000), 0x1.040001008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdfefffff), -0x1.040001008p+53, -0x1p+0 },
+{ INT64_C(0x0020800020800000), 0x1.04000104p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffdf7fffff), -0x1.04000104p+53, -0x1p+0 },
+{ INT64_C(0x0020800022000000), 0x1.0400011p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffddffffff), -0x1.0400011p+53, -0x1p+0 },
+{ INT64_C(0x0020800028000000), 0x1.0400014p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fffd7ffffff), -0x1.0400014p+53, -0x1p+0 },
+{ INT64_C(0x0020800200000000), 0x1.04001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdffffffff), -0x1.04001p+53, -0x1p+0 },
+{ INT64_C(0x0020800200000001), 0x1.04001p+53, 0x1p+0 },
+{ INT64_C(0xffdf7ffdfffffffe), -0x1.0400100000001p+53, 0x0p+0 },
+{ INT64_C(0x0020800200000008), 0x1.0400100000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdfffffff7), -0x1.0400100000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800200000040), 0x1.040010000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdffffffbf), -0x1.040010000002p+53, -0x1p+0 },
+{ INT64_C(0x0020800200000100), 0x1.040010000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdfffffeff), -0x1.040010000008p+53, -0x1p+0 },
+{ INT64_C(0x0020800200000800), 0x1.04001000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdfffff7ff), -0x1.04001000004p+53, -0x1p+0 },
+{ INT64_C(0x0020800200002000), 0x1.0400100001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdffffdfff), -0x1.0400100001p+53, -0x1p+0 },
+{ INT64_C(0x0020800200008000), 0x1.0400100004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdffff7fff), -0x1.0400100004p+53, -0x1p+0 },
+{ INT64_C(0x0020800200080000), 0x1.040010004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdfff7ffff), -0x1.040010004p+53, -0x1p+0 },
+{ INT64_C(0x0020800200800000), 0x1.04001004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdff7fffff), -0x1.04001004p+53, -0x1p+0 },
+{ INT64_C(0x0020800202000000), 0x1.0400101p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdfdffffff), -0x1.0400101p+53, -0x1p+0 },
+{ INT64_C(0x0020800208000000), 0x1.0400104p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffdf7ffffff), -0x1.0400104p+53, -0x1p+0 },
+{ INT64_C(0x0020800280000000), 0x1.040014p+53, 0x0p+0 },
+{ INT64_C(0xffdf7ffd7fffffff), -0x1.040014p+53, -0x1p+0 },
+{ INT64_C(0x0020801000000000), 0x1.04008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefffffffff), -0x1.04008p+53, -0x1p+0 },
+{ INT64_C(0x0020801000000001), 0x1.04008p+53, 0x1p+0 },
+{ INT64_C(0xffdf7feffffffffe), -0x1.0400800000001p+53, 0x0p+0 },
+{ INT64_C(0x0020801000000002), 0x1.0400800000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffffffffd), -0x1.0400800000002p+53, 0x1p+0 },
+{ INT64_C(0x0020801000000008), 0x1.0400800000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffffffff7), -0x1.0400800000004p+53, -0x1p+0 },
+{ INT64_C(0x0020801000000040), 0x1.040080000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefffffffbf), -0x1.040080000002p+53, -0x1p+0 },
+{ INT64_C(0x0020801000000200), 0x1.04008000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffffffdff), -0x1.04008000001p+53, -0x1p+0 },
+{ INT64_C(0x0020801000000800), 0x1.04008000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffffff7ff), -0x1.04008000004p+53, -0x1p+0 },
+{ INT64_C(0x0020801000001000), 0x1.04008000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefffffefff), -0x1.04008000008p+53, -0x1p+0 },
+{ INT64_C(0x0020801000010000), 0x1.0400800008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffffeffff), -0x1.0400800008p+53, -0x1p+0 },
+{ INT64_C(0x0020801000020000), 0x1.040080001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffffdffff), -0x1.040080001p+53, -0x1p+0 },
+{ INT64_C(0x0020801000100000), 0x1.040080008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefffefffff), -0x1.040080008p+53, -0x1p+0 },
+{ INT64_C(0x0020801000200000), 0x1.04008001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefffdfffff), -0x1.04008001p+53, -0x1p+0 },
+{ INT64_C(0x0020801002000000), 0x1.0400801p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffdffffff), -0x1.0400801p+53, -0x1p+0 },
+{ INT64_C(0x0020801004000000), 0x1.0400802p+53, 0x0p+0 },
+{ INT64_C(0xffdf7feffbffffff), -0x1.0400802p+53, -0x1p+0 },
+{ INT64_C(0x0020801020000000), 0x1.040081p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefdfffffff), -0x1.040081p+53, -0x1p+0 },
+{ INT64_C(0x0020801040000000), 0x1.040082p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fefbfffffff), -0x1.040082p+53, -0x1p+0 },
+{ INT64_C(0x0020801400000000), 0x1.0400ap+53, 0x0p+0 },
+{ INT64_C(0xffdf7febffffffff), -0x1.0400ap+53, -0x1p+0 },
+{ INT64_C(0x0020804000000000), 0x1.0402p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfffffffff), -0x1.0402p+53, -0x1p+0 },
+{ INT64_C(0x0020804000000001), 0x1.0402p+53, 0x1p+0 },
+{ INT64_C(0xffdf7fbffffffffe), -0x1.0402000000001p+53, 0x0p+0 },
+{ INT64_C(0x0020804000000010), 0x1.0402000000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfffffffef), -0x1.0402000000008p+53, -0x1p+0 },
+{ INT64_C(0x0020804000000020), 0x1.040200000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfffffffdf), -0x1.040200000001p+53, -0x1p+0 },
+{ INT64_C(0x0020804000000200), 0x1.04020000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbffffffdff), -0x1.04020000001p+53, -0x1p+0 },
+{ INT64_C(0x0020804000002000), 0x1.0402000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfffffdfff), -0x1.0402000001p+53, -0x1p+0 },
+{ INT64_C(0x0020804000004000), 0x1.0402000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfffffbfff), -0x1.0402000002p+53, -0x1p+0 },
+{ INT64_C(0x0020804000010000), 0x1.0402000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbffffeffff), -0x1.0402000008p+53, -0x1p+0 },
+{ INT64_C(0x0020804000080000), 0x1.040200004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbffff7ffff), -0x1.040200004p+53, -0x1p+0 },
+{ INT64_C(0x0020804000100000), 0x1.040200008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfffefffff), -0x1.040200008p+53, -0x1p+0 },
+{ INT64_C(0x0020804001000000), 0x1.04020008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbffeffffff), -0x1.04020008p+53, -0x1p+0 },
+{ INT64_C(0x0020804008000000), 0x1.0402004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbff7ffffff), -0x1.0402004p+53, -0x1p+0 },
+{ INT64_C(0x0020804040000000), 0x1.040202p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbfbfffffff), -0x1.040202p+53, -0x1p+0 },
+{ INT64_C(0x0020804100000000), 0x1.040208p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbeffffffff), -0x1.040208p+53, -0x1p+0 },
+{ INT64_C(0x0020804400000000), 0x1.04022p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fbbffffffff), -0x1.04022p+53, -0x1p+0 },
+{ INT64_C(0x0020804800000000), 0x1.04024p+53, 0x0p+0 },
+{ INT64_C(0xffdf7fb7ffffffff), -0x1.04024p+53, -0x1p+0 },
+{ INT64_C(0x0020806000000000), 0x1.0403p+53, 0x0p+0 },
+{ INT64_C(0xffdf7f9fffffffff), -0x1.0403p+53, -0x1p+0 },
+{ INT64_C(0x0020820000000000), 0x1.041p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffffffffff), -0x1.041p+53, -0x1p+0 },
+{ INT64_C(0x0020820000000002), 0x1.0410000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dfffffffffd), -0x1.0410000000002p+53, 0x1p+0 },
+{ INT64_C(0x0020820000000004), 0x1.0410000000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dfffffffffb), -0x1.0410000000002p+53, -0x1p+0 },
+{ INT64_C(0x0020820000000020), 0x1.041000000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffffffffdf), -0x1.041000000001p+53, -0x1p+0 },
+{ INT64_C(0x0020820000000080), 0x1.041000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffffffff7f), -0x1.041000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020820000000400), 0x1.04100000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dfffffffbff), -0x1.04100000002p+53, -0x1p+0 },
+{ INT64_C(0x0020820000001000), 0x1.04100000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffffffefff), -0x1.04100000008p+53, -0x1p+0 },
+{ INT64_C(0x0020820000008000), 0x1.0410000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffffff7fff), -0x1.0410000004p+53, -0x1p+0 },
+{ INT64_C(0x0020820000040000), 0x1.041000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dfffffbffff), -0x1.041000002p+53, -0x1p+0 },
+{ INT64_C(0x0020820000100000), 0x1.041000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffffefffff), -0x1.041000008p+53, -0x1p+0 },
+{ INT64_C(0x0020820001000000), 0x1.04100008p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dfffeffffff), -0x1.04100008p+53, -0x1p+0 },
+{ INT64_C(0x0020820004000000), 0x1.0410002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dfffbffffff), -0x1.0410002p+53, -0x1p+0 },
+{ INT64_C(0x0020820040000000), 0x1.041002p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dffbfffffff), -0x1.041002p+53, -0x1p+0 },
+{ INT64_C(0x0020820080000000), 0x1.041004p+53, 0x0p+0 },
+{ INT64_C(0xffdf7dff7fffffff), -0x1.041004p+53, -0x1p+0 },
+{ INT64_C(0x0020820800000000), 0x1.04104p+53, 0x0p+0 },
+{ INT64_C(0xffdf7df7ffffffff), -0x1.04104p+53, -0x1p+0 },
+{ INT64_C(0x0020828000000000), 0x1.0414p+53, 0x0p+0 },
+{ INT64_C(0xffdf7d7fffffffff), -0x1.0414p+53, -0x1p+0 },
+{ INT64_C(0x0020900000000000), 0x1.048p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffffffff), -0x1.048p+53, -0x1p+0 },
+{ INT64_C(0x0020900000000008), 0x1.0480000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ffffffffff7), -0x1.0480000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020900000000080), 0x1.048000000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffffff7f), -0x1.048000000004p+53, -0x1p+0 },
+{ INT64_C(0x0020900000000800), 0x1.04800000004p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ffffffff7ff), -0x1.04800000004p+53, -0x1p+0 },
+{ INT64_C(0x0020900000001000), 0x1.04800000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffffefff), -0x1.04800000008p+53, -0x1p+0 },
+{ INT64_C(0x0020900000002000), 0x1.0480000001p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffffdfff), -0x1.0480000001p+53, -0x1p+0 },
+{ INT64_C(0x0020900000004000), 0x1.0480000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffffbfff), -0x1.0480000002p+53, -0x1p+0 },
+{ INT64_C(0x0020900000040000), 0x1.048000002p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ffffffbffff), -0x1.048000002p+53, -0x1p+0 },
+{ INT64_C(0x0020900000100000), 0x1.048000008p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffefffff), -0x1.048000008p+53, -0x1p+0 },
+{ INT64_C(0x0020900000200000), 0x1.04800001p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffffdfffff), -0x1.04800001p+53, -0x1p+0 },
+{ INT64_C(0x0020900001000000), 0x1.04800008p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ffffeffffff), -0x1.04800008p+53, -0x1p+0 },
+{ INT64_C(0x0020900010000000), 0x1.0480008p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffefffffff), -0x1.0480008p+53, -0x1p+0 },
+{ INT64_C(0x0020900020000000), 0x1.048001p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fffdfffffff), -0x1.048001p+53, -0x1p+0 },
+{ INT64_C(0x0020900100000000), 0x1.048008p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ffeffffffff), -0x1.048008p+53, -0x1p+0 },
+{ INT64_C(0x0020900400000000), 0x1.04802p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ffbffffffff), -0x1.04802p+53, -0x1p+0 },
+{ INT64_C(0x0020900800000000), 0x1.04804p+53, 0x0p+0 },
+{ INT64_C(0xffdf6ff7ffffffff), -0x1.04804p+53, -0x1p+0 },
+{ INT64_C(0x0020901000000000), 0x1.04808p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fefffffffff), -0x1.04808p+53, -0x1p+0 },
+{ INT64_C(0x0020902000000000), 0x1.0481p+53, 0x0p+0 },
+{ INT64_C(0xffdf6fdfffffffff), -0x1.0481p+53, -0x1p+0 },
+{ INT64_C(0x0020910000000000), 0x1.0488p+53, 0x0p+0 },
+{ INT64_C(0xffdf6effffffffff), -0x1.0488p+53, -0x1p+0 },
+{ INT64_C(0x0020980000000000), 0x1.04cp+53, 0x0p+0 },
+{ INT64_C(0xffdf67ffffffffff), -0x1.04cp+53, -0x1p+0 },
+{ INT64_C(0x0028000000000001), 0x1.4p+53, 0x1p+0 },
+{ INT64_C(0xffd7fffffffffffe), -0x1.4000000000001p+53, 0x0p+0 },
+{ INT64_C(0x0028000000000004), 0x1.4000000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffffb), -0x1.4000000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000010), 0x1.4000000000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffef), -0x1.4000000000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000012), 0x1.4000000000009p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffed), -0x1.400000000000ap+53, 0x1p+0 },
+{ INT64_C(0x0028000000000014), 0x1.400000000000ap+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffeb), -0x1.400000000000ap+53, -0x1p+0 },
+{ INT64_C(0x0028000000000020), 0x1.400000000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffdf), -0x1.400000000001p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000024), 0x1.4000000000012p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffdb), -0x1.4000000000012p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000028), 0x1.4000000000014p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffd7), -0x1.4000000000014p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000030), 0x1.4000000000018p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffffcf), -0x1.4000000000018p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000100), 0x1.400000000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffeff), -0x1.400000000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000108), 0x1.4000000000084p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffef7), -0x1.4000000000084p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000110), 0x1.4000000000088p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffeef), -0x1.4000000000088p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000140), 0x1.40000000000ap+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffebf), -0x1.40000000000ap+53, -0x1p+0 },
+{ INT64_C(0x0028000000000200), 0x1.40000000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffdff), -0x1.40000000001p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000208), 0x1.4000000000104p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffdf7), -0x1.4000000000104p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000280), 0x1.400000000014p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffd7f), -0x1.400000000014p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000400), 0x1.40000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffbff), -0x1.40000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000402), 0x1.4000000000201p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffbfd), -0x1.4000000000202p+53, 0x1p+0 },
+{ INT64_C(0x0028000000000410), 0x1.4000000000208p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffbef), -0x1.4000000000208p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000480), 0x1.400000000024p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffffb7f), -0x1.400000000024p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000800), 0x1.40000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff7ff), -0x1.40000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000802), 0x1.4000000000401p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff7fd), -0x1.4000000000402p+53, 0x1p+0 },
+{ INT64_C(0x0028000000000804), 0x1.4000000000402p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff7fb), -0x1.4000000000402p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000808), 0x1.4000000000404p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff7f7), -0x1.4000000000404p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000820), 0x1.400000000041p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff7df), -0x1.400000000041p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000840), 0x1.400000000042p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff7bf), -0x1.400000000042p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000a00), 0x1.40000000005p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff5ff), -0x1.40000000005p+53, -0x1p+0 },
+{ INT64_C(0x0028000000000c00), 0x1.40000000006p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffff3ff), -0x1.40000000006p+53, -0x1p+0 },
+{ INT64_C(0x0028000000004000), 0x1.4000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffbfff), -0x1.4000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000004004), 0x1.4000000002002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffbffb), -0x1.4000000002002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000004008), 0x1.4000000002004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffbff7), -0x1.4000000002004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000004010), 0x1.4000000002008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffbfef), -0x1.4000000002008p+53, -0x1p+0 },
+{ INT64_C(0x0028000000004040), 0x1.400000000202p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffbfbf), -0x1.400000000202p+53, -0x1p+0 },
+{ INT64_C(0x0028000000004400), 0x1.40000000022p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffffbbff), -0x1.40000000022p+53, -0x1p+0 },
+{ INT64_C(0x0028000000006000), 0x1.4000000003p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff9fff), -0x1.4000000003p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008000), 0x1.4000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff7fff), -0x1.4000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008008), 0x1.4000000004004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff7ff7), -0x1.4000000004004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008010), 0x1.4000000004008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff7fef), -0x1.4000000004008p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008020), 0x1.400000000401p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff7fdf), -0x1.400000000401p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008080), 0x1.400000000404p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff7f7f), -0x1.400000000404p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008400), 0x1.40000000042p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff7bff), -0x1.40000000042p+53, -0x1p+0 },
+{ INT64_C(0x0028000000008800), 0x1.40000000044p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff77ff), -0x1.40000000044p+53, -0x1p+0 },
+{ INT64_C(0x0028000000009000), 0x1.40000000048p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffff6fff), -0x1.40000000048p+53, -0x1p+0 },
+{ INT64_C(0x0028000000040000), 0x1.400000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffbffff), -0x1.400000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000040008), 0x1.4000000020004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffbfff7), -0x1.4000000020004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000040080), 0x1.400000002004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffbff7f), -0x1.400000002004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000040400), 0x1.40000000202p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffbfbff), -0x1.40000000202p+53, -0x1p+0 },
+{ INT64_C(0x0028000000044000), 0x1.4000000022p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffffbbfff), -0x1.4000000022p+53, -0x1p+0 },
+{ INT64_C(0x0028000000400000), 0x1.40000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbfffff), -0x1.40000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000400004), 0x1.4000000200002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbffffb), -0x1.4000000200002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000400040), 0x1.400000020002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbfffbf), -0x1.400000020002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000400200), 0x1.40000002001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbffdff), -0x1.40000002001p+53, -0x1p+0 },
+{ INT64_C(0x0028000000400400), 0x1.40000002002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbffbff), -0x1.40000002002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000400800), 0x1.40000002004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbff7ff), -0x1.40000002004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000404000), 0x1.4000000202p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbfbfff), -0x1.4000000202p+53, -0x1p+0 },
+{ INT64_C(0x0028000000440000), 0x1.400000022p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffbbffff), -0x1.400000022p+53, -0x1p+0 },
+{ INT64_C(0x0028000000480000), 0x1.400000024p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffffb7ffff), -0x1.400000024p+53, -0x1p+0 },
+{ INT64_C(0x0028000000800000), 0x1.40000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7fffff), -0x1.40000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000000800004), 0x1.4000000400002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7ffffb), -0x1.4000000400002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000800040), 0x1.400000040002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7fffbf), -0x1.400000040002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000800100), 0x1.400000040008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7ffeff), -0x1.400000040008p+53, -0x1p+0 },
+{ INT64_C(0x0028000000800400), 0x1.40000004002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7ffbff), -0x1.40000004002p+53, -0x1p+0 },
+{ INT64_C(0x0028000000804000), 0x1.4000000402p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7fbfff), -0x1.4000000402p+53, -0x1p+0 },
+{ INT64_C(0x0028000000810000), 0x1.4000000408p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff7effff), -0x1.4000000408p+53, -0x1p+0 },
+{ INT64_C(0x0028000000880000), 0x1.400000044p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffff77ffff), -0x1.400000044p+53, -0x1p+0 },
+{ INT64_C(0x0028000002000000), 0x1.4000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdffffff), -0x1.4000001p+53, -0x1p+0 },
+{ INT64_C(0x0028000002000004), 0x1.4000001000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdfffffb), -0x1.4000001000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000002000010), 0x1.4000001000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdffffef), -0x1.4000001000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000002000080), 0x1.400000100004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdffff7f), -0x1.400000100004p+53, -0x1p+0 },
+{ INT64_C(0x0028000002000400), 0x1.40000010002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdfffbff), -0x1.40000010002p+53, -0x1p+0 },
+{ INT64_C(0x0028000002001000), 0x1.40000010008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdffefff), -0x1.40000010008p+53, -0x1p+0 },
+{ INT64_C(0x0028000002010000), 0x1.4000001008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdfeffff), -0x1.4000001008p+53, -0x1p+0 },
+{ INT64_C(0x0028000002080000), 0x1.400000104p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdf7ffff), -0x1.400000104p+53, -0x1p+0 },
+{ INT64_C(0x0028000002100000), 0x1.400000108p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffdefffff), -0x1.400000108p+53, -0x1p+0 },
+{ INT64_C(0x0028000002200000), 0x1.40000011p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffddfffff), -0x1.40000011p+53, -0x1p+0 },
+{ INT64_C(0x0028000003000000), 0x1.40000018p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffffcffffff), -0x1.40000018p+53, -0x1p+0 },
+{ INT64_C(0x0028000008000000), 0x1.4000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7ffffff), -0x1.4000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000008000008), 0x1.4000004000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7fffff7), -0x1.4000004000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000008000080), 0x1.400000400004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7ffff7f), -0x1.400000400004p+53, -0x1p+0 },
+{ INT64_C(0x0028000008000200), 0x1.40000040001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7fffdff), -0x1.40000040001p+53, -0x1p+0 },
+{ INT64_C(0x0028000008000400), 0x1.40000040002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7fffbff), -0x1.40000040002p+53, -0x1p+0 },
+{ INT64_C(0x0028000008001000), 0x1.40000040008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7ffefff), -0x1.40000040008p+53, -0x1p+0 },
+{ INT64_C(0x0028000008008000), 0x1.4000004004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7ff7fff), -0x1.4000004004p+53, -0x1p+0 },
+{ INT64_C(0x0028000008080000), 0x1.400000404p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7f7ffff), -0x1.400000404p+53, -0x1p+0 },
+{ INT64_C(0x0028000008400000), 0x1.40000042p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff7bfffff), -0x1.40000042p+53, -0x1p+0 },
+{ INT64_C(0x002800000a000000), 0x1.4000005p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff5ffffff), -0x1.4000005p+53, -0x1p+0 },
+{ INT64_C(0x002800000c000000), 0x1.4000006p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffff3ffffff), -0x1.4000006p+53, -0x1p+0 },
+{ INT64_C(0x0028000010000000), 0x1.4000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffefffffff), -0x1.4000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000010000008), 0x1.4000008000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffeffffff7), -0x1.4000008000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000010000040), 0x1.400000800002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffefffffbf), -0x1.400000800002p+53, -0x1p+0 },
+{ INT64_C(0x0028000010000400), 0x1.40000080002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffeffffbff), -0x1.40000080002p+53, -0x1p+0 },
+{ INT64_C(0x0028000010001000), 0x1.40000080008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffefffefff), -0x1.40000080008p+53, -0x1p+0 },
+{ INT64_C(0x0028000010004000), 0x1.4000008002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffefffbfff), -0x1.4000008002p+53, -0x1p+0 },
+{ INT64_C(0x0028000010040000), 0x1.400000802p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffeffbffff), -0x1.400000802p+53, -0x1p+0 },
+{ INT64_C(0x0028000010100000), 0x1.400000808p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffefefffff), -0x1.400000808p+53, -0x1p+0 },
+{ INT64_C(0x0028000010800000), 0x1.40000084p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffef7fffff), -0x1.40000084p+53, -0x1p+0 },
+{ INT64_C(0x0028000018000000), 0x1.400000cp+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffe7ffffff), -0x1.400000cp+53, -0x1p+0 },
+{ INT64_C(0x0028000020000000), 0x1.400001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdfffffff), -0x1.400001p+53, -0x1p+0 },
+{ INT64_C(0x0028000020000008), 0x1.4000010000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdffffff7), -0x1.4000010000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000020000080), 0x1.400001000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdfffff7f), -0x1.400001000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000020000200), 0x1.40000100001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdffffdff), -0x1.40000100001p+53, -0x1p+0 },
+{ INT64_C(0x0028000020000400), 0x1.40000100002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdffffbff), -0x1.40000100002p+53, -0x1p+0 },
+{ INT64_C(0x0028000020001000), 0x1.40000100008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdfffefff), -0x1.40000100008p+53, -0x1p+0 },
+{ INT64_C(0x0028000020002000), 0x1.4000010001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdfffdfff), -0x1.4000010001p+53, -0x1p+0 },
+{ INT64_C(0x0028000020020000), 0x1.400001001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdffdffff), -0x1.400001001p+53, -0x1p+0 },
+{ INT64_C(0x0028000020100000), 0x1.400001008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdfefffff), -0x1.400001008p+53, -0x1p+0 },
+{ INT64_C(0x0028000020800000), 0x1.40000104p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffdf7fffff), -0x1.40000104p+53, -0x1p+0 },
+{ INT64_C(0x0028000028000000), 0x1.4000014p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffffd7ffffff), -0x1.4000014p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000000), 0x1.400008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffeffffffff), -0x1.400008p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000002), 0x1.4000080000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefffffffd), -0x1.4000080000002p+53, 0x1p+0 },
+{ INT64_C(0x0028000100000008), 0x1.4000080000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefffffff7), -0x1.4000080000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000010), 0x1.4000080000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffeffffffef), -0x1.4000080000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000040), 0x1.400008000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffeffffffbf), -0x1.400008000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000200), 0x1.40000800001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefffffdff), -0x1.40000800001p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000400), 0x1.40000800002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefffffbff), -0x1.40000800002p+53, -0x1p+0 },
+{ INT64_C(0x0028000100000800), 0x1.40000800004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefffff7ff), -0x1.40000800004p+53, -0x1p+0 },
+{ INT64_C(0x0028000100004000), 0x1.4000080002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffeffffbfff), -0x1.4000080002p+53, -0x1p+0 },
+{ INT64_C(0x0028000100010000), 0x1.4000080008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefffeffff), -0x1.4000080008p+53, -0x1p+0 },
+{ INT64_C(0x0028000100080000), 0x1.400008004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefff7ffff), -0x1.400008004p+53, -0x1p+0 },
+{ INT64_C(0x0028000100100000), 0x1.400008008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffeffefffff), -0x1.400008008p+53, -0x1p+0 },
+{ INT64_C(0x0028000101000000), 0x1.40000808p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffefeffffff), -0x1.40000808p+53, -0x1p+0 },
+{ INT64_C(0x0028000108000000), 0x1.4000084p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffef7ffffff), -0x1.4000084p+53, -0x1p+0 },
+{ INT64_C(0x0028000120000000), 0x1.400009p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffedfffffff), -0x1.400009p+53, -0x1p+0 },
+{ INT64_C(0x0028000180000000), 0x1.40000cp+53, 0x0p+0 },
+{ INT64_C(0xffd7fffe7fffffff), -0x1.40000cp+53, -0x1p+0 },
+{ INT64_C(0x0028000200000000), 0x1.40001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffffffff), -0x1.40001p+53, -0x1p+0 },
+{ INT64_C(0x0028000200000001), 0x1.40001p+53, 0x1p+0 },
+{ INT64_C(0xffd7fffdfffffffe), -0x1.4000100000001p+53, 0x0p+0 },
+{ INT64_C(0x0028000200000002), 0x1.4000100000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdfffffffd), -0x1.4000100000002p+53, 0x1p+0 },
+{ INT64_C(0x0028000200000010), 0x1.4000100000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffffffef), -0x1.4000100000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000200000080), 0x1.400010000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffffff7f), -0x1.400010000004p+53, -0x1p+0 },
+{ INT64_C(0x0028000200000200), 0x1.40001000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdfffffdff), -0x1.40001000001p+53, -0x1p+0 },
+{ INT64_C(0x0028000200000400), 0x1.40001000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdfffffbff), -0x1.40001000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000200001000), 0x1.40001000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffffefff), -0x1.40001000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000200002000), 0x1.4000100001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffffdfff), -0x1.4000100001p+53, -0x1p+0 },
+{ INT64_C(0x0028000200008000), 0x1.4000100004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffff7fff), -0x1.4000100004p+53, -0x1p+0 },
+{ INT64_C(0x0028000200010000), 0x1.4000100008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdfffeffff), -0x1.4000100008p+53, -0x1p+0 },
+{ INT64_C(0x0028000200040000), 0x1.400010002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdfffbffff), -0x1.400010002p+53, -0x1p+0 },
+{ INT64_C(0x0028000200200000), 0x1.40001001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdffdfffff), -0x1.40001001p+53, -0x1p+0 },
+{ INT64_C(0x0028000201000000), 0x1.40001008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdfeffffff), -0x1.40001008p+53, -0x1p+0 },
+{ INT64_C(0x0028000208000000), 0x1.4000104p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffdf7ffffff), -0x1.4000104p+53, -0x1p+0 },
+{ INT64_C(0x0028000280000000), 0x1.400014p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffd7fffffff), -0x1.400014p+53, -0x1p+0 },
+{ INT64_C(0x0028000300000000), 0x1.400018p+53, 0x0p+0 },
+{ INT64_C(0xffd7fffcffffffff), -0x1.400018p+53, -0x1p+0 },
+{ INT64_C(0x0028000800000000), 0x1.40004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffffffff), -0x1.40004p+53, -0x1p+0 },
+{ INT64_C(0x0028000800000004), 0x1.4000400000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7fffffffb), -0x1.4000400000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000800000010), 0x1.4000400000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffffffef), -0x1.4000400000008p+53, -0x1p+0 },
+{ INT64_C(0x0028000800000020), 0x1.400040000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffffffdf), -0x1.400040000001p+53, -0x1p+0 },
+{ INT64_C(0x0028000800000040), 0x1.400040000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffffffbf), -0x1.400040000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000800000400), 0x1.40004000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7fffffbff), -0x1.40004000002p+53, -0x1p+0 },
+{ INT64_C(0x0028000800002000), 0x1.4000400001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffffdfff), -0x1.4000400001p+53, -0x1p+0 },
+{ INT64_C(0x0028000800020000), 0x1.400040001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7fffdffff), -0x1.400040001p+53, -0x1p+0 },
+{ INT64_C(0x0028000800100000), 0x1.400040008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffefffff), -0x1.400040008p+53, -0x1p+0 },
+{ INT64_C(0x0028000800400000), 0x1.40004002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7ffbfffff), -0x1.40004002p+53, -0x1p+0 },
+{ INT64_C(0x0028000802000000), 0x1.4000401p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7fdffffff), -0x1.4000401p+53, -0x1p+0 },
+{ INT64_C(0x0028000808000000), 0x1.4000404p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7f7ffffff), -0x1.4000404p+53, -0x1p+0 },
+{ INT64_C(0x0028000840000000), 0x1.400042p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff7bfffffff), -0x1.400042p+53, -0x1p+0 },
+{ INT64_C(0x0028000880000000), 0x1.400044p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff77fffffff), -0x1.400044p+53, -0x1p+0 },
+{ INT64_C(0x0028000900000000), 0x1.400048p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff6ffffffff), -0x1.400048p+53, -0x1p+0 },
+{ INT64_C(0x0028000a00000000), 0x1.40005p+53, 0x0p+0 },
+{ INT64_C(0xffd7fff5ffffffff), -0x1.40005p+53, -0x1p+0 },
+{ INT64_C(0x0028002000000000), 0x1.4001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdfffffffff), -0x1.4001p+53, -0x1p+0 },
+{ INT64_C(0x0028002000000008), 0x1.4001000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdffffffff7), -0x1.4001000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028002000000020), 0x1.400100000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdfffffffdf), -0x1.400100000001p+53, -0x1p+0 },
+{ INT64_C(0x0028002000000080), 0x1.400100000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdfffffff7f), -0x1.400100000004p+53, -0x1p+0 },
+{ INT64_C(0x0028002000000800), 0x1.40010000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdffffff7ff), -0x1.40010000004p+53, -0x1p+0 },
+{ INT64_C(0x0028002000004000), 0x1.4001000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdfffffbfff), -0x1.4001000002p+53, -0x1p+0 },
+{ INT64_C(0x0028002000020000), 0x1.400100001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdffffdffff), -0x1.400100001p+53, -0x1p+0 },
+{ INT64_C(0x0028002000200000), 0x1.40010001p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdfffdfffff), -0x1.40010001p+53, -0x1p+0 },
+{ INT64_C(0x0028002001000000), 0x1.40010008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdffeffffff), -0x1.40010008p+53, -0x1p+0 },
+{ INT64_C(0x0028002008000000), 0x1.4001004p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdff7ffffff), -0x1.4001004p+53, -0x1p+0 },
+{ INT64_C(0x0028002010000000), 0x1.4001008p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdfefffffff), -0x1.4001008p+53, -0x1p+0 },
+{ INT64_C(0x0028002100000000), 0x1.400108p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffdeffffffff), -0x1.400108p+53, -0x1p+0 },
+{ INT64_C(0x0028002800000000), 0x1.40014p+53, 0x0p+0 },
+{ INT64_C(0xffd7ffd7ffffffff), -0x1.40014p+53, -0x1p+0 },
+{ INT64_C(0x0028020000000000), 0x1.401p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffffffff), -0x1.401p+53, -0x1p+0 },
+{ INT64_C(0x0028020000000002), 0x1.4010000000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfffffffffd), -0x1.4010000000002p+53, 0x1p+0 },
+{ INT64_C(0x0028020000000008), 0x1.4010000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfffffffff7), -0x1.4010000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028020000000010), 0x1.4010000000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffffffef), -0x1.4010000000008p+53, -0x1p+0 },
+{ INT64_C(0x0028020000000080), 0x1.401000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffffff7f), -0x1.401000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028020000000200), 0x1.40100000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfffffffdff), -0x1.40100000001p+53, -0x1p+0 },
+{ INT64_C(0x0028020000002000), 0x1.4010000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffffdfff), -0x1.4010000001p+53, -0x1p+0 },
+{ INT64_C(0x0028020000008000), 0x1.4010000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffff7fff), -0x1.4010000004p+53, -0x1p+0 },
+{ INT64_C(0x0028020000020000), 0x1.401000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfffffdffff), -0x1.401000001p+53, -0x1p+0 },
+{ INT64_C(0x0028020000100000), 0x1.401000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffefffff), -0x1.401000008p+53, -0x1p+0 },
+{ INT64_C(0x0028020000200000), 0x1.40100001p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffffdfffff), -0x1.40100001p+53, -0x1p+0 },
+{ INT64_C(0x0028020001000000), 0x1.40100008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfffeffffff), -0x1.40100008p+53, -0x1p+0 },
+{ INT64_C(0x0028020004000000), 0x1.4010002p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfffbffffff), -0x1.4010002p+53, -0x1p+0 },
+{ INT64_C(0x0028020010000000), 0x1.4010008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdffefffffff), -0x1.4010008p+53, -0x1p+0 },
+{ INT64_C(0x0028020080000000), 0x1.401004p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdff7fffffff), -0x1.401004p+53, -0x1p+0 },
+{ INT64_C(0x0028020100000000), 0x1.401008p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdfeffffffff), -0x1.401008p+53, -0x1p+0 },
+{ INT64_C(0x0028021000000000), 0x1.40108p+53, 0x0p+0 },
+{ INT64_C(0xffd7fdefffffffff), -0x1.40108p+53, -0x1p+0 },
+{ INT64_C(0x0028022000000000), 0x1.4011p+53, 0x0p+0 },
+{ INT64_C(0xffd7fddfffffffff), -0x1.4011p+53, -0x1p+0 },
+{ INT64_C(0x0028028000000000), 0x1.4014p+53, 0x0p+0 },
+{ INT64_C(0xffd7fd7fffffffff), -0x1.4014p+53, -0x1p+0 },
+{ INT64_C(0x0028080000000000), 0x1.404p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7ffffffffff), -0x1.404p+53, -0x1p+0 },
+{ INT64_C(0x0028080000000004), 0x1.4040000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fffffffffb), -0x1.4040000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028080000000008), 0x1.4040000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fffffffff7), -0x1.4040000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028080000000040), 0x1.404000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7ffffffffbf), -0x1.404000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028080000000200), 0x1.40400000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fffffffdff), -0x1.40400000001p+53, -0x1p+0 },
+{ INT64_C(0x0028080000001000), 0x1.40400000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7ffffffefff), -0x1.40400000008p+53, -0x1p+0 },
+{ INT64_C(0x0028080000008000), 0x1.4040000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7ffffff7fff), -0x1.4040000004p+53, -0x1p+0 },
+{ INT64_C(0x0028080000010000), 0x1.4040000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fffffeffff), -0x1.4040000008p+53, -0x1p+0 },
+{ INT64_C(0x0028080000080000), 0x1.404000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fffff7ffff), -0x1.404000004p+53, -0x1p+0 },
+{ INT64_C(0x0028080000800000), 0x1.40400004p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7ffff7fffff), -0x1.40400004p+53, -0x1p+0 },
+{ INT64_C(0x0028080008000000), 0x1.4040004p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fff7ffffff), -0x1.4040004p+53, -0x1p+0 },
+{ INT64_C(0x0028080080000000), 0x1.404004p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7ff7fffffff), -0x1.404004p+53, -0x1p+0 },
+{ INT64_C(0x0028080400000000), 0x1.40402p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7fbffffffff), -0x1.40402p+53, -0x1p+0 },
+{ INT64_C(0x0028082000000000), 0x1.4041p+53, 0x0p+0 },
+{ INT64_C(0xffd7f7dfffffffff), -0x1.4041p+53, -0x1p+0 },
+{ INT64_C(0x0028088000000000), 0x1.4044p+53, 0x0p+0 },
+{ INT64_C(0xffd7f77fffffffff), -0x1.4044p+53, -0x1p+0 },
+{ INT64_C(0x00280a0000000000), 0x1.405p+53, 0x0p+0 },
+{ INT64_C(0xffd7f5ffffffffff), -0x1.405p+53, -0x1p+0 },
+{ INT64_C(0x0028200000000000), 0x1.41p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfffffffffff), -0x1.41p+53, -0x1p+0 },
+{ INT64_C(0x0028200000000002), 0x1.4100000000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffffffffd), -0x1.4100000000002p+53, 0x1p+0 },
+{ INT64_C(0x0028200000000004), 0x1.4100000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffffffffb), -0x1.4100000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028200000000008), 0x1.4100000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffffffff7), -0x1.4100000000004p+53, -0x1p+0 },
+{ INT64_C(0x0028200000000040), 0x1.410000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfffffffffbf), -0x1.410000000002p+53, -0x1p+0 },
+{ INT64_C(0x0028200000000200), 0x1.41000000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffffffdff), -0x1.41000000001p+53, -0x1p+0 },
+{ INT64_C(0x0028200000002000), 0x1.4100000001p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfffffffdfff), -0x1.4100000001p+53, -0x1p+0 },
+{ INT64_C(0x0028200000004000), 0x1.4100000002p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfffffffbfff), -0x1.4100000002p+53, -0x1p+0 },
+{ INT64_C(0x0028200000010000), 0x1.4100000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffffeffff), -0x1.4100000008p+53, -0x1p+0 },
+{ INT64_C(0x0028200000100000), 0x1.410000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfffffefffff), -0x1.410000008p+53, -0x1p+0 },
+{ INT64_C(0x0028200001000000), 0x1.41000008p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffeffffff), -0x1.41000008p+53, -0x1p+0 },
+{ INT64_C(0x0028200002000000), 0x1.4100001p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffffdffffff), -0x1.4100001p+53, -0x1p+0 },
+{ INT64_C(0x0028200010000000), 0x1.4100008p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfffefffffff), -0x1.4100008p+53, -0x1p+0 },
+{ INT64_C(0x0028200100000000), 0x1.410008p+53, 0x0p+0 },
+{ INT64_C(0xffd7dffeffffffff), -0x1.410008p+53, -0x1p+0 },
+{ INT64_C(0x0028200800000000), 0x1.41004p+53, 0x0p+0 },
+{ INT64_C(0xffd7dff7ffffffff), -0x1.41004p+53, -0x1p+0 },
+{ INT64_C(0x0028202000000000), 0x1.4101p+53, 0x0p+0 },
+{ INT64_C(0xffd7dfdfffffffff), -0x1.4101p+53, -0x1p+0 },
+{ INT64_C(0x0028210000000000), 0x1.4108p+53, 0x0p+0 },
+{ INT64_C(0xffd7deffffffffff), -0x1.4108p+53, -0x1p+0 },
+{ INT64_C(0x0028300000000000), 0x1.418p+53, 0x0p+0 },
+{ INT64_C(0xffd7cfffffffffff), -0x1.418p+53, -0x1p+0 },
+{ INT64_C(0x002a000000000000), 0x1.5p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffffffffff), -0x1.5p+53, -0x1p+0 },
+{ INT64_C(0x002a000000000008), 0x1.5000000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffffffffff7), -0x1.5000000000004p+53, -0x1p+0 },
+{ INT64_C(0x002a000000000080), 0x1.500000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffffffff7f), -0x1.500000000004p+53, -0x1p+0 },
+{ INT64_C(0x002a000000000800), 0x1.50000000004p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffffffff7ff), -0x1.50000000004p+53, -0x1p+0 },
+{ INT64_C(0x002a000000004000), 0x1.5000000002p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffffffbfff), -0x1.5000000002p+53, -0x1p+0 },
+{ INT64_C(0x002a000000010000), 0x1.5000000008p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffffffeffff), -0x1.5000000008p+53, -0x1p+0 },
+{ INT64_C(0x002a000000020000), 0x1.500000001p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffffffdffff), -0x1.500000001p+53, -0x1p+0 },
+{ INT64_C(0x002a000000100000), 0x1.500000008p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffffefffff), -0x1.500000008p+53, -0x1p+0 },
+{ INT64_C(0x002a000000200000), 0x1.50000001p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffffdfffff), -0x1.50000001p+53, -0x1p+0 },
+{ INT64_C(0x002a000000400000), 0x1.50000002p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffffbfffff), -0x1.50000002p+53, -0x1p+0 },
+{ INT64_C(0x002a000002000000), 0x1.5000001p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffffdffffff), -0x1.5000001p+53, -0x1p+0 },
+{ INT64_C(0x002a000008000000), 0x1.5000004p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffff7ffffff), -0x1.5000004p+53, -0x1p+0 },
+{ INT64_C(0x002a000040000000), 0x1.500002p+53, 0x0p+0 },
+{ INT64_C(0xffd5ffffbfffffff), -0x1.500002p+53, -0x1p+0 },
+{ INT64_C(0x002a000200000000), 0x1.50001p+53, 0x0p+0 },
+{ INT64_C(0xffd5fffdffffffff), -0x1.50001p+53, -0x1p+0 },
+{ INT64_C(0x002a000800000000), 0x1.50004p+53, 0x0p+0 },
+{ INT64_C(0xffd5fff7ffffffff), -0x1.50004p+53, -0x1p+0 },
+{ INT64_C(0x002a008000000000), 0x1.5004p+53, 0x0p+0 },
+{ INT64_C(0xffd5ff7fffffffff), -0x1.5004p+53, -0x1p+0 },
+{ INT64_C(0x002a020000000000), 0x1.501p+53, 0x0p+0 },
+{ INT64_C(0xffd5fdffffffffff), -0x1.501p+53, -0x1p+0 },
+{ INT64_C(0x002a200000000000), 0x1.51p+53, 0x0p+0 },
+{ INT64_C(0xffd5dfffffffffff), -0x1.51p+53, -0x1p+0 },
+{ INT64_C(0x002a800000000000), 0x1.54p+53, 0x0p+0 },
+{ INT64_C(0xffd57fffffffffff), -0x1.54p+53, -0x1p+0 },
+{ INT64_C(0x002b000000000000), 0x1.58p+53, 0x0p+0 },
+{ INT64_C(0xffd4ffffffffffff), -0x1.58p+53, -0x1p+0 },
+{ INT64_C(0x0200000000000022), 0x1.0000000000001p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffffffdd), -0x1.0000000000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000000023), 0x1.0000000000001p+57, 0x1.8p+1 },
+{ INT64_C(0xfdffffffffffffdc), -0x1.0000000000001p+57, -0x1p+2 },
+{ INT64_C(0x0200000000000028), 0x1.0000000000001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffffffd7), -0x1.0000000000001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000000029), 0x1.0000000000001p+57, 0x1.2p+3 },
+{ INT64_C(0xfdffffffffffffd6), -0x1.0000000000001p+57, -0x1.4p+3 },
+{ INT64_C(0x020000000000002c), 0x1.0000000000001p+57, 0x1.8p+3 },
+{ INT64_C(0xfdffffffffffffd3), -0x1.0000000000001p+57, -0x1.ap+3 },
+{ INT64_C(0x0200000000000104), 0x1.0000000000008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffffffefb), -0x1.0000000000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000000140), 0x1.000000000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffffebf), -0x1.000000000000ap+57, -0x1p+0 },
+{ INT64_C(0x0200000000000141), 0x1.000000000000ap+57, 0x1p+0 },
+{ INT64_C(0xfdfffffffffffebe), -0x1.000000000000ap+57, -0x1p+1 },
+{ INT64_C(0x0200000000000144), 0x1.000000000000ap+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffffffebb), -0x1.000000000000ap+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000000148), 0x1.000000000000ap+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffffffeb7), -0x1.000000000000ap+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000000150), 0x1.000000000000ap+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffffffeaf), -0x1.000000000000bp+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000001004), 0x1.000000000008p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffffeffb), -0x1.000000000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000001005), 0x1.000000000008p+57, 0x1.4p+2 },
+{ INT64_C(0xfdffffffffffeffa), -0x1.000000000008p+57, -0x1.8p+2 },
+{ INT64_C(0x0200000000001010), 0x1.000000000008p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffffffefef), -0x1.0000000000081p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000001018), 0x1.0000000000081p+57, -0x1p+3 },
+{ INT64_C(0xfdffffffffffefe7), -0x1.0000000000081p+57, 0x1.cp+2 },
+{ INT64_C(0x0200000000001040), 0x1.0000000000082p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffefbf), -0x1.0000000000082p+57, -0x1p+0 },
+{ INT64_C(0x0200000000001041), 0x1.0000000000082p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffffffefbe), -0x1.0000000000082p+57, -0x1p+1 },
+{ INT64_C(0x0200000000001042), 0x1.0000000000082p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffffefbd), -0x1.0000000000082p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000001050), 0x1.0000000000082p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffffffefaf), -0x1.0000000000083p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000001080), 0x1.0000000000084p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffef7f), -0x1.0000000000084p+57, -0x1p+0 },
+{ INT64_C(0x0200000000001081), 0x1.0000000000084p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffffffef7e), -0x1.0000000000084p+57, -0x1p+1 },
+{ INT64_C(0x0200000000001088), 0x1.0000000000084p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffffef77), -0x1.0000000000084p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000001200), 0x1.000000000009p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffedff), -0x1.000000000009p+57, -0x1p+0 },
+{ INT64_C(0x0200000000001202), 0x1.000000000009p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffffedfd), -0x1.000000000009p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000001208), 0x1.000000000009p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffffedf7), -0x1.000000000009p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000001240), 0x1.0000000000092p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffedbf), -0x1.0000000000092p+57, -0x1p+0 },
+{ INT64_C(0x0200000000001800), 0x1.00000000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffe7ff), -0x1.00000000000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000000001804), 0x1.00000000000cp+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffffe7fb), -0x1.00000000000cp+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000001810), 0x1.00000000000cp+57, 0x1p+4 },
+{ INT64_C(0xfdffffffffffe7ef), -0x1.00000000000c1p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000001820), 0x1.00000000000c1p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffe7df), -0x1.00000000000c1p+57, -0x1p+0 },
+{ INT64_C(0x0200000000001900), 0x1.00000000000c8p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffe6ff), -0x1.00000000000c8p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004002), 0x1.00000000002p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffffbffd), -0x1.00000000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000004004), 0x1.00000000002p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffffbffb), -0x1.00000000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000004040), 0x1.0000000000202p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffbfbf), -0x1.0000000000202p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004041), 0x1.0000000000202p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffffffbfbe), -0x1.0000000000202p+57, -0x1p+1 },
+{ INT64_C(0x0200000000004050), 0x1.0000000000202p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffffffbfaf), -0x1.0000000000203p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000004080), 0x1.0000000000204p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffbf7f), -0x1.0000000000204p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004081), 0x1.0000000000204p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffffffbf7e), -0x1.0000000000204p+57, -0x1p+1 },
+{ INT64_C(0x0200000000004082), 0x1.0000000000204p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffffbf7d), -0x1.0000000000204p+57, -0x1.8p+1 },
+{ INT64_C(0x02000000000040a0), 0x1.0000000000205p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffbf5f), -0x1.0000000000205p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004400), 0x1.000000000022p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffbbff), -0x1.000000000022p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004404), 0x1.000000000022p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffffbbfb), -0x1.000000000022p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000004408), 0x1.000000000022p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffffbbf7), -0x1.000000000022p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000004420), 0x1.0000000000221p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffbbdf), -0x1.0000000000221p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004440), 0x1.0000000000222p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffbbbf), -0x1.0000000000222p+57, -0x1p+0 },
+{ INT64_C(0x0200000000004600), 0x1.000000000023p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffffb9ff), -0x1.000000000023p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040002), 0x1.0000000002p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffffffbfffd), -0x1.0000000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000040008), 0x1.0000000002p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffffbfff7), -0x1.0000000002p+57, -0x1.2p+3 },
+{ INT64_C(0x020000000004000c), 0x1.0000000002p+57, 0x1.8p+3 },
+{ INT64_C(0xfdfffffffffbfff3), -0x1.0000000002p+57, -0x1.ap+3 },
+{ INT64_C(0x0200000000040040), 0x1.0000000002002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbffbf), -0x1.0000000002002p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040042), 0x1.0000000002002p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffffffbffbd), -0x1.0000000002002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000040044), 0x1.0000000002002p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffffbffbb), -0x1.0000000002002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000040048), 0x1.0000000002002p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffffbffb7), -0x1.0000000002002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000040050), 0x1.0000000002002p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffffbffaf), -0x1.0000000002003p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000040200), 0x1.000000000201p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbfdff), -0x1.000000000201p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040208), 0x1.000000000201p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffffbfdf7), -0x1.000000000201p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000040220), 0x1.0000000002011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbfddf), -0x1.0000000002011p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040280), 0x1.0000000002014p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbfd7f), -0x1.0000000002014p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040300), 0x1.0000000002018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbfcff), -0x1.0000000002018p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040400), 0x1.000000000202p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbfbff), -0x1.000000000202p+57, -0x1p+0 },
+{ INT64_C(0x0200000000040404), 0x1.000000000202p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffffbfbfb), -0x1.000000000202p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000040410), 0x1.000000000202p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffffbfbef), -0x1.0000000002021p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000040500), 0x1.0000000002028p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbfaff), -0x1.0000000002028p+57, -0x1p+0 },
+{ INT64_C(0x0200000000042000), 0x1.00000000021p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbdfff), -0x1.00000000021p+57, -0x1p+0 },
+{ INT64_C(0x0200000000042002), 0x1.00000000021p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffffffbdffd), -0x1.00000000021p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000042004), 0x1.00000000021p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffffbdffb), -0x1.00000000021p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000042040), 0x1.0000000002102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbdfbf), -0x1.0000000002102p+57, -0x1p+0 },
+{ INT64_C(0x0200000000042400), 0x1.000000000212p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffbdbff), -0x1.000000000212p+57, -0x1p+0 },
+{ INT64_C(0x0200000000048000), 0x1.00000000024p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffb7fff), -0x1.00000000024p+57, -0x1p+0 },
+{ INT64_C(0x0200000000048004), 0x1.00000000024p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffffb7ffb), -0x1.00000000024p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000048040), 0x1.0000000002402p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffb7fbf), -0x1.0000000002402p+57, -0x1p+0 },
+{ INT64_C(0x0200000000048100), 0x1.0000000002408p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffb7eff), -0x1.0000000002408p+57, -0x1p+0 },
+{ INT64_C(0x0200000000049000), 0x1.000000000248p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffb6fff), -0x1.000000000248p+57, -0x1p+0 },
+{ INT64_C(0x020000000004a000), 0x1.00000000025p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffb5fff), -0x1.00000000025p+57, -0x1p+0 },
+{ INT64_C(0x020000000004c000), 0x1.00000000026p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffffb3fff), -0x1.00000000026p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200004), 0x1.000000001p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffdffffb), -0x1.000000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000200005), 0x1.000000001p+57, 0x1.4p+2 },
+{ INT64_C(0xfdffffffffdffffa), -0x1.000000001p+57, -0x1.8p+2 },
+{ INT64_C(0x0200000000200006), 0x1.000000001p+57, 0x1.8p+2 },
+{ INT64_C(0xfdffffffffdffff9), -0x1.000000001p+57, -0x1.cp+2 },
+{ INT64_C(0x0200000000200040), 0x1.0000000010002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdfffbf), -0x1.0000000010002p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200044), 0x1.0000000010002p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffdfffbb), -0x1.0000000010002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000200048), 0x1.0000000010002p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffdfffb7), -0x1.0000000010002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000200060), 0x1.0000000010003p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdfff9f), -0x1.0000000010003p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200200), 0x1.000000001001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdffdff), -0x1.000000001001p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200202), 0x1.000000001001p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffdffdfd), -0x1.000000001001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000200208), 0x1.000000001001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffdffdf7), -0x1.000000001001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000200240), 0x1.0000000010012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdffdbf), -0x1.0000000010012p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200300), 0x1.0000000010018p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdffcff), -0x1.0000000010018p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200800), 0x1.000000001004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdff7ff), -0x1.000000001004p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200802), 0x1.000000001004p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffdff7fd), -0x1.000000001004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000200810), 0x1.000000001004p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffffdff7ef), -0x1.0000000010041p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000200820), 0x1.0000000010041p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdff7df), -0x1.0000000010041p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200a00), 0x1.000000001005p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdff5ff), -0x1.000000001005p+57, -0x1p+0 },
+{ INT64_C(0x0200000000200c00), 0x1.000000001006p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdff3ff), -0x1.000000001006p+57, -0x1p+0 },
+{ INT64_C(0x0200000000208000), 0x1.00000000104p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdf7fff), -0x1.00000000104p+57, -0x1p+0 },
+{ INT64_C(0x0200000000208002), 0x1.00000000104p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffdf7ffd), -0x1.00000000104p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000208004), 0x1.00000000104p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffdf7ffb), -0x1.00000000104p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000208010), 0x1.00000000104p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffffdf7fef), -0x1.0000000010401p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000208100), 0x1.0000000010408p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdf7eff), -0x1.0000000010408p+57, -0x1p+0 },
+{ INT64_C(0x0200000000209000), 0x1.000000001048p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdf6fff), -0x1.000000001048p+57, -0x1p+0 },
+{ INT64_C(0x020000000020a000), 0x1.00000000105p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdf5fff), -0x1.00000000105p+57, -0x1p+0 },
+{ INT64_C(0x0200000000210000), 0x1.00000000108p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdeffff), -0x1.00000000108p+57, -0x1p+0 },
+{ INT64_C(0x0200000000210002), 0x1.00000000108p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffffdefffd), -0x1.00000000108p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000210004), 0x1.00000000108p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffffdefffb), -0x1.00000000108p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000210020), 0x1.0000000010801p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdeffdf), -0x1.0000000010801p+57, -0x1p+0 },
+{ INT64_C(0x0200000000210200), 0x1.000000001081p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdefdff), -0x1.000000001081p+57, -0x1p+0 },
+{ INT64_C(0x0200000000210400), 0x1.000000001082p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdefbff), -0x1.000000001082p+57, -0x1p+0 },
+{ INT64_C(0x0200000000211000), 0x1.000000001088p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffdeefff), -0x1.000000001088p+57, -0x1p+0 },
+{ INT64_C(0x0200000000300000), 0x1.0000000018p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffcfffff), -0x1.0000000018p+57, -0x1p+0 },
+{ INT64_C(0x0200000000300008), 0x1.0000000018p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffffcffff7), -0x1.0000000018p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000300080), 0x1.0000000018004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffcfff7f), -0x1.0000000018004p+57, -0x1p+0 },
+{ INT64_C(0x0200000000300400), 0x1.000000001802p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffcffbff), -0x1.000000001802p+57, -0x1p+0 },
+{ INT64_C(0x0200000000304000), 0x1.00000000182p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffcfbfff), -0x1.00000000182p+57, -0x1p+0 },
+{ INT64_C(0x0200000000310000), 0x1.00000000188p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffceffff), -0x1.00000000188p+57, -0x1p+0 },
+{ INT64_C(0x0200000000320000), 0x1.0000000019p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffffcdffff), -0x1.0000000019p+57, -0x1p+0 },
+{ INT64_C(0x0200000000800004), 0x1.000000004p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffff7ffffb), -0x1.000000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000800006), 0x1.000000004p+57, 0x1.8p+2 },
+{ INT64_C(0xfdffffffff7ffff9), -0x1.000000004p+57, -0x1.cp+2 },
+{ INT64_C(0x0200000000800008), 0x1.000000004p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffff7ffff7), -0x1.000000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000800040), 0x1.0000000040002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fffbf), -0x1.0000000040002p+57, -0x1p+0 },
+{ INT64_C(0x0200000000800041), 0x1.0000000040002p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffff7fffbe), -0x1.0000000040002p+57, -0x1p+1 },
+{ INT64_C(0x0200000000800042), 0x1.0000000040002p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffff7fffbd), -0x1.0000000040002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000800044), 0x1.0000000040002p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffff7fffbb), -0x1.0000000040002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000800050), 0x1.0000000040002p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffff7fffaf), -0x1.0000000040003p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000800200), 0x1.000000004001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7ffdff), -0x1.000000004001p+57, -0x1p+0 },
+{ INT64_C(0x0200000000800208), 0x1.000000004001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffff7ffdf7), -0x1.000000004001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000800210), 0x1.000000004001p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffff7ffdef), -0x1.0000000040011p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000800300), 0x1.0000000040018p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7ffcff), -0x1.0000000040018p+57, -0x1p+0 },
+{ INT64_C(0x0200000000800800), 0x1.000000004004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7ff7ff), -0x1.000000004004p+57, -0x1p+0 },
+{ INT64_C(0x0200000000800808), 0x1.000000004004p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffff7ff7f7), -0x1.000000004004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000800810), 0x1.000000004004p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffff7ff7ef), -0x1.0000000040041p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000800900), 0x1.0000000040048p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7ff6ff), -0x1.0000000040048p+57, -0x1p+0 },
+{ INT64_C(0x0200000000801000), 0x1.000000004008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fefff), -0x1.000000004008p+57, -0x1p+0 },
+{ INT64_C(0x0200000000801004), 0x1.000000004008p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffff7feffb), -0x1.000000004008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000801010), 0x1.000000004008p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffff7fefef), -0x1.0000000040081p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000801100), 0x1.0000000040088p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7feeff), -0x1.0000000040088p+57, -0x1p+0 },
+{ INT64_C(0x0200000000801800), 0x1.00000000400cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fe7ff), -0x1.00000000400cp+57, -0x1p+0 },
+{ INT64_C(0x0200000000804000), 0x1.00000000402p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fbfff), -0x1.00000000402p+57, -0x1p+0 },
+{ INT64_C(0x0200000000804002), 0x1.00000000402p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffff7fbffd), -0x1.00000000402p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000804010), 0x1.00000000402p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffff7fbfef), -0x1.0000000040201p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000000804040), 0x1.0000000040202p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fbfbf), -0x1.0000000040202p+57, -0x1p+0 },
+{ INT64_C(0x0200000000804100), 0x1.0000000040208p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fbeff), -0x1.0000000040208p+57, -0x1p+0 },
+{ INT64_C(0x0200000000804400), 0x1.000000004022p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7fbbff), -0x1.000000004022p+57, -0x1p+0 },
+{ INT64_C(0x0200000000806000), 0x1.00000000403p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7f9fff), -0x1.00000000403p+57, -0x1p+0 },
+{ INT64_C(0x0200000000820000), 0x1.0000000041p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7dffff), -0x1.0000000041p+57, -0x1p+0 },
+{ INT64_C(0x0200000000820001), 0x1.0000000041p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffff7dfffe), -0x1.0000000041p+57, -0x1p+1 },
+{ INT64_C(0x0200000000820004), 0x1.0000000041p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffff7dfffb), -0x1.0000000041p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000820040), 0x1.0000000041002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7dffbf), -0x1.0000000041002p+57, -0x1p+0 },
+{ INT64_C(0x0200000000820400), 0x1.000000004102p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7dfbff), -0x1.000000004102p+57, -0x1p+0 },
+{ INT64_C(0x0200000000822000), 0x1.00000000411p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7ddfff), -0x1.00000000411p+57, -0x1p+0 },
+{ INT64_C(0x0200000000840000), 0x1.0000000042p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7bffff), -0x1.0000000042p+57, -0x1p+0 },
+{ INT64_C(0x0200000000840004), 0x1.0000000042p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffff7bfffb), -0x1.0000000042p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000000840020), 0x1.0000000042001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7bffdf), -0x1.0000000042001p+57, -0x1p+0 },
+{ INT64_C(0x0200000000840100), 0x1.0000000042008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7bfeff), -0x1.0000000042008p+57, -0x1p+0 },
+{ INT64_C(0x0200000000841000), 0x1.000000004208p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7befff), -0x1.000000004208p+57, -0x1p+0 },
+{ INT64_C(0x0200000000844000), 0x1.00000000422p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff7bbfff), -0x1.00000000422p+57, -0x1p+0 },
+{ INT64_C(0x0200000000860000), 0x1.0000000043p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff79ffff), -0x1.0000000043p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c00000), 0x1.000000006p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3fffff), -0x1.000000006p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c00002), 0x1.000000006p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffff3ffffd), -0x1.000000006p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000000c00008), 0x1.000000006p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffff3ffff7), -0x1.000000006p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000000c00020), 0x1.0000000060001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3fffdf), -0x1.0000000060001p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c00100), 0x1.0000000060008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3ffeff), -0x1.0000000060008p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c00200), 0x1.000000006001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3ffdff), -0x1.000000006001p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c00800), 0x1.000000006004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3ff7ff), -0x1.000000006004p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c08000), 0x1.00000000604p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3f7fff), -0x1.00000000604p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c10000), 0x1.00000000608p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3effff), -0x1.00000000608p+57, -0x1p+0 },
+{ INT64_C(0x0200000000c40000), 0x1.0000000062p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff3bffff), -0x1.0000000062p+57, -0x1p+0 },
+{ INT64_C(0x0200000000e00000), 0x1.000000007p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffff1fffff), -0x1.000000007p+57, -0x1p+0 },
+{ INT64_C(0x0200000002000004), 0x1.00000001p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffdfffffb), -0x1.00000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000002000008), 0x1.00000001p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffdfffff7), -0x1.00000001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000002000020), 0x1.0000000100001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdffffdf), -0x1.0000000100001p+57, -0x1p+0 },
+{ INT64_C(0x0200000002000022), 0x1.0000000100001p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffffdffffdd), -0x1.0000000100001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000002000100), 0x1.0000000100008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfffeff), -0x1.0000000100008p+57, -0x1p+0 },
+{ INT64_C(0x0200000002000104), 0x1.0000000100008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffdfffefb), -0x1.0000000100008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000002000120), 0x1.0000000100009p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfffedf), -0x1.0000000100009p+57, -0x1p+0 },
+{ INT64_C(0x0200000002000180), 0x1.000000010000cp+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfffe7f), -0x1.000000010000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000002001000), 0x1.000000010008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdffefff), -0x1.000000010008p+57, -0x1p+0 },
+{ INT64_C(0x0200000002001002), 0x1.000000010008p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffffdffeffd), -0x1.000000010008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000002001010), 0x1.000000010008p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffdffefef), -0x1.0000000100081p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000002001040), 0x1.0000000100082p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdffefbf), -0x1.0000000100082p+57, -0x1p+0 },
+{ INT64_C(0x0200000002001200), 0x1.000000010009p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdffedff), -0x1.000000010009p+57, -0x1p+0 },
+{ INT64_C(0x0200000002008000), 0x1.00000001004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdff7fff), -0x1.00000001004p+57, -0x1p+0 },
+{ INT64_C(0x0200000002008008), 0x1.00000001004p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffdff7ff7), -0x1.00000001004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000002008010), 0x1.00000001004p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffdff7fef), -0x1.0000000100401p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000002008080), 0x1.0000000100404p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdff7f7f), -0x1.0000000100404p+57, -0x1p+0 },
+{ INT64_C(0x0200000002008100), 0x1.0000000100408p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdff7eff), -0x1.0000000100408p+57, -0x1p+0 },
+{ INT64_C(0x0200000002009000), 0x1.000000010048p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdff6fff), -0x1.000000010048p+57, -0x1p+0 },
+{ INT64_C(0x0200000002040000), 0x1.0000000102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfbffff), -0x1.0000000102p+57, -0x1p+0 },
+{ INT64_C(0x0200000002040001), 0x1.0000000102p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffffdfbfffe), -0x1.0000000102p+57, -0x1p+1 },
+{ INT64_C(0x0200000002040004), 0x1.0000000102p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffffdfbfffb), -0x1.0000000102p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000002040010), 0x1.0000000102p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffdfbffef), -0x1.0000000102001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000002040040), 0x1.0000000102002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfbffbf), -0x1.0000000102002p+57, -0x1p+0 },
+{ INT64_C(0x0200000002040400), 0x1.000000010202p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfbfbff), -0x1.000000010202p+57, -0x1p+0 },
+{ INT64_C(0x0200000002040800), 0x1.000000010204p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfbf7ff), -0x1.000000010204p+57, -0x1p+0 },
+{ INT64_C(0x0200000002042000), 0x1.00000001021p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdfbdfff), -0x1.00000001021p+57, -0x1p+0 },
+{ INT64_C(0x0200000002060000), 0x1.0000000103p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdf9ffff), -0x1.0000000103p+57, -0x1p+0 },
+{ INT64_C(0x0200000002200000), 0x1.000000011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffddfffff), -0x1.000000011p+57, -0x1p+0 },
+{ INT64_C(0x0200000002200008), 0x1.000000011p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffddffff7), -0x1.000000011p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000002200080), 0x1.0000000110004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffddfff7f), -0x1.0000000110004p+57, -0x1p+0 },
+{ INT64_C(0x0200000002200400), 0x1.000000011002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffddffbff), -0x1.000000011002p+57, -0x1p+0 },
+{ INT64_C(0x0200000002201000), 0x1.000000011008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffddfefff), -0x1.000000011008p+57, -0x1p+0 },
+{ INT64_C(0x0200000002204000), 0x1.00000001102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffddfbfff), -0x1.00000001102p+57, -0x1p+0 },
+{ INT64_C(0x0200000002220000), 0x1.0000000111p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdddffff), -0x1.0000000111p+57, -0x1p+0 },
+{ INT64_C(0x0200000002280000), 0x1.0000000114p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffdd7ffff), -0x1.0000000114p+57, -0x1p+0 },
+{ INT64_C(0x0200000003000000), 0x1.000000018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcffffff), -0x1.000000018p+57, -0x1p+0 },
+{ INT64_C(0x0200000003000001), 0x1.000000018p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffffcfffffe), -0x1.000000018p+57, -0x1p+1 },
+{ INT64_C(0x0200000003000002), 0x1.000000018p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffffcfffffd), -0x1.000000018p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000003000008), 0x1.000000018p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffffcfffff7), -0x1.000000018p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000003000010), 0x1.000000018p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffffcffffef), -0x1.0000000180001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000003000080), 0x1.0000000180004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcffff7f), -0x1.0000000180004p+57, -0x1p+0 },
+{ INT64_C(0x0200000003000200), 0x1.000000018001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcfffdff), -0x1.000000018001p+57, -0x1p+0 },
+{ INT64_C(0x0200000003000800), 0x1.000000018004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcfff7ff), -0x1.000000018004p+57, -0x1p+0 },
+{ INT64_C(0x0200000003001000), 0x1.000000018008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcffefff), -0x1.000000018008p+57, -0x1p+0 },
+{ INT64_C(0x0200000003004000), 0x1.00000001802p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcffbfff), -0x1.00000001802p+57, -0x1p+0 },
+{ INT64_C(0x0200000003040000), 0x1.0000000182p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcfbffff), -0x1.0000000182p+57, -0x1p+0 },
+{ INT64_C(0x0200000003100000), 0x1.0000000188p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcefffff), -0x1.0000000188p+57, -0x1p+0 },
+{ INT64_C(0x0200000003200000), 0x1.000000019p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffffcdfffff), -0x1.000000019p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000004), 0x1.00000004p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffff7fffffb), -0x1.00000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000008000020), 0x1.0000000400001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffffdf), -0x1.0000000400001p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000021), 0x1.0000000400001p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffff7ffffde), -0x1.0000000400001p+57, -0x1p+1 },
+{ INT64_C(0x0200000008000024), 0x1.0000000400001p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffff7ffffdb), -0x1.0000000400001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000008000028), 0x1.0000000400001p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffff7ffffd7), -0x1.0000000400001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000008000030), 0x1.0000000400002p+57, -0x1p+4 },
+{ INT64_C(0xfdfffffff7ffffcf), -0x1.0000000400002p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000008000080), 0x1.0000000400004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffff7f), -0x1.0000000400004p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000081), 0x1.0000000400004p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffff7ffff7e), -0x1.0000000400004p+57, -0x1p+1 },
+{ INT64_C(0x0200000008000082), 0x1.0000000400004p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffff7ffff7d), -0x1.0000000400004p+57, -0x1.8p+1 },
+{ INT64_C(0x02000000080000a0), 0x1.0000000400005p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffff5f), -0x1.0000000400005p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000200), 0x1.000000040001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fffdff), -0x1.000000040001p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000201), 0x1.000000040001p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffff7fffdfe), -0x1.000000040001p+57, -0x1p+1 },
+{ INT64_C(0x0200000008000208), 0x1.000000040001p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffff7fffdf7), -0x1.000000040001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000008000280), 0x1.0000000400014p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fffd7f), -0x1.0000000400014p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000800), 0x1.000000040004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fff7ff), -0x1.000000040004p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000801), 0x1.000000040004p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffff7fff7fe), -0x1.000000040004p+57, -0x1p+1 },
+{ INT64_C(0x0200000008000804), 0x1.000000040004p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffff7fff7fb), -0x1.000000040004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000008000808), 0x1.000000040004p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffff7fff7f7), -0x1.000000040004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000008000880), 0x1.0000000400044p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fff77f), -0x1.0000000400044p+57, -0x1p+0 },
+{ INT64_C(0x0200000008000c00), 0x1.000000040006p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fff3ff), -0x1.000000040006p+57, -0x1p+0 },
+{ INT64_C(0x0200000008002000), 0x1.00000004001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffdfff), -0x1.00000004001p+57, -0x1p+0 },
+{ INT64_C(0x0200000008002008), 0x1.00000004001p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffff7ffdff7), -0x1.00000004001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000008002010), 0x1.00000004001p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffff7ffdfef), -0x1.0000000400101p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000008002080), 0x1.0000000400104p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffdf7f), -0x1.0000000400104p+57, -0x1p+0 },
+{ INT64_C(0x0200000008002200), 0x1.000000040011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffddff), -0x1.000000040011p+57, -0x1p+0 },
+{ INT64_C(0x0200000008003000), 0x1.000000040018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7ffcfff), -0x1.000000040018p+57, -0x1p+0 },
+{ INT64_C(0x0200000008020000), 0x1.0000000401p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fdffff), -0x1.0000000401p+57, -0x1p+0 },
+{ INT64_C(0x0200000008020008), 0x1.0000000401p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffff7fdfff7), -0x1.0000000401p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000008020040), 0x1.0000000401002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fdffbf), -0x1.0000000401002p+57, -0x1p+0 },
+{ INT64_C(0x0200000008020080), 0x1.0000000401004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fdff7f), -0x1.0000000401004p+57, -0x1p+0 },
+{ INT64_C(0x0200000008020800), 0x1.000000040104p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fdf7ff), -0x1.000000040104p+57, -0x1p+0 },
+{ INT64_C(0x0200000008022000), 0x1.00000004011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7fddfff), -0x1.00000004011p+57, -0x1p+0 },
+{ INT64_C(0x0200000008200000), 0x1.000000041p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dfffff), -0x1.000000041p+57, -0x1p+0 },
+{ INT64_C(0x0200000008200001), 0x1.000000041p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffff7dffffe), -0x1.000000041p+57, -0x1p+1 },
+{ INT64_C(0x0200000008200004), 0x1.000000041p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffff7dffffb), -0x1.000000041p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000008200020), 0x1.0000000410001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dfffdf), -0x1.0000000410001p+57, -0x1p+0 },
+{ INT64_C(0x0200000008200040), 0x1.0000000410002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dfffbf), -0x1.0000000410002p+57, -0x1p+0 },
+{ INT64_C(0x0200000008200400), 0x1.000000041002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dffbff), -0x1.000000041002p+57, -0x1p+0 },
+{ INT64_C(0x0200000008201000), 0x1.000000041008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dfefff), -0x1.000000041008p+57, -0x1p+0 },
+{ INT64_C(0x0200000008202000), 0x1.00000004101p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dfdfff), -0x1.00000004101p+57, -0x1p+0 },
+{ INT64_C(0x0200000008204000), 0x1.00000004102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dfbfff), -0x1.00000004102p+57, -0x1p+0 },
+{ INT64_C(0x0200000008240000), 0x1.0000000412p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7dbffff), -0x1.0000000412p+57, -0x1p+0 },
+{ INT64_C(0x0200000008400000), 0x1.000000042p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7bfffff), -0x1.000000042p+57, -0x1p+0 },
+{ INT64_C(0x0200000008400004), 0x1.000000042p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffff7bffffb), -0x1.000000042p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000008400040), 0x1.0000000420002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7bfffbf), -0x1.0000000420002p+57, -0x1p+0 },
+{ INT64_C(0x0200000008400400), 0x1.000000042002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7bffbff), -0x1.000000042002p+57, -0x1p+0 },
+{ INT64_C(0x0200000008404000), 0x1.00000004202p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7bfbfff), -0x1.00000004202p+57, -0x1p+0 },
+{ INT64_C(0x0200000008440000), 0x1.0000000422p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7bbffff), -0x1.0000000422p+57, -0x1p+0 },
+{ INT64_C(0x0200000008480000), 0x1.0000000424p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff7b7ffff), -0x1.0000000424p+57, -0x1p+0 },
+{ INT64_C(0x0200000009000000), 0x1.000000048p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff6ffffff), -0x1.000000048p+57, -0x1p+0 },
+{ INT64_C(0x0200000009000002), 0x1.000000048p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffff6fffffd), -0x1.000000048p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000009000010), 0x1.000000048p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffff6ffffef), -0x1.0000000480001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000009000080), 0x1.0000000480004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff6ffff7f), -0x1.0000000480004p+57, -0x1p+0 },
+{ INT64_C(0x0200000009000800), 0x1.000000048004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff6fff7ff), -0x1.000000048004p+57, -0x1p+0 },
+{ INT64_C(0x0200000009008000), 0x1.00000004804p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff6ff7fff), -0x1.00000004804p+57, -0x1p+0 },
+{ INT64_C(0x0200000009040000), 0x1.0000000482p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff6fbffff), -0x1.0000000482p+57, -0x1p+0 },
+{ INT64_C(0x0200000009200000), 0x1.000000049p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff6dfffff), -0x1.000000049p+57, -0x1p+0 },
+{ INT64_C(0x0200000009800000), 0x1.00000004cp+57, 0x0p+0 },
+{ INT64_C(0xfdfffffff67fffff), -0x1.00000004cp+57, -0x1p+0 },
+{ INT64_C(0x0200000020000004), 0x1.0000001p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffdffffffb), -0x1.0000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000020000005), 0x1.0000001p+57, 0x1.4p+2 },
+{ INT64_C(0xfdffffffdffffffa), -0x1.0000001p+57, -0x1.8p+2 },
+{ INT64_C(0x0200000020000008), 0x1.0000001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdffffff7), -0x1.0000001p+57, -0x1.2p+3 },
+{ INT64_C(0x020000002000000a), 0x1.0000001p+57, 0x1.4p+3 },
+{ INT64_C(0xfdffffffdffffff5), -0x1.0000001p+57, -0x1.6p+3 },
+{ INT64_C(0x0200000020000040), 0x1.0000001000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffffbf), -0x1.0000001000002p+57, -0x1p+0 },
+{ INT64_C(0x0200000020000044), 0x1.0000001000002p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffdfffffbb), -0x1.0000001000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000020000100), 0x1.0000001000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffffeff), -0x1.0000001000008p+57, -0x1p+0 },
+{ INT64_C(0x0200000020000102), 0x1.0000001000008p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffdffffefd), -0x1.0000001000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000020000108), 0x1.0000001000008p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdffffef7), -0x1.0000001000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000020000110), 0x1.0000001000008p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffdffffeef), -0x1.0000001000009p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000020000180), 0x1.000000100000cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffffe7f), -0x1.000000100000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000020001000), 0x1.000000100008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffefff), -0x1.000000100008p+57, -0x1p+0 },
+{ INT64_C(0x0200000020001004), 0x1.000000100008p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffdfffeffb), -0x1.000000100008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000020001020), 0x1.0000001000081p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffefdf), -0x1.0000001000081p+57, -0x1p+0 },
+{ INT64_C(0x0200000020001080), 0x1.0000001000084p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffef7f), -0x1.0000001000084p+57, -0x1p+0 },
+{ INT64_C(0x0200000020001800), 0x1.00000010000cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffe7ff), -0x1.00000010000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000020002000), 0x1.00000010001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffdfff), -0x1.00000010001p+57, -0x1p+0 },
+{ INT64_C(0x0200000020002002), 0x1.00000010001p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffdfffdffd), -0x1.00000010001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000020002020), 0x1.0000001000101p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffdfdf), -0x1.0000001000101p+57, -0x1p+0 },
+{ INT64_C(0x0200000020002200), 0x1.000000100011p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffddff), -0x1.000000100011p+57, -0x1p+0 },
+{ INT64_C(0x0200000020002400), 0x1.000000100012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffdbff), -0x1.000000100012p+57, -0x1p+0 },
+{ INT64_C(0x0200000020002800), 0x1.000000100014p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfffd7ff), -0x1.000000100014p+57, -0x1p+0 },
+{ INT64_C(0x0200000020008000), 0x1.00000010004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfff7fff), -0x1.00000010004p+57, -0x1p+0 },
+{ INT64_C(0x0200000020008001), 0x1.00000010004p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffdfff7ffe), -0x1.00000010004p+57, -0x1p+1 },
+{ INT64_C(0x0200000020008008), 0x1.00000010004p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdfff7ff7), -0x1.00000010004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000020008040), 0x1.0000001000402p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfff7fbf), -0x1.0000001000402p+57, -0x1p+0 },
+{ INT64_C(0x0200000020008400), 0x1.000000100042p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfff7bff), -0x1.000000100042p+57, -0x1p+0 },
+{ INT64_C(0x0200000020009000), 0x1.000000100048p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfff6fff), -0x1.000000100048p+57, -0x1p+0 },
+{ INT64_C(0x020000002000c000), 0x1.00000010006p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfff3fff), -0x1.00000010006p+57, -0x1p+0 },
+{ INT64_C(0x0200000020020000), 0x1.0000001001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffdffff), -0x1.0000001001p+57, -0x1p+0 },
+{ INT64_C(0x0200000020020002), 0x1.0000001001p+57, 0x1p+1 },
+{ INT64_C(0xfdffffffdffdfffd), -0x1.0000001001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000020020008), 0x1.0000001001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdffdfff7), -0x1.0000001001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000020020020), 0x1.0000001001001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffdffdf), -0x1.0000001001001p+57, -0x1p+0 },
+{ INT64_C(0x0200000020020080), 0x1.0000001001004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffdff7f), -0x1.0000001001004p+57, -0x1p+0 },
+{ INT64_C(0x0200000020020100), 0x1.0000001001008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffdfeff), -0x1.0000001001008p+57, -0x1p+0 },
+{ INT64_C(0x0200000020020800), 0x1.000000100104p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffdf7ff), -0x1.000000100104p+57, -0x1p+0 },
+{ INT64_C(0x0200000020022000), 0x1.00000010011p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffddfff), -0x1.00000010011p+57, -0x1p+0 },
+{ INT64_C(0x0200000020028000), 0x1.00000010014p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffd7fff), -0x1.00000010014p+57, -0x1p+0 },
+{ INT64_C(0x0200000020040000), 0x1.0000001002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbffff), -0x1.0000001002p+57, -0x1p+0 },
+{ INT64_C(0x0200000020040004), 0x1.0000001002p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffdffbfffb), -0x1.0000001002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000020040008), 0x1.0000001002p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdffbfff7), -0x1.0000001002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000020040020), 0x1.0000001002001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbffdf), -0x1.0000001002001p+57, -0x1p+0 },
+{ INT64_C(0x0200000020040080), 0x1.0000001002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbff7f), -0x1.0000001002004p+57, -0x1p+0 },
+{ INT64_C(0x0200000020040200), 0x1.000000100201p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbfdff), -0x1.000000100201p+57, -0x1p+0 },
+{ INT64_C(0x0200000020040400), 0x1.000000100202p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbfbff), -0x1.000000100202p+57, -0x1p+0 },
+{ INT64_C(0x0200000020041000), 0x1.000000100208p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbefff), -0x1.000000100208p+57, -0x1p+0 },
+{ INT64_C(0x0200000020042000), 0x1.00000010021p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffbdfff), -0x1.00000010021p+57, -0x1p+0 },
+{ INT64_C(0x0200000020048000), 0x1.00000010024p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdffb7fff), -0x1.00000010024p+57, -0x1p+0 },
+{ INT64_C(0x0200000020060000), 0x1.0000001003p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdff9ffff), -0x1.0000001003p+57, -0x1p+0 },
+{ INT64_C(0x0200000020200000), 0x1.000000101p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfdfffff), -0x1.000000101p+57, -0x1p+0 },
+{ INT64_C(0x0200000020200008), 0x1.000000101p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdfdffff7), -0x1.000000101p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000020200020), 0x1.0000001010001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfdfffdf), -0x1.0000001010001p+57, -0x1p+0 },
+{ INT64_C(0x0200000020200080), 0x1.0000001010004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfdfff7f), -0x1.0000001010004p+57, -0x1p+0 },
+{ INT64_C(0x0200000020200400), 0x1.000000101002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfdffbff), -0x1.000000101002p+57, -0x1p+0 },
+{ INT64_C(0x0200000020202000), 0x1.00000010101p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfdfdfff), -0x1.00000010101p+57, -0x1p+0 },
+{ INT64_C(0x0200000020220000), 0x1.0000001011p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfddffff), -0x1.0000001011p+57, -0x1p+0 },
+{ INT64_C(0x0200000020300000), 0x1.0000001018p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdfcfffff), -0x1.0000001018p+57, -0x1p+0 },
+{ INT64_C(0x0200000020800000), 0x1.000000104p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7fffff), -0x1.000000104p+57, -0x1p+0 },
+{ INT64_C(0x0200000020800004), 0x1.000000104p+57, 0x1p+2 },
+{ INT64_C(0xfdffffffdf7ffffb), -0x1.000000104p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000020800008), 0x1.000000104p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdf7ffff7), -0x1.000000104p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000020800040), 0x1.0000001040002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7fffbf), -0x1.0000001040002p+57, -0x1p+0 },
+{ INT64_C(0x0200000020800100), 0x1.0000001040008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7ffeff), -0x1.0000001040008p+57, -0x1p+0 },
+{ INT64_C(0x0200000020800200), 0x1.000000104001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7ffdff), -0x1.000000104001p+57, -0x1p+0 },
+{ INT64_C(0x0200000020800800), 0x1.000000104004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7ff7ff), -0x1.000000104004p+57, -0x1p+0 },
+{ INT64_C(0x0200000020808000), 0x1.00000010404p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7f7fff), -0x1.00000010404p+57, -0x1p+0 },
+{ INT64_C(0x0200000020810000), 0x1.00000010408p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7effff), -0x1.00000010408p+57, -0x1p+0 },
+{ INT64_C(0x0200000020820000), 0x1.0000001041p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7dffff), -0x1.0000001041p+57, -0x1p+0 },
+{ INT64_C(0x0200000020840000), 0x1.0000001042p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf7bffff), -0x1.0000001042p+57, -0x1p+0 },
+{ INT64_C(0x0200000020a00000), 0x1.000000105p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdf5fffff), -0x1.000000105p+57, -0x1p+0 },
+{ INT64_C(0x0200000024000000), 0x1.00000012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbffffff), -0x1.00000012p+57, -0x1p+0 },
+{ INT64_C(0x0200000024000001), 0x1.00000012p+57, 0x1p+0 },
+{ INT64_C(0xfdffffffdbfffffe), -0x1.00000012p+57, -0x1p+1 },
+{ INT64_C(0x0200000024000008), 0x1.00000012p+57, 0x1p+3 },
+{ INT64_C(0xfdffffffdbfffff7), -0x1.00000012p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000024000010), 0x1.00000012p+57, 0x1p+4 },
+{ INT64_C(0xfdffffffdbffffef), -0x1.0000001200001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000024000100), 0x1.0000001200008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbfffeff), -0x1.0000001200008p+57, -0x1p+0 },
+{ INT64_C(0x0200000024000800), 0x1.000000120004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbfff7ff), -0x1.000000120004p+57, -0x1p+0 },
+{ INT64_C(0x0200000024008000), 0x1.00000012004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbff7fff), -0x1.00000012004p+57, -0x1p+0 },
+{ INT64_C(0x0200000024040000), 0x1.0000001202p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbfbffff), -0x1.0000001202p+57, -0x1p+0 },
+{ INT64_C(0x0200000024080000), 0x1.0000001204p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbf7ffff), -0x1.0000001204p+57, -0x1p+0 },
+{ INT64_C(0x0200000024200000), 0x1.000000121p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdbdfffff), -0x1.000000121p+57, -0x1p+0 },
+{ INT64_C(0x0200000025000000), 0x1.000000128p+57, 0x0p+0 },
+{ INT64_C(0xfdffffffdaffffff), -0x1.000000128p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000004), 0x1.0000004p+57, 0x1p+2 },
+{ INT64_C(0xfdffffff7ffffffb), -0x1.0000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000080000005), 0x1.0000004p+57, 0x1.4p+2 },
+{ INT64_C(0xfdffffff7ffffffa), -0x1.0000004p+57, -0x1.8p+2 },
+{ INT64_C(0x0200000080000006), 0x1.0000004p+57, 0x1.8p+2 },
+{ INT64_C(0xfdffffff7ffffff9), -0x1.0000004p+57, -0x1.cp+2 },
+{ INT64_C(0x0200000080000020), 0x1.0000004000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fffffdf), -0x1.0000004000001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000022), 0x1.0000004000001p+57, 0x1p+1 },
+{ INT64_C(0xfdffffff7fffffdd), -0x1.0000004000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000080000028), 0x1.0000004000001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffff7fffffd7), -0x1.0000004000001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000080000100), 0x1.0000004000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffffeff), -0x1.0000004000008p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000104), 0x1.0000004000008p+57, 0x1p+2 },
+{ INT64_C(0xfdffffff7ffffefb), -0x1.0000004000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000080000120), 0x1.0000004000009p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffffedf), -0x1.0000004000009p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000180), 0x1.000000400000cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffffe7f), -0x1.000000400000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000080000200), 0x1.000000400001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffffdff), -0x1.000000400001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000201), 0x1.000000400001p+57, 0x1p+0 },
+{ INT64_C(0xfdffffff7ffffdfe), -0x1.000000400001p+57, -0x1p+1 },
+{ INT64_C(0x0200000080000208), 0x1.000000400001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffff7ffffdf7), -0x1.000000400001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000080000240), 0x1.0000004000012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffffdbf), -0x1.0000004000012p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000800), 0x1.000000400004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffff7ff), -0x1.000000400004p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000808), 0x1.000000400004p+57, 0x1p+3 },
+{ INT64_C(0xfdffffff7ffff7f7), -0x1.000000400004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000080000820), 0x1.0000004000041p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffff7df), -0x1.0000004000041p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000840), 0x1.0000004000042p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffff7bf), -0x1.0000004000042p+57, -0x1p+0 },
+{ INT64_C(0x0200000080000a00), 0x1.000000400005p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffff5ff), -0x1.000000400005p+57, -0x1p+0 },
+{ INT64_C(0x0200000080002000), 0x1.00000040001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fffdfff), -0x1.00000040001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080002004), 0x1.00000040001p+57, 0x1p+2 },
+{ INT64_C(0xfdffffff7fffdffb), -0x1.00000040001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000080002010), 0x1.00000040001p+57, 0x1p+4 },
+{ INT64_C(0xfdffffff7fffdfef), -0x1.0000004000101p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000080002080), 0x1.0000004000104p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fffdf7f), -0x1.0000004000104p+57, -0x1p+0 },
+{ INT64_C(0x0200000080002800), 0x1.000000400014p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fffd7ff), -0x1.000000400014p+57, -0x1p+0 },
+{ INT64_C(0x0200000080003000), 0x1.000000400018p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fffcfff), -0x1.000000400018p+57, -0x1p+0 },
+{ INT64_C(0x0200000080010000), 0x1.00000040008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffeffff), -0x1.00000040008p+57, -0x1p+0 },
+{ INT64_C(0x0200000080010002), 0x1.00000040008p+57, 0x1p+1 },
+{ INT64_C(0xfdffffff7ffefffd), -0x1.00000040008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000080010004), 0x1.00000040008p+57, 0x1p+2 },
+{ INT64_C(0xfdffffff7ffefffb), -0x1.00000040008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000080010008), 0x1.00000040008p+57, 0x1p+3 },
+{ INT64_C(0xfdffffff7ffefff7), -0x1.00000040008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000080010040), 0x1.0000004000802p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffeffbf), -0x1.0000004000802p+57, -0x1p+0 },
+{ INT64_C(0x0200000080010200), 0x1.000000400081p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffefdff), -0x1.000000400081p+57, -0x1p+0 },
+{ INT64_C(0x0200000080010400), 0x1.000000400082p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffefbff), -0x1.000000400082p+57, -0x1p+0 },
+{ INT64_C(0x0200000080014000), 0x1.0000004000ap+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffebfff), -0x1.0000004000ap+57, -0x1p+0 },
+{ INT64_C(0x0200000080040000), 0x1.0000004002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffbffff), -0x1.0000004002p+57, -0x1p+0 },
+{ INT64_C(0x0200000080040002), 0x1.0000004002p+57, 0x1p+1 },
+{ INT64_C(0xfdffffff7ffbfffd), -0x1.0000004002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000080040010), 0x1.0000004002p+57, 0x1p+4 },
+{ INT64_C(0xfdffffff7ffbffef), -0x1.0000004002001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000080040020), 0x1.0000004002001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffbffdf), -0x1.0000004002001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080040200), 0x1.000000400201p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffbfdff), -0x1.000000400201p+57, -0x1p+0 },
+{ INT64_C(0x0200000080040800), 0x1.000000400204p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffbf7ff), -0x1.000000400204p+57, -0x1p+0 },
+{ INT64_C(0x0200000080048000), 0x1.00000040024p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ffb7fff), -0x1.00000040024p+57, -0x1p+0 },
+{ INT64_C(0x0200000080060000), 0x1.0000004003p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ff9ffff), -0x1.0000004003p+57, -0x1p+0 },
+{ INT64_C(0x0200000080100000), 0x1.0000004008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fefffff), -0x1.0000004008p+57, -0x1p+0 },
+{ INT64_C(0x0200000080100001), 0x1.0000004008p+57, 0x1p+0 },
+{ INT64_C(0xfdffffff7feffffe), -0x1.0000004008p+57, -0x1p+1 },
+{ INT64_C(0x0200000080100002), 0x1.0000004008p+57, 0x1p+1 },
+{ INT64_C(0xfdffffff7feffffd), -0x1.0000004008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000080100020), 0x1.0000004008001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fefffdf), -0x1.0000004008001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080100100), 0x1.0000004008008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7feffeff), -0x1.0000004008008p+57, -0x1p+0 },
+{ INT64_C(0x0200000080101000), 0x1.000000400808p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fefefff), -0x1.000000400808p+57, -0x1p+0 },
+{ INT64_C(0x0200000080104000), 0x1.00000040082p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fefbfff), -0x1.00000040082p+57, -0x1p+0 },
+{ INT64_C(0x0200000080120000), 0x1.0000004009p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fedffff), -0x1.0000004009p+57, -0x1p+0 },
+{ INT64_C(0x0200000080180000), 0x1.000000400cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fe7ffff), -0x1.000000400cp+57, -0x1p+0 },
+{ INT64_C(0x0200000080400000), 0x1.000000402p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fbfffff), -0x1.000000402p+57, -0x1p+0 },
+{ INT64_C(0x0200000080400004), 0x1.000000402p+57, 0x1p+2 },
+{ INT64_C(0xfdffffff7fbffffb), -0x1.000000402p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000080400010), 0x1.000000402p+57, 0x1p+4 },
+{ INT64_C(0xfdffffff7fbfffef), -0x1.0000004020001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000080400020), 0x1.0000004020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fbfffdf), -0x1.0000004020001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080400200), 0x1.000000402001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fbffdff), -0x1.000000402001p+57, -0x1p+0 },
+{ INT64_C(0x0200000080400400), 0x1.000000402002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fbffbff), -0x1.000000402002p+57, -0x1p+0 },
+{ INT64_C(0x0200000080404000), 0x1.00000040202p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fbfbfff), -0x1.00000040202p+57, -0x1p+0 },
+{ INT64_C(0x0200000080420000), 0x1.0000004021p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7fbdffff), -0x1.0000004021p+57, -0x1p+0 },
+{ INT64_C(0x0200000080600000), 0x1.000000403p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7f9fffff), -0x1.000000403p+57, -0x1p+0 },
+{ INT64_C(0x0200000081000000), 0x1.000000408p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7effffff), -0x1.000000408p+57, -0x1p+0 },
+{ INT64_C(0x0200000081000001), 0x1.000000408p+57, 0x1p+0 },
+{ INT64_C(0xfdffffff7efffffe), -0x1.000000408p+57, -0x1p+1 },
+{ INT64_C(0x0200000081000002), 0x1.000000408p+57, 0x1p+1 },
+{ INT64_C(0xfdffffff7efffffd), -0x1.000000408p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000081000020), 0x1.0000004080001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7effffdf), -0x1.0000004080001p+57, -0x1p+0 },
+{ INT64_C(0x0200000081000200), 0x1.000000408001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7efffdff), -0x1.000000408001p+57, -0x1p+0 },
+{ INT64_C(0x0200000081001000), 0x1.000000408008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7effefff), -0x1.000000408008p+57, -0x1p+0 },
+{ INT64_C(0x0200000081004000), 0x1.00000040802p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7effbfff), -0x1.00000040802p+57, -0x1p+0 },
+{ INT64_C(0x0200000081010000), 0x1.00000040808p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7efeffff), -0x1.00000040808p+57, -0x1p+0 },
+{ INT64_C(0x0200000081020000), 0x1.0000004081p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7efdffff), -0x1.0000004081p+57, -0x1p+0 },
+{ INT64_C(0x0200000081080000), 0x1.0000004084p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7ef7ffff), -0x1.0000004084p+57, -0x1p+0 },
+{ INT64_C(0x0200000081100000), 0x1.0000004088p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7eefffff), -0x1.0000004088p+57, -0x1p+0 },
+{ INT64_C(0x0200000081800000), 0x1.00000040cp+57, 0x0p+0 },
+{ INT64_C(0xfdffffff7e7fffff), -0x1.00000040cp+57, -0x1p+0 },
+{ INT64_C(0x0200000090000000), 0x1.00000048p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6fffffff), -0x1.00000048p+57, -0x1p+0 },
+{ INT64_C(0x0200000090000004), 0x1.00000048p+57, 0x1p+2 },
+{ INT64_C(0xfdffffff6ffffffb), -0x1.00000048p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000090000040), 0x1.0000004800002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6fffffbf), -0x1.0000004800002p+57, -0x1p+0 },
+{ INT64_C(0x0200000090000080), 0x1.0000004800004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6fffff7f), -0x1.0000004800004p+57, -0x1p+0 },
+{ INT64_C(0x0200000090000800), 0x1.000000480004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6ffff7ff), -0x1.000000480004p+57, -0x1p+0 },
+{ INT64_C(0x0200000090002000), 0x1.00000048001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6fffdfff), -0x1.00000048001p+57, -0x1p+0 },
+{ INT64_C(0x0200000090004000), 0x1.00000048002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6fffbfff), -0x1.00000048002p+57, -0x1p+0 },
+{ INT64_C(0x0200000090040000), 0x1.0000004802p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6ffbffff), -0x1.0000004802p+57, -0x1p+0 },
+{ INT64_C(0x0200000090400000), 0x1.000000482p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6fbfffff), -0x1.000000482p+57, -0x1p+0 },
+{ INT64_C(0x0200000091000000), 0x1.000000488p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6effffff), -0x1.000000488p+57, -0x1p+0 },
+{ INT64_C(0x0200000092000000), 0x1.00000049p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6dffffff), -0x1.00000049p+57, -0x1p+0 },
+{ INT64_C(0x0200000094000000), 0x1.0000004ap+57, 0x0p+0 },
+{ INT64_C(0xfdffffff6bffffff), -0x1.0000004ap+57, -0x1p+0 },
+{ INT64_C(0x02000000c0000000), 0x1.0000006p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3fffffff), -0x1.0000006p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0000001), 0x1.0000006p+57, 0x1p+0 },
+{ INT64_C(0xfdffffff3ffffffe), -0x1.0000006p+57, -0x1p+1 },
+{ INT64_C(0x02000000c0000002), 0x1.0000006p+57, 0x1p+1 },
+{ INT64_C(0xfdffffff3ffffffd), -0x1.0000006p+57, -0x1.8p+1 },
+{ INT64_C(0x02000000c0000008), 0x1.0000006p+57, 0x1p+3 },
+{ INT64_C(0xfdffffff3ffffff7), -0x1.0000006p+57, -0x1.2p+3 },
+{ INT64_C(0x02000000c0000020), 0x1.0000006000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3fffffdf), -0x1.0000006000001p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0000080), 0x1.0000006000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3fffff7f), -0x1.0000006000004p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0000800), 0x1.000000600004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3ffff7ff), -0x1.000000600004p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0001000), 0x1.000000600008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3fffefff), -0x1.000000600008p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0008000), 0x1.00000060004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3fff7fff), -0x1.00000060004p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0080000), 0x1.0000006004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3ff7ffff), -0x1.0000006004p+57, -0x1p+0 },
+{ INT64_C(0x02000000c0800000), 0x1.000000604p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3f7fffff), -0x1.000000604p+57, -0x1p+0 },
+{ INT64_C(0x02000000c1000000), 0x1.000000608p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3effffff), -0x1.000000608p+57, -0x1p+0 },
+{ INT64_C(0x02000000c4000000), 0x1.00000062p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff3bffffff), -0x1.00000062p+57, -0x1p+0 },
+{ INT64_C(0x02000000c8000000), 0x1.00000064p+57, 0x0p+0 },
+{ INT64_C(0xfdffffff37ffffff), -0x1.00000064p+57, -0x1p+0 },
+{ INT64_C(0x0200000200000002), 0x1.000001p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffdfffffffd), -0x1.000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000200000003), 0x1.000001p+57, 0x1.8p+1 },
+{ INT64_C(0xfdfffffdfffffffc), -0x1.000001p+57, -0x1p+2 },
+{ INT64_C(0x0200000200000004), 0x1.000001p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffdfffffffb), -0x1.000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000200000006), 0x1.000001p+57, 0x1.8p+2 },
+{ INT64_C(0xfdfffffdfffffff9), -0x1.000001p+57, -0x1.cp+2 },
+{ INT64_C(0x0200000200000008), 0x1.000001p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffdfffffff7), -0x1.000001p+57, -0x1.2p+3 },
+{ INT64_C(0x020000020000000c), 0x1.000001p+57, 0x1.8p+3 },
+{ INT64_C(0xfdfffffdfffffff3), -0x1.000001p+57, -0x1.ap+3 },
+{ INT64_C(0x0200000200000020), 0x1.0000010000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffffffdf), -0x1.0000010000001p+57, -0x1p+0 },
+{ INT64_C(0x0200000200000022), 0x1.0000010000001p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffdffffffdd), -0x1.0000010000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000200000100), 0x1.0000010000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffffeff), -0x1.0000010000008p+57, -0x1p+0 },
+{ INT64_C(0x0200000200000101), 0x1.0000010000008p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffdfffffefe), -0x1.0000010000008p+57, -0x1p+1 },
+{ INT64_C(0x0200000200000110), 0x1.0000010000008p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffdfffffeef), -0x1.0000010000009p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000200001000), 0x1.000001000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffffefff), -0x1.000001000008p+57, -0x1p+0 },
+{ INT64_C(0x0200000200001002), 0x1.000001000008p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffdffffeffd), -0x1.000001000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000200001004), 0x1.000001000008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffdffffeffb), -0x1.000001000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000200001010), 0x1.000001000008p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffdffffefef), -0x1.0000010000081p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000200001100), 0x1.0000010000088p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffffeeff), -0x1.0000010000088p+57, -0x1p+0 },
+{ INT64_C(0x0200000200010000), 0x1.00000100008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffeffff), -0x1.00000100008p+57, -0x1p+0 },
+{ INT64_C(0x0200000200010008), 0x1.00000100008p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffdfffefff7), -0x1.00000100008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000200010010), 0x1.00000100008p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffdfffeffef), -0x1.0000010000801p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000200010020), 0x1.0000010000801p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffeffdf), -0x1.0000010000801p+57, -0x1p+0 },
+{ INT64_C(0x0200000200010080), 0x1.0000010000804p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffeff7f), -0x1.0000010000804p+57, -0x1p+0 },
+{ INT64_C(0x0200000200010400), 0x1.000001000082p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffefbff), -0x1.000001000082p+57, -0x1p+0 },
+{ INT64_C(0x0200000200011000), 0x1.000001000088p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffeefff), -0x1.000001000088p+57, -0x1p+0 },
+{ INT64_C(0x0200000200018000), 0x1.0000010000cp+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfffe7fff), -0x1.0000010000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000200080000), 0x1.0000010004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfff7ffff), -0x1.0000010004p+57, -0x1p+0 },
+{ INT64_C(0x0200000200080008), 0x1.0000010004p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffdfff7fff7), -0x1.0000010004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000200080080), 0x1.0000010004004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfff7ff7f), -0x1.0000010004004p+57, -0x1p+0 },
+{ INT64_C(0x0200000200080800), 0x1.000001000404p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfff7f7ff), -0x1.000001000404p+57, -0x1p+0 },
+{ INT64_C(0x0200000200088000), 0x1.00000100044p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfff77fff), -0x1.00000100044p+57, -0x1p+0 },
+{ INT64_C(0x02000002000c0000), 0x1.0000010006p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfff3ffff), -0x1.0000010006p+57, -0x1p+0 },
+{ INT64_C(0x0200000200400000), 0x1.000001002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffbfffff), -0x1.000001002p+57, -0x1p+0 },
+{ INT64_C(0x0200000200400001), 0x1.000001002p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffdffbffffe), -0x1.000001002p+57, -0x1p+1 },
+{ INT64_C(0x0200000200400010), 0x1.000001002p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffdffbfffef), -0x1.0000010020001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000200400100), 0x1.0000010020008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffbffeff), -0x1.0000010020008p+57, -0x1p+0 },
+{ INT64_C(0x0200000200401000), 0x1.000001002008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffbfefff), -0x1.000001002008p+57, -0x1p+0 },
+{ INT64_C(0x0200000200410000), 0x1.00000100208p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffbeffff), -0x1.00000100208p+57, -0x1p+0 },
+{ INT64_C(0x0200000200500000), 0x1.0000010028p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdffafffff), -0x1.0000010028p+57, -0x1p+0 },
+{ INT64_C(0x0200000200600000), 0x1.000001003p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdff9fffff), -0x1.000001003p+57, -0x1p+0 },
+{ INT64_C(0x0200000201000000), 0x1.000001008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfeffffff), -0x1.000001008p+57, -0x1p+0 },
+{ INT64_C(0x0200000201000002), 0x1.000001008p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffdfefffffd), -0x1.000001008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000201000020), 0x1.0000010080001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfeffffdf), -0x1.0000010080001p+57, -0x1p+0 },
+{ INT64_C(0x0200000201000080), 0x1.0000010080004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfeffff7f), -0x1.0000010080004p+57, -0x1p+0 },
+{ INT64_C(0x0200000201000800), 0x1.000001008004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfefff7ff), -0x1.000001008004p+57, -0x1p+0 },
+{ INT64_C(0x0200000201002000), 0x1.00000100801p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfeffdfff), -0x1.00000100801p+57, -0x1p+0 },
+{ INT64_C(0x0200000201008000), 0x1.00000100804p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfeff7fff), -0x1.00000100804p+57, -0x1p+0 },
+{ INT64_C(0x0200000201080000), 0x1.0000010084p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfef7ffff), -0x1.0000010084p+57, -0x1p+0 },
+{ INT64_C(0x0200000201800000), 0x1.00000100cp+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdfe7fffff), -0x1.00000100cp+57, -0x1p+0 },
+{ INT64_C(0x0200000210000000), 0x1.00000108p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdefffffff), -0x1.00000108p+57, -0x1p+0 },
+{ INT64_C(0x0200000210000002), 0x1.00000108p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffdeffffffd), -0x1.00000108p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000210000010), 0x1.00000108p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffdefffffef), -0x1.0000010800001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000210000080), 0x1.0000010800004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdefffff7f), -0x1.0000010800004p+57, -0x1p+0 },
+{ INT64_C(0x0200000210000100), 0x1.0000010800008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdeffffeff), -0x1.0000010800008p+57, -0x1p+0 },
+{ INT64_C(0x0200000210000800), 0x1.000001080004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdeffff7ff), -0x1.000001080004p+57, -0x1p+0 },
+{ INT64_C(0x0200000210004000), 0x1.00000108002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdefffbfff), -0x1.00000108002p+57, -0x1p+0 },
+{ INT64_C(0x0200000210010000), 0x1.00000108008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdeffeffff), -0x1.00000108008p+57, -0x1p+0 },
+{ INT64_C(0x0200000210100000), 0x1.0000010808p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdefefffff), -0x1.0000010808p+57, -0x1p+0 },
+{ INT64_C(0x0200000210800000), 0x1.000001084p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffdef7fffff), -0x1.000001084p+57, -0x1p+0 },
+{ INT64_C(0x0200000218000000), 0x1.0000010cp+57, 0x0p+0 },
+{ INT64_C(0xfdfffffde7ffffff), -0x1.0000010cp+57, -0x1p+0 },
+{ INT64_C(0x0200000280000000), 0x1.0000014p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7fffffff), -0x1.0000014p+57, -0x1p+0 },
+{ INT64_C(0x0200000280000008), 0x1.0000014p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffd7ffffff7), -0x1.0000014p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000280000020), 0x1.0000014000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7fffffdf), -0x1.0000014000001p+57, -0x1p+0 },
+{ INT64_C(0x0200000280000080), 0x1.0000014000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7fffff7f), -0x1.0000014000004p+57, -0x1p+0 },
+{ INT64_C(0x0200000280000800), 0x1.000001400004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7ffff7ff), -0x1.000001400004p+57, -0x1p+0 },
+{ INT64_C(0x0200000280008000), 0x1.00000140004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7fff7fff), -0x1.00000140004p+57, -0x1p+0 },
+{ INT64_C(0x0200000280040000), 0x1.0000014002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7ffbffff), -0x1.0000014002p+57, -0x1p+0 },
+{ INT64_C(0x0200000280080000), 0x1.0000014004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7ff7ffff), -0x1.0000014004p+57, -0x1p+0 },
+{ INT64_C(0x0200000280400000), 0x1.000001402p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7fbfffff), -0x1.000001402p+57, -0x1p+0 },
+{ INT64_C(0x0200000280800000), 0x1.000001404p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd7f7fffff), -0x1.000001404p+57, -0x1p+0 },
+{ INT64_C(0x0200000288000000), 0x1.00000144p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd77ffffff), -0x1.00000144p+57, -0x1p+0 },
+{ INT64_C(0x02000002c0000000), 0x1.0000016p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffd3fffffff), -0x1.0000016p+57, -0x1p+0 },
+{ INT64_C(0x0200000400000004), 0x1.000002p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffbfffffffb), -0x1.000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000400000040), 0x1.0000020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffffffbf), -0x1.0000020000002p+57, -0x1p+0 },
+{ INT64_C(0x0200000400000041), 0x1.0000020000002p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffbffffffbe), -0x1.0000020000002p+57, -0x1p+1 },
+{ INT64_C(0x0200000400000042), 0x1.0000020000002p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffbffffffbd), -0x1.0000020000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000400000044), 0x1.0000020000002p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffbffffffbb), -0x1.0000020000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000400000100), 0x1.0000020000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffffeff), -0x1.0000020000008p+57, -0x1p+0 },
+{ INT64_C(0x0200000400000104), 0x1.0000020000008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffbfffffefb), -0x1.0000020000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000400000140), 0x1.000002000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffffebf), -0x1.000002000000ap+57, -0x1p+0 },
+{ INT64_C(0x0200000400000180), 0x1.000002000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffffe7f), -0x1.000002000000cp+57, -0x1p+0 },
+{ INT64_C(0x0200000400001000), 0x1.000002000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffffefff), -0x1.000002000008p+57, -0x1p+0 },
+{ INT64_C(0x0200000400001008), 0x1.000002000008p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffbffffeff7), -0x1.000002000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000400001020), 0x1.0000020000081p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffffefdf), -0x1.0000020000081p+57, -0x1p+0 },
+{ INT64_C(0x0200000400001200), 0x1.000002000009p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffffedff), -0x1.000002000009p+57, -0x1p+0 },
+{ INT64_C(0x0200000400010000), 0x1.00000200008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffeffff), -0x1.00000200008p+57, -0x1p+0 },
+{ INT64_C(0x0200000400010008), 0x1.00000200008p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffbfffefff7), -0x1.00000200008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000400010020), 0x1.0000020000801p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffeffdf), -0x1.0000020000801p+57, -0x1p+0 },
+{ INT64_C(0x0200000400010100), 0x1.0000020000808p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffefeff), -0x1.0000020000808p+57, -0x1p+0 },
+{ INT64_C(0x0200000400010200), 0x1.000002000081p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffefdff), -0x1.000002000081p+57, -0x1p+0 },
+{ INT64_C(0x0200000400010800), 0x1.000002000084p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffef7ff), -0x1.000002000084p+57, -0x1p+0 },
+{ INT64_C(0x0200000400014000), 0x1.0000020000ap+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffebfff), -0x1.0000020000ap+57, -0x1p+0 },
+{ INT64_C(0x0200000400020000), 0x1.0000020001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffdffff), -0x1.0000020001p+57, -0x1p+0 },
+{ INT64_C(0x0200000400020002), 0x1.0000020001p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffbfffdfffd), -0x1.0000020001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000400020010), 0x1.0000020001p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffbfffdffef), -0x1.0000020001001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000400020080), 0x1.0000020001004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffdff7f), -0x1.0000020001004p+57, -0x1p+0 },
+{ INT64_C(0x0200000400020100), 0x1.0000020001008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffdfeff), -0x1.0000020001008p+57, -0x1p+0 },
+{ INT64_C(0x0200000400020400), 0x1.000002000102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffdfbff), -0x1.000002000102p+57, -0x1p+0 },
+{ INT64_C(0x0200000400020800), 0x1.000002000104p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffdf7ff), -0x1.000002000104p+57, -0x1p+0 },
+{ INT64_C(0x0200000400028000), 0x1.00000200014p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffd7fff), -0x1.00000200014p+57, -0x1p+0 },
+{ INT64_C(0x0200000400030000), 0x1.00000200018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfffcffff), -0x1.00000200018p+57, -0x1p+0 },
+{ INT64_C(0x0200000400200000), 0x1.000002001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdfffff), -0x1.000002001p+57, -0x1p+0 },
+{ INT64_C(0x0200000400200001), 0x1.000002001p+57, 0x1p+0 },
+{ INT64_C(0xfdfffffbffdffffe), -0x1.000002001p+57, -0x1p+1 },
+{ INT64_C(0x0200000400200010), 0x1.000002001p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffbffdfffef), -0x1.0000020010001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000400200080), 0x1.0000020010004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdfff7f), -0x1.0000020010004p+57, -0x1p+0 },
+{ INT64_C(0x0200000400200400), 0x1.000002001002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdffbff), -0x1.000002001002p+57, -0x1p+0 },
+{ INT64_C(0x0200000400200800), 0x1.000002001004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdff7ff), -0x1.000002001004p+57, -0x1p+0 },
+{ INT64_C(0x0200000400202000), 0x1.00000200101p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdfdfff), -0x1.00000200101p+57, -0x1p+0 },
+{ INT64_C(0x0200000400204000), 0x1.00000200102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdfbfff), -0x1.00000200102p+57, -0x1p+0 },
+{ INT64_C(0x0200000400210000), 0x1.00000200108p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdeffff), -0x1.00000200108p+57, -0x1p+0 },
+{ INT64_C(0x0200000400240000), 0x1.0000020012p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffdbffff), -0x1.0000020012p+57, -0x1p+0 },
+{ INT64_C(0x0200000400400000), 0x1.000002002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffbfffff), -0x1.000002002p+57, -0x1p+0 },
+{ INT64_C(0x0200000400400002), 0x1.000002002p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffbffbffffd), -0x1.000002002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000400400020), 0x1.0000020020001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffbfffdf), -0x1.0000020020001p+57, -0x1p+0 },
+{ INT64_C(0x0200000400400200), 0x1.000002002001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffbffdff), -0x1.000002002001p+57, -0x1p+0 },
+{ INT64_C(0x0200000400402000), 0x1.00000200201p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffbfdfff), -0x1.00000200201p+57, -0x1p+0 },
+{ INT64_C(0x0200000400410000), 0x1.00000200208p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffbeffff), -0x1.00000200208p+57, -0x1p+0 },
+{ INT64_C(0x0200000400420000), 0x1.0000020021p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffbdffff), -0x1.0000020021p+57, -0x1p+0 },
+{ INT64_C(0x0200000400480000), 0x1.0000020024p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbffb7ffff), -0x1.0000020024p+57, -0x1p+0 },
+{ INT64_C(0x0200000404000000), 0x1.00000202p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbffffff), -0x1.00000202p+57, -0x1p+0 },
+{ INT64_C(0x0200000404000002), 0x1.00000202p+57, 0x1p+1 },
+{ INT64_C(0xfdfffffbfbfffffd), -0x1.00000202p+57, -0x1.8p+1 },
+{ INT64_C(0x0200000404000008), 0x1.00000202p+57, 0x1p+3 },
+{ INT64_C(0xfdfffffbfbfffff7), -0x1.00000202p+57, -0x1.2p+3 },
+{ INT64_C(0x0200000404000080), 0x1.0000020200004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbffff7f), -0x1.0000020200004p+57, -0x1p+0 },
+{ INT64_C(0x0200000404000400), 0x1.000002020002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbfffbff), -0x1.000002020002p+57, -0x1p+0 },
+{ INT64_C(0x0200000404002000), 0x1.00000202001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbffdfff), -0x1.00000202001p+57, -0x1p+0 },
+{ INT64_C(0x0200000404010000), 0x1.00000202008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbfeffff), -0x1.00000202008p+57, -0x1p+0 },
+{ INT64_C(0x0200000404040000), 0x1.0000020202p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbfbffff), -0x1.0000020202p+57, -0x1p+0 },
+{ INT64_C(0x0200000404400000), 0x1.000002022p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfbbfffff), -0x1.000002022p+57, -0x1p+0 },
+{ INT64_C(0x0200000405000000), 0x1.000002028p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbfaffffff), -0x1.000002028p+57, -0x1p+0 },
+{ INT64_C(0x0200000406000000), 0x1.00000203p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbf9ffffff), -0x1.00000203p+57, -0x1p+0 },
+{ INT64_C(0x0200000440000000), 0x1.0000022p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbfffffff), -0x1.0000022p+57, -0x1p+0 },
+{ INT64_C(0x0200000440000004), 0x1.0000022p+57, 0x1p+2 },
+{ INT64_C(0xfdfffffbbffffffb), -0x1.0000022p+57, -0x1.4p+2 },
+{ INT64_C(0x0200000440000010), 0x1.0000022p+57, 0x1p+4 },
+{ INT64_C(0xfdfffffbbfffffef), -0x1.0000022000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200000440000080), 0x1.0000022000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbfffff7f), -0x1.0000022000004p+57, -0x1p+0 },
+{ INT64_C(0x0200000440000800), 0x1.000002200004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbffff7ff), -0x1.000002200004p+57, -0x1p+0 },
+{ INT64_C(0x0200000440002000), 0x1.00000220001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbfffdfff), -0x1.00000220001p+57, -0x1p+0 },
+{ INT64_C(0x0200000440010000), 0x1.00000220008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbffeffff), -0x1.00000220008p+57, -0x1p+0 },
+{ INT64_C(0x0200000440100000), 0x1.0000022008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbfefffff), -0x1.0000022008p+57, -0x1p+0 },
+{ INT64_C(0x0200000441000000), 0x1.000002208p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbbeffffff), -0x1.000002208p+57, -0x1p+0 },
+{ INT64_C(0x0200000448000000), 0x1.00000224p+57, 0x0p+0 },
+{ INT64_C(0xfdfffffbb7ffffff), -0x1.00000224p+57, -0x1p+0 },
+{ INT64_C(0x0200004000000008), 0x1.00002p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbffffffff7), -0x1.00002p+57, -0x1.2p+3 },
+{ INT64_C(0x020000400000000a), 0x1.00002p+57, 0x1.4p+3 },
+{ INT64_C(0xfdffffbffffffff5), -0x1.00002p+57, -0x1.6p+3 },
+{ INT64_C(0x020000400000000c), 0x1.00002p+57, 0x1.8p+3 },
+{ INT64_C(0xfdffffbffffffff3), -0x1.00002p+57, -0x1.ap+3 },
+{ INT64_C(0x0200004000000020), 0x1.0000200000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffffffdf), -0x1.0000200000001p+57, -0x1p+0 },
+{ INT64_C(0x0200004000000024), 0x1.0000200000001p+57, 0x1p+2 },
+{ INT64_C(0xfdffffbfffffffdb), -0x1.0000200000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200004000000030), 0x1.0000200000002p+57, -0x1p+4 },
+{ INT64_C(0xfdffffbfffffffcf), -0x1.0000200000002p+57, 0x1.ep+3 },
+{ INT64_C(0x0200004000000040), 0x1.0000200000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffffffbf), -0x1.0000200000002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000000048), 0x1.0000200000002p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbfffffffb7), -0x1.0000200000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004000000050), 0x1.0000200000002p+57, 0x1p+4 },
+{ INT64_C(0xfdffffbfffffffaf), -0x1.0000200000003p+57, 0x1.ep+3 },
+{ INT64_C(0x0200004000000100), 0x1.0000200000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffffeff), -0x1.0000200000008p+57, -0x1p+0 },
+{ INT64_C(0x0200004000000104), 0x1.0000200000008p+57, 0x1p+2 },
+{ INT64_C(0xfdffffbffffffefb), -0x1.0000200000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200004000000140), 0x1.000020000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffffebf), -0x1.000020000000ap+57, -0x1p+0 },
+{ INT64_C(0x0200004000000400), 0x1.000020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffffbff), -0x1.000020000002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000000404), 0x1.000020000002p+57, 0x1p+2 },
+{ INT64_C(0xfdffffbffffffbfb), -0x1.000020000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200004000000420), 0x1.0000200000021p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffffbdf), -0x1.0000200000021p+57, -0x1p+0 },
+{ INT64_C(0x0200004000000440), 0x1.0000200000022p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffffbbf), -0x1.0000200000022p+57, -0x1p+0 },
+{ INT64_C(0x0200004000002000), 0x1.00002000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffffdfff), -0x1.00002000001p+57, -0x1p+0 },
+{ INT64_C(0x0200004000002004), 0x1.00002000001p+57, 0x1p+2 },
+{ INT64_C(0xfdffffbfffffdffb), -0x1.00002000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200004000002008), 0x1.00002000001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbfffffdff7), -0x1.00002000001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004000002040), 0x1.0000200000102p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffffdfbf), -0x1.0000200000102p+57, -0x1p+0 },
+{ INT64_C(0x0200004000002100), 0x1.0000200000108p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffffdeff), -0x1.0000200000108p+57, -0x1p+0 },
+{ INT64_C(0x0200004000002400), 0x1.000020000012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffffdbff), -0x1.000020000012p+57, -0x1p+0 },
+{ INT64_C(0x0200004000010000), 0x1.00002000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffeffff), -0x1.00002000008p+57, -0x1p+0 },
+{ INT64_C(0x0200004000010001), 0x1.00002000008p+57, 0x1p+0 },
+{ INT64_C(0xfdffffbffffefffe), -0x1.00002000008p+57, -0x1p+1 },
+{ INT64_C(0x0200004000010002), 0x1.00002000008p+57, 0x1p+1 },
+{ INT64_C(0xfdffffbffffefffd), -0x1.00002000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200004000010008), 0x1.00002000008p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbffffefff7), -0x1.00002000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004000010080), 0x1.0000200000804p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffeff7f), -0x1.0000200000804p+57, -0x1p+0 },
+{ INT64_C(0x0200004000010800), 0x1.000020000084p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffef7ff), -0x1.000020000084p+57, -0x1p+0 },
+{ INT64_C(0x0200004000012000), 0x1.00002000009p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffedfff), -0x1.00002000009p+57, -0x1p+0 },
+{ INT64_C(0x0200004000040000), 0x1.0000200002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffbffff), -0x1.0000200002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000040008), 0x1.0000200002p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbffffbfff7), -0x1.0000200002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004000040080), 0x1.0000200002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffbff7f), -0x1.0000200002004p+57, -0x1p+0 },
+{ INT64_C(0x0200004000040200), 0x1.000020000201p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffbfdff), -0x1.000020000201p+57, -0x1p+0 },
+{ INT64_C(0x0200004000041000), 0x1.000020000208p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffbefff), -0x1.000020000208p+57, -0x1p+0 },
+{ INT64_C(0x0200004000050000), 0x1.00002000028p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffffaffff), -0x1.00002000028p+57, -0x1p+0 },
+{ INT64_C(0x0200004000200000), 0x1.000020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdfffff), -0x1.000020001p+57, -0x1p+0 },
+{ INT64_C(0x0200004000200008), 0x1.000020001p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbfffdffff7), -0x1.000020001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004000200040), 0x1.0000200010002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdfffbf), -0x1.0000200010002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000200080), 0x1.0000200010004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdfff7f), -0x1.0000200010004p+57, -0x1p+0 },
+{ INT64_C(0x0200004000200400), 0x1.000020001002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdffbff), -0x1.000020001002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000202000), 0x1.00002000101p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdfdfff), -0x1.00002000101p+57, -0x1p+0 },
+{ INT64_C(0x0200004000204000), 0x1.00002000102p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdfbfff), -0x1.00002000102p+57, -0x1p+0 },
+{ INT64_C(0x0200004000240000), 0x1.0000200012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffdbffff), -0x1.0000200012p+57, -0x1p+0 },
+{ INT64_C(0x0200004000400000), 0x1.000020002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbfffff), -0x1.000020002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000400002), 0x1.000020002p+57, 0x1p+1 },
+{ INT64_C(0xfdffffbfffbffffd), -0x1.000020002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200004000400020), 0x1.0000200020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbfffdf), -0x1.0000200020001p+57, -0x1p+0 },
+{ INT64_C(0x0200004000400100), 0x1.0000200020008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbffeff), -0x1.0000200020008p+57, -0x1p+0 },
+{ INT64_C(0x0200004000400400), 0x1.000020002002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbffbff), -0x1.000020002002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000401000), 0x1.000020002008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbfefff), -0x1.000020002008p+57, -0x1p+0 },
+{ INT64_C(0x0200004000408000), 0x1.00002000204p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbf7fff), -0x1.00002000204p+57, -0x1p+0 },
+{ INT64_C(0x0200004000440000), 0x1.0000200022p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffbbffff), -0x1.0000200022p+57, -0x1p+0 },
+{ INT64_C(0x0200004000480000), 0x1.0000200024p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfffb7ffff), -0x1.0000200024p+57, -0x1p+0 },
+{ INT64_C(0x0200004000800000), 0x1.000020004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7fffff), -0x1.000020004p+57, -0x1p+0 },
+{ INT64_C(0x0200004000800002), 0x1.000020004p+57, 0x1p+1 },
+{ INT64_C(0xfdffffbfff7ffffd), -0x1.000020004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200004000800020), 0x1.0000200040001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7fffdf), -0x1.0000200040001p+57, -0x1p+0 },
+{ INT64_C(0x0200004000800040), 0x1.0000200040002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7fffbf), -0x1.0000200040002p+57, -0x1p+0 },
+{ INT64_C(0x0200004000800080), 0x1.0000200040004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7fff7f), -0x1.0000200040004p+57, -0x1p+0 },
+{ INT64_C(0x0200004000800100), 0x1.0000200040008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7ffeff), -0x1.0000200040008p+57, -0x1p+0 },
+{ INT64_C(0x0200004000801000), 0x1.000020004008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7fefff), -0x1.000020004008p+57, -0x1p+0 },
+{ INT64_C(0x0200004000804000), 0x1.00002000402p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7fbfff), -0x1.00002000402p+57, -0x1p+0 },
+{ INT64_C(0x0200004000810000), 0x1.00002000408p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff7effff), -0x1.00002000408p+57, -0x1p+0 },
+{ INT64_C(0x0200004000880000), 0x1.0000200044p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff77ffff), -0x1.0000200044p+57, -0x1p+0 },
+{ INT64_C(0x0200004000a00000), 0x1.000020005p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff5fffff), -0x1.000020005p+57, -0x1p+0 },
+{ INT64_C(0x0200004000c00000), 0x1.000020006p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfff3fffff), -0x1.000020006p+57, -0x1p+0 },
+{ INT64_C(0x0200004004000000), 0x1.00002002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbffffff), -0x1.00002002p+57, -0x1p+0 },
+{ INT64_C(0x0200004004000002), 0x1.00002002p+57, 0x1p+1 },
+{ INT64_C(0xfdffffbffbfffffd), -0x1.00002002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200004004000010), 0x1.00002002p+57, 0x1p+4 },
+{ INT64_C(0xfdffffbffbffffef), -0x1.0000200200001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200004004000020), 0x1.0000200200001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbffffdf), -0x1.0000200200001p+57, -0x1p+0 },
+{ INT64_C(0x0200004004000200), 0x1.000020020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbfffdff), -0x1.000020020001p+57, -0x1p+0 },
+{ INT64_C(0x0200004004001000), 0x1.000020020008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbffefff), -0x1.000020020008p+57, -0x1p+0 },
+{ INT64_C(0x0200004004008000), 0x1.00002002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbff7fff), -0x1.00002002004p+57, -0x1p+0 },
+{ INT64_C(0x0200004004020000), 0x1.0000200201p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbfdffff), -0x1.0000200201p+57, -0x1p+0 },
+{ INT64_C(0x0200004004080000), 0x1.0000200204p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffbf7ffff), -0x1.0000200204p+57, -0x1p+0 },
+{ INT64_C(0x0200004004800000), 0x1.000020024p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbffb7fffff), -0x1.000020024p+57, -0x1p+0 },
+{ INT64_C(0x0200004020000000), 0x1.0000201p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdfffffff), -0x1.0000201p+57, -0x1p+0 },
+{ INT64_C(0x0200004020000002), 0x1.0000201p+57, 0x1p+1 },
+{ INT64_C(0xfdffffbfdffffffd), -0x1.0000201p+57, -0x1.8p+1 },
+{ INT64_C(0x0200004020000004), 0x1.0000201p+57, 0x1p+2 },
+{ INT64_C(0xfdffffbfdffffffb), -0x1.0000201p+57, -0x1.4p+2 },
+{ INT64_C(0x0200004020000008), 0x1.0000201p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbfdffffff7), -0x1.0000201p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004020000080), 0x1.0000201000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdfffff7f), -0x1.0000201000004p+57, -0x1p+0 },
+{ INT64_C(0x0200004020000400), 0x1.000020100002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdffffbff), -0x1.000020100002p+57, -0x1p+0 },
+{ INT64_C(0x0200004020004000), 0x1.00002010002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdfffbfff), -0x1.00002010002p+57, -0x1p+0 },
+{ INT64_C(0x0200004020040000), 0x1.0000201002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdffbffff), -0x1.0000201002p+57, -0x1p+0 },
+{ INT64_C(0x0200004020100000), 0x1.0000201008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdfefffff), -0x1.0000201008p+57, -0x1p+0 },
+{ INT64_C(0x0200004020800000), 0x1.000020104p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdf7fffff), -0x1.000020104p+57, -0x1p+0 },
+{ INT64_C(0x0200004022000000), 0x1.00002011p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfddffffff), -0x1.00002011p+57, -0x1p+0 },
+{ INT64_C(0x0200004024000000), 0x1.00002012p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfdbffffff), -0x1.00002012p+57, -0x1p+0 },
+{ INT64_C(0x0200004028000000), 0x1.00002014p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbfd7ffffff), -0x1.00002014p+57, -0x1p+0 },
+{ INT64_C(0x0200004100000000), 0x1.0000208p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffffffff), -0x1.0000208p+57, -0x1p+0 },
+{ INT64_C(0x0200004100000001), 0x1.0000208p+57, 0x1p+0 },
+{ INT64_C(0xfdffffbefffffffe), -0x1.0000208p+57, -0x1p+1 },
+{ INT64_C(0x0200004100000002), 0x1.0000208p+57, 0x1p+1 },
+{ INT64_C(0xfdffffbefffffffd), -0x1.0000208p+57, -0x1.8p+1 },
+{ INT64_C(0x0200004100000010), 0x1.0000208p+57, 0x1p+4 },
+{ INT64_C(0xfdffffbeffffffef), -0x1.0000208000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200004100000020), 0x1.0000208000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffffffdf), -0x1.0000208000001p+57, -0x1p+0 },
+{ INT64_C(0x0200004100000040), 0x1.0000208000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffffffbf), -0x1.0000208000002p+57, -0x1p+0 },
+{ INT64_C(0x0200004100000100), 0x1.0000208000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbefffffeff), -0x1.0000208000008p+57, -0x1p+0 },
+{ INT64_C(0x0200004100000400), 0x1.000020800002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbefffffbff), -0x1.000020800002p+57, -0x1p+0 },
+{ INT64_C(0x0200004100001000), 0x1.000020800008p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffffefff), -0x1.000020800008p+57, -0x1p+0 },
+{ INT64_C(0x0200004100008000), 0x1.00002080004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffff7fff), -0x1.00002080004p+57, -0x1p+0 },
+{ INT64_C(0x0200004100020000), 0x1.0000208001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbefffdffff), -0x1.0000208001p+57, -0x1p+0 },
+{ INT64_C(0x0200004100200000), 0x1.000020801p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffdfffff), -0x1.000020801p+57, -0x1p+0 },
+{ INT64_C(0x0200004100400000), 0x1.000020802p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbeffbfffff), -0x1.000020802p+57, -0x1p+0 },
+{ INT64_C(0x0200004101000000), 0x1.000020808p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbefeffffff), -0x1.000020808p+57, -0x1p+0 },
+{ INT64_C(0x0200004102000000), 0x1.00002081p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbefdffffff), -0x1.00002081p+57, -0x1p+0 },
+{ INT64_C(0x0200004104000000), 0x1.00002082p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbefbffffff), -0x1.00002082p+57, -0x1p+0 },
+{ INT64_C(0x0200004140000000), 0x1.000020ap+57, 0x0p+0 },
+{ INT64_C(0xfdffffbebfffffff), -0x1.000020ap+57, -0x1p+0 },
+{ INT64_C(0x0200004200000000), 0x1.000021p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdffffffff), -0x1.000021p+57, -0x1p+0 },
+{ INT64_C(0x0200004200000001), 0x1.000021p+57, 0x1p+0 },
+{ INT64_C(0xfdffffbdfffffffe), -0x1.000021p+57, -0x1p+1 },
+{ INT64_C(0x0200004200000008), 0x1.000021p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbdfffffff7), -0x1.000021p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004200000040), 0x1.0000210000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdffffffbf), -0x1.0000210000002p+57, -0x1p+0 },
+{ INT64_C(0x0200004200000200), 0x1.000021000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdfffffdff), -0x1.000021000001p+57, -0x1p+0 },
+{ INT64_C(0x0200004200000400), 0x1.000021000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdfffffbff), -0x1.000021000002p+57, -0x1p+0 },
+{ INT64_C(0x0200004200002000), 0x1.00002100001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdffffdfff), -0x1.00002100001p+57, -0x1p+0 },
+{ INT64_C(0x0200004200004000), 0x1.00002100002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdffffbfff), -0x1.00002100002p+57, -0x1p+0 },
+{ INT64_C(0x0200004200020000), 0x1.0000210001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdfffdffff), -0x1.0000210001p+57, -0x1p+0 },
+{ INT64_C(0x0200004200080000), 0x1.0000210004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdfff7ffff), -0x1.0000210004p+57, -0x1p+0 },
+{ INT64_C(0x0200004200400000), 0x1.000021002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdffbfffff), -0x1.000021002p+57, -0x1p+0 },
+{ INT64_C(0x0200004200800000), 0x1.000021004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdff7fffff), -0x1.000021004p+57, -0x1p+0 },
+{ INT64_C(0x0200004204000000), 0x1.00002102p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdfbffffff), -0x1.00002102p+57, -0x1p+0 },
+{ INT64_C(0x0200004210000000), 0x1.00002108p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbdefffffff), -0x1.00002108p+57, -0x1p+0 },
+{ INT64_C(0x0200004220000000), 0x1.0000211p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbddfffffff), -0x1.0000211p+57, -0x1p+0 },
+{ INT64_C(0x0200004280000000), 0x1.0000214p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbd7fffffff), -0x1.0000214p+57, -0x1p+0 },
+{ INT64_C(0x0200004400000000), 0x1.000022p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbffffffff), -0x1.000022p+57, -0x1p+0 },
+{ INT64_C(0x0200004400000004), 0x1.000022p+57, 0x1p+2 },
+{ INT64_C(0xfdffffbbfffffffb), -0x1.000022p+57, -0x1.4p+2 },
+{ INT64_C(0x0200004400000008), 0x1.000022p+57, 0x1p+3 },
+{ INT64_C(0xfdffffbbfffffff7), -0x1.000022p+57, -0x1.2p+3 },
+{ INT64_C(0x0200004400000080), 0x1.0000220000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbffffff7f), -0x1.0000220000004p+57, -0x1p+0 },
+{ INT64_C(0x0200004400000800), 0x1.000022000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbfffff7ff), -0x1.000022000004p+57, -0x1p+0 },
+{ INT64_C(0x0200004400004000), 0x1.00002200002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbffffbfff), -0x1.00002200002p+57, -0x1p+0 },
+{ INT64_C(0x0200004400020000), 0x1.0000220001p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbfffdffff), -0x1.0000220001p+57, -0x1p+0 },
+{ INT64_C(0x0200004400040000), 0x1.0000220002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbfffbffff), -0x1.0000220002p+57, -0x1p+0 },
+{ INT64_C(0x0200004400400000), 0x1.000022002p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbffbfffff), -0x1.000022002p+57, -0x1p+0 },
+{ INT64_C(0x0200004402000000), 0x1.00002201p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbfdffffff), -0x1.00002201p+57, -0x1p+0 },
+{ INT64_C(0x0200004420000000), 0x1.0000221p+57, 0x0p+0 },
+{ INT64_C(0xfdffffbbdfffffff), -0x1.0000221p+57, -0x1p+0 },
+{ INT64_C(0x0200004600000000), 0x1.000023p+57, 0x0p+0 },
+{ INT64_C(0xfdffffb9ffffffff), -0x1.000023p+57, -0x1p+0 },
+{ INT64_C(0x0200006000000000), 0x1.00003p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fffffffff), -0x1.00003p+57, -0x1p+0 },
+{ INT64_C(0x0200006000000004), 0x1.00003p+57, 0x1p+2 },
+{ INT64_C(0xfdffff9ffffffffb), -0x1.00003p+57, -0x1.4p+2 },
+{ INT64_C(0x0200006000000010), 0x1.00003p+57, 0x1p+4 },
+{ INT64_C(0xfdffff9fffffffef), -0x1.0000300000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200006000000040), 0x1.0000300000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fffffffbf), -0x1.0000300000002p+57, -0x1p+0 },
+{ INT64_C(0x0200006000000200), 0x1.000030000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9ffffffdff), -0x1.000030000001p+57, -0x1p+0 },
+{ INT64_C(0x0200006000000400), 0x1.000030000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9ffffffbff), -0x1.000030000002p+57, -0x1p+0 },
+{ INT64_C(0x0200006000000800), 0x1.000030000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9ffffff7ff), -0x1.000030000004p+57, -0x1p+0 },
+{ INT64_C(0x0200006000004000), 0x1.00003000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fffffbfff), -0x1.00003000002p+57, -0x1p+0 },
+{ INT64_C(0x0200006000010000), 0x1.00003000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9ffffeffff), -0x1.00003000008p+57, -0x1p+0 },
+{ INT64_C(0x0200006000040000), 0x1.0000300002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9ffffbffff), -0x1.0000300002p+57, -0x1p+0 },
+{ INT64_C(0x0200006000200000), 0x1.000030001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fffdfffff), -0x1.000030001p+57, -0x1p+0 },
+{ INT64_C(0x0200006002000000), 0x1.00003001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9ffdffffff), -0x1.00003001p+57, -0x1p+0 },
+{ INT64_C(0x0200006010000000), 0x1.00003008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fefffffff), -0x1.00003008p+57, -0x1p+0 },
+{ INT64_C(0x0200006020000000), 0x1.0000301p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fdfffffff), -0x1.0000301p+57, -0x1p+0 },
+{ INT64_C(0x0200006040000000), 0x1.0000302p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9fbfffffff), -0x1.0000302p+57, -0x1p+0 },
+{ INT64_C(0x0200006100000000), 0x1.0000308p+57, 0x0p+0 },
+{ INT64_C(0xfdffff9effffffff), -0x1.0000308p+57, -0x1p+0 },
+{ INT64_C(0x0200006800000000), 0x1.000034p+57, 0x0p+0 },
+{ INT64_C(0xfdffff97ffffffff), -0x1.000034p+57, -0x1p+0 },
+{ INT64_C(0x0200008000000002), 0x1.00004p+57, 0x1p+1 },
+{ INT64_C(0xfdffff7ffffffffd), -0x1.00004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200008000000020), 0x1.0000400000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fffffffdf), -0x1.0000400000001p+57, -0x1p+0 },
+{ INT64_C(0x0200008000000021), 0x1.0000400000001p+57, 0x1p+0 },
+{ INT64_C(0xfdffff7fffffffde), -0x1.0000400000001p+57, -0x1p+1 },
+{ INT64_C(0x0200008000000024), 0x1.0000400000001p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7fffffffdb), -0x1.0000400000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008000000028), 0x1.0000400000001p+57, 0x1p+3 },
+{ INT64_C(0xfdffff7fffffffd7), -0x1.0000400000001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200008000000100), 0x1.0000400000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffffeff), -0x1.0000400000008p+57, -0x1p+0 },
+{ INT64_C(0x0200008000000101), 0x1.0000400000008p+57, 0x1p+0 },
+{ INT64_C(0xfdffff7ffffffefe), -0x1.0000400000008p+57, -0x1p+1 },
+{ INT64_C(0x0200008000000104), 0x1.0000400000008p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7ffffffefb), -0x1.0000400000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008000000108), 0x1.0000400000008p+57, 0x1p+3 },
+{ INT64_C(0xfdffff7ffffffef7), -0x1.0000400000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200008000000110), 0x1.0000400000008p+57, 0x1p+4 },
+{ INT64_C(0xfdffff7ffffffeef), -0x1.0000400000009p+57, 0x1.ep+3 },
+{ INT64_C(0x0200008000000120), 0x1.0000400000009p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffffedf), -0x1.0000400000009p+57, -0x1p+0 },
+{ INT64_C(0x0200008000000180), 0x1.000040000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffffe7f), -0x1.000040000000cp+57, -0x1p+0 },
+{ INT64_C(0x0200008000000200), 0x1.000040000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffffdff), -0x1.000040000001p+57, -0x1p+0 },
+{ INT64_C(0x0200008000000202), 0x1.000040000001p+57, 0x1p+1 },
+{ INT64_C(0xfdffff7ffffffdfd), -0x1.000040000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200008000000210), 0x1.000040000001p+57, 0x1p+4 },
+{ INT64_C(0xfdffff7ffffffdef), -0x1.0000400000011p+57, 0x1.ep+3 },
+{ INT64_C(0x0200008000000220), 0x1.0000400000011p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffffddf), -0x1.0000400000011p+57, -0x1p+0 },
+{ INT64_C(0x0200008000001000), 0x1.000040000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fffffefff), -0x1.000040000008p+57, -0x1p+0 },
+{ INT64_C(0x0200008000001004), 0x1.000040000008p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7fffffeffb), -0x1.000040000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008000001008), 0x1.000040000008p+57, 0x1p+3 },
+{ INT64_C(0xfdffff7fffffeff7), -0x1.000040000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200008000001080), 0x1.0000400000084p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fffffef7f), -0x1.0000400000084p+57, -0x1p+0 },
+{ INT64_C(0x0200008000001800), 0x1.00004000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fffffe7ff), -0x1.00004000000cp+57, -0x1p+0 },
+{ INT64_C(0x0200008000010000), 0x1.00004000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffeffff), -0x1.00004000008p+57, -0x1p+0 },
+{ INT64_C(0x0200008000010002), 0x1.00004000008p+57, 0x1p+1 },
+{ INT64_C(0xfdffff7ffffefffd), -0x1.00004000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200008000010004), 0x1.00004000008p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7ffffefffb), -0x1.00004000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008000010020), 0x1.0000400000801p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffeffdf), -0x1.0000400000801p+57, -0x1p+0 },
+{ INT64_C(0x0200008000010200), 0x1.000040000081p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffefdff), -0x1.000040000081p+57, -0x1p+0 },
+{ INT64_C(0x0200008000012000), 0x1.00004000009p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffedfff), -0x1.00004000009p+57, -0x1p+0 },
+{ INT64_C(0x0200008000020000), 0x1.0000400001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffdffff), -0x1.0000400001p+57, -0x1p+0 },
+{ INT64_C(0x0200008000020001), 0x1.0000400001p+57, 0x1p+0 },
+{ INT64_C(0xfdffff7ffffdfffe), -0x1.0000400001p+57, -0x1p+1 },
+{ INT64_C(0x0200008000020004), 0x1.0000400001p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7ffffdfffb), -0x1.0000400001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008000020010), 0x1.0000400001p+57, 0x1p+4 },
+{ INT64_C(0xfdffff7ffffdffef), -0x1.0000400001001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200008000020080), 0x1.0000400001004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffdff7f), -0x1.0000400001004p+57, -0x1p+0 },
+{ INT64_C(0x0200008000020800), 0x1.000040000104p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffdf7ff), -0x1.000040000104p+57, -0x1p+0 },
+{ INT64_C(0x0200008000028000), 0x1.00004000014p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffffd7fff), -0x1.00004000014p+57, -0x1p+0 },
+{ INT64_C(0x0200008000080000), 0x1.0000400004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffff7ffff), -0x1.0000400004p+57, -0x1p+0 },
+{ INT64_C(0x0200008000080004), 0x1.0000400004p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7ffff7fffb), -0x1.0000400004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008000080040), 0x1.0000400004002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffff7ffbf), -0x1.0000400004002p+57, -0x1p+0 },
+{ INT64_C(0x0200008000080200), 0x1.000040000401p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffff7fdff), -0x1.000040000401p+57, -0x1p+0 },
+{ INT64_C(0x0200008000082000), 0x1.00004000041p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffff7dfff), -0x1.00004000041p+57, -0x1p+0 },
+{ INT64_C(0x02000080000a0000), 0x1.0000400005p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffff5ffff), -0x1.0000400005p+57, -0x1p+0 },
+{ INT64_C(0x0200008000800000), 0x1.000040004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7fffff), -0x1.000040004p+57, -0x1p+0 },
+{ INT64_C(0x0200008000800001), 0x1.000040004p+57, 0x1p+0 },
+{ INT64_C(0xfdffff7fff7ffffe), -0x1.000040004p+57, -0x1p+1 },
+{ INT64_C(0x0200008000800010), 0x1.000040004p+57, 0x1p+4 },
+{ INT64_C(0xfdffff7fff7fffef), -0x1.0000400040001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200008000800080), 0x1.0000400040004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7fff7f), -0x1.0000400040004p+57, -0x1p+0 },
+{ INT64_C(0x0200008000800100), 0x1.0000400040008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7ffeff), -0x1.0000400040008p+57, -0x1p+0 },
+{ INT64_C(0x0200008000800400), 0x1.000040004002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7ffbff), -0x1.000040004002p+57, -0x1p+0 },
+{ INT64_C(0x0200008000800800), 0x1.000040004004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7ff7ff), -0x1.000040004004p+57, -0x1p+0 },
+{ INT64_C(0x0200008000808000), 0x1.00004000404p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7f7fff), -0x1.00004000404p+57, -0x1p+0 },
+{ INT64_C(0x0200008000820000), 0x1.0000400041p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff7dffff), -0x1.0000400041p+57, -0x1p+0 },
+{ INT64_C(0x0200008000900000), 0x1.0000400048p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff6fffff), -0x1.0000400048p+57, -0x1p+0 },
+{ INT64_C(0x0200008000c00000), 0x1.000040006p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fff3fffff), -0x1.000040006p+57, -0x1p+0 },
+{ INT64_C(0x0200008001000000), 0x1.000040008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffeffffff), -0x1.000040008p+57, -0x1p+0 },
+{ INT64_C(0x0200008001000008), 0x1.000040008p+57, 0x1p+3 },
+{ INT64_C(0xfdffff7ffefffff7), -0x1.000040008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200008001000040), 0x1.0000400080002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffeffffbf), -0x1.0000400080002p+57, -0x1p+0 },
+{ INT64_C(0x0200008001000080), 0x1.0000400080004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffeffff7f), -0x1.0000400080004p+57, -0x1p+0 },
+{ INT64_C(0x0200008001000200), 0x1.000040008001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffefffdff), -0x1.000040008001p+57, -0x1p+0 },
+{ INT64_C(0x0200008001001000), 0x1.000040008008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffeffefff), -0x1.000040008008p+57, -0x1p+0 },
+{ INT64_C(0x0200008001002000), 0x1.00004000801p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffeffdfff), -0x1.00004000801p+57, -0x1p+0 },
+{ INT64_C(0x0200008001004000), 0x1.00004000802p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffeffbfff), -0x1.00004000802p+57, -0x1p+0 },
+{ INT64_C(0x0200008001040000), 0x1.0000400082p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffefbffff), -0x1.0000400082p+57, -0x1p+0 },
+{ INT64_C(0x0200008001400000), 0x1.00004000ap+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffebfffff), -0x1.00004000ap+57, -0x1p+0 },
+{ INT64_C(0x0200008004000000), 0x1.00004002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbffffff), -0x1.00004002p+57, -0x1p+0 },
+{ INT64_C(0x0200008004000004), 0x1.00004002p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7ffbfffffb), -0x1.00004002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008004000020), 0x1.0000400200001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbffffdf), -0x1.0000400200001p+57, -0x1p+0 },
+{ INT64_C(0x0200008004000200), 0x1.000040020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbfffdff), -0x1.000040020001p+57, -0x1p+0 },
+{ INT64_C(0x0200008004000400), 0x1.000040020002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbfffbff), -0x1.000040020002p+57, -0x1p+0 },
+{ INT64_C(0x0200008004001000), 0x1.000040020008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbffefff), -0x1.000040020008p+57, -0x1p+0 },
+{ INT64_C(0x0200008004002000), 0x1.00004002001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbffdfff), -0x1.00004002001p+57, -0x1p+0 },
+{ INT64_C(0x0200008004004000), 0x1.00004002002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbffbfff), -0x1.00004002002p+57, -0x1p+0 },
+{ INT64_C(0x0200008004008000), 0x1.00004002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbff7fff), -0x1.00004002004p+57, -0x1p+0 },
+{ INT64_C(0x0200008004080000), 0x1.0000400204p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbf7ffff), -0x1.0000400204p+57, -0x1p+0 },
+{ INT64_C(0x0200008004200000), 0x1.000040021p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffbdfffff), -0x1.000040021p+57, -0x1p+0 },
+{ INT64_C(0x0200008004800000), 0x1.000040024p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7ffb7fffff), -0x1.000040024p+57, -0x1p+0 },
+{ INT64_C(0x0200008020000000), 0x1.0000401p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdfffffff), -0x1.0000401p+57, -0x1p+0 },
+{ INT64_C(0x0200008020000002), 0x1.0000401p+57, 0x1p+1 },
+{ INT64_C(0xfdffff7fdffffffd), -0x1.0000401p+57, -0x1.8p+1 },
+{ INT64_C(0x0200008020000004), 0x1.0000401p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7fdffffffb), -0x1.0000401p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008020000020), 0x1.0000401000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdfffffdf), -0x1.0000401000001p+57, -0x1p+0 },
+{ INT64_C(0x0200008020000200), 0x1.000040100001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdffffdff), -0x1.000040100001p+57, -0x1p+0 },
+{ INT64_C(0x0200008020002000), 0x1.00004010001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdfffdfff), -0x1.00004010001p+57, -0x1p+0 },
+{ INT64_C(0x0200008020008000), 0x1.00004010004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdfff7fff), -0x1.00004010004p+57, -0x1p+0 },
+{ INT64_C(0x0200008020020000), 0x1.0000401001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdffdffff), -0x1.0000401001p+57, -0x1p+0 },
+{ INT64_C(0x0200008020100000), 0x1.0000401008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdfefffff), -0x1.0000401008p+57, -0x1p+0 },
+{ INT64_C(0x0200008021000000), 0x1.000040108p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fdeffffff), -0x1.000040108p+57, -0x1p+0 },
+{ INT64_C(0x0200008028000000), 0x1.00004014p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7fd7ffffff), -0x1.00004014p+57, -0x1p+0 },
+{ INT64_C(0x0200008080000000), 0x1.0000404p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7fffffff), -0x1.0000404p+57, -0x1p+0 },
+{ INT64_C(0x0200008080000002), 0x1.0000404p+57, 0x1p+1 },
+{ INT64_C(0xfdffff7f7ffffffd), -0x1.0000404p+57, -0x1.8p+1 },
+{ INT64_C(0x0200008080000004), 0x1.0000404p+57, 0x1p+2 },
+{ INT64_C(0xfdffff7f7ffffffb), -0x1.0000404p+57, -0x1.4p+2 },
+{ INT64_C(0x0200008080000040), 0x1.0000404000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7fffffbf), -0x1.0000404000002p+57, -0x1p+0 },
+{ INT64_C(0x0200008080000200), 0x1.000040400001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7ffffdff), -0x1.000040400001p+57, -0x1p+0 },
+{ INT64_C(0x0200008080000400), 0x1.000040400002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7ffffbff), -0x1.000040400002p+57, -0x1p+0 },
+{ INT64_C(0x0200008080001000), 0x1.000040400008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7fffefff), -0x1.000040400008p+57, -0x1p+0 },
+{ INT64_C(0x0200008080004000), 0x1.00004040002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7fffbfff), -0x1.00004040002p+57, -0x1p+0 },
+{ INT64_C(0x0200008080040000), 0x1.0000404002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7ffbffff), -0x1.0000404002p+57, -0x1p+0 },
+{ INT64_C(0x0200008080400000), 0x1.000040402p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7fbfffff), -0x1.000040402p+57, -0x1p+0 },
+{ INT64_C(0x0200008080800000), 0x1.000040404p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7f7fffff), -0x1.000040404p+57, -0x1p+0 },
+{ INT64_C(0x0200008081000000), 0x1.000040408p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7effffff), -0x1.000040408p+57, -0x1p+0 },
+{ INT64_C(0x0200008082000000), 0x1.00004041p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f7dffffff), -0x1.00004041p+57, -0x1p+0 },
+{ INT64_C(0x0200008088000000), 0x1.00004044p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f77ffffff), -0x1.00004044p+57, -0x1p+0 },
+{ INT64_C(0x0200008090000000), 0x1.00004048p+57, 0x0p+0 },
+{ INT64_C(0xfdffff7f6fffffff), -0x1.00004048p+57, -0x1p+0 },
+{ INT64_C(0x0200008800000000), 0x1.000044p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77ffffffff), -0x1.000044p+57, -0x1p+0 },
+{ INT64_C(0x0200008800000001), 0x1.000044p+57, 0x1p+0 },
+{ INT64_C(0xfdffff77fffffffe), -0x1.000044p+57, -0x1p+1 },
+{ INT64_C(0x0200008800000010), 0x1.000044p+57, 0x1p+4 },
+{ INT64_C(0xfdffff77ffffffef), -0x1.0000440000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200008800000080), 0x1.0000440000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77ffffff7f), -0x1.0000440000004p+57, -0x1p+0 },
+{ INT64_C(0x0200008800000200), 0x1.000044000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77fffffdff), -0x1.000044000001p+57, -0x1p+0 },
+{ INT64_C(0x0200008800000800), 0x1.000044000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77fffff7ff), -0x1.000044000004p+57, -0x1p+0 },
+{ INT64_C(0x0200008800001000), 0x1.000044000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77ffffefff), -0x1.000044000008p+57, -0x1p+0 },
+{ INT64_C(0x0200008800010000), 0x1.00004400008p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77fffeffff), -0x1.00004400008p+57, -0x1p+0 },
+{ INT64_C(0x0200008800040000), 0x1.0000440002p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77fffbffff), -0x1.0000440002p+57, -0x1p+0 },
+{ INT64_C(0x0200008800200000), 0x1.000044001p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77ffdfffff), -0x1.000044001p+57, -0x1p+0 },
+{ INT64_C(0x0200008802000000), 0x1.00004401p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77fdffffff), -0x1.00004401p+57, -0x1p+0 },
+{ INT64_C(0x0200008820000000), 0x1.0000441p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77dfffffff), -0x1.0000441p+57, -0x1p+0 },
+{ INT64_C(0x0200008840000000), 0x1.0000442p+57, 0x0p+0 },
+{ INT64_C(0xfdffff77bfffffff), -0x1.0000442p+57, -0x1p+0 },
+{ INT64_C(0x0200008880000000), 0x1.0000444p+57, 0x0p+0 },
+{ INT64_C(0xfdffff777fffffff), -0x1.0000444p+57, -0x1p+0 },
+{ INT64_C(0x0200008c00000000), 0x1.000046p+57, 0x0p+0 },
+{ INT64_C(0xfdffff73ffffffff), -0x1.000046p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000004), 0x1.0002p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbfffffffffb), -0x1.0002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040000000006), 0x1.0002p+57, 0x1.8p+2 },
+{ INT64_C(0xfdfffbfffffffff9), -0x1.0002p+57, -0x1.cp+2 },
+{ INT64_C(0x0200040000000040), 0x1.0002000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffffffbf), -0x1.0002000000002p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000041), 0x1.0002000000002p+57, 0x1p+0 },
+{ INT64_C(0xfdfffbffffffffbe), -0x1.0002000000002p+57, -0x1p+1 },
+{ INT64_C(0x0200040000000050), 0x1.0002000000002p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbffffffffaf), -0x1.0002000000003p+57, 0x1.ep+3 },
+{ INT64_C(0x0200040000000200), 0x1.000200000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffffdff), -0x1.000200000001p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000204), 0x1.000200000001p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbfffffffdfb), -0x1.000200000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040000000220), 0x1.0002000000011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffffddf), -0x1.0002000000011p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000300), 0x1.0002000000018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffffcff), -0x1.0002000000018p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000800), 0x1.000200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffff7ff), -0x1.000200000004p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000801), 0x1.000200000004p+57, 0x1p+0 },
+{ INT64_C(0xfdfffbfffffff7fe), -0x1.000200000004p+57, -0x1p+1 },
+{ INT64_C(0x0200040000000808), 0x1.000200000004p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbfffffff7f7), -0x1.000200000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200040000000810), 0x1.000200000004p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbfffffff7ef), -0x1.0002000000041p+57, 0x1.ep+3 },
+{ INT64_C(0x0200040000000900), 0x1.0002000000048p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffff6ff), -0x1.0002000000048p+57, -0x1p+0 },
+{ INT64_C(0x0200040000000c00), 0x1.000200000006p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffff3ff), -0x1.000200000006p+57, -0x1p+0 },
+{ INT64_C(0x0200040000001000), 0x1.000200000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffffefff), -0x1.000200000008p+57, -0x1p+0 },
+{ INT64_C(0x0200040000001001), 0x1.000200000008p+57, 0x1p+0 },
+{ INT64_C(0xfdfffbffffffeffe), -0x1.000200000008p+57, -0x1p+1 },
+{ INT64_C(0x0200040000001002), 0x1.000200000008p+57, 0x1p+1 },
+{ INT64_C(0xfdfffbffffffeffd), -0x1.000200000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200040000001004), 0x1.000200000008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbffffffeffb), -0x1.000200000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040000001010), 0x1.000200000008p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbffffffefef), -0x1.0002000000081p+57, 0x1.ep+3 },
+{ INT64_C(0x0200040000001100), 0x1.0002000000088p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffffeeff), -0x1.0002000000088p+57, -0x1p+0 },
+{ INT64_C(0x0200040000001400), 0x1.00020000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffffebff), -0x1.00020000000ap+57, -0x1p+0 },
+{ INT64_C(0x0200040000008000), 0x1.00020000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff7fff), -0x1.00020000004p+57, -0x1p+0 },
+{ INT64_C(0x0200040000008004), 0x1.00020000004p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbffffff7ffb), -0x1.00020000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040000008040), 0x1.0002000000402p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff7fbf), -0x1.0002000000402p+57, -0x1p+0 },
+{ INT64_C(0x0200040000008100), 0x1.0002000000408p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff7eff), -0x1.0002000000408p+57, -0x1p+0 },
+{ INT64_C(0x0200040000008800), 0x1.000200000044p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff77ff), -0x1.000200000044p+57, -0x1p+0 },
+{ INT64_C(0x0200040000009000), 0x1.000200000048p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff6fff), -0x1.000200000048p+57, -0x1p+0 },
+{ INT64_C(0x020004000000a000), 0x1.00020000005p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff5fff), -0x1.00020000005p+57, -0x1p+0 },
+{ INT64_C(0x020004000000c000), 0x1.00020000006p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffff3fff), -0x1.00020000006p+57, -0x1p+0 },
+{ INT64_C(0x0200040000040000), 0x1.0002000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffbffff), -0x1.0002000002p+57, -0x1p+0 },
+{ INT64_C(0x0200040000040002), 0x1.0002000002p+57, 0x1p+1 },
+{ INT64_C(0xfdfffbfffffbfffd), -0x1.0002000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200040000040020), 0x1.0002000002001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffbffdf), -0x1.0002000002001p+57, -0x1p+0 },
+{ INT64_C(0x0200040000040080), 0x1.0002000002004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffbff7f), -0x1.0002000002004p+57, -0x1p+0 },
+{ INT64_C(0x0200040000040200), 0x1.000200000201p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffbfdff), -0x1.000200000201p+57, -0x1p+0 },
+{ INT64_C(0x0200040000040400), 0x1.000200000202p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffbfbff), -0x1.000200000202p+57, -0x1p+0 },
+{ INT64_C(0x0200040000040800), 0x1.000200000204p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffbf7ff), -0x1.000200000204p+57, -0x1p+0 },
+{ INT64_C(0x0200040000048000), 0x1.00020000024p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffffb7fff), -0x1.00020000024p+57, -0x1p+0 },
+{ INT64_C(0x0200040000060000), 0x1.0002000003p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffff9ffff), -0x1.0002000003p+57, -0x1p+0 },
+{ INT64_C(0x0200040000080000), 0x1.0002000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffff7ffff), -0x1.0002000004p+57, -0x1p+0 },
+{ INT64_C(0x0200040000080004), 0x1.0002000004p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbfffff7fffb), -0x1.0002000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040000080008), 0x1.0002000004p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbfffff7fff7), -0x1.0002000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200040000080080), 0x1.0002000004004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffff7ff7f), -0x1.0002000004004p+57, -0x1p+0 },
+{ INT64_C(0x0200040000080800), 0x1.000200000404p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffff7f7ff), -0x1.000200000404p+57, -0x1p+0 },
+{ INT64_C(0x0200040000081000), 0x1.000200000408p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffff7efff), -0x1.000200000408p+57, -0x1p+0 },
+{ INT64_C(0x0200040000090000), 0x1.00020000048p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffff6ffff), -0x1.00020000048p+57, -0x1p+0 },
+{ INT64_C(0x0200040000100000), 0x1.0002000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffefffff), -0x1.0002000008p+57, -0x1p+0 },
+{ INT64_C(0x0200040000100004), 0x1.0002000008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbffffeffffb), -0x1.0002000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040000100008), 0x1.0002000008p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbffffeffff7), -0x1.0002000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200040000100010), 0x1.0002000008p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbffffefffef), -0x1.0002000008001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200040000100020), 0x1.0002000008001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffefffdf), -0x1.0002000008001p+57, -0x1p+0 },
+{ INT64_C(0x0200040000100200), 0x1.000200000801p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffeffdff), -0x1.000200000801p+57, -0x1p+0 },
+{ INT64_C(0x0200040000100800), 0x1.000200000804p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffeff7ff), -0x1.000200000804p+57, -0x1p+0 },
+{ INT64_C(0x0200040000104000), 0x1.00020000082p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffefbfff), -0x1.00020000082p+57, -0x1p+0 },
+{ INT64_C(0x0200040000110000), 0x1.00020000088p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffeeffff), -0x1.00020000088p+57, -0x1p+0 },
+{ INT64_C(0x0200040000200000), 0x1.000200001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffdfffff), -0x1.000200001p+57, -0x1p+0 },
+{ INT64_C(0x0200040000200008), 0x1.000200001p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbffffdffff7), -0x1.000200001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200040000200040), 0x1.0002000010002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffdfffbf), -0x1.0002000010002p+57, -0x1p+0 },
+{ INT64_C(0x0200040000200400), 0x1.000200001002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffdffbff), -0x1.000200001002p+57, -0x1p+0 },
+{ INT64_C(0x0200040000204000), 0x1.00020000102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffdfbfff), -0x1.00020000102p+57, -0x1p+0 },
+{ INT64_C(0x0200040000208000), 0x1.00020000104p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffdf7fff), -0x1.00020000104p+57, -0x1p+0 },
+{ INT64_C(0x0200040000210000), 0x1.00020000108p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffdeffff), -0x1.00020000108p+57, -0x1p+0 },
+{ INT64_C(0x0200040000220000), 0x1.0002000011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffddffff), -0x1.0002000011p+57, -0x1p+0 },
+{ INT64_C(0x0200040000300000), 0x1.0002000018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffffcfffff), -0x1.0002000018p+57, -0x1p+0 },
+{ INT64_C(0x0200040002000000), 0x1.00020001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdffffff), -0x1.00020001p+57, -0x1p+0 },
+{ INT64_C(0x0200040002000002), 0x1.00020001p+57, 0x1p+1 },
+{ INT64_C(0xfdfffbfffdfffffd), -0x1.00020001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200040002000010), 0x1.00020001p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbfffdffffef), -0x1.0002000100001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200040002000020), 0x1.0002000100001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdffffdf), -0x1.0002000100001p+57, -0x1p+0 },
+{ INT64_C(0x0200040002000040), 0x1.0002000100002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdffffbf), -0x1.0002000100002p+57, -0x1p+0 },
+{ INT64_C(0x0200040002000100), 0x1.0002000100008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdfffeff), -0x1.0002000100008p+57, -0x1p+0 },
+{ INT64_C(0x0200040002000800), 0x1.000200010004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdfff7ff), -0x1.000200010004p+57, -0x1p+0 },
+{ INT64_C(0x0200040002004000), 0x1.00020001002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdffbfff), -0x1.00020001002p+57, -0x1p+0 },
+{ INT64_C(0x0200040002008000), 0x1.00020001004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdff7fff), -0x1.00020001004p+57, -0x1p+0 },
+{ INT64_C(0x0200040002010000), 0x1.00020001008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdfeffff), -0x1.00020001008p+57, -0x1p+0 },
+{ INT64_C(0x0200040002100000), 0x1.0002000108p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdefffff), -0x1.0002000108p+57, -0x1p+0 },
+{ INT64_C(0x0200040002400000), 0x1.000200012p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffdbfffff), -0x1.000200012p+57, -0x1p+0 },
+{ INT64_C(0x0200040003000000), 0x1.000200018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfffcffffff), -0x1.000200018p+57, -0x1p+0 },
+{ INT64_C(0x0200040020000000), 0x1.0002001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdfffffff), -0x1.0002001p+57, -0x1p+0 },
+{ INT64_C(0x0200040020000002), 0x1.0002001p+57, 0x1p+1 },
+{ INT64_C(0xfdfffbffdffffffd), -0x1.0002001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200040020000010), 0x1.0002001p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbffdfffffef), -0x1.0002001000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200040020000040), 0x1.0002001000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdfffffbf), -0x1.0002001000002p+57, -0x1p+0 },
+{ INT64_C(0x0200040020000400), 0x1.000200100002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdffffbff), -0x1.000200100002p+57, -0x1p+0 },
+{ INT64_C(0x0200040020002000), 0x1.00020010001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdfffdfff), -0x1.00020010001p+57, -0x1p+0 },
+{ INT64_C(0x0200040020020000), 0x1.0002001001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdffdffff), -0x1.0002001001p+57, -0x1p+0 },
+{ INT64_C(0x0200040020100000), 0x1.0002001008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdfefffff), -0x1.0002001008p+57, -0x1p+0 },
+{ INT64_C(0x0200040020800000), 0x1.000200104p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdf7fffff), -0x1.000200104p+57, -0x1p+0 },
+{ INT64_C(0x0200040021000000), 0x1.000200108p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffdeffffff), -0x1.000200108p+57, -0x1p+0 },
+{ INT64_C(0x0200040022000000), 0x1.00020011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffddffffff), -0x1.00020011p+57, -0x1p+0 },
+{ INT64_C(0x0200040030000000), 0x1.00020018p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbffcfffffff), -0x1.00020018p+57, -0x1p+0 },
+{ INT64_C(0x0200040100000000), 0x1.0002008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeffffffff), -0x1.0002008p+57, -0x1p+0 },
+{ INT64_C(0x0200040100000002), 0x1.0002008p+57, 0x1p+1 },
+{ INT64_C(0xfdfffbfefffffffd), -0x1.0002008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200040100000004), 0x1.0002008p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbfefffffffb), -0x1.0002008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040100000008), 0x1.0002008p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbfefffffff7), -0x1.0002008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200040100000020), 0x1.0002008000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeffffffdf), -0x1.0002008000001p+57, -0x1p+0 },
+{ INT64_C(0x0200040100000080), 0x1.0002008000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeffffff7f), -0x1.0002008000004p+57, -0x1p+0 },
+{ INT64_C(0x0200040100000800), 0x1.000200800004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfefffff7ff), -0x1.000200800004p+57, -0x1p+0 },
+{ INT64_C(0x0200040100002000), 0x1.00020080001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeffffdfff), -0x1.00020080001p+57, -0x1p+0 },
+{ INT64_C(0x0200040100020000), 0x1.0002008001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfefffdffff), -0x1.0002008001p+57, -0x1p+0 },
+{ INT64_C(0x0200040100040000), 0x1.0002008002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfefffbffff), -0x1.0002008002p+57, -0x1p+0 },
+{ INT64_C(0x0200040100200000), 0x1.000200801p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeffdfffff), -0x1.000200801p+57, -0x1p+0 },
+{ INT64_C(0x0200040100800000), 0x1.000200804p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeff7fffff), -0x1.000200804p+57, -0x1p+0 },
+{ INT64_C(0x0200040104000000), 0x1.00020082p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfefbffffff), -0x1.00020082p+57, -0x1p+0 },
+{ INT64_C(0x0200040110000000), 0x1.00020088p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfeefffffff), -0x1.00020088p+57, -0x1p+0 },
+{ INT64_C(0x0200040200000000), 0x1.000201p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdffffffff), -0x1.000201p+57, -0x1p+0 },
+{ INT64_C(0x0200040200000001), 0x1.000201p+57, 0x1p+0 },
+{ INT64_C(0xfdfffbfdfffffffe), -0x1.000201p+57, -0x1p+1 },
+{ INT64_C(0x0200040200000004), 0x1.000201p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbfdfffffffb), -0x1.000201p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040200000020), 0x1.0002010000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdffffffdf), -0x1.0002010000001p+57, -0x1p+0 },
+{ INT64_C(0x0200040200000100), 0x1.0002010000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdfffffeff), -0x1.0002010000008p+57, -0x1p+0 },
+{ INT64_C(0x0200040200001000), 0x1.000201000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdffffefff), -0x1.000201000008p+57, -0x1p+0 },
+{ INT64_C(0x0200040200010000), 0x1.00020100008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdfffeffff), -0x1.00020100008p+57, -0x1p+0 },
+{ INT64_C(0x0200040200100000), 0x1.0002010008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdffefffff), -0x1.0002010008p+57, -0x1p+0 },
+{ INT64_C(0x0200040200400000), 0x1.000201002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdffbfffff), -0x1.000201002p+57, -0x1p+0 },
+{ INT64_C(0x0200040201000000), 0x1.000201008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdfeffffff), -0x1.000201008p+57, -0x1p+0 },
+{ INT64_C(0x0200040210000000), 0x1.00020108p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdefffffff), -0x1.00020108p+57, -0x1p+0 },
+{ INT64_C(0x0200040220000000), 0x1.0002011p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfddfffffff), -0x1.0002011p+57, -0x1p+0 },
+{ INT64_C(0x0200040240000000), 0x1.0002012p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfdbfffffff), -0x1.0002012p+57, -0x1p+0 },
+{ INT64_C(0x0200040280000000), 0x1.0002014p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbfd7fffffff), -0x1.0002014p+57, -0x1p+0 },
+{ INT64_C(0x0200040800000000), 0x1.000204p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7ffffffff), -0x1.000204p+57, -0x1p+0 },
+{ INT64_C(0x0200040800000002), 0x1.000204p+57, 0x1p+1 },
+{ INT64_C(0xfdfffbf7fffffffd), -0x1.000204p+57, -0x1.8p+1 },
+{ INT64_C(0x0200040800000004), 0x1.000204p+57, 0x1p+2 },
+{ INT64_C(0xfdfffbf7fffffffb), -0x1.000204p+57, -0x1.4p+2 },
+{ INT64_C(0x0200040800000008), 0x1.000204p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbf7fffffff7), -0x1.000204p+57, -0x1.2p+3 },
+{ INT64_C(0x0200040800000040), 0x1.0002040000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7ffffffbf), -0x1.0002040000002p+57, -0x1p+0 },
+{ INT64_C(0x0200040800000100), 0x1.0002040000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7fffffeff), -0x1.0002040000008p+57, -0x1p+0 },
+{ INT64_C(0x0200040800000800), 0x1.000204000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7fffff7ff), -0x1.000204000004p+57, -0x1p+0 },
+{ INT64_C(0x0200040800001000), 0x1.000204000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7ffffefff), -0x1.000204000008p+57, -0x1p+0 },
+{ INT64_C(0x0200040800004000), 0x1.00020400002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7ffffbfff), -0x1.00020400002p+57, -0x1p+0 },
+{ INT64_C(0x0200040800008000), 0x1.00020400004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7ffff7fff), -0x1.00020400004p+57, -0x1p+0 },
+{ INT64_C(0x0200040800080000), 0x1.0002040004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7fff7ffff), -0x1.0002040004p+57, -0x1p+0 },
+{ INT64_C(0x0200040800800000), 0x1.000204004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7ff7fffff), -0x1.000204004p+57, -0x1p+0 },
+{ INT64_C(0x0200040808000000), 0x1.00020404p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7f7ffffff), -0x1.00020404p+57, -0x1p+0 },
+{ INT64_C(0x0200040820000000), 0x1.0002041p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf7dfffffff), -0x1.0002041p+57, -0x1p+0 },
+{ INT64_C(0x0200040900000000), 0x1.0002048p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbf6ffffffff), -0x1.0002048p+57, -0x1p+0 },
+{ INT64_C(0x0200042000000000), 0x1.00021p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdfffffffff), -0x1.00021p+57, -0x1p+0 },
+{ INT64_C(0x0200042000000008), 0x1.00021p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbdffffffff7), -0x1.00021p+57, -0x1.2p+3 },
+{ INT64_C(0x0200042000000010), 0x1.00021p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbdfffffffef), -0x1.0002100000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200042000000100), 0x1.0002100000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdffffffeff), -0x1.0002100000008p+57, -0x1p+0 },
+{ INT64_C(0x0200042000000800), 0x1.000210000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdffffff7ff), -0x1.000210000004p+57, -0x1p+0 },
+{ INT64_C(0x0200042000002000), 0x1.00021000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdfffffdfff), -0x1.00021000001p+57, -0x1p+0 },
+{ INT64_C(0x0200042000008000), 0x1.00021000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdfffff7fff), -0x1.00021000004p+57, -0x1p+0 },
+{ INT64_C(0x0200042000010000), 0x1.00021000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdffffeffff), -0x1.00021000008p+57, -0x1p+0 },
+{ INT64_C(0x0200042000100000), 0x1.0002100008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdfffefffff), -0x1.0002100008p+57, -0x1p+0 },
+{ INT64_C(0x0200042000400000), 0x1.000210002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdfffbfffff), -0x1.000210002p+57, -0x1p+0 },
+{ INT64_C(0x0200042004000000), 0x1.00021002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdffbffffff), -0x1.00021002p+57, -0x1p+0 },
+{ INT64_C(0x0200042040000000), 0x1.0002102p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdfbfffffff), -0x1.0002102p+57, -0x1p+0 },
+{ INT64_C(0x0200042400000000), 0x1.000212p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbdbffffffff), -0x1.000212p+57, -0x1p+0 },
+{ INT64_C(0x0200044000000000), 0x1.00022p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfffffffff), -0x1.00022p+57, -0x1p+0 },
+{ INT64_C(0x0200044000000008), 0x1.00022p+57, 0x1p+3 },
+{ INT64_C(0xfdfffbbffffffff7), -0x1.00022p+57, -0x1.2p+3 },
+{ INT64_C(0x0200044000000010), 0x1.00022p+57, 0x1p+4 },
+{ INT64_C(0xfdfffbbfffffffef), -0x1.0002200000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200044000000080), 0x1.0002200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfffffff7f), -0x1.0002200000004p+57, -0x1p+0 },
+{ INT64_C(0x0200044000000100), 0x1.0002200000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbffffffeff), -0x1.0002200000008p+57, -0x1p+0 },
+{ INT64_C(0x0200044000000400), 0x1.000220000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbffffffbff), -0x1.000220000002p+57, -0x1p+0 },
+{ INT64_C(0x0200044000001000), 0x1.000220000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfffffefff), -0x1.000220000008p+57, -0x1p+0 },
+{ INT64_C(0x0200044000004000), 0x1.00022000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfffffbfff), -0x1.00022000002p+57, -0x1p+0 },
+{ INT64_C(0x0200044000008000), 0x1.00022000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfffff7fff), -0x1.00022000004p+57, -0x1p+0 },
+{ INT64_C(0x0200044000080000), 0x1.0002200004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbffff7ffff), -0x1.0002200004p+57, -0x1p+0 },
+{ INT64_C(0x0200044000800000), 0x1.000220004p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfff7fffff), -0x1.000220004p+57, -0x1p+0 },
+{ INT64_C(0x0200044002000000), 0x1.00022001p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbffdffffff), -0x1.00022001p+57, -0x1p+0 },
+{ INT64_C(0x0200044004000000), 0x1.00022002p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbffbffffff), -0x1.00022002p+57, -0x1p+0 },
+{ INT64_C(0x0200044020000000), 0x1.0002201p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbfdfffffff), -0x1.0002201p+57, -0x1p+0 },
+{ INT64_C(0x0200044080000000), 0x1.0002204p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbf7fffffff), -0x1.0002204p+57, -0x1p+0 },
+{ INT64_C(0x0200044400000000), 0x1.000222p+57, 0x0p+0 },
+{ INT64_C(0xfdfffbbbffffffff), -0x1.000222p+57, -0x1p+0 },
+{ INT64_C(0x0200046000000000), 0x1.00023p+57, 0x0p+0 },
+{ INT64_C(0xfdfffb9fffffffff), -0x1.00023p+57, -0x1p+0 },
+{ INT64_C(0x0200060000000000), 0x1.0003p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffffffffff), -0x1.0003p+57, -0x1p+0 },
+{ INT64_C(0x0200060000000002), 0x1.0003p+57, 0x1p+1 },
+{ INT64_C(0xfdfff9fffffffffd), -0x1.0003p+57, -0x1.8p+1 },
+{ INT64_C(0x0200060000000020), 0x1.0003000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffffffffdf), -0x1.0003000000001p+57, -0x1p+0 },
+{ INT64_C(0x0200060000000080), 0x1.0003000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffffffff7f), -0x1.0003000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200060000000200), 0x1.000300000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9fffffffdff), -0x1.000300000001p+57, -0x1p+0 },
+{ INT64_C(0x0200060000002000), 0x1.00030000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffffffdfff), -0x1.00030000001p+57, -0x1p+0 },
+{ INT64_C(0x0200060000020000), 0x1.0003000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9fffffdffff), -0x1.0003000001p+57, -0x1p+0 },
+{ INT64_C(0x0200060000080000), 0x1.0003000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9fffff7ffff), -0x1.0003000004p+57, -0x1p+0 },
+{ INT64_C(0x0200060000400000), 0x1.000300002p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffffbfffff), -0x1.000300002p+57, -0x1p+0 },
+{ INT64_C(0x0200060000800000), 0x1.000300004p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffff7fffff), -0x1.000300004p+57, -0x1p+0 },
+{ INT64_C(0x0200060002000000), 0x1.00030001p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9fffdffffff), -0x1.00030001p+57, -0x1p+0 },
+{ INT64_C(0x0200060010000000), 0x1.00030008p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9ffefffffff), -0x1.00030008p+57, -0x1p+0 },
+{ INT64_C(0x0200060100000000), 0x1.0003008p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9feffffffff), -0x1.0003008p+57, -0x1p+0 },
+{ INT64_C(0x0200061000000000), 0x1.000308p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9efffffffff), -0x1.000308p+57, -0x1p+0 },
+{ INT64_C(0x0200062000000000), 0x1.00031p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9dfffffffff), -0x1.00031p+57, -0x1p+0 },
+{ INT64_C(0x0200064000000000), 0x1.00032p+57, 0x0p+0 },
+{ INT64_C(0xfdfff9bfffffffff), -0x1.00032p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000004), 0x1.002p+57, 0x1p+2 },
+{ INT64_C(0xfdffbffffffffffb), -0x1.002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200400000000006), 0x1.002p+57, 0x1.8p+2 },
+{ INT64_C(0xfdffbffffffffff9), -0x1.002p+57, -0x1.cp+2 },
+{ INT64_C(0x0200400000000010), 0x1.002p+57, 0x1p+4 },
+{ INT64_C(0xfdffbfffffffffef), -0x1.0020000000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200400000000014), 0x1.0020000000001p+57, -0x1.8p+3 },
+{ INT64_C(0xfdffbfffffffffeb), -0x1.0020000000001p+57, 0x1.6p+3 },
+{ INT64_C(0x0200400000000080), 0x1.0020000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffffff7f), -0x1.0020000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000088), 0x1.0020000000004p+57, 0x1p+3 },
+{ INT64_C(0xfdffbfffffffff77), -0x1.0020000000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200400000000200), 0x1.002000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffffdff), -0x1.002000000001p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000201), 0x1.002000000001p+57, 0x1p+0 },
+{ INT64_C(0xfdffbffffffffdfe), -0x1.002000000001p+57, -0x1p+1 },
+{ INT64_C(0x0200400000000202), 0x1.002000000001p+57, 0x1p+1 },
+{ INT64_C(0xfdffbffffffffdfd), -0x1.002000000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200400000000210), 0x1.002000000001p+57, 0x1p+4 },
+{ INT64_C(0xfdffbffffffffdef), -0x1.0020000000011p+57, 0x1.ep+3 },
+{ INT64_C(0x0200400000000280), 0x1.0020000000014p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffffd7f), -0x1.0020000000014p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000800), 0x1.002000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffff7ff), -0x1.002000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000801), 0x1.002000000004p+57, 0x1p+0 },
+{ INT64_C(0xfdffbffffffff7fe), -0x1.002000000004p+57, -0x1p+1 },
+{ INT64_C(0x0200400000000808), 0x1.002000000004p+57, 0x1p+3 },
+{ INT64_C(0xfdffbffffffff7f7), -0x1.002000000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200400000000810), 0x1.002000000004p+57, 0x1p+4 },
+{ INT64_C(0xfdffbffffffff7ef), -0x1.0020000000041p+57, 0x1.ep+3 },
+{ INT64_C(0x0200400000000840), 0x1.0020000000042p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffff7bf), -0x1.0020000000042p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000880), 0x1.0020000000044p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffff77f), -0x1.0020000000044p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000900), 0x1.0020000000048p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffff6ff), -0x1.0020000000048p+57, -0x1p+0 },
+{ INT64_C(0x0200400000000a00), 0x1.002000000005p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffff5ff), -0x1.002000000005p+57, -0x1p+0 },
+{ INT64_C(0x0200400000008000), 0x1.00200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffff7fff), -0x1.00200000004p+57, -0x1p+0 },
+{ INT64_C(0x0200400000008002), 0x1.00200000004p+57, 0x1p+1 },
+{ INT64_C(0xfdffbfffffff7ffd), -0x1.00200000004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200400000008020), 0x1.0020000000401p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffff7fdf), -0x1.0020000000401p+57, -0x1p+0 },
+{ INT64_C(0x0200400000008200), 0x1.002000000041p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffff7dff), -0x1.002000000041p+57, -0x1p+0 },
+{ INT64_C(0x0200400000009000), 0x1.002000000048p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffff6fff), -0x1.002000000048p+57, -0x1p+0 },
+{ INT64_C(0x020040000000c000), 0x1.00200000006p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffff3fff), -0x1.00200000006p+57, -0x1p+0 },
+{ INT64_C(0x0200400000040000), 0x1.0020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffbffff), -0x1.0020000002p+57, -0x1p+0 },
+{ INT64_C(0x0200400000040001), 0x1.0020000002p+57, 0x1p+0 },
+{ INT64_C(0xfdffbffffffbfffe), -0x1.0020000002p+57, -0x1p+1 },
+{ INT64_C(0x0200400000040010), 0x1.0020000002p+57, 0x1p+4 },
+{ INT64_C(0xfdffbffffffbffef), -0x1.0020000002001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200400000040080), 0x1.0020000002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffbff7f), -0x1.0020000002004p+57, -0x1p+0 },
+{ INT64_C(0x0200400000040100), 0x1.0020000002008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffbfeff), -0x1.0020000002008p+57, -0x1p+0 },
+{ INT64_C(0x0200400000040800), 0x1.002000000204p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffbf7ff), -0x1.002000000204p+57, -0x1p+0 },
+{ INT64_C(0x0200400000042000), 0x1.00200000021p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffbdfff), -0x1.00200000021p+57, -0x1p+0 },
+{ INT64_C(0x0200400000044000), 0x1.00200000022p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffffbbfff), -0x1.00200000022p+57, -0x1p+0 },
+{ INT64_C(0x0200400000060000), 0x1.0020000003p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffff9ffff), -0x1.0020000003p+57, -0x1p+0 },
+{ INT64_C(0x0200400000400000), 0x1.002000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbfffff), -0x1.002000002p+57, -0x1p+0 },
+{ INT64_C(0x0200400000400002), 0x1.002000002p+57, 0x1p+1 },
+{ INT64_C(0xfdffbfffffbffffd), -0x1.002000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0200400000400004), 0x1.002000002p+57, 0x1p+2 },
+{ INT64_C(0xfdffbfffffbffffb), -0x1.002000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200400000400020), 0x1.0020000020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbfffdf), -0x1.0020000020001p+57, -0x1p+0 },
+{ INT64_C(0x0200400000400040), 0x1.0020000020002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbfffbf), -0x1.0020000020002p+57, -0x1p+0 },
+{ INT64_C(0x0200400000400100), 0x1.0020000020008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbffeff), -0x1.0020000020008p+57, -0x1p+0 },
+{ INT64_C(0x0200400000401000), 0x1.002000002008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbfefff), -0x1.002000002008p+57, -0x1p+0 },
+{ INT64_C(0x0200400000402000), 0x1.00200000201p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbfdfff), -0x1.00200000201p+57, -0x1p+0 },
+{ INT64_C(0x0200400000410000), 0x1.00200000208p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffbeffff), -0x1.00200000208p+57, -0x1p+0 },
+{ INT64_C(0x0200400000500000), 0x1.0020000028p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffffafffff), -0x1.0020000028p+57, -0x1p+0 },
+{ INT64_C(0x0200400000600000), 0x1.002000003p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffff9fffff), -0x1.002000003p+57, -0x1p+0 },
+{ INT64_C(0x0200400001000000), 0x1.002000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffeffffff), -0x1.002000008p+57, -0x1p+0 },
+{ INT64_C(0x0200400001000001), 0x1.002000008p+57, 0x1p+0 },
+{ INT64_C(0xfdffbffffefffffe), -0x1.002000008p+57, -0x1p+1 },
+{ INT64_C(0x0200400001000008), 0x1.002000008p+57, 0x1p+3 },
+{ INT64_C(0xfdffbffffefffff7), -0x1.002000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200400001000020), 0x1.0020000080001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffeffffdf), -0x1.0020000080001p+57, -0x1p+0 },
+{ INT64_C(0x0200400001000100), 0x1.0020000080008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffefffeff), -0x1.0020000080008p+57, -0x1p+0 },
+{ INT64_C(0x0200400001000400), 0x1.002000008002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffefffbff), -0x1.002000008002p+57, -0x1p+0 },
+{ INT64_C(0x0200400001000800), 0x1.002000008004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffefff7ff), -0x1.002000008004p+57, -0x1p+0 },
+{ INT64_C(0x0200400001008000), 0x1.00200000804p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffeff7fff), -0x1.00200000804p+57, -0x1p+0 },
+{ INT64_C(0x0200400001040000), 0x1.0020000082p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffefbffff), -0x1.0020000082p+57, -0x1p+0 },
+{ INT64_C(0x0200400001400000), 0x1.00200000ap+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffebfffff), -0x1.00200000ap+57, -0x1p+0 },
+{ INT64_C(0x0200400004000000), 0x1.00200002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbffffff), -0x1.00200002p+57, -0x1p+0 },
+{ INT64_C(0x0200400004000004), 0x1.00200002p+57, 0x1p+2 },
+{ INT64_C(0xfdffbffffbfffffb), -0x1.00200002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200400004000040), 0x1.0020000200002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbffffbf), -0x1.0020000200002p+57, -0x1p+0 },
+{ INT64_C(0x0200400004000400), 0x1.002000020002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbfffbff), -0x1.002000020002p+57, -0x1p+0 },
+{ INT64_C(0x0200400004002000), 0x1.00200002001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbffdfff), -0x1.00200002001p+57, -0x1p+0 },
+{ INT64_C(0x0200400004004000), 0x1.00200002002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbffbfff), -0x1.00200002002p+57, -0x1p+0 },
+{ INT64_C(0x0200400004040000), 0x1.0020000202p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbfbffff), -0x1.0020000202p+57, -0x1p+0 },
+{ INT64_C(0x0200400004100000), 0x1.0020000208p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbefffff), -0x1.0020000208p+57, -0x1p+0 },
+{ INT64_C(0x0200400004400000), 0x1.002000022p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffbbfffff), -0x1.002000022p+57, -0x1p+0 },
+{ INT64_C(0x0200400004800000), 0x1.002000024p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffffb7fffff), -0x1.002000024p+57, -0x1p+0 },
+{ INT64_C(0x0200400006000000), 0x1.00200003p+57, 0x0p+0 },
+{ INT64_C(0xfdffbffff9ffffff), -0x1.00200003p+57, -0x1p+0 },
+{ INT64_C(0x0200400020000000), 0x1.0020001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfffffff), -0x1.0020001p+57, -0x1p+0 },
+{ INT64_C(0x0200400020000002), 0x1.0020001p+57, 0x1p+1 },
+{ INT64_C(0xfdffbfffdffffffd), -0x1.0020001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200400020000004), 0x1.0020001p+57, 0x1p+2 },
+{ INT64_C(0xfdffbfffdffffffb), -0x1.0020001p+57, -0x1.4p+2 },
+{ INT64_C(0x0200400020000020), 0x1.0020001000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfffffdf), -0x1.0020001000001p+57, -0x1p+0 },
+{ INT64_C(0x0200400020000040), 0x1.0020001000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfffffbf), -0x1.0020001000002p+57, -0x1p+0 },
+{ INT64_C(0x0200400020000200), 0x1.002000100001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdffffdff), -0x1.002000100001p+57, -0x1p+0 },
+{ INT64_C(0x0200400020000400), 0x1.002000100002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdffffbff), -0x1.002000100002p+57, -0x1p+0 },
+{ INT64_C(0x0200400020001000), 0x1.002000100008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfffefff), -0x1.002000100008p+57, -0x1p+0 },
+{ INT64_C(0x0200400020002000), 0x1.00200010001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfffdfff), -0x1.00200010001p+57, -0x1p+0 },
+{ INT64_C(0x0200400020008000), 0x1.00200010004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfff7fff), -0x1.00200010004p+57, -0x1p+0 },
+{ INT64_C(0x0200400020020000), 0x1.0020001001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdffdffff), -0x1.0020001001p+57, -0x1p+0 },
+{ INT64_C(0x0200400020100000), 0x1.0020001008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdfefffff), -0x1.0020001008p+57, -0x1p+0 },
+{ INT64_C(0x0200400020800000), 0x1.002000104p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdf7fffff), -0x1.002000104p+57, -0x1p+0 },
+{ INT64_C(0x0200400024000000), 0x1.00200012p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffdbffffff), -0x1.00200012p+57, -0x1p+0 },
+{ INT64_C(0x0200400030000000), 0x1.00200018p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffcfffffff), -0x1.00200018p+57, -0x1p+0 },
+{ INT64_C(0x0200400040000000), 0x1.0020002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbfffffff), -0x1.0020002p+57, -0x1p+0 },
+{ INT64_C(0x0200400040000008), 0x1.0020002p+57, 0x1p+3 },
+{ INT64_C(0xfdffbfffbffffff7), -0x1.0020002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200400040000020), 0x1.0020002000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbfffffdf), -0x1.0020002000001p+57, -0x1p+0 },
+{ INT64_C(0x0200400040000040), 0x1.0020002000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbfffffbf), -0x1.0020002000002p+57, -0x1p+0 },
+{ INT64_C(0x0200400040000080), 0x1.0020002000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbfffff7f), -0x1.0020002000004p+57, -0x1p+0 },
+{ INT64_C(0x0200400040000800), 0x1.002000200004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbffff7ff), -0x1.002000200004p+57, -0x1p+0 },
+{ INT64_C(0x0200400040004000), 0x1.00200020002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbfffbfff), -0x1.00200020002p+57, -0x1p+0 },
+{ INT64_C(0x0200400040020000), 0x1.0020002001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbffdffff), -0x1.0020002001p+57, -0x1p+0 },
+{ INT64_C(0x0200400040080000), 0x1.0020002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbff7ffff), -0x1.0020002004p+57, -0x1p+0 },
+{ INT64_C(0x0200400040800000), 0x1.002000204p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbf7fffff), -0x1.002000204p+57, -0x1p+0 },
+{ INT64_C(0x0200400042000000), 0x1.00200021p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfffbdffffff), -0x1.00200021p+57, -0x1p+0 },
+{ INT64_C(0x0200400060000000), 0x1.0020003p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff9fffffff), -0x1.0020003p+57, -0x1p+0 },
+{ INT64_C(0x0200400080000000), 0x1.0020004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7fffffff), -0x1.0020004p+57, -0x1p+0 },
+{ INT64_C(0x0200400080000002), 0x1.0020004p+57, 0x1p+1 },
+{ INT64_C(0xfdffbfff7ffffffd), -0x1.0020004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200400080000020), 0x1.0020004000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7fffffdf), -0x1.0020004000001p+57, -0x1p+0 },
+{ INT64_C(0x0200400080000200), 0x1.002000400001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7ffffdff), -0x1.002000400001p+57, -0x1p+0 },
+{ INT64_C(0x0200400080000800), 0x1.002000400004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7ffff7ff), -0x1.002000400004p+57, -0x1p+0 },
+{ INT64_C(0x0200400080008000), 0x1.00200040004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7fff7fff), -0x1.00200040004p+57, -0x1p+0 },
+{ INT64_C(0x0200400080040000), 0x1.0020004002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7ffbffff), -0x1.0020004002p+57, -0x1p+0 },
+{ INT64_C(0x0200400080400000), 0x1.002000402p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7fbfffff), -0x1.002000402p+57, -0x1p+0 },
+{ INT64_C(0x0200400084000000), 0x1.00200042p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff7bffffff), -0x1.00200042p+57, -0x1p+0 },
+{ INT64_C(0x0200400090000000), 0x1.00200048p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff6fffffff), -0x1.00200048p+57, -0x1p+0 },
+{ INT64_C(0x02004000c0000000), 0x1.0020006p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfff3fffffff), -0x1.0020006p+57, -0x1p+0 },
+{ INT64_C(0x0200400800000000), 0x1.002004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7ffffffff), -0x1.002004p+57, -0x1p+0 },
+{ INT64_C(0x0200400800000002), 0x1.002004p+57, 0x1p+1 },
+{ INT64_C(0xfdffbff7fffffffd), -0x1.002004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200400800000010), 0x1.002004p+57, 0x1p+4 },
+{ INT64_C(0xfdffbff7ffffffef), -0x1.0020040000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200400800000100), 0x1.0020040000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7fffffeff), -0x1.0020040000008p+57, -0x1p+0 },
+{ INT64_C(0x0200400800000400), 0x1.002004000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7fffffbff), -0x1.002004000002p+57, -0x1p+0 },
+{ INT64_C(0x0200400800001000), 0x1.002004000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7ffffefff), -0x1.002004000008p+57, -0x1p+0 },
+{ INT64_C(0x0200400800010000), 0x1.00200400008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7fffeffff), -0x1.00200400008p+57, -0x1p+0 },
+{ INT64_C(0x0200400800020000), 0x1.0020040001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7fffdffff), -0x1.0020040001p+57, -0x1p+0 },
+{ INT64_C(0x0200400800080000), 0x1.0020040004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7fff7ffff), -0x1.0020040004p+57, -0x1p+0 },
+{ INT64_C(0x0200400800400000), 0x1.002004002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7ffbfffff), -0x1.002004002p+57, -0x1p+0 },
+{ INT64_C(0x0200400800800000), 0x1.002004004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7ff7fffff), -0x1.002004004p+57, -0x1p+0 },
+{ INT64_C(0x0200400804000000), 0x1.00200402p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7fbffffff), -0x1.00200402p+57, -0x1p+0 },
+{ INT64_C(0x0200400810000000), 0x1.00200408p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7efffffff), -0x1.00200408p+57, -0x1p+0 },
+{ INT64_C(0x0200400820000000), 0x1.0020041p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff7dfffffff), -0x1.0020041p+57, -0x1p+0 },
+{ INT64_C(0x0200400880000000), 0x1.0020044p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff77fffffff), -0x1.0020044p+57, -0x1p+0 },
+{ INT64_C(0x0200400c00000000), 0x1.002006p+57, 0x0p+0 },
+{ INT64_C(0xfdffbff3ffffffff), -0x1.002006p+57, -0x1p+0 },
+{ INT64_C(0x0200402000000000), 0x1.00201p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfffffffff), -0x1.00201p+57, -0x1p+0 },
+{ INT64_C(0x0200402000000002), 0x1.00201p+57, 0x1p+1 },
+{ INT64_C(0xfdffbfdffffffffd), -0x1.00201p+57, -0x1.8p+1 },
+{ INT64_C(0x0200402000000004), 0x1.00201p+57, 0x1p+2 },
+{ INT64_C(0xfdffbfdffffffffb), -0x1.00201p+57, -0x1.4p+2 },
+{ INT64_C(0x0200402000000010), 0x1.00201p+57, 0x1p+4 },
+{ INT64_C(0xfdffbfdfffffffef), -0x1.0020100000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200402000000040), 0x1.0020100000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfffffffbf), -0x1.0020100000002p+57, -0x1p+0 },
+{ INT64_C(0x0200402000000200), 0x1.002010000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdffffffdff), -0x1.002010000001p+57, -0x1p+0 },
+{ INT64_C(0x0200402000000400), 0x1.002010000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdffffffbff), -0x1.002010000002p+57, -0x1p+0 },
+{ INT64_C(0x0200402000001000), 0x1.002010000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfffffefff), -0x1.002010000008p+57, -0x1p+0 },
+{ INT64_C(0x0200402000002000), 0x1.00201000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfffffdfff), -0x1.00201000001p+57, -0x1p+0 },
+{ INT64_C(0x0200402000010000), 0x1.00201000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdffffeffff), -0x1.00201000008p+57, -0x1p+0 },
+{ INT64_C(0x0200402000080000), 0x1.0020100004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdffff7ffff), -0x1.0020100004p+57, -0x1p+0 },
+{ INT64_C(0x0200402000100000), 0x1.0020100008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfffefffff), -0x1.0020100008p+57, -0x1p+0 },
+{ INT64_C(0x0200402000400000), 0x1.002010002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfffbfffff), -0x1.002010002p+57, -0x1p+0 },
+{ INT64_C(0x0200402000800000), 0x1.002010004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfff7fffff), -0x1.002010004p+57, -0x1p+0 },
+{ INT64_C(0x0200402002000000), 0x1.00201001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdffdffffff), -0x1.00201001p+57, -0x1p+0 },
+{ INT64_C(0x0200402004000000), 0x1.00201002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdffbffffff), -0x1.00201002p+57, -0x1p+0 },
+{ INT64_C(0x0200402010000000), 0x1.00201008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfefffffff), -0x1.00201008p+57, -0x1p+0 },
+{ INT64_C(0x0200402040000000), 0x1.0020102p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdfbfffffff), -0x1.0020102p+57, -0x1p+0 },
+{ INT64_C(0x0200402100000000), 0x1.0020108p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfdeffffffff), -0x1.0020108p+57, -0x1p+0 },
+{ INT64_C(0x0200403000000000), 0x1.002018p+57, 0x0p+0 },
+{ INT64_C(0xfdffbfcfffffffff), -0x1.002018p+57, -0x1p+0 },
+{ INT64_C(0x0200408000000000), 0x1.00204p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7fffffffff), -0x1.00204p+57, -0x1p+0 },
+{ INT64_C(0x0200408000000008), 0x1.00204p+57, 0x1p+3 },
+{ INT64_C(0xfdffbf7ffffffff7), -0x1.00204p+57, -0x1.2p+3 },
+{ INT64_C(0x0200408000000020), 0x1.0020400000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7fffffffdf), -0x1.0020400000001p+57, -0x1p+0 },
+{ INT64_C(0x0200408000000100), 0x1.0020400000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7ffffffeff), -0x1.0020400000008p+57, -0x1p+0 },
+{ INT64_C(0x0200408000000400), 0x1.002040000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7ffffffbff), -0x1.002040000002p+57, -0x1p+0 },
+{ INT64_C(0x0200408000002000), 0x1.00204000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7fffffdfff), -0x1.00204000001p+57, -0x1p+0 },
+{ INT64_C(0x0200408000010000), 0x1.00204000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7ffffeffff), -0x1.00204000008p+57, -0x1p+0 },
+{ INT64_C(0x0200408000040000), 0x1.0020400002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7ffffbffff), -0x1.0020400002p+57, -0x1p+0 },
+{ INT64_C(0x0200408000100000), 0x1.0020400008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7fffefffff), -0x1.0020400008p+57, -0x1p+0 },
+{ INT64_C(0x0200408001000000), 0x1.002040008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7ffeffffff), -0x1.002040008p+57, -0x1p+0 },
+{ INT64_C(0x0200408008000000), 0x1.00204004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7ff7ffffff), -0x1.00204004p+57, -0x1p+0 },
+{ INT64_C(0x0200408020000000), 0x1.0020401p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7fdfffffff), -0x1.0020401p+57, -0x1p+0 },
+{ INT64_C(0x0200408200000000), 0x1.002041p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf7dffffffff), -0x1.002041p+57, -0x1p+0 },
+{ INT64_C(0x0200409000000000), 0x1.002048p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf6fffffffff), -0x1.002048p+57, -0x1p+0 },
+{ INT64_C(0x020040c000000000), 0x1.00206p+57, 0x0p+0 },
+{ INT64_C(0xfdffbf3fffffffff), -0x1.00206p+57, -0x1p+0 },
+{ INT64_C(0x0200420000000000), 0x1.0021p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffffffffff), -0x1.0021p+57, -0x1p+0 },
+{ INT64_C(0x0200420000000002), 0x1.0021p+57, 0x1p+1 },
+{ INT64_C(0xfdffbdfffffffffd), -0x1.0021p+57, -0x1.8p+1 },
+{ INT64_C(0x0200420000000004), 0x1.0021p+57, 0x1p+2 },
+{ INT64_C(0xfdffbdfffffffffb), -0x1.0021p+57, -0x1.4p+2 },
+{ INT64_C(0x0200420000000010), 0x1.0021p+57, 0x1p+4 },
+{ INT64_C(0xfdffbdffffffffef), -0x1.0021000000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200420000000080), 0x1.0021000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffffffff7f), -0x1.0021000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200420000000200), 0x1.002100000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdfffffffdff), -0x1.002100000001p+57, -0x1p+0 },
+{ INT64_C(0x0200420000000800), 0x1.002100000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdfffffff7ff), -0x1.002100000004p+57, -0x1p+0 },
+{ INT64_C(0x0200420000004000), 0x1.00210000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffffffbfff), -0x1.00210000002p+57, -0x1p+0 },
+{ INT64_C(0x0200420000008000), 0x1.00210000004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffffff7fff), -0x1.00210000004p+57, -0x1p+0 },
+{ INT64_C(0x0200420000040000), 0x1.0021000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdfffffbffff), -0x1.0021000002p+57, -0x1p+0 },
+{ INT64_C(0x0200420000400000), 0x1.002100002p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffffbfffff), -0x1.002100002p+57, -0x1p+0 },
+{ INT64_C(0x0200420000800000), 0x1.002100004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffff7fffff), -0x1.002100004p+57, -0x1p+0 },
+{ INT64_C(0x0200420002000000), 0x1.00210001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdfffdffffff), -0x1.00210001p+57, -0x1p+0 },
+{ INT64_C(0x0200420008000000), 0x1.00210004p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdfff7ffffff), -0x1.00210004p+57, -0x1p+0 },
+{ INT64_C(0x0200420010000000), 0x1.00210008p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffefffffff), -0x1.00210008p+57, -0x1p+0 },
+{ INT64_C(0x0200420020000000), 0x1.0021001p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdffdfffffff), -0x1.0021001p+57, -0x1p+0 },
+{ INT64_C(0x0200420200000000), 0x1.002101p+57, 0x0p+0 },
+{ INT64_C(0xfdffbdfdffffffff), -0x1.002101p+57, -0x1p+0 },
+{ INT64_C(0x0200422000000000), 0x1.00211p+57, 0x0p+0 },
+{ INT64_C(0xfdffbddfffffffff), -0x1.00211p+57, -0x1p+0 },
+{ INT64_C(0x0200428000000000), 0x1.00214p+57, 0x0p+0 },
+{ INT64_C(0xfdffbd7fffffffff), -0x1.00214p+57, -0x1p+0 },
+{ INT64_C(0x0200500000000000), 0x1.0028p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffffffffff), -0x1.0028p+57, -0x1p+0 },
+{ INT64_C(0x0200500000000004), 0x1.0028p+57, 0x1p+2 },
+{ INT64_C(0xfdffaffffffffffb), -0x1.0028p+57, -0x1.4p+2 },
+{ INT64_C(0x0200500000000040), 0x1.0028000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffffffffbf), -0x1.0028000000002p+57, -0x1p+0 },
+{ INT64_C(0x0200500000000400), 0x1.002800000002p+57, 0x0p+0 },
+{ INT64_C(0xfdffaffffffffbff), -0x1.002800000002p+57, -0x1p+0 },
+{ INT64_C(0x0200500000002000), 0x1.00280000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffffffdfff), -0x1.00280000001p+57, -0x1p+0 },
+{ INT64_C(0x0200500000020000), 0x1.0028000001p+57, 0x0p+0 },
+{ INT64_C(0xfdffaffffffdffff), -0x1.0028000001p+57, -0x1p+0 },
+{ INT64_C(0x0200500000100000), 0x1.0028000008p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffffefffff), -0x1.0028000008p+57, -0x1p+0 },
+{ INT64_C(0x0200500000200000), 0x1.002800001p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffffdfffff), -0x1.002800001p+57, -0x1p+0 },
+{ INT64_C(0x0200500000800000), 0x1.002800004p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffff7fffff), -0x1.002800004p+57, -0x1p+0 },
+{ INT64_C(0x0200500002000000), 0x1.00280001p+57, 0x0p+0 },
+{ INT64_C(0xfdffaffffdffffff), -0x1.00280001p+57, -0x1p+0 },
+{ INT64_C(0x0200500020000000), 0x1.0028001p+57, 0x0p+0 },
+{ INT64_C(0xfdffafffdfffffff), -0x1.0028001p+57, -0x1p+0 },
+{ INT64_C(0x0200500080000000), 0x1.0028004p+57, 0x0p+0 },
+{ INT64_C(0xfdffafff7fffffff), -0x1.0028004p+57, -0x1p+0 },
+{ INT64_C(0x0200500800000000), 0x1.002804p+57, 0x0p+0 },
+{ INT64_C(0xfdffaff7ffffffff), -0x1.002804p+57, -0x1p+0 },
+{ INT64_C(0x0200502000000000), 0x1.00281p+57, 0x0p+0 },
+{ INT64_C(0xfdffafdfffffffff), -0x1.00281p+57, -0x1p+0 },
+{ INT64_C(0x0200520000000000), 0x1.0029p+57, 0x0p+0 },
+{ INT64_C(0xfdffadffffffffff), -0x1.0029p+57, -0x1p+0 },
+{ INT64_C(0x0200540000000000), 0x1.002ap+57, 0x0p+0 },
+{ INT64_C(0xfdffabffffffffff), -0x1.002ap+57, -0x1p+0 },
+{ INT64_C(0x0200580000000000), 0x1.002cp+57, 0x0p+0 },
+{ INT64_C(0xfdffa7ffffffffff), -0x1.002cp+57, -0x1p+0 },
+{ INT64_C(0x0200800000000002), 0x1.004p+57, 0x1p+1 },
+{ INT64_C(0xfdff7ffffffffffd), -0x1.004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200800000000010), 0x1.004p+57, 0x1p+4 },
+{ INT64_C(0xfdff7fffffffffef), -0x1.0040000000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200800000000012), 0x1.0040000000001p+57, -0x1.cp+3 },
+{ INT64_C(0xfdff7fffffffffed), -0x1.0040000000001p+57, 0x1.ap+3 },
+{ INT64_C(0x0200800000000018), 0x1.0040000000001p+57, -0x1p+3 },
+{ INT64_C(0xfdff7fffffffffe7), -0x1.0040000000001p+57, 0x1.cp+2 },
+{ INT64_C(0x0200800000000080), 0x1.0040000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffffff7f), -0x1.0040000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200800000000084), 0x1.0040000000004p+57, 0x1p+2 },
+{ INT64_C(0xfdff7fffffffff7b), -0x1.0040000000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0200800000000088), 0x1.0040000000004p+57, 0x1p+3 },
+{ INT64_C(0xfdff7fffffffff77), -0x1.0040000000004p+57, -0x1.2p+3 },
+{ INT64_C(0x02008000000000a0), 0x1.0040000000005p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffffff5f), -0x1.0040000000005p+57, -0x1p+0 },
+{ INT64_C(0x0200800000000400), 0x1.004000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffffbff), -0x1.004000000002p+57, -0x1p+0 },
+{ INT64_C(0x0200800000000408), 0x1.004000000002p+57, 0x1p+3 },
+{ INT64_C(0xfdff7ffffffffbf7), -0x1.004000000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800000000480), 0x1.0040000000024p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffffb7f), -0x1.0040000000024p+57, -0x1p+0 },
+{ INT64_C(0x0200800000002000), 0x1.00400000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffffdfff), -0x1.00400000001p+57, -0x1p+0 },
+{ INT64_C(0x0200800000002001), 0x1.00400000001p+57, 0x1p+0 },
+{ INT64_C(0xfdff7fffffffdffe), -0x1.00400000001p+57, -0x1p+1 },
+{ INT64_C(0x0200800000002008), 0x1.00400000001p+57, 0x1p+3 },
+{ INT64_C(0xfdff7fffffffdff7), -0x1.00400000001p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800000002080), 0x1.0040000000104p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffffdf7f), -0x1.0040000000104p+57, -0x1p+0 },
+{ INT64_C(0x0200800000002400), 0x1.004000000012p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffffdbff), -0x1.004000000012p+57, -0x1p+0 },
+{ INT64_C(0x0200800000002800), 0x1.004000000014p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffffd7ff), -0x1.004000000014p+57, -0x1p+0 },
+{ INT64_C(0x0200800000008000), 0x1.00400000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffff7fff), -0x1.00400000004p+57, -0x1p+0 },
+{ INT64_C(0x0200800000008002), 0x1.00400000004p+57, 0x1p+1 },
+{ INT64_C(0xfdff7fffffff7ffd), -0x1.00400000004p+57, -0x1.8p+1 },
+{ INT64_C(0x0200800000008008), 0x1.00400000004p+57, 0x1p+3 },
+{ INT64_C(0xfdff7fffffff7ff7), -0x1.00400000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800000008020), 0x1.0040000000401p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffff7fdf), -0x1.0040000000401p+57, -0x1p+0 },
+{ INT64_C(0x0200800000008200), 0x1.004000000041p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffff7dff), -0x1.004000000041p+57, -0x1p+0 },
+{ INT64_C(0x0200800000008400), 0x1.004000000042p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffff7bff), -0x1.004000000042p+57, -0x1p+0 },
+{ INT64_C(0x0200800000008800), 0x1.004000000044p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffff77ff), -0x1.004000000044p+57, -0x1p+0 },
+{ INT64_C(0x0200800000010000), 0x1.00400000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffeffff), -0x1.00400000008p+57, -0x1p+0 },
+{ INT64_C(0x0200800000010002), 0x1.00400000008p+57, 0x1p+1 },
+{ INT64_C(0xfdff7ffffffefffd), -0x1.00400000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0200800000010004), 0x1.00400000008p+57, 0x1p+2 },
+{ INT64_C(0xfdff7ffffffefffb), -0x1.00400000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200800000010040), 0x1.0040000000802p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffeffbf), -0x1.0040000000802p+57, -0x1p+0 },
+{ INT64_C(0x0200800000010200), 0x1.004000000081p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffefdff), -0x1.004000000081p+57, -0x1p+0 },
+{ INT64_C(0x0200800000010800), 0x1.004000000084p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffef7ff), -0x1.004000000084p+57, -0x1p+0 },
+{ INT64_C(0x0200800000014000), 0x1.0040000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffebfff), -0x1.0040000000ap+57, -0x1p+0 },
+{ INT64_C(0x0200800000018000), 0x1.0040000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffffffe7fff), -0x1.0040000000cp+57, -0x1p+0 },
+{ INT64_C(0x0200800000100000), 0x1.0040000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffefffff), -0x1.0040000008p+57, -0x1p+0 },
+{ INT64_C(0x0200800000100004), 0x1.0040000008p+57, 0x1p+2 },
+{ INT64_C(0xfdff7fffffeffffb), -0x1.0040000008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200800000100040), 0x1.0040000008002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffefffbf), -0x1.0040000008002p+57, -0x1p+0 },
+{ INT64_C(0x0200800000100100), 0x1.0040000008008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffeffeff), -0x1.0040000008008p+57, -0x1p+0 },
+{ INT64_C(0x0200800000101000), 0x1.004000000808p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffefefff), -0x1.004000000808p+57, -0x1p+0 },
+{ INT64_C(0x0200800000104000), 0x1.00400000082p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffefbfff), -0x1.00400000082p+57, -0x1p+0 },
+{ INT64_C(0x0200800000108000), 0x1.00400000084p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffef7fff), -0x1.00400000084p+57, -0x1p+0 },
+{ INT64_C(0x0200800000110000), 0x1.00400000088p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffeeffff), -0x1.00400000088p+57, -0x1p+0 },
+{ INT64_C(0x0200800000180000), 0x1.004000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffffe7ffff), -0x1.004000000cp+57, -0x1p+0 },
+{ INT64_C(0x0200800000800000), 0x1.004000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7fffff), -0x1.004000004p+57, -0x1p+0 },
+{ INT64_C(0x0200800000800008), 0x1.004000004p+57, 0x1p+3 },
+{ INT64_C(0xfdff7fffff7ffff7), -0x1.004000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800000800040), 0x1.0040000040002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7fffbf), -0x1.0040000040002p+57, -0x1p+0 },
+{ INT64_C(0x0200800000800080), 0x1.0040000040004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7fff7f), -0x1.0040000040004p+57, -0x1p+0 },
+{ INT64_C(0x0200800000800100), 0x1.0040000040008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7ffeff), -0x1.0040000040008p+57, -0x1p+0 },
+{ INT64_C(0x0200800000800400), 0x1.004000004002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7ffbff), -0x1.004000004002p+57, -0x1p+0 },
+{ INT64_C(0x0200800000802000), 0x1.00400000401p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7fdfff), -0x1.00400000401p+57, -0x1p+0 },
+{ INT64_C(0x0200800000808000), 0x1.00400000404p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7f7fff), -0x1.00400000404p+57, -0x1p+0 },
+{ INT64_C(0x0200800000810000), 0x1.00400000408p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff7effff), -0x1.00400000408p+57, -0x1p+0 },
+{ INT64_C(0x0200800000900000), 0x1.0040000048p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff6fffff), -0x1.0040000048p+57, -0x1p+0 },
+{ INT64_C(0x0200800000a00000), 0x1.004000005p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff5fffff), -0x1.004000005p+57, -0x1p+0 },
+{ INT64_C(0x0200800000c00000), 0x1.004000006p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffff3fffff), -0x1.004000006p+57, -0x1p+0 },
+{ INT64_C(0x0200800008000000), 0x1.00400004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff7ffffff), -0x1.00400004p+57, -0x1p+0 },
+{ INT64_C(0x0200800008000008), 0x1.00400004p+57, 0x1p+3 },
+{ INT64_C(0xfdff7ffff7fffff7), -0x1.00400004p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800008000080), 0x1.0040000400004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff7ffff7f), -0x1.0040000400004p+57, -0x1p+0 },
+{ INT64_C(0x0200800008000800), 0x1.004000040004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff7fff7ff), -0x1.004000040004p+57, -0x1p+0 },
+{ INT64_C(0x0200800008008000), 0x1.00400004004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff7ff7fff), -0x1.00400004004p+57, -0x1p+0 },
+{ INT64_C(0x0200800008080000), 0x1.0040000404p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff7f7ffff), -0x1.0040000404p+57, -0x1p+0 },
+{ INT64_C(0x0200800008800000), 0x1.004000044p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff77fffff), -0x1.004000044p+57, -0x1p+0 },
+{ INT64_C(0x0200800009000000), 0x1.004000048p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffff6ffffff), -0x1.004000048p+57, -0x1p+0 },
+{ INT64_C(0x0200800010000000), 0x1.00400008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffefffffff), -0x1.00400008p+57, -0x1p+0 },
+{ INT64_C(0x0200800010000001), 0x1.00400008p+57, 0x1p+0 },
+{ INT64_C(0xfdff7fffeffffffe), -0x1.00400008p+57, -0x1p+1 },
+{ INT64_C(0x0200800010000004), 0x1.00400008p+57, 0x1p+2 },
+{ INT64_C(0xfdff7fffeffffffb), -0x1.00400008p+57, -0x1.4p+2 },
+{ INT64_C(0x0200800010000008), 0x1.00400008p+57, 0x1p+3 },
+{ INT64_C(0xfdff7fffeffffff7), -0x1.00400008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800010000020), 0x1.0040000800001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffefffffdf), -0x1.0040000800001p+57, -0x1p+0 },
+{ INT64_C(0x0200800010000100), 0x1.0040000800008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffeffffeff), -0x1.0040000800008p+57, -0x1p+0 },
+{ INT64_C(0x0200800010000800), 0x1.004000080004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffeffff7ff), -0x1.004000080004p+57, -0x1p+0 },
+{ INT64_C(0x0200800010001000), 0x1.004000080008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffefffefff), -0x1.004000080008p+57, -0x1p+0 },
+{ INT64_C(0x0200800010008000), 0x1.00400008004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffefff7fff), -0x1.00400008004p+57, -0x1p+0 },
+{ INT64_C(0x0200800010020000), 0x1.0040000801p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffeffdffff), -0x1.0040000801p+57, -0x1p+0 },
+{ INT64_C(0x0200800010200000), 0x1.004000081p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffefdfffff), -0x1.004000081p+57, -0x1p+0 },
+{ INT64_C(0x0200800011000000), 0x1.004000088p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffeeffffff), -0x1.004000088p+57, -0x1p+0 },
+{ INT64_C(0x0200800018000000), 0x1.0040000cp+57, 0x0p+0 },
+{ INT64_C(0xfdff7fffe7ffffff), -0x1.0040000cp+57, -0x1p+0 },
+{ INT64_C(0x0200800100000000), 0x1.0040008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffeffffffff), -0x1.0040008p+57, -0x1p+0 },
+{ INT64_C(0x0200800100000008), 0x1.0040008p+57, 0x1p+3 },
+{ INT64_C(0xfdff7ffefffffff7), -0x1.0040008p+57, -0x1.2p+3 },
+{ INT64_C(0x0200800100000040), 0x1.0040008000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffeffffffbf), -0x1.0040008000002p+57, -0x1p+0 },
+{ INT64_C(0x0200800100000200), 0x1.004000800001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffefffffdff), -0x1.004000800001p+57, -0x1p+0 },
+{ INT64_C(0x0200800100002000), 0x1.00400080001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffeffffdfff), -0x1.00400080001p+57, -0x1p+0 },
+{ INT64_C(0x0200800100010000), 0x1.00400080008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffefffeffff), -0x1.00400080008p+57, -0x1p+0 },
+{ INT64_C(0x0200800100100000), 0x1.0040008008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffeffefffff), -0x1.0040008008p+57, -0x1p+0 },
+{ INT64_C(0x0200800101000000), 0x1.004000808p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffefeffffff), -0x1.004000808p+57, -0x1p+0 },
+{ INT64_C(0x0200800102000000), 0x1.00400081p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffefdffffff), -0x1.00400081p+57, -0x1p+0 },
+{ INT64_C(0x0200800120000000), 0x1.0040009p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffedfffffff), -0x1.0040009p+57, -0x1p+0 },
+{ INT64_C(0x0200800140000000), 0x1.004000ap+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffebfffffff), -0x1.004000ap+57, -0x1p+0 },
+{ INT64_C(0x0200800200000000), 0x1.004001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdffffffff), -0x1.004001p+57, -0x1p+0 },
+{ INT64_C(0x0200800200000002), 0x1.004001p+57, 0x1p+1 },
+{ INT64_C(0xfdff7ffdfffffffd), -0x1.004001p+57, -0x1.8p+1 },
+{ INT64_C(0x0200800200000010), 0x1.004001p+57, 0x1p+4 },
+{ INT64_C(0xfdff7ffdffffffef), -0x1.0040010000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200800200000020), 0x1.0040010000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdffffffdf), -0x1.0040010000001p+57, -0x1p+0 },
+{ INT64_C(0x0200800200000080), 0x1.0040010000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdffffff7f), -0x1.0040010000004p+57, -0x1p+0 },
+{ INT64_C(0x0200800200000200), 0x1.004001000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdfffffdff), -0x1.004001000001p+57, -0x1p+0 },
+{ INT64_C(0x0200800200000400), 0x1.004001000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdfffffbff), -0x1.004001000002p+57, -0x1p+0 },
+{ INT64_C(0x0200800200000800), 0x1.004001000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdfffff7ff), -0x1.004001000004p+57, -0x1p+0 },
+{ INT64_C(0x0200800200008000), 0x1.00400100004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdffff7fff), -0x1.00400100004p+57, -0x1p+0 },
+{ INT64_C(0x0200800200080000), 0x1.0040010004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdfff7ffff), -0x1.0040010004p+57, -0x1p+0 },
+{ INT64_C(0x0200800200400000), 0x1.004001002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdffbfffff), -0x1.004001002p+57, -0x1p+0 },
+{ INT64_C(0x0200800204000000), 0x1.00400102p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdfbffffff), -0x1.00400102p+57, -0x1p+0 },
+{ INT64_C(0x0200800220000000), 0x1.0040011p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffddfffffff), -0x1.0040011p+57, -0x1p+0 },
+{ INT64_C(0x0200800240000000), 0x1.0040012p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffdbfffffff), -0x1.0040012p+57, -0x1p+0 },
+{ INT64_C(0x0200800280000000), 0x1.0040014p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffd7fffffff), -0x1.0040014p+57, -0x1p+0 },
+{ INT64_C(0x0200800300000000), 0x1.0040018p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffcffffffff), -0x1.0040018p+57, -0x1p+0 },
+{ INT64_C(0x0200800400000000), 0x1.004002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffffffff), -0x1.004002p+57, -0x1p+0 },
+{ INT64_C(0x0200800400000004), 0x1.004002p+57, 0x1p+2 },
+{ INT64_C(0xfdff7ffbfffffffb), -0x1.004002p+57, -0x1.4p+2 },
+{ INT64_C(0x0200800400000010), 0x1.004002p+57, 0x1p+4 },
+{ INT64_C(0xfdff7ffbffffffef), -0x1.0040020000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200800400000020), 0x1.0040020000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffffffdf), -0x1.0040020000001p+57, -0x1p+0 },
+{ INT64_C(0x0200800400000040), 0x1.0040020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffffffbf), -0x1.0040020000002p+57, -0x1p+0 },
+{ INT64_C(0x0200800400000100), 0x1.0040020000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbfffffeff), -0x1.0040020000008p+57, -0x1p+0 },
+{ INT64_C(0x0200800400000800), 0x1.004002000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbfffff7ff), -0x1.004002000004p+57, -0x1p+0 },
+{ INT64_C(0x0200800400004000), 0x1.00400200002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffffbfff), -0x1.00400200002p+57, -0x1p+0 },
+{ INT64_C(0x0200800400020000), 0x1.0040020001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbfffdffff), -0x1.0040020001p+57, -0x1p+0 },
+{ INT64_C(0x0200800400100000), 0x1.0040020008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffefffff), -0x1.0040020008p+57, -0x1p+0 },
+{ INT64_C(0x0200800400200000), 0x1.004002001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffdfffff), -0x1.004002001p+57, -0x1p+0 },
+{ INT64_C(0x0200800400400000), 0x1.004002002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbffbfffff), -0x1.004002002p+57, -0x1p+0 },
+{ INT64_C(0x0200800404000000), 0x1.00400202p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbfbffffff), -0x1.00400202p+57, -0x1p+0 },
+{ INT64_C(0x0200800410000000), 0x1.00400208p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffbefffffff), -0x1.00400208p+57, -0x1p+0 },
+{ INT64_C(0x0200800500000000), 0x1.0040028p+57, 0x0p+0 },
+{ INT64_C(0xfdff7ffaffffffff), -0x1.0040028p+57, -0x1p+0 },
+{ INT64_C(0x0200804000000000), 0x1.00402p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfffffffff), -0x1.00402p+57, -0x1p+0 },
+{ INT64_C(0x0200804000000008), 0x1.00402p+57, 0x1p+3 },
+{ INT64_C(0xfdff7fbffffffff7), -0x1.00402p+57, -0x1.2p+3 },
+{ INT64_C(0x0200804000000020), 0x1.0040200000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfffffffdf), -0x1.0040200000001p+57, -0x1p+0 },
+{ INT64_C(0x0200804000000200), 0x1.004020000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbffffffdff), -0x1.004020000001p+57, -0x1p+0 },
+{ INT64_C(0x0200804000000800), 0x1.004020000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbffffff7ff), -0x1.004020000004p+57, -0x1p+0 },
+{ INT64_C(0x0200804000001000), 0x1.004020000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfffffefff), -0x1.004020000008p+57, -0x1p+0 },
+{ INT64_C(0x0200804000010000), 0x1.00402000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbffffeffff), -0x1.00402000008p+57, -0x1p+0 },
+{ INT64_C(0x0200804000100000), 0x1.0040200008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfffefffff), -0x1.0040200008p+57, -0x1p+0 },
+{ INT64_C(0x0200804000400000), 0x1.004020002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfffbfffff), -0x1.004020002p+57, -0x1p+0 },
+{ INT64_C(0x0200804000800000), 0x1.004020004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfff7fffff), -0x1.004020004p+57, -0x1p+0 },
+{ INT64_C(0x0200804001000000), 0x1.004020008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbffeffffff), -0x1.004020008p+57, -0x1p+0 },
+{ INT64_C(0x0200804002000000), 0x1.00402001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbffdffffff), -0x1.00402001p+57, -0x1p+0 },
+{ INT64_C(0x0200804020000000), 0x1.0040201p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbfdfffffff), -0x1.0040201p+57, -0x1p+0 },
+{ INT64_C(0x0200804100000000), 0x1.0040208p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fbeffffffff), -0x1.0040208p+57, -0x1p+0 },
+{ INT64_C(0x0200804800000000), 0x1.004024p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fb7ffffffff), -0x1.004024p+57, -0x1p+0 },
+{ INT64_C(0x0200805000000000), 0x1.004028p+57, 0x0p+0 },
+{ INT64_C(0xfdff7fafffffffff), -0x1.004028p+57, -0x1p+0 },
+{ INT64_C(0x0200808000000000), 0x1.00404p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffffffff), -0x1.00404p+57, -0x1p+0 },
+{ INT64_C(0x0200808000000004), 0x1.00404p+57, 0x1p+2 },
+{ INT64_C(0xfdff7f7ffffffffb), -0x1.00404p+57, -0x1.4p+2 },
+{ INT64_C(0x0200808000000010), 0x1.00404p+57, 0x1p+4 },
+{ INT64_C(0xfdff7f7fffffffef), -0x1.0040400000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200808000000080), 0x1.0040400000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffffff7f), -0x1.0040400000004p+57, -0x1p+0 },
+{ INT64_C(0x0200808000000200), 0x1.004040000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7ffffffdff), -0x1.004040000001p+57, -0x1p+0 },
+{ INT64_C(0x0200808000002000), 0x1.00404000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffffdfff), -0x1.00404000001p+57, -0x1p+0 },
+{ INT64_C(0x0200808000004000), 0x1.00404000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffffbfff), -0x1.00404000002p+57, -0x1p+0 },
+{ INT64_C(0x0200808000008000), 0x1.00404000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffff7fff), -0x1.00404000004p+57, -0x1p+0 },
+{ INT64_C(0x0200808000010000), 0x1.00404000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7ffffeffff), -0x1.00404000008p+57, -0x1p+0 },
+{ INT64_C(0x0200808000020000), 0x1.0040400001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7ffffdffff), -0x1.0040400001p+57, -0x1p+0 },
+{ INT64_C(0x0200808000040000), 0x1.0040400002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7ffffbffff), -0x1.0040400002p+57, -0x1p+0 },
+{ INT64_C(0x0200808000200000), 0x1.004040001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffdfffff), -0x1.004040001p+57, -0x1p+0 },
+{ INT64_C(0x0200808000400000), 0x1.004040002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fffbfffff), -0x1.004040002p+57, -0x1p+0 },
+{ INT64_C(0x0200808004000000), 0x1.00404002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7ffbffffff), -0x1.00404002p+57, -0x1p+0 },
+{ INT64_C(0x0200808010000000), 0x1.00404008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7fefffffff), -0x1.00404008p+57, -0x1p+0 },
+{ INT64_C(0x0200808100000000), 0x1.0040408p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f7effffffff), -0x1.0040408p+57, -0x1p+0 },
+{ INT64_C(0x0200809000000000), 0x1.004048p+57, 0x0p+0 },
+{ INT64_C(0xfdff7f6fffffffff), -0x1.004048p+57, -0x1p+0 },
+{ INT64_C(0x0200840000000000), 0x1.0042p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bffffffffff), -0x1.0042p+57, -0x1p+0 },
+{ INT64_C(0x0200840000000008), 0x1.0042p+57, 0x1p+3 },
+{ INT64_C(0xfdff7bfffffffff7), -0x1.0042p+57, -0x1.2p+3 },
+{ INT64_C(0x0200840000000080), 0x1.0042000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bffffffff7f), -0x1.0042000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200840000000800), 0x1.004200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfffffff7ff), -0x1.004200000004p+57, -0x1p+0 },
+{ INT64_C(0x0200840000004000), 0x1.00420000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bffffffbfff), -0x1.00420000002p+57, -0x1p+0 },
+{ INT64_C(0x0200840000010000), 0x1.00420000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfffffeffff), -0x1.00420000008p+57, -0x1p+0 },
+{ INT64_C(0x0200840000080000), 0x1.0042000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfffff7ffff), -0x1.0042000004p+57, -0x1p+0 },
+{ INT64_C(0x0200840000200000), 0x1.004200001p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bffffdfffff), -0x1.004200001p+57, -0x1p+0 },
+{ INT64_C(0x0200840001000000), 0x1.004200008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfffeffffff), -0x1.004200008p+57, -0x1p+0 },
+{ INT64_C(0x0200840008000000), 0x1.00420004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfff7ffffff), -0x1.00420004p+57, -0x1p+0 },
+{ INT64_C(0x0200840080000000), 0x1.0042004p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bff7fffffff), -0x1.0042004p+57, -0x1p+0 },
+{ INT64_C(0x0200840100000000), 0x1.0042008p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfeffffffff), -0x1.0042008p+57, -0x1p+0 },
+{ INT64_C(0x0200840400000000), 0x1.004202p+57, 0x0p+0 },
+{ INT64_C(0xfdff7bfbffffffff), -0x1.004202p+57, -0x1p+0 },
+{ INT64_C(0x0200841000000000), 0x1.004208p+57, 0x0p+0 },
+{ INT64_C(0xfdff7befffffffff), -0x1.004208p+57, -0x1p+0 },
+{ INT64_C(0x0200850000000000), 0x1.00428p+57, 0x0p+0 },
+{ INT64_C(0xfdff7affffffffff), -0x1.00428p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000000000), 0x1.005p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffffffffff), -0x1.005p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000000001), 0x1.005p+57, 0x1p+0 },
+{ INT64_C(0xfdff5ffffffffffe), -0x1.005p+57, -0x1p+1 },
+{ INT64_C(0x0200a00000000004), 0x1.005p+57, 0x1p+2 },
+{ INT64_C(0xfdff5ffffffffffb), -0x1.005p+57, -0x1.4p+2 },
+{ INT64_C(0x0200a00000000008), 0x1.005p+57, 0x1p+3 },
+{ INT64_C(0xfdff5ffffffffff7), -0x1.005p+57, -0x1.2p+3 },
+{ INT64_C(0x0200a00000000010), 0x1.005p+57, 0x1p+4 },
+{ INT64_C(0xfdff5fffffffffef), -0x1.0050000000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0200a00000000040), 0x1.0050000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffffffffbf), -0x1.0050000000002p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000000080), 0x1.0050000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffffffff7f), -0x1.0050000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000000800), 0x1.005000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff5ffffffff7ff), -0x1.005000000004p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000001000), 0x1.005000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffffffefff), -0x1.005000000008p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000002000), 0x1.00500000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffffffdfff), -0x1.00500000001p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000020000), 0x1.0050000001p+57, 0x0p+0 },
+{ INT64_C(0xfdff5ffffffdffff), -0x1.0050000001p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000040000), 0x1.0050000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff5ffffffbffff), -0x1.0050000002p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000400000), 0x1.005000002p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffffbfffff), -0x1.005000002p+57, -0x1p+0 },
+{ INT64_C(0x0200a00000800000), 0x1.005000004p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffff7fffff), -0x1.005000004p+57, -0x1p+0 },
+{ INT64_C(0x0200a00001000000), 0x1.005000008p+57, 0x0p+0 },
+{ INT64_C(0xfdff5ffffeffffff), -0x1.005000008p+57, -0x1p+0 },
+{ INT64_C(0x0200a00010000000), 0x1.00500008p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fffefffffff), -0x1.00500008p+57, -0x1p+0 },
+{ INT64_C(0x0200a00080000000), 0x1.0050004p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fff7fffffff), -0x1.0050004p+57, -0x1p+0 },
+{ INT64_C(0x0200a00800000000), 0x1.005004p+57, 0x0p+0 },
+{ INT64_C(0xfdff5ff7ffffffff), -0x1.005004p+57, -0x1p+0 },
+{ INT64_C(0x0200a04000000000), 0x1.00502p+57, 0x0p+0 },
+{ INT64_C(0xfdff5fbfffffffff), -0x1.00502p+57, -0x1p+0 },
+{ INT64_C(0x0200a20000000000), 0x1.0051p+57, 0x0p+0 },
+{ INT64_C(0xfdff5dffffffffff), -0x1.0051p+57, -0x1p+0 },
+{ INT64_C(0x0204000000000004), 0x1.02p+57, 0x1p+2 },
+{ INT64_C(0xfdfbfffffffffffb), -0x1.02p+57, -0x1.4p+2 },
+{ INT64_C(0x0204000000000020), 0x1.0200000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffffffdf), -0x1.0200000000001p+57, -0x1p+0 },
+{ INT64_C(0x0204000000000022), 0x1.0200000000001p+57, 0x1p+1 },
+{ INT64_C(0xfdfbffffffffffdd), -0x1.0200000000001p+57, -0x1.8p+1 },
+{ INT64_C(0x0204000000000024), 0x1.0200000000001p+57, 0x1p+2 },
+{ INT64_C(0xfdfbffffffffffdb), -0x1.0200000000001p+57, -0x1.4p+2 },
+{ INT64_C(0x0204000000000100), 0x1.0200000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffffeff), -0x1.0200000000008p+57, -0x1p+0 },
+{ INT64_C(0x0204000000000101), 0x1.0200000000008p+57, 0x1p+0 },
+{ INT64_C(0xfdfbfffffffffefe), -0x1.0200000000008p+57, -0x1p+1 },
+{ INT64_C(0x0204000000000108), 0x1.0200000000008p+57, 0x1p+3 },
+{ INT64_C(0xfdfbfffffffffef7), -0x1.0200000000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000000000180), 0x1.020000000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffffe7f), -0x1.020000000000cp+57, -0x1p+0 },
+{ INT64_C(0x0204000000000400), 0x1.020000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffffbff), -0x1.020000000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000000000402), 0x1.020000000002p+57, 0x1p+1 },
+{ INT64_C(0xfdfbfffffffffbfd), -0x1.020000000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0204000000000420), 0x1.0200000000021p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffffbdf), -0x1.0200000000021p+57, -0x1p+0 },
+{ INT64_C(0x0204000000000440), 0x1.0200000000022p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffffbbf), -0x1.0200000000022p+57, -0x1p+0 },
+{ INT64_C(0x0204000000000500), 0x1.0200000000028p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffffaff), -0x1.0200000000028p+57, -0x1p+0 },
+{ INT64_C(0x0204000000001000), 0x1.020000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffffefff), -0x1.020000000008p+57, -0x1p+0 },
+{ INT64_C(0x0204000000001001), 0x1.020000000008p+57, 0x1p+0 },
+{ INT64_C(0xfdfbffffffffeffe), -0x1.020000000008p+57, -0x1p+1 },
+{ INT64_C(0x0204000000001002), 0x1.020000000008p+57, 0x1p+1 },
+{ INT64_C(0xfdfbffffffffeffd), -0x1.020000000008p+57, -0x1.8p+1 },
+{ INT64_C(0x0204000000001008), 0x1.020000000008p+57, 0x1p+3 },
+{ INT64_C(0xfdfbffffffffeff7), -0x1.020000000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000000001020), 0x1.0200000000081p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffffefdf), -0x1.0200000000081p+57, -0x1p+0 },
+{ INT64_C(0x0204000000001200), 0x1.020000000009p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffffedff), -0x1.020000000009p+57, -0x1p+0 },
+{ INT64_C(0x0204000000001400), 0x1.02000000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffffebff), -0x1.02000000000ap+57, -0x1p+0 },
+{ INT64_C(0x0204000000001800), 0x1.02000000000cp+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffffe7ff), -0x1.02000000000cp+57, -0x1p+0 },
+{ INT64_C(0x0204000000008000), 0x1.02000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffff7fff), -0x1.02000000004p+57, -0x1p+0 },
+{ INT64_C(0x0204000000008002), 0x1.02000000004p+57, 0x1p+1 },
+{ INT64_C(0xfdfbffffffff7ffd), -0x1.02000000004p+57, -0x1.8p+1 },
+{ INT64_C(0x0204000000008008), 0x1.02000000004p+57, 0x1p+3 },
+{ INT64_C(0xfdfbffffffff7ff7), -0x1.02000000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000000008080), 0x1.0200000000404p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffff7f7f), -0x1.0200000000404p+57, -0x1p+0 },
+{ INT64_C(0x0204000000008800), 0x1.020000000044p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffff77ff), -0x1.020000000044p+57, -0x1p+0 },
+{ INT64_C(0x0204000000009000), 0x1.020000000048p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffff6fff), -0x1.020000000048p+57, -0x1p+0 },
+{ INT64_C(0x0204000000040000), 0x1.0200000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffbffff), -0x1.0200000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000000040008), 0x1.0200000002p+57, 0x1p+3 },
+{ INT64_C(0xfdfbfffffffbfff7), -0x1.0200000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000000040080), 0x1.0200000002004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffbff7f), -0x1.0200000002004p+57, -0x1p+0 },
+{ INT64_C(0x0204000000040800), 0x1.020000000204p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffbf7ff), -0x1.020000000204p+57, -0x1p+0 },
+{ INT64_C(0x0204000000048000), 0x1.02000000024p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffffb7fff), -0x1.02000000024p+57, -0x1p+0 },
+{ INT64_C(0x0204000000080000), 0x1.0200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffff7ffff), -0x1.0200000004p+57, -0x1p+0 },
+{ INT64_C(0x0204000000080001), 0x1.0200000004p+57, 0x1p+0 },
+{ INT64_C(0xfdfbfffffff7fffe), -0x1.0200000004p+57, -0x1p+1 },
+{ INT64_C(0x0204000000080010), 0x1.0200000004p+57, 0x1p+4 },
+{ INT64_C(0xfdfbfffffff7ffef), -0x1.0200000004001p+57, 0x1.ep+3 },
+{ INT64_C(0x0204000000080040), 0x1.0200000004002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffff7ffbf), -0x1.0200000004002p+57, -0x1p+0 },
+{ INT64_C(0x0204000000080200), 0x1.020000000401p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffff7fdff), -0x1.020000000401p+57, -0x1p+0 },
+{ INT64_C(0x0204000000082000), 0x1.02000000041p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffff7dfff), -0x1.02000000041p+57, -0x1p+0 },
+{ INT64_C(0x02040000000a0000), 0x1.0200000005p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffff5ffff), -0x1.0200000005p+57, -0x1p+0 },
+{ INT64_C(0x0204000000400000), 0x1.020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffbfffff), -0x1.020000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000000400002), 0x1.020000002p+57, 0x1p+1 },
+{ INT64_C(0xfdfbffffffbffffd), -0x1.020000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0204000000400008), 0x1.020000002p+57, 0x1p+3 },
+{ INT64_C(0xfdfbffffffbffff7), -0x1.020000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000000400020), 0x1.0200000020001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffbfffdf), -0x1.0200000020001p+57, -0x1p+0 },
+{ INT64_C(0x0204000000400200), 0x1.020000002001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffbffdff), -0x1.020000002001p+57, -0x1p+0 },
+{ INT64_C(0x0204000000400800), 0x1.020000002004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffbff7ff), -0x1.020000002004p+57, -0x1p+0 },
+{ INT64_C(0x0204000000404000), 0x1.02000000202p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffbfbfff), -0x1.02000000202p+57, -0x1p+0 },
+{ INT64_C(0x0204000000420000), 0x1.0200000021p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffbdffff), -0x1.0200000021p+57, -0x1p+0 },
+{ INT64_C(0x0204000000480000), 0x1.0200000024p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffb7ffff), -0x1.0200000024p+57, -0x1p+0 },
+{ INT64_C(0x0204000000500000), 0x1.0200000028p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffffafffff), -0x1.0200000028p+57, -0x1p+0 },
+{ INT64_C(0x0204000000600000), 0x1.020000003p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffff9fffff), -0x1.020000003p+57, -0x1p+0 },
+{ INT64_C(0x0204000004000000), 0x1.02000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbffffff), -0x1.02000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000004000001), 0x1.02000002p+57, 0x1p+0 },
+{ INT64_C(0xfdfbfffffbfffffe), -0x1.02000002p+57, -0x1p+1 },
+{ INT64_C(0x0204000004000004), 0x1.02000002p+57, 0x1p+2 },
+{ INT64_C(0xfdfbfffffbfffffb), -0x1.02000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0204000004000040), 0x1.0200000200002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbffffbf), -0x1.0200000200002p+57, -0x1p+0 },
+{ INT64_C(0x0204000004000200), 0x1.020000020001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbfffdff), -0x1.020000020001p+57, -0x1p+0 },
+{ INT64_C(0x0204000004002000), 0x1.02000002001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbffdfff), -0x1.02000002001p+57, -0x1p+0 },
+{ INT64_C(0x0204000004004000), 0x1.02000002002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbffbfff), -0x1.02000002002p+57, -0x1p+0 },
+{ INT64_C(0x0204000004010000), 0x1.02000002008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbfeffff), -0x1.02000002008p+57, -0x1p+0 },
+{ INT64_C(0x0204000004040000), 0x1.0200000202p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbfbffff), -0x1.0200000202p+57, -0x1p+0 },
+{ INT64_C(0x0204000004100000), 0x1.0200000208p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbefffff), -0x1.0200000208p+57, -0x1p+0 },
+{ INT64_C(0x0204000004200000), 0x1.020000021p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffffbdfffff), -0x1.020000021p+57, -0x1p+0 },
+{ INT64_C(0x0204000006000000), 0x1.02000003p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffff9ffffff), -0x1.02000003p+57, -0x1p+0 },
+{ INT64_C(0x0204000020000000), 0x1.0200001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdfffffff), -0x1.0200001p+57, -0x1p+0 },
+{ INT64_C(0x0204000020000001), 0x1.0200001p+57, 0x1p+0 },
+{ INT64_C(0xfdfbffffdffffffe), -0x1.0200001p+57, -0x1p+1 },
+{ INT64_C(0x0204000020000002), 0x1.0200001p+57, 0x1p+1 },
+{ INT64_C(0xfdfbffffdffffffd), -0x1.0200001p+57, -0x1.8p+1 },
+{ INT64_C(0x0204000020000010), 0x1.0200001p+57, 0x1p+4 },
+{ INT64_C(0xfdfbffffdfffffef), -0x1.0200001000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0204000020000040), 0x1.0200001000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdfffffbf), -0x1.0200001000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000020000200), 0x1.020000100001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdffffdff), -0x1.020000100001p+57, -0x1p+0 },
+{ INT64_C(0x0204000020000800), 0x1.020000100004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdffff7ff), -0x1.020000100004p+57, -0x1p+0 },
+{ INT64_C(0x0204000020008000), 0x1.02000010004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdfff7fff), -0x1.02000010004p+57, -0x1p+0 },
+{ INT64_C(0x0204000020020000), 0x1.0200001001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdffdffff), -0x1.0200001001p+57, -0x1p+0 },
+{ INT64_C(0x0204000020100000), 0x1.0200001008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdfefffff), -0x1.0200001008p+57, -0x1p+0 },
+{ INT64_C(0x0204000020400000), 0x1.020000102p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdfbfffff), -0x1.020000102p+57, -0x1p+0 },
+{ INT64_C(0x0204000024000000), 0x1.02000012p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffffdbffffff), -0x1.02000012p+57, -0x1p+0 },
+{ INT64_C(0x0204000080000000), 0x1.0200004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7fffffff), -0x1.0200004p+57, -0x1p+0 },
+{ INT64_C(0x0204000080000008), 0x1.0200004p+57, 0x1p+3 },
+{ INT64_C(0xfdfbffff7ffffff7), -0x1.0200004p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000080000020), 0x1.0200004000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7fffffdf), -0x1.0200004000001p+57, -0x1p+0 },
+{ INT64_C(0x0204000080000200), 0x1.020000400001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7ffffdff), -0x1.020000400001p+57, -0x1p+0 },
+{ INT64_C(0x0204000080002000), 0x1.02000040001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7fffdfff), -0x1.02000040001p+57, -0x1p+0 },
+{ INT64_C(0x0204000080004000), 0x1.02000040002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7fffbfff), -0x1.02000040002p+57, -0x1p+0 },
+{ INT64_C(0x0204000080010000), 0x1.02000040008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7ffeffff), -0x1.02000040008p+57, -0x1p+0 },
+{ INT64_C(0x0204000080020000), 0x1.0200004001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7ffdffff), -0x1.0200004001p+57, -0x1p+0 },
+{ INT64_C(0x0204000080200000), 0x1.020000401p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7fdfffff), -0x1.020000401p+57, -0x1p+0 },
+{ INT64_C(0x0204000082000000), 0x1.02000041p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff7dffffff), -0x1.02000041p+57, -0x1p+0 },
+{ INT64_C(0x0204000088000000), 0x1.02000044p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff77ffffff), -0x1.02000044p+57, -0x1p+0 },
+{ INT64_C(0x0204000090000000), 0x1.02000048p+57, 0x0p+0 },
+{ INT64_C(0xfdfbffff6fffffff), -0x1.02000048p+57, -0x1p+0 },
+{ INT64_C(0x0204000400000000), 0x1.020002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbffffffff), -0x1.020002p+57, -0x1p+0 },
+{ INT64_C(0x0204000400000004), 0x1.020002p+57, 0x1p+2 },
+{ INT64_C(0xfdfbfffbfffffffb), -0x1.020002p+57, -0x1.4p+2 },
+{ INT64_C(0x0204000400000040), 0x1.0200020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbffffffbf), -0x1.0200020000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000400000080), 0x1.0200020000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbffffff7f), -0x1.0200020000004p+57, -0x1p+0 },
+{ INT64_C(0x0204000400000100), 0x1.0200020000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbfffffeff), -0x1.0200020000008p+57, -0x1p+0 },
+{ INT64_C(0x0204000400000200), 0x1.020002000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbfffffdff), -0x1.020002000001p+57, -0x1p+0 },
+{ INT64_C(0x0204000400002000), 0x1.02000200001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbffffdfff), -0x1.02000200001p+57, -0x1p+0 },
+{ INT64_C(0x0204000400008000), 0x1.02000200004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbffff7fff), -0x1.02000200004p+57, -0x1p+0 },
+{ INT64_C(0x0204000400080000), 0x1.0200020004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbfff7ffff), -0x1.0200020004p+57, -0x1p+0 },
+{ INT64_C(0x0204000400800000), 0x1.020002004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbff7fffff), -0x1.020002004p+57, -0x1p+0 },
+{ INT64_C(0x0204000401000000), 0x1.020002008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbfeffffff), -0x1.020002008p+57, -0x1p+0 },
+{ INT64_C(0x0204000402000000), 0x1.02000201p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbfdffffff), -0x1.02000201p+57, -0x1p+0 },
+{ INT64_C(0x0204000410000000), 0x1.02000208p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffbefffffff), -0x1.02000208p+57, -0x1p+0 },
+{ INT64_C(0x0204000500000000), 0x1.0200028p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfffaffffffff), -0x1.0200028p+57, -0x1p+0 },
+{ INT64_C(0x0204000600000000), 0x1.020003p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff9ffffffff), -0x1.020003p+57, -0x1p+0 },
+{ INT64_C(0x0204000800000000), 0x1.020004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7ffffffff), -0x1.020004p+57, -0x1p+0 },
+{ INT64_C(0x0204000800000008), 0x1.020004p+57, 0x1p+3 },
+{ INT64_C(0xfdfbfff7fffffff7), -0x1.020004p+57, -0x1.2p+3 },
+{ INT64_C(0x0204000800000020), 0x1.0200040000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7ffffffdf), -0x1.0200040000001p+57, -0x1p+0 },
+{ INT64_C(0x0204000800000080), 0x1.0200040000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7ffffff7f), -0x1.0200040000004p+57, -0x1p+0 },
+{ INT64_C(0x0204000800000100), 0x1.0200040000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7fffffeff), -0x1.0200040000008p+57, -0x1p+0 },
+{ INT64_C(0x0204000800000400), 0x1.020004000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7fffffbff), -0x1.020004000002p+57, -0x1p+0 },
+{ INT64_C(0x0204000800000800), 0x1.020004000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7fffff7ff), -0x1.020004000004p+57, -0x1p+0 },
+{ INT64_C(0x0204000800004000), 0x1.02000400002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7ffffbfff), -0x1.02000400002p+57, -0x1p+0 },
+{ INT64_C(0x0204000800040000), 0x1.0200040002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7fffbffff), -0x1.0200040002p+57, -0x1p+0 },
+{ INT64_C(0x0204000800100000), 0x1.0200040008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7ffefffff), -0x1.0200040008p+57, -0x1p+0 },
+{ INT64_C(0x0204000801000000), 0x1.020004008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7feffffff), -0x1.020004008p+57, -0x1p+0 },
+{ INT64_C(0x0204000810000000), 0x1.02000408p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff7efffffff), -0x1.02000408p+57, -0x1p+0 },
+{ INT64_C(0x0204000900000000), 0x1.0200048p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfff6ffffffff), -0x1.0200048p+57, -0x1p+0 },
+{ INT64_C(0x0204008000000000), 0x1.02004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7fffffffff), -0x1.02004p+57, -0x1p+0 },
+{ INT64_C(0x0204008000000008), 0x1.02004p+57, 0x1p+3 },
+{ INT64_C(0xfdfbff7ffffffff7), -0x1.02004p+57, -0x1.2p+3 },
+{ INT64_C(0x0204008000000080), 0x1.0200400000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7fffffff7f), -0x1.0200400000004p+57, -0x1p+0 },
+{ INT64_C(0x0204008000000400), 0x1.020040000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7ffffffbff), -0x1.020040000002p+57, -0x1p+0 },
+{ INT64_C(0x0204008000002000), 0x1.02004000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7fffffdfff), -0x1.02004000001p+57, -0x1p+0 },
+{ INT64_C(0x0204008000020000), 0x1.0200400001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7ffffdffff), -0x1.0200400001p+57, -0x1p+0 },
+{ INT64_C(0x0204008000200000), 0x1.020040001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7fffdfffff), -0x1.020040001p+57, -0x1p+0 },
+{ INT64_C(0x0204008000800000), 0x1.020040004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7fff7fffff), -0x1.020040004p+57, -0x1p+0 },
+{ INT64_C(0x0204008001000000), 0x1.020040008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7ffeffffff), -0x1.020040008p+57, -0x1p+0 },
+{ INT64_C(0x0204008010000000), 0x1.02004008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7fefffffff), -0x1.02004008p+57, -0x1p+0 },
+{ INT64_C(0x0204008100000000), 0x1.0200408p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7effffffff), -0x1.0200408p+57, -0x1p+0 },
+{ INT64_C(0x0204008200000000), 0x1.020041p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7dffffffff), -0x1.020041p+57, -0x1p+0 },
+{ INT64_C(0x0204008400000000), 0x1.020042p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff7bffffffff), -0x1.020042p+57, -0x1p+0 },
+{ INT64_C(0x020400a000000000), 0x1.02005p+57, 0x0p+0 },
+{ INT64_C(0xfdfbff5fffffffff), -0x1.02005p+57, -0x1p+0 },
+{ INT64_C(0x0204040000000000), 0x1.0202p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbffffffffff), -0x1.0202p+57, -0x1p+0 },
+{ INT64_C(0x0204040000000002), 0x1.0202p+57, 0x1p+1 },
+{ INT64_C(0xfdfbfbfffffffffd), -0x1.0202p+57, -0x1.8p+1 },
+{ INT64_C(0x0204040000000004), 0x1.0202p+57, 0x1p+2 },
+{ INT64_C(0xfdfbfbfffffffffb), -0x1.0202p+57, -0x1.4p+2 },
+{ INT64_C(0x0204040000000008), 0x1.0202p+57, 0x1p+3 },
+{ INT64_C(0xfdfbfbfffffffff7), -0x1.0202p+57, -0x1.2p+3 },
+{ INT64_C(0x0204040000000020), 0x1.0202000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbffffffffdf), -0x1.0202000000001p+57, -0x1p+0 },
+{ INT64_C(0x0204040000000100), 0x1.0202000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbfffffffeff), -0x1.0202000000008p+57, -0x1p+0 },
+{ INT64_C(0x0204040000001000), 0x1.020200000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbffffffefff), -0x1.020200000008p+57, -0x1p+0 },
+{ INT64_C(0x0204040000010000), 0x1.02020000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbfffffeffff), -0x1.02020000008p+57, -0x1p+0 },
+{ INT64_C(0x0204040000040000), 0x1.0202000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbfffffbffff), -0x1.0202000002p+57, -0x1p+0 },
+{ INT64_C(0x0204040000400000), 0x1.020200002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbffffbfffff), -0x1.020200002p+57, -0x1p+0 },
+{ INT64_C(0x0204040001000000), 0x1.020200008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbfffeffffff), -0x1.020200008p+57, -0x1p+0 },
+{ INT64_C(0x0204040010000000), 0x1.02020008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbffefffffff), -0x1.02020008p+57, -0x1p+0 },
+{ INT64_C(0x0204040040000000), 0x1.0202002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbffbfffffff), -0x1.0202002p+57, -0x1p+0 },
+{ INT64_C(0x0204040080000000), 0x1.0202004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbff7fffffff), -0x1.0202004p+57, -0x1p+0 },
+{ INT64_C(0x0204040200000000), 0x1.020201p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbfdffffffff), -0x1.020201p+57, -0x1p+0 },
+{ INT64_C(0x0204042000000000), 0x1.02021p+57, 0x0p+0 },
+{ INT64_C(0xfdfbfbdfffffffff), -0x1.02021p+57, -0x1p+0 },
+{ INT64_C(0x0204060000000000), 0x1.0203p+57, 0x0p+0 },
+{ INT64_C(0xfdfbf9ffffffffff), -0x1.0203p+57, -0x1p+0 },
+{ INT64_C(0x0204100000000000), 0x1.0208p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffffffffff), -0x1.0208p+57, -0x1p+0 },
+{ INT64_C(0x0204100000000004), 0x1.0208p+57, 0x1p+2 },
+{ INT64_C(0xfdfbeffffffffffb), -0x1.0208p+57, -0x1.4p+2 },
+{ INT64_C(0x0204100000000020), 0x1.0208000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffffffffdf), -0x1.0208000000001p+57, -0x1p+0 },
+{ INT64_C(0x0204100000000040), 0x1.0208000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffffffffbf), -0x1.0208000000002p+57, -0x1p+0 },
+{ INT64_C(0x0204100000000400), 0x1.020800000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbeffffffffbff), -0x1.020800000002p+57, -0x1p+0 },
+{ INT64_C(0x0204100000000800), 0x1.020800000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbeffffffff7ff), -0x1.020800000004p+57, -0x1p+0 },
+{ INT64_C(0x0204100000004000), 0x1.02080000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffffffbfff), -0x1.02080000002p+57, -0x1p+0 },
+{ INT64_C(0x0204100000040000), 0x1.0208000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbeffffffbffff), -0x1.0208000002p+57, -0x1p+0 },
+{ INT64_C(0x0204100000080000), 0x1.0208000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbeffffff7ffff), -0x1.0208000004p+57, -0x1p+0 },
+{ INT64_C(0x0204100000100000), 0x1.0208000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffffefffff), -0x1.0208000008p+57, -0x1p+0 },
+{ INT64_C(0x0204100000200000), 0x1.020800001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffffdfffff), -0x1.020800001p+57, -0x1p+0 },
+{ INT64_C(0x0204100000800000), 0x1.020800004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffff7fffff), -0x1.020800004p+57, -0x1p+0 },
+{ INT64_C(0x0204100008000000), 0x1.02080004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbeffff7ffffff), -0x1.02080004p+57, -0x1p+0 },
+{ INT64_C(0x0204100040000000), 0x1.0208002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefffbfffffff), -0x1.0208002p+57, -0x1p+0 },
+{ INT64_C(0x0204100400000000), 0x1.020802p+57, 0x0p+0 },
+{ INT64_C(0xfdfbeffbffffffff), -0x1.020802p+57, -0x1p+0 },
+{ INT64_C(0x0204101000000000), 0x1.020808p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefefffffffff), -0x1.020808p+57, -0x1p+0 },
+{ INT64_C(0x0204104000000000), 0x1.02082p+57, 0x0p+0 },
+{ INT64_C(0xfdfbefbfffffffff), -0x1.02082p+57, -0x1p+0 },
+{ INT64_C(0x0204120000000000), 0x1.0209p+57, 0x0p+0 },
+{ INT64_C(0xfdfbedffffffffff), -0x1.0209p+57, -0x1p+0 },
+{ INT64_C(0x0204140000000000), 0x1.020ap+57, 0x0p+0 },
+{ INT64_C(0xfdfbebffffffffff), -0x1.020ap+57, -0x1p+0 },
+{ INT64_C(0x0204400000000000), 0x1.022p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffffffffff), -0x1.022p+57, -0x1p+0 },
+{ INT64_C(0x0204400000000001), 0x1.022p+57, 0x1p+0 },
+{ INT64_C(0xfdfbbffffffffffe), -0x1.022p+57, -0x1p+1 },
+{ INT64_C(0x0204400000000002), 0x1.022p+57, 0x1p+1 },
+{ INT64_C(0xfdfbbffffffffffd), -0x1.022p+57, -0x1.8p+1 },
+{ INT64_C(0x0204400000000020), 0x1.0220000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffffffffdf), -0x1.0220000000001p+57, -0x1p+0 },
+{ INT64_C(0x0204400000000040), 0x1.0220000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffffffffbf), -0x1.0220000000002p+57, -0x1p+0 },
+{ INT64_C(0x0204400000000100), 0x1.0220000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffffffffeff), -0x1.0220000000008p+57, -0x1p+0 },
+{ INT64_C(0x0204400000000400), 0x1.022000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffffffffbff), -0x1.022000000002p+57, -0x1p+0 },
+{ INT64_C(0x0204400000000800), 0x1.022000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffffffff7ff), -0x1.022000000004p+57, -0x1p+0 },
+{ INT64_C(0x0204400000002000), 0x1.02200000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffffffdfff), -0x1.02200000001p+57, -0x1p+0 },
+{ INT64_C(0x0204400000008000), 0x1.02200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffffff7fff), -0x1.02200000004p+57, -0x1p+0 },
+{ INT64_C(0x0204400000040000), 0x1.0220000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffffffbffff), -0x1.0220000002p+57, -0x1p+0 },
+{ INT64_C(0x0204400000400000), 0x1.022000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffffbfffff), -0x1.022000002p+57, -0x1p+0 },
+{ INT64_C(0x0204400000800000), 0x1.022000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffff7fffff), -0x1.022000004p+57, -0x1p+0 },
+{ INT64_C(0x0204400004000000), 0x1.02200002p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffffbffffff), -0x1.02200002p+57, -0x1p+0 },
+{ INT64_C(0x0204400008000000), 0x1.02200004p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffff7ffffff), -0x1.02200004p+57, -0x1p+0 },
+{ INT64_C(0x0204400020000000), 0x1.0220001p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfffdfffffff), -0x1.0220001p+57, -0x1p+0 },
+{ INT64_C(0x0204400100000000), 0x1.0220008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbffeffffffff), -0x1.0220008p+57, -0x1p+0 },
+{ INT64_C(0x0204401000000000), 0x1.022008p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbfefffffffff), -0x1.022008p+57, -0x1p+0 },
+{ INT64_C(0x0204408000000000), 0x1.02204p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbf7fffffffff), -0x1.02204p+57, -0x1p+0 },
+{ INT64_C(0x0204440000000000), 0x1.0222p+57, 0x0p+0 },
+{ INT64_C(0xfdfbbbffffffffff), -0x1.0222p+57, -0x1p+0 },
+{ INT64_C(0x0204600000000000), 0x1.023p+57, 0x0p+0 },
+{ INT64_C(0xfdfb9fffffffffff), -0x1.023p+57, -0x1p+0 },
+{ INT64_C(0x0204800000000000), 0x1.024p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffffffffff), -0x1.024p+57, -0x1p+0 },
+{ INT64_C(0x0204800000000002), 0x1.024p+57, 0x1p+1 },
+{ INT64_C(0xfdfb7ffffffffffd), -0x1.024p+57, -0x1.8p+1 },
+{ INT64_C(0x0204800000000004), 0x1.024p+57, 0x1p+2 },
+{ INT64_C(0xfdfb7ffffffffffb), -0x1.024p+57, -0x1.4p+2 },
+{ INT64_C(0x0204800000000020), 0x1.0240000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffffffffdf), -0x1.0240000000001p+57, -0x1p+0 },
+{ INT64_C(0x0204800000000040), 0x1.0240000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffffffffbf), -0x1.0240000000002p+57, -0x1p+0 },
+{ INT64_C(0x0204800000000080), 0x1.0240000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffffffff7f), -0x1.0240000000004p+57, -0x1p+0 },
+{ INT64_C(0x0204800000000200), 0x1.024000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffffffffdff), -0x1.024000000001p+57, -0x1p+0 },
+{ INT64_C(0x0204800000000400), 0x1.024000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffffffffbff), -0x1.024000000002p+57, -0x1p+0 },
+{ INT64_C(0x0204800000004000), 0x1.02400000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffffffbfff), -0x1.02400000002p+57, -0x1p+0 },
+{ INT64_C(0x0204800000040000), 0x1.0240000002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffffffbffff), -0x1.0240000002p+57, -0x1p+0 },
+{ INT64_C(0x0204800000080000), 0x1.0240000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffffff7ffff), -0x1.0240000004p+57, -0x1p+0 },
+{ INT64_C(0x0204800000800000), 0x1.024000004p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffff7fffff), -0x1.024000004p+57, -0x1p+0 },
+{ INT64_C(0x0204800004000000), 0x1.02400002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffffbffffff), -0x1.02400002p+57, -0x1p+0 },
+{ INT64_C(0x0204800040000000), 0x1.0240002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fffbfffffff), -0x1.0240002p+57, -0x1p+0 },
+{ INT64_C(0x0204800200000000), 0x1.024001p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffdffffffff), -0x1.024001p+57, -0x1p+0 },
+{ INT64_C(0x0204800400000000), 0x1.024002p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7ffbffffffff), -0x1.024002p+57, -0x1p+0 },
+{ INT64_C(0x0204802000000000), 0x1.02401p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7fdfffffffff), -0x1.02401p+57, -0x1p+0 },
+{ INT64_C(0x0204820000000000), 0x1.0241p+57, 0x0p+0 },
+{ INT64_C(0xfdfb7dffffffffff), -0x1.0241p+57, -0x1p+0 },
+{ INT64_C(0x0204900000000000), 0x1.0248p+57, 0x0p+0 },
+{ INT64_C(0xfdfb6fffffffffff), -0x1.0248p+57, -0x1p+0 },
+{ INT64_C(0x0240000000000008), 0x1.2p+57, 0x1p+3 },
+{ INT64_C(0xfdbffffffffffff7), -0x1.2p+57, -0x1.2p+3 },
+{ INT64_C(0x024000000000000a), 0x1.2p+57, 0x1.4p+3 },
+{ INT64_C(0xfdbffffffffffff5), -0x1.2p+57, -0x1.6p+3 },
+{ INT64_C(0x0240000000000040), 0x1.2000000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffffbf), -0x1.2000000000002p+57, -0x1p+0 },
+{ INT64_C(0x0240000000000048), 0x1.2000000000002p+57, 0x1p+3 },
+{ INT64_C(0xfdbfffffffffffb7), -0x1.2000000000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0240000000000060), 0x1.2000000000003p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffff9f), -0x1.2000000000003p+57, -0x1p+0 },
+{ INT64_C(0x0240000000000080), 0x1.2000000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffff7f), -0x1.2000000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000000000081), 0x1.2000000000004p+57, 0x1p+0 },
+{ INT64_C(0xfdbfffffffffff7e), -0x1.2000000000004p+57, -0x1p+1 },
+{ INT64_C(0x0240000000000090), 0x1.2000000000004p+57, 0x1p+4 },
+{ INT64_C(0xfdbfffffffffff6f), -0x1.2000000000005p+57, 0x1.ep+3 },
+{ INT64_C(0x0240000000000800), 0x1.200000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffff7ff), -0x1.200000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000000000804), 0x1.200000000004p+57, 0x1p+2 },
+{ INT64_C(0xfdbffffffffff7fb), -0x1.200000000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0240000000000808), 0x1.200000000004p+57, 0x1p+3 },
+{ INT64_C(0xfdbffffffffff7f7), -0x1.200000000004p+57, -0x1.2p+3 },
+{ INT64_C(0x0240000000000810), 0x1.200000000004p+57, 0x1p+4 },
+{ INT64_C(0xfdbffffffffff7ef), -0x1.2000000000041p+57, 0x1.ep+3 },
+{ INT64_C(0x0240000000000900), 0x1.2000000000048p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffff6ff), -0x1.2000000000048p+57, -0x1p+0 },
+{ INT64_C(0x0240000000000a00), 0x1.200000000005p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffff5ff), -0x1.200000000005p+57, -0x1p+0 },
+{ INT64_C(0x0240000000004000), 0x1.20000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffbfff), -0x1.20000000002p+57, -0x1p+0 },
+{ INT64_C(0x0240000000004008), 0x1.20000000002p+57, 0x1p+3 },
+{ INT64_C(0xfdbfffffffffbff7), -0x1.20000000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0240000000004020), 0x1.2000000000201p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffbfdf), -0x1.2000000000201p+57, -0x1p+0 },
+{ INT64_C(0x0240000000004080), 0x1.2000000000204p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffbf7f), -0x1.2000000000204p+57, -0x1p+0 },
+{ INT64_C(0x0240000000004200), 0x1.200000000021p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffffbdff), -0x1.200000000021p+57, -0x1p+0 },
+{ INT64_C(0x0240000000006000), 0x1.20000000003p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffffff9fff), -0x1.20000000003p+57, -0x1p+0 },
+{ INT64_C(0x0240000000010000), 0x1.20000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffeffff), -0x1.20000000008p+57, -0x1p+0 },
+{ INT64_C(0x0240000000010008), 0x1.20000000008p+57, 0x1p+3 },
+{ INT64_C(0xfdbffffffffefff7), -0x1.20000000008p+57, -0x1.2p+3 },
+{ INT64_C(0x0240000000010040), 0x1.2000000000802p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffeffbf), -0x1.2000000000802p+57, -0x1p+0 },
+{ INT64_C(0x0240000000010400), 0x1.200000000082p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffefbff), -0x1.200000000082p+57, -0x1p+0 },
+{ INT64_C(0x0240000000012000), 0x1.20000000009p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffedfff), -0x1.20000000009p+57, -0x1p+0 },
+{ INT64_C(0x0240000000014000), 0x1.2000000000ap+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffffebfff), -0x1.2000000000ap+57, -0x1p+0 },
+{ INT64_C(0x0240000000080000), 0x1.2000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffff7ffff), -0x1.2000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000000080002), 0x1.2000000004p+57, 0x1p+1 },
+{ INT64_C(0xfdbffffffff7fffd), -0x1.2000000004p+57, -0x1.8p+1 },
+{ INT64_C(0x0240000000080004), 0x1.2000000004p+57, 0x1p+2 },
+{ INT64_C(0xfdbffffffff7fffb), -0x1.2000000004p+57, -0x1.4p+2 },
+{ INT64_C(0x0240000000080040), 0x1.2000000004002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffff7ffbf), -0x1.2000000004002p+57, -0x1p+0 },
+{ INT64_C(0x0240000000080100), 0x1.2000000004008p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffff7feff), -0x1.2000000004008p+57, -0x1p+0 },
+{ INT64_C(0x0240000000081000), 0x1.200000000408p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffff7efff), -0x1.200000000408p+57, -0x1p+0 },
+{ INT64_C(0x0240000000088000), 0x1.20000000044p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffff77fff), -0x1.20000000044p+57, -0x1p+0 },
+{ INT64_C(0x02400000000a0000), 0x1.2000000005p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffff5ffff), -0x1.2000000005p+57, -0x1p+0 },
+{ INT64_C(0x0240000000800000), 0x1.200000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffff7fffff), -0x1.200000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000000800001), 0x1.200000004p+57, 0x1p+0 },
+{ INT64_C(0xfdbfffffff7ffffe), -0x1.200000004p+57, -0x1p+1 },
+{ INT64_C(0x0240000000800002), 0x1.200000004p+57, 0x1p+1 },
+{ INT64_C(0xfdbfffffff7ffffd), -0x1.200000004p+57, -0x1.8p+1 },
+{ INT64_C(0x0240000000800010), 0x1.200000004p+57, 0x1p+4 },
+{ INT64_C(0xfdbfffffff7fffef), -0x1.2000000040001p+57, 0x1.ep+3 },
+{ INT64_C(0x0240000000800080), 0x1.2000000040004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffff7fff7f), -0x1.2000000040004p+57, -0x1p+0 },
+{ INT64_C(0x0240000000800800), 0x1.200000004004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffff7ff7ff), -0x1.200000004004p+57, -0x1p+0 },
+{ INT64_C(0x0240000000808000), 0x1.20000000404p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffff7f7fff), -0x1.20000000404p+57, -0x1p+0 },
+{ INT64_C(0x0240000000880000), 0x1.2000000044p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffff77ffff), -0x1.2000000044p+57, -0x1p+0 },
+{ INT64_C(0x0240000000c00000), 0x1.200000006p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffff3fffff), -0x1.200000006p+57, -0x1p+0 },
+{ INT64_C(0x0240000004000000), 0x1.20000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbffffff), -0x1.20000002p+57, -0x1p+0 },
+{ INT64_C(0x0240000004000001), 0x1.20000002p+57, 0x1p+0 },
+{ INT64_C(0xfdbffffffbfffffe), -0x1.20000002p+57, -0x1p+1 },
+{ INT64_C(0x0240000004000008), 0x1.20000002p+57, 0x1p+3 },
+{ INT64_C(0xfdbffffffbfffff7), -0x1.20000002p+57, -0x1.2p+3 },
+{ INT64_C(0x0240000004000040), 0x1.2000000200002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbffffbf), -0x1.2000000200002p+57, -0x1p+0 },
+{ INT64_C(0x0240000004000100), 0x1.2000000200008p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbfffeff), -0x1.2000000200008p+57, -0x1p+0 },
+{ INT64_C(0x0240000004000400), 0x1.200000020002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbfffbff), -0x1.200000020002p+57, -0x1p+0 },
+{ INT64_C(0x0240000004004000), 0x1.20000002002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbffbfff), -0x1.20000002002p+57, -0x1p+0 },
+{ INT64_C(0x0240000004008000), 0x1.20000002004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbff7fff), -0x1.20000002004p+57, -0x1p+0 },
+{ INT64_C(0x0240000004040000), 0x1.2000000202p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbfbffff), -0x1.2000000202p+57, -0x1p+0 },
+{ INT64_C(0x0240000004400000), 0x1.200000022p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffffbbfffff), -0x1.200000022p+57, -0x1p+0 },
+{ INT64_C(0x0240000006000000), 0x1.20000003p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffff9ffffff), -0x1.20000003p+57, -0x1p+0 },
+{ INT64_C(0x0240000040000000), 0x1.2000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbfffffff), -0x1.2000002p+57, -0x1p+0 },
+{ INT64_C(0x0240000040000002), 0x1.2000002p+57, 0x1p+1 },
+{ INT64_C(0xfdbfffffbffffffd), -0x1.2000002p+57, -0x1.8p+1 },
+{ INT64_C(0x0240000040000004), 0x1.2000002p+57, 0x1p+2 },
+{ INT64_C(0xfdbfffffbffffffb), -0x1.2000002p+57, -0x1.4p+2 },
+{ INT64_C(0x0240000040000010), 0x1.2000002p+57, 0x1p+4 },
+{ INT64_C(0xfdbfffffbfffffef), -0x1.2000002000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0240000040000080), 0x1.2000002000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbfffff7f), -0x1.2000002000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000040000100), 0x1.2000002000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbffffeff), -0x1.2000002000008p+57, -0x1p+0 },
+{ INT64_C(0x0240000040000400), 0x1.200000200002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbffffbff), -0x1.200000200002p+57, -0x1p+0 },
+{ INT64_C(0x0240000040002000), 0x1.20000020001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbfffdfff), -0x1.20000020001p+57, -0x1p+0 },
+{ INT64_C(0x0240000040010000), 0x1.20000020008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbffeffff), -0x1.20000020008p+57, -0x1p+0 },
+{ INT64_C(0x0240000040020000), 0x1.2000002001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbffdffff), -0x1.2000002001p+57, -0x1p+0 },
+{ INT64_C(0x0240000040200000), 0x1.200000201p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbfdfffff), -0x1.200000201p+57, -0x1p+0 },
+{ INT64_C(0x0240000041000000), 0x1.200000208p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbeffffff), -0x1.200000208p+57, -0x1p+0 },
+{ INT64_C(0x0240000042000000), 0x1.20000021p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbdffffff), -0x1.20000021p+57, -0x1p+0 },
+{ INT64_C(0x0240000044000000), 0x1.20000022p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffffbbffffff), -0x1.20000022p+57, -0x1p+0 },
+{ INT64_C(0x0240000060000000), 0x1.2000003p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffff9fffffff), -0x1.2000003p+57, -0x1p+0 },
+{ INT64_C(0x0240000400000000), 0x1.200002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbffffffff), -0x1.200002p+57, -0x1p+0 },
+{ INT64_C(0x0240000400000008), 0x1.200002p+57, 0x1p+3 },
+{ INT64_C(0xfdbffffbfffffff7), -0x1.200002p+57, -0x1.2p+3 },
+{ INT64_C(0x0240000400000020), 0x1.2000020000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbffffffdf), -0x1.2000020000001p+57, -0x1p+0 },
+{ INT64_C(0x0240000400000080), 0x1.2000020000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbffffff7f), -0x1.2000020000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000400000800), 0x1.200002000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbfffff7ff), -0x1.200002000004p+57, -0x1p+0 },
+{ INT64_C(0x0240000400008000), 0x1.20000200004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbffff7fff), -0x1.20000200004p+57, -0x1p+0 },
+{ INT64_C(0x0240000400010000), 0x1.20000200008p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbfffeffff), -0x1.20000200008p+57, -0x1p+0 },
+{ INT64_C(0x0240000400100000), 0x1.2000020008p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbffefffff), -0x1.2000020008p+57, -0x1p+0 },
+{ INT64_C(0x0240000400200000), 0x1.200002001p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbffdfffff), -0x1.200002001p+57, -0x1p+0 },
+{ INT64_C(0x0240000400800000), 0x1.200002004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbff7fffff), -0x1.200002004p+57, -0x1p+0 },
+{ INT64_C(0x0240000404000000), 0x1.20000202p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbfbffffff), -0x1.20000202p+57, -0x1p+0 },
+{ INT64_C(0x0240000420000000), 0x1.2000021p+57, 0x0p+0 },
+{ INT64_C(0xfdbffffbdfffffff), -0x1.2000021p+57, -0x1p+0 },
+{ INT64_C(0x0240000600000000), 0x1.200003p+57, 0x0p+0 },
+{ INT64_C(0xfdbffff9ffffffff), -0x1.200003p+57, -0x1p+0 },
+{ INT64_C(0x0240001000000000), 0x1.200008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffefffffffff), -0x1.200008p+57, -0x1p+0 },
+{ INT64_C(0x0240001000000002), 0x1.200008p+57, 0x1p+1 },
+{ INT64_C(0xfdbfffeffffffffd), -0x1.200008p+57, -0x1.8p+1 },
+{ INT64_C(0x0240001000000008), 0x1.200008p+57, 0x1p+3 },
+{ INT64_C(0xfdbfffeffffffff7), -0x1.200008p+57, -0x1.2p+3 },
+{ INT64_C(0x0240001000000040), 0x1.2000080000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffefffffffbf), -0x1.2000080000002p+57, -0x1p+0 },
+{ INT64_C(0x0240001000000100), 0x1.2000080000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffeffffffeff), -0x1.2000080000008p+57, -0x1p+0 },
+{ INT64_C(0x0240001000000800), 0x1.200008000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffeffffff7ff), -0x1.200008000004p+57, -0x1p+0 },
+{ INT64_C(0x0240001000004000), 0x1.20000800002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffefffffbfff), -0x1.20000800002p+57, -0x1p+0 },
+{ INT64_C(0x0240001000008000), 0x1.20000800004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffefffff7fff), -0x1.20000800004p+57, -0x1p+0 },
+{ INT64_C(0x0240001000040000), 0x1.2000080002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffeffffbffff), -0x1.2000080002p+57, -0x1p+0 },
+{ INT64_C(0x0240001000100000), 0x1.2000080008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffefffefffff), -0x1.2000080008p+57, -0x1p+0 },
+{ INT64_C(0x0240001000800000), 0x1.200008004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffefff7fffff), -0x1.200008004p+57, -0x1p+0 },
+{ INT64_C(0x0240001001000000), 0x1.200008008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffeffeffffff), -0x1.200008008p+57, -0x1p+0 },
+{ INT64_C(0x0240001002000000), 0x1.20000801p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffeffdffffff), -0x1.20000801p+57, -0x1p+0 },
+{ INT64_C(0x0240001008000000), 0x1.20000804p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffeff7ffffff), -0x1.20000804p+57, -0x1p+0 },
+{ INT64_C(0x0240001080000000), 0x1.2000084p+57, 0x0p+0 },
+{ INT64_C(0xfdbfffef7fffffff), -0x1.2000084p+57, -0x1p+0 },
+{ INT64_C(0x0240001800000000), 0x1.20000cp+57, 0x0p+0 },
+{ INT64_C(0xfdbfffe7ffffffff), -0x1.20000cp+57, -0x1p+0 },
+{ INT64_C(0x0240010000000000), 0x1.20008p+57, 0x0p+0 },
+{ INT64_C(0xfdbffeffffffffff), -0x1.20008p+57, -0x1p+0 },
+{ INT64_C(0x0240010000000002), 0x1.20008p+57, 0x1p+1 },
+{ INT64_C(0xfdbffefffffffffd), -0x1.20008p+57, -0x1.8p+1 },
+{ INT64_C(0x0240010000000008), 0x1.20008p+57, 0x1p+3 },
+{ INT64_C(0xfdbffefffffffff7), -0x1.20008p+57, -0x1.2p+3 },
+{ INT64_C(0x0240010000000040), 0x1.2000800000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffeffffffffbf), -0x1.2000800000002p+57, -0x1p+0 },
+{ INT64_C(0x0240010000000200), 0x1.200080000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefffffffdff), -0x1.200080000001p+57, -0x1p+0 },
+{ INT64_C(0x0240010000000400), 0x1.200080000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefffffffbff), -0x1.200080000002p+57, -0x1p+0 },
+{ INT64_C(0x0240010000004000), 0x1.20008000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffeffffffbfff), -0x1.20008000002p+57, -0x1p+0 },
+{ INT64_C(0x0240010000020000), 0x1.2000800001p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefffffdffff), -0x1.2000800001p+57, -0x1p+0 },
+{ INT64_C(0x0240010000040000), 0x1.2000800002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefffffbffff), -0x1.2000800002p+57, -0x1p+0 },
+{ INT64_C(0x0240010000080000), 0x1.2000800004p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefffff7ffff), -0x1.2000800004p+57, -0x1p+0 },
+{ INT64_C(0x0240010000400000), 0x1.200080002p+57, 0x0p+0 },
+{ INT64_C(0xfdbffeffffbfffff), -0x1.200080002p+57, -0x1p+0 },
+{ INT64_C(0x0240010002000000), 0x1.20008001p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefffdffffff), -0x1.20008001p+57, -0x1p+0 },
+{ INT64_C(0x0240010020000000), 0x1.2000801p+57, 0x0p+0 },
+{ INT64_C(0xfdbffeffdfffffff), -0x1.2000801p+57, -0x1p+0 },
+{ INT64_C(0x0240010040000000), 0x1.2000802p+57, 0x0p+0 },
+{ INT64_C(0xfdbffeffbfffffff), -0x1.2000802p+57, -0x1p+0 },
+{ INT64_C(0x0240010100000000), 0x1.2000808p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefeffffffff), -0x1.2000808p+57, -0x1p+0 },
+{ INT64_C(0x0240010400000000), 0x1.200082p+57, 0x0p+0 },
+{ INT64_C(0xfdbffefbffffffff), -0x1.200082p+57, -0x1p+0 },
+{ INT64_C(0x0240010800000000), 0x1.200084p+57, 0x0p+0 },
+{ INT64_C(0xfdbffef7ffffffff), -0x1.200084p+57, -0x1p+0 },
+{ INT64_C(0x0240012000000000), 0x1.20009p+57, 0x0p+0 },
+{ INT64_C(0xfdbffedfffffffff), -0x1.20009p+57, -0x1p+0 },
+{ INT64_C(0x0240100000000000), 0x1.2008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffffffffff), -0x1.2008p+57, -0x1p+0 },
+{ INT64_C(0x0240100000000004), 0x1.2008p+57, 0x1p+2 },
+{ INT64_C(0xfdbfeffffffffffb), -0x1.2008p+57, -0x1.4p+2 },
+{ INT64_C(0x0240100000000008), 0x1.2008p+57, 0x1p+3 },
+{ INT64_C(0xfdbfeffffffffff7), -0x1.2008p+57, -0x1.2p+3 },
+{ INT64_C(0x0240100000000040), 0x1.2008000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffffffffbf), -0x1.2008000000002p+57, -0x1p+0 },
+{ INT64_C(0x0240100000000080), 0x1.2008000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffffffff7f), -0x1.2008000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240100000000400), 0x1.200800000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeffffffffbff), -0x1.200800000002p+57, -0x1p+0 },
+{ INT64_C(0x0240100000001000), 0x1.200800000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffffffefff), -0x1.200800000008p+57, -0x1p+0 },
+{ INT64_C(0x0240100000008000), 0x1.20080000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffffff7fff), -0x1.20080000004p+57, -0x1p+0 },
+{ INT64_C(0x0240100000010000), 0x1.20080000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeffffffeffff), -0x1.20080000008p+57, -0x1p+0 },
+{ INT64_C(0x0240100000020000), 0x1.2008000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeffffffdffff), -0x1.2008000001p+57, -0x1p+0 },
+{ INT64_C(0x0240100000200000), 0x1.200800001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffffdfffff), -0x1.200800001p+57, -0x1p+0 },
+{ INT64_C(0x0240100002000000), 0x1.20080001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeffffdffffff), -0x1.20080001p+57, -0x1p+0 },
+{ INT64_C(0x0240100010000000), 0x1.20080008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffefffffff), -0x1.20080008p+57, -0x1p+0 },
+{ INT64_C(0x0240100040000000), 0x1.2008002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefffbfffffff), -0x1.2008002p+57, -0x1p+0 },
+{ INT64_C(0x0240100400000000), 0x1.200802p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeffbffffffff), -0x1.200802p+57, -0x1p+0 },
+{ INT64_C(0x0240100800000000), 0x1.200804p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeff7ffffffff), -0x1.200804p+57, -0x1p+0 },
+{ INT64_C(0x0240102000000000), 0x1.20081p+57, 0x0p+0 },
+{ INT64_C(0xfdbfefdfffffffff), -0x1.20081p+57, -0x1p+0 },
+{ INT64_C(0x0240110000000000), 0x1.20088p+57, 0x0p+0 },
+{ INT64_C(0xfdbfeeffffffffff), -0x1.20088p+57, -0x1p+0 },
+{ INT64_C(0x0240200000000000), 0x1.201p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdfffffffffff), -0x1.201p+57, -0x1p+0 },
+{ INT64_C(0x0240200000000002), 0x1.201p+57, 0x1p+1 },
+{ INT64_C(0xfdbfdffffffffffd), -0x1.201p+57, -0x1.8p+1 },
+{ INT64_C(0x0240200000000008), 0x1.201p+57, 0x1p+3 },
+{ INT64_C(0xfdbfdffffffffff7), -0x1.201p+57, -0x1.2p+3 },
+{ INT64_C(0x0240200000000010), 0x1.201p+57, 0x1p+4 },
+{ INT64_C(0xfdbfdfffffffffef), -0x1.2010000000001p+57, 0x1.ep+3 },
+{ INT64_C(0x0240200000000100), 0x1.2010000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffffffffeff), -0x1.2010000000008p+57, -0x1p+0 },
+{ INT64_C(0x0240200000000400), 0x1.201000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffffffffbff), -0x1.201000000002p+57, -0x1p+0 },
+{ INT64_C(0x0240200000000800), 0x1.201000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffffffff7ff), -0x1.201000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240200000008000), 0x1.20100000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdfffffff7fff), -0x1.20100000004p+57, -0x1p+0 },
+{ INT64_C(0x0240200000020000), 0x1.2010000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffffffdffff), -0x1.2010000001p+57, -0x1p+0 },
+{ INT64_C(0x0240200000200000), 0x1.201000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdfffffdfffff), -0x1.201000001p+57, -0x1p+0 },
+{ INT64_C(0x0240200001000000), 0x1.201000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffffeffffff), -0x1.201000008p+57, -0x1p+0 },
+{ INT64_C(0x0240200004000000), 0x1.20100002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffffbffffff), -0x1.20100002p+57, -0x1p+0 },
+{ INT64_C(0x0240200040000000), 0x1.2010002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdfffbfffffff), -0x1.2010002p+57, -0x1p+0 },
+{ INT64_C(0x0240200200000000), 0x1.201001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdffdffffffff), -0x1.201001p+57, -0x1p+0 },
+{ INT64_C(0x0240202000000000), 0x1.20101p+57, 0x0p+0 },
+{ INT64_C(0xfdbfdfdfffffffff), -0x1.20101p+57, -0x1p+0 },
+{ INT64_C(0x0240220000000000), 0x1.2011p+57, 0x0p+0 },
+{ INT64_C(0xfdbfddffffffffff), -0x1.2011p+57, -0x1p+0 },
+{ INT64_C(0x0240400000000000), 0x1.202p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffffffff), -0x1.202p+57, -0x1p+0 },
+{ INT64_C(0x0240400000000004), 0x1.202p+57, 0x1p+2 },
+{ INT64_C(0xfdbfbffffffffffb), -0x1.202p+57, -0x1.4p+2 },
+{ INT64_C(0x0240400000000020), 0x1.2020000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffffffdf), -0x1.2020000000001p+57, -0x1p+0 },
+{ INT64_C(0x0240400000000040), 0x1.2020000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffffffbf), -0x1.2020000000002p+57, -0x1p+0 },
+{ INT64_C(0x0240400000000080), 0x1.2020000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffffff7f), -0x1.2020000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240400000000100), 0x1.2020000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffffffffeff), -0x1.2020000000008p+57, -0x1p+0 },
+{ INT64_C(0x0240400000000800), 0x1.202000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffffffff7ff), -0x1.202000000004p+57, -0x1p+0 },
+{ INT64_C(0x0240400000002000), 0x1.20200000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffffdfff), -0x1.20200000001p+57, -0x1p+0 },
+{ INT64_C(0x0240400000010000), 0x1.20200000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffffffeffff), -0x1.20200000008p+57, -0x1p+0 },
+{ INT64_C(0x0240400000040000), 0x1.2020000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffffffbffff), -0x1.2020000002p+57, -0x1p+0 },
+{ INT64_C(0x0240400000080000), 0x1.2020000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffffff7ffff), -0x1.2020000004p+57, -0x1p+0 },
+{ INT64_C(0x0240400000100000), 0x1.2020000008p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffefffff), -0x1.2020000008p+57, -0x1p+0 },
+{ INT64_C(0x0240400000400000), 0x1.202000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffffbfffff), -0x1.202000002p+57, -0x1p+0 },
+{ INT64_C(0x0240400004000000), 0x1.20200002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffffbffffff), -0x1.20200002p+57, -0x1p+0 },
+{ INT64_C(0x0240400020000000), 0x1.2020001p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfffdfffffff), -0x1.2020001p+57, -0x1p+0 },
+{ INT64_C(0x0240400080000000), 0x1.2020004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfff7fffffff), -0x1.2020004p+57, -0x1p+0 },
+{ INT64_C(0x0240400400000000), 0x1.202002p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbffbffffffff), -0x1.202002p+57, -0x1p+0 },
+{ INT64_C(0x0240400800000000), 0x1.202004p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbff7ffffffff), -0x1.202004p+57, -0x1p+0 },
+{ INT64_C(0x0240402000000000), 0x1.20201p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbfdfffffffff), -0x1.20201p+57, -0x1p+0 },
+{ INT64_C(0x0240408000000000), 0x1.20204p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbf7fffffffff), -0x1.20204p+57, -0x1p+0 },
+{ INT64_C(0x0240410000000000), 0x1.20208p+57, 0x0p+0 },
+{ INT64_C(0xfdbfbeffffffffff), -0x1.20208p+57, -0x1p+0 },
+{ INT64_C(0x0240500000000000), 0x1.2028p+57, 0x0p+0 },
+{ INT64_C(0xfdbfafffffffffff), -0x1.2028p+57, -0x1p+0 },
+{ INT64_C(0x0242000000000000), 0x1.21p+57, 0x0p+0 },
+{ INT64_C(0xfdbdffffffffffff), -0x1.21p+57, -0x1p+0 },
+{ INT64_C(0x0242000000000002), 0x1.21p+57, 0x1p+1 },
+{ INT64_C(0xfdbdfffffffffffd), -0x1.21p+57, -0x1.8p+1 },
+{ INT64_C(0x0242000000000004), 0x1.21p+57, 0x1p+2 },
+{ INT64_C(0xfdbdfffffffffffb), -0x1.21p+57, -0x1.4p+2 },
+{ INT64_C(0x0242000000000008), 0x1.21p+57, 0x1p+3 },
+{ INT64_C(0xfdbdfffffffffff7), -0x1.21p+57, -0x1.2p+3 },
+{ INT64_C(0x0242000000000040), 0x1.2100000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbdffffffffffbf), -0x1.2100000000002p+57, -0x1p+0 },
+{ INT64_C(0x0242000000000400), 0x1.210000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffffffffbff), -0x1.210000000002p+57, -0x1p+0 },
+{ INT64_C(0x0242000000000800), 0x1.210000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffffffff7ff), -0x1.210000000004p+57, -0x1p+0 },
+{ INT64_C(0x0242000000004000), 0x1.21000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbdffffffffbfff), -0x1.21000000002p+57, -0x1p+0 },
+{ INT64_C(0x0242000000040000), 0x1.2100000002p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffffffbffff), -0x1.2100000002p+57, -0x1p+0 },
+{ INT64_C(0x0242000000080000), 0x1.2100000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffffff7ffff), -0x1.2100000004p+57, -0x1p+0 },
+{ INT64_C(0x0242000000200000), 0x1.210000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbdffffffdfffff), -0x1.210000001p+57, -0x1p+0 },
+{ INT64_C(0x0242000002000000), 0x1.21000001p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffffdffffff), -0x1.21000001p+57, -0x1p+0 },
+{ INT64_C(0x0242000008000000), 0x1.21000004p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffff7ffffff), -0x1.21000004p+57, -0x1p+0 },
+{ INT64_C(0x0242000040000000), 0x1.2100002p+57, 0x0p+0 },
+{ INT64_C(0xfdbdffffbfffffff), -0x1.2100002p+57, -0x1p+0 },
+{ INT64_C(0x0242000200000000), 0x1.210001p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfffdffffffff), -0x1.210001p+57, -0x1p+0 },
+{ INT64_C(0x0242000800000000), 0x1.210004p+57, 0x0p+0 },
+{ INT64_C(0xfdbdfff7ffffffff), -0x1.210004p+57, -0x1p+0 },
+{ INT64_C(0x0242008000000000), 0x1.21004p+57, 0x0p+0 },
+{ INT64_C(0xfdbdff7fffffffff), -0x1.21004p+57, -0x1p+0 },
+{ INT64_C(0x0242080000000000), 0x1.2104p+57, 0x0p+0 },
+{ INT64_C(0xfdbdf7ffffffffff), -0x1.2104p+57, -0x1p+0 },
+{ INT64_C(0x0242400000000000), 0x1.212p+57, 0x0p+0 },
+{ INT64_C(0xfdbdbfffffffffff), -0x1.212p+57, -0x1p+0 },
+{ INT64_C(0x0243000000000000), 0x1.218p+57, 0x0p+0 },
+{ INT64_C(0xfdbcffffffffffff), -0x1.218p+57, -0x1p+0 },
+{ INT64_C(0x0250000000000000), 0x1.28p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffffffffff), -0x1.28p+57, -0x1p+0 },
+{ INT64_C(0x0250000000000004), 0x1.28p+57, 0x1p+2 },
+{ INT64_C(0xfdaffffffffffffb), -0x1.28p+57, -0x1.4p+2 },
+{ INT64_C(0x0250000000000040), 0x1.2800000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffffffffbf), -0x1.2800000000002p+57, -0x1p+0 },
+{ INT64_C(0x0250000000000100), 0x1.2800000000008p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffffffffeff), -0x1.2800000000008p+57, -0x1p+0 },
+{ INT64_C(0x0250000000000200), 0x1.280000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffffffffdff), -0x1.280000000001p+57, -0x1p+0 },
+{ INT64_C(0x0250000000002000), 0x1.28000000001p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffffffdfff), -0x1.28000000001p+57, -0x1p+0 },
+{ INT64_C(0x0250000000004000), 0x1.28000000002p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffffffbfff), -0x1.28000000002p+57, -0x1p+0 },
+{ INT64_C(0x0250000000008000), 0x1.28000000004p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffffff7fff), -0x1.28000000004p+57, -0x1p+0 },
+{ INT64_C(0x0250000000040000), 0x1.2800000002p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffffffbffff), -0x1.2800000002p+57, -0x1p+0 },
+{ INT64_C(0x0250000000200000), 0x1.280000001p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffffdfffff), -0x1.280000001p+57, -0x1p+0 },
+{ INT64_C(0x0250000000800000), 0x1.280000004p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffff7fffff), -0x1.280000004p+57, -0x1p+0 },
+{ INT64_C(0x0250000002000000), 0x1.28000001p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffffdffffff), -0x1.28000001p+57, -0x1p+0 },
+{ INT64_C(0x0250000010000000), 0x1.28000008p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffefffffff), -0x1.28000008p+57, -0x1p+0 },
+{ INT64_C(0x0250000020000000), 0x1.2800001p+57, 0x0p+0 },
+{ INT64_C(0xfdafffffdfffffff), -0x1.2800001p+57, -0x1p+0 },
+{ INT64_C(0x0250000100000000), 0x1.2800008p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffeffffffff), -0x1.2800008p+57, -0x1p+0 },
+{ INT64_C(0x0250000200000000), 0x1.280001p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffdffffffff), -0x1.280001p+57, -0x1p+0 },
+{ INT64_C(0x0250000400000000), 0x1.280002p+57, 0x0p+0 },
+{ INT64_C(0xfdaffffbffffffff), -0x1.280002p+57, -0x1p+0 },
+{ INT64_C(0x0250000800000000), 0x1.280004p+57, 0x0p+0 },
+{ INT64_C(0xfdaffff7ffffffff), -0x1.280004p+57, -0x1p+0 },
+{ INT64_C(0x0250004000000000), 0x1.28002p+57, 0x0p+0 },
+{ INT64_C(0xfdafffbfffffffff), -0x1.28002p+57, -0x1p+0 },
+{ INT64_C(0x0250040000000000), 0x1.2802p+57, 0x0p+0 },
+{ INT64_C(0xfdaffbffffffffff), -0x1.2802p+57, -0x1p+0 },
+{ INT64_C(0x0250400000000000), 0x1.282p+57, 0x0p+0 },
+{ INT64_C(0xfdafbfffffffffff), -0x1.282p+57, -0x1p+0 },
+{ INT64_C(0x0254000000000000), 0x1.2ap+57, 0x0p+0 },
+{ INT64_C(0xfdabffffffffffff), -0x1.2ap+57, -0x1p+0 },
+{ INT64_C(0x100000000000000c), 0x1p+60, 0x1.8p+3 },
+{ INT64_C(0xeffffffffffffff3), -0x1p+60, -0x1.ap+3 },
+{ INT64_C(0x1000000000000022), 0x1p+60, 0x1.1p+5 },
+{ INT64_C(0xefffffffffffffdd), -0x1p+60, -0x1.18p+5 },
+{ INT64_C(0x1000000000000028), 0x1p+60, 0x1.4p+5 },
+{ INT64_C(0xefffffffffffffd7), -0x1p+60, -0x1.48p+5 },
+{ INT64_C(0x1000000000000029), 0x1p+60, 0x1.48p+5 },
+{ INT64_C(0xefffffffffffffd6), -0x1p+60, -0x1.5p+5 },
+{ INT64_C(0x1000000000000030), 0x1p+60, 0x1.8p+5 },
+{ INT64_C(0xefffffffffffffcf), -0x1p+60, -0x1.88p+5 },
+{ INT64_C(0x1000000000000032), 0x1p+60, 0x1.9p+5 },
+{ INT64_C(0xefffffffffffffcd), -0x1p+60, -0x1.98p+5 },
+{ INT64_C(0x1000000000000201), 0x1.0000000000002p+60, 0x1p+0 },
+{ INT64_C(0xeffffffffffffdfe), -0x1.0000000000002p+60, -0x1p+1 },
+{ INT64_C(0x1000000000000210), 0x1.0000000000002p+60, 0x1p+4 },
+{ INT64_C(0xeffffffffffffdef), -0x1.0000000000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000000000211), 0x1.0000000000002p+60, 0x1.1p+4 },
+{ INT64_C(0xeffffffffffffdee), -0x1.0000000000002p+60, -0x1.2p+4 },
+{ INT64_C(0x1000000000000212), 0x1.0000000000002p+60, 0x1.2p+4 },
+{ INT64_C(0xeffffffffffffded), -0x1.0000000000002p+60, -0x1.3p+4 },
+{ INT64_C(0x1000000000000214), 0x1.0000000000002p+60, 0x1.4p+4 },
+{ INT64_C(0xeffffffffffffdeb), -0x1.0000000000002p+60, -0x1.5p+4 },
+{ INT64_C(0x1000000000000218), 0x1.0000000000002p+60, 0x1.8p+4 },
+{ INT64_C(0xeffffffffffffde7), -0x1.0000000000002p+60, -0x1.9p+4 },
+{ INT64_C(0x1000000000000300), 0x1.0000000000003p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffffcff), -0x1.0000000000003p+60, -0x1p+0 },
+{ INT64_C(0x1000000000000302), 0x1.0000000000003p+60, 0x1p+1 },
+{ INT64_C(0xeffffffffffffcfd), -0x1.0000000000003p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000000000304), 0x1.0000000000003p+60, 0x1p+2 },
+{ INT64_C(0xeffffffffffffcfb), -0x1.0000000000003p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000000340), 0x1.0000000000003p+60, 0x1p+6 },
+{ INT64_C(0xeffffffffffffcbf), -0x1.0000000000003p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000000801), 0x1.0000000000008p+60, 0x1p+0 },
+{ INT64_C(0xeffffffffffff7fe), -0x1.0000000000008p+60, -0x1p+1 },
+{ INT64_C(0x1000000000000804), 0x1.0000000000008p+60, 0x1p+2 },
+{ INT64_C(0xeffffffffffff7fb), -0x1.0000000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000000806), 0x1.0000000000008p+60, 0x1.8p+2 },
+{ INT64_C(0xeffffffffffff7f9), -0x1.0000000000008p+60, -0x1.cp+2 },
+{ INT64_C(0x1000000000000820), 0x1.0000000000008p+60, 0x1p+5 },
+{ INT64_C(0xeffffffffffff7df), -0x1.0000000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000000822), 0x1.0000000000008p+60, 0x1.1p+5 },
+{ INT64_C(0xeffffffffffff7dd), -0x1.0000000000008p+60, -0x1.18p+5 },
+{ INT64_C(0x1000000000000824), 0x1.0000000000008p+60, 0x1.2p+5 },
+{ INT64_C(0xeffffffffffff7db), -0x1.0000000000008p+60, -0x1.28p+5 },
+{ INT64_C(0x1000000000000830), 0x1.0000000000008p+60, 0x1.8p+5 },
+{ INT64_C(0xeffffffffffff7cf), -0x1.0000000000008p+60, -0x1.88p+5 },
+{ INT64_C(0x1000000000000900), 0x1.0000000000009p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffff6ff), -0x1.0000000000009p+60, -0x1p+0 },
+{ INT64_C(0x1000000000000902), 0x1.0000000000009p+60, 0x1p+1 },
+{ INT64_C(0xeffffffffffff6fd), -0x1.0000000000009p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000000000908), 0x1.0000000000009p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffff6f7), -0x1.0000000000009p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000000980), 0x1.000000000000ap+60, -0x1p+7 },
+{ INT64_C(0xeffffffffffff67f), -0x1.000000000000ap+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000001008), 0x1.000000000001p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffffeff7), -0x1.000000000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000001010), 0x1.000000000001p+60, 0x1p+4 },
+{ INT64_C(0xefffffffffffefef), -0x1.000000000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000000001011), 0x1.000000000001p+60, 0x1.1p+4 },
+{ INT64_C(0xefffffffffffefee), -0x1.000000000001p+60, -0x1.2p+4 },
+{ INT64_C(0x1000000000001014), 0x1.000000000001p+60, 0x1.4p+4 },
+{ INT64_C(0xefffffffffffefeb), -0x1.000000000001p+60, -0x1.5p+4 },
+{ INT64_C(0x1000000000001040), 0x1.000000000001p+60, 0x1p+6 },
+{ INT64_C(0xefffffffffffefbf), -0x1.000000000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000001041), 0x1.000000000001p+60, 0x1.04p+6 },
+{ INT64_C(0xefffffffffffefbe), -0x1.000000000001p+60, -0x1.08p+6 },
+{ INT64_C(0x1000000000001044), 0x1.000000000001p+60, 0x1.1p+6 },
+{ INT64_C(0xefffffffffffefbb), -0x1.000000000001p+60, -0x1.14p+6 },
+{ INT64_C(0x1000000000001050), 0x1.000000000001p+60, 0x1.4p+6 },
+{ INT64_C(0xefffffffffffefaf), -0x1.000000000001p+60, -0x1.44p+6 },
+{ INT64_C(0x1000000000001060), 0x1.000000000001p+60, 0x1.8p+6 },
+{ INT64_C(0xefffffffffffef9f), -0x1.000000000001p+60, -0x1.84p+6 },
+{ INT64_C(0x1000000000001400), 0x1.0000000000014p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffffebff), -0x1.0000000000014p+60, -0x1p+0 },
+{ INT64_C(0x1000000000001401), 0x1.0000000000014p+60, 0x1p+0 },
+{ INT64_C(0xefffffffffffebfe), -0x1.0000000000014p+60, -0x1p+1 },
+{ INT64_C(0x1000000000001408), 0x1.0000000000014p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffffebf7), -0x1.0000000000014p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000001440), 0x1.0000000000014p+60, 0x1p+6 },
+{ INT64_C(0xefffffffffffebbf), -0x1.0000000000014p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000001800), 0x1.0000000000018p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffffe7ff), -0x1.0000000000018p+60, -0x1p+0 },
+{ INT64_C(0x1000000000001804), 0x1.0000000000018p+60, 0x1p+2 },
+{ INT64_C(0xefffffffffffe7fb), -0x1.0000000000018p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000001820), 0x1.0000000000018p+60, 0x1p+5 },
+{ INT64_C(0xefffffffffffe7df), -0x1.0000000000018p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000001a00), 0x1.000000000001ap+60, 0x0p+0 },
+{ INT64_C(0xefffffffffffe5ff), -0x1.000000000001ap+60, -0x1p+0 },
+{ INT64_C(0x1000000000001c00), 0x1.000000000001cp+60, 0x0p+0 },
+{ INT64_C(0xefffffffffffe3ff), -0x1.000000000001cp+60, -0x1p+0 },
+{ INT64_C(0x1000000000008004), 0x1.000000000008p+60, 0x1p+2 },
+{ INT64_C(0xefffffffffff7ffb), -0x1.000000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000008005), 0x1.000000000008p+60, 0x1.4p+2 },
+{ INT64_C(0xefffffffffff7ffa), -0x1.000000000008p+60, -0x1.8p+2 },
+{ INT64_C(0x1000000000008020), 0x1.000000000008p+60, 0x1p+5 },
+{ INT64_C(0xefffffffffff7fdf), -0x1.000000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000008021), 0x1.000000000008p+60, 0x1.08p+5 },
+{ INT64_C(0xefffffffffff7fde), -0x1.000000000008p+60, -0x1.1p+5 },
+{ INT64_C(0x1000000000008030), 0x1.000000000008p+60, 0x1.8p+5 },
+{ INT64_C(0xefffffffffff7fcf), -0x1.000000000008p+60, -0x1.88p+5 },
+{ INT64_C(0x1000000000008200), 0x1.0000000000082p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff7dff), -0x1.0000000000082p+60, -0x1p+0 },
+{ INT64_C(0x1000000000008201), 0x1.0000000000082p+60, 0x1p+0 },
+{ INT64_C(0xefffffffffff7dfe), -0x1.0000000000082p+60, -0x1p+1 },
+{ INT64_C(0x1000000000008208), 0x1.0000000000082p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffff7df7), -0x1.0000000000082p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000008280), 0x1.0000000000082p+60, 0x1p+7 },
+{ INT64_C(0xefffffffffff7d7f), -0x1.0000000000083p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000009000), 0x1.000000000009p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff6fff), -0x1.000000000009p+60, -0x1p+0 },
+{ INT64_C(0x1000000000009008), 0x1.000000000009p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffff6ff7), -0x1.000000000009p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000009020), 0x1.000000000009p+60, 0x1p+5 },
+{ INT64_C(0xefffffffffff6fdf), -0x1.000000000009p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000009200), 0x1.0000000000092p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff6dff), -0x1.0000000000092p+60, -0x1p+0 },
+{ INT64_C(0x1000000000009400), 0x1.0000000000094p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff6bff), -0x1.0000000000094p+60, -0x1p+0 },
+{ INT64_C(0x100000000000c000), 0x1.00000000000cp+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff3fff), -0x1.00000000000cp+60, -0x1p+0 },
+{ INT64_C(0x100000000000c001), 0x1.00000000000cp+60, 0x1p+0 },
+{ INT64_C(0xefffffffffff3ffe), -0x1.00000000000cp+60, -0x1p+1 },
+{ INT64_C(0x100000000000c004), 0x1.00000000000cp+60, 0x1p+2 },
+{ INT64_C(0xefffffffffff3ffb), -0x1.00000000000cp+60, -0x1.4p+2 },
+{ INT64_C(0x100000000000c020), 0x1.00000000000cp+60, 0x1p+5 },
+{ INT64_C(0xefffffffffff3fdf), -0x1.00000000000cp+60, -0x1.08p+5 },
+{ INT64_C(0x100000000000c200), 0x1.00000000000c2p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff3dff), -0x1.00000000000c2p+60, -0x1p+0 },
+{ INT64_C(0x100000000000c400), 0x1.00000000000c4p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff3bff), -0x1.00000000000c4p+60, -0x1p+0 },
+{ INT64_C(0x100000000000d000), 0x1.00000000000dp+60, 0x0p+0 },
+{ INT64_C(0xefffffffffff2fff), -0x1.00000000000dp+60, -0x1p+0 },
+{ INT64_C(0x1000000000040008), 0x1.00000000004p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffbfff7), -0x1.00000000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000040010), 0x1.00000000004p+60, 0x1p+4 },
+{ INT64_C(0xeffffffffffbffef), -0x1.00000000004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000000040012), 0x1.00000000004p+60, 0x1.2p+4 },
+{ INT64_C(0xeffffffffffbffed), -0x1.00000000004p+60, -0x1.3p+4 },
+{ INT64_C(0x1000000000040040), 0x1.00000000004p+60, 0x1p+6 },
+{ INT64_C(0xeffffffffffbffbf), -0x1.00000000004p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000040042), 0x1.00000000004p+60, 0x1.08p+6 },
+{ INT64_C(0xeffffffffffbffbd), -0x1.00000000004p+60, -0x1.0cp+6 },
+{ INT64_C(0x1000000000040044), 0x1.00000000004p+60, 0x1.1p+6 },
+{ INT64_C(0xeffffffffffbffbb), -0x1.00000000004p+60, -0x1.14p+6 },
+{ INT64_C(0x1000000000040060), 0x1.00000000004p+60, 0x1.8p+6 },
+{ INT64_C(0xeffffffffffbff9f), -0x1.00000000004p+60, -0x1.84p+6 },
+{ INT64_C(0x1000000000040100), 0x1.0000000000401p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbfeff), -0x1.0000000000401p+60, -0x1p+0 },
+{ INT64_C(0x1000000000040102), 0x1.0000000000401p+60, 0x1p+1 },
+{ INT64_C(0xeffffffffffbfefd), -0x1.0000000000401p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000000040104), 0x1.0000000000401p+60, 0x1p+2 },
+{ INT64_C(0xeffffffffffbfefb), -0x1.0000000000401p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000040108), 0x1.0000000000401p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffbfef7), -0x1.0000000000401p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000040120), 0x1.0000000000401p+60, 0x1p+5 },
+{ INT64_C(0xeffffffffffbfedf), -0x1.0000000000401p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000040200), 0x1.0000000000402p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbfdff), -0x1.0000000000402p+60, -0x1p+0 },
+{ INT64_C(0x1000000000040201), 0x1.0000000000402p+60, 0x1p+0 },
+{ INT64_C(0xeffffffffffbfdfe), -0x1.0000000000402p+60, -0x1p+1 },
+{ INT64_C(0x1000000000040204), 0x1.0000000000402p+60, 0x1p+2 },
+{ INT64_C(0xeffffffffffbfdfb), -0x1.0000000000402p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000040208), 0x1.0000000000402p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffbfdf7), -0x1.0000000000402p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000040280), 0x1.0000000000402p+60, 0x1p+7 },
+{ INT64_C(0xeffffffffffbfd7f), -0x1.0000000000403p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000041000), 0x1.000000000041p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbefff), -0x1.000000000041p+60, -0x1p+0 },
+{ INT64_C(0x1000000000041001), 0x1.000000000041p+60, 0x1p+0 },
+{ INT64_C(0xeffffffffffbeffe), -0x1.000000000041p+60, -0x1p+1 },
+{ INT64_C(0x1000000000041008), 0x1.000000000041p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffbeff7), -0x1.000000000041p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000041040), 0x1.000000000041p+60, 0x1p+6 },
+{ INT64_C(0xeffffffffffbefbf), -0x1.000000000041p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000041400), 0x1.0000000000414p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbebff), -0x1.0000000000414p+60, -0x1p+0 },
+{ INT64_C(0x1000000000041800), 0x1.0000000000418p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbe7ff), -0x1.0000000000418p+60, -0x1p+0 },
+{ INT64_C(0x1000000000042000), 0x1.000000000042p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbdfff), -0x1.000000000042p+60, -0x1p+0 },
+{ INT64_C(0x1000000000042001), 0x1.000000000042p+60, 0x1p+0 },
+{ INT64_C(0xeffffffffffbdffe), -0x1.000000000042p+60, -0x1p+1 },
+{ INT64_C(0x1000000000042008), 0x1.000000000042p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffbdff7), -0x1.000000000042p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000042040), 0x1.000000000042p+60, 0x1p+6 },
+{ INT64_C(0xeffffffffffbdfbf), -0x1.000000000042p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000042080), 0x1.000000000042p+60, 0x1p+7 },
+{ INT64_C(0xeffffffffffbdf7f), -0x1.0000000000421p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000042400), 0x1.0000000000424p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbdbff), -0x1.0000000000424p+60, -0x1p+0 },
+{ INT64_C(0x1000000000043000), 0x1.000000000043p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffbcfff), -0x1.000000000043p+60, -0x1p+0 },
+{ INT64_C(0x1000000000048000), 0x1.000000000048p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffb7fff), -0x1.000000000048p+60, -0x1p+0 },
+{ INT64_C(0x1000000000048008), 0x1.000000000048p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffffb7ff7), -0x1.000000000048p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000048020), 0x1.000000000048p+60, 0x1p+5 },
+{ INT64_C(0xeffffffffffb7fdf), -0x1.000000000048p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000048040), 0x1.000000000048p+60, 0x1p+6 },
+{ INT64_C(0xeffffffffffb7fbf), -0x1.000000000048p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000048200), 0x1.0000000000482p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffb7dff), -0x1.0000000000482p+60, -0x1p+0 },
+{ INT64_C(0x1000000000048400), 0x1.0000000000484p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffb7bff), -0x1.0000000000484p+60, -0x1p+0 },
+{ INT64_C(0x1000000000049000), 0x1.000000000049p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffb6fff), -0x1.000000000049p+60, -0x1p+0 },
+{ INT64_C(0x100000000004a000), 0x1.00000000004ap+60, 0x0p+0 },
+{ INT64_C(0xeffffffffffb5fff), -0x1.00000000004ap+60, -0x1p+0 },
+{ INT64_C(0x1000000000060000), 0x1.00000000006p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffff9ffff), -0x1.00000000006p+60, -0x1p+0 },
+{ INT64_C(0x1000000000060008), 0x1.00000000006p+60, 0x1p+3 },
+{ INT64_C(0xeffffffffff9fff7), -0x1.00000000006p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000060010), 0x1.00000000006p+60, 0x1p+4 },
+{ INT64_C(0xeffffffffff9ffef), -0x1.00000000006p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000000060080), 0x1.00000000006p+60, 0x1p+7 },
+{ INT64_C(0xeffffffffff9ff7f), -0x1.0000000000601p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000060400), 0x1.0000000000604p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffff9fbff), -0x1.0000000000604p+60, -0x1p+0 },
+{ INT64_C(0x1000000000064000), 0x1.000000000064p+60, 0x0p+0 },
+{ INT64_C(0xeffffffffff9bfff), -0x1.000000000064p+60, -0x1p+0 },
+{ INT64_C(0x1000000000100004), 0x1.0000000001p+60, 0x1p+2 },
+{ INT64_C(0xefffffffffeffffb), -0x1.0000000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000100040), 0x1.0000000001p+60, 0x1p+6 },
+{ INT64_C(0xefffffffffefffbf), -0x1.0000000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000100048), 0x1.0000000001p+60, 0x1.2p+6 },
+{ INT64_C(0xefffffffffefffb7), -0x1.0000000001p+60, -0x1.24p+6 },
+{ INT64_C(0x1000000000100060), 0x1.0000000001p+60, 0x1.8p+6 },
+{ INT64_C(0xefffffffffefff9f), -0x1.0000000001p+60, -0x1.84p+6 },
+{ INT64_C(0x1000000000100200), 0x1.0000000001002p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffeffdff), -0x1.0000000001002p+60, -0x1p+0 },
+{ INT64_C(0x1000000000100208), 0x1.0000000001002p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffeffdf7), -0x1.0000000001002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000100220), 0x1.0000000001002p+60, 0x1p+5 },
+{ INT64_C(0xefffffffffeffddf), -0x1.0000000001002p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000100300), 0x1.0000000001003p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffeffcff), -0x1.0000000001003p+60, -0x1p+0 },
+{ INT64_C(0x1000000000102000), 0x1.000000000102p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffefdfff), -0x1.000000000102p+60, -0x1p+0 },
+{ INT64_C(0x1000000000102008), 0x1.000000000102p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffefdff7), -0x1.000000000102p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000102040), 0x1.000000000102p+60, 0x1p+6 },
+{ INT64_C(0xefffffffffefdfbf), -0x1.000000000102p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000102400), 0x1.0000000001024p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffefdbff), -0x1.0000000001024p+60, -0x1p+0 },
+{ INT64_C(0x1000000000103000), 0x1.000000000103p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffefcfff), -0x1.000000000103p+60, -0x1p+0 },
+{ INT64_C(0x1000000000110000), 0x1.00000000011p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffeeffff), -0x1.00000000011p+60, -0x1p+0 },
+{ INT64_C(0x1000000000110001), 0x1.00000000011p+60, 0x1p+0 },
+{ INT64_C(0xefffffffffeefffe), -0x1.00000000011p+60, -0x1p+1 },
+{ INT64_C(0x1000000000110010), 0x1.00000000011p+60, 0x1p+4 },
+{ INT64_C(0xefffffffffeeffef), -0x1.00000000011p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000000110080), 0x1.00000000011p+60, 0x1p+7 },
+{ INT64_C(0xefffffffffeeff7f), -0x1.0000000001101p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000110200), 0x1.0000000001102p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffeefdff), -0x1.0000000001102p+60, -0x1p+0 },
+{ INT64_C(0x1000000000111000), 0x1.000000000111p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffeeefff), -0x1.000000000111p+60, -0x1p+0 },
+{ INT64_C(0x1000000000114000), 0x1.000000000114p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffeebfff), -0x1.000000000114p+60, -0x1p+0 },
+{ INT64_C(0x1000000000180000), 0x1.00000000018p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffe7ffff), -0x1.00000000018p+60, -0x1p+0 },
+{ INT64_C(0x1000000000180008), 0x1.00000000018p+60, 0x1p+3 },
+{ INT64_C(0xefffffffffe7fff7), -0x1.00000000018p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000180020), 0x1.00000000018p+60, 0x1p+5 },
+{ INT64_C(0xefffffffffe7ffdf), -0x1.00000000018p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000180100), 0x1.0000000001801p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffe7feff), -0x1.0000000001801p+60, -0x1p+0 },
+{ INT64_C(0x1000000000180200), 0x1.0000000001802p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffe7fdff), -0x1.0000000001802p+60, -0x1p+0 },
+{ INT64_C(0x1000000000180800), 0x1.0000000001808p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffe7f7ff), -0x1.0000000001808p+60, -0x1p+0 },
+{ INT64_C(0x1000000000188000), 0x1.000000000188p+60, 0x0p+0 },
+{ INT64_C(0xefffffffffe77fff), -0x1.000000000188p+60, -0x1p+0 },
+{ INT64_C(0x10000000001c0000), 0x1.0000000001cp+60, 0x0p+0 },
+{ INT64_C(0xefffffffffe3ffff), -0x1.0000000001cp+60, -0x1p+0 },
+{ INT64_C(0x1000000000800002), 0x1.0000000008p+60, 0x1p+1 },
+{ INT64_C(0xefffffffff7ffffd), -0x1.0000000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000000800008), 0x1.0000000008p+60, 0x1p+3 },
+{ INT64_C(0xefffffffff7ffff7), -0x1.0000000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000800040), 0x1.0000000008p+60, 0x1p+6 },
+{ INT64_C(0xefffffffff7fffbf), -0x1.0000000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000800048), 0x1.0000000008p+60, 0x1.2p+6 },
+{ INT64_C(0xefffffffff7fffb7), -0x1.0000000008p+60, -0x1.24p+6 },
+{ INT64_C(0x1000000000800060), 0x1.0000000008p+60, 0x1.8p+6 },
+{ INT64_C(0xefffffffff7fff9f), -0x1.0000000008p+60, -0x1.84p+6 },
+{ INT64_C(0x1000000000800400), 0x1.0000000008004p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7ffbff), -0x1.0000000008004p+60, -0x1p+0 },
+{ INT64_C(0x1000000000800402), 0x1.0000000008004p+60, 0x1p+1 },
+{ INT64_C(0xefffffffff7ffbfd), -0x1.0000000008004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000000800410), 0x1.0000000008004p+60, 0x1p+4 },
+{ INT64_C(0xefffffffff7ffbef), -0x1.0000000008004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000000800420), 0x1.0000000008004p+60, 0x1p+5 },
+{ INT64_C(0xefffffffff7ffbdf), -0x1.0000000008004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000800480), 0x1.0000000008004p+60, 0x1p+7 },
+{ INT64_C(0xefffffffff7ffb7f), -0x1.0000000008005p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000802000), 0x1.000000000802p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7fdfff), -0x1.000000000802p+60, -0x1p+0 },
+{ INT64_C(0x1000000000802008), 0x1.000000000802p+60, 0x1p+3 },
+{ INT64_C(0xefffffffff7fdff7), -0x1.000000000802p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000802080), 0x1.000000000802p+60, 0x1p+7 },
+{ INT64_C(0xefffffffff7fdf7f), -0x1.0000000008021p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000802100), 0x1.0000000008021p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7fdeff), -0x1.0000000008021p+60, -0x1p+0 },
+{ INT64_C(0x1000000000803000), 0x1.000000000803p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7fcfff), -0x1.000000000803p+60, -0x1p+0 },
+{ INT64_C(0x1000000000810000), 0x1.00000000081p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7effff), -0x1.00000000081p+60, -0x1p+0 },
+{ INT64_C(0x1000000000810004), 0x1.00000000081p+60, 0x1p+2 },
+{ INT64_C(0xefffffffff7efffb), -0x1.00000000081p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000000810040), 0x1.00000000081p+60, 0x1p+6 },
+{ INT64_C(0xefffffffff7effbf), -0x1.00000000081p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000000810200), 0x1.0000000008102p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7efdff), -0x1.0000000008102p+60, -0x1p+0 },
+{ INT64_C(0x1000000000812000), 0x1.000000000812p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7edfff), -0x1.000000000812p+60, -0x1p+0 },
+{ INT64_C(0x1000000000814000), 0x1.000000000814p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7ebfff), -0x1.000000000814p+60, -0x1p+0 },
+{ INT64_C(0x1000000000818000), 0x1.000000000818p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7e7fff), -0x1.000000000818p+60, -0x1p+0 },
+{ INT64_C(0x1000000000820000), 0x1.00000000082p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7dffff), -0x1.00000000082p+60, -0x1p+0 },
+{ INT64_C(0x1000000000820008), 0x1.00000000082p+60, 0x1p+3 },
+{ INT64_C(0xefffffffff7dfff7), -0x1.00000000082p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000820080), 0x1.00000000082p+60, 0x1p+7 },
+{ INT64_C(0xefffffffff7dff7f), -0x1.0000000008201p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000820800), 0x1.0000000008208p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7df7ff), -0x1.0000000008208p+60, -0x1p+0 },
+{ INT64_C(0x1000000000822000), 0x1.000000000822p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7ddfff), -0x1.000000000822p+60, -0x1p+0 },
+{ INT64_C(0x1000000000824000), 0x1.000000000824p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff7dbfff), -0x1.000000000824p+60, -0x1p+0 },
+{ INT64_C(0x1000000000a00000), 0x1.000000000ap+60, 0x0p+0 },
+{ INT64_C(0xefffffffff5fffff), -0x1.000000000ap+60, -0x1p+0 },
+{ INT64_C(0x1000000000a00008), 0x1.000000000ap+60, 0x1p+3 },
+{ INT64_C(0xefffffffff5ffff7), -0x1.000000000ap+60, -0x1.2p+3 },
+{ INT64_C(0x1000000000a00020), 0x1.000000000ap+60, 0x1p+5 },
+{ INT64_C(0xefffffffff5fffdf), -0x1.000000000ap+60, -0x1.08p+5 },
+{ INT64_C(0x1000000000a00080), 0x1.000000000ap+60, 0x1p+7 },
+{ INT64_C(0xefffffffff5fff7f), -0x1.000000000a001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000000a00200), 0x1.000000000a002p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff5ffdff), -0x1.000000000a002p+60, -0x1p+0 },
+{ INT64_C(0x1000000000a02000), 0x1.000000000a02p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff5fdfff), -0x1.000000000a02p+60, -0x1p+0 },
+{ INT64_C(0x1000000000a08000), 0x1.000000000a08p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff5f7fff), -0x1.000000000a08p+60, -0x1p+0 },
+{ INT64_C(0x1000000000a20000), 0x1.000000000a2p+60, 0x0p+0 },
+{ INT64_C(0xefffffffff5dffff), -0x1.000000000a2p+60, -0x1p+0 },
+{ INT64_C(0x1000000000b00000), 0x1.000000000bp+60, 0x0p+0 },
+{ INT64_C(0xefffffffff4fffff), -0x1.000000000bp+60, -0x1p+0 },
+{ INT64_C(0x1000000008000004), 0x1.000000008p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff7fffffb), -0x1.000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000008000020), 0x1.000000008p+60, 0x1p+5 },
+{ INT64_C(0xeffffffff7ffffdf), -0x1.000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000008000021), 0x1.000000008p+60, 0x1.08p+5 },
+{ INT64_C(0xeffffffff7ffffde), -0x1.000000008p+60, -0x1.1p+5 },
+{ INT64_C(0x1000000008000030), 0x1.000000008p+60, 0x1.8p+5 },
+{ INT64_C(0xeffffffff7ffffcf), -0x1.000000008p+60, -0x1.88p+5 },
+{ INT64_C(0x1000000008000040), 0x1.000000008p+60, 0x1p+6 },
+{ INT64_C(0xeffffffff7ffffbf), -0x1.000000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000008000048), 0x1.000000008p+60, 0x1.2p+6 },
+{ INT64_C(0xeffffffff7ffffb7), -0x1.000000008p+60, -0x1.24p+6 },
+{ INT64_C(0x1000000008000080), 0x1.000000008p+60, 0x1p+7 },
+{ INT64_C(0xeffffffff7ffff7f), -0x1.0000000080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000008000081), 0x1.0000000080001p+60, -0x1.fcp+6 },
+{ INT64_C(0xeffffffff7ffff7e), -0x1.0000000080001p+60, 0x1.f8p+6 },
+{ INT64_C(0x1000000008000090), 0x1.0000000080001p+60, -0x1.cp+6 },
+{ INT64_C(0xeffffffff7ffff6f), -0x1.0000000080001p+60, 0x1.bcp+6 },
+{ INT64_C(0x1000000008000400), 0x1.0000000080004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7fffbff), -0x1.0000000080004p+60, -0x1p+0 },
+{ INT64_C(0x1000000008000404), 0x1.0000000080004p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff7fffbfb), -0x1.0000000080004p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000008000440), 0x1.0000000080004p+60, 0x1p+6 },
+{ INT64_C(0xeffffffff7fffbbf), -0x1.0000000080004p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000008000600), 0x1.0000000080006p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7fff9ff), -0x1.0000000080006p+60, -0x1p+0 },
+{ INT64_C(0x1000000008002000), 0x1.000000008002p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ffdfff), -0x1.000000008002p+60, -0x1p+0 },
+{ INT64_C(0x1000000008002004), 0x1.000000008002p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff7ffdffb), -0x1.000000008002p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000008002008), 0x1.000000008002p+60, 0x1p+3 },
+{ INT64_C(0xeffffffff7ffdff7), -0x1.000000008002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000008002040), 0x1.000000008002p+60, 0x1p+6 },
+{ INT64_C(0xeffffffff7ffdfbf), -0x1.000000008002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000008002080), 0x1.000000008002p+60, 0x1p+7 },
+{ INT64_C(0xeffffffff7ffdf7f), -0x1.0000000080021p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000008002200), 0x1.0000000080022p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ffddff), -0x1.0000000080022p+60, -0x1p+0 },
+{ INT64_C(0x1000000008008000), 0x1.000000008008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ff7fff), -0x1.000000008008p+60, -0x1p+0 },
+{ INT64_C(0x1000000008008001), 0x1.000000008008p+60, 0x1p+0 },
+{ INT64_C(0xeffffffff7ff7ffe), -0x1.000000008008p+60, -0x1p+1 },
+{ INT64_C(0x1000000008008008), 0x1.000000008008p+60, 0x1p+3 },
+{ INT64_C(0xeffffffff7ff7ff7), -0x1.000000008008p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000008008010), 0x1.000000008008p+60, 0x1p+4 },
+{ INT64_C(0xeffffffff7ff7fef), -0x1.000000008008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000008008080), 0x1.000000008008p+60, 0x1p+7 },
+{ INT64_C(0xeffffffff7ff7f7f), -0x1.0000000080081p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000008008400), 0x1.0000000080084p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ff7bff), -0x1.0000000080084p+60, -0x1p+0 },
+{ INT64_C(0x100000000800a000), 0x1.00000000800ap+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ff5fff), -0x1.00000000800ap+60, -0x1p+0 },
+{ INT64_C(0x100000000800c000), 0x1.00000000800cp+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ff3fff), -0x1.00000000800cp+60, -0x1p+0 },
+{ INT64_C(0x1000000008010000), 0x1.00000000801p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7feffff), -0x1.00000000801p+60, -0x1p+0 },
+{ INT64_C(0x1000000008010004), 0x1.00000000801p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff7fefffb), -0x1.00000000801p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000008010008), 0x1.00000000801p+60, 0x1p+3 },
+{ INT64_C(0xeffffffff7fefff7), -0x1.00000000801p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000008010080), 0x1.00000000801p+60, 0x1p+7 },
+{ INT64_C(0xeffffffff7feff7f), -0x1.0000000080101p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000008010100), 0x1.0000000080101p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7fefeff), -0x1.0000000080101p+60, -0x1p+0 },
+{ INT64_C(0x1000000008010400), 0x1.0000000080104p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7fefbff), -0x1.0000000080104p+60, -0x1p+0 },
+{ INT64_C(0x1000000008011000), 0x1.000000008011p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7feefff), -0x1.000000008011p+60, -0x1p+0 },
+{ INT64_C(0x1000000008100000), 0x1.0000000081p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7efffff), -0x1.0000000081p+60, -0x1p+0 },
+{ INT64_C(0x1000000008100004), 0x1.0000000081p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff7effffb), -0x1.0000000081p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000008100010), 0x1.0000000081p+60, 0x1p+4 },
+{ INT64_C(0xeffffffff7efffef), -0x1.0000000081p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000008100020), 0x1.0000000081p+60, 0x1p+5 },
+{ INT64_C(0xeffffffff7efffdf), -0x1.0000000081p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000008100100), 0x1.0000000081001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7effeff), -0x1.0000000081001p+60, -0x1p+0 },
+{ INT64_C(0x1000000008100800), 0x1.0000000081008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7eff7ff), -0x1.0000000081008p+60, -0x1p+0 },
+{ INT64_C(0x1000000008108000), 0x1.000000008108p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ef7fff), -0x1.000000008108p+60, -0x1p+0 },
+{ INT64_C(0x1000000008180000), 0x1.00000000818p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7e7ffff), -0x1.00000000818p+60, -0x1p+0 },
+{ INT64_C(0x1000000008200000), 0x1.0000000082p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7dfffff), -0x1.0000000082p+60, -0x1p+0 },
+{ INT64_C(0x1000000008200001), 0x1.0000000082p+60, 0x1p+0 },
+{ INT64_C(0xeffffffff7dffffe), -0x1.0000000082p+60, -0x1p+1 },
+{ INT64_C(0x1000000008200002), 0x1.0000000082p+60, 0x1p+1 },
+{ INT64_C(0xeffffffff7dffffd), -0x1.0000000082p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000008200004), 0x1.0000000082p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff7dffffb), -0x1.0000000082p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000008200010), 0x1.0000000082p+60, 0x1p+4 },
+{ INT64_C(0xeffffffff7dfffef), -0x1.0000000082p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000008200020), 0x1.0000000082p+60, 0x1p+5 },
+{ INT64_C(0xeffffffff7dfffdf), -0x1.0000000082p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000008200080), 0x1.0000000082p+60, 0x1p+7 },
+{ INT64_C(0xeffffffff7dfff7f), -0x1.0000000082001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000008200100), 0x1.0000000082001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7dffeff), -0x1.0000000082001p+60, -0x1p+0 },
+{ INT64_C(0x1000000008200800), 0x1.0000000082008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7dff7ff), -0x1.0000000082008p+60, -0x1p+0 },
+{ INT64_C(0x1000000008202000), 0x1.000000008202p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7dfdfff), -0x1.000000008202p+60, -0x1p+0 },
+{ INT64_C(0x1000000008220000), 0x1.00000000822p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7ddffff), -0x1.00000000822p+60, -0x1p+0 },
+{ INT64_C(0x1000000008280000), 0x1.00000000828p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff7d7ffff), -0x1.00000000828p+60, -0x1p+0 },
+{ INT64_C(0x1000000009000000), 0x1.000000009p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6ffffff), -0x1.000000009p+60, -0x1p+0 },
+{ INT64_C(0x1000000009000004), 0x1.000000009p+60, 0x1p+2 },
+{ INT64_C(0xeffffffff6fffffb), -0x1.000000009p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000009000010), 0x1.000000009p+60, 0x1p+4 },
+{ INT64_C(0xeffffffff6ffffef), -0x1.000000009p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000009000100), 0x1.0000000090001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6fffeff), -0x1.0000000090001p+60, -0x1p+0 },
+{ INT64_C(0x1000000009000400), 0x1.0000000090004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6fffbff), -0x1.0000000090004p+60, -0x1p+0 },
+{ INT64_C(0x1000000009001000), 0x1.000000009001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6ffefff), -0x1.000000009001p+60, -0x1p+0 },
+{ INT64_C(0x1000000009002000), 0x1.000000009002p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6ffdfff), -0x1.000000009002p+60, -0x1p+0 },
+{ INT64_C(0x1000000009020000), 0x1.00000000902p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6fdffff), -0x1.00000000902p+60, -0x1p+0 },
+{ INT64_C(0x1000000009200000), 0x1.0000000092p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff6dfffff), -0x1.0000000092p+60, -0x1p+0 },
+{ INT64_C(0x1000000009800000), 0x1.0000000098p+60, 0x0p+0 },
+{ INT64_C(0xeffffffff67fffff), -0x1.0000000098p+60, -0x1p+0 },
+{ INT64_C(0x1000000040000001), 0x1.00000004p+60, 0x1p+0 },
+{ INT64_C(0xefffffffbffffffe), -0x1.00000004p+60, -0x1p+1 },
+{ INT64_C(0x1000000040000008), 0x1.00000004p+60, 0x1p+3 },
+{ INT64_C(0xefffffffbffffff7), -0x1.00000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000040000020), 0x1.00000004p+60, 0x1p+5 },
+{ INT64_C(0xefffffffbfffffdf), -0x1.00000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000040000024), 0x1.00000004p+60, 0x1.2p+5 },
+{ INT64_C(0xefffffffbfffffdb), -0x1.00000004p+60, -0x1.28p+5 },
+{ INT64_C(0x1000000040000100), 0x1.0000000400001p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffffeff), -0x1.0000000400001p+60, -0x1p+0 },
+{ INT64_C(0x1000000040000101), 0x1.0000000400001p+60, 0x1p+0 },
+{ INT64_C(0xefffffffbffffefe), -0x1.0000000400001p+60, -0x1p+1 },
+{ INT64_C(0x1000000040000108), 0x1.0000000400001p+60, 0x1p+3 },
+{ INT64_C(0xefffffffbffffef7), -0x1.0000000400001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000040000180), 0x1.0000000400002p+60, -0x1p+7 },
+{ INT64_C(0xefffffffbffffe7f), -0x1.0000000400002p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000040000400), 0x1.0000000400004p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffffbff), -0x1.0000000400004p+60, -0x1p+0 },
+{ INT64_C(0x1000000040000401), 0x1.0000000400004p+60, 0x1p+0 },
+{ INT64_C(0xefffffffbffffbfe), -0x1.0000000400004p+60, -0x1p+1 },
+{ INT64_C(0x1000000040000410), 0x1.0000000400004p+60, 0x1p+4 },
+{ INT64_C(0xefffffffbffffbef), -0x1.0000000400004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000040000480), 0x1.0000000400004p+60, 0x1p+7 },
+{ INT64_C(0xefffffffbffffb7f), -0x1.0000000400005p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000040001000), 0x1.000000040001p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfffefff), -0x1.000000040001p+60, -0x1p+0 },
+{ INT64_C(0x1000000040001002), 0x1.000000040001p+60, 0x1p+1 },
+{ INT64_C(0xefffffffbfffeffd), -0x1.000000040001p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000040001004), 0x1.000000040001p+60, 0x1p+2 },
+{ INT64_C(0xefffffffbfffeffb), -0x1.000000040001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000040001040), 0x1.000000040001p+60, 0x1p+6 },
+{ INT64_C(0xefffffffbfffefbf), -0x1.000000040001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000040001400), 0x1.0000000400014p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfffebff), -0x1.0000000400014p+60, -0x1p+0 },
+{ INT64_C(0x1000000040001800), 0x1.0000000400018p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfffe7ff), -0x1.0000000400018p+60, -0x1p+0 },
+{ INT64_C(0x1000000040008000), 0x1.000000040008p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfff7fff), -0x1.000000040008p+60, -0x1p+0 },
+{ INT64_C(0x1000000040008004), 0x1.000000040008p+60, 0x1p+2 },
+{ INT64_C(0xefffffffbfff7ffb), -0x1.000000040008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000040008010), 0x1.000000040008p+60, 0x1p+4 },
+{ INT64_C(0xefffffffbfff7fef), -0x1.000000040008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000040008020), 0x1.000000040008p+60, 0x1p+5 },
+{ INT64_C(0xefffffffbfff7fdf), -0x1.000000040008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000040008100), 0x1.0000000400081p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfff7eff), -0x1.0000000400081p+60, -0x1p+0 },
+{ INT64_C(0x1000000040008200), 0x1.0000000400082p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfff7dff), -0x1.0000000400082p+60, -0x1p+0 },
+{ INT64_C(0x100000004000a000), 0x1.00000004000ap+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfff5fff), -0x1.00000004000ap+60, -0x1p+0 },
+{ INT64_C(0x100000004000c000), 0x1.00000004000cp+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfff3fff), -0x1.00000004000cp+60, -0x1p+0 },
+{ INT64_C(0x1000000040010000), 0x1.00000004001p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffeffff), -0x1.00000004001p+60, -0x1p+0 },
+{ INT64_C(0x1000000040010002), 0x1.00000004001p+60, 0x1p+1 },
+{ INT64_C(0xefffffffbffefffd), -0x1.00000004001p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000040010010), 0x1.00000004001p+60, 0x1p+4 },
+{ INT64_C(0xefffffffbffeffef), -0x1.00000004001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000040010080), 0x1.00000004001p+60, 0x1p+7 },
+{ INT64_C(0xefffffffbffeff7f), -0x1.0000000400101p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000040010200), 0x1.0000000400102p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffefdff), -0x1.0000000400102p+60, -0x1p+0 },
+{ INT64_C(0x1000000040010800), 0x1.0000000400108p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffef7ff), -0x1.0000000400108p+60, -0x1p+0 },
+{ INT64_C(0x1000000040011000), 0x1.000000040011p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffeefff), -0x1.000000040011p+60, -0x1p+0 },
+{ INT64_C(0x1000000040012000), 0x1.000000040012p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffedfff), -0x1.000000040012p+60, -0x1p+0 },
+{ INT64_C(0x1000000040014000), 0x1.000000040014p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffebfff), -0x1.000000040014p+60, -0x1p+0 },
+{ INT64_C(0x1000000040018000), 0x1.000000040018p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffe7fff), -0x1.000000040018p+60, -0x1p+0 },
+{ INT64_C(0x1000000040040000), 0x1.00000004004p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffbffff), -0x1.00000004004p+60, -0x1p+0 },
+{ INT64_C(0x1000000040040004), 0x1.00000004004p+60, 0x1p+2 },
+{ INT64_C(0xefffffffbffbfffb), -0x1.00000004004p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000040040010), 0x1.00000004004p+60, 0x1p+4 },
+{ INT64_C(0xefffffffbffbffef), -0x1.00000004004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000040040020), 0x1.00000004004p+60, 0x1p+5 },
+{ INT64_C(0xefffffffbffbffdf), -0x1.00000004004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000040040100), 0x1.0000000400401p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffbfeff), -0x1.0000000400401p+60, -0x1p+0 },
+{ INT64_C(0x1000000040040400), 0x1.0000000400404p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffbfbff), -0x1.0000000400404p+60, -0x1p+0 },
+{ INT64_C(0x1000000040042000), 0x1.000000040042p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffbdfff), -0x1.000000040042p+60, -0x1p+0 },
+{ INT64_C(0x1000000040048000), 0x1.000000040048p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffb7fff), -0x1.000000040048p+60, -0x1p+0 },
+{ INT64_C(0x1000000040050000), 0x1.00000004005p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbffaffff), -0x1.00000004005p+60, -0x1p+0 },
+{ INT64_C(0x1000000040200000), 0x1.0000000402p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfdfffff), -0x1.0000000402p+60, -0x1p+0 },
+{ INT64_C(0x1000000040200002), 0x1.0000000402p+60, 0x1p+1 },
+{ INT64_C(0xefffffffbfdffffd), -0x1.0000000402p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000040200010), 0x1.0000000402p+60, 0x1p+4 },
+{ INT64_C(0xefffffffbfdfffef), -0x1.0000000402p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000040200040), 0x1.0000000402p+60, 0x1p+6 },
+{ INT64_C(0xefffffffbfdfffbf), -0x1.0000000402p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000040200100), 0x1.0000000402001p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfdffeff), -0x1.0000000402001p+60, -0x1p+0 },
+{ INT64_C(0x1000000040201000), 0x1.000000040201p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfdfefff), -0x1.000000040201p+60, -0x1p+0 },
+{ INT64_C(0x1000000040204000), 0x1.000000040204p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfdfbfff), -0x1.000000040204p+60, -0x1p+0 },
+{ INT64_C(0x1000000040240000), 0x1.00000004024p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfdbffff), -0x1.00000004024p+60, -0x1p+0 },
+{ INT64_C(0x1000000040280000), 0x1.00000004028p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbfd7ffff), -0x1.00000004028p+60, -0x1p+0 },
+{ INT64_C(0x1000000040800000), 0x1.0000000408p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbf7fffff), -0x1.0000000408p+60, -0x1p+0 },
+{ INT64_C(0x1000000040800008), 0x1.0000000408p+60, 0x1p+3 },
+{ INT64_C(0xefffffffbf7ffff7), -0x1.0000000408p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000040800080), 0x1.0000000408p+60, 0x1p+7 },
+{ INT64_C(0xefffffffbf7fff7f), -0x1.0000000408001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000040800800), 0x1.0000000408008p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbf7ff7ff), -0x1.0000000408008p+60, -0x1p+0 },
+{ INT64_C(0x1000000040808000), 0x1.000000040808p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbf7f7fff), -0x1.000000040808p+60, -0x1p+0 },
+{ INT64_C(0x1000000040840000), 0x1.00000004084p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbf7bffff), -0x1.00000004084p+60, -0x1p+0 },
+{ INT64_C(0x1000000040880000), 0x1.00000004088p+60, 0x0p+0 },
+{ INT64_C(0xefffffffbf77ffff), -0x1.00000004088p+60, -0x1p+0 },
+{ INT64_C(0x1000000048000000), 0x1.000000048p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7ffffff), -0x1.000000048p+60, -0x1p+0 },
+{ INT64_C(0x1000000048000004), 0x1.000000048p+60, 0x1p+2 },
+{ INT64_C(0xefffffffb7fffffb), -0x1.000000048p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000048000020), 0x1.000000048p+60, 0x1p+5 },
+{ INT64_C(0xefffffffb7ffffdf), -0x1.000000048p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000048000080), 0x1.000000048p+60, 0x1p+7 },
+{ INT64_C(0xefffffffb7ffff7f), -0x1.0000000480001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000048000400), 0x1.0000000480004p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7fffbff), -0x1.0000000480004p+60, -0x1p+0 },
+{ INT64_C(0x1000000048002000), 0x1.000000048002p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7ffdfff), -0x1.000000048002p+60, -0x1p+0 },
+{ INT64_C(0x1000000048010000), 0x1.00000004801p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7feffff), -0x1.00000004801p+60, -0x1p+0 },
+{ INT64_C(0x1000000048020000), 0x1.00000004802p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7fdffff), -0x1.00000004802p+60, -0x1p+0 },
+{ INT64_C(0x1000000048040000), 0x1.00000004804p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7fbffff), -0x1.00000004804p+60, -0x1p+0 },
+{ INT64_C(0x1000000048080000), 0x1.00000004808p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7f7ffff), -0x1.00000004808p+60, -0x1p+0 },
+{ INT64_C(0x1000000048100000), 0x1.0000000481p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb7efffff), -0x1.0000000481p+60, -0x1p+0 },
+{ INT64_C(0x1000000049000000), 0x1.000000049p+60, 0x0p+0 },
+{ INT64_C(0xefffffffb6ffffff), -0x1.000000049p+60, -0x1p+0 },
+{ INT64_C(0x1000000060000000), 0x1.00000006p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9fffffff), -0x1.00000006p+60, -0x1p+0 },
+{ INT64_C(0x1000000060000008), 0x1.00000006p+60, 0x1p+3 },
+{ INT64_C(0xefffffff9ffffff7), -0x1.00000006p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000060000040), 0x1.00000006p+60, 0x1p+6 },
+{ INT64_C(0xefffffff9fffffbf), -0x1.00000006p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000060000400), 0x1.0000000600004p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9ffffbff), -0x1.0000000600004p+60, -0x1p+0 },
+{ INT64_C(0x1000000060000800), 0x1.0000000600008p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9ffff7ff), -0x1.0000000600008p+60, -0x1p+0 },
+{ INT64_C(0x1000000060002000), 0x1.000000060002p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9fffdfff), -0x1.000000060002p+60, -0x1p+0 },
+{ INT64_C(0x1000000060008000), 0x1.000000060008p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9fff7fff), -0x1.000000060008p+60, -0x1p+0 },
+{ INT64_C(0x1000000060020000), 0x1.00000006002p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9ffdffff), -0x1.00000006002p+60, -0x1p+0 },
+{ INT64_C(0x1000000060200000), 0x1.0000000602p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9fdfffff), -0x1.0000000602p+60, -0x1p+0 },
+{ INT64_C(0x1000000062000000), 0x1.000000062p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9dffffff), -0x1.000000062p+60, -0x1p+0 },
+{ INT64_C(0x1000000064000000), 0x1.000000064p+60, 0x0p+0 },
+{ INT64_C(0xefffffff9bffffff), -0x1.000000064p+60, -0x1p+0 },
+{ INT64_C(0x1000000200000001), 0x1.0000002p+60, 0x1p+0 },
+{ INT64_C(0xeffffffdfffffffe), -0x1.0000002p+60, -0x1p+1 },
+{ INT64_C(0x1000000200000002), 0x1.0000002p+60, 0x1p+1 },
+{ INT64_C(0xeffffffdfffffffd), -0x1.0000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000200000003), 0x1.0000002p+60, 0x1.8p+1 },
+{ INT64_C(0xeffffffdfffffffc), -0x1.0000002p+60, -0x1p+2 },
+{ INT64_C(0x1000000200000008), 0x1.0000002p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdfffffff7), -0x1.0000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000200000009), 0x1.0000002p+60, 0x1.2p+3 },
+{ INT64_C(0xeffffffdfffffff6), -0x1.0000002p+60, -0x1.4p+3 },
+{ INT64_C(0x1000000200000020), 0x1.0000002p+60, 0x1p+5 },
+{ INT64_C(0xeffffffdffffffdf), -0x1.0000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000200000022), 0x1.0000002p+60, 0x1.1p+5 },
+{ INT64_C(0xeffffffdffffffdd), -0x1.0000002p+60, -0x1.18p+5 },
+{ INT64_C(0x1000000200000028), 0x1.0000002p+60, 0x1.4p+5 },
+{ INT64_C(0xeffffffdffffffd7), -0x1.0000002p+60, -0x1.48p+5 },
+{ INT64_C(0x1000000200000040), 0x1.0000002p+60, 0x1p+6 },
+{ INT64_C(0xeffffffdffffffbf), -0x1.0000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000200000041), 0x1.0000002p+60, 0x1.04p+6 },
+{ INT64_C(0xeffffffdffffffbe), -0x1.0000002p+60, -0x1.08p+6 },
+{ INT64_C(0x1000000200000044), 0x1.0000002p+60, 0x1.1p+6 },
+{ INT64_C(0xeffffffdffffffbb), -0x1.0000002p+60, -0x1.14p+6 },
+{ INT64_C(0x1000000200000050), 0x1.0000002p+60, 0x1.4p+6 },
+{ INT64_C(0xeffffffdffffffaf), -0x1.0000002p+60, -0x1.44p+6 },
+{ INT64_C(0x1000000200000400), 0x1.0000002000004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffffbff), -0x1.0000002000004p+60, -0x1p+0 },
+{ INT64_C(0x1000000200000401), 0x1.0000002000004p+60, 0x1p+0 },
+{ INT64_C(0xeffffffdfffffbfe), -0x1.0000002000004p+60, -0x1p+1 },
+{ INT64_C(0x1000000200000408), 0x1.0000002000004p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdfffffbf7), -0x1.0000002000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000200000420), 0x1.0000002000004p+60, 0x1p+5 },
+{ INT64_C(0xeffffffdfffffbdf), -0x1.0000002000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000200000480), 0x1.0000002000004p+60, 0x1p+7 },
+{ INT64_C(0xeffffffdfffffb7f), -0x1.0000002000005p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000200000600), 0x1.0000002000006p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffff9ff), -0x1.0000002000006p+60, -0x1p+0 },
+{ INT64_C(0x1000000200001000), 0x1.000000200001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffffefff), -0x1.000000200001p+60, -0x1p+0 },
+{ INT64_C(0x1000000200001001), 0x1.000000200001p+60, 0x1p+0 },
+{ INT64_C(0xeffffffdffffeffe), -0x1.000000200001p+60, -0x1p+1 },
+{ INT64_C(0x1000000200001008), 0x1.000000200001p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdffffeff7), -0x1.000000200001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000200001010), 0x1.000000200001p+60, 0x1p+4 },
+{ INT64_C(0xeffffffdffffefef), -0x1.000000200001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000200001080), 0x1.000000200001p+60, 0x1p+7 },
+{ INT64_C(0xeffffffdffffef7f), -0x1.0000002000011p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000200001400), 0x1.0000002000014p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffffebff), -0x1.0000002000014p+60, -0x1p+0 },
+{ INT64_C(0x1000000200004000), 0x1.000000200004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffffbfff), -0x1.000000200004p+60, -0x1p+0 },
+{ INT64_C(0x1000000200004008), 0x1.000000200004p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdffffbff7), -0x1.000000200004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000200004020), 0x1.000000200004p+60, 0x1p+5 },
+{ INT64_C(0xeffffffdffffbfdf), -0x1.000000200004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000200004100), 0x1.0000002000041p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffffbeff), -0x1.0000002000041p+60, -0x1p+0 },
+{ INT64_C(0x1000000200004400), 0x1.0000002000044p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffffbbff), -0x1.0000002000044p+60, -0x1p+0 },
+{ INT64_C(0x1000000200004800), 0x1.0000002000048p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffffb7ff), -0x1.0000002000048p+60, -0x1p+0 },
+{ INT64_C(0x1000000200006000), 0x1.000000200006p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffff9fff), -0x1.000000200006p+60, -0x1p+0 },
+{ INT64_C(0x1000000200040000), 0x1.00000020004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffbffff), -0x1.00000020004p+60, -0x1p+0 },
+{ INT64_C(0x1000000200040001), 0x1.00000020004p+60, 0x1p+0 },
+{ INT64_C(0xeffffffdfffbfffe), -0x1.00000020004p+60, -0x1p+1 },
+{ INT64_C(0x1000000200040008), 0x1.00000020004p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdfffbfff7), -0x1.00000020004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000200040080), 0x1.00000020004p+60, 0x1p+7 },
+{ INT64_C(0xeffffffdfffbff7f), -0x1.0000002000401p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000200040100), 0x1.0000002000401p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffbfeff), -0x1.0000002000401p+60, -0x1p+0 },
+{ INT64_C(0x1000000200040400), 0x1.0000002000404p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffbfbff), -0x1.0000002000404p+60, -0x1p+0 },
+{ INT64_C(0x1000000200040800), 0x1.0000002000408p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffbf7ff), -0x1.0000002000408p+60, -0x1p+0 },
+{ INT64_C(0x1000000200042000), 0x1.000000200042p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffbdfff), -0x1.000000200042p+60, -0x1p+0 },
+{ INT64_C(0x1000000200044000), 0x1.000000200044p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffbbfff), -0x1.000000200044p+60, -0x1p+0 },
+{ INT64_C(0x1000000200048000), 0x1.000000200048p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfffb7fff), -0x1.000000200048p+60, -0x1p+0 },
+{ INT64_C(0x1000000200400000), 0x1.0000002004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffbfffff), -0x1.0000002004p+60, -0x1p+0 },
+{ INT64_C(0x1000000200400002), 0x1.0000002004p+60, 0x1p+1 },
+{ INT64_C(0xeffffffdffbffffd), -0x1.0000002004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000200400004), 0x1.0000002004p+60, 0x1p+2 },
+{ INT64_C(0xeffffffdffbffffb), -0x1.0000002004p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000200400020), 0x1.0000002004p+60, 0x1p+5 },
+{ INT64_C(0xeffffffdffbfffdf), -0x1.0000002004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000200400080), 0x1.0000002004p+60, 0x1p+7 },
+{ INT64_C(0xeffffffdffbfff7f), -0x1.0000002004001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000200400800), 0x1.0000002004008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffbff7ff), -0x1.0000002004008p+60, -0x1p+0 },
+{ INT64_C(0x1000000200404000), 0x1.000000200404p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffbfbfff), -0x1.000000200404p+60, -0x1p+0 },
+{ INT64_C(0x1000000200440000), 0x1.00000020044p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffbbffff), -0x1.00000020044p+60, -0x1p+0 },
+{ INT64_C(0x1000000200500000), 0x1.0000002005p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdffafffff), -0x1.0000002005p+60, -0x1p+0 },
+{ INT64_C(0x1000000201000000), 0x1.000000201p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfeffffff), -0x1.000000201p+60, -0x1p+0 },
+{ INT64_C(0x1000000201000008), 0x1.000000201p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdfefffff7), -0x1.000000201p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000201000020), 0x1.000000201p+60, 0x1p+5 },
+{ INT64_C(0xeffffffdfeffffdf), -0x1.000000201p+60, -0x1.08p+5 },
+{ INT64_C(0x1000000201000100), 0x1.0000002010001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfefffeff), -0x1.0000002010001p+60, -0x1p+0 },
+{ INT64_C(0x1000000201000400), 0x1.0000002010004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfefffbff), -0x1.0000002010004p+60, -0x1p+0 },
+{ INT64_C(0x1000000201001000), 0x1.000000201001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfeffefff), -0x1.000000201001p+60, -0x1p+0 },
+{ INT64_C(0x1000000201010000), 0x1.00000020101p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfefeffff), -0x1.00000020101p+60, -0x1p+0 },
+{ INT64_C(0x1000000201040000), 0x1.00000020104p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfefbffff), -0x1.00000020104p+60, -0x1p+0 },
+{ INT64_C(0x1000000201400000), 0x1.0000002014p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfebfffff), -0x1.0000002014p+60, -0x1p+0 },
+{ INT64_C(0x1000000202000000), 0x1.000000202p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdffffff), -0x1.000000202p+60, -0x1p+0 },
+{ INT64_C(0x1000000202000008), 0x1.000000202p+60, 0x1p+3 },
+{ INT64_C(0xeffffffdfdfffff7), -0x1.000000202p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000202000040), 0x1.000000202p+60, 0x1p+6 },
+{ INT64_C(0xeffffffdfdffffbf), -0x1.000000202p+60, -0x1.04p+6 },
+{ INT64_C(0x1000000202000100), 0x1.0000002020001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdfffeff), -0x1.0000002020001p+60, -0x1p+0 },
+{ INT64_C(0x1000000202000200), 0x1.0000002020002p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdfffdff), -0x1.0000002020002p+60, -0x1p+0 },
+{ INT64_C(0x1000000202000400), 0x1.0000002020004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdfffbff), -0x1.0000002020004p+60, -0x1p+0 },
+{ INT64_C(0x1000000202000800), 0x1.0000002020008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdfff7ff), -0x1.0000002020008p+60, -0x1p+0 },
+{ INT64_C(0x1000000202004000), 0x1.000000202004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdffbfff), -0x1.000000202004p+60, -0x1p+0 },
+{ INT64_C(0x1000000202008000), 0x1.000000202008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdff7fff), -0x1.000000202008p+60, -0x1p+0 },
+{ INT64_C(0x1000000202010000), 0x1.00000020201p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdfeffff), -0x1.00000020201p+60, -0x1p+0 },
+{ INT64_C(0x1000000202080000), 0x1.00000020208p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdf7ffff), -0x1.00000020208p+60, -0x1p+0 },
+{ INT64_C(0x1000000202400000), 0x1.0000002024p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfdbfffff), -0x1.0000002024p+60, -0x1p+0 },
+{ INT64_C(0x1000000202800000), 0x1.0000002028p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdfd7fffff), -0x1.0000002028p+60, -0x1p+0 },
+{ INT64_C(0x1000000208000000), 0x1.000000208p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7ffffff), -0x1.000000208p+60, -0x1p+0 },
+{ INT64_C(0x1000000208000001), 0x1.000000208p+60, 0x1p+0 },
+{ INT64_C(0xeffffffdf7fffffe), -0x1.000000208p+60, -0x1p+1 },
+{ INT64_C(0x1000000208000004), 0x1.000000208p+60, 0x1p+2 },
+{ INT64_C(0xeffffffdf7fffffb), -0x1.000000208p+60, -0x1.4p+2 },
+{ INT64_C(0x1000000208000010), 0x1.000000208p+60, 0x1p+4 },
+{ INT64_C(0xeffffffdf7ffffef), -0x1.000000208p+60, -0x1.1p+4 },
+{ INT64_C(0x1000000208000080), 0x1.000000208p+60, 0x1p+7 },
+{ INT64_C(0xeffffffdf7ffff7f), -0x1.0000002080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000208000200), 0x1.0000002080002p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7fffdff), -0x1.0000002080002p+60, -0x1p+0 },
+{ INT64_C(0x1000000208000800), 0x1.0000002080008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7fff7ff), -0x1.0000002080008p+60, -0x1p+0 },
+{ INT64_C(0x1000000208001000), 0x1.000000208001p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7ffefff), -0x1.000000208001p+60, -0x1p+0 },
+{ INT64_C(0x1000000208002000), 0x1.000000208002p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7ffdfff), -0x1.000000208002p+60, -0x1p+0 },
+{ INT64_C(0x1000000208020000), 0x1.00000020802p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7fdffff), -0x1.00000020802p+60, -0x1p+0 },
+{ INT64_C(0x1000000208200000), 0x1.0000002082p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf7dfffff), -0x1.0000002082p+60, -0x1p+0 },
+{ INT64_C(0x1000000209000000), 0x1.000000209p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdf6ffffff), -0x1.000000209p+60, -0x1p+0 },
+{ INT64_C(0x1000000220000000), 0x1.00000022p+60, 0x0p+0 },
+{ INT64_C(0xeffffffddfffffff), -0x1.00000022p+60, -0x1p+0 },
+{ INT64_C(0x1000000220000002), 0x1.00000022p+60, 0x1p+1 },
+{ INT64_C(0xeffffffddffffffd), -0x1.00000022p+60, -0x1.8p+1 },
+{ INT64_C(0x1000000220000008), 0x1.00000022p+60, 0x1p+3 },
+{ INT64_C(0xeffffffddffffff7), -0x1.00000022p+60, -0x1.2p+3 },
+{ INT64_C(0x1000000220000080), 0x1.00000022p+60, 0x1p+7 },
+{ INT64_C(0xeffffffddfffff7f), -0x1.0000002200001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000000220000200), 0x1.0000002200002p+60, 0x0p+0 },
+{ INT64_C(0xeffffffddffffdff), -0x1.0000002200002p+60, -0x1p+0 },
+{ INT64_C(0x1000000220000800), 0x1.0000002200008p+60, 0x0p+0 },
+{ INT64_C(0xeffffffddffff7ff), -0x1.0000002200008p+60, -0x1p+0 },
+{ INT64_C(0x1000000220004000), 0x1.000000220004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffddfffbfff), -0x1.000000220004p+60, -0x1p+0 },
+{ INT64_C(0x1000000220040000), 0x1.00000022004p+60, 0x0p+0 },
+{ INT64_C(0xeffffffddffbffff), -0x1.00000022004p+60, -0x1p+0 },
+{ INT64_C(0x1000000220200000), 0x1.0000002202p+60, 0x0p+0 },
+{ INT64_C(0xeffffffddfdfffff), -0x1.0000002202p+60, -0x1p+0 },
+{ INT64_C(0x1000000222000000), 0x1.000000222p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdddffffff), -0x1.000000222p+60, -0x1p+0 },
+{ INT64_C(0x1000000228000000), 0x1.000000228p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdd7ffffff), -0x1.000000228p+60, -0x1p+0 },
+{ INT64_C(0x1000000230000000), 0x1.00000023p+60, 0x0p+0 },
+{ INT64_C(0xeffffffdcfffffff), -0x1.00000023p+60, -0x1p+0 },
+{ INT64_C(0x1000002000000002), 0x1.000002p+60, 0x1p+1 },
+{ INT64_C(0xefffffdffffffffd), -0x1.000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1000002000000004), 0x1.000002p+60, 0x1p+2 },
+{ INT64_C(0xefffffdffffffffb), -0x1.000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002000000006), 0x1.000002p+60, 0x1.8p+2 },
+{ INT64_C(0xefffffdffffffff9), -0x1.000002p+60, -0x1.cp+2 },
+{ INT64_C(0x1000002000000008), 0x1.000002p+60, 0x1p+3 },
+{ INT64_C(0xefffffdffffffff7), -0x1.000002p+60, -0x1.2p+3 },
+{ INT64_C(0x100000200000000c), 0x1.000002p+60, 0x1.8p+3 },
+{ INT64_C(0xefffffdffffffff3), -0x1.000002p+60, -0x1.ap+3 },
+{ INT64_C(0x1000002000000080), 0x1.000002p+60, 0x1p+7 },
+{ INT64_C(0xefffffdfffffff7f), -0x1.0000020000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000002000000088), 0x1.0000020000001p+60, -0x1.ep+6 },
+{ INT64_C(0xefffffdfffffff77), -0x1.0000020000001p+60, 0x1.dcp+6 },
+{ INT64_C(0x1000002000000090), 0x1.0000020000001p+60, -0x1.cp+6 },
+{ INT64_C(0xefffffdfffffff6f), -0x1.0000020000001p+60, 0x1.bcp+6 },
+{ INT64_C(0x1000002000000200), 0x1.0000020000002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffffdff), -0x1.0000020000002p+60, -0x1p+0 },
+{ INT64_C(0x1000002000000204), 0x1.0000020000002p+60, 0x1p+2 },
+{ INT64_C(0xefffffdffffffdfb), -0x1.0000020000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002000000210), 0x1.0000020000002p+60, 0x1p+4 },
+{ INT64_C(0xefffffdffffffdef), -0x1.0000020000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1000002000000240), 0x1.0000020000002p+60, 0x1p+6 },
+{ INT64_C(0xefffffdffffffdbf), -0x1.0000020000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000002000000400), 0x1.0000020000004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffffbff), -0x1.0000020000004p+60, -0x1p+0 },
+{ INT64_C(0x1000002000000404), 0x1.0000020000004p+60, 0x1p+2 },
+{ INT64_C(0xefffffdffffffbfb), -0x1.0000020000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002000000440), 0x1.0000020000004p+60, 0x1p+6 },
+{ INT64_C(0xefffffdffffffbbf), -0x1.0000020000004p+60, -0x1.04p+6 },
+{ INT64_C(0x1000002000000600), 0x1.0000020000006p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffff9ff), -0x1.0000020000006p+60, -0x1p+0 },
+{ INT64_C(0x1000002000001000), 0x1.000002000001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffffefff), -0x1.000002000001p+60, -0x1p+0 },
+{ INT64_C(0x1000002000001004), 0x1.000002000001p+60, 0x1p+2 },
+{ INT64_C(0xefffffdfffffeffb), -0x1.000002000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002000001010), 0x1.000002000001p+60, 0x1p+4 },
+{ INT64_C(0xefffffdfffffefef), -0x1.000002000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000002000001080), 0x1.000002000001p+60, 0x1p+7 },
+{ INT64_C(0xefffffdfffffef7f), -0x1.0000020000011p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000002000001400), 0x1.0000020000014p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffffebff), -0x1.0000020000014p+60, -0x1p+0 },
+{ INT64_C(0x1000002000008000), 0x1.000002000008p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffff7fff), -0x1.000002000008p+60, -0x1p+0 },
+{ INT64_C(0x1000002000008008), 0x1.000002000008p+60, 0x1p+3 },
+{ INT64_C(0xefffffdfffff7ff7), -0x1.000002000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1000002000008080), 0x1.000002000008p+60, 0x1p+7 },
+{ INT64_C(0xefffffdfffff7f7f), -0x1.0000020000081p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000002000008200), 0x1.0000020000082p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffff7dff), -0x1.0000020000082p+60, -0x1p+0 },
+{ INT64_C(0x1000002000008400), 0x1.0000020000084p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffff7bff), -0x1.0000020000084p+60, -0x1p+0 },
+{ INT64_C(0x1000002000009000), 0x1.000002000009p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffff6fff), -0x1.000002000009p+60, -0x1p+0 },
+{ INT64_C(0x100000200000a000), 0x1.00000200000ap+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffff5fff), -0x1.00000200000ap+60, -0x1p+0 },
+{ INT64_C(0x1000002000040000), 0x1.00000200004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffbffff), -0x1.00000200004p+60, -0x1p+0 },
+{ INT64_C(0x1000002000040002), 0x1.00000200004p+60, 0x1p+1 },
+{ INT64_C(0xefffffdffffbfffd), -0x1.00000200004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000002000040020), 0x1.00000200004p+60, 0x1p+5 },
+{ INT64_C(0xefffffdffffbffdf), -0x1.00000200004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000002000040100), 0x1.0000020000401p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffbfeff), -0x1.0000020000401p+60, -0x1p+0 },
+{ INT64_C(0x1000002000040200), 0x1.0000020000402p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffbfdff), -0x1.0000020000402p+60, -0x1p+0 },
+{ INT64_C(0x1000002000040800), 0x1.0000020000408p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffbf7ff), -0x1.0000020000408p+60, -0x1p+0 },
+{ INT64_C(0x1000002000042000), 0x1.000002000042p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffbdfff), -0x1.000002000042p+60, -0x1p+0 },
+{ INT64_C(0x1000002000050000), 0x1.00000200005p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffffaffff), -0x1.00000200005p+60, -0x1p+0 },
+{ INT64_C(0x1000002000100000), 0x1.0000020001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffefffff), -0x1.0000020001p+60, -0x1p+0 },
+{ INT64_C(0x1000002000100008), 0x1.0000020001p+60, 0x1p+3 },
+{ INT64_C(0xefffffdfffeffff7), -0x1.0000020001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000002000100020), 0x1.0000020001p+60, 0x1p+5 },
+{ INT64_C(0xefffffdfffefffdf), -0x1.0000020001p+60, -0x1.08p+5 },
+{ INT64_C(0x1000002000100100), 0x1.0000020001001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffeffeff), -0x1.0000020001001p+60, -0x1p+0 },
+{ INT64_C(0x1000002000101000), 0x1.000002000101p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffefefff), -0x1.000002000101p+60, -0x1p+0 },
+{ INT64_C(0x1000002000104000), 0x1.000002000104p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffefbfff), -0x1.000002000104p+60, -0x1p+0 },
+{ INT64_C(0x1000002000108000), 0x1.000002000108p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffef7fff), -0x1.000002000108p+60, -0x1p+0 },
+{ INT64_C(0x1000002000120000), 0x1.00000200012p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffedffff), -0x1.00000200012p+60, -0x1p+0 },
+{ INT64_C(0x1000002000140000), 0x1.00000200014p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffebffff), -0x1.00000200014p+60, -0x1p+0 },
+{ INT64_C(0x1000002000200000), 0x1.0000020002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffdfffff), -0x1.0000020002p+60, -0x1p+0 },
+{ INT64_C(0x1000002000200008), 0x1.0000020002p+60, 0x1p+3 },
+{ INT64_C(0xefffffdfffdffff7), -0x1.0000020002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000002000200080), 0x1.0000020002p+60, 0x1p+7 },
+{ INT64_C(0xefffffdfffdfff7f), -0x1.0000020002001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000002000200400), 0x1.0000020002004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffdffbff), -0x1.0000020002004p+60, -0x1p+0 },
+{ INT64_C(0x1000002000204000), 0x1.000002000204p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffdfbfff), -0x1.000002000204p+60, -0x1p+0 },
+{ INT64_C(0x1000002000208000), 0x1.000002000208p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffdf7fff), -0x1.000002000208p+60, -0x1p+0 },
+{ INT64_C(0x1000002000210000), 0x1.00000200021p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffdeffff), -0x1.00000200021p+60, -0x1p+0 },
+{ INT64_C(0x1000002000280000), 0x1.00000200028p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffd7ffff), -0x1.00000200028p+60, -0x1p+0 },
+{ INT64_C(0x1000002000300000), 0x1.0000020003p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfffcfffff), -0x1.0000020003p+60, -0x1p+0 },
+{ INT64_C(0x1000002002000000), 0x1.000002002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffdffffff), -0x1.000002002p+60, -0x1p+0 },
+{ INT64_C(0x1000002002000004), 0x1.000002002p+60, 0x1p+2 },
+{ INT64_C(0xefffffdffdfffffb), -0x1.000002002p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002002000020), 0x1.000002002p+60, 0x1p+5 },
+{ INT64_C(0xefffffdffdffffdf), -0x1.000002002p+60, -0x1.08p+5 },
+{ INT64_C(0x1000002002000100), 0x1.0000020020001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffdfffeff), -0x1.0000020020001p+60, -0x1p+0 },
+{ INT64_C(0x1000002002000400), 0x1.0000020020004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffdfffbff), -0x1.0000020020004p+60, -0x1p+0 },
+{ INT64_C(0x1000002002002000), 0x1.000002002002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffdffdfff), -0x1.000002002002p+60, -0x1p+0 },
+{ INT64_C(0x1000002002020000), 0x1.00000200202p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffdfdffff), -0x1.00000200202p+60, -0x1p+0 },
+{ INT64_C(0x1000002002200000), 0x1.0000020022p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffddfffff), -0x1.0000020022p+60, -0x1p+0 },
+{ INT64_C(0x1000002002800000), 0x1.0000020028p+60, 0x0p+0 },
+{ INT64_C(0xefffffdffd7fffff), -0x1.0000020028p+60, -0x1p+0 },
+{ INT64_C(0x1000002020000000), 0x1.00000202p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdfffffff), -0x1.00000202p+60, -0x1p+0 },
+{ INT64_C(0x1000002020000001), 0x1.00000202p+60, 0x1p+0 },
+{ INT64_C(0xefffffdfdffffffe), -0x1.00000202p+60, -0x1p+1 },
+{ INT64_C(0x1000002020000004), 0x1.00000202p+60, 0x1p+2 },
+{ INT64_C(0xefffffdfdffffffb), -0x1.00000202p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002020000010), 0x1.00000202p+60, 0x1p+4 },
+{ INT64_C(0xefffffdfdfffffef), -0x1.00000202p+60, -0x1.1p+4 },
+{ INT64_C(0x1000002020000020), 0x1.00000202p+60, 0x1p+5 },
+{ INT64_C(0xefffffdfdfffffdf), -0x1.00000202p+60, -0x1.08p+5 },
+{ INT64_C(0x1000002020000100), 0x1.0000020200001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdffffeff), -0x1.0000020200001p+60, -0x1p+0 },
+{ INT64_C(0x1000002020000800), 0x1.0000020200008p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdffff7ff), -0x1.0000020200008p+60, -0x1p+0 },
+{ INT64_C(0x1000002020001000), 0x1.000002020001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdfffefff), -0x1.000002020001p+60, -0x1p+0 },
+{ INT64_C(0x1000002020002000), 0x1.000002020002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdfffdfff), -0x1.000002020002p+60, -0x1p+0 },
+{ INT64_C(0x1000002020008000), 0x1.000002020008p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdfff7fff), -0x1.000002020008p+60, -0x1p+0 },
+{ INT64_C(0x1000002020040000), 0x1.00000202004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdffbffff), -0x1.00000202004p+60, -0x1p+0 },
+{ INT64_C(0x1000002020400000), 0x1.0000020204p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdfbfffff), -0x1.0000020204p+60, -0x1p+0 },
+{ INT64_C(0x1000002021000000), 0x1.000002021p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfdeffffff), -0x1.000002021p+60, -0x1p+0 },
+{ INT64_C(0x1000002030000000), 0x1.00000203p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfcfffffff), -0x1.00000203p+60, -0x1p+0 },
+{ INT64_C(0x1000002040000000), 0x1.00000204p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbfffffff), -0x1.00000204p+60, -0x1p+0 },
+{ INT64_C(0x1000002040000002), 0x1.00000204p+60, 0x1p+1 },
+{ INT64_C(0xefffffdfbffffffd), -0x1.00000204p+60, -0x1.8p+1 },
+{ INT64_C(0x1000002040000008), 0x1.00000204p+60, 0x1p+3 },
+{ INT64_C(0xefffffdfbffffff7), -0x1.00000204p+60, -0x1.2p+3 },
+{ INT64_C(0x1000002040000020), 0x1.00000204p+60, 0x1p+5 },
+{ INT64_C(0xefffffdfbfffffdf), -0x1.00000204p+60, -0x1.08p+5 },
+{ INT64_C(0x1000002040000200), 0x1.0000020400002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbffffdff), -0x1.0000020400002p+60, -0x1p+0 },
+{ INT64_C(0x1000002040001000), 0x1.000002040001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbfffefff), -0x1.000002040001p+60, -0x1p+0 },
+{ INT64_C(0x1000002040002000), 0x1.000002040002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbfffdfff), -0x1.000002040002p+60, -0x1p+0 },
+{ INT64_C(0x1000002040004000), 0x1.000002040004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbfffbfff), -0x1.000002040004p+60, -0x1p+0 },
+{ INT64_C(0x1000002040008000), 0x1.000002040008p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbfff7fff), -0x1.000002040008p+60, -0x1p+0 },
+{ INT64_C(0x1000002040020000), 0x1.00000204002p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbffdffff), -0x1.00000204002p+60, -0x1p+0 },
+{ INT64_C(0x1000002040200000), 0x1.0000020402p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbfdfffff), -0x1.0000020402p+60, -0x1p+0 },
+{ INT64_C(0x1000002042000000), 0x1.000002042p+60, 0x0p+0 },
+{ INT64_C(0xefffffdfbdffffff), -0x1.000002042p+60, -0x1p+0 },
+{ INT64_C(0x1000002060000000), 0x1.00000206p+60, 0x0p+0 },
+{ INT64_C(0xefffffdf9fffffff), -0x1.00000206p+60, -0x1p+0 },
+{ INT64_C(0x1000002400000000), 0x1.0000024p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbffffffff), -0x1.0000024p+60, -0x1p+0 },
+{ INT64_C(0x1000002400000002), 0x1.0000024p+60, 0x1p+1 },
+{ INT64_C(0xefffffdbfffffffd), -0x1.0000024p+60, -0x1.8p+1 },
+{ INT64_C(0x1000002400000004), 0x1.0000024p+60, 0x1p+2 },
+{ INT64_C(0xefffffdbfffffffb), -0x1.0000024p+60, -0x1.4p+2 },
+{ INT64_C(0x1000002400000010), 0x1.0000024p+60, 0x1p+4 },
+{ INT64_C(0xefffffdbffffffef), -0x1.0000024p+60, -0x1.1p+4 },
+{ INT64_C(0x1000002400000100), 0x1.0000024000001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbfffffeff), -0x1.0000024000001p+60, -0x1p+0 },
+{ INT64_C(0x1000002400001000), 0x1.000002400001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbffffefff), -0x1.000002400001p+60, -0x1p+0 },
+{ INT64_C(0x1000002400004000), 0x1.000002400004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbffffbfff), -0x1.000002400004p+60, -0x1p+0 },
+{ INT64_C(0x1000002400008000), 0x1.000002400008p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbffff7fff), -0x1.000002400008p+60, -0x1p+0 },
+{ INT64_C(0x1000002400040000), 0x1.00000240004p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbfffbffff), -0x1.00000240004p+60, -0x1p+0 },
+{ INT64_C(0x1000002400100000), 0x1.0000024001p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbffefffff), -0x1.0000024001p+60, -0x1p+0 },
+{ INT64_C(0x1000002400800000), 0x1.0000024008p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbff7fffff), -0x1.0000024008p+60, -0x1p+0 },
+{ INT64_C(0x1000002408000000), 0x1.000002408p+60, 0x0p+0 },
+{ INT64_C(0xefffffdbf7ffffff), -0x1.000002408p+60, -0x1p+0 },
+{ INT64_C(0x1000002480000000), 0x1.00000248p+60, 0x0p+0 },
+{ INT64_C(0xefffffdb7fffffff), -0x1.00000248p+60, -0x1p+0 },
+{ INT64_C(0x1000003000000000), 0x1.000003p+60, 0x0p+0 },
+{ INT64_C(0xefffffcfffffffff), -0x1.000003p+60, -0x1p+0 },
+{ INT64_C(0x1000003000000004), 0x1.000003p+60, 0x1p+2 },
+{ INT64_C(0xefffffcffffffffb), -0x1.000003p+60, -0x1.4p+2 },
+{ INT64_C(0x1000003000000008), 0x1.000003p+60, 0x1p+3 },
+{ INT64_C(0xefffffcffffffff7), -0x1.000003p+60, -0x1.2p+3 },
+{ INT64_C(0x1000003000000020), 0x1.000003p+60, 0x1p+5 },
+{ INT64_C(0xefffffcfffffffdf), -0x1.000003p+60, -0x1.08p+5 },
+{ INT64_C(0x1000003000000200), 0x1.0000030000002p+60, 0x0p+0 },
+{ INT64_C(0xefffffcffffffdff), -0x1.0000030000002p+60, -0x1p+0 },
+{ INT64_C(0x1000003000000800), 0x1.0000030000008p+60, 0x0p+0 },
+{ INT64_C(0xefffffcffffff7ff), -0x1.0000030000008p+60, -0x1p+0 },
+{ INT64_C(0x1000003000004000), 0x1.000003000004p+60, 0x0p+0 },
+{ INT64_C(0xefffffcfffffbfff), -0x1.000003000004p+60, -0x1p+0 },
+{ INT64_C(0x1000003000010000), 0x1.00000300001p+60, 0x0p+0 },
+{ INT64_C(0xefffffcffffeffff), -0x1.00000300001p+60, -0x1p+0 },
+{ INT64_C(0x1000003000040000), 0x1.00000300004p+60, 0x0p+0 },
+{ INT64_C(0xefffffcffffbffff), -0x1.00000300004p+60, -0x1p+0 },
+{ INT64_C(0x1000003000100000), 0x1.0000030001p+60, 0x0p+0 },
+{ INT64_C(0xefffffcfffefffff), -0x1.0000030001p+60, -0x1p+0 },
+{ INT64_C(0x1000003001000000), 0x1.000003001p+60, 0x0p+0 },
+{ INT64_C(0xefffffcffeffffff), -0x1.000003001p+60, -0x1p+0 },
+{ INT64_C(0x1000003010000000), 0x1.00000301p+60, 0x0p+0 },
+{ INT64_C(0xefffffcfefffffff), -0x1.00000301p+60, -0x1p+0 },
+{ INT64_C(0x1000003040000000), 0x1.00000304p+60, 0x0p+0 },
+{ INT64_C(0xefffffcfbfffffff), -0x1.00000304p+60, -0x1p+0 },
+{ INT64_C(0x1000003080000000), 0x1.00000308p+60, 0x0p+0 },
+{ INT64_C(0xefffffcf7fffffff), -0x1.00000308p+60, -0x1p+0 },
+{ INT64_C(0x1000003100000000), 0x1.0000031p+60, 0x0p+0 },
+{ INT64_C(0xefffffceffffffff), -0x1.0000031p+60, -0x1p+0 },
+{ INT64_C(0x1000003800000000), 0x1.0000038p+60, 0x0p+0 },
+{ INT64_C(0xefffffc7ffffffff), -0x1.0000038p+60, -0x1p+0 },
+{ INT64_C(0x1000020000000001), 0x1.00002p+60, 0x1p+0 },
+{ INT64_C(0xeffffdfffffffffe), -0x1.00002p+60, -0x1p+1 },
+{ INT64_C(0x1000020000000004), 0x1.00002p+60, 0x1p+2 },
+{ INT64_C(0xeffffdfffffffffb), -0x1.00002p+60, -0x1.4p+2 },
+{ INT64_C(0x1000020000000010), 0x1.00002p+60, 0x1p+4 },
+{ INT64_C(0xeffffdffffffffef), -0x1.00002p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020000000018), 0x1.00002p+60, 0x1.8p+4 },
+{ INT64_C(0xeffffdffffffffe7), -0x1.00002p+60, -0x1.9p+4 },
+{ INT64_C(0x1000020000000040), 0x1.00002p+60, 0x1p+6 },
+{ INT64_C(0xeffffdffffffffbf), -0x1.00002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000020000000044), 0x1.00002p+60, 0x1.1p+6 },
+{ INT64_C(0xeffffdffffffffbb), -0x1.00002p+60, -0x1.14p+6 },
+{ INT64_C(0x1000020000000080), 0x1.00002p+60, 0x1p+7 },
+{ INT64_C(0xeffffdffffffff7f), -0x1.0000200000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000020000000082), 0x1.0000200000001p+60, -0x1.f8p+6 },
+{ INT64_C(0xeffffdffffffff7d), -0x1.0000200000001p+60, 0x1.f4p+6 },
+{ INT64_C(0x1000020000000090), 0x1.0000200000001p+60, -0x1.cp+6 },
+{ INT64_C(0xeffffdffffffff6f), -0x1.0000200000001p+60, 0x1.bcp+6 },
+{ INT64_C(0x10000200000000c0), 0x1.0000200000001p+60, -0x1p+6 },
+{ INT64_C(0xeffffdffffffff3f), -0x1.0000200000001p+60, 0x1.f8p+5 },
+{ INT64_C(0x1000020000000800), 0x1.0000200000008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffffff7ff), -0x1.0000200000008p+60, -0x1p+0 },
+{ INT64_C(0x1000020000000802), 0x1.0000200000008p+60, 0x1p+1 },
+{ INT64_C(0xeffffdfffffff7fd), -0x1.0000200000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1000020000000820), 0x1.0000200000008p+60, 0x1p+5 },
+{ INT64_C(0xeffffdfffffff7df), -0x1.0000200000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000020000000840), 0x1.0000200000008p+60, 0x1p+6 },
+{ INT64_C(0xeffffdfffffff7bf), -0x1.0000200000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1000020000000900), 0x1.0000200000009p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffffff6ff), -0x1.0000200000009p+60, -0x1p+0 },
+{ INT64_C(0x1000020000008000), 0x1.000020000008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffffff7fff), -0x1.000020000008p+60, -0x1p+0 },
+{ INT64_C(0x1000020000008004), 0x1.000020000008p+60, 0x1p+2 },
+{ INT64_C(0xeffffdffffff7ffb), -0x1.000020000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000020000008020), 0x1.000020000008p+60, 0x1p+5 },
+{ INT64_C(0xeffffdffffff7fdf), -0x1.000020000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000020000008100), 0x1.0000200000081p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffffff7eff), -0x1.0000200000081p+60, -0x1p+0 },
+{ INT64_C(0x1000020000009000), 0x1.000020000009p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffffff6fff), -0x1.000020000009p+60, -0x1p+0 },
+{ INT64_C(0x1000020000040000), 0x1.00002000004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffffbffff), -0x1.00002000004p+60, -0x1p+0 },
+{ INT64_C(0x1000020000040002), 0x1.00002000004p+60, 0x1p+1 },
+{ INT64_C(0xeffffdfffffbfffd), -0x1.00002000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000020000040020), 0x1.00002000004p+60, 0x1p+5 },
+{ INT64_C(0xeffffdfffffbffdf), -0x1.00002000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000020000040100), 0x1.0000200000401p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffffbfeff), -0x1.0000200000401p+60, -0x1p+0 },
+{ INT64_C(0x1000020000041000), 0x1.000020000041p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffffbefff), -0x1.000020000041p+60, -0x1p+0 },
+{ INT64_C(0x1000020000050000), 0x1.00002000005p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffffaffff), -0x1.00002000005p+60, -0x1p+0 },
+{ INT64_C(0x1000020000080000), 0x1.00002000008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffff7ffff), -0x1.00002000008p+60, -0x1p+0 },
+{ INT64_C(0x1000020000080001), 0x1.00002000008p+60, 0x1p+0 },
+{ INT64_C(0xeffffdfffff7fffe), -0x1.00002000008p+60, -0x1p+1 },
+{ INT64_C(0x1000020000080008), 0x1.00002000008p+60, 0x1p+3 },
+{ INT64_C(0xeffffdfffff7fff7), -0x1.00002000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1000020000080010), 0x1.00002000008p+60, 0x1p+4 },
+{ INT64_C(0xeffffdfffff7ffef), -0x1.00002000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020000080080), 0x1.00002000008p+60, 0x1p+7 },
+{ INT64_C(0xeffffdfffff7ff7f), -0x1.0000200000801p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000020000080100), 0x1.0000200000801p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffff7feff), -0x1.0000200000801p+60, -0x1p+0 },
+{ INT64_C(0x1000020000080800), 0x1.0000200000808p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffff7f7ff), -0x1.0000200000808p+60, -0x1p+0 },
+{ INT64_C(0x1000020000088000), 0x1.000020000088p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfffff77fff), -0x1.000020000088p+60, -0x1p+0 },
+{ INT64_C(0x1000020000800000), 0x1.0000200008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffff7fffff), -0x1.0000200008p+60, -0x1p+0 },
+{ INT64_C(0x1000020000800004), 0x1.0000200008p+60, 0x1p+2 },
+{ INT64_C(0xeffffdffff7ffffb), -0x1.0000200008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000020000800010), 0x1.0000200008p+60, 0x1p+4 },
+{ INT64_C(0xeffffdffff7fffef), -0x1.0000200008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020000800080), 0x1.0000200008p+60, 0x1p+7 },
+{ INT64_C(0xeffffdffff7fff7f), -0x1.0000200008001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000020000800800), 0x1.0000200008008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffff7ff7ff), -0x1.0000200008008p+60, -0x1p+0 },
+{ INT64_C(0x1000020000808000), 0x1.000020000808p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffff7f7fff), -0x1.000020000808p+60, -0x1p+0 },
+{ INT64_C(0x1000020000840000), 0x1.00002000084p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffff7bffff), -0x1.00002000084p+60, -0x1p+0 },
+{ INT64_C(0x1000020000880000), 0x1.00002000088p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffff77ffff), -0x1.00002000088p+60, -0x1p+0 },
+{ INT64_C(0x1000020000c00000), 0x1.000020000cp+60, 0x0p+0 },
+{ INT64_C(0xeffffdffff3fffff), -0x1.000020000cp+60, -0x1p+0 },
+{ INT64_C(0x1000020008000000), 0x1.000020008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7ffffff), -0x1.000020008p+60, -0x1p+0 },
+{ INT64_C(0x1000020008000002), 0x1.000020008p+60, 0x1p+1 },
+{ INT64_C(0xeffffdfff7fffffd), -0x1.000020008p+60, -0x1.8p+1 },
+{ INT64_C(0x1000020008000010), 0x1.000020008p+60, 0x1p+4 },
+{ INT64_C(0xeffffdfff7ffffef), -0x1.000020008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020008000080), 0x1.000020008p+60, 0x1p+7 },
+{ INT64_C(0xeffffdfff7ffff7f), -0x1.0000200080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000020008000200), 0x1.0000200080002p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7fffdff), -0x1.0000200080002p+60, -0x1p+0 },
+{ INT64_C(0x1000020008000400), 0x1.0000200080004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7fffbff), -0x1.0000200080004p+60, -0x1p+0 },
+{ INT64_C(0x1000020008001000), 0x1.000020008001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7ffefff), -0x1.000020008001p+60, -0x1p+0 },
+{ INT64_C(0x1000020008004000), 0x1.000020008004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7ffbfff), -0x1.000020008004p+60, -0x1p+0 },
+{ INT64_C(0x1000020008020000), 0x1.00002000802p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7fdffff), -0x1.00002000802p+60, -0x1p+0 },
+{ INT64_C(0x1000020008100000), 0x1.0000200081p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff7efffff), -0x1.0000200081p+60, -0x1p+0 },
+{ INT64_C(0x1000020009000000), 0x1.000020009p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfff6ffffff), -0x1.000020009p+60, -0x1p+0 },
+{ INT64_C(0x1000020010000000), 0x1.00002001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffefffffff), -0x1.00002001p+60, -0x1p+0 },
+{ INT64_C(0x1000020010000001), 0x1.00002001p+60, 0x1p+0 },
+{ INT64_C(0xeffffdffeffffffe), -0x1.00002001p+60, -0x1p+1 },
+{ INT64_C(0x1000020010000008), 0x1.00002001p+60, 0x1p+3 },
+{ INT64_C(0xeffffdffeffffff7), -0x1.00002001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000020010000010), 0x1.00002001p+60, 0x1p+4 },
+{ INT64_C(0xeffffdffefffffef), -0x1.00002001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020010000100), 0x1.0000200100001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffeffffeff), -0x1.0000200100001p+60, -0x1p+0 },
+{ INT64_C(0x1000020010000200), 0x1.0000200100002p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffeffffdff), -0x1.0000200100002p+60, -0x1p+0 },
+{ INT64_C(0x1000020010000800), 0x1.0000200100008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffeffff7ff), -0x1.0000200100008p+60, -0x1p+0 },
+{ INT64_C(0x1000020010008000), 0x1.000020010008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffefff7fff), -0x1.000020010008p+60, -0x1p+0 },
+{ INT64_C(0x1000020010080000), 0x1.00002001008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffeff7ffff), -0x1.00002001008p+60, -0x1p+0 },
+{ INT64_C(0x1000020010800000), 0x1.0000200108p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffef7fffff), -0x1.0000200108p+60, -0x1p+0 },
+{ INT64_C(0x1000020014000000), 0x1.000020014p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffebffffff), -0x1.000020014p+60, -0x1p+0 },
+{ INT64_C(0x1000020040000000), 0x1.00002004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbfffffff), -0x1.00002004p+60, -0x1p+0 },
+{ INT64_C(0x1000020040000002), 0x1.00002004p+60, 0x1p+1 },
+{ INT64_C(0xeffffdffbffffffd), -0x1.00002004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000020040000010), 0x1.00002004p+60, 0x1p+4 },
+{ INT64_C(0xeffffdffbfffffef), -0x1.00002004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020040000080), 0x1.00002004p+60, 0x1p+7 },
+{ INT64_C(0xeffffdffbfffff7f), -0x1.0000200400001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000020040000100), 0x1.0000200400001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbffffeff), -0x1.0000200400001p+60, -0x1p+0 },
+{ INT64_C(0x1000020040000200), 0x1.0000200400002p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbffffdff), -0x1.0000200400002p+60, -0x1p+0 },
+{ INT64_C(0x1000020040001000), 0x1.000020040001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbfffefff), -0x1.000020040001p+60, -0x1p+0 },
+{ INT64_C(0x1000020040008000), 0x1.000020040008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbfff7fff), -0x1.000020040008p+60, -0x1p+0 },
+{ INT64_C(0x1000020040040000), 0x1.00002004004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbffbffff), -0x1.00002004004p+60, -0x1p+0 },
+{ INT64_C(0x1000020040400000), 0x1.0000200404p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbfbfffff), -0x1.0000200404p+60, -0x1p+0 },
+{ INT64_C(0x1000020040800000), 0x1.0000200408p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbf7fffff), -0x1.0000200408p+60, -0x1p+0 },
+{ INT64_C(0x1000020041000000), 0x1.000020041p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbeffffff), -0x1.000020041p+60, -0x1p+0 },
+{ INT64_C(0x1000020044000000), 0x1.000020044p+60, 0x0p+0 },
+{ INT64_C(0xeffffdffbbffffff), -0x1.000020044p+60, -0x1p+0 },
+{ INT64_C(0x1000020060000000), 0x1.00002006p+60, 0x0p+0 },
+{ INT64_C(0xeffffdff9fffffff), -0x1.00002006p+60, -0x1p+0 },
+{ INT64_C(0x1000020100000000), 0x1.0000201p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfeffffffff), -0x1.0000201p+60, -0x1p+0 },
+{ INT64_C(0x1000020100000002), 0x1.0000201p+60, 0x1p+1 },
+{ INT64_C(0xeffffdfefffffffd), -0x1.0000201p+60, -0x1.8p+1 },
+{ INT64_C(0x1000020100000004), 0x1.0000201p+60, 0x1p+2 },
+{ INT64_C(0xeffffdfefffffffb), -0x1.0000201p+60, -0x1.4p+2 },
+{ INT64_C(0x1000020100000020), 0x1.0000201p+60, 0x1p+5 },
+{ INT64_C(0xeffffdfeffffffdf), -0x1.0000201p+60, -0x1.08p+5 },
+{ INT64_C(0x1000020100000100), 0x1.0000201000001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfefffffeff), -0x1.0000201000001p+60, -0x1p+0 },
+{ INT64_C(0x1000020100000200), 0x1.0000201000002p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfefffffdff), -0x1.0000201000002p+60, -0x1p+0 },
+{ INT64_C(0x1000020100001000), 0x1.000020100001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfeffffefff), -0x1.000020100001p+60, -0x1p+0 },
+{ INT64_C(0x1000020100008000), 0x1.000020100008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfeffff7fff), -0x1.000020100008p+60, -0x1p+0 },
+{ INT64_C(0x1000020100080000), 0x1.00002010008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfefff7ffff), -0x1.00002010008p+60, -0x1p+0 },
+{ INT64_C(0x1000020100100000), 0x1.0000201001p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfeffefffff), -0x1.0000201001p+60, -0x1p+0 },
+{ INT64_C(0x1000020100400000), 0x1.0000201004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfeffbfffff), -0x1.0000201004p+60, -0x1p+0 },
+{ INT64_C(0x1000020104000000), 0x1.000020104p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfefbffffff), -0x1.000020104p+60, -0x1p+0 },
+{ INT64_C(0x1000020108000000), 0x1.000020108p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfef7ffffff), -0x1.000020108p+60, -0x1p+0 },
+{ INT64_C(0x1000020140000000), 0x1.00002014p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfebfffffff), -0x1.00002014p+60, -0x1p+0 },
+{ INT64_C(0x1000020180000000), 0x1.00002018p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfe7fffffff), -0x1.00002018p+60, -0x1p+0 },
+{ INT64_C(0x1000020400000000), 0x1.0000204p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbffffffff), -0x1.0000204p+60, -0x1p+0 },
+{ INT64_C(0x1000020400000002), 0x1.0000204p+60, 0x1p+1 },
+{ INT64_C(0xeffffdfbfffffffd), -0x1.0000204p+60, -0x1.8p+1 },
+{ INT64_C(0x1000020400000010), 0x1.0000204p+60, 0x1p+4 },
+{ INT64_C(0xeffffdfbffffffef), -0x1.0000204p+60, -0x1.1p+4 },
+{ INT64_C(0x1000020400000020), 0x1.0000204p+60, 0x1p+5 },
+{ INT64_C(0xeffffdfbffffffdf), -0x1.0000204p+60, -0x1.08p+5 },
+{ INT64_C(0x1000020400000080), 0x1.0000204p+60, 0x1p+7 },
+{ INT64_C(0xeffffdfbffffff7f), -0x1.0000204000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000020400000400), 0x1.0000204000004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbfffffbff), -0x1.0000204000004p+60, -0x1p+0 },
+{ INT64_C(0x1000020400004000), 0x1.000020400004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbffffbfff), -0x1.000020400004p+60, -0x1p+0 },
+{ INT64_C(0x1000020400020000), 0x1.00002040002p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbfffdffff), -0x1.00002040002p+60, -0x1p+0 },
+{ INT64_C(0x1000020400040000), 0x1.00002040004p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbfffbffff), -0x1.00002040004p+60, -0x1p+0 },
+{ INT64_C(0x1000020400200000), 0x1.0000204002p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbffdfffff), -0x1.0000204002p+60, -0x1p+0 },
+{ INT64_C(0x1000020400800000), 0x1.0000204008p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbff7fffff), -0x1.0000204008p+60, -0x1p+0 },
+{ INT64_C(0x1000020402000000), 0x1.000020402p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbfdffffff), -0x1.000020402p+60, -0x1p+0 },
+{ INT64_C(0x1000020420000000), 0x1.00002042p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbdfffffff), -0x1.00002042p+60, -0x1p+0 },
+{ INT64_C(0x1000020440000000), 0x1.00002044p+60, 0x0p+0 },
+{ INT64_C(0xeffffdfbbfffffff), -0x1.00002044p+60, -0x1p+0 },
+{ INT64_C(0x1000020600000000), 0x1.0000206p+60, 0x0p+0 },
+{ INT64_C(0xeffffdf9ffffffff), -0x1.0000206p+60, -0x1p+0 },
+{ INT64_C(0x1000022000000000), 0x1.000022p+60, 0x0p+0 },
+{ INT64_C(0xeffffddfffffffff), -0x1.000022p+60, -0x1p+0 },
+{ INT64_C(0x1000022000000008), 0x1.000022p+60, 0x1p+3 },
+{ INT64_C(0xeffffddffffffff7), -0x1.000022p+60, -0x1.2p+3 },
+{ INT64_C(0x1000022000000020), 0x1.000022p+60, 0x1p+5 },
+{ INT64_C(0xeffffddfffffffdf), -0x1.000022p+60, -0x1.08p+5 },
+{ INT64_C(0x1000022000000080), 0x1.000022p+60, 0x1p+7 },
+{ INT64_C(0xeffffddfffffff7f), -0x1.0000220000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000022000000200), 0x1.0000220000002p+60, 0x0p+0 },
+{ INT64_C(0xeffffddffffffdff), -0x1.0000220000002p+60, -0x1p+0 },
+{ INT64_C(0x1000022000000400), 0x1.0000220000004p+60, 0x0p+0 },
+{ INT64_C(0xeffffddffffffbff), -0x1.0000220000004p+60, -0x1p+0 },
+{ INT64_C(0x1000022000000800), 0x1.0000220000008p+60, 0x0p+0 },
+{ INT64_C(0xeffffddffffff7ff), -0x1.0000220000008p+60, -0x1p+0 },
+{ INT64_C(0x1000022000002000), 0x1.000022000002p+60, 0x0p+0 },
+{ INT64_C(0xeffffddfffffdfff), -0x1.000022000002p+60, -0x1p+0 },
+{ INT64_C(0x1000022000008000), 0x1.000022000008p+60, 0x0p+0 },
+{ INT64_C(0xeffffddfffff7fff), -0x1.000022000008p+60, -0x1p+0 },
+{ INT64_C(0x1000022000080000), 0x1.00002200008p+60, 0x0p+0 },
+{ INT64_C(0xeffffddffff7ffff), -0x1.00002200008p+60, -0x1p+0 },
+{ INT64_C(0x1000022000200000), 0x1.0000220002p+60, 0x0p+0 },
+{ INT64_C(0xeffffddfffdfffff), -0x1.0000220002p+60, -0x1p+0 },
+{ INT64_C(0x1000022000800000), 0x1.0000220008p+60, 0x0p+0 },
+{ INT64_C(0xeffffddfff7fffff), -0x1.0000220008p+60, -0x1p+0 },
+{ INT64_C(0x1000022002000000), 0x1.000022002p+60, 0x0p+0 },
+{ INT64_C(0xeffffddffdffffff), -0x1.000022002p+60, -0x1p+0 },
+{ INT64_C(0x1000022008000000), 0x1.000022008p+60, 0x0p+0 },
+{ INT64_C(0xeffffddff7ffffff), -0x1.000022008p+60, -0x1p+0 },
+{ INT64_C(0x1000022010000000), 0x1.00002201p+60, 0x0p+0 },
+{ INT64_C(0xeffffddfefffffff), -0x1.00002201p+60, -0x1p+0 },
+{ INT64_C(0x1000022080000000), 0x1.00002208p+60, 0x0p+0 },
+{ INT64_C(0xeffffddf7fffffff), -0x1.00002208p+60, -0x1p+0 },
+{ INT64_C(0x1000022800000000), 0x1.0000228p+60, 0x0p+0 },
+{ INT64_C(0xeffffdd7ffffffff), -0x1.0000228p+60, -0x1p+0 },
+{ INT64_C(0x1000023000000000), 0x1.000023p+60, 0x0p+0 },
+{ INT64_C(0xeffffdcfffffffff), -0x1.000023p+60, -0x1p+0 },
+{ INT64_C(0x1000028000000000), 0x1.000028p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7fffffffff), -0x1.000028p+60, -0x1p+0 },
+{ INT64_C(0x1000028000000004), 0x1.000028p+60, 0x1p+2 },
+{ INT64_C(0xeffffd7ffffffffb), -0x1.000028p+60, -0x1.4p+2 },
+{ INT64_C(0x1000028000000008), 0x1.000028p+60, 0x1p+3 },
+{ INT64_C(0xeffffd7ffffffff7), -0x1.000028p+60, -0x1.2p+3 },
+{ INT64_C(0x1000028000000040), 0x1.000028p+60, 0x1p+6 },
+{ INT64_C(0xeffffd7fffffffbf), -0x1.000028p+60, -0x1.04p+6 },
+{ INT64_C(0x1000028000000400), 0x1.0000280000004p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7ffffffbff), -0x1.0000280000004p+60, -0x1p+0 },
+{ INT64_C(0x1000028000002000), 0x1.000028000002p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7fffffdfff), -0x1.000028000002p+60, -0x1p+0 },
+{ INT64_C(0x1000028000010000), 0x1.00002800001p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7ffffeffff), -0x1.00002800001p+60, -0x1p+0 },
+{ INT64_C(0x1000028000080000), 0x1.00002800008p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7ffff7ffff), -0x1.00002800008p+60, -0x1p+0 },
+{ INT64_C(0x1000028000800000), 0x1.0000280008p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7fff7fffff), -0x1.0000280008p+60, -0x1p+0 },
+{ INT64_C(0x1000028002000000), 0x1.000028002p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7ffdffffff), -0x1.000028002p+60, -0x1p+0 },
+{ INT64_C(0x1000028004000000), 0x1.000028004p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7ffbffffff), -0x1.000028004p+60, -0x1p+0 },
+{ INT64_C(0x1000028010000000), 0x1.00002801p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7fefffffff), -0x1.00002801p+60, -0x1p+0 },
+{ INT64_C(0x1000028020000000), 0x1.00002802p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7fdfffffff), -0x1.00002802p+60, -0x1p+0 },
+{ INT64_C(0x1000028100000000), 0x1.0000281p+60, 0x0p+0 },
+{ INT64_C(0xeffffd7effffffff), -0x1.0000281p+60, -0x1p+0 },
+{ INT64_C(0x1000029000000000), 0x1.000029p+60, 0x0p+0 },
+{ INT64_C(0xeffffd6fffffffff), -0x1.000029p+60, -0x1p+0 },
+{ INT64_C(0x1000080000000004), 0x1.00008p+60, 0x1p+2 },
+{ INT64_C(0xeffff7fffffffffb), -0x1.00008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000080000000006), 0x1.00008p+60, 0x1.8p+2 },
+{ INT64_C(0xeffff7fffffffff9), -0x1.00008p+60, -0x1.cp+2 },
+{ INT64_C(0x1000080000000010), 0x1.00008p+60, 0x1p+4 },
+{ INT64_C(0xeffff7ffffffffef), -0x1.00008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080000000014), 0x1.00008p+60, 0x1.4p+4 },
+{ INT64_C(0xeffff7ffffffffeb), -0x1.00008p+60, -0x1.5p+4 },
+{ INT64_C(0x1000080000000018), 0x1.00008p+60, 0x1.8p+4 },
+{ INT64_C(0xeffff7ffffffffe7), -0x1.00008p+60, -0x1.9p+4 },
+{ INT64_C(0x1000080000000020), 0x1.00008p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffffffffdf), -0x1.00008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000000021), 0x1.00008p+60, 0x1.08p+5 },
+{ INT64_C(0xeffff7ffffffffde), -0x1.00008p+60, -0x1.1p+5 },
+{ INT64_C(0x1000080000000028), 0x1.00008p+60, 0x1.4p+5 },
+{ INT64_C(0xeffff7ffffffffd7), -0x1.00008p+60, -0x1.48p+5 },
+{ INT64_C(0x1000080000000100), 0x1.0000800000001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffffeff), -0x1.0000800000001p+60, -0x1p+0 },
+{ INT64_C(0x1000080000000102), 0x1.0000800000001p+60, 0x1p+1 },
+{ INT64_C(0xeffff7fffffffefd), -0x1.0000800000001p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080000000104), 0x1.0000800000001p+60, 0x1p+2 },
+{ INT64_C(0xeffff7fffffffefb), -0x1.0000800000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000080000000108), 0x1.0000800000001p+60, 0x1p+3 },
+{ INT64_C(0xeffff7fffffffef7), -0x1.0000800000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080000000110), 0x1.0000800000001p+60, 0x1p+4 },
+{ INT64_C(0xeffff7fffffffeef), -0x1.0000800000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080000000180), 0x1.0000800000002p+60, -0x1p+7 },
+{ INT64_C(0xeffff7fffffffe7f), -0x1.0000800000002p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000080000000200), 0x1.0000800000002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffffdff), -0x1.0000800000002p+60, -0x1p+0 },
+{ INT64_C(0x1000080000000202), 0x1.0000800000002p+60, 0x1p+1 },
+{ INT64_C(0xeffff7fffffffdfd), -0x1.0000800000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080000000208), 0x1.0000800000002p+60, 0x1p+3 },
+{ INT64_C(0xeffff7fffffffdf7), -0x1.0000800000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080000000240), 0x1.0000800000002p+60, 0x1p+6 },
+{ INT64_C(0xeffff7fffffffdbf), -0x1.0000800000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080000000300), 0x1.0000800000003p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffffcff), -0x1.0000800000003p+60, -0x1p+0 },
+{ INT64_C(0x1000080000000800), 0x1.0000800000008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffff7ff), -0x1.0000800000008p+60, -0x1p+0 },
+{ INT64_C(0x1000080000000804), 0x1.0000800000008p+60, 0x1p+2 },
+{ INT64_C(0xeffff7fffffff7fb), -0x1.0000800000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000080000000810), 0x1.0000800000008p+60, 0x1p+4 },
+{ INT64_C(0xeffff7fffffff7ef), -0x1.0000800000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080000000820), 0x1.0000800000008p+60, 0x1p+5 },
+{ INT64_C(0xeffff7fffffff7df), -0x1.0000800000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000000a00), 0x1.000080000000ap+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffff5ff), -0x1.000080000000ap+60, -0x1p+0 },
+{ INT64_C(0x1000080000000c00), 0x1.000080000000cp+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffff3ff), -0x1.000080000000cp+60, -0x1p+0 },
+{ INT64_C(0x1000080000001000), 0x1.000080000001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffefff), -0x1.000080000001p+60, -0x1p+0 },
+{ INT64_C(0x1000080000001004), 0x1.000080000001p+60, 0x1p+2 },
+{ INT64_C(0xeffff7ffffffeffb), -0x1.000080000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000080000001010), 0x1.000080000001p+60, 0x1p+4 },
+{ INT64_C(0xeffff7ffffffefef), -0x1.000080000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080000001020), 0x1.000080000001p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffffffefdf), -0x1.000080000001p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000001100), 0x1.0000800000011p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffeeff), -0x1.0000800000011p+60, -0x1p+0 },
+{ INT64_C(0x1000080000001400), 0x1.0000800000014p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffebff), -0x1.0000800000014p+60, -0x1p+0 },
+{ INT64_C(0x1000080000001800), 0x1.0000800000018p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffe7ff), -0x1.0000800000018p+60, -0x1p+0 },
+{ INT64_C(0x1000080000004000), 0x1.000080000004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffbfff), -0x1.000080000004p+60, -0x1p+0 },
+{ INT64_C(0x1000080000004008), 0x1.000080000004p+60, 0x1p+3 },
+{ INT64_C(0xeffff7ffffffbff7), -0x1.000080000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080000004020), 0x1.000080000004p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffffffbfdf), -0x1.000080000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000004040), 0x1.000080000004p+60, 0x1p+6 },
+{ INT64_C(0xeffff7ffffffbfbf), -0x1.000080000004p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080000004100), 0x1.0000800000041p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffbeff), -0x1.0000800000041p+60, -0x1p+0 },
+{ INT64_C(0x1000080000004800), 0x1.0000800000048p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffffb7ff), -0x1.0000800000048p+60, -0x1p+0 },
+{ INT64_C(0x1000080000008000), 0x1.000080000008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffff7fff), -0x1.000080000008p+60, -0x1p+0 },
+{ INT64_C(0x1000080000008008), 0x1.000080000008p+60, 0x1p+3 },
+{ INT64_C(0xeffff7ffffff7ff7), -0x1.000080000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080000008040), 0x1.000080000008p+60, 0x1p+6 },
+{ INT64_C(0xeffff7ffffff7fbf), -0x1.000080000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080000008080), 0x1.000080000008p+60, 0x1p+7 },
+{ INT64_C(0xeffff7ffffff7f7f), -0x1.0000800000081p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000080000008100), 0x1.0000800000081p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffff7eff), -0x1.0000800000081p+60, -0x1p+0 },
+{ INT64_C(0x1000080000008800), 0x1.0000800000088p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffff77ff), -0x1.0000800000088p+60, -0x1p+0 },
+{ INT64_C(0x100008000000c000), 0x1.00008000000cp+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffff3fff), -0x1.00008000000cp+60, -0x1p+0 },
+{ INT64_C(0x1000080000020000), 0x1.00008000002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffdffff), -0x1.00008000002p+60, -0x1p+0 },
+{ INT64_C(0x1000080000020002), 0x1.00008000002p+60, 0x1p+1 },
+{ INT64_C(0xeffff7fffffdfffd), -0x1.00008000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080000020020), 0x1.00008000002p+60, 0x1p+5 },
+{ INT64_C(0xeffff7fffffdffdf), -0x1.00008000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000020100), 0x1.0000800000201p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffdfeff), -0x1.0000800000201p+60, -0x1p+0 },
+{ INT64_C(0x1000080000020800), 0x1.0000800000208p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffdf7ff), -0x1.0000800000208p+60, -0x1p+0 },
+{ INT64_C(0x1000080000028000), 0x1.000080000028p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffffd7fff), -0x1.000080000028p+60, -0x1p+0 },
+{ INT64_C(0x1000080000080000), 0x1.00008000008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffff7ffff), -0x1.00008000008p+60, -0x1p+0 },
+{ INT64_C(0x1000080000080004), 0x1.00008000008p+60, 0x1p+2 },
+{ INT64_C(0xeffff7fffff7fffb), -0x1.00008000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000080000080010), 0x1.00008000008p+60, 0x1p+4 },
+{ INT64_C(0xeffff7fffff7ffef), -0x1.00008000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080000080100), 0x1.0000800000801p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffff7feff), -0x1.0000800000801p+60, -0x1p+0 },
+{ INT64_C(0x1000080000080400), 0x1.0000800000804p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffff7fbff), -0x1.0000800000804p+60, -0x1p+0 },
+{ INT64_C(0x1000080000082000), 0x1.000080000082p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffff7dfff), -0x1.000080000082p+60, -0x1p+0 },
+{ INT64_C(0x1000080000088000), 0x1.000080000088p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffff77fff), -0x1.000080000088p+60, -0x1p+0 },
+{ INT64_C(0x1000080000090000), 0x1.00008000009p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffff6ffff), -0x1.00008000009p+60, -0x1p+0 },
+{ INT64_C(0x1000080000100000), 0x1.0000800001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffefffff), -0x1.0000800001p+60, -0x1p+0 },
+{ INT64_C(0x1000080000100001), 0x1.0000800001p+60, 0x1p+0 },
+{ INT64_C(0xeffff7ffffeffffe), -0x1.0000800001p+60, -0x1p+1 },
+{ INT64_C(0x1000080000100002), 0x1.0000800001p+60, 0x1p+1 },
+{ INT64_C(0xeffff7ffffeffffd), -0x1.0000800001p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080000100010), 0x1.0000800001p+60, 0x1p+4 },
+{ INT64_C(0xeffff7ffffefffef), -0x1.0000800001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080000100020), 0x1.0000800001p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffffefffdf), -0x1.0000800001p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000100200), 0x1.0000800001002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffeffdff), -0x1.0000800001002p+60, -0x1p+0 },
+{ INT64_C(0x1000080000100800), 0x1.0000800001008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffeff7ff), -0x1.0000800001008p+60, -0x1p+0 },
+{ INT64_C(0x1000080000108000), 0x1.000080000108p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffef7fff), -0x1.000080000108p+60, -0x1p+0 },
+{ INT64_C(0x1000080000110000), 0x1.00008000011p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffeeffff), -0x1.00008000011p+60, -0x1p+0 },
+{ INT64_C(0x1000080000120000), 0x1.00008000012p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffedffff), -0x1.00008000012p+60, -0x1p+0 },
+{ INT64_C(0x1000080000200000), 0x1.0000800002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffdfffff), -0x1.0000800002p+60, -0x1p+0 },
+{ INT64_C(0x1000080000200008), 0x1.0000800002p+60, 0x1p+3 },
+{ INT64_C(0xeffff7ffffdffff7), -0x1.0000800002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080000200020), 0x1.0000800002p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffffdfffdf), -0x1.0000800002p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080000200080), 0x1.0000800002p+60, 0x1p+7 },
+{ INT64_C(0xeffff7ffffdfff7f), -0x1.0000800002001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000080000200100), 0x1.0000800002001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffdffeff), -0x1.0000800002001p+60, -0x1p+0 },
+{ INT64_C(0x1000080000201000), 0x1.000080000201p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffdfefff), -0x1.000080000201p+60, -0x1p+0 },
+{ INT64_C(0x1000080000210000), 0x1.00008000021p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffdeffff), -0x1.00008000021p+60, -0x1p+0 },
+{ INT64_C(0x1000080000240000), 0x1.00008000024p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffdbffff), -0x1.00008000024p+60, -0x1p+0 },
+{ INT64_C(0x1000080000300000), 0x1.0000800003p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffffcfffff), -0x1.0000800003p+60, -0x1p+0 },
+{ INT64_C(0x1000080002000000), 0x1.000080002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffdffffff), -0x1.000080002p+60, -0x1p+0 },
+{ INT64_C(0x1000080002000008), 0x1.000080002p+60, 0x1p+3 },
+{ INT64_C(0xeffff7fffdfffff7), -0x1.000080002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080002000010), 0x1.000080002p+60, 0x1p+4 },
+{ INT64_C(0xeffff7fffdffffef), -0x1.000080002p+60, -0x1.1p+4 },
+{ INT64_C(0x1000080002000040), 0x1.000080002p+60, 0x1p+6 },
+{ INT64_C(0xeffff7fffdffffbf), -0x1.000080002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080002000200), 0x1.0000800020002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffdfffdff), -0x1.0000800020002p+60, -0x1p+0 },
+{ INT64_C(0x1000080002000800), 0x1.0000800020008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffdfff7ff), -0x1.0000800020008p+60, -0x1p+0 },
+{ INT64_C(0x1000080002002000), 0x1.000080002002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffdffdfff), -0x1.000080002002p+60, -0x1p+0 },
+{ INT64_C(0x1000080002020000), 0x1.00008000202p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffdfdffff), -0x1.00008000202p+60, -0x1p+0 },
+{ INT64_C(0x1000080002100000), 0x1.0000800021p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffdefffff), -0x1.0000800021p+60, -0x1p+0 },
+{ INT64_C(0x1000080003000000), 0x1.000080003p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fffcffffff), -0x1.000080003p+60, -0x1p+0 },
+{ INT64_C(0x1000080008000000), 0x1.000080008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7ffffff), -0x1.000080008p+60, -0x1p+0 },
+{ INT64_C(0x1000080008000002), 0x1.000080008p+60, 0x1p+1 },
+{ INT64_C(0xeffff7fff7fffffd), -0x1.000080008p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080008000004), 0x1.000080008p+60, 0x1p+2 },
+{ INT64_C(0xeffff7fff7fffffb), -0x1.000080008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000080008000040), 0x1.000080008p+60, 0x1p+6 },
+{ INT64_C(0xeffff7fff7ffffbf), -0x1.000080008p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080008000080), 0x1.000080008p+60, 0x1p+7 },
+{ INT64_C(0xeffff7fff7ffff7f), -0x1.0000800080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000080008000100), 0x1.0000800080001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7fffeff), -0x1.0000800080001p+60, -0x1p+0 },
+{ INT64_C(0x1000080008000200), 0x1.0000800080002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7fffdff), -0x1.0000800080002p+60, -0x1p+0 },
+{ INT64_C(0x1000080008000800), 0x1.0000800080008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7fff7ff), -0x1.0000800080008p+60, -0x1p+0 },
+{ INT64_C(0x1000080008002000), 0x1.000080008002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7ffdfff), -0x1.000080008002p+60, -0x1p+0 },
+{ INT64_C(0x1000080008004000), 0x1.000080008004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7ffbfff), -0x1.000080008004p+60, -0x1p+0 },
+{ INT64_C(0x1000080008040000), 0x1.00008000804p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7fbffff), -0x1.00008000804p+60, -0x1p+0 },
+{ INT64_C(0x1000080008400000), 0x1.0000800084p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff7bfffff), -0x1.0000800084p+60, -0x1p+0 },
+{ INT64_C(0x100008000a000000), 0x1.00008000ap+60, 0x0p+0 },
+{ INT64_C(0xeffff7fff5ffffff), -0x1.00008000ap+60, -0x1p+0 },
+{ INT64_C(0x1000080010000000), 0x1.00008001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffefffffff), -0x1.00008001p+60, -0x1p+0 },
+{ INT64_C(0x1000080010000002), 0x1.00008001p+60, 0x1p+1 },
+{ INT64_C(0xeffff7ffeffffffd), -0x1.00008001p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080010000020), 0x1.00008001p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffefffffdf), -0x1.00008001p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080010000040), 0x1.00008001p+60, 0x1p+6 },
+{ INT64_C(0xeffff7ffefffffbf), -0x1.00008001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080010000200), 0x1.0000800100002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffeffffdff), -0x1.0000800100002p+60, -0x1p+0 },
+{ INT64_C(0x1000080010000400), 0x1.0000800100004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffeffffbff), -0x1.0000800100004p+60, -0x1p+0 },
+{ INT64_C(0x1000080010004000), 0x1.000080010004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffefffbfff), -0x1.000080010004p+60, -0x1p+0 },
+{ INT64_C(0x1000080010040000), 0x1.00008001004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffeffbffff), -0x1.00008001004p+60, -0x1p+0 },
+{ INT64_C(0x1000080010080000), 0x1.00008001008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffeff7ffff), -0x1.00008001008p+60, -0x1p+0 },
+{ INT64_C(0x1000080010100000), 0x1.0000800101p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffefefffff), -0x1.0000800101p+60, -0x1p+0 },
+{ INT64_C(0x1000080010800000), 0x1.0000800108p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffef7fffff), -0x1.0000800108p+60, -0x1p+0 },
+{ INT64_C(0x1000080011000000), 0x1.000080011p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffeeffffff), -0x1.000080011p+60, -0x1p+0 },
+{ INT64_C(0x1000080040000000), 0x1.00008004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffbfffffff), -0x1.00008004p+60, -0x1p+0 },
+{ INT64_C(0x1000080040000008), 0x1.00008004p+60, 0x1p+3 },
+{ INT64_C(0xeffff7ffbffffff7), -0x1.00008004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080040000020), 0x1.00008004p+60, 0x1p+5 },
+{ INT64_C(0xeffff7ffbfffffdf), -0x1.00008004p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080040000080), 0x1.00008004p+60, 0x1p+7 },
+{ INT64_C(0xeffff7ffbfffff7f), -0x1.0000800400001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000080040000800), 0x1.0000800400008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffbffff7ff), -0x1.0000800400008p+60, -0x1p+0 },
+{ INT64_C(0x1000080040008000), 0x1.000080040008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffbfff7fff), -0x1.000080040008p+60, -0x1p+0 },
+{ INT64_C(0x1000080040080000), 0x1.00008004008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffbff7ffff), -0x1.00008004008p+60, -0x1p+0 },
+{ INT64_C(0x1000080040400000), 0x1.0000800404p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffbfbfffff), -0x1.0000800404p+60, -0x1p+0 },
+{ INT64_C(0x1000080040800000), 0x1.0000800408p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffbf7fffff), -0x1.0000800408p+60, -0x1p+0 },
+{ INT64_C(0x1000080048000000), 0x1.000080048p+60, 0x0p+0 },
+{ INT64_C(0xeffff7ffb7ffffff), -0x1.000080048p+60, -0x1p+0 },
+{ INT64_C(0x1000080100000000), 0x1.0000801p+60, 0x0p+0 },
+{ INT64_C(0xeffff7feffffffff), -0x1.0000801p+60, -0x1p+0 },
+{ INT64_C(0x1000080100000002), 0x1.0000801p+60, 0x1p+1 },
+{ INT64_C(0xeffff7fefffffffd), -0x1.0000801p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080100000020), 0x1.0000801p+60, 0x1p+5 },
+{ INT64_C(0xeffff7feffffffdf), -0x1.0000801p+60, -0x1.08p+5 },
+{ INT64_C(0x1000080100000040), 0x1.0000801p+60, 0x1p+6 },
+{ INT64_C(0xeffff7feffffffbf), -0x1.0000801p+60, -0x1.04p+6 },
+{ INT64_C(0x1000080100000200), 0x1.0000801000002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fefffffdff), -0x1.0000801000002p+60, -0x1p+0 },
+{ INT64_C(0x1000080100000400), 0x1.0000801000004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fefffffbff), -0x1.0000801000004p+60, -0x1p+0 },
+{ INT64_C(0x1000080100001000), 0x1.000080100001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7feffffefff), -0x1.000080100001p+60, -0x1p+0 },
+{ INT64_C(0x1000080100004000), 0x1.000080100004p+60, 0x0p+0 },
+{ INT64_C(0xeffff7feffffbfff), -0x1.000080100004p+60, -0x1p+0 },
+{ INT64_C(0x1000080100010000), 0x1.00008010001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fefffeffff), -0x1.00008010001p+60, -0x1p+0 },
+{ INT64_C(0x1000080100100000), 0x1.0000801001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7feffefffff), -0x1.0000801001p+60, -0x1p+0 },
+{ INT64_C(0x1000080101000000), 0x1.000080101p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fefeffffff), -0x1.000080101p+60, -0x1p+0 },
+{ INT64_C(0x1000080110000000), 0x1.00008011p+60, 0x0p+0 },
+{ INT64_C(0xeffff7feefffffff), -0x1.00008011p+60, -0x1p+0 },
+{ INT64_C(0x1000080120000000), 0x1.00008012p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fedfffffff), -0x1.00008012p+60, -0x1p+0 },
+{ INT64_C(0x1000080180000000), 0x1.00008018p+60, 0x0p+0 },
+{ INT64_C(0xeffff7fe7fffffff), -0x1.00008018p+60, -0x1p+0 },
+{ INT64_C(0x1000080800000000), 0x1.0000808p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7ffffffff), -0x1.0000808p+60, -0x1p+0 },
+{ INT64_C(0x1000080800000002), 0x1.0000808p+60, 0x1p+1 },
+{ INT64_C(0xeffff7f7fffffffd), -0x1.0000808p+60, -0x1.8p+1 },
+{ INT64_C(0x1000080800000008), 0x1.0000808p+60, 0x1p+3 },
+{ INT64_C(0xeffff7f7fffffff7), -0x1.0000808p+60, -0x1.2p+3 },
+{ INT64_C(0x1000080800000080), 0x1.0000808p+60, 0x1p+7 },
+{ INT64_C(0xeffff7f7ffffff7f), -0x1.0000808000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000080800000800), 0x1.0000808000008p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7fffff7ff), -0x1.0000808000008p+60, -0x1p+0 },
+{ INT64_C(0x1000080800002000), 0x1.000080800002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7ffffdfff), -0x1.000080800002p+60, -0x1p+0 },
+{ INT64_C(0x1000080800020000), 0x1.00008080002p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7fffdffff), -0x1.00008080002p+60, -0x1p+0 },
+{ INT64_C(0x1000080800100000), 0x1.0000808001p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7ffefffff), -0x1.0000808001p+60, -0x1p+0 },
+{ INT64_C(0x1000080801000000), 0x1.000080801p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7feffffff), -0x1.000080801p+60, -0x1p+0 },
+{ INT64_C(0x1000080802000000), 0x1.000080802p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7fdffffff), -0x1.000080802p+60, -0x1p+0 },
+{ INT64_C(0x1000080810000000), 0x1.00008081p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7efffffff), -0x1.00008081p+60, -0x1p+0 },
+{ INT64_C(0x1000080820000000), 0x1.00008082p+60, 0x0p+0 },
+{ INT64_C(0xeffff7f7dfffffff), -0x1.00008082p+60, -0x1p+0 },
+{ INT64_C(0x1000080a00000000), 0x1.000080ap+60, 0x0p+0 },
+{ INT64_C(0xeffff7f5ffffffff), -0x1.000080ap+60, -0x1p+0 },
+{ INT64_C(0x1000088000000000), 0x1.000088p+60, 0x0p+0 },
+{ INT64_C(0xeffff77fffffffff), -0x1.000088p+60, -0x1p+0 },
+{ INT64_C(0x1000088000000001), 0x1.000088p+60, 0x1p+0 },
+{ INT64_C(0xeffff77ffffffffe), -0x1.000088p+60, -0x1p+1 },
+{ INT64_C(0x1000088000000010), 0x1.000088p+60, 0x1p+4 },
+{ INT64_C(0xeffff77fffffffef), -0x1.000088p+60, -0x1.1p+4 },
+{ INT64_C(0x1000088000000080), 0x1.000088p+60, 0x1p+7 },
+{ INT64_C(0xeffff77fffffff7f), -0x1.0000880000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000088000000400), 0x1.0000880000004p+60, 0x0p+0 },
+{ INT64_C(0xeffff77ffffffbff), -0x1.0000880000004p+60, -0x1p+0 },
+{ INT64_C(0x1000088000001000), 0x1.000088000001p+60, 0x0p+0 },
+{ INT64_C(0xeffff77fffffefff), -0x1.000088000001p+60, -0x1p+0 },
+{ INT64_C(0x1000088000008000), 0x1.000088000008p+60, 0x0p+0 },
+{ INT64_C(0xeffff77fffff7fff), -0x1.000088000008p+60, -0x1p+0 },
+{ INT64_C(0x1000088000010000), 0x1.00008800001p+60, 0x0p+0 },
+{ INT64_C(0xeffff77ffffeffff), -0x1.00008800001p+60, -0x1p+0 },
+{ INT64_C(0x1000088000040000), 0x1.00008800004p+60, 0x0p+0 },
+{ INT64_C(0xeffff77ffffbffff), -0x1.00008800004p+60, -0x1p+0 },
+{ INT64_C(0x1000088000100000), 0x1.0000880001p+60, 0x0p+0 },
+{ INT64_C(0xeffff77fffefffff), -0x1.0000880001p+60, -0x1p+0 },
+{ INT64_C(0x1000088001000000), 0x1.000088001p+60, 0x0p+0 },
+{ INT64_C(0xeffff77ffeffffff), -0x1.000088001p+60, -0x1p+0 },
+{ INT64_C(0x1000088004000000), 0x1.000088004p+60, 0x0p+0 },
+{ INT64_C(0xeffff77ffbffffff), -0x1.000088004p+60, -0x1p+0 },
+{ INT64_C(0x1000088008000000), 0x1.000088008p+60, 0x0p+0 },
+{ INT64_C(0xeffff77ff7ffffff), -0x1.000088008p+60, -0x1p+0 },
+{ INT64_C(0x1000088080000000), 0x1.00008808p+60, 0x0p+0 },
+{ INT64_C(0xeffff77f7fffffff), -0x1.00008808p+60, -0x1p+0 },
+{ INT64_C(0x1000088800000000), 0x1.0000888p+60, 0x0p+0 },
+{ INT64_C(0xeffff777ffffffff), -0x1.0000888p+60, -0x1p+0 },
+{ INT64_C(0x100008c000000000), 0x1.00008cp+60, 0x0p+0 },
+{ INT64_C(0xeffff73fffffffff), -0x1.00008cp+60, -0x1p+0 },
+{ INT64_C(0x1000800000000002), 0x1.0008p+60, 0x1p+1 },
+{ INT64_C(0xefff7ffffffffffd), -0x1.0008p+60, -0x1.8p+1 },
+{ INT64_C(0x1000800000000020), 0x1.0008p+60, 0x1p+5 },
+{ INT64_C(0xefff7fffffffffdf), -0x1.0008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000800000000021), 0x1.0008p+60, 0x1.08p+5 },
+{ INT64_C(0xefff7fffffffffde), -0x1.0008p+60, -0x1.1p+5 },
+{ INT64_C(0x1000800000000030), 0x1.0008p+60, 0x1.8p+5 },
+{ INT64_C(0xefff7fffffffffcf), -0x1.0008p+60, -0x1.88p+5 },
+{ INT64_C(0x1000800000000100), 0x1.0008000000001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffffeff), -0x1.0008000000001p+60, -0x1p+0 },
+{ INT64_C(0x1000800000000108), 0x1.0008000000001p+60, 0x1p+3 },
+{ INT64_C(0xefff7ffffffffef7), -0x1.0008000000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800000000140), 0x1.0008000000001p+60, 0x1p+6 },
+{ INT64_C(0xefff7ffffffffebf), -0x1.0008000000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800000000200), 0x1.0008000000002p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffffdff), -0x1.0008000000002p+60, -0x1p+0 },
+{ INT64_C(0x1000800000000208), 0x1.0008000000002p+60, 0x1p+3 },
+{ INT64_C(0xefff7ffffffffdf7), -0x1.0008000000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800000000220), 0x1.0008000000002p+60, 0x1p+5 },
+{ INT64_C(0xefff7ffffffffddf), -0x1.0008000000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1000800000000280), 0x1.0008000000002p+60, 0x1p+7 },
+{ INT64_C(0xefff7ffffffffd7f), -0x1.0008000000003p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800000000400), 0x1.0008000000004p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffffbff), -0x1.0008000000004p+60, -0x1p+0 },
+{ INT64_C(0x1000800000000402), 0x1.0008000000004p+60, 0x1p+1 },
+{ INT64_C(0xefff7ffffffffbfd), -0x1.0008000000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000800000000404), 0x1.0008000000004p+60, 0x1p+2 },
+{ INT64_C(0xefff7ffffffffbfb), -0x1.0008000000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800000000440), 0x1.0008000000004p+60, 0x1p+6 },
+{ INT64_C(0xefff7ffffffffbbf), -0x1.0008000000004p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800000000500), 0x1.0008000000005p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffffaff), -0x1.0008000000005p+60, -0x1p+0 },
+{ INT64_C(0x1000800000004000), 0x1.000800000004p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffffbfff), -0x1.000800000004p+60, -0x1p+0 },
+{ INT64_C(0x1000800000004001), 0x1.000800000004p+60, 0x1p+0 },
+{ INT64_C(0xefff7fffffffbffe), -0x1.000800000004p+60, -0x1p+1 },
+{ INT64_C(0x1000800000004010), 0x1.000800000004p+60, 0x1p+4 },
+{ INT64_C(0xefff7fffffffbfef), -0x1.000800000004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000800000004040), 0x1.000800000004p+60, 0x1p+6 },
+{ INT64_C(0xefff7fffffffbfbf), -0x1.000800000004p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800000004080), 0x1.000800000004p+60, 0x1p+7 },
+{ INT64_C(0xefff7fffffffbf7f), -0x1.0008000000041p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800000004100), 0x1.0008000000041p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffffbeff), -0x1.0008000000041p+60, -0x1p+0 },
+{ INT64_C(0x1000800000004200), 0x1.0008000000042p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffffbdff), -0x1.0008000000042p+60, -0x1p+0 },
+{ INT64_C(0x1000800000004800), 0x1.0008000000048p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffffb7ff), -0x1.0008000000048p+60, -0x1p+0 },
+{ INT64_C(0x1000800000006000), 0x1.000800000006p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffff9fff), -0x1.000800000006p+60, -0x1p+0 },
+{ INT64_C(0x1000800000010000), 0x1.00080000001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffeffff), -0x1.00080000001p+60, -0x1p+0 },
+{ INT64_C(0x1000800000010004), 0x1.00080000001p+60, 0x1p+2 },
+{ INT64_C(0xefff7ffffffefffb), -0x1.00080000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800000010020), 0x1.00080000001p+60, 0x1p+5 },
+{ INT64_C(0xefff7ffffffeffdf), -0x1.00080000001p+60, -0x1.08p+5 },
+{ INT64_C(0x1000800000010080), 0x1.00080000001p+60, 0x1p+7 },
+{ INT64_C(0xefff7ffffffeff7f), -0x1.0008000000101p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800000010100), 0x1.0008000000101p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffefeff), -0x1.0008000000101p+60, -0x1p+0 },
+{ INT64_C(0x1000800000011000), 0x1.000800000011p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffeefff), -0x1.000800000011p+60, -0x1p+0 },
+{ INT64_C(0x1000800000018000), 0x1.000800000018p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffe7fff), -0x1.000800000018p+60, -0x1p+0 },
+{ INT64_C(0x1000800000020000), 0x1.00080000002p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffdffff), -0x1.00080000002p+60, -0x1p+0 },
+{ INT64_C(0x1000800000020001), 0x1.00080000002p+60, 0x1p+0 },
+{ INT64_C(0xefff7ffffffdfffe), -0x1.00080000002p+60, -0x1p+1 },
+{ INT64_C(0x1000800000020010), 0x1.00080000002p+60, 0x1p+4 },
+{ INT64_C(0xefff7ffffffdffef), -0x1.00080000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1000800000020040), 0x1.00080000002p+60, 0x1p+6 },
+{ INT64_C(0xefff7ffffffdffbf), -0x1.00080000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800000020100), 0x1.0008000000201p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffdfeff), -0x1.0008000000201p+60, -0x1p+0 },
+{ INT64_C(0x1000800000020800), 0x1.0008000000208p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffdf7ff), -0x1.0008000000208p+60, -0x1p+0 },
+{ INT64_C(0x1000800000028000), 0x1.000800000028p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffffd7fff), -0x1.000800000028p+60, -0x1p+0 },
+{ INT64_C(0x1000800000100000), 0x1.0008000001p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffefffff), -0x1.0008000001p+60, -0x1p+0 },
+{ INT64_C(0x1000800000100004), 0x1.0008000001p+60, 0x1p+2 },
+{ INT64_C(0xefff7fffffeffffb), -0x1.0008000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800000100008), 0x1.0008000001p+60, 0x1p+3 },
+{ INT64_C(0xefff7fffffeffff7), -0x1.0008000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800000100040), 0x1.0008000001p+60, 0x1p+6 },
+{ INT64_C(0xefff7fffffefffbf), -0x1.0008000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800000100400), 0x1.0008000001004p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffeffbff), -0x1.0008000001004p+60, -0x1p+0 },
+{ INT64_C(0x1000800000104000), 0x1.000800000104p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffefbfff), -0x1.000800000104p+60, -0x1p+0 },
+{ INT64_C(0x1000800000120000), 0x1.00080000012p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffedffff), -0x1.00080000012p+60, -0x1p+0 },
+{ INT64_C(0x1000800000140000), 0x1.00080000014p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffffebffff), -0x1.00080000014p+60, -0x1p+0 },
+{ INT64_C(0x1000800000800000), 0x1.0008000008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff7fffff), -0x1.0008000008p+60, -0x1p+0 },
+{ INT64_C(0x1000800000800002), 0x1.0008000008p+60, 0x1p+1 },
+{ INT64_C(0xefff7fffff7ffffd), -0x1.0008000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1000800000800008), 0x1.0008000008p+60, 0x1p+3 },
+{ INT64_C(0xefff7fffff7ffff7), -0x1.0008000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800000800010), 0x1.0008000008p+60, 0x1p+4 },
+{ INT64_C(0xefff7fffff7fffef), -0x1.0008000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000800000800020), 0x1.0008000008p+60, 0x1p+5 },
+{ INT64_C(0xefff7fffff7fffdf), -0x1.0008000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1000800000800040), 0x1.0008000008p+60, 0x1p+6 },
+{ INT64_C(0xefff7fffff7fffbf), -0x1.0008000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800000800100), 0x1.0008000008001p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff7ffeff), -0x1.0008000008001p+60, -0x1p+0 },
+{ INT64_C(0x1000800000800200), 0x1.0008000008002p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff7ffdff), -0x1.0008000008002p+60, -0x1p+0 },
+{ INT64_C(0x1000800000800800), 0x1.0008000008008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff7ff7ff), -0x1.0008000008008p+60, -0x1p+0 },
+{ INT64_C(0x1000800000802000), 0x1.000800000802p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff7fdfff), -0x1.000800000802p+60, -0x1p+0 },
+{ INT64_C(0x1000800000810000), 0x1.00080000081p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff7effff), -0x1.00080000081p+60, -0x1p+0 },
+{ INT64_C(0x1000800000880000), 0x1.00080000088p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff77ffff), -0x1.00080000088p+60, -0x1p+0 },
+{ INT64_C(0x1000800000a00000), 0x1.000800000ap+60, 0x0p+0 },
+{ INT64_C(0xefff7fffff5fffff), -0x1.000800000ap+60, -0x1p+0 },
+{ INT64_C(0x1000800004000000), 0x1.000800004p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffbffffff), -0x1.000800004p+60, -0x1p+0 },
+{ INT64_C(0x1000800004000001), 0x1.000800004p+60, 0x1p+0 },
+{ INT64_C(0xefff7ffffbfffffe), -0x1.000800004p+60, -0x1p+1 },
+{ INT64_C(0x1000800004000002), 0x1.000800004p+60, 0x1p+1 },
+{ INT64_C(0xefff7ffffbfffffd), -0x1.000800004p+60, -0x1.8p+1 },
+{ INT64_C(0x1000800004000004), 0x1.000800004p+60, 0x1p+2 },
+{ INT64_C(0xefff7ffffbfffffb), -0x1.000800004p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800004000010), 0x1.000800004p+60, 0x1p+4 },
+{ INT64_C(0xefff7ffffbffffef), -0x1.000800004p+60, -0x1.1p+4 },
+{ INT64_C(0x1000800004000080), 0x1.000800004p+60, 0x1p+7 },
+{ INT64_C(0xefff7ffffbffff7f), -0x1.0008000040001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800004000200), 0x1.0008000040002p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffbfffdff), -0x1.0008000040002p+60, -0x1p+0 },
+{ INT64_C(0x1000800004001000), 0x1.000800004001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffbffefff), -0x1.000800004001p+60, -0x1p+0 },
+{ INT64_C(0x1000800004008000), 0x1.000800004008p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffbff7fff), -0x1.000800004008p+60, -0x1p+0 },
+{ INT64_C(0x1000800004020000), 0x1.00080000402p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffbfdffff), -0x1.00080000402p+60, -0x1p+0 },
+{ INT64_C(0x1000800004200000), 0x1.0008000042p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffffbdfffff), -0x1.0008000042p+60, -0x1p+0 },
+{ INT64_C(0x1000800006000000), 0x1.000800006p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffff9ffffff), -0x1.000800006p+60, -0x1p+0 },
+{ INT64_C(0x1000800010000000), 0x1.00080001p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffefffffff), -0x1.00080001p+60, -0x1p+0 },
+{ INT64_C(0x1000800010000004), 0x1.00080001p+60, 0x1p+2 },
+{ INT64_C(0xefff7fffeffffffb), -0x1.00080001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800010000008), 0x1.00080001p+60, 0x1p+3 },
+{ INT64_C(0xefff7fffeffffff7), -0x1.00080001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800010000010), 0x1.00080001p+60, 0x1p+4 },
+{ INT64_C(0xefff7fffefffffef), -0x1.00080001p+60, -0x1.1p+4 },
+{ INT64_C(0x1000800010000080), 0x1.00080001p+60, 0x1p+7 },
+{ INT64_C(0xefff7fffefffff7f), -0x1.0008000100001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800010000100), 0x1.0008000100001p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffeffffeff), -0x1.0008000100001p+60, -0x1p+0 },
+{ INT64_C(0x1000800010001000), 0x1.000800010001p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffefffefff), -0x1.000800010001p+60, -0x1p+0 },
+{ INT64_C(0x1000800010008000), 0x1.000800010008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffefff7fff), -0x1.000800010008p+60, -0x1p+0 },
+{ INT64_C(0x1000800010020000), 0x1.00080001002p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffeffdffff), -0x1.00080001002p+60, -0x1p+0 },
+{ INT64_C(0x1000800010040000), 0x1.00080001004p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffeffbffff), -0x1.00080001004p+60, -0x1p+0 },
+{ INT64_C(0x1000800010200000), 0x1.0008000102p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffefdfffff), -0x1.0008000102p+60, -0x1p+0 },
+{ INT64_C(0x1000800010400000), 0x1.0008000104p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffefbfffff), -0x1.0008000104p+60, -0x1p+0 },
+{ INT64_C(0x1000800014000000), 0x1.000800014p+60, 0x0p+0 },
+{ INT64_C(0xefff7fffebffffff), -0x1.000800014p+60, -0x1p+0 },
+{ INT64_C(0x1000800080000000), 0x1.00080008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7fffffff), -0x1.00080008p+60, -0x1p+0 },
+{ INT64_C(0x1000800080000004), 0x1.00080008p+60, 0x1p+2 },
+{ INT64_C(0xefff7fff7ffffffb), -0x1.00080008p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800080000010), 0x1.00080008p+60, 0x1p+4 },
+{ INT64_C(0xefff7fff7fffffef), -0x1.00080008p+60, -0x1.1p+4 },
+{ INT64_C(0x1000800080000080), 0x1.00080008p+60, 0x1p+7 },
+{ INT64_C(0xefff7fff7fffff7f), -0x1.0008000800001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800080000400), 0x1.0008000800004p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7ffffbff), -0x1.0008000800004p+60, -0x1p+0 },
+{ INT64_C(0x1000800080002000), 0x1.000800080002p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7fffdfff), -0x1.000800080002p+60, -0x1p+0 },
+{ INT64_C(0x1000800080004000), 0x1.000800080004p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7fffbfff), -0x1.000800080004p+60, -0x1p+0 },
+{ INT64_C(0x1000800080020000), 0x1.00080008002p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7ffdffff), -0x1.00080008002p+60, -0x1p+0 },
+{ INT64_C(0x1000800080080000), 0x1.00080008008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7ff7ffff), -0x1.00080008008p+60, -0x1p+0 },
+{ INT64_C(0x1000800080800000), 0x1.0008000808p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7f7fffff), -0x1.0008000808p+60, -0x1p+0 },
+{ INT64_C(0x1000800084000000), 0x1.000800084p+60, 0x0p+0 },
+{ INT64_C(0xefff7fff7bffffff), -0x1.000800084p+60, -0x1p+0 },
+{ INT64_C(0x10008000c0000000), 0x1.0008000cp+60, 0x0p+0 },
+{ INT64_C(0xefff7fff3fffffff), -0x1.0008000cp+60, -0x1p+0 },
+{ INT64_C(0x1000800100000000), 0x1.0008001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffeffffffff), -0x1.0008001p+60, -0x1p+0 },
+{ INT64_C(0x1000800100000004), 0x1.0008001p+60, 0x1p+2 },
+{ INT64_C(0xefff7ffefffffffb), -0x1.0008001p+60, -0x1.4p+2 },
+{ INT64_C(0x1000800100000008), 0x1.0008001p+60, 0x1p+3 },
+{ INT64_C(0xefff7ffefffffff7), -0x1.0008001p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800100000040), 0x1.0008001p+60, 0x1p+6 },
+{ INT64_C(0xefff7ffeffffffbf), -0x1.0008001p+60, -0x1.04p+6 },
+{ INT64_C(0x1000800100000080), 0x1.0008001p+60, 0x1p+7 },
+{ INT64_C(0xefff7ffeffffff7f), -0x1.0008001000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800100000100), 0x1.0008001000001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffefffffeff), -0x1.0008001000001p+60, -0x1p+0 },
+{ INT64_C(0x1000800100001000), 0x1.000800100001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffeffffefff), -0x1.000800100001p+60, -0x1p+0 },
+{ INT64_C(0x1000800100008000), 0x1.000800100008p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffeffff7fff), -0x1.000800100008p+60, -0x1p+0 },
+{ INT64_C(0x1000800100010000), 0x1.00080010001p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffefffeffff), -0x1.00080010001p+60, -0x1p+0 },
+{ INT64_C(0x1000800100080000), 0x1.00080010008p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffefff7ffff), -0x1.00080010008p+60, -0x1p+0 },
+{ INT64_C(0x1000800100200000), 0x1.0008001002p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffeffdfffff), -0x1.0008001002p+60, -0x1p+0 },
+{ INT64_C(0x1000800100800000), 0x1.0008001008p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffeff7fffff), -0x1.0008001008p+60, -0x1p+0 },
+{ INT64_C(0x1000800108000000), 0x1.000800108p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffef7ffffff), -0x1.000800108p+60, -0x1p+0 },
+{ INT64_C(0x1000800110000000), 0x1.00080011p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffeefffffff), -0x1.00080011p+60, -0x1p+0 },
+{ INT64_C(0x1000800140000000), 0x1.00080014p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffebfffffff), -0x1.00080014p+60, -0x1p+0 },
+{ INT64_C(0x1000800400000000), 0x1.0008004p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbffffffff), -0x1.0008004p+60, -0x1p+0 },
+{ INT64_C(0x1000800400000008), 0x1.0008004p+60, 0x1p+3 },
+{ INT64_C(0xefff7ffbfffffff7), -0x1.0008004p+60, -0x1.2p+3 },
+{ INT64_C(0x1000800400000080), 0x1.0008004p+60, 0x1p+7 },
+{ INT64_C(0xefff7ffbffffff7f), -0x1.0008004000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1000800400000400), 0x1.0008004000004p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbfffffbff), -0x1.0008004000004p+60, -0x1p+0 },
+{ INT64_C(0x1000800400004000), 0x1.000800400004p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbffffbfff), -0x1.000800400004p+60, -0x1p+0 },
+{ INT64_C(0x1000800400008000), 0x1.000800400008p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbffff7fff), -0x1.000800400008p+60, -0x1p+0 },
+{ INT64_C(0x1000800400040000), 0x1.00080040004p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbfffbffff), -0x1.00080040004p+60, -0x1p+0 },
+{ INT64_C(0x1000800400200000), 0x1.0008004002p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbffdfffff), -0x1.0008004002p+60, -0x1p+0 },
+{ INT64_C(0x1000800401000000), 0x1.000800401p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbfeffffff), -0x1.000800401p+60, -0x1p+0 },
+{ INT64_C(0x1000800410000000), 0x1.00080041p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffbefffffff), -0x1.00080041p+60, -0x1p+0 },
+{ INT64_C(0x1000800500000000), 0x1.0008005p+60, 0x0p+0 },
+{ INT64_C(0xefff7ffaffffffff), -0x1.0008005p+60, -0x1p+0 },
+{ INT64_C(0x1000802000000000), 0x1.000802p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdfffffffff), -0x1.000802p+60, -0x1p+0 },
+{ INT64_C(0x1000802000000004), 0x1.000802p+60, 0x1p+2 },
+{ INT64_C(0xefff7fdffffffffb), -0x1.000802p+60, -0x1.4p+2 },
+{ INT64_C(0x1000802000000040), 0x1.000802p+60, 0x1p+6 },
+{ INT64_C(0xefff7fdfffffffbf), -0x1.000802p+60, -0x1.04p+6 },
+{ INT64_C(0x1000802000000100), 0x1.0008020000001p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdffffffeff), -0x1.0008020000001p+60, -0x1p+0 },
+{ INT64_C(0x1000802000000800), 0x1.0008020000008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdffffff7ff), -0x1.0008020000008p+60, -0x1p+0 },
+{ INT64_C(0x1000802000008000), 0x1.000802000008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdfffff7fff), -0x1.000802000008p+60, -0x1p+0 },
+{ INT64_C(0x1000802000040000), 0x1.00080200004p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdffffbffff), -0x1.00080200004p+60, -0x1p+0 },
+{ INT64_C(0x1000802000080000), 0x1.00080200008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdffff7ffff), -0x1.00080200008p+60, -0x1p+0 },
+{ INT64_C(0x1000802000800000), 0x1.0008020008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdfff7fffff), -0x1.0008020008p+60, -0x1p+0 },
+{ INT64_C(0x1000802008000000), 0x1.000802008p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdff7ffffff), -0x1.000802008p+60, -0x1p+0 },
+{ INT64_C(0x1000802040000000), 0x1.00080204p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdfbfffffff), -0x1.00080204p+60, -0x1p+0 },
+{ INT64_C(0x1000802400000000), 0x1.0008024p+60, 0x0p+0 },
+{ INT64_C(0xefff7fdbffffffff), -0x1.0008024p+60, -0x1p+0 },
+{ INT64_C(0x1000810000000000), 0x1.00081p+60, 0x0p+0 },
+{ INT64_C(0xefff7effffffffff), -0x1.00081p+60, -0x1p+0 },
+{ INT64_C(0x1000810000000001), 0x1.00081p+60, 0x1p+0 },
+{ INT64_C(0xefff7efffffffffe), -0x1.00081p+60, -0x1p+1 },
+{ INT64_C(0x1000810000000004), 0x1.00081p+60, 0x1p+2 },
+{ INT64_C(0xefff7efffffffffb), -0x1.00081p+60, -0x1.4p+2 },
+{ INT64_C(0x1000810000000020), 0x1.00081p+60, 0x1p+5 },
+{ INT64_C(0xefff7effffffffdf), -0x1.00081p+60, -0x1.08p+5 },
+{ INT64_C(0x1000810000000200), 0x1.0008100000002p+60, 0x0p+0 },
+{ INT64_C(0xefff7efffffffdff), -0x1.0008100000002p+60, -0x1p+0 },
+{ INT64_C(0x1000810000000400), 0x1.0008100000004p+60, 0x0p+0 },
+{ INT64_C(0xefff7efffffffbff), -0x1.0008100000004p+60, -0x1p+0 },
+{ INT64_C(0x1000810000002000), 0x1.000810000002p+60, 0x0p+0 },
+{ INT64_C(0xefff7effffffdfff), -0x1.000810000002p+60, -0x1p+0 },
+{ INT64_C(0x1000810000004000), 0x1.000810000004p+60, 0x0p+0 },
+{ INT64_C(0xefff7effffffbfff), -0x1.000810000004p+60, -0x1p+0 },
+{ INT64_C(0x1000810000008000), 0x1.000810000008p+60, 0x0p+0 },
+{ INT64_C(0xefff7effffff7fff), -0x1.000810000008p+60, -0x1p+0 },
+{ INT64_C(0x1000810000080000), 0x1.00081000008p+60, 0x0p+0 },
+{ INT64_C(0xefff7efffff7ffff), -0x1.00081000008p+60, -0x1p+0 },
+{ INT64_C(0x1000810000100000), 0x1.0008100001p+60, 0x0p+0 },
+{ INT64_C(0xefff7effffefffff), -0x1.0008100001p+60, -0x1p+0 },
+{ INT64_C(0x1000810000200000), 0x1.0008100002p+60, 0x0p+0 },
+{ INT64_C(0xefff7effffdfffff), -0x1.0008100002p+60, -0x1p+0 },
+{ INT64_C(0x1000810000800000), 0x1.0008100008p+60, 0x0p+0 },
+{ INT64_C(0xefff7effff7fffff), -0x1.0008100008p+60, -0x1p+0 },
+{ INT64_C(0x1000810004000000), 0x1.000810004p+60, 0x0p+0 },
+{ INT64_C(0xefff7efffbffffff), -0x1.000810004p+60, -0x1p+0 },
+{ INT64_C(0x1000810010000000), 0x1.00081001p+60, 0x0p+0 },
+{ INT64_C(0xefff7effefffffff), -0x1.00081001p+60, -0x1p+0 },
+{ INT64_C(0x1000810100000000), 0x1.0008101p+60, 0x0p+0 },
+{ INT64_C(0xefff7efeffffffff), -0x1.0008101p+60, -0x1p+0 },
+{ INT64_C(0x1000810800000000), 0x1.0008108p+60, 0x0p+0 },
+{ INT64_C(0xefff7ef7ffffffff), -0x1.0008108p+60, -0x1p+0 },
+{ INT64_C(0x1000818000000000), 0x1.000818p+60, 0x0p+0 },
+{ INT64_C(0xefff7e7fffffffff), -0x1.000818p+60, -0x1p+0 },
+{ INT64_C(0x1000900000000000), 0x1.0009p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffffffffff), -0x1.0009p+60, -0x1p+0 },
+{ INT64_C(0x1000900000000002), 0x1.0009p+60, 0x1p+1 },
+{ INT64_C(0xefff6ffffffffffd), -0x1.0009p+60, -0x1.8p+1 },
+{ INT64_C(0x1000900000000004), 0x1.0009p+60, 0x1p+2 },
+{ INT64_C(0xefff6ffffffffffb), -0x1.0009p+60, -0x1.4p+2 },
+{ INT64_C(0x1000900000000008), 0x1.0009p+60, 0x1p+3 },
+{ INT64_C(0xefff6ffffffffff7), -0x1.0009p+60, -0x1.2p+3 },
+{ INT64_C(0x1000900000000020), 0x1.0009p+60, 0x1p+5 },
+{ INT64_C(0xefff6fffffffffdf), -0x1.0009p+60, -0x1.08p+5 },
+{ INT64_C(0x1000900000000100), 0x1.0009000000001p+60, 0x0p+0 },
+{ INT64_C(0xefff6ffffffffeff), -0x1.0009000000001p+60, -0x1p+0 },
+{ INT64_C(0x1000900000001000), 0x1.000900000001p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffffffefff), -0x1.000900000001p+60, -0x1p+0 },
+{ INT64_C(0x1000900000002000), 0x1.000900000002p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffffffdfff), -0x1.000900000002p+60, -0x1p+0 },
+{ INT64_C(0x1000900000004000), 0x1.000900000004p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffffffbfff), -0x1.000900000004p+60, -0x1p+0 },
+{ INT64_C(0x1000900000010000), 0x1.00090000001p+60, 0x0p+0 },
+{ INT64_C(0xefff6ffffffeffff), -0x1.00090000001p+60, -0x1p+0 },
+{ INT64_C(0x1000900000100000), 0x1.0009000001p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffffefffff), -0x1.0009000001p+60, -0x1p+0 },
+{ INT64_C(0x1000900000400000), 0x1.0009000004p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffffbfffff), -0x1.0009000004p+60, -0x1p+0 },
+{ INT64_C(0x1000900004000000), 0x1.000900004p+60, 0x0p+0 },
+{ INT64_C(0xefff6ffffbffffff), -0x1.000900004p+60, -0x1p+0 },
+{ INT64_C(0x1000900010000000), 0x1.00090001p+60, 0x0p+0 },
+{ INT64_C(0xefff6fffefffffff), -0x1.00090001p+60, -0x1p+0 },
+{ INT64_C(0x1000900100000000), 0x1.0009001p+60, 0x0p+0 },
+{ INT64_C(0xefff6ffeffffffff), -0x1.0009001p+60, -0x1p+0 },
+{ INT64_C(0x1000900400000000), 0x1.0009004p+60, 0x0p+0 },
+{ INT64_C(0xefff6ffbffffffff), -0x1.0009004p+60, -0x1p+0 },
+{ INT64_C(0x1000904000000000), 0x1.000904p+60, 0x0p+0 },
+{ INT64_C(0xefff6fbfffffffff), -0x1.000904p+60, -0x1p+0 },
+{ INT64_C(0x1000920000000000), 0x1.00092p+60, 0x0p+0 },
+{ INT64_C(0xefff6dffffffffff), -0x1.00092p+60, -0x1p+0 },
+{ INT64_C(0x1000940000000000), 0x1.00094p+60, 0x0p+0 },
+{ INT64_C(0xefff6bffffffffff), -0x1.00094p+60, -0x1p+0 },
+{ INT64_C(0x1000980000000000), 0x1.00098p+60, 0x0p+0 },
+{ INT64_C(0xefff67ffffffffff), -0x1.00098p+60, -0x1p+0 },
+{ INT64_C(0x1004000000000008), 0x1.004p+60, 0x1p+3 },
+{ INT64_C(0xeffbfffffffffff7), -0x1.004p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000000000009), 0x1.004p+60, 0x1.2p+3 },
+{ INT64_C(0xeffbfffffffffff6), -0x1.004p+60, -0x1.4p+3 },
+{ INT64_C(0x100400000000000c), 0x1.004p+60, 0x1.8p+3 },
+{ INT64_C(0xeffbfffffffffff3), -0x1.004p+60, -0x1.ap+3 },
+{ INT64_C(0x1004000000000080), 0x1.004p+60, 0x1p+7 },
+{ INT64_C(0xeffbffffffffff7f), -0x1.0040000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1004000000000084), 0x1.0040000000001p+60, -0x1.fp+6 },
+{ INT64_C(0xeffbffffffffff7b), -0x1.0040000000001p+60, 0x1.ecp+6 },
+{ INT64_C(0x1004000000000090), 0x1.0040000000001p+60, -0x1.cp+6 },
+{ INT64_C(0xeffbffffffffff6f), -0x1.0040000000001p+60, 0x1.bcp+6 },
+{ INT64_C(0x1004000000000200), 0x1.0040000000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffffdff), -0x1.0040000000002p+60, -0x1p+0 },
+{ INT64_C(0x1004000000000202), 0x1.0040000000002p+60, 0x1p+1 },
+{ INT64_C(0xeffbfffffffffdfd), -0x1.0040000000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1004000000000210), 0x1.0040000000002p+60, 0x1p+4 },
+{ INT64_C(0xeffbfffffffffdef), -0x1.0040000000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1004000000000300), 0x1.0040000000003p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffffcff), -0x1.0040000000003p+60, -0x1p+0 },
+{ INT64_C(0x1004000000000800), 0x1.0040000000008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffff7ff), -0x1.0040000000008p+60, -0x1p+0 },
+{ INT64_C(0x1004000000000802), 0x1.0040000000008p+60, 0x1p+1 },
+{ INT64_C(0xeffbfffffffff7fd), -0x1.0040000000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1004000000000810), 0x1.0040000000008p+60, 0x1p+4 },
+{ INT64_C(0xeffbfffffffff7ef), -0x1.0040000000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1004000000000900), 0x1.0040000000009p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffff6ff), -0x1.0040000000009p+60, -0x1p+0 },
+{ INT64_C(0x1004000000004000), 0x1.004000000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffffbfff), -0x1.004000000004p+60, -0x1p+0 },
+{ INT64_C(0x1004000000004001), 0x1.004000000004p+60, 0x1p+0 },
+{ INT64_C(0xeffbffffffffbffe), -0x1.004000000004p+60, -0x1p+1 },
+{ INT64_C(0x1004000000004004), 0x1.004000000004p+60, 0x1p+2 },
+{ INT64_C(0xeffbffffffffbffb), -0x1.004000000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1004000000004020), 0x1.004000000004p+60, 0x1p+5 },
+{ INT64_C(0xeffbffffffffbfdf), -0x1.004000000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1004000000004200), 0x1.0040000000042p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffffbdff), -0x1.0040000000042p+60, -0x1p+0 },
+{ INT64_C(0x1004000000006000), 0x1.004000000006p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffff9fff), -0x1.004000000006p+60, -0x1p+0 },
+{ INT64_C(0x1004000000010000), 0x1.00400000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffeffff), -0x1.00400000001p+60, -0x1p+0 },
+{ INT64_C(0x1004000000010008), 0x1.00400000001p+60, 0x1p+3 },
+{ INT64_C(0xeffbfffffffefff7), -0x1.00400000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000000010040), 0x1.00400000001p+60, 0x1p+6 },
+{ INT64_C(0xeffbfffffffeffbf), -0x1.00400000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1004000000010100), 0x1.0040000000101p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffefeff), -0x1.0040000000101p+60, -0x1p+0 },
+{ INT64_C(0x1004000000010800), 0x1.0040000000108p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffef7ff), -0x1.0040000000108p+60, -0x1p+0 },
+{ INT64_C(0x1004000000011000), 0x1.004000000011p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffeefff), -0x1.004000000011p+60, -0x1p+0 },
+{ INT64_C(0x1004000000012000), 0x1.004000000012p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffffedfff), -0x1.004000000012p+60, -0x1p+0 },
+{ INT64_C(0x1004000000100000), 0x1.0040000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffefffff), -0x1.0040000001p+60, -0x1p+0 },
+{ INT64_C(0x1004000000100008), 0x1.0040000001p+60, 0x1p+3 },
+{ INT64_C(0xeffbffffffeffff7), -0x1.0040000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000000100040), 0x1.0040000001p+60, 0x1p+6 },
+{ INT64_C(0xeffbffffffefffbf), -0x1.0040000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1004000000100080), 0x1.0040000001p+60, 0x1p+7 },
+{ INT64_C(0xeffbffffffefff7f), -0x1.0040000001001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1004000000100800), 0x1.0040000001008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffeff7ff), -0x1.0040000001008p+60, -0x1p+0 },
+{ INT64_C(0x1004000000101000), 0x1.004000000101p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffefefff), -0x1.004000000101p+60, -0x1p+0 },
+{ INT64_C(0x1004000000108000), 0x1.004000000108p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffef7fff), -0x1.004000000108p+60, -0x1p+0 },
+{ INT64_C(0x1004000000140000), 0x1.00400000014p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffebffff), -0x1.00400000014p+60, -0x1p+0 },
+{ INT64_C(0x1004000000400000), 0x1.0040000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffbfffff), -0x1.0040000004p+60, -0x1p+0 },
+{ INT64_C(0x1004000000400002), 0x1.0040000004p+60, 0x1p+1 },
+{ INT64_C(0xeffbffffffbffffd), -0x1.0040000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1004000000400008), 0x1.0040000004p+60, 0x1p+3 },
+{ INT64_C(0xeffbffffffbffff7), -0x1.0040000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000000400040), 0x1.0040000004p+60, 0x1p+6 },
+{ INT64_C(0xeffbffffffbfffbf), -0x1.0040000004p+60, -0x1.04p+6 },
+{ INT64_C(0x1004000000400200), 0x1.0040000004002p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffbffdff), -0x1.0040000004002p+60, -0x1p+0 },
+{ INT64_C(0x1004000000400800), 0x1.0040000004008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffbff7ff), -0x1.0040000004008p+60, -0x1p+0 },
+{ INT64_C(0x1004000000404000), 0x1.004000000404p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffbfbfff), -0x1.004000000404p+60, -0x1p+0 },
+{ INT64_C(0x1004000000440000), 0x1.00400000044p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffbbffff), -0x1.00400000044p+60, -0x1p+0 },
+{ INT64_C(0x1004000000500000), 0x1.0040000005p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffffafffff), -0x1.0040000005p+60, -0x1p+0 },
+{ INT64_C(0x1004000001000000), 0x1.004000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffeffffff), -0x1.004000001p+60, -0x1p+0 },
+{ INT64_C(0x1004000001000002), 0x1.004000001p+60, 0x1p+1 },
+{ INT64_C(0xeffbfffffefffffd), -0x1.004000001p+60, -0x1.8p+1 },
+{ INT64_C(0x1004000001000008), 0x1.004000001p+60, 0x1p+3 },
+{ INT64_C(0xeffbfffffefffff7), -0x1.004000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000001000020), 0x1.004000001p+60, 0x1p+5 },
+{ INT64_C(0xeffbfffffeffffdf), -0x1.004000001p+60, -0x1.08p+5 },
+{ INT64_C(0x1004000001000080), 0x1.004000001p+60, 0x1p+7 },
+{ INT64_C(0xeffbfffffeffff7f), -0x1.0040000010001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1004000001000400), 0x1.0040000010004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffefffbff), -0x1.0040000010004p+60, -0x1p+0 },
+{ INT64_C(0x1004000001004000), 0x1.004000001004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffeffbfff), -0x1.004000001004p+60, -0x1p+0 },
+{ INT64_C(0x1004000001008000), 0x1.004000001008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffeff7fff), -0x1.004000001008p+60, -0x1p+0 },
+{ INT64_C(0x1004000001010000), 0x1.00400000101p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffefeffff), -0x1.00400000101p+60, -0x1p+0 },
+{ INT64_C(0x1004000001100000), 0x1.0040000011p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffeefffff), -0x1.0040000011p+60, -0x1p+0 },
+{ INT64_C(0x1004000001800000), 0x1.0040000018p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffffe7fffff), -0x1.0040000018p+60, -0x1p+0 },
+{ INT64_C(0x1004000008000000), 0x1.004000008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff7ffffff), -0x1.004000008p+60, -0x1p+0 },
+{ INT64_C(0x1004000008000004), 0x1.004000008p+60, 0x1p+2 },
+{ INT64_C(0xeffbfffff7fffffb), -0x1.004000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1004000008000008), 0x1.004000008p+60, 0x1p+3 },
+{ INT64_C(0xeffbfffff7fffff7), -0x1.004000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000008000020), 0x1.004000008p+60, 0x1p+5 },
+{ INT64_C(0xeffbfffff7ffffdf), -0x1.004000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1004000008000080), 0x1.004000008p+60, 0x1p+7 },
+{ INT64_C(0xeffbfffff7ffff7f), -0x1.0040000080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1004000008000200), 0x1.0040000080002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff7fffdff), -0x1.0040000080002p+60, -0x1p+0 },
+{ INT64_C(0x1004000008000800), 0x1.0040000080008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff7fff7ff), -0x1.0040000080008p+60, -0x1p+0 },
+{ INT64_C(0x1004000008008000), 0x1.004000008008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff7ff7fff), -0x1.004000008008p+60, -0x1p+0 },
+{ INT64_C(0x1004000008020000), 0x1.00400000802p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff7fdffff), -0x1.00400000802p+60, -0x1p+0 },
+{ INT64_C(0x1004000008080000), 0x1.00400000808p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff7f7ffff), -0x1.00400000808p+60, -0x1p+0 },
+{ INT64_C(0x1004000008800000), 0x1.0040000088p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffff77fffff), -0x1.0040000088p+60, -0x1p+0 },
+{ INT64_C(0x1004000040000000), 0x1.00400004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbfffffff), -0x1.00400004p+60, -0x1p+0 },
+{ INT64_C(0x1004000040000001), 0x1.00400004p+60, 0x1p+0 },
+{ INT64_C(0xeffbffffbffffffe), -0x1.00400004p+60, -0x1p+1 },
+{ INT64_C(0x1004000040000010), 0x1.00400004p+60, 0x1p+4 },
+{ INT64_C(0xeffbffffbfffffef), -0x1.00400004p+60, -0x1.1p+4 },
+{ INT64_C(0x1004000040000020), 0x1.00400004p+60, 0x1p+5 },
+{ INT64_C(0xeffbffffbfffffdf), -0x1.00400004p+60, -0x1.08p+5 },
+{ INT64_C(0x1004000040000200), 0x1.0040000400002p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbffffdff), -0x1.0040000400002p+60, -0x1p+0 },
+{ INT64_C(0x1004000040002000), 0x1.004000040002p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbfffdfff), -0x1.004000040002p+60, -0x1p+0 },
+{ INT64_C(0x1004000040008000), 0x1.004000040008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbfff7fff), -0x1.004000040008p+60, -0x1p+0 },
+{ INT64_C(0x1004000040020000), 0x1.00400004002p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbffdffff), -0x1.00400004002p+60, -0x1p+0 },
+{ INT64_C(0x1004000040080000), 0x1.00400004008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbff7ffff), -0x1.00400004008p+60, -0x1p+0 },
+{ INT64_C(0x1004000040100000), 0x1.0040000401p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbfefffff), -0x1.0040000401p+60, -0x1p+0 },
+{ INT64_C(0x1004000040800000), 0x1.0040000408p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbf7fffff), -0x1.0040000408p+60, -0x1p+0 },
+{ INT64_C(0x1004000041000000), 0x1.004000041p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbeffffff), -0x1.004000041p+60, -0x1p+0 },
+{ INT64_C(0x1004000042000000), 0x1.004000042p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbdffffff), -0x1.004000042p+60, -0x1p+0 },
+{ INT64_C(0x1004000044000000), 0x1.004000044p+60, 0x0p+0 },
+{ INT64_C(0xeffbffffbbffffff), -0x1.004000044p+60, -0x1p+0 },
+{ INT64_C(0x1004000080000000), 0x1.00400008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7fffffff), -0x1.00400008p+60, -0x1p+0 },
+{ INT64_C(0x1004000080000004), 0x1.00400008p+60, 0x1p+2 },
+{ INT64_C(0xeffbffff7ffffffb), -0x1.00400008p+60, -0x1.4p+2 },
+{ INT64_C(0x1004000080000040), 0x1.00400008p+60, 0x1p+6 },
+{ INT64_C(0xeffbffff7fffffbf), -0x1.00400008p+60, -0x1.04p+6 },
+{ INT64_C(0x1004000080000400), 0x1.0040000800004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7ffffbff), -0x1.0040000800004p+60, -0x1p+0 },
+{ INT64_C(0x1004000080002000), 0x1.004000080002p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7fffdfff), -0x1.004000080002p+60, -0x1p+0 },
+{ INT64_C(0x1004000080004000), 0x1.004000080004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7fffbfff), -0x1.004000080004p+60, -0x1p+0 },
+{ INT64_C(0x1004000080010000), 0x1.00400008001p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7ffeffff), -0x1.00400008001p+60, -0x1p+0 },
+{ INT64_C(0x1004000080100000), 0x1.0040000801p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7fefffff), -0x1.0040000801p+60, -0x1p+0 },
+{ INT64_C(0x1004000080200000), 0x1.0040000802p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7fdfffff), -0x1.0040000802p+60, -0x1p+0 },
+{ INT64_C(0x1004000080800000), 0x1.0040000808p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7f7fffff), -0x1.0040000808p+60, -0x1p+0 },
+{ INT64_C(0x1004000084000000), 0x1.004000084p+60, 0x0p+0 },
+{ INT64_C(0xeffbffff7bffffff), -0x1.004000084p+60, -0x1p+0 },
+{ INT64_C(0x10040000c0000000), 0x1.0040000cp+60, 0x0p+0 },
+{ INT64_C(0xeffbffff3fffffff), -0x1.0040000cp+60, -0x1p+0 },
+{ INT64_C(0x1004000100000000), 0x1.0040001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffeffffffff), -0x1.0040001p+60, -0x1p+0 },
+{ INT64_C(0x1004000100000008), 0x1.0040001p+60, 0x1p+3 },
+{ INT64_C(0xeffbfffefffffff7), -0x1.0040001p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000100000040), 0x1.0040001p+60, 0x1p+6 },
+{ INT64_C(0xeffbfffeffffffbf), -0x1.0040001p+60, -0x1.04p+6 },
+{ INT64_C(0x1004000100000200), 0x1.0040001000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffefffffdff), -0x1.0040001000002p+60, -0x1p+0 },
+{ INT64_C(0x1004000100002000), 0x1.004000100002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffeffffdfff), -0x1.004000100002p+60, -0x1p+0 },
+{ INT64_C(0x1004000100010000), 0x1.00400010001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffefffeffff), -0x1.00400010001p+60, -0x1p+0 },
+{ INT64_C(0x1004000100080000), 0x1.00400010008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffefff7ffff), -0x1.00400010008p+60, -0x1p+0 },
+{ INT64_C(0x1004000100400000), 0x1.0040001004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffeffbfffff), -0x1.0040001004p+60, -0x1p+0 },
+{ INT64_C(0x1004000101000000), 0x1.004000101p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffefeffffff), -0x1.004000101p+60, -0x1p+0 },
+{ INT64_C(0x1004000108000000), 0x1.004000108p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffef7ffffff), -0x1.004000108p+60, -0x1p+0 },
+{ INT64_C(0x1004000180000000), 0x1.00400018p+60, 0x0p+0 },
+{ INT64_C(0xeffbfffe7fffffff), -0x1.00400018p+60, -0x1p+0 },
+{ INT64_C(0x1004000800000000), 0x1.0040008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7ffffffff), -0x1.0040008p+60, -0x1p+0 },
+{ INT64_C(0x1004000800000008), 0x1.0040008p+60, 0x1p+3 },
+{ INT64_C(0xeffbfff7fffffff7), -0x1.0040008p+60, -0x1.2p+3 },
+{ INT64_C(0x1004000800000010), 0x1.0040008p+60, 0x1p+4 },
+{ INT64_C(0xeffbfff7ffffffef), -0x1.0040008p+60, -0x1.1p+4 },
+{ INT64_C(0x1004000800000100), 0x1.0040008000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7fffffeff), -0x1.0040008000001p+60, -0x1p+0 },
+{ INT64_C(0x1004000800000400), 0x1.0040008000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7fffffbff), -0x1.0040008000004p+60, -0x1p+0 },
+{ INT64_C(0x1004000800002000), 0x1.004000800002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7ffffdfff), -0x1.004000800002p+60, -0x1p+0 },
+{ INT64_C(0x1004000800008000), 0x1.004000800008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7ffff7fff), -0x1.004000800008p+60, -0x1p+0 },
+{ INT64_C(0x1004000800020000), 0x1.00400080002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7fffdffff), -0x1.00400080002p+60, -0x1p+0 },
+{ INT64_C(0x1004000800200000), 0x1.0040008002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7ffdfffff), -0x1.0040008002p+60, -0x1p+0 },
+{ INT64_C(0x1004000800800000), 0x1.0040008008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7ff7fffff), -0x1.0040008008p+60, -0x1p+0 },
+{ INT64_C(0x1004000802000000), 0x1.004000802p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7fdffffff), -0x1.004000802p+60, -0x1p+0 },
+{ INT64_C(0x1004000808000000), 0x1.004000808p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7f7ffffff), -0x1.004000808p+60, -0x1p+0 },
+{ INT64_C(0x1004000810000000), 0x1.00400081p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff7efffffff), -0x1.00400081p+60, -0x1p+0 },
+{ INT64_C(0x1004000880000000), 0x1.00400088p+60, 0x0p+0 },
+{ INT64_C(0xeffbfff77fffffff), -0x1.00400088p+60, -0x1p+0 },
+{ INT64_C(0x1004000c00000000), 0x1.004000cp+60, 0x0p+0 },
+{ INT64_C(0xeffbfff3ffffffff), -0x1.004000cp+60, -0x1p+0 },
+{ INT64_C(0x1004004000000000), 0x1.004004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbfffffffff), -0x1.004004p+60, -0x1p+0 },
+{ INT64_C(0x1004004000000008), 0x1.004004p+60, 0x1p+3 },
+{ INT64_C(0xeffbffbffffffff7), -0x1.004004p+60, -0x1.2p+3 },
+{ INT64_C(0x1004004000000040), 0x1.004004p+60, 0x1p+6 },
+{ INT64_C(0xeffbffbfffffffbf), -0x1.004004p+60, -0x1.04p+6 },
+{ INT64_C(0x1004004000000080), 0x1.004004p+60, 0x1p+7 },
+{ INT64_C(0xeffbffbfffffff7f), -0x1.0040040000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1004004000000800), 0x1.0040040000008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbffffff7ff), -0x1.0040040000008p+60, -0x1p+0 },
+{ INT64_C(0x1004004000008000), 0x1.004004000008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbfffff7fff), -0x1.004004000008p+60, -0x1p+0 },
+{ INT64_C(0x1004004000080000), 0x1.00400400008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbffff7ffff), -0x1.00400400008p+60, -0x1p+0 },
+{ INT64_C(0x1004004000800000), 0x1.0040040008p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbfff7fffff), -0x1.0040040008p+60, -0x1p+0 },
+{ INT64_C(0x1004004004000000), 0x1.004004004p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbffbffffff), -0x1.004004004p+60, -0x1p+0 },
+{ INT64_C(0x1004004010000000), 0x1.00400401p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbfefffffff), -0x1.00400401p+60, -0x1p+0 },
+{ INT64_C(0x1004004040000000), 0x1.00400404p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbfbfffffff), -0x1.00400404p+60, -0x1p+0 },
+{ INT64_C(0x1004004400000000), 0x1.0040044p+60, 0x0p+0 },
+{ INT64_C(0xeffbffbbffffffff), -0x1.0040044p+60, -0x1p+0 },
+{ INT64_C(0x1004006000000000), 0x1.004006p+60, 0x0p+0 },
+{ INT64_C(0xeffbff9fffffffff), -0x1.004006p+60, -0x1p+0 },
+{ INT64_C(0x1004020000000000), 0x1.00402p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdffffffffff), -0x1.00402p+60, -0x1p+0 },
+{ INT64_C(0x1004020000000002), 0x1.00402p+60, 0x1p+1 },
+{ INT64_C(0xeffbfdfffffffffd), -0x1.00402p+60, -0x1.8p+1 },
+{ INT64_C(0x1004020000000004), 0x1.00402p+60, 0x1p+2 },
+{ INT64_C(0xeffbfdfffffffffb), -0x1.00402p+60, -0x1.4p+2 },
+{ INT64_C(0x1004020000000020), 0x1.00402p+60, 0x1p+5 },
+{ INT64_C(0xeffbfdffffffffdf), -0x1.00402p+60, -0x1.08p+5 },
+{ INT64_C(0x1004020000000040), 0x1.00402p+60, 0x1p+6 },
+{ INT64_C(0xeffbfdffffffffbf), -0x1.00402p+60, -0x1.04p+6 },
+{ INT64_C(0x1004020000000100), 0x1.0040200000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfffffffeff), -0x1.0040200000001p+60, -0x1p+0 },
+{ INT64_C(0x1004020000000800), 0x1.0040200000008p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfffffff7ff), -0x1.0040200000008p+60, -0x1p+0 },
+{ INT64_C(0x1004020000002000), 0x1.004020000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdffffffdfff), -0x1.004020000002p+60, -0x1p+0 },
+{ INT64_C(0x1004020000020000), 0x1.00402000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfffffdffff), -0x1.00402000002p+60, -0x1p+0 },
+{ INT64_C(0x1004020000040000), 0x1.00402000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfffffbffff), -0x1.00402000004p+60, -0x1p+0 },
+{ INT64_C(0x1004020000200000), 0x1.0040200002p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdffffdfffff), -0x1.0040200002p+60, -0x1p+0 },
+{ INT64_C(0x1004020000400000), 0x1.0040200004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdffffbfffff), -0x1.0040200004p+60, -0x1p+0 },
+{ INT64_C(0x1004020001000000), 0x1.004020001p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfffeffffff), -0x1.004020001p+60, -0x1p+0 },
+{ INT64_C(0x1004020004000000), 0x1.004020004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfffbffffff), -0x1.004020004p+60, -0x1p+0 },
+{ INT64_C(0x1004020040000000), 0x1.00402004p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdffbfffffff), -0x1.00402004p+60, -0x1p+0 },
+{ INT64_C(0x1004020100000000), 0x1.0040201p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfeffffffff), -0x1.0040201p+60, -0x1p+0 },
+{ INT64_C(0x1004020400000000), 0x1.0040204p+60, 0x0p+0 },
+{ INT64_C(0xeffbfdfbffffffff), -0x1.0040204p+60, -0x1p+0 },
+{ INT64_C(0x1004022000000000), 0x1.004022p+60, 0x0p+0 },
+{ INT64_C(0xeffbfddfffffffff), -0x1.004022p+60, -0x1p+0 },
+{ INT64_C(0x1004200000000000), 0x1.0042p+60, 0x0p+0 },
+{ INT64_C(0xeffbdfffffffffff), -0x1.0042p+60, -0x1p+0 },
+{ INT64_C(0x1004200000000004), 0x1.0042p+60, 0x1p+2 },
+{ INT64_C(0xeffbdffffffffffb), -0x1.0042p+60, -0x1.4p+2 },
+{ INT64_C(0x1004200000000010), 0x1.0042p+60, 0x1p+4 },
+{ INT64_C(0xeffbdfffffffffef), -0x1.0042p+60, -0x1.1p+4 },
+{ INT64_C(0x1004200000000040), 0x1.0042p+60, 0x1p+6 },
+{ INT64_C(0xeffbdfffffffffbf), -0x1.0042p+60, -0x1.04p+6 },
+{ INT64_C(0x1004200000000100), 0x1.0042000000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbdffffffffeff), -0x1.0042000000001p+60, -0x1p+0 },
+{ INT64_C(0x1004200000000200), 0x1.0042000000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbdffffffffdff), -0x1.0042000000002p+60, -0x1p+0 },
+{ INT64_C(0x1004200000002000), 0x1.004200000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbdfffffffdfff), -0x1.004200000002p+60, -0x1p+0 },
+{ INT64_C(0x1004200000004000), 0x1.004200000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbdfffffffbfff), -0x1.004200000004p+60, -0x1p+0 },
+{ INT64_C(0x1004200000040000), 0x1.00420000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbdffffffbffff), -0x1.00420000004p+60, -0x1p+0 },
+{ INT64_C(0x1004200000200000), 0x1.0042000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbdfffffdfffff), -0x1.0042000002p+60, -0x1p+0 },
+{ INT64_C(0x1004200002000000), 0x1.004200002p+60, 0x0p+0 },
+{ INT64_C(0xeffbdffffdffffff), -0x1.004200002p+60, -0x1p+0 },
+{ INT64_C(0x1004200004000000), 0x1.004200004p+60, 0x0p+0 },
+{ INT64_C(0xeffbdffffbffffff), -0x1.004200004p+60, -0x1p+0 },
+{ INT64_C(0x1004200040000000), 0x1.00420004p+60, 0x0p+0 },
+{ INT64_C(0xeffbdfffbfffffff), -0x1.00420004p+60, -0x1p+0 },
+{ INT64_C(0x1004200200000000), 0x1.0042002p+60, 0x0p+0 },
+{ INT64_C(0xeffbdffdffffffff), -0x1.0042002p+60, -0x1p+0 },
+{ INT64_C(0x1004200800000000), 0x1.0042008p+60, 0x0p+0 },
+{ INT64_C(0xeffbdff7ffffffff), -0x1.0042008p+60, -0x1p+0 },
+{ INT64_C(0x1004202000000000), 0x1.004202p+60, 0x0p+0 },
+{ INT64_C(0xeffbdfdfffffffff), -0x1.004202p+60, -0x1p+0 },
+{ INT64_C(0x1004210000000000), 0x1.00421p+60, 0x0p+0 },
+{ INT64_C(0xeffbdeffffffffff), -0x1.00421p+60, -0x1p+0 },
+{ INT64_C(0x1004300000000000), 0x1.0043p+60, 0x0p+0 },
+{ INT64_C(0xeffbcfffffffffff), -0x1.0043p+60, -0x1p+0 },
+{ INT64_C(0x1004400000000000), 0x1.0044p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfffffffffff), -0x1.0044p+60, -0x1p+0 },
+{ INT64_C(0x1004400000000002), 0x1.0044p+60, 0x1p+1 },
+{ INT64_C(0xeffbbffffffffffd), -0x1.0044p+60, -0x1.8p+1 },
+{ INT64_C(0x1004400000000004), 0x1.0044p+60, 0x1p+2 },
+{ INT64_C(0xeffbbffffffffffb), -0x1.0044p+60, -0x1.4p+2 },
+{ INT64_C(0x1004400000000040), 0x1.0044p+60, 0x1p+6 },
+{ INT64_C(0xeffbbfffffffffbf), -0x1.0044p+60, -0x1.04p+6 },
+{ INT64_C(0x1004400000000200), 0x1.0044000000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffffffffdff), -0x1.0044000000002p+60, -0x1p+0 },
+{ INT64_C(0x1004400000000800), 0x1.0044000000008p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffffffff7ff), -0x1.0044000000008p+60, -0x1p+0 },
+{ INT64_C(0x1004400000004000), 0x1.004400000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfffffffbfff), -0x1.004400000004p+60, -0x1p+0 },
+{ INT64_C(0x1004400000020000), 0x1.00440000002p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffffffdffff), -0x1.00440000002p+60, -0x1p+0 },
+{ INT64_C(0x1004400000040000), 0x1.00440000004p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffffffbffff), -0x1.00440000004p+60, -0x1p+0 },
+{ INT64_C(0x1004400000100000), 0x1.0044000001p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfffffefffff), -0x1.0044000001p+60, -0x1p+0 },
+{ INT64_C(0x1004400001000000), 0x1.004400001p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffffeffffff), -0x1.004400001p+60, -0x1p+0 },
+{ INT64_C(0x1004400008000000), 0x1.004400008p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffff7ffffff), -0x1.004400008p+60, -0x1p+0 },
+{ INT64_C(0x1004400010000000), 0x1.00440001p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfffefffffff), -0x1.00440001p+60, -0x1p+0 },
+{ INT64_C(0x1004400040000000), 0x1.00440004p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfffbfffffff), -0x1.00440004p+60, -0x1p+0 },
+{ INT64_C(0x1004400080000000), 0x1.00440008p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfff7fffffff), -0x1.00440008p+60, -0x1p+0 },
+{ INT64_C(0x1004400400000000), 0x1.0044004p+60, 0x0p+0 },
+{ INT64_C(0xeffbbffbffffffff), -0x1.0044004p+60, -0x1p+0 },
+{ INT64_C(0x1004400800000000), 0x1.0044008p+60, 0x0p+0 },
+{ INT64_C(0xeffbbff7ffffffff), -0x1.0044008p+60, -0x1p+0 },
+{ INT64_C(0x1004402000000000), 0x1.004402p+60, 0x0p+0 },
+{ INT64_C(0xeffbbfdfffffffff), -0x1.004402p+60, -0x1p+0 },
+{ INT64_C(0x1004420000000000), 0x1.00442p+60, 0x0p+0 },
+{ INT64_C(0xeffbbdffffffffff), -0x1.00442p+60, -0x1p+0 },
+{ INT64_C(0x1004440000000000), 0x1.00444p+60, 0x0p+0 },
+{ INT64_C(0xeffbbbffffffffff), -0x1.00444p+60, -0x1p+0 },
+{ INT64_C(0x1004600000000000), 0x1.0046p+60, 0x0p+0 },
+{ INT64_C(0xeffb9fffffffffff), -0x1.0046p+60, -0x1p+0 },
+{ INT64_C(0x1006000000000000), 0x1.006p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffffffffffff), -0x1.006p+60, -0x1p+0 },
+{ INT64_C(0x1006000000000004), 0x1.006p+60, 0x1p+2 },
+{ INT64_C(0xeff9fffffffffffb), -0x1.006p+60, -0x1.4p+2 },
+{ INT64_C(0x1006000000000020), 0x1.006p+60, 0x1p+5 },
+{ INT64_C(0xeff9ffffffffffdf), -0x1.006p+60, -0x1.08p+5 },
+{ INT64_C(0x1006000000000080), 0x1.006p+60, 0x1p+7 },
+{ INT64_C(0xeff9ffffffffff7f), -0x1.0060000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1006000000000400), 0x1.0060000000004p+60, 0x0p+0 },
+{ INT64_C(0xeff9fffffffffbff), -0x1.0060000000004p+60, -0x1p+0 },
+{ INT64_C(0x1006000000001000), 0x1.006000000001p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffffffffefff), -0x1.006000000001p+60, -0x1p+0 },
+{ INT64_C(0x1006000000002000), 0x1.006000000002p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffffffffdfff), -0x1.006000000002p+60, -0x1p+0 },
+{ INT64_C(0x1006000000020000), 0x1.00600000002p+60, 0x0p+0 },
+{ INT64_C(0xeff9fffffffdffff), -0x1.00600000002p+60, -0x1p+0 },
+{ INT64_C(0x1006000000200000), 0x1.0060000002p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffffffdfffff), -0x1.0060000002p+60, -0x1p+0 },
+{ INT64_C(0x1006000001000000), 0x1.006000001p+60, 0x0p+0 },
+{ INT64_C(0xeff9fffffeffffff), -0x1.006000001p+60, -0x1p+0 },
+{ INT64_C(0x1006000004000000), 0x1.006000004p+60, 0x0p+0 },
+{ INT64_C(0xeff9fffffbffffff), -0x1.006000004p+60, -0x1p+0 },
+{ INT64_C(0x1006000020000000), 0x1.00600002p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffffdfffffff), -0x1.00600002p+60, -0x1p+0 },
+{ INT64_C(0x1006000080000000), 0x1.00600008p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffff7fffffff), -0x1.00600008p+60, -0x1p+0 },
+{ INT64_C(0x1006000800000000), 0x1.0060008p+60, 0x0p+0 },
+{ INT64_C(0xeff9fff7ffffffff), -0x1.0060008p+60, -0x1p+0 },
+{ INT64_C(0x1006001000000000), 0x1.006001p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffefffffffff), -0x1.006001p+60, -0x1p+0 },
+{ INT64_C(0x1006002000000000), 0x1.006002p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffdfffffffff), -0x1.006002p+60, -0x1p+0 },
+{ INT64_C(0x1006004000000000), 0x1.006004p+60, 0x0p+0 },
+{ INT64_C(0xeff9ffbfffffffff), -0x1.006004p+60, -0x1p+0 },
+{ INT64_C(0x1006040000000000), 0x1.00604p+60, 0x0p+0 },
+{ INT64_C(0xeff9fbffffffffff), -0x1.00604p+60, -0x1p+0 },
+{ INT64_C(0x1006200000000000), 0x1.0062p+60, 0x0p+0 },
+{ INT64_C(0xeff9dfffffffffff), -0x1.0062p+60, -0x1p+0 },
+{ INT64_C(0x1007000000000000), 0x1.007p+60, 0x0p+0 },
+{ INT64_C(0xeff8ffffffffffff), -0x1.007p+60, -0x1p+0 },
+{ INT64_C(0x1010000000000008), 0x1.01p+60, 0x1p+3 },
+{ INT64_C(0xefeffffffffffff7), -0x1.01p+60, -0x1.2p+3 },
+{ INT64_C(0x101000000000000a), 0x1.01p+60, 0x1.4p+3 },
+{ INT64_C(0xefeffffffffffff5), -0x1.01p+60, -0x1.6p+3 },
+{ INT64_C(0x1010000000000020), 0x1.01p+60, 0x1p+5 },
+{ INT64_C(0xefefffffffffffdf), -0x1.01p+60, -0x1.08p+5 },
+{ INT64_C(0x1010000000000022), 0x1.01p+60, 0x1.1p+5 },
+{ INT64_C(0xefefffffffffffdd), -0x1.01p+60, -0x1.18p+5 },
+{ INT64_C(0x1010000000000024), 0x1.01p+60, 0x1.2p+5 },
+{ INT64_C(0xefefffffffffffdb), -0x1.01p+60, -0x1.28p+5 },
+{ INT64_C(0x1010000000000040), 0x1.01p+60, 0x1p+6 },
+{ INT64_C(0xefefffffffffffbf), -0x1.01p+60, -0x1.04p+6 },
+{ INT64_C(0x1010000000000041), 0x1.01p+60, 0x1.04p+6 },
+{ INT64_C(0xefefffffffffffbe), -0x1.01p+60, -0x1.08p+6 },
+{ INT64_C(0x1010000000000044), 0x1.01p+60, 0x1.1p+6 },
+{ INT64_C(0xefefffffffffffbb), -0x1.01p+60, -0x1.14p+6 },
+{ INT64_C(0x1010000000000080), 0x1.01p+60, 0x1p+7 },
+{ INT64_C(0xefefffffffffff7f), -0x1.0100000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1010000000000088), 0x1.0100000000001p+60, -0x1.ep+6 },
+{ INT64_C(0xefefffffffffff77), -0x1.0100000000001p+60, 0x1.dcp+6 },
+{ INT64_C(0x1010000000000090), 0x1.0100000000001p+60, -0x1.cp+6 },
+{ INT64_C(0xefefffffffffff6f), -0x1.0100000000001p+60, 0x1.bcp+6 },
+{ INT64_C(0x1010000000000800), 0x1.0100000000008p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffff7ff), -0x1.0100000000008p+60, -0x1p+0 },
+{ INT64_C(0x1010000000000801), 0x1.0100000000008p+60, 0x1p+0 },
+{ INT64_C(0xefeffffffffff7fe), -0x1.0100000000008p+60, -0x1p+1 },
+{ INT64_C(0x1010000000000802), 0x1.0100000000008p+60, 0x1p+1 },
+{ INT64_C(0xefeffffffffff7fd), -0x1.0100000000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1010000000000810), 0x1.0100000000008p+60, 0x1p+4 },
+{ INT64_C(0xefeffffffffff7ef), -0x1.0100000000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1010000000000820), 0x1.0100000000008p+60, 0x1p+5 },
+{ INT64_C(0xefeffffffffff7df), -0x1.0100000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1010000000000a00), 0x1.010000000000ap+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffff5ff), -0x1.010000000000ap+60, -0x1p+0 },
+{ INT64_C(0x1010000000000c00), 0x1.010000000000cp+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffff3ff), -0x1.010000000000cp+60, -0x1p+0 },
+{ INT64_C(0x1010000000004000), 0x1.010000000004p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffffbfff), -0x1.010000000004p+60, -0x1p+0 },
+{ INT64_C(0x1010000000004001), 0x1.010000000004p+60, 0x1p+0 },
+{ INT64_C(0xefefffffffffbffe), -0x1.010000000004p+60, -0x1p+1 },
+{ INT64_C(0x1010000000004010), 0x1.010000000004p+60, 0x1p+4 },
+{ INT64_C(0xefefffffffffbfef), -0x1.010000000004p+60, -0x1.1p+4 },
+{ INT64_C(0x1010000000004020), 0x1.010000000004p+60, 0x1p+5 },
+{ INT64_C(0xefefffffffffbfdf), -0x1.010000000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1010000000004080), 0x1.010000000004p+60, 0x1p+7 },
+{ INT64_C(0xefefffffffffbf7f), -0x1.0100000000041p+60, 0x1.fcp+6 },
+{ INT64_C(0x1010000000004200), 0x1.0100000000042p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffffbdff), -0x1.0100000000042p+60, -0x1p+0 },
+{ INT64_C(0x1010000000005000), 0x1.010000000005p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffffafff), -0x1.010000000005p+60, -0x1p+0 },
+{ INT64_C(0x1010000000040000), 0x1.01000000004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffbffff), -0x1.01000000004p+60, -0x1p+0 },
+{ INT64_C(0x1010000000040008), 0x1.01000000004p+60, 0x1p+3 },
+{ INT64_C(0xefeffffffffbfff7), -0x1.01000000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1010000000040010), 0x1.01000000004p+60, 0x1p+4 },
+{ INT64_C(0xefeffffffffbffef), -0x1.01000000004p+60, -0x1.1p+4 },
+{ INT64_C(0x1010000000040100), 0x1.0100000000401p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffbfeff), -0x1.0100000000401p+60, -0x1p+0 },
+{ INT64_C(0x1010000000040400), 0x1.0100000000404p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffbfbff), -0x1.0100000000404p+60, -0x1p+0 },
+{ INT64_C(0x1010000000042000), 0x1.010000000042p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffffbdfff), -0x1.010000000042p+60, -0x1p+0 },
+{ INT64_C(0x1010000000060000), 0x1.01000000006p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffff9ffff), -0x1.01000000006p+60, -0x1p+0 },
+{ INT64_C(0x1010000000200000), 0x1.0100000002p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffdfffff), -0x1.0100000002p+60, -0x1p+0 },
+{ INT64_C(0x1010000000200004), 0x1.0100000002p+60, 0x1p+2 },
+{ INT64_C(0xefefffffffdffffb), -0x1.0100000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1010000000200040), 0x1.0100000002p+60, 0x1p+6 },
+{ INT64_C(0xefefffffffdfffbf), -0x1.0100000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1010000000200100), 0x1.0100000002001p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffdffeff), -0x1.0100000002001p+60, -0x1p+0 },
+{ INT64_C(0x1010000000200400), 0x1.0100000002004p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffdffbff), -0x1.0100000002004p+60, -0x1p+0 },
+{ INT64_C(0x1010000000204000), 0x1.010000000204p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffdfbfff), -0x1.010000000204p+60, -0x1p+0 },
+{ INT64_C(0x1010000000208000), 0x1.010000000208p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffdf7fff), -0x1.010000000208p+60, -0x1p+0 },
+{ INT64_C(0x1010000000280000), 0x1.01000000028p+60, 0x0p+0 },
+{ INT64_C(0xefefffffffd7ffff), -0x1.01000000028p+60, -0x1p+0 },
+{ INT64_C(0x1010000001000000), 0x1.010000001p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffeffffff), -0x1.010000001p+60, -0x1p+0 },
+{ INT64_C(0x1010000001000008), 0x1.010000001p+60, 0x1p+3 },
+{ INT64_C(0xefeffffffefffff7), -0x1.010000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1010000001000080), 0x1.010000001p+60, 0x1p+7 },
+{ INT64_C(0xefeffffffeffff7f), -0x1.0100000010001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1010000001000200), 0x1.0100000010002p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffefffdff), -0x1.0100000010002p+60, -0x1p+0 },
+{ INT64_C(0x1010000001001000), 0x1.010000001001p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffeffefff), -0x1.010000001001p+60, -0x1p+0 },
+{ INT64_C(0x1010000001004000), 0x1.010000001004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffeffbfff), -0x1.010000001004p+60, -0x1p+0 },
+{ INT64_C(0x1010000001020000), 0x1.01000000102p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffefdffff), -0x1.01000000102p+60, -0x1p+0 },
+{ INT64_C(0x1010000001200000), 0x1.0100000012p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffedfffff), -0x1.0100000012p+60, -0x1p+0 },
+{ INT64_C(0x1010000001800000), 0x1.0100000018p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffe7fffff), -0x1.0100000018p+60, -0x1p+0 },
+{ INT64_C(0x1010000002000000), 0x1.010000002p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdffffff), -0x1.010000002p+60, -0x1p+0 },
+{ INT64_C(0x1010000002000008), 0x1.010000002p+60, 0x1p+3 },
+{ INT64_C(0xefeffffffdfffff7), -0x1.010000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1010000002000040), 0x1.010000002p+60, 0x1p+6 },
+{ INT64_C(0xefeffffffdffffbf), -0x1.010000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1010000002000200), 0x1.0100000020002p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdfffdff), -0x1.0100000020002p+60, -0x1p+0 },
+{ INT64_C(0x1010000002000400), 0x1.0100000020004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdfffbff), -0x1.0100000020004p+60, -0x1p+0 },
+{ INT64_C(0x1010000002000800), 0x1.0100000020008p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdfff7ff), -0x1.0100000020008p+60, -0x1p+0 },
+{ INT64_C(0x1010000002004000), 0x1.010000002004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdffbfff), -0x1.010000002004p+60, -0x1p+0 },
+{ INT64_C(0x1010000002040000), 0x1.01000000204p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdfbffff), -0x1.01000000204p+60, -0x1p+0 },
+{ INT64_C(0x1010000002100000), 0x1.0100000021p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffdefffff), -0x1.0100000021p+60, -0x1p+0 },
+{ INT64_C(0x1010000002800000), 0x1.0100000028p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffd7fffff), -0x1.0100000028p+60, -0x1p+0 },
+{ INT64_C(0x1010000003000000), 0x1.010000003p+60, 0x0p+0 },
+{ INT64_C(0xefeffffffcffffff), -0x1.010000003p+60, -0x1p+0 },
+{ INT64_C(0x1010000008000000), 0x1.010000008p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff7ffffff), -0x1.010000008p+60, -0x1p+0 },
+{ INT64_C(0x1010000008000004), 0x1.010000008p+60, 0x1p+2 },
+{ INT64_C(0xefeffffff7fffffb), -0x1.010000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1010000008000020), 0x1.010000008p+60, 0x1p+5 },
+{ INT64_C(0xefeffffff7ffffdf), -0x1.010000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1010000008000080), 0x1.010000008p+60, 0x1p+7 },
+{ INT64_C(0xefeffffff7ffff7f), -0x1.0100000080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1010000008000200), 0x1.0100000080002p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff7fffdff), -0x1.0100000080002p+60, -0x1p+0 },
+{ INT64_C(0x1010000008001000), 0x1.010000008001p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff7ffefff), -0x1.010000008001p+60, -0x1p+0 },
+{ INT64_C(0x1010000008010000), 0x1.01000000801p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff7feffff), -0x1.01000000801p+60, -0x1p+0 },
+{ INT64_C(0x1010000008040000), 0x1.01000000804p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff7fbffff), -0x1.01000000804p+60, -0x1p+0 },
+{ INT64_C(0x1010000008200000), 0x1.0100000082p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff7dfffff), -0x1.0100000082p+60, -0x1p+0 },
+{ INT64_C(0x1010000008800000), 0x1.0100000088p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff77fffff), -0x1.0100000088p+60, -0x1p+0 },
+{ INT64_C(0x1010000009000000), 0x1.010000009p+60, 0x0p+0 },
+{ INT64_C(0xefeffffff6ffffff), -0x1.010000009p+60, -0x1p+0 },
+{ INT64_C(0x101000000a000000), 0x1.01000000ap+60, 0x0p+0 },
+{ INT64_C(0xefeffffff5ffffff), -0x1.01000000ap+60, -0x1p+0 },
+{ INT64_C(0x1010000020000000), 0x1.01000002p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdfffffff), -0x1.01000002p+60, -0x1p+0 },
+{ INT64_C(0x1010000020000004), 0x1.01000002p+60, 0x1p+2 },
+{ INT64_C(0xefefffffdffffffb), -0x1.01000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1010000020000040), 0x1.01000002p+60, 0x1p+6 },
+{ INT64_C(0xefefffffdfffffbf), -0x1.01000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1010000020000200), 0x1.0100000200002p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdffffdff), -0x1.0100000200002p+60, -0x1p+0 },
+{ INT64_C(0x1010000020002000), 0x1.010000020002p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdfffdfff), -0x1.010000020002p+60, -0x1p+0 },
+{ INT64_C(0x1010000020004000), 0x1.010000020004p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdfffbfff), -0x1.010000020004p+60, -0x1p+0 },
+{ INT64_C(0x1010000020010000), 0x1.01000002001p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdffeffff), -0x1.01000002001p+60, -0x1p+0 },
+{ INT64_C(0x1010000020080000), 0x1.01000002008p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdff7ffff), -0x1.01000002008p+60, -0x1p+0 },
+{ INT64_C(0x1010000020400000), 0x1.0100000204p+60, 0x0p+0 },
+{ INT64_C(0xefefffffdfbfffff), -0x1.0100000204p+60, -0x1p+0 },
+{ INT64_C(0x1010000022000000), 0x1.010000022p+60, 0x0p+0 },
+{ INT64_C(0xefefffffddffffff), -0x1.010000022p+60, -0x1p+0 },
+{ INT64_C(0x1010000030000000), 0x1.01000003p+60, 0x0p+0 },
+{ INT64_C(0xefefffffcfffffff), -0x1.01000003p+60, -0x1p+0 },
+{ INT64_C(0x1010000040000000), 0x1.01000004p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbfffffff), -0x1.01000004p+60, -0x1p+0 },
+{ INT64_C(0x1010000040000008), 0x1.01000004p+60, 0x1p+3 },
+{ INT64_C(0xefefffffbffffff7), -0x1.01000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1010000040000080), 0x1.01000004p+60, 0x1p+7 },
+{ INT64_C(0xefefffffbfffff7f), -0x1.0100000400001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1010000040000200), 0x1.0100000400002p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbffffdff), -0x1.0100000400002p+60, -0x1p+0 },
+{ INT64_C(0x1010000040001000), 0x1.010000040001p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbfffefff), -0x1.010000040001p+60, -0x1p+0 },
+{ INT64_C(0x1010000040004000), 0x1.010000040004p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbfffbfff), -0x1.010000040004p+60, -0x1p+0 },
+{ INT64_C(0x1010000040040000), 0x1.01000004004p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbffbffff), -0x1.01000004004p+60, -0x1p+0 },
+{ INT64_C(0x1010000040200000), 0x1.0100000402p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbfdfffff), -0x1.0100000402p+60, -0x1p+0 },
+{ INT64_C(0x1010000041000000), 0x1.010000041p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbeffffff), -0x1.010000041p+60, -0x1p+0 },
+{ INT64_C(0x1010000044000000), 0x1.010000044p+60, 0x0p+0 },
+{ INT64_C(0xefefffffbbffffff), -0x1.010000044p+60, -0x1p+0 },
+{ INT64_C(0x1010000060000000), 0x1.01000006p+60, 0x0p+0 },
+{ INT64_C(0xefefffff9fffffff), -0x1.01000006p+60, -0x1p+0 },
+{ INT64_C(0x1010000400000000), 0x1.0100004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbffffffff), -0x1.0100004p+60, -0x1p+0 },
+{ INT64_C(0x1010000400000008), 0x1.0100004p+60, 0x1p+3 },
+{ INT64_C(0xefeffffbfffffff7), -0x1.0100004p+60, -0x1.2p+3 },
+{ INT64_C(0x1010000400000040), 0x1.0100004p+60, 0x1p+6 },
+{ INT64_C(0xefeffffbffffffbf), -0x1.0100004p+60, -0x1.04p+6 },
+{ INT64_C(0x1010000400000080), 0x1.0100004p+60, 0x1p+7 },
+{ INT64_C(0xefeffffbffffff7f), -0x1.0100004000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1010000400000200), 0x1.0100004000002p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbfffffdff), -0x1.0100004000002p+60, -0x1p+0 },
+{ INT64_C(0x1010000400000400), 0x1.0100004000004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbfffffbff), -0x1.0100004000004p+60, -0x1p+0 },
+{ INT64_C(0x1010000400002000), 0x1.010000400002p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbffffdfff), -0x1.010000400002p+60, -0x1p+0 },
+{ INT64_C(0x1010000400010000), 0x1.01000040001p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbfffeffff), -0x1.01000040001p+60, -0x1p+0 },
+{ INT64_C(0x1010000400080000), 0x1.01000040008p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbfff7ffff), -0x1.01000040008p+60, -0x1p+0 },
+{ INT64_C(0x1010000400400000), 0x1.0100004004p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbffbfffff), -0x1.0100004004p+60, -0x1p+0 },
+{ INT64_C(0x1010000400800000), 0x1.0100004008p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbff7fffff), -0x1.0100004008p+60, -0x1p+0 },
+{ INT64_C(0x1010000408000000), 0x1.010000408p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbf7ffffff), -0x1.010000408p+60, -0x1p+0 },
+{ INT64_C(0x1010000410000000), 0x1.01000041p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbefffffff), -0x1.01000041p+60, -0x1p+0 },
+{ INT64_C(0x1010000440000000), 0x1.01000044p+60, 0x0p+0 },
+{ INT64_C(0xefeffffbbfffffff), -0x1.01000044p+60, -0x1p+0 },
+{ INT64_C(0x1010000800000000), 0x1.0100008p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7ffffffff), -0x1.0100008p+60, -0x1p+0 },
+{ INT64_C(0x1010000800000004), 0x1.0100008p+60, 0x1p+2 },
+{ INT64_C(0xefeffff7fffffffb), -0x1.0100008p+60, -0x1.4p+2 },
+{ INT64_C(0x1010000800000008), 0x1.0100008p+60, 0x1p+3 },
+{ INT64_C(0xefeffff7fffffff7), -0x1.0100008p+60, -0x1.2p+3 },
+{ INT64_C(0x1010000800000020), 0x1.0100008p+60, 0x1p+5 },
+{ INT64_C(0xefeffff7ffffffdf), -0x1.0100008p+60, -0x1.08p+5 },
+{ INT64_C(0x1010000800000040), 0x1.0100008p+60, 0x1p+6 },
+{ INT64_C(0xefeffff7ffffffbf), -0x1.0100008p+60, -0x1.04p+6 },
+{ INT64_C(0x1010000800000400), 0x1.0100008000004p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7fffffbff), -0x1.0100008000004p+60, -0x1p+0 },
+{ INT64_C(0x1010000800002000), 0x1.010000800002p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7ffffdfff), -0x1.010000800002p+60, -0x1p+0 },
+{ INT64_C(0x1010000800004000), 0x1.010000800004p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7ffffbfff), -0x1.010000800004p+60, -0x1p+0 },
+{ INT64_C(0x1010000800020000), 0x1.01000080002p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7fffdffff), -0x1.01000080002p+60, -0x1p+0 },
+{ INT64_C(0x1010000800100000), 0x1.0100008001p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7ffefffff), -0x1.0100008001p+60, -0x1p+0 },
+{ INT64_C(0x1010000800200000), 0x1.0100008002p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7ffdfffff), -0x1.0100008002p+60, -0x1p+0 },
+{ INT64_C(0x1010000800400000), 0x1.0100008004p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7ffbfffff), -0x1.0100008004p+60, -0x1p+0 },
+{ INT64_C(0x1010000804000000), 0x1.010000804p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7fbffffff), -0x1.010000804p+60, -0x1p+0 },
+{ INT64_C(0x1010000820000000), 0x1.01000082p+60, 0x0p+0 },
+{ INT64_C(0xefeffff7dfffffff), -0x1.01000082p+60, -0x1p+0 },
+{ INT64_C(0x1010000900000000), 0x1.0100009p+60, 0x0p+0 },
+{ INT64_C(0xefeffff6ffffffff), -0x1.0100009p+60, -0x1p+0 },
+{ INT64_C(0x1010000a00000000), 0x1.010000ap+60, 0x0p+0 },
+{ INT64_C(0xefeffff5ffffffff), -0x1.010000ap+60, -0x1p+0 },
+{ INT64_C(0x1010008000000000), 0x1.010008p+60, 0x0p+0 },
+{ INT64_C(0xefefff7fffffffff), -0x1.010008p+60, -0x1p+0 },
+{ INT64_C(0x1010008000000001), 0x1.010008p+60, 0x1p+0 },
+{ INT64_C(0xefefff7ffffffffe), -0x1.010008p+60, -0x1p+1 },
+{ INT64_C(0x1010008000000008), 0x1.010008p+60, 0x1p+3 },
+{ INT64_C(0xefefff7ffffffff7), -0x1.010008p+60, -0x1.2p+3 },
+{ INT64_C(0x1010008000000010), 0x1.010008p+60, 0x1p+4 },
+{ INT64_C(0xefefff7fffffffef), -0x1.010008p+60, -0x1.1p+4 },
+{ INT64_C(0x1010008000000040), 0x1.010008p+60, 0x1p+6 },
+{ INT64_C(0xefefff7fffffffbf), -0x1.010008p+60, -0x1.04p+6 },
+{ INT64_C(0x1010008000000100), 0x1.0100080000001p+60, 0x0p+0 },
+{ INT64_C(0xefefff7ffffffeff), -0x1.0100080000001p+60, -0x1p+0 },
+{ INT64_C(0x1010008000000400), 0x1.0100080000004p+60, 0x0p+0 },
+{ INT64_C(0xefefff7ffffffbff), -0x1.0100080000004p+60, -0x1p+0 },
+{ INT64_C(0x1010008000002000), 0x1.010008000002p+60, 0x0p+0 },
+{ INT64_C(0xefefff7fffffdfff), -0x1.010008000002p+60, -0x1p+0 },
+{ INT64_C(0x1010008000020000), 0x1.01000800002p+60, 0x0p+0 },
+{ INT64_C(0xefefff7ffffdffff), -0x1.01000800002p+60, -0x1p+0 },
+{ INT64_C(0x1010008000100000), 0x1.0100080001p+60, 0x0p+0 },
+{ INT64_C(0xefefff7fffefffff), -0x1.0100080001p+60, -0x1p+0 },
+{ INT64_C(0x1010008000200000), 0x1.0100080002p+60, 0x0p+0 },
+{ INT64_C(0xefefff7fffdfffff), -0x1.0100080002p+60, -0x1p+0 },
+{ INT64_C(0x1010008000400000), 0x1.0100080004p+60, 0x0p+0 },
+{ INT64_C(0xefefff7fffbfffff), -0x1.0100080004p+60, -0x1p+0 },
+{ INT64_C(0x1010008001000000), 0x1.010008001p+60, 0x0p+0 },
+{ INT64_C(0xefefff7ffeffffff), -0x1.010008001p+60, -0x1p+0 },
+{ INT64_C(0x1010008008000000), 0x1.010008008p+60, 0x0p+0 },
+{ INT64_C(0xefefff7ff7ffffff), -0x1.010008008p+60, -0x1p+0 },
+{ INT64_C(0x1010008010000000), 0x1.01000801p+60, 0x0p+0 },
+{ INT64_C(0xefefff7fefffffff), -0x1.01000801p+60, -0x1p+0 },
+{ INT64_C(0x1010008080000000), 0x1.01000808p+60, 0x0p+0 },
+{ INT64_C(0xefefff7f7fffffff), -0x1.01000808p+60, -0x1p+0 },
+{ INT64_C(0x1010008100000000), 0x1.0100081p+60, 0x0p+0 },
+{ INT64_C(0xefefff7effffffff), -0x1.0100081p+60, -0x1p+0 },
+{ INT64_C(0x1010008800000000), 0x1.0100088p+60, 0x0p+0 },
+{ INT64_C(0xefefff77ffffffff), -0x1.0100088p+60, -0x1p+0 },
+{ INT64_C(0x101000c000000000), 0x1.01000cp+60, 0x0p+0 },
+{ INT64_C(0xefefff3fffffffff), -0x1.01000cp+60, -0x1p+0 },
+{ INT64_C(0x1010040000000000), 0x1.01004p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffffffffff), -0x1.01004p+60, -0x1p+0 },
+{ INT64_C(0x1010040000000008), 0x1.01004p+60, 0x1p+3 },
+{ INT64_C(0xefeffbfffffffff7), -0x1.01004p+60, -0x1.2p+3 },
+{ INT64_C(0x1010040000000010), 0x1.01004p+60, 0x1p+4 },
+{ INT64_C(0xefeffbffffffffef), -0x1.01004p+60, -0x1.1p+4 },
+{ INT64_C(0x1010040000000100), 0x1.0100400000001p+60, 0x0p+0 },
+{ INT64_C(0xefeffbfffffffeff), -0x1.0100400000001p+60, -0x1p+0 },
+{ INT64_C(0x1010040000000800), 0x1.0100400000008p+60, 0x0p+0 },
+{ INT64_C(0xefeffbfffffff7ff), -0x1.0100400000008p+60, -0x1p+0 },
+{ INT64_C(0x1010040000001000), 0x1.010040000001p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffffffefff), -0x1.010040000001p+60, -0x1p+0 },
+{ INT64_C(0x1010040000002000), 0x1.010040000002p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffffffdfff), -0x1.010040000002p+60, -0x1p+0 },
+{ INT64_C(0x1010040000008000), 0x1.010040000008p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffffff7fff), -0x1.010040000008p+60, -0x1p+0 },
+{ INT64_C(0x1010040000040000), 0x1.01004000004p+60, 0x0p+0 },
+{ INT64_C(0xefeffbfffffbffff), -0x1.01004000004p+60, -0x1p+0 },
+{ INT64_C(0x1010040000400000), 0x1.0100400004p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffffbfffff), -0x1.0100400004p+60, -0x1p+0 },
+{ INT64_C(0x1010040000800000), 0x1.0100400008p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffff7fffff), -0x1.0100400008p+60, -0x1p+0 },
+{ INT64_C(0x1010040008000000), 0x1.010040008p+60, 0x0p+0 },
+{ INT64_C(0xefeffbfff7ffffff), -0x1.010040008p+60, -0x1p+0 },
+{ INT64_C(0x1010040040000000), 0x1.01004004p+60, 0x0p+0 },
+{ INT64_C(0xefeffbffbfffffff), -0x1.01004004p+60, -0x1p+0 },
+{ INT64_C(0x1010040400000000), 0x1.0100404p+60, 0x0p+0 },
+{ INT64_C(0xefeffbfbffffffff), -0x1.0100404p+60, -0x1p+0 },
+{ INT64_C(0x1010041000000000), 0x1.010041p+60, 0x0p+0 },
+{ INT64_C(0xefeffbefffffffff), -0x1.010041p+60, -0x1p+0 },
+{ INT64_C(0x1010042000000000), 0x1.010042p+60, 0x0p+0 },
+{ INT64_C(0xefeffbdfffffffff), -0x1.010042p+60, -0x1p+0 },
+{ INT64_C(0x1010060000000000), 0x1.01006p+60, 0x0p+0 },
+{ INT64_C(0xefeff9ffffffffff), -0x1.01006p+60, -0x1p+0 },
+{ INT64_C(0x1010080000000000), 0x1.01008p+60, 0x0p+0 },
+{ INT64_C(0xefeff7ffffffffff), -0x1.01008p+60, -0x1p+0 },
+{ INT64_C(0x1010080000000001), 0x1.01008p+60, 0x1p+0 },
+{ INT64_C(0xefeff7fffffffffe), -0x1.01008p+60, -0x1p+1 },
+{ INT64_C(0x1010080000000008), 0x1.01008p+60, 0x1p+3 },
+{ INT64_C(0xefeff7fffffffff7), -0x1.01008p+60, -0x1.2p+3 },
+{ INT64_C(0x1010080000000040), 0x1.01008p+60, 0x1p+6 },
+{ INT64_C(0xefeff7ffffffffbf), -0x1.01008p+60, -0x1.04p+6 },
+{ INT64_C(0x1010080000000200), 0x1.0100800000002p+60, 0x0p+0 },
+{ INT64_C(0xefeff7fffffffdff), -0x1.0100800000002p+60, -0x1p+0 },
+{ INT64_C(0x1010080000000400), 0x1.0100800000004p+60, 0x0p+0 },
+{ INT64_C(0xefeff7fffffffbff), -0x1.0100800000004p+60, -0x1p+0 },
+{ INT64_C(0x1010080000000800), 0x1.0100800000008p+60, 0x0p+0 },
+{ INT64_C(0xefeff7fffffff7ff), -0x1.0100800000008p+60, -0x1p+0 },
+{ INT64_C(0x1010080000008000), 0x1.010080000008p+60, 0x0p+0 },
+{ INT64_C(0xefeff7ffffff7fff), -0x1.010080000008p+60, -0x1p+0 },
+{ INT64_C(0x1010080000080000), 0x1.01008000008p+60, 0x0p+0 },
+{ INT64_C(0xefeff7fffff7ffff), -0x1.01008000008p+60, -0x1p+0 },
+{ INT64_C(0x1010080000800000), 0x1.0100800008p+60, 0x0p+0 },
+{ INT64_C(0xefeff7ffff7fffff), -0x1.0100800008p+60, -0x1p+0 },
+{ INT64_C(0x1010080002000000), 0x1.010080002p+60, 0x0p+0 },
+{ INT64_C(0xefeff7fffdffffff), -0x1.010080002p+60, -0x1p+0 },
+{ INT64_C(0x1010080020000000), 0x1.01008002p+60, 0x0p+0 },
+{ INT64_C(0xefeff7ffdfffffff), -0x1.01008002p+60, -0x1p+0 },
+{ INT64_C(0x1010080100000000), 0x1.0100801p+60, 0x0p+0 },
+{ INT64_C(0xefeff7feffffffff), -0x1.0100801p+60, -0x1p+0 },
+{ INT64_C(0x1010080400000000), 0x1.0100804p+60, 0x0p+0 },
+{ INT64_C(0xefeff7fbffffffff), -0x1.0100804p+60, -0x1p+0 },
+{ INT64_C(0x1010080800000000), 0x1.0100808p+60, 0x0p+0 },
+{ INT64_C(0xefeff7f7ffffffff), -0x1.0100808p+60, -0x1p+0 },
+{ INT64_C(0x1010088000000000), 0x1.010088p+60, 0x0p+0 },
+{ INT64_C(0xefeff77fffffffff), -0x1.010088p+60, -0x1p+0 },
+{ INT64_C(0x1010800000000000), 0x1.0108p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffffffffff), -0x1.0108p+60, -0x1p+0 },
+{ INT64_C(0x1010800000000004), 0x1.0108p+60, 0x1p+2 },
+{ INT64_C(0xefef7ffffffffffb), -0x1.0108p+60, -0x1.4p+2 },
+{ INT64_C(0x1010800000000010), 0x1.0108p+60, 0x1p+4 },
+{ INT64_C(0xefef7fffffffffef), -0x1.0108p+60, -0x1.1p+4 },
+{ INT64_C(0x1010800000000100), 0x1.0108000000001p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffffffffeff), -0x1.0108000000001p+60, -0x1p+0 },
+{ INT64_C(0x1010800000000200), 0x1.0108000000002p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffffffffdff), -0x1.0108000000002p+60, -0x1p+0 },
+{ INT64_C(0x1010800000000400), 0x1.0108000000004p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffffffffbff), -0x1.0108000000004p+60, -0x1p+0 },
+{ INT64_C(0x1010800000004000), 0x1.010800000004p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffffffbfff), -0x1.010800000004p+60, -0x1p+0 },
+{ INT64_C(0x1010800000040000), 0x1.01080000004p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffffffbffff), -0x1.01080000004p+60, -0x1p+0 },
+{ INT64_C(0x1010800000080000), 0x1.01080000008p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffffff7ffff), -0x1.01080000008p+60, -0x1p+0 },
+{ INT64_C(0x1010800000100000), 0x1.0108000001p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffffefffff), -0x1.0108000001p+60, -0x1p+0 },
+{ INT64_C(0x1010800000200000), 0x1.0108000002p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffffdfffff), -0x1.0108000002p+60, -0x1p+0 },
+{ INT64_C(0x1010800000800000), 0x1.0108000008p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffff7fffff), -0x1.0108000008p+60, -0x1p+0 },
+{ INT64_C(0x1010800001000000), 0x1.010800001p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffffeffffff), -0x1.010800001p+60, -0x1p+0 },
+{ INT64_C(0x1010800010000000), 0x1.01080001p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffefffffff), -0x1.01080001p+60, -0x1p+0 },
+{ INT64_C(0x1010800040000000), 0x1.01080004p+60, 0x0p+0 },
+{ INT64_C(0xefef7fffbfffffff), -0x1.01080004p+60, -0x1p+0 },
+{ INT64_C(0x1010800100000000), 0x1.0108001p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffeffffffff), -0x1.0108001p+60, -0x1p+0 },
+{ INT64_C(0x1010800400000000), 0x1.0108004p+60, 0x0p+0 },
+{ INT64_C(0xefef7ffbffffffff), -0x1.0108004p+60, -0x1p+0 },
+{ INT64_C(0x1010804000000000), 0x1.010804p+60, 0x0p+0 },
+{ INT64_C(0xefef7fbfffffffff), -0x1.010804p+60, -0x1p+0 },
+{ INT64_C(0x1010840000000000), 0x1.01084p+60, 0x0p+0 },
+{ INT64_C(0xefef7bffffffffff), -0x1.01084p+60, -0x1p+0 },
+{ INT64_C(0x1010a00000000000), 0x1.010ap+60, 0x0p+0 },
+{ INT64_C(0xefef5fffffffffff), -0x1.010ap+60, -0x1p+0 },
+{ INT64_C(0x1018000000000000), 0x1.018p+60, 0x0p+0 },
+{ INT64_C(0xefe7ffffffffffff), -0x1.018p+60, -0x1p+0 },
+{ INT64_C(0x1018000000000001), 0x1.018p+60, 0x1p+0 },
+{ INT64_C(0xefe7fffffffffffe), -0x1.018p+60, -0x1p+1 },
+{ INT64_C(0x1018000000000008), 0x1.018p+60, 0x1p+3 },
+{ INT64_C(0xefe7fffffffffff7), -0x1.018p+60, -0x1.2p+3 },
+{ INT64_C(0x1018000000000010), 0x1.018p+60, 0x1p+4 },
+{ INT64_C(0xefe7ffffffffffef), -0x1.018p+60, -0x1.1p+4 },
+{ INT64_C(0x1018000000000100), 0x1.0180000000001p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffffffffeff), -0x1.0180000000001p+60, -0x1p+0 },
+{ INT64_C(0x1018000000000400), 0x1.0180000000004p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffffffffbff), -0x1.0180000000004p+60, -0x1p+0 },
+{ INT64_C(0x1018000000001000), 0x1.018000000001p+60, 0x0p+0 },
+{ INT64_C(0xefe7ffffffffefff), -0x1.018000000001p+60, -0x1p+0 },
+{ INT64_C(0x1018000000004000), 0x1.018000000004p+60, 0x0p+0 },
+{ INT64_C(0xefe7ffffffffbfff), -0x1.018000000004p+60, -0x1p+0 },
+{ INT64_C(0x1018000000008000), 0x1.018000000008p+60, 0x0p+0 },
+{ INT64_C(0xefe7ffffffff7fff), -0x1.018000000008p+60, -0x1p+0 },
+{ INT64_C(0x1018000000010000), 0x1.01800000001p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffffffeffff), -0x1.01800000001p+60, -0x1p+0 },
+{ INT64_C(0x1018000000080000), 0x1.01800000008p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffffff7ffff), -0x1.01800000008p+60, -0x1p+0 },
+{ INT64_C(0x1018000000200000), 0x1.0180000002p+60, 0x0p+0 },
+{ INT64_C(0xefe7ffffffdfffff), -0x1.0180000002p+60, -0x1p+0 },
+{ INT64_C(0x1018000001000000), 0x1.018000001p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffffeffffff), -0x1.018000001p+60, -0x1p+0 },
+{ INT64_C(0x1018000002000000), 0x1.018000002p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffffdffffff), -0x1.018000002p+60, -0x1p+0 },
+{ INT64_C(0x1018000020000000), 0x1.01800002p+60, 0x0p+0 },
+{ INT64_C(0xefe7ffffdfffffff), -0x1.01800002p+60, -0x1p+0 },
+{ INT64_C(0x1018000100000000), 0x1.0180001p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffeffffffff), -0x1.0180001p+60, -0x1p+0 },
+{ INT64_C(0x1018000400000000), 0x1.0180004p+60, 0x0p+0 },
+{ INT64_C(0xefe7fffbffffffff), -0x1.0180004p+60, -0x1p+0 },
+{ INT64_C(0x1018000800000000), 0x1.0180008p+60, 0x0p+0 },
+{ INT64_C(0xefe7fff7ffffffff), -0x1.0180008p+60, -0x1p+0 },
+{ INT64_C(0x1018008000000000), 0x1.018008p+60, 0x0p+0 },
+{ INT64_C(0xefe7ff7fffffffff), -0x1.018008p+60, -0x1p+0 },
+{ INT64_C(0x1018020000000000), 0x1.01802p+60, 0x0p+0 },
+{ INT64_C(0xefe7fdffffffffff), -0x1.01802p+60, -0x1p+0 },
+{ INT64_C(0x1018040000000000), 0x1.01804p+60, 0x0p+0 },
+{ INT64_C(0xefe7fbffffffffff), -0x1.01804p+60, -0x1p+0 },
+{ INT64_C(0x1018080000000000), 0x1.01808p+60, 0x0p+0 },
+{ INT64_C(0xefe7f7ffffffffff), -0x1.01808p+60, -0x1p+0 },
+{ INT64_C(0x1018400000000000), 0x1.0184p+60, 0x0p+0 },
+{ INT64_C(0xefe7bfffffffffff), -0x1.0184p+60, -0x1p+0 },
+{ INT64_C(0x1019000000000000), 0x1.019p+60, 0x0p+0 },
+{ INT64_C(0xefe6ffffffffffff), -0x1.019p+60, -0x1p+0 },
+{ INT64_C(0x1020000000000001), 0x1.02p+60, 0x1p+0 },
+{ INT64_C(0xefdffffffffffffe), -0x1.02p+60, -0x1p+1 },
+{ INT64_C(0x1020000000000010), 0x1.02p+60, 0x1p+4 },
+{ INT64_C(0xefdfffffffffffef), -0x1.02p+60, -0x1.1p+4 },
+{ INT64_C(0x1020000000000012), 0x1.02p+60, 0x1.2p+4 },
+{ INT64_C(0xefdfffffffffffed), -0x1.02p+60, -0x1.3p+4 },
+{ INT64_C(0x1020000000000100), 0x1.0200000000001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffffffeff), -0x1.0200000000001p+60, -0x1p+0 },
+{ INT64_C(0x1020000000000102), 0x1.0200000000001p+60, 0x1p+1 },
+{ INT64_C(0xefdffffffffffefd), -0x1.0200000000001p+60, -0x1.8p+1 },
+{ INT64_C(0x1020000000000108), 0x1.0200000000001p+60, 0x1p+3 },
+{ INT64_C(0xefdffffffffffef7), -0x1.0200000000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1020000000000180), 0x1.0200000000002p+60, -0x1p+7 },
+{ INT64_C(0xefdffffffffffe7f), -0x1.0200000000002p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020000000000800), 0x1.0200000000008p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffffff7ff), -0x1.0200000000008p+60, -0x1p+0 },
+{ INT64_C(0x1020000000000804), 0x1.0200000000008p+60, 0x1p+2 },
+{ INT64_C(0xefdffffffffff7fb), -0x1.0200000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1020000000000820), 0x1.0200000000008p+60, 0x1p+5 },
+{ INT64_C(0xefdffffffffff7df), -0x1.0200000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1020000000000840), 0x1.0200000000008p+60, 0x1p+6 },
+{ INT64_C(0xefdffffffffff7bf), -0x1.0200000000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1020000000000900), 0x1.0200000000009p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffffff6ff), -0x1.0200000000009p+60, -0x1p+0 },
+{ INT64_C(0x1020000000000c00), 0x1.020000000000cp+60, 0x0p+0 },
+{ INT64_C(0xefdffffffffff3ff), -0x1.020000000000cp+60, -0x1p+0 },
+{ INT64_C(0x1020000000008000), 0x1.020000000008p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffff7fff), -0x1.020000000008p+60, -0x1p+0 },
+{ INT64_C(0x1020000000008002), 0x1.020000000008p+60, 0x1p+1 },
+{ INT64_C(0xefdfffffffff7ffd), -0x1.020000000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1020000000008010), 0x1.020000000008p+60, 0x1p+4 },
+{ INT64_C(0xefdfffffffff7fef), -0x1.020000000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1020000000008040), 0x1.020000000008p+60, 0x1p+6 },
+{ INT64_C(0xefdfffffffff7fbf), -0x1.020000000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1020000000008080), 0x1.020000000008p+60, 0x1p+7 },
+{ INT64_C(0xefdfffffffff7f7f), -0x1.0200000000081p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020000000008200), 0x1.0200000000082p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffff7dff), -0x1.0200000000082p+60, -0x1p+0 },
+{ INT64_C(0x1020000000008400), 0x1.0200000000084p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffff7bff), -0x1.0200000000084p+60, -0x1p+0 },
+{ INT64_C(0x1020000000009000), 0x1.020000000009p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffff6fff), -0x1.020000000009p+60, -0x1p+0 },
+{ INT64_C(0x1020000000080000), 0x1.02000000008p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffff7ffff), -0x1.02000000008p+60, -0x1p+0 },
+{ INT64_C(0x1020000000080004), 0x1.02000000008p+60, 0x1p+2 },
+{ INT64_C(0xefdffffffff7fffb), -0x1.02000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1020000000080020), 0x1.02000000008p+60, 0x1p+5 },
+{ INT64_C(0xefdffffffff7ffdf), -0x1.02000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1020000000080200), 0x1.0200000000802p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffff7fdff), -0x1.0200000000802p+60, -0x1p+0 },
+{ INT64_C(0x1020000000081000), 0x1.020000000081p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffff7efff), -0x1.020000000081p+60, -0x1p+0 },
+{ INT64_C(0x1020000000088000), 0x1.020000000088p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffff77fff), -0x1.020000000088p+60, -0x1p+0 },
+{ INT64_C(0x10200000000c0000), 0x1.0200000000cp+60, 0x0p+0 },
+{ INT64_C(0xefdffffffff3ffff), -0x1.0200000000cp+60, -0x1p+0 },
+{ INT64_C(0x1020000000400000), 0x1.0200000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffbfffff), -0x1.0200000004p+60, -0x1p+0 },
+{ INT64_C(0x1020000000400002), 0x1.0200000004p+60, 0x1p+1 },
+{ INT64_C(0xefdfffffffbffffd), -0x1.0200000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1020000000400004), 0x1.0200000004p+60, 0x1p+2 },
+{ INT64_C(0xefdfffffffbffffb), -0x1.0200000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1020000000400020), 0x1.0200000004p+60, 0x1p+5 },
+{ INT64_C(0xefdfffffffbfffdf), -0x1.0200000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1020000000400080), 0x1.0200000004p+60, 0x1p+7 },
+{ INT64_C(0xefdfffffffbfff7f), -0x1.0200000004001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020000000400400), 0x1.0200000004004p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffbffbff), -0x1.0200000004004p+60, -0x1p+0 },
+{ INT64_C(0x1020000000402000), 0x1.020000000402p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffbfdfff), -0x1.020000000402p+60, -0x1p+0 },
+{ INT64_C(0x1020000000410000), 0x1.02000000041p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffbeffff), -0x1.02000000041p+60, -0x1p+0 },
+{ INT64_C(0x1020000000480000), 0x1.02000000048p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffffb7ffff), -0x1.02000000048p+60, -0x1p+0 },
+{ INT64_C(0x1020000000600000), 0x1.0200000006p+60, 0x0p+0 },
+{ INT64_C(0xefdfffffff9fffff), -0x1.0200000006p+60, -0x1p+0 },
+{ INT64_C(0x1020000001000000), 0x1.020000001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffeffffff), -0x1.020000001p+60, -0x1p+0 },
+{ INT64_C(0x1020000001000004), 0x1.020000001p+60, 0x1p+2 },
+{ INT64_C(0xefdffffffefffffb), -0x1.020000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1020000001000008), 0x1.020000001p+60, 0x1p+3 },
+{ INT64_C(0xefdffffffefffff7), -0x1.020000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1020000001000010), 0x1.020000001p+60, 0x1p+4 },
+{ INT64_C(0xefdffffffeffffef), -0x1.020000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1020000001000080), 0x1.020000001p+60, 0x1p+7 },
+{ INT64_C(0xefdffffffeffff7f), -0x1.0200000010001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020000001000100), 0x1.0200000010001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffefffeff), -0x1.0200000010001p+60, -0x1p+0 },
+{ INT64_C(0x1020000001001000), 0x1.020000001001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffeffefff), -0x1.020000001001p+60, -0x1p+0 },
+{ INT64_C(0x1020000001008000), 0x1.020000001008p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffeff7fff), -0x1.020000001008p+60, -0x1p+0 },
+{ INT64_C(0x1020000001040000), 0x1.02000000104p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffefbffff), -0x1.02000000104p+60, -0x1p+0 },
+{ INT64_C(0x1020000001200000), 0x1.0200000012p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffedfffff), -0x1.0200000012p+60, -0x1p+0 },
+{ INT64_C(0x1020000001800000), 0x1.0200000018p+60, 0x0p+0 },
+{ INT64_C(0xefdffffffe7fffff), -0x1.0200000018p+60, -0x1p+0 },
+{ INT64_C(0x1020000008000000), 0x1.020000008p+60, 0x0p+0 },
+{ INT64_C(0xefdffffff7ffffff), -0x1.020000008p+60, -0x1p+0 },
+{ INT64_C(0x1020000008000002), 0x1.020000008p+60, 0x1p+1 },
+{ INT64_C(0xefdffffff7fffffd), -0x1.020000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1020000008000020), 0x1.020000008p+60, 0x1p+5 },
+{ INT64_C(0xefdffffff7ffffdf), -0x1.020000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1020000008000080), 0x1.020000008p+60, 0x1p+7 },
+{ INT64_C(0xefdffffff7ffff7f), -0x1.0200000080001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020000008000400), 0x1.0200000080004p+60, 0x0p+0 },
+{ INT64_C(0xefdffffff7fffbff), -0x1.0200000080004p+60, -0x1p+0 },
+{ INT64_C(0x1020000008004000), 0x1.020000008004p+60, 0x0p+0 },
+{ INT64_C(0xefdffffff7ffbfff), -0x1.020000008004p+60, -0x1p+0 },
+{ INT64_C(0x1020000008020000), 0x1.02000000802p+60, 0x0p+0 },
+{ INT64_C(0xefdffffff7fdffff), -0x1.02000000802p+60, -0x1p+0 },
+{ INT64_C(0x1020000008080000), 0x1.02000000808p+60, 0x0p+0 },
+{ INT64_C(0xefdffffff7f7ffff), -0x1.02000000808p+60, -0x1p+0 },
+{ INT64_C(0x1020000008400000), 0x1.0200000084p+60, 0x0p+0 },
+{ INT64_C(0xefdffffff7bfffff), -0x1.0200000084p+60, -0x1p+0 },
+{ INT64_C(0x102000000c000000), 0x1.02000000cp+60, 0x0p+0 },
+{ INT64_C(0xefdffffff3ffffff), -0x1.02000000cp+60, -0x1p+0 },
+{ INT64_C(0x1020000080000000), 0x1.02000008p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7fffffff), -0x1.02000008p+60, -0x1p+0 },
+{ INT64_C(0x1020000080000002), 0x1.02000008p+60, 0x1p+1 },
+{ INT64_C(0xefdfffff7ffffffd), -0x1.02000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1020000080000010), 0x1.02000008p+60, 0x1p+4 },
+{ INT64_C(0xefdfffff7fffffef), -0x1.02000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1020000080000080), 0x1.02000008p+60, 0x1p+7 },
+{ INT64_C(0xefdfffff7fffff7f), -0x1.0200000800001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020000080000100), 0x1.0200000800001p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7ffffeff), -0x1.0200000800001p+60, -0x1p+0 },
+{ INT64_C(0x1020000080000200), 0x1.0200000800002p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7ffffdff), -0x1.0200000800002p+60, -0x1p+0 },
+{ INT64_C(0x1020000080001000), 0x1.020000080001p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7fffefff), -0x1.020000080001p+60, -0x1p+0 },
+{ INT64_C(0x1020000080002000), 0x1.020000080002p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7fffdfff), -0x1.020000080002p+60, -0x1p+0 },
+{ INT64_C(0x1020000080020000), 0x1.02000008002p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7ffdffff), -0x1.02000008002p+60, -0x1p+0 },
+{ INT64_C(0x1020000080080000), 0x1.02000008008p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7ff7ffff), -0x1.02000008008p+60, -0x1p+0 },
+{ INT64_C(0x1020000080400000), 0x1.0200000804p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7fbfffff), -0x1.0200000804p+60, -0x1p+0 },
+{ INT64_C(0x1020000082000000), 0x1.020000082p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff7dffffff), -0x1.020000082p+60, -0x1p+0 },
+{ INT64_C(0x1020000088000000), 0x1.020000088p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff77ffffff), -0x1.020000088p+60, -0x1p+0 },
+{ INT64_C(0x1020000090000000), 0x1.02000009p+60, 0x0p+0 },
+{ INT64_C(0xefdfffff6fffffff), -0x1.02000009p+60, -0x1p+0 },
+{ INT64_C(0x10200000c0000000), 0x1.0200000cp+60, 0x0p+0 },
+{ INT64_C(0xefdfffff3fffffff), -0x1.0200000cp+60, -0x1p+0 },
+{ INT64_C(0x1020000200000000), 0x1.0200002p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdffffffff), -0x1.0200002p+60, -0x1p+0 },
+{ INT64_C(0x1020000200000008), 0x1.0200002p+60, 0x1p+3 },
+{ INT64_C(0xefdffffdfffffff7), -0x1.0200002p+60, -0x1.2p+3 },
+{ INT64_C(0x1020000200000020), 0x1.0200002p+60, 0x1p+5 },
+{ INT64_C(0xefdffffdffffffdf), -0x1.0200002p+60, -0x1.08p+5 },
+{ INT64_C(0x1020000200000200), 0x1.0200002000002p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfffffdff), -0x1.0200002000002p+60, -0x1p+0 },
+{ INT64_C(0x1020000200000800), 0x1.0200002000008p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfffff7ff), -0x1.0200002000008p+60, -0x1p+0 },
+{ INT64_C(0x1020000200001000), 0x1.020000200001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdffffefff), -0x1.020000200001p+60, -0x1p+0 },
+{ INT64_C(0x1020000200008000), 0x1.020000200008p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdffff7fff), -0x1.020000200008p+60, -0x1p+0 },
+{ INT64_C(0x1020000200010000), 0x1.02000020001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfffeffff), -0x1.02000020001p+60, -0x1p+0 },
+{ INT64_C(0x1020000200020000), 0x1.02000020002p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfffdffff), -0x1.02000020002p+60, -0x1p+0 },
+{ INT64_C(0x1020000200040000), 0x1.02000020004p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfffbffff), -0x1.02000020004p+60, -0x1p+0 },
+{ INT64_C(0x1020000200100000), 0x1.0200002001p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdffefffff), -0x1.0200002001p+60, -0x1p+0 },
+{ INT64_C(0x1020000201000000), 0x1.020000201p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfeffffff), -0x1.020000201p+60, -0x1p+0 },
+{ INT64_C(0x1020000202000000), 0x1.020000202p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdfdffffff), -0x1.020000202p+60, -0x1p+0 },
+{ INT64_C(0x1020000220000000), 0x1.02000022p+60, 0x0p+0 },
+{ INT64_C(0xefdffffddfffffff), -0x1.02000022p+60, -0x1p+0 },
+{ INT64_C(0x1020000240000000), 0x1.02000024p+60, 0x0p+0 },
+{ INT64_C(0xefdffffdbfffffff), -0x1.02000024p+60, -0x1p+0 },
+{ INT64_C(0x1020002000000000), 0x1.020002p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdfffffffff), -0x1.020002p+60, -0x1p+0 },
+{ INT64_C(0x1020002000000001), 0x1.020002p+60, 0x1p+0 },
+{ INT64_C(0xefdfffdffffffffe), -0x1.020002p+60, -0x1p+1 },
+{ INT64_C(0x1020002000000004), 0x1.020002p+60, 0x1p+2 },
+{ INT64_C(0xefdfffdffffffffb), -0x1.020002p+60, -0x1.4p+2 },
+{ INT64_C(0x1020002000000010), 0x1.020002p+60, 0x1p+4 },
+{ INT64_C(0xefdfffdfffffffef), -0x1.020002p+60, -0x1.1p+4 },
+{ INT64_C(0x1020002000000080), 0x1.020002p+60, 0x1p+7 },
+{ INT64_C(0xefdfffdfffffff7f), -0x1.0200020000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020002000000100), 0x1.0200020000001p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdffffffeff), -0x1.0200020000001p+60, -0x1p+0 },
+{ INT64_C(0x1020002000000400), 0x1.0200020000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdffffffbff), -0x1.0200020000004p+60, -0x1p+0 },
+{ INT64_C(0x1020002000004000), 0x1.020002000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdfffffbfff), -0x1.020002000004p+60, -0x1p+0 },
+{ INT64_C(0x1020002000020000), 0x1.02000200002p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdffffdffff), -0x1.02000200002p+60, -0x1p+0 },
+{ INT64_C(0x1020002000200000), 0x1.0200020002p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdfffdfffff), -0x1.0200020002p+60, -0x1p+0 },
+{ INT64_C(0x1020002001000000), 0x1.020002001p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdffeffffff), -0x1.020002001p+60, -0x1p+0 },
+{ INT64_C(0x1020002010000000), 0x1.02000201p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdfefffffff), -0x1.02000201p+60, -0x1p+0 },
+{ INT64_C(0x1020002020000000), 0x1.02000202p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdfdfffffff), -0x1.02000202p+60, -0x1p+0 },
+{ INT64_C(0x1020002100000000), 0x1.0200021p+60, 0x0p+0 },
+{ INT64_C(0xefdfffdeffffffff), -0x1.0200021p+60, -0x1p+0 },
+{ INT64_C(0x1020002200000000), 0x1.0200022p+60, 0x0p+0 },
+{ INT64_C(0xefdfffddffffffff), -0x1.0200022p+60, -0x1p+0 },
+{ INT64_C(0x1020003000000000), 0x1.020003p+60, 0x0p+0 },
+{ INT64_C(0xefdfffcfffffffff), -0x1.020003p+60, -0x1p+0 },
+{ INT64_C(0x1020008000000000), 0x1.020008p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7fffffffff), -0x1.020008p+60, -0x1p+0 },
+{ INT64_C(0x1020008000000008), 0x1.020008p+60, 0x1p+3 },
+{ INT64_C(0xefdfff7ffffffff7), -0x1.020008p+60, -0x1.2p+3 },
+{ INT64_C(0x1020008000000020), 0x1.020008p+60, 0x1p+5 },
+{ INT64_C(0xefdfff7fffffffdf), -0x1.020008p+60, -0x1.08p+5 },
+{ INT64_C(0x1020008000000080), 0x1.020008p+60, 0x1p+7 },
+{ INT64_C(0xefdfff7fffffff7f), -0x1.0200080000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020008000000400), 0x1.0200080000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7ffffffbff), -0x1.0200080000004p+60, -0x1p+0 },
+{ INT64_C(0x1020008000004000), 0x1.020008000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7fffffbfff), -0x1.020008000004p+60, -0x1p+0 },
+{ INT64_C(0x1020008000010000), 0x1.02000800001p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7ffffeffff), -0x1.02000800001p+60, -0x1p+0 },
+{ INT64_C(0x1020008000040000), 0x1.02000800004p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7ffffbffff), -0x1.02000800004p+60, -0x1p+0 },
+{ INT64_C(0x1020008000100000), 0x1.0200080001p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7fffefffff), -0x1.0200080001p+60, -0x1p+0 },
+{ INT64_C(0x1020008000400000), 0x1.0200080004p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7fffbfffff), -0x1.0200080004p+60, -0x1p+0 },
+{ INT64_C(0x1020008004000000), 0x1.020008004p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7ffbffffff), -0x1.020008004p+60, -0x1p+0 },
+{ INT64_C(0x1020008010000000), 0x1.02000801p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7fefffffff), -0x1.02000801p+60, -0x1p+0 },
+{ INT64_C(0x1020008020000000), 0x1.02000802p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7fdfffffff), -0x1.02000802p+60, -0x1p+0 },
+{ INT64_C(0x1020008200000000), 0x1.0200082p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7dffffffff), -0x1.0200082p+60, -0x1p+0 },
+{ INT64_C(0x1020008400000000), 0x1.0200084p+60, 0x0p+0 },
+{ INT64_C(0xefdfff7bffffffff), -0x1.0200084p+60, -0x1p+0 },
+{ INT64_C(0x102000a000000000), 0x1.02000ap+60, 0x0p+0 },
+{ INT64_C(0xefdfff5fffffffff), -0x1.02000ap+60, -0x1p+0 },
+{ INT64_C(0x102000c000000000), 0x1.02000cp+60, 0x0p+0 },
+{ INT64_C(0xefdfff3fffffffff), -0x1.02000cp+60, -0x1p+0 },
+{ INT64_C(0x1020040000000000), 0x1.02004p+60, 0x0p+0 },
+{ INT64_C(0xefdffbffffffffff), -0x1.02004p+60, -0x1p+0 },
+{ INT64_C(0x1020040000000008), 0x1.02004p+60, 0x1p+3 },
+{ INT64_C(0xefdffbfffffffff7), -0x1.02004p+60, -0x1.2p+3 },
+{ INT64_C(0x1020040000000040), 0x1.02004p+60, 0x1p+6 },
+{ INT64_C(0xefdffbffffffffbf), -0x1.02004p+60, -0x1.04p+6 },
+{ INT64_C(0x1020040000000080), 0x1.02004p+60, 0x1p+7 },
+{ INT64_C(0xefdffbffffffff7f), -0x1.0200400000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1020040000000100), 0x1.0200400000001p+60, 0x0p+0 },
+{ INT64_C(0xefdffbfffffffeff), -0x1.0200400000001p+60, -0x1p+0 },
+{ INT64_C(0x1020040000001000), 0x1.020040000001p+60, 0x0p+0 },
+{ INT64_C(0xefdffbffffffefff), -0x1.020040000001p+60, -0x1p+0 },
+{ INT64_C(0x1020040000004000), 0x1.020040000004p+60, 0x0p+0 },
+{ INT64_C(0xefdffbffffffbfff), -0x1.020040000004p+60, -0x1p+0 },
+{ INT64_C(0x1020040000040000), 0x1.02004000004p+60, 0x0p+0 },
+{ INT64_C(0xefdffbfffffbffff), -0x1.02004000004p+60, -0x1p+0 },
+{ INT64_C(0x1020040000400000), 0x1.0200400004p+60, 0x0p+0 },
+{ INT64_C(0xefdffbffffbfffff), -0x1.0200400004p+60, -0x1p+0 },
+{ INT64_C(0x1020040000800000), 0x1.0200400008p+60, 0x0p+0 },
+{ INT64_C(0xefdffbffff7fffff), -0x1.0200400008p+60, -0x1p+0 },
+{ INT64_C(0x1020040008000000), 0x1.020040008p+60, 0x0p+0 },
+{ INT64_C(0xefdffbfff7ffffff), -0x1.020040008p+60, -0x1p+0 },
+{ INT64_C(0x1020040080000000), 0x1.02004008p+60, 0x0p+0 },
+{ INT64_C(0xefdffbff7fffffff), -0x1.02004008p+60, -0x1p+0 },
+{ INT64_C(0x1020040100000000), 0x1.0200401p+60, 0x0p+0 },
+{ INT64_C(0xefdffbfeffffffff), -0x1.0200401p+60, -0x1p+0 },
+{ INT64_C(0x1020040400000000), 0x1.0200404p+60, 0x0p+0 },
+{ INT64_C(0xefdffbfbffffffff), -0x1.0200404p+60, -0x1p+0 },
+{ INT64_C(0x1020040800000000), 0x1.0200408p+60, 0x0p+0 },
+{ INT64_C(0xefdffbf7ffffffff), -0x1.0200408p+60, -0x1p+0 },
+{ INT64_C(0x1020048000000000), 0x1.020048p+60, 0x0p+0 },
+{ INT64_C(0xefdffb7fffffffff), -0x1.020048p+60, -0x1p+0 },
+{ INT64_C(0x1020080000000000), 0x1.02008p+60, 0x0p+0 },
+{ INT64_C(0xefdff7ffffffffff), -0x1.02008p+60, -0x1p+0 },
+{ INT64_C(0x1020080000000008), 0x1.02008p+60, 0x1p+3 },
+{ INT64_C(0xefdff7fffffffff7), -0x1.02008p+60, -0x1.2p+3 },
+{ INT64_C(0x1020080000000040), 0x1.02008p+60, 0x1p+6 },
+{ INT64_C(0xefdff7ffffffffbf), -0x1.02008p+60, -0x1.04p+6 },
+{ INT64_C(0x1020080000000100), 0x1.0200800000001p+60, 0x0p+0 },
+{ INT64_C(0xefdff7fffffffeff), -0x1.0200800000001p+60, -0x1p+0 },
+{ INT64_C(0x1020080000000400), 0x1.0200800000004p+60, 0x0p+0 },
+{ INT64_C(0xefdff7fffffffbff), -0x1.0200800000004p+60, -0x1p+0 },
+{ INT64_C(0x1020080000001000), 0x1.020080000001p+60, 0x0p+0 },
+{ INT64_C(0xefdff7ffffffefff), -0x1.020080000001p+60, -0x1p+0 },
+{ INT64_C(0x1020080000008000), 0x1.020080000008p+60, 0x0p+0 },
+{ INT64_C(0xefdff7ffffff7fff), -0x1.020080000008p+60, -0x1p+0 },
+{ INT64_C(0x1020080000040000), 0x1.02008000004p+60, 0x0p+0 },
+{ INT64_C(0xefdff7fffffbffff), -0x1.02008000004p+60, -0x1p+0 },
+{ INT64_C(0x1020080000200000), 0x1.0200800002p+60, 0x0p+0 },
+{ INT64_C(0xefdff7ffffdfffff), -0x1.0200800002p+60, -0x1p+0 },
+{ INT64_C(0x1020080000800000), 0x1.0200800008p+60, 0x0p+0 },
+{ INT64_C(0xefdff7ffff7fffff), -0x1.0200800008p+60, -0x1p+0 },
+{ INT64_C(0x1020080002000000), 0x1.020080002p+60, 0x0p+0 },
+{ INT64_C(0xefdff7fffdffffff), -0x1.020080002p+60, -0x1p+0 },
+{ INT64_C(0x1020080010000000), 0x1.02008001p+60, 0x0p+0 },
+{ INT64_C(0xefdff7ffefffffff), -0x1.02008001p+60, -0x1p+0 },
+{ INT64_C(0x1020080100000000), 0x1.0200801p+60, 0x0p+0 },
+{ INT64_C(0xefdff7feffffffff), -0x1.0200801p+60, -0x1p+0 },
+{ INT64_C(0x1020080200000000), 0x1.0200802p+60, 0x0p+0 },
+{ INT64_C(0xefdff7fdffffffff), -0x1.0200802p+60, -0x1p+0 },
+{ INT64_C(0x1020080800000000), 0x1.0200808p+60, 0x0p+0 },
+{ INT64_C(0xefdff7f7ffffffff), -0x1.0200808p+60, -0x1p+0 },
+{ INT64_C(0x1020081000000000), 0x1.020081p+60, 0x0p+0 },
+{ INT64_C(0xefdff7efffffffff), -0x1.020081p+60, -0x1p+0 },
+{ INT64_C(0x1020082000000000), 0x1.020082p+60, 0x0p+0 },
+{ INT64_C(0xefdff7dfffffffff), -0x1.020082p+60, -0x1p+0 },
+{ INT64_C(0x1020084000000000), 0x1.020084p+60, 0x0p+0 },
+{ INT64_C(0xefdff7bfffffffff), -0x1.020084p+60, -0x1p+0 },
+{ INT64_C(0x1020088000000000), 0x1.020088p+60, 0x0p+0 },
+{ INT64_C(0xefdff77fffffffff), -0x1.020088p+60, -0x1p+0 },
+{ INT64_C(0x10200a0000000000), 0x1.0200ap+60, 0x0p+0 },
+{ INT64_C(0xefdff5ffffffffff), -0x1.0200ap+60, -0x1p+0 },
+{ INT64_C(0x1020100000000000), 0x1.0201p+60, 0x0p+0 },
+{ INT64_C(0xefdfefffffffffff), -0x1.0201p+60, -0x1p+0 },
+{ INT64_C(0x1020100000000004), 0x1.0201p+60, 0x1p+2 },
+{ INT64_C(0xefdfeffffffffffb), -0x1.0201p+60, -0x1.4p+2 },
+{ INT64_C(0x1020100000000008), 0x1.0201p+60, 0x1p+3 },
+{ INT64_C(0xefdfeffffffffff7), -0x1.0201p+60, -0x1.2p+3 },
+{ INT64_C(0x1020100000000020), 0x1.0201p+60, 0x1p+5 },
+{ INT64_C(0xefdfefffffffffdf), -0x1.0201p+60, -0x1.08p+5 },
+{ INT64_C(0x1020100000000200), 0x1.0201000000002p+60, 0x0p+0 },
+{ INT64_C(0xefdfeffffffffdff), -0x1.0201000000002p+60, -0x1p+0 },
+{ INT64_C(0x1020100000000800), 0x1.0201000000008p+60, 0x0p+0 },
+{ INT64_C(0xefdfeffffffff7ff), -0x1.0201000000008p+60, -0x1p+0 },
+{ INT64_C(0x1020100000001000), 0x1.020100000001p+60, 0x0p+0 },
+{ INT64_C(0xefdfefffffffefff), -0x1.020100000001p+60, -0x1p+0 },
+{ INT64_C(0x1020100000010000), 0x1.02010000001p+60, 0x0p+0 },
+{ INT64_C(0xefdfeffffffeffff), -0x1.02010000001p+60, -0x1p+0 },
+{ INT64_C(0x1020100000100000), 0x1.0201000001p+60, 0x0p+0 },
+{ INT64_C(0xefdfefffffefffff), -0x1.0201000001p+60, -0x1p+0 },
+{ INT64_C(0x1020100000200000), 0x1.0201000002p+60, 0x0p+0 },
+{ INT64_C(0xefdfefffffdfffff), -0x1.0201000002p+60, -0x1p+0 },
+{ INT64_C(0x1020100002000000), 0x1.020100002p+60, 0x0p+0 },
+{ INT64_C(0xefdfeffffdffffff), -0x1.020100002p+60, -0x1p+0 },
+{ INT64_C(0x1020100004000000), 0x1.020100004p+60, 0x0p+0 },
+{ INT64_C(0xefdfeffffbffffff), -0x1.020100004p+60, -0x1p+0 },
+{ INT64_C(0x1020100020000000), 0x1.02010002p+60, 0x0p+0 },
+{ INT64_C(0xefdfefffdfffffff), -0x1.02010002p+60, -0x1p+0 },
+{ INT64_C(0x1020100040000000), 0x1.02010004p+60, 0x0p+0 },
+{ INT64_C(0xefdfefffbfffffff), -0x1.02010004p+60, -0x1p+0 },
+{ INT64_C(0x1020100100000000), 0x1.0201001p+60, 0x0p+0 },
+{ INT64_C(0xefdfeffeffffffff), -0x1.0201001p+60, -0x1p+0 },
+{ INT64_C(0x1020101000000000), 0x1.020101p+60, 0x0p+0 },
+{ INT64_C(0xefdfefefffffffff), -0x1.020101p+60, -0x1p+0 },
+{ INT64_C(0x1020108000000000), 0x1.020108p+60, 0x0p+0 },
+{ INT64_C(0xefdfef7fffffffff), -0x1.020108p+60, -0x1p+0 },
+{ INT64_C(0x1020180000000000), 0x1.02018p+60, 0x0p+0 },
+{ INT64_C(0xefdfe7ffffffffff), -0x1.02018p+60, -0x1p+0 },
+{ INT64_C(0x1020200000000000), 0x1.0202p+60, 0x0p+0 },
+{ INT64_C(0xefdfdfffffffffff), -0x1.0202p+60, -0x1p+0 },
+{ INT64_C(0x1020200000000001), 0x1.0202p+60, 0x1p+0 },
+{ INT64_C(0xefdfdffffffffffe), -0x1.0202p+60, -0x1p+1 },
+{ INT64_C(0x1020200000000004), 0x1.0202p+60, 0x1p+2 },
+{ INT64_C(0xefdfdffffffffffb), -0x1.0202p+60, -0x1.4p+2 },
+{ INT64_C(0x1020200000000008), 0x1.0202p+60, 0x1p+3 },
+{ INT64_C(0xefdfdffffffffff7), -0x1.0202p+60, -0x1.2p+3 },
+{ INT64_C(0x1020200000000040), 0x1.0202p+60, 0x1p+6 },
+{ INT64_C(0xefdfdfffffffffbf), -0x1.0202p+60, -0x1.04p+6 },
+{ INT64_C(0x1020200000000100), 0x1.0202000000001p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffffffffeff), -0x1.0202000000001p+60, -0x1p+0 },
+{ INT64_C(0x1020200000000200), 0x1.0202000000002p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffffffffdff), -0x1.0202000000002p+60, -0x1p+0 },
+{ INT64_C(0x1020200000002000), 0x1.020200000002p+60, 0x0p+0 },
+{ INT64_C(0xefdfdfffffffdfff), -0x1.020200000002p+60, -0x1p+0 },
+{ INT64_C(0x1020200000004000), 0x1.020200000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfdfffffffbfff), -0x1.020200000004p+60, -0x1p+0 },
+{ INT64_C(0x1020200000040000), 0x1.02020000004p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffffffbffff), -0x1.02020000004p+60, -0x1p+0 },
+{ INT64_C(0x1020200000100000), 0x1.0202000001p+60, 0x0p+0 },
+{ INT64_C(0xefdfdfffffefffff), -0x1.0202000001p+60, -0x1p+0 },
+{ INT64_C(0x1020200000800000), 0x1.0202000008p+60, 0x0p+0 },
+{ INT64_C(0xefdfdfffff7fffff), -0x1.0202000008p+60, -0x1p+0 },
+{ INT64_C(0x1020200001000000), 0x1.020200001p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffffeffffff), -0x1.020200001p+60, -0x1p+0 },
+{ INT64_C(0x1020200008000000), 0x1.020200008p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffff7ffffff), -0x1.020200008p+60, -0x1p+0 },
+{ INT64_C(0x1020200040000000), 0x1.02020004p+60, 0x0p+0 },
+{ INT64_C(0xefdfdfffbfffffff), -0x1.02020004p+60, -0x1p+0 },
+{ INT64_C(0x1020200100000000), 0x1.0202001p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffeffffffff), -0x1.0202001p+60, -0x1p+0 },
+{ INT64_C(0x1020200200000000), 0x1.0202002p+60, 0x0p+0 },
+{ INT64_C(0xefdfdffdffffffff), -0x1.0202002p+60, -0x1p+0 },
+{ INT64_C(0x1020200800000000), 0x1.0202008p+60, 0x0p+0 },
+{ INT64_C(0xefdfdff7ffffffff), -0x1.0202008p+60, -0x1p+0 },
+{ INT64_C(0x1020208000000000), 0x1.020208p+60, 0x0p+0 },
+{ INT64_C(0xefdfdf7fffffffff), -0x1.020208p+60, -0x1p+0 },
+{ INT64_C(0x1020280000000000), 0x1.02028p+60, 0x0p+0 },
+{ INT64_C(0xefdfd7ffffffffff), -0x1.02028p+60, -0x1p+0 },
+{ INT64_C(0x1020800000000000), 0x1.0208p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffffffffff), -0x1.0208p+60, -0x1p+0 },
+{ INT64_C(0x1020800000000008), 0x1.0208p+60, 0x1p+3 },
+{ INT64_C(0xefdf7ffffffffff7), -0x1.0208p+60, -0x1.2p+3 },
+{ INT64_C(0x1020800000000040), 0x1.0208p+60, 0x1p+6 },
+{ INT64_C(0xefdf7fffffffffbf), -0x1.0208p+60, -0x1.04p+6 },
+{ INT64_C(0x1020800000000100), 0x1.0208000000001p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ffffffffeff), -0x1.0208000000001p+60, -0x1p+0 },
+{ INT64_C(0x1020800000000400), 0x1.0208000000004p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ffffffffbff), -0x1.0208000000004p+60, -0x1p+0 },
+{ INT64_C(0x1020800000001000), 0x1.020800000001p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffffffefff), -0x1.020800000001p+60, -0x1p+0 },
+{ INT64_C(0x1020800000002000), 0x1.020800000002p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffffffdfff), -0x1.020800000002p+60, -0x1p+0 },
+{ INT64_C(0x1020800000004000), 0x1.020800000004p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffffffbfff), -0x1.020800000004p+60, -0x1p+0 },
+{ INT64_C(0x1020800000010000), 0x1.02080000001p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ffffffeffff), -0x1.02080000001p+60, -0x1p+0 },
+{ INT64_C(0x1020800000040000), 0x1.02080000004p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ffffffbffff), -0x1.02080000004p+60, -0x1p+0 },
+{ INT64_C(0x1020800000100000), 0x1.0208000001p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffffefffff), -0x1.0208000001p+60, -0x1p+0 },
+{ INT64_C(0x1020800000800000), 0x1.0208000008p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffff7fffff), -0x1.0208000008p+60, -0x1p+0 },
+{ INT64_C(0x1020800008000000), 0x1.020800008p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ffff7ffffff), -0x1.020800008p+60, -0x1p+0 },
+{ INT64_C(0x1020800010000000), 0x1.02080001p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffefffffff), -0x1.02080001p+60, -0x1p+0 },
+{ INT64_C(0x1020800020000000), 0x1.02080002p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fffdfffffff), -0x1.02080002p+60, -0x1p+0 },
+{ INT64_C(0x1020800100000000), 0x1.0208001p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ffeffffffff), -0x1.0208001p+60, -0x1p+0 },
+{ INT64_C(0x1020800800000000), 0x1.0208008p+60, 0x0p+0 },
+{ INT64_C(0xefdf7ff7ffffffff), -0x1.0208008p+60, -0x1p+0 },
+{ INT64_C(0x1020804000000000), 0x1.020804p+60, 0x0p+0 },
+{ INT64_C(0xefdf7fbfffffffff), -0x1.020804p+60, -0x1p+0 },
+{ INT64_C(0x1020810000000000), 0x1.02081p+60, 0x0p+0 },
+{ INT64_C(0xefdf7effffffffff), -0x1.02081p+60, -0x1p+0 },
+{ INT64_C(0x1020820000000000), 0x1.02082p+60, 0x0p+0 },
+{ INT64_C(0xefdf7dffffffffff), -0x1.02082p+60, -0x1p+0 },
+{ INT64_C(0x1020a00000000000), 0x1.020ap+60, 0x0p+0 },
+{ INT64_C(0xefdf5fffffffffff), -0x1.020ap+60, -0x1p+0 },
+{ INT64_C(0x1024000000000000), 0x1.024p+60, 0x0p+0 },
+{ INT64_C(0xefdbffffffffffff), -0x1.024p+60, -0x1p+0 },
+{ INT64_C(0x1024000000000004), 0x1.024p+60, 0x1p+2 },
+{ INT64_C(0xefdbfffffffffffb), -0x1.024p+60, -0x1.4p+2 },
+{ INT64_C(0x1024000000000020), 0x1.024p+60, 0x1p+5 },
+{ INT64_C(0xefdbffffffffffdf), -0x1.024p+60, -0x1.08p+5 },
+{ INT64_C(0x1024000000000080), 0x1.024p+60, 0x1p+7 },
+{ INT64_C(0xefdbffffffffff7f), -0x1.0240000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1024000000000400), 0x1.0240000000004p+60, 0x0p+0 },
+{ INT64_C(0xefdbfffffffffbff), -0x1.0240000000004p+60, -0x1p+0 },
+{ INT64_C(0x1024000000002000), 0x1.024000000002p+60, 0x0p+0 },
+{ INT64_C(0xefdbffffffffdfff), -0x1.024000000002p+60, -0x1p+0 },
+{ INT64_C(0x1024000000010000), 0x1.02400000001p+60, 0x0p+0 },
+{ INT64_C(0xefdbfffffffeffff), -0x1.02400000001p+60, -0x1p+0 },
+{ INT64_C(0x1024000000040000), 0x1.02400000004p+60, 0x0p+0 },
+{ INT64_C(0xefdbfffffffbffff), -0x1.02400000004p+60, -0x1p+0 },
+{ INT64_C(0x1024000000400000), 0x1.0240000004p+60, 0x0p+0 },
+{ INT64_C(0xefdbffffffbfffff), -0x1.0240000004p+60, -0x1p+0 },
+{ INT64_C(0x1024000001000000), 0x1.024000001p+60, 0x0p+0 },
+{ INT64_C(0xefdbfffffeffffff), -0x1.024000001p+60, -0x1p+0 },
+{ INT64_C(0x1024000008000000), 0x1.024000008p+60, 0x0p+0 },
+{ INT64_C(0xefdbfffff7ffffff), -0x1.024000008p+60, -0x1p+0 },
+{ INT64_C(0x1024000080000000), 0x1.02400008p+60, 0x0p+0 },
+{ INT64_C(0xefdbffff7fffffff), -0x1.02400008p+60, -0x1p+0 },
+{ INT64_C(0x1024000800000000), 0x1.0240008p+60, 0x0p+0 },
+{ INT64_C(0xefdbfff7ffffffff), -0x1.0240008p+60, -0x1p+0 },
+{ INT64_C(0x1024008000000000), 0x1.024008p+60, 0x0p+0 },
+{ INT64_C(0xefdbff7fffffffff), -0x1.024008p+60, -0x1p+0 },
+{ INT64_C(0x1024020000000000), 0x1.02402p+60, 0x0p+0 },
+{ INT64_C(0xefdbfdffffffffff), -0x1.02402p+60, -0x1p+0 },
+{ INT64_C(0x1024100000000000), 0x1.0241p+60, 0x0p+0 },
+{ INT64_C(0xefdbefffffffffff), -0x1.0241p+60, -0x1p+0 },
+{ INT64_C(0x1024400000000000), 0x1.0244p+60, 0x0p+0 },
+{ INT64_C(0xefdbbfffffffffff), -0x1.0244p+60, -0x1p+0 },
+{ INT64_C(0x1100000000000008), 0x1.1p+60, 0x1p+3 },
+{ INT64_C(0xeefffffffffffff7), -0x1.1p+60, -0x1.2p+3 },
+{ INT64_C(0x110000000000000c), 0x1.1p+60, 0x1.8p+3 },
+{ INT64_C(0xeefffffffffffff3), -0x1.1p+60, -0x1.ap+3 },
+{ INT64_C(0x1100000000000020), 0x1.1p+60, 0x1p+5 },
+{ INT64_C(0xeeffffffffffffdf), -0x1.1p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000000000024), 0x1.1p+60, 0x1.2p+5 },
+{ INT64_C(0xeeffffffffffffdb), -0x1.1p+60, -0x1.28p+5 },
+{ INT64_C(0x1100000000000028), 0x1.1p+60, 0x1.4p+5 },
+{ INT64_C(0xeeffffffffffffd7), -0x1.1p+60, -0x1.48p+5 },
+{ INT64_C(0x1100000000000100), 0x1.1000000000001p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffffeff), -0x1.1000000000001p+60, -0x1p+0 },
+{ INT64_C(0x1100000000000104), 0x1.1000000000001p+60, 0x1p+2 },
+{ INT64_C(0xeefffffffffffefb), -0x1.1000000000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000000000140), 0x1.1000000000001p+60, 0x1p+6 },
+{ INT64_C(0xeefffffffffffebf), -0x1.1000000000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1100000000000180), 0x1.1000000000002p+60, -0x1p+7 },
+{ INT64_C(0xeefffffffffffe7f), -0x1.1000000000002p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100000000000200), 0x1.1000000000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffffdff), -0x1.1000000000002p+60, -0x1p+0 },
+{ INT64_C(0x1100000000000204), 0x1.1000000000002p+60, 0x1p+2 },
+{ INT64_C(0xeefffffffffffdfb), -0x1.1000000000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000000000220), 0x1.1000000000002p+60, 0x1p+5 },
+{ INT64_C(0xeefffffffffffddf), -0x1.1000000000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000000000280), 0x1.1000000000002p+60, 0x1p+7 },
+{ INT64_C(0xeefffffffffffd7f), -0x1.1000000000003p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100000000000800), 0x1.1000000000008p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffff7ff), -0x1.1000000000008p+60, -0x1p+0 },
+{ INT64_C(0x1100000000000801), 0x1.1000000000008p+60, 0x1p+0 },
+{ INT64_C(0xeefffffffffff7fe), -0x1.1000000000008p+60, -0x1p+1 },
+{ INT64_C(0x1100000000000810), 0x1.1000000000008p+60, 0x1p+4 },
+{ INT64_C(0xeefffffffffff7ef), -0x1.1000000000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1100000000000820), 0x1.1000000000008p+60, 0x1p+5 },
+{ INT64_C(0xeefffffffffff7df), -0x1.1000000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000000000880), 0x1.1000000000008p+60, 0x1p+7 },
+{ INT64_C(0xeefffffffffff77f), -0x1.1000000000009p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100000000000900), 0x1.1000000000009p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffff6ff), -0x1.1000000000009p+60, -0x1p+0 },
+{ INT64_C(0x1100000000001000), 0x1.100000000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffffefff), -0x1.100000000001p+60, -0x1p+0 },
+{ INT64_C(0x1100000000001001), 0x1.100000000001p+60, 0x1p+0 },
+{ INT64_C(0xeeffffffffffeffe), -0x1.100000000001p+60, -0x1p+1 },
+{ INT64_C(0x1100000000001004), 0x1.100000000001p+60, 0x1p+2 },
+{ INT64_C(0xeeffffffffffeffb), -0x1.100000000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000000001020), 0x1.100000000001p+60, 0x1p+5 },
+{ INT64_C(0xeeffffffffffefdf), -0x1.100000000001p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000000001080), 0x1.100000000001p+60, 0x1p+7 },
+{ INT64_C(0xeeffffffffffef7f), -0x1.1000000000011p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100000000001800), 0x1.1000000000018p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffffe7ff), -0x1.1000000000018p+60, -0x1p+0 },
+{ INT64_C(0x1100000000002000), 0x1.100000000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffffdfff), -0x1.100000000002p+60, -0x1p+0 },
+{ INT64_C(0x1100000000002002), 0x1.100000000002p+60, 0x1p+1 },
+{ INT64_C(0xeeffffffffffdffd), -0x1.100000000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1100000000002008), 0x1.100000000002p+60, 0x1p+3 },
+{ INT64_C(0xeeffffffffffdff7), -0x1.100000000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1100000000002040), 0x1.100000000002p+60, 0x1p+6 },
+{ INT64_C(0xeeffffffffffdfbf), -0x1.100000000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1100000000002200), 0x1.1000000000022p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffffddff), -0x1.1000000000022p+60, -0x1p+0 },
+{ INT64_C(0x1100000000002400), 0x1.1000000000024p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffffdbff), -0x1.1000000000024p+60, -0x1p+0 },
+{ INT64_C(0x1100000000002800), 0x1.1000000000028p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffffd7ff), -0x1.1000000000028p+60, -0x1p+0 },
+{ INT64_C(0x1100000000020000), 0x1.10000000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffdffff), -0x1.10000000002p+60, -0x1p+0 },
+{ INT64_C(0x1100000000020004), 0x1.10000000002p+60, 0x1p+2 },
+{ INT64_C(0xeefffffffffdfffb), -0x1.10000000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000000020008), 0x1.10000000002p+60, 0x1p+3 },
+{ INT64_C(0xeefffffffffdfff7), -0x1.10000000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1100000000020040), 0x1.10000000002p+60, 0x1p+6 },
+{ INT64_C(0xeefffffffffdffbf), -0x1.10000000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1100000000020200), 0x1.1000000000202p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffdfdff), -0x1.1000000000202p+60, -0x1p+0 },
+{ INT64_C(0x1100000000020400), 0x1.1000000000204p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffdfbff), -0x1.1000000000204p+60, -0x1p+0 },
+{ INT64_C(0x1100000000022000), 0x1.100000000022p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffffddfff), -0x1.100000000022p+60, -0x1p+0 },
+{ INT64_C(0x1100000000100000), 0x1.1000000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffefffff), -0x1.1000000001p+60, -0x1p+0 },
+{ INT64_C(0x1100000000100001), 0x1.1000000001p+60, 0x1p+0 },
+{ INT64_C(0xeeffffffffeffffe), -0x1.1000000001p+60, -0x1p+1 },
+{ INT64_C(0x1100000000100010), 0x1.1000000001p+60, 0x1p+4 },
+{ INT64_C(0xeeffffffffefffef), -0x1.1000000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1100000000100020), 0x1.1000000001p+60, 0x1p+5 },
+{ INT64_C(0xeeffffffffefffdf), -0x1.1000000001p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000000100200), 0x1.1000000001002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffeffdff), -0x1.1000000001002p+60, -0x1p+0 },
+{ INT64_C(0x1100000000102000), 0x1.100000000102p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffefdfff), -0x1.100000000102p+60, -0x1p+0 },
+{ INT64_C(0x1100000000120000), 0x1.10000000012p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffedffff), -0x1.10000000012p+60, -0x1p+0 },
+{ INT64_C(0x1100000000180000), 0x1.10000000018p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffffe7ffff), -0x1.10000000018p+60, -0x1p+0 },
+{ INT64_C(0x1100000001000000), 0x1.100000001p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffeffffff), -0x1.100000001p+60, -0x1p+0 },
+{ INT64_C(0x1100000001000004), 0x1.100000001p+60, 0x1p+2 },
+{ INT64_C(0xeefffffffefffffb), -0x1.100000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000001000040), 0x1.100000001p+60, 0x1p+6 },
+{ INT64_C(0xeefffffffeffffbf), -0x1.100000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1100000001000200), 0x1.1000000010002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffefffdff), -0x1.1000000010002p+60, -0x1p+0 },
+{ INT64_C(0x1100000001002000), 0x1.100000001002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffeffdfff), -0x1.100000001002p+60, -0x1p+0 },
+{ INT64_C(0x1100000001004000), 0x1.100000001004p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffeffbfff), -0x1.100000001004p+60, -0x1p+0 },
+{ INT64_C(0x1100000001010000), 0x1.10000000101p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffefeffff), -0x1.10000000101p+60, -0x1p+0 },
+{ INT64_C(0x1100000001080000), 0x1.10000000108p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffef7ffff), -0x1.10000000108p+60, -0x1p+0 },
+{ INT64_C(0x1100000001200000), 0x1.1000000012p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffedfffff), -0x1.1000000012p+60, -0x1p+0 },
+{ INT64_C(0x1100000001400000), 0x1.1000000014p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffebfffff), -0x1.1000000014p+60, -0x1p+0 },
+{ INT64_C(0x1100000001800000), 0x1.1000000018p+60, 0x0p+0 },
+{ INT64_C(0xeefffffffe7fffff), -0x1.1000000018p+60, -0x1p+0 },
+{ INT64_C(0x1100000010000000), 0x1.10000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffefffffff), -0x1.10000001p+60, -0x1p+0 },
+{ INT64_C(0x1100000010000001), 0x1.10000001p+60, 0x1p+0 },
+{ INT64_C(0xeeffffffeffffffe), -0x1.10000001p+60, -0x1p+1 },
+{ INT64_C(0x1100000010000004), 0x1.10000001p+60, 0x1p+2 },
+{ INT64_C(0xeeffffffeffffffb), -0x1.10000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000010000020), 0x1.10000001p+60, 0x1p+5 },
+{ INT64_C(0xeeffffffefffffdf), -0x1.10000001p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000010000200), 0x1.1000000100002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffeffffdff), -0x1.1000000100002p+60, -0x1p+0 },
+{ INT64_C(0x1100000010000400), 0x1.1000000100004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffeffffbff), -0x1.1000000100004p+60, -0x1p+0 },
+{ INT64_C(0x1100000010002000), 0x1.100000010002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffefffdfff), -0x1.100000010002p+60, -0x1p+0 },
+{ INT64_C(0x1100000010010000), 0x1.10000001001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffeffeffff), -0x1.10000001001p+60, -0x1p+0 },
+{ INT64_C(0x1100000010020000), 0x1.10000001002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffeffdffff), -0x1.10000001002p+60, -0x1p+0 },
+{ INT64_C(0x1100000010080000), 0x1.10000001008p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffeff7ffff), -0x1.10000001008p+60, -0x1p+0 },
+{ INT64_C(0x1100000010800000), 0x1.1000000108p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffef7fffff), -0x1.1000000108p+60, -0x1p+0 },
+{ INT64_C(0x1100000012000000), 0x1.100000012p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffedffffff), -0x1.100000012p+60, -0x1p+0 },
+{ INT64_C(0x1100000020000000), 0x1.10000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdfffffff), -0x1.10000002p+60, -0x1p+0 },
+{ INT64_C(0x1100000020000002), 0x1.10000002p+60, 0x1p+1 },
+{ INT64_C(0xeeffffffdffffffd), -0x1.10000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1100000020000004), 0x1.10000002p+60, 0x1p+2 },
+{ INT64_C(0xeeffffffdffffffb), -0x1.10000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000020000020), 0x1.10000002p+60, 0x1p+5 },
+{ INT64_C(0xeeffffffdfffffdf), -0x1.10000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1100000020000040), 0x1.10000002p+60, 0x1p+6 },
+{ INT64_C(0xeeffffffdfffffbf), -0x1.10000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1100000020000400), 0x1.1000000200004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdffffbff), -0x1.1000000200004p+60, -0x1p+0 },
+{ INT64_C(0x1100000020002000), 0x1.100000020002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdfffdfff), -0x1.100000020002p+60, -0x1p+0 },
+{ INT64_C(0x1100000020008000), 0x1.100000020008p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdfff7fff), -0x1.100000020008p+60, -0x1p+0 },
+{ INT64_C(0x1100000020080000), 0x1.10000002008p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdff7ffff), -0x1.10000002008p+60, -0x1p+0 },
+{ INT64_C(0x1100000020100000), 0x1.1000000201p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdfefffff), -0x1.1000000201p+60, -0x1p+0 },
+{ INT64_C(0x1100000021000000), 0x1.100000021p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffdeffffff), -0x1.100000021p+60, -0x1p+0 },
+{ INT64_C(0x1100000030000000), 0x1.10000003p+60, 0x0p+0 },
+{ INT64_C(0xeeffffffcfffffff), -0x1.10000003p+60, -0x1p+0 },
+{ INT64_C(0x1100000080000000), 0x1.10000008p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7fffffff), -0x1.10000008p+60, -0x1p+0 },
+{ INT64_C(0x1100000080000002), 0x1.10000008p+60, 0x1p+1 },
+{ INT64_C(0xeeffffff7ffffffd), -0x1.10000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1100000080000004), 0x1.10000008p+60, 0x1p+2 },
+{ INT64_C(0xeeffffff7ffffffb), -0x1.10000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1100000080000010), 0x1.10000008p+60, 0x1p+4 },
+{ INT64_C(0xeeffffff7fffffef), -0x1.10000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1100000080000040), 0x1.10000008p+60, 0x1p+6 },
+{ INT64_C(0xeeffffff7fffffbf), -0x1.10000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1100000080000200), 0x1.1000000800002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7ffffdff), -0x1.1000000800002p+60, -0x1p+0 },
+{ INT64_C(0x1100000080001000), 0x1.100000080001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7fffefff), -0x1.100000080001p+60, -0x1p+0 },
+{ INT64_C(0x1100000080010000), 0x1.10000008001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7ffeffff), -0x1.10000008001p+60, -0x1p+0 },
+{ INT64_C(0x1100000080040000), 0x1.10000008004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7ffbffff), -0x1.10000008004p+60, -0x1p+0 },
+{ INT64_C(0x1100000080080000), 0x1.10000008008p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7ff7ffff), -0x1.10000008008p+60, -0x1p+0 },
+{ INT64_C(0x1100000080100000), 0x1.1000000801p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7fefffff), -0x1.1000000801p+60, -0x1p+0 },
+{ INT64_C(0x1100000080800000), 0x1.1000000808p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7f7fffff), -0x1.1000000808p+60, -0x1p+0 },
+{ INT64_C(0x1100000081000000), 0x1.100000081p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7effffff), -0x1.100000081p+60, -0x1p+0 },
+{ INT64_C(0x1100000082000000), 0x1.100000082p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7dffffff), -0x1.100000082p+60, -0x1p+0 },
+{ INT64_C(0x1100000084000000), 0x1.100000084p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff7bffffff), -0x1.100000084p+60, -0x1p+0 },
+{ INT64_C(0x1100000090000000), 0x1.10000009p+60, 0x0p+0 },
+{ INT64_C(0xeeffffff6fffffff), -0x1.10000009p+60, -0x1p+0 },
+{ INT64_C(0x11000000a0000000), 0x1.1000000ap+60, 0x0p+0 },
+{ INT64_C(0xeeffffff5fffffff), -0x1.1000000ap+60, -0x1p+0 },
+{ INT64_C(0x1100000200000000), 0x1.1000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdffffffff), -0x1.1000002p+60, -0x1p+0 },
+{ INT64_C(0x1100000200000008), 0x1.1000002p+60, 0x1p+3 },
+{ INT64_C(0xeefffffdfffffff7), -0x1.1000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1100000200000080), 0x1.1000002p+60, 0x1p+7 },
+{ INT64_C(0xeefffffdffffff7f), -0x1.1000002000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100000200000400), 0x1.1000002000004p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdfffffbff), -0x1.1000002000004p+60, -0x1p+0 },
+{ INT64_C(0x1100000200002000), 0x1.100000200002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdffffdfff), -0x1.100000200002p+60, -0x1p+0 },
+{ INT64_C(0x1100000200004000), 0x1.100000200004p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdffffbfff), -0x1.100000200004p+60, -0x1p+0 },
+{ INT64_C(0x1100000200040000), 0x1.10000020004p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdfffbffff), -0x1.10000020004p+60, -0x1p+0 },
+{ INT64_C(0x1100000200080000), 0x1.10000020008p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdfff7ffff), -0x1.10000020008p+60, -0x1p+0 },
+{ INT64_C(0x1100000200200000), 0x1.1000002002p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdffdfffff), -0x1.1000002002p+60, -0x1p+0 },
+{ INT64_C(0x1100000200400000), 0x1.1000002004p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdffbfffff), -0x1.1000002004p+60, -0x1p+0 },
+{ INT64_C(0x1100000204000000), 0x1.100000204p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdfbffffff), -0x1.100000204p+60, -0x1p+0 },
+{ INT64_C(0x1100000240000000), 0x1.10000024p+60, 0x0p+0 },
+{ INT64_C(0xeefffffdbfffffff), -0x1.10000024p+60, -0x1p+0 },
+{ INT64_C(0x1100000300000000), 0x1.1000003p+60, 0x0p+0 },
+{ INT64_C(0xeefffffcffffffff), -0x1.1000003p+60, -0x1p+0 },
+{ INT64_C(0x1100001000000000), 0x1.100001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffefffffffff), -0x1.100001p+60, -0x1p+0 },
+{ INT64_C(0x1100001000000002), 0x1.100001p+60, 0x1p+1 },
+{ INT64_C(0xeeffffeffffffffd), -0x1.100001p+60, -0x1.8p+1 },
+{ INT64_C(0x1100001000000004), 0x1.100001p+60, 0x1p+2 },
+{ INT64_C(0xeeffffeffffffffb), -0x1.100001p+60, -0x1.4p+2 },
+{ INT64_C(0x1100001000000010), 0x1.100001p+60, 0x1p+4 },
+{ INT64_C(0xeeffffefffffffef), -0x1.100001p+60, -0x1.1p+4 },
+{ INT64_C(0x1100001000000020), 0x1.100001p+60, 0x1p+5 },
+{ INT64_C(0xeeffffefffffffdf), -0x1.100001p+60, -0x1.08p+5 },
+{ INT64_C(0x1100001000000100), 0x1.1000010000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffeffffffeff), -0x1.1000010000001p+60, -0x1p+0 },
+{ INT64_C(0x1100001000000400), 0x1.1000010000004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffeffffffbff), -0x1.1000010000004p+60, -0x1p+0 },
+{ INT64_C(0x1100001000000800), 0x1.1000010000008p+60, 0x0p+0 },
+{ INT64_C(0xeeffffeffffff7ff), -0x1.1000010000008p+60, -0x1p+0 },
+{ INT64_C(0x1100001000002000), 0x1.100001000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffffefffffdfff), -0x1.100001000002p+60, -0x1p+0 },
+{ INT64_C(0x1100001000004000), 0x1.100001000004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffefffffbfff), -0x1.100001000004p+60, -0x1p+0 },
+{ INT64_C(0x1100001000040000), 0x1.10000100004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffeffffbffff), -0x1.10000100004p+60, -0x1p+0 },
+{ INT64_C(0x1100001000100000), 0x1.1000010001p+60, 0x0p+0 },
+{ INT64_C(0xeeffffefffefffff), -0x1.1000010001p+60, -0x1p+0 },
+{ INT64_C(0x1100001000400000), 0x1.1000010004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffefffbfffff), -0x1.1000010004p+60, -0x1p+0 },
+{ INT64_C(0x1100001004000000), 0x1.100001004p+60, 0x0p+0 },
+{ INT64_C(0xeeffffeffbffffff), -0x1.100001004p+60, -0x1p+0 },
+{ INT64_C(0x1100001020000000), 0x1.10000102p+60, 0x0p+0 },
+{ INT64_C(0xeeffffefdfffffff), -0x1.10000102p+60, -0x1p+0 },
+{ INT64_C(0x1100001200000000), 0x1.1000012p+60, 0x0p+0 },
+{ INT64_C(0xeeffffedffffffff), -0x1.1000012p+60, -0x1p+0 },
+{ INT64_C(0x1100010000000000), 0x1.10001p+60, 0x0p+0 },
+{ INT64_C(0xeefffeffffffffff), -0x1.10001p+60, -0x1p+0 },
+{ INT64_C(0x1100010000000002), 0x1.10001p+60, 0x1p+1 },
+{ INT64_C(0xeefffefffffffffd), -0x1.10001p+60, -0x1.8p+1 },
+{ INT64_C(0x1100010000000020), 0x1.10001p+60, 0x1p+5 },
+{ INT64_C(0xeefffeffffffffdf), -0x1.10001p+60, -0x1.08p+5 },
+{ INT64_C(0x1100010000000040), 0x1.10001p+60, 0x1p+6 },
+{ INT64_C(0xeefffeffffffffbf), -0x1.10001p+60, -0x1.04p+6 },
+{ INT64_C(0x1100010000000200), 0x1.1000100000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffefffffffdff), -0x1.1000100000002p+60, -0x1p+0 },
+{ INT64_C(0x1100010000001000), 0x1.100010000001p+60, 0x0p+0 },
+{ INT64_C(0xeefffeffffffefff), -0x1.100010000001p+60, -0x1p+0 },
+{ INT64_C(0x1100010000002000), 0x1.100010000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffeffffffdfff), -0x1.100010000002p+60, -0x1p+0 },
+{ INT64_C(0x1100010000020000), 0x1.10001000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffefffffdffff), -0x1.10001000002p+60, -0x1p+0 },
+{ INT64_C(0x1100010000200000), 0x1.1000100002p+60, 0x0p+0 },
+{ INT64_C(0xeefffeffffdfffff), -0x1.1000100002p+60, -0x1p+0 },
+{ INT64_C(0x1100010000800000), 0x1.1000100008p+60, 0x0p+0 },
+{ INT64_C(0xeefffeffff7fffff), -0x1.1000100008p+60, -0x1p+0 },
+{ INT64_C(0x1100010008000000), 0x1.100010008p+60, 0x0p+0 },
+{ INT64_C(0xeefffefff7ffffff), -0x1.100010008p+60, -0x1p+0 },
+{ INT64_C(0x1100010080000000), 0x1.10001008p+60, 0x0p+0 },
+{ INT64_C(0xeefffeff7fffffff), -0x1.10001008p+60, -0x1p+0 },
+{ INT64_C(0x1100010400000000), 0x1.1000104p+60, 0x0p+0 },
+{ INT64_C(0xeefffefbffffffff), -0x1.1000104p+60, -0x1p+0 },
+{ INT64_C(0x1100011000000000), 0x1.100011p+60, 0x0p+0 },
+{ INT64_C(0xeefffeefffffffff), -0x1.100011p+60, -0x1p+0 },
+{ INT64_C(0x1100020000000000), 0x1.10002p+60, 0x0p+0 },
+{ INT64_C(0xeefffdffffffffff), -0x1.10002p+60, -0x1p+0 },
+{ INT64_C(0x1100020000000004), 0x1.10002p+60, 0x1p+2 },
+{ INT64_C(0xeefffdfffffffffb), -0x1.10002p+60, -0x1.4p+2 },
+{ INT64_C(0x1100020000000008), 0x1.10002p+60, 0x1p+3 },
+{ INT64_C(0xeefffdfffffffff7), -0x1.10002p+60, -0x1.2p+3 },
+{ INT64_C(0x1100020000000010), 0x1.10002p+60, 0x1p+4 },
+{ INT64_C(0xeefffdffffffffef), -0x1.10002p+60, -0x1.1p+4 },
+{ INT64_C(0x1100020000000020), 0x1.10002p+60, 0x1p+5 },
+{ INT64_C(0xeefffdffffffffdf), -0x1.10002p+60, -0x1.08p+5 },
+{ INT64_C(0x1100020000000080), 0x1.10002p+60, 0x1p+7 },
+{ INT64_C(0xeefffdffffffff7f), -0x1.1000200000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100020000000100), 0x1.1000200000001p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfffffffeff), -0x1.1000200000001p+60, -0x1p+0 },
+{ INT64_C(0x1100020000000400), 0x1.1000200000004p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfffffffbff), -0x1.1000200000004p+60, -0x1p+0 },
+{ INT64_C(0x1100020000001000), 0x1.100020000001p+60, 0x0p+0 },
+{ INT64_C(0xeefffdffffffefff), -0x1.100020000001p+60, -0x1p+0 },
+{ INT64_C(0x1100020000002000), 0x1.100020000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffdffffffdfff), -0x1.100020000002p+60, -0x1p+0 },
+{ INT64_C(0x1100020000008000), 0x1.100020000008p+60, 0x0p+0 },
+{ INT64_C(0xeefffdffffff7fff), -0x1.100020000008p+60, -0x1p+0 },
+{ INT64_C(0x1100020000010000), 0x1.10002000001p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfffffeffff), -0x1.10002000001p+60, -0x1p+0 },
+{ INT64_C(0x1100020000020000), 0x1.10002000002p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfffffdffff), -0x1.10002000002p+60, -0x1p+0 },
+{ INT64_C(0x1100020000200000), 0x1.1000200002p+60, 0x0p+0 },
+{ INT64_C(0xeefffdffffdfffff), -0x1.1000200002p+60, -0x1p+0 },
+{ INT64_C(0x1100020000800000), 0x1.1000200008p+60, 0x0p+0 },
+{ INT64_C(0xeefffdffff7fffff), -0x1.1000200008p+60, -0x1p+0 },
+{ INT64_C(0x1100020008000000), 0x1.100020008p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfff7ffffff), -0x1.100020008p+60, -0x1p+0 },
+{ INT64_C(0x1100020080000000), 0x1.10002008p+60, 0x0p+0 },
+{ INT64_C(0xeefffdff7fffffff), -0x1.10002008p+60, -0x1p+0 },
+{ INT64_C(0x1100020100000000), 0x1.1000201p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfeffffffff), -0x1.1000201p+60, -0x1p+0 },
+{ INT64_C(0x1100020400000000), 0x1.1000204p+60, 0x0p+0 },
+{ INT64_C(0xeefffdfbffffffff), -0x1.1000204p+60, -0x1p+0 },
+{ INT64_C(0x1100021000000000), 0x1.100021p+60, 0x0p+0 },
+{ INT64_C(0xeefffdefffffffff), -0x1.100021p+60, -0x1p+0 },
+{ INT64_C(0x1100028000000000), 0x1.100028p+60, 0x0p+0 },
+{ INT64_C(0xeefffd7fffffffff), -0x1.100028p+60, -0x1p+0 },
+{ INT64_C(0x1100100000000000), 0x1.1001p+60, 0x0p+0 },
+{ INT64_C(0xeeffefffffffffff), -0x1.1001p+60, -0x1p+0 },
+{ INT64_C(0x1100100000000001), 0x1.1001p+60, 0x1p+0 },
+{ INT64_C(0xeeffeffffffffffe), -0x1.1001p+60, -0x1p+1 },
+{ INT64_C(0x1100100000000010), 0x1.1001p+60, 0x1p+4 },
+{ INT64_C(0xeeffefffffffffef), -0x1.1001p+60, -0x1.1p+4 },
+{ INT64_C(0x1100100000000080), 0x1.1001p+60, 0x1p+7 },
+{ INT64_C(0xeeffefffffffff7f), -0x1.1001000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1100100000000100), 0x1.1001000000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffeffffffffeff), -0x1.1001000000001p+60, -0x1p+0 },
+{ INT64_C(0x1100100000000400), 0x1.1001000000004p+60, 0x0p+0 },
+{ INT64_C(0xeeffeffffffffbff), -0x1.1001000000004p+60, -0x1p+0 },
+{ INT64_C(0x1100100000002000), 0x1.100100000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffefffffffdfff), -0x1.100100000002p+60, -0x1p+0 },
+{ INT64_C(0x1100100000020000), 0x1.10010000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffeffffffdffff), -0x1.10010000002p+60, -0x1p+0 },
+{ INT64_C(0x1100100000100000), 0x1.1001000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffefffffefffff), -0x1.1001000001p+60, -0x1p+0 },
+{ INT64_C(0x1100100000800000), 0x1.1001000008p+60, 0x0p+0 },
+{ INT64_C(0xeeffefffff7fffff), -0x1.1001000008p+60, -0x1p+0 },
+{ INT64_C(0x1100100004000000), 0x1.100100004p+60, 0x0p+0 },
+{ INT64_C(0xeeffeffffbffffff), -0x1.100100004p+60, -0x1p+0 },
+{ INT64_C(0x1100100020000000), 0x1.10010002p+60, 0x0p+0 },
+{ INT64_C(0xeeffefffdfffffff), -0x1.10010002p+60, -0x1p+0 },
+{ INT64_C(0x1100100200000000), 0x1.1001002p+60, 0x0p+0 },
+{ INT64_C(0xeeffeffdffffffff), -0x1.1001002p+60, -0x1p+0 },
+{ INT64_C(0x1100100400000000), 0x1.1001004p+60, 0x0p+0 },
+{ INT64_C(0xeeffeffbffffffff), -0x1.1001004p+60, -0x1p+0 },
+{ INT64_C(0x1100100800000000), 0x1.1001008p+60, 0x0p+0 },
+{ INT64_C(0xeeffeff7ffffffff), -0x1.1001008p+60, -0x1p+0 },
+{ INT64_C(0x1100102000000000), 0x1.100102p+60, 0x0p+0 },
+{ INT64_C(0xeeffefdfffffffff), -0x1.100102p+60, -0x1p+0 },
+{ INT64_C(0x1100110000000000), 0x1.10011p+60, 0x0p+0 },
+{ INT64_C(0xeeffeeffffffffff), -0x1.10011p+60, -0x1p+0 },
+{ INT64_C(0x1100140000000000), 0x1.10014p+60, 0x0p+0 },
+{ INT64_C(0xeeffebffffffffff), -0x1.10014p+60, -0x1p+0 },
+{ INT64_C(0x1100180000000000), 0x1.10018p+60, 0x0p+0 },
+{ INT64_C(0xeeffe7ffffffffff), -0x1.10018p+60, -0x1p+0 },
+{ INT64_C(0x1100400000000000), 0x1.1004p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfffffffffff), -0x1.1004p+60, -0x1p+0 },
+{ INT64_C(0x1100400000000008), 0x1.1004p+60, 0x1p+3 },
+{ INT64_C(0xeeffbffffffffff7), -0x1.1004p+60, -0x1.2p+3 },
+{ INT64_C(0x1100400000000040), 0x1.1004p+60, 0x1p+6 },
+{ INT64_C(0xeeffbfffffffffbf), -0x1.1004p+60, -0x1.04p+6 },
+{ INT64_C(0x1100400000000100), 0x1.1004000000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffbffffffffeff), -0x1.1004000000001p+60, -0x1p+0 },
+{ INT64_C(0x1100400000000200), 0x1.1004000000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffbffffffffdff), -0x1.1004000000002p+60, -0x1p+0 },
+{ INT64_C(0x1100400000002000), 0x1.100400000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfffffffdfff), -0x1.100400000002p+60, -0x1p+0 },
+{ INT64_C(0x1100400000004000), 0x1.100400000004p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfffffffbfff), -0x1.100400000004p+60, -0x1p+0 },
+{ INT64_C(0x1100400000020000), 0x1.10040000002p+60, 0x0p+0 },
+{ INT64_C(0xeeffbffffffdffff), -0x1.10040000002p+60, -0x1p+0 },
+{ INT64_C(0x1100400000100000), 0x1.1004000001p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfffffefffff), -0x1.1004000001p+60, -0x1p+0 },
+{ INT64_C(0x1100400000800000), 0x1.1004000008p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfffff7fffff), -0x1.1004000008p+60, -0x1p+0 },
+{ INT64_C(0x1100400001000000), 0x1.100400001p+60, 0x0p+0 },
+{ INT64_C(0xeeffbffffeffffff), -0x1.100400001p+60, -0x1p+0 },
+{ INT64_C(0x1100400010000000), 0x1.10040001p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfffefffffff), -0x1.10040001p+60, -0x1p+0 },
+{ INT64_C(0x1100400100000000), 0x1.1004001p+60, 0x0p+0 },
+{ INT64_C(0xeeffbffeffffffff), -0x1.1004001p+60, -0x1p+0 },
+{ INT64_C(0x1100400400000000), 0x1.1004004p+60, 0x0p+0 },
+{ INT64_C(0xeeffbffbffffffff), -0x1.1004004p+60, -0x1p+0 },
+{ INT64_C(0x1100401000000000), 0x1.100401p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfefffffffff), -0x1.100401p+60, -0x1p+0 },
+{ INT64_C(0x1100402000000000), 0x1.100402p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfdfffffffff), -0x1.100402p+60, -0x1p+0 },
+{ INT64_C(0x1100404000000000), 0x1.100404p+60, 0x0p+0 },
+{ INT64_C(0xeeffbfbfffffffff), -0x1.100404p+60, -0x1p+0 },
+{ INT64_C(0x1100440000000000), 0x1.10044p+60, 0x0p+0 },
+{ INT64_C(0xeeffbbffffffffff), -0x1.10044p+60, -0x1p+0 },
+{ INT64_C(0x1100600000000000), 0x1.1006p+60, 0x0p+0 },
+{ INT64_C(0xeeff9fffffffffff), -0x1.1006p+60, -0x1p+0 },
+{ INT64_C(0x1101000000000000), 0x1.101p+60, 0x0p+0 },
+{ INT64_C(0xeefeffffffffffff), -0x1.101p+60, -0x1p+0 },
+{ INT64_C(0x1101000000000004), 0x1.101p+60, 0x1p+2 },
+{ INT64_C(0xeefefffffffffffb), -0x1.101p+60, -0x1.4p+2 },
+{ INT64_C(0x1101000000000010), 0x1.101p+60, 0x1p+4 },
+{ INT64_C(0xeefeffffffffffef), -0x1.101p+60, -0x1.1p+4 },
+{ INT64_C(0x1101000000000100), 0x1.1010000000001p+60, 0x0p+0 },
+{ INT64_C(0xeefefffffffffeff), -0x1.1010000000001p+60, -0x1p+0 },
+{ INT64_C(0x1101000000001000), 0x1.101000000001p+60, 0x0p+0 },
+{ INT64_C(0xeefeffffffffefff), -0x1.101000000001p+60, -0x1p+0 },
+{ INT64_C(0x1101000000002000), 0x1.101000000002p+60, 0x0p+0 },
+{ INT64_C(0xeefeffffffffdfff), -0x1.101000000002p+60, -0x1p+0 },
+{ INT64_C(0x1101000000020000), 0x1.10100000002p+60, 0x0p+0 },
+{ INT64_C(0xeefefffffffdffff), -0x1.10100000002p+60, -0x1p+0 },
+{ INT64_C(0x1101000000080000), 0x1.10100000008p+60, 0x0p+0 },
+{ INT64_C(0xeefefffffff7ffff), -0x1.10100000008p+60, -0x1p+0 },
+{ INT64_C(0x1101000000100000), 0x1.1010000001p+60, 0x0p+0 },
+{ INT64_C(0xeefeffffffefffff), -0x1.1010000001p+60, -0x1p+0 },
+{ INT64_C(0x1101000000400000), 0x1.1010000004p+60, 0x0p+0 },
+{ INT64_C(0xeefeffffffbfffff), -0x1.1010000004p+60, -0x1p+0 },
+{ INT64_C(0x1101000000800000), 0x1.1010000008p+60, 0x0p+0 },
+{ INT64_C(0xeefeffffff7fffff), -0x1.1010000008p+60, -0x1p+0 },
+{ INT64_C(0x1101000001000000), 0x1.101000001p+60, 0x0p+0 },
+{ INT64_C(0xeefefffffeffffff), -0x1.101000001p+60, -0x1p+0 },
+{ INT64_C(0x1101000008000000), 0x1.101000008p+60, 0x0p+0 },
+{ INT64_C(0xeefefffff7ffffff), -0x1.101000008p+60, -0x1p+0 },
+{ INT64_C(0x1101000080000000), 0x1.10100008p+60, 0x0p+0 },
+{ INT64_C(0xeefeffff7fffffff), -0x1.10100008p+60, -0x1p+0 },
+{ INT64_C(0x1101000800000000), 0x1.1010008p+60, 0x0p+0 },
+{ INT64_C(0xeefefff7ffffffff), -0x1.1010008p+60, -0x1p+0 },
+{ INT64_C(0x1101001000000000), 0x1.101001p+60, 0x0p+0 },
+{ INT64_C(0xeefeffefffffffff), -0x1.101001p+60, -0x1p+0 },
+{ INT64_C(0x1101004000000000), 0x1.101004p+60, 0x0p+0 },
+{ INT64_C(0xeefeffbfffffffff), -0x1.101004p+60, -0x1p+0 },
+{ INT64_C(0x1101040000000000), 0x1.10104p+60, 0x0p+0 },
+{ INT64_C(0xeefefbffffffffff), -0x1.10104p+60, -0x1p+0 },
+{ INT64_C(0x1101400000000000), 0x1.1014p+60, 0x0p+0 },
+{ INT64_C(0xeefebfffffffffff), -0x1.1014p+60, -0x1p+0 },
+{ INT64_C(0x1101800000000000), 0x1.1018p+60, 0x0p+0 },
+{ INT64_C(0xeefe7fffffffffff), -0x1.1018p+60, -0x1p+0 },
+{ INT64_C(0x1102000000000000), 0x1.102p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffffffffff), -0x1.102p+60, -0x1p+0 },
+{ INT64_C(0x1102000000000004), 0x1.102p+60, 0x1p+2 },
+{ INT64_C(0xeefdfffffffffffb), -0x1.102p+60, -0x1.4p+2 },
+{ INT64_C(0x1102000000000010), 0x1.102p+60, 0x1p+4 },
+{ INT64_C(0xeefdffffffffffef), -0x1.102p+60, -0x1.1p+4 },
+{ INT64_C(0x1102000000000100), 0x1.1020000000001p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffffffeff), -0x1.1020000000001p+60, -0x1p+0 },
+{ INT64_C(0x1102000000000200), 0x1.1020000000002p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffffffdff), -0x1.1020000000002p+60, -0x1p+0 },
+{ INT64_C(0x1102000000000400), 0x1.1020000000004p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffffffbff), -0x1.1020000000004p+60, -0x1p+0 },
+{ INT64_C(0x1102000000001000), 0x1.102000000001p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffffffefff), -0x1.102000000001p+60, -0x1p+0 },
+{ INT64_C(0x1102000000002000), 0x1.102000000002p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffffffdfff), -0x1.102000000002p+60, -0x1p+0 },
+{ INT64_C(0x1102000000010000), 0x1.10200000001p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffffeffff), -0x1.10200000001p+60, -0x1p+0 },
+{ INT64_C(0x1102000000020000), 0x1.10200000002p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffffdffff), -0x1.10200000002p+60, -0x1p+0 },
+{ INT64_C(0x1102000000100000), 0x1.1020000001p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffffefffff), -0x1.1020000001p+60, -0x1p+0 },
+{ INT64_C(0x1102000000400000), 0x1.1020000004p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffffbfffff), -0x1.1020000004p+60, -0x1p+0 },
+{ INT64_C(0x1102000001000000), 0x1.102000001p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffeffffff), -0x1.102000001p+60, -0x1p+0 },
+{ INT64_C(0x1102000002000000), 0x1.102000002p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffffdffffff), -0x1.102000002p+60, -0x1p+0 },
+{ INT64_C(0x1102000010000000), 0x1.10200001p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffefffffff), -0x1.10200001p+60, -0x1p+0 },
+{ INT64_C(0x1102000040000000), 0x1.10200004p+60, 0x0p+0 },
+{ INT64_C(0xeefdffffbfffffff), -0x1.10200004p+60, -0x1p+0 },
+{ INT64_C(0x1102000100000000), 0x1.1020001p+60, 0x0p+0 },
+{ INT64_C(0xeefdfffeffffffff), -0x1.1020001p+60, -0x1p+0 },
+{ INT64_C(0x1102001000000000), 0x1.102001p+60, 0x0p+0 },
+{ INT64_C(0xeefdffefffffffff), -0x1.102001p+60, -0x1p+0 },
+{ INT64_C(0x1102002000000000), 0x1.102002p+60, 0x0p+0 },
+{ INT64_C(0xeefdffdfffffffff), -0x1.102002p+60, -0x1p+0 },
+{ INT64_C(0x1102020000000000), 0x1.10202p+60, 0x0p+0 },
+{ INT64_C(0xeefdfdffffffffff), -0x1.10202p+60, -0x1p+0 },
+{ INT64_C(0x1102080000000000), 0x1.10208p+60, 0x0p+0 },
+{ INT64_C(0xeefdf7ffffffffff), -0x1.10208p+60, -0x1p+0 },
+{ INT64_C(0x1102800000000000), 0x1.1028p+60, 0x0p+0 },
+{ INT64_C(0xeefd7fffffffffff), -0x1.1028p+60, -0x1p+0 },
+{ INT64_C(0x1120000000000000), 0x1.12p+60, 0x0p+0 },
+{ INT64_C(0xeedfffffffffffff), -0x1.12p+60, -0x1p+0 },
+{ INT64_C(0x1120000000000001), 0x1.12p+60, 0x1p+0 },
+{ INT64_C(0xeedffffffffffffe), -0x1.12p+60, -0x1p+1 },
+{ INT64_C(0x1120000000000008), 0x1.12p+60, 0x1p+3 },
+{ INT64_C(0xeedffffffffffff7), -0x1.12p+60, -0x1.2p+3 },
+{ INT64_C(0x1120000000000040), 0x1.12p+60, 0x1p+6 },
+{ INT64_C(0xeedfffffffffffbf), -0x1.12p+60, -0x1.04p+6 },
+{ INT64_C(0x1120000000000200), 0x1.1200000000002p+60, 0x0p+0 },
+{ INT64_C(0xeedffffffffffdff), -0x1.1200000000002p+60, -0x1p+0 },
+{ INT64_C(0x1120000000000800), 0x1.1200000000008p+60, 0x0p+0 },
+{ INT64_C(0xeedffffffffff7ff), -0x1.1200000000008p+60, -0x1p+0 },
+{ INT64_C(0x1120000000002000), 0x1.120000000002p+60, 0x0p+0 },
+{ INT64_C(0xeedfffffffffdfff), -0x1.120000000002p+60, -0x1p+0 },
+{ INT64_C(0x1120000000004000), 0x1.120000000004p+60, 0x0p+0 },
+{ INT64_C(0xeedfffffffffbfff), -0x1.120000000004p+60, -0x1p+0 },
+{ INT64_C(0x1120000000010000), 0x1.12000000001p+60, 0x0p+0 },
+{ INT64_C(0xeedffffffffeffff), -0x1.12000000001p+60, -0x1p+0 },
+{ INT64_C(0x1120000000020000), 0x1.12000000002p+60, 0x0p+0 },
+{ INT64_C(0xeedffffffffdffff), -0x1.12000000002p+60, -0x1p+0 },
+{ INT64_C(0x1120000000080000), 0x1.12000000008p+60, 0x0p+0 },
+{ INT64_C(0xeedffffffff7ffff), -0x1.12000000008p+60, -0x1p+0 },
+{ INT64_C(0x1120000000400000), 0x1.1200000004p+60, 0x0p+0 },
+{ INT64_C(0xeedfffffffbfffff), -0x1.1200000004p+60, -0x1p+0 },
+{ INT64_C(0x1120000000800000), 0x1.1200000008p+60, 0x0p+0 },
+{ INT64_C(0xeedfffffff7fffff), -0x1.1200000008p+60, -0x1p+0 },
+{ INT64_C(0x1120000001000000), 0x1.120000001p+60, 0x0p+0 },
+{ INT64_C(0xeedffffffeffffff), -0x1.120000001p+60, -0x1p+0 },
+{ INT64_C(0x1120000010000000), 0x1.12000001p+60, 0x0p+0 },
+{ INT64_C(0xeedfffffefffffff), -0x1.12000001p+60, -0x1p+0 },
+{ INT64_C(0x1120000080000000), 0x1.12000008p+60, 0x0p+0 },
+{ INT64_C(0xeedfffff7fffffff), -0x1.12000008p+60, -0x1p+0 },
+{ INT64_C(0x1120000800000000), 0x1.1200008p+60, 0x0p+0 },
+{ INT64_C(0xeedffff7ffffffff), -0x1.1200008p+60, -0x1p+0 },
+{ INT64_C(0x1120001000000000), 0x1.120001p+60, 0x0p+0 },
+{ INT64_C(0xeedfffefffffffff), -0x1.120001p+60, -0x1p+0 },
+{ INT64_C(0x1120010000000000), 0x1.12001p+60, 0x0p+0 },
+{ INT64_C(0xeedffeffffffffff), -0x1.12001p+60, -0x1p+0 },
+{ INT64_C(0x1120020000000000), 0x1.12002p+60, 0x0p+0 },
+{ INT64_C(0xeedffdffffffffff), -0x1.12002p+60, -0x1p+0 },
+{ INT64_C(0x1120200000000000), 0x1.1202p+60, 0x0p+0 },
+{ INT64_C(0xeedfdfffffffffff), -0x1.1202p+60, -0x1p+0 },
+{ INT64_C(0x1120400000000000), 0x1.1204p+60, 0x0p+0 },
+{ INT64_C(0xeedfbfffffffffff), -0x1.1204p+60, -0x1p+0 },
+{ INT64_C(0x1120800000000000), 0x1.1208p+60, 0x0p+0 },
+{ INT64_C(0xeedf7fffffffffff), -0x1.1208p+60, -0x1p+0 },
+{ INT64_C(0x1122000000000000), 0x1.122p+60, 0x0p+0 },
+{ INT64_C(0xeeddffffffffffff), -0x1.122p+60, -0x1p+0 },
+{ INT64_C(0x1130000000000000), 0x1.13p+60, 0x0p+0 },
+{ INT64_C(0xeecfffffffffffff), -0x1.13p+60, -0x1p+0 },
+{ INT64_C(0x1200000000000002), 0x1.2p+60, 0x1p+1 },
+{ INT64_C(0xedfffffffffffffd), -0x1.2p+60, -0x1.8p+1 },
+{ INT64_C(0x1200000000000010), 0x1.2p+60, 0x1p+4 },
+{ INT64_C(0xedffffffffffffef), -0x1.2p+60, -0x1.1p+4 },
+{ INT64_C(0x1200000000000012), 0x1.2p+60, 0x1.2p+4 },
+{ INT64_C(0xedffffffffffffed), -0x1.2p+60, -0x1.3p+4 },
+{ INT64_C(0x1200000000000040), 0x1.2p+60, 0x1p+6 },
+{ INT64_C(0xedffffffffffffbf), -0x1.2p+60, -0x1.04p+6 },
+{ INT64_C(0x1200000000000044), 0x1.2p+60, 0x1.1p+6 },
+{ INT64_C(0xedffffffffffffbb), -0x1.2p+60, -0x1.14p+6 },
+{ INT64_C(0x1200000000000080), 0x1.2p+60, 0x1p+7 },
+{ INT64_C(0xedffffffffffff7f), -0x1.2000000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000000000081), 0x1.2000000000001p+60, -0x1.fcp+6 },
+{ INT64_C(0xedffffffffffff7e), -0x1.2000000000001p+60, 0x1.f8p+6 },
+{ INT64_C(0x1200000000000082), 0x1.2000000000001p+60, -0x1.f8p+6 },
+{ INT64_C(0xedffffffffffff7d), -0x1.2000000000001p+60, 0x1.f4p+6 },
+{ INT64_C(0x12000000000000a0), 0x1.2000000000001p+60, -0x1.8p+6 },
+{ INT64_C(0xedffffffffffff5f), -0x1.2000000000001p+60, 0x1.7cp+6 },
+{ INT64_C(0x12000000000000c0), 0x1.2000000000001p+60, -0x1p+6 },
+{ INT64_C(0xedffffffffffff3f), -0x1.2000000000001p+60, 0x1.f8p+5 },
+{ INT64_C(0x1200000000000800), 0x1.2000000000008p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffffff7ff), -0x1.2000000000008p+60, -0x1p+0 },
+{ INT64_C(0x1200000000000804), 0x1.2000000000008p+60, 0x1p+2 },
+{ INT64_C(0xedfffffffffff7fb), -0x1.2000000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000000000808), 0x1.2000000000008p+60, 0x1p+3 },
+{ INT64_C(0xedfffffffffff7f7), -0x1.2000000000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1200000000000810), 0x1.2000000000008p+60, 0x1p+4 },
+{ INT64_C(0xedfffffffffff7ef), -0x1.2000000000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1200000000000880), 0x1.2000000000008p+60, 0x1p+7 },
+{ INT64_C(0xedfffffffffff77f), -0x1.2000000000009p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000000000900), 0x1.2000000000009p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffffff6ff), -0x1.2000000000009p+60, -0x1p+0 },
+{ INT64_C(0x1200000000004000), 0x1.200000000004p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffffbfff), -0x1.200000000004p+60, -0x1p+0 },
+{ INT64_C(0x1200000000004002), 0x1.200000000004p+60, 0x1p+1 },
+{ INT64_C(0xedffffffffffbffd), -0x1.200000000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1200000000004004), 0x1.200000000004p+60, 0x1p+2 },
+{ INT64_C(0xedffffffffffbffb), -0x1.200000000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000000004008), 0x1.200000000004p+60, 0x1p+3 },
+{ INT64_C(0xedffffffffffbff7), -0x1.200000000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1200000000004080), 0x1.200000000004p+60, 0x1p+7 },
+{ INT64_C(0xedffffffffffbf7f), -0x1.2000000000041p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000000004100), 0x1.2000000000041p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffffbeff), -0x1.2000000000041p+60, -0x1p+0 },
+{ INT64_C(0x1200000000004400), 0x1.2000000000044p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffffbbff), -0x1.2000000000044p+60, -0x1p+0 },
+{ INT64_C(0x1200000000006000), 0x1.200000000006p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffff9fff), -0x1.200000000006p+60, -0x1p+0 },
+{ INT64_C(0x1200000000008000), 0x1.200000000008p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffff7fff), -0x1.200000000008p+60, -0x1p+0 },
+{ INT64_C(0x1200000000008004), 0x1.200000000008p+60, 0x1p+2 },
+{ INT64_C(0xedffffffffff7ffb), -0x1.200000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000000008020), 0x1.200000000008p+60, 0x1p+5 },
+{ INT64_C(0xedffffffffff7fdf), -0x1.200000000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1200000000008080), 0x1.200000000008p+60, 0x1p+7 },
+{ INT64_C(0xedffffffffff7f7f), -0x1.2000000000081p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000000008100), 0x1.2000000000081p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffff7eff), -0x1.2000000000081p+60, -0x1p+0 },
+{ INT64_C(0x1200000000008400), 0x1.2000000000084p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffff7bff), -0x1.2000000000084p+60, -0x1p+0 },
+{ INT64_C(0x1200000000009000), 0x1.200000000009p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffff6fff), -0x1.200000000009p+60, -0x1p+0 },
+{ INT64_C(0x1200000000040000), 0x1.20000000004p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffffbffff), -0x1.20000000004p+60, -0x1p+0 },
+{ INT64_C(0x1200000000040001), 0x1.20000000004p+60, 0x1p+0 },
+{ INT64_C(0xedfffffffffbfffe), -0x1.20000000004p+60, -0x1p+1 },
+{ INT64_C(0x1200000000040004), 0x1.20000000004p+60, 0x1p+2 },
+{ INT64_C(0xedfffffffffbfffb), -0x1.20000000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000000040008), 0x1.20000000004p+60, 0x1p+3 },
+{ INT64_C(0xedfffffffffbfff7), -0x1.20000000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1200000000040080), 0x1.20000000004p+60, 0x1p+7 },
+{ INT64_C(0xedfffffffffbff7f), -0x1.2000000000401p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000000040800), 0x1.2000000000408p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffffbf7ff), -0x1.2000000000408p+60, -0x1p+0 },
+{ INT64_C(0x1200000000042000), 0x1.200000000042p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffffbdfff), -0x1.200000000042p+60, -0x1p+0 },
+{ INT64_C(0x1200000000048000), 0x1.200000000048p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffffb7fff), -0x1.200000000048p+60, -0x1p+0 },
+{ INT64_C(0x1200000000200000), 0x1.2000000002p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffdfffff), -0x1.2000000002p+60, -0x1p+0 },
+{ INT64_C(0x1200000000200004), 0x1.2000000002p+60, 0x1p+2 },
+{ INT64_C(0xedffffffffdffffb), -0x1.2000000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000000200020), 0x1.2000000002p+60, 0x1p+5 },
+{ INT64_C(0xedffffffffdfffdf), -0x1.2000000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1200000000200200), 0x1.2000000002002p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffdffdff), -0x1.2000000002002p+60, -0x1p+0 },
+{ INT64_C(0x1200000000202000), 0x1.200000000202p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffdfdfff), -0x1.200000000202p+60, -0x1p+0 },
+{ INT64_C(0x1200000000210000), 0x1.20000000021p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffdeffff), -0x1.20000000021p+60, -0x1p+0 },
+{ INT64_C(0x1200000000280000), 0x1.20000000028p+60, 0x0p+0 },
+{ INT64_C(0xedffffffffd7ffff), -0x1.20000000028p+60, -0x1p+0 },
+{ INT64_C(0x1200000002000000), 0x1.200000002p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffdffffff), -0x1.200000002p+60, -0x1p+0 },
+{ INT64_C(0x1200000002000008), 0x1.200000002p+60, 0x1p+3 },
+{ INT64_C(0xedfffffffdfffff7), -0x1.200000002p+60, -0x1.2p+3 },
+{ INT64_C(0x1200000002000020), 0x1.200000002p+60, 0x1p+5 },
+{ INT64_C(0xedfffffffdffffdf), -0x1.200000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1200000002000080), 0x1.200000002p+60, 0x1p+7 },
+{ INT64_C(0xedfffffffdffff7f), -0x1.2000000020001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000002000400), 0x1.2000000020004p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffdfffbff), -0x1.2000000020004p+60, -0x1p+0 },
+{ INT64_C(0x1200000002002000), 0x1.200000002002p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffdffdfff), -0x1.200000002002p+60, -0x1p+0 },
+{ INT64_C(0x1200000002020000), 0x1.20000000202p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffdfdffff), -0x1.20000000202p+60, -0x1p+0 },
+{ INT64_C(0x1200000002200000), 0x1.2000000022p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffddfffff), -0x1.2000000022p+60, -0x1p+0 },
+{ INT64_C(0x1200000002400000), 0x1.2000000024p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffdbfffff), -0x1.2000000024p+60, -0x1p+0 },
+{ INT64_C(0x1200000003000000), 0x1.200000003p+60, 0x0p+0 },
+{ INT64_C(0xedfffffffcffffff), -0x1.200000003p+60, -0x1p+0 },
+{ INT64_C(0x1200000020000000), 0x1.20000002p+60, 0x0p+0 },
+{ INT64_C(0xedffffffdfffffff), -0x1.20000002p+60, -0x1p+0 },
+{ INT64_C(0x1200000020000001), 0x1.20000002p+60, 0x1p+0 },
+{ INT64_C(0xedffffffdffffffe), -0x1.20000002p+60, -0x1p+1 },
+{ INT64_C(0x1200000020000010), 0x1.20000002p+60, 0x1p+4 },
+{ INT64_C(0xedffffffdfffffef), -0x1.20000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1200000020000040), 0x1.20000002p+60, 0x1p+6 },
+{ INT64_C(0xedffffffdfffffbf), -0x1.20000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1200000020000400), 0x1.2000000200004p+60, 0x0p+0 },
+{ INT64_C(0xedffffffdffffbff), -0x1.2000000200004p+60, -0x1p+0 },
+{ INT64_C(0x1200000020000800), 0x1.2000000200008p+60, 0x0p+0 },
+{ INT64_C(0xedffffffdffff7ff), -0x1.2000000200008p+60, -0x1p+0 },
+{ INT64_C(0x1200000020002000), 0x1.200000020002p+60, 0x0p+0 },
+{ INT64_C(0xedffffffdfffdfff), -0x1.200000020002p+60, -0x1p+0 },
+{ INT64_C(0x1200000020020000), 0x1.20000002002p+60, 0x0p+0 },
+{ INT64_C(0xedffffffdffdffff), -0x1.20000002002p+60, -0x1p+0 },
+{ INT64_C(0x1200000020200000), 0x1.2000000202p+60, 0x0p+0 },
+{ INT64_C(0xedffffffdfdfffff), -0x1.2000000202p+60, -0x1p+0 },
+{ INT64_C(0x1200000022000000), 0x1.200000022p+60, 0x0p+0 },
+{ INT64_C(0xedffffffddffffff), -0x1.200000022p+60, -0x1p+0 },
+{ INT64_C(0x1200000080000000), 0x1.20000008p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7fffffff), -0x1.20000008p+60, -0x1p+0 },
+{ INT64_C(0x1200000080000001), 0x1.20000008p+60, 0x1p+0 },
+{ INT64_C(0xedffffff7ffffffe), -0x1.20000008p+60, -0x1p+1 },
+{ INT64_C(0x1200000080000004), 0x1.20000008p+60, 0x1p+2 },
+{ INT64_C(0xedffffff7ffffffb), -0x1.20000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000080000008), 0x1.20000008p+60, 0x1p+3 },
+{ INT64_C(0xedffffff7ffffff7), -0x1.20000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1200000080000080), 0x1.20000008p+60, 0x1p+7 },
+{ INT64_C(0xedffffff7fffff7f), -0x1.2000000800001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200000080000100), 0x1.2000000800001p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7ffffeff), -0x1.2000000800001p+60, -0x1p+0 },
+{ INT64_C(0x1200000080000800), 0x1.2000000800008p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7ffff7ff), -0x1.2000000800008p+60, -0x1p+0 },
+{ INT64_C(0x1200000080004000), 0x1.200000080004p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7fffbfff), -0x1.200000080004p+60, -0x1p+0 },
+{ INT64_C(0x1200000080010000), 0x1.20000008001p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7ffeffff), -0x1.20000008001p+60, -0x1p+0 },
+{ INT64_C(0x1200000080080000), 0x1.20000008008p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7ff7ffff), -0x1.20000008008p+60, -0x1p+0 },
+{ INT64_C(0x1200000080100000), 0x1.2000000801p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7fefffff), -0x1.2000000801p+60, -0x1p+0 },
+{ INT64_C(0x1200000080800000), 0x1.2000000808p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7f7fffff), -0x1.2000000808p+60, -0x1p+0 },
+{ INT64_C(0x1200000081000000), 0x1.200000081p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7effffff), -0x1.200000081p+60, -0x1p+0 },
+{ INT64_C(0x1200000082000000), 0x1.200000082p+60, 0x0p+0 },
+{ INT64_C(0xedffffff7dffffff), -0x1.200000082p+60, -0x1p+0 },
+{ INT64_C(0x12000000a0000000), 0x1.2000000ap+60, 0x0p+0 },
+{ INT64_C(0xedffffff5fffffff), -0x1.2000000ap+60, -0x1p+0 },
+{ INT64_C(0x1200000100000000), 0x1.2000001p+60, 0x0p+0 },
+{ INT64_C(0xedfffffeffffffff), -0x1.2000001p+60, -0x1p+0 },
+{ INT64_C(0x1200000100000004), 0x1.2000001p+60, 0x1p+2 },
+{ INT64_C(0xedfffffefffffffb), -0x1.2000001p+60, -0x1.4p+2 },
+{ INT64_C(0x1200000100000010), 0x1.2000001p+60, 0x1p+4 },
+{ INT64_C(0xedfffffeffffffef), -0x1.2000001p+60, -0x1.1p+4 },
+{ INT64_C(0x1200000100000040), 0x1.2000001p+60, 0x1p+6 },
+{ INT64_C(0xedfffffeffffffbf), -0x1.2000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1200000100000200), 0x1.2000001000002p+60, 0x0p+0 },
+{ INT64_C(0xedfffffefffffdff), -0x1.2000001000002p+60, -0x1p+0 },
+{ INT64_C(0x1200000100000800), 0x1.2000001000008p+60, 0x0p+0 },
+{ INT64_C(0xedfffffefffff7ff), -0x1.2000001000008p+60, -0x1p+0 },
+{ INT64_C(0x1200000100002000), 0x1.200000100002p+60, 0x0p+0 },
+{ INT64_C(0xedfffffeffffdfff), -0x1.200000100002p+60, -0x1p+0 },
+{ INT64_C(0x1200000100020000), 0x1.20000010002p+60, 0x0p+0 },
+{ INT64_C(0xedfffffefffdffff), -0x1.20000010002p+60, -0x1p+0 },
+{ INT64_C(0x1200000100040000), 0x1.20000010004p+60, 0x0p+0 },
+{ INT64_C(0xedfffffefffbffff), -0x1.20000010004p+60, -0x1p+0 },
+{ INT64_C(0x1200000100080000), 0x1.20000010008p+60, 0x0p+0 },
+{ INT64_C(0xedfffffefff7ffff), -0x1.20000010008p+60, -0x1p+0 },
+{ INT64_C(0x1200000100400000), 0x1.2000001004p+60, 0x0p+0 },
+{ INT64_C(0xedfffffeffbfffff), -0x1.2000001004p+60, -0x1p+0 },
+{ INT64_C(0x1200000100800000), 0x1.2000001008p+60, 0x0p+0 },
+{ INT64_C(0xedfffffeff7fffff), -0x1.2000001008p+60, -0x1p+0 },
+{ INT64_C(0x1200000102000000), 0x1.200000102p+60, 0x0p+0 },
+{ INT64_C(0xedfffffefdffffff), -0x1.200000102p+60, -0x1p+0 },
+{ INT64_C(0x1200000110000000), 0x1.20000011p+60, 0x0p+0 },
+{ INT64_C(0xedfffffeefffffff), -0x1.20000011p+60, -0x1p+0 },
+{ INT64_C(0x1200000120000000), 0x1.20000012p+60, 0x0p+0 },
+{ INT64_C(0xedfffffedfffffff), -0x1.20000012p+60, -0x1p+0 },
+{ INT64_C(0x1200000180000000), 0x1.20000018p+60, 0x0p+0 },
+{ INT64_C(0xedfffffe7fffffff), -0x1.20000018p+60, -0x1p+0 },
+{ INT64_C(0x1200001000000000), 0x1.200001p+60, 0x0p+0 },
+{ INT64_C(0xedffffefffffffff), -0x1.200001p+60, -0x1p+0 },
+{ INT64_C(0x1200001000000004), 0x1.200001p+60, 0x1p+2 },
+{ INT64_C(0xedffffeffffffffb), -0x1.200001p+60, -0x1.4p+2 },
+{ INT64_C(0x1200001000000040), 0x1.200001p+60, 0x1p+6 },
+{ INT64_C(0xedffffefffffffbf), -0x1.200001p+60, -0x1.04p+6 },
+{ INT64_C(0x1200001000000100), 0x1.2000010000001p+60, 0x0p+0 },
+{ INT64_C(0xedffffeffffffeff), -0x1.2000010000001p+60, -0x1p+0 },
+{ INT64_C(0x1200001000000800), 0x1.2000010000008p+60, 0x0p+0 },
+{ INT64_C(0xedffffeffffff7ff), -0x1.2000010000008p+60, -0x1p+0 },
+{ INT64_C(0x1200001000002000), 0x1.200001000002p+60, 0x0p+0 },
+{ INT64_C(0xedffffefffffdfff), -0x1.200001000002p+60, -0x1p+0 },
+{ INT64_C(0x1200001000010000), 0x1.20000100001p+60, 0x0p+0 },
+{ INT64_C(0xedffffeffffeffff), -0x1.20000100001p+60, -0x1p+0 },
+{ INT64_C(0x1200001000040000), 0x1.20000100004p+60, 0x0p+0 },
+{ INT64_C(0xedffffeffffbffff), -0x1.20000100004p+60, -0x1p+0 },
+{ INT64_C(0x1200001000100000), 0x1.2000010001p+60, 0x0p+0 },
+{ INT64_C(0xedffffefffefffff), -0x1.2000010001p+60, -0x1p+0 },
+{ INT64_C(0x1200001000800000), 0x1.2000010008p+60, 0x0p+0 },
+{ INT64_C(0xedffffefff7fffff), -0x1.2000010008p+60, -0x1p+0 },
+{ INT64_C(0x1200001008000000), 0x1.200001008p+60, 0x0p+0 },
+{ INT64_C(0xedffffeff7ffffff), -0x1.200001008p+60, -0x1p+0 },
+{ INT64_C(0x1200001040000000), 0x1.20000104p+60, 0x0p+0 },
+{ INT64_C(0xedffffefbfffffff), -0x1.20000104p+60, -0x1p+0 },
+{ INT64_C(0x1200001100000000), 0x1.2000011p+60, 0x0p+0 },
+{ INT64_C(0xedffffeeffffffff), -0x1.2000011p+60, -0x1p+0 },
+{ INT64_C(0x1200001800000000), 0x1.2000018p+60, 0x0p+0 },
+{ INT64_C(0xedffffe7ffffffff), -0x1.2000018p+60, -0x1p+0 },
+{ INT64_C(0x1200004000000000), 0x1.200004p+60, 0x0p+0 },
+{ INT64_C(0xedffffbfffffffff), -0x1.200004p+60, -0x1p+0 },
+{ INT64_C(0x1200004000000001), 0x1.200004p+60, 0x1p+0 },
+{ INT64_C(0xedffffbffffffffe), -0x1.200004p+60, -0x1p+1 },
+{ INT64_C(0x1200004000000004), 0x1.200004p+60, 0x1p+2 },
+{ INT64_C(0xedffffbffffffffb), -0x1.200004p+60, -0x1.4p+2 },
+{ INT64_C(0x1200004000000010), 0x1.200004p+60, 0x1p+4 },
+{ INT64_C(0xedffffbfffffffef), -0x1.200004p+60, -0x1.1p+4 },
+{ INT64_C(0x1200004000000040), 0x1.200004p+60, 0x1p+6 },
+{ INT64_C(0xedffffbfffffffbf), -0x1.200004p+60, -0x1.04p+6 },
+{ INT64_C(0x1200004000000100), 0x1.2000040000001p+60, 0x0p+0 },
+{ INT64_C(0xedffffbffffffeff), -0x1.2000040000001p+60, -0x1p+0 },
+{ INT64_C(0x1200004000000200), 0x1.2000040000002p+60, 0x0p+0 },
+{ INT64_C(0xedffffbffffffdff), -0x1.2000040000002p+60, -0x1p+0 },
+{ INT64_C(0x1200004000001000), 0x1.200004000001p+60, 0x0p+0 },
+{ INT64_C(0xedffffbfffffefff), -0x1.200004000001p+60, -0x1p+0 },
+{ INT64_C(0x1200004000008000), 0x1.200004000008p+60, 0x0p+0 },
+{ INT64_C(0xedffffbfffff7fff), -0x1.200004000008p+60, -0x1p+0 },
+{ INT64_C(0x1200004000010000), 0x1.20000400001p+60, 0x0p+0 },
+{ INT64_C(0xedffffbffffeffff), -0x1.20000400001p+60, -0x1p+0 },
+{ INT64_C(0x1200004000080000), 0x1.20000400008p+60, 0x0p+0 },
+{ INT64_C(0xedffffbffff7ffff), -0x1.20000400008p+60, -0x1p+0 },
+{ INT64_C(0x1200004000800000), 0x1.2000040008p+60, 0x0p+0 },
+{ INT64_C(0xedffffbfff7fffff), -0x1.2000040008p+60, -0x1p+0 },
+{ INT64_C(0x1200004002000000), 0x1.200004002p+60, 0x0p+0 },
+{ INT64_C(0xedffffbffdffffff), -0x1.200004002p+60, -0x1p+0 },
+{ INT64_C(0x1200004020000000), 0x1.20000402p+60, 0x0p+0 },
+{ INT64_C(0xedffffbfdfffffff), -0x1.20000402p+60, -0x1p+0 },
+{ INT64_C(0x1200004200000000), 0x1.2000042p+60, 0x0p+0 },
+{ INT64_C(0xedffffbdffffffff), -0x1.2000042p+60, -0x1p+0 },
+{ INT64_C(0x1200004400000000), 0x1.2000044p+60, 0x0p+0 },
+{ INT64_C(0xedffffbbffffffff), -0x1.2000044p+60, -0x1p+0 },
+{ INT64_C(0x1200004800000000), 0x1.2000048p+60, 0x0p+0 },
+{ INT64_C(0xedffffb7ffffffff), -0x1.2000048p+60, -0x1p+0 },
+{ INT64_C(0x1200005000000000), 0x1.200005p+60, 0x0p+0 },
+{ INT64_C(0xedffffafffffffff), -0x1.200005p+60, -0x1p+0 },
+{ INT64_C(0x1200006000000000), 0x1.200006p+60, 0x0p+0 },
+{ INT64_C(0xedffff9fffffffff), -0x1.200006p+60, -0x1p+0 },
+{ INT64_C(0x1200010000000000), 0x1.20001p+60, 0x0p+0 },
+{ INT64_C(0xedfffeffffffffff), -0x1.20001p+60, -0x1p+0 },
+{ INT64_C(0x1200010000000001), 0x1.20001p+60, 0x1p+0 },
+{ INT64_C(0xedfffefffffffffe), -0x1.20001p+60, -0x1p+1 },
+{ INT64_C(0x1200010000000004), 0x1.20001p+60, 0x1p+2 },
+{ INT64_C(0xedfffefffffffffb), -0x1.20001p+60, -0x1.4p+2 },
+{ INT64_C(0x1200010000000040), 0x1.20001p+60, 0x1p+6 },
+{ INT64_C(0xedfffeffffffffbf), -0x1.20001p+60, -0x1.04p+6 },
+{ INT64_C(0x1200010000000080), 0x1.20001p+60, 0x1p+7 },
+{ INT64_C(0xedfffeffffffff7f), -0x1.2000100000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200010000000400), 0x1.2000100000004p+60, 0x0p+0 },
+{ INT64_C(0xedfffefffffffbff), -0x1.2000100000004p+60, -0x1p+0 },
+{ INT64_C(0x1200010000001000), 0x1.200010000001p+60, 0x0p+0 },
+{ INT64_C(0xedfffeffffffefff), -0x1.200010000001p+60, -0x1p+0 },
+{ INT64_C(0x1200010000008000), 0x1.200010000008p+60, 0x0p+0 },
+{ INT64_C(0xedfffeffffff7fff), -0x1.200010000008p+60, -0x1p+0 },
+{ INT64_C(0x1200010000020000), 0x1.20001000002p+60, 0x0p+0 },
+{ INT64_C(0xedfffefffffdffff), -0x1.20001000002p+60, -0x1p+0 },
+{ INT64_C(0x1200010000040000), 0x1.20001000004p+60, 0x0p+0 },
+{ INT64_C(0xedfffefffffbffff), -0x1.20001000004p+60, -0x1p+0 },
+{ INT64_C(0x1200010000100000), 0x1.2000100001p+60, 0x0p+0 },
+{ INT64_C(0xedfffeffffefffff), -0x1.2000100001p+60, -0x1p+0 },
+{ INT64_C(0x1200010000400000), 0x1.2000100004p+60, 0x0p+0 },
+{ INT64_C(0xedfffeffffbfffff), -0x1.2000100004p+60, -0x1p+0 },
+{ INT64_C(0x1200010004000000), 0x1.200010004p+60, 0x0p+0 },
+{ INT64_C(0xedfffefffbffffff), -0x1.200010004p+60, -0x1p+0 },
+{ INT64_C(0x1200010040000000), 0x1.20001004p+60, 0x0p+0 },
+{ INT64_C(0xedfffeffbfffffff), -0x1.20001004p+60, -0x1p+0 },
+{ INT64_C(0x1200010400000000), 0x1.2000104p+60, 0x0p+0 },
+{ INT64_C(0xedfffefbffffffff), -0x1.2000104p+60, -0x1p+0 },
+{ INT64_C(0x1200014000000000), 0x1.200014p+60, 0x0p+0 },
+{ INT64_C(0xedfffebfffffffff), -0x1.200014p+60, -0x1p+0 },
+{ INT64_C(0x1200020000000000), 0x1.20002p+60, 0x0p+0 },
+{ INT64_C(0xedfffdffffffffff), -0x1.20002p+60, -0x1p+0 },
+{ INT64_C(0x1200020000000002), 0x1.20002p+60, 0x1p+1 },
+{ INT64_C(0xedfffdfffffffffd), -0x1.20002p+60, -0x1.8p+1 },
+{ INT64_C(0x1200020000000008), 0x1.20002p+60, 0x1p+3 },
+{ INT64_C(0xedfffdfffffffff7), -0x1.20002p+60, -0x1.2p+3 },
+{ INT64_C(0x1200020000000080), 0x1.20002p+60, 0x1p+7 },
+{ INT64_C(0xedfffdffffffff7f), -0x1.2000200000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1200020000000800), 0x1.2000200000008p+60, 0x0p+0 },
+{ INT64_C(0xedfffdfffffff7ff), -0x1.2000200000008p+60, -0x1p+0 },
+{ INT64_C(0x1200020000002000), 0x1.200020000002p+60, 0x0p+0 },
+{ INT64_C(0xedfffdffffffdfff), -0x1.200020000002p+60, -0x1p+0 },
+{ INT64_C(0x1200020000020000), 0x1.20002000002p+60, 0x0p+0 },
+{ INT64_C(0xedfffdfffffdffff), -0x1.20002000002p+60, -0x1p+0 },
+{ INT64_C(0x1200020000100000), 0x1.2000200001p+60, 0x0p+0 },
+{ INT64_C(0xedfffdffffefffff), -0x1.2000200001p+60, -0x1p+0 },
+{ INT64_C(0x1200020001000000), 0x1.200020001p+60, 0x0p+0 },
+{ INT64_C(0xedfffdfffeffffff), -0x1.200020001p+60, -0x1p+0 },
+{ INT64_C(0x1200020002000000), 0x1.200020002p+60, 0x0p+0 },
+{ INT64_C(0xedfffdfffdffffff), -0x1.200020002p+60, -0x1p+0 },
+{ INT64_C(0x1200020004000000), 0x1.200020004p+60, 0x0p+0 },
+{ INT64_C(0xedfffdfffbffffff), -0x1.200020004p+60, -0x1p+0 },
+{ INT64_C(0x1200020040000000), 0x1.20002004p+60, 0x0p+0 },
+{ INT64_C(0xedfffdffbfffffff), -0x1.20002004p+60, -0x1p+0 },
+{ INT64_C(0x1200020080000000), 0x1.20002008p+60, 0x0p+0 },
+{ INT64_C(0xedfffdff7fffffff), -0x1.20002008p+60, -0x1p+0 },
+{ INT64_C(0x1200020400000000), 0x1.2000204p+60, 0x0p+0 },
+{ INT64_C(0xedfffdfbffffffff), -0x1.2000204p+60, -0x1p+0 },
+{ INT64_C(0x1200022000000000), 0x1.200022p+60, 0x0p+0 },
+{ INT64_C(0xedfffddfffffffff), -0x1.200022p+60, -0x1p+0 },
+{ INT64_C(0x1200030000000000), 0x1.20003p+60, 0x0p+0 },
+{ INT64_C(0xedfffcffffffffff), -0x1.20003p+60, -0x1p+0 },
+{ INT64_C(0x1200200000000000), 0x1.2002p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffffffffff), -0x1.2002p+60, -0x1p+0 },
+{ INT64_C(0x1200200000000008), 0x1.2002p+60, 0x1p+3 },
+{ INT64_C(0xedffdffffffffff7), -0x1.2002p+60, -0x1.2p+3 },
+{ INT64_C(0x1200200000000010), 0x1.2002p+60, 0x1p+4 },
+{ INT64_C(0xedffdfffffffffef), -0x1.2002p+60, -0x1.1p+4 },
+{ INT64_C(0x1200200000000020), 0x1.2002p+60, 0x1p+5 },
+{ INT64_C(0xedffdfffffffffdf), -0x1.2002p+60, -0x1.08p+5 },
+{ INT64_C(0x1200200000000200), 0x1.2002000000002p+60, 0x0p+0 },
+{ INT64_C(0xedffdffffffffdff), -0x1.2002000000002p+60, -0x1p+0 },
+{ INT64_C(0x1200200000000800), 0x1.2002000000008p+60, 0x0p+0 },
+{ INT64_C(0xedffdffffffff7ff), -0x1.2002000000008p+60, -0x1p+0 },
+{ INT64_C(0x1200200000001000), 0x1.200200000001p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffffffefff), -0x1.200200000001p+60, -0x1p+0 },
+{ INT64_C(0x1200200000002000), 0x1.200200000002p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffffffdfff), -0x1.200200000002p+60, -0x1p+0 },
+{ INT64_C(0x1200200000004000), 0x1.200200000004p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffffffbfff), -0x1.200200000004p+60, -0x1p+0 },
+{ INT64_C(0x1200200000008000), 0x1.200200000008p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffffff7fff), -0x1.200200000008p+60, -0x1p+0 },
+{ INT64_C(0x1200200000080000), 0x1.20020000008p+60, 0x0p+0 },
+{ INT64_C(0xedffdffffff7ffff), -0x1.20020000008p+60, -0x1p+0 },
+{ INT64_C(0x1200200000200000), 0x1.2002000002p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffffdfffff), -0x1.2002000002p+60, -0x1p+0 },
+{ INT64_C(0x1200200001000000), 0x1.200200001p+60, 0x0p+0 },
+{ INT64_C(0xedffdffffeffffff), -0x1.200200001p+60, -0x1p+0 },
+{ INT64_C(0x1200200004000000), 0x1.200200004p+60, 0x0p+0 },
+{ INT64_C(0xedffdffffbffffff), -0x1.200200004p+60, -0x1p+0 },
+{ INT64_C(0x1200200010000000), 0x1.20020001p+60, 0x0p+0 },
+{ INT64_C(0xedffdfffefffffff), -0x1.20020001p+60, -0x1p+0 },
+{ INT64_C(0x1200200100000000), 0x1.2002001p+60, 0x0p+0 },
+{ INT64_C(0xedffdffeffffffff), -0x1.2002001p+60, -0x1p+0 },
+{ INT64_C(0x1200200200000000), 0x1.2002002p+60, 0x0p+0 },
+{ INT64_C(0xedffdffdffffffff), -0x1.2002002p+60, -0x1p+0 },
+{ INT64_C(0x1200202000000000), 0x1.200202p+60, 0x0p+0 },
+{ INT64_C(0xedffdfdfffffffff), -0x1.200202p+60, -0x1p+0 },
+{ INT64_C(0x1200204000000000), 0x1.200204p+60, 0x0p+0 },
+{ INT64_C(0xedffdfbfffffffff), -0x1.200204p+60, -0x1p+0 },
+{ INT64_C(0x1200240000000000), 0x1.20024p+60, 0x0p+0 },
+{ INT64_C(0xedffdbffffffffff), -0x1.20024p+60, -0x1p+0 },
+{ INT64_C(0x1200800000000000), 0x1.2008p+60, 0x0p+0 },
+{ INT64_C(0xedff7fffffffffff), -0x1.2008p+60, -0x1p+0 },
+{ INT64_C(0x1200800000000004), 0x1.2008p+60, 0x1p+2 },
+{ INT64_C(0xedff7ffffffffffb), -0x1.2008p+60, -0x1.4p+2 },
+{ INT64_C(0x1200800000000040), 0x1.2008p+60, 0x1p+6 },
+{ INT64_C(0xedff7fffffffffbf), -0x1.2008p+60, -0x1.04p+6 },
+{ INT64_C(0x1200800000000400), 0x1.2008000000004p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffffffffbff), -0x1.2008000000004p+60, -0x1p+0 },
+{ INT64_C(0x1200800000000800), 0x1.2008000000008p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffffffff7ff), -0x1.2008000000008p+60, -0x1p+0 },
+{ INT64_C(0x1200800000001000), 0x1.200800000001p+60, 0x0p+0 },
+{ INT64_C(0xedff7fffffffefff), -0x1.200800000001p+60, -0x1p+0 },
+{ INT64_C(0x1200800000010000), 0x1.20080000001p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffffffeffff), -0x1.20080000001p+60, -0x1p+0 },
+{ INT64_C(0x1200800000040000), 0x1.20080000004p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffffffbffff), -0x1.20080000004p+60, -0x1p+0 },
+{ INT64_C(0x1200800000400000), 0x1.2008000004p+60, 0x0p+0 },
+{ INT64_C(0xedff7fffffbfffff), -0x1.2008000004p+60, -0x1p+0 },
+{ INT64_C(0x1200800002000000), 0x1.200800002p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffffdffffff), -0x1.200800002p+60, -0x1p+0 },
+{ INT64_C(0x1200800008000000), 0x1.200800008p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffff7ffffff), -0x1.200800008p+60, -0x1p+0 },
+{ INT64_C(0x1200800020000000), 0x1.20080002p+60, 0x0p+0 },
+{ INT64_C(0xedff7fffdfffffff), -0x1.20080002p+60, -0x1p+0 },
+{ INT64_C(0x1200800040000000), 0x1.20080004p+60, 0x0p+0 },
+{ INT64_C(0xedff7fffbfffffff), -0x1.20080004p+60, -0x1p+0 },
+{ INT64_C(0x1200800080000000), 0x1.20080008p+60, 0x0p+0 },
+{ INT64_C(0xedff7fff7fffffff), -0x1.20080008p+60, -0x1p+0 },
+{ INT64_C(0x1200800400000000), 0x1.2008004p+60, 0x0p+0 },
+{ INT64_C(0xedff7ffbffffffff), -0x1.2008004p+60, -0x1p+0 },
+{ INT64_C(0x1200802000000000), 0x1.200802p+60, 0x0p+0 },
+{ INT64_C(0xedff7fdfffffffff), -0x1.200802p+60, -0x1p+0 },
+{ INT64_C(0x1200810000000000), 0x1.20081p+60, 0x0p+0 },
+{ INT64_C(0xedff7effffffffff), -0x1.20081p+60, -0x1p+0 },
+{ INT64_C(0x1200820000000000), 0x1.20082p+60, 0x0p+0 },
+{ INT64_C(0xedff7dffffffffff), -0x1.20082p+60, -0x1p+0 },
+{ INT64_C(0x1200900000000000), 0x1.2009p+60, 0x0p+0 },
+{ INT64_C(0xedff6fffffffffff), -0x1.2009p+60, -0x1p+0 },
+{ INT64_C(0x1201000000000000), 0x1.201p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffffffffff), -0x1.201p+60, -0x1p+0 },
+{ INT64_C(0x1201000000000008), 0x1.201p+60, 0x1p+3 },
+{ INT64_C(0xedfefffffffffff7), -0x1.201p+60, -0x1.2p+3 },
+{ INT64_C(0x1201000000000040), 0x1.201p+60, 0x1p+6 },
+{ INT64_C(0xedfeffffffffffbf), -0x1.201p+60, -0x1.04p+6 },
+{ INT64_C(0x1201000000000080), 0x1.201p+60, 0x1p+7 },
+{ INT64_C(0xedfeffffffffff7f), -0x1.2010000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1201000000000200), 0x1.2010000000002p+60, 0x0p+0 },
+{ INT64_C(0xedfefffffffffdff), -0x1.2010000000002p+60, -0x1p+0 },
+{ INT64_C(0x1201000000001000), 0x1.201000000001p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffffffefff), -0x1.201000000001p+60, -0x1p+0 },
+{ INT64_C(0x1201000000004000), 0x1.201000000004p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffffffbfff), -0x1.201000000004p+60, -0x1p+0 },
+{ INT64_C(0x1201000000008000), 0x1.201000000008p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffffff7fff), -0x1.201000000008p+60, -0x1p+0 },
+{ INT64_C(0x1201000000040000), 0x1.20100000004p+60, 0x0p+0 },
+{ INT64_C(0xedfefffffffbffff), -0x1.20100000004p+60, -0x1p+0 },
+{ INT64_C(0x1201000000080000), 0x1.20100000008p+60, 0x0p+0 },
+{ INT64_C(0xedfefffffff7ffff), -0x1.20100000008p+60, -0x1p+0 },
+{ INT64_C(0x1201000000800000), 0x1.2010000008p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffff7fffff), -0x1.2010000008p+60, -0x1p+0 },
+{ INT64_C(0x1201000002000000), 0x1.201000002p+60, 0x0p+0 },
+{ INT64_C(0xedfefffffdffffff), -0x1.201000002p+60, -0x1p+0 },
+{ INT64_C(0x1201000008000000), 0x1.201000008p+60, 0x0p+0 },
+{ INT64_C(0xedfefffff7ffffff), -0x1.201000008p+60, -0x1p+0 },
+{ INT64_C(0x1201000010000000), 0x1.20100001p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffefffffff), -0x1.20100001p+60, -0x1p+0 },
+{ INT64_C(0x1201000020000000), 0x1.20100002p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffdfffffff), -0x1.20100002p+60, -0x1p+0 },
+{ INT64_C(0x1201000040000000), 0x1.20100004p+60, 0x0p+0 },
+{ INT64_C(0xedfeffffbfffffff), -0x1.20100004p+60, -0x1p+0 },
+{ INT64_C(0x1201000100000000), 0x1.2010001p+60, 0x0p+0 },
+{ INT64_C(0xedfefffeffffffff), -0x1.2010001p+60, -0x1p+0 },
+{ INT64_C(0x1201000800000000), 0x1.2010008p+60, 0x0p+0 },
+{ INT64_C(0xedfefff7ffffffff), -0x1.2010008p+60, -0x1p+0 },
+{ INT64_C(0x1201001000000000), 0x1.201001p+60, 0x0p+0 },
+{ INT64_C(0xedfeffefffffffff), -0x1.201001p+60, -0x1p+0 },
+{ INT64_C(0x1201002000000000), 0x1.201002p+60, 0x0p+0 },
+{ INT64_C(0xedfeffdfffffffff), -0x1.201002p+60, -0x1p+0 },
+{ INT64_C(0x1201020000000000), 0x1.20102p+60, 0x0p+0 },
+{ INT64_C(0xedfefdffffffffff), -0x1.20102p+60, -0x1p+0 },
+{ INT64_C(0x1201040000000000), 0x1.20104p+60, 0x0p+0 },
+{ INT64_C(0xedfefbffffffffff), -0x1.20104p+60, -0x1p+0 },
+{ INT64_C(0x1201400000000000), 0x1.2014p+60, 0x0p+0 },
+{ INT64_C(0xedfebfffffffffff), -0x1.2014p+60, -0x1p+0 },
+{ INT64_C(0x1208000000000000), 0x1.208p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffffffffff), -0x1.208p+60, -0x1p+0 },
+{ INT64_C(0x1208000000000001), 0x1.208p+60, 0x1p+0 },
+{ INT64_C(0xedf7fffffffffffe), -0x1.208p+60, -0x1p+1 },
+{ INT64_C(0x1208000000000004), 0x1.208p+60, 0x1p+2 },
+{ INT64_C(0xedf7fffffffffffb), -0x1.208p+60, -0x1.4p+2 },
+{ INT64_C(0x1208000000000040), 0x1.208p+60, 0x1p+6 },
+{ INT64_C(0xedf7ffffffffffbf), -0x1.208p+60, -0x1.04p+6 },
+{ INT64_C(0x1208000000000100), 0x1.2080000000001p+60, 0x0p+0 },
+{ INT64_C(0xedf7fffffffffeff), -0x1.2080000000001p+60, -0x1p+0 },
+{ INT64_C(0x1208000000000400), 0x1.2080000000004p+60, 0x0p+0 },
+{ INT64_C(0xedf7fffffffffbff), -0x1.2080000000004p+60, -0x1p+0 },
+{ INT64_C(0x1208000000002000), 0x1.208000000002p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffffffdfff), -0x1.208000000002p+60, -0x1p+0 },
+{ INT64_C(0x1208000000004000), 0x1.208000000004p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffffffbfff), -0x1.208000000004p+60, -0x1p+0 },
+{ INT64_C(0x1208000000020000), 0x1.20800000002p+60, 0x0p+0 },
+{ INT64_C(0xedf7fffffffdffff), -0x1.20800000002p+60, -0x1p+0 },
+{ INT64_C(0x1208000000200000), 0x1.2080000002p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffffdfffff), -0x1.2080000002p+60, -0x1p+0 },
+{ INT64_C(0x1208000000800000), 0x1.2080000008p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffff7fffff), -0x1.2080000008p+60, -0x1p+0 },
+{ INT64_C(0x1208000002000000), 0x1.208000002p+60, 0x0p+0 },
+{ INT64_C(0xedf7fffffdffffff), -0x1.208000002p+60, -0x1p+0 },
+{ INT64_C(0x1208000010000000), 0x1.20800001p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffefffffff), -0x1.20800001p+60, -0x1p+0 },
+{ INT64_C(0x1208000020000000), 0x1.20800002p+60, 0x0p+0 },
+{ INT64_C(0xedf7ffffdfffffff), -0x1.20800002p+60, -0x1p+0 },
+{ INT64_C(0x1208000200000000), 0x1.2080002p+60, 0x0p+0 },
+{ INT64_C(0xedf7fffdffffffff), -0x1.2080002p+60, -0x1p+0 },
+{ INT64_C(0x1208000800000000), 0x1.2080008p+60, 0x0p+0 },
+{ INT64_C(0xedf7fff7ffffffff), -0x1.2080008p+60, -0x1p+0 },
+{ INT64_C(0x1208008000000000), 0x1.208008p+60, 0x0p+0 },
+{ INT64_C(0xedf7ff7fffffffff), -0x1.208008p+60, -0x1p+0 },
+{ INT64_C(0x1208010000000000), 0x1.20801p+60, 0x0p+0 },
+{ INT64_C(0xedf7feffffffffff), -0x1.20801p+60, -0x1p+0 },
+{ INT64_C(0x1208020000000000), 0x1.20802p+60, 0x0p+0 },
+{ INT64_C(0xedf7fdffffffffff), -0x1.20802p+60, -0x1p+0 },
+{ INT64_C(0x1208040000000000), 0x1.20804p+60, 0x0p+0 },
+{ INT64_C(0xedf7fbffffffffff), -0x1.20804p+60, -0x1p+0 },
+{ INT64_C(0x1208100000000000), 0x1.2081p+60, 0x0p+0 },
+{ INT64_C(0xedf7efffffffffff), -0x1.2081p+60, -0x1p+0 },
+{ INT64_C(0x1208200000000000), 0x1.2082p+60, 0x0p+0 },
+{ INT64_C(0xedf7dfffffffffff), -0x1.2082p+60, -0x1p+0 },
+{ INT64_C(0x1208800000000000), 0x1.2088p+60, 0x0p+0 },
+{ INT64_C(0xedf77fffffffffff), -0x1.2088p+60, -0x1p+0 },
+{ INT64_C(0x1209000000000000), 0x1.209p+60, 0x0p+0 },
+{ INT64_C(0xedf6ffffffffffff), -0x1.209p+60, -0x1p+0 },
+{ INT64_C(0x1220000000000000), 0x1.22p+60, 0x0p+0 },
+{ INT64_C(0xeddfffffffffffff), -0x1.22p+60, -0x1p+0 },
+{ INT64_C(0x1220000000000002), 0x1.22p+60, 0x1p+1 },
+{ INT64_C(0xeddffffffffffffd), -0x1.22p+60, -0x1.8p+1 },
+{ INT64_C(0x1220000000000008), 0x1.22p+60, 0x1p+3 },
+{ INT64_C(0xeddffffffffffff7), -0x1.22p+60, -0x1.2p+3 },
+{ INT64_C(0x1220000000000040), 0x1.22p+60, 0x1p+6 },
+{ INT64_C(0xeddfffffffffffbf), -0x1.22p+60, -0x1.04p+6 },
+{ INT64_C(0x1220000000000200), 0x1.2200000000002p+60, 0x0p+0 },
+{ INT64_C(0xeddffffffffffdff), -0x1.2200000000002p+60, -0x1p+0 },
+{ INT64_C(0x1220000000000800), 0x1.2200000000008p+60, 0x0p+0 },
+{ INT64_C(0xeddffffffffff7ff), -0x1.2200000000008p+60, -0x1p+0 },
+{ INT64_C(0x1220000000002000), 0x1.220000000002p+60, 0x0p+0 },
+{ INT64_C(0xeddfffffffffdfff), -0x1.220000000002p+60, -0x1p+0 },
+{ INT64_C(0x1220000000010000), 0x1.22000000001p+60, 0x0p+0 },
+{ INT64_C(0xeddffffffffeffff), -0x1.22000000001p+60, -0x1p+0 },
+{ INT64_C(0x1220000000080000), 0x1.22000000008p+60, 0x0p+0 },
+{ INT64_C(0xeddffffffff7ffff), -0x1.22000000008p+60, -0x1p+0 },
+{ INT64_C(0x1220000000200000), 0x1.2200000002p+60, 0x0p+0 },
+{ INT64_C(0xeddfffffffdfffff), -0x1.2200000002p+60, -0x1p+0 },
+{ INT64_C(0x1220000000800000), 0x1.2200000008p+60, 0x0p+0 },
+{ INT64_C(0xeddfffffff7fffff), -0x1.2200000008p+60, -0x1p+0 },
+{ INT64_C(0x1220000001000000), 0x1.220000001p+60, 0x0p+0 },
+{ INT64_C(0xeddffffffeffffff), -0x1.220000001p+60, -0x1p+0 },
+{ INT64_C(0x1220000004000000), 0x1.220000004p+60, 0x0p+0 },
+{ INT64_C(0xeddffffffbffffff), -0x1.220000004p+60, -0x1p+0 },
+{ INT64_C(0x1220000010000000), 0x1.22000001p+60, 0x0p+0 },
+{ INT64_C(0xeddfffffefffffff), -0x1.22000001p+60, -0x1p+0 },
+{ INT64_C(0x1220000040000000), 0x1.22000004p+60, 0x0p+0 },
+{ INT64_C(0xeddfffffbfffffff), -0x1.22000004p+60, -0x1p+0 },
+{ INT64_C(0x1220000200000000), 0x1.2200002p+60, 0x0p+0 },
+{ INT64_C(0xeddffffdffffffff), -0x1.2200002p+60, -0x1p+0 },
+{ INT64_C(0x1220000400000000), 0x1.2200004p+60, 0x0p+0 },
+{ INT64_C(0xeddffffbffffffff), -0x1.2200004p+60, -0x1p+0 },
+{ INT64_C(0x1220000800000000), 0x1.2200008p+60, 0x0p+0 },
+{ INT64_C(0xeddffff7ffffffff), -0x1.2200008p+60, -0x1p+0 },
+{ INT64_C(0x1220002000000000), 0x1.220002p+60, 0x0p+0 },
+{ INT64_C(0xeddfffdfffffffff), -0x1.220002p+60, -0x1p+0 },
+{ INT64_C(0x1220008000000000), 0x1.220008p+60, 0x0p+0 },
+{ INT64_C(0xeddfff7fffffffff), -0x1.220008p+60, -0x1p+0 },
+{ INT64_C(0x1220040000000000), 0x1.22004p+60, 0x0p+0 },
+{ INT64_C(0xeddffbffffffffff), -0x1.22004p+60, -0x1p+0 },
+{ INT64_C(0x1220100000000000), 0x1.2201p+60, 0x0p+0 },
+{ INT64_C(0xeddfefffffffffff), -0x1.2201p+60, -0x1p+0 },
+{ INT64_C(0x1221000000000000), 0x1.221p+60, 0x0p+0 },
+{ INT64_C(0xeddeffffffffffff), -0x1.221p+60, -0x1p+0 },
+{ INT64_C(0x1228000000000000), 0x1.228p+60, 0x0p+0 },
+{ INT64_C(0xedd7ffffffffffff), -0x1.228p+60, -0x1p+0 },
+{ INT64_C(0x1230000000000000), 0x1.23p+60, 0x0p+0 },
+{ INT64_C(0xedcfffffffffffff), -0x1.23p+60, -0x1p+0 },
+{ INT64_C(0x1300000000000000), 0x1.3p+60, 0x0p+0 },
+{ INT64_C(0xecffffffffffffff), -0x1.3p+60, -0x1p+0 },
+{ INT64_C(0x1300000000000001), 0x1.3p+60, 0x1p+0 },
+{ INT64_C(0xecfffffffffffffe), -0x1.3p+60, -0x1p+1 },
+{ INT64_C(0x1300000000000010), 0x1.3p+60, 0x1p+4 },
+{ INT64_C(0xecffffffffffffef), -0x1.3p+60, -0x1.1p+4 },
+{ INT64_C(0x1300000000000080), 0x1.3p+60, 0x1p+7 },
+{ INT64_C(0xecffffffffffff7f), -0x1.3000000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1300000000000800), 0x1.3000000000008p+60, 0x0p+0 },
+{ INT64_C(0xecfffffffffff7ff), -0x1.3000000000008p+60, -0x1p+0 },
+{ INT64_C(0x1300000000001000), 0x1.300000000001p+60, 0x0p+0 },
+{ INT64_C(0xecffffffffffefff), -0x1.300000000001p+60, -0x1p+0 },
+{ INT64_C(0x1300000000004000), 0x1.300000000004p+60, 0x0p+0 },
+{ INT64_C(0xecffffffffffbfff), -0x1.300000000004p+60, -0x1p+0 },
+{ INT64_C(0x1300000000008000), 0x1.300000000008p+60, 0x0p+0 },
+{ INT64_C(0xecffffffffff7fff), -0x1.300000000008p+60, -0x1p+0 },
+{ INT64_C(0x1300000000010000), 0x1.30000000001p+60, 0x0p+0 },
+{ INT64_C(0xecfffffffffeffff), -0x1.30000000001p+60, -0x1p+0 },
+{ INT64_C(0x1300000000040000), 0x1.30000000004p+60, 0x0p+0 },
+{ INT64_C(0xecfffffffffbffff), -0x1.30000000004p+60, -0x1p+0 },
+{ INT64_C(0x1300000000200000), 0x1.3000000002p+60, 0x0p+0 },
+{ INT64_C(0xecffffffffdfffff), -0x1.3000000002p+60, -0x1p+0 },
+{ INT64_C(0x1300000001000000), 0x1.300000001p+60, 0x0p+0 },
+{ INT64_C(0xecfffffffeffffff), -0x1.300000001p+60, -0x1p+0 },
+{ INT64_C(0x1300000004000000), 0x1.300000004p+60, 0x0p+0 },
+{ INT64_C(0xecfffffffbffffff), -0x1.300000004p+60, -0x1p+0 },
+{ INT64_C(0x1300000010000000), 0x1.30000001p+60, 0x0p+0 },
+{ INT64_C(0xecffffffefffffff), -0x1.30000001p+60, -0x1p+0 },
+{ INT64_C(0x1300000100000000), 0x1.3000001p+60, 0x0p+0 },
+{ INT64_C(0xecfffffeffffffff), -0x1.3000001p+60, -0x1p+0 },
+{ INT64_C(0x1300000800000000), 0x1.3000008p+60, 0x0p+0 },
+{ INT64_C(0xecfffff7ffffffff), -0x1.3000008p+60, -0x1p+0 },
+{ INT64_C(0x1300001000000000), 0x1.300001p+60, 0x0p+0 },
+{ INT64_C(0xecffffefffffffff), -0x1.300001p+60, -0x1p+0 },
+{ INT64_C(0x1300002000000000), 0x1.300002p+60, 0x0p+0 },
+{ INT64_C(0xecffffdfffffffff), -0x1.300002p+60, -0x1p+0 },
+{ INT64_C(0x1300010000000000), 0x1.30001p+60, 0x0p+0 },
+{ INT64_C(0xecfffeffffffffff), -0x1.30001p+60, -0x1p+0 },
+{ INT64_C(0x1300040000000000), 0x1.30004p+60, 0x0p+0 },
+{ INT64_C(0xecfffbffffffffff), -0x1.30004p+60, -0x1p+0 },
+{ INT64_C(0x1300400000000000), 0x1.3004p+60, 0x0p+0 },
+{ INT64_C(0xecffbfffffffffff), -0x1.3004p+60, -0x1p+0 },
+{ INT64_C(0x1302000000000000), 0x1.302p+60, 0x0p+0 },
+{ INT64_C(0xecfdffffffffffff), -0x1.302p+60, -0x1p+0 },
+{ INT64_C(0x1308000000000000), 0x1.308p+60, 0x0p+0 },
+{ INT64_C(0xecf7ffffffffffff), -0x1.308p+60, -0x1p+0 },
+{ INT64_C(0x1340000000000000), 0x1.34p+60, 0x0p+0 },
+{ INT64_C(0xecbfffffffffffff), -0x1.34p+60, -0x1p+0 },
+{ INT64_C(0x1400000000000002), 0x1.4p+60, 0x1p+1 },
+{ INT64_C(0xebfffffffffffffd), -0x1.4p+60, -0x1.8p+1 },
+{ INT64_C(0x1400000000000010), 0x1.4p+60, 0x1p+4 },
+{ INT64_C(0xebffffffffffffef), -0x1.4p+60, -0x1.1p+4 },
+{ INT64_C(0x1400000000000018), 0x1.4p+60, 0x1.8p+4 },
+{ INT64_C(0xebffffffffffffe7), -0x1.4p+60, -0x1.9p+4 },
+{ INT64_C(0x1400000000000080), 0x1.4p+60, 0x1p+7 },
+{ INT64_C(0xebffffffffffff7f), -0x1.4000000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1400000000000082), 0x1.4000000000001p+60, -0x1.f8p+6 },
+{ INT64_C(0xebffffffffffff7d), -0x1.4000000000001p+60, 0x1.f4p+6 },
+{ INT64_C(0x1400000000000084), 0x1.4000000000001p+60, -0x1.fp+6 },
+{ INT64_C(0xebffffffffffff7b), -0x1.4000000000001p+60, 0x1.ecp+6 },
+{ INT64_C(0x1400000000000088), 0x1.4000000000001p+60, -0x1.ep+6 },
+{ INT64_C(0xebffffffffffff77), -0x1.4000000000001p+60, 0x1.dcp+6 },
+{ INT64_C(0x14000000000000c0), 0x1.4000000000001p+60, -0x1p+6 },
+{ INT64_C(0xebffffffffffff3f), -0x1.4000000000001p+60, 0x1.f8p+5 },
+{ INT64_C(0x1400000000000400), 0x1.4000000000004p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffffbff), -0x1.4000000000004p+60, -0x1p+0 },
+{ INT64_C(0x1400000000000402), 0x1.4000000000004p+60, 0x1p+1 },
+{ INT64_C(0xebfffffffffffbfd), -0x1.4000000000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1400000000000408), 0x1.4000000000004p+60, 0x1p+3 },
+{ INT64_C(0xebfffffffffffbf7), -0x1.4000000000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1400000000000420), 0x1.4000000000004p+60, 0x1p+5 },
+{ INT64_C(0xebfffffffffffbdf), -0x1.4000000000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1400000000000500), 0x1.4000000000005p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffffaff), -0x1.4000000000005p+60, -0x1p+0 },
+{ INT64_C(0x1400000000000800), 0x1.4000000000008p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffff7ff), -0x1.4000000000008p+60, -0x1p+0 },
+{ INT64_C(0x1400000000000804), 0x1.4000000000008p+60, 0x1p+2 },
+{ INT64_C(0xebfffffffffff7fb), -0x1.4000000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1400000000000808), 0x1.4000000000008p+60, 0x1p+3 },
+{ INT64_C(0xebfffffffffff7f7), -0x1.4000000000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1400000000000880), 0x1.4000000000008p+60, 0x1p+7 },
+{ INT64_C(0xebfffffffffff77f), -0x1.4000000000009p+60, 0x1.fcp+6 },
+{ INT64_C(0x1400000000000a00), 0x1.400000000000ap+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffff5ff), -0x1.400000000000ap+60, -0x1p+0 },
+{ INT64_C(0x1400000000002000), 0x1.400000000002p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffffdfff), -0x1.400000000002p+60, -0x1p+0 },
+{ INT64_C(0x1400000000002002), 0x1.400000000002p+60, 0x1p+1 },
+{ INT64_C(0xebffffffffffdffd), -0x1.400000000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1400000000002010), 0x1.400000000002p+60, 0x1p+4 },
+{ INT64_C(0xebffffffffffdfef), -0x1.400000000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1400000000002040), 0x1.400000000002p+60, 0x1p+6 },
+{ INT64_C(0xebffffffffffdfbf), -0x1.400000000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1400000000002080), 0x1.400000000002p+60, 0x1p+7 },
+{ INT64_C(0xebffffffffffdf7f), -0x1.4000000000021p+60, 0x1.fcp+6 },
+{ INT64_C(0x1400000000002100), 0x1.4000000000021p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffffdeff), -0x1.4000000000021p+60, -0x1p+0 },
+{ INT64_C(0x1400000000003000), 0x1.400000000003p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffffcfff), -0x1.400000000003p+60, -0x1p+0 },
+{ INT64_C(0x1400000000008000), 0x1.400000000008p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffff7fff), -0x1.400000000008p+60, -0x1p+0 },
+{ INT64_C(0x1400000000008004), 0x1.400000000008p+60, 0x1p+2 },
+{ INT64_C(0xebffffffffff7ffb), -0x1.400000000008p+60, -0x1.4p+2 },
+{ INT64_C(0x1400000000008008), 0x1.400000000008p+60, 0x1p+3 },
+{ INT64_C(0xebffffffffff7ff7), -0x1.400000000008p+60, -0x1.2p+3 },
+{ INT64_C(0x1400000000008040), 0x1.400000000008p+60, 0x1p+6 },
+{ INT64_C(0xebffffffffff7fbf), -0x1.400000000008p+60, -0x1.04p+6 },
+{ INT64_C(0x1400000000008400), 0x1.4000000000084p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffff7bff), -0x1.4000000000084p+60, -0x1p+0 },
+{ INT64_C(0x140000000000a000), 0x1.40000000000ap+60, 0x0p+0 },
+{ INT64_C(0xebffffffffff5fff), -0x1.40000000000ap+60, -0x1p+0 },
+{ INT64_C(0x1400000000040000), 0x1.40000000004p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffbffff), -0x1.40000000004p+60, -0x1p+0 },
+{ INT64_C(0x1400000000040004), 0x1.40000000004p+60, 0x1p+2 },
+{ INT64_C(0xebfffffffffbfffb), -0x1.40000000004p+60, -0x1.4p+2 },
+{ INT64_C(0x1400000000040010), 0x1.40000000004p+60, 0x1p+4 },
+{ INT64_C(0xebfffffffffbffef), -0x1.40000000004p+60, -0x1.1p+4 },
+{ INT64_C(0x1400000000040080), 0x1.40000000004p+60, 0x1p+7 },
+{ INT64_C(0xebfffffffffbff7f), -0x1.4000000000401p+60, 0x1.fcp+6 },
+{ INT64_C(0x1400000000040400), 0x1.4000000000404p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffbfbff), -0x1.4000000000404p+60, -0x1p+0 },
+{ INT64_C(0x1400000000042000), 0x1.400000000042p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffbdfff), -0x1.400000000042p+60, -0x1p+0 },
+{ INT64_C(0x1400000000044000), 0x1.400000000044p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffffbbfff), -0x1.400000000044p+60, -0x1p+0 },
+{ INT64_C(0x1400000000100000), 0x1.4000000001p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffefffff), -0x1.4000000001p+60, -0x1p+0 },
+{ INT64_C(0x1400000000100008), 0x1.4000000001p+60, 0x1p+3 },
+{ INT64_C(0xebffffffffeffff7), -0x1.4000000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1400000000100040), 0x1.4000000001p+60, 0x1p+6 },
+{ INT64_C(0xebffffffffefffbf), -0x1.4000000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1400000000100080), 0x1.4000000001p+60, 0x1p+7 },
+{ INT64_C(0xebffffffffefff7f), -0x1.4000000001001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1400000000100400), 0x1.4000000001004p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffeffbff), -0x1.4000000001004p+60, -0x1p+0 },
+{ INT64_C(0x1400000000100800), 0x1.4000000001008p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffeff7ff), -0x1.4000000001008p+60, -0x1p+0 },
+{ INT64_C(0x1400000000101000), 0x1.400000000101p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffefefff), -0x1.400000000101p+60, -0x1p+0 },
+{ INT64_C(0x1400000000108000), 0x1.400000000108p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffef7fff), -0x1.400000000108p+60, -0x1p+0 },
+{ INT64_C(0x1400000000110000), 0x1.40000000011p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffeeffff), -0x1.40000000011p+60, -0x1p+0 },
+{ INT64_C(0x1400000000200000), 0x1.4000000002p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffdfffff), -0x1.4000000002p+60, -0x1p+0 },
+{ INT64_C(0x1400000000200001), 0x1.4000000002p+60, 0x1p+0 },
+{ INT64_C(0xebffffffffdffffe), -0x1.4000000002p+60, -0x1p+1 },
+{ INT64_C(0x1400000000200004), 0x1.4000000002p+60, 0x1p+2 },
+{ INT64_C(0xebffffffffdffffb), -0x1.4000000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1400000000200020), 0x1.4000000002p+60, 0x1p+5 },
+{ INT64_C(0xebffffffffdfffdf), -0x1.4000000002p+60, -0x1.08p+5 },
+{ INT64_C(0x1400000000200040), 0x1.4000000002p+60, 0x1p+6 },
+{ INT64_C(0xebffffffffdfffbf), -0x1.4000000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1400000000200200), 0x1.4000000002002p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffdffdff), -0x1.4000000002002p+60, -0x1p+0 },
+{ INT64_C(0x1400000000202000), 0x1.400000000202p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffdfdfff), -0x1.400000000202p+60, -0x1p+0 },
+{ INT64_C(0x1400000000220000), 0x1.40000000022p+60, 0x0p+0 },
+{ INT64_C(0xebffffffffddffff), -0x1.40000000022p+60, -0x1p+0 },
+{ INT64_C(0x1400000001000000), 0x1.400000001p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffeffffff), -0x1.400000001p+60, -0x1p+0 },
+{ INT64_C(0x1400000001000008), 0x1.400000001p+60, 0x1p+3 },
+{ INT64_C(0xebfffffffefffff7), -0x1.400000001p+60, -0x1.2p+3 },
+{ INT64_C(0x1400000001000040), 0x1.400000001p+60, 0x1p+6 },
+{ INT64_C(0xebfffffffeffffbf), -0x1.400000001p+60, -0x1.04p+6 },
+{ INT64_C(0x1400000001000100), 0x1.4000000010001p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffefffeff), -0x1.4000000010001p+60, -0x1p+0 },
+{ INT64_C(0x1400000001000400), 0x1.4000000010004p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffefffbff), -0x1.4000000010004p+60, -0x1p+0 },
+{ INT64_C(0x1400000001004000), 0x1.400000001004p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffeffbfff), -0x1.400000001004p+60, -0x1p+0 },
+{ INT64_C(0x1400000001040000), 0x1.40000000104p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffefbffff), -0x1.40000000104p+60, -0x1p+0 },
+{ INT64_C(0x1400000001400000), 0x1.4000000014p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffebfffff), -0x1.4000000014p+60, -0x1p+0 },
+{ INT64_C(0x1400000001800000), 0x1.4000000018p+60, 0x0p+0 },
+{ INT64_C(0xebfffffffe7fffff), -0x1.4000000018p+60, -0x1p+0 },
+{ INT64_C(0x1400000008000000), 0x1.400000008p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff7ffffff), -0x1.400000008p+60, -0x1p+0 },
+{ INT64_C(0x1400000008000002), 0x1.400000008p+60, 0x1p+1 },
+{ INT64_C(0xebfffffff7fffffd), -0x1.400000008p+60, -0x1.8p+1 },
+{ INT64_C(0x1400000008000020), 0x1.400000008p+60, 0x1p+5 },
+{ INT64_C(0xebfffffff7ffffdf), -0x1.400000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1400000008000200), 0x1.4000000080002p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff7fffdff), -0x1.4000000080002p+60, -0x1p+0 },
+{ INT64_C(0x1400000008002000), 0x1.400000008002p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff7ffdfff), -0x1.400000008002p+60, -0x1p+0 },
+{ INT64_C(0x1400000008004000), 0x1.400000008004p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff7ffbfff), -0x1.400000008004p+60, -0x1p+0 },
+{ INT64_C(0x1400000008008000), 0x1.400000008008p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff7ff7fff), -0x1.400000008008p+60, -0x1p+0 },
+{ INT64_C(0x1400000008080000), 0x1.40000000808p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff7f7ffff), -0x1.40000000808p+60, -0x1p+0 },
+{ INT64_C(0x1400000008800000), 0x1.4000000088p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff77fffff), -0x1.4000000088p+60, -0x1p+0 },
+{ INT64_C(0x1400000009000000), 0x1.400000009p+60, 0x0p+0 },
+{ INT64_C(0xebfffffff6ffffff), -0x1.400000009p+60, -0x1p+0 },
+{ INT64_C(0x140000000c000000), 0x1.40000000cp+60, 0x0p+0 },
+{ INT64_C(0xebfffffff3ffffff), -0x1.40000000cp+60, -0x1p+0 },
+{ INT64_C(0x1400000040000000), 0x1.40000004p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbfffffff), -0x1.40000004p+60, -0x1p+0 },
+{ INT64_C(0x1400000040000002), 0x1.40000004p+60, 0x1p+1 },
+{ INT64_C(0xebffffffbffffffd), -0x1.40000004p+60, -0x1.8p+1 },
+{ INT64_C(0x1400000040000008), 0x1.40000004p+60, 0x1p+3 },
+{ INT64_C(0xebffffffbffffff7), -0x1.40000004p+60, -0x1.2p+3 },
+{ INT64_C(0x1400000040000020), 0x1.40000004p+60, 0x1p+5 },
+{ INT64_C(0xebffffffbfffffdf), -0x1.40000004p+60, -0x1.08p+5 },
+{ INT64_C(0x1400000040000200), 0x1.4000000400002p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbffffdff), -0x1.4000000400002p+60, -0x1p+0 },
+{ INT64_C(0x1400000040001000), 0x1.400000040001p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbfffefff), -0x1.400000040001p+60, -0x1p+0 },
+{ INT64_C(0x1400000040008000), 0x1.400000040008p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbfff7fff), -0x1.400000040008p+60, -0x1p+0 },
+{ INT64_C(0x1400000040080000), 0x1.40000004008p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbff7ffff), -0x1.40000004008p+60, -0x1p+0 },
+{ INT64_C(0x1400000040400000), 0x1.4000000404p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbfbfffff), -0x1.4000000404p+60, -0x1p+0 },
+{ INT64_C(0x1400000041000000), 0x1.400000041p+60, 0x0p+0 },
+{ INT64_C(0xebffffffbeffffff), -0x1.400000041p+60, -0x1p+0 },
+{ INT64_C(0x1400000048000000), 0x1.400000048p+60, 0x0p+0 },
+{ INT64_C(0xebffffffb7ffffff), -0x1.400000048p+60, -0x1p+0 },
+{ INT64_C(0x1400000200000000), 0x1.4000002p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdffffffff), -0x1.4000002p+60, -0x1p+0 },
+{ INT64_C(0x1400000200000002), 0x1.4000002p+60, 0x1p+1 },
+{ INT64_C(0xebfffffdfffffffd), -0x1.4000002p+60, -0x1.8p+1 },
+{ INT64_C(0x1400000200000004), 0x1.4000002p+60, 0x1p+2 },
+{ INT64_C(0xebfffffdfffffffb), -0x1.4000002p+60, -0x1.4p+2 },
+{ INT64_C(0x1400000200000010), 0x1.4000002p+60, 0x1p+4 },
+{ INT64_C(0xebfffffdffffffef), -0x1.4000002p+60, -0x1.1p+4 },
+{ INT64_C(0x1400000200000040), 0x1.4000002p+60, 0x1p+6 },
+{ INT64_C(0xebfffffdffffffbf), -0x1.4000002p+60, -0x1.04p+6 },
+{ INT64_C(0x1400000200000400), 0x1.4000002000004p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdfffffbff), -0x1.4000002000004p+60, -0x1p+0 },
+{ INT64_C(0x1400000200001000), 0x1.400000200001p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdffffefff), -0x1.400000200001p+60, -0x1p+0 },
+{ INT64_C(0x1400000200010000), 0x1.40000020001p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdfffeffff), -0x1.40000020001p+60, -0x1p+0 },
+{ INT64_C(0x1400000200020000), 0x1.40000020002p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdfffdffff), -0x1.40000020002p+60, -0x1p+0 },
+{ INT64_C(0x1400000200100000), 0x1.4000002001p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdffefffff), -0x1.4000002001p+60, -0x1p+0 },
+{ INT64_C(0x1400000200800000), 0x1.4000002008p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdff7fffff), -0x1.4000002008p+60, -0x1p+0 },
+{ INT64_C(0x1400000208000000), 0x1.400000208p+60, 0x0p+0 },
+{ INT64_C(0xebfffffdf7ffffff), -0x1.400000208p+60, -0x1p+0 },
+{ INT64_C(0x1400000280000000), 0x1.40000028p+60, 0x0p+0 },
+{ INT64_C(0xebfffffd7fffffff), -0x1.40000028p+60, -0x1p+0 },
+{ INT64_C(0x1400000800000000), 0x1.4000008p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7ffffffff), -0x1.4000008p+60, -0x1p+0 },
+{ INT64_C(0x1400000800000001), 0x1.4000008p+60, 0x1p+0 },
+{ INT64_C(0xebfffff7fffffffe), -0x1.4000008p+60, -0x1p+1 },
+{ INT64_C(0x1400000800000010), 0x1.4000008p+60, 0x1p+4 },
+{ INT64_C(0xebfffff7ffffffef), -0x1.4000008p+60, -0x1.1p+4 },
+{ INT64_C(0x1400000800000020), 0x1.4000008p+60, 0x1p+5 },
+{ INT64_C(0xebfffff7ffffffdf), -0x1.4000008p+60, -0x1.08p+5 },
+{ INT64_C(0x1400000800000200), 0x1.4000008000002p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7fffffdff), -0x1.4000008000002p+60, -0x1p+0 },
+{ INT64_C(0x1400000800001000), 0x1.400000800001p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7ffffefff), -0x1.400000800001p+60, -0x1p+0 },
+{ INT64_C(0x1400000800010000), 0x1.40000080001p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7fffeffff), -0x1.40000080001p+60, -0x1p+0 },
+{ INT64_C(0x1400000800020000), 0x1.40000080002p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7fffdffff), -0x1.40000080002p+60, -0x1p+0 },
+{ INT64_C(0x1400000800200000), 0x1.4000008002p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7ffdfffff), -0x1.4000008002p+60, -0x1p+0 },
+{ INT64_C(0x1400000800400000), 0x1.4000008004p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7ffbfffff), -0x1.4000008004p+60, -0x1p+0 },
+{ INT64_C(0x1400000800800000), 0x1.4000008008p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7ff7fffff), -0x1.4000008008p+60, -0x1p+0 },
+{ INT64_C(0x1400000804000000), 0x1.400000804p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7fbffffff), -0x1.400000804p+60, -0x1p+0 },
+{ INT64_C(0x1400000840000000), 0x1.40000084p+60, 0x0p+0 },
+{ INT64_C(0xebfffff7bfffffff), -0x1.40000084p+60, -0x1p+0 },
+{ INT64_C(0x1400000a00000000), 0x1.400000ap+60, 0x0p+0 },
+{ INT64_C(0xebfffff5ffffffff), -0x1.400000ap+60, -0x1p+0 },
+{ INT64_C(0x1400004000000000), 0x1.400004p+60, 0x0p+0 },
+{ INT64_C(0xebffffbfffffffff), -0x1.400004p+60, -0x1p+0 },
+{ INT64_C(0x1400004000000004), 0x1.400004p+60, 0x1p+2 },
+{ INT64_C(0xebffffbffffffffb), -0x1.400004p+60, -0x1.4p+2 },
+{ INT64_C(0x1400004000000010), 0x1.400004p+60, 0x1p+4 },
+{ INT64_C(0xebffffbfffffffef), -0x1.400004p+60, -0x1.1p+4 },
+{ INT64_C(0x1400004000000040), 0x1.400004p+60, 0x1p+6 },
+{ INT64_C(0xebffffbfffffffbf), -0x1.400004p+60, -0x1.04p+6 },
+{ INT64_C(0x1400004000000200), 0x1.4000040000002p+60, 0x0p+0 },
+{ INT64_C(0xebffffbffffffdff), -0x1.4000040000002p+60, -0x1p+0 },
+{ INT64_C(0x1400004000000800), 0x1.4000040000008p+60, 0x0p+0 },
+{ INT64_C(0xebffffbffffff7ff), -0x1.4000040000008p+60, -0x1p+0 },
+{ INT64_C(0x1400004000002000), 0x1.400004000002p+60, 0x0p+0 },
+{ INT64_C(0xebffffbfffffdfff), -0x1.400004000002p+60, -0x1p+0 },
+{ INT64_C(0x1400004000020000), 0x1.40000400002p+60, 0x0p+0 },
+{ INT64_C(0xebffffbffffdffff), -0x1.40000400002p+60, -0x1p+0 },
+{ INT64_C(0x1400004000080000), 0x1.40000400008p+60, 0x0p+0 },
+{ INT64_C(0xebffffbffff7ffff), -0x1.40000400008p+60, -0x1p+0 },
+{ INT64_C(0x1400004000400000), 0x1.4000040004p+60, 0x0p+0 },
+{ INT64_C(0xebffffbfffbfffff), -0x1.4000040004p+60, -0x1p+0 },
+{ INT64_C(0x1400004001000000), 0x1.400004001p+60, 0x0p+0 },
+{ INT64_C(0xebffffbffeffffff), -0x1.400004001p+60, -0x1p+0 },
+{ INT64_C(0x1400004010000000), 0x1.40000401p+60, 0x0p+0 },
+{ INT64_C(0xebffffbfefffffff), -0x1.40000401p+60, -0x1p+0 },
+{ INT64_C(0x1400004100000000), 0x1.4000041p+60, 0x0p+0 },
+{ INT64_C(0xebffffbeffffffff), -0x1.4000041p+60, -0x1p+0 },
+{ INT64_C(0x1400004400000000), 0x1.4000044p+60, 0x0p+0 },
+{ INT64_C(0xebffffbbffffffff), -0x1.4000044p+60, -0x1p+0 },
+{ INT64_C(0x1400004800000000), 0x1.4000048p+60, 0x0p+0 },
+{ INT64_C(0xebffffb7ffffffff), -0x1.4000048p+60, -0x1p+0 },
+{ INT64_C(0x1400006000000000), 0x1.400006p+60, 0x0p+0 },
+{ INT64_C(0xebffff9fffffffff), -0x1.400006p+60, -0x1p+0 },
+{ INT64_C(0x1400040000000000), 0x1.40004p+60, 0x0p+0 },
+{ INT64_C(0xebfffbffffffffff), -0x1.40004p+60, -0x1p+0 },
+{ INT64_C(0x1400040000000004), 0x1.40004p+60, 0x1p+2 },
+{ INT64_C(0xebfffbfffffffffb), -0x1.40004p+60, -0x1.4p+2 },
+{ INT64_C(0x1400040000000008), 0x1.40004p+60, 0x1p+3 },
+{ INT64_C(0xebfffbfffffffff7), -0x1.40004p+60, -0x1.2p+3 },
+{ INT64_C(0x1400040000000020), 0x1.40004p+60, 0x1p+5 },
+{ INT64_C(0xebfffbffffffffdf), -0x1.40004p+60, -0x1.08p+5 },
+{ INT64_C(0x1400040000000100), 0x1.4000400000001p+60, 0x0p+0 },
+{ INT64_C(0xebfffbfffffffeff), -0x1.4000400000001p+60, -0x1p+0 },
+{ INT64_C(0x1400040000000800), 0x1.4000400000008p+60, 0x0p+0 },
+{ INT64_C(0xebfffbfffffff7ff), -0x1.4000400000008p+60, -0x1p+0 },
+{ INT64_C(0x1400040000004000), 0x1.400040000004p+60, 0x0p+0 },
+{ INT64_C(0xebfffbffffffbfff), -0x1.400040000004p+60, -0x1p+0 },
+{ INT64_C(0x1400040000040000), 0x1.40004000004p+60, 0x0p+0 },
+{ INT64_C(0xebfffbfffffbffff), -0x1.40004000004p+60, -0x1p+0 },
+{ INT64_C(0x1400040000400000), 0x1.4000400004p+60, 0x0p+0 },
+{ INT64_C(0xebfffbffffbfffff), -0x1.4000400004p+60, -0x1p+0 },
+{ INT64_C(0x1400040004000000), 0x1.400040004p+60, 0x0p+0 },
+{ INT64_C(0xebfffbfffbffffff), -0x1.400040004p+60, -0x1p+0 },
+{ INT64_C(0x1400040020000000), 0x1.40004002p+60, 0x0p+0 },
+{ INT64_C(0xebfffbffdfffffff), -0x1.40004002p+60, -0x1p+0 },
+{ INT64_C(0x1400040080000000), 0x1.40004008p+60, 0x0p+0 },
+{ INT64_C(0xebfffbff7fffffff), -0x1.40004008p+60, -0x1p+0 },
+{ INT64_C(0x1400040400000000), 0x1.4000404p+60, 0x0p+0 },
+{ INT64_C(0xebfffbfbffffffff), -0x1.4000404p+60, -0x1p+0 },
+{ INT64_C(0x1400041000000000), 0x1.400041p+60, 0x0p+0 },
+{ INT64_C(0xebfffbefffffffff), -0x1.400041p+60, -0x1p+0 },
+{ INT64_C(0x1400048000000000), 0x1.400048p+60, 0x0p+0 },
+{ INT64_C(0xebfffb7fffffffff), -0x1.400048p+60, -0x1p+0 },
+{ INT64_C(0x1400100000000000), 0x1.4001p+60, 0x0p+0 },
+{ INT64_C(0xebffefffffffffff), -0x1.4001p+60, -0x1p+0 },
+{ INT64_C(0x1400100000000008), 0x1.4001p+60, 0x1p+3 },
+{ INT64_C(0xebffeffffffffff7), -0x1.4001p+60, -0x1.2p+3 },
+{ INT64_C(0x1400100000000010), 0x1.4001p+60, 0x1p+4 },
+{ INT64_C(0xebffefffffffffef), -0x1.4001p+60, -0x1.1p+4 },
+{ INT64_C(0x1400100000000020), 0x1.4001p+60, 0x1p+5 },
+{ INT64_C(0xebffefffffffffdf), -0x1.4001p+60, -0x1.08p+5 },
+{ INT64_C(0x1400100000000100), 0x1.4001000000001p+60, 0x0p+0 },
+{ INT64_C(0xebffeffffffffeff), -0x1.4001000000001p+60, -0x1p+0 },
+{ INT64_C(0x1400100000000800), 0x1.4001000000008p+60, 0x0p+0 },
+{ INT64_C(0xebffeffffffff7ff), -0x1.4001000000008p+60, -0x1p+0 },
+{ INT64_C(0x1400100000004000), 0x1.400100000004p+60, 0x0p+0 },
+{ INT64_C(0xebffefffffffbfff), -0x1.400100000004p+60, -0x1p+0 },
+{ INT64_C(0x1400100000010000), 0x1.40010000001p+60, 0x0p+0 },
+{ INT64_C(0xebffeffffffeffff), -0x1.40010000001p+60, -0x1p+0 },
+{ INT64_C(0x1400100000020000), 0x1.40010000002p+60, 0x0p+0 },
+{ INT64_C(0xebffeffffffdffff), -0x1.40010000002p+60, -0x1p+0 },
+{ INT64_C(0x1400100000100000), 0x1.4001000001p+60, 0x0p+0 },
+{ INT64_C(0xebffefffffefffff), -0x1.4001000001p+60, -0x1p+0 },
+{ INT64_C(0x1400100000800000), 0x1.4001000008p+60, 0x0p+0 },
+{ INT64_C(0xebffefffff7fffff), -0x1.4001000008p+60, -0x1p+0 },
+{ INT64_C(0x1400100004000000), 0x1.400100004p+60, 0x0p+0 },
+{ INT64_C(0xebffeffffbffffff), -0x1.400100004p+60, -0x1p+0 },
+{ INT64_C(0x1400100008000000), 0x1.400100008p+60, 0x0p+0 },
+{ INT64_C(0xebffeffff7ffffff), -0x1.400100008p+60, -0x1p+0 },
+{ INT64_C(0x1400100010000000), 0x1.40010001p+60, 0x0p+0 },
+{ INT64_C(0xebffefffefffffff), -0x1.40010001p+60, -0x1p+0 },
+{ INT64_C(0x1400100080000000), 0x1.40010008p+60, 0x0p+0 },
+{ INT64_C(0xebffefff7fffffff), -0x1.40010008p+60, -0x1p+0 },
+{ INT64_C(0x1400100800000000), 0x1.4001008p+60, 0x0p+0 },
+{ INT64_C(0xebffeff7ffffffff), -0x1.4001008p+60, -0x1p+0 },
+{ INT64_C(0x1400108000000000), 0x1.400108p+60, 0x0p+0 },
+{ INT64_C(0xebffef7fffffffff), -0x1.400108p+60, -0x1p+0 },
+{ INT64_C(0x1400140000000000), 0x1.40014p+60, 0x0p+0 },
+{ INT64_C(0xebffebffffffffff), -0x1.40014p+60, -0x1p+0 },
+{ INT64_C(0x1400800000000000), 0x1.4008p+60, 0x0p+0 },
+{ INT64_C(0xebff7fffffffffff), -0x1.4008p+60, -0x1p+0 },
+{ INT64_C(0x1400800000000001), 0x1.4008p+60, 0x1p+0 },
+{ INT64_C(0xebff7ffffffffffe), -0x1.4008p+60, -0x1p+1 },
+{ INT64_C(0x1400800000000008), 0x1.4008p+60, 0x1p+3 },
+{ INT64_C(0xebff7ffffffffff7), -0x1.4008p+60, -0x1.2p+3 },
+{ INT64_C(0x1400800000000040), 0x1.4008p+60, 0x1p+6 },
+{ INT64_C(0xebff7fffffffffbf), -0x1.4008p+60, -0x1.04p+6 },
+{ INT64_C(0x1400800000000100), 0x1.4008000000001p+60, 0x0p+0 },
+{ INT64_C(0xebff7ffffffffeff), -0x1.4008000000001p+60, -0x1p+0 },
+{ INT64_C(0x1400800000001000), 0x1.400800000001p+60, 0x0p+0 },
+{ INT64_C(0xebff7fffffffefff), -0x1.400800000001p+60, -0x1p+0 },
+{ INT64_C(0x1400800000010000), 0x1.40080000001p+60, 0x0p+0 },
+{ INT64_C(0xebff7ffffffeffff), -0x1.40080000001p+60, -0x1p+0 },
+{ INT64_C(0x1400800000020000), 0x1.40080000002p+60, 0x0p+0 },
+{ INT64_C(0xebff7ffffffdffff), -0x1.40080000002p+60, -0x1p+0 },
+{ INT64_C(0x1400800000080000), 0x1.40080000008p+60, 0x0p+0 },
+{ INT64_C(0xebff7ffffff7ffff), -0x1.40080000008p+60, -0x1p+0 },
+{ INT64_C(0x1400800000400000), 0x1.4008000004p+60, 0x0p+0 },
+{ INT64_C(0xebff7fffffbfffff), -0x1.4008000004p+60, -0x1p+0 },
+{ INT64_C(0x1400800000800000), 0x1.4008000008p+60, 0x0p+0 },
+{ INT64_C(0xebff7fffff7fffff), -0x1.4008000008p+60, -0x1p+0 },
+{ INT64_C(0x1400800008000000), 0x1.400800008p+60, 0x0p+0 },
+{ INT64_C(0xebff7ffff7ffffff), -0x1.400800008p+60, -0x1p+0 },
+{ INT64_C(0x1400800040000000), 0x1.40080004p+60, 0x0p+0 },
+{ INT64_C(0xebff7fffbfffffff), -0x1.40080004p+60, -0x1p+0 },
+{ INT64_C(0x1400800400000000), 0x1.4008004p+60, 0x0p+0 },
+{ INT64_C(0xebff7ffbffffffff), -0x1.4008004p+60, -0x1p+0 },
+{ INT64_C(0x1400800800000000), 0x1.4008008p+60, 0x0p+0 },
+{ INT64_C(0xebff7ff7ffffffff), -0x1.4008008p+60, -0x1p+0 },
+{ INT64_C(0x1400801000000000), 0x1.400801p+60, 0x0p+0 },
+{ INT64_C(0xebff7fefffffffff), -0x1.400801p+60, -0x1p+0 },
+{ INT64_C(0x1400804000000000), 0x1.400804p+60, 0x0p+0 },
+{ INT64_C(0xebff7fbfffffffff), -0x1.400804p+60, -0x1p+0 },
+{ INT64_C(0x1400820000000000), 0x1.40082p+60, 0x0p+0 },
+{ INT64_C(0xebff7dffffffffff), -0x1.40082p+60, -0x1p+0 },
+{ INT64_C(0x1400840000000000), 0x1.40084p+60, 0x0p+0 },
+{ INT64_C(0xebff7bffffffffff), -0x1.40084p+60, -0x1p+0 },
+{ INT64_C(0x1400900000000000), 0x1.4009p+60, 0x0p+0 },
+{ INT64_C(0xebff6fffffffffff), -0x1.4009p+60, -0x1p+0 },
+{ INT64_C(0x1404000000000000), 0x1.404p+60, 0x0p+0 },
+{ INT64_C(0xebfbffffffffffff), -0x1.404p+60, -0x1p+0 },
+{ INT64_C(0x1404000000000002), 0x1.404p+60, 0x1p+1 },
+{ INT64_C(0xebfbfffffffffffd), -0x1.404p+60, -0x1.8p+1 },
+{ INT64_C(0x1404000000000004), 0x1.404p+60, 0x1p+2 },
+{ INT64_C(0xebfbfffffffffffb), -0x1.404p+60, -0x1.4p+2 },
+{ INT64_C(0x1404000000000010), 0x1.404p+60, 0x1p+4 },
+{ INT64_C(0xebfbffffffffffef), -0x1.404p+60, -0x1.1p+4 },
+{ INT64_C(0x1404000000000080), 0x1.404p+60, 0x1p+7 },
+{ INT64_C(0xebfbffffffffff7f), -0x1.4040000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1404000000000100), 0x1.4040000000001p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffffffffeff), -0x1.4040000000001p+60, -0x1p+0 },
+{ INT64_C(0x1404000000000200), 0x1.4040000000002p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffffffffdff), -0x1.4040000000002p+60, -0x1p+0 },
+{ INT64_C(0x1404000000001000), 0x1.404000000001p+60, 0x0p+0 },
+{ INT64_C(0xebfbffffffffefff), -0x1.404000000001p+60, -0x1p+0 },
+{ INT64_C(0x1404000000004000), 0x1.404000000004p+60, 0x0p+0 },
+{ INT64_C(0xebfbffffffffbfff), -0x1.404000000004p+60, -0x1p+0 },
+{ INT64_C(0x1404000000008000), 0x1.404000000008p+60, 0x0p+0 },
+{ INT64_C(0xebfbffffffff7fff), -0x1.404000000008p+60, -0x1p+0 },
+{ INT64_C(0x1404000000010000), 0x1.40400000001p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffffffeffff), -0x1.40400000001p+60, -0x1p+0 },
+{ INT64_C(0x1404000000040000), 0x1.40400000004p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffffffbffff), -0x1.40400000004p+60, -0x1p+0 },
+{ INT64_C(0x1404000000100000), 0x1.4040000001p+60, 0x0p+0 },
+{ INT64_C(0xebfbffffffefffff), -0x1.4040000001p+60, -0x1p+0 },
+{ INT64_C(0x1404000001000000), 0x1.404000001p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffffeffffff), -0x1.404000001p+60, -0x1p+0 },
+{ INT64_C(0x1404000004000000), 0x1.404000004p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffffbffffff), -0x1.404000004p+60, -0x1p+0 },
+{ INT64_C(0x1404000040000000), 0x1.40400004p+60, 0x0p+0 },
+{ INT64_C(0xebfbffffbfffffff), -0x1.40400004p+60, -0x1p+0 },
+{ INT64_C(0x1404000100000000), 0x1.4040001p+60, 0x0p+0 },
+{ INT64_C(0xebfbfffeffffffff), -0x1.4040001p+60, -0x1p+0 },
+{ INT64_C(0x1404001000000000), 0x1.404001p+60, 0x0p+0 },
+{ INT64_C(0xebfbffefffffffff), -0x1.404001p+60, -0x1p+0 },
+{ INT64_C(0x1404004000000000), 0x1.404004p+60, 0x0p+0 },
+{ INT64_C(0xebfbffbfffffffff), -0x1.404004p+60, -0x1p+0 },
+{ INT64_C(0x1404010000000000), 0x1.40401p+60, 0x0p+0 },
+{ INT64_C(0xebfbfeffffffffff), -0x1.40401p+60, -0x1p+0 },
+{ INT64_C(0x1404100000000000), 0x1.4041p+60, 0x0p+0 },
+{ INT64_C(0xebfbefffffffffff), -0x1.4041p+60, -0x1p+0 },
+{ INT64_C(0x1404800000000000), 0x1.4048p+60, 0x0p+0 },
+{ INT64_C(0xebfb7fffffffffff), -0x1.4048p+60, -0x1p+0 },
+{ INT64_C(0x1406000000000000), 0x1.406p+60, 0x0p+0 },
+{ INT64_C(0xebf9ffffffffffff), -0x1.406p+60, -0x1p+0 },
+{ INT64_C(0x1410000000000000), 0x1.41p+60, 0x0p+0 },
+{ INT64_C(0xebefffffffffffff), -0x1.41p+60, -0x1p+0 },
+{ INT64_C(0x1410000000000001), 0x1.41p+60, 0x1p+0 },
+{ INT64_C(0xebeffffffffffffe), -0x1.41p+60, -0x1p+1 },
+{ INT64_C(0x1410000000000002), 0x1.41p+60, 0x1p+1 },
+{ INT64_C(0xebeffffffffffffd), -0x1.41p+60, -0x1.8p+1 },
+{ INT64_C(0x1410000000000020), 0x1.41p+60, 0x1p+5 },
+{ INT64_C(0xebefffffffffffdf), -0x1.41p+60, -0x1.08p+5 },
+{ INT64_C(0x1410000000000040), 0x1.41p+60, 0x1p+6 },
+{ INT64_C(0xebefffffffffffbf), -0x1.41p+60, -0x1.04p+6 },
+{ INT64_C(0x1410000000000080), 0x1.41p+60, 0x1p+7 },
+{ INT64_C(0xebefffffffffff7f), -0x1.4100000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1410000000000200), 0x1.4100000000002p+60, 0x0p+0 },
+{ INT64_C(0xebeffffffffffdff), -0x1.4100000000002p+60, -0x1p+0 },
+{ INT64_C(0x1410000000002000), 0x1.410000000002p+60, 0x0p+0 },
+{ INT64_C(0xebefffffffffdfff), -0x1.410000000002p+60, -0x1p+0 },
+{ INT64_C(0x1410000000008000), 0x1.410000000008p+60, 0x0p+0 },
+{ INT64_C(0xebefffffffff7fff), -0x1.410000000008p+60, -0x1p+0 },
+{ INT64_C(0x1410000000040000), 0x1.41000000004p+60, 0x0p+0 },
+{ INT64_C(0xebeffffffffbffff), -0x1.41000000004p+60, -0x1p+0 },
+{ INT64_C(0x1410000000080000), 0x1.41000000008p+60, 0x0p+0 },
+{ INT64_C(0xebeffffffff7ffff), -0x1.41000000008p+60, -0x1p+0 },
+{ INT64_C(0x1410000000400000), 0x1.4100000004p+60, 0x0p+0 },
+{ INT64_C(0xebefffffffbfffff), -0x1.4100000004p+60, -0x1p+0 },
+{ INT64_C(0x1410000001000000), 0x1.410000001p+60, 0x0p+0 },
+{ INT64_C(0xebeffffffeffffff), -0x1.410000001p+60, -0x1p+0 },
+{ INT64_C(0x1410000008000000), 0x1.410000008p+60, 0x0p+0 },
+{ INT64_C(0xebeffffff7ffffff), -0x1.410000008p+60, -0x1p+0 },
+{ INT64_C(0x1410000080000000), 0x1.41000008p+60, 0x0p+0 },
+{ INT64_C(0xebefffff7fffffff), -0x1.41000008p+60, -0x1p+0 },
+{ INT64_C(0x1410000200000000), 0x1.4100002p+60, 0x0p+0 },
+{ INT64_C(0xebeffffdffffffff), -0x1.4100002p+60, -0x1p+0 },
+{ INT64_C(0x1410000400000000), 0x1.4100004p+60, 0x0p+0 },
+{ INT64_C(0xebeffffbffffffff), -0x1.4100004p+60, -0x1p+0 },
+{ INT64_C(0x1410000800000000), 0x1.4100008p+60, 0x0p+0 },
+{ INT64_C(0xebeffff7ffffffff), -0x1.4100008p+60, -0x1p+0 },
+{ INT64_C(0x1410001000000000), 0x1.410001p+60, 0x0p+0 },
+{ INT64_C(0xebefffefffffffff), -0x1.410001p+60, -0x1p+0 },
+{ INT64_C(0x1410008000000000), 0x1.410008p+60, 0x0p+0 },
+{ INT64_C(0xebefff7fffffffff), -0x1.410008p+60, -0x1p+0 },
+{ INT64_C(0x1410020000000000), 0x1.41002p+60, 0x0p+0 },
+{ INT64_C(0xebeffdffffffffff), -0x1.41002p+60, -0x1p+0 },
+{ INT64_C(0x1410200000000000), 0x1.4102p+60, 0x0p+0 },
+{ INT64_C(0xebefdfffffffffff), -0x1.4102p+60, -0x1p+0 },
+{ INT64_C(0x1411000000000000), 0x1.411p+60, 0x0p+0 },
+{ INT64_C(0xebeeffffffffffff), -0x1.411p+60, -0x1p+0 },
+{ INT64_C(0x1414000000000000), 0x1.414p+60, 0x0p+0 },
+{ INT64_C(0xebebffffffffffff), -0x1.414p+60, -0x1p+0 },
+{ INT64_C(0x1420000000000000), 0x1.42p+60, 0x0p+0 },
+{ INT64_C(0xebdfffffffffffff), -0x1.42p+60, -0x1p+0 },
+{ INT64_C(0x1420000000000008), 0x1.42p+60, 0x1p+3 },
+{ INT64_C(0xebdffffffffffff7), -0x1.42p+60, -0x1.2p+3 },
+{ INT64_C(0x1420000000000080), 0x1.42p+60, 0x1p+7 },
+{ INT64_C(0xebdfffffffffff7f), -0x1.4200000000001p+60, 0x1.fcp+6 },
+{ INT64_C(0x1420000000000800), 0x1.4200000000008p+60, 0x0p+0 },
+{ INT64_C(0xebdffffffffff7ff), -0x1.4200000000008p+60, -0x1p+0 },
+{ INT64_C(0x1420000000004000), 0x1.420000000004p+60, 0x0p+0 },
+{ INT64_C(0xebdfffffffffbfff), -0x1.420000000004p+60, -0x1p+0 },
+{ INT64_C(0x1420000000040000), 0x1.42000000004p+60, 0x0p+0 },
+{ INT64_C(0xebdffffffffbffff), -0x1.42000000004p+60, -0x1p+0 },
+{ INT64_C(0x1420000000080000), 0x1.42000000008p+60, 0x0p+0 },
+{ INT64_C(0xebdffffffff7ffff), -0x1.42000000008p+60, -0x1p+0 },
+{ INT64_C(0x1420000000200000), 0x1.4200000002p+60, 0x0p+0 },
+{ INT64_C(0xebdfffffffdfffff), -0x1.4200000002p+60, -0x1p+0 },
+{ INT64_C(0x1420000002000000), 0x1.420000002p+60, 0x0p+0 },
+{ INT64_C(0xebdffffffdffffff), -0x1.420000002p+60, -0x1p+0 },
+{ INT64_C(0x1420000020000000), 0x1.42000002p+60, 0x0p+0 },
+{ INT64_C(0xebdfffffdfffffff), -0x1.42000002p+60, -0x1p+0 },
+{ INT64_C(0x1420000100000000), 0x1.4200001p+60, 0x0p+0 },
+{ INT64_C(0xebdffffeffffffff), -0x1.4200001p+60, -0x1p+0 },
+{ INT64_C(0x1420000400000000), 0x1.4200004p+60, 0x0p+0 },
+{ INT64_C(0xebdffffbffffffff), -0x1.4200004p+60, -0x1p+0 },
+{ INT64_C(0x1420001000000000), 0x1.420001p+60, 0x0p+0 },
+{ INT64_C(0xebdfffefffffffff), -0x1.420001p+60, -0x1p+0 },
+{ INT64_C(0x1420010000000000), 0x1.42001p+60, 0x0p+0 },
+{ INT64_C(0xebdffeffffffffff), -0x1.42001p+60, -0x1p+0 },
+{ INT64_C(0x1420080000000000), 0x1.42008p+60, 0x0p+0 },
+{ INT64_C(0xebdff7ffffffffff), -0x1.42008p+60, -0x1p+0 },
+{ INT64_C(0x1420200000000000), 0x1.4202p+60, 0x0p+0 },
+{ INT64_C(0xebdfdfffffffffff), -0x1.4202p+60, -0x1p+0 },
+{ INT64_C(0x1422000000000000), 0x1.422p+60, 0x0p+0 },
+{ INT64_C(0xebddffffffffffff), -0x1.422p+60, -0x1p+0 },
+{ INT64_C(0x1424000000000000), 0x1.424p+60, 0x0p+0 },
+{ INT64_C(0xebdbffffffffffff), -0x1.424p+60, -0x1p+0 },
+{ INT64_C(0x1600000000000000), 0x1.6p+60, 0x0p+0 },
+{ INT64_C(0xe9ffffffffffffff), -0x1.6p+60, -0x1p+0 },
+{ INT64_C(0x1600000000000004), 0x1.6p+60, 0x1p+2 },
+{ INT64_C(0xe9fffffffffffffb), -0x1.6p+60, -0x1.4p+2 },
+{ INT64_C(0x1600000000000020), 0x1.6p+60, 0x1p+5 },
+{ INT64_C(0xe9ffffffffffffdf), -0x1.6p+60, -0x1.08p+5 },
+{ INT64_C(0x1600000000000200), 0x1.6000000000002p+60, 0x0p+0 },
+{ INT64_C(0xe9fffffffffffdff), -0x1.6000000000002p+60, -0x1p+0 },
+{ INT64_C(0x1600000000000800), 0x1.6000000000008p+60, 0x0p+0 },
+{ INT64_C(0xe9fffffffffff7ff), -0x1.6000000000008p+60, -0x1p+0 },
+{ INT64_C(0x1600000000008000), 0x1.600000000008p+60, 0x0p+0 },
+{ INT64_C(0xe9ffffffffff7fff), -0x1.600000000008p+60, -0x1p+0 },
+{ INT64_C(0x1600000000040000), 0x1.60000000004p+60, 0x0p+0 },
+{ INT64_C(0xe9fffffffffbffff), -0x1.60000000004p+60, -0x1p+0 },
+{ INT64_C(0x1600000000080000), 0x1.60000000008p+60, 0x0p+0 },
+{ INT64_C(0xe9fffffffff7ffff), -0x1.60000000008p+60, -0x1p+0 },
+{ INT64_C(0x1600000000800000), 0x1.6000000008p+60, 0x0p+0 },
+{ INT64_C(0xe9ffffffff7fffff), -0x1.6000000008p+60, -0x1p+0 },
+{ INT64_C(0x1600000004000000), 0x1.600000004p+60, 0x0p+0 },
+{ INT64_C(0xe9fffffffbffffff), -0x1.600000004p+60, -0x1p+0 },
+{ INT64_C(0x1600000040000000), 0x1.60000004p+60, 0x0p+0 },
+{ INT64_C(0xe9ffffffbfffffff), -0x1.60000004p+60, -0x1p+0 },
+{ INT64_C(0x1600000200000000), 0x1.6000002p+60, 0x0p+0 },
+{ INT64_C(0xe9fffffdffffffff), -0x1.6000002p+60, -0x1p+0 },
+{ INT64_C(0x1600002000000000), 0x1.600002p+60, 0x0p+0 },
+{ INT64_C(0xe9ffffdfffffffff), -0x1.600002p+60, -0x1p+0 },
+{ INT64_C(0x1600008000000000), 0x1.600008p+60, 0x0p+0 },
+{ INT64_C(0xe9ffff7fffffffff), -0x1.600008p+60, -0x1p+0 },
+{ INT64_C(0x1600080000000000), 0x1.60008p+60, 0x0p+0 },
+{ INT64_C(0xe9fff7ffffffffff), -0x1.60008p+60, -0x1p+0 },
+{ INT64_C(0x1600100000000000), 0x1.6001p+60, 0x0p+0 },
+{ INT64_C(0xe9ffefffffffffff), -0x1.6001p+60, -0x1p+0 },
+{ INT64_C(0x1601000000000000), 0x1.601p+60, 0x0p+0 },
+{ INT64_C(0xe9feffffffffffff), -0x1.601p+60, -0x1p+0 },
+{ INT64_C(0x1604000000000000), 0x1.604p+60, 0x0p+0 },
+{ INT64_C(0xe9fbffffffffffff), -0x1.604p+60, -0x1p+0 },
+{ INT64_C(0x1640000000000000), 0x1.64p+60, 0x0p+0 },
+{ INT64_C(0xe9bfffffffffffff), -0x1.64p+60, -0x1p+0 },
+{ INT64_C(0x1700000000000000), 0x1.7p+60, 0x0p+0 },
+{ INT64_C(0xe8ffffffffffffff), -0x1.7p+60, -0x1p+0 },
+{ INT64_C(0x400000000000000c), 0x1p+62, 0x1.8p+3 },
+{ INT64_C(0xbffffffffffffff3), -0x1p+62, -0x1.ap+3 },
+{ INT64_C(0x4000000000000024), 0x1p+62, 0x1.2p+5 },
+{ INT64_C(0xbfffffffffffffdb), -0x1p+62, -0x1.28p+5 },
+{ INT64_C(0x4000000000000026), 0x1p+62, 0x1.3p+5 },
+{ INT64_C(0xbfffffffffffffd9), -0x1p+62, -0x1.38p+5 },
+{ INT64_C(0x4000000000000204), 0x1.0000000000001p+62, -0x1.fcp+8 },
+{ INT64_C(0xbffffffffffffdfb), -0x1.0000000000001p+62, 0x1.fbp+8 },
+{ INT64_C(0x4000000000000220), 0x1.0000000000001p+62, -0x1.ep+8 },
+{ INT64_C(0xbffffffffffffddf), -0x1.0000000000001p+62, 0x1.dfp+8 },
+{ INT64_C(0x4000000000000221), 0x1.0000000000001p+62, -0x1.dfp+8 },
+{ INT64_C(0xbffffffffffffdde), -0x1.0000000000001p+62, 0x1.dep+8 },
+{ INT64_C(0x4000000000000224), 0x1.0000000000001p+62, -0x1.dcp+8 },
+{ INT64_C(0xbffffffffffffddb), -0x1.0000000000001p+62, 0x1.dbp+8 },
+{ INT64_C(0x4000000000000230), 0x1.0000000000001p+62, -0x1.dp+8 },
+{ INT64_C(0xbffffffffffffdcf), -0x1.0000000000001p+62, 0x1.cfp+8 },
+{ INT64_C(0x4000000000000240), 0x1.0000000000001p+62, -0x1.cp+8 },
+{ INT64_C(0xbffffffffffffdbf), -0x1.0000000000001p+62, 0x1.bfp+8 },
+{ INT64_C(0x4000000000000242), 0x1.0000000000001p+62, -0x1.bep+8 },
+{ INT64_C(0xbffffffffffffdbd), -0x1.0000000000001p+62, 0x1.bdp+8 },
+{ INT64_C(0x4000000000000248), 0x1.0000000000001p+62, -0x1.b8p+8 },
+{ INT64_C(0xbffffffffffffdb7), -0x1.0000000000001p+62, 0x1.b7p+8 },
+{ INT64_C(0x4000000000000260), 0x1.0000000000001p+62, -0x1.ap+8 },
+{ INT64_C(0xbffffffffffffd9f), -0x1.0000000000001p+62, 0x1.9fp+8 },
+{ INT64_C(0x4000000000000280), 0x1.0000000000001p+62, -0x1.8p+8 },
+{ INT64_C(0xbffffffffffffd7f), -0x1.0000000000001p+62, 0x1.7fp+8 },
+{ INT64_C(0x4000000000000288), 0x1.0000000000001p+62, -0x1.78p+8 },
+{ INT64_C(0xbffffffffffffd77), -0x1.0000000000001p+62, 0x1.77p+8 },
+{ INT64_C(0x40000000000002a0), 0x1.0000000000001p+62, -0x1.6p+8 },
+{ INT64_C(0xbffffffffffffd5f), -0x1.0000000000001p+62, 0x1.5fp+8 },
+{ INT64_C(0x4000000000002008), 0x1.0000000000008p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffffffdff7), -0x1.0000000000008p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000002080), 0x1.0000000000008p+62, 0x1p+7 },
+{ INT64_C(0xbfffffffffffdf7f), -0x1.0000000000008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000000002082), 0x1.0000000000008p+62, 0x1.04p+7 },
+{ INT64_C(0xbfffffffffffdf7d), -0x1.0000000000008p+62, -0x1.06p+7 },
+{ INT64_C(0x4000000000002084), 0x1.0000000000008p+62, 0x1.08p+7 },
+{ INT64_C(0xbfffffffffffdf7b), -0x1.0000000000008p+62, -0x1.0ap+7 },
+{ INT64_C(0x4000000000002090), 0x1.0000000000008p+62, 0x1.2p+7 },
+{ INT64_C(0xbfffffffffffdf6f), -0x1.0000000000008p+62, -0x1.22p+7 },
+{ INT64_C(0x40000000000020c0), 0x1.0000000000008p+62, 0x1.8p+7 },
+{ INT64_C(0xbfffffffffffdf3f), -0x1.0000000000008p+62, -0x1.82p+7 },
+{ INT64_C(0x4000000000002800), 0x1.000000000000ap+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffffd7ff), -0x1.000000000000ap+62, -0x1p+0 },
+{ INT64_C(0x4000000000002808), 0x1.000000000000ap+62, 0x1p+3 },
+{ INT64_C(0xbfffffffffffd7f7), -0x1.000000000000ap+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000002840), 0x1.000000000000ap+62, 0x1p+6 },
+{ INT64_C(0xbfffffffffffd7bf), -0x1.000000000000ap+62, -0x1.04p+6 },
+{ INT64_C(0x4000000000002900), 0x1.000000000000ap+62, 0x1p+8 },
+{ INT64_C(0xbfffffffffffd6ff), -0x1.000000000000ap+62, -0x1.01p+8 },
+{ INT64_C(0x4000000000010004), 0x1.000000000004p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffffefffb), -0x1.000000000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000010040), 0x1.000000000004p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffffeffbf), -0x1.000000000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000000010048), 0x1.000000000004p+62, 0x1.2p+6 },
+{ INT64_C(0xbffffffffffeffb7), -0x1.000000000004p+62, -0x1.24p+6 },
+{ INT64_C(0x4000000000010050), 0x1.000000000004p+62, 0x1.4p+6 },
+{ INT64_C(0xbffffffffffeffaf), -0x1.000000000004p+62, -0x1.44p+6 },
+{ INT64_C(0x4000000000010200), 0x1.000000000004p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffffefdff), -0x1.0000000000041p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000010204), 0x1.0000000000041p+62, -0x1.fcp+8 },
+{ INT64_C(0xbffffffffffefdfb), -0x1.0000000000041p+62, 0x1.fbp+8 },
+{ INT64_C(0x4000000000010210), 0x1.0000000000041p+62, -0x1.fp+8 },
+{ INT64_C(0xbffffffffffefdef), -0x1.0000000000041p+62, 0x1.efp+8 },
+{ INT64_C(0x4000000000010280), 0x1.0000000000041p+62, -0x1.8p+8 },
+{ INT64_C(0xbffffffffffefd7f), -0x1.0000000000041p+62, 0x1.7fp+8 },
+{ INT64_C(0x4000000000010800), 0x1.0000000000042p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffef7ff), -0x1.0000000000042p+62, -0x1p+0 },
+{ INT64_C(0x4000000000010804), 0x1.0000000000042p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffffef7fb), -0x1.0000000000042p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000010808), 0x1.0000000000042p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffffef7f7), -0x1.0000000000042p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000010880), 0x1.0000000000042p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffffef77f), -0x1.0000000000042p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000000010a00), 0x1.0000000000042p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffffef5ff), -0x1.0000000000043p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000010c00), 0x1.0000000000043p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffef3ff), -0x1.0000000000043p+62, -0x1p+0 },
+{ INT64_C(0x4000000000014000), 0x1.000000000005p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffebfff), -0x1.000000000005p+62, -0x1p+0 },
+{ INT64_C(0x4000000000014004), 0x1.000000000005p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffffebffb), -0x1.000000000005p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000014040), 0x1.000000000005p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffffebfbf), -0x1.000000000005p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000000014100), 0x1.000000000005p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffffebeff), -0x1.000000000005p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000000014200), 0x1.000000000005p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffffebdff), -0x1.0000000000051p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000015000), 0x1.0000000000054p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffeafff), -0x1.0000000000054p+62, -0x1p+0 },
+{ INT64_C(0x4000000000016000), 0x1.0000000000058p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffe9fff), -0x1.0000000000058p+62, -0x1p+0 },
+{ INT64_C(0x4000000000020008), 0x1.000000000008p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffffdfff7), -0x1.000000000008p+62, -0x1.2p+3 },
+{ INT64_C(0x400000000002000c), 0x1.000000000008p+62, 0x1.8p+3 },
+{ INT64_C(0xbffffffffffdfff3), -0x1.000000000008p+62, -0x1.ap+3 },
+{ INT64_C(0x4000000000020010), 0x1.000000000008p+62, 0x1p+4 },
+{ INT64_C(0xbffffffffffdffef), -0x1.000000000008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000000020011), 0x1.000000000008p+62, 0x1.1p+4 },
+{ INT64_C(0xbffffffffffdffee), -0x1.000000000008p+62, -0x1.2p+4 },
+{ INT64_C(0x4000000000020014), 0x1.000000000008p+62, 0x1.4p+4 },
+{ INT64_C(0xbffffffffffdffeb), -0x1.000000000008p+62, -0x1.5p+4 },
+{ INT64_C(0x4000000000020100), 0x1.000000000008p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffffdfeff), -0x1.000000000008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000000020104), 0x1.000000000008p+62, 0x1.04p+8 },
+{ INT64_C(0xbffffffffffdfefb), -0x1.000000000008p+62, -0x1.05p+8 },
+{ INT64_C(0x4000000000020108), 0x1.000000000008p+62, 0x1.08p+8 },
+{ INT64_C(0xbffffffffffdfef7), -0x1.000000000008p+62, -0x1.09p+8 },
+{ INT64_C(0x4000000000020110), 0x1.000000000008p+62, 0x1.1p+8 },
+{ INT64_C(0xbffffffffffdfeef), -0x1.000000000008p+62, -0x1.11p+8 },
+{ INT64_C(0x4000000000020200), 0x1.000000000008p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffffdfdff), -0x1.0000000000081p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000020208), 0x1.0000000000081p+62, -0x1.f8p+8 },
+{ INT64_C(0xbffffffffffdfdf7), -0x1.0000000000081p+62, 0x1.f7p+8 },
+{ INT64_C(0x4000000000020280), 0x1.0000000000081p+62, -0x1.8p+8 },
+{ INT64_C(0xbffffffffffdfd7f), -0x1.0000000000081p+62, 0x1.7fp+8 },
+{ INT64_C(0x4000000000022000), 0x1.0000000000088p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffddfff), -0x1.0000000000088p+62, -0x1p+0 },
+{ INT64_C(0x4000000000022004), 0x1.0000000000088p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffffddffb), -0x1.0000000000088p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000022040), 0x1.0000000000088p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffffddfbf), -0x1.0000000000088p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000000022100), 0x1.0000000000088p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffffddeff), -0x1.0000000000088p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000000023000), 0x1.000000000008cp+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffdcfff), -0x1.000000000008cp+62, -0x1p+0 },
+{ INT64_C(0x4000000000028000), 0x1.00000000000ap+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffd7fff), -0x1.00000000000ap+62, -0x1p+0 },
+{ INT64_C(0x4000000000028004), 0x1.00000000000ap+62, 0x1p+2 },
+{ INT64_C(0xbffffffffffd7ffb), -0x1.00000000000ap+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000028010), 0x1.00000000000ap+62, 0x1p+4 },
+{ INT64_C(0xbffffffffffd7fef), -0x1.00000000000ap+62, -0x1.1p+4 },
+{ INT64_C(0x4000000000028080), 0x1.00000000000ap+62, 0x1p+7 },
+{ INT64_C(0xbffffffffffd7f7f), -0x1.00000000000ap+62, -0x1.02p+7 },
+{ INT64_C(0x4000000000028400), 0x1.00000000000a1p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffd7bff), -0x1.00000000000a1p+62, -0x1p+0 },
+{ INT64_C(0x400000000002a000), 0x1.00000000000a8p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffffd5fff), -0x1.00000000000a8p+62, -0x1p+0 },
+{ INT64_C(0x4000000000100008), 0x1.00000000004p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffffeffff7), -0x1.00000000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000100020), 0x1.00000000004p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffffefffdf), -0x1.00000000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000000100022), 0x1.00000000004p+62, 0x1.1p+5 },
+{ INT64_C(0xbfffffffffefffdd), -0x1.00000000004p+62, -0x1.18p+5 },
+{ INT64_C(0x4000000000100200), 0x1.00000000004p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffffeffdff), -0x1.0000000000401p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000100208), 0x1.0000000000401p+62, -0x1.f8p+8 },
+{ INT64_C(0xbfffffffffeffdf7), -0x1.0000000000401p+62, 0x1.f7p+8 },
+{ INT64_C(0x4000000000100210), 0x1.0000000000401p+62, -0x1.fp+8 },
+{ INT64_C(0xbfffffffffeffdef), -0x1.0000000000401p+62, 0x1.efp+8 },
+{ INT64_C(0x4000000000100240), 0x1.0000000000401p+62, -0x1.cp+8 },
+{ INT64_C(0xbfffffffffeffdbf), -0x1.0000000000401p+62, 0x1.bfp+8 },
+{ INT64_C(0x4000000000102000), 0x1.0000000000408p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffefdfff), -0x1.0000000000408p+62, -0x1p+0 },
+{ INT64_C(0x4000000000102001), 0x1.0000000000408p+62, 0x1p+0 },
+{ INT64_C(0xbfffffffffefdffe), -0x1.0000000000408p+62, -0x1p+1 },
+{ INT64_C(0x4000000000102002), 0x1.0000000000408p+62, 0x1p+1 },
+{ INT64_C(0xbfffffffffefdffd), -0x1.0000000000408p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000000102004), 0x1.0000000000408p+62, 0x1p+2 },
+{ INT64_C(0xbfffffffffefdffb), -0x1.0000000000408p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000102010), 0x1.0000000000408p+62, 0x1p+4 },
+{ INT64_C(0xbfffffffffefdfef), -0x1.0000000000408p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000000102040), 0x1.0000000000408p+62, 0x1p+6 },
+{ INT64_C(0xbfffffffffefdfbf), -0x1.0000000000408p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000000102200), 0x1.0000000000408p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffffefddff), -0x1.0000000000409p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000103000), 0x1.000000000040cp+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffefcfff), -0x1.000000000040cp+62, -0x1p+0 },
+{ INT64_C(0x4000000000108000), 0x1.000000000042p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffef7fff), -0x1.000000000042p+62, -0x1p+0 },
+{ INT64_C(0x4000000000108001), 0x1.000000000042p+62, 0x1p+0 },
+{ INT64_C(0xbfffffffffef7ffe), -0x1.000000000042p+62, -0x1p+1 },
+{ INT64_C(0x4000000000108008), 0x1.000000000042p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffffef7ff7), -0x1.000000000042p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000108020), 0x1.000000000042p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffffef7fdf), -0x1.000000000042p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000000108200), 0x1.000000000042p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffffef7dff), -0x1.0000000000421p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000108800), 0x1.0000000000422p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffef77ff), -0x1.0000000000422p+62, -0x1p+0 },
+{ INT64_C(0x400000000010c000), 0x1.000000000043p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffef3fff), -0x1.000000000043p+62, -0x1p+0 },
+{ INT64_C(0x4000000000140000), 0x1.00000000005p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffebffff), -0x1.00000000005p+62, -0x1p+0 },
+{ INT64_C(0x4000000000140004), 0x1.00000000005p+62, 0x1p+2 },
+{ INT64_C(0xbfffffffffebfffb), -0x1.00000000005p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000000140008), 0x1.00000000005p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffffebfff7), -0x1.00000000005p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000140020), 0x1.00000000005p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffffebffdf), -0x1.00000000005p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000000140040), 0x1.00000000005p+62, 0x1p+6 },
+{ INT64_C(0xbfffffffffebffbf), -0x1.00000000005p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000000140100), 0x1.00000000005p+62, 0x1p+8 },
+{ INT64_C(0xbfffffffffebfeff), -0x1.00000000005p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000000140200), 0x1.00000000005p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffffebfdff), -0x1.0000000000501p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000000141000), 0x1.0000000000504p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffebefff), -0x1.0000000000504p+62, -0x1p+0 },
+{ INT64_C(0x4000000000144000), 0x1.000000000051p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffebbfff), -0x1.000000000051p+62, -0x1p+0 },
+{ INT64_C(0x4000000000150000), 0x1.000000000054p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffeaffff), -0x1.000000000054p+62, -0x1p+0 },
+{ INT64_C(0x4000000000180000), 0x1.00000000006p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffe7ffff), -0x1.00000000006p+62, -0x1p+0 },
+{ INT64_C(0x4000000000180008), 0x1.00000000006p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffffe7fff7), -0x1.00000000006p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000000180010), 0x1.00000000006p+62, 0x1p+4 },
+{ INT64_C(0xbfffffffffe7ffef), -0x1.00000000006p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000000180100), 0x1.00000000006p+62, 0x1p+8 },
+{ INT64_C(0xbfffffffffe7feff), -0x1.00000000006p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000000181000), 0x1.0000000000604p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffe7efff), -0x1.0000000000604p+62, -0x1p+0 },
+{ INT64_C(0x4000000000182000), 0x1.0000000000608p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffe7dfff), -0x1.0000000000608p+62, -0x1p+0 },
+{ INT64_C(0x4000000000190000), 0x1.000000000064p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffffe6ffff), -0x1.000000000064p+62, -0x1p+0 },
+{ INT64_C(0x4000000001000002), 0x1.0000000004p+62, 0x1p+1 },
+{ INT64_C(0xbffffffffefffffd), -0x1.0000000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000001000020), 0x1.0000000004p+62, 0x1p+5 },
+{ INT64_C(0xbffffffffeffffdf), -0x1.0000000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000001000022), 0x1.0000000004p+62, 0x1.1p+5 },
+{ INT64_C(0xbffffffffeffffdd), -0x1.0000000004p+62, -0x1.18p+5 },
+{ INT64_C(0x4000000001000028), 0x1.0000000004p+62, 0x1.4p+5 },
+{ INT64_C(0xbffffffffeffffd7), -0x1.0000000004p+62, -0x1.48p+5 },
+{ INT64_C(0x4000000001000080), 0x1.0000000004p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffeffff7f), -0x1.0000000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000001000084), 0x1.0000000004p+62, 0x1.08p+7 },
+{ INT64_C(0xbffffffffeffff7b), -0x1.0000000004p+62, -0x1.0ap+7 },
+{ INT64_C(0x40000000010000c0), 0x1.0000000004p+62, 0x1.8p+7 },
+{ INT64_C(0xbffffffffeffff3f), -0x1.0000000004p+62, -0x1.82p+7 },
+{ INT64_C(0x4000000001000400), 0x1.0000000004001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffefffbff), -0x1.0000000004001p+62, -0x1p+0 },
+{ INT64_C(0x4000000001000404), 0x1.0000000004001p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffefffbfb), -0x1.0000000004001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000001000440), 0x1.0000000004001p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffefffbbf), -0x1.0000000004001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000001000500), 0x1.0000000004001p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffefffaff), -0x1.0000000004001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000001000600), 0x1.0000000004002p+62, -0x1p+9 },
+{ INT64_C(0xbffffffffefff9ff), -0x1.0000000004002p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000001004000), 0x1.000000000401p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffeffbfff), -0x1.000000000401p+62, -0x1p+0 },
+{ INT64_C(0x4000000001004002), 0x1.000000000401p+62, 0x1p+1 },
+{ INT64_C(0xbffffffffeffbffd), -0x1.000000000401p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000001004008), 0x1.000000000401p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffeffbff7), -0x1.000000000401p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000001004020), 0x1.000000000401p+62, 0x1p+5 },
+{ INT64_C(0xbffffffffeffbfdf), -0x1.000000000401p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000001004100), 0x1.000000000401p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffeffbeff), -0x1.000000000401p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000001004200), 0x1.000000000401p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffeffbdff), -0x1.0000000004011p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000001006000), 0x1.0000000004018p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffeff9fff), -0x1.0000000004018p+62, -0x1p+0 },
+{ INT64_C(0x4000000001020000), 0x1.000000000408p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffefdffff), -0x1.000000000408p+62, -0x1p+0 },
+{ INT64_C(0x4000000001020001), 0x1.000000000408p+62, 0x1p+0 },
+{ INT64_C(0xbffffffffefdfffe), -0x1.000000000408p+62, -0x1p+1 },
+{ INT64_C(0x4000000001020004), 0x1.000000000408p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffefdfffb), -0x1.000000000408p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000001020020), 0x1.000000000408p+62, 0x1p+5 },
+{ INT64_C(0xbffffffffefdffdf), -0x1.000000000408p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000001020080), 0x1.000000000408p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffefdff7f), -0x1.000000000408p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000001020400), 0x1.0000000004081p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffefdfbff), -0x1.0000000004081p+62, -0x1p+0 },
+{ INT64_C(0x4000000001020800), 0x1.0000000004082p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffefdf7ff), -0x1.0000000004082p+62, -0x1p+0 },
+{ INT64_C(0x4000000001028000), 0x1.00000000040ap+62, 0x0p+0 },
+{ INT64_C(0xbffffffffefd7fff), -0x1.00000000040ap+62, -0x1p+0 },
+{ INT64_C(0x4000000001100000), 0x1.00000000044p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffeefffff), -0x1.00000000044p+62, -0x1p+0 },
+{ INT64_C(0x4000000001100008), 0x1.00000000044p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffeeffff7), -0x1.00000000044p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000001100080), 0x1.00000000044p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffeefff7f), -0x1.00000000044p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000001100800), 0x1.0000000004402p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffeeff7ff), -0x1.0000000004402p+62, -0x1p+0 },
+{ INT64_C(0x4000000001108000), 0x1.000000000442p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffeef7fff), -0x1.000000000442p+62, -0x1p+0 },
+{ INT64_C(0x4000000001110000), 0x1.000000000444p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffeeeffff), -0x1.000000000444p+62, -0x1p+0 },
+{ INT64_C(0x4000000002000008), 0x1.0000000008p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffdfffff7), -0x1.0000000008p+62, -0x1.2p+3 },
+{ INT64_C(0x400000000200000a), 0x1.0000000008p+62, 0x1.4p+3 },
+{ INT64_C(0xbffffffffdfffff5), -0x1.0000000008p+62, -0x1.6p+3 },
+{ INT64_C(0x4000000002000010), 0x1.0000000008p+62, 0x1p+4 },
+{ INT64_C(0xbffffffffdffffef), -0x1.0000000008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000002000018), 0x1.0000000008p+62, 0x1.8p+4 },
+{ INT64_C(0xbffffffffdffffe7), -0x1.0000000008p+62, -0x1.9p+4 },
+{ INT64_C(0x4000000002000040), 0x1.0000000008p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffdffffbf), -0x1.0000000008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000002000042), 0x1.0000000008p+62, 0x1.08p+6 },
+{ INT64_C(0xbffffffffdffffbd), -0x1.0000000008p+62, -0x1.0cp+6 },
+{ INT64_C(0x4000000002000050), 0x1.0000000008p+62, 0x1.4p+6 },
+{ INT64_C(0xbffffffffdffffaf), -0x1.0000000008p+62, -0x1.44p+6 },
+{ INT64_C(0x4000000002000080), 0x1.0000000008p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffdffff7f), -0x1.0000000008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000002000082), 0x1.0000000008p+62, 0x1.04p+7 },
+{ INT64_C(0xbffffffffdffff7d), -0x1.0000000008p+62, -0x1.06p+7 },
+{ INT64_C(0x4000000002000090), 0x1.0000000008p+62, 0x1.2p+7 },
+{ INT64_C(0xbffffffffdffff6f), -0x1.0000000008p+62, -0x1.22p+7 },
+{ INT64_C(0x4000000002000800), 0x1.0000000008002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfff7ff), -0x1.0000000008002p+62, -0x1p+0 },
+{ INT64_C(0x4000000002000804), 0x1.0000000008002p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffdfff7fb), -0x1.0000000008002p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000002000810), 0x1.0000000008002p+62, 0x1p+4 },
+{ INT64_C(0xbffffffffdfff7ef), -0x1.0000000008002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000002000840), 0x1.0000000008002p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffdfff7bf), -0x1.0000000008002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000002000900), 0x1.0000000008002p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffdfff6ff), -0x1.0000000008002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000002000c00), 0x1.0000000008003p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfff3ff), -0x1.0000000008003p+62, -0x1p+0 },
+{ INT64_C(0x4000000002008000), 0x1.000000000802p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdff7fff), -0x1.000000000802p+62, -0x1p+0 },
+{ INT64_C(0x4000000002008002), 0x1.000000000802p+62, 0x1p+1 },
+{ INT64_C(0xbffffffffdff7ffd), -0x1.000000000802p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000002008004), 0x1.000000000802p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffdff7ffb), -0x1.000000000802p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000002008040), 0x1.000000000802p+62, 0x1p+6 },
+{ INT64_C(0xbffffffffdff7fbf), -0x1.000000000802p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000002008080), 0x1.000000000802p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffdff7f7f), -0x1.000000000802p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000002008800), 0x1.0000000008022p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdff77ff), -0x1.0000000008022p+62, -0x1p+0 },
+{ INT64_C(0x4000000002009000), 0x1.0000000008024p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdff6fff), -0x1.0000000008024p+62, -0x1p+0 },
+{ INT64_C(0x400000000200c000), 0x1.000000000803p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdff3fff), -0x1.000000000803p+62, -0x1p+0 },
+{ INT64_C(0x4000000002010000), 0x1.000000000804p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfeffff), -0x1.000000000804p+62, -0x1p+0 },
+{ INT64_C(0x4000000002010004), 0x1.000000000804p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffdfefffb), -0x1.000000000804p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000002010010), 0x1.000000000804p+62, 0x1p+4 },
+{ INT64_C(0xbffffffffdfeffef), -0x1.000000000804p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000002010020), 0x1.000000000804p+62, 0x1p+5 },
+{ INT64_C(0xbffffffffdfeffdf), -0x1.000000000804p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000002010080), 0x1.000000000804p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffdfeff7f), -0x1.000000000804p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000002010100), 0x1.000000000804p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffdfefeff), -0x1.000000000804p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000002011000), 0x1.0000000008044p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfeefff), -0x1.0000000008044p+62, -0x1p+0 },
+{ INT64_C(0x4000000002020000), 0x1.000000000808p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfdffff), -0x1.000000000808p+62, -0x1p+0 },
+{ INT64_C(0x4000000002020004), 0x1.000000000808p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffdfdfffb), -0x1.000000000808p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000002020008), 0x1.000000000808p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffdfdfff7), -0x1.000000000808p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000002020010), 0x1.000000000808p+62, 0x1p+4 },
+{ INT64_C(0xbffffffffdfdffef), -0x1.000000000808p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000002020080), 0x1.000000000808p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffdfdff7f), -0x1.000000000808p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000002020800), 0x1.0000000008082p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfdf7ff), -0x1.0000000008082p+62, -0x1p+0 },
+{ INT64_C(0x4000000002021000), 0x1.0000000008084p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfdefff), -0x1.0000000008084p+62, -0x1p+0 },
+{ INT64_C(0x4000000002030000), 0x1.00000000080cp+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdfcffff), -0x1.00000000080cp+62, -0x1p+0 },
+{ INT64_C(0x4000000002080000), 0x1.00000000082p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdf7ffff), -0x1.00000000082p+62, -0x1p+0 },
+{ INT64_C(0x4000000002080008), 0x1.00000000082p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffdf7fff7), -0x1.00000000082p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000002080010), 0x1.00000000082p+62, 0x1p+4 },
+{ INT64_C(0xbffffffffdf7ffef), -0x1.00000000082p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000002080080), 0x1.00000000082p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffdf7ff7f), -0x1.00000000082p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000002080200), 0x1.00000000082p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffdf7fdff), -0x1.0000000008201p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000002081000), 0x1.0000000008204p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdf7efff), -0x1.0000000008204p+62, -0x1p+0 },
+{ INT64_C(0x4000000002082000), 0x1.0000000008208p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdf7dfff), -0x1.0000000008208p+62, -0x1p+0 },
+{ INT64_C(0x40000000020a0000), 0x1.000000000828p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdf5ffff), -0x1.000000000828p+62, -0x1p+0 },
+{ INT64_C(0x4000000002100000), 0x1.00000000084p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdefffff), -0x1.00000000084p+62, -0x1p+0 },
+{ INT64_C(0x4000000002100002), 0x1.00000000084p+62, 0x1p+1 },
+{ INT64_C(0xbffffffffdeffffd), -0x1.00000000084p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000002100008), 0x1.00000000084p+62, 0x1p+3 },
+{ INT64_C(0xbffffffffdeffff7), -0x1.00000000084p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000002100020), 0x1.00000000084p+62, 0x1p+5 },
+{ INT64_C(0xbffffffffdefffdf), -0x1.00000000084p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000002100080), 0x1.00000000084p+62, 0x1p+7 },
+{ INT64_C(0xbffffffffdefff7f), -0x1.00000000084p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000002100100), 0x1.00000000084p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffdeffeff), -0x1.00000000084p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000002100200), 0x1.00000000084p+62, 0x1p+9 },
+{ INT64_C(0xbffffffffdeffdff), -0x1.0000000008401p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000002100400), 0x1.0000000008401p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdeffbff), -0x1.0000000008401p+62, -0x1p+0 },
+{ INT64_C(0x4000000002101000), 0x1.0000000008404p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdefefff), -0x1.0000000008404p+62, -0x1p+0 },
+{ INT64_C(0x4000000002108000), 0x1.000000000842p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdef7fff), -0x1.000000000842p+62, -0x1p+0 },
+{ INT64_C(0x4000000002120000), 0x1.000000000848p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdedffff), -0x1.000000000848p+62, -0x1p+0 },
+{ INT64_C(0x4000000002200000), 0x1.00000000088p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffddfffff), -0x1.00000000088p+62, -0x1p+0 },
+{ INT64_C(0x4000000002200004), 0x1.00000000088p+62, 0x1p+2 },
+{ INT64_C(0xbffffffffddffffb), -0x1.00000000088p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000002200020), 0x1.00000000088p+62, 0x1p+5 },
+{ INT64_C(0xbffffffffddfffdf), -0x1.00000000088p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000002200100), 0x1.00000000088p+62, 0x1p+8 },
+{ INT64_C(0xbffffffffddffeff), -0x1.00000000088p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000002200800), 0x1.0000000008802p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffddff7ff), -0x1.0000000008802p+62, -0x1p+0 },
+{ INT64_C(0x4000000002202000), 0x1.0000000008808p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffddfdfff), -0x1.0000000008808p+62, -0x1p+0 },
+{ INT64_C(0x4000000002208000), 0x1.000000000882p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffddf7fff), -0x1.000000000882p+62, -0x1p+0 },
+{ INT64_C(0x4000000002210000), 0x1.000000000884p+62, 0x0p+0 },
+{ INT64_C(0xbffffffffddeffff), -0x1.000000000884p+62, -0x1p+0 },
+{ INT64_C(0x4000000002280000), 0x1.0000000008ap+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdd7ffff), -0x1.0000000008ap+62, -0x1p+0 },
+{ INT64_C(0x4000000002300000), 0x1.0000000008cp+62, 0x0p+0 },
+{ INT64_C(0xbffffffffdcfffff), -0x1.0000000008cp+62, -0x1p+0 },
+{ INT64_C(0x4000000008000002), 0x1.000000002p+62, 0x1p+1 },
+{ INT64_C(0xbffffffff7fffffd), -0x1.000000002p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000008000008), 0x1.000000002p+62, 0x1p+3 },
+{ INT64_C(0xbffffffff7fffff7), -0x1.000000002p+62, -0x1.2p+3 },
+{ INT64_C(0x400000000800000a), 0x1.000000002p+62, 0x1.4p+3 },
+{ INT64_C(0xbffffffff7fffff5), -0x1.000000002p+62, -0x1.6p+3 },
+{ INT64_C(0x400000000800000c), 0x1.000000002p+62, 0x1.8p+3 },
+{ INT64_C(0xbffffffff7fffff3), -0x1.000000002p+62, -0x1.ap+3 },
+{ INT64_C(0x4000000008000080), 0x1.000000002p+62, 0x1p+7 },
+{ INT64_C(0xbffffffff7ffff7f), -0x1.000000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000008000088), 0x1.000000002p+62, 0x1.1p+7 },
+{ INT64_C(0xbffffffff7ffff77), -0x1.000000002p+62, -0x1.12p+7 },
+{ INT64_C(0x40000000080000c0), 0x1.000000002p+62, 0x1.8p+7 },
+{ INT64_C(0xbffffffff7ffff3f), -0x1.000000002p+62, -0x1.82p+7 },
+{ INT64_C(0x4000000008000100), 0x1.000000002p+62, 0x1p+8 },
+{ INT64_C(0xbffffffff7fffeff), -0x1.000000002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000008000104), 0x1.000000002p+62, 0x1.04p+8 },
+{ INT64_C(0xbffffffff7fffefb), -0x1.000000002p+62, -0x1.05p+8 },
+{ INT64_C(0x4000000008000120), 0x1.000000002p+62, 0x1.2p+8 },
+{ INT64_C(0xbffffffff7fffedf), -0x1.000000002p+62, -0x1.21p+8 },
+{ INT64_C(0x4000000008000200), 0x1.000000002p+62, 0x1p+9 },
+{ INT64_C(0xbffffffff7fffdff), -0x1.0000000020001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000008000202), 0x1.0000000020001p+62, -0x1.fep+8 },
+{ INT64_C(0xbffffffff7fffdfd), -0x1.0000000020001p+62, 0x1.fdp+8 },
+{ INT64_C(0x4000000008000210), 0x1.0000000020001p+62, -0x1.fp+8 },
+{ INT64_C(0xbffffffff7fffdef), -0x1.0000000020001p+62, 0x1.efp+8 },
+{ INT64_C(0x4000000008000220), 0x1.0000000020001p+62, -0x1.ep+8 },
+{ INT64_C(0xbffffffff7fffddf), -0x1.0000000020001p+62, 0x1.dfp+8 },
+{ INT64_C(0x4000000008000280), 0x1.0000000020001p+62, -0x1.8p+8 },
+{ INT64_C(0xbffffffff7fffd7f), -0x1.0000000020001p+62, 0x1.7fp+8 },
+{ INT64_C(0x4000000008000300), 0x1.0000000020001p+62, -0x1p+8 },
+{ INT64_C(0xbffffffff7fffcff), -0x1.0000000020001p+62, 0x1.fep+7 },
+{ INT64_C(0x4000000008001000), 0x1.0000000020004p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7ffefff), -0x1.0000000020004p+62, -0x1p+0 },
+{ INT64_C(0x4000000008001008), 0x1.0000000020004p+62, 0x1p+3 },
+{ INT64_C(0xbffffffff7ffeff7), -0x1.0000000020004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000008001010), 0x1.0000000020004p+62, 0x1p+4 },
+{ INT64_C(0xbffffffff7ffefef), -0x1.0000000020004p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000008001020), 0x1.0000000020004p+62, 0x1p+5 },
+{ INT64_C(0xbffffffff7ffefdf), -0x1.0000000020004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000008001040), 0x1.0000000020004p+62, 0x1p+6 },
+{ INT64_C(0xbffffffff7ffefbf), -0x1.0000000020004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000008001080), 0x1.0000000020004p+62, 0x1p+7 },
+{ INT64_C(0xbffffffff7ffef7f), -0x1.0000000020004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000008001400), 0x1.0000000020005p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7ffebff), -0x1.0000000020005p+62, -0x1p+0 },
+{ INT64_C(0x4000000008008000), 0x1.000000002002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7ff7fff), -0x1.000000002002p+62, -0x1p+0 },
+{ INT64_C(0x4000000008008004), 0x1.000000002002p+62, 0x1p+2 },
+{ INT64_C(0xbffffffff7ff7ffb), -0x1.000000002002p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000008008010), 0x1.000000002002p+62, 0x1p+4 },
+{ INT64_C(0xbffffffff7ff7fef), -0x1.000000002002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000008008020), 0x1.000000002002p+62, 0x1p+5 },
+{ INT64_C(0xbffffffff7ff7fdf), -0x1.000000002002p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000008008100), 0x1.000000002002p+62, 0x1p+8 },
+{ INT64_C(0xbffffffff7ff7eff), -0x1.000000002002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000008009000), 0x1.0000000020024p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7ff6fff), -0x1.0000000020024p+62, -0x1p+0 },
+{ INT64_C(0x400000000800a000), 0x1.0000000020028p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7ff5fff), -0x1.0000000020028p+62, -0x1p+0 },
+{ INT64_C(0x4000000008020000), 0x1.000000002008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7fdffff), -0x1.000000002008p+62, -0x1p+0 },
+{ INT64_C(0x4000000008020001), 0x1.000000002008p+62, 0x1p+0 },
+{ INT64_C(0xbffffffff7fdfffe), -0x1.000000002008p+62, -0x1p+1 },
+{ INT64_C(0x4000000008020008), 0x1.000000002008p+62, 0x1p+3 },
+{ INT64_C(0xbffffffff7fdfff7), -0x1.000000002008p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000008020010), 0x1.000000002008p+62, 0x1p+4 },
+{ INT64_C(0xbffffffff7fdffef), -0x1.000000002008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000008020020), 0x1.000000002008p+62, 0x1p+5 },
+{ INT64_C(0xbffffffff7fdffdf), -0x1.000000002008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000008020040), 0x1.000000002008p+62, 0x1p+6 },
+{ INT64_C(0xbffffffff7fdffbf), -0x1.000000002008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000008020400), 0x1.0000000020081p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7fdfbff), -0x1.0000000020081p+62, -0x1p+0 },
+{ INT64_C(0x4000000008021000), 0x1.0000000020084p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7fdefff), -0x1.0000000020084p+62, -0x1p+0 },
+{ INT64_C(0x4000000008030000), 0x1.00000000200cp+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7fcffff), -0x1.00000000200cp+62, -0x1p+0 },
+{ INT64_C(0x4000000008200000), 0x1.00000000208p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7dfffff), -0x1.00000000208p+62, -0x1p+0 },
+{ INT64_C(0x4000000008200002), 0x1.00000000208p+62, 0x1p+1 },
+{ INT64_C(0xbffffffff7dffffd), -0x1.00000000208p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000008200020), 0x1.00000000208p+62, 0x1p+5 },
+{ INT64_C(0xbffffffff7dfffdf), -0x1.00000000208p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000008200100), 0x1.00000000208p+62, 0x1p+8 },
+{ INT64_C(0xbffffffff7dffeff), -0x1.00000000208p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000008200800), 0x1.0000000020802p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7dff7ff), -0x1.0000000020802p+62, -0x1p+0 },
+{ INT64_C(0x4000000008208000), 0x1.000000002082p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7df7fff), -0x1.000000002082p+62, -0x1p+0 },
+{ INT64_C(0x4000000008280000), 0x1.0000000020ap+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7d7ffff), -0x1.0000000020ap+62, -0x1p+0 },
+{ INT64_C(0x4000000008400000), 0x1.0000000021p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7bfffff), -0x1.0000000021p+62, -0x1p+0 },
+{ INT64_C(0x4000000008400002), 0x1.0000000021p+62, 0x1p+1 },
+{ INT64_C(0xbffffffff7bffffd), -0x1.0000000021p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000008400004), 0x1.0000000021p+62, 0x1p+2 },
+{ INT64_C(0xbffffffff7bffffb), -0x1.0000000021p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000008400010), 0x1.0000000021p+62, 0x1p+4 },
+{ INT64_C(0xbffffffff7bfffef), -0x1.0000000021p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000008400100), 0x1.0000000021p+62, 0x1p+8 },
+{ INT64_C(0xbffffffff7bffeff), -0x1.0000000021p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000008400800), 0x1.0000000021002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7bff7ff), -0x1.0000000021002p+62, -0x1p+0 },
+{ INT64_C(0x4000000008402000), 0x1.0000000021008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7bfdfff), -0x1.0000000021008p+62, -0x1p+0 },
+{ INT64_C(0x4000000008408000), 0x1.000000002102p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7bf7fff), -0x1.000000002102p+62, -0x1p+0 },
+{ INT64_C(0x4000000008480000), 0x1.00000000212p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff7b7ffff), -0x1.00000000212p+62, -0x1p+0 },
+{ INT64_C(0x4000000008600000), 0x1.00000000218p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff79fffff), -0x1.00000000218p+62, -0x1p+0 },
+{ INT64_C(0x4000000008800000), 0x1.0000000022p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff77fffff), -0x1.0000000022p+62, -0x1p+0 },
+{ INT64_C(0x4000000008800004), 0x1.0000000022p+62, 0x1p+2 },
+{ INT64_C(0xbffffffff77ffffb), -0x1.0000000022p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000008800008), 0x1.0000000022p+62, 0x1p+3 },
+{ INT64_C(0xbffffffff77ffff7), -0x1.0000000022p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000008800020), 0x1.0000000022p+62, 0x1p+5 },
+{ INT64_C(0xbffffffff77fffdf), -0x1.0000000022p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000008800080), 0x1.0000000022p+62, 0x1p+7 },
+{ INT64_C(0xbffffffff77fff7f), -0x1.0000000022p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000008800400), 0x1.0000000022001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff77ffbff), -0x1.0000000022001p+62, -0x1p+0 },
+{ INT64_C(0x4000000008800800), 0x1.0000000022002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff77ff7ff), -0x1.0000000022002p+62, -0x1p+0 },
+{ INT64_C(0x4000000008802000), 0x1.0000000022008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff77fdfff), -0x1.0000000022008p+62, -0x1p+0 },
+{ INT64_C(0x4000000008820000), 0x1.000000002208p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff77dffff), -0x1.000000002208p+62, -0x1p+0 },
+{ INT64_C(0x4000000008880000), 0x1.00000000222p+62, 0x0p+0 },
+{ INT64_C(0xbffffffff777ffff), -0x1.00000000222p+62, -0x1p+0 },
+{ INT64_C(0x4000000040000008), 0x1.00000001p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffbffffff7), -0x1.00000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000040000010), 0x1.00000001p+62, 0x1p+4 },
+{ INT64_C(0xbfffffffbfffffef), -0x1.00000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000040000012), 0x1.00000001p+62, 0x1.2p+4 },
+{ INT64_C(0xbfffffffbfffffed), -0x1.00000001p+62, -0x1.3p+4 },
+{ INT64_C(0x4000000040000018), 0x1.00000001p+62, 0x1.8p+4 },
+{ INT64_C(0xbfffffffbfffffe7), -0x1.00000001p+62, -0x1.9p+4 },
+{ INT64_C(0x4000000040000080), 0x1.00000001p+62, 0x1p+7 },
+{ INT64_C(0xbfffffffbfffff7f), -0x1.00000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000040000082), 0x1.00000001p+62, 0x1.04p+7 },
+{ INT64_C(0xbfffffffbfffff7d), -0x1.00000001p+62, -0x1.06p+7 },
+{ INT64_C(0x4000000040000090), 0x1.00000001p+62, 0x1.2p+7 },
+{ INT64_C(0xbfffffffbfffff6f), -0x1.00000001p+62, -0x1.22p+7 },
+{ INT64_C(0x40000000400000a0), 0x1.00000001p+62, 0x1.4p+7 },
+{ INT64_C(0xbfffffffbfffff5f), -0x1.00000001p+62, -0x1.42p+7 },
+{ INT64_C(0x4000000040000800), 0x1.0000000100002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffff7ff), -0x1.0000000100002p+62, -0x1p+0 },
+{ INT64_C(0x4000000040000801), 0x1.0000000100002p+62, 0x1p+0 },
+{ INT64_C(0xbfffffffbffff7fe), -0x1.0000000100002p+62, -0x1p+1 },
+{ INT64_C(0x4000000040000802), 0x1.0000000100002p+62, 0x1p+1 },
+{ INT64_C(0xbfffffffbffff7fd), -0x1.0000000100002p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000040000808), 0x1.0000000100002p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffbffff7f7), -0x1.0000000100002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000040000840), 0x1.0000000100002p+62, 0x1p+6 },
+{ INT64_C(0xbfffffffbffff7bf), -0x1.0000000100002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000040000900), 0x1.0000000100002p+62, 0x1p+8 },
+{ INT64_C(0xbfffffffbffff6ff), -0x1.0000000100002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000040000c00), 0x1.0000000100003p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffff3ff), -0x1.0000000100003p+62, -0x1p+0 },
+{ INT64_C(0x4000000040002000), 0x1.0000000100008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfffdfff), -0x1.0000000100008p+62, -0x1p+0 },
+{ INT64_C(0x4000000040002004), 0x1.0000000100008p+62, 0x1p+2 },
+{ INT64_C(0xbfffffffbfffdffb), -0x1.0000000100008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000040002020), 0x1.0000000100008p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffbfffdfdf), -0x1.0000000100008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000040002200), 0x1.0000000100008p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffbfffddff), -0x1.0000000100009p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000040002800), 0x1.000000010000ap+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfffd7ff), -0x1.000000010000ap+62, -0x1p+0 },
+{ INT64_C(0x4000000040020000), 0x1.000000010008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffdffff), -0x1.000000010008p+62, -0x1p+0 },
+{ INT64_C(0x4000000040020002), 0x1.000000010008p+62, 0x1p+1 },
+{ INT64_C(0xbfffffffbffdfffd), -0x1.000000010008p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000040020020), 0x1.000000010008p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffbffdffdf), -0x1.000000010008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000040020100), 0x1.000000010008p+62, 0x1p+8 },
+{ INT64_C(0xbfffffffbffdfeff), -0x1.000000010008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000040020800), 0x1.0000000100082p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffdf7ff), -0x1.0000000100082p+62, -0x1p+0 },
+{ INT64_C(0x4000000040021000), 0x1.0000000100084p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffdefff), -0x1.0000000100084p+62, -0x1p+0 },
+{ INT64_C(0x4000000040022000), 0x1.0000000100088p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffddfff), -0x1.0000000100088p+62, -0x1p+0 },
+{ INT64_C(0x4000000040030000), 0x1.00000001000cp+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffcffff), -0x1.00000001000cp+62, -0x1p+0 },
+{ INT64_C(0x4000000040040000), 0x1.00000001001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffbffff), -0x1.00000001001p+62, -0x1p+0 },
+{ INT64_C(0x4000000040040004), 0x1.00000001001p+62, 0x1p+2 },
+{ INT64_C(0xbfffffffbffbfffb), -0x1.00000001001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000040040040), 0x1.00000001001p+62, 0x1p+6 },
+{ INT64_C(0xbfffffffbffbffbf), -0x1.00000001001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000040040200), 0x1.00000001001p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffbffbfdff), -0x1.0000000100101p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000040040800), 0x1.0000000100102p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffbf7ff), -0x1.0000000100102p+62, -0x1p+0 },
+{ INT64_C(0x4000000040044000), 0x1.000000010011p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffbbfff), -0x1.000000010011p+62, -0x1p+0 },
+{ INT64_C(0x4000000040048000), 0x1.000000010012p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffb7fff), -0x1.000000010012p+62, -0x1p+0 },
+{ INT64_C(0x4000000040050000), 0x1.000000010014p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbffaffff), -0x1.000000010014p+62, -0x1p+0 },
+{ INT64_C(0x4000000040100000), 0x1.00000001004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfefffff), -0x1.00000001004p+62, -0x1p+0 },
+{ INT64_C(0x4000000040100008), 0x1.00000001004p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffbfeffff7), -0x1.00000001004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000040100040), 0x1.00000001004p+62, 0x1p+6 },
+{ INT64_C(0xbfffffffbfefffbf), -0x1.00000001004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000040100100), 0x1.00000001004p+62, 0x1p+8 },
+{ INT64_C(0xbfffffffbfeffeff), -0x1.00000001004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000040100200), 0x1.00000001004p+62, 0x1p+9 },
+{ INT64_C(0xbfffffffbfeffdff), -0x1.0000000100401p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000040102000), 0x1.0000000100408p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfefdfff), -0x1.0000000100408p+62, -0x1p+0 },
+{ INT64_C(0x4000000040104000), 0x1.000000010041p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfefbfff), -0x1.000000010041p+62, -0x1p+0 },
+{ INT64_C(0x4000000040120000), 0x1.000000010048p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfedffff), -0x1.000000010048p+62, -0x1p+0 },
+{ INT64_C(0x4000000040200000), 0x1.00000001008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfdfffff), -0x1.00000001008p+62, -0x1p+0 },
+{ INT64_C(0x4000000040200004), 0x1.00000001008p+62, 0x1p+2 },
+{ INT64_C(0xbfffffffbfdffffb), -0x1.00000001008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000040200020), 0x1.00000001008p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffbfdfffdf), -0x1.00000001008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000040200080), 0x1.00000001008p+62, 0x1p+7 },
+{ INT64_C(0xbfffffffbfdfff7f), -0x1.00000001008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000040200400), 0x1.0000000100801p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfdffbff), -0x1.0000000100801p+62, -0x1p+0 },
+{ INT64_C(0x4000000040200800), 0x1.0000000100802p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfdff7ff), -0x1.0000000100802p+62, -0x1p+0 },
+{ INT64_C(0x4000000040201000), 0x1.0000000100804p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfdfefff), -0x1.0000000100804p+62, -0x1p+0 },
+{ INT64_C(0x4000000040210000), 0x1.000000010084p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfdeffff), -0x1.000000010084p+62, -0x1p+0 },
+{ INT64_C(0x4000000040240000), 0x1.00000001009p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbfdbffff), -0x1.00000001009p+62, -0x1p+0 },
+{ INT64_C(0x4000000040800000), 0x1.0000000102p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf7fffff), -0x1.0000000102p+62, -0x1p+0 },
+{ INT64_C(0x4000000040800002), 0x1.0000000102p+62, 0x1p+1 },
+{ INT64_C(0xbfffffffbf7ffffd), -0x1.0000000102p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000040800020), 0x1.0000000102p+62, 0x1p+5 },
+{ INT64_C(0xbfffffffbf7fffdf), -0x1.0000000102p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000040800100), 0x1.0000000102p+62, 0x1p+8 },
+{ INT64_C(0xbfffffffbf7ffeff), -0x1.0000000102p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000040801000), 0x1.0000000102004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf7fefff), -0x1.0000000102004p+62, -0x1p+0 },
+{ INT64_C(0x4000000040802000), 0x1.0000000102008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf7fdfff), -0x1.0000000102008p+62, -0x1p+0 },
+{ INT64_C(0x4000000040804000), 0x1.000000010201p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf7fbfff), -0x1.000000010201p+62, -0x1p+0 },
+{ INT64_C(0x4000000040810000), 0x1.000000010204p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf7effff), -0x1.000000010204p+62, -0x1p+0 },
+{ INT64_C(0x4000000040840000), 0x1.00000001021p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf7bffff), -0x1.00000001021p+62, -0x1p+0 },
+{ INT64_C(0x4000000040c00000), 0x1.0000000103p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbf3fffff), -0x1.0000000103p+62, -0x1p+0 },
+{ INT64_C(0x4000000042000000), 0x1.0000000108p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdffffff), -0x1.0000000108p+62, -0x1p+0 },
+{ INT64_C(0x4000000042000001), 0x1.0000000108p+62, 0x1p+0 },
+{ INT64_C(0xbfffffffbdfffffe), -0x1.0000000108p+62, -0x1p+1 },
+{ INT64_C(0x4000000042000002), 0x1.0000000108p+62, 0x1p+1 },
+{ INT64_C(0xbfffffffbdfffffd), -0x1.0000000108p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000042000010), 0x1.0000000108p+62, 0x1p+4 },
+{ INT64_C(0xbfffffffbdffffef), -0x1.0000000108p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000042000080), 0x1.0000000108p+62, 0x1p+7 },
+{ INT64_C(0xbfffffffbdffff7f), -0x1.0000000108p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000042000400), 0x1.0000000108001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdfffbff), -0x1.0000000108001p+62, -0x1p+0 },
+{ INT64_C(0x4000000042001000), 0x1.0000000108004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdffefff), -0x1.0000000108004p+62, -0x1p+0 },
+{ INT64_C(0x4000000042010000), 0x1.000000010804p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdfeffff), -0x1.000000010804p+62, -0x1p+0 },
+{ INT64_C(0x4000000042020000), 0x1.000000010808p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdfdffff), -0x1.000000010808p+62, -0x1p+0 },
+{ INT64_C(0x4000000042040000), 0x1.00000001081p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdfbffff), -0x1.00000001081p+62, -0x1p+0 },
+{ INT64_C(0x4000000042200000), 0x1.00000001088p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbddfffff), -0x1.00000001088p+62, -0x1p+0 },
+{ INT64_C(0x4000000042400000), 0x1.0000000109p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffbdbfffff), -0x1.0000000109p+62, -0x1p+0 },
+{ INT64_C(0x4000000050000000), 0x1.000000014p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffafffffff), -0x1.000000014p+62, -0x1p+0 },
+{ INT64_C(0x4000000050000008), 0x1.000000014p+62, 0x1p+3 },
+{ INT64_C(0xbfffffffaffffff7), -0x1.000000014p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000050000080), 0x1.000000014p+62, 0x1p+7 },
+{ INT64_C(0xbfffffffafffff7f), -0x1.000000014p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000050000400), 0x1.0000000140001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffaffffbff), -0x1.0000000140001p+62, -0x1p+0 },
+{ INT64_C(0x4000000050004000), 0x1.000000014001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffafffbfff), -0x1.000000014001p+62, -0x1p+0 },
+{ INT64_C(0x4000000050020000), 0x1.000000014008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffaffdffff), -0x1.000000014008p+62, -0x1p+0 },
+{ INT64_C(0x4000000050100000), 0x1.00000001404p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffafefffff), -0x1.00000001404p+62, -0x1p+0 },
+{ INT64_C(0x4000000050800000), 0x1.0000000142p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffaf7fffff), -0x1.0000000142p+62, -0x1p+0 },
+{ INT64_C(0x4000000054000000), 0x1.000000015p+62, 0x0p+0 },
+{ INT64_C(0xbfffffffabffffff), -0x1.000000015p+62, -0x1p+0 },
+{ INT64_C(0x4000000100000002), 0x1.00000004p+62, 0x1p+1 },
+{ INT64_C(0xbffffffefffffffd), -0x1.00000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000100000003), 0x1.00000004p+62, 0x1.8p+1 },
+{ INT64_C(0xbffffffefffffffc), -0x1.00000004p+62, -0x1p+2 },
+{ INT64_C(0x4000000100000004), 0x1.00000004p+62, 0x1p+2 },
+{ INT64_C(0xbffffffefffffffb), -0x1.00000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000100000005), 0x1.00000004p+62, 0x1.4p+2 },
+{ INT64_C(0xbffffffefffffffa), -0x1.00000004p+62, -0x1.8p+2 },
+{ INT64_C(0x4000000100000020), 0x1.00000004p+62, 0x1p+5 },
+{ INT64_C(0xbffffffeffffffdf), -0x1.00000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000100000021), 0x1.00000004p+62, 0x1.08p+5 },
+{ INT64_C(0xbffffffeffffffde), -0x1.00000004p+62, -0x1.1p+5 },
+{ INT64_C(0x4000000100000022), 0x1.00000004p+62, 0x1.1p+5 },
+{ INT64_C(0xbffffffeffffffdd), -0x1.00000004p+62, -0x1.18p+5 },
+{ INT64_C(0x4000000100000024), 0x1.00000004p+62, 0x1.2p+5 },
+{ INT64_C(0xbffffffeffffffdb), -0x1.00000004p+62, -0x1.28p+5 },
+{ INT64_C(0x4000000100000028), 0x1.00000004p+62, 0x1.4p+5 },
+{ INT64_C(0xbffffffeffffffd7), -0x1.00000004p+62, -0x1.48p+5 },
+{ INT64_C(0x4000000100000080), 0x1.00000004p+62, 0x1p+7 },
+{ INT64_C(0xbffffffeffffff7f), -0x1.00000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000100000082), 0x1.00000004p+62, 0x1.04p+7 },
+{ INT64_C(0xbffffffeffffff7d), -0x1.00000004p+62, -0x1.06p+7 },
+{ INT64_C(0x40000001000000a0), 0x1.00000004p+62, 0x1.4p+7 },
+{ INT64_C(0xbffffffeffffff5f), -0x1.00000004p+62, -0x1.42p+7 },
+{ INT64_C(0x40000001000000c0), 0x1.00000004p+62, 0x1.8p+7 },
+{ INT64_C(0xbffffffeffffff3f), -0x1.00000004p+62, -0x1.82p+7 },
+{ INT64_C(0x4000000100000400), 0x1.0000000400001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffefffffbff), -0x1.0000000400001p+62, -0x1p+0 },
+{ INT64_C(0x4000000100000402), 0x1.0000000400001p+62, 0x1p+1 },
+{ INT64_C(0xbffffffefffffbfd), -0x1.0000000400001p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000100000408), 0x1.0000000400001p+62, 0x1p+3 },
+{ INT64_C(0xbffffffefffffbf7), -0x1.0000000400001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000100000440), 0x1.0000000400001p+62, 0x1p+6 },
+{ INT64_C(0xbffffffefffffbbf), -0x1.0000000400001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000100000600), 0x1.0000000400002p+62, -0x1p+9 },
+{ INT64_C(0xbffffffefffff9ff), -0x1.0000000400002p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000100000800), 0x1.0000000400002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffefffff7ff), -0x1.0000000400002p+62, -0x1p+0 },
+{ INT64_C(0x4000000100000804), 0x1.0000000400002p+62, 0x1p+2 },
+{ INT64_C(0xbffffffefffff7fb), -0x1.0000000400002p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000100000840), 0x1.0000000400002p+62, 0x1p+6 },
+{ INT64_C(0xbffffffefffff7bf), -0x1.0000000400002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000100000a00), 0x1.0000000400002p+62, 0x1p+9 },
+{ INT64_C(0xbffffffefffff5ff), -0x1.0000000400003p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000100000c00), 0x1.0000000400003p+62, 0x0p+0 },
+{ INT64_C(0xbffffffefffff3ff), -0x1.0000000400003p+62, -0x1p+0 },
+{ INT64_C(0x4000000100004000), 0x1.000000040001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffffbfff), -0x1.000000040001p+62, -0x1p+0 },
+{ INT64_C(0x4000000100004004), 0x1.000000040001p+62, 0x1p+2 },
+{ INT64_C(0xbffffffeffffbffb), -0x1.000000040001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000100004040), 0x1.000000040001p+62, 0x1p+6 },
+{ INT64_C(0xbffffffeffffbfbf), -0x1.000000040001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000100004400), 0x1.0000000400011p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffffbbff), -0x1.0000000400011p+62, -0x1p+0 },
+{ INT64_C(0x4000000100020000), 0x1.000000040008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffefffdffff), -0x1.000000040008p+62, -0x1p+0 },
+{ INT64_C(0x4000000100020001), 0x1.000000040008p+62, 0x1p+0 },
+{ INT64_C(0xbffffffefffdfffe), -0x1.000000040008p+62, -0x1p+1 },
+{ INT64_C(0x4000000100020002), 0x1.000000040008p+62, 0x1p+1 },
+{ INT64_C(0xbffffffefffdfffd), -0x1.000000040008p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000100020008), 0x1.000000040008p+62, 0x1p+3 },
+{ INT64_C(0xbffffffefffdfff7), -0x1.000000040008p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000100020080), 0x1.000000040008p+62, 0x1p+7 },
+{ INT64_C(0xbffffffefffdff7f), -0x1.000000040008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000100020100), 0x1.000000040008p+62, 0x1p+8 },
+{ INT64_C(0xbffffffefffdfeff), -0x1.000000040008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000100020200), 0x1.000000040008p+62, 0x1p+9 },
+{ INT64_C(0xbffffffefffdfdff), -0x1.0000000400081p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000100022000), 0x1.0000000400088p+62, 0x0p+0 },
+{ INT64_C(0xbffffffefffddfff), -0x1.0000000400088p+62, -0x1p+0 },
+{ INT64_C(0x4000000100030000), 0x1.00000004000cp+62, 0x0p+0 },
+{ INT64_C(0xbffffffefffcffff), -0x1.00000004000cp+62, -0x1p+0 },
+{ INT64_C(0x4000000100200000), 0x1.00000004008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffdfffff), -0x1.00000004008p+62, -0x1p+0 },
+{ INT64_C(0x4000000100200004), 0x1.00000004008p+62, 0x1p+2 },
+{ INT64_C(0xbffffffeffdffffb), -0x1.00000004008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000100200020), 0x1.00000004008p+62, 0x1p+5 },
+{ INT64_C(0xbffffffeffdfffdf), -0x1.00000004008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000100200080), 0x1.00000004008p+62, 0x1p+7 },
+{ INT64_C(0xbffffffeffdfff7f), -0x1.00000004008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000100200400), 0x1.0000000400801p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffdffbff), -0x1.0000000400801p+62, -0x1p+0 },
+{ INT64_C(0x4000000100202000), 0x1.0000000400808p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffdfdfff), -0x1.0000000400808p+62, -0x1p+0 },
+{ INT64_C(0x4000000100210000), 0x1.000000040084p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffdeffff), -0x1.000000040084p+62, -0x1p+0 },
+{ INT64_C(0x4000000100300000), 0x1.0000000400cp+62, 0x0p+0 },
+{ INT64_C(0xbffffffeffcfffff), -0x1.0000000400cp+62, -0x1p+0 },
+{ INT64_C(0x4000000100800000), 0x1.0000000402p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeff7fffff), -0x1.0000000402p+62, -0x1p+0 },
+{ INT64_C(0x4000000100800004), 0x1.0000000402p+62, 0x1p+2 },
+{ INT64_C(0xbffffffeff7ffffb), -0x1.0000000402p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000100800010), 0x1.0000000402p+62, 0x1p+4 },
+{ INT64_C(0xbffffffeff7fffef), -0x1.0000000402p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000100800040), 0x1.0000000402p+62, 0x1p+6 },
+{ INT64_C(0xbffffffeff7fffbf), -0x1.0000000402p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000100800080), 0x1.0000000402p+62, 0x1p+7 },
+{ INT64_C(0xbffffffeff7fff7f), -0x1.0000000402p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000100800100), 0x1.0000000402p+62, 0x1p+8 },
+{ INT64_C(0xbffffffeff7ffeff), -0x1.0000000402p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000100800400), 0x1.0000000402001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeff7ffbff), -0x1.0000000402001p+62, -0x1p+0 },
+{ INT64_C(0x4000000100804000), 0x1.000000040201p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeff7fbfff), -0x1.000000040201p+62, -0x1p+0 },
+{ INT64_C(0x4000000100810000), 0x1.000000040204p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeff7effff), -0x1.000000040204p+62, -0x1p+0 },
+{ INT64_C(0x4000000100900000), 0x1.00000004024p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeff6fffff), -0x1.00000004024p+62, -0x1p+0 },
+{ INT64_C(0x4000000100c00000), 0x1.0000000403p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeff3fffff), -0x1.0000000403p+62, -0x1p+0 },
+{ INT64_C(0x4000000108000000), 0x1.000000042p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef7ffffff), -0x1.000000042p+62, -0x1p+0 },
+{ INT64_C(0x4000000108000008), 0x1.000000042p+62, 0x1p+3 },
+{ INT64_C(0xbffffffef7fffff7), -0x1.000000042p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000108000020), 0x1.000000042p+62, 0x1p+5 },
+{ INT64_C(0xbffffffef7ffffdf), -0x1.000000042p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000108000040), 0x1.000000042p+62, 0x1p+6 },
+{ INT64_C(0xbffffffef7ffffbf), -0x1.000000042p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000108000080), 0x1.000000042p+62, 0x1p+7 },
+{ INT64_C(0xbffffffef7ffff7f), -0x1.000000042p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000108000400), 0x1.0000000420001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef7fffbff), -0x1.0000000420001p+62, -0x1p+0 },
+{ INT64_C(0x4000000108004000), 0x1.000000042001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef7ffbfff), -0x1.000000042001p+62, -0x1p+0 },
+{ INT64_C(0x4000000108020000), 0x1.000000042008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef7fdffff), -0x1.000000042008p+62, -0x1p+0 },
+{ INT64_C(0x4000000108100000), 0x1.00000004204p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef7efffff), -0x1.00000004204p+62, -0x1p+0 },
+{ INT64_C(0x4000000108400000), 0x1.0000000421p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef7bfffff), -0x1.0000000421p+62, -0x1p+0 },
+{ INT64_C(0x400000010c000000), 0x1.000000043p+62, 0x0p+0 },
+{ INT64_C(0xbffffffef3ffffff), -0x1.000000043p+62, -0x1p+0 },
+{ INT64_C(0x4000000110000000), 0x1.000000044p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeefffffff), -0x1.000000044p+62, -0x1p+0 },
+{ INT64_C(0x4000000110000001), 0x1.000000044p+62, 0x1p+0 },
+{ INT64_C(0xbffffffeeffffffe), -0x1.000000044p+62, -0x1p+1 },
+{ INT64_C(0x4000000110000004), 0x1.000000044p+62, 0x1p+2 },
+{ INT64_C(0xbffffffeeffffffb), -0x1.000000044p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000110000010), 0x1.000000044p+62, 0x1p+4 },
+{ INT64_C(0xbffffffeefffffef), -0x1.000000044p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000110000020), 0x1.000000044p+62, 0x1p+5 },
+{ INT64_C(0xbffffffeefffffdf), -0x1.000000044p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000110000200), 0x1.000000044p+62, 0x1p+9 },
+{ INT64_C(0xbffffffeeffffdff), -0x1.0000000440001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000110001000), 0x1.0000000440004p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeefffefff), -0x1.0000000440004p+62, -0x1p+0 },
+{ INT64_C(0x4000000110008000), 0x1.000000044002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeefff7fff), -0x1.000000044002p+62, -0x1p+0 },
+{ INT64_C(0x4000000110040000), 0x1.00000004401p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeeffbffff), -0x1.00000004401p+62, -0x1p+0 },
+{ INT64_C(0x4000000110080000), 0x1.00000004402p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeeff7ffff), -0x1.00000004402p+62, -0x1p+0 },
+{ INT64_C(0x4000000110800000), 0x1.0000000442p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeef7fffff), -0x1.0000000442p+62, -0x1p+0 },
+{ INT64_C(0x4000000111000000), 0x1.0000000444p+62, 0x0p+0 },
+{ INT64_C(0xbffffffeeeffffff), -0x1.0000000444p+62, -0x1p+0 },
+{ INT64_C(0x4000000118000000), 0x1.000000046p+62, 0x0p+0 },
+{ INT64_C(0xbffffffee7ffffff), -0x1.000000046p+62, -0x1p+0 },
+{ INT64_C(0x4000000400000004), 0x1.0000001p+62, 0x1p+2 },
+{ INT64_C(0xbffffffbfffffffb), -0x1.0000001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000400000010), 0x1.0000001p+62, 0x1p+4 },
+{ INT64_C(0xbffffffbffffffef), -0x1.0000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000400000012), 0x1.0000001p+62, 0x1.2p+4 },
+{ INT64_C(0xbffffffbffffffed), -0x1.0000001p+62, -0x1.3p+4 },
+{ INT64_C(0x4000000400000100), 0x1.0000001p+62, 0x1p+8 },
+{ INT64_C(0xbffffffbfffffeff), -0x1.0000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000400000104), 0x1.0000001p+62, 0x1.04p+8 },
+{ INT64_C(0xbffffffbfffffefb), -0x1.0000001p+62, -0x1.05p+8 },
+{ INT64_C(0x4000000400000110), 0x1.0000001p+62, 0x1.1p+8 },
+{ INT64_C(0xbffffffbfffffeef), -0x1.0000001p+62, -0x1.11p+8 },
+{ INT64_C(0x4000000400000180), 0x1.0000001p+62, 0x1.8p+8 },
+{ INT64_C(0xbffffffbfffffe7f), -0x1.0000001p+62, -0x1.81p+8 },
+{ INT64_C(0x4000000400000200), 0x1.0000001p+62, 0x1p+9 },
+{ INT64_C(0xbffffffbfffffdff), -0x1.0000001000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000400000201), 0x1.0000001000001p+62, -0x1.ffp+8 },
+{ INT64_C(0xbffffffbfffffdfe), -0x1.0000001000001p+62, 0x1.fep+8 },
+{ INT64_C(0x4000000400000210), 0x1.0000001000001p+62, -0x1.fp+8 },
+{ INT64_C(0xbffffffbfffffdef), -0x1.0000001000001p+62, 0x1.efp+8 },
+{ INT64_C(0x4000000400000300), 0x1.0000001000001p+62, -0x1p+8 },
+{ INT64_C(0xbffffffbfffffcff), -0x1.0000001000001p+62, 0x1.fep+7 },
+{ INT64_C(0x4000000400000800), 0x1.0000001000002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfffff7ff), -0x1.0000001000002p+62, -0x1p+0 },
+{ INT64_C(0x4000000400000804), 0x1.0000001000002p+62, 0x1p+2 },
+{ INT64_C(0xbffffffbfffff7fb), -0x1.0000001000002p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000400000808), 0x1.0000001000002p+62, 0x1p+3 },
+{ INT64_C(0xbffffffbfffff7f7), -0x1.0000001000002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000400000880), 0x1.0000001000002p+62, 0x1p+7 },
+{ INT64_C(0xbffffffbfffff77f), -0x1.0000001000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000400000a00), 0x1.0000001000002p+62, 0x1p+9 },
+{ INT64_C(0xbffffffbfffff5ff), -0x1.0000001000003p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000400000c00), 0x1.0000001000003p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfffff3ff), -0x1.0000001000003p+62, -0x1p+0 },
+{ INT64_C(0x4000000400008000), 0x1.000000100002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffff7fff), -0x1.000000100002p+62, -0x1p+0 },
+{ INT64_C(0x4000000400008008), 0x1.000000100002p+62, 0x1p+3 },
+{ INT64_C(0xbffffffbffff7ff7), -0x1.000000100002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000400008080), 0x1.000000100002p+62, 0x1p+7 },
+{ INT64_C(0xbffffffbffff7f7f), -0x1.000000100002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000400008800), 0x1.0000001000022p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffff77ff), -0x1.0000001000022p+62, -0x1p+0 },
+{ INT64_C(0x400000040000c000), 0x1.000000100003p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffff3fff), -0x1.000000100003p+62, -0x1p+0 },
+{ INT64_C(0x4000000400080000), 0x1.00000010002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfff7ffff), -0x1.00000010002p+62, -0x1p+0 },
+{ INT64_C(0x4000000400080002), 0x1.00000010002p+62, 0x1p+1 },
+{ INT64_C(0xbffffffbfff7fffd), -0x1.00000010002p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000400080008), 0x1.00000010002p+62, 0x1p+3 },
+{ INT64_C(0xbffffffbfff7fff7), -0x1.00000010002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000400080080), 0x1.00000010002p+62, 0x1p+7 },
+{ INT64_C(0xbffffffbfff7ff7f), -0x1.00000010002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000000400080100), 0x1.00000010002p+62, 0x1p+8 },
+{ INT64_C(0xbffffffbfff7feff), -0x1.00000010002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000400080800), 0x1.0000001000202p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfff7f7ff), -0x1.0000001000202p+62, -0x1p+0 },
+{ INT64_C(0x4000000400081000), 0x1.0000001000204p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfff7efff), -0x1.0000001000204p+62, -0x1p+0 },
+{ INT64_C(0x4000000400088000), 0x1.000000100022p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfff77fff), -0x1.000000100022p+62, -0x1p+0 },
+{ INT64_C(0x4000000400090000), 0x1.000000100024p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfff6ffff), -0x1.000000100024p+62, -0x1p+0 },
+{ INT64_C(0x4000000400200000), 0x1.00000010008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffdfffff), -0x1.00000010008p+62, -0x1p+0 },
+{ INT64_C(0x4000000400200001), 0x1.00000010008p+62, 0x1p+0 },
+{ INT64_C(0xbffffffbffdffffe), -0x1.00000010008p+62, -0x1p+1 },
+{ INT64_C(0x4000000400200008), 0x1.00000010008p+62, 0x1p+3 },
+{ INT64_C(0xbffffffbffdffff7), -0x1.00000010008p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000400200010), 0x1.00000010008p+62, 0x1p+4 },
+{ INT64_C(0xbffffffbffdfffef), -0x1.00000010008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000000400200020), 0x1.00000010008p+62, 0x1p+5 },
+{ INT64_C(0xbffffffbffdfffdf), -0x1.00000010008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000400200040), 0x1.00000010008p+62, 0x1p+6 },
+{ INT64_C(0xbffffffbffdfffbf), -0x1.00000010008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000400200400), 0x1.0000001000801p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffdffbff), -0x1.0000001000801p+62, -0x1p+0 },
+{ INT64_C(0x4000000400204000), 0x1.000000100081p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffdfbfff), -0x1.000000100081p+62, -0x1p+0 },
+{ INT64_C(0x4000000400220000), 0x1.000000100088p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbffddffff), -0x1.000000100088p+62, -0x1p+0 },
+{ INT64_C(0x4000000401000000), 0x1.0000001004p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfeffffff), -0x1.0000001004p+62, -0x1p+0 },
+{ INT64_C(0x4000000401000004), 0x1.0000001004p+62, 0x1p+2 },
+{ INT64_C(0xbffffffbfefffffb), -0x1.0000001004p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000401000008), 0x1.0000001004p+62, 0x1p+3 },
+{ INT64_C(0xbffffffbfefffff7), -0x1.0000001004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000401000040), 0x1.0000001004p+62, 0x1p+6 },
+{ INT64_C(0xbffffffbfeffffbf), -0x1.0000001004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000401000100), 0x1.0000001004p+62, 0x1p+8 },
+{ INT64_C(0xbffffffbfefffeff), -0x1.0000001004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000401000200), 0x1.0000001004p+62, 0x1p+9 },
+{ INT64_C(0xbffffffbfefffdff), -0x1.0000001004001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000401000800), 0x1.0000001004002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfefff7ff), -0x1.0000001004002p+62, -0x1p+0 },
+{ INT64_C(0x4000000401004000), 0x1.000000100401p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfeffbfff), -0x1.000000100401p+62, -0x1p+0 },
+{ INT64_C(0x4000000401040000), 0x1.00000010041p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfefbffff), -0x1.00000010041p+62, -0x1p+0 },
+{ INT64_C(0x4000000401200000), 0x1.00000010048p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfedfffff), -0x1.00000010048p+62, -0x1p+0 },
+{ INT64_C(0x4000000401400000), 0x1.0000001005p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfebfffff), -0x1.0000001005p+62, -0x1p+0 },
+{ INT64_C(0x4000000404000000), 0x1.000000101p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbffffff), -0x1.000000101p+62, -0x1p+0 },
+{ INT64_C(0x4000000404000002), 0x1.000000101p+62, 0x1p+1 },
+{ INT64_C(0xbffffffbfbfffffd), -0x1.000000101p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000404000008), 0x1.000000101p+62, 0x1p+3 },
+{ INT64_C(0xbffffffbfbfffff7), -0x1.000000101p+62, -0x1.2p+3 },
+{ INT64_C(0x4000000404000020), 0x1.000000101p+62, 0x1p+5 },
+{ INT64_C(0xbffffffbfbffffdf), -0x1.000000101p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000404000100), 0x1.000000101p+62, 0x1p+8 },
+{ INT64_C(0xbffffffbfbfffeff), -0x1.000000101p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000404001000), 0x1.0000001010004p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbffefff), -0x1.0000001010004p+62, -0x1p+0 },
+{ INT64_C(0x4000000404002000), 0x1.0000001010008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbffdfff), -0x1.0000001010008p+62, -0x1p+0 },
+{ INT64_C(0x4000000404010000), 0x1.000000101004p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbfeffff), -0x1.000000101004p+62, -0x1p+0 },
+{ INT64_C(0x4000000404020000), 0x1.000000101008p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbfdffff), -0x1.000000101008p+62, -0x1p+0 },
+{ INT64_C(0x4000000404080000), 0x1.00000010102p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbf7ffff), -0x1.00000010102p+62, -0x1p+0 },
+{ INT64_C(0x4000000404100000), 0x1.00000010104p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbefffff), -0x1.00000010104p+62, -0x1p+0 },
+{ INT64_C(0x4000000404200000), 0x1.00000010108p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbfbdfffff), -0x1.00000010108p+62, -0x1p+0 },
+{ INT64_C(0x4000000406000000), 0x1.0000001018p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbf9ffffff), -0x1.0000001018p+62, -0x1p+0 },
+{ INT64_C(0x4000000410000000), 0x1.000000104p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbefffffff), -0x1.000000104p+62, -0x1p+0 },
+{ INT64_C(0x4000000410000001), 0x1.000000104p+62, 0x1p+0 },
+{ INT64_C(0xbffffffbeffffffe), -0x1.000000104p+62, -0x1p+1 },
+{ INT64_C(0x4000000410000002), 0x1.000000104p+62, 0x1p+1 },
+{ INT64_C(0xbffffffbeffffffd), -0x1.000000104p+62, -0x1.8p+1 },
+{ INT64_C(0x4000000410000004), 0x1.000000104p+62, 0x1p+2 },
+{ INT64_C(0xbffffffbeffffffb), -0x1.000000104p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000410000040), 0x1.000000104p+62, 0x1p+6 },
+{ INT64_C(0xbffffffbefffffbf), -0x1.000000104p+62, -0x1.04p+6 },
+{ INT64_C(0x4000000410000400), 0x1.0000001040001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbeffffbff), -0x1.0000001040001p+62, -0x1p+0 },
+{ INT64_C(0x4000000410001000), 0x1.0000001040004p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbefffefff), -0x1.0000001040004p+62, -0x1p+0 },
+{ INT64_C(0x4000000410004000), 0x1.000000104001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbefffbfff), -0x1.000000104001p+62, -0x1p+0 },
+{ INT64_C(0x4000000410008000), 0x1.000000104002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbefff7fff), -0x1.000000104002p+62, -0x1p+0 },
+{ INT64_C(0x4000000410080000), 0x1.00000010402p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbeff7ffff), -0x1.00000010402p+62, -0x1p+0 },
+{ INT64_C(0x4000000410400000), 0x1.0000001041p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbefbfffff), -0x1.0000001041p+62, -0x1p+0 },
+{ INT64_C(0x4000000410800000), 0x1.0000001042p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbef7fffff), -0x1.0000001042p+62, -0x1p+0 },
+{ INT64_C(0x4000000412000000), 0x1.0000001048p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbedffffff), -0x1.0000001048p+62, -0x1p+0 },
+{ INT64_C(0x4000000418000000), 0x1.000000106p+62, 0x0p+0 },
+{ INT64_C(0xbffffffbe7ffffff), -0x1.000000106p+62, -0x1p+0 },
+{ INT64_C(0x4000000500000000), 0x1.00000014p+62, 0x0p+0 },
+{ INT64_C(0xbffffffaffffffff), -0x1.00000014p+62, -0x1p+0 },
+{ INT64_C(0x4000000500000004), 0x1.00000014p+62, 0x1p+2 },
+{ INT64_C(0xbffffffafffffffb), -0x1.00000014p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000500000020), 0x1.00000014p+62, 0x1p+5 },
+{ INT64_C(0xbffffffaffffffdf), -0x1.00000014p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000500000200), 0x1.00000014p+62, 0x1p+9 },
+{ INT64_C(0xbffffffafffffdff), -0x1.0000001400001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000000500000800), 0x1.0000001400002p+62, 0x0p+0 },
+{ INT64_C(0xbffffffafffff7ff), -0x1.0000001400002p+62, -0x1p+0 },
+{ INT64_C(0x4000000500004000), 0x1.000000140001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffaffffbfff), -0x1.000000140001p+62, -0x1p+0 },
+{ INT64_C(0x4000000500040000), 0x1.00000014001p+62, 0x0p+0 },
+{ INT64_C(0xbffffffafffbffff), -0x1.00000014001p+62, -0x1p+0 },
+{ INT64_C(0x4000000500400000), 0x1.0000001401p+62, 0x0p+0 },
+{ INT64_C(0xbffffffaffbfffff), -0x1.0000001401p+62, -0x1p+0 },
+{ INT64_C(0x4000000500800000), 0x1.0000001402p+62, 0x0p+0 },
+{ INT64_C(0xbffffffaff7fffff), -0x1.0000001402p+62, -0x1p+0 },
+{ INT64_C(0x4000000508000000), 0x1.000000142p+62, 0x0p+0 },
+{ INT64_C(0xbffffffaf7ffffff), -0x1.000000142p+62, -0x1p+0 },
+{ INT64_C(0x4000000540000000), 0x1.00000015p+62, 0x0p+0 },
+{ INT64_C(0xbffffffabfffffff), -0x1.00000015p+62, -0x1p+0 },
+{ INT64_C(0x4000000600000000), 0x1.00000018p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9ffffffff), -0x1.00000018p+62, -0x1p+0 },
+{ INT64_C(0x4000000600000004), 0x1.00000018p+62, 0x1p+2 },
+{ INT64_C(0xbffffff9fffffffb), -0x1.00000018p+62, -0x1.4p+2 },
+{ INT64_C(0x4000000600000020), 0x1.00000018p+62, 0x1p+5 },
+{ INT64_C(0xbffffff9ffffffdf), -0x1.00000018p+62, -0x1.08p+5 },
+{ INT64_C(0x4000000600000100), 0x1.00000018p+62, 0x1p+8 },
+{ INT64_C(0xbffffff9fffffeff), -0x1.00000018p+62, -0x1.01p+8 },
+{ INT64_C(0x4000000600000400), 0x1.0000001800001p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9fffffbff), -0x1.0000001800001p+62, -0x1p+0 },
+{ INT64_C(0x4000000600004000), 0x1.000000180001p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9ffffbfff), -0x1.000000180001p+62, -0x1p+0 },
+{ INT64_C(0x4000000600008000), 0x1.000000180002p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9ffff7fff), -0x1.000000180002p+62, -0x1p+0 },
+{ INT64_C(0x4000000600080000), 0x1.00000018002p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9fff7ffff), -0x1.00000018002p+62, -0x1p+0 },
+{ INT64_C(0x4000000600400000), 0x1.0000001801p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9ffbfffff), -0x1.0000001801p+62, -0x1p+0 },
+{ INT64_C(0x4000000601000000), 0x1.0000001804p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9feffffff), -0x1.0000001804p+62, -0x1p+0 },
+{ INT64_C(0x4000000604000000), 0x1.000000181p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9fbffffff), -0x1.000000181p+62, -0x1p+0 },
+{ INT64_C(0x4000000608000000), 0x1.000000182p+62, 0x0p+0 },
+{ INT64_C(0xbffffff9f7ffffff), -0x1.000000182p+62, -0x1p+0 },
+{ INT64_C(0x4000000680000000), 0x1.0000001ap+62, 0x0p+0 },
+{ INT64_C(0xbffffff97fffffff), -0x1.0000001ap+62, -0x1p+0 },
+{ INT64_C(0x4000001000000008), 0x1.0000004p+62, 0x1p+3 },
+{ INT64_C(0xbfffffeffffffff7), -0x1.0000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001000000009), 0x1.0000004p+62, 0x1.2p+3 },
+{ INT64_C(0xbfffffeffffffff6), -0x1.0000004p+62, -0x1.4p+3 },
+{ INT64_C(0x400000100000000c), 0x1.0000004p+62, 0x1.8p+3 },
+{ INT64_C(0xbfffffeffffffff3), -0x1.0000004p+62, -0x1.ap+3 },
+{ INT64_C(0x4000001000000020), 0x1.0000004p+62, 0x1p+5 },
+{ INT64_C(0xbfffffefffffffdf), -0x1.0000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000001000000021), 0x1.0000004p+62, 0x1.08p+5 },
+{ INT64_C(0xbfffffefffffffde), -0x1.0000004p+62, -0x1.1p+5 },
+{ INT64_C(0x4000001000000022), 0x1.0000004p+62, 0x1.1p+5 },
+{ INT64_C(0xbfffffefffffffdd), -0x1.0000004p+62, -0x1.18p+5 },
+{ INT64_C(0x4000001000000024), 0x1.0000004p+62, 0x1.2p+5 },
+{ INT64_C(0xbfffffefffffffdb), -0x1.0000004p+62, -0x1.28p+5 },
+{ INT64_C(0x4000001000000080), 0x1.0000004p+62, 0x1p+7 },
+{ INT64_C(0xbfffffefffffff7f), -0x1.0000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000001000000082), 0x1.0000004p+62, 0x1.04p+7 },
+{ INT64_C(0xbfffffefffffff7d), -0x1.0000004p+62, -0x1.06p+7 },
+{ INT64_C(0x4000001000000088), 0x1.0000004p+62, 0x1.1p+7 },
+{ INT64_C(0xbfffffefffffff77), -0x1.0000004p+62, -0x1.12p+7 },
+{ INT64_C(0x40000010000000c0), 0x1.0000004p+62, 0x1.8p+7 },
+{ INT64_C(0xbfffffefffffff3f), -0x1.0000004p+62, -0x1.82p+7 },
+{ INT64_C(0x4000001000000100), 0x1.0000004p+62, 0x1p+8 },
+{ INT64_C(0xbfffffeffffffeff), -0x1.0000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000001000000104), 0x1.0000004p+62, 0x1.04p+8 },
+{ INT64_C(0xbfffffeffffffefb), -0x1.0000004p+62, -0x1.05p+8 },
+{ INT64_C(0x4000001000000140), 0x1.0000004p+62, 0x1.4p+8 },
+{ INT64_C(0xbfffffeffffffebf), -0x1.0000004p+62, -0x1.41p+8 },
+{ INT64_C(0x4000001000000180), 0x1.0000004p+62, 0x1.8p+8 },
+{ INT64_C(0xbfffffeffffffe7f), -0x1.0000004p+62, -0x1.81p+8 },
+{ INT64_C(0x4000001000000200), 0x1.0000004p+62, 0x1p+9 },
+{ INT64_C(0xbfffffeffffffdff), -0x1.0000004000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001000000202), 0x1.0000004000001p+62, -0x1.fep+8 },
+{ INT64_C(0xbfffffeffffffdfd), -0x1.0000004000001p+62, 0x1.fdp+8 },
+{ INT64_C(0x4000001000000204), 0x1.0000004000001p+62, -0x1.fcp+8 },
+{ INT64_C(0xbfffffeffffffdfb), -0x1.0000004000001p+62, 0x1.fbp+8 },
+{ INT64_C(0x4000001000000220), 0x1.0000004000001p+62, -0x1.ep+8 },
+{ INT64_C(0xbfffffeffffffddf), -0x1.0000004000001p+62, 0x1.dfp+8 },
+{ INT64_C(0x4000001000000240), 0x1.0000004000001p+62, -0x1.cp+8 },
+{ INT64_C(0xbfffffeffffffdbf), -0x1.0000004000001p+62, 0x1.bfp+8 },
+{ INT64_C(0x4000001000000280), 0x1.0000004000001p+62, -0x1.8p+8 },
+{ INT64_C(0xbfffffeffffffd7f), -0x1.0000004000001p+62, 0x1.7fp+8 },
+{ INT64_C(0x4000001000000400), 0x1.0000004000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffffffbff), -0x1.0000004000001p+62, -0x1p+0 },
+{ INT64_C(0x4000001000000401), 0x1.0000004000001p+62, 0x1p+0 },
+{ INT64_C(0xbfffffeffffffbfe), -0x1.0000004000001p+62, -0x1p+1 },
+{ INT64_C(0x4000001000000410), 0x1.0000004000001p+62, 0x1p+4 },
+{ INT64_C(0xbfffffeffffffbef), -0x1.0000004000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000001000000500), 0x1.0000004000001p+62, 0x1p+8 },
+{ INT64_C(0xbfffffeffffffaff), -0x1.0000004000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000001000000600), 0x1.0000004000002p+62, -0x1p+9 },
+{ INT64_C(0xbfffffeffffff9ff), -0x1.0000004000002p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001000004000), 0x1.000000400001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffffbfff), -0x1.000000400001p+62, -0x1p+0 },
+{ INT64_C(0x4000001000004001), 0x1.000000400001p+62, 0x1p+0 },
+{ INT64_C(0xbfffffefffffbffe), -0x1.000000400001p+62, -0x1p+1 },
+{ INT64_C(0x4000001000004010), 0x1.000000400001p+62, 0x1p+4 },
+{ INT64_C(0xbfffffefffffbfef), -0x1.000000400001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000001000004020), 0x1.000000400001p+62, 0x1p+5 },
+{ INT64_C(0xbfffffefffffbfdf), -0x1.000000400001p+62, -0x1.08p+5 },
+{ INT64_C(0x4000001000004200), 0x1.000000400001p+62, 0x1p+9 },
+{ INT64_C(0xbfffffefffffbdff), -0x1.0000004000011p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001000004800), 0x1.0000004000012p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffffb7ff), -0x1.0000004000012p+62, -0x1p+0 },
+{ INT64_C(0x4000001000010000), 0x1.000000400004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffffeffff), -0x1.000000400004p+62, -0x1p+0 },
+{ INT64_C(0x4000001000010008), 0x1.000000400004p+62, 0x1p+3 },
+{ INT64_C(0xbfffffeffffefff7), -0x1.000000400004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001000010020), 0x1.000000400004p+62, 0x1p+5 },
+{ INT64_C(0xbfffffeffffeffdf), -0x1.000000400004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000001000010200), 0x1.000000400004p+62, 0x1p+9 },
+{ INT64_C(0xbfffffeffffefdff), -0x1.0000004000041p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001000010800), 0x1.0000004000042p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffffef7ff), -0x1.0000004000042p+62, -0x1p+0 },
+{ INT64_C(0x4000001000011000), 0x1.0000004000044p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffffeefff), -0x1.0000004000044p+62, -0x1p+0 },
+{ INT64_C(0x4000001000080000), 0x1.00000040002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffff7ffff), -0x1.00000040002p+62, -0x1p+0 },
+{ INT64_C(0x4000001000080008), 0x1.00000040002p+62, 0x1p+3 },
+{ INT64_C(0xbfffffeffff7fff7), -0x1.00000040002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001000080010), 0x1.00000040002p+62, 0x1p+4 },
+{ INT64_C(0xbfffffeffff7ffef), -0x1.00000040002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000001000080020), 0x1.00000040002p+62, 0x1p+5 },
+{ INT64_C(0xbfffffeffff7ffdf), -0x1.00000040002p+62, -0x1.08p+5 },
+{ INT64_C(0x4000001000080080), 0x1.00000040002p+62, 0x1p+7 },
+{ INT64_C(0xbfffffeffff7ff7f), -0x1.00000040002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000001000080200), 0x1.00000040002p+62, 0x1p+9 },
+{ INT64_C(0xbfffffeffff7fdff), -0x1.0000004000201p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001000080400), 0x1.0000004000201p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffff7fbff), -0x1.0000004000201p+62, -0x1p+0 },
+{ INT64_C(0x4000001000082000), 0x1.0000004000208p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffff7dfff), -0x1.0000004000208p+62, -0x1p+0 },
+{ INT64_C(0x4000001000088000), 0x1.000000400022p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffff77fff), -0x1.000000400022p+62, -0x1p+0 },
+{ INT64_C(0x40000010000a0000), 0x1.000000400028p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffff5ffff), -0x1.000000400028p+62, -0x1p+0 },
+{ INT64_C(0x4000001000200000), 0x1.00000040008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffdfffff), -0x1.00000040008p+62, -0x1p+0 },
+{ INT64_C(0x4000001000200004), 0x1.00000040008p+62, 0x1p+2 },
+{ INT64_C(0xbfffffefffdffffb), -0x1.00000040008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000001000200008), 0x1.00000040008p+62, 0x1p+3 },
+{ INT64_C(0xbfffffefffdffff7), -0x1.00000040008p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001000200020), 0x1.00000040008p+62, 0x1p+5 },
+{ INT64_C(0xbfffffefffdfffdf), -0x1.00000040008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000001000200040), 0x1.00000040008p+62, 0x1p+6 },
+{ INT64_C(0xbfffffefffdfffbf), -0x1.00000040008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000001000200080), 0x1.00000040008p+62, 0x1p+7 },
+{ INT64_C(0xbfffffefffdfff7f), -0x1.00000040008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000001000200400), 0x1.0000004000801p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffdffbff), -0x1.0000004000801p+62, -0x1p+0 },
+{ INT64_C(0x4000001000202000), 0x1.0000004000808p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffdfdfff), -0x1.0000004000808p+62, -0x1p+0 },
+{ INT64_C(0x4000001000208000), 0x1.000000400082p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffdf7fff), -0x1.000000400082p+62, -0x1p+0 },
+{ INT64_C(0x4000001000210000), 0x1.000000400084p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffdeffff), -0x1.000000400084p+62, -0x1p+0 },
+{ INT64_C(0x4000001000280000), 0x1.0000004000ap+62, 0x0p+0 },
+{ INT64_C(0xbfffffefffd7ffff), -0x1.0000004000ap+62, -0x1p+0 },
+{ INT64_C(0x4000001000800000), 0x1.0000004002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefff7fffff), -0x1.0000004002p+62, -0x1p+0 },
+{ INT64_C(0x4000001000800001), 0x1.0000004002p+62, 0x1p+0 },
+{ INT64_C(0xbfffffefff7ffffe), -0x1.0000004002p+62, -0x1p+1 },
+{ INT64_C(0x4000001000800002), 0x1.0000004002p+62, 0x1p+1 },
+{ INT64_C(0xbfffffefff7ffffd), -0x1.0000004002p+62, -0x1.8p+1 },
+{ INT64_C(0x4000001000800020), 0x1.0000004002p+62, 0x1p+5 },
+{ INT64_C(0xbfffffefff7fffdf), -0x1.0000004002p+62, -0x1.08p+5 },
+{ INT64_C(0x4000001000800040), 0x1.0000004002p+62, 0x1p+6 },
+{ INT64_C(0xbfffffefff7fffbf), -0x1.0000004002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000001000800200), 0x1.0000004002p+62, 0x1p+9 },
+{ INT64_C(0xbfffffefff7ffdff), -0x1.0000004002001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001000800400), 0x1.0000004002001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefff7ffbff), -0x1.0000004002001p+62, -0x1p+0 },
+{ INT64_C(0x4000001000802000), 0x1.0000004002008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefff7fdfff), -0x1.0000004002008p+62, -0x1p+0 },
+{ INT64_C(0x4000001000820000), 0x1.000000400208p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefff7dffff), -0x1.000000400208p+62, -0x1p+0 },
+{ INT64_C(0x4000001000a00000), 0x1.00000040028p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefff5fffff), -0x1.00000040028p+62, -0x1p+0 },
+{ INT64_C(0x4000001004000000), 0x1.000000401p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffbffffff), -0x1.000000401p+62, -0x1p+0 },
+{ INT64_C(0x4000001004000001), 0x1.000000401p+62, 0x1p+0 },
+{ INT64_C(0xbfffffeffbfffffe), -0x1.000000401p+62, -0x1p+1 },
+{ INT64_C(0x4000001004000008), 0x1.000000401p+62, 0x1p+3 },
+{ INT64_C(0xbfffffeffbfffff7), -0x1.000000401p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001004000080), 0x1.000000401p+62, 0x1p+7 },
+{ INT64_C(0xbfffffeffbffff7f), -0x1.000000401p+62, -0x1.02p+7 },
+{ INT64_C(0x4000001004000100), 0x1.000000401p+62, 0x1p+8 },
+{ INT64_C(0xbfffffeffbfffeff), -0x1.000000401p+62, -0x1.01p+8 },
+{ INT64_C(0x4000001004000800), 0x1.0000004010002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffbfff7ff), -0x1.0000004010002p+62, -0x1p+0 },
+{ INT64_C(0x4000001004008000), 0x1.000000401002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffbff7fff), -0x1.000000401002p+62, -0x1p+0 },
+{ INT64_C(0x4000001004040000), 0x1.00000040101p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffbfbffff), -0x1.00000040101p+62, -0x1p+0 },
+{ INT64_C(0x4000001004400000), 0x1.0000004011p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffbbfffff), -0x1.0000004011p+62, -0x1p+0 },
+{ INT64_C(0x4000001005000000), 0x1.0000004014p+62, 0x0p+0 },
+{ INT64_C(0xbfffffeffaffffff), -0x1.0000004014p+62, -0x1p+0 },
+{ INT64_C(0x4000001010000000), 0x1.000000404p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefefffffff), -0x1.000000404p+62, -0x1p+0 },
+{ INT64_C(0x4000001010000008), 0x1.000000404p+62, 0x1p+3 },
+{ INT64_C(0xbfffffefeffffff7), -0x1.000000404p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001010000080), 0x1.000000404p+62, 0x1p+7 },
+{ INT64_C(0xbfffffefefffff7f), -0x1.000000404p+62, -0x1.02p+7 },
+{ INT64_C(0x4000001010000100), 0x1.000000404p+62, 0x1p+8 },
+{ INT64_C(0xbfffffefeffffeff), -0x1.000000404p+62, -0x1.01p+8 },
+{ INT64_C(0x4000001010000400), 0x1.0000004040001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefeffffbff), -0x1.0000004040001p+62, -0x1p+0 },
+{ INT64_C(0x4000001010000800), 0x1.0000004040002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefeffff7ff), -0x1.0000004040002p+62, -0x1p+0 },
+{ INT64_C(0x4000001010004000), 0x1.000000404001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefefffbfff), -0x1.000000404001p+62, -0x1p+0 },
+{ INT64_C(0x4000001010008000), 0x1.000000404002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefefff7fff), -0x1.000000404002p+62, -0x1p+0 },
+{ INT64_C(0x4000001010080000), 0x1.00000040402p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefeff7ffff), -0x1.00000040402p+62, -0x1p+0 },
+{ INT64_C(0x4000001010100000), 0x1.00000040404p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefefefffff), -0x1.00000040404p+62, -0x1p+0 },
+{ INT64_C(0x4000001011000000), 0x1.0000004044p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefeeffffff), -0x1.0000004044p+62, -0x1p+0 },
+{ INT64_C(0x4000001040000000), 0x1.00000041p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbfffffff), -0x1.00000041p+62, -0x1p+0 },
+{ INT64_C(0x4000001040000002), 0x1.00000041p+62, 0x1p+1 },
+{ INT64_C(0xbfffffefbffffffd), -0x1.00000041p+62, -0x1.8p+1 },
+{ INT64_C(0x4000001040000010), 0x1.00000041p+62, 0x1p+4 },
+{ INT64_C(0xbfffffefbfffffef), -0x1.00000041p+62, -0x1.1p+4 },
+{ INT64_C(0x4000001040000100), 0x1.00000041p+62, 0x1p+8 },
+{ INT64_C(0xbfffffefbffffeff), -0x1.00000041p+62, -0x1.01p+8 },
+{ INT64_C(0x4000001040000800), 0x1.0000004100002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbffff7ff), -0x1.0000004100002p+62, -0x1p+0 },
+{ INT64_C(0x4000001040002000), 0x1.0000004100008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbfffdfff), -0x1.0000004100008p+62, -0x1p+0 },
+{ INT64_C(0x4000001040004000), 0x1.000000410001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbfffbfff), -0x1.000000410001p+62, -0x1p+0 },
+{ INT64_C(0x4000001040010000), 0x1.000000410004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbffeffff), -0x1.000000410004p+62, -0x1p+0 },
+{ INT64_C(0x4000001040040000), 0x1.00000041001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbffbffff), -0x1.00000041001p+62, -0x1p+0 },
+{ INT64_C(0x4000001040080000), 0x1.00000041002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbff7ffff), -0x1.00000041002p+62, -0x1p+0 },
+{ INT64_C(0x4000001040400000), 0x1.0000004101p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbfbfffff), -0x1.0000004101p+62, -0x1p+0 },
+{ INT64_C(0x4000001042000000), 0x1.0000004108p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefbdffffff), -0x1.0000004108p+62, -0x1p+0 },
+{ INT64_C(0x4000001050000000), 0x1.000000414p+62, 0x0p+0 },
+{ INT64_C(0xbfffffefafffffff), -0x1.000000414p+62, -0x1p+0 },
+{ INT64_C(0x4000001080000000), 0x1.00000042p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7fffffff), -0x1.00000042p+62, -0x1p+0 },
+{ INT64_C(0x4000001080000004), 0x1.00000042p+62, 0x1p+2 },
+{ INT64_C(0xbfffffef7ffffffb), -0x1.00000042p+62, -0x1.4p+2 },
+{ INT64_C(0x4000001080000040), 0x1.00000042p+62, 0x1p+6 },
+{ INT64_C(0xbfffffef7fffffbf), -0x1.00000042p+62, -0x1.04p+6 },
+{ INT64_C(0x4000001080000100), 0x1.00000042p+62, 0x1p+8 },
+{ INT64_C(0xbfffffef7ffffeff), -0x1.00000042p+62, -0x1.01p+8 },
+{ INT64_C(0x4000001080000800), 0x1.0000004200002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7ffff7ff), -0x1.0000004200002p+62, -0x1p+0 },
+{ INT64_C(0x4000001080002000), 0x1.0000004200008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7fffdfff), -0x1.0000004200008p+62, -0x1p+0 },
+{ INT64_C(0x4000001080008000), 0x1.000000420002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7fff7fff), -0x1.000000420002p+62, -0x1p+0 },
+{ INT64_C(0x4000001080080000), 0x1.00000042002p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7ff7ffff), -0x1.00000042002p+62, -0x1p+0 },
+{ INT64_C(0x4000001080400000), 0x1.0000004201p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7fbfffff), -0x1.0000004201p+62, -0x1p+0 },
+{ INT64_C(0x4000001080800000), 0x1.0000004202p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7f7fffff), -0x1.0000004202p+62, -0x1p+0 },
+{ INT64_C(0x4000001081000000), 0x1.0000004204p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7effffff), -0x1.0000004204p+62, -0x1p+0 },
+{ INT64_C(0x4000001082000000), 0x1.0000004208p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7dffffff), -0x1.0000004208p+62, -0x1p+0 },
+{ INT64_C(0x4000001084000000), 0x1.000000421p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef7bffffff), -0x1.000000421p+62, -0x1p+0 },
+{ INT64_C(0x4000001088000000), 0x1.000000422p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef77ffffff), -0x1.000000422p+62, -0x1p+0 },
+{ INT64_C(0x4000001090000000), 0x1.000000424p+62, 0x0p+0 },
+{ INT64_C(0xbfffffef6fffffff), -0x1.000000424p+62, -0x1p+0 },
+{ INT64_C(0x4000001800000000), 0x1.0000006p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7ffffffff), -0x1.0000006p+62, -0x1p+0 },
+{ INT64_C(0x4000001800000008), 0x1.0000006p+62, 0x1p+3 },
+{ INT64_C(0xbfffffe7fffffff7), -0x1.0000006p+62, -0x1.2p+3 },
+{ INT64_C(0x4000001800000040), 0x1.0000006p+62, 0x1p+6 },
+{ INT64_C(0xbfffffe7ffffffbf), -0x1.0000006p+62, -0x1.04p+6 },
+{ INT64_C(0x4000001800000200), 0x1.0000006p+62, 0x1p+9 },
+{ INT64_C(0xbfffffe7fffffdff), -0x1.0000006000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000001800000400), 0x1.0000006000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7fffffbff), -0x1.0000006000001p+62, -0x1p+0 },
+{ INT64_C(0x4000001800002000), 0x1.0000006000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7ffffdfff), -0x1.0000006000008p+62, -0x1p+0 },
+{ INT64_C(0x4000001800010000), 0x1.000000600004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7fffeffff), -0x1.000000600004p+62, -0x1p+0 },
+{ INT64_C(0x4000001800100000), 0x1.00000060004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7ffefffff), -0x1.00000060004p+62, -0x1p+0 },
+{ INT64_C(0x4000001801000000), 0x1.0000006004p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7feffffff), -0x1.0000006004p+62, -0x1p+0 },
+{ INT64_C(0x4000001802000000), 0x1.0000006008p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7fdffffff), -0x1.0000006008p+62, -0x1p+0 },
+{ INT64_C(0x4000001808000000), 0x1.000000602p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7f7ffffff), -0x1.000000602p+62, -0x1p+0 },
+{ INT64_C(0x4000001820000000), 0x1.000000608p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe7dfffffff), -0x1.000000608p+62, -0x1p+0 },
+{ INT64_C(0x4000001a00000000), 0x1.00000068p+62, 0x0p+0 },
+{ INT64_C(0xbfffffe5ffffffff), -0x1.00000068p+62, -0x1p+0 },
+{ INT64_C(0x4000008000000008), 0x1.000002p+62, 0x1p+3 },
+{ INT64_C(0xbfffff7ffffffff7), -0x1.000002p+62, -0x1.2p+3 },
+{ INT64_C(0x400000800000000c), 0x1.000002p+62, 0x1.8p+3 },
+{ INT64_C(0xbfffff7ffffffff3), -0x1.000002p+62, -0x1.ap+3 },
+{ INT64_C(0x4000008000000010), 0x1.000002p+62, 0x1p+4 },
+{ INT64_C(0xbfffff7fffffffef), -0x1.000002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000008000000012), 0x1.000002p+62, 0x1.2p+4 },
+{ INT64_C(0xbfffff7fffffffed), -0x1.000002p+62, -0x1.3p+4 },
+{ INT64_C(0x4000008000000080), 0x1.000002p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7fffffff7f), -0x1.000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008000000088), 0x1.000002p+62, 0x1.1p+7 },
+{ INT64_C(0xbfffff7fffffff77), -0x1.000002p+62, -0x1.12p+7 },
+{ INT64_C(0x4000008000000100), 0x1.000002p+62, 0x1p+8 },
+{ INT64_C(0xbfffff7ffffffeff), -0x1.000002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008000000102), 0x1.000002p+62, 0x1.02p+8 },
+{ INT64_C(0xbfffff7ffffffefd), -0x1.000002p+62, -0x1.03p+8 },
+{ INT64_C(0x4000008000000104), 0x1.000002p+62, 0x1.04p+8 },
+{ INT64_C(0xbfffff7ffffffefb), -0x1.000002p+62, -0x1.05p+8 },
+{ INT64_C(0x4000008000000140), 0x1.000002p+62, 0x1.4p+8 },
+{ INT64_C(0xbfffff7ffffffebf), -0x1.000002p+62, -0x1.41p+8 },
+{ INT64_C(0x4000008000000180), 0x1.000002p+62, 0x1.8p+8 },
+{ INT64_C(0xbfffff7ffffffe7f), -0x1.000002p+62, -0x1.81p+8 },
+{ INT64_C(0x4000008000000400), 0x1.0000020000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffffffbff), -0x1.0000020000001p+62, -0x1p+0 },
+{ INT64_C(0x4000008000000402), 0x1.0000020000001p+62, 0x1p+1 },
+{ INT64_C(0xbfffff7ffffffbfd), -0x1.0000020000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4000008000000404), 0x1.0000020000001p+62, 0x1p+2 },
+{ INT64_C(0xbfffff7ffffffbfb), -0x1.0000020000001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000008000000408), 0x1.0000020000001p+62, 0x1p+3 },
+{ INT64_C(0xbfffff7ffffffbf7), -0x1.0000020000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000008000000410), 0x1.0000020000001p+62, 0x1p+4 },
+{ INT64_C(0xbfffff7ffffffbef), -0x1.0000020000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000008000000480), 0x1.0000020000001p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7ffffffb7f), -0x1.0000020000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008000000500), 0x1.0000020000001p+62, 0x1p+8 },
+{ INT64_C(0xbfffff7ffffffaff), -0x1.0000020000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008000000600), 0x1.0000020000002p+62, -0x1p+9 },
+{ INT64_C(0xbfffff7ffffff9ff), -0x1.0000020000002p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000008000001000), 0x1.0000020000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffffefff), -0x1.0000020000004p+62, -0x1p+0 },
+{ INT64_C(0x4000008000001001), 0x1.0000020000004p+62, 0x1p+0 },
+{ INT64_C(0xbfffff7fffffeffe), -0x1.0000020000004p+62, -0x1p+1 },
+{ INT64_C(0x4000008000001010), 0x1.0000020000004p+62, 0x1p+4 },
+{ INT64_C(0xbfffff7fffffefef), -0x1.0000020000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4000008000001040), 0x1.0000020000004p+62, 0x1p+6 },
+{ INT64_C(0xbfffff7fffffefbf), -0x1.0000020000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000008000001080), 0x1.0000020000004p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7fffffef7f), -0x1.0000020000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008000001200), 0x1.0000020000004p+62, 0x1p+9 },
+{ INT64_C(0xbfffff7fffffedff), -0x1.0000020000005p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000008000004000), 0x1.000002000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffffbfff), -0x1.000002000001p+62, -0x1p+0 },
+{ INT64_C(0x4000008000004001), 0x1.000002000001p+62, 0x1p+0 },
+{ INT64_C(0xbfffff7fffffbffe), -0x1.000002000001p+62, -0x1p+1 },
+{ INT64_C(0x4000008000004010), 0x1.000002000001p+62, 0x1p+4 },
+{ INT64_C(0xbfffff7fffffbfef), -0x1.000002000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000008000004100), 0x1.000002000001p+62, 0x1p+8 },
+{ INT64_C(0xbfffff7fffffbeff), -0x1.000002000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008000004400), 0x1.0000020000011p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffffbbff), -0x1.0000020000011p+62, -0x1p+0 },
+{ INT64_C(0x4000008000004800), 0x1.0000020000012p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffffb7ff), -0x1.0000020000012p+62, -0x1p+0 },
+{ INT64_C(0x4000008000008000), 0x1.000002000002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffff7fff), -0x1.000002000002p+62, -0x1p+0 },
+{ INT64_C(0x4000008000008008), 0x1.000002000002p+62, 0x1p+3 },
+{ INT64_C(0xbfffff7fffff7ff7), -0x1.000002000002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000008000008080), 0x1.000002000002p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7fffff7f7f), -0x1.000002000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008000008400), 0x1.0000020000021p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffff7bff), -0x1.0000020000021p+62, -0x1p+0 },
+{ INT64_C(0x4000008000009000), 0x1.0000020000024p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffff6fff), -0x1.0000020000024p+62, -0x1p+0 },
+{ INT64_C(0x4000008000010000), 0x1.000002000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffffeffff), -0x1.000002000004p+62, -0x1p+0 },
+{ INT64_C(0x4000008000010002), 0x1.000002000004p+62, 0x1p+1 },
+{ INT64_C(0xbfffff7ffffefffd), -0x1.000002000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4000008000010020), 0x1.000002000004p+62, 0x1p+5 },
+{ INT64_C(0xbfffff7ffffeffdf), -0x1.000002000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000008000010100), 0x1.000002000004p+62, 0x1p+8 },
+{ INT64_C(0xbfffff7ffffefeff), -0x1.000002000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008000011000), 0x1.0000020000044p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffffeefff), -0x1.0000020000044p+62, -0x1p+0 },
+{ INT64_C(0x4000008000100000), 0x1.00000200004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffefffff), -0x1.00000200004p+62, -0x1p+0 },
+{ INT64_C(0x4000008000100002), 0x1.00000200004p+62, 0x1p+1 },
+{ INT64_C(0xbfffff7fffeffffd), -0x1.00000200004p+62, -0x1.8p+1 },
+{ INT64_C(0x4000008000100008), 0x1.00000200004p+62, 0x1p+3 },
+{ INT64_C(0xbfffff7fffeffff7), -0x1.00000200004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000008000100080), 0x1.00000200004p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7fffefff7f), -0x1.00000200004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008000100200), 0x1.00000200004p+62, 0x1p+9 },
+{ INT64_C(0xbfffff7fffeffdff), -0x1.0000020000401p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000008000100400), 0x1.0000020000401p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffeffbff), -0x1.0000020000401p+62, -0x1p+0 },
+{ INT64_C(0x4000008000101000), 0x1.0000020000404p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffefefff), -0x1.0000020000404p+62, -0x1p+0 },
+{ INT64_C(0x4000008000102000), 0x1.0000020000408p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffefdfff), -0x1.0000020000408p+62, -0x1p+0 },
+{ INT64_C(0x4000008000108000), 0x1.000002000042p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffef7fff), -0x1.000002000042p+62, -0x1p+0 },
+{ INT64_C(0x4000008000140000), 0x1.00000200005p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffebffff), -0x1.00000200005p+62, -0x1p+0 },
+{ INT64_C(0x4000008000200000), 0x1.00000200008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffdfffff), -0x1.00000200008p+62, -0x1p+0 },
+{ INT64_C(0x4000008000200002), 0x1.00000200008p+62, 0x1p+1 },
+{ INT64_C(0xbfffff7fffdffffd), -0x1.00000200008p+62, -0x1.8p+1 },
+{ INT64_C(0x4000008000200010), 0x1.00000200008p+62, 0x1p+4 },
+{ INT64_C(0xbfffff7fffdfffef), -0x1.00000200008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000008000200040), 0x1.00000200008p+62, 0x1p+6 },
+{ INT64_C(0xbfffff7fffdfffbf), -0x1.00000200008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000008000200080), 0x1.00000200008p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7fffdfff7f), -0x1.00000200008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008000200100), 0x1.00000200008p+62, 0x1p+8 },
+{ INT64_C(0xbfffff7fffdffeff), -0x1.00000200008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008000200800), 0x1.0000020000802p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffdff7ff), -0x1.0000020000802p+62, -0x1p+0 },
+{ INT64_C(0x4000008000208000), 0x1.000002000082p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffdf7fff), -0x1.000002000082p+62, -0x1p+0 },
+{ INT64_C(0x4000008000280000), 0x1.0000020000ap+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffd7ffff), -0x1.0000020000ap+62, -0x1p+0 },
+{ INT64_C(0x4000008000300000), 0x1.0000020000cp+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fffcfffff), -0x1.0000020000cp+62, -0x1p+0 },
+{ INT64_C(0x4000008002000000), 0x1.0000020008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffdffffff), -0x1.0000020008p+62, -0x1p+0 },
+{ INT64_C(0x4000008002000002), 0x1.0000020008p+62, 0x1p+1 },
+{ INT64_C(0xbfffff7ffdfffffd), -0x1.0000020008p+62, -0x1.8p+1 },
+{ INT64_C(0x4000008002000004), 0x1.0000020008p+62, 0x1p+2 },
+{ INT64_C(0xbfffff7ffdfffffb), -0x1.0000020008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000008002000020), 0x1.0000020008p+62, 0x1p+5 },
+{ INT64_C(0xbfffff7ffdffffdf), -0x1.0000020008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000008002000080), 0x1.0000020008p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7ffdffff7f), -0x1.0000020008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008002000400), 0x1.0000020008001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffdfffbff), -0x1.0000020008001p+62, -0x1p+0 },
+{ INT64_C(0x4000008002002000), 0x1.0000020008008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffdffdfff), -0x1.0000020008008p+62, -0x1p+0 },
+{ INT64_C(0x4000008002004000), 0x1.000002000801p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffdffbfff), -0x1.000002000801p+62, -0x1p+0 },
+{ INT64_C(0x4000008002020000), 0x1.000002000808p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffdfdffff), -0x1.000002000808p+62, -0x1p+0 },
+{ INT64_C(0x4000008002200000), 0x1.00000200088p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffddfffff), -0x1.00000200088p+62, -0x1p+0 },
+{ INT64_C(0x4000008004000000), 0x1.000002001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbffffff), -0x1.000002001p+62, -0x1p+0 },
+{ INT64_C(0x4000008004000008), 0x1.000002001p+62, 0x1p+3 },
+{ INT64_C(0xbfffff7ffbfffff7), -0x1.000002001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000008004000020), 0x1.000002001p+62, 0x1p+5 },
+{ INT64_C(0xbfffff7ffbffffdf), -0x1.000002001p+62, -0x1.08p+5 },
+{ INT64_C(0x4000008004000080), 0x1.000002001p+62, 0x1p+7 },
+{ INT64_C(0xbfffff7ffbffff7f), -0x1.000002001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000008004000800), 0x1.0000020010002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbfff7ff), -0x1.0000020010002p+62, -0x1p+0 },
+{ INT64_C(0x4000008004002000), 0x1.0000020010008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbffdfff), -0x1.0000020010008p+62, -0x1p+0 },
+{ INT64_C(0x4000008004008000), 0x1.000002001002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbff7fff), -0x1.000002001002p+62, -0x1p+0 },
+{ INT64_C(0x4000008004010000), 0x1.000002001004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbfeffff), -0x1.000002001004p+62, -0x1p+0 },
+{ INT64_C(0x4000008004040000), 0x1.00000200101p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbfbffff), -0x1.00000200101p+62, -0x1p+0 },
+{ INT64_C(0x4000008004080000), 0x1.00000200102p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbf7ffff), -0x1.00000200102p+62, -0x1p+0 },
+{ INT64_C(0x4000008004100000), 0x1.00000200104p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbefffff), -0x1.00000200104p+62, -0x1p+0 },
+{ INT64_C(0x4000008004400000), 0x1.0000020011p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7ffbbfffff), -0x1.0000020011p+62, -0x1p+0 },
+{ INT64_C(0x4000008010000000), 0x1.000002004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fefffffff), -0x1.000002004p+62, -0x1p+0 },
+{ INT64_C(0x4000008010000008), 0x1.000002004p+62, 0x1p+3 },
+{ INT64_C(0xbfffff7feffffff7), -0x1.000002004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000008010000020), 0x1.000002004p+62, 0x1p+5 },
+{ INT64_C(0xbfffff7fefffffdf), -0x1.000002004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000008010000040), 0x1.000002004p+62, 0x1p+6 },
+{ INT64_C(0xbfffff7fefffffbf), -0x1.000002004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000008010000100), 0x1.000002004p+62, 0x1p+8 },
+{ INT64_C(0xbfffff7feffffeff), -0x1.000002004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008010000200), 0x1.000002004p+62, 0x1p+9 },
+{ INT64_C(0xbfffff7feffffdff), -0x1.0000020040001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000008010001000), 0x1.0000020040004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fefffefff), -0x1.0000020040004p+62, -0x1p+0 },
+{ INT64_C(0x4000008010004000), 0x1.000002004001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fefffbfff), -0x1.000002004001p+62, -0x1p+0 },
+{ INT64_C(0x4000008010040000), 0x1.00000200401p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7feffbffff), -0x1.00000200401p+62, -0x1p+0 },
+{ INT64_C(0x4000008010400000), 0x1.0000020041p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fefbfffff), -0x1.0000020041p+62, -0x1p+0 },
+{ INT64_C(0x4000008012000000), 0x1.0000020048p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7fedffffff), -0x1.0000020048p+62, -0x1p+0 },
+{ INT64_C(0x4000008080000000), 0x1.00000202p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7fffffff), -0x1.00000202p+62, -0x1p+0 },
+{ INT64_C(0x4000008080000004), 0x1.00000202p+62, 0x1p+2 },
+{ INT64_C(0xbfffff7f7ffffffb), -0x1.00000202p+62, -0x1.4p+2 },
+{ INT64_C(0x4000008080000020), 0x1.00000202p+62, 0x1p+5 },
+{ INT64_C(0xbfffff7f7fffffdf), -0x1.00000202p+62, -0x1.08p+5 },
+{ INT64_C(0x4000008080000200), 0x1.00000202p+62, 0x1p+9 },
+{ INT64_C(0xbfffff7f7ffffdff), -0x1.0000020200001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000008080000400), 0x1.0000020200001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7ffffbff), -0x1.0000020200001p+62, -0x1p+0 },
+{ INT64_C(0x4000008080004000), 0x1.000002020001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7fffbfff), -0x1.000002020001p+62, -0x1p+0 },
+{ INT64_C(0x4000008080008000), 0x1.000002020002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7fff7fff), -0x1.000002020002p+62, -0x1p+0 },
+{ INT64_C(0x4000008080010000), 0x1.000002020004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7ffeffff), -0x1.000002020004p+62, -0x1p+0 },
+{ INT64_C(0x4000008080080000), 0x1.00000202002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7ff7ffff), -0x1.00000202002p+62, -0x1p+0 },
+{ INT64_C(0x4000008080400000), 0x1.0000020201p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7fbfffff), -0x1.0000020201p+62, -0x1p+0 },
+{ INT64_C(0x4000008081000000), 0x1.0000020204p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f7effffff), -0x1.0000020204p+62, -0x1p+0 },
+{ INT64_C(0x4000008088000000), 0x1.000002022p+62, 0x0p+0 },
+{ INT64_C(0xbfffff7f77ffffff), -0x1.000002022p+62, -0x1p+0 },
+{ INT64_C(0x4000008800000000), 0x1.0000022p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77ffffffff), -0x1.0000022p+62, -0x1p+0 },
+{ INT64_C(0x4000008800000008), 0x1.0000022p+62, 0x1p+3 },
+{ INT64_C(0xbfffff77fffffff7), -0x1.0000022p+62, -0x1.2p+3 },
+{ INT64_C(0x4000008800000010), 0x1.0000022p+62, 0x1p+4 },
+{ INT64_C(0xbfffff77ffffffef), -0x1.0000022p+62, -0x1.1p+4 },
+{ INT64_C(0x4000008800000020), 0x1.0000022p+62, 0x1p+5 },
+{ INT64_C(0xbfffff77ffffffdf), -0x1.0000022p+62, -0x1.08p+5 },
+{ INT64_C(0x4000008800000100), 0x1.0000022p+62, 0x1p+8 },
+{ INT64_C(0xbfffff77fffffeff), -0x1.0000022p+62, -0x1.01p+8 },
+{ INT64_C(0x4000008800000800), 0x1.0000022000002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77fffff7ff), -0x1.0000022000002p+62, -0x1p+0 },
+{ INT64_C(0x4000008800004000), 0x1.000002200001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77ffffbfff), -0x1.000002200001p+62, -0x1p+0 },
+{ INT64_C(0x4000008800010000), 0x1.000002200004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77fffeffff), -0x1.000002200004p+62, -0x1p+0 },
+{ INT64_C(0x4000008800100000), 0x1.00000220004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77ffefffff), -0x1.00000220004p+62, -0x1p+0 },
+{ INT64_C(0x4000008801000000), 0x1.0000022004p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77feffffff), -0x1.0000022004p+62, -0x1p+0 },
+{ INT64_C(0x4000008808000000), 0x1.000002202p+62, 0x0p+0 },
+{ INT64_C(0xbfffff77f7ffffff), -0x1.000002202p+62, -0x1p+0 },
+{ INT64_C(0x4000008880000000), 0x1.00000222p+62, 0x0p+0 },
+{ INT64_C(0xbfffff777fffffff), -0x1.00000222p+62, -0x1p+0 },
+{ INT64_C(0x4000008a00000000), 0x1.00000228p+62, 0x0p+0 },
+{ INT64_C(0xbfffff75ffffffff), -0x1.00000228p+62, -0x1p+0 },
+{ INT64_C(0x400000a000000000), 0x1.0000028p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5fffffffff), -0x1.0000028p+62, -0x1p+0 },
+{ INT64_C(0x400000a000000002), 0x1.0000028p+62, 0x1p+1 },
+{ INT64_C(0xbfffff5ffffffffd), -0x1.0000028p+62, -0x1.8p+1 },
+{ INT64_C(0x400000a000000010), 0x1.0000028p+62, 0x1p+4 },
+{ INT64_C(0xbfffff5fffffffef), -0x1.0000028p+62, -0x1.1p+4 },
+{ INT64_C(0x400000a000000020), 0x1.0000028p+62, 0x1p+5 },
+{ INT64_C(0xbfffff5fffffffdf), -0x1.0000028p+62, -0x1.08p+5 },
+{ INT64_C(0x400000a000000080), 0x1.0000028p+62, 0x1p+7 },
+{ INT64_C(0xbfffff5fffffff7f), -0x1.0000028p+62, -0x1.02p+7 },
+{ INT64_C(0x400000a000000400), 0x1.0000028000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5ffffffbff), -0x1.0000028000001p+62, -0x1p+0 },
+{ INT64_C(0x400000a000002000), 0x1.0000028000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5fffffdfff), -0x1.0000028000008p+62, -0x1p+0 },
+{ INT64_C(0x400000a000020000), 0x1.000002800008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5ffffdffff), -0x1.000002800008p+62, -0x1p+0 },
+{ INT64_C(0x400000a000080000), 0x1.00000280002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5ffff7ffff), -0x1.00000280002p+62, -0x1p+0 },
+{ INT64_C(0x400000a000800000), 0x1.0000028002p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5fff7fffff), -0x1.0000028002p+62, -0x1p+0 },
+{ INT64_C(0x400000a002000000), 0x1.0000028008p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5ffdffffff), -0x1.0000028008p+62, -0x1p+0 },
+{ INT64_C(0x400000a020000000), 0x1.000002808p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5fdfffffff), -0x1.000002808p+62, -0x1p+0 },
+{ INT64_C(0x400000a200000000), 0x1.00000288p+62, 0x0p+0 },
+{ INT64_C(0xbfffff5dffffffff), -0x1.00000288p+62, -0x1p+0 },
+{ INT64_C(0x400000a800000000), 0x1.000002ap+62, 0x0p+0 },
+{ INT64_C(0xbfffff57ffffffff), -0x1.000002ap+62, -0x1p+0 },
+{ INT64_C(0x400000b000000000), 0x1.000002cp+62, 0x0p+0 },
+{ INT64_C(0xbfffff4fffffffff), -0x1.000002cp+62, -0x1p+0 },
+{ INT64_C(0x4000080000000004), 0x1.00002p+62, 0x1p+2 },
+{ INT64_C(0xbffff7fffffffffb), -0x1.00002p+62, -0x1.4p+2 },
+{ INT64_C(0x4000080000000010), 0x1.00002p+62, 0x1p+4 },
+{ INT64_C(0xbffff7ffffffffef), -0x1.00002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000080000000014), 0x1.00002p+62, 0x1.4p+4 },
+{ INT64_C(0xbffff7ffffffffeb), -0x1.00002p+62, -0x1.5p+4 },
+{ INT64_C(0x4000080000000018), 0x1.00002p+62, 0x1.8p+4 },
+{ INT64_C(0xbffff7ffffffffe7), -0x1.00002p+62, -0x1.9p+4 },
+{ INT64_C(0x4000080000000040), 0x1.00002p+62, 0x1p+6 },
+{ INT64_C(0xbffff7ffffffffbf), -0x1.00002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000080000000041), 0x1.00002p+62, 0x1.04p+6 },
+{ INT64_C(0xbffff7ffffffffbe), -0x1.00002p+62, -0x1.08p+6 },
+{ INT64_C(0x4000080000000044), 0x1.00002p+62, 0x1.1p+6 },
+{ INT64_C(0xbffff7ffffffffbb), -0x1.00002p+62, -0x1.14p+6 },
+{ INT64_C(0x4000080000000100), 0x1.00002p+62, 0x1p+8 },
+{ INT64_C(0xbffff7fffffffeff), -0x1.00002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000080000000108), 0x1.00002p+62, 0x1.08p+8 },
+{ INT64_C(0xbffff7fffffffef7), -0x1.00002p+62, -0x1.09p+8 },
+{ INT64_C(0x4000080000000140), 0x1.00002p+62, 0x1.4p+8 },
+{ INT64_C(0xbffff7fffffffebf), -0x1.00002p+62, -0x1.41p+8 },
+{ INT64_C(0x4000080000000400), 0x1.0000200000001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffffbff), -0x1.0000200000001p+62, -0x1p+0 },
+{ INT64_C(0x4000080000000401), 0x1.0000200000001p+62, 0x1p+0 },
+{ INT64_C(0xbffff7fffffffbfe), -0x1.0000200000001p+62, -0x1p+1 },
+{ INT64_C(0x4000080000000410), 0x1.0000200000001p+62, 0x1p+4 },
+{ INT64_C(0xbffff7fffffffbef), -0x1.0000200000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4000080000000480), 0x1.0000200000001p+62, 0x1p+7 },
+{ INT64_C(0xbffff7fffffffb7f), -0x1.0000200000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000080000000500), 0x1.0000200000001p+62, 0x1p+8 },
+{ INT64_C(0xbffff7fffffffaff), -0x1.0000200000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000080000000600), 0x1.0000200000002p+62, -0x1p+9 },
+{ INT64_C(0xbffff7fffffff9ff), -0x1.0000200000002p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000080000002000), 0x1.0000200000008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffffdfff), -0x1.0000200000008p+62, -0x1p+0 },
+{ INT64_C(0x4000080000002004), 0x1.0000200000008p+62, 0x1p+2 },
+{ INT64_C(0xbffff7ffffffdffb), -0x1.0000200000008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000080000002010), 0x1.0000200000008p+62, 0x1p+4 },
+{ INT64_C(0xbffff7ffffffdfef), -0x1.0000200000008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000080000002080), 0x1.0000200000008p+62, 0x1p+7 },
+{ INT64_C(0xbffff7ffffffdf7f), -0x1.0000200000008p+62, -0x1.02p+7 },
+{ INT64_C(0x4000080000002200), 0x1.0000200000008p+62, 0x1p+9 },
+{ INT64_C(0xbffff7ffffffddff), -0x1.0000200000009p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000080000010000), 0x1.000020000004p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffeffff), -0x1.000020000004p+62, -0x1p+0 },
+{ INT64_C(0x4000080000010004), 0x1.000020000004p+62, 0x1p+2 },
+{ INT64_C(0xbffff7fffffefffb), -0x1.000020000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4000080000010020), 0x1.000020000004p+62, 0x1p+5 },
+{ INT64_C(0xbffff7fffffeffdf), -0x1.000020000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000080000010100), 0x1.000020000004p+62, 0x1p+8 },
+{ INT64_C(0xbffff7fffffefeff), -0x1.000020000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000080000010200), 0x1.000020000004p+62, 0x1p+9 },
+{ INT64_C(0xbffff7fffffefdff), -0x1.0000200000041p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000080000010800), 0x1.0000200000042p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffef7ff), -0x1.0000200000042p+62, -0x1p+0 },
+{ INT64_C(0x4000080000011000), 0x1.0000200000044p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffeefff), -0x1.0000200000044p+62, -0x1p+0 },
+{ INT64_C(0x4000080000018000), 0x1.000020000006p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffe7fff), -0x1.000020000006p+62, -0x1p+0 },
+{ INT64_C(0x4000080000040000), 0x1.00002000001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffbffff), -0x1.00002000001p+62, -0x1p+0 },
+{ INT64_C(0x4000080000040001), 0x1.00002000001p+62, 0x1p+0 },
+{ INT64_C(0xbffff7fffffbfffe), -0x1.00002000001p+62, -0x1p+1 },
+{ INT64_C(0x4000080000040002), 0x1.00002000001p+62, 0x1p+1 },
+{ INT64_C(0xbffff7fffffbfffd), -0x1.00002000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4000080000040008), 0x1.00002000001p+62, 0x1p+3 },
+{ INT64_C(0xbffff7fffffbfff7), -0x1.00002000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000080000040080), 0x1.00002000001p+62, 0x1p+7 },
+{ INT64_C(0xbffff7fffffbff7f), -0x1.00002000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000080000040100), 0x1.00002000001p+62, 0x1p+8 },
+{ INT64_C(0xbffff7fffffbfeff), -0x1.00002000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000080000040400), 0x1.0000200000101p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffbfbff), -0x1.0000200000101p+62, -0x1p+0 },
+{ INT64_C(0x4000080000042000), 0x1.0000200000108p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffffbdfff), -0x1.0000200000108p+62, -0x1p+0 },
+{ INT64_C(0x4000080000060000), 0x1.000020000018p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffff9ffff), -0x1.000020000018p+62, -0x1p+0 },
+{ INT64_C(0x4000080000100000), 0x1.00002000004p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffefffff), -0x1.00002000004p+62, -0x1p+0 },
+{ INT64_C(0x4000080000100001), 0x1.00002000004p+62, 0x1p+0 },
+{ INT64_C(0xbffff7ffffeffffe), -0x1.00002000004p+62, -0x1p+1 },
+{ INT64_C(0x4000080000100010), 0x1.00002000004p+62, 0x1p+4 },
+{ INT64_C(0xbffff7ffffefffef), -0x1.00002000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4000080000100020), 0x1.00002000004p+62, 0x1p+5 },
+{ INT64_C(0xbffff7ffffefffdf), -0x1.00002000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000080000100080), 0x1.00002000004p+62, 0x1p+7 },
+{ INT64_C(0xbffff7ffffefff7f), -0x1.00002000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000080000100800), 0x1.0000200000402p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffeff7ff), -0x1.0000200000402p+62, -0x1p+0 },
+{ INT64_C(0x4000080000101000), 0x1.0000200000404p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffefefff), -0x1.0000200000404p+62, -0x1p+0 },
+{ INT64_C(0x4000080000110000), 0x1.000020000044p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffeeffff), -0x1.000020000044p+62, -0x1p+0 },
+{ INT64_C(0x4000080000180000), 0x1.00002000006p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffe7ffff), -0x1.00002000006p+62, -0x1p+0 },
+{ INT64_C(0x4000080000400000), 0x1.0000200001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffbfffff), -0x1.0000200001p+62, -0x1p+0 },
+{ INT64_C(0x4000080000400004), 0x1.0000200001p+62, 0x1p+2 },
+{ INT64_C(0xbffff7ffffbffffb), -0x1.0000200001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000080000400040), 0x1.0000200001p+62, 0x1p+6 },
+{ INT64_C(0xbffff7ffffbfffbf), -0x1.0000200001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000080000400200), 0x1.0000200001p+62, 0x1p+9 },
+{ INT64_C(0xbffff7ffffbffdff), -0x1.0000200001001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000080000400800), 0x1.0000200001002p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffbff7ff), -0x1.0000200001002p+62, -0x1p+0 },
+{ INT64_C(0x4000080000404000), 0x1.000020000101p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffbfbfff), -0x1.000020000101p+62, -0x1p+0 },
+{ INT64_C(0x4000080000410000), 0x1.000020000104p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffbeffff), -0x1.000020000104p+62, -0x1p+0 },
+{ INT64_C(0x4000080000440000), 0x1.00002000011p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffffbbffff), -0x1.00002000011p+62, -0x1p+0 },
+{ INT64_C(0x4000080000600000), 0x1.00002000018p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ffff9fffff), -0x1.00002000018p+62, -0x1p+0 },
+{ INT64_C(0x4000080002000000), 0x1.0000200008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdffffff), -0x1.0000200008p+62, -0x1p+0 },
+{ INT64_C(0x4000080002000008), 0x1.0000200008p+62, 0x1p+3 },
+{ INT64_C(0xbffff7fffdfffff7), -0x1.0000200008p+62, -0x1.2p+3 },
+{ INT64_C(0x4000080002000040), 0x1.0000200008p+62, 0x1p+6 },
+{ INT64_C(0xbffff7fffdffffbf), -0x1.0000200008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000080002000400), 0x1.0000200008001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdfffbff), -0x1.0000200008001p+62, -0x1p+0 },
+{ INT64_C(0x4000080002000800), 0x1.0000200008002p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdfff7ff), -0x1.0000200008002p+62, -0x1p+0 },
+{ INT64_C(0x4000080002002000), 0x1.0000200008008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdffdfff), -0x1.0000200008008p+62, -0x1p+0 },
+{ INT64_C(0x4000080002010000), 0x1.000020000804p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdfeffff), -0x1.000020000804p+62, -0x1p+0 },
+{ INT64_C(0x4000080002080000), 0x1.00002000082p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdf7ffff), -0x1.00002000082p+62, -0x1p+0 },
+{ INT64_C(0x4000080002100000), 0x1.00002000084p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdefffff), -0x1.00002000084p+62, -0x1p+0 },
+{ INT64_C(0x4000080002200000), 0x1.00002000088p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffddfffff), -0x1.00002000088p+62, -0x1p+0 },
+{ INT64_C(0x4000080002400000), 0x1.0000200009p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fffdbfffff), -0x1.0000200009p+62, -0x1p+0 },
+{ INT64_C(0x4000080008000000), 0x1.000020002p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7ffffff), -0x1.000020002p+62, -0x1p+0 },
+{ INT64_C(0x4000080008000008), 0x1.000020002p+62, 0x1p+3 },
+{ INT64_C(0xbffff7fff7fffff7), -0x1.000020002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000080008000010), 0x1.000020002p+62, 0x1p+4 },
+{ INT64_C(0xbffff7fff7ffffef), -0x1.000020002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000080008000100), 0x1.000020002p+62, 0x1p+8 },
+{ INT64_C(0xbffff7fff7fffeff), -0x1.000020002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000080008001000), 0x1.0000200020004p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7ffefff), -0x1.0000200020004p+62, -0x1p+0 },
+{ INT64_C(0x4000080008002000), 0x1.0000200020008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7ffdfff), -0x1.0000200020008p+62, -0x1p+0 },
+{ INT64_C(0x4000080008010000), 0x1.000020002004p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7feffff), -0x1.000020002004p+62, -0x1p+0 },
+{ INT64_C(0x4000080008040000), 0x1.00002000201p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7fbffff), -0x1.00002000201p+62, -0x1p+0 },
+{ INT64_C(0x4000080008080000), 0x1.00002000202p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7f7ffff), -0x1.00002000202p+62, -0x1p+0 },
+{ INT64_C(0x4000080008100000), 0x1.00002000204p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7efffff), -0x1.00002000204p+62, -0x1p+0 },
+{ INT64_C(0x4000080008400000), 0x1.0000200021p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff7bfffff), -0x1.0000200021p+62, -0x1p+0 },
+{ INT64_C(0x400008000c000000), 0x1.000020003p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fff3ffffff), -0x1.000020003p+62, -0x1p+0 },
+{ INT64_C(0x4000080080000000), 0x1.00002002p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff7fffffff), -0x1.00002002p+62, -0x1p+0 },
+{ INT64_C(0x4000080080000004), 0x1.00002002p+62, 0x1p+2 },
+{ INT64_C(0xbffff7ff7ffffffb), -0x1.00002002p+62, -0x1.4p+2 },
+{ INT64_C(0x4000080080000010), 0x1.00002002p+62, 0x1p+4 },
+{ INT64_C(0xbffff7ff7fffffef), -0x1.00002002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000080080000100), 0x1.00002002p+62, 0x1p+8 },
+{ INT64_C(0xbffff7ff7ffffeff), -0x1.00002002p+62, -0x1.01p+8 },
+{ INT64_C(0x4000080080000200), 0x1.00002002p+62, 0x1p+9 },
+{ INT64_C(0xbffff7ff7ffffdff), -0x1.0000200200001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000080080002000), 0x1.0000200200008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff7fffdfff), -0x1.0000200200008p+62, -0x1p+0 },
+{ INT64_C(0x4000080080020000), 0x1.000020020008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff7ffdffff), -0x1.000020020008p+62, -0x1p+0 },
+{ INT64_C(0x4000080080080000), 0x1.00002002002p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff7ff7ffff), -0x1.00002002002p+62, -0x1p+0 },
+{ INT64_C(0x4000080080800000), 0x1.0000200202p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff7f7fffff), -0x1.0000200202p+62, -0x1p+0 },
+{ INT64_C(0x4000080082000000), 0x1.0000200208p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff7dffffff), -0x1.0000200208p+62, -0x1p+0 },
+{ INT64_C(0x4000080088000000), 0x1.000020022p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff77ffffff), -0x1.000020022p+62, -0x1p+0 },
+{ INT64_C(0x40000800a0000000), 0x1.000020028p+62, 0x0p+0 },
+{ INT64_C(0xbffff7ff5fffffff), -0x1.000020028p+62, -0x1p+0 },
+{ INT64_C(0x4000080400000000), 0x1.0000201p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbffffffff), -0x1.0000201p+62, -0x1p+0 },
+{ INT64_C(0x4000080400000002), 0x1.0000201p+62, 0x1p+1 },
+{ INT64_C(0xbffff7fbfffffffd), -0x1.0000201p+62, -0x1.8p+1 },
+{ INT64_C(0x4000080400000004), 0x1.0000201p+62, 0x1p+2 },
+{ INT64_C(0xbffff7fbfffffffb), -0x1.0000201p+62, -0x1.4p+2 },
+{ INT64_C(0x4000080400000040), 0x1.0000201p+62, 0x1p+6 },
+{ INT64_C(0xbffff7fbffffffbf), -0x1.0000201p+62, -0x1.04p+6 },
+{ INT64_C(0x4000080400000200), 0x1.0000201p+62, 0x1p+9 },
+{ INT64_C(0xbffff7fbfffffdff), -0x1.0000201000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000080400000800), 0x1.0000201000002p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbfffff7ff), -0x1.0000201000002p+62, -0x1p+0 },
+{ INT64_C(0x4000080400002000), 0x1.0000201000008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbffffdfff), -0x1.0000201000008p+62, -0x1p+0 },
+{ INT64_C(0x4000080400010000), 0x1.000020100004p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbfffeffff), -0x1.000020100004p+62, -0x1p+0 },
+{ INT64_C(0x4000080400040000), 0x1.00002010001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbfffbffff), -0x1.00002010001p+62, -0x1p+0 },
+{ INT64_C(0x4000080400400000), 0x1.0000201001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbffbfffff), -0x1.0000201001p+62, -0x1p+0 },
+{ INT64_C(0x4000080402000000), 0x1.0000201008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbfdffffff), -0x1.0000201008p+62, -0x1p+0 },
+{ INT64_C(0x4000080404000000), 0x1.000020101p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbfbffffff), -0x1.000020101p+62, -0x1p+0 },
+{ INT64_C(0x4000080440000000), 0x1.00002011p+62, 0x0p+0 },
+{ INT64_C(0xbffff7fbbfffffff), -0x1.00002011p+62, -0x1p+0 },
+{ INT64_C(0x4000080600000000), 0x1.00002018p+62, 0x0p+0 },
+{ INT64_C(0xbffff7f9ffffffff), -0x1.00002018p+62, -0x1p+0 },
+{ INT64_C(0x4000081000000000), 0x1.0000204p+62, 0x0p+0 },
+{ INT64_C(0xbffff7efffffffff), -0x1.0000204p+62, -0x1p+0 },
+{ INT64_C(0x4000081000000008), 0x1.0000204p+62, 0x1p+3 },
+{ INT64_C(0xbffff7effffffff7), -0x1.0000204p+62, -0x1.2p+3 },
+{ INT64_C(0x4000081000000010), 0x1.0000204p+62, 0x1p+4 },
+{ INT64_C(0xbffff7efffffffef), -0x1.0000204p+62, -0x1.1p+4 },
+{ INT64_C(0x4000081000000020), 0x1.0000204p+62, 0x1p+5 },
+{ INT64_C(0xbffff7efffffffdf), -0x1.0000204p+62, -0x1.08p+5 },
+{ INT64_C(0x4000081000000200), 0x1.0000204p+62, 0x1p+9 },
+{ INT64_C(0xbffff7effffffdff), -0x1.0000204000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000081000000400), 0x1.0000204000001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7effffffbff), -0x1.0000204000001p+62, -0x1p+0 },
+{ INT64_C(0x4000081000001000), 0x1.0000204000004p+62, 0x0p+0 },
+{ INT64_C(0xbffff7efffffefff), -0x1.0000204000004p+62, -0x1p+0 },
+{ INT64_C(0x4000081000004000), 0x1.000020400001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7efffffbfff), -0x1.000020400001p+62, -0x1p+0 },
+{ INT64_C(0x4000081000020000), 0x1.000020400008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7effffdffff), -0x1.000020400008p+62, -0x1p+0 },
+{ INT64_C(0x4000081000040000), 0x1.00002040001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7effffbffff), -0x1.00002040001p+62, -0x1p+0 },
+{ INT64_C(0x4000081000400000), 0x1.0000204001p+62, 0x0p+0 },
+{ INT64_C(0xbffff7efffbfffff), -0x1.0000204001p+62, -0x1p+0 },
+{ INT64_C(0x4000081002000000), 0x1.0000204008p+62, 0x0p+0 },
+{ INT64_C(0xbffff7effdffffff), -0x1.0000204008p+62, -0x1p+0 },
+{ INT64_C(0x4000081008000000), 0x1.000020402p+62, 0x0p+0 },
+{ INT64_C(0xbffff7eff7ffffff), -0x1.000020402p+62, -0x1p+0 },
+{ INT64_C(0x4000081020000000), 0x1.000020408p+62, 0x0p+0 },
+{ INT64_C(0xbffff7efdfffffff), -0x1.000020408p+62, -0x1p+0 },
+{ INT64_C(0x4000081100000000), 0x1.00002044p+62, 0x0p+0 },
+{ INT64_C(0xbffff7eeffffffff), -0x1.00002044p+62, -0x1p+0 },
+{ INT64_C(0x4000081800000000), 0x1.0000206p+62, 0x0p+0 },
+{ INT64_C(0xbffff7e7ffffffff), -0x1.0000206p+62, -0x1p+0 },
+{ INT64_C(0x4000088000000000), 0x1.000022p+62, 0x0p+0 },
+{ INT64_C(0xbffff77fffffffff), -0x1.000022p+62, -0x1p+0 },
+{ INT64_C(0x4000088000000002), 0x1.000022p+62, 0x1p+1 },
+{ INT64_C(0xbffff77ffffffffd), -0x1.000022p+62, -0x1.8p+1 },
+{ INT64_C(0x4000088000000010), 0x1.000022p+62, 0x1p+4 },
+{ INT64_C(0xbffff77fffffffef), -0x1.000022p+62, -0x1.1p+4 },
+{ INT64_C(0x4000088000000040), 0x1.000022p+62, 0x1p+6 },
+{ INT64_C(0xbffff77fffffffbf), -0x1.000022p+62, -0x1.04p+6 },
+{ INT64_C(0x4000088000000400), 0x1.0000220000001p+62, 0x0p+0 },
+{ INT64_C(0xbffff77ffffffbff), -0x1.0000220000001p+62, -0x1p+0 },
+{ INT64_C(0x4000088000002000), 0x1.0000220000008p+62, 0x0p+0 },
+{ INT64_C(0xbffff77fffffdfff), -0x1.0000220000008p+62, -0x1p+0 },
+{ INT64_C(0x4000088000010000), 0x1.000022000004p+62, 0x0p+0 },
+{ INT64_C(0xbffff77ffffeffff), -0x1.000022000004p+62, -0x1p+0 },
+{ INT64_C(0x4000088000020000), 0x1.000022000008p+62, 0x0p+0 },
+{ INT64_C(0xbffff77ffffdffff), -0x1.000022000008p+62, -0x1p+0 },
+{ INT64_C(0x4000088000100000), 0x1.00002200004p+62, 0x0p+0 },
+{ INT64_C(0xbffff77fffefffff), -0x1.00002200004p+62, -0x1p+0 },
+{ INT64_C(0x4000088000400000), 0x1.0000220001p+62, 0x0p+0 },
+{ INT64_C(0xbffff77fffbfffff), -0x1.0000220001p+62, -0x1p+0 },
+{ INT64_C(0x4000088001000000), 0x1.0000220004p+62, 0x0p+0 },
+{ INT64_C(0xbffff77ffeffffff), -0x1.0000220004p+62, -0x1p+0 },
+{ INT64_C(0x4000088004000000), 0x1.000022001p+62, 0x0p+0 },
+{ INT64_C(0xbffff77ffbffffff), -0x1.000022001p+62, -0x1p+0 },
+{ INT64_C(0x4000088040000000), 0x1.00002201p+62, 0x0p+0 },
+{ INT64_C(0xbffff77fbfffffff), -0x1.00002201p+62, -0x1p+0 },
+{ INT64_C(0x4000088100000000), 0x1.00002204p+62, 0x0p+0 },
+{ INT64_C(0xbffff77effffffff), -0x1.00002204p+62, -0x1p+0 },
+{ INT64_C(0x4000088200000000), 0x1.00002208p+62, 0x0p+0 },
+{ INT64_C(0xbffff77dffffffff), -0x1.00002208p+62, -0x1p+0 },
+{ INT64_C(0x4000088800000000), 0x1.0000222p+62, 0x0p+0 },
+{ INT64_C(0xbffff777ffffffff), -0x1.0000222p+62, -0x1p+0 },
+{ INT64_C(0x400008a000000000), 0x1.0000228p+62, 0x0p+0 },
+{ INT64_C(0xbffff75fffffffff), -0x1.0000228p+62, -0x1p+0 },
+{ INT64_C(0x4000400000000004), 0x1.0001p+62, 0x1p+2 },
+{ INT64_C(0xbfffbffffffffffb), -0x1.0001p+62, -0x1.4p+2 },
+{ INT64_C(0x4000400000000020), 0x1.0001p+62, 0x1p+5 },
+{ INT64_C(0xbfffbfffffffffdf), -0x1.0001p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400000000021), 0x1.0001p+62, 0x1.08p+5 },
+{ INT64_C(0xbfffbfffffffffde), -0x1.0001p+62, -0x1.1p+5 },
+{ INT64_C(0x4000400000000028), 0x1.0001p+62, 0x1.4p+5 },
+{ INT64_C(0xbfffbfffffffffd7), -0x1.0001p+62, -0x1.48p+5 },
+{ INT64_C(0x4000400000000040), 0x1.0001p+62, 0x1p+6 },
+{ INT64_C(0xbfffbfffffffffbf), -0x1.0001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400000000042), 0x1.0001p+62, 0x1.08p+6 },
+{ INT64_C(0xbfffbfffffffffbd), -0x1.0001p+62, -0x1.0cp+6 },
+{ INT64_C(0x4000400000000044), 0x1.0001p+62, 0x1.1p+6 },
+{ INT64_C(0xbfffbfffffffffbb), -0x1.0001p+62, -0x1.14p+6 },
+{ INT64_C(0x4000400000000400), 0x1.0001000000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffffbff), -0x1.0001000000001p+62, -0x1p+0 },
+{ INT64_C(0x4000400000000408), 0x1.0001000000001p+62, 0x1p+3 },
+{ INT64_C(0xbfffbffffffffbf7), -0x1.0001000000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000400000000440), 0x1.0001000000001p+62, 0x1p+6 },
+{ INT64_C(0xbfffbffffffffbbf), -0x1.0001000000001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400000000480), 0x1.0001000000001p+62, 0x1p+7 },
+{ INT64_C(0xbfffbffffffffb7f), -0x1.0001000000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000400000001000), 0x1.0001000000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffffefff), -0x1.0001000000004p+62, -0x1p+0 },
+{ INT64_C(0x4000400000001002), 0x1.0001000000004p+62, 0x1p+1 },
+{ INT64_C(0xbfffbfffffffeffd), -0x1.0001000000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4000400000001010), 0x1.0001000000004p+62, 0x1p+4 },
+{ INT64_C(0xbfffbfffffffefef), -0x1.0001000000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4000400000001040), 0x1.0001000000004p+62, 0x1p+6 },
+{ INT64_C(0xbfffbfffffffefbf), -0x1.0001000000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400000001080), 0x1.0001000000004p+62, 0x1p+7 },
+{ INT64_C(0xbfffbfffffffef7f), -0x1.0001000000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000400000001200), 0x1.0001000000004p+62, 0x1p+9 },
+{ INT64_C(0xbfffbfffffffedff), -0x1.0001000000005p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000400000001800), 0x1.0001000000006p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffffe7ff), -0x1.0001000000006p+62, -0x1p+0 },
+{ INT64_C(0x4000400000002000), 0x1.0001000000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffffdfff), -0x1.0001000000008p+62, -0x1p+0 },
+{ INT64_C(0x4000400000002001), 0x1.0001000000008p+62, 0x1p+0 },
+{ INT64_C(0xbfffbfffffffdffe), -0x1.0001000000008p+62, -0x1p+1 },
+{ INT64_C(0x4000400000002010), 0x1.0001000000008p+62, 0x1p+4 },
+{ INT64_C(0xbfffbfffffffdfef), -0x1.0001000000008p+62, -0x1.1p+4 },
+{ INT64_C(0x4000400000002100), 0x1.0001000000008p+62, 0x1p+8 },
+{ INT64_C(0xbfffbfffffffdeff), -0x1.0001000000008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000400000003000), 0x1.000100000000cp+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffffcfff), -0x1.000100000000cp+62, -0x1p+0 },
+{ INT64_C(0x4000400000010000), 0x1.000100000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffeffff), -0x1.000100000004p+62, -0x1p+0 },
+{ INT64_C(0x4000400000010001), 0x1.000100000004p+62, 0x1p+0 },
+{ INT64_C(0xbfffbffffffefffe), -0x1.000100000004p+62, -0x1p+1 },
+{ INT64_C(0x4000400000010008), 0x1.000100000004p+62, 0x1p+3 },
+{ INT64_C(0xbfffbffffffefff7), -0x1.000100000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4000400000010040), 0x1.000100000004p+62, 0x1p+6 },
+{ INT64_C(0xbfffbffffffeffbf), -0x1.000100000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400000010080), 0x1.000100000004p+62, 0x1p+7 },
+{ INT64_C(0xbfffbffffffeff7f), -0x1.000100000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000400000010400), 0x1.0001000000041p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffefbff), -0x1.0001000000041p+62, -0x1p+0 },
+{ INT64_C(0x4000400000012000), 0x1.0001000000048p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffedfff), -0x1.0001000000048p+62, -0x1p+0 },
+{ INT64_C(0x4000400000020000), 0x1.000100000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffdffff), -0x1.000100000008p+62, -0x1p+0 },
+{ INT64_C(0x4000400000020004), 0x1.000100000008p+62, 0x1p+2 },
+{ INT64_C(0xbfffbffffffdfffb), -0x1.000100000008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000400000020040), 0x1.000100000008p+62, 0x1p+6 },
+{ INT64_C(0xbfffbffffffdffbf), -0x1.000100000008p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400000020100), 0x1.000100000008p+62, 0x1p+8 },
+{ INT64_C(0xbfffbffffffdfeff), -0x1.000100000008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000400000021000), 0x1.0001000000084p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffdefff), -0x1.0001000000084p+62, -0x1p+0 },
+{ INT64_C(0x4000400000028000), 0x1.00010000000ap+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffd7fff), -0x1.00010000000ap+62, -0x1p+0 },
+{ INT64_C(0x4000400000040000), 0x1.00010000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffbffff), -0x1.00010000001p+62, -0x1p+0 },
+{ INT64_C(0x4000400000040001), 0x1.00010000001p+62, 0x1p+0 },
+{ INT64_C(0xbfffbffffffbfffe), -0x1.00010000001p+62, -0x1p+1 },
+{ INT64_C(0x4000400000040002), 0x1.00010000001p+62, 0x1p+1 },
+{ INT64_C(0xbfffbffffffbfffd), -0x1.00010000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4000400000040020), 0x1.00010000001p+62, 0x1p+5 },
+{ INT64_C(0xbfffbffffffbffdf), -0x1.00010000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400000040100), 0x1.00010000001p+62, 0x1p+8 },
+{ INT64_C(0xbfffbffffffbfeff), -0x1.00010000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000400000041000), 0x1.0001000000104p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffbefff), -0x1.0001000000104p+62, -0x1p+0 },
+{ INT64_C(0x4000400000050000), 0x1.000100000014p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffffffaffff), -0x1.000100000014p+62, -0x1p+0 },
+{ INT64_C(0x4000400000400000), 0x1.0001000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffbfffff), -0x1.0001000001p+62, -0x1p+0 },
+{ INT64_C(0x4000400000400002), 0x1.0001000001p+62, 0x1p+1 },
+{ INT64_C(0xbfffbfffffbffffd), -0x1.0001000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4000400000400020), 0x1.0001000001p+62, 0x1p+5 },
+{ INT64_C(0xbfffbfffffbfffdf), -0x1.0001000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400000400080), 0x1.0001000001p+62, 0x1p+7 },
+{ INT64_C(0xbfffbfffffbfff7f), -0x1.0001000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000400000400400), 0x1.0001000001001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffbffbff), -0x1.0001000001001p+62, -0x1p+0 },
+{ INT64_C(0x4000400000404000), 0x1.000100000101p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffbfbfff), -0x1.000100000101p+62, -0x1p+0 },
+{ INT64_C(0x4000400000440000), 0x1.00010000011p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffbbffff), -0x1.00010000011p+62, -0x1p+0 },
+{ INT64_C(0x4000400000500000), 0x1.00010000014p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffffafffff), -0x1.00010000014p+62, -0x1p+0 },
+{ INT64_C(0x4000400000800000), 0x1.0001000002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff7fffff), -0x1.0001000002p+62, -0x1p+0 },
+{ INT64_C(0x4000400000800002), 0x1.0001000002p+62, 0x1p+1 },
+{ INT64_C(0xbfffbfffff7ffffd), -0x1.0001000002p+62, -0x1.8p+1 },
+{ INT64_C(0x4000400000800020), 0x1.0001000002p+62, 0x1p+5 },
+{ INT64_C(0xbfffbfffff7fffdf), -0x1.0001000002p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400000800040), 0x1.0001000002p+62, 0x1p+6 },
+{ INT64_C(0xbfffbfffff7fffbf), -0x1.0001000002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400000800400), 0x1.0001000002001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff7ffbff), -0x1.0001000002001p+62, -0x1p+0 },
+{ INT64_C(0x4000400000802000), 0x1.0001000002008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff7fdfff), -0x1.0001000002008p+62, -0x1p+0 },
+{ INT64_C(0x4000400000808000), 0x1.000100000202p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff7f7fff), -0x1.000100000202p+62, -0x1p+0 },
+{ INT64_C(0x4000400000880000), 0x1.00010000022p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff77ffff), -0x1.00010000022p+62, -0x1p+0 },
+{ INT64_C(0x4000400000900000), 0x1.00010000024p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff6fffff), -0x1.00010000024p+62, -0x1p+0 },
+{ INT64_C(0x4000400000c00000), 0x1.0001000003p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffff3fffff), -0x1.0001000003p+62, -0x1p+0 },
+{ INT64_C(0x4000400008000000), 0x1.000100002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff7ffffff), -0x1.000100002p+62, -0x1p+0 },
+{ INT64_C(0x4000400008000002), 0x1.000100002p+62, 0x1p+1 },
+{ INT64_C(0xbfffbffff7fffffd), -0x1.000100002p+62, -0x1.8p+1 },
+{ INT64_C(0x4000400008000008), 0x1.000100002p+62, 0x1p+3 },
+{ INT64_C(0xbfffbffff7fffff7), -0x1.000100002p+62, -0x1.2p+3 },
+{ INT64_C(0x4000400008000010), 0x1.000100002p+62, 0x1p+4 },
+{ INT64_C(0xbfffbffff7ffffef), -0x1.000100002p+62, -0x1.1p+4 },
+{ INT64_C(0x4000400008000020), 0x1.000100002p+62, 0x1p+5 },
+{ INT64_C(0xbfffbffff7ffffdf), -0x1.000100002p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400008000040), 0x1.000100002p+62, 0x1p+6 },
+{ INT64_C(0xbfffbffff7ffffbf), -0x1.000100002p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400008000200), 0x1.000100002p+62, 0x1p+9 },
+{ INT64_C(0xbfffbffff7fffdff), -0x1.0001000020001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000400008001000), 0x1.0001000020004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff7ffefff), -0x1.0001000020004p+62, -0x1p+0 },
+{ INT64_C(0x4000400008010000), 0x1.000100002004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff7feffff), -0x1.000100002004p+62, -0x1p+0 },
+{ INT64_C(0x4000400008080000), 0x1.00010000202p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff7f7ffff), -0x1.00010000202p+62, -0x1p+0 },
+{ INT64_C(0x4000400008800000), 0x1.0001000022p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff77fffff), -0x1.0001000022p+62, -0x1p+0 },
+{ INT64_C(0x4000400009000000), 0x1.0001000024p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff6ffffff), -0x1.0001000024p+62, -0x1p+0 },
+{ INT64_C(0x400040000c000000), 0x1.000100003p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffff3ffffff), -0x1.000100003p+62, -0x1p+0 },
+{ INT64_C(0x4000400020000000), 0x1.000100008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdfffffff), -0x1.000100008p+62, -0x1p+0 },
+{ INT64_C(0x4000400020000004), 0x1.000100008p+62, 0x1p+2 },
+{ INT64_C(0xbfffbfffdffffffb), -0x1.000100008p+62, -0x1.4p+2 },
+{ INT64_C(0x4000400020000020), 0x1.000100008p+62, 0x1p+5 },
+{ INT64_C(0xbfffbfffdfffffdf), -0x1.000100008p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400020000100), 0x1.000100008p+62, 0x1p+8 },
+{ INT64_C(0xbfffbfffdffffeff), -0x1.000100008p+62, -0x1.01p+8 },
+{ INT64_C(0x4000400020001000), 0x1.0001000080004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdfffefff), -0x1.0001000080004p+62, -0x1p+0 },
+{ INT64_C(0x4000400020002000), 0x1.0001000080008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdfffdfff), -0x1.0001000080008p+62, -0x1p+0 },
+{ INT64_C(0x4000400020004000), 0x1.000100008001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdfffbfff), -0x1.000100008001p+62, -0x1p+0 },
+{ INT64_C(0x4000400020008000), 0x1.000100008002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdfff7fff), -0x1.000100008002p+62, -0x1p+0 },
+{ INT64_C(0x4000400020010000), 0x1.000100008004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdffeffff), -0x1.000100008004p+62, -0x1p+0 },
+{ INT64_C(0x4000400020020000), 0x1.000100008008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdffdffff), -0x1.000100008008p+62, -0x1p+0 },
+{ INT64_C(0x4000400020080000), 0x1.00010000802p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdff7ffff), -0x1.00010000802p+62, -0x1p+0 },
+{ INT64_C(0x4000400020800000), 0x1.0001000082p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdf7fffff), -0x1.0001000082p+62, -0x1p+0 },
+{ INT64_C(0x4000400021000000), 0x1.0001000084p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffdeffffff), -0x1.0001000084p+62, -0x1p+0 },
+{ INT64_C(0x4000400028000000), 0x1.00010000ap+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffd7ffffff), -0x1.00010000ap+62, -0x1p+0 },
+{ INT64_C(0x4000400030000000), 0x1.00010000cp+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffcfffffff), -0x1.00010000cp+62, -0x1p+0 },
+{ INT64_C(0x4000400040000000), 0x1.00010001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffbfffffff), -0x1.00010001p+62, -0x1p+0 },
+{ INT64_C(0x4000400040000008), 0x1.00010001p+62, 0x1p+3 },
+{ INT64_C(0xbfffbfffbffffff7), -0x1.00010001p+62, -0x1.2p+3 },
+{ INT64_C(0x4000400040000040), 0x1.00010001p+62, 0x1p+6 },
+{ INT64_C(0xbfffbfffbfffffbf), -0x1.00010001p+62, -0x1.04p+6 },
+{ INT64_C(0x4000400040000080), 0x1.00010001p+62, 0x1p+7 },
+{ INT64_C(0xbfffbfffbfffff7f), -0x1.00010001p+62, -0x1.02p+7 },
+{ INT64_C(0x4000400040000100), 0x1.00010001p+62, 0x1p+8 },
+{ INT64_C(0xbfffbfffbffffeff), -0x1.00010001p+62, -0x1.01p+8 },
+{ INT64_C(0x4000400040001000), 0x1.0001000100004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffbfffefff), -0x1.0001000100004p+62, -0x1p+0 },
+{ INT64_C(0x4000400040010000), 0x1.000100010004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffbffeffff), -0x1.000100010004p+62, -0x1p+0 },
+{ INT64_C(0x4000400040040000), 0x1.00010001001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffbffbffff), -0x1.00010001001p+62, -0x1p+0 },
+{ INT64_C(0x4000400040400000), 0x1.0001000101p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffbfbfffff), -0x1.0001000101p+62, -0x1p+0 },
+{ INT64_C(0x4000400044000000), 0x1.000100011p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfffbbffffff), -0x1.000100011p+62, -0x1p+0 },
+{ INT64_C(0x4000400060000000), 0x1.000100018p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfff9fffffff), -0x1.000100018p+62, -0x1p+0 },
+{ INT64_C(0x4000400400000000), 0x1.0001001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbffffffff), -0x1.0001001p+62, -0x1p+0 },
+{ INT64_C(0x4000400400000002), 0x1.0001001p+62, 0x1p+1 },
+{ INT64_C(0xbfffbffbfffffffd), -0x1.0001001p+62, -0x1.8p+1 },
+{ INT64_C(0x4000400400000020), 0x1.0001001p+62, 0x1p+5 },
+{ INT64_C(0xbfffbffbffffffdf), -0x1.0001001p+62, -0x1.08p+5 },
+{ INT64_C(0x4000400400000200), 0x1.0001001p+62, 0x1p+9 },
+{ INT64_C(0xbfffbffbfffffdff), -0x1.0001001000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000400400000400), 0x1.0001001000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbfffffbff), -0x1.0001001000001p+62, -0x1p+0 },
+{ INT64_C(0x4000400400002000), 0x1.0001001000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbffffdfff), -0x1.0001001000008p+62, -0x1p+0 },
+{ INT64_C(0x4000400400020000), 0x1.000100100008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbfffdffff), -0x1.000100100008p+62, -0x1p+0 },
+{ INT64_C(0x4000400400100000), 0x1.00010010004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbffefffff), -0x1.00010010004p+62, -0x1p+0 },
+{ INT64_C(0x4000400400400000), 0x1.0001001001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbffbfffff), -0x1.0001001001p+62, -0x1p+0 },
+{ INT64_C(0x4000400401000000), 0x1.0001001004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbfeffffff), -0x1.0001001004p+62, -0x1p+0 },
+{ INT64_C(0x4000400408000000), 0x1.000100102p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbf7ffffff), -0x1.000100102p+62, -0x1p+0 },
+{ INT64_C(0x4000400420000000), 0x1.000100108p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbdfffffff), -0x1.000100108p+62, -0x1p+0 },
+{ INT64_C(0x4000400440000000), 0x1.00010011p+62, 0x0p+0 },
+{ INT64_C(0xbfffbffbbfffffff), -0x1.00010011p+62, -0x1p+0 },
+{ INT64_C(0x4000401000000000), 0x1.0001004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfefffffffff), -0x1.0001004p+62, -0x1p+0 },
+{ INT64_C(0x4000401000000004), 0x1.0001004p+62, 0x1p+2 },
+{ INT64_C(0xbfffbfeffffffffb), -0x1.0001004p+62, -0x1.4p+2 },
+{ INT64_C(0x4000401000000020), 0x1.0001004p+62, 0x1p+5 },
+{ INT64_C(0xbfffbfefffffffdf), -0x1.0001004p+62, -0x1.08p+5 },
+{ INT64_C(0x4000401000000040), 0x1.0001004p+62, 0x1p+6 },
+{ INT64_C(0xbfffbfefffffffbf), -0x1.0001004p+62, -0x1.04p+6 },
+{ INT64_C(0x4000401000000080), 0x1.0001004p+62, 0x1p+7 },
+{ INT64_C(0xbfffbfefffffff7f), -0x1.0001004p+62, -0x1.02p+7 },
+{ INT64_C(0x4000401000000100), 0x1.0001004p+62, 0x1p+8 },
+{ INT64_C(0xbfffbfeffffffeff), -0x1.0001004p+62, -0x1.01p+8 },
+{ INT64_C(0x4000401000001000), 0x1.0001004000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfefffffefff), -0x1.0001004000004p+62, -0x1p+0 },
+{ INT64_C(0x4000401000002000), 0x1.0001004000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfefffffdfff), -0x1.0001004000008p+62, -0x1p+0 },
+{ INT64_C(0x4000401000008000), 0x1.000100400002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfefffff7fff), -0x1.000100400002p+62, -0x1p+0 },
+{ INT64_C(0x4000401000040000), 0x1.00010040001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfeffffbffff), -0x1.00010040001p+62, -0x1p+0 },
+{ INT64_C(0x4000401000080000), 0x1.00010040002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfeffff7ffff), -0x1.00010040002p+62, -0x1p+0 },
+{ INT64_C(0x4000401000800000), 0x1.0001004002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfefff7fffff), -0x1.0001004002p+62, -0x1p+0 },
+{ INT64_C(0x4000401001000000), 0x1.0001004004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfeffeffffff), -0x1.0001004004p+62, -0x1p+0 },
+{ INT64_C(0x4000401002000000), 0x1.0001004008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfeffdffffff), -0x1.0001004008p+62, -0x1p+0 },
+{ INT64_C(0x4000401020000000), 0x1.000100408p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfefdfffffff), -0x1.000100408p+62, -0x1p+0 },
+{ INT64_C(0x4000401200000000), 0x1.00010048p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfedffffffff), -0x1.00010048p+62, -0x1p+0 },
+{ INT64_C(0x4000404000000000), 0x1.000101p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbfffffffff), -0x1.000101p+62, -0x1p+0 },
+{ INT64_C(0x4000404000000002), 0x1.000101p+62, 0x1p+1 },
+{ INT64_C(0xbfffbfbffffffffd), -0x1.000101p+62, -0x1.8p+1 },
+{ INT64_C(0x4000404000000008), 0x1.000101p+62, 0x1p+3 },
+{ INT64_C(0xbfffbfbffffffff7), -0x1.000101p+62, -0x1.2p+3 },
+{ INT64_C(0x4000404000000080), 0x1.000101p+62, 0x1p+7 },
+{ INT64_C(0xbfffbfbfffffff7f), -0x1.000101p+62, -0x1.02p+7 },
+{ INT64_C(0x4000404000000100), 0x1.000101p+62, 0x1p+8 },
+{ INT64_C(0xbfffbfbffffffeff), -0x1.000101p+62, -0x1.01p+8 },
+{ INT64_C(0x4000404000001000), 0x1.0001010000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbfffffefff), -0x1.0001010000004p+62, -0x1p+0 },
+{ INT64_C(0x4000404000004000), 0x1.000101000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbfffffbfff), -0x1.000101000001p+62, -0x1p+0 },
+{ INT64_C(0x4000404000008000), 0x1.000101000002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbfffff7fff), -0x1.000101000002p+62, -0x1p+0 },
+{ INT64_C(0x4000404000020000), 0x1.000101000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbffffdffff), -0x1.000101000008p+62, -0x1p+0 },
+{ INT64_C(0x4000404000200000), 0x1.00010100008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbfffdfffff), -0x1.00010100008p+62, -0x1p+0 },
+{ INT64_C(0x4000404002000000), 0x1.0001010008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbffdffffff), -0x1.0001010008p+62, -0x1p+0 },
+{ INT64_C(0x4000404008000000), 0x1.000101002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbff7ffffff), -0x1.000101002p+62, -0x1p+0 },
+{ INT64_C(0x4000404040000000), 0x1.00010101p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbfbfffffff), -0x1.00010101p+62, -0x1p+0 },
+{ INT64_C(0x4000404080000000), 0x1.00010102p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbf7fffffff), -0x1.00010102p+62, -0x1p+0 },
+{ INT64_C(0x4000404100000000), 0x1.00010104p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbeffffffff), -0x1.00010104p+62, -0x1p+0 },
+{ INT64_C(0x4000404200000000), 0x1.00010108p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfbdffffffff), -0x1.00010108p+62, -0x1p+0 },
+{ INT64_C(0x4000404800000000), 0x1.0001012p+62, 0x0p+0 },
+{ INT64_C(0xbfffbfb7ffffffff), -0x1.0001012p+62, -0x1p+0 },
+{ INT64_C(0x4000406000000000), 0x1.0001018p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf9fffffffff), -0x1.0001018p+62, -0x1p+0 },
+{ INT64_C(0x4000408000000000), 0x1.000102p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7fffffffff), -0x1.000102p+62, -0x1p+0 },
+{ INT64_C(0x4000408000000002), 0x1.000102p+62, 0x1p+1 },
+{ INT64_C(0xbfffbf7ffffffffd), -0x1.000102p+62, -0x1.8p+1 },
+{ INT64_C(0x4000408000000020), 0x1.000102p+62, 0x1p+5 },
+{ INT64_C(0xbfffbf7fffffffdf), -0x1.000102p+62, -0x1.08p+5 },
+{ INT64_C(0x4000408000000080), 0x1.000102p+62, 0x1p+7 },
+{ INT64_C(0xbfffbf7fffffff7f), -0x1.000102p+62, -0x1.02p+7 },
+{ INT64_C(0x4000408000000100), 0x1.000102p+62, 0x1p+8 },
+{ INT64_C(0xbfffbf7ffffffeff), -0x1.000102p+62, -0x1.01p+8 },
+{ INT64_C(0x4000408000000400), 0x1.0001020000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7ffffffbff), -0x1.0001020000001p+62, -0x1p+0 },
+{ INT64_C(0x4000408000001000), 0x1.0001020000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7fffffefff), -0x1.0001020000004p+62, -0x1p+0 },
+{ INT64_C(0x4000408000010000), 0x1.000102000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7ffffeffff), -0x1.000102000004p+62, -0x1p+0 },
+{ INT64_C(0x4000408000020000), 0x1.000102000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7ffffdffff), -0x1.000102000008p+62, -0x1p+0 },
+{ INT64_C(0x4000408000100000), 0x1.00010200004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7fffefffff), -0x1.00010200004p+62, -0x1p+0 },
+{ INT64_C(0x4000408001000000), 0x1.0001020004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7ffeffffff), -0x1.0001020004p+62, -0x1p+0 },
+{ INT64_C(0x4000408002000000), 0x1.0001020008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7ffdffffff), -0x1.0001020008p+62, -0x1p+0 },
+{ INT64_C(0x4000408008000000), 0x1.000102002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7ff7ffffff), -0x1.000102002p+62, -0x1p+0 },
+{ INT64_C(0x4000408080000000), 0x1.00010202p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7f7fffffff), -0x1.00010202p+62, -0x1p+0 },
+{ INT64_C(0x4000408400000000), 0x1.0001021p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf7bffffffff), -0x1.0001021p+62, -0x1p+0 },
+{ INT64_C(0x4000409000000000), 0x1.0001024p+62, 0x0p+0 },
+{ INT64_C(0xbfffbf6fffffffff), -0x1.0001024p+62, -0x1p+0 },
+{ INT64_C(0x4000440000000000), 0x1.00011p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbffffffffff), -0x1.00011p+62, -0x1p+0 },
+{ INT64_C(0x4000440000000001), 0x1.00011p+62, 0x1p+0 },
+{ INT64_C(0xbfffbbfffffffffe), -0x1.00011p+62, -0x1p+1 },
+{ INT64_C(0x4000440000000002), 0x1.00011p+62, 0x1p+1 },
+{ INT64_C(0xbfffbbfffffffffd), -0x1.00011p+62, -0x1.8p+1 },
+{ INT64_C(0x4000440000000008), 0x1.00011p+62, 0x1p+3 },
+{ INT64_C(0xbfffbbfffffffff7), -0x1.00011p+62, -0x1.2p+3 },
+{ INT64_C(0x4000440000000040), 0x1.00011p+62, 0x1p+6 },
+{ INT64_C(0xbfffbbffffffffbf), -0x1.00011p+62, -0x1.04p+6 },
+{ INT64_C(0x4000440000000080), 0x1.00011p+62, 0x1p+7 },
+{ INT64_C(0xbfffbbffffffff7f), -0x1.00011p+62, -0x1.02p+7 },
+{ INT64_C(0x4000440000000200), 0x1.00011p+62, 0x1p+9 },
+{ INT64_C(0xbfffbbfffffffdff), -0x1.0001100000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000440000002000), 0x1.0001100000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbffffffdfff), -0x1.0001100000008p+62, -0x1p+0 },
+{ INT64_C(0x4000440000010000), 0x1.000110000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfffffeffff), -0x1.000110000004p+62, -0x1p+0 },
+{ INT64_C(0x4000440000080000), 0x1.00011000002p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfffff7ffff), -0x1.00011000002p+62, -0x1p+0 },
+{ INT64_C(0x4000440000100000), 0x1.00011000004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbffffefffff), -0x1.00011000004p+62, -0x1p+0 },
+{ INT64_C(0x4000440000200000), 0x1.00011000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbffffdfffff), -0x1.00011000008p+62, -0x1p+0 },
+{ INT64_C(0x4000440001000000), 0x1.0001100004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfffeffffff), -0x1.0001100004p+62, -0x1p+0 },
+{ INT64_C(0x4000440002000000), 0x1.0001100008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfffdffffff), -0x1.0001100008p+62, -0x1p+0 },
+{ INT64_C(0x4000440010000000), 0x1.000110004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbffefffffff), -0x1.000110004p+62, -0x1p+0 },
+{ INT64_C(0x4000440100000000), 0x1.00011004p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfeffffffff), -0x1.00011004p+62, -0x1p+0 },
+{ INT64_C(0x4000440200000000), 0x1.00011008p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfdffffffff), -0x1.00011008p+62, -0x1p+0 },
+{ INT64_C(0x4000440400000000), 0x1.0001101p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbfbffffffff), -0x1.0001101p+62, -0x1p+0 },
+{ INT64_C(0x4000442000000000), 0x1.0001108p+62, 0x0p+0 },
+{ INT64_C(0xbfffbbdfffffffff), -0x1.0001108p+62, -0x1p+0 },
+{ INT64_C(0x4000460000000000), 0x1.000118p+62, 0x0p+0 },
+{ INT64_C(0xbfffb9ffffffffff), -0x1.000118p+62, -0x1p+0 },
+{ INT64_C(0x4000500000000000), 0x1.00014p+62, 0x0p+0 },
+{ INT64_C(0xbfffafffffffffff), -0x1.00014p+62, -0x1p+0 },
+{ INT64_C(0x4000500000000004), 0x1.00014p+62, 0x1p+2 },
+{ INT64_C(0xbfffaffffffffffb), -0x1.00014p+62, -0x1.4p+2 },
+{ INT64_C(0x4000500000000020), 0x1.00014p+62, 0x1p+5 },
+{ INT64_C(0xbfffafffffffffdf), -0x1.00014p+62, -0x1.08p+5 },
+{ INT64_C(0x4000500000000040), 0x1.00014p+62, 0x1p+6 },
+{ INT64_C(0xbfffafffffffffbf), -0x1.00014p+62, -0x1.04p+6 },
+{ INT64_C(0x4000500000000080), 0x1.00014p+62, 0x1p+7 },
+{ INT64_C(0xbfffafffffffff7f), -0x1.00014p+62, -0x1.02p+7 },
+{ INT64_C(0x4000500000000200), 0x1.00014p+62, 0x1p+9 },
+{ INT64_C(0xbfffaffffffffdff), -0x1.0001400000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4000500000002000), 0x1.0001400000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffafffffffdfff), -0x1.0001400000008p+62, -0x1p+0 },
+{ INT64_C(0x4000500000020000), 0x1.000140000008p+62, 0x0p+0 },
+{ INT64_C(0xbfffaffffffdffff), -0x1.000140000008p+62, -0x1p+0 },
+{ INT64_C(0x4000500000040000), 0x1.00014000001p+62, 0x0p+0 },
+{ INT64_C(0xbfffaffffffbffff), -0x1.00014000001p+62, -0x1p+0 },
+{ INT64_C(0x4000500000080000), 0x1.00014000002p+62, 0x0p+0 },
+{ INT64_C(0xbfffaffffff7ffff), -0x1.00014000002p+62, -0x1p+0 },
+{ INT64_C(0x4000500000800000), 0x1.0001400002p+62, 0x0p+0 },
+{ INT64_C(0xbfffafffff7fffff), -0x1.0001400002p+62, -0x1p+0 },
+{ INT64_C(0x4000500002000000), 0x1.0001400008p+62, 0x0p+0 },
+{ INT64_C(0xbfffaffffdffffff), -0x1.0001400008p+62, -0x1p+0 },
+{ INT64_C(0x4000500004000000), 0x1.000140001p+62, 0x0p+0 },
+{ INT64_C(0xbfffaffffbffffff), -0x1.000140001p+62, -0x1p+0 },
+{ INT64_C(0x4000500020000000), 0x1.000140008p+62, 0x0p+0 },
+{ INT64_C(0xbfffafffdfffffff), -0x1.000140008p+62, -0x1p+0 },
+{ INT64_C(0x4000500080000000), 0x1.00014002p+62, 0x0p+0 },
+{ INT64_C(0xbfffafff7fffffff), -0x1.00014002p+62, -0x1p+0 },
+{ INT64_C(0x4000500100000000), 0x1.00014004p+62, 0x0p+0 },
+{ INT64_C(0xbfffaffeffffffff), -0x1.00014004p+62, -0x1p+0 },
+{ INT64_C(0x4000501000000000), 0x1.0001404p+62, 0x0p+0 },
+{ INT64_C(0xbfffafefffffffff), -0x1.0001404p+62, -0x1p+0 },
+{ INT64_C(0x4000508000000000), 0x1.000142p+62, 0x0p+0 },
+{ INT64_C(0xbfffaf7fffffffff), -0x1.000142p+62, -0x1p+0 },
+{ INT64_C(0x4000510000000000), 0x1.000144p+62, 0x0p+0 },
+{ INT64_C(0xbfffaeffffffffff), -0x1.000144p+62, -0x1p+0 },
+{ INT64_C(0x4000540000000000), 0x1.00015p+62, 0x0p+0 },
+{ INT64_C(0xbfffabffffffffff), -0x1.00015p+62, -0x1p+0 },
+{ INT64_C(0x4000580000000000), 0x1.00016p+62, 0x0p+0 },
+{ INT64_C(0xbfffa7ffffffffff), -0x1.00016p+62, -0x1p+0 },
+{ INT64_C(0x4002000000000004), 0x1.0008p+62, 0x1p+2 },
+{ INT64_C(0xbffdfffffffffffb), -0x1.0008p+62, -0x1.4p+2 },
+{ INT64_C(0x4002000000000010), 0x1.0008p+62, 0x1p+4 },
+{ INT64_C(0xbffdffffffffffef), -0x1.0008p+62, -0x1.1p+4 },
+{ INT64_C(0x4002000000000012), 0x1.0008p+62, 0x1.2p+4 },
+{ INT64_C(0xbffdffffffffffed), -0x1.0008p+62, -0x1.3p+4 },
+{ INT64_C(0x4002000000000014), 0x1.0008p+62, 0x1.4p+4 },
+{ INT64_C(0xbffdffffffffffeb), -0x1.0008p+62, -0x1.5p+4 },
+{ INT64_C(0x4002000000000018), 0x1.0008p+62, 0x1.8p+4 },
+{ INT64_C(0xbffdffffffffffe7), -0x1.0008p+62, -0x1.9p+4 },
+{ INT64_C(0x4002000000000080), 0x1.0008p+62, 0x1p+7 },
+{ INT64_C(0xbffdffffffffff7f), -0x1.0008p+62, -0x1.02p+7 },
+{ INT64_C(0x4002000000000084), 0x1.0008p+62, 0x1.08p+7 },
+{ INT64_C(0xbffdffffffffff7b), -0x1.0008p+62, -0x1.0ap+7 },
+{ INT64_C(0x4002000000000088), 0x1.0008p+62, 0x1.1p+7 },
+{ INT64_C(0xbffdffffffffff77), -0x1.0008p+62, -0x1.12p+7 },
+{ INT64_C(0x40020000000000c0), 0x1.0008p+62, 0x1.8p+7 },
+{ INT64_C(0xbffdffffffffff3f), -0x1.0008p+62, -0x1.82p+7 },
+{ INT64_C(0x4002000000000400), 0x1.0008000000001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffffffbff), -0x1.0008000000001p+62, -0x1p+0 },
+{ INT64_C(0x4002000000000401), 0x1.0008000000001p+62, 0x1p+0 },
+{ INT64_C(0xbffdfffffffffbfe), -0x1.0008000000001p+62, -0x1p+1 },
+{ INT64_C(0x4002000000000402), 0x1.0008000000001p+62, 0x1p+1 },
+{ INT64_C(0xbffdfffffffffbfd), -0x1.0008000000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4002000000000420), 0x1.0008000000001p+62, 0x1p+5 },
+{ INT64_C(0xbffdfffffffffbdf), -0x1.0008000000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4002000000000500), 0x1.0008000000001p+62, 0x1p+8 },
+{ INT64_C(0xbffdfffffffffaff), -0x1.0008000000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4002000000001000), 0x1.0008000000004p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffffefff), -0x1.0008000000004p+62, -0x1p+0 },
+{ INT64_C(0x4002000000001001), 0x1.0008000000004p+62, 0x1p+0 },
+{ INT64_C(0xbffdffffffffeffe), -0x1.0008000000004p+62, -0x1p+1 },
+{ INT64_C(0x4002000000001010), 0x1.0008000000004p+62, 0x1p+4 },
+{ INT64_C(0xbffdffffffffefef), -0x1.0008000000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4002000000001100), 0x1.0008000000004p+62, 0x1p+8 },
+{ INT64_C(0xbffdffffffffeeff), -0x1.0008000000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4002000000001800), 0x1.0008000000006p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffffe7ff), -0x1.0008000000006p+62, -0x1p+0 },
+{ INT64_C(0x4002000000004000), 0x1.000800000001p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffffbfff), -0x1.000800000001p+62, -0x1p+0 },
+{ INT64_C(0x4002000000004002), 0x1.000800000001p+62, 0x1p+1 },
+{ INT64_C(0xbffdffffffffbffd), -0x1.000800000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4002000000004008), 0x1.000800000001p+62, 0x1p+3 },
+{ INT64_C(0xbffdffffffffbff7), -0x1.000800000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4002000000004080), 0x1.000800000001p+62, 0x1p+7 },
+{ INT64_C(0xbffdffffffffbf7f), -0x1.000800000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4002000000004100), 0x1.000800000001p+62, 0x1p+8 },
+{ INT64_C(0xbffdffffffffbeff), -0x1.000800000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4002000000004800), 0x1.0008000000012p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffffb7ff), -0x1.0008000000012p+62, -0x1p+0 },
+{ INT64_C(0x4002000000005000), 0x1.0008000000014p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffffafff), -0x1.0008000000014p+62, -0x1p+0 },
+{ INT64_C(0x4002000000006000), 0x1.0008000000018p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffff9fff), -0x1.0008000000018p+62, -0x1p+0 },
+{ INT64_C(0x4002000000040000), 0x1.00080000001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffffbffff), -0x1.00080000001p+62, -0x1p+0 },
+{ INT64_C(0x4002000000040001), 0x1.00080000001p+62, 0x1p+0 },
+{ INT64_C(0xbffdfffffffbfffe), -0x1.00080000001p+62, -0x1p+1 },
+{ INT64_C(0x4002000000040008), 0x1.00080000001p+62, 0x1p+3 },
+{ INT64_C(0xbffdfffffffbfff7), -0x1.00080000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4002000000040040), 0x1.00080000001p+62, 0x1p+6 },
+{ INT64_C(0xbffdfffffffbffbf), -0x1.00080000001p+62, -0x1.04p+6 },
+{ INT64_C(0x4002000000040080), 0x1.00080000001p+62, 0x1p+7 },
+{ INT64_C(0xbffdfffffffbff7f), -0x1.00080000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4002000000040200), 0x1.00080000001p+62, 0x1p+9 },
+{ INT64_C(0xbffdfffffffbfdff), -0x1.0008000000101p+62, 0x1.ffp+8 },
+{ INT64_C(0x4002000000042000), 0x1.0008000000108p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffffbdfff), -0x1.0008000000108p+62, -0x1p+0 },
+{ INT64_C(0x4002000000060000), 0x1.000800000018p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffff9ffff), -0x1.000800000018p+62, -0x1p+0 },
+{ INT64_C(0x4002000000100000), 0x1.00080000004p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffefffff), -0x1.00080000004p+62, -0x1p+0 },
+{ INT64_C(0x4002000000100002), 0x1.00080000004p+62, 0x1p+1 },
+{ INT64_C(0xbffdffffffeffffd), -0x1.00080000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4002000000100020), 0x1.00080000004p+62, 0x1p+5 },
+{ INT64_C(0xbffdffffffefffdf), -0x1.00080000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4002000000100080), 0x1.00080000004p+62, 0x1p+7 },
+{ INT64_C(0xbffdffffffefff7f), -0x1.00080000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4002000000100400), 0x1.0008000000401p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffeffbff), -0x1.0008000000401p+62, -0x1p+0 },
+{ INT64_C(0x4002000000102000), 0x1.0008000000408p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffefdfff), -0x1.0008000000408p+62, -0x1p+0 },
+{ INT64_C(0x4002000000120000), 0x1.000800000048p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffedffff), -0x1.000800000048p+62, -0x1p+0 },
+{ INT64_C(0x4002000000140000), 0x1.00080000005p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffffebffff), -0x1.00080000005p+62, -0x1p+0 },
+{ INT64_C(0x4002000001000000), 0x1.0008000004p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffeffffff), -0x1.0008000004p+62, -0x1p+0 },
+{ INT64_C(0x4002000001000002), 0x1.0008000004p+62, 0x1p+1 },
+{ INT64_C(0xbffdfffffefffffd), -0x1.0008000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4002000001000004), 0x1.0008000004p+62, 0x1p+2 },
+{ INT64_C(0xbffdfffffefffffb), -0x1.0008000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4002000001000010), 0x1.0008000004p+62, 0x1p+4 },
+{ INT64_C(0xbffdfffffeffffef), -0x1.0008000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4002000001000020), 0x1.0008000004p+62, 0x1p+5 },
+{ INT64_C(0xbffdfffffeffffdf), -0x1.0008000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4002000001000100), 0x1.0008000004p+62, 0x1p+8 },
+{ INT64_C(0xbffdfffffefffeff), -0x1.0008000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4002000001001000), 0x1.0008000004004p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffeffefff), -0x1.0008000004004p+62, -0x1p+0 },
+{ INT64_C(0x4002000001008000), 0x1.000800000402p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffeff7fff), -0x1.000800000402p+62, -0x1p+0 },
+{ INT64_C(0x4002000001080000), 0x1.00080000042p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffef7ffff), -0x1.00080000042p+62, -0x1p+0 },
+{ INT64_C(0x4002000001400000), 0x1.0008000005p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffffebfffff), -0x1.0008000005p+62, -0x1p+0 },
+{ INT64_C(0x4002000010000000), 0x1.000800004p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffefffffff), -0x1.000800004p+62, -0x1p+0 },
+{ INT64_C(0x4002000010000002), 0x1.000800004p+62, 0x1p+1 },
+{ INT64_C(0xbffdffffeffffffd), -0x1.000800004p+62, -0x1.8p+1 },
+{ INT64_C(0x4002000010000010), 0x1.000800004p+62, 0x1p+4 },
+{ INT64_C(0xbffdffffefffffef), -0x1.000800004p+62, -0x1.1p+4 },
+{ INT64_C(0x4002000010000100), 0x1.000800004p+62, 0x1p+8 },
+{ INT64_C(0xbffdffffeffffeff), -0x1.000800004p+62, -0x1.01p+8 },
+{ INT64_C(0x4002000010000800), 0x1.0008000040002p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffeffff7ff), -0x1.0008000040002p+62, -0x1p+0 },
+{ INT64_C(0x4002000010004000), 0x1.000800004001p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffefffbfff), -0x1.000800004001p+62, -0x1p+0 },
+{ INT64_C(0x4002000010020000), 0x1.000800004008p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffeffdffff), -0x1.000800004008p+62, -0x1p+0 },
+{ INT64_C(0x4002000010200000), 0x1.00080000408p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffefdfffff), -0x1.00080000408p+62, -0x1p+0 },
+{ INT64_C(0x4002000010800000), 0x1.0008000042p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffef7fffff), -0x1.0008000042p+62, -0x1p+0 },
+{ INT64_C(0x4002000014000000), 0x1.000800005p+62, 0x0p+0 },
+{ INT64_C(0xbffdffffebffffff), -0x1.000800005p+62, -0x1p+0 },
+{ INT64_C(0x4002000100000000), 0x1.00080004p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeffffffff), -0x1.00080004p+62, -0x1p+0 },
+{ INT64_C(0x4002000100000008), 0x1.00080004p+62, 0x1p+3 },
+{ INT64_C(0xbffdfffefffffff7), -0x1.00080004p+62, -0x1.2p+3 },
+{ INT64_C(0x4002000100000020), 0x1.00080004p+62, 0x1p+5 },
+{ INT64_C(0xbffdfffeffffffdf), -0x1.00080004p+62, -0x1.08p+5 },
+{ INT64_C(0x4002000100000040), 0x1.00080004p+62, 0x1p+6 },
+{ INT64_C(0xbffdfffeffffffbf), -0x1.00080004p+62, -0x1.04p+6 },
+{ INT64_C(0x4002000100000080), 0x1.00080004p+62, 0x1p+7 },
+{ INT64_C(0xbffdfffeffffff7f), -0x1.00080004p+62, -0x1.02p+7 },
+{ INT64_C(0x4002000100000400), 0x1.0008000400001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffefffffbff), -0x1.0008000400001p+62, -0x1p+0 },
+{ INT64_C(0x4002000100004000), 0x1.000800040001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeffffbfff), -0x1.000800040001p+62, -0x1p+0 },
+{ INT64_C(0x4002000100008000), 0x1.000800040002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeffff7fff), -0x1.000800040002p+62, -0x1p+0 },
+{ INT64_C(0x4002000100080000), 0x1.00080004002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffefff7ffff), -0x1.00080004002p+62, -0x1p+0 },
+{ INT64_C(0x4002000100100000), 0x1.00080004004p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeffefffff), -0x1.00080004004p+62, -0x1p+0 },
+{ INT64_C(0x4002000100400000), 0x1.0008000401p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeffbfffff), -0x1.0008000401p+62, -0x1p+0 },
+{ INT64_C(0x4002000100800000), 0x1.0008000402p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeff7fffff), -0x1.0008000402p+62, -0x1p+0 },
+{ INT64_C(0x4002000101000000), 0x1.0008000404p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffefeffffff), -0x1.0008000404p+62, -0x1p+0 },
+{ INT64_C(0x4002000104000000), 0x1.000800041p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffefbffffff), -0x1.000800041p+62, -0x1p+0 },
+{ INT64_C(0x4002000110000000), 0x1.000800044p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffeefffffff), -0x1.000800044p+62, -0x1p+0 },
+{ INT64_C(0x4002000140000000), 0x1.00080005p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffebfffffff), -0x1.00080005p+62, -0x1p+0 },
+{ INT64_C(0x4002000180000000), 0x1.00080006p+62, 0x0p+0 },
+{ INT64_C(0xbffdfffe7fffffff), -0x1.00080006p+62, -0x1p+0 },
+{ INT64_C(0x4002000800000000), 0x1.0008002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7ffffffff), -0x1.0008002p+62, -0x1p+0 },
+{ INT64_C(0x4002000800000004), 0x1.0008002p+62, 0x1p+2 },
+{ INT64_C(0xbffdfff7fffffffb), -0x1.0008002p+62, -0x1.4p+2 },
+{ INT64_C(0x4002000800000040), 0x1.0008002p+62, 0x1p+6 },
+{ INT64_C(0xbffdfff7ffffffbf), -0x1.0008002p+62, -0x1.04p+6 },
+{ INT64_C(0x4002000800000100), 0x1.0008002p+62, 0x1p+8 },
+{ INT64_C(0xbffdfff7fffffeff), -0x1.0008002p+62, -0x1.01p+8 },
+{ INT64_C(0x4002000800000200), 0x1.0008002p+62, 0x1p+9 },
+{ INT64_C(0xbffdfff7fffffdff), -0x1.0008002000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4002000800000800), 0x1.0008002000002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7fffff7ff), -0x1.0008002000002p+62, -0x1p+0 },
+{ INT64_C(0x4002000800004000), 0x1.000800200001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7ffffbfff), -0x1.000800200001p+62, -0x1p+0 },
+{ INT64_C(0x4002000800008000), 0x1.000800200002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7ffff7fff), -0x1.000800200002p+62, -0x1p+0 },
+{ INT64_C(0x4002000800080000), 0x1.00080020002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7fff7ffff), -0x1.00080020002p+62, -0x1p+0 },
+{ INT64_C(0x4002000800400000), 0x1.0008002001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7ffbfffff), -0x1.0008002001p+62, -0x1p+0 },
+{ INT64_C(0x4002000802000000), 0x1.0008002008p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7fdffffff), -0x1.0008002008p+62, -0x1p+0 },
+{ INT64_C(0x4002000820000000), 0x1.000800208p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff7dfffffff), -0x1.000800208p+62, -0x1p+0 },
+{ INT64_C(0x4002000880000000), 0x1.00080022p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff77fffffff), -0x1.00080022p+62, -0x1p+0 },
+{ INT64_C(0x4002000900000000), 0x1.00080024p+62, 0x0p+0 },
+{ INT64_C(0xbffdfff6ffffffff), -0x1.00080024p+62, -0x1p+0 },
+{ INT64_C(0x4002008000000000), 0x1.000802p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7fffffffff), -0x1.000802p+62, -0x1p+0 },
+{ INT64_C(0x4002008000000002), 0x1.000802p+62, 0x1p+1 },
+{ INT64_C(0xbffdff7ffffffffd), -0x1.000802p+62, -0x1.8p+1 },
+{ INT64_C(0x4002008000000004), 0x1.000802p+62, 0x1p+2 },
+{ INT64_C(0xbffdff7ffffffffb), -0x1.000802p+62, -0x1.4p+2 },
+{ INT64_C(0x4002008000000040), 0x1.000802p+62, 0x1p+6 },
+{ INT64_C(0xbffdff7fffffffbf), -0x1.000802p+62, -0x1.04p+6 },
+{ INT64_C(0x4002008000000080), 0x1.000802p+62, 0x1p+7 },
+{ INT64_C(0xbffdff7fffffff7f), -0x1.000802p+62, -0x1.02p+7 },
+{ INT64_C(0x4002008000000800), 0x1.0008020000002p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7ffffff7ff), -0x1.0008020000002p+62, -0x1p+0 },
+{ INT64_C(0x4002008000002000), 0x1.0008020000008p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7fffffdfff), -0x1.0008020000008p+62, -0x1p+0 },
+{ INT64_C(0x4002008000020000), 0x1.000802000008p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7ffffdffff), -0x1.000802000008p+62, -0x1p+0 },
+{ INT64_C(0x4002008000080000), 0x1.00080200002p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7ffff7ffff), -0x1.00080200002p+62, -0x1p+0 },
+{ INT64_C(0x4002008000200000), 0x1.00080200008p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7fffdfffff), -0x1.00080200008p+62, -0x1p+0 },
+{ INT64_C(0x4002008002000000), 0x1.0008020008p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7ffdffffff), -0x1.0008020008p+62, -0x1p+0 },
+{ INT64_C(0x4002008004000000), 0x1.000802001p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7ffbffffff), -0x1.000802001p+62, -0x1p+0 },
+{ INT64_C(0x4002008010000000), 0x1.000802004p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7fefffffff), -0x1.000802004p+62, -0x1p+0 },
+{ INT64_C(0x4002008100000000), 0x1.00080204p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7effffffff), -0x1.00080204p+62, -0x1p+0 },
+{ INT64_C(0x4002008400000000), 0x1.0008021p+62, 0x0p+0 },
+{ INT64_C(0xbffdff7bffffffff), -0x1.0008021p+62, -0x1p+0 },
+{ INT64_C(0x400200c000000000), 0x1.000803p+62, 0x0p+0 },
+{ INT64_C(0xbffdff3fffffffff), -0x1.000803p+62, -0x1p+0 },
+{ INT64_C(0x4002010000000000), 0x1.000804p+62, 0x0p+0 },
+{ INT64_C(0xbffdfeffffffffff), -0x1.000804p+62, -0x1p+0 },
+{ INT64_C(0x4002010000000008), 0x1.000804p+62, 0x1p+3 },
+{ INT64_C(0xbffdfefffffffff7), -0x1.000804p+62, -0x1.2p+3 },
+{ INT64_C(0x4002010000000040), 0x1.000804p+62, 0x1p+6 },
+{ INT64_C(0xbffdfeffffffffbf), -0x1.000804p+62, -0x1.04p+6 },
+{ INT64_C(0x4002010000000100), 0x1.000804p+62, 0x1p+8 },
+{ INT64_C(0xbffdfefffffffeff), -0x1.000804p+62, -0x1.01p+8 },
+{ INT64_C(0x4002010000000800), 0x1.0008040000002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfefffffff7ff), -0x1.0008040000002p+62, -0x1p+0 },
+{ INT64_C(0x4002010000008000), 0x1.000804000002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfeffffff7fff), -0x1.000804000002p+62, -0x1p+0 },
+{ INT64_C(0x4002010000080000), 0x1.00080400002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfefffff7ffff), -0x1.00080400002p+62, -0x1p+0 },
+{ INT64_C(0x4002010000400000), 0x1.0008040001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfeffffbfffff), -0x1.0008040001p+62, -0x1p+0 },
+{ INT64_C(0x4002010000800000), 0x1.0008040002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfeffff7fffff), -0x1.0008040002p+62, -0x1p+0 },
+{ INT64_C(0x4002010002000000), 0x1.0008040008p+62, 0x0p+0 },
+{ INT64_C(0xbffdfefffdffffff), -0x1.0008040008p+62, -0x1p+0 },
+{ INT64_C(0x4002010020000000), 0x1.000804008p+62, 0x0p+0 },
+{ INT64_C(0xbffdfeffdfffffff), -0x1.000804008p+62, -0x1p+0 },
+{ INT64_C(0x4002010100000000), 0x1.00080404p+62, 0x0p+0 },
+{ INT64_C(0xbffdfefeffffffff), -0x1.00080404p+62, -0x1p+0 },
+{ INT64_C(0x4002011000000000), 0x1.0008044p+62, 0x0p+0 },
+{ INT64_C(0xbffdfeefffffffff), -0x1.0008044p+62, -0x1p+0 },
+{ INT64_C(0x4002014000000000), 0x1.000805p+62, 0x0p+0 },
+{ INT64_C(0xbffdfebfffffffff), -0x1.000805p+62, -0x1p+0 },
+{ INT64_C(0x4002040000000000), 0x1.00081p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbffffffffff), -0x1.00081p+62, -0x1p+0 },
+{ INT64_C(0x4002040000000001), 0x1.00081p+62, 0x1p+0 },
+{ INT64_C(0xbffdfbfffffffffe), -0x1.00081p+62, -0x1p+1 },
+{ INT64_C(0x4002040000000010), 0x1.00081p+62, 0x1p+4 },
+{ INT64_C(0xbffdfbffffffffef), -0x1.00081p+62, -0x1.1p+4 },
+{ INT64_C(0x4002040000000020), 0x1.00081p+62, 0x1p+5 },
+{ INT64_C(0xbffdfbffffffffdf), -0x1.00081p+62, -0x1.08p+5 },
+{ INT64_C(0x4002040000000200), 0x1.00081p+62, 0x1p+9 },
+{ INT64_C(0xbffdfbfffffffdff), -0x1.0008100000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4002040000002000), 0x1.0008100000008p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbffffffdfff), -0x1.0008100000008p+62, -0x1p+0 },
+{ INT64_C(0x4002040000004000), 0x1.000810000001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbffffffbfff), -0x1.000810000001p+62, -0x1p+0 },
+{ INT64_C(0x4002040000008000), 0x1.000810000002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbffffff7fff), -0x1.000810000002p+62, -0x1p+0 },
+{ INT64_C(0x4002040000080000), 0x1.00081000002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbfffff7ffff), -0x1.00081000002p+62, -0x1p+0 },
+{ INT64_C(0x4002040000800000), 0x1.0008100002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbffff7fffff), -0x1.0008100002p+62, -0x1p+0 },
+{ INT64_C(0x4002040002000000), 0x1.0008100008p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbfffdffffff), -0x1.0008100008p+62, -0x1p+0 },
+{ INT64_C(0x4002040004000000), 0x1.000810001p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbfffbffffff), -0x1.000810001p+62, -0x1p+0 },
+{ INT64_C(0x4002040010000000), 0x1.000810004p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbffefffffff), -0x1.000810004p+62, -0x1p+0 },
+{ INT64_C(0x4002040080000000), 0x1.00081002p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbff7fffffff), -0x1.00081002p+62, -0x1p+0 },
+{ INT64_C(0x4002040200000000), 0x1.00081008p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbfdffffffff), -0x1.00081008p+62, -0x1p+0 },
+{ INT64_C(0x4002042000000000), 0x1.0008108p+62, 0x0p+0 },
+{ INT64_C(0xbffdfbdfffffffff), -0x1.0008108p+62, -0x1p+0 },
+{ INT64_C(0x4002060000000000), 0x1.000818p+62, 0x0p+0 },
+{ INT64_C(0xbffdf9ffffffffff), -0x1.000818p+62, -0x1p+0 },
+{ INT64_C(0x4002200000000000), 0x1.00088p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffffffffff), -0x1.00088p+62, -0x1p+0 },
+{ INT64_C(0x4002200000000008), 0x1.00088p+62, 0x1p+3 },
+{ INT64_C(0xbffddffffffffff7), -0x1.00088p+62, -0x1.2p+3 },
+{ INT64_C(0x4002200000000040), 0x1.00088p+62, 0x1p+6 },
+{ INT64_C(0xbffddfffffffffbf), -0x1.00088p+62, -0x1.04p+6 },
+{ INT64_C(0x4002200000000400), 0x1.0008800000001p+62, 0x0p+0 },
+{ INT64_C(0xbffddffffffffbff), -0x1.0008800000001p+62, -0x1p+0 },
+{ INT64_C(0x4002200000001000), 0x1.0008800000004p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffffffefff), -0x1.0008800000004p+62, -0x1p+0 },
+{ INT64_C(0x4002200000002000), 0x1.0008800000008p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffffffdfff), -0x1.0008800000008p+62, -0x1p+0 },
+{ INT64_C(0x4002200000008000), 0x1.000880000002p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffffff7fff), -0x1.000880000002p+62, -0x1p+0 },
+{ INT64_C(0x4002200000080000), 0x1.00088000002p+62, 0x0p+0 },
+{ INT64_C(0xbffddffffff7ffff), -0x1.00088000002p+62, -0x1p+0 },
+{ INT64_C(0x4002200000200000), 0x1.00088000008p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffffdfffff), -0x1.00088000008p+62, -0x1p+0 },
+{ INT64_C(0x4002200000800000), 0x1.0008800002p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffff7fffff), -0x1.0008800002p+62, -0x1p+0 },
+{ INT64_C(0x4002200002000000), 0x1.0008800008p+62, 0x0p+0 },
+{ INT64_C(0xbffddffffdffffff), -0x1.0008800008p+62, -0x1p+0 },
+{ INT64_C(0x4002200008000000), 0x1.000880002p+62, 0x0p+0 },
+{ INT64_C(0xbffddffff7ffffff), -0x1.000880002p+62, -0x1p+0 },
+{ INT64_C(0x4002200020000000), 0x1.000880008p+62, 0x0p+0 },
+{ INT64_C(0xbffddfffdfffffff), -0x1.000880008p+62, -0x1p+0 },
+{ INT64_C(0x4002200200000000), 0x1.00088008p+62, 0x0p+0 },
+{ INT64_C(0xbffddffdffffffff), -0x1.00088008p+62, -0x1p+0 },
+{ INT64_C(0x4002200400000000), 0x1.0008801p+62, 0x0p+0 },
+{ INT64_C(0xbffddffbffffffff), -0x1.0008801p+62, -0x1p+0 },
+{ INT64_C(0x4002202000000000), 0x1.0008808p+62, 0x0p+0 },
+{ INT64_C(0xbffddfdfffffffff), -0x1.0008808p+62, -0x1p+0 },
+{ INT64_C(0x4002208000000000), 0x1.000882p+62, 0x0p+0 },
+{ INT64_C(0xbffddf7fffffffff), -0x1.000882p+62, -0x1p+0 },
+{ INT64_C(0x4002220000000000), 0x1.000888p+62, 0x0p+0 },
+{ INT64_C(0xbffdddffffffffff), -0x1.000888p+62, -0x1p+0 },
+{ INT64_C(0x4002280000000000), 0x1.0008ap+62, 0x0p+0 },
+{ INT64_C(0xbffdd7ffffffffff), -0x1.0008ap+62, -0x1p+0 },
+{ INT64_C(0x4003000000000000), 0x1.000cp+62, 0x0p+0 },
+{ INT64_C(0xbffcffffffffffff), -0x1.000cp+62, -0x1p+0 },
+{ INT64_C(0x4003000000000008), 0x1.000cp+62, 0x1p+3 },
+{ INT64_C(0xbffcfffffffffff7), -0x1.000cp+62, -0x1.2p+3 },
+{ INT64_C(0x4003000000000020), 0x1.000cp+62, 0x1p+5 },
+{ INT64_C(0xbffcffffffffffdf), -0x1.000cp+62, -0x1.08p+5 },
+{ INT64_C(0x4003000000000040), 0x1.000cp+62, 0x1p+6 },
+{ INT64_C(0xbffcffffffffffbf), -0x1.000cp+62, -0x1.04p+6 },
+{ INT64_C(0x4003000000000400), 0x1.000c000000001p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffffffffbff), -0x1.000c000000001p+62, -0x1p+0 },
+{ INT64_C(0x4003000000001000), 0x1.000c000000004p+62, 0x0p+0 },
+{ INT64_C(0xbffcffffffffefff), -0x1.000c000000004p+62, -0x1p+0 },
+{ INT64_C(0x4003000000010000), 0x1.000c00000004p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffffffeffff), -0x1.000c00000004p+62, -0x1p+0 },
+{ INT64_C(0x4003000000020000), 0x1.000c00000008p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffffffdffff), -0x1.000c00000008p+62, -0x1p+0 },
+{ INT64_C(0x4003000000080000), 0x1.000c0000002p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffffff7ffff), -0x1.000c0000002p+62, -0x1p+0 },
+{ INT64_C(0x4003000000100000), 0x1.000c0000004p+62, 0x0p+0 },
+{ INT64_C(0xbffcffffffefffff), -0x1.000c0000004p+62, -0x1p+0 },
+{ INT64_C(0x4003000001000000), 0x1.000c000004p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffffeffffff), -0x1.000c000004p+62, -0x1p+0 },
+{ INT64_C(0x4003000004000000), 0x1.000c00001p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffffbffffff), -0x1.000c00001p+62, -0x1p+0 },
+{ INT64_C(0x4003000040000000), 0x1.000c0001p+62, 0x0p+0 },
+{ INT64_C(0xbffcffffbfffffff), -0x1.000c0001p+62, -0x1p+0 },
+{ INT64_C(0x4003000200000000), 0x1.000c0008p+62, 0x0p+0 },
+{ INT64_C(0xbffcfffdffffffff), -0x1.000c0008p+62, -0x1p+0 },
+{ INT64_C(0x4003000800000000), 0x1.000c002p+62, 0x0p+0 },
+{ INT64_C(0xbffcfff7ffffffff), -0x1.000c002p+62, -0x1p+0 },
+{ INT64_C(0x4003004000000000), 0x1.000c01p+62, 0x0p+0 },
+{ INT64_C(0xbffcffbfffffffff), -0x1.000c01p+62, -0x1p+0 },
+{ INT64_C(0x4003008000000000), 0x1.000c02p+62, 0x0p+0 },
+{ INT64_C(0xbffcff7fffffffff), -0x1.000c02p+62, -0x1p+0 },
+{ INT64_C(0x4003010000000000), 0x1.000c04p+62, 0x0p+0 },
+{ INT64_C(0xbffcfeffffffffff), -0x1.000c04p+62, -0x1p+0 },
+{ INT64_C(0x4003020000000000), 0x1.000c08p+62, 0x0p+0 },
+{ INT64_C(0xbffcfdffffffffff), -0x1.000c08p+62, -0x1p+0 },
+{ INT64_C(0x4003040000000000), 0x1.000c1p+62, 0x0p+0 },
+{ INT64_C(0xbffcfbffffffffff), -0x1.000c1p+62, -0x1p+0 },
+{ INT64_C(0x4003100000000000), 0x1.000c4p+62, 0x0p+0 },
+{ INT64_C(0xbffcefffffffffff), -0x1.000c4p+62, -0x1p+0 },
+{ INT64_C(0x4003800000000000), 0x1.000ep+62, 0x0p+0 },
+{ INT64_C(0xbffc7fffffffffff), -0x1.000ep+62, -0x1p+0 },
+{ INT64_C(0x4010000000000008), 0x1.004p+62, 0x1p+3 },
+{ INT64_C(0xbfeffffffffffff7), -0x1.004p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000000000009), 0x1.004p+62, 0x1.2p+3 },
+{ INT64_C(0xbfeffffffffffff6), -0x1.004p+62, -0x1.4p+3 },
+{ INT64_C(0x4010000000000040), 0x1.004p+62, 0x1p+6 },
+{ INT64_C(0xbfefffffffffffbf), -0x1.004p+62, -0x1.04p+6 },
+{ INT64_C(0x4010000000000044), 0x1.004p+62, 0x1.1p+6 },
+{ INT64_C(0xbfefffffffffffbb), -0x1.004p+62, -0x1.14p+6 },
+{ INT64_C(0x4010000000000060), 0x1.004p+62, 0x1.8p+6 },
+{ INT64_C(0xbfefffffffffff9f), -0x1.004p+62, -0x1.84p+6 },
+{ INT64_C(0x4010000000000400), 0x1.0040000000001p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffffffbff), -0x1.0040000000001p+62, -0x1p+0 },
+{ INT64_C(0x4010000000000402), 0x1.0040000000001p+62, 0x1p+1 },
+{ INT64_C(0xbfeffffffffffbfd), -0x1.0040000000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4010000000000408), 0x1.0040000000001p+62, 0x1p+3 },
+{ INT64_C(0xbfeffffffffffbf7), -0x1.0040000000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000000000480), 0x1.0040000000001p+62, 0x1p+7 },
+{ INT64_C(0xbfeffffffffffb7f), -0x1.0040000000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4010000000001000), 0x1.0040000000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffffefff), -0x1.0040000000004p+62, -0x1p+0 },
+{ INT64_C(0x4010000000001008), 0x1.0040000000004p+62, 0x1p+3 },
+{ INT64_C(0xbfefffffffffeff7), -0x1.0040000000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000000001010), 0x1.0040000000004p+62, 0x1p+4 },
+{ INT64_C(0xbfefffffffffefef), -0x1.0040000000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4010000000001080), 0x1.0040000000004p+62, 0x1p+7 },
+{ INT64_C(0xbfefffffffffef7f), -0x1.0040000000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4010000000001800), 0x1.0040000000006p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffffe7ff), -0x1.0040000000006p+62, -0x1p+0 },
+{ INT64_C(0x4010000000008000), 0x1.004000000002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffff7fff), -0x1.004000000002p+62, -0x1p+0 },
+{ INT64_C(0x4010000000008001), 0x1.004000000002p+62, 0x1p+0 },
+{ INT64_C(0xbfefffffffff7ffe), -0x1.004000000002p+62, -0x1p+1 },
+{ INT64_C(0x4010000000008010), 0x1.004000000002p+62, 0x1p+4 },
+{ INT64_C(0xbfefffffffff7fef), -0x1.004000000002p+62, -0x1.1p+4 },
+{ INT64_C(0x4010000000008100), 0x1.004000000002p+62, 0x1p+8 },
+{ INT64_C(0xbfefffffffff7eff), -0x1.004000000002p+62, -0x1.01p+8 },
+{ INT64_C(0x4010000000008800), 0x1.0040000000022p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffff77ff), -0x1.0040000000022p+62, -0x1p+0 },
+{ INT64_C(0x401000000000a000), 0x1.0040000000028p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffff5fff), -0x1.0040000000028p+62, -0x1p+0 },
+{ INT64_C(0x4010000000080000), 0x1.00400000002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffff7ffff), -0x1.00400000002p+62, -0x1p+0 },
+{ INT64_C(0x4010000000080004), 0x1.00400000002p+62, 0x1p+2 },
+{ INT64_C(0xbfeffffffff7fffb), -0x1.00400000002p+62, -0x1.4p+2 },
+{ INT64_C(0x4010000000080040), 0x1.00400000002p+62, 0x1p+6 },
+{ INT64_C(0xbfeffffffff7ffbf), -0x1.00400000002p+62, -0x1.04p+6 },
+{ INT64_C(0x4010000000080400), 0x1.0040000000201p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffff7fbff), -0x1.0040000000201p+62, -0x1p+0 },
+{ INT64_C(0x4010000000081000), 0x1.0040000000204p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffff7efff), -0x1.0040000000204p+62, -0x1p+0 },
+{ INT64_C(0x4010000000090000), 0x1.004000000024p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffff6ffff), -0x1.004000000024p+62, -0x1p+0 },
+{ INT64_C(0x4010000000100000), 0x1.00400000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffefffff), -0x1.00400000004p+62, -0x1p+0 },
+{ INT64_C(0x4010000000100008), 0x1.00400000004p+62, 0x1p+3 },
+{ INT64_C(0xbfefffffffeffff7), -0x1.00400000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000000100020), 0x1.00400000004p+62, 0x1p+5 },
+{ INT64_C(0xbfefffffffefffdf), -0x1.00400000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4010000000100040), 0x1.00400000004p+62, 0x1p+6 },
+{ INT64_C(0xbfefffffffefffbf), -0x1.00400000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4010000000100100), 0x1.00400000004p+62, 0x1p+8 },
+{ INT64_C(0xbfefffffffeffeff), -0x1.00400000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4010000000100800), 0x1.0040000000402p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffeff7ff), -0x1.0040000000402p+62, -0x1p+0 },
+{ INT64_C(0x4010000000104000), 0x1.004000000041p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffefbfff), -0x1.004000000041p+62, -0x1p+0 },
+{ INT64_C(0x4010000000108000), 0x1.004000000042p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffef7fff), -0x1.004000000042p+62, -0x1p+0 },
+{ INT64_C(0x4010000000180000), 0x1.00400000006p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffffe7ffff), -0x1.00400000006p+62, -0x1p+0 },
+{ INT64_C(0x4010000001000000), 0x1.0040000004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffeffffff), -0x1.0040000004p+62, -0x1p+0 },
+{ INT64_C(0x4010000001000004), 0x1.0040000004p+62, 0x1p+2 },
+{ INT64_C(0xbfeffffffefffffb), -0x1.0040000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4010000001000010), 0x1.0040000004p+62, 0x1p+4 },
+{ INT64_C(0xbfeffffffeffffef), -0x1.0040000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4010000001000080), 0x1.0040000004p+62, 0x1p+7 },
+{ INT64_C(0xbfeffffffeffff7f), -0x1.0040000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4010000001000800), 0x1.0040000004002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffefff7ff), -0x1.0040000004002p+62, -0x1p+0 },
+{ INT64_C(0x4010000001004000), 0x1.004000000401p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffeffbfff), -0x1.004000000401p+62, -0x1p+0 },
+{ INT64_C(0x4010000001008000), 0x1.004000000402p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffeff7fff), -0x1.004000000402p+62, -0x1p+0 },
+{ INT64_C(0x4010000001010000), 0x1.004000000404p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffefeffff), -0x1.004000000404p+62, -0x1p+0 },
+{ INT64_C(0x4010000001100000), 0x1.00400000044p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffeefffff), -0x1.00400000044p+62, -0x1p+0 },
+{ INT64_C(0x4010000001800000), 0x1.0040000006p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffe7fffff), -0x1.0040000006p+62, -0x1p+0 },
+{ INT64_C(0x4010000002000000), 0x1.0040000008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdffffff), -0x1.0040000008p+62, -0x1p+0 },
+{ INT64_C(0x4010000002000008), 0x1.0040000008p+62, 0x1p+3 },
+{ INT64_C(0xbfeffffffdfffff7), -0x1.0040000008p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000002000080), 0x1.0040000008p+62, 0x1p+7 },
+{ INT64_C(0xbfeffffffdffff7f), -0x1.0040000008p+62, -0x1.02p+7 },
+{ INT64_C(0x4010000002000400), 0x1.0040000008001p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdfffbff), -0x1.0040000008001p+62, -0x1p+0 },
+{ INT64_C(0x4010000002001000), 0x1.0040000008004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdffefff), -0x1.0040000008004p+62, -0x1p+0 },
+{ INT64_C(0x4010000002002000), 0x1.0040000008008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdffdfff), -0x1.0040000008008p+62, -0x1p+0 },
+{ INT64_C(0x4010000002010000), 0x1.004000000804p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdfeffff), -0x1.004000000804p+62, -0x1p+0 },
+{ INT64_C(0x4010000002080000), 0x1.00400000082p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdf7ffff), -0x1.00400000082p+62, -0x1p+0 },
+{ INT64_C(0x4010000002400000), 0x1.0040000009p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffdbfffff), -0x1.0040000009p+62, -0x1p+0 },
+{ INT64_C(0x4010000004000000), 0x1.004000001p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffbffffff), -0x1.004000001p+62, -0x1p+0 },
+{ INT64_C(0x4010000004000001), 0x1.004000001p+62, 0x1p+0 },
+{ INT64_C(0xbfeffffffbfffffe), -0x1.004000001p+62, -0x1p+1 },
+{ INT64_C(0x4010000004000008), 0x1.004000001p+62, 0x1p+3 },
+{ INT64_C(0xbfeffffffbfffff7), -0x1.004000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000004000020), 0x1.004000001p+62, 0x1p+5 },
+{ INT64_C(0xbfeffffffbffffdf), -0x1.004000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4010000004000080), 0x1.004000001p+62, 0x1p+7 },
+{ INT64_C(0xbfeffffffbffff7f), -0x1.004000001p+62, -0x1.02p+7 },
+{ INT64_C(0x4010000004000100), 0x1.004000001p+62, 0x1p+8 },
+{ INT64_C(0xbfeffffffbfffeff), -0x1.004000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4010000004001000), 0x1.0040000010004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffbffefff), -0x1.0040000010004p+62, -0x1p+0 },
+{ INT64_C(0x4010000004008000), 0x1.004000001002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffbff7fff), -0x1.004000001002p+62, -0x1p+0 },
+{ INT64_C(0x4010000004020000), 0x1.004000001008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffbfdffff), -0x1.004000001008p+62, -0x1p+0 },
+{ INT64_C(0x4010000004100000), 0x1.00400000104p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffbefffff), -0x1.00400000104p+62, -0x1p+0 },
+{ INT64_C(0x4010000004800000), 0x1.0040000012p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffb7fffff), -0x1.0040000012p+62, -0x1p+0 },
+{ INT64_C(0x4010000005000000), 0x1.0040000014p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffffaffffff), -0x1.0040000014p+62, -0x1p+0 },
+{ INT64_C(0x4010000040000000), 0x1.00400001p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbfffffff), -0x1.00400001p+62, -0x1p+0 },
+{ INT64_C(0x4010000040000002), 0x1.00400001p+62, 0x1p+1 },
+{ INT64_C(0xbfefffffbffffffd), -0x1.00400001p+62, -0x1.8p+1 },
+{ INT64_C(0x4010000040000020), 0x1.00400001p+62, 0x1p+5 },
+{ INT64_C(0xbfefffffbfffffdf), -0x1.00400001p+62, -0x1.08p+5 },
+{ INT64_C(0x4010000040000200), 0x1.00400001p+62, 0x1p+9 },
+{ INT64_C(0xbfefffffbffffdff), -0x1.0040000100001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4010000040000800), 0x1.0040000100002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbffff7ff), -0x1.0040000100002p+62, -0x1p+0 },
+{ INT64_C(0x4010000040001000), 0x1.0040000100004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbfffefff), -0x1.0040000100004p+62, -0x1p+0 },
+{ INT64_C(0x4010000040002000), 0x1.0040000100008p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbfffdfff), -0x1.0040000100008p+62, -0x1p+0 },
+{ INT64_C(0x4010000040008000), 0x1.004000010002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbfff7fff), -0x1.004000010002p+62, -0x1p+0 },
+{ INT64_C(0x4010000040080000), 0x1.00400001002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbff7ffff), -0x1.00400001002p+62, -0x1p+0 },
+{ INT64_C(0x4010000040100000), 0x1.00400001004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbfefffff), -0x1.00400001004p+62, -0x1p+0 },
+{ INT64_C(0x4010000041000000), 0x1.0040000104p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffbeffffff), -0x1.0040000104p+62, -0x1p+0 },
+{ INT64_C(0x4010000050000000), 0x1.004000014p+62, 0x0p+0 },
+{ INT64_C(0xbfefffffafffffff), -0x1.004000014p+62, -0x1p+0 },
+{ INT64_C(0x4010000400000000), 0x1.0040001p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbffffffff), -0x1.0040001p+62, -0x1p+0 },
+{ INT64_C(0x4010000400000001), 0x1.0040001p+62, 0x1p+0 },
+{ INT64_C(0xbfeffffbfffffffe), -0x1.0040001p+62, -0x1p+1 },
+{ INT64_C(0x4010000400000010), 0x1.0040001p+62, 0x1p+4 },
+{ INT64_C(0xbfeffffbffffffef), -0x1.0040001p+62, -0x1.1p+4 },
+{ INT64_C(0x4010000400000100), 0x1.0040001p+62, 0x1p+8 },
+{ INT64_C(0xbfeffffbfffffeff), -0x1.0040001p+62, -0x1.01p+8 },
+{ INT64_C(0x4010000400000800), 0x1.0040001000002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbfffff7ff), -0x1.0040001000002p+62, -0x1p+0 },
+{ INT64_C(0x4010000400008000), 0x1.004000100002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbffff7fff), -0x1.004000100002p+62, -0x1p+0 },
+{ INT64_C(0x4010000400010000), 0x1.004000100004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbfffeffff), -0x1.004000100004p+62, -0x1p+0 },
+{ INT64_C(0x4010000400040000), 0x1.00400010001p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbfffbffff), -0x1.00400010001p+62, -0x1p+0 },
+{ INT64_C(0x4010000400200000), 0x1.00400010008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbffdfffff), -0x1.00400010008p+62, -0x1p+0 },
+{ INT64_C(0x4010000401000000), 0x1.0040001004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbfeffffff), -0x1.0040001004p+62, -0x1p+0 },
+{ INT64_C(0x4010000410000000), 0x1.004000104p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffbefffffff), -0x1.004000104p+62, -0x1p+0 },
+{ INT64_C(0x4010000500000000), 0x1.00400014p+62, 0x0p+0 },
+{ INT64_C(0xbfeffffaffffffff), -0x1.00400014p+62, -0x1p+0 },
+{ INT64_C(0x4010000800000000), 0x1.0040002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7ffffffff), -0x1.0040002p+62, -0x1p+0 },
+{ INT64_C(0x4010000800000008), 0x1.0040002p+62, 0x1p+3 },
+{ INT64_C(0xbfeffff7fffffff7), -0x1.0040002p+62, -0x1.2p+3 },
+{ INT64_C(0x4010000800000080), 0x1.0040002p+62, 0x1p+7 },
+{ INT64_C(0xbfeffff7ffffff7f), -0x1.0040002p+62, -0x1.02p+7 },
+{ INT64_C(0x4010000800000400), 0x1.0040002000001p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7fffffbff), -0x1.0040002000001p+62, -0x1p+0 },
+{ INT64_C(0x4010000800001000), 0x1.0040002000004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7ffffefff), -0x1.0040002000004p+62, -0x1p+0 },
+{ INT64_C(0x4010000800002000), 0x1.0040002000008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7ffffdfff), -0x1.0040002000008p+62, -0x1p+0 },
+{ INT64_C(0x4010000800020000), 0x1.004000200008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7fffdffff), -0x1.004000200008p+62, -0x1p+0 },
+{ INT64_C(0x4010000800100000), 0x1.00400020004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7ffefffff), -0x1.00400020004p+62, -0x1p+0 },
+{ INT64_C(0x4010000800800000), 0x1.0040002002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7ff7fffff), -0x1.0040002002p+62, -0x1p+0 },
+{ INT64_C(0x4010000808000000), 0x1.004000202p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7f7ffffff), -0x1.004000202p+62, -0x1p+0 },
+{ INT64_C(0x4010000820000000), 0x1.004000208p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff7dfffffff), -0x1.004000208p+62, -0x1p+0 },
+{ INT64_C(0x4010000a00000000), 0x1.00400028p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff5ffffffff), -0x1.00400028p+62, -0x1p+0 },
+{ INT64_C(0x4010000c00000000), 0x1.0040003p+62, 0x0p+0 },
+{ INT64_C(0xbfeffff3ffffffff), -0x1.0040003p+62, -0x1p+0 },
+{ INT64_C(0x4010002000000000), 0x1.0040008p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdfffffffff), -0x1.0040008p+62, -0x1p+0 },
+{ INT64_C(0x4010002000000001), 0x1.0040008p+62, 0x1p+0 },
+{ INT64_C(0xbfefffdffffffffe), -0x1.0040008p+62, -0x1p+1 },
+{ INT64_C(0x4010002000000010), 0x1.0040008p+62, 0x1p+4 },
+{ INT64_C(0xbfefffdfffffffef), -0x1.0040008p+62, -0x1.1p+4 },
+{ INT64_C(0x4010002000000020), 0x1.0040008p+62, 0x1p+5 },
+{ INT64_C(0xbfefffdfffffffdf), -0x1.0040008p+62, -0x1.08p+5 },
+{ INT64_C(0x4010002000000100), 0x1.0040008p+62, 0x1p+8 },
+{ INT64_C(0xbfefffdffffffeff), -0x1.0040008p+62, -0x1.01p+8 },
+{ INT64_C(0x4010002000000800), 0x1.0040008000002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdffffff7ff), -0x1.0040008000002p+62, -0x1p+0 },
+{ INT64_C(0x4010002000001000), 0x1.0040008000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdfffffefff), -0x1.0040008000004p+62, -0x1p+0 },
+{ INT64_C(0x4010002000008000), 0x1.004000800002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdfffff7fff), -0x1.004000800002p+62, -0x1p+0 },
+{ INT64_C(0x4010002000010000), 0x1.004000800004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdffffeffff), -0x1.004000800004p+62, -0x1p+0 },
+{ INT64_C(0x4010002000080000), 0x1.00400080002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdffff7ffff), -0x1.00400080002p+62, -0x1p+0 },
+{ INT64_C(0x4010002000800000), 0x1.0040008002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdfff7fffff), -0x1.0040008002p+62, -0x1p+0 },
+{ INT64_C(0x4010002004000000), 0x1.004000801p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdffbffffff), -0x1.004000801p+62, -0x1p+0 },
+{ INT64_C(0x4010002020000000), 0x1.004000808p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdfdfffffff), -0x1.004000808p+62, -0x1p+0 },
+{ INT64_C(0x4010002080000000), 0x1.00400082p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdf7fffffff), -0x1.00400082p+62, -0x1p+0 },
+{ INT64_C(0x4010002200000000), 0x1.00400088p+62, 0x0p+0 },
+{ INT64_C(0xbfefffddffffffff), -0x1.00400088p+62, -0x1p+0 },
+{ INT64_C(0x4010002400000000), 0x1.0040009p+62, 0x0p+0 },
+{ INT64_C(0xbfefffdbffffffff), -0x1.0040009p+62, -0x1p+0 },
+{ INT64_C(0x4010004000000000), 0x1.004001p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbfffffffff), -0x1.004001p+62, -0x1p+0 },
+{ INT64_C(0x4010004000000001), 0x1.004001p+62, 0x1p+0 },
+{ INT64_C(0xbfefffbffffffffe), -0x1.004001p+62, -0x1p+1 },
+{ INT64_C(0x4010004000000004), 0x1.004001p+62, 0x1p+2 },
+{ INT64_C(0xbfefffbffffffffb), -0x1.004001p+62, -0x1.4p+2 },
+{ INT64_C(0x4010004000000020), 0x1.004001p+62, 0x1p+5 },
+{ INT64_C(0xbfefffbfffffffdf), -0x1.004001p+62, -0x1.08p+5 },
+{ INT64_C(0x4010004000000080), 0x1.004001p+62, 0x1p+7 },
+{ INT64_C(0xbfefffbfffffff7f), -0x1.004001p+62, -0x1.02p+7 },
+{ INT64_C(0x4010004000000800), 0x1.0040010000002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbffffff7ff), -0x1.0040010000002p+62, -0x1p+0 },
+{ INT64_C(0x4010004000002000), 0x1.0040010000008p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbfffffdfff), -0x1.0040010000008p+62, -0x1p+0 },
+{ INT64_C(0x4010004000010000), 0x1.004001000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbffffeffff), -0x1.004001000004p+62, -0x1p+0 },
+{ INT64_C(0x4010004000040000), 0x1.00400100001p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbffffbffff), -0x1.00400100001p+62, -0x1p+0 },
+{ INT64_C(0x4010004000080000), 0x1.00400100002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbffff7ffff), -0x1.00400100002p+62, -0x1p+0 },
+{ INT64_C(0x4010004000200000), 0x1.00400100008p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbfffdfffff), -0x1.00400100008p+62, -0x1p+0 },
+{ INT64_C(0x4010004001000000), 0x1.0040010004p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbffeffffff), -0x1.0040010004p+62, -0x1p+0 },
+{ INT64_C(0x4010004008000000), 0x1.004001002p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbff7ffffff), -0x1.004001002p+62, -0x1p+0 },
+{ INT64_C(0x4010004020000000), 0x1.004001008p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbfdfffffff), -0x1.004001008p+62, -0x1p+0 },
+{ INT64_C(0x4010004200000000), 0x1.00400108p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbdffffffff), -0x1.00400108p+62, -0x1p+0 },
+{ INT64_C(0x4010004400000000), 0x1.0040011p+62, 0x0p+0 },
+{ INT64_C(0xbfefffbbffffffff), -0x1.0040011p+62, -0x1p+0 },
+{ INT64_C(0x4010005000000000), 0x1.0040014p+62, 0x0p+0 },
+{ INT64_C(0xbfefffafffffffff), -0x1.0040014p+62, -0x1p+0 },
+{ INT64_C(0x4010008000000000), 0x1.004002p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7fffffffff), -0x1.004002p+62, -0x1p+0 },
+{ INT64_C(0x4010008000000001), 0x1.004002p+62, 0x1p+0 },
+{ INT64_C(0xbfefff7ffffffffe), -0x1.004002p+62, -0x1p+1 },
+{ INT64_C(0x4010008000000002), 0x1.004002p+62, 0x1p+1 },
+{ INT64_C(0xbfefff7ffffffffd), -0x1.004002p+62, -0x1.8p+1 },
+{ INT64_C(0x4010008000000008), 0x1.004002p+62, 0x1p+3 },
+{ INT64_C(0xbfefff7ffffffff7), -0x1.004002p+62, -0x1.2p+3 },
+{ INT64_C(0x4010008000000010), 0x1.004002p+62, 0x1p+4 },
+{ INT64_C(0xbfefff7fffffffef), -0x1.004002p+62, -0x1.1p+4 },
+{ INT64_C(0x4010008000000080), 0x1.004002p+62, 0x1p+7 },
+{ INT64_C(0xbfefff7fffffff7f), -0x1.004002p+62, -0x1.02p+7 },
+{ INT64_C(0x4010008000000100), 0x1.004002p+62, 0x1p+8 },
+{ INT64_C(0xbfefff7ffffffeff), -0x1.004002p+62, -0x1.01p+8 },
+{ INT64_C(0x4010008000001000), 0x1.0040020000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7fffffefff), -0x1.0040020000004p+62, -0x1p+0 },
+{ INT64_C(0x4010008000008000), 0x1.004002000002p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7fffff7fff), -0x1.004002000002p+62, -0x1p+0 },
+{ INT64_C(0x4010008000020000), 0x1.004002000008p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7ffffdffff), -0x1.004002000008p+62, -0x1p+0 },
+{ INT64_C(0x4010008000080000), 0x1.00400200002p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7ffff7ffff), -0x1.00400200002p+62, -0x1p+0 },
+{ INT64_C(0x4010008000800000), 0x1.0040020002p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7fff7fffff), -0x1.0040020002p+62, -0x1p+0 },
+{ INT64_C(0x4010008002000000), 0x1.0040020008p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7ffdffffff), -0x1.0040020008p+62, -0x1p+0 },
+{ INT64_C(0x4010008020000000), 0x1.004002008p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7fdfffffff), -0x1.004002008p+62, -0x1p+0 },
+{ INT64_C(0x4010008040000000), 0x1.00400201p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7fbfffffff), -0x1.00400201p+62, -0x1p+0 },
+{ INT64_C(0x4010008200000000), 0x1.00400208p+62, 0x0p+0 },
+{ INT64_C(0xbfefff7dffffffff), -0x1.00400208p+62, -0x1p+0 },
+{ INT64_C(0x4010009000000000), 0x1.0040024p+62, 0x0p+0 },
+{ INT64_C(0xbfefff6fffffffff), -0x1.0040024p+62, -0x1p+0 },
+{ INT64_C(0x401000a000000000), 0x1.0040028p+62, 0x0p+0 },
+{ INT64_C(0xbfefff5fffffffff), -0x1.0040028p+62, -0x1p+0 },
+{ INT64_C(0x4010040000000000), 0x1.00401p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbffffffffff), -0x1.00401p+62, -0x1p+0 },
+{ INT64_C(0x4010040000000001), 0x1.00401p+62, 0x1p+0 },
+{ INT64_C(0xbfeffbfffffffffe), -0x1.00401p+62, -0x1p+1 },
+{ INT64_C(0x4010040000000008), 0x1.00401p+62, 0x1p+3 },
+{ INT64_C(0xbfeffbfffffffff7), -0x1.00401p+62, -0x1.2p+3 },
+{ INT64_C(0x4010040000000080), 0x1.00401p+62, 0x1p+7 },
+{ INT64_C(0xbfeffbffffffff7f), -0x1.00401p+62, -0x1.02p+7 },
+{ INT64_C(0x4010040000000100), 0x1.00401p+62, 0x1p+8 },
+{ INT64_C(0xbfeffbfffffffeff), -0x1.00401p+62, -0x1.01p+8 },
+{ INT64_C(0x4010040000001000), 0x1.0040100000004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbffffffefff), -0x1.0040100000004p+62, -0x1p+0 },
+{ INT64_C(0x4010040000002000), 0x1.0040100000008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbffffffdfff), -0x1.0040100000008p+62, -0x1p+0 },
+{ INT64_C(0x4010040000020000), 0x1.004010000008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbfffffdffff), -0x1.004010000008p+62, -0x1p+0 },
+{ INT64_C(0x4010040000100000), 0x1.00401000004p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbffffefffff), -0x1.00401000004p+62, -0x1p+0 },
+{ INT64_C(0x4010040000800000), 0x1.0040100002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbffff7fffff), -0x1.0040100002p+62, -0x1p+0 },
+{ INT64_C(0x4010040002000000), 0x1.0040100008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbfffdffffff), -0x1.0040100008p+62, -0x1p+0 },
+{ INT64_C(0x4010040020000000), 0x1.004010008p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbffdfffffff), -0x1.004010008p+62, -0x1p+0 },
+{ INT64_C(0x4010040080000000), 0x1.00401002p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbff7fffffff), -0x1.00401002p+62, -0x1p+0 },
+{ INT64_C(0x4010040400000000), 0x1.0040101p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbfbffffffff), -0x1.0040101p+62, -0x1p+0 },
+{ INT64_C(0x4010042000000000), 0x1.0040108p+62, 0x0p+0 },
+{ INT64_C(0xbfeffbdfffffffff), -0x1.0040108p+62, -0x1p+0 },
+{ INT64_C(0x4010048000000000), 0x1.004012p+62, 0x0p+0 },
+{ INT64_C(0xbfeffb7fffffffff), -0x1.004012p+62, -0x1p+0 },
+{ INT64_C(0x4010100000000000), 0x1.00404p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffffffffff), -0x1.00404p+62, -0x1p+0 },
+{ INT64_C(0x4010100000000008), 0x1.00404p+62, 0x1p+3 },
+{ INT64_C(0xbfefeffffffffff7), -0x1.00404p+62, -0x1.2p+3 },
+{ INT64_C(0x4010100000000020), 0x1.00404p+62, 0x1p+5 },
+{ INT64_C(0xbfefefffffffffdf), -0x1.00404p+62, -0x1.08p+5 },
+{ INT64_C(0x4010100000000100), 0x1.00404p+62, 0x1p+8 },
+{ INT64_C(0xbfefeffffffffeff), -0x1.00404p+62, -0x1.01p+8 },
+{ INT64_C(0x4010100000001000), 0x1.0040400000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffffffefff), -0x1.0040400000004p+62, -0x1p+0 },
+{ INT64_C(0x4010100000004000), 0x1.004040000001p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffffffbfff), -0x1.004040000001p+62, -0x1p+0 },
+{ INT64_C(0x4010100000008000), 0x1.004040000002p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffffff7fff), -0x1.004040000002p+62, -0x1p+0 },
+{ INT64_C(0x4010100000010000), 0x1.004040000004p+62, 0x0p+0 },
+{ INT64_C(0xbfefeffffffeffff), -0x1.004040000004p+62, -0x1p+0 },
+{ INT64_C(0x4010100000040000), 0x1.00404000001p+62, 0x0p+0 },
+{ INT64_C(0xbfefeffffffbffff), -0x1.00404000001p+62, -0x1p+0 },
+{ INT64_C(0x4010100000400000), 0x1.0040400001p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffffbfffff), -0x1.0040400001p+62, -0x1p+0 },
+{ INT64_C(0x4010100000800000), 0x1.0040400002p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffff7fffff), -0x1.0040400002p+62, -0x1p+0 },
+{ INT64_C(0x4010100008000000), 0x1.004040002p+62, 0x0p+0 },
+{ INT64_C(0xbfefeffff7ffffff), -0x1.004040002p+62, -0x1p+0 },
+{ INT64_C(0x4010100010000000), 0x1.004040004p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffefffffff), -0x1.004040004p+62, -0x1p+0 },
+{ INT64_C(0x4010100020000000), 0x1.004040008p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffdfffffff), -0x1.004040008p+62, -0x1p+0 },
+{ INT64_C(0x4010100040000000), 0x1.00404001p+62, 0x0p+0 },
+{ INT64_C(0xbfefefffbfffffff), -0x1.00404001p+62, -0x1p+0 },
+{ INT64_C(0x4010100400000000), 0x1.0040401p+62, 0x0p+0 },
+{ INT64_C(0xbfefeffbffffffff), -0x1.0040401p+62, -0x1p+0 },
+{ INT64_C(0x4010101000000000), 0x1.0040404p+62, 0x0p+0 },
+{ INT64_C(0xbfefefefffffffff), -0x1.0040404p+62, -0x1p+0 },
+{ INT64_C(0x4010110000000000), 0x1.004044p+62, 0x0p+0 },
+{ INT64_C(0xbfefeeffffffffff), -0x1.004044p+62, -0x1p+0 },
+{ INT64_C(0x4010180000000000), 0x1.00406p+62, 0x0p+0 },
+{ INT64_C(0xbfefe7ffffffffff), -0x1.00406p+62, -0x1p+0 },
+{ INT64_C(0x4010800000000000), 0x1.0042p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fffffffffff), -0x1.0042p+62, -0x1p+0 },
+{ INT64_C(0x4010800000000008), 0x1.0042p+62, 0x1p+3 },
+{ INT64_C(0xbfef7ffffffffff7), -0x1.0042p+62, -0x1.2p+3 },
+{ INT64_C(0x4010800000000020), 0x1.0042p+62, 0x1p+5 },
+{ INT64_C(0xbfef7fffffffffdf), -0x1.0042p+62, -0x1.08p+5 },
+{ INT64_C(0x4010800000000100), 0x1.0042p+62, 0x1p+8 },
+{ INT64_C(0xbfef7ffffffffeff), -0x1.0042p+62, -0x1.01p+8 },
+{ INT64_C(0x4010800000000800), 0x1.0042000000002p+62, 0x0p+0 },
+{ INT64_C(0xbfef7ffffffff7ff), -0x1.0042000000002p+62, -0x1p+0 },
+{ INT64_C(0x4010800000002000), 0x1.0042000000008p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fffffffdfff), -0x1.0042000000008p+62, -0x1p+0 },
+{ INT64_C(0x4010800000004000), 0x1.004200000001p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fffffffbfff), -0x1.004200000001p+62, -0x1p+0 },
+{ INT64_C(0x4010800000040000), 0x1.00420000001p+62, 0x0p+0 },
+{ INT64_C(0xbfef7ffffffbffff), -0x1.00420000001p+62, -0x1p+0 },
+{ INT64_C(0x4010800000200000), 0x1.00420000008p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fffffdfffff), -0x1.00420000008p+62, -0x1p+0 },
+{ INT64_C(0x4010800000800000), 0x1.0042000002p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fffff7fffff), -0x1.0042000002p+62, -0x1p+0 },
+{ INT64_C(0x4010800008000000), 0x1.004200002p+62, 0x0p+0 },
+{ INT64_C(0xbfef7ffff7ffffff), -0x1.004200002p+62, -0x1p+0 },
+{ INT64_C(0x4010800040000000), 0x1.00420001p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fffbfffffff), -0x1.00420001p+62, -0x1p+0 },
+{ INT64_C(0x4010800080000000), 0x1.00420002p+62, 0x0p+0 },
+{ INT64_C(0xbfef7fff7fffffff), -0x1.00420002p+62, -0x1p+0 },
+{ INT64_C(0x4010800400000000), 0x1.0042001p+62, 0x0p+0 },
+{ INT64_C(0xbfef7ffbffffffff), -0x1.0042001p+62, -0x1p+0 },
+{ INT64_C(0x4010800800000000), 0x1.0042002p+62, 0x0p+0 },
+{ INT64_C(0xbfef7ff7ffffffff), -0x1.0042002p+62, -0x1p+0 },
+{ INT64_C(0x4010808000000000), 0x1.004202p+62, 0x0p+0 },
+{ INT64_C(0xbfef7f7fffffffff), -0x1.004202p+62, -0x1p+0 },
+{ INT64_C(0x4010880000000000), 0x1.00422p+62, 0x0p+0 },
+{ INT64_C(0xbfef77ffffffffff), -0x1.00422p+62, -0x1p+0 },
+{ INT64_C(0x4018000000000000), 0x1.006p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ffffffffffff), -0x1.006p+62, -0x1p+0 },
+{ INT64_C(0x4018000000000002), 0x1.006p+62, 0x1p+1 },
+{ INT64_C(0xbfe7fffffffffffd), -0x1.006p+62, -0x1.8p+1 },
+{ INT64_C(0x4018000000000020), 0x1.006p+62, 0x1p+5 },
+{ INT64_C(0xbfe7ffffffffffdf), -0x1.006p+62, -0x1.08p+5 },
+{ INT64_C(0x4018000000000100), 0x1.006p+62, 0x1p+8 },
+{ INT64_C(0xbfe7fffffffffeff), -0x1.006p+62, -0x1.01p+8 },
+{ INT64_C(0x4018000000000400), 0x1.0060000000001p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fffffffffbff), -0x1.0060000000001p+62, -0x1p+0 },
+{ INT64_C(0x4018000000002000), 0x1.0060000000008p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ffffffffdfff), -0x1.0060000000008p+62, -0x1p+0 },
+{ INT64_C(0x4018000000004000), 0x1.006000000001p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ffffffffbfff), -0x1.006000000001p+62, -0x1p+0 },
+{ INT64_C(0x4018000000020000), 0x1.006000000008p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fffffffdffff), -0x1.006000000008p+62, -0x1p+0 },
+{ INT64_C(0x4018000000080000), 0x1.00600000002p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fffffff7ffff), -0x1.00600000002p+62, -0x1p+0 },
+{ INT64_C(0x4018000000100000), 0x1.00600000004p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ffffffefffff), -0x1.00600000004p+62, -0x1p+0 },
+{ INT64_C(0x4018000000400000), 0x1.0060000001p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ffffffbfffff), -0x1.0060000001p+62, -0x1p+0 },
+{ INT64_C(0x4018000004000000), 0x1.006000001p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fffffbffffff), -0x1.006000001p+62, -0x1p+0 },
+{ INT64_C(0x4018000040000000), 0x1.00600001p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ffffbfffffff), -0x1.00600001p+62, -0x1p+0 },
+{ INT64_C(0x4018000100000000), 0x1.00600004p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fffeffffffff), -0x1.00600004p+62, -0x1p+0 },
+{ INT64_C(0x4018000800000000), 0x1.0060002p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fff7ffffffff), -0x1.0060002p+62, -0x1p+0 },
+{ INT64_C(0x4018008000000000), 0x1.006002p+62, 0x0p+0 },
+{ INT64_C(0xbfe7ff7fffffffff), -0x1.006002p+62, -0x1p+0 },
+{ INT64_C(0x4018020000000000), 0x1.006008p+62, 0x0p+0 },
+{ INT64_C(0xbfe7fdffffffffff), -0x1.006008p+62, -0x1p+0 },
+{ INT64_C(0x4018200000000000), 0x1.00608p+62, 0x0p+0 },
+{ INT64_C(0xbfe7dfffffffffff), -0x1.00608p+62, -0x1p+0 },
+{ INT64_C(0x401a000000000000), 0x1.0068p+62, 0x0p+0 },
+{ INT64_C(0xbfe5ffffffffffff), -0x1.0068p+62, -0x1p+0 },
+{ INT64_C(0x401c000000000000), 0x1.007p+62, 0x0p+0 },
+{ INT64_C(0xbfe3ffffffffffff), -0x1.007p+62, -0x1p+0 },
+{ INT64_C(0x4100000000000008), 0x1.04p+62, 0x1p+3 },
+{ INT64_C(0xbefffffffffffff7), -0x1.04p+62, -0x1.2p+3 },
+{ INT64_C(0x410000000000000a), 0x1.04p+62, 0x1.4p+3 },
+{ INT64_C(0xbefffffffffffff5), -0x1.04p+62, -0x1.6p+3 },
+{ INT64_C(0x410000000000000c), 0x1.04p+62, 0x1.8p+3 },
+{ INT64_C(0xbefffffffffffff3), -0x1.04p+62, -0x1.ap+3 },
+{ INT64_C(0x4100000000000080), 0x1.04p+62, 0x1p+7 },
+{ INT64_C(0xbeffffffffffff7f), -0x1.04p+62, -0x1.02p+7 },
+{ INT64_C(0x4100000000000088), 0x1.04p+62, 0x1.1p+7 },
+{ INT64_C(0xbeffffffffffff77), -0x1.04p+62, -0x1.12p+7 },
+{ INT64_C(0x4100000000000400), 0x1.0400000000001p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffffffbff), -0x1.0400000000001p+62, -0x1p+0 },
+{ INT64_C(0x4100000000000408), 0x1.0400000000001p+62, 0x1p+3 },
+{ INT64_C(0xbefffffffffffbf7), -0x1.0400000000001p+62, -0x1.2p+3 },
+{ INT64_C(0x4100000000000410), 0x1.0400000000001p+62, 0x1p+4 },
+{ INT64_C(0xbefffffffffffbef), -0x1.0400000000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4100000000000420), 0x1.0400000000001p+62, 0x1p+5 },
+{ INT64_C(0xbefffffffffffbdf), -0x1.0400000000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000000000600), 0x1.0400000000002p+62, -0x1p+9 },
+{ INT64_C(0xbefffffffffff9ff), -0x1.0400000000002p+62, 0x1.ffp+8 },
+{ INT64_C(0x4100000000000800), 0x1.0400000000002p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffffff7ff), -0x1.0400000000002p+62, -0x1p+0 },
+{ INT64_C(0x4100000000000802), 0x1.0400000000002p+62, 0x1p+1 },
+{ INT64_C(0xbefffffffffff7fd), -0x1.0400000000002p+62, -0x1.8p+1 },
+{ INT64_C(0x4100000000000820), 0x1.0400000000002p+62, 0x1p+5 },
+{ INT64_C(0xbefffffffffff7df), -0x1.0400000000002p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000000000a00), 0x1.0400000000002p+62, 0x1p+9 },
+{ INT64_C(0xbefffffffffff5ff), -0x1.0400000000003p+62, 0x1.ffp+8 },
+{ INT64_C(0x4100000000004000), 0x1.040000000001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffffbfff), -0x1.040000000001p+62, -0x1p+0 },
+{ INT64_C(0x4100000000004001), 0x1.040000000001p+62, 0x1p+0 },
+{ INT64_C(0xbeffffffffffbffe), -0x1.040000000001p+62, -0x1p+1 },
+{ INT64_C(0x4100000000004004), 0x1.040000000001p+62, 0x1p+2 },
+{ INT64_C(0xbeffffffffffbffb), -0x1.040000000001p+62, -0x1.4p+2 },
+{ INT64_C(0x4100000000004020), 0x1.040000000001p+62, 0x1p+5 },
+{ INT64_C(0xbeffffffffffbfdf), -0x1.040000000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000000004040), 0x1.040000000001p+62, 0x1p+6 },
+{ INT64_C(0xbeffffffffffbfbf), -0x1.040000000001p+62, -0x1.04p+6 },
+{ INT64_C(0x4100000000004100), 0x1.040000000001p+62, 0x1p+8 },
+{ INT64_C(0xbeffffffffffbeff), -0x1.040000000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4100000000005000), 0x1.0400000000014p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffffafff), -0x1.0400000000014p+62, -0x1p+0 },
+{ INT64_C(0x4100000000008000), 0x1.040000000002p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffff7fff), -0x1.040000000002p+62, -0x1p+0 },
+{ INT64_C(0x4100000000008004), 0x1.040000000002p+62, 0x1p+2 },
+{ INT64_C(0xbeffffffffff7ffb), -0x1.040000000002p+62, -0x1.4p+2 },
+{ INT64_C(0x4100000000008008), 0x1.040000000002p+62, 0x1p+3 },
+{ INT64_C(0xbeffffffffff7ff7), -0x1.040000000002p+62, -0x1.2p+3 },
+{ INT64_C(0x4100000000008080), 0x1.040000000002p+62, 0x1p+7 },
+{ INT64_C(0xbeffffffffff7f7f), -0x1.040000000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4100000000008400), 0x1.0400000000021p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffff7bff), -0x1.0400000000021p+62, -0x1p+0 },
+{ INT64_C(0x410000000000a000), 0x1.0400000000028p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffff5fff), -0x1.0400000000028p+62, -0x1p+0 },
+{ INT64_C(0x4100000000020000), 0x1.040000000008p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffffdffff), -0x1.040000000008p+62, -0x1p+0 },
+{ INT64_C(0x4100000000020002), 0x1.040000000008p+62, 0x1p+1 },
+{ INT64_C(0xbefffffffffdfffd), -0x1.040000000008p+62, -0x1.8p+1 },
+{ INT64_C(0x4100000000020004), 0x1.040000000008p+62, 0x1p+2 },
+{ INT64_C(0xbefffffffffdfffb), -0x1.040000000008p+62, -0x1.4p+2 },
+{ INT64_C(0x4100000000020010), 0x1.040000000008p+62, 0x1p+4 },
+{ INT64_C(0xbefffffffffdffef), -0x1.040000000008p+62, -0x1.1p+4 },
+{ INT64_C(0x4100000000020080), 0x1.040000000008p+62, 0x1p+7 },
+{ INT64_C(0xbefffffffffdff7f), -0x1.040000000008p+62, -0x1.02p+7 },
+{ INT64_C(0x4100000000020800), 0x1.0400000000082p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffffdf7ff), -0x1.0400000000082p+62, -0x1p+0 },
+{ INT64_C(0x4100000000028000), 0x1.04000000000ap+62, 0x0p+0 },
+{ INT64_C(0xbefffffffffd7fff), -0x1.04000000000ap+62, -0x1p+0 },
+{ INT64_C(0x4100000000080000), 0x1.04000000002p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffff7ffff), -0x1.04000000002p+62, -0x1p+0 },
+{ INT64_C(0x4100000000080002), 0x1.04000000002p+62, 0x1p+1 },
+{ INT64_C(0xbefffffffff7fffd), -0x1.04000000002p+62, -0x1.8p+1 },
+{ INT64_C(0x4100000000080020), 0x1.04000000002p+62, 0x1p+5 },
+{ INT64_C(0xbefffffffff7ffdf), -0x1.04000000002p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000000080080), 0x1.04000000002p+62, 0x1p+7 },
+{ INT64_C(0xbefffffffff7ff7f), -0x1.04000000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4100000000080100), 0x1.04000000002p+62, 0x1p+8 },
+{ INT64_C(0xbefffffffff7feff), -0x1.04000000002p+62, -0x1.01p+8 },
+{ INT64_C(0x4100000000080800), 0x1.0400000000202p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffff7f7ff), -0x1.0400000000202p+62, -0x1p+0 },
+{ INT64_C(0x4100000000081000), 0x1.0400000000204p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffff7efff), -0x1.0400000000204p+62, -0x1p+0 },
+{ INT64_C(0x4100000000090000), 0x1.040000000024p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffff6ffff), -0x1.040000000024p+62, -0x1p+0 },
+{ INT64_C(0x41000000000c0000), 0x1.04000000003p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffff3ffff), -0x1.04000000003p+62, -0x1p+0 },
+{ INT64_C(0x4100000000400000), 0x1.0400000001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffbfffff), -0x1.0400000001p+62, -0x1p+0 },
+{ INT64_C(0x4100000000400004), 0x1.0400000001p+62, 0x1p+2 },
+{ INT64_C(0xbeffffffffbffffb), -0x1.0400000001p+62, -0x1.4p+2 },
+{ INT64_C(0x4100000000400040), 0x1.0400000001p+62, 0x1p+6 },
+{ INT64_C(0xbeffffffffbfffbf), -0x1.0400000001p+62, -0x1.04p+6 },
+{ INT64_C(0x4100000000400100), 0x1.0400000001p+62, 0x1p+8 },
+{ INT64_C(0xbeffffffffbffeff), -0x1.0400000001p+62, -0x1.01p+8 },
+{ INT64_C(0x4100000000400800), 0x1.0400000001002p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffbff7ff), -0x1.0400000001002p+62, -0x1p+0 },
+{ INT64_C(0x4100000000404000), 0x1.040000000101p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffbfbfff), -0x1.040000000101p+62, -0x1p+0 },
+{ INT64_C(0x4100000000408000), 0x1.040000000102p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffbf7fff), -0x1.040000000102p+62, -0x1p+0 },
+{ INT64_C(0x4100000000410000), 0x1.040000000104p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffbeffff), -0x1.040000000104p+62, -0x1p+0 },
+{ INT64_C(0x4100000000500000), 0x1.04000000014p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffffafffff), -0x1.04000000014p+62, -0x1p+0 },
+{ INT64_C(0x4100000000600000), 0x1.04000000018p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffff9fffff), -0x1.04000000018p+62, -0x1p+0 },
+{ INT64_C(0x4100000001000000), 0x1.0400000004p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffeffffff), -0x1.0400000004p+62, -0x1p+0 },
+{ INT64_C(0x4100000001000004), 0x1.0400000004p+62, 0x1p+2 },
+{ INT64_C(0xbefffffffefffffb), -0x1.0400000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4100000001000008), 0x1.0400000004p+62, 0x1p+3 },
+{ INT64_C(0xbefffffffefffff7), -0x1.0400000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4100000001000020), 0x1.0400000004p+62, 0x1p+5 },
+{ INT64_C(0xbefffffffeffffdf), -0x1.0400000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000001000080), 0x1.0400000004p+62, 0x1p+7 },
+{ INT64_C(0xbefffffffeffff7f), -0x1.0400000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4100000001000800), 0x1.0400000004002p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffefff7ff), -0x1.0400000004002p+62, -0x1p+0 },
+{ INT64_C(0x4100000001008000), 0x1.040000000402p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffeff7fff), -0x1.040000000402p+62, -0x1p+0 },
+{ INT64_C(0x4100000001040000), 0x1.04000000041p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffefbffff), -0x1.04000000041p+62, -0x1p+0 },
+{ INT64_C(0x4100000001080000), 0x1.04000000042p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffef7ffff), -0x1.04000000042p+62, -0x1p+0 },
+{ INT64_C(0x4100000001800000), 0x1.0400000006p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffe7fffff), -0x1.0400000006p+62, -0x1p+0 },
+{ INT64_C(0x4100000004000000), 0x1.040000001p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbffffff), -0x1.040000001p+62, -0x1p+0 },
+{ INT64_C(0x4100000004000001), 0x1.040000001p+62, 0x1p+0 },
+{ INT64_C(0xbefffffffbfffffe), -0x1.040000001p+62, -0x1p+1 },
+{ INT64_C(0x4100000004000002), 0x1.040000001p+62, 0x1p+1 },
+{ INT64_C(0xbefffffffbfffffd), -0x1.040000001p+62, -0x1.8p+1 },
+{ INT64_C(0x4100000004000004), 0x1.040000001p+62, 0x1p+2 },
+{ INT64_C(0xbefffffffbfffffb), -0x1.040000001p+62, -0x1.4p+2 },
+{ INT64_C(0x4100000004000040), 0x1.040000001p+62, 0x1p+6 },
+{ INT64_C(0xbefffffffbffffbf), -0x1.040000001p+62, -0x1.04p+6 },
+{ INT64_C(0x4100000004000400), 0x1.0400000010001p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbfffbff), -0x1.0400000010001p+62, -0x1p+0 },
+{ INT64_C(0x4100000004001000), 0x1.0400000010004p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbffefff), -0x1.0400000010004p+62, -0x1p+0 },
+{ INT64_C(0x4100000004002000), 0x1.0400000010008p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbffdfff), -0x1.0400000010008p+62, -0x1p+0 },
+{ INT64_C(0x4100000004008000), 0x1.040000001002p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbff7fff), -0x1.040000001002p+62, -0x1p+0 },
+{ INT64_C(0x4100000004010000), 0x1.040000001004p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbfeffff), -0x1.040000001004p+62, -0x1p+0 },
+{ INT64_C(0x4100000004040000), 0x1.04000000101p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbfbffff), -0x1.04000000101p+62, -0x1p+0 },
+{ INT64_C(0x4100000004200000), 0x1.04000000108p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffbdfffff), -0x1.04000000108p+62, -0x1p+0 },
+{ INT64_C(0x4100000005000000), 0x1.0400000014p+62, 0x0p+0 },
+{ INT64_C(0xbefffffffaffffff), -0x1.0400000014p+62, -0x1p+0 },
+{ INT64_C(0x4100000010000000), 0x1.040000004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffefffffff), -0x1.040000004p+62, -0x1p+0 },
+{ INT64_C(0x4100000010000001), 0x1.040000004p+62, 0x1p+0 },
+{ INT64_C(0xbeffffffeffffffe), -0x1.040000004p+62, -0x1p+1 },
+{ INT64_C(0x4100000010000010), 0x1.040000004p+62, 0x1p+4 },
+{ INT64_C(0xbeffffffefffffef), -0x1.040000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4100000010000020), 0x1.040000004p+62, 0x1p+5 },
+{ INT64_C(0xbeffffffefffffdf), -0x1.040000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000010000080), 0x1.040000004p+62, 0x1p+7 },
+{ INT64_C(0xbeffffffefffff7f), -0x1.040000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4100000010000100), 0x1.040000004p+62, 0x1p+8 },
+{ INT64_C(0xbeffffffeffffeff), -0x1.040000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4100000010000400), 0x1.0400000040001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffeffffbff), -0x1.0400000040001p+62, -0x1p+0 },
+{ INT64_C(0x4100000010001000), 0x1.0400000040004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffefffefff), -0x1.0400000040004p+62, -0x1p+0 },
+{ INT64_C(0x4100000010004000), 0x1.040000004001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffefffbfff), -0x1.040000004001p+62, -0x1p+0 },
+{ INT64_C(0x4100000010010000), 0x1.040000004004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffeffeffff), -0x1.040000004004p+62, -0x1p+0 },
+{ INT64_C(0x4100000010040000), 0x1.04000000401p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffeffbffff), -0x1.04000000401p+62, -0x1p+0 },
+{ INT64_C(0x4100000010080000), 0x1.04000000402p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffeff7ffff), -0x1.04000000402p+62, -0x1p+0 },
+{ INT64_C(0x4100000010200000), 0x1.04000000408p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffefdfffff), -0x1.04000000408p+62, -0x1p+0 },
+{ INT64_C(0x4100000010400000), 0x1.0400000041p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffefbfffff), -0x1.0400000041p+62, -0x1p+0 },
+{ INT64_C(0x4100000012000000), 0x1.0400000048p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffedffffff), -0x1.0400000048p+62, -0x1p+0 },
+{ INT64_C(0x4100000014000000), 0x1.040000005p+62, 0x0p+0 },
+{ INT64_C(0xbeffffffebffffff), -0x1.040000005p+62, -0x1p+0 },
+{ INT64_C(0x4100000100000000), 0x1.04000004p+62, 0x0p+0 },
+{ INT64_C(0xbefffffeffffffff), -0x1.04000004p+62, -0x1p+0 },
+{ INT64_C(0x4100000100000001), 0x1.04000004p+62, 0x1p+0 },
+{ INT64_C(0xbefffffefffffffe), -0x1.04000004p+62, -0x1p+1 },
+{ INT64_C(0x4100000100000002), 0x1.04000004p+62, 0x1p+1 },
+{ INT64_C(0xbefffffefffffffd), -0x1.04000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4100000100000020), 0x1.04000004p+62, 0x1p+5 },
+{ INT64_C(0xbefffffeffffffdf), -0x1.04000004p+62, -0x1.08p+5 },
+{ INT64_C(0x4100000100000200), 0x1.04000004p+62, 0x1p+9 },
+{ INT64_C(0xbefffffefffffdff), -0x1.0400000400001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4100000100002000), 0x1.0400000400008p+62, 0x0p+0 },
+{ INT64_C(0xbefffffeffffdfff), -0x1.0400000400008p+62, -0x1p+0 },
+{ INT64_C(0x4100000100020000), 0x1.040000040008p+62, 0x0p+0 },
+{ INT64_C(0xbefffffefffdffff), -0x1.040000040008p+62, -0x1p+0 },
+{ INT64_C(0x4100000100100000), 0x1.04000004004p+62, 0x0p+0 },
+{ INT64_C(0xbefffffeffefffff), -0x1.04000004004p+62, -0x1p+0 },
+{ INT64_C(0x4100000100200000), 0x1.04000004008p+62, 0x0p+0 },
+{ INT64_C(0xbefffffeffdfffff), -0x1.04000004008p+62, -0x1p+0 },
+{ INT64_C(0x4100000100400000), 0x1.0400000401p+62, 0x0p+0 },
+{ INT64_C(0xbefffffeffbfffff), -0x1.0400000401p+62, -0x1p+0 },
+{ INT64_C(0x4100000104000000), 0x1.040000041p+62, 0x0p+0 },
+{ INT64_C(0xbefffffefbffffff), -0x1.040000041p+62, -0x1p+0 },
+{ INT64_C(0x4100000140000000), 0x1.04000005p+62, 0x0p+0 },
+{ INT64_C(0xbefffffebfffffff), -0x1.04000005p+62, -0x1p+0 },
+{ INT64_C(0x4100001000000000), 0x1.0400004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffefffffffff), -0x1.0400004p+62, -0x1p+0 },
+{ INT64_C(0x4100001000000008), 0x1.0400004p+62, 0x1p+3 },
+{ INT64_C(0xbeffffeffffffff7), -0x1.0400004p+62, -0x1.2p+3 },
+{ INT64_C(0x4100001000000040), 0x1.0400004p+62, 0x1p+6 },
+{ INT64_C(0xbeffffefffffffbf), -0x1.0400004p+62, -0x1.04p+6 },
+{ INT64_C(0x4100001000000400), 0x1.0400004000001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffeffffffbff), -0x1.0400004000001p+62, -0x1p+0 },
+{ INT64_C(0x4100001000002000), 0x1.0400004000008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffefffffdfff), -0x1.0400004000008p+62, -0x1p+0 },
+{ INT64_C(0x4100001000020000), 0x1.040000400008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffeffffdffff), -0x1.040000400008p+62, -0x1p+0 },
+{ INT64_C(0x4100001000080000), 0x1.04000040002p+62, 0x0p+0 },
+{ INT64_C(0xbeffffeffff7ffff), -0x1.04000040002p+62, -0x1p+0 },
+{ INT64_C(0x4100001000400000), 0x1.0400004001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffefffbfffff), -0x1.0400004001p+62, -0x1p+0 },
+{ INT64_C(0x4100001004000000), 0x1.040000401p+62, 0x0p+0 },
+{ INT64_C(0xbeffffeffbffffff), -0x1.040000401p+62, -0x1p+0 },
+{ INT64_C(0x4100001010000000), 0x1.040000404p+62, 0x0p+0 },
+{ INT64_C(0xbeffffefefffffff), -0x1.040000404p+62, -0x1p+0 },
+{ INT64_C(0x4100001080000000), 0x1.04000042p+62, 0x0p+0 },
+{ INT64_C(0xbeffffef7fffffff), -0x1.04000042p+62, -0x1p+0 },
+{ INT64_C(0x4100001200000000), 0x1.04000048p+62, 0x0p+0 },
+{ INT64_C(0xbeffffedffffffff), -0x1.04000048p+62, -0x1p+0 },
+{ INT64_C(0x4100001400000000), 0x1.0400005p+62, 0x0p+0 },
+{ INT64_C(0xbeffffebffffffff), -0x1.0400005p+62, -0x1p+0 },
+{ INT64_C(0x4100002000000000), 0x1.0400008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdfffffffff), -0x1.0400008p+62, -0x1p+0 },
+{ INT64_C(0x4100002000000001), 0x1.0400008p+62, 0x1p+0 },
+{ INT64_C(0xbeffffdffffffffe), -0x1.0400008p+62, -0x1p+1 },
+{ INT64_C(0x4100002000000008), 0x1.0400008p+62, 0x1p+3 },
+{ INT64_C(0xbeffffdffffffff7), -0x1.0400008p+62, -0x1.2p+3 },
+{ INT64_C(0x4100002000000080), 0x1.0400008p+62, 0x1p+7 },
+{ INT64_C(0xbeffffdfffffff7f), -0x1.0400008p+62, -0x1.02p+7 },
+{ INT64_C(0x4100002000000200), 0x1.0400008p+62, 0x1p+9 },
+{ INT64_C(0xbeffffdffffffdff), -0x1.0400008000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4100002000000800), 0x1.0400008000002p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdffffff7ff), -0x1.0400008000002p+62, -0x1p+0 },
+{ INT64_C(0x4100002000008000), 0x1.040000800002p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdfffff7fff), -0x1.040000800002p+62, -0x1p+0 },
+{ INT64_C(0x4100002000020000), 0x1.040000800008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdffffdffff), -0x1.040000800008p+62, -0x1p+0 },
+{ INT64_C(0x4100002000100000), 0x1.04000080004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdfffefffff), -0x1.04000080004p+62, -0x1p+0 },
+{ INT64_C(0x4100002000200000), 0x1.04000080008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdfffdfffff), -0x1.04000080008p+62, -0x1p+0 },
+{ INT64_C(0x4100002001000000), 0x1.0400008004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdffeffffff), -0x1.0400008004p+62, -0x1p+0 },
+{ INT64_C(0x4100002010000000), 0x1.040000804p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdfefffffff), -0x1.040000804p+62, -0x1p+0 },
+{ INT64_C(0x4100002040000000), 0x1.04000081p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdfbfffffff), -0x1.04000081p+62, -0x1p+0 },
+{ INT64_C(0x4100002080000000), 0x1.04000082p+62, 0x0p+0 },
+{ INT64_C(0xbeffffdf7fffffff), -0x1.04000082p+62, -0x1p+0 },
+{ INT64_C(0x4100002800000000), 0x1.040000ap+62, 0x0p+0 },
+{ INT64_C(0xbeffffd7ffffffff), -0x1.040000ap+62, -0x1p+0 },
+{ INT64_C(0x4100004000000000), 0x1.040001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbfffffffff), -0x1.040001p+62, -0x1p+0 },
+{ INT64_C(0x4100004000000004), 0x1.040001p+62, 0x1p+2 },
+{ INT64_C(0xbeffffbffffffffb), -0x1.040001p+62, -0x1.4p+2 },
+{ INT64_C(0x4100004000000008), 0x1.040001p+62, 0x1p+3 },
+{ INT64_C(0xbeffffbffffffff7), -0x1.040001p+62, -0x1.2p+3 },
+{ INT64_C(0x4100004000000020), 0x1.040001p+62, 0x1p+5 },
+{ INT64_C(0xbeffffbfffffffdf), -0x1.040001p+62, -0x1.08p+5 },
+{ INT64_C(0x4100004000000100), 0x1.040001p+62, 0x1p+8 },
+{ INT64_C(0xbeffffbffffffeff), -0x1.040001p+62, -0x1.01p+8 },
+{ INT64_C(0x4100004000000400), 0x1.0400010000001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbffffffbff), -0x1.0400010000001p+62, -0x1p+0 },
+{ INT64_C(0x4100004000001000), 0x1.0400010000004p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbfffffefff), -0x1.0400010000004p+62, -0x1p+0 },
+{ INT64_C(0x4100004000004000), 0x1.040001000001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbfffffbfff), -0x1.040001000001p+62, -0x1p+0 },
+{ INT64_C(0x4100004000020000), 0x1.040001000008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbffffdffff), -0x1.040001000008p+62, -0x1p+0 },
+{ INT64_C(0x4100004000200000), 0x1.04000100008p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbfffdfffff), -0x1.04000100008p+62, -0x1p+0 },
+{ INT64_C(0x4100004000800000), 0x1.0400010002p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbfff7fffff), -0x1.0400010002p+62, -0x1p+0 },
+{ INT64_C(0x4100004004000000), 0x1.040001001p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbffbffffff), -0x1.040001001p+62, -0x1p+0 },
+{ INT64_C(0x4100004040000000), 0x1.04000101p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbfbfffffff), -0x1.04000101p+62, -0x1p+0 },
+{ INT64_C(0x4100004200000000), 0x1.04000108p+62, 0x0p+0 },
+{ INT64_C(0xbeffffbdffffffff), -0x1.04000108p+62, -0x1p+0 },
+{ INT64_C(0x4100006000000000), 0x1.0400018p+62, 0x0p+0 },
+{ INT64_C(0xbeffff9fffffffff), -0x1.0400018p+62, -0x1p+0 },
+{ INT64_C(0x4100010000000000), 0x1.040004p+62, 0x0p+0 },
+{ INT64_C(0xbefffeffffffffff), -0x1.040004p+62, -0x1p+0 },
+{ INT64_C(0x4100010000000001), 0x1.040004p+62, 0x1p+0 },
+{ INT64_C(0xbefffefffffffffe), -0x1.040004p+62, -0x1p+1 },
+{ INT64_C(0x4100010000000004), 0x1.040004p+62, 0x1p+2 },
+{ INT64_C(0xbefffefffffffffb), -0x1.040004p+62, -0x1.4p+2 },
+{ INT64_C(0x4100010000000040), 0x1.040004p+62, 0x1p+6 },
+{ INT64_C(0xbefffeffffffffbf), -0x1.040004p+62, -0x1.04p+6 },
+{ INT64_C(0x4100010000000100), 0x1.040004p+62, 0x1p+8 },
+{ INT64_C(0xbefffefffffffeff), -0x1.040004p+62, -0x1.01p+8 },
+{ INT64_C(0x4100010000000800), 0x1.0400040000002p+62, 0x0p+0 },
+{ INT64_C(0xbefffefffffff7ff), -0x1.0400040000002p+62, -0x1p+0 },
+{ INT64_C(0x4100010000002000), 0x1.0400040000008p+62, 0x0p+0 },
+{ INT64_C(0xbefffeffffffdfff), -0x1.0400040000008p+62, -0x1p+0 },
+{ INT64_C(0x4100010000004000), 0x1.040004000001p+62, 0x0p+0 },
+{ INT64_C(0xbefffeffffffbfff), -0x1.040004000001p+62, -0x1p+0 },
+{ INT64_C(0x4100010000020000), 0x1.040004000008p+62, 0x0p+0 },
+{ INT64_C(0xbefffefffffdffff), -0x1.040004000008p+62, -0x1p+0 },
+{ INT64_C(0x4100010000080000), 0x1.04000400002p+62, 0x0p+0 },
+{ INT64_C(0xbefffefffff7ffff), -0x1.04000400002p+62, -0x1p+0 },
+{ INT64_C(0x4100010000800000), 0x1.0400040002p+62, 0x0p+0 },
+{ INT64_C(0xbefffeffff7fffff), -0x1.0400040002p+62, -0x1p+0 },
+{ INT64_C(0x4100010008000000), 0x1.040004002p+62, 0x0p+0 },
+{ INT64_C(0xbefffefff7ffffff), -0x1.040004002p+62, -0x1p+0 },
+{ INT64_C(0x4100010080000000), 0x1.04000402p+62, 0x0p+0 },
+{ INT64_C(0xbefffeff7fffffff), -0x1.04000402p+62, -0x1p+0 },
+{ INT64_C(0x4100010100000000), 0x1.04000404p+62, 0x0p+0 },
+{ INT64_C(0xbefffefeffffffff), -0x1.04000404p+62, -0x1p+0 },
+{ INT64_C(0x4100010800000000), 0x1.0400042p+62, 0x0p+0 },
+{ INT64_C(0xbefffef7ffffffff), -0x1.0400042p+62, -0x1p+0 },
+{ INT64_C(0x4100011000000000), 0x1.0400044p+62, 0x0p+0 },
+{ INT64_C(0xbefffeefffffffff), -0x1.0400044p+62, -0x1p+0 },
+{ INT64_C(0x4100080000000000), 0x1.04002p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffffffffff), -0x1.04002p+62, -0x1p+0 },
+{ INT64_C(0x4100080000000002), 0x1.04002p+62, 0x1p+1 },
+{ INT64_C(0xbefff7fffffffffd), -0x1.04002p+62, -0x1.8p+1 },
+{ INT64_C(0x4100080000000008), 0x1.04002p+62, 0x1p+3 },
+{ INT64_C(0xbefff7fffffffff7), -0x1.04002p+62, -0x1.2p+3 },
+{ INT64_C(0x4100080000000010), 0x1.04002p+62, 0x1p+4 },
+{ INT64_C(0xbefff7ffffffffef), -0x1.04002p+62, -0x1.1p+4 },
+{ INT64_C(0x4100080000000080), 0x1.04002p+62, 0x1p+7 },
+{ INT64_C(0xbefff7ffffffff7f), -0x1.04002p+62, -0x1.02p+7 },
+{ INT64_C(0x4100080000000200), 0x1.04002p+62, 0x1p+9 },
+{ INT64_C(0xbefff7fffffffdff), -0x1.0400200000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4100080000000800), 0x1.0400200000002p+62, 0x0p+0 },
+{ INT64_C(0xbefff7fffffff7ff), -0x1.0400200000002p+62, -0x1p+0 },
+{ INT64_C(0x4100080000002000), 0x1.0400200000008p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffffffdfff), -0x1.0400200000008p+62, -0x1p+0 },
+{ INT64_C(0x4100080000008000), 0x1.040020000002p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffffff7fff), -0x1.040020000002p+62, -0x1p+0 },
+{ INT64_C(0x4100080000040000), 0x1.04002000001p+62, 0x0p+0 },
+{ INT64_C(0xbefff7fffffbffff), -0x1.04002000001p+62, -0x1p+0 },
+{ INT64_C(0x4100080000200000), 0x1.04002000008p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffffdfffff), -0x1.04002000008p+62, -0x1p+0 },
+{ INT64_C(0x4100080000400000), 0x1.0400200001p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffffbfffff), -0x1.0400200001p+62, -0x1p+0 },
+{ INT64_C(0x4100080002000000), 0x1.0400200008p+62, 0x0p+0 },
+{ INT64_C(0xbefff7fffdffffff), -0x1.0400200008p+62, -0x1p+0 },
+{ INT64_C(0x4100080010000000), 0x1.040020004p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffefffffff), -0x1.040020004p+62, -0x1p+0 },
+{ INT64_C(0x4100080020000000), 0x1.040020008p+62, 0x0p+0 },
+{ INT64_C(0xbefff7ffdfffffff), -0x1.040020008p+62, -0x1p+0 },
+{ INT64_C(0x4100080100000000), 0x1.04002004p+62, 0x0p+0 },
+{ INT64_C(0xbefff7feffffffff), -0x1.04002004p+62, -0x1p+0 },
+{ INT64_C(0x4100080800000000), 0x1.0400202p+62, 0x0p+0 },
+{ INT64_C(0xbefff7f7ffffffff), -0x1.0400202p+62, -0x1p+0 },
+{ INT64_C(0x4100082000000000), 0x1.0400208p+62, 0x0p+0 },
+{ INT64_C(0xbefff7dfffffffff), -0x1.0400208p+62, -0x1p+0 },
+{ INT64_C(0x41000a0000000000), 0x1.040028p+62, 0x0p+0 },
+{ INT64_C(0xbefff5ffffffffff), -0x1.040028p+62, -0x1p+0 },
+{ INT64_C(0x4100800000000000), 0x1.0402p+62, 0x0p+0 },
+{ INT64_C(0xbeff7fffffffffff), -0x1.0402p+62, -0x1p+0 },
+{ INT64_C(0x4100800000000004), 0x1.0402p+62, 0x1p+2 },
+{ INT64_C(0xbeff7ffffffffffb), -0x1.0402p+62, -0x1.4p+2 },
+{ INT64_C(0x4100800000000020), 0x1.0402p+62, 0x1p+5 },
+{ INT64_C(0xbeff7fffffffffdf), -0x1.0402p+62, -0x1.08p+5 },
+{ INT64_C(0x4100800000000200), 0x1.0402p+62, 0x1p+9 },
+{ INT64_C(0xbeff7ffffffffdff), -0x1.0402000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4100800000002000), 0x1.0402000000008p+62, 0x0p+0 },
+{ INT64_C(0xbeff7fffffffdfff), -0x1.0402000000008p+62, -0x1p+0 },
+{ INT64_C(0x4100800000010000), 0x1.040200000004p+62, 0x0p+0 },
+{ INT64_C(0xbeff7ffffffeffff), -0x1.040200000004p+62, -0x1p+0 },
+{ INT64_C(0x4100800000080000), 0x1.04020000002p+62, 0x0p+0 },
+{ INT64_C(0xbeff7ffffff7ffff), -0x1.04020000002p+62, -0x1p+0 },
+{ INT64_C(0x4100800000200000), 0x1.04020000008p+62, 0x0p+0 },
+{ INT64_C(0xbeff7fffffdfffff), -0x1.04020000008p+62, -0x1p+0 },
+{ INT64_C(0x4100800001000000), 0x1.0402000004p+62, 0x0p+0 },
+{ INT64_C(0xbeff7ffffeffffff), -0x1.0402000004p+62, -0x1p+0 },
+{ INT64_C(0x4100800008000000), 0x1.040200002p+62, 0x0p+0 },
+{ INT64_C(0xbeff7ffff7ffffff), -0x1.040200002p+62, -0x1p+0 },
+{ INT64_C(0x4100800080000000), 0x1.04020002p+62, 0x0p+0 },
+{ INT64_C(0xbeff7fff7fffffff), -0x1.04020002p+62, -0x1p+0 },
+{ INT64_C(0x4100800400000000), 0x1.0402001p+62, 0x0p+0 },
+{ INT64_C(0xbeff7ffbffffffff), -0x1.0402001p+62, -0x1p+0 },
+{ INT64_C(0x4100801000000000), 0x1.0402004p+62, 0x0p+0 },
+{ INT64_C(0xbeff7fefffffffff), -0x1.0402004p+62, -0x1p+0 },
+{ INT64_C(0x4100808000000000), 0x1.040202p+62, 0x0p+0 },
+{ INT64_C(0xbeff7f7fffffffff), -0x1.040202p+62, -0x1p+0 },
+{ INT64_C(0x4100880000000000), 0x1.04022p+62, 0x0p+0 },
+{ INT64_C(0xbeff77ffffffffff), -0x1.04022p+62, -0x1p+0 },
+{ INT64_C(0x4101000000000000), 0x1.0404p+62, 0x0p+0 },
+{ INT64_C(0xbefeffffffffffff), -0x1.0404p+62, -0x1p+0 },
+{ INT64_C(0x4101000000000002), 0x1.0404p+62, 0x1p+1 },
+{ INT64_C(0xbefefffffffffffd), -0x1.0404p+62, -0x1.8p+1 },
+{ INT64_C(0x4101000000000010), 0x1.0404p+62, 0x1p+4 },
+{ INT64_C(0xbefeffffffffffef), -0x1.0404p+62, -0x1.1p+4 },
+{ INT64_C(0x4101000000000080), 0x1.0404p+62, 0x1p+7 },
+{ INT64_C(0xbefeffffffffff7f), -0x1.0404p+62, -0x1.02p+7 },
+{ INT64_C(0x4101000000000400), 0x1.0404000000001p+62, 0x0p+0 },
+{ INT64_C(0xbefefffffffffbff), -0x1.0404000000001p+62, -0x1p+0 },
+{ INT64_C(0x4101000000001000), 0x1.0404000000004p+62, 0x0p+0 },
+{ INT64_C(0xbefeffffffffefff), -0x1.0404000000004p+62, -0x1p+0 },
+{ INT64_C(0x4101000000008000), 0x1.040400000002p+62, 0x0p+0 },
+{ INT64_C(0xbefeffffffff7fff), -0x1.040400000002p+62, -0x1p+0 },
+{ INT64_C(0x4101000000040000), 0x1.04040000001p+62, 0x0p+0 },
+{ INT64_C(0xbefefffffffbffff), -0x1.04040000001p+62, -0x1p+0 },
+{ INT64_C(0x4101000000400000), 0x1.0404000001p+62, 0x0p+0 },
+{ INT64_C(0xbefeffffffbfffff), -0x1.0404000001p+62, -0x1p+0 },
+{ INT64_C(0x4101000001000000), 0x1.0404000004p+62, 0x0p+0 },
+{ INT64_C(0xbefefffffeffffff), -0x1.0404000004p+62, -0x1p+0 },
+{ INT64_C(0x4101000010000000), 0x1.040400004p+62, 0x0p+0 },
+{ INT64_C(0xbefeffffefffffff), -0x1.040400004p+62, -0x1p+0 },
+{ INT64_C(0x4101000040000000), 0x1.04040001p+62, 0x0p+0 },
+{ INT64_C(0xbefeffffbfffffff), -0x1.04040001p+62, -0x1p+0 },
+{ INT64_C(0x4101000100000000), 0x1.04040004p+62, 0x0p+0 },
+{ INT64_C(0xbefefffeffffffff), -0x1.04040004p+62, -0x1p+0 },
+{ INT64_C(0x4101001000000000), 0x1.0404004p+62, 0x0p+0 },
+{ INT64_C(0xbefeffefffffffff), -0x1.0404004p+62, -0x1p+0 },
+{ INT64_C(0x4101004000000000), 0x1.040401p+62, 0x0p+0 },
+{ INT64_C(0xbefeffbfffffffff), -0x1.040401p+62, -0x1p+0 },
+{ INT64_C(0x4101008000000000), 0x1.040402p+62, 0x0p+0 },
+{ INT64_C(0xbefeff7fffffffff), -0x1.040402p+62, -0x1p+0 },
+{ INT64_C(0x4101010000000000), 0x1.040404p+62, 0x0p+0 },
+{ INT64_C(0xbefefeffffffffff), -0x1.040404p+62, -0x1p+0 },
+{ INT64_C(0x4101100000000000), 0x1.04044p+62, 0x0p+0 },
+{ INT64_C(0xbefeefffffffffff), -0x1.04044p+62, -0x1p+0 },
+{ INT64_C(0x4101400000000000), 0x1.0405p+62, 0x0p+0 },
+{ INT64_C(0xbefebfffffffffff), -0x1.0405p+62, -0x1p+0 },
+{ INT64_C(0x4104000000000000), 0x1.041p+62, 0x0p+0 },
+{ INT64_C(0xbefbffffffffffff), -0x1.041p+62, -0x1p+0 },
+{ INT64_C(0x4104000000000001), 0x1.041p+62, 0x1p+0 },
+{ INT64_C(0xbefbfffffffffffe), -0x1.041p+62, -0x1p+1 },
+{ INT64_C(0x4104000000000008), 0x1.041p+62, 0x1p+3 },
+{ INT64_C(0xbefbfffffffffff7), -0x1.041p+62, -0x1.2p+3 },
+{ INT64_C(0x4104000000000010), 0x1.041p+62, 0x1p+4 },
+{ INT64_C(0xbefbffffffffffef), -0x1.041p+62, -0x1.1p+4 },
+{ INT64_C(0x4104000000000020), 0x1.041p+62, 0x1p+5 },
+{ INT64_C(0xbefbffffffffffdf), -0x1.041p+62, -0x1.08p+5 },
+{ INT64_C(0x4104000000000040), 0x1.041p+62, 0x1p+6 },
+{ INT64_C(0xbefbffffffffffbf), -0x1.041p+62, -0x1.04p+6 },
+{ INT64_C(0x4104000000000200), 0x1.041p+62, 0x1p+9 },
+{ INT64_C(0xbefbfffffffffdff), -0x1.0410000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4104000000000800), 0x1.0410000000002p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffffffff7ff), -0x1.0410000000002p+62, -0x1p+0 },
+{ INT64_C(0x4104000000001000), 0x1.0410000000004p+62, 0x0p+0 },
+{ INT64_C(0xbefbffffffffefff), -0x1.0410000000004p+62, -0x1p+0 },
+{ INT64_C(0x4104000000002000), 0x1.0410000000008p+62, 0x0p+0 },
+{ INT64_C(0xbefbffffffffdfff), -0x1.0410000000008p+62, -0x1p+0 },
+{ INT64_C(0x4104000000020000), 0x1.041000000008p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffffffdffff), -0x1.041000000008p+62, -0x1p+0 },
+{ INT64_C(0x4104000000040000), 0x1.04100000001p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffffffbffff), -0x1.04100000001p+62, -0x1p+0 },
+{ INT64_C(0x4104000000400000), 0x1.0410000001p+62, 0x0p+0 },
+{ INT64_C(0xbefbffffffbfffff), -0x1.0410000001p+62, -0x1p+0 },
+{ INT64_C(0x4104000000800000), 0x1.0410000002p+62, 0x0p+0 },
+{ INT64_C(0xbefbffffff7fffff), -0x1.0410000002p+62, -0x1p+0 },
+{ INT64_C(0x4104000004000000), 0x1.041000001p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffffbffffff), -0x1.041000001p+62, -0x1p+0 },
+{ INT64_C(0x4104000008000000), 0x1.041000002p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffff7ffffff), -0x1.041000002p+62, -0x1p+0 },
+{ INT64_C(0x4104000040000000), 0x1.04100001p+62, 0x0p+0 },
+{ INT64_C(0xbefbffffbfffffff), -0x1.04100001p+62, -0x1p+0 },
+{ INT64_C(0x4104000100000000), 0x1.04100004p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffeffffffff), -0x1.04100004p+62, -0x1p+0 },
+{ INT64_C(0x4104000400000000), 0x1.0410001p+62, 0x0p+0 },
+{ INT64_C(0xbefbfffbffffffff), -0x1.0410001p+62, -0x1p+0 },
+{ INT64_C(0x4104004000000000), 0x1.041001p+62, 0x0p+0 },
+{ INT64_C(0xbefbffbfffffffff), -0x1.041001p+62, -0x1p+0 },
+{ INT64_C(0x4104008000000000), 0x1.041002p+62, 0x0p+0 },
+{ INT64_C(0xbefbff7fffffffff), -0x1.041002p+62, -0x1p+0 },
+{ INT64_C(0x4104040000000000), 0x1.04101p+62, 0x0p+0 },
+{ INT64_C(0xbefbfbffffffffff), -0x1.04101p+62, -0x1p+0 },
+{ INT64_C(0x4104080000000000), 0x1.04102p+62, 0x0p+0 },
+{ INT64_C(0xbefbf7ffffffffff), -0x1.04102p+62, -0x1p+0 },
+{ INT64_C(0x4104200000000000), 0x1.04108p+62, 0x0p+0 },
+{ INT64_C(0xbefbdfffffffffff), -0x1.04108p+62, -0x1p+0 },
+{ INT64_C(0x4106000000000000), 0x1.0418p+62, 0x0p+0 },
+{ INT64_C(0xbef9ffffffffffff), -0x1.0418p+62, -0x1p+0 },
+{ INT64_C(0x4120000000000000), 0x1.048p+62, 0x0p+0 },
+{ INT64_C(0xbedfffffffffffff), -0x1.048p+62, -0x1p+0 },
+{ INT64_C(0x4120000000000002), 0x1.048p+62, 0x1p+1 },
+{ INT64_C(0xbedffffffffffffd), -0x1.048p+62, -0x1.8p+1 },
+{ INT64_C(0x4120000000000004), 0x1.048p+62, 0x1p+2 },
+{ INT64_C(0xbedffffffffffffb), -0x1.048p+62, -0x1.4p+2 },
+{ INT64_C(0x4120000000000008), 0x1.048p+62, 0x1p+3 },
+{ INT64_C(0xbedffffffffffff7), -0x1.048p+62, -0x1.2p+3 },
+{ INT64_C(0x4120000000000080), 0x1.048p+62, 0x1p+7 },
+{ INT64_C(0xbedfffffffffff7f), -0x1.048p+62, -0x1.02p+7 },
+{ INT64_C(0x4120000000000200), 0x1.048p+62, 0x1p+9 },
+{ INT64_C(0xbedffffffffffdff), -0x1.0480000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4120000000002000), 0x1.0480000000008p+62, 0x0p+0 },
+{ INT64_C(0xbedfffffffffdfff), -0x1.0480000000008p+62, -0x1p+0 },
+{ INT64_C(0x4120000000020000), 0x1.048000000008p+62, 0x0p+0 },
+{ INT64_C(0xbedffffffffdffff), -0x1.048000000008p+62, -0x1p+0 },
+{ INT64_C(0x4120000000200000), 0x1.04800000008p+62, 0x0p+0 },
+{ INT64_C(0xbedfffffffdfffff), -0x1.04800000008p+62, -0x1p+0 },
+{ INT64_C(0x4120000000800000), 0x1.0480000002p+62, 0x0p+0 },
+{ INT64_C(0xbedfffffff7fffff), -0x1.0480000002p+62, -0x1p+0 },
+{ INT64_C(0x4120000008000000), 0x1.048000002p+62, 0x0p+0 },
+{ INT64_C(0xbedffffff7ffffff), -0x1.048000002p+62, -0x1p+0 },
+{ INT64_C(0x4120000040000000), 0x1.04800001p+62, 0x0p+0 },
+{ INT64_C(0xbedfffffbfffffff), -0x1.04800001p+62, -0x1p+0 },
+{ INT64_C(0x4120000100000000), 0x1.04800004p+62, 0x0p+0 },
+{ INT64_C(0xbedffffeffffffff), -0x1.04800004p+62, -0x1p+0 },
+{ INT64_C(0x4120001000000000), 0x1.0480004p+62, 0x0p+0 },
+{ INT64_C(0xbedfffefffffffff), -0x1.0480004p+62, -0x1p+0 },
+{ INT64_C(0x4120008000000000), 0x1.048002p+62, 0x0p+0 },
+{ INT64_C(0xbedfff7fffffffff), -0x1.048002p+62, -0x1p+0 },
+{ INT64_C(0x4120020000000000), 0x1.048008p+62, 0x0p+0 },
+{ INT64_C(0xbedffdffffffffff), -0x1.048008p+62, -0x1p+0 },
+{ INT64_C(0x4120200000000000), 0x1.04808p+62, 0x0p+0 },
+{ INT64_C(0xbedfdfffffffffff), -0x1.04808p+62, -0x1p+0 },
+{ INT64_C(0x4121000000000000), 0x1.0484p+62, 0x0p+0 },
+{ INT64_C(0xbedeffffffffffff), -0x1.0484p+62, -0x1p+0 },
+{ INT64_C(0x4124000000000000), 0x1.049p+62, 0x0p+0 },
+{ INT64_C(0xbedbffffffffffff), -0x1.049p+62, -0x1p+0 },
+{ INT64_C(0x4128000000000000), 0x1.04ap+62, 0x0p+0 },
+{ INT64_C(0xbed7ffffffffffff), -0x1.04ap+62, -0x1p+0 },
+{ INT64_C(0x4140000000000000), 0x1.05p+62, 0x0p+0 },
+{ INT64_C(0xbebfffffffffffff), -0x1.05p+62, -0x1p+0 },
+{ INT64_C(0x4140000000000002), 0x1.05p+62, 0x1p+1 },
+{ INT64_C(0xbebffffffffffffd), -0x1.05p+62, -0x1.8p+1 },
+{ INT64_C(0x4140000000000004), 0x1.05p+62, 0x1p+2 },
+{ INT64_C(0xbebffffffffffffb), -0x1.05p+62, -0x1.4p+2 },
+{ INT64_C(0x4140000000000020), 0x1.05p+62, 0x1p+5 },
+{ INT64_C(0xbebfffffffffffdf), -0x1.05p+62, -0x1.08p+5 },
+{ INT64_C(0x4140000000000080), 0x1.05p+62, 0x1p+7 },
+{ INT64_C(0xbebfffffffffff7f), -0x1.05p+62, -0x1.02p+7 },
+{ INT64_C(0x4140000000000200), 0x1.05p+62, 0x1p+9 },
+{ INT64_C(0xbebffffffffffdff), -0x1.0500000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4140000000000800), 0x1.0500000000002p+62, 0x0p+0 },
+{ INT64_C(0xbebffffffffff7ff), -0x1.0500000000002p+62, -0x1p+0 },
+{ INT64_C(0x4140000000001000), 0x1.0500000000004p+62, 0x0p+0 },
+{ INT64_C(0xbebfffffffffefff), -0x1.0500000000004p+62, -0x1p+0 },
+{ INT64_C(0x4140000000004000), 0x1.050000000001p+62, 0x0p+0 },
+{ INT64_C(0xbebfffffffffbfff), -0x1.050000000001p+62, -0x1p+0 },
+{ INT64_C(0x4140000000040000), 0x1.05000000001p+62, 0x0p+0 },
+{ INT64_C(0xbebffffffffbffff), -0x1.05000000001p+62, -0x1p+0 },
+{ INT64_C(0x4140000000100000), 0x1.05000000004p+62, 0x0p+0 },
+{ INT64_C(0xbebfffffffefffff), -0x1.05000000004p+62, -0x1p+0 },
+{ INT64_C(0x4140000001000000), 0x1.0500000004p+62, 0x0p+0 },
+{ INT64_C(0xbebffffffeffffff), -0x1.0500000004p+62, -0x1p+0 },
+{ INT64_C(0x4140000004000000), 0x1.050000001p+62, 0x0p+0 },
+{ INT64_C(0xbebffffffbffffff), -0x1.050000001p+62, -0x1p+0 },
+{ INT64_C(0x4140000008000000), 0x1.050000002p+62, 0x0p+0 },
+{ INT64_C(0xbebffffff7ffffff), -0x1.050000002p+62, -0x1p+0 },
+{ INT64_C(0x4140000040000000), 0x1.05000001p+62, 0x0p+0 },
+{ INT64_C(0xbebfffffbfffffff), -0x1.05000001p+62, -0x1p+0 },
+{ INT64_C(0x4140000100000000), 0x1.05000004p+62, 0x0p+0 },
+{ INT64_C(0xbebffffeffffffff), -0x1.05000004p+62, -0x1p+0 },
+{ INT64_C(0x4140000400000000), 0x1.0500001p+62, 0x0p+0 },
+{ INT64_C(0xbebffffbffffffff), -0x1.0500001p+62, -0x1p+0 },
+{ INT64_C(0x4140000800000000), 0x1.0500002p+62, 0x0p+0 },
+{ INT64_C(0xbebffff7ffffffff), -0x1.0500002p+62, -0x1p+0 },
+{ INT64_C(0x4140002000000000), 0x1.0500008p+62, 0x0p+0 },
+{ INT64_C(0xbebfffdfffffffff), -0x1.0500008p+62, -0x1p+0 },
+{ INT64_C(0x4140010000000000), 0x1.050004p+62, 0x0p+0 },
+{ INT64_C(0xbebffeffffffffff), -0x1.050004p+62, -0x1p+0 },
+{ INT64_C(0x4140080000000000), 0x1.05002p+62, 0x0p+0 },
+{ INT64_C(0xbebff7ffffffffff), -0x1.05002p+62, -0x1p+0 },
+{ INT64_C(0x4140400000000000), 0x1.0501p+62, 0x0p+0 },
+{ INT64_C(0xbebfbfffffffffff), -0x1.0501p+62, -0x1p+0 },
+{ INT64_C(0x4141000000000000), 0x1.0504p+62, 0x0p+0 },
+{ INT64_C(0xbebeffffffffffff), -0x1.0504p+62, -0x1p+0 },
+{ INT64_C(0x4150000000000000), 0x1.054p+62, 0x0p+0 },
+{ INT64_C(0xbeafffffffffffff), -0x1.054p+62, -0x1p+0 },
+{ INT64_C(0x4800000000000008), 0x1.2p+62, 0x1p+3 },
+{ INT64_C(0xb7fffffffffffff7), -0x1.2p+62, -0x1.2p+3 },
+{ INT64_C(0x480000000000000c), 0x1.2p+62, 0x1.8p+3 },
+{ INT64_C(0xb7fffffffffffff3), -0x1.2p+62, -0x1.ap+3 },
+{ INT64_C(0x4800000000000080), 0x1.2p+62, 0x1p+7 },
+{ INT64_C(0xb7ffffffffffff7f), -0x1.2p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000000000081), 0x1.2p+62, 0x1.02p+7 },
+{ INT64_C(0xb7ffffffffffff7e), -0x1.2p+62, -0x1.04p+7 },
+{ INT64_C(0x4800000000000090), 0x1.2p+62, 0x1.2p+7 },
+{ INT64_C(0xb7ffffffffffff6f), -0x1.2p+62, -0x1.22p+7 },
+{ INT64_C(0x48000000000000a0), 0x1.2p+62, 0x1.4p+7 },
+{ INT64_C(0xb7ffffffffffff5f), -0x1.2p+62, -0x1.42p+7 },
+{ INT64_C(0x4800000000000200), 0x1.2p+62, 0x1p+9 },
+{ INT64_C(0xb7fffffffffffdff), -0x1.2000000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800000000000208), 0x1.2000000000001p+62, -0x1.f8p+8 },
+{ INT64_C(0xb7fffffffffffdf7), -0x1.2000000000001p+62, 0x1.f7p+8 },
+{ INT64_C(0x4800000000000240), 0x1.2000000000001p+62, -0x1.cp+8 },
+{ INT64_C(0xb7fffffffffffdbf), -0x1.2000000000001p+62, 0x1.bfp+8 },
+{ INT64_C(0x4800000000000800), 0x1.2000000000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffffff7ff), -0x1.2000000000002p+62, -0x1p+0 },
+{ INT64_C(0x4800000000000802), 0x1.2000000000002p+62, 0x1p+1 },
+{ INT64_C(0xb7fffffffffff7fd), -0x1.2000000000002p+62, -0x1.8p+1 },
+{ INT64_C(0x4800000000000808), 0x1.2000000000002p+62, 0x1p+3 },
+{ INT64_C(0xb7fffffffffff7f7), -0x1.2000000000002p+62, -0x1.2p+3 },
+{ INT64_C(0x4800000000000840), 0x1.2000000000002p+62, 0x1p+6 },
+{ INT64_C(0xb7fffffffffff7bf), -0x1.2000000000002p+62, -0x1.04p+6 },
+{ INT64_C(0x4800000000000900), 0x1.2000000000002p+62, 0x1p+8 },
+{ INT64_C(0xb7fffffffffff6ff), -0x1.2000000000002p+62, -0x1.01p+8 },
+{ INT64_C(0x4800000000000a00), 0x1.2000000000002p+62, 0x1p+9 },
+{ INT64_C(0xb7fffffffffff5ff), -0x1.2000000000003p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800000000008000), 0x1.200000000002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffff7fff), -0x1.200000000002p+62, -0x1p+0 },
+{ INT64_C(0x4800000000008008), 0x1.200000000002p+62, 0x1p+3 },
+{ INT64_C(0xb7ffffffffff7ff7), -0x1.200000000002p+62, -0x1.2p+3 },
+{ INT64_C(0x4800000000008080), 0x1.200000000002p+62, 0x1p+7 },
+{ INT64_C(0xb7ffffffffff7f7f), -0x1.200000000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000000008200), 0x1.200000000002p+62, 0x1p+9 },
+{ INT64_C(0xb7ffffffffff7dff), -0x1.2000000000021p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800000000008400), 0x1.2000000000021p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffff7bff), -0x1.2000000000021p+62, -0x1p+0 },
+{ INT64_C(0x480000000000a000), 0x1.2000000000028p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffff5fff), -0x1.2000000000028p+62, -0x1p+0 },
+{ INT64_C(0x4800000000040000), 0x1.20000000001p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffffbffff), -0x1.20000000001p+62, -0x1p+0 },
+{ INT64_C(0x4800000000040001), 0x1.20000000001p+62, 0x1p+0 },
+{ INT64_C(0xb7fffffffffbfffe), -0x1.20000000001p+62, -0x1p+1 },
+{ INT64_C(0x4800000000040010), 0x1.20000000001p+62, 0x1p+4 },
+{ INT64_C(0xb7fffffffffbffef), -0x1.20000000001p+62, -0x1.1p+4 },
+{ INT64_C(0x4800000000040020), 0x1.20000000001p+62, 0x1p+5 },
+{ INT64_C(0xb7fffffffffbffdf), -0x1.20000000001p+62, -0x1.08p+5 },
+{ INT64_C(0x4800000000040200), 0x1.20000000001p+62, 0x1p+9 },
+{ INT64_C(0xb7fffffffffbfdff), -0x1.2000000000101p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800000000040400), 0x1.2000000000101p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffffbfbff), -0x1.2000000000101p+62, -0x1p+0 },
+{ INT64_C(0x4800000000042000), 0x1.2000000000108p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffffbdfff), -0x1.2000000000108p+62, -0x1p+0 },
+{ INT64_C(0x4800000000050000), 0x1.200000000014p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffffaffff), -0x1.200000000014p+62, -0x1p+0 },
+{ INT64_C(0x4800000000100000), 0x1.20000000004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffefffff), -0x1.20000000004p+62, -0x1p+0 },
+{ INT64_C(0x4800000000100002), 0x1.20000000004p+62, 0x1p+1 },
+{ INT64_C(0xb7ffffffffeffffd), -0x1.20000000004p+62, -0x1.8p+1 },
+{ INT64_C(0x4800000000100008), 0x1.20000000004p+62, 0x1p+3 },
+{ INT64_C(0xb7ffffffffeffff7), -0x1.20000000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4800000000100080), 0x1.20000000004p+62, 0x1p+7 },
+{ INT64_C(0xb7ffffffffefff7f), -0x1.20000000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000000100100), 0x1.20000000004p+62, 0x1p+8 },
+{ INT64_C(0xb7ffffffffeffeff), -0x1.20000000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4800000000100800), 0x1.2000000000402p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffeff7ff), -0x1.2000000000402p+62, -0x1p+0 },
+{ INT64_C(0x4800000000104000), 0x1.200000000041p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffefbfff), -0x1.200000000041p+62, -0x1p+0 },
+{ INT64_C(0x4800000000120000), 0x1.200000000048p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffffedffff), -0x1.200000000048p+62, -0x1p+0 },
+{ INT64_C(0x4800000001000000), 0x1.2000000004p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffeffffff), -0x1.2000000004p+62, -0x1p+0 },
+{ INT64_C(0x4800000001000008), 0x1.2000000004p+62, 0x1p+3 },
+{ INT64_C(0xb7fffffffefffff7), -0x1.2000000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4800000001000040), 0x1.2000000004p+62, 0x1p+6 },
+{ INT64_C(0xb7fffffffeffffbf), -0x1.2000000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4800000001000100), 0x1.2000000004p+62, 0x1p+8 },
+{ INT64_C(0xb7fffffffefffeff), -0x1.2000000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4800000001000200), 0x1.2000000004p+62, 0x1p+9 },
+{ INT64_C(0xb7fffffffefffdff), -0x1.2000000004001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800000001002000), 0x1.2000000004008p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffeffdfff), -0x1.2000000004008p+62, -0x1p+0 },
+{ INT64_C(0x4800000001008000), 0x1.200000000402p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffeff7fff), -0x1.200000000402p+62, -0x1p+0 },
+{ INT64_C(0x4800000001010000), 0x1.200000000404p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffefeffff), -0x1.200000000404p+62, -0x1p+0 },
+{ INT64_C(0x4800000001020000), 0x1.200000000408p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffefdffff), -0x1.200000000408p+62, -0x1p+0 },
+{ INT64_C(0x4800000001200000), 0x1.20000000048p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffffedfffff), -0x1.20000000048p+62, -0x1p+0 },
+{ INT64_C(0x4800000010000000), 0x1.200000004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffefffffff), -0x1.200000004p+62, -0x1p+0 },
+{ INT64_C(0x4800000010000008), 0x1.200000004p+62, 0x1p+3 },
+{ INT64_C(0xb7ffffffeffffff7), -0x1.200000004p+62, -0x1.2p+3 },
+{ INT64_C(0x4800000010000080), 0x1.200000004p+62, 0x1p+7 },
+{ INT64_C(0xb7ffffffefffff7f), -0x1.200000004p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000010000200), 0x1.200000004p+62, 0x1p+9 },
+{ INT64_C(0xb7ffffffeffffdff), -0x1.2000000040001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800000010001000), 0x1.2000000040004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffefffefff), -0x1.2000000040004p+62, -0x1p+0 },
+{ INT64_C(0x4800000010002000), 0x1.2000000040008p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffefffdfff), -0x1.2000000040008p+62, -0x1p+0 },
+{ INT64_C(0x4800000010010000), 0x1.200000004004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffeffeffff), -0x1.200000004004p+62, -0x1p+0 },
+{ INT64_C(0x4800000010100000), 0x1.20000000404p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffefefffff), -0x1.20000000404p+62, -0x1p+0 },
+{ INT64_C(0x4800000011000000), 0x1.2000000044p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffeeffffff), -0x1.2000000044p+62, -0x1p+0 },
+{ INT64_C(0x4800000012000000), 0x1.2000000048p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffedffffff), -0x1.2000000048p+62, -0x1p+0 },
+{ INT64_C(0x4800000020000000), 0x1.200000008p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdfffffff), -0x1.200000008p+62, -0x1p+0 },
+{ INT64_C(0x4800000020000002), 0x1.200000008p+62, 0x1p+1 },
+{ INT64_C(0xb7ffffffdffffffd), -0x1.200000008p+62, -0x1.8p+1 },
+{ INT64_C(0x4800000020000010), 0x1.200000008p+62, 0x1p+4 },
+{ INT64_C(0xb7ffffffdfffffef), -0x1.200000008p+62, -0x1.1p+4 },
+{ INT64_C(0x4800000020000080), 0x1.200000008p+62, 0x1p+7 },
+{ INT64_C(0xb7ffffffdfffff7f), -0x1.200000008p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000020000400), 0x1.2000000080001p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdffffbff), -0x1.2000000080001p+62, -0x1p+0 },
+{ INT64_C(0x4800000020000800), 0x1.2000000080002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdffff7ff), -0x1.2000000080002p+62, -0x1p+0 },
+{ INT64_C(0x4800000020001000), 0x1.2000000080004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdfffefff), -0x1.2000000080004p+62, -0x1p+0 },
+{ INT64_C(0x4800000020008000), 0x1.200000008002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdfff7fff), -0x1.200000008002p+62, -0x1p+0 },
+{ INT64_C(0x4800000020020000), 0x1.200000008008p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdffdffff), -0x1.200000008008p+62, -0x1p+0 },
+{ INT64_C(0x4800000020040000), 0x1.20000000801p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdffbffff), -0x1.20000000801p+62, -0x1p+0 },
+{ INT64_C(0x4800000020100000), 0x1.20000000804p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdfefffff), -0x1.20000000804p+62, -0x1p+0 },
+{ INT64_C(0x4800000020400000), 0x1.2000000081p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdfbfffff), -0x1.2000000081p+62, -0x1p+0 },
+{ INT64_C(0x4800000024000000), 0x1.200000009p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffdbffffff), -0x1.200000009p+62, -0x1p+0 },
+{ INT64_C(0x4800000030000000), 0x1.20000000cp+62, 0x0p+0 },
+{ INT64_C(0xb7ffffffcfffffff), -0x1.20000000cp+62, -0x1p+0 },
+{ INT64_C(0x4800000080000000), 0x1.20000002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7fffffff), -0x1.20000002p+62, -0x1p+0 },
+{ INT64_C(0x4800000080000004), 0x1.20000002p+62, 0x1p+2 },
+{ INT64_C(0xb7ffffff7ffffffb), -0x1.20000002p+62, -0x1.4p+2 },
+{ INT64_C(0x4800000080000020), 0x1.20000002p+62, 0x1p+5 },
+{ INT64_C(0xb7ffffff7fffffdf), -0x1.20000002p+62, -0x1.08p+5 },
+{ INT64_C(0x4800000080000080), 0x1.20000002p+62, 0x1p+7 },
+{ INT64_C(0xb7ffffff7fffff7f), -0x1.20000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000080000800), 0x1.2000000200002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7ffff7ff), -0x1.2000000200002p+62, -0x1p+0 },
+{ INT64_C(0x4800000080008000), 0x1.200000020002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7fff7fff), -0x1.200000020002p+62, -0x1p+0 },
+{ INT64_C(0x4800000080010000), 0x1.200000020004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7ffeffff), -0x1.200000020004p+62, -0x1p+0 },
+{ INT64_C(0x4800000080080000), 0x1.20000002002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7ff7ffff), -0x1.20000002002p+62, -0x1p+0 },
+{ INT64_C(0x4800000080200000), 0x1.20000002008p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7fdfffff), -0x1.20000002008p+62, -0x1p+0 },
+{ INT64_C(0x4800000080800000), 0x1.2000000202p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7f7fffff), -0x1.2000000202p+62, -0x1p+0 },
+{ INT64_C(0x4800000084000000), 0x1.200000021p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff7bffffff), -0x1.200000021p+62, -0x1p+0 },
+{ INT64_C(0x4800000088000000), 0x1.200000022p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff77ffffff), -0x1.200000022p+62, -0x1p+0 },
+{ INT64_C(0x48000000c0000000), 0x1.20000003p+62, 0x0p+0 },
+{ INT64_C(0xb7ffffff3fffffff), -0x1.20000003p+62, -0x1p+0 },
+{ INT64_C(0x4800000100000000), 0x1.20000004p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffeffffffff), -0x1.20000004p+62, -0x1p+0 },
+{ INT64_C(0x4800000100000001), 0x1.20000004p+62, 0x1p+0 },
+{ INT64_C(0xb7fffffefffffffe), -0x1.20000004p+62, -0x1p+1 },
+{ INT64_C(0x4800000100000004), 0x1.20000004p+62, 0x1p+2 },
+{ INT64_C(0xb7fffffefffffffb), -0x1.20000004p+62, -0x1.4p+2 },
+{ INT64_C(0x4800000100000010), 0x1.20000004p+62, 0x1p+4 },
+{ INT64_C(0xb7fffffeffffffef), -0x1.20000004p+62, -0x1.1p+4 },
+{ INT64_C(0x4800000100000040), 0x1.20000004p+62, 0x1p+6 },
+{ INT64_C(0xb7fffffeffffffbf), -0x1.20000004p+62, -0x1.04p+6 },
+{ INT64_C(0x4800000100000100), 0x1.20000004p+62, 0x1p+8 },
+{ INT64_C(0xb7fffffefffffeff), -0x1.20000004p+62, -0x1.01p+8 },
+{ INT64_C(0x4800000100001000), 0x1.2000000400004p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffeffffefff), -0x1.2000000400004p+62, -0x1p+0 },
+{ INT64_C(0x4800000100004000), 0x1.200000040001p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffeffffbfff), -0x1.200000040001p+62, -0x1p+0 },
+{ INT64_C(0x4800000100020000), 0x1.200000040008p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffefffdffff), -0x1.200000040008p+62, -0x1p+0 },
+{ INT64_C(0x4800000100080000), 0x1.20000004002p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffefff7ffff), -0x1.20000004002p+62, -0x1p+0 },
+{ INT64_C(0x4800000100800000), 0x1.2000000402p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffeff7fffff), -0x1.2000000402p+62, -0x1p+0 },
+{ INT64_C(0x4800000101000000), 0x1.2000000404p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffefeffffff), -0x1.2000000404p+62, -0x1p+0 },
+{ INT64_C(0x4800000110000000), 0x1.200000044p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffeefffffff), -0x1.200000044p+62, -0x1p+0 },
+{ INT64_C(0x4800000120000000), 0x1.200000048p+62, 0x0p+0 },
+{ INT64_C(0xb7fffffedfffffff), -0x1.200000048p+62, -0x1p+0 },
+{ INT64_C(0x4800000800000000), 0x1.2000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7ffffffff), -0x1.2000002p+62, -0x1p+0 },
+{ INT64_C(0x4800000800000004), 0x1.2000002p+62, 0x1p+2 },
+{ INT64_C(0xb7fffff7fffffffb), -0x1.2000002p+62, -0x1.4p+2 },
+{ INT64_C(0x4800000800000010), 0x1.2000002p+62, 0x1p+4 },
+{ INT64_C(0xb7fffff7ffffffef), -0x1.2000002p+62, -0x1.1p+4 },
+{ INT64_C(0x4800000800000020), 0x1.2000002p+62, 0x1p+5 },
+{ INT64_C(0xb7fffff7ffffffdf), -0x1.2000002p+62, -0x1.08p+5 },
+{ INT64_C(0x4800000800000080), 0x1.2000002p+62, 0x1p+7 },
+{ INT64_C(0xb7fffff7ffffff7f), -0x1.2000002p+62, -0x1.02p+7 },
+{ INT64_C(0x4800000800000800), 0x1.2000002000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7fffff7ff), -0x1.2000002000002p+62, -0x1p+0 },
+{ INT64_C(0x4800000800008000), 0x1.200000200002p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7ffff7fff), -0x1.200000200002p+62, -0x1p+0 },
+{ INT64_C(0x4800000800040000), 0x1.20000020001p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7fffbffff), -0x1.20000020001p+62, -0x1p+0 },
+{ INT64_C(0x4800000800400000), 0x1.2000002001p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7ffbfffff), -0x1.2000002001p+62, -0x1p+0 },
+{ INT64_C(0x4800000802000000), 0x1.2000002008p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7fdffffff), -0x1.2000002008p+62, -0x1p+0 },
+{ INT64_C(0x4800000808000000), 0x1.200000202p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7f7ffffff), -0x1.200000202p+62, -0x1p+0 },
+{ INT64_C(0x4800000810000000), 0x1.200000204p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7efffffff), -0x1.200000204p+62, -0x1p+0 },
+{ INT64_C(0x4800000820000000), 0x1.200000208p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7dfffffff), -0x1.200000208p+62, -0x1p+0 },
+{ INT64_C(0x4800000840000000), 0x1.20000021p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff7bfffffff), -0x1.20000021p+62, -0x1p+0 },
+{ INT64_C(0x4800000c00000000), 0x1.2000003p+62, 0x0p+0 },
+{ INT64_C(0xb7fffff3ffffffff), -0x1.2000003p+62, -0x1p+0 },
+{ INT64_C(0x4800008000000000), 0x1.200002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7fffffffff), -0x1.200002p+62, -0x1p+0 },
+{ INT64_C(0x4800008000000004), 0x1.200002p+62, 0x1p+2 },
+{ INT64_C(0xb7ffff7ffffffffb), -0x1.200002p+62, -0x1.4p+2 },
+{ INT64_C(0x4800008000000040), 0x1.200002p+62, 0x1p+6 },
+{ INT64_C(0xb7ffff7fffffffbf), -0x1.200002p+62, -0x1.04p+6 },
+{ INT64_C(0x4800008000000080), 0x1.200002p+62, 0x1p+7 },
+{ INT64_C(0xb7ffff7fffffff7f), -0x1.200002p+62, -0x1.02p+7 },
+{ INT64_C(0x4800008000000800), 0x1.2000020000002p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7ffffff7ff), -0x1.2000020000002p+62, -0x1p+0 },
+{ INT64_C(0x4800008000004000), 0x1.200002000001p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7fffffbfff), -0x1.200002000001p+62, -0x1p+0 },
+{ INT64_C(0x4800008000010000), 0x1.200002000004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7ffffeffff), -0x1.200002000004p+62, -0x1p+0 },
+{ INT64_C(0x4800008000100000), 0x1.20000200004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7fffefffff), -0x1.20000200004p+62, -0x1p+0 },
+{ INT64_C(0x4800008000200000), 0x1.20000200008p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7fffdfffff), -0x1.20000200008p+62, -0x1p+0 },
+{ INT64_C(0x4800008001000000), 0x1.2000020004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7ffeffffff), -0x1.2000020004p+62, -0x1p+0 },
+{ INT64_C(0x4800008002000000), 0x1.2000020008p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7ffdffffff), -0x1.2000020008p+62, -0x1p+0 },
+{ INT64_C(0x4800008010000000), 0x1.200002004p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7fefffffff), -0x1.200002004p+62, -0x1p+0 },
+{ INT64_C(0x4800008040000000), 0x1.20000201p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7fbfffffff), -0x1.20000201p+62, -0x1p+0 },
+{ INT64_C(0x4800008200000000), 0x1.20000208p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff7dffffffff), -0x1.20000208p+62, -0x1p+0 },
+{ INT64_C(0x4800009000000000), 0x1.2000024p+62, 0x0p+0 },
+{ INT64_C(0xb7ffff6fffffffff), -0x1.2000024p+62, -0x1p+0 },
+{ INT64_C(0x4800080000000000), 0x1.20002p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffffffffff), -0x1.20002p+62, -0x1p+0 },
+{ INT64_C(0x4800080000000008), 0x1.20002p+62, 0x1p+3 },
+{ INT64_C(0xb7fff7fffffffff7), -0x1.20002p+62, -0x1.2p+3 },
+{ INT64_C(0x4800080000000020), 0x1.20002p+62, 0x1p+5 },
+{ INT64_C(0xb7fff7ffffffffdf), -0x1.20002p+62, -0x1.08p+5 },
+{ INT64_C(0x4800080000000200), 0x1.20002p+62, 0x1p+9 },
+{ INT64_C(0xb7fff7fffffffdff), -0x1.2000200000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4800080000000800), 0x1.2000200000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7fffffff7ff), -0x1.2000200000002p+62, -0x1p+0 },
+{ INT64_C(0x4800080000001000), 0x1.2000200000004p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffffffefff), -0x1.2000200000004p+62, -0x1p+0 },
+{ INT64_C(0x4800080000004000), 0x1.200020000001p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffffffbfff), -0x1.200020000001p+62, -0x1p+0 },
+{ INT64_C(0x4800080000020000), 0x1.200020000008p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7fffffdffff), -0x1.200020000008p+62, -0x1p+0 },
+{ INT64_C(0x4800080000100000), 0x1.20002000004p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffffefffff), -0x1.20002000004p+62, -0x1p+0 },
+{ INT64_C(0x4800080000400000), 0x1.2000200001p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffffbfffff), -0x1.2000200001p+62, -0x1p+0 },
+{ INT64_C(0x4800080002000000), 0x1.2000200008p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7fffdffffff), -0x1.2000200008p+62, -0x1p+0 },
+{ INT64_C(0x4800080004000000), 0x1.200020001p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7fffbffffff), -0x1.200020001p+62, -0x1p+0 },
+{ INT64_C(0x4800080020000000), 0x1.200020008p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffdfffffff), -0x1.200020008p+62, -0x1p+0 },
+{ INT64_C(0x4800080040000000), 0x1.20002001p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ffbfffffff), -0x1.20002001p+62, -0x1p+0 },
+{ INT64_C(0x4800080080000000), 0x1.20002002p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7ff7fffffff), -0x1.20002002p+62, -0x1p+0 },
+{ INT64_C(0x4800080800000000), 0x1.2000202p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7f7ffffffff), -0x1.2000202p+62, -0x1p+0 },
+{ INT64_C(0x4800082000000000), 0x1.2000208p+62, 0x0p+0 },
+{ INT64_C(0xb7fff7dfffffffff), -0x1.2000208p+62, -0x1p+0 },
+{ INT64_C(0x48000a0000000000), 0x1.200028p+62, 0x0p+0 },
+{ INT64_C(0xb7fff5ffffffffff), -0x1.200028p+62, -0x1p+0 },
+{ INT64_C(0x4800800000000000), 0x1.2002p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fffffffffff), -0x1.2002p+62, -0x1p+0 },
+{ INT64_C(0x4800800000000008), 0x1.2002p+62, 0x1p+3 },
+{ INT64_C(0xb7ff7ffffffffff7), -0x1.2002p+62, -0x1.2p+3 },
+{ INT64_C(0x4800800000000010), 0x1.2002p+62, 0x1p+4 },
+{ INT64_C(0xb7ff7fffffffffef), -0x1.2002p+62, -0x1.1p+4 },
+{ INT64_C(0x4800800000000020), 0x1.2002p+62, 0x1p+5 },
+{ INT64_C(0xb7ff7fffffffffdf), -0x1.2002p+62, -0x1.08p+5 },
+{ INT64_C(0x4800800000000100), 0x1.2002p+62, 0x1p+8 },
+{ INT64_C(0xb7ff7ffffffffeff), -0x1.2002p+62, -0x1.01p+8 },
+{ INT64_C(0x4800800000000400), 0x1.2002000000001p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7ffffffffbff), -0x1.2002000000001p+62, -0x1p+0 },
+{ INT64_C(0x4800800000001000), 0x1.2002000000004p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fffffffefff), -0x1.2002000000004p+62, -0x1p+0 },
+{ INT64_C(0x4800800000010000), 0x1.200200000004p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7ffffffeffff), -0x1.200200000004p+62, -0x1p+0 },
+{ INT64_C(0x4800800000080000), 0x1.20020000002p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7ffffff7ffff), -0x1.20020000002p+62, -0x1p+0 },
+{ INT64_C(0x4800800000200000), 0x1.20020000008p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fffffdfffff), -0x1.20020000008p+62, -0x1p+0 },
+{ INT64_C(0x4800800000400000), 0x1.2002000001p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fffffbfffff), -0x1.2002000001p+62, -0x1p+0 },
+{ INT64_C(0x4800800002000000), 0x1.2002000008p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7ffffdffffff), -0x1.2002000008p+62, -0x1p+0 },
+{ INT64_C(0x4800800010000000), 0x1.200200004p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fffefffffff), -0x1.200200004p+62, -0x1p+0 },
+{ INT64_C(0x4800800020000000), 0x1.200200008p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fffdfffffff), -0x1.200200008p+62, -0x1p+0 },
+{ INT64_C(0x4800800100000000), 0x1.20020004p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7ffeffffffff), -0x1.20020004p+62, -0x1p+0 },
+{ INT64_C(0x4800800400000000), 0x1.2002001p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7ffbffffffff), -0x1.2002001p+62, -0x1p+0 },
+{ INT64_C(0x4800804000000000), 0x1.200201p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7fbfffffffff), -0x1.200201p+62, -0x1p+0 },
+{ INT64_C(0x4800810000000000), 0x1.200204p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7effffffffff), -0x1.200204p+62, -0x1p+0 },
+{ INT64_C(0x4800820000000000), 0x1.200208p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7dffffffffff), -0x1.200208p+62, -0x1p+0 },
+{ INT64_C(0x4800840000000000), 0x1.20021p+62, 0x0p+0 },
+{ INT64_C(0xb7ff7bffffffffff), -0x1.20021p+62, -0x1p+0 },
+{ INT64_C(0x4800880000000000), 0x1.20022p+62, 0x0p+0 },
+{ INT64_C(0xb7ff77ffffffffff), -0x1.20022p+62, -0x1p+0 },
+{ INT64_C(0x4800c00000000000), 0x1.2003p+62, 0x0p+0 },
+{ INT64_C(0xb7ff3fffffffffff), -0x1.2003p+62, -0x1p+0 },
+{ INT64_C(0x4804000000000000), 0x1.201p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffffffffffff), -0x1.201p+62, -0x1p+0 },
+{ INT64_C(0x4804000000000002), 0x1.201p+62, 0x1p+1 },
+{ INT64_C(0xb7fbfffffffffffd), -0x1.201p+62, -0x1.8p+1 },
+{ INT64_C(0x4804000000000010), 0x1.201p+62, 0x1p+4 },
+{ INT64_C(0xb7fbffffffffffef), -0x1.201p+62, -0x1.1p+4 },
+{ INT64_C(0x4804000000000040), 0x1.201p+62, 0x1p+6 },
+{ INT64_C(0xb7fbffffffffffbf), -0x1.201p+62, -0x1.04p+6 },
+{ INT64_C(0x4804000000000200), 0x1.201p+62, 0x1p+9 },
+{ INT64_C(0xb7fbfffffffffdff), -0x1.2010000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4804000000000800), 0x1.2010000000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfffffffff7ff), -0x1.2010000000002p+62, -0x1p+0 },
+{ INT64_C(0x4804000000002000), 0x1.2010000000008p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffffffffdfff), -0x1.2010000000008p+62, -0x1p+0 },
+{ INT64_C(0x4804000000010000), 0x1.201000000004p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfffffffeffff), -0x1.201000000004p+62, -0x1p+0 },
+{ INT64_C(0x4804000000040000), 0x1.20100000001p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfffffffbffff), -0x1.20100000001p+62, -0x1p+0 },
+{ INT64_C(0x4804000000080000), 0x1.20100000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfffffff7ffff), -0x1.20100000002p+62, -0x1p+0 },
+{ INT64_C(0x4804000000100000), 0x1.20100000004p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffffffefffff), -0x1.20100000004p+62, -0x1p+0 },
+{ INT64_C(0x4804000000400000), 0x1.2010000001p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffffffbfffff), -0x1.2010000001p+62, -0x1p+0 },
+{ INT64_C(0x4804000000800000), 0x1.2010000002p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffffff7fffff), -0x1.2010000002p+62, -0x1p+0 },
+{ INT64_C(0x4804000002000000), 0x1.2010000008p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfffffdffffff), -0x1.2010000008p+62, -0x1p+0 },
+{ INT64_C(0x4804000020000000), 0x1.201000008p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffffdfffffff), -0x1.201000008p+62, -0x1p+0 },
+{ INT64_C(0x4804000200000000), 0x1.20100008p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfffdffffffff), -0x1.20100008p+62, -0x1p+0 },
+{ INT64_C(0x4804002000000000), 0x1.2010008p+62, 0x0p+0 },
+{ INT64_C(0xb7fbffdfffffffff), -0x1.2010008p+62, -0x1p+0 },
+{ INT64_C(0x4804008000000000), 0x1.201002p+62, 0x0p+0 },
+{ INT64_C(0xb7fbff7fffffffff), -0x1.201002p+62, -0x1p+0 },
+{ INT64_C(0x4804010000000000), 0x1.201004p+62, 0x0p+0 },
+{ INT64_C(0xb7fbfeffffffffff), -0x1.201004p+62, -0x1p+0 },
+{ INT64_C(0x4804100000000000), 0x1.20104p+62, 0x0p+0 },
+{ INT64_C(0xb7fbefffffffffff), -0x1.20104p+62, -0x1p+0 },
+{ INT64_C(0x4805000000000000), 0x1.2014p+62, 0x0p+0 },
+{ INT64_C(0xb7faffffffffffff), -0x1.2014p+62, -0x1p+0 },
+{ INT64_C(0x4810000000000000), 0x1.204p+62, 0x0p+0 },
+{ INT64_C(0xb7efffffffffffff), -0x1.204p+62, -0x1p+0 },
+{ INT64_C(0x4810000000000002), 0x1.204p+62, 0x1p+1 },
+{ INT64_C(0xb7effffffffffffd), -0x1.204p+62, -0x1.8p+1 },
+{ INT64_C(0x4810000000000020), 0x1.204p+62, 0x1p+5 },
+{ INT64_C(0xb7efffffffffffdf), -0x1.204p+62, -0x1.08p+5 },
+{ INT64_C(0x4810000000000200), 0x1.204p+62, 0x1p+9 },
+{ INT64_C(0xb7effffffffffdff), -0x1.2040000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4810000000002000), 0x1.2040000000008p+62, 0x0p+0 },
+{ INT64_C(0xb7efffffffffdfff), -0x1.2040000000008p+62, -0x1p+0 },
+{ INT64_C(0x4810000000004000), 0x1.204000000001p+62, 0x0p+0 },
+{ INT64_C(0xb7efffffffffbfff), -0x1.204000000001p+62, -0x1p+0 },
+{ INT64_C(0x4810000000020000), 0x1.204000000008p+62, 0x0p+0 },
+{ INT64_C(0xb7effffffffdffff), -0x1.204000000008p+62, -0x1p+0 },
+{ INT64_C(0x4810000000080000), 0x1.20400000002p+62, 0x0p+0 },
+{ INT64_C(0xb7effffffff7ffff), -0x1.20400000002p+62, -0x1p+0 },
+{ INT64_C(0x4810000000800000), 0x1.2040000002p+62, 0x0p+0 },
+{ INT64_C(0xb7efffffff7fffff), -0x1.2040000002p+62, -0x1p+0 },
+{ INT64_C(0x4810000008000000), 0x1.204000002p+62, 0x0p+0 },
+{ INT64_C(0xb7effffff7ffffff), -0x1.204000002p+62, -0x1p+0 },
+{ INT64_C(0x4810000020000000), 0x1.204000008p+62, 0x0p+0 },
+{ INT64_C(0xb7efffffdfffffff), -0x1.204000008p+62, -0x1p+0 },
+{ INT64_C(0x4810000040000000), 0x1.20400001p+62, 0x0p+0 },
+{ INT64_C(0xb7efffffbfffffff), -0x1.20400001p+62, -0x1p+0 },
+{ INT64_C(0x4810000080000000), 0x1.20400002p+62, 0x0p+0 },
+{ INT64_C(0xb7efffff7fffffff), -0x1.20400002p+62, -0x1p+0 },
+{ INT64_C(0x4810000100000000), 0x1.20400004p+62, 0x0p+0 },
+{ INT64_C(0xb7effffeffffffff), -0x1.20400004p+62, -0x1p+0 },
+{ INT64_C(0x4810000200000000), 0x1.20400008p+62, 0x0p+0 },
+{ INT64_C(0xb7effffdffffffff), -0x1.20400008p+62, -0x1p+0 },
+{ INT64_C(0x4810002000000000), 0x1.2040008p+62, 0x0p+0 },
+{ INT64_C(0xb7efffdfffffffff), -0x1.2040008p+62, -0x1p+0 },
+{ INT64_C(0x4810020000000000), 0x1.204008p+62, 0x0p+0 },
+{ INT64_C(0xb7effdffffffffff), -0x1.204008p+62, -0x1p+0 },
+{ INT64_C(0x4810200000000000), 0x1.20408p+62, 0x0p+0 },
+{ INT64_C(0xb7efdfffffffffff), -0x1.20408p+62, -0x1p+0 },
+{ INT64_C(0x4812000000000000), 0x1.2048p+62, 0x0p+0 },
+{ INT64_C(0xb7edffffffffffff), -0x1.2048p+62, -0x1p+0 },
+{ INT64_C(0x4818000000000000), 0x1.206p+62, 0x0p+0 },
+{ INT64_C(0xb7e7ffffffffffff), -0x1.206p+62, -0x1p+0 },
+{ INT64_C(0x4900000000000000), 0x1.24p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffffffffffff), -0x1.24p+62, -0x1p+0 },
+{ INT64_C(0x4900000000000004), 0x1.24p+62, 0x1p+2 },
+{ INT64_C(0xb6fffffffffffffb), -0x1.24p+62, -0x1.4p+2 },
+{ INT64_C(0x4900000000000020), 0x1.24p+62, 0x1p+5 },
+{ INT64_C(0xb6ffffffffffffdf), -0x1.24p+62, -0x1.08p+5 },
+{ INT64_C(0x4900000000000200), 0x1.24p+62, 0x1p+9 },
+{ INT64_C(0xb6fffffffffffdff), -0x1.2400000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x4900000000001000), 0x1.2400000000004p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffffffffefff), -0x1.2400000000004p+62, -0x1p+0 },
+{ INT64_C(0x4900000000008000), 0x1.240000000002p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffffffff7fff), -0x1.240000000002p+62, -0x1p+0 },
+{ INT64_C(0x4900000000040000), 0x1.24000000001p+62, 0x0p+0 },
+{ INT64_C(0xb6fffffffffbffff), -0x1.24000000001p+62, -0x1p+0 },
+{ INT64_C(0x4900000000200000), 0x1.24000000008p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffffffdfffff), -0x1.24000000008p+62, -0x1p+0 },
+{ INT64_C(0x4900000000800000), 0x1.2400000002p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffffff7fffff), -0x1.2400000002p+62, -0x1p+0 },
+{ INT64_C(0x4900000008000000), 0x1.240000002p+62, 0x0p+0 },
+{ INT64_C(0xb6fffffff7ffffff), -0x1.240000002p+62, -0x1p+0 },
+{ INT64_C(0x4900000040000000), 0x1.24000001p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffffbfffffff), -0x1.24000001p+62, -0x1p+0 },
+{ INT64_C(0x4900000080000000), 0x1.24000002p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffff7fffffff), -0x1.24000002p+62, -0x1p+0 },
+{ INT64_C(0x4900000400000000), 0x1.2400001p+62, 0x0p+0 },
+{ INT64_C(0xb6fffffbffffffff), -0x1.2400001p+62, -0x1p+0 },
+{ INT64_C(0x4900001000000000), 0x1.2400004p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffefffffffff), -0x1.2400004p+62, -0x1p+0 },
+{ INT64_C(0x4900004000000000), 0x1.240001p+62, 0x0p+0 },
+{ INT64_C(0xb6ffffbfffffffff), -0x1.240001p+62, -0x1p+0 },
+{ INT64_C(0x4900040000000000), 0x1.24001p+62, 0x0p+0 },
+{ INT64_C(0xb6fffbffffffffff), -0x1.24001p+62, -0x1p+0 },
+{ INT64_C(0x4900200000000000), 0x1.24008p+62, 0x0p+0 },
+{ INT64_C(0xb6ffdfffffffffff), -0x1.24008p+62, -0x1p+0 },
+{ INT64_C(0x4901000000000000), 0x1.2404p+62, 0x0p+0 },
+{ INT64_C(0xb6feffffffffffff), -0x1.2404p+62, -0x1p+0 },
+{ INT64_C(0x4910000000000000), 0x1.244p+62, 0x0p+0 },
+{ INT64_C(0xb6efffffffffffff), -0x1.244p+62, -0x1p+0 },
+{ INT64_C(0x4980000000000000), 0x1.26p+62, 0x0p+0 },
+{ INT64_C(0xb67fffffffffffff), -0x1.26p+62, -0x1p+0 },
+{ INT64_C(0x4c00000000000000), 0x1.3p+62, 0x0p+0 },
+{ INT64_C(0xb3ffffffffffffff), -0x1.3p+62, -0x1p+0 },
+{ INT64_C(0x4c00000000000008), 0x1.3p+62, 0x1p+3 },
+{ INT64_C(0xb3fffffffffffff7), -0x1.3p+62, -0x1.2p+3 },
+{ INT64_C(0x4c00000000000080), 0x1.3p+62, 0x1p+7 },
+{ INT64_C(0xb3ffffffffffff7f), -0x1.3p+62, -0x1.02p+7 },
+{ INT64_C(0x4c00000000000400), 0x1.3000000000001p+62, 0x0p+0 },
+{ INT64_C(0xb3fffffffffffbff), -0x1.3000000000001p+62, -0x1p+0 },
+{ INT64_C(0x4c00000000002000), 0x1.3000000000008p+62, 0x0p+0 },
+{ INT64_C(0xb3ffffffffffdfff), -0x1.3000000000008p+62, -0x1p+0 },
+{ INT64_C(0x4c00000000004000), 0x1.300000000001p+62, 0x0p+0 },
+{ INT64_C(0xb3ffffffffffbfff), -0x1.300000000001p+62, -0x1p+0 },
+{ INT64_C(0x4c00000000040000), 0x1.30000000001p+62, 0x0p+0 },
+{ INT64_C(0xb3fffffffffbffff), -0x1.30000000001p+62, -0x1p+0 },
+{ INT64_C(0x4c00000000400000), 0x1.3000000001p+62, 0x0p+0 },
+{ INT64_C(0xb3ffffffffbfffff), -0x1.3000000001p+62, -0x1p+0 },
+{ INT64_C(0x4c00000002000000), 0x1.3000000008p+62, 0x0p+0 },
+{ INT64_C(0xb3fffffffdffffff), -0x1.3000000008p+62, -0x1p+0 },
+{ INT64_C(0x4c00000004000000), 0x1.300000001p+62, 0x0p+0 },
+{ INT64_C(0xb3fffffffbffffff), -0x1.300000001p+62, -0x1p+0 },
+{ INT64_C(0x4c00000008000000), 0x1.300000002p+62, 0x0p+0 },
+{ INT64_C(0xb3fffffff7ffffff), -0x1.300000002p+62, -0x1p+0 },
+{ INT64_C(0x4c00000080000000), 0x1.30000002p+62, 0x0p+0 },
+{ INT64_C(0xb3ffffff7fffffff), -0x1.30000002p+62, -0x1p+0 },
+{ INT64_C(0x4c00000200000000), 0x1.30000008p+62, 0x0p+0 },
+{ INT64_C(0xb3fffffdffffffff), -0x1.30000008p+62, -0x1p+0 },
+{ INT64_C(0x4c00002000000000), 0x1.3000008p+62, 0x0p+0 },
+{ INT64_C(0xb3ffffdfffffffff), -0x1.3000008p+62, -0x1p+0 },
+{ INT64_C(0x4c00010000000000), 0x1.300004p+62, 0x0p+0 },
+{ INT64_C(0xb3fffeffffffffff), -0x1.300004p+62, -0x1p+0 },
+{ INT64_C(0x4c00040000000000), 0x1.30001p+62, 0x0p+0 },
+{ INT64_C(0xb3fffbffffffffff), -0x1.30001p+62, -0x1p+0 },
+{ INT64_C(0x4c00080000000000), 0x1.30002p+62, 0x0p+0 },
+{ INT64_C(0xb3fff7ffffffffff), -0x1.30002p+62, -0x1p+0 },
+{ INT64_C(0x4c00800000000000), 0x1.3002p+62, 0x0p+0 },
+{ INT64_C(0xb3ff7fffffffffff), -0x1.3002p+62, -0x1p+0 },
+{ INT64_C(0x4c01000000000000), 0x1.3004p+62, 0x0p+0 },
+{ INT64_C(0xb3feffffffffffff), -0x1.3004p+62, -0x1p+0 },
+{ INT64_C(0x4c04000000000000), 0x1.301p+62, 0x0p+0 },
+{ INT64_C(0xb3fbffffffffffff), -0x1.301p+62, -0x1p+0 },
+{ INT64_C(0x4c40000000000000), 0x1.31p+62, 0x0p+0 },
+{ INT64_C(0xb3bfffffffffffff), -0x1.31p+62, -0x1p+0 },
+{ INT64_C(0x4e00000000000000), 0x1.38p+62, 0x0p+0 },
+{ INT64_C(0xb1ffffffffffffff), -0x1.38p+62, -0x1p+0 },
+{ INT64_C(0x6000000000000008), 0x1.8p+62, 0x1p+3 },
+{ INT64_C(0x9ffffffffffffff7), -0x1.8p+62, -0x1.2p+3 },
+{ INT64_C(0x600000000000000a), 0x1.8p+62, 0x1.4p+3 },
+{ INT64_C(0x9ffffffffffffff5), -0x1.8p+62, -0x1.6p+3 },
+{ INT64_C(0x6000000000000080), 0x1.8p+62, 0x1p+7 },
+{ INT64_C(0x9fffffffffffff7f), -0x1.8p+62, -0x1.02p+7 },
+{ INT64_C(0x6000000000000088), 0x1.8p+62, 0x1.1p+7 },
+{ INT64_C(0x9fffffffffffff77), -0x1.8p+62, -0x1.12p+7 },
+{ INT64_C(0x60000000000000a0), 0x1.8p+62, 0x1.4p+7 },
+{ INT64_C(0x9fffffffffffff5f), -0x1.8p+62, -0x1.42p+7 },
+{ INT64_C(0x6000000000000400), 0x1.8000000000001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffffffbff), -0x1.8000000000001p+62, -0x1p+0 },
+{ INT64_C(0x6000000000000408), 0x1.8000000000001p+62, 0x1p+3 },
+{ INT64_C(0x9ffffffffffffbf7), -0x1.8000000000001p+62, -0x1.2p+3 },
+{ INT64_C(0x6000000000000420), 0x1.8000000000001p+62, 0x1p+5 },
+{ INT64_C(0x9ffffffffffffbdf), -0x1.8000000000001p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000000000480), 0x1.8000000000001p+62, 0x1p+7 },
+{ INT64_C(0x9ffffffffffffb7f), -0x1.8000000000001p+62, -0x1.02p+7 },
+{ INT64_C(0x6000000000000500), 0x1.8000000000001p+62, 0x1p+8 },
+{ INT64_C(0x9ffffffffffffaff), -0x1.8000000000001p+62, -0x1.01p+8 },
+{ INT64_C(0x6000000000004000), 0x1.800000000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffffbfff), -0x1.800000000001p+62, -0x1p+0 },
+{ INT64_C(0x6000000000004001), 0x1.800000000001p+62, 0x1p+0 },
+{ INT64_C(0x9fffffffffffbffe), -0x1.800000000001p+62, -0x1p+1 },
+{ INT64_C(0x6000000000004004), 0x1.800000000001p+62, 0x1p+2 },
+{ INT64_C(0x9fffffffffffbffb), -0x1.800000000001p+62, -0x1.4p+2 },
+{ INT64_C(0x6000000000004040), 0x1.800000000001p+62, 0x1p+6 },
+{ INT64_C(0x9fffffffffffbfbf), -0x1.800000000001p+62, -0x1.04p+6 },
+{ INT64_C(0x6000000000004080), 0x1.800000000001p+62, 0x1p+7 },
+{ INT64_C(0x9fffffffffffbf7f), -0x1.800000000001p+62, -0x1.02p+7 },
+{ INT64_C(0x6000000000004800), 0x1.8000000000012p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffffb7ff), -0x1.8000000000012p+62, -0x1p+0 },
+{ INT64_C(0x6000000000008000), 0x1.800000000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffff7fff), -0x1.800000000002p+62, -0x1p+0 },
+{ INT64_C(0x6000000000008008), 0x1.800000000002p+62, 0x1p+3 },
+{ INT64_C(0x9fffffffffff7ff7), -0x1.800000000002p+62, -0x1.2p+3 },
+{ INT64_C(0x6000000000008010), 0x1.800000000002p+62, 0x1p+4 },
+{ INT64_C(0x9fffffffffff7fef), -0x1.800000000002p+62, -0x1.1p+4 },
+{ INT64_C(0x6000000000008080), 0x1.800000000002p+62, 0x1p+7 },
+{ INT64_C(0x9fffffffffff7f7f), -0x1.800000000002p+62, -0x1.02p+7 },
+{ INT64_C(0x6000000000008100), 0x1.800000000002p+62, 0x1p+8 },
+{ INT64_C(0x9fffffffffff7eff), -0x1.800000000002p+62, -0x1.01p+8 },
+{ INT64_C(0x6000000000008800), 0x1.8000000000022p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffff77ff), -0x1.8000000000022p+62, -0x1p+0 },
+{ INT64_C(0x6000000000080000), 0x1.80000000002p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffff7ffff), -0x1.80000000002p+62, -0x1p+0 },
+{ INT64_C(0x6000000000080004), 0x1.80000000002p+62, 0x1p+2 },
+{ INT64_C(0x9ffffffffff7fffb), -0x1.80000000002p+62, -0x1.4p+2 },
+{ INT64_C(0x6000000000080008), 0x1.80000000002p+62, 0x1p+3 },
+{ INT64_C(0x9ffffffffff7fff7), -0x1.80000000002p+62, -0x1.2p+3 },
+{ INT64_C(0x6000000000080020), 0x1.80000000002p+62, 0x1p+5 },
+{ INT64_C(0x9ffffffffff7ffdf), -0x1.80000000002p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000000080040), 0x1.80000000002p+62, 0x1p+6 },
+{ INT64_C(0x9ffffffffff7ffbf), -0x1.80000000002p+62, -0x1.04p+6 },
+{ INT64_C(0x6000000000080200), 0x1.80000000002p+62, 0x1p+9 },
+{ INT64_C(0x9ffffffffff7fdff), -0x1.8000000000201p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000000082000), 0x1.8000000000208p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffff7dfff), -0x1.8000000000208p+62, -0x1p+0 },
+{ INT64_C(0x6000000000088000), 0x1.800000000022p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffff77fff), -0x1.800000000022p+62, -0x1p+0 },
+{ INT64_C(0x6000000000200000), 0x1.80000000008p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffdfffff), -0x1.80000000008p+62, -0x1p+0 },
+{ INT64_C(0x6000000000200002), 0x1.80000000008p+62, 0x1p+1 },
+{ INT64_C(0x9fffffffffdffffd), -0x1.80000000008p+62, -0x1.8p+1 },
+{ INT64_C(0x6000000000200020), 0x1.80000000008p+62, 0x1p+5 },
+{ INT64_C(0x9fffffffffdfffdf), -0x1.80000000008p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000000200100), 0x1.80000000008p+62, 0x1p+8 },
+{ INT64_C(0x9fffffffffdffeff), -0x1.80000000008p+62, -0x1.01p+8 },
+{ INT64_C(0x6000000000200200), 0x1.80000000008p+62, 0x1p+9 },
+{ INT64_C(0x9fffffffffdffdff), -0x1.8000000000801p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000000200800), 0x1.8000000000802p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffdff7ff), -0x1.8000000000802p+62, -0x1p+0 },
+{ INT64_C(0x6000000000208000), 0x1.800000000082p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffdf7fff), -0x1.800000000082p+62, -0x1p+0 },
+{ INT64_C(0x6000000000240000), 0x1.80000000009p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffdbffff), -0x1.80000000009p+62, -0x1p+0 },
+{ INT64_C(0x6000000000300000), 0x1.8000000000cp+62, 0x0p+0 },
+{ INT64_C(0x9fffffffffcfffff), -0x1.8000000000cp+62, -0x1p+0 },
+{ INT64_C(0x6000000001000000), 0x1.8000000004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffeffffff), -0x1.8000000004p+62, -0x1p+0 },
+{ INT64_C(0x6000000001000004), 0x1.8000000004p+62, 0x1p+2 },
+{ INT64_C(0x9ffffffffefffffb), -0x1.8000000004p+62, -0x1.4p+2 },
+{ INT64_C(0x6000000001000020), 0x1.8000000004p+62, 0x1p+5 },
+{ INT64_C(0x9ffffffffeffffdf), -0x1.8000000004p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000001000100), 0x1.8000000004p+62, 0x1p+8 },
+{ INT64_C(0x9ffffffffefffeff), -0x1.8000000004p+62, -0x1.01p+8 },
+{ INT64_C(0x6000000001000200), 0x1.8000000004p+62, 0x1p+9 },
+{ INT64_C(0x9ffffffffefffdff), -0x1.8000000004001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000001001000), 0x1.8000000004004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffeffefff), -0x1.8000000004004p+62, -0x1p+0 },
+{ INT64_C(0x6000000001010000), 0x1.800000000404p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffefeffff), -0x1.800000000404p+62, -0x1p+0 },
+{ INT64_C(0x6000000001080000), 0x1.80000000042p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffef7ffff), -0x1.80000000042p+62, -0x1p+0 },
+{ INT64_C(0x6000000001200000), 0x1.80000000048p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffedfffff), -0x1.80000000048p+62, -0x1p+0 },
+{ INT64_C(0x6000000002000000), 0x1.8000000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffdffffff), -0x1.8000000008p+62, -0x1p+0 },
+{ INT64_C(0x6000000002000004), 0x1.8000000008p+62, 0x1p+2 },
+{ INT64_C(0x9ffffffffdfffffb), -0x1.8000000008p+62, -0x1.4p+2 },
+{ INT64_C(0x6000000002000020), 0x1.8000000008p+62, 0x1p+5 },
+{ INT64_C(0x9ffffffffdffffdf), -0x1.8000000008p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000002000200), 0x1.8000000008p+62, 0x1p+9 },
+{ INT64_C(0x9ffffffffdfffdff), -0x1.8000000008001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000002000400), 0x1.8000000008001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffdfffbff), -0x1.8000000008001p+62, -0x1p+0 },
+{ INT64_C(0x6000000002000800), 0x1.8000000008002p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffdfff7ff), -0x1.8000000008002p+62, -0x1p+0 },
+{ INT64_C(0x6000000002002000), 0x1.8000000008008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffdffdfff), -0x1.8000000008008p+62, -0x1p+0 },
+{ INT64_C(0x6000000002010000), 0x1.800000000804p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffdfeffff), -0x1.800000000804p+62, -0x1p+0 },
+{ INT64_C(0x6000000002080000), 0x1.80000000082p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffdf7ffff), -0x1.80000000082p+62, -0x1p+0 },
+{ INT64_C(0x6000000002200000), 0x1.80000000088p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffddfffff), -0x1.80000000088p+62, -0x1p+0 },
+{ INT64_C(0x6000000002800000), 0x1.800000000ap+62, 0x0p+0 },
+{ INT64_C(0x9ffffffffd7fffff), -0x1.800000000ap+62, -0x1p+0 },
+{ INT64_C(0x6000000008000000), 0x1.800000002p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffff7ffffff), -0x1.800000002p+62, -0x1p+0 },
+{ INT64_C(0x6000000008000002), 0x1.800000002p+62, 0x1p+1 },
+{ INT64_C(0x9ffffffff7fffffd), -0x1.800000002p+62, -0x1.8p+1 },
+{ INT64_C(0x6000000008000010), 0x1.800000002p+62, 0x1p+4 },
+{ INT64_C(0x9ffffffff7ffffef), -0x1.800000002p+62, -0x1.1p+4 },
+{ INT64_C(0x6000000008000020), 0x1.800000002p+62, 0x1p+5 },
+{ INT64_C(0x9ffffffff7ffffdf), -0x1.800000002p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000008000200), 0x1.800000002p+62, 0x1p+9 },
+{ INT64_C(0x9ffffffff7fffdff), -0x1.8000000020001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000008002000), 0x1.8000000020008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffff7ffdfff), -0x1.8000000020008p+62, -0x1p+0 },
+{ INT64_C(0x6000000008010000), 0x1.800000002004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffff7feffff), -0x1.800000002004p+62, -0x1p+0 },
+{ INT64_C(0x6000000008040000), 0x1.80000000201p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffff7fbffff), -0x1.80000000201p+62, -0x1p+0 },
+{ INT64_C(0x6000000008100000), 0x1.80000000204p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffff7efffff), -0x1.80000000204p+62, -0x1p+0 },
+{ INT64_C(0x6000000009000000), 0x1.8000000024p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffff6ffffff), -0x1.8000000024p+62, -0x1p+0 },
+{ INT64_C(0x6000000040000000), 0x1.80000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbfffffff), -0x1.80000001p+62, -0x1p+0 },
+{ INT64_C(0x6000000040000002), 0x1.80000001p+62, 0x1p+1 },
+{ INT64_C(0x9fffffffbffffffd), -0x1.80000001p+62, -0x1.8p+1 },
+{ INT64_C(0x6000000040000020), 0x1.80000001p+62, 0x1p+5 },
+{ INT64_C(0x9fffffffbfffffdf), -0x1.80000001p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000040000080), 0x1.80000001p+62, 0x1p+7 },
+{ INT64_C(0x9fffffffbfffff7f), -0x1.80000001p+62, -0x1.02p+7 },
+{ INT64_C(0x6000000040000200), 0x1.80000001p+62, 0x1p+9 },
+{ INT64_C(0x9fffffffbffffdff), -0x1.8000000100001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000040000400), 0x1.8000000100001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbffffbff), -0x1.8000000100001p+62, -0x1p+0 },
+{ INT64_C(0x6000000040002000), 0x1.8000000100008p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbfffdfff), -0x1.8000000100008p+62, -0x1p+0 },
+{ INT64_C(0x6000000040020000), 0x1.800000010008p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbffdffff), -0x1.800000010008p+62, -0x1p+0 },
+{ INT64_C(0x6000000040040000), 0x1.80000001001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbffbffff), -0x1.80000001001p+62, -0x1p+0 },
+{ INT64_C(0x6000000040200000), 0x1.80000001008p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbfdfffff), -0x1.80000001008p+62, -0x1p+0 },
+{ INT64_C(0x6000000041000000), 0x1.8000000104p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbeffffff), -0x1.8000000104p+62, -0x1p+0 },
+{ INT64_C(0x6000000044000000), 0x1.800000011p+62, 0x0p+0 },
+{ INT64_C(0x9fffffffbbffffff), -0x1.800000011p+62, -0x1p+0 },
+{ INT64_C(0x6000000060000000), 0x1.800000018p+62, 0x0p+0 },
+{ INT64_C(0x9fffffff9fffffff), -0x1.800000018p+62, -0x1p+0 },
+{ INT64_C(0x6000000100000000), 0x1.80000004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffeffffffff), -0x1.80000004p+62, -0x1p+0 },
+{ INT64_C(0x6000000100000002), 0x1.80000004p+62, 0x1p+1 },
+{ INT64_C(0x9ffffffefffffffd), -0x1.80000004p+62, -0x1.8p+1 },
+{ INT64_C(0x6000000100000008), 0x1.80000004p+62, 0x1p+3 },
+{ INT64_C(0x9ffffffefffffff7), -0x1.80000004p+62, -0x1.2p+3 },
+{ INT64_C(0x6000000100000020), 0x1.80000004p+62, 0x1p+5 },
+{ INT64_C(0x9ffffffeffffffdf), -0x1.80000004p+62, -0x1.08p+5 },
+{ INT64_C(0x6000000100000200), 0x1.80000004p+62, 0x1p+9 },
+{ INT64_C(0x9ffffffefffffdff), -0x1.8000000400001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000100000400), 0x1.8000000400001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffefffffbff), -0x1.8000000400001p+62, -0x1p+0 },
+{ INT64_C(0x6000000100001000), 0x1.8000000400004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffeffffefff), -0x1.8000000400004p+62, -0x1p+0 },
+{ INT64_C(0x6000000100002000), 0x1.8000000400008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffeffffdfff), -0x1.8000000400008p+62, -0x1p+0 },
+{ INT64_C(0x6000000100020000), 0x1.800000040008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffefffdffff), -0x1.800000040008p+62, -0x1p+0 },
+{ INT64_C(0x6000000100200000), 0x1.80000004008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffeffdfffff), -0x1.80000004008p+62, -0x1p+0 },
+{ INT64_C(0x6000000101000000), 0x1.8000000404p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffefeffffff), -0x1.8000000404p+62, -0x1p+0 },
+{ INT64_C(0x6000000104000000), 0x1.800000041p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffefbffffff), -0x1.800000041p+62, -0x1p+0 },
+{ INT64_C(0x6000000110000000), 0x1.800000044p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffeefffffff), -0x1.800000044p+62, -0x1p+0 },
+{ INT64_C(0x6000000180000000), 0x1.80000006p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffe7fffffff), -0x1.80000006p+62, -0x1p+0 },
+{ INT64_C(0x6000000200000000), 0x1.80000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdffffffff), -0x1.80000008p+62, -0x1p+0 },
+{ INT64_C(0x6000000200000004), 0x1.80000008p+62, 0x1p+2 },
+{ INT64_C(0x9ffffffdfffffffb), -0x1.80000008p+62, -0x1.4p+2 },
+{ INT64_C(0x6000000200000010), 0x1.80000008p+62, 0x1p+4 },
+{ INT64_C(0x9ffffffdffffffef), -0x1.80000008p+62, -0x1.1p+4 },
+{ INT64_C(0x6000000200000040), 0x1.80000008p+62, 0x1p+6 },
+{ INT64_C(0x9ffffffdffffffbf), -0x1.80000008p+62, -0x1.04p+6 },
+{ INT64_C(0x6000000200000200), 0x1.80000008p+62, 0x1p+9 },
+{ INT64_C(0x9ffffffdfffffdff), -0x1.8000000800001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000000200000400), 0x1.8000000800001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdfffffbff), -0x1.8000000800001p+62, -0x1p+0 },
+{ INT64_C(0x6000000200001000), 0x1.8000000800004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdffffefff), -0x1.8000000800004p+62, -0x1p+0 },
+{ INT64_C(0x6000000200010000), 0x1.800000080004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdfffeffff), -0x1.800000080004p+62, -0x1p+0 },
+{ INT64_C(0x6000000200040000), 0x1.80000008001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdfffbffff), -0x1.80000008001p+62, -0x1p+0 },
+{ INT64_C(0x6000000200100000), 0x1.80000008004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdffefffff), -0x1.80000008004p+62, -0x1p+0 },
+{ INT64_C(0x6000000201000000), 0x1.8000000804p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdfeffffff), -0x1.8000000804p+62, -0x1p+0 },
+{ INT64_C(0x6000000210000000), 0x1.800000084p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffdefffffff), -0x1.800000084p+62, -0x1p+0 },
+{ INT64_C(0x6000000280000000), 0x1.8000000ap+62, 0x0p+0 },
+{ INT64_C(0x9ffffffd7fffffff), -0x1.8000000ap+62, -0x1p+0 },
+{ INT64_C(0x6000000300000000), 0x1.8000000cp+62, 0x0p+0 },
+{ INT64_C(0x9ffffffcffffffff), -0x1.8000000cp+62, -0x1p+0 },
+{ INT64_C(0x6000000400000000), 0x1.8000001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbffffffff), -0x1.8000001p+62, -0x1p+0 },
+{ INT64_C(0x6000000400000001), 0x1.8000001p+62, 0x1p+0 },
+{ INT64_C(0x9ffffffbfffffffe), -0x1.8000001p+62, -0x1p+1 },
+{ INT64_C(0x6000000400000002), 0x1.8000001p+62, 0x1p+1 },
+{ INT64_C(0x9ffffffbfffffffd), -0x1.8000001p+62, -0x1.8p+1 },
+{ INT64_C(0x6000000400000008), 0x1.8000001p+62, 0x1p+3 },
+{ INT64_C(0x9ffffffbfffffff7), -0x1.8000001p+62, -0x1.2p+3 },
+{ INT64_C(0x6000000400000010), 0x1.8000001p+62, 0x1p+4 },
+{ INT64_C(0x9ffffffbffffffef), -0x1.8000001p+62, -0x1.1p+4 },
+{ INT64_C(0x6000000400000040), 0x1.8000001p+62, 0x1p+6 },
+{ INT64_C(0x9ffffffbffffffbf), -0x1.8000001p+62, -0x1.04p+6 },
+{ INT64_C(0x6000000400000400), 0x1.8000001000001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbfffffbff), -0x1.8000001000001p+62, -0x1p+0 },
+{ INT64_C(0x6000000400000800), 0x1.8000001000002p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbfffff7ff), -0x1.8000001000002p+62, -0x1p+0 },
+{ INT64_C(0x6000000400002000), 0x1.8000001000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbffffdfff), -0x1.8000001000008p+62, -0x1p+0 },
+{ INT64_C(0x6000000400010000), 0x1.800000100004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbfffeffff), -0x1.800000100004p+62, -0x1p+0 },
+{ INT64_C(0x6000000400080000), 0x1.80000010002p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbfff7ffff), -0x1.80000010002p+62, -0x1p+0 },
+{ INT64_C(0x6000000400800000), 0x1.8000001002p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbff7fffff), -0x1.8000001002p+62, -0x1p+0 },
+{ INT64_C(0x6000000401000000), 0x1.8000001004p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbfeffffff), -0x1.8000001004p+62, -0x1p+0 },
+{ INT64_C(0x6000000410000000), 0x1.800000104p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbefffffff), -0x1.800000104p+62, -0x1p+0 },
+{ INT64_C(0x6000000420000000), 0x1.800000108p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffbdfffffff), -0x1.800000108p+62, -0x1p+0 },
+{ INT64_C(0x6000000500000000), 0x1.80000014p+62, 0x0p+0 },
+{ INT64_C(0x9ffffffaffffffff), -0x1.80000014p+62, -0x1p+0 },
+{ INT64_C(0x6000000600000000), 0x1.80000018p+62, 0x0p+0 },
+{ INT64_C(0x9ffffff9ffffffff), -0x1.80000018p+62, -0x1p+0 },
+{ INT64_C(0x6000004000000000), 0x1.800001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbfffffffff), -0x1.800001p+62, -0x1p+0 },
+{ INT64_C(0x6000004000000001), 0x1.800001p+62, 0x1p+0 },
+{ INT64_C(0x9fffffbffffffffe), -0x1.800001p+62, -0x1p+1 },
+{ INT64_C(0x6000004000000002), 0x1.800001p+62, 0x1p+1 },
+{ INT64_C(0x9fffffbffffffffd), -0x1.800001p+62, -0x1.8p+1 },
+{ INT64_C(0x6000004000000004), 0x1.800001p+62, 0x1p+2 },
+{ INT64_C(0x9fffffbffffffffb), -0x1.800001p+62, -0x1.4p+2 },
+{ INT64_C(0x6000004000000008), 0x1.800001p+62, 0x1p+3 },
+{ INT64_C(0x9fffffbffffffff7), -0x1.800001p+62, -0x1.2p+3 },
+{ INT64_C(0x6000004000000020), 0x1.800001p+62, 0x1p+5 },
+{ INT64_C(0x9fffffbfffffffdf), -0x1.800001p+62, -0x1.08p+5 },
+{ INT64_C(0x6000004000000100), 0x1.800001p+62, 0x1p+8 },
+{ INT64_C(0x9fffffbffffffeff), -0x1.800001p+62, -0x1.01p+8 },
+{ INT64_C(0x6000004000000800), 0x1.8000010000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbffffff7ff), -0x1.8000010000002p+62, -0x1p+0 },
+{ INT64_C(0x6000004000001000), 0x1.8000010000004p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbfffffefff), -0x1.8000010000004p+62, -0x1p+0 },
+{ INT64_C(0x6000004000004000), 0x1.800001000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbfffffbfff), -0x1.800001000001p+62, -0x1p+0 },
+{ INT64_C(0x6000004000040000), 0x1.80000100001p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbffffbffff), -0x1.80000100001p+62, -0x1p+0 },
+{ INT64_C(0x6000004000200000), 0x1.80000100008p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbfffdfffff), -0x1.80000100008p+62, -0x1p+0 },
+{ INT64_C(0x6000004001000000), 0x1.8000010004p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbffeffffff), -0x1.8000010004p+62, -0x1p+0 },
+{ INT64_C(0x6000004010000000), 0x1.800001004p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbfefffffff), -0x1.800001004p+62, -0x1p+0 },
+{ INT64_C(0x6000004080000000), 0x1.80000102p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbf7fffffff), -0x1.80000102p+62, -0x1p+0 },
+{ INT64_C(0x6000004100000000), 0x1.80000104p+62, 0x0p+0 },
+{ INT64_C(0x9fffffbeffffffff), -0x1.80000104p+62, -0x1p+0 },
+{ INT64_C(0x6000004800000000), 0x1.8000012p+62, 0x0p+0 },
+{ INT64_C(0x9fffffb7ffffffff), -0x1.8000012p+62, -0x1p+0 },
+{ INT64_C(0x6000006000000000), 0x1.8000018p+62, 0x0p+0 },
+{ INT64_C(0x9fffff9fffffffff), -0x1.8000018p+62, -0x1p+0 },
+{ INT64_C(0x6000020000000000), 0x1.800008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdffffffffff), -0x1.800008p+62, -0x1p+0 },
+{ INT64_C(0x6000020000000004), 0x1.800008p+62, 0x1p+2 },
+{ INT64_C(0x9ffffdfffffffffb), -0x1.800008p+62, -0x1.4p+2 },
+{ INT64_C(0x6000020000000040), 0x1.800008p+62, 0x1p+6 },
+{ INT64_C(0x9ffffdffffffffbf), -0x1.800008p+62, -0x1.04p+6 },
+{ INT64_C(0x6000020000000080), 0x1.800008p+62, 0x1p+7 },
+{ INT64_C(0x9ffffdffffffff7f), -0x1.800008p+62, -0x1.02p+7 },
+{ INT64_C(0x6000020000000100), 0x1.800008p+62, 0x1p+8 },
+{ INT64_C(0x9ffffdfffffffeff), -0x1.800008p+62, -0x1.01p+8 },
+{ INT64_C(0x6000020000000400), 0x1.8000080000001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdfffffffbff), -0x1.8000080000001p+62, -0x1p+0 },
+{ INT64_C(0x6000020000004000), 0x1.800008000001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdffffffbfff), -0x1.800008000001p+62, -0x1p+0 },
+{ INT64_C(0x6000020000020000), 0x1.800008000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdfffffdffff), -0x1.800008000008p+62, -0x1p+0 },
+{ INT64_C(0x6000020000200000), 0x1.80000800008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdffffdfffff), -0x1.80000800008p+62, -0x1p+0 },
+{ INT64_C(0x6000020002000000), 0x1.8000080008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdfffdffffff), -0x1.8000080008p+62, -0x1p+0 },
+{ INT64_C(0x6000020004000000), 0x1.800008001p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdfffbffffff), -0x1.800008001p+62, -0x1p+0 },
+{ INT64_C(0x6000020020000000), 0x1.800008008p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdffdfffffff), -0x1.800008008p+62, -0x1p+0 },
+{ INT64_C(0x6000020040000000), 0x1.80000801p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdffbfffffff), -0x1.80000801p+62, -0x1p+0 },
+{ INT64_C(0x6000020400000000), 0x1.8000081p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdfbffffffff), -0x1.8000081p+62, -0x1p+0 },
+{ INT64_C(0x6000021000000000), 0x1.8000084p+62, 0x0p+0 },
+{ INT64_C(0x9ffffdefffffffff), -0x1.8000084p+62, -0x1p+0 },
+{ INT64_C(0x6000030000000000), 0x1.80000cp+62, 0x0p+0 },
+{ INT64_C(0x9ffffcffffffffff), -0x1.80000cp+62, -0x1p+0 },
+{ INT64_C(0x6000100000000000), 0x1.80004p+62, 0x0p+0 },
+{ INT64_C(0x9fffefffffffffff), -0x1.80004p+62, -0x1p+0 },
+{ INT64_C(0x6000100000000008), 0x1.80004p+62, 0x1p+3 },
+{ INT64_C(0x9fffeffffffffff7), -0x1.80004p+62, -0x1.2p+3 },
+{ INT64_C(0x6000100000000010), 0x1.80004p+62, 0x1p+4 },
+{ INT64_C(0x9fffefffffffffef), -0x1.80004p+62, -0x1.1p+4 },
+{ INT64_C(0x6000100000000040), 0x1.80004p+62, 0x1p+6 },
+{ INT64_C(0x9fffefffffffffbf), -0x1.80004p+62, -0x1.04p+6 },
+{ INT64_C(0x6000100000000080), 0x1.80004p+62, 0x1p+7 },
+{ INT64_C(0x9fffefffffffff7f), -0x1.80004p+62, -0x1.02p+7 },
+{ INT64_C(0x6000100000000200), 0x1.80004p+62, 0x1p+9 },
+{ INT64_C(0x9fffeffffffffdff), -0x1.8000400000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000100000000400), 0x1.8000400000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffffffbff), -0x1.8000400000001p+62, -0x1p+0 },
+{ INT64_C(0x6000100000000800), 0x1.8000400000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffffff7ff), -0x1.8000400000002p+62, -0x1p+0 },
+{ INT64_C(0x6000100000004000), 0x1.800040000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffefffffffbfff), -0x1.800040000001p+62, -0x1p+0 },
+{ INT64_C(0x6000100000008000), 0x1.800040000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffefffffff7fff), -0x1.800040000002p+62, -0x1p+0 },
+{ INT64_C(0x6000100000010000), 0x1.800040000004p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffffeffff), -0x1.800040000004p+62, -0x1p+0 },
+{ INT64_C(0x6000100000020000), 0x1.800040000008p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffffdffff), -0x1.800040000008p+62, -0x1p+0 },
+{ INT64_C(0x6000100000040000), 0x1.80004000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffffbffff), -0x1.80004000001p+62, -0x1p+0 },
+{ INT64_C(0x6000100000080000), 0x1.80004000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffff7ffff), -0x1.80004000002p+62, -0x1p+0 },
+{ INT64_C(0x6000100000800000), 0x1.8000400002p+62, 0x0p+0 },
+{ INT64_C(0x9fffefffff7fffff), -0x1.8000400002p+62, -0x1p+0 },
+{ INT64_C(0x6000100004000000), 0x1.800040001p+62, 0x0p+0 },
+{ INT64_C(0x9fffeffffbffffff), -0x1.800040001p+62, -0x1p+0 },
+{ INT64_C(0x6000100040000000), 0x1.80004001p+62, 0x0p+0 },
+{ INT64_C(0x9fffefffbfffffff), -0x1.80004001p+62, -0x1p+0 },
+{ INT64_C(0x6000100080000000), 0x1.80004002p+62, 0x0p+0 },
+{ INT64_C(0x9fffefff7fffffff), -0x1.80004002p+62, -0x1p+0 },
+{ INT64_C(0x6000100800000000), 0x1.8000402p+62, 0x0p+0 },
+{ INT64_C(0x9fffeff7ffffffff), -0x1.8000402p+62, -0x1p+0 },
+{ INT64_C(0x6000101000000000), 0x1.8000404p+62, 0x0p+0 },
+{ INT64_C(0x9fffefefffffffff), -0x1.8000404p+62, -0x1p+0 },
+{ INT64_C(0x6000102000000000), 0x1.8000408p+62, 0x0p+0 },
+{ INT64_C(0x9fffefdfffffffff), -0x1.8000408p+62, -0x1p+0 },
+{ INT64_C(0x6000120000000000), 0x1.800048p+62, 0x0p+0 },
+{ INT64_C(0x9fffedffffffffff), -0x1.800048p+62, -0x1p+0 },
+{ INT64_C(0x6000200000000000), 0x1.80008p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfffffffffff), -0x1.80008p+62, -0x1p+0 },
+{ INT64_C(0x6000200000000002), 0x1.80008p+62, 0x1p+1 },
+{ INT64_C(0x9fffdffffffffffd), -0x1.80008p+62, -0x1.8p+1 },
+{ INT64_C(0x6000200000000004), 0x1.80008p+62, 0x1p+2 },
+{ INT64_C(0x9fffdffffffffffb), -0x1.80008p+62, -0x1.4p+2 },
+{ INT64_C(0x6000200000000020), 0x1.80008p+62, 0x1p+5 },
+{ INT64_C(0x9fffdfffffffffdf), -0x1.80008p+62, -0x1.08p+5 },
+{ INT64_C(0x6000200000000100), 0x1.80008p+62, 0x1p+8 },
+{ INT64_C(0x9fffdffffffffeff), -0x1.80008p+62, -0x1.01p+8 },
+{ INT64_C(0x6000200000000200), 0x1.80008p+62, 0x1p+9 },
+{ INT64_C(0x9fffdffffffffdff), -0x1.8000800000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6000200000000800), 0x1.8000800000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffdffffffff7ff), -0x1.8000800000002p+62, -0x1p+0 },
+{ INT64_C(0x6000200000008000), 0x1.800080000002p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfffffff7fff), -0x1.800080000002p+62, -0x1p+0 },
+{ INT64_C(0x6000200000010000), 0x1.800080000004p+62, 0x0p+0 },
+{ INT64_C(0x9fffdffffffeffff), -0x1.800080000004p+62, -0x1p+0 },
+{ INT64_C(0x6000200000040000), 0x1.80008000001p+62, 0x0p+0 },
+{ INT64_C(0x9fffdffffffbffff), -0x1.80008000001p+62, -0x1p+0 },
+{ INT64_C(0x6000200000200000), 0x1.80008000008p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfffffdfffff), -0x1.80008000008p+62, -0x1p+0 },
+{ INT64_C(0x6000200000400000), 0x1.8000800001p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfffffbfffff), -0x1.8000800001p+62, -0x1p+0 },
+{ INT64_C(0x6000200002000000), 0x1.8000800008p+62, 0x0p+0 },
+{ INT64_C(0x9fffdffffdffffff), -0x1.8000800008p+62, -0x1p+0 },
+{ INT64_C(0x6000200020000000), 0x1.800080008p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfffdfffffff), -0x1.800080008p+62, -0x1p+0 },
+{ INT64_C(0x6000200080000000), 0x1.80008002p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfff7fffffff), -0x1.80008002p+62, -0x1p+0 },
+{ INT64_C(0x6000200200000000), 0x1.80008008p+62, 0x0p+0 },
+{ INT64_C(0x9fffdffdffffffff), -0x1.80008008p+62, -0x1p+0 },
+{ INT64_C(0x6000201000000000), 0x1.8000804p+62, 0x0p+0 },
+{ INT64_C(0x9fffdfefffffffff), -0x1.8000804p+62, -0x1p+0 },
+{ INT64_C(0x6000208000000000), 0x1.800082p+62, 0x0p+0 },
+{ INT64_C(0x9fffdf7fffffffff), -0x1.800082p+62, -0x1p+0 },
+{ INT64_C(0x6000280000000000), 0x1.8000ap+62, 0x0p+0 },
+{ INT64_C(0x9fffd7ffffffffff), -0x1.8000ap+62, -0x1p+0 },
+{ INT64_C(0x6000800000000000), 0x1.8002p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffffffffff), -0x1.8002p+62, -0x1p+0 },
+{ INT64_C(0x6000800000000001), 0x1.8002p+62, 0x1p+0 },
+{ INT64_C(0x9fff7ffffffffffe), -0x1.8002p+62, -0x1p+1 },
+{ INT64_C(0x6000800000000004), 0x1.8002p+62, 0x1p+2 },
+{ INT64_C(0x9fff7ffffffffffb), -0x1.8002p+62, -0x1.4p+2 },
+{ INT64_C(0x6000800000000010), 0x1.8002p+62, 0x1p+4 },
+{ INT64_C(0x9fff7fffffffffef), -0x1.8002p+62, -0x1.1p+4 },
+{ INT64_C(0x6000800000000100), 0x1.8002p+62, 0x1p+8 },
+{ INT64_C(0x9fff7ffffffffeff), -0x1.8002p+62, -0x1.01p+8 },
+{ INT64_C(0x6000800000000400), 0x1.8002000000001p+62, 0x0p+0 },
+{ INT64_C(0x9fff7ffffffffbff), -0x1.8002000000001p+62, -0x1p+0 },
+{ INT64_C(0x6000800000001000), 0x1.8002000000004p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffffffefff), -0x1.8002000000004p+62, -0x1p+0 },
+{ INT64_C(0x6000800000002000), 0x1.8002000000008p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffffffdfff), -0x1.8002000000008p+62, -0x1p+0 },
+{ INT64_C(0x6000800000008000), 0x1.800200000002p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffffff7fff), -0x1.800200000002p+62, -0x1p+0 },
+{ INT64_C(0x6000800000040000), 0x1.80020000001p+62, 0x0p+0 },
+{ INT64_C(0x9fff7ffffffbffff), -0x1.80020000001p+62, -0x1p+0 },
+{ INT64_C(0x6000800000100000), 0x1.80020000004p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffffefffff), -0x1.80020000004p+62, -0x1p+0 },
+{ INT64_C(0x6000800000400000), 0x1.8002000001p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffffbfffff), -0x1.8002000001p+62, -0x1p+0 },
+{ INT64_C(0x6000800000800000), 0x1.8002000002p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffff7fffff), -0x1.8002000002p+62, -0x1p+0 },
+{ INT64_C(0x6000800008000000), 0x1.800200002p+62, 0x0p+0 },
+{ INT64_C(0x9fff7ffff7ffffff), -0x1.800200002p+62, -0x1p+0 },
+{ INT64_C(0x6000800020000000), 0x1.800200008p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffdfffffff), -0x1.800200008p+62, -0x1p+0 },
+{ INT64_C(0x6000800040000000), 0x1.80020001p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fffbfffffff), -0x1.80020001p+62, -0x1p+0 },
+{ INT64_C(0x6000800080000000), 0x1.80020002p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fff7fffffff), -0x1.80020002p+62, -0x1p+0 },
+{ INT64_C(0x6000800400000000), 0x1.8002001p+62, 0x0p+0 },
+{ INT64_C(0x9fff7ffbffffffff), -0x1.8002001p+62, -0x1p+0 },
+{ INT64_C(0x6000800800000000), 0x1.8002002p+62, 0x0p+0 },
+{ INT64_C(0x9fff7ff7ffffffff), -0x1.8002002p+62, -0x1p+0 },
+{ INT64_C(0x6000802000000000), 0x1.8002008p+62, 0x0p+0 },
+{ INT64_C(0x9fff7fdfffffffff), -0x1.8002008p+62, -0x1p+0 },
+{ INT64_C(0x6000808000000000), 0x1.800202p+62, 0x0p+0 },
+{ INT64_C(0x9fff7f7fffffffff), -0x1.800202p+62, -0x1p+0 },
+{ INT64_C(0x6000880000000000), 0x1.80022p+62, 0x0p+0 },
+{ INT64_C(0x9fff77ffffffffff), -0x1.80022p+62, -0x1p+0 },
+{ INT64_C(0x6000900000000000), 0x1.80024p+62, 0x0p+0 },
+{ INT64_C(0x9fff6fffffffffff), -0x1.80024p+62, -0x1p+0 },
+{ INT64_C(0x6000c00000000000), 0x1.8003p+62, 0x0p+0 },
+{ INT64_C(0x9fff3fffffffffff), -0x1.8003p+62, -0x1p+0 },
+{ INT64_C(0x6001000000000000), 0x1.8004p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffffffffffff), -0x1.8004p+62, -0x1p+0 },
+{ INT64_C(0x6001000000000004), 0x1.8004p+62, 0x1p+2 },
+{ INT64_C(0x9ffefffffffffffb), -0x1.8004p+62, -0x1.4p+2 },
+{ INT64_C(0x6001000000000010), 0x1.8004p+62, 0x1p+4 },
+{ INT64_C(0x9ffeffffffffffef), -0x1.8004p+62, -0x1.1p+4 },
+{ INT64_C(0x6001000000000100), 0x1.8004p+62, 0x1p+8 },
+{ INT64_C(0x9ffefffffffffeff), -0x1.8004p+62, -0x1.01p+8 },
+{ INT64_C(0x6001000000001000), 0x1.8004000000004p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffffffffefff), -0x1.8004000000004p+62, -0x1p+0 },
+{ INT64_C(0x6001000000010000), 0x1.800400000004p+62, 0x0p+0 },
+{ INT64_C(0x9ffefffffffeffff), -0x1.800400000004p+62, -0x1p+0 },
+{ INT64_C(0x6001000000020000), 0x1.800400000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffefffffffdffff), -0x1.800400000008p+62, -0x1p+0 },
+{ INT64_C(0x6001000000040000), 0x1.80040000001p+62, 0x0p+0 },
+{ INT64_C(0x9ffefffffffbffff), -0x1.80040000001p+62, -0x1p+0 },
+{ INT64_C(0x6001000000200000), 0x1.80040000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffffffdfffff), -0x1.80040000008p+62, -0x1p+0 },
+{ INT64_C(0x6001000002000000), 0x1.8004000008p+62, 0x0p+0 },
+{ INT64_C(0x9ffefffffdffffff), -0x1.8004000008p+62, -0x1p+0 },
+{ INT64_C(0x6001000010000000), 0x1.800400004p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffffefffffff), -0x1.800400004p+62, -0x1p+0 },
+{ INT64_C(0x6001000020000000), 0x1.800400008p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffffdfffffff), -0x1.800400008p+62, -0x1p+0 },
+{ INT64_C(0x6001000040000000), 0x1.80040001p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffffbfffffff), -0x1.80040001p+62, -0x1p+0 },
+{ INT64_C(0x6001000080000000), 0x1.80040002p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffff7fffffff), -0x1.80040002p+62, -0x1p+0 },
+{ INT64_C(0x6001000200000000), 0x1.80040008p+62, 0x0p+0 },
+{ INT64_C(0x9ffefffdffffffff), -0x1.80040008p+62, -0x1p+0 },
+{ INT64_C(0x6001000800000000), 0x1.8004002p+62, 0x0p+0 },
+{ INT64_C(0x9ffefff7ffffffff), -0x1.8004002p+62, -0x1p+0 },
+{ INT64_C(0x6001001000000000), 0x1.8004004p+62, 0x0p+0 },
+{ INT64_C(0x9ffeffefffffffff), -0x1.8004004p+62, -0x1p+0 },
+{ INT64_C(0x6001008000000000), 0x1.800402p+62, 0x0p+0 },
+{ INT64_C(0x9ffeff7fffffffff), -0x1.800402p+62, -0x1p+0 },
+{ INT64_C(0x6001010000000000), 0x1.800404p+62, 0x0p+0 },
+{ INT64_C(0x9ffefeffffffffff), -0x1.800404p+62, -0x1p+0 },
+{ INT64_C(0x6001040000000000), 0x1.80041p+62, 0x0p+0 },
+{ INT64_C(0x9ffefbffffffffff), -0x1.80041p+62, -0x1p+0 },
+{ INT64_C(0x6001200000000000), 0x1.80048p+62, 0x0p+0 },
+{ INT64_C(0x9ffedfffffffffff), -0x1.80048p+62, -0x1p+0 },
+{ INT64_C(0x6001800000000000), 0x1.8006p+62, 0x0p+0 },
+{ INT64_C(0x9ffe7fffffffffff), -0x1.8006p+62, -0x1p+0 },
+{ INT64_C(0x6008000000000000), 0x1.802p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffffffffff), -0x1.802p+62, -0x1p+0 },
+{ INT64_C(0x6008000000000004), 0x1.802p+62, 0x1p+2 },
+{ INT64_C(0x9ff7fffffffffffb), -0x1.802p+62, -0x1.4p+2 },
+{ INT64_C(0x6008000000000020), 0x1.802p+62, 0x1p+5 },
+{ INT64_C(0x9ff7ffffffffffdf), -0x1.802p+62, -0x1.08p+5 },
+{ INT64_C(0x6008000000000200), 0x1.802p+62, 0x1p+9 },
+{ INT64_C(0x9ff7fffffffffdff), -0x1.8020000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6008000000002000), 0x1.8020000000008p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffffffdfff), -0x1.8020000000008p+62, -0x1p+0 },
+{ INT64_C(0x6008000000004000), 0x1.802000000001p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffffffbfff), -0x1.802000000001p+62, -0x1p+0 },
+{ INT64_C(0x6008000000040000), 0x1.80200000001p+62, 0x0p+0 },
+{ INT64_C(0x9ff7fffffffbffff), -0x1.80200000001p+62, -0x1p+0 },
+{ INT64_C(0x6008000000200000), 0x1.80200000008p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffffdfffff), -0x1.80200000008p+62, -0x1p+0 },
+{ INT64_C(0x6008000000400000), 0x1.8020000001p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffffbfffff), -0x1.8020000001p+62, -0x1p+0 },
+{ INT64_C(0x6008000002000000), 0x1.8020000008p+62, 0x0p+0 },
+{ INT64_C(0x9ff7fffffdffffff), -0x1.8020000008p+62, -0x1p+0 },
+{ INT64_C(0x6008000010000000), 0x1.802000004p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffefffffff), -0x1.802000004p+62, -0x1p+0 },
+{ INT64_C(0x6008000040000000), 0x1.80200001p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffffbfffffff), -0x1.80200001p+62, -0x1p+0 },
+{ INT64_C(0x6008000400000000), 0x1.8020001p+62, 0x0p+0 },
+{ INT64_C(0x9ff7fffbffffffff), -0x1.8020001p+62, -0x1p+0 },
+{ INT64_C(0x6008002000000000), 0x1.8020008p+62, 0x0p+0 },
+{ INT64_C(0x9ff7ffdfffffffff), -0x1.8020008p+62, -0x1p+0 },
+{ INT64_C(0x6008010000000000), 0x1.802004p+62, 0x0p+0 },
+{ INT64_C(0x9ff7feffffffffff), -0x1.802004p+62, -0x1p+0 },
+{ INT64_C(0x6008100000000000), 0x1.80204p+62, 0x0p+0 },
+{ INT64_C(0x9ff7efffffffffff), -0x1.80204p+62, -0x1p+0 },
+{ INT64_C(0x6008800000000000), 0x1.8022p+62, 0x0p+0 },
+{ INT64_C(0x9ff77fffffffffff), -0x1.8022p+62, -0x1p+0 },
+{ INT64_C(0x600c000000000000), 0x1.803p+62, 0x0p+0 },
+{ INT64_C(0x9ff3ffffffffffff), -0x1.803p+62, -0x1p+0 },
+{ INT64_C(0x6080000000000000), 0x1.82p+62, 0x0p+0 },
+{ INT64_C(0x9f7fffffffffffff), -0x1.82p+62, -0x1p+0 },
+{ INT64_C(0x6080000000000001), 0x1.82p+62, 0x1p+0 },
+{ INT64_C(0x9f7ffffffffffffe), -0x1.82p+62, -0x1p+1 },
+{ INT64_C(0x6080000000000010), 0x1.82p+62, 0x1p+4 },
+{ INT64_C(0x9f7fffffffffffef), -0x1.82p+62, -0x1.1p+4 },
+{ INT64_C(0x6080000000000020), 0x1.82p+62, 0x1p+5 },
+{ INT64_C(0x9f7fffffffffffdf), -0x1.82p+62, -0x1.08p+5 },
+{ INT64_C(0x6080000000000100), 0x1.82p+62, 0x1p+8 },
+{ INT64_C(0x9f7ffffffffffeff), -0x1.82p+62, -0x1.01p+8 },
+{ INT64_C(0x6080000000000200), 0x1.82p+62, 0x1p+9 },
+{ INT64_C(0x9f7ffffffffffdff), -0x1.8200000000001p+62, 0x1.ffp+8 },
+{ INT64_C(0x6080000000000400), 0x1.8200000000001p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffffffffffbff), -0x1.8200000000001p+62, -0x1p+0 },
+{ INT64_C(0x6080000000001000), 0x1.8200000000004p+62, 0x0p+0 },
+{ INT64_C(0x9f7fffffffffefff), -0x1.8200000000004p+62, -0x1p+0 },
+{ INT64_C(0x6080000000008000), 0x1.820000000002p+62, 0x0p+0 },
+{ INT64_C(0x9f7fffffffff7fff), -0x1.820000000002p+62, -0x1p+0 },
+{ INT64_C(0x6080000000020000), 0x1.820000000008p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffffffffdffff), -0x1.820000000008p+62, -0x1p+0 },
+{ INT64_C(0x6080000000100000), 0x1.82000000004p+62, 0x0p+0 },
+{ INT64_C(0x9f7fffffffefffff), -0x1.82000000004p+62, -0x1p+0 },
+{ INT64_C(0x6080000001000000), 0x1.8200000004p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffffffeffffff), -0x1.8200000004p+62, -0x1p+0 },
+{ INT64_C(0x6080000004000000), 0x1.820000001p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffffffbffffff), -0x1.820000001p+62, -0x1p+0 },
+{ INT64_C(0x6080000010000000), 0x1.820000004p+62, 0x0p+0 },
+{ INT64_C(0x9f7fffffefffffff), -0x1.820000004p+62, -0x1p+0 },
+{ INT64_C(0x6080000100000000), 0x1.82000004p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffffeffffffff), -0x1.82000004p+62, -0x1p+0 },
+{ INT64_C(0x6080000800000000), 0x1.8200002p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffff7ffffffff), -0x1.8200002p+62, -0x1p+0 },
+{ INT64_C(0x6080004000000000), 0x1.820001p+62, 0x0p+0 },
+{ INT64_C(0x9f7fffbfffffffff), -0x1.820001p+62, -0x1p+0 },
+{ INT64_C(0x6080040000000000), 0x1.82001p+62, 0x0p+0 },
+{ INT64_C(0x9f7ffbffffffffff), -0x1.82001p+62, -0x1p+0 },
+{ INT64_C(0x6080100000000000), 0x1.82004p+62, 0x0p+0 },
+{ INT64_C(0x9f7fefffffffffff), -0x1.82004p+62, -0x1p+0 },
+{ INT64_C(0x6080800000000000), 0x1.8202p+62, 0x0p+0 },
+{ INT64_C(0x9f7f7fffffffffff), -0x1.8202p+62, -0x1p+0 },
+{ INT64_C(0x6088000000000000), 0x1.822p+62, 0x0p+0 },
+{ INT64_C(0x9f77ffffffffffff), -0x1.822p+62, -0x1p+0 },
+{ INT64_C(0x6090000000000000), 0x1.824p+62, 0x0p+0 },
+{ INT64_C(0x9f6fffffffffffff), -0x1.824p+62, -0x1p+0 },
+{ INT64_C(0x6100000000000000), 0x1.84p+62, 0x0p+0 },
+{ INT64_C(0x9effffffffffffff), -0x1.84p+62, -0x1p+0 },
+{ INT64_C(0x6100000000000008), 0x1.84p+62, 0x1p+3 },
+{ INT64_C(0x9efffffffffffff7), -0x1.84p+62, -0x1.2p+3 },
+{ INT64_C(0x6100000000000020), 0x1.84p+62, 0x1p+5 },
+{ INT64_C(0x9effffffffffffdf), -0x1.84p+62, -0x1.08p+5 },
+{ INT64_C(0x6100000000000040), 0x1.84p+62, 0x1p+6 },
+{ INT64_C(0x9effffffffffffbf), -0x1.84p+62, -0x1.04p+6 },
+{ INT64_C(0x6100000000000080), 0x1.84p+62, 0x1p+7 },
+{ INT64_C(0x9effffffffffff7f), -0x1.84p+62, -0x1.02p+7 },
+{ INT64_C(0x6100000000000800), 0x1.8400000000002p+62, 0x0p+0 },
+{ INT64_C(0x9efffffffffff7ff), -0x1.8400000000002p+62, -0x1p+0 },
+{ INT64_C(0x6100000000008000), 0x1.840000000002p+62, 0x0p+0 },
+{ INT64_C(0x9effffffffff7fff), -0x1.840000000002p+62, -0x1p+0 },
+{ INT64_C(0x6100000000010000), 0x1.840000000004p+62, 0x0p+0 },
+{ INT64_C(0x9efffffffffeffff), -0x1.840000000004p+62, -0x1p+0 },
+{ INT64_C(0x6100000000020000), 0x1.840000000008p+62, 0x0p+0 },
+{ INT64_C(0x9efffffffffdffff), -0x1.840000000008p+62, -0x1p+0 },
+{ INT64_C(0x6100000000080000), 0x1.84000000002p+62, 0x0p+0 },
+{ INT64_C(0x9efffffffff7ffff), -0x1.84000000002p+62, -0x1p+0 },
+{ INT64_C(0x6100000000800000), 0x1.8400000002p+62, 0x0p+0 },
+{ INT64_C(0x9effffffff7fffff), -0x1.8400000002p+62, -0x1p+0 },
+{ INT64_C(0x6100000002000000), 0x1.8400000008p+62, 0x0p+0 },
+{ INT64_C(0x9efffffffdffffff), -0x1.8400000008p+62, -0x1p+0 },
+{ INT64_C(0x6100000010000000), 0x1.840000004p+62, 0x0p+0 },
+{ INT64_C(0x9effffffefffffff), -0x1.840000004p+62, -0x1p+0 },
+{ INT64_C(0x6100000100000000), 0x1.84000004p+62, 0x0p+0 },
+{ INT64_C(0x9efffffeffffffff), -0x1.84000004p+62, -0x1p+0 },
+{ INT64_C(0x6100000400000000), 0x1.8400001p+62, 0x0p+0 },
+{ INT64_C(0x9efffffbffffffff), -0x1.8400001p+62, -0x1p+0 },
+{ INT64_C(0x6100002000000000), 0x1.8400008p+62, 0x0p+0 },
+{ INT64_C(0x9effffdfffffffff), -0x1.8400008p+62, -0x1p+0 },
+{ INT64_C(0x6100020000000000), 0x1.840008p+62, 0x0p+0 },
+{ INT64_C(0x9efffdffffffffff), -0x1.840008p+62, -0x1p+0 },
+{ INT64_C(0x6100040000000000), 0x1.84001p+62, 0x0p+0 },
+{ INT64_C(0x9efffbffffffffff), -0x1.84001p+62, -0x1p+0 },
+{ INT64_C(0x6100080000000000), 0x1.84002p+62, 0x0p+0 },
+{ INT64_C(0x9efff7ffffffffff), -0x1.84002p+62, -0x1p+0 },
+{ INT64_C(0x6100800000000000), 0x1.8402p+62, 0x0p+0 },
+{ INT64_C(0x9eff7fffffffffff), -0x1.8402p+62, -0x1p+0 },
+{ INT64_C(0x6102000000000000), 0x1.8408p+62, 0x0p+0 },
+{ INT64_C(0x9efdffffffffffff), -0x1.8408p+62, -0x1p+0 },
+{ INT64_C(0x6120000000000000), 0x1.848p+62, 0x0p+0 },
+{ INT64_C(0x9edfffffffffffff), -0x1.848p+62, -0x1p+0 },
+{ INT64_C(0x6180000000000000), 0x1.86p+62, 0x0p+0 },
+{ INT64_C(0x9e7fffffffffffff), -0x1.86p+62, -0x1p+0 },
+{ INT64_C(0x7000000000000000), 0x1.cp+62, 0x0p+0 },
+{ INT64_C(0x8fffffffffffffff), -0x1.cp+62, -0x1p+0 },
+{ INT64_C(0x7000000000000001), 0x1.cp+62, 0x1p+0 },
+{ INT64_C(0x8ffffffffffffffe), -0x1.cp+62, -0x1p+1 },
+{ INT64_C(0x7000000000000008), 0x1.cp+62, 0x1p+3 },
+{ INT64_C(0x8ffffffffffffff7), -0x1.cp+62, -0x1.2p+3 },
+{ INT64_C(0x7000000000000020), 0x1.cp+62, 0x1p+5 },
+{ INT64_C(0x8fffffffffffffdf), -0x1.cp+62, -0x1.08p+5 },
+{ INT64_C(0x7000000000000040), 0x1.cp+62, 0x1p+6 },
+{ INT64_C(0x8fffffffffffffbf), -0x1.cp+62, -0x1.04p+6 },
+{ INT64_C(0x7000000000000080), 0x1.cp+62, 0x1p+7 },
+{ INT64_C(0x8fffffffffffff7f), -0x1.cp+62, -0x1.02p+7 },
+{ INT64_C(0x7000000000000800), 0x1.c000000000002p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffffffff7ff), -0x1.c000000000002p+62, -0x1p+0 },
+{ INT64_C(0x7000000000002000), 0x1.c000000000008p+62, 0x0p+0 },
+{ INT64_C(0x8fffffffffffdfff), -0x1.c000000000008p+62, -0x1p+0 },
+{ INT64_C(0x7000000000010000), 0x1.c00000000004p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffffffeffff), -0x1.c00000000004p+62, -0x1p+0 },
+{ INT64_C(0x7000000000040000), 0x1.c0000000001p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffffffbffff), -0x1.c0000000001p+62, -0x1p+0 },
+{ INT64_C(0x7000000000080000), 0x1.c0000000002p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffffff7ffff), -0x1.c0000000002p+62, -0x1p+0 },
+{ INT64_C(0x7000000000800000), 0x1.c000000002p+62, 0x0p+0 },
+{ INT64_C(0x8fffffffff7fffff), -0x1.c000000002p+62, -0x1p+0 },
+{ INT64_C(0x7000000008000000), 0x1.c00000002p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffff7ffffff), -0x1.c00000002p+62, -0x1p+0 },
+{ INT64_C(0x7000000010000000), 0x1.c00000004p+62, 0x0p+0 },
+{ INT64_C(0x8fffffffefffffff), -0x1.c00000004p+62, -0x1p+0 },
+{ INT64_C(0x7000000100000000), 0x1.c0000004p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffeffffffff), -0x1.c0000004p+62, -0x1p+0 },
+{ INT64_C(0x7000000200000000), 0x1.c0000008p+62, 0x0p+0 },
+{ INT64_C(0x8ffffffdffffffff), -0x1.c0000008p+62, -0x1p+0 },
+{ INT64_C(0x7000000800000000), 0x1.c000002p+62, 0x0p+0 },
+{ INT64_C(0x8ffffff7ffffffff), -0x1.c000002p+62, -0x1p+0 },
+{ INT64_C(0x7000008000000000), 0x1.c00002p+62, 0x0p+0 },
+{ INT64_C(0x8fffff7fffffffff), -0x1.c00002p+62, -0x1p+0 },
+{ INT64_C(0x7000010000000000), 0x1.c00004p+62, 0x0p+0 },
+{ INT64_C(0x8ffffeffffffffff), -0x1.c00004p+62, -0x1p+0 },
+{ INT64_C(0x7000080000000000), 0x1.c0002p+62, 0x0p+0 },
+{ INT64_C(0x8ffff7ffffffffff), -0x1.c0002p+62, -0x1p+0 },
+{ INT64_C(0x7000800000000000), 0x1.c002p+62, 0x0p+0 },
+{ INT64_C(0x8fff7fffffffffff), -0x1.c002p+62, -0x1p+0 },
+{ INT64_C(0x7002000000000000), 0x1.c008p+62, 0x0p+0 },
+{ INT64_C(0x8ffdffffffffffff), -0x1.c008p+62, -0x1p+0 },
+{ INT64_C(0x7008000000000000), 0x1.c02p+62, 0x0p+0 },
+{ INT64_C(0x8ff7ffffffffffff), -0x1.c02p+62, -0x1p+0 },
+{ INT64_C(0x7080000000000000), 0x1.c2p+62, 0x0p+0 },
+{ INT64_C(0x8f7fffffffffffff), -0x1.c2p+62, -0x1p+0 },
+{ INT64_C(0x7400000000000000), 0x1.dp+62, 0x0p+0 },
+{ INT64_C(0x8bffffffffffffff), -0x1.dp+62, -0x1p+0 },
+};
+
+static const int numTests = sizeof(tests) / sizeof(struct testCase);
diff --git a/compiler-rt/test/builtins/Unit/ppc/floatunditf_test.c b/compiler-rt/test/builtins/Unit/ppc/floatunditf_test.c
new file mode 100644
index 0000000..4d1ce08
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/floatunditf_test.c
@@ -0,0 +1,30 @@
+#include <stdint.h>
+#include <stdio.h>
+
+COMPILER_RT_ABI long double __floatunditf(uint64_t);
+
+#include "floatunditf_test.h"
+#include "DD.h"
+
+int main(int argc, char *argv[]) {
+	int i;
+	
+	DD expected;
+	DD computed;
+	
+	for (i=0; i<numTests; ++i) {
+		expected.hi = tests[i].hi;
+		expected.lo = tests[i].lo;
+		computed.ld = __floatunditf(tests[i].input);
+		
+		if ((computed.hi != expected.hi) || (computed.lo != expected.lo))
+		{
+			printf("Error on __floatunditf( 0x%016llx ):\n", tests[i].input);
+			printf("\tExpected %La = ( %a , %a )\n", expected.ld, expected.hi, expected.lo);
+			printf("\tComputed %La = ( %a , %a )\n", computed.ld, computed.hi, computed.lo);
+			return 1;
+		}
+	}
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ppc/floatunditf_test.h b/compiler-rt/test/builtins/Unit/ppc/floatunditf_test.h
new file mode 100644
index 0000000..4a42e97
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/floatunditf_test.h
@@ -0,0 +1,19014 @@
+struct testCase {
+	uint64_t input;
+	double hi;
+	double lo;
+};
+
+struct testCase tests[] = {
+{ UINT64_C(0x0000000000000061), 0x1.84p+6, 0x0p+0 },
+{ UINT64_C(0x0000000000000062), 0x1.88p+6, 0x0p+0 },
+{ UINT64_C(0x0000000000000403), 0x1.00cp+10, 0x0p+0 },
+{ UINT64_C(0x000000000000040a), 0x1.028p+10, 0x0p+0 },
+{ UINT64_C(0x000000000000040c), 0x1.03p+10, 0x0p+0 },
+{ UINT64_C(0x000000000000040e), 0x1.038p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000418), 0x1.06p+10, 0x0p+0 },
+{ UINT64_C(0x000000000000041a), 0x1.068p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000504), 0x1.41p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000506), 0x1.418p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000510), 0x1.44p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000518), 0x1.46p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000602), 0x1.808p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000603), 0x1.80cp+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000608), 0x1.82p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000609), 0x1.824p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000640), 0x1.9p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000642), 0x1.908p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000648), 0x1.92p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000660), 0x1.98p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000680), 0x1.ap+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000681), 0x1.a04p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000688), 0x1.a2p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000000690), 0x1.a4p+10, 0x0p+0 },
+{ UINT64_C(0x00000000000006a0), 0x1.a8p+10, 0x0p+0 },
+{ UINT64_C(0x0000000000002003), 0x1.0018p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002009), 0x1.0048p+13, 0x0p+0 },
+{ UINT64_C(0x000000000000200c), 0x1.006p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002082), 0x1.041p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002090), 0x1.048p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002098), 0x1.04cp+13, 0x0p+0 },
+{ UINT64_C(0x00000000000020c0), 0x1.06p+13, 0x0p+0 },
+{ UINT64_C(0x00000000000020c2), 0x1.061p+13, 0x0p+0 },
+{ UINT64_C(0x00000000000020e0), 0x1.07p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002202), 0x1.101p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002208), 0x1.104p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002209), 0x1.1048p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002240), 0x1.12p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002241), 0x1.1208p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002250), 0x1.128p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002404), 0x1.202p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002405), 0x1.2028p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002420), 0x1.21p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002421), 0x1.2108p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002424), 0x1.212p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002430), 0x1.218p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002440), 0x1.22p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002442), 0x1.221p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002450), 0x1.228p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002500), 0x1.28p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002504), 0x1.282p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002508), 0x1.284p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000002520), 0x1.29p+13, 0x0p+0 },
+{ UINT64_C(0x0000000000020041), 0x1.00208p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020042), 0x1.0021p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020050), 0x1.0028p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020051), 0x1.00288p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020060), 0x1.003p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020062), 0x1.0031p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020070), 0x1.0038p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020202), 0x1.0101p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020204), 0x1.0102p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020210), 0x1.0108p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020218), 0x1.010cp+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020300), 0x1.018p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020302), 0x1.0181p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020310), 0x1.0188p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020801), 0x1.04008p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020802), 0x1.0401p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020820), 0x1.041p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020824), 0x1.0412p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020828), 0x1.0414p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020a00), 0x1.05p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020a08), 0x1.0504p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000020a40), 0x1.052p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021002), 0x1.0801p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021020), 0x1.081p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021024), 0x1.0812p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021030), 0x1.0818p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021100), 0x1.088p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021104), 0x1.0882p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021108), 0x1.0884p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021110), 0x1.0888p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021180), 0x1.08cp+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021800), 0x1.0cp+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021804), 0x1.0c02p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021840), 0x1.0c2p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021a00), 0x1.0dp+17, 0x0p+0 },
+{ UINT64_C(0x0000000000021c00), 0x1.0ep+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030008), 0x1.8004p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030020), 0x1.801p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030022), 0x1.8011p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030024), 0x1.8012p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030200), 0x1.81p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030202), 0x1.8101p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030204), 0x1.8102p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030210), 0x1.8108p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030300), 0x1.818p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030400), 0x1.82p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030401), 0x1.82008p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030410), 0x1.8208p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000030500), 0x1.828p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000032000), 0x1.9p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000032004), 0x1.9002p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000032040), 0x1.902p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000032400), 0x1.92p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000032800), 0x1.94p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000033000), 0x1.98p+17, 0x0p+0 },
+{ UINT64_C(0x0000000000040022), 0x1.00088p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040028), 0x1.000ap+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040104), 0x1.0041p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040108), 0x1.0042p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004010a), 0x1.00428p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040120), 0x1.0048p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040128), 0x1.004ap+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040130), 0x1.004cp+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040140), 0x1.005p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000040148), 0x1.0052p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041001), 0x1.04004p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041002), 0x1.04008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041003), 0x1.0400cp+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041004), 0x1.0401p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041010), 0x1.0404p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041018), 0x1.0406p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041040), 0x1.041p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041042), 0x1.04108p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041044), 0x1.0411p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041400), 0x1.05p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041404), 0x1.0501p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041440), 0x1.051p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041600), 0x1.058p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041800), 0x1.06p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041802), 0x1.06008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041820), 0x1.0608p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041840), 0x1.061p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041a00), 0x1.068p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000041c00), 0x1.07p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044008), 0x1.1002p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044080), 0x1.102p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044084), 0x1.1021p+18, 0x0p+0 },
+{ UINT64_C(0x00000000000440c0), 0x1.103p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044200), 0x1.108p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044201), 0x1.10804p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044204), 0x1.1081p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044240), 0x1.109p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044400), 0x1.11p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044402), 0x1.11008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044408), 0x1.1102p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044420), 0x1.1108p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044480), 0x1.112p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044500), 0x1.114p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000044600), 0x1.118p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045000), 0x1.14p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045001), 0x1.14004p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045002), 0x1.14008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045010), 0x1.1404p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045080), 0x1.142p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045100), 0x1.144p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000045200), 0x1.148p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048002), 0x1.20008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048003), 0x1.2000cp+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048010), 0x1.2004p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048018), 0x1.2006p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048040), 0x1.201p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048042), 0x1.20108p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048060), 0x1.2018p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048400), 0x1.21p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048402), 0x1.21008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048410), 0x1.2104p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048440), 0x1.211p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048480), 0x1.212p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000048600), 0x1.218p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a000), 0x1.28p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a004), 0x1.2801p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a008), 0x1.2802p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a010), 0x1.2804p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a080), 0x1.282p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a200), 0x1.288p+18, 0x0p+0 },
+{ UINT64_C(0x000000000004a400), 0x1.29p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060002), 0x1.80008p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060003), 0x1.8000cp+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060010), 0x1.8004p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060012), 0x1.80048p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060080), 0x1.802p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060084), 0x1.8021p+18, 0x0p+0 },
+{ UINT64_C(0x00000000000600c0), 0x1.803p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060200), 0x1.808p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060208), 0x1.8082p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060210), 0x1.8084p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060280), 0x1.80ap+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060800), 0x1.82p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060808), 0x1.8202p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060810), 0x1.8204p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060840), 0x1.821p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060900), 0x1.824p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000060c00), 0x1.83p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000064000), 0x1.9p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000064001), 0x1.90004p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000064008), 0x1.9002p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000064010), 0x1.9004p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000064100), 0x1.904p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000065000), 0x1.94p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000066000), 0x1.98p+18, 0x0p+0 },
+{ UINT64_C(0x0000000000400005), 0x1.000014p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400012), 0x1.000048p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400018), 0x1.00006p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400019), 0x1.000064p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400042), 0x1.000108p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400060), 0x1.00018p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400068), 0x1.0001ap+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400408), 0x1.00102p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400480), 0x1.0012p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400482), 0x1.001208p+22, 0x0p+0 },
+{ UINT64_C(0x00000000004004a0), 0x1.00128p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400600), 0x1.0018p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400608), 0x1.00182p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400610), 0x1.00184p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000400640), 0x1.0019p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402004), 0x1.00801p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402005), 0x1.008014p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402006), 0x1.008018p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402040), 0x1.0081p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402042), 0x1.008108p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402044), 0x1.00811p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402060), 0x1.00818p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402080), 0x1.0082p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402088), 0x1.00822p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402090), 0x1.00824p+22, 0x0p+0 },
+{ UINT64_C(0x00000000004020a0), 0x1.00828p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402400), 0x1.009p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402408), 0x1.00902p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402410), 0x1.00904p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402480), 0x1.0092p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402800), 0x1.00ap+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402808), 0x1.00a02p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402810), 0x1.00a04p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402880), 0x1.00a2p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000402a00), 0x1.00a8p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420004), 0x1.08001p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420040), 0x1.0801p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420044), 0x1.08011p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420048), 0x1.08012p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420200), 0x1.0808p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420208), 0x1.08082p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420220), 0x1.08088p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000420300), 0x1.080cp+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422000), 0x1.088p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422004), 0x1.08801p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422010), 0x1.08804p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422020), 0x1.08808p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422040), 0x1.0881p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422080), 0x1.0882p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422400), 0x1.089p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000422800), 0x1.08ap+22, 0x0p+0 },
+{ UINT64_C(0x0000000000424000), 0x1.09p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000424001), 0x1.090004p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000424008), 0x1.09002p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000424080), 0x1.0902p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000424100), 0x1.0904p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000425000), 0x1.094p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000430000), 0x1.0cp+22, 0x0p+0 },
+{ UINT64_C(0x0000000000430002), 0x1.0c0008p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000430004), 0x1.0c001p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000430020), 0x1.0c008p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000430100), 0x1.0c04p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000430400), 0x1.0c1p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000431000), 0x1.0c4p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000432000), 0x1.0c8p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000438000), 0x1.0ep+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440002), 0x1.100008p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440003), 0x1.10000cp+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440004), 0x1.10001p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440010), 0x1.10004p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440018), 0x1.10006p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440080), 0x1.1002p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440084), 0x1.10021p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440090), 0x1.10024p+22, 0x0p+0 },
+{ UINT64_C(0x00000000004400c0), 0x1.1003p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440100), 0x1.1004p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440104), 0x1.10041p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440140), 0x1.1005p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440180), 0x1.1006p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440400), 0x1.101p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440404), 0x1.10101p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440408), 0x1.10102p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000440480), 0x1.1012p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000444000), 0x1.11p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000444008), 0x1.11002p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000444040), 0x1.1101p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000444100), 0x1.1104p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000444400), 0x1.111p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000445000), 0x1.114p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000446000), 0x1.118p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600002), 0x1.800008p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600004), 0x1.80001p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600040), 0x1.8001p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600044), 0x1.80011p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600050), 0x1.80014p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600100), 0x1.8004p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600102), 0x1.800408p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600110), 0x1.80044p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600120), 0x1.80048p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600140), 0x1.8005p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600180), 0x1.8006p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600200), 0x1.8008p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600201), 0x1.800804p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600202), 0x1.800808p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600204), 0x1.80081p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600240), 0x1.8009p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000600280), 0x1.800ap+22, 0x0p+0 },
+{ UINT64_C(0x0000000000601000), 0x1.804p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000601002), 0x1.804008p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000601020), 0x1.80408p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000601040), 0x1.8041p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000601400), 0x1.805p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000602000), 0x1.808p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000602008), 0x1.80802p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000602020), 0x1.80808p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000602080), 0x1.8082p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000602100), 0x1.8084p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000602200), 0x1.8088p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000603000), 0x1.80cp+22, 0x0p+0 },
+{ UINT64_C(0x0000000000620000), 0x1.88p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000620004), 0x1.88001p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000620040), 0x1.8801p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000620400), 0x1.881p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000622000), 0x1.888p+22, 0x0p+0 },
+{ UINT64_C(0x0000000000628000), 0x1.8ap+22, 0x0p+0 },
+{ UINT64_C(0x0000000004000005), 0x1.0000014p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400000a), 0x1.0000028p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000081), 0x1.0000204p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000082), 0x1.0000208p+26, 0x0p+0 },
+{ UINT64_C(0x00000000040000a0), 0x1.000028p+26, 0x0p+0 },
+{ UINT64_C(0x00000000040000a4), 0x1.000029p+26, 0x0p+0 },
+{ UINT64_C(0x00000000040000a8), 0x1.00002ap+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000201), 0x1.0000804p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000204), 0x1.000081p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000206), 0x1.0000818p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000208), 0x1.000082p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000209), 0x1.0000824p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400020c), 0x1.000083p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000280), 0x1.0000ap+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000282), 0x1.0000a08p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000284), 0x1.0000a1p+26, 0x0p+0 },
+{ UINT64_C(0x00000000040002a0), 0x1.0000a8p+26, 0x0p+0 },
+{ UINT64_C(0x00000000040002c0), 0x1.0000bp+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000401), 0x1.0001004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000408), 0x1.000102p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400040c), 0x1.000103p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000410), 0x1.000104p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000414), 0x1.000105p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000480), 0x1.00012p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004000482), 0x1.0001208p+26, 0x0p+0 },
+{ UINT64_C(0x00000000040004a0), 0x1.000128p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002002), 0x1.0008008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002004), 0x1.000801p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002006), 0x1.0008018p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002040), 0x1.00081p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002041), 0x1.0008104p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002048), 0x1.000812p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002050), 0x1.000814p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002060), 0x1.000818p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002400), 0x1.0009p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002401), 0x1.0009004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002404), 0x1.000901p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002440), 0x1.00091p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002480), 0x1.00092p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002500), 0x1.00094p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004002600), 0x1.00098p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008004), 0x1.002001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008008), 0x1.002002p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400800c), 0x1.002003p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008020), 0x1.002008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008028), 0x1.00200ap+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008200), 0x1.00208p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008202), 0x1.0020808p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008220), 0x1.002088p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008280), 0x1.0020ap+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008300), 0x1.0020cp+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008800), 0x1.0022p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008802), 0x1.0022008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008808), 0x1.002202p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008840), 0x1.00221p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008900), 0x1.00224p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004008a00), 0x1.00228p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400c000), 0x1.003p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400c002), 0x1.0030008p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400c010), 0x1.003004p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400c080), 0x1.00302p+26, 0x0p+0 },
+{ UINT64_C(0x000000000400c800), 0x1.0032p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020008), 0x1.008002p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020009), 0x1.0080024p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020010), 0x1.008004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020018), 0x1.008006p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020100), 0x1.00804p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020108), 0x1.008042p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020110), 0x1.008044p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020120), 0x1.008048p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020180), 0x1.00806p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020800), 0x1.0082p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020808), 0x1.008202p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004020880), 0x1.00822p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004022000), 0x1.0088p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004022001), 0x1.0088004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004022004), 0x1.008801p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004022010), 0x1.008804p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004022100), 0x1.00884p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004023000), 0x1.008cp+26, 0x0p+0 },
+{ UINT64_C(0x0000000004030000), 0x1.00cp+26, 0x0p+0 },
+{ UINT64_C(0x0000000004030004), 0x1.00c001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004030040), 0x1.00c01p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004030080), 0x1.00c02p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004030800), 0x1.00c2p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004038000), 0x1.00ep+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200001), 0x1.0800004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200004), 0x1.080001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200020), 0x1.080008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200024), 0x1.080009p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200040), 0x1.08001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200041), 0x1.0800104p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200044), 0x1.080011p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200060), 0x1.080018p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200100), 0x1.08004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200101), 0x1.0800404p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200104), 0x1.080041p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200110), 0x1.080044p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200800), 0x1.0802p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200808), 0x1.080202p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200820), 0x1.080208p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200840), 0x1.08021p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200880), 0x1.08022p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004200c00), 0x1.0803p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004208000), 0x1.082p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004208001), 0x1.0820004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004208010), 0x1.082004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004208040), 0x1.08201p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004208100), 0x1.08204p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004208200), 0x1.08208p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004209000), 0x1.0824p+26, 0x0p+0 },
+{ UINT64_C(0x000000000420c000), 0x1.083p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004210000), 0x1.084p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004210008), 0x1.084002p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004210040), 0x1.08401p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004210200), 0x1.08408p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004212000), 0x1.0848p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004218000), 0x1.086p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004240000), 0x1.09p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004240008), 0x1.090002p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004240010), 0x1.090004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004240020), 0x1.090008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004240200), 0x1.09008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004241000), 0x1.0904p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004242000), 0x1.0908p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004244000), 0x1.091p+26, 0x0p+0 },
+{ UINT64_C(0x0000000004260000), 0x1.098p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000008), 0x1.400002p+26, 0x0p+0 },
+{ UINT64_C(0x000000000500000c), 0x1.400003p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000020), 0x1.400008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000028), 0x1.40000ap+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000030), 0x1.40000cp+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000200), 0x1.40008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000204), 0x1.400081p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000220), 0x1.400088p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000800), 0x1.4002p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000802), 0x1.4002008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000820), 0x1.400208p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005000a00), 0x1.40028p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005001000), 0x1.4004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005001001), 0x1.4004004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005001010), 0x1.400404p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005001100), 0x1.40044p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008000), 0x1.402p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008001), 0x1.4020004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008010), 0x1.402004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008040), 0x1.40201p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008100), 0x1.40204p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008200), 0x1.40208p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005008800), 0x1.4022p+26, 0x0p+0 },
+{ UINT64_C(0x000000000500c000), 0x1.403p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005010000), 0x1.404p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005010002), 0x1.4040008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005010020), 0x1.404008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005010100), 0x1.40404p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005011000), 0x1.4044p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005012000), 0x1.4048p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005100000), 0x1.44p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005100004), 0x1.440001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005100020), 0x1.440008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005100040), 0x1.44001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005100200), 0x1.44008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005100400), 0x1.4401p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005101000), 0x1.4404p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005104000), 0x1.441p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005140000), 0x1.45p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005200000), 0x1.48p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005200002), 0x1.4800008p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005200010), 0x1.480004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005200040), 0x1.48001p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005200100), 0x1.48004p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005200400), 0x1.4801p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005202000), 0x1.4808p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005204000), 0x1.481p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005208000), 0x1.482p+26, 0x0p+0 },
+{ UINT64_C(0x0000000005240000), 0x1.49p+26, 0x0p+0 },
+{ UINT64_C(0x0000000020000022), 0x1.0000011p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000024), 0x1.0000012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000025), 0x1.00000128p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000028), 0x1.0000014p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000030), 0x1.0000018p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000034), 0x1.000001ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000038), 0x1.000001cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000044), 0x1.0000022p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000050), 0x1.0000028p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000058), 0x1.000002cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000102), 0x1.0000081p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000108), 0x1.0000084p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000010c), 0x1.0000086p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000120), 0x1.000009p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000122), 0x1.0000091p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000128), 0x1.0000094p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000140), 0x1.00000ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000148), 0x1.00000a4p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000160), 0x1.00000bp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000202), 0x1.0000101p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000210), 0x1.0000108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000218), 0x1.000010cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000240), 0x1.000012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000244), 0x1.0000122p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000404), 0x1.0000202p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000420), 0x1.000021p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000421), 0x1.00002108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000422), 0x1.0000211p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000424), 0x1.0000212p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000440), 0x1.000022p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000441), 0x1.00002208p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000448), 0x1.0000224p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000450), 0x1.0000228p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000808), 0x1.0000404p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000080a), 0x1.0000405p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000810), 0x1.0000408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000818), 0x1.000040cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000900), 0x1.000048p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000902), 0x1.0000481p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000920), 0x1.000049p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020000980), 0x1.00004cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008001), 0x1.00040008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008010), 0x1.0004008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008014), 0x1.000400ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008020), 0x1.000401p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008022), 0x1.0004011p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008030), 0x1.0004018p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008100), 0x1.000408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008101), 0x1.00040808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008102), 0x1.0004081p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008108), 0x1.0004084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008180), 0x1.00040cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008200), 0x1.00041p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008201), 0x1.00041008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008210), 0x1.0004108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020008280), 0x1.000414p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a000), 0x1.0005p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a002), 0x1.0005001p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a004), 0x1.0005002p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a010), 0x1.0005008p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a020), 0x1.000501p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a040), 0x1.000502p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a080), 0x1.000504p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000a400), 0x1.00052p+29, 0x0p+0 },
+{ UINT64_C(0x000000002000b000), 0x1.00058p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040002), 0x1.0020001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040008), 0x1.0020004p+29, 0x0p+0 },
+{ UINT64_C(0x000000002004000c), 0x1.0020006p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040040), 0x1.002002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040044), 0x1.0020022p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040400), 0x1.00202p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040408), 0x1.0020204p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040420), 0x1.002021p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020040500), 0x1.002028p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020041000), 0x1.00208p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020041008), 0x1.0020804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020041040), 0x1.002082p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020041400), 0x1.0020ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020050000), 0x1.0028p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020050004), 0x1.0028002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020050010), 0x1.0028008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020050100), 0x1.002808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020050800), 0x1.00284p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020051000), 0x1.00288p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020054000), 0x1.002ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080004), 0x1.0040002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080008), 0x1.0040004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080010), 0x1.0040008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080018), 0x1.004000cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080020), 0x1.004001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080024), 0x1.0040012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080080), 0x1.004004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080084), 0x1.0040042p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200800c0), 0x1.004006p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080200), 0x1.00401p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080202), 0x1.0040101p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080210), 0x1.0040108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080220), 0x1.004011p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020080300), 0x1.004018p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020081000), 0x1.00408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020081008), 0x1.0040804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020081010), 0x1.0040808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020081100), 0x1.004088p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020081800), 0x1.0040cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082000), 0x1.0041p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082008), 0x1.0041004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082010), 0x1.0041008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082020), 0x1.004101p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082040), 0x1.004102p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082080), 0x1.004104p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020082400), 0x1.00412p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200a0000), 0x1.005p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200a0001), 0x1.00500008p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200a0010), 0x1.0050008p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200a0080), 0x1.005004p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200a0800), 0x1.00504p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200a8000), 0x1.0054p+29, 0x0p+0 },
+{ UINT64_C(0x00000000200b0000), 0x1.0058p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100002), 0x1.0080001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100003), 0x1.00800018p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100020), 0x1.008001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100028), 0x1.0080014p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100200), 0x1.00801p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100201), 0x1.00801008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100204), 0x1.0080102p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100240), 0x1.008012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100300), 0x1.008018p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100400), 0x1.00802p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100401), 0x1.00802008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100402), 0x1.0080201p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100410), 0x1.0080208p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100500), 0x1.008028p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100800), 0x1.00804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100802), 0x1.0080401p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100820), 0x1.008041p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020100900), 0x1.008048p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020101000), 0x1.00808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020101008), 0x1.0080804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020101020), 0x1.008081p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020101100), 0x1.008088p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020108000), 0x1.0084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020108002), 0x1.0084001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020108020), 0x1.008401p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020108080), 0x1.008404p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020108200), 0x1.00841p+29, 0x0p+0 },
+{ UINT64_C(0x000000002010a000), 0x1.0085p+29, 0x0p+0 },
+{ UINT64_C(0x000000002010c000), 0x1.0086p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020180000), 0x1.00cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020180008), 0x1.00c0004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020180010), 0x1.00c0008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020180020), 0x1.00c001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020180100), 0x1.00c008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020180800), 0x1.00c04p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020188000), 0x1.00c4p+29, 0x0p+0 },
+{ UINT64_C(0x00000000201a0000), 0x1.00dp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800008), 0x1.0400004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800009), 0x1.04000048p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800010), 0x1.0400008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800012), 0x1.0400009p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800080), 0x1.040004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800082), 0x1.0400041p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800088), 0x1.0400044p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800090), 0x1.0400048p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800100), 0x1.040008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800108), 0x1.0400084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800140), 0x1.04000ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800180), 0x1.04000cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800800), 0x1.04004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800801), 0x1.04004008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800810), 0x1.0400408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800840), 0x1.040042p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020800c00), 0x1.04006p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020801000), 0x1.04008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020801008), 0x1.0400804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020801020), 0x1.040081p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020801080), 0x1.040084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020801400), 0x1.0400ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802000), 0x1.0401p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802004), 0x1.0401002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802040), 0x1.040102p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802080), 0x1.040104p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802100), 0x1.040108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802200), 0x1.04011p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020802400), 0x1.04012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020808000), 0x1.0404p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020808001), 0x1.04040008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020808010), 0x1.0404008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020808080), 0x1.040404p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020808100), 0x1.040408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020809000), 0x1.04048p+29, 0x0p+0 },
+{ UINT64_C(0x000000002080a000), 0x1.0405p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810000), 0x1.0408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810001), 0x1.04080008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810002), 0x1.0408001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810004), 0x1.0408002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810020), 0x1.040801p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810040), 0x1.040802p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810100), 0x1.040808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020810400), 0x1.04082p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020814000), 0x1.040ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020900000), 0x1.048p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020900004), 0x1.0480002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020900040), 0x1.048002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020900100), 0x1.048008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020900800), 0x1.04804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020901000), 0x1.04808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020908000), 0x1.0484p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020910000), 0x1.0488p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020940000), 0x1.04ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a00000), 0x1.05p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a00008), 0x1.0500004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a00010), 0x1.0500008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a00040), 0x1.050002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a00400), 0x1.05002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a01000), 0x1.05008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a08000), 0x1.0504p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020a10000), 0x1.0508p+29, 0x0p+0 },
+{ UINT64_C(0x0000000020b00000), 0x1.058p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000008), 0x1.2000004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000040), 0x1.200002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000042), 0x1.2000021p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000050), 0x1.2000028p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000200), 0x1.20001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000201), 0x1.20001008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000202), 0x1.2000101p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000204), 0x1.2000102p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000210), 0x1.2000108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024000300), 0x1.200018p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024001000), 0x1.20008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024001002), 0x1.2000801p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024001008), 0x1.2000804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024001040), 0x1.200082p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024001100), 0x1.200088p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024001800), 0x1.2000cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002000), 0x1.2001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002002), 0x1.2001001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002004), 0x1.2001002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002020), 0x1.200101p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002080), 0x1.200104p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002400), 0x1.20012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024002800), 0x1.20014p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024010000), 0x1.2008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024010008), 0x1.2008004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024010020), 0x1.200801p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024010080), 0x1.200804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024010100), 0x1.200808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024010800), 0x1.20084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024011000), 0x1.20088p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040000), 0x1.202p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040008), 0x1.2020004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040010), 0x1.2020008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040040), 0x1.202002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040080), 0x1.202004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040100), 0x1.202008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024040800), 0x1.20204p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024041000), 0x1.20208p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024042000), 0x1.2021p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024060000), 0x1.203p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024400000), 0x1.22p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024400001), 0x1.22000008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024400010), 0x1.2200008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024400100), 0x1.220008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024400200), 0x1.22001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024400800), 0x1.22004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024408000), 0x1.2204p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024420000), 0x1.221p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024500000), 0x1.228p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024800000), 0x1.24p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024800002), 0x1.2400001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024800004), 0x1.2400002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024800010), 0x1.2400008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024800040), 0x1.240002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024800100), 0x1.240008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024801000), 0x1.24008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024810000), 0x1.2408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000024900000), 0x1.248p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000004), 0x1.4000002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000006), 0x1.4000003p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000020), 0x1.400001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000021), 0x1.40000108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000024), 0x1.4000012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000040), 0x1.400002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000041), 0x1.40000208p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000048), 0x1.4000024p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000060), 0x1.400003p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000080), 0x1.400004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000081), 0x1.40000408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000090), 0x1.4000048p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000100), 0x1.400008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000108), 0x1.4000084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000140), 0x1.40000ap+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000200), 0x1.40001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000208), 0x1.4000104p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000210), 0x1.4000108p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000220), 0x1.400011p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028000240), 0x1.400012p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001000), 0x1.40008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001001), 0x1.40008008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001004), 0x1.4000802p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001008), 0x1.4000804p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001010), 0x1.4000808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001100), 0x1.400088p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028001200), 0x1.40009p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010000), 0x1.4008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010001), 0x1.40080008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010004), 0x1.4008002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010010), 0x1.4008008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010040), 0x1.400802p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010200), 0x1.40081p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028010800), 0x1.40084p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028012000), 0x1.4009p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028040000), 0x1.402p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028040008), 0x1.4020004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028040040), 0x1.402002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028040080), 0x1.402004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028040100), 0x1.402008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028040800), 0x1.40204p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028044000), 0x1.4022p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028060000), 0x1.403p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028100000), 0x1.408p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028100004), 0x1.4080002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028100010), 0x1.4080008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028100040), 0x1.408002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028100080), 0x1.408004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028100100), 0x1.408008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028101000), 0x1.40808p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028110000), 0x1.4088p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028180000), 0x1.40cp+29, 0x0p+0 },
+{ UINT64_C(0x0000000028400000), 0x1.42p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028400001), 0x1.42000008p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028400002), 0x1.4200001p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028400008), 0x1.4200004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028400040), 0x1.420002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028400400), 0x1.42002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028404000), 0x1.4202p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028410000), 0x1.4208p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028440000), 0x1.422p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028480000), 0x1.424p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028500000), 0x1.428p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028800000), 0x1.44p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028800008), 0x1.4400004p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028800040), 0x1.440002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028800400), 0x1.44002p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028804000), 0x1.4402p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028808000), 0x1.4404p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028880000), 0x1.444p+29, 0x0p+0 },
+{ UINT64_C(0x0000000028c00000), 0x1.46p+29, 0x0p+0 },
+{ UINT64_C(0x0000000080000006), 0x1.0000000cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000048), 0x1.0000009p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000049), 0x1.00000092p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000004a), 0x1.00000094p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000088), 0x1.0000011p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000008a), 0x1.00000114p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000008c), 0x1.00000118p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000090), 0x1.0000012p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000092), 0x1.00000124p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000401), 0x1.00000802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000408), 0x1.0000081p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000040a), 0x1.00000814p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000040c), 0x1.00000818p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000480), 0x1.000009p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080000488), 0x1.0000091p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800004a0), 0x1.0000094p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800004c0), 0x1.0000098p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001008), 0x1.0000201p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000100c), 0x1.00002018p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001020), 0x1.0000204p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001024), 0x1.00002048p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001028), 0x1.0000205p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001200), 0x1.000024p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001208), 0x1.0000241p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001220), 0x1.0000244p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001240), 0x1.0000248p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001280), 0x1.000025p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001300), 0x1.000026p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001400), 0x1.000028p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001402), 0x1.00002804p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001404), 0x1.00002808p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001420), 0x1.0000284p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080001600), 0x1.00002cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002001), 0x1.00004002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002010), 0x1.0000402p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002014), 0x1.00004028p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002080), 0x1.000041p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002082), 0x1.00004104p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002090), 0x1.0000412p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800020a0), 0x1.0000414p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002800), 0x1.00005p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002804), 0x1.00005008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002808), 0x1.0000501p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002810), 0x1.0000502p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080002900), 0x1.000052p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008001), 0x1.00010002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008008), 0x1.0001001p+31, 0x0p+0 },
+{ UINT64_C(0x000000008000800a), 0x1.00010014p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008080), 0x1.000101p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008088), 0x1.0001011p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008090), 0x1.0001012p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008100), 0x1.000102p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008108), 0x1.0001021p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008180), 0x1.000103p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008200), 0x1.000104p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008201), 0x1.00010402p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008208), 0x1.0001041p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080008240), 0x1.0001048p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080009000), 0x1.00012p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080009002), 0x1.00012004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080009008), 0x1.0001201p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080009080), 0x1.000121p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080009800), 0x1.00013p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080002), 0x1.00100004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080010), 0x1.0010002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080018), 0x1.0010003p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080020), 0x1.0010004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080028), 0x1.0010005p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080030), 0x1.0010006p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080040), 0x1.0010008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080042), 0x1.00100084p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080050), 0x1.001000ap+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080080), 0x1.001001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080088), 0x1.0010011p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800800c0), 0x1.0010018p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080800), 0x1.00101p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080802), 0x1.00101004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080810), 0x1.0010102p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080880), 0x1.001011p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080080a00), 0x1.001014p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080081000), 0x1.00102p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080081002), 0x1.00102004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080081008), 0x1.0010201p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080081080), 0x1.001021p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080081400), 0x1.001028p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080081800), 0x1.00103p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080082000), 0x1.00104p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080082008), 0x1.0010401p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080082040), 0x1.0010408p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080082100), 0x1.001042p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080082200), 0x1.001044p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080082800), 0x1.00105p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080084000), 0x1.00108p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080084001), 0x1.00108002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080084002), 0x1.00108004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080084010), 0x1.0010802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080084020), 0x1.0010804p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080084200), 0x1.001084p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080086000), 0x1.0010cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000080088000), 0x1.0011p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080088008), 0x1.0011001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080088020), 0x1.0011004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080088040), 0x1.0011008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080088200), 0x1.001104p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080088800), 0x1.00111p+31, 0x0p+0 },
+{ UINT64_C(0x000000008008c000), 0x1.00118p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800a0000), 0x1.0014p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800a0004), 0x1.00140008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800a0040), 0x1.0014008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800a0100), 0x1.001402p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800a1000), 0x1.00142p+31, 0x0p+0 },
+{ UINT64_C(0x00000000800b0000), 0x1.0016p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400004), 0x1.00800008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400040), 0x1.0080008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400044), 0x1.00800088p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400100), 0x1.008002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400104), 0x1.00800208p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400108), 0x1.0080021p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400180), 0x1.008003p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400800), 0x1.00801p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400808), 0x1.0080101p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400810), 0x1.0080102p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400820), 0x1.0080104p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400840), 0x1.0080108p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080400880), 0x1.008011p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080401000), 0x1.00802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080401008), 0x1.0080201p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080401020), 0x1.0080204p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080401040), 0x1.0080208p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080401200), 0x1.008024p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080401400), 0x1.008028p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080404000), 0x1.00808p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080404002), 0x1.00808004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080404010), 0x1.0080802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080404100), 0x1.008082p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080404800), 0x1.00809p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080406000), 0x1.0080cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000080408000), 0x1.0081p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080408004), 0x1.00810008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080408020), 0x1.0081004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080408080), 0x1.008101p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080408200), 0x1.008104p+31, 0x0p+0 },
+{ UINT64_C(0x000000008040a000), 0x1.00814p+31, 0x0p+0 },
+{ UINT64_C(0x000000008040c000), 0x1.00818p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440000), 0x1.0088p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440002), 0x1.00880004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440020), 0x1.0088004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440080), 0x1.008801p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440100), 0x1.008802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440400), 0x1.008808p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080440800), 0x1.00881p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080448000), 0x1.0089p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080480000), 0x1.009p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080480002), 0x1.00900004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080480020), 0x1.0090004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080480040), 0x1.0090008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080480400), 0x1.009008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080484000), 0x1.00908p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080490000), 0x1.0092p+31, 0x0p+0 },
+{ UINT64_C(0x00000000804a0000), 0x1.0094p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080500000), 0x1.00ap+31, 0x0p+0 },
+{ UINT64_C(0x0000000080500008), 0x1.00a0001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080500080), 0x1.00a001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080500400), 0x1.00a008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080502000), 0x1.00a04p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080520000), 0x1.00a4p+31, 0x0p+0 },
+{ UINT64_C(0x0000000080580000), 0x1.00bp+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000004), 0x1.08000008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000006), 0x1.0800000cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000040), 0x1.0800008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000044), 0x1.08000088p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000060), 0x1.080000cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000200), 0x1.080004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000201), 0x1.08000402p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000204), 0x1.08000408p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000208), 0x1.0800041p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000240), 0x1.0800048p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000800), 0x1.08001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000801), 0x1.08001002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000810), 0x1.0800102p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084000880), 0x1.080011p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084001000), 0x1.08002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084001004), 0x1.08002008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084001008), 0x1.0800201p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084001010), 0x1.0800202p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084001100), 0x1.080022p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084001800), 0x1.08003p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008000), 0x1.0801p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008001), 0x1.08010002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008002), 0x1.08010004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008008), 0x1.0801001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008020), 0x1.0801004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008080), 0x1.080101p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084008800), 0x1.08011p+31, 0x0p+0 },
+{ UINT64_C(0x000000008400a000), 0x1.08014p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084010000), 0x1.0802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084010002), 0x1.08020004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084010020), 0x1.0802004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084010200), 0x1.080204p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084012000), 0x1.08024p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084100000), 0x1.082p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084100001), 0x1.08200002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084100010), 0x1.0820002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084100040), 0x1.0820008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084100200), 0x1.082004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084101000), 0x1.08202p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084102000), 0x1.08204p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084108000), 0x1.0821p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084120000), 0x1.0824p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400000), 0x1.088p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400001), 0x1.08800002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400008), 0x1.0880001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400020), 0x1.0880004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400100), 0x1.088002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400400), 0x1.088008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084400800), 0x1.08801p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084401000), 0x1.08802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084408000), 0x1.0881p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084420000), 0x1.0884p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084480000), 0x1.089p+31, 0x0p+0 },
+{ UINT64_C(0x0000000084600000), 0x1.08cp+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000000), 0x1.0ap+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000001), 0x1.0a000002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000002), 0x1.0a000004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000020), 0x1.0a00004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000080), 0x1.0a0001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000400), 0x1.0a0008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085000800), 0x1.0a001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085008000), 0x1.0a01p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085080000), 0x1.0a1p+31, 0x0p+0 },
+{ UINT64_C(0x0000000085100000), 0x1.0a2p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000002), 0x1.20000004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000020), 0x1.2000004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000024), 0x1.20000048p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000028), 0x1.2000005p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000200), 0x1.200004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000204), 0x1.20000408p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000208), 0x1.2000041p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000210), 0x1.2000042p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000240), 0x1.2000048p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000400), 0x1.200008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000401), 0x1.20000802p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000410), 0x1.2000082p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090000500), 0x1.20000ap+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002000), 0x1.20004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002001), 0x1.20004002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002010), 0x1.2000402p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002020), 0x1.2000404p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002080), 0x1.200041p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002100), 0x1.200042p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090002400), 0x1.200048p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090008000), 0x1.2001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090008008), 0x1.2001001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090008010), 0x1.2001002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090008080), 0x1.200101p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090008400), 0x1.200108p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090008800), 0x1.20011p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090080000), 0x1.201p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090080004), 0x1.20100008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090080040), 0x1.2010008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090080200), 0x1.201004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090082000), 0x1.20104p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090084000), 0x1.20108p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090090000), 0x1.2012p+31, 0x0p+0 },
+{ UINT64_C(0x00000000900a0000), 0x1.2014p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090200000), 0x1.204p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090200008), 0x1.2040001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090200020), 0x1.2040004p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090200100), 0x1.204002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090201000), 0x1.20402p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090208000), 0x1.2041p+31, 0x0p+0 },
+{ UINT64_C(0x0000000090280000), 0x1.205p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091000000), 0x1.22p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091000004), 0x1.22000008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091000010), 0x1.2200002p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091000080), 0x1.220001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091000400), 0x1.220008p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091000800), 0x1.22001p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091008000), 0x1.2201p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091080000), 0x1.221p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091200000), 0x1.224p+31, 0x0p+0 },
+{ UINT64_C(0x0000000091800000), 0x1.23p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000004), 0x1.80000008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000006), 0x1.8000000cp+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000040), 0x1.8000008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000041), 0x1.80000082p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000042), 0x1.80000084p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000048), 0x1.8000009p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000400), 0x1.800008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000408), 0x1.8000081p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000420), 0x1.8000084p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000480), 0x1.800009p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000800), 0x1.80001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000801), 0x1.80001002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000808), 0x1.8000101p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000840), 0x1.8000108p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0000c00), 0x1.800018p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0008000), 0x1.8001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0008001), 0x1.80010002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0008008), 0x1.8001001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0008040), 0x1.8001008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0008100), 0x1.800102p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0008800), 0x1.80011p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c000a000), 0x1.80014p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0040000), 0x1.8008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0040004), 0x1.80080008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0040040), 0x1.8008008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0040200), 0x1.800804p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0042000), 0x1.80084p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0060000), 0x1.800cp+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0200000), 0x1.804p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0200008), 0x1.8040001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0200020), 0x1.8040004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0200200), 0x1.804004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0200400), 0x1.804008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0201000), 0x1.80402p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0210000), 0x1.8042p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0280000), 0x1.805p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0400000), 0x1.808p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0400004), 0x1.80800008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0400040), 0x1.8080008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0400400), 0x1.808008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0404000), 0x1.80808p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0420000), 0x1.8084p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0480000), 0x1.809p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0600000), 0x1.80cp+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0800000), 0x1.81p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0800001), 0x1.81000002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0800010), 0x1.8100002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0800100), 0x1.810002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0800800), 0x1.81001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0802000), 0x1.81004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0810000), 0x1.8102p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0880000), 0x1.811p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0a00000), 0x1.814p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c0c00000), 0x1.818p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1000000), 0x1.82p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1000004), 0x1.82000008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1000020), 0x1.8200004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1000100), 0x1.820002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1000800), 0x1.82001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1004000), 0x1.82008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1008000), 0x1.8201p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1080000), 0x1.821p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1200000), 0x1.824p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c1800000), 0x1.83p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8000000), 0x1.9p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8000004), 0x1.90000008p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8000008), 0x1.9000001p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8000020), 0x1.9000004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8000200), 0x1.900004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8002000), 0x1.90004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8010000), 0x1.9002p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8020000), 0x1.9004p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8080000), 0x1.901p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8100000), 0x1.902p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c8400000), 0x1.908p+31, 0x0p+0 },
+{ UINT64_C(0x00000000c9000000), 0x1.92p+31, 0x0p+0 },
+{ UINT64_C(0x000000080000000a), 0x1.000000014p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000022), 0x1.000000044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000024), 0x1.000000048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000025), 0x1.00000004ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000026), 0x1.00000004cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000041), 0x1.000000082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000048), 0x1.00000009p+35, 0x0p+0 },
+{ UINT64_C(0x000000080000004c), 0x1.000000098p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000102), 0x1.000000204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000120), 0x1.00000024p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000121), 0x1.000000242p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000130), 0x1.00000026p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000140), 0x1.00000028p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000144), 0x1.000000288p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800000160), 0x1.0000002cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001002), 0x1.000002004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001020), 0x1.00000204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001022), 0x1.000002044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001024), 0x1.000002048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001028), 0x1.00000205p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001030), 0x1.00000206p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001200), 0x1.0000024p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001208), 0x1.00000241p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001220), 0x1.00000244p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800001300), 0x1.0000026p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004001), 0x1.000008002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004008), 0x1.00000801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004009), 0x1.000008012p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004080), 0x1.0000081p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004081), 0x1.000008102p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004088), 0x1.00000811p+35, 0x0p+0 },
+{ UINT64_C(0x00000008000040c0), 0x1.00000818p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004800), 0x1.000009p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004801), 0x1.000009002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004802), 0x1.000009004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004808), 0x1.00000901p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004820), 0x1.00000904p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004880), 0x1.0000091p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800004a00), 0x1.0000094p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800005000), 0x1.00000ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000800005001), 0x1.00000a002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800005002), 0x1.00000a004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800005020), 0x1.00000a04p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800005080), 0x1.00000a1p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800005400), 0x1.00000a8p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040002), 0x1.000080004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040010), 0x1.00008002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040018), 0x1.00008003p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040040), 0x1.00008008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040042), 0x1.000080084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040060), 0x1.0000800cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040200), 0x1.0000804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040204), 0x1.000080408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040220), 0x1.00008044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800040280), 0x1.0000805p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800041000), 0x1.000082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800041002), 0x1.000082004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800041020), 0x1.00008204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800041200), 0x1.0000824p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800050000), 0x1.0000ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000800050008), 0x1.0000a001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800050020), 0x1.0000a004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800050100), 0x1.0000a02p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800050800), 0x1.0000a1p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800058000), 0x1.0000bp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800060000), 0x1.0000cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800060008), 0x1.0000c001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800060080), 0x1.0000c01p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800060400), 0x1.0000c08p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800061000), 0x1.0000c2p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800068000), 0x1.0000dp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800070000), 0x1.0000ep+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100008), 0x1.00020001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100009), 0x1.000200012p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100040), 0x1.00020008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100044), 0x1.000200088p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100200), 0x1.0002004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100204), 0x1.000200408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100220), 0x1.00020044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800100300), 0x1.0002006p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800101000), 0x1.000202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800101001), 0x1.000202002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800101002), 0x1.000202004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800101020), 0x1.00020204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800101080), 0x1.0002021p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800101400), 0x1.0002028p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102000), 0x1.000204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102001), 0x1.000204002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102002), 0x1.000204004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102008), 0x1.00020401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102010), 0x1.00020402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102020), 0x1.00020404p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102040), 0x1.00020408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102100), 0x1.0002042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800102400), 0x1.0002048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800120000), 0x1.00024p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800120002), 0x1.000240004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800120008), 0x1.00024001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800120080), 0x1.0002401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800120800), 0x1.000241p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800122000), 0x1.000244p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800128000), 0x1.00025p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800140000), 0x1.00028p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800140004), 0x1.000280008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800140010), 0x1.00028002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800140020), 0x1.00028004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800140200), 0x1.0002804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800141000), 0x1.000282p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800142000), 0x1.000284p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800144000), 0x1.000288p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800160000), 0x1.0002cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200002), 0x1.000400004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200003), 0x1.000400006p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200004), 0x1.000400008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200008), 0x1.00040001p+35, 0x0p+0 },
+{ UINT64_C(0x000000080020000c), 0x1.000400018p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200020), 0x1.00040004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200024), 0x1.000400048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200030), 0x1.00040006p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200200), 0x1.0004004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200204), 0x1.000400408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200210), 0x1.00040042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200280), 0x1.0004005p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200800), 0x1.000401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200802), 0x1.000401004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200810), 0x1.00040102p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200820), 0x1.00040104p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800200900), 0x1.0004012p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800204000), 0x1.000408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800204008), 0x1.00040801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800204020), 0x1.00040804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800204080), 0x1.0004081p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800204200), 0x1.0004084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800206000), 0x1.00040cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000800208000), 0x1.00041p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800208004), 0x1.000410008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800208040), 0x1.00041008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800208100), 0x1.0004102p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800208800), 0x1.000411p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800240000), 0x1.00048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800240004), 0x1.000480008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800240020), 0x1.00048004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800240100), 0x1.0004802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800241000), 0x1.000482p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800250000), 0x1.0004ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000800300000), 0x1.0006p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800300008), 0x1.00060001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800300040), 0x1.00060008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800300200), 0x1.0006004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800300400), 0x1.0006008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800304000), 0x1.000608p+35, 0x0p+0 },
+{ UINT64_C(0x0000000800340000), 0x1.00068p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000004), 0x1.002000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000008), 0x1.00200001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000009), 0x1.002000012p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000040), 0x1.00200008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000041), 0x1.002000082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000044), 0x1.002000088p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000048), 0x1.00200009p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000200), 0x1.0020004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000201), 0x1.002000402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000202), 0x1.002000404p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000220), 0x1.00200044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000800), 0x1.002001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000804), 0x1.002001008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000820), 0x1.00200104p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801000900), 0x1.0020012p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801004000), 0x1.002008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801004008), 0x1.00200801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801004010), 0x1.00200802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801004100), 0x1.0020082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801004200), 0x1.0020084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801005000), 0x1.00200ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000801006000), 0x1.00200cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020000), 0x1.00204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020004), 0x1.002040008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020020), 0x1.00204004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020080), 0x1.0020401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020200), 0x1.0020404p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020400), 0x1.0020408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801020800), 0x1.002041p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801022000), 0x1.002044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801028000), 0x1.00205p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040000), 0x1.00208p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040004), 0x1.002080008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040008), 0x1.00208001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040010), 0x1.00208002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040100), 0x1.0020802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040200), 0x1.0020804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801040400), 0x1.0020808p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801044000), 0x1.002088p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801048000), 0x1.00209p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801060000), 0x1.0020cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000801100000), 0x1.0022p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801100004), 0x1.002200008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801100010), 0x1.00220002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801100040), 0x1.00220008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801100400), 0x1.0022008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801101000), 0x1.002202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801110000), 0x1.00222p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801800000), 0x1.003p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801800001), 0x1.003000002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801800004), 0x1.003000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801800010), 0x1.00300002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801800100), 0x1.0030002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801801000), 0x1.003002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801804000), 0x1.003008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801810000), 0x1.00302p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801840000), 0x1.00308p+35, 0x0p+0 },
+{ UINT64_C(0x0000000801900000), 0x1.0032p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000008), 0x1.00800001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000009), 0x1.008000012p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000010), 0x1.00800002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000018), 0x1.00800003p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000080), 0x1.0080001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000081), 0x1.008000102p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000082), 0x1.008000104p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000088), 0x1.00800011p+35, 0x0p+0 },
+{ UINT64_C(0x00000008040000c0), 0x1.00800018p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000200), 0x1.0080004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000202), 0x1.008000404p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000210), 0x1.00800042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804000300), 0x1.0080006p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002000), 0x1.008004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002002), 0x1.008004004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002010), 0x1.00800402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002100), 0x1.0080042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002200), 0x1.0080044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002400), 0x1.0080048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804002800), 0x1.008005p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804020000), 0x1.00804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804020002), 0x1.008040004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804020020), 0x1.00804004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804020200), 0x1.0080404p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804020400), 0x1.0080408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804020800), 0x1.008041p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804024000), 0x1.008048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804030000), 0x1.00806p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804080000), 0x1.0081p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804080004), 0x1.008100008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804080008), 0x1.00810001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804080080), 0x1.0081001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804080800), 0x1.008101p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804082000), 0x1.008104p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804090000), 0x1.00812p+35, 0x0p+0 },
+{ UINT64_C(0x00000008040c0000), 0x1.00818p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804400000), 0x1.0088p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804400004), 0x1.008800008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804400020), 0x1.00880004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804400040), 0x1.00880008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804400080), 0x1.0088001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804400200), 0x1.0088004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804401000), 0x1.008802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804408000), 0x1.00881p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804420000), 0x1.00884p+35, 0x0p+0 },
+{ UINT64_C(0x0000000804600000), 0x1.008cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000806000000), 0x1.00cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000806000002), 0x1.00c000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000806000020), 0x1.00c00004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000806000040), 0x1.00c00008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000806000200), 0x1.00c0004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000806002000), 0x1.00c004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000806010000), 0x1.00c02p+35, 0x0p+0 },
+{ UINT64_C(0x0000000806100000), 0x1.00c2p+35, 0x0p+0 },
+{ UINT64_C(0x0000000807000000), 0x1.00ep+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000004), 0x1.080000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000006), 0x1.08000000cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000020), 0x1.08000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000021), 0x1.080000042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000030), 0x1.08000006p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000200), 0x1.0800004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000201), 0x1.080000402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000210), 0x1.08000042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000220), 0x1.08000044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840000280), 0x1.0800005p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840002000), 0x1.080004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840002002), 0x1.080004004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840002020), 0x1.08000404p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840002100), 0x1.0800042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840002800), 0x1.080005p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004000), 0x1.080008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004001), 0x1.080008002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004008), 0x1.08000801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004020), 0x1.08000804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004080), 0x1.0800081p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004100), 0x1.0800082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840004200), 0x1.0800084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840005000), 0x1.08000ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000840040000), 0x1.08008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840040008), 0x1.08008001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840040040), 0x1.08008008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840040080), 0x1.0800801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840040800), 0x1.080081p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840048000), 0x1.08009p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840050000), 0x1.0800ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000840060000), 0x1.0800cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000840100000), 0x1.0802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840100002), 0x1.080200004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840100008), 0x1.08020001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840100080), 0x1.0802001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840100400), 0x1.0802008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840101000), 0x1.080202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840110000), 0x1.08022p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200000), 0x1.0804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200001), 0x1.080400002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200002), 0x1.080400004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200008), 0x1.08040001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200010), 0x1.08040002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200020), 0x1.08040004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200080), 0x1.0804001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200200), 0x1.0804004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840200800), 0x1.080401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840208000), 0x1.08041p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840210000), 0x1.08042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000840280000), 0x1.0805p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842000000), 0x1.084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842000004), 0x1.084000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842000010), 0x1.08400002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842000080), 0x1.0840001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842000200), 0x1.0840004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842000800), 0x1.084001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842002000), 0x1.084004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842010000), 0x1.08402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842040000), 0x1.08408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000842400000), 0x1.0848p+35, 0x0p+0 },
+{ UINT64_C(0x0000000843000000), 0x1.086p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000000), 0x1.088p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000001), 0x1.088000002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000002), 0x1.088000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000008), 0x1.08800001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000020), 0x1.08800004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000200), 0x1.0880004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844000800), 0x1.088001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844008000), 0x1.08801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844040000), 0x1.08808p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844080000), 0x1.0881p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844200000), 0x1.0884p+35, 0x0p+0 },
+{ UINT64_C(0x0000000844400000), 0x1.0888p+35, 0x0p+0 },
+{ UINT64_C(0x0000000846000000), 0x1.08cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000848000000), 0x1.09p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848000008), 0x1.09000001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848000080), 0x1.0900001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848000800), 0x1.090001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848004000), 0x1.090008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848010000), 0x1.09002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848100000), 0x1.0902p+35, 0x0p+0 },
+{ UINT64_C(0x0000000848800000), 0x1.091p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000000), 0x1.0ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000002), 0x1.0a0000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000008), 0x1.0a000001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000010), 0x1.0a000002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000080), 0x1.0a00001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000200), 0x1.0a00004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850000400), 0x1.0a00008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850002000), 0x1.0a0004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850020000), 0x1.0a004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850080000), 0x1.0a01p+35, 0x0p+0 },
+{ UINT64_C(0x0000000850400000), 0x1.0a08p+35, 0x0p+0 },
+{ UINT64_C(0x0000000852000000), 0x1.0a4p+35, 0x0p+0 },
+{ UINT64_C(0x0000000858000000), 0x1.0bp+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000002), 0x1.100000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000008), 0x1.10000001p+35, 0x0p+0 },
+{ UINT64_C(0x000000088000000c), 0x1.100000018p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000040), 0x1.10000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000041), 0x1.100000082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000048), 0x1.10000009p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000200), 0x1.1000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000201), 0x1.100000402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000210), 0x1.10000042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000220), 0x1.10000044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880000280), 0x1.1000005p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880002000), 0x1.100004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880002001), 0x1.100004002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880002004), 0x1.100004008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880002008), 0x1.10000401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880002040), 0x1.10000408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880002200), 0x1.1000044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880004000), 0x1.100008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880004004), 0x1.100008008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880004010), 0x1.10000802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880004020), 0x1.10000804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880004200), 0x1.1000084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880005000), 0x1.10000ap+35, 0x0p+0 },
+{ UINT64_C(0x0000000880020000), 0x1.10004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880020008), 0x1.10004001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880020080), 0x1.1000401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880020400), 0x1.1000408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880022000), 0x1.100044p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880080000), 0x1.1001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880080008), 0x1.10010001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880080080), 0x1.1001001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880080400), 0x1.1001008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880084000), 0x1.100108p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880088000), 0x1.10011p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880090000), 0x1.10012p+35, 0x0p+0 },
+{ UINT64_C(0x00000008800a0000), 0x1.10014p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200000), 0x1.1004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200001), 0x1.100400002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200004), 0x1.100400008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200008), 0x1.10040001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200020), 0x1.10040004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200040), 0x1.10040008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200080), 0x1.1004001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200200), 0x1.1004004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880200800), 0x1.100401p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880208000), 0x1.10041p+35, 0x0p+0 },
+{ UINT64_C(0x0000000880240000), 0x1.10048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881000000), 0x1.102p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881000004), 0x1.102000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881000008), 0x1.10200001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881000080), 0x1.1020001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881000200), 0x1.1020004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881000800), 0x1.102001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881001000), 0x1.102002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881010000), 0x1.10202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881020000), 0x1.10204p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881100000), 0x1.1022p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881200000), 0x1.1024p+35, 0x0p+0 },
+{ UINT64_C(0x0000000881800000), 0x1.103p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884000000), 0x1.108p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884000008), 0x1.10800001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884000010), 0x1.10800002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884000080), 0x1.1080001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884000400), 0x1.1080008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884001000), 0x1.108002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884010000), 0x1.10802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884100000), 0x1.1082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000884800000), 0x1.109p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888000000), 0x1.11p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888000008), 0x1.11000001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888000080), 0x1.1100001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888000400), 0x1.1100008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888004000), 0x1.110008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888010000), 0x1.11002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888100000), 0x1.1102p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888200000), 0x1.1104p+35, 0x0p+0 },
+{ UINT64_C(0x0000000888400000), 0x1.1108p+35, 0x0p+0 },
+{ UINT64_C(0x0000000889000000), 0x1.112p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000004), 0x1.400000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000020), 0x1.40000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000021), 0x1.400000042p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000024), 0x1.400000048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000028), 0x1.40000005p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000100), 0x1.4000002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000108), 0x1.40000021p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00000140), 0x1.40000028p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00001000), 0x1.400002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00001004), 0x1.400002008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00001008), 0x1.40000201p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00001010), 0x1.40000202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00001080), 0x1.4000021p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00001200), 0x1.4000024p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00002000), 0x1.400004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00002004), 0x1.400004008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00002040), 0x1.40000408p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00002080), 0x1.4000041p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00002400), 0x1.4000048p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00010000), 0x1.40002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00010004), 0x1.400020008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00010020), 0x1.40002004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00010100), 0x1.4000202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00010800), 0x1.400021p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00018000), 0x1.40003p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00040000), 0x1.40008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00040004), 0x1.400080008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00040040), 0x1.40008008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00040200), 0x1.4000804p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00040400), 0x1.4000808p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00042000), 0x1.400084p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00044000), 0x1.400088p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00060000), 0x1.4000cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00400000), 0x1.4008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00400001), 0x1.400800002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00400010), 0x1.40080002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00400080), 0x1.4008001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00400800), 0x1.400801p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00401000), 0x1.400802p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00410000), 0x1.40082p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00480000), 0x1.4009p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a00600000), 0x1.400cp+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01000000), 0x1.402p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01000008), 0x1.40200001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01000080), 0x1.4020001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01000800), 0x1.402001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01001000), 0x1.402002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01010000), 0x1.40202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01080000), 0x1.4021p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a01800000), 0x1.403p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10000000), 0x1.42p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10000002), 0x1.420000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10000020), 0x1.42000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10000080), 0x1.4200001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10000400), 0x1.4200008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10002000), 0x1.420004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10020000), 0x1.42004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10040000), 0x1.42008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a10100000), 0x1.4202p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a11000000), 0x1.422p+35, 0x0p+0 },
+{ UINT64_C(0x0000000a14000000), 0x1.428p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00000000), 0x1.6p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00000004), 0x1.600000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00000008), 0x1.60000001p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00000020), 0x1.60000004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00000100), 0x1.6000002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00000400), 0x1.6000008p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00001000), 0x1.600002p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00002000), 0x1.600004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00020000), 0x1.60004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b00200000), 0x1.6004p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b01000000), 0x1.602p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b08000000), 0x1.61p+35, 0x0p+0 },
+{ UINT64_C(0x0000000b20000000), 0x1.64p+35, 0x0p+0 },
+{ UINT64_C(0x000000200000000c), 0x1.000000006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000044), 0x1.000000022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000060), 0x1.00000003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000064), 0x1.000000032p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000408), 0x1.000000204p+37, 0x0p+0 },
+{ UINT64_C(0x000000200000040a), 0x1.000000205p+37, 0x0p+0 },
+{ UINT64_C(0x000000200000040c), 0x1.000000206p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000410), 0x1.000000208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000411), 0x1.0000002088p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000440), 0x1.00000022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000442), 0x1.000000221p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000448), 0x1.000000224p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000480), 0x1.00000024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000488), 0x1.000000244p+37, 0x0p+0 },
+{ UINT64_C(0x00000020000004a0), 0x1.00000025p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000500), 0x1.00000028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000508), 0x1.000000284p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000000510), 0x1.000000288p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001001), 0x1.0000008008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001002), 0x1.000000801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001003), 0x1.0000008018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001004), 0x1.000000802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001040), 0x1.00000082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001042), 0x1.000000821p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001044), 0x1.000000822p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001050), 0x1.000000828p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001060), 0x1.00000083p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001200), 0x1.0000009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001208), 0x1.000000904p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001220), 0x1.00000091p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001300), 0x1.00000098p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001800), 0x1.000000cp+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001802), 0x1.000000c01p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001804), 0x1.000000c02p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001810), 0x1.000000c08p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001820), 0x1.000000c1p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000001880), 0x1.000000c4p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000008004), 0x1.000004002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000008020), 0x1.00000401p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000008028), 0x1.000004014p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000008100), 0x1.00000408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000008108), 0x1.000004084p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000008180), 0x1.0000040cp+37, 0x0p+0 },
+{ UINT64_C(0x0000002000009000), 0x1.0000048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000009001), 0x1.0000048008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000009002), 0x1.000004801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000009008), 0x1.000004804p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000009020), 0x1.00000481p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000009200), 0x1.0000049p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020001), 0x1.0000100008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020002), 0x1.000010001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020008), 0x1.000010004p+37, 0x0p+0 },
+{ UINT64_C(0x000000200002000c), 0x1.000010006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020040), 0x1.00001002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020044), 0x1.000010022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020050), 0x1.000010028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020080), 0x1.00001004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020081), 0x1.0000100408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020084), 0x1.000010042p+37, 0x0p+0 },
+{ UINT64_C(0x00000020000200a0), 0x1.00001005p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020100), 0x1.00001008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020102), 0x1.000010081p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020120), 0x1.00001009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020180), 0x1.0000100cp+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020800), 0x1.0000104p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020808), 0x1.000010404p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020810), 0x1.000010408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020820), 0x1.00001041p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020880), 0x1.00001044p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000020900), 0x1.00001048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000024000), 0x1.000012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000024008), 0x1.000012004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000024020), 0x1.00001201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000024040), 0x1.00001202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000024080), 0x1.00001204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000024800), 0x1.0000124p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000026000), 0x1.000013p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000028000), 0x1.000014p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000028004), 0x1.000014002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000028040), 0x1.00001402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000028400), 0x1.0000142p+37, 0x0p+0 },
+{ UINT64_C(0x000000200002c000), 0x1.000016p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000030000), 0x1.000018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000030008), 0x1.000018004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000030010), 0x1.000018008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000030040), 0x1.00001802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000030200), 0x1.0000181p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000031000), 0x1.0000188p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000034000), 0x1.00001ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200002), 0x1.000100001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200010), 0x1.000100008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200011), 0x1.0001000088p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200012), 0x1.000100009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200100), 0x1.00010008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200108), 0x1.000100084p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200120), 0x1.00010009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200180), 0x1.0001000cp+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200200), 0x1.0001001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200204), 0x1.000100102p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000200240), 0x1.00010012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000201000), 0x1.0001008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000201001), 0x1.0001008008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000201002), 0x1.000100801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000201010), 0x1.000100808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000201040), 0x1.00010082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000201400), 0x1.000100ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002000204000), 0x1.000102p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000204002), 0x1.000102001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000204010), 0x1.000102008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000204080), 0x1.00010204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000204200), 0x1.0001021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000204800), 0x1.0001024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000206000), 0x1.000103p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000240000), 0x1.00012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000240008), 0x1.000120004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000240020), 0x1.00012001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000240200), 0x1.0001201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000240800), 0x1.0001204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000242000), 0x1.000121p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000248000), 0x1.000124p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300000), 0x1.00018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300001), 0x1.0001800008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300010), 0x1.000180008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300040), 0x1.00018002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300100), 0x1.00018008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300200), 0x1.0001801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000300400), 0x1.0001802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000301000), 0x1.0001808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000304000), 0x1.000182p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000308000), 0x1.000184p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000310000), 0x1.000188p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400001), 0x1.0002000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400002), 0x1.000200001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400004), 0x1.000200002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400020), 0x1.00020001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400024), 0x1.000200012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400100), 0x1.00020008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400102), 0x1.000200081p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000400120), 0x1.00020009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000401000), 0x1.0002008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000401002), 0x1.000200801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000401008), 0x1.000200804p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000401040), 0x1.00020082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000401400), 0x1.000200ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002000404000), 0x1.000202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000404002), 0x1.000202001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000404004), 0x1.000202002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000404008), 0x1.000202004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000404080), 0x1.00020204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000404400), 0x1.0002022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000420000), 0x1.00021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000420008), 0x1.000210004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000420010), 0x1.000210008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000420020), 0x1.00021001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000420200), 0x1.0002101p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000421000), 0x1.0002108p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000424000), 0x1.000212p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440000), 0x1.00022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440001), 0x1.0002200008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440010), 0x1.000220008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440040), 0x1.00022002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440080), 0x1.00022004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440100), 0x1.00022008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000440200), 0x1.0002201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000442000), 0x1.000221p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000448000), 0x1.000224p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000460000), 0x1.00023p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000480000), 0x1.00024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000480002), 0x1.000240001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000480008), 0x1.000240004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000480010), 0x1.000240008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000480040), 0x1.00024002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000480400), 0x1.0002402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000481000), 0x1.0002408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000490000), 0x1.000248p+37, 0x0p+0 },
+{ UINT64_C(0x00000020004a0000), 0x1.00025p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800001), 0x1.0004000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800010), 0x1.000400008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800012), 0x1.000400009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800040), 0x1.00040002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800041), 0x1.0004000208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800044), 0x1.000400022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800060), 0x1.00040003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800400), 0x1.0004002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800408), 0x1.000400204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800420), 0x1.00040021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000800600), 0x1.0004003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000804000), 0x1.000402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000804002), 0x1.000402001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000804020), 0x1.00040201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000804080), 0x1.00040204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000804200), 0x1.0004021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000804800), 0x1.0004024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000806000), 0x1.000403p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000810000), 0x1.000408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000810001), 0x1.0004080008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000810010), 0x1.000408008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000810040), 0x1.00040802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000810400), 0x1.0004082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000811000), 0x1.0004088p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000812000), 0x1.000409p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820000), 0x1.00041p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820008), 0x1.000410004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820010), 0x1.000410008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820080), 0x1.00041004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820100), 0x1.00041008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820200), 0x1.0004101p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000820800), 0x1.0004104p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000822000), 0x1.000411p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000824000), 0x1.000412p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000828000), 0x1.000414p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000830000), 0x1.000418p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000840000), 0x1.00042p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000840002), 0x1.000420001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000840010), 0x1.000420008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000840100), 0x1.00042008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000841000), 0x1.0004208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000850000), 0x1.000428p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000900000), 0x1.00048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000900004), 0x1.000480002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000900020), 0x1.00048001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000900200), 0x1.0004801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000900400), 0x1.0004802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000904000), 0x1.000482p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000910000), 0x1.000488p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c00000), 0x1.0006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c00002), 0x1.000600001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c00020), 0x1.00060001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c00200), 0x1.0006001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c01000), 0x1.0006008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c02000), 0x1.000601p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c04000), 0x1.000602p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c08000), 0x1.000604p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000c20000), 0x1.00061p+37, 0x0p+0 },
+{ UINT64_C(0x0000002000e00000), 0x1.0007p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000002), 0x1.002000001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000004), 0x1.002000002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000006), 0x1.002000003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000010), 0x1.002000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000012), 0x1.002000009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000018), 0x1.00200000cp+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000100), 0x1.00200008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000104), 0x1.002000082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004000140), 0x1.0020000ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002004001000), 0x1.0020008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004001002), 0x1.002000801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004001008), 0x1.002000804p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004001020), 0x1.00200081p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004001200), 0x1.0020009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004008000), 0x1.002004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004008002), 0x1.002004001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004008020), 0x1.00200401p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004008080), 0x1.00200404p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004008800), 0x1.0020044p+37, 0x0p+0 },
+{ UINT64_C(0x000000200400a000), 0x1.002005p+37, 0x0p+0 },
+{ UINT64_C(0x000000200400c000), 0x1.002006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004040000), 0x1.00202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004040001), 0x1.0020200008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004040002), 0x1.002020001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004040004), 0x1.002020002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004040020), 0x1.00202001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004040200), 0x1.0020201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004042000), 0x1.002021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004044000), 0x1.002022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004050000), 0x1.002028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004060000), 0x1.00203p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004200000), 0x1.0021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004200004), 0x1.002100002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004200040), 0x1.00210002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004200080), 0x1.00210004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004200200), 0x1.0021001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004200400), 0x1.0021002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004201000), 0x1.0021008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004202000), 0x1.002101p+37, 0x0p+0 },
+{ UINT64_C(0x0000002004220000), 0x1.00211p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005000000), 0x1.0028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005000001), 0x1.0028000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005000008), 0x1.002800004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005000040), 0x1.00280002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005000200), 0x1.0028001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005001000), 0x1.0028008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005004000), 0x1.002802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005008000), 0x1.002804p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005080000), 0x1.00284p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005100000), 0x1.00288p+37, 0x0p+0 },
+{ UINT64_C(0x0000002005200000), 0x1.0029p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000002), 0x1.004000001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000003), 0x1.0040000018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000008), 0x1.004000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000009), 0x1.0040000048p+37, 0x0p+0 },
+{ UINT64_C(0x000000200800000a), 0x1.004000005p+37, 0x0p+0 },
+{ UINT64_C(0x000000200800000c), 0x1.004000006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000020), 0x1.00400001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000022), 0x1.004000011p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000030), 0x1.004000018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000200), 0x1.0040001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000204), 0x1.004000102p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000210), 0x1.004000108p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008000300), 0x1.00400018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002000), 0x1.004001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002004), 0x1.004001002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002010), 0x1.004001008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002020), 0x1.00400101p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002040), 0x1.00400102p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002100), 0x1.00400108p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008002400), 0x1.0040012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008010000), 0x1.004008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008010004), 0x1.004008002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008010040), 0x1.00400802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008010080), 0x1.00400804p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008010800), 0x1.0040084p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008018000), 0x1.00400cp+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040000), 0x1.00402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040001), 0x1.0040200008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040002), 0x1.004020001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040020), 0x1.00402001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040040), 0x1.00402002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040080), 0x1.00402004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040200), 0x1.0040201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008040400), 0x1.0040202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008044000), 0x1.004022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008400000), 0x1.0042p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008400002), 0x1.004200001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008400010), 0x1.004200008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008400040), 0x1.00420002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008400400), 0x1.0042002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008402000), 0x1.004201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008408000), 0x1.004204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008440000), 0x1.00422p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008500000), 0x1.00428p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008800000), 0x1.0044p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008800004), 0x1.004400002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008800008), 0x1.004400004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008800040), 0x1.00440002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008800100), 0x1.00440008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008801000), 0x1.0044008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008802000), 0x1.004401p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008804000), 0x1.004402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008820000), 0x1.00441p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008840000), 0x1.00442p+37, 0x0p+0 },
+{ UINT64_C(0x0000002008c00000), 0x1.0046p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000000), 0x1.006p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000001), 0x1.0060000008p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000010), 0x1.006000008p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000040), 0x1.00600002p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000080), 0x1.00600004p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000200), 0x1.0060001p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c000800), 0x1.0060004p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c004000), 0x1.006002p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c008000), 0x1.006004p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c080000), 0x1.00604p+37, 0x0p+0 },
+{ UINT64_C(0x000000200c800000), 0x1.0064p+37, 0x0p+0 },
+{ UINT64_C(0x000000200e000000), 0x1.007p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000002), 0x1.008000001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000003), 0x1.0080000018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000020), 0x1.00800001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000021), 0x1.0080000108p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000030), 0x1.008000018p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000200), 0x1.0080001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000208), 0x1.008000104p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000220), 0x1.00800011p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000400), 0x1.0080002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000404), 0x1.008000202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000420), 0x1.00800021p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010000500), 0x1.00800028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010002000), 0x1.008001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010002002), 0x1.008001001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010002004), 0x1.008001002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010002020), 0x1.00800101p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010002200), 0x1.0080011p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010002800), 0x1.0080014p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008000), 0x1.008004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008002), 0x1.008004001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008004), 0x1.008004002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008020), 0x1.00800401p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008040), 0x1.00800402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008080), 0x1.00800404p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010008200), 0x1.0080041p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010009000), 0x1.0080048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040000), 0x1.00802p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040008), 0x1.008020004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040040), 0x1.00802002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040100), 0x1.00802008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040200), 0x1.0080201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040400), 0x1.0080202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010040800), 0x1.0080204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010041000), 0x1.0080208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010048000), 0x1.008024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010060000), 0x1.00803p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010100000), 0x1.00808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010100001), 0x1.0080800008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010100008), 0x1.008080004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010100020), 0x1.00808001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010100100), 0x1.00808008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010101000), 0x1.0080808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010104000), 0x1.008082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010120000), 0x1.00809p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010400000), 0x1.0082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010400004), 0x1.008200002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010400008), 0x1.008200004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010400080), 0x1.00820004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010400400), 0x1.0082002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010402000), 0x1.008201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010408000), 0x1.008204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002010480000), 0x1.00824p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014000000), 0x1.00ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002014000008), 0x1.00a000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014000010), 0x1.00a000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014000100), 0x1.00a00008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014000400), 0x1.00a0002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014004000), 0x1.00a002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014008000), 0x1.00a004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014020000), 0x1.00a01p+37, 0x0p+0 },
+{ UINT64_C(0x0000002014100000), 0x1.00a08p+37, 0x0p+0 },
+{ UINT64_C(0x0000002015000000), 0x1.00a8p+37, 0x0p+0 },
+{ UINT64_C(0x0000002016000000), 0x1.00bp+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000004), 0x1.010000002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000006), 0x1.010000003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000040), 0x1.01000002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000041), 0x1.0100000208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000044), 0x1.010000022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000050), 0x1.010000028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000400), 0x1.0100002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000401), 0x1.0100002008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000410), 0x1.010000208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000440), 0x1.01000022p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000800), 0x1.0100004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000801), 0x1.0100004008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000804), 0x1.010000402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000808), 0x1.010000404p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000820), 0x1.01000041p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000880), 0x1.01000044p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020000900), 0x1.01000048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020004000), 0x1.010002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020004002), 0x1.010002001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020004010), 0x1.010002008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020004020), 0x1.01000201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020004100), 0x1.01000208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020005000), 0x1.0100028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020008000), 0x1.010004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020008008), 0x1.010004004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020008040), 0x1.01000402p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020008400), 0x1.0100042p+37, 0x0p+0 },
+{ UINT64_C(0x000000202000a000), 0x1.010005p+37, 0x0p+0 },
+{ UINT64_C(0x000000202000c000), 0x1.010006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020020000), 0x1.01001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020020004), 0x1.010010002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020020020), 0x1.01001001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020020200), 0x1.0100101p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020022000), 0x1.010011p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020024000), 0x1.010012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020040000), 0x1.01002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020040008), 0x1.010020004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020040020), 0x1.01002001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020040080), 0x1.01002004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020040400), 0x1.0100202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020040800), 0x1.0100204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020041000), 0x1.0100208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020048000), 0x1.010024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020060000), 0x1.01003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020100000), 0x1.01008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020100002), 0x1.010080001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020100008), 0x1.010080004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020100080), 0x1.01008004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020100100), 0x1.01008008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020100200), 0x1.0100801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020101000), 0x1.0100808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020102000), 0x1.010081p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020108000), 0x1.010084p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020140000), 0x1.0100ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002020800000), 0x1.0104p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020800001), 0x1.0104000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020800004), 0x1.010400002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020800040), 0x1.01040002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020800080), 0x1.01040004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020800400), 0x1.0104002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020802000), 0x1.010401p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020808000), 0x1.010404p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020810000), 0x1.010408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002020900000), 0x1.01048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021000000), 0x1.0108p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021000001), 0x1.0108000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021000004), 0x1.010800002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021000020), 0x1.01080001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021000040), 0x1.01080002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021000400), 0x1.0108002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021001000), 0x1.0108008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021010000), 0x1.010808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021100000), 0x1.01088p+37, 0x0p+0 },
+{ UINT64_C(0x0000002021400000), 0x1.010ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002024000000), 0x1.012p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024000001), 0x1.0120000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024000002), 0x1.012000001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024000008), 0x1.012000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024000080), 0x1.01200004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024000200), 0x1.0120001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024002000), 0x1.012001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024020000), 0x1.01201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024200000), 0x1.0121p+37, 0x0p+0 },
+{ UINT64_C(0x0000002024400000), 0x1.0122p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000008), 0x1.100000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000009), 0x1.1000000048p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000010), 0x1.100000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000012), 0x1.100000009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000014), 0x1.10000000ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000040), 0x1.10000002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000048), 0x1.100000024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000060), 0x1.10000003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000100), 0x1.10000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000101), 0x1.1000000808p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000104), 0x1.100000082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000140), 0x1.1000000ap+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000800), 0x1.1000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000802), 0x1.100000401p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000820), 0x1.10000041p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000840), 0x1.10000042p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200000c00), 0x1.1000006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200008000), 0x1.100004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200008001), 0x1.1000040008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200008008), 0x1.100004004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200008010), 0x1.100004008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200008100), 0x1.10000408p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200008800), 0x1.1000044p+37, 0x0p+0 },
+{ UINT64_C(0x000000220000c000), 0x1.100006p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200040000), 0x1.10002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200040008), 0x1.100020004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200040080), 0x1.10002004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200040200), 0x1.1000201p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200041000), 0x1.1000208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200050000), 0x1.100028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200060000), 0x1.10003p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200100000), 0x1.10008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200100004), 0x1.100080002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200100020), 0x1.10008001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200100080), 0x1.10008004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200100200), 0x1.1000801p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200102000), 0x1.100081p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200104000), 0x1.100082p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200120000), 0x1.10009p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400000), 0x1.1002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400001), 0x1.1002000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400002), 0x1.100200001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400010), 0x1.100200008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400020), 0x1.10020001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400100), 0x1.10020008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200400400), 0x1.1002002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200404000), 0x1.100202p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200408000), 0x1.100204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200410000), 0x1.100208p+37, 0x0p+0 },
+{ UINT64_C(0x0000002200500000), 0x1.10028p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204000000), 0x1.102p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204000004), 0x1.102000002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204000010), 0x1.102000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204000040), 0x1.10200002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204000400), 0x1.1020002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204004000), 0x1.102002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204010000), 0x1.102008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204080000), 0x1.10204p+37, 0x0p+0 },
+{ UINT64_C(0x0000002204800000), 0x1.1024p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220000000), 0x1.11p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220000008), 0x1.110000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220000080), 0x1.11000004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220000100), 0x1.11000008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220000400), 0x1.1100002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220000800), 0x1.1100004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220001000), 0x1.1100008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220010000), 0x1.110008p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220020000), 0x1.11001p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220040000), 0x1.11002p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220080000), 0x1.11004p+37, 0x0p+0 },
+{ UINT64_C(0x0000002220400000), 0x1.1102p+37, 0x0p+0 },
+{ UINT64_C(0x0000002224000000), 0x1.112p+37, 0x0p+0 },
+{ UINT64_C(0x0000002228000000), 0x1.114p+37, 0x0p+0 },
+{ UINT64_C(0x0000002230000000), 0x1.118p+37, 0x0p+0 },
+{ UINT64_C(0x0000004000000005), 0x1.0000000014p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000006), 0x1.0000000018p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000021), 0x1.0000000084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000022), 0x1.0000000088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000023), 0x1.000000008cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000048), 0x1.000000012p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000004c), 0x1.000000013p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000084), 0x1.000000021p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000086), 0x1.0000000218p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000090), 0x1.000000024p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000098), 0x1.000000026p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000108), 0x1.000000042p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000109), 0x1.0000000424p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000010a), 0x1.0000000428p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000010c), 0x1.000000043p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000120), 0x1.000000048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000121), 0x1.0000000484p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000128), 0x1.00000004ap+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000130), 0x1.00000004cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000180), 0x1.00000006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000188), 0x1.000000062p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000808), 0x1.000000202p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000080a), 0x1.0000002028p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000820), 0x1.000000208p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000822), 0x1.0000002088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000828), 0x1.00000020ap+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000830), 0x1.00000020cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000840), 0x1.00000021p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000844), 0x1.000000211p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000a00), 0x1.00000028p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000a02), 0x1.0000002808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000a04), 0x1.000000281p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000a40), 0x1.00000029p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000c00), 0x1.0000003p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000c08), 0x1.000000302p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000c20), 0x1.000000308p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000c40), 0x1.00000031p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000000d00), 0x1.00000034p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008004), 0x1.000002001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008006), 0x1.0000020018p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008040), 0x1.00000201p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008048), 0x1.000002012p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008060), 0x1.000002018p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008100), 0x1.00000204p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008104), 0x1.000002041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008110), 0x1.000002044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000008120), 0x1.000002048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000009000), 0x1.0000024p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000009002), 0x1.0000024008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000009020), 0x1.000002408p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000009080), 0x1.00000242p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000009200), 0x1.00000248p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000009400), 0x1.0000025p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000c000), 0x1.000003p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000c004), 0x1.000003001p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000c020), 0x1.000003008p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000c100), 0x1.00000304p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000c400), 0x1.0000031p+38, 0x0p+0 },
+{ UINT64_C(0x000000400000d000), 0x1.0000034p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010004), 0x1.000004001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010005), 0x1.0000040014p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010006), 0x1.0000040018p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010010), 0x1.000004004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010018), 0x1.000004006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010100), 0x1.00000404p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010108), 0x1.000004042p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010110), 0x1.000004044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010400), 0x1.0000041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010404), 0x1.000004101p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010410), 0x1.000004104p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000010480), 0x1.00000412p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000012000), 0x1.0000048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000012004), 0x1.000004801p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000012040), 0x1.00000481p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000012400), 0x1.0000049p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000014000), 0x1.000005p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000014002), 0x1.0000050008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000014020), 0x1.000005008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000014040), 0x1.00000501p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000014100), 0x1.00000504p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000015000), 0x1.0000054p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000018000), 0x1.000006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000018001), 0x1.0000060004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000018010), 0x1.000006004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000018080), 0x1.00000602p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000018400), 0x1.0000061p+38, 0x0p+0 },
+{ UINT64_C(0x000000400001a000), 0x1.0000068p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080008), 0x1.000020002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080009), 0x1.0000200024p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080080), 0x1.00002002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080088), 0x1.000020022p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000800a0), 0x1.000020028p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080100), 0x1.00002004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080104), 0x1.000020041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080110), 0x1.000020044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080120), 0x1.000020048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080200), 0x1.00002008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080201), 0x1.0000200804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080202), 0x1.0000200808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080220), 0x1.000020088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080800), 0x1.0000202p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080808), 0x1.000020202p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080840), 0x1.00002021p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080880), 0x1.00002022p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000080900), 0x1.00002024p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000081000), 0x1.0000204p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000081008), 0x1.000020402p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000081080), 0x1.00002042p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000081200), 0x1.00002048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000084000), 0x1.000021p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000084008), 0x1.000021002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000084040), 0x1.00002101p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000084400), 0x1.0000211p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000a0000), 0x1.000028p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000a0004), 0x1.000028001p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000a0010), 0x1.000028004p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000a0080), 0x1.00002802p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000a0800), 0x1.0000282p+38, 0x0p+0 },
+{ UINT64_C(0x00000040000a8000), 0x1.00002ap+38, 0x0p+0 },
+{ UINT64_C(0x00000040000b0000), 0x1.00002cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200001), 0x1.0000800004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200004), 0x1.000080001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200006), 0x1.0000800018p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200020), 0x1.000080008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200024), 0x1.000080009p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200200), 0x1.00008008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200202), 0x1.0000800808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200204), 0x1.000080081p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200220), 0x1.000080088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200400), 0x1.0000801p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200401), 0x1.0000801004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200404), 0x1.000080101p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200420), 0x1.000080108p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000200480), 0x1.00008012p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000201000), 0x1.0000804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000201004), 0x1.000080401p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000201040), 0x1.00008041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000201200), 0x1.00008048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000202000), 0x1.0000808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000202002), 0x1.0000808008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000202020), 0x1.000080808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000202100), 0x1.00008084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000203000), 0x1.000080cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000210000), 0x1.000084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000210008), 0x1.000084002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000210080), 0x1.00008402p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000210200), 0x1.00008408p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000210400), 0x1.0000841p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000211000), 0x1.0000844p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000212000), 0x1.0000848p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000218000), 0x1.000086p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000220000), 0x1.000088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000220008), 0x1.000088002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000220020), 0x1.000088008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000220100), 0x1.00008804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000220200), 0x1.00008808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000220400), 0x1.0000881p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000222000), 0x1.0000888p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000230000), 0x1.00008cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300000), 0x1.0000cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300004), 0x1.0000c0001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300010), 0x1.0000c0004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300080), 0x1.0000c002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300100), 0x1.0000c004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300400), 0x1.0000c01p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000300800), 0x1.0000c02p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000301000), 0x1.0000c04p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000310000), 0x1.0000c4p+38, 0x0p+0 },
+{ UINT64_C(0x0000004000340000), 0x1.0000dp+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000001), 0x1.0008000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000010), 0x1.000800004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000014), 0x1.000800005p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000100), 0x1.00080004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000108), 0x1.000800042p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000110), 0x1.000800044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000200), 0x1.00080008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000208), 0x1.000800082p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000210), 0x1.000800084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002000240), 0x1.00080009p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002001000), 0x1.0008004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002001008), 0x1.000800402p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002001010), 0x1.000800404p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002001100), 0x1.00080044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002001800), 0x1.0008006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002010000), 0x1.000804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002010001), 0x1.0008040004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002010008), 0x1.000804002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002010010), 0x1.000804004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002010040), 0x1.00080401p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002010200), 0x1.00080408p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002011000), 0x1.0008044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002018000), 0x1.000806p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002100000), 0x1.00084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002100004), 0x1.000840001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002100040), 0x1.00084001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002100200), 0x1.00084008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002102000), 0x1.0008408p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002104000), 0x1.000841p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002108000), 0x1.000842p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002120000), 0x1.000848p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002200000), 0x1.00088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002200001), 0x1.0008800004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002200004), 0x1.000880001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002200010), 0x1.000880004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002200100), 0x1.00088004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002201000), 0x1.0008804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002202000), 0x1.0008808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002204000), 0x1.000881p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002208000), 0x1.000882p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002240000), 0x1.00089p+38, 0x0p+0 },
+{ UINT64_C(0x0000004002280000), 0x1.0008ap+38, 0x0p+0 },
+{ UINT64_C(0x0000004002300000), 0x1.0008cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000008), 0x1.008000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000040), 0x1.00800001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000041), 0x1.0080000104p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000048), 0x1.008000012p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000080), 0x1.00800002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000084), 0x1.008000021p+38, 0x0p+0 },
+{ UINT64_C(0x00000040200000a0), 0x1.008000028p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000200), 0x1.00800008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000202), 0x1.0080000808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000210), 0x1.008000084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000220), 0x1.008000088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020000300), 0x1.0080000cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004020001000), 0x1.0080004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020001004), 0x1.008000401p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020001010), 0x1.008000404p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020001040), 0x1.00800041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020001400), 0x1.0080005p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002000), 0x1.0080008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002001), 0x1.0080008004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002002), 0x1.0080008008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002004), 0x1.008000801p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002008), 0x1.008000802p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002040), 0x1.00800081p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020002400), 0x1.0080009p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020000), 0x1.008008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020008), 0x1.008008002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020010), 0x1.008008004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020080), 0x1.00800802p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020100), 0x1.00800804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020400), 0x1.0080081p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020020800), 0x1.0080082p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020024000), 0x1.008009p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020030000), 0x1.00800cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004020200000), 0x1.00808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020200008), 0x1.008080002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020200010), 0x1.008080004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020200080), 0x1.00808002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020200400), 0x1.0080801p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020201000), 0x1.0080804p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020202000), 0x1.0080808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020210000), 0x1.008084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004020240000), 0x1.00809p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022000000), 0x1.0088p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022000004), 0x1.008800001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022000008), 0x1.008800002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022000020), 0x1.008800008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022000080), 0x1.00880002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022000800), 0x1.0088002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022002000), 0x1.0088008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022020000), 0x1.008808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004022200000), 0x1.00888p+38, 0x0p+0 },
+{ UINT64_C(0x0000004023000000), 0x1.008cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004024000000), 0x1.009p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024000002), 0x1.0090000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024000008), 0x1.009000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024000020), 0x1.009000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024000200), 0x1.00900008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024000800), 0x1.0090002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024001000), 0x1.0090004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024004000), 0x1.009001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024020000), 0x1.009008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024100000), 0x1.00904p+38, 0x0p+0 },
+{ UINT64_C(0x0000004024800000), 0x1.0092p+38, 0x0p+0 },
+{ UINT64_C(0x0000004025000000), 0x1.0094p+38, 0x0p+0 },
+{ UINT64_C(0x0000004026000000), 0x1.0098p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028000000), 0x1.00ap+38, 0x0p+0 },
+{ UINT64_C(0x0000004028000001), 0x1.00a0000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028000008), 0x1.00a000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028000040), 0x1.00a00001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028000200), 0x1.00a00008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028002000), 0x1.00a0008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028010000), 0x1.00a004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028080000), 0x1.00a02p+38, 0x0p+0 },
+{ UINT64_C(0x0000004028800000), 0x1.00a2p+38, 0x0p+0 },
+{ UINT64_C(0x0000004029000000), 0x1.00a4p+38, 0x0p+0 },
+{ UINT64_C(0x000000402a000000), 0x1.00a8p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000008), 0x1.080000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000080), 0x1.08000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000081), 0x1.0800000204p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000084), 0x1.080000021p+38, 0x0p+0 },
+{ UINT64_C(0x00000042000000a0), 0x1.080000028p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000100), 0x1.08000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000104), 0x1.080000041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000110), 0x1.080000044p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000180), 0x1.08000006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000800), 0x1.0800002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000801), 0x1.0800002004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000808), 0x1.080000202p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000820), 0x1.080000208p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200000880), 0x1.08000022p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001000), 0x1.0800004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001001), 0x1.0800004004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001002), 0x1.0800004008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001008), 0x1.080000402p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001040), 0x1.08000041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001080), 0x1.08000042p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001400), 0x1.0800005p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200001800), 0x1.0800006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200004000), 0x1.080001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200004004), 0x1.080001001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200004040), 0x1.08000101p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200004100), 0x1.08000104p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200004800), 0x1.0800012p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200005000), 0x1.0800014p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200008000), 0x1.080002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200008008), 0x1.080002002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200008020), 0x1.080002008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200008100), 0x1.08000204p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200008200), 0x1.08000208p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200008800), 0x1.0800022p+38, 0x0p+0 },
+{ UINT64_C(0x000000420000c000), 0x1.080003p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200010000), 0x1.080004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200010001), 0x1.0800040004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200010002), 0x1.0800040008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200010020), 0x1.080004008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200010200), 0x1.08000408p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200012000), 0x1.0800048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200018000), 0x1.080006p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100000), 0x1.08004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100001), 0x1.0800400004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100002), 0x1.0800400008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100010), 0x1.080040004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100040), 0x1.08004001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100080), 0x1.08004002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200100800), 0x1.0800402p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200104000), 0x1.080041p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200120000), 0x1.080048p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200140000), 0x1.08005p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200200000), 0x1.08008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200200004), 0x1.080080001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200200040), 0x1.08008001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200200080), 0x1.08008002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200200200), 0x1.08008008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200202000), 0x1.0800808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200210000), 0x1.080084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200240000), 0x1.08009p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200300000), 0x1.0800cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004200800000), 0x1.0802p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200800008), 0x1.080200002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200800080), 0x1.08020002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200800100), 0x1.08020004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200800800), 0x1.0802002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200808000), 0x1.080202p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200810000), 0x1.080204p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200820000), 0x1.080208p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200880000), 0x1.08022p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200900000), 0x1.08024p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200a00000), 0x1.08028p+38, 0x0p+0 },
+{ UINT64_C(0x0000004200c00000), 0x1.0803p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202000000), 0x1.0808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202000004), 0x1.080800001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202000010), 0x1.080800004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202000100), 0x1.08080004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202000800), 0x1.0808002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202001000), 0x1.0808004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202002000), 0x1.0808008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202004000), 0x1.080801p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202020000), 0x1.080808p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202040000), 0x1.08081p+38, 0x0p+0 },
+{ UINT64_C(0x0000004202400000), 0x1.0809p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210000000), 0x1.084p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210000004), 0x1.084000001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210000020), 0x1.084000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210000080), 0x1.08400002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210000800), 0x1.0840002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210008000), 0x1.084002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210080000), 0x1.08402p+38, 0x0p+0 },
+{ UINT64_C(0x0000004210800000), 0x1.0842p+38, 0x0p+0 },
+{ UINT64_C(0x0000004218000000), 0x1.086p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300000000), 0x1.0cp+38, 0x0p+0 },
+{ UINT64_C(0x0000004300000008), 0x1.0c0000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300000080), 0x1.0c000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300000200), 0x1.0c000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300002000), 0x1.0c00008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300008000), 0x1.0c0002p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300010000), 0x1.0c0004p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300040000), 0x1.0c001p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300200000), 0x1.0c008p+38, 0x0p+0 },
+{ UINT64_C(0x0000004300400000), 0x1.0c01p+38, 0x0p+0 },
+{ UINT64_C(0x0000004301000000), 0x1.0c04p+38, 0x0p+0 },
+{ UINT64_C(0x0000004308000000), 0x1.0c2p+38, 0x0p+0 },
+{ UINT64_C(0x0000004320000000), 0x1.0c8p+38, 0x0p+0 },
+{ UINT64_C(0x0000004340000000), 0x1.0dp+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000008), 0x1.800000002p+38, 0x0p+0 },
+{ UINT64_C(0x000000600000000c), 0x1.800000003p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000040), 0x1.80000001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000044), 0x1.800000011p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000060), 0x1.800000018p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000100), 0x1.80000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000102), 0x1.8000000408p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000000120), 0x1.800000048p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000001000), 0x1.8000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000001004), 0x1.800000401p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000001010), 0x1.800000404p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000001080), 0x1.80000042p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000001200), 0x1.80000048p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000010000), 0x1.800004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000010008), 0x1.800004002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000010010), 0x1.800004004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000010100), 0x1.80000404p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000010800), 0x1.8000042p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000011000), 0x1.8000044p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000012000), 0x1.8000048p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000020000), 0x1.800008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000020002), 0x1.8000080008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000020020), 0x1.800008008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000020080), 0x1.80000802p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000020200), 0x1.80000808p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000020400), 0x1.8000081p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000022000), 0x1.8000088p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000024000), 0x1.800009p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000030000), 0x1.80000cp+38, 0x0p+0 },
+{ UINT64_C(0x0000006000200000), 0x1.80008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000200004), 0x1.800080001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000200020), 0x1.800080008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000200080), 0x1.80008002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000200800), 0x1.8000802p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000202000), 0x1.8000808p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000210000), 0x1.800084p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000220000), 0x1.800088p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000240000), 0x1.80009p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000280000), 0x1.8000ap+38, 0x0p+0 },
+{ UINT64_C(0x0000006000800000), 0x1.8002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000800004), 0x1.800200001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000800010), 0x1.800200004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000800020), 0x1.800200008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000800200), 0x1.80020008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000802000), 0x1.8002008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000804000), 0x1.800201p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000810000), 0x1.800204p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000840000), 0x1.80021p+38, 0x0p+0 },
+{ UINT64_C(0x0000006000a00000), 0x1.80028p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004000000), 0x1.801p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004000008), 0x1.801000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004000080), 0x1.80100002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004000200), 0x1.80100008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004001000), 0x1.8010004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004010000), 0x1.801004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004040000), 0x1.80101p+38, 0x0p+0 },
+{ UINT64_C(0x0000006004100000), 0x1.80104p+38, 0x0p+0 },
+{ UINT64_C(0x0000006005000000), 0x1.8014p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000000), 0x1.81p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000001), 0x1.8100000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000002), 0x1.8100000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000020), 0x1.810000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000080), 0x1.81000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000100), 0x1.81000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040000200), 0x1.81000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040002000), 0x1.8100008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040004000), 0x1.810001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040008000), 0x1.810002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040040000), 0x1.81001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040200000), 0x1.81008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006040800000), 0x1.8102p+38, 0x0p+0 },
+{ UINT64_C(0x0000006042000000), 0x1.8108p+38, 0x0p+0 },
+{ UINT64_C(0x0000006050000000), 0x1.814p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000000), 0x1.9p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000001), 0x1.9000000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000010), 0x1.900000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000020), 0x1.900000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000040), 0x1.90000001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000400), 0x1.9000001p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400000800), 0x1.9000002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400008000), 0x1.900002p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400020000), 0x1.900008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006400200000), 0x1.90008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006402000000), 0x1.9008p+38, 0x0p+0 },
+{ UINT64_C(0x0000006420000000), 0x1.908p+38, 0x0p+0 },
+{ UINT64_C(0x0000006600000000), 0x1.98p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000000000), 0x1.cp+38, 0x0p+0 },
+{ UINT64_C(0x0000007000000002), 0x1.c000000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000000010), 0x1.c00000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000000040), 0x1.c0000001p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000000100), 0x1.c0000004p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000000200), 0x1.c0000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000002000), 0x1.c000008p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000020000), 0x1.c00008p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000200000), 0x1.c0008p+38, 0x0p+0 },
+{ UINT64_C(0x0000007000400000), 0x1.c001p+38, 0x0p+0 },
+{ UINT64_C(0x0000007001000000), 0x1.c004p+38, 0x0p+0 },
+{ UINT64_C(0x0000007002000000), 0x1.c008p+38, 0x0p+0 },
+{ UINT64_C(0x0000007004000000), 0x1.c01p+38, 0x0p+0 },
+{ UINT64_C(0x0000007008000000), 0x1.c02p+38, 0x0p+0 },
+{ UINT64_C(0x0000007040000000), 0x1.c1p+38, 0x0p+0 },
+{ UINT64_C(0x0000007080000000), 0x1.c2p+38, 0x0p+0 },
+{ UINT64_C(0x0000007200000000), 0x1.c8p+38, 0x0p+0 },
+{ UINT64_C(0x0000007800000000), 0x1.ep+38, 0x0p+0 },
+{ UINT64_C(0x0000010000000012), 0x1.0000000012p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000014), 0x1.0000000014p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000016), 0x1.0000000016p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000024), 0x1.0000000024p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000026), 0x1.0000000026p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000081), 0x1.0000000081p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000090), 0x1.000000009p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000092), 0x1.0000000092p+40, 0x0p+0 },
+{ UINT64_C(0x00000100000000c0), 0x1.00000000cp+40, 0x0p+0 },
+{ UINT64_C(0x00000100000000c2), 0x1.00000000c2p+40, 0x0p+0 },
+{ UINT64_C(0x00000100000000c8), 0x1.00000000c8p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000404), 0x1.0000000404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000440), 0x1.000000044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000441), 0x1.0000000441p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000442), 0x1.0000000442p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000444), 0x1.0000000444p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000448), 0x1.0000000448p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000000460), 0x1.000000046p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001008), 0x1.0000001008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001009), 0x1.0000001009p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001080), 0x1.000000108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001088), 0x1.0000001088p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001200), 0x1.00000012p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001202), 0x1.0000001202p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001204), 0x1.0000001204p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001208), 0x1.0000001208p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001280), 0x1.000000128p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001300), 0x1.00000013p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001400), 0x1.00000014p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001402), 0x1.0000001402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001408), 0x1.0000001408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001480), 0x1.000000148p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000001600), 0x1.00000016p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004004), 0x1.0000004004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004040), 0x1.000000404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004044), 0x1.0000004044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004050), 0x1.000000405p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004080), 0x1.000000408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004088), 0x1.0000004088p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004800), 0x1.00000048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004804), 0x1.0000004804p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004820), 0x1.000000482p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004840), 0x1.000000484p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004900), 0x1.00000049p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000004c00), 0x1.0000004cp+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040001), 0x1.0000040001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040008), 0x1.0000040008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040009), 0x1.0000040009p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040010), 0x1.000004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040011), 0x1.0000040011p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040014), 0x1.0000040014p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040040), 0x1.000004004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040041), 0x1.0000040041p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040048), 0x1.0000040048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040200), 0x1.00000402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040208), 0x1.0000040208p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040220), 0x1.000004022p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040300), 0x1.00000403p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040800), 0x1.00000408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040801), 0x1.0000040801p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040808), 0x1.0000040808p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040820), 0x1.000004082p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040840), 0x1.000004084p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040880), 0x1.000004088p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000040c00), 0x1.0000040cp+40, 0x0p+0 },
+{ UINT64_C(0x0000010000044000), 0x1.0000044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000044008), 0x1.0000044008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000044020), 0x1.000004402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000044100), 0x1.00000441p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000044400), 0x1.00000444p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000044800), 0x1.00000448p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000046000), 0x1.0000046p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000048000), 0x1.0000048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000048004), 0x1.0000048004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000048010), 0x1.000004801p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000048040), 0x1.000004804p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000048100), 0x1.00000481p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000049000), 0x1.0000049p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000060000), 0x1.000006p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000060004), 0x1.0000060004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000060020), 0x1.000006002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000060080), 0x1.000006008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000060800), 0x1.00000608p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000061000), 0x1.0000061p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000064000), 0x1.0000064p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000068000), 0x1.0000068p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100008), 0x1.0000100008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100080), 0x1.000010008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100082), 0x1.0000100082p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100088), 0x1.0000100088p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100090), 0x1.000010009p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100100), 0x1.00001001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100104), 0x1.0000100104p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100108), 0x1.0000100108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000100180), 0x1.000010018p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000101000), 0x1.0000101p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000101008), 0x1.0000101008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000101080), 0x1.000010108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000101400), 0x1.00001014p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000110000), 0x1.000011p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000110002), 0x1.0000110002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000110020), 0x1.000011002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000110100), 0x1.00001101p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000111000), 0x1.0000111p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000114000), 0x1.0000114p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400008), 0x1.0000400008p+40, 0x0p+0 },
+{ UINT64_C(0x000001000040000c), 0x1.000040000cp+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400020), 0x1.000040002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400022), 0x1.0000400022p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400028), 0x1.0000400028p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400100), 0x1.00004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400104), 0x1.0000400104p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400108), 0x1.0000400108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400120), 0x1.000040012p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400400), 0x1.00004004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400401), 0x1.0000400401p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400408), 0x1.0000400408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400410), 0x1.000040041p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400500), 0x1.00004005p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000400600), 0x1.00004006p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000404000), 0x1.0000404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000404004), 0x1.0000404004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000404008), 0x1.0000404008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000404040), 0x1.000040404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000404080), 0x1.000040408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000404400), 0x1.00004044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000405000), 0x1.0000405p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000406000), 0x1.0000406p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000408000), 0x1.0000408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000408008), 0x1.0000408008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000408040), 0x1.000040804p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000408400), 0x1.00004084p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000409000), 0x1.0000409p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000480000), 0x1.000048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000480004), 0x1.0000480004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000480008), 0x1.0000480008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000480020), 0x1.000048002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000480080), 0x1.000048008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000480200), 0x1.00004802p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000481000), 0x1.0000481p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000488000), 0x1.0000488p+40, 0x0p+0 },
+{ UINT64_C(0x00000100004a0000), 0x1.00004ap+40, 0x0p+0 },
+{ UINT64_C(0x0000010000600000), 0x1.00006p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000600004), 0x1.0000600004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000600010), 0x1.000060001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000600020), 0x1.000060002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000600040), 0x1.000060004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000600200), 0x1.00006002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000601000), 0x1.0000601p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000608000), 0x1.0000608p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000620000), 0x1.000062p+40, 0x0p+0 },
+{ UINT64_C(0x0000010000680000), 0x1.000068p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000001), 0x1.0004000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000010), 0x1.000400001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000012), 0x1.0004000012p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000040), 0x1.000400004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000048), 0x1.0004000048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000100), 0x1.00040001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000108), 0x1.0004000108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000110), 0x1.000400011p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000180), 0x1.000400018p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000400), 0x1.00040004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000401), 0x1.0004000401p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000402), 0x1.0004000402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000420), 0x1.000400042p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000440), 0x1.000400044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000480), 0x1.000400048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004000600), 0x1.00040006p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004001000), 0x1.0004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004001001), 0x1.0004001001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004001002), 0x1.0004001002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004001008), 0x1.0004001008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004001080), 0x1.000400108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004001400), 0x1.00040014p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002000), 0x1.0004002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002001), 0x1.0004002001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002002), 0x1.0004002002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002004), 0x1.0004002004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002010), 0x1.000400201p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002100), 0x1.00040021p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002400), 0x1.00040024p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004002800), 0x1.00040028p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020000), 0x1.000402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020001), 0x1.0004020001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020002), 0x1.0004020002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020008), 0x1.0004020008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020010), 0x1.000402001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020080), 0x1.000402008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004020400), 0x1.00040204p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004022000), 0x1.0004022p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004030000), 0x1.000403p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004200000), 0x1.00042p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004200001), 0x1.0004200001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004200002), 0x1.0004200002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004200008), 0x1.0004200008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004200080), 0x1.000420008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004200800), 0x1.00042008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004202000), 0x1.0004202p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004208000), 0x1.0004208p+40, 0x0p+0 },
+{ UINT64_C(0x0000010004280000), 0x1.000428p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005000000), 0x1.0005p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005000001), 0x1.0005000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005000002), 0x1.0005000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005000010), 0x1.000500001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005000080), 0x1.000500008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005000200), 0x1.00050002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005002000), 0x1.0005002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005020000), 0x1.000502p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005040000), 0x1.000504p+40, 0x0p+0 },
+{ UINT64_C(0x0000010005400000), 0x1.00054p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000008), 0x1.0040000008p+40, 0x0p+0 },
+{ UINT64_C(0x000001004000000c), 0x1.004000000cp+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000020), 0x1.004000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000028), 0x1.0040000028p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000030), 0x1.004000003p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000040), 0x1.004000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000042), 0x1.0040000042p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000048), 0x1.0040000048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000060), 0x1.004000006p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000080), 0x1.004000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000088), 0x1.0040000088p+40, 0x0p+0 },
+{ UINT64_C(0x00000100400000a0), 0x1.00400000ap+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000800), 0x1.00400008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000801), 0x1.0040000801p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000808), 0x1.0040000808p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040000880), 0x1.004000088p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001000), 0x1.0040001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001002), 0x1.0040001002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001008), 0x1.0040001008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001040), 0x1.004000104p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001080), 0x1.004000108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001100), 0x1.00400011p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040001200), 0x1.00400012p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010000), 0x1.004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010001), 0x1.0040010001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010008), 0x1.0040010008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010010), 0x1.004001001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010020), 0x1.004001002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010040), 0x1.004001004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010080), 0x1.004001008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010200), 0x1.00400102p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040010800), 0x1.00400108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040011000), 0x1.0040011p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040014000), 0x1.0040014p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040080000), 0x1.004008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040080002), 0x1.0040080002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040080020), 0x1.004008002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040080040), 0x1.004008004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040080400), 0x1.00400804p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040080800), 0x1.00400808p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040081000), 0x1.0040081p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040090000), 0x1.004009p+40, 0x0p+0 },
+{ UINT64_C(0x00000100400c0000), 0x1.00400cp+40, 0x0p+0 },
+{ UINT64_C(0x0000010040400000), 0x1.00404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040400008), 0x1.0040400008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040400010), 0x1.004040001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040400100), 0x1.00404001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040400200), 0x1.00404002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040402000), 0x1.0040402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040404000), 0x1.0040404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040410000), 0x1.004041p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040480000), 0x1.004048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010040500000), 0x1.00405p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042000000), 0x1.0042p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042000004), 0x1.0042000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042000010), 0x1.004200001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042000020), 0x1.004200002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042000200), 0x1.00420002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042001000), 0x1.0042001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042004000), 0x1.0042004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042008000), 0x1.0042008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042040000), 0x1.004204p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042080000), 0x1.004208p+40, 0x0p+0 },
+{ UINT64_C(0x0000010042400000), 0x1.00424p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044000000), 0x1.0044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044000001), 0x1.0044000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044000002), 0x1.0044000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044000020), 0x1.004400002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044000100), 0x1.00440001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044001000), 0x1.0044001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044004000), 0x1.0044004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044008000), 0x1.0044008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044010000), 0x1.004401p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044020000), 0x1.004402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044040000), 0x1.004404p+40, 0x0p+0 },
+{ UINT64_C(0x0000010044200000), 0x1.00442p+40, 0x0p+0 },
+{ UINT64_C(0x0000010046000000), 0x1.0046p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000008), 0x1.0400000008p+40, 0x0p+0 },
+{ UINT64_C(0x000001040000000a), 0x1.040000000ap+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000020), 0x1.040000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000024), 0x1.0400000024p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000028), 0x1.0400000028p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000200), 0x1.04000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000201), 0x1.0400000201p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000202), 0x1.0400000202p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000208), 0x1.0400000208p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400000280), 0x1.040000028p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400002000), 0x1.0400002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400002004), 0x1.0400002004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400002008), 0x1.0400002008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400002040), 0x1.040000204p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400002400), 0x1.04000024p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400002800), 0x1.04000028p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400004000), 0x1.0400004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400004001), 0x1.0400004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400004010), 0x1.040000401p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400004100), 0x1.04000041p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400005000), 0x1.0400005p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010000), 0x1.040001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010001), 0x1.0400010001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010002), 0x1.0400010002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010008), 0x1.0400010008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010010), 0x1.040001001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010040), 0x1.040001004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010400), 0x1.04000104p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400010800), 0x1.04000108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400012000), 0x1.0400012p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400020000), 0x1.040002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400020001), 0x1.0400020001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400020004), 0x1.0400020004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400020040), 0x1.040002004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400020080), 0x1.040002008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400020400), 0x1.04000204p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400021000), 0x1.0400021p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400030000), 0x1.040003p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040000), 0x1.040004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040001), 0x1.0400040001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040008), 0x1.0400040008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040010), 0x1.040004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040040), 0x1.040004004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040200), 0x1.04000402p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400040800), 0x1.04000408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400044000), 0x1.0400044p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400100000), 0x1.04001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400100004), 0x1.0400100004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400100040), 0x1.040010004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400100080), 0x1.040010008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400100800), 0x1.04001008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400101000), 0x1.0400101p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400108000), 0x1.0400108p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400180000), 0x1.040018p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200000), 0x1.04002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200001), 0x1.0400200001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200010), 0x1.040020001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200020), 0x1.040020002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200080), 0x1.040020008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200400), 0x1.04002004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400200800), 0x1.04002008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400208000), 0x1.0400208p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400220000), 0x1.040022p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400800000), 0x1.04008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400800002), 0x1.0400800002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400800008), 0x1.0400800008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400800080), 0x1.040080008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400800800), 0x1.04008008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400801000), 0x1.0400801p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400802000), 0x1.0400802p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400820000), 0x1.040082p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400900000), 0x1.04009p+40, 0x0p+0 },
+{ UINT64_C(0x0000010400a00000), 0x1.0400ap+40, 0x0p+0 },
+{ UINT64_C(0x0000010408000000), 0x1.0408p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408000008), 0x1.0408000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408000010), 0x1.040800001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408000100), 0x1.04080001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408000200), 0x1.04080002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408000800), 0x1.04080008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408004000), 0x1.0408004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408010000), 0x1.040801p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408040000), 0x1.040804p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408080000), 0x1.040808p+40, 0x0p+0 },
+{ UINT64_C(0x0000010408800000), 0x1.04088p+40, 0x0p+0 },
+{ UINT64_C(0x000001040c000000), 0x1.040cp+40, 0x0p+0 },
+{ UINT64_C(0x0000010480000000), 0x1.048p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480000008), 0x1.0480000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480000010), 0x1.048000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480000100), 0x1.04800001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480001000), 0x1.0480001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480010000), 0x1.048001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480080000), 0x1.048008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010480800000), 0x1.04808p+40, 0x0p+0 },
+{ UINT64_C(0x0000010484000000), 0x1.0484p+40, 0x0p+0 },
+{ UINT64_C(0x0000010488000000), 0x1.0488p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000000), 0x1.06p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000001), 0x1.0600000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000002), 0x1.0600000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000004), 0x1.0600000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000010), 0x1.060000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000020), 0x1.060000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600000200), 0x1.06000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600001000), 0x1.0600001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600002000), 0x1.0600002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600010000), 0x1.060001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600020000), 0x1.060002p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600080000), 0x1.060008p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600100000), 0x1.06001p+40, 0x0p+0 },
+{ UINT64_C(0x0000010600400000), 0x1.06004p+40, 0x0p+0 },
+{ UINT64_C(0x0000010604000000), 0x1.0604p+40, 0x0p+0 },
+{ UINT64_C(0x0000010610000000), 0x1.061p+40, 0x0p+0 },
+{ UINT64_C(0x0000010620000000), 0x1.062p+40, 0x0p+0 },
+{ UINT64_C(0x0000010700000000), 0x1.07p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000002), 0x1.2000000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000008), 0x1.2000000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000020), 0x1.200000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000024), 0x1.2000000024p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000040), 0x1.200000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000048), 0x1.2000000048p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000060), 0x1.200000006p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000100), 0x1.20000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000102), 0x1.2000000102p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000120), 0x1.200000012p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000200), 0x1.20000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000201), 0x1.2000000201p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000210), 0x1.200000021p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000000280), 0x1.200000028p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000002000), 0x1.2000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000002004), 0x1.2000002004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000002040), 0x1.200000204p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000002400), 0x1.20000024p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000004000), 0x1.2000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000004004), 0x1.2000004004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000004040), 0x1.200000404p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000004100), 0x1.20000041p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000004400), 0x1.20000044p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040000), 0x1.200004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040002), 0x1.2000040002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040008), 0x1.2000040008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040010), 0x1.200004001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040020), 0x1.200004002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040080), 0x1.200004008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000040200), 0x1.20000402p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000042000), 0x1.2000042p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000060000), 0x1.200006p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000100000), 0x1.20001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000100008), 0x1.2000100008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000100010), 0x1.200010001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000100100), 0x1.20001001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000101000), 0x1.2000101p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000108000), 0x1.2000108p+40, 0x0p+0 },
+{ UINT64_C(0x0000012000180000), 0x1.200018p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001000000), 0x1.2001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001000002), 0x1.2001000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001000004), 0x1.2001000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001000040), 0x1.200100004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001000400), 0x1.20010004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001000800), 0x1.20010008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001004000), 0x1.2001004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001010000), 0x1.200101p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001100000), 0x1.20011p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001200000), 0x1.20012p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001400000), 0x1.20014p+40, 0x0p+0 },
+{ UINT64_C(0x0000012001800000), 0x1.20018p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008000000), 0x1.2008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008000008), 0x1.2008000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008000010), 0x1.200800001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008000020), 0x1.200800002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008000040), 0x1.200800004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008000400), 0x1.20080004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008001000), 0x1.2008001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008002000), 0x1.2008002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008004000), 0x1.2008004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008020000), 0x1.200802p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008080000), 0x1.200808p+40, 0x0p+0 },
+{ UINT64_C(0x0000012008400000), 0x1.20084p+40, 0x0p+0 },
+{ UINT64_C(0x000001200c000000), 0x1.200cp+40, 0x0p+0 },
+{ UINT64_C(0x0000012040000000), 0x1.204p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040000001), 0x1.2040000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040000002), 0x1.2040000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040000010), 0x1.204000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040000040), 0x1.204000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040000200), 0x1.20400002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040002000), 0x1.2040002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040008000), 0x1.2040008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040020000), 0x1.204002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040100000), 0x1.20401p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040200000), 0x1.20402p+40, 0x0p+0 },
+{ UINT64_C(0x0000012040400000), 0x1.20404p+40, 0x0p+0 },
+{ UINT64_C(0x0000012044000000), 0x1.2044p+40, 0x0p+0 },
+{ UINT64_C(0x0000012050000000), 0x1.205p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080000000), 0x1.208p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080000002), 0x1.2080000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080000010), 0x1.208000001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080000040), 0x1.208000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080000200), 0x1.20800002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080000800), 0x1.20800008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080004000), 0x1.2080004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080010000), 0x1.208001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080040000), 0x1.208004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080080000), 0x1.208008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012080200000), 0x1.20802p+40, 0x0p+0 },
+{ UINT64_C(0x0000012082000000), 0x1.2082p+40, 0x0p+0 },
+{ UINT64_C(0x0000012088000000), 0x1.2088p+40, 0x0p+0 },
+{ UINT64_C(0x0000012090000000), 0x1.209p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100000000), 0x1.21p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100000008), 0x1.2100000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100000020), 0x1.210000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100000200), 0x1.21000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100000800), 0x1.21000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100008000), 0x1.2100008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100010000), 0x1.210001p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100020000), 0x1.210002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012100200000), 0x1.21002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012102000000), 0x1.2102p+40, 0x0p+0 },
+{ UINT64_C(0x0000012104000000), 0x1.2104p+40, 0x0p+0 },
+{ UINT64_C(0x0000012140000000), 0x1.214p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400000000), 0x1.24p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400000004), 0x1.2400000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400000008), 0x1.2400000008p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400000040), 0x1.240000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400000200), 0x1.24000002p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400000400), 0x1.24000004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400004000), 0x1.2400004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400040000), 0x1.240004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012400400000), 0x1.24004p+40, 0x0p+0 },
+{ UINT64_C(0x0000012402000000), 0x1.2402p+40, 0x0p+0 },
+{ UINT64_C(0x0000012410000000), 0x1.241p+40, 0x0p+0 },
+{ UINT64_C(0x0000012440000000), 0x1.244p+40, 0x0p+0 },
+{ UINT64_C(0x0000012480000000), 0x1.248p+40, 0x0p+0 },
+{ UINT64_C(0x0000012500000000), 0x1.25p+40, 0x0p+0 },
+{ UINT64_C(0x0000080000000011), 0x1.00000000022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000022), 0x1.00000000044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000024), 0x1.00000000048p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000102), 0x1.00000000204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000108), 0x1.0000000021p+43, 0x0p+0 },
+{ UINT64_C(0x000008000000010a), 0x1.00000000214p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000110), 0x1.0000000022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000111), 0x1.00000000222p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000112), 0x1.00000000224p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000118), 0x1.0000000023p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000120), 0x1.0000000024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000000122), 0x1.00000000244p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001001), 0x1.00000002002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001008), 0x1.0000000201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001010), 0x1.0000000202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001014), 0x1.00000002028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001020), 0x1.0000000204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001022), 0x1.00000002044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001080), 0x1.000000021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001084), 0x1.00000002108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001090), 0x1.0000000212p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000010c0), 0x1.0000000218p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001400), 0x1.000000028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001404), 0x1.00000002808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001420), 0x1.0000000284p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001480), 0x1.000000029p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000001600), 0x1.00000002cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010004), 0x1.00000020008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010010), 0x1.0000002002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010018), 0x1.0000002003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010100), 0x1.000000202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010102), 0x1.00000020204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010120), 0x1.0000002024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010400), 0x1.000000208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010401), 0x1.00000020802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010410), 0x1.0000002082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010480), 0x1.000000209p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010600), 0x1.00000020cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010800), 0x1.00000021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010801), 0x1.00000021002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010810), 0x1.0000002102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010840), 0x1.0000002108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010880), 0x1.000000211p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000010c00), 0x1.000000218p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000012000), 0x1.00000024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000012004), 0x1.00000024008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000012040), 0x1.0000002408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000012200), 0x1.000000244p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000012400), 0x1.000000248p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000012800), 0x1.00000025p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000013000), 0x1.00000026p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020002), 0x1.00000040004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020008), 0x1.0000004001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020080), 0x1.000000401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020088), 0x1.0000004011p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000200a0), 0x1.0000004014p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020800), 0x1.00000041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020802), 0x1.00000041004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020808), 0x1.0000004101p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000020880), 0x1.000000411p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000021000), 0x1.00000042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000021002), 0x1.00000042004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000021010), 0x1.0000004202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000021040), 0x1.0000004208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000021100), 0x1.000000422p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000030000), 0x1.0000006p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000030001), 0x1.00000060002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000030004), 0x1.00000060008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000030020), 0x1.0000006004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000030200), 0x1.000000604p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000030800), 0x1.00000061p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000038000), 0x1.0000007p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040008), 0x1.0000008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040009), 0x1.00000080012p+43, 0x0p+0 },
+{ UINT64_C(0x000008000004000c), 0x1.00000080018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040040), 0x1.0000008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040044), 0x1.00000080088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040048), 0x1.0000008009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040100), 0x1.000000802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040101), 0x1.00000080202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040102), 0x1.00000080204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040110), 0x1.0000008022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040800), 0x1.00000081p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040802), 0x1.00000081004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040820), 0x1.0000008104p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040840), 0x1.0000008108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000040c00), 0x1.000000818p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048000), 0x1.0000009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048001), 0x1.00000090002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048004), 0x1.00000090008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048008), 0x1.0000009001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048010), 0x1.0000009002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048080), 0x1.000000901p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048100), 0x1.000000902p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000048400), 0x1.000000908p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000049000), 0x1.00000092p+43, 0x0p+0 },
+{ UINT64_C(0x000008000004a000), 0x1.00000094p+43, 0x0p+0 },
+{ UINT64_C(0x000008000004c000), 0x1.00000098p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080001), 0x1.00000100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080002), 0x1.00000100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080003), 0x1.00000100006p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080010), 0x1.0000010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080012), 0x1.00000100024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080014), 0x1.00000100028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080020), 0x1.0000010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080021), 0x1.00000100042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080022), 0x1.00000100044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080030), 0x1.0000010006p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080040), 0x1.0000010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080042), 0x1.00000100084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080060), 0x1.000001000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080100), 0x1.000001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080104), 0x1.00000100208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080140), 0x1.0000010028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080800), 0x1.00000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080808), 0x1.0000010101p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080810), 0x1.0000010102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080840), 0x1.0000010108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000080900), 0x1.000001012p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000088000), 0x1.0000011p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000088004), 0x1.00000110008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000088040), 0x1.0000011008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000088200), 0x1.000001104p+43, 0x0p+0 },
+{ UINT64_C(0x000008000008a000), 0x1.00000114p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c0000), 0x1.0000018p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c0001), 0x1.00000180002p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c0004), 0x1.00000180008p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c0020), 0x1.0000018004p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c0040), 0x1.0000018008p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c0100), 0x1.000001802p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c1000), 0x1.00000182p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000c2000), 0x1.00000184p+43, 0x0p+0 },
+{ UINT64_C(0x00000800000e0000), 0x1.000001cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100008), 0x1.0000020001p+43, 0x0p+0 },
+{ UINT64_C(0x000008000010000a), 0x1.00000200014p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100040), 0x1.0000020008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100042), 0x1.00000200084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100048), 0x1.0000020009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100060), 0x1.000002000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100100), 0x1.000002002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100108), 0x1.0000020021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100110), 0x1.0000020022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000100140), 0x1.0000020028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000101000), 0x1.00000202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000101001), 0x1.00000202002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000101002), 0x1.00000202004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000101010), 0x1.0000020202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000101100), 0x1.000002022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000101200), 0x1.000002024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000102000), 0x1.00000204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000102008), 0x1.0000020401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000102080), 0x1.000002041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000102200), 0x1.000002044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000102800), 0x1.00000205p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000110000), 0x1.0000022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000110004), 0x1.00000220008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000110020), 0x1.0000022004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000110080), 0x1.000002201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000110100), 0x1.000002202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000110200), 0x1.000002204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000112000), 0x1.00000224p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000118000), 0x1.0000023p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000180000), 0x1.000003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000180004), 0x1.00000300008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000180020), 0x1.0000030004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000180040), 0x1.0000030008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000180200), 0x1.000003004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000180400), 0x1.000003008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000182000), 0x1.00000304p+43, 0x0p+0 },
+{ UINT64_C(0x0000080000188000), 0x1.0000031p+43, 0x0p+0 },
+{ UINT64_C(0x00000800001a0000), 0x1.0000034p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001000001), 0x1.00002000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001000010), 0x1.0000200002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001000012), 0x1.00002000024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001000100), 0x1.000020002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001000108), 0x1.0000200021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001000180), 0x1.000020003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001001000), 0x1.00002002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001001002), 0x1.00002002004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001001008), 0x1.0000200201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001001040), 0x1.0000200208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001001200), 0x1.000020024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001010000), 0x1.0000202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001010008), 0x1.0000202001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001010010), 0x1.0000202002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001010080), 0x1.000020201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001010800), 0x1.00002021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001012000), 0x1.00002024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001100000), 0x1.000022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001100008), 0x1.0000220001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001100020), 0x1.0000220004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001100200), 0x1.000022004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001100400), 0x1.000022008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001104000), 0x1.00002208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080001120000), 0x1.0000224p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000001), 0x1.00010000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000004), 0x1.00010000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000040), 0x1.0001000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000042), 0x1.00010000084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000060), 0x1.000100000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000200), 0x1.000100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000204), 0x1.00010000408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000208), 0x1.0001000041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000210), 0x1.0001000042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000280), 0x1.000100005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000300), 0x1.000100006p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000400), 0x1.000100008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000404), 0x1.00010000808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000440), 0x1.0001000088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000600), 0x1.00010000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000800), 0x1.00010001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000801), 0x1.00010001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000808), 0x1.0001000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008000880), 0x1.000100011p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008004000), 0x1.00010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008004008), 0x1.0001000801p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008004080), 0x1.000100081p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008004200), 0x1.000100084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008004400), 0x1.000100088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008004800), 0x1.00010009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010000), 0x1.0001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010001), 0x1.00010020002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010004), 0x1.00010020008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010020), 0x1.0001002004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010040), 0x1.0001002008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010080), 0x1.000100201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010200), 0x1.000100204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008010400), 0x1.000100208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008012000), 0x1.00010024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008040000), 0x1.0001008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008040008), 0x1.0001008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008040020), 0x1.0001008004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008040040), 0x1.0001008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008040200), 0x1.000100804p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008041000), 0x1.00010082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008048000), 0x1.0001009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008080000), 0x1.000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008080008), 0x1.0001010001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008080010), 0x1.0001010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008080020), 0x1.0001010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008080080), 0x1.000101001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008080400), 0x1.000101008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008082000), 0x1.00010104p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008090000), 0x1.0001012p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008100000), 0x1.000102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008100004), 0x1.00010200008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008100020), 0x1.0001020004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008100080), 0x1.000102001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008100200), 0x1.000102004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008100800), 0x1.00010201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008102000), 0x1.00010204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008120000), 0x1.0001024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008400000), 0x1.000108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008400008), 0x1.0001080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008400020), 0x1.0001080004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008400080), 0x1.000108001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008400800), 0x1.00010801p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008404000), 0x1.00010808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008440000), 0x1.0001088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080008480000), 0x1.000109p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c000000), 0x1.00018p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c000008), 0x1.0001800001p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c000040), 0x1.0001800008p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c000100), 0x1.000180002p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c000400), 0x1.000180008p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c004000), 0x1.00018008p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c040000), 0x1.0001808p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c100000), 0x1.000182p+43, 0x0p+0 },
+{ UINT64_C(0x000008000c800000), 0x1.00019p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000002), 0x1.00080000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000010), 0x1.0008000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000018), 0x1.0008000003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000040), 0x1.0008000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000041), 0x1.00080000082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000044), 0x1.00080000088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000060), 0x1.000800000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000400), 0x1.000800008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000404), 0x1.00080000808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000408), 0x1.0008000081p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000420), 0x1.0008000084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040000600), 0x1.00080000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080040001000), 0x1.00080002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040001008), 0x1.0008000201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040001020), 0x1.0008000204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040001040), 0x1.0008000208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040001400), 0x1.000800028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040001800), 0x1.00080003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040004000), 0x1.00080008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040004004), 0x1.00080008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040004010), 0x1.0008000802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040004100), 0x1.000800082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040005000), 0x1.0008000ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080040008000), 0x1.0008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040008008), 0x1.0008001001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040008020), 0x1.0008001004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040008040), 0x1.0008001008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040008100), 0x1.000800102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040009000), 0x1.00080012p+43, 0x0p+0 },
+{ UINT64_C(0x000008004000c000), 0x1.00080018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040080000), 0x1.000801p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040080002), 0x1.00080100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040080010), 0x1.0008010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040080080), 0x1.000801001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040080100), 0x1.000801002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040080400), 0x1.000801008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040084000), 0x1.00080108p+43, 0x0p+0 },
+{ UINT64_C(0x00000800400a0000), 0x1.0008014p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040100000), 0x1.000802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040100001), 0x1.00080200002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040100008), 0x1.0008020001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040100080), 0x1.000802001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040100200), 0x1.000802004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040100400), 0x1.000802008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040101000), 0x1.00080202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040102000), 0x1.00080204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040104000), 0x1.00080208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040110000), 0x1.0008022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040180000), 0x1.000803p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040400000), 0x1.000808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040400001), 0x1.00080800002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040400008), 0x1.0008080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040400080), 0x1.000808001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040400400), 0x1.000808008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040404000), 0x1.00080808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040408000), 0x1.0008081p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040410000), 0x1.0008082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040420000), 0x1.0008084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080040500000), 0x1.00080ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080042000000), 0x1.00084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042000001), 0x1.00084000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042000010), 0x1.0008400002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042000100), 0x1.000840002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042000200), 0x1.000840004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042000400), 0x1.000840008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042004000), 0x1.00084008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042008000), 0x1.0008401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042040000), 0x1.0008408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042080000), 0x1.000841p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042100000), 0x1.000842p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042400000), 0x1.000848p+43, 0x0p+0 },
+{ UINT64_C(0x0000080042800000), 0x1.00085p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048000000), 0x1.0009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048000004), 0x1.00090000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048000010), 0x1.0009000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048000080), 0x1.000900001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048000400), 0x1.000900008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048002000), 0x1.00090004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048008000), 0x1.0009001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048080000), 0x1.000901p+43, 0x0p+0 },
+{ UINT64_C(0x0000080048800000), 0x1.00091p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000004), 0x1.00100000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000040), 0x1.0010000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000041), 0x1.00100000082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000048), 0x1.0010000009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000060), 0x1.001000000cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000400), 0x1.001000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000404), 0x1.00100000808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000420), 0x1.0010000084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000500), 0x1.00100000ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000800), 0x1.00100001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000804), 0x1.00100001008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000808), 0x1.0010000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000820), 0x1.0010000104p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000900), 0x1.001000012p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080000c00), 0x1.001000018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002000), 0x1.00100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002001), 0x1.00100004002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002008), 0x1.0010000401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002080), 0x1.001000041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002100), 0x1.001000042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002400), 0x1.001000048p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080002800), 0x1.00100005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080010000), 0x1.0010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080010004), 0x1.00100020008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080010010), 0x1.0010002002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080010040), 0x1.0010002008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080010080), 0x1.001000201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080010100), 0x1.001000202p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080011000), 0x1.00100022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080012000), 0x1.00100024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080018000), 0x1.0010003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080020000), 0x1.0010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080020008), 0x1.0010004001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080020010), 0x1.0010004002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080020100), 0x1.001000402p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080020400), 0x1.001000408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080022000), 0x1.00100044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080028000), 0x1.0010005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080000), 0x1.001001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080001), 0x1.00100100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080004), 0x1.00100100008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080020), 0x1.0010010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080040), 0x1.0010010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080080), 0x1.001001001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080080200), 0x1.001001004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080082000), 0x1.00100104p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080084000), 0x1.00100108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080090000), 0x1.0010012p+43, 0x0p+0 },
+{ UINT64_C(0x00000800800c0000), 0x1.0010018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080400000), 0x1.001008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080400008), 0x1.0010080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080400020), 0x1.0010080004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080400080), 0x1.001008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080400100), 0x1.001008002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080400200), 0x1.001008004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080401000), 0x1.00100802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080402000), 0x1.00100804p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080420000), 0x1.0010084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080080500000), 0x1.00100ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080081000000), 0x1.00102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081000008), 0x1.0010200001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081000080), 0x1.001020001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081000200), 0x1.001020004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081001000), 0x1.00102002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081002000), 0x1.00102004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081020000), 0x1.0010204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081100000), 0x1.001022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081200000), 0x1.001024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080081400000), 0x1.001028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082000000), 0x1.00104p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082000008), 0x1.0010400001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082000080), 0x1.001040001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082000800), 0x1.00104001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082002000), 0x1.00104004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082004000), 0x1.00104008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082010000), 0x1.0010402p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082040000), 0x1.0010408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080082100000), 0x1.001042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080083000000), 0x1.00106p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088000000), 0x1.0011p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088000001), 0x1.00110000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088000008), 0x1.0011000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088000080), 0x1.001100001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088000400), 0x1.001100008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088000800), 0x1.00110001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088008000), 0x1.0011001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088010000), 0x1.0011002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088100000), 0x1.001102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088400000), 0x1.001108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080088800000), 0x1.00111p+43, 0x0p+0 },
+{ UINT64_C(0x0000080089000000), 0x1.00112p+43, 0x0p+0 },
+{ UINT64_C(0x000008008a000000), 0x1.00114p+43, 0x0p+0 },
+{ UINT64_C(0x000008008c000000), 0x1.00118p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000008), 0x1.0040000001p+43, 0x0p+0 },
+{ UINT64_C(0x000008020000000a), 0x1.00400000014p+43, 0x0p+0 },
+{ UINT64_C(0x000008020000000c), 0x1.00400000018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000010), 0x1.0040000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000014), 0x1.00400000028p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000040), 0x1.0040000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000042), 0x1.00400000084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000048), 0x1.0040000009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000080), 0x1.004000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000082), 0x1.00400000104p+43, 0x0p+0 },
+{ UINT64_C(0x00000802000000a0), 0x1.0040000014p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000200), 0x1.004000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000202), 0x1.00400000404p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000220), 0x1.0040000044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000240), 0x1.0040000048p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200000280), 0x1.004000005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200002000), 0x1.00400004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200002002), 0x1.00400004004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200002020), 0x1.0040000404p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200002080), 0x1.004000041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200002800), 0x1.00400005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200008000), 0x1.0040001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200008001), 0x1.00400010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200008010), 0x1.0040001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200008100), 0x1.004000102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200008400), 0x1.004000108p+43, 0x0p+0 },
+{ UINT64_C(0x000008020000a000), 0x1.00400014p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200040000), 0x1.0040008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200040001), 0x1.00400080002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200040004), 0x1.00400080008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200040040), 0x1.0040008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200040400), 0x1.004000808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200044000), 0x1.00400088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200048000), 0x1.0040009p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200200000), 0x1.004004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200200004), 0x1.00400400008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200200040), 0x1.0040040008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200200400), 0x1.004004008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200202000), 0x1.00400404p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200220000), 0x1.0040044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200280000), 0x1.004005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200400000), 0x1.004008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200400004), 0x1.00400800008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200400008), 0x1.0040080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200400040), 0x1.0040080008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200400080), 0x1.004008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200400800), 0x1.00400801p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200408000), 0x1.0040081p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200440000), 0x1.0040088p+43, 0x0p+0 },
+{ UINT64_C(0x0000080200500000), 0x1.00400ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080200600000), 0x1.00400cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080202000000), 0x1.00404p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202000002), 0x1.00404000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202000008), 0x1.0040400001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202000080), 0x1.004040001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202000200), 0x1.004040004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202002000), 0x1.00404004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202008000), 0x1.0040401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202010000), 0x1.0040402p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202080000), 0x1.004041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080202100000), 0x1.004042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080203000000), 0x1.00406p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204000000), 0x1.00408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204000004), 0x1.00408000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204000010), 0x1.0040800002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204000040), 0x1.0040800008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204000400), 0x1.004080008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204004000), 0x1.00408008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204020000), 0x1.0040804p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204040000), 0x1.0040808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080204100000), 0x1.004082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080205000000), 0x1.0040ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080220000000), 0x1.0044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220000008), 0x1.0044000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220000020), 0x1.0044000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220000100), 0x1.004400002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220001000), 0x1.00440002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220010000), 0x1.0044002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220020000), 0x1.0044004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220200000), 0x1.004404p+43, 0x0p+0 },
+{ UINT64_C(0x0000080220800000), 0x1.00441p+43, 0x0p+0 },
+{ UINT64_C(0x0000080224000000), 0x1.00448p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240000000), 0x1.0048p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240000008), 0x1.0048000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240000040), 0x1.0048000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240000100), 0x1.004800002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240000200), 0x1.004800004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240000800), 0x1.00480001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240008000), 0x1.0048001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240020000), 0x1.0048004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240100000), 0x1.004802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240200000), 0x1.004804p+43, 0x0p+0 },
+{ UINT64_C(0x0000080240800000), 0x1.00481p+43, 0x0p+0 },
+{ UINT64_C(0x0000080242000000), 0x1.00484p+43, 0x0p+0 },
+{ UINT64_C(0x0000080260000000), 0x1.004cp+43, 0x0p+0 },
+{ UINT64_C(0x0000080280000000), 0x1.005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280000004), 0x1.00500000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280000008), 0x1.0050000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280000040), 0x1.0050000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280000200), 0x1.005000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280000400), 0x1.005000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280002000), 0x1.00500004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280004000), 0x1.00500008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280040000), 0x1.0050008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280080000), 0x1.005001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080280800000), 0x1.00501p+43, 0x0p+0 },
+{ UINT64_C(0x0000080281000000), 0x1.00502p+43, 0x0p+0 },
+{ UINT64_C(0x0000080290000000), 0x1.0052p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000008), 0x1.0080000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000009), 0x1.00800000012p+43, 0x0p+0 },
+{ UINT64_C(0x000008040000000c), 0x1.00800000018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000010), 0x1.0080000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000011), 0x1.00800000022p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000012), 0x1.00800000024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000018), 0x1.0080000003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000020), 0x1.0080000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000022), 0x1.00800000044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000028), 0x1.0080000005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000080), 0x1.008000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000084), 0x1.00800000108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000090), 0x1.0080000012p+43, 0x0p+0 },
+{ UINT64_C(0x00000804000000c0), 0x1.0080000018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000200), 0x1.008000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000208), 0x1.0080000041p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400000240), 0x1.0080000048p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400002000), 0x1.00800004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400002008), 0x1.0080000401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400002040), 0x1.0080000408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400002200), 0x1.008000044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400002800), 0x1.00800005p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008000), 0x1.0080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008008), 0x1.0080001001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008010), 0x1.0080001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008020), 0x1.0080001004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008040), 0x1.0080001008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008100), 0x1.008000102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400008400), 0x1.008000108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400009000), 0x1.00800012p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400080000), 0x1.008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400080001), 0x1.00800100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400080002), 0x1.00800100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400080020), 0x1.0080010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400080100), 0x1.008001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400080200), 0x1.008001004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400081000), 0x1.00800102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400090000), 0x1.0080012p+43, 0x0p+0 },
+{ UINT64_C(0x00000804000a0000), 0x1.0080014p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400100000), 0x1.008002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400100002), 0x1.00800200004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400100004), 0x1.00800200008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400100020), 0x1.0080020004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400100200), 0x1.008002004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400100800), 0x1.00800201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400108000), 0x1.0080021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400180000), 0x1.008003p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400200000), 0x1.008004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400200008), 0x1.0080040001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400200020), 0x1.0080040004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400200080), 0x1.008004001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400200100), 0x1.008004002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400200800), 0x1.00800401p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400201000), 0x1.00800402p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400210000), 0x1.0080042p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400300000), 0x1.008006p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400800000), 0x1.00801p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400800004), 0x1.00801000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400800010), 0x1.0080100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400800020), 0x1.0080100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400800200), 0x1.008010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400801000), 0x1.00801002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400810000), 0x1.0080102p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400840000), 0x1.0080108p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400900000), 0x1.008012p+43, 0x0p+0 },
+{ UINT64_C(0x0000080400c00000), 0x1.008018p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401000000), 0x1.00802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401000001), 0x1.00802000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401000010), 0x1.0080200002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401000100), 0x1.008020002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401000800), 0x1.00802001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401008000), 0x1.0080201p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401020000), 0x1.0080204p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401040000), 0x1.0080208p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401080000), 0x1.008021p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401200000), 0x1.008024p+43, 0x0p+0 },
+{ UINT64_C(0x0000080401800000), 0x1.00803p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402000000), 0x1.00804p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402000002), 0x1.00804000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402000020), 0x1.0080400004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402000200), 0x1.008040004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402000400), 0x1.008040008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402004000), 0x1.00804008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402020000), 0x1.0080404p+43, 0x0p+0 },
+{ UINT64_C(0x0000080402200000), 0x1.008044p+43, 0x0p+0 },
+{ UINT64_C(0x0000080403000000), 0x1.00806p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404000000), 0x1.00808p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404000002), 0x1.00808000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404000010), 0x1.0080800002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404000020), 0x1.0080800004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404000200), 0x1.008080004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404001000), 0x1.00808002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404010000), 0x1.0080802p+43, 0x0p+0 },
+{ UINT64_C(0x0000080404100000), 0x1.008082p+43, 0x0p+0 },
+{ UINT64_C(0x0000080405000000), 0x1.0080ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080420000000), 0x1.0084p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420000002), 0x1.00840000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420000008), 0x1.0084000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420000080), 0x1.008400001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420000100), 0x1.008400002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420000800), 0x1.00840001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420002000), 0x1.00840004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420008000), 0x1.0084001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420040000), 0x1.0084008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420100000), 0x1.008402p+43, 0x0p+0 },
+{ UINT64_C(0x0000080420400000), 0x1.008408p+43, 0x0p+0 },
+{ UINT64_C(0x0000080421000000), 0x1.00842p+43, 0x0p+0 },
+{ UINT64_C(0x0000080428000000), 0x1.0085p+43, 0x0p+0 },
+{ UINT64_C(0x0000080430000000), 0x1.0086p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500000000), 0x1.00ap+43, 0x0p+0 },
+{ UINT64_C(0x0000080500000004), 0x1.00a00000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500000040), 0x1.00a0000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500000100), 0x1.00a000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500001000), 0x1.00a00002p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500002000), 0x1.00a00004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500004000), 0x1.00a00008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500008000), 0x1.00a0001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500020000), 0x1.00a0004p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500080000), 0x1.00a001p+43, 0x0p+0 },
+{ UINT64_C(0x0000080500400000), 0x1.00a008p+43, 0x0p+0 },
+{ UINT64_C(0x0000080501000000), 0x1.00a02p+43, 0x0p+0 },
+{ UINT64_C(0x0000080502000000), 0x1.00a04p+43, 0x0p+0 },
+{ UINT64_C(0x0000080504000000), 0x1.00a08p+43, 0x0p+0 },
+{ UINT64_C(0x0000080520000000), 0x1.00a4p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000001), 0x1.08000000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000010), 0x1.0800000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000011), 0x1.08000000022p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000100), 0x1.080000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000108), 0x1.0800000021p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000120), 0x1.0800000024p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000180), 0x1.080000003p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000200), 0x1.080000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000202), 0x1.08000000404p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000208), 0x1.0800000041p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000280), 0x1.080000005p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000300), 0x1.080000006p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000800), 0x1.08000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000801), 0x1.08000001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000808), 0x1.0800000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000880), 0x1.080000011p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000000900), 0x1.080000012p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000004000), 0x1.08000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000004002), 0x1.08000008004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000004004), 0x1.08000008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000004010), 0x1.0800000802p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000004100), 0x1.080000082p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000005000), 0x1.0800000ap+43, 0x0p+0 },
+{ UINT64_C(0x0000084000010000), 0x1.0800002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000010004), 0x1.08000020008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000010008), 0x1.0800002001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000010080), 0x1.080000201p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000010200), 0x1.080000204p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000012000), 0x1.08000024p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000080000), 0x1.080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000080008), 0x1.0800010001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000080010), 0x1.0800010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000080080), 0x1.080001001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000080800), 0x1.08000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000088000), 0x1.0800011p+43, 0x0p+0 },
+{ UINT64_C(0x00000840000a0000), 0x1.0800014p+43, 0x0p+0 },
+{ UINT64_C(0x00000840000c0000), 0x1.0800018p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100000), 0x1.080002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100008), 0x1.0800020001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100020), 0x1.0800020004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100040), 0x1.0800020008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100080), 0x1.080002001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100400), 0x1.080002008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000100800), 0x1.08000201p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000101000), 0x1.08000202p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000108000), 0x1.0800021p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000110000), 0x1.0800022p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000140000), 0x1.0800028p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000800000), 0x1.08001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000800004), 0x1.08001000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000800040), 0x1.0800100008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000800080), 0x1.080010001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000800400), 0x1.080010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000801000), 0x1.08001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000802000), 0x1.08001004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000810000), 0x1.0800102p+43, 0x0p+0 },
+{ UINT64_C(0x0000084000900000), 0x1.080012p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008000000), 0x1.0801p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008000004), 0x1.08010000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008000040), 0x1.0801000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008000200), 0x1.080100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008002000), 0x1.08010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008004000), 0x1.08010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008020000), 0x1.0801004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008040000), 0x1.0801008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084008200000), 0x1.080104p+43, 0x0p+0 },
+{ UINT64_C(0x0000084009000000), 0x1.08012p+43, 0x0p+0 },
+{ UINT64_C(0x000008400a000000), 0x1.08014p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010000000), 0x1.0802p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010000002), 0x1.08020000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010000008), 0x1.0802000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010000040), 0x1.0802000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010000100), 0x1.080200002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010001000), 0x1.08020002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010010000), 0x1.0802002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010100000), 0x1.080202p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010200000), 0x1.080204p+43, 0x0p+0 },
+{ UINT64_C(0x0000084010800000), 0x1.08021p+43, 0x0p+0 },
+{ UINT64_C(0x0000084014000000), 0x1.08028p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080000000), 0x1.081p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080000002), 0x1.08100000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080000010), 0x1.0810000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080000100), 0x1.081000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080001000), 0x1.08100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080008000), 0x1.0810001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080020000), 0x1.0810004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084080100000), 0x1.081002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084081000000), 0x1.08102p+43, 0x0p+0 },
+{ UINT64_C(0x0000084088000000), 0x1.0811p+43, 0x0p+0 },
+{ UINT64_C(0x00000840a0000000), 0x1.0814p+43, 0x0p+0 },
+{ UINT64_C(0x00000840c0000000), 0x1.0818p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800000000), 0x1.09p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800000004), 0x1.09000000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800000008), 0x1.0900000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800000040), 0x1.0900000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800000200), 0x1.090000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800000800), 0x1.09000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800001000), 0x1.09000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800004000), 0x1.09000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800040000), 0x1.0900008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800200000), 0x1.090004p+43, 0x0p+0 },
+{ UINT64_C(0x0000084800800000), 0x1.09001p+43, 0x0p+0 },
+{ UINT64_C(0x0000084801000000), 0x1.09002p+43, 0x0p+0 },
+{ UINT64_C(0x0000084804000000), 0x1.09008p+43, 0x0p+0 },
+{ UINT64_C(0x0000084808000000), 0x1.0901p+43, 0x0p+0 },
+{ UINT64_C(0x0000084820000000), 0x1.0904p+43, 0x0p+0 },
+{ UINT64_C(0x0000084840000000), 0x1.0908p+43, 0x0p+0 },
+{ UINT64_C(0x0000084c00000000), 0x1.098p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000000), 0x1.0ap+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000002), 0x1.0a000000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000008), 0x1.0a00000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000010), 0x1.0a00000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000040), 0x1.0a00000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000100), 0x1.0a0000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000000400), 0x1.0a0000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000002000), 0x1.0a000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000004000), 0x1.0a000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000008000), 0x1.0a00001p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000080000), 0x1.0a0001p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000200000), 0x1.0a0004p+43, 0x0p+0 },
+{ UINT64_C(0x0000085000400000), 0x1.0a0008p+43, 0x0p+0 },
+{ UINT64_C(0x0000085002000000), 0x1.0a004p+43, 0x0p+0 },
+{ UINT64_C(0x0000085020000000), 0x1.0a04p+43, 0x0p+0 },
+{ UINT64_C(0x0000085040000000), 0x1.0a08p+43, 0x0p+0 },
+{ UINT64_C(0x0000085080000000), 0x1.0a1p+43, 0x0p+0 },
+{ UINT64_C(0x0000085400000000), 0x1.0a8p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000008), 0x1.2000000001p+43, 0x0p+0 },
+{ UINT64_C(0x000009000000000c), 0x1.20000000018p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000020), 0x1.2000000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000024), 0x1.20000000048p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000030), 0x1.2000000006p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000200), 0x1.200000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000204), 0x1.20000000408p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000210), 0x1.2000000042p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000240), 0x1.2000000048p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000280), 0x1.200000005p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000300), 0x1.200000006p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000800), 0x1.20000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000801), 0x1.20000001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000810), 0x1.2000000102p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000900), 0x1.200000012p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000000a00), 0x1.200000014p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008000), 0x1.2000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008002), 0x1.20000010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008008), 0x1.2000001001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008010), 0x1.2000001002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008080), 0x1.200000101p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008100), 0x1.200000102p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008200), 0x1.200000104p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000008800), 0x1.20000011p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000009000), 0x1.20000012p+43, 0x0p+0 },
+{ UINT64_C(0x000009000000a000), 0x1.20000014p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000080000), 0x1.200001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000080004), 0x1.20000100008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000080010), 0x1.2000010002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000080040), 0x1.2000010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000080200), 0x1.200001004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000081000), 0x1.20000102p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000090000), 0x1.2000012p+43, 0x0p+0 },
+{ UINT64_C(0x00000900000c0000), 0x1.2000018p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000100000), 0x1.200002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000100002), 0x1.20000200004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000100020), 0x1.2000020004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000100080), 0x1.200002001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000100200), 0x1.200002004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000102000), 0x1.20000204p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000104000), 0x1.20000208p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000108000), 0x1.2000021p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000140000), 0x1.2000028p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000180000), 0x1.200003p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400000), 0x1.200008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400002), 0x1.20000800004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400008), 0x1.2000080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400020), 0x1.2000080004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400080), 0x1.200008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400400), 0x1.200008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000400800), 0x1.20000801p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000402000), 0x1.20000804p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000410000), 0x1.2000082p+43, 0x0p+0 },
+{ UINT64_C(0x0000090000500000), 0x1.20000ap+43, 0x0p+0 },
+{ UINT64_C(0x0000090002000000), 0x1.20004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002000004), 0x1.20004000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002000008), 0x1.2000400001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002000010), 0x1.2000400002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002000080), 0x1.200040001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002000800), 0x1.20004001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002002000), 0x1.20004004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002004000), 0x1.20004008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002040000), 0x1.2000408p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002100000), 0x1.200042p+43, 0x0p+0 },
+{ UINT64_C(0x0000090002800000), 0x1.20005p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004000000), 0x1.20008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004000004), 0x1.20008000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004000008), 0x1.2000800001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004000080), 0x1.200080001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004000800), 0x1.20008001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004004000), 0x1.20008008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004008000), 0x1.2000801p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004020000), 0x1.2000804p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004040000), 0x1.2000808p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004080000), 0x1.200081p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004100000), 0x1.200082p+43, 0x0p+0 },
+{ UINT64_C(0x0000090004800000), 0x1.20009p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008000000), 0x1.2001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008000004), 0x1.20010000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008000040), 0x1.2001000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008000200), 0x1.200100004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008002000), 0x1.20010004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008004000), 0x1.20010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008040000), 0x1.2001008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008080000), 0x1.200101p+43, 0x0p+0 },
+{ UINT64_C(0x0000090008400000), 0x1.200108p+43, 0x0p+0 },
+{ UINT64_C(0x000009000a000000), 0x1.20014p+43, 0x0p+0 },
+{ UINT64_C(0x000009000c000000), 0x1.20018p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010000000), 0x1.2002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010000004), 0x1.20020000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010000040), 0x1.2002000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010000100), 0x1.200200002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010000200), 0x1.200200004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010001000), 0x1.20020002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010010000), 0x1.2002002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010020000), 0x1.2002004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010100000), 0x1.200202p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010400000), 0x1.200208p+43, 0x0p+0 },
+{ UINT64_C(0x0000090010800000), 0x1.20021p+43, 0x0p+0 },
+{ UINT64_C(0x0000090014000000), 0x1.20028p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080000000), 0x1.201p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080000001), 0x1.20100000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080000002), 0x1.20100000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080000008), 0x1.2010000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080000080), 0x1.201000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080000100), 0x1.201000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080001000), 0x1.20100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080008000), 0x1.2010001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080040000), 0x1.2010008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080100000), 0x1.201002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090080400000), 0x1.201008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090084000000), 0x1.20108p+43, 0x0p+0 },
+{ UINT64_C(0x00000900a0000000), 0x1.2014p+43, 0x0p+0 },
+{ UINT64_C(0x00000900c0000000), 0x1.2018p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800000000), 0x1.21p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800000004), 0x1.21000000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800000020), 0x1.2100000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800000100), 0x1.210000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800001000), 0x1.21000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800010000), 0x1.2100002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800040000), 0x1.2100008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800100000), 0x1.210002p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800400000), 0x1.210008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090800800000), 0x1.21001p+43, 0x0p+0 },
+{ UINT64_C(0x0000090804000000), 0x1.21008p+43, 0x0p+0 },
+{ UINT64_C(0x0000090820000000), 0x1.2104p+43, 0x0p+0 },
+{ UINT64_C(0x0000090900000000), 0x1.212p+43, 0x0p+0 },
+{ UINT64_C(0x0000090c00000000), 0x1.218p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000000000), 0x1.24p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000000001), 0x1.24000000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000000004), 0x1.24000000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000000040), 0x1.2400000008p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000000100), 0x1.240000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000000800), 0x1.24000001p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000001000), 0x1.24000002p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000002000), 0x1.24000004p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000020000), 0x1.2400004p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000080000), 0x1.240001p+43, 0x0p+0 },
+{ UINT64_C(0x0000092000200000), 0x1.240004p+43, 0x0p+0 },
+{ UINT64_C(0x0000092002000000), 0x1.24004p+43, 0x0p+0 },
+{ UINT64_C(0x0000092020000000), 0x1.2404p+43, 0x0p+0 },
+{ UINT64_C(0x0000092040000000), 0x1.2408p+43, 0x0p+0 },
+{ UINT64_C(0x0000092080000000), 0x1.241p+43, 0x0p+0 },
+{ UINT64_C(0x0000092100000000), 0x1.242p+43, 0x0p+0 },
+{ UINT64_C(0x0000092800000000), 0x1.25p+43, 0x0p+0 },
+{ UINT64_C(0x0000100000000003), 0x1.00000000003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000028), 0x1.00000000028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000029), 0x1.00000000029p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000030), 0x1.0000000003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000034), 0x1.00000000034p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000038), 0x1.00000000038p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000041), 0x1.00000000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000050), 0x1.0000000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000058), 0x1.00000000058p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000408), 0x1.00000000408p+44, 0x0p+0 },
+{ UINT64_C(0x000010000000040a), 0x1.0000000040ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000410), 0x1.0000000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000414), 0x1.00000000414p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000418), 0x1.00000000418p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000480), 0x1.0000000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000484), 0x1.00000000484p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000000488), 0x1.00000000488p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004002), 0x1.00000004002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004010), 0x1.0000000401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004012), 0x1.00000004012p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004040), 0x1.0000000404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004042), 0x1.00000004042p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004048), 0x1.00000004048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004060), 0x1.0000000406p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004100), 0x1.000000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004101), 0x1.00000004101p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004110), 0x1.0000000411p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004180), 0x1.0000000418p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004400), 0x1.000000044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004401), 0x1.00000004401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004404), 0x1.00000004404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004410), 0x1.0000000441p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004480), 0x1.0000000448p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004800), 0x1.000000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004802), 0x1.00000004802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004808), 0x1.00000004808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004820), 0x1.0000000482p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000004a00), 0x1.00000004ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100000006000), 0x1.00000006p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000006001), 0x1.00000006001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000006002), 0x1.00000006002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000006020), 0x1.0000000602p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000006100), 0x1.000000061p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000006400), 0x1.000000064p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040001), 0x1.00000040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040010), 0x1.0000004001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040011), 0x1.00000040011p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040018), 0x1.00000040018p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040100), 0x1.000000401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040108), 0x1.00000040108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040180), 0x1.0000004018p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040200), 0x1.000000402p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040208), 0x1.00000040208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040240), 0x1.0000004024p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000040300), 0x1.000000403p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000041000), 0x1.00000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000041001), 0x1.00000041001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000041002), 0x1.00000041002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000041020), 0x1.0000004102p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000041080), 0x1.0000004108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000041200), 0x1.000000412p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000042000), 0x1.00000042p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000042001), 0x1.00000042001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000042010), 0x1.0000004201p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000042040), 0x1.0000004204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000042400), 0x1.000000424p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000048000), 0x1.00000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000048008), 0x1.00000048008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000048040), 0x1.0000004804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000048080), 0x1.0000004808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000048800), 0x1.000000488p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080001), 0x1.00000080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080010), 0x1.0000008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080018), 0x1.00000080018p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080020), 0x1.0000008002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080022), 0x1.00000080022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080028), 0x1.00000080028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080200), 0x1.000000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080208), 0x1.00000080208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080220), 0x1.0000008022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000080300), 0x1.000000803p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000082000), 0x1.00000082p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000082004), 0x1.00000082004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000082020), 0x1.0000008202p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000082040), 0x1.0000008204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000082080), 0x1.0000008208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000082400), 0x1.000000824p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000088000), 0x1.00000088p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000088004), 0x1.00000088004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000088010), 0x1.0000008801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000088020), 0x1.0000008802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000088200), 0x1.000000882p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000088400), 0x1.000000884p+44, 0x0p+0 },
+{ UINT64_C(0x000010000008a000), 0x1.0000008ap+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a0000), 0x1.000000ap+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a0002), 0x1.000000a0002p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a0004), 0x1.000000a0004p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a0020), 0x1.000000a002p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a0100), 0x1.000000a01p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a0800), 0x1.000000a08p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000a4000), 0x1.000000a4p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000c0000), 0x1.000000cp+44, 0x0p+0 },
+{ UINT64_C(0x00001000000c0008), 0x1.000000c0008p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000c0020), 0x1.000000c002p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000c0100), 0x1.000000c01p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000c1000), 0x1.000000c1p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000c4000), 0x1.000000c4p+44, 0x0p+0 },
+{ UINT64_C(0x00001000000d0000), 0x1.000000dp+44, 0x0p+0 },
+{ UINT64_C(0x00001000000e0000), 0x1.000000ep+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400008), 0x1.00000400008p+44, 0x0p+0 },
+{ UINT64_C(0x000010000040000c), 0x1.0000040000cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400010), 0x1.0000040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400018), 0x1.00000400018p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400080), 0x1.0000040008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400084), 0x1.00000400084p+44, 0x0p+0 },
+{ UINT64_C(0x00001000004000a0), 0x1.000004000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400400), 0x1.000004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400401), 0x1.00000400401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400404), 0x1.00000400404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000400440), 0x1.0000040044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000404000), 0x1.00000404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000404004), 0x1.00000404004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000404010), 0x1.0000040401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000404100), 0x1.000004041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000404200), 0x1.000004042p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000404400), 0x1.000004044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000405000), 0x1.00000405p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000408000), 0x1.00000408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000408008), 0x1.00000408008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000408040), 0x1.0000040804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000408080), 0x1.0000040808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000408100), 0x1.000004081p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000408400), 0x1.000004084p+44, 0x0p+0 },
+{ UINT64_C(0x000010000040c000), 0x1.0000040cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100000410000), 0x1.0000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000410002), 0x1.00000410002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000410020), 0x1.0000041002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000410100), 0x1.000004101p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000410800), 0x1.000004108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000411000), 0x1.00000411p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000418000), 0x1.00000418p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440000), 0x1.0000044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440004), 0x1.00000440004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440008), 0x1.00000440008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440010), 0x1.0000044001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440020), 0x1.0000044002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440200), 0x1.000004402p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000440400), 0x1.000004404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000441000), 0x1.00000441p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000444000), 0x1.00000444p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000448000), 0x1.00000448p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000450000), 0x1.0000045p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000480000), 0x1.0000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000480002), 0x1.00000480002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000480008), 0x1.00000480008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000480020), 0x1.0000048002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000480200), 0x1.000004802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000481000), 0x1.00000481p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000484000), 0x1.00000484p+44, 0x0p+0 },
+{ UINT64_C(0x00001000004a0000), 0x1.000004ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100000500000), 0x1.000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000500008), 0x1.00000500008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000500020), 0x1.0000050002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000500080), 0x1.0000050008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000500800), 0x1.000005008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000502000), 0x1.00000502p+44, 0x0p+0 },
+{ UINT64_C(0x0000100000520000), 0x1.0000052p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000002), 0x1.00004000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000008), 0x1.00004000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000040), 0x1.0000400004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000041), 0x1.00004000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000050), 0x1.0000400005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000060), 0x1.0000400006p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000200), 0x1.000040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000202), 0x1.00004000202p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004000220), 0x1.0000400022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001000), 0x1.00004001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001002), 0x1.00004001002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001004), 0x1.00004001004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001008), 0x1.00004001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001040), 0x1.0000400104p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001080), 0x1.0000400108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001400), 0x1.000040014p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004001800), 0x1.000040018p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004004000), 0x1.00004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004004001), 0x1.00004004001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004004004), 0x1.00004004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004004040), 0x1.0000400404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004004400), 0x1.000040044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004004800), 0x1.000040048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004020000), 0x1.0000402p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004020004), 0x1.00004020004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004020020), 0x1.0000402002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004020080), 0x1.0000402008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004020400), 0x1.000040204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004022000), 0x1.00004022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004024000), 0x1.00004024p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004028000), 0x1.00004028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004080000), 0x1.0000408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004080008), 0x1.00004080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004080020), 0x1.0000408002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004080040), 0x1.0000408004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004080400), 0x1.000040804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004080800), 0x1.000040808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004084000), 0x1.00004084p+44, 0x0p+0 },
+{ UINT64_C(0x00001000040c0000), 0x1.000040cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100004800000), 0x1.000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004800008), 0x1.00004800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004800040), 0x1.0000480004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004800100), 0x1.000048001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004800400), 0x1.000048004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004802000), 0x1.00004802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004808000), 0x1.00004808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004810000), 0x1.0000481p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004900000), 0x1.000049p+44, 0x0p+0 },
+{ UINT64_C(0x0000100004a00000), 0x1.00004ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000004), 0x1.00008000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000040), 0x1.0000800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000048), 0x1.00008000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000050), 0x1.0000800005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000080), 0x1.0000800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000081), 0x1.00008000081p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000088), 0x1.00008000088p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000800), 0x1.000080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000802), 0x1.00008000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000810), 0x1.0000800081p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000820), 0x1.0000800082p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000840), 0x1.0000800084p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008000a00), 0x1.00008000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100008004000), 0x1.00008004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008004004), 0x1.00008004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008004010), 0x1.0000800401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008004040), 0x1.0000800404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008004080), 0x1.0000800408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008004200), 0x1.000080042p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008005000), 0x1.00008005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008020000), 0x1.0000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008020001), 0x1.00008020001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008020008), 0x1.00008020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008020080), 0x1.0000802008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008020200), 0x1.000080202p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008021000), 0x1.00008021p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008022000), 0x1.00008022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008024000), 0x1.00008024p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008028000), 0x1.00008028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008080000), 0x1.0000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008080008), 0x1.00008080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008080040), 0x1.0000808004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008080100), 0x1.000080801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008080800), 0x1.000080808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008084000), 0x1.00008084p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008088000), 0x1.00008088p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008090000), 0x1.0000809p+44, 0x0p+0 },
+{ UINT64_C(0x00001000080c0000), 0x1.000080cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100008400000), 0x1.000084p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008400002), 0x1.00008400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008400008), 0x1.00008400008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008400010), 0x1.0000840001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008400100), 0x1.000084001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008400400), 0x1.000084004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008401000), 0x1.00008401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008404000), 0x1.00008404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100008440000), 0x1.0000844p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009000000), 0x1.00009p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009000002), 0x1.00009000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009000004), 0x1.00009000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009000020), 0x1.0000900002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009000200), 0x1.000090002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009000800), 0x1.000090008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009004000), 0x1.00009004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009040000), 0x1.0000904p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009100000), 0x1.000091p+44, 0x0p+0 },
+{ UINT64_C(0x0000100009200000), 0x1.000092p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000000), 0x1.0000cp+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000002), 0x1.0000c000002p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000020), 0x1.0000c00002p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000040), 0x1.0000c00004p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000080), 0x1.0000c00008p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000100), 0x1.0000c0001p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c000400), 0x1.0000c0004p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c002000), 0x1.0000c002p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c008000), 0x1.0000c008p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c080000), 0x1.0000c08p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c400000), 0x1.0000c4p+44, 0x0p+0 },
+{ UINT64_C(0x000010000c800000), 0x1.0000c8p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000002), 0x1.00020000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000020), 0x1.0002000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000024), 0x1.00020000024p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000040), 0x1.0002000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000048), 0x1.00020000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000050), 0x1.0002000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000100), 0x1.000200001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000104), 0x1.00020000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000140), 0x1.0002000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000800), 0x1.000200008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000808), 0x1.00020000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000840), 0x1.0002000084p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000900), 0x1.000200009p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000a00), 0x1.00020000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100020000c00), 0x1.00020000cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100020008000), 0x1.00020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020008002), 0x1.00020008002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020008010), 0x1.0002000801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020008040), 0x1.0002000804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020008080), 0x1.0002000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020008800), 0x1.000200088p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080000), 0x1.0002008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080001), 0x1.00020080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080008), 0x1.00020080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080010), 0x1.0002008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080020), 0x1.0002008002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080100), 0x1.000200801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020080200), 0x1.000200802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020082000), 0x1.00020082p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020090000), 0x1.0002009p+44, 0x0p+0 },
+{ UINT64_C(0x00001000200a0000), 0x1.000200ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800000), 0x1.000208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800001), 0x1.00020800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800008), 0x1.00020800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800020), 0x1.0002080002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800100), 0x1.000208001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800200), 0x1.000208002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020800400), 0x1.000208004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020804000), 0x1.00020804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020810000), 0x1.0002081p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020900000), 0x1.000209p+44, 0x0p+0 },
+{ UINT64_C(0x0000100020a00000), 0x1.00020ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000000), 0x1.00021p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000002), 0x1.00021000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000004), 0x1.00021000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000020), 0x1.0002100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000040), 0x1.0002100004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000080), 0x1.0002100008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021000800), 0x1.000210008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021002000), 0x1.00021002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021020000), 0x1.0002102p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021100000), 0x1.000211p+44, 0x0p+0 },
+{ UINT64_C(0x0000100021200000), 0x1.000212p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028000000), 0x1.00028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028000008), 0x1.00028000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028000020), 0x1.0002800002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028000040), 0x1.0002800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028000200), 0x1.000280002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028000400), 0x1.000280004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028001000), 0x1.00028001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028010000), 0x1.0002801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028020000), 0x1.0002802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028040000), 0x1.0002804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028100000), 0x1.000281p+44, 0x0p+0 },
+{ UINT64_C(0x0000100028400000), 0x1.000284p+44, 0x0p+0 },
+{ UINT64_C(0x0000100029000000), 0x1.00029p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000004), 0x1.00040000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000005), 0x1.00040000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000006), 0x1.00040000006p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000008), 0x1.00040000008p+44, 0x0p+0 },
+{ UINT64_C(0x000010004000000a), 0x1.0004000000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000020), 0x1.0004000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000021), 0x1.00040000021p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000030), 0x1.0004000003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000200), 0x1.000400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000208), 0x1.00040000208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000280), 0x1.0004000028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040000300), 0x1.000400003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040002000), 0x1.00040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040002008), 0x1.00040002008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040002020), 0x1.0004000202p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040002040), 0x1.0004000204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040002080), 0x1.0004000208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040002200), 0x1.000400022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040003000), 0x1.00040003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040020000), 0x1.0004002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040020001), 0x1.00040020001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040020008), 0x1.00040020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040020080), 0x1.0004002008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040020100), 0x1.000400201p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040021000), 0x1.00040021p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040028000), 0x1.00040028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200000), 0x1.000402p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200004), 0x1.00040200004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200008), 0x1.00040200008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200010), 0x1.0004020001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200080), 0x1.0004020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200100), 0x1.000402001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040200800), 0x1.000402008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040201000), 0x1.00040201p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040202000), 0x1.00040202p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040220000), 0x1.0004022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100040300000), 0x1.000403p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041000000), 0x1.00041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041000004), 0x1.00041000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041000020), 0x1.0004100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041000100), 0x1.000410001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041000800), 0x1.000410008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041001000), 0x1.00041001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041002000), 0x1.00041002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041020000), 0x1.0004102p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041200000), 0x1.000412p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041400000), 0x1.000414p+44, 0x0p+0 },
+{ UINT64_C(0x0000100041800000), 0x1.000418p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044000000), 0x1.00044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044000008), 0x1.00044000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044000010), 0x1.0004400001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044000040), 0x1.0004400004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044000400), 0x1.000440004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044001000), 0x1.00044001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044010000), 0x1.0004401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100044100000), 0x1.000441p+44, 0x0p+0 },
+{ UINT64_C(0x0000100045000000), 0x1.00045p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000004), 0x1.00200000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000010), 0x1.0020000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000012), 0x1.00200000012p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000018), 0x1.00200000018p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000080), 0x1.0020000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000088), 0x1.00200000088p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000200), 0x1.002000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000208), 0x1.00200000208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000240), 0x1.0020000024p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200000280), 0x1.0020000028p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200002000), 0x1.00200002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200002002), 0x1.00200002002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200002020), 0x1.0020000202p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200002200), 0x1.002000022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200004000), 0x1.00200004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200004002), 0x1.00200004002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200004004), 0x1.00200004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200004008), 0x1.00200004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200004080), 0x1.0020000408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200004400), 0x1.002000044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200006000), 0x1.00200006p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200008000), 0x1.00200008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200008001), 0x1.00200008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200008008), 0x1.00200008008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200008080), 0x1.0020000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200008200), 0x1.002000082p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200008800), 0x1.002000088p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200009000), 0x1.00200009p+44, 0x0p+0 },
+{ UINT64_C(0x000010020000c000), 0x1.0020000cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020000), 0x1.0020002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020001), 0x1.00200020001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020002), 0x1.00200020002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020008), 0x1.00200020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020010), 0x1.0020002001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020040), 0x1.0020002004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200020400), 0x1.002000204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200022000), 0x1.00200022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200030000), 0x1.0020003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200100000), 0x1.002001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200100001), 0x1.00200100001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200100004), 0x1.00200100004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200100008), 0x1.00200100008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200100080), 0x1.0020010008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200100800), 0x1.002001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200108000), 0x1.00200108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200120000), 0x1.0020012p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200400000), 0x1.002004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200400004), 0x1.00200400004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200400020), 0x1.0020040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200400100), 0x1.002004001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200400400), 0x1.002004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200401000), 0x1.00200401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200410000), 0x1.0020041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200480000), 0x1.0020048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100200500000), 0x1.002005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000000), 0x1.00204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000002), 0x1.00204000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000020), 0x1.0020400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000080), 0x1.0020400008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000100), 0x1.002040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000200), 0x1.002040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204000400), 0x1.002040004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204004000), 0x1.00204004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204010000), 0x1.0020401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204100000), 0x1.002041p+44, 0x0p+0 },
+{ UINT64_C(0x0000100204400000), 0x1.002044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100205000000), 0x1.00205p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208000000), 0x1.00208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208000008), 0x1.00208000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208000080), 0x1.0020800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208000100), 0x1.002080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208000800), 0x1.002080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208004000), 0x1.00208004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208040000), 0x1.0020804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208200000), 0x1.002082p+44, 0x0p+0 },
+{ UINT64_C(0x0000100208800000), 0x1.002088p+44, 0x0p+0 },
+{ UINT64_C(0x000010020c000000), 0x1.0020cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100220000000), 0x1.0022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220000004), 0x1.00220000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220000008), 0x1.00220000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220000010), 0x1.0022000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220000080), 0x1.0022000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220000100), 0x1.002200001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220001000), 0x1.00220001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220008000), 0x1.00220008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220010000), 0x1.0022001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220100000), 0x1.002201p+44, 0x0p+0 },
+{ UINT64_C(0x0000100220400000), 0x1.002204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100224000000), 0x1.00224p+44, 0x0p+0 },
+{ UINT64_C(0x0000100228000000), 0x1.00228p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000004), 0x1.00400000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000040), 0x1.0040000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000048), 0x1.00400000048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000050), 0x1.0040000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000200), 0x1.004000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000204), 0x1.00400000204p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000220), 0x1.0040000022p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000300), 0x1.004000003p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000800), 0x1.004000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000801), 0x1.00400000801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000808), 0x1.00400000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000840), 0x1.0040000084p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400000c00), 0x1.00400000cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001000), 0x1.00400001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001004), 0x1.00400001004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001010), 0x1.0040000101p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001040), 0x1.0040000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001080), 0x1.0040000108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001200), 0x1.004000012p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400001400), 0x1.004000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400004000), 0x1.00400004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400004008), 0x1.00400004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400004080), 0x1.0040000408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400004400), 0x1.004000044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400005000), 0x1.00400005p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400010000), 0x1.0040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400010002), 0x1.00400010002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400010004), 0x1.00400010004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400010010), 0x1.0040001001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400010100), 0x1.004000101p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400011000), 0x1.00400011p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400080000), 0x1.0040008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400080008), 0x1.00400080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400080040), 0x1.0040008004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400080080), 0x1.0040008008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400080400), 0x1.004000804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400080800), 0x1.004000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400081000), 0x1.00400081p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400088000), 0x1.00400088p+44, 0x0p+0 },
+{ UINT64_C(0x00001004000c0000), 0x1.004000cp+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400000), 0x1.004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400002), 0x1.00400400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400008), 0x1.00400400008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400010), 0x1.0040040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400040), 0x1.0040040004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400080), 0x1.0040040008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400400800), 0x1.004004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400401000), 0x1.00400401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400408000), 0x1.00400408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400420000), 0x1.0040042p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400600000), 0x1.004006p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400800000), 0x1.004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400800008), 0x1.00400800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400800080), 0x1.0040080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400800400), 0x1.004008004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400800800), 0x1.004008008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400802000), 0x1.00400802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400804000), 0x1.00400804p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400808000), 0x1.00400808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400810000), 0x1.0040081p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400820000), 0x1.0040082p+44, 0x0p+0 },
+{ UINT64_C(0x0000100400a00000), 0x1.00400ap+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000000), 0x1.00401p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000001), 0x1.00401000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000004), 0x1.00401000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000008), 0x1.00401000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000020), 0x1.0040100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000080), 0x1.0040100008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000200), 0x1.004010002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401000800), 0x1.004010008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401001000), 0x1.00401001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401008000), 0x1.00401008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401020000), 0x1.0040102p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401080000), 0x1.0040108p+44, 0x0p+0 },
+{ UINT64_C(0x0000100401400000), 0x1.004014p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404000000), 0x1.00404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404000001), 0x1.00404000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404000008), 0x1.00404000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404000010), 0x1.0040400001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404000080), 0x1.0040400008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404000200), 0x1.004040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404001000), 0x1.00404001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404004000), 0x1.00404004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404040000), 0x1.0040404p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404080000), 0x1.0040408p+44, 0x0p+0 },
+{ UINT64_C(0x0000100404400000), 0x1.004044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420000000), 0x1.0042p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420000004), 0x1.00420000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420000008), 0x1.00420000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420000010), 0x1.0042000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420000040), 0x1.0042000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420000400), 0x1.004200004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420004000), 0x1.00420004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420008000), 0x1.00420008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420080000), 0x1.0042008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100420800000), 0x1.004208p+44, 0x0p+0 },
+{ UINT64_C(0x0000100424000000), 0x1.00424p+44, 0x0p+0 },
+{ UINT64_C(0x0000100428000000), 0x1.00428p+44, 0x0p+0 },
+{ UINT64_C(0x0000100430000000), 0x1.0043p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440000000), 0x1.0044p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440000002), 0x1.00440000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440000004), 0x1.00440000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440000040), 0x1.0044000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440000400), 0x1.004400004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440001000), 0x1.00440001p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440008000), 0x1.00440008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440080000), 0x1.0044008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100440200000), 0x1.004402p+44, 0x0p+0 },
+{ UINT64_C(0x0000100441000000), 0x1.00441p+44, 0x0p+0 },
+{ UINT64_C(0x0000100450000000), 0x1.0045p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000000), 0x1.0048p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000004), 0x1.00480000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000008), 0x1.00480000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000020), 0x1.0048000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000200), 0x1.004800002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000400), 0x1.004800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480000800), 0x1.004800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480004000), 0x1.00480004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480008000), 0x1.00480008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480020000), 0x1.0048002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480080000), 0x1.0048008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480100000), 0x1.004801p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480200000), 0x1.004802p+44, 0x0p+0 },
+{ UINT64_C(0x0000100480800000), 0x1.004808p+44, 0x0p+0 },
+{ UINT64_C(0x0000100488000000), 0x1.00488p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600000000), 0x1.006p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600000008), 0x1.00600000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600000040), 0x1.0060000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600000200), 0x1.006000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600002000), 0x1.00600002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600004000), 0x1.00600004p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600020000), 0x1.0060002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100600200000), 0x1.006002p+44, 0x0p+0 },
+{ UINT64_C(0x0000100601000000), 0x1.00601p+44, 0x0p+0 },
+{ UINT64_C(0x0000100610000000), 0x1.0061p+44, 0x0p+0 },
+{ UINT64_C(0x0000100640000000), 0x1.0064p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000004), 0x1.02000000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000006), 0x1.02000000006p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000040), 0x1.0200000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000044), 0x1.02000000044p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000100), 0x1.020000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000104), 0x1.02000000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000000140), 0x1.0200000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000001000), 0x1.02000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000001004), 0x1.02000001004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000001008), 0x1.02000001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000001080), 0x1.0200000108p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000001800), 0x1.020000018p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000010000), 0x1.0200001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000010001), 0x1.02000010001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000010008), 0x1.02000010008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000010020), 0x1.0200001002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000010200), 0x1.020000102p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000010800), 0x1.020000108p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000018000), 0x1.02000018p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000100000), 0x1.020001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000100004), 0x1.02000100004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000100020), 0x1.0200010002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000100080), 0x1.0200010008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000100800), 0x1.020001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000104000), 0x1.02000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000120000), 0x1.0200012p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000140000), 0x1.0200014p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000800000), 0x1.020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000800001), 0x1.02000800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000800010), 0x1.0200080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000800100), 0x1.020008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000800800), 0x1.020008008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000802000), 0x1.02000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000804000), 0x1.02000804p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000810000), 0x1.0200081p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000880000), 0x1.0200088p+44, 0x0p+0 },
+{ UINT64_C(0x0000102000a00000), 0x1.02000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000102004000000), 0x1.02004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004000008), 0x1.02004000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004000020), 0x1.0200400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004000080), 0x1.0200400008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004000200), 0x1.020040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004000800), 0x1.020040008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004008000), 0x1.02004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004040000), 0x1.0200404p+44, 0x0p+0 },
+{ UINT64_C(0x0000102004200000), 0x1.020042p+44, 0x0p+0 },
+{ UINT64_C(0x0000102006000000), 0x1.02006p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000000), 0x1.0201p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000004), 0x1.02010000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000008), 0x1.02010000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000040), 0x1.0201000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000100), 0x1.020100001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000200), 0x1.020100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010000800), 0x1.020100008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010004000), 0x1.02010004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010040000), 0x1.0201004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102010400000), 0x1.020104p+44, 0x0p+0 },
+{ UINT64_C(0x0000102011000000), 0x1.02011p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020000000), 0x1.0202p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020000008), 0x1.02020000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020000010), 0x1.0202000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020000040), 0x1.0202000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020000080), 0x1.0202000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020000800), 0x1.020200008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020008000), 0x1.02020008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020020000), 0x1.0202002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102020200000), 0x1.020202p+44, 0x0p+0 },
+{ UINT64_C(0x0000102021000000), 0x1.02021p+44, 0x0p+0 },
+{ UINT64_C(0x0000102028000000), 0x1.02028p+44, 0x0p+0 },
+{ UINT64_C(0x0000102030000000), 0x1.0203p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000000), 0x1.0204p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000001), 0x1.02040000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000010), 0x1.0204000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000020), 0x1.0204000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000040), 0x1.0204000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000080), 0x1.0204000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040000800), 0x1.020400008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040001000), 0x1.02040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040002000), 0x1.02040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040020000), 0x1.0204002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102040100000), 0x1.020401p+44, 0x0p+0 },
+{ UINT64_C(0x0000102041000000), 0x1.02041p+44, 0x0p+0 },
+{ UINT64_C(0x0000102042000000), 0x1.02042p+44, 0x0p+0 },
+{ UINT64_C(0x0000102060000000), 0x1.0206p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080000000), 0x1.0208p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080000004), 0x1.02080000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080000010), 0x1.0208000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080000020), 0x1.0208000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080000100), 0x1.020800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080000800), 0x1.020800008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080008000), 0x1.02080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080020000), 0x1.0208002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080200000), 0x1.020802p+44, 0x0p+0 },
+{ UINT64_C(0x0000102080800000), 0x1.020808p+44, 0x0p+0 },
+{ UINT64_C(0x0000102081000000), 0x1.02081p+44, 0x0p+0 },
+{ UINT64_C(0x0000102090000000), 0x1.0209p+44, 0x0p+0 },
+{ UINT64_C(0x00001020a0000000), 0x1.020ap+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000000), 0x1.021p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000002), 0x1.02100000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000008), 0x1.02100000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000020), 0x1.0210000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000100), 0x1.021000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000400), 0x1.021000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100000800), 0x1.021000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100004000), 0x1.02100004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100010000), 0x1.0210001p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100080000), 0x1.0210008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100200000), 0x1.021002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102100400000), 0x1.021004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102102000000), 0x1.02102p+44, 0x0p+0 },
+{ UINT64_C(0x0000102104000000), 0x1.02104p+44, 0x0p+0 },
+{ UINT64_C(0x0000102140000000), 0x1.0214p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800000000), 0x1.028p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800000002), 0x1.02800000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800000004), 0x1.02800000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800000040), 0x1.0280000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800000200), 0x1.028000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800000400), 0x1.028000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800004000), 0x1.02800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800040000), 0x1.0280004p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800080000), 0x1.0280008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102800800000), 0x1.028008p+44, 0x0p+0 },
+{ UINT64_C(0x0000102804000000), 0x1.02804p+44, 0x0p+0 },
+{ UINT64_C(0x0000102810000000), 0x1.0281p+44, 0x0p+0 },
+{ UINT64_C(0x0000102840000000), 0x1.0284p+44, 0x0p+0 },
+{ UINT64_C(0x0000102900000000), 0x1.029p+44, 0x0p+0 },
+{ UINT64_C(0x0000102c00000000), 0x1.02cp+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000004), 0x1.10000000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000005), 0x1.10000000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000006), 0x1.10000000006p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000010), 0x1.1000000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000014), 0x1.10000000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000018), 0x1.10000000018p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000100), 0x1.100000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000104), 0x1.10000000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000110), 0x1.1000000011p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000140), 0x1.1000000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000000180), 0x1.1000000018p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000001000), 0x1.10000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000001001), 0x1.10000001001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000001008), 0x1.10000001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000001040), 0x1.1000000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000001400), 0x1.100000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008000), 0x1.10000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008002), 0x1.10000008002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008020), 0x1.1000000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008040), 0x1.1000000804p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008080), 0x1.1000000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008100), 0x1.100000081p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000008400), 0x1.100000084p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000009000), 0x1.10000009p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000080000), 0x1.1000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000080001), 0x1.10000080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000080010), 0x1.1000008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000080100), 0x1.100000801p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000080800), 0x1.100000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000082000), 0x1.10000082p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000090000), 0x1.1000009p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000100000), 0x1.100001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000100002), 0x1.10000100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000100020), 0x1.1000010002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000100200), 0x1.100001002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000101000), 0x1.10000101p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000108000), 0x1.10000108p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000140000), 0x1.1000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000800000), 0x1.100008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000800001), 0x1.10000800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000800010), 0x1.1000080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000800100), 0x1.100008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000801000), 0x1.10000801p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000802000), 0x1.10000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000820000), 0x1.1000082p+44, 0x0p+0 },
+{ UINT64_C(0x0000110000a00000), 0x1.10000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000000), 0x1.10008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000001), 0x1.10008000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000002), 0x1.10008000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000008), 0x1.10008000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000040), 0x1.1000800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000200), 0x1.100080002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008000800), 0x1.100080008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008002000), 0x1.10008002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008004000), 0x1.10008004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008010000), 0x1.1000801p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008080000), 0x1.1000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000110008800000), 0x1.100088p+44, 0x0p+0 },
+{ UINT64_C(0x000011000c000000), 0x1.1000cp+44, 0x0p+0 },
+{ UINT64_C(0x0000110010000000), 0x1.1001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010000008), 0x1.10010000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010000010), 0x1.1001000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010000080), 0x1.1001000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010000200), 0x1.100100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010002000), 0x1.10010002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010020000), 0x1.1001002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010100000), 0x1.100101p+44, 0x0p+0 },
+{ UINT64_C(0x0000110010400000), 0x1.100104p+44, 0x0p+0 },
+{ UINT64_C(0x0000110012000000), 0x1.10012p+44, 0x0p+0 },
+{ UINT64_C(0x0000110018000000), 0x1.10018p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040000000), 0x1.1004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040000008), 0x1.10040000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040000020), 0x1.1004000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040000040), 0x1.1004000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040000200), 0x1.100400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040002000), 0x1.10040002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040008000), 0x1.10040008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040040000), 0x1.1004004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040080000), 0x1.1004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110040800000), 0x1.100408p+44, 0x0p+0 },
+{ UINT64_C(0x0000110044000000), 0x1.10044p+44, 0x0p+0 },
+{ UINT64_C(0x0000110048000000), 0x1.10048p+44, 0x0p+0 },
+{ UINT64_C(0x0000110060000000), 0x1.1006p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080000000), 0x1.1008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080000001), 0x1.10080000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080000008), 0x1.10080000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080000040), 0x1.1008000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080000080), 0x1.1008000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080000200), 0x1.100800002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080002000), 0x1.10080002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080010000), 0x1.1008001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080100000), 0x1.100801p+44, 0x0p+0 },
+{ UINT64_C(0x0000110080400000), 0x1.100804p+44, 0x0p+0 },
+{ UINT64_C(0x0000110081000000), 0x1.10081p+44, 0x0p+0 },
+{ UINT64_C(0x0000110088000000), 0x1.10088p+44, 0x0p+0 },
+{ UINT64_C(0x00001100c0000000), 0x1.100cp+44, 0x0p+0 },
+{ UINT64_C(0x0000110400000000), 0x1.104p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400000004), 0x1.10400000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400000040), 0x1.1040000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400000080), 0x1.1040000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400000200), 0x1.104000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400002000), 0x1.10400002p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400010000), 0x1.1040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400100000), 0x1.104001p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400400000), 0x1.104004p+44, 0x0p+0 },
+{ UINT64_C(0x0000110400800000), 0x1.104008p+44, 0x0p+0 },
+{ UINT64_C(0x0000110404000000), 0x1.10404p+44, 0x0p+0 },
+{ UINT64_C(0x0000110420000000), 0x1.1042p+44, 0x0p+0 },
+{ UINT64_C(0x0000110480000000), 0x1.1048p+44, 0x0p+0 },
+{ UINT64_C(0x0000110600000000), 0x1.106p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000000), 0x1.12p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000001), 0x1.12000000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000004), 0x1.12000000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000010), 0x1.1200000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000080), 0x1.1200000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000100), 0x1.120000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000400), 0x1.120000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000000800), 0x1.120000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000001000), 0x1.12000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000004000), 0x1.12000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000008000), 0x1.12000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000020000), 0x1.1200002p+44, 0x0p+0 },
+{ UINT64_C(0x0000112000100000), 0x1.120001p+44, 0x0p+0 },
+{ UINT64_C(0x0000112001000000), 0x1.12001p+44, 0x0p+0 },
+{ UINT64_C(0x0000112008000000), 0x1.12008p+44, 0x0p+0 },
+{ UINT64_C(0x0000112010000000), 0x1.1201p+44, 0x0p+0 },
+{ UINT64_C(0x0000112100000000), 0x1.121p+44, 0x0p+0 },
+{ UINT64_C(0x0000112400000000), 0x1.124p+44, 0x0p+0 },
+{ UINT64_C(0x0000112800000000), 0x1.128p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000000), 0x1.18p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000001), 0x1.18000000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000002), 0x1.18000000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000004), 0x1.18000000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000008), 0x1.18000000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000010), 0x1.1800000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000020), 0x1.1800000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000100), 0x1.180000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000000400), 0x1.180000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000001000), 0x1.18000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000010000), 0x1.1800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000040000), 0x1.1800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000100000), 0x1.180001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118000200000), 0x1.180002p+44, 0x0p+0 },
+{ UINT64_C(0x0000118001000000), 0x1.18001p+44, 0x0p+0 },
+{ UINT64_C(0x0000118008000000), 0x1.18008p+44, 0x0p+0 },
+{ UINT64_C(0x0000118080000000), 0x1.1808p+44, 0x0p+0 },
+{ UINT64_C(0x0000118800000000), 0x1.188p+44, 0x0p+0 },
+{ UINT64_C(0x000011a000000000), 0x1.1ap+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000008), 0x1.80000000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000010), 0x1.8000000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000018), 0x1.80000000018p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000020), 0x1.8000000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000028), 0x1.80000000028p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000200), 0x1.800000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000208), 0x1.80000000208p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000280), 0x1.8000000028p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000400), 0x1.800000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000401), 0x1.80000000401p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000408), 0x1.80000000408p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000410), 0x1.8000000041p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000500), 0x1.800000005p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000600), 0x1.800000006p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000800), 0x1.800000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000808), 0x1.80000000808p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000880), 0x1.8000000088p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000000a00), 0x1.80000000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000180000002000), 0x1.80000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000002004), 0x1.80000002004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000002008), 0x1.80000002008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000002080), 0x1.8000000208p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000002400), 0x1.800000024p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000002800), 0x1.800000028p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000010000), 0x1.8000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000010004), 0x1.80000010004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000010010), 0x1.8000001001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000010040), 0x1.8000001004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000010400), 0x1.800000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000011000), 0x1.80000011p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000014000), 0x1.80000014p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100000), 0x1.800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100004), 0x1.80000100004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100008), 0x1.80000100008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100010), 0x1.8000010001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100020), 0x1.8000010002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100040), 0x1.8000010004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100200), 0x1.800001002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000100800), 0x1.800001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000101000), 0x1.80000101p+44, 0x0p+0 },
+{ UINT64_C(0x0000180000110000), 0x1.8000011p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001000000), 0x1.80001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001000008), 0x1.80001000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001000040), 0x1.8000100004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001000400), 0x1.800010004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001000800), 0x1.800010008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001004000), 0x1.80001004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001008000), 0x1.80001008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001040000), 0x1.8000104p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001080000), 0x1.8000108p+44, 0x0p+0 },
+{ UINT64_C(0x0000180001800000), 0x1.800018p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004000000), 0x1.80004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004000008), 0x1.80004000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004000010), 0x1.8000400001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004000040), 0x1.8000400004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004000400), 0x1.800040004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004000800), 0x1.800040008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004001000), 0x1.80004001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004008000), 0x1.80004008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004020000), 0x1.8000402p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004040000), 0x1.8000404p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004100000), 0x1.800041p+44, 0x0p+0 },
+{ UINT64_C(0x0000180004200000), 0x1.800042p+44, 0x0p+0 },
+{ UINT64_C(0x0000180006000000), 0x1.80006p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008000000), 0x1.80008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008000008), 0x1.80008000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008000020), 0x1.8000800002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008000100), 0x1.800080001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008000400), 0x1.800080004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008004000), 0x1.80008004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008008000), 0x1.80008008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008020000), 0x1.8000802p+44, 0x0p+0 },
+{ UINT64_C(0x0000180008200000), 0x1.800082p+44, 0x0p+0 },
+{ UINT64_C(0x000018000a000000), 0x1.8000ap+44, 0x0p+0 },
+{ UINT64_C(0x0000180040000000), 0x1.8004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040000001), 0x1.80040000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040000008), 0x1.80040000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040000010), 0x1.8004000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040000040), 0x1.8004000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040000100), 0x1.800400001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040001000), 0x1.80040001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040010000), 0x1.8004001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180040100000), 0x1.800401p+44, 0x0p+0 },
+{ UINT64_C(0x0000180041000000), 0x1.80041p+44, 0x0p+0 },
+{ UINT64_C(0x0000180050000000), 0x1.8005p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100000000), 0x1.801p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100000008), 0x1.80100000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100000040), 0x1.8010000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100000400), 0x1.801000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100000800), 0x1.801000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100001000), 0x1.80100001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100002000), 0x1.80100002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100010000), 0x1.8010001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100040000), 0x1.8010004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180100200000), 0x1.801002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180101000000), 0x1.80101p+44, 0x0p+0 },
+{ UINT64_C(0x0000180104000000), 0x1.80104p+44, 0x0p+0 },
+{ UINT64_C(0x0000180140000000), 0x1.8014p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800000000), 0x1.808p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800000001), 0x1.80800000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800000004), 0x1.80800000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800000008), 0x1.80800000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800000080), 0x1.8080000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800000200), 0x1.808000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800001000), 0x1.80800001p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800004000), 0x1.80800004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800040000), 0x1.8080004p+44, 0x0p+0 },
+{ UINT64_C(0x0000180800200000), 0x1.808002p+44, 0x0p+0 },
+{ UINT64_C(0x0000180802000000), 0x1.80802p+44, 0x0p+0 },
+{ UINT64_C(0x0000180808000000), 0x1.80808p+44, 0x0p+0 },
+{ UINT64_C(0x0000180810000000), 0x1.8081p+44, 0x0p+0 },
+{ UINT64_C(0x0000180880000000), 0x1.8088p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000000000), 0x1.84p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000000002), 0x1.84000000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000000004), 0x1.84000000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000000020), 0x1.8400000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000000100), 0x1.840000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000001000), 0x1.84000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000004000), 0x1.84000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000008000), 0x1.84000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000010000), 0x1.8400001p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000100000), 0x1.840001p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000200000), 0x1.840002p+44, 0x0p+0 },
+{ UINT64_C(0x0000184000800000), 0x1.840008p+44, 0x0p+0 },
+{ UINT64_C(0x0000184001000000), 0x1.84001p+44, 0x0p+0 },
+{ UINT64_C(0x0000184010000000), 0x1.8401p+44, 0x0p+0 },
+{ UINT64_C(0x0000184040000000), 0x1.8404p+44, 0x0p+0 },
+{ UINT64_C(0x0000184200000000), 0x1.842p+44, 0x0p+0 },
+{ UINT64_C(0x0000184400000000), 0x1.844p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000000000), 0x1.9p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000000004), 0x1.90000000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000000020), 0x1.9000000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000000080), 0x1.9000000008p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000000200), 0x1.900000002p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000001000), 0x1.90000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000010000), 0x1.9000001p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000040000), 0x1.9000004p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000100000), 0x1.900001p+44, 0x0p+0 },
+{ UINT64_C(0x0000190000800000), 0x1.900008p+44, 0x0p+0 },
+{ UINT64_C(0x0000190008000000), 0x1.90008p+44, 0x0p+0 },
+{ UINT64_C(0x0000190080000000), 0x1.9008p+44, 0x0p+0 },
+{ UINT64_C(0x0000190200000000), 0x1.902p+44, 0x0p+0 },
+{ UINT64_C(0x0000191000000000), 0x1.91p+44, 0x0p+0 },
+{ UINT64_C(0x0000192000000000), 0x1.92p+44, 0x0p+0 },
+{ UINT64_C(0x0000800000000011), 0x1.000000000022p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000012), 0x1.000000000024p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000018), 0x1.00000000003p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000001a), 0x1.000000000034p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000104), 0x1.000000000208p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000105), 0x1.00000000020ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000140), 0x1.00000000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000144), 0x1.000000000288p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000160), 0x1.0000000002cp+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000802), 0x1.000000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000804), 0x1.000000001008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000820), 0x1.00000000104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000821), 0x1.000000001042p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000824), 0x1.000000001048p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000830), 0x1.00000000106p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000880), 0x1.0000000011p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000882), 0x1.000000001104p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000008a0), 0x1.00000000114p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000008c0), 0x1.00000000118p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000a00), 0x1.0000000014p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000a04), 0x1.000000001408p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000a10), 0x1.00000000142p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000000a40), 0x1.00000000148p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008008), 0x1.00000001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008020), 0x1.00000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008024), 0x1.000000010048p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008030), 0x1.00000001006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008100), 0x1.0000000102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008102), 0x1.000000010204p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008110), 0x1.00000001022p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008180), 0x1.0000000103p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008200), 0x1.0000000104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008202), 0x1.000000010404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008208), 0x1.00000001041p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000008280), 0x1.0000000105p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000a000), 0x1.000000014p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000a008), 0x1.00000001401p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000a020), 0x1.00000001404p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000a040), 0x1.00000001408p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000a080), 0x1.0000000141p+47, 0x0p+0 },
+{ UINT64_C(0x000080000000a400), 0x1.0000000148p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040002), 0x1.000000080004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040008), 0x1.00000008001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040080), 0x1.0000000801p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040082), 0x1.000000080104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040084), 0x1.000000080108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040088), 0x1.00000008011p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000400a0), 0x1.00000008014p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000400c0), 0x1.00000008018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040100), 0x1.0000000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040101), 0x1.000000080202p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040104), 0x1.000000080208p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040120), 0x1.00000008024p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000040180), 0x1.0000000803p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000041000), 0x1.000000082p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000041004), 0x1.000000082008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000041008), 0x1.00000008201p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000041080), 0x1.0000000821p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000041400), 0x1.0000000828p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044000), 0x1.000000088p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044004), 0x1.000000088008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044008), 0x1.00000008801p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044010), 0x1.00000008802p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044100), 0x1.0000000882p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044200), 0x1.0000000884p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000044800), 0x1.000000089p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000046000), 0x1.00000008cp+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080001), 0x1.000000100002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080010), 0x1.00000010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080018), 0x1.00000010003p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080020), 0x1.00000010004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080028), 0x1.00000010005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080030), 0x1.00000010006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080200), 0x1.0000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080201), 0x1.000000100402p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080202), 0x1.000000100404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080204), 0x1.000000100408p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080220), 0x1.00000010044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080300), 0x1.0000001006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080800), 0x1.000000101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080808), 0x1.00000010101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080810), 0x1.00000010102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080900), 0x1.0000001012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000080c00), 0x1.0000001018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000084000), 0x1.000000108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000084004), 0x1.000000108008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000084020), 0x1.00000010804p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000084100), 0x1.0000001082p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000084800), 0x1.000000109p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000085000), 0x1.00000010ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800000088000), 0x1.00000011p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000088001), 0x1.000000110002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000088008), 0x1.00000011001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000088010), 0x1.00000011002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000088020), 0x1.00000011004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000088200), 0x1.0000001104p+47, 0x0p+0 },
+{ UINT64_C(0x000080000008a000), 0x1.000000114p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000c0000), 0x1.00000018p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000c0004), 0x1.000000180008p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000c0020), 0x1.00000018004p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000c0080), 0x1.0000001801p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000c0200), 0x1.0000001804p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000c1000), 0x1.000000182p+47, 0x0p+0 },
+{ UINT64_C(0x00008000000d0000), 0x1.0000001ap+47, 0x0p+0 },
+{ UINT64_C(0x00008000000e0000), 0x1.0000001cp+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800002), 0x1.000001000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800003), 0x1.000001000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800020), 0x1.00000100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800022), 0x1.000001000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800030), 0x1.00000100006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800080), 0x1.0000010001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800084), 0x1.000001000108p+47, 0x0p+0 },
+{ UINT64_C(0x00008000008000c0), 0x1.00000100018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800400), 0x1.0000010008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800401), 0x1.000001000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800404), 0x1.000001000808p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800420), 0x1.00000100084p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000800480), 0x1.0000010009p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000802000), 0x1.000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000802004), 0x1.000001004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000802010), 0x1.00000100402p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000802040), 0x1.00000100408p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000802200), 0x1.0000010044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000802800), 0x1.000001005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000820000), 0x1.00000104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000820004), 0x1.000001040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000820008), 0x1.00000104001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000820040), 0x1.00000104008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000820100), 0x1.0000010402p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000820800), 0x1.000001041p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000824000), 0x1.000001048p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000900000), 0x1.0000012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000900004), 0x1.000001200008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000900008), 0x1.00000120001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000900080), 0x1.0000012001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000900200), 0x1.0000012004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000900400), 0x1.0000012008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000904000), 0x1.000001208p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000908000), 0x1.00000121p+47, 0x0p+0 },
+{ UINT64_C(0x0000800000940000), 0x1.00000128p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000008), 0x1.00001000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000010), 0x1.00001000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000011), 0x1.000010000022p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000014), 0x1.000010000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000080), 0x1.0000100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000082), 0x1.000010000104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000088), 0x1.00001000011p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000200), 0x1.0000100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000204), 0x1.000010000408p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000240), 0x1.00001000048p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008000280), 0x1.0000100005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008001000), 0x1.000010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008001004), 0x1.000010002008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008001040), 0x1.00001000208p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008001100), 0x1.0000100022p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008008000), 0x1.00001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008008001), 0x1.000010010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008008004), 0x1.000010010008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008008008), 0x1.00001001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008008080), 0x1.0000100101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008008100), 0x1.0000100102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008009000), 0x1.000010012p+47, 0x0p+0 },
+{ UINT64_C(0x000080000800c000), 0x1.000010018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008080000), 0x1.0000101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008080008), 0x1.00001010001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008080010), 0x1.00001010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008080100), 0x1.0000101002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008080400), 0x1.0000101008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008080800), 0x1.000010101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008082000), 0x1.000010104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008088000), 0x1.00001011p+47, 0x0p+0 },
+{ UINT64_C(0x00008000080a0000), 0x1.00001014p+47, 0x0p+0 },
+{ UINT64_C(0x00008000080c0000), 0x1.00001018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008800000), 0x1.000011p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008800008), 0x1.00001100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008800040), 0x1.00001100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008800200), 0x1.0000110004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008800800), 0x1.000011001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008808000), 0x1.00001101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008810000), 0x1.00001102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800008880000), 0x1.0000111p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009000000), 0x1.000012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009000001), 0x1.000012000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009000010), 0x1.00001200002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009000080), 0x1.0000120001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009000800), 0x1.000012001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009001000), 0x1.000012002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009008000), 0x1.00001201p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009020000), 0x1.00001204p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009200000), 0x1.0000124p+47, 0x0p+0 },
+{ UINT64_C(0x0000800009800000), 0x1.000013p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a000000), 0x1.000014p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a000001), 0x1.000014000002p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a000004), 0x1.000014000008p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a000040), 0x1.00001400008p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a000400), 0x1.0000140008p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a000800), 0x1.000014001p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a001000), 0x1.000014002p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a010000), 0x1.00001402p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a100000), 0x1.0000142p+47, 0x0p+0 },
+{ UINT64_C(0x000080000a400000), 0x1.0000148p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c000000), 0x1.000018p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c000008), 0x1.00001800001p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c000080), 0x1.0000180001p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c000200), 0x1.0000180004p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c000400), 0x1.0000180008p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c004000), 0x1.000018008p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c020000), 0x1.00001804p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c100000), 0x1.0000182p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c200000), 0x1.0000184p+47, 0x0p+0 },
+{ UINT64_C(0x000080000c400000), 0x1.0000188p+47, 0x0p+0 },
+{ UINT64_C(0x000080000e000000), 0x1.00001cp+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000001), 0x1.000040000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000002), 0x1.000040000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000003), 0x1.000040000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000004), 0x1.000040000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000010), 0x1.00004000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000018), 0x1.00004000003p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000100), 0x1.0000400002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000108), 0x1.00004000021p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000110), 0x1.00004000022p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000140), 0x1.00004000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000180), 0x1.0000400003p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000200), 0x1.0000400004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000202), 0x1.000040000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000208), 0x1.00004000041p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020000280), 0x1.0000400005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020002000), 0x1.000040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020002004), 0x1.000040004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020002020), 0x1.00004000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020002100), 0x1.0000400042p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020002200), 0x1.0000400044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020000), 0x1.00004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020001), 0x1.000040040002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020004), 0x1.000040040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020040), 0x1.00004004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020100), 0x1.0000400402p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020200), 0x1.0000400404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020020400), 0x1.0000400408p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020024000), 0x1.000040048p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020028000), 0x1.00004005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080000), 0x1.0000401p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080002), 0x1.000040100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080008), 0x1.00004010001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080010), 0x1.00004010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080080), 0x1.0000401001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080100), 0x1.0000401002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080200), 0x1.0000401004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020080800), 0x1.000040101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020081000), 0x1.000040102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020088000), 0x1.00004011p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020800000), 0x1.000041p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020800008), 0x1.00004100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020800080), 0x1.0000410001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020800100), 0x1.0000410002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020800800), 0x1.000041001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020802000), 0x1.000041004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020808000), 0x1.00004101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020840000), 0x1.00004108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800020a00000), 0x1.0000414p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024000000), 0x1.000048p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024000004), 0x1.000048000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024000010), 0x1.00004800002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024000040), 0x1.00004800008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024000400), 0x1.0000480008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024000800), 0x1.000048001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024004000), 0x1.000048008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024010000), 0x1.00004802p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024100000), 0x1.0000482p+47, 0x0p+0 },
+{ UINT64_C(0x0000800024400000), 0x1.0000488p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000001), 0x1.000100000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000008), 0x1.00010000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000009), 0x1.000100000012p+47, 0x0p+0 },
+{ UINT64_C(0x000080008000000c), 0x1.000100000018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000080), 0x1.0001000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000084), 0x1.000100000108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000090), 0x1.00010000012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000200), 0x1.0001000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000202), 0x1.000100000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000204), 0x1.000100000408p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000220), 0x1.00010000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000400), 0x1.0001000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000404), 0x1.000100000808p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000440), 0x1.00010000088p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080000500), 0x1.000100000ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800080004000), 0x1.000100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080004008), 0x1.00010000801p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080004010), 0x1.00010000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080004100), 0x1.0001000082p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080005000), 0x1.00010000ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800080020000), 0x1.00010004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080020008), 0x1.00010004001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080020080), 0x1.0001000401p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080020800), 0x1.000100041p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080022000), 0x1.000100044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080028000), 0x1.00010005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080000), 0x1.0001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080001), 0x1.000100100002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080004), 0x1.000100100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080010), 0x1.00010010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080040), 0x1.00010010008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080100), 0x1.0001001002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080080800), 0x1.000100101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080081000), 0x1.000100102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080088000), 0x1.00010011p+47, 0x0p+0 },
+{ UINT64_C(0x00008000800a0000), 0x1.00010014p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080400000), 0x1.0001008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080400008), 0x1.00010080001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080400040), 0x1.00010080008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080400400), 0x1.0001008008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080400800), 0x1.000100801p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080404000), 0x1.000100808p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080410000), 0x1.00010082p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080500000), 0x1.000100ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800080600000), 0x1.000100cp+47, 0x0p+0 },
+{ UINT64_C(0x0000800080800000), 0x1.000101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080800002), 0x1.000101000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080800020), 0x1.00010100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080800040), 0x1.00010100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080800080), 0x1.0001010001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080800400), 0x1.0001010008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080801000), 0x1.000101002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080804000), 0x1.000101008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080820000), 0x1.00010104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080840000), 0x1.00010108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800080900000), 0x1.0001012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000000), 0x1.000108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000008), 0x1.00010800001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000010), 0x1.00010800002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000080), 0x1.0001080001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000100), 0x1.0001080002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000200), 0x1.0001080004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084000800), 0x1.000108001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084002000), 0x1.000108004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084020000), 0x1.00010804p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084080000), 0x1.0001081p+47, 0x0p+0 },
+{ UINT64_C(0x0000800084100000), 0x1.0001082p+47, 0x0p+0 },
+{ UINT64_C(0x0000800085000000), 0x1.00010ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800090000000), 0x1.00012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090000008), 0x1.00012000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090000020), 0x1.00012000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090000200), 0x1.0001200004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090002000), 0x1.000120004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090008000), 0x1.00012001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090040000), 0x1.00012008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090080000), 0x1.0001201p+47, 0x0p+0 },
+{ UINT64_C(0x0000800090400000), 0x1.0001208p+47, 0x0p+0 },
+{ UINT64_C(0x0000800091000000), 0x1.000122p+47, 0x0p+0 },
+{ UINT64_C(0x0000800098000000), 0x1.00013p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0000000), 0x1.00018p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0000008), 0x1.00018000001p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0000010), 0x1.00018000002p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0000080), 0x1.0001800001p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0000100), 0x1.0001800002p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0000800), 0x1.000180001p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0004000), 0x1.000180008p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0008000), 0x1.00018001p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0020000), 0x1.00018004p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0100000), 0x1.0001802p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c0800000), 0x1.000181p+47, 0x0p+0 },
+{ UINT64_C(0x00008000c4000000), 0x1.000188p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000004), 0x1.001000000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000010), 0x1.00100000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000012), 0x1.001000000024p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000014), 0x1.001000000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000018), 0x1.00100000003p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000020), 0x1.00100000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000022), 0x1.001000000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000030), 0x1.00100000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000080), 0x1.0010000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000082), 0x1.001000000104p+47, 0x0p+0 },
+{ UINT64_C(0x00008008000000a0), 0x1.00100000014p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000400), 0x1.0010000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000402), 0x1.001000000804p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000420), 0x1.00100000084p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000500), 0x1.001000000ap+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000600), 0x1.001000000cp+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000800), 0x1.001000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000802), 0x1.001000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000820), 0x1.00100000104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800000a00), 0x1.0010000014p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800008000), 0x1.00100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800008008), 0x1.00100001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800008020), 0x1.00100001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800008100), 0x1.0010000102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800008200), 0x1.0010000104p+47, 0x0p+0 },
+{ UINT64_C(0x000080080000a000), 0x1.001000014p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800020000), 0x1.00100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800020002), 0x1.001000040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800020004), 0x1.001000040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800020040), 0x1.00100004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800020200), 0x1.0010000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800021000), 0x1.001000042p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800028000), 0x1.00100005p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800200000), 0x1.0010004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800200008), 0x1.00100040001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800200020), 0x1.00100040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800200040), 0x1.00100040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800200080), 0x1.0010004001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800200200), 0x1.0010004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800202000), 0x1.001000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800208000), 0x1.00100041p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800220000), 0x1.00100044p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800300000), 0x1.0010006p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800800000), 0x1.001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800800004), 0x1.001001000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800800010), 0x1.00100100002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800800040), 0x1.00100100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800800100), 0x1.0010010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800800800), 0x1.001001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800801000), 0x1.001001002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800810000), 0x1.00100102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800840000), 0x1.00100108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800880000), 0x1.0010011p+47, 0x0p+0 },
+{ UINT64_C(0x0000800800a00000), 0x1.0010014p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804000000), 0x1.001008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804000008), 0x1.00100800001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804000040), 0x1.00100800008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804000100), 0x1.0010080002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804000200), 0x1.0010080004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804002000), 0x1.001008004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804020000), 0x1.00100804p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804100000), 0x1.0010082p+47, 0x0p+0 },
+{ UINT64_C(0x0000800804800000), 0x1.001009p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808000000), 0x1.00101p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808000008), 0x1.00101000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808000080), 0x1.0010100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808000400), 0x1.0010100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808000800), 0x1.001010001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808008000), 0x1.00101001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808020000), 0x1.00101004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808200000), 0x1.0010104p+47, 0x0p+0 },
+{ UINT64_C(0x0000800808400000), 0x1.0010108p+47, 0x0p+0 },
+{ UINT64_C(0x0000800809000000), 0x1.001012p+47, 0x0p+0 },
+{ UINT64_C(0x000080080c000000), 0x1.001018p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810000000), 0x1.00102p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810000008), 0x1.00102000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810000080), 0x1.0010200001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810000100), 0x1.0010200002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810001000), 0x1.001020002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810002000), 0x1.001020004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810020000), 0x1.00102004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810040000), 0x1.00102008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810200000), 0x1.0010204p+47, 0x0p+0 },
+{ UINT64_C(0x0000800810800000), 0x1.001021p+47, 0x0p+0 },
+{ UINT64_C(0x0000800814000000), 0x1.001028p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900000000), 0x1.0012p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900000001), 0x1.001200000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900000010), 0x1.00120000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900000040), 0x1.00120000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900000200), 0x1.0012000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900002000), 0x1.001200004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900020000), 0x1.00120004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900040000), 0x1.00120008p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900080000), 0x1.0012001p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900200000), 0x1.0012004p+47, 0x0p+0 },
+{ UINT64_C(0x0000800900800000), 0x1.001201p+47, 0x0p+0 },
+{ UINT64_C(0x0000800901000000), 0x1.001202p+47, 0x0p+0 },
+{ UINT64_C(0x0000800902000000), 0x1.001204p+47, 0x0p+0 },
+{ UINT64_C(0x0000800904000000), 0x1.001208p+47, 0x0p+0 },
+{ UINT64_C(0x0000800908000000), 0x1.00121p+47, 0x0p+0 },
+{ UINT64_C(0x0000800920000000), 0x1.00124p+47, 0x0p+0 },
+{ UINT64_C(0x0000800940000000), 0x1.00128p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000001), 0x1.004000000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000002), 0x1.004000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000020), 0x1.00400000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000022), 0x1.004000000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000024), 0x1.004000000048p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000030), 0x1.00400000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000200), 0x1.0040000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000208), 0x1.00400000041p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000000220), 0x1.00400000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000001000), 0x1.004000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000001001), 0x1.004000002002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000001004), 0x1.004000002008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000001020), 0x1.00400000204p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000001040), 0x1.00400000208p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000001400), 0x1.0040000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000002000), 0x1.004000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000002002), 0x1.004000004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000002004), 0x1.004000004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000002040), 0x1.00400000408p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000002200), 0x1.0040000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000002400), 0x1.0040000048p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000010000), 0x1.00400002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000010001), 0x1.004000020002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000010010), 0x1.00400002002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000010020), 0x1.00400002004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000010040), 0x1.00400002008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000010200), 0x1.0040000204p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000012000), 0x1.004000024p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000014000), 0x1.004000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000080000), 0x1.0040001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000080002), 0x1.004000100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000080020), 0x1.00400010004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000080080), 0x1.0040001001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000080400), 0x1.0040001008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000084000), 0x1.004000108p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000090000), 0x1.00400012p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000400000), 0x1.0040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000400008), 0x1.00400080001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000400080), 0x1.0040008001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000400100), 0x1.0040008002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000400800), 0x1.004000801p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000401000), 0x1.004000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000410000), 0x1.00400082p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000420000), 0x1.00400084p+47, 0x0p+0 },
+{ UINT64_C(0x0000802000480000), 0x1.0040009p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002000000), 0x1.004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002000002), 0x1.004004000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002000020), 0x1.00400400004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002000040), 0x1.00400400008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002000100), 0x1.0040040002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002000200), 0x1.0040040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002002000), 0x1.004004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002008000), 0x1.00400401p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002080000), 0x1.0040041p+47, 0x0p+0 },
+{ UINT64_C(0x0000802002200000), 0x1.0040044p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020000000), 0x1.00404p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020000008), 0x1.00404000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020000080), 0x1.0040400001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020000200), 0x1.0040400004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020001000), 0x1.004040002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020004000), 0x1.004040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020010000), 0x1.00404002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020080000), 0x1.0040401p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020100000), 0x1.0040402p+47, 0x0p+0 },
+{ UINT64_C(0x0000802020800000), 0x1.004041p+47, 0x0p+0 },
+{ UINT64_C(0x0000802028000000), 0x1.00405p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100000000), 0x1.0042p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100000008), 0x1.00420000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100000010), 0x1.00420000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100000040), 0x1.00420000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100000200), 0x1.0042000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100001000), 0x1.004200002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100004000), 0x1.004200008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100040000), 0x1.00420008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100200000), 0x1.0042004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802100400000), 0x1.0042008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802104000000), 0x1.004208p+47, 0x0p+0 },
+{ UINT64_C(0x0000802110000000), 0x1.00422p+47, 0x0p+0 },
+{ UINT64_C(0x0000802120000000), 0x1.00424p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200000000), 0x1.0044p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200000001), 0x1.004400000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200000010), 0x1.00440000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200000100), 0x1.0044000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200000200), 0x1.0044000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200001000), 0x1.004400002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200004000), 0x1.004400008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200008000), 0x1.00440001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200040000), 0x1.00440008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802200200000), 0x1.0044004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802201000000), 0x1.004402p+47, 0x0p+0 },
+{ UINT64_C(0x0000802202000000), 0x1.004404p+47, 0x0p+0 },
+{ UINT64_C(0x0000802210000000), 0x1.00442p+47, 0x0p+0 },
+{ UINT64_C(0x0000802280000000), 0x1.0045p+47, 0x0p+0 },
+{ UINT64_C(0x0000802300000000), 0x1.0046p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400000000), 0x1.0048p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400000002), 0x1.004800000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400000020), 0x1.00480000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400000100), 0x1.0048000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400001000), 0x1.004800002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400002000), 0x1.004800004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400004000), 0x1.004800008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400008000), 0x1.00480001p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400010000), 0x1.00480002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400100000), 0x1.0048002p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400200000), 0x1.0048004p+47, 0x0p+0 },
+{ UINT64_C(0x0000802400400000), 0x1.0048008p+47, 0x0p+0 },
+{ UINT64_C(0x0000802404000000), 0x1.004808p+47, 0x0p+0 },
+{ UINT64_C(0x0000802440000000), 0x1.00488p+47, 0x0p+0 },
+{ UINT64_C(0x0000802600000000), 0x1.004cp+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000002), 0x1.020000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000003), 0x1.020000000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000004), 0x1.020000000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000006), 0x1.02000000000cp+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000040), 0x1.02000000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000041), 0x1.020000000082p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000044), 0x1.020000000088p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000048), 0x1.02000000009p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000080), 0x1.0200000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000084), 0x1.020000000108p+47, 0x0p+0 },
+{ UINT64_C(0x00008100000000a0), 0x1.02000000014p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000200), 0x1.0200000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000201), 0x1.020000000402p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000202), 0x1.020000000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000210), 0x1.02000000042p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000240), 0x1.02000000048p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000800), 0x1.020000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000801), 0x1.020000001002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000802), 0x1.020000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000810), 0x1.02000000102p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000820), 0x1.02000000104p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000840), 0x1.02000000108p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000000900), 0x1.0200000012p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000001000), 0x1.020000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000001004), 0x1.020000002008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000001010), 0x1.02000000202p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000001100), 0x1.0200000022p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000004000), 0x1.020000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000004008), 0x1.02000000801p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000004020), 0x1.02000000804p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000004200), 0x1.0200000084p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000006000), 0x1.02000000cp+47, 0x0p+0 },
+{ UINT64_C(0x0000810000020000), 0x1.02000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000020008), 0x1.02000004001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000020020), 0x1.02000004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000020040), 0x1.02000004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000020100), 0x1.0200000402p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000020800), 0x1.020000041p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000021000), 0x1.020000042p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000030000), 0x1.02000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000040000), 0x1.02000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000040008), 0x1.02000008001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000040040), 0x1.02000008008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000040100), 0x1.0200000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000041000), 0x1.020000082p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000042000), 0x1.020000084p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000044000), 0x1.020000088p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000048000), 0x1.02000009p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000200000), 0x1.0200004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000200002), 0x1.020000400004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000200020), 0x1.02000040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000200100), 0x1.0200004002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000200200), 0x1.0200004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000202000), 0x1.020000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000810000220000), 0x1.02000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000000), 0x1.020002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000008), 0x1.02000200001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000040), 0x1.02000200008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000080), 0x1.0200020001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000100), 0x1.0200020002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000200), 0x1.0200020004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000400), 0x1.0200020008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001000800), 0x1.020002001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001001000), 0x1.020002002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001002000), 0x1.020002004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001010000), 0x1.02000202p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001100000), 0x1.0200022p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001200000), 0x1.0200024p+47, 0x0p+0 },
+{ UINT64_C(0x0000810001400000), 0x1.0200028p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010000000), 0x1.02002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010000001), 0x1.020020000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010000010), 0x1.02002000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010000020), 0x1.02002000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010000200), 0x1.0200200004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010001000), 0x1.020020002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010002000), 0x1.020020004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010010000), 0x1.02002002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010020000), 0x1.02002004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810010200000), 0x1.0200204p+47, 0x0p+0 },
+{ UINT64_C(0x0000810012000000), 0x1.020024p+47, 0x0p+0 },
+{ UINT64_C(0x0000810018000000), 0x1.02003p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020000000), 0x1.02004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020000002), 0x1.020040000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020000020), 0x1.02004000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020000080), 0x1.0200400001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020000100), 0x1.0200400002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020000400), 0x1.0200400008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020002000), 0x1.020040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020020000), 0x1.02004004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810020100000), 0x1.0200402p+47, 0x0p+0 },
+{ UINT64_C(0x0000810021000000), 0x1.020042p+47, 0x0p+0 },
+{ UINT64_C(0x0000810030000000), 0x1.02006p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080000000), 0x1.0201p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080000002), 0x1.020100000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080000010), 0x1.02010000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080000080), 0x1.0201000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080000400), 0x1.0201000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080002000), 0x1.020100004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080004000), 0x1.020100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080010000), 0x1.02010002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080020000), 0x1.02010004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080040000), 0x1.02010008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080080000), 0x1.0201001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080100000), 0x1.0201002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080400000), 0x1.0201008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810080800000), 0x1.020101p+47, 0x0p+0 },
+{ UINT64_C(0x0000810084000000), 0x1.020108p+47, 0x0p+0 },
+{ UINT64_C(0x00008100a0000000), 0x1.02014p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100000000), 0x1.0202p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100000001), 0x1.020200000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100000010), 0x1.02020000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100000040), 0x1.02020000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100000080), 0x1.0202000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100000200), 0x1.0202000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100002000), 0x1.020200004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100008000), 0x1.02020001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100080000), 0x1.0202001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810100800000), 0x1.020201p+47, 0x0p+0 },
+{ UINT64_C(0x0000810108000000), 0x1.02021p+47, 0x0p+0 },
+{ UINT64_C(0x0000810180000000), 0x1.0203p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800000000), 0x1.021p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800000004), 0x1.021000000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800000020), 0x1.02100000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800000200), 0x1.0210000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800001000), 0x1.021000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800004000), 0x1.021000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800008000), 0x1.02100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800010000), 0x1.02100002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800080000), 0x1.0210001p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800100000), 0x1.0210002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810800400000), 0x1.0210008p+47, 0x0p+0 },
+{ UINT64_C(0x0000810801000000), 0x1.021002p+47, 0x0p+0 },
+{ UINT64_C(0x0000810810000000), 0x1.02102p+47, 0x0p+0 },
+{ UINT64_C(0x0000810840000000), 0x1.02108p+47, 0x0p+0 },
+{ UINT64_C(0x0000810a00000000), 0x1.0214p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000000000), 0x1.028p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000000008), 0x1.02800000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000000040), 0x1.02800000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000000100), 0x1.0280000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000000800), 0x1.028000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000004000), 0x1.028000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000020000), 0x1.02800004p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000040000), 0x1.02800008p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000200000), 0x1.0280004p+47, 0x0p+0 },
+{ UINT64_C(0x0000814000800000), 0x1.028001p+47, 0x0p+0 },
+{ UINT64_C(0x0000814001000000), 0x1.028002p+47, 0x0p+0 },
+{ UINT64_C(0x0000814002000000), 0x1.028004p+47, 0x0p+0 },
+{ UINT64_C(0x0000814008000000), 0x1.02801p+47, 0x0p+0 },
+{ UINT64_C(0x0000814020000000), 0x1.02804p+47, 0x0p+0 },
+{ UINT64_C(0x0000814040000000), 0x1.02808p+47, 0x0p+0 },
+{ UINT64_C(0x0000814080000000), 0x1.0281p+47, 0x0p+0 },
+{ UINT64_C(0x0000814800000000), 0x1.029p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000002), 0x1.200000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000003), 0x1.200000000006p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000008), 0x1.20000000001p+47, 0x0p+0 },
+{ UINT64_C(0x000090000000000a), 0x1.200000000014p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000020), 0x1.20000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000021), 0x1.200000000042p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000024), 0x1.200000000048p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000200), 0x1.2000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000202), 0x1.200000000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000204), 0x1.200000000408p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000208), 0x1.20000000041p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000210), 0x1.20000000042p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000280), 0x1.2000000005p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000800), 0x1.200000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000804), 0x1.200000001008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000840), 0x1.20000000108p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000000c00), 0x1.2000000018p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001000), 0x1.200000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001001), 0x1.200000002002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001008), 0x1.20000000201p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001010), 0x1.20000000202p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001020), 0x1.20000000204p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001040), 0x1.20000000208p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001080), 0x1.2000000021p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001100), 0x1.2000000022p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000001200), 0x1.2000000024p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004000), 0x1.200000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004001), 0x1.200000008002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004002), 0x1.200000008004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004004), 0x1.200000008008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004010), 0x1.20000000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004100), 0x1.2000000082p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004200), 0x1.2000000084p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000004800), 0x1.200000009p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000006000), 0x1.20000000cp+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020000), 0x1.20000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020004), 0x1.200000040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020008), 0x1.20000004001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020010), 0x1.20000004002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020040), 0x1.20000004008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020200), 0x1.2000000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000020400), 0x1.2000000408p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000022000), 0x1.200000044p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080000), 0x1.2000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080004), 0x1.200000100008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080020), 0x1.20000010004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080040), 0x1.20000010008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080100), 0x1.2000001002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080200), 0x1.2000001004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080400), 0x1.2000001008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000080800), 0x1.200000101p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000088000), 0x1.20000011p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000090000), 0x1.20000012p+47, 0x0p+0 },
+{ UINT64_C(0x00009000000c0000), 0x1.20000018p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100000), 0x1.2000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100002), 0x1.200000200004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100004), 0x1.200000200008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100020), 0x1.20000020004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100080), 0x1.2000002001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100400), 0x1.2000002008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000100800), 0x1.200000201p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000102000), 0x1.200000204p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000104000), 0x1.200000208p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000120000), 0x1.20000024p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000400000), 0x1.2000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000400001), 0x1.200000800002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000400004), 0x1.200000800008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000400010), 0x1.20000080002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000400100), 0x1.2000008002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000400400), 0x1.2000008008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000401000), 0x1.200000802p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000408000), 0x1.20000081p+47, 0x0p+0 },
+{ UINT64_C(0x0000900000480000), 0x1.2000009p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001000000), 0x1.200002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001000008), 0x1.20000200001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001000040), 0x1.20000200008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001000080), 0x1.2000020001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001000100), 0x1.2000020002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001001000), 0x1.200002002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001010000), 0x1.20000202p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001040000), 0x1.20000208p+47, 0x0p+0 },
+{ UINT64_C(0x0000900001400000), 0x1.2000028p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004000000), 0x1.200008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004000002), 0x1.200008000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004000020), 0x1.20000800004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004000040), 0x1.20000800008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004000080), 0x1.2000080001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004000200), 0x1.2000080004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004002000), 0x1.200008004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004008000), 0x1.20000801p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004080000), 0x1.2000081p+47, 0x0p+0 },
+{ UINT64_C(0x0000900004800000), 0x1.200009p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000000), 0x1.20004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000002), 0x1.200040000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000008), 0x1.20004000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000020), 0x1.20004000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000040), 0x1.20004000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000400), 0x1.2000400008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020000800), 0x1.200040001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020002000), 0x1.200040004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020008000), 0x1.20004001p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020010000), 0x1.20004002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020080000), 0x1.2000401p+47, 0x0p+0 },
+{ UINT64_C(0x0000900020200000), 0x1.2000404p+47, 0x0p+0 },
+{ UINT64_C(0x0000900022000000), 0x1.200044p+47, 0x0p+0 },
+{ UINT64_C(0x0000900030000000), 0x1.20006p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000000), 0x1.2004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000001), 0x1.200400000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000004), 0x1.200400000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000020), 0x1.20040000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000100), 0x1.2004000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000200), 0x1.2004000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200000400), 0x1.2004000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200004000), 0x1.200400008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200040000), 0x1.20040008p+47, 0x0p+0 },
+{ UINT64_C(0x0000900200100000), 0x1.2004002p+47, 0x0p+0 },
+{ UINT64_C(0x0000900201000000), 0x1.200402p+47, 0x0p+0 },
+{ UINT64_C(0x0000900202000000), 0x1.200404p+47, 0x0p+0 },
+{ UINT64_C(0x0000900204000000), 0x1.200408p+47, 0x0p+0 },
+{ UINT64_C(0x0000900210000000), 0x1.20042p+47, 0x0p+0 },
+{ UINT64_C(0x0000900240000000), 0x1.20048p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000000000), 0x1.204p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000000004), 0x1.204000000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000000040), 0x1.20400000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000000200), 0x1.2040000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000002000), 0x1.204000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000004000), 0x1.204000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000020000), 0x1.20400004p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000100000), 0x1.2040002p+47, 0x0p+0 },
+{ UINT64_C(0x0000902000800000), 0x1.204001p+47, 0x0p+0 },
+{ UINT64_C(0x0000902004000000), 0x1.204008p+47, 0x0p+0 },
+{ UINT64_C(0x0000902008000000), 0x1.20401p+47, 0x0p+0 },
+{ UINT64_C(0x0000902080000000), 0x1.2041p+47, 0x0p+0 },
+{ UINT64_C(0x0000902100000000), 0x1.2042p+47, 0x0p+0 },
+{ UINT64_C(0x0000902200000000), 0x1.2044p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000000), 0x1.21p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000004), 0x1.210000000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000010), 0x1.21000000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000020), 0x1.21000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000100), 0x1.2100000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000200), 0x1.2100000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000000800), 0x1.210000001p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000002000), 0x1.210000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000010000), 0x1.21000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000040000), 0x1.21000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000080000), 0x1.2100001p+47, 0x0p+0 },
+{ UINT64_C(0x0000908000800000), 0x1.210001p+47, 0x0p+0 },
+{ UINT64_C(0x0000908002000000), 0x1.210004p+47, 0x0p+0 },
+{ UINT64_C(0x0000908020000000), 0x1.21004p+47, 0x0p+0 },
+{ UINT64_C(0x0000908200000000), 0x1.2104p+47, 0x0p+0 },
+{ UINT64_C(0x000090a000000000), 0x1.214p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000000), 0x1.24p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000001), 0x1.240000000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000002), 0x1.240000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000010), 0x1.24000000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000020), 0x1.24000000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000200), 0x1.2400000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000000400), 0x1.2400000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000001000), 0x1.240000002p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000002000), 0x1.240000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000004000), 0x1.240000008p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000020000), 0x1.24000004p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000200000), 0x1.2400004p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000400000), 0x1.2400008p+47, 0x0p+0 },
+{ UINT64_C(0x0000920000800000), 0x1.240001p+47, 0x0p+0 },
+{ UINT64_C(0x0000920004000000), 0x1.240008p+47, 0x0p+0 },
+{ UINT64_C(0x0000920040000000), 0x1.24008p+47, 0x0p+0 },
+{ UINT64_C(0x0000920400000000), 0x1.2408p+47, 0x0p+0 },
+{ UINT64_C(0x0000920800000000), 0x1.241p+47, 0x0p+0 },
+{ UINT64_C(0x0000928000000000), 0x1.25p+47, 0x0p+0 },
+{ UINT64_C(0x0001000000000005), 0x1.000000000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000018), 0x1.000000000018p+48, 0x0p+0 },
+{ UINT64_C(0x000100000000001a), 0x1.00000000001ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000042), 0x1.000000000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000050), 0x1.00000000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000058), 0x1.000000000058p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000101), 0x1.000000000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000102), 0x1.000000000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000110), 0x1.00000000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000111), 0x1.000000000111p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000000112), 0x1.000000000112p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001001), 0x1.000000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001004), 0x1.000000001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001020), 0x1.00000000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001028), 0x1.000000001028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001030), 0x1.00000000103p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001080), 0x1.00000000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001082), 0x1.000000001082p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001088), 0x1.000000001088p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000010a0), 0x1.0000000010ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001200), 0x1.0000000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001204), 0x1.000000001204p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001208), 0x1.000000001208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001240), 0x1.00000000124p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001400), 0x1.0000000014p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001408), 0x1.000000001408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001410), 0x1.00000000141p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001420), 0x1.00000000142p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000001500), 0x1.0000000015p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004001), 0x1.000000004001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004002), 0x1.000000004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004010), 0x1.00000000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004012), 0x1.000000004012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004018), 0x1.000000004018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004080), 0x1.00000000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004084), 0x1.000000004084p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004088), 0x1.000000004088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004100), 0x1.0000000041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004101), 0x1.000000004101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004102), 0x1.000000004102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004120), 0x1.00000000412p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004800), 0x1.0000000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004808), 0x1.000000004808p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004810), 0x1.00000000481p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004840), 0x1.00000000484p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000004a00), 0x1.000000004ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000000005000), 0x1.000000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000005004), 0x1.000000005004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000005020), 0x1.00000000502p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000005100), 0x1.0000000051p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040004), 0x1.000000040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040005), 0x1.000000040005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040020), 0x1.00000004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040024), 0x1.000000040024p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040040), 0x1.00000004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040044), 0x1.000000040044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040060), 0x1.00000004006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040080), 0x1.00000004008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040088), 0x1.000000040088p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000400c0), 0x1.0000000400cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040400), 0x1.0000000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040404), 0x1.000000040404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040410), 0x1.00000004041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040420), 0x1.00000004042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000040440), 0x1.00000004044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000042000), 0x1.000000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000042008), 0x1.000000042008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000042080), 0x1.00000004208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000042100), 0x1.0000000421p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000043000), 0x1.000000043p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044000), 0x1.000000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044001), 0x1.000000044001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044010), 0x1.00000004401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044080), 0x1.00000004408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044200), 0x1.0000000442p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044400), 0x1.0000000444p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000044800), 0x1.0000000448p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000046000), 0x1.000000046p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080004), 0x1.000000080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080006), 0x1.000000080006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080008), 0x1.000000080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080040), 0x1.00000008004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080048), 0x1.000000080048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080050), 0x1.00000008005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080060), 0x1.00000008006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080200), 0x1.0000000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080202), 0x1.000000080202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000080220), 0x1.00000008022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000081000), 0x1.000000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000081004), 0x1.000000081004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000081020), 0x1.00000008102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000081100), 0x1.0000000811p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000081800), 0x1.0000000818p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000090000), 0x1.00000009p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000090001), 0x1.000000090001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000090004), 0x1.000000090004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000090040), 0x1.00000009004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000090080), 0x1.00000009008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000090200), 0x1.0000000902p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000092000), 0x1.000000092p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0000), 0x1.0000000ap+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0001), 0x1.0000000a0001p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0002), 0x1.0000000a0002p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0020), 0x1.0000000a002p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0080), 0x1.0000000a008p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0400), 0x1.0000000a04p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a0800), 0x1.0000000a08p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000a4000), 0x1.0000000a4p+48, 0x0p+0 },
+{ UINT64_C(0x00010000000b0000), 0x1.0000000bp+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100002), 0x1.000000100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100003), 0x1.000000100003p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100020), 0x1.00000010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100021), 0x1.000000100021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100024), 0x1.000000100024p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100028), 0x1.000000100028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100100), 0x1.0000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100108), 0x1.000000100108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100180), 0x1.00000010018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100400), 0x1.0000001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100408), 0x1.000000100408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100420), 0x1.00000010042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100440), 0x1.00000010044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100800), 0x1.0000001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100804), 0x1.000000100804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100810), 0x1.00000010081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100840), 0x1.00000010084p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000100a00), 0x1.000000100ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000000108000), 0x1.000000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000108001), 0x1.000000108001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000108002), 0x1.000000108002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000108010), 0x1.00000010801p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000108100), 0x1.0000001081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000109000), 0x1.000000109p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000120000), 0x1.00000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000120004), 0x1.000000120004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000120008), 0x1.000000120008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000120040), 0x1.00000012004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000120200), 0x1.0000001202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000120800), 0x1.0000001208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000128000), 0x1.000000128p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200004), 0x1.000000200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200008), 0x1.000000200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200020), 0x1.00000020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200028), 0x1.000000200028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200030), 0x1.00000020003p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200100), 0x1.0000002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200101), 0x1.000000200101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200108), 0x1.000000200108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200120), 0x1.00000020012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200800), 0x1.0000002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200804), 0x1.000000200804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200810), 0x1.00000020081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000200880), 0x1.00000020088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000201000), 0x1.000000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000201008), 0x1.000000201008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000201080), 0x1.00000020108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000201200), 0x1.0000002012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000204000), 0x1.000000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000204002), 0x1.000000204002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000204010), 0x1.00000020401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000204020), 0x1.00000020402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000204040), 0x1.00000020404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000204200), 0x1.0000002042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000205000), 0x1.000000205p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000210000), 0x1.00000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000210001), 0x1.000000210001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000210010), 0x1.00000021001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000210080), 0x1.00000021008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000210100), 0x1.0000002101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000211000), 0x1.000000211p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000240000), 0x1.00000024p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000240008), 0x1.000000240008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000240020), 0x1.00000024002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000240200), 0x1.0000002402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000241000), 0x1.000000241p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000244000), 0x1.000000244p+48, 0x0p+0 },
+{ UINT64_C(0x0001000000250000), 0x1.00000025p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000002), 0x1.000001000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000020), 0x1.00000100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000022), 0x1.000001000022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000030), 0x1.00000100003p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000100), 0x1.0000010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000101), 0x1.000001000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000104), 0x1.000001000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000120), 0x1.00000100012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000200), 0x1.0000010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000201), 0x1.000001000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000208), 0x1.000001000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000210), 0x1.00000100021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000240), 0x1.00000100024p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000300), 0x1.0000010003p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000800), 0x1.0000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000802), 0x1.000001000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000820), 0x1.00000100082p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000840), 0x1.00000100084p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000880), 0x1.00000100088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001000a00), 0x1.000001000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008000), 0x1.000001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008002), 0x1.000001008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008010), 0x1.00000100801p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008040), 0x1.00000100804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008080), 0x1.00000100808p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008100), 0x1.0000010081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001008800), 0x1.0000010088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001020000), 0x1.00000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001020008), 0x1.000001020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001020040), 0x1.00000102004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001020400), 0x1.0000010204p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001024000), 0x1.000001024p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001100000), 0x1.0000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001100001), 0x1.000001100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001100008), 0x1.000001100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001100080), 0x1.00000110008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001100200), 0x1.0000011002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001100800), 0x1.0000011008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001104000), 0x1.000001104p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001110000), 0x1.00000111p+48, 0x0p+0 },
+{ UINT64_C(0x0001000001180000), 0x1.00000118p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000004), 0x1.000010000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000005), 0x1.000010000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000006), 0x1.000010000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000008), 0x1.000010000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000080), 0x1.00001000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000084), 0x1.000010000084p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000090), 0x1.00001000009p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000400), 0x1.0000100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000401), 0x1.000010000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000402), 0x1.000010000402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000408), 0x1.000010000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000410), 0x1.00001000041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000420), 0x1.00001000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000480), 0x1.00001000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000600), 0x1.0000100006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000800), 0x1.0000100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000804), 0x1.000010000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000820), 0x1.00001000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000840), 0x1.00001000084p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010000c00), 0x1.000010000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000010002000), 0x1.000010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010002002), 0x1.000010002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010002010), 0x1.00001000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010002080), 0x1.00001000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010002400), 0x1.0000100024p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010004000), 0x1.000010004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010004008), 0x1.000010004008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010004010), 0x1.00001000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010004040), 0x1.00001000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010004200), 0x1.0000100042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010004400), 0x1.0000100044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010040000), 0x1.00001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010040008), 0x1.000010040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010040010), 0x1.00001004001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010040040), 0x1.00001004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010040200), 0x1.0000100402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010040800), 0x1.0000100408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010041000), 0x1.000010041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010048000), 0x1.000010048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010080000), 0x1.00001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010080004), 0x1.000010080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010080008), 0x1.000010080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010080040), 0x1.00001008004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010080400), 0x1.0000100804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010084000), 0x1.000010084p+48, 0x0p+0 },
+{ UINT64_C(0x00010000100a0000), 0x1.0000100ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000010400000), 0x1.0000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010400004), 0x1.000010400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010400040), 0x1.00001040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010400400), 0x1.0000104004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010401000), 0x1.000010401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010404000), 0x1.000010404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010420000), 0x1.00001042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000010600000), 0x1.0000106p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011000000), 0x1.000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011000008), 0x1.000011000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011000040), 0x1.00001100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011000100), 0x1.0000110001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011000400), 0x1.0000110004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011001000), 0x1.000011001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011004000), 0x1.000011004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011020000), 0x1.00001102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011040000), 0x1.00001104p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011080000), 0x1.00001108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011400000), 0x1.0000114p+48, 0x0p+0 },
+{ UINT64_C(0x0001000011800000), 0x1.0000118p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018000000), 0x1.000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018000002), 0x1.000018000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018000008), 0x1.000018000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018000010), 0x1.00001800001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018000100), 0x1.0000180001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018000200), 0x1.0000180002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018002000), 0x1.000018002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018004000), 0x1.000018004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018010000), 0x1.00001801p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018100000), 0x1.0000181p+48, 0x0p+0 },
+{ UINT64_C(0x0001000018200000), 0x1.0000182p+48, 0x0p+0 },
+{ UINT64_C(0x000100001a000000), 0x1.00001ap+48, 0x0p+0 },
+{ UINT64_C(0x000100001c000000), 0x1.00001cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000004), 0x1.000040000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000040), 0x1.00004000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000042), 0x1.000040000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000044), 0x1.000040000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000048), 0x1.000040000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000050), 0x1.00004000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000200), 0x1.0000400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000202), 0x1.000040000202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000208), 0x1.000040000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000210), 0x1.00004000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040000280), 0x1.00004000028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040002000), 0x1.000040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040002008), 0x1.000040002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040002020), 0x1.00004000202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040002200), 0x1.0000400022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040020000), 0x1.00004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040020008), 0x1.000040020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040020020), 0x1.00004002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040020200), 0x1.0000400202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040022000), 0x1.000040022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040028000), 0x1.000040028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040100000), 0x1.0000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040100004), 0x1.000040100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040100010), 0x1.00004010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040100100), 0x1.0000401001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040101000), 0x1.000040101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040104000), 0x1.000040104p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040120000), 0x1.00004012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040200000), 0x1.0000402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040200001), 0x1.000040200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040200004), 0x1.000040200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040200010), 0x1.00004020001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040200100), 0x1.0000402001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040200400), 0x1.0000402004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040204000), 0x1.000040204p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040208000), 0x1.000040208p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040210000), 0x1.00004021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040220000), 0x1.00004022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000040280000), 0x1.00004028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041000000), 0x1.000041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041000002), 0x1.000041000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041000010), 0x1.00004100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041000100), 0x1.0000410001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041000400), 0x1.0000410004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041002000), 0x1.000041002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041020000), 0x1.00004102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041100000), 0x1.0000411p+48, 0x0p+0 },
+{ UINT64_C(0x0001000041200000), 0x1.0000412p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000000), 0x1.000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000001), 0x1.000048000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000004), 0x1.000048000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000008), 0x1.000048000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000020), 0x1.00004800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000200), 0x1.0000480002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048000800), 0x1.0000480008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048008000), 0x1.000048008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048020000), 0x1.00004802p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048040000), 0x1.00004804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000048100000), 0x1.0000481p+48, 0x0p+0 },
+{ UINT64_C(0x0001000049000000), 0x1.000049p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000001), 0x1.000100000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000008), 0x1.000100000008p+48, 0x0p+0 },
+{ UINT64_C(0x000100010000000a), 0x1.00010000000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000020), 0x1.00010000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000022), 0x1.000100000022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000030), 0x1.00010000003p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000080), 0x1.00010000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000088), 0x1.000100000088p+48, 0x0p+0 },
+{ UINT64_C(0x00010001000000a0), 0x1.0001000000ap+48, 0x0p+0 },
+{ UINT64_C(0x00010001000000c0), 0x1.0001000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000400), 0x1.0001000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000408), 0x1.000100000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100000440), 0x1.00010000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100001000), 0x1.000100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100001008), 0x1.000100001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100001040), 0x1.00010000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100001100), 0x1.0001000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100001200), 0x1.0001000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100001800), 0x1.0001000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100004000), 0x1.000100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100004004), 0x1.000100004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100004020), 0x1.00010000402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100004100), 0x1.0001000041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100004200), 0x1.0001000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100006000), 0x1.000100006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100020000), 0x1.00010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100020008), 0x1.000100020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100020010), 0x1.00010002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100020020), 0x1.00010002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100020040), 0x1.00010002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100020400), 0x1.0001000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100021000), 0x1.000100021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100022000), 0x1.000100022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100028000), 0x1.000100028p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100080000), 0x1.00010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100080004), 0x1.000100080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100080008), 0x1.000100080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100080080), 0x1.00010008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100080400), 0x1.0001000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100082000), 0x1.000100082p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100088000), 0x1.000100088p+48, 0x0p+0 },
+{ UINT64_C(0x00010001000c0000), 0x1.0001000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000100100000), 0x1.0001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100100001), 0x1.000100100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100100010), 0x1.00010010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100100100), 0x1.0001001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100100800), 0x1.0001001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100101000), 0x1.000100101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100110000), 0x1.00010011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100120000), 0x1.00010012p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100400000), 0x1.0001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100400001), 0x1.000100400001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100400004), 0x1.000100400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100400040), 0x1.00010040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100400400), 0x1.0001004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100400800), 0x1.0001004008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100402000), 0x1.000100402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100410000), 0x1.00010041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100420000), 0x1.00010042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100480000), 0x1.00010048p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100500000), 0x1.0001005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100800000), 0x1.0001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100800004), 0x1.000100800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100800020), 0x1.00010080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100800040), 0x1.00010080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100800080), 0x1.00010080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100800200), 0x1.0001008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100802000), 0x1.000100802p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100808000), 0x1.000100808p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100810000), 0x1.00010081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100880000), 0x1.00010088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000100a00000), 0x1.000100ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000101000000), 0x1.000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101000002), 0x1.000101000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101000020), 0x1.00010100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101000100), 0x1.0001010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101001000), 0x1.000101001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101004000), 0x1.000101004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101020000), 0x1.00010102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101080000), 0x1.00010108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000101800000), 0x1.0001018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110000000), 0x1.00011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110000002), 0x1.000110000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110000020), 0x1.00011000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110000080), 0x1.00011000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110000800), 0x1.0001100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110001000), 0x1.000110001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110008000), 0x1.000110008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110020000), 0x1.00011002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000110200000), 0x1.0001102p+48, 0x0p+0 },
+{ UINT64_C(0x0001000112000000), 0x1.000112p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140000000), 0x1.00014p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140000008), 0x1.000140000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140000020), 0x1.00014000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140000100), 0x1.0001400001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140000800), 0x1.0001400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140008000), 0x1.000140008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140010000), 0x1.00014001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140040000), 0x1.00014004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000140400000), 0x1.0001404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000144000000), 0x1.000144p+48, 0x0p+0 },
+{ UINT64_C(0x0001000160000000), 0x1.00016p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000000), 0x1.00018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000002), 0x1.000180000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000010), 0x1.00018000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000020), 0x1.00018000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000040), 0x1.00018000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000200), 0x1.0001800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180000800), 0x1.0001800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180002000), 0x1.000180002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180020000), 0x1.00018002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180100000), 0x1.0001801p+48, 0x0p+0 },
+{ UINT64_C(0x0001000180400000), 0x1.0001804p+48, 0x0p+0 },
+{ UINT64_C(0x0001000182000000), 0x1.000182p+48, 0x0p+0 },
+{ UINT64_C(0x0001000190000000), 0x1.00019p+48, 0x0p+0 },
+{ UINT64_C(0x00010001c0000000), 0x1.0001cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000008), 0x1.000800000008p+48, 0x0p+0 },
+{ UINT64_C(0x000100080000000a), 0x1.00080000000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000040), 0x1.00080000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000042), 0x1.000800000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000060), 0x1.00080000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000100), 0x1.0008000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000101), 0x1.000800000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000108), 0x1.000800000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000110), 0x1.00080000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000180), 0x1.00080000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000400), 0x1.0008000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000408), 0x1.000800000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000420), 0x1.00080000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800000600), 0x1.0008000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800004000), 0x1.000800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800004004), 0x1.000800004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800004020), 0x1.00080000402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800004040), 0x1.00080000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800004100), 0x1.0008000041p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800004400), 0x1.0008000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800005000), 0x1.000800005p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800006000), 0x1.000800006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800040000), 0x1.00080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800040008), 0x1.000800040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800040020), 0x1.00080004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800040100), 0x1.0008000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800040200), 0x1.0008000402p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800042000), 0x1.000800042p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800060000), 0x1.00080006p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800200000), 0x1.0008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800200004), 0x1.000800200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800200040), 0x1.00080020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800200080), 0x1.00080020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800200200), 0x1.0008002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800202000), 0x1.000800202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800204000), 0x1.000800204p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800210000), 0x1.00080021p+48, 0x0p+0 },
+{ UINT64_C(0x0001000800300000), 0x1.0008003p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802000000), 0x1.000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802000001), 0x1.000802000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802000002), 0x1.000802000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802000008), 0x1.000802000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802000040), 0x1.00080200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802000200), 0x1.0008020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802002000), 0x1.000802002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802020000), 0x1.00080202p+48, 0x0p+0 },
+{ UINT64_C(0x0001000802200000), 0x1.0008022p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808000000), 0x1.000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808000004), 0x1.000808000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808000040), 0x1.00080800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808000400), 0x1.0008080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808004000), 0x1.000808004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808008000), 0x1.000808008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808010000), 0x1.00080801p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808100000), 0x1.0008081p+48, 0x0p+0 },
+{ UINT64_C(0x0001000808800000), 0x1.0008088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000809000000), 0x1.000809p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880000000), 0x1.00088p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880000004), 0x1.000880000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880000020), 0x1.00088000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880000200), 0x1.0008800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880000400), 0x1.0008800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880001000), 0x1.000880001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880004000), 0x1.000880004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880008000), 0x1.000880008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880040000), 0x1.00088004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880100000), 0x1.0008801p+48, 0x0p+0 },
+{ UINT64_C(0x0001000880200000), 0x1.0008802p+48, 0x0p+0 },
+{ UINT64_C(0x0001000881000000), 0x1.000881p+48, 0x0p+0 },
+{ UINT64_C(0x0001000890000000), 0x1.00089p+48, 0x0p+0 },
+{ UINT64_C(0x00010008a0000000), 0x1.0008ap+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00000000), 0x1.000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00000004), 0x1.000c00000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00000020), 0x1.000c0000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00000080), 0x1.000c0000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00000800), 0x1.000c000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00002000), 0x1.000c00002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00008000), 0x1.000c00008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00010000), 0x1.000c0001p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00020000), 0x1.000c0002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00040000), 0x1.000c0004p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00200000), 0x1.000c002p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c00800000), 0x1.000c008p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c01000000), 0x1.000c01p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c08000000), 0x1.000c08p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c20000000), 0x1.000c2p+48, 0x0p+0 },
+{ UINT64_C(0x0001000c40000000), 0x1.000c4p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000008), 0x1.008000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000020), 0x1.00800000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000028), 0x1.008000000028p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000080), 0x1.00800000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000082), 0x1.008000000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000090), 0x1.00800000009p+48, 0x0p+0 },
+{ UINT64_C(0x00010080000000a0), 0x1.0080000000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000800), 0x1.0080000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000802), 0x1.008000000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000808), 0x1.008000000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000810), 0x1.00800000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000820), 0x1.00800000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000000900), 0x1.0080000009p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001000), 0x1.008000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001001), 0x1.008000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001004), 0x1.008000001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001010), 0x1.00800000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001020), 0x1.00800000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001080), 0x1.00800000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000001800), 0x1.0080000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000002000), 0x1.008000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000002004), 0x1.008000002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000002040), 0x1.00800000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000002100), 0x1.0080000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000003000), 0x1.008000003p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008000), 0x1.008000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008004), 0x1.008000008004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008010), 0x1.00800000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008040), 0x1.00800000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008100), 0x1.0080000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008400), 0x1.0080000084p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000008800), 0x1.0080000088p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020000), 0x1.00800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020001), 0x1.008000020001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020002), 0x1.008000020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020004), 0x1.008000020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020020), 0x1.00800002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020100), 0x1.0080000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000020400), 0x1.0080000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000021000), 0x1.008000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000022000), 0x1.008000022p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000024000), 0x1.008000024p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000080000), 0x1.00800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000080008), 0x1.008000080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000080020), 0x1.00800008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000080200), 0x1.0080000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000080400), 0x1.0080000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000081000), 0x1.008000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000090000), 0x1.00800009p+48, 0x0p+0 },
+{ UINT64_C(0x00010080000a0000), 0x1.0080000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200000), 0x1.0080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200001), 0x1.008000200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200002), 0x1.008000200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200020), 0x1.00800020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200080), 0x1.00800020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200100), 0x1.0080002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000200800), 0x1.0080002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000208000), 0x1.008000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000240000), 0x1.00800024p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000280000), 0x1.00800028p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800000), 0x1.0080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800001), 0x1.008000800001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800004), 0x1.008000800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800020), 0x1.00800080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800080), 0x1.00800080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800200), 0x1.0080008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000800800), 0x1.0080008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000802000), 0x1.008000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000804000), 0x1.008000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000810000), 0x1.00800081p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000840000), 0x1.00800084p+48, 0x0p+0 },
+{ UINT64_C(0x0001008000c00000), 0x1.008000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001008002000000), 0x1.008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002000002), 0x1.008002000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002000004), 0x1.008002000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002000020), 0x1.00800200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002000080), 0x1.00800200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002000800), 0x1.0080020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002004000), 0x1.008002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002040000), 0x1.00800204p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002080000), 0x1.00800208p+48, 0x0p+0 },
+{ UINT64_C(0x0001008002400000), 0x1.0080024p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010000000), 0x1.00801p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010000001), 0x1.008010000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010000010), 0x1.00801000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010000040), 0x1.00801000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010000200), 0x1.0080100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010000800), 0x1.0080100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010004000), 0x1.008010004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010040000), 0x1.00801004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008010400000), 0x1.0080104p+48, 0x0p+0 },
+{ UINT64_C(0x0001008011000000), 0x1.008011p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080000000), 0x1.00808p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080000002), 0x1.008080000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080000010), 0x1.00808000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080000080), 0x1.00808000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080000200), 0x1.0080800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080000800), 0x1.0080800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080002000), 0x1.008080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080020000), 0x1.00808002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080100000), 0x1.0080801p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080400000), 0x1.0080804p+48, 0x0p+0 },
+{ UINT64_C(0x0001008080800000), 0x1.0080808p+48, 0x0p+0 },
+{ UINT64_C(0x0001008084000000), 0x1.008084p+48, 0x0p+0 },
+{ UINT64_C(0x0001008088000000), 0x1.008088p+48, 0x0p+0 },
+{ UINT64_C(0x00010080a0000000), 0x1.0080ap+48, 0x0p+0 },
+{ UINT64_C(0x0001008100000000), 0x1.0081p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100000004), 0x1.008100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100000020), 0x1.00810000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100000100), 0x1.0081000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100001000), 0x1.008100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100002000), 0x1.008100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100010000), 0x1.00810001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100080000), 0x1.00810008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100200000), 0x1.0081002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008100400000), 0x1.0081004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008102000000), 0x1.008102p+48, 0x0p+0 },
+{ UINT64_C(0x0001008120000000), 0x1.00812p+48, 0x0p+0 },
+{ UINT64_C(0x0001008140000000), 0x1.00814p+48, 0x0p+0 },
+{ UINT64_C(0x0001008180000000), 0x1.00818p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400000000), 0x1.0084p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400000002), 0x1.008400000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400000010), 0x1.00840000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400000040), 0x1.00840000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400000100), 0x1.0084000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400000800), 0x1.0084000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400004000), 0x1.008400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400008000), 0x1.008400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400020000), 0x1.00840002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008400200000), 0x1.0084002p+48, 0x0p+0 },
+{ UINT64_C(0x0001008402000000), 0x1.008402p+48, 0x0p+0 },
+{ UINT64_C(0x0001008408000000), 0x1.008408p+48, 0x0p+0 },
+{ UINT64_C(0x0001008480000000), 0x1.00848p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000000), 0x1.00ap+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000002), 0x1.00a000000002p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000010), 0x1.00a00000001p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000020), 0x1.00a00000002p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000100), 0x1.00a0000001p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000200), 0x1.00a0000002p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000000400), 0x1.00a0000004p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000004000), 0x1.00a000004p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000010000), 0x1.00a00001p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000020000), 0x1.00a00002p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000100000), 0x1.00a0001p+48, 0x0p+0 },
+{ UINT64_C(0x000100a000400000), 0x1.00a0004p+48, 0x0p+0 },
+{ UINT64_C(0x000100a001000000), 0x1.00a001p+48, 0x0p+0 },
+{ UINT64_C(0x000100a004000000), 0x1.00a004p+48, 0x0p+0 },
+{ UINT64_C(0x000100a020000000), 0x1.00a02p+48, 0x0p+0 },
+{ UINT64_C(0x000100a200000000), 0x1.00a2p+48, 0x0p+0 },
+{ UINT64_C(0x000100b000000000), 0x1.00bp+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000008), 0x1.010000000008p+48, 0x0p+0 },
+{ UINT64_C(0x000101000000000a), 0x1.01000000000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000080), 0x1.01000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000084), 0x1.010000000084p+48, 0x0p+0 },
+{ UINT64_C(0x00010100000000c0), 0x1.0100000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000100), 0x1.0100000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000104), 0x1.010000000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000140), 0x1.01000000014p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000400), 0x1.0100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000404), 0x1.010000000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000408), 0x1.010000000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000440), 0x1.01000000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000480), 0x1.01000000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000000600), 0x1.0100000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001000), 0x1.010000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001001), 0x1.010000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001008), 0x1.010000001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001010), 0x1.01000000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001020), 0x1.01000000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001040), 0x1.01000000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001080), 0x1.01000000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000001800), 0x1.0100000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000004000), 0x1.010000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000004001), 0x1.010000004001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000004002), 0x1.010000004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000004010), 0x1.01000000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000004080), 0x1.01000000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000004200), 0x1.0100000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000006000), 0x1.010000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010000), 0x1.01000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010001), 0x1.010000010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010008), 0x1.010000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010020), 0x1.01000001002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010040), 0x1.01000001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010100), 0x1.0100000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000010800), 0x1.0100000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000018000), 0x1.010000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000080000), 0x1.01000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000080001), 0x1.010000080001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000080010), 0x1.01000008001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000080080), 0x1.01000008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000080400), 0x1.0100000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000082000), 0x1.010000082p+48, 0x0p+0 },
+{ UINT64_C(0x00010100000a0000), 0x1.0100000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001010000800000), 0x1.0100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000800002), 0x1.010000800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000800010), 0x1.01000080001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000800020), 0x1.01000080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000800040), 0x1.01000080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000800100), 0x1.0100008001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000801000), 0x1.010000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000808000), 0x1.010000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000840000), 0x1.01000084p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000880000), 0x1.01000088p+48, 0x0p+0 },
+{ UINT64_C(0x0001010000a00000), 0x1.010000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001010002000000), 0x1.010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002000001), 0x1.010002000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002000008), 0x1.010002000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002000080), 0x1.01000200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002000400), 0x1.0100020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002001000), 0x1.010002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002002000), 0x1.010002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002010000), 0x1.01000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002040000), 0x1.01000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002080000), 0x1.01000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002100000), 0x1.0100021p+48, 0x0p+0 },
+{ UINT64_C(0x0001010002800000), 0x1.0100028p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010000000), 0x1.01001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010000004), 0x1.010010000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010000040), 0x1.01001000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010000100), 0x1.0100100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010001000), 0x1.010010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010004000), 0x1.010010004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010008000), 0x1.010010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010020000), 0x1.01001002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010040000), 0x1.01001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010010100000), 0x1.0100101p+48, 0x0p+0 },
+{ UINT64_C(0x0001010011000000), 0x1.010011p+48, 0x0p+0 },
+{ UINT64_C(0x0001010014000000), 0x1.010014p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040000000), 0x1.01004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040000008), 0x1.010040000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040000080), 0x1.01004000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040000800), 0x1.0100400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040002000), 0x1.010040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040008000), 0x1.010040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040080000), 0x1.01004008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010040800000), 0x1.0100408p+48, 0x0p+0 },
+{ UINT64_C(0x0001010042000000), 0x1.010042p+48, 0x0p+0 },
+{ UINT64_C(0x0001010044000000), 0x1.010044p+48, 0x0p+0 },
+{ UINT64_C(0x0001010048000000), 0x1.010048p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000000), 0x1.0101p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000001), 0x1.010100000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000004), 0x1.010100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000040), 0x1.01010000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000200), 0x1.0101000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000400), 0x1.0101000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100000800), 0x1.0101000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100001000), 0x1.010100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100010000), 0x1.01010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100020000), 0x1.01010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100100000), 0x1.0101001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100400000), 0x1.0101004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010100800000), 0x1.0101008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010102000000), 0x1.010102p+48, 0x0p+0 },
+{ UINT64_C(0x0001010120000000), 0x1.01012p+48, 0x0p+0 },
+{ UINT64_C(0x0001010180000000), 0x1.01018p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400000000), 0x1.0104p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400000004), 0x1.010400000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400000010), 0x1.01040000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400000020), 0x1.01040000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400000100), 0x1.0104000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400000200), 0x1.0104000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400001000), 0x1.010400001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400004000), 0x1.010400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400008000), 0x1.010400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400010000), 0x1.01040001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400020000), 0x1.01040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400100000), 0x1.0104001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400200000), 0x1.0104002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010400400000), 0x1.0104004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010401000000), 0x1.010401p+48, 0x0p+0 },
+{ UINT64_C(0x0001010404000000), 0x1.010404p+48, 0x0p+0 },
+{ UINT64_C(0x0001010410000000), 0x1.01041p+48, 0x0p+0 },
+{ UINT64_C(0x0001010480000000), 0x1.01048p+48, 0x0p+0 },
+{ UINT64_C(0x0001010600000000), 0x1.0106p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800000000), 0x1.0108p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800000001), 0x1.010800000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800000004), 0x1.010800000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800000020), 0x1.01080000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800000100), 0x1.0108000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800000800), 0x1.0108000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800002000), 0x1.010800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800004000), 0x1.010800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800020000), 0x1.01080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800200000), 0x1.0108002p+48, 0x0p+0 },
+{ UINT64_C(0x0001010800800000), 0x1.0108008p+48, 0x0p+0 },
+{ UINT64_C(0x0001010808000000), 0x1.010808p+48, 0x0p+0 },
+{ UINT64_C(0x0001010880000000), 0x1.01088p+48, 0x0p+0 },
+{ UINT64_C(0x0001010a00000000), 0x1.010ap+48, 0x0p+0 },
+{ UINT64_C(0x0001011000000000), 0x1.011p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000000004), 0x1.011000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000000010), 0x1.01100000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000000040), 0x1.01100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000000400), 0x1.0110000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000001000), 0x1.011000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000008000), 0x1.011000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000040000), 0x1.01100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001011000100000), 0x1.0110001p+48, 0x0p+0 },
+{ UINT64_C(0x0001011001000000), 0x1.011001p+48, 0x0p+0 },
+{ UINT64_C(0x0001011004000000), 0x1.011004p+48, 0x0p+0 },
+{ UINT64_C(0x0001011008000000), 0x1.011008p+48, 0x0p+0 },
+{ UINT64_C(0x0001011010000000), 0x1.01101p+48, 0x0p+0 },
+{ UINT64_C(0x0001011040000000), 0x1.01104p+48, 0x0p+0 },
+{ UINT64_C(0x0001011400000000), 0x1.0114p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000002), 0x1.020000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000003), 0x1.020000000003p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000008), 0x1.020000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000009), 0x1.020000000009p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000040), 0x1.02000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000044), 0x1.020000000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000048), 0x1.020000000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000060), 0x1.02000000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000080), 0x1.02000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000084), 0x1.020000000084p+48, 0x0p+0 },
+{ UINT64_C(0x00010200000000a0), 0x1.0200000000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000100), 0x1.0200000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000101), 0x1.020000000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000102), 0x1.020000000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000108), 0x1.020000000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000110), 0x1.02000000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000180), 0x1.02000000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000200), 0x1.0200000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000201), 0x1.020000000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000208), 0x1.020000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000000240), 0x1.02000000024p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000002000), 0x1.020000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000002002), 0x1.020000002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000002020), 0x1.02000000202p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000002080), 0x1.02000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000002100), 0x1.0200000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000003000), 0x1.020000003p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010000), 0x1.02000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010002), 0x1.020000010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010004), 0x1.020000010004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010010), 0x1.02000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010040), 0x1.02000001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010080), 0x1.02000001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000010400), 0x1.0200000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000011000), 0x1.020000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000100000), 0x1.0200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000100002), 0x1.020000100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000100010), 0x1.02000010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000100080), 0x1.02000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000100400), 0x1.0200001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000104000), 0x1.020000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000120000), 0x1.02000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000140000), 0x1.02000014p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200000), 0x1.0200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200001), 0x1.020000200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200004), 0x1.020000200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200020), 0x1.02000020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200100), 0x1.0200002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200200), 0x1.0200002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000200400), 0x1.0200002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000202000), 0x1.020000202p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000210000), 0x1.02000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001020000240000), 0x1.02000024p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000000), 0x1.020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000004), 0x1.020002000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000010), 0x1.02000200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000040), 0x1.02000200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000080), 0x1.02000200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000100), 0x1.0200020001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000400), 0x1.0200020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002000800), 0x1.0200020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002002000), 0x1.020002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002008000), 0x1.020002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002080000), 0x1.02000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001020002800000), 0x1.0200028p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000000), 0x1.02002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000002), 0x1.020020000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000004), 0x1.020020000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000010), 0x1.02002000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000040), 0x1.02002000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000200), 0x1.0200200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020000400), 0x1.0200200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020004000), 0x1.020020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020008000), 0x1.020020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020010000), 0x1.02002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020020000), 0x1.02002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020020200000), 0x1.0200202p+48, 0x0p+0 },
+{ UINT64_C(0x0001020021000000), 0x1.020021p+48, 0x0p+0 },
+{ UINT64_C(0x0001020024000000), 0x1.020024p+48, 0x0p+0 },
+{ UINT64_C(0x0001020030000000), 0x1.02003p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040000000), 0x1.02004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040000002), 0x1.020040000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040000020), 0x1.02004000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040000200), 0x1.0200400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040002000), 0x1.020040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040008000), 0x1.020040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040040000), 0x1.02004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040080000), 0x1.02004008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040100000), 0x1.0200401p+48, 0x0p+0 },
+{ UINT64_C(0x0001020040200000), 0x1.0200402p+48, 0x0p+0 },
+{ UINT64_C(0x0001020041000000), 0x1.020041p+48, 0x0p+0 },
+{ UINT64_C(0x0001020048000000), 0x1.020048p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200000000), 0x1.0202p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200000004), 0x1.020200000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200000020), 0x1.02020000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200000080), 0x1.02020000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200000200), 0x1.0202000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200000400), 0x1.0202000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200001000), 0x1.020200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200010000), 0x1.02020001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200100000), 0x1.0202001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200400000), 0x1.0202004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020200800000), 0x1.0202008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020204000000), 0x1.020204p+48, 0x0p+0 },
+{ UINT64_C(0x0001020240000000), 0x1.02024p+48, 0x0p+0 },
+{ UINT64_C(0x0001020300000000), 0x1.0203p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000000), 0x1.0204p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000001), 0x1.020400000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000004), 0x1.020400000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000008), 0x1.020400000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000020), 0x1.02040000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000200), 0x1.0204000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400000400), 0x1.0204000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400004000), 0x1.020400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400010000), 0x1.02040001p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400040000), 0x1.02040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001020400200000), 0x1.0204002p+48, 0x0p+0 },
+{ UINT64_C(0x0001020402000000), 0x1.020402p+48, 0x0p+0 },
+{ UINT64_C(0x0001020408000000), 0x1.020408p+48, 0x0p+0 },
+{ UINT64_C(0x0001020480000000), 0x1.02048p+48, 0x0p+0 },
+{ UINT64_C(0x0001020500000000), 0x1.0205p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000000000), 0x1.021p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000000008), 0x1.021000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000000040), 0x1.02100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000000200), 0x1.0210000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000002000), 0x1.021000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000010000), 0x1.02100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000020000), 0x1.02100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000100000), 0x1.0210001p+48, 0x0p+0 },
+{ UINT64_C(0x0001021000800000), 0x1.0210008p+48, 0x0p+0 },
+{ UINT64_C(0x0001021008000000), 0x1.021008p+48, 0x0p+0 },
+{ UINT64_C(0x0001021040000000), 0x1.02104p+48, 0x0p+0 },
+{ UINT64_C(0x0001021100000000), 0x1.0211p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000000), 0x1.022p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000002), 0x1.022000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000004), 0x1.022000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000008), 0x1.022000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000020), 0x1.02200000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000100), 0x1.0220000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000400), 0x1.0220000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000000800), 0x1.0220000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000002000), 0x1.022000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000008000), 0x1.022000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000040000), 0x1.02200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000200000), 0x1.0220002p+48, 0x0p+0 },
+{ UINT64_C(0x0001022000800000), 0x1.0220008p+48, 0x0p+0 },
+{ UINT64_C(0x0001022008000000), 0x1.022008p+48, 0x0p+0 },
+{ UINT64_C(0x0001022040000000), 0x1.02204p+48, 0x0p+0 },
+{ UINT64_C(0x0001022400000000), 0x1.0224p+48, 0x0p+0 },
+{ UINT64_C(0x0001022800000000), 0x1.0228p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000000000), 0x1.028p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000000008), 0x1.028000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000000080), 0x1.02800000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000000800), 0x1.0280000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000004000), 0x1.028000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000020000), 0x1.02800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000080000), 0x1.02800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001028000800000), 0x1.0280008p+48, 0x0p+0 },
+{ UINT64_C(0x0001028002000000), 0x1.028002p+48, 0x0p+0 },
+{ UINT64_C(0x0001028010000000), 0x1.02801p+48, 0x0p+0 },
+{ UINT64_C(0x0001028080000000), 0x1.02808p+48, 0x0p+0 },
+{ UINT64_C(0x0001028200000000), 0x1.0282p+48, 0x0p+0 },
+{ UINT64_C(0x0001028400000000), 0x1.0284p+48, 0x0p+0 },
+{ UINT64_C(0x0001029000000000), 0x1.029p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000001), 0x1.040000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000008), 0x1.040000000008p+48, 0x0p+0 },
+{ UINT64_C(0x000104000000000a), 0x1.04000000000ap+48, 0x0p+0 },
+{ UINT64_C(0x000104000000000c), 0x1.04000000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000040), 0x1.04000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000044), 0x1.040000000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000200), 0x1.0400000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000208), 0x1.040000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000280), 0x1.04000000028p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000800), 0x1.0400000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000808), 0x1.040000000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000810), 0x1.04000000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000820), 0x1.04000000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000000900), 0x1.0400000009p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000008000), 0x1.040000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000008008), 0x1.040000008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000008010), 0x1.04000000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000008100), 0x1.0400000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000008200), 0x1.0400000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000009000), 0x1.040000009p+48, 0x0p+0 },
+{ UINT64_C(0x000104000000a000), 0x1.04000000ap+48, 0x0p+0 },
+{ UINT64_C(0x000104000000c000), 0x1.04000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001040000040000), 0x1.04000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000040004), 0x1.040000040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000040008), 0x1.040000040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000040040), 0x1.04000004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000040100), 0x1.0400000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000040800), 0x1.0400000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000048000), 0x1.040000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000060000), 0x1.04000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080000), 0x1.04000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080002), 0x1.040000080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080004), 0x1.040000080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080008), 0x1.040000080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080020), 0x1.04000008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080100), 0x1.0400000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000080800), 0x1.0400000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000081000), 0x1.040000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000082000), 0x1.040000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000088000), 0x1.040000088p+48, 0x0p+0 },
+{ UINT64_C(0x00010400000c0000), 0x1.0400000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001040000400000), 0x1.0400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000400008), 0x1.040000400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000400010), 0x1.04000040001p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000400100), 0x1.0400004001p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000400400), 0x1.0400004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000402000), 0x1.040000402p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000420000), 0x1.04000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001040000600000), 0x1.0400006p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004000000), 0x1.040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004000002), 0x1.040004000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004000020), 0x1.04000400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004000080), 0x1.04000400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004000800), 0x1.0400040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004004000), 0x1.040004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004040000), 0x1.04000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004100000), 0x1.0400041p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004200000), 0x1.0400042p+48, 0x0p+0 },
+{ UINT64_C(0x0001040004800000), 0x1.0400048p+48, 0x0p+0 },
+{ UINT64_C(0x0001040006000000), 0x1.040006p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020000000), 0x1.04002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020000001), 0x1.040020000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020000008), 0x1.040020000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020000080), 0x1.04002000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020000400), 0x1.0400200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020002000), 0x1.040020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020004000), 0x1.040020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020040000), 0x1.04002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020400000), 0x1.0400204p+48, 0x0p+0 },
+{ UINT64_C(0x0001040020800000), 0x1.0400208p+48, 0x0p+0 },
+{ UINT64_C(0x0001040028000000), 0x1.040028p+48, 0x0p+0 },
+{ UINT64_C(0x0001040030000000), 0x1.04003p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040000000), 0x1.04004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040000004), 0x1.040040000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040000040), 0x1.04004000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040000200), 0x1.0400400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040000800), 0x1.0400400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040002000), 0x1.040040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040020000), 0x1.04004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040040000), 0x1.04004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040040200000), 0x1.0400402p+48, 0x0p+0 },
+{ UINT64_C(0x0001040041000000), 0x1.040041p+48, 0x0p+0 },
+{ UINT64_C(0x0001040048000000), 0x1.040048p+48, 0x0p+0 },
+{ UINT64_C(0x0001040050000000), 0x1.04005p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400000000), 0x1.0404p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400000008), 0x1.040400000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400000040), 0x1.04040000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400000080), 0x1.04040000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400000200), 0x1.0404000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400002000), 0x1.040400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400004000), 0x1.040400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400020000), 0x1.04040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400040000), 0x1.04040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040400400000), 0x1.0404004p+48, 0x0p+0 },
+{ UINT64_C(0x0001040404000000), 0x1.040404p+48, 0x0p+0 },
+{ UINT64_C(0x0001040410000000), 0x1.04041p+48, 0x0p+0 },
+{ UINT64_C(0x0001040440000000), 0x1.04044p+48, 0x0p+0 },
+{ UINT64_C(0x0001040500000000), 0x1.0405p+48, 0x0p+0 },
+{ UINT64_C(0x0001040600000000), 0x1.0406p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000000000), 0x1.041p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000000008), 0x1.041000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000000080), 0x1.04100000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000000800), 0x1.0410000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000001000), 0x1.041000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000002000), 0x1.041000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000004000), 0x1.041000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000040000), 0x1.04100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001041000400000), 0x1.0410004p+48, 0x0p+0 },
+{ UINT64_C(0x0001041001000000), 0x1.041001p+48, 0x0p+0 },
+{ UINT64_C(0x0001041002000000), 0x1.041002p+48, 0x0p+0 },
+{ UINT64_C(0x0001041004000000), 0x1.041004p+48, 0x0p+0 },
+{ UINT64_C(0x0001041010000000), 0x1.04101p+48, 0x0p+0 },
+{ UINT64_C(0x0001041080000000), 0x1.04108p+48, 0x0p+0 },
+{ UINT64_C(0x0001041100000000), 0x1.0411p+48, 0x0p+0 },
+{ UINT64_C(0x0001041200000000), 0x1.0412p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000000000), 0x1.042p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000000008), 0x1.042000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000000020), 0x1.04200000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000000200), 0x1.0420000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000000400), 0x1.0420000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000000800), 0x1.0420000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000002000), 0x1.042000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000020000), 0x1.04200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000040000), 0x1.04200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001042000200000), 0x1.0420002p+48, 0x0p+0 },
+{ UINT64_C(0x0001042001000000), 0x1.042001p+48, 0x0p+0 },
+{ UINT64_C(0x0001042008000000), 0x1.042008p+48, 0x0p+0 },
+{ UINT64_C(0x0001042080000000), 0x1.04208p+48, 0x0p+0 },
+{ UINT64_C(0x0001042100000000), 0x1.0421p+48, 0x0p+0 },
+{ UINT64_C(0x0001042800000000), 0x1.0428p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000000000), 0x1.05p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000000008), 0x1.050000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000000080), 0x1.05000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000000100), 0x1.0500000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000000800), 0x1.0500000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000001000), 0x1.050000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000002000), 0x1.050000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000008000), 0x1.050000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000010000), 0x1.05000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000100000), 0x1.0500001p+48, 0x0p+0 },
+{ UINT64_C(0x0001050000400000), 0x1.0500004p+48, 0x0p+0 },
+{ UINT64_C(0x0001050001000000), 0x1.050001p+48, 0x0p+0 },
+{ UINT64_C(0x0001050010000000), 0x1.05001p+48, 0x0p+0 },
+{ UINT64_C(0x0001050100000000), 0x1.0501p+48, 0x0p+0 },
+{ UINT64_C(0x0001051000000000), 0x1.051p+48, 0x0p+0 },
+{ UINT64_C(0x0001058000000000), 0x1.058p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000000000), 0x1.06p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000000004), 0x1.060000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000000010), 0x1.06000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000000080), 0x1.06000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000000200), 0x1.0600000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000001000), 0x1.060000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000010000), 0x1.06000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000020000), 0x1.06000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001060000200000), 0x1.0600002p+48, 0x0p+0 },
+{ UINT64_C(0x0001060001000000), 0x1.060001p+48, 0x0p+0 },
+{ UINT64_C(0x0001060004000000), 0x1.060004p+48, 0x0p+0 },
+{ UINT64_C(0x0001060008000000), 0x1.060008p+48, 0x0p+0 },
+{ UINT64_C(0x0001060020000000), 0x1.06002p+48, 0x0p+0 },
+{ UINT64_C(0x0001060100000000), 0x1.0601p+48, 0x0p+0 },
+{ UINT64_C(0x0001061000000000), 0x1.061p+48, 0x0p+0 },
+{ UINT64_C(0x0001062000000000), 0x1.062p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000001), 0x1.200000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000010), 0x1.20000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000014), 0x1.200000000014p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000080), 0x1.20000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000088), 0x1.200000000088p+48, 0x0p+0 },
+{ UINT64_C(0x00012000000000c0), 0x1.2000000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000200), 0x1.2000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000201), 0x1.200000000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000208), 0x1.200000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000280), 0x1.20000000028p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000800), 0x1.2000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000801), 0x1.200000000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000808), 0x1.200000000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000880), 0x1.20000000088p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000000a00), 0x1.200000000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001200000004000), 0x1.200000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000004002), 0x1.200000004002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000004010), 0x1.20000000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000004080), 0x1.20000000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000004400), 0x1.2000000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000020000), 0x1.20000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000020004), 0x1.200000020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000020008), 0x1.200000020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000020080), 0x1.20000002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000020100), 0x1.2000000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000020800), 0x1.2000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000021000), 0x1.200000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000022000), 0x1.200000022p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000028000), 0x1.200000028p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000080000), 0x1.20000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000080002), 0x1.200000080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000080020), 0x1.20000008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000080080), 0x1.20000008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000080800), 0x1.2000000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000084000), 0x1.200000084p+48, 0x0p+0 },
+{ UINT64_C(0x00012000000c0000), 0x1.2000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001200000200000), 0x1.2000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000200004), 0x1.200000200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000200010), 0x1.20000020001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000200080), 0x1.20000020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000200400), 0x1.2000002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000204000), 0x1.200000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000210000), 0x1.20000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000240000), 0x1.20000024p+48, 0x0p+0 },
+{ UINT64_C(0x0001200000300000), 0x1.2000003p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001000000), 0x1.200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001000001), 0x1.200001000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001000004), 0x1.200001000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001000040), 0x1.20000100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001000080), 0x1.20000100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001000800), 0x1.2000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001001000), 0x1.200001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001010000), 0x1.20000101p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001040000), 0x1.20000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001200000), 0x1.2000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001200001800000), 0x1.2000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008000000), 0x1.200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008000004), 0x1.200008000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008000040), 0x1.20000800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008000080), 0x1.20000800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008000200), 0x1.2000080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008001000), 0x1.200008001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008008000), 0x1.200008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008010000), 0x1.20000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008020000), 0x1.20000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001200008200000), 0x1.2000082p+48, 0x0p+0 },
+{ UINT64_C(0x000120000a000000), 0x1.20000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000000), 0x1.20001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000002), 0x1.200010000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000004), 0x1.200010000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000008), 0x1.200010000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000080), 0x1.20001000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000100), 0x1.2000100001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010000400), 0x1.2000100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010001000), 0x1.200010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010004000), 0x1.200010004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010040000), 0x1.20001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200010400000), 0x1.2000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001200011000000), 0x1.200011p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080000000), 0x1.20008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080000002), 0x1.200080000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080000020), 0x1.20008000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080000200), 0x1.2000800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080001000), 0x1.200080001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080010000), 0x1.20008001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080020000), 0x1.20008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080100000), 0x1.2000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001200080200000), 0x1.2000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001200082000000), 0x1.200082p+48, 0x0p+0 },
+{ UINT64_C(0x00012000a0000000), 0x1.2000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001200100000000), 0x1.2001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100000008), 0x1.200100000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100000040), 0x1.20010000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100000200), 0x1.2001000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100002000), 0x1.200100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100010000), 0x1.20010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100100000), 0x1.2001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200100800000), 0x1.2001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200104000000), 0x1.200104p+48, 0x0p+0 },
+{ UINT64_C(0x0001200120000000), 0x1.20012p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200000000), 0x1.2002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200000002), 0x1.200200000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200000008), 0x1.200200000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200000040), 0x1.20020000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200000080), 0x1.20020000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200000400), 0x1.2002000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200002000), 0x1.200200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200004000), 0x1.200200004p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200008000), 0x1.200200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200020000), 0x1.20020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200100000), 0x1.2002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001200200800000), 0x1.2002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001200201000000), 0x1.200201p+48, 0x0p+0 },
+{ UINT64_C(0x0001200202000000), 0x1.200202p+48, 0x0p+0 },
+{ UINT64_C(0x0001200204000000), 0x1.200204p+48, 0x0p+0 },
+{ UINT64_C(0x0001200240000000), 0x1.20024p+48, 0x0p+0 },
+{ UINT64_C(0x0001200300000000), 0x1.2003p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000000000), 0x1.202p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000000002), 0x1.202000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000000010), 0x1.20200000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000000080), 0x1.20200000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000000800), 0x1.2020000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000008000), 0x1.202000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000080000), 0x1.20200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001202000400000), 0x1.2020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001202001000000), 0x1.202001p+48, 0x0p+0 },
+{ UINT64_C(0x0001202010000000), 0x1.20201p+48, 0x0p+0 },
+{ UINT64_C(0x0001202040000000), 0x1.20204p+48, 0x0p+0 },
+{ UINT64_C(0x0001202200000000), 0x1.2022p+48, 0x0p+0 },
+{ UINT64_C(0x0001202400000000), 0x1.2024p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000000000), 0x1.204p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000000004), 0x1.204000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000000020), 0x1.20400000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000000200), 0x1.2040000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000001000), 0x1.204000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000002000), 0x1.204000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000004000), 0x1.204000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000010000), 0x1.20400001p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000080000), 0x1.20400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001204000800000), 0x1.2040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001204008000000), 0x1.204008p+48, 0x0p+0 },
+{ UINT64_C(0x0001204040000000), 0x1.20404p+48, 0x0p+0 },
+{ UINT64_C(0x0001204080000000), 0x1.20408p+48, 0x0p+0 },
+{ UINT64_C(0x0001204100000000), 0x1.2041p+48, 0x0p+0 },
+{ UINT64_C(0x0001205000000000), 0x1.205p+48, 0x0p+0 },
+{ UINT64_C(0x0001206000000000), 0x1.206p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000000000), 0x1.22p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000000004), 0x1.220000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000000020), 0x1.22000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000000040), 0x1.22000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000000400), 0x1.2200000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000002000), 0x1.220000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000008000), 0x1.220000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000020000), 0x1.22000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000080000), 0x1.22000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001220000100000), 0x1.2200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001220001000000), 0x1.220001p+48, 0x0p+0 },
+{ UINT64_C(0x0001220008000000), 0x1.220008p+48, 0x0p+0 },
+{ UINT64_C(0x0001220020000000), 0x1.22002p+48, 0x0p+0 },
+{ UINT64_C(0x0001220100000000), 0x1.2201p+48, 0x0p+0 },
+{ UINT64_C(0x0001220200000000), 0x1.2202p+48, 0x0p+0 },
+{ UINT64_C(0x0001222000000000), 0x1.222p+48, 0x0p+0 },
+{ UINT64_C(0x0001224000000000), 0x1.224p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000000000), 0x1.24p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000000008), 0x1.240000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000000040), 0x1.24000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000000200), 0x1.2400000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000001000), 0x1.240000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000008000), 0x1.240000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000080000), 0x1.24000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001240000200000), 0x1.2400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001240002000000), 0x1.240002p+48, 0x0p+0 },
+{ UINT64_C(0x0001240020000000), 0x1.24002p+48, 0x0p+0 },
+{ UINT64_C(0x0001240040000000), 0x1.24004p+48, 0x0p+0 },
+{ UINT64_C(0x0001240400000000), 0x1.2404p+48, 0x0p+0 },
+{ UINT64_C(0x0001244000000000), 0x1.244p+48, 0x0p+0 },
+{ UINT64_C(0x0001248000000000), 0x1.248p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000004), 0x1.400000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000008), 0x1.400000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000009), 0x1.400000000009p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000040), 0x1.40000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000048), 0x1.400000000048p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000050), 0x1.40000000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000080), 0x1.40000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000088), 0x1.400000000088p+48, 0x0p+0 },
+{ UINT64_C(0x00014000000000c0), 0x1.4000000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000800), 0x1.4000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000801), 0x1.400000000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000802), 0x1.400000000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000804), 0x1.400000000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000808), 0x1.400000000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000840), 0x1.40000000084p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000000c00), 0x1.400000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001400000002000), 0x1.400000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000002002), 0x1.400000002002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000002004), 0x1.400000002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000002010), 0x1.40000000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000002080), 0x1.40000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000002200), 0x1.4000000022p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020000), 0x1.40000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020002), 0x1.400000020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020008), 0x1.400000020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020010), 0x1.40000002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020080), 0x1.40000002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020400), 0x1.4000000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000020800), 0x1.4000000208p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000022000), 0x1.400000022p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000100000), 0x1.4000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000100004), 0x1.400000100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000100008), 0x1.400000100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000100080), 0x1.40000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000100100), 0x1.4000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000100400), 0x1.4000001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000102000), 0x1.400000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000110000), 0x1.40000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000120000), 0x1.40000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000140000), 0x1.40000014p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200000), 0x1.4000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200002), 0x1.400000200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200008), 0x1.400000200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200020), 0x1.40000020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200040), 0x1.40000020004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200080), 0x1.40000020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000200400), 0x1.4000002004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000201000), 0x1.400000201p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000202000), 0x1.400000202p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000210000), 0x1.40000021p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000240000), 0x1.40000024p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000280000), 0x1.40000028p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000400000), 0x1.4000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000400004), 0x1.400000400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000400020), 0x1.40000040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000400080), 0x1.40000040008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000400400), 0x1.4000004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000404000), 0x1.400000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000408000), 0x1.400000408p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000420000), 0x1.40000042p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000440000), 0x1.40000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001400000500000), 0x1.4000005p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001000000), 0x1.400001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001000008), 0x1.400001000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001000040), 0x1.40000100004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001000100), 0x1.4000010001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001000800), 0x1.4000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001001000), 0x1.400001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001004000), 0x1.400001004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001020000), 0x1.40000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001040000), 0x1.40000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001100000), 0x1.4000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001400001800000), 0x1.4000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008000000), 0x1.400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008000004), 0x1.400008000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008000040), 0x1.40000800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008000200), 0x1.4000080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008002000), 0x1.400008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008004000), 0x1.400008004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008020000), 0x1.40000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008100000), 0x1.4000081p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008400000), 0x1.4000084p+48, 0x0p+0 },
+{ UINT64_C(0x0001400008800000), 0x1.4000088p+48, 0x0p+0 },
+{ UINT64_C(0x0001400009000000), 0x1.400009p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000000), 0x1.40008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000001), 0x1.400080000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000008), 0x1.400080000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000020), 0x1.40008000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000040), 0x1.40008000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000200), 0x1.4000800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080000800), 0x1.4000800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080004000), 0x1.400080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080010000), 0x1.40008001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080020000), 0x1.40008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080100000), 0x1.4000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001400080400000), 0x1.4000804p+48, 0x0p+0 },
+{ UINT64_C(0x0001400081000000), 0x1.400081p+48, 0x0p+0 },
+{ UINT64_C(0x0001400084000000), 0x1.400084p+48, 0x0p+0 },
+{ UINT64_C(0x0001400090000000), 0x1.40009p+48, 0x0p+0 },
+{ UINT64_C(0x00014000a0000000), 0x1.4000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001400800000000), 0x1.4008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800000004), 0x1.400800000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800000010), 0x1.40080000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800000080), 0x1.40080000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800000100), 0x1.4008000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800000200), 0x1.4008000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800002000), 0x1.400800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800020000), 0x1.40080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800080000), 0x1.40080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400800800000), 0x1.4008008p+48, 0x0p+0 },
+{ UINT64_C(0x0001400804000000), 0x1.400804p+48, 0x0p+0 },
+{ UINT64_C(0x0001400810000000), 0x1.40081p+48, 0x0p+0 },
+{ UINT64_C(0x0001400880000000), 0x1.40088p+48, 0x0p+0 },
+{ UINT64_C(0x0001400c00000000), 0x1.400cp+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000000), 0x1.404p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000001), 0x1.404000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000002), 0x1.404000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000010), 0x1.40400000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000100), 0x1.4040000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000200), 0x1.4040000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000000800), 0x1.4040000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000001000), 0x1.404000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000010000), 0x1.40400001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000020000), 0x1.40400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000040000), 0x1.40400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001404000100000), 0x1.4040001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404001000000), 0x1.404001p+48, 0x0p+0 },
+{ UINT64_C(0x0001404002000000), 0x1.404002p+48, 0x0p+0 },
+{ UINT64_C(0x0001404004000000), 0x1.404004p+48, 0x0p+0 },
+{ UINT64_C(0x0001404040000000), 0x1.40404p+48, 0x0p+0 },
+{ UINT64_C(0x0001404080000000), 0x1.40408p+48, 0x0p+0 },
+{ UINT64_C(0x0001404400000000), 0x1.4044p+48, 0x0p+0 },
+{ UINT64_C(0x0001406000000000), 0x1.406p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000000000), 0x1.41p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000000004), 0x1.410000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000000010), 0x1.41000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000000080), 0x1.41000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000000400), 0x1.4100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000000800), 0x1.4100000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000001000), 0x1.410000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000008000), 0x1.410000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000080000), 0x1.41000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410000800000), 0x1.4100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410008000000), 0x1.410008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410080000000), 0x1.41008p+48, 0x0p+0 },
+{ UINT64_C(0x0001410200000000), 0x1.4102p+48, 0x0p+0 },
+{ UINT64_C(0x0001410400000000), 0x1.4104p+48, 0x0p+0 },
+{ UINT64_C(0x0001411000000000), 0x1.411p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000000), 0x1.48p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000002), 0x1.480000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000004), 0x1.480000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000010), 0x1.48000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000020), 0x1.48000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000080), 0x1.48000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000200), 0x1.4800000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000000400), 0x1.4800000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000004000), 0x1.480000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000020000), 0x1.48000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480000200000), 0x1.4800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480002000000), 0x1.480002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480020000000), 0x1.48002p+48, 0x0p+0 },
+{ UINT64_C(0x0001480200000000), 0x1.4802p+48, 0x0p+0 },
+{ UINT64_C(0x0001480400000000), 0x1.4804p+48, 0x0p+0 },
+{ UINT64_C(0x0001480800000000), 0x1.4808p+48, 0x0p+0 },
+{ UINT64_C(0x0001482000000000), 0x1.482p+48, 0x0p+0 },
+{ UINT64_C(0x0001488000000000), 0x1.488p+48, 0x0p+0 },
+{ UINT64_C(0x0001490000000000), 0x1.49p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000000000), 0x1.6p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000000008), 0x1.600000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000000020), 0x1.60000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000000040), 0x1.60000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000000100), 0x1.6000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000001000), 0x1.600000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000002000), 0x1.600000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000008000), 0x1.600000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000040000), 0x1.60000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001600000400000), 0x1.6000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001600001000000), 0x1.600001p+48, 0x0p+0 },
+{ UINT64_C(0x0001600002000000), 0x1.600002p+48, 0x0p+0 },
+{ UINT64_C(0x0001600008000000), 0x1.600008p+48, 0x0p+0 },
+{ UINT64_C(0x0001600020000000), 0x1.60002p+48, 0x0p+0 },
+{ UINT64_C(0x0001600040000000), 0x1.60004p+48, 0x0p+0 },
+{ UINT64_C(0x0001600200000000), 0x1.6002p+48, 0x0p+0 },
+{ UINT64_C(0x0001600800000000), 0x1.6008p+48, 0x0p+0 },
+{ UINT64_C(0x0001601000000000), 0x1.601p+48, 0x0p+0 },
+{ UINT64_C(0x0001604000000000), 0x1.604p+48, 0x0p+0 },
+{ UINT64_C(0x0001610000000000), 0x1.61p+48, 0x0p+0 },
+{ UINT64_C(0x0001680000000000), 0x1.68p+48, 0x0p+0 },
+{ UINT64_C(0x0001700000000000), 0x1.7p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000004), 0x1.800000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000010), 0x1.80000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000018), 0x1.800000000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000100), 0x1.8000000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000104), 0x1.800000000104p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000110), 0x1.80000000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000000120), 0x1.80000000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001000), 0x1.800000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001002), 0x1.800000001002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001020), 0x1.80000000102p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001080), 0x1.80000000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001100), 0x1.8000000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001200), 0x1.8000000012p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000001800), 0x1.8000000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000010000), 0x1.80000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000010008), 0x1.800000010008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000010010), 0x1.80000001001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000010080), 0x1.80000001008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000010800), 0x1.8000000108p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000011000), 0x1.800000011p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000018000), 0x1.800000018p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000080000), 0x1.80000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000080002), 0x1.800000080002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000080020), 0x1.80000008002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000080040), 0x1.80000008004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000080200), 0x1.8000000802p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000082000), 0x1.800000082p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000090000), 0x1.80000009p+48, 0x0p+0 },
+{ UINT64_C(0x00018000000a0000), 0x1.8000000ap+48, 0x0p+0 },
+{ UINT64_C(0x00018000000c0000), 0x1.8000000cp+48, 0x0p+0 },
+{ UINT64_C(0x0001800000400000), 0x1.8000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000400002), 0x1.800000400002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000400004), 0x1.800000400004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000400020), 0x1.80000040002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000400040), 0x1.80000040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000400100), 0x1.8000004001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000401000), 0x1.800000401p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000404000), 0x1.800000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000440000), 0x1.80000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001800000600000), 0x1.8000006p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004000000), 0x1.800004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004000008), 0x1.800004000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004000080), 0x1.80000400008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004000400), 0x1.8000040004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004004000), 0x1.800004004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004040000), 0x1.80000404p+48, 0x0p+0 },
+{ UINT64_C(0x0001800004400000), 0x1.8000044p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000000), 0x1.800008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000001), 0x1.800008000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000004), 0x1.800008000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000020), 0x1.80000800002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000100), 0x1.8000080001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000400), 0x1.8000080004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008000800), 0x1.8000080008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008004000), 0x1.800008004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008010000), 0x1.80000801p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008080000), 0x1.80000808p+48, 0x0p+0 },
+{ UINT64_C(0x0001800008200000), 0x1.8000082p+48, 0x0p+0 },
+{ UINT64_C(0x000180000a000000), 0x1.80000ap+48, 0x0p+0 },
+{ UINT64_C(0x0001800020000000), 0x1.80002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020000008), 0x1.800020000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020000020), 0x1.80002000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020000040), 0x1.80002000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020000080), 0x1.80002000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020000200), 0x1.8000200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020002000), 0x1.800020002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020010000), 0x1.80002001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020080000), 0x1.80002008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800020400000), 0x1.8000204p+48, 0x0p+0 },
+{ UINT64_C(0x0001800021000000), 0x1.800021p+48, 0x0p+0 },
+{ UINT64_C(0x0001800028000000), 0x1.800028p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100000000), 0x1.8001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100000004), 0x1.800100000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100000010), 0x1.80010000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100000080), 0x1.80010000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100000200), 0x1.8001000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100002000), 0x1.800100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100008000), 0x1.800100008p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100020000), 0x1.80010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800100200000), 0x1.8001002p+48, 0x0p+0 },
+{ UINT64_C(0x0001800102000000), 0x1.800102p+48, 0x0p+0 },
+{ UINT64_C(0x0001800108000000), 0x1.800108p+48, 0x0p+0 },
+{ UINT64_C(0x0001800110000000), 0x1.80011p+48, 0x0p+0 },
+{ UINT64_C(0x0001800120000000), 0x1.80012p+48, 0x0p+0 },
+{ UINT64_C(0x0001800140000000), 0x1.80014p+48, 0x0p+0 },
+{ UINT64_C(0x0001800180000000), 0x1.80018p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000000000), 0x1.801p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000000002), 0x1.801000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000000008), 0x1.801000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000000020), 0x1.80100000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000000200), 0x1.8010000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000002000), 0x1.801000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000020000), 0x1.80100002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000200000), 0x1.8010002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801000400000), 0x1.8010004p+48, 0x0p+0 },
+{ UINT64_C(0x0001801002000000), 0x1.801002p+48, 0x0p+0 },
+{ UINT64_C(0x0001801010000000), 0x1.80101p+48, 0x0p+0 },
+{ UINT64_C(0x0001801020000000), 0x1.80102p+48, 0x0p+0 },
+{ UINT64_C(0x0001801040000000), 0x1.80104p+48, 0x0p+0 },
+{ UINT64_C(0x0001801080000000), 0x1.80108p+48, 0x0p+0 },
+{ UINT64_C(0x0001801200000000), 0x1.8012p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000000000), 0x1.802p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000000008), 0x1.802000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000000080), 0x1.80200000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000000800), 0x1.8020000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000001000), 0x1.802000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000010000), 0x1.80200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000020000), 0x1.80200002p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000100000), 0x1.8020001p+48, 0x0p+0 },
+{ UINT64_C(0x0001802000800000), 0x1.8020008p+48, 0x0p+0 },
+{ UINT64_C(0x0001802008000000), 0x1.802008p+48, 0x0p+0 },
+{ UINT64_C(0x0001802010000000), 0x1.80201p+48, 0x0p+0 },
+{ UINT64_C(0x0001802100000000), 0x1.8021p+48, 0x0p+0 },
+{ UINT64_C(0x0001802200000000), 0x1.8022p+48, 0x0p+0 },
+{ UINT64_C(0x0001803000000000), 0x1.803p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000000000), 0x1.82p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000000002), 0x1.820000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000000004), 0x1.820000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000000008), 0x1.820000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000000040), 0x1.82000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000000400), 0x1.8200000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000001000), 0x1.820000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000002000), 0x1.820000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000010000), 0x1.82000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000100000), 0x1.8200001p+48, 0x0p+0 },
+{ UINT64_C(0x0001820000800000), 0x1.8200008p+48, 0x0p+0 },
+{ UINT64_C(0x0001820004000000), 0x1.820004p+48, 0x0p+0 },
+{ UINT64_C(0x0001820040000000), 0x1.82004p+48, 0x0p+0 },
+{ UINT64_C(0x0001820400000000), 0x1.8204p+48, 0x0p+0 },
+{ UINT64_C(0x0001822000000000), 0x1.822p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000000000), 0x1.ap+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000000008), 0x1.a00000000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000000020), 0x1.a0000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000000200), 0x1.a000000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000000400), 0x1.a000000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000004000), 0x1.a00000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000040000), 0x1.a0000004p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000080000), 0x1.a0000008p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000100000), 0x1.a000001p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00000200000), 0x1.a000002p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00002000000), 0x1.a00002p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00010000000), 0x1.a0001p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00100000000), 0x1.a001p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00400000000), 0x1.a004p+48, 0x0p+0 },
+{ UINT64_C(0x0001a00800000000), 0x1.a008p+48, 0x0p+0 },
+{ UINT64_C(0x0001a04000000000), 0x1.a04p+48, 0x0p+0 },
+{ UINT64_C(0x0001a10000000000), 0x1.a1p+48, 0x0p+0 },
+{ UINT64_C(0x0001a80000000000), 0x1.a8p+48, 0x0p+0 },
+{ UINT64_C(0x0002000000000022), 0x1.000000000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000024), 0x1.000000000012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000028), 0x1.000000000014p+49, 0x0p+0 },
+{ UINT64_C(0x000200000000002c), 0x1.000000000016p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000082), 0x1.000000000041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000090), 0x1.000000000048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000091), 0x1.0000000000488p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000092), 0x1.000000000049p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000094), 0x1.00000000004ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000202), 0x1.000000000101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000220), 0x1.00000000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000228), 0x1.000000000114p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000230), 0x1.000000000118p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000280), 0x1.00000000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000281), 0x1.0000000001408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000284), 0x1.000000000142p+49, 0x0p+0 },
+{ UINT64_C(0x00020000000002c0), 0x1.00000000016p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000801), 0x1.0000000004008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000802), 0x1.000000000401p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000803), 0x1.0000000004018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000804), 0x1.000000000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000810), 0x1.000000000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000814), 0x1.00000000040ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000840), 0x1.00000000042p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000842), 0x1.000000000421p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000848), 0x1.000000000424p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000860), 0x1.00000000043p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000c00), 0x1.0000000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000c08), 0x1.000000000604p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000000c40), 0x1.00000000062p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008004), 0x1.000000004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008005), 0x1.0000000040028p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008006), 0x1.000000004003p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008010), 0x1.000000004008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008012), 0x1.000000004009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008100), 0x1.00000000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008104), 0x1.000000004082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008110), 0x1.000000004088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000008180), 0x1.0000000040cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000000009000), 0x1.0000000048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000009008), 0x1.000000004804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000009040), 0x1.00000000482p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000009400), 0x1.000000004ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000000009800), 0x1.000000004cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010004), 0x1.000000008002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010010), 0x1.000000008008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010014), 0x1.00000000800ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010080), 0x1.00000000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010084), 0x1.000000008042p+49, 0x0p+0 },
+{ UINT64_C(0x00020000000100a0), 0x1.00000000805p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010200), 0x1.0000000081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010201), 0x1.0000000081008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010202), 0x1.000000008101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010208), 0x1.000000008104p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010280), 0x1.00000000814p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010300), 0x1.00000000818p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010400), 0x1.0000000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010401), 0x1.0000000082008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010408), 0x1.000000008204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010420), 0x1.00000000821p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010480), 0x1.00000000824p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010800), 0x1.0000000084p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010801), 0x1.0000000084008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010802), 0x1.000000008401p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010808), 0x1.000000008404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010810), 0x1.000000008408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010880), 0x1.00000000844p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000010c00), 0x1.0000000086p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018000), 0x1.00000000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018001), 0x1.00000000c0008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018008), 0x1.00000000c004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018010), 0x1.00000000c008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018100), 0x1.00000000c08p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018400), 0x1.00000000c2p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000018800), 0x1.00000000c4p+49, 0x0p+0 },
+{ UINT64_C(0x000200000001c000), 0x1.00000000ep+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020004), 0x1.000000010002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020005), 0x1.0000000100028p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020006), 0x1.000000010003p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020020), 0x1.00000001001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020021), 0x1.0000000100108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020028), 0x1.000000010014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020040), 0x1.00000001002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020041), 0x1.0000000100208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020048), 0x1.000000010024p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020060), 0x1.00000001003p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020200), 0x1.0000000101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020202), 0x1.000000010101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020208), 0x1.000000010104p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020210), 0x1.000000010108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020300), 0x1.00000001018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020400), 0x1.0000000102p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020404), 0x1.000000010202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020440), 0x1.00000001022p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000020600), 0x1.0000000103p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000024000), 0x1.000000012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000024008), 0x1.000000012004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000024020), 0x1.00000001201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000024200), 0x1.0000000121p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000025000), 0x1.0000000128p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000028000), 0x1.000000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000028002), 0x1.000000014001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000028010), 0x1.000000014008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000028080), 0x1.00000001404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000028200), 0x1.0000000141p+49, 0x0p+0 },
+{ UINT64_C(0x000200000002a000), 0x1.000000015p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200008), 0x1.000000100004p+49, 0x0p+0 },
+{ UINT64_C(0x000200000020000c), 0x1.000000100006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200080), 0x1.00000010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200088), 0x1.000000100044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200090), 0x1.000000100048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200400), 0x1.0000001002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200404), 0x1.000000100202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200410), 0x1.000000100208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200500), 0x1.00000010028p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000200600), 0x1.0000001003p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000201000), 0x1.0000001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000201002), 0x1.000000100801p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000201020), 0x1.00000010081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000201040), 0x1.00000010082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000201100), 0x1.00000010088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000204000), 0x1.000000102p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000204001), 0x1.0000001020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000204008), 0x1.000000102004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000204040), 0x1.00000010202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000204200), 0x1.0000001021p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000204400), 0x1.0000001022p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000206000), 0x1.000000103p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000240000), 0x1.00000012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000240002), 0x1.000000120001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000240020), 0x1.00000012001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000240040), 0x1.00000012002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000240080), 0x1.00000012004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000240800), 0x1.0000001204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000248000), 0x1.000000124p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000250000), 0x1.000000128p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000260000), 0x1.00000013p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000300000), 0x1.00000018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000300001), 0x1.0000001800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000300002), 0x1.000000180001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000300010), 0x1.000000180008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000300100), 0x1.00000018008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000300800), 0x1.0000001804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000308000), 0x1.000000184p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000320000), 0x1.00000019p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800008), 0x1.000000400004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800010), 0x1.000000400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800012), 0x1.000000400009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800014), 0x1.00000040000ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800020), 0x1.00000040001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800022), 0x1.000000400011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800024), 0x1.000000400012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800080), 0x1.00000040004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800082), 0x1.000000400041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800088), 0x1.000000400044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800200), 0x1.0000004001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800202), 0x1.000000400101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800204), 0x1.000000400102p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800220), 0x1.00000040011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000800300), 0x1.00000040018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000801000), 0x1.0000004008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000801001), 0x1.0000004008008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000801004), 0x1.000000400802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000801020), 0x1.00000040081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000801200), 0x1.0000004009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804000), 0x1.000000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804002), 0x1.000000402001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804004), 0x1.000000402002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804008), 0x1.000000402004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804020), 0x1.00000040201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804080), 0x1.00000040204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804100), 0x1.00000040208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000804400), 0x1.0000004022p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810000), 0x1.000000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810002), 0x1.000000408001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810008), 0x1.000000408004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810010), 0x1.000000408008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810040), 0x1.00000040802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810100), 0x1.00000040808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810400), 0x1.0000004082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000810800), 0x1.0000004084p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000812000), 0x1.000000409p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000814000), 0x1.00000040ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000000880000), 0x1.00000044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000880001), 0x1.0000004400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000880008), 0x1.000000440004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000880010), 0x1.000000440008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000880080), 0x1.00000044004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000880400), 0x1.0000004402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000884000), 0x1.000000442p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000888000), 0x1.000000444p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a00000), 0x1.0000005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a00008), 0x1.000000500004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a00040), 0x1.00000050002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a00400), 0x1.0000005002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a00800), 0x1.0000005004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a04000), 0x1.000000502p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000a20000), 0x1.00000051p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000b00000), 0x1.00000058p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c00000), 0x1.0000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c00001), 0x1.0000006000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c00010), 0x1.000000600008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c00020), 0x1.00000060001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c00100), 0x1.00000060008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c01000), 0x1.0000006008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c02000), 0x1.000000601p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000c20000), 0x1.00000061p+49, 0x0p+0 },
+{ UINT64_C(0x0002000000e00000), 0x1.0000007p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000002), 0x1.000000800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000008), 0x1.000000800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000009), 0x1.0000008000048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000020), 0x1.00000080001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000028), 0x1.000000800014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000100), 0x1.00000080008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000102), 0x1.000000800081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001000110), 0x1.000000800088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001001000), 0x1.0000008008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001001004), 0x1.000000800802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001001010), 0x1.000000800808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001001040), 0x1.00000080082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001001400), 0x1.000000800ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000001008000), 0x1.000000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001008001), 0x1.0000008040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001008004), 0x1.000000804002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001008010), 0x1.000000804008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001008100), 0x1.00000080408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001008800), 0x1.0000008044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001010000), 0x1.000000808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001010008), 0x1.000000808004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001010010), 0x1.000000808008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001010020), 0x1.00000080801p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001010100), 0x1.00000080808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001010800), 0x1.0000008084p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001012000), 0x1.000000809p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001040000), 0x1.00000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001040001), 0x1.0000008200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001040010), 0x1.000000820008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001040100), 0x1.00000082008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001040800), 0x1.0000008204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001048000), 0x1.000000824p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100000), 0x1.00000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100008), 0x1.000000880004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100010), 0x1.000000880008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100020), 0x1.00000088001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100040), 0x1.00000088002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100080), 0x1.00000088004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001100800), 0x1.0000008804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001104000), 0x1.000000882p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001108000), 0x1.000000884p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001120000), 0x1.00000089p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001180000), 0x1.0000008cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800000), 0x1.000000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800001), 0x1.000000c000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800004), 0x1.000000c00002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800008), 0x1.000000c00004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800020), 0x1.000000c0001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800080), 0x1.000000c0004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800400), 0x1.000000c002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001800800), 0x1.000000c004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001804000), 0x1.000000c02p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001820000), 0x1.000000c1p+49, 0x0p+0 },
+{ UINT64_C(0x0002000001a00000), 0x1.000000dp+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000002), 0x1.000001000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000008), 0x1.000001000004p+49, 0x0p+0 },
+{ UINT64_C(0x000200000200000a), 0x1.000001000005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000010), 0x1.000001000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000014), 0x1.00000100000ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000018), 0x1.00000100000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000020), 0x1.00000100001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000022), 0x1.000001000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000028), 0x1.000001000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000080), 0x1.00000100004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000082), 0x1.000001000041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000084), 0x1.000001000042p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000088), 0x1.000001000044p+49, 0x0p+0 },
+{ UINT64_C(0x00020000020000a0), 0x1.00000100005p+49, 0x0p+0 },
+{ UINT64_C(0x00020000020000c0), 0x1.00000100006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000100), 0x1.00000100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000101), 0x1.0000010000808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000110), 0x1.000001000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002000180), 0x1.0000010000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000002001000), 0x1.0000010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002001004), 0x1.000001000802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002001040), 0x1.00000100082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002001100), 0x1.00000100088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002001800), 0x1.000001000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010000), 0x1.000001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010001), 0x1.0000010080008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010002), 0x1.000001008001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010004), 0x1.000001008002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010020), 0x1.00000100801p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010040), 0x1.00000100802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010200), 0x1.0000010081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002010400), 0x1.0000010082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002012000), 0x1.000001009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002014000), 0x1.00000100ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000002018000), 0x1.00000100cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100000), 0x1.00000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100004), 0x1.000001080002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100010), 0x1.000001080008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100040), 0x1.00000108002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100080), 0x1.00000108004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100100), 0x1.00000108008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002100800), 0x1.0000010804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002101000), 0x1.0000010808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002102000), 0x1.000001081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002104000), 0x1.000001082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002140000), 0x1.0000010ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000002400000), 0x1.0000012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002400004), 0x1.000001200002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002400010), 0x1.000001200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002400040), 0x1.00000120002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002400080), 0x1.00000120004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002400800), 0x1.0000012004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002402000), 0x1.000001201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002404000), 0x1.000001202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000002440000), 0x1.00000122p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003000000), 0x1.0000018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003000008), 0x1.000001800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003000020), 0x1.00000180001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003000100), 0x1.00000180008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003001000), 0x1.0000018008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003004000), 0x1.000001802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003020000), 0x1.00000181p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003200000), 0x1.0000019p+49, 0x0p+0 },
+{ UINT64_C(0x0002000003400000), 0x1.000001ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000004), 0x1.000004000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000006), 0x1.000004000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000008), 0x1.000004000004p+49, 0x0p+0 },
+{ UINT64_C(0x000200000800000c), 0x1.000004000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000020), 0x1.00000400001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000022), 0x1.000004000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000028), 0x1.000004000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000200), 0x1.0000040001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000201), 0x1.0000040001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000210), 0x1.000004000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008000280), 0x1.00000400014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008002000), 0x1.000004001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008002002), 0x1.000004001001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008002020), 0x1.00000400101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008002200), 0x1.0000040011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008003000), 0x1.0000040018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008020000), 0x1.00000401p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008020008), 0x1.000004010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008020080), 0x1.00000401004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008020400), 0x1.0000040102p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008022000), 0x1.000004011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008028000), 0x1.000004014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008030000), 0x1.000004018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008040000), 0x1.00000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008040004), 0x1.000004020002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008040040), 0x1.00000402002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008040100), 0x1.00000402008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008040200), 0x1.0000040201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008040400), 0x1.0000040202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008044000), 0x1.000004022p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008060000), 0x1.00000403p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008400000), 0x1.0000042p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008400002), 0x1.000004200001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008400010), 0x1.000004200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008400020), 0x1.00000420001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008400100), 0x1.00000420008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008400800), 0x1.0000042004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008404000), 0x1.000004202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008440000), 0x1.00000422p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008500000), 0x1.00000428p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008600000), 0x1.0000043p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800000), 0x1.0000044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800001), 0x1.0000044000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800008), 0x1.000004400004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800010), 0x1.000004400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800040), 0x1.00000440002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800100), 0x1.00000440008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800200), 0x1.0000044001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800400), 0x1.0000044002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008800800), 0x1.0000044004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008802000), 0x1.000004401p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008810000), 0x1.000004408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000008900000), 0x1.00000448p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009000000), 0x1.0000048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009000008), 0x1.000004800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009000010), 0x1.000004800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009000100), 0x1.00000480008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009001000), 0x1.0000048008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009008000), 0x1.000004804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009080000), 0x1.00000484p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009200000), 0x1.0000049p+49, 0x0p+0 },
+{ UINT64_C(0x0002000009400000), 0x1.000004ap+49, 0x0p+0 },
+{ UINT64_C(0x000200000a000000), 0x1.000005p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a000004), 0x1.000005000002p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a000040), 0x1.00000500002p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a000400), 0x1.0000050002p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a002000), 0x1.000005001p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a010000), 0x1.000005008p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a040000), 0x1.00000502p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a080000), 0x1.00000504p+49, 0x0p+0 },
+{ UINT64_C(0x000200000a800000), 0x1.0000054p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000002), 0x1.000008000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000003), 0x1.0000080000018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000020), 0x1.00000800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000021), 0x1.0000080000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000028), 0x1.000008000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000100), 0x1.00000800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000102), 0x1.000008000081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000110), 0x1.000008000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000180), 0x1.0000080000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000200), 0x1.0000080001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000204), 0x1.000008000102p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000240), 0x1.00000800012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000280), 0x1.00000800014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000300), 0x1.00000800018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000800), 0x1.0000080004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000804), 0x1.000008000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000810), 0x1.000008000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000900), 0x1.00000800048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010000a00), 0x1.0000080005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010008000), 0x1.000008004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010008008), 0x1.000008004004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010008040), 0x1.00000800402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010008100), 0x1.00000800408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010008200), 0x1.0000080041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010009000), 0x1.0000080048p+49, 0x0p+0 },
+{ UINT64_C(0x000200001000a000), 0x1.000008005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010080000), 0x1.00000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010080001), 0x1.0000080400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010080010), 0x1.000008040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010080100), 0x1.00000804008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010081000), 0x1.0000080408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010084000), 0x1.000008042p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010090000), 0x1.000008048p+49, 0x0p+0 },
+{ UINT64_C(0x00020000100c0000), 0x1.00000806p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010200000), 0x1.0000081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010200004), 0x1.000008100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010200020), 0x1.00000810001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010200200), 0x1.0000081001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010202000), 0x1.000008101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010208000), 0x1.000008104p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010220000), 0x1.00000811p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010800000), 0x1.0000084p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010800004), 0x1.000008400002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010800040), 0x1.00000840002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010800080), 0x1.00000840004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010800100), 0x1.00000840008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010800400), 0x1.0000084002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010804000), 0x1.000008402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010808000), 0x1.000008404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010820000), 0x1.00000841p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010880000), 0x1.00000844p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010a00000), 0x1.0000085p+49, 0x0p+0 },
+{ UINT64_C(0x0002000010c00000), 0x1.0000086p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000000), 0x1.0000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000001), 0x1.0000088000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000002), 0x1.000008800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000010), 0x1.000008800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000020), 0x1.00000880001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000080), 0x1.00000880004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011000200), 0x1.0000088001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011002000), 0x1.000008801p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011008000), 0x1.000008804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011040000), 0x1.00000882p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011200000), 0x1.0000089p+49, 0x0p+0 },
+{ UINT64_C(0x0002000011400000), 0x1.000008ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000012000000), 0x1.000009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012000001), 0x1.0000090000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012000008), 0x1.000009000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012000020), 0x1.00000900001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012000200), 0x1.0000090001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012001000), 0x1.0000090008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012002000), 0x1.000009001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012008000), 0x1.000009004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012020000), 0x1.00000901p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012100000), 0x1.00000908p+49, 0x0p+0 },
+{ UINT64_C(0x0002000012200000), 0x1.0000091p+49, 0x0p+0 },
+{ UINT64_C(0x0002000013000000), 0x1.0000098p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014000000), 0x1.00000ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000014000002), 0x1.00000a000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014000010), 0x1.00000a000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014000040), 0x1.00000a00002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014000080), 0x1.00000a00004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014000400), 0x1.00000a0002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014004000), 0x1.00000a002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014040000), 0x1.00000a02p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014080000), 0x1.00000a04p+49, 0x0p+0 },
+{ UINT64_C(0x0002000014200000), 0x1.00000a1p+49, 0x0p+0 },
+{ UINT64_C(0x0002000016000000), 0x1.00000bp+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000001), 0x1.0000100000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000010), 0x1.000010000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000011), 0x1.0000100000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000080), 0x1.00001000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000082), 0x1.000010000041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000090), 0x1.000010000048p+49, 0x0p+0 },
+{ UINT64_C(0x00020000200000c0), 0x1.00001000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000400), 0x1.0000100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000401), 0x1.0000100002008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000404), 0x1.000010000202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000410), 0x1.000010000208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020000480), 0x1.00001000024p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020001000), 0x1.0000100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020001002), 0x1.000010000801p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020001020), 0x1.00001000081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020001100), 0x1.00001000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020001800), 0x1.000010000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000020008000), 0x1.000010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020008004), 0x1.000010004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020008020), 0x1.00001000401p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020008040), 0x1.00001000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020008200), 0x1.0000100041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020008800), 0x1.0000100044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010000), 0x1.000010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010002), 0x1.000010008001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010008), 0x1.000010008004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010010), 0x1.000010008008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010020), 0x1.00001000801p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010200), 0x1.0000100081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020010400), 0x1.0000100082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020012000), 0x1.000010009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020040000), 0x1.00001002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020040001), 0x1.0000100200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020040004), 0x1.000010020002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020040008), 0x1.000010020004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020040080), 0x1.00001002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020040400), 0x1.0000100202p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020041000), 0x1.0000100208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020044000), 0x1.000010022p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020048000), 0x1.000010024p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020100000), 0x1.00001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020100002), 0x1.000010080001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020100008), 0x1.000010080004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020100080), 0x1.00001008004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020100800), 0x1.0000100804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020102000), 0x1.000010081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020120000), 0x1.00001009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020180000), 0x1.0000100cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000020800000), 0x1.0000104p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020800001), 0x1.0000104000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020800002), 0x1.000010400001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020800020), 0x1.00001040001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020800100), 0x1.00001040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020800400), 0x1.0000104002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020801000), 0x1.0000104008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020808000), 0x1.000010404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020810000), 0x1.000010408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000020900000), 0x1.00001048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000000), 0x1.0000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000002), 0x1.000010800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000008), 0x1.000010800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000020), 0x1.00001080001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000040), 0x1.00001080002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000080), 0x1.00001080004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021000400), 0x1.0000108002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021001000), 0x1.0000108008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021010000), 0x1.000010808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021100000), 0x1.00001088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000021400000), 0x1.000010ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000022000000), 0x1.000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022000004), 0x1.000011000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022000020), 0x1.00001100001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022000040), 0x1.00001100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022000200), 0x1.0000110001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022002000), 0x1.000011001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022008000), 0x1.000011004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022020000), 0x1.00001101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022080000), 0x1.00001104p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022400000), 0x1.0000112p+49, 0x0p+0 },
+{ UINT64_C(0x0002000022800000), 0x1.0000114p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024000000), 0x1.000012p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024000004), 0x1.000012000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024000020), 0x1.00001200001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024000100), 0x1.00001200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024000400), 0x1.0000120002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024000800), 0x1.0000120004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024004000), 0x1.000012002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024008000), 0x1.000012004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024010000), 0x1.000012008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024020000), 0x1.00001201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024080000), 0x1.00001204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000024100000), 0x1.00001208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000025000000), 0x1.0000128p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000008), 0x1.000020000004p+49, 0x0p+0 },
+{ UINT64_C(0x000200004000000a), 0x1.000020000005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000020), 0x1.00002000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000021), 0x1.0000200000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000030), 0x1.000020000018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000080), 0x1.00002000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000088), 0x1.000020000044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000090), 0x1.000020000048p+49, 0x0p+0 },
+{ UINT64_C(0x00020000400000c0), 0x1.00002000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000800), 0x1.0000200004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000801), 0x1.0000200004008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000810), 0x1.000020000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040000880), 0x1.00002000044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040002000), 0x1.000020001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040002004), 0x1.000020001002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040002020), 0x1.00002000101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040002200), 0x1.0000200011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040003000), 0x1.0000200018p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010000), 0x1.000020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010001), 0x1.0000200080008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010002), 0x1.000020008001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010004), 0x1.000020008002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010040), 0x1.00002000802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010100), 0x1.00002000808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010200), 0x1.0000200081p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040010800), 0x1.0000200084p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040012000), 0x1.000020009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040018000), 0x1.00002000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000040040000), 0x1.00002002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040040008), 0x1.000020020004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040040010), 0x1.000020020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040040040), 0x1.00002002002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040040080), 0x1.00002002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040040800), 0x1.0000200204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040041000), 0x1.0000200208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040048000), 0x1.000020024p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040080000), 0x1.00002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040080001), 0x1.0000200400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040080010), 0x1.000020040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040080040), 0x1.00002004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040080400), 0x1.0000200402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040084000), 0x1.000020042p+49, 0x0p+0 },
+{ UINT64_C(0x00020000400a0000), 0x1.00002005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800000), 0x1.0000204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800002), 0x1.000020400001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800004), 0x1.000020400002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800008), 0x1.000020400004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800020), 0x1.00002040001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800040), 0x1.00002040002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800080), 0x1.00002040004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040800800), 0x1.0000204004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040801000), 0x1.0000204008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040808000), 0x1.000020404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040810000), 0x1.000020408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000040900000), 0x1.00002048p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041000000), 0x1.0000208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041000002), 0x1.000020800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041000008), 0x1.000020800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041000010), 0x1.000020800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041000020), 0x1.00002080001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041000100), 0x1.00002080008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041001000), 0x1.0000208008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041004000), 0x1.000020802p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041010000), 0x1.000020808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041080000), 0x1.00002084p+49, 0x0p+0 },
+{ UINT64_C(0x0002000041400000), 0x1.000020ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000050000000), 0x1.000028p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050000001), 0x1.0000280000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050000010), 0x1.000028000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050000080), 0x1.00002800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050000400), 0x1.0000280002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050000800), 0x1.0000280004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050008000), 0x1.000028004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050080000), 0x1.00002804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050100000), 0x1.00002808p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050200000), 0x1.0000281p+49, 0x0p+0 },
+{ UINT64_C(0x0002000050800000), 0x1.0000284p+49, 0x0p+0 },
+{ UINT64_C(0x0002000058000000), 0x1.00002cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000004), 0x1.000200000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000010), 0x1.000200000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000011), 0x1.0002000000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000018), 0x1.00020000000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000020), 0x1.00020000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000021), 0x1.0002000000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000028), 0x1.000200000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000100), 0x1.00020000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000104), 0x1.000200000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400000140), 0x1.0002000000ap+49, 0x0p+0 },
+{ UINT64_C(0x0002000400001000), 0x1.0002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400001008), 0x1.000200000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400001040), 0x1.00020000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400001200), 0x1.0002000009p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400001800), 0x1.000200000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002000400008000), 0x1.000200004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400008001), 0x1.0002000040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400008008), 0x1.000200004004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400008040), 0x1.00020000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400008400), 0x1.0002000042p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400009000), 0x1.0002000048p+49, 0x0p+0 },
+{ UINT64_C(0x000200040000a000), 0x1.000200005p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080000), 0x1.00020004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080001), 0x1.0002000400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080002), 0x1.000200040001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080008), 0x1.000200040004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080020), 0x1.00020004001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080040), 0x1.00020004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080400), 0x1.0002000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400080800), 0x1.0002000404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400081000), 0x1.0002000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400090000), 0x1.000200048p+49, 0x0p+0 },
+{ UINT64_C(0x00020004000c0000), 0x1.00020006p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400800000), 0x1.0002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400800002), 0x1.000200400001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400800008), 0x1.000200400004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400800010), 0x1.000200400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400800080), 0x1.00020040004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400800800), 0x1.0002004004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400808000), 0x1.000200404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400820000), 0x1.00020041p+49, 0x0p+0 },
+{ UINT64_C(0x0002000400880000), 0x1.00020044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000000), 0x1.000201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000002), 0x1.000201000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000008), 0x1.000201000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000020), 0x1.00020100001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000200), 0x1.0002010001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000400), 0x1.0002010002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402000800), 0x1.0002010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402002000), 0x1.000201001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402020000), 0x1.00020101p+49, 0x0p+0 },
+{ UINT64_C(0x0002000402200000), 0x1.0002011p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408000000), 0x1.000204p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408000008), 0x1.000204000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408000040), 0x1.00020400002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408000400), 0x1.0002040002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408000800), 0x1.0002040004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408004000), 0x1.000204002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408008000), 0x1.000204004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408080000), 0x1.00020404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000408800000), 0x1.0002044p+49, 0x0p+0 },
+{ UINT64_C(0x0002000409000000), 0x1.0002048p+49, 0x0p+0 },
+{ UINT64_C(0x000200040a000000), 0x1.000205p+49, 0x0p+0 },
+{ UINT64_C(0x000200040c000000), 0x1.000206p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440000000), 0x1.00022p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440000004), 0x1.000220000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440000008), 0x1.000220000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440000080), 0x1.00022000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440000200), 0x1.0002200001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440000800), 0x1.0002200004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440004000), 0x1.000220002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440010000), 0x1.000220008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440020000), 0x1.00022001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000440200000), 0x1.0002201p+49, 0x0p+0 },
+{ UINT64_C(0x0002000441000000), 0x1.0002208p+49, 0x0p+0 },
+{ UINT64_C(0x0002000444000000), 0x1.000222p+49, 0x0p+0 },
+{ UINT64_C(0x0002000448000000), 0x1.000224p+49, 0x0p+0 },
+{ UINT64_C(0x0002000460000000), 0x1.00023p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000000), 0x1.00024p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000002), 0x1.000240000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000008), 0x1.000240000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000010), 0x1.000240000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000100), 0x1.00024000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000200), 0x1.0002400001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480000800), 0x1.0002400004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480001000), 0x1.0002400008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480008000), 0x1.000240004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480080000), 0x1.00024004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480100000), 0x1.00024008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000480800000), 0x1.0002404p+49, 0x0p+0 },
+{ UINT64_C(0x0002000481000000), 0x1.0002408p+49, 0x0p+0 },
+{ UINT64_C(0x0002000484000000), 0x1.000242p+49, 0x0p+0 },
+{ UINT64_C(0x0002000488000000), 0x1.000244p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600000000), 0x1.0003p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600000002), 0x1.000300000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600000008), 0x1.000300000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600000010), 0x1.000300000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600000100), 0x1.00030000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600000400), 0x1.0003000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600002000), 0x1.000300001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600008000), 0x1.000300004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600020000), 0x1.00030001p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600080000), 0x1.00030004p+49, 0x0p+0 },
+{ UINT64_C(0x0002000600400000), 0x1.0003002p+49, 0x0p+0 },
+{ UINT64_C(0x0002000601000000), 0x1.0003008p+49, 0x0p+0 },
+{ UINT64_C(0x0002000602000000), 0x1.000301p+49, 0x0p+0 },
+{ UINT64_C(0x0002000608000000), 0x1.000304p+49, 0x0p+0 },
+{ UINT64_C(0x0002000640000000), 0x1.00032p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000001), 0x1.0010000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000010), 0x1.001000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000011), 0x1.0010000000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000014), 0x1.00100000000ap+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000018), 0x1.00100000000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000020), 0x1.00100000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000021), 0x1.0010000000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000028), 0x1.001000000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000030), 0x1.001000000018p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000100), 0x1.00100000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000104), 0x1.001000000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000110), 0x1.001000000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000180), 0x1.0010000000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000200), 0x1.0010000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000202), 0x1.001000000101p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000204), 0x1.001000000102p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000000220), 0x1.00100000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000002000), 0x1.001000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000002001), 0x1.0010000010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000002004), 0x1.001000001002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000002040), 0x1.00100000102p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000002100), 0x1.00100000108p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000003000), 0x1.0010000018p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008000), 0x1.001000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008002), 0x1.001000004001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008004), 0x1.001000004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008010), 0x1.001000004008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008080), 0x1.00100000404p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008200), 0x1.0010000041p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000008800), 0x1.0010000044p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000009000), 0x1.0010000048p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000080000), 0x1.00100004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000080004), 0x1.001000040002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000080010), 0x1.001000040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000080100), 0x1.00100004008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000080400), 0x1.0010000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000080800), 0x1.0010000404p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000081000), 0x1.0010000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000082000), 0x1.001000041p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000090000), 0x1.001000048p+49, 0x0p+0 },
+{ UINT64_C(0x00020020000a0000), 0x1.00100005p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400000), 0x1.0010002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400001), 0x1.0010002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400002), 0x1.001000200001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400008), 0x1.001000200004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400010), 0x1.001000200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400080), 0x1.00100020004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000400200), 0x1.0010002001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000402000), 0x1.001000201p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000404000), 0x1.001000202p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000410000), 0x1.001000208p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000440000), 0x1.00100022p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000500000), 0x1.00100028p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000800000), 0x1.0010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000800004), 0x1.001000400002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000800020), 0x1.00100040001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000800040), 0x1.00100040002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000800100), 0x1.00100040008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000800800), 0x1.0010004004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000804000), 0x1.001000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000820000), 0x1.00100041p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000900000), 0x1.00100048p+49, 0x0p+0 },
+{ UINT64_C(0x0002002000c00000), 0x1.0010006p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002000000), 0x1.001001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002000004), 0x1.001001000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002000010), 0x1.001001000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002000100), 0x1.00100100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002001000), 0x1.0010010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002008000), 0x1.001001004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002020000), 0x1.00100101p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002100000), 0x1.00100108p+49, 0x0p+0 },
+{ UINT64_C(0x0002002002200000), 0x1.0010011p+49, 0x0p+0 },
+{ UINT64_C(0x0002002003000000), 0x1.0010018p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020000000), 0x1.00101p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020000008), 0x1.001010000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020000080), 0x1.00101000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020000100), 0x1.00101000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020000200), 0x1.0010100001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020001000), 0x1.0010100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020008000), 0x1.001010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020020000), 0x1.00101001p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020040000), 0x1.00101002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020100000), 0x1.00101008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002020400000), 0x1.0010102p+49, 0x0p+0 },
+{ UINT64_C(0x0002002024000000), 0x1.001012p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100000000), 0x1.00108p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100000008), 0x1.001080000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100000040), 0x1.00108000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100000080), 0x1.00108000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100000800), 0x1.0010800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100001000), 0x1.0010800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100008000), 0x1.001080004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100040000), 0x1.00108002p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100080000), 0x1.00108004p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100200000), 0x1.0010801p+49, 0x0p+0 },
+{ UINT64_C(0x0002002100800000), 0x1.0010804p+49, 0x0p+0 },
+{ UINT64_C(0x0002002101000000), 0x1.0010808p+49, 0x0p+0 },
+{ UINT64_C(0x0002002104000000), 0x1.001082p+49, 0x0p+0 },
+{ UINT64_C(0x0002002108000000), 0x1.001084p+49, 0x0p+0 },
+{ UINT64_C(0x0002002180000000), 0x1.0010cp+49, 0x0p+0 },
+{ UINT64_C(0x0002003000000000), 0x1.0018p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000000004), 0x1.001800000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000000020), 0x1.00180000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000000040), 0x1.00180000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000000100), 0x1.00180000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000000800), 0x1.0018000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000008000), 0x1.001800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000040000), 0x1.00180002p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000080000), 0x1.00180004p+49, 0x0p+0 },
+{ UINT64_C(0x0002003000200000), 0x1.0018001p+49, 0x0p+0 },
+{ UINT64_C(0x0002003002000000), 0x1.001801p+49, 0x0p+0 },
+{ UINT64_C(0x0002003010000000), 0x1.001808p+49, 0x0p+0 },
+{ UINT64_C(0x0002003080000000), 0x1.00184p+49, 0x0p+0 },
+{ UINT64_C(0x0002003100000000), 0x1.00188p+49, 0x0p+0 },
+{ UINT64_C(0x0002003800000000), 0x1.001cp+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000008), 0x1.010000000004p+49, 0x0p+0 },
+{ UINT64_C(0x000202000000000c), 0x1.010000000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000040), 0x1.01000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000048), 0x1.010000000024p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000050), 0x1.010000000028p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000400), 0x1.0100000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000404), 0x1.010000000202p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000420), 0x1.01000000021p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000000600), 0x1.0100000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000002000), 0x1.010000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000002004), 0x1.010000001002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000002040), 0x1.01000000102p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000002200), 0x1.0100000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000008000), 0x1.010000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000008004), 0x1.010000004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000008008), 0x1.010000004004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000008040), 0x1.01000000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000008200), 0x1.0100000041p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000008400), 0x1.0100000042p+49, 0x0p+0 },
+{ UINT64_C(0x000202000000c000), 0x1.010000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040000), 0x1.01000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040001), 0x1.0100000200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040002), 0x1.010000020001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040004), 0x1.010000020002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040010), 0x1.010000020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040080), 0x1.01000002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000040800), 0x1.0100000204p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000044000), 0x1.010000022p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000048000), 0x1.010000024p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000060000), 0x1.01000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000080000), 0x1.01000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000080008), 0x1.010000040004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000080040), 0x1.01000004002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000080200), 0x1.0100000401p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000080400), 0x1.0100000402p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000081000), 0x1.0100000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000084000), 0x1.010000042p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000088000), 0x1.010000044p+49, 0x0p+0 },
+{ UINT64_C(0x00020200000c0000), 0x1.01000006p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000100000), 0x1.01000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000100001), 0x1.0100000800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000100008), 0x1.010000080004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000100080), 0x1.01000008004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000100100), 0x1.01000008008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000100400), 0x1.0100000802p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000104000), 0x1.010000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000110000), 0x1.010000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000200000), 0x1.0100001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000200008), 0x1.010000100004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000200080), 0x1.01000010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000200800), 0x1.0100001004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000201000), 0x1.0100001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000202000), 0x1.010000101p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000220000), 0x1.01000011p+49, 0x0p+0 },
+{ UINT64_C(0x0002020000280000), 0x1.01000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001000000), 0x1.0100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001000002), 0x1.010000800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001000010), 0x1.010000800008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001000040), 0x1.01000080002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001000400), 0x1.0100008002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001000800), 0x1.0100008004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001001000), 0x1.0100008008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001008000), 0x1.010000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001010000), 0x1.010000808p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001040000), 0x1.01000082p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001100000), 0x1.01000088p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001200000), 0x1.0100009p+49, 0x0p+0 },
+{ UINT64_C(0x0002020001800000), 0x1.010000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002020004000000), 0x1.010002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004000004), 0x1.010002000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004000010), 0x1.010002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004000020), 0x1.01000200001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004000200), 0x1.0100020001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004001000), 0x1.0100020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004008000), 0x1.010002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004010000), 0x1.010002008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004100000), 0x1.01000208p+49, 0x0p+0 },
+{ UINT64_C(0x0002020004800000), 0x1.0100024p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010000000), 0x1.010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010000002), 0x1.010008000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010000004), 0x1.010008000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010000040), 0x1.01000800002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010000400), 0x1.0100080002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010004000), 0x1.010008002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010040000), 0x1.01000802p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010080000), 0x1.01000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002020010800000), 0x1.0100084p+49, 0x0p+0 },
+{ UINT64_C(0x0002020018000000), 0x1.01000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002020020000000), 0x1.01001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020000002), 0x1.010010000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020000004), 0x1.010010000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020000010), 0x1.010010000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020000040), 0x1.01001000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020000100), 0x1.01001000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020001000), 0x1.0100100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020008000), 0x1.010010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020010000), 0x1.010010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020020100000), 0x1.01001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020021000000), 0x1.0100108p+49, 0x0p+0 },
+{ UINT64_C(0x0002020030000000), 0x1.010018p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200000000), 0x1.0101p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200000008), 0x1.010100000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200000040), 0x1.01010000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200000100), 0x1.01010000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200001000), 0x1.0101000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200002000), 0x1.010100001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200004000), 0x1.010100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200020000), 0x1.01010001p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200080000), 0x1.01010004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020200800000), 0x1.0101004p+49, 0x0p+0 },
+{ UINT64_C(0x0002020204000000), 0x1.010102p+49, 0x0p+0 },
+{ UINT64_C(0x0002020210000000), 0x1.010108p+49, 0x0p+0 },
+{ UINT64_C(0x0002020220000000), 0x1.01011p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000000), 0x1.0108p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000001), 0x1.0108000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000002), 0x1.010800000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000004), 0x1.010800000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000010), 0x1.010800000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000080), 0x1.01080000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000000800), 0x1.0108000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000002000), 0x1.010800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000008000), 0x1.010800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000080000), 0x1.01080004p+49, 0x0p+0 },
+{ UINT64_C(0x0002021000400000), 0x1.0108002p+49, 0x0p+0 },
+{ UINT64_C(0x0002021004000000), 0x1.010802p+49, 0x0p+0 },
+{ UINT64_C(0x0002021008000000), 0x1.010804p+49, 0x0p+0 },
+{ UINT64_C(0x0002021010000000), 0x1.010808p+49, 0x0p+0 },
+{ UINT64_C(0x0002021040000000), 0x1.01082p+49, 0x0p+0 },
+{ UINT64_C(0x0002021100000000), 0x1.01088p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000000000), 0x1.011p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000000001), 0x1.0110000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000000004), 0x1.011000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000000020), 0x1.01100000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000000200), 0x1.0110000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000000800), 0x1.0110000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000008000), 0x1.011000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000010000), 0x1.011000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000040000), 0x1.01100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002022000200000), 0x1.0110001p+49, 0x0p+0 },
+{ UINT64_C(0x0002022002000000), 0x1.011001p+49, 0x0p+0 },
+{ UINT64_C(0x0002022008000000), 0x1.011004p+49, 0x0p+0 },
+{ UINT64_C(0x0002022010000000), 0x1.011008p+49, 0x0p+0 },
+{ UINT64_C(0x0002022040000000), 0x1.01102p+49, 0x0p+0 },
+{ UINT64_C(0x0002022080000000), 0x1.01104p+49, 0x0p+0 },
+{ UINT64_C(0x0002022400000000), 0x1.0112p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000000000), 0x1.018p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000000002), 0x1.018000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000000010), 0x1.018000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000000040), 0x1.01800000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000000400), 0x1.0180000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000000800), 0x1.0180000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000002000), 0x1.018000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000004000), 0x1.018000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000040000), 0x1.01800002p+49, 0x0p+0 },
+{ UINT64_C(0x0002030000400000), 0x1.0180002p+49, 0x0p+0 },
+{ UINT64_C(0x0002030001000000), 0x1.0180008p+49, 0x0p+0 },
+{ UINT64_C(0x0002030002000000), 0x1.018001p+49, 0x0p+0 },
+{ UINT64_C(0x0002030004000000), 0x1.018002p+49, 0x0p+0 },
+{ UINT64_C(0x0002030010000000), 0x1.018008p+49, 0x0p+0 },
+{ UINT64_C(0x0002030040000000), 0x1.01802p+49, 0x0p+0 },
+{ UINT64_C(0x0002030400000000), 0x1.0182p+49, 0x0p+0 },
+{ UINT64_C(0x0002034000000000), 0x1.01ap+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000004), 0x1.080000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000006), 0x1.080000000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000040), 0x1.08000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000042), 0x1.080000000021p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000044), 0x1.080000000022p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000400), 0x1.0800000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000401), 0x1.0800000002008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000408), 0x1.080000000204p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000420), 0x1.08000000021p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000600), 0x1.0800000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000800), 0x1.0800000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000808), 0x1.080000000404p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000810), 0x1.080000000408p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000000900), 0x1.08000000048p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000004000), 0x1.080000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000004004), 0x1.080000002002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000004020), 0x1.08000000201p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000004100), 0x1.08000000208p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000004400), 0x1.0800000022p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000006000), 0x1.080000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000010000), 0x1.080000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000010008), 0x1.080000008004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000010080), 0x1.08000000804p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000010200), 0x1.0800000081p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000010800), 0x1.0800000084p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000018000), 0x1.08000000cp+49, 0x0p+0 },
+{ UINT64_C(0x0002100000040000), 0x1.08000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000040004), 0x1.080000020002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000040010), 0x1.080000020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000040100), 0x1.08000002008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000040400), 0x1.0800000202p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000040800), 0x1.0800000204p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000042000), 0x1.080000021p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000048000), 0x1.080000024p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000060000), 0x1.08000003p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000200000), 0x1.0800001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000200004), 0x1.080000100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000200010), 0x1.080000100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000200100), 0x1.08000010008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000200200), 0x1.0800001001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000201000), 0x1.0800001008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000208000), 0x1.080000104p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000280000), 0x1.08000014p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000400000), 0x1.0800002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000400004), 0x1.080000200002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000400008), 0x1.080000200004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000400010), 0x1.080000200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000400080), 0x1.08000020004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000400800), 0x1.0800002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000402000), 0x1.080000201p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000408000), 0x1.080000204p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000420000), 0x1.08000021p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000480000), 0x1.08000024p+49, 0x0p+0 },
+{ UINT64_C(0x0002100000600000), 0x1.0800003p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004000000), 0x1.080002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004000001), 0x1.0800020000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004000010), 0x1.080002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004000040), 0x1.08000200002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004000100), 0x1.08000200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004000200), 0x1.0800020001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004001000), 0x1.0800020008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004008000), 0x1.080002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004040000), 0x1.08000202p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004400000), 0x1.0800022p+49, 0x0p+0 },
+{ UINT64_C(0x0002100004800000), 0x1.0800024p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040000000), 0x1.08002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040000008), 0x1.080020000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040000020), 0x1.08002000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040000080), 0x1.08002000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040000400), 0x1.0800200002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040004000), 0x1.080020002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040008000), 0x1.080020004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040020000), 0x1.08002001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040080000), 0x1.08002004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100040800000), 0x1.0800204p+49, 0x0p+0 },
+{ UINT64_C(0x0002100044000000), 0x1.080022p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100000000), 0x1.08008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100000001), 0x1.0800800000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100000004), 0x1.080080000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100000008), 0x1.080080000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100000080), 0x1.08008000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100000800), 0x1.0800800004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100004000), 0x1.080080002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100020000), 0x1.08008001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100040000), 0x1.08008002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100100400000), 0x1.0800802p+49, 0x0p+0 },
+{ UINT64_C(0x0002100101000000), 0x1.0800808p+49, 0x0p+0 },
+{ UINT64_C(0x0002100110000000), 0x1.080088p+49, 0x0p+0 },
+{ UINT64_C(0x0002100120000000), 0x1.08009p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000000), 0x1.0802p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000001), 0x1.0802000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000008), 0x1.080200000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000010), 0x1.080200000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000040), 0x1.08020000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000200), 0x1.0802000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400000800), 0x1.0802000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400008000), 0x1.080200004p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400040000), 0x1.08020002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100400400000), 0x1.0802002p+49, 0x0p+0 },
+{ UINT64_C(0x0002100404000000), 0x1.080202p+49, 0x0p+0 },
+{ UINT64_C(0x0002100420000000), 0x1.08021p+49, 0x0p+0 },
+{ UINT64_C(0x0002100600000000), 0x1.0803p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000000000), 0x1.081p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000000004), 0x1.081000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000000020), 0x1.08100000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000000200), 0x1.0810000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000001000), 0x1.0810000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000004000), 0x1.081000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000040000), 0x1.08100002p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000100000), 0x1.08100008p+49, 0x0p+0 },
+{ UINT64_C(0x0002102000800000), 0x1.0810004p+49, 0x0p+0 },
+{ UINT64_C(0x0002102002000000), 0x1.081001p+49, 0x0p+0 },
+{ UINT64_C(0x0002102008000000), 0x1.081004p+49, 0x0p+0 },
+{ UINT64_C(0x0002102010000000), 0x1.081008p+49, 0x0p+0 },
+{ UINT64_C(0x0002102020000000), 0x1.08101p+49, 0x0p+0 },
+{ UINT64_C(0x0002102200000000), 0x1.0811p+49, 0x0p+0 },
+{ UINT64_C(0x0002102800000000), 0x1.0814p+49, 0x0p+0 },
+{ UINT64_C(0x0002103000000000), 0x1.0818p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000000000), 0x1.082p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000000008), 0x1.082000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000000010), 0x1.082000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000000080), 0x1.08200000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000000100), 0x1.08200000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000000200), 0x1.0820000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000002000), 0x1.082000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000008000), 0x1.082000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000040000), 0x1.08200002p+49, 0x0p+0 },
+{ UINT64_C(0x0002104000100000), 0x1.08200008p+49, 0x0p+0 },
+{ UINT64_C(0x0002104001000000), 0x1.0820008p+49, 0x0p+0 },
+{ UINT64_C(0x0002104004000000), 0x1.082002p+49, 0x0p+0 },
+{ UINT64_C(0x0002104008000000), 0x1.082004p+49, 0x0p+0 },
+{ UINT64_C(0x0002104010000000), 0x1.082008p+49, 0x0p+0 },
+{ UINT64_C(0x0002104040000000), 0x1.08202p+49, 0x0p+0 },
+{ UINT64_C(0x0002104400000000), 0x1.0822p+49, 0x0p+0 },
+{ UINT64_C(0x0002104800000000), 0x1.0824p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000000), 0x1.09p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000002), 0x1.090000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000004), 0x1.090000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000010), 0x1.090000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000020), 0x1.09000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000100), 0x1.09000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000000400), 0x1.0900000002p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000002000), 0x1.090000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000020000), 0x1.09000001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000080000), 0x1.09000004p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000200000), 0x1.0900001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120000800000), 0x1.0900004p+49, 0x0p+0 },
+{ UINT64_C(0x0002120002000000), 0x1.090001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120008000000), 0x1.090004p+49, 0x0p+0 },
+{ UINT64_C(0x0002120020000000), 0x1.09001p+49, 0x0p+0 },
+{ UINT64_C(0x0002120100000000), 0x1.09008p+49, 0x0p+0 },
+{ UINT64_C(0x0002121000000000), 0x1.0908p+49, 0x0p+0 },
+{ UINT64_C(0x0002130000000000), 0x1.098p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000002), 0x1.800000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000003), 0x1.8000000000018p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000008), 0x1.800000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000009), 0x1.8000000000048p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000020), 0x1.80000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000024), 0x1.800000000012p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000200), 0x1.8000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000202), 0x1.800000000101p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000208), 0x1.800000000104p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000220), 0x1.80000000011p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000800), 0x1.8000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000808), 0x1.800000000404p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000840), 0x1.80000000042p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000880), 0x1.80000000044p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000000c00), 0x1.8000000006p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000001000), 0x1.8000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000001002), 0x1.800000000801p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000001010), 0x1.800000000808p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000001080), 0x1.80000000084p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000001400), 0x1.800000000ap+49, 0x0p+0 },
+{ UINT64_C(0x0003000000008000), 0x1.800000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000008002), 0x1.800000004001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000008008), 0x1.800000004004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000008040), 0x1.80000000402p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000008400), 0x1.8000000042p+49, 0x0p+0 },
+{ UINT64_C(0x000300000000c000), 0x1.800000006p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000040000), 0x1.80000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000040002), 0x1.800000020001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000040010), 0x1.800000020008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000040040), 0x1.80000002002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000040400), 0x1.8000000202p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000044000), 0x1.800000022p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000060000), 0x1.80000003p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000080000), 0x1.80000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000080001), 0x1.8000000400008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000080002), 0x1.800000040001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000080010), 0x1.800000040008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000080080), 0x1.80000004004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000080200), 0x1.8000000401p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000081000), 0x1.8000000408p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000082000), 0x1.800000041p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000090000), 0x1.800000048p+49, 0x0p+0 },
+{ UINT64_C(0x00030000000c0000), 0x1.80000006p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000400000), 0x1.8000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000400001), 0x1.8000002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000400008), 0x1.800000200004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000400020), 0x1.80000020001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000400100), 0x1.80000020008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000400400), 0x1.8000002002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000402000), 0x1.800000201p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000408000), 0x1.800000204p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000420000), 0x1.80000021p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000440000), 0x1.80000022p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000800000), 0x1.8000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000800008), 0x1.800000400004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000800020), 0x1.80000040001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000800040), 0x1.80000040002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000800100), 0x1.80000040008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000800200), 0x1.8000004001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000802000), 0x1.800000401p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000804000), 0x1.800000402p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000808000), 0x1.800000404p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000810000), 0x1.800000408p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000880000), 0x1.80000044p+49, 0x0p+0 },
+{ UINT64_C(0x0003000000c00000), 0x1.8000006p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004000000), 0x1.800002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004000002), 0x1.800002000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004000004), 0x1.800002000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004000010), 0x1.800002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004000100), 0x1.80000200008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004001000), 0x1.8000020008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004004000), 0x1.800002002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004010000), 0x1.800002008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004020000), 0x1.80000201p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004080000), 0x1.80000204p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004400000), 0x1.8000022p+49, 0x0p+0 },
+{ UINT64_C(0x0003000004800000), 0x1.8000024p+49, 0x0p+0 },
+{ UINT64_C(0x0003000006000000), 0x1.800003p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040000000), 0x1.80002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040000004), 0x1.800020000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040000040), 0x1.80002000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040000200), 0x1.8000200001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040001000), 0x1.8000200008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040002000), 0x1.800020001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040008000), 0x1.800020004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040080000), 0x1.80002004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000040200000), 0x1.8000201p+49, 0x0p+0 },
+{ UINT64_C(0x0003000042000000), 0x1.800021p+49, 0x0p+0 },
+{ UINT64_C(0x0003000060000000), 0x1.80003p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200000000), 0x1.8001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200000008), 0x1.800100000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200000080), 0x1.80010000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200000400), 0x1.8001000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200002000), 0x1.800100001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200004000), 0x1.800100002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200020000), 0x1.80010001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200100000), 0x1.80010008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000200400000), 0x1.8001002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000204000000), 0x1.800102p+49, 0x0p+0 },
+{ UINT64_C(0x0003000210000000), 0x1.800108p+49, 0x0p+0 },
+{ UINT64_C(0x0003000280000000), 0x1.80014p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400000000), 0x1.8002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400000004), 0x1.800200000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400000008), 0x1.800200000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400000010), 0x1.800200000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400000080), 0x1.80020000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400000400), 0x1.8002000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400001000), 0x1.8002000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400010000), 0x1.800200008p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400020000), 0x1.80020001p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400040000), 0x1.80020002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400080000), 0x1.80020004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400400000), 0x1.8002002p+49, 0x0p+0 },
+{ UINT64_C(0x0003000400800000), 0x1.8002004p+49, 0x0p+0 },
+{ UINT64_C(0x0003000404000000), 0x1.800202p+49, 0x0p+0 },
+{ UINT64_C(0x0003000408000000), 0x1.800204p+49, 0x0p+0 },
+{ UINT64_C(0x0003000440000000), 0x1.80022p+49, 0x0p+0 },
+{ UINT64_C(0x0003000600000000), 0x1.8003p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000000000), 0x1.802p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000000001), 0x1.8020000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000000002), 0x1.802000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000000010), 0x1.802000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000000020), 0x1.80200000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000000200), 0x1.8020000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000001000), 0x1.8020000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000002000), 0x1.802000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000008000), 0x1.802000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000020000), 0x1.80200001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000200000), 0x1.8020001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004000800000), 0x1.8020004p+49, 0x0p+0 },
+{ UINT64_C(0x0003004001000000), 0x1.8020008p+49, 0x0p+0 },
+{ UINT64_C(0x0003004002000000), 0x1.802001p+49, 0x0p+0 },
+{ UINT64_C(0x0003004020000000), 0x1.80201p+49, 0x0p+0 },
+{ UINT64_C(0x0003004040000000), 0x1.80202p+49, 0x0p+0 },
+{ UINT64_C(0x0003004100000000), 0x1.80208p+49, 0x0p+0 },
+{ UINT64_C(0x0003005000000000), 0x1.8028p+49, 0x0p+0 },
+{ UINT64_C(0x0003006000000000), 0x1.803p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000000000), 0x1.804p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000000008), 0x1.804000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000000020), 0x1.80400000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000000100), 0x1.80400000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000000200), 0x1.8040000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000000400), 0x1.8040000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000001000), 0x1.8040000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000010000), 0x1.804000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000100000), 0x1.80400008p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000200000), 0x1.8040001p+49, 0x0p+0 },
+{ UINT64_C(0x0003008000800000), 0x1.8040004p+49, 0x0p+0 },
+{ UINT64_C(0x0003008002000000), 0x1.804001p+49, 0x0p+0 },
+{ UINT64_C(0x0003008008000000), 0x1.804004p+49, 0x0p+0 },
+{ UINT64_C(0x0003008020000000), 0x1.80401p+49, 0x0p+0 },
+{ UINT64_C(0x0003008080000000), 0x1.80404p+49, 0x0p+0 },
+{ UINT64_C(0x0003008100000000), 0x1.80408p+49, 0x0p+0 },
+{ UINT64_C(0x0003008200000000), 0x1.8041p+49, 0x0p+0 },
+{ UINT64_C(0x0003008400000000), 0x1.8042p+49, 0x0p+0 },
+{ UINT64_C(0x000300a000000000), 0x1.805p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000000000), 0x1.808p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000000001), 0x1.8080000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000000010), 0x1.808000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000000080), 0x1.80800000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000000800), 0x1.8080000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000004000), 0x1.808000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000040000), 0x1.80800002p+49, 0x0p+0 },
+{ UINT64_C(0x0003010000400000), 0x1.8080002p+49, 0x0p+0 },
+{ UINT64_C(0x0003010004000000), 0x1.808002p+49, 0x0p+0 },
+{ UINT64_C(0x0003010040000000), 0x1.80802p+49, 0x0p+0 },
+{ UINT64_C(0x0003010200000000), 0x1.8081p+49, 0x0p+0 },
+{ UINT64_C(0x0003010800000000), 0x1.8084p+49, 0x0p+0 },
+{ UINT64_C(0x0003011000000000), 0x1.8088p+49, 0x0p+0 },
+{ UINT64_C(0x0003014000000000), 0x1.80ap+49, 0x0p+0 },
+{ UINT64_C(0x0003040000000000), 0x1.82p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000000004), 0x1.820000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000000010), 0x1.820000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000000020), 0x1.82000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000000100), 0x1.82000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000001000), 0x1.8200000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000010000), 0x1.820000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000080000), 0x1.82000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003040000800000), 0x1.8200004p+49, 0x0p+0 },
+{ UINT64_C(0x0003040004000000), 0x1.820002p+49, 0x0p+0 },
+{ UINT64_C(0x0003040010000000), 0x1.820008p+49, 0x0p+0 },
+{ UINT64_C(0x0003040040000000), 0x1.82002p+49, 0x0p+0 },
+{ UINT64_C(0x0003040400000000), 0x1.8202p+49, 0x0p+0 },
+{ UINT64_C(0x0003040800000000), 0x1.8204p+49, 0x0p+0 },
+{ UINT64_C(0x0003048000000000), 0x1.824p+49, 0x0p+0 },
+{ UINT64_C(0x0003050000000000), 0x1.828p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000000000), 0x1.84p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000000004), 0x1.840000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000000040), 0x1.84000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000000100), 0x1.84000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000000800), 0x1.8400000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000008000), 0x1.840000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000020000), 0x1.84000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000080000), 0x1.84000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000400000), 0x1.8400002p+49, 0x0p+0 },
+{ UINT64_C(0x0003080000800000), 0x1.8400004p+49, 0x0p+0 },
+{ UINT64_C(0x0003080008000000), 0x1.840004p+49, 0x0p+0 },
+{ UINT64_C(0x0003080010000000), 0x1.840008p+49, 0x0p+0 },
+{ UINT64_C(0x0003080100000000), 0x1.84008p+49, 0x0p+0 },
+{ UINT64_C(0x0003080200000000), 0x1.8401p+49, 0x0p+0 },
+{ UINT64_C(0x0003082000000000), 0x1.841p+49, 0x0p+0 },
+{ UINT64_C(0x0003090000000000), 0x1.848p+49, 0x0p+0 },
+{ UINT64_C(0x00030a0000000000), 0x1.85p+49, 0x0p+0 },
+{ UINT64_C(0x00030c0000000000), 0x1.86p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000000000), 0x1.9p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000000002), 0x1.900000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000000010), 0x1.900000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000000040), 0x1.90000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000000100), 0x1.90000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000001000), 0x1.9000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000008000), 0x1.900000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000010000), 0x1.900000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000100000), 0x1.90000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003200000800000), 0x1.9000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003200001000000), 0x1.9000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003200008000000), 0x1.900004p+49, 0x0p+0 },
+{ UINT64_C(0x0003200040000000), 0x1.90002p+49, 0x0p+0 },
+{ UINT64_C(0x0003200400000000), 0x1.9002p+49, 0x0p+0 },
+{ UINT64_C(0x0003204000000000), 0x1.902p+49, 0x0p+0 },
+{ UINT64_C(0x0003210000000000), 0x1.908p+49, 0x0p+0 },
+{ UINT64_C(0x0003220000000000), 0x1.91p+49, 0x0p+0 },
+{ UINT64_C(0x0003300000000000), 0x1.98p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000000000), 0x1.ap+49, 0x0p+0 },
+{ UINT64_C(0x0003400000000002), 0x1.a00000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000000008), 0x1.a00000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000000040), 0x1.a0000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000000400), 0x1.a000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000004000), 0x1.a00000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000020000), 0x1.a0000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000040000), 0x1.a0000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000100000), 0x1.a0000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003400000800000), 0x1.a000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003400001000000), 0x1.a000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003400008000000), 0x1.a00004p+49, 0x0p+0 },
+{ UINT64_C(0x0003400010000000), 0x1.a00008p+49, 0x0p+0 },
+{ UINT64_C(0x0003400040000000), 0x1.a0002p+49, 0x0p+0 },
+{ UINT64_C(0x0003400400000000), 0x1.a002p+49, 0x0p+0 },
+{ UINT64_C(0x0003404000000000), 0x1.a02p+49, 0x0p+0 },
+{ UINT64_C(0x0003408000000000), 0x1.a04p+49, 0x0p+0 },
+{ UINT64_C(0x0003410000000000), 0x1.a08p+49, 0x0p+0 },
+{ UINT64_C(0x0003440000000000), 0x1.a2p+49, 0x0p+0 },
+{ UINT64_C(0x0003600000000000), 0x1.bp+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000000), 0x1.cp+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000002), 0x1.c00000000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000004), 0x1.c00000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000010), 0x1.c00000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000080), 0x1.c0000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000400), 0x1.c000000002p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000000800), 0x1.c000000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000001000), 0x1.c000000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000002000), 0x1.c00000001p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000010000), 0x1.c00000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000080000), 0x1.c0000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000100000), 0x1.c0000008p+49, 0x0p+0 },
+{ UINT64_C(0x0003800000800000), 0x1.c000004p+49, 0x0p+0 },
+{ UINT64_C(0x0003800004000000), 0x1.c00002p+49, 0x0p+0 },
+{ UINT64_C(0x0003800008000000), 0x1.c00004p+49, 0x0p+0 },
+{ UINT64_C(0x0003800010000000), 0x1.c00008p+49, 0x0p+0 },
+{ UINT64_C(0x0003800020000000), 0x1.c0001p+49, 0x0p+0 },
+{ UINT64_C(0x0003800040000000), 0x1.c0002p+49, 0x0p+0 },
+{ UINT64_C(0x0003800400000000), 0x1.c002p+49, 0x0p+0 },
+{ UINT64_C(0x0003800800000000), 0x1.c004p+49, 0x0p+0 },
+{ UINT64_C(0x0003802000000000), 0x1.c01p+49, 0x0p+0 },
+{ UINT64_C(0x0003820000000000), 0x1.c1p+49, 0x0p+0 },
+{ UINT64_C(0x0003900000000000), 0x1.c8p+49, 0x0p+0 },
+{ UINT64_C(0x000400000000000c), 0x1.000000000003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000028), 0x1.00000000000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000044), 0x1.000000000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000046), 0x1.0000000000118p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000050), 0x1.000000000014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000058), 0x1.000000000016p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000408), 0x1.000000000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000410), 0x1.000000000104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000414), 0x1.000000000105p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000440), 0x1.00000000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000000448), 0x1.000000000112p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001001), 0x1.0000000004004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001010), 0x1.000000000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001011), 0x1.0000000004044p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001012), 0x1.0000000004048p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001018), 0x1.000000000406p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001040), 0x1.00000000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001044), 0x1.000000000411p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001080), 0x1.00000000042p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001082), 0x1.0000000004208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001090), 0x1.000000000424p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001200), 0x1.00000000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001202), 0x1.0000000004808p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001208), 0x1.000000000482p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001220), 0x1.000000000488p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001280), 0x1.0000000004ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001300), 0x1.0000000004cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001400), 0x1.0000000005p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001404), 0x1.000000000501p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001440), 0x1.00000000051p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000001480), 0x1.00000000052p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010004), 0x1.000000004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010040), 0x1.00000000401p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010042), 0x1.0000000040108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010048), 0x1.000000004012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010050), 0x1.000000004014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010100), 0x1.00000000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010104), 0x1.000000004041p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010110), 0x1.000000004044p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000010180), 0x1.00000000406p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000011000), 0x1.0000000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000011001), 0x1.0000000044004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000011002), 0x1.0000000044008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000011004), 0x1.000000004401p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000011040), 0x1.00000000441p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000011100), 0x1.00000000444p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000018000), 0x1.000000006p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000018008), 0x1.000000006002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000018020), 0x1.000000006008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000018080), 0x1.00000000602p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000018400), 0x1.0000000061p+50, 0x0p+0 },
+{ UINT64_C(0x000400000001a000), 0x1.0000000068p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040008), 0x1.000000010002p+50, 0x0p+0 },
+{ UINT64_C(0x000400000004000a), 0x1.0000000100028p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040010), 0x1.000000010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040018), 0x1.000000010006p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040040), 0x1.00000001001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040042), 0x1.0000000100108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040044), 0x1.000000010011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040048), 0x1.000000010012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040050), 0x1.000000010014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040100), 0x1.00000001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040108), 0x1.000000010042p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040180), 0x1.00000001006p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040800), 0x1.0000000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040802), 0x1.0000000102008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040808), 0x1.000000010202p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040820), 0x1.000000010208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040900), 0x1.00000001024p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000040c00), 0x1.0000000103p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000044000), 0x1.000000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000044001), 0x1.0000000110004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000044004), 0x1.000000011001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000044008), 0x1.000000011002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000044040), 0x1.00000001101p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000044100), 0x1.00000001104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000045000), 0x1.0000000114p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000048000), 0x1.000000012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000048002), 0x1.0000000120008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000048008), 0x1.000000012002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000048080), 0x1.00000001202p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000048200), 0x1.00000001208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000049000), 0x1.0000000124p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060000), 0x1.000000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060001), 0x1.0000000180004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060004), 0x1.000000018001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060008), 0x1.000000018002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060040), 0x1.00000001801p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060400), 0x1.0000000181p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000060800), 0x1.0000000182p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000064000), 0x1.000000019p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000070000), 0x1.00000001cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080002), 0x1.0000000200008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080004), 0x1.000000020001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080010), 0x1.000000020004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080012), 0x1.0000000200048p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080040), 0x1.00000002001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080041), 0x1.0000000200104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080042), 0x1.0000000200108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080050), 0x1.000000020014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080200), 0x1.00000002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080201), 0x1.0000000200804p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080208), 0x1.000000020082p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080280), 0x1.0000000200ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080400), 0x1.0000000201p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080401), 0x1.0000000201004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080404), 0x1.000000020101p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080440), 0x1.00000002011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000080600), 0x1.00000002018p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000082000), 0x1.0000000208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000082004), 0x1.000000020801p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000082010), 0x1.000000020804p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000082040), 0x1.00000002081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000082400), 0x1.0000000209p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000088000), 0x1.000000022p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000088002), 0x1.0000000220008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000088010), 0x1.000000022004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000088080), 0x1.00000002202p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000088400), 0x1.0000000221p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000089000), 0x1.0000000224p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090000), 0x1.000000024p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090001), 0x1.0000000240004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090004), 0x1.000000024001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090008), 0x1.000000024002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090040), 0x1.00000002401p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090200), 0x1.00000002408p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000090400), 0x1.0000000241p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000092000), 0x1.0000000248p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000098000), 0x1.000000026p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c0000), 0x1.00000003p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c0004), 0x1.000000030001p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c0020), 0x1.000000030008p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c0040), 0x1.00000003001p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c0400), 0x1.0000000301p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c4000), 0x1.000000031p+50, 0x0p+0 },
+{ UINT64_C(0x00040000000c8000), 0x1.000000032p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400001), 0x1.0000001000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400008), 0x1.000000100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400010), 0x1.000000100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400014), 0x1.000000100005p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400040), 0x1.00000010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400044), 0x1.000000100011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400048), 0x1.000000100012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400060), 0x1.000000100018p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400080), 0x1.00000010002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400082), 0x1.0000001000208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400084), 0x1.000000100021p+50, 0x0p+0 },
+{ UINT64_C(0x00040000004000c0), 0x1.00000010003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400800), 0x1.0000001002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400802), 0x1.0000001002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400820), 0x1.000000100208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400840), 0x1.00000010021p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000400c00), 0x1.0000001003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000402000), 0x1.0000001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000402002), 0x1.0000001008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000402004), 0x1.000000100801p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000402040), 0x1.00000010081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000402080), 0x1.00000010082p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000402800), 0x1.000000100ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000000420000), 0x1.000000108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000420008), 0x1.000000108002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000420080), 0x1.00000010802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000420100), 0x1.00000010804p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000420200), 0x1.00000010808p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000420800), 0x1.0000001082p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000428000), 0x1.00000010ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000000600000), 0x1.00000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000600002), 0x1.0000001800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000600020), 0x1.000000180008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000600100), 0x1.00000018004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000600200), 0x1.00000018008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000600800), 0x1.0000001802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000602000), 0x1.0000001808p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000608000), 0x1.000000182p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000620000), 0x1.000000188p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000700000), 0x1.0000001cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800008), 0x1.000000200002p+50, 0x0p+0 },
+{ UINT64_C(0x000400000080000c), 0x1.000000200003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800040), 0x1.00000020001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800048), 0x1.000000200012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800060), 0x1.000000200018p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800080), 0x1.00000020002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800081), 0x1.0000002000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800088), 0x1.000000200022p+50, 0x0p+0 },
+{ UINT64_C(0x00040000008000a0), 0x1.000000200028p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800800), 0x1.0000002002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800804), 0x1.000000200201p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800820), 0x1.000000200208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800900), 0x1.00000020024p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800a00), 0x1.00000020028p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000800c00), 0x1.0000002003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000808000), 0x1.000000202p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000808008), 0x1.000000202002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000808040), 0x1.00000020201p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000808100), 0x1.00000020204p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000808200), 0x1.00000020208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000809000), 0x1.0000002024p+50, 0x0p+0 },
+{ UINT64_C(0x000400000080c000), 0x1.000000203p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820000), 0x1.000000208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820002), 0x1.0000002080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820008), 0x1.000000208002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820010), 0x1.000000208004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820080), 0x1.00000020802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820200), 0x1.00000020808p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000820400), 0x1.0000002081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000821000), 0x1.0000002084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000824000), 0x1.000000209p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000830000), 0x1.00000020cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000000a00000), 0x1.00000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000a00008), 0x1.000000280002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000a00080), 0x1.00000028002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000a00800), 0x1.0000002802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000a08000), 0x1.000000282p+50, 0x0p+0 },
+{ UINT64_C(0x0004000000a80000), 0x1.0000002ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000001), 0x1.0000008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000002), 0x1.0000008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000010), 0x1.000000800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000014), 0x1.000000800005p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000020), 0x1.000000800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000028), 0x1.00000080000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000030), 0x1.00000080000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000100), 0x1.00000080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000108), 0x1.000000800042p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000120), 0x1.000000800048p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000140), 0x1.00000080005p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000800), 0x1.0000008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000802), 0x1.0000008002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000810), 0x1.000000800204p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000900), 0x1.00000080024p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002000c00), 0x1.0000008003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004000), 0x1.000000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004002), 0x1.0000008010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004020), 0x1.000000801008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004080), 0x1.00000080102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004100), 0x1.00000080104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004200), 0x1.00000080108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002004400), 0x1.0000008011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002005000), 0x1.0000008014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002040000), 0x1.00000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002040008), 0x1.000000810002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002040080), 0x1.00000081002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002040800), 0x1.0000008102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002041000), 0x1.0000008104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002042000), 0x1.0000008108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002050000), 0x1.000000814p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002060000), 0x1.000000818p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002100000), 0x1.00000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002100001), 0x1.0000008400004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002100008), 0x1.000000840002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002100010), 0x1.000000840004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002100100), 0x1.00000084004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002101000), 0x1.0000008404p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002102000), 0x1.0000008408p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002110000), 0x1.000000844p+50, 0x0p+0 },
+{ UINT64_C(0x0004000002140000), 0x1.00000085p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003000000), 0x1.000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000003000008), 0x1.000000c00002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003000020), 0x1.000000c00008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003000200), 0x1.000000c0008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003001000), 0x1.000000c004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003002000), 0x1.000000c008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003008000), 0x1.000000c02p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003080000), 0x1.000000c2p+50, 0x0p+0 },
+{ UINT64_C(0x0004000003400000), 0x1.000000dp+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000008), 0x1.000008000002p+50, 0x0p+0 },
+{ UINT64_C(0x000400002000000c), 0x1.000008000003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000020), 0x1.000008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000021), 0x1.0000080000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000022), 0x1.0000080000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000030), 0x1.00000800000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000100), 0x1.00000800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000104), 0x1.000008000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000120), 0x1.000008000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000200), 0x1.00000800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000201), 0x1.0000080000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000202), 0x1.0000080000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000204), 0x1.000008000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000208), 0x1.000008000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000220), 0x1.000008000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000280), 0x1.0000080000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000300), 0x1.0000080000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000400), 0x1.0000080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000401), 0x1.0000080001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000408), 0x1.000008000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000410), 0x1.000008000104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000440), 0x1.00000800011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020000480), 0x1.00000800012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020002000), 0x1.0000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020002008), 0x1.000008000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020002010), 0x1.000008000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020002100), 0x1.00000800084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020003000), 0x1.000008000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000020008000), 0x1.000008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020008001), 0x1.0000080020004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020008010), 0x1.000008002004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020008080), 0x1.00000800202p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020008400), 0x1.0000080021p+50, 0x0p+0 },
+{ UINT64_C(0x000400002000c000), 0x1.000008003p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020000), 0x1.000008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020001), 0x1.0000080080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020010), 0x1.000008008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020020), 0x1.000008008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020040), 0x1.00000800801p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020080), 0x1.00000800802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020020200), 0x1.00000800808p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020022000), 0x1.0000080088p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020030000), 0x1.00000800cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000020080000), 0x1.00000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020080008), 0x1.000008020002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020080040), 0x1.00000802001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020080200), 0x1.00000802008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020081000), 0x1.0000080204p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020088000), 0x1.000008022p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020090000), 0x1.000008024p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400000), 0x1.0000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400004), 0x1.000008100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400008), 0x1.000008100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400010), 0x1.000008100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400020), 0x1.000008100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400080), 0x1.00000810002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020400200), 0x1.00000810008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020401000), 0x1.0000081004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020408000), 0x1.000008102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020410000), 0x1.000008104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020420000), 0x1.000008108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000020500000), 0x1.00000814p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021000000), 0x1.0000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021000004), 0x1.000008400001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021000040), 0x1.00000840001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021000400), 0x1.0000084001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021000800), 0x1.0000084002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021008000), 0x1.000008402p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021020000), 0x1.000008408p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021080000), 0x1.00000842p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021100000), 0x1.00000844p+50, 0x0p+0 },
+{ UINT64_C(0x0004000021400000), 0x1.0000085p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024000000), 0x1.000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024000008), 0x1.000009000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024000040), 0x1.00000900001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024000080), 0x1.00000900002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024000400), 0x1.0000090001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024004000), 0x1.000009001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024020000), 0x1.000009008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024200000), 0x1.00000908p+50, 0x0p+0 },
+{ UINT64_C(0x0004000024400000), 0x1.0000091p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030000000), 0x1.00000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004000030000004), 0x1.00000c000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030000008), 0x1.00000c000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030000020), 0x1.00000c000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030000200), 0x1.00000c00008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030001000), 0x1.00000c0004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030010000), 0x1.00000c004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030040000), 0x1.00000c01p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030400000), 0x1.00000c1p+50, 0x0p+0 },
+{ UINT64_C(0x0004000030800000), 0x1.00000c2p+50, 0x0p+0 },
+{ UINT64_C(0x0004000034000000), 0x1.00000dp+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000004), 0x1.000040000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000006), 0x1.0000400000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000020), 0x1.000040000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000021), 0x1.0000400000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000024), 0x1.000040000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000200), 0x1.00004000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000204), 0x1.000040000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000210), 0x1.000040000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000220), 0x1.000040000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000800), 0x1.0000400002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000802), 0x1.0000400002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000804), 0x1.000040000201p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000820), 0x1.000040000208p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100000a00), 0x1.00004000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100001000), 0x1.0000400004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100001002), 0x1.0000400004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100001010), 0x1.000040000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100001100), 0x1.00004000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100001400), 0x1.0000400005p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004000), 0x1.000040001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004002), 0x1.0000400010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004010), 0x1.000040001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004040), 0x1.00004000101p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004080), 0x1.00004000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004200), 0x1.00004000108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100004400), 0x1.0000400011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100005000), 0x1.0000400014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040000), 0x1.00004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040001), 0x1.0000400100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040002), 0x1.0000400100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040008), 0x1.000040010002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040010), 0x1.000040010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040040), 0x1.00004001001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040080), 0x1.00004001002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100040100), 0x1.00004001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100041000), 0x1.0000400104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100048000), 0x1.000040012p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100050000), 0x1.000040014p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100400000), 0x1.0000401p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100400004), 0x1.000040100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100400040), 0x1.00004010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100400100), 0x1.00004010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100400200), 0x1.00004010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100400400), 0x1.0000401001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100401000), 0x1.0000401004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100410000), 0x1.000040104p+50, 0x0p+0 },
+{ UINT64_C(0x0004000100440000), 0x1.00004011p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102000000), 0x1.0000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102000002), 0x1.0000408000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102000020), 0x1.000040800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102000080), 0x1.00004080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102000800), 0x1.0000408002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102001000), 0x1.0000408004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102004000), 0x1.000040801p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102010000), 0x1.000040804p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102040000), 0x1.00004081p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102080000), 0x1.00004082p+50, 0x0p+0 },
+{ UINT64_C(0x0004000102200000), 0x1.00004088p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104000000), 0x1.000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104000001), 0x1.0000410000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104000008), 0x1.000041000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104000080), 0x1.00004100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104000800), 0x1.0000410002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104002000), 0x1.0000410008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104008000), 0x1.000041002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104020000), 0x1.000041008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104040000), 0x1.00004101p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104200000), 0x1.00004108p+50, 0x0p+0 },
+{ UINT64_C(0x0004000104800000), 0x1.0000412p+50, 0x0p+0 },
+{ UINT64_C(0x0004000106000000), 0x1.0000418p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110000000), 0x1.000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110000004), 0x1.000044000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110000008), 0x1.000044000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110000040), 0x1.00004400001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110000100), 0x1.00004400004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110000200), 0x1.00004400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110002000), 0x1.0000440008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110004000), 0x1.000044001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110020000), 0x1.000044008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110200000), 0x1.00004408p+50, 0x0p+0 },
+{ UINT64_C(0x0004000110800000), 0x1.0000442p+50, 0x0p+0 },
+{ UINT64_C(0x0004000112000000), 0x1.0000448p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140000000), 0x1.00005p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140000004), 0x1.000050000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140000010), 0x1.000050000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140000040), 0x1.00005000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140000200), 0x1.00005000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140000400), 0x1.0000500001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140002000), 0x1.0000500008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140004000), 0x1.000050001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140010000), 0x1.000050004p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140040000), 0x1.00005001p+50, 0x0p+0 },
+{ UINT64_C(0x0004000140200000), 0x1.00005008p+50, 0x0p+0 },
+{ UINT64_C(0x0004000142000000), 0x1.0000508p+50, 0x0p+0 },
+{ UINT64_C(0x0004000144000000), 0x1.000051p+50, 0x0p+0 },
+{ UINT64_C(0x0004000148000000), 0x1.000052p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000008), 0x1.000400000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000009), 0x1.0004000000024p+50, 0x0p+0 },
+{ UINT64_C(0x000400100000000a), 0x1.0004000000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000080), 0x1.00040000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000088), 0x1.000400000022p+50, 0x0p+0 },
+{ UINT64_C(0x00040010000000a0), 0x1.000400000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000200), 0x1.00040000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000201), 0x1.0004000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000202), 0x1.0004000000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000220), 0x1.000400000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000400), 0x1.0004000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000401), 0x1.0004000001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000402), 0x1.0004000001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000404), 0x1.000400000101p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000408), 0x1.000400000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000410), 0x1.000400000104p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000000500), 0x1.00040000014p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000002000), 0x1.0004000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000002008), 0x1.000400000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000002080), 0x1.00040000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000002800), 0x1.000400000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004001000020000), 0x1.000400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000020002), 0x1.0004000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000020010), 0x1.000400008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000020080), 0x1.00040000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000020200), 0x1.00040000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000022000), 0x1.0004000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000030000), 0x1.00040000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200000), 0x1.00040008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200004), 0x1.000400080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200008), 0x1.000400080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200020), 0x1.000400080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200080), 0x1.00040008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200100), 0x1.00040008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000200800), 0x1.0004000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000201000), 0x1.0004000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000208000), 0x1.000400082p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000220000), 0x1.000400088p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000400000), 0x1.0004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000400004), 0x1.000400100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000400010), 0x1.000400100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000400040), 0x1.00040010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000400400), 0x1.0004001001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000400800), 0x1.0004001002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000402000), 0x1.0004001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000404000), 0x1.000400101p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000410000), 0x1.000400104p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000420000), 0x1.000400108p+50, 0x0p+0 },
+{ UINT64_C(0x0004001000480000), 0x1.00040012p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004000000), 0x1.000401p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004000002), 0x1.0004010000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004000004), 0x1.000401000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004000040), 0x1.00040100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004000200), 0x1.00040100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004000400), 0x1.0004010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004002000), 0x1.0004010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004010000), 0x1.000401004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004040000), 0x1.00040101p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004080000), 0x1.00040102p+50, 0x0p+0 },
+{ UINT64_C(0x0004001004400000), 0x1.0004011p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040000000), 0x1.00041p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040000002), 0x1.0004100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040000020), 0x1.000410000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040000080), 0x1.00041000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040000200), 0x1.00041000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040000800), 0x1.0004100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040002000), 0x1.0004100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040008000), 0x1.000410002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040020000), 0x1.000410008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040040000), 0x1.00041001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001040200000), 0x1.00041008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001041000000), 0x1.0004104p+50, 0x0p+0 },
+{ UINT64_C(0x0004001048000000), 0x1.000412p+50, 0x0p+0 },
+{ UINT64_C(0x0004001060000000), 0x1.000418p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080000000), 0x1.00042p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080000002), 0x1.0004200000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080000010), 0x1.000420000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080000080), 0x1.00042000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080000200), 0x1.00042000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080001000), 0x1.0004200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080010000), 0x1.000420004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080020000), 0x1.000420008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080100000), 0x1.00042004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001080800000), 0x1.0004202p+50, 0x0p+0 },
+{ UINT64_C(0x0004001084000000), 0x1.000421p+50, 0x0p+0 },
+{ UINT64_C(0x00040010a0000000), 0x1.000428p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200000000), 0x1.00048p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200000004), 0x1.000480000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200000020), 0x1.000480000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200000200), 0x1.00048000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200000800), 0x1.0004800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200002000), 0x1.0004800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200008000), 0x1.000480002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200010000), 0x1.000480004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200100000), 0x1.00048004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001200800000), 0x1.0004802p+50, 0x0p+0 },
+{ UINT64_C(0x0004001208000000), 0x1.000482p+50, 0x0p+0 },
+{ UINT64_C(0x0004001220000000), 0x1.000488p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400000000), 0x1.0005p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400000001), 0x1.0005000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400000002), 0x1.0005000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400000020), 0x1.000500000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400000100), 0x1.00050000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400000800), 0x1.0005000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400001000), 0x1.0005000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400008000), 0x1.000500002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400010000), 0x1.000500004p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400080000), 0x1.00050002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001400800000), 0x1.0005002p+50, 0x0p+0 },
+{ UINT64_C(0x0004001402000000), 0x1.0005008p+50, 0x0p+0 },
+{ UINT64_C(0x0004001420000000), 0x1.000508p+50, 0x0p+0 },
+{ UINT64_C(0x0004001500000000), 0x1.00054p+50, 0x0p+0 },
+{ UINT64_C(0x0004001600000000), 0x1.00058p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000001), 0x1.0040000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000008), 0x1.004000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000009), 0x1.0040000000024p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000010), 0x1.004000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000018), 0x1.004000000006p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000100), 0x1.00400000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000102), 0x1.0040000000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000108), 0x1.004000000042p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000140), 0x1.00400000005p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000400), 0x1.0040000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000404), 0x1.004000000101p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000408), 0x1.004000000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000440), 0x1.00400000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000000480), 0x1.00400000012p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000001000), 0x1.0040000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000001004), 0x1.004000000401p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000001008), 0x1.004000000402p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000001020), 0x1.004000000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000001200), 0x1.00400000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002000), 0x1.0040000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002002), 0x1.0040000008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002004), 0x1.004000000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002010), 0x1.004000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002100), 0x1.00400000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002200), 0x1.00400000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000002400), 0x1.0040000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008000), 0x1.004000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008008), 0x1.004000002002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008010), 0x1.004000002004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008040), 0x1.00400000201p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008080), 0x1.00400000202p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008100), 0x1.00400000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008200), 0x1.00400000208p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000008400), 0x1.0040000021p+50, 0x0p+0 },
+{ UINT64_C(0x000401000000c000), 0x1.004000003p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000020000), 0x1.004000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000020004), 0x1.004000008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000020040), 0x1.00400000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000020400), 0x1.0040000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000022000), 0x1.0040000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000200000), 0x1.00400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000200002), 0x1.0040000800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000200020), 0x1.004000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000200100), 0x1.00400008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000200800), 0x1.0040000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000204000), 0x1.004000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000208000), 0x1.004000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004010000280000), 0x1.0040000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004010000300000), 0x1.0040000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004010002000000), 0x1.0040008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002000004), 0x1.004000800001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002000040), 0x1.00400080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002000200), 0x1.00400080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002000800), 0x1.0040008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002001000), 0x1.0040008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002004000), 0x1.004000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002008000), 0x1.004000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002010000), 0x1.004000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002020000), 0x1.004000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002100000), 0x1.00400084p+50, 0x0p+0 },
+{ UINT64_C(0x0004010002800000), 0x1.004000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000000), 0x1.004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000004), 0x1.004008000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000010), 0x1.004008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000020), 0x1.004008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000040), 0x1.00400800001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000100), 0x1.00400800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020000800), 0x1.0040080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020001000), 0x1.0040080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020010000), 0x1.004008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010020100000), 0x1.00400804p+50, 0x0p+0 },
+{ UINT64_C(0x0004010021000000), 0x1.0040084p+50, 0x0p+0 },
+{ UINT64_C(0x0004010022000000), 0x1.0040088p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040000000), 0x1.00401p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040000004), 0x1.004010000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040000020), 0x1.004010000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040000100), 0x1.00401000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040000200), 0x1.00401000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040001000), 0x1.0040100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040002000), 0x1.0040100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040010000), 0x1.004010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040100000), 0x1.00401004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010040200000), 0x1.00401008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010041000000), 0x1.0040104p+50, 0x0p+0 },
+{ UINT64_C(0x0004010048000000), 0x1.004012p+50, 0x0p+0 },
+{ UINT64_C(0x0004010050000000), 0x1.004014p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100000000), 0x1.00404p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100000002), 0x1.0040400000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100000008), 0x1.004040000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100000080), 0x1.00404000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100000200), 0x1.00404000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100000800), 0x1.0040400002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100001000), 0x1.0040400004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100010000), 0x1.004040004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100020000), 0x1.004040008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100100000), 0x1.00404004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010100400000), 0x1.0040401p+50, 0x0p+0 },
+{ UINT64_C(0x0004010104000000), 0x1.004041p+50, 0x0p+0 },
+{ UINT64_C(0x0004010110000000), 0x1.004044p+50, 0x0p+0 },
+{ UINT64_C(0x0004010140000000), 0x1.00405p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400000000), 0x1.0041p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400000001), 0x1.0041000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400000004), 0x1.004100000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400000020), 0x1.004100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400000040), 0x1.00410000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400000400), 0x1.0041000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400002000), 0x1.0041000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400020000), 0x1.004100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400100000), 0x1.00410004p+50, 0x0p+0 },
+{ UINT64_C(0x0004010400800000), 0x1.0041002p+50, 0x0p+0 },
+{ UINT64_C(0x0004010402000000), 0x1.0041008p+50, 0x0p+0 },
+{ UINT64_C(0x0004010404000000), 0x1.004101p+50, 0x0p+0 },
+{ UINT64_C(0x0004010410000000), 0x1.004104p+50, 0x0p+0 },
+{ UINT64_C(0x0004010500000000), 0x1.00414p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000000000), 0x1.005p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000000004), 0x1.005000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000000020), 0x1.005000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000000200), 0x1.00500000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000000400), 0x1.0050000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000000800), 0x1.0050000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000008000), 0x1.005000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000080000), 0x1.00500002p+50, 0x0p+0 },
+{ UINT64_C(0x0004014000800000), 0x1.0050002p+50, 0x0p+0 },
+{ UINT64_C(0x0004014001000000), 0x1.0050004p+50, 0x0p+0 },
+{ UINT64_C(0x0004014002000000), 0x1.0050008p+50, 0x0p+0 },
+{ UINT64_C(0x0004014008000000), 0x1.005002p+50, 0x0p+0 },
+{ UINT64_C(0x0004014020000000), 0x1.005008p+50, 0x0p+0 },
+{ UINT64_C(0x0004014200000000), 0x1.00508p+50, 0x0p+0 },
+{ UINT64_C(0x0004015000000000), 0x1.0054p+50, 0x0p+0 },
+{ UINT64_C(0x0004016000000000), 0x1.0058p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000002), 0x1.0080000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000003), 0x1.008000000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000008), 0x1.008000000002p+50, 0x0p+0 },
+{ UINT64_C(0x000402000000000a), 0x1.0080000000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000040), 0x1.00800000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000048), 0x1.008000000012p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000100), 0x1.00800000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000101), 0x1.0080000000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000104), 0x1.008000000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000108), 0x1.008000000042p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000110), 0x1.008000000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000140), 0x1.00800000005p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000000180), 0x1.00800000006p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000001000), 0x1.0080000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000001002), 0x1.0080000004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000001020), 0x1.008000000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000001100), 0x1.00800000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000002000), 0x1.0080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000002002), 0x1.0080000008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000002008), 0x1.008000000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000002010), 0x1.008000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000002100), 0x1.00800000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000002400), 0x1.0080000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000004000), 0x1.008000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000004001), 0x1.0080000010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000004004), 0x1.008000001001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000004020), 0x1.008000001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000004200), 0x1.00800000108p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000006000), 0x1.0080000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000008000), 0x1.008000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000008008), 0x1.008000002002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000008020), 0x1.008000002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000008100), 0x1.00800000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000008400), 0x1.0080000021p+50, 0x0p+0 },
+{ UINT64_C(0x000402000000c000), 0x1.008000003p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000010000), 0x1.008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000010001), 0x1.0080000040004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000010004), 0x1.008000004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000010020), 0x1.008000004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000010200), 0x1.00800000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000012000), 0x1.0080000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000020000), 0x1.008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000020002), 0x1.0080000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000020020), 0x1.008000008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000020040), 0x1.00800000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000020080), 0x1.00800000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000020400), 0x1.0080000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000022000), 0x1.0080000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000030000), 0x1.00800000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004020000200000), 0x1.00800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000200001), 0x1.0080000800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000200010), 0x1.008000080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000200100), 0x1.00800008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000201000), 0x1.0080000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000208000), 0x1.008000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000240000), 0x1.00800009p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000280000), 0x1.0080000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004020000400000), 0x1.0080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000400001), 0x1.0080001000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000400008), 0x1.008000100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000400010), 0x1.008000100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000400040), 0x1.00800010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000400400), 0x1.0080001001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000402000), 0x1.0080001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000404000), 0x1.008000101p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000440000), 0x1.00800011p+50, 0x0p+0 },
+{ UINT64_C(0x0004020000480000), 0x1.00800012p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004000000), 0x1.008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004000002), 0x1.0080010000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004000004), 0x1.008001000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004000040), 0x1.00800100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004000100), 0x1.00800100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004001000), 0x1.0080010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004002000), 0x1.0080010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004020000), 0x1.008001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004100000), 0x1.00800104p+50, 0x0p+0 },
+{ UINT64_C(0x0004020004800000), 0x1.0080012p+50, 0x0p+0 },
+{ UINT64_C(0x0004020005000000), 0x1.0080014p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040000000), 0x1.00801p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040000002), 0x1.0080100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040000004), 0x1.008010000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040000008), 0x1.008010000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040000080), 0x1.00801000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040000800), 0x1.0080100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040002000), 0x1.0080100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040020000), 0x1.008010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040080000), 0x1.00801002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040400000), 0x1.0080101p+50, 0x0p+0 },
+{ UINT64_C(0x0004020040800000), 0x1.0080102p+50, 0x0p+0 },
+{ UINT64_C(0x0004020042000000), 0x1.0080108p+50, 0x0p+0 },
+{ UINT64_C(0x0004020060000000), 0x1.008018p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400000000), 0x1.0081p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400000004), 0x1.008100000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400000020), 0x1.008100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400000200), 0x1.00810000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400001000), 0x1.0081000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400010000), 0x1.008100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400080000), 0x1.00810002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020400800000), 0x1.0081002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020401000000), 0x1.0081004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020410000000), 0x1.008104p+50, 0x0p+0 },
+{ UINT64_C(0x0004020500000000), 0x1.00814p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800000000), 0x1.0082p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800000001), 0x1.0082000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800000008), 0x1.008200000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800000080), 0x1.00820000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800000800), 0x1.0082000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800001000), 0x1.0082000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800008000), 0x1.008200002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800080000), 0x1.00820002p+50, 0x0p+0 },
+{ UINT64_C(0x0004020800200000), 0x1.00820008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020802000000), 0x1.0082008p+50, 0x0p+0 },
+{ UINT64_C(0x0004020804000000), 0x1.008201p+50, 0x0p+0 },
+{ UINT64_C(0x0004020840000000), 0x1.00821p+50, 0x0p+0 },
+{ UINT64_C(0x0004020880000000), 0x1.00822p+50, 0x0p+0 },
+{ UINT64_C(0x0004020c00000000), 0x1.0083p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000000000), 0x1.009p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000000001), 0x1.0090000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000000002), 0x1.0090000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000000020), 0x1.009000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000000200), 0x1.00900000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000002000), 0x1.0090000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000008000), 0x1.009000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000080000), 0x1.00900002p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000100000), 0x1.00900004p+50, 0x0p+0 },
+{ UINT64_C(0x0004024000800000), 0x1.0090002p+50, 0x0p+0 },
+{ UINT64_C(0x0004024001000000), 0x1.0090004p+50, 0x0p+0 },
+{ UINT64_C(0x0004024008000000), 0x1.009002p+50, 0x0p+0 },
+{ UINT64_C(0x0004024040000000), 0x1.00901p+50, 0x0p+0 },
+{ UINT64_C(0x0004024200000000), 0x1.00908p+50, 0x0p+0 },
+{ UINT64_C(0x0004024800000000), 0x1.0092p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000000), 0x1.00ap+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000002), 0x1.00a0000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000004), 0x1.00a000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000010), 0x1.00a000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000020), 0x1.00a000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000100), 0x1.00a00000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000200), 0x1.00a00000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000400), 0x1.00a0000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000000800), 0x1.00a0000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000002000), 0x1.00a0000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000010000), 0x1.00a000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000040000), 0x1.00a00001p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000080000), 0x1.00a00002p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000100000), 0x1.00a00004p+50, 0x0p+0 },
+{ UINT64_C(0x0004028000800000), 0x1.00a0002p+50, 0x0p+0 },
+{ UINT64_C(0x0004028002000000), 0x1.00a0008p+50, 0x0p+0 },
+{ UINT64_C(0x0004028004000000), 0x1.00a001p+50, 0x0p+0 },
+{ UINT64_C(0x0004028008000000), 0x1.00a002p+50, 0x0p+0 },
+{ UINT64_C(0x0004028020000000), 0x1.00a008p+50, 0x0p+0 },
+{ UINT64_C(0x0004028040000000), 0x1.00a01p+50, 0x0p+0 },
+{ UINT64_C(0x0004028200000000), 0x1.00a08p+50, 0x0p+0 },
+{ UINT64_C(0x0004028400000000), 0x1.00a1p+50, 0x0p+0 },
+{ UINT64_C(0x0004028800000000), 0x1.00a2p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000008), 0x1.010000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000010), 0x1.010000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000012), 0x1.0100000000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000014), 0x1.010000000005p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000100), 0x1.01000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000104), 0x1.010000000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000120), 0x1.010000000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000180), 0x1.01000000006p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000400), 0x1.0100000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000402), 0x1.0100000001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000404), 0x1.010000000101p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000410), 0x1.010000000104p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000000480), 0x1.01000000012p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002000), 0x1.0100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002001), 0x1.0100000008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002002), 0x1.0100000008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002004), 0x1.010000000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002020), 0x1.010000000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002080), 0x1.01000000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002100), 0x1.01000000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000002800), 0x1.010000000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004040000003000), 0x1.010000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004040000010000), 0x1.010000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000010004), 0x1.010000004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000010008), 0x1.010000004002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000010020), 0x1.010000004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000010200), 0x1.01000000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000012000), 0x1.0100000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000018000), 0x1.010000006p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000020000), 0x1.010000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000020008), 0x1.010000008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000020040), 0x1.01000000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000020100), 0x1.01000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000021000), 0x1.0100000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000024000), 0x1.010000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000028000), 0x1.01000000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004040000030000), 0x1.01000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004040000040000), 0x1.01000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000040004), 0x1.010000010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000040010), 0x1.010000010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000040080), 0x1.01000001002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000040100), 0x1.01000001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000041000), 0x1.0100000104p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000050000), 0x1.010000014p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000400000), 0x1.0100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000400001), 0x1.0100001000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000400008), 0x1.010000100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000400010), 0x1.010000100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000400100), 0x1.01000010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000400800), 0x1.0100001002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000408000), 0x1.010000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000420000), 0x1.010000108p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000440000), 0x1.01000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000500000), 0x1.01000014p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000800000), 0x1.0100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000800008), 0x1.010000200002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000800010), 0x1.010000200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000800080), 0x1.01000020002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000800400), 0x1.0100002001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000801000), 0x1.0100002004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000810000), 0x1.010000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000880000), 0x1.01000022p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000a00000), 0x1.01000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004040000c00000), 0x1.0100003p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008000000), 0x1.010002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008000002), 0x1.0100020000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008000008), 0x1.010002000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008000010), 0x1.010002000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008000100), 0x1.01000200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008001000), 0x1.0100020004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008002000), 0x1.0100020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008004000), 0x1.010002001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008020000), 0x1.010002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008200000), 0x1.01000208p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008400000), 0x1.0100021p+50, 0x0p+0 },
+{ UINT64_C(0x0004040008800000), 0x1.0100022p+50, 0x0p+0 },
+{ UINT64_C(0x000404000a000000), 0x1.0100028p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010000000), 0x1.010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010000008), 0x1.010004000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010000040), 0x1.01000400001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010000200), 0x1.01000400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010000400), 0x1.0100040001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010001000), 0x1.0100040004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010008000), 0x1.010004002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010040000), 0x1.01000401p+50, 0x0p+0 },
+{ UINT64_C(0x0004040010200000), 0x1.01000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004040012000000), 0x1.0100048p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080000000), 0x1.01002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080000004), 0x1.010020000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080000008), 0x1.010020000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080000020), 0x1.010020000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080000080), 0x1.01002000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080000400), 0x1.0100200001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080002000), 0x1.0100200008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080020000), 0x1.010020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040080100000), 0x1.01002004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040081000000), 0x1.0100204p+50, 0x0p+0 },
+{ UINT64_C(0x0004040088000000), 0x1.010022p+50, 0x0p+0 },
+{ UINT64_C(0x00040400c0000000), 0x1.01003p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100000000), 0x1.01004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100000001), 0x1.0100400000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100000008), 0x1.010040000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100000040), 0x1.01004000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100000200), 0x1.01004000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100002000), 0x1.0100400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100004000), 0x1.010040001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100020000), 0x1.010040008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100100000), 0x1.01004004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100400000), 0x1.0100401p+50, 0x0p+0 },
+{ UINT64_C(0x0004040100800000), 0x1.0100402p+50, 0x0p+0 },
+{ UINT64_C(0x0004040108000000), 0x1.010042p+50, 0x0p+0 },
+{ UINT64_C(0x0004040110000000), 0x1.010044p+50, 0x0p+0 },
+{ UINT64_C(0x0004040140000000), 0x1.01005p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200000000), 0x1.01008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200000001), 0x1.0100800000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200000010), 0x1.010080000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200000020), 0x1.010080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200000040), 0x1.01008000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200000200), 0x1.01008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200002000), 0x1.0100800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200004000), 0x1.010080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200020000), 0x1.010080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200040000), 0x1.01008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200100000), 0x1.01008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004040200800000), 0x1.0100802p+50, 0x0p+0 },
+{ UINT64_C(0x0004040208000000), 0x1.010082p+50, 0x0p+0 },
+{ UINT64_C(0x0004040240000000), 0x1.01009p+50, 0x0p+0 },
+{ UINT64_C(0x0004040280000000), 0x1.0100ap+50, 0x0p+0 },
+{ UINT64_C(0x0004040300000000), 0x1.0100cp+50, 0x0p+0 },
+{ UINT64_C(0x0004042000000000), 0x1.0108p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000000001), 0x1.0108000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000000010), 0x1.010800000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000000100), 0x1.01080000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000000200), 0x1.01080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000000800), 0x1.0108000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000004000), 0x1.010800001p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000040000), 0x1.01080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004042000100000), 0x1.01080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004042001000000), 0x1.0108004p+50, 0x0p+0 },
+{ UINT64_C(0x0004042002000000), 0x1.0108008p+50, 0x0p+0 },
+{ UINT64_C(0x0004042020000000), 0x1.010808p+50, 0x0p+0 },
+{ UINT64_C(0x0004042100000000), 0x1.01084p+50, 0x0p+0 },
+{ UINT64_C(0x0004042200000000), 0x1.01088p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000000000), 0x1.011p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000000001), 0x1.0110000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000000008), 0x1.011000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000000080), 0x1.01100000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000000800), 0x1.0110000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000001000), 0x1.0110000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000008000), 0x1.011000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000020000), 0x1.011000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000100000), 0x1.01100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004044000400000), 0x1.0110001p+50, 0x0p+0 },
+{ UINT64_C(0x0004044002000000), 0x1.0110008p+50, 0x0p+0 },
+{ UINT64_C(0x0004044008000000), 0x1.011002p+50, 0x0p+0 },
+{ UINT64_C(0x0004044010000000), 0x1.011004p+50, 0x0p+0 },
+{ UINT64_C(0x0004044040000000), 0x1.01101p+50, 0x0p+0 },
+{ UINT64_C(0x0004044100000000), 0x1.01104p+50, 0x0p+0 },
+{ UINT64_C(0x0004044800000000), 0x1.0112p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000000), 0x1.012p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000004), 0x1.012000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000008), 0x1.012000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000020), 0x1.012000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000040), 0x1.01200000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000080), 0x1.01200000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000100), 0x1.01200000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000200), 0x1.01200000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000000800), 0x1.0120000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000001000), 0x1.0120000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000010000), 0x1.012000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004048000100000), 0x1.01200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004048001000000), 0x1.0120004p+50, 0x0p+0 },
+{ UINT64_C(0x0004048002000000), 0x1.0120008p+50, 0x0p+0 },
+{ UINT64_C(0x0004048004000000), 0x1.012001p+50, 0x0p+0 },
+{ UINT64_C(0x0004048010000000), 0x1.012004p+50, 0x0p+0 },
+{ UINT64_C(0x0004048100000000), 0x1.01204p+50, 0x0p+0 },
+{ UINT64_C(0x0004048400000000), 0x1.0121p+50, 0x0p+0 },
+{ UINT64_C(0x0004049000000000), 0x1.0124p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000000000), 0x1.018p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000000008), 0x1.018000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000000080), 0x1.01800000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000000400), 0x1.0180000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000004000), 0x1.018000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000020000), 0x1.018000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000200000), 0x1.01800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004060000800000), 0x1.0180002p+50, 0x0p+0 },
+{ UINT64_C(0x0004060002000000), 0x1.0180008p+50, 0x0p+0 },
+{ UINT64_C(0x0004060020000000), 0x1.018008p+50, 0x0p+0 },
+{ UINT64_C(0x0004060200000000), 0x1.01808p+50, 0x0p+0 },
+{ UINT64_C(0x0004062000000000), 0x1.0188p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000008), 0x1.020000000002p+50, 0x0p+0 },
+{ UINT64_C(0x000408000000000a), 0x1.0200000000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000020), 0x1.020000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000021), 0x1.0200000000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000022), 0x1.0200000000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000024), 0x1.020000000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000028), 0x1.02000000000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000100), 0x1.02000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000101), 0x1.0200000000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000108), 0x1.020000000042p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000000180), 0x1.02000000006p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000001000), 0x1.0200000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000001001), 0x1.0200000004004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000001004), 0x1.020000000401p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000001010), 0x1.020000000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000001020), 0x1.020000000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000001100), 0x1.02000000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000008000), 0x1.020000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000008008), 0x1.020000002002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000008020), 0x1.020000002008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000008100), 0x1.02000000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000008800), 0x1.0200000022p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000080000), 0x1.02000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000080002), 0x1.0200000200008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000080020), 0x1.020000020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000080080), 0x1.02000002002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000080400), 0x1.0200000201p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000081000), 0x1.0200000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000090000), 0x1.020000024p+50, 0x0p+0 },
+{ UINT64_C(0x00040800000c0000), 0x1.02000003p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000400000), 0x1.0200001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000400008), 0x1.020000100002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000400010), 0x1.020000100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000400040), 0x1.02000010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000400100), 0x1.02000010004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000401000), 0x1.0200001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000402000), 0x1.0200001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000420000), 0x1.020000108p+50, 0x0p+0 },
+{ UINT64_C(0x0004080000600000), 0x1.02000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000000), 0x1.0200008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000002), 0x1.0200008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000010), 0x1.020000800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000080), 0x1.02000080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000200), 0x1.02000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000400), 0x1.0200008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002000800), 0x1.0200008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002004000), 0x1.020000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002010000), 0x1.020000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002100000), 0x1.02000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004080002200000), 0x1.02000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004080003000000), 0x1.020000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004080020000000), 0x1.020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020000008), 0x1.020008000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020000020), 0x1.020008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020000080), 0x1.02000800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020000800), 0x1.0200080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020002000), 0x1.0200080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020010000), 0x1.020008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020100000), 0x1.02000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004080020800000), 0x1.0200082p+50, 0x0p+0 },
+{ UINT64_C(0x0004080024000000), 0x1.020009p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040000000), 0x1.02001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040000002), 0x1.0200100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040000020), 0x1.020010000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040000040), 0x1.02001000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040000080), 0x1.02001000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040000400), 0x1.0200100001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040004000), 0x1.020010001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040020000), 0x1.020010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040100000), 0x1.02001004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080040200000), 0x1.02001008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080042000000), 0x1.0200108p+50, 0x0p+0 },
+{ UINT64_C(0x0004080048000000), 0x1.020012p+50, 0x0p+0 },
+{ UINT64_C(0x0004080050000000), 0x1.020014p+50, 0x0p+0 },
+{ UINT64_C(0x0004080060000000), 0x1.020018p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200000000), 0x1.02008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200000002), 0x1.0200800000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200000020), 0x1.020080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200000100), 0x1.02008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200000400), 0x1.0200800001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200000800), 0x1.0200800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200004000), 0x1.020080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200020000), 0x1.020080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200040000), 0x1.02008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200200000), 0x1.02008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080200800000), 0x1.0200802p+50, 0x0p+0 },
+{ UINT64_C(0x0004080208000000), 0x1.020082p+50, 0x0p+0 },
+{ UINT64_C(0x0004080220000000), 0x1.020088p+50, 0x0p+0 },
+{ UINT64_C(0x0004080300000000), 0x1.0200cp+50, 0x0p+0 },
+{ UINT64_C(0x0004080400000000), 0x1.0201p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400000001), 0x1.0201000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400000010), 0x1.020100000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400000040), 0x1.02010000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400000400), 0x1.0201000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400002000), 0x1.0201000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400010000), 0x1.020100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400020000), 0x1.020100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400200000), 0x1.02010008p+50, 0x0p+0 },
+{ UINT64_C(0x0004080400800000), 0x1.0201002p+50, 0x0p+0 },
+{ UINT64_C(0x0004080408000000), 0x1.020102p+50, 0x0p+0 },
+{ UINT64_C(0x0004080420000000), 0x1.020108p+50, 0x0p+0 },
+{ UINT64_C(0x0004080600000000), 0x1.02018p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000000000), 0x1.0204p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000000002), 0x1.0204000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000000020), 0x1.020400000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000000040), 0x1.02040000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000000400), 0x1.0204000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000001000), 0x1.0204000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000010000), 0x1.020400004p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000080000), 0x1.02040002p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000100000), 0x1.02040004p+50, 0x0p+0 },
+{ UINT64_C(0x0004081000800000), 0x1.0204002p+50, 0x0p+0 },
+{ UINT64_C(0x0004081004000000), 0x1.020401p+50, 0x0p+0 },
+{ UINT64_C(0x0004081040000000), 0x1.02041p+50, 0x0p+0 },
+{ UINT64_C(0x0004081080000000), 0x1.02042p+50, 0x0p+0 },
+{ UINT64_C(0x0004081200000000), 0x1.02048p+50, 0x0p+0 },
+{ UINT64_C(0x0004081400000000), 0x1.0205p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000000000), 0x1.022p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000000008), 0x1.022000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000000010), 0x1.022000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000000040), 0x1.02200000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000000400), 0x1.0220000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000001000), 0x1.0220000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000004000), 0x1.022000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000008000), 0x1.022000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000040000), 0x1.02200001p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000080000), 0x1.02200002p+50, 0x0p+0 },
+{ UINT64_C(0x0004088000800000), 0x1.0220002p+50, 0x0p+0 },
+{ UINT64_C(0x0004088001000000), 0x1.0220004p+50, 0x0p+0 },
+{ UINT64_C(0x0004088010000000), 0x1.022004p+50, 0x0p+0 },
+{ UINT64_C(0x0004088020000000), 0x1.022008p+50, 0x0p+0 },
+{ UINT64_C(0x0004088200000000), 0x1.02208p+50, 0x0p+0 },
+{ UINT64_C(0x0004089000000000), 0x1.0224p+50, 0x0p+0 },
+{ UINT64_C(0x000408a000000000), 0x1.0228p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000000000), 0x1.028p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000000008), 0x1.028000000002p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000000020), 0x1.028000000008p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000000200), 0x1.02800000008p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000000800), 0x1.0280000002p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000008000), 0x1.028000002p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000080000), 0x1.02800002p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000200000), 0x1.02800008p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0000800000), 0x1.0280002p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0002000000), 0x1.0280008p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0008000000), 0x1.028002p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0020000000), 0x1.028008p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0100000000), 0x1.02804p+50, 0x0p+0 },
+{ UINT64_C(0x00040a0400000000), 0x1.0281p+50, 0x0p+0 },
+{ UINT64_C(0x00040a4000000000), 0x1.029p+50, 0x0p+0 },
+{ UINT64_C(0x00040a8000000000), 0x1.02ap+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000001), 0x1.0800000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000002), 0x1.0800000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000010), 0x1.080000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000014), 0x1.080000000005p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000020), 0x1.080000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000022), 0x1.0800000000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000028), 0x1.08000000000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000030), 0x1.08000000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000200), 0x1.08000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000204), 0x1.080000000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000210), 0x1.080000000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000000300), 0x1.0800000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004200000001000), 0x1.0800000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000001008), 0x1.080000000402p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000001040), 0x1.08000000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000001100), 0x1.08000000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008000), 0x1.080000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008002), 0x1.0800000020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008004), 0x1.080000002001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008040), 0x1.08000000201p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008080), 0x1.08000000202p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008100), 0x1.08000000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008400), 0x1.0800000021p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000008800), 0x1.0800000022p+50, 0x0p+0 },
+{ UINT64_C(0x000420000000a000), 0x1.0800000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000020000), 0x1.080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000020002), 0x1.0800000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000020010), 0x1.080000008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000020100), 0x1.08000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000020200), 0x1.08000000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000020800), 0x1.0800000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000024000), 0x1.080000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000030000), 0x1.08000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004200000080000), 0x1.08000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000080004), 0x1.080000020001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000080020), 0x1.080000020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000080100), 0x1.08000002004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000080400), 0x1.0800000201p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000084000), 0x1.080000021p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000088000), 0x1.080000022p+50, 0x0p+0 },
+{ UINT64_C(0x00042000000a0000), 0x1.080000028p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000200000), 0x1.08000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000200008), 0x1.080000080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000200040), 0x1.08000008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000200400), 0x1.0800000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000200800), 0x1.0800000802p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000204000), 0x1.080000081p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000220000), 0x1.080000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004200000280000), 0x1.0800000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004200000300000), 0x1.0800000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004200001000000), 0x1.0800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001000002), 0x1.0800004000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001000020), 0x1.080000400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001000040), 0x1.08000040001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001000100), 0x1.08000040004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001000800), 0x1.0800004002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001008000), 0x1.080000402p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001080000), 0x1.08000042p+50, 0x0p+0 },
+{ UINT64_C(0x0004200001800000), 0x1.0800006p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000000), 0x1.080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000002), 0x1.0800040000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000008), 0x1.080004000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000010), 0x1.080004000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000020), 0x1.080004000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000040), 0x1.08000400001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000080), 0x1.08000400002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010000200), 0x1.08000400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010002000), 0x1.0800040008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010008000), 0x1.080004002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010010000), 0x1.080004004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010020000), 0x1.080004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010200000), 0x1.08000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004200010400000), 0x1.0800041p+50, 0x0p+0 },
+{ UINT64_C(0x0004200014000000), 0x1.080005p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020000000), 0x1.080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020000001), 0x1.0800080000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020000010), 0x1.080008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020000100), 0x1.08000800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020000800), 0x1.0800080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020002000), 0x1.0800080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020004000), 0x1.080008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020040000), 0x1.08000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020100000), 0x1.08000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004200020400000), 0x1.0800081p+50, 0x0p+0 },
+{ UINT64_C(0x0004200024000000), 0x1.080009p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000000), 0x1.08008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000002), 0x1.0800800000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000020), 0x1.080080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000080), 0x1.08008000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000100), 0x1.08008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000400), 0x1.0800800001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200000800), 0x1.0800800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200001000), 0x1.0800800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200008000), 0x1.080080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200020000), 0x1.080080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200040000), 0x1.08008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200100000), 0x1.08008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200200000), 0x1.08008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200200400000), 0x1.0800801p+50, 0x0p+0 },
+{ UINT64_C(0x0004200201000000), 0x1.0800804p+50, 0x0p+0 },
+{ UINT64_C(0x0004200204000000), 0x1.080081p+50, 0x0p+0 },
+{ UINT64_C(0x0004200220000000), 0x1.080088p+50, 0x0p+0 },
+{ UINT64_C(0x0004200240000000), 0x1.08009p+50, 0x0p+0 },
+{ UINT64_C(0x0004200280000000), 0x1.0800ap+50, 0x0p+0 },
+{ UINT64_C(0x0004200800000000), 0x1.0802p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800000008), 0x1.080200000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800000080), 0x1.08020000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800000200), 0x1.08020000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800000400), 0x1.0802000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800002000), 0x1.0802000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800004000), 0x1.080200001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800040000), 0x1.08020001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200800400000), 0x1.0802001p+50, 0x0p+0 },
+{ UINT64_C(0x0004200804000000), 0x1.080201p+50, 0x0p+0 },
+{ UINT64_C(0x0004200840000000), 0x1.08021p+50, 0x0p+0 },
+{ UINT64_C(0x0004200a00000000), 0x1.08028p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000000000), 0x1.0808p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000000008), 0x1.080800000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000000020), 0x1.080800000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000000200), 0x1.08080000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000001000), 0x1.0808000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000010000), 0x1.080800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000080000), 0x1.08080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004202000400000), 0x1.0808001p+50, 0x0p+0 },
+{ UINT64_C(0x0004202004000000), 0x1.080801p+50, 0x0p+0 },
+{ UINT64_C(0x0004202008000000), 0x1.080802p+50, 0x0p+0 },
+{ UINT64_C(0x0004202020000000), 0x1.080808p+50, 0x0p+0 },
+{ UINT64_C(0x0004202040000000), 0x1.08081p+50, 0x0p+0 },
+{ UINT64_C(0x0004202100000000), 0x1.08084p+50, 0x0p+0 },
+{ UINT64_C(0x0004202800000000), 0x1.080ap+50, 0x0p+0 },
+{ UINT64_C(0x0004203000000000), 0x1.080cp+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000000), 0x1.082p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000002), 0x1.0820000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000008), 0x1.082000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000020), 0x1.082000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000040), 0x1.08200000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000080), 0x1.08200000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000000800), 0x1.0820000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000008000), 0x1.082000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000010000), 0x1.082000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000100000), 0x1.08200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004208000400000), 0x1.0820001p+50, 0x0p+0 },
+{ UINT64_C(0x0004208002000000), 0x1.0820008p+50, 0x0p+0 },
+{ UINT64_C(0x0004208004000000), 0x1.082001p+50, 0x0p+0 },
+{ UINT64_C(0x0004208010000000), 0x1.082004p+50, 0x0p+0 },
+{ UINT64_C(0x0004208020000000), 0x1.082008p+50, 0x0p+0 },
+{ UINT64_C(0x0004208080000000), 0x1.08202p+50, 0x0p+0 },
+{ UINT64_C(0x0004208100000000), 0x1.08204p+50, 0x0p+0 },
+{ UINT64_C(0x0004208200000000), 0x1.08208p+50, 0x0p+0 },
+{ UINT64_C(0x000420a000000000), 0x1.0828p+50, 0x0p+0 },
+{ UINT64_C(0x000420c000000000), 0x1.083p+50, 0x0p+0 },
+{ UINT64_C(0x0004280000000000), 0x1.0ap+50, 0x0p+0 },
+{ UINT64_C(0x0004280000000004), 0x1.0a0000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004280000000040), 0x1.0a000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004280000000400), 0x1.0a00000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004280000002000), 0x1.0a00000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004280000020000), 0x1.0a0000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004280000200000), 0x1.0a000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004280002000000), 0x1.0a00008p+50, 0x0p+0 },
+{ UINT64_C(0x0004280010000000), 0x1.0a0004p+50, 0x0p+0 },
+{ UINT64_C(0x0004280100000000), 0x1.0a004p+50, 0x0p+0 },
+{ UINT64_C(0x0004280800000000), 0x1.0a02p+50, 0x0p+0 },
+{ UINT64_C(0x0004281000000000), 0x1.0a04p+50, 0x0p+0 },
+{ UINT64_C(0x0004290000000000), 0x1.0a4p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000004), 0x1.100000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000006), 0x1.1000000000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000040), 0x1.10000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000048), 0x1.100000000012p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000100), 0x1.10000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000104), 0x1.100000000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000110), 0x1.100000000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000400), 0x1.1000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000408), 0x1.100000000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000440), 0x1.10000000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000000500), 0x1.10000000014p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000004000), 0x1.100000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000004008), 0x1.100000001002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000004080), 0x1.10000000102p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000004400), 0x1.1000000011p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000004800), 0x1.1000000012p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000005000), 0x1.1000000014p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000006000), 0x1.1000000018p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010000), 0x1.100000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010001), 0x1.1000000040004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010004), 0x1.100000004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010010), 0x1.100000004004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010080), 0x1.10000000402p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010200), 0x1.10000000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000010400), 0x1.1000000041p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000012000), 0x1.1000000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000020000), 0x1.100000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000020008), 0x1.100000008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000020010), 0x1.100000008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000020100), 0x1.10000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000020800), 0x1.1000000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000021000), 0x1.1000000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000024000), 0x1.100000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000028000), 0x1.10000000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004400000200000), 0x1.10000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000200001), 0x1.1000000800004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000200002), 0x1.1000000800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000200008), 0x1.100000080002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000200040), 0x1.10000008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000200100), 0x1.10000008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000201000), 0x1.1000000804p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000210000), 0x1.100000084p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000240000), 0x1.10000009p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000300000), 0x1.1000000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004400000800000), 0x1.1000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000800002), 0x1.1000002000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000800010), 0x1.100000200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000800100), 0x1.10000020004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000800800), 0x1.1000002002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000808000), 0x1.100000202p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000810000), 0x1.100000204p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000880000), 0x1.10000022p+50, 0x0p+0 },
+{ UINT64_C(0x0004400000900000), 0x1.10000024p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000000), 0x1.1000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000001), 0x1.1000008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000008), 0x1.100000800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000040), 0x1.10000080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000100), 0x1.10000080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000400), 0x1.1000008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002000800), 0x1.1000008002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002002000), 0x1.1000008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002004000), 0x1.100000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002020000), 0x1.100000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002080000), 0x1.10000082p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002200000), 0x1.10000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004400002800000), 0x1.100000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004400010000000), 0x1.100004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010000004), 0x1.100004000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010000040), 0x1.10000400001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010000100), 0x1.10000400004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010000200), 0x1.10000400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010002000), 0x1.1000040008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010008000), 0x1.100004002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010010000), 0x1.100004004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400010100000), 0x1.10000404p+50, 0x0p+0 },
+{ UINT64_C(0x0004400011000000), 0x1.1000044p+50, 0x0p+0 },
+{ UINT64_C(0x0004400012000000), 0x1.1000048p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020000000), 0x1.100008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020000008), 0x1.100008000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020000020), 0x1.100008000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020000080), 0x1.10000800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020000200), 0x1.10000800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020001000), 0x1.1000080004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020002000), 0x1.1000080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020010000), 0x1.100008004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020020000), 0x1.100008008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400020200000), 0x1.10000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004400022000000), 0x1.1000088p+50, 0x0p+0 },
+{ UINT64_C(0x0004400028000000), 0x1.10000ap+50, 0x0p+0 },
+{ UINT64_C(0x0004400030000000), 0x1.10000cp+50, 0x0p+0 },
+{ UINT64_C(0x0004400100000000), 0x1.10004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100000008), 0x1.100040000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100000080), 0x1.10004000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100000800), 0x1.1000400002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100008000), 0x1.100040002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100040000), 0x1.10004001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100200000), 0x1.10004008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400100800000), 0x1.1000402p+50, 0x0p+0 },
+{ UINT64_C(0x0004400102000000), 0x1.1000408p+50, 0x0p+0 },
+{ UINT64_C(0x0004400110000000), 0x1.100044p+50, 0x0p+0 },
+{ UINT64_C(0x0004400120000000), 0x1.100048p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000000), 0x1.10008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000001), 0x1.1000800000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000002), 0x1.1000800000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000010), 0x1.100080000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000100), 0x1.10008000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000400), 0x1.1000800001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200000800), 0x1.1000800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200004000), 0x1.100080001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200020000), 0x1.100080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200040000), 0x1.10008001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400200400000), 0x1.1000801p+50, 0x0p+0 },
+{ UINT64_C(0x0004400202000000), 0x1.1000808p+50, 0x0p+0 },
+{ UINT64_C(0x0004400204000000), 0x1.100081p+50, 0x0p+0 },
+{ UINT64_C(0x0004400208000000), 0x1.100082p+50, 0x0p+0 },
+{ UINT64_C(0x0004400240000000), 0x1.10009p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800000000), 0x1.1002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800000002), 0x1.1002000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800000010), 0x1.100200000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800000040), 0x1.10020000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800000200), 0x1.10020000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800000400), 0x1.1002000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800001000), 0x1.1002000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800008000), 0x1.100200002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800080000), 0x1.10020002p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800100000), 0x1.10020004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400800200000), 0x1.10020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004400801000000), 0x1.1002004p+50, 0x0p+0 },
+{ UINT64_C(0x0004400804000000), 0x1.100201p+50, 0x0p+0 },
+{ UINT64_C(0x0004400820000000), 0x1.100208p+50, 0x0p+0 },
+{ UINT64_C(0x0004400900000000), 0x1.10024p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000000000), 0x1.102p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000000004), 0x1.102000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000000020), 0x1.102000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000000080), 0x1.10200000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000000400), 0x1.1020000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000002000), 0x1.1020000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000008000), 0x1.102000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000020000), 0x1.102000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000100000), 0x1.10200004p+50, 0x0p+0 },
+{ UINT64_C(0x0004408000200000), 0x1.10200008p+50, 0x0p+0 },
+{ UINT64_C(0x0004408002000000), 0x1.1020008p+50, 0x0p+0 },
+{ UINT64_C(0x0004408020000000), 0x1.102008p+50, 0x0p+0 },
+{ UINT64_C(0x0004408080000000), 0x1.10202p+50, 0x0p+0 },
+{ UINT64_C(0x0004408800000000), 0x1.1022p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000000000), 0x1.108p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000000008), 0x1.108000000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000000040), 0x1.10800000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000000080), 0x1.10800000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000000800), 0x1.1080000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000008000), 0x1.108000002p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000010000), 0x1.108000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000080000), 0x1.10800002p+50, 0x0p+0 },
+{ UINT64_C(0x0004420000200000), 0x1.10800008p+50, 0x0p+0 },
+{ UINT64_C(0x0004420002000000), 0x1.1080008p+50, 0x0p+0 },
+{ UINT64_C(0x0004420010000000), 0x1.108004p+50, 0x0p+0 },
+{ UINT64_C(0x0004420100000000), 0x1.10804p+50, 0x0p+0 },
+{ UINT64_C(0x0004420400000000), 0x1.1081p+50, 0x0p+0 },
+{ UINT64_C(0x0004420800000000), 0x1.1082p+50, 0x0p+0 },
+{ UINT64_C(0x0004421000000000), 0x1.1084p+50, 0x0p+0 },
+{ UINT64_C(0x0004428000000000), 0x1.10ap+50, 0x0p+0 },
+{ UINT64_C(0x0004430000000000), 0x1.10cp+50, 0x0p+0 },
+{ UINT64_C(0x0004500000000000), 0x1.14p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000000002), 0x1.1400000000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000000004), 0x1.140000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000000040), 0x1.14000000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000000100), 0x1.14000000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000000400), 0x1.1400000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000002000), 0x1.1400000008p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000010000), 0x1.140000004p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000040000), 0x1.14000001p+50, 0x0p+0 },
+{ UINT64_C(0x0004500000400000), 0x1.1400001p+50, 0x0p+0 },
+{ UINT64_C(0x0004500002000000), 0x1.1400008p+50, 0x0p+0 },
+{ UINT64_C(0x0004500020000000), 0x1.140008p+50, 0x0p+0 },
+{ UINT64_C(0x0004500080000000), 0x1.14002p+50, 0x0p+0 },
+{ UINT64_C(0x0004500400000000), 0x1.1401p+50, 0x0p+0 },
+{ UINT64_C(0x0004502000000000), 0x1.1408p+50, 0x0p+0 },
+{ UINT64_C(0x0004510000000000), 0x1.144p+50, 0x0p+0 },
+{ UINT64_C(0x002000000000000a), 0x1.0000000000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000084), 0x1.0000000000042p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000085), 0x1.0000000000042p+53, 0x1p+0 },
+{ UINT64_C(0x00200000000000c0), 0x1.000000000006p+53, 0x0p+0 },
+{ UINT64_C(0x00200000000000c4), 0x1.0000000000062p+53, 0x0p+0 },
+{ UINT64_C(0x00200000000000d0), 0x1.0000000000068p+53, 0x0p+0 },
+{ UINT64_C(0x00200000000000e0), 0x1.000000000007p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000202), 0x1.0000000000101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000210), 0x1.0000000000108p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000214), 0x1.000000000010ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000240), 0x1.000000000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000244), 0x1.0000000000122p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000250), 0x1.0000000000128p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000260), 0x1.000000000013p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000808), 0x1.0000000000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000809), 0x1.0000000000404p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000000880), 0x1.000000000044p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000882), 0x1.0000000000441p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000884), 0x1.0000000000442p+53, 0x0p+0 },
+{ UINT64_C(0x00200000000008a0), 0x1.000000000045p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000900), 0x1.000000000048p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000902), 0x1.0000000000481p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000920), 0x1.000000000049p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000940), 0x1.00000000004ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000000000980), 0x1.00000000004cp+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002008), 0x1.0000000001004p+53, 0x0p+0 },
+{ UINT64_C(0x002000000000200c), 0x1.0000000001006p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002040), 0x1.000000000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002048), 0x1.0000000001024p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002060), 0x1.000000000103p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002100), 0x1.000000000108p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002108), 0x1.0000000001084p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002140), 0x1.00000000010ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002800), 0x1.00000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002801), 0x1.00000000014p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000002804), 0x1.0000000001402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002820), 0x1.000000000141p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002840), 0x1.000000000142p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000002880), 0x1.000000000144p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000003000), 0x1.00000000018p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000003001), 0x1.00000000018p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000003008), 0x1.0000000001804p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000003080), 0x1.000000000184p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000003200), 0x1.00000000019p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000003800), 0x1.0000000001cp+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020008), 0x1.0000000010004p+53, 0x0p+0 },
+{ UINT64_C(0x002000000002000c), 0x1.0000000010006p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020020), 0x1.000000001001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020021), 0x1.000000001001p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000020024), 0x1.0000000010012p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020080), 0x1.000000001004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020088), 0x1.0000000010044p+53, 0x0p+0 },
+{ UINT64_C(0x00200000000200a0), 0x1.000000001005p+53, 0x0p+0 },
+{ UINT64_C(0x00200000000200c0), 0x1.000000001006p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020100), 0x1.000000001008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020108), 0x1.0000000010084p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020140), 0x1.00000000100ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020200), 0x1.00000000101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020201), 0x1.00000000101p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000020210), 0x1.0000000010108p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020280), 0x1.000000001014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020800), 0x1.00000000104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020801), 0x1.00000000104p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000020804), 0x1.0000000010402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020810), 0x1.0000000010408p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020880), 0x1.000000001044p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000020c00), 0x1.00000000106p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000024000), 0x1.0000000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000024004), 0x1.0000000012002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000024040), 0x1.000000001202p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000024080), 0x1.000000001204p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000024200), 0x1.00000000121p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000025000), 0x1.00000000128p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000026000), 0x1.0000000013p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028000), 0x1.0000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028008), 0x1.0000000014004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028010), 0x1.0000000014008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028040), 0x1.000000001402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028080), 0x1.000000001404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028200), 0x1.00000000141p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000028400), 0x1.00000000142p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000029000), 0x1.00000000148p+53, 0x0p+0 },
+{ UINT64_C(0x002000000002a000), 0x1.0000000015p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030000), 0x1.0000000018p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030001), 0x1.0000000018p+53, 0x1p+0 },
+{ UINT64_C(0x0020000000030004), 0x1.0000000018002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030008), 0x1.0000000018004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030040), 0x1.000000001802p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030080), 0x1.000000001804p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030100), 0x1.000000001808p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030400), 0x1.00000000182p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000030800), 0x1.00000000184p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000038000), 0x1.000000001cp+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200002), 0x1.0000000100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200020), 0x1.000000010001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200028), 0x1.0000000100014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200200), 0x1.00000001001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200204), 0x1.0000000100102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200208), 0x1.0000000100104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000200280), 0x1.000000010014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000202000), 0x1.0000000101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000202008), 0x1.0000000101004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000202010), 0x1.0000000101008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000202080), 0x1.000000010104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000202400), 0x1.00000001012p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000202800), 0x1.00000001014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000204000), 0x1.0000000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000204002), 0x1.0000000102001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000204004), 0x1.0000000102002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000204040), 0x1.000000010202p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000204400), 0x1.00000001022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000206000), 0x1.0000000103p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000220000), 0x1.000000011p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000220002), 0x1.0000000110001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000220010), 0x1.0000000110008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000220100), 0x1.000000011008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000220200), 0x1.00000001101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000220800), 0x1.00000001104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000222000), 0x1.0000000111p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000224000), 0x1.0000000112p+53, 0x0p+0 },
+{ UINT64_C(0x0020000000230000), 0x1.0000000118p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000001), 0x1.00000008p+53, 0x1p+0 },
+{ UINT64_C(0x0020000001000004), 0x1.0000000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000020), 0x1.000000080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000028), 0x1.0000000800014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000040), 0x1.000000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000044), 0x1.0000000800022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000048), 0x1.0000000800024p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000050), 0x1.0000000800028p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000080), 0x1.000000080004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000082), 0x1.0000000800041p+53, 0x0p+0 },
+{ UINT64_C(0x00200000010000a0), 0x1.000000080005p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000400), 0x1.00000008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000402), 0x1.0000000800201p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000404), 0x1.0000000800202p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000410), 0x1.0000000800208p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001000500), 0x1.000000080028p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001001000), 0x1.00000008008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001001002), 0x1.0000000800801p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001001010), 0x1.0000000800808p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001001100), 0x1.000000080088p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001001400), 0x1.0000000800ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000001004000), 0x1.0000000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001004002), 0x1.0000000802001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001004010), 0x1.0000000802008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001004080), 0x1.000000080204p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001004400), 0x1.00000008022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008000), 0x1.0000000804p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008004), 0x1.0000000804002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008010), 0x1.0000000804008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008040), 0x1.000000080402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008080), 0x1.000000080404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008200), 0x1.00000008041p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001008400), 0x1.00000008042p+53, 0x0p+0 },
+{ UINT64_C(0x002000000100a000), 0x1.0000000805p+53, 0x0p+0 },
+{ UINT64_C(0x002000000100c000), 0x1.0000000806p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001020000), 0x1.000000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001020008), 0x1.0000000810004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001020020), 0x1.000000081001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001020200), 0x1.00000008101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001020800), 0x1.00000008104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001024000), 0x1.0000000812p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001030000), 0x1.0000000818p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080000), 0x1.000000084p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080004), 0x1.0000000840002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080008), 0x1.0000000840004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080080), 0x1.000000084004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080100), 0x1.000000084008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080200), 0x1.00000008401p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001080400), 0x1.00000008402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001082000), 0x1.0000000841p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001090000), 0x1.0000000848p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001100000), 0x1.000000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001100004), 0x1.0000000880002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001100010), 0x1.0000000880008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001100080), 0x1.000000088004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001100100), 0x1.000000088008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001100400), 0x1.00000008802p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001102000), 0x1.0000000881p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001108000), 0x1.0000000884p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001140000), 0x1.00000008ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000001400000), 0x1.0000000ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000001400004), 0x1.0000000a00002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001400010), 0x1.0000000a00008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001400020), 0x1.0000000a0001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001400200), 0x1.0000000a001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001400800), 0x1.0000000a004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001404000), 0x1.0000000a02p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001440000), 0x1.0000000a2p+53, 0x0p+0 },
+{ UINT64_C(0x0020000001600000), 0x1.0000000bp+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000002), 0x1.0000004000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000003), 0x1.0000004000002p+53, -0x1p+0 },
+{ UINT64_C(0x0020000008000008), 0x1.0000004000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000009), 0x1.0000004000004p+53, 0x1p+0 },
+{ UINT64_C(0x002000000800000a), 0x1.0000004000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000040), 0x1.000000400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000042), 0x1.0000004000021p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000048), 0x1.0000004000024p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000400), 0x1.00000040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000402), 0x1.0000004000201p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000404), 0x1.0000004000202p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000420), 0x1.000000400021p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008000440), 0x1.000000400022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008002000), 0x1.0000004001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008002008), 0x1.0000004001004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008002040), 0x1.000000400102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008002080), 0x1.000000400104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008002100), 0x1.000000400108p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008002200), 0x1.00000040011p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008010000), 0x1.0000004008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008010004), 0x1.0000004008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008010020), 0x1.000000400801p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008010080), 0x1.000000400804p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008010100), 0x1.000000400808p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008011000), 0x1.00000040088p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008012000), 0x1.0000004009p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008018000), 0x1.000000400cp+53, 0x0p+0 },
+{ UINT64_C(0x0020000008080000), 0x1.000000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008080001), 0x1.000000404p+53, 0x1p+0 },
+{ UINT64_C(0x0020000008080002), 0x1.0000004040001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008080004), 0x1.0000004040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008080020), 0x1.000000404001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008080200), 0x1.00000040401p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008080800), 0x1.00000040404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008088000), 0x1.0000004044p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008200000), 0x1.00000041p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008200002), 0x1.0000004100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008200020), 0x1.000000410001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008200200), 0x1.00000041001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008200400), 0x1.00000041002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008204000), 0x1.0000004102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008208000), 0x1.0000004104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008220000), 0x1.000000411p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008300000), 0x1.000000418p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008800000), 0x1.00000044p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008800008), 0x1.0000004400004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008800020), 0x1.000000440001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008800100), 0x1.000000440008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008801000), 0x1.00000044008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008804000), 0x1.0000004402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008820000), 0x1.000000441p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008840000), 0x1.000000442p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008a00000), 0x1.00000045p+53, 0x0p+0 },
+{ UINT64_C(0x0020000008c00000), 0x1.00000046p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a000000), 0x1.0000005p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a000001), 0x1.0000005p+53, 0x1p+0 },
+{ UINT64_C(0x002000000a000002), 0x1.0000005000001p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a000008), 0x1.0000005000004p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a000080), 0x1.000000500004p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a000800), 0x1.00000050004p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a004000), 0x1.0000005002p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a040000), 0x1.000000502p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a400000), 0x1.00000052p+53, 0x0p+0 },
+{ UINT64_C(0x002000000a800000), 0x1.00000054p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000008), 0x1.0000010000004p+53, 0x0p+0 },
+{ UINT64_C(0x002000002000000a), 0x1.0000010000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000080), 0x1.000001000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000084), 0x1.0000010000042p+53, 0x0p+0 },
+{ UINT64_C(0x00200000200000c0), 0x1.000001000006p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000200), 0x1.00000100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000204), 0x1.0000010000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000208), 0x1.0000010000104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000240), 0x1.000001000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000400), 0x1.00000100002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000402), 0x1.0000010000201p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000410), 0x1.0000010000208p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020000440), 0x1.000001000022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020004000), 0x1.0000010002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020004001), 0x1.0000010002p+53, 0x1p+0 },
+{ UINT64_C(0x0020000020004002), 0x1.0000010002001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020004008), 0x1.0000010002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020004040), 0x1.000001000202p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020004400), 0x1.00000100022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020006000), 0x1.0000010003p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020040000), 0x1.000001002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020040001), 0x1.000001002p+53, 0x1p+0 },
+{ UINT64_C(0x0020000020040010), 0x1.0000010020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020040080), 0x1.000001002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020040100), 0x1.000001002008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020040800), 0x1.00000100204p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020048000), 0x1.0000010024p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020050000), 0x1.0000010028p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020400000), 0x1.00000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020400002), 0x1.0000010200001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020400020), 0x1.000001020001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020400080), 0x1.000001020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020400100), 0x1.000001020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020400800), 0x1.00000102004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020402000), 0x1.0000010201p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020410000), 0x1.0000010208p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020500000), 0x1.000001028p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020800000), 0x1.00000104p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020800004), 0x1.0000010400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020800008), 0x1.0000010400004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020800040), 0x1.000001040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020800400), 0x1.00000104002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020800800), 0x1.00000104004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020801000), 0x1.00000104008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020808000), 0x1.0000010404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020820000), 0x1.000001041p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020840000), 0x1.000001042p+53, 0x0p+0 },
+{ UINT64_C(0x0020000020c00000), 0x1.00000106p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028000000), 0x1.0000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028000002), 0x1.0000014000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028000020), 0x1.000001400001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028000200), 0x1.00000140001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028001000), 0x1.00000140008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028008000), 0x1.0000014004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028010000), 0x1.0000014008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028100000), 0x1.000001408p+53, 0x0p+0 },
+{ UINT64_C(0x0020000028800000), 0x1.00000144p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000004), 0x1.0000080000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000008), 0x1.0000080000004p+53, 0x0p+0 },
+{ UINT64_C(0x002000010000000c), 0x1.0000080000006p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000020), 0x1.000008000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000028), 0x1.0000080000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000200), 0x1.00000800001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000202), 0x1.0000080000101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000210), 0x1.0000080000108p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000220), 0x1.000008000011p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000280), 0x1.000008000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000400), 0x1.00000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000404), 0x1.0000080000202p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000410), 0x1.0000080000208p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100000500), 0x1.000008000028p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100002000), 0x1.0000080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100002004), 0x1.0000080001002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100002020), 0x1.000008000101p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100002040), 0x1.000008000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100002200), 0x1.00000800011p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100003000), 0x1.00000800018p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100010000), 0x1.0000080008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100010001), 0x1.0000080008p+53, 0x1p+0 },
+{ UINT64_C(0x0020000100010008), 0x1.0000080008004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100010010), 0x1.0000080008008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100010020), 0x1.000008000801p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100010200), 0x1.00000800081p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100012000), 0x1.0000080009p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100018000), 0x1.000008000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020000100040000), 0x1.000008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100040004), 0x1.0000080020002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100040040), 0x1.000008002002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100040080), 0x1.000008002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100040800), 0x1.00000800204p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100041000), 0x1.00000800208p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100044000), 0x1.0000080022p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100060000), 0x1.000008003p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100080000), 0x1.000008004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100080004), 0x1.0000080040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100080040), 0x1.000008004002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100080100), 0x1.000008004008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100080200), 0x1.00000800401p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100082000), 0x1.0000080041p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100088000), 0x1.0000080044p+53, 0x0p+0 },
+{ UINT64_C(0x00200001000c0000), 0x1.000008006p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100800000), 0x1.00000804p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100800001), 0x1.00000804p+53, 0x1p+0 },
+{ UINT64_C(0x0020000100800002), 0x1.0000080400001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100800004), 0x1.0000080400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100800008), 0x1.0000080400004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100800080), 0x1.000008040004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100800400), 0x1.00000804002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100804000), 0x1.0000080402p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100840000), 0x1.000008042p+53, 0x0p+0 },
+{ UINT64_C(0x0020000100c00000), 0x1.00000806p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108000000), 0x1.0000084p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108000002), 0x1.0000084000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108000010), 0x1.0000084000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108000100), 0x1.000008400008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108001000), 0x1.00000840008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108002000), 0x1.0000084001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108010000), 0x1.0000084008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108080000), 0x1.000008404p+53, 0x0p+0 },
+{ UINT64_C(0x0020000108800000), 0x1.00000844p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120000000), 0x1.000009p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120000001), 0x1.000009p+53, 0x1p+0 },
+{ UINT64_C(0x0020000120000002), 0x1.0000090000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120000004), 0x1.0000090000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120000040), 0x1.000009000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120000100), 0x1.000009000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120000400), 0x1.00000900002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120004000), 0x1.0000090002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120040000), 0x1.000009002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120100000), 0x1.000009008p+53, 0x0p+0 },
+{ UINT64_C(0x0020000120400000), 0x1.00000902p+53, 0x0p+0 },
+{ UINT64_C(0x0020000122000000), 0x1.0000091p+53, 0x0p+0 },
+{ UINT64_C(0x0020000130000000), 0x1.0000098p+53, 0x0p+0 },
+{ UINT64_C(0x0020000140000000), 0x1.00000ap+53, 0x0p+0 },
+{ UINT64_C(0x0020000140000008), 0x1.00000a0000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000140000080), 0x1.00000a000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000140000800), 0x1.00000a00004p+53, 0x0p+0 },
+{ UINT64_C(0x0020000140004000), 0x1.00000a0002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000140040000), 0x1.00000a002p+53, 0x0p+0 },
+{ UINT64_C(0x0020000140400000), 0x1.00000a02p+53, 0x0p+0 },
+{ UINT64_C(0x0020000142000000), 0x1.00000a1p+53, 0x0p+0 },
+{ UINT64_C(0x0020000160000000), 0x1.00000bp+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000008), 0x1.0000800000004p+53, 0x0p+0 },
+{ UINT64_C(0x002000100000000a), 0x1.0000800000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000080), 0x1.000080000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000088), 0x1.0000800000044p+53, 0x0p+0 },
+{ UINT64_C(0x00200010000000c0), 0x1.000080000006p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000800), 0x1.00008000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000802), 0x1.0000800000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000804), 0x1.0000800000402p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000808), 0x1.0000800000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000820), 0x1.000080000041p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000900), 0x1.000080000048p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000000a00), 0x1.00008000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000004000), 0x1.0000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000004008), 0x1.0000800002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000004010), 0x1.0000800002008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000004100), 0x1.000080000208p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000005000), 0x1.00008000028p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000010000), 0x1.0000800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000010004), 0x1.0000800008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000010040), 0x1.000080000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000010100), 0x1.000080000808p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000011000), 0x1.00008000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000012000), 0x1.0000800009p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000100000), 0x1.000080008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000100001), 0x1.000080008p+53, 0x1p+0 },
+{ UINT64_C(0x0020001000100010), 0x1.0000800080008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000100040), 0x1.000080008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000100400), 0x1.00008000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000101000), 0x1.00008000808p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000102000), 0x1.0000800081p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000108000), 0x1.0000800084p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000140000), 0x1.00008000ap+53, 0x0p+0 },
+{ UINT64_C(0x0020001000180000), 0x1.00008000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020001000800000), 0x1.00008004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000800004), 0x1.0000800400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000800040), 0x1.000080040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000800100), 0x1.000080040008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000800800), 0x1.00008004004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000801000), 0x1.00008004008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000810000), 0x1.0000800408p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000880000), 0x1.000080044p+53, 0x0p+0 },
+{ UINT64_C(0x0020001000c00000), 0x1.00008006p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004000000), 0x1.0000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004000004), 0x1.0000802000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004000040), 0x1.000080200002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004000080), 0x1.000080200004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004000400), 0x1.00008020002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004002000), 0x1.0000802001p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004004000), 0x1.0000802002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004020000), 0x1.000080201p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004100000), 0x1.000080208p+53, 0x0p+0 },
+{ UINT64_C(0x0020001004800000), 0x1.00008024p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000000), 0x1.000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000002), 0x1.0000810000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000010), 0x1.0000810000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000040), 0x1.000081000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000100), 0x1.000081000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000200), 0x1.00008100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020000800), 0x1.00008100004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020008000), 0x1.0000810004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020080000), 0x1.000081004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020200000), 0x1.00008101p+53, 0x0p+0 },
+{ UINT64_C(0x0020001020400000), 0x1.00008102p+53, 0x0p+0 },
+{ UINT64_C(0x0020001022000000), 0x1.0000811p+53, 0x0p+0 },
+{ UINT64_C(0x0020001030000000), 0x1.0000818p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100000000), 0x1.000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100000008), 0x1.0000880000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100000080), 0x1.000088000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100000800), 0x1.00008800004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100008000), 0x1.0000880004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100080000), 0x1.000088004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001100400000), 0x1.00008802p+53, 0x0p+0 },
+{ UINT64_C(0x0020001104000000), 0x1.0000882p+53, 0x0p+0 },
+{ UINT64_C(0x0020001140000000), 0x1.00008ap+53, 0x0p+0 },
+{ UINT64_C(0x0020001180000000), 0x1.00008cp+53, 0x0p+0 },
+{ UINT64_C(0x0020001200000000), 0x1.00009p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200000008), 0x1.0000900000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200000080), 0x1.000090000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200000800), 0x1.00009000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200004000), 0x1.0000900002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200020000), 0x1.000090001p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200040000), 0x1.000090002p+53, 0x0p+0 },
+{ UINT64_C(0x0020001200200000), 0x1.00009001p+53, 0x0p+0 },
+{ UINT64_C(0x0020001202000000), 0x1.0000901p+53, 0x0p+0 },
+{ UINT64_C(0x0020001204000000), 0x1.0000902p+53, 0x0p+0 },
+{ UINT64_C(0x0020001220000000), 0x1.000091p+53, 0x0p+0 },
+{ UINT64_C(0x0020001240000000), 0x1.000092p+53, 0x0p+0 },
+{ UINT64_C(0x0020001280000000), 0x1.000094p+53, 0x0p+0 },
+{ UINT64_C(0x0020001300000000), 0x1.000098p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000001), 0x1.0008p+53, 0x1p+0 },
+{ UINT64_C(0x0020010000000004), 0x1.0008000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000006), 0x1.0008000000003p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000008), 0x1.0008000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000009), 0x1.0008000000004p+53, 0x1p+0 },
+{ UINT64_C(0x0020010000000010), 0x1.0008000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000014), 0x1.000800000000ap+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000100), 0x1.000800000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000101), 0x1.000800000008p+53, 0x1p+0 },
+{ UINT64_C(0x0020010000000110), 0x1.0008000000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000180), 0x1.00080000000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000800), 0x1.00080000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000802), 0x1.0008000000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000804), 0x1.0008000000402p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000840), 0x1.000800000042p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000000a00), 0x1.00080000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000001000), 0x1.00080000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000001002), 0x1.0008000000801p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000001020), 0x1.000800000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000001200), 0x1.00080000009p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000004000), 0x1.0008000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000004008), 0x1.0008000002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000004080), 0x1.000800000204p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000004400), 0x1.00080000022p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000006000), 0x1.0008000003p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040000), 0x1.000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040004), 0x1.0008000020002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040008), 0x1.0008000020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040010), 0x1.0008000020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040040), 0x1.000800002002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040100), 0x1.000800002008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040200), 0x1.00080000201p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000040800), 0x1.00080000204p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000044000), 0x1.0008000022p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000400000), 0x1.00080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000400004), 0x1.0008000200002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000400020), 0x1.000800020001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000400100), 0x1.000800020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000400200), 0x1.00080002001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000400400), 0x1.00080002002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000404000), 0x1.0008000202p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000420000), 0x1.000800021p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000440000), 0x1.000800022p+53, 0x0p+0 },
+{ UINT64_C(0x0020010000480000), 0x1.000800024p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002000000), 0x1.0008001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002000008), 0x1.0008001000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002000040), 0x1.000800100002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002000100), 0x1.000800100008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002000400), 0x1.00080010002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002002000), 0x1.0008001001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002020000), 0x1.000800101p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002040000), 0x1.000800102p+53, 0x0p+0 },
+{ UINT64_C(0x0020010002100000), 0x1.000800108p+53, 0x0p+0 },
+{ UINT64_C(0x0020010003000000), 0x1.00080018p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020000000), 0x1.000801p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020000002), 0x1.0008010000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020000008), 0x1.0008010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020000010), 0x1.0008010000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020000040), 0x1.000801000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020000400), 0x1.00080100002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020004000), 0x1.0008010002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020010000), 0x1.0008010008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020020000), 0x1.000801001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020200000), 0x1.00080101p+53, 0x0p+0 },
+{ UINT64_C(0x0020010020800000), 0x1.00080104p+53, 0x0p+0 },
+{ UINT64_C(0x0020010028000000), 0x1.0008014p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000000), 0x1.000808p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000002), 0x1.0008080000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000010), 0x1.0008080000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000020), 0x1.000808000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000100), 0x1.000808000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000200), 0x1.00080800001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100000800), 0x1.00080800004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100008000), 0x1.0008080004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100020000), 0x1.000808001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100040000), 0x1.000808002p+53, 0x0p+0 },
+{ UINT64_C(0x0020010100200000), 0x1.00080801p+53, 0x0p+0 },
+{ UINT64_C(0x0020010101000000), 0x1.00080808p+53, 0x0p+0 },
+{ UINT64_C(0x0020010108000000), 0x1.0008084p+53, 0x0p+0 },
+{ UINT64_C(0x0020010180000000), 0x1.00080cp+53, 0x0p+0 },
+{ UINT64_C(0x0020010800000000), 0x1.00084p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800000001), 0x1.00084p+53, 0x1p+0 },
+{ UINT64_C(0x0020010800000010), 0x1.0008400000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800000100), 0x1.000840000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800001000), 0x1.00084000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800008000), 0x1.0008400004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800010000), 0x1.0008400008p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800020000), 0x1.000840001p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800080000), 0x1.000840004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010800800000), 0x1.00084004p+53, 0x0p+0 },
+{ UINT64_C(0x0020010804000000), 0x1.0008402p+53, 0x0p+0 },
+{ UINT64_C(0x0020010840000000), 0x1.000842p+53, 0x0p+0 },
+{ UINT64_C(0x0020010880000000), 0x1.000844p+53, 0x0p+0 },
+{ UINT64_C(0x0020010900000000), 0x1.000848p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000000000), 0x1.0009p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000000004), 0x1.0009000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000000008), 0x1.0009000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000000080), 0x1.000900000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000000100), 0x1.000900000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000000800), 0x1.00090000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000002000), 0x1.0009000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000008000), 0x1.0009000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000080000), 0x1.000900004p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000100000), 0x1.000900008p+53, 0x0p+0 },
+{ UINT64_C(0x0020012000400000), 0x1.00090002p+53, 0x0p+0 },
+{ UINT64_C(0x0020012002000000), 0x1.0009001p+53, 0x0p+0 },
+{ UINT64_C(0x0020012010000000), 0x1.0009008p+53, 0x0p+0 },
+{ UINT64_C(0x0020012100000000), 0x1.000908p+53, 0x0p+0 },
+{ UINT64_C(0x0020012200000000), 0x1.00091p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000008), 0x1.0080000000004p+53, 0x0p+0 },
+{ UINT64_C(0x002010000000000a), 0x1.0080000000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000020), 0x1.008000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000028), 0x1.0080000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000200), 0x1.00800000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000204), 0x1.0080000000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000210), 0x1.0080000000108p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000240), 0x1.008000000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000000280), 0x1.008000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000001000), 0x1.00800000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000001004), 0x1.0080000000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000001020), 0x1.008000000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000001200), 0x1.00800000009p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000001800), 0x1.0080000000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020100000008000), 0x1.0080000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000008008), 0x1.0080000004004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000008040), 0x1.008000000402p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000008080), 0x1.008000000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000008100), 0x1.008000000408p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000009000), 0x1.00800000048p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000020000), 0x1.008000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000020002), 0x1.0080000010001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000020020), 0x1.008000001001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000020200), 0x1.00800000101p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000020400), 0x1.00800000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000022000), 0x1.0080000011p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000030000), 0x1.0080000018p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000080000), 0x1.008000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000080001), 0x1.008000004p+53, 0x1p+0 },
+{ UINT64_C(0x0020100000080004), 0x1.0080000040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000080040), 0x1.008000004002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000080200), 0x1.00800000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000080800), 0x1.00800000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000084000), 0x1.0080000042p+53, 0x0p+0 },
+{ UINT64_C(0x00201000000c0000), 0x1.008000006p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400000), 0x1.00800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400004), 0x1.0080000200002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400008), 0x1.0080000200004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400080), 0x1.008000020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400200), 0x1.00800002001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400400), 0x1.00800002002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000400800), 0x1.00800002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000404000), 0x1.0080000202p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000408000), 0x1.0080000204p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000420000), 0x1.008000021p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000500000), 0x1.008000028p+53, 0x0p+0 },
+{ UINT64_C(0x0020100000600000), 0x1.00800003p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000000), 0x1.00800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000002), 0x1.0080000800001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000004), 0x1.0080000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000020), 0x1.008000080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000040), 0x1.008000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000200), 0x1.00800008001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001000400), 0x1.00800008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001002000), 0x1.0080000801p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001004000), 0x1.0080000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001020000), 0x1.008000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001200000), 0x1.00800009p+53, 0x0p+0 },
+{ UINT64_C(0x0020100001800000), 0x1.0080000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020100004000000), 0x1.0080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004000002), 0x1.0080002000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004000008), 0x1.0080002000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004000020), 0x1.008000200001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004000100), 0x1.008000200008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004001000), 0x1.00800020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004010000), 0x1.0080002008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004020000), 0x1.008000201p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004080000), 0x1.008000204p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004100000), 0x1.008000208p+53, 0x0p+0 },
+{ UINT64_C(0x0020100004800000), 0x1.00800024p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040000000), 0x1.008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040000001), 0x1.008002p+53, 0x1p+0 },
+{ UINT64_C(0x0020100040000010), 0x1.0080020000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040000040), 0x1.008002000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040000100), 0x1.008002000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040000800), 0x1.00800200004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040002000), 0x1.0080020001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040004000), 0x1.0080020002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040008000), 0x1.0080020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040040000), 0x1.008002002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040200000), 0x1.00800201p+53, 0x0p+0 },
+{ UINT64_C(0x0020100040400000), 0x1.00800202p+53, 0x0p+0 },
+{ UINT64_C(0x0020100042000000), 0x1.0080021p+53, 0x0p+0 },
+{ UINT64_C(0x0020100060000000), 0x1.008003p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080000000), 0x1.008004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080000002), 0x1.0080040000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080000020), 0x1.008004000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080000100), 0x1.008004000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080000200), 0x1.00800400001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080000400), 0x1.00800400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080004000), 0x1.0080040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080020000), 0x1.008004001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080080000), 0x1.008004004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100080400000), 0x1.00800402p+53, 0x0p+0 },
+{ UINT64_C(0x0020100082000000), 0x1.0080041p+53, 0x0p+0 },
+{ UINT64_C(0x00201000a0000000), 0x1.008005p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100000000), 0x1.008008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100000004), 0x1.0080080000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100000040), 0x1.008008000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100000100), 0x1.008008000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100001000), 0x1.00800800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100004000), 0x1.0080080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100040000), 0x1.008008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100100400000), 0x1.00800802p+53, 0x0p+0 },
+{ UINT64_C(0x0020100104000000), 0x1.0080082p+53, 0x0p+0 },
+{ UINT64_C(0x0020100110000000), 0x1.0080088p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400000000), 0x1.00802p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400000008), 0x1.0080200000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400000040), 0x1.008020000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400000200), 0x1.00802000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400001000), 0x1.00802000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400002000), 0x1.0080200001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400008000), 0x1.0080200004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400020000), 0x1.008020001p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400040000), 0x1.008020002p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400080000), 0x1.008020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100400800000), 0x1.00802004p+53, 0x0p+0 },
+{ UINT64_C(0x0020100401000000), 0x1.00802008p+53, 0x0p+0 },
+{ UINT64_C(0x0020100410000000), 0x1.0080208p+53, 0x0p+0 },
+{ UINT64_C(0x0020100420000000), 0x1.008021p+53, 0x0p+0 },
+{ UINT64_C(0x0020100600000000), 0x1.00803p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000000000), 0x1.0081p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000000004), 0x1.0081000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000000008), 0x1.0081000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000000020), 0x1.008100000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000000080), 0x1.008100000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000000800), 0x1.00810000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000002000), 0x1.0081000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000004000), 0x1.0081000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000010000), 0x1.0081000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000020000), 0x1.008100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000040000), 0x1.008100002p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000080000), 0x1.008100004p+53, 0x0p+0 },
+{ UINT64_C(0x0020102000100000), 0x1.008100008p+53, 0x0p+0 },
+{ UINT64_C(0x0020102001000000), 0x1.00810008p+53, 0x0p+0 },
+{ UINT64_C(0x0020102010000000), 0x1.0081008p+53, 0x0p+0 },
+{ UINT64_C(0x0020102020000000), 0x1.008101p+53, 0x0p+0 },
+{ UINT64_C(0x0020102080000000), 0x1.008104p+53, 0x0p+0 },
+{ UINT64_C(0x0020102800000000), 0x1.00814p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000000000), 0x1.0084p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000000002), 0x1.0084000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000000004), 0x1.0084000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000000020), 0x1.008400000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000000200), 0x1.00840000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000002000), 0x1.0084000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000004000), 0x1.0084000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000020000), 0x1.008400001p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000040000), 0x1.008400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020108000400000), 0x1.00840002p+53, 0x0p+0 },
+{ UINT64_C(0x0020108004000000), 0x1.0084002p+53, 0x0p+0 },
+{ UINT64_C(0x0020108020000000), 0x1.008401p+53, 0x0p+0 },
+{ UINT64_C(0x0020108040000000), 0x1.008402p+53, 0x0p+0 },
+{ UINT64_C(0x0020108080000000), 0x1.008404p+53, 0x0p+0 },
+{ UINT64_C(0x0020108100000000), 0x1.008408p+53, 0x0p+0 },
+{ UINT64_C(0x0020108800000000), 0x1.00844p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000000000), 0x1.00cp+53, 0x0p+0 },
+{ UINT64_C(0x0020180000000008), 0x1.00c0000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000000020), 0x1.00c000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000000100), 0x1.00c000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000000400), 0x1.00c00000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000002000), 0x1.00c0000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000004000), 0x1.00c0000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000008000), 0x1.00c0000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000040000), 0x1.00c000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020180000400000), 0x1.00c00002p+53, 0x0p+0 },
+{ UINT64_C(0x0020180001000000), 0x1.00c00008p+53, 0x0p+0 },
+{ UINT64_C(0x0020180002000000), 0x1.00c0001p+53, 0x0p+0 },
+{ UINT64_C(0x0020180010000000), 0x1.00c0008p+53, 0x0p+0 },
+{ UINT64_C(0x0020180020000000), 0x1.00c001p+53, 0x0p+0 },
+{ UINT64_C(0x0020180040000000), 0x1.00c002p+53, 0x0p+0 },
+{ UINT64_C(0x0020180200000000), 0x1.00c01p+53, 0x0p+0 },
+{ UINT64_C(0x0020182000000000), 0x1.00c1p+53, 0x0p+0 },
+{ UINT64_C(0x0020190000000000), 0x1.00c8p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000004), 0x1.0100000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000005), 0x1.0100000000002p+53, 0x1p+0 },
+{ UINT64_C(0x0020200000000020), 0x1.010000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000022), 0x1.0100000000011p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000040), 0x1.010000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000044), 0x1.0100000000022p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000100), 0x1.010000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000102), 0x1.0100000000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000110), 0x1.0100000000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000180), 0x1.01000000000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000800), 0x1.01000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000802), 0x1.0100000000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000808), 0x1.0100000000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000880), 0x1.010000000044p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000a00), 0x1.01000000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000000c00), 0x1.01000000006p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000002000), 0x1.0100000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000002008), 0x1.0100000001004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000002080), 0x1.010000000104p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000002100), 0x1.010000000108p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000003000), 0x1.01000000018p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000020000), 0x1.010000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000020008), 0x1.0100000010004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000020080), 0x1.010000001004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000020800), 0x1.01000000104p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000024000), 0x1.0100000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000040000), 0x1.010000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000040008), 0x1.0100000020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000040010), 0x1.0100000020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000040020), 0x1.010000002001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000040200), 0x1.01000000201p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000041000), 0x1.01000000208p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000044000), 0x1.0100000022p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000100000), 0x1.010000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000100004), 0x1.0100000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000100040), 0x1.010000008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000100400), 0x1.01000000802p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000101000), 0x1.01000000808p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000102000), 0x1.0100000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000108000), 0x1.0100000084p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000110000), 0x1.0100000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000120000), 0x1.010000009p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000180000), 0x1.01000000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020200000400000), 0x1.01000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000400002), 0x1.0100000200001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000400010), 0x1.0100000200008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000400080), 0x1.010000020004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000400400), 0x1.01000002002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000404000), 0x1.0100000202p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000420000), 0x1.010000021p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000480000), 0x1.010000024p+53, 0x0p+0 },
+{ UINT64_C(0x0020200000600000), 0x1.01000003p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002000000), 0x1.0100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002000001), 0x1.0100001p+53, 0x1p+0 },
+{ UINT64_C(0x0020200002000004), 0x1.0100001000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002000008), 0x1.0100001000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002000010), 0x1.0100001000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002000100), 0x1.010000100008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002000400), 0x1.01000010002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002004000), 0x1.0100001002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002010000), 0x1.0100001008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002040000), 0x1.010000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020200002400000), 0x1.01000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020200003000000), 0x1.01000018p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010000000), 0x1.0100008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010000001), 0x1.0100008p+53, 0x1p+0 },
+{ UINT64_C(0x0020200010000008), 0x1.0100008000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010000080), 0x1.010000800004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010000100), 0x1.010000800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010000200), 0x1.01000080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010002000), 0x1.0100008001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010008000), 0x1.0100008004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010080000), 0x1.010000804p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010200000), 0x1.01000081p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010400000), 0x1.01000082p+53, 0x0p+0 },
+{ UINT64_C(0x0020200010800000), 0x1.01000084p+53, 0x0p+0 },
+{ UINT64_C(0x0020200012000000), 0x1.0100009p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080000000), 0x1.010004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080000004), 0x1.0100040000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080000040), 0x1.010004000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080000100), 0x1.010004000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080001000), 0x1.01000400008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080010000), 0x1.0100040008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080040000), 0x1.010004002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200080200000), 0x1.01000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020200081000000), 0x1.01000408p+53, 0x0p+0 },
+{ UINT64_C(0x0020200082000000), 0x1.0100041p+53, 0x0p+0 },
+{ UINT64_C(0x00202000a0000000), 0x1.010005p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200000000), 0x1.01001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200000001), 0x1.01001p+53, 0x1p+0 },
+{ UINT64_C(0x0020200200000010), 0x1.0100100000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200000080), 0x1.010010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200000400), 0x1.01001000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200004000), 0x1.0100100002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200020000), 0x1.010010001p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200040000), 0x1.010010002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200200400000), 0x1.01001002p+53, 0x0p+0 },
+{ UINT64_C(0x0020200202000000), 0x1.0100101p+53, 0x0p+0 },
+{ UINT64_C(0x0020200220000000), 0x1.010011p+53, 0x0p+0 },
+{ UINT64_C(0x0020200300000000), 0x1.010018p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000000000), 0x1.01008p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000000008), 0x1.0100800000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000000010), 0x1.0100800000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000000080), 0x1.010080000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000000200), 0x1.01008000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000000400), 0x1.01008000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000004000), 0x1.0100800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000020000), 0x1.010080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000080000), 0x1.010080004p+53, 0x0p+0 },
+{ UINT64_C(0x0020201000200000), 0x1.01008001p+53, 0x0p+0 },
+{ UINT64_C(0x0020201002000000), 0x1.0100801p+53, 0x0p+0 },
+{ UINT64_C(0x0020201008000000), 0x1.0100804p+53, 0x0p+0 },
+{ UINT64_C(0x0020201020000000), 0x1.010081p+53, 0x0p+0 },
+{ UINT64_C(0x0020201200000000), 0x1.01009p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000000000), 0x1.0102p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000000004), 0x1.0102000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000000040), 0x1.010200000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000000400), 0x1.01020000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000000800), 0x1.01020000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000004000), 0x1.0102000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000008000), 0x1.0102000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000020000), 0x1.010200001p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000040000), 0x1.010200002p+53, 0x0p+0 },
+{ UINT64_C(0x0020204000200000), 0x1.01020001p+53, 0x0p+0 },
+{ UINT64_C(0x0020204001000000), 0x1.01020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020204002000000), 0x1.0102001p+53, 0x0p+0 },
+{ UINT64_C(0x0020204020000000), 0x1.010201p+53, 0x0p+0 },
+{ UINT64_C(0x0020204080000000), 0x1.010204p+53, 0x0p+0 },
+{ UINT64_C(0x0020204100000000), 0x1.010208p+53, 0x0p+0 },
+{ UINT64_C(0x0020204800000000), 0x1.01024p+53, 0x0p+0 },
+{ UINT64_C(0x0020206000000000), 0x1.0103p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000000000), 0x1.012p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000000004), 0x1.0120000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000000040), 0x1.012000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000000080), 0x1.012000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000000200), 0x1.01200000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000000800), 0x1.01200000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000008000), 0x1.0120000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000080000), 0x1.012000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020240000200000), 0x1.01200001p+53, 0x0p+0 },
+{ UINT64_C(0x0020240002000000), 0x1.0120001p+53, 0x0p+0 },
+{ UINT64_C(0x0020240020000000), 0x1.012001p+53, 0x0p+0 },
+{ UINT64_C(0x0020240040000000), 0x1.012002p+53, 0x0p+0 },
+{ UINT64_C(0x0020240080000000), 0x1.012004p+53, 0x0p+0 },
+{ UINT64_C(0x0020240200000000), 0x1.01201p+53, 0x0p+0 },
+{ UINT64_C(0x0020240400000000), 0x1.01202p+53, 0x0p+0 },
+{ UINT64_C(0x0020244000000000), 0x1.0122p+53, 0x0p+0 },
+{ UINT64_C(0x0020260000000000), 0x1.013p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000002), 0x1.0400000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000010), 0x1.0400000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000014), 0x1.040000000000ap+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000020), 0x1.040000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000028), 0x1.0400000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000080), 0x1.040000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000084), 0x1.0400000000042p+53, 0x0p+0 },
+{ UINT64_C(0x00208000000000a0), 0x1.040000000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000400), 0x1.04000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000401), 0x1.04000000002p+53, 0x1p+0 },
+{ UINT64_C(0x0020800000000402), 0x1.0400000000201p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000408), 0x1.0400000000204p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000420), 0x1.040000000021p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000480), 0x1.040000000024p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000500), 0x1.040000000028p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000000600), 0x1.04000000003p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000002000), 0x1.0400000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000002004), 0x1.0400000001002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000002010), 0x1.0400000001008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000002040), 0x1.040000000102p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000002100), 0x1.040000000108p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000002400), 0x1.04000000012p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000003000), 0x1.04000000018p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000008000), 0x1.0400000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000008001), 0x1.0400000004p+53, 0x1p+0 },
+{ UINT64_C(0x0020800000008008), 0x1.0400000004004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000008020), 0x1.040000000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000008040), 0x1.040000000402p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000008100), 0x1.040000000408p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000008400), 0x1.04000000042p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000009000), 0x1.04000000048p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000080000), 0x1.040000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000080004), 0x1.0400000040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000080010), 0x1.0400000040008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000080100), 0x1.040000004008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000080400), 0x1.04000000402p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000082000), 0x1.0400000041p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000090000), 0x1.0400000048p+53, 0x0p+0 },
+{ UINT64_C(0x00208000000a0000), 0x1.040000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000400000), 0x1.04000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000400001), 0x1.04000002p+53, 0x1p+0 },
+{ UINT64_C(0x0020800000400004), 0x1.0400000200002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000400010), 0x1.0400000200008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000400100), 0x1.040000020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000400800), 0x1.04000002004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000408000), 0x1.0400000204p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000480000), 0x1.040000024p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000500000), 0x1.040000028p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000800000), 0x1.04000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000800001), 0x1.04000004p+53, 0x1p+0 },
+{ UINT64_C(0x0020800000800004), 0x1.0400000400002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000800020), 0x1.040000040001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000800040), 0x1.040000040002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000800400), 0x1.04000004002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000802000), 0x1.0400000401p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000804000), 0x1.0400000402p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000840000), 0x1.040000042p+53, 0x0p+0 },
+{ UINT64_C(0x0020800000a00000), 0x1.04000005p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001000000), 0x1.04000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001000004), 0x1.0400000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001000020), 0x1.040000080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001000040), 0x1.040000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001000080), 0x1.040000080004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001000400), 0x1.04000008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001001000), 0x1.04000008008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001010000), 0x1.0400000808p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001100000), 0x1.040000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001200000), 0x1.04000009p+53, 0x0p+0 },
+{ UINT64_C(0x0020800001800000), 0x1.0400000cp+53, 0x0p+0 },
+{ UINT64_C(0x0020800008000000), 0x1.0400004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008000008), 0x1.0400004000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008000080), 0x1.040000400004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008000100), 0x1.040000400008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008001000), 0x1.04000040008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008010000), 0x1.0400004008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008080000), 0x1.040000404p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008200000), 0x1.04000041p+53, 0x0p+0 },
+{ UINT64_C(0x0020800008400000), 0x1.04000042p+53, 0x0p+0 },
+{ UINT64_C(0x002080000c000000), 0x1.0400006p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010000000), 0x1.0400008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010000004), 0x1.0400008000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010000010), 0x1.0400008000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010000100), 0x1.040000800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010000400), 0x1.04000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010000800), 0x1.04000080004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010004000), 0x1.0400008002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010010000), 0x1.0400008008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010100000), 0x1.040000808p+53, 0x0p+0 },
+{ UINT64_C(0x0020800010400000), 0x1.04000082p+53, 0x0p+0 },
+{ UINT64_C(0x0020800011000000), 0x1.04000088p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020000000), 0x1.040001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020000008), 0x1.0400010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020000020), 0x1.040001000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020000200), 0x1.04000100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020000400), 0x1.04000100002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020001000), 0x1.04000100008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020002000), 0x1.0400010001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020020000), 0x1.040001001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020100000), 0x1.040001008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800020800000), 0x1.04000104p+53, 0x0p+0 },
+{ UINT64_C(0x0020800022000000), 0x1.0400011p+53, 0x0p+0 },
+{ UINT64_C(0x0020800028000000), 0x1.0400014p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200000000), 0x1.04001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200000001), 0x1.04001p+53, 0x1p+0 },
+{ UINT64_C(0x0020800200000008), 0x1.0400100000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200000040), 0x1.040010000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200000100), 0x1.040010000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200000800), 0x1.04001000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200002000), 0x1.0400100001p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200008000), 0x1.0400100004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200080000), 0x1.040010004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800200800000), 0x1.04001004p+53, 0x0p+0 },
+{ UINT64_C(0x0020800202000000), 0x1.0400101p+53, 0x0p+0 },
+{ UINT64_C(0x0020800208000000), 0x1.0400104p+53, 0x0p+0 },
+{ UINT64_C(0x0020800280000000), 0x1.040014p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000000000), 0x1.04008p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000000001), 0x1.04008p+53, 0x1p+0 },
+{ UINT64_C(0x0020801000000002), 0x1.0400800000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000000008), 0x1.0400800000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000000040), 0x1.040080000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000000200), 0x1.04008000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000000800), 0x1.04008000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000001000), 0x1.04008000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000010000), 0x1.0400800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000020000), 0x1.040080001p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000100000), 0x1.040080008p+53, 0x0p+0 },
+{ UINT64_C(0x0020801000200000), 0x1.04008001p+53, 0x0p+0 },
+{ UINT64_C(0x0020801002000000), 0x1.0400801p+53, 0x0p+0 },
+{ UINT64_C(0x0020801004000000), 0x1.0400802p+53, 0x0p+0 },
+{ UINT64_C(0x0020801020000000), 0x1.040081p+53, 0x0p+0 },
+{ UINT64_C(0x0020801040000000), 0x1.040082p+53, 0x0p+0 },
+{ UINT64_C(0x0020801400000000), 0x1.0400ap+53, 0x0p+0 },
+{ UINT64_C(0x0020804000000000), 0x1.0402p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000000001), 0x1.0402p+53, 0x1p+0 },
+{ UINT64_C(0x0020804000000010), 0x1.0402000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000000020), 0x1.040200000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000000200), 0x1.04020000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000002000), 0x1.0402000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000004000), 0x1.0402000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000010000), 0x1.0402000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000080000), 0x1.040200004p+53, 0x0p+0 },
+{ UINT64_C(0x0020804000100000), 0x1.040200008p+53, 0x0p+0 },
+{ UINT64_C(0x0020804001000000), 0x1.04020008p+53, 0x0p+0 },
+{ UINT64_C(0x0020804008000000), 0x1.0402004p+53, 0x0p+0 },
+{ UINT64_C(0x0020804040000000), 0x1.040202p+53, 0x0p+0 },
+{ UINT64_C(0x0020804100000000), 0x1.040208p+53, 0x0p+0 },
+{ UINT64_C(0x0020804400000000), 0x1.04022p+53, 0x0p+0 },
+{ UINT64_C(0x0020804800000000), 0x1.04024p+53, 0x0p+0 },
+{ UINT64_C(0x0020806000000000), 0x1.0403p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000000000), 0x1.041p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000000002), 0x1.0410000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000000004), 0x1.0410000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000000020), 0x1.041000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000000080), 0x1.041000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000000400), 0x1.04100000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000001000), 0x1.04100000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000008000), 0x1.0410000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000040000), 0x1.041000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020820000100000), 0x1.041000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020820001000000), 0x1.04100008p+53, 0x0p+0 },
+{ UINT64_C(0x0020820004000000), 0x1.0410002p+53, 0x0p+0 },
+{ UINT64_C(0x0020820040000000), 0x1.041002p+53, 0x0p+0 },
+{ UINT64_C(0x0020820080000000), 0x1.041004p+53, 0x0p+0 },
+{ UINT64_C(0x0020820800000000), 0x1.04104p+53, 0x0p+0 },
+{ UINT64_C(0x0020828000000000), 0x1.0414p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000000000), 0x1.048p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000000008), 0x1.0480000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000000080), 0x1.048000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000000800), 0x1.04800000004p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000001000), 0x1.04800000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000002000), 0x1.0480000001p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000004000), 0x1.0480000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000040000), 0x1.048000002p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000100000), 0x1.048000008p+53, 0x0p+0 },
+{ UINT64_C(0x0020900000200000), 0x1.04800001p+53, 0x0p+0 },
+{ UINT64_C(0x0020900001000000), 0x1.04800008p+53, 0x0p+0 },
+{ UINT64_C(0x0020900010000000), 0x1.0480008p+53, 0x0p+0 },
+{ UINT64_C(0x0020900020000000), 0x1.048001p+53, 0x0p+0 },
+{ UINT64_C(0x0020900100000000), 0x1.048008p+53, 0x0p+0 },
+{ UINT64_C(0x0020900400000000), 0x1.04802p+53, 0x0p+0 },
+{ UINT64_C(0x0020900800000000), 0x1.04804p+53, 0x0p+0 },
+{ UINT64_C(0x0020901000000000), 0x1.04808p+53, 0x0p+0 },
+{ UINT64_C(0x0020902000000000), 0x1.0481p+53, 0x0p+0 },
+{ UINT64_C(0x0020910000000000), 0x1.0488p+53, 0x0p+0 },
+{ UINT64_C(0x0020980000000000), 0x1.04cp+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000001), 0x1.4p+53, 0x1p+0 },
+{ UINT64_C(0x0028000000000004), 0x1.4000000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000010), 0x1.4000000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000012), 0x1.4000000000009p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000014), 0x1.400000000000ap+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000020), 0x1.400000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000024), 0x1.4000000000012p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000028), 0x1.4000000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000030), 0x1.4000000000018p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000100), 0x1.400000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000108), 0x1.4000000000084p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000110), 0x1.4000000000088p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000140), 0x1.40000000000ap+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000200), 0x1.40000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000208), 0x1.4000000000104p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000280), 0x1.400000000014p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000400), 0x1.40000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000402), 0x1.4000000000201p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000410), 0x1.4000000000208p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000480), 0x1.400000000024p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000800), 0x1.40000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000802), 0x1.4000000000401p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000804), 0x1.4000000000402p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000808), 0x1.4000000000404p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000820), 0x1.400000000041p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000840), 0x1.400000000042p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000a00), 0x1.40000000005p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000000c00), 0x1.40000000006p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000004000), 0x1.4000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000004004), 0x1.4000000002002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000004008), 0x1.4000000002004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000004010), 0x1.4000000002008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000004040), 0x1.400000000202p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000004400), 0x1.40000000022p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000006000), 0x1.4000000003p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008000), 0x1.4000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008008), 0x1.4000000004004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008010), 0x1.4000000004008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008020), 0x1.400000000401p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008080), 0x1.400000000404p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008400), 0x1.40000000042p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000008800), 0x1.40000000044p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000009000), 0x1.40000000048p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000040000), 0x1.400000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000040008), 0x1.4000000020004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000040080), 0x1.400000002004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000040400), 0x1.40000000202p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000044000), 0x1.4000000022p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000400000), 0x1.40000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000400004), 0x1.4000000200002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000400040), 0x1.400000020002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000400200), 0x1.40000002001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000400400), 0x1.40000002002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000400800), 0x1.40000002004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000404000), 0x1.4000000202p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000440000), 0x1.400000022p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000480000), 0x1.400000024p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000800000), 0x1.40000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000800004), 0x1.4000000400002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000800040), 0x1.400000040002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000800100), 0x1.400000040008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000800400), 0x1.40000004002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000804000), 0x1.4000000402p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000810000), 0x1.4000000408p+53, 0x0p+0 },
+{ UINT64_C(0x0028000000880000), 0x1.400000044p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002000000), 0x1.4000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002000004), 0x1.4000001000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002000010), 0x1.4000001000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002000080), 0x1.400000100004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002000400), 0x1.40000010002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002001000), 0x1.40000010008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002010000), 0x1.4000001008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002080000), 0x1.400000104p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002100000), 0x1.400000108p+53, 0x0p+0 },
+{ UINT64_C(0x0028000002200000), 0x1.40000011p+53, 0x0p+0 },
+{ UINT64_C(0x0028000003000000), 0x1.40000018p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008000000), 0x1.4000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008000008), 0x1.4000004000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008000080), 0x1.400000400004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008000200), 0x1.40000040001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008000400), 0x1.40000040002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008001000), 0x1.40000040008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008008000), 0x1.4000004004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008080000), 0x1.400000404p+53, 0x0p+0 },
+{ UINT64_C(0x0028000008400000), 0x1.40000042p+53, 0x0p+0 },
+{ UINT64_C(0x002800000a000000), 0x1.4000005p+53, 0x0p+0 },
+{ UINT64_C(0x002800000c000000), 0x1.4000006p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010000000), 0x1.4000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010000008), 0x1.4000008000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010000040), 0x1.400000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010000400), 0x1.40000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010001000), 0x1.40000080008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010004000), 0x1.4000008002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010040000), 0x1.400000802p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010100000), 0x1.400000808p+53, 0x0p+0 },
+{ UINT64_C(0x0028000010800000), 0x1.40000084p+53, 0x0p+0 },
+{ UINT64_C(0x0028000018000000), 0x1.400000cp+53, 0x0p+0 },
+{ UINT64_C(0x0028000020000000), 0x1.400001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020000008), 0x1.4000010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020000080), 0x1.400001000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020000200), 0x1.40000100001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020000400), 0x1.40000100002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020001000), 0x1.40000100008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020002000), 0x1.4000010001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020020000), 0x1.400001001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020100000), 0x1.400001008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000020800000), 0x1.40000104p+53, 0x0p+0 },
+{ UINT64_C(0x0028000028000000), 0x1.4000014p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000000), 0x1.400008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000002), 0x1.4000080000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000008), 0x1.4000080000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000010), 0x1.4000080000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000040), 0x1.400008000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000200), 0x1.40000800001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000400), 0x1.40000800002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100000800), 0x1.40000800004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100004000), 0x1.4000080002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100010000), 0x1.4000080008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100080000), 0x1.400008004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000100100000), 0x1.400008008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000101000000), 0x1.40000808p+53, 0x0p+0 },
+{ UINT64_C(0x0028000108000000), 0x1.4000084p+53, 0x0p+0 },
+{ UINT64_C(0x0028000120000000), 0x1.400009p+53, 0x0p+0 },
+{ UINT64_C(0x0028000180000000), 0x1.40000cp+53, 0x0p+0 },
+{ UINT64_C(0x0028000200000000), 0x1.40001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200000001), 0x1.40001p+53, 0x1p+0 },
+{ UINT64_C(0x0028000200000002), 0x1.4000100000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200000010), 0x1.4000100000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200000080), 0x1.400010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200000200), 0x1.40001000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200000400), 0x1.40001000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200001000), 0x1.40001000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200002000), 0x1.4000100001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200008000), 0x1.4000100004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200010000), 0x1.4000100008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200040000), 0x1.400010002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000200200000), 0x1.40001001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000201000000), 0x1.40001008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000208000000), 0x1.4000104p+53, 0x0p+0 },
+{ UINT64_C(0x0028000280000000), 0x1.400014p+53, 0x0p+0 },
+{ UINT64_C(0x0028000300000000), 0x1.400018p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800000000), 0x1.40004p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800000004), 0x1.4000400000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800000010), 0x1.4000400000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800000020), 0x1.400040000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800000040), 0x1.400040000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800000400), 0x1.40004000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800002000), 0x1.4000400001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800020000), 0x1.400040001p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800100000), 0x1.400040008p+53, 0x0p+0 },
+{ UINT64_C(0x0028000800400000), 0x1.40004002p+53, 0x0p+0 },
+{ UINT64_C(0x0028000802000000), 0x1.4000401p+53, 0x0p+0 },
+{ UINT64_C(0x0028000808000000), 0x1.4000404p+53, 0x0p+0 },
+{ UINT64_C(0x0028000840000000), 0x1.400042p+53, 0x0p+0 },
+{ UINT64_C(0x0028000880000000), 0x1.400044p+53, 0x0p+0 },
+{ UINT64_C(0x0028000900000000), 0x1.400048p+53, 0x0p+0 },
+{ UINT64_C(0x0028000a00000000), 0x1.40005p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000000000), 0x1.4001p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000000008), 0x1.4001000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000000020), 0x1.400100000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000000080), 0x1.400100000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000000800), 0x1.40010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000004000), 0x1.4001000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000020000), 0x1.400100001p+53, 0x0p+0 },
+{ UINT64_C(0x0028002000200000), 0x1.40010001p+53, 0x0p+0 },
+{ UINT64_C(0x0028002001000000), 0x1.40010008p+53, 0x0p+0 },
+{ UINT64_C(0x0028002008000000), 0x1.4001004p+53, 0x0p+0 },
+{ UINT64_C(0x0028002010000000), 0x1.4001008p+53, 0x0p+0 },
+{ UINT64_C(0x0028002100000000), 0x1.400108p+53, 0x0p+0 },
+{ UINT64_C(0x0028002800000000), 0x1.40014p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000000000), 0x1.401p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000000002), 0x1.4010000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000000008), 0x1.4010000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000000010), 0x1.4010000000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000000080), 0x1.401000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000000200), 0x1.40100000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000002000), 0x1.4010000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000008000), 0x1.4010000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000020000), 0x1.401000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000100000), 0x1.401000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028020000200000), 0x1.40100001p+53, 0x0p+0 },
+{ UINT64_C(0x0028020001000000), 0x1.40100008p+53, 0x0p+0 },
+{ UINT64_C(0x0028020004000000), 0x1.4010002p+53, 0x0p+0 },
+{ UINT64_C(0x0028020010000000), 0x1.4010008p+53, 0x0p+0 },
+{ UINT64_C(0x0028020080000000), 0x1.401004p+53, 0x0p+0 },
+{ UINT64_C(0x0028020100000000), 0x1.401008p+53, 0x0p+0 },
+{ UINT64_C(0x0028021000000000), 0x1.40108p+53, 0x0p+0 },
+{ UINT64_C(0x0028022000000000), 0x1.4011p+53, 0x0p+0 },
+{ UINT64_C(0x0028028000000000), 0x1.4014p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000000000), 0x1.404p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000000004), 0x1.4040000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000000008), 0x1.4040000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000000040), 0x1.404000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000000200), 0x1.40400000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000001000), 0x1.40400000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000008000), 0x1.4040000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000010000), 0x1.4040000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000080000), 0x1.404000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028080000800000), 0x1.40400004p+53, 0x0p+0 },
+{ UINT64_C(0x0028080008000000), 0x1.4040004p+53, 0x0p+0 },
+{ UINT64_C(0x0028080080000000), 0x1.404004p+53, 0x0p+0 },
+{ UINT64_C(0x0028080400000000), 0x1.40402p+53, 0x0p+0 },
+{ UINT64_C(0x0028082000000000), 0x1.4041p+53, 0x0p+0 },
+{ UINT64_C(0x0028088000000000), 0x1.4044p+53, 0x0p+0 },
+{ UINT64_C(0x00280a0000000000), 0x1.405p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000000000), 0x1.41p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000000002), 0x1.4100000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000000004), 0x1.4100000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000000008), 0x1.4100000000004p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000000040), 0x1.410000000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000000200), 0x1.41000000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000002000), 0x1.4100000001p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000004000), 0x1.4100000002p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000010000), 0x1.4100000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028200000100000), 0x1.410000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028200001000000), 0x1.41000008p+53, 0x0p+0 },
+{ UINT64_C(0x0028200002000000), 0x1.4100001p+53, 0x0p+0 },
+{ UINT64_C(0x0028200010000000), 0x1.4100008p+53, 0x0p+0 },
+{ UINT64_C(0x0028200100000000), 0x1.410008p+53, 0x0p+0 },
+{ UINT64_C(0x0028200800000000), 0x1.41004p+53, 0x0p+0 },
+{ UINT64_C(0x0028202000000000), 0x1.4101p+53, 0x0p+0 },
+{ UINT64_C(0x0028210000000000), 0x1.4108p+53, 0x0p+0 },
+{ UINT64_C(0x0028300000000000), 0x1.418p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000000000), 0x1.5p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000000008), 0x1.5000000000004p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000000080), 0x1.500000000004p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000000800), 0x1.50000000004p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000004000), 0x1.5000000002p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000010000), 0x1.5000000008p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000020000), 0x1.500000001p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000100000), 0x1.500000008p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000200000), 0x1.50000001p+53, 0x0p+0 },
+{ UINT64_C(0x002a000000400000), 0x1.50000002p+53, 0x0p+0 },
+{ UINT64_C(0x002a000002000000), 0x1.5000001p+53, 0x0p+0 },
+{ UINT64_C(0x002a000008000000), 0x1.5000004p+53, 0x0p+0 },
+{ UINT64_C(0x002a000040000000), 0x1.500002p+53, 0x0p+0 },
+{ UINT64_C(0x002a000200000000), 0x1.50001p+53, 0x0p+0 },
+{ UINT64_C(0x002a000800000000), 0x1.50004p+53, 0x0p+0 },
+{ UINT64_C(0x002a008000000000), 0x1.5004p+53, 0x0p+0 },
+{ UINT64_C(0x002a020000000000), 0x1.501p+53, 0x0p+0 },
+{ UINT64_C(0x002a200000000000), 0x1.51p+53, 0x0p+0 },
+{ UINT64_C(0x002a800000000000), 0x1.54p+53, 0x0p+0 },
+{ UINT64_C(0x002b000000000000), 0x1.58p+53, 0x0p+0 },
+{ UINT64_C(0x0200000000000022), 0x1.0000000000001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000000023), 0x1.0000000000001p+57, 0x1.8p+1 },
+{ UINT64_C(0x0200000000000028), 0x1.0000000000001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000000029), 0x1.0000000000001p+57, 0x1.2p+3 },
+{ UINT64_C(0x020000000000002c), 0x1.0000000000001p+57, 0x1.8p+3 },
+{ UINT64_C(0x0200000000000104), 0x1.0000000000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000000140), 0x1.000000000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200000000000141), 0x1.000000000000ap+57, 0x1p+0 },
+{ UINT64_C(0x0200000000000144), 0x1.000000000000ap+57, 0x1p+2 },
+{ UINT64_C(0x0200000000000148), 0x1.000000000000ap+57, 0x1p+3 },
+{ UINT64_C(0x0200000000000150), 0x1.000000000000ap+57, 0x1p+4 },
+{ UINT64_C(0x0200000000001004), 0x1.000000000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000001005), 0x1.000000000008p+57, 0x1.4p+2 },
+{ UINT64_C(0x0200000000001010), 0x1.000000000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000001018), 0x1.0000000000081p+57, -0x1p+3 },
+{ UINT64_C(0x0200000000001040), 0x1.0000000000082p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000001041), 0x1.0000000000082p+57, 0x1p+0 },
+{ UINT64_C(0x0200000000001042), 0x1.0000000000082p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000001050), 0x1.0000000000082p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000001080), 0x1.0000000000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000001081), 0x1.0000000000084p+57, 0x1p+0 },
+{ UINT64_C(0x0200000000001088), 0x1.0000000000084p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000001200), 0x1.000000000009p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000001202), 0x1.000000000009p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000001208), 0x1.000000000009p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000001240), 0x1.0000000000092p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000001800), 0x1.00000000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000000001804), 0x1.00000000000cp+57, 0x1p+2 },
+{ UINT64_C(0x0200000000001810), 0x1.00000000000cp+57, 0x1p+4 },
+{ UINT64_C(0x0200000000001820), 0x1.00000000000c1p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000001900), 0x1.00000000000c8p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004002), 0x1.00000000002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000004004), 0x1.00000000002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000004040), 0x1.0000000000202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004041), 0x1.0000000000202p+57, 0x1p+0 },
+{ UINT64_C(0x0200000000004050), 0x1.0000000000202p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000004080), 0x1.0000000000204p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004081), 0x1.0000000000204p+57, 0x1p+0 },
+{ UINT64_C(0x0200000000004082), 0x1.0000000000204p+57, 0x1p+1 },
+{ UINT64_C(0x02000000000040a0), 0x1.0000000000205p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004400), 0x1.000000000022p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004404), 0x1.000000000022p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000004408), 0x1.000000000022p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000004420), 0x1.0000000000221p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004440), 0x1.0000000000222p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000004600), 0x1.000000000023p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040002), 0x1.0000000002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000040008), 0x1.0000000002p+57, 0x1p+3 },
+{ UINT64_C(0x020000000004000c), 0x1.0000000002p+57, 0x1.8p+3 },
+{ UINT64_C(0x0200000000040040), 0x1.0000000002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040042), 0x1.0000000002002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000040044), 0x1.0000000002002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000040048), 0x1.0000000002002p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000040050), 0x1.0000000002002p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000040200), 0x1.000000000201p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040208), 0x1.000000000201p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000040220), 0x1.0000000002011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040280), 0x1.0000000002014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040300), 0x1.0000000002018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040400), 0x1.000000000202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000040404), 0x1.000000000202p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000040410), 0x1.000000000202p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000040500), 0x1.0000000002028p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000042000), 0x1.00000000021p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000042002), 0x1.00000000021p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000042004), 0x1.00000000021p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000042040), 0x1.0000000002102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000042400), 0x1.000000000212p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000048000), 0x1.00000000024p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000048004), 0x1.00000000024p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000048040), 0x1.0000000002402p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000048100), 0x1.0000000002408p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000049000), 0x1.000000000248p+57, 0x0p+0 },
+{ UINT64_C(0x020000000004a000), 0x1.00000000025p+57, 0x0p+0 },
+{ UINT64_C(0x020000000004c000), 0x1.00000000026p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200004), 0x1.000000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000200005), 0x1.000000001p+57, 0x1.4p+2 },
+{ UINT64_C(0x0200000000200006), 0x1.000000001p+57, 0x1.8p+2 },
+{ UINT64_C(0x0200000000200040), 0x1.0000000010002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200044), 0x1.0000000010002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000200048), 0x1.0000000010002p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000200060), 0x1.0000000010003p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200200), 0x1.000000001001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200202), 0x1.000000001001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000200208), 0x1.000000001001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000200240), 0x1.0000000010012p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200300), 0x1.0000000010018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200800), 0x1.000000001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200802), 0x1.000000001004p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000200810), 0x1.000000001004p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000200820), 0x1.0000000010041p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200a00), 0x1.000000001005p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000200c00), 0x1.000000001006p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000208000), 0x1.00000000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000208002), 0x1.00000000104p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000208004), 0x1.00000000104p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000208010), 0x1.00000000104p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000208100), 0x1.0000000010408p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000209000), 0x1.000000001048p+57, 0x0p+0 },
+{ UINT64_C(0x020000000020a000), 0x1.00000000105p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000210000), 0x1.00000000108p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000210002), 0x1.00000000108p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000210004), 0x1.00000000108p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000210020), 0x1.0000000010801p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000210200), 0x1.000000001081p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000210400), 0x1.000000001082p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000211000), 0x1.000000001088p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000300000), 0x1.0000000018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000300008), 0x1.0000000018p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000300080), 0x1.0000000018004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000300400), 0x1.000000001802p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000304000), 0x1.00000000182p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000310000), 0x1.00000000188p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000320000), 0x1.0000000019p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000800004), 0x1.000000004p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000800006), 0x1.000000004p+57, 0x1.8p+2 },
+{ UINT64_C(0x0200000000800008), 0x1.000000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000800040), 0x1.0000000040002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000800041), 0x1.0000000040002p+57, 0x1p+0 },
+{ UINT64_C(0x0200000000800042), 0x1.0000000040002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000800044), 0x1.0000000040002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000800050), 0x1.0000000040002p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000800200), 0x1.000000004001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000800208), 0x1.000000004001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000800210), 0x1.000000004001p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000800300), 0x1.0000000040018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000800800), 0x1.000000004004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000800808), 0x1.000000004004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000800810), 0x1.000000004004p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000800900), 0x1.0000000040048p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000801000), 0x1.000000004008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000801004), 0x1.000000004008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000801010), 0x1.000000004008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000801100), 0x1.0000000040088p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000801800), 0x1.00000000400cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000000804000), 0x1.00000000402p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000804002), 0x1.00000000402p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000804010), 0x1.00000000402p+57, 0x1p+4 },
+{ UINT64_C(0x0200000000804040), 0x1.0000000040202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000804100), 0x1.0000000040208p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000804400), 0x1.000000004022p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000806000), 0x1.00000000403p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000820000), 0x1.0000000041p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000820001), 0x1.0000000041p+57, 0x1p+0 },
+{ UINT64_C(0x0200000000820004), 0x1.0000000041p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000820040), 0x1.0000000041002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000820400), 0x1.000000004102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000822000), 0x1.00000000411p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000840000), 0x1.0000000042p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000840004), 0x1.0000000042p+57, 0x1p+2 },
+{ UINT64_C(0x0200000000840020), 0x1.0000000042001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000840100), 0x1.0000000042008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000841000), 0x1.000000004208p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000844000), 0x1.00000000422p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000860000), 0x1.0000000043p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c00000), 0x1.000000006p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c00002), 0x1.000000006p+57, 0x1p+1 },
+{ UINT64_C(0x0200000000c00008), 0x1.000000006p+57, 0x1p+3 },
+{ UINT64_C(0x0200000000c00020), 0x1.0000000060001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c00100), 0x1.0000000060008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c00200), 0x1.000000006001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c00800), 0x1.000000006004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c08000), 0x1.00000000604p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c10000), 0x1.00000000608p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000c40000), 0x1.0000000062p+57, 0x0p+0 },
+{ UINT64_C(0x0200000000e00000), 0x1.000000007p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002000004), 0x1.00000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200000002000008), 0x1.00000001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000002000020), 0x1.0000000100001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002000022), 0x1.0000000100001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000002000100), 0x1.0000000100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002000104), 0x1.0000000100008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000002000120), 0x1.0000000100009p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002000180), 0x1.000000010000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000002001000), 0x1.000000010008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002001002), 0x1.000000010008p+57, 0x1p+1 },
+{ UINT64_C(0x0200000002001010), 0x1.000000010008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000002001040), 0x1.0000000100082p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002001200), 0x1.000000010009p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002008000), 0x1.00000001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002008008), 0x1.00000001004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000002008010), 0x1.00000001004p+57, 0x1p+4 },
+{ UINT64_C(0x0200000002008080), 0x1.0000000100404p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002008100), 0x1.0000000100408p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002009000), 0x1.000000010048p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002040000), 0x1.0000000102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002040001), 0x1.0000000102p+57, 0x1p+0 },
+{ UINT64_C(0x0200000002040004), 0x1.0000000102p+57, 0x1p+2 },
+{ UINT64_C(0x0200000002040010), 0x1.0000000102p+57, 0x1p+4 },
+{ UINT64_C(0x0200000002040040), 0x1.0000000102002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002040400), 0x1.000000010202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002040800), 0x1.000000010204p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002042000), 0x1.00000001021p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002060000), 0x1.0000000103p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002200000), 0x1.000000011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002200008), 0x1.000000011p+57, 0x1p+3 },
+{ UINT64_C(0x0200000002200080), 0x1.0000000110004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002200400), 0x1.000000011002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002201000), 0x1.000000011008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002204000), 0x1.00000001102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002220000), 0x1.0000000111p+57, 0x0p+0 },
+{ UINT64_C(0x0200000002280000), 0x1.0000000114p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003000000), 0x1.000000018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003000001), 0x1.000000018p+57, 0x1p+0 },
+{ UINT64_C(0x0200000003000002), 0x1.000000018p+57, 0x1p+1 },
+{ UINT64_C(0x0200000003000008), 0x1.000000018p+57, 0x1p+3 },
+{ UINT64_C(0x0200000003000010), 0x1.000000018p+57, 0x1p+4 },
+{ UINT64_C(0x0200000003000080), 0x1.0000000180004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003000200), 0x1.000000018001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003000800), 0x1.000000018004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003001000), 0x1.000000018008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003004000), 0x1.00000001802p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003040000), 0x1.0000000182p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003100000), 0x1.0000000188p+57, 0x0p+0 },
+{ UINT64_C(0x0200000003200000), 0x1.000000019p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000004), 0x1.00000004p+57, 0x1p+2 },
+{ UINT64_C(0x0200000008000020), 0x1.0000000400001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000021), 0x1.0000000400001p+57, 0x1p+0 },
+{ UINT64_C(0x0200000008000024), 0x1.0000000400001p+57, 0x1p+2 },
+{ UINT64_C(0x0200000008000028), 0x1.0000000400001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000008000030), 0x1.0000000400002p+57, -0x1p+4 },
+{ UINT64_C(0x0200000008000080), 0x1.0000000400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000081), 0x1.0000000400004p+57, 0x1p+0 },
+{ UINT64_C(0x0200000008000082), 0x1.0000000400004p+57, 0x1p+1 },
+{ UINT64_C(0x02000000080000a0), 0x1.0000000400005p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000200), 0x1.000000040001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000201), 0x1.000000040001p+57, 0x1p+0 },
+{ UINT64_C(0x0200000008000208), 0x1.000000040001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000008000280), 0x1.0000000400014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000800), 0x1.000000040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000801), 0x1.000000040004p+57, 0x1p+0 },
+{ UINT64_C(0x0200000008000804), 0x1.000000040004p+57, 0x1p+2 },
+{ UINT64_C(0x0200000008000808), 0x1.000000040004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000008000880), 0x1.0000000400044p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008000c00), 0x1.000000040006p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008002000), 0x1.00000004001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008002008), 0x1.00000004001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000008002010), 0x1.00000004001p+57, 0x1p+4 },
+{ UINT64_C(0x0200000008002080), 0x1.0000000400104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008002200), 0x1.000000040011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008003000), 0x1.000000040018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008020000), 0x1.0000000401p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008020008), 0x1.0000000401p+57, 0x1p+3 },
+{ UINT64_C(0x0200000008020040), 0x1.0000000401002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008020080), 0x1.0000000401004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008020800), 0x1.000000040104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008022000), 0x1.00000004011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008200000), 0x1.000000041p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008200001), 0x1.000000041p+57, 0x1p+0 },
+{ UINT64_C(0x0200000008200004), 0x1.000000041p+57, 0x1p+2 },
+{ UINT64_C(0x0200000008200020), 0x1.0000000410001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008200040), 0x1.0000000410002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008200400), 0x1.000000041002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008201000), 0x1.000000041008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008202000), 0x1.00000004101p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008204000), 0x1.00000004102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008240000), 0x1.0000000412p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008400000), 0x1.000000042p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008400004), 0x1.000000042p+57, 0x1p+2 },
+{ UINT64_C(0x0200000008400040), 0x1.0000000420002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008400400), 0x1.000000042002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008404000), 0x1.00000004202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008440000), 0x1.0000000422p+57, 0x0p+0 },
+{ UINT64_C(0x0200000008480000), 0x1.0000000424p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009000000), 0x1.000000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009000002), 0x1.000000048p+57, 0x1p+1 },
+{ UINT64_C(0x0200000009000010), 0x1.000000048p+57, 0x1p+4 },
+{ UINT64_C(0x0200000009000080), 0x1.0000000480004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009000800), 0x1.000000048004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009008000), 0x1.00000004804p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009040000), 0x1.0000000482p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009200000), 0x1.000000049p+57, 0x0p+0 },
+{ UINT64_C(0x0200000009800000), 0x1.00000004cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000020000004), 0x1.0000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200000020000005), 0x1.0000001p+57, 0x1.4p+2 },
+{ UINT64_C(0x0200000020000008), 0x1.0000001p+57, 0x1p+3 },
+{ UINT64_C(0x020000002000000a), 0x1.0000001p+57, 0x1.4p+3 },
+{ UINT64_C(0x0200000020000040), 0x1.0000001000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020000044), 0x1.0000001000002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000020000100), 0x1.0000001000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020000102), 0x1.0000001000008p+57, 0x1p+1 },
+{ UINT64_C(0x0200000020000108), 0x1.0000001000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200000020000110), 0x1.0000001000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000020000180), 0x1.000000100000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000020001000), 0x1.000000100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020001004), 0x1.000000100008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000020001020), 0x1.0000001000081p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020001080), 0x1.0000001000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020001800), 0x1.00000010000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000020002000), 0x1.00000010001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020002002), 0x1.00000010001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000020002020), 0x1.0000001000101p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020002200), 0x1.000000100011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020002400), 0x1.000000100012p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020002800), 0x1.000000100014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020008000), 0x1.00000010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020008001), 0x1.00000010004p+57, 0x1p+0 },
+{ UINT64_C(0x0200000020008008), 0x1.00000010004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000020008040), 0x1.0000001000402p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020008400), 0x1.000000100042p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020009000), 0x1.000000100048p+57, 0x0p+0 },
+{ UINT64_C(0x020000002000c000), 0x1.00000010006p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020020000), 0x1.0000001001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020020002), 0x1.0000001001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000020020008), 0x1.0000001001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000020020020), 0x1.0000001001001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020020080), 0x1.0000001001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020020100), 0x1.0000001001008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020020800), 0x1.000000100104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020022000), 0x1.00000010011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020028000), 0x1.00000010014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020040000), 0x1.0000001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020040004), 0x1.0000001002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000020040008), 0x1.0000001002p+57, 0x1p+3 },
+{ UINT64_C(0x0200000020040020), 0x1.0000001002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020040080), 0x1.0000001002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020040200), 0x1.000000100201p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020040400), 0x1.000000100202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020041000), 0x1.000000100208p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020042000), 0x1.00000010021p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020048000), 0x1.00000010024p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020060000), 0x1.0000001003p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020200000), 0x1.000000101p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020200008), 0x1.000000101p+57, 0x1p+3 },
+{ UINT64_C(0x0200000020200020), 0x1.0000001010001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020200080), 0x1.0000001010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020200400), 0x1.000000101002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020202000), 0x1.00000010101p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020220000), 0x1.0000001011p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020300000), 0x1.0000001018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020800000), 0x1.000000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020800004), 0x1.000000104p+57, 0x1p+2 },
+{ UINT64_C(0x0200000020800008), 0x1.000000104p+57, 0x1p+3 },
+{ UINT64_C(0x0200000020800040), 0x1.0000001040002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020800100), 0x1.0000001040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020800200), 0x1.000000104001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020800800), 0x1.000000104004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020808000), 0x1.00000010404p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020810000), 0x1.00000010408p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020820000), 0x1.0000001041p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020840000), 0x1.0000001042p+57, 0x0p+0 },
+{ UINT64_C(0x0200000020a00000), 0x1.000000105p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024000000), 0x1.00000012p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024000001), 0x1.00000012p+57, 0x1p+0 },
+{ UINT64_C(0x0200000024000008), 0x1.00000012p+57, 0x1p+3 },
+{ UINT64_C(0x0200000024000010), 0x1.00000012p+57, 0x1p+4 },
+{ UINT64_C(0x0200000024000100), 0x1.0000001200008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024000800), 0x1.000000120004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024008000), 0x1.00000012004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024040000), 0x1.0000001202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024080000), 0x1.0000001204p+57, 0x0p+0 },
+{ UINT64_C(0x0200000024200000), 0x1.000000121p+57, 0x0p+0 },
+{ UINT64_C(0x0200000025000000), 0x1.000000128p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000004), 0x1.0000004p+57, 0x1p+2 },
+{ UINT64_C(0x0200000080000005), 0x1.0000004p+57, 0x1.4p+2 },
+{ UINT64_C(0x0200000080000006), 0x1.0000004p+57, 0x1.8p+2 },
+{ UINT64_C(0x0200000080000020), 0x1.0000004000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000022), 0x1.0000004000001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000080000028), 0x1.0000004000001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000080000100), 0x1.0000004000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000104), 0x1.0000004000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000080000120), 0x1.0000004000009p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000180), 0x1.000000400000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000200), 0x1.000000400001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000201), 0x1.000000400001p+57, 0x1p+0 },
+{ UINT64_C(0x0200000080000208), 0x1.000000400001p+57, 0x1p+3 },
+{ UINT64_C(0x0200000080000240), 0x1.0000004000012p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000800), 0x1.000000400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000808), 0x1.000000400004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000080000820), 0x1.0000004000041p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000840), 0x1.0000004000042p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080000a00), 0x1.000000400005p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080002000), 0x1.00000040001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080002004), 0x1.00000040001p+57, 0x1p+2 },
+{ UINT64_C(0x0200000080002010), 0x1.00000040001p+57, 0x1p+4 },
+{ UINT64_C(0x0200000080002080), 0x1.0000004000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080002800), 0x1.000000400014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080003000), 0x1.000000400018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080010000), 0x1.00000040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080010002), 0x1.00000040008p+57, 0x1p+1 },
+{ UINT64_C(0x0200000080010004), 0x1.00000040008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000080010008), 0x1.00000040008p+57, 0x1p+3 },
+{ UINT64_C(0x0200000080010040), 0x1.0000004000802p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080010200), 0x1.000000400081p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080010400), 0x1.000000400082p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080014000), 0x1.0000004000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200000080040000), 0x1.0000004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080040002), 0x1.0000004002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000080040010), 0x1.0000004002p+57, 0x1p+4 },
+{ UINT64_C(0x0200000080040020), 0x1.0000004002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080040200), 0x1.000000400201p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080040800), 0x1.000000400204p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080048000), 0x1.00000040024p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080060000), 0x1.0000004003p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080100000), 0x1.0000004008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080100001), 0x1.0000004008p+57, 0x1p+0 },
+{ UINT64_C(0x0200000080100002), 0x1.0000004008p+57, 0x1p+1 },
+{ UINT64_C(0x0200000080100020), 0x1.0000004008001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080100100), 0x1.0000004008008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080101000), 0x1.000000400808p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080104000), 0x1.00000040082p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080120000), 0x1.0000004009p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080180000), 0x1.000000400cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000080400000), 0x1.000000402p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080400004), 0x1.000000402p+57, 0x1p+2 },
+{ UINT64_C(0x0200000080400010), 0x1.000000402p+57, 0x1p+4 },
+{ UINT64_C(0x0200000080400020), 0x1.0000004020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080400200), 0x1.000000402001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080400400), 0x1.000000402002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080404000), 0x1.00000040202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080420000), 0x1.0000004021p+57, 0x0p+0 },
+{ UINT64_C(0x0200000080600000), 0x1.000000403p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081000000), 0x1.000000408p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081000001), 0x1.000000408p+57, 0x1p+0 },
+{ UINT64_C(0x0200000081000002), 0x1.000000408p+57, 0x1p+1 },
+{ UINT64_C(0x0200000081000020), 0x1.0000004080001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081000200), 0x1.000000408001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081001000), 0x1.000000408008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081004000), 0x1.00000040802p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081010000), 0x1.00000040808p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081020000), 0x1.0000004081p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081080000), 0x1.0000004084p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081100000), 0x1.0000004088p+57, 0x0p+0 },
+{ UINT64_C(0x0200000081800000), 0x1.00000040cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000090000000), 0x1.00000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090000004), 0x1.00000048p+57, 0x1p+2 },
+{ UINT64_C(0x0200000090000040), 0x1.0000004800002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090000080), 0x1.0000004800004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090000800), 0x1.000000480004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090002000), 0x1.00000048001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090004000), 0x1.00000048002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090040000), 0x1.0000004802p+57, 0x0p+0 },
+{ UINT64_C(0x0200000090400000), 0x1.000000482p+57, 0x0p+0 },
+{ UINT64_C(0x0200000091000000), 0x1.000000488p+57, 0x0p+0 },
+{ UINT64_C(0x0200000092000000), 0x1.00000049p+57, 0x0p+0 },
+{ UINT64_C(0x0200000094000000), 0x1.0000004ap+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0000000), 0x1.0000006p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0000001), 0x1.0000006p+57, 0x1p+0 },
+{ UINT64_C(0x02000000c0000002), 0x1.0000006p+57, 0x1p+1 },
+{ UINT64_C(0x02000000c0000008), 0x1.0000006p+57, 0x1p+3 },
+{ UINT64_C(0x02000000c0000020), 0x1.0000006000001p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0000080), 0x1.0000006000004p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0000800), 0x1.000000600004p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0001000), 0x1.000000600008p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0008000), 0x1.00000060004p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0080000), 0x1.0000006004p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c0800000), 0x1.000000604p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c1000000), 0x1.000000608p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c4000000), 0x1.00000062p+57, 0x0p+0 },
+{ UINT64_C(0x02000000c8000000), 0x1.00000064p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200000002), 0x1.000001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000200000003), 0x1.000001p+57, 0x1.8p+1 },
+{ UINT64_C(0x0200000200000004), 0x1.000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200000200000006), 0x1.000001p+57, 0x1.8p+2 },
+{ UINT64_C(0x0200000200000008), 0x1.000001p+57, 0x1p+3 },
+{ UINT64_C(0x020000020000000c), 0x1.000001p+57, 0x1.8p+3 },
+{ UINT64_C(0x0200000200000020), 0x1.0000010000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200000022), 0x1.0000010000001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000200000100), 0x1.0000010000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200000101), 0x1.0000010000008p+57, 0x1p+0 },
+{ UINT64_C(0x0200000200000110), 0x1.0000010000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000200001000), 0x1.000001000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200001002), 0x1.000001000008p+57, 0x1p+1 },
+{ UINT64_C(0x0200000200001004), 0x1.000001000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000200001010), 0x1.000001000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000200001100), 0x1.0000010000088p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200010000), 0x1.00000100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200010008), 0x1.00000100008p+57, 0x1p+3 },
+{ UINT64_C(0x0200000200010010), 0x1.00000100008p+57, 0x1p+4 },
+{ UINT64_C(0x0200000200010020), 0x1.0000010000801p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200010080), 0x1.0000010000804p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200010400), 0x1.000001000082p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200011000), 0x1.000001000088p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200018000), 0x1.0000010000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000200080000), 0x1.0000010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200080008), 0x1.0000010004p+57, 0x1p+3 },
+{ UINT64_C(0x0200000200080080), 0x1.0000010004004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200080800), 0x1.000001000404p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200088000), 0x1.00000100044p+57, 0x0p+0 },
+{ UINT64_C(0x02000002000c0000), 0x1.0000010006p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200400000), 0x1.000001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200400001), 0x1.000001002p+57, 0x1p+0 },
+{ UINT64_C(0x0200000200400010), 0x1.000001002p+57, 0x1p+4 },
+{ UINT64_C(0x0200000200400100), 0x1.0000010020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200401000), 0x1.000001002008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200410000), 0x1.00000100208p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200500000), 0x1.0000010028p+57, 0x0p+0 },
+{ UINT64_C(0x0200000200600000), 0x1.000001003p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201000000), 0x1.000001008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201000002), 0x1.000001008p+57, 0x1p+1 },
+{ UINT64_C(0x0200000201000020), 0x1.0000010080001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201000080), 0x1.0000010080004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201000800), 0x1.000001008004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201002000), 0x1.00000100801p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201008000), 0x1.00000100804p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201080000), 0x1.0000010084p+57, 0x0p+0 },
+{ UINT64_C(0x0200000201800000), 0x1.00000100cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000210000000), 0x1.00000108p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210000002), 0x1.00000108p+57, 0x1p+1 },
+{ UINT64_C(0x0200000210000010), 0x1.00000108p+57, 0x1p+4 },
+{ UINT64_C(0x0200000210000080), 0x1.0000010800004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210000100), 0x1.0000010800008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210000800), 0x1.000001080004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210004000), 0x1.00000108002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210010000), 0x1.00000108008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210100000), 0x1.0000010808p+57, 0x0p+0 },
+{ UINT64_C(0x0200000210800000), 0x1.000001084p+57, 0x0p+0 },
+{ UINT64_C(0x0200000218000000), 0x1.0000010cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000280000000), 0x1.0000014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280000008), 0x1.0000014p+57, 0x1p+3 },
+{ UINT64_C(0x0200000280000020), 0x1.0000014000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280000080), 0x1.0000014000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280000800), 0x1.000001400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280008000), 0x1.00000140004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280040000), 0x1.0000014002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280080000), 0x1.0000014004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280400000), 0x1.000001402p+57, 0x0p+0 },
+{ UINT64_C(0x0200000280800000), 0x1.000001404p+57, 0x0p+0 },
+{ UINT64_C(0x0200000288000000), 0x1.00000144p+57, 0x0p+0 },
+{ UINT64_C(0x02000002c0000000), 0x1.0000016p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400000004), 0x1.000002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000400000040), 0x1.0000020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400000041), 0x1.0000020000002p+57, 0x1p+0 },
+{ UINT64_C(0x0200000400000042), 0x1.0000020000002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000400000044), 0x1.0000020000002p+57, 0x1p+2 },
+{ UINT64_C(0x0200000400000100), 0x1.0000020000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400000104), 0x1.0000020000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200000400000140), 0x1.000002000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200000400000180), 0x1.000002000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200000400001000), 0x1.000002000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400001008), 0x1.000002000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200000400001020), 0x1.0000020000081p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400001200), 0x1.000002000009p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400010000), 0x1.00000200008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400010008), 0x1.00000200008p+57, 0x1p+3 },
+{ UINT64_C(0x0200000400010020), 0x1.0000020000801p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400010100), 0x1.0000020000808p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400010200), 0x1.000002000081p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400010800), 0x1.000002000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400014000), 0x1.0000020000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200000400020000), 0x1.0000020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400020002), 0x1.0000020001p+57, 0x1p+1 },
+{ UINT64_C(0x0200000400020010), 0x1.0000020001p+57, 0x1p+4 },
+{ UINT64_C(0x0200000400020080), 0x1.0000020001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400020100), 0x1.0000020001008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400020400), 0x1.000002000102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400020800), 0x1.000002000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400028000), 0x1.00000200014p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400030000), 0x1.00000200018p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400200000), 0x1.000002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400200001), 0x1.000002001p+57, 0x1p+0 },
+{ UINT64_C(0x0200000400200010), 0x1.000002001p+57, 0x1p+4 },
+{ UINT64_C(0x0200000400200080), 0x1.0000020010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400200400), 0x1.000002001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400200800), 0x1.000002001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400202000), 0x1.00000200101p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400204000), 0x1.00000200102p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400210000), 0x1.00000200108p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400240000), 0x1.0000020012p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400400000), 0x1.000002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400400002), 0x1.000002002p+57, 0x1p+1 },
+{ UINT64_C(0x0200000400400020), 0x1.0000020020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400400200), 0x1.000002002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400402000), 0x1.00000200201p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400410000), 0x1.00000200208p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400420000), 0x1.0000020021p+57, 0x0p+0 },
+{ UINT64_C(0x0200000400480000), 0x1.0000020024p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404000000), 0x1.00000202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404000002), 0x1.00000202p+57, 0x1p+1 },
+{ UINT64_C(0x0200000404000008), 0x1.00000202p+57, 0x1p+3 },
+{ UINT64_C(0x0200000404000080), 0x1.0000020200004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404000400), 0x1.000002020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404002000), 0x1.00000202001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404010000), 0x1.00000202008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404040000), 0x1.0000020202p+57, 0x0p+0 },
+{ UINT64_C(0x0200000404400000), 0x1.000002022p+57, 0x0p+0 },
+{ UINT64_C(0x0200000405000000), 0x1.000002028p+57, 0x0p+0 },
+{ UINT64_C(0x0200000406000000), 0x1.00000203p+57, 0x0p+0 },
+{ UINT64_C(0x0200000440000000), 0x1.0000022p+57, 0x0p+0 },
+{ UINT64_C(0x0200000440000004), 0x1.0000022p+57, 0x1p+2 },
+{ UINT64_C(0x0200000440000010), 0x1.0000022p+57, 0x1p+4 },
+{ UINT64_C(0x0200000440000080), 0x1.0000022000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000440000800), 0x1.000002200004p+57, 0x0p+0 },
+{ UINT64_C(0x0200000440002000), 0x1.00000220001p+57, 0x0p+0 },
+{ UINT64_C(0x0200000440010000), 0x1.00000220008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000440100000), 0x1.0000022008p+57, 0x0p+0 },
+{ UINT64_C(0x0200000441000000), 0x1.000002208p+57, 0x0p+0 },
+{ UINT64_C(0x0200000448000000), 0x1.00000224p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000008), 0x1.00002p+57, 0x1p+3 },
+{ UINT64_C(0x020000400000000a), 0x1.00002p+57, 0x1.4p+3 },
+{ UINT64_C(0x020000400000000c), 0x1.00002p+57, 0x1.8p+3 },
+{ UINT64_C(0x0200004000000020), 0x1.0000200000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000024), 0x1.0000200000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200004000000030), 0x1.0000200000002p+57, -0x1p+4 },
+{ UINT64_C(0x0200004000000040), 0x1.0000200000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000048), 0x1.0000200000002p+57, 0x1p+3 },
+{ UINT64_C(0x0200004000000050), 0x1.0000200000002p+57, 0x1p+4 },
+{ UINT64_C(0x0200004000000100), 0x1.0000200000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000104), 0x1.0000200000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200004000000140), 0x1.000020000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000400), 0x1.000020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000404), 0x1.000020000002p+57, 0x1p+2 },
+{ UINT64_C(0x0200004000000420), 0x1.0000200000021p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000000440), 0x1.0000200000022p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000002000), 0x1.00002000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000002004), 0x1.00002000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200004000002008), 0x1.00002000001p+57, 0x1p+3 },
+{ UINT64_C(0x0200004000002040), 0x1.0000200000102p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000002100), 0x1.0000200000108p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000002400), 0x1.000020000012p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000010000), 0x1.00002000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000010001), 0x1.00002000008p+57, 0x1p+0 },
+{ UINT64_C(0x0200004000010002), 0x1.00002000008p+57, 0x1p+1 },
+{ UINT64_C(0x0200004000010008), 0x1.00002000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200004000010080), 0x1.0000200000804p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000010800), 0x1.000020000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000012000), 0x1.00002000009p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000040000), 0x1.0000200002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000040008), 0x1.0000200002p+57, 0x1p+3 },
+{ UINT64_C(0x0200004000040080), 0x1.0000200002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000040200), 0x1.000020000201p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000041000), 0x1.000020000208p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000050000), 0x1.00002000028p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000200000), 0x1.000020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000200008), 0x1.000020001p+57, 0x1p+3 },
+{ UINT64_C(0x0200004000200040), 0x1.0000200010002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000200080), 0x1.0000200010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000200400), 0x1.000020001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000202000), 0x1.00002000101p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000204000), 0x1.00002000102p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000240000), 0x1.0000200012p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000400000), 0x1.000020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000400002), 0x1.000020002p+57, 0x1p+1 },
+{ UINT64_C(0x0200004000400020), 0x1.0000200020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000400100), 0x1.0000200020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000400400), 0x1.000020002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000401000), 0x1.000020002008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000408000), 0x1.00002000204p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000440000), 0x1.0000200022p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000480000), 0x1.0000200024p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000800000), 0x1.000020004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000800002), 0x1.000020004p+57, 0x1p+1 },
+{ UINT64_C(0x0200004000800020), 0x1.0000200040001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000800040), 0x1.0000200040002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000800080), 0x1.0000200040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000800100), 0x1.0000200040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000801000), 0x1.000020004008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000804000), 0x1.00002000402p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000810000), 0x1.00002000408p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000880000), 0x1.0000200044p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000a00000), 0x1.000020005p+57, 0x0p+0 },
+{ UINT64_C(0x0200004000c00000), 0x1.000020006p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004000000), 0x1.00002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004000002), 0x1.00002002p+57, 0x1p+1 },
+{ UINT64_C(0x0200004004000010), 0x1.00002002p+57, 0x1p+4 },
+{ UINT64_C(0x0200004004000020), 0x1.0000200200001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004000200), 0x1.000020020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004001000), 0x1.000020020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004008000), 0x1.00002002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004020000), 0x1.0000200201p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004080000), 0x1.0000200204p+57, 0x0p+0 },
+{ UINT64_C(0x0200004004800000), 0x1.000020024p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020000000), 0x1.0000201p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020000002), 0x1.0000201p+57, 0x1p+1 },
+{ UINT64_C(0x0200004020000004), 0x1.0000201p+57, 0x1p+2 },
+{ UINT64_C(0x0200004020000008), 0x1.0000201p+57, 0x1p+3 },
+{ UINT64_C(0x0200004020000080), 0x1.0000201000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020000400), 0x1.000020100002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020004000), 0x1.00002010002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020040000), 0x1.0000201002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020100000), 0x1.0000201008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004020800000), 0x1.000020104p+57, 0x0p+0 },
+{ UINT64_C(0x0200004022000000), 0x1.00002011p+57, 0x0p+0 },
+{ UINT64_C(0x0200004024000000), 0x1.00002012p+57, 0x0p+0 },
+{ UINT64_C(0x0200004028000000), 0x1.00002014p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100000000), 0x1.0000208p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100000001), 0x1.0000208p+57, 0x1p+0 },
+{ UINT64_C(0x0200004100000002), 0x1.0000208p+57, 0x1p+1 },
+{ UINT64_C(0x0200004100000010), 0x1.0000208p+57, 0x1p+4 },
+{ UINT64_C(0x0200004100000020), 0x1.0000208000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100000040), 0x1.0000208000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100000100), 0x1.0000208000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100000400), 0x1.000020800002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100001000), 0x1.000020800008p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100008000), 0x1.00002080004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100020000), 0x1.0000208001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100200000), 0x1.000020801p+57, 0x0p+0 },
+{ UINT64_C(0x0200004100400000), 0x1.000020802p+57, 0x0p+0 },
+{ UINT64_C(0x0200004101000000), 0x1.000020808p+57, 0x0p+0 },
+{ UINT64_C(0x0200004102000000), 0x1.00002081p+57, 0x0p+0 },
+{ UINT64_C(0x0200004104000000), 0x1.00002082p+57, 0x0p+0 },
+{ UINT64_C(0x0200004140000000), 0x1.000020ap+57, 0x0p+0 },
+{ UINT64_C(0x0200004200000000), 0x1.000021p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200000001), 0x1.000021p+57, 0x1p+0 },
+{ UINT64_C(0x0200004200000008), 0x1.000021p+57, 0x1p+3 },
+{ UINT64_C(0x0200004200000040), 0x1.0000210000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200000200), 0x1.000021000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200000400), 0x1.000021000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200002000), 0x1.00002100001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200004000), 0x1.00002100002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200020000), 0x1.0000210001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200080000), 0x1.0000210004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200400000), 0x1.000021002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004200800000), 0x1.000021004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004204000000), 0x1.00002102p+57, 0x0p+0 },
+{ UINT64_C(0x0200004210000000), 0x1.00002108p+57, 0x0p+0 },
+{ UINT64_C(0x0200004220000000), 0x1.0000211p+57, 0x0p+0 },
+{ UINT64_C(0x0200004280000000), 0x1.0000214p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400000000), 0x1.000022p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400000004), 0x1.000022p+57, 0x1p+2 },
+{ UINT64_C(0x0200004400000008), 0x1.000022p+57, 0x1p+3 },
+{ UINT64_C(0x0200004400000080), 0x1.0000220000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400000800), 0x1.000022000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400004000), 0x1.00002200002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400020000), 0x1.0000220001p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400040000), 0x1.0000220002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004400400000), 0x1.000022002p+57, 0x0p+0 },
+{ UINT64_C(0x0200004402000000), 0x1.00002201p+57, 0x0p+0 },
+{ UINT64_C(0x0200004420000000), 0x1.0000221p+57, 0x0p+0 },
+{ UINT64_C(0x0200004600000000), 0x1.000023p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000000000), 0x1.00003p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000000004), 0x1.00003p+57, 0x1p+2 },
+{ UINT64_C(0x0200006000000010), 0x1.00003p+57, 0x1p+4 },
+{ UINT64_C(0x0200006000000040), 0x1.0000300000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000000200), 0x1.000030000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000000400), 0x1.000030000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000000800), 0x1.000030000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000004000), 0x1.00003000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000010000), 0x1.00003000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000040000), 0x1.0000300002p+57, 0x0p+0 },
+{ UINT64_C(0x0200006000200000), 0x1.000030001p+57, 0x0p+0 },
+{ UINT64_C(0x0200006002000000), 0x1.00003001p+57, 0x0p+0 },
+{ UINT64_C(0x0200006010000000), 0x1.00003008p+57, 0x0p+0 },
+{ UINT64_C(0x0200006020000000), 0x1.0000301p+57, 0x0p+0 },
+{ UINT64_C(0x0200006040000000), 0x1.0000302p+57, 0x0p+0 },
+{ UINT64_C(0x0200006100000000), 0x1.0000308p+57, 0x0p+0 },
+{ UINT64_C(0x0200006800000000), 0x1.000034p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000000002), 0x1.00004p+57, 0x1p+1 },
+{ UINT64_C(0x0200008000000020), 0x1.0000400000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000000021), 0x1.0000400000001p+57, 0x1p+0 },
+{ UINT64_C(0x0200008000000024), 0x1.0000400000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200008000000028), 0x1.0000400000001p+57, 0x1p+3 },
+{ UINT64_C(0x0200008000000100), 0x1.0000400000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000000101), 0x1.0000400000008p+57, 0x1p+0 },
+{ UINT64_C(0x0200008000000104), 0x1.0000400000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200008000000108), 0x1.0000400000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200008000000110), 0x1.0000400000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200008000000120), 0x1.0000400000009p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000000180), 0x1.000040000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200008000000200), 0x1.000040000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000000202), 0x1.000040000001p+57, 0x1p+1 },
+{ UINT64_C(0x0200008000000210), 0x1.000040000001p+57, 0x1p+4 },
+{ UINT64_C(0x0200008000000220), 0x1.0000400000011p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000001000), 0x1.000040000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000001004), 0x1.000040000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200008000001008), 0x1.000040000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200008000001080), 0x1.0000400000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000001800), 0x1.00004000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200008000010000), 0x1.00004000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000010002), 0x1.00004000008p+57, 0x1p+1 },
+{ UINT64_C(0x0200008000010004), 0x1.00004000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200008000010020), 0x1.0000400000801p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000010200), 0x1.000040000081p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000012000), 0x1.00004000009p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000020000), 0x1.0000400001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000020001), 0x1.0000400001p+57, 0x1p+0 },
+{ UINT64_C(0x0200008000020004), 0x1.0000400001p+57, 0x1p+2 },
+{ UINT64_C(0x0200008000020010), 0x1.0000400001p+57, 0x1p+4 },
+{ UINT64_C(0x0200008000020080), 0x1.0000400001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000020800), 0x1.000040000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000028000), 0x1.00004000014p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000080000), 0x1.0000400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000080004), 0x1.0000400004p+57, 0x1p+2 },
+{ UINT64_C(0x0200008000080040), 0x1.0000400004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000080200), 0x1.000040000401p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000082000), 0x1.00004000041p+57, 0x0p+0 },
+{ UINT64_C(0x02000080000a0000), 0x1.0000400005p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000800000), 0x1.000040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000800001), 0x1.000040004p+57, 0x1p+0 },
+{ UINT64_C(0x0200008000800010), 0x1.000040004p+57, 0x1p+4 },
+{ UINT64_C(0x0200008000800080), 0x1.0000400040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000800100), 0x1.0000400040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000800400), 0x1.000040004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000800800), 0x1.000040004004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000808000), 0x1.00004000404p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000820000), 0x1.0000400041p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000900000), 0x1.0000400048p+57, 0x0p+0 },
+{ UINT64_C(0x0200008000c00000), 0x1.000040006p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001000000), 0x1.000040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001000008), 0x1.000040008p+57, 0x1p+3 },
+{ UINT64_C(0x0200008001000040), 0x1.0000400080002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001000080), 0x1.0000400080004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001000200), 0x1.000040008001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001001000), 0x1.000040008008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001002000), 0x1.00004000801p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001004000), 0x1.00004000802p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001040000), 0x1.0000400082p+57, 0x0p+0 },
+{ UINT64_C(0x0200008001400000), 0x1.00004000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200008004000000), 0x1.00004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004000004), 0x1.00004002p+57, 0x1p+2 },
+{ UINT64_C(0x0200008004000020), 0x1.0000400200001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004000200), 0x1.000040020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004000400), 0x1.000040020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004001000), 0x1.000040020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004002000), 0x1.00004002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004004000), 0x1.00004002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004008000), 0x1.00004002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004080000), 0x1.0000400204p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004200000), 0x1.000040021p+57, 0x0p+0 },
+{ UINT64_C(0x0200008004800000), 0x1.000040024p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020000000), 0x1.0000401p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020000002), 0x1.0000401p+57, 0x1p+1 },
+{ UINT64_C(0x0200008020000004), 0x1.0000401p+57, 0x1p+2 },
+{ UINT64_C(0x0200008020000020), 0x1.0000401000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020000200), 0x1.000040100001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020002000), 0x1.00004010001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020008000), 0x1.00004010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020020000), 0x1.0000401001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008020100000), 0x1.0000401008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008021000000), 0x1.000040108p+57, 0x0p+0 },
+{ UINT64_C(0x0200008028000000), 0x1.00004014p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080000000), 0x1.0000404p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080000002), 0x1.0000404p+57, 0x1p+1 },
+{ UINT64_C(0x0200008080000004), 0x1.0000404p+57, 0x1p+2 },
+{ UINT64_C(0x0200008080000040), 0x1.0000404000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080000200), 0x1.000040400001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080000400), 0x1.000040400002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080001000), 0x1.000040400008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080004000), 0x1.00004040002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080040000), 0x1.0000404002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080400000), 0x1.000040402p+57, 0x0p+0 },
+{ UINT64_C(0x0200008080800000), 0x1.000040404p+57, 0x0p+0 },
+{ UINT64_C(0x0200008081000000), 0x1.000040408p+57, 0x0p+0 },
+{ UINT64_C(0x0200008082000000), 0x1.00004041p+57, 0x0p+0 },
+{ UINT64_C(0x0200008088000000), 0x1.00004044p+57, 0x0p+0 },
+{ UINT64_C(0x0200008090000000), 0x1.00004048p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800000000), 0x1.000044p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800000001), 0x1.000044p+57, 0x1p+0 },
+{ UINT64_C(0x0200008800000010), 0x1.000044p+57, 0x1p+4 },
+{ UINT64_C(0x0200008800000080), 0x1.0000440000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800000200), 0x1.000044000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800000800), 0x1.000044000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800001000), 0x1.000044000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800010000), 0x1.00004400008p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800040000), 0x1.0000440002p+57, 0x0p+0 },
+{ UINT64_C(0x0200008800200000), 0x1.000044001p+57, 0x0p+0 },
+{ UINT64_C(0x0200008802000000), 0x1.00004401p+57, 0x0p+0 },
+{ UINT64_C(0x0200008820000000), 0x1.0000441p+57, 0x0p+0 },
+{ UINT64_C(0x0200008840000000), 0x1.0000442p+57, 0x0p+0 },
+{ UINT64_C(0x0200008880000000), 0x1.0000444p+57, 0x0p+0 },
+{ UINT64_C(0x0200008c00000000), 0x1.000046p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000004), 0x1.0002p+57, 0x1p+2 },
+{ UINT64_C(0x0200040000000006), 0x1.0002p+57, 0x1.8p+2 },
+{ UINT64_C(0x0200040000000040), 0x1.0002000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000041), 0x1.0002000000002p+57, 0x1p+0 },
+{ UINT64_C(0x0200040000000050), 0x1.0002000000002p+57, 0x1p+4 },
+{ UINT64_C(0x0200040000000200), 0x1.000200000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000204), 0x1.000200000001p+57, 0x1p+2 },
+{ UINT64_C(0x0200040000000220), 0x1.0002000000011p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000300), 0x1.0002000000018p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000800), 0x1.000200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000801), 0x1.000200000004p+57, 0x1p+0 },
+{ UINT64_C(0x0200040000000808), 0x1.000200000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200040000000810), 0x1.000200000004p+57, 0x1p+4 },
+{ UINT64_C(0x0200040000000900), 0x1.0002000000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000000c00), 0x1.000200000006p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000001000), 0x1.000200000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000001001), 0x1.000200000008p+57, 0x1p+0 },
+{ UINT64_C(0x0200040000001002), 0x1.000200000008p+57, 0x1p+1 },
+{ UINT64_C(0x0200040000001004), 0x1.000200000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200040000001010), 0x1.000200000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200040000001100), 0x1.0002000000088p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000001400), 0x1.00020000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200040000008000), 0x1.00020000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000008004), 0x1.00020000004p+57, 0x1p+2 },
+{ UINT64_C(0x0200040000008040), 0x1.0002000000402p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000008100), 0x1.0002000000408p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000008800), 0x1.000200000044p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000009000), 0x1.000200000048p+57, 0x0p+0 },
+{ UINT64_C(0x020004000000a000), 0x1.00020000005p+57, 0x0p+0 },
+{ UINT64_C(0x020004000000c000), 0x1.00020000006p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000040000), 0x1.0002000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000040002), 0x1.0002000002p+57, 0x1p+1 },
+{ UINT64_C(0x0200040000040020), 0x1.0002000002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000040080), 0x1.0002000002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000040200), 0x1.000200000201p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000040400), 0x1.000200000202p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000040800), 0x1.000200000204p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000048000), 0x1.00020000024p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000060000), 0x1.0002000003p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000080000), 0x1.0002000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000080004), 0x1.0002000004p+57, 0x1p+2 },
+{ UINT64_C(0x0200040000080008), 0x1.0002000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200040000080080), 0x1.0002000004004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000080800), 0x1.000200000404p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000081000), 0x1.000200000408p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000090000), 0x1.00020000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000100000), 0x1.0002000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000100004), 0x1.0002000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200040000100008), 0x1.0002000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200040000100010), 0x1.0002000008p+57, 0x1p+4 },
+{ UINT64_C(0x0200040000100020), 0x1.0002000008001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000100200), 0x1.000200000801p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000100800), 0x1.000200000804p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000104000), 0x1.00020000082p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000110000), 0x1.00020000088p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000200000), 0x1.000200001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000200008), 0x1.000200001p+57, 0x1p+3 },
+{ UINT64_C(0x0200040000200040), 0x1.0002000010002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000200400), 0x1.000200001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000204000), 0x1.00020000102p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000208000), 0x1.00020000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000210000), 0x1.00020000108p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000220000), 0x1.0002000011p+57, 0x0p+0 },
+{ UINT64_C(0x0200040000300000), 0x1.0002000018p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002000000), 0x1.00020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002000002), 0x1.00020001p+57, 0x1p+1 },
+{ UINT64_C(0x0200040002000010), 0x1.00020001p+57, 0x1p+4 },
+{ UINT64_C(0x0200040002000020), 0x1.0002000100001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002000040), 0x1.0002000100002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002000100), 0x1.0002000100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002000800), 0x1.000200010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002004000), 0x1.00020001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002008000), 0x1.00020001004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002010000), 0x1.00020001008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002100000), 0x1.0002000108p+57, 0x0p+0 },
+{ UINT64_C(0x0200040002400000), 0x1.000200012p+57, 0x0p+0 },
+{ UINT64_C(0x0200040003000000), 0x1.000200018p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020000000), 0x1.0002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020000002), 0x1.0002001p+57, 0x1p+1 },
+{ UINT64_C(0x0200040020000010), 0x1.0002001p+57, 0x1p+4 },
+{ UINT64_C(0x0200040020000040), 0x1.0002001000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020000400), 0x1.000200100002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020002000), 0x1.00020010001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020020000), 0x1.0002001001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020100000), 0x1.0002001008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040020800000), 0x1.000200104p+57, 0x0p+0 },
+{ UINT64_C(0x0200040021000000), 0x1.000200108p+57, 0x0p+0 },
+{ UINT64_C(0x0200040022000000), 0x1.00020011p+57, 0x0p+0 },
+{ UINT64_C(0x0200040030000000), 0x1.00020018p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100000000), 0x1.0002008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100000002), 0x1.0002008p+57, 0x1p+1 },
+{ UINT64_C(0x0200040100000004), 0x1.0002008p+57, 0x1p+2 },
+{ UINT64_C(0x0200040100000008), 0x1.0002008p+57, 0x1p+3 },
+{ UINT64_C(0x0200040100000020), 0x1.0002008000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100000080), 0x1.0002008000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100000800), 0x1.000200800004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100002000), 0x1.00020080001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100020000), 0x1.0002008001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100040000), 0x1.0002008002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100200000), 0x1.000200801p+57, 0x0p+0 },
+{ UINT64_C(0x0200040100800000), 0x1.000200804p+57, 0x0p+0 },
+{ UINT64_C(0x0200040104000000), 0x1.00020082p+57, 0x0p+0 },
+{ UINT64_C(0x0200040110000000), 0x1.00020088p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200000000), 0x1.000201p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200000001), 0x1.000201p+57, 0x1p+0 },
+{ UINT64_C(0x0200040200000004), 0x1.000201p+57, 0x1p+2 },
+{ UINT64_C(0x0200040200000020), 0x1.0002010000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200000100), 0x1.0002010000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200001000), 0x1.000201000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200010000), 0x1.00020100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200100000), 0x1.0002010008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040200400000), 0x1.000201002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040201000000), 0x1.000201008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040210000000), 0x1.00020108p+57, 0x0p+0 },
+{ UINT64_C(0x0200040220000000), 0x1.0002011p+57, 0x0p+0 },
+{ UINT64_C(0x0200040240000000), 0x1.0002012p+57, 0x0p+0 },
+{ UINT64_C(0x0200040280000000), 0x1.0002014p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800000000), 0x1.000204p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800000002), 0x1.000204p+57, 0x1p+1 },
+{ UINT64_C(0x0200040800000004), 0x1.000204p+57, 0x1p+2 },
+{ UINT64_C(0x0200040800000008), 0x1.000204p+57, 0x1p+3 },
+{ UINT64_C(0x0200040800000040), 0x1.0002040000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800000100), 0x1.0002040000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800000800), 0x1.000204000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800001000), 0x1.000204000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800004000), 0x1.00020400002p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800008000), 0x1.00020400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800080000), 0x1.0002040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040800800000), 0x1.000204004p+57, 0x0p+0 },
+{ UINT64_C(0x0200040808000000), 0x1.00020404p+57, 0x0p+0 },
+{ UINT64_C(0x0200040820000000), 0x1.0002041p+57, 0x0p+0 },
+{ UINT64_C(0x0200040900000000), 0x1.0002048p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000000000), 0x1.00021p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000000008), 0x1.00021p+57, 0x1p+3 },
+{ UINT64_C(0x0200042000000010), 0x1.00021p+57, 0x1p+4 },
+{ UINT64_C(0x0200042000000100), 0x1.0002100000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000000800), 0x1.000210000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000002000), 0x1.00021000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000008000), 0x1.00021000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000010000), 0x1.00021000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000100000), 0x1.0002100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200042000400000), 0x1.000210002p+57, 0x0p+0 },
+{ UINT64_C(0x0200042004000000), 0x1.00021002p+57, 0x0p+0 },
+{ UINT64_C(0x0200042040000000), 0x1.0002102p+57, 0x0p+0 },
+{ UINT64_C(0x0200042400000000), 0x1.000212p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000000000), 0x1.00022p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000000008), 0x1.00022p+57, 0x1p+3 },
+{ UINT64_C(0x0200044000000010), 0x1.00022p+57, 0x1p+4 },
+{ UINT64_C(0x0200044000000080), 0x1.0002200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000000100), 0x1.0002200000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000000400), 0x1.000220000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000001000), 0x1.000220000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000004000), 0x1.00022000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000008000), 0x1.00022000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000080000), 0x1.0002200004p+57, 0x0p+0 },
+{ UINT64_C(0x0200044000800000), 0x1.000220004p+57, 0x0p+0 },
+{ UINT64_C(0x0200044002000000), 0x1.00022001p+57, 0x0p+0 },
+{ UINT64_C(0x0200044004000000), 0x1.00022002p+57, 0x0p+0 },
+{ UINT64_C(0x0200044020000000), 0x1.0002201p+57, 0x0p+0 },
+{ UINT64_C(0x0200044080000000), 0x1.0002204p+57, 0x0p+0 },
+{ UINT64_C(0x0200044400000000), 0x1.000222p+57, 0x0p+0 },
+{ UINT64_C(0x0200046000000000), 0x1.00023p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000000000), 0x1.0003p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000000002), 0x1.0003p+57, 0x1p+1 },
+{ UINT64_C(0x0200060000000020), 0x1.0003000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000000080), 0x1.0003000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000000200), 0x1.000300000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000002000), 0x1.00030000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000020000), 0x1.0003000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000080000), 0x1.0003000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000400000), 0x1.000300002p+57, 0x0p+0 },
+{ UINT64_C(0x0200060000800000), 0x1.000300004p+57, 0x0p+0 },
+{ UINT64_C(0x0200060002000000), 0x1.00030001p+57, 0x0p+0 },
+{ UINT64_C(0x0200060010000000), 0x1.00030008p+57, 0x0p+0 },
+{ UINT64_C(0x0200060100000000), 0x1.0003008p+57, 0x0p+0 },
+{ UINT64_C(0x0200061000000000), 0x1.000308p+57, 0x0p+0 },
+{ UINT64_C(0x0200062000000000), 0x1.00031p+57, 0x0p+0 },
+{ UINT64_C(0x0200064000000000), 0x1.00032p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000004), 0x1.002p+57, 0x1p+2 },
+{ UINT64_C(0x0200400000000006), 0x1.002p+57, 0x1.8p+2 },
+{ UINT64_C(0x0200400000000010), 0x1.002p+57, 0x1p+4 },
+{ UINT64_C(0x0200400000000014), 0x1.0020000000001p+57, -0x1.8p+3 },
+{ UINT64_C(0x0200400000000080), 0x1.0020000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000088), 0x1.0020000000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200400000000200), 0x1.002000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000201), 0x1.002000000001p+57, 0x1p+0 },
+{ UINT64_C(0x0200400000000202), 0x1.002000000001p+57, 0x1p+1 },
+{ UINT64_C(0x0200400000000210), 0x1.002000000001p+57, 0x1p+4 },
+{ UINT64_C(0x0200400000000280), 0x1.0020000000014p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000800), 0x1.002000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000801), 0x1.002000000004p+57, 0x1p+0 },
+{ UINT64_C(0x0200400000000808), 0x1.002000000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200400000000810), 0x1.002000000004p+57, 0x1p+4 },
+{ UINT64_C(0x0200400000000840), 0x1.0020000000042p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000880), 0x1.0020000000044p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000900), 0x1.0020000000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000000a00), 0x1.002000000005p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000008000), 0x1.00200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000008002), 0x1.00200000004p+57, 0x1p+1 },
+{ UINT64_C(0x0200400000008020), 0x1.0020000000401p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000008200), 0x1.002000000041p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000009000), 0x1.002000000048p+57, 0x0p+0 },
+{ UINT64_C(0x020040000000c000), 0x1.00200000006p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000040000), 0x1.0020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000040001), 0x1.0020000002p+57, 0x1p+0 },
+{ UINT64_C(0x0200400000040010), 0x1.0020000002p+57, 0x1p+4 },
+{ UINT64_C(0x0200400000040080), 0x1.0020000002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000040100), 0x1.0020000002008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000040800), 0x1.002000000204p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000042000), 0x1.00200000021p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000044000), 0x1.00200000022p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000060000), 0x1.0020000003p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000400000), 0x1.002000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000400002), 0x1.002000002p+57, 0x1p+1 },
+{ UINT64_C(0x0200400000400004), 0x1.002000002p+57, 0x1p+2 },
+{ UINT64_C(0x0200400000400020), 0x1.0020000020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000400040), 0x1.0020000020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000400100), 0x1.0020000020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000401000), 0x1.002000002008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000402000), 0x1.00200000201p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000410000), 0x1.00200000208p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000500000), 0x1.0020000028p+57, 0x0p+0 },
+{ UINT64_C(0x0200400000600000), 0x1.002000003p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001000000), 0x1.002000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001000001), 0x1.002000008p+57, 0x1p+0 },
+{ UINT64_C(0x0200400001000008), 0x1.002000008p+57, 0x1p+3 },
+{ UINT64_C(0x0200400001000020), 0x1.0020000080001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001000100), 0x1.0020000080008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001000400), 0x1.002000008002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001000800), 0x1.002000008004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001008000), 0x1.00200000804p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001040000), 0x1.0020000082p+57, 0x0p+0 },
+{ UINT64_C(0x0200400001400000), 0x1.00200000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200400004000000), 0x1.00200002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004000004), 0x1.00200002p+57, 0x1p+2 },
+{ UINT64_C(0x0200400004000040), 0x1.0020000200002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004000400), 0x1.002000020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004002000), 0x1.00200002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004004000), 0x1.00200002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004040000), 0x1.0020000202p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004100000), 0x1.0020000208p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004400000), 0x1.002000022p+57, 0x0p+0 },
+{ UINT64_C(0x0200400004800000), 0x1.002000024p+57, 0x0p+0 },
+{ UINT64_C(0x0200400006000000), 0x1.00200003p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020000000), 0x1.0020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020000002), 0x1.0020001p+57, 0x1p+1 },
+{ UINT64_C(0x0200400020000004), 0x1.0020001p+57, 0x1p+2 },
+{ UINT64_C(0x0200400020000020), 0x1.0020001000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020000040), 0x1.0020001000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020000200), 0x1.002000100001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020000400), 0x1.002000100002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020001000), 0x1.002000100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020002000), 0x1.00200010001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020008000), 0x1.00200010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020020000), 0x1.0020001001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020100000), 0x1.0020001008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400020800000), 0x1.002000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200400024000000), 0x1.00200012p+57, 0x0p+0 },
+{ UINT64_C(0x0200400030000000), 0x1.00200018p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040000000), 0x1.0020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040000008), 0x1.0020002p+57, 0x1p+3 },
+{ UINT64_C(0x0200400040000020), 0x1.0020002000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040000040), 0x1.0020002000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040000080), 0x1.0020002000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040000800), 0x1.002000200004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040004000), 0x1.00200020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040020000), 0x1.0020002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040080000), 0x1.0020002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400040800000), 0x1.002000204p+57, 0x0p+0 },
+{ UINT64_C(0x0200400042000000), 0x1.00200021p+57, 0x0p+0 },
+{ UINT64_C(0x0200400060000000), 0x1.0020003p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080000000), 0x1.0020004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080000002), 0x1.0020004p+57, 0x1p+1 },
+{ UINT64_C(0x0200400080000020), 0x1.0020004000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080000200), 0x1.002000400001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080000800), 0x1.002000400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080008000), 0x1.00200040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080040000), 0x1.0020004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400080400000), 0x1.002000402p+57, 0x0p+0 },
+{ UINT64_C(0x0200400084000000), 0x1.00200042p+57, 0x0p+0 },
+{ UINT64_C(0x0200400090000000), 0x1.00200048p+57, 0x0p+0 },
+{ UINT64_C(0x02004000c0000000), 0x1.0020006p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800000000), 0x1.002004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800000002), 0x1.002004p+57, 0x1p+1 },
+{ UINT64_C(0x0200400800000010), 0x1.002004p+57, 0x1p+4 },
+{ UINT64_C(0x0200400800000100), 0x1.0020040000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800000400), 0x1.002004000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800001000), 0x1.002004000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800010000), 0x1.00200400008p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800020000), 0x1.0020040001p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800080000), 0x1.0020040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800400000), 0x1.002004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200400800800000), 0x1.002004004p+57, 0x0p+0 },
+{ UINT64_C(0x0200400804000000), 0x1.00200402p+57, 0x0p+0 },
+{ UINT64_C(0x0200400810000000), 0x1.00200408p+57, 0x0p+0 },
+{ UINT64_C(0x0200400820000000), 0x1.0020041p+57, 0x0p+0 },
+{ UINT64_C(0x0200400880000000), 0x1.0020044p+57, 0x0p+0 },
+{ UINT64_C(0x0200400c00000000), 0x1.002006p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000000000), 0x1.00201p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000000002), 0x1.00201p+57, 0x1p+1 },
+{ UINT64_C(0x0200402000000004), 0x1.00201p+57, 0x1p+2 },
+{ UINT64_C(0x0200402000000010), 0x1.00201p+57, 0x1p+4 },
+{ UINT64_C(0x0200402000000040), 0x1.0020100000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000000200), 0x1.002010000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000000400), 0x1.002010000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000001000), 0x1.002010000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000002000), 0x1.00201000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000010000), 0x1.00201000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000080000), 0x1.0020100004p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000100000), 0x1.0020100008p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000400000), 0x1.002010002p+57, 0x0p+0 },
+{ UINT64_C(0x0200402000800000), 0x1.002010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200402002000000), 0x1.00201001p+57, 0x0p+0 },
+{ UINT64_C(0x0200402004000000), 0x1.00201002p+57, 0x0p+0 },
+{ UINT64_C(0x0200402010000000), 0x1.00201008p+57, 0x0p+0 },
+{ UINT64_C(0x0200402040000000), 0x1.0020102p+57, 0x0p+0 },
+{ UINT64_C(0x0200402100000000), 0x1.0020108p+57, 0x0p+0 },
+{ UINT64_C(0x0200403000000000), 0x1.002018p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000000000), 0x1.00204p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000000008), 0x1.00204p+57, 0x1p+3 },
+{ UINT64_C(0x0200408000000020), 0x1.0020400000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000000100), 0x1.0020400000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000000400), 0x1.002040000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000002000), 0x1.00204000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000010000), 0x1.00204000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000040000), 0x1.0020400002p+57, 0x0p+0 },
+{ UINT64_C(0x0200408000100000), 0x1.0020400008p+57, 0x0p+0 },
+{ UINT64_C(0x0200408001000000), 0x1.002040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200408008000000), 0x1.00204004p+57, 0x0p+0 },
+{ UINT64_C(0x0200408020000000), 0x1.0020401p+57, 0x0p+0 },
+{ UINT64_C(0x0200408200000000), 0x1.002041p+57, 0x0p+0 },
+{ UINT64_C(0x0200409000000000), 0x1.002048p+57, 0x0p+0 },
+{ UINT64_C(0x020040c000000000), 0x1.00206p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000000000), 0x1.0021p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000000002), 0x1.0021p+57, 0x1p+1 },
+{ UINT64_C(0x0200420000000004), 0x1.0021p+57, 0x1p+2 },
+{ UINT64_C(0x0200420000000010), 0x1.0021p+57, 0x1p+4 },
+{ UINT64_C(0x0200420000000080), 0x1.0021000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000000200), 0x1.002100000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000000800), 0x1.002100000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000004000), 0x1.00210000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000008000), 0x1.00210000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000040000), 0x1.0021000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000400000), 0x1.002100002p+57, 0x0p+0 },
+{ UINT64_C(0x0200420000800000), 0x1.002100004p+57, 0x0p+0 },
+{ UINT64_C(0x0200420002000000), 0x1.00210001p+57, 0x0p+0 },
+{ UINT64_C(0x0200420008000000), 0x1.00210004p+57, 0x0p+0 },
+{ UINT64_C(0x0200420010000000), 0x1.00210008p+57, 0x0p+0 },
+{ UINT64_C(0x0200420020000000), 0x1.0021001p+57, 0x0p+0 },
+{ UINT64_C(0x0200420200000000), 0x1.002101p+57, 0x0p+0 },
+{ UINT64_C(0x0200422000000000), 0x1.00211p+57, 0x0p+0 },
+{ UINT64_C(0x0200428000000000), 0x1.00214p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000000000), 0x1.0028p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000000004), 0x1.0028p+57, 0x1p+2 },
+{ UINT64_C(0x0200500000000040), 0x1.0028000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000000400), 0x1.002800000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000002000), 0x1.00280000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000020000), 0x1.0028000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000100000), 0x1.0028000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000200000), 0x1.002800001p+57, 0x0p+0 },
+{ UINT64_C(0x0200500000800000), 0x1.002800004p+57, 0x0p+0 },
+{ UINT64_C(0x0200500002000000), 0x1.00280001p+57, 0x0p+0 },
+{ UINT64_C(0x0200500020000000), 0x1.0028001p+57, 0x0p+0 },
+{ UINT64_C(0x0200500080000000), 0x1.0028004p+57, 0x0p+0 },
+{ UINT64_C(0x0200500800000000), 0x1.002804p+57, 0x0p+0 },
+{ UINT64_C(0x0200502000000000), 0x1.00281p+57, 0x0p+0 },
+{ UINT64_C(0x0200520000000000), 0x1.0029p+57, 0x0p+0 },
+{ UINT64_C(0x0200540000000000), 0x1.002ap+57, 0x0p+0 },
+{ UINT64_C(0x0200580000000000), 0x1.002cp+57, 0x0p+0 },
+{ UINT64_C(0x0200800000000002), 0x1.004p+57, 0x1p+1 },
+{ UINT64_C(0x0200800000000010), 0x1.004p+57, 0x1p+4 },
+{ UINT64_C(0x0200800000000012), 0x1.0040000000001p+57, -0x1.cp+3 },
+{ UINT64_C(0x0200800000000018), 0x1.0040000000001p+57, -0x1p+3 },
+{ UINT64_C(0x0200800000000080), 0x1.0040000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000000084), 0x1.0040000000004p+57, 0x1p+2 },
+{ UINT64_C(0x0200800000000088), 0x1.0040000000004p+57, 0x1p+3 },
+{ UINT64_C(0x02008000000000a0), 0x1.0040000000005p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000000400), 0x1.004000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000000408), 0x1.004000000002p+57, 0x1p+3 },
+{ UINT64_C(0x0200800000000480), 0x1.0040000000024p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000002000), 0x1.00400000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000002001), 0x1.00400000001p+57, 0x1p+0 },
+{ UINT64_C(0x0200800000002008), 0x1.00400000001p+57, 0x1p+3 },
+{ UINT64_C(0x0200800000002080), 0x1.0040000000104p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000002400), 0x1.004000000012p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000002800), 0x1.004000000014p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000008000), 0x1.00400000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000008002), 0x1.00400000004p+57, 0x1p+1 },
+{ UINT64_C(0x0200800000008008), 0x1.00400000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200800000008020), 0x1.0040000000401p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000008200), 0x1.004000000041p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000008400), 0x1.004000000042p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000008800), 0x1.004000000044p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000010000), 0x1.00400000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000010002), 0x1.00400000008p+57, 0x1p+1 },
+{ UINT64_C(0x0200800000010004), 0x1.00400000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200800000010040), 0x1.0040000000802p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000010200), 0x1.004000000081p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000010800), 0x1.004000000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000014000), 0x1.0040000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200800000018000), 0x1.0040000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200800000100000), 0x1.0040000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000100004), 0x1.0040000008p+57, 0x1p+2 },
+{ UINT64_C(0x0200800000100040), 0x1.0040000008002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000100100), 0x1.0040000008008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000101000), 0x1.004000000808p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000104000), 0x1.00400000082p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000108000), 0x1.00400000084p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000110000), 0x1.00400000088p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000180000), 0x1.004000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200800000800000), 0x1.004000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000800008), 0x1.004000004p+57, 0x1p+3 },
+{ UINT64_C(0x0200800000800040), 0x1.0040000040002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000800080), 0x1.0040000040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000800100), 0x1.0040000040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000800400), 0x1.004000004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000802000), 0x1.00400000401p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000808000), 0x1.00400000404p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000810000), 0x1.00400000408p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000900000), 0x1.0040000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000a00000), 0x1.004000005p+57, 0x0p+0 },
+{ UINT64_C(0x0200800000c00000), 0x1.004000006p+57, 0x0p+0 },
+{ UINT64_C(0x0200800008000000), 0x1.00400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800008000008), 0x1.00400004p+57, 0x1p+3 },
+{ UINT64_C(0x0200800008000080), 0x1.0040000400004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800008000800), 0x1.004000040004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800008008000), 0x1.00400004004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800008080000), 0x1.0040000404p+57, 0x0p+0 },
+{ UINT64_C(0x0200800008800000), 0x1.004000044p+57, 0x0p+0 },
+{ UINT64_C(0x0200800009000000), 0x1.004000048p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010000000), 0x1.00400008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010000001), 0x1.00400008p+57, 0x1p+0 },
+{ UINT64_C(0x0200800010000004), 0x1.00400008p+57, 0x1p+2 },
+{ UINT64_C(0x0200800010000008), 0x1.00400008p+57, 0x1p+3 },
+{ UINT64_C(0x0200800010000020), 0x1.0040000800001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010000100), 0x1.0040000800008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010000800), 0x1.004000080004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010001000), 0x1.004000080008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010008000), 0x1.00400008004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010020000), 0x1.0040000801p+57, 0x0p+0 },
+{ UINT64_C(0x0200800010200000), 0x1.004000081p+57, 0x0p+0 },
+{ UINT64_C(0x0200800011000000), 0x1.004000088p+57, 0x0p+0 },
+{ UINT64_C(0x0200800018000000), 0x1.0040000cp+57, 0x0p+0 },
+{ UINT64_C(0x0200800100000000), 0x1.0040008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800100000008), 0x1.0040008p+57, 0x1p+3 },
+{ UINT64_C(0x0200800100000040), 0x1.0040008000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800100000200), 0x1.004000800001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800100002000), 0x1.00400080001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800100010000), 0x1.00400080008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800100100000), 0x1.0040008008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800101000000), 0x1.004000808p+57, 0x0p+0 },
+{ UINT64_C(0x0200800102000000), 0x1.00400081p+57, 0x0p+0 },
+{ UINT64_C(0x0200800120000000), 0x1.0040009p+57, 0x0p+0 },
+{ UINT64_C(0x0200800140000000), 0x1.004000ap+57, 0x0p+0 },
+{ UINT64_C(0x0200800200000000), 0x1.004001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200000002), 0x1.004001p+57, 0x1p+1 },
+{ UINT64_C(0x0200800200000010), 0x1.004001p+57, 0x1p+4 },
+{ UINT64_C(0x0200800200000020), 0x1.0040010000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200000080), 0x1.0040010000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200000200), 0x1.004001000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200000400), 0x1.004001000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200000800), 0x1.004001000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200008000), 0x1.00400100004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200080000), 0x1.0040010004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800200400000), 0x1.004001002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800204000000), 0x1.00400102p+57, 0x0p+0 },
+{ UINT64_C(0x0200800220000000), 0x1.0040011p+57, 0x0p+0 },
+{ UINT64_C(0x0200800240000000), 0x1.0040012p+57, 0x0p+0 },
+{ UINT64_C(0x0200800280000000), 0x1.0040014p+57, 0x0p+0 },
+{ UINT64_C(0x0200800300000000), 0x1.0040018p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400000000), 0x1.004002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400000004), 0x1.004002p+57, 0x1p+2 },
+{ UINT64_C(0x0200800400000010), 0x1.004002p+57, 0x1p+4 },
+{ UINT64_C(0x0200800400000020), 0x1.0040020000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400000040), 0x1.0040020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400000100), 0x1.0040020000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400000800), 0x1.004002000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400004000), 0x1.00400200002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400020000), 0x1.0040020001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400100000), 0x1.0040020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400200000), 0x1.004002001p+57, 0x0p+0 },
+{ UINT64_C(0x0200800400400000), 0x1.004002002p+57, 0x0p+0 },
+{ UINT64_C(0x0200800404000000), 0x1.00400202p+57, 0x0p+0 },
+{ UINT64_C(0x0200800410000000), 0x1.00400208p+57, 0x0p+0 },
+{ UINT64_C(0x0200800500000000), 0x1.0040028p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000000000), 0x1.00402p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000000008), 0x1.00402p+57, 0x1p+3 },
+{ UINT64_C(0x0200804000000020), 0x1.0040200000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000000200), 0x1.004020000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000000800), 0x1.004020000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000001000), 0x1.004020000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000010000), 0x1.00402000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000100000), 0x1.0040200008p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000400000), 0x1.004020002p+57, 0x0p+0 },
+{ UINT64_C(0x0200804000800000), 0x1.004020004p+57, 0x0p+0 },
+{ UINT64_C(0x0200804001000000), 0x1.004020008p+57, 0x0p+0 },
+{ UINT64_C(0x0200804002000000), 0x1.00402001p+57, 0x0p+0 },
+{ UINT64_C(0x0200804020000000), 0x1.0040201p+57, 0x0p+0 },
+{ UINT64_C(0x0200804100000000), 0x1.0040208p+57, 0x0p+0 },
+{ UINT64_C(0x0200804800000000), 0x1.004024p+57, 0x0p+0 },
+{ UINT64_C(0x0200805000000000), 0x1.004028p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000000000), 0x1.00404p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000000004), 0x1.00404p+57, 0x1p+2 },
+{ UINT64_C(0x0200808000000010), 0x1.00404p+57, 0x1p+4 },
+{ UINT64_C(0x0200808000000080), 0x1.0040400000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000000200), 0x1.004040000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000002000), 0x1.00404000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000004000), 0x1.00404000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000008000), 0x1.00404000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000010000), 0x1.00404000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000020000), 0x1.0040400001p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000040000), 0x1.0040400002p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000200000), 0x1.004040001p+57, 0x0p+0 },
+{ UINT64_C(0x0200808000400000), 0x1.004040002p+57, 0x0p+0 },
+{ UINT64_C(0x0200808004000000), 0x1.00404002p+57, 0x0p+0 },
+{ UINT64_C(0x0200808010000000), 0x1.00404008p+57, 0x0p+0 },
+{ UINT64_C(0x0200808100000000), 0x1.0040408p+57, 0x0p+0 },
+{ UINT64_C(0x0200809000000000), 0x1.004048p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000000000), 0x1.0042p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000000008), 0x1.0042p+57, 0x1p+3 },
+{ UINT64_C(0x0200840000000080), 0x1.0042000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000000800), 0x1.004200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000004000), 0x1.00420000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000010000), 0x1.00420000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000080000), 0x1.0042000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200840000200000), 0x1.004200001p+57, 0x0p+0 },
+{ UINT64_C(0x0200840001000000), 0x1.004200008p+57, 0x0p+0 },
+{ UINT64_C(0x0200840008000000), 0x1.00420004p+57, 0x0p+0 },
+{ UINT64_C(0x0200840080000000), 0x1.0042004p+57, 0x0p+0 },
+{ UINT64_C(0x0200840100000000), 0x1.0042008p+57, 0x0p+0 },
+{ UINT64_C(0x0200840400000000), 0x1.004202p+57, 0x0p+0 },
+{ UINT64_C(0x0200841000000000), 0x1.004208p+57, 0x0p+0 },
+{ UINT64_C(0x0200850000000000), 0x1.00428p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000000000), 0x1.005p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000000001), 0x1.005p+57, 0x1p+0 },
+{ UINT64_C(0x0200a00000000004), 0x1.005p+57, 0x1p+2 },
+{ UINT64_C(0x0200a00000000008), 0x1.005p+57, 0x1p+3 },
+{ UINT64_C(0x0200a00000000010), 0x1.005p+57, 0x1p+4 },
+{ UINT64_C(0x0200a00000000040), 0x1.0050000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000000080), 0x1.0050000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000000800), 0x1.005000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000001000), 0x1.005000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000002000), 0x1.00500000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000020000), 0x1.0050000001p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000040000), 0x1.0050000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000400000), 0x1.005000002p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00000800000), 0x1.005000004p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00001000000), 0x1.005000008p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00010000000), 0x1.00500008p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00080000000), 0x1.0050004p+57, 0x0p+0 },
+{ UINT64_C(0x0200a00800000000), 0x1.005004p+57, 0x0p+0 },
+{ UINT64_C(0x0200a04000000000), 0x1.00502p+57, 0x0p+0 },
+{ UINT64_C(0x0200a20000000000), 0x1.0051p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000004), 0x1.02p+57, 0x1p+2 },
+{ UINT64_C(0x0204000000000020), 0x1.0200000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000022), 0x1.0200000000001p+57, 0x1p+1 },
+{ UINT64_C(0x0204000000000024), 0x1.0200000000001p+57, 0x1p+2 },
+{ UINT64_C(0x0204000000000100), 0x1.0200000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000101), 0x1.0200000000008p+57, 0x1p+0 },
+{ UINT64_C(0x0204000000000108), 0x1.0200000000008p+57, 0x1p+3 },
+{ UINT64_C(0x0204000000000180), 0x1.020000000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000400), 0x1.020000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000402), 0x1.020000000002p+57, 0x1p+1 },
+{ UINT64_C(0x0204000000000420), 0x1.0200000000021p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000440), 0x1.0200000000022p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000000500), 0x1.0200000000028p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000001000), 0x1.020000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000001001), 0x1.020000000008p+57, 0x1p+0 },
+{ UINT64_C(0x0204000000001002), 0x1.020000000008p+57, 0x1p+1 },
+{ UINT64_C(0x0204000000001008), 0x1.020000000008p+57, 0x1p+3 },
+{ UINT64_C(0x0204000000001020), 0x1.0200000000081p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000001200), 0x1.020000000009p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000001400), 0x1.02000000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0204000000001800), 0x1.02000000000cp+57, 0x0p+0 },
+{ UINT64_C(0x0204000000008000), 0x1.02000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000008002), 0x1.02000000004p+57, 0x1p+1 },
+{ UINT64_C(0x0204000000008008), 0x1.02000000004p+57, 0x1p+3 },
+{ UINT64_C(0x0204000000008080), 0x1.0200000000404p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000008800), 0x1.020000000044p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000009000), 0x1.020000000048p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000040000), 0x1.0200000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000040008), 0x1.0200000002p+57, 0x1p+3 },
+{ UINT64_C(0x0204000000040080), 0x1.0200000002004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000040800), 0x1.020000000204p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000048000), 0x1.02000000024p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000080000), 0x1.0200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000080001), 0x1.0200000004p+57, 0x1p+0 },
+{ UINT64_C(0x0204000000080010), 0x1.0200000004p+57, 0x1p+4 },
+{ UINT64_C(0x0204000000080040), 0x1.0200000004002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000080200), 0x1.020000000401p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000082000), 0x1.02000000041p+57, 0x0p+0 },
+{ UINT64_C(0x02040000000a0000), 0x1.0200000005p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000400000), 0x1.020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000400002), 0x1.020000002p+57, 0x1p+1 },
+{ UINT64_C(0x0204000000400008), 0x1.020000002p+57, 0x1p+3 },
+{ UINT64_C(0x0204000000400020), 0x1.0200000020001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000400200), 0x1.020000002001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000400800), 0x1.020000002004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000404000), 0x1.02000000202p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000420000), 0x1.0200000021p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000480000), 0x1.0200000024p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000500000), 0x1.0200000028p+57, 0x0p+0 },
+{ UINT64_C(0x0204000000600000), 0x1.020000003p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004000000), 0x1.02000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004000001), 0x1.02000002p+57, 0x1p+0 },
+{ UINT64_C(0x0204000004000004), 0x1.02000002p+57, 0x1p+2 },
+{ UINT64_C(0x0204000004000040), 0x1.0200000200002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004000200), 0x1.020000020001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004002000), 0x1.02000002001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004004000), 0x1.02000002002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004010000), 0x1.02000002008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004040000), 0x1.0200000202p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004100000), 0x1.0200000208p+57, 0x0p+0 },
+{ UINT64_C(0x0204000004200000), 0x1.020000021p+57, 0x0p+0 },
+{ UINT64_C(0x0204000006000000), 0x1.02000003p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020000000), 0x1.0200001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020000001), 0x1.0200001p+57, 0x1p+0 },
+{ UINT64_C(0x0204000020000002), 0x1.0200001p+57, 0x1p+1 },
+{ UINT64_C(0x0204000020000010), 0x1.0200001p+57, 0x1p+4 },
+{ UINT64_C(0x0204000020000040), 0x1.0200001000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020000200), 0x1.020000100001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020000800), 0x1.020000100004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020008000), 0x1.02000010004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020020000), 0x1.0200001001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020100000), 0x1.0200001008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000020400000), 0x1.020000102p+57, 0x0p+0 },
+{ UINT64_C(0x0204000024000000), 0x1.02000012p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080000000), 0x1.0200004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080000008), 0x1.0200004p+57, 0x1p+3 },
+{ UINT64_C(0x0204000080000020), 0x1.0200004000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080000200), 0x1.020000400001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080002000), 0x1.02000040001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080004000), 0x1.02000040002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080010000), 0x1.02000040008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080020000), 0x1.0200004001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000080200000), 0x1.020000401p+57, 0x0p+0 },
+{ UINT64_C(0x0204000082000000), 0x1.02000041p+57, 0x0p+0 },
+{ UINT64_C(0x0204000088000000), 0x1.02000044p+57, 0x0p+0 },
+{ UINT64_C(0x0204000090000000), 0x1.02000048p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400000000), 0x1.020002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400000004), 0x1.020002p+57, 0x1p+2 },
+{ UINT64_C(0x0204000400000040), 0x1.0200020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400000080), 0x1.0200020000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400000100), 0x1.0200020000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400000200), 0x1.020002000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400002000), 0x1.02000200001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400008000), 0x1.02000200004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400080000), 0x1.0200020004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000400800000), 0x1.020002004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000401000000), 0x1.020002008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000402000000), 0x1.02000201p+57, 0x0p+0 },
+{ UINT64_C(0x0204000410000000), 0x1.02000208p+57, 0x0p+0 },
+{ UINT64_C(0x0204000500000000), 0x1.0200028p+57, 0x0p+0 },
+{ UINT64_C(0x0204000600000000), 0x1.020003p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800000000), 0x1.020004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800000008), 0x1.020004p+57, 0x1p+3 },
+{ UINT64_C(0x0204000800000020), 0x1.0200040000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800000080), 0x1.0200040000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800000100), 0x1.0200040000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800000400), 0x1.020004000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800000800), 0x1.020004000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800004000), 0x1.02000400002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800040000), 0x1.0200040002p+57, 0x0p+0 },
+{ UINT64_C(0x0204000800100000), 0x1.0200040008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000801000000), 0x1.020004008p+57, 0x0p+0 },
+{ UINT64_C(0x0204000810000000), 0x1.02000408p+57, 0x0p+0 },
+{ UINT64_C(0x0204000900000000), 0x1.0200048p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000000000), 0x1.02004p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000000008), 0x1.02004p+57, 0x1p+3 },
+{ UINT64_C(0x0204008000000080), 0x1.0200400000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000000400), 0x1.020040000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000002000), 0x1.02004000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000020000), 0x1.0200400001p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000200000), 0x1.020040001p+57, 0x0p+0 },
+{ UINT64_C(0x0204008000800000), 0x1.020040004p+57, 0x0p+0 },
+{ UINT64_C(0x0204008001000000), 0x1.020040008p+57, 0x0p+0 },
+{ UINT64_C(0x0204008010000000), 0x1.02004008p+57, 0x0p+0 },
+{ UINT64_C(0x0204008100000000), 0x1.0200408p+57, 0x0p+0 },
+{ UINT64_C(0x0204008200000000), 0x1.020041p+57, 0x0p+0 },
+{ UINT64_C(0x0204008400000000), 0x1.020042p+57, 0x0p+0 },
+{ UINT64_C(0x020400a000000000), 0x1.02005p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000000000), 0x1.0202p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000000002), 0x1.0202p+57, 0x1p+1 },
+{ UINT64_C(0x0204040000000004), 0x1.0202p+57, 0x1p+2 },
+{ UINT64_C(0x0204040000000008), 0x1.0202p+57, 0x1p+3 },
+{ UINT64_C(0x0204040000000020), 0x1.0202000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000000100), 0x1.0202000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000001000), 0x1.020200000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000010000), 0x1.02020000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000040000), 0x1.0202000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204040000400000), 0x1.020200002p+57, 0x0p+0 },
+{ UINT64_C(0x0204040001000000), 0x1.020200008p+57, 0x0p+0 },
+{ UINT64_C(0x0204040010000000), 0x1.02020008p+57, 0x0p+0 },
+{ UINT64_C(0x0204040040000000), 0x1.0202002p+57, 0x0p+0 },
+{ UINT64_C(0x0204040080000000), 0x1.0202004p+57, 0x0p+0 },
+{ UINT64_C(0x0204040200000000), 0x1.020201p+57, 0x0p+0 },
+{ UINT64_C(0x0204042000000000), 0x1.02021p+57, 0x0p+0 },
+{ UINT64_C(0x0204060000000000), 0x1.0203p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000000000), 0x1.0208p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000000004), 0x1.0208p+57, 0x1p+2 },
+{ UINT64_C(0x0204100000000020), 0x1.0208000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000000040), 0x1.0208000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000000400), 0x1.020800000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000000800), 0x1.020800000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000004000), 0x1.02080000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000040000), 0x1.0208000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000080000), 0x1.0208000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000100000), 0x1.0208000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000200000), 0x1.020800001p+57, 0x0p+0 },
+{ UINT64_C(0x0204100000800000), 0x1.020800004p+57, 0x0p+0 },
+{ UINT64_C(0x0204100008000000), 0x1.02080004p+57, 0x0p+0 },
+{ UINT64_C(0x0204100040000000), 0x1.0208002p+57, 0x0p+0 },
+{ UINT64_C(0x0204100400000000), 0x1.020802p+57, 0x0p+0 },
+{ UINT64_C(0x0204101000000000), 0x1.020808p+57, 0x0p+0 },
+{ UINT64_C(0x0204104000000000), 0x1.02082p+57, 0x0p+0 },
+{ UINT64_C(0x0204120000000000), 0x1.0209p+57, 0x0p+0 },
+{ UINT64_C(0x0204140000000000), 0x1.020ap+57, 0x0p+0 },
+{ UINT64_C(0x0204400000000000), 0x1.022p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000000001), 0x1.022p+57, 0x1p+0 },
+{ UINT64_C(0x0204400000000002), 0x1.022p+57, 0x1p+1 },
+{ UINT64_C(0x0204400000000020), 0x1.0220000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000000040), 0x1.0220000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000000100), 0x1.0220000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000000400), 0x1.022000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000000800), 0x1.022000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000002000), 0x1.02200000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000008000), 0x1.02200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000040000), 0x1.0220000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000400000), 0x1.022000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204400000800000), 0x1.022000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204400004000000), 0x1.02200002p+57, 0x0p+0 },
+{ UINT64_C(0x0204400008000000), 0x1.02200004p+57, 0x0p+0 },
+{ UINT64_C(0x0204400020000000), 0x1.0220001p+57, 0x0p+0 },
+{ UINT64_C(0x0204400100000000), 0x1.0220008p+57, 0x0p+0 },
+{ UINT64_C(0x0204401000000000), 0x1.022008p+57, 0x0p+0 },
+{ UINT64_C(0x0204408000000000), 0x1.02204p+57, 0x0p+0 },
+{ UINT64_C(0x0204440000000000), 0x1.0222p+57, 0x0p+0 },
+{ UINT64_C(0x0204600000000000), 0x1.023p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000000000), 0x1.024p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000000002), 0x1.024p+57, 0x1p+1 },
+{ UINT64_C(0x0204800000000004), 0x1.024p+57, 0x1p+2 },
+{ UINT64_C(0x0204800000000020), 0x1.0240000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000000040), 0x1.0240000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000000080), 0x1.0240000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000000200), 0x1.024000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000000400), 0x1.024000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000004000), 0x1.02400000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000040000), 0x1.0240000002p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000080000), 0x1.0240000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204800000800000), 0x1.024000004p+57, 0x0p+0 },
+{ UINT64_C(0x0204800004000000), 0x1.02400002p+57, 0x0p+0 },
+{ UINT64_C(0x0204800040000000), 0x1.0240002p+57, 0x0p+0 },
+{ UINT64_C(0x0204800200000000), 0x1.024001p+57, 0x0p+0 },
+{ UINT64_C(0x0204800400000000), 0x1.024002p+57, 0x0p+0 },
+{ UINT64_C(0x0204802000000000), 0x1.02401p+57, 0x0p+0 },
+{ UINT64_C(0x0204820000000000), 0x1.0241p+57, 0x0p+0 },
+{ UINT64_C(0x0204900000000000), 0x1.0248p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000000008), 0x1.2p+57, 0x1p+3 },
+{ UINT64_C(0x024000000000000a), 0x1.2p+57, 0x1.4p+3 },
+{ UINT64_C(0x0240000000000040), 0x1.2000000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000000048), 0x1.2000000000002p+57, 0x1p+3 },
+{ UINT64_C(0x0240000000000060), 0x1.2000000000003p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000000080), 0x1.2000000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000000081), 0x1.2000000000004p+57, 0x1p+0 },
+{ UINT64_C(0x0240000000000090), 0x1.2000000000004p+57, 0x1p+4 },
+{ UINT64_C(0x0240000000000800), 0x1.200000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000000804), 0x1.200000000004p+57, 0x1p+2 },
+{ UINT64_C(0x0240000000000808), 0x1.200000000004p+57, 0x1p+3 },
+{ UINT64_C(0x0240000000000810), 0x1.200000000004p+57, 0x1p+4 },
+{ UINT64_C(0x0240000000000900), 0x1.2000000000048p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000000a00), 0x1.200000000005p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000004000), 0x1.20000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000004008), 0x1.20000000002p+57, 0x1p+3 },
+{ UINT64_C(0x0240000000004020), 0x1.2000000000201p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000004080), 0x1.2000000000204p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000004200), 0x1.200000000021p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000006000), 0x1.20000000003p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000010000), 0x1.20000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000010008), 0x1.20000000008p+57, 0x1p+3 },
+{ UINT64_C(0x0240000000010040), 0x1.2000000000802p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000010400), 0x1.200000000082p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000012000), 0x1.20000000009p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000014000), 0x1.2000000000ap+57, 0x0p+0 },
+{ UINT64_C(0x0240000000080000), 0x1.2000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000080002), 0x1.2000000004p+57, 0x1p+1 },
+{ UINT64_C(0x0240000000080004), 0x1.2000000004p+57, 0x1p+2 },
+{ UINT64_C(0x0240000000080040), 0x1.2000000004002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000080100), 0x1.2000000004008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000081000), 0x1.200000000408p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000088000), 0x1.20000000044p+57, 0x0p+0 },
+{ UINT64_C(0x02400000000a0000), 0x1.2000000005p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000800000), 0x1.200000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000800001), 0x1.200000004p+57, 0x1p+0 },
+{ UINT64_C(0x0240000000800002), 0x1.200000004p+57, 0x1p+1 },
+{ UINT64_C(0x0240000000800010), 0x1.200000004p+57, 0x1p+4 },
+{ UINT64_C(0x0240000000800080), 0x1.2000000040004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000800800), 0x1.200000004004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000808000), 0x1.20000000404p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000880000), 0x1.2000000044p+57, 0x0p+0 },
+{ UINT64_C(0x0240000000c00000), 0x1.200000006p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004000000), 0x1.20000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004000001), 0x1.20000002p+57, 0x1p+0 },
+{ UINT64_C(0x0240000004000008), 0x1.20000002p+57, 0x1p+3 },
+{ UINT64_C(0x0240000004000040), 0x1.2000000200002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004000100), 0x1.2000000200008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004000400), 0x1.200000020002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004004000), 0x1.20000002002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004008000), 0x1.20000002004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004040000), 0x1.2000000202p+57, 0x0p+0 },
+{ UINT64_C(0x0240000004400000), 0x1.200000022p+57, 0x0p+0 },
+{ UINT64_C(0x0240000006000000), 0x1.20000003p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040000000), 0x1.2000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040000002), 0x1.2000002p+57, 0x1p+1 },
+{ UINT64_C(0x0240000040000004), 0x1.2000002p+57, 0x1p+2 },
+{ UINT64_C(0x0240000040000010), 0x1.2000002p+57, 0x1p+4 },
+{ UINT64_C(0x0240000040000080), 0x1.2000002000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040000100), 0x1.2000002000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040000400), 0x1.200000200002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040002000), 0x1.20000020001p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040010000), 0x1.20000020008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040020000), 0x1.2000002001p+57, 0x0p+0 },
+{ UINT64_C(0x0240000040200000), 0x1.200000201p+57, 0x0p+0 },
+{ UINT64_C(0x0240000041000000), 0x1.200000208p+57, 0x0p+0 },
+{ UINT64_C(0x0240000042000000), 0x1.20000021p+57, 0x0p+0 },
+{ UINT64_C(0x0240000044000000), 0x1.20000022p+57, 0x0p+0 },
+{ UINT64_C(0x0240000060000000), 0x1.2000003p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400000000), 0x1.200002p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400000008), 0x1.200002p+57, 0x1p+3 },
+{ UINT64_C(0x0240000400000020), 0x1.2000020000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400000080), 0x1.2000020000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400000800), 0x1.200002000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400008000), 0x1.20000200004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400010000), 0x1.20000200008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400100000), 0x1.2000020008p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400200000), 0x1.200002001p+57, 0x0p+0 },
+{ UINT64_C(0x0240000400800000), 0x1.200002004p+57, 0x0p+0 },
+{ UINT64_C(0x0240000404000000), 0x1.20000202p+57, 0x0p+0 },
+{ UINT64_C(0x0240000420000000), 0x1.2000021p+57, 0x0p+0 },
+{ UINT64_C(0x0240000600000000), 0x1.200003p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000000000), 0x1.200008p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000000002), 0x1.200008p+57, 0x1p+1 },
+{ UINT64_C(0x0240001000000008), 0x1.200008p+57, 0x1p+3 },
+{ UINT64_C(0x0240001000000040), 0x1.2000080000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000000100), 0x1.2000080000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000000800), 0x1.200008000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000004000), 0x1.20000800002p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000008000), 0x1.20000800004p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000040000), 0x1.2000080002p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000100000), 0x1.2000080008p+57, 0x0p+0 },
+{ UINT64_C(0x0240001000800000), 0x1.200008004p+57, 0x0p+0 },
+{ UINT64_C(0x0240001001000000), 0x1.200008008p+57, 0x0p+0 },
+{ UINT64_C(0x0240001002000000), 0x1.20000801p+57, 0x0p+0 },
+{ UINT64_C(0x0240001008000000), 0x1.20000804p+57, 0x0p+0 },
+{ UINT64_C(0x0240001080000000), 0x1.2000084p+57, 0x0p+0 },
+{ UINT64_C(0x0240001800000000), 0x1.20000cp+57, 0x0p+0 },
+{ UINT64_C(0x0240010000000000), 0x1.20008p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000000002), 0x1.20008p+57, 0x1p+1 },
+{ UINT64_C(0x0240010000000008), 0x1.20008p+57, 0x1p+3 },
+{ UINT64_C(0x0240010000000040), 0x1.2000800000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000000200), 0x1.200080000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000000400), 0x1.200080000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000004000), 0x1.20008000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000020000), 0x1.2000800001p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000040000), 0x1.2000800002p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000080000), 0x1.2000800004p+57, 0x0p+0 },
+{ UINT64_C(0x0240010000400000), 0x1.200080002p+57, 0x0p+0 },
+{ UINT64_C(0x0240010002000000), 0x1.20008001p+57, 0x0p+0 },
+{ UINT64_C(0x0240010020000000), 0x1.2000801p+57, 0x0p+0 },
+{ UINT64_C(0x0240010040000000), 0x1.2000802p+57, 0x0p+0 },
+{ UINT64_C(0x0240010100000000), 0x1.2000808p+57, 0x0p+0 },
+{ UINT64_C(0x0240010400000000), 0x1.200082p+57, 0x0p+0 },
+{ UINT64_C(0x0240010800000000), 0x1.200084p+57, 0x0p+0 },
+{ UINT64_C(0x0240012000000000), 0x1.20009p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000000000), 0x1.2008p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000000004), 0x1.2008p+57, 0x1p+2 },
+{ UINT64_C(0x0240100000000008), 0x1.2008p+57, 0x1p+3 },
+{ UINT64_C(0x0240100000000040), 0x1.2008000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000000080), 0x1.2008000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000000400), 0x1.200800000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000001000), 0x1.200800000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000008000), 0x1.20080000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000010000), 0x1.20080000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000020000), 0x1.2008000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240100000200000), 0x1.200800001p+57, 0x0p+0 },
+{ UINT64_C(0x0240100002000000), 0x1.20080001p+57, 0x0p+0 },
+{ UINT64_C(0x0240100010000000), 0x1.20080008p+57, 0x0p+0 },
+{ UINT64_C(0x0240100040000000), 0x1.2008002p+57, 0x0p+0 },
+{ UINT64_C(0x0240100400000000), 0x1.200802p+57, 0x0p+0 },
+{ UINT64_C(0x0240100800000000), 0x1.200804p+57, 0x0p+0 },
+{ UINT64_C(0x0240102000000000), 0x1.20081p+57, 0x0p+0 },
+{ UINT64_C(0x0240110000000000), 0x1.20088p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000000000), 0x1.201p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000000002), 0x1.201p+57, 0x1p+1 },
+{ UINT64_C(0x0240200000000008), 0x1.201p+57, 0x1p+3 },
+{ UINT64_C(0x0240200000000010), 0x1.201p+57, 0x1p+4 },
+{ UINT64_C(0x0240200000000100), 0x1.2010000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000000400), 0x1.201000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000000800), 0x1.201000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000008000), 0x1.20100000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000020000), 0x1.2010000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240200000200000), 0x1.201000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240200001000000), 0x1.201000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240200004000000), 0x1.20100002p+57, 0x0p+0 },
+{ UINT64_C(0x0240200040000000), 0x1.2010002p+57, 0x0p+0 },
+{ UINT64_C(0x0240200200000000), 0x1.201001p+57, 0x0p+0 },
+{ UINT64_C(0x0240202000000000), 0x1.20101p+57, 0x0p+0 },
+{ UINT64_C(0x0240220000000000), 0x1.2011p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000000000), 0x1.202p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000000004), 0x1.202p+57, 0x1p+2 },
+{ UINT64_C(0x0240400000000020), 0x1.2020000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000000040), 0x1.2020000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000000080), 0x1.2020000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000000100), 0x1.2020000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000000800), 0x1.202000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000002000), 0x1.20200000001p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000010000), 0x1.20200000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000040000), 0x1.2020000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000080000), 0x1.2020000004p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000100000), 0x1.2020000008p+57, 0x0p+0 },
+{ UINT64_C(0x0240400000400000), 0x1.202000002p+57, 0x0p+0 },
+{ UINT64_C(0x0240400004000000), 0x1.20200002p+57, 0x0p+0 },
+{ UINT64_C(0x0240400020000000), 0x1.2020001p+57, 0x0p+0 },
+{ UINT64_C(0x0240400080000000), 0x1.2020004p+57, 0x0p+0 },
+{ UINT64_C(0x0240400400000000), 0x1.202002p+57, 0x0p+0 },
+{ UINT64_C(0x0240400800000000), 0x1.202004p+57, 0x0p+0 },
+{ UINT64_C(0x0240402000000000), 0x1.20201p+57, 0x0p+0 },
+{ UINT64_C(0x0240408000000000), 0x1.20204p+57, 0x0p+0 },
+{ UINT64_C(0x0240410000000000), 0x1.20208p+57, 0x0p+0 },
+{ UINT64_C(0x0240500000000000), 0x1.2028p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000000000), 0x1.21p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000000002), 0x1.21p+57, 0x1p+1 },
+{ UINT64_C(0x0242000000000004), 0x1.21p+57, 0x1p+2 },
+{ UINT64_C(0x0242000000000008), 0x1.21p+57, 0x1p+3 },
+{ UINT64_C(0x0242000000000040), 0x1.2100000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000000400), 0x1.210000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000000800), 0x1.210000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000004000), 0x1.21000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000040000), 0x1.2100000002p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000080000), 0x1.2100000004p+57, 0x0p+0 },
+{ UINT64_C(0x0242000000200000), 0x1.210000001p+57, 0x0p+0 },
+{ UINT64_C(0x0242000002000000), 0x1.21000001p+57, 0x0p+0 },
+{ UINT64_C(0x0242000008000000), 0x1.21000004p+57, 0x0p+0 },
+{ UINT64_C(0x0242000040000000), 0x1.2100002p+57, 0x0p+0 },
+{ UINT64_C(0x0242000200000000), 0x1.210001p+57, 0x0p+0 },
+{ UINT64_C(0x0242000800000000), 0x1.210004p+57, 0x0p+0 },
+{ UINT64_C(0x0242008000000000), 0x1.21004p+57, 0x0p+0 },
+{ UINT64_C(0x0242080000000000), 0x1.2104p+57, 0x0p+0 },
+{ UINT64_C(0x0242400000000000), 0x1.212p+57, 0x0p+0 },
+{ UINT64_C(0x0243000000000000), 0x1.218p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000000000), 0x1.28p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000000004), 0x1.28p+57, 0x1p+2 },
+{ UINT64_C(0x0250000000000040), 0x1.2800000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000000100), 0x1.2800000000008p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000000200), 0x1.280000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000002000), 0x1.28000000001p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000004000), 0x1.28000000002p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000008000), 0x1.28000000004p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000040000), 0x1.2800000002p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000200000), 0x1.280000001p+57, 0x0p+0 },
+{ UINT64_C(0x0250000000800000), 0x1.280000004p+57, 0x0p+0 },
+{ UINT64_C(0x0250000002000000), 0x1.28000001p+57, 0x0p+0 },
+{ UINT64_C(0x0250000010000000), 0x1.28000008p+57, 0x0p+0 },
+{ UINT64_C(0x0250000020000000), 0x1.2800001p+57, 0x0p+0 },
+{ UINT64_C(0x0250000100000000), 0x1.2800008p+57, 0x0p+0 },
+{ UINT64_C(0x0250000200000000), 0x1.280001p+57, 0x0p+0 },
+{ UINT64_C(0x0250000400000000), 0x1.280002p+57, 0x0p+0 },
+{ UINT64_C(0x0250000800000000), 0x1.280004p+57, 0x0p+0 },
+{ UINT64_C(0x0250004000000000), 0x1.28002p+57, 0x0p+0 },
+{ UINT64_C(0x0250040000000000), 0x1.2802p+57, 0x0p+0 },
+{ UINT64_C(0x0250400000000000), 0x1.282p+57, 0x0p+0 },
+{ UINT64_C(0x0254000000000000), 0x1.2ap+57, 0x0p+0 },
+{ UINT64_C(0x100000000000000c), 0x1p+60, 0x1.8p+3 },
+{ UINT64_C(0x1000000000000022), 0x1p+60, 0x1.1p+5 },
+{ UINT64_C(0x1000000000000028), 0x1p+60, 0x1.4p+5 },
+{ UINT64_C(0x1000000000000029), 0x1p+60, 0x1.48p+5 },
+{ UINT64_C(0x1000000000000030), 0x1p+60, 0x1.8p+5 },
+{ UINT64_C(0x1000000000000032), 0x1p+60, 0x1.9p+5 },
+{ UINT64_C(0x1000000000000201), 0x1.0000000000002p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000000210), 0x1.0000000000002p+60, 0x1p+4 },
+{ UINT64_C(0x1000000000000211), 0x1.0000000000002p+60, 0x1.1p+4 },
+{ UINT64_C(0x1000000000000212), 0x1.0000000000002p+60, 0x1.2p+4 },
+{ UINT64_C(0x1000000000000214), 0x1.0000000000002p+60, 0x1.4p+4 },
+{ UINT64_C(0x1000000000000218), 0x1.0000000000002p+60, 0x1.8p+4 },
+{ UINT64_C(0x1000000000000300), 0x1.0000000000003p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000000302), 0x1.0000000000003p+60, 0x1p+1 },
+{ UINT64_C(0x1000000000000304), 0x1.0000000000003p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000000340), 0x1.0000000000003p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000000801), 0x1.0000000000008p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000000804), 0x1.0000000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000000806), 0x1.0000000000008p+60, 0x1.8p+2 },
+{ UINT64_C(0x1000000000000820), 0x1.0000000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000000822), 0x1.0000000000008p+60, 0x1.1p+5 },
+{ UINT64_C(0x1000000000000824), 0x1.0000000000008p+60, 0x1.2p+5 },
+{ UINT64_C(0x1000000000000830), 0x1.0000000000008p+60, 0x1.8p+5 },
+{ UINT64_C(0x1000000000000900), 0x1.0000000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000000902), 0x1.0000000000009p+60, 0x1p+1 },
+{ UINT64_C(0x1000000000000908), 0x1.0000000000009p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000000980), 0x1.000000000000ap+60, -0x1p+7 },
+{ UINT64_C(0x1000000000001008), 0x1.000000000001p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000001010), 0x1.000000000001p+60, 0x1p+4 },
+{ UINT64_C(0x1000000000001011), 0x1.000000000001p+60, 0x1.1p+4 },
+{ UINT64_C(0x1000000000001014), 0x1.000000000001p+60, 0x1.4p+4 },
+{ UINT64_C(0x1000000000001040), 0x1.000000000001p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000001041), 0x1.000000000001p+60, 0x1.04p+6 },
+{ UINT64_C(0x1000000000001044), 0x1.000000000001p+60, 0x1.1p+6 },
+{ UINT64_C(0x1000000000001050), 0x1.000000000001p+60, 0x1.4p+6 },
+{ UINT64_C(0x1000000000001060), 0x1.000000000001p+60, 0x1.8p+6 },
+{ UINT64_C(0x1000000000001400), 0x1.0000000000014p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000001401), 0x1.0000000000014p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000001408), 0x1.0000000000014p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000001440), 0x1.0000000000014p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000001800), 0x1.0000000000018p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000001804), 0x1.0000000000018p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000001820), 0x1.0000000000018p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000001a00), 0x1.000000000001ap+60, 0x0p+0 },
+{ UINT64_C(0x1000000000001c00), 0x1.000000000001cp+60, 0x0p+0 },
+{ UINT64_C(0x1000000000008004), 0x1.000000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000008005), 0x1.000000000008p+60, 0x1.4p+2 },
+{ UINT64_C(0x1000000000008020), 0x1.000000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000008021), 0x1.000000000008p+60, 0x1.08p+5 },
+{ UINT64_C(0x1000000000008030), 0x1.000000000008p+60, 0x1.8p+5 },
+{ UINT64_C(0x1000000000008200), 0x1.0000000000082p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000008201), 0x1.0000000000082p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000008208), 0x1.0000000000082p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000008280), 0x1.0000000000082p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000009000), 0x1.000000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000009008), 0x1.000000000009p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000009020), 0x1.000000000009p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000009200), 0x1.0000000000092p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000009400), 0x1.0000000000094p+60, 0x0p+0 },
+{ UINT64_C(0x100000000000c000), 0x1.00000000000cp+60, 0x0p+0 },
+{ UINT64_C(0x100000000000c001), 0x1.00000000000cp+60, 0x1p+0 },
+{ UINT64_C(0x100000000000c004), 0x1.00000000000cp+60, 0x1p+2 },
+{ UINT64_C(0x100000000000c020), 0x1.00000000000cp+60, 0x1p+5 },
+{ UINT64_C(0x100000000000c200), 0x1.00000000000c2p+60, 0x0p+0 },
+{ UINT64_C(0x100000000000c400), 0x1.00000000000c4p+60, 0x0p+0 },
+{ UINT64_C(0x100000000000d000), 0x1.00000000000dp+60, 0x0p+0 },
+{ UINT64_C(0x1000000000040008), 0x1.00000000004p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000040010), 0x1.00000000004p+60, 0x1p+4 },
+{ UINT64_C(0x1000000000040012), 0x1.00000000004p+60, 0x1.2p+4 },
+{ UINT64_C(0x1000000000040040), 0x1.00000000004p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000040042), 0x1.00000000004p+60, 0x1.08p+6 },
+{ UINT64_C(0x1000000000040044), 0x1.00000000004p+60, 0x1.1p+6 },
+{ UINT64_C(0x1000000000040060), 0x1.00000000004p+60, 0x1.8p+6 },
+{ UINT64_C(0x1000000000040100), 0x1.0000000000401p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000040102), 0x1.0000000000401p+60, 0x1p+1 },
+{ UINT64_C(0x1000000000040104), 0x1.0000000000401p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000040108), 0x1.0000000000401p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000040120), 0x1.0000000000401p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000040200), 0x1.0000000000402p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000040201), 0x1.0000000000402p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000040204), 0x1.0000000000402p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000040208), 0x1.0000000000402p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000040280), 0x1.0000000000402p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000041000), 0x1.000000000041p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000041001), 0x1.000000000041p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000041008), 0x1.000000000041p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000041040), 0x1.000000000041p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000041400), 0x1.0000000000414p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000041800), 0x1.0000000000418p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000042000), 0x1.000000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000042001), 0x1.000000000042p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000042008), 0x1.000000000042p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000042040), 0x1.000000000042p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000042080), 0x1.000000000042p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000042400), 0x1.0000000000424p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000043000), 0x1.000000000043p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000048000), 0x1.000000000048p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000048008), 0x1.000000000048p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000048020), 0x1.000000000048p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000048040), 0x1.000000000048p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000048200), 0x1.0000000000482p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000048400), 0x1.0000000000484p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000049000), 0x1.000000000049p+60, 0x0p+0 },
+{ UINT64_C(0x100000000004a000), 0x1.00000000004ap+60, 0x0p+0 },
+{ UINT64_C(0x1000000000060000), 0x1.00000000006p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000060008), 0x1.00000000006p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000060010), 0x1.00000000006p+60, 0x1p+4 },
+{ UINT64_C(0x1000000000060080), 0x1.00000000006p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000060400), 0x1.0000000000604p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000064000), 0x1.000000000064p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000100004), 0x1.0000000001p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000100040), 0x1.0000000001p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000100048), 0x1.0000000001p+60, 0x1.2p+6 },
+{ UINT64_C(0x1000000000100060), 0x1.0000000001p+60, 0x1.8p+6 },
+{ UINT64_C(0x1000000000100200), 0x1.0000000001002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000100208), 0x1.0000000001002p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000100220), 0x1.0000000001002p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000100300), 0x1.0000000001003p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000102000), 0x1.000000000102p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000102008), 0x1.000000000102p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000102040), 0x1.000000000102p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000102400), 0x1.0000000001024p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000103000), 0x1.000000000103p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000110000), 0x1.00000000011p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000110001), 0x1.00000000011p+60, 0x1p+0 },
+{ UINT64_C(0x1000000000110010), 0x1.00000000011p+60, 0x1p+4 },
+{ UINT64_C(0x1000000000110080), 0x1.00000000011p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000110200), 0x1.0000000001102p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000111000), 0x1.000000000111p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000114000), 0x1.000000000114p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000180000), 0x1.00000000018p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000180008), 0x1.00000000018p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000180020), 0x1.00000000018p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000180100), 0x1.0000000001801p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000180200), 0x1.0000000001802p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000180800), 0x1.0000000001808p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000188000), 0x1.000000000188p+60, 0x0p+0 },
+{ UINT64_C(0x10000000001c0000), 0x1.0000000001cp+60, 0x0p+0 },
+{ UINT64_C(0x1000000000800002), 0x1.0000000008p+60, 0x1p+1 },
+{ UINT64_C(0x1000000000800008), 0x1.0000000008p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000800040), 0x1.0000000008p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000800048), 0x1.0000000008p+60, 0x1.2p+6 },
+{ UINT64_C(0x1000000000800060), 0x1.0000000008p+60, 0x1.8p+6 },
+{ UINT64_C(0x1000000000800400), 0x1.0000000008004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000800402), 0x1.0000000008004p+60, 0x1p+1 },
+{ UINT64_C(0x1000000000800410), 0x1.0000000008004p+60, 0x1p+4 },
+{ UINT64_C(0x1000000000800420), 0x1.0000000008004p+60, 0x1p+5 },
+{ UINT64_C(0x1000000000800480), 0x1.0000000008004p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000802000), 0x1.000000000802p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000802008), 0x1.000000000802p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000802080), 0x1.000000000802p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000802100), 0x1.0000000008021p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000803000), 0x1.000000000803p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000810000), 0x1.00000000081p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000810004), 0x1.00000000081p+60, 0x1p+2 },
+{ UINT64_C(0x1000000000810040), 0x1.00000000081p+60, 0x1p+6 },
+{ UINT64_C(0x1000000000810200), 0x1.0000000008102p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000812000), 0x1.000000000812p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000814000), 0x1.000000000814p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000818000), 0x1.000000000818p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000820000), 0x1.00000000082p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000820008), 0x1.00000000082p+60, 0x1p+3 },
+{ UINT64_C(0x1000000000820080), 0x1.00000000082p+60, 0x1p+7 },
+{ UINT64_C(0x1000000000820800), 0x1.0000000008208p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000822000), 0x1.000000000822p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000824000), 0x1.000000000824p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000a00000), 0x1.000000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1000000000a00008), 0x1.000000000ap+60, 0x1p+3 },
+{ UINT64_C(0x1000000000a00020), 0x1.000000000ap+60, 0x1p+5 },
+{ UINT64_C(0x1000000000a00080), 0x1.000000000ap+60, 0x1p+7 },
+{ UINT64_C(0x1000000000a00200), 0x1.000000000a002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000a02000), 0x1.000000000a02p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000a08000), 0x1.000000000a08p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000a20000), 0x1.000000000a2p+60, 0x0p+0 },
+{ UINT64_C(0x1000000000b00000), 0x1.000000000bp+60, 0x0p+0 },
+{ UINT64_C(0x1000000008000004), 0x1.000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1000000008000020), 0x1.000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000000008000021), 0x1.000000008p+60, 0x1.08p+5 },
+{ UINT64_C(0x1000000008000030), 0x1.000000008p+60, 0x1.8p+5 },
+{ UINT64_C(0x1000000008000040), 0x1.000000008p+60, 0x1p+6 },
+{ UINT64_C(0x1000000008000048), 0x1.000000008p+60, 0x1.2p+6 },
+{ UINT64_C(0x1000000008000080), 0x1.000000008p+60, 0x1p+7 },
+{ UINT64_C(0x1000000008000081), 0x1.0000000080001p+60, -0x1.fcp+6 },
+{ UINT64_C(0x1000000008000090), 0x1.0000000080001p+60, -0x1.cp+6 },
+{ UINT64_C(0x1000000008000400), 0x1.0000000080004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008000404), 0x1.0000000080004p+60, 0x1p+2 },
+{ UINT64_C(0x1000000008000440), 0x1.0000000080004p+60, 0x1p+6 },
+{ UINT64_C(0x1000000008000600), 0x1.0000000080006p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008002000), 0x1.000000008002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008002004), 0x1.000000008002p+60, 0x1p+2 },
+{ UINT64_C(0x1000000008002008), 0x1.000000008002p+60, 0x1p+3 },
+{ UINT64_C(0x1000000008002040), 0x1.000000008002p+60, 0x1p+6 },
+{ UINT64_C(0x1000000008002080), 0x1.000000008002p+60, 0x1p+7 },
+{ UINT64_C(0x1000000008002200), 0x1.0000000080022p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008008000), 0x1.000000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008008001), 0x1.000000008008p+60, 0x1p+0 },
+{ UINT64_C(0x1000000008008008), 0x1.000000008008p+60, 0x1p+3 },
+{ UINT64_C(0x1000000008008010), 0x1.000000008008p+60, 0x1p+4 },
+{ UINT64_C(0x1000000008008080), 0x1.000000008008p+60, 0x1p+7 },
+{ UINT64_C(0x1000000008008400), 0x1.0000000080084p+60, 0x0p+0 },
+{ UINT64_C(0x100000000800a000), 0x1.00000000800ap+60, 0x0p+0 },
+{ UINT64_C(0x100000000800c000), 0x1.00000000800cp+60, 0x0p+0 },
+{ UINT64_C(0x1000000008010000), 0x1.00000000801p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008010004), 0x1.00000000801p+60, 0x1p+2 },
+{ UINT64_C(0x1000000008010008), 0x1.00000000801p+60, 0x1p+3 },
+{ UINT64_C(0x1000000008010080), 0x1.00000000801p+60, 0x1p+7 },
+{ UINT64_C(0x1000000008010100), 0x1.0000000080101p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008010400), 0x1.0000000080104p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008011000), 0x1.000000008011p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008100000), 0x1.0000000081p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008100004), 0x1.0000000081p+60, 0x1p+2 },
+{ UINT64_C(0x1000000008100010), 0x1.0000000081p+60, 0x1p+4 },
+{ UINT64_C(0x1000000008100020), 0x1.0000000081p+60, 0x1p+5 },
+{ UINT64_C(0x1000000008100100), 0x1.0000000081001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008100800), 0x1.0000000081008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008108000), 0x1.000000008108p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008180000), 0x1.00000000818p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008200000), 0x1.0000000082p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008200001), 0x1.0000000082p+60, 0x1p+0 },
+{ UINT64_C(0x1000000008200002), 0x1.0000000082p+60, 0x1p+1 },
+{ UINT64_C(0x1000000008200004), 0x1.0000000082p+60, 0x1p+2 },
+{ UINT64_C(0x1000000008200010), 0x1.0000000082p+60, 0x1p+4 },
+{ UINT64_C(0x1000000008200020), 0x1.0000000082p+60, 0x1p+5 },
+{ UINT64_C(0x1000000008200080), 0x1.0000000082p+60, 0x1p+7 },
+{ UINT64_C(0x1000000008200100), 0x1.0000000082001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008200800), 0x1.0000000082008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008202000), 0x1.000000008202p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008220000), 0x1.00000000822p+60, 0x0p+0 },
+{ UINT64_C(0x1000000008280000), 0x1.00000000828p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009000000), 0x1.000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009000004), 0x1.000000009p+60, 0x1p+2 },
+{ UINT64_C(0x1000000009000010), 0x1.000000009p+60, 0x1p+4 },
+{ UINT64_C(0x1000000009000100), 0x1.0000000090001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009000400), 0x1.0000000090004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009001000), 0x1.000000009001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009002000), 0x1.000000009002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009020000), 0x1.00000000902p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009200000), 0x1.0000000092p+60, 0x0p+0 },
+{ UINT64_C(0x1000000009800000), 0x1.0000000098p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040000001), 0x1.00000004p+60, 0x1p+0 },
+{ UINT64_C(0x1000000040000008), 0x1.00000004p+60, 0x1p+3 },
+{ UINT64_C(0x1000000040000020), 0x1.00000004p+60, 0x1p+5 },
+{ UINT64_C(0x1000000040000024), 0x1.00000004p+60, 0x1.2p+5 },
+{ UINT64_C(0x1000000040000100), 0x1.0000000400001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040000101), 0x1.0000000400001p+60, 0x1p+0 },
+{ UINT64_C(0x1000000040000108), 0x1.0000000400001p+60, 0x1p+3 },
+{ UINT64_C(0x1000000040000180), 0x1.0000000400002p+60, -0x1p+7 },
+{ UINT64_C(0x1000000040000400), 0x1.0000000400004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040000401), 0x1.0000000400004p+60, 0x1p+0 },
+{ UINT64_C(0x1000000040000410), 0x1.0000000400004p+60, 0x1p+4 },
+{ UINT64_C(0x1000000040000480), 0x1.0000000400004p+60, 0x1p+7 },
+{ UINT64_C(0x1000000040001000), 0x1.000000040001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040001002), 0x1.000000040001p+60, 0x1p+1 },
+{ UINT64_C(0x1000000040001004), 0x1.000000040001p+60, 0x1p+2 },
+{ UINT64_C(0x1000000040001040), 0x1.000000040001p+60, 0x1p+6 },
+{ UINT64_C(0x1000000040001400), 0x1.0000000400014p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040001800), 0x1.0000000400018p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040008000), 0x1.000000040008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040008004), 0x1.000000040008p+60, 0x1p+2 },
+{ UINT64_C(0x1000000040008010), 0x1.000000040008p+60, 0x1p+4 },
+{ UINT64_C(0x1000000040008020), 0x1.000000040008p+60, 0x1p+5 },
+{ UINT64_C(0x1000000040008100), 0x1.0000000400081p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040008200), 0x1.0000000400082p+60, 0x0p+0 },
+{ UINT64_C(0x100000004000a000), 0x1.00000004000ap+60, 0x0p+0 },
+{ UINT64_C(0x100000004000c000), 0x1.00000004000cp+60, 0x0p+0 },
+{ UINT64_C(0x1000000040010000), 0x1.00000004001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040010002), 0x1.00000004001p+60, 0x1p+1 },
+{ UINT64_C(0x1000000040010010), 0x1.00000004001p+60, 0x1p+4 },
+{ UINT64_C(0x1000000040010080), 0x1.00000004001p+60, 0x1p+7 },
+{ UINT64_C(0x1000000040010200), 0x1.0000000400102p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040010800), 0x1.0000000400108p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040011000), 0x1.000000040011p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040012000), 0x1.000000040012p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040014000), 0x1.000000040014p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040018000), 0x1.000000040018p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040040000), 0x1.00000004004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040040004), 0x1.00000004004p+60, 0x1p+2 },
+{ UINT64_C(0x1000000040040010), 0x1.00000004004p+60, 0x1p+4 },
+{ UINT64_C(0x1000000040040020), 0x1.00000004004p+60, 0x1p+5 },
+{ UINT64_C(0x1000000040040100), 0x1.0000000400401p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040040400), 0x1.0000000400404p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040042000), 0x1.000000040042p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040048000), 0x1.000000040048p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040050000), 0x1.00000004005p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040200000), 0x1.0000000402p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040200002), 0x1.0000000402p+60, 0x1p+1 },
+{ UINT64_C(0x1000000040200010), 0x1.0000000402p+60, 0x1p+4 },
+{ UINT64_C(0x1000000040200040), 0x1.0000000402p+60, 0x1p+6 },
+{ UINT64_C(0x1000000040200100), 0x1.0000000402001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040201000), 0x1.000000040201p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040204000), 0x1.000000040204p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040240000), 0x1.00000004024p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040280000), 0x1.00000004028p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040800000), 0x1.0000000408p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040800008), 0x1.0000000408p+60, 0x1p+3 },
+{ UINT64_C(0x1000000040800080), 0x1.0000000408p+60, 0x1p+7 },
+{ UINT64_C(0x1000000040800800), 0x1.0000000408008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040808000), 0x1.000000040808p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040840000), 0x1.00000004084p+60, 0x0p+0 },
+{ UINT64_C(0x1000000040880000), 0x1.00000004088p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048000000), 0x1.000000048p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048000004), 0x1.000000048p+60, 0x1p+2 },
+{ UINT64_C(0x1000000048000020), 0x1.000000048p+60, 0x1p+5 },
+{ UINT64_C(0x1000000048000080), 0x1.000000048p+60, 0x1p+7 },
+{ UINT64_C(0x1000000048000400), 0x1.0000000480004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048002000), 0x1.000000048002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048010000), 0x1.00000004801p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048020000), 0x1.00000004802p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048040000), 0x1.00000004804p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048080000), 0x1.00000004808p+60, 0x0p+0 },
+{ UINT64_C(0x1000000048100000), 0x1.0000000481p+60, 0x0p+0 },
+{ UINT64_C(0x1000000049000000), 0x1.000000049p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060000000), 0x1.00000006p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060000008), 0x1.00000006p+60, 0x1p+3 },
+{ UINT64_C(0x1000000060000040), 0x1.00000006p+60, 0x1p+6 },
+{ UINT64_C(0x1000000060000400), 0x1.0000000600004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060000800), 0x1.0000000600008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060002000), 0x1.000000060002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060008000), 0x1.000000060008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060020000), 0x1.00000006002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000060200000), 0x1.0000000602p+60, 0x0p+0 },
+{ UINT64_C(0x1000000062000000), 0x1.000000062p+60, 0x0p+0 },
+{ UINT64_C(0x1000000064000000), 0x1.000000064p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200000001), 0x1.0000002p+60, 0x1p+0 },
+{ UINT64_C(0x1000000200000002), 0x1.0000002p+60, 0x1p+1 },
+{ UINT64_C(0x1000000200000003), 0x1.0000002p+60, 0x1.8p+1 },
+{ UINT64_C(0x1000000200000008), 0x1.0000002p+60, 0x1p+3 },
+{ UINT64_C(0x1000000200000009), 0x1.0000002p+60, 0x1.2p+3 },
+{ UINT64_C(0x1000000200000020), 0x1.0000002p+60, 0x1p+5 },
+{ UINT64_C(0x1000000200000022), 0x1.0000002p+60, 0x1.1p+5 },
+{ UINT64_C(0x1000000200000028), 0x1.0000002p+60, 0x1.4p+5 },
+{ UINT64_C(0x1000000200000040), 0x1.0000002p+60, 0x1p+6 },
+{ UINT64_C(0x1000000200000041), 0x1.0000002p+60, 0x1.04p+6 },
+{ UINT64_C(0x1000000200000044), 0x1.0000002p+60, 0x1.1p+6 },
+{ UINT64_C(0x1000000200000050), 0x1.0000002p+60, 0x1.4p+6 },
+{ UINT64_C(0x1000000200000400), 0x1.0000002000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200000401), 0x1.0000002000004p+60, 0x1p+0 },
+{ UINT64_C(0x1000000200000408), 0x1.0000002000004p+60, 0x1p+3 },
+{ UINT64_C(0x1000000200000420), 0x1.0000002000004p+60, 0x1p+5 },
+{ UINT64_C(0x1000000200000480), 0x1.0000002000004p+60, 0x1p+7 },
+{ UINT64_C(0x1000000200000600), 0x1.0000002000006p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200001000), 0x1.000000200001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200001001), 0x1.000000200001p+60, 0x1p+0 },
+{ UINT64_C(0x1000000200001008), 0x1.000000200001p+60, 0x1p+3 },
+{ UINT64_C(0x1000000200001010), 0x1.000000200001p+60, 0x1p+4 },
+{ UINT64_C(0x1000000200001080), 0x1.000000200001p+60, 0x1p+7 },
+{ UINT64_C(0x1000000200001400), 0x1.0000002000014p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200004000), 0x1.000000200004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200004008), 0x1.000000200004p+60, 0x1p+3 },
+{ UINT64_C(0x1000000200004020), 0x1.000000200004p+60, 0x1p+5 },
+{ UINT64_C(0x1000000200004100), 0x1.0000002000041p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200004400), 0x1.0000002000044p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200004800), 0x1.0000002000048p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200006000), 0x1.000000200006p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200040000), 0x1.00000020004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200040001), 0x1.00000020004p+60, 0x1p+0 },
+{ UINT64_C(0x1000000200040008), 0x1.00000020004p+60, 0x1p+3 },
+{ UINT64_C(0x1000000200040080), 0x1.00000020004p+60, 0x1p+7 },
+{ UINT64_C(0x1000000200040100), 0x1.0000002000401p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200040400), 0x1.0000002000404p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200040800), 0x1.0000002000408p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200042000), 0x1.000000200042p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200044000), 0x1.000000200044p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200048000), 0x1.000000200048p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200400000), 0x1.0000002004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200400002), 0x1.0000002004p+60, 0x1p+1 },
+{ UINT64_C(0x1000000200400004), 0x1.0000002004p+60, 0x1p+2 },
+{ UINT64_C(0x1000000200400020), 0x1.0000002004p+60, 0x1p+5 },
+{ UINT64_C(0x1000000200400080), 0x1.0000002004p+60, 0x1p+7 },
+{ UINT64_C(0x1000000200400800), 0x1.0000002004008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200404000), 0x1.000000200404p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200440000), 0x1.00000020044p+60, 0x0p+0 },
+{ UINT64_C(0x1000000200500000), 0x1.0000002005p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201000000), 0x1.000000201p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201000008), 0x1.000000201p+60, 0x1p+3 },
+{ UINT64_C(0x1000000201000020), 0x1.000000201p+60, 0x1p+5 },
+{ UINT64_C(0x1000000201000100), 0x1.0000002010001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201000400), 0x1.0000002010004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201001000), 0x1.000000201001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201010000), 0x1.00000020101p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201040000), 0x1.00000020104p+60, 0x0p+0 },
+{ UINT64_C(0x1000000201400000), 0x1.0000002014p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202000000), 0x1.000000202p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202000008), 0x1.000000202p+60, 0x1p+3 },
+{ UINT64_C(0x1000000202000040), 0x1.000000202p+60, 0x1p+6 },
+{ UINT64_C(0x1000000202000100), 0x1.0000002020001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202000200), 0x1.0000002020002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202000400), 0x1.0000002020004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202000800), 0x1.0000002020008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202004000), 0x1.000000202004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202008000), 0x1.000000202008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202010000), 0x1.00000020201p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202080000), 0x1.00000020208p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202400000), 0x1.0000002024p+60, 0x0p+0 },
+{ UINT64_C(0x1000000202800000), 0x1.0000002028p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208000000), 0x1.000000208p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208000001), 0x1.000000208p+60, 0x1p+0 },
+{ UINT64_C(0x1000000208000004), 0x1.000000208p+60, 0x1p+2 },
+{ UINT64_C(0x1000000208000010), 0x1.000000208p+60, 0x1p+4 },
+{ UINT64_C(0x1000000208000080), 0x1.000000208p+60, 0x1p+7 },
+{ UINT64_C(0x1000000208000200), 0x1.0000002080002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208000800), 0x1.0000002080008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208001000), 0x1.000000208001p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208002000), 0x1.000000208002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208020000), 0x1.00000020802p+60, 0x0p+0 },
+{ UINT64_C(0x1000000208200000), 0x1.0000002082p+60, 0x0p+0 },
+{ UINT64_C(0x1000000209000000), 0x1.000000209p+60, 0x0p+0 },
+{ UINT64_C(0x1000000220000000), 0x1.00000022p+60, 0x0p+0 },
+{ UINT64_C(0x1000000220000002), 0x1.00000022p+60, 0x1p+1 },
+{ UINT64_C(0x1000000220000008), 0x1.00000022p+60, 0x1p+3 },
+{ UINT64_C(0x1000000220000080), 0x1.00000022p+60, 0x1p+7 },
+{ UINT64_C(0x1000000220000200), 0x1.0000002200002p+60, 0x0p+0 },
+{ UINT64_C(0x1000000220000800), 0x1.0000002200008p+60, 0x0p+0 },
+{ UINT64_C(0x1000000220004000), 0x1.000000220004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000220040000), 0x1.00000022004p+60, 0x0p+0 },
+{ UINT64_C(0x1000000220200000), 0x1.0000002202p+60, 0x0p+0 },
+{ UINT64_C(0x1000000222000000), 0x1.000000222p+60, 0x0p+0 },
+{ UINT64_C(0x1000000228000000), 0x1.000000228p+60, 0x0p+0 },
+{ UINT64_C(0x1000000230000000), 0x1.00000023p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000000002), 0x1.000002p+60, 0x1p+1 },
+{ UINT64_C(0x1000002000000004), 0x1.000002p+60, 0x1p+2 },
+{ UINT64_C(0x1000002000000006), 0x1.000002p+60, 0x1.8p+2 },
+{ UINT64_C(0x1000002000000008), 0x1.000002p+60, 0x1p+3 },
+{ UINT64_C(0x100000200000000c), 0x1.000002p+60, 0x1.8p+3 },
+{ UINT64_C(0x1000002000000080), 0x1.000002p+60, 0x1p+7 },
+{ UINT64_C(0x1000002000000088), 0x1.0000020000001p+60, -0x1.ep+6 },
+{ UINT64_C(0x1000002000000090), 0x1.0000020000001p+60, -0x1.cp+6 },
+{ UINT64_C(0x1000002000000200), 0x1.0000020000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000000204), 0x1.0000020000002p+60, 0x1p+2 },
+{ UINT64_C(0x1000002000000210), 0x1.0000020000002p+60, 0x1p+4 },
+{ UINT64_C(0x1000002000000240), 0x1.0000020000002p+60, 0x1p+6 },
+{ UINT64_C(0x1000002000000400), 0x1.0000020000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000000404), 0x1.0000020000004p+60, 0x1p+2 },
+{ UINT64_C(0x1000002000000440), 0x1.0000020000004p+60, 0x1p+6 },
+{ UINT64_C(0x1000002000000600), 0x1.0000020000006p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000001000), 0x1.000002000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000001004), 0x1.000002000001p+60, 0x1p+2 },
+{ UINT64_C(0x1000002000001010), 0x1.000002000001p+60, 0x1p+4 },
+{ UINT64_C(0x1000002000001080), 0x1.000002000001p+60, 0x1p+7 },
+{ UINT64_C(0x1000002000001400), 0x1.0000020000014p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000008000), 0x1.000002000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000008008), 0x1.000002000008p+60, 0x1p+3 },
+{ UINT64_C(0x1000002000008080), 0x1.000002000008p+60, 0x1p+7 },
+{ UINT64_C(0x1000002000008200), 0x1.0000020000082p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000008400), 0x1.0000020000084p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000009000), 0x1.000002000009p+60, 0x0p+0 },
+{ UINT64_C(0x100000200000a000), 0x1.00000200000ap+60, 0x0p+0 },
+{ UINT64_C(0x1000002000040000), 0x1.00000200004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000040002), 0x1.00000200004p+60, 0x1p+1 },
+{ UINT64_C(0x1000002000040020), 0x1.00000200004p+60, 0x1p+5 },
+{ UINT64_C(0x1000002000040100), 0x1.0000020000401p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000040200), 0x1.0000020000402p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000040800), 0x1.0000020000408p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000042000), 0x1.000002000042p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000050000), 0x1.00000200005p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000100000), 0x1.0000020001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000100008), 0x1.0000020001p+60, 0x1p+3 },
+{ UINT64_C(0x1000002000100020), 0x1.0000020001p+60, 0x1p+5 },
+{ UINT64_C(0x1000002000100100), 0x1.0000020001001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000101000), 0x1.000002000101p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000104000), 0x1.000002000104p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000108000), 0x1.000002000108p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000120000), 0x1.00000200012p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000140000), 0x1.00000200014p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000200000), 0x1.0000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000200008), 0x1.0000020002p+60, 0x1p+3 },
+{ UINT64_C(0x1000002000200080), 0x1.0000020002p+60, 0x1p+7 },
+{ UINT64_C(0x1000002000200400), 0x1.0000020002004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000204000), 0x1.000002000204p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000208000), 0x1.000002000208p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000210000), 0x1.00000200021p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000280000), 0x1.00000200028p+60, 0x0p+0 },
+{ UINT64_C(0x1000002000300000), 0x1.0000020003p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002000000), 0x1.000002002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002000004), 0x1.000002002p+60, 0x1p+2 },
+{ UINT64_C(0x1000002002000020), 0x1.000002002p+60, 0x1p+5 },
+{ UINT64_C(0x1000002002000100), 0x1.0000020020001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002000400), 0x1.0000020020004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002002000), 0x1.000002002002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002020000), 0x1.00000200202p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002200000), 0x1.0000020022p+60, 0x0p+0 },
+{ UINT64_C(0x1000002002800000), 0x1.0000020028p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020000000), 0x1.00000202p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020000001), 0x1.00000202p+60, 0x1p+0 },
+{ UINT64_C(0x1000002020000004), 0x1.00000202p+60, 0x1p+2 },
+{ UINT64_C(0x1000002020000010), 0x1.00000202p+60, 0x1p+4 },
+{ UINT64_C(0x1000002020000020), 0x1.00000202p+60, 0x1p+5 },
+{ UINT64_C(0x1000002020000100), 0x1.0000020200001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020000800), 0x1.0000020200008p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020001000), 0x1.000002020001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020002000), 0x1.000002020002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020008000), 0x1.000002020008p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020040000), 0x1.00000202004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002020400000), 0x1.0000020204p+60, 0x0p+0 },
+{ UINT64_C(0x1000002021000000), 0x1.000002021p+60, 0x0p+0 },
+{ UINT64_C(0x1000002030000000), 0x1.00000203p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040000000), 0x1.00000204p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040000002), 0x1.00000204p+60, 0x1p+1 },
+{ UINT64_C(0x1000002040000008), 0x1.00000204p+60, 0x1p+3 },
+{ UINT64_C(0x1000002040000020), 0x1.00000204p+60, 0x1p+5 },
+{ UINT64_C(0x1000002040000200), 0x1.0000020400002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040001000), 0x1.000002040001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040002000), 0x1.000002040002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040004000), 0x1.000002040004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040008000), 0x1.000002040008p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040020000), 0x1.00000204002p+60, 0x0p+0 },
+{ UINT64_C(0x1000002040200000), 0x1.0000020402p+60, 0x0p+0 },
+{ UINT64_C(0x1000002042000000), 0x1.000002042p+60, 0x0p+0 },
+{ UINT64_C(0x1000002060000000), 0x1.00000206p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400000000), 0x1.0000024p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400000002), 0x1.0000024p+60, 0x1p+1 },
+{ UINT64_C(0x1000002400000004), 0x1.0000024p+60, 0x1p+2 },
+{ UINT64_C(0x1000002400000010), 0x1.0000024p+60, 0x1p+4 },
+{ UINT64_C(0x1000002400000100), 0x1.0000024000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400001000), 0x1.000002400001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400004000), 0x1.000002400004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400008000), 0x1.000002400008p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400040000), 0x1.00000240004p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400100000), 0x1.0000024001p+60, 0x0p+0 },
+{ UINT64_C(0x1000002400800000), 0x1.0000024008p+60, 0x0p+0 },
+{ UINT64_C(0x1000002408000000), 0x1.000002408p+60, 0x0p+0 },
+{ UINT64_C(0x1000002480000000), 0x1.00000248p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000000000), 0x1.000003p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000000004), 0x1.000003p+60, 0x1p+2 },
+{ UINT64_C(0x1000003000000008), 0x1.000003p+60, 0x1p+3 },
+{ UINT64_C(0x1000003000000020), 0x1.000003p+60, 0x1p+5 },
+{ UINT64_C(0x1000003000000200), 0x1.0000030000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000000800), 0x1.0000030000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000004000), 0x1.000003000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000010000), 0x1.00000300001p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000040000), 0x1.00000300004p+60, 0x0p+0 },
+{ UINT64_C(0x1000003000100000), 0x1.0000030001p+60, 0x0p+0 },
+{ UINT64_C(0x1000003001000000), 0x1.000003001p+60, 0x0p+0 },
+{ UINT64_C(0x1000003010000000), 0x1.00000301p+60, 0x0p+0 },
+{ UINT64_C(0x1000003040000000), 0x1.00000304p+60, 0x0p+0 },
+{ UINT64_C(0x1000003080000000), 0x1.00000308p+60, 0x0p+0 },
+{ UINT64_C(0x1000003100000000), 0x1.0000031p+60, 0x0p+0 },
+{ UINT64_C(0x1000003800000000), 0x1.0000038p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000000001), 0x1.00002p+60, 0x1p+0 },
+{ UINT64_C(0x1000020000000004), 0x1.00002p+60, 0x1p+2 },
+{ UINT64_C(0x1000020000000010), 0x1.00002p+60, 0x1p+4 },
+{ UINT64_C(0x1000020000000018), 0x1.00002p+60, 0x1.8p+4 },
+{ UINT64_C(0x1000020000000040), 0x1.00002p+60, 0x1p+6 },
+{ UINT64_C(0x1000020000000044), 0x1.00002p+60, 0x1.1p+6 },
+{ UINT64_C(0x1000020000000080), 0x1.00002p+60, 0x1p+7 },
+{ UINT64_C(0x1000020000000082), 0x1.0000200000001p+60, -0x1.f8p+6 },
+{ UINT64_C(0x1000020000000090), 0x1.0000200000001p+60, -0x1.cp+6 },
+{ UINT64_C(0x10000200000000c0), 0x1.0000200000001p+60, -0x1p+6 },
+{ UINT64_C(0x1000020000000800), 0x1.0000200000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000000802), 0x1.0000200000008p+60, 0x1p+1 },
+{ UINT64_C(0x1000020000000820), 0x1.0000200000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000020000000840), 0x1.0000200000008p+60, 0x1p+6 },
+{ UINT64_C(0x1000020000000900), 0x1.0000200000009p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000008000), 0x1.000020000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000008004), 0x1.000020000008p+60, 0x1p+2 },
+{ UINT64_C(0x1000020000008020), 0x1.000020000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000020000008100), 0x1.0000200000081p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000009000), 0x1.000020000009p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000040000), 0x1.00002000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000040002), 0x1.00002000004p+60, 0x1p+1 },
+{ UINT64_C(0x1000020000040020), 0x1.00002000004p+60, 0x1p+5 },
+{ UINT64_C(0x1000020000040100), 0x1.0000200000401p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000041000), 0x1.000020000041p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000050000), 0x1.00002000005p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000080000), 0x1.00002000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000080001), 0x1.00002000008p+60, 0x1p+0 },
+{ UINT64_C(0x1000020000080008), 0x1.00002000008p+60, 0x1p+3 },
+{ UINT64_C(0x1000020000080010), 0x1.00002000008p+60, 0x1p+4 },
+{ UINT64_C(0x1000020000080080), 0x1.00002000008p+60, 0x1p+7 },
+{ UINT64_C(0x1000020000080100), 0x1.0000200000801p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000080800), 0x1.0000200000808p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000088000), 0x1.000020000088p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000800000), 0x1.0000200008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000800004), 0x1.0000200008p+60, 0x1p+2 },
+{ UINT64_C(0x1000020000800010), 0x1.0000200008p+60, 0x1p+4 },
+{ UINT64_C(0x1000020000800080), 0x1.0000200008p+60, 0x1p+7 },
+{ UINT64_C(0x1000020000800800), 0x1.0000200008008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000808000), 0x1.000020000808p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000840000), 0x1.00002000084p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000880000), 0x1.00002000088p+60, 0x0p+0 },
+{ UINT64_C(0x1000020000c00000), 0x1.000020000cp+60, 0x0p+0 },
+{ UINT64_C(0x1000020008000000), 0x1.000020008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020008000002), 0x1.000020008p+60, 0x1p+1 },
+{ UINT64_C(0x1000020008000010), 0x1.000020008p+60, 0x1p+4 },
+{ UINT64_C(0x1000020008000080), 0x1.000020008p+60, 0x1p+7 },
+{ UINT64_C(0x1000020008000200), 0x1.0000200080002p+60, 0x0p+0 },
+{ UINT64_C(0x1000020008000400), 0x1.0000200080004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020008001000), 0x1.000020008001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020008004000), 0x1.000020008004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020008020000), 0x1.00002000802p+60, 0x0p+0 },
+{ UINT64_C(0x1000020008100000), 0x1.0000200081p+60, 0x0p+0 },
+{ UINT64_C(0x1000020009000000), 0x1.000020009p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010000000), 0x1.00002001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010000001), 0x1.00002001p+60, 0x1p+0 },
+{ UINT64_C(0x1000020010000008), 0x1.00002001p+60, 0x1p+3 },
+{ UINT64_C(0x1000020010000010), 0x1.00002001p+60, 0x1p+4 },
+{ UINT64_C(0x1000020010000100), 0x1.0000200100001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010000200), 0x1.0000200100002p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010000800), 0x1.0000200100008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010008000), 0x1.000020010008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010080000), 0x1.00002001008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020010800000), 0x1.0000200108p+60, 0x0p+0 },
+{ UINT64_C(0x1000020014000000), 0x1.000020014p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040000000), 0x1.00002004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040000002), 0x1.00002004p+60, 0x1p+1 },
+{ UINT64_C(0x1000020040000010), 0x1.00002004p+60, 0x1p+4 },
+{ UINT64_C(0x1000020040000080), 0x1.00002004p+60, 0x1p+7 },
+{ UINT64_C(0x1000020040000100), 0x1.0000200400001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040000200), 0x1.0000200400002p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040001000), 0x1.000020040001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040008000), 0x1.000020040008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040040000), 0x1.00002004004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040400000), 0x1.0000200404p+60, 0x0p+0 },
+{ UINT64_C(0x1000020040800000), 0x1.0000200408p+60, 0x0p+0 },
+{ UINT64_C(0x1000020041000000), 0x1.000020041p+60, 0x0p+0 },
+{ UINT64_C(0x1000020044000000), 0x1.000020044p+60, 0x0p+0 },
+{ UINT64_C(0x1000020060000000), 0x1.00002006p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100000000), 0x1.0000201p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100000002), 0x1.0000201p+60, 0x1p+1 },
+{ UINT64_C(0x1000020100000004), 0x1.0000201p+60, 0x1p+2 },
+{ UINT64_C(0x1000020100000020), 0x1.0000201p+60, 0x1p+5 },
+{ UINT64_C(0x1000020100000100), 0x1.0000201000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100000200), 0x1.0000201000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100001000), 0x1.000020100001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100008000), 0x1.000020100008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100080000), 0x1.00002010008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100100000), 0x1.0000201001p+60, 0x0p+0 },
+{ UINT64_C(0x1000020100400000), 0x1.0000201004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020104000000), 0x1.000020104p+60, 0x0p+0 },
+{ UINT64_C(0x1000020108000000), 0x1.000020108p+60, 0x0p+0 },
+{ UINT64_C(0x1000020140000000), 0x1.00002014p+60, 0x0p+0 },
+{ UINT64_C(0x1000020180000000), 0x1.00002018p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400000000), 0x1.0000204p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400000002), 0x1.0000204p+60, 0x1p+1 },
+{ UINT64_C(0x1000020400000010), 0x1.0000204p+60, 0x1p+4 },
+{ UINT64_C(0x1000020400000020), 0x1.0000204p+60, 0x1p+5 },
+{ UINT64_C(0x1000020400000080), 0x1.0000204p+60, 0x1p+7 },
+{ UINT64_C(0x1000020400000400), 0x1.0000204000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400004000), 0x1.000020400004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400020000), 0x1.00002040002p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400040000), 0x1.00002040004p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400200000), 0x1.0000204002p+60, 0x0p+0 },
+{ UINT64_C(0x1000020400800000), 0x1.0000204008p+60, 0x0p+0 },
+{ UINT64_C(0x1000020402000000), 0x1.000020402p+60, 0x0p+0 },
+{ UINT64_C(0x1000020420000000), 0x1.00002042p+60, 0x0p+0 },
+{ UINT64_C(0x1000020440000000), 0x1.00002044p+60, 0x0p+0 },
+{ UINT64_C(0x1000020600000000), 0x1.0000206p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000000000), 0x1.000022p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000000008), 0x1.000022p+60, 0x1p+3 },
+{ UINT64_C(0x1000022000000020), 0x1.000022p+60, 0x1p+5 },
+{ UINT64_C(0x1000022000000080), 0x1.000022p+60, 0x1p+7 },
+{ UINT64_C(0x1000022000000200), 0x1.0000220000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000000400), 0x1.0000220000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000000800), 0x1.0000220000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000002000), 0x1.000022000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000008000), 0x1.000022000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000080000), 0x1.00002200008p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000200000), 0x1.0000220002p+60, 0x0p+0 },
+{ UINT64_C(0x1000022000800000), 0x1.0000220008p+60, 0x0p+0 },
+{ UINT64_C(0x1000022002000000), 0x1.000022002p+60, 0x0p+0 },
+{ UINT64_C(0x1000022008000000), 0x1.000022008p+60, 0x0p+0 },
+{ UINT64_C(0x1000022010000000), 0x1.00002201p+60, 0x0p+0 },
+{ UINT64_C(0x1000022080000000), 0x1.00002208p+60, 0x0p+0 },
+{ UINT64_C(0x1000022800000000), 0x1.0000228p+60, 0x0p+0 },
+{ UINT64_C(0x1000023000000000), 0x1.000023p+60, 0x0p+0 },
+{ UINT64_C(0x1000028000000000), 0x1.000028p+60, 0x0p+0 },
+{ UINT64_C(0x1000028000000004), 0x1.000028p+60, 0x1p+2 },
+{ UINT64_C(0x1000028000000008), 0x1.000028p+60, 0x1p+3 },
+{ UINT64_C(0x1000028000000040), 0x1.000028p+60, 0x1p+6 },
+{ UINT64_C(0x1000028000000400), 0x1.0000280000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000028000002000), 0x1.000028000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000028000010000), 0x1.00002800001p+60, 0x0p+0 },
+{ UINT64_C(0x1000028000080000), 0x1.00002800008p+60, 0x0p+0 },
+{ UINT64_C(0x1000028000800000), 0x1.0000280008p+60, 0x0p+0 },
+{ UINT64_C(0x1000028002000000), 0x1.000028002p+60, 0x0p+0 },
+{ UINT64_C(0x1000028004000000), 0x1.000028004p+60, 0x0p+0 },
+{ UINT64_C(0x1000028010000000), 0x1.00002801p+60, 0x0p+0 },
+{ UINT64_C(0x1000028020000000), 0x1.00002802p+60, 0x0p+0 },
+{ UINT64_C(0x1000028100000000), 0x1.0000281p+60, 0x0p+0 },
+{ UINT64_C(0x1000029000000000), 0x1.000029p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000000004), 0x1.00008p+60, 0x1p+2 },
+{ UINT64_C(0x1000080000000006), 0x1.00008p+60, 0x1.8p+2 },
+{ UINT64_C(0x1000080000000010), 0x1.00008p+60, 0x1p+4 },
+{ UINT64_C(0x1000080000000014), 0x1.00008p+60, 0x1.4p+4 },
+{ UINT64_C(0x1000080000000018), 0x1.00008p+60, 0x1.8p+4 },
+{ UINT64_C(0x1000080000000020), 0x1.00008p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000000021), 0x1.00008p+60, 0x1.08p+5 },
+{ UINT64_C(0x1000080000000028), 0x1.00008p+60, 0x1.4p+5 },
+{ UINT64_C(0x1000080000000100), 0x1.0000800000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000000102), 0x1.0000800000001p+60, 0x1p+1 },
+{ UINT64_C(0x1000080000000104), 0x1.0000800000001p+60, 0x1p+2 },
+{ UINT64_C(0x1000080000000108), 0x1.0000800000001p+60, 0x1p+3 },
+{ UINT64_C(0x1000080000000110), 0x1.0000800000001p+60, 0x1p+4 },
+{ UINT64_C(0x1000080000000180), 0x1.0000800000002p+60, -0x1p+7 },
+{ UINT64_C(0x1000080000000200), 0x1.0000800000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000000202), 0x1.0000800000002p+60, 0x1p+1 },
+{ UINT64_C(0x1000080000000208), 0x1.0000800000002p+60, 0x1p+3 },
+{ UINT64_C(0x1000080000000240), 0x1.0000800000002p+60, 0x1p+6 },
+{ UINT64_C(0x1000080000000300), 0x1.0000800000003p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000000800), 0x1.0000800000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000000804), 0x1.0000800000008p+60, 0x1p+2 },
+{ UINT64_C(0x1000080000000810), 0x1.0000800000008p+60, 0x1p+4 },
+{ UINT64_C(0x1000080000000820), 0x1.0000800000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000000a00), 0x1.000080000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1000080000000c00), 0x1.000080000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1000080000001000), 0x1.000080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000001004), 0x1.000080000001p+60, 0x1p+2 },
+{ UINT64_C(0x1000080000001010), 0x1.000080000001p+60, 0x1p+4 },
+{ UINT64_C(0x1000080000001020), 0x1.000080000001p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000001100), 0x1.0000800000011p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000001400), 0x1.0000800000014p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000001800), 0x1.0000800000018p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000004000), 0x1.000080000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000004008), 0x1.000080000004p+60, 0x1p+3 },
+{ UINT64_C(0x1000080000004020), 0x1.000080000004p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000004040), 0x1.000080000004p+60, 0x1p+6 },
+{ UINT64_C(0x1000080000004100), 0x1.0000800000041p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000004800), 0x1.0000800000048p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000008000), 0x1.000080000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000008008), 0x1.000080000008p+60, 0x1p+3 },
+{ UINT64_C(0x1000080000008040), 0x1.000080000008p+60, 0x1p+6 },
+{ UINT64_C(0x1000080000008080), 0x1.000080000008p+60, 0x1p+7 },
+{ UINT64_C(0x1000080000008100), 0x1.0000800000081p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000008800), 0x1.0000800000088p+60, 0x0p+0 },
+{ UINT64_C(0x100008000000c000), 0x1.00008000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1000080000020000), 0x1.00008000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000020002), 0x1.00008000002p+60, 0x1p+1 },
+{ UINT64_C(0x1000080000020020), 0x1.00008000002p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000020100), 0x1.0000800000201p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000020800), 0x1.0000800000208p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000028000), 0x1.000080000028p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000080000), 0x1.00008000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000080004), 0x1.00008000008p+60, 0x1p+2 },
+{ UINT64_C(0x1000080000080010), 0x1.00008000008p+60, 0x1p+4 },
+{ UINT64_C(0x1000080000080100), 0x1.0000800000801p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000080400), 0x1.0000800000804p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000082000), 0x1.000080000082p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000088000), 0x1.000080000088p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000090000), 0x1.00008000009p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000100000), 0x1.0000800001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000100001), 0x1.0000800001p+60, 0x1p+0 },
+{ UINT64_C(0x1000080000100002), 0x1.0000800001p+60, 0x1p+1 },
+{ UINT64_C(0x1000080000100010), 0x1.0000800001p+60, 0x1p+4 },
+{ UINT64_C(0x1000080000100020), 0x1.0000800001p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000100200), 0x1.0000800001002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000100800), 0x1.0000800001008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000108000), 0x1.000080000108p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000110000), 0x1.00008000011p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000120000), 0x1.00008000012p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000200000), 0x1.0000800002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000200008), 0x1.0000800002p+60, 0x1p+3 },
+{ UINT64_C(0x1000080000200020), 0x1.0000800002p+60, 0x1p+5 },
+{ UINT64_C(0x1000080000200080), 0x1.0000800002p+60, 0x1p+7 },
+{ UINT64_C(0x1000080000200100), 0x1.0000800002001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000201000), 0x1.000080000201p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000210000), 0x1.00008000021p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000240000), 0x1.00008000024p+60, 0x0p+0 },
+{ UINT64_C(0x1000080000300000), 0x1.0000800003p+60, 0x0p+0 },
+{ UINT64_C(0x1000080002000000), 0x1.000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080002000008), 0x1.000080002p+60, 0x1p+3 },
+{ UINT64_C(0x1000080002000010), 0x1.000080002p+60, 0x1p+4 },
+{ UINT64_C(0x1000080002000040), 0x1.000080002p+60, 0x1p+6 },
+{ UINT64_C(0x1000080002000200), 0x1.0000800020002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080002000800), 0x1.0000800020008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080002002000), 0x1.000080002002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080002020000), 0x1.00008000202p+60, 0x0p+0 },
+{ UINT64_C(0x1000080002100000), 0x1.0000800021p+60, 0x0p+0 },
+{ UINT64_C(0x1000080003000000), 0x1.000080003p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008000000), 0x1.000080008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008000002), 0x1.000080008p+60, 0x1p+1 },
+{ UINT64_C(0x1000080008000004), 0x1.000080008p+60, 0x1p+2 },
+{ UINT64_C(0x1000080008000040), 0x1.000080008p+60, 0x1p+6 },
+{ UINT64_C(0x1000080008000080), 0x1.000080008p+60, 0x1p+7 },
+{ UINT64_C(0x1000080008000100), 0x1.0000800080001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008000200), 0x1.0000800080002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008000800), 0x1.0000800080008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008002000), 0x1.000080008002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008004000), 0x1.000080008004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008040000), 0x1.00008000804p+60, 0x0p+0 },
+{ UINT64_C(0x1000080008400000), 0x1.0000800084p+60, 0x0p+0 },
+{ UINT64_C(0x100008000a000000), 0x1.00008000ap+60, 0x0p+0 },
+{ UINT64_C(0x1000080010000000), 0x1.00008001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010000002), 0x1.00008001p+60, 0x1p+1 },
+{ UINT64_C(0x1000080010000020), 0x1.00008001p+60, 0x1p+5 },
+{ UINT64_C(0x1000080010000040), 0x1.00008001p+60, 0x1p+6 },
+{ UINT64_C(0x1000080010000200), 0x1.0000800100002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010000400), 0x1.0000800100004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010004000), 0x1.000080010004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010040000), 0x1.00008001004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010080000), 0x1.00008001008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010100000), 0x1.0000800101p+60, 0x0p+0 },
+{ UINT64_C(0x1000080010800000), 0x1.0000800108p+60, 0x0p+0 },
+{ UINT64_C(0x1000080011000000), 0x1.000080011p+60, 0x0p+0 },
+{ UINT64_C(0x1000080040000000), 0x1.00008004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080040000008), 0x1.00008004p+60, 0x1p+3 },
+{ UINT64_C(0x1000080040000020), 0x1.00008004p+60, 0x1p+5 },
+{ UINT64_C(0x1000080040000080), 0x1.00008004p+60, 0x1p+7 },
+{ UINT64_C(0x1000080040000800), 0x1.0000800400008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080040008000), 0x1.000080040008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080040080000), 0x1.00008004008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080040400000), 0x1.0000800404p+60, 0x0p+0 },
+{ UINT64_C(0x1000080040800000), 0x1.0000800408p+60, 0x0p+0 },
+{ UINT64_C(0x1000080048000000), 0x1.000080048p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100000000), 0x1.0000801p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100000002), 0x1.0000801p+60, 0x1p+1 },
+{ UINT64_C(0x1000080100000020), 0x1.0000801p+60, 0x1p+5 },
+{ UINT64_C(0x1000080100000040), 0x1.0000801p+60, 0x1p+6 },
+{ UINT64_C(0x1000080100000200), 0x1.0000801000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100000400), 0x1.0000801000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100001000), 0x1.000080100001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100004000), 0x1.000080100004p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100010000), 0x1.00008010001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080100100000), 0x1.0000801001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080101000000), 0x1.000080101p+60, 0x0p+0 },
+{ UINT64_C(0x1000080110000000), 0x1.00008011p+60, 0x0p+0 },
+{ UINT64_C(0x1000080120000000), 0x1.00008012p+60, 0x0p+0 },
+{ UINT64_C(0x1000080180000000), 0x1.00008018p+60, 0x0p+0 },
+{ UINT64_C(0x1000080800000000), 0x1.0000808p+60, 0x0p+0 },
+{ UINT64_C(0x1000080800000002), 0x1.0000808p+60, 0x1p+1 },
+{ UINT64_C(0x1000080800000008), 0x1.0000808p+60, 0x1p+3 },
+{ UINT64_C(0x1000080800000080), 0x1.0000808p+60, 0x1p+7 },
+{ UINT64_C(0x1000080800000800), 0x1.0000808000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000080800002000), 0x1.000080800002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080800020000), 0x1.00008080002p+60, 0x0p+0 },
+{ UINT64_C(0x1000080800100000), 0x1.0000808001p+60, 0x0p+0 },
+{ UINT64_C(0x1000080801000000), 0x1.000080801p+60, 0x0p+0 },
+{ UINT64_C(0x1000080802000000), 0x1.000080802p+60, 0x0p+0 },
+{ UINT64_C(0x1000080810000000), 0x1.00008081p+60, 0x0p+0 },
+{ UINT64_C(0x1000080820000000), 0x1.00008082p+60, 0x0p+0 },
+{ UINT64_C(0x1000080a00000000), 0x1.000080ap+60, 0x0p+0 },
+{ UINT64_C(0x1000088000000000), 0x1.000088p+60, 0x0p+0 },
+{ UINT64_C(0x1000088000000001), 0x1.000088p+60, 0x1p+0 },
+{ UINT64_C(0x1000088000000010), 0x1.000088p+60, 0x1p+4 },
+{ UINT64_C(0x1000088000000080), 0x1.000088p+60, 0x1p+7 },
+{ UINT64_C(0x1000088000000400), 0x1.0000880000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000088000001000), 0x1.000088000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000088000008000), 0x1.000088000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000088000010000), 0x1.00008800001p+60, 0x0p+0 },
+{ UINT64_C(0x1000088000040000), 0x1.00008800004p+60, 0x0p+0 },
+{ UINT64_C(0x1000088000100000), 0x1.0000880001p+60, 0x0p+0 },
+{ UINT64_C(0x1000088001000000), 0x1.000088001p+60, 0x0p+0 },
+{ UINT64_C(0x1000088004000000), 0x1.000088004p+60, 0x0p+0 },
+{ UINT64_C(0x1000088008000000), 0x1.000088008p+60, 0x0p+0 },
+{ UINT64_C(0x1000088080000000), 0x1.00008808p+60, 0x0p+0 },
+{ UINT64_C(0x1000088800000000), 0x1.0000888p+60, 0x0p+0 },
+{ UINT64_C(0x100008c000000000), 0x1.00008cp+60, 0x0p+0 },
+{ UINT64_C(0x1000800000000002), 0x1.0008p+60, 0x1p+1 },
+{ UINT64_C(0x1000800000000020), 0x1.0008p+60, 0x1p+5 },
+{ UINT64_C(0x1000800000000021), 0x1.0008p+60, 0x1.08p+5 },
+{ UINT64_C(0x1000800000000030), 0x1.0008p+60, 0x1.8p+5 },
+{ UINT64_C(0x1000800000000100), 0x1.0008000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000000108), 0x1.0008000000001p+60, 0x1p+3 },
+{ UINT64_C(0x1000800000000140), 0x1.0008000000001p+60, 0x1p+6 },
+{ UINT64_C(0x1000800000000200), 0x1.0008000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000000208), 0x1.0008000000002p+60, 0x1p+3 },
+{ UINT64_C(0x1000800000000220), 0x1.0008000000002p+60, 0x1p+5 },
+{ UINT64_C(0x1000800000000280), 0x1.0008000000002p+60, 0x1p+7 },
+{ UINT64_C(0x1000800000000400), 0x1.0008000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000000402), 0x1.0008000000004p+60, 0x1p+1 },
+{ UINT64_C(0x1000800000000404), 0x1.0008000000004p+60, 0x1p+2 },
+{ UINT64_C(0x1000800000000440), 0x1.0008000000004p+60, 0x1p+6 },
+{ UINT64_C(0x1000800000000500), 0x1.0008000000005p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000004000), 0x1.000800000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000004001), 0x1.000800000004p+60, 0x1p+0 },
+{ UINT64_C(0x1000800000004010), 0x1.000800000004p+60, 0x1p+4 },
+{ UINT64_C(0x1000800000004040), 0x1.000800000004p+60, 0x1p+6 },
+{ UINT64_C(0x1000800000004080), 0x1.000800000004p+60, 0x1p+7 },
+{ UINT64_C(0x1000800000004100), 0x1.0008000000041p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000004200), 0x1.0008000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000004800), 0x1.0008000000048p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000006000), 0x1.000800000006p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000010000), 0x1.00080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000010004), 0x1.00080000001p+60, 0x1p+2 },
+{ UINT64_C(0x1000800000010020), 0x1.00080000001p+60, 0x1p+5 },
+{ UINT64_C(0x1000800000010080), 0x1.00080000001p+60, 0x1p+7 },
+{ UINT64_C(0x1000800000010100), 0x1.0008000000101p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000011000), 0x1.000800000011p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000018000), 0x1.000800000018p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000020000), 0x1.00080000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000020001), 0x1.00080000002p+60, 0x1p+0 },
+{ UINT64_C(0x1000800000020010), 0x1.00080000002p+60, 0x1p+4 },
+{ UINT64_C(0x1000800000020040), 0x1.00080000002p+60, 0x1p+6 },
+{ UINT64_C(0x1000800000020100), 0x1.0008000000201p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000020800), 0x1.0008000000208p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000028000), 0x1.000800000028p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000100000), 0x1.0008000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000100004), 0x1.0008000001p+60, 0x1p+2 },
+{ UINT64_C(0x1000800000100008), 0x1.0008000001p+60, 0x1p+3 },
+{ UINT64_C(0x1000800000100040), 0x1.0008000001p+60, 0x1p+6 },
+{ UINT64_C(0x1000800000100400), 0x1.0008000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000104000), 0x1.000800000104p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000120000), 0x1.00080000012p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000140000), 0x1.00080000014p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000800000), 0x1.0008000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000800002), 0x1.0008000008p+60, 0x1p+1 },
+{ UINT64_C(0x1000800000800008), 0x1.0008000008p+60, 0x1p+3 },
+{ UINT64_C(0x1000800000800010), 0x1.0008000008p+60, 0x1p+4 },
+{ UINT64_C(0x1000800000800020), 0x1.0008000008p+60, 0x1p+5 },
+{ UINT64_C(0x1000800000800040), 0x1.0008000008p+60, 0x1p+6 },
+{ UINT64_C(0x1000800000800100), 0x1.0008000008001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000800200), 0x1.0008000008002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000800800), 0x1.0008000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000802000), 0x1.000800000802p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000810000), 0x1.00080000081p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000880000), 0x1.00080000088p+60, 0x0p+0 },
+{ UINT64_C(0x1000800000a00000), 0x1.000800000ap+60, 0x0p+0 },
+{ UINT64_C(0x1000800004000000), 0x1.000800004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800004000001), 0x1.000800004p+60, 0x1p+0 },
+{ UINT64_C(0x1000800004000002), 0x1.000800004p+60, 0x1p+1 },
+{ UINT64_C(0x1000800004000004), 0x1.000800004p+60, 0x1p+2 },
+{ UINT64_C(0x1000800004000010), 0x1.000800004p+60, 0x1p+4 },
+{ UINT64_C(0x1000800004000080), 0x1.000800004p+60, 0x1p+7 },
+{ UINT64_C(0x1000800004000200), 0x1.0008000040002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800004001000), 0x1.000800004001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800004008000), 0x1.000800004008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800004020000), 0x1.00080000402p+60, 0x0p+0 },
+{ UINT64_C(0x1000800004200000), 0x1.0008000042p+60, 0x0p+0 },
+{ UINT64_C(0x1000800006000000), 0x1.000800006p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010000000), 0x1.00080001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010000004), 0x1.00080001p+60, 0x1p+2 },
+{ UINT64_C(0x1000800010000008), 0x1.00080001p+60, 0x1p+3 },
+{ UINT64_C(0x1000800010000010), 0x1.00080001p+60, 0x1p+4 },
+{ UINT64_C(0x1000800010000080), 0x1.00080001p+60, 0x1p+7 },
+{ UINT64_C(0x1000800010000100), 0x1.0008000100001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010001000), 0x1.000800010001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010008000), 0x1.000800010008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010020000), 0x1.00080001002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010040000), 0x1.00080001004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010200000), 0x1.0008000102p+60, 0x0p+0 },
+{ UINT64_C(0x1000800010400000), 0x1.0008000104p+60, 0x0p+0 },
+{ UINT64_C(0x1000800014000000), 0x1.000800014p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080000000), 0x1.00080008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080000004), 0x1.00080008p+60, 0x1p+2 },
+{ UINT64_C(0x1000800080000010), 0x1.00080008p+60, 0x1p+4 },
+{ UINT64_C(0x1000800080000080), 0x1.00080008p+60, 0x1p+7 },
+{ UINT64_C(0x1000800080000400), 0x1.0008000800004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080002000), 0x1.000800080002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080004000), 0x1.000800080004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080020000), 0x1.00080008002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080080000), 0x1.00080008008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800080800000), 0x1.0008000808p+60, 0x0p+0 },
+{ UINT64_C(0x1000800084000000), 0x1.000800084p+60, 0x0p+0 },
+{ UINT64_C(0x10008000c0000000), 0x1.0008000cp+60, 0x0p+0 },
+{ UINT64_C(0x1000800100000000), 0x1.0008001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100000004), 0x1.0008001p+60, 0x1p+2 },
+{ UINT64_C(0x1000800100000008), 0x1.0008001p+60, 0x1p+3 },
+{ UINT64_C(0x1000800100000040), 0x1.0008001p+60, 0x1p+6 },
+{ UINT64_C(0x1000800100000080), 0x1.0008001p+60, 0x1p+7 },
+{ UINT64_C(0x1000800100000100), 0x1.0008001000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100001000), 0x1.000800100001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100008000), 0x1.000800100008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100010000), 0x1.00080010001p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100080000), 0x1.00080010008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100200000), 0x1.0008001002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800100800000), 0x1.0008001008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800108000000), 0x1.000800108p+60, 0x0p+0 },
+{ UINT64_C(0x1000800110000000), 0x1.00080011p+60, 0x0p+0 },
+{ UINT64_C(0x1000800140000000), 0x1.00080014p+60, 0x0p+0 },
+{ UINT64_C(0x1000800400000000), 0x1.0008004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800400000008), 0x1.0008004p+60, 0x1p+3 },
+{ UINT64_C(0x1000800400000080), 0x1.0008004p+60, 0x1p+7 },
+{ UINT64_C(0x1000800400000400), 0x1.0008004000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800400004000), 0x1.000800400004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800400008000), 0x1.000800400008p+60, 0x0p+0 },
+{ UINT64_C(0x1000800400040000), 0x1.00080040004p+60, 0x0p+0 },
+{ UINT64_C(0x1000800400200000), 0x1.0008004002p+60, 0x0p+0 },
+{ UINT64_C(0x1000800401000000), 0x1.000800401p+60, 0x0p+0 },
+{ UINT64_C(0x1000800410000000), 0x1.00080041p+60, 0x0p+0 },
+{ UINT64_C(0x1000800500000000), 0x1.0008005p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000000000), 0x1.000802p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000000004), 0x1.000802p+60, 0x1p+2 },
+{ UINT64_C(0x1000802000000040), 0x1.000802p+60, 0x1p+6 },
+{ UINT64_C(0x1000802000000100), 0x1.0008020000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000000800), 0x1.0008020000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000008000), 0x1.000802000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000040000), 0x1.00080200004p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000080000), 0x1.00080200008p+60, 0x0p+0 },
+{ UINT64_C(0x1000802000800000), 0x1.0008020008p+60, 0x0p+0 },
+{ UINT64_C(0x1000802008000000), 0x1.000802008p+60, 0x0p+0 },
+{ UINT64_C(0x1000802040000000), 0x1.00080204p+60, 0x0p+0 },
+{ UINT64_C(0x1000802400000000), 0x1.0008024p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000000000), 0x1.00081p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000000001), 0x1.00081p+60, 0x1p+0 },
+{ UINT64_C(0x1000810000000004), 0x1.00081p+60, 0x1p+2 },
+{ UINT64_C(0x1000810000000020), 0x1.00081p+60, 0x1p+5 },
+{ UINT64_C(0x1000810000000200), 0x1.0008100000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000000400), 0x1.0008100000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000002000), 0x1.000810000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000004000), 0x1.000810000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000008000), 0x1.000810000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000080000), 0x1.00081000008p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000100000), 0x1.0008100001p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000200000), 0x1.0008100002p+60, 0x0p+0 },
+{ UINT64_C(0x1000810000800000), 0x1.0008100008p+60, 0x0p+0 },
+{ UINT64_C(0x1000810004000000), 0x1.000810004p+60, 0x0p+0 },
+{ UINT64_C(0x1000810010000000), 0x1.00081001p+60, 0x0p+0 },
+{ UINT64_C(0x1000810100000000), 0x1.0008101p+60, 0x0p+0 },
+{ UINT64_C(0x1000810800000000), 0x1.0008108p+60, 0x0p+0 },
+{ UINT64_C(0x1000818000000000), 0x1.000818p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000000000), 0x1.0009p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000000002), 0x1.0009p+60, 0x1p+1 },
+{ UINT64_C(0x1000900000000004), 0x1.0009p+60, 0x1p+2 },
+{ UINT64_C(0x1000900000000008), 0x1.0009p+60, 0x1p+3 },
+{ UINT64_C(0x1000900000000020), 0x1.0009p+60, 0x1p+5 },
+{ UINT64_C(0x1000900000000100), 0x1.0009000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000001000), 0x1.000900000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000002000), 0x1.000900000002p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000004000), 0x1.000900000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000010000), 0x1.00090000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000100000), 0x1.0009000001p+60, 0x0p+0 },
+{ UINT64_C(0x1000900000400000), 0x1.0009000004p+60, 0x0p+0 },
+{ UINT64_C(0x1000900004000000), 0x1.000900004p+60, 0x0p+0 },
+{ UINT64_C(0x1000900010000000), 0x1.00090001p+60, 0x0p+0 },
+{ UINT64_C(0x1000900100000000), 0x1.0009001p+60, 0x0p+0 },
+{ UINT64_C(0x1000900400000000), 0x1.0009004p+60, 0x0p+0 },
+{ UINT64_C(0x1000904000000000), 0x1.000904p+60, 0x0p+0 },
+{ UINT64_C(0x1000920000000000), 0x1.00092p+60, 0x0p+0 },
+{ UINT64_C(0x1000940000000000), 0x1.00094p+60, 0x0p+0 },
+{ UINT64_C(0x1000980000000000), 0x1.00098p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000000008), 0x1.004p+60, 0x1p+3 },
+{ UINT64_C(0x1004000000000009), 0x1.004p+60, 0x1.2p+3 },
+{ UINT64_C(0x100400000000000c), 0x1.004p+60, 0x1.8p+3 },
+{ UINT64_C(0x1004000000000080), 0x1.004p+60, 0x1p+7 },
+{ UINT64_C(0x1004000000000084), 0x1.0040000000001p+60, -0x1.fp+6 },
+{ UINT64_C(0x1004000000000090), 0x1.0040000000001p+60, -0x1.cp+6 },
+{ UINT64_C(0x1004000000000200), 0x1.0040000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000000202), 0x1.0040000000002p+60, 0x1p+1 },
+{ UINT64_C(0x1004000000000210), 0x1.0040000000002p+60, 0x1p+4 },
+{ UINT64_C(0x1004000000000300), 0x1.0040000000003p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000000800), 0x1.0040000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000000802), 0x1.0040000000008p+60, 0x1p+1 },
+{ UINT64_C(0x1004000000000810), 0x1.0040000000008p+60, 0x1p+4 },
+{ UINT64_C(0x1004000000000900), 0x1.0040000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000004000), 0x1.004000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000004001), 0x1.004000000004p+60, 0x1p+0 },
+{ UINT64_C(0x1004000000004004), 0x1.004000000004p+60, 0x1p+2 },
+{ UINT64_C(0x1004000000004020), 0x1.004000000004p+60, 0x1p+5 },
+{ UINT64_C(0x1004000000004200), 0x1.0040000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000006000), 0x1.004000000006p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000010000), 0x1.00400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000010008), 0x1.00400000001p+60, 0x1p+3 },
+{ UINT64_C(0x1004000000010040), 0x1.00400000001p+60, 0x1p+6 },
+{ UINT64_C(0x1004000000010100), 0x1.0040000000101p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000010800), 0x1.0040000000108p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000011000), 0x1.004000000011p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000012000), 0x1.004000000012p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000100000), 0x1.0040000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000100008), 0x1.0040000001p+60, 0x1p+3 },
+{ UINT64_C(0x1004000000100040), 0x1.0040000001p+60, 0x1p+6 },
+{ UINT64_C(0x1004000000100080), 0x1.0040000001p+60, 0x1p+7 },
+{ UINT64_C(0x1004000000100800), 0x1.0040000001008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000101000), 0x1.004000000101p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000108000), 0x1.004000000108p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000140000), 0x1.00400000014p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000400000), 0x1.0040000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000400002), 0x1.0040000004p+60, 0x1p+1 },
+{ UINT64_C(0x1004000000400008), 0x1.0040000004p+60, 0x1p+3 },
+{ UINT64_C(0x1004000000400040), 0x1.0040000004p+60, 0x1p+6 },
+{ UINT64_C(0x1004000000400200), 0x1.0040000004002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000400800), 0x1.0040000004008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000404000), 0x1.004000000404p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000440000), 0x1.00400000044p+60, 0x0p+0 },
+{ UINT64_C(0x1004000000500000), 0x1.0040000005p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001000000), 0x1.004000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001000002), 0x1.004000001p+60, 0x1p+1 },
+{ UINT64_C(0x1004000001000008), 0x1.004000001p+60, 0x1p+3 },
+{ UINT64_C(0x1004000001000020), 0x1.004000001p+60, 0x1p+5 },
+{ UINT64_C(0x1004000001000080), 0x1.004000001p+60, 0x1p+7 },
+{ UINT64_C(0x1004000001000400), 0x1.0040000010004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001004000), 0x1.004000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001008000), 0x1.004000001008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001010000), 0x1.00400000101p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001100000), 0x1.0040000011p+60, 0x0p+0 },
+{ UINT64_C(0x1004000001800000), 0x1.0040000018p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008000000), 0x1.004000008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008000004), 0x1.004000008p+60, 0x1p+2 },
+{ UINT64_C(0x1004000008000008), 0x1.004000008p+60, 0x1p+3 },
+{ UINT64_C(0x1004000008000020), 0x1.004000008p+60, 0x1p+5 },
+{ UINT64_C(0x1004000008000080), 0x1.004000008p+60, 0x1p+7 },
+{ UINT64_C(0x1004000008000200), 0x1.0040000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008000800), 0x1.0040000080008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008008000), 0x1.004000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008020000), 0x1.00400000802p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008080000), 0x1.00400000808p+60, 0x0p+0 },
+{ UINT64_C(0x1004000008800000), 0x1.0040000088p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040000000), 0x1.00400004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040000001), 0x1.00400004p+60, 0x1p+0 },
+{ UINT64_C(0x1004000040000010), 0x1.00400004p+60, 0x1p+4 },
+{ UINT64_C(0x1004000040000020), 0x1.00400004p+60, 0x1p+5 },
+{ UINT64_C(0x1004000040000200), 0x1.0040000400002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040002000), 0x1.004000040002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040008000), 0x1.004000040008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040020000), 0x1.00400004002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040080000), 0x1.00400004008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040100000), 0x1.0040000401p+60, 0x0p+0 },
+{ UINT64_C(0x1004000040800000), 0x1.0040000408p+60, 0x0p+0 },
+{ UINT64_C(0x1004000041000000), 0x1.004000041p+60, 0x0p+0 },
+{ UINT64_C(0x1004000042000000), 0x1.004000042p+60, 0x0p+0 },
+{ UINT64_C(0x1004000044000000), 0x1.004000044p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080000000), 0x1.00400008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080000004), 0x1.00400008p+60, 0x1p+2 },
+{ UINT64_C(0x1004000080000040), 0x1.00400008p+60, 0x1p+6 },
+{ UINT64_C(0x1004000080000400), 0x1.0040000800004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080002000), 0x1.004000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080004000), 0x1.004000080004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080010000), 0x1.00400008001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080100000), 0x1.0040000801p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080200000), 0x1.0040000802p+60, 0x0p+0 },
+{ UINT64_C(0x1004000080800000), 0x1.0040000808p+60, 0x0p+0 },
+{ UINT64_C(0x1004000084000000), 0x1.004000084p+60, 0x0p+0 },
+{ UINT64_C(0x10040000c0000000), 0x1.0040000cp+60, 0x0p+0 },
+{ UINT64_C(0x1004000100000000), 0x1.0040001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000100000008), 0x1.0040001p+60, 0x1p+3 },
+{ UINT64_C(0x1004000100000040), 0x1.0040001p+60, 0x1p+6 },
+{ UINT64_C(0x1004000100000200), 0x1.0040001000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000100002000), 0x1.004000100002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000100010000), 0x1.00400010001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000100080000), 0x1.00400010008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000100400000), 0x1.0040001004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000101000000), 0x1.004000101p+60, 0x0p+0 },
+{ UINT64_C(0x1004000108000000), 0x1.004000108p+60, 0x0p+0 },
+{ UINT64_C(0x1004000180000000), 0x1.00400018p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800000000), 0x1.0040008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800000008), 0x1.0040008p+60, 0x1p+3 },
+{ UINT64_C(0x1004000800000010), 0x1.0040008p+60, 0x1p+4 },
+{ UINT64_C(0x1004000800000100), 0x1.0040008000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800000400), 0x1.0040008000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800002000), 0x1.004000800002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800008000), 0x1.004000800008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800020000), 0x1.00400080002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800200000), 0x1.0040008002p+60, 0x0p+0 },
+{ UINT64_C(0x1004000800800000), 0x1.0040008008p+60, 0x0p+0 },
+{ UINT64_C(0x1004000802000000), 0x1.004000802p+60, 0x0p+0 },
+{ UINT64_C(0x1004000808000000), 0x1.004000808p+60, 0x0p+0 },
+{ UINT64_C(0x1004000810000000), 0x1.00400081p+60, 0x0p+0 },
+{ UINT64_C(0x1004000880000000), 0x1.00400088p+60, 0x0p+0 },
+{ UINT64_C(0x1004000c00000000), 0x1.004000cp+60, 0x0p+0 },
+{ UINT64_C(0x1004004000000000), 0x1.004004p+60, 0x0p+0 },
+{ UINT64_C(0x1004004000000008), 0x1.004004p+60, 0x1p+3 },
+{ UINT64_C(0x1004004000000040), 0x1.004004p+60, 0x1p+6 },
+{ UINT64_C(0x1004004000000080), 0x1.004004p+60, 0x1p+7 },
+{ UINT64_C(0x1004004000000800), 0x1.0040040000008p+60, 0x0p+0 },
+{ UINT64_C(0x1004004000008000), 0x1.004004000008p+60, 0x0p+0 },
+{ UINT64_C(0x1004004000080000), 0x1.00400400008p+60, 0x0p+0 },
+{ UINT64_C(0x1004004000800000), 0x1.0040040008p+60, 0x0p+0 },
+{ UINT64_C(0x1004004004000000), 0x1.004004004p+60, 0x0p+0 },
+{ UINT64_C(0x1004004010000000), 0x1.00400401p+60, 0x0p+0 },
+{ UINT64_C(0x1004004040000000), 0x1.00400404p+60, 0x0p+0 },
+{ UINT64_C(0x1004004400000000), 0x1.0040044p+60, 0x0p+0 },
+{ UINT64_C(0x1004006000000000), 0x1.004006p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000000000), 0x1.00402p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000000002), 0x1.00402p+60, 0x1p+1 },
+{ UINT64_C(0x1004020000000004), 0x1.00402p+60, 0x1p+2 },
+{ UINT64_C(0x1004020000000020), 0x1.00402p+60, 0x1p+5 },
+{ UINT64_C(0x1004020000000040), 0x1.00402p+60, 0x1p+6 },
+{ UINT64_C(0x1004020000000100), 0x1.0040200000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000000800), 0x1.0040200000008p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000002000), 0x1.004020000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000020000), 0x1.00402000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000040000), 0x1.00402000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000200000), 0x1.0040200002p+60, 0x0p+0 },
+{ UINT64_C(0x1004020000400000), 0x1.0040200004p+60, 0x0p+0 },
+{ UINT64_C(0x1004020001000000), 0x1.004020001p+60, 0x0p+0 },
+{ UINT64_C(0x1004020004000000), 0x1.004020004p+60, 0x0p+0 },
+{ UINT64_C(0x1004020040000000), 0x1.00402004p+60, 0x0p+0 },
+{ UINT64_C(0x1004020100000000), 0x1.0040201p+60, 0x0p+0 },
+{ UINT64_C(0x1004020400000000), 0x1.0040204p+60, 0x0p+0 },
+{ UINT64_C(0x1004022000000000), 0x1.004022p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000000000), 0x1.0042p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000000004), 0x1.0042p+60, 0x1p+2 },
+{ UINT64_C(0x1004200000000010), 0x1.0042p+60, 0x1p+4 },
+{ UINT64_C(0x1004200000000040), 0x1.0042p+60, 0x1p+6 },
+{ UINT64_C(0x1004200000000100), 0x1.0042000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000000200), 0x1.0042000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000002000), 0x1.004200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000004000), 0x1.004200000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000040000), 0x1.00420000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004200000200000), 0x1.0042000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004200002000000), 0x1.004200002p+60, 0x0p+0 },
+{ UINT64_C(0x1004200004000000), 0x1.004200004p+60, 0x0p+0 },
+{ UINT64_C(0x1004200040000000), 0x1.00420004p+60, 0x0p+0 },
+{ UINT64_C(0x1004200200000000), 0x1.0042002p+60, 0x0p+0 },
+{ UINT64_C(0x1004200800000000), 0x1.0042008p+60, 0x0p+0 },
+{ UINT64_C(0x1004202000000000), 0x1.004202p+60, 0x0p+0 },
+{ UINT64_C(0x1004210000000000), 0x1.00421p+60, 0x0p+0 },
+{ UINT64_C(0x1004300000000000), 0x1.0043p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000000000), 0x1.0044p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000000002), 0x1.0044p+60, 0x1p+1 },
+{ UINT64_C(0x1004400000000004), 0x1.0044p+60, 0x1p+2 },
+{ UINT64_C(0x1004400000000040), 0x1.0044p+60, 0x1p+6 },
+{ UINT64_C(0x1004400000000200), 0x1.0044000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000000800), 0x1.0044000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000004000), 0x1.004400000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000020000), 0x1.00440000002p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000040000), 0x1.00440000004p+60, 0x0p+0 },
+{ UINT64_C(0x1004400000100000), 0x1.0044000001p+60, 0x0p+0 },
+{ UINT64_C(0x1004400001000000), 0x1.004400001p+60, 0x0p+0 },
+{ UINT64_C(0x1004400008000000), 0x1.004400008p+60, 0x0p+0 },
+{ UINT64_C(0x1004400010000000), 0x1.00440001p+60, 0x0p+0 },
+{ UINT64_C(0x1004400040000000), 0x1.00440004p+60, 0x0p+0 },
+{ UINT64_C(0x1004400080000000), 0x1.00440008p+60, 0x0p+0 },
+{ UINT64_C(0x1004400400000000), 0x1.0044004p+60, 0x0p+0 },
+{ UINT64_C(0x1004400800000000), 0x1.0044008p+60, 0x0p+0 },
+{ UINT64_C(0x1004402000000000), 0x1.004402p+60, 0x0p+0 },
+{ UINT64_C(0x1004420000000000), 0x1.00442p+60, 0x0p+0 },
+{ UINT64_C(0x1004440000000000), 0x1.00444p+60, 0x0p+0 },
+{ UINT64_C(0x1004600000000000), 0x1.0046p+60, 0x0p+0 },
+{ UINT64_C(0x1006000000000000), 0x1.006p+60, 0x0p+0 },
+{ UINT64_C(0x1006000000000004), 0x1.006p+60, 0x1p+2 },
+{ UINT64_C(0x1006000000000020), 0x1.006p+60, 0x1p+5 },
+{ UINT64_C(0x1006000000000080), 0x1.006p+60, 0x1p+7 },
+{ UINT64_C(0x1006000000000400), 0x1.0060000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1006000000001000), 0x1.006000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1006000000002000), 0x1.006000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1006000000020000), 0x1.00600000002p+60, 0x0p+0 },
+{ UINT64_C(0x1006000000200000), 0x1.0060000002p+60, 0x0p+0 },
+{ UINT64_C(0x1006000001000000), 0x1.006000001p+60, 0x0p+0 },
+{ UINT64_C(0x1006000004000000), 0x1.006000004p+60, 0x0p+0 },
+{ UINT64_C(0x1006000020000000), 0x1.00600002p+60, 0x0p+0 },
+{ UINT64_C(0x1006000080000000), 0x1.00600008p+60, 0x0p+0 },
+{ UINT64_C(0x1006000800000000), 0x1.0060008p+60, 0x0p+0 },
+{ UINT64_C(0x1006001000000000), 0x1.006001p+60, 0x0p+0 },
+{ UINT64_C(0x1006002000000000), 0x1.006002p+60, 0x0p+0 },
+{ UINT64_C(0x1006004000000000), 0x1.006004p+60, 0x0p+0 },
+{ UINT64_C(0x1006040000000000), 0x1.00604p+60, 0x0p+0 },
+{ UINT64_C(0x1006200000000000), 0x1.0062p+60, 0x0p+0 },
+{ UINT64_C(0x1007000000000000), 0x1.007p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000000008), 0x1.01p+60, 0x1p+3 },
+{ UINT64_C(0x101000000000000a), 0x1.01p+60, 0x1.4p+3 },
+{ UINT64_C(0x1010000000000020), 0x1.01p+60, 0x1p+5 },
+{ UINT64_C(0x1010000000000022), 0x1.01p+60, 0x1.1p+5 },
+{ UINT64_C(0x1010000000000024), 0x1.01p+60, 0x1.2p+5 },
+{ UINT64_C(0x1010000000000040), 0x1.01p+60, 0x1p+6 },
+{ UINT64_C(0x1010000000000041), 0x1.01p+60, 0x1.04p+6 },
+{ UINT64_C(0x1010000000000044), 0x1.01p+60, 0x1.1p+6 },
+{ UINT64_C(0x1010000000000080), 0x1.01p+60, 0x1p+7 },
+{ UINT64_C(0x1010000000000088), 0x1.0100000000001p+60, -0x1.ep+6 },
+{ UINT64_C(0x1010000000000090), 0x1.0100000000001p+60, -0x1.cp+6 },
+{ UINT64_C(0x1010000000000800), 0x1.0100000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000000801), 0x1.0100000000008p+60, 0x1p+0 },
+{ UINT64_C(0x1010000000000802), 0x1.0100000000008p+60, 0x1p+1 },
+{ UINT64_C(0x1010000000000810), 0x1.0100000000008p+60, 0x1p+4 },
+{ UINT64_C(0x1010000000000820), 0x1.0100000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1010000000000a00), 0x1.010000000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1010000000000c00), 0x1.010000000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1010000000004000), 0x1.010000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000004001), 0x1.010000000004p+60, 0x1p+0 },
+{ UINT64_C(0x1010000000004010), 0x1.010000000004p+60, 0x1p+4 },
+{ UINT64_C(0x1010000000004020), 0x1.010000000004p+60, 0x1p+5 },
+{ UINT64_C(0x1010000000004080), 0x1.010000000004p+60, 0x1p+7 },
+{ UINT64_C(0x1010000000004200), 0x1.0100000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000005000), 0x1.010000000005p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000040000), 0x1.01000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000040008), 0x1.01000000004p+60, 0x1p+3 },
+{ UINT64_C(0x1010000000040010), 0x1.01000000004p+60, 0x1p+4 },
+{ UINT64_C(0x1010000000040100), 0x1.0100000000401p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000040400), 0x1.0100000000404p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000042000), 0x1.010000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000060000), 0x1.01000000006p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000200000), 0x1.0100000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000200004), 0x1.0100000002p+60, 0x1p+2 },
+{ UINT64_C(0x1010000000200040), 0x1.0100000002p+60, 0x1p+6 },
+{ UINT64_C(0x1010000000200100), 0x1.0100000002001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000200400), 0x1.0100000002004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000204000), 0x1.010000000204p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000208000), 0x1.010000000208p+60, 0x0p+0 },
+{ UINT64_C(0x1010000000280000), 0x1.01000000028p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001000000), 0x1.010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001000008), 0x1.010000001p+60, 0x1p+3 },
+{ UINT64_C(0x1010000001000080), 0x1.010000001p+60, 0x1p+7 },
+{ UINT64_C(0x1010000001000200), 0x1.0100000010002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001001000), 0x1.010000001001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001004000), 0x1.010000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001020000), 0x1.01000000102p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001200000), 0x1.0100000012p+60, 0x0p+0 },
+{ UINT64_C(0x1010000001800000), 0x1.0100000018p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002000000), 0x1.010000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002000008), 0x1.010000002p+60, 0x1p+3 },
+{ UINT64_C(0x1010000002000040), 0x1.010000002p+60, 0x1p+6 },
+{ UINT64_C(0x1010000002000200), 0x1.0100000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002000400), 0x1.0100000020004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002000800), 0x1.0100000020008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002004000), 0x1.010000002004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002040000), 0x1.01000000204p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002100000), 0x1.0100000021p+60, 0x0p+0 },
+{ UINT64_C(0x1010000002800000), 0x1.0100000028p+60, 0x0p+0 },
+{ UINT64_C(0x1010000003000000), 0x1.010000003p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008000000), 0x1.010000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008000004), 0x1.010000008p+60, 0x1p+2 },
+{ UINT64_C(0x1010000008000020), 0x1.010000008p+60, 0x1p+5 },
+{ UINT64_C(0x1010000008000080), 0x1.010000008p+60, 0x1p+7 },
+{ UINT64_C(0x1010000008000200), 0x1.0100000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008001000), 0x1.010000008001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008010000), 0x1.01000000801p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008040000), 0x1.01000000804p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008200000), 0x1.0100000082p+60, 0x0p+0 },
+{ UINT64_C(0x1010000008800000), 0x1.0100000088p+60, 0x0p+0 },
+{ UINT64_C(0x1010000009000000), 0x1.010000009p+60, 0x0p+0 },
+{ UINT64_C(0x101000000a000000), 0x1.01000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1010000020000000), 0x1.01000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000020000004), 0x1.01000002p+60, 0x1p+2 },
+{ UINT64_C(0x1010000020000040), 0x1.01000002p+60, 0x1p+6 },
+{ UINT64_C(0x1010000020000200), 0x1.0100000200002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000020002000), 0x1.010000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000020004000), 0x1.010000020004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000020010000), 0x1.01000002001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000020080000), 0x1.01000002008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000020400000), 0x1.0100000204p+60, 0x0p+0 },
+{ UINT64_C(0x1010000022000000), 0x1.010000022p+60, 0x0p+0 },
+{ UINT64_C(0x1010000030000000), 0x1.01000003p+60, 0x0p+0 },
+{ UINT64_C(0x1010000040000000), 0x1.01000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000040000008), 0x1.01000004p+60, 0x1p+3 },
+{ UINT64_C(0x1010000040000080), 0x1.01000004p+60, 0x1p+7 },
+{ UINT64_C(0x1010000040000200), 0x1.0100000400002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000040001000), 0x1.010000040001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000040004000), 0x1.010000040004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000040040000), 0x1.01000004004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000040200000), 0x1.0100000402p+60, 0x0p+0 },
+{ UINT64_C(0x1010000041000000), 0x1.010000041p+60, 0x0p+0 },
+{ UINT64_C(0x1010000044000000), 0x1.010000044p+60, 0x0p+0 },
+{ UINT64_C(0x1010000060000000), 0x1.01000006p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400000000), 0x1.0100004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400000008), 0x1.0100004p+60, 0x1p+3 },
+{ UINT64_C(0x1010000400000040), 0x1.0100004p+60, 0x1p+6 },
+{ UINT64_C(0x1010000400000080), 0x1.0100004p+60, 0x1p+7 },
+{ UINT64_C(0x1010000400000200), 0x1.0100004000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400000400), 0x1.0100004000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400002000), 0x1.010000400002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400010000), 0x1.01000040001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400080000), 0x1.01000040008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400400000), 0x1.0100004004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000400800000), 0x1.0100004008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000408000000), 0x1.010000408p+60, 0x0p+0 },
+{ UINT64_C(0x1010000410000000), 0x1.01000041p+60, 0x0p+0 },
+{ UINT64_C(0x1010000440000000), 0x1.01000044p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800000000), 0x1.0100008p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800000004), 0x1.0100008p+60, 0x1p+2 },
+{ UINT64_C(0x1010000800000008), 0x1.0100008p+60, 0x1p+3 },
+{ UINT64_C(0x1010000800000020), 0x1.0100008p+60, 0x1p+5 },
+{ UINT64_C(0x1010000800000040), 0x1.0100008p+60, 0x1p+6 },
+{ UINT64_C(0x1010000800000400), 0x1.0100008000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800002000), 0x1.010000800002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800004000), 0x1.010000800004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800020000), 0x1.01000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800100000), 0x1.0100008001p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800200000), 0x1.0100008002p+60, 0x0p+0 },
+{ UINT64_C(0x1010000800400000), 0x1.0100008004p+60, 0x0p+0 },
+{ UINT64_C(0x1010000804000000), 0x1.010000804p+60, 0x0p+0 },
+{ UINT64_C(0x1010000820000000), 0x1.01000082p+60, 0x0p+0 },
+{ UINT64_C(0x1010000900000000), 0x1.0100009p+60, 0x0p+0 },
+{ UINT64_C(0x1010000a00000000), 0x1.010000ap+60, 0x0p+0 },
+{ UINT64_C(0x1010008000000000), 0x1.010008p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000000001), 0x1.010008p+60, 0x1p+0 },
+{ UINT64_C(0x1010008000000008), 0x1.010008p+60, 0x1p+3 },
+{ UINT64_C(0x1010008000000010), 0x1.010008p+60, 0x1p+4 },
+{ UINT64_C(0x1010008000000040), 0x1.010008p+60, 0x1p+6 },
+{ UINT64_C(0x1010008000000100), 0x1.0100080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000000400), 0x1.0100080000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000002000), 0x1.010008000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000020000), 0x1.01000800002p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000100000), 0x1.0100080001p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000200000), 0x1.0100080002p+60, 0x0p+0 },
+{ UINT64_C(0x1010008000400000), 0x1.0100080004p+60, 0x0p+0 },
+{ UINT64_C(0x1010008001000000), 0x1.010008001p+60, 0x0p+0 },
+{ UINT64_C(0x1010008008000000), 0x1.010008008p+60, 0x0p+0 },
+{ UINT64_C(0x1010008010000000), 0x1.01000801p+60, 0x0p+0 },
+{ UINT64_C(0x1010008080000000), 0x1.01000808p+60, 0x0p+0 },
+{ UINT64_C(0x1010008100000000), 0x1.0100081p+60, 0x0p+0 },
+{ UINT64_C(0x1010008800000000), 0x1.0100088p+60, 0x0p+0 },
+{ UINT64_C(0x101000c000000000), 0x1.01000cp+60, 0x0p+0 },
+{ UINT64_C(0x1010040000000000), 0x1.01004p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000000008), 0x1.01004p+60, 0x1p+3 },
+{ UINT64_C(0x1010040000000010), 0x1.01004p+60, 0x1p+4 },
+{ UINT64_C(0x1010040000000100), 0x1.0100400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000000800), 0x1.0100400000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000001000), 0x1.010040000001p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000002000), 0x1.010040000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000008000), 0x1.010040000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000040000), 0x1.01004000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000400000), 0x1.0100400004p+60, 0x0p+0 },
+{ UINT64_C(0x1010040000800000), 0x1.0100400008p+60, 0x0p+0 },
+{ UINT64_C(0x1010040008000000), 0x1.010040008p+60, 0x0p+0 },
+{ UINT64_C(0x1010040040000000), 0x1.01004004p+60, 0x0p+0 },
+{ UINT64_C(0x1010040400000000), 0x1.0100404p+60, 0x0p+0 },
+{ UINT64_C(0x1010041000000000), 0x1.010041p+60, 0x0p+0 },
+{ UINT64_C(0x1010042000000000), 0x1.010042p+60, 0x0p+0 },
+{ UINT64_C(0x1010060000000000), 0x1.01006p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000000000), 0x1.01008p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000000001), 0x1.01008p+60, 0x1p+0 },
+{ UINT64_C(0x1010080000000008), 0x1.01008p+60, 0x1p+3 },
+{ UINT64_C(0x1010080000000040), 0x1.01008p+60, 0x1p+6 },
+{ UINT64_C(0x1010080000000200), 0x1.0100800000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000000400), 0x1.0100800000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000000800), 0x1.0100800000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000008000), 0x1.010080000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000080000), 0x1.01008000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010080000800000), 0x1.0100800008p+60, 0x0p+0 },
+{ UINT64_C(0x1010080002000000), 0x1.010080002p+60, 0x0p+0 },
+{ UINT64_C(0x1010080020000000), 0x1.01008002p+60, 0x0p+0 },
+{ UINT64_C(0x1010080100000000), 0x1.0100801p+60, 0x0p+0 },
+{ UINT64_C(0x1010080400000000), 0x1.0100804p+60, 0x0p+0 },
+{ UINT64_C(0x1010080800000000), 0x1.0100808p+60, 0x0p+0 },
+{ UINT64_C(0x1010088000000000), 0x1.010088p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000000000), 0x1.0108p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000000004), 0x1.0108p+60, 0x1p+2 },
+{ UINT64_C(0x1010800000000010), 0x1.0108p+60, 0x1p+4 },
+{ UINT64_C(0x1010800000000100), 0x1.0108000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000000200), 0x1.0108000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000000400), 0x1.0108000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000004000), 0x1.010800000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000040000), 0x1.01080000004p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000080000), 0x1.01080000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000100000), 0x1.0108000001p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000200000), 0x1.0108000002p+60, 0x0p+0 },
+{ UINT64_C(0x1010800000800000), 0x1.0108000008p+60, 0x0p+0 },
+{ UINT64_C(0x1010800001000000), 0x1.010800001p+60, 0x0p+0 },
+{ UINT64_C(0x1010800010000000), 0x1.01080001p+60, 0x0p+0 },
+{ UINT64_C(0x1010800040000000), 0x1.01080004p+60, 0x0p+0 },
+{ UINT64_C(0x1010800100000000), 0x1.0108001p+60, 0x0p+0 },
+{ UINT64_C(0x1010800400000000), 0x1.0108004p+60, 0x0p+0 },
+{ UINT64_C(0x1010804000000000), 0x1.010804p+60, 0x0p+0 },
+{ UINT64_C(0x1010840000000000), 0x1.01084p+60, 0x0p+0 },
+{ UINT64_C(0x1010a00000000000), 0x1.010ap+60, 0x0p+0 },
+{ UINT64_C(0x1018000000000000), 0x1.018p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000000001), 0x1.018p+60, 0x1p+0 },
+{ UINT64_C(0x1018000000000008), 0x1.018p+60, 0x1p+3 },
+{ UINT64_C(0x1018000000000010), 0x1.018p+60, 0x1p+4 },
+{ UINT64_C(0x1018000000000100), 0x1.0180000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000000400), 0x1.0180000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000001000), 0x1.018000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000004000), 0x1.018000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000008000), 0x1.018000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000010000), 0x1.01800000001p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000080000), 0x1.01800000008p+60, 0x0p+0 },
+{ UINT64_C(0x1018000000200000), 0x1.0180000002p+60, 0x0p+0 },
+{ UINT64_C(0x1018000001000000), 0x1.018000001p+60, 0x0p+0 },
+{ UINT64_C(0x1018000002000000), 0x1.018000002p+60, 0x0p+0 },
+{ UINT64_C(0x1018000020000000), 0x1.01800002p+60, 0x0p+0 },
+{ UINT64_C(0x1018000100000000), 0x1.0180001p+60, 0x0p+0 },
+{ UINT64_C(0x1018000400000000), 0x1.0180004p+60, 0x0p+0 },
+{ UINT64_C(0x1018000800000000), 0x1.0180008p+60, 0x0p+0 },
+{ UINT64_C(0x1018008000000000), 0x1.018008p+60, 0x0p+0 },
+{ UINT64_C(0x1018020000000000), 0x1.01802p+60, 0x0p+0 },
+{ UINT64_C(0x1018040000000000), 0x1.01804p+60, 0x0p+0 },
+{ UINT64_C(0x1018080000000000), 0x1.01808p+60, 0x0p+0 },
+{ UINT64_C(0x1018400000000000), 0x1.0184p+60, 0x0p+0 },
+{ UINT64_C(0x1019000000000000), 0x1.019p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000000001), 0x1.02p+60, 0x1p+0 },
+{ UINT64_C(0x1020000000000010), 0x1.02p+60, 0x1p+4 },
+{ UINT64_C(0x1020000000000012), 0x1.02p+60, 0x1.2p+4 },
+{ UINT64_C(0x1020000000000100), 0x1.0200000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000000102), 0x1.0200000000001p+60, 0x1p+1 },
+{ UINT64_C(0x1020000000000108), 0x1.0200000000001p+60, 0x1p+3 },
+{ UINT64_C(0x1020000000000180), 0x1.0200000000002p+60, -0x1p+7 },
+{ UINT64_C(0x1020000000000800), 0x1.0200000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000000804), 0x1.0200000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1020000000000820), 0x1.0200000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1020000000000840), 0x1.0200000000008p+60, 0x1p+6 },
+{ UINT64_C(0x1020000000000900), 0x1.0200000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000000c00), 0x1.020000000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1020000000008000), 0x1.020000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000008002), 0x1.020000000008p+60, 0x1p+1 },
+{ UINT64_C(0x1020000000008010), 0x1.020000000008p+60, 0x1p+4 },
+{ UINT64_C(0x1020000000008040), 0x1.020000000008p+60, 0x1p+6 },
+{ UINT64_C(0x1020000000008080), 0x1.020000000008p+60, 0x1p+7 },
+{ UINT64_C(0x1020000000008200), 0x1.0200000000082p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000008400), 0x1.0200000000084p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000009000), 0x1.020000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000080000), 0x1.02000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000080004), 0x1.02000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1020000000080020), 0x1.02000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1020000000080200), 0x1.0200000000802p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000081000), 0x1.020000000081p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000088000), 0x1.020000000088p+60, 0x0p+0 },
+{ UINT64_C(0x10200000000c0000), 0x1.0200000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1020000000400000), 0x1.0200000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000400002), 0x1.0200000004p+60, 0x1p+1 },
+{ UINT64_C(0x1020000000400004), 0x1.0200000004p+60, 0x1p+2 },
+{ UINT64_C(0x1020000000400020), 0x1.0200000004p+60, 0x1p+5 },
+{ UINT64_C(0x1020000000400080), 0x1.0200000004p+60, 0x1p+7 },
+{ UINT64_C(0x1020000000400400), 0x1.0200000004004p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000402000), 0x1.020000000402p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000410000), 0x1.02000000041p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000480000), 0x1.02000000048p+60, 0x0p+0 },
+{ UINT64_C(0x1020000000600000), 0x1.0200000006p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001000000), 0x1.020000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001000004), 0x1.020000001p+60, 0x1p+2 },
+{ UINT64_C(0x1020000001000008), 0x1.020000001p+60, 0x1p+3 },
+{ UINT64_C(0x1020000001000010), 0x1.020000001p+60, 0x1p+4 },
+{ UINT64_C(0x1020000001000080), 0x1.020000001p+60, 0x1p+7 },
+{ UINT64_C(0x1020000001000100), 0x1.0200000010001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001001000), 0x1.020000001001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001008000), 0x1.020000001008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001040000), 0x1.02000000104p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001200000), 0x1.0200000012p+60, 0x0p+0 },
+{ UINT64_C(0x1020000001800000), 0x1.0200000018p+60, 0x0p+0 },
+{ UINT64_C(0x1020000008000000), 0x1.020000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000008000002), 0x1.020000008p+60, 0x1p+1 },
+{ UINT64_C(0x1020000008000020), 0x1.020000008p+60, 0x1p+5 },
+{ UINT64_C(0x1020000008000080), 0x1.020000008p+60, 0x1p+7 },
+{ UINT64_C(0x1020000008000400), 0x1.0200000080004p+60, 0x0p+0 },
+{ UINT64_C(0x1020000008004000), 0x1.020000008004p+60, 0x0p+0 },
+{ UINT64_C(0x1020000008020000), 0x1.02000000802p+60, 0x0p+0 },
+{ UINT64_C(0x1020000008080000), 0x1.02000000808p+60, 0x0p+0 },
+{ UINT64_C(0x1020000008400000), 0x1.0200000084p+60, 0x0p+0 },
+{ UINT64_C(0x102000000c000000), 0x1.02000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1020000080000000), 0x1.02000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080000002), 0x1.02000008p+60, 0x1p+1 },
+{ UINT64_C(0x1020000080000010), 0x1.02000008p+60, 0x1p+4 },
+{ UINT64_C(0x1020000080000080), 0x1.02000008p+60, 0x1p+7 },
+{ UINT64_C(0x1020000080000100), 0x1.0200000800001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080000200), 0x1.0200000800002p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080001000), 0x1.020000080001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080002000), 0x1.020000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080020000), 0x1.02000008002p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080080000), 0x1.02000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000080400000), 0x1.0200000804p+60, 0x0p+0 },
+{ UINT64_C(0x1020000082000000), 0x1.020000082p+60, 0x0p+0 },
+{ UINT64_C(0x1020000088000000), 0x1.020000088p+60, 0x0p+0 },
+{ UINT64_C(0x1020000090000000), 0x1.02000009p+60, 0x0p+0 },
+{ UINT64_C(0x10200000c0000000), 0x1.0200000cp+60, 0x0p+0 },
+{ UINT64_C(0x1020000200000000), 0x1.0200002p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200000008), 0x1.0200002p+60, 0x1p+3 },
+{ UINT64_C(0x1020000200000020), 0x1.0200002p+60, 0x1p+5 },
+{ UINT64_C(0x1020000200000200), 0x1.0200002000002p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200000800), 0x1.0200002000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200001000), 0x1.020000200001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200008000), 0x1.020000200008p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200010000), 0x1.02000020001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200020000), 0x1.02000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200040000), 0x1.02000020004p+60, 0x0p+0 },
+{ UINT64_C(0x1020000200100000), 0x1.0200002001p+60, 0x0p+0 },
+{ UINT64_C(0x1020000201000000), 0x1.020000201p+60, 0x0p+0 },
+{ UINT64_C(0x1020000202000000), 0x1.020000202p+60, 0x0p+0 },
+{ UINT64_C(0x1020000220000000), 0x1.02000022p+60, 0x0p+0 },
+{ UINT64_C(0x1020000240000000), 0x1.02000024p+60, 0x0p+0 },
+{ UINT64_C(0x1020002000000000), 0x1.020002p+60, 0x0p+0 },
+{ UINT64_C(0x1020002000000001), 0x1.020002p+60, 0x1p+0 },
+{ UINT64_C(0x1020002000000004), 0x1.020002p+60, 0x1p+2 },
+{ UINT64_C(0x1020002000000010), 0x1.020002p+60, 0x1p+4 },
+{ UINT64_C(0x1020002000000080), 0x1.020002p+60, 0x1p+7 },
+{ UINT64_C(0x1020002000000100), 0x1.0200020000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020002000000400), 0x1.0200020000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020002000004000), 0x1.020002000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020002000020000), 0x1.02000200002p+60, 0x0p+0 },
+{ UINT64_C(0x1020002000200000), 0x1.0200020002p+60, 0x0p+0 },
+{ UINT64_C(0x1020002001000000), 0x1.020002001p+60, 0x0p+0 },
+{ UINT64_C(0x1020002010000000), 0x1.02000201p+60, 0x0p+0 },
+{ UINT64_C(0x1020002020000000), 0x1.02000202p+60, 0x0p+0 },
+{ UINT64_C(0x1020002100000000), 0x1.0200021p+60, 0x0p+0 },
+{ UINT64_C(0x1020002200000000), 0x1.0200022p+60, 0x0p+0 },
+{ UINT64_C(0x1020003000000000), 0x1.020003p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000000000), 0x1.020008p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000000008), 0x1.020008p+60, 0x1p+3 },
+{ UINT64_C(0x1020008000000020), 0x1.020008p+60, 0x1p+5 },
+{ UINT64_C(0x1020008000000080), 0x1.020008p+60, 0x1p+7 },
+{ UINT64_C(0x1020008000000400), 0x1.0200080000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000004000), 0x1.020008000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000010000), 0x1.02000800001p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000040000), 0x1.02000800004p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000100000), 0x1.0200080001p+60, 0x0p+0 },
+{ UINT64_C(0x1020008000400000), 0x1.0200080004p+60, 0x0p+0 },
+{ UINT64_C(0x1020008004000000), 0x1.020008004p+60, 0x0p+0 },
+{ UINT64_C(0x1020008010000000), 0x1.02000801p+60, 0x0p+0 },
+{ UINT64_C(0x1020008020000000), 0x1.02000802p+60, 0x0p+0 },
+{ UINT64_C(0x1020008200000000), 0x1.0200082p+60, 0x0p+0 },
+{ UINT64_C(0x1020008400000000), 0x1.0200084p+60, 0x0p+0 },
+{ UINT64_C(0x102000a000000000), 0x1.02000ap+60, 0x0p+0 },
+{ UINT64_C(0x102000c000000000), 0x1.02000cp+60, 0x0p+0 },
+{ UINT64_C(0x1020040000000000), 0x1.02004p+60, 0x0p+0 },
+{ UINT64_C(0x1020040000000008), 0x1.02004p+60, 0x1p+3 },
+{ UINT64_C(0x1020040000000040), 0x1.02004p+60, 0x1p+6 },
+{ UINT64_C(0x1020040000000080), 0x1.02004p+60, 0x1p+7 },
+{ UINT64_C(0x1020040000000100), 0x1.0200400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020040000001000), 0x1.020040000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020040000004000), 0x1.020040000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020040000040000), 0x1.02004000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020040000400000), 0x1.0200400004p+60, 0x0p+0 },
+{ UINT64_C(0x1020040000800000), 0x1.0200400008p+60, 0x0p+0 },
+{ UINT64_C(0x1020040008000000), 0x1.020040008p+60, 0x0p+0 },
+{ UINT64_C(0x1020040080000000), 0x1.02004008p+60, 0x0p+0 },
+{ UINT64_C(0x1020040100000000), 0x1.0200401p+60, 0x0p+0 },
+{ UINT64_C(0x1020040400000000), 0x1.0200404p+60, 0x0p+0 },
+{ UINT64_C(0x1020040800000000), 0x1.0200408p+60, 0x0p+0 },
+{ UINT64_C(0x1020048000000000), 0x1.020048p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000000000), 0x1.02008p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000000008), 0x1.02008p+60, 0x1p+3 },
+{ UINT64_C(0x1020080000000040), 0x1.02008p+60, 0x1p+6 },
+{ UINT64_C(0x1020080000000100), 0x1.0200800000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000000400), 0x1.0200800000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000001000), 0x1.020080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000008000), 0x1.020080000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000040000), 0x1.02008000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000200000), 0x1.0200800002p+60, 0x0p+0 },
+{ UINT64_C(0x1020080000800000), 0x1.0200800008p+60, 0x0p+0 },
+{ UINT64_C(0x1020080002000000), 0x1.020080002p+60, 0x0p+0 },
+{ UINT64_C(0x1020080010000000), 0x1.02008001p+60, 0x0p+0 },
+{ UINT64_C(0x1020080100000000), 0x1.0200801p+60, 0x0p+0 },
+{ UINT64_C(0x1020080200000000), 0x1.0200802p+60, 0x0p+0 },
+{ UINT64_C(0x1020080800000000), 0x1.0200808p+60, 0x0p+0 },
+{ UINT64_C(0x1020081000000000), 0x1.020081p+60, 0x0p+0 },
+{ UINT64_C(0x1020082000000000), 0x1.020082p+60, 0x0p+0 },
+{ UINT64_C(0x1020084000000000), 0x1.020084p+60, 0x0p+0 },
+{ UINT64_C(0x1020088000000000), 0x1.020088p+60, 0x0p+0 },
+{ UINT64_C(0x10200a0000000000), 0x1.0200ap+60, 0x0p+0 },
+{ UINT64_C(0x1020100000000000), 0x1.0201p+60, 0x0p+0 },
+{ UINT64_C(0x1020100000000004), 0x1.0201p+60, 0x1p+2 },
+{ UINT64_C(0x1020100000000008), 0x1.0201p+60, 0x1p+3 },
+{ UINT64_C(0x1020100000000020), 0x1.0201p+60, 0x1p+5 },
+{ UINT64_C(0x1020100000000200), 0x1.0201000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1020100000000800), 0x1.0201000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020100000001000), 0x1.020100000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020100000010000), 0x1.02010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020100000100000), 0x1.0201000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020100000200000), 0x1.0201000002p+60, 0x0p+0 },
+{ UINT64_C(0x1020100002000000), 0x1.020100002p+60, 0x0p+0 },
+{ UINT64_C(0x1020100004000000), 0x1.020100004p+60, 0x0p+0 },
+{ UINT64_C(0x1020100020000000), 0x1.02010002p+60, 0x0p+0 },
+{ UINT64_C(0x1020100040000000), 0x1.02010004p+60, 0x0p+0 },
+{ UINT64_C(0x1020100100000000), 0x1.0201001p+60, 0x0p+0 },
+{ UINT64_C(0x1020101000000000), 0x1.020101p+60, 0x0p+0 },
+{ UINT64_C(0x1020108000000000), 0x1.020108p+60, 0x0p+0 },
+{ UINT64_C(0x1020180000000000), 0x1.02018p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000000000), 0x1.0202p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000000001), 0x1.0202p+60, 0x1p+0 },
+{ UINT64_C(0x1020200000000004), 0x1.0202p+60, 0x1p+2 },
+{ UINT64_C(0x1020200000000008), 0x1.0202p+60, 0x1p+3 },
+{ UINT64_C(0x1020200000000040), 0x1.0202p+60, 0x1p+6 },
+{ UINT64_C(0x1020200000000100), 0x1.0202000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000000200), 0x1.0202000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000002000), 0x1.020200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000004000), 0x1.020200000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000040000), 0x1.02020000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000100000), 0x1.0202000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020200000800000), 0x1.0202000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020200001000000), 0x1.020200001p+60, 0x0p+0 },
+{ UINT64_C(0x1020200008000000), 0x1.020200008p+60, 0x0p+0 },
+{ UINT64_C(0x1020200040000000), 0x1.02020004p+60, 0x0p+0 },
+{ UINT64_C(0x1020200100000000), 0x1.0202001p+60, 0x0p+0 },
+{ UINT64_C(0x1020200200000000), 0x1.0202002p+60, 0x0p+0 },
+{ UINT64_C(0x1020200800000000), 0x1.0202008p+60, 0x0p+0 },
+{ UINT64_C(0x1020208000000000), 0x1.020208p+60, 0x0p+0 },
+{ UINT64_C(0x1020280000000000), 0x1.02028p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000000000), 0x1.0208p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000000008), 0x1.0208p+60, 0x1p+3 },
+{ UINT64_C(0x1020800000000040), 0x1.0208p+60, 0x1p+6 },
+{ UINT64_C(0x1020800000000100), 0x1.0208000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000000400), 0x1.0208000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000001000), 0x1.020800000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000002000), 0x1.020800000002p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000004000), 0x1.020800000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000010000), 0x1.02080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000040000), 0x1.02080000004p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000100000), 0x1.0208000001p+60, 0x0p+0 },
+{ UINT64_C(0x1020800000800000), 0x1.0208000008p+60, 0x0p+0 },
+{ UINT64_C(0x1020800008000000), 0x1.020800008p+60, 0x0p+0 },
+{ UINT64_C(0x1020800010000000), 0x1.02080001p+60, 0x0p+0 },
+{ UINT64_C(0x1020800020000000), 0x1.02080002p+60, 0x0p+0 },
+{ UINT64_C(0x1020800100000000), 0x1.0208001p+60, 0x0p+0 },
+{ UINT64_C(0x1020800800000000), 0x1.0208008p+60, 0x0p+0 },
+{ UINT64_C(0x1020804000000000), 0x1.020804p+60, 0x0p+0 },
+{ UINT64_C(0x1020810000000000), 0x1.02081p+60, 0x0p+0 },
+{ UINT64_C(0x1020820000000000), 0x1.02082p+60, 0x0p+0 },
+{ UINT64_C(0x1020a00000000000), 0x1.020ap+60, 0x0p+0 },
+{ UINT64_C(0x1024000000000000), 0x1.024p+60, 0x0p+0 },
+{ UINT64_C(0x1024000000000004), 0x1.024p+60, 0x1p+2 },
+{ UINT64_C(0x1024000000000020), 0x1.024p+60, 0x1p+5 },
+{ UINT64_C(0x1024000000000080), 0x1.024p+60, 0x1p+7 },
+{ UINT64_C(0x1024000000000400), 0x1.0240000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1024000000002000), 0x1.024000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1024000000010000), 0x1.02400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1024000000040000), 0x1.02400000004p+60, 0x0p+0 },
+{ UINT64_C(0x1024000000400000), 0x1.0240000004p+60, 0x0p+0 },
+{ UINT64_C(0x1024000001000000), 0x1.024000001p+60, 0x0p+0 },
+{ UINT64_C(0x1024000008000000), 0x1.024000008p+60, 0x0p+0 },
+{ UINT64_C(0x1024000080000000), 0x1.02400008p+60, 0x0p+0 },
+{ UINT64_C(0x1024000800000000), 0x1.0240008p+60, 0x0p+0 },
+{ UINT64_C(0x1024008000000000), 0x1.024008p+60, 0x0p+0 },
+{ UINT64_C(0x1024020000000000), 0x1.02402p+60, 0x0p+0 },
+{ UINT64_C(0x1024100000000000), 0x1.0241p+60, 0x0p+0 },
+{ UINT64_C(0x1024400000000000), 0x1.0244p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000000008), 0x1.1p+60, 0x1p+3 },
+{ UINT64_C(0x110000000000000c), 0x1.1p+60, 0x1.8p+3 },
+{ UINT64_C(0x1100000000000020), 0x1.1p+60, 0x1p+5 },
+{ UINT64_C(0x1100000000000024), 0x1.1p+60, 0x1.2p+5 },
+{ UINT64_C(0x1100000000000028), 0x1.1p+60, 0x1.4p+5 },
+{ UINT64_C(0x1100000000000100), 0x1.1000000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000000104), 0x1.1000000000001p+60, 0x1p+2 },
+{ UINT64_C(0x1100000000000140), 0x1.1000000000001p+60, 0x1p+6 },
+{ UINT64_C(0x1100000000000180), 0x1.1000000000002p+60, -0x1p+7 },
+{ UINT64_C(0x1100000000000200), 0x1.1000000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000000204), 0x1.1000000000002p+60, 0x1p+2 },
+{ UINT64_C(0x1100000000000220), 0x1.1000000000002p+60, 0x1p+5 },
+{ UINT64_C(0x1100000000000280), 0x1.1000000000002p+60, 0x1p+7 },
+{ UINT64_C(0x1100000000000800), 0x1.1000000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000000801), 0x1.1000000000008p+60, 0x1p+0 },
+{ UINT64_C(0x1100000000000810), 0x1.1000000000008p+60, 0x1p+4 },
+{ UINT64_C(0x1100000000000820), 0x1.1000000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1100000000000880), 0x1.1000000000008p+60, 0x1p+7 },
+{ UINT64_C(0x1100000000000900), 0x1.1000000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000001000), 0x1.100000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000001001), 0x1.100000000001p+60, 0x1p+0 },
+{ UINT64_C(0x1100000000001004), 0x1.100000000001p+60, 0x1p+2 },
+{ UINT64_C(0x1100000000001020), 0x1.100000000001p+60, 0x1p+5 },
+{ UINT64_C(0x1100000000001080), 0x1.100000000001p+60, 0x1p+7 },
+{ UINT64_C(0x1100000000001800), 0x1.1000000000018p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000002000), 0x1.100000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000002002), 0x1.100000000002p+60, 0x1p+1 },
+{ UINT64_C(0x1100000000002008), 0x1.100000000002p+60, 0x1p+3 },
+{ UINT64_C(0x1100000000002040), 0x1.100000000002p+60, 0x1p+6 },
+{ UINT64_C(0x1100000000002200), 0x1.1000000000022p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000002400), 0x1.1000000000024p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000002800), 0x1.1000000000028p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000020000), 0x1.10000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000020004), 0x1.10000000002p+60, 0x1p+2 },
+{ UINT64_C(0x1100000000020008), 0x1.10000000002p+60, 0x1p+3 },
+{ UINT64_C(0x1100000000020040), 0x1.10000000002p+60, 0x1p+6 },
+{ UINT64_C(0x1100000000020200), 0x1.1000000000202p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000020400), 0x1.1000000000204p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000022000), 0x1.100000000022p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000100000), 0x1.1000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000100001), 0x1.1000000001p+60, 0x1p+0 },
+{ UINT64_C(0x1100000000100010), 0x1.1000000001p+60, 0x1p+4 },
+{ UINT64_C(0x1100000000100020), 0x1.1000000001p+60, 0x1p+5 },
+{ UINT64_C(0x1100000000100200), 0x1.1000000001002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000102000), 0x1.100000000102p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000120000), 0x1.10000000012p+60, 0x0p+0 },
+{ UINT64_C(0x1100000000180000), 0x1.10000000018p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001000000), 0x1.100000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001000004), 0x1.100000001p+60, 0x1p+2 },
+{ UINT64_C(0x1100000001000040), 0x1.100000001p+60, 0x1p+6 },
+{ UINT64_C(0x1100000001000200), 0x1.1000000010002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001002000), 0x1.100000001002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001004000), 0x1.100000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001010000), 0x1.10000000101p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001080000), 0x1.10000000108p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001200000), 0x1.1000000012p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001400000), 0x1.1000000014p+60, 0x0p+0 },
+{ UINT64_C(0x1100000001800000), 0x1.1000000018p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010000000), 0x1.10000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010000001), 0x1.10000001p+60, 0x1p+0 },
+{ UINT64_C(0x1100000010000004), 0x1.10000001p+60, 0x1p+2 },
+{ UINT64_C(0x1100000010000020), 0x1.10000001p+60, 0x1p+5 },
+{ UINT64_C(0x1100000010000200), 0x1.1000000100002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010000400), 0x1.1000000100004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010002000), 0x1.100000010002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010010000), 0x1.10000001001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010020000), 0x1.10000001002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010080000), 0x1.10000001008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000010800000), 0x1.1000000108p+60, 0x0p+0 },
+{ UINT64_C(0x1100000012000000), 0x1.100000012p+60, 0x0p+0 },
+{ UINT64_C(0x1100000020000000), 0x1.10000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000020000002), 0x1.10000002p+60, 0x1p+1 },
+{ UINT64_C(0x1100000020000004), 0x1.10000002p+60, 0x1p+2 },
+{ UINT64_C(0x1100000020000020), 0x1.10000002p+60, 0x1p+5 },
+{ UINT64_C(0x1100000020000040), 0x1.10000002p+60, 0x1p+6 },
+{ UINT64_C(0x1100000020000400), 0x1.1000000200004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000020002000), 0x1.100000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000020008000), 0x1.100000020008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000020080000), 0x1.10000002008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000020100000), 0x1.1000000201p+60, 0x0p+0 },
+{ UINT64_C(0x1100000021000000), 0x1.100000021p+60, 0x0p+0 },
+{ UINT64_C(0x1100000030000000), 0x1.10000003p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080000000), 0x1.10000008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080000002), 0x1.10000008p+60, 0x1p+1 },
+{ UINT64_C(0x1100000080000004), 0x1.10000008p+60, 0x1p+2 },
+{ UINT64_C(0x1100000080000010), 0x1.10000008p+60, 0x1p+4 },
+{ UINT64_C(0x1100000080000040), 0x1.10000008p+60, 0x1p+6 },
+{ UINT64_C(0x1100000080000200), 0x1.1000000800002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080001000), 0x1.100000080001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080010000), 0x1.10000008001p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080040000), 0x1.10000008004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080080000), 0x1.10000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080100000), 0x1.1000000801p+60, 0x0p+0 },
+{ UINT64_C(0x1100000080800000), 0x1.1000000808p+60, 0x0p+0 },
+{ UINT64_C(0x1100000081000000), 0x1.100000081p+60, 0x0p+0 },
+{ UINT64_C(0x1100000082000000), 0x1.100000082p+60, 0x0p+0 },
+{ UINT64_C(0x1100000084000000), 0x1.100000084p+60, 0x0p+0 },
+{ UINT64_C(0x1100000090000000), 0x1.10000009p+60, 0x0p+0 },
+{ UINT64_C(0x11000000a0000000), 0x1.1000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1100000200000000), 0x1.1000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200000008), 0x1.1000002p+60, 0x1p+3 },
+{ UINT64_C(0x1100000200000080), 0x1.1000002p+60, 0x1p+7 },
+{ UINT64_C(0x1100000200000400), 0x1.1000002000004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200002000), 0x1.100000200002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200004000), 0x1.100000200004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200040000), 0x1.10000020004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200080000), 0x1.10000020008p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200200000), 0x1.1000002002p+60, 0x0p+0 },
+{ UINT64_C(0x1100000200400000), 0x1.1000002004p+60, 0x0p+0 },
+{ UINT64_C(0x1100000204000000), 0x1.100000204p+60, 0x0p+0 },
+{ UINT64_C(0x1100000240000000), 0x1.10000024p+60, 0x0p+0 },
+{ UINT64_C(0x1100000300000000), 0x1.1000003p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000000000), 0x1.100001p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000000002), 0x1.100001p+60, 0x1p+1 },
+{ UINT64_C(0x1100001000000004), 0x1.100001p+60, 0x1p+2 },
+{ UINT64_C(0x1100001000000010), 0x1.100001p+60, 0x1p+4 },
+{ UINT64_C(0x1100001000000020), 0x1.100001p+60, 0x1p+5 },
+{ UINT64_C(0x1100001000000100), 0x1.1000010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000000400), 0x1.1000010000004p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000000800), 0x1.1000010000008p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000002000), 0x1.100001000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000004000), 0x1.100001000004p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000040000), 0x1.10000100004p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000100000), 0x1.1000010001p+60, 0x0p+0 },
+{ UINT64_C(0x1100001000400000), 0x1.1000010004p+60, 0x0p+0 },
+{ UINT64_C(0x1100001004000000), 0x1.100001004p+60, 0x0p+0 },
+{ UINT64_C(0x1100001020000000), 0x1.10000102p+60, 0x0p+0 },
+{ UINT64_C(0x1100001200000000), 0x1.1000012p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000000000), 0x1.10001p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000000002), 0x1.10001p+60, 0x1p+1 },
+{ UINT64_C(0x1100010000000020), 0x1.10001p+60, 0x1p+5 },
+{ UINT64_C(0x1100010000000040), 0x1.10001p+60, 0x1p+6 },
+{ UINT64_C(0x1100010000000200), 0x1.1000100000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000001000), 0x1.100010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000002000), 0x1.100010000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000020000), 0x1.10001000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000200000), 0x1.1000100002p+60, 0x0p+0 },
+{ UINT64_C(0x1100010000800000), 0x1.1000100008p+60, 0x0p+0 },
+{ UINT64_C(0x1100010008000000), 0x1.100010008p+60, 0x0p+0 },
+{ UINT64_C(0x1100010080000000), 0x1.10001008p+60, 0x0p+0 },
+{ UINT64_C(0x1100010400000000), 0x1.1000104p+60, 0x0p+0 },
+{ UINT64_C(0x1100011000000000), 0x1.100011p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000000000), 0x1.10002p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000000004), 0x1.10002p+60, 0x1p+2 },
+{ UINT64_C(0x1100020000000008), 0x1.10002p+60, 0x1p+3 },
+{ UINT64_C(0x1100020000000010), 0x1.10002p+60, 0x1p+4 },
+{ UINT64_C(0x1100020000000020), 0x1.10002p+60, 0x1p+5 },
+{ UINT64_C(0x1100020000000080), 0x1.10002p+60, 0x1p+7 },
+{ UINT64_C(0x1100020000000100), 0x1.1000200000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000000400), 0x1.1000200000004p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000001000), 0x1.100020000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000002000), 0x1.100020000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000008000), 0x1.100020000008p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000010000), 0x1.10002000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000020000), 0x1.10002000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000200000), 0x1.1000200002p+60, 0x0p+0 },
+{ UINT64_C(0x1100020000800000), 0x1.1000200008p+60, 0x0p+0 },
+{ UINT64_C(0x1100020008000000), 0x1.100020008p+60, 0x0p+0 },
+{ UINT64_C(0x1100020080000000), 0x1.10002008p+60, 0x0p+0 },
+{ UINT64_C(0x1100020100000000), 0x1.1000201p+60, 0x0p+0 },
+{ UINT64_C(0x1100020400000000), 0x1.1000204p+60, 0x0p+0 },
+{ UINT64_C(0x1100021000000000), 0x1.100021p+60, 0x0p+0 },
+{ UINT64_C(0x1100028000000000), 0x1.100028p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000000000), 0x1.1001p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000000001), 0x1.1001p+60, 0x1p+0 },
+{ UINT64_C(0x1100100000000010), 0x1.1001p+60, 0x1p+4 },
+{ UINT64_C(0x1100100000000080), 0x1.1001p+60, 0x1p+7 },
+{ UINT64_C(0x1100100000000100), 0x1.1001000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000000400), 0x1.1001000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000002000), 0x1.100100000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000020000), 0x1.10010000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000100000), 0x1.1001000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100100000800000), 0x1.1001000008p+60, 0x0p+0 },
+{ UINT64_C(0x1100100004000000), 0x1.100100004p+60, 0x0p+0 },
+{ UINT64_C(0x1100100020000000), 0x1.10010002p+60, 0x0p+0 },
+{ UINT64_C(0x1100100200000000), 0x1.1001002p+60, 0x0p+0 },
+{ UINT64_C(0x1100100400000000), 0x1.1001004p+60, 0x0p+0 },
+{ UINT64_C(0x1100100800000000), 0x1.1001008p+60, 0x0p+0 },
+{ UINT64_C(0x1100102000000000), 0x1.100102p+60, 0x0p+0 },
+{ UINT64_C(0x1100110000000000), 0x1.10011p+60, 0x0p+0 },
+{ UINT64_C(0x1100140000000000), 0x1.10014p+60, 0x0p+0 },
+{ UINT64_C(0x1100180000000000), 0x1.10018p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000000000), 0x1.1004p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000000008), 0x1.1004p+60, 0x1p+3 },
+{ UINT64_C(0x1100400000000040), 0x1.1004p+60, 0x1p+6 },
+{ UINT64_C(0x1100400000000100), 0x1.1004000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000000200), 0x1.1004000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000002000), 0x1.100400000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000004000), 0x1.100400000004p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000020000), 0x1.10040000002p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000100000), 0x1.1004000001p+60, 0x0p+0 },
+{ UINT64_C(0x1100400000800000), 0x1.1004000008p+60, 0x0p+0 },
+{ UINT64_C(0x1100400001000000), 0x1.100400001p+60, 0x0p+0 },
+{ UINT64_C(0x1100400010000000), 0x1.10040001p+60, 0x0p+0 },
+{ UINT64_C(0x1100400100000000), 0x1.1004001p+60, 0x0p+0 },
+{ UINT64_C(0x1100400400000000), 0x1.1004004p+60, 0x0p+0 },
+{ UINT64_C(0x1100401000000000), 0x1.100401p+60, 0x0p+0 },
+{ UINT64_C(0x1100402000000000), 0x1.100402p+60, 0x0p+0 },
+{ UINT64_C(0x1100404000000000), 0x1.100404p+60, 0x0p+0 },
+{ UINT64_C(0x1100440000000000), 0x1.10044p+60, 0x0p+0 },
+{ UINT64_C(0x1100600000000000), 0x1.1006p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000000000), 0x1.101p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000000004), 0x1.101p+60, 0x1p+2 },
+{ UINT64_C(0x1101000000000010), 0x1.101p+60, 0x1p+4 },
+{ UINT64_C(0x1101000000000100), 0x1.1010000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000001000), 0x1.101000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000002000), 0x1.101000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000020000), 0x1.10100000002p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000080000), 0x1.10100000008p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000100000), 0x1.1010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000400000), 0x1.1010000004p+60, 0x0p+0 },
+{ UINT64_C(0x1101000000800000), 0x1.1010000008p+60, 0x0p+0 },
+{ UINT64_C(0x1101000001000000), 0x1.101000001p+60, 0x0p+0 },
+{ UINT64_C(0x1101000008000000), 0x1.101000008p+60, 0x0p+0 },
+{ UINT64_C(0x1101000080000000), 0x1.10100008p+60, 0x0p+0 },
+{ UINT64_C(0x1101000800000000), 0x1.1010008p+60, 0x0p+0 },
+{ UINT64_C(0x1101001000000000), 0x1.101001p+60, 0x0p+0 },
+{ UINT64_C(0x1101004000000000), 0x1.101004p+60, 0x0p+0 },
+{ UINT64_C(0x1101040000000000), 0x1.10104p+60, 0x0p+0 },
+{ UINT64_C(0x1101400000000000), 0x1.1014p+60, 0x0p+0 },
+{ UINT64_C(0x1101800000000000), 0x1.1018p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000000000), 0x1.102p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000000004), 0x1.102p+60, 0x1p+2 },
+{ UINT64_C(0x1102000000000010), 0x1.102p+60, 0x1p+4 },
+{ UINT64_C(0x1102000000000100), 0x1.1020000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000000200), 0x1.1020000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000000400), 0x1.1020000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000001000), 0x1.102000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000002000), 0x1.102000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000010000), 0x1.10200000001p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000020000), 0x1.10200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000100000), 0x1.1020000001p+60, 0x0p+0 },
+{ UINT64_C(0x1102000000400000), 0x1.1020000004p+60, 0x0p+0 },
+{ UINT64_C(0x1102000001000000), 0x1.102000001p+60, 0x0p+0 },
+{ UINT64_C(0x1102000002000000), 0x1.102000002p+60, 0x0p+0 },
+{ UINT64_C(0x1102000010000000), 0x1.10200001p+60, 0x0p+0 },
+{ UINT64_C(0x1102000040000000), 0x1.10200004p+60, 0x0p+0 },
+{ UINT64_C(0x1102000100000000), 0x1.1020001p+60, 0x0p+0 },
+{ UINT64_C(0x1102001000000000), 0x1.102001p+60, 0x0p+0 },
+{ UINT64_C(0x1102002000000000), 0x1.102002p+60, 0x0p+0 },
+{ UINT64_C(0x1102020000000000), 0x1.10202p+60, 0x0p+0 },
+{ UINT64_C(0x1102080000000000), 0x1.10208p+60, 0x0p+0 },
+{ UINT64_C(0x1102800000000000), 0x1.1028p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000000000), 0x1.12p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000000001), 0x1.12p+60, 0x1p+0 },
+{ UINT64_C(0x1120000000000008), 0x1.12p+60, 0x1p+3 },
+{ UINT64_C(0x1120000000000040), 0x1.12p+60, 0x1p+6 },
+{ UINT64_C(0x1120000000000200), 0x1.1200000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000000800), 0x1.1200000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000002000), 0x1.120000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000004000), 0x1.120000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000010000), 0x1.12000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000020000), 0x1.12000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000080000), 0x1.12000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000400000), 0x1.1200000004p+60, 0x0p+0 },
+{ UINT64_C(0x1120000000800000), 0x1.1200000008p+60, 0x0p+0 },
+{ UINT64_C(0x1120000001000000), 0x1.120000001p+60, 0x0p+0 },
+{ UINT64_C(0x1120000010000000), 0x1.12000001p+60, 0x0p+0 },
+{ UINT64_C(0x1120000080000000), 0x1.12000008p+60, 0x0p+0 },
+{ UINT64_C(0x1120000800000000), 0x1.1200008p+60, 0x0p+0 },
+{ UINT64_C(0x1120001000000000), 0x1.120001p+60, 0x0p+0 },
+{ UINT64_C(0x1120010000000000), 0x1.12001p+60, 0x0p+0 },
+{ UINT64_C(0x1120020000000000), 0x1.12002p+60, 0x0p+0 },
+{ UINT64_C(0x1120200000000000), 0x1.1202p+60, 0x0p+0 },
+{ UINT64_C(0x1120400000000000), 0x1.1204p+60, 0x0p+0 },
+{ UINT64_C(0x1120800000000000), 0x1.1208p+60, 0x0p+0 },
+{ UINT64_C(0x1122000000000000), 0x1.122p+60, 0x0p+0 },
+{ UINT64_C(0x1130000000000000), 0x1.13p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000000002), 0x1.2p+60, 0x1p+1 },
+{ UINT64_C(0x1200000000000010), 0x1.2p+60, 0x1p+4 },
+{ UINT64_C(0x1200000000000012), 0x1.2p+60, 0x1.2p+4 },
+{ UINT64_C(0x1200000000000040), 0x1.2p+60, 0x1p+6 },
+{ UINT64_C(0x1200000000000044), 0x1.2p+60, 0x1.1p+6 },
+{ UINT64_C(0x1200000000000080), 0x1.2p+60, 0x1p+7 },
+{ UINT64_C(0x1200000000000081), 0x1.2000000000001p+60, -0x1.fcp+6 },
+{ UINT64_C(0x1200000000000082), 0x1.2000000000001p+60, -0x1.f8p+6 },
+{ UINT64_C(0x12000000000000a0), 0x1.2000000000001p+60, -0x1.8p+6 },
+{ UINT64_C(0x12000000000000c0), 0x1.2000000000001p+60, -0x1p+6 },
+{ UINT64_C(0x1200000000000800), 0x1.2000000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000000804), 0x1.2000000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1200000000000808), 0x1.2000000000008p+60, 0x1p+3 },
+{ UINT64_C(0x1200000000000810), 0x1.2000000000008p+60, 0x1p+4 },
+{ UINT64_C(0x1200000000000880), 0x1.2000000000008p+60, 0x1p+7 },
+{ UINT64_C(0x1200000000000900), 0x1.2000000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000004000), 0x1.200000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000004002), 0x1.200000000004p+60, 0x1p+1 },
+{ UINT64_C(0x1200000000004004), 0x1.200000000004p+60, 0x1p+2 },
+{ UINT64_C(0x1200000000004008), 0x1.200000000004p+60, 0x1p+3 },
+{ UINT64_C(0x1200000000004080), 0x1.200000000004p+60, 0x1p+7 },
+{ UINT64_C(0x1200000000004100), 0x1.2000000000041p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000004400), 0x1.2000000000044p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000006000), 0x1.200000000006p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000008000), 0x1.200000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000008004), 0x1.200000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1200000000008020), 0x1.200000000008p+60, 0x1p+5 },
+{ UINT64_C(0x1200000000008080), 0x1.200000000008p+60, 0x1p+7 },
+{ UINT64_C(0x1200000000008100), 0x1.2000000000081p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000008400), 0x1.2000000000084p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000009000), 0x1.200000000009p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000040000), 0x1.20000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000040001), 0x1.20000000004p+60, 0x1p+0 },
+{ UINT64_C(0x1200000000040004), 0x1.20000000004p+60, 0x1p+2 },
+{ UINT64_C(0x1200000000040008), 0x1.20000000004p+60, 0x1p+3 },
+{ UINT64_C(0x1200000000040080), 0x1.20000000004p+60, 0x1p+7 },
+{ UINT64_C(0x1200000000040800), 0x1.2000000000408p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000042000), 0x1.200000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000048000), 0x1.200000000048p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000200000), 0x1.2000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000200004), 0x1.2000000002p+60, 0x1p+2 },
+{ UINT64_C(0x1200000000200020), 0x1.2000000002p+60, 0x1p+5 },
+{ UINT64_C(0x1200000000200200), 0x1.2000000002002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000202000), 0x1.200000000202p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000210000), 0x1.20000000021p+60, 0x0p+0 },
+{ UINT64_C(0x1200000000280000), 0x1.20000000028p+60, 0x0p+0 },
+{ UINT64_C(0x1200000002000000), 0x1.200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000002000008), 0x1.200000002p+60, 0x1p+3 },
+{ UINT64_C(0x1200000002000020), 0x1.200000002p+60, 0x1p+5 },
+{ UINT64_C(0x1200000002000080), 0x1.200000002p+60, 0x1p+7 },
+{ UINT64_C(0x1200000002000400), 0x1.2000000020004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000002002000), 0x1.200000002002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000002020000), 0x1.20000000202p+60, 0x0p+0 },
+{ UINT64_C(0x1200000002200000), 0x1.2000000022p+60, 0x0p+0 },
+{ UINT64_C(0x1200000002400000), 0x1.2000000024p+60, 0x0p+0 },
+{ UINT64_C(0x1200000003000000), 0x1.200000003p+60, 0x0p+0 },
+{ UINT64_C(0x1200000020000000), 0x1.20000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000020000001), 0x1.20000002p+60, 0x1p+0 },
+{ UINT64_C(0x1200000020000010), 0x1.20000002p+60, 0x1p+4 },
+{ UINT64_C(0x1200000020000040), 0x1.20000002p+60, 0x1p+6 },
+{ UINT64_C(0x1200000020000400), 0x1.2000000200004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000020000800), 0x1.2000000200008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000020002000), 0x1.200000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000020020000), 0x1.20000002002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000020200000), 0x1.2000000202p+60, 0x0p+0 },
+{ UINT64_C(0x1200000022000000), 0x1.200000022p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080000000), 0x1.20000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080000001), 0x1.20000008p+60, 0x1p+0 },
+{ UINT64_C(0x1200000080000004), 0x1.20000008p+60, 0x1p+2 },
+{ UINT64_C(0x1200000080000008), 0x1.20000008p+60, 0x1p+3 },
+{ UINT64_C(0x1200000080000080), 0x1.20000008p+60, 0x1p+7 },
+{ UINT64_C(0x1200000080000100), 0x1.2000000800001p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080000800), 0x1.2000000800008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080004000), 0x1.200000080004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080010000), 0x1.20000008001p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080080000), 0x1.20000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080100000), 0x1.2000000801p+60, 0x0p+0 },
+{ UINT64_C(0x1200000080800000), 0x1.2000000808p+60, 0x0p+0 },
+{ UINT64_C(0x1200000081000000), 0x1.200000081p+60, 0x0p+0 },
+{ UINT64_C(0x1200000082000000), 0x1.200000082p+60, 0x0p+0 },
+{ UINT64_C(0x12000000a0000000), 0x1.2000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1200000100000000), 0x1.2000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100000004), 0x1.2000001p+60, 0x1p+2 },
+{ UINT64_C(0x1200000100000010), 0x1.2000001p+60, 0x1p+4 },
+{ UINT64_C(0x1200000100000040), 0x1.2000001p+60, 0x1p+6 },
+{ UINT64_C(0x1200000100000200), 0x1.2000001000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100000800), 0x1.2000001000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100002000), 0x1.200000100002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100020000), 0x1.20000010002p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100040000), 0x1.20000010004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100080000), 0x1.20000010008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100400000), 0x1.2000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1200000100800000), 0x1.2000001008p+60, 0x0p+0 },
+{ UINT64_C(0x1200000102000000), 0x1.200000102p+60, 0x0p+0 },
+{ UINT64_C(0x1200000110000000), 0x1.20000011p+60, 0x0p+0 },
+{ UINT64_C(0x1200000120000000), 0x1.20000012p+60, 0x0p+0 },
+{ UINT64_C(0x1200000180000000), 0x1.20000018p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000000000), 0x1.200001p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000000004), 0x1.200001p+60, 0x1p+2 },
+{ UINT64_C(0x1200001000000040), 0x1.200001p+60, 0x1p+6 },
+{ UINT64_C(0x1200001000000100), 0x1.2000010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000000800), 0x1.2000010000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000002000), 0x1.200001000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000010000), 0x1.20000100001p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000040000), 0x1.20000100004p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000100000), 0x1.2000010001p+60, 0x0p+0 },
+{ UINT64_C(0x1200001000800000), 0x1.2000010008p+60, 0x0p+0 },
+{ UINT64_C(0x1200001008000000), 0x1.200001008p+60, 0x0p+0 },
+{ UINT64_C(0x1200001040000000), 0x1.20000104p+60, 0x0p+0 },
+{ UINT64_C(0x1200001100000000), 0x1.2000011p+60, 0x0p+0 },
+{ UINT64_C(0x1200001800000000), 0x1.2000018p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000000000), 0x1.200004p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000000001), 0x1.200004p+60, 0x1p+0 },
+{ UINT64_C(0x1200004000000004), 0x1.200004p+60, 0x1p+2 },
+{ UINT64_C(0x1200004000000010), 0x1.200004p+60, 0x1p+4 },
+{ UINT64_C(0x1200004000000040), 0x1.200004p+60, 0x1p+6 },
+{ UINT64_C(0x1200004000000100), 0x1.2000040000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000000200), 0x1.2000040000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000001000), 0x1.200004000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000008000), 0x1.200004000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000010000), 0x1.20000400001p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000080000), 0x1.20000400008p+60, 0x0p+0 },
+{ UINT64_C(0x1200004000800000), 0x1.2000040008p+60, 0x0p+0 },
+{ UINT64_C(0x1200004002000000), 0x1.200004002p+60, 0x0p+0 },
+{ UINT64_C(0x1200004020000000), 0x1.20000402p+60, 0x0p+0 },
+{ UINT64_C(0x1200004200000000), 0x1.2000042p+60, 0x0p+0 },
+{ UINT64_C(0x1200004400000000), 0x1.2000044p+60, 0x0p+0 },
+{ UINT64_C(0x1200004800000000), 0x1.2000048p+60, 0x0p+0 },
+{ UINT64_C(0x1200005000000000), 0x1.200005p+60, 0x0p+0 },
+{ UINT64_C(0x1200006000000000), 0x1.200006p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000000000), 0x1.20001p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000000001), 0x1.20001p+60, 0x1p+0 },
+{ UINT64_C(0x1200010000000004), 0x1.20001p+60, 0x1p+2 },
+{ UINT64_C(0x1200010000000040), 0x1.20001p+60, 0x1p+6 },
+{ UINT64_C(0x1200010000000080), 0x1.20001p+60, 0x1p+7 },
+{ UINT64_C(0x1200010000000400), 0x1.2000100000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000001000), 0x1.200010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000008000), 0x1.200010000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000020000), 0x1.20001000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000040000), 0x1.20001000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000100000), 0x1.2000100001p+60, 0x0p+0 },
+{ UINT64_C(0x1200010000400000), 0x1.2000100004p+60, 0x0p+0 },
+{ UINT64_C(0x1200010004000000), 0x1.200010004p+60, 0x0p+0 },
+{ UINT64_C(0x1200010040000000), 0x1.20001004p+60, 0x0p+0 },
+{ UINT64_C(0x1200010400000000), 0x1.2000104p+60, 0x0p+0 },
+{ UINT64_C(0x1200014000000000), 0x1.200014p+60, 0x0p+0 },
+{ UINT64_C(0x1200020000000000), 0x1.20002p+60, 0x0p+0 },
+{ UINT64_C(0x1200020000000002), 0x1.20002p+60, 0x1p+1 },
+{ UINT64_C(0x1200020000000008), 0x1.20002p+60, 0x1p+3 },
+{ UINT64_C(0x1200020000000080), 0x1.20002p+60, 0x1p+7 },
+{ UINT64_C(0x1200020000000800), 0x1.2000200000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200020000002000), 0x1.200020000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200020000020000), 0x1.20002000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200020000100000), 0x1.2000200001p+60, 0x0p+0 },
+{ UINT64_C(0x1200020001000000), 0x1.200020001p+60, 0x0p+0 },
+{ UINT64_C(0x1200020002000000), 0x1.200020002p+60, 0x0p+0 },
+{ UINT64_C(0x1200020004000000), 0x1.200020004p+60, 0x0p+0 },
+{ UINT64_C(0x1200020040000000), 0x1.20002004p+60, 0x0p+0 },
+{ UINT64_C(0x1200020080000000), 0x1.20002008p+60, 0x0p+0 },
+{ UINT64_C(0x1200020400000000), 0x1.2000204p+60, 0x0p+0 },
+{ UINT64_C(0x1200022000000000), 0x1.200022p+60, 0x0p+0 },
+{ UINT64_C(0x1200030000000000), 0x1.20003p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000000000), 0x1.2002p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000000008), 0x1.2002p+60, 0x1p+3 },
+{ UINT64_C(0x1200200000000010), 0x1.2002p+60, 0x1p+4 },
+{ UINT64_C(0x1200200000000020), 0x1.2002p+60, 0x1p+5 },
+{ UINT64_C(0x1200200000000200), 0x1.2002000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000000800), 0x1.2002000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000001000), 0x1.200200000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000002000), 0x1.200200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000004000), 0x1.200200000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000008000), 0x1.200200000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000080000), 0x1.20020000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200200000200000), 0x1.2002000002p+60, 0x0p+0 },
+{ UINT64_C(0x1200200001000000), 0x1.200200001p+60, 0x0p+0 },
+{ UINT64_C(0x1200200004000000), 0x1.200200004p+60, 0x0p+0 },
+{ UINT64_C(0x1200200010000000), 0x1.20020001p+60, 0x0p+0 },
+{ UINT64_C(0x1200200100000000), 0x1.2002001p+60, 0x0p+0 },
+{ UINT64_C(0x1200200200000000), 0x1.2002002p+60, 0x0p+0 },
+{ UINT64_C(0x1200202000000000), 0x1.200202p+60, 0x0p+0 },
+{ UINT64_C(0x1200204000000000), 0x1.200204p+60, 0x0p+0 },
+{ UINT64_C(0x1200240000000000), 0x1.20024p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000000000), 0x1.2008p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000000004), 0x1.2008p+60, 0x1p+2 },
+{ UINT64_C(0x1200800000000040), 0x1.2008p+60, 0x1p+6 },
+{ UINT64_C(0x1200800000000400), 0x1.2008000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000000800), 0x1.2008000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000001000), 0x1.200800000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000010000), 0x1.20080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000040000), 0x1.20080000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200800000400000), 0x1.2008000004p+60, 0x0p+0 },
+{ UINT64_C(0x1200800002000000), 0x1.200800002p+60, 0x0p+0 },
+{ UINT64_C(0x1200800008000000), 0x1.200800008p+60, 0x0p+0 },
+{ UINT64_C(0x1200800020000000), 0x1.20080002p+60, 0x0p+0 },
+{ UINT64_C(0x1200800040000000), 0x1.20080004p+60, 0x0p+0 },
+{ UINT64_C(0x1200800080000000), 0x1.20080008p+60, 0x0p+0 },
+{ UINT64_C(0x1200800400000000), 0x1.2008004p+60, 0x0p+0 },
+{ UINT64_C(0x1200802000000000), 0x1.200802p+60, 0x0p+0 },
+{ UINT64_C(0x1200810000000000), 0x1.20081p+60, 0x0p+0 },
+{ UINT64_C(0x1200820000000000), 0x1.20082p+60, 0x0p+0 },
+{ UINT64_C(0x1200900000000000), 0x1.2009p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000000000), 0x1.201p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000000008), 0x1.201p+60, 0x1p+3 },
+{ UINT64_C(0x1201000000000040), 0x1.201p+60, 0x1p+6 },
+{ UINT64_C(0x1201000000000080), 0x1.201p+60, 0x1p+7 },
+{ UINT64_C(0x1201000000000200), 0x1.2010000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000001000), 0x1.201000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000004000), 0x1.201000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000008000), 0x1.201000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000040000), 0x1.20100000004p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000080000), 0x1.20100000008p+60, 0x0p+0 },
+{ UINT64_C(0x1201000000800000), 0x1.2010000008p+60, 0x0p+0 },
+{ UINT64_C(0x1201000002000000), 0x1.201000002p+60, 0x0p+0 },
+{ UINT64_C(0x1201000008000000), 0x1.201000008p+60, 0x0p+0 },
+{ UINT64_C(0x1201000010000000), 0x1.20100001p+60, 0x0p+0 },
+{ UINT64_C(0x1201000020000000), 0x1.20100002p+60, 0x0p+0 },
+{ UINT64_C(0x1201000040000000), 0x1.20100004p+60, 0x0p+0 },
+{ UINT64_C(0x1201000100000000), 0x1.2010001p+60, 0x0p+0 },
+{ UINT64_C(0x1201000800000000), 0x1.2010008p+60, 0x0p+0 },
+{ UINT64_C(0x1201001000000000), 0x1.201001p+60, 0x0p+0 },
+{ UINT64_C(0x1201002000000000), 0x1.201002p+60, 0x0p+0 },
+{ UINT64_C(0x1201020000000000), 0x1.20102p+60, 0x0p+0 },
+{ UINT64_C(0x1201040000000000), 0x1.20104p+60, 0x0p+0 },
+{ UINT64_C(0x1201400000000000), 0x1.2014p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000000000), 0x1.208p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000000001), 0x1.208p+60, 0x1p+0 },
+{ UINT64_C(0x1208000000000004), 0x1.208p+60, 0x1p+2 },
+{ UINT64_C(0x1208000000000040), 0x1.208p+60, 0x1p+6 },
+{ UINT64_C(0x1208000000000100), 0x1.2080000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000000400), 0x1.2080000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000002000), 0x1.208000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000004000), 0x1.208000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000020000), 0x1.20800000002p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000200000), 0x1.2080000002p+60, 0x0p+0 },
+{ UINT64_C(0x1208000000800000), 0x1.2080000008p+60, 0x0p+0 },
+{ UINT64_C(0x1208000002000000), 0x1.208000002p+60, 0x0p+0 },
+{ UINT64_C(0x1208000010000000), 0x1.20800001p+60, 0x0p+0 },
+{ UINT64_C(0x1208000020000000), 0x1.20800002p+60, 0x0p+0 },
+{ UINT64_C(0x1208000200000000), 0x1.2080002p+60, 0x0p+0 },
+{ UINT64_C(0x1208000800000000), 0x1.2080008p+60, 0x0p+0 },
+{ UINT64_C(0x1208008000000000), 0x1.208008p+60, 0x0p+0 },
+{ UINT64_C(0x1208010000000000), 0x1.20801p+60, 0x0p+0 },
+{ UINT64_C(0x1208020000000000), 0x1.20802p+60, 0x0p+0 },
+{ UINT64_C(0x1208040000000000), 0x1.20804p+60, 0x0p+0 },
+{ UINT64_C(0x1208100000000000), 0x1.2081p+60, 0x0p+0 },
+{ UINT64_C(0x1208200000000000), 0x1.2082p+60, 0x0p+0 },
+{ UINT64_C(0x1208800000000000), 0x1.2088p+60, 0x0p+0 },
+{ UINT64_C(0x1209000000000000), 0x1.209p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000000000), 0x1.22p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000000002), 0x1.22p+60, 0x1p+1 },
+{ UINT64_C(0x1220000000000008), 0x1.22p+60, 0x1p+3 },
+{ UINT64_C(0x1220000000000040), 0x1.22p+60, 0x1p+6 },
+{ UINT64_C(0x1220000000000200), 0x1.2200000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000000800), 0x1.2200000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000002000), 0x1.220000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000010000), 0x1.22000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000080000), 0x1.22000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000200000), 0x1.2200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1220000000800000), 0x1.2200000008p+60, 0x0p+0 },
+{ UINT64_C(0x1220000001000000), 0x1.220000001p+60, 0x0p+0 },
+{ UINT64_C(0x1220000004000000), 0x1.220000004p+60, 0x0p+0 },
+{ UINT64_C(0x1220000010000000), 0x1.22000001p+60, 0x0p+0 },
+{ UINT64_C(0x1220000040000000), 0x1.22000004p+60, 0x0p+0 },
+{ UINT64_C(0x1220000200000000), 0x1.2200002p+60, 0x0p+0 },
+{ UINT64_C(0x1220000400000000), 0x1.2200004p+60, 0x0p+0 },
+{ UINT64_C(0x1220000800000000), 0x1.2200008p+60, 0x0p+0 },
+{ UINT64_C(0x1220002000000000), 0x1.220002p+60, 0x0p+0 },
+{ UINT64_C(0x1220008000000000), 0x1.220008p+60, 0x0p+0 },
+{ UINT64_C(0x1220040000000000), 0x1.22004p+60, 0x0p+0 },
+{ UINT64_C(0x1220100000000000), 0x1.2201p+60, 0x0p+0 },
+{ UINT64_C(0x1221000000000000), 0x1.221p+60, 0x0p+0 },
+{ UINT64_C(0x1228000000000000), 0x1.228p+60, 0x0p+0 },
+{ UINT64_C(0x1230000000000000), 0x1.23p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000000000), 0x1.3p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000000001), 0x1.3p+60, 0x1p+0 },
+{ UINT64_C(0x1300000000000010), 0x1.3p+60, 0x1p+4 },
+{ UINT64_C(0x1300000000000080), 0x1.3p+60, 0x1p+7 },
+{ UINT64_C(0x1300000000000800), 0x1.3000000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000001000), 0x1.300000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000004000), 0x1.300000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000008000), 0x1.300000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000010000), 0x1.30000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000040000), 0x1.30000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1300000000200000), 0x1.3000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1300000001000000), 0x1.300000001p+60, 0x0p+0 },
+{ UINT64_C(0x1300000004000000), 0x1.300000004p+60, 0x0p+0 },
+{ UINT64_C(0x1300000010000000), 0x1.30000001p+60, 0x0p+0 },
+{ UINT64_C(0x1300000100000000), 0x1.3000001p+60, 0x0p+0 },
+{ UINT64_C(0x1300000800000000), 0x1.3000008p+60, 0x0p+0 },
+{ UINT64_C(0x1300001000000000), 0x1.300001p+60, 0x0p+0 },
+{ UINT64_C(0x1300002000000000), 0x1.300002p+60, 0x0p+0 },
+{ UINT64_C(0x1300010000000000), 0x1.30001p+60, 0x0p+0 },
+{ UINT64_C(0x1300040000000000), 0x1.30004p+60, 0x0p+0 },
+{ UINT64_C(0x1300400000000000), 0x1.3004p+60, 0x0p+0 },
+{ UINT64_C(0x1302000000000000), 0x1.302p+60, 0x0p+0 },
+{ UINT64_C(0x1308000000000000), 0x1.308p+60, 0x0p+0 },
+{ UINT64_C(0x1340000000000000), 0x1.34p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000000002), 0x1.4p+60, 0x1p+1 },
+{ UINT64_C(0x1400000000000010), 0x1.4p+60, 0x1p+4 },
+{ UINT64_C(0x1400000000000018), 0x1.4p+60, 0x1.8p+4 },
+{ UINT64_C(0x1400000000000080), 0x1.4p+60, 0x1p+7 },
+{ UINT64_C(0x1400000000000082), 0x1.4000000000001p+60, -0x1.f8p+6 },
+{ UINT64_C(0x1400000000000084), 0x1.4000000000001p+60, -0x1.fp+6 },
+{ UINT64_C(0x1400000000000088), 0x1.4000000000001p+60, -0x1.ep+6 },
+{ UINT64_C(0x14000000000000c0), 0x1.4000000000001p+60, -0x1p+6 },
+{ UINT64_C(0x1400000000000400), 0x1.4000000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000000402), 0x1.4000000000004p+60, 0x1p+1 },
+{ UINT64_C(0x1400000000000408), 0x1.4000000000004p+60, 0x1p+3 },
+{ UINT64_C(0x1400000000000420), 0x1.4000000000004p+60, 0x1p+5 },
+{ UINT64_C(0x1400000000000500), 0x1.4000000000005p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000000800), 0x1.4000000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000000804), 0x1.4000000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1400000000000808), 0x1.4000000000008p+60, 0x1p+3 },
+{ UINT64_C(0x1400000000000880), 0x1.4000000000008p+60, 0x1p+7 },
+{ UINT64_C(0x1400000000000a00), 0x1.400000000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1400000000002000), 0x1.400000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000002002), 0x1.400000000002p+60, 0x1p+1 },
+{ UINT64_C(0x1400000000002010), 0x1.400000000002p+60, 0x1p+4 },
+{ UINT64_C(0x1400000000002040), 0x1.400000000002p+60, 0x1p+6 },
+{ UINT64_C(0x1400000000002080), 0x1.400000000002p+60, 0x1p+7 },
+{ UINT64_C(0x1400000000002100), 0x1.4000000000021p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000003000), 0x1.400000000003p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000008000), 0x1.400000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000008004), 0x1.400000000008p+60, 0x1p+2 },
+{ UINT64_C(0x1400000000008008), 0x1.400000000008p+60, 0x1p+3 },
+{ UINT64_C(0x1400000000008040), 0x1.400000000008p+60, 0x1p+6 },
+{ UINT64_C(0x1400000000008400), 0x1.4000000000084p+60, 0x0p+0 },
+{ UINT64_C(0x140000000000a000), 0x1.40000000000ap+60, 0x0p+0 },
+{ UINT64_C(0x1400000000040000), 0x1.40000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000040004), 0x1.40000000004p+60, 0x1p+2 },
+{ UINT64_C(0x1400000000040010), 0x1.40000000004p+60, 0x1p+4 },
+{ UINT64_C(0x1400000000040080), 0x1.40000000004p+60, 0x1p+7 },
+{ UINT64_C(0x1400000000040400), 0x1.4000000000404p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000042000), 0x1.400000000042p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000044000), 0x1.400000000044p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000100000), 0x1.4000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000100008), 0x1.4000000001p+60, 0x1p+3 },
+{ UINT64_C(0x1400000000100040), 0x1.4000000001p+60, 0x1p+6 },
+{ UINT64_C(0x1400000000100080), 0x1.4000000001p+60, 0x1p+7 },
+{ UINT64_C(0x1400000000100400), 0x1.4000000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000100800), 0x1.4000000001008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000101000), 0x1.400000000101p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000108000), 0x1.400000000108p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000110000), 0x1.40000000011p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000200000), 0x1.4000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000200001), 0x1.4000000002p+60, 0x1p+0 },
+{ UINT64_C(0x1400000000200004), 0x1.4000000002p+60, 0x1p+2 },
+{ UINT64_C(0x1400000000200020), 0x1.4000000002p+60, 0x1p+5 },
+{ UINT64_C(0x1400000000200040), 0x1.4000000002p+60, 0x1p+6 },
+{ UINT64_C(0x1400000000200200), 0x1.4000000002002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000202000), 0x1.400000000202p+60, 0x0p+0 },
+{ UINT64_C(0x1400000000220000), 0x1.40000000022p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001000000), 0x1.400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001000008), 0x1.400000001p+60, 0x1p+3 },
+{ UINT64_C(0x1400000001000040), 0x1.400000001p+60, 0x1p+6 },
+{ UINT64_C(0x1400000001000100), 0x1.4000000010001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001000400), 0x1.4000000010004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001004000), 0x1.400000001004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001040000), 0x1.40000000104p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001400000), 0x1.4000000014p+60, 0x0p+0 },
+{ UINT64_C(0x1400000001800000), 0x1.4000000018p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008000000), 0x1.400000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008000002), 0x1.400000008p+60, 0x1p+1 },
+{ UINT64_C(0x1400000008000020), 0x1.400000008p+60, 0x1p+5 },
+{ UINT64_C(0x1400000008000200), 0x1.4000000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008002000), 0x1.400000008002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008004000), 0x1.400000008004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008008000), 0x1.400000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008080000), 0x1.40000000808p+60, 0x0p+0 },
+{ UINT64_C(0x1400000008800000), 0x1.4000000088p+60, 0x0p+0 },
+{ UINT64_C(0x1400000009000000), 0x1.400000009p+60, 0x0p+0 },
+{ UINT64_C(0x140000000c000000), 0x1.40000000cp+60, 0x0p+0 },
+{ UINT64_C(0x1400000040000000), 0x1.40000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000040000002), 0x1.40000004p+60, 0x1p+1 },
+{ UINT64_C(0x1400000040000008), 0x1.40000004p+60, 0x1p+3 },
+{ UINT64_C(0x1400000040000020), 0x1.40000004p+60, 0x1p+5 },
+{ UINT64_C(0x1400000040000200), 0x1.4000000400002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000040001000), 0x1.400000040001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000040008000), 0x1.400000040008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000040080000), 0x1.40000004008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000040400000), 0x1.4000000404p+60, 0x0p+0 },
+{ UINT64_C(0x1400000041000000), 0x1.400000041p+60, 0x0p+0 },
+{ UINT64_C(0x1400000048000000), 0x1.400000048p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200000000), 0x1.4000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200000002), 0x1.4000002p+60, 0x1p+1 },
+{ UINT64_C(0x1400000200000004), 0x1.4000002p+60, 0x1p+2 },
+{ UINT64_C(0x1400000200000010), 0x1.4000002p+60, 0x1p+4 },
+{ UINT64_C(0x1400000200000040), 0x1.4000002p+60, 0x1p+6 },
+{ UINT64_C(0x1400000200000400), 0x1.4000002000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200001000), 0x1.400000200001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200010000), 0x1.40000020001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200020000), 0x1.40000020002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200100000), 0x1.4000002001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000200800000), 0x1.4000002008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000208000000), 0x1.400000208p+60, 0x0p+0 },
+{ UINT64_C(0x1400000280000000), 0x1.40000028p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800000000), 0x1.4000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800000001), 0x1.4000008p+60, 0x1p+0 },
+{ UINT64_C(0x1400000800000010), 0x1.4000008p+60, 0x1p+4 },
+{ UINT64_C(0x1400000800000020), 0x1.4000008p+60, 0x1p+5 },
+{ UINT64_C(0x1400000800000200), 0x1.4000008000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800001000), 0x1.400000800001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800010000), 0x1.40000080001p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800020000), 0x1.40000080002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800200000), 0x1.4000008002p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800400000), 0x1.4000008004p+60, 0x0p+0 },
+{ UINT64_C(0x1400000800800000), 0x1.4000008008p+60, 0x0p+0 },
+{ UINT64_C(0x1400000804000000), 0x1.400000804p+60, 0x0p+0 },
+{ UINT64_C(0x1400000840000000), 0x1.40000084p+60, 0x0p+0 },
+{ UINT64_C(0x1400000a00000000), 0x1.400000ap+60, 0x0p+0 },
+{ UINT64_C(0x1400004000000000), 0x1.400004p+60, 0x0p+0 },
+{ UINT64_C(0x1400004000000004), 0x1.400004p+60, 0x1p+2 },
+{ UINT64_C(0x1400004000000010), 0x1.400004p+60, 0x1p+4 },
+{ UINT64_C(0x1400004000000040), 0x1.400004p+60, 0x1p+6 },
+{ UINT64_C(0x1400004000000200), 0x1.4000040000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400004000000800), 0x1.4000040000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400004000002000), 0x1.400004000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400004000020000), 0x1.40000400002p+60, 0x0p+0 },
+{ UINT64_C(0x1400004000080000), 0x1.40000400008p+60, 0x0p+0 },
+{ UINT64_C(0x1400004000400000), 0x1.4000040004p+60, 0x0p+0 },
+{ UINT64_C(0x1400004001000000), 0x1.400004001p+60, 0x0p+0 },
+{ UINT64_C(0x1400004010000000), 0x1.40000401p+60, 0x0p+0 },
+{ UINT64_C(0x1400004100000000), 0x1.4000041p+60, 0x0p+0 },
+{ UINT64_C(0x1400004400000000), 0x1.4000044p+60, 0x0p+0 },
+{ UINT64_C(0x1400004800000000), 0x1.4000048p+60, 0x0p+0 },
+{ UINT64_C(0x1400006000000000), 0x1.400006p+60, 0x0p+0 },
+{ UINT64_C(0x1400040000000000), 0x1.40004p+60, 0x0p+0 },
+{ UINT64_C(0x1400040000000004), 0x1.40004p+60, 0x1p+2 },
+{ UINT64_C(0x1400040000000008), 0x1.40004p+60, 0x1p+3 },
+{ UINT64_C(0x1400040000000020), 0x1.40004p+60, 0x1p+5 },
+{ UINT64_C(0x1400040000000100), 0x1.4000400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400040000000800), 0x1.4000400000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400040000004000), 0x1.400040000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400040000040000), 0x1.40004000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400040000400000), 0x1.4000400004p+60, 0x0p+0 },
+{ UINT64_C(0x1400040004000000), 0x1.400040004p+60, 0x0p+0 },
+{ UINT64_C(0x1400040020000000), 0x1.40004002p+60, 0x0p+0 },
+{ UINT64_C(0x1400040080000000), 0x1.40004008p+60, 0x0p+0 },
+{ UINT64_C(0x1400040400000000), 0x1.4000404p+60, 0x0p+0 },
+{ UINT64_C(0x1400041000000000), 0x1.400041p+60, 0x0p+0 },
+{ UINT64_C(0x1400048000000000), 0x1.400048p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000000000), 0x1.4001p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000000008), 0x1.4001p+60, 0x1p+3 },
+{ UINT64_C(0x1400100000000010), 0x1.4001p+60, 0x1p+4 },
+{ UINT64_C(0x1400100000000020), 0x1.4001p+60, 0x1p+5 },
+{ UINT64_C(0x1400100000000100), 0x1.4001000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000000800), 0x1.4001000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000004000), 0x1.400100000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000010000), 0x1.40010000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000020000), 0x1.40010000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000100000), 0x1.4001000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400100000800000), 0x1.4001000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400100004000000), 0x1.400100004p+60, 0x0p+0 },
+{ UINT64_C(0x1400100008000000), 0x1.400100008p+60, 0x0p+0 },
+{ UINT64_C(0x1400100010000000), 0x1.40010001p+60, 0x0p+0 },
+{ UINT64_C(0x1400100080000000), 0x1.40010008p+60, 0x0p+0 },
+{ UINT64_C(0x1400100800000000), 0x1.4001008p+60, 0x0p+0 },
+{ UINT64_C(0x1400108000000000), 0x1.400108p+60, 0x0p+0 },
+{ UINT64_C(0x1400140000000000), 0x1.40014p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000000000), 0x1.4008p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000000001), 0x1.4008p+60, 0x1p+0 },
+{ UINT64_C(0x1400800000000008), 0x1.4008p+60, 0x1p+3 },
+{ UINT64_C(0x1400800000000040), 0x1.4008p+60, 0x1p+6 },
+{ UINT64_C(0x1400800000000100), 0x1.4008000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000001000), 0x1.400800000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000010000), 0x1.40080000001p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000020000), 0x1.40080000002p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000080000), 0x1.40080000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000400000), 0x1.4008000004p+60, 0x0p+0 },
+{ UINT64_C(0x1400800000800000), 0x1.4008000008p+60, 0x0p+0 },
+{ UINT64_C(0x1400800008000000), 0x1.400800008p+60, 0x0p+0 },
+{ UINT64_C(0x1400800040000000), 0x1.40080004p+60, 0x0p+0 },
+{ UINT64_C(0x1400800400000000), 0x1.4008004p+60, 0x0p+0 },
+{ UINT64_C(0x1400800800000000), 0x1.4008008p+60, 0x0p+0 },
+{ UINT64_C(0x1400801000000000), 0x1.400801p+60, 0x0p+0 },
+{ UINT64_C(0x1400804000000000), 0x1.400804p+60, 0x0p+0 },
+{ UINT64_C(0x1400820000000000), 0x1.40082p+60, 0x0p+0 },
+{ UINT64_C(0x1400840000000000), 0x1.40084p+60, 0x0p+0 },
+{ UINT64_C(0x1400900000000000), 0x1.4009p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000000000), 0x1.404p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000000002), 0x1.404p+60, 0x1p+1 },
+{ UINT64_C(0x1404000000000004), 0x1.404p+60, 0x1p+2 },
+{ UINT64_C(0x1404000000000010), 0x1.404p+60, 0x1p+4 },
+{ UINT64_C(0x1404000000000080), 0x1.404p+60, 0x1p+7 },
+{ UINT64_C(0x1404000000000100), 0x1.4040000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000000200), 0x1.4040000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000001000), 0x1.404000000001p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000004000), 0x1.404000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000008000), 0x1.404000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000010000), 0x1.40400000001p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000040000), 0x1.40400000004p+60, 0x0p+0 },
+{ UINT64_C(0x1404000000100000), 0x1.4040000001p+60, 0x0p+0 },
+{ UINT64_C(0x1404000001000000), 0x1.404000001p+60, 0x0p+0 },
+{ UINT64_C(0x1404000004000000), 0x1.404000004p+60, 0x0p+0 },
+{ UINT64_C(0x1404000040000000), 0x1.40400004p+60, 0x0p+0 },
+{ UINT64_C(0x1404000100000000), 0x1.4040001p+60, 0x0p+0 },
+{ UINT64_C(0x1404001000000000), 0x1.404001p+60, 0x0p+0 },
+{ UINT64_C(0x1404004000000000), 0x1.404004p+60, 0x0p+0 },
+{ UINT64_C(0x1404010000000000), 0x1.40401p+60, 0x0p+0 },
+{ UINT64_C(0x1404100000000000), 0x1.4041p+60, 0x0p+0 },
+{ UINT64_C(0x1404800000000000), 0x1.4048p+60, 0x0p+0 },
+{ UINT64_C(0x1406000000000000), 0x1.406p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000000000), 0x1.41p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000000001), 0x1.41p+60, 0x1p+0 },
+{ UINT64_C(0x1410000000000002), 0x1.41p+60, 0x1p+1 },
+{ UINT64_C(0x1410000000000020), 0x1.41p+60, 0x1p+5 },
+{ UINT64_C(0x1410000000000040), 0x1.41p+60, 0x1p+6 },
+{ UINT64_C(0x1410000000000080), 0x1.41p+60, 0x1p+7 },
+{ UINT64_C(0x1410000000000200), 0x1.4100000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000002000), 0x1.410000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000008000), 0x1.410000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000040000), 0x1.41000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000080000), 0x1.41000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1410000000400000), 0x1.4100000004p+60, 0x0p+0 },
+{ UINT64_C(0x1410000001000000), 0x1.410000001p+60, 0x0p+0 },
+{ UINT64_C(0x1410000008000000), 0x1.410000008p+60, 0x0p+0 },
+{ UINT64_C(0x1410000080000000), 0x1.41000008p+60, 0x0p+0 },
+{ UINT64_C(0x1410000200000000), 0x1.4100002p+60, 0x0p+0 },
+{ UINT64_C(0x1410000400000000), 0x1.4100004p+60, 0x0p+0 },
+{ UINT64_C(0x1410000800000000), 0x1.4100008p+60, 0x0p+0 },
+{ UINT64_C(0x1410001000000000), 0x1.410001p+60, 0x0p+0 },
+{ UINT64_C(0x1410008000000000), 0x1.410008p+60, 0x0p+0 },
+{ UINT64_C(0x1410020000000000), 0x1.41002p+60, 0x0p+0 },
+{ UINT64_C(0x1410200000000000), 0x1.4102p+60, 0x0p+0 },
+{ UINT64_C(0x1411000000000000), 0x1.411p+60, 0x0p+0 },
+{ UINT64_C(0x1414000000000000), 0x1.414p+60, 0x0p+0 },
+{ UINT64_C(0x1420000000000000), 0x1.42p+60, 0x0p+0 },
+{ UINT64_C(0x1420000000000008), 0x1.42p+60, 0x1p+3 },
+{ UINT64_C(0x1420000000000080), 0x1.42p+60, 0x1p+7 },
+{ UINT64_C(0x1420000000000800), 0x1.4200000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1420000000004000), 0x1.420000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1420000000040000), 0x1.42000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1420000000080000), 0x1.42000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1420000000200000), 0x1.4200000002p+60, 0x0p+0 },
+{ UINT64_C(0x1420000002000000), 0x1.420000002p+60, 0x0p+0 },
+{ UINT64_C(0x1420000020000000), 0x1.42000002p+60, 0x0p+0 },
+{ UINT64_C(0x1420000100000000), 0x1.4200001p+60, 0x0p+0 },
+{ UINT64_C(0x1420000400000000), 0x1.4200004p+60, 0x0p+0 },
+{ UINT64_C(0x1420001000000000), 0x1.420001p+60, 0x0p+0 },
+{ UINT64_C(0x1420010000000000), 0x1.42001p+60, 0x0p+0 },
+{ UINT64_C(0x1420080000000000), 0x1.42008p+60, 0x0p+0 },
+{ UINT64_C(0x1420200000000000), 0x1.4202p+60, 0x0p+0 },
+{ UINT64_C(0x1422000000000000), 0x1.422p+60, 0x0p+0 },
+{ UINT64_C(0x1424000000000000), 0x1.424p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000000000), 0x1.6p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000000004), 0x1.6p+60, 0x1p+2 },
+{ UINT64_C(0x1600000000000020), 0x1.6p+60, 0x1p+5 },
+{ UINT64_C(0x1600000000000200), 0x1.6000000000002p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000000800), 0x1.6000000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000008000), 0x1.600000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000040000), 0x1.60000000004p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000080000), 0x1.60000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1600000000800000), 0x1.6000000008p+60, 0x0p+0 },
+{ UINT64_C(0x1600000004000000), 0x1.600000004p+60, 0x0p+0 },
+{ UINT64_C(0x1600000040000000), 0x1.60000004p+60, 0x0p+0 },
+{ UINT64_C(0x1600000200000000), 0x1.6000002p+60, 0x0p+0 },
+{ UINT64_C(0x1600002000000000), 0x1.600002p+60, 0x0p+0 },
+{ UINT64_C(0x1600008000000000), 0x1.600008p+60, 0x0p+0 },
+{ UINT64_C(0x1600080000000000), 0x1.60008p+60, 0x0p+0 },
+{ UINT64_C(0x1600100000000000), 0x1.6001p+60, 0x0p+0 },
+{ UINT64_C(0x1601000000000000), 0x1.601p+60, 0x0p+0 },
+{ UINT64_C(0x1604000000000000), 0x1.604p+60, 0x0p+0 },
+{ UINT64_C(0x1640000000000000), 0x1.64p+60, 0x0p+0 },
+{ UINT64_C(0x1700000000000000), 0x1.7p+60, 0x0p+0 },
+{ UINT64_C(0x400000000000000c), 0x1p+62, 0x1.8p+3 },
+{ UINT64_C(0x4000000000000024), 0x1p+62, 0x1.2p+5 },
+{ UINT64_C(0x4000000000000026), 0x1p+62, 0x1.3p+5 },
+{ UINT64_C(0x4000000000000204), 0x1.0000000000001p+62, -0x1.fcp+8 },
+{ UINT64_C(0x4000000000000220), 0x1.0000000000001p+62, -0x1.ep+8 },
+{ UINT64_C(0x4000000000000221), 0x1.0000000000001p+62, -0x1.dfp+8 },
+{ UINT64_C(0x4000000000000224), 0x1.0000000000001p+62, -0x1.dcp+8 },
+{ UINT64_C(0x4000000000000230), 0x1.0000000000001p+62, -0x1.dp+8 },
+{ UINT64_C(0x4000000000000240), 0x1.0000000000001p+62, -0x1.cp+8 },
+{ UINT64_C(0x4000000000000242), 0x1.0000000000001p+62, -0x1.bep+8 },
+{ UINT64_C(0x4000000000000248), 0x1.0000000000001p+62, -0x1.b8p+8 },
+{ UINT64_C(0x4000000000000260), 0x1.0000000000001p+62, -0x1.ap+8 },
+{ UINT64_C(0x4000000000000280), 0x1.0000000000001p+62, -0x1.8p+8 },
+{ UINT64_C(0x4000000000000288), 0x1.0000000000001p+62, -0x1.78p+8 },
+{ UINT64_C(0x40000000000002a0), 0x1.0000000000001p+62, -0x1.6p+8 },
+{ UINT64_C(0x4000000000002008), 0x1.0000000000008p+62, 0x1p+3 },
+{ UINT64_C(0x4000000000002080), 0x1.0000000000008p+62, 0x1p+7 },
+{ UINT64_C(0x4000000000002082), 0x1.0000000000008p+62, 0x1.04p+7 },
+{ UINT64_C(0x4000000000002084), 0x1.0000000000008p+62, 0x1.08p+7 },
+{ UINT64_C(0x4000000000002090), 0x1.0000000000008p+62, 0x1.2p+7 },
+{ UINT64_C(0x40000000000020c0), 0x1.0000000000008p+62, 0x1.8p+7 },
+{ UINT64_C(0x4000000000002800), 0x1.000000000000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000000000002808), 0x1.000000000000ap+62, 0x1p+3 },
+{ UINT64_C(0x4000000000002840), 0x1.000000000000ap+62, 0x1p+6 },
+{ UINT64_C(0x4000000000002900), 0x1.000000000000ap+62, 0x1p+8 },
+{ UINT64_C(0x4000000000010004), 0x1.000000000004p+62, 0x1p+2 },
+{ UINT64_C(0x4000000000010040), 0x1.000000000004p+62, 0x1p+6 },
+{ UINT64_C(0x4000000000010048), 0x1.000000000004p+62, 0x1.2p+6 },
+{ UINT64_C(0x4000000000010050), 0x1.000000000004p+62, 0x1.4p+6 },
+{ UINT64_C(0x4000000000010200), 0x1.000000000004p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000010204), 0x1.0000000000041p+62, -0x1.fcp+8 },
+{ UINT64_C(0x4000000000010210), 0x1.0000000000041p+62, -0x1.fp+8 },
+{ UINT64_C(0x4000000000010280), 0x1.0000000000041p+62, -0x1.8p+8 },
+{ UINT64_C(0x4000000000010800), 0x1.0000000000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000010804), 0x1.0000000000042p+62, 0x1p+2 },
+{ UINT64_C(0x4000000000010808), 0x1.0000000000042p+62, 0x1p+3 },
+{ UINT64_C(0x4000000000010880), 0x1.0000000000042p+62, 0x1p+7 },
+{ UINT64_C(0x4000000000010a00), 0x1.0000000000042p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000010c00), 0x1.0000000000043p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000014000), 0x1.000000000005p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000014004), 0x1.000000000005p+62, 0x1p+2 },
+{ UINT64_C(0x4000000000014040), 0x1.000000000005p+62, 0x1p+6 },
+{ UINT64_C(0x4000000000014100), 0x1.000000000005p+62, 0x1p+8 },
+{ UINT64_C(0x4000000000014200), 0x1.000000000005p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000015000), 0x1.0000000000054p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000016000), 0x1.0000000000058p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000020008), 0x1.000000000008p+62, 0x1p+3 },
+{ UINT64_C(0x400000000002000c), 0x1.000000000008p+62, 0x1.8p+3 },
+{ UINT64_C(0x4000000000020010), 0x1.000000000008p+62, 0x1p+4 },
+{ UINT64_C(0x4000000000020011), 0x1.000000000008p+62, 0x1.1p+4 },
+{ UINT64_C(0x4000000000020014), 0x1.000000000008p+62, 0x1.4p+4 },
+{ UINT64_C(0x4000000000020100), 0x1.000000000008p+62, 0x1p+8 },
+{ UINT64_C(0x4000000000020104), 0x1.000000000008p+62, 0x1.04p+8 },
+{ UINT64_C(0x4000000000020108), 0x1.000000000008p+62, 0x1.08p+8 },
+{ UINT64_C(0x4000000000020110), 0x1.000000000008p+62, 0x1.1p+8 },
+{ UINT64_C(0x4000000000020200), 0x1.000000000008p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000020208), 0x1.0000000000081p+62, -0x1.f8p+8 },
+{ UINT64_C(0x4000000000020280), 0x1.0000000000081p+62, -0x1.8p+8 },
+{ UINT64_C(0x4000000000022000), 0x1.0000000000088p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000022004), 0x1.0000000000088p+62, 0x1p+2 },
+{ UINT64_C(0x4000000000022040), 0x1.0000000000088p+62, 0x1p+6 },
+{ UINT64_C(0x4000000000022100), 0x1.0000000000088p+62, 0x1p+8 },
+{ UINT64_C(0x4000000000023000), 0x1.000000000008cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000000028000), 0x1.00000000000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000000000028004), 0x1.00000000000ap+62, 0x1p+2 },
+{ UINT64_C(0x4000000000028010), 0x1.00000000000ap+62, 0x1p+4 },
+{ UINT64_C(0x4000000000028080), 0x1.00000000000ap+62, 0x1p+7 },
+{ UINT64_C(0x4000000000028400), 0x1.00000000000a1p+62, 0x0p+0 },
+{ UINT64_C(0x400000000002a000), 0x1.00000000000a8p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000100008), 0x1.00000000004p+62, 0x1p+3 },
+{ UINT64_C(0x4000000000100020), 0x1.00000000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000000000100022), 0x1.00000000004p+62, 0x1.1p+5 },
+{ UINT64_C(0x4000000000100200), 0x1.00000000004p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000100208), 0x1.0000000000401p+62, -0x1.f8p+8 },
+{ UINT64_C(0x4000000000100210), 0x1.0000000000401p+62, -0x1.fp+8 },
+{ UINT64_C(0x4000000000100240), 0x1.0000000000401p+62, -0x1.cp+8 },
+{ UINT64_C(0x4000000000102000), 0x1.0000000000408p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000102001), 0x1.0000000000408p+62, 0x1p+0 },
+{ UINT64_C(0x4000000000102002), 0x1.0000000000408p+62, 0x1p+1 },
+{ UINT64_C(0x4000000000102004), 0x1.0000000000408p+62, 0x1p+2 },
+{ UINT64_C(0x4000000000102010), 0x1.0000000000408p+62, 0x1p+4 },
+{ UINT64_C(0x4000000000102040), 0x1.0000000000408p+62, 0x1p+6 },
+{ UINT64_C(0x4000000000102200), 0x1.0000000000408p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000103000), 0x1.000000000040cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000000108000), 0x1.000000000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000108001), 0x1.000000000042p+62, 0x1p+0 },
+{ UINT64_C(0x4000000000108008), 0x1.000000000042p+62, 0x1p+3 },
+{ UINT64_C(0x4000000000108020), 0x1.000000000042p+62, 0x1p+5 },
+{ UINT64_C(0x4000000000108200), 0x1.000000000042p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000108800), 0x1.0000000000422p+62, 0x0p+0 },
+{ UINT64_C(0x400000000010c000), 0x1.000000000043p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000140000), 0x1.00000000005p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000140004), 0x1.00000000005p+62, 0x1p+2 },
+{ UINT64_C(0x4000000000140008), 0x1.00000000005p+62, 0x1p+3 },
+{ UINT64_C(0x4000000000140020), 0x1.00000000005p+62, 0x1p+5 },
+{ UINT64_C(0x4000000000140040), 0x1.00000000005p+62, 0x1p+6 },
+{ UINT64_C(0x4000000000140100), 0x1.00000000005p+62, 0x1p+8 },
+{ UINT64_C(0x4000000000140200), 0x1.00000000005p+62, 0x1p+9 },
+{ UINT64_C(0x4000000000141000), 0x1.0000000000504p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000144000), 0x1.000000000051p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000150000), 0x1.000000000054p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000180000), 0x1.00000000006p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000180008), 0x1.00000000006p+62, 0x1p+3 },
+{ UINT64_C(0x4000000000180010), 0x1.00000000006p+62, 0x1p+4 },
+{ UINT64_C(0x4000000000180100), 0x1.00000000006p+62, 0x1p+8 },
+{ UINT64_C(0x4000000000181000), 0x1.0000000000604p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000182000), 0x1.0000000000608p+62, 0x0p+0 },
+{ UINT64_C(0x4000000000190000), 0x1.000000000064p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001000002), 0x1.0000000004p+62, 0x1p+1 },
+{ UINT64_C(0x4000000001000020), 0x1.0000000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000000001000022), 0x1.0000000004p+62, 0x1.1p+5 },
+{ UINT64_C(0x4000000001000028), 0x1.0000000004p+62, 0x1.4p+5 },
+{ UINT64_C(0x4000000001000080), 0x1.0000000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000000001000084), 0x1.0000000004p+62, 0x1.08p+7 },
+{ UINT64_C(0x40000000010000c0), 0x1.0000000004p+62, 0x1.8p+7 },
+{ UINT64_C(0x4000000001000400), 0x1.0000000004001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001000404), 0x1.0000000004001p+62, 0x1p+2 },
+{ UINT64_C(0x4000000001000440), 0x1.0000000004001p+62, 0x1p+6 },
+{ UINT64_C(0x4000000001000500), 0x1.0000000004001p+62, 0x1p+8 },
+{ UINT64_C(0x4000000001000600), 0x1.0000000004002p+62, -0x1p+9 },
+{ UINT64_C(0x4000000001004000), 0x1.000000000401p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001004002), 0x1.000000000401p+62, 0x1p+1 },
+{ UINT64_C(0x4000000001004008), 0x1.000000000401p+62, 0x1p+3 },
+{ UINT64_C(0x4000000001004020), 0x1.000000000401p+62, 0x1p+5 },
+{ UINT64_C(0x4000000001004100), 0x1.000000000401p+62, 0x1p+8 },
+{ UINT64_C(0x4000000001004200), 0x1.000000000401p+62, 0x1p+9 },
+{ UINT64_C(0x4000000001006000), 0x1.0000000004018p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001020000), 0x1.000000000408p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001020001), 0x1.000000000408p+62, 0x1p+0 },
+{ UINT64_C(0x4000000001020004), 0x1.000000000408p+62, 0x1p+2 },
+{ UINT64_C(0x4000000001020020), 0x1.000000000408p+62, 0x1p+5 },
+{ UINT64_C(0x4000000001020080), 0x1.000000000408p+62, 0x1p+7 },
+{ UINT64_C(0x4000000001020400), 0x1.0000000004081p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001020800), 0x1.0000000004082p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001028000), 0x1.00000000040ap+62, 0x0p+0 },
+{ UINT64_C(0x4000000001100000), 0x1.00000000044p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001100008), 0x1.00000000044p+62, 0x1p+3 },
+{ UINT64_C(0x4000000001100080), 0x1.00000000044p+62, 0x1p+7 },
+{ UINT64_C(0x4000000001100800), 0x1.0000000004402p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001108000), 0x1.000000000442p+62, 0x0p+0 },
+{ UINT64_C(0x4000000001110000), 0x1.000000000444p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002000008), 0x1.0000000008p+62, 0x1p+3 },
+{ UINT64_C(0x400000000200000a), 0x1.0000000008p+62, 0x1.4p+3 },
+{ UINT64_C(0x4000000002000010), 0x1.0000000008p+62, 0x1p+4 },
+{ UINT64_C(0x4000000002000018), 0x1.0000000008p+62, 0x1.8p+4 },
+{ UINT64_C(0x4000000002000040), 0x1.0000000008p+62, 0x1p+6 },
+{ UINT64_C(0x4000000002000042), 0x1.0000000008p+62, 0x1.08p+6 },
+{ UINT64_C(0x4000000002000050), 0x1.0000000008p+62, 0x1.4p+6 },
+{ UINT64_C(0x4000000002000080), 0x1.0000000008p+62, 0x1p+7 },
+{ UINT64_C(0x4000000002000082), 0x1.0000000008p+62, 0x1.04p+7 },
+{ UINT64_C(0x4000000002000090), 0x1.0000000008p+62, 0x1.2p+7 },
+{ UINT64_C(0x4000000002000800), 0x1.0000000008002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002000804), 0x1.0000000008002p+62, 0x1p+2 },
+{ UINT64_C(0x4000000002000810), 0x1.0000000008002p+62, 0x1p+4 },
+{ UINT64_C(0x4000000002000840), 0x1.0000000008002p+62, 0x1p+6 },
+{ UINT64_C(0x4000000002000900), 0x1.0000000008002p+62, 0x1p+8 },
+{ UINT64_C(0x4000000002000c00), 0x1.0000000008003p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002008000), 0x1.000000000802p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002008002), 0x1.000000000802p+62, 0x1p+1 },
+{ UINT64_C(0x4000000002008004), 0x1.000000000802p+62, 0x1p+2 },
+{ UINT64_C(0x4000000002008040), 0x1.000000000802p+62, 0x1p+6 },
+{ UINT64_C(0x4000000002008080), 0x1.000000000802p+62, 0x1p+7 },
+{ UINT64_C(0x4000000002008800), 0x1.0000000008022p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002009000), 0x1.0000000008024p+62, 0x0p+0 },
+{ UINT64_C(0x400000000200c000), 0x1.000000000803p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002010000), 0x1.000000000804p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002010004), 0x1.000000000804p+62, 0x1p+2 },
+{ UINT64_C(0x4000000002010010), 0x1.000000000804p+62, 0x1p+4 },
+{ UINT64_C(0x4000000002010020), 0x1.000000000804p+62, 0x1p+5 },
+{ UINT64_C(0x4000000002010080), 0x1.000000000804p+62, 0x1p+7 },
+{ UINT64_C(0x4000000002010100), 0x1.000000000804p+62, 0x1p+8 },
+{ UINT64_C(0x4000000002011000), 0x1.0000000008044p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002020000), 0x1.000000000808p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002020004), 0x1.000000000808p+62, 0x1p+2 },
+{ UINT64_C(0x4000000002020008), 0x1.000000000808p+62, 0x1p+3 },
+{ UINT64_C(0x4000000002020010), 0x1.000000000808p+62, 0x1p+4 },
+{ UINT64_C(0x4000000002020080), 0x1.000000000808p+62, 0x1p+7 },
+{ UINT64_C(0x4000000002020800), 0x1.0000000008082p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002021000), 0x1.0000000008084p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002030000), 0x1.00000000080cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000002080000), 0x1.00000000082p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002080008), 0x1.00000000082p+62, 0x1p+3 },
+{ UINT64_C(0x4000000002080010), 0x1.00000000082p+62, 0x1p+4 },
+{ UINT64_C(0x4000000002080080), 0x1.00000000082p+62, 0x1p+7 },
+{ UINT64_C(0x4000000002080200), 0x1.00000000082p+62, 0x1p+9 },
+{ UINT64_C(0x4000000002081000), 0x1.0000000008204p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002082000), 0x1.0000000008208p+62, 0x0p+0 },
+{ UINT64_C(0x40000000020a0000), 0x1.000000000828p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002100000), 0x1.00000000084p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002100002), 0x1.00000000084p+62, 0x1p+1 },
+{ UINT64_C(0x4000000002100008), 0x1.00000000084p+62, 0x1p+3 },
+{ UINT64_C(0x4000000002100020), 0x1.00000000084p+62, 0x1p+5 },
+{ UINT64_C(0x4000000002100080), 0x1.00000000084p+62, 0x1p+7 },
+{ UINT64_C(0x4000000002100100), 0x1.00000000084p+62, 0x1p+8 },
+{ UINT64_C(0x4000000002100200), 0x1.00000000084p+62, 0x1p+9 },
+{ UINT64_C(0x4000000002100400), 0x1.0000000008401p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002101000), 0x1.0000000008404p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002108000), 0x1.000000000842p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002120000), 0x1.000000000848p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002200000), 0x1.00000000088p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002200004), 0x1.00000000088p+62, 0x1p+2 },
+{ UINT64_C(0x4000000002200020), 0x1.00000000088p+62, 0x1p+5 },
+{ UINT64_C(0x4000000002200100), 0x1.00000000088p+62, 0x1p+8 },
+{ UINT64_C(0x4000000002200800), 0x1.0000000008802p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002202000), 0x1.0000000008808p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002208000), 0x1.000000000882p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002210000), 0x1.000000000884p+62, 0x0p+0 },
+{ UINT64_C(0x4000000002280000), 0x1.0000000008ap+62, 0x0p+0 },
+{ UINT64_C(0x4000000002300000), 0x1.0000000008cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000008000002), 0x1.000000002p+62, 0x1p+1 },
+{ UINT64_C(0x4000000008000008), 0x1.000000002p+62, 0x1p+3 },
+{ UINT64_C(0x400000000800000a), 0x1.000000002p+62, 0x1.4p+3 },
+{ UINT64_C(0x400000000800000c), 0x1.000000002p+62, 0x1.8p+3 },
+{ UINT64_C(0x4000000008000080), 0x1.000000002p+62, 0x1p+7 },
+{ UINT64_C(0x4000000008000088), 0x1.000000002p+62, 0x1.1p+7 },
+{ UINT64_C(0x40000000080000c0), 0x1.000000002p+62, 0x1.8p+7 },
+{ UINT64_C(0x4000000008000100), 0x1.000000002p+62, 0x1p+8 },
+{ UINT64_C(0x4000000008000104), 0x1.000000002p+62, 0x1.04p+8 },
+{ UINT64_C(0x4000000008000120), 0x1.000000002p+62, 0x1.2p+8 },
+{ UINT64_C(0x4000000008000200), 0x1.000000002p+62, 0x1p+9 },
+{ UINT64_C(0x4000000008000202), 0x1.0000000020001p+62, -0x1.fep+8 },
+{ UINT64_C(0x4000000008000210), 0x1.0000000020001p+62, -0x1.fp+8 },
+{ UINT64_C(0x4000000008000220), 0x1.0000000020001p+62, -0x1.ep+8 },
+{ UINT64_C(0x4000000008000280), 0x1.0000000020001p+62, -0x1.8p+8 },
+{ UINT64_C(0x4000000008000300), 0x1.0000000020001p+62, -0x1p+8 },
+{ UINT64_C(0x4000000008001000), 0x1.0000000020004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008001008), 0x1.0000000020004p+62, 0x1p+3 },
+{ UINT64_C(0x4000000008001010), 0x1.0000000020004p+62, 0x1p+4 },
+{ UINT64_C(0x4000000008001020), 0x1.0000000020004p+62, 0x1p+5 },
+{ UINT64_C(0x4000000008001040), 0x1.0000000020004p+62, 0x1p+6 },
+{ UINT64_C(0x4000000008001080), 0x1.0000000020004p+62, 0x1p+7 },
+{ UINT64_C(0x4000000008001400), 0x1.0000000020005p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008008000), 0x1.000000002002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008008004), 0x1.000000002002p+62, 0x1p+2 },
+{ UINT64_C(0x4000000008008010), 0x1.000000002002p+62, 0x1p+4 },
+{ UINT64_C(0x4000000008008020), 0x1.000000002002p+62, 0x1p+5 },
+{ UINT64_C(0x4000000008008100), 0x1.000000002002p+62, 0x1p+8 },
+{ UINT64_C(0x4000000008009000), 0x1.0000000020024p+62, 0x0p+0 },
+{ UINT64_C(0x400000000800a000), 0x1.0000000020028p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008020000), 0x1.000000002008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008020001), 0x1.000000002008p+62, 0x1p+0 },
+{ UINT64_C(0x4000000008020008), 0x1.000000002008p+62, 0x1p+3 },
+{ UINT64_C(0x4000000008020010), 0x1.000000002008p+62, 0x1p+4 },
+{ UINT64_C(0x4000000008020020), 0x1.000000002008p+62, 0x1p+5 },
+{ UINT64_C(0x4000000008020040), 0x1.000000002008p+62, 0x1p+6 },
+{ UINT64_C(0x4000000008020400), 0x1.0000000020081p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008021000), 0x1.0000000020084p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008030000), 0x1.00000000200cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000008200000), 0x1.00000000208p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008200002), 0x1.00000000208p+62, 0x1p+1 },
+{ UINT64_C(0x4000000008200020), 0x1.00000000208p+62, 0x1p+5 },
+{ UINT64_C(0x4000000008200100), 0x1.00000000208p+62, 0x1p+8 },
+{ UINT64_C(0x4000000008200800), 0x1.0000000020802p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008208000), 0x1.000000002082p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008280000), 0x1.0000000020ap+62, 0x0p+0 },
+{ UINT64_C(0x4000000008400000), 0x1.0000000021p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008400002), 0x1.0000000021p+62, 0x1p+1 },
+{ UINT64_C(0x4000000008400004), 0x1.0000000021p+62, 0x1p+2 },
+{ UINT64_C(0x4000000008400010), 0x1.0000000021p+62, 0x1p+4 },
+{ UINT64_C(0x4000000008400100), 0x1.0000000021p+62, 0x1p+8 },
+{ UINT64_C(0x4000000008400800), 0x1.0000000021002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008402000), 0x1.0000000021008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008408000), 0x1.000000002102p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008480000), 0x1.00000000212p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008600000), 0x1.00000000218p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008800000), 0x1.0000000022p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008800004), 0x1.0000000022p+62, 0x1p+2 },
+{ UINT64_C(0x4000000008800008), 0x1.0000000022p+62, 0x1p+3 },
+{ UINT64_C(0x4000000008800020), 0x1.0000000022p+62, 0x1p+5 },
+{ UINT64_C(0x4000000008800080), 0x1.0000000022p+62, 0x1p+7 },
+{ UINT64_C(0x4000000008800400), 0x1.0000000022001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008800800), 0x1.0000000022002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008802000), 0x1.0000000022008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008820000), 0x1.000000002208p+62, 0x0p+0 },
+{ UINT64_C(0x4000000008880000), 0x1.00000000222p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040000008), 0x1.00000001p+62, 0x1p+3 },
+{ UINT64_C(0x4000000040000010), 0x1.00000001p+62, 0x1p+4 },
+{ UINT64_C(0x4000000040000012), 0x1.00000001p+62, 0x1.2p+4 },
+{ UINT64_C(0x4000000040000018), 0x1.00000001p+62, 0x1.8p+4 },
+{ UINT64_C(0x4000000040000080), 0x1.00000001p+62, 0x1p+7 },
+{ UINT64_C(0x4000000040000082), 0x1.00000001p+62, 0x1.04p+7 },
+{ UINT64_C(0x4000000040000090), 0x1.00000001p+62, 0x1.2p+7 },
+{ UINT64_C(0x40000000400000a0), 0x1.00000001p+62, 0x1.4p+7 },
+{ UINT64_C(0x4000000040000800), 0x1.0000000100002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040000801), 0x1.0000000100002p+62, 0x1p+0 },
+{ UINT64_C(0x4000000040000802), 0x1.0000000100002p+62, 0x1p+1 },
+{ UINT64_C(0x4000000040000808), 0x1.0000000100002p+62, 0x1p+3 },
+{ UINT64_C(0x4000000040000840), 0x1.0000000100002p+62, 0x1p+6 },
+{ UINT64_C(0x4000000040000900), 0x1.0000000100002p+62, 0x1p+8 },
+{ UINT64_C(0x4000000040000c00), 0x1.0000000100003p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040002000), 0x1.0000000100008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040002004), 0x1.0000000100008p+62, 0x1p+2 },
+{ UINT64_C(0x4000000040002020), 0x1.0000000100008p+62, 0x1p+5 },
+{ UINT64_C(0x4000000040002200), 0x1.0000000100008p+62, 0x1p+9 },
+{ UINT64_C(0x4000000040002800), 0x1.000000010000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000000040020000), 0x1.000000010008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040020002), 0x1.000000010008p+62, 0x1p+1 },
+{ UINT64_C(0x4000000040020020), 0x1.000000010008p+62, 0x1p+5 },
+{ UINT64_C(0x4000000040020100), 0x1.000000010008p+62, 0x1p+8 },
+{ UINT64_C(0x4000000040020800), 0x1.0000000100082p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040021000), 0x1.0000000100084p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040022000), 0x1.0000000100088p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040030000), 0x1.00000001000cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000040040000), 0x1.00000001001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040040004), 0x1.00000001001p+62, 0x1p+2 },
+{ UINT64_C(0x4000000040040040), 0x1.00000001001p+62, 0x1p+6 },
+{ UINT64_C(0x4000000040040200), 0x1.00000001001p+62, 0x1p+9 },
+{ UINT64_C(0x4000000040040800), 0x1.0000000100102p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040044000), 0x1.000000010011p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040048000), 0x1.000000010012p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040050000), 0x1.000000010014p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040100000), 0x1.00000001004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040100008), 0x1.00000001004p+62, 0x1p+3 },
+{ UINT64_C(0x4000000040100040), 0x1.00000001004p+62, 0x1p+6 },
+{ UINT64_C(0x4000000040100100), 0x1.00000001004p+62, 0x1p+8 },
+{ UINT64_C(0x4000000040100200), 0x1.00000001004p+62, 0x1p+9 },
+{ UINT64_C(0x4000000040102000), 0x1.0000000100408p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040104000), 0x1.000000010041p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040120000), 0x1.000000010048p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040200000), 0x1.00000001008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040200004), 0x1.00000001008p+62, 0x1p+2 },
+{ UINT64_C(0x4000000040200020), 0x1.00000001008p+62, 0x1p+5 },
+{ UINT64_C(0x4000000040200080), 0x1.00000001008p+62, 0x1p+7 },
+{ UINT64_C(0x4000000040200400), 0x1.0000000100801p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040200800), 0x1.0000000100802p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040201000), 0x1.0000000100804p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040210000), 0x1.000000010084p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040240000), 0x1.00000001009p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040800000), 0x1.0000000102p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040800002), 0x1.0000000102p+62, 0x1p+1 },
+{ UINT64_C(0x4000000040800020), 0x1.0000000102p+62, 0x1p+5 },
+{ UINT64_C(0x4000000040800100), 0x1.0000000102p+62, 0x1p+8 },
+{ UINT64_C(0x4000000040801000), 0x1.0000000102004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040802000), 0x1.0000000102008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040804000), 0x1.000000010201p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040810000), 0x1.000000010204p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040840000), 0x1.00000001021p+62, 0x0p+0 },
+{ UINT64_C(0x4000000040c00000), 0x1.0000000103p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042000000), 0x1.0000000108p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042000001), 0x1.0000000108p+62, 0x1p+0 },
+{ UINT64_C(0x4000000042000002), 0x1.0000000108p+62, 0x1p+1 },
+{ UINT64_C(0x4000000042000010), 0x1.0000000108p+62, 0x1p+4 },
+{ UINT64_C(0x4000000042000080), 0x1.0000000108p+62, 0x1p+7 },
+{ UINT64_C(0x4000000042000400), 0x1.0000000108001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042001000), 0x1.0000000108004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042010000), 0x1.000000010804p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042020000), 0x1.000000010808p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042040000), 0x1.00000001081p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042200000), 0x1.00000001088p+62, 0x0p+0 },
+{ UINT64_C(0x4000000042400000), 0x1.0000000109p+62, 0x0p+0 },
+{ UINT64_C(0x4000000050000000), 0x1.000000014p+62, 0x0p+0 },
+{ UINT64_C(0x4000000050000008), 0x1.000000014p+62, 0x1p+3 },
+{ UINT64_C(0x4000000050000080), 0x1.000000014p+62, 0x1p+7 },
+{ UINT64_C(0x4000000050000400), 0x1.0000000140001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000050004000), 0x1.000000014001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000050020000), 0x1.000000014008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000050100000), 0x1.00000001404p+62, 0x0p+0 },
+{ UINT64_C(0x4000000050800000), 0x1.0000000142p+62, 0x0p+0 },
+{ UINT64_C(0x4000000054000000), 0x1.000000015p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100000002), 0x1.00000004p+62, 0x1p+1 },
+{ UINT64_C(0x4000000100000003), 0x1.00000004p+62, 0x1.8p+1 },
+{ UINT64_C(0x4000000100000004), 0x1.00000004p+62, 0x1p+2 },
+{ UINT64_C(0x4000000100000005), 0x1.00000004p+62, 0x1.4p+2 },
+{ UINT64_C(0x4000000100000020), 0x1.00000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000000100000021), 0x1.00000004p+62, 0x1.08p+5 },
+{ UINT64_C(0x4000000100000022), 0x1.00000004p+62, 0x1.1p+5 },
+{ UINT64_C(0x4000000100000024), 0x1.00000004p+62, 0x1.2p+5 },
+{ UINT64_C(0x4000000100000028), 0x1.00000004p+62, 0x1.4p+5 },
+{ UINT64_C(0x4000000100000080), 0x1.00000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000000100000082), 0x1.00000004p+62, 0x1.04p+7 },
+{ UINT64_C(0x40000001000000a0), 0x1.00000004p+62, 0x1.4p+7 },
+{ UINT64_C(0x40000001000000c0), 0x1.00000004p+62, 0x1.8p+7 },
+{ UINT64_C(0x4000000100000400), 0x1.0000000400001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100000402), 0x1.0000000400001p+62, 0x1p+1 },
+{ UINT64_C(0x4000000100000408), 0x1.0000000400001p+62, 0x1p+3 },
+{ UINT64_C(0x4000000100000440), 0x1.0000000400001p+62, 0x1p+6 },
+{ UINT64_C(0x4000000100000600), 0x1.0000000400002p+62, -0x1p+9 },
+{ UINT64_C(0x4000000100000800), 0x1.0000000400002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100000804), 0x1.0000000400002p+62, 0x1p+2 },
+{ UINT64_C(0x4000000100000840), 0x1.0000000400002p+62, 0x1p+6 },
+{ UINT64_C(0x4000000100000a00), 0x1.0000000400002p+62, 0x1p+9 },
+{ UINT64_C(0x4000000100000c00), 0x1.0000000400003p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100004000), 0x1.000000040001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100004004), 0x1.000000040001p+62, 0x1p+2 },
+{ UINT64_C(0x4000000100004040), 0x1.000000040001p+62, 0x1p+6 },
+{ UINT64_C(0x4000000100004400), 0x1.0000000400011p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100020000), 0x1.000000040008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100020001), 0x1.000000040008p+62, 0x1p+0 },
+{ UINT64_C(0x4000000100020002), 0x1.000000040008p+62, 0x1p+1 },
+{ UINT64_C(0x4000000100020008), 0x1.000000040008p+62, 0x1p+3 },
+{ UINT64_C(0x4000000100020080), 0x1.000000040008p+62, 0x1p+7 },
+{ UINT64_C(0x4000000100020100), 0x1.000000040008p+62, 0x1p+8 },
+{ UINT64_C(0x4000000100020200), 0x1.000000040008p+62, 0x1p+9 },
+{ UINT64_C(0x4000000100022000), 0x1.0000000400088p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100030000), 0x1.00000004000cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000100200000), 0x1.00000004008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100200004), 0x1.00000004008p+62, 0x1p+2 },
+{ UINT64_C(0x4000000100200020), 0x1.00000004008p+62, 0x1p+5 },
+{ UINT64_C(0x4000000100200080), 0x1.00000004008p+62, 0x1p+7 },
+{ UINT64_C(0x4000000100200400), 0x1.0000000400801p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100202000), 0x1.0000000400808p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100210000), 0x1.000000040084p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100300000), 0x1.0000000400cp+62, 0x0p+0 },
+{ UINT64_C(0x4000000100800000), 0x1.0000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100800004), 0x1.0000000402p+62, 0x1p+2 },
+{ UINT64_C(0x4000000100800010), 0x1.0000000402p+62, 0x1p+4 },
+{ UINT64_C(0x4000000100800040), 0x1.0000000402p+62, 0x1p+6 },
+{ UINT64_C(0x4000000100800080), 0x1.0000000402p+62, 0x1p+7 },
+{ UINT64_C(0x4000000100800100), 0x1.0000000402p+62, 0x1p+8 },
+{ UINT64_C(0x4000000100800400), 0x1.0000000402001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100804000), 0x1.000000040201p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100810000), 0x1.000000040204p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100900000), 0x1.00000004024p+62, 0x0p+0 },
+{ UINT64_C(0x4000000100c00000), 0x1.0000000403p+62, 0x0p+0 },
+{ UINT64_C(0x4000000108000000), 0x1.000000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000000108000008), 0x1.000000042p+62, 0x1p+3 },
+{ UINT64_C(0x4000000108000020), 0x1.000000042p+62, 0x1p+5 },
+{ UINT64_C(0x4000000108000040), 0x1.000000042p+62, 0x1p+6 },
+{ UINT64_C(0x4000000108000080), 0x1.000000042p+62, 0x1p+7 },
+{ UINT64_C(0x4000000108000400), 0x1.0000000420001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000108004000), 0x1.000000042001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000108020000), 0x1.000000042008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000108100000), 0x1.00000004204p+62, 0x0p+0 },
+{ UINT64_C(0x4000000108400000), 0x1.0000000421p+62, 0x0p+0 },
+{ UINT64_C(0x400000010c000000), 0x1.000000043p+62, 0x0p+0 },
+{ UINT64_C(0x4000000110000000), 0x1.000000044p+62, 0x0p+0 },
+{ UINT64_C(0x4000000110000001), 0x1.000000044p+62, 0x1p+0 },
+{ UINT64_C(0x4000000110000004), 0x1.000000044p+62, 0x1p+2 },
+{ UINT64_C(0x4000000110000010), 0x1.000000044p+62, 0x1p+4 },
+{ UINT64_C(0x4000000110000020), 0x1.000000044p+62, 0x1p+5 },
+{ UINT64_C(0x4000000110000200), 0x1.000000044p+62, 0x1p+9 },
+{ UINT64_C(0x4000000110001000), 0x1.0000000440004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000110008000), 0x1.000000044002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000110040000), 0x1.00000004401p+62, 0x0p+0 },
+{ UINT64_C(0x4000000110080000), 0x1.00000004402p+62, 0x0p+0 },
+{ UINT64_C(0x4000000110800000), 0x1.0000000442p+62, 0x0p+0 },
+{ UINT64_C(0x4000000111000000), 0x1.0000000444p+62, 0x0p+0 },
+{ UINT64_C(0x4000000118000000), 0x1.000000046p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400000004), 0x1.0000001p+62, 0x1p+2 },
+{ UINT64_C(0x4000000400000010), 0x1.0000001p+62, 0x1p+4 },
+{ UINT64_C(0x4000000400000012), 0x1.0000001p+62, 0x1.2p+4 },
+{ UINT64_C(0x4000000400000100), 0x1.0000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000000400000104), 0x1.0000001p+62, 0x1.04p+8 },
+{ UINT64_C(0x4000000400000110), 0x1.0000001p+62, 0x1.1p+8 },
+{ UINT64_C(0x4000000400000180), 0x1.0000001p+62, 0x1.8p+8 },
+{ UINT64_C(0x4000000400000200), 0x1.0000001p+62, 0x1p+9 },
+{ UINT64_C(0x4000000400000201), 0x1.0000001000001p+62, -0x1.ffp+8 },
+{ UINT64_C(0x4000000400000210), 0x1.0000001000001p+62, -0x1.fp+8 },
+{ UINT64_C(0x4000000400000300), 0x1.0000001000001p+62, -0x1p+8 },
+{ UINT64_C(0x4000000400000800), 0x1.0000001000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400000804), 0x1.0000001000002p+62, 0x1p+2 },
+{ UINT64_C(0x4000000400000808), 0x1.0000001000002p+62, 0x1p+3 },
+{ UINT64_C(0x4000000400000880), 0x1.0000001000002p+62, 0x1p+7 },
+{ UINT64_C(0x4000000400000a00), 0x1.0000001000002p+62, 0x1p+9 },
+{ UINT64_C(0x4000000400000c00), 0x1.0000001000003p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400008000), 0x1.000000100002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400008008), 0x1.000000100002p+62, 0x1p+3 },
+{ UINT64_C(0x4000000400008080), 0x1.000000100002p+62, 0x1p+7 },
+{ UINT64_C(0x4000000400008800), 0x1.0000001000022p+62, 0x0p+0 },
+{ UINT64_C(0x400000040000c000), 0x1.000000100003p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400080000), 0x1.00000010002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400080002), 0x1.00000010002p+62, 0x1p+1 },
+{ UINT64_C(0x4000000400080008), 0x1.00000010002p+62, 0x1p+3 },
+{ UINT64_C(0x4000000400080080), 0x1.00000010002p+62, 0x1p+7 },
+{ UINT64_C(0x4000000400080100), 0x1.00000010002p+62, 0x1p+8 },
+{ UINT64_C(0x4000000400080800), 0x1.0000001000202p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400081000), 0x1.0000001000204p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400088000), 0x1.000000100022p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400090000), 0x1.000000100024p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400200000), 0x1.00000010008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400200001), 0x1.00000010008p+62, 0x1p+0 },
+{ UINT64_C(0x4000000400200008), 0x1.00000010008p+62, 0x1p+3 },
+{ UINT64_C(0x4000000400200010), 0x1.00000010008p+62, 0x1p+4 },
+{ UINT64_C(0x4000000400200020), 0x1.00000010008p+62, 0x1p+5 },
+{ UINT64_C(0x4000000400200040), 0x1.00000010008p+62, 0x1p+6 },
+{ UINT64_C(0x4000000400200400), 0x1.0000001000801p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400204000), 0x1.000000100081p+62, 0x0p+0 },
+{ UINT64_C(0x4000000400220000), 0x1.000000100088p+62, 0x0p+0 },
+{ UINT64_C(0x4000000401000000), 0x1.0000001004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000401000004), 0x1.0000001004p+62, 0x1p+2 },
+{ UINT64_C(0x4000000401000008), 0x1.0000001004p+62, 0x1p+3 },
+{ UINT64_C(0x4000000401000040), 0x1.0000001004p+62, 0x1p+6 },
+{ UINT64_C(0x4000000401000100), 0x1.0000001004p+62, 0x1p+8 },
+{ UINT64_C(0x4000000401000200), 0x1.0000001004p+62, 0x1p+9 },
+{ UINT64_C(0x4000000401000800), 0x1.0000001004002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000401004000), 0x1.000000100401p+62, 0x0p+0 },
+{ UINT64_C(0x4000000401040000), 0x1.00000010041p+62, 0x0p+0 },
+{ UINT64_C(0x4000000401200000), 0x1.00000010048p+62, 0x0p+0 },
+{ UINT64_C(0x4000000401400000), 0x1.0000001005p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404000000), 0x1.000000101p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404000002), 0x1.000000101p+62, 0x1p+1 },
+{ UINT64_C(0x4000000404000008), 0x1.000000101p+62, 0x1p+3 },
+{ UINT64_C(0x4000000404000020), 0x1.000000101p+62, 0x1p+5 },
+{ UINT64_C(0x4000000404000100), 0x1.000000101p+62, 0x1p+8 },
+{ UINT64_C(0x4000000404001000), 0x1.0000001010004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404002000), 0x1.0000001010008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404010000), 0x1.000000101004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404020000), 0x1.000000101008p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404080000), 0x1.00000010102p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404100000), 0x1.00000010104p+62, 0x0p+0 },
+{ UINT64_C(0x4000000404200000), 0x1.00000010108p+62, 0x0p+0 },
+{ UINT64_C(0x4000000406000000), 0x1.0000001018p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410000000), 0x1.000000104p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410000001), 0x1.000000104p+62, 0x1p+0 },
+{ UINT64_C(0x4000000410000002), 0x1.000000104p+62, 0x1p+1 },
+{ UINT64_C(0x4000000410000004), 0x1.000000104p+62, 0x1p+2 },
+{ UINT64_C(0x4000000410000040), 0x1.000000104p+62, 0x1p+6 },
+{ UINT64_C(0x4000000410000400), 0x1.0000001040001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410001000), 0x1.0000001040004p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410004000), 0x1.000000104001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410008000), 0x1.000000104002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410080000), 0x1.00000010402p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410400000), 0x1.0000001041p+62, 0x0p+0 },
+{ UINT64_C(0x4000000410800000), 0x1.0000001042p+62, 0x0p+0 },
+{ UINT64_C(0x4000000412000000), 0x1.0000001048p+62, 0x0p+0 },
+{ UINT64_C(0x4000000418000000), 0x1.000000106p+62, 0x0p+0 },
+{ UINT64_C(0x4000000500000000), 0x1.00000014p+62, 0x0p+0 },
+{ UINT64_C(0x4000000500000004), 0x1.00000014p+62, 0x1p+2 },
+{ UINT64_C(0x4000000500000020), 0x1.00000014p+62, 0x1p+5 },
+{ UINT64_C(0x4000000500000200), 0x1.00000014p+62, 0x1p+9 },
+{ UINT64_C(0x4000000500000800), 0x1.0000001400002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000500004000), 0x1.000000140001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000500040000), 0x1.00000014001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000500400000), 0x1.0000001401p+62, 0x0p+0 },
+{ UINT64_C(0x4000000500800000), 0x1.0000001402p+62, 0x0p+0 },
+{ UINT64_C(0x4000000508000000), 0x1.000000142p+62, 0x0p+0 },
+{ UINT64_C(0x4000000540000000), 0x1.00000015p+62, 0x0p+0 },
+{ UINT64_C(0x4000000600000000), 0x1.00000018p+62, 0x0p+0 },
+{ UINT64_C(0x4000000600000004), 0x1.00000018p+62, 0x1p+2 },
+{ UINT64_C(0x4000000600000020), 0x1.00000018p+62, 0x1p+5 },
+{ UINT64_C(0x4000000600000100), 0x1.00000018p+62, 0x1p+8 },
+{ UINT64_C(0x4000000600000400), 0x1.0000001800001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000600004000), 0x1.000000180001p+62, 0x0p+0 },
+{ UINT64_C(0x4000000600008000), 0x1.000000180002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000600080000), 0x1.00000018002p+62, 0x0p+0 },
+{ UINT64_C(0x4000000600400000), 0x1.0000001801p+62, 0x0p+0 },
+{ UINT64_C(0x4000000601000000), 0x1.0000001804p+62, 0x0p+0 },
+{ UINT64_C(0x4000000604000000), 0x1.000000181p+62, 0x0p+0 },
+{ UINT64_C(0x4000000608000000), 0x1.000000182p+62, 0x0p+0 },
+{ UINT64_C(0x4000000680000000), 0x1.0000001ap+62, 0x0p+0 },
+{ UINT64_C(0x4000001000000008), 0x1.0000004p+62, 0x1p+3 },
+{ UINT64_C(0x4000001000000009), 0x1.0000004p+62, 0x1.2p+3 },
+{ UINT64_C(0x400000100000000c), 0x1.0000004p+62, 0x1.8p+3 },
+{ UINT64_C(0x4000001000000020), 0x1.0000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000001000000021), 0x1.0000004p+62, 0x1.08p+5 },
+{ UINT64_C(0x4000001000000022), 0x1.0000004p+62, 0x1.1p+5 },
+{ UINT64_C(0x4000001000000024), 0x1.0000004p+62, 0x1.2p+5 },
+{ UINT64_C(0x4000001000000080), 0x1.0000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000001000000082), 0x1.0000004p+62, 0x1.04p+7 },
+{ UINT64_C(0x4000001000000088), 0x1.0000004p+62, 0x1.1p+7 },
+{ UINT64_C(0x40000010000000c0), 0x1.0000004p+62, 0x1.8p+7 },
+{ UINT64_C(0x4000001000000100), 0x1.0000004p+62, 0x1p+8 },
+{ UINT64_C(0x4000001000000104), 0x1.0000004p+62, 0x1.04p+8 },
+{ UINT64_C(0x4000001000000140), 0x1.0000004p+62, 0x1.4p+8 },
+{ UINT64_C(0x4000001000000180), 0x1.0000004p+62, 0x1.8p+8 },
+{ UINT64_C(0x4000001000000200), 0x1.0000004p+62, 0x1p+9 },
+{ UINT64_C(0x4000001000000202), 0x1.0000004000001p+62, -0x1.fep+8 },
+{ UINT64_C(0x4000001000000204), 0x1.0000004000001p+62, -0x1.fcp+8 },
+{ UINT64_C(0x4000001000000220), 0x1.0000004000001p+62, -0x1.ep+8 },
+{ UINT64_C(0x4000001000000240), 0x1.0000004000001p+62, -0x1.cp+8 },
+{ UINT64_C(0x4000001000000280), 0x1.0000004000001p+62, -0x1.8p+8 },
+{ UINT64_C(0x4000001000000400), 0x1.0000004000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000000401), 0x1.0000004000001p+62, 0x1p+0 },
+{ UINT64_C(0x4000001000000410), 0x1.0000004000001p+62, 0x1p+4 },
+{ UINT64_C(0x4000001000000500), 0x1.0000004000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000001000000600), 0x1.0000004000002p+62, -0x1p+9 },
+{ UINT64_C(0x4000001000004000), 0x1.000000400001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000004001), 0x1.000000400001p+62, 0x1p+0 },
+{ UINT64_C(0x4000001000004010), 0x1.000000400001p+62, 0x1p+4 },
+{ UINT64_C(0x4000001000004020), 0x1.000000400001p+62, 0x1p+5 },
+{ UINT64_C(0x4000001000004200), 0x1.000000400001p+62, 0x1p+9 },
+{ UINT64_C(0x4000001000004800), 0x1.0000004000012p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000010000), 0x1.000000400004p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000010008), 0x1.000000400004p+62, 0x1p+3 },
+{ UINT64_C(0x4000001000010020), 0x1.000000400004p+62, 0x1p+5 },
+{ UINT64_C(0x4000001000010200), 0x1.000000400004p+62, 0x1p+9 },
+{ UINT64_C(0x4000001000010800), 0x1.0000004000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000011000), 0x1.0000004000044p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000080000), 0x1.00000040002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000080008), 0x1.00000040002p+62, 0x1p+3 },
+{ UINT64_C(0x4000001000080010), 0x1.00000040002p+62, 0x1p+4 },
+{ UINT64_C(0x4000001000080020), 0x1.00000040002p+62, 0x1p+5 },
+{ UINT64_C(0x4000001000080080), 0x1.00000040002p+62, 0x1p+7 },
+{ UINT64_C(0x4000001000080200), 0x1.00000040002p+62, 0x1p+9 },
+{ UINT64_C(0x4000001000080400), 0x1.0000004000201p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000082000), 0x1.0000004000208p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000088000), 0x1.000000400022p+62, 0x0p+0 },
+{ UINT64_C(0x40000010000a0000), 0x1.000000400028p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000200000), 0x1.00000040008p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000200004), 0x1.00000040008p+62, 0x1p+2 },
+{ UINT64_C(0x4000001000200008), 0x1.00000040008p+62, 0x1p+3 },
+{ UINT64_C(0x4000001000200020), 0x1.00000040008p+62, 0x1p+5 },
+{ UINT64_C(0x4000001000200040), 0x1.00000040008p+62, 0x1p+6 },
+{ UINT64_C(0x4000001000200080), 0x1.00000040008p+62, 0x1p+7 },
+{ UINT64_C(0x4000001000200400), 0x1.0000004000801p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000202000), 0x1.0000004000808p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000208000), 0x1.000000400082p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000210000), 0x1.000000400084p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000280000), 0x1.0000004000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000001000800000), 0x1.0000004002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000800001), 0x1.0000004002p+62, 0x1p+0 },
+{ UINT64_C(0x4000001000800002), 0x1.0000004002p+62, 0x1p+1 },
+{ UINT64_C(0x4000001000800020), 0x1.0000004002p+62, 0x1p+5 },
+{ UINT64_C(0x4000001000800040), 0x1.0000004002p+62, 0x1p+6 },
+{ UINT64_C(0x4000001000800200), 0x1.0000004002p+62, 0x1p+9 },
+{ UINT64_C(0x4000001000800400), 0x1.0000004002001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000802000), 0x1.0000004002008p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000820000), 0x1.000000400208p+62, 0x0p+0 },
+{ UINT64_C(0x4000001000a00000), 0x1.00000040028p+62, 0x0p+0 },
+{ UINT64_C(0x4000001004000000), 0x1.000000401p+62, 0x0p+0 },
+{ UINT64_C(0x4000001004000001), 0x1.000000401p+62, 0x1p+0 },
+{ UINT64_C(0x4000001004000008), 0x1.000000401p+62, 0x1p+3 },
+{ UINT64_C(0x4000001004000080), 0x1.000000401p+62, 0x1p+7 },
+{ UINT64_C(0x4000001004000100), 0x1.000000401p+62, 0x1p+8 },
+{ UINT64_C(0x4000001004000800), 0x1.0000004010002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001004008000), 0x1.000000401002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001004040000), 0x1.00000040101p+62, 0x0p+0 },
+{ UINT64_C(0x4000001004400000), 0x1.0000004011p+62, 0x0p+0 },
+{ UINT64_C(0x4000001005000000), 0x1.0000004014p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010000000), 0x1.000000404p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010000008), 0x1.000000404p+62, 0x1p+3 },
+{ UINT64_C(0x4000001010000080), 0x1.000000404p+62, 0x1p+7 },
+{ UINT64_C(0x4000001010000100), 0x1.000000404p+62, 0x1p+8 },
+{ UINT64_C(0x4000001010000400), 0x1.0000004040001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010000800), 0x1.0000004040002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010004000), 0x1.000000404001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010008000), 0x1.000000404002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010080000), 0x1.00000040402p+62, 0x0p+0 },
+{ UINT64_C(0x4000001010100000), 0x1.00000040404p+62, 0x0p+0 },
+{ UINT64_C(0x4000001011000000), 0x1.0000004044p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040000000), 0x1.00000041p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040000002), 0x1.00000041p+62, 0x1p+1 },
+{ UINT64_C(0x4000001040000010), 0x1.00000041p+62, 0x1p+4 },
+{ UINT64_C(0x4000001040000100), 0x1.00000041p+62, 0x1p+8 },
+{ UINT64_C(0x4000001040000800), 0x1.0000004100002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040002000), 0x1.0000004100008p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040004000), 0x1.000000410001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040010000), 0x1.000000410004p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040040000), 0x1.00000041001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040080000), 0x1.00000041002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001040400000), 0x1.0000004101p+62, 0x0p+0 },
+{ UINT64_C(0x4000001042000000), 0x1.0000004108p+62, 0x0p+0 },
+{ UINT64_C(0x4000001050000000), 0x1.000000414p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080000000), 0x1.00000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080000004), 0x1.00000042p+62, 0x1p+2 },
+{ UINT64_C(0x4000001080000040), 0x1.00000042p+62, 0x1p+6 },
+{ UINT64_C(0x4000001080000100), 0x1.00000042p+62, 0x1p+8 },
+{ UINT64_C(0x4000001080000800), 0x1.0000004200002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080002000), 0x1.0000004200008p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080008000), 0x1.000000420002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080080000), 0x1.00000042002p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080400000), 0x1.0000004201p+62, 0x0p+0 },
+{ UINT64_C(0x4000001080800000), 0x1.0000004202p+62, 0x0p+0 },
+{ UINT64_C(0x4000001081000000), 0x1.0000004204p+62, 0x0p+0 },
+{ UINT64_C(0x4000001082000000), 0x1.0000004208p+62, 0x0p+0 },
+{ UINT64_C(0x4000001084000000), 0x1.000000421p+62, 0x0p+0 },
+{ UINT64_C(0x4000001088000000), 0x1.000000422p+62, 0x0p+0 },
+{ UINT64_C(0x4000001090000000), 0x1.000000424p+62, 0x0p+0 },
+{ UINT64_C(0x4000001800000000), 0x1.0000006p+62, 0x0p+0 },
+{ UINT64_C(0x4000001800000008), 0x1.0000006p+62, 0x1p+3 },
+{ UINT64_C(0x4000001800000040), 0x1.0000006p+62, 0x1p+6 },
+{ UINT64_C(0x4000001800000200), 0x1.0000006p+62, 0x1p+9 },
+{ UINT64_C(0x4000001800000400), 0x1.0000006000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000001800002000), 0x1.0000006000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000001800010000), 0x1.000000600004p+62, 0x0p+0 },
+{ UINT64_C(0x4000001800100000), 0x1.00000060004p+62, 0x0p+0 },
+{ UINT64_C(0x4000001801000000), 0x1.0000006004p+62, 0x0p+0 },
+{ UINT64_C(0x4000001802000000), 0x1.0000006008p+62, 0x0p+0 },
+{ UINT64_C(0x4000001808000000), 0x1.000000602p+62, 0x0p+0 },
+{ UINT64_C(0x4000001820000000), 0x1.000000608p+62, 0x0p+0 },
+{ UINT64_C(0x4000001a00000000), 0x1.00000068p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000000008), 0x1.000002p+62, 0x1p+3 },
+{ UINT64_C(0x400000800000000c), 0x1.000002p+62, 0x1.8p+3 },
+{ UINT64_C(0x4000008000000010), 0x1.000002p+62, 0x1p+4 },
+{ UINT64_C(0x4000008000000012), 0x1.000002p+62, 0x1.2p+4 },
+{ UINT64_C(0x4000008000000080), 0x1.000002p+62, 0x1p+7 },
+{ UINT64_C(0x4000008000000088), 0x1.000002p+62, 0x1.1p+7 },
+{ UINT64_C(0x4000008000000100), 0x1.000002p+62, 0x1p+8 },
+{ UINT64_C(0x4000008000000102), 0x1.000002p+62, 0x1.02p+8 },
+{ UINT64_C(0x4000008000000104), 0x1.000002p+62, 0x1.04p+8 },
+{ UINT64_C(0x4000008000000140), 0x1.000002p+62, 0x1.4p+8 },
+{ UINT64_C(0x4000008000000180), 0x1.000002p+62, 0x1.8p+8 },
+{ UINT64_C(0x4000008000000400), 0x1.0000020000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000000402), 0x1.0000020000001p+62, 0x1p+1 },
+{ UINT64_C(0x4000008000000404), 0x1.0000020000001p+62, 0x1p+2 },
+{ UINT64_C(0x4000008000000408), 0x1.0000020000001p+62, 0x1p+3 },
+{ UINT64_C(0x4000008000000410), 0x1.0000020000001p+62, 0x1p+4 },
+{ UINT64_C(0x4000008000000480), 0x1.0000020000001p+62, 0x1p+7 },
+{ UINT64_C(0x4000008000000500), 0x1.0000020000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000008000000600), 0x1.0000020000002p+62, -0x1p+9 },
+{ UINT64_C(0x4000008000001000), 0x1.0000020000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000001001), 0x1.0000020000004p+62, 0x1p+0 },
+{ UINT64_C(0x4000008000001010), 0x1.0000020000004p+62, 0x1p+4 },
+{ UINT64_C(0x4000008000001040), 0x1.0000020000004p+62, 0x1p+6 },
+{ UINT64_C(0x4000008000001080), 0x1.0000020000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000008000001200), 0x1.0000020000004p+62, 0x1p+9 },
+{ UINT64_C(0x4000008000004000), 0x1.000002000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000004001), 0x1.000002000001p+62, 0x1p+0 },
+{ UINT64_C(0x4000008000004010), 0x1.000002000001p+62, 0x1p+4 },
+{ UINT64_C(0x4000008000004100), 0x1.000002000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000008000004400), 0x1.0000020000011p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000004800), 0x1.0000020000012p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000008000), 0x1.000002000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000008008), 0x1.000002000002p+62, 0x1p+3 },
+{ UINT64_C(0x4000008000008080), 0x1.000002000002p+62, 0x1p+7 },
+{ UINT64_C(0x4000008000008400), 0x1.0000020000021p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000009000), 0x1.0000020000024p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000010000), 0x1.000002000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000010002), 0x1.000002000004p+62, 0x1p+1 },
+{ UINT64_C(0x4000008000010020), 0x1.000002000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000008000010100), 0x1.000002000004p+62, 0x1p+8 },
+{ UINT64_C(0x4000008000011000), 0x1.0000020000044p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000100000), 0x1.00000200004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000100002), 0x1.00000200004p+62, 0x1p+1 },
+{ UINT64_C(0x4000008000100008), 0x1.00000200004p+62, 0x1p+3 },
+{ UINT64_C(0x4000008000100080), 0x1.00000200004p+62, 0x1p+7 },
+{ UINT64_C(0x4000008000100200), 0x1.00000200004p+62, 0x1p+9 },
+{ UINT64_C(0x4000008000100400), 0x1.0000020000401p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000101000), 0x1.0000020000404p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000102000), 0x1.0000020000408p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000108000), 0x1.000002000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000140000), 0x1.00000200005p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000200000), 0x1.00000200008p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000200002), 0x1.00000200008p+62, 0x1p+1 },
+{ UINT64_C(0x4000008000200010), 0x1.00000200008p+62, 0x1p+4 },
+{ UINT64_C(0x4000008000200040), 0x1.00000200008p+62, 0x1p+6 },
+{ UINT64_C(0x4000008000200080), 0x1.00000200008p+62, 0x1p+7 },
+{ UINT64_C(0x4000008000200100), 0x1.00000200008p+62, 0x1p+8 },
+{ UINT64_C(0x4000008000200800), 0x1.0000020000802p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000208000), 0x1.000002000082p+62, 0x0p+0 },
+{ UINT64_C(0x4000008000280000), 0x1.0000020000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000008000300000), 0x1.0000020000cp+62, 0x0p+0 },
+{ UINT64_C(0x4000008002000000), 0x1.0000020008p+62, 0x0p+0 },
+{ UINT64_C(0x4000008002000002), 0x1.0000020008p+62, 0x1p+1 },
+{ UINT64_C(0x4000008002000004), 0x1.0000020008p+62, 0x1p+2 },
+{ UINT64_C(0x4000008002000020), 0x1.0000020008p+62, 0x1p+5 },
+{ UINT64_C(0x4000008002000080), 0x1.0000020008p+62, 0x1p+7 },
+{ UINT64_C(0x4000008002000400), 0x1.0000020008001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008002002000), 0x1.0000020008008p+62, 0x0p+0 },
+{ UINT64_C(0x4000008002004000), 0x1.000002000801p+62, 0x0p+0 },
+{ UINT64_C(0x4000008002020000), 0x1.000002000808p+62, 0x0p+0 },
+{ UINT64_C(0x4000008002200000), 0x1.00000200088p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004000000), 0x1.000002001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004000008), 0x1.000002001p+62, 0x1p+3 },
+{ UINT64_C(0x4000008004000020), 0x1.000002001p+62, 0x1p+5 },
+{ UINT64_C(0x4000008004000080), 0x1.000002001p+62, 0x1p+7 },
+{ UINT64_C(0x4000008004000800), 0x1.0000020010002p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004002000), 0x1.0000020010008p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004008000), 0x1.000002001002p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004010000), 0x1.000002001004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004040000), 0x1.00000200101p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004080000), 0x1.00000200102p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004100000), 0x1.00000200104p+62, 0x0p+0 },
+{ UINT64_C(0x4000008004400000), 0x1.0000020011p+62, 0x0p+0 },
+{ UINT64_C(0x4000008010000000), 0x1.000002004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008010000008), 0x1.000002004p+62, 0x1p+3 },
+{ UINT64_C(0x4000008010000020), 0x1.000002004p+62, 0x1p+5 },
+{ UINT64_C(0x4000008010000040), 0x1.000002004p+62, 0x1p+6 },
+{ UINT64_C(0x4000008010000100), 0x1.000002004p+62, 0x1p+8 },
+{ UINT64_C(0x4000008010000200), 0x1.000002004p+62, 0x1p+9 },
+{ UINT64_C(0x4000008010001000), 0x1.0000020040004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008010004000), 0x1.000002004001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008010040000), 0x1.00000200401p+62, 0x0p+0 },
+{ UINT64_C(0x4000008010400000), 0x1.0000020041p+62, 0x0p+0 },
+{ UINT64_C(0x4000008012000000), 0x1.0000020048p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080000000), 0x1.00000202p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080000004), 0x1.00000202p+62, 0x1p+2 },
+{ UINT64_C(0x4000008080000020), 0x1.00000202p+62, 0x1p+5 },
+{ UINT64_C(0x4000008080000200), 0x1.00000202p+62, 0x1p+9 },
+{ UINT64_C(0x4000008080000400), 0x1.0000020200001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080004000), 0x1.000002020001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080008000), 0x1.000002020002p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080010000), 0x1.000002020004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080080000), 0x1.00000202002p+62, 0x0p+0 },
+{ UINT64_C(0x4000008080400000), 0x1.0000020201p+62, 0x0p+0 },
+{ UINT64_C(0x4000008081000000), 0x1.0000020204p+62, 0x0p+0 },
+{ UINT64_C(0x4000008088000000), 0x1.000002022p+62, 0x0p+0 },
+{ UINT64_C(0x4000008800000000), 0x1.0000022p+62, 0x0p+0 },
+{ UINT64_C(0x4000008800000008), 0x1.0000022p+62, 0x1p+3 },
+{ UINT64_C(0x4000008800000010), 0x1.0000022p+62, 0x1p+4 },
+{ UINT64_C(0x4000008800000020), 0x1.0000022p+62, 0x1p+5 },
+{ UINT64_C(0x4000008800000100), 0x1.0000022p+62, 0x1p+8 },
+{ UINT64_C(0x4000008800000800), 0x1.0000022000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000008800004000), 0x1.000002200001p+62, 0x0p+0 },
+{ UINT64_C(0x4000008800010000), 0x1.000002200004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008800100000), 0x1.00000220004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008801000000), 0x1.0000022004p+62, 0x0p+0 },
+{ UINT64_C(0x4000008808000000), 0x1.000002202p+62, 0x0p+0 },
+{ UINT64_C(0x4000008880000000), 0x1.00000222p+62, 0x0p+0 },
+{ UINT64_C(0x4000008a00000000), 0x1.00000228p+62, 0x0p+0 },
+{ UINT64_C(0x400000a000000000), 0x1.0000028p+62, 0x0p+0 },
+{ UINT64_C(0x400000a000000002), 0x1.0000028p+62, 0x1p+1 },
+{ UINT64_C(0x400000a000000010), 0x1.0000028p+62, 0x1p+4 },
+{ UINT64_C(0x400000a000000020), 0x1.0000028p+62, 0x1p+5 },
+{ UINT64_C(0x400000a000000080), 0x1.0000028p+62, 0x1p+7 },
+{ UINT64_C(0x400000a000000400), 0x1.0000028000001p+62, 0x0p+0 },
+{ UINT64_C(0x400000a000002000), 0x1.0000028000008p+62, 0x0p+0 },
+{ UINT64_C(0x400000a000020000), 0x1.000002800008p+62, 0x0p+0 },
+{ UINT64_C(0x400000a000080000), 0x1.00000280002p+62, 0x0p+0 },
+{ UINT64_C(0x400000a000800000), 0x1.0000028002p+62, 0x0p+0 },
+{ UINT64_C(0x400000a002000000), 0x1.0000028008p+62, 0x0p+0 },
+{ UINT64_C(0x400000a020000000), 0x1.000002808p+62, 0x0p+0 },
+{ UINT64_C(0x400000a200000000), 0x1.00000288p+62, 0x0p+0 },
+{ UINT64_C(0x400000a800000000), 0x1.000002ap+62, 0x0p+0 },
+{ UINT64_C(0x400000b000000000), 0x1.000002cp+62, 0x0p+0 },
+{ UINT64_C(0x4000080000000004), 0x1.00002p+62, 0x1p+2 },
+{ UINT64_C(0x4000080000000010), 0x1.00002p+62, 0x1p+4 },
+{ UINT64_C(0x4000080000000014), 0x1.00002p+62, 0x1.4p+4 },
+{ UINT64_C(0x4000080000000018), 0x1.00002p+62, 0x1.8p+4 },
+{ UINT64_C(0x4000080000000040), 0x1.00002p+62, 0x1p+6 },
+{ UINT64_C(0x4000080000000041), 0x1.00002p+62, 0x1.04p+6 },
+{ UINT64_C(0x4000080000000044), 0x1.00002p+62, 0x1.1p+6 },
+{ UINT64_C(0x4000080000000100), 0x1.00002p+62, 0x1p+8 },
+{ UINT64_C(0x4000080000000108), 0x1.00002p+62, 0x1.08p+8 },
+{ UINT64_C(0x4000080000000140), 0x1.00002p+62, 0x1.4p+8 },
+{ UINT64_C(0x4000080000000400), 0x1.0000200000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000000401), 0x1.0000200000001p+62, 0x1p+0 },
+{ UINT64_C(0x4000080000000410), 0x1.0000200000001p+62, 0x1p+4 },
+{ UINT64_C(0x4000080000000480), 0x1.0000200000001p+62, 0x1p+7 },
+{ UINT64_C(0x4000080000000500), 0x1.0000200000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000080000000600), 0x1.0000200000002p+62, -0x1p+9 },
+{ UINT64_C(0x4000080000002000), 0x1.0000200000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000002004), 0x1.0000200000008p+62, 0x1p+2 },
+{ UINT64_C(0x4000080000002010), 0x1.0000200000008p+62, 0x1p+4 },
+{ UINT64_C(0x4000080000002080), 0x1.0000200000008p+62, 0x1p+7 },
+{ UINT64_C(0x4000080000002200), 0x1.0000200000008p+62, 0x1p+9 },
+{ UINT64_C(0x4000080000010000), 0x1.000020000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000010004), 0x1.000020000004p+62, 0x1p+2 },
+{ UINT64_C(0x4000080000010020), 0x1.000020000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000080000010100), 0x1.000020000004p+62, 0x1p+8 },
+{ UINT64_C(0x4000080000010200), 0x1.000020000004p+62, 0x1p+9 },
+{ UINT64_C(0x4000080000010800), 0x1.0000200000042p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000011000), 0x1.0000200000044p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000018000), 0x1.000020000006p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000040000), 0x1.00002000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000040001), 0x1.00002000001p+62, 0x1p+0 },
+{ UINT64_C(0x4000080000040002), 0x1.00002000001p+62, 0x1p+1 },
+{ UINT64_C(0x4000080000040008), 0x1.00002000001p+62, 0x1p+3 },
+{ UINT64_C(0x4000080000040080), 0x1.00002000001p+62, 0x1p+7 },
+{ UINT64_C(0x4000080000040100), 0x1.00002000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000080000040400), 0x1.0000200000101p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000042000), 0x1.0000200000108p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000060000), 0x1.000020000018p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000100000), 0x1.00002000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000100001), 0x1.00002000004p+62, 0x1p+0 },
+{ UINT64_C(0x4000080000100010), 0x1.00002000004p+62, 0x1p+4 },
+{ UINT64_C(0x4000080000100020), 0x1.00002000004p+62, 0x1p+5 },
+{ UINT64_C(0x4000080000100080), 0x1.00002000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000080000100800), 0x1.0000200000402p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000101000), 0x1.0000200000404p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000110000), 0x1.000020000044p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000180000), 0x1.00002000006p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000400000), 0x1.0000200001p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000400004), 0x1.0000200001p+62, 0x1p+2 },
+{ UINT64_C(0x4000080000400040), 0x1.0000200001p+62, 0x1p+6 },
+{ UINT64_C(0x4000080000400200), 0x1.0000200001p+62, 0x1p+9 },
+{ UINT64_C(0x4000080000400800), 0x1.0000200001002p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000404000), 0x1.000020000101p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000410000), 0x1.000020000104p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000440000), 0x1.00002000011p+62, 0x0p+0 },
+{ UINT64_C(0x4000080000600000), 0x1.00002000018p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002000000), 0x1.0000200008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002000008), 0x1.0000200008p+62, 0x1p+3 },
+{ UINT64_C(0x4000080002000040), 0x1.0000200008p+62, 0x1p+6 },
+{ UINT64_C(0x4000080002000400), 0x1.0000200008001p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002000800), 0x1.0000200008002p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002002000), 0x1.0000200008008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002010000), 0x1.000020000804p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002080000), 0x1.00002000082p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002100000), 0x1.00002000084p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002200000), 0x1.00002000088p+62, 0x0p+0 },
+{ UINT64_C(0x4000080002400000), 0x1.0000200009p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008000000), 0x1.000020002p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008000008), 0x1.000020002p+62, 0x1p+3 },
+{ UINT64_C(0x4000080008000010), 0x1.000020002p+62, 0x1p+4 },
+{ UINT64_C(0x4000080008000100), 0x1.000020002p+62, 0x1p+8 },
+{ UINT64_C(0x4000080008001000), 0x1.0000200020004p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008002000), 0x1.0000200020008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008010000), 0x1.000020002004p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008040000), 0x1.00002000201p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008080000), 0x1.00002000202p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008100000), 0x1.00002000204p+62, 0x0p+0 },
+{ UINT64_C(0x4000080008400000), 0x1.0000200021p+62, 0x0p+0 },
+{ UINT64_C(0x400008000c000000), 0x1.000020003p+62, 0x0p+0 },
+{ UINT64_C(0x4000080080000000), 0x1.00002002p+62, 0x0p+0 },
+{ UINT64_C(0x4000080080000004), 0x1.00002002p+62, 0x1p+2 },
+{ UINT64_C(0x4000080080000010), 0x1.00002002p+62, 0x1p+4 },
+{ UINT64_C(0x4000080080000100), 0x1.00002002p+62, 0x1p+8 },
+{ UINT64_C(0x4000080080000200), 0x1.00002002p+62, 0x1p+9 },
+{ UINT64_C(0x4000080080002000), 0x1.0000200200008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080080020000), 0x1.000020020008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080080080000), 0x1.00002002002p+62, 0x0p+0 },
+{ UINT64_C(0x4000080080800000), 0x1.0000200202p+62, 0x0p+0 },
+{ UINT64_C(0x4000080082000000), 0x1.0000200208p+62, 0x0p+0 },
+{ UINT64_C(0x4000080088000000), 0x1.000020022p+62, 0x0p+0 },
+{ UINT64_C(0x40000800a0000000), 0x1.000020028p+62, 0x0p+0 },
+{ UINT64_C(0x4000080400000000), 0x1.0000201p+62, 0x0p+0 },
+{ UINT64_C(0x4000080400000002), 0x1.0000201p+62, 0x1p+1 },
+{ UINT64_C(0x4000080400000004), 0x1.0000201p+62, 0x1p+2 },
+{ UINT64_C(0x4000080400000040), 0x1.0000201p+62, 0x1p+6 },
+{ UINT64_C(0x4000080400000200), 0x1.0000201p+62, 0x1p+9 },
+{ UINT64_C(0x4000080400000800), 0x1.0000201000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000080400002000), 0x1.0000201000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080400010000), 0x1.000020100004p+62, 0x0p+0 },
+{ UINT64_C(0x4000080400040000), 0x1.00002010001p+62, 0x0p+0 },
+{ UINT64_C(0x4000080400400000), 0x1.0000201001p+62, 0x0p+0 },
+{ UINT64_C(0x4000080402000000), 0x1.0000201008p+62, 0x0p+0 },
+{ UINT64_C(0x4000080404000000), 0x1.000020101p+62, 0x0p+0 },
+{ UINT64_C(0x4000080440000000), 0x1.00002011p+62, 0x0p+0 },
+{ UINT64_C(0x4000080600000000), 0x1.00002018p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000000000), 0x1.0000204p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000000008), 0x1.0000204p+62, 0x1p+3 },
+{ UINT64_C(0x4000081000000010), 0x1.0000204p+62, 0x1p+4 },
+{ UINT64_C(0x4000081000000020), 0x1.0000204p+62, 0x1p+5 },
+{ UINT64_C(0x4000081000000200), 0x1.0000204p+62, 0x1p+9 },
+{ UINT64_C(0x4000081000000400), 0x1.0000204000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000001000), 0x1.0000204000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000004000), 0x1.000020400001p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000020000), 0x1.000020400008p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000040000), 0x1.00002040001p+62, 0x0p+0 },
+{ UINT64_C(0x4000081000400000), 0x1.0000204001p+62, 0x0p+0 },
+{ UINT64_C(0x4000081002000000), 0x1.0000204008p+62, 0x0p+0 },
+{ UINT64_C(0x4000081008000000), 0x1.000020402p+62, 0x0p+0 },
+{ UINT64_C(0x4000081020000000), 0x1.000020408p+62, 0x0p+0 },
+{ UINT64_C(0x4000081100000000), 0x1.00002044p+62, 0x0p+0 },
+{ UINT64_C(0x4000081800000000), 0x1.0000206p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000000000), 0x1.000022p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000000002), 0x1.000022p+62, 0x1p+1 },
+{ UINT64_C(0x4000088000000010), 0x1.000022p+62, 0x1p+4 },
+{ UINT64_C(0x4000088000000040), 0x1.000022p+62, 0x1p+6 },
+{ UINT64_C(0x4000088000000400), 0x1.0000220000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000002000), 0x1.0000220000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000010000), 0x1.000022000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000020000), 0x1.000022000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000100000), 0x1.00002200004p+62, 0x0p+0 },
+{ UINT64_C(0x4000088000400000), 0x1.0000220001p+62, 0x0p+0 },
+{ UINT64_C(0x4000088001000000), 0x1.0000220004p+62, 0x0p+0 },
+{ UINT64_C(0x4000088004000000), 0x1.000022001p+62, 0x0p+0 },
+{ UINT64_C(0x4000088040000000), 0x1.00002201p+62, 0x0p+0 },
+{ UINT64_C(0x4000088100000000), 0x1.00002204p+62, 0x0p+0 },
+{ UINT64_C(0x4000088200000000), 0x1.00002208p+62, 0x0p+0 },
+{ UINT64_C(0x4000088800000000), 0x1.0000222p+62, 0x0p+0 },
+{ UINT64_C(0x400008a000000000), 0x1.0000228p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000000004), 0x1.0001p+62, 0x1p+2 },
+{ UINT64_C(0x4000400000000020), 0x1.0001p+62, 0x1p+5 },
+{ UINT64_C(0x4000400000000021), 0x1.0001p+62, 0x1.08p+5 },
+{ UINT64_C(0x4000400000000028), 0x1.0001p+62, 0x1.4p+5 },
+{ UINT64_C(0x4000400000000040), 0x1.0001p+62, 0x1p+6 },
+{ UINT64_C(0x4000400000000042), 0x1.0001p+62, 0x1.08p+6 },
+{ UINT64_C(0x4000400000000044), 0x1.0001p+62, 0x1.1p+6 },
+{ UINT64_C(0x4000400000000400), 0x1.0001000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000000408), 0x1.0001000000001p+62, 0x1p+3 },
+{ UINT64_C(0x4000400000000440), 0x1.0001000000001p+62, 0x1p+6 },
+{ UINT64_C(0x4000400000000480), 0x1.0001000000001p+62, 0x1p+7 },
+{ UINT64_C(0x4000400000001000), 0x1.0001000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000001002), 0x1.0001000000004p+62, 0x1p+1 },
+{ UINT64_C(0x4000400000001010), 0x1.0001000000004p+62, 0x1p+4 },
+{ UINT64_C(0x4000400000001040), 0x1.0001000000004p+62, 0x1p+6 },
+{ UINT64_C(0x4000400000001080), 0x1.0001000000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000400000001200), 0x1.0001000000004p+62, 0x1p+9 },
+{ UINT64_C(0x4000400000001800), 0x1.0001000000006p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000002000), 0x1.0001000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000002001), 0x1.0001000000008p+62, 0x1p+0 },
+{ UINT64_C(0x4000400000002010), 0x1.0001000000008p+62, 0x1p+4 },
+{ UINT64_C(0x4000400000002100), 0x1.0001000000008p+62, 0x1p+8 },
+{ UINT64_C(0x4000400000003000), 0x1.000100000000cp+62, 0x0p+0 },
+{ UINT64_C(0x4000400000010000), 0x1.000100000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000010001), 0x1.000100000004p+62, 0x1p+0 },
+{ UINT64_C(0x4000400000010008), 0x1.000100000004p+62, 0x1p+3 },
+{ UINT64_C(0x4000400000010040), 0x1.000100000004p+62, 0x1p+6 },
+{ UINT64_C(0x4000400000010080), 0x1.000100000004p+62, 0x1p+7 },
+{ UINT64_C(0x4000400000010400), 0x1.0001000000041p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000012000), 0x1.0001000000048p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000020000), 0x1.000100000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000020004), 0x1.000100000008p+62, 0x1p+2 },
+{ UINT64_C(0x4000400000020040), 0x1.000100000008p+62, 0x1p+6 },
+{ UINT64_C(0x4000400000020100), 0x1.000100000008p+62, 0x1p+8 },
+{ UINT64_C(0x4000400000021000), 0x1.0001000000084p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000028000), 0x1.00010000000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000400000040000), 0x1.00010000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000040001), 0x1.00010000001p+62, 0x1p+0 },
+{ UINT64_C(0x4000400000040002), 0x1.00010000001p+62, 0x1p+1 },
+{ UINT64_C(0x4000400000040020), 0x1.00010000001p+62, 0x1p+5 },
+{ UINT64_C(0x4000400000040100), 0x1.00010000001p+62, 0x1p+8 },
+{ UINT64_C(0x4000400000041000), 0x1.0001000000104p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000050000), 0x1.000100000014p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000400000), 0x1.0001000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000400002), 0x1.0001000001p+62, 0x1p+1 },
+{ UINT64_C(0x4000400000400020), 0x1.0001000001p+62, 0x1p+5 },
+{ UINT64_C(0x4000400000400080), 0x1.0001000001p+62, 0x1p+7 },
+{ UINT64_C(0x4000400000400400), 0x1.0001000001001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000404000), 0x1.000100000101p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000440000), 0x1.00010000011p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000500000), 0x1.00010000014p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000800000), 0x1.0001000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000800002), 0x1.0001000002p+62, 0x1p+1 },
+{ UINT64_C(0x4000400000800020), 0x1.0001000002p+62, 0x1p+5 },
+{ UINT64_C(0x4000400000800040), 0x1.0001000002p+62, 0x1p+6 },
+{ UINT64_C(0x4000400000800400), 0x1.0001000002001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000802000), 0x1.0001000002008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000808000), 0x1.000100000202p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000880000), 0x1.00010000022p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000900000), 0x1.00010000024p+62, 0x0p+0 },
+{ UINT64_C(0x4000400000c00000), 0x1.0001000003p+62, 0x0p+0 },
+{ UINT64_C(0x4000400008000000), 0x1.000100002p+62, 0x0p+0 },
+{ UINT64_C(0x4000400008000002), 0x1.000100002p+62, 0x1p+1 },
+{ UINT64_C(0x4000400008000008), 0x1.000100002p+62, 0x1p+3 },
+{ UINT64_C(0x4000400008000010), 0x1.000100002p+62, 0x1p+4 },
+{ UINT64_C(0x4000400008000020), 0x1.000100002p+62, 0x1p+5 },
+{ UINT64_C(0x4000400008000040), 0x1.000100002p+62, 0x1p+6 },
+{ UINT64_C(0x4000400008000200), 0x1.000100002p+62, 0x1p+9 },
+{ UINT64_C(0x4000400008001000), 0x1.0001000020004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400008010000), 0x1.000100002004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400008080000), 0x1.00010000202p+62, 0x0p+0 },
+{ UINT64_C(0x4000400008800000), 0x1.0001000022p+62, 0x0p+0 },
+{ UINT64_C(0x4000400009000000), 0x1.0001000024p+62, 0x0p+0 },
+{ UINT64_C(0x400040000c000000), 0x1.000100003p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020000000), 0x1.000100008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020000004), 0x1.000100008p+62, 0x1p+2 },
+{ UINT64_C(0x4000400020000020), 0x1.000100008p+62, 0x1p+5 },
+{ UINT64_C(0x4000400020000100), 0x1.000100008p+62, 0x1p+8 },
+{ UINT64_C(0x4000400020001000), 0x1.0001000080004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020002000), 0x1.0001000080008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020004000), 0x1.000100008001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020008000), 0x1.000100008002p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020010000), 0x1.000100008004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020020000), 0x1.000100008008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020080000), 0x1.00010000802p+62, 0x0p+0 },
+{ UINT64_C(0x4000400020800000), 0x1.0001000082p+62, 0x0p+0 },
+{ UINT64_C(0x4000400021000000), 0x1.0001000084p+62, 0x0p+0 },
+{ UINT64_C(0x4000400028000000), 0x1.00010000ap+62, 0x0p+0 },
+{ UINT64_C(0x4000400030000000), 0x1.00010000cp+62, 0x0p+0 },
+{ UINT64_C(0x4000400040000000), 0x1.00010001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400040000008), 0x1.00010001p+62, 0x1p+3 },
+{ UINT64_C(0x4000400040000040), 0x1.00010001p+62, 0x1p+6 },
+{ UINT64_C(0x4000400040000080), 0x1.00010001p+62, 0x1p+7 },
+{ UINT64_C(0x4000400040000100), 0x1.00010001p+62, 0x1p+8 },
+{ UINT64_C(0x4000400040001000), 0x1.0001000100004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400040010000), 0x1.000100010004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400040040000), 0x1.00010001001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400040400000), 0x1.0001000101p+62, 0x0p+0 },
+{ UINT64_C(0x4000400044000000), 0x1.000100011p+62, 0x0p+0 },
+{ UINT64_C(0x4000400060000000), 0x1.000100018p+62, 0x0p+0 },
+{ UINT64_C(0x4000400400000000), 0x1.0001001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400400000002), 0x1.0001001p+62, 0x1p+1 },
+{ UINT64_C(0x4000400400000020), 0x1.0001001p+62, 0x1p+5 },
+{ UINT64_C(0x4000400400000200), 0x1.0001001p+62, 0x1p+9 },
+{ UINT64_C(0x4000400400000400), 0x1.0001001000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400400002000), 0x1.0001001000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400400020000), 0x1.000100100008p+62, 0x0p+0 },
+{ UINT64_C(0x4000400400100000), 0x1.00010010004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400400400000), 0x1.0001001001p+62, 0x0p+0 },
+{ UINT64_C(0x4000400401000000), 0x1.0001001004p+62, 0x0p+0 },
+{ UINT64_C(0x4000400408000000), 0x1.000100102p+62, 0x0p+0 },
+{ UINT64_C(0x4000400420000000), 0x1.000100108p+62, 0x0p+0 },
+{ UINT64_C(0x4000400440000000), 0x1.00010011p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000000000), 0x1.0001004p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000000004), 0x1.0001004p+62, 0x1p+2 },
+{ UINT64_C(0x4000401000000020), 0x1.0001004p+62, 0x1p+5 },
+{ UINT64_C(0x4000401000000040), 0x1.0001004p+62, 0x1p+6 },
+{ UINT64_C(0x4000401000000080), 0x1.0001004p+62, 0x1p+7 },
+{ UINT64_C(0x4000401000000100), 0x1.0001004p+62, 0x1p+8 },
+{ UINT64_C(0x4000401000001000), 0x1.0001004000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000002000), 0x1.0001004000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000008000), 0x1.000100400002p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000040000), 0x1.00010040001p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000080000), 0x1.00010040002p+62, 0x0p+0 },
+{ UINT64_C(0x4000401000800000), 0x1.0001004002p+62, 0x0p+0 },
+{ UINT64_C(0x4000401001000000), 0x1.0001004004p+62, 0x0p+0 },
+{ UINT64_C(0x4000401002000000), 0x1.0001004008p+62, 0x0p+0 },
+{ UINT64_C(0x4000401020000000), 0x1.000100408p+62, 0x0p+0 },
+{ UINT64_C(0x4000401200000000), 0x1.00010048p+62, 0x0p+0 },
+{ UINT64_C(0x4000404000000000), 0x1.000101p+62, 0x0p+0 },
+{ UINT64_C(0x4000404000000002), 0x1.000101p+62, 0x1p+1 },
+{ UINT64_C(0x4000404000000008), 0x1.000101p+62, 0x1p+3 },
+{ UINT64_C(0x4000404000000080), 0x1.000101p+62, 0x1p+7 },
+{ UINT64_C(0x4000404000000100), 0x1.000101p+62, 0x1p+8 },
+{ UINT64_C(0x4000404000001000), 0x1.0001010000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000404000004000), 0x1.000101000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000404000008000), 0x1.000101000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000404000020000), 0x1.000101000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000404000200000), 0x1.00010100008p+62, 0x0p+0 },
+{ UINT64_C(0x4000404002000000), 0x1.0001010008p+62, 0x0p+0 },
+{ UINT64_C(0x4000404008000000), 0x1.000101002p+62, 0x0p+0 },
+{ UINT64_C(0x4000404040000000), 0x1.00010101p+62, 0x0p+0 },
+{ UINT64_C(0x4000404080000000), 0x1.00010102p+62, 0x0p+0 },
+{ UINT64_C(0x4000404100000000), 0x1.00010104p+62, 0x0p+0 },
+{ UINT64_C(0x4000404200000000), 0x1.00010108p+62, 0x0p+0 },
+{ UINT64_C(0x4000404800000000), 0x1.0001012p+62, 0x0p+0 },
+{ UINT64_C(0x4000406000000000), 0x1.0001018p+62, 0x0p+0 },
+{ UINT64_C(0x4000408000000000), 0x1.000102p+62, 0x0p+0 },
+{ UINT64_C(0x4000408000000002), 0x1.000102p+62, 0x1p+1 },
+{ UINT64_C(0x4000408000000020), 0x1.000102p+62, 0x1p+5 },
+{ UINT64_C(0x4000408000000080), 0x1.000102p+62, 0x1p+7 },
+{ UINT64_C(0x4000408000000100), 0x1.000102p+62, 0x1p+8 },
+{ UINT64_C(0x4000408000000400), 0x1.0001020000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000408000001000), 0x1.0001020000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000408000010000), 0x1.000102000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000408000020000), 0x1.000102000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000408000100000), 0x1.00010200004p+62, 0x0p+0 },
+{ UINT64_C(0x4000408001000000), 0x1.0001020004p+62, 0x0p+0 },
+{ UINT64_C(0x4000408002000000), 0x1.0001020008p+62, 0x0p+0 },
+{ UINT64_C(0x4000408008000000), 0x1.000102002p+62, 0x0p+0 },
+{ UINT64_C(0x4000408080000000), 0x1.00010202p+62, 0x0p+0 },
+{ UINT64_C(0x4000408400000000), 0x1.0001021p+62, 0x0p+0 },
+{ UINT64_C(0x4000409000000000), 0x1.0001024p+62, 0x0p+0 },
+{ UINT64_C(0x4000440000000000), 0x1.00011p+62, 0x0p+0 },
+{ UINT64_C(0x4000440000000001), 0x1.00011p+62, 0x1p+0 },
+{ UINT64_C(0x4000440000000002), 0x1.00011p+62, 0x1p+1 },
+{ UINT64_C(0x4000440000000008), 0x1.00011p+62, 0x1p+3 },
+{ UINT64_C(0x4000440000000040), 0x1.00011p+62, 0x1p+6 },
+{ UINT64_C(0x4000440000000080), 0x1.00011p+62, 0x1p+7 },
+{ UINT64_C(0x4000440000000200), 0x1.00011p+62, 0x1p+9 },
+{ UINT64_C(0x4000440000002000), 0x1.0001100000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000440000010000), 0x1.000110000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000440000080000), 0x1.00011000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000440000100000), 0x1.00011000004p+62, 0x0p+0 },
+{ UINT64_C(0x4000440000200000), 0x1.00011000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000440001000000), 0x1.0001100004p+62, 0x0p+0 },
+{ UINT64_C(0x4000440002000000), 0x1.0001100008p+62, 0x0p+0 },
+{ UINT64_C(0x4000440010000000), 0x1.000110004p+62, 0x0p+0 },
+{ UINT64_C(0x4000440100000000), 0x1.00011004p+62, 0x0p+0 },
+{ UINT64_C(0x4000440200000000), 0x1.00011008p+62, 0x0p+0 },
+{ UINT64_C(0x4000440400000000), 0x1.0001101p+62, 0x0p+0 },
+{ UINT64_C(0x4000442000000000), 0x1.0001108p+62, 0x0p+0 },
+{ UINT64_C(0x4000460000000000), 0x1.000118p+62, 0x0p+0 },
+{ UINT64_C(0x4000500000000000), 0x1.00014p+62, 0x0p+0 },
+{ UINT64_C(0x4000500000000004), 0x1.00014p+62, 0x1p+2 },
+{ UINT64_C(0x4000500000000020), 0x1.00014p+62, 0x1p+5 },
+{ UINT64_C(0x4000500000000040), 0x1.00014p+62, 0x1p+6 },
+{ UINT64_C(0x4000500000000080), 0x1.00014p+62, 0x1p+7 },
+{ UINT64_C(0x4000500000000200), 0x1.00014p+62, 0x1p+9 },
+{ UINT64_C(0x4000500000002000), 0x1.0001400000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000500000020000), 0x1.000140000008p+62, 0x0p+0 },
+{ UINT64_C(0x4000500000040000), 0x1.00014000001p+62, 0x0p+0 },
+{ UINT64_C(0x4000500000080000), 0x1.00014000002p+62, 0x0p+0 },
+{ UINT64_C(0x4000500000800000), 0x1.0001400002p+62, 0x0p+0 },
+{ UINT64_C(0x4000500002000000), 0x1.0001400008p+62, 0x0p+0 },
+{ UINT64_C(0x4000500004000000), 0x1.000140001p+62, 0x0p+0 },
+{ UINT64_C(0x4000500020000000), 0x1.000140008p+62, 0x0p+0 },
+{ UINT64_C(0x4000500080000000), 0x1.00014002p+62, 0x0p+0 },
+{ UINT64_C(0x4000500100000000), 0x1.00014004p+62, 0x0p+0 },
+{ UINT64_C(0x4000501000000000), 0x1.0001404p+62, 0x0p+0 },
+{ UINT64_C(0x4000508000000000), 0x1.000142p+62, 0x0p+0 },
+{ UINT64_C(0x4000510000000000), 0x1.000144p+62, 0x0p+0 },
+{ UINT64_C(0x4000540000000000), 0x1.00015p+62, 0x0p+0 },
+{ UINT64_C(0x4000580000000000), 0x1.00016p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000000004), 0x1.0008p+62, 0x1p+2 },
+{ UINT64_C(0x4002000000000010), 0x1.0008p+62, 0x1p+4 },
+{ UINT64_C(0x4002000000000012), 0x1.0008p+62, 0x1.2p+4 },
+{ UINT64_C(0x4002000000000014), 0x1.0008p+62, 0x1.4p+4 },
+{ UINT64_C(0x4002000000000018), 0x1.0008p+62, 0x1.8p+4 },
+{ UINT64_C(0x4002000000000080), 0x1.0008p+62, 0x1p+7 },
+{ UINT64_C(0x4002000000000084), 0x1.0008p+62, 0x1.08p+7 },
+{ UINT64_C(0x4002000000000088), 0x1.0008p+62, 0x1.1p+7 },
+{ UINT64_C(0x40020000000000c0), 0x1.0008p+62, 0x1.8p+7 },
+{ UINT64_C(0x4002000000000400), 0x1.0008000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000000401), 0x1.0008000000001p+62, 0x1p+0 },
+{ UINT64_C(0x4002000000000402), 0x1.0008000000001p+62, 0x1p+1 },
+{ UINT64_C(0x4002000000000420), 0x1.0008000000001p+62, 0x1p+5 },
+{ UINT64_C(0x4002000000000500), 0x1.0008000000001p+62, 0x1p+8 },
+{ UINT64_C(0x4002000000001000), 0x1.0008000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000001001), 0x1.0008000000004p+62, 0x1p+0 },
+{ UINT64_C(0x4002000000001010), 0x1.0008000000004p+62, 0x1p+4 },
+{ UINT64_C(0x4002000000001100), 0x1.0008000000004p+62, 0x1p+8 },
+{ UINT64_C(0x4002000000001800), 0x1.0008000000006p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000004000), 0x1.000800000001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000004002), 0x1.000800000001p+62, 0x1p+1 },
+{ UINT64_C(0x4002000000004008), 0x1.000800000001p+62, 0x1p+3 },
+{ UINT64_C(0x4002000000004080), 0x1.000800000001p+62, 0x1p+7 },
+{ UINT64_C(0x4002000000004100), 0x1.000800000001p+62, 0x1p+8 },
+{ UINT64_C(0x4002000000004800), 0x1.0008000000012p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000005000), 0x1.0008000000014p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000006000), 0x1.0008000000018p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000040000), 0x1.00080000001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000040001), 0x1.00080000001p+62, 0x1p+0 },
+{ UINT64_C(0x4002000000040008), 0x1.00080000001p+62, 0x1p+3 },
+{ UINT64_C(0x4002000000040040), 0x1.00080000001p+62, 0x1p+6 },
+{ UINT64_C(0x4002000000040080), 0x1.00080000001p+62, 0x1p+7 },
+{ UINT64_C(0x4002000000040200), 0x1.00080000001p+62, 0x1p+9 },
+{ UINT64_C(0x4002000000042000), 0x1.0008000000108p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000060000), 0x1.000800000018p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000100000), 0x1.00080000004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000100002), 0x1.00080000004p+62, 0x1p+1 },
+{ UINT64_C(0x4002000000100020), 0x1.00080000004p+62, 0x1p+5 },
+{ UINT64_C(0x4002000000100080), 0x1.00080000004p+62, 0x1p+7 },
+{ UINT64_C(0x4002000000100400), 0x1.0008000000401p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000102000), 0x1.0008000000408p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000120000), 0x1.000800000048p+62, 0x0p+0 },
+{ UINT64_C(0x4002000000140000), 0x1.00080000005p+62, 0x0p+0 },
+{ UINT64_C(0x4002000001000000), 0x1.0008000004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000001000002), 0x1.0008000004p+62, 0x1p+1 },
+{ UINT64_C(0x4002000001000004), 0x1.0008000004p+62, 0x1p+2 },
+{ UINT64_C(0x4002000001000010), 0x1.0008000004p+62, 0x1p+4 },
+{ UINT64_C(0x4002000001000020), 0x1.0008000004p+62, 0x1p+5 },
+{ UINT64_C(0x4002000001000100), 0x1.0008000004p+62, 0x1p+8 },
+{ UINT64_C(0x4002000001001000), 0x1.0008000004004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000001008000), 0x1.000800000402p+62, 0x0p+0 },
+{ UINT64_C(0x4002000001080000), 0x1.00080000042p+62, 0x0p+0 },
+{ UINT64_C(0x4002000001400000), 0x1.0008000005p+62, 0x0p+0 },
+{ UINT64_C(0x4002000010000000), 0x1.000800004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000010000002), 0x1.000800004p+62, 0x1p+1 },
+{ UINT64_C(0x4002000010000010), 0x1.000800004p+62, 0x1p+4 },
+{ UINT64_C(0x4002000010000100), 0x1.000800004p+62, 0x1p+8 },
+{ UINT64_C(0x4002000010000800), 0x1.0008000040002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000010004000), 0x1.000800004001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000010020000), 0x1.000800004008p+62, 0x0p+0 },
+{ UINT64_C(0x4002000010200000), 0x1.00080000408p+62, 0x0p+0 },
+{ UINT64_C(0x4002000010800000), 0x1.0008000042p+62, 0x0p+0 },
+{ UINT64_C(0x4002000014000000), 0x1.000800005p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100000000), 0x1.00080004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100000008), 0x1.00080004p+62, 0x1p+3 },
+{ UINT64_C(0x4002000100000020), 0x1.00080004p+62, 0x1p+5 },
+{ UINT64_C(0x4002000100000040), 0x1.00080004p+62, 0x1p+6 },
+{ UINT64_C(0x4002000100000080), 0x1.00080004p+62, 0x1p+7 },
+{ UINT64_C(0x4002000100000400), 0x1.0008000400001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100004000), 0x1.000800040001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100008000), 0x1.000800040002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100080000), 0x1.00080004002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100100000), 0x1.00080004004p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100400000), 0x1.0008000401p+62, 0x0p+0 },
+{ UINT64_C(0x4002000100800000), 0x1.0008000402p+62, 0x0p+0 },
+{ UINT64_C(0x4002000101000000), 0x1.0008000404p+62, 0x0p+0 },
+{ UINT64_C(0x4002000104000000), 0x1.000800041p+62, 0x0p+0 },
+{ UINT64_C(0x4002000110000000), 0x1.000800044p+62, 0x0p+0 },
+{ UINT64_C(0x4002000140000000), 0x1.00080005p+62, 0x0p+0 },
+{ UINT64_C(0x4002000180000000), 0x1.00080006p+62, 0x0p+0 },
+{ UINT64_C(0x4002000800000000), 0x1.0008002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000800000004), 0x1.0008002p+62, 0x1p+2 },
+{ UINT64_C(0x4002000800000040), 0x1.0008002p+62, 0x1p+6 },
+{ UINT64_C(0x4002000800000100), 0x1.0008002p+62, 0x1p+8 },
+{ UINT64_C(0x4002000800000200), 0x1.0008002p+62, 0x1p+9 },
+{ UINT64_C(0x4002000800000800), 0x1.0008002000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000800004000), 0x1.000800200001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000800008000), 0x1.000800200002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000800080000), 0x1.00080020002p+62, 0x0p+0 },
+{ UINT64_C(0x4002000800400000), 0x1.0008002001p+62, 0x0p+0 },
+{ UINT64_C(0x4002000802000000), 0x1.0008002008p+62, 0x0p+0 },
+{ UINT64_C(0x4002000820000000), 0x1.000800208p+62, 0x0p+0 },
+{ UINT64_C(0x4002000880000000), 0x1.00080022p+62, 0x0p+0 },
+{ UINT64_C(0x4002000900000000), 0x1.00080024p+62, 0x0p+0 },
+{ UINT64_C(0x4002008000000000), 0x1.000802p+62, 0x0p+0 },
+{ UINT64_C(0x4002008000000002), 0x1.000802p+62, 0x1p+1 },
+{ UINT64_C(0x4002008000000004), 0x1.000802p+62, 0x1p+2 },
+{ UINT64_C(0x4002008000000040), 0x1.000802p+62, 0x1p+6 },
+{ UINT64_C(0x4002008000000080), 0x1.000802p+62, 0x1p+7 },
+{ UINT64_C(0x4002008000000800), 0x1.0008020000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002008000002000), 0x1.0008020000008p+62, 0x0p+0 },
+{ UINT64_C(0x4002008000020000), 0x1.000802000008p+62, 0x0p+0 },
+{ UINT64_C(0x4002008000080000), 0x1.00080200002p+62, 0x0p+0 },
+{ UINT64_C(0x4002008000200000), 0x1.00080200008p+62, 0x0p+0 },
+{ UINT64_C(0x4002008002000000), 0x1.0008020008p+62, 0x0p+0 },
+{ UINT64_C(0x4002008004000000), 0x1.000802001p+62, 0x0p+0 },
+{ UINT64_C(0x4002008010000000), 0x1.000802004p+62, 0x0p+0 },
+{ UINT64_C(0x4002008100000000), 0x1.00080204p+62, 0x0p+0 },
+{ UINT64_C(0x4002008400000000), 0x1.0008021p+62, 0x0p+0 },
+{ UINT64_C(0x400200c000000000), 0x1.000803p+62, 0x0p+0 },
+{ UINT64_C(0x4002010000000000), 0x1.000804p+62, 0x0p+0 },
+{ UINT64_C(0x4002010000000008), 0x1.000804p+62, 0x1p+3 },
+{ UINT64_C(0x4002010000000040), 0x1.000804p+62, 0x1p+6 },
+{ UINT64_C(0x4002010000000100), 0x1.000804p+62, 0x1p+8 },
+{ UINT64_C(0x4002010000000800), 0x1.0008040000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002010000008000), 0x1.000804000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002010000080000), 0x1.00080400002p+62, 0x0p+0 },
+{ UINT64_C(0x4002010000400000), 0x1.0008040001p+62, 0x0p+0 },
+{ UINT64_C(0x4002010000800000), 0x1.0008040002p+62, 0x0p+0 },
+{ UINT64_C(0x4002010002000000), 0x1.0008040008p+62, 0x0p+0 },
+{ UINT64_C(0x4002010020000000), 0x1.000804008p+62, 0x0p+0 },
+{ UINT64_C(0x4002010100000000), 0x1.00080404p+62, 0x0p+0 },
+{ UINT64_C(0x4002011000000000), 0x1.0008044p+62, 0x0p+0 },
+{ UINT64_C(0x4002014000000000), 0x1.000805p+62, 0x0p+0 },
+{ UINT64_C(0x4002040000000000), 0x1.00081p+62, 0x0p+0 },
+{ UINT64_C(0x4002040000000001), 0x1.00081p+62, 0x1p+0 },
+{ UINT64_C(0x4002040000000010), 0x1.00081p+62, 0x1p+4 },
+{ UINT64_C(0x4002040000000020), 0x1.00081p+62, 0x1p+5 },
+{ UINT64_C(0x4002040000000200), 0x1.00081p+62, 0x1p+9 },
+{ UINT64_C(0x4002040000002000), 0x1.0008100000008p+62, 0x0p+0 },
+{ UINT64_C(0x4002040000004000), 0x1.000810000001p+62, 0x0p+0 },
+{ UINT64_C(0x4002040000008000), 0x1.000810000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002040000080000), 0x1.00081000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002040000800000), 0x1.0008100002p+62, 0x0p+0 },
+{ UINT64_C(0x4002040002000000), 0x1.0008100008p+62, 0x0p+0 },
+{ UINT64_C(0x4002040004000000), 0x1.000810001p+62, 0x0p+0 },
+{ UINT64_C(0x4002040010000000), 0x1.000810004p+62, 0x0p+0 },
+{ UINT64_C(0x4002040080000000), 0x1.00081002p+62, 0x0p+0 },
+{ UINT64_C(0x4002040200000000), 0x1.00081008p+62, 0x0p+0 },
+{ UINT64_C(0x4002042000000000), 0x1.0008108p+62, 0x0p+0 },
+{ UINT64_C(0x4002060000000000), 0x1.000818p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000000000), 0x1.00088p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000000008), 0x1.00088p+62, 0x1p+3 },
+{ UINT64_C(0x4002200000000040), 0x1.00088p+62, 0x1p+6 },
+{ UINT64_C(0x4002200000000400), 0x1.0008800000001p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000001000), 0x1.0008800000004p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000002000), 0x1.0008800000008p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000008000), 0x1.000880000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000080000), 0x1.00088000002p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000200000), 0x1.00088000008p+62, 0x0p+0 },
+{ UINT64_C(0x4002200000800000), 0x1.0008800002p+62, 0x0p+0 },
+{ UINT64_C(0x4002200002000000), 0x1.0008800008p+62, 0x0p+0 },
+{ UINT64_C(0x4002200008000000), 0x1.000880002p+62, 0x0p+0 },
+{ UINT64_C(0x4002200020000000), 0x1.000880008p+62, 0x0p+0 },
+{ UINT64_C(0x4002200200000000), 0x1.00088008p+62, 0x0p+0 },
+{ UINT64_C(0x4002200400000000), 0x1.0008801p+62, 0x0p+0 },
+{ UINT64_C(0x4002202000000000), 0x1.0008808p+62, 0x0p+0 },
+{ UINT64_C(0x4002208000000000), 0x1.000882p+62, 0x0p+0 },
+{ UINT64_C(0x4002220000000000), 0x1.000888p+62, 0x0p+0 },
+{ UINT64_C(0x4002280000000000), 0x1.0008ap+62, 0x0p+0 },
+{ UINT64_C(0x4003000000000000), 0x1.000cp+62, 0x0p+0 },
+{ UINT64_C(0x4003000000000008), 0x1.000cp+62, 0x1p+3 },
+{ UINT64_C(0x4003000000000020), 0x1.000cp+62, 0x1p+5 },
+{ UINT64_C(0x4003000000000040), 0x1.000cp+62, 0x1p+6 },
+{ UINT64_C(0x4003000000000400), 0x1.000c000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4003000000001000), 0x1.000c000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4003000000010000), 0x1.000c00000004p+62, 0x0p+0 },
+{ UINT64_C(0x4003000000020000), 0x1.000c00000008p+62, 0x0p+0 },
+{ UINT64_C(0x4003000000080000), 0x1.000c0000002p+62, 0x0p+0 },
+{ UINT64_C(0x4003000000100000), 0x1.000c0000004p+62, 0x0p+0 },
+{ UINT64_C(0x4003000001000000), 0x1.000c000004p+62, 0x0p+0 },
+{ UINT64_C(0x4003000004000000), 0x1.000c00001p+62, 0x0p+0 },
+{ UINT64_C(0x4003000040000000), 0x1.000c0001p+62, 0x0p+0 },
+{ UINT64_C(0x4003000200000000), 0x1.000c0008p+62, 0x0p+0 },
+{ UINT64_C(0x4003000800000000), 0x1.000c002p+62, 0x0p+0 },
+{ UINT64_C(0x4003004000000000), 0x1.000c01p+62, 0x0p+0 },
+{ UINT64_C(0x4003008000000000), 0x1.000c02p+62, 0x0p+0 },
+{ UINT64_C(0x4003010000000000), 0x1.000c04p+62, 0x0p+0 },
+{ UINT64_C(0x4003020000000000), 0x1.000c08p+62, 0x0p+0 },
+{ UINT64_C(0x4003040000000000), 0x1.000c1p+62, 0x0p+0 },
+{ UINT64_C(0x4003100000000000), 0x1.000c4p+62, 0x0p+0 },
+{ UINT64_C(0x4003800000000000), 0x1.000ep+62, 0x0p+0 },
+{ UINT64_C(0x4010000000000008), 0x1.004p+62, 0x1p+3 },
+{ UINT64_C(0x4010000000000009), 0x1.004p+62, 0x1.2p+3 },
+{ UINT64_C(0x4010000000000040), 0x1.004p+62, 0x1p+6 },
+{ UINT64_C(0x4010000000000044), 0x1.004p+62, 0x1.1p+6 },
+{ UINT64_C(0x4010000000000060), 0x1.004p+62, 0x1.8p+6 },
+{ UINT64_C(0x4010000000000400), 0x1.0040000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000000402), 0x1.0040000000001p+62, 0x1p+1 },
+{ UINT64_C(0x4010000000000408), 0x1.0040000000001p+62, 0x1p+3 },
+{ UINT64_C(0x4010000000000480), 0x1.0040000000001p+62, 0x1p+7 },
+{ UINT64_C(0x4010000000001000), 0x1.0040000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000001008), 0x1.0040000000004p+62, 0x1p+3 },
+{ UINT64_C(0x4010000000001010), 0x1.0040000000004p+62, 0x1p+4 },
+{ UINT64_C(0x4010000000001080), 0x1.0040000000004p+62, 0x1p+7 },
+{ UINT64_C(0x4010000000001800), 0x1.0040000000006p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000008000), 0x1.004000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000008001), 0x1.004000000002p+62, 0x1p+0 },
+{ UINT64_C(0x4010000000008010), 0x1.004000000002p+62, 0x1p+4 },
+{ UINT64_C(0x4010000000008100), 0x1.004000000002p+62, 0x1p+8 },
+{ UINT64_C(0x4010000000008800), 0x1.0040000000022p+62, 0x0p+0 },
+{ UINT64_C(0x401000000000a000), 0x1.0040000000028p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000080000), 0x1.00400000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000080004), 0x1.00400000002p+62, 0x1p+2 },
+{ UINT64_C(0x4010000000080040), 0x1.00400000002p+62, 0x1p+6 },
+{ UINT64_C(0x4010000000080400), 0x1.0040000000201p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000081000), 0x1.0040000000204p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000090000), 0x1.004000000024p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000100000), 0x1.00400000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000100008), 0x1.00400000004p+62, 0x1p+3 },
+{ UINT64_C(0x4010000000100020), 0x1.00400000004p+62, 0x1p+5 },
+{ UINT64_C(0x4010000000100040), 0x1.00400000004p+62, 0x1p+6 },
+{ UINT64_C(0x4010000000100100), 0x1.00400000004p+62, 0x1p+8 },
+{ UINT64_C(0x4010000000100800), 0x1.0040000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000104000), 0x1.004000000041p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000108000), 0x1.004000000042p+62, 0x0p+0 },
+{ UINT64_C(0x4010000000180000), 0x1.00400000006p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001000000), 0x1.0040000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001000004), 0x1.0040000004p+62, 0x1p+2 },
+{ UINT64_C(0x4010000001000010), 0x1.0040000004p+62, 0x1p+4 },
+{ UINT64_C(0x4010000001000080), 0x1.0040000004p+62, 0x1p+7 },
+{ UINT64_C(0x4010000001000800), 0x1.0040000004002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001004000), 0x1.004000000401p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001008000), 0x1.004000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001010000), 0x1.004000000404p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001100000), 0x1.00400000044p+62, 0x0p+0 },
+{ UINT64_C(0x4010000001800000), 0x1.0040000006p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002000000), 0x1.0040000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002000008), 0x1.0040000008p+62, 0x1p+3 },
+{ UINT64_C(0x4010000002000080), 0x1.0040000008p+62, 0x1p+7 },
+{ UINT64_C(0x4010000002000400), 0x1.0040000008001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002001000), 0x1.0040000008004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002002000), 0x1.0040000008008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002010000), 0x1.004000000804p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002080000), 0x1.00400000082p+62, 0x0p+0 },
+{ UINT64_C(0x4010000002400000), 0x1.0040000009p+62, 0x0p+0 },
+{ UINT64_C(0x4010000004000000), 0x1.004000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000004000001), 0x1.004000001p+62, 0x1p+0 },
+{ UINT64_C(0x4010000004000008), 0x1.004000001p+62, 0x1p+3 },
+{ UINT64_C(0x4010000004000020), 0x1.004000001p+62, 0x1p+5 },
+{ UINT64_C(0x4010000004000080), 0x1.004000001p+62, 0x1p+7 },
+{ UINT64_C(0x4010000004000100), 0x1.004000001p+62, 0x1p+8 },
+{ UINT64_C(0x4010000004001000), 0x1.0040000010004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000004008000), 0x1.004000001002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000004020000), 0x1.004000001008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000004100000), 0x1.00400000104p+62, 0x0p+0 },
+{ UINT64_C(0x4010000004800000), 0x1.0040000012p+62, 0x0p+0 },
+{ UINT64_C(0x4010000005000000), 0x1.0040000014p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040000000), 0x1.00400001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040000002), 0x1.00400001p+62, 0x1p+1 },
+{ UINT64_C(0x4010000040000020), 0x1.00400001p+62, 0x1p+5 },
+{ UINT64_C(0x4010000040000200), 0x1.00400001p+62, 0x1p+9 },
+{ UINT64_C(0x4010000040000800), 0x1.0040000100002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040001000), 0x1.0040000100004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040002000), 0x1.0040000100008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040008000), 0x1.004000010002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040080000), 0x1.00400001002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000040100000), 0x1.00400001004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000041000000), 0x1.0040000104p+62, 0x0p+0 },
+{ UINT64_C(0x4010000050000000), 0x1.004000014p+62, 0x0p+0 },
+{ UINT64_C(0x4010000400000000), 0x1.0040001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000400000001), 0x1.0040001p+62, 0x1p+0 },
+{ UINT64_C(0x4010000400000010), 0x1.0040001p+62, 0x1p+4 },
+{ UINT64_C(0x4010000400000100), 0x1.0040001p+62, 0x1p+8 },
+{ UINT64_C(0x4010000400000800), 0x1.0040001000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000400008000), 0x1.004000100002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000400010000), 0x1.004000100004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000400040000), 0x1.00400010001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000400200000), 0x1.00400010008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000401000000), 0x1.0040001004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000410000000), 0x1.004000104p+62, 0x0p+0 },
+{ UINT64_C(0x4010000500000000), 0x1.00400014p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800000000), 0x1.0040002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800000008), 0x1.0040002p+62, 0x1p+3 },
+{ UINT64_C(0x4010000800000080), 0x1.0040002p+62, 0x1p+7 },
+{ UINT64_C(0x4010000800000400), 0x1.0040002000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800001000), 0x1.0040002000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800002000), 0x1.0040002000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800020000), 0x1.004000200008p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800100000), 0x1.00400020004p+62, 0x0p+0 },
+{ UINT64_C(0x4010000800800000), 0x1.0040002002p+62, 0x0p+0 },
+{ UINT64_C(0x4010000808000000), 0x1.004000202p+62, 0x0p+0 },
+{ UINT64_C(0x4010000820000000), 0x1.004000208p+62, 0x0p+0 },
+{ UINT64_C(0x4010000a00000000), 0x1.00400028p+62, 0x0p+0 },
+{ UINT64_C(0x4010000c00000000), 0x1.0040003p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000000000), 0x1.0040008p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000000001), 0x1.0040008p+62, 0x1p+0 },
+{ UINT64_C(0x4010002000000010), 0x1.0040008p+62, 0x1p+4 },
+{ UINT64_C(0x4010002000000020), 0x1.0040008p+62, 0x1p+5 },
+{ UINT64_C(0x4010002000000100), 0x1.0040008p+62, 0x1p+8 },
+{ UINT64_C(0x4010002000000800), 0x1.0040008000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000001000), 0x1.0040008000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000008000), 0x1.004000800002p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000010000), 0x1.004000800004p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000080000), 0x1.00400080002p+62, 0x0p+0 },
+{ UINT64_C(0x4010002000800000), 0x1.0040008002p+62, 0x0p+0 },
+{ UINT64_C(0x4010002004000000), 0x1.004000801p+62, 0x0p+0 },
+{ UINT64_C(0x4010002020000000), 0x1.004000808p+62, 0x0p+0 },
+{ UINT64_C(0x4010002080000000), 0x1.00400082p+62, 0x0p+0 },
+{ UINT64_C(0x4010002200000000), 0x1.00400088p+62, 0x0p+0 },
+{ UINT64_C(0x4010002400000000), 0x1.0040009p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000000000), 0x1.004001p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000000001), 0x1.004001p+62, 0x1p+0 },
+{ UINT64_C(0x4010004000000004), 0x1.004001p+62, 0x1p+2 },
+{ UINT64_C(0x4010004000000020), 0x1.004001p+62, 0x1p+5 },
+{ UINT64_C(0x4010004000000080), 0x1.004001p+62, 0x1p+7 },
+{ UINT64_C(0x4010004000000800), 0x1.0040010000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000002000), 0x1.0040010000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000010000), 0x1.004001000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000040000), 0x1.00400100001p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000080000), 0x1.00400100002p+62, 0x0p+0 },
+{ UINT64_C(0x4010004000200000), 0x1.00400100008p+62, 0x0p+0 },
+{ UINT64_C(0x4010004001000000), 0x1.0040010004p+62, 0x0p+0 },
+{ UINT64_C(0x4010004008000000), 0x1.004001002p+62, 0x0p+0 },
+{ UINT64_C(0x4010004020000000), 0x1.004001008p+62, 0x0p+0 },
+{ UINT64_C(0x4010004200000000), 0x1.00400108p+62, 0x0p+0 },
+{ UINT64_C(0x4010004400000000), 0x1.0040011p+62, 0x0p+0 },
+{ UINT64_C(0x4010005000000000), 0x1.0040014p+62, 0x0p+0 },
+{ UINT64_C(0x4010008000000000), 0x1.004002p+62, 0x0p+0 },
+{ UINT64_C(0x4010008000000001), 0x1.004002p+62, 0x1p+0 },
+{ UINT64_C(0x4010008000000002), 0x1.004002p+62, 0x1p+1 },
+{ UINT64_C(0x4010008000000008), 0x1.004002p+62, 0x1p+3 },
+{ UINT64_C(0x4010008000000010), 0x1.004002p+62, 0x1p+4 },
+{ UINT64_C(0x4010008000000080), 0x1.004002p+62, 0x1p+7 },
+{ UINT64_C(0x4010008000000100), 0x1.004002p+62, 0x1p+8 },
+{ UINT64_C(0x4010008000001000), 0x1.0040020000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010008000008000), 0x1.004002000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010008000020000), 0x1.004002000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010008000080000), 0x1.00400200002p+62, 0x0p+0 },
+{ UINT64_C(0x4010008000800000), 0x1.0040020002p+62, 0x0p+0 },
+{ UINT64_C(0x4010008002000000), 0x1.0040020008p+62, 0x0p+0 },
+{ UINT64_C(0x4010008020000000), 0x1.004002008p+62, 0x0p+0 },
+{ UINT64_C(0x4010008040000000), 0x1.00400201p+62, 0x0p+0 },
+{ UINT64_C(0x4010008200000000), 0x1.00400208p+62, 0x0p+0 },
+{ UINT64_C(0x4010009000000000), 0x1.0040024p+62, 0x0p+0 },
+{ UINT64_C(0x401000a000000000), 0x1.0040028p+62, 0x0p+0 },
+{ UINT64_C(0x4010040000000000), 0x1.00401p+62, 0x0p+0 },
+{ UINT64_C(0x4010040000000001), 0x1.00401p+62, 0x1p+0 },
+{ UINT64_C(0x4010040000000008), 0x1.00401p+62, 0x1p+3 },
+{ UINT64_C(0x4010040000000080), 0x1.00401p+62, 0x1p+7 },
+{ UINT64_C(0x4010040000000100), 0x1.00401p+62, 0x1p+8 },
+{ UINT64_C(0x4010040000001000), 0x1.0040100000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010040000002000), 0x1.0040100000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010040000020000), 0x1.004010000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010040000100000), 0x1.00401000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010040000800000), 0x1.0040100002p+62, 0x0p+0 },
+{ UINT64_C(0x4010040002000000), 0x1.0040100008p+62, 0x0p+0 },
+{ UINT64_C(0x4010040020000000), 0x1.004010008p+62, 0x0p+0 },
+{ UINT64_C(0x4010040080000000), 0x1.00401002p+62, 0x0p+0 },
+{ UINT64_C(0x4010040400000000), 0x1.0040101p+62, 0x0p+0 },
+{ UINT64_C(0x4010042000000000), 0x1.0040108p+62, 0x0p+0 },
+{ UINT64_C(0x4010048000000000), 0x1.004012p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000000000), 0x1.00404p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000000008), 0x1.00404p+62, 0x1p+3 },
+{ UINT64_C(0x4010100000000020), 0x1.00404p+62, 0x1p+5 },
+{ UINT64_C(0x4010100000000100), 0x1.00404p+62, 0x1p+8 },
+{ UINT64_C(0x4010100000001000), 0x1.0040400000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000004000), 0x1.004040000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000008000), 0x1.004040000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000010000), 0x1.004040000004p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000040000), 0x1.00404000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000400000), 0x1.0040400001p+62, 0x0p+0 },
+{ UINT64_C(0x4010100000800000), 0x1.0040400002p+62, 0x0p+0 },
+{ UINT64_C(0x4010100008000000), 0x1.004040002p+62, 0x0p+0 },
+{ UINT64_C(0x4010100010000000), 0x1.004040004p+62, 0x0p+0 },
+{ UINT64_C(0x4010100020000000), 0x1.004040008p+62, 0x0p+0 },
+{ UINT64_C(0x4010100040000000), 0x1.00404001p+62, 0x0p+0 },
+{ UINT64_C(0x4010100400000000), 0x1.0040401p+62, 0x0p+0 },
+{ UINT64_C(0x4010101000000000), 0x1.0040404p+62, 0x0p+0 },
+{ UINT64_C(0x4010110000000000), 0x1.004044p+62, 0x0p+0 },
+{ UINT64_C(0x4010180000000000), 0x1.00406p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000000000), 0x1.0042p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000000008), 0x1.0042p+62, 0x1p+3 },
+{ UINT64_C(0x4010800000000020), 0x1.0042p+62, 0x1p+5 },
+{ UINT64_C(0x4010800000000100), 0x1.0042p+62, 0x1p+8 },
+{ UINT64_C(0x4010800000000800), 0x1.0042000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000002000), 0x1.0042000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000004000), 0x1.004200000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000040000), 0x1.00420000001p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000200000), 0x1.00420000008p+62, 0x0p+0 },
+{ UINT64_C(0x4010800000800000), 0x1.0042000002p+62, 0x0p+0 },
+{ UINT64_C(0x4010800008000000), 0x1.004200002p+62, 0x0p+0 },
+{ UINT64_C(0x4010800040000000), 0x1.00420001p+62, 0x0p+0 },
+{ UINT64_C(0x4010800080000000), 0x1.00420002p+62, 0x0p+0 },
+{ UINT64_C(0x4010800400000000), 0x1.0042001p+62, 0x0p+0 },
+{ UINT64_C(0x4010800800000000), 0x1.0042002p+62, 0x0p+0 },
+{ UINT64_C(0x4010808000000000), 0x1.004202p+62, 0x0p+0 },
+{ UINT64_C(0x4010880000000000), 0x1.00422p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000000000), 0x1.006p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000000002), 0x1.006p+62, 0x1p+1 },
+{ UINT64_C(0x4018000000000020), 0x1.006p+62, 0x1p+5 },
+{ UINT64_C(0x4018000000000100), 0x1.006p+62, 0x1p+8 },
+{ UINT64_C(0x4018000000000400), 0x1.0060000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000002000), 0x1.0060000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000004000), 0x1.006000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000020000), 0x1.006000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000080000), 0x1.00600000002p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000100000), 0x1.00600000004p+62, 0x0p+0 },
+{ UINT64_C(0x4018000000400000), 0x1.0060000001p+62, 0x0p+0 },
+{ UINT64_C(0x4018000004000000), 0x1.006000001p+62, 0x0p+0 },
+{ UINT64_C(0x4018000040000000), 0x1.00600001p+62, 0x0p+0 },
+{ UINT64_C(0x4018000100000000), 0x1.00600004p+62, 0x0p+0 },
+{ UINT64_C(0x4018000800000000), 0x1.0060002p+62, 0x0p+0 },
+{ UINT64_C(0x4018008000000000), 0x1.006002p+62, 0x0p+0 },
+{ UINT64_C(0x4018020000000000), 0x1.006008p+62, 0x0p+0 },
+{ UINT64_C(0x4018200000000000), 0x1.00608p+62, 0x0p+0 },
+{ UINT64_C(0x401a000000000000), 0x1.0068p+62, 0x0p+0 },
+{ UINT64_C(0x401c000000000000), 0x1.007p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000000008), 0x1.04p+62, 0x1p+3 },
+{ UINT64_C(0x410000000000000a), 0x1.04p+62, 0x1.4p+3 },
+{ UINT64_C(0x410000000000000c), 0x1.04p+62, 0x1.8p+3 },
+{ UINT64_C(0x4100000000000080), 0x1.04p+62, 0x1p+7 },
+{ UINT64_C(0x4100000000000088), 0x1.04p+62, 0x1.1p+7 },
+{ UINT64_C(0x4100000000000400), 0x1.0400000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000000408), 0x1.0400000000001p+62, 0x1p+3 },
+{ UINT64_C(0x4100000000000410), 0x1.0400000000001p+62, 0x1p+4 },
+{ UINT64_C(0x4100000000000420), 0x1.0400000000001p+62, 0x1p+5 },
+{ UINT64_C(0x4100000000000600), 0x1.0400000000002p+62, -0x1p+9 },
+{ UINT64_C(0x4100000000000800), 0x1.0400000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000000802), 0x1.0400000000002p+62, 0x1p+1 },
+{ UINT64_C(0x4100000000000820), 0x1.0400000000002p+62, 0x1p+5 },
+{ UINT64_C(0x4100000000000a00), 0x1.0400000000002p+62, 0x1p+9 },
+{ UINT64_C(0x4100000000004000), 0x1.040000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000004001), 0x1.040000000001p+62, 0x1p+0 },
+{ UINT64_C(0x4100000000004004), 0x1.040000000001p+62, 0x1p+2 },
+{ UINT64_C(0x4100000000004020), 0x1.040000000001p+62, 0x1p+5 },
+{ UINT64_C(0x4100000000004040), 0x1.040000000001p+62, 0x1p+6 },
+{ UINT64_C(0x4100000000004100), 0x1.040000000001p+62, 0x1p+8 },
+{ UINT64_C(0x4100000000005000), 0x1.0400000000014p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000008000), 0x1.040000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000008004), 0x1.040000000002p+62, 0x1p+2 },
+{ UINT64_C(0x4100000000008008), 0x1.040000000002p+62, 0x1p+3 },
+{ UINT64_C(0x4100000000008080), 0x1.040000000002p+62, 0x1p+7 },
+{ UINT64_C(0x4100000000008400), 0x1.0400000000021p+62, 0x0p+0 },
+{ UINT64_C(0x410000000000a000), 0x1.0400000000028p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000020000), 0x1.040000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000020002), 0x1.040000000008p+62, 0x1p+1 },
+{ UINT64_C(0x4100000000020004), 0x1.040000000008p+62, 0x1p+2 },
+{ UINT64_C(0x4100000000020010), 0x1.040000000008p+62, 0x1p+4 },
+{ UINT64_C(0x4100000000020080), 0x1.040000000008p+62, 0x1p+7 },
+{ UINT64_C(0x4100000000020800), 0x1.0400000000082p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000028000), 0x1.04000000000ap+62, 0x0p+0 },
+{ UINT64_C(0x4100000000080000), 0x1.04000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000080002), 0x1.04000000002p+62, 0x1p+1 },
+{ UINT64_C(0x4100000000080020), 0x1.04000000002p+62, 0x1p+5 },
+{ UINT64_C(0x4100000000080080), 0x1.04000000002p+62, 0x1p+7 },
+{ UINT64_C(0x4100000000080100), 0x1.04000000002p+62, 0x1p+8 },
+{ UINT64_C(0x4100000000080800), 0x1.0400000000202p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000081000), 0x1.0400000000204p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000090000), 0x1.040000000024p+62, 0x0p+0 },
+{ UINT64_C(0x41000000000c0000), 0x1.04000000003p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000400000), 0x1.0400000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000400004), 0x1.0400000001p+62, 0x1p+2 },
+{ UINT64_C(0x4100000000400040), 0x1.0400000001p+62, 0x1p+6 },
+{ UINT64_C(0x4100000000400100), 0x1.0400000001p+62, 0x1p+8 },
+{ UINT64_C(0x4100000000400800), 0x1.0400000001002p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000404000), 0x1.040000000101p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000408000), 0x1.040000000102p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000410000), 0x1.040000000104p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000500000), 0x1.04000000014p+62, 0x0p+0 },
+{ UINT64_C(0x4100000000600000), 0x1.04000000018p+62, 0x0p+0 },
+{ UINT64_C(0x4100000001000000), 0x1.0400000004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000001000004), 0x1.0400000004p+62, 0x1p+2 },
+{ UINT64_C(0x4100000001000008), 0x1.0400000004p+62, 0x1p+3 },
+{ UINT64_C(0x4100000001000020), 0x1.0400000004p+62, 0x1p+5 },
+{ UINT64_C(0x4100000001000080), 0x1.0400000004p+62, 0x1p+7 },
+{ UINT64_C(0x4100000001000800), 0x1.0400000004002p+62, 0x0p+0 },
+{ UINT64_C(0x4100000001008000), 0x1.040000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4100000001040000), 0x1.04000000041p+62, 0x0p+0 },
+{ UINT64_C(0x4100000001080000), 0x1.04000000042p+62, 0x0p+0 },
+{ UINT64_C(0x4100000001800000), 0x1.0400000006p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004000000), 0x1.040000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004000001), 0x1.040000001p+62, 0x1p+0 },
+{ UINT64_C(0x4100000004000002), 0x1.040000001p+62, 0x1p+1 },
+{ UINT64_C(0x4100000004000004), 0x1.040000001p+62, 0x1p+2 },
+{ UINT64_C(0x4100000004000040), 0x1.040000001p+62, 0x1p+6 },
+{ UINT64_C(0x4100000004000400), 0x1.0400000010001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004001000), 0x1.0400000010004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004002000), 0x1.0400000010008p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004008000), 0x1.040000001002p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004010000), 0x1.040000001004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004040000), 0x1.04000000101p+62, 0x0p+0 },
+{ UINT64_C(0x4100000004200000), 0x1.04000000108p+62, 0x0p+0 },
+{ UINT64_C(0x4100000005000000), 0x1.0400000014p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010000000), 0x1.040000004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010000001), 0x1.040000004p+62, 0x1p+0 },
+{ UINT64_C(0x4100000010000010), 0x1.040000004p+62, 0x1p+4 },
+{ UINT64_C(0x4100000010000020), 0x1.040000004p+62, 0x1p+5 },
+{ UINT64_C(0x4100000010000080), 0x1.040000004p+62, 0x1p+7 },
+{ UINT64_C(0x4100000010000100), 0x1.040000004p+62, 0x1p+8 },
+{ UINT64_C(0x4100000010000400), 0x1.0400000040001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010001000), 0x1.0400000040004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010004000), 0x1.040000004001p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010010000), 0x1.040000004004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010040000), 0x1.04000000401p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010080000), 0x1.04000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010200000), 0x1.04000000408p+62, 0x0p+0 },
+{ UINT64_C(0x4100000010400000), 0x1.0400000041p+62, 0x0p+0 },
+{ UINT64_C(0x4100000012000000), 0x1.0400000048p+62, 0x0p+0 },
+{ UINT64_C(0x4100000014000000), 0x1.040000005p+62, 0x0p+0 },
+{ UINT64_C(0x4100000100000000), 0x1.04000004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000100000001), 0x1.04000004p+62, 0x1p+0 },
+{ UINT64_C(0x4100000100000002), 0x1.04000004p+62, 0x1p+1 },
+{ UINT64_C(0x4100000100000020), 0x1.04000004p+62, 0x1p+5 },
+{ UINT64_C(0x4100000100000200), 0x1.04000004p+62, 0x1p+9 },
+{ UINT64_C(0x4100000100002000), 0x1.0400000400008p+62, 0x0p+0 },
+{ UINT64_C(0x4100000100020000), 0x1.040000040008p+62, 0x0p+0 },
+{ UINT64_C(0x4100000100100000), 0x1.04000004004p+62, 0x0p+0 },
+{ UINT64_C(0x4100000100200000), 0x1.04000004008p+62, 0x0p+0 },
+{ UINT64_C(0x4100000100400000), 0x1.0400000401p+62, 0x0p+0 },
+{ UINT64_C(0x4100000104000000), 0x1.040000041p+62, 0x0p+0 },
+{ UINT64_C(0x4100000140000000), 0x1.04000005p+62, 0x0p+0 },
+{ UINT64_C(0x4100001000000000), 0x1.0400004p+62, 0x0p+0 },
+{ UINT64_C(0x4100001000000008), 0x1.0400004p+62, 0x1p+3 },
+{ UINT64_C(0x4100001000000040), 0x1.0400004p+62, 0x1p+6 },
+{ UINT64_C(0x4100001000000400), 0x1.0400004000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100001000002000), 0x1.0400004000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100001000020000), 0x1.040000400008p+62, 0x0p+0 },
+{ UINT64_C(0x4100001000080000), 0x1.04000040002p+62, 0x0p+0 },
+{ UINT64_C(0x4100001000400000), 0x1.0400004001p+62, 0x0p+0 },
+{ UINT64_C(0x4100001004000000), 0x1.040000401p+62, 0x0p+0 },
+{ UINT64_C(0x4100001010000000), 0x1.040000404p+62, 0x0p+0 },
+{ UINT64_C(0x4100001080000000), 0x1.04000042p+62, 0x0p+0 },
+{ UINT64_C(0x4100001200000000), 0x1.04000048p+62, 0x0p+0 },
+{ UINT64_C(0x4100001400000000), 0x1.0400005p+62, 0x0p+0 },
+{ UINT64_C(0x4100002000000000), 0x1.0400008p+62, 0x0p+0 },
+{ UINT64_C(0x4100002000000001), 0x1.0400008p+62, 0x1p+0 },
+{ UINT64_C(0x4100002000000008), 0x1.0400008p+62, 0x1p+3 },
+{ UINT64_C(0x4100002000000080), 0x1.0400008p+62, 0x1p+7 },
+{ UINT64_C(0x4100002000000200), 0x1.0400008p+62, 0x1p+9 },
+{ UINT64_C(0x4100002000000800), 0x1.0400008000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100002000008000), 0x1.040000800002p+62, 0x0p+0 },
+{ UINT64_C(0x4100002000020000), 0x1.040000800008p+62, 0x0p+0 },
+{ UINT64_C(0x4100002000100000), 0x1.04000080004p+62, 0x0p+0 },
+{ UINT64_C(0x4100002000200000), 0x1.04000080008p+62, 0x0p+0 },
+{ UINT64_C(0x4100002001000000), 0x1.0400008004p+62, 0x0p+0 },
+{ UINT64_C(0x4100002010000000), 0x1.040000804p+62, 0x0p+0 },
+{ UINT64_C(0x4100002040000000), 0x1.04000081p+62, 0x0p+0 },
+{ UINT64_C(0x4100002080000000), 0x1.04000082p+62, 0x0p+0 },
+{ UINT64_C(0x4100002800000000), 0x1.040000ap+62, 0x0p+0 },
+{ UINT64_C(0x4100004000000000), 0x1.040001p+62, 0x0p+0 },
+{ UINT64_C(0x4100004000000004), 0x1.040001p+62, 0x1p+2 },
+{ UINT64_C(0x4100004000000008), 0x1.040001p+62, 0x1p+3 },
+{ UINT64_C(0x4100004000000020), 0x1.040001p+62, 0x1p+5 },
+{ UINT64_C(0x4100004000000100), 0x1.040001p+62, 0x1p+8 },
+{ UINT64_C(0x4100004000000400), 0x1.0400010000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100004000001000), 0x1.0400010000004p+62, 0x0p+0 },
+{ UINT64_C(0x4100004000004000), 0x1.040001000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100004000020000), 0x1.040001000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100004000200000), 0x1.04000100008p+62, 0x0p+0 },
+{ UINT64_C(0x4100004000800000), 0x1.0400010002p+62, 0x0p+0 },
+{ UINT64_C(0x4100004004000000), 0x1.040001001p+62, 0x0p+0 },
+{ UINT64_C(0x4100004040000000), 0x1.04000101p+62, 0x0p+0 },
+{ UINT64_C(0x4100004200000000), 0x1.04000108p+62, 0x0p+0 },
+{ UINT64_C(0x4100006000000000), 0x1.0400018p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000000000), 0x1.040004p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000000001), 0x1.040004p+62, 0x1p+0 },
+{ UINT64_C(0x4100010000000004), 0x1.040004p+62, 0x1p+2 },
+{ UINT64_C(0x4100010000000040), 0x1.040004p+62, 0x1p+6 },
+{ UINT64_C(0x4100010000000100), 0x1.040004p+62, 0x1p+8 },
+{ UINT64_C(0x4100010000000800), 0x1.0400040000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000002000), 0x1.0400040000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000004000), 0x1.040004000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000020000), 0x1.040004000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000080000), 0x1.04000400002p+62, 0x0p+0 },
+{ UINT64_C(0x4100010000800000), 0x1.0400040002p+62, 0x0p+0 },
+{ UINT64_C(0x4100010008000000), 0x1.040004002p+62, 0x0p+0 },
+{ UINT64_C(0x4100010080000000), 0x1.04000402p+62, 0x0p+0 },
+{ UINT64_C(0x4100010100000000), 0x1.04000404p+62, 0x0p+0 },
+{ UINT64_C(0x4100010800000000), 0x1.0400042p+62, 0x0p+0 },
+{ UINT64_C(0x4100011000000000), 0x1.0400044p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000000000), 0x1.04002p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000000002), 0x1.04002p+62, 0x1p+1 },
+{ UINT64_C(0x4100080000000008), 0x1.04002p+62, 0x1p+3 },
+{ UINT64_C(0x4100080000000010), 0x1.04002p+62, 0x1p+4 },
+{ UINT64_C(0x4100080000000080), 0x1.04002p+62, 0x1p+7 },
+{ UINT64_C(0x4100080000000200), 0x1.04002p+62, 0x1p+9 },
+{ UINT64_C(0x4100080000000800), 0x1.0400200000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000002000), 0x1.0400200000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000008000), 0x1.040020000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000040000), 0x1.04002000001p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000200000), 0x1.04002000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100080000400000), 0x1.0400200001p+62, 0x0p+0 },
+{ UINT64_C(0x4100080002000000), 0x1.0400200008p+62, 0x0p+0 },
+{ UINT64_C(0x4100080010000000), 0x1.040020004p+62, 0x0p+0 },
+{ UINT64_C(0x4100080020000000), 0x1.040020008p+62, 0x0p+0 },
+{ UINT64_C(0x4100080100000000), 0x1.04002004p+62, 0x0p+0 },
+{ UINT64_C(0x4100080800000000), 0x1.0400202p+62, 0x0p+0 },
+{ UINT64_C(0x4100082000000000), 0x1.0400208p+62, 0x0p+0 },
+{ UINT64_C(0x41000a0000000000), 0x1.040028p+62, 0x0p+0 },
+{ UINT64_C(0x4100800000000000), 0x1.0402p+62, 0x0p+0 },
+{ UINT64_C(0x4100800000000004), 0x1.0402p+62, 0x1p+2 },
+{ UINT64_C(0x4100800000000020), 0x1.0402p+62, 0x1p+5 },
+{ UINT64_C(0x4100800000000200), 0x1.0402p+62, 0x1p+9 },
+{ UINT64_C(0x4100800000002000), 0x1.0402000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100800000010000), 0x1.040200000004p+62, 0x0p+0 },
+{ UINT64_C(0x4100800000080000), 0x1.04020000002p+62, 0x0p+0 },
+{ UINT64_C(0x4100800000200000), 0x1.04020000008p+62, 0x0p+0 },
+{ UINT64_C(0x4100800001000000), 0x1.0402000004p+62, 0x0p+0 },
+{ UINT64_C(0x4100800008000000), 0x1.040200002p+62, 0x0p+0 },
+{ UINT64_C(0x4100800080000000), 0x1.04020002p+62, 0x0p+0 },
+{ UINT64_C(0x4100800400000000), 0x1.0402001p+62, 0x0p+0 },
+{ UINT64_C(0x4100801000000000), 0x1.0402004p+62, 0x0p+0 },
+{ UINT64_C(0x4100808000000000), 0x1.040202p+62, 0x0p+0 },
+{ UINT64_C(0x4100880000000000), 0x1.04022p+62, 0x0p+0 },
+{ UINT64_C(0x4101000000000000), 0x1.0404p+62, 0x0p+0 },
+{ UINT64_C(0x4101000000000002), 0x1.0404p+62, 0x1p+1 },
+{ UINT64_C(0x4101000000000010), 0x1.0404p+62, 0x1p+4 },
+{ UINT64_C(0x4101000000000080), 0x1.0404p+62, 0x1p+7 },
+{ UINT64_C(0x4101000000000400), 0x1.0404000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4101000000001000), 0x1.0404000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4101000000008000), 0x1.040400000002p+62, 0x0p+0 },
+{ UINT64_C(0x4101000000040000), 0x1.04040000001p+62, 0x0p+0 },
+{ UINT64_C(0x4101000000400000), 0x1.0404000001p+62, 0x0p+0 },
+{ UINT64_C(0x4101000001000000), 0x1.0404000004p+62, 0x0p+0 },
+{ UINT64_C(0x4101000010000000), 0x1.040400004p+62, 0x0p+0 },
+{ UINT64_C(0x4101000040000000), 0x1.04040001p+62, 0x0p+0 },
+{ UINT64_C(0x4101000100000000), 0x1.04040004p+62, 0x0p+0 },
+{ UINT64_C(0x4101001000000000), 0x1.0404004p+62, 0x0p+0 },
+{ UINT64_C(0x4101004000000000), 0x1.040401p+62, 0x0p+0 },
+{ UINT64_C(0x4101008000000000), 0x1.040402p+62, 0x0p+0 },
+{ UINT64_C(0x4101010000000000), 0x1.040404p+62, 0x0p+0 },
+{ UINT64_C(0x4101100000000000), 0x1.04044p+62, 0x0p+0 },
+{ UINT64_C(0x4101400000000000), 0x1.0405p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000000000), 0x1.041p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000000001), 0x1.041p+62, 0x1p+0 },
+{ UINT64_C(0x4104000000000008), 0x1.041p+62, 0x1p+3 },
+{ UINT64_C(0x4104000000000010), 0x1.041p+62, 0x1p+4 },
+{ UINT64_C(0x4104000000000020), 0x1.041p+62, 0x1p+5 },
+{ UINT64_C(0x4104000000000040), 0x1.041p+62, 0x1p+6 },
+{ UINT64_C(0x4104000000000200), 0x1.041p+62, 0x1p+9 },
+{ UINT64_C(0x4104000000000800), 0x1.0410000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000001000), 0x1.0410000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000002000), 0x1.0410000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000020000), 0x1.041000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000040000), 0x1.04100000001p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000400000), 0x1.0410000001p+62, 0x0p+0 },
+{ UINT64_C(0x4104000000800000), 0x1.0410000002p+62, 0x0p+0 },
+{ UINT64_C(0x4104000004000000), 0x1.041000001p+62, 0x0p+0 },
+{ UINT64_C(0x4104000008000000), 0x1.041000002p+62, 0x0p+0 },
+{ UINT64_C(0x4104000040000000), 0x1.04100001p+62, 0x0p+0 },
+{ UINT64_C(0x4104000100000000), 0x1.04100004p+62, 0x0p+0 },
+{ UINT64_C(0x4104000400000000), 0x1.0410001p+62, 0x0p+0 },
+{ UINT64_C(0x4104004000000000), 0x1.041001p+62, 0x0p+0 },
+{ UINT64_C(0x4104008000000000), 0x1.041002p+62, 0x0p+0 },
+{ UINT64_C(0x4104040000000000), 0x1.04101p+62, 0x0p+0 },
+{ UINT64_C(0x4104080000000000), 0x1.04102p+62, 0x0p+0 },
+{ UINT64_C(0x4104200000000000), 0x1.04108p+62, 0x0p+0 },
+{ UINT64_C(0x4106000000000000), 0x1.0418p+62, 0x0p+0 },
+{ UINT64_C(0x4120000000000000), 0x1.048p+62, 0x0p+0 },
+{ UINT64_C(0x4120000000000002), 0x1.048p+62, 0x1p+1 },
+{ UINT64_C(0x4120000000000004), 0x1.048p+62, 0x1p+2 },
+{ UINT64_C(0x4120000000000008), 0x1.048p+62, 0x1p+3 },
+{ UINT64_C(0x4120000000000080), 0x1.048p+62, 0x1p+7 },
+{ UINT64_C(0x4120000000000200), 0x1.048p+62, 0x1p+9 },
+{ UINT64_C(0x4120000000002000), 0x1.0480000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4120000000020000), 0x1.048000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4120000000200000), 0x1.04800000008p+62, 0x0p+0 },
+{ UINT64_C(0x4120000000800000), 0x1.0480000002p+62, 0x0p+0 },
+{ UINT64_C(0x4120000008000000), 0x1.048000002p+62, 0x0p+0 },
+{ UINT64_C(0x4120000040000000), 0x1.04800001p+62, 0x0p+0 },
+{ UINT64_C(0x4120000100000000), 0x1.04800004p+62, 0x0p+0 },
+{ UINT64_C(0x4120001000000000), 0x1.0480004p+62, 0x0p+0 },
+{ UINT64_C(0x4120008000000000), 0x1.048002p+62, 0x0p+0 },
+{ UINT64_C(0x4120020000000000), 0x1.048008p+62, 0x0p+0 },
+{ UINT64_C(0x4120200000000000), 0x1.04808p+62, 0x0p+0 },
+{ UINT64_C(0x4121000000000000), 0x1.0484p+62, 0x0p+0 },
+{ UINT64_C(0x4124000000000000), 0x1.049p+62, 0x0p+0 },
+{ UINT64_C(0x4128000000000000), 0x1.04ap+62, 0x0p+0 },
+{ UINT64_C(0x4140000000000000), 0x1.05p+62, 0x0p+0 },
+{ UINT64_C(0x4140000000000002), 0x1.05p+62, 0x1p+1 },
+{ UINT64_C(0x4140000000000004), 0x1.05p+62, 0x1p+2 },
+{ UINT64_C(0x4140000000000020), 0x1.05p+62, 0x1p+5 },
+{ UINT64_C(0x4140000000000080), 0x1.05p+62, 0x1p+7 },
+{ UINT64_C(0x4140000000000200), 0x1.05p+62, 0x1p+9 },
+{ UINT64_C(0x4140000000000800), 0x1.0500000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4140000000001000), 0x1.0500000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4140000000004000), 0x1.050000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4140000000040000), 0x1.05000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4140000000100000), 0x1.05000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4140000001000000), 0x1.0500000004p+62, 0x0p+0 },
+{ UINT64_C(0x4140000004000000), 0x1.050000001p+62, 0x0p+0 },
+{ UINT64_C(0x4140000008000000), 0x1.050000002p+62, 0x0p+0 },
+{ UINT64_C(0x4140000040000000), 0x1.05000001p+62, 0x0p+0 },
+{ UINT64_C(0x4140000100000000), 0x1.05000004p+62, 0x0p+0 },
+{ UINT64_C(0x4140000400000000), 0x1.0500001p+62, 0x0p+0 },
+{ UINT64_C(0x4140000800000000), 0x1.0500002p+62, 0x0p+0 },
+{ UINT64_C(0x4140002000000000), 0x1.0500008p+62, 0x0p+0 },
+{ UINT64_C(0x4140010000000000), 0x1.050004p+62, 0x0p+0 },
+{ UINT64_C(0x4140080000000000), 0x1.05002p+62, 0x0p+0 },
+{ UINT64_C(0x4140400000000000), 0x1.0501p+62, 0x0p+0 },
+{ UINT64_C(0x4141000000000000), 0x1.0504p+62, 0x0p+0 },
+{ UINT64_C(0x4150000000000000), 0x1.054p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000000008), 0x1.2p+62, 0x1p+3 },
+{ UINT64_C(0x480000000000000c), 0x1.2p+62, 0x1.8p+3 },
+{ UINT64_C(0x4800000000000080), 0x1.2p+62, 0x1p+7 },
+{ UINT64_C(0x4800000000000081), 0x1.2p+62, 0x1.02p+7 },
+{ UINT64_C(0x4800000000000090), 0x1.2p+62, 0x1.2p+7 },
+{ UINT64_C(0x48000000000000a0), 0x1.2p+62, 0x1.4p+7 },
+{ UINT64_C(0x4800000000000200), 0x1.2p+62, 0x1p+9 },
+{ UINT64_C(0x4800000000000208), 0x1.2000000000001p+62, -0x1.f8p+8 },
+{ UINT64_C(0x4800000000000240), 0x1.2000000000001p+62, -0x1.cp+8 },
+{ UINT64_C(0x4800000000000800), 0x1.2000000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000000802), 0x1.2000000000002p+62, 0x1p+1 },
+{ UINT64_C(0x4800000000000808), 0x1.2000000000002p+62, 0x1p+3 },
+{ UINT64_C(0x4800000000000840), 0x1.2000000000002p+62, 0x1p+6 },
+{ UINT64_C(0x4800000000000900), 0x1.2000000000002p+62, 0x1p+8 },
+{ UINT64_C(0x4800000000000a00), 0x1.2000000000002p+62, 0x1p+9 },
+{ UINT64_C(0x4800000000008000), 0x1.200000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000008008), 0x1.200000000002p+62, 0x1p+3 },
+{ UINT64_C(0x4800000000008080), 0x1.200000000002p+62, 0x1p+7 },
+{ UINT64_C(0x4800000000008200), 0x1.200000000002p+62, 0x1p+9 },
+{ UINT64_C(0x4800000000008400), 0x1.2000000000021p+62, 0x0p+0 },
+{ UINT64_C(0x480000000000a000), 0x1.2000000000028p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000040000), 0x1.20000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000040001), 0x1.20000000001p+62, 0x1p+0 },
+{ UINT64_C(0x4800000000040010), 0x1.20000000001p+62, 0x1p+4 },
+{ UINT64_C(0x4800000000040020), 0x1.20000000001p+62, 0x1p+5 },
+{ UINT64_C(0x4800000000040200), 0x1.20000000001p+62, 0x1p+9 },
+{ UINT64_C(0x4800000000040400), 0x1.2000000000101p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000042000), 0x1.2000000000108p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000050000), 0x1.200000000014p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000100000), 0x1.20000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000100002), 0x1.20000000004p+62, 0x1p+1 },
+{ UINT64_C(0x4800000000100008), 0x1.20000000004p+62, 0x1p+3 },
+{ UINT64_C(0x4800000000100080), 0x1.20000000004p+62, 0x1p+7 },
+{ UINT64_C(0x4800000000100100), 0x1.20000000004p+62, 0x1p+8 },
+{ UINT64_C(0x4800000000100800), 0x1.2000000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000104000), 0x1.200000000041p+62, 0x0p+0 },
+{ UINT64_C(0x4800000000120000), 0x1.200000000048p+62, 0x0p+0 },
+{ UINT64_C(0x4800000001000000), 0x1.2000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000001000008), 0x1.2000000004p+62, 0x1p+3 },
+{ UINT64_C(0x4800000001000040), 0x1.2000000004p+62, 0x1p+6 },
+{ UINT64_C(0x4800000001000100), 0x1.2000000004p+62, 0x1p+8 },
+{ UINT64_C(0x4800000001000200), 0x1.2000000004p+62, 0x1p+9 },
+{ UINT64_C(0x4800000001002000), 0x1.2000000004008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000001008000), 0x1.200000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4800000001010000), 0x1.200000000404p+62, 0x0p+0 },
+{ UINT64_C(0x4800000001020000), 0x1.200000000408p+62, 0x0p+0 },
+{ UINT64_C(0x4800000001200000), 0x1.20000000048p+62, 0x0p+0 },
+{ UINT64_C(0x4800000010000000), 0x1.200000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000010000008), 0x1.200000004p+62, 0x1p+3 },
+{ UINT64_C(0x4800000010000080), 0x1.200000004p+62, 0x1p+7 },
+{ UINT64_C(0x4800000010000200), 0x1.200000004p+62, 0x1p+9 },
+{ UINT64_C(0x4800000010001000), 0x1.2000000040004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000010002000), 0x1.2000000040008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000010010000), 0x1.200000004004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000010100000), 0x1.20000000404p+62, 0x0p+0 },
+{ UINT64_C(0x4800000011000000), 0x1.2000000044p+62, 0x0p+0 },
+{ UINT64_C(0x4800000012000000), 0x1.2000000048p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020000000), 0x1.200000008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020000002), 0x1.200000008p+62, 0x1p+1 },
+{ UINT64_C(0x4800000020000010), 0x1.200000008p+62, 0x1p+4 },
+{ UINT64_C(0x4800000020000080), 0x1.200000008p+62, 0x1p+7 },
+{ UINT64_C(0x4800000020000400), 0x1.2000000080001p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020000800), 0x1.2000000080002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020001000), 0x1.2000000080004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020008000), 0x1.200000008002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020020000), 0x1.200000008008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020040000), 0x1.20000000801p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020100000), 0x1.20000000804p+62, 0x0p+0 },
+{ UINT64_C(0x4800000020400000), 0x1.2000000081p+62, 0x0p+0 },
+{ UINT64_C(0x4800000024000000), 0x1.200000009p+62, 0x0p+0 },
+{ UINT64_C(0x4800000030000000), 0x1.20000000cp+62, 0x0p+0 },
+{ UINT64_C(0x4800000080000000), 0x1.20000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000080000004), 0x1.20000002p+62, 0x1p+2 },
+{ UINT64_C(0x4800000080000020), 0x1.20000002p+62, 0x1p+5 },
+{ UINT64_C(0x4800000080000080), 0x1.20000002p+62, 0x1p+7 },
+{ UINT64_C(0x4800000080000800), 0x1.2000000200002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000080008000), 0x1.200000020002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000080010000), 0x1.200000020004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000080080000), 0x1.20000002002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000080200000), 0x1.20000002008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000080800000), 0x1.2000000202p+62, 0x0p+0 },
+{ UINT64_C(0x4800000084000000), 0x1.200000021p+62, 0x0p+0 },
+{ UINT64_C(0x4800000088000000), 0x1.200000022p+62, 0x0p+0 },
+{ UINT64_C(0x48000000c0000000), 0x1.20000003p+62, 0x0p+0 },
+{ UINT64_C(0x4800000100000000), 0x1.20000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000100000001), 0x1.20000004p+62, 0x1p+0 },
+{ UINT64_C(0x4800000100000004), 0x1.20000004p+62, 0x1p+2 },
+{ UINT64_C(0x4800000100000010), 0x1.20000004p+62, 0x1p+4 },
+{ UINT64_C(0x4800000100000040), 0x1.20000004p+62, 0x1p+6 },
+{ UINT64_C(0x4800000100000100), 0x1.20000004p+62, 0x1p+8 },
+{ UINT64_C(0x4800000100001000), 0x1.2000000400004p+62, 0x0p+0 },
+{ UINT64_C(0x4800000100004000), 0x1.200000040001p+62, 0x0p+0 },
+{ UINT64_C(0x4800000100020000), 0x1.200000040008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000100080000), 0x1.20000004002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000100800000), 0x1.2000000402p+62, 0x0p+0 },
+{ UINT64_C(0x4800000101000000), 0x1.2000000404p+62, 0x0p+0 },
+{ UINT64_C(0x4800000110000000), 0x1.200000044p+62, 0x0p+0 },
+{ UINT64_C(0x4800000120000000), 0x1.200000048p+62, 0x0p+0 },
+{ UINT64_C(0x4800000800000000), 0x1.2000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000800000004), 0x1.2000002p+62, 0x1p+2 },
+{ UINT64_C(0x4800000800000010), 0x1.2000002p+62, 0x1p+4 },
+{ UINT64_C(0x4800000800000020), 0x1.2000002p+62, 0x1p+5 },
+{ UINT64_C(0x4800000800000080), 0x1.2000002p+62, 0x1p+7 },
+{ UINT64_C(0x4800000800000800), 0x1.2000002000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000800008000), 0x1.200000200002p+62, 0x0p+0 },
+{ UINT64_C(0x4800000800040000), 0x1.20000020001p+62, 0x0p+0 },
+{ UINT64_C(0x4800000800400000), 0x1.2000002001p+62, 0x0p+0 },
+{ UINT64_C(0x4800000802000000), 0x1.2000002008p+62, 0x0p+0 },
+{ UINT64_C(0x4800000808000000), 0x1.200000202p+62, 0x0p+0 },
+{ UINT64_C(0x4800000810000000), 0x1.200000204p+62, 0x0p+0 },
+{ UINT64_C(0x4800000820000000), 0x1.200000208p+62, 0x0p+0 },
+{ UINT64_C(0x4800000840000000), 0x1.20000021p+62, 0x0p+0 },
+{ UINT64_C(0x4800000c00000000), 0x1.2000003p+62, 0x0p+0 },
+{ UINT64_C(0x4800008000000000), 0x1.200002p+62, 0x0p+0 },
+{ UINT64_C(0x4800008000000004), 0x1.200002p+62, 0x1p+2 },
+{ UINT64_C(0x4800008000000040), 0x1.200002p+62, 0x1p+6 },
+{ UINT64_C(0x4800008000000080), 0x1.200002p+62, 0x1p+7 },
+{ UINT64_C(0x4800008000000800), 0x1.2000020000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800008000004000), 0x1.200002000001p+62, 0x0p+0 },
+{ UINT64_C(0x4800008000010000), 0x1.200002000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800008000100000), 0x1.20000200004p+62, 0x0p+0 },
+{ UINT64_C(0x4800008000200000), 0x1.20000200008p+62, 0x0p+0 },
+{ UINT64_C(0x4800008001000000), 0x1.2000020004p+62, 0x0p+0 },
+{ UINT64_C(0x4800008002000000), 0x1.2000020008p+62, 0x0p+0 },
+{ UINT64_C(0x4800008010000000), 0x1.200002004p+62, 0x0p+0 },
+{ UINT64_C(0x4800008040000000), 0x1.20000201p+62, 0x0p+0 },
+{ UINT64_C(0x4800008200000000), 0x1.20000208p+62, 0x0p+0 },
+{ UINT64_C(0x4800009000000000), 0x1.2000024p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000000000), 0x1.20002p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000000008), 0x1.20002p+62, 0x1p+3 },
+{ UINT64_C(0x4800080000000020), 0x1.20002p+62, 0x1p+5 },
+{ UINT64_C(0x4800080000000200), 0x1.20002p+62, 0x1p+9 },
+{ UINT64_C(0x4800080000000800), 0x1.2000200000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000001000), 0x1.2000200000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000004000), 0x1.200020000001p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000020000), 0x1.200020000008p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000100000), 0x1.20002000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800080000400000), 0x1.2000200001p+62, 0x0p+0 },
+{ UINT64_C(0x4800080002000000), 0x1.2000200008p+62, 0x0p+0 },
+{ UINT64_C(0x4800080004000000), 0x1.200020001p+62, 0x0p+0 },
+{ UINT64_C(0x4800080020000000), 0x1.200020008p+62, 0x0p+0 },
+{ UINT64_C(0x4800080040000000), 0x1.20002001p+62, 0x0p+0 },
+{ UINT64_C(0x4800080080000000), 0x1.20002002p+62, 0x0p+0 },
+{ UINT64_C(0x4800080800000000), 0x1.2000202p+62, 0x0p+0 },
+{ UINT64_C(0x4800082000000000), 0x1.2000208p+62, 0x0p+0 },
+{ UINT64_C(0x48000a0000000000), 0x1.200028p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000000000), 0x1.2002p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000000008), 0x1.2002p+62, 0x1p+3 },
+{ UINT64_C(0x4800800000000010), 0x1.2002p+62, 0x1p+4 },
+{ UINT64_C(0x4800800000000020), 0x1.2002p+62, 0x1p+5 },
+{ UINT64_C(0x4800800000000100), 0x1.2002p+62, 0x1p+8 },
+{ UINT64_C(0x4800800000000400), 0x1.2002000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000001000), 0x1.2002000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000010000), 0x1.200200000004p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000080000), 0x1.20020000002p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000200000), 0x1.20020000008p+62, 0x0p+0 },
+{ UINT64_C(0x4800800000400000), 0x1.2002000001p+62, 0x0p+0 },
+{ UINT64_C(0x4800800002000000), 0x1.2002000008p+62, 0x0p+0 },
+{ UINT64_C(0x4800800010000000), 0x1.200200004p+62, 0x0p+0 },
+{ UINT64_C(0x4800800020000000), 0x1.200200008p+62, 0x0p+0 },
+{ UINT64_C(0x4800800100000000), 0x1.20020004p+62, 0x0p+0 },
+{ UINT64_C(0x4800800400000000), 0x1.2002001p+62, 0x0p+0 },
+{ UINT64_C(0x4800804000000000), 0x1.200201p+62, 0x0p+0 },
+{ UINT64_C(0x4800810000000000), 0x1.200204p+62, 0x0p+0 },
+{ UINT64_C(0x4800820000000000), 0x1.200208p+62, 0x0p+0 },
+{ UINT64_C(0x4800840000000000), 0x1.20021p+62, 0x0p+0 },
+{ UINT64_C(0x4800880000000000), 0x1.20022p+62, 0x0p+0 },
+{ UINT64_C(0x4800c00000000000), 0x1.2003p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000000000), 0x1.201p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000000002), 0x1.201p+62, 0x1p+1 },
+{ UINT64_C(0x4804000000000010), 0x1.201p+62, 0x1p+4 },
+{ UINT64_C(0x4804000000000040), 0x1.201p+62, 0x1p+6 },
+{ UINT64_C(0x4804000000000200), 0x1.201p+62, 0x1p+9 },
+{ UINT64_C(0x4804000000000800), 0x1.2010000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000002000), 0x1.2010000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000010000), 0x1.201000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000040000), 0x1.20100000001p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000080000), 0x1.20100000002p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000100000), 0x1.20100000004p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000400000), 0x1.2010000001p+62, 0x0p+0 },
+{ UINT64_C(0x4804000000800000), 0x1.2010000002p+62, 0x0p+0 },
+{ UINT64_C(0x4804000002000000), 0x1.2010000008p+62, 0x0p+0 },
+{ UINT64_C(0x4804000020000000), 0x1.201000008p+62, 0x0p+0 },
+{ UINT64_C(0x4804000200000000), 0x1.20100008p+62, 0x0p+0 },
+{ UINT64_C(0x4804002000000000), 0x1.2010008p+62, 0x0p+0 },
+{ UINT64_C(0x4804008000000000), 0x1.201002p+62, 0x0p+0 },
+{ UINT64_C(0x4804010000000000), 0x1.201004p+62, 0x0p+0 },
+{ UINT64_C(0x4804100000000000), 0x1.20104p+62, 0x0p+0 },
+{ UINT64_C(0x4805000000000000), 0x1.2014p+62, 0x0p+0 },
+{ UINT64_C(0x4810000000000000), 0x1.204p+62, 0x0p+0 },
+{ UINT64_C(0x4810000000000002), 0x1.204p+62, 0x1p+1 },
+{ UINT64_C(0x4810000000000020), 0x1.204p+62, 0x1p+5 },
+{ UINT64_C(0x4810000000000200), 0x1.204p+62, 0x1p+9 },
+{ UINT64_C(0x4810000000002000), 0x1.2040000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4810000000004000), 0x1.204000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4810000000020000), 0x1.204000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4810000000080000), 0x1.20400000002p+62, 0x0p+0 },
+{ UINT64_C(0x4810000000800000), 0x1.2040000002p+62, 0x0p+0 },
+{ UINT64_C(0x4810000008000000), 0x1.204000002p+62, 0x0p+0 },
+{ UINT64_C(0x4810000020000000), 0x1.204000008p+62, 0x0p+0 },
+{ UINT64_C(0x4810000040000000), 0x1.20400001p+62, 0x0p+0 },
+{ UINT64_C(0x4810000080000000), 0x1.20400002p+62, 0x0p+0 },
+{ UINT64_C(0x4810000100000000), 0x1.20400004p+62, 0x0p+0 },
+{ UINT64_C(0x4810000200000000), 0x1.20400008p+62, 0x0p+0 },
+{ UINT64_C(0x4810002000000000), 0x1.2040008p+62, 0x0p+0 },
+{ UINT64_C(0x4810020000000000), 0x1.204008p+62, 0x0p+0 },
+{ UINT64_C(0x4810200000000000), 0x1.20408p+62, 0x0p+0 },
+{ UINT64_C(0x4812000000000000), 0x1.2048p+62, 0x0p+0 },
+{ UINT64_C(0x4818000000000000), 0x1.206p+62, 0x0p+0 },
+{ UINT64_C(0x4900000000000000), 0x1.24p+62, 0x0p+0 },
+{ UINT64_C(0x4900000000000004), 0x1.24p+62, 0x1p+2 },
+{ UINT64_C(0x4900000000000020), 0x1.24p+62, 0x1p+5 },
+{ UINT64_C(0x4900000000000200), 0x1.24p+62, 0x1p+9 },
+{ UINT64_C(0x4900000000001000), 0x1.2400000000004p+62, 0x0p+0 },
+{ UINT64_C(0x4900000000008000), 0x1.240000000002p+62, 0x0p+0 },
+{ UINT64_C(0x4900000000040000), 0x1.24000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4900000000200000), 0x1.24000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4900000000800000), 0x1.2400000002p+62, 0x0p+0 },
+{ UINT64_C(0x4900000008000000), 0x1.240000002p+62, 0x0p+0 },
+{ UINT64_C(0x4900000040000000), 0x1.24000001p+62, 0x0p+0 },
+{ UINT64_C(0x4900000080000000), 0x1.24000002p+62, 0x0p+0 },
+{ UINT64_C(0x4900000400000000), 0x1.2400001p+62, 0x0p+0 },
+{ UINT64_C(0x4900001000000000), 0x1.2400004p+62, 0x0p+0 },
+{ UINT64_C(0x4900004000000000), 0x1.240001p+62, 0x0p+0 },
+{ UINT64_C(0x4900040000000000), 0x1.24001p+62, 0x0p+0 },
+{ UINT64_C(0x4900200000000000), 0x1.24008p+62, 0x0p+0 },
+{ UINT64_C(0x4901000000000000), 0x1.2404p+62, 0x0p+0 },
+{ UINT64_C(0x4910000000000000), 0x1.244p+62, 0x0p+0 },
+{ UINT64_C(0x4980000000000000), 0x1.26p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000000000000), 0x1.3p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000000000008), 0x1.3p+62, 0x1p+3 },
+{ UINT64_C(0x4c00000000000080), 0x1.3p+62, 0x1p+7 },
+{ UINT64_C(0x4c00000000000400), 0x1.3000000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000000002000), 0x1.3000000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000000004000), 0x1.300000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000000040000), 0x1.30000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000000400000), 0x1.3000000001p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000002000000), 0x1.3000000008p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000004000000), 0x1.300000001p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000008000000), 0x1.300000002p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000080000000), 0x1.30000002p+62, 0x0p+0 },
+{ UINT64_C(0x4c00000200000000), 0x1.30000008p+62, 0x0p+0 },
+{ UINT64_C(0x4c00002000000000), 0x1.3000008p+62, 0x0p+0 },
+{ UINT64_C(0x4c00010000000000), 0x1.300004p+62, 0x0p+0 },
+{ UINT64_C(0x4c00040000000000), 0x1.30001p+62, 0x0p+0 },
+{ UINT64_C(0x4c00080000000000), 0x1.30002p+62, 0x0p+0 },
+{ UINT64_C(0x4c00800000000000), 0x1.3002p+62, 0x0p+0 },
+{ UINT64_C(0x4c01000000000000), 0x1.3004p+62, 0x0p+0 },
+{ UINT64_C(0x4c04000000000000), 0x1.301p+62, 0x0p+0 },
+{ UINT64_C(0x4c40000000000000), 0x1.31p+62, 0x0p+0 },
+{ UINT64_C(0x4e00000000000000), 0x1.38p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000000008), 0x1.8p+62, 0x1p+3 },
+{ UINT64_C(0x600000000000000a), 0x1.8p+62, 0x1.4p+3 },
+{ UINT64_C(0x6000000000000080), 0x1.8p+62, 0x1p+7 },
+{ UINT64_C(0x6000000000000088), 0x1.8p+62, 0x1.1p+7 },
+{ UINT64_C(0x60000000000000a0), 0x1.8p+62, 0x1.4p+7 },
+{ UINT64_C(0x6000000000000400), 0x1.8000000000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000000408), 0x1.8000000000001p+62, 0x1p+3 },
+{ UINT64_C(0x6000000000000420), 0x1.8000000000001p+62, 0x1p+5 },
+{ UINT64_C(0x6000000000000480), 0x1.8000000000001p+62, 0x1p+7 },
+{ UINT64_C(0x6000000000000500), 0x1.8000000000001p+62, 0x1p+8 },
+{ UINT64_C(0x6000000000004000), 0x1.800000000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000004001), 0x1.800000000001p+62, 0x1p+0 },
+{ UINT64_C(0x6000000000004004), 0x1.800000000001p+62, 0x1p+2 },
+{ UINT64_C(0x6000000000004040), 0x1.800000000001p+62, 0x1p+6 },
+{ UINT64_C(0x6000000000004080), 0x1.800000000001p+62, 0x1p+7 },
+{ UINT64_C(0x6000000000004800), 0x1.8000000000012p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000008000), 0x1.800000000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000008008), 0x1.800000000002p+62, 0x1p+3 },
+{ UINT64_C(0x6000000000008010), 0x1.800000000002p+62, 0x1p+4 },
+{ UINT64_C(0x6000000000008080), 0x1.800000000002p+62, 0x1p+7 },
+{ UINT64_C(0x6000000000008100), 0x1.800000000002p+62, 0x1p+8 },
+{ UINT64_C(0x6000000000008800), 0x1.8000000000022p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000080000), 0x1.80000000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000080004), 0x1.80000000002p+62, 0x1p+2 },
+{ UINT64_C(0x6000000000080008), 0x1.80000000002p+62, 0x1p+3 },
+{ UINT64_C(0x6000000000080020), 0x1.80000000002p+62, 0x1p+5 },
+{ UINT64_C(0x6000000000080040), 0x1.80000000002p+62, 0x1p+6 },
+{ UINT64_C(0x6000000000080200), 0x1.80000000002p+62, 0x1p+9 },
+{ UINT64_C(0x6000000000082000), 0x1.8000000000208p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000088000), 0x1.800000000022p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000200000), 0x1.80000000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000200002), 0x1.80000000008p+62, 0x1p+1 },
+{ UINT64_C(0x6000000000200020), 0x1.80000000008p+62, 0x1p+5 },
+{ UINT64_C(0x6000000000200100), 0x1.80000000008p+62, 0x1p+8 },
+{ UINT64_C(0x6000000000200200), 0x1.80000000008p+62, 0x1p+9 },
+{ UINT64_C(0x6000000000200800), 0x1.8000000000802p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000208000), 0x1.800000000082p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000240000), 0x1.80000000009p+62, 0x0p+0 },
+{ UINT64_C(0x6000000000300000), 0x1.8000000000cp+62, 0x0p+0 },
+{ UINT64_C(0x6000000001000000), 0x1.8000000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000001000004), 0x1.8000000004p+62, 0x1p+2 },
+{ UINT64_C(0x6000000001000020), 0x1.8000000004p+62, 0x1p+5 },
+{ UINT64_C(0x6000000001000100), 0x1.8000000004p+62, 0x1p+8 },
+{ UINT64_C(0x6000000001000200), 0x1.8000000004p+62, 0x1p+9 },
+{ UINT64_C(0x6000000001001000), 0x1.8000000004004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000001010000), 0x1.800000000404p+62, 0x0p+0 },
+{ UINT64_C(0x6000000001080000), 0x1.80000000042p+62, 0x0p+0 },
+{ UINT64_C(0x6000000001200000), 0x1.80000000048p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002000000), 0x1.8000000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002000004), 0x1.8000000008p+62, 0x1p+2 },
+{ UINT64_C(0x6000000002000020), 0x1.8000000008p+62, 0x1p+5 },
+{ UINT64_C(0x6000000002000200), 0x1.8000000008p+62, 0x1p+9 },
+{ UINT64_C(0x6000000002000400), 0x1.8000000008001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002000800), 0x1.8000000008002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002002000), 0x1.8000000008008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002010000), 0x1.800000000804p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002080000), 0x1.80000000082p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002200000), 0x1.80000000088p+62, 0x0p+0 },
+{ UINT64_C(0x6000000002800000), 0x1.800000000ap+62, 0x0p+0 },
+{ UINT64_C(0x6000000008000000), 0x1.800000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000008000002), 0x1.800000002p+62, 0x1p+1 },
+{ UINT64_C(0x6000000008000010), 0x1.800000002p+62, 0x1p+4 },
+{ UINT64_C(0x6000000008000020), 0x1.800000002p+62, 0x1p+5 },
+{ UINT64_C(0x6000000008000200), 0x1.800000002p+62, 0x1p+9 },
+{ UINT64_C(0x6000000008002000), 0x1.8000000020008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000008010000), 0x1.800000002004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000008040000), 0x1.80000000201p+62, 0x0p+0 },
+{ UINT64_C(0x6000000008100000), 0x1.80000000204p+62, 0x0p+0 },
+{ UINT64_C(0x6000000009000000), 0x1.8000000024p+62, 0x0p+0 },
+{ UINT64_C(0x6000000040000000), 0x1.80000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000040000002), 0x1.80000001p+62, 0x1p+1 },
+{ UINT64_C(0x6000000040000020), 0x1.80000001p+62, 0x1p+5 },
+{ UINT64_C(0x6000000040000080), 0x1.80000001p+62, 0x1p+7 },
+{ UINT64_C(0x6000000040000200), 0x1.80000001p+62, 0x1p+9 },
+{ UINT64_C(0x6000000040000400), 0x1.8000000100001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000040002000), 0x1.8000000100008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000040020000), 0x1.800000010008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000040040000), 0x1.80000001001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000040200000), 0x1.80000001008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000041000000), 0x1.8000000104p+62, 0x0p+0 },
+{ UINT64_C(0x6000000044000000), 0x1.800000011p+62, 0x0p+0 },
+{ UINT64_C(0x6000000060000000), 0x1.800000018p+62, 0x0p+0 },
+{ UINT64_C(0x6000000100000000), 0x1.80000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000100000002), 0x1.80000004p+62, 0x1p+1 },
+{ UINT64_C(0x6000000100000008), 0x1.80000004p+62, 0x1p+3 },
+{ UINT64_C(0x6000000100000020), 0x1.80000004p+62, 0x1p+5 },
+{ UINT64_C(0x6000000100000200), 0x1.80000004p+62, 0x1p+9 },
+{ UINT64_C(0x6000000100000400), 0x1.8000000400001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000100001000), 0x1.8000000400004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000100002000), 0x1.8000000400008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000100020000), 0x1.800000040008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000100200000), 0x1.80000004008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000101000000), 0x1.8000000404p+62, 0x0p+0 },
+{ UINT64_C(0x6000000104000000), 0x1.800000041p+62, 0x0p+0 },
+{ UINT64_C(0x6000000110000000), 0x1.800000044p+62, 0x0p+0 },
+{ UINT64_C(0x6000000180000000), 0x1.80000006p+62, 0x0p+0 },
+{ UINT64_C(0x6000000200000000), 0x1.80000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000200000004), 0x1.80000008p+62, 0x1p+2 },
+{ UINT64_C(0x6000000200000010), 0x1.80000008p+62, 0x1p+4 },
+{ UINT64_C(0x6000000200000040), 0x1.80000008p+62, 0x1p+6 },
+{ UINT64_C(0x6000000200000200), 0x1.80000008p+62, 0x1p+9 },
+{ UINT64_C(0x6000000200000400), 0x1.8000000800001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000200001000), 0x1.8000000800004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000200010000), 0x1.800000080004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000200040000), 0x1.80000008001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000200100000), 0x1.80000008004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000201000000), 0x1.8000000804p+62, 0x0p+0 },
+{ UINT64_C(0x6000000210000000), 0x1.800000084p+62, 0x0p+0 },
+{ UINT64_C(0x6000000280000000), 0x1.8000000ap+62, 0x0p+0 },
+{ UINT64_C(0x6000000300000000), 0x1.8000000cp+62, 0x0p+0 },
+{ UINT64_C(0x6000000400000000), 0x1.8000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000400000001), 0x1.8000001p+62, 0x1p+0 },
+{ UINT64_C(0x6000000400000002), 0x1.8000001p+62, 0x1p+1 },
+{ UINT64_C(0x6000000400000008), 0x1.8000001p+62, 0x1p+3 },
+{ UINT64_C(0x6000000400000010), 0x1.8000001p+62, 0x1p+4 },
+{ UINT64_C(0x6000000400000040), 0x1.8000001p+62, 0x1p+6 },
+{ UINT64_C(0x6000000400000400), 0x1.8000001000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000000400000800), 0x1.8000001000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000400002000), 0x1.8000001000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000000400010000), 0x1.800000100004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000400080000), 0x1.80000010002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000400800000), 0x1.8000001002p+62, 0x0p+0 },
+{ UINT64_C(0x6000000401000000), 0x1.8000001004p+62, 0x0p+0 },
+{ UINT64_C(0x6000000410000000), 0x1.800000104p+62, 0x0p+0 },
+{ UINT64_C(0x6000000420000000), 0x1.800000108p+62, 0x0p+0 },
+{ UINT64_C(0x6000000500000000), 0x1.80000014p+62, 0x0p+0 },
+{ UINT64_C(0x6000000600000000), 0x1.80000018p+62, 0x0p+0 },
+{ UINT64_C(0x6000004000000000), 0x1.800001p+62, 0x0p+0 },
+{ UINT64_C(0x6000004000000001), 0x1.800001p+62, 0x1p+0 },
+{ UINT64_C(0x6000004000000002), 0x1.800001p+62, 0x1p+1 },
+{ UINT64_C(0x6000004000000004), 0x1.800001p+62, 0x1p+2 },
+{ UINT64_C(0x6000004000000008), 0x1.800001p+62, 0x1p+3 },
+{ UINT64_C(0x6000004000000020), 0x1.800001p+62, 0x1p+5 },
+{ UINT64_C(0x6000004000000100), 0x1.800001p+62, 0x1p+8 },
+{ UINT64_C(0x6000004000000800), 0x1.8000010000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000004000001000), 0x1.8000010000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000004000004000), 0x1.800001000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000004000040000), 0x1.80000100001p+62, 0x0p+0 },
+{ UINT64_C(0x6000004000200000), 0x1.80000100008p+62, 0x0p+0 },
+{ UINT64_C(0x6000004001000000), 0x1.8000010004p+62, 0x0p+0 },
+{ UINT64_C(0x6000004010000000), 0x1.800001004p+62, 0x0p+0 },
+{ UINT64_C(0x6000004080000000), 0x1.80000102p+62, 0x0p+0 },
+{ UINT64_C(0x6000004100000000), 0x1.80000104p+62, 0x0p+0 },
+{ UINT64_C(0x6000004800000000), 0x1.8000012p+62, 0x0p+0 },
+{ UINT64_C(0x6000006000000000), 0x1.8000018p+62, 0x0p+0 },
+{ UINT64_C(0x6000020000000000), 0x1.800008p+62, 0x0p+0 },
+{ UINT64_C(0x6000020000000004), 0x1.800008p+62, 0x1p+2 },
+{ UINT64_C(0x6000020000000040), 0x1.800008p+62, 0x1p+6 },
+{ UINT64_C(0x6000020000000080), 0x1.800008p+62, 0x1p+7 },
+{ UINT64_C(0x6000020000000100), 0x1.800008p+62, 0x1p+8 },
+{ UINT64_C(0x6000020000000400), 0x1.8000080000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000020000004000), 0x1.800008000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000020000020000), 0x1.800008000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000020000200000), 0x1.80000800008p+62, 0x0p+0 },
+{ UINT64_C(0x6000020002000000), 0x1.8000080008p+62, 0x0p+0 },
+{ UINT64_C(0x6000020004000000), 0x1.800008001p+62, 0x0p+0 },
+{ UINT64_C(0x6000020020000000), 0x1.800008008p+62, 0x0p+0 },
+{ UINT64_C(0x6000020040000000), 0x1.80000801p+62, 0x0p+0 },
+{ UINT64_C(0x6000020400000000), 0x1.8000081p+62, 0x0p+0 },
+{ UINT64_C(0x6000021000000000), 0x1.8000084p+62, 0x0p+0 },
+{ UINT64_C(0x6000030000000000), 0x1.80000cp+62, 0x0p+0 },
+{ UINT64_C(0x6000100000000000), 0x1.80004p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000000008), 0x1.80004p+62, 0x1p+3 },
+{ UINT64_C(0x6000100000000010), 0x1.80004p+62, 0x1p+4 },
+{ UINT64_C(0x6000100000000040), 0x1.80004p+62, 0x1p+6 },
+{ UINT64_C(0x6000100000000080), 0x1.80004p+62, 0x1p+7 },
+{ UINT64_C(0x6000100000000200), 0x1.80004p+62, 0x1p+9 },
+{ UINT64_C(0x6000100000000400), 0x1.8000400000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000000800), 0x1.8000400000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000004000), 0x1.800040000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000008000), 0x1.800040000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000010000), 0x1.800040000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000020000), 0x1.800040000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000040000), 0x1.80004000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000080000), 0x1.80004000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000100000800000), 0x1.8000400002p+62, 0x0p+0 },
+{ UINT64_C(0x6000100004000000), 0x1.800040001p+62, 0x0p+0 },
+{ UINT64_C(0x6000100040000000), 0x1.80004001p+62, 0x0p+0 },
+{ UINT64_C(0x6000100080000000), 0x1.80004002p+62, 0x0p+0 },
+{ UINT64_C(0x6000100800000000), 0x1.8000402p+62, 0x0p+0 },
+{ UINT64_C(0x6000101000000000), 0x1.8000404p+62, 0x0p+0 },
+{ UINT64_C(0x6000102000000000), 0x1.8000408p+62, 0x0p+0 },
+{ UINT64_C(0x6000120000000000), 0x1.800048p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000000000), 0x1.80008p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000000002), 0x1.80008p+62, 0x1p+1 },
+{ UINT64_C(0x6000200000000004), 0x1.80008p+62, 0x1p+2 },
+{ UINT64_C(0x6000200000000020), 0x1.80008p+62, 0x1p+5 },
+{ UINT64_C(0x6000200000000100), 0x1.80008p+62, 0x1p+8 },
+{ UINT64_C(0x6000200000000200), 0x1.80008p+62, 0x1p+9 },
+{ UINT64_C(0x6000200000000800), 0x1.8000800000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000008000), 0x1.800080000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000010000), 0x1.800080000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000040000), 0x1.80008000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000200000), 0x1.80008000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000200000400000), 0x1.8000800001p+62, 0x0p+0 },
+{ UINT64_C(0x6000200002000000), 0x1.8000800008p+62, 0x0p+0 },
+{ UINT64_C(0x6000200020000000), 0x1.800080008p+62, 0x0p+0 },
+{ UINT64_C(0x6000200080000000), 0x1.80008002p+62, 0x0p+0 },
+{ UINT64_C(0x6000200200000000), 0x1.80008008p+62, 0x0p+0 },
+{ UINT64_C(0x6000201000000000), 0x1.8000804p+62, 0x0p+0 },
+{ UINT64_C(0x6000208000000000), 0x1.800082p+62, 0x0p+0 },
+{ UINT64_C(0x6000280000000000), 0x1.8000ap+62, 0x0p+0 },
+{ UINT64_C(0x6000800000000000), 0x1.8002p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000000001), 0x1.8002p+62, 0x1p+0 },
+{ UINT64_C(0x6000800000000004), 0x1.8002p+62, 0x1p+2 },
+{ UINT64_C(0x6000800000000010), 0x1.8002p+62, 0x1p+4 },
+{ UINT64_C(0x6000800000000100), 0x1.8002p+62, 0x1p+8 },
+{ UINT64_C(0x6000800000000400), 0x1.8002000000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000001000), 0x1.8002000000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000002000), 0x1.8002000000008p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000008000), 0x1.800200000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000040000), 0x1.80020000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000100000), 0x1.80020000004p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000400000), 0x1.8002000001p+62, 0x0p+0 },
+{ UINT64_C(0x6000800000800000), 0x1.8002000002p+62, 0x0p+0 },
+{ UINT64_C(0x6000800008000000), 0x1.800200002p+62, 0x0p+0 },
+{ UINT64_C(0x6000800020000000), 0x1.800200008p+62, 0x0p+0 },
+{ UINT64_C(0x6000800040000000), 0x1.80020001p+62, 0x0p+0 },
+{ UINT64_C(0x6000800080000000), 0x1.80020002p+62, 0x0p+0 },
+{ UINT64_C(0x6000800400000000), 0x1.8002001p+62, 0x0p+0 },
+{ UINT64_C(0x6000800800000000), 0x1.8002002p+62, 0x0p+0 },
+{ UINT64_C(0x6000802000000000), 0x1.8002008p+62, 0x0p+0 },
+{ UINT64_C(0x6000808000000000), 0x1.800202p+62, 0x0p+0 },
+{ UINT64_C(0x6000880000000000), 0x1.80022p+62, 0x0p+0 },
+{ UINT64_C(0x6000900000000000), 0x1.80024p+62, 0x0p+0 },
+{ UINT64_C(0x6000c00000000000), 0x1.8003p+62, 0x0p+0 },
+{ UINT64_C(0x6001000000000000), 0x1.8004p+62, 0x0p+0 },
+{ UINT64_C(0x6001000000000004), 0x1.8004p+62, 0x1p+2 },
+{ UINT64_C(0x6001000000000010), 0x1.8004p+62, 0x1p+4 },
+{ UINT64_C(0x6001000000000100), 0x1.8004p+62, 0x1p+8 },
+{ UINT64_C(0x6001000000001000), 0x1.8004000000004p+62, 0x0p+0 },
+{ UINT64_C(0x6001000000010000), 0x1.800400000004p+62, 0x0p+0 },
+{ UINT64_C(0x6001000000020000), 0x1.800400000008p+62, 0x0p+0 },
+{ UINT64_C(0x6001000000040000), 0x1.80040000001p+62, 0x0p+0 },
+{ UINT64_C(0x6001000000200000), 0x1.80040000008p+62, 0x0p+0 },
+{ UINT64_C(0x6001000002000000), 0x1.8004000008p+62, 0x0p+0 },
+{ UINT64_C(0x6001000010000000), 0x1.800400004p+62, 0x0p+0 },
+{ UINT64_C(0x6001000020000000), 0x1.800400008p+62, 0x0p+0 },
+{ UINT64_C(0x6001000040000000), 0x1.80040001p+62, 0x0p+0 },
+{ UINT64_C(0x6001000080000000), 0x1.80040002p+62, 0x0p+0 },
+{ UINT64_C(0x6001000200000000), 0x1.80040008p+62, 0x0p+0 },
+{ UINT64_C(0x6001000800000000), 0x1.8004002p+62, 0x0p+0 },
+{ UINT64_C(0x6001001000000000), 0x1.8004004p+62, 0x0p+0 },
+{ UINT64_C(0x6001008000000000), 0x1.800402p+62, 0x0p+0 },
+{ UINT64_C(0x6001010000000000), 0x1.800404p+62, 0x0p+0 },
+{ UINT64_C(0x6001040000000000), 0x1.80041p+62, 0x0p+0 },
+{ UINT64_C(0x6001200000000000), 0x1.80048p+62, 0x0p+0 },
+{ UINT64_C(0x6001800000000000), 0x1.8006p+62, 0x0p+0 },
+{ UINT64_C(0x6008000000000000), 0x1.802p+62, 0x0p+0 },
+{ UINT64_C(0x6008000000000004), 0x1.802p+62, 0x1p+2 },
+{ UINT64_C(0x6008000000000020), 0x1.802p+62, 0x1p+5 },
+{ UINT64_C(0x6008000000000200), 0x1.802p+62, 0x1p+9 },
+{ UINT64_C(0x6008000000002000), 0x1.8020000000008p+62, 0x0p+0 },
+{ UINT64_C(0x6008000000004000), 0x1.802000000001p+62, 0x0p+0 },
+{ UINT64_C(0x6008000000040000), 0x1.80200000001p+62, 0x0p+0 },
+{ UINT64_C(0x6008000000200000), 0x1.80200000008p+62, 0x0p+0 },
+{ UINT64_C(0x6008000000400000), 0x1.8020000001p+62, 0x0p+0 },
+{ UINT64_C(0x6008000002000000), 0x1.8020000008p+62, 0x0p+0 },
+{ UINT64_C(0x6008000010000000), 0x1.802000004p+62, 0x0p+0 },
+{ UINT64_C(0x6008000040000000), 0x1.80200001p+62, 0x0p+0 },
+{ UINT64_C(0x6008000400000000), 0x1.8020001p+62, 0x0p+0 },
+{ UINT64_C(0x6008002000000000), 0x1.8020008p+62, 0x0p+0 },
+{ UINT64_C(0x6008010000000000), 0x1.802004p+62, 0x0p+0 },
+{ UINT64_C(0x6008100000000000), 0x1.80204p+62, 0x0p+0 },
+{ UINT64_C(0x6008800000000000), 0x1.8022p+62, 0x0p+0 },
+{ UINT64_C(0x600c000000000000), 0x1.803p+62, 0x0p+0 },
+{ UINT64_C(0x6080000000000000), 0x1.82p+62, 0x0p+0 },
+{ UINT64_C(0x6080000000000001), 0x1.82p+62, 0x1p+0 },
+{ UINT64_C(0x6080000000000010), 0x1.82p+62, 0x1p+4 },
+{ UINT64_C(0x6080000000000020), 0x1.82p+62, 0x1p+5 },
+{ UINT64_C(0x6080000000000100), 0x1.82p+62, 0x1p+8 },
+{ UINT64_C(0x6080000000000200), 0x1.82p+62, 0x1p+9 },
+{ UINT64_C(0x6080000000000400), 0x1.8200000000001p+62, 0x0p+0 },
+{ UINT64_C(0x6080000000001000), 0x1.8200000000004p+62, 0x0p+0 },
+{ UINT64_C(0x6080000000008000), 0x1.820000000002p+62, 0x0p+0 },
+{ UINT64_C(0x6080000000020000), 0x1.820000000008p+62, 0x0p+0 },
+{ UINT64_C(0x6080000000100000), 0x1.82000000004p+62, 0x0p+0 },
+{ UINT64_C(0x6080000001000000), 0x1.8200000004p+62, 0x0p+0 },
+{ UINT64_C(0x6080000004000000), 0x1.820000001p+62, 0x0p+0 },
+{ UINT64_C(0x6080000010000000), 0x1.820000004p+62, 0x0p+0 },
+{ UINT64_C(0x6080000100000000), 0x1.82000004p+62, 0x0p+0 },
+{ UINT64_C(0x6080000800000000), 0x1.8200002p+62, 0x0p+0 },
+{ UINT64_C(0x6080004000000000), 0x1.820001p+62, 0x0p+0 },
+{ UINT64_C(0x6080040000000000), 0x1.82001p+62, 0x0p+0 },
+{ UINT64_C(0x6080100000000000), 0x1.82004p+62, 0x0p+0 },
+{ UINT64_C(0x6080800000000000), 0x1.8202p+62, 0x0p+0 },
+{ UINT64_C(0x6088000000000000), 0x1.822p+62, 0x0p+0 },
+{ UINT64_C(0x6090000000000000), 0x1.824p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000000000), 0x1.84p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000000008), 0x1.84p+62, 0x1p+3 },
+{ UINT64_C(0x6100000000000020), 0x1.84p+62, 0x1p+5 },
+{ UINT64_C(0x6100000000000040), 0x1.84p+62, 0x1p+6 },
+{ UINT64_C(0x6100000000000080), 0x1.84p+62, 0x1p+7 },
+{ UINT64_C(0x6100000000000800), 0x1.8400000000002p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000008000), 0x1.840000000002p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000010000), 0x1.840000000004p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000020000), 0x1.840000000008p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000080000), 0x1.84000000002p+62, 0x0p+0 },
+{ UINT64_C(0x6100000000800000), 0x1.8400000002p+62, 0x0p+0 },
+{ UINT64_C(0x6100000002000000), 0x1.8400000008p+62, 0x0p+0 },
+{ UINT64_C(0x6100000010000000), 0x1.840000004p+62, 0x0p+0 },
+{ UINT64_C(0x6100000100000000), 0x1.84000004p+62, 0x0p+0 },
+{ UINT64_C(0x6100000400000000), 0x1.8400001p+62, 0x0p+0 },
+{ UINT64_C(0x6100002000000000), 0x1.8400008p+62, 0x0p+0 },
+{ UINT64_C(0x6100020000000000), 0x1.840008p+62, 0x0p+0 },
+{ UINT64_C(0x6100040000000000), 0x1.84001p+62, 0x0p+0 },
+{ UINT64_C(0x6100080000000000), 0x1.84002p+62, 0x0p+0 },
+{ UINT64_C(0x6100800000000000), 0x1.8402p+62, 0x0p+0 },
+{ UINT64_C(0x6102000000000000), 0x1.8408p+62, 0x0p+0 },
+{ UINT64_C(0x6120000000000000), 0x1.848p+62, 0x0p+0 },
+{ UINT64_C(0x6180000000000000), 0x1.86p+62, 0x0p+0 },
+{ UINT64_C(0x7000000000000000), 0x1.cp+62, 0x0p+0 },
+{ UINT64_C(0x7000000000000001), 0x1.cp+62, 0x1p+0 },
+{ UINT64_C(0x7000000000000008), 0x1.cp+62, 0x1p+3 },
+{ UINT64_C(0x7000000000000020), 0x1.cp+62, 0x1p+5 },
+{ UINT64_C(0x7000000000000040), 0x1.cp+62, 0x1p+6 },
+{ UINT64_C(0x7000000000000080), 0x1.cp+62, 0x1p+7 },
+{ UINT64_C(0x7000000000000800), 0x1.c000000000002p+62, 0x0p+0 },
+{ UINT64_C(0x7000000000002000), 0x1.c000000000008p+62, 0x0p+0 },
+{ UINT64_C(0x7000000000010000), 0x1.c00000000004p+62, 0x0p+0 },
+{ UINT64_C(0x7000000000040000), 0x1.c0000000001p+62, 0x0p+0 },
+{ UINT64_C(0x7000000000080000), 0x1.c0000000002p+62, 0x0p+0 },
+{ UINT64_C(0x7000000000800000), 0x1.c000000002p+62, 0x0p+0 },
+{ UINT64_C(0x7000000008000000), 0x1.c00000002p+62, 0x0p+0 },
+{ UINT64_C(0x7000000010000000), 0x1.c00000004p+62, 0x0p+0 },
+{ UINT64_C(0x7000000100000000), 0x1.c0000004p+62, 0x0p+0 },
+{ UINT64_C(0x7000000200000000), 0x1.c0000008p+62, 0x0p+0 },
+{ UINT64_C(0x7000000800000000), 0x1.c000002p+62, 0x0p+0 },
+{ UINT64_C(0x7000008000000000), 0x1.c00002p+62, 0x0p+0 },
+{ UINT64_C(0x7000010000000000), 0x1.c00004p+62, 0x0p+0 },
+{ UINT64_C(0x7000080000000000), 0x1.c0002p+62, 0x0p+0 },
+{ UINT64_C(0x7000800000000000), 0x1.c002p+62, 0x0p+0 },
+{ UINT64_C(0x7002000000000000), 0x1.c008p+62, 0x0p+0 },
+{ UINT64_C(0x7008000000000000), 0x1.c02p+62, 0x0p+0 },
+{ UINT64_C(0x7080000000000000), 0x1.c2p+62, 0x0p+0 },
+{ UINT64_C(0x7400000000000000), 0x1.dp+62, 0x0p+0 },
+};
+
+static const int numTests = sizeof(tests) / sizeof(struct testCase);
diff --git a/compiler-rt/test/builtins/Unit/ppc/qadd_test.c b/compiler-rt/test/builtins/Unit/ppc/qadd_test.c
new file mode 100644
index 0000000..6d4ca93
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/qadd_test.c
@@ -0,0 +1,1872 @@
+#include <stdio.h>
+#include "DD.h"
+
+long double __gcc_qadd(long double x, long double y);
+
+double testAccuracy();
+int testEdgeCases();
+
+int main(int argc, char *argv[]) {
+	if (testEdgeCases())
+		return 1;
+	
+	if (testAccuracy() > 1.0)
+		return 1;
+	
+	return 0;
+}
+
+struct testVector {
+	double xhi; double xlo;
+	double yhi; double ylo;
+	double rhi; double rlo;
+};
+
+#define INFINITY __builtin_inf()
+#define HUGE 0x1.fffffffffffffp1023
+#define QNAN __builtin_nan("")
+
+const struct testVector edgeCases[] = {
+{	0.0,		0.0,		0.0,		0.0,		0.0,		0.0			},
+{  -0.0,		0.0,		0.0,		0.0,		0.0,		0.0			},
+{   0.0,		0.0,	   -0.0,		0.0,		0.0,		0.0			},
+{  -0.0,		0.0,	   -0.0,		0.0,	   -0.0,		0.0			},
+
+{   INFINITY,	0.0,		0.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,		0.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -0.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -0.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	    1.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    1.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -1.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -1.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	    HUGE,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    HUGE,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -HUGE,		0.0,	    INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -HUGE,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	    INFINITY,	0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    INFINITY,	0.0,		QNAN,		0.0			},
+{   INFINITY,	0.0,	   -INFINITY,	0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   0.0,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{   0.0,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -0.0,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{  -0.0,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   1.0,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{   1.0,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -1.0,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{  -1.0,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   HUGE,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{   HUGE,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -HUGE,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{  -HUGE,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+
+{   QNAN,		0.0,		0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    QNAN,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -QNAN,		0.0,	    QNAN,		0.0			},
+{	0.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+};
+
+const int numEdgeCases = sizeof(edgeCases) / sizeof(struct testVector);
+
+
+int testEdgeCases() {
+	int i;
+	DD a, b, c, r;
+	for (i=0; i<numEdgeCases; ++i) {
+		a.hi = edgeCases[i].xhi;
+		a.lo = edgeCases[i].xlo;
+		b.hi = edgeCases[i].yhi;
+		b.lo = edgeCases[i].ylo;
+		r.hi = edgeCases[i].rhi;
+		r.lo = edgeCases[i].rlo;
+		
+		int error;
+		
+		DD c = { .ld = __gcc_qadd(a.ld, b.ld) };
+		
+		if (r.hi != r.hi) {
+			if (c.hi == c.hi)
+				error = 1;
+			else if (c.lo != 0.0)
+				error = 1;
+			else
+				error = 0;
+		}
+
+		else if (r.hi == 0.0)
+			error = memcmp(&c, &r, sizeof(DD));
+		
+		else
+			error = ((c.hi != r.hi) || (c.lo != r.lo));
+		
+		if (error) {
+			printf("Error on edge case %a + %a: expected (%a, %a), got (%a, %a).\n", a.hi, b.hi, r.hi, r.lo, c.hi, c.lo);
+			return 1;
+		}
+	}
+	
+	return 0;
+}
+
+
+/*
+
+ Code for generating the test cases, requires the mpfr package to run.
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <mpfr.h>
+ 
+ #ifdef __x86_64__
+ #define randlength 2
+ #else
+ #define randlength 4
+ #endif
+ 
+ 
+ int main(int argc, char *argv[]) {
+ 
+ MPFR_DECL_INIT(a, 106);
+ MPFR_DECL_INIT(b, 106);
+ MPFR_DECL_INIT(c, 106);
+ 
+ MPFR_DECL_INIT(tmp, 53);
+ 
+ int exponent_range = atoi(argv[1]);
+ 
+ int i;
+ for (i=0; i<128; ++i) {
+ mpfr_random2(a, randlength, exponent_range);
+ mpfr_random2(b, randlength, exponent_range);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ double ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ double alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ double bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ double blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ double chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ double clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ 
+ mpfr_neg(a, a, GMP_RNDN);
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ }
+ 
+ return 0;
+ }
+
+
+ */
+
+const struct testVector accuracyTests[] = {
+// Some test cases that cover the whole exponent range:
+{0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302, 0x1.0003ffffffffcp+140, 0x1.ffffc00000000p+53, 0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302},
+{0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302, -0x1.0003ffffffffcp+140, -0x1.ffffc00000000p+53, 0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302},
+{-0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302, 0x1.0003ffffffffcp+140, 0x1.ffffc00000000p+53, -0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302},
+{-0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302, -0x1.0003ffffffffcp+140, -0x1.ffffc00000000p+53, -0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302},
+{0x1.0000100000000p-746, -0x1.0000000000000p-808, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692},
+{0x1.0000100000000p-746, -0x1.0000000000000p-808, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692},
+{-0x1.0000100000000p-746, 0x1.0000000000000p-808, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692},
+{-0x1.0000100000000p-746, 0x1.0000000000000p-808, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692},
+{0x1.0000000800000p+426, -0x1.0000000000000p+354, 0x1.000003fffc002p-730, -0x1.0000000000000p-835, 0x1.0000000800000p+426, -0x1.0000000000000p+354},
+{0x1.0000000800000p+426, -0x1.0000000000000p+354, -0x1.000003fffc002p-730, 0x1.0000000000000p-835, 0x1.0000000800000p+426, -0x1.0000000000000p+354},
+{-0x1.0000000800000p+426, 0x1.0000000000000p+354, 0x1.000003fffc002p-730, -0x1.0000000000000p-835, -0x1.0000000800000p+426, 0x1.0000000000000p+354},
+{-0x1.0000000800000p+426, 0x1.0000000000000p+354, -0x1.000003fffc002p-730, 0x1.0000000000000p-835, -0x1.0000000800000p+426, 0x1.0000000000000p+354},
+{0x1.0000000000000p-262, 0x1.ffc001ffffe00p-317, 0x1.000003fff8000p-258, 0x1.fffc000fc0000p-329, 0x1.100003fff8000p-258, 0x1.ffe001c000dc0p-317},
+{0x1.0000000000000p-262, 0x1.ffc001ffffe00p-317, -0x1.000003fff8000p-258, -0x1.fffc000fc0000p-329, -0x1.e00007fff0000p-259, 0x1.ffa0023ffee40p-317},
+{-0x1.0000000000000p-262, -0x1.ffc001ffffe00p-317, 0x1.000003fff8000p-258, 0x1.fffc000fc0000p-329, 0x1.e00007fff0000p-259, -0x1.ffa0023ffee40p-317},
+{-0x1.0000000000000p-262, -0x1.ffc001ffffe00p-317, -0x1.000003fff8000p-258, -0x1.fffc000fc0000p-329, -0x1.100003fff8000p-258, -0x1.ffe001c000dc0p-317},
+{0x1.0000000000003p+980, 0x1.fc00001fff800p+916, 0x1.0000000000020p+626, -0x1.fc01ffe002000p+562, 0x1.0000000000003p+980, 0x1.fc00001fff800p+916},
+{0x1.0000000000003p+980, 0x1.fc00001fff800p+916, -0x1.0000000000020p+626, 0x1.fc01ffe002000p+562, 0x1.0000000000003p+980, 0x1.fc00001fff800p+916},
+{-0x1.0000000000003p+980, -0x1.fc00001fff800p+916, 0x1.0000000000020p+626, -0x1.fc01ffe002000p+562, -0x1.0000000000003p+980, -0x1.fc00001fff800p+916},
+{-0x1.0000000000003p+980, -0x1.fc00001fff800p+916, -0x1.0000000000020p+626, 0x1.fc01ffe002000p+562, -0x1.0000000000003p+980, -0x1.fc00001fff800p+916},
+{0x1.0000000000000p-800, 0x1.fffff00001ffep-854, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410},
+{0x1.0000000000000p-800, 0x1.fffff00001ffep-854, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410},
+{-0x1.0000000000000p-800, -0x1.fffff00001ffep-854, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410},
+{-0x1.0000000000000p-800, -0x1.fffff00001ffep-854, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410},
+{0x1.0000000000000p+925, 0x1.ffffffffffc00p+862, 0x1.0000200000000p-454, -0x1.ffc0000080000p-526, 0x1.0000000000000p+925, 0x1.ffffffffffc00p+862},
+{0x1.0000000000000p+925, 0x1.ffffffffffc00p+862, -0x1.0000200000000p-454, 0x1.ffc0000080000p-526, 0x1.0000000000000p+925, 0x1.ffffffffffc00p+862},
+{-0x1.0000000000000p+925, -0x1.ffffffffffc00p+862, 0x1.0000200000000p-454, -0x1.ffc0000080000p-526, -0x1.0000000000000p+925, -0x1.ffffffffffc00p+862},
+{-0x1.0000000000000p+925, -0x1.ffffffffffc00p+862, -0x1.0000200000000p-454, 0x1.ffc0000080000p-526, -0x1.0000000000000p+925, -0x1.ffffffffffc00p+862},
+{0x1.0000000000800p+265, -0x1.fffc000000010p+208, 0x1.0000000000008p-204, -0x1.ffe03fffff010p-261, 0x1.0000000000800p+265, -0x1.fffc000000010p+208},
+{0x1.0000000000800p+265, -0x1.fffc000000010p+208, -0x1.0000000000008p-204, 0x1.ffe03fffff010p-261, 0x1.0000000000800p+265, -0x1.fffc000000010p+208},
+{-0x1.0000000000800p+265, 0x1.fffc000000010p+208, 0x1.0000000000008p-204, -0x1.ffe03fffff010p-261, -0x1.0000000000800p+265, 0x1.fffc000000010p+208},
+{-0x1.0000000000800p+265, 0x1.fffc000000010p+208, -0x1.0000000000008p-204, 0x1.ffe03fffff010p-261, -0x1.0000000000800p+265, 0x1.fffc000000010p+208},
+{0x1.0000000000000p-690, 0x1.fffef0ffff000p-753, 0x1.0000100000000p+763, -0x1.fff8000000800p+699, 0x1.0000100000000p+763, -0x1.fff8000000800p+699},
+{0x1.0000000000000p-690, 0x1.fffef0ffff000p-753, -0x1.0000100000000p+763, 0x1.fff8000000800p+699, -0x1.0000100000000p+763, 0x1.fff8000000800p+699},
+{-0x1.0000000000000p-690, -0x1.fffef0ffff000p-753, 0x1.0000100000000p+763, -0x1.fff8000000800p+699, 0x1.0000100000000p+763, -0x1.fff8000000800p+699},
+{-0x1.0000000000000p-690, -0x1.fffef0ffff000p-753, -0x1.0000100000000p+763, 0x1.fff8000000800p+699, -0x1.0000100000000p+763, 0x1.fff8000000800p+699},
+{0x1.07c00007ffff0p-506, 0x1.fffc00f800000p-582, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373},
+{0x1.07c00007ffff0p-506, 0x1.fffc00f800000p-582, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373},
+{-0x1.07c00007ffff0p-506, -0x1.fffc00f800000p-582, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373},
+{-0x1.07c00007ffff0p-506, -0x1.fffc00f800000p-582, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373},
+{0x1.0000000000000p-958, 0x1.ff800fffff800p-1014, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317},
+{0x1.0000000000000p-958, 0x1.ff800fffff800p-1014, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317},
+{-0x1.0000000000000p-958, -0x1.ff800fffff800p-1014, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317},
+{-0x1.0000000000000p-958, -0x1.ff800fffff800p-1014, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317},
+{0x1.0000000008000p+114, -0x1.ffff807ffe002p+60, 0x1.0000000800000p-783, -0x1.ffffff8000008p-839, 0x1.0000000008000p+114, -0x1.ffff807ffe002p+60},
+{0x1.0000000008000p+114, -0x1.ffff807ffe002p+60, -0x1.0000000800000p-783, 0x1.ffffff8000008p-839, 0x1.0000000008000p+114, -0x1.ffff807ffe002p+60},
+{-0x1.0000000008000p+114, 0x1.ffff807ffe002p+60, 0x1.0000000800000p-783, -0x1.ffffff8000008p-839, -0x1.0000000008000p+114, 0x1.ffff807ffe002p+60},
+{-0x1.0000000008000p+114, 0x1.ffff807ffe002p+60, -0x1.0000000800000p-783, 0x1.ffffff8000008p-839, -0x1.0000000008000p+114, 0x1.ffff807ffe002p+60},
+{0x1.0000000000020p+340, -0x1.0000000000000p+257, 0x1.0000000000000p-442, 0x1.fffff000003c0p-501, 0x1.0000000000020p+340, -0x1.0000000000000p+257},
+{0x1.0000000000020p+340, -0x1.0000000000000p+257, -0x1.0000000000000p-442, -0x1.fffff000003c0p-501, 0x1.0000000000020p+340, -0x1.0000000000000p+257},
+{-0x1.0000000000020p+340, 0x1.0000000000000p+257, 0x1.0000000000000p-442, 0x1.fffff000003c0p-501, -0x1.0000000000020p+340, 0x1.0000000000000p+257},
+{-0x1.0000000000020p+340, 0x1.0000000000000p+257, -0x1.0000000000000p-442, -0x1.fffff000003c0p-501, -0x1.0000000000020p+340, 0x1.0000000000000p+257},
+{0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331, 0x1.0000000200000p+69, -0x1.0000000000000p+0, 0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331},
+{0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331, -0x1.0000000200000p+69, 0x1.0000000000000p+0, 0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331},
+{-0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331, 0x1.0000000200000p+69, -0x1.0000000000000p+0, -0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331},
+{-0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331, -0x1.0000000200000p+69, 0x1.0000000000000p+0, -0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331},
+{0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198, 0x1.0000000000000p-934, 0x1.8fff01fffff00p-994, 0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198},
+{0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198, -0x1.0000000000000p-934, -0x1.8fff01fffff00p-994, 0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198},
+{-0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198, 0x1.0000000000000p-934, 0x1.8fff01fffff00p-994, -0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198},
+{-0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198, -0x1.0000000000000p-934, -0x1.8fff01fffff00p-994, -0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198},
+{0x1.0000000000008p+975, -0x1.ffffc00800000p+902, 0x1.00003ffe00002p-979, -0x1.ffffffc180000p-1039, 0x1.0000000000008p+975, -0x1.ffffc00800000p+902},
+{0x1.0000000000008p+975, -0x1.ffffc00800000p+902, -0x1.00003ffe00002p-979, 0x1.ffffffc180000p-1039, 0x1.0000000000008p+975, -0x1.ffffc00800000p+902},
+{-0x1.0000000000008p+975, 0x1.ffffc00800000p+902, 0x1.00003ffe00002p-979, -0x1.ffffffc180000p-1039, -0x1.0000000000008p+975, 0x1.ffffc00800000p+902},
+{-0x1.0000000000008p+975, 0x1.ffffc00800000p+902, -0x1.00003ffe00002p-979, 0x1.ffffffc180000p-1039, -0x1.0000000000008p+975, 0x1.ffffc00800000p+902},
+{0x1.000000ffffff8p+56, 0x1.ffffffc000000p-1, 0x1.0000000000000p-40, 0x1.ffffffe000000p-98, 0x1.000000ffffff8p+56, 0x1.ffffffc002000p-1},
+{0x1.000000ffffff8p+56, 0x1.ffffffc000000p-1, -0x1.0000000000000p-40, -0x1.ffffffe000000p-98, 0x1.000000ffffff8p+56, 0x1.ffffffbffe000p-1},
+{-0x1.000000ffffff8p+56, -0x1.ffffffc000000p-1, 0x1.0000000000000p-40, 0x1.ffffffe000000p-98, -0x1.000000ffffff8p+56, -0x1.ffffffbffe000p-1},
+{-0x1.000000ffffff8p+56, -0x1.ffffffc000000p-1, -0x1.0000000000000p-40, -0x1.ffffffe000000p-98, -0x1.000000ffffff8p+56, -0x1.ffffffc002000p-1},
+{0x1.0000000020000p-764, -0x1.0000000000000p-869, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470},
+{0x1.0000000020000p-764, -0x1.0000000000000p-869, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470},
+{-0x1.0000000020000p-764, 0x1.0000000000000p-869, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470},
+{-0x1.0000000020000p-764, 0x1.0000000000000p-869, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470},
+{0x1.0000ff8020000p-469, -0x1.fffffa0000000p-531, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80},
+{0x1.0000ff8020000p-469, -0x1.fffffa0000000p-531, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80},
+{-0x1.0000ff8020000p-469, 0x1.fffffa0000000p-531, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80},
+{-0x1.0000ff8020000p-469, 0x1.fffffa0000000p-531, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80},
+{0x1.0000020000000p+518, -0x1.0000000000000p+454, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710},
+{0x1.0000020000000p+518, -0x1.0000000000000p+454, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710},
+{-0x1.0000020000000p+518, 0x1.0000000000000p+454, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710},
+{-0x1.0000020000000p+518, 0x1.0000000000000p+454, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710},
+{0x1.0007e3ffe0000p-546, 0x1.fe0ffffffe000p-610, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506},
+{0x1.0007e3ffe0000p-546, 0x1.fe0ffffffe000p-610, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506},
+{-0x1.0007e3ffe0000p-546, -0x1.fe0ffffffe000p-610, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506},
+{-0x1.0007e3ffe0000p-546, -0x1.fe0ffffffe000p-610, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506},
+{0x1.00000000fe000p-853, 0x1.ff00004000000p-920, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322},
+{0x1.00000000fe000p-853, 0x1.ff00004000000p-920, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322},
+{-0x1.00000000fe000p-853, -0x1.ff00004000000p-920, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322},
+{-0x1.00000000fe000p-853, -0x1.ff00004000000p-920, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322},
+{0x1.0000800000000p-529, -0x1.0000000000000p-585, 0x1.0000000000000p-716, 0x1.fffffffc1fc00p-779, 0x1.0000800000000p-529, -0x1.0000000000000p-585},
+{0x1.0000800000000p-529, -0x1.0000000000000p-585, -0x1.0000000000000p-716, -0x1.fffffffc1fc00p-779, 0x1.0000800000000p-529, -0x1.0000000000000p-585},
+{-0x1.0000800000000p-529, 0x1.0000000000000p-585, 0x1.0000000000000p-716, 0x1.fffffffc1fc00p-779, -0x1.0000800000000p-529, 0x1.0000000000000p-585},
+{-0x1.0000800000000p-529, 0x1.0000000000000p-585, -0x1.0000000000000p-716, -0x1.fffffffc1fc00p-779, -0x1.0000800000000p-529, 0x1.0000000000000p-585},
+{0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491, 0x1.0000000000000p-565, 0x1.fe0003fffc000p-624, 0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491},
+{0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491, -0x1.0000000000000p-565, -0x1.fe0003fffc000p-624, 0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491},
+{-0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491, 0x1.0000000000000p-565, 0x1.fe0003fffc000p-624, -0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491},
+{-0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491, -0x1.0000000000000p-565, -0x1.fe0003fffc000p-624, -0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491},
+{0x1.000000e000010p-739, -0x1.ffffffc020000p-809, 0x1.00000001f0000p+66, 0x1.8000000000000p-38, 0x1.00000001f0000p+66, 0x1.8000000000000p-38},
+{0x1.000000e000010p-739, -0x1.ffffffc020000p-809, -0x1.00000001f0000p+66, -0x1.8000000000000p-38, -0x1.00000001f0000p+66, -0x1.8000000000000p-38},
+{-0x1.000000e000010p-739, 0x1.ffffffc020000p-809, 0x1.00000001f0000p+66, 0x1.8000000000000p-38, 0x1.00000001f0000p+66, 0x1.8000000000000p-38},
+{-0x1.000000e000010p-739, 0x1.ffffffc020000p-809, -0x1.00000001f0000p+66, -0x1.8000000000000p-38, -0x1.00000001f0000p+66, -0x1.8000000000000p-38},
+{0x1.000003ff00000p-980, 0x1.8000000000000p-1057, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386},
+{0x1.000003ff00000p-980, 0x1.8000000000000p-1057, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386},
+{-0x1.000003ff00000p-980, -0x1.8000000000000p-1057, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386},
+{-0x1.000003ff00000p-980, -0x1.8000000000000p-1057, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386},
+{0x1.0000000000200p+292, -0x1.ffffffffffc08p+236, 0x1.0000000000000p-660, 0x1.ffffffffffffep-714, 0x1.0000000000200p+292, -0x1.ffffffffffc08p+236},
+{0x1.0000000000200p+292, -0x1.ffffffffffc08p+236, -0x1.0000000000000p-660, -0x1.ffffffffffffep-714, 0x1.0000000000200p+292, -0x1.ffffffffffc08p+236},
+{-0x1.0000000000200p+292, 0x1.ffffffffffc08p+236, 0x1.0000000000000p-660, 0x1.ffffffffffffep-714, -0x1.0000000000200p+292, 0x1.ffffffffffc08p+236},
+{-0x1.0000000000200p+292, 0x1.ffffffffffc08p+236, -0x1.0000000000000p-660, -0x1.ffffffffffffep-714, -0x1.0000000000200p+292, 0x1.ffffffffffc08p+236},
+{0x1.0000000040000p-475, -0x1.fffff80002000p-541, 0x1.0000000000000p-741, 0x1.ffc01ffff3c00p-804, 0x1.0000000040000p-475, -0x1.fffff80002000p-541},
+{0x1.0000000040000p-475, -0x1.fffff80002000p-541, -0x1.0000000000000p-741, -0x1.ffc01ffff3c00p-804, 0x1.0000000040000p-475, -0x1.fffff80002000p-541},
+{-0x1.0000000040000p-475, 0x1.fffff80002000p-541, 0x1.0000000000000p-741, 0x1.ffc01ffff3c00p-804, -0x1.0000000040000p-475, 0x1.fffff80002000p-541},
+{-0x1.0000000040000p-475, 0x1.fffff80002000p-541, -0x1.0000000000000p-741, -0x1.ffc01ffff3c00p-804, -0x1.0000000040000p-475, 0x1.fffff80002000p-541},
+{0x1.0000800000000p+1022, -0x1.0000000000000p+917, 0x1.0000003800001p-290, 0x1.fffffe000003ep-344, 0x1.0000800000000p+1022, -0x1.0000000000000p+917},
+{0x1.0000800000000p+1022, -0x1.0000000000000p+917, -0x1.0000003800001p-290, -0x1.fffffe000003ep-344, 0x1.0000800000000p+1022, -0x1.0000000000000p+917},
+{-0x1.0000800000000p+1022, 0x1.0000000000000p+917, 0x1.0000003800001p-290, 0x1.fffffe000003ep-344, -0x1.0000800000000p+1022, 0x1.0000000000000p+917},
+{-0x1.0000800000000p+1022, 0x1.0000000000000p+917, -0x1.0000003800001p-290, -0x1.fffffe000003ep-344, -0x1.0000800000000p+1022, 0x1.0000000000000p+917},
+{0x1.0f00000020000p-425, -0x1.fffe000000100p-479, 0x1.0000000400000p-527, -0x1.ffffffc004000p-594, 0x1.0f00000020000p-425, -0x1.fffe0000000f0p-479},
+{0x1.0f00000020000p-425, -0x1.fffe000000100p-479, -0x1.0000000400000p-527, 0x1.ffffffc004000p-594, 0x1.0f00000020000p-425, -0x1.fffe000000110p-479},
+{-0x1.0f00000020000p-425, 0x1.fffe000000100p-479, 0x1.0000000400000p-527, -0x1.ffffffc004000p-594, -0x1.0f00000020000p-425, 0x1.fffe000000110p-479},
+{-0x1.0f00000020000p-425, 0x1.fffe000000100p-479, -0x1.0000000400000p-527, 0x1.ffffffc004000p-594, -0x1.0f00000020000p-425, 0x1.fffe0000000f0p-479},
+{0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652, 0x1.0000000000400p+142, -0x1.ffff800007ffcp+87, 0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652},
+{0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652, -0x1.0000000000400p+142, 0x1.ffff800007ffcp+87, 0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652},
+{-0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652, 0x1.0000000000400p+142, -0x1.ffff800007ffcp+87, -0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652},
+{-0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652, -0x1.0000000000400p+142, 0x1.ffff800007ffcp+87, -0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652},
+{0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11, 0x1.0000020000000p-926, -0x1.0000000000000p-1002, 0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11},
+{0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11, -0x1.0000020000000p-926, 0x1.0000000000000p-1002, 0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11},
+{-0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11, 0x1.0000020000000p-926, -0x1.0000000000000p-1002, -0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11},
+{-0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11, -0x1.0000020000000p-926, 0x1.0000000000000p-1002, -0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11},
+{0x1.0000000000040p-915, -0x1.8000000800000p-990, 0x1.0000000002000p-454, -0x1.0000000000000p-558, 0x1.0000000002000p-454, -0x1.0000000000000p-558},
+{0x1.0000000000040p-915, -0x1.8000000800000p-990, -0x1.0000000002000p-454, 0x1.0000000000000p-558, -0x1.0000000002000p-454, 0x1.0000000000000p-558},
+{-0x1.0000000000040p-915, 0x1.8000000800000p-990, 0x1.0000000002000p-454, -0x1.0000000000000p-558, 0x1.0000000002000p-454, -0x1.0000000000000p-558},
+{-0x1.0000000000040p-915, 0x1.8000000800000p-990, -0x1.0000000002000p-454, 0x1.0000000000000p-558, -0x1.0000000002000p-454, 0x1.0000000000000p-558},
+{0x1.0000000800000p-123, -0x1.ffffc02000000p-201, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488},
+{0x1.0000000800000p-123, -0x1.ffffc02000000p-201, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488},
+{-0x1.0000000800000p-123, 0x1.ffffc02000000p-201, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488},
+{-0x1.0000000800000p-123, 0x1.ffffc02000000p-201, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488},
+{0x1.0000400000000p+352, -0x1.0000000000000p+261, 0x1.4000000000000p-216, -0x1.ffffffff00020p-274, 0x1.0000400000000p+352, -0x1.0000000000000p+261},
+{0x1.0000400000000p+352, -0x1.0000000000000p+261, -0x1.4000000000000p-216, 0x1.ffffffff00020p-274, 0x1.0000400000000p+352, -0x1.0000000000000p+261},
+{-0x1.0000400000000p+352, 0x1.0000000000000p+261, 0x1.4000000000000p-216, -0x1.ffffffff00020p-274, -0x1.0000400000000p+352, 0x1.0000000000000p+261},
+{-0x1.0000400000000p+352, 0x1.0000000000000p+261, -0x1.4000000000000p-216, 0x1.ffffffff00020p-274, -0x1.0000400000000p+352, 0x1.0000000000000p+261},
+{0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771, 0x1.00001fffc0000p-889, 0x1.f80001f000f80p-949, 0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771},
+{0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771, -0x1.00001fffc0000p-889, -0x1.f80001f000f80p-949, 0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771},
+{-0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771, 0x1.00001fffc0000p-889, 0x1.f80001f000f80p-949, -0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771},
+{-0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771, -0x1.00001fffc0000p-889, -0x1.f80001f000f80p-949, -0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771},
+{0x1.03ffffffffffep-517, 0x1.8000000000000p-621, 0x1.0000040000000p-478, -0x1.0000000000000p-583, 0x1.0000040002080p-478, -0x1.0002000000000p-568},
+{0x1.03ffffffffffep-517, 0x1.8000000000000p-621, -0x1.0000040000000p-478, 0x1.0000000000000p-583, -0x1.000003fffdf80p-478, -0x1.fffc000000000p-569},
+{-0x1.03ffffffffffep-517, -0x1.8000000000000p-621, 0x1.0000040000000p-478, -0x1.0000000000000p-583, 0x1.000003fffdf80p-478, 0x1.fffc000000000p-569},
+{-0x1.03ffffffffffep-517, -0x1.8000000000000p-621, -0x1.0000040000000p-478, 0x1.0000000000000p-583, -0x1.0000040002080p-478, 0x1.0002000000000p-568},
+{0x1.0007ffffcfffcp-566, 0x1.ff01fffe00000p-640, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66},
+{0x1.0007ffffcfffcp-566, 0x1.ff01fffe00000p-640, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66},
+{-0x1.0007ffffcfffcp-566, -0x1.ff01fffe00000p-640, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66},
+{-0x1.0007ffffcfffcp-566, -0x1.ff01fffe00000p-640, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66},
+{0x1.00000000007fep-907, 0x1.ff00003ffff00p-968, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751},
+{0x1.00000000007fep-907, 0x1.ff00003ffff00p-968, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751},
+{-0x1.00000000007fep-907, -0x1.ff00003ffff00p-968, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751},
+{-0x1.00000000007fep-907, -0x1.ff00003ffff00p-968, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751},
+{0x1.00000003ff000p-540, 0x1.ffff000000000p-629, 0x1.0000fffff8000p-864, 0x1.f003ffe0003e0p-922, 0x1.00000003ff000p-540, 0x1.ffff000000000p-629},
+{0x1.00000003ff000p-540, 0x1.ffff000000000p-629, -0x1.0000fffff8000p-864, -0x1.f003ffe0003e0p-922, 0x1.00000003ff000p-540, 0x1.ffff000000000p-629},
+{-0x1.00000003ff000p-540, -0x1.ffff000000000p-629, 0x1.0000fffff8000p-864, 0x1.f003ffe0003e0p-922, -0x1.00000003ff000p-540, -0x1.ffff000000000p-629},
+{-0x1.00000003ff000p-540, -0x1.ffff000000000p-629, -0x1.0000fffff8000p-864, -0x1.f003ffe0003e0p-922, -0x1.00000003ff000p-540, -0x1.ffff000000000p-629},
+{0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45, 0x1.01fffffe00000p-954, 0x1.ffffffffffc00p-1012, 0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45},
+{0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45, -0x1.01fffffe00000p-954, -0x1.ffffffffffc00p-1012, 0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45},
+{-0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45, 0x1.01fffffe00000p-954, 0x1.ffffffffffc00p-1012, -0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45},
+{-0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45, -0x1.01fffffe00000p-954, -0x1.ffffffffffc00p-1012, -0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45},
+{0x1.00003ff808000p-919, -0x1.ffe0000800000p-980, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136},
+{0x1.00003ff808000p-919, -0x1.ffe0000800000p-980, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136},
+{-0x1.00003ff808000p-919, 0x1.ffe0000800000p-980, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136},
+{-0x1.00003ff808000p-919, 0x1.ffe0000800000p-980, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136},
+{0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727, 0x1.0000000007f80p-960, 0x1.ff0007f802000p-1024, 0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727},
+{0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727, -0x1.0000000007f80p-960, -0x1.ff0007f802000p-1024, 0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727},
+{-0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727, 0x1.0000000007f80p-960, 0x1.ff0007f802000p-1024, -0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727},
+{-0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727, -0x1.0000000007f80p-960, -0x1.ff0007f802000p-1024, -0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727},
+{0x1.0020000000000p+107, -0x1.0000000000000p+30, 0x1.000001ffff802p-529, -0x1.ffffffc000040p-588, 0x1.0020000000000p+107, -0x1.0000000000000p+30},
+{0x1.0020000000000p+107, -0x1.0000000000000p+30, -0x1.000001ffff802p-529, 0x1.ffffffc000040p-588, 0x1.0020000000000p+107, -0x1.0000000000000p+30},
+{-0x1.0020000000000p+107, 0x1.0000000000000p+30, 0x1.000001ffff802p-529, -0x1.ffffffc000040p-588, -0x1.0020000000000p+107, 0x1.0000000000000p+30},
+{-0x1.0020000000000p+107, 0x1.0000000000000p+30, -0x1.000001ffff802p-529, 0x1.ffffffc000040p-588, -0x1.0020000000000p+107, 0x1.0000000000000p+30},
+{0x1.0000000000800p+985, -0x1.ffe0000400000p+923, 0x1.0000000000038p+697, 0x1.e100000000000p+623, 0x1.0000000000800p+985, -0x1.ffe0000400000p+923},
+{0x1.0000000000800p+985, -0x1.ffe0000400000p+923, -0x1.0000000000038p+697, -0x1.e100000000000p+623, 0x1.0000000000800p+985, -0x1.ffe0000400000p+923},
+{-0x1.0000000000800p+985, 0x1.ffe0000400000p+923, 0x1.0000000000038p+697, 0x1.e100000000000p+623, -0x1.0000000000800p+985, 0x1.ffe0000400000p+923},
+{-0x1.0000000000800p+985, 0x1.ffe0000400000p+923, -0x1.0000000000038p+697, -0x1.e100000000000p+623, -0x1.0000000000800p+985, 0x1.ffe0000400000p+923},
+{0x1.0000000000020p+26, -0x1.8007ffff80c04p-29, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513},
+{0x1.0000000000020p+26, -0x1.8007ffff80c04p-29, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513},
+{-0x1.0000000000020p+26, 0x1.8007ffff80c04p-29, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513},
+{-0x1.0000000000020p+26, 0x1.8007ffff80c04p-29, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513},
+{0x1.7fffffff80000p-290, 0x1.f000000000000p-367, 0x1.000007ffffffep-351, 0x1.ffffff8000000p-427, 0x1.7fffffff80000p-290, 0x1.0001f80000000p-351},
+{0x1.7fffffff80000p-290, 0x1.f000000000000p-367, -0x1.000007ffffffep-351, -0x1.ffffff8000000p-427, 0x1.7fffffff80000p-290, -0x1.fffc300000000p-352},
+{-0x1.7fffffff80000p-290, -0x1.f000000000000p-367, 0x1.000007ffffffep-351, 0x1.ffffff8000000p-427, -0x1.7fffffff80000p-290, 0x1.fffc300000000p-352},
+{-0x1.7fffffff80000p-290, -0x1.f000000000000p-367, -0x1.000007ffffffep-351, -0x1.ffffff8000000p-427, -0x1.7fffffff80000p-290, -0x1.0001f80000000p-351},
+{0x1.0000000010000p-869, -0x1.0000000000000p-955, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304},
+{0x1.0000000010000p-869, -0x1.0000000000000p-955, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304},
+{-0x1.0000000010000p-869, 0x1.0000000000000p-955, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304},
+{-0x1.0000000010000p-869, 0x1.0000000000000p-955, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304},
+{0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297, 0x1.0000000000002p-749, -0x1.0000000000000p-854, 0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297},
+{0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297, -0x1.0000000000002p-749, 0x1.0000000000000p-854, 0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297},
+{-0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297, 0x1.0000000000002p-749, -0x1.0000000000000p-854, -0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297},
+{-0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297, -0x1.0000000000002p-749, 0x1.0000000000000p-854, -0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297},
+{0x1.000ffffc00000p+483, 0x1.fffff00000000p+414, 0x1.0000000000040p+210, -0x1.0000000000000p+105, 0x1.000ffffc00000p+483, 0x1.fffff00000000p+414},
+{0x1.000ffffc00000p+483, 0x1.fffff00000000p+414, -0x1.0000000000040p+210, 0x1.0000000000000p+105, 0x1.000ffffc00000p+483, 0x1.fffff00000000p+414},
+{-0x1.000ffffc00000p+483, -0x1.fffff00000000p+414, 0x1.0000000000040p+210, -0x1.0000000000000p+105, -0x1.000ffffc00000p+483, -0x1.fffff00000000p+414},
+{-0x1.000ffffc00000p+483, -0x1.fffff00000000p+414, -0x1.0000000000040p+210, 0x1.0000000000000p+105, -0x1.000ffffc00000p+483, -0x1.fffff00000000p+414},
+{0x1.0004000000000p-94, -0x1.0000000000000p-162, 0x1.0000000200000p-175, -0x1.ffbffffff8020p-233, 0x1.0004000000000p-94, -0x1.fff0000000000p-163},
+{0x1.0004000000000p-94, -0x1.0000000000000p-162, -0x1.0000000200000p-175, 0x1.ffbffffff8020p-233, 0x1.0004000000000p-94, -0x1.0008000000000p-162},
+{-0x1.0004000000000p-94, 0x1.0000000000000p-162, 0x1.0000000200000p-175, -0x1.ffbffffff8020p-233, -0x1.0004000000000p-94, 0x1.0008000000000p-162},
+{-0x1.0004000000000p-94, 0x1.0000000000000p-162, -0x1.0000000200000p-175, 0x1.ffbffffff8020p-233, -0x1.0004000000000p-94, 0x1.fff0000000000p-163},
+{0x1.0000000000000p-421, 0x1.e0001e7fbff00p-482, 0x1.0000001fffffep-395, 0x0.0000000000000p+0, 0x1.0000005fffffep-395, 0x1.e000000000000p-482},
+{0x1.0000000000000p-421, 0x1.e0001e7fbff00p-482, -0x1.0000001fffffep-395, 0x0.0000000000000p+0, -0x1.ffffffbfffffcp-396, 0x1.e000200000000p-482},
+{-0x1.0000000000000p-421, -0x1.e0001e7fbff00p-482, 0x1.0000001fffffep-395, 0x0.0000000000000p+0, 0x1.ffffffbfffffcp-396, -0x1.e000200000000p-482},
+{-0x1.0000000000000p-421, -0x1.e0001e7fbff00p-482, -0x1.0000001fffffep-395, 0x0.0000000000000p+0, -0x1.0000005fffffep-395, -0x1.e000000000000p-482},
+{0x1.0000000000fffp-362, 0x1.fffff3e000000p-435, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813},
+{0x1.0000000000fffp-362, 0x1.fffff3e000000p-435, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813},
+{-0x1.0000000000fffp-362, -0x1.fffff3e000000p-435, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813},
+{-0x1.0000000000fffp-362, -0x1.fffff3e000000p-435, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813},
+{0x1.0000080000000p+509, -0x1.0000000000000p+404, 0x1.0000000080000p-689, -0x1.0000000000000p-744, 0x1.0000080000000p+509, -0x1.0000000000000p+404},
+{0x1.0000080000000p+509, -0x1.0000000000000p+404, -0x1.0000000080000p-689, 0x1.0000000000000p-744, 0x1.0000080000000p+509, -0x1.0000000000000p+404},
+{-0x1.0000080000000p+509, 0x1.0000000000000p+404, 0x1.0000000080000p-689, -0x1.0000000000000p-744, -0x1.0000080000000p+509, 0x1.0000000000000p+404},
+{-0x1.0000080000000p+509, 0x1.0000000000000p+404, -0x1.0000000080000p-689, 0x1.0000000000000p-744, -0x1.0000080000000p+509, 0x1.0000000000000p+404},
+{0x1.003ffffffffe0p+511, 0x1.ffffe03800000p+435, 0x1.0000000002000p+705, -0x1.0000000000000p+652, 0x1.0000000002000p+705, -0x1.0000000000000p+652},
+{0x1.003ffffffffe0p+511, 0x1.ffffe03800000p+435, -0x1.0000000002000p+705, 0x1.0000000000000p+652, -0x1.0000000002000p+705, 0x1.0000000000000p+652},
+{-0x1.003ffffffffe0p+511, -0x1.ffffe03800000p+435, 0x1.0000000002000p+705, -0x1.0000000000000p+652, 0x1.0000000002000p+705, -0x1.0000000000000p+652},
+{-0x1.003ffffffffe0p+511, -0x1.ffffe03800000p+435, -0x1.0000000002000p+705, 0x1.0000000000000p+652, -0x1.0000000002000p+705, 0x1.0000000000000p+652},
+{0x1.0000000000008p-749, -0x1.ff000007ffc00p-809, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786},
+{0x1.0000000000008p-749, -0x1.ff000007ffc00p-809, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786},
+{-0x1.0000000000008p-749, 0x1.ff000007ffc00p-809, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786},
+{-0x1.0000000000008p-749, 0x1.ff000007ffc00p-809, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786},
+{0x1.0000000000080p+921, -0x1.0000000000000p+816, 0x1.01ffffff80001p+85, -0x1.ff90000000000p-8, 0x1.0000000000080p+921, -0x1.0000000000000p+816},
+{0x1.0000000000080p+921, -0x1.0000000000000p+816, -0x1.01ffffff80001p+85, 0x1.ff90000000000p-8, 0x1.0000000000080p+921, -0x1.0000000000000p+816},
+{-0x1.0000000000080p+921, 0x1.0000000000000p+816, 0x1.01ffffff80001p+85, -0x1.ff90000000000p-8, -0x1.0000000000080p+921, 0x1.0000000000000p+816},
+{-0x1.0000000000080p+921, 0x1.0000000000000p+816, -0x1.01ffffff80001p+85, 0x1.ff90000000000p-8, -0x1.0000000000080p+921, 0x1.0000000000000p+816},
+{0x1.0000000000800p-666, -0x1.fffff80002000p-732, 0x1.0008000000000p-639, -0x1.0000000000000p-718, 0x1.0008002000000p-639, 0x1.ffbffe0000000p-708},
+{0x1.0000000000800p-666, -0x1.fffff80002000p-732, -0x1.0008000000000p-639, 0x1.0000000000000p-718, -0x1.0007ffe000000p-639, 0x1.001fff0000000p-707},
+{-0x1.0000000000800p-666, 0x1.fffff80002000p-732, 0x1.0008000000000p-639, -0x1.0000000000000p-718, 0x1.0007ffe000000p-639, -0x1.001fff0000000p-707},
+{-0x1.0000000000800p-666, 0x1.fffff80002000p-732, -0x1.0008000000000p-639, 0x1.0000000000000p-718, -0x1.0008002000000p-639, -0x1.ffbffe0000000p-708},
+{0x1.0000000000002p+14, -0x1.ffffffe200000p-60, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70},
+{0x1.0000000000002p+14, -0x1.ffffffe200000p-60, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70},
+{-0x1.0000000000002p+14, 0x1.ffffffe200000p-60, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70},
+{-0x1.0000000000002p+14, 0x1.ffffffe200000p-60, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70},
+{0x1.000003f000000p+120, 0x1.fffffffe00000p+59, 0x1.0000000000ff0p+144, 0x1.c03fff0e00000p+70, 0x1.000001000102fp+144, 0x1.c07fff0e00000p+70},
+{0x1.000003f000000p+120, 0x1.fffffffe00000p+59, -0x1.0000000000ff0p+144, -0x1.c03fff0e00000p+70, -0x1.fffffe0001f62p+143, -0x1.bfffff0e00000p+70},
+{-0x1.000003f000000p+120, -0x1.fffffffe00000p+59, 0x1.0000000000ff0p+144, 0x1.c03fff0e00000p+70, 0x1.fffffe0001f62p+143, 0x1.bfffff0e00000p+70},
+{-0x1.000003f000000p+120, -0x1.fffffffe00000p+59, -0x1.0000000000ff0p+144, -0x1.c03fff0e00000p+70, -0x1.000001000102fp+144, -0x1.c07fff0e00000p+70},
+{0x1.0000000018000p+68, 0x1.fffffe0000000p-14, 0x1.0000100000000p+766, -0x1.0000000000000p+661, 0x1.0000100000000p+766, -0x1.0000000000000p+661},
+{0x1.0000000018000p+68, 0x1.fffffe0000000p-14, -0x1.0000100000000p+766, 0x1.0000000000000p+661, -0x1.0000100000000p+766, 0x1.0000000000000p+661},
+{-0x1.0000000018000p+68, -0x1.fffffe0000000p-14, 0x1.0000100000000p+766, -0x1.0000000000000p+661, 0x1.0000100000000p+766, -0x1.0000000000000p+661},
+{-0x1.0000000018000p+68, -0x1.fffffe0000000p-14, -0x1.0000100000000p+766, 0x1.0000000000000p+661, -0x1.0000100000000p+766, 0x1.0000000000000p+661},
+{0x1.0000000000001p-191, -0x1.fffffc1000000p-258, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256},
+{0x1.0000000000001p-191, -0x1.fffffc1000000p-258, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256},
+{-0x1.0000000000001p-191, 0x1.fffffc1000000p-258, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256},
+{-0x1.0000000000001p-191, 0x1.fffffc1000000p-258, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256},
+{0x1.0000003800000p-790, 0x1.ffe000001fffcp-845, 0x1.0000007fffff0p-815, 0x1.fe1ffffc00000p-877, 0x1.000000b800004p-790, 0x1.ffdfc0021e1fcp-845},
+{0x1.0000003800000p-790, 0x1.ffe000001fffcp-845, -0x1.0000007fffff0p-815, -0x1.fe1ffffc00000p-877, 0x1.ffffff6fffff8p-791, 0x1.ffe03ffe21dfcp-845},
+{-0x1.0000003800000p-790, -0x1.ffe000001fffcp-845, 0x1.0000007fffff0p-815, 0x1.fe1ffffc00000p-877, -0x1.ffffff6fffff8p-791, -0x1.ffe03ffe21dfcp-845},
+{-0x1.0000003800000p-790, -0x1.ffe000001fffcp-845, -0x1.0000007fffff0p-815, -0x1.fe1ffffc00000p-877, -0x1.000000b800004p-790, -0x1.ffdfc0021e1fcp-845},
+{0x1.0000001fffc00p-770, 0x1.f00007ffe0000p-834, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932},
+{0x1.0000001fffc00p-770, 0x1.f00007ffe0000p-834, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932},
+{-0x1.0000001fffc00p-770, -0x1.f00007ffe0000p-834, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932},
+{-0x1.0000001fffc00p-770, -0x1.f00007ffe0000p-834, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932},
+{0x1.0000000008000p+440, -0x1.c0000007ffe04p+385, 0x1.00000fffffffep-521, 0x1.fc00000000000p-620, 0x1.0000000008000p+440, -0x1.c0000007ffe04p+385},
+{0x1.0000000008000p+440, -0x1.c0000007ffe04p+385, -0x1.00000fffffffep-521, -0x1.fc00000000000p-620, 0x1.0000000008000p+440, -0x1.c0000007ffe04p+385},
+{-0x1.0000000008000p+440, 0x1.c0000007ffe04p+385, 0x1.00000fffffffep-521, 0x1.fc00000000000p-620, -0x1.0000000008000p+440, 0x1.c0000007ffe04p+385},
+{-0x1.0000000008000p+440, 0x1.c0000007ffe04p+385, -0x1.00000fffffffep-521, -0x1.fc00000000000p-620, -0x1.0000000008000p+440, 0x1.c0000007ffe04p+385},
+{0x1.0000003e00004p-731, -0x1.fe00040000000p-801, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419},
+{0x1.0000003e00004p-731, -0x1.fe00040000000p-801, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419},
+{-0x1.0000003e00004p-731, 0x1.fe00040000000p-801, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419},
+{-0x1.0000003e00004p-731, 0x1.fe00040000000p-801, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419},
+{0x1.03fffffffc000p-192, 0x1.ffffffc000000p-267, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554},
+{0x1.03fffffffc000p-192, 0x1.ffffffc000000p-267, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554},
+{-0x1.03fffffffc000p-192, -0x1.ffffffc000000p-267, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554},
+{-0x1.03fffffffc000p-192, -0x1.ffffffc000000p-267, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554},
+{0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230, 0x1.0000000000004p-464, -0x1.fffc000200000p-533, 0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230},
+{0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230, -0x1.0000000000004p-464, 0x1.fffc000200000p-533, 0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230},
+{-0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230, 0x1.0000000000004p-464, -0x1.fffc000200000p-533, -0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230},
+{-0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230, -0x1.0000000000004p-464, 0x1.fffc000200000p-533, -0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230},
+{0x1.00003ffffff80p-1007, 0x1.0000000000000p-1068, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{0x1.00003ffffff80p-1007, 0x1.0000000000000p-1068, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{-0x1.00003ffffff80p-1007, -0x1.0000000000000p-1068, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{-0x1.00003ffffff80p-1007, -0x1.0000000000000p-1068, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{0x1.0000010000000p-912, -0x1.0000000000000p-1017, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60},
+{0x1.0000010000000p-912, -0x1.0000000000000p-1017, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60},
+{-0x1.0000010000000p-912, 0x1.0000000000000p-1017, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60},
+{-0x1.0000010000000p-912, 0x1.0000000000000p-1017, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60},
+{0x1.0000000000004p+652, -0x1.fff0008000000p+588, 0x1.0000000100000p+402, -0x1.fffffe0004000p+335, 0x1.0000000000004p+652, -0x1.fff0008000000p+588},
+{0x1.0000000000004p+652, -0x1.fff0008000000p+588, -0x1.0000000100000p+402, 0x1.fffffe0004000p+335, 0x1.0000000000004p+652, -0x1.fff0008000000p+588},
+{-0x1.0000000000004p+652, 0x1.fff0008000000p+588, 0x1.0000000100000p+402, -0x1.fffffe0004000p+335, -0x1.0000000000004p+652, 0x1.fff0008000000p+588},
+{-0x1.0000000000004p+652, 0x1.fff0008000000p+588, -0x1.0000000100000p+402, 0x1.fffffe0004000p+335, -0x1.0000000000004p+652, 0x1.fff0008000000p+588},
+{0x1.0000000000800p-11, -0x1.0000000000000p-89, 0x1.0000010000000p+68, -0x1.0000000000000p-35, 0x1.0000010000000p+68, 0x1.fffffe0000000p-12},
+{0x1.0000000000800p-11, -0x1.0000000000000p-89, -0x1.0000010000000p+68, 0x1.0000000000000p-35, -0x1.0000010000000p+68, 0x1.0000010000000p-11},
+{-0x1.0000000000800p-11, 0x1.0000000000000p-89, 0x1.0000010000000p+68, -0x1.0000000000000p-35, 0x1.0000010000000p+68, -0x1.0000010000000p-11},
+{-0x1.0000000000800p-11, 0x1.0000000000000p-89, -0x1.0000010000000p+68, 0x1.0000000000000p-35, -0x1.0000010000000p+68, -0x1.fffffe0000000p-12},
+{0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842, 0x1.0000007c00000p-1007, 0x0.0000000000000p+0, 0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842},
+{0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842, -0x1.0000007c00000p-1007, -0x0.0000000000000p+0, 0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842},
+{-0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842, 0x1.0000007c00000p-1007, 0x0.0000000000000p+0, -0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842},
+{-0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842, -0x1.0000007c00000p-1007, -0x0.0000000000000p+0, -0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842},
+{0x1.fffffffe00000p+397, 0x1.e000001fff800p+333, 0x1.00000001ffffep+347, 0x0.0000000000000p+0, 0x1.fffffffe00004p+397, 0x1.e000801ff7800p+333},
+{0x1.fffffffe00000p+397, 0x1.e000001fff800p+333, -0x1.00000001ffffep+347, 0x0.0000000000000p+0, 0x1.fffffffdffffcp+397, 0x1.dfff802007800p+333},
+{-0x1.fffffffe00000p+397, -0x1.e000001fff800p+333, 0x1.00000001ffffep+347, 0x0.0000000000000p+0, -0x1.fffffffdffffcp+397, -0x1.dfff802007800p+333},
+{-0x1.fffffffe00000p+397, -0x1.e000001fff800p+333, -0x1.00000001ffffep+347, 0x0.0000000000000p+0, -0x1.fffffffe00004p+397, -0x1.e000801ff7800p+333},
+{0x1.0000000000008p-231, -0x1.fffff00400000p-303, 0x1.00003ffffe000p-829, 0x1.ffffe00000000p-901, 0x1.0000000000008p-231, -0x1.fffff00400000p-303},
+{0x1.0000000000008p-231, -0x1.fffff00400000p-303, -0x1.00003ffffe000p-829, -0x1.ffffe00000000p-901, 0x1.0000000000008p-231, -0x1.fffff00400000p-303},
+{-0x1.0000000000008p-231, 0x1.fffff00400000p-303, 0x1.00003ffffe000p-829, 0x1.ffffe00000000p-901, -0x1.0000000000008p-231, 0x1.fffff00400000p-303},
+{-0x1.0000000000008p-231, 0x1.fffff00400000p-303, -0x1.00003ffffe000p-829, -0x1.ffffe00000000p-901, -0x1.0000000000008p-231, 0x1.fffff00400000p-303},
+{0x1.0000000000000p-479, 0x1.ffffffffffc00p-542, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414},
+{0x1.0000000000000p-479, 0x1.ffffffffffc00p-542, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414},
+{-0x1.0000000000000p-479, -0x1.ffffffffffc00p-542, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414},
+{-0x1.0000000000000p-479, -0x1.ffffffffffc00p-542, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414},
+{0x1.0000000000400p-496, -0x1.f800000002000p-557, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116},
+{0x1.0000000000400p-496, -0x1.f800000002000p-557, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116},
+{-0x1.0000000000400p-496, 0x1.f800000002000p-557, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116},
+{-0x1.0000000000400p-496, 0x1.f800000002000p-557, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116},
+{0x1.0000000000000p+267, 0x1.fffffffffff00p+211, 0x1.000007c000000p+439, 0x1.fff8000000000p+383, 0x1.000007c000000p+439, 0x1.fff8000000000p+383},
+{0x1.0000000000000p+267, 0x1.fffffffffff00p+211, -0x1.000007c000000p+439, -0x1.fff8000000000p+383, -0x1.000007c000000p+439, -0x1.fff8000000000p+383},
+{-0x1.0000000000000p+267, -0x1.fffffffffff00p+211, 0x1.000007c000000p+439, 0x1.fff8000000000p+383, 0x1.000007c000000p+439, 0x1.fff8000000000p+383},
+{-0x1.0000000000000p+267, -0x1.fffffffffff00p+211, -0x1.000007c000000p+439, -0x1.fff8000000000p+383, -0x1.000007c000000p+439, -0x1.fff8000000000p+383},
+{0x1.0000000000400p-383, -0x1.fffc0003fffd0p-440, 0x1.0000000000000p+249, 0x1.fffffff800000p+193, 0x1.0000000000000p+249, 0x1.fffffff800000p+193},
+{0x1.0000000000400p-383, -0x1.fffc0003fffd0p-440, -0x1.0000000000000p+249, -0x1.fffffff800000p+193, -0x1.0000000000000p+249, -0x1.fffffff800000p+193},
+{-0x1.0000000000400p-383, 0x1.fffc0003fffd0p-440, 0x1.0000000000000p+249, 0x1.fffffff800000p+193, 0x1.0000000000000p+249, 0x1.fffffff800000p+193},
+{-0x1.0000000000400p-383, 0x1.fffc0003fffd0p-440, -0x1.0000000000000p+249, -0x1.fffffff800000p+193, -0x1.0000000000000p+249, -0x1.fffffff800000p+193},
+{0x1.0000000002000p-673, -0x1.ffff040000000p-744, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862},
+{0x1.0000000002000p-673, -0x1.ffff040000000p-744, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862},
+{-0x1.0000000002000p-673, 0x1.ffff040000000p-744, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862},
+{-0x1.0000000002000p-673, 0x1.ffff040000000p-744, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862},
+{0x1.0000008000000p+436, -0x1.ffffff8200000p+379, 0x1.000fff8000000p-8, 0x1.fffffe0000000p-70, 0x1.0000008000000p+436, -0x1.ffffff8200000p+379},
+{0x1.0000008000000p+436, -0x1.ffffff8200000p+379, -0x1.000fff8000000p-8, -0x1.fffffe0000000p-70, 0x1.0000008000000p+436, -0x1.ffffff8200000p+379},
+{-0x1.0000008000000p+436, 0x1.ffffff8200000p+379, 0x1.000fff8000000p-8, 0x1.fffffe0000000p-70, -0x1.0000008000000p+436, 0x1.ffffff8200000p+379},
+{-0x1.0000008000000p+436, 0x1.ffffff8200000p+379, -0x1.000fff8000000p-8, -0x1.fffffe0000000p-70, -0x1.0000008000000p+436, 0x1.ffffff8200000p+379},
+{0x1.0000000000000p+138, 0x1.0001f9e000000p+78, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366},
+{0x1.0000000000000p+138, 0x1.0001f9e000000p+78, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366},
+{-0x1.0000000000000p+138, -0x1.0001f9e000000p+78, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366},
+{-0x1.0000000000000p+138, -0x1.0001f9e000000p+78, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366},
+{0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888, 0x1.0000010000000p+582, -0x1.ffc007ffffe20p+524, 0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888},
+{0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888, -0x1.0000010000000p+582, 0x1.ffc007ffffe20p+524, 0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888},
+{-0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888, 0x1.0000010000000p+582, -0x1.ffc007ffffe20p+524, -0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888},
+{-0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888, -0x1.0000010000000p+582, 0x1.ffc007ffffe20p+524, -0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888},
+{0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694, 0x1.0040000000000p-580, -0x1.c000000400000p-641, 0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694},
+{0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694, -0x1.0040000000000p-580, 0x1.c000000400000p-641, 0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694},
+{-0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694, 0x1.0040000000000p-580, -0x1.c000000400000p-641, -0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694},
+{-0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694, -0x1.0040000000000p-580, 0x1.c000000400000p-641, -0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694},
+{0x1.0080000000000p-806, -0x1.0000000000000p-911, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541},
+{0x1.0080000000000p-806, -0x1.0000000000000p-911, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541},
+{-0x1.0080000000000p-806, 0x1.0000000000000p-911, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541},
+{-0x1.0080000000000p-806, 0x1.0000000000000p-911, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541},
+{0x1.000000003ff00p-698, 0x0.0000000000000p+0, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362},
+{0x1.000000003ff00p-698, 0x0.0000000000000p+0, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362},
+{-0x1.000000003ff00p-698, 0x0.0000000000000p+0, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362},
+{-0x1.000000003ff00p-698, 0x0.0000000000000p+0, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362},
+{0x1.00003fffffe00p-546, 0x1.fffffc0000380p-606, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386},
+{0x1.00003fffffe00p-546, 0x1.fffffc0000380p-606, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386},
+{-0x1.00003fffffe00p-546, -0x1.fffffc0000380p-606, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386},
+{-0x1.00003fffffe00p-546, -0x1.fffffc0000380p-606, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386},
+{0x1.0000000080000p-450, -0x1.fffffc0010000p-519, 0x1.3fffff8000000p-829, 0x1.fffff800fe000p-895, 0x1.0000000080000p-450, -0x1.fffffc0010000p-519},
+{0x1.0000000080000p-450, -0x1.fffffc0010000p-519, -0x1.3fffff8000000p-829, -0x1.fffff800fe000p-895, 0x1.0000000080000p-450, -0x1.fffffc0010000p-519},
+{-0x1.0000000080000p-450, 0x1.fffffc0010000p-519, 0x1.3fffff8000000p-829, 0x1.fffff800fe000p-895, -0x1.0000000080000p-450, 0x1.fffffc0010000p-519},
+{-0x1.0000000080000p-450, 0x1.fffffc0010000p-519, -0x1.3fffff8000000p-829, -0x1.fffff800fe000p-895, -0x1.0000000080000p-450, 0x1.fffffc0010000p-519},
+{0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794, 0x1.0000000000000p+214, 0x1.fc1fffc0000fep+160, 0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794},
+{0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794, -0x1.0000000000000p+214, -0x1.fc1fffc0000fep+160, 0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794},
+{-0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794, 0x1.0000000000000p+214, 0x1.fc1fffc0000fep+160, -0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794},
+{-0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794, -0x1.0000000000000p+214, -0x1.fc1fffc0000fep+160, -0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794},
+{0x1.0000000000000p+702, 0x1.fffffffffffc0p+643, 0x1.0000000000000p-646, 0x1.ffffffffffe00p-708, 0x1.0000000000000p+702, 0x1.fffffffffffc0p+643},
+{0x1.0000000000000p+702, 0x1.fffffffffffc0p+643, -0x1.0000000000000p-646, -0x1.ffffffffffe00p-708, 0x1.0000000000000p+702, 0x1.fffffffffffc0p+643},
+{-0x1.0000000000000p+702, -0x1.fffffffffffc0p+643, 0x1.0000000000000p-646, 0x1.ffffffffffe00p-708, -0x1.0000000000000p+702, -0x1.fffffffffffc0p+643},
+{-0x1.0000000000000p+702, -0x1.fffffffffffc0p+643, -0x1.0000000000000p-646, -0x1.ffffffffffe00p-708, -0x1.0000000000000p+702, -0x1.fffffffffffc0p+643},
+{0x1.0000000100000p+167, -0x1.0000000000000p+88, 0x1.0000004000000p+455, -0x1.0000000000000p+375, 0x1.0000004000000p+455, -0x1.0000000000000p+375},
+{0x1.0000000100000p+167, -0x1.0000000000000p+88, -0x1.0000004000000p+455, 0x1.0000000000000p+375, -0x1.0000004000000p+455, 0x1.0000000000000p+375},
+{-0x1.0000000100000p+167, 0x1.0000000000000p+88, 0x1.0000004000000p+455, -0x1.0000000000000p+375, 0x1.0000004000000p+455, -0x1.0000000000000p+375},
+{-0x1.0000000100000p+167, 0x1.0000000000000p+88, -0x1.0000004000000p+455, 0x1.0000000000000p+375, -0x1.0000004000000p+455, 0x1.0000000000000p+375},
+{0x1.0000010000000p+394, -0x1.ffffe00001000p+338, 0x1.000ffffff007fp-145, 0x1.ffffc00000000p-226, 0x1.0000010000000p+394, -0x1.ffffe00001000p+338},
+{0x1.0000010000000p+394, -0x1.ffffe00001000p+338, -0x1.000ffffff007fp-145, -0x1.ffffc00000000p-226, 0x1.0000010000000p+394, -0x1.ffffe00001000p+338},
+{-0x1.0000010000000p+394, 0x1.ffffe00001000p+338, 0x1.000ffffff007fp-145, 0x1.ffffc00000000p-226, -0x1.0000010000000p+394, 0x1.ffffe00001000p+338},
+{-0x1.0000010000000p+394, 0x1.ffffe00001000p+338, -0x1.000ffffff007fp-145, -0x1.ffffc00000000p-226, -0x1.0000010000000p+394, 0x1.ffffe00001000p+338},
+{0x1.1000fffffc000p+16, 0x1.fffffc003f000p-40, 0x1.0000000001000p+243, -0x1.0000000000000p+138, 0x1.0000000001000p+243, -0x1.0000000000000p+138},
+{0x1.1000fffffc000p+16, 0x1.fffffc003f000p-40, -0x1.0000000001000p+243, 0x1.0000000000000p+138, -0x1.0000000001000p+243, 0x1.0000000000000p+138},
+{-0x1.1000fffffc000p+16, -0x1.fffffc003f000p-40, 0x1.0000000001000p+243, -0x1.0000000000000p+138, 0x1.0000000001000p+243, -0x1.0000000000000p+138},
+{-0x1.1000fffffc000p+16, -0x1.fffffc003f000p-40, -0x1.0000000001000p+243, 0x1.0000000000000p+138, -0x1.0000000001000p+243, 0x1.0000000000000p+138},
+{0x1.00000fff80000p+494, 0x1.fffe000000000p+409, 0x1.0000001f00000p-623, 0x1.fffffff000000p-700, 0x1.00000fff80000p+494, 0x1.fffe000000000p+409},
+{0x1.00000fff80000p+494, 0x1.fffe000000000p+409, -0x1.0000001f00000p-623, -0x1.fffffff000000p-700, 0x1.00000fff80000p+494, 0x1.fffe000000000p+409},
+{-0x1.00000fff80000p+494, -0x1.fffe000000000p+409, 0x1.0000001f00000p-623, 0x1.fffffff000000p-700, -0x1.00000fff80000p+494, -0x1.fffe000000000p+409},
+{-0x1.00000fff80000p+494, -0x1.fffe000000000p+409, -0x1.0000001f00000p-623, -0x1.fffffff000000p-700, -0x1.00000fff80000p+494, -0x1.fffe000000000p+409},
+{0x1.3fdfffff02000p-533, -0x1.0000000000000p-611, 0x1.0000000000000p-602, 0x1.ffffffffffe00p-663, 0x1.3fdfffff02000p-533, 0x1.ff00000000000p-603},
+{0x1.3fdfffff02000p-533, -0x1.0000000000000p-611, -0x1.0000000000000p-602, -0x1.ffffffffffe00p-663, 0x1.3fdfffff02000p-533, -0x1.0080000000000p-602},
+{-0x1.3fdfffff02000p-533, 0x1.0000000000000p-611, 0x1.0000000000000p-602, 0x1.ffffffffffe00p-663, -0x1.3fdfffff02000p-533, 0x1.0080000000000p-602},
+{-0x1.3fdfffff02000p-533, 0x1.0000000000000p-611, -0x1.0000000000000p-602, -0x1.ffffffffffe00p-663, -0x1.3fdfffff02000p-533, -0x1.ff00000000000p-603},
+{0x1.0000000000008p-274, -0x1.e0ffffd002000p-340, 0x1.0000000000400p-229, 0x1.ffffffff03ffep-283, 0x1.0000000000480p-229, 0x1.ffffffff04ffep-283},
+{0x1.0000000000008p-274, -0x1.e0ffffd002000p-340, -0x1.0000000000400p-229, -0x1.ffffffff03ffep-283, -0x1.0000000000380p-229, -0x1.ffffffff02ffep-283},
+{-0x1.0000000000008p-274, 0x1.e0ffffd002000p-340, 0x1.0000000000400p-229, 0x1.ffffffff03ffep-283, 0x1.0000000000380p-229, 0x1.ffffffff02ffep-283},
+{-0x1.0000000000008p-274, 0x1.e0ffffd002000p-340, -0x1.0000000000400p-229, -0x1.ffffffff03ffep-283, -0x1.0000000000480p-229, -0x1.ffffffff04ffep-283},
+{0x1.000000fffe020p-113, -0x1.f800100000000p-186, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84},
+{0x1.000000fffe020p-113, -0x1.f800100000000p-186, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84},
+{-0x1.000000fffe020p-113, 0x1.f800100000000p-186, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84},
+{-0x1.000000fffe020p-113, 0x1.f800100000000p-186, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84},
+{0x1.4000000000000p+455, -0x1.0000000000000p+350, 0x1.0000000000010p-968, 0x1.e000000000000p-1036, 0x1.4000000000000p+455, -0x1.0000000000000p+350},
+{0x1.4000000000000p+455, -0x1.0000000000000p+350, -0x1.0000000000010p-968, -0x1.e000000000000p-1036, 0x1.4000000000000p+455, -0x1.0000000000000p+350},
+{-0x1.4000000000000p+455, 0x1.0000000000000p+350, 0x1.0000000000010p-968, 0x1.e000000000000p-1036, -0x1.4000000000000p+455, 0x1.0000000000000p+350},
+{-0x1.4000000000000p+455, 0x1.0000000000000p+350, -0x1.0000000000010p-968, -0x1.e000000000000p-1036, -0x1.4000000000000p+455, 0x1.0000000000000p+350},
+{0x1.2000000000000p+333, -0x1.fffffff01ff20p+276, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644},
+{0x1.2000000000000p+333, -0x1.fffffff01ff20p+276, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644},
+{-0x1.2000000000000p+333, 0x1.fffffff01ff20p+276, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644},
+{-0x1.2000000000000p+333, 0x1.fffffff01ff20p+276, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644},
+{0x1.2000000000000p+275, -0x1.fc08000000000p+183, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681},
+{0x1.2000000000000p+275, -0x1.fc08000000000p+183, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681},
+{-0x1.2000000000000p+275, 0x1.fc08000000000p+183, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681},
+{-0x1.2000000000000p+275, 0x1.fc08000000000p+183, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681},
+{0x1.0000000000200p+680, 0x0.0000000000000p+0, 0x1.00001ffff0000p-146, 0x1.ffff80001f000p-203, 0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{0x1.0000000000200p+680, 0x0.0000000000000p+0, -0x1.00001ffff0000p-146, -0x1.ffff80001f000p-203, 0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{-0x1.0000000000200p+680, 0x0.0000000000000p+0, 0x1.00001ffff0000p-146, 0x1.ffff80001f000p-203, -0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{-0x1.0000000000200p+680, 0x0.0000000000000p+0, -0x1.00001ffff0000p-146, -0x1.ffff80001f000p-203, -0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{0x1.0000100000000p-400, -0x1.0000000000000p-505, 0x1.0038000800000p-754, -0x1.fffffe0000080p-814, 0x1.0000100000000p-400, -0x1.0000000000000p-505},
+{0x1.0000100000000p-400, -0x1.0000000000000p-505, -0x1.0038000800000p-754, 0x1.fffffe0000080p-814, 0x1.0000100000000p-400, -0x1.0000000000000p-505},
+{-0x1.0000100000000p-400, 0x1.0000000000000p-505, 0x1.0038000800000p-754, -0x1.fffffe0000080p-814, -0x1.0000100000000p-400, 0x1.0000000000000p-505},
+{-0x1.0000100000000p-400, 0x1.0000000000000p-505, -0x1.0038000800000p-754, 0x1.fffffe0000080p-814, -0x1.0000100000000p-400, 0x1.0000000000000p-505},
+{0x1.0000000000004p+838, -0x1.ffffe00400000p+765, 0x1.0000000000000p-355, 0x1.ffffffffffff8p-411, 0x1.0000000000004p+838, -0x1.ffffe00400000p+765},
+{0x1.0000000000004p+838, -0x1.ffffe00400000p+765, -0x1.0000000000000p-355, -0x1.ffffffffffff8p-411, 0x1.0000000000004p+838, -0x1.ffffe00400000p+765},
+{-0x1.0000000000004p+838, 0x1.ffffe00400000p+765, 0x1.0000000000000p-355, 0x1.ffffffffffff8p-411, -0x1.0000000000004p+838, 0x1.ffffe00400000p+765},
+{-0x1.0000000000004p+838, 0x1.ffffe00400000p+765, -0x1.0000000000000p-355, -0x1.ffffffffffff8p-411, -0x1.0000000000004p+838, 0x1.ffffe00400000p+765},
+{0x1.0000000000100p+877, -0x1.ffffe7e400000p+807, 0x1.1ffe000008000p+922, -0x1.fffc000004000p+855, 0x1.1ffe000008080p+922, -0x1.fffbfc0004000p+855},
+{0x1.0000000000100p+877, -0x1.ffffe7e400000p+807, -0x1.1ffe000008000p+922, 0x1.fffc000004000p+855, -0x1.1ffe000007f80p+922, 0x1.fffc040004000p+855},
+{-0x1.0000000000100p+877, 0x1.ffffe7e400000p+807, 0x1.1ffe000008000p+922, -0x1.fffc000004000p+855, 0x1.1ffe000007f80p+922, -0x1.fffc040004000p+855},
+{-0x1.0000000000100p+877, 0x1.ffffe7e400000p+807, -0x1.1ffe000008000p+922, 0x1.fffc000004000p+855, -0x1.1ffe000008080p+922, 0x1.fffbfc0004000p+855},
+{0x1.0000000000004p-490, -0x1.0000000000000p-595, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413},
+{0x1.0000000000004p-490, -0x1.0000000000000p-595, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413},
+{-0x1.0000000000004p-490, 0x1.0000000000000p-595, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413},
+{-0x1.0000000000004p-490, 0x1.0000000000000p-595, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413},
+{0x1.0000000000000p-458, 0x1.fffffff000000p-519, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712},
+{0x1.0000000000000p-458, 0x1.fffffff000000p-519, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712},
+{-0x1.0000000000000p-458, -0x1.fffffff000000p-519, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712},
+{-0x1.0000000000000p-458, -0x1.fffffff000000p-519, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712},
+{0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803, 0x1.0080000000000p-983, -0x0.0000000000000p+0, 0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803},
+{0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803, -0x1.0080000000000p-983, 0x0.0000000000000p+0, 0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803},
+{-0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803, 0x1.0080000000000p-983, -0x0.0000000000000p+0, -0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803},
+{-0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803, -0x1.0080000000000p-983, 0x0.0000000000000p+0, -0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803},
+{0x1.0000000000080p-788, 0x0.0000000000000p+0, 0x1.0000080000000p+973, -0x1.0000000000000p+888, 0x1.0000080000000p+973, -0x1.0000000000000p+888},
+{0x1.0000000000080p-788, 0x0.0000000000000p+0, -0x1.0000080000000p+973, 0x1.0000000000000p+888, -0x1.0000080000000p+973, 0x1.0000000000000p+888},
+{-0x1.0000000000080p-788, 0x0.0000000000000p+0, 0x1.0000080000000p+973, -0x1.0000000000000p+888, 0x1.0000080000000p+973, -0x1.0000000000000p+888},
+{-0x1.0000000000080p-788, 0x0.0000000000000p+0, -0x1.0000080000000p+973, 0x1.0000000000000p+888, -0x1.0000080000000p+973, 0x1.0000000000000p+888},
+{0x1.0400000000000p-287, -0x1.0000000000000p-392, 0x1.0000000000400p+736, -0x1.fffff00008000p+680, 0x1.0000000000400p+736, -0x1.fffff00008000p+680},
+{0x1.0400000000000p-287, -0x1.0000000000000p-392, -0x1.0000000000400p+736, 0x1.fffff00008000p+680, -0x1.0000000000400p+736, 0x1.fffff00008000p+680},
+{-0x1.0400000000000p-287, 0x1.0000000000000p-392, 0x1.0000000000400p+736, -0x1.fffff00008000p+680, 0x1.0000000000400p+736, -0x1.fffff00008000p+680},
+{-0x1.0400000000000p-287, 0x1.0000000000000p-392, -0x1.0000000000400p+736, 0x1.fffff00008000p+680, -0x1.0000000000400p+736, 0x1.fffff00008000p+680},
+{0x1.0000000000001p+232, -0x1.fc0000c004000p+167, 0x1.0000000000200p+192, -0x1.ffe0000200000p+124, 0x1.0000000001001p+232, -0x1.fbffc0c004000p+167},
+{0x1.0000000000001p+232, -0x1.fc0000c004000p+167, -0x1.0000000000200p+192, 0x1.ffe0000200000p+124, 0x1.fffffffffe002p+231, -0x1.fc0040c004000p+167},
+{-0x1.0000000000001p+232, 0x1.fc0000c004000p+167, 0x1.0000000000200p+192, -0x1.ffe0000200000p+124, -0x1.fffffffffe002p+231, 0x1.fc0040c004000p+167},
+{-0x1.0000000000001p+232, 0x1.fc0000c004000p+167, -0x1.0000000000200p+192, 0x1.ffe0000200000p+124, -0x1.0000000001001p+232, 0x1.fbffc0c004000p+167},
+{0x1.00000c0000004p+583, -0x1.ff80000800000p+515, 0x1.18003ffff8000p-786, 0x1.ffffff8000000p-852, 0x1.00000c0000004p+583, -0x1.ff80000800000p+515},
+{0x1.00000c0000004p+583, -0x1.ff80000800000p+515, -0x1.18003ffff8000p-786, -0x1.ffffff8000000p-852, 0x1.00000c0000004p+583, -0x1.ff80000800000p+515},
+{-0x1.00000c0000004p+583, 0x1.ff80000800000p+515, 0x1.18003ffff8000p-786, 0x1.ffffff8000000p-852, -0x1.00000c0000004p+583, 0x1.ff80000800000p+515},
+{-0x1.00000c0000004p+583, 0x1.ff80000800000p+515, -0x1.18003ffff8000p-786, -0x1.ffffff8000000p-852, -0x1.00000c0000004p+583, 0x1.ff80000800000p+515},
+{0x1.1ffff80000040p+488, -0x1.0000000000000p+398, 0x1.000000000fe00p-510, 0x1.ffff7e0003ff8p-566, 0x1.1ffff80000040p+488, -0x1.0000000000000p+398},
+{0x1.1ffff80000040p+488, -0x1.0000000000000p+398, -0x1.000000000fe00p-510, -0x1.ffff7e0003ff8p-566, 0x1.1ffff80000040p+488, -0x1.0000000000000p+398},
+{-0x1.1ffff80000040p+488, 0x1.0000000000000p+398, 0x1.000000000fe00p-510, 0x1.ffff7e0003ff8p-566, -0x1.1ffff80000040p+488, 0x1.0000000000000p+398},
+{-0x1.1ffff80000040p+488, 0x1.0000000000000p+398, -0x1.000000000fe00p-510, -0x1.ffff7e0003ff8p-566, -0x1.1ffff80000040p+488, 0x1.0000000000000p+398},
+{0x1.3fc0000040000p+871, -0x1.fffffff802000p+815, 0x1.fffffffffff00p-663, 0x0.0000000000000p+0, 0x1.3fc0000040000p+871, -0x1.fffffff802000p+815},
+{0x1.3fc0000040000p+871, -0x1.fffffff802000p+815, -0x1.fffffffffff00p-663, 0x0.0000000000000p+0, 0x1.3fc0000040000p+871, -0x1.fffffff802000p+815},
+{-0x1.3fc0000040000p+871, 0x1.fffffff802000p+815, 0x1.fffffffffff00p-663, 0x0.0000000000000p+0, -0x1.3fc0000040000p+871, 0x1.fffffff802000p+815},
+{-0x1.3fc0000040000p+871, 0x1.fffffff802000p+815, -0x1.fffffffffff00p-663, 0x0.0000000000000p+0, -0x1.3fc0000040000p+871, 0x1.fffffff802000p+815},
+{0x1.00000001fffffp-628, 0x1.00001f8000000p-699, 0x1.0000000000200p-312, -0x1.0000000000000p-417, 0x1.0000000000200p-312, -0x1.0000000000000p-417},
+{0x1.00000001fffffp-628, 0x1.00001f8000000p-699, -0x1.0000000000200p-312, 0x1.0000000000000p-417, -0x1.0000000000200p-312, 0x1.0000000000000p-417},
+{-0x1.00000001fffffp-628, -0x1.00001f8000000p-699, 0x1.0000000000200p-312, -0x1.0000000000000p-417, 0x1.0000000000200p-312, -0x1.0000000000000p-417},
+{-0x1.00000001fffffp-628, -0x1.00001f8000000p-699, -0x1.0000000000200p-312, 0x1.0000000000000p-417, -0x1.0000000000200p-312, 0x1.0000000000000p-417},
+{0x1.0000000010000p+23, -0x1.0000000000000p-54, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268},
+{0x1.0000000010000p+23, -0x1.0000000000000p-54, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268},
+{-0x1.0000000010000p+23, 0x1.0000000000000p-54, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268},
+{-0x1.0000000010000p+23, 0x1.0000000000000p-54, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268},
+{0x1.0000000000002p-4, -0x1.0000000000000p-91, 0x1.0000000000200p+643, -0x1.0000000000000p+558, 0x1.0000000000200p+643, -0x1.0000000000000p+558},
+{0x1.0000000000002p-4, -0x1.0000000000000p-91, -0x1.0000000000200p+643, 0x1.0000000000000p+558, -0x1.0000000000200p+643, 0x1.0000000000000p+558},
+{-0x1.0000000000002p-4, 0x1.0000000000000p-91, 0x1.0000000000200p+643, -0x1.0000000000000p+558, 0x1.0000000000200p+643, -0x1.0000000000000p+558},
+{-0x1.0000000000002p-4, 0x1.0000000000000p-91, -0x1.0000000000200p+643, 0x1.0000000000000p+558, -0x1.0000000000200p+643, 0x1.0000000000000p+558},
+{0x1.0000000000002p-252, -0x1.ffff800008000p-319, 0x1.000000003fffep-236, 0x1.f81fc007c0000p-307, 0x1.000100003fffep-236, 0x1.1f7ffc00fc000p-303},
+{0x1.0000000000002p-252, -0x1.ffff800008000p-319, -0x1.000000003fffep-236, -0x1.f81fc007c0000p-307, -0x1.fffe00007fffcp-237, 0x1.c0f8080008000p-304},
+{-0x1.0000000000002p-252, 0x1.ffff800008000p-319, 0x1.000000003fffep-236, 0x1.f81fc007c0000p-307, 0x1.fffe00007fffcp-237, -0x1.c0f8080008000p-304},
+{-0x1.0000000000002p-252, 0x1.ffff800008000p-319, -0x1.000000003fffep-236, -0x1.f81fc007c0000p-307, -0x1.000100003fffep-236, -0x1.1f7ffc00fc000p-303},
+{0x1.7ffffffff0000p-1014, 0x0.0000000000000p+0, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957},
+{0x1.7ffffffff0000p-1014, 0x0.0000000000000p+0, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957},
+{-0x1.7ffffffff0000p-1014, -0x0.0000000000000p+0, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957},
+{-0x1.7ffffffff0000p-1014, -0x0.0000000000000p+0, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957},
+{0x1.00007fff00080p+981, -0x1.ffffff0001000p+916, 0x1.00000000007c0p-918, 0x1.ffffff8000000p-985, 0x1.00007fff00080p+981, -0x1.ffffff0001000p+916},
+{0x1.00007fff00080p+981, -0x1.ffffff0001000p+916, -0x1.00000000007c0p-918, -0x1.ffffff8000000p-985, 0x1.00007fff00080p+981, -0x1.ffffff0001000p+916},
+{-0x1.00007fff00080p+981, 0x1.ffffff0001000p+916, 0x1.00000000007c0p-918, 0x1.ffffff8000000p-985, -0x1.00007fff00080p+981, 0x1.ffffff0001000p+916},
+{-0x1.00007fff00080p+981, 0x1.ffffff0001000p+916, -0x1.00000000007c0p-918, -0x1.ffffff8000000p-985, -0x1.00007fff00080p+981, 0x1.ffffff0001000p+916},
+{0x1.1fff81ff00000p-768, 0x1.e007ffff00000p-825, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292},
+{0x1.1fff81ff00000p-768, 0x1.e007ffff00000p-825, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292},
+{-0x1.1fff81ff00000p-768, -0x1.e007ffff00000p-825, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292},
+{-0x1.1fff81ff00000p-768, -0x1.e007ffff00000p-825, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292},
+{0x1.0000000000000p-141, 0x1.fffc03fe00700p-202, 0x1.0000000000001p-845, -0x1.fff8060000f34p-900, 0x1.0000000000000p-141, 0x1.fffc03fe00700p-202},
+{0x1.0000000000000p-141, 0x1.fffc03fe00700p-202, -0x1.0000000000001p-845, 0x1.fff8060000f34p-900, 0x1.0000000000000p-141, 0x1.fffc03fe00700p-202},
+{-0x1.0000000000000p-141, -0x1.fffc03fe00700p-202, 0x1.0000000000001p-845, -0x1.fff8060000f34p-900, -0x1.0000000000000p-141, -0x1.fffc03fe00700p-202},
+{-0x1.0000000000000p-141, -0x1.fffc03fe00700p-202, -0x1.0000000000001p-845, 0x1.fff8060000f34p-900, -0x1.0000000000000p-141, -0x1.fffc03fe00700p-202},
+{0x1.001ffffc00080p+872, -0x1.fe00000200000p+811, 0x1.0000000001000p-359, -0x1.fe3ffffff0080p-419, 0x1.001ffffc00080p+872, -0x1.fe00000200000p+811},
+{0x1.001ffffc00080p+872, -0x1.fe00000200000p+811, -0x1.0000000001000p-359, 0x1.fe3ffffff0080p-419, 0x1.001ffffc00080p+872, -0x1.fe00000200000p+811},
+{-0x1.001ffffc00080p+872, 0x1.fe00000200000p+811, 0x1.0000000001000p-359, -0x1.fe3ffffff0080p-419, -0x1.001ffffc00080p+872, 0x1.fe00000200000p+811},
+{-0x1.001ffffc00080p+872, 0x1.fe00000200000p+811, -0x1.0000000001000p-359, 0x1.fe3ffffff0080p-419, -0x1.001ffffc00080p+872, 0x1.fe00000200000p+811},
+{0x1.00001fffff800p-894, 0x1.ffffff801ffc0p-953, 0x1.0000000002000p-720, -0x1.0000000000000p-825, 0x1.0000000002000p-720, -0x1.0000000000000p-825},
+{0x1.00001fffff800p-894, 0x1.ffffff801ffc0p-953, -0x1.0000000002000p-720, 0x1.0000000000000p-825, -0x1.0000000002000p-720, 0x1.0000000000000p-825},
+{-0x1.00001fffff800p-894, -0x1.ffffff801ffc0p-953, 0x1.0000000002000p-720, -0x1.0000000000000p-825, 0x1.0000000002000p-720, -0x1.0000000000000p-825},
+{-0x1.00001fffff800p-894, -0x1.ffffff801ffc0p-953, -0x1.0000000002000p-720, 0x1.0000000000000p-825, -0x1.0000000002000p-720, 0x1.0000000000000p-825},
+{0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86, 0x1.0000000000000p-240, 0x1.ffffffffe0000p-296, 0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86},
+{0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86, -0x1.0000000000000p-240, -0x1.ffffffffe0000p-296, 0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86},
+{-0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86, 0x1.0000000000000p-240, 0x1.ffffffffe0000p-296, -0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86},
+{-0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86, -0x1.0000000000000p-240, -0x1.ffffffffe0000p-296, -0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86},
+{0x1.0000000000000p-874, 0x1.fffe7ff3dff00p-935, 0x1.000007f830000p-977, 0x1.fff0001000000p-1038, 0x1.0000000000000p-874, 0x1.fffe7ff3e0300p-935},
+{0x1.0000000000000p-874, 0x1.fffe7ff3dff00p-935, -0x1.000007f830000p-977, -0x1.fff0001000000p-1038, 0x1.0000000000000p-874, 0x1.fffe7ff3dfb00p-935},
+{-0x1.0000000000000p-874, -0x1.fffe7ff3dff00p-935, 0x1.000007f830000p-977, 0x1.fff0001000000p-1038, -0x1.0000000000000p-874, -0x1.fffe7ff3dfb00p-935},
+{-0x1.0000000000000p-874, -0x1.fffe7ff3dff00p-935, -0x1.000007f830000p-977, -0x1.fff0001000000p-1038, -0x1.0000000000000p-874, -0x1.fffe7ff3e0300p-935},
+{0x1.00000ffffe000p-269, 0x1.fffffffffc000p-336, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171},
+{0x1.00000ffffe000p-269, 0x1.fffffffffc000p-336, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171},
+{-0x1.00000ffffe000p-269, -0x1.fffffffffc000p-336, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171},
+{-0x1.00000ffffe000p-269, -0x1.fffffffffc000p-336, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171},
+{0x1.0000000000060p+403, 0x1.fffe3fff00000p+340, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726},
+{0x1.0000000000060p+403, 0x1.fffe3fff00000p+340, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726},
+{-0x1.0000000000060p+403, -0x1.fffe3fff00000p+340, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726},
+{-0x1.0000000000060p+403, -0x1.fffe3fff00000p+340, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726},
+{0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347, 0x1.07ff000008000p-591, -0x1.e000020000000p-652, 0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347},
+{0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347, -0x1.07ff000008000p-591, 0x1.e000020000000p-652, 0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347},
+{-0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347, 0x1.07ff000008000p-591, -0x1.e000020000000p-652, -0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347},
+{-0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347, -0x1.07ff000008000p-591, 0x1.e000020000000p-652, -0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347},
+// Some test cases where a and b are guaranteed to overlap:
+{0x1.0000000000002p-39, -0x1.ffc0ffff90000p-103, 0x1.0003ffffffffcp-35, 0x1.ffffc00000000p-122, 0x1.1003ffffffffcp-35, 0x1.ffe003f400068p-91},
+{0x1.0000000000002p-39, -0x1.ffc0ffff90000p-103, -0x1.0003ffffffffcp-35, -0x1.ffffc00000000p-122, -0x1.e007ffffffff8p-36, 0x1.ffe003ec00078p-91},
+{-0x1.0000000000002p-39, 0x1.ffc0ffff90000p-103, 0x1.0003ffffffffcp-35, 0x1.ffffc00000000p-122, 0x1.e007ffffffff8p-36, -0x1.ffe003ec00078p-91},
+{-0x1.0000000000002p-39, 0x1.ffc0ffff90000p-103, -0x1.0003ffffffffcp-35, -0x1.ffffc00000000p-122, -0x1.1003ffffffffcp-35, -0x1.ffe003f400068p-91},
+{0x1.0000100000000p+23, -0x1.0000000000000p-39, 0x1.0000000004000p-41, -0x1.ffffe00fc0200p-97, 0x1.0000100000000p+23, -0x1.7ffffffffe000p-40},
+{0x1.0000100000000p+23, -0x1.0000000000000p-39, -0x1.0000000004000p-41, 0x1.ffffe00fc0200p-97, 0x1.0000100000000p+23, -0x1.4000000001000p-39},
+{-0x1.0000100000000p+23, 0x1.0000000000000p-39, 0x1.0000000004000p-41, -0x1.ffffe00fc0200p-97, -0x1.0000100000000p+23, 0x1.4000000001000p-39},
+{-0x1.0000100000000p+23, 0x1.0000000000000p-39, -0x1.0000000004000p-41, 0x1.ffffe00fc0200p-97, -0x1.0000100000000p+23, 0x1.7ffffffffe000p-40},
+{0x1.0000000800000p-42, -0x1.0000000000000p-114, 0x1.000003fffc002p-41, -0x1.0000000000000p-146, 0x1.80000403fc002p-41, -0x1.0000000100000p-114},
+{0x1.0000000800000p-42, -0x1.0000000000000p-114, -0x1.000003fffc002p-41, 0x1.0000000000000p-146, -0x1.000007f7f8004p-42, -0x1.fffffffe00000p-115},
+{-0x1.0000000800000p-42, 0x1.0000000000000p-114, 0x1.000003fffc002p-41, -0x1.0000000000000p-146, 0x1.000007f7f8004p-42, 0x1.fffffffe00000p-115},
+{-0x1.0000000800000p-42, 0x1.0000000000000p-114, -0x1.000003fffc002p-41, 0x1.0000000000000p-146, -0x1.80000403fc002p-41, 0x1.0000000100000p-114},
+{0x1.0000000000000p+46, 0x1.ffc001ffffe00p-9, 0x1.000003fff8000p-19, 0x1.fffc000fc0000p-90, 0x1.0000000000000p+46, 0x1.000001007fef0p-8},
+{0x1.0000000000000p+46, 0x1.ffc001ffffe00p-9, -0x1.000003fff8000p-19, -0x1.fffc000fc0000p-90, 0x1.0000000000000p+46, 0x1.ff8001feffe20p-9},
+{-0x1.0000000000000p+46, -0x1.ffc001ffffe00p-9, 0x1.000003fff8000p-19, 0x1.fffc000fc0000p-90, -0x1.0000000000000p+46, -0x1.ff8001feffe20p-9},
+{-0x1.0000000000000p+46, -0x1.ffc001ffffe00p-9, -0x1.000003fff8000p-19, -0x1.fffc000fc0000p-90, -0x1.0000000000000p+46, -0x1.000001007fef0p-8},
+{0x1.0000000000003p+33, 0x1.fc00001fff800p-31, 0x1.0000000000020p+40, -0x1.fc01ffe002000p-24, 0x1.0200000000020p+40, 0x1.781fd80080f80p-18},
+{0x1.0000000000003p+33, 0x1.fc00001fff800p-31, -0x1.0000000000020p+40, 0x1.fc01ffe002000p-24, -0x1.fc00000000040p+39, 0x1.87ffe7ff81080p-18},
+{-0x1.0000000000003p+33, -0x1.fc00001fff800p-31, 0x1.0000000000020p+40, -0x1.fc01ffe002000p-24, 0x1.fc00000000040p+39, -0x1.87ffe7ff81080p-18},
+{-0x1.0000000000003p+33, -0x1.fc00001fff800p-31, -0x1.0000000000020p+40, 0x1.fc01ffe002000p-24, -0x1.0200000000020p+40, -0x1.781fd80080f80p-18},
+{0x1.0000000000000p-42, 0x1.fffff00001ffep-96, 0x1.0000000000000p-9, 0x1.ff00000ffff80p-69, 0x1.0000000080000p-9, 0x1.ff00004ffff80p-69},
+{0x1.0000000000000p-42, 0x1.fffff00001ffep-96, -0x1.0000000000000p-9, -0x1.ff00000ffff80p-69, -0x1.ffffffff00000p-10, -0x1.feffffcffff80p-69},
+{-0x1.0000000000000p-42, -0x1.fffff00001ffep-96, 0x1.0000000000000p-9, 0x1.ff00000ffff80p-69, 0x1.ffffffff00000p-10, 0x1.feffffcffff80p-69},
+{-0x1.0000000000000p-42, -0x1.fffff00001ffep-96, -0x1.0000000000000p-9, -0x1.ff00000ffff80p-69, -0x1.0000000080000p-9, -0x1.ff00004ffff80p-69},
+{0x1.0000000000000p-46, 0x1.ffffffffffc00p-109, 0x1.0000200000000p+11, -0x1.ffc0000080000p-61, 0x1.0000200000000p+11, 0x1.fff800fffffe0p-47},
+{0x1.0000000000000p-46, 0x1.ffffffffffc00p-109, -0x1.0000200000000p+11, 0x1.ffc0000080000p-61, -0x1.0000200000000p+11, 0x1.0003ff8000010p-46},
+{-0x1.0000000000000p-46, -0x1.ffffffffffc00p-109, 0x1.0000200000000p+11, -0x1.ffc0000080000p-61, 0x1.0000200000000p+11, -0x1.0003ff8000010p-46},
+{-0x1.0000000000000p-46, -0x1.ffffffffffc00p-109, -0x1.0000200000000p+11, 0x1.ffc0000080000p-61, -0x1.0000200000000p+11, -0x1.fff800fffffe0p-47},
+{0x1.0000000000800p-4, -0x1.fffc000000010p-61, 0x1.0000000000008p-2, -0x1.ffe03fffff010p-59, 0x1.4000000000208p-2, -0x1.3fef9fffff808p-58},
+{0x1.0000000000800p-4, -0x1.fffc000000010p-61, -0x1.0000000000008p-2, 0x1.ffe03fffff010p-59, -0x1.7fffffffffc10p-3, 0x1.7fe13fffff010p-59},
+{-0x1.0000000000800p-4, 0x1.fffc000000010p-61, 0x1.0000000000008p-2, -0x1.ffe03fffff010p-59, 0x1.7fffffffffc10p-3, -0x1.7fe13fffff010p-59},
+{-0x1.0000000000800p-4, 0x1.fffc000000010p-61, -0x1.0000000000008p-2, 0x1.ffe03fffff010p-59, -0x1.4000000000208p-2, 0x1.3fef9fffff808p-58},
+{0x1.0000000000000p-39, 0x1.fffef0ffff000p-102, 0x1.0000100000000p-7, -0x1.fff8000000800p-71, 0x1.0000100100000p-7, -0x1.fff7fffc00800p-71},
+{0x1.0000000000000p-39, 0x1.fffef0ffff000p-102, -0x1.0000100000000p-7, 0x1.fff8000000800p-71, -0x1.00000fff00000p-7, 0x1.fff8000400800p-71},
+{-0x1.0000000000000p-39, -0x1.fffef0ffff000p-102, 0x1.0000100000000p-7, -0x1.fff8000000800p-71, 0x1.00000fff00000p-7, -0x1.fff8000400800p-71},
+{-0x1.0000000000000p-39, -0x1.fffef0ffff000p-102, -0x1.0000100000000p-7, 0x1.fff8000000800p-71, -0x1.0000100100000p-7, 0x1.fff7fffc00800p-71},
+{0x1.07c00007ffff0p-15, 0x1.fffc00f800000p-91, 0x1.0000007ffffe0p-11, 0x1.f000000000000p-82, 0x1.107c00807ffdfp-11, 0x1.f0fffe0080000p-82},
+{0x1.07c00007ffff0p-15, 0x1.fffc00f800000p-91, -0x1.0000007ffffe0p-11, -0x1.f000000000000p-82, -0x1.df0800fefffc2p-12, -0x1.ef0001ff80000p-82},
+{-0x1.07c00007ffff0p-15, -0x1.fffc00f800000p-91, 0x1.0000007ffffe0p-11, 0x1.f000000000000p-82, 0x1.df0800fefffc2p-12, 0x1.ef0001ff80000p-82},
+{-0x1.07c00007ffff0p-15, -0x1.fffc00f800000p-91, -0x1.0000007ffffe0p-11, -0x1.f000000000000p-82, -0x1.107c00807ffdfp-11, -0x1.f0fffe0080000p-82},
+{0x1.0000000000000p+37, 0x1.ff800fffff800p-19, 0x1.0000000000000p-32, 0x1.fffc0000ffff8p-88, 0x1.0000000000000p+37, 0x1.ff880fffff800p-19},
+{0x1.0000000000000p+37, 0x1.ff800fffff800p-19, -0x1.0000000000000p-32, -0x1.fffc0000ffff8p-88, 0x1.0000000000000p+37, 0x1.ff780fffff800p-19},
+{-0x1.0000000000000p+37, -0x1.ff800fffff800p-19, 0x1.0000000000000p-32, 0x1.fffc0000ffff8p-88, -0x1.0000000000000p+37, -0x1.ff780fffff800p-19},
+{-0x1.0000000000000p+37, -0x1.ff800fffff800p-19, -0x1.0000000000000p-32, -0x1.fffc0000ffff8p-88, -0x1.0000000000000p+37, -0x1.ff880fffff800p-19},
+{0x1.0000000008000p+44, -0x1.ffff807ffe002p-10, 0x1.0000000800000p-6, -0x1.ffffff8000008p-62, 0x1.0000000008004p+44, -0x1.ffff7ffffe004p-10},
+{0x1.0000000008000p+44, -0x1.ffff807ffe002p-10, -0x1.0000000800000p-6, 0x1.ffffff8000008p-62, 0x1.0000000007ffcp+44, -0x1.ffff80fffe000p-10},
+{-0x1.0000000008000p+44, 0x1.ffff807ffe002p-10, 0x1.0000000800000p-6, -0x1.ffffff8000008p-62, -0x1.0000000007ffcp+44, 0x1.ffff80fffe000p-10},
+{-0x1.0000000008000p+44, 0x1.ffff807ffe002p-10, -0x1.0000000800000p-6, 0x1.ffffff8000008p-62, -0x1.0000000008004p+44, 0x1.ffff7ffffe004p-10},
+{0x1.0000000000020p-53, -0x1.0000000000000p-136, 0x1.0000000000000p+33, 0x1.fffff000003c0p-26, 0x1.0000000000000p+33, 0x1.fffff020003c0p-26},
+{0x1.0000000000020p-53, -0x1.0000000000000p-136, -0x1.0000000000000p+33, -0x1.fffff000003c0p-26, -0x1.0000000000000p+33, -0x1.ffffefe0003c0p-26},
+{-0x1.0000000000020p-53, 0x1.0000000000000p-136, 0x1.0000000000000p+33, 0x1.fffff000003c0p-26, 0x1.0000000000000p+33, 0x1.ffffefe0003c0p-26},
+{-0x1.0000000000020p-53, 0x1.0000000000000p-136, -0x1.0000000000000p+33, -0x1.fffff000003c0p-26, -0x1.0000000000000p+33, -0x1.fffff020003c0p-26},
+{0x1.0000001ffff80p-7, 0x1.fffffdfffff8ep-61, 0x1.0000000200000p-27, -0x1.0000000000000p-96, 0x1.0000101ffff82p-7, 0x1.fffffdffdff8ep-61},
+{0x1.0000001ffff80p-7, 0x1.fffffdfffff8ep-61, -0x1.0000000200000p-27, 0x1.0000000000000p-96, 0x1.ffffe03fffefdp-8, -0x1.ffe0072000000p-85},
+{-0x1.0000001ffff80p-7, -0x1.fffffdfffff8ep-61, 0x1.0000000200000p-27, -0x1.0000000000000p-96, -0x1.ffffe03fffefdp-8, 0x1.ffe0072000000p-85},
+{-0x1.0000001ffff80p-7, -0x1.fffffdfffff8ep-61, -0x1.0000000200000p-27, 0x1.0000000000000p-96, -0x1.0000101ffff82p-7, -0x1.fffffdffdff8ep-61},
+{0x1.01ffffff80400p-38, -0x1.c7ffffc000100p-96, 0x1.0000000000000p-47, 0x1.8fff01fffff00p-107, 0x1.027fffff80400p-38, -0x1.c7cdffdfc0100p-96},
+{0x1.01ffffff80400p-38, -0x1.c7ffffc000100p-96, -0x1.0000000000000p-47, -0x1.8fff01fffff00p-107, 0x1.017fffff80400p-38, -0x1.c831ffa040100p-96},
+{-0x1.01ffffff80400p-38, 0x1.c7ffffc000100p-96, 0x1.0000000000000p-47, 0x1.8fff01fffff00p-107, -0x1.017fffff80400p-38, 0x1.c831ffa040100p-96},
+{-0x1.01ffffff80400p-38, 0x1.c7ffffc000100p-96, -0x1.0000000000000p-47, -0x1.8fff01fffff00p-107, -0x1.027fffff80400p-38, 0x1.c7cdffdfc0100p-96},
+{0x1.0000000000008p-27, -0x1.ffffc00800000p-100, 0x1.00003ffe00002p+16, -0x1.ffffffc180080p-44, 0x1.00003ffe00202p+16, -0x1.ffffffc080080p-44},
+{0x1.0000000000008p-27, -0x1.ffffc00800000p-100, -0x1.00003ffe00002p+16, 0x1.ffffffc180080p-44, -0x1.00003ffdffe02p+16, 0x1.ffffffc280080p-44},
+{-0x1.0000000000008p-27, 0x1.ffffc00800000p-100, 0x1.00003ffe00002p+16, -0x1.ffffffc180080p-44, 0x1.00003ffdffe02p+16, -0x1.ffffffc280080p-44},
+{-0x1.0000000000008p-27, 0x1.ffffc00800000p-100, -0x1.00003ffe00002p+16, 0x1.ffffffc180080p-44, -0x1.00003ffe00202p+16, 0x1.ffffffc080080p-44},
+{0x1.000000ffffff8p+16, 0x1.ffffffc000000p-41, 0x1.0000000000000p+8, 0x1.ffffffe000000p-50, 0x1.010000ffffff8p+16, 0x1.007fffdff8000p-40},
+{0x1.000000ffffff8p+16, 0x1.ffffffc000000p-41, -0x1.0000000000000p+8, -0x1.ffffffe000000p-50, 0x1.fe0001ffffff0p+15, 0x1.feffffc010000p-41},
+{-0x1.000000ffffff8p+16, -0x1.ffffffc000000p-41, 0x1.0000000000000p+8, 0x1.ffffffe000000p-50, -0x1.fe0001ffffff0p+15, -0x1.feffffc010000p-41},
+{-0x1.000000ffffff8p+16, -0x1.ffffffc000000p-41, -0x1.0000000000000p+8, -0x1.ffffffe000000p-50, -0x1.010000ffffff8p+16, -0x1.007fffdff8000p-40},
+{0x1.0000000020000p-39, -0x1.0000000000000p-144, 0x1.0000000000400p-40, -0x1.ff1ffffff4000p-107, 0x1.8000000020200p-39, -0x1.ff20000000000p-107},
+{0x1.0000000020000p-39, -0x1.0000000000000p-144, -0x1.0000000000400p-40, 0x1.ff1ffffff4000p-107, 0x1.000000003fc00p-40, 0x1.ff1fffffec000p-107},
+{-0x1.0000000020000p-39, 0x1.0000000000000p-144, 0x1.0000000000400p-40, -0x1.ff1ffffff4000p-107, -0x1.000000003fc00p-40, -0x1.ff1fffffec000p-107},
+{-0x1.0000000020000p-39, 0x1.0000000000000p-144, -0x1.0000000000400p-40, 0x1.ff1ffffff4000p-107, -0x1.8000000020200p-39, 0x1.ff20000000000p-107},
+{0x1.0000ff8020000p-18, -0x1.fffffa0000000p-80, 0x1.0000000001ff0p+30, 0x1.f700000ffe000p-36, 0x1.0000000002000p+30, 0x1.7d402003ff800p-34},
+{0x1.0000ff8020000p-18, -0x1.fffffa0000000p-80, -0x1.0000000001ff0p+30, -0x1.f700000ffe000p-36, -0x1.0000000001fe0p+30, 0x1.03803ff801000p-35},
+{-0x1.0000ff8020000p-18, 0x1.fffffa0000000p-80, 0x1.0000000001ff0p+30, 0x1.f700000ffe000p-36, 0x1.0000000001fe0p+30, -0x1.03803ff801000p-35},
+{-0x1.0000ff8020000p-18, 0x1.fffffa0000000p-80, -0x1.0000000001ff0p+30, -0x1.f700000ffe000p-36, -0x1.0000000002000p+30, -0x1.7d402003ff800p-34},
+{0x1.0000020000000p+8, -0x1.0000000000000p-56, 0x1.003e00001f800p-14, 0x1.ffde000001e00p-76, 0x1.00000600f8000p+8, 0x1.f400007ff7800p-50},
+{0x1.0000020000000p+8, -0x1.0000000000000p-56, -0x1.003e00001f800p-14, -0x1.ffde000001e00p-76, 0x1.fffffbfe10000p+7, -0x1.fc00007ff7800p-50},
+{-0x1.0000020000000p+8, 0x1.0000000000000p-56, 0x1.003e00001f800p-14, 0x1.ffde000001e00p-76, -0x1.fffffbfe10000p+7, 0x1.fc00007ff7800p-50},
+{-0x1.0000020000000p+8, 0x1.0000000000000p-56, -0x1.003e00001f800p-14, -0x1.ffde000001e00p-76, -0x1.00000600f8000p+8, -0x1.f400007ff7800p-50},
+{0x1.0007e3ffe0000p-24, 0x1.fe0ffffffe000p-88, 0x1.0000000000000p+0, 0x1.fffffe07fff00p-61, 0x1.0000010007e40p+0, -0x1.000000dc1f080p-60},
+{0x1.0007e3ffe0000p-24, 0x1.fe0ffffffe000p-88, -0x1.0000000000000p+0, -0x1.fffffe07fff00p-61, -0x1.fffffdfff0380p-1, -0x1.7fffff720f7c0p-59},
+{-0x1.0007e3ffe0000p-24, -0x1.fe0ffffffe000p-88, 0x1.0000000000000p+0, 0x1.fffffe07fff00p-61, 0x1.fffffdfff0380p-1, 0x1.7fffff720f7c0p-59},
+{-0x1.0007e3ffe0000p-24, -0x1.fe0ffffffe000p-88, -0x1.0000000000000p+0, -0x1.fffffe07fff00p-61, -0x1.0000010007e40p+0, 0x1.000000dc1f080p-60},
+{0x1.00000000fe000p+38, 0x1.ff00004000000p-29, 0x1.000003fffff80p-32, 0x1.fff8400000000p-92, 0x1.00000000fe000p+38, 0x1.0f80006000000p-28},
+{0x1.00000000fe000p+38, 0x1.ff00004000000p-29, -0x1.000003fffff80p-32, -0x1.fff8400000000p-92, 0x1.00000000fe000p+38, 0x1.deffffc000000p-29},
+{-0x1.00000000fe000p+38, -0x1.ff00004000000p-29, 0x1.000003fffff80p-32, 0x1.fff8400000000p-92, -0x1.00000000fe000p+38, -0x1.deffffc000000p-29},
+{-0x1.00000000fe000p+38, -0x1.ff00004000000p-29, -0x1.000003fffff80p-32, -0x1.fff8400000000p-92, -0x1.00000000fe000p+38, -0x1.0f80006000000p-28},
+{0x1.0000800000000p-9, -0x1.0000000000000p-65, 0x1.0000000000000p-51, 0x1.fffffffc1fc00p-114, 0x1.0000800000400p-9, -0x1.fffffffffffe0p-66},
+{0x1.0000800000000p-9, -0x1.0000000000000p-65, -0x1.0000000000000p-51, -0x1.fffffffc1fc00p-114, 0x1.00007fffffc00p-9, -0x1.0000000000010p-65},
+{-0x1.0000800000000p-9, 0x1.0000000000000p-65, 0x1.0000000000000p-51, 0x1.fffffffc1fc00p-114, -0x1.00007fffffc00p-9, 0x1.0000000000010p-65},
+{-0x1.0000800000000p-9, 0x1.0000000000000p-65, -0x1.0000000000000p-51, -0x1.fffffffc1fc00p-114, -0x1.0000800000400p-9, 0x1.fffffffffffe0p-66},
+{0x1.0000000000000p-40, 0x1.ff000ff3ffe00p-94, 0x1.0000000000000p-18, 0x1.fe0003fffc000p-77, 0x1.0000040000000p-18, 0x1.fe01038003f80p-77},
+{0x1.0000000000000p-40, 0x1.ff000ff3ffe00p-94, -0x1.0000000000000p-18, -0x1.fe0003fffc000p-77, -0x1.fffff80000000p-19, -0x1.fdff047ff4060p-77},
+{-0x1.0000000000000p-40, -0x1.ff000ff3ffe00p-94, 0x1.0000000000000p-18, 0x1.fe0003fffc000p-77, 0x1.fffff80000000p-19, 0x1.fdff047ff4060p-77},
+{-0x1.0000000000000p-40, -0x1.ff000ff3ffe00p-94, -0x1.0000000000000p-18, -0x1.fe0003fffc000p-77, -0x1.0000040000000p-18, -0x1.fe01038003f80p-77},
+{0x1.000000e000010p-12, -0x1.ffffffc020000p-82, 0x1.00000001f0000p-4, 0x1.8000000000000p-108, 0x1.01000002d0000p-4, 0x1.fffff00000050p-61},
+{0x1.000000e000010p-12, -0x1.ffffffc020000p-82, -0x1.00000001f0000p-4, -0x1.8000000000000p-108, -0x1.fe00000220000p-5, 0x1.ffffefffffff0p-61},
+{-0x1.000000e000010p-12, 0x1.ffffffc020000p-82, 0x1.00000001f0000p-4, 0x1.8000000000000p-108, 0x1.fe00000220000p-5, -0x1.ffffefffffff0p-61},
+{-0x1.000000e000010p-12, 0x1.ffffffc020000p-82, -0x1.00000001f0000p-4, -0x1.8000000000000p-108, -0x1.01000002d0000p-4, -0x1.fffff00000050p-61},
+{0x1.000003ff00000p+23, 0x1.8000000000000p-54, 0x1.0001ffffe0000p-39, 0x1.f800000100000p-112, 0x1.000003ff00000p+23, 0x1.0004ffffe0000p-39},
+{0x1.000003ff00000p+23, 0x1.8000000000000p-54, -0x1.0001ffffe0000p-39, -0x1.f800000100000p-112, 0x1.000003ff00000p+23, -0x1.fffdffffc0000p-40},
+{-0x1.000003ff00000p+23, -0x1.8000000000000p-54, 0x1.0001ffffe0000p-39, 0x1.f800000100000p-112, -0x1.000003ff00000p+23, 0x1.fffdffffc0000p-40},
+{-0x1.000003ff00000p+23, -0x1.8000000000000p-54, -0x1.0001ffffe0000p-39, -0x1.f800000100000p-112, -0x1.000003ff00000p+23, -0x1.0004ffffe0000p-39},
+{0x1.0000000000200p+14, -0x1.ffffffffffc08p-42, 0x1.0000000000000p-48, 0x1.ffffffffffffep-102, 0x1.0000000000200p+14, -0x1.fbffffffffc08p-42},
+{0x1.0000000000200p+14, -0x1.ffffffffffc08p-42, -0x1.0000000000000p-48, -0x1.ffffffffffffep-102, 0x1.0000000000200p+14, -0x1.01ffffffffe04p-41},
+{-0x1.0000000000200p+14, 0x1.ffffffffffc08p-42, 0x1.0000000000000p-48, 0x1.ffffffffffffep-102, -0x1.0000000000200p+14, 0x1.01ffffffffe04p-41},
+{-0x1.0000000000200p+14, 0x1.ffffffffffc08p-42, -0x1.0000000000000p-48, -0x1.ffffffffffffep-102, -0x1.0000000000200p+14, 0x1.fbffffffffc08p-42},
+{0x1.0000000040000p+37, -0x1.fffff80002000p-29, 0x1.0000000000000p-21, 0x1.ffc01ffff3c00p-84, 0x1.0000000040000p+37, 0x1.fc00000ffffc0p-22},
+{0x1.0000000040000p+37, -0x1.fffff80002000p-29, -0x1.0000000000000p-21, -0x1.ffc01ffff3c00p-84, 0x1.0000000040000p+37, -0x1.01fffff800020p-21},
+{-0x1.0000000040000p+37, 0x1.fffff80002000p-29, 0x1.0000000000000p-21, 0x1.ffc01ffff3c00p-84, -0x1.0000000040000p+37, 0x1.01fffff800020p-21},
+{-0x1.0000000040000p+37, 0x1.fffff80002000p-29, -0x1.0000000000000p-21, -0x1.ffc01ffff3c00p-84, -0x1.0000000040000p+37, -0x1.fc00000ffffc0p-22},
+{0x1.0000800000000p+25, -0x1.0000000000000p-80, 0x1.0000003800001p-52, 0x1.fffffe000003ep-106, 0x1.0000800000000p+25, 0x1.0000003000000p-52},
+{0x1.0000800000000p+25, -0x1.0000000000000p-80, -0x1.0000003800001p-52, -0x1.fffffe000003ep-106, 0x1.0000800000000p+25, -0x1.0000005000000p-52},
+{-0x1.0000800000000p+25, 0x1.0000000000000p-80, 0x1.0000003800001p-52, 0x1.fffffe000003ep-106, -0x1.0000800000000p+25, 0x1.0000005000000p-52},
+{-0x1.0000800000000p+25, 0x1.0000000000000p-80, -0x1.0000003800001p-52, -0x1.fffffe000003ep-106, -0x1.0000800000000p+25, -0x1.0000003000000p-52},
+{0x1.0f00000020000p-4, -0x1.fffe000000100p-58, 0x1.0000000400000p-7, -0x1.ffffffc004000p-74, 0x1.2f000000a0000p-4, -0x1.ffffffffffd00p-58},
+{0x1.0f00000020000p-4, -0x1.fffe000000100p-58, -0x1.0000000400000p-7, 0x1.ffffffc004000p-74, 0x1.ddffffff3ffffp-5, 0x1.ffffffd800000p-73},
+{-0x1.0f00000020000p-4, 0x1.fffe000000100p-58, 0x1.0000000400000p-7, -0x1.ffffffc004000p-74, -0x1.ddffffff3ffffp-5, -0x1.ffffffd800000p-73},
+{-0x1.0f00000020000p-4, 0x1.fffe000000100p-58, -0x1.0000000400000p-7, 0x1.ffffffc004000p-74, -0x1.2f000000a0000p-4, 0x1.ffffffffffd00p-58},
+{0x1.003fe00020000p-13, -0x1.ffffffffe8000p-81, 0x1.0000000000400p-48, -0x1.ffff800007ffcp-103, 0x1.003fe00040000p-13, -0x1.ff8007ffe8000p-81},
+{0x1.003fe00020000p-13, -0x1.ffffffffe8000p-81, -0x1.0000000000400p-48, 0x1.ffff800007ffcp-103, 0x1.003fe00000000p-13, -0x1.003ffbfff4000p-80},
+{-0x1.003fe00020000p-13, 0x1.ffffffffe8000p-81, 0x1.0000000000400p-48, -0x1.ffff800007ffcp-103, -0x1.003fe00000000p-13, 0x1.003ffbfff4000p-80},
+{-0x1.003fe00020000p-13, 0x1.ffffffffe8000p-81, -0x1.0000000000400p-48, 0x1.ffff800007ffcp-103, -0x1.003fe00040000p-13, 0x1.ff8007ffe8000p-81},
+{0x1.ffff00fffffc4p-6, -0x1.8080000000000p-88, 0x1.0000020000000p-1, -0x1.0000000000000p-77, 0x1.0ffffa07ffffep-1, 0x1.ffffeffcff000p-57},
+{0x1.ffff00fffffc4p-6, -0x1.8080000000000p-88, -0x1.0000020000000p-1, 0x1.0000000000000p-77, -0x1.e00013f000004p-2, 0x1.000007fe7f800p-56},
+{-0x1.ffff00fffffc4p-6, 0x1.8080000000000p-88, 0x1.0000020000000p-1, -0x1.0000000000000p-77, 0x1.e00013f000004p-2, -0x1.000007fe7f800p-56},
+{-0x1.ffff00fffffc4p-6, 0x1.8080000000000p-88, -0x1.0000020000000p-1, 0x1.0000000000000p-77, -0x1.0ffffa07ffffep-1, -0x1.ffffeffcff000p-57},
+{0x1.0000000000040p+36, -0x1.8000000800000p-39, 0x1.0000000002000p+30, -0x1.0000000000000p-74, 0x1.04000000000c0p+36, -0x1.8000000800000p-39},
+{0x1.0000000000040p+36, -0x1.8000000800000p-39, -0x1.0000000002000p+30, 0x1.0000000000000p-74, 0x1.f7fffffffff80p+35, -0x1.8000000800000p-39},
+{-0x1.0000000000040p+36, 0x1.8000000800000p-39, 0x1.0000000002000p+30, -0x1.0000000000000p-74, -0x1.f7fffffffff80p+35, 0x1.8000000800000p-39},
+{-0x1.0000000000040p+36, 0x1.8000000800000p-39, -0x1.0000000002000p+30, 0x1.0000000000000p-74, -0x1.04000000000c0p+36, 0x1.8000000800000p-39},
+{0x1.0000000800000p-29, -0x1.ffffc02000000p-107, 0x1.7fffe00800000p-48, -0x1.0000000000000p-153, 0x1.00003007fc010p-29, -0x1.ffffc02000000p-107},
+{0x1.0000000800000p-29, -0x1.ffffc02000000p-107, -0x1.7fffe00800000p-48, 0x1.0000000000000p-153, 0x1.ffffa01007fe0p-30, -0x1.ffffc02000000p-107},
+{-0x1.0000000800000p-29, 0x1.ffffc02000000p-107, 0x1.7fffe00800000p-48, -0x1.0000000000000p-153, -0x1.ffffa01007fe0p-30, 0x1.ffffc02000000p-107},
+{-0x1.0000000800000p-29, 0x1.ffffc02000000p-107, -0x1.7fffe00800000p-48, 0x1.0000000000000p-153, -0x1.00003007fc010p-29, 0x1.ffffc02000000p-107},
+{0x1.0000400000000p+11, -0x1.0000000000000p-80, 0x1.4000000000000p+51, -0x1.ffffffff00020p-7, 0x1.4000000001000p+51, -0x1.fffffffe00040p-8},
+{0x1.0000400000000p+11, -0x1.0000000000000p-80, -0x1.4000000000000p+51, 0x1.ffffffff00020p-7, -0x1.3fffffffff000p+51, 0x1.7fffffff80010p-6},
+{-0x1.0000400000000p+11, 0x1.0000000000000p-80, 0x1.4000000000000p+51, -0x1.ffffffff00020p-7, 0x1.3fffffffff000p+51, -0x1.7fffffff80010p-6},
+{-0x1.0000400000000p+11, 0x1.0000000000000p-80, -0x1.4000000000000p+51, 0x1.ffffffff00020p-7, -0x1.4000000001000p+51, 0x1.fffffffe00040p-8},
+{0x1.0000000000000p+42, 0x1.03eff7ff3fff0p-15, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, 0x1.0000000000200p+42, 0x1.0befe7ff40070p-15},
+{0x1.0000000000000p+42, 0x1.03eff7ff3fff0p-15, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, 0x1.ffffffffffc00p+41, 0x1.f7e00ffe7fee0p-16},
+{-0x1.0000000000000p+42, -0x1.03eff7ff3fff0p-15, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, -0x1.ffffffffffc00p+41, -0x1.f7e00ffe7fee0p-16},
+{-0x1.0000000000000p+42, -0x1.03eff7ff3fff0p-15, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, -0x1.0000000000200p+42, -0x1.0befe7ff40070p-15},
+{0x1.03ffffffffffep-18, 0x1.8000000000000p-122, 0x1.0000040000000p+49, -0x1.0000000000000p-56, 0x1.0000040000000p+49, 0x1.03fffffffc000p-18},
+{0x1.03ffffffffffep-18, 0x1.8000000000000p-122, -0x1.0000040000000p+49, 0x1.0000000000000p-56, -0x1.0000040000000p+49, 0x1.0400000004000p-18},
+{-0x1.03ffffffffffep-18, -0x1.8000000000000p-122, 0x1.0000040000000p+49, -0x1.0000000000000p-56, 0x1.0000040000000p+49, -0x1.0400000004000p-18},
+{-0x1.03ffffffffffep-18, -0x1.8000000000000p-122, -0x1.0000040000000p+49, 0x1.0000000000000p-56, -0x1.0000040000000p+49, -0x1.03fffffffc000p-18},
+{0x1.0007ffffcfffcp+9, 0x1.ff01fffe00000p-65, 0x1.01fff08000000p-5, -0x1.fffffe0000020p-59, 0x1.000c07ff91ffcp+9, -0x1.f803f60008000p-59},
+{0x1.0007ffffcfffcp+9, 0x1.ff01fffe00000p-65, -0x1.01fff08000000p-5, 0x1.fffffe0000020p-59, 0x1.0003f8000dffcp+9, 0x1.03fe02fffc000p-58},
+{-0x1.0007ffffcfffcp+9, -0x1.ff01fffe00000p-65, 0x1.01fff08000000p-5, -0x1.fffffe0000020p-59, -0x1.0003f8000dffcp+9, -0x1.03fe02fffc000p-58},
+{-0x1.0007ffffcfffcp+9, -0x1.ff01fffe00000p-65, -0x1.01fff08000000p-5, 0x1.fffffe0000020p-59, -0x1.000c07ff91ffcp+9, 0x1.f803f60008000p-59},
+{0x1.00000000007fep-4, 0x1.ff00003ffff00p-65, 0x1.004000e000008p+5, -0x1.ffffe02000000p-73, 0x1.00c000e00000cp+5, -0x1.ff017fffd0100p-56},
+{0x1.00000000007fep-4, 0x1.ff00003ffff00p-65, -0x1.004000e000008p+5, 0x1.ffffe02000000p-73, -0x1.ff8001c000008p+4, -0x1.feff7fffeff00p-56},
+{-0x1.00000000007fep-4, -0x1.ff00003ffff00p-65, 0x1.004000e000008p+5, -0x1.ffffe02000000p-73, 0x1.ff8001c000008p+4, 0x1.feff7fffeff00p-56},
+{-0x1.00000000007fep-4, -0x1.ff00003ffff00p-65, -0x1.004000e000008p+5, 0x1.ffffe02000000p-73, -0x1.00c000e00000cp+5, 0x1.ff017fffd0100p-56},
+{0x1.00000003ff000p-41, 0x1.ffff000000000p-130, 0x1.0000fffff8000p-20, 0x1.f003ffe0003e0p-78, 0x1.000107fff8002p-20, 0x1.d003ffe0003e0p-78},
+{0x1.00000003ff000p-41, 0x1.ffff000000000p-130, -0x1.0000fffff8000p-20, -0x1.f003ffe0003e0p-78, -0x1.0000f7fff7ffep-20, -0x1.0801fff0001f0p-77},
+{-0x1.00000003ff000p-41, -0x1.ffff000000000p-130, 0x1.0000fffff8000p-20, 0x1.f003ffe0003e0p-78, 0x1.0000f7fff7ffep-20, 0x1.0801fff0001f0p-77},
+{-0x1.00000003ff000p-41, -0x1.ffff000000000p-130, -0x1.0000fffff8000p-20, -0x1.f003ffe0003e0p-78, -0x1.000107fff8002p-20, -0x1.d003ffe0003e0p-78},
+{0x1.0000000000000p-41, 0x1.ffe001c0003c0p-100, 0x1.01fffffe00000p+41, 0x1.ffffffffffc00p-17, 0x1.01fffffe00000p+41, 0x1.0000007fffe00p-16},
+{0x1.0000000000000p-41, 0x1.ffe001c0003c0p-100, -0x1.01fffffe00000p+41, -0x1.ffffffffffc00p-17, -0x1.01fffffe00000p+41, -0x1.fffffeffffc00p-17},
+{-0x1.0000000000000p-41, -0x1.ffe001c0003c0p-100, 0x1.01fffffe00000p+41, 0x1.ffffffffffc00p-17, 0x1.01fffffe00000p+41, 0x1.fffffeffffc00p-17},
+{-0x1.0000000000000p-41, -0x1.ffe001c0003c0p-100, -0x1.01fffffe00000p+41, -0x1.ffffffffffc00p-17, -0x1.01fffffe00000p+41, -0x1.0000007fffe00p-16},
+{0x1.00003ff808000p+36, -0x1.ffe0000800000p-25, 0x1.000001ffff000p+41, 0x1.ff80000000000p-33, 0x1.080003ffbf400p+41, -0x1.fde0800800000p-25},
+{0x1.00003ff808000p+36, -0x1.ffe0000800000p-25, -0x1.000001ffff000p+41, -0x1.ff80000000000p-33, -0x1.f00000007d800p+40, -0x1.00efc00400000p-24},
+{-0x1.00003ff808000p+36, 0x1.ffe0000800000p-25, 0x1.000001ffff000p+41, 0x1.ff80000000000p-33, 0x1.f00000007d800p+40, 0x1.00efc00400000p-24},
+{-0x1.00003ff808000p+36, 0x1.ffe0000800000p-25, -0x1.000001ffff000p+41, -0x1.ff80000000000p-33, -0x1.080003ffbf400p+41, 0x1.fde0800800000p-25},
+{0x1.0000000000000p+6, 0x1.fc007f0ff0000p-56, 0x1.0000000007f80p-50, 0x1.ff0007f802000p-114, 0x1.0000000000000p+6, 0x1.07f001fc47b80p-50},
+{0x1.0000000000000p+6, 0x1.fc007f0ff0000p-56, -0x1.0000000007f80p-50, -0x1.ff0007f802000p-114, 0x1.0000000000000p+6, -0x1.f01ffc0790700p-51},
+{-0x1.0000000000000p+6, -0x1.fc007f0ff0000p-56, 0x1.0000000007f80p-50, 0x1.ff0007f802000p-114, -0x1.0000000000000p+6, 0x1.f01ffc0790700p-51},
+{-0x1.0000000000000p+6, -0x1.fc007f0ff0000p-56, -0x1.0000000007f80p-50, -0x1.ff0007f802000p-114, -0x1.0000000000000p+6, -0x1.07f001fc47b80p-50},
+{0x1.0020000000000p+12, -0x1.0000000000000p-65, 0x1.000001ffff802p-4, -0x1.ffffffc000040p-63, 0x1.0021000002000p+12, -0x1.ff811fffffe00p-46},
+{0x1.0020000000000p+12, -0x1.0000000000000p-65, -0x1.000001ffff802p-4, 0x1.ffffffc000040p-63, 0x1.001efffffe000p+12, 0x1.ff80dfffffe00p-46},
+{-0x1.0020000000000p+12, 0x1.0000000000000p-65, 0x1.000001ffff802p-4, -0x1.ffffffc000040p-63, -0x1.001efffffe000p+12, -0x1.ff80dfffffe00p-46},
+{-0x1.0020000000000p+12, 0x1.0000000000000p-65, -0x1.000001ffff802p-4, 0x1.ffffffc000040p-63, -0x1.0021000002000p+12, 0x1.ff811fffffe00p-46},
+{0x1.0000000000800p-45, -0x1.ffe0000400000p-107, 0x1.0000000000038p+25, 0x1.e100000000000p-49, 0x1.0000000000038p+25, 0x1.1e10000000000p-45},
+{0x1.0000000000800p-45, -0x1.ffe0000400000p-107, -0x1.0000000000038p+25, -0x1.e100000000000p-49, -0x1.0000000000038p+25, 0x1.c3e0000000000p-46},
+{-0x1.0000000000800p-45, 0x1.ffe0000400000p-107, 0x1.0000000000038p+25, 0x1.e100000000000p-49, 0x1.0000000000038p+25, -0x1.c3e0000000000p-46},
+{-0x1.0000000000800p-45, 0x1.ffe0000400000p-107, -0x1.0000000000038p+25, -0x1.e100000000000p-49, -0x1.0000000000038p+25, -0x1.1e10000000000p-45},
+{0x1.0000000000020p-31, -0x1.8007ffff80c04p-86, 0x1.0000000000000p+50, 0x1.ffffe00000c00p-13, 0x1.0000000000000p+50, 0x1.0000100000600p-12},
+{0x1.0000000000020p-31, -0x1.8007ffff80c04p-86, -0x1.0000000000000p+50, -0x1.ffffe00000c00p-13, -0x1.0000000000000p+50, -0x1.ffffa00000c00p-13},
+{-0x1.0000000000020p-31, 0x1.8007ffff80c04p-86, 0x1.0000000000000p+50, 0x1.ffffe00000c00p-13, 0x1.0000000000000p+50, 0x1.ffffa00000c00p-13},
+{-0x1.0000000000020p-31, 0x1.8007ffff80c04p-86, -0x1.0000000000000p+50, -0x1.ffffe00000c00p-13, -0x1.0000000000000p+50, -0x1.0000100000600p-12},
+{0x1.7fffffff80000p+1, 0x1.f000000000000p-76, 0x1.000007ffffffep-41, 0x1.ffffff8000000p-117, 0x1.7fffffff80400p+1, 0x1.0007bffc00000p-62},
+{0x1.7fffffff80000p+1, 0x1.f000000000000p-76, -0x1.000007ffffffep-41, -0x1.ffffff8000000p-117, 0x1.7fffffff7fc00p+1, -0x1.fff07ff800000p-63},
+{-0x1.7fffffff80000p+1, -0x1.f000000000000p-76, 0x1.000007ffffffep-41, 0x1.ffffff8000000p-117, -0x1.7fffffff7fc00p+1, 0x1.fff07ff800000p-63},
+{-0x1.7fffffff80000p+1, -0x1.f000000000000p-76, -0x1.000007ffffffep-41, -0x1.ffffff8000000p-117, -0x1.7fffffff80400p+1, -0x1.0007bffc00000p-62},
+{0x1.0000000010000p+45, -0x1.0000000000000p-41, 0x1.0000000000000p+5, 0x1.c000003ffc3fep-49, 0x1.0000000011000p+45, -0x1.fc80000000000p-42},
+{0x1.0000000010000p+45, -0x1.0000000000000p-41, -0x1.0000000000000p+5, -0x1.c000003ffc3fep-49, 0x1.000000000f000p+45, -0x1.01c0000000000p-41},
+{-0x1.0000000010000p+45, 0x1.0000000000000p-41, 0x1.0000000000000p+5, 0x1.c000003ffc3fep-49, -0x1.000000000f000p+45, 0x1.01c0000000000p-41},
+{-0x1.0000000010000p+45, 0x1.0000000000000p-41, -0x1.0000000000000p+5, -0x1.c000003ffc3fep-49, -0x1.0000000011000p+45, 0x1.fc80000000000p-42},
+{0x1.00000ffff0800p-14, -0x1.fff80000ffc20p-72, 0x1.0000000000002p-19, -0x1.0000000000000p-124, 0x1.08000ffff0800p-14, 0x1.0003ffff801f0p-71},
+{0x1.00000ffff0800p-14, -0x1.fff80000ffc20p-72, -0x1.0000000000002p-19, 0x1.0000000000000p-124, 0x1.f0001fffe1000p-15, -0x1.7ffe00003ff08p-70},
+{-0x1.00000ffff0800p-14, 0x1.fff80000ffc20p-72, 0x1.0000000000002p-19, -0x1.0000000000000p-124, -0x1.f0001fffe1000p-15, 0x1.7ffe00003ff08p-70},
+{-0x1.00000ffff0800p-14, 0x1.fff80000ffc20p-72, -0x1.0000000000002p-19, 0x1.0000000000000p-124, -0x1.08000ffff0800p-14, -0x1.0003ffff801f0p-71},
+{0x1.000ffffc00000p+49, 0x1.fffff00000000p-20, 0x1.0000000000040p+45, -0x1.0000000000000p-60, 0x1.100ffffc00004p+49, 0x1.fffff00000000p-20},
+{0x1.000ffffc00000p+49, 0x1.fffff00000000p-20, -0x1.0000000000040p+45, 0x1.0000000000000p-60, 0x1.e01ffff7ffff8p+48, 0x1.fffff00000000p-20},
+{-0x1.000ffffc00000p+49, -0x1.fffff00000000p-20, 0x1.0000000000040p+45, -0x1.0000000000000p-60, -0x1.e01ffff7ffff8p+48, -0x1.fffff00000000p-20},
+{-0x1.000ffffc00000p+49, -0x1.fffff00000000p-20, -0x1.0000000000040p+45, 0x1.0000000000000p-60, -0x1.100ffffc00004p+49, -0x1.fffff00000000p-20},
+{0x1.0004000000000p+14, -0x1.0000000000000p-54, 0x1.0000000200000p-4, -0x1.ffbffffff8020p-62, 0x1.0004400000008p+14, -0x1.01ffc00000000p-54},
+{0x1.0004000000000p+14, -0x1.0000000000000p-54, -0x1.0000000200000p-4, 0x1.ffbffffff8020p-62, 0x1.0003bfffffff8p+14, -0x1.fc00800000000p-55},
+{-0x1.0004000000000p+14, 0x1.0000000000000p-54, 0x1.0000000200000p-4, -0x1.ffbffffff8020p-62, -0x1.0003bfffffff8p+14, 0x1.fc00800000000p-55},
+{-0x1.0004000000000p+14, 0x1.0000000000000p-54, -0x1.0000000200000p-4, 0x1.ffbffffff8020p-62, -0x1.0004400000008p+14, 0x1.01ffc00000000p-54},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, 0x1.0000001fffffep+43, 0x0.0000000000000p+0, 0x1.00000020000fep+43, 0x1.0000000000000p-61},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, -0x1.0000001fffffep+43, 0x0.0000000000000p+0, -0x1.0000001fffefep+43, 0x1.0000000000000p-61},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, 0x1.0000001fffffep+43, 0x0.0000000000000p+0, 0x1.0000001fffefep+43, -0x1.0000000000000p-61},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, -0x1.0000001fffffep+43, 0x0.0000000000000p+0, -0x1.00000020000fep+43, -0x1.0000000000000p-61},
+{0x1.0000000000fffp-39, 0x1.fffff3e000000p-112, 0x1.001ffe0000000p-15, 0x1.fffffffffffc0p-74, 0x1.001fff0000000p-15, 0x1.03ffc00003fe0p-73},
+{0x1.0000000000fffp-39, 0x1.fffff3e000000p-112, -0x1.001ffe0000000p-15, -0x1.fffffffffffc0p-74, -0x1.001ffd0000000p-15, -0x1.f8007ffff7fc0p-74},
+{-0x1.0000000000fffp-39, -0x1.fffff3e000000p-112, 0x1.001ffe0000000p-15, 0x1.fffffffffffc0p-74, 0x1.001ffd0000000p-15, 0x1.f8007ffff7fc0p-74},
+{-0x1.0000000000fffp-39, -0x1.fffff3e000000p-112, -0x1.001ffe0000000p-15, -0x1.fffffffffffc0p-74, -0x1.001fff0000000p-15, -0x1.03ffc00003fe0p-73},
+{0x1.0000080000000p-27, -0x1.0000000000000p-132, 0x1.0000000080000p-48, -0x1.0000000000000p-103, 0x1.0000100000000p-27, 0x1.fffff7ffffffcp-82},
+{0x1.0000080000000p-27, -0x1.0000000000000p-132, -0x1.0000000080000p-48, 0x1.0000000000000p-103, 0x1.0000000000000p-27, -0x1.fffff80000004p-82},
+{-0x1.0000080000000p-27, 0x1.0000000000000p-132, 0x1.0000000080000p-48, -0x1.0000000000000p-103, -0x1.0000000000000p-27, 0x1.fffff80000004p-82},
+{-0x1.0000080000000p-27, 0x1.0000000000000p-132, -0x1.0000000080000p-48, 0x1.0000000000000p-103, -0x1.0000100000000p-27, -0x1.fffff7ffffffcp-82},
+{0x1.003ffffffffe0p-31, 0x1.ffffe03800000p-107, 0x1.0000000002000p-53, -0x1.0000000000000p-106, 0x1.004003fffffe0p-31, 0x1.ffffffff80e00p-93},
+{0x1.003ffffffffe0p-31, 0x1.ffffe03800000p-107, -0x1.0000000002000p-53, 0x1.0000000000000p-106, 0x1.003ffbfffffe0p-31, -0x1.fff000007f200p-93},
+{-0x1.003ffffffffe0p-31, -0x1.ffffe03800000p-107, 0x1.0000000002000p-53, -0x1.0000000000000p-106, -0x1.003ffbfffffe0p-31, 0x1.fff000007f200p-93},
+{-0x1.003ffffffffe0p-31, -0x1.ffffe03800000p-107, -0x1.0000000002000p-53, 0x1.0000000000000p-106, -0x1.004003fffffe0p-31, -0x1.ffffffff80e00p-93},
+{0x1.0000000000008p+23, -0x1.ff000007ffc00p-37, 0x1.0000000060000p+36, 0x1.ffffff8000000p-44, 0x1.0008000060000p+36, 0x1.ff813ffffdc00p-27},
+{0x1.0000000000008p+23, -0x1.ff000007ffc00p-37, -0x1.0000000060000p+36, -0x1.ffffff8000000p-44, -0x1.fff00000c0000p+35, 0x1.ff7f3ffffe400p-27},
+{-0x1.0000000000008p+23, 0x1.ff000007ffc00p-37, 0x1.0000000060000p+36, 0x1.ffffff8000000p-44, 0x1.fff00000c0000p+35, -0x1.ff7f3ffffe400p-27},
+{-0x1.0000000000008p+23, 0x1.ff000007ffc00p-37, -0x1.0000000060000p+36, -0x1.ffffff8000000p-44, -0x1.0008000060000p+36, -0x1.ff813ffffdc00p-27},
+{0x1.0000000000080p+25, -0x1.0000000000000p-80, 0x1.01ffffff80001p+15, -0x1.ff90000000000p-78, 0x1.00407fffffe80p+25, 0x1.fffffffffdc00p-38},
+{0x1.0000000000080p+25, -0x1.0000000000000p-80, -0x1.01ffffff80001p+15, 0x1.ff90000000000p-78, 0x1.ff7f000000500p+24, -0x1.fffffffffe400p-38},
+{-0x1.0000000000080p+25, 0x1.0000000000000p-80, 0x1.01ffffff80001p+15, -0x1.ff90000000000p-78, -0x1.ff7f000000500p+24, 0x1.fffffffffe400p-38},
+{-0x1.0000000000080p+25, 0x1.0000000000000p-80, -0x1.01ffffff80001p+15, 0x1.ff90000000000p-78, -0x1.00407fffffe80p+25, -0x1.fffffffffdc00p-38},
+{0x1.0000000000800p+7, -0x1.fffff80002000p-59, 0x1.0008000000000p+50, -0x1.0000000000000p-29, 0x1.0008000000200p+50, -0x1.f000000000000p-30},
+{0x1.0000000000800p+7, -0x1.fffff80002000p-59, -0x1.0008000000000p+50, 0x1.0000000000000p-29, -0x1.0007ffffffe00p+50, 0x1.0800000000000p-29},
+{-0x1.0000000000800p+7, 0x1.fffff80002000p-59, 0x1.0008000000000p+50, -0x1.0000000000000p-29, 0x1.0007ffffffe00p+50, -0x1.0800000000000p-29},
+{-0x1.0000000000800p+7, 0x1.fffff80002000p-59, -0x1.0008000000000p+50, 0x1.0000000000000p-29, -0x1.0008000000200p+50, 0x1.f000000000000p-30},
+{0x1.0000000000002p+26, -0x1.ffffffe200000p-48, 0x1.0003fffffffc0p+27, 0x1.ffffe00000400p-36, 0x1.8003fffffffc1p+27, 0x1.ffdfe00002000p-36},
+{0x1.0000000000002p+26, -0x1.ffffffe200000p-48, -0x1.0003fffffffc0p+27, -0x1.ffffe00000400p-36, -0x1.0007fffffff7ep+26, -0x1.000fefffff300p-35},
+{-0x1.0000000000002p+26, 0x1.ffffffe200000p-48, 0x1.0003fffffffc0p+27, 0x1.ffffe00000400p-36, 0x1.0007fffffff7ep+26, 0x1.000fefffff300p-35},
+{-0x1.0000000000002p+26, 0x1.ffffffe200000p-48, -0x1.0003fffffffc0p+27, -0x1.ffffe00000400p-36, -0x1.8003fffffffc1p+27, -0x1.ffdfe00002000p-36},
+{0x1.000003f000000p+13, 0x1.fffffffe00000p-48, 0x1.0000000000ff0p+50, 0x1.c03fff0e00000p-24, 0x1.0000000008ff0p+50, 0x1.f807010004380p-10},
+{0x1.000003f000000p+13, 0x1.fffffffe00000p-48, -0x1.0000000000ff0p+50, -0x1.c03fff0e00000p-24, -0x1.fffffffff1fe0p+49, 0x1.f7f8ff000bc80p-10},
+{-0x1.000003f000000p+13, -0x1.fffffffe00000p-48, 0x1.0000000000ff0p+50, 0x1.c03fff0e00000p-24, 0x1.fffffffff1fe0p+49, -0x1.f7f8ff000bc80p-10},
+{-0x1.000003f000000p+13, -0x1.fffffffe00000p-48, -0x1.0000000000ff0p+50, -0x1.c03fff0e00000p-24, -0x1.0000000008ff0p+50, -0x1.f807010004380p-10},
+{0x1.0000000018000p-6, 0x1.fffffe0000000p-88, 0x1.0000100000000p+32, -0x1.0000000000000p-73, 0x1.0000100004000p+32, 0x1.7ffffffe00000p-42},
+{0x1.0000000018000p-6, 0x1.fffffe0000000p-88, -0x1.0000100000000p+32, 0x1.0000000000000p-73, -0x1.00000ffffc000p+32, 0x1.8000000200000p-42},
+{-0x1.0000000018000p-6, -0x1.fffffe0000000p-88, 0x1.0000100000000p+32, -0x1.0000000000000p-73, 0x1.00000ffffc000p+32, -0x1.8000000200000p-42},
+{-0x1.0000000018000p-6, -0x1.fffffe0000000p-88, -0x1.0000100000000p+32, 0x1.0000000000000p-73, -0x1.0000100004000p+32, -0x1.7ffffffe00000p-42},
+{0x1.0000000000001p+35, -0x1.fffffc1000000p-32, 0x1.1ffffff01f000p+36, 0x1.ffffc000060fcp-19, 0x1.9ffffff01f001p+36, -0x1.00081fffed382p-18},
+{0x1.0000000000001p+35, -0x1.fffffc1000000p-32, -0x1.1ffffff01f000p+36, -0x1.ffffc000060fcp-19, -0x1.3fffffe03e000p+35, 0x1.fff0400019704p-19},
+{-0x1.0000000000001p+35, 0x1.fffffc1000000p-32, 0x1.1ffffff01f000p+36, 0x1.ffffc000060fcp-19, 0x1.3fffffe03e000p+35, -0x1.fff0400019704p-19},
+{-0x1.0000000000001p+35, 0x1.fffffc1000000p-32, -0x1.1ffffff01f000p+36, -0x1.ffffc000060fcp-19, -0x1.9ffffff01f001p+36, 0x1.00081fffed382p-18},
+{0x1.0000003800000p+43, 0x1.ffe000001fffcp-12, 0x1.0000007fffff0p+50, 0x1.fe1ffffc00000p-12, 0x1.020000806fff0p+50, 0x1.fefffffe10000p-11},
+{0x1.0000003800000p+43, 0x1.ffe000001fffcp-12, -0x1.0000007fffff0p+50, -0x1.fe1ffffc00000p-12, -0x1.fc0000ff1ffe0p+49, 0x1.c000042000000p-20},
+{-0x1.0000003800000p+43, -0x1.ffe000001fffcp-12, 0x1.0000007fffff0p+50, 0x1.fe1ffffc00000p-12, 0x1.fc0000ff1ffe0p+49, -0x1.c000042000000p-20},
+{-0x1.0000003800000p+43, -0x1.ffe000001fffcp-12, -0x1.0000007fffff0p+50, -0x1.fe1ffffc00000p-12, -0x1.020000806fff0p+50, -0x1.fefffffe10000p-11},
+{0x1.0000001fffc00p+32, 0x1.f00007ffe0000p-32, 0x1.0000000000180p+25, 0x1.fffffe0000800p-39, 0x1.0200001fffc03p+32, 0x1.f40007fbe0000p-32},
+{0x1.0000001fffc00p+32, 0x1.f00007ffe0000p-32, -0x1.0000000000180p+25, -0x1.fffffe0000800p-39, 0x1.fc00003fff7fap+31, 0x1.ec000803e0000p-32},
+{-0x1.0000001fffc00p+32, -0x1.f00007ffe0000p-32, 0x1.0000000000180p+25, 0x1.fffffe0000800p-39, -0x1.fc00003fff7fap+31, -0x1.ec000803e0000p-32},
+{-0x1.0000001fffc00p+32, -0x1.f00007ffe0000p-32, -0x1.0000000000180p+25, -0x1.fffffe0000800p-39, -0x1.0200001fffc03p+32, -0x1.f40007fbe0000p-32},
+{0x1.0000000008000p+19, -0x1.c0000007ffe04p-36, 0x1.00000fffffffep-53, 0x1.fc00000000000p-152, 0x1.0000000008000p+19, -0x1.bfff8007f7e04p-36},
+{0x1.0000000008000p+19, -0x1.c0000007ffe04p-36, -0x1.00000fffffffep-53, -0x1.fc00000000000p-152, 0x1.0000000008000p+19, -0x1.c000800807e04p-36},
+{-0x1.0000000008000p+19, 0x1.c0000007ffe04p-36, 0x1.00000fffffffep-53, 0x1.fc00000000000p-152, -0x1.0000000008000p+19, 0x1.c000800807e04p-36},
+{-0x1.0000000008000p+19, 0x1.c0000007ffe04p-36, -0x1.00000fffffffep-53, -0x1.fc00000000000p-152, -0x1.0000000008000p+19, 0x1.bfff8007f7e04p-36},
+{0x1.0000003e00004p+43, -0x1.fe00040000000p-27, 0x1.00007c0001e00p+8, 0x1.fffe13ffe0000p-56, 0x1.0000003e20005p+43, -0x1.000f78001f800p-14},
+{0x1.0000003e00004p+43, -0x1.fe00040000000p-27, -0x1.00007c0001e00p+8, -0x1.fffe13ffe0000p-56, 0x1.0000003de0003p+43, 0x1.ffdf2fffbf000p-15},
+{-0x1.0000003e00004p+43, 0x1.fe00040000000p-27, 0x1.00007c0001e00p+8, 0x1.fffe13ffe0000p-56, -0x1.0000003de0003p+43, -0x1.ffdf2fffbf000p-15},
+{-0x1.0000003e00004p+43, 0x1.fe00040000000p-27, -0x1.00007c0001e00p+8, -0x1.fffe13ffe0000p-56, -0x1.0000003e20005p+43, 0x1.000f78001f800p-14},
+{0x1.03fffffffc000p+44, 0x1.ffffffc000000p-31, 0x1.0003ffffff000p-28, 0x1.ffc0000000000p-123, 0x1.03fffffffc000p+44, 0x1.4003fff800000p-28},
+{0x1.03fffffffc000p+44, 0x1.ffffffc000000p-31, -0x1.0003ffffff000p-28, -0x1.ffc0000000000p-123, 0x1.03fffffffc000p+44, -0x1.8008001000000p-29},
+{-0x1.03fffffffc000p+44, -0x1.ffffffc000000p-31, 0x1.0003ffffff000p-28, 0x1.ffc0000000000p-123, -0x1.03fffffffc000p+44, 0x1.8008001000000p-29},
+{-0x1.03fffffffc000p+44, -0x1.ffffffc000000p-31, -0x1.0003ffffff000p-28, -0x1.ffc0000000000p-123, -0x1.03fffffffc000p+44, -0x1.4003fff800000p-28},
+{0x1.07ffffff80000p+48, 0x1.8007ffffc0000p-23, 0x1.0000000000004p-5, -0x1.fffc000200000p-74, 0x1.07ffffff80001p+48, -0x1.ffff3ffbffffap-6},
+{0x1.07ffffff80000p+48, 0x1.8007ffffc0000p-23, -0x1.0000000000004p-5, 0x1.fffc000200000p-74, 0x1.07ffffff80000p+48, -0x1.ffff3ffc0000ap-6},
+{-0x1.07ffffff80000p+48, -0x1.8007ffffc0000p-23, 0x1.0000000000004p-5, -0x1.fffc000200000p-74, -0x1.07ffffff80000p+48, 0x1.ffff3ffc0000ap-6},
+{-0x1.07ffffff80000p+48, -0x1.8007ffffc0000p-23, -0x1.0000000000004p-5, 0x1.fffc000200000p-74, -0x1.07ffffff80001p+48, 0x1.ffff3ffbffffap-6},
+{0x1.00003ffffff80p-25, 0x1.ffff0000ffe00p-87, 0x1.00003fffffff8p-48, 0x0.0000000000000p+0, 0x1.0000420000780p-25, 0x1.ffbf0000ffe00p-87},
+{0x1.00003ffffff80p-25, 0x1.ffff0000ffe00p-87, -0x1.00003fffffff8p-48, 0x0.0000000000000p+0, 0x1.00003dffff780p-25, 0x1.001f80007ff00p-86},
+{-0x1.00003ffffff80p-25, -0x1.ffff0000ffe00p-87, 0x1.00003fffffff8p-48, 0x0.0000000000000p+0, -0x1.00003dffff780p-25, -0x1.001f80007ff00p-86},
+{-0x1.00003ffffff80p-25, -0x1.ffff0000ffe00p-87, -0x1.00003fffffff8p-48, 0x0.0000000000000p+0, -0x1.0000420000780p-25, -0x1.ffbf0000ffe00p-87},
+{0x1.0000010000000p+29, -0x1.0000000000000p-76, 0x1.00f81ffffff81p-9, 0x1.fffff03c00000p-71, 0x1.000001000403ep+29, 0x1.ffffff81007e0p-29},
+{0x1.0000010000000p+29, -0x1.0000000000000p-76, -0x1.00f81ffffff81p-9, -0x1.fffff03c00000p-71, 0x1.000000fffbfc2p+29, -0x1.ffffff8100820p-29},
+{-0x1.0000010000000p+29, 0x1.0000000000000p-76, 0x1.00f81ffffff81p-9, 0x1.fffff03c00000p-71, -0x1.000000fffbfc2p+29, 0x1.ffffff8100820p-29},
+{-0x1.0000010000000p+29, 0x1.0000000000000p-76, -0x1.00f81ffffff81p-9, -0x1.fffff03c00000p-71, -0x1.000001000403ep+29, -0x1.ffffff81007e0p-29},
+{0x1.0000000000004p+5, -0x1.fff0008000000p-59, 0x1.0000000100000p+48, -0x1.fffffe0004000p-19, 0x1.0000000100200p+48, -0x1.fffffdc004000p-19},
+{0x1.0000000000004p+5, -0x1.fff0008000000p-59, -0x1.0000000100000p+48, 0x1.fffffe0004000p-19, -0x1.00000000ffe00p+48, 0x1.fffffe4004000p-19},
+{-0x1.0000000000004p+5, 0x1.fff0008000000p-59, 0x1.0000000100000p+48, -0x1.fffffe0004000p-19, 0x1.00000000ffe00p+48, -0x1.fffffe4004000p-19},
+{-0x1.0000000000004p+5, 0x1.fff0008000000p-59, -0x1.0000000100000p+48, 0x1.fffffe0004000p-19, -0x1.0000000100200p+48, 0x1.fffffdc004000p-19},
+{0x1.0000000000800p+23, -0x1.0000000000000p-55, 0x1.0000010000000p+11, -0x1.0000000000000p-92, 0x1.0010000010800p+23, -0x1.0000000000000p-55},
+{0x1.0000000000800p+23, -0x1.0000000000000p-55, -0x1.0000010000000p+11, 0x1.0000000000000p-92, 0x1.ffdfffffe1000p+22, -0x1.0000000000000p-55},
+{-0x1.0000000000800p+23, 0x1.0000000000000p-55, 0x1.0000010000000p+11, -0x1.0000000000000p-92, -0x1.ffdfffffe1000p+22, 0x1.0000000000000p-55},
+{-0x1.0000000000800p+23, 0x1.0000000000000p-55, -0x1.0000010000000p+11, 0x1.0000000000000p-92, -0x1.0010000010800p+23, 0x1.0000000000000p-55},
+{0x1.00000007fff00p-25, 0x1.fffc1ffff87f0p-81, 0x1.0000007c00000p-2, 0x1.fff0000000000p-73, 0x1.0000027c00001p-2, -0x1.bfc2007c00000p-70},
+{0x1.00000007fff00p-25, 0x1.fffc1ffff87f0p-81, -0x1.0000007c00000p-2, -0x1.fff0000000000p-73, -0x1.fffffcf7ffffep-3, -0x1.1fdf003e00000p-69},
+{-0x1.00000007fff00p-25, -0x1.fffc1ffff87f0p-81, 0x1.0000007c00000p-2, 0x1.fff0000000000p-73, 0x1.fffffcf7ffffep-3, 0x1.1fdf003e00000p-69},
+{-0x1.00000007fff00p-25, -0x1.fffc1ffff87f0p-81, -0x1.0000007c00000p-2, -0x1.fff0000000000p-73, -0x1.0000027c00001p-2, 0x1.bfc2007c00000p-70},
+{0x1.fffffffe00000p+40, 0x1.e000001fff800p-24, 0x1.00000001ffffep-36, 0x0.0000000000000p+0, 0x1.fffffffe00000p+40, 0x1.e010001fff800p-24},
+{0x1.fffffffe00000p+40, 0x1.e000001fff800p-24, -0x1.00000001ffffep-36, 0x0.0000000000000p+0, 0x1.fffffffe00000p+40, 0x1.dff0001fff800p-24},
+{-0x1.fffffffe00000p+40, -0x1.e000001fff800p-24, 0x1.00000001ffffep-36, 0x0.0000000000000p+0, -0x1.fffffffe00000p+40, -0x1.dff0001fff800p-24},
+{-0x1.fffffffe00000p+40, -0x1.e000001fff800p-24, -0x1.00000001ffffep-36, 0x0.0000000000000p+0, -0x1.fffffffe00000p+40, -0x1.e010001fff800p-24},
+{0x1.0000000000008p+12, -0x1.fffff00400000p-60, 0x1.00003ffffe000p-40, 0x1.ffffe00000000p-112, 0x1.0000000000009p+12, 0x1.ffffeffc00000p-60},
+{0x1.0000000000008p+12, -0x1.fffff00400000p-60, -0x1.00003ffffe000p-40, -0x1.ffffe00000000p-112, 0x1.0000000000007p+12, -0x1.7ffff40100000p-58},
+{-0x1.0000000000008p+12, 0x1.fffff00400000p-60, 0x1.00003ffffe000p-40, 0x1.ffffe00000000p-112, -0x1.0000000000007p+12, 0x1.7ffff40100000p-58},
+{-0x1.0000000000008p+12, 0x1.fffff00400000p-60, -0x1.00003ffffe000p-40, -0x1.ffffe00000000p-112, -0x1.0000000000009p+12, -0x1.ffffeffc00000p-60},
+{0x1.0000000000000p-26, 0x1.ffffffffffc00p-89, 0x1.000001ffe0000p+32, 0x1.ff87ff9f801c0p-27, 0x1.000001ffe0000p+32, 0x1.ffc3ffcfc00e0p-26},
+{0x1.0000000000000p-26, 0x1.ffffffffffc00p-89, -0x1.000001ffe0000p+32, -0x1.ff87ff9f801c0p-27, -0x1.000001ffe0000p+32, 0x1.e00181ff90000p-37},
+{-0x1.0000000000000p-26, -0x1.ffffffffffc00p-89, 0x1.000001ffe0000p+32, 0x1.ff87ff9f801c0p-27, 0x1.000001ffe0000p+32, -0x1.e00181ff90000p-37},
+{-0x1.0000000000000p-26, -0x1.ffffffffffc00p-89, -0x1.000001ffe0000p+32, -0x1.ff87ff9f801c0p-27, -0x1.000001ffe0000p+32, -0x1.ffc3ffcfc00e0p-26},
+{0x1.0000000000400p+5, -0x1.f800000002000p-56, 0x1.03fffffffff00p+2, 0x1.fffe7fffffffep-52, 0x1.20800000003e0p+5, 0x1.e07e7fffffe00p-52},
+{0x1.0000000000400p+5, -0x1.f800000002000p-56, -0x1.03fffffffff00p+2, -0x1.fffe7fffffffep-52, 0x1.bf00000000840p+4, -0x1.0fbf400000100p-51},
+{-0x1.0000000000400p+5, 0x1.f800000002000p-56, 0x1.03fffffffff00p+2, 0x1.fffe7fffffffep-52, -0x1.bf00000000840p+4, 0x1.0fbf400000100p-51},
+{-0x1.0000000000400p+5, 0x1.f800000002000p-56, -0x1.03fffffffff00p+2, -0x1.fffe7fffffffep-52, -0x1.20800000003e0p+5, -0x1.e07e7fffffe00p-52},
+{0x1.0000000000000p+13, 0x1.fffffffffff00p-43, 0x1.000007c000000p-28, 0x1.fff8000000000p-84, 0x1.0000000000800p+13, 0x1.01f0000000780p-42},
+{0x1.0000000000000p+13, 0x1.fffffffffff00p-43, -0x1.000007c000000p-28, -0x1.fff8000000000p-84, 0x1.ffffffffff000p+12, 0x1.fc1ffffffef00p-43},
+{-0x1.0000000000000p+13, -0x1.fffffffffff00p-43, 0x1.000007c000000p-28, 0x1.fff8000000000p-84, -0x1.ffffffffff000p+12, -0x1.fc1ffffffef00p-43},
+{-0x1.0000000000000p+13, -0x1.fffffffffff00p-43, -0x1.000007c000000p-28, -0x1.fff8000000000p-84, -0x1.0000000000800p+13, -0x1.01f0000000780p-42},
+{0x1.0000000000400p-35, -0x1.fffc0003fffd0p-92, 0x1.0000000000000p+4, 0x1.fffffff800000p-52, 0x1.0000000002000p+4, 0x1.0000003bff000p-51},
+{0x1.0000000000400p-35, -0x1.fffc0003fffd0p-92, -0x1.0000000000000p+4, -0x1.fffffff800000p-52, -0x1.fffffffffc000p+3, -0x1.ffffff7802000p-52},
+{-0x1.0000000000400p-35, 0x1.fffc0003fffd0p-92, 0x1.0000000000000p+4, 0x1.fffffff800000p-52, 0x1.fffffffffc000p+3, 0x1.ffffff7802000p-52},
+{-0x1.0000000000400p-35, 0x1.fffc0003fffd0p-92, -0x1.0000000000000p+4, -0x1.fffffff800000p-52, -0x1.0000000002000p+4, -0x1.0000003bff000p-51},
+{0x1.0000000002000p-51, -0x1.ffff040000000p-122, 0x1.03fffff800000p-40, 0x1.fffffe0000000p-108, 0x1.041ffff800004p-40, 0x1.fff7fe03f0000p-108},
+{0x1.0000000002000p-51, -0x1.ffff040000000p-122, -0x1.03fffff800000p-40, -0x1.fffffe0000000p-108, -0x1.03dffff7ffffcp-40, -0x1.0003fefe08000p-107},
+{-0x1.0000000002000p-51, 0x1.ffff040000000p-122, 0x1.03fffff800000p-40, 0x1.fffffe0000000p-108, 0x1.03dffff7ffffcp-40, 0x1.0003fefe08000p-107},
+{-0x1.0000000002000p-51, 0x1.ffff040000000p-122, -0x1.03fffff800000p-40, -0x1.fffffe0000000p-108, -0x1.041ffff800004p-40, -0x1.fff7fe03f0000p-108},
+{0x1.0000008000000p-21, -0x1.ffffff8200000p-78, 0x1.000fff8000000p+9, 0x1.fffffe0000000p-53, 0x1.000fff8400000p+9, 0x1.03fffffa00000p-46},
+{0x1.0000008000000p-21, -0x1.ffffff8200000p-78, -0x1.000fff8000000p+9, -0x1.fffffe0000000p-53, -0x1.000fff7c00000p+9, 0x1.f800000400000p-47},
+{-0x1.0000008000000p-21, 0x1.ffffff8200000p-78, 0x1.000fff8000000p+9, 0x1.fffffe0000000p-53, 0x1.000fff7c00000p+9, -0x1.f800000400000p-47},
+{-0x1.0000008000000p-21, 0x1.ffffff8200000p-78, -0x1.000fff8000000p+9, -0x1.fffffe0000000p-53, -0x1.000fff8400000p+9, -0x1.03fffffa00000p-46},
+{0x1.0000000000000p-33, 0x1.0001f9e000000p-93, 0x1.0000000000040p+19, -0x1.fffffc0080000p-53, 0x1.0000000000041p+19, -0x1.fffffc0080000p-53},
+{0x1.0000000000000p-33, 0x1.0001f9e000000p-93, -0x1.0000000000040p+19, 0x1.fffffc0080000p-53, -0x1.000000000003fp+19, 0x1.fffffc0080000p-53},
+{-0x1.0000000000000p-33, -0x1.0001f9e000000p-93, 0x1.0000000000040p+19, -0x1.fffffc0080000p-53, 0x1.000000000003fp+19, -0x1.fffffc0080000p-53},
+{-0x1.0000000000000p-33, -0x1.0001f9e000000p-93, -0x1.0000000000040p+19, 0x1.fffffc0080000p-53, -0x1.0000000000041p+19, 0x1.fffffc0080000p-53},
+{0x1.0000ff0007e00p-13, 0x1.ffc001ff00000p-80, 0x1.0000010000000p-33, -0x1.ffc007ffffe20p-91, 0x1.00010f0007f00p-13, 0x1.ff8009fe00000p-80},
+{0x1.0000ff0007e00p-13, 0x1.ffc001ff00000p-80, -0x1.0000010000000p-33, 0x1.ffc007ffffe20p-91, 0x1.0000ef0007d00p-13, 0x1.fffffa0000000p-80},
+{-0x1.0000ff0007e00p-13, -0x1.ffc001ff00000p-80, 0x1.0000010000000p-33, -0x1.ffc007ffffe20p-91, -0x1.0000ef0007d00p-13, -0x1.fffffa0000000p-80},
+{-0x1.0000ff0007e00p-13, -0x1.ffc001ff00000p-80, -0x1.0000010000000p-33, 0x1.ffc007ffffe20p-91, -0x1.00010f0007f00p-13, -0x1.ff8009fe00000p-80},
+{0x1.07ffffff1fe00p-53, 0x1.fc00000000000p-150, 0x1.0040000000000p-23, -0x1.c000000400000p-84, 0x1.0040000420000p-23, -0x1.1808000200000p-83},
+{0x1.07ffffff1fe00p-53, 0x1.fc00000000000p-150, -0x1.0040000000000p-23, 0x1.c000000400000p-84, -0x1.003ffffbe0000p-23, 0x1.4ff0000400000p-84},
+{-0x1.07ffffff1fe00p-53, -0x1.fc00000000000p-150, 0x1.0040000000000p-23, -0x1.c000000400000p-84, 0x1.003ffffbe0000p-23, -0x1.4ff0000400000p-84},
+{-0x1.07ffffff1fe00p-53, -0x1.fc00000000000p-150, -0x1.0040000000000p-23, 0x1.c000000400000p-84, -0x1.0040000420000p-23, 0x1.1808000200000p-83},
+{0x1.0080000000000p+15, -0x1.0000000000000p-90, 0x1.00000001fffc0p-35, 0x1.fffff80f80000p-107, 0x1.0080000000004p+15, 0x1.fffbfe0000000p-67},
+{0x1.0080000000000p+15, -0x1.0000000000000p-90, -0x1.00000001fffc0p-35, -0x1.fffff80f80000p-107, 0x1.007fffffffffcp+15, -0x1.fffc020000000p-67},
+{-0x1.0080000000000p+15, 0x1.0000000000000p-90, 0x1.00000001fffc0p-35, 0x1.fffff80f80000p-107, -0x1.007fffffffffcp+15, 0x1.fffc020000000p-67},
+{-0x1.0080000000000p+15, 0x1.0000000000000p-90, -0x1.00000001fffc0p-35, -0x1.fffff80f80000p-107, -0x1.0080000000004p+15, -0x1.fffbfe0000000p-67},
+{0x1.000000003ff00p+2, 0x0.0000000000000p+0, 0x1.0000000000000p+46, 0x1.f83007ffffe00p-14, 0x1.0000000000100p+46, 0x1.f83047efffe00p-14},
+{0x1.000000003ff00p+2, 0x0.0000000000000p+0, -0x1.0000000000000p+46, -0x1.f83007ffffe00p-14, -0x1.ffffffffffe00p+45, -0x1.f82fc80fffe00p-14},
+{-0x1.000000003ff00p+2, 0x0.0000000000000p+0, 0x1.0000000000000p+46, 0x1.f83007ffffe00p-14, 0x1.ffffffffffe00p+45, 0x1.f82fc80fffe00p-14},
+{-0x1.000000003ff00p+2, 0x0.0000000000000p+0, -0x1.0000000000000p+46, -0x1.f83007ffffe00p-14, -0x1.0000000000100p+46, -0x1.f83047efffe00p-14},
+{0x1.00003fffffe00p+13, 0x1.fffffc0000380p-47, 0x1.0000010000000p-8, -0x1.ffffff8000008p-64, 0x1.000047ffffe80p+13, 0x1.fffefc0000780p-47},
+{0x1.00003fffffe00p+13, 0x1.fffffc0000380p-47, -0x1.0000010000000p-8, 0x1.ffffff8000008p-64, 0x1.000037ffffd80p+13, 0x1.00007dfffffc0p-46},
+{-0x1.00003fffffe00p+13, -0x1.fffffc0000380p-47, 0x1.0000010000000p-8, -0x1.ffffff8000008p-64, -0x1.000037ffffd80p+13, -0x1.00007dfffffc0p-46},
+{-0x1.00003fffffe00p+13, -0x1.fffffc0000380p-47, -0x1.0000010000000p-8, 0x1.ffffff8000008p-64, -0x1.000047ffffe80p+13, -0x1.fffefc0000780p-47},
+{0x1.0000000080000p+13, -0x1.fffffc0010000p-56, 0x1.3fffff8000000p-19, 0x1.fffff800fe000p-85, 0x1.00000001c0000p+13, -0x1.001fffffbf010p-44},
+{0x1.0000000080000p+13, -0x1.fffffc0010000p-56, -0x1.3fffff8000000p-19, -0x1.fffff800fe000p-85, 0x1.fffffffe80000p+12, 0x1.ffc000007dfe0p-45},
+{-0x1.0000000080000p+13, 0x1.fffffc0010000p-56, 0x1.3fffff8000000p-19, 0x1.fffff800fe000p-85, -0x1.fffffffe80000p+12, -0x1.ffc000007dfe0p-45},
+{-0x1.0000000080000p+13, 0x1.fffffc0010000p-56, -0x1.3fffff8000000p-19, -0x1.fffff800fe000p-85, -0x1.00000001c0000p+13, 0x1.001fffffbf010p-44},
+{0x1.0003f001fc3f0p-13, 0x1.fffffc0000000p-69, 0x1.0000000000000p+27, 0x1.fc1fffc0000fep-27, 0x1.0000000001001p+27, -0x1.07df81303f702p-27},
+{0x1.0003f001fc3f0p-13, 0x1.fffffc0000000p-69, -0x1.0000000000000p+27, -0x1.fc1fffc0000fep-27, -0x1.fffffffffe001p+26, 0x1.ffc0fe9f80e04p-28},
+{-0x1.0003f001fc3f0p-13, -0x1.fffffc0000000p-69, 0x1.0000000000000p+27, 0x1.fc1fffc0000fep-27, 0x1.fffffffffe001p+26, -0x1.ffc0fe9f80e04p-28},
+{-0x1.0003f001fc3f0p-13, -0x1.fffffc0000000p-69, -0x1.0000000000000p+27, -0x1.fc1fffc0000fep-27, -0x1.0000000001001p+27, 0x1.07df81303f702p-27},
+{0x1.0000000000000p+49, 0x1.fffffffffffc0p-10, 0x1.0000000000000p+12, 0x1.ffffffffffe00p-50, 0x1.0000000008000p+49, 0x1.0000000000fe0p-9},
+{0x1.0000000000000p+49, 0x1.fffffffffffc0p-10, -0x1.0000000000000p+12, -0x1.ffffffffffe00p-50, 0x1.fffffffff0000p+48, 0x1.fffffffffdfc0p-10},
+{-0x1.0000000000000p+49, -0x1.fffffffffffc0p-10, 0x1.0000000000000p+12, 0x1.ffffffffffe00p-50, -0x1.fffffffff0000p+48, -0x1.fffffffffdfc0p-10},
+{-0x1.0000000000000p+49, -0x1.fffffffffffc0p-10, -0x1.0000000000000p+12, -0x1.ffffffffffe00p-50, -0x1.0000000008000p+49, -0x1.0000000000fe0p-9},
+{0x1.0000000100000p-51, -0x1.0000000000000p-130, 0x1.0000004000000p+23, -0x1.0000000000000p-57, 0x1.0000004000000p+23, 0x1.f800000000000p-52},
+{0x1.0000000100000p-51, -0x1.0000000000000p-130, -0x1.0000004000000p+23, 0x1.0000000000000p-57, -0x1.0000004000000p+23, 0x1.0400000000000p-51},
+{-0x1.0000000100000p-51, 0x1.0000000000000p-130, 0x1.0000004000000p+23, -0x1.0000000000000p-57, 0x1.0000004000000p+23, -0x1.0400000000000p-51},
+{-0x1.0000000100000p-51, 0x1.0000000000000p-130, -0x1.0000004000000p+23, 0x1.0000000000000p-57, -0x1.0000004000000p+23, -0x1.f800000000000p-52},
+{0x1.0000010000000p-27, -0x1.ffffe00001000p-83, 0x1.000ffffff007fp-2, 0x1.ffffc00000000p-83, 0x1.0010007ff0087p-2, -0x1.0000000000000p-102},
+{0x1.0000010000000p-27, -0x1.ffffe00001000p-83, -0x1.000ffffff007fp-2, -0x1.ffffc00000000p-83, -0x1.000fff7ff0077p-2, -0x1.ffffd00000000p-82},
+{-0x1.0000010000000p-27, 0x1.ffffe00001000p-83, 0x1.000ffffff007fp-2, 0x1.ffffc00000000p-83, 0x1.000fff7ff0077p-2, 0x1.ffffd00000000p-82},
+{-0x1.0000010000000p-27, 0x1.ffffe00001000p-83, -0x1.000ffffff007fp-2, -0x1.ffffc00000000p-83, -0x1.0010007ff0087p-2, 0x1.0000000000000p-102},
+{0x1.1000fffffc000p+50, 0x1.fffffc003f000p-6, 0x1.0000000001000p+30, -0x1.0000000000000p-75, 0x1.10010ffffc000p+50, 0x1.07fffe001f800p-5},
+{0x1.1000fffffc000p+50, 0x1.fffffc003f000p-6, -0x1.0000000001000p+30, 0x1.0000000000000p-75, 0x1.1000effffc000p+50, 0x1.effffc003f000p-6},
+{-0x1.1000fffffc000p+50, -0x1.fffffc003f000p-6, 0x1.0000000001000p+30, -0x1.0000000000000p-75, -0x1.1000effffc000p+50, -0x1.effffc003f000p-6},
+{-0x1.1000fffffc000p+50, -0x1.fffffc003f000p-6, -0x1.0000000001000p+30, 0x1.0000000000000p-75, -0x1.10010ffffc000p+50, -0x1.07fffe001f800p-5},
+{0x1.00000fff80000p+32, 0x1.fffe000000000p-53, 0x1.0000001f00000p+41, 0x1.fffffff000000p-36, 0x1.00800026ffc00p+41, 0x1.00007ff800000p-35},
+{0x1.00000fff80000p+32, 0x1.fffe000000000p-53, -0x1.0000001f00000p+41, -0x1.fffffff000000p-36, -0x1.ff00002e00800p+40, -0x1.fffefff000000p-36},
+{-0x1.00000fff80000p+32, -0x1.fffe000000000p-53, 0x1.0000001f00000p+41, 0x1.fffffff000000p-36, 0x1.ff00002e00800p+40, 0x1.fffefff000000p-36},
+{-0x1.00000fff80000p+32, -0x1.fffe000000000p-53, -0x1.0000001f00000p+41, -0x1.fffffff000000p-36, -0x1.00800026ffc00p+41, -0x1.00007ff800000p-35},
+{0x1.3fdfffff02000p+34, -0x1.0000000000000p-44, 0x1.0000000000000p+31, 0x1.ffffffffffe00p-30, 0x1.5fdfffff02000p+34, 0x1.fffc000000000p-30},
+{0x1.3fdfffff02000p+34, -0x1.0000000000000p-44, -0x1.0000000000000p+31, -0x1.ffffffffffe00p-30, 0x1.1fdfffff02000p+34, -0x1.0002000000000p-29},
+{-0x1.3fdfffff02000p+34, 0x1.0000000000000p-44, 0x1.0000000000000p+31, 0x1.ffffffffffe00p-30, -0x1.1fdfffff02000p+34, 0x1.0002000000000p-29},
+{-0x1.3fdfffff02000p+34, 0x1.0000000000000p-44, -0x1.0000000000000p+31, -0x1.ffffffffffe00p-30, -0x1.5fdfffff02000p+34, -0x1.fffc000000000p-30},
+{0x1.0000000000008p+41, -0x1.e0ffffd002000p-25, 0x1.0000000000400p+36, 0x1.ffffffff03ffep-18, 0x1.0800000000028p+41, 0x1.fc3dffff63fc0p-18},
+{0x1.0000000000008p+41, -0x1.e0ffffd002000p-25, -0x1.0000000000400p+36, -0x1.ffffffff03ffep-18, 0x1.effffffffffd0p+40, -0x1.01e0ffff52020p-17},
+{-0x1.0000000000008p+41, 0x1.e0ffffd002000p-25, 0x1.0000000000400p+36, 0x1.ffffffff03ffep-18, -0x1.effffffffffd0p+40, 0x1.01e0ffff52020p-17},
+{-0x1.0000000000008p+41, 0x1.e0ffffd002000p-25, -0x1.0000000000400p+36, -0x1.ffffffff03ffep-18, -0x1.0800000000028p+41, -0x1.fc3dffff63fc0p-18},
+{0x1.000000fffe020p+17, -0x1.f800100000000p-56, 0x1.0001fff80ffc0p+20, 0x1.ff00000000000p-77, 0x1.200200180fbc4p+20, -0x1.f800000800000p-56},
+{0x1.000000fffe020p+17, -0x1.f800100000000p-56, -0x1.0001fff80ffc0p+20, -0x1.ff00000000000p-77, -0x1.c003ffb020778p+19, -0x1.f8001ff800000p-56},
+{-0x1.000000fffe020p+17, 0x1.f800100000000p-56, 0x1.0001fff80ffc0p+20, 0x1.ff00000000000p-77, 0x1.c003ffb020778p+19, 0x1.f8001ff800000p-56},
+{-0x1.000000fffe020p+17, 0x1.f800100000000p-56, -0x1.0001fff80ffc0p+20, -0x1.ff00000000000p-77, -0x1.200200180fbc4p+20, 0x1.f800000800000p-56},
+{0x1.4000000000000p+46, -0x1.0000000000000p-59, 0x1.0000000000010p-11, 0x1.e000000000000p-79, 0x1.4000000000000p+46, 0x1.0000000000000p-11},
+{0x1.4000000000000p+46, -0x1.0000000000000p-59, -0x1.0000000000010p-11, -0x1.e000000000000p-79, 0x1.4000000000000p+46, -0x1.0000000000020p-11},
+{-0x1.4000000000000p+46, 0x1.0000000000000p-59, 0x1.0000000000010p-11, 0x1.e000000000000p-79, -0x1.4000000000000p+46, 0x1.0000000000020p-11},
+{-0x1.4000000000000p+46, 0x1.0000000000000p-59, -0x1.0000000000010p-11, -0x1.e000000000000p-79, -0x1.4000000000000p+46, -0x1.0000000000000p-11},
+{0x1.2000000000000p+0, -0x1.fffffff01ff20p-57, 0x1.0000000000000p-33, 0x1.fff8003ff0000p-90, 0x1.2000000080000p+0, -0x1.ffffffef1ff60p-57},
+{0x1.2000000000000p+0, -0x1.fffffff01ff20p-57, -0x1.0000000000000p-33, -0x1.fff8003ff0000p-90, 0x1.1fffffff80000p+0, -0x1.fffffff11fee0p-57},
+{-0x1.2000000000000p+0, 0x1.fffffff01ff20p-57, 0x1.0000000000000p-33, 0x1.fff8003ff0000p-90, -0x1.1fffffff80000p+0, 0x1.fffffff11fee0p-57},
+{-0x1.2000000000000p+0, 0x1.fffffff01ff20p-57, -0x1.0000000000000p-33, -0x1.fff8003ff0000p-90, -0x1.2000000080000p+0, 0x1.ffffffef1ff60p-57},
+{0x1.2000000000000p+14, -0x1.fc08000000000p-78, 0x1.0000000038004p+6, -0x1.fffffc4000000p-63, 0x1.2100000000380p+14, 0x1.ffff7fff02ec0p-45},
+{0x1.2000000000000p+14, -0x1.fc08000000000p-78, -0x1.0000000038004p+6, 0x1.fffffc4000000p-63, 0x1.1effffffffc80p+14, -0x1.ffff8000fef40p-45},
+{-0x1.2000000000000p+14, 0x1.fc08000000000p-78, 0x1.0000000038004p+6, -0x1.fffffc4000000p-63, -0x1.1effffffffc80p+14, 0x1.ffff8000fef40p-45},
+{-0x1.2000000000000p+14, 0x1.fc08000000000p-78, -0x1.0000000038004p+6, 0x1.fffffc4000000p-63, -0x1.2100000000380p+14, -0x1.ffff7fff02ec0p-45},
+{0x1.0000000000200p+30, 0x0.0000000000000p+0, 0x1.00001ffff0000p+10, 0x1.ffff80001f000p-47, 0x1.0000100002200p+30, -0x1.ffffe00008000p-27},
+{0x1.0000000000200p+30, 0x0.0000000000000p+0, -0x1.00001ffff0000p+10, -0x1.ffff80001f000p-47, 0x1.ffffdffffc400p+29, 0x1.ffffe00008000p-27},
+{-0x1.0000000000200p+30, 0x0.0000000000000p+0, 0x1.00001ffff0000p+10, 0x1.ffff80001f000p-47, -0x1.ffffdffffc400p+29, -0x1.ffffe00008000p-27},
+{-0x1.0000000000200p+30, 0x0.0000000000000p+0, -0x1.00001ffff0000p+10, -0x1.ffff80001f000p-47, -0x1.0000100002200p+30, 0x1.ffffe00008000p-27},
+{0x1.0000100000000p-17, -0x1.0000000000000p-122, 0x1.0038000800000p+15, -0x1.fffffe0000080p-45, 0x1.0038000900001p+15, -0x1.fffffe0000080p-45},
+{0x1.0000100000000p-17, -0x1.0000000000000p-122, -0x1.0038000800000p+15, 0x1.fffffe0000080p-45, -0x1.00380006fffffp+15, 0x1.fffffe0000080p-45},
+{-0x1.0000100000000p-17, 0x1.0000000000000p-122, 0x1.0038000800000p+15, -0x1.fffffe0000080p-45, 0x1.00380006fffffp+15, -0x1.fffffe0000080p-45},
+{-0x1.0000100000000p-17, 0x1.0000000000000p-122, -0x1.0038000800000p+15, 0x1.fffffe0000080p-45, -0x1.0038000900001p+15, 0x1.fffffe0000080p-45},
+{0x1.0000000000004p-11, -0x1.ffffe00400000p-84, 0x1.0000000000000p-12, 0x1.ffffffffffff8p-68, 0x1.8000000000004p-11, 0x1.fffe00001ffc0p-68},
+{0x1.0000000000004p-11, -0x1.ffffe00400000p-84, -0x1.0000000000000p-12, -0x1.ffffffffffff8p-68, 0x1.0000000000008p-12, -0x1.0000fffff001cp-67},
+{-0x1.0000000000004p-11, 0x1.ffffe00400000p-84, 0x1.0000000000000p-12, 0x1.ffffffffffff8p-68, -0x1.0000000000008p-12, 0x1.0000fffff001cp-67},
+{-0x1.0000000000004p-11, 0x1.ffffe00400000p-84, -0x1.0000000000000p-12, -0x1.ffffffffffff8p-68, -0x1.8000000000004p-11, -0x1.fffe00001ffc0p-68},
+{0x1.0000000000100p-33, -0x1.ffffe7e400000p-103, 0x1.1ffe000008000p-33, -0x1.fffc000004000p-100, 0x1.0fff000004080p-32, -0x1.1ffdfe7e40000p-99},
+{0x1.0000000000100p-33, -0x1.ffffe7e400000p-103, -0x1.1ffe000008000p-33, 0x1.fffc000004000p-100, -0x1.ffe000007f000p-37, 0x1.bffc030384000p-100},
+{-0x1.0000000000100p-33, 0x1.ffffe7e400000p-103, 0x1.1ffe000008000p-33, -0x1.fffc000004000p-100, 0x1.ffe000007f000p-37, -0x1.bffc030384000p-100},
+{-0x1.0000000000100p-33, 0x1.ffffe7e400000p-103, -0x1.1ffe000008000p-33, 0x1.fffc000004000p-100, -0x1.0fff000004080p-32, 0x1.1ffdfe7e40000p-99},
+{0x1.0000000000004p-52, -0x1.0000000000000p-157, 0x1.00000007ffffep-10, 0x1.ffffe000f0000p-71, 0x1.00000008003fep-10, 0x1.ffffe002f0000p-71},
+{0x1.0000000000004p-52, -0x1.0000000000000p-157, -0x1.00000007ffffep-10, -0x1.ffffe000f0000p-71, -0x1.00000007ffbfep-10, -0x1.ffffdffef0000p-71},
+{-0x1.0000000000004p-52, 0x1.0000000000000p-157, 0x1.00000007ffffep-10, 0x1.ffffe000f0000p-71, 0x1.00000007ffbfep-10, 0x1.ffffdffef0000p-71},
+{-0x1.0000000000004p-52, 0x1.0000000000000p-157, -0x1.00000007ffffep-10, -0x1.ffffe000f0000p-71, -0x1.00000008003fep-10, -0x1.ffffe002f0000p-71},
+{0x1.0000000000000p+3, 0x1.fffffff000000p-58, 0x1.0001fffc00001p-42, -0x1.0000000000000p-121, 0x1.0000000000080p+3, 0x1.fffdfff808000p-57},
+{0x1.0000000000000p+3, 0x1.fffffff000000p-58, -0x1.0001fffc00001p-42, 0x1.0000000000000p-121, 0x1.fffffffffff00p+2, 0x1.fff7f80000000p-73},
+{-0x1.0000000000000p+3, -0x1.fffffff000000p-58, 0x1.0001fffc00001p-42, -0x1.0000000000000p-121, -0x1.fffffffffff00p+2, -0x1.fff7f80000000p-73},
+{-0x1.0000000000000p+3, -0x1.fffffff000000p-58, -0x1.0001fffc00001p-42, 0x1.0000000000000p-121, -0x1.0000000000080p+3, -0x1.fffdfff808000p-57},
+{0x1.00007fdfffff0p+50, 0x1.fff000f803fe0p-8, 0x1.0080000000000p-8, -0x1.0000000000000p-100, 0x1.00007fdfffff0p+50, 0x1.8038007c01ff0p-7},
+{0x1.00007fdfffff0p+50, 0x1.fff000f803fe0p-8, -0x1.0080000000000p-8, 0x1.0000000000000p-100, 0x1.00007fdfffff0p+50, 0x1.fee001f007fc0p-9},
+{-0x1.00007fdfffff0p+50, -0x1.fff000f803fe0p-8, 0x1.0080000000000p-8, -0x1.0000000000000p-100, -0x1.00007fdfffff0p+50, -0x1.fee001f007fc0p-9},
+{-0x1.00007fdfffff0p+50, -0x1.fff000f803fe0p-8, -0x1.0080000000000p-8, 0x1.0000000000000p-100, -0x1.00007fdfffff0p+50, -0x1.8038007c01ff0p-7},
+{0x1.0000000000080p+4, 0x0.0000000000000p+0, 0x1.0000080000000p+20, -0x1.0000000000000p-65, 0x1.0001080000000p+20, 0x1.fffffe0000000p-42},
+{0x1.0000000000080p+4, 0x0.0000000000000p+0, -0x1.0000080000000p+20, 0x1.0000000000000p-65, -0x1.fffe100000000p+19, 0x1.0000010000000p-41},
+{-0x1.0000000000080p+4, 0x0.0000000000000p+0, 0x1.0000080000000p+20, -0x1.0000000000000p-65, 0x1.fffe100000000p+19, -0x1.0000010000000p-41},
+{-0x1.0000000000080p+4, 0x0.0000000000000p+0, -0x1.0000080000000p+20, 0x1.0000000000000p-65, -0x1.0001080000000p+20, -0x1.fffffe0000000p-42},
+{0x1.0400000000000p+20, -0x1.0000000000000p-85, 0x1.0000000000400p+5, -0x1.fffff00008000p-51, 0x1.0402000000000p+20, 0x1.fff000007ffe0p-38},
+{0x1.0400000000000p+20, -0x1.0000000000000p-85, -0x1.0000000000400p+5, 0x1.fffff00008000p-51, 0x1.03fe000000000p+20, -0x1.fff0000080020p-38},
+{-0x1.0400000000000p+20, 0x1.0000000000000p-85, 0x1.0000000000400p+5, -0x1.fffff00008000p-51, -0x1.03fe000000000p+20, 0x1.fff0000080020p-38},
+{-0x1.0400000000000p+20, 0x1.0000000000000p-85, -0x1.0000000000400p+5, 0x1.fffff00008000p-51, -0x1.0402000000000p+20, -0x1.fff000007ffe0p-38},
+{0x1.0000000000001p+43, -0x1.fc0000c004000p-22, 0x1.0000000000200p+29, -0x1.ffe0000200000p-39, 0x1.0004000000001p+43, 0x1.fc07fdfe9ff80p-15},
+{0x1.0000000000001p+43, -0x1.fc0000c004000p-22, -0x1.0000000000200p+29, 0x1.ffe0000200000p-39, 0x1.fff8000000002p+42, -0x1.01fbff00d0040p-14},
+{-0x1.0000000000001p+43, 0x1.fc0000c004000p-22, 0x1.0000000000200p+29, -0x1.ffe0000200000p-39, -0x1.fff8000000002p+42, 0x1.01fbff00d0040p-14},
+{-0x1.0000000000001p+43, 0x1.fc0000c004000p-22, -0x1.0000000000200p+29, 0x1.ffe0000200000p-39, -0x1.0004000000001p+43, -0x1.fc07fdfe9ff80p-15},
+{0x1.00000c0000004p+1, -0x1.ff80000800000p-67, 0x1.18003ffff8000p+4, 0x1.ffffff8000000p-62, 0x1.3800417ff8001p+4, -0x1.ffe0ffc008040p-50},
+{0x1.00000c0000004p+1, -0x1.ff80000800000p-67, -0x1.18003ffff8000p+4, -0x1.ffffff8000000p-62, -0x1.f0007cffeffffp+3, -0x1.07fdffc020000p-61},
+{-0x1.00000c0000004p+1, 0x1.ff80000800000p-67, 0x1.18003ffff8000p+4, 0x1.ffffff8000000p-62, 0x1.f0007cffeffffp+3, 0x1.07fdffc020000p-61},
+{-0x1.00000c0000004p+1, 0x1.ff80000800000p-67, -0x1.18003ffff8000p+4, -0x1.ffffff8000000p-62, -0x1.3800417ff8001p+4, 0x1.ffe0ffc008040p-50},
+{0x1.1ffff80000040p+31, -0x1.0000000000000p-59, 0x1.000000000fe00p+44, 0x1.ffff7e0003ff8p-12, 0x1.0008ffffcfe00p+44, 0x1.0fffbf0001fecp-11},
+{0x1.1ffff80000040p+31, -0x1.0000000000000p-59, -0x1.000000000fe00p+44, -0x1.ffff7e0003ff8p-12, -0x1.ffee00009fc00p+43, -0x1.dfff7e0004018p-12},
+{-0x1.1ffff80000040p+31, 0x1.0000000000000p-59, 0x1.000000000fe00p+44, 0x1.ffff7e0003ff8p-12, 0x1.ffee00009fc00p+43, 0x1.dfff7e0004018p-12},
+{-0x1.1ffff80000040p+31, 0x1.0000000000000p-59, -0x1.000000000fe00p+44, -0x1.ffff7e0003ff8p-12, -0x1.0008ffffcfe00p+44, -0x1.0fffbf0001fecp-11},
+{0x1.3fc0000040000p-13, -0x1.fffffff802000p-69, 0x1.fffffffffff00p+30, 0x0.0000000000000p+0, 0x1.00000000000c0p+31, -0x1.fffffe0000100p-24},
+{0x1.3fc0000040000p-13, -0x1.fffffff802000p-69, -0x1.fffffffffff00p+30, 0x0.0000000000000p+0, -0x1.ffffffffffc80p+30, -0x1.fffffe0000100p-24},
+{-0x1.3fc0000040000p-13, 0x1.fffffff802000p-69, 0x1.fffffffffff00p+30, 0x0.0000000000000p+0, 0x1.ffffffffffc80p+30, 0x1.fffffe0000100p-24},
+{-0x1.3fc0000040000p-13, 0x1.fffffff802000p-69, -0x1.fffffffffff00p+30, 0x0.0000000000000p+0, -0x1.00000000000c0p+31, 0x1.fffffe0000100p-24},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, 0x1.0000000000200p-15, -0x1.0000000000000p-120, 0x1.00040001fffffp-1, 0x1.000400007e000p-58},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, -0x1.0000000000200p-15, 0x1.0000000000000p-120, 0x1.fff80003ffffep-2, -0x1.fff7ffff04000p-59},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, 0x1.0000000000200p-15, -0x1.0000000000000p-120, -0x1.fff80003ffffep-2, 0x1.fff7ffff04000p-59},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, -0x1.0000000000200p-15, 0x1.0000000000000p-120, -0x1.00040001fffffp-1, -0x1.000400007e000p-58},
+{0x1.0000000010000p+26, -0x1.0000000000000p-51, 0x1.1fff010000000p-53, 0x1.ff8c0000007fep-107, 0x1.0000000010000p+26, -0x1.70007f8000000p-52},
+{0x1.0000000010000p+26, -0x1.0000000000000p-51, -0x1.1fff010000000p-53, -0x1.ff8c0000007fep-107, 0x1.0000000010000p+26, -0x1.47ffc04000000p-51},
+{-0x1.0000000010000p+26, 0x1.0000000000000p-51, 0x1.1fff010000000p-53, 0x1.ff8c0000007fep-107, -0x1.0000000010000p+26, 0x1.47ffc04000000p-51},
+{-0x1.0000000010000p+26, 0x1.0000000000000p-51, -0x1.1fff010000000p-53, -0x1.ff8c0000007fep-107, -0x1.0000000010000p+26, 0x1.70007f8000000p-52},
+{0x1.0000000000002p-44, -0x1.0000000000000p-131, 0x1.0000000000200p+33, -0x1.0000000000000p-52, 0x1.0000000000200p+33, 0x1.fe00000000000p-45},
+{0x1.0000000000002p-44, -0x1.0000000000000p-131, -0x1.0000000000200p+33, 0x1.0000000000000p-52, -0x1.0000000000200p+33, 0x1.0100000000000p-44},
+{-0x1.0000000000002p-44, 0x1.0000000000000p-131, 0x1.0000000000200p+33, -0x1.0000000000000p-52, 0x1.0000000000200p+33, -0x1.0100000000000p-44},
+{-0x1.0000000000002p-44, 0x1.0000000000000p-131, -0x1.0000000000200p+33, 0x1.0000000000000p-52, -0x1.0000000000200p+33, -0x1.fe00000000000p-45},
+{0x1.0000000000002p+32, -0x1.ffff800008000p-35, 0x1.000000003fffep-25, 0x1.f81fc007c0000p-96, 0x1.0000000000002p+32, 0x1.ff0000407ffc0p-26},
+{0x1.0000000000002p+32, -0x1.ffff800008000p-35, -0x1.000000003fffep-25, -0x1.f81fc007c0000p-96, 0x1.0000000000002p+32, -0x1.007fffe040020p-25},
+{-0x1.0000000000002p+32, 0x1.ffff800008000p-35, 0x1.000000003fffep-25, 0x1.f81fc007c0000p-96, -0x1.0000000000002p+32, 0x1.007fffe040020p-25},
+{-0x1.0000000000002p+32, 0x1.ffff800008000p-35, -0x1.000000003fffep-25, -0x1.f81fc007c0000p-96, -0x1.0000000000002p+32, -0x1.ff0000407ffc0p-26},
+{0x1.7ffffffff0000p+18, 0x1.ffff07fffc000p-46, 0x1.000000000ffe0p-32, 0x1.ff0000003c000p-95, 0x1.7ffffffff0004p+18, 0x1.ffff0bff7c000p-46},
+{0x1.7ffffffff0000p+18, 0x1.ffff07fffc000p-46, -0x1.000000000ffe0p-32, -0x1.ff0000003c000p-95, 0x1.7fffffffefffcp+18, 0x1.ffff04007c000p-46},
+{-0x1.7ffffffff0000p+18, -0x1.ffff07fffc000p-46, 0x1.000000000ffe0p-32, 0x1.ff0000003c000p-95, -0x1.7fffffffefffcp+18, -0x1.ffff04007c000p-46},
+{-0x1.7ffffffff0000p+18, -0x1.ffff07fffc000p-46, -0x1.000000000ffe0p-32, -0x1.ff0000003c000p-95, -0x1.7ffffffff0004p+18, -0x1.ffff0bff7c000p-46},
+{0x1.00007fff00080p-52, -0x1.ffffff0001000p-117, 0x1.00000000007c0p+41, 0x1.ffffff8000000p-26, 0x1.00000000007c0p+41, 0x1.ffffffc000000p-26},
+{0x1.00007fff00080p-52, -0x1.ffffff0001000p-117, -0x1.00000000007c0p+41, -0x1.ffffff8000000p-26, -0x1.00000000007c0p+41, -0x1.ffffff4000000p-26},
+{-0x1.00007fff00080p-52, 0x1.ffffff0001000p-117, 0x1.00000000007c0p+41, 0x1.ffffff8000000p-26, 0x1.00000000007c0p+41, 0x1.ffffff4000000p-26},
+{-0x1.00007fff00080p-52, 0x1.ffffff0001000p-117, -0x1.00000000007c0p+41, -0x1.ffffff8000000p-26, -0x1.00000000007c0p+41, -0x1.ffffffc000000p-26},
+{0x1.1fff81ff00000p+13, 0x1.e007ffff00000p-44, 0x1.1ffffffff8000p-5, 0x1.fe001ffffffe0p-61, 0x1.1fffc9ff00000p+13, -0x1.0ffb808078000p-43},
+{0x1.1fff81ff00000p+13, 0x1.e007ffff00000p-44, -0x1.1ffffffff8000p-5, -0x1.fe001ffffffe0p-61, 0x1.1fff39ff00000p+13, 0x1.7801c03fbc000p-42},
+{-0x1.1fff81ff00000p+13, -0x1.e007ffff00000p-44, 0x1.1ffffffff8000p-5, 0x1.fe001ffffffe0p-61, -0x1.1fff39ff00000p+13, -0x1.7801c03fbc000p-42},
+{-0x1.1fff81ff00000p+13, -0x1.e007ffff00000p-44, -0x1.1ffffffff8000p-5, -0x1.fe001ffffffe0p-61, -0x1.1fffc9ff00000p+13, 0x1.0ffb808078000p-43},
+{0x1.0000000000000p+15, 0x1.fffc03fe00700p-46, 0x1.0000000000001p+24, -0x1.fff8060000f34p-31, 0x1.0080000000001p+24, -0x1.fff40607f8f74p-31},
+{0x1.0000000000000p+15, 0x1.fffc03fe00700p-46, -0x1.0000000000001p+24, 0x1.fff8060000f34p-31, -0x1.ff00000000002p+23, 0x1.fffc05f808ef4p-31},
+{-0x1.0000000000000p+15, -0x1.fffc03fe00700p-46, 0x1.0000000000001p+24, -0x1.fff8060000f34p-31, 0x1.ff00000000002p+23, -0x1.fffc05f808ef4p-31},
+{-0x1.0000000000000p+15, -0x1.fffc03fe00700p-46, -0x1.0000000000001p+24, 0x1.fff8060000f34p-31, -0x1.0080000000001p+24, 0x1.fff40607f8f74p-31},
+{0x1.001ffffc00080p+19, -0x1.fe00000200000p-42, 0x1.0000000001000p-24, -0x1.fe3ffffff0080p-84, 0x1.001ffffc00280p+19, -0x1.fdfffc0200800p-42},
+{0x1.001ffffc00080p+19, -0x1.fe00000200000p-42, -0x1.0000000001000p-24, 0x1.fe3ffffff0080p-84, 0x1.001ffffbffe80p+19, -0x1.fe000401ff800p-42},
+{-0x1.001ffffc00080p+19, 0x1.fe00000200000p-42, 0x1.0000000001000p-24, -0x1.fe3ffffff0080p-84, -0x1.001ffffbffe80p+19, 0x1.fe000401ff800p-42},
+{-0x1.001ffffc00080p+19, 0x1.fe00000200000p-42, -0x1.0000000001000p-24, 0x1.fe3ffffff0080p-84, -0x1.001ffffc00280p+19, 0x1.fdfffc0200800p-42},
+{0x1.00001fffff800p+37, 0x1.ffffff801ffc0p-22, 0x1.0000000002000p+12, -0x1.0000000000000p-93, 0x1.0000207fff800p+37, 0x1.03ffffc00ffe0p-21},
+{0x1.00001fffff800p+37, 0x1.ffffff801ffc0p-22, -0x1.0000000002000p+12, 0x1.0000000000000p-93, 0x1.00001f7fff800p+37, 0x1.f7ffff801ffc0p-22},
+{-0x1.00001fffff800p+37, -0x1.ffffff801ffc0p-22, 0x1.0000000002000p+12, -0x1.0000000000000p-93, -0x1.00001f7fff800p+37, -0x1.f7ffff801ffc0p-22},
+{-0x1.00001fffff800p+37, -0x1.ffffff801ffc0p-22, -0x1.0000000002000p+12, 0x1.0000000000000p-93, -0x1.0000207fff800p+37, -0x1.03ffffc00ffe0p-21},
+{0x1.0000000000000p-40, 0x1.ffff83ffbfff0p-96, 0x1.0000000000000p-34, 0x1.ffffffffe0000p-90, 0x1.0400000000000p-34, 0x1.03ffff07ef800p-89},
+{0x1.0000000000000p-40, 0x1.ffff83ffbfff0p-96, -0x1.0000000000000p-34, -0x1.ffffffffe0000p-90, -0x1.f800000000000p-35, -0x1.f80001efe1000p-90},
+{-0x1.0000000000000p-40, -0x1.ffff83ffbfff0p-96, 0x1.0000000000000p-34, 0x1.ffffffffe0000p-90, 0x1.f800000000000p-35, 0x1.f80001efe1000p-90},
+{-0x1.0000000000000p-40, -0x1.ffff83ffbfff0p-96, -0x1.0000000000000p-34, -0x1.ffffffffe0000p-90, -0x1.0400000000000p-34, -0x1.03ffff07ef800p-89},
+{0x1.0000000000000p+39, 0x1.fffe7ff3dff00p-22, 0x1.000007f830000p+13, 0x1.fff0000ffe100p-48, 0x1.0000004000020p+39, -0x1.e4000bfc61208p-17},
+{0x1.0000000000000p+39, 0x1.fffe7ff3dff00p-22, -0x1.000007f830000p+13, -0x1.fff0000ffe100p-48, 0x1.ffffff7ffffc0p+38, 0x1.01fff9fdcf8fcp-16},
+{-0x1.0000000000000p+39, -0x1.fffe7ff3dff00p-22, 0x1.000007f830000p+13, 0x1.fff0000ffe100p-48, -0x1.ffffff7ffffc0p+38, -0x1.01fff9fdcf8fcp-16},
+{-0x1.0000000000000p+39, -0x1.fffe7ff3dff00p-22, -0x1.000007f830000p+13, -0x1.fff0000ffe100p-48, -0x1.0000004000020p+39, 0x1.e4000bfc61208p-17},
+{0x1.00000ffffe000p+18, 0x1.fffffffffc000p-49, 0x1.0000000000002p-46, -0x1.fffffe01f8004p-101, 0x1.00000ffffe000p+18, 0x1.3fffffffff800p-46},
+{0x1.00000ffffe000p+18, 0x1.fffffffffc000p-49, -0x1.0000000000002p-46, 0x1.fffffe01f8004p-101, 0x1.00000ffffe000p+18, -0x1.8000000001000p-47},
+{-0x1.00000ffffe000p+18, -0x1.fffffffffc000p-49, 0x1.0000000000002p-46, -0x1.fffffe01f8004p-101, -0x1.00000ffffe000p+18, 0x1.8000000001000p-47},
+{-0x1.00000ffffe000p+18, -0x1.fffffffffc000p-49, -0x1.0000000000002p-46, 0x1.fffffe01f8004p-101, -0x1.00000ffffe000p+18, -0x1.3fffffffff800p-46},
+{0x1.0000000000060p+41, 0x1.fffe3fff00000p-22, 0x1.0000000002000p+4, -0x1.ffe0002000000p-53, 0x1.0000000008060p+41, 0x1.00031ffd80200p-21},
+{0x1.0000000000060p+41, 0x1.fffe3fff00000p-22, -0x1.0000000002000p+4, 0x1.ffe0002000000p-53, 0x1.fffffffff00c0p+40, 0x1.fff64002ffc00p-22},
+{-0x1.0000000000060p+41, -0x1.fffe3fff00000p-22, 0x1.0000000002000p+4, -0x1.ffe0002000000p-53, -0x1.fffffffff00c0p+40, -0x1.fff64002ffc00p-22},
+{-0x1.0000000000060p+41, -0x1.fffe3fff00000p-22, -0x1.0000000002000p+4, 0x1.ffe0002000000p-53, -0x1.0000000008060p+41, -0x1.00031ffd80200p-21},
+{0x1.0003ffffffff8p-50, 0x1.ffffe07e00000p-124, 0x1.07ff000008000p+19, -0x1.e000020000000p-42, 0x1.07ff000008000p+19, -0x1.defffe0000000p-42},
+{0x1.0003ffffffff8p-50, 0x1.ffffe07e00000p-124, -0x1.07ff000008000p+19, 0x1.e000020000000p-42, -0x1.07ff000008000p+19, 0x1.e100060000000p-42},
+{-0x1.0003ffffffff8p-50, -0x1.ffffe07e00000p-124, 0x1.07ff000008000p+19, -0x1.e000020000000p-42, 0x1.07ff000008000p+19, -0x1.e100060000000p-42},
+{-0x1.0003ffffffff8p-50, -0x1.ffffe07e00000p-124, -0x1.07ff000008000p+19, 0x1.e000020000000p-42, -0x1.07ff000008000p+19, 0x1.defffe0000000p-42},
+// Some test cases drawn only from the [0.5,1] binade:
+{0x1.0000000000002p-1, -0x1.ffc0ffff90000p-65, 0x1.0003ffffffffcp-1, 0x1.ffffc00000000p-88, 0x1.0001fffffffffp+0, -0x1.ffc0fbff90000p-65},
+{0x1.0000000000002p-1, -0x1.ffc0ffff90000p-65, -0x1.0003ffffffffcp-1, -0x1.ffffc00000000p-88, -0x1.ffffffffd0010p-16, 0x1.f7e0038400000p-76},
+{-0x1.0000000000002p-1, 0x1.ffc0ffff90000p-65, 0x1.0003ffffffffcp-1, 0x1.ffffc00000000p-88, 0x1.ffffffffd0010p-16, -0x1.f7e0038400000p-76},
+{-0x1.0000000000002p-1, 0x1.ffc0ffff90000p-65, -0x1.0003ffffffffcp-1, -0x1.ffffc00000000p-88, -0x1.0001fffffffffp+0, 0x1.ffc0fbff90000p-65},
+{0x1.0000100000000p-1, -0x1.0000000000000p-63, 0x1.0000000004000p-1, -0x1.ffffe00fc0200p-57, 0x1.0000080002000p+0, -0x1.01fff007e0100p-56},
+{0x1.0000100000000p-1, -0x1.0000000000000p-63, -0x1.0000000004000p-1, 0x1.ffffe00fc0200p-57, 0x1.ffff80003f800p-22, -0x1.ff03fe0000000p-77},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-63, 0x1.0000000004000p-1, -0x1.ffffe00fc0200p-57, -0x1.ffff80003f800p-22, 0x1.ff03fe0000000p-77},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-63, -0x1.0000000004000p-1, 0x1.ffffe00fc0200p-57, -0x1.0000080002000p+0, 0x1.01fff007e0100p-56},
+{0x1.0000000800000p-1, -0x1.0000000000000p-73, 0x1.000003fffc002p-1, -0x1.0000000000000p-106, 0x1.00000203fe001p+0, -0x1.0000000000000p-73},
+{0x1.0000000800000p-1, -0x1.0000000000000p-73, -0x1.000003fffc002p-1, 0x1.0000000000000p-106, -0x1.fbfe001000008p-24, 0x1.0000000000000p-106},
+{-0x1.0000000800000p-1, 0x1.0000000000000p-73, 0x1.000003fffc002p-1, -0x1.0000000000000p-106, 0x1.fbfe001000008p-24, -0x1.0000000000000p-106},
+{-0x1.0000000800000p-1, 0x1.0000000000000p-73, -0x1.000003fffc002p-1, 0x1.0000000000000p-106, -0x1.00000203fe001p+0, 0x1.0000000000000p-73},
+{0x1.0000000000000p-1, 0x1.ffc001ffffe00p-56, 0x1.000003fff8000p-1, 0x1.fffc000fc0000p-72, 0x1.000001fffc000p+0, 0x1.ffc201fbfff00p-56},
+{0x1.0000000000000p-1, 0x1.ffc001ffffe00p-56, -0x1.000003fff8000p-1, -0x1.fffc000fc0000p-72, -0x1.fffbfffe00420p-24, 0x1.01ffe82000000p-79},
+{-0x1.0000000000000p-1, -0x1.ffc001ffffe00p-56, 0x1.000003fff8000p-1, 0x1.fffc000fc0000p-72, 0x1.fffbfffe00420p-24, -0x1.01ffe82000000p-79},
+{-0x1.0000000000000p-1, -0x1.ffc001ffffe00p-56, -0x1.000003fff8000p-1, -0x1.fffc000fc0000p-72, -0x1.000001fffc000p+0, -0x1.ffc201fbfff00p-56},
+{0x1.0000000000003p-1, 0x1.fc00001fff800p-65, 0x1.0000000000020p-1, -0x1.fc01ffe002000p-65, 0x1.0000000000011p+0, 0x1.ffffffc007ffcp-54},
+{0x1.0000000000003p-1, 0x1.fc00001fff800p-65, -0x1.0000000000020p-1, 0x1.fc01ffe002000p-65, -0x1.cffc07fe00000p-49, 0x1.8000000000000p-105},
+{-0x1.0000000000003p-1, -0x1.fc00001fff800p-65, 0x1.0000000000020p-1, -0x1.fc01ffe002000p-65, 0x1.cffc07fe00000p-49, -0x1.8000000000000p-105},
+{-0x1.0000000000003p-1, -0x1.fc00001fff800p-65, -0x1.0000000000020p-1, 0x1.fc01ffe002000p-65, -0x1.0000000000011p+0, -0x1.ffffffc007ffcp-54},
+{0x1.0000000000000p-1, 0x1.fffff00001ffep-55, 0x1.0000000000000p-1, 0x1.ff00000ffff80p-61, 0x1.0000000000000p+0, 0x1.03fdf80020ffep-54},
+{0x1.0000000000000p-1, 0x1.fffff00001ffep-55, -0x1.0000000000000p-1, -0x1.ff00000ffff80p-61, 0x1.f803efffc2000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffff00001ffep-55, 0x1.0000000000000p-1, 0x1.ff00000ffff80p-61, -0x1.f803efffc2000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffff00001ffep-55, -0x1.0000000000000p-1, -0x1.ff00000ffff80p-61, -0x1.0000000000000p+0, -0x1.03fdf80020ffep-54},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, 0x1.0000200000000p-1, -0x1.ffc0000080000p-73, 0x1.0000100000000p+0, 0x1.ff001fffff800p-64},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, -0x1.0000200000000p-1, 0x1.ffc0000080000p-73, -0x1.ffffffffffbfep-21, -0x1.0000000000000p-83},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, 0x1.0000200000000p-1, -0x1.ffc0000080000p-73, 0x1.ffffffffffbfep-21, 0x1.0000000000000p-83},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, -0x1.0000200000000p-1, 0x1.ffc0000080000p-73, -0x1.0000100000000p+0, -0x1.ff001fffff800p-64},
+{0x1.0000000000800p-1, -0x1.fffc000000010p-58, 0x1.0000000000008p-1, -0x1.ffe03fffff010p-58, 0x1.0000000000404p+0, -0x1.ffee1fffff810p-57},
+{0x1.0000000000800p-1, -0x1.fffc000000010p-58, -0x1.0000000000008p-1, 0x1.ffe03fffff010p-58, 0x1.fdffffc880000p-43, -0x1.0000000000000p-98},
+{-0x1.0000000000800p-1, 0x1.fffc000000010p-58, 0x1.0000000000008p-1, -0x1.ffe03fffff010p-58, -0x1.fdffffc880000p-43, 0x1.0000000000000p-98},
+{-0x1.0000000000800p-1, 0x1.fffc000000010p-58, -0x1.0000000000008p-1, 0x1.ffe03fffff010p-58, -0x1.0000000000404p+0, 0x1.ffee1fffff810p-57},
+{0x1.0000000000000p-1, 0x1.fffef0ffff000p-64, 0x1.0000100000000p-1, -0x1.fff8000000800p-65, 0x1.0000080000000p+0, 0x1.0002f0ffff000p-64},
+{0x1.0000000000000p-1, 0x1.fffef0ffff000p-64, -0x1.0000100000000p-1, 0x1.fff8000000800p-65, -0x1.ffffffffff400p-22, -0x1.43c0003000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffef0ffff000p-64, 0x1.0000100000000p-1, -0x1.fff8000000800p-65, 0x1.ffffffffff400p-22, 0x1.43c0003000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffef0ffff000p-64, -0x1.0000100000000p-1, 0x1.fff8000000800p-65, -0x1.0000080000000p+0, -0x1.0002f0ffff000p-64},
+{0x1.07c00007ffff0p-1, 0x1.fffc00f800000p-77, 0x1.0000007ffffe0p-1, 0x1.f000000000000p-72, 0x1.03e00043fffe8p+0, 0x1.ffffe00800000p-72},
+{0x1.07c00007ffff0p-1, 0x1.fffc00f800000p-77, -0x1.0000007ffffe0p-1, -0x1.f000000000000p-72, 0x1.efffe20000400p-7, -0x1.e0001ff840000p-72},
+{-0x1.07c00007ffff0p-1, -0x1.fffc00f800000p-77, 0x1.0000007ffffe0p-1, 0x1.f000000000000p-72, -0x1.efffe20000400p-7, 0x1.e0001ff840000p-72},
+{-0x1.07c00007ffff0p-1, -0x1.fffc00f800000p-77, -0x1.0000007ffffe0p-1, -0x1.f000000000000p-72, -0x1.03e00043fffe8p+0, -0x1.ffffe00800000p-72},
+{0x1.0000000000000p-1, 0x1.ff800fffff800p-57, 0x1.0000000000000p-1, 0x1.fffc0000ffff8p-57, 0x1.0000000000000p+0, 0x1.ffbe08007fc00p-56},
+{0x1.0000000000000p-1, 0x1.ff800fffff800p-57, -0x1.0000000000000p-1, -0x1.fffc0000ffff8p-57, -0x1.efc00401fe000p-67, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff800fffff800p-57, 0x1.0000000000000p-1, 0x1.fffc0000ffff8p-57, 0x1.efc00401fe000p-67, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff800fffff800p-57, -0x1.0000000000000p-1, -0x1.fffc0000ffff8p-57, -0x1.0000000000000p+0, -0x1.ffbe08007fc00p-56},
+{0x1.0000000008000p-1, -0x1.ffff807ffe002p-55, 0x1.0000000800000p-1, -0x1.ffffff8000008p-57, 0x1.0000000404000p+0, -0x1.3fffc02fff002p-54},
+{0x1.0000000008000p-1, -0x1.ffff807ffe002p-55, -0x1.0000000800000p-1, 0x1.ffffff8000008p-57, -0x1.fe00017fff80ap-31, 0x1.0000000000000p-94},
+{-0x1.0000000008000p-1, 0x1.ffff807ffe002p-55, 0x1.0000000800000p-1, -0x1.ffffff8000008p-57, 0x1.fe00017fff80ap-31, -0x1.0000000000000p-94},
+{-0x1.0000000008000p-1, 0x1.ffff807ffe002p-55, -0x1.0000000800000p-1, 0x1.ffffff8000008p-57, -0x1.0000000404000p+0, 0x1.3fffc02fff002p-54},
+{0x1.0000000000020p-1, -0x1.0000000000000p-84, 0x1.0000000000000p-1, 0x1.fffff000003c0p-60, 0x1.0000000000010p+0, 0x1.ffffef0000400p-60},
+{0x1.0000000000020p-1, -0x1.0000000000000p-84, -0x1.0000000000000p-1, -0x1.fffff000003c0p-60, 0x1.ffc00001e0000p-49, -0x1.e000000000000p-103},
+{-0x1.0000000000020p-1, 0x1.0000000000000p-84, 0x1.0000000000000p-1, 0x1.fffff000003c0p-60, -0x1.ffc00001e0000p-49, 0x1.e000000000000p-103},
+{-0x1.0000000000020p-1, 0x1.0000000000000p-84, -0x1.0000000000000p-1, -0x1.fffff000003c0p-60, -0x1.0000000000010p+0, -0x1.ffffef0000400p-60},
+{0x1.0000001ffff80p-1, 0x1.fffffdfffff8ep-55, 0x1.0000000200000p-1, -0x1.0000000000000p-70, 0x1.00000010fffc0p+0, 0x1.fffdfdfffff90p-55},
+{0x1.0000001ffff80p-1, 0x1.fffffdfffff8ep-55, -0x1.0000000200000p-1, 0x1.0000000000000p-70, 0x1.dfff8080007f8p-29, -0x1.c800000000000p-101},
+{-0x1.0000001ffff80p-1, -0x1.fffffdfffff8ep-55, 0x1.0000000200000p-1, -0x1.0000000000000p-70, -0x1.dfff8080007f8p-29, 0x1.c800000000000p-101},
+{-0x1.0000001ffff80p-1, -0x1.fffffdfffff8ep-55, -0x1.0000000200000p-1, 0x1.0000000000000p-70, -0x1.00000010fffc0p+0, -0x1.fffdfdfffff90p-55},
+{0x1.01ffffff80400p-1, -0x1.c7ffffc000100p-59, 0x1.0000000000000p-1, 0x1.8fff01fffff00p-61, 0x1.00ffffffc0200p+0, -0x1.64003f4000140p-59},
+{0x1.01ffffff80400p-1, -0x1.c7ffffc000100p-59, -0x1.0000000000000p-1, -0x1.8fff01fffff00p-61, 0x1.ffffff803fff7p-9, 0x1.4003fbffff400p-63},
+{-0x1.01ffffff80400p-1, 0x1.c7ffffc000100p-59, 0x1.0000000000000p-1, 0x1.8fff01fffff00p-61, -0x1.ffffff803fff7p-9, -0x1.4003fbffff400p-63},
+{-0x1.01ffffff80400p-1, 0x1.c7ffffc000100p-59, -0x1.0000000000000p-1, -0x1.8fff01fffff00p-61, -0x1.00ffffffc0200p+0, 0x1.64003f4000140p-59},
+{0x1.0000000000008p-1, -0x1.ffffc00800000p-74, 0x1.00003ffe00002p-1, -0x1.ffffffc180080p-61, 0x1.00001fff00005p+0, -0x1.0007ffdfc0200p-60},
+{0x1.0000000000008p-1, -0x1.ffffc00800000p-74, -0x1.00003ffe00002p-1, 0x1.ffffffc180080p-61, -0x1.ffeffffcff001p-20, 0x1.fff86ff900000p-74},
+{-0x1.0000000000008p-1, 0x1.ffffc00800000p-74, 0x1.00003ffe00002p-1, -0x1.ffffffc180080p-61, 0x1.ffeffffcff001p-20, -0x1.fff86ff900000p-74},
+{-0x1.0000000000008p-1, 0x1.ffffc00800000p-74, -0x1.00003ffe00002p-1, 0x1.ffffffc180080p-61, -0x1.00001fff00005p+0, 0x1.0007ffdfc0200p-60},
+{0x1.000000ffffff8p-1, 0x1.ffffffc000000p-58, 0x1.0000000000000p-1, 0x1.ffffffe000000p-59, 0x1.0000007fffffcp+0, 0x1.7fffffd800000p-57},
+{0x1.000000ffffff8p-1, 0x1.ffffffc000000p-58, -0x1.0000000000000p-1, -0x1.ffffffe000000p-59, 0x1.ffffff0100000p-26, -0x1.8000000000000p-85},
+{-0x1.000000ffffff8p-1, -0x1.ffffffc000000p-58, 0x1.0000000000000p-1, 0x1.ffffffe000000p-59, -0x1.ffffff0100000p-26, 0x1.8000000000000p-85},
+{-0x1.000000ffffff8p-1, -0x1.ffffffc000000p-58, -0x1.0000000000000p-1, -0x1.ffffffe000000p-59, -0x1.0000007fffffcp+0, -0x1.7fffffd800000p-57},
+{0x1.0000000020000p-1, -0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.ff1ffffff4000p-68, 0x1.0000000010200p+0, -0x1.ff1ffffff8000p-68},
+{0x1.0000000020000p-1, -0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.ff1ffffff4000p-68, 0x1.fc000003fe400p-37, -0x1.0000000000000p-104},
+{-0x1.0000000020000p-1, 0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.ff1ffffff4000p-68, -0x1.fc000003fe400p-37, 0x1.0000000000000p-104},
+{-0x1.0000000020000p-1, 0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.ff1ffffff4000p-68, -0x1.0000000010200p+0, 0x1.ff1ffffff8000p-68},
+{0x1.0000ff8020000p-1, -0x1.fffffa0000000p-63, 0x1.0000000001ff0p-1, 0x1.f700000ffe000p-67, 0x1.00007fc010ff8p+0, -0x1.e08ff9ff00000p-63},
+{0x1.0000ff8020000p-1, -0x1.fffffa0000000p-63, -0x1.0000000001ff0p-1, -0x1.f700000ffe000p-67, 0x1.ff003c01ffef0p-18, 0x1.200bfe0040000p-72},
+{-0x1.0000ff8020000p-1, 0x1.fffffa0000000p-63, 0x1.0000000001ff0p-1, 0x1.f700000ffe000p-67, -0x1.ff003c01ffef0p-18, -0x1.200bfe0040000p-72},
+{-0x1.0000ff8020000p-1, 0x1.fffffa0000000p-63, -0x1.0000000001ff0p-1, -0x1.f700000ffe000p-67, -0x1.00007fc010ff8p+0, 0x1.e08ff9ff00000p-63},
+{0x1.0000020000000p-1, -0x1.0000000000000p-65, 0x1.003e00001f800p-1, 0x1.ffde000001e00p-63, 0x1.001f01000fc00p+0, 0x1.bfde000002000p-63},
+{0x1.0000020000000p-1, -0x1.0000000000000p-65, -0x1.003e00001f800p-1, -0x1.ffde000001e00p-63, -0x1.eff000fc00004p-12, -0x1.fef000000f000p-66},
+{-0x1.0000020000000p-1, 0x1.0000000000000p-65, 0x1.003e00001f800p-1, 0x1.ffde000001e00p-63, 0x1.eff000fc00004p-12, 0x1.fef000000f000p-66},
+{-0x1.0000020000000p-1, 0x1.0000000000000p-65, -0x1.003e00001f800p-1, -0x1.ffde000001e00p-63, -0x1.001f01000fc00p+0, -0x1.bfde000002000p-63},
+{0x1.0007e3ffe0000p-1, 0x1.fe0ffffffe000p-65, 0x1.0000000000000p-1, 0x1.fffffe07fff00p-62, 0x1.0003f1fff0000p+0, 0x1.1fe0ff03ffe00p-61},
+{0x1.0007e3ffe0000p-1, 0x1.fe0ffffffe000p-65, -0x1.0000000000000p-1, -0x1.fffffe07fff00p-62, 0x1.f8fff7fffffc8p-15, -0x1.eff0400180000p-73},
+{-0x1.0007e3ffe0000p-1, -0x1.fe0ffffffe000p-65, 0x1.0000000000000p-1, 0x1.fffffe07fff00p-62, -0x1.f8fff7fffffc8p-15, 0x1.eff0400180000p-73},
+{-0x1.0007e3ffe0000p-1, -0x1.fe0ffffffe000p-65, -0x1.0000000000000p-1, -0x1.fffffe07fff00p-62, -0x1.0003f1fff0000p+0, -0x1.1fe0ff03ffe00p-61},
+{0x1.00000000fe000p-1, 0x1.ff00004000000p-68, 0x1.000003fffff80p-1, 0x1.fff8400000000p-61, 0x1.000002007efc0p+0, 0x1.01fb200040000p-60},
+{0x1.00000000fe000p-1, 0x1.ff00004000000p-68, -0x1.000003fffff80p-1, -0x1.fff8400000000p-61, -0x1.ff80fc000fdfdp-24, -0x1.fffc000000000p-80},
+{-0x1.00000000fe000p-1, -0x1.ff00004000000p-68, 0x1.000003fffff80p-1, 0x1.fff8400000000p-61, 0x1.ff80fc000fdfdp-24, 0x1.fffc000000000p-80},
+{-0x1.00000000fe000p-1, -0x1.ff00004000000p-68, -0x1.000003fffff80p-1, -0x1.fff8400000000p-61, -0x1.000002007efc0p+0, -0x1.01fb200040000p-60},
+{0x1.0000800000000p-1, -0x1.0000000000000p-57, 0x1.0000000000000p-1, 0x1.fffffffc1fc00p-64, 0x1.0000400000000p+0, -0x1.f80000000f800p-58},
+{0x1.0000800000000p-1, -0x1.0000000000000p-57, -0x1.0000000000000p-1, -0x1.fffffffc1fc00p-64, 0x1.fffffffffbf00p-19, 0x1.f020000000000p-95},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-57, 0x1.0000000000000p-1, 0x1.fffffffc1fc00p-64, -0x1.fffffffffbf00p-19, -0x1.f020000000000p-95},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-57, -0x1.0000000000000p-1, -0x1.fffffffc1fc00p-64, -0x1.0000400000000p+0, 0x1.f80000000f800p-58},
+{0x1.0000000000000p-1, 0x1.ff000ff3ffe00p-55, 0x1.0000000000000p-1, 0x1.fe0003fffc000p-60, 0x1.0000000000000p+0, 0x1.07780809ffe00p-54},
+{0x1.0000000000000p-1, 0x1.ff000ff3ffe00p-55, -0x1.0000000000000p-1, -0x1.fe0003fffc000p-60, 0x1.ef100fd400000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff000ff3ffe00p-55, 0x1.0000000000000p-1, 0x1.fe0003fffc000p-60, -0x1.ef100fd400000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff000ff3ffe00p-55, -0x1.0000000000000p-1, -0x1.fe0003fffc000p-60, -0x1.0000000000000p+0, -0x1.07780809ffe00p-54},
+{0x1.000000e000010p-1, -0x1.ffffffc020000p-71, 0x1.00000001f0000p-1, 0x1.8000000000000p-105, 0x1.00000070f8008p+0, -0x1.ffffffbfc0000p-71},
+{0x1.000000e000010p-1, -0x1.ffffffc020000p-71, -0x1.00000001f0000p-1, -0x1.8000000000000p-105, 0x1.bc2001fffff00p-26, 0x1.fc00000000000p-98},
+{-0x1.000000e000010p-1, 0x1.ffffffc020000p-71, 0x1.00000001f0000p-1, 0x1.8000000000000p-105, -0x1.bc2001fffff00p-26, -0x1.fc00000000000p-98},
+{-0x1.000000e000010p-1, 0x1.ffffffc020000p-71, -0x1.00000001f0000p-1, -0x1.8000000000000p-105, -0x1.00000070f8008p+0, 0x1.ffffffbfc0000p-71},
+{0x1.000003ff00000p-1, 0x1.8000000000000p-78, 0x1.0001ffffe0000p-1, 0x1.f800000100000p-74, 0x1.000101ff70000p+0, 0x1.0800000000000p-73},
+{0x1.000003ff00000p-1, 0x1.8000000000000p-78, -0x1.0001ffffe0000p-1, -0x1.f800000100000p-74, -0x1.fc00e00000000p-17, -0x1.e000000100000p-74},
+{-0x1.000003ff00000p-1, -0x1.8000000000000p-78, 0x1.0001ffffe0000p-1, 0x1.f800000100000p-74, 0x1.fc00e00000000p-17, 0x1.e000000100000p-74},
+{-0x1.000003ff00000p-1, -0x1.8000000000000p-78, -0x1.0001ffffe0000p-1, -0x1.f800000100000p-74, -0x1.000101ff70000p+0, -0x1.0800000000000p-73},
+{0x1.0000000000200p-1, -0x1.ffffffffffc08p-57, 0x1.0000000000000p-1, 0x1.ffffffffffffep-55, 0x1.0000000000100p+0, 0x1.80000000000fcp-55},
+{0x1.0000000000200p-1, -0x1.ffffffffffc08p-57, -0x1.0000000000000p-1, -0x1.ffffffffffffep-55, 0x1.ff60000000000p-45, 0x1.0000000000000p-99},
+{-0x1.0000000000200p-1, 0x1.ffffffffffc08p-57, 0x1.0000000000000p-1, 0x1.ffffffffffffep-55, -0x1.ff60000000000p-45, -0x1.0000000000000p-99},
+{-0x1.0000000000200p-1, 0x1.ffffffffffc08p-57, -0x1.0000000000000p-1, -0x1.ffffffffffffep-55, -0x1.0000000000100p+0, -0x1.80000000000fcp-55},
+{0x1.0000000040000p-1, -0x1.fffff80002000p-67, 0x1.0000000000000p-1, 0x1.ffc01ffff3c00p-64, 0x1.0000000020000p+0, 0x1.bfc020fff3800p-64},
+{0x1.0000000040000p-1, -0x1.fffff80002000p-67, -0x1.0000000000000p-1, -0x1.ffc01ffff3c00p-64, 0x1.ffffffdc03fe1p-36, 0x1.8000000000000p-101},
+{-0x1.0000000040000p-1, 0x1.fffff80002000p-67, 0x1.0000000000000p-1, 0x1.ffc01ffff3c00p-64, -0x1.ffffffdc03fe1p-36, -0x1.8000000000000p-101},
+{-0x1.0000000040000p-1, 0x1.fffff80002000p-67, -0x1.0000000000000p-1, -0x1.ffc01ffff3c00p-64, -0x1.0000000020000p+0, -0x1.bfc020fff3800p-64},
+{0x1.0000800000000p-1, -0x1.0000000000000p-106, 0x1.0000003800001p-1, 0x1.fffffe000003ep-55, 0x1.0000401c00001p+0, -0x1.000000fffffe2p-54},
+{0x1.0000800000000p-1, -0x1.0000000000000p-106, -0x1.0000003800001p-1, -0x1.fffffe000003ep-55, 0x1.ff1fffffa0000p-19, 0x1.fffffc0000000p-79},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-106, 0x1.0000003800001p-1, 0x1.fffffe000003ep-55, -0x1.ff1fffffa0000p-19, -0x1.fffffc0000000p-79},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-106, -0x1.0000003800001p-1, -0x1.fffffe000003ep-55, -0x1.0000401c00001p+0, 0x1.000000fffffe2p-54},
+{0x1.0f00000020000p-1, -0x1.fffe000000100p-55, 0x1.0000000400000p-1, -0x1.ffffffc004000p-68, 0x1.0780000210000p+0, -0x1.0006ffffff080p-54},
+{0x1.0f00000020000p-1, -0x1.fffe000000100p-55, -0x1.0000000400000p-1, 0x1.ffffffc004000p-68, 0x1.dfffff83ffff0p-6, 0x1.1fffffdf02000p-67},
+{-0x1.0f00000020000p-1, 0x1.fffe000000100p-55, 0x1.0000000400000p-1, -0x1.ffffffc004000p-68, -0x1.dfffff83ffff0p-6, -0x1.1fffffdf02000p-67},
+{-0x1.0f00000020000p-1, 0x1.fffe000000100p-55, -0x1.0000000400000p-1, 0x1.ffffffc004000p-68, -0x1.0780000210000p+0, 0x1.0006ffffff080p-54},
+{0x1.003fe00020000p-1, -0x1.ffffffffe8000p-69, 0x1.0000000000400p-1, -0x1.ffff800007ffcp-56, 0x1.001ff00010200p+0, -0x1.0007c00003ff8p-55},
+{0x1.003fe00020000p-1, -0x1.ffffffffe8000p-69, -0x1.0000000000400p-1, 0x1.ffff800007ffcp-56, 0x1.ff0000fe00200p-12, -0x1.07ffff7ff8000p-68},
+{-0x1.003fe00020000p-1, 0x1.ffffffffe8000p-69, 0x1.0000000000400p-1, -0x1.ffff800007ffcp-56, -0x1.ff0000fe00200p-12, 0x1.07ffff7ff8000p-68},
+{-0x1.003fe00020000p-1, 0x1.ffffffffe8000p-69, -0x1.0000000000400p-1, 0x1.ffff800007ffcp-56, -0x1.001ff00010200p+0, 0x1.0007c00003ff8p-55},
+{0x1.ffff00fffffc4p-1, -0x1.8080000000000p-83, 0x1.0000020000000p-1, -0x1.0000000000000p-77, 0x1.7fff817ffffe2p+0, -0x1.0602000000000p-77},
+{0x1.ffff00fffffc4p-1, -0x1.8080000000000p-83, -0x1.0000020000000p-1, 0x1.0000000000000p-77, 0x1.fffdfdfffff88p-2, 0x1.f3fc000000000p-78},
+{-0x1.ffff00fffffc4p-1, 0x1.8080000000000p-83, 0x1.0000020000000p-1, -0x1.0000000000000p-77, -0x1.fffdfdfffff88p-2, -0x1.f3fc000000000p-78},
+{-0x1.ffff00fffffc4p-1, 0x1.8080000000000p-83, -0x1.0000020000000p-1, 0x1.0000000000000p-77, -0x1.7fff817ffffe2p+0, 0x1.0602000000000p-77},
+{0x1.0000000000040p-1, -0x1.8000000800000p-76, 0x1.0000000002000p-1, -0x1.0000000000000p-105, 0x1.0000000001020p+0, -0x1.8000001000000p-76},
+{0x1.0000000000040p-1, -0x1.8000000800000p-76, -0x1.0000000002000p-1, 0x1.0000000000000p-105, -0x1.fc00000030000p-41, 0x0.0000000000000p+0},
+{-0x1.0000000000040p-1, 0x1.8000000800000p-76, 0x1.0000000002000p-1, -0x1.0000000000000p-105, 0x1.fc00000030000p-41, 0x0.0000000000000p+0},
+{-0x1.0000000000040p-1, 0x1.8000000800000p-76, -0x1.0000000002000p-1, 0x1.0000000000000p-105, -0x1.0000000001020p+0, 0x1.8000001000000p-76},
+{0x1.0000000800000p-1, -0x1.ffffc02000000p-79, 0x1.7fffe00800000p-1, -0x1.0000000000000p-106, 0x1.3ffff00800000p+0, -0x1.ffffc04000000p-79},
+{0x1.0000000800000p-1, -0x1.ffffc02000000p-79, -0x1.7fffe00800000p-1, 0x1.0000000000000p-106, -0x1.ffff800000000p-3, -0x1.ffffc00000000p-79},
+{-0x1.0000000800000p-1, 0x1.ffffc02000000p-79, 0x1.7fffe00800000p-1, -0x1.0000000000000p-106, 0x1.ffff800000000p-3, 0x1.ffffc00000000p-79},
+{-0x1.0000000800000p-1, 0x1.ffffc02000000p-79, -0x1.7fffe00800000p-1, 0x1.0000000000000p-106, -0x1.3ffff00800000p+0, 0x1.ffffc04000000p-79},
+{0x1.0000400000000p-1, -0x1.0000000000000p-92, 0x1.4000000000000p-1, -0x1.ffffffff00020p-59, 0x1.2000200000000p+0, -0x1.ffffffff80000p-59},
+{0x1.0000400000000p-1, -0x1.0000000000000p-92, -0x1.4000000000000p-1, 0x1.ffffffff00020p-59, -0x1.fffe000000000p-4, 0x1.fffffffe80020p-59},
+{-0x1.0000400000000p-1, 0x1.0000000000000p-92, 0x1.4000000000000p-1, -0x1.ffffffff00020p-59, 0x1.fffe000000000p-4, -0x1.fffffffe80020p-59},
+{-0x1.0000400000000p-1, 0x1.0000000000000p-92, -0x1.4000000000000p-1, 0x1.ffffffff00020p-59, -0x1.2000200000000p+0, 0x1.ffffffff80000p-59},
+{0x1.0000000000000p-1, 0x1.03eff7ff3fff0p-58, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, 0x1.00000fffe0000p+0, 0x1.42eff83d401e0p-58},
+{0x1.0000000000000p-1, 0x1.03eff7ff3fff0p-58, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, -0x1.fffbfffff9d88p-21, -0x1.07d8040000000p-79},
+{-0x1.0000000000000p-1, -0x1.03eff7ff3fff0p-58, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, 0x1.fffbfffff9d88p-21, 0x1.07d8040000000p-79},
+{-0x1.0000000000000p-1, -0x1.03eff7ff3fff0p-58, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, -0x1.00000fffe0000p+0, -0x1.42eff83d401e0p-58},
+{0x1.03ffffffffffep-1, 0x1.8000000000000p-105, 0x1.0000040000000p-1, -0x1.0000000000000p-106, 0x1.020001fffffffp+0, 0x1.0000000000000p-105},
+{0x1.03ffffffffffep-1, 0x1.8000000000000p-105, -0x1.0000040000000p-1, 0x1.0000000000000p-106, 0x1.fffdfffffff00p-8, 0x1.0000000000000p-104},
+{-0x1.03ffffffffffep-1, -0x1.8000000000000p-105, 0x1.0000040000000p-1, -0x1.0000000000000p-106, -0x1.fffdfffffff00p-8, -0x1.0000000000000p-104},
+{-0x1.03ffffffffffep-1, -0x1.8000000000000p-105, -0x1.0000040000000p-1, 0x1.0000000000000p-106, -0x1.020001fffffffp+0, -0x1.0000000000000p-105},
+{0x1.0007ffffcfffcp-1, 0x1.ff01fffe00000p-75, 0x1.01fff08000000p-1, -0x1.fffffe0000020p-55, 0x1.0103f83fe7ffep+0, -0x1.ffffde0fe0020p-55},
+{0x1.0007ffffcfffcp-1, 0x1.ff01fffe00000p-75, -0x1.01fff08000000p-1, 0x1.fffffe0000020p-55, -0x1.f7f0803000380p-9, 0x1.df02001e00000p-75},
+{-0x1.0007ffffcfffcp-1, -0x1.ff01fffe00000p-75, 0x1.01fff08000000p-1, -0x1.fffffe0000020p-55, 0x1.f7f0803000380p-9, -0x1.df02001e00000p-75},
+{-0x1.0007ffffcfffcp-1, -0x1.ff01fffe00000p-75, -0x1.01fff08000000p-1, 0x1.fffffe0000020p-55, -0x1.0103f83fe7ffep+0, 0x1.ffffde0fe0020p-55},
+{0x1.00000000007fep-1, 0x1.ff00003ffff00p-62, 0x1.004000e000008p-1, -0x1.ffffe02000000p-79, 0x1.0020007000403p+0, 0x1.feff00400fe00p-62},
+{0x1.00000000007fep-1, 0x1.ff00003ffff00p-62, -0x1.004000e000008p-1, 0x1.ffffe02000000p-79, -0x1.00037ffe027fcp-11, -0x1.fdff802000000p-71},
+{-0x1.00000000007fep-1, -0x1.ff00003ffff00p-62, 0x1.004000e000008p-1, -0x1.ffffe02000000p-79, 0x1.00037ffe027fcp-11, 0x1.fdff802000000p-71},
+{-0x1.00000000007fep-1, -0x1.ff00003ffff00p-62, -0x1.004000e000008p-1, 0x1.ffffe02000000p-79, -0x1.0020007000403p+0, -0x1.feff00400fe00p-62},
+{0x1.00000003ff000p-1, 0x1.ffff000000000p-90, 0x1.0000fffff8000p-1, 0x1.f003ffe0003e0p-59, 0x1.00008001fb800p+0, 0x1.f003ffe4003c0p-59},
+{0x1.00000003ff000p-1, 0x1.ffff000000000p-90, -0x1.0000fffff8000p-1, -0x1.f003ffe0003e0p-59, -0x1.fff7f20000f80p-18, -0x1.ffee002000000p-74},
+{-0x1.00000003ff000p-1, -0x1.ffff000000000p-90, 0x1.0000fffff8000p-1, 0x1.f003ffe0003e0p-59, 0x1.fff7f20000f80p-18, 0x1.ffee002000000p-74},
+{-0x1.00000003ff000p-1, -0x1.ffff000000000p-90, -0x1.0000fffff8000p-1, -0x1.f003ffe0003e0p-59, -0x1.00008001fb800p+0, -0x1.f003ffe4003c0p-59},
+{0x1.0000000000000p-1, 0x1.ffe001c0003c0p-60, 0x1.01fffffe00000p-1, 0x1.ffffffffffc00p-59, 0x1.00ffffff00000p+0, 0x1.7ff8006ffff00p-58},
+{0x1.0000000000000p-1, 0x1.ffe001c0003c0p-60, -0x1.01fffffe00000p-1, -0x1.ffffffffffc00p-59, -0x1.fffffe0000004p-9, -0x1.ffe3fff440000p-72},
+{-0x1.0000000000000p-1, -0x1.ffe001c0003c0p-60, 0x1.01fffffe00000p-1, 0x1.ffffffffffc00p-59, 0x1.fffffe0000004p-9, 0x1.ffe3fff440000p-72},
+{-0x1.0000000000000p-1, -0x1.ffe001c0003c0p-60, -0x1.01fffffe00000p-1, -0x1.ffffffffffc00p-59, -0x1.00ffffff00000p+0, -0x1.7ff8006ffff00p-58},
+{0x1.00003ff808000p-1, -0x1.ffe0000800000p-62, 0x1.000001ffff000p-1, 0x1.ff80000000000p-75, 0x1.000020fc03800p+0, -0x1.ffd0040800000p-62},
+{0x1.00003ff808000p-1, -0x1.ffe0000800000p-62, -0x1.000001ffff000p-1, -0x1.ff80000000000p-75, 0x1.efc047ffff800p-20, 0x1.003f800000000p-74},
+{-0x1.00003ff808000p-1, 0x1.ffe0000800000p-62, 0x1.000001ffff000p-1, 0x1.ff80000000000p-75, -0x1.efc047ffff800p-20, -0x1.003f800000000p-74},
+{-0x1.00003ff808000p-1, 0x1.ffe0000800000p-62, -0x1.000001ffff000p-1, -0x1.ff80000000000p-75, -0x1.000020fc03800p+0, 0x1.ffd0040800000p-62},
+{0x1.0000000000000p-1, 0x1.fc007f0ff0000p-63, 0x1.0000000007f80p-1, 0x1.ff0007f802000p-65, 0x1.0000000003fc0p+0, 0x1.3de04086f8400p-62},
+{0x1.0000000000000p-1, 0x1.fc007f0ff0000p-63, -0x1.0000000007f80p-1, -0x1.ff0007f802000p-65, -0x1.fdfffe83bf82fp-39, 0x1.ef80000000000p-95},
+{-0x1.0000000000000p-1, -0x1.fc007f0ff0000p-63, 0x1.0000000007f80p-1, 0x1.ff0007f802000p-65, 0x1.fdfffe83bf82fp-39, -0x1.ef80000000000p-95},
+{-0x1.0000000000000p-1, -0x1.fc007f0ff0000p-63, -0x1.0000000007f80p-1, -0x1.ff0007f802000p-65, -0x1.0000000003fc0p+0, -0x1.3de04086f8400p-62},
+{0x1.0020000000000p-1, -0x1.0000000000000p-78, 0x1.000001ffff802p-1, -0x1.ffffffc000040p-60, 0x1.001000ffffc01p+0, -0x1.00001fe000000p-59},
+{0x1.0020000000000p-1, -0x1.0000000000000p-78, -0x1.000001ffff802p-1, 0x1.ffffffc000040p-60, 0x1.ffe00007fe040p-13, -0x1.00fffff000000p-78},
+{-0x1.0020000000000p-1, 0x1.0000000000000p-78, 0x1.000001ffff802p-1, -0x1.ffffffc000040p-60, -0x1.ffe00007fe040p-13, 0x1.00fffff000000p-78},
+{-0x1.0020000000000p-1, 0x1.0000000000000p-78, -0x1.000001ffff802p-1, 0x1.ffffffc000040p-60, -0x1.001000ffffc01p+0, 0x1.00001fe000000p-59},
+{0x1.0000000000800p-1, -0x1.ffe0000400000p-63, 0x1.0000000000038p-1, 0x1.e100000000000p-75, 0x1.000000000041cp+0, -0x1.ffc1f00400000p-63},
+{0x1.0000000000800p-1, -0x1.ffe0000400000p-63, -0x1.0000000000038p-1, -0x1.e100000000000p-75, 0x1.f1ffe0001effcp-43, 0x0.0000000000000p+0},
+{-0x1.0000000000800p-1, 0x1.ffe0000400000p-63, 0x1.0000000000038p-1, 0x1.e100000000000p-75, -0x1.f1ffe0001effcp-43, 0x0.0000000000000p+0},
+{-0x1.0000000000800p-1, 0x1.ffe0000400000p-63, -0x1.0000000000038p-1, -0x1.e100000000000p-75, -0x1.000000000041cp+0, 0x1.ffc1f00400000p-63},
+{0x1.0000000000020p-1, -0x1.8007ffff80c04p-56, 0x1.0000000000000p-1, 0x1.ffffe00000c00p-64, 0x1.0000000000010p+0, -0x1.7e08001f80bf8p-56},
+{0x1.0000000000020p-1, -0x1.8007ffff80c04p-56, -0x1.0000000000000p-1, -0x1.ffffe00000c00p-64, 0x1.fcfbf00040fe8p-49, -0x1.0000000000000p-104},
+{-0x1.0000000000020p-1, 0x1.8007ffff80c04p-56, 0x1.0000000000000p-1, 0x1.ffffe00000c00p-64, -0x1.fcfbf00040fe8p-49, 0x1.0000000000000p-104},
+{-0x1.0000000000020p-1, 0x1.8007ffff80c04p-56, -0x1.0000000000000p-1, -0x1.ffffe00000c00p-64, -0x1.0000000000010p+0, 0x1.7e08001f80bf8p-56},
+{0x1.7fffffff80000p-1, 0x1.f000000000000p-78, 0x1.000007ffffffep-1, 0x1.ffffff8000000p-77, 0x1.400003ffbffffp+0, 0x1.7bffffc000000p-76},
+{0x1.7fffffff80000p-1, 0x1.f000000000000p-78, -0x1.000007ffffffep-1, -0x1.ffffff8000000p-77, 0x1.ffffdffe00008p-3, -0x1.07ffff8000000p-77},
+{-0x1.7fffffff80000p-1, -0x1.f000000000000p-78, 0x1.000007ffffffep-1, 0x1.ffffff8000000p-77, -0x1.ffffdffe00008p-3, 0x1.07ffff8000000p-77},
+{-0x1.7fffffff80000p-1, -0x1.f000000000000p-78, -0x1.000007ffffffep-1, -0x1.ffffff8000000p-77, -0x1.400003ffbffffp+0, -0x1.7bffffc000000p-76},
+{0x1.0000000010000p-1, -0x1.0000000000000p-87, 0x1.0000000000000p-1, 0x1.c000003ffc3fep-55, 0x1.0000000008000p+0, 0x1.c000003efc400p-55},
+{0x1.0000000010000p-1, -0x1.0000000000000p-87, -0x1.0000000000000p-1, -0x1.c000003ffc3fep-55, 0x1.ffff1fffffdf8p-38, 0x1.e010000000000p-94},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-87, 0x1.0000000000000p-1, 0x1.c000003ffc3fep-55, -0x1.ffff1fffffdf8p-38, -0x1.e010000000000p-94},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-87, -0x1.0000000000000p-1, -0x1.c000003ffc3fep-55, -0x1.0000000008000p+0, -0x1.c000003efc400p-55},
+{0x1.00000ffff0800p-1, -0x1.fff80000ffc20p-59, 0x1.0000000000002p-1, -0x1.0000000000000p-106, 0x1.000007fff8401p+0, -0x1.fff80000ffc40p-59},
+{0x1.00000ffff0800p-1, -0x1.fff80000ffc20p-59, -0x1.0000000000002p-1, 0x1.0000000000000p-106, 0x1.fffe0ffbf0004p-22, -0x1.ff80000000000p-92},
+{-0x1.00000ffff0800p-1, 0x1.fff80000ffc20p-59, 0x1.0000000000002p-1, -0x1.0000000000000p-106, -0x1.fffe0ffbf0004p-22, 0x1.ff80000000000p-92},
+{-0x1.00000ffff0800p-1, 0x1.fff80000ffc20p-59, -0x1.0000000000002p-1, 0x1.0000000000000p-106, -0x1.000007fff8401p+0, 0x1.fff80000ffc40p-59},
+{0x1.000ffffc00000p-1, 0x1.fffff00000000p-70, 0x1.0000000000040p-1, -0x1.0000000000000p-106, 0x1.0007fffe00020p+0, 0x1.fffff00000000p-70},
+{0x1.000ffffc00000p-1, 0x1.fffff00000000p-70, -0x1.0000000000040p-1, 0x1.0000000000000p-106, 0x1.ffff7fff80000p-14, 0x1.fffff00010000p-70},
+{-0x1.000ffffc00000p-1, -0x1.fffff00000000p-70, 0x1.0000000000040p-1, -0x1.0000000000000p-106, -0x1.ffff7fff80000p-14, -0x1.fffff00010000p-70},
+{-0x1.000ffffc00000p-1, -0x1.fffff00000000p-70, -0x1.0000000000040p-1, 0x1.0000000000000p-106, -0x1.0007fffe00020p+0, -0x1.fffff00000000p-70},
+{0x1.0004000000000p-1, -0x1.0000000000000p-69, 0x1.0000000200000p-1, -0x1.ffbffffff8020p-59, 0x1.0002000100000p+0, -0x1.fffffffff8000p-59},
+{0x1.0004000000000p-1, -0x1.0000000000000p-69, -0x1.0000000200000p-1, 0x1.ffbffffff8020p-59, 0x1.ffff0000003ffp-16, -0x1.ff80000000000p-97},
+{-0x1.0004000000000p-1, 0x1.0000000000000p-69, 0x1.0000000200000p-1, -0x1.ffbffffff8020p-59, -0x1.ffff0000003ffp-16, 0x1.ff80000000000p-97},
+{-0x1.0004000000000p-1, 0x1.0000000000000p-69, -0x1.0000000200000p-1, 0x1.ffbffffff8020p-59, -0x1.0002000100000p+0, 0x1.fffffffff8000p-59},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, 0x1.0000001fffffep-1, 0x0.0000000000000p+0, 0x1.0000000ffffffp+0, 0x1.e0001e7fc0000p-62},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, -0x1.0000001fffffep-1, 0x0.0000000000000p+0, -0x1.fffffdff0ffffp-29, -0x1.8040100000000p-86},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, 0x1.0000001fffffep-1, 0x0.0000000000000p+0, 0x1.fffffdff0ffffp-29, 0x1.8040100000000p-86},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, -0x1.0000001fffffep-1, 0x0.0000000000000p+0, -0x1.0000000ffffffp+0, -0x1.e0001e7fc0000p-62},
+{0x1.0000000000fffp-1, 0x1.fffff3e000000p-74, 0x1.001ffe0000000p-1, 0x1.fffffffffffc0p-60, 0x1.000fff0000800p+0, -0x1.f7ffe00000c20p-54},
+{0x1.0000000000fffp-1, 0x1.fffff3e000000p-74, -0x1.001ffe0000000p-1, -0x1.fffffffffffc0p-60, -0x1.ffdffff001040p-13, 0x1.fffff3e100000p-74},
+{-0x1.0000000000fffp-1, -0x1.fffff3e000000p-74, 0x1.001ffe0000000p-1, 0x1.fffffffffffc0p-60, 0x1.ffdffff001040p-13, -0x1.fffff3e100000p-74},
+{-0x1.0000000000fffp-1, -0x1.fffff3e000000p-74, -0x1.001ffe0000000p-1, -0x1.fffffffffffc0p-60, -0x1.000fff0000800p+0, 0x1.f7ffe00000c20p-54},
+{0x1.0000080000000p-1, -0x1.0000000000000p-106, 0x1.0000000080000p-1, -0x1.0000000000000p-56, 0x1.0000040040000p+0, -0x1.0000000000000p-56},
+{0x1.0000080000000p-1, -0x1.0000000000000p-106, -0x1.0000000080000p-1, 0x1.0000000000000p-56, 0x1.ffe0000080000p-23, -0x1.0000000000000p-106},
+{-0x1.0000080000000p-1, 0x1.0000000000000p-106, 0x1.0000000080000p-1, -0x1.0000000000000p-56, -0x1.ffe0000080000p-23, 0x1.0000000000000p-106},
+{-0x1.0000080000000p-1, 0x1.0000000000000p-106, -0x1.0000000080000p-1, 0x1.0000000000000p-56, -0x1.0000040040000p+0, 0x1.0000000000000p-56},
+{0x1.003ffffffffe0p-1, 0x1.ffffe03800000p-77, 0x1.0000000002000p-1, -0x1.0000000000000p-54, 0x1.0020000000ff0p+0, -0x1.fffff800007f0p-55},
+{0x1.003ffffffffe0p-1, 0x1.ffffe03800000p-77, -0x1.0000000002000p-1, 0x1.0000000000000p-54, 0x1.ffffffeff0400p-12, 0x1.ffffe03800000p-77},
+{-0x1.003ffffffffe0p-1, -0x1.ffffe03800000p-77, 0x1.0000000002000p-1, -0x1.0000000000000p-54, -0x1.ffffffeff0400p-12, -0x1.ffffe03800000p-77},
+{-0x1.003ffffffffe0p-1, -0x1.ffffe03800000p-77, -0x1.0000000002000p-1, 0x1.0000000000000p-54, -0x1.0020000000ff0p+0, 0x1.fffff800007f0p-55},
+{0x1.0000000000008p-1, -0x1.ff000007ffc00p-61, 0x1.0000000060000p-1, 0x1.ffffff8000000p-81, 0x1.0000000030004p+0, -0x1.feffe007ffc00p-61},
+{0x1.0000000000008p-1, -0x1.ff000007ffc00p-61, -0x1.0000000060000p-1, -0x1.ffffff8000000p-81, -0x1.7ffe007fc0080p-35, -0x1.ffee000000000p-91},
+{-0x1.0000000000008p-1, 0x1.ff000007ffc00p-61, 0x1.0000000060000p-1, 0x1.ffffff8000000p-81, 0x1.7ffe007fc0080p-35, 0x1.ffee000000000p-91},
+{-0x1.0000000000008p-1, 0x1.ff000007ffc00p-61, -0x1.0000000060000p-1, -0x1.ffffff8000000p-81, -0x1.0000000030004p+0, 0x1.feffe007ffc00p-61},
+{0x1.0000000000080p-1, -0x1.0000000000000p-106, 0x1.01ffffff80001p-1, -0x1.ff90000000000p-94, 0x1.00ffffffc0040p+0, 0x1.fffffffffe006p-54},
+{0x1.0000000000080p-1, -0x1.0000000000000p-106, -0x1.01ffffff80001p-1, 0x1.ff90000000000p-94, -0x1.ffffff7ff8100p-9, 0x1.ff80000000000p-94},
+{-0x1.0000000000080p-1, 0x1.0000000000000p-106, 0x1.01ffffff80001p-1, -0x1.ff90000000000p-94, 0x1.ffffff7ff8100p-9, -0x1.ff80000000000p-94},
+{-0x1.0000000000080p-1, 0x1.0000000000000p-106, -0x1.01ffffff80001p-1, 0x1.ff90000000000p-94, -0x1.00ffffffc0040p+0, -0x1.fffffffffe006p-54},
+{0x1.0000000000800p-1, -0x1.fffff80002000p-67, 0x1.0008000000000p-1, -0x1.0000000000000p-80, 0x1.0004000000400p+0, -0x1.0003fc0000000p-66},
+{0x1.0000000000800p-1, -0x1.fffff80002000p-67, -0x1.0008000000000p-1, 0x1.0000000000000p-80, -0x1.ffffffe000002p-15, 0x1.00ffffc000000p-80},
+{-0x1.0000000000800p-1, 0x1.fffff80002000p-67, 0x1.0008000000000p-1, -0x1.0000000000000p-80, 0x1.ffffffe000002p-15, -0x1.00ffffc000000p-80},
+{-0x1.0000000000800p-1, 0x1.fffff80002000p-67, -0x1.0008000000000p-1, 0x1.0000000000000p-80, -0x1.0004000000400p+0, 0x1.0003fc0000000p-66},
+{0x1.0000000000002p-1, -0x1.ffffffe200000p-75, 0x1.0003fffffffc0p-1, 0x1.ffffe00000400p-64, 0x1.0001fffffffe1p+0, 0x1.ffbfe00004000p-64},
+{0x1.0000000000002p-1, -0x1.ffffffe200000p-75, -0x1.0003fffffffc0p-1, -0x1.ffffe00000400p-64, -0x1.fffffffdf0020p-16, -0x1.feffffe400000p-75},
+{-0x1.0000000000002p-1, 0x1.ffffffe200000p-75, 0x1.0003fffffffc0p-1, 0x1.ffffe00000400p-64, 0x1.fffffffdf0020p-16, 0x1.feffffe400000p-75},
+{-0x1.0000000000002p-1, 0x1.ffffffe200000p-75, -0x1.0003fffffffc0p-1, -0x1.ffffe00000400p-64, -0x1.0001fffffffe1p+0, -0x1.ffbfe00004000p-64},
+{0x1.000003f000000p-1, 0x1.fffffffe00000p-62, 0x1.0000000000ff0p-1, 0x1.c03fff0e00000p-75, 0x1.000001f8007f8p+0, 0x1.000700fefc400p-61},
+{0x1.000003f000000p-1, 0x1.fffffffe00000p-62, -0x1.0000000000ff0p-1, -0x1.c03fff0e00000p-75, 0x1.f7ff808007ffcp-24, 0x1.fdfe079000000p-78},
+{-0x1.000003f000000p-1, -0x1.fffffffe00000p-62, 0x1.0000000000ff0p-1, 0x1.c03fff0e00000p-75, -0x1.f7ff808007ffcp-24, -0x1.fdfe079000000p-78},
+{-0x1.000003f000000p-1, -0x1.fffffffe00000p-62, -0x1.0000000000ff0p-1, -0x1.c03fff0e00000p-75, -0x1.000001f8007f8p+0, -0x1.000700fefc400p-61},
+{0x1.0000000018000p-1, 0x1.fffffe0000000p-83, 0x1.0000100000000p-1, -0x1.0000000000000p-106, 0x1.000008000c000p+0, 0x1.fffffc0000000p-83},
+{0x1.0000000018000p-1, 0x1.fffffe0000000p-83, -0x1.0000100000000p-1, 0x1.0000000000000p-106, -0x1.fffd000000000p-22, 0x1.0000000000000p-82},
+{-0x1.0000000018000p-1, -0x1.fffffe0000000p-83, 0x1.0000100000000p-1, -0x1.0000000000000p-106, 0x1.fffd000000000p-22, -0x1.0000000000000p-82},
+{-0x1.0000000018000p-1, -0x1.fffffe0000000p-83, -0x1.0000100000000p-1, 0x1.0000000000000p-106, -0x1.000008000c000p+0, -0x1.fffffc0000000p-83},
+{0x1.0000000000001p-1, -0x1.fffffc1000000p-68, 0x1.1ffffff01f000p-1, 0x1.ffffc000060fcp-56, 0x1.0ffffff80f801p+0, -0x1.80080fffeebc0p-54},
+{0x1.0000000000001p-1, -0x1.fffffc1000000p-68, -0x1.1ffffff01f000p-1, -0x1.ffffc000060fcp-56, -0x1.ffffff01efff4p-5, -0x1.fbfffc70fc000p-68},
+{-0x1.0000000000001p-1, 0x1.fffffc1000000p-68, 0x1.1ffffff01f000p-1, 0x1.ffffc000060fcp-56, 0x1.ffffff01efff4p-5, 0x1.fbfffc70fc000p-68},
+{-0x1.0000000000001p-1, 0x1.fffffc1000000p-68, -0x1.1ffffff01f000p-1, -0x1.ffffc000060fcp-56, -0x1.0ffffff80f801p+0, 0x1.80080fffeebc0p-54},
+{0x1.0000003800000p-1, 0x1.ffe000001fffcp-56, 0x1.0000007fffff0p-1, 0x1.fe1ffffc00000p-63, 0x1.0000005bffff8p+0, 0x1.01ee20000c000p-55},
+{0x1.0000003800000p-1, 0x1.ffe000001fffcp-56, -0x1.0000007fffff0p-1, -0x1.fe1ffffc00000p-63, -0x1.1ffffbf020e20p-27, 0x1.3ffe000000000p-91},
+{-0x1.0000003800000p-1, -0x1.ffe000001fffcp-56, 0x1.0000007fffff0p-1, 0x1.fe1ffffc00000p-63, 0x1.1ffffbf020e20p-27, -0x1.3ffe000000000p-91},
+{-0x1.0000003800000p-1, -0x1.ffe000001fffcp-56, -0x1.0000007fffff0p-1, -0x1.fe1ffffc00000p-63, -0x1.0000005bffff8p+0, -0x1.01ee20000c000p-55},
+{0x1.0000001fffc00p-1, 0x1.f00007ffe0000p-65, 0x1.0000000000180p-1, 0x1.fffffe0000800p-65, 0x1.0000000fffec0p+0, 0x1.f80002fff0000p-64},
+{0x1.0000001fffc00p-1, 0x1.f00007ffe0000p-65, -0x1.0000000000180p-1, -0x1.fffffe0000800p-65, 0x1.fffa7fffff000p-29, 0x1.3ffbf00000000p-86},
+{-0x1.0000001fffc00p-1, -0x1.f00007ffe0000p-65, 0x1.0000000000180p-1, 0x1.fffffe0000800p-65, -0x1.fffa7fffff000p-29, -0x1.3ffbf00000000p-86},
+{-0x1.0000001fffc00p-1, -0x1.f00007ffe0000p-65, -0x1.0000000000180p-1, -0x1.fffffe0000800p-65, -0x1.0000000fffec0p+0, -0x1.f80002fff0000p-64},
+{0x1.0000000008000p-1, -0x1.c0000007ffe04p-56, 0x1.00000fffffffep-1, 0x1.fc00000000000p-100, 0x1.0000080003fffp+0, -0x1.c0000007ffc08p-56},
+{0x1.0000000008000p-1, -0x1.c0000007ffe04p-56, -0x1.00000fffffffep-1, -0x1.fc00000000000p-100, -0x1.fffefffc70000p-22, -0x1.0000000000000p-85},
+{-0x1.0000000008000p-1, 0x1.c0000007ffe04p-56, 0x1.00000fffffffep-1, 0x1.fc00000000000p-100, 0x1.fffefffc70000p-22, 0x1.0000000000000p-85},
+{-0x1.0000000008000p-1, 0x1.c0000007ffe04p-56, -0x1.00000fffffffep-1, -0x1.fc00000000000p-100, -0x1.0000080003fffp+0, 0x1.c0000007ffc08p-56},
+{0x1.0000003e00004p-1, -0x1.fe00040000000p-71, 0x1.00007c0001e00p-1, 0x1.fffe13ffe0000p-65, 0x1.00003e1f00f02p+0, 0x1.f80613efe0000p-65},
+{0x1.0000003e00004p-1, -0x1.fe00040000000p-71, -0x1.00007c0001e00p-1, -0x1.fffe13ffe0000p-65, -0x1.ef08077f00082p-19, 0x1.3d7e040000000p-78},
+{-0x1.0000003e00004p-1, 0x1.fe00040000000p-71, 0x1.00007c0001e00p-1, 0x1.fffe13ffe0000p-65, 0x1.ef08077f00082p-19, -0x1.3d7e040000000p-78},
+{-0x1.0000003e00004p-1, 0x1.fe00040000000p-71, -0x1.00007c0001e00p-1, -0x1.fffe13ffe0000p-65, -0x1.00003e1f00f02p+0, -0x1.f80613efe0000p-65},
+{0x1.03fffffffc000p-1, 0x1.ffffffc000000p-76, 0x1.0003ffffff000p-1, 0x1.ffc0000000000p-96, 0x1.0201fffffd800p+0, 0x1.00000fe000000p-75},
+{0x1.03fffffffc000p-1, 0x1.ffffffc000000p-76, -0x1.0003ffffff000p-1, -0x1.ffc0000000000p-96, 0x1.fdfffffe80000p-8, 0x1.ffffdfc400000p-76},
+{-0x1.03fffffffc000p-1, -0x1.ffffffc000000p-76, 0x1.0003ffffff000p-1, 0x1.ffc0000000000p-96, -0x1.fdfffffe80000p-8, -0x1.ffffdfc400000p-76},
+{-0x1.03fffffffc000p-1, -0x1.ffffffc000000p-76, -0x1.0003ffffff000p-1, -0x1.ffc0000000000p-96, -0x1.0201fffffd800p+0, -0x1.00000fe000000p-75},
+{0x1.07ffffff80000p-1, 0x1.8007ffffc0000p-72, 0x1.0000000000004p-1, -0x1.fffc000200000p-70, 0x1.03ffffffc0002p+0, -0x1.9ffa000200000p-70},
+{0x1.07ffffff80000p-1, 0x1.8007ffffc0000p-72, -0x1.0000000000004p-1, 0x1.fffc000200000p-70, 0x1.ffffffdffff00p-7, 0x1.2fff0000f8000p-69},
+{-0x1.07ffffff80000p-1, -0x1.8007ffffc0000p-72, 0x1.0000000000004p-1, -0x1.fffc000200000p-70, -0x1.ffffffdffff00p-7, -0x1.2fff0000f8000p-69},
+{-0x1.07ffffff80000p-1, -0x1.8007ffffc0000p-72, -0x1.0000000000004p-1, 0x1.fffc000200000p-70, -0x1.03ffffffc0002p+0, 0x1.9ffa000200000p-70},
+{0x1.00003ffffff80p-1, 0x1.ffff0000ffe00p-63, 0x1.00003fffffff8p-1, 0x0.0000000000000p+0, 0x1.00003ffffffbcp+0, 0x1.ffff000100000p-63},
+{0x1.00003ffffff80p-1, 0x1.ffff0000ffe00p-63, -0x1.00003fffffff8p-1, 0x0.0000000000000p+0, -0x1.dffe0000ffff0p-47, -0x1.0000000000000p-106},
+{-0x1.00003ffffff80p-1, -0x1.ffff0000ffe00p-63, 0x1.00003fffffff8p-1, 0x0.0000000000000p+0, 0x1.dffe0000ffff0p-47, 0x1.0000000000000p-106},
+{-0x1.00003ffffff80p-1, -0x1.ffff0000ffe00p-63, -0x1.00003fffffff8p-1, 0x0.0000000000000p+0, -0x1.00003ffffffbcp+0, -0x1.ffff000100000p-63},
+{0x1.0000010000000p-1, -0x1.0000000000000p-106, 0x1.00f81ffffff81p-1, 0x1.fffff03c00000p-63, 0x1.007c107ffffc1p+0, -0x1.ff000007e2000p-54},
+{0x1.0000010000000p-1, -0x1.0000000000000p-106, -0x1.00f81ffffff81p-1, -0x1.fffff03c00000p-63, -0x1.f03dfffff0201p-10, 0x1.f87ffc0000000p-84},
+{-0x1.0000010000000p-1, 0x1.0000000000000p-106, 0x1.00f81ffffff81p-1, 0x1.fffff03c00000p-63, 0x1.f03dfffff0201p-10, -0x1.f87ffc0000000p-84},
+{-0x1.0000010000000p-1, 0x1.0000000000000p-106, -0x1.00f81ffffff81p-1, -0x1.fffff03c00000p-63, -0x1.007c107ffffc1p+0, 0x1.ff000007e2000p-54},
+{0x1.0000000000004p-1, -0x1.fff0008000000p-65, 0x1.0000000100000p-1, -0x1.fffffe0004000p-68, 0x1.0000000080002p+0, -0x1.1ff8002000000p-64},
+{0x1.0000000000004p-1, -0x1.fff0008000000p-65, -0x1.0000000100000p-1, 0x1.fffffe0004000p-68, -0x1.ffff80037fe00p-34, -0x1.7fff000000000p-90},
+{-0x1.0000000000004p-1, 0x1.fff0008000000p-65, 0x1.0000000100000p-1, -0x1.fffffe0004000p-68, 0x1.ffff80037fe00p-34, 0x1.7fff000000000p-90},
+{-0x1.0000000000004p-1, 0x1.fff0008000000p-65, -0x1.0000000100000p-1, 0x1.fffffe0004000p-68, -0x1.0000000080002p+0, 0x1.1ff8002000000p-64},
+{0x1.0000000000800p-1, -0x1.0000000000000p-79, 0x1.0000010000000p-1, -0x1.0000000000000p-104, 0x1.0000008000400p+0, -0x1.0000008000000p-79},
+{0x1.0000000000800p-1, -0x1.0000000000000p-79, -0x1.0000010000000p-1, 0x1.0000000000000p-104, -0x1.ffff000000000p-26, -0x1.ffffff0000000p-80},
+{-0x1.0000000000800p-1, 0x1.0000000000000p-79, 0x1.0000010000000p-1, -0x1.0000000000000p-104, 0x1.ffff000000000p-26, 0x1.ffffff0000000p-80},
+{-0x1.0000000000800p-1, 0x1.0000000000000p-79, -0x1.0000010000000p-1, 0x1.0000000000000p-104, -0x1.0000008000400p+0, 0x1.0000008000000p-79},
+{0x1.00000007fff00p-1, 0x1.fffc1ffff87f0p-57, 0x1.0000007c00000p-1, 0x1.fff0000000000p-72, 0x1.00000041fff80p+0, 0x1.00000feffc3f8p-56},
+{0x1.00000007fff00p-1, 0x1.fffc1ffff87f0p-57, -0x1.0000007c00000p-1, -0x1.fff0000000000p-72, -0x1.d0003ff8001f8p-27, 0x1.ff87f00000000p-85},
+{-0x1.00000007fff00p-1, -0x1.fffc1ffff87f0p-57, 0x1.0000007c00000p-1, 0x1.fff0000000000p-72, 0x1.d0003ff8001f8p-27, -0x1.ff87f00000000p-85},
+{-0x1.00000007fff00p-1, -0x1.fffc1ffff87f0p-57, -0x1.0000007c00000p-1, -0x1.fff0000000000p-72, -0x1.00000041fff80p+0, -0x1.00000feffc3f8p-56},
+{0x1.fffffffe00000p-1, 0x1.e000001fff800p-65, 0x1.00000001ffffep-1, 0x0.0000000000000p+0, 0x1.7ffffffffffffp+0, 0x1.e000002000000p-65},
+{0x1.fffffffe00000p-1, 0x1.e000001fff800p-65, -0x1.00000001ffffep-1, 0x0.0000000000000p+0, 0x1.fffffff800004p-2, 0x1.e000001fff800p-65},
+{-0x1.fffffffe00000p-1, -0x1.e000001fff800p-65, 0x1.00000001ffffep-1, 0x0.0000000000000p+0, -0x1.fffffff800004p-2, -0x1.e000001fff800p-65},
+{-0x1.fffffffe00000p-1, -0x1.e000001fff800p-65, -0x1.00000001ffffep-1, 0x0.0000000000000p+0, -0x1.7ffffffffffffp+0, -0x1.e000002000000p-65},
+{0x1.0000000000008p-1, -0x1.fffff00400000p-73, 0x1.00003ffffe000p-1, 0x1.ffffe00000000p-73, 0x1.00001fffff004p+0, -0x1.0040000000000p-93},
+{0x1.0000000000008p-1, -0x1.fffff00400000p-73, -0x1.00003ffffe000p-1, -0x1.ffffe00000000p-73, -0x1.ffffeffc00002p-20, 0x1.7fe0000000000p-92},
+{-0x1.0000000000008p-1, 0x1.fffff00400000p-73, 0x1.00003ffffe000p-1, 0x1.ffffe00000000p-73, 0x1.ffffeffc00002p-20, -0x1.7fe0000000000p-92},
+{-0x1.0000000000008p-1, 0x1.fffff00400000p-73, -0x1.00003ffffe000p-1, -0x1.ffffe00000000p-73, -0x1.00001fffff004p+0, 0x1.0040000000000p-93},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, 0x1.000001ffe0000p-1, 0x1.ff87ff9f801c0p-60, 0x1.000000fff0000p+0, 0x1.0fc3ffcfc00c0p-59},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, -0x1.000001ffe0000p-1, -0x1.ff87ff9f801c0p-60, -0x1.ffe000003bf10p-25, 0x1.81ff800000000p-86},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, 0x1.000001ffe0000p-1, 0x1.ff87ff9f801c0p-60, 0x1.ffe000003bf10p-25, -0x1.81ff800000000p-86},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, -0x1.000001ffe0000p-1, -0x1.ff87ff9f801c0p-60, -0x1.000000fff0000p+0, -0x1.0fc3ffcfc00c0p-59},
+{0x1.0000000000400p-1, -0x1.f800000002000p-62, 0x1.03fffffffff00p-1, 0x1.fffe7fffffffep-55, 0x1.0200000000180p+0, 0x1.fc0e7ffffffc0p-55},
+{0x1.0000000000400p-1, -0x1.f800000002000p-62, -0x1.03fffffffff00p-1, -0x1.fffe7fffffffep-55, -0x1.ffffffffd8040p-8, -0x1.f740000001f00p-62},
+{-0x1.0000000000400p-1, 0x1.f800000002000p-62, 0x1.03fffffffff00p-1, 0x1.fffe7fffffffep-55, 0x1.ffffffffd8040p-8, 0x1.f740000001f00p-62},
+{-0x1.0000000000400p-1, 0x1.f800000002000p-62, -0x1.03fffffffff00p-1, -0x1.fffe7fffffffep-55, -0x1.0200000000180p+0, -0x1.fc0e7ffffffc0p-55},
+{0x1.0000000000000p-1, 0x1.fffffffffff00p-57, 0x1.000007c000000p-1, 0x1.fff8000000000p-57, 0x1.000003e000000p+0, 0x1.fffbfffffff80p-56},
+{0x1.0000000000000p-1, 0x1.fffffffffff00p-57, -0x1.000007c000000p-1, -0x1.fff8000000000p-57, -0x1.effffffffffe0p-23, -0x1.0000000000000p-101},
+{-0x1.0000000000000p-1, -0x1.fffffffffff00p-57, 0x1.000007c000000p-1, 0x1.fff8000000000p-57, 0x1.effffffffffe0p-23, 0x1.0000000000000p-101},
+{-0x1.0000000000000p-1, -0x1.fffffffffff00p-57, -0x1.000007c000000p-1, -0x1.fff8000000000p-57, -0x1.000003e000000p+0, -0x1.fffbfffffff80p-56},
+{0x1.0000000000400p-1, -0x1.fffc0003fffd0p-58, 0x1.0000000000000p-1, 0x1.fffffff800000p-57, 0x1.0000000000200p+0, 0x1.0001fff600020p-57},
+{0x1.0000000000400p-1, -0x1.fffc0003fffd0p-58, -0x1.0000000000000p-1, -0x1.fffffff800000p-57, 0x1.ffe8001000300p-44, 0x1.8000000000000p-105},
+{-0x1.0000000000400p-1, 0x1.fffc0003fffd0p-58, 0x1.0000000000000p-1, 0x1.fffffff800000p-57, -0x1.ffe8001000300p-44, -0x1.8000000000000p-105},
+{-0x1.0000000000400p-1, 0x1.fffc0003fffd0p-58, -0x1.0000000000000p-1, -0x1.fffffff800000p-57, -0x1.0000000000200p+0, -0x1.0001fff600020p-57},
+{0x1.0000000002000p-1, -0x1.ffff040000000p-72, 0x1.03fffff800000p-1, 0x1.fffffe0000000p-69, 0x1.01fffffc01000p+0, 0x1.c0001d8000000p-69},
+{0x1.0000000002000p-1, -0x1.ffff040000000p-72, -0x1.03fffff800000p-1, -0x1.fffffe0000000p-69, -0x1.fffffbff00000p-8, -0x1.1fffef4000000p-68},
+{-0x1.0000000002000p-1, 0x1.ffff040000000p-72, 0x1.03fffff800000p-1, 0x1.fffffe0000000p-69, 0x1.fffffbff00000p-8, 0x1.1fffef4000000p-68},
+{-0x1.0000000002000p-1, 0x1.ffff040000000p-72, -0x1.03fffff800000p-1, -0x1.fffffe0000000p-69, -0x1.01fffffc01000p+0, -0x1.c0001d8000000p-69},
+{0x1.0000008000000p-1, -0x1.ffffff8200000p-58, 0x1.000fff8000000p-1, 0x1.fffffe0000000p-63, 0x1.0008000000000p+0, -0x1.efffff9200000p-58},
+{0x1.0000008000000p-1, -0x1.ffffff8200000p-58, -0x1.000fff8000000p-1, -0x1.fffffe0000000p-63, -0x1.ffe0000000210p-14, 0x1.1c00000000000p-83},
+{-0x1.0000008000000p-1, 0x1.ffffff8200000p-58, 0x1.000fff8000000p-1, 0x1.fffffe0000000p-63, 0x1.ffe0000000210p-14, -0x1.1c00000000000p-83},
+{-0x1.0000008000000p-1, 0x1.ffffff8200000p-58, -0x1.000fff8000000p-1, -0x1.fffffe0000000p-63, -0x1.0008000000000p+0, 0x1.efffff9200000p-58},
+{0x1.0000000000000p-1, 0x1.0001f9e000000p-61, 0x1.0000000000040p-1, -0x1.fffffc0080000p-73, 0x1.0000000000020p+0, 0x1.ffc3f3c080000p-62},
+{0x1.0000000000000p-1, 0x1.0001f9e000000p-61, -0x1.0000000000040p-1, 0x1.fffffc0080000p-73, -0x1.fff7fef031020p-48, 0x1.0000000000000p-106},
+{-0x1.0000000000000p-1, -0x1.0001f9e000000p-61, 0x1.0000000000040p-1, -0x1.fffffc0080000p-73, 0x1.fff7fef031020p-48, -0x1.0000000000000p-106},
+{-0x1.0000000000000p-1, -0x1.0001f9e000000p-61, -0x1.0000000000040p-1, 0x1.fffffc0080000p-73, -0x1.0000000000020p+0, -0x1.ffc3f3c080000p-62},
+{0x1.0000ff0007e00p-1, 0x1.ffc001ff00000p-68, 0x1.0000010000000p-1, -0x1.ffc007ffffe20p-59, 0x1.0000800003f00p+0, -0x1.fec027ff00600p-59},
+{0x1.0000ff0007e00p-1, 0x1.ffc001ff00000p-68, -0x1.0000010000000p-1, 0x1.ffc007ffffe20p-59, 0x1.fc000fc001006p-18, -0x1.7ff009e000000p-79},
+{-0x1.0000ff0007e00p-1, -0x1.ffc001ff00000p-68, 0x1.0000010000000p-1, -0x1.ffc007ffffe20p-59, -0x1.fc000fc001006p-18, 0x1.7ff009e000000p-79},
+{-0x1.0000ff0007e00p-1, -0x1.ffc001ff00000p-68, -0x1.0000010000000p-1, 0x1.ffc007ffffe20p-59, -0x1.0000800003f00p+0, 0x1.fec027ff00600p-59},
+{0x1.07ffffff1fe00p-1, 0x1.fc00000000000p-98, 0x1.0040000000000p-1, -0x1.c000000400000p-62, 0x1.041fffff8ff00p+0, -0x1.c0000003e0400p-62},
+{0x1.07ffffff1fe00p-1, 0x1.fc00000000000p-98, -0x1.0040000000000p-1, 0x1.c000000400000p-62, 0x1.efffffc7f8000p-7, 0x1.c00000041fc00p-62},
+{-0x1.07ffffff1fe00p-1, -0x1.fc00000000000p-98, 0x1.0040000000000p-1, -0x1.c000000400000p-62, -0x1.efffffc7f8000p-7, -0x1.c00000041fc00p-62},
+{-0x1.07ffffff1fe00p-1, -0x1.fc00000000000p-98, -0x1.0040000000000p-1, 0x1.c000000400000p-62, -0x1.041fffff8ff00p+0, 0x1.c0000003e0400p-62},
+{0x1.0080000000000p-1, -0x1.0000000000000p-106, 0x1.00000001fffc0p-1, 0x1.fffff80f80000p-73, 0x1.00400000fffe0p+0, 0x1.fffff80f00000p-73},
+{0x1.0080000000000p-1, -0x1.0000000000000p-106, -0x1.00000001fffc0p-1, -0x1.fffff80f80000p-73, 0x1.fffff80010000p-11, -0x1.fffff81000000p-73},
+{-0x1.0080000000000p-1, 0x1.0000000000000p-106, 0x1.00000001fffc0p-1, 0x1.fffff80f80000p-73, -0x1.fffff80010000p-11, 0x1.fffff81000000p-73},
+{-0x1.0080000000000p-1, 0x1.0000000000000p-106, -0x1.00000001fffc0p-1, -0x1.fffff80f80000p-73, -0x1.00400000fffe0p+0, -0x1.fffff80f00000p-73},
+{0x1.000000003ff00p-1, 0x0.0000000000000p+0, 0x1.0000000000000p-1, 0x1.f83007ffffe00p-61, 0x1.000000001ff80p+0, 0x1.f83007ffffe00p-61},
+{0x1.000000003ff00p-1, 0x0.0000000000000p+0, -0x1.0000000000000p-1, -0x1.f83007ffffe00p-61, 0x1.ff7fff03e7fc0p-36, 0x1.0000000000000p-104},
+{-0x1.000000003ff00p-1, 0x0.0000000000000p+0, 0x1.0000000000000p-1, 0x1.f83007ffffe00p-61, -0x1.ff7fff03e7fc0p-36, -0x1.0000000000000p-104},
+{-0x1.000000003ff00p-1, 0x0.0000000000000p+0, -0x1.0000000000000p-1, -0x1.f83007ffffe00p-61, -0x1.000000001ff80p+0, -0x1.f83007ffffe00p-61},
+{0x1.00003fffffe00p-1, 0x1.fffffc0000380p-61, 0x1.0000010000000p-1, -0x1.ffffff8000008p-57, 0x1.0000207ffff00p+0, -0x1.dfffffbffffd0p-57},
+{0x1.00003fffffe00p-1, 0x1.fffffc0000380p-61, -0x1.0000010000000p-1, 0x1.ffffff8000008p-57, 0x1.f7ffff0011000p-20, -0x1.7ffff80000000p-82},
+{-0x1.00003fffffe00p-1, -0x1.fffffc0000380p-61, 0x1.0000010000000p-1, -0x1.ffffff8000008p-57, -0x1.f7ffff0011000p-20, 0x1.7ffff80000000p-82},
+{-0x1.00003fffffe00p-1, -0x1.fffffc0000380p-61, -0x1.0000010000000p-1, 0x1.ffffff8000008p-57, -0x1.0000207ffff00p+0, 0x1.dfffffbffffd0p-57},
+{0x1.0000000080000p-1, -0x1.fffffc0010000p-70, 0x1.3fffff8000000p-1, 0x1.fffff800fe000p-67, 0x1.1fffffc040000p+0, 0x1.bffff880fc000p-67},
+{0x1.0000000080000p-1, -0x1.fffffc0010000p-70, -0x1.3fffff8000000p-1, -0x1.fffff800fe000p-67, -0x1.fffffbfc00000p-4, -0x1.1ffffbc080000p-66},
+{-0x1.0000000080000p-1, 0x1.fffffc0010000p-70, 0x1.3fffff8000000p-1, 0x1.fffff800fe000p-67, 0x1.fffffbfc00000p-4, 0x1.1ffffbc080000p-66},
+{-0x1.0000000080000p-1, 0x1.fffffc0010000p-70, -0x1.3fffff8000000p-1, -0x1.fffff800fe000p-67, -0x1.1fffffc040000p+0, -0x1.bffff880fc000p-67},
+{0x1.0003f001fc3f0p-1, 0x1.fffffc0000000p-57, 0x1.0000000000000p-1, 0x1.fc1fffc0000fep-55, 0x1.0001f800fe1f8p+0, 0x1.3e0fff6000080p-54},
+{0x1.0003f001fc3f0p-1, 0x1.fffffc0000000p-57, -0x1.0000000000000p-1, -0x1.fc1fffc0000fep-55, 0x1.f800fe1f7d07cp-16, -0x1.80001fc000000p-80},
+{-0x1.0003f001fc3f0p-1, -0x1.fffffc0000000p-57, 0x1.0000000000000p-1, 0x1.fc1fffc0000fep-55, -0x1.f800fe1f7d07cp-16, 0x1.80001fc000000p-80},
+{-0x1.0003f001fc3f0p-1, -0x1.fffffc0000000p-57, -0x1.0000000000000p-1, -0x1.fc1fffc0000fep-55, -0x1.0001f800fe1f8p+0, -0x1.3e0fff6000080p-54},
+{0x1.0000000000000p-1, 0x1.fffffffffffc0p-60, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-63, 0x1.0000000000000p+0, 0x1.1ffffffffffc0p-59},
+{0x1.0000000000000p-1, 0x1.fffffffffffc0p-60, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-63, 0x1.c000000000000p-60, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffffffffffc0p-60, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-63, -0x1.c000000000000p-60, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffffffffffc0p-60, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-63, -0x1.0000000000000p+0, -0x1.1ffffffffffc0p-59},
+{0x1.0000000100000p-1, -0x1.0000000000000p-80, 0x1.0000004000000p-1, -0x1.0000000000000p-81, 0x1.0000002080000p+0, -0x1.8000000000000p-80},
+{0x1.0000000100000p-1, -0x1.0000000000000p-80, -0x1.0000004000000p-1, 0x1.0000000000000p-81, -0x1.f800000000000p-28, -0x1.0000000000000p-81},
+{-0x1.0000000100000p-1, 0x1.0000000000000p-80, 0x1.0000004000000p-1, -0x1.0000000000000p-81, 0x1.f800000000000p-28, 0x1.0000000000000p-81},
+{-0x1.0000000100000p-1, 0x1.0000000000000p-80, -0x1.0000004000000p-1, 0x1.0000000000000p-81, -0x1.0000002080000p+0, 0x1.8000000000000p-80},
+{0x1.0000010000000p-1, -0x1.ffffe00001000p-57, 0x1.000ffffff007fp-1, 0x1.ffffc00000000p-82, 0x1.0008007ff803fp+0, 0x1.c000041fffdc0p-54},
+{0x1.0000010000000p-1, -0x1.ffffe00001000p-57, -0x1.000ffffff007fp-1, -0x1.ffffc00000000p-82, -0x1.ffdffe00fe400p-14, 0x1.effff20000000p-77},
+{-0x1.0000010000000p-1, 0x1.ffffe00001000p-57, 0x1.000ffffff007fp-1, 0x1.ffffc00000000p-82, 0x1.ffdffe00fe400p-14, -0x1.effff20000000p-77},
+{-0x1.0000010000000p-1, 0x1.ffffe00001000p-57, -0x1.000ffffff007fp-1, -0x1.ffffc00000000p-82, -0x1.0008007ff803fp+0, -0x1.c000041fffdc0p-54},
+{0x1.1000fffffc000p-1, 0x1.fffffc003f000p-57, 0x1.0000000001000p-1, -0x1.0000000000000p-106, 0x1.08007ffffe800p+0, 0x1.fffffc003f000p-57},
+{0x1.1000fffffc000p-1, 0x1.fffffc003f000p-57, -0x1.0000000001000p-1, 0x1.0000000000000p-106, 0x1.000fffffb0002p-5, -0x1.ffe07fc000000p-80},
+{-0x1.1000fffffc000p-1, -0x1.fffffc003f000p-57, 0x1.0000000001000p-1, -0x1.0000000000000p-106, -0x1.000fffffb0002p-5, 0x1.ffe07fc000000p-80},
+{-0x1.1000fffffc000p-1, -0x1.fffffc003f000p-57, -0x1.0000000001000p-1, 0x1.0000000000000p-106, -0x1.08007ffffe800p+0, -0x1.fffffc003f000p-57},
+{0x1.00000fff80000p-1, 0x1.fffe000000000p-86, 0x1.0000001f00000p-1, 0x1.fffffff000000p-78, 0x1.0000080f40000p+0, 0x1.00ffff0000000p-77},
+{0x1.00000fff80000p-1, 0x1.fffe000000000p-86, -0x1.0000001f00000p-1, -0x1.fffffff000000p-78, 0x1.fc10000000000p-22, -0x1.fe0001f000000p-78},
+{-0x1.00000fff80000p-1, -0x1.fffe000000000p-86, 0x1.0000001f00000p-1, 0x1.fffffff000000p-78, -0x1.fc10000000000p-22, 0x1.fe0001f000000p-78},
+{-0x1.00000fff80000p-1, -0x1.fffe000000000p-86, -0x1.0000001f00000p-1, -0x1.fffffff000000p-78, -0x1.0000080f40000p+0, -0x1.00ffff0000000p-77},
+{0x1.3fdfffff02000p-1, -0x1.0000000000000p-79, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-62, 0x1.1fefffff81000p+0, 0x1.ffff7fffffe00p-62},
+{0x1.3fdfffff02000p-1, -0x1.0000000000000p-79, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-62, 0x1.fefffff810000p-4, -0x1.00003ffffff00p-61},
+{-0x1.3fdfffff02000p-1, 0x1.0000000000000p-79, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-62, -0x1.fefffff810000p-4, 0x1.00003ffffff00p-61},
+{-0x1.3fdfffff02000p-1, 0x1.0000000000000p-79, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-62, -0x1.1fefffff81000p+0, -0x1.ffff7fffffe00p-62},
+{0x1.0000000000008p-1, -0x1.e0ffffd002000p-67, 0x1.0000000000400p-1, 0x1.ffffffff03ffep-55, 0x1.0000000000204p+0, 0x1.ffe1efff06ffcp-55},
+{0x1.0000000000008p-1, -0x1.e0ffffd002000p-67, -0x1.0000000000400p-1, -0x1.ffffffff03ffep-55, -0x1.fc4003c1ffe02p-44, 0x0.0000000000000p+0},
+{-0x1.0000000000008p-1, 0x1.e0ffffd002000p-67, 0x1.0000000000400p-1, 0x1.ffffffff03ffep-55, 0x1.fc4003c1ffe02p-44, 0x0.0000000000000p+0},
+{-0x1.0000000000008p-1, 0x1.e0ffffd002000p-67, -0x1.0000000000400p-1, -0x1.ffffffff03ffep-55, -0x1.0000000000204p+0, -0x1.ffe1efff06ffcp-55},
+{0x1.000000fffe020p-1, -0x1.f800100000000p-74, 0x1.0001fff80ffc0p-1, 0x1.ff00000000000p-98, 0x1.0001007c06ff0p+0, -0x1.f8000e0000000p-74},
+{0x1.000000fffe020p-1, -0x1.f800100000000p-74, -0x1.0001fff80ffc0p-1, -0x1.ff00000000000p-98, -0x1.fef811fa00000p-17, -0x1.f80011ff00000p-74},
+{-0x1.000000fffe020p-1, 0x1.f800100000000p-74, 0x1.0001fff80ffc0p-1, 0x1.ff00000000000p-98, 0x1.fef811fa00000p-17, 0x1.f80011ff00000p-74},
+{-0x1.000000fffe020p-1, 0x1.f800100000000p-74, -0x1.0001fff80ffc0p-1, -0x1.ff00000000000p-98, -0x1.0001007c06ff0p+0, 0x1.f8000e0000000p-74},
+{0x1.4000000000000p-1, -0x1.0000000000000p-106, 0x1.0000000000010p-1, 0x1.e000000000000p-69, 0x1.2000000000008p+0, 0x1.e000000000000p-69},
+{0x1.4000000000000p-1, -0x1.0000000000000p-106, -0x1.0000000000010p-1, -0x1.e000000000000p-69, 0x1.fffffffffff80p-4, -0x1.e000000008000p-69},
+{-0x1.4000000000000p-1, 0x1.0000000000000p-106, 0x1.0000000000010p-1, 0x1.e000000000000p-69, -0x1.fffffffffff80p-4, 0x1.e000000008000p-69},
+{-0x1.4000000000000p-1, 0x1.0000000000000p-106, -0x1.0000000000010p-1, -0x1.e000000000000p-69, -0x1.2000000000008p+0, -0x1.e000000000000p-69},
+{0x1.2000000000000p-1, -0x1.fffffff01ff20p-58, 0x1.0000000000000p-1, 0x1.fff8003ff0000p-58, 0x1.1000000000000p+0, -0x1.ffec0bfc80000p-72},
+{0x1.2000000000000p-1, -0x1.fffffff01ff20p-58, -0x1.0000000000000p-1, -0x1.fff8003ff0000p-58, 0x1.ffffffffffffep-5, 0x1.fff3fc0380000p-72},
+{-0x1.2000000000000p-1, 0x1.fffffff01ff20p-58, 0x1.0000000000000p-1, 0x1.fff8003ff0000p-58, -0x1.ffffffffffffep-5, -0x1.fff3fc0380000p-72},
+{-0x1.2000000000000p-1, 0x1.fffffff01ff20p-58, -0x1.0000000000000p-1, -0x1.fff8003ff0000p-58, -0x1.1000000000000p+0, 0x1.ffec0bfc80000p-72},
+{0x1.2000000000000p-1, -0x1.fc08000000000p-93, 0x1.0000000038004p-1, -0x1.fffffc4000000p-70, 0x1.100000001c002p+0, -0x1.0000001c00000p-69},
+{0x1.2000000000000p-1, -0x1.fc08000000000p-93, -0x1.0000000038004p-1, 0x1.fffffc4000000p-70, 0x1.fffffffc7ffc0p-5, 0x1.fffff847f0000p-70},
+{-0x1.2000000000000p-1, 0x1.fc08000000000p-93, 0x1.0000000038004p-1, -0x1.fffffc4000000p-70, -0x1.fffffffc7ffc0p-5, -0x1.fffff847f0000p-70},
+{-0x1.2000000000000p-1, 0x1.fc08000000000p-93, -0x1.0000000038004p-1, 0x1.fffffc4000000p-70, -0x1.100000001c002p+0, 0x1.0000001c00000p-69},
+{0x1.0000000000200p-1, 0x0.0000000000000p+0, 0x1.00001ffff0000p-1, 0x1.ffff80001f000p-58, 0x1.00000ffff8100p+0, 0x1.ffff80001f000p-58},
+{0x1.0000000000200p-1, 0x0.0000000000000p+0, -0x1.00001ffff0000p-1, -0x1.ffff80001f000p-58, -0x1.fffefe0010000p-21, 0x1.ffff840000000p-76},
+{-0x1.0000000000200p-1, 0x0.0000000000000p+0, 0x1.00001ffff0000p-1, 0x1.ffff80001f000p-58, 0x1.fffefe0010000p-21, -0x1.ffff840000000p-76},
+{-0x1.0000000000200p-1, 0x0.0000000000000p+0, -0x1.00001ffff0000p-1, -0x1.ffff80001f000p-58, -0x1.00000ffff8100p+0, -0x1.ffff80001f000p-58},
+{0x1.0000100000000p-1, -0x1.0000000000000p-106, 0x1.0038000800000p-1, -0x1.fffffe0000080p-61, 0x1.001c080400000p+0, -0x1.fffffe0000100p-61},
+{0x1.0000100000000p-1, -0x1.0000000000000p-106, -0x1.0038000800000p-1, 0x1.fffffe0000080p-61, -0x1.bf803fffffff0p-12, -0x1.0000000000000p-84},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-106, 0x1.0038000800000p-1, -0x1.fffffe0000080p-61, 0x1.bf803fffffff0p-12, 0x1.0000000000000p-84},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-106, -0x1.0038000800000p-1, 0x1.fffffe0000080p-61, -0x1.001c080400000p+0, 0x1.fffffe0000100p-61},
+{0x1.0000000000004p-1, -0x1.ffffe00400000p-74, 0x1.0000000000000p-1, 0x1.ffffffffffff8p-57, 0x1.0000000000002p+0, 0x1.ffff00000ffe0p-57},
+{0x1.0000000000004p-1, -0x1.ffffe00400000p-74, -0x1.0000000000000p-1, -0x1.ffffffffffff8p-57, 0x1.effff800007ffp-52, 0x1.0000000000000p-106},
+{-0x1.0000000000004p-1, 0x1.ffffe00400000p-74, 0x1.0000000000000p-1, 0x1.ffffffffffff8p-57, -0x1.effff800007ffp-52, -0x1.0000000000000p-106},
+{-0x1.0000000000004p-1, 0x1.ffffe00400000p-74, -0x1.0000000000000p-1, -0x1.ffffffffffff8p-57, -0x1.0000000000002p+0, -0x1.ffff00000ffe0p-57},
+{0x1.0000000000100p-1, -0x1.ffffe7e400000p-71, 0x1.1ffe000008000p-1, -0x1.fffc000004000p-68, 0x1.0fff000004080p+0, -0x1.1ffdfe7e40000p-67},
+{0x1.0000000000100p-1, -0x1.ffffe7e400000p-71, -0x1.1ffe000008000p-1, 0x1.fffc000004000p-68, -0x1.ffe000007f000p-5, 0x1.bffc030384000p-68},
+{-0x1.0000000000100p-1, 0x1.ffffe7e400000p-71, 0x1.1ffe000008000p-1, -0x1.fffc000004000p-68, 0x1.ffe000007f000p-5, -0x1.bffc030384000p-68},
+{-0x1.0000000000100p-1, 0x1.ffffe7e400000p-71, -0x1.1ffe000008000p-1, 0x1.fffc000004000p-68, -0x1.0fff000004080p+0, 0x1.1ffdfe7e40000p-67},
+{0x1.0000000000004p-1, -0x1.0000000000000p-106, 0x1.00000007ffffep-1, 0x1.ffffe000f0000p-62, 0x1.0000000400001p+0, 0x1.ffffe000f0000p-62},
+{0x1.0000000000004p-1, -0x1.0000000000000p-106, -0x1.00000007ffffep-1, -0x1.ffffe000f0000p-62, -0x1.ffffe803ffffcp-31, -0x1.e020000000000p-95},
+{-0x1.0000000000004p-1, 0x1.0000000000000p-106, 0x1.00000007ffffep-1, 0x1.ffffe000f0000p-62, 0x1.ffffe803ffffcp-31, 0x1.e020000000000p-95},
+{-0x1.0000000000004p-1, 0x1.0000000000000p-106, -0x1.00000007ffffep-1, -0x1.ffffe000f0000p-62, -0x1.0000000400001p+0, -0x1.ffffe000f0000p-62},
+{0x1.0000000000000p-1, 0x1.fffffff000000p-62, 0x1.0001fffc00001p-1, -0x1.0000000000000p-80, 0x1.0000fffe00001p+0, -0x1.fe00004010000p-54},
+{0x1.0000000000000p-1, 0x1.fffffff000000p-62, -0x1.0001fffc00001p-1, 0x1.0000000000000p-80, -0x1.fffc00000ff00p-17, 0x1.ff80000000000p-81},
+{-0x1.0000000000000p-1, -0x1.fffffff000000p-62, 0x1.0001fffc00001p-1, -0x1.0000000000000p-80, 0x1.fffc00000ff00p-17, -0x1.ff80000000000p-81},
+{-0x1.0000000000000p-1, -0x1.fffffff000000p-62, -0x1.0001fffc00001p-1, 0x1.0000000000000p-80, -0x1.0000fffe00001p+0, 0x1.fe00004010000p-54},
+{0x1.00007fdfffff0p-1, 0x1.fff000f803fe0p-59, 0x1.0080000000000p-1, -0x1.0000000000000p-93, 0x1.00403fefffff8p+0, 0x1.fff000f7c4000p-59},
+{0x1.00007fdfffff0p-1, 0x1.fff000f803fe0p-59, -0x1.0080000000000p-1, 0x1.0000000000000p-93, -0x1.fe00800003fe0p-11, -0x1.ffe0f78040000p-72},
+{-0x1.00007fdfffff0p-1, -0x1.fff000f803fe0p-59, 0x1.0080000000000p-1, -0x1.0000000000000p-93, 0x1.fe00800003fe0p-11, 0x1.ffe0f78040000p-72},
+{-0x1.00007fdfffff0p-1, -0x1.fff000f803fe0p-59, -0x1.0080000000000p-1, 0x1.0000000000000p-93, -0x1.00403fefffff8p+0, -0x1.fff000f7c4000p-59},
+{0x1.0000000000080p-1, 0x0.0000000000000p+0, 0x1.0000080000000p-1, -0x1.0000000000000p-86, 0x1.0000040000040p+0, -0x1.0000000000000p-86},
+{0x1.0000000000080p-1, 0x0.0000000000000p+0, -0x1.0000080000000p-1, 0x1.0000000000000p-86, -0x1.fffffe0000000p-23, 0x1.0000000000000p-86},
+{-0x1.0000000000080p-1, 0x0.0000000000000p+0, 0x1.0000080000000p-1, -0x1.0000000000000p-86, 0x1.fffffe0000000p-23, -0x1.0000000000000p-86},
+{-0x1.0000000000080p-1, 0x0.0000000000000p+0, -0x1.0000080000000p-1, 0x1.0000000000000p-86, -0x1.0000040000040p+0, 0x1.0000000000000p-86},
+{0x1.0400000000000p-1, -0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.fffff00008000p-57, 0x1.0200000000200p+0, -0x1.fffff00008000p-57},
+{0x1.0400000000000p-1, -0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.fffff00008000p-57, 0x1.ffffffffe0010p-8, -0x1.ffff001000000p-78},
+{-0x1.0400000000000p-1, 0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.fffff00008000p-57, -0x1.ffffffffe0010p-8, 0x1.ffff001000000p-78},
+{-0x1.0400000000000p-1, 0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.fffff00008000p-57, -0x1.0200000000200p+0, 0x1.fffff00008000p-57},
+{0x1.0000000000001p-1, -0x1.fc0000c004000p-66, 0x1.0000000000200p-1, -0x1.ffe0000200000p-69, 0x1.0000000000100p+0, 0x1.ffdc403ff3fbcp-54},
+{0x1.0000000000001p-1, -0x1.fc0000c004000p-66, -0x1.0000000000200p-1, 0x1.ffe0000200000p-69, -0x1.ff000de020060p-45, 0x1.e000000000000p-101},
+{-0x1.0000000000001p-1, 0x1.fc0000c004000p-66, 0x1.0000000000200p-1, -0x1.ffe0000200000p-69, 0x1.ff000de020060p-45, -0x1.e000000000000p-101},
+{-0x1.0000000000001p-1, 0x1.fc0000c004000p-66, -0x1.0000000000200p-1, 0x1.ffe0000200000p-69, -0x1.0000000000100p+0, -0x1.ffdc403ff3fbcp-54},
+{0x1.00000c0000004p-1, -0x1.ff80000800000p-69, 0x1.18003ffff8000p-1, 0x1.ffffff8000000p-67, 0x1.0c0025fffc002p+0, 0x1.801fff7e00000p-67},
+{0x1.00000c0000004p-1, -0x1.ff80000800000p-69, -0x1.18003ffff8000p-1, -0x1.ffffff8000000p-67, -0x1.80033fff7ffc0p-5, -0x1.3fefffc100000p-66},
+{-0x1.00000c0000004p-1, 0x1.ff80000800000p-69, 0x1.18003ffff8000p-1, 0x1.ffffff8000000p-67, 0x1.80033fff7ffc0p-5, 0x1.3fefffc100000p-66},
+{-0x1.00000c0000004p-1, 0x1.ff80000800000p-69, -0x1.18003ffff8000p-1, -0x1.ffffff8000000p-67, -0x1.0c0025fffc002p+0, -0x1.801fff7e00000p-67},
+{0x1.1ffff80000040p-1, -0x1.0000000000000p-91, 0x1.000000000fe00p-1, 0x1.ffff7e0003ff8p-57, 0x1.0ffffc0007f20p+0, 0x1.ffff7dffc4000p-57},
+{0x1.1ffff80000040p-1, -0x1.0000000000000p-91, -0x1.000000000fe00p-1, -0x1.ffff7e0003ff8p-57, 0x1.ffff7fff023fep-5, 0x1.03ff780100000p-74},
+{-0x1.1ffff80000040p-1, 0x1.0000000000000p-91, 0x1.000000000fe00p-1, 0x1.ffff7e0003ff8p-57, -0x1.ffff7fff023fep-5, -0x1.03ff780100000p-74},
+{-0x1.1ffff80000040p-1, 0x1.0000000000000p-91, -0x1.000000000fe00p-1, -0x1.ffff7e0003ff8p-57, -0x1.0ffffc0007f20p+0, -0x1.ffff7dffc4000p-57},
+{0x1.3fc0000040000p-1, -0x1.fffffff802000p-57, 0x1.fffffffffff00p-1, 0x0.0000000000000p+0, 0x1.9fe000001ff80p+0, -0x1.fffffff802000p-57},
+{0x1.3fc0000040000p-1, -0x1.fffffff802000p-57, -0x1.fffffffffff00p-1, 0x0.0000000000000p+0, -0x1.807fffff7fe00p-2, -0x1.fffffff802000p-57},
+{-0x1.3fc0000040000p-1, 0x1.fffffff802000p-57, 0x1.fffffffffff00p-1, 0x0.0000000000000p+0, 0x1.807fffff7fe00p-2, 0x1.fffffff802000p-57},
+{-0x1.3fc0000040000p-1, 0x1.fffffff802000p-57, -0x1.fffffffffff00p-1, 0x0.0000000000000p+0, -0x1.9fe000001ff80p+0, 0x1.fffffff802000p-57},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, 0x1.0000000000200p-1, -0x1.0000000000000p-106, 0x1.0000000100100p+0, -0x1.ffffbffff8200p-54},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, -0x1.0000000000200p-1, 0x1.0000000000000p-106, 0x1.ffdff00002000p-33, 0x1.f804000000000p-92},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, 0x1.0000000000200p-1, -0x1.0000000000000p-106, -0x1.ffdff00002000p-33, -0x1.f804000000000p-92},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, -0x1.0000000000200p-1, 0x1.0000000000000p-106, -0x1.0000000100100p+0, 0x1.ffffbffff8200p-54},
+{0x1.0000000010000p-1, -0x1.0000000000000p-78, 0x1.1fff010000000p-1, 0x1.ff8c0000007fep-55, 0x1.0fff808008000p+0, 0x1.ff8bfe0000800p-55},
+{0x1.0000000010000p-1, -0x1.0000000000000p-78, -0x1.1fff010000000p-1, -0x1.ff8c0000007fep-55, -0x1.fff00fff00008p-5, 0x1.cff7fffe00800p-65},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-78, 0x1.1fff010000000p-1, 0x1.ff8c0000007fep-55, 0x1.fff00fff00008p-5, -0x1.cff7fffe00800p-65},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-78, -0x1.1fff010000000p-1, -0x1.ff8c0000007fep-55, -0x1.0fff808008000p+0, -0x1.ff8bfe0000800p-55},
+{0x1.0000000000002p-1, -0x1.0000000000000p-88, 0x1.0000000000200p-1, -0x1.0000000000000p-86, 0x1.0000000000101p+0, -0x1.4000000000000p-86},
+{0x1.0000000000002p-1, -0x1.0000000000000p-88, -0x1.0000000000200p-1, 0x1.0000000000000p-86, -0x1.fdffffffffa00p-45, 0x0.0000000000000p+0},
+{-0x1.0000000000002p-1, 0x1.0000000000000p-88, 0x1.0000000000200p-1, -0x1.0000000000000p-86, 0x1.fdffffffffa00p-45, 0x0.0000000000000p+0},
+{-0x1.0000000000002p-1, 0x1.0000000000000p-88, -0x1.0000000000200p-1, 0x1.0000000000000p-86, -0x1.0000000000101p+0, 0x1.4000000000000p-86},
+{0x1.0000000000002p-1, -0x1.ffff800008000p-68, 0x1.000000003fffep-1, 0x1.f81fc007c0000p-72, 0x1.0000000020000p+0, -0x1.e07d83ff90000p-68},
+{0x1.0000000000002p-1, -0x1.ffff800008000p-68, -0x1.000000003fffep-1, -0x1.f81fc007c0000p-72, -0x1.fffe00021f818p-36, 0x1.ffbe000000000p-91},
+{-0x1.0000000000002p-1, 0x1.ffff800008000p-68, 0x1.000000003fffep-1, 0x1.f81fc007c0000p-72, 0x1.fffe00021f818p-36, -0x1.ffbe000000000p-91},
+{-0x1.0000000000002p-1, 0x1.ffff800008000p-68, -0x1.000000003fffep-1, -0x1.f81fc007c0000p-72, -0x1.0000000020000p+0, 0x1.e07d83ff90000p-68},
+{0x1.7ffffffff0000p-1, 0x1.ffff07fffc000p-65, 0x1.000000000ffe0p-1, 0x1.ff0000003c000p-64, 0x1.3fffffffffff0p+0, 0x1.7f7fc2001d000p-63},
+{0x1.7ffffffff0000p-1, 0x1.ffff07fffc000p-65, -0x1.000000000ffe0p-1, -0x1.ff0000003c000p-64, 0x1.ffffffff80080p-3, -0x1.fe00f8007c000p-65},
+{-0x1.7ffffffff0000p-1, -0x1.ffff07fffc000p-65, 0x1.000000000ffe0p-1, 0x1.ff0000003c000p-64, -0x1.ffffffff80080p-3, 0x1.fe00f8007c000p-65},
+{-0x1.7ffffffff0000p-1, -0x1.ffff07fffc000p-65, -0x1.000000000ffe0p-1, -0x1.ff0000003c000p-64, -0x1.3fffffffffff0p+0, -0x1.7f7fc2001d000p-63},
+{0x1.00007fff00080p-1, -0x1.ffffff0001000p-66, 0x1.00000000007c0p-1, 0x1.ffffff8000000p-68, 0x1.00003fff80420p+0, -0x1.7fffff2000000p-66},
+{0x1.00007fff00080p-1, -0x1.ffffff0001000p-66, -0x1.00000000007c0p-1, -0x1.ffffff8000000p-68, 0x1.fffbfe2ffffb0p-19, 0x1.1fff000000000p-90},
+{-0x1.00007fff00080p-1, 0x1.ffffff0001000p-66, 0x1.00000000007c0p-1, 0x1.ffffff8000000p-68, -0x1.fffbfe2ffffb0p-19, -0x1.1fff000000000p-90},
+{-0x1.00007fff00080p-1, 0x1.ffffff0001000p-66, -0x1.00000000007c0p-1, -0x1.ffffff8000000p-68, -0x1.00003fff80420p+0, 0x1.7fffff2000000p-66},
+{0x1.1fff81ff00000p-1, 0x1.e007ffff00000p-58, 0x1.1ffffffff8000p-1, 0x1.fe001ffffffe0p-57, 0x1.1fffc0ff7c000p+0, 0x1.77020fffbfff0p-56},
+{0x1.1fff81ff00000p-1, 0x1.e007ffff00000p-58, -0x1.1ffffffff8000p-1, -0x1.fe001ffffffe0p-57, -0x1.f803e0000437fp-19, -0x1.0003fff000000p-76},
+{-0x1.1fff81ff00000p-1, -0x1.e007ffff00000p-58, 0x1.1ffffffff8000p-1, 0x1.fe001ffffffe0p-57, 0x1.f803e0000437fp-19, 0x1.0003fff000000p-76},
+{-0x1.1fff81ff00000p-1, -0x1.e007ffff00000p-58, -0x1.1ffffffff8000p-1, -0x1.fe001ffffffe0p-57, -0x1.1fffc0ff7c000p+0, -0x1.77020fffbfff0p-56},
+{0x1.0000000000000p-1, 0x1.fffc03fe00700p-62, 0x1.0000000000001p-1, -0x1.fff8060000f34p-56, 0x1.0000000000000p+0, 0x1.8201fa83fdc3ap-54},
+{0x1.0000000000000p-1, 0x1.fffc03fe00700p-62, -0x1.0000000000001p-1, 0x1.fff8060000f34p-56, -0x1.7e02027c01c2cp-54, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffc03fe00700p-62, 0x1.0000000000001p-1, -0x1.fff8060000f34p-56, 0x1.7e02027c01c2cp-54, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffc03fe00700p-62, -0x1.0000000000001p-1, 0x1.fff8060000f34p-56, -0x1.0000000000000p+0, -0x1.8201fa83fdc3ap-54},
+{0x1.001ffffc00080p-1, -0x1.fe00000200000p-62, 0x1.0000000001000p-1, -0x1.fe3ffffff0080p-61, 0x1.000ffffe00840p+0, -0x1.7ea0000078000p-60},
+{0x1.001ffffc00080p-1, -0x1.fe00000200000p-62, -0x1.0000000001000p-1, 0x1.fe3ffffff0080p-61, 0x1.ffffbff080010p-13, -0x1.8000021ff0000p-70},
+{-0x1.001ffffc00080p-1, 0x1.fe00000200000p-62, 0x1.0000000001000p-1, -0x1.fe3ffffff0080p-61, -0x1.ffffbff080010p-13, 0x1.8000021ff0000p-70},
+{-0x1.001ffffc00080p-1, 0x1.fe00000200000p-62, -0x1.0000000001000p-1, 0x1.fe3ffffff0080p-61, -0x1.000ffffe00840p+0, 0x1.7ea0000078000p-60},
+{0x1.00001fffff800p-1, 0x1.ffffff801ffc0p-60, 0x1.0000000002000p-1, -0x1.0000000000000p-106, 0x1.0000100000c00p+0, 0x1.ffffff801ff80p-60},
+{0x1.00001fffff800p-1, 0x1.ffffff801ffc0p-60, -0x1.0000000002000p-1, 0x1.0000000000000p-106, 0x1.ffffd80004000p-21, -0x1.ff80000000000p-86},
+{-0x1.00001fffff800p-1, -0x1.ffffff801ffc0p-60, 0x1.0000000002000p-1, -0x1.0000000000000p-106, -0x1.ffffd80004000p-21, 0x1.ff80000000000p-86},
+{-0x1.00001fffff800p-1, -0x1.ffffff801ffc0p-60, -0x1.0000000002000p-1, 0x1.0000000000000p-106, -0x1.0000100000c00p+0, -0x1.ffffff801ff80p-60},
+{0x1.0000000000000p-1, 0x1.ffff83ffbfff0p-57, 0x1.0000000000000p-1, 0x1.ffffffffe0000p-57, 0x1.0000000000000p+0, 0x1.ffffc1ffcfff8p-56},
+{0x1.0000000000000p-1, 0x1.ffff83ffbfff0p-57, -0x1.0000000000000p-1, -0x1.ffffffffe0000p-57, -0x1.f000800400000p-75, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ffff83ffbfff0p-57, 0x1.0000000000000p-1, 0x1.ffffffffe0000p-57, 0x1.f000800400000p-75, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ffff83ffbfff0p-57, -0x1.0000000000000p-1, -0x1.ffffffffe0000p-57, -0x1.0000000000000p+0, -0x1.ffffc1ffcfff8p-56},
+{0x1.0000000000000p-1, 0x1.fffe7ff3dff00p-62, 0x1.000007f830000p-1, 0x1.fff0000ffe100p-62, 0x1.000003fc18000p+0, 0x1.fff74001ef000p-61},
+{0x1.0000000000000p-1, 0x1.fffe7ff3dff00p-62, -0x1.000007f830000p-1, -0x1.fff0000ffe100p-62, -0x1.fe0bffffffffep-23, -0x1.801c1e2000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffe7ff3dff00p-62, 0x1.000007f830000p-1, 0x1.fff0000ffe100p-62, 0x1.fe0bffffffffep-23, 0x1.801c1e2000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffe7ff3dff00p-62, -0x1.000007f830000p-1, -0x1.fff0000ffe100p-62, -0x1.000003fc18000p+0, -0x1.fff74001ef000p-61},
+{0x1.00000ffffe000p-1, 0x1.fffffffffc000p-68, 0x1.0000000000002p-1, -0x1.fffffe01f8004p-56, 0x1.000007ffff001p+0, -0x1.ffdffe01f8008p-56},
+{0x1.00000ffffe000p-1, 0x1.fffffffffc000p-68, -0x1.0000000000002p-1, 0x1.fffffe01f8004p-56, 0x1.ffffbffc80080p-22, -0x1.fe08000000000p-80},
+{-0x1.00000ffffe000p-1, -0x1.fffffffffc000p-68, 0x1.0000000000002p-1, -0x1.fffffe01f8004p-56, -0x1.ffffbffc80080p-22, 0x1.fe08000000000p-80},
+{-0x1.00000ffffe000p-1, -0x1.fffffffffc000p-68, -0x1.0000000000002p-1, 0x1.fffffe01f8004p-56, -0x1.000007ffff001p+0, 0x1.ffdffe01f8008p-56},
+{0x1.0000000000060p-1, 0x1.fffe3fff00000p-64, 0x1.0000000002000p-1, -0x1.ffe0002000000p-58, 0x1.0000000001030p+0, -0x1.f7e0072004000p-58},
+{0x1.0000000000060p-1, 0x1.fffe3fff00000p-64, -0x1.0000000002000p-1, 0x1.ffe0002000000p-58, -0x1.f9fefc1003700p-41, -0x1.0000000000000p-96},
+{-0x1.0000000000060p-1, -0x1.fffe3fff00000p-64, 0x1.0000000002000p-1, -0x1.ffe0002000000p-58, 0x1.f9fefc1003700p-41, 0x1.0000000000000p-96},
+{-0x1.0000000000060p-1, -0x1.fffe3fff00000p-64, -0x1.0000000002000p-1, 0x1.ffe0002000000p-58, -0x1.0000000001030p+0, 0x1.f7e0072004000p-58},
+{0x1.0003ffffffff8p-1, 0x1.ffffe07e00000p-75, 0x1.07ff000008000p-1, -0x1.e000020000000p-62, 0x1.0401800003ffcp+0, -0x1.dff00200fc000p-62},
+{0x1.0003ffffffff8p-1, 0x1.ffffe07e00000p-75, -0x1.07ff000008000p-1, 0x1.e000020000000p-62, -0x1.fec0000200200p-7, 0x1.e01001ff03f00p-62},
+{-0x1.0003ffffffff8p-1, -0x1.ffffe07e00000p-75, 0x1.07ff000008000p-1, -0x1.e000020000000p-62, 0x1.fec0000200200p-7, -0x1.e01001ff03f00p-62},
+{-0x1.0003ffffffff8p-1, -0x1.ffffe07e00000p-75, -0x1.07ff000008000p-1, 0x1.e000020000000p-62, -0x1.0401800003ffcp+0, 0x1.dff00200fc000p-62},
+};
+
+const int numAccuracyTests = sizeof(accuracyTests) / sizeof(struct testVector);
+
+#include <math.h>
+
+double testAccuracy() {
+	int i;
+	DD a, b, c, r;
+	
+	double worstUlps = 0.5;
+	
+	for (i=0; i<numAccuracyTests; ++i) {
+		a.hi = accuracyTests[i].xhi;
+		a.lo = accuracyTests[i].xlo;
+		b.hi = accuracyTests[i].yhi;
+		b.lo = accuracyTests[i].ylo;
+		r.hi = accuracyTests[i].rhi;
+		r.lo = accuracyTests[i].rlo;
+		
+		DD c = { .ld = __gcc_qadd(a.ld, b.ld) };
+		
+		double error = __builtin_fabs(((r.hi - c.hi) + r.lo) - c.lo);
+		
+		if (error != 0.0) {
+		
+			int exponent = ilogb(r.hi);
+			exponent = (exponent < -1022 ? -1022 : exponent);
+			double ulpError = scalbn(error, 106 - exponent);
+		
+			if (ulpError > worstUlps) {
+#ifdef PRINT_ACCURACY_INFORMATION
+				printf("New worst rounding error for (%a,%a) + (%a,%a):\n", a.hi, a.lo, b.hi, b.lo);
+				printf("\tExpected: (%a,%a)\n", r.hi, r.lo);
+				printf("\tComputed: (%a,%a)\n", c.hi, c.lo);
+				printf("\tError: %f ulps\n", ulpError);
+#endif
+				worstUlps = ulpError;
+			}
+		}
+	}
+	
+	return worstUlps;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/compiler-rt/test/builtins/Unit/ppc/qdiv_test.c b/compiler-rt/test/builtins/Unit/ppc/qdiv_test.c
new file mode 100644
index 0000000..8e4e75a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/qdiv_test.c
@@ -0,0 +1,795 @@
+#include <stdio.h>
+#include "DD.h"
+
+long double __gcc_qdiv(long double x, long double y);
+
+double testAccuracy();
+int testEdgeCases();
+
+int main(int argc, char *argv[]) {
+	if (testEdgeCases())
+		return 1;
+	
+	if (testAccuracy() > 4.0)
+		return 1;
+	
+	return 0;
+}
+
+struct testVector {
+	double xhi; double xlo;
+	double yhi; double ylo;
+	double rhi; double rlo;
+};
+
+#define INFINITY __builtin_inf()
+#define HUGE 0x1.fffffffffffffp1023
+#define QNAN __builtin_nan("")
+
+const struct testVector edgeCases[] = {
+{	0.0,		0.0,		0.0,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,		0.0,		0.0,	    QNAN,		0.0			},
+{   0.0,		0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+{  -0.0,		0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+
+{   INFINITY,	0.0,		0.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,		0.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -0.0,		0.0,	   -INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -0.0,		0.0,	    INFINITY,	0.0			},
+{   INFINITY,	0.0,	    1.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    1.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -1.0,		0.0,	   -INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -1.0,		0.0,	    INFINITY,	0.0			},
+{   INFINITY,	0.0,	    HUGE,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    HUGE,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -HUGE,		0.0,	   -INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -HUGE,		0.0,	    INFINITY,	0.0			},
+{   INFINITY,	0.0,	    INFINITY,	0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	    INFINITY,	0.0,	   -QNAN,		0.0			},
+{   INFINITY,	0.0,	   -INFINITY,	0.0,	   -QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{   0.0,		0.0,		INFINITY,	0.0,		0.0,		0.0			},
+{   0.0,		0.0,	   -INFINITY,	0.0,	   -0.0,		0.0			},
+{  -0.0,		0.0,		INFINITY,	0.0,	   -0.0,		0.0			},
+{  -0.0,		0.0,	   -INFINITY,	0.0,	    0.0,		0.0			},
+{   1.0,		0.0,		INFINITY,	0.0,		0.0,		0.0			},
+{   1.0,		0.0,	   -INFINITY,	0.0,	   -0.0,		0.0			},
+{  -1.0,		0.0,		INFINITY,	0.0,	   -0.0,		0.0			},
+{  -1.0,		0.0,	   -INFINITY,	0.0,	    0.0,		0.0			},
+{   HUGE,		0.0,		INFINITY,	0.0,		0.0,		0.0			},
+{   HUGE,		0.0,	   -INFINITY,	0.0,	   -0.0,		0.0			},
+{  -HUGE,		0.0,		INFINITY,	0.0,	   -0.0,		0.0			},
+{  -HUGE,		0.0,	   -INFINITY,	0.0,	    0.0,		0.0			},
+
+{   QNAN,		0.0,		0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    QNAN,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -QNAN,		0.0,	    QNAN,		0.0			},
+{	0.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+};
+
+const int numEdgeCases = sizeof(edgeCases) / sizeof(struct testVector);
+
+
+int testEdgeCases() {
+	int i;
+	DD a, b, c, r;
+	for (i=0; i<numEdgeCases; ++i) {
+		a.hi = edgeCases[i].xhi;
+		a.lo = edgeCases[i].xlo;
+		b.hi = edgeCases[i].yhi;
+		b.lo = edgeCases[i].ylo;
+		r.hi = edgeCases[i].rhi;
+		r.lo = edgeCases[i].rlo;
+		
+		int error;
+		
+		DD c = { .ld = __gcc_qdiv(a.ld, b.ld) };
+		
+		if (r.hi != r.hi) {
+			if (c.hi == c.hi)
+				error = 1;
+			else if (c.lo != 0.0)
+				error = 1;
+			else
+				error = 0;
+		}
+
+		else if (r.hi == 0.0)
+			error = memcmp(&c, &r, sizeof(DD));
+		
+		else
+			error = ((c.hi != r.hi) || (c.lo != r.lo));
+		
+		if (error) {
+			printf("Error on edge case %a / %a: expected (%a, %a), got (%a, %a).\n", a.hi, b.hi, r.hi, r.lo, c.hi, c.lo);
+			return 1;
+		}
+	}
+	
+	return 0;
+}
+
+
+/*
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <mpfr.h>
+ #include <math.h>
+ 
+ #ifdef __x86_64__
+ #define randlength 2
+ #else
+ #define randlength 4
+ #endif
+ 
+ void printTest(mpfr_t a, mpfr_t b, mpfr_t c) {
+ static const double infinityD = __builtin_inf();
+ 
+ MPFR_DECL_INIT(tmp, 53);
+ 
+ double ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ double alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ double bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ double blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ double chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ double clo = isinf(chi) ? 0.0 : mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ }
+ 
+ int main(int argc, char *argv[]) {
+ 
+ MPFR_DECL_INIT(a, 106);
+ MPFR_DECL_INIT(b, 106);
+ MPFR_DECL_INIT(c, 106);
+ 
+ int exponent_range = atoi(argv[1]);
+ 
+ int i;
+ for (i=0; i<128; ++i) {
+ mpfr_random2(a, randlength, exponent_range);
+ mpfr_random2(b, randlength, exponent_range);
+ mpfr_div(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_div(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ 
+ mpfr_neg(a, a, GMP_RNDN);
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_div(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_div(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ }
+ return 0;
+ } 
+ 
+ */
+
+const struct testVector accuracyTests[] = {
+{0x1.00001ffffff00p+419, 0x1.fffff83ff8000p+364, 0x1.00ffc00ffff00p-598, 0x1.fe0007fffff00p-654, 0x1.fe02bca42ad25p+1016, 0x1.29aa5d717c42cp+961},
+{0x1.00001ffffff00p+419, 0x1.fffff83ff8000p+364, -0x1.00ffc00ffff00p-598, -0x1.fe0007fffff00p-654, -0x1.fe02bca42ad25p+1016, -0x1.29aa5d717c42cp+961},
+{-0x1.00001ffffff00p+419, -0x1.fffff83ff8000p+364, 0x1.00ffc00ffff00p-598, 0x1.fe0007fffff00p-654, -0x1.fe02bca42ad25p+1016, -0x1.29aa5d717c42cp+961},
+{-0x1.00001ffffff00p+419, -0x1.fffff83ff8000p+364, -0x1.00ffc00ffff00p-598, -0x1.fe0007fffff00p-654, 0x1.fe02bca42ad25p+1016, 0x1.29aa5d717c42cp+961},
+{0x1.00001fffff800p-575, 0x1.fffffffe00000p-649, 0x1.3fffffff80000p-17, 0x1.ffffffff00000p-90, 0x1.9999cccd6fd72p-559, -0x1.476d58085a038p-615},
+{0x1.00001fffff800p-575, 0x1.fffffffe00000p-649, -0x1.3fffffff80000p-17, -0x1.ffffffff00000p-90, -0x1.9999cccd6fd72p-559, 0x1.476d58085a038p-615},
+{-0x1.00001fffff800p-575, -0x1.fffffffe00000p-649, 0x1.3fffffff80000p-17, 0x1.ffffffff00000p-90, -0x1.9999cccd6fd72p-559, 0x1.476d58085a038p-615},
+{-0x1.00001fffff800p-575, -0x1.fffffffe00000p-649, -0x1.3fffffff80000p-17, -0x1.ffffffff00000p-90, 0x1.9999cccd6fd72p-559, -0x1.476d58085a038p-615},
+{0x1.0000000800000p-557, -0x1.0000000000000p-629, 0x1.000003fffc002p+323, -0x1.0000000000000p+218, 0x1.fffff810081f8p-881, -0x1.00fb820825b80p-939},
+{0x1.0000000800000p-557, -0x1.0000000000000p-629, -0x1.000003fffc002p+323, 0x1.0000000000000p+218, -0x1.fffff810081f8p-881, 0x1.00fb820825b80p-939},
+{-0x1.0000000800000p-557, 0x1.0000000000000p-629, 0x1.000003fffc002p+323, -0x1.0000000000000p+218, -0x1.fffff810081f8p-881, 0x1.00fb820825b80p-939},
+{-0x1.0000000800000p-557, 0x1.0000000000000p-629, -0x1.000003fffc002p+323, 0x1.0000000000000p+218, 0x1.fffff810081f8p-881, -0x1.00fb820825b80p-939},
+{0x1.000003ffffffep+356, -0x1.ffe0080000000p+272, 0x1.0800000000000p-150, -0x1.0000000000000p-246, 0x1.f07c26c9b26c6p+505, -0x1.745d1764d6558p+450},
+{0x1.000003ffffffep+356, -0x1.ffe0080000000p+272, -0x1.0800000000000p-150, 0x1.0000000000000p-246, -0x1.f07c26c9b26c6p+505, 0x1.745d1764d6558p+450},
+{-0x1.000003ffffffep+356, 0x1.ffe0080000000p+272, 0x1.0800000000000p-150, -0x1.0000000000000p-246, -0x1.f07c26c9b26c6p+505, 0x1.745d1764d6558p+450},
+{-0x1.000003ffffffep+356, 0x1.ffe0080000000p+272, -0x1.0800000000000p-150, 0x1.0000000000000p-246, 0x1.f07c26c9b26c6p+505, -0x1.745d1764d6558p+450},
+{0x1.0000007fffc00p-14, 0x1.efe0000000000p-108, 0x1.007fffffe0000p-312, 0x0.0000000000000p+0, 0x1.ff0080bfdf705p+297, 0x1.fb017ac5608fap+243},
+{0x1.0000007fffc00p-14, 0x1.efe0000000000p-108, -0x1.007fffffe0000p-312, 0x0.0000000000000p+0, -0x1.ff0080bfdf705p+297, -0x1.fb017ac5608fap+243},
+{-0x1.0000007fffc00p-14, -0x1.efe0000000000p-108, 0x1.007fffffe0000p-312, 0x0.0000000000000p+0, -0x1.ff0080bfdf705p+297, -0x1.fb017ac5608fap+243},
+{-0x1.0000007fffc00p-14, -0x1.efe0000000000p-108, -0x1.007fffffe0000p-312, 0x0.0000000000000p+0, 0x1.ff0080bfdf705p+297, 0x1.fb017ac5608fap+243},
+{0x1.3fe0000100000p-744, -0x1.0000000000000p-817, 0x1.3fffffffffe00p+293, 0x1.fe00040000000p+218, 0x1.ffccccce60000p-1038, 0x0.0000000000000p+0},
+{0x1.3fe0000100000p-744, -0x1.0000000000000p-817, -0x1.3fffffffffe00p+293, -0x1.fe00040000000p+218, -0x1.ffccccce60000p-1038, -0x0.0000000000000p+0},
+{-0x1.3fe0000100000p-744, 0x1.0000000000000p-817, 0x1.3fffffffffe00p+293, 0x1.fe00040000000p+218, -0x1.ffccccce60000p-1038, -0x0.0000000000000p+0},
+{-0x1.3fe0000100000p-744, 0x1.0000000000000p-817, -0x1.3fffffffffe00p+293, -0x1.fe00040000000p+218, 0x1.ffccccce60000p-1038, 0x0.0000000000000p+0},
+{0x1.0001fff800000p+0, 0x1.ffffff0000ffep-54, 0x1.00ff000000800p+11, -0x1.0000000800000p-55, 0x1.fe07f601f30ffp-12, -0x1.b3714144d2a90p-69},
+{0x1.0001fff800000p+0, 0x1.ffffff0000ffep-54, -0x1.00ff000000800p+11, 0x1.0000000800000p-55, -0x1.fe07f601f30ffp-12, 0x1.b3714144d2a90p-69},
+{-0x1.0001fff800000p+0, -0x1.ffffff0000ffep-54, 0x1.00ff000000800p+11, -0x1.0000000800000p-55, -0x1.fe07f601f30ffp-12, 0x1.b3714144d2a90p-69},
+{-0x1.0001fff800000p+0, -0x1.ffffff0000ffep-54, -0x1.00ff000000800p+11, 0x1.0000000800000p-55, 0x1.fe07f601f30ffp-12, -0x1.b3714144d2a90p-69},
+{0x1.0000800000000p-381, -0x1.ffffffe400000p-444, 0x1.000001ffffffap+606, -0x1.ffe1f80400000p+531, 0x1.00007dffff046p-987, -0x1.d940000000000p-1051},
+{0x1.0000800000000p-381, -0x1.ffffffe400000p-444, -0x1.000001ffffffap+606, 0x1.ffe1f80400000p+531, -0x1.00007dffff046p-987, 0x1.d940000000000p-1051},
+{-0x1.0000800000000p-381, 0x1.ffffffe400000p-444, 0x1.000001ffffffap+606, -0x1.ffe1f80400000p+531, -0x1.00007dffff046p-987, 0x1.d940000000000p-1051},
+{-0x1.0000800000000p-381, 0x1.ffffffe400000p-444, -0x1.000001ffffffap+606, 0x1.ffe1f80400000p+531, 0x1.00007dffff046p-987, -0x1.d940000000000p-1051},
+{0x1.0000010000000p+772, -0x1.0000000000000p+667, 0x1.007fffffffc00p+750, 0x1.fffffc0000000p+679, 0x1.ff0081bf20ef5p+21, -0x1.e0f5922874ff2p-33},
+{0x1.0000010000000p+772, -0x1.0000000000000p+667, -0x1.007fffffffc00p+750, -0x1.fffffc0000000p+679, -0x1.ff0081bf20ef5p+21, 0x1.e0f5922874ff2p-33},
+{-0x1.0000010000000p+772, 0x1.0000000000000p+667, 0x1.007fffffffc00p+750, 0x1.fffffc0000000p+679, -0x1.ff0081bf20ef5p+21, 0x1.e0f5922874ff2p-33},
+{-0x1.0000010000000p+772, 0x1.0000000000000p+667, -0x1.007fffffffc00p+750, -0x1.fffffc0000000p+679, 0x1.ff0081bf20ef5p+21, -0x1.e0f5922874ff2p-33},
+{0x1.0080000000000p-547, -0x1.0000000000000p-620, 0x1.001ffffffc000p+963, 0x1.fffffffff001cp+908, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0080000000000p-547, -0x1.0000000000000p-620, -0x1.001ffffffc000p+963, -0x1.fffffffff001cp+908, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0080000000000p-547, 0x1.0000000000000p-620, 0x1.001ffffffc000p+963, 0x1.fffffffff001cp+908, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0080000000000p-547, 0x1.0000000000000p-620, -0x1.001ffffffc000p+963, -0x1.fffffffff001cp+908, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.000001fffff80p-138, 0x1.fffffc001fffcp-193, 0x1.00001ffff8000p-554, 0x1.00007f001e000p-609, 0x1.ffffc40017700p+415, -0x1.9c017d7fb3e20p+358},
+{0x1.000001fffff80p-138, 0x1.fffffc001fffcp-193, -0x1.00001ffff8000p-554, -0x1.00007f001e000p-609, -0x1.ffffc40017700p+415, 0x1.9c017d7fb3e20p+358},
+{-0x1.000001fffff80p-138, -0x1.fffffc001fffcp-193, 0x1.00001ffff8000p-554, 0x1.00007f001e000p-609, -0x1.ffffc40017700p+415, 0x1.9c017d7fb3e20p+358},
+{-0x1.000001fffff80p-138, -0x1.fffffc001fffcp-193, -0x1.00001ffff8000p-554, -0x1.00007f001e000p-609, 0x1.ffffc40017700p+415, -0x1.9c017d7fb3e20p+358},
+{0x1.00f3ffffff000p-238, 0x1.fff8000000000p-306, 0x1.3dfffffffc000p-529, 0x1.ff000003ffe00p-590, 0x1.9db5efe640c6bp+290, 0x1.d0e9f9b84e302p+236},
+{0x1.00f3ffffff000p-238, 0x1.fff8000000000p-306, -0x1.3dfffffffc000p-529, -0x1.ff000003ffe00p-590, -0x1.9db5efe640c6bp+290, -0x1.d0e9f9b84e302p+236},
+{-0x1.00f3ffffff000p-238, -0x1.fff8000000000p-306, 0x1.3dfffffffc000p-529, 0x1.ff000003ffe00p-590, -0x1.9db5efe640c6bp+290, -0x1.d0e9f9b84e302p+236},
+{-0x1.00f3ffffff000p-238, -0x1.fff8000000000p-306, -0x1.3dfffffffc000p-529, -0x1.ff000003ffe00p-590, 0x1.9db5efe640c6bp+290, 0x1.d0e9f9b84e302p+236},
+{0x1.0000001ffff80p-69, 0x1.fffffdfffff8ep-123, 0x1.0000000000000p-311, -0x1.0000000000000p-381, 0x1.0000001ffff81p+242, -0x1.ffff01ffffe72p+188},
+{0x1.0000001ffff80p-69, 0x1.fffffdfffff8ep-123, -0x1.0000000000000p-311, 0x1.0000000000000p-381, -0x1.0000001ffff81p+242, 0x1.ffff01ffffe72p+188},
+{-0x1.0000001ffff80p-69, -0x1.fffffdfffff8ep-123, 0x1.0000000000000p-311, -0x1.0000000000000p-381, -0x1.0000001ffff81p+242, 0x1.ffff01ffffe72p+188},
+{-0x1.0000001ffff80p-69, -0x1.fffffdfffff8ep-123, -0x1.0000000000000p-311, 0x1.0000000000000p-381, 0x1.0000001ffff81p+242, -0x1.ffff01ffffe72p+188},
+{0x1.001fffffffe00p-160, 0x0.0000000000000p+0, 0x1.0000002000000p+499, -0x1.0000000000000p+399, 0x1.001fffdffbe00p-659, 0x1.0020ffdffbe40p-713},
+{0x1.001fffffffe00p-160, 0x0.0000000000000p+0, -0x1.0000002000000p+499, 0x1.0000000000000p+399, -0x1.001fffdffbe00p-659, -0x1.0020ffdffbe40p-713},
+{-0x1.001fffffffe00p-160, 0x0.0000000000000p+0, 0x1.0000002000000p+499, -0x1.0000000000000p+399, -0x1.001fffdffbe00p-659, -0x1.0020ffdffbe40p-713},
+{-0x1.001fffffffe00p-160, 0x0.0000000000000p+0, -0x1.0000002000000p+499, 0x1.0000000000000p+399, 0x1.001fffdffbe00p-659, 0x1.0020ffdffbe40p-713},
+{0x1.01ffffffe0000p+182, 0x1.c000000200000p+121, 0x1.0001fff800ffep-8, 0x1.c000000000000p-111, 0x1.01fdfc0bf6d61p+190, 0x1.41500c3427868p+136},
+{0x1.01ffffffe0000p+182, 0x1.c000000200000p+121, -0x1.0001fff800ffep-8, -0x1.c000000000000p-111, -0x1.01fdfc0bf6d61p+190, -0x1.41500c3427868p+136},
+{-0x1.01ffffffe0000p+182, -0x1.c000000200000p+121, 0x1.0001fff800ffep-8, 0x1.c000000000000p-111, -0x1.01fdfc0bf6d61p+190, -0x1.41500c3427868p+136},
+{-0x1.01ffffffe0000p+182, -0x1.c000000200000p+121, -0x1.0001fff800ffep-8, -0x1.c000000000000p-111, 0x1.01fdfc0bf6d61p+190, 0x1.41500c3427868p+136},
+{0x1.00000007ff800p-868, 0x1.ffff800000000p-956, 0x1.00003fe0c4000p+822, -0x1.fffc032000000p+759, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00000007ff800p-868, 0x1.ffff800000000p-956, -0x1.00003fe0c4000p+822, 0x1.fffc032000000p+759, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00000007ff800p-868, -0x1.ffff800000000p-956, 0x1.00003fe0c4000p+822, -0x1.fffc032000000p+759, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00000007ff800p-868, -0x1.ffff800000000p-956, -0x1.00003fe0c4000p+822, 0x1.fffc032000000p+759, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.000001fff8008p-330, -0x1.0000000000000p-412, 0x1.000ffffff8000p-674, 0x1.ffffffffffc00p-729, 0x1.ffe005ffa005fp+343, 0x1.f43ff5ecf10d0p+289},
+{0x1.000001fff8008p-330, -0x1.0000000000000p-412, -0x1.000ffffff8000p-674, -0x1.ffffffffffc00p-729, -0x1.ffe005ffa005fp+343, -0x1.f43ff5ecf10d0p+289},
+{-0x1.000001fff8008p-330, 0x1.0000000000000p-412, 0x1.000ffffff8000p-674, 0x1.ffffffffffc00p-729, -0x1.ffe005ffa005fp+343, -0x1.f43ff5ecf10d0p+289},
+{-0x1.000001fff8008p-330, 0x1.0000000000000p-412, -0x1.000ffffff8000p-674, -0x1.ffffffffffc00p-729, 0x1.ffe005ffa005fp+343, 0x1.f43ff5ecf10d0p+289},
+{0x1.007fbfffffcf0p+664, 0x1.ffff803ffe000p+609, 0x1.0007ffff00000p+281, 0x1.fffff80000000p+211, 0x1.0077bc431e2ddp+383, -0x1.2b617a631e528p+327},
+{0x1.007fbfffffcf0p+664, 0x1.ffff803ffe000p+609, -0x1.0007ffff00000p+281, -0x1.fffff80000000p+211, -0x1.0077bc431e2ddp+383, 0x1.2b617a631e528p+327},
+{-0x1.007fbfffffcf0p+664, -0x1.ffff803ffe000p+609, 0x1.0007ffff00000p+281, 0x1.fffff80000000p+211, -0x1.0077bc431e2ddp+383, 0x1.2b617a631e528p+327},
+{-0x1.007fbfffffcf0p+664, -0x1.ffff803ffe000p+609, -0x1.0007ffff00000p+281, -0x1.fffff80000000p+211, 0x1.0077bc431e2ddp+383, -0x1.2b617a631e528p+327},
+{0x1.0000001fc4000p+296, -0x1.fe003ffe00000p+240, 0x1.01ffffffc0004p+770, -0x1.fffc100000000p+709, 0x1.fc07f05f4870ap-475, -0x1.fd9f5028f5e8ap-529},
+{0x1.0000001fc4000p+296, -0x1.fe003ffe00000p+240, -0x1.01ffffffc0004p+770, 0x1.fffc100000000p+709, -0x1.fc07f05f4870ap-475, 0x1.fd9f5028f5e8ap-529},
+{-0x1.0000001fc4000p+296, 0x1.fe003ffe00000p+240, 0x1.01ffffffc0004p+770, -0x1.fffc100000000p+709, -0x1.fc07f05f4870ap-475, 0x1.fd9f5028f5e8ap-529},
+{-0x1.0000001fc4000p+296, 0x1.fe003ffe00000p+240, -0x1.01ffffffc0004p+770, 0x1.fffc100000000p+709, 0x1.fc07f05f4870ap-475, -0x1.fd9f5028f5e8ap-529},
+{0x1.0007e3ffe0000p+601, 0x1.fe0ffffffe000p+537, 0x1.0000001000000p+631, -0x1.ffffff0000800p+567, 0x1.0007e3efdf81cp-30, 0x1.060603b67f558p-86},
+{0x1.0007e3ffe0000p+601, 0x1.fe0ffffffe000p+537, -0x1.0000001000000p+631, 0x1.ffffff0000800p+567, -0x1.0007e3efdf81cp-30, -0x1.060603b67f558p-86},
+{-0x1.0007e3ffe0000p+601, -0x1.fe0ffffffe000p+537, 0x1.0000001000000p+631, -0x1.ffffff0000800p+567, -0x1.0007e3efdf81cp-30, -0x1.060603b67f558p-86},
+{-0x1.0007e3ffe0000p+601, -0x1.fe0ffffffe000p+537, -0x1.0000001000000p+631, 0x1.ffffff0000800p+567, 0x1.0007e3efdf81cp-30, 0x1.060603b67f558p-86},
+{0x1.00000003ff800p+298, 0x1.ffffe00000000p+212, 0x1.0000200000000p+469, -0x1.ff80800000000p+404, 0x1.ffffc00806ff0p-172, -0x1.bbc0c7e7b71b0p-229},
+{0x1.00000003ff800p+298, 0x1.ffffe00000000p+212, -0x1.0000200000000p+469, 0x1.ff80800000000p+404, -0x1.ffffc00806ff0p-172, 0x1.bbc0c7e7b71b0p-229},
+{-0x1.00000003ff800p+298, -0x1.ffffe00000000p+212, 0x1.0000200000000p+469, -0x1.ff80800000000p+404, -0x1.ffffc00806ff0p-172, 0x1.bbc0c7e7b71b0p-229},
+{-0x1.00000003ff800p+298, -0x1.ffffe00000000p+212, -0x1.0000200000000p+469, 0x1.ff80800000000p+404, 0x1.ffffc00806ff0p-172, -0x1.bbc0c7e7b71b0p-229},
+{0x1.0000001000000p-64, -0x1.fffffff804000p-131, 0x1.003ffffff8000p+483, 0x1.f00000007fc00p+425, 0x1.ff80201809f98p-548, 0x1.a8143b315e430p-604},
+{0x1.0000001000000p-64, -0x1.fffffff804000p-131, -0x1.003ffffff8000p+483, -0x1.f00000007fc00p+425, -0x1.ff80201809f98p-548, -0x1.a8143b315e430p-604},
+{-0x1.0000001000000p-64, 0x1.fffffff804000p-131, 0x1.003ffffff8000p+483, 0x1.f00000007fc00p+425, -0x1.ff80201809f98p-548, -0x1.a8143b315e430p-604},
+{-0x1.0000001000000p-64, 0x1.fffffff804000p-131, -0x1.003ffffff8000p+483, -0x1.f00000007fc00p+425, 0x1.ff80201809f98p-548, 0x1.a8143b315e430p-604},
+{0x1.1ffff80000000p-10, 0x1.ffffff7ff8000p-69, 0x1.00ff000000004p-167, -0x1.ffffff0000400p-230, 0x1.1ee234ad87262p+157, -0x1.99e41e6e04f48p+103},
+{0x1.1ffff80000000p-10, 0x1.ffffff7ff8000p-69, -0x1.00ff000000004p-167, 0x1.ffffff0000400p-230, -0x1.1ee234ad87262p+157, 0x1.99e41e6e04f48p+103},
+{-0x1.1ffff80000000p-10, -0x1.ffffff7ff8000p-69, 0x1.00ff000000004p-167, -0x1.ffffff0000400p-230, -0x1.1ee234ad87262p+157, 0x1.99e41e6e04f48p+103},
+{-0x1.1ffff80000000p-10, -0x1.ffffff7ff8000p-69, -0x1.00ff000000004p-167, 0x1.ffffff0000400p-230, 0x1.1ee234ad87262p+157, -0x1.99e41e6e04f48p+103},
+{0x1.000000ffff800p+869, 0x1.fffffc0000000p+786, 0x1.0008000000000p+602, -0x1.0000000000000p+534, 0x1.fff0027feb00ap+266, 0x1.feb80a1fb901ap+212},
+{0x1.000000ffff800p+869, 0x1.fffffc0000000p+786, -0x1.0008000000000p+602, 0x1.0000000000000p+534, -0x1.fff0027feb00ap+266, -0x1.feb80a1fb901ap+212},
+{-0x1.000000ffff800p+869, -0x1.fffffc0000000p+786, 0x1.0008000000000p+602, -0x1.0000000000000p+534, -0x1.fff0027feb00ap+266, -0x1.feb80a1fb901ap+212},
+{-0x1.000000ffff800p+869, -0x1.fffffc0000000p+786, -0x1.0008000000000p+602, 0x1.0000000000000p+534, 0x1.fff0027feb00ap+266, 0x1.feb80a1fb901ap+212},
+{0x1.0000183ffffc0p+625, 0x1.fff07fcfffffcp+571, 0x1.0000010000000p-809, -0x1.0000000000000p-884, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000183ffffc0p+625, 0x1.fff07fcfffffcp+571, -0x1.0000010000000p-809, 0x1.0000000000000p-884, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000183ffffc0p+625, -0x1.fff07fcfffffcp+571, 0x1.0000010000000p-809, -0x1.0000000000000p-884, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000183ffffc0p+625, -0x1.fff07fcfffffcp+571, -0x1.0000010000000p-809, 0x1.0000000000000p-884, INFINITY, 0x0.0000000000000p+0},
+{0x1.0001000000000p+252, -0x1.fffffff800400p+189, 0x1.0000800000000p+229, -0x1.fffff80100000p+156, 0x1.00007fffc0002p+23, -0x1.03bf7dfd41200p-39},
+{0x1.0001000000000p+252, -0x1.fffffff800400p+189, -0x1.0000800000000p+229, 0x1.fffff80100000p+156, -0x1.00007fffc0002p+23, 0x1.03bf7dfd41200p-39},
+{-0x1.0001000000000p+252, 0x1.fffffff800400p+189, 0x1.0000800000000p+229, -0x1.fffff80100000p+156, -0x1.00007fffc0002p+23, 0x1.03bf7dfd41200p-39},
+{-0x1.0001000000000p+252, 0x1.fffffff800400p+189, -0x1.0000800000000p+229, 0x1.fffff80100000p+156, 0x1.00007fffc0002p+23, -0x1.03bf7dfd41200p-39},
+{0x1.3ffff800fff81p+251, -0x1.0000000000000p+160, 0x1.1fffffff00000p-134, 0x1.fffffff000000p-211, 0x1.1c71c001e05e1p+385, -0x1.c571834f1dba0p+329},
+{0x1.3ffff800fff81p+251, -0x1.0000000000000p+160, -0x1.1fffffff00000p-134, -0x1.fffffff000000p-211, -0x1.1c71c001e05e1p+385, 0x1.c571834f1dba0p+329},
+{-0x1.3ffff800fff81p+251, 0x1.0000000000000p+160, 0x1.1fffffff00000p-134, 0x1.fffffff000000p-211, -0x1.1c71c001e05e1p+385, 0x1.c571834f1dba0p+329},
+{-0x1.3ffff800fff81p+251, 0x1.0000000000000p+160, -0x1.1fffffff00000p-134, -0x1.fffffff000000p-211, 0x1.1c71c001e05e1p+385, -0x1.c571834f1dba0p+329},
+{0x1.fffffc0000100p+380, -0x1.fffe000040000p+309, 0x1.0000800000000p+410, -0x1.c000fffffffd0p+353, 0x1.fffefc00820fcp-30, 0x1.703780ec1f1f0p-87},
+{0x1.fffffc0000100p+380, -0x1.fffe000040000p+309, -0x1.0000800000000p+410, 0x1.c000fffffffd0p+353, -0x1.fffefc00820fcp-30, -0x1.703780ec1f1f0p-87},
+{-0x1.fffffc0000100p+380, 0x1.fffe000040000p+309, 0x1.0000800000000p+410, -0x1.c000fffffffd0p+353, -0x1.fffefc00820fcp-30, -0x1.703780ec1f1f0p-87},
+{-0x1.fffffc0000100p+380, 0x1.fffe000040000p+309, -0x1.0000800000000p+410, 0x1.c000fffffffd0p+353, 0x1.fffefc00820fcp-30, 0x1.703780ec1f1f0p-87},
+{0x1.003f80ff00004p-166, -0x1.ffffc00040000p-237, 0x1.0000ffffff000p+849, 0x1.ffe000003ffe0p+791, 0x1.003e80c080400p-1015, -0x1.2000000000000p-1070},
+{0x1.003f80ff00004p-166, -0x1.ffffc00040000p-237, -0x1.0000ffffff000p+849, -0x1.ffe000003ffe0p+791, -0x1.003e80c080400p-1015, 0x1.2000000000000p-1070},
+{-0x1.003f80ff00004p-166, 0x1.ffffc00040000p-237, 0x1.0000ffffff000p+849, 0x1.ffe000003ffe0p+791, -0x1.003e80c080400p-1015, 0x1.2000000000000p-1070},
+{-0x1.003f80ff00004p-166, 0x1.ffffc00040000p-237, -0x1.0000ffffff000p+849, -0x1.ffe000003ffe0p+791, 0x1.003e80c080400p-1015, -0x1.2000000000000p-1070},
+{0x1.000003fffff80p-485, 0x1.f007ffe00fc00p-548, 0x1.3ff8007ffffc0p+163, 0x1.e0007ff000000p+97, 0x1.99a3dd0e7862fp-649, -0x1.e94ba8273c842p-703},
+{0x1.000003fffff80p-485, 0x1.f007ffe00fc00p-548, -0x1.3ff8007ffffc0p+163, -0x1.e0007ff000000p+97, -0x1.99a3dd0e7862fp-649, 0x1.e94ba8273c842p-703},
+{-0x1.000003fffff80p-485, -0x1.f007ffe00fc00p-548, 0x1.3ff8007ffffc0p+163, 0x1.e0007ff000000p+97, -0x1.99a3dd0e7862fp-649, 0x1.e94ba8273c842p-703},
+{-0x1.000003fffff80p-485, -0x1.f007ffe00fc00p-548, -0x1.3ff8007ffffc0p+163, -0x1.e0007ff000000p+97, 0x1.99a3dd0e7862fp-649, -0x1.e94ba8273c842p-703},
+{0x1.ffffffe000000p-232, -0x1.ff80000020000p-288, 0x1.0000ffffff81fp+818, 0x1.ffc7fff800000p+754, 0x1.fffe000000000p-1050, -0x0.0000000000000p+0},
+{0x1.ffffffe000000p-232, -0x1.ff80000020000p-288, -0x1.0000ffffff81fp+818, -0x1.ffc7fff800000p+754, -0x1.fffe000000000p-1050, 0x0.0000000000000p+0},
+{-0x1.ffffffe000000p-232, 0x1.ff80000020000p-288, 0x1.0000ffffff81fp+818, 0x1.ffc7fff800000p+754, -0x1.fffe000000000p-1050, 0x0.0000000000000p+0},
+{-0x1.ffffffe000000p-232, 0x1.ff80000020000p-288, -0x1.0000ffffff81fp+818, -0x1.ffc7fff800000p+754, 0x1.fffe000000000p-1050, -0x0.0000000000000p+0},
+{0x1.0000000800000p-741, -0x1.ffffc02000000p-819, 0x1.7fffe00800000p-232, -0x1.0000000000000p-337, 0x1.555571caad093p-510, -0x1.e0b116af638a0p-568},
+{0x1.0000000800000p-741, -0x1.ffffc02000000p-819, -0x1.7fffe00800000p-232, 0x1.0000000000000p-337, -0x1.555571caad093p-510, 0x1.e0b116af638a0p-568},
+{-0x1.0000000800000p-741, 0x1.ffffc02000000p-819, 0x1.7fffe00800000p-232, -0x1.0000000000000p-337, -0x1.555571caad093p-510, 0x1.e0b116af638a0p-568},
+{-0x1.0000000800000p-741, 0x1.ffffc02000000p-819, -0x1.7fffe00800000p-232, 0x1.0000000000000p-337, 0x1.555571caad093p-510, -0x1.e0b116af638a0p-568},
+{0x1.0000400000000p-741, -0x1.0000000000000p-832, 0x1.4000000000000p-919, -0x1.ffffffff00020p-977, 0x1.999a000000000p+177, 0x1.47ae66655c2a0p+120},
+{0x1.0000400000000p-741, -0x1.0000000000000p-832, -0x1.4000000000000p-919, 0x1.ffffffff00020p-977, -0x1.999a000000000p+177, -0x1.47ae66655c2a0p+120},
+{-0x1.0000400000000p-741, 0x1.0000000000000p-832, 0x1.4000000000000p-919, -0x1.ffffffff00020p-977, -0x1.999a000000000p+177, -0x1.47ae66655c2a0p+120},
+{-0x1.0000400000000p-741, 0x1.0000000000000p-832, -0x1.4000000000000p-919, 0x1.ffffffff00020p-977, 0x1.999a000000000p+177, 0x1.47ae66655c2a0p+120},
+{0x1.000000fffff80p+807, 0x1.ffffef003e000p+744, 0x1.0000010000000p+666, -0x1.8000000000020p+608, 0x1.fffffffffff00p+140, 0x1.901ffde7e1e80p+83},
+{0x1.000000fffff80p+807, 0x1.ffffef003e000p+744, -0x1.0000010000000p+666, 0x1.8000000000020p+608, -0x1.fffffffffff00p+140, -0x1.901ffde7e1e80p+83},
+{-0x1.000000fffff80p+807, -0x1.ffffef003e000p+744, 0x1.0000010000000p+666, -0x1.8000000000020p+608, -0x1.fffffffffff00p+140, -0x1.901ffde7e1e80p+83},
+{-0x1.000000fffff80p+807, -0x1.ffffef003e000p+744, -0x1.0000010000000p+666, 0x1.8000000000020p+608, 0x1.fffffffffff00p+140, 0x1.901ffde7e1e80p+83},
+{0x1.7fffffffc0000p-420, 0x1.fffc000000000p-490, 0x1.0000001fe0000p+340, 0x1.fffffc0001f00p+279, 0x1.7fffffcff0000p-760, 0x1.79017fd9cf2a6p-814},
+{0x1.7fffffffc0000p-420, 0x1.fffc000000000p-490, -0x1.0000001fe0000p+340, -0x1.fffffc0001f00p+279, -0x1.7fffffcff0000p-760, -0x1.79017fd9cf2a6p-814},
+{-0x1.7fffffffc0000p-420, -0x1.fffc000000000p-490, 0x1.0000001fe0000p+340, 0x1.fffffc0001f00p+279, -0x1.7fffffcff0000p-760, -0x1.79017fd9cf2a6p-814},
+{-0x1.7fffffffc0000p-420, -0x1.fffc000000000p-490, -0x1.0000001fe0000p+340, -0x1.fffffc0001f00p+279, 0x1.7fffffcff0000p-760, 0x1.79017fd9cf2a6p-814},
+{0x1.0000004000000p-97, -0x1.0000000000000p-155, 0x1.8000000000000p-464, -0x1.ffe7ffc001000p-529, 0x1.555555aaaaaabp+366, -0x1.6a71c9c71555ep+312},
+{0x1.0000004000000p-97, -0x1.0000000000000p-155, -0x1.8000000000000p-464, 0x1.ffe7ffc001000p-529, -0x1.555555aaaaaabp+366, 0x1.6a71c9c71555ep+312},
+{-0x1.0000004000000p-97, 0x1.0000000000000p-155, 0x1.8000000000000p-464, -0x1.ffe7ffc001000p-529, -0x1.555555aaaaaabp+366, 0x1.6a71c9c71555ep+312},
+{-0x1.0000004000000p-97, 0x1.0000000000000p-155, -0x1.8000000000000p-464, 0x1.ffe7ffc001000p-529, 0x1.555555aaaaaabp+366, -0x1.6a71c9c71555ep+312},
+{0x1.0000000800000p-953, -0x1.fffffff400000p-1028, 0x1.007fc00007800p-531, 0x1.e0000f80001e0p-589, 0x1.ff00ff5088975p-423, -0x1.eb9bace924318p-479},
+{0x1.0000000800000p-953, -0x1.fffffff400000p-1028, -0x1.007fc00007800p-531, -0x1.e0000f80001e0p-589, -0x1.ff00ff5088975p-423, 0x1.eb9bace924318p-479},
+{-0x1.0000000800000p-953, 0x1.fffffff400000p-1028, 0x1.007fc00007800p-531, 0x1.e0000f80001e0p-589, -0x1.ff00ff5088975p-423, 0x1.eb9bace924318p-479},
+{-0x1.0000000800000p-953, 0x1.fffffff400000p-1028, -0x1.007fc00007800p-531, -0x1.e0000f80001e0p-589, 0x1.ff00ff5088975p-423, -0x1.eb9bace924318p-479},
+{0x1.3fffff0000000p+486, 0x1.fffffe0000000p+423, 0x1.0000200000000p-608, -0x1.0000000000000p-713, INFINITY, 0x0.0000000000000p+0},
+{0x1.3fffff0000000p+486, 0x1.fffffe0000000p+423, -0x1.0000200000000p-608, 0x1.0000000000000p-713, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.3fffff0000000p+486, -0x1.fffffe0000000p+423, 0x1.0000200000000p-608, -0x1.0000000000000p-713, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.3fffff0000000p+486, -0x1.fffffe0000000p+423, -0x1.0000200000000p-608, 0x1.0000000000000p-713, INFINITY, 0x0.0000000000000p+0},
+{0x1.7fe0000000008p-874, -0x1.fffff3ff80200p-936, 0x1.000001fff8400p+934, -0x1.fffff80010000p+869, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.7fe0000000008p-874, -0x1.fffff3ff80200p-936, -0x1.000001fff8400p+934, 0x1.fffff80010000p+869, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.7fe0000000008p-874, 0x1.fffff3ff80200p-936, 0x1.000001fff8400p+934, -0x1.fffff80010000p+869, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.7fe0000000008p-874, 0x1.fffff3ff80200p-936, -0x1.000001fff8400p+934, 0x1.fffff80010000p+869, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00000fffffff8p-940, 0x1.fffffffc00000p-999, 0x1.0000007001000p+288, -0x1.e00000fff8200p+228, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00000fffffff8p-940, 0x1.fffffffc00000p-999, -0x1.0000007001000p+288, 0x1.e00000fff8200p+228, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00000fffffff8p-940, -0x1.fffffffc00000p-999, 0x1.0000007001000p+288, -0x1.e00000fff8200p+228, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00000fffffff8p-940, -0x1.fffffffc00000p-999, -0x1.0000007001000p+288, 0x1.e00000fff8200p+228, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.001fffc000400p-967, -0x1.e000000001000p-1032, 0x1.0200000000000p+224, -0x1.0000000000000p+121, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.001fffc000400p-967, -0x1.e000000001000p-1032, -0x1.0200000000000p+224, 0x1.0000000000000p+121, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.001fffc000400p-967, 0x1.e000000001000p-1032, 0x1.0200000000000p+224, -0x1.0000000000000p+121, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.001fffc000400p-967, 0x1.e000000001000p-1032, -0x1.0200000000000p+224, 0x1.0000000000000p+121, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000008000000p-97, -0x1.0000000000000p-167, 0x1.07fff80000002p-376, -0x1.c010000000000p-447, 0x1.f07c2f0b854dbp+278, 0x1.2c698df3c3460p+221},
+{0x1.0000008000000p-97, -0x1.0000000000000p-167, -0x1.07fff80000002p-376, 0x1.c010000000000p-447, -0x1.f07c2f0b854dbp+278, -0x1.2c698df3c3460p+221},
+{-0x1.0000008000000p-97, 0x1.0000000000000p-167, 0x1.07fff80000002p-376, -0x1.c010000000000p-447, -0x1.f07c2f0b854dbp+278, -0x1.2c698df3c3460p+221},
+{-0x1.0000008000000p-97, 0x1.0000000000000p-167, -0x1.07fff80000002p-376, 0x1.c010000000000p-447, 0x1.f07c2f0b854dbp+278, 0x1.2c698df3c3460p+221},
+{0x1.03ffffffe0000p+781, 0x1.ff80000000000p+692, 0x1.7ffff00000002p-601, -0x1.0000000000000p-694, INFINITY, 0x0.0000000000000p+0},
+{0x1.03ffffffe0000p+781, 0x1.ff80000000000p+692, -0x1.7ffff00000002p-601, 0x1.0000000000000p-694, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.03ffffffe0000p+781, -0x1.ff80000000000p+692, 0x1.7ffff00000002p-601, -0x1.0000000000000p-694, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.03ffffffe0000p+781, -0x1.ff80000000000p+692, -0x1.7ffff00000002p-601, 0x1.0000000000000p-694, INFINITY, 0x0.0000000000000p+0},
+{0x1.0008000000000p+386, -0x1.9000000000000p+285, 0x1.0000000700002p+420, -0x1.fffff80200000p+357, 0x1.0007fff8ffc7ep-34, 0x1.a00d4d7413580p-93},
+{0x1.0008000000000p+386, -0x1.9000000000000p+285, -0x1.0000000700002p+420, 0x1.fffff80200000p+357, -0x1.0007fff8ffc7ep-34, -0x1.a00d4d7413580p-93},
+{-0x1.0008000000000p+386, 0x1.9000000000000p+285, 0x1.0000000700002p+420, -0x1.fffff80200000p+357, -0x1.0007fff8ffc7ep-34, -0x1.a00d4d7413580p-93},
+{-0x1.0008000000000p+386, 0x1.9000000000000p+285, -0x1.0000000700002p+420, 0x1.fffff80200000p+357, 0x1.0007fff8ffc7ep-34, 0x1.a00d4d7413580p-93},
+{0x1.0010000000000p-808, -0x1.0000000000000p-885, 0x1.007fc00001000p-874, -0x1.ff80000400000p-930, 0x1.ff20ef50918c4p+65, 0x1.5059d3d1c2168p+9},
+{0x1.0010000000000p-808, -0x1.0000000000000p-885, -0x1.007fc00001000p-874, 0x1.ff80000400000p-930, -0x1.ff20ef50918c4p+65, -0x1.5059d3d1c2168p+9},
+{-0x1.0010000000000p-808, 0x1.0000000000000p-885, 0x1.007fc00001000p-874, -0x1.ff80000400000p-930, -0x1.ff20ef50918c4p+65, -0x1.5059d3d1c2168p+9},
+{-0x1.0010000000000p-808, 0x1.0000000000000p-885, -0x1.007fc00001000p-874, 0x1.ff80000400000p-930, 0x1.ff20ef50918c4p+65, 0x1.5059d3d1c2168p+9},
+{0x1.0000008000000p+531, -0x1.fff0000000100p+472, 0x1.7fffff8100000p-278, -0x1.fffcc00000080p-338, 0x1.55555670e38e9p+808, 0x1.9c985b0496336p+754},
+{0x1.0000008000000p+531, -0x1.fff0000000100p+472, -0x1.7fffff8100000p-278, 0x1.fffcc00000080p-338, -0x1.55555670e38e9p+808, -0x1.9c985b0496336p+754},
+{-0x1.0000008000000p+531, 0x1.fff0000000100p+472, 0x1.7fffff8100000p-278, -0x1.fffcc00000080p-338, -0x1.55555670e38e9p+808, -0x1.9c985b0496336p+754},
+{-0x1.0000008000000p+531, 0x1.fff0000000100p+472, -0x1.7fffff8100000p-278, 0x1.fffcc00000080p-338, 0x1.55555670e38e9p+808, 0x1.9c985b0496336p+754},
+{0x1.0000003ffc010p-568, -0x1.ffffc00400000p-637, 0x1.0000c00400000p+799, -0x1.ff80800000000p+718, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000003ffc010p-568, -0x1.ffffc00400000p-637, -0x1.0000c00400000p+799, 0x1.ff80800000000p+718, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000003ffc010p-568, 0x1.ffffc00400000p-637, 0x1.0000c00400000p+799, -0x1.ff80800000000p+718, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000003ffc010p-568, 0x1.ffffc00400000p-637, -0x1.0000c00400000p+799, 0x1.ff80800000000p+718, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000007fff800p-430, 0x1.ffff800007fc0p-489, 0x1.0000007fff000p+851, 0x1.ffffff8000000p+776, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000007fff800p-430, 0x1.ffff800007fc0p-489, -0x1.0000007fff000p+851, -0x1.ffffff8000000p+776, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000007fff800p-430, -0x1.ffff800007fc0p-489, 0x1.0000007fff000p+851, 0x1.ffffff8000000p+776, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000007fff800p-430, -0x1.ffff800007fc0p-489, -0x1.0000007fff000p+851, -0x1.ffffff8000000p+776, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.4000000000000p-853, -0x1.0000000000000p-935, 0x1.0000001ff8040p+392, -0x1.fff0ffffff008p+336, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.4000000000000p-853, -0x1.0000000000000p-935, -0x1.0000001ff8040p+392, 0x1.fff0ffffff008p+336, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.4000000000000p-853, 0x1.0000000000000p-935, 0x1.0000001ff8040p+392, -0x1.fff0ffffff008p+336, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.4000000000000p-853, 0x1.0000000000000p-935, -0x1.0000001ff8040p+392, 0x1.fff0ffffff008p+336, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0004000000000p+80, -0x1.fffffffe40000p+9, 0x1.000001ffff1f0p+442, 0x1.ff807ffffc000p+388, 0x1.0003fdfff8e50p-362, -0x1.1b6c795bc3930p-416},
+{0x1.0004000000000p+80, -0x1.fffffffe40000p+9, -0x1.000001ffff1f0p+442, -0x1.ff807ffffc000p+388, -0x1.0003fdfff8e50p-362, 0x1.1b6c795bc3930p-416},
+{-0x1.0004000000000p+80, 0x1.fffffffe40000p+9, 0x1.000001ffff1f0p+442, 0x1.ff807ffffc000p+388, -0x1.0003fdfff8e50p-362, 0x1.1b6c795bc3930p-416},
+{-0x1.0004000000000p+80, 0x1.fffffffe40000p+9, -0x1.000001ffff1f0p+442, -0x1.ff807ffffc000p+388, 0x1.0003fdfff8e50p-362, -0x1.1b6c795bc3930p-416},
+{0x1.003fe00030100p-112, -0x1.00003fe002000p-178, 0x1.3ffffff800200p+913, -0x1.0000000000000p+836, 0x1.99ffccd759890p-1026, -0x0.0000000000000p+0},
+{0x1.003fe00030100p-112, -0x1.00003fe002000p-178, -0x1.3ffffff800200p+913, 0x1.0000000000000p+836, -0x1.99ffccd759890p-1026, 0x0.0000000000000p+0},
+{-0x1.003fe00030100p-112, 0x1.00003fe002000p-178, 0x1.3ffffff800200p+913, -0x1.0000000000000p+836, -0x1.99ffccd759890p-1026, 0x0.0000000000000p+0},
+{-0x1.003fe00030100p-112, 0x1.00003fe002000p-178, -0x1.3ffffff800200p+913, 0x1.0000000000000p+836, 0x1.99ffccd759890p-1026, -0x0.0000000000000p+0},
+{0x1.0001ffc1ffc20p+846, -0x1.fffffc0002000p+780, 0x1.000003fffffc0p-56, 0x1.fffffe0000000p-134, 0x1.0001fbc1f7d70p+902, -0x1.f5fb3830001ccp+848},
+{0x1.0001ffc1ffc20p+846, -0x1.fffffc0002000p+780, -0x1.000003fffffc0p-56, -0x1.fffffe0000000p-134, -0x1.0001fbc1f7d70p+902, 0x1.f5fb3830001ccp+848},
+{-0x1.0001ffc1ffc20p+846, 0x1.fffffc0002000p+780, 0x1.000003fffffc0p-56, 0x1.fffffe0000000p-134, -0x1.0001fbc1f7d70p+902, 0x1.f5fb3830001ccp+848},
+{-0x1.0001ffc1ffc20p+846, 0x1.fffffc0002000p+780, -0x1.000003fffffc0p-56, -0x1.fffffe0000000p-134, 0x1.0001fbc1f7d70p+902, -0x1.f5fb3830001ccp+848},
+{0x1.0400000000000p-92, -0x1.0000000000000p-146, 0x1.0000200000000p+893, -0x1.ffffffffffc40p+834, 0x1.03ffdf8004100p-985, -0x1.103fe00000000p-1039},
+{0x1.0400000000000p-92, -0x1.0000000000000p-146, -0x1.0000200000000p+893, 0x1.ffffffffffc40p+834, -0x1.03ffdf8004100p-985, 0x1.103fe00000000p-1039},
+{-0x1.0400000000000p-92, 0x1.0000000000000p-146, 0x1.0000200000000p+893, -0x1.ffffffffffc40p+834, -0x1.03ffdf8004100p-985, 0x1.103fe00000000p-1039},
+{-0x1.0400000000000p-92, 0x1.0000000000000p-146, -0x1.0000200000000p+893, 0x1.ffffffffffc40p+834, 0x1.03ffdf8004100p-985, -0x1.103fe00000000p-1039},
+{0x1.00003ff820000p-373, -0x1.ffffffe000100p-428, 0x1.0001f80020000p-217, -0x1.ffffffc1c0040p-276, 0x1.fffc8ff6c4929p-157, 0x1.c04a167bfc32cp-212},
+{0x1.00003ff820000p-373, -0x1.ffffffe000100p-428, -0x1.0001f80020000p-217, 0x1.ffffffc1c0040p-276, -0x1.fffc8ff6c4929p-157, -0x1.c04a167bfc32cp-212},
+{-0x1.00003ff820000p-373, 0x1.ffffffe000100p-428, 0x1.0001f80020000p-217, -0x1.ffffffc1c0040p-276, -0x1.fffc8ff6c4929p-157, -0x1.c04a167bfc32cp-212},
+{-0x1.00003ff820000p-373, 0x1.ffffffe000100p-428, -0x1.0001f80020000p-217, 0x1.ffffffc1c0040p-276, 0x1.fffc8ff6c4929p-157, 0x1.c04a167bfc32cp-212},
+{0x1.007ffffffff80p+570, 0x1.fffffffe00000p+496, 0x1.0100000000000p-172, -0x1.0000000000000p-249, 0x1.ff00ff00fef11p+741, -0x1.0ef00007f0190p+685},
+{0x1.007ffffffff80p+570, 0x1.fffffffe00000p+496, -0x1.0100000000000p-172, 0x1.0000000000000p-249, -0x1.ff00ff00fef11p+741, 0x1.0ef00007f0190p+685},
+{-0x1.007ffffffff80p+570, -0x1.fffffffe00000p+496, 0x1.0100000000000p-172, -0x1.0000000000000p-249, -0x1.ff00ff00fef11p+741, 0x1.0ef00007f0190p+685},
+{-0x1.007ffffffff80p+570, -0x1.fffffffe00000p+496, -0x1.0100000000000p-172, 0x1.0000000000000p-249, 0x1.ff00ff00fef11p+741, -0x1.0ef00007f0190p+685},
+{0x1.0000000400000p-622, -0x1.e00003fff8200p-684, 0x1.000ffff802000p-88, -0x1.fffe3fffffe00p-150, 0x1.ffe00217d982cp-535, -0x1.dbfb6b1d22926p-589},
+{0x1.0000000400000p-622, -0x1.e00003fff8200p-684, -0x1.000ffff802000p-88, 0x1.fffe3fffffe00p-150, -0x1.ffe00217d982cp-535, 0x1.dbfb6b1d22926p-589},
+{-0x1.0000000400000p-622, 0x1.e00003fff8200p-684, 0x1.000ffff802000p-88, -0x1.fffe3fffffe00p-150, -0x1.ffe00217d982cp-535, 0x1.dbfb6b1d22926p-589},
+{-0x1.0000000400000p-622, 0x1.e00003fff8200p-684, -0x1.000ffff802000p-88, 0x1.fffe3fffffe00p-150, 0x1.ffe00217d982cp-535, -0x1.dbfb6b1d22926p-589},
+{0x1.00003ffffff00p+633, 0x1.ffc003ffffe00p+578, 0x1.0001ff0000000p+629, 0x1.ff8007fffffe0p+574, 0x1.fffc8206f8541p+3, 0x1.944d561338738p-51},
+{0x1.00003ffffff00p+633, 0x1.ffc003ffffe00p+578, -0x1.0001ff0000000p+629, -0x1.ff8007fffffe0p+574, -0x1.fffc8206f8541p+3, -0x1.944d561338738p-51},
+{-0x1.00003ffffff00p+633, -0x1.ffc003ffffe00p+578, 0x1.0001ff0000000p+629, 0x1.ff8007fffffe0p+574, -0x1.fffc8206f8541p+3, -0x1.944d561338738p-51},
+{-0x1.00003ffffff00p+633, -0x1.ffc003ffffe00p+578, -0x1.0001ff0000000p+629, -0x1.ff8007fffffe0p+574, 0x1.fffc8206f8541p+3, 0x1.944d561338738p-51},
+{0x1.1000000000000p+920, -0x1.ff00000001000p+855, 0x1.0200000000000p-494, -0x1.c000000000008p-550, INFINITY, 0x0.0000000000000p+0},
+{0x1.1000000000000p+920, -0x1.ff00000001000p+855, -0x1.0200000000000p-494, 0x1.c000000000008p-550, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.1000000000000p+920, 0x1.ff00000001000p+855, 0x1.0200000000000p-494, -0x1.c000000000008p-550, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.1000000000000p+920, 0x1.ff00000001000p+855, -0x1.0200000000000p-494, 0x1.c000000000008p-550, INFINITY, 0x0.0000000000000p+0},
+{0x1.1fffffc000000p+266, 0x1.ffffffffffff0p+209, 0x1.007fc00000800p-488, -0x1.fffff03fff000p-548, 0x1.1f708f547908ep+754, 0x1.5692f64f2b738p+699},
+{0x1.1fffffc000000p+266, 0x1.ffffffffffff0p+209, -0x1.007fc00000800p-488, 0x1.fffff03fff000p-548, -0x1.1f708f547908ep+754, -0x1.5692f64f2b738p+699},
+{-0x1.1fffffc000000p+266, -0x1.ffffffffffff0p+209, 0x1.007fc00000800p-488, -0x1.fffff03fff000p-548, -0x1.1f708f547908ep+754, -0x1.5692f64f2b738p+699},
+{-0x1.1fffffc000000p+266, -0x1.ffffffffffff0p+209, -0x1.007fc00000800p-488, 0x1.fffff03fff000p-548, 0x1.1f708f547908ep+754, 0x1.5692f64f2b738p+699},
+{0x1.00007fffff000p+951, 0x1.ffffffff00000p+879, 0x1.1fffffffc0000p+24, 0x1.fff0000000000p-44, 0x1.c71d5555b8b13p+926, -0x1.2f9a266305f00p+869},
+{0x1.00007fffff000p+951, 0x1.ffffffff00000p+879, -0x1.1fffffffc0000p+24, -0x1.fff0000000000p-44, -0x1.c71d5555b8b13p+926, 0x1.2f9a266305f00p+869},
+{-0x1.00007fffff000p+951, -0x1.ffffffff00000p+879, 0x1.1fffffffc0000p+24, 0x1.fff0000000000p-44, -0x1.c71d5555b8b13p+926, 0x1.2f9a266305f00p+869},
+{-0x1.00007fffff000p+951, -0x1.ffffffff00000p+879, -0x1.1fffffffc0000p+24, -0x1.fff0000000000p-44, 0x1.c71d5555b8b13p+926, -0x1.2f9a266305f00p+869},
+{0x1.0003ffffffffcp+259, 0x1.f000000000000p+158, 0x1.0000003ffff80p+431, 0x1.fffffefff8000p+363, 0x1.0003ffbfff07dp-172, 0x1.00e05b827c740p-231},
+{0x1.0003ffffffffcp+259, 0x1.f000000000000p+158, -0x1.0000003ffff80p+431, -0x1.fffffefff8000p+363, -0x1.0003ffbfff07dp-172, -0x1.00e05b827c740p-231},
+{-0x1.0003ffffffffcp+259, -0x1.f000000000000p+158, 0x1.0000003ffff80p+431, 0x1.fffffefff8000p+363, -0x1.0003ffbfff07dp-172, -0x1.00e05b827c740p-231},
+{-0x1.0003ffffffffcp+259, -0x1.f000000000000p+158, -0x1.0000003ffff80p+431, -0x1.fffffefff8000p+363, 0x1.0003ffbfff07dp-172, 0x1.00e05b827c740p-231},
+{0x1.00007ffc00000p-308, 0x1.ffffe00000000p-377, 0x1.3fffffc004000p+942, -0x1.ffffe00010000p+878, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00007ffc00000p-308, 0x1.ffffe00000000p-377, -0x1.3fffffc004000p+942, 0x1.ffffe00010000p+878, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00007ffc00000p-308, -0x1.ffffe00000000p-377, 0x1.3fffffc004000p+942, -0x1.ffffe00010000p+878, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00007ffc00000p-308, -0x1.ffffe00000000p-377, -0x1.3fffffc004000p+942, 0x1.ffffe00010000p+878, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0007ffffc0004p+198, -0x1.fffffe0040000p+127, 0x1.00ffffe000400p-503, -0x1.0000000000000p-595, 0x1.fe11ee50f0cdfp+700, 0x1.eab4ac047c964p+646},
+{0x1.0007ffffc0004p+198, -0x1.fffffe0040000p+127, -0x1.00ffffe000400p-503, 0x1.0000000000000p-595, -0x1.fe11ee50f0cdfp+700, -0x1.eab4ac047c964p+646},
+{-0x1.0007ffffc0004p+198, 0x1.fffffe0040000p+127, 0x1.00ffffe000400p-503, -0x1.0000000000000p-595, -0x1.fe11ee50f0cdfp+700, -0x1.eab4ac047c964p+646},
+{-0x1.0007ffffc0004p+198, 0x1.fffffe0040000p+127, -0x1.00ffffe000400p-503, 0x1.0000000000000p-595, 0x1.fe11ee50f0cdfp+700, 0x1.eab4ac047c964p+646},
+{0x1.007ffffffff00p+38, 0x1.fff8003000000p-39, 0x1.01fffffffe000p-764, 0x1.fffc000000000p-852, 0x1.fd05f417d431bp+801, -0x1.da3f8ecab4cb2p+747},
+{0x1.007ffffffff00p+38, 0x1.fff8003000000p-39, -0x1.01fffffffe000p-764, -0x1.fffc000000000p-852, -0x1.fd05f417d431bp+801, 0x1.da3f8ecab4cb2p+747},
+{-0x1.007ffffffff00p+38, -0x1.fff8003000000p-39, 0x1.01fffffffe000p-764, 0x1.fffc000000000p-852, -0x1.fd05f417d431bp+801, 0x1.da3f8ecab4cb2p+747},
+{-0x1.007ffffffff00p+38, -0x1.fff8003000000p-39, -0x1.01fffffffe000p-764, -0x1.fffc000000000p-852, 0x1.fd05f417d431bp+801, -0x1.da3f8ecab4cb2p+747},
+{0x1.00003e0000000p+844, 0x1.ffffffffe0000p+785, 0x1.07ffffff80000p+555, 0x1.8007ffffc0000p+484, 0x1.f07c9746c22cep+288, 0x1.3edfd2a2574e4p+234},
+{0x1.00003e0000000p+844, 0x1.ffffffffe0000p+785, -0x1.07ffffff80000p+555, -0x1.8007ffffc0000p+484, -0x1.f07c9746c22cep+288, -0x1.3edfd2a2574e4p+234},
+{-0x1.00003e0000000p+844, -0x1.ffffffffe0000p+785, 0x1.07ffffff80000p+555, 0x1.8007ffffc0000p+484, -0x1.f07c9746c22cep+288, -0x1.3edfd2a2574e4p+234},
+{-0x1.00003e0000000p+844, -0x1.ffffffffe0000p+785, -0x1.07ffffff80000p+555, -0x1.8007ffffc0000p+484, 0x1.f07c9746c22cep+288, 0x1.3edfd2a2574e4p+234},
+{0x1.00003ff810000p+183, -0x1.fffffffc00800p+119, 0x1.00000ffff8002p+532, -0x1.fffffffe04000p+465, 0x1.00002ff815006p-349, 0x1.6fa53168c6300p-408},
+{0x1.00003ff810000p+183, -0x1.fffffffc00800p+119, -0x1.00000ffff8002p+532, 0x1.fffffffe04000p+465, -0x1.00002ff815006p-349, -0x1.6fa53168c6300p-408},
+{-0x1.00003ff810000p+183, 0x1.fffffffc00800p+119, 0x1.00000ffff8002p+532, -0x1.fffffffe04000p+465, -0x1.00002ff815006p-349, -0x1.6fa53168c6300p-408},
+{-0x1.00003ff810000p+183, 0x1.fffffffc00800p+119, -0x1.00000ffff8002p+532, 0x1.fffffffe04000p+465, 0x1.00002ff815006p-349, 0x1.6fa53168c6300p-408},
+{0x1.0100000000000p-963, -0x1.0000000000000p-1050, 0x1.01ffffff00004p+35, -0x1.0000000000000p-55, 0x1.fe03f811da4eep-999, -0x1.4936800000000p-1053},
+{0x1.0100000000000p-963, -0x1.0000000000000p-1050, -0x1.01ffffff00004p+35, 0x1.0000000000000p-55, -0x1.fe03f811da4eep-999, 0x1.4936800000000p-1053},
+{-0x1.0100000000000p-963, 0x1.0000000000000p-1050, 0x1.01ffffff00004p+35, -0x1.0000000000000p-55, -0x1.fe03f811da4eep-999, 0x1.4936800000000p-1053},
+{-0x1.0100000000000p-963, 0x1.0000000000000p-1050, -0x1.01ffffff00004p+35, 0x1.0000000000000p-55, 0x1.fe03f811da4eep-999, -0x1.4936800000000p-1053},
+{0x1.001fffffff800p+716, 0x1.fffff00000000p+636, 0x1.07ffe00001000p-16, -0x1.c7ffc001fe010p-73, 0x1.f0ba6ac140645p+731, -0x1.85bb11db4ee88p+676},
+{0x1.001fffffff800p+716, 0x1.fffff00000000p+636, -0x1.07ffe00001000p-16, 0x1.c7ffc001fe010p-73, -0x1.f0ba6ac140645p+731, 0x1.85bb11db4ee88p+676},
+{-0x1.001fffffff800p+716, -0x1.fffff00000000p+636, 0x1.07ffe00001000p-16, -0x1.c7ffc001fe010p-73, -0x1.f0ba6ac140645p+731, 0x1.85bb11db4ee88p+676},
+{-0x1.001fffffff800p+716, -0x1.fffff00000000p+636, -0x1.07ffe00001000p-16, 0x1.c7ffc001fe010p-73, 0x1.f0ba6ac140645p+731, -0x1.85bb11db4ee88p+676},
+{0x1.000000ffffff8p+223, 0x1.ffe0000000000p+151, 0x1.1fffffff00001p+902, -0x1.0000000000000p+817, 0x1.c71c738fcd6dap-680, 0x1.62af33c1d8a00p-735},
+{0x1.000000ffffff8p+223, 0x1.ffe0000000000p+151, -0x1.1fffffff00001p+902, 0x1.0000000000000p+817, -0x1.c71c738fcd6dap-680, -0x1.62af33c1d8a00p-735},
+{-0x1.000000ffffff8p+223, -0x1.ffe0000000000p+151, 0x1.1fffffff00001p+902, -0x1.0000000000000p+817, -0x1.c71c738fcd6dap-680, -0x1.62af33c1d8a00p-735},
+{-0x1.000000ffffff8p+223, -0x1.ffe0000000000p+151, -0x1.1fffffff00001p+902, 0x1.0000000000000p+817, 0x1.c71c738fcd6dap-680, 0x1.62af33c1d8a00p-735},
+{0x1.00000007fff00p+641, 0x1.fffc1ffff87f0p+585, 0x1.0000007c00000p+146, 0x1.fff0000000000p+75, 0x1.ffffff17ffe07p+494, 0x1.17ffe1f85d360p+440},
+{0x1.00000007fff00p+641, 0x1.fffc1ffff87f0p+585, -0x1.0000007c00000p+146, -0x1.fff0000000000p+75, -0x1.ffffff17ffe07p+494, -0x1.17ffe1f85d360p+440},
+{-0x1.00000007fff00p+641, -0x1.fffc1ffff87f0p+585, 0x1.0000007c00000p+146, 0x1.fff0000000000p+75, -0x1.ffffff17ffe07p+494, -0x1.17ffe1f85d360p+440},
+{-0x1.00000007fff00p+641, -0x1.fffc1ffff87f0p+585, -0x1.0000007c00000p+146, -0x1.fff0000000000p+75, 0x1.ffffff17ffe07p+494, 0x1.17ffe1f85d360p+440},
+{0x1.fffffffe00000p+119, 0x1.e000001fff800p+55, 0x1.0000000000000p+792, -0x1.f000080000000p+707, 0x1.fffffffe00000p-673, 0x1.e0001f2000000p-737},
+{0x1.fffffffe00000p+119, 0x1.e000001fff800p+55, -0x1.0000000000000p+792, 0x1.f000080000000p+707, -0x1.fffffffe00000p-673, -0x1.e0001f2000000p-737},
+{-0x1.fffffffe00000p+119, -0x1.e000001fff800p+55, 0x1.0000000000000p+792, -0x1.f000080000000p+707, -0x1.fffffffe00000p-673, -0x1.e0001f2000000p-737},
+{-0x1.fffffffe00000p+119, -0x1.e000001fff800p+55, -0x1.0000000000000p+792, 0x1.f000080000000p+707, 0x1.fffffffe00000p-673, 0x1.e0001f2000000p-737},
+{0x1.00007fffffe00p-629, 0x1.ffffff8000000p-699, 0x1.001f03f07ff00p-553, 0x1.ffffff8000000p-626, 0x1.ffc2ff82ff538p-77, -0x1.3d82a9119b388p-132},
+{0x1.00007fffffe00p-629, 0x1.ffffff8000000p-699, -0x1.001f03f07ff00p-553, -0x1.ffffff8000000p-626, -0x1.ffc2ff82ff538p-77, 0x1.3d82a9119b388p-132},
+{-0x1.00007fffffe00p-629, -0x1.ffffff8000000p-699, 0x1.001f03f07ff00p-553, 0x1.ffffff8000000p-626, -0x1.ffc2ff82ff538p-77, 0x1.3d82a9119b388p-132},
+{-0x1.00007fffffe00p-629, -0x1.ffffff8000000p-699, -0x1.001f03f07ff00p-553, -0x1.ffffff8000000p-626, 0x1.ffc2ff82ff538p-77, -0x1.3d82a9119b388p-132},
+{0x1.00003fffffffcp-120, 0x1.ffe0000700000p-193, 0x1.001f000000040p-170, 0x1.ffc0ffffc0000p-241, 0x1.ffc287719935fp+49, 0x1.b6b0fe47ab6b8p-6},
+{0x1.00003fffffffcp-120, 0x1.ffe0000700000p-193, -0x1.001f000000040p-170, -0x1.ffc0ffffc0000p-241, -0x1.ffc287719935fp+49, -0x1.b6b0fe47ab6b8p-6},
+{-0x1.00003fffffffcp-120, -0x1.ffe0000700000p-193, 0x1.001f000000040p-170, 0x1.ffc0ffffc0000p-241, -0x1.ffc287719935fp+49, -0x1.b6b0fe47ab6b8p-6},
+{-0x1.00003fffffffcp-120, -0x1.ffe0000700000p-193, -0x1.001f000000040p-170, -0x1.ffc0ffffc0000p-241, 0x1.ffc287719935fp+49, 0x1.b6b0fe47ab6b8p-6},
+{0x1.0000100000000p+396, -0x1.0000000000000p+314, 0x1.0000020000000p-778, -0x1.0000000000000p-870, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000100000000p+396, -0x1.0000000000000p+314, -0x1.0000020000000p-778, 0x1.0000000000000p-870, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000100000000p+396, 0x1.0000000000000p+314, 0x1.0000020000000p-778, -0x1.0000000000000p-870, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000100000000p+396, 0x1.0000000000000p+314, -0x1.0000020000000p-778, 0x1.0000000000000p-870, INFINITY, 0x0.0000000000000p+0},
+{0x1.000007c000000p-728, 0x1.fff8000000000p-784, 0x1.003fff0000200p-354, -0x1.fe0003fc00040p-413, 0x1.ff8031732328cp-375, -0x1.49885abdce908p-430},
+{0x1.000007c000000p-728, 0x1.fff8000000000p-784, -0x1.003fff0000200p-354, 0x1.fe0003fc00040p-413, -0x1.ff8031732328cp-375, 0x1.49885abdce908p-430},
+{-0x1.000007c000000p-728, -0x1.fff8000000000p-784, 0x1.003fff0000200p-354, -0x1.fe0003fc00040p-413, -0x1.ff8031732328cp-375, 0x1.49885abdce908p-430},
+{-0x1.000007c000000p-728, -0x1.fff8000000000p-784, -0x1.003fff0000200p-354, 0x1.fe0003fc00040p-413, 0x1.ff8031732328cp-375, -0x1.49885abdce908p-430},
+{0x1.00001fffcffc0p-216, -0x1.fffe000000004p-271, 0x1.03fffff800000p+515, 0x1.fffffe0000000p+447, 0x1.f81fc10b34257p-732, -0x1.5454259251f24p-786},
+{0x1.00001fffcffc0p-216, -0x1.fffe000000004p-271, -0x1.03fffff800000p+515, -0x1.fffffe0000000p+447, -0x1.f81fc10b34257p-732, 0x1.5454259251f24p-786},
+{-0x1.00001fffcffc0p-216, 0x1.fffe000000004p-271, 0x1.03fffff800000p+515, 0x1.fffffe0000000p+447, -0x1.f81fc10b34257p-732, 0x1.5454259251f24p-786},
+{-0x1.00001fffcffc0p-216, 0x1.fffe000000004p-271, -0x1.03fffff800000p+515, -0x1.fffffe0000000p+447, 0x1.f81fc10b34257p-732, -0x1.5454259251f24p-786},
+{0x1.0000008000000p-347, -0x1.ffffff8200000p-404, 0x1.000fff8000000p+341, 0x1.fffffe0000000p+279, 0x1.ffe003ffb0070p-689, -0x1.53e881ead4d3cp-744},
+{0x1.0000008000000p-347, -0x1.ffffff8200000p-404, -0x1.000fff8000000p+341, -0x1.fffffe0000000p+279, -0x1.ffe003ffb0070p-689, 0x1.53e881ead4d3cp-744},
+{-0x1.0000008000000p-347, 0x1.ffffff8200000p-404, 0x1.000fff8000000p+341, 0x1.fffffe0000000p+279, -0x1.ffe003ffb0070p-689, 0x1.53e881ead4d3cp-744},
+{-0x1.0000008000000p-347, 0x1.ffffff8200000p-404, -0x1.000fff8000000p+341, -0x1.fffffe0000000p+279, 0x1.ffe003ffb0070p-689, -0x1.53e881ead4d3cp-744},
+{0x1.00000010001f8p-866, 0x1.fffc007e00000p-940, 0x1.0003fc0000000p+17, 0x1.ffff80ffffc00p-40, 0x1.fff8083fbf610p-884, -0x1.0ce0e337685c0p-941},
+{0x1.00000010001f8p-866, 0x1.fffc007e00000p-940, -0x1.0003fc0000000p+17, -0x1.ffff80ffffc00p-40, -0x1.fff8083fbf610p-884, 0x1.0ce0e337685c0p-941},
+{-0x1.00000010001f8p-866, -0x1.fffc007e00000p-940, 0x1.0003fc0000000p+17, 0x1.ffff80ffffc00p-40, -0x1.fff8083fbf610p-884, 0x1.0ce0e337685c0p-941},
+{-0x1.00000010001f8p-866, -0x1.fffc007e00000p-940, -0x1.0003fc0000000p+17, -0x1.ffff80ffffc00p-40, 0x1.fff8083fbf610p-884, -0x1.0ce0e337685c0p-941},
+{0x1.0000000000000p-406, -0x1.0000000000000p-501, 0x1.0300000001f00p+916, 0x1.fffffff800000p+840, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000000000000p-406, -0x1.0000000000000p-501, -0x1.0300000001f00p+916, -0x1.fffffff800000p+840, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000000000p-406, 0x1.0000000000000p-501, 0x1.0300000001f00p+916, 0x1.fffffff800000p+840, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000000000p-406, 0x1.0000000000000p-501, -0x1.0300000001f00p+916, -0x1.fffffff800000p+840, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.07ffffff1fe00p-512, 0x1.fc00000000000p-609, 0x1.0040000000000p-704, -0x1.c000000400000p-765, 0x1.07be107b011fcp+192, -0x1.f7e6ed0b063d2p+138},
+{0x1.07ffffff1fe00p-512, 0x1.fc00000000000p-609, -0x1.0040000000000p-704, 0x1.c000000400000p-765, -0x1.07be107b011fcp+192, 0x1.f7e6ed0b063d2p+138},
+{-0x1.07ffffff1fe00p-512, -0x1.fc00000000000p-609, 0x1.0040000000000p-704, -0x1.c000000400000p-765, -0x1.07be107b011fcp+192, 0x1.f7e6ed0b063d2p+138},
+{-0x1.07ffffff1fe00p-512, -0x1.fc00000000000p-609, -0x1.0040000000000p-704, 0x1.c000000400000p-765, 0x1.07be107b011fcp+192, -0x1.f7e6ed0b063d2p+138},
+{0x1.0080000000000p+198, -0x1.0000000000000p+93, 0x1.fffff1ff80000p-814, 0x1.ffffc000fe000p-869, 0x1.00800703c0512p+1011, -0x1.7f7600e4b93c0p+957},
+{0x1.0080000000000p+198, -0x1.0000000000000p+93, -0x1.fffff1ff80000p-814, -0x1.ffffc000fe000p-869, -0x1.00800703c0512p+1011, 0x1.7f7600e4b93c0p+957},
+{-0x1.0080000000000p+198, 0x1.0000000000000p+93, 0x1.fffff1ff80000p-814, 0x1.ffffc000fe000p-869, -0x1.00800703c0512p+1011, 0x1.7f7600e4b93c0p+957},
+{-0x1.0080000000000p+198, 0x1.0000000000000p+93, -0x1.fffff1ff80000p-814, -0x1.ffffc000fe000p-869, 0x1.00800703c0512p+1011, -0x1.7f7600e4b93c0p+957},
+{0x1.0400000000000p+566, -0x1.0000000000000p+461, 0x1.7fffe00000008p+712, -0x1.e000080000000p+632, 0x1.5aaac78e3b4b6p-147, 0x1.ae0183122f590p-201},
+{0x1.0400000000000p+566, -0x1.0000000000000p+461, -0x1.7fffe00000008p+712, 0x1.e000080000000p+632, -0x1.5aaac78e3b4b6p-147, -0x1.ae0183122f590p-201},
+{-0x1.0400000000000p+566, 0x1.0000000000000p+461, 0x1.7fffe00000008p+712, -0x1.e000080000000p+632, -0x1.5aaac78e3b4b6p-147, -0x1.ae0183122f590p-201},
+{-0x1.0400000000000p+566, 0x1.0000000000000p+461, -0x1.7fffe00000008p+712, 0x1.e000080000000p+632, 0x1.5aaac78e3b4b6p-147, 0x1.ae0183122f590p-201},
+{0x1.000001d000000p-530, -0x1.ff80000200000p-585, 0x1.0000003fffffcp+783, 0x1.feffff8000000p+703, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.000001d000000p-530, -0x1.ff80000200000p-585, -0x1.0000003fffffcp+783, -0x1.feffff8000000p+703, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.000001d000000p-530, 0x1.ff80000200000p-585, 0x1.0000003fffffcp+783, 0x1.feffff8000000p+703, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.000001d000000p-530, 0x1.ff80000200000p-585, -0x1.0000003fffffcp+783, -0x1.feffff8000000p+703, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.001ffffffffc0p+355, 0x1.fffffff03ff00p+294, 0x1.0000010000000p-724, -0x1.fffffff810000p-793, INFINITY, 0x0.0000000000000p+0},
+{0x1.001ffffffffc0p+355, 0x1.fffffff03ff00p+294, -0x1.0000010000000p-724, 0x1.fffffff810000p-793, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.001ffffffffc0p+355, -0x1.fffffff03ff00p+294, 0x1.0000010000000p-724, -0x1.fffffff810000p-793, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.001ffffffffc0p+355, -0x1.fffffff03ff00p+294, -0x1.0000010000000p-724, 0x1.fffffff810000p-793, INFINITY, 0x0.0000000000000p+0},
+{0x1.00000fffc0001p+277, -0x1.fc000007e0040p+218, 0x1.000007fffffc0p+726, 0x1.fc0003fc00000p+666, 0x1.000007ffbfc41p-449, 0x1.a2bf70aa60b60p-505},
+{0x1.00000fffc0001p+277, -0x1.fc000007e0040p+218, -0x1.000007fffffc0p+726, -0x1.fc0003fc00000p+666, -0x1.000007ffbfc41p-449, -0x1.a2bf70aa60b60p-505},
+{-0x1.00000fffc0001p+277, 0x1.fc000007e0040p+218, 0x1.000007fffffc0p+726, 0x1.fc0003fc00000p+666, -0x1.000007ffbfc41p-449, -0x1.a2bf70aa60b60p-505},
+{-0x1.00000fffc0001p+277, 0x1.fc000007e0040p+218, -0x1.000007fffffc0p+726, -0x1.fc0003fc00000p+666, 0x1.000007ffbfc41p-449, 0x1.a2bf70aa60b60p-505},
+{0x1.01ffe000003fep-455, 0x1.ffffff8000000p-521, 0x1.00fffffe00000p-662, 0x1.ffffffe7ff800p-723, 0x1.00fee120e15c4p+207, 0x1.7b11a0fd9d316p+153},
+{0x1.01ffe000003fep-455, 0x1.ffffff8000000p-521, -0x1.00fffffe00000p-662, -0x1.ffffffe7ff800p-723, -0x1.00fee120e15c4p+207, -0x1.7b11a0fd9d316p+153},
+{-0x1.01ffe000003fep-455, -0x1.ffffff8000000p-521, 0x1.00fffffe00000p-662, 0x1.ffffffe7ff800p-723, -0x1.00fee120e15c4p+207, -0x1.7b11a0fd9d316p+153},
+{-0x1.01ffe000003fep-455, -0x1.ffffff8000000p-521, -0x1.00fffffe00000p-662, -0x1.ffffffe7ff800p-723, 0x1.00fee120e15c4p+207, 0x1.7b11a0fd9d316p+153},
+{0x1.3fffffffffc00p+478, 0x1.ffffffe000000p+415, 0x1.07c0ffc200000p+108, -0x1.e000003bfffe0p+50, 0x1.3697b20f8de20p+370, -0x1.388b9803adee0p+316},
+{0x1.3fffffffffc00p+478, 0x1.ffffffe000000p+415, -0x1.07c0ffc200000p+108, 0x1.e000003bfffe0p+50, -0x1.3697b20f8de20p+370, 0x1.388b9803adee0p+316},
+{-0x1.3fffffffffc00p+478, -0x1.ffffffe000000p+415, 0x1.07c0ffc200000p+108, -0x1.e000003bfffe0p+50, -0x1.3697b20f8de20p+370, 0x1.388b9803adee0p+316},
+{-0x1.3fffffffffc00p+478, -0x1.ffffffe000000p+415, -0x1.07c0ffc200000p+108, 0x1.e000003bfffe0p+50, 0x1.3697b20f8de20p+370, -0x1.388b9803adee0p+316},
+{0x1.0000001800000p+405, 0x1.fffffc0000200p+351, 0x1.0000004000000p-957, -0x1.fff0000004000p-1024, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000001800000p+405, 0x1.fffffc0000200p+351, -0x1.0000004000000p-957, 0x1.fff0000004000p-1024, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000001800000p+405, -0x1.fffffc0000200p+351, 0x1.0000004000000p-957, -0x1.fff0000004000p-1024, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000001800000p+405, -0x1.fffffc0000200p+351, -0x1.0000004000000p-957, 0x1.fff0000004000p-1024, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000800000000p+271, -0x1.0000000000000p+208, 0x1.0fc007c004000p-537, -0x1.fffe100000000p-601, 0x1.e2544251693b5p+807, 0x1.bf6c5bc03d0b8p+751},
+{0x1.0000800000000p+271, -0x1.0000000000000p+208, -0x1.0fc007c004000p-537, 0x1.fffe100000000p-601, -0x1.e2544251693b5p+807, -0x1.bf6c5bc03d0b8p+751},
+{-0x1.0000800000000p+271, 0x1.0000000000000p+208, 0x1.0fc007c004000p-537, -0x1.fffe100000000p-601, -0x1.e2544251693b5p+807, -0x1.bf6c5bc03d0b8p+751},
+{-0x1.0000800000000p+271, 0x1.0000000000000p+208, -0x1.0fc007c004000p-537, 0x1.fffe100000000p-601, 0x1.e2544251693b5p+807, 0x1.bf6c5bc03d0b8p+751},
+{0x1.00007fffffe00p-85, 0x1.ffffffc003f00p-146, 0x1.0080000000000p-834, -0x1.0000000000000p-892, 0x1.ff017f405f904p+748, -0x1.df2057e109728p+694},
+{0x1.00007fffffe00p-85, 0x1.ffffffc003f00p-146, -0x1.0080000000000p-834, 0x1.0000000000000p-892, -0x1.ff017f405f904p+748, 0x1.df2057e109728p+694},
+{-0x1.00007fffffe00p-85, -0x1.ffffffc003f00p-146, 0x1.0080000000000p-834, -0x1.0000000000000p-892, -0x1.ff017f405f904p+748, 0x1.df2057e109728p+694},
+{-0x1.00007fffffe00p-85, -0x1.ffffffc003f00p-146, -0x1.0080000000000p-834, 0x1.0000000000000p-892, 0x1.ff017f405f904p+748, -0x1.df2057e109728p+694},
+{0x1.0000200000000p-779, -0x1.0000000000000p-835, 0x1.00000ffffff80p-484, 0x1.ffffff0007ff8p-540, 0x1.00000fffff080p-295, -0x1.77fff803e38b4p-350},
+{0x1.0000200000000p-779, -0x1.0000000000000p-835, -0x1.00000ffffff80p-484, -0x1.ffffff0007ff8p-540, -0x1.00000fffff080p-295, 0x1.77fff803e38b4p-350},
+{-0x1.0000200000000p-779, 0x1.0000000000000p-835, 0x1.00000ffffff80p-484, 0x1.ffffff0007ff8p-540, -0x1.00000fffff080p-295, 0x1.77fff803e38b4p-350},
+{-0x1.0000200000000p-779, 0x1.0000000000000p-835, -0x1.00000ffffff80p-484, -0x1.ffffff0007ff8p-540, 0x1.00000fffff080p-295, -0x1.77fff803e38b4p-350},
+{0x1.00fe000000000p-622, 0x1.001ffffff0000p-691, 0x1.00007fffff000p+682, 0x0.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00fe000000000p-622, 0x1.001ffffff0000p-691, -0x1.00007fffff000p+682, 0x0.0000000000000p+0, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00fe000000000p-622, -0x1.001ffffff0000p-691, 0x1.00007fffff000p+682, 0x0.0000000000000p+0, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00fe000000000p-622, -0x1.001ffffff0000p-691, -0x1.00007fffff000p+682, 0x0.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.01e0000000002p+213, -0x1.fffffffffc200p+154, 0x1.0000080000000p-358, -0x1.0000000000000p-463, 0x1.01dff7f100409p+571, 0x1.ef7ed084099b0p+517},
+{0x1.01e0000000002p+213, -0x1.fffffffffc200p+154, -0x1.0000080000000p-358, 0x1.0000000000000p-463, -0x1.01dff7f100409p+571, -0x1.ef7ed084099b0p+517},
+{-0x1.01e0000000002p+213, 0x1.fffffffffc200p+154, 0x1.0000080000000p-358, -0x1.0000000000000p-463, -0x1.01dff7f100409p+571, -0x1.ef7ed084099b0p+517},
+{-0x1.01e0000000002p+213, 0x1.fffffffffc200p+154, -0x1.0000080000000p-358, 0x1.0000000000000p-463, 0x1.01dff7f100409p+571, 0x1.ef7ed084099b0p+517},
+{0x1.000000f1fe001p+66, -0x1.0000000000000p-17, 0x1.00003fffffff0p-433, 0x1.fc00000000000p-510, 0x1.ffff81e41b892p+498, -0x1.b8b120ccd3920p+444},
+{0x1.000000f1fe001p+66, -0x1.0000000000000p-17, -0x1.00003fffffff0p-433, -0x1.fc00000000000p-510, -0x1.ffff81e41b892p+498, 0x1.b8b120ccd3920p+444},
+{-0x1.000000f1fe001p+66, 0x1.0000000000000p-17, 0x1.00003fffffff0p-433, 0x1.fc00000000000p-510, -0x1.ffff81e41b892p+498, 0x1.b8b120ccd3920p+444},
+{-0x1.000000f1fe001p+66, 0x1.0000000000000p-17, -0x1.00003fffffff0p-433, -0x1.fc00000000000p-510, 0x1.ffff81e41b892p+498, -0x1.b8b120ccd3920p+444},
+{0x1.0008000000010p+115, -0x1.f8000ffff9000p+50, 0x1.00001ffff0000p-192, 0x1.ffff80001f000p-249, 0x1.0007dfff1401ap+307, -0x1.60516bf0b366cp+253},
+{0x1.0008000000010p+115, -0x1.f8000ffff9000p+50, -0x1.00001ffff0000p-192, -0x1.ffff80001f000p-249, -0x1.0007dfff1401ap+307, 0x1.60516bf0b366cp+253},
+{-0x1.0008000000010p+115, 0x1.f8000ffff9000p+50, 0x1.00001ffff0000p-192, 0x1.ffff80001f000p-249, -0x1.0007dfff1401ap+307, 0x1.60516bf0b366cp+253},
+{-0x1.0008000000010p+115, 0x1.f8000ffff9000p+50, -0x1.00001ffff0000p-192, -0x1.ffff80001f000p-249, 0x1.0007dfff1401ap+307, -0x1.60516bf0b366cp+253},
+{0x1.0000100000000p-13, -0x1.0000000000000p-118, 0x1.0038000800000p+253, -0x1.fffffe0000080p+193, 0x1.ff903863adb04p-267, -0x1.6b2c09860d9d8p-323},
+{0x1.0000100000000p-13, -0x1.0000000000000p-118, -0x1.0038000800000p+253, 0x1.fffffe0000080p+193, -0x1.ff903863adb04p-267, 0x1.6b2c09860d9d8p-323},
+{-0x1.0000100000000p-13, 0x1.0000000000000p-118, 0x1.0038000800000p+253, -0x1.fffffe0000080p+193, -0x1.ff903863adb04p-267, 0x1.6b2c09860d9d8p-323},
+{-0x1.0000100000000p-13, 0x1.0000000000000p-118, -0x1.0038000800000p+253, 0x1.fffffe0000080p+193, 0x1.ff903863adb04p-267, -0x1.6b2c09860d9d8p-323},
+{0x1.00003fe008000p-845, -0x1.fffdff0000080p-904, 0x1.ffffffffff800p+109, 0x1.fe00000000000p+11, 0x1.00003fe008400p-955, -0x1.803dee8002680p-1014},
+{0x1.00003fe008000p-845, -0x1.fffdff0000080p-904, -0x1.ffffffffff800p+109, -0x1.fe00000000000p+11, -0x1.00003fe008400p-955, 0x1.803dee8002680p-1014},
+{-0x1.00003fe008000p-845, 0x1.fffdff0000080p-904, 0x1.ffffffffff800p+109, 0x1.fe00000000000p+11, -0x1.00003fe008400p-955, 0x1.803dee8002680p-1014},
+{-0x1.00003fe008000p-845, 0x1.fffdff0000080p-904, -0x1.ffffffffff800p+109, -0x1.fe00000000000p+11, 0x1.00003fe008400p-955, -0x1.803dee8002680p-1014},
+{0x1.1fffffff00000p-151, 0x1.ffffff8000000p-223, 0x1.0000100000000p-443, -0x1.0000000000000p-537, 0x1.1fffedff01201p+292, -0x1.1fefee00c1200p+232},
+{0x1.1fffffff00000p-151, 0x1.ffffff8000000p-223, -0x1.0000100000000p-443, 0x1.0000000000000p-537, -0x1.1fffedff01201p+292, 0x1.1fefee00c1200p+232},
+{-0x1.1fffffff00000p-151, -0x1.ffffff8000000p-223, 0x1.0000100000000p-443, -0x1.0000000000000p-537, -0x1.1fffedff01201p+292, 0x1.1fefee00c1200p+232},
+{-0x1.1fffffff00000p-151, -0x1.ffffff8000000p-223, -0x1.0000100000000p-443, 0x1.0000000000000p-537, 0x1.1fffedff01201p+292, -0x1.1fefee00c1200p+232},
+{0x1.0ffffc0000010p-901, 0x1.f000000ff0000p-970, 0x1.00003ff002010p-855, -0x1.0000020000000p-920, 0x1.0fffb8110fd73p-46, -0x1.2a08548118244p-101},
+{0x1.0ffffc0000010p-901, 0x1.f000000ff0000p-970, -0x1.00003ff002010p-855, 0x1.0000020000000p-920, -0x1.0fffb8110fd73p-46, 0x1.2a08548118244p-101},
+{-0x1.0ffffc0000010p-901, -0x1.f000000ff0000p-970, 0x1.00003ff002010p-855, -0x1.0000020000000p-920, -0x1.0fffb8110fd73p-46, 0x1.2a08548118244p-101},
+{-0x1.0ffffc0000010p-901, -0x1.f000000ff0000p-970, -0x1.00003ff002010p-855, 0x1.0000020000000p-920, 0x1.0fffb8110fd73p-46, -0x1.2a08548118244p-101},
+{0x1.00ffffffc0000p+149, 0x1.fffffe00003f0p+94, 0x1.1fffffffff020p-235, -0x1.ffff000400000p-310, 0x1.c8e38e38735a1p+383, 0x1.ba7818263c098p+329},
+{0x1.00ffffffc0000p+149, 0x1.fffffe00003f0p+94, -0x1.1fffffffff020p-235, 0x1.ffff000400000p-310, -0x1.c8e38e38735a1p+383, -0x1.ba7818263c098p+329},
+{-0x1.00ffffffc0000p+149, -0x1.fffffe00003f0p+94, 0x1.1fffffffff020p-235, -0x1.ffff000400000p-310, -0x1.c8e38e38735a1p+383, -0x1.ba7818263c098p+329},
+{-0x1.00ffffffc0000p+149, -0x1.fffffe00003f0p+94, -0x1.1fffffffff020p-235, 0x1.ffff000400000p-310, 0x1.c8e38e38735a1p+383, 0x1.ba7818263c098p+329},
+{0x1.0200000000000p+564, -0x1.0000000000000p+511, 0x1.0000700000000p-366, 0x1.ffffffe000000p-437, 0x1.01ff8f203161ep+930, 0x1.329475dfee4e0p+875},
+{0x1.0200000000000p+564, -0x1.0000000000000p+511, -0x1.0000700000000p-366, -0x1.ffffffe000000p-437, -0x1.01ff8f203161ep+930, -0x1.329475dfee4e0p+875},
+{-0x1.0200000000000p+564, 0x1.0000000000000p+511, 0x1.0000700000000p-366, 0x1.ffffffe000000p-437, -0x1.01ff8f203161ep+930, -0x1.329475dfee4e0p+875},
+{-0x1.0200000000000p+564, 0x1.0000000000000p+511, -0x1.0000700000000p-366, -0x1.ffffffe000000p-437, 0x1.01ff8f203161ep+930, 0x1.329475dfee4e0p+875},
+{0x1.3fffffc0001fcp+882, 0x1.007fffff00000p+819, 0x1.007fffff80000p-564, 0x1.fffffffe00000p-632, INFINITY, 0x0.0000000000000p+0},
+{0x1.3fffffc0001fcp+882, 0x1.007fffff00000p+819, -0x1.007fffff80000p-564, -0x1.fffffffe00000p-632, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.3fffffc0001fcp+882, -0x1.007fffff00000p+819, 0x1.007fffff80000p-564, 0x1.fffffffe00000p-632, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.3fffffc0001fcp+882, -0x1.007fffff00000p+819, -0x1.007fffff80000p-564, -0x1.fffffffe00000p-632, INFINITY, 0x0.0000000000000p+0},
+{0x1.00000ffffffd0p-606, -0x1.ffffff8200000p-672, 0x1.00000c0000004p+258, -0x1.ff80000800000p+190, 0x1.000003ffffcccp-864, 0x1.02fbf43288800p-927},
+{0x1.00000ffffffd0p-606, -0x1.ffffff8200000p-672, -0x1.00000c0000004p+258, 0x1.ff80000800000p+190, -0x1.000003ffffcccp-864, -0x1.02fbf43288800p-927},
+{-0x1.00000ffffffd0p-606, 0x1.ffffff8200000p-672, 0x1.00000c0000004p+258, -0x1.ff80000800000p+190, -0x1.000003ffffcccp-864, -0x1.02fbf43288800p-927},
+{-0x1.00000ffffffd0p-606, 0x1.ffffff8200000p-672, -0x1.00000c0000004p+258, 0x1.ff80000800000p+190, 0x1.000003ffffcccp-864, 0x1.02fbf43288800p-927},
+{0x1.18003ffff8000p-770, 0x1.ffffff8000000p-836, 0x1.1ffff80000040p-581, -0x1.0000000000000p-671, 0x1.f1c79c0c99a42p-190, -0x1.672e152d5a5bep-244},
+{0x1.18003ffff8000p-770, 0x1.ffffff8000000p-836, -0x1.1ffff80000040p-581, 0x1.0000000000000p-671, -0x1.f1c79c0c99a42p-190, 0x1.672e152d5a5bep-244},
+{-0x1.18003ffff8000p-770, -0x1.ffffff8000000p-836, 0x1.1ffff80000040p-581, -0x1.0000000000000p-671, -0x1.f1c79c0c99a42p-190, 0x1.672e152d5a5bep-244},
+{-0x1.18003ffff8000p-770, -0x1.ffffff8000000p-836, -0x1.1ffff80000040p-581, 0x1.0000000000000p-671, 0x1.f1c79c0c99a42p-190, -0x1.672e152d5a5bep-244},
+{0x1.0ffffff9ffff0p+390, 0x1.f800008200000p+320, 0x1.000000ffffff8p+202, 0x1.ff0000007ffc0p+143, 0x1.0ffffeea0000ap+188, -0x1.21eba43b6d104p+133},
+{0x1.0ffffff9ffff0p+390, 0x1.f800008200000p+320, -0x1.000000ffffff8p+202, -0x1.ff0000007ffc0p+143, -0x1.0ffffeea0000ap+188, 0x1.21eba43b6d104p+133},
+{-0x1.0ffffff9ffff0p+390, -0x1.f800008200000p+320, 0x1.000000ffffff8p+202, 0x1.ff0000007ffc0p+143, -0x1.0ffffeea0000ap+188, 0x1.21eba43b6d104p+133},
+{-0x1.0ffffff9ffff0p+390, -0x1.f800008200000p+320, -0x1.000000ffffff8p+202, -0x1.ff0000007ffc0p+143, 0x1.0ffffeea0000ap+188, -0x1.21eba43b6d104p+133},
+{0x1.1fffffe000000p-899, 0x1.ffff800001ffep-953, 0x1.0000008000000p-864, -0x1.fffffc0000008p-920, 0x1.1fffff5000006p-35, 0x1.1ffee480048f8p-90},
+{0x1.1fffffe000000p-899, 0x1.ffff800001ffep-953, -0x1.0000008000000p-864, 0x1.fffffc0000008p-920, -0x1.1fffff5000006p-35, -0x1.1ffee480048f8p-90},
+{-0x1.1fffffe000000p-899, -0x1.ffff800001ffep-953, 0x1.0000008000000p-864, -0x1.fffffc0000008p-920, -0x1.1fffff5000006p-35, -0x1.1ffee480048f8p-90},
+{-0x1.1fffffe000000p-899, -0x1.ffff800001ffep-953, -0x1.0000008000000p-864, 0x1.fffffc0000008p-920, 0x1.1fffff5000006p-35, 0x1.1ffee480048f8p-90},
+{0x1.0000200000000p-148, -0x1.fffffff804000p-215, 0x1.0000080000000p+818, -0x1.0000000000000p+723, 0x1.000017ffff400p-966, 0x1.6ffff480c0400p-1028},
+{0x1.0000200000000p-148, -0x1.fffffff804000p-215, -0x1.0000080000000p+818, 0x1.0000000000000p+723, -0x1.000017ffff400p-966, -0x1.6ffff480c0400p-1028},
+{-0x1.0000200000000p-148, 0x1.fffffff804000p-215, 0x1.0000080000000p+818, -0x1.0000000000000p+723, -0x1.000017ffff400p-966, -0x1.6ffff480c0400p-1028},
+{-0x1.0000200000000p-148, 0x1.fffffff804000p-215, -0x1.0000080000000p+818, 0x1.0000000000000p+723, 0x1.000017ffff400p-966, 0x1.6ffff480c0400p-1028},
+{0x1.03ffff0000010p+113, -0x1.fffc010000000p+37, 0x1.0000020000000p+293, -0x1.0000000000000p+188, 0x1.03fffcf800071p-180, -0x1.c7fff471f0000p-249},
+{0x1.03ffff0000010p+113, -0x1.fffc010000000p+37, -0x1.0000020000000p+293, 0x1.0000000000000p+188, -0x1.03fffcf800071p-180, 0x1.c7fff471f0000p-249},
+{-0x1.03ffff0000010p+113, 0x1.fffc010000000p+37, 0x1.0000020000000p+293, -0x1.0000000000000p+188, -0x1.03fffcf800071p-180, 0x1.c7fff471f0000p-249},
+{-0x1.03ffff0000010p+113, 0x1.fffc010000000p+37, -0x1.0000020000000p+293, 0x1.0000000000000p+188, 0x1.03fffcf800071p-180, -0x1.c7fff471f0000p-249},
+{0x1.7ffffffc00000p-873, 0x1.fff80000fc000p-934, 0x1.0010000000000p+21, -0x1.ffffffffc4000p-46, 0x1.7fe8017be8418p-894, -0x1.01d7f400a641ep-948},
+{0x1.7ffffffc00000p-873, 0x1.fff80000fc000p-934, -0x1.0010000000000p+21, 0x1.ffffffffc4000p-46, -0x1.7fe8017be8418p-894, 0x1.01d7f400a641ep-948},
+{-0x1.7ffffffc00000p-873, -0x1.fff80000fc000p-934, 0x1.0010000000000p+21, -0x1.ffffffffc4000p-46, -0x1.7fe8017be8418p-894, 0x1.01d7f400a641ep-948},
+{-0x1.7ffffffc00000p-873, -0x1.fff80000fc000p-934, -0x1.0010000000000p+21, 0x1.ffffffffc4000p-46, 0x1.7fe8017be8418p-894, -0x1.01d7f400a641ep-948},
+{0x1.000007fffc004p-531, -0x1.8000004000000p-590, 0x1.7fe000001ff00p+464, 0x1.f000000000000p+363, 0x1.5571d426e1829p-996, -0x1.e917b80000000p-1050},
+{0x1.000007fffc004p-531, -0x1.8000004000000p-590, -0x1.7fe000001ff00p+464, -0x1.f000000000000p+363, -0x1.5571d426e1829p-996, 0x1.e917b80000000p-1050},
+{-0x1.000007fffc004p-531, 0x1.8000004000000p-590, 0x1.7fe000001ff00p+464, 0x1.f000000000000p+363, -0x1.5571d426e1829p-996, 0x1.e917b80000000p-1050},
+{-0x1.000007fffc004p-531, 0x1.8000004000000p-590, -0x1.7fe000001ff00p+464, -0x1.f000000000000p+363, 0x1.5571d426e1829p-996, -0x1.e917b80000000p-1050},
+{0x1.01ffffffffc00p+132, 0x0.0000000000000p+0, 0x1.0ffffff000000p+156, 0x1.fffffff000000p+86, 0x1.e5a5a5c236733p-25, -0x1.9d54b36e3ce32p-79},
+{0x1.01ffffffffc00p+132, 0x0.0000000000000p+0, -0x1.0ffffff000000p+156, -0x1.fffffff000000p+86, -0x1.e5a5a5c236733p-25, 0x1.9d54b36e3ce32p-79},
+{-0x1.01ffffffffc00p+132, 0x0.0000000000000p+0, 0x1.0ffffff000000p+156, 0x1.fffffff000000p+86, -0x1.e5a5a5c236733p-25, 0x1.9d54b36e3ce32p-79},
+{-0x1.01ffffffffc00p+132, 0x0.0000000000000p+0, -0x1.0ffffff000000p+156, -0x1.fffffff000000p+86, 0x1.e5a5a5c236733p-25, -0x1.9d54b36e3ce32p-79},
+{0x1.0000010000000p-428, -0x1.ffffffffe4000p-490, 0x1.0000020000000p-498, -0x1.ff80000100000p-571, 0x1.fffffe0000040p+69, -0x1.006005ff51e00p+9},
+{0x1.0000010000000p-428, -0x1.ffffffffe4000p-490, -0x1.0000020000000p-498, 0x1.ff80000100000p-571, -0x1.fffffe0000040p+69, 0x1.006005ff51e00p+9},
+{-0x1.0000010000000p-428, 0x1.ffffffffe4000p-490, 0x1.0000020000000p-498, -0x1.ff80000100000p-571, -0x1.fffffe0000040p+69, 0x1.006005ff51e00p+9},
+{-0x1.0000010000000p-428, 0x1.ffffffffe4000p-490, -0x1.0000020000000p-498, 0x1.ff80000100000p-571, 0x1.fffffe0000040p+69, -0x1.006005ff51e00p+9},
+{0x1.0008000000000p+313, -0x1.0000000000000p+208, 0x1.000fffff80000p+721, 0x1.fffffffc00000p+665, 0x1.fff00100efe90p-409, -0x1.07a38c84ab908p-464},
+{0x1.0008000000000p+313, -0x1.0000000000000p+208, -0x1.000fffff80000p+721, -0x1.fffffffc00000p+665, -0x1.fff00100efe90p-409, 0x1.07a38c84ab908p-464},
+{-0x1.0008000000000p+313, 0x1.0000000000000p+208, 0x1.000fffff80000p+721, 0x1.fffffffc00000p+665, -0x1.fff00100efe90p-409, 0x1.07a38c84ab908p-464},
+{-0x1.0008000000000p+313, 0x1.0000000000000p+208, -0x1.000fffff80000p+721, -0x1.fffffffc00000p+665, 0x1.fff00100efe90p-409, -0x1.07a38c84ab908p-464},
+{0x1.007fffffffc00p+944, 0x1.ffffc00000000p+879, 0x1.1ffffffff8000p-208, 0x1.fe001ffffffe0p-264, INFINITY, 0x0.0000000000000p+0},
+{0x1.007fffffffc00p+944, 0x1.ffffc00000000p+879, -0x1.1ffffffff8000p-208, -0x1.fe001ffffffe0p-264, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.007fffffffc00p+944, -0x1.ffffc00000000p+879, 0x1.1ffffffff8000p-208, 0x1.fe001ffffffe0p-264, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.007fffffffc00p+944, -0x1.ffffc00000000p+879, -0x1.1ffffffff8000p-208, -0x1.fe001ffffffe0p-264, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000000fffe00p+879, 0x1.3fffff87fc000p+819, 0x1.00003ffffc000p-310, 0x1.e003ff8000000p-375, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000000fffe00p+879, 0x1.3fffff87fc000p+819, -0x1.00003ffffc000p-310, -0x1.e003ff8000000p-375, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000000fffe00p+879, -0x1.3fffff87fc000p+819, 0x1.00003ffffc000p-310, 0x1.e003ff8000000p-375, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000000fffe00p+879, -0x1.3fffff87fc000p+819, -0x1.00003ffffc000p-310, -0x1.e003ff8000000p-375, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000000800000p-526, -0x1.0000000000000p-631, 0x1.7ffff80000000p-359, 0x1.ffffffffe0000p-415, 0x1.55555c7c71ed4p-168, 0x1.30ff0fb9aebd0p-225},
+{0x1.0000000800000p-526, -0x1.0000000000000p-631, -0x1.7ffff80000000p-359, -0x1.ffffffffe0000p-415, -0x1.55555c7c71ed4p-168, -0x1.30ff0fb9aebd0p-225},
+{-0x1.0000000800000p-526, 0x1.0000000000000p-631, 0x1.7ffff80000000p-359, 0x1.ffffffffe0000p-415, -0x1.55555c7c71ed4p-168, -0x1.30ff0fb9aebd0p-225},
+{-0x1.0000000800000p-526, 0x1.0000000000000p-631, -0x1.7ffff80000000p-359, -0x1.ffffffffe0000p-415, 0x1.55555c7c71ed4p-168, 0x1.30ff0fb9aebd0p-225},
+{0x1.00fffffff8000p-357, 0x1.fffe000000000p-431, 0x1.0000100000000p-423, -0x1.fffffffffc100p-478, 0x1.00ffefeff9010p+66, 0x1.1cfbfe2017250p+12},
+{0x1.00fffffff8000p-357, 0x1.fffe000000000p-431, -0x1.0000100000000p-423, 0x1.fffffffffc100p-478, -0x1.00ffefeff9010p+66, -0x1.1cfbfe2017250p+12},
+{-0x1.00fffffff8000p-357, -0x1.fffe000000000p-431, 0x1.0000100000000p-423, -0x1.fffffffffc100p-478, -0x1.00ffefeff9010p+66, -0x1.1cfbfe2017250p+12},
+{-0x1.00fffffff8000p-357, -0x1.fffe000000000p-431, -0x1.0000100000000p-423, 0x1.fffffffffc100p-478, 0x1.00ffefeff9010p+66, 0x1.1cfbfe2017250p+12},
+{0x1.0007ffffffff0p-319, 0x1.fffffc0000000p-402, 0x1.0003800000080p-931, -0x1.0000000000000p-1036, 0x1.00047ff0402e2p+612, -0x1.8ad99d893a930p+555},
+{0x1.0007ffffffff0p-319, 0x1.fffffc0000000p-402, -0x1.0003800000080p-931, 0x1.0000000000000p-1036, -0x1.00047ff0402e2p+612, 0x1.8ad99d893a930p+555},
+{-0x1.0007ffffffff0p-319, -0x1.fffffc0000000p-402, 0x1.0003800000080p-931, -0x1.0000000000000p-1036, -0x1.00047ff0402e2p+612, 0x1.8ad99d893a930p+555},
+{-0x1.0007ffffffff0p-319, -0x1.fffffc0000000p-402, -0x1.0003800000080p-931, 0x1.0000000000000p-1036, 0x1.00047ff0402e2p+612, -0x1.8ad99d893a930p+555},
+{0x1.000001fffff80p-279, 0x1.ff00000000000p-363, 0x1.0000020000000p-640, -0x1.8002000000000p-716, 0x1.fffffffffff00p+360, 0x1.0181fefcfc000p+293},
+{0x1.000001fffff80p-279, 0x1.ff00000000000p-363, -0x1.0000020000000p-640, 0x1.8002000000000p-716, -0x1.fffffffffff00p+360, -0x1.0181fefcfc000p+293},
+{-0x1.000001fffff80p-279, -0x1.ff00000000000p-363, 0x1.0000020000000p-640, -0x1.8002000000000p-716, -0x1.fffffffffff00p+360, -0x1.0181fefcfc000p+293},
+{-0x1.000001fffff80p-279, -0x1.ff00000000000p-363, -0x1.0000020000000p-640, 0x1.8002000000000p-716, 0x1.fffffffffff00p+360, 0x1.0181fefcfc000p+293},
+{0x1.0003fffff0000p+964, 0x1.ffff800007f80p+904, 0x1.000007ffffe00p+308, -0x1.fe0c000004000p+250, 0x1.0003f7ffd0600p+656, 0x1.4dc26b9fd5b00p+601},
+{0x1.0003fffff0000p+964, 0x1.ffff800007f80p+904, -0x1.000007ffffe00p+308, 0x1.fe0c000004000p+250, -0x1.0003f7ffd0600p+656, -0x1.4dc26b9fd5b00p+601},
+{-0x1.0003fffff0000p+964, -0x1.ffff800007f80p+904, 0x1.000007ffffe00p+308, -0x1.fe0c000004000p+250, -0x1.0003f7ffd0600p+656, -0x1.4dc26b9fd5b00p+601},
+{-0x1.0003fffff0000p+964, -0x1.ffff800007f80p+904, -0x1.000007ffffe00p+308, 0x1.fe0c000004000p+250, 0x1.0003f7ffd0600p+656, 0x1.4dc26b9fd5b00p+601},
+{0x1.00000003f0000p+137, 0x1.ffffffe000000p+59, 0x1.0100000000000p+110, -0x1.fffffff000080p+50, 0x1.fe01fe09d629dp+26, 0x1.9a55be319d934p-28},
+{0x1.00000003f0000p+137, 0x1.ffffffe000000p+59, -0x1.0100000000000p+110, 0x1.fffffff000080p+50, -0x1.fe01fe09d629dp+26, -0x1.9a55be319d934p-28},
+{-0x1.00000003f0000p+137, -0x1.ffffffe000000p+59, 0x1.0100000000000p+110, -0x1.fffffff000080p+50, -0x1.fe01fe09d629dp+26, -0x1.9a55be319d934p-28},
+{-0x1.00000003f0000p+137, -0x1.ffffffe000000p+59, -0x1.0100000000000p+110, 0x1.fffffff000080p+50, 0x1.fe01fe09d629dp+26, 0x1.9a55be319d934p-28},
+{0x1.007fffffffc00p+472, 0x1.fffffe0000000p+390, 0x1.0000003fffff8p-373, 0x1.fffff80000000p-444, 0x1.007fffbfdfc09p+845, 0x1.202ee977b9860p+787},
+{0x1.007fffffffc00p+472, 0x1.fffffe0000000p+390, -0x1.0000003fffff8p-373, -0x1.fffff80000000p-444, -0x1.007fffbfdfc09p+845, -0x1.202ee977b9860p+787},
+{-0x1.007fffffffc00p+472, -0x1.fffffe0000000p+390, 0x1.0000003fffff8p-373, 0x1.fffff80000000p-444, -0x1.007fffbfdfc09p+845, -0x1.202ee977b9860p+787},
+{-0x1.007fffffffc00p+472, -0x1.fffffe0000000p+390, -0x1.0000003fffff8p-373, -0x1.fffff80000000p-444, 0x1.007fffbfdfc09p+845, 0x1.202ee977b9860p+787},
+{0x1.00000003ff000p+517, 0x1.ffffff0000000p+455, 0x1.0000ffff80000p+482, 0x1.e0000000fffc0p+423, 0x1.fffe000afdf40p+34, 0x1.a97dc87838c28p-22},
+{0x1.00000003ff000p+517, 0x1.ffffff0000000p+455, -0x1.0000ffff80000p+482, -0x1.e0000000fffc0p+423, -0x1.fffe000afdf40p+34, -0x1.a97dc87838c28p-22},
+{-0x1.00000003ff000p+517, -0x1.ffffff0000000p+455, 0x1.0000ffff80000p+482, 0x1.e0000000fffc0p+423, -0x1.fffe000afdf40p+34, -0x1.a97dc87838c28p-22},
+{-0x1.00000003ff000p+517, -0x1.ffffff0000000p+455, -0x1.0000ffff80000p+482, -0x1.e0000000fffc0p+423, 0x1.fffe000afdf40p+34, 0x1.a97dc87838c28p-22},
+{0x1.007ffffffc000p-870, 0x1.ffffff8000000p-937, 0x1.0003fffffffe0p-380, 0x1.fffffff000780p-440, 0x1.007bfe1003c1fp-490, 0x1.d0655eb0f91c0p-546},
+{0x1.007ffffffc000p-870, 0x1.ffffff8000000p-937, -0x1.0003fffffffe0p-380, -0x1.fffffff000780p-440, -0x1.007bfe1003c1fp-490, -0x1.d0655eb0f91c0p-546},
+{-0x1.007ffffffc000p-870, -0x1.ffffff8000000p-937, 0x1.0003fffffffe0p-380, 0x1.fffffff000780p-440, -0x1.007bfe1003c1fp-490, -0x1.d0655eb0f91c0p-546},
+{-0x1.007ffffffc000p-870, -0x1.ffffff8000000p-937, -0x1.0003fffffffe0p-380, -0x1.fffffff000780p-440, 0x1.007bfe1003c1fp-490, 0x1.d0655eb0f91c0p-546},
+{0x1.07fffffe0003cp+175, 0x1.ffe000007f000p+110, 0x1.1ffff00800000p-290, -0x1.0000000000000p-387, 0x1.d5556f57b59dcp+464, 0x1.ea436d67e8132p+410},
+{0x1.07fffffe0003cp+175, 0x1.ffe000007f000p+110, -0x1.1ffff00800000p-290, 0x1.0000000000000p-387, -0x1.d5556f57b59dcp+464, -0x1.ea436d67e8132p+410},
+{-0x1.07fffffe0003cp+175, -0x1.ffe000007f000p+110, 0x1.1ffff00800000p-290, -0x1.0000000000000p-387, -0x1.d5556f57b59dcp+464, -0x1.ea436d67e8132p+410},
+{-0x1.07fffffe0003cp+175, -0x1.ffe000007f000p+110, -0x1.1ffff00800000p-290, 0x1.0000000000000p-387, 0x1.d5556f57b59dcp+464, 0x1.ea436d67e8132p+410},
+{0x1.000003fff8000p+401, 0x1.ffff00000003cp+346, 0x1.000001ffff020p+721, -0x1.fff0000200000p+651, 0x1.000001fff8fa0p-320, 0x1.04037c2a010d6p-374},
+{0x1.000003fff8000p+401, 0x1.ffff00000003cp+346, -0x1.000001ffff020p+721, 0x1.fff0000200000p+651, -0x1.000001fff8fa0p-320, -0x1.04037c2a010d6p-374},
+{-0x1.000003fff8000p+401, -0x1.ffff00000003cp+346, 0x1.000001ffff020p+721, -0x1.fff0000200000p+651, -0x1.000001fff8fa0p-320, -0x1.04037c2a010d6p-374},
+{-0x1.000003fff8000p+401, -0x1.ffff00000003cp+346, -0x1.000001ffff020p+721, 0x1.fff0000200000p+651, 0x1.000001fff8fa0p-320, 0x1.04037c2a010d6p-374},
+{0x1.00ffe00000000p-249, 0x1.fe00000000000p-309, 0x1.0000100000000p+516, -0x1.ffff800010000p+447, 0x1.00ffcff003010p-765, -0x1.01fef05060e00p-825},
+{0x1.00ffe00000000p-249, 0x1.fe00000000000p-309, -0x1.0000100000000p+516, 0x1.ffff800010000p+447, -0x1.00ffcff003010p-765, 0x1.01fef05060e00p-825},
+{-0x1.00ffe00000000p-249, -0x1.fe00000000000p-309, 0x1.0000100000000p+516, -0x1.ffff800010000p+447, -0x1.00ffcff003010p-765, 0x1.01fef05060e00p-825},
+{-0x1.00ffe00000000p-249, -0x1.fe00000000000p-309, -0x1.0000100000000p+516, 0x1.ffff800010000p+447, 0x1.00ffcff003010p-765, -0x1.01fef05060e00p-825},
+{0x1.fffffff000008p-375, -0x1.ffffff1000000p-452, 0x1.0001fffffff80p-412, 0x1.fffe000000000p-497, 0x1.fffbfff800208p+37, -0x1.83fe387f7d700p-21},
+{0x1.fffffff000008p-375, -0x1.ffffff1000000p-452, -0x1.0001fffffff80p-412, -0x1.fffe000000000p-497, -0x1.fffbfff800208p+37, 0x1.83fe387f7d700p-21},
+{-0x1.fffffff000008p-375, 0x1.ffffff1000000p-452, 0x1.0001fffffff80p-412, 0x1.fffe000000000p-497, -0x1.fffbfff800208p+37, 0x1.83fe387f7d700p-21},
+{-0x1.fffffff000008p-375, 0x1.ffffff1000000p-452, -0x1.0001fffffff80p-412, -0x1.fffe000000000p-497, 0x1.fffbfff800208p+37, -0x1.83fe387f7d700p-21},
+};
+
+const int numAccuracyTests = sizeof(accuracyTests) / sizeof(struct testVector);
+
+#include <math.h>
+
+double testAccuracy() {
+	int i;
+	DD a, b, c, r;
+	
+	double worstUlps = 0.5;
+	
+	for (i=0; i<numAccuracyTests; ++i) {
+		a.hi = accuracyTests[i].xhi;
+		a.lo = accuracyTests[i].xlo;
+		b.hi = accuracyTests[i].yhi;
+		b.lo = accuracyTests[i].ylo;
+		r.hi = accuracyTests[i].rhi;
+		r.lo = accuracyTests[i].rlo;
+		
+		DD c = { .ld = __gcc_qdiv(a.ld, b.ld) };
+		
+		double error = __builtin_fabs(((r.hi - c.hi) + r.lo) - c.lo);
+		
+		if (error != 0.0) {
+		
+			int exponent = ilogb(r.hi);
+			exponent = (exponent < -1022 ? -1022 : exponent);
+			double ulpError = scalbn(error, 106 - exponent);
+		
+			if (ulpError > worstUlps) {
+#ifdef PRINT_ACCURACY_INFORMATION
+				printf("New worst rounding error for (%a,%a) / (%a,%a):\n", a.hi, a.lo, b.hi, b.lo);
+				printf("\tExpected: (%a,%a)\n", r.hi, r.lo);
+				printf("\tComputed: (%a,%a)\n", c.hi, c.lo);
+				printf("\tError: %f ulps\n", ulpError);
+#endif
+				worstUlps = ulpError;
+			}
+		}
+	}
+	
+	return worstUlps;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/compiler-rt/test/builtins/Unit/ppc/qmul_test.c b/compiler-rt/test/builtins/Unit/ppc/qmul_test.c
new file mode 100644
index 0000000..fc5b46d
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/qmul_test.c
@@ -0,0 +1,793 @@
+#include <stdio.h>
+#include "DD.h"
+
+long double __gcc_qmul(long double x, long double y);
+
+double testAccuracy();
+int testEdgeCases();
+
+int main(int argc, char *argv[]) {
+	if (testEdgeCases())
+		return 1;
+	
+	if (testAccuracy() > 2.0)
+		return 1;
+	
+	return 0;
+}
+
+struct testVector {
+	double xhi; double xlo;
+	double yhi; double ylo;
+	double rhi; double rlo;
+};
+
+#define INFINITY __builtin_inf()
+#define HUGE 0x1.fffffffffffffp1023
+#define QNAN __builtin_nan("")
+
+const struct testVector edgeCases[] = {
+{	0.0,		0.0,		0.0,		0.0,		0.0,		0.0			},
+{  -0.0,		0.0,		0.0,		0.0,	   -0.0,		0.0			},
+{   0.0,		0.0,	   -0.0,		0.0,	   -0.0,		0.0			},
+{  -0.0,		0.0,	   -0.0,		0.0,	    0.0,		0.0			},
+
+{   INFINITY,	0.0,		0.0,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,		0.0,		0.0,	    QNAN,		0.0			},
+{   INFINITY,	0.0,	   -0.0,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+{   INFINITY,	0.0,	    1.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    1.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -1.0,		0.0,	   -INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -1.0,		0.0,	    INFINITY,	0.0			},
+{   INFINITY,	0.0,	    HUGE,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    HUGE,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -HUGE,		0.0,	   -INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -HUGE,		0.0,	    INFINITY,	0.0			},
+{   INFINITY,	0.0,	    INFINITY,	0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -INFINITY,	0.0,	    INFINITY,	0.0			},
+{   0.0,		0.0,		INFINITY,	0.0,		QNAN,		0.0			},
+{   0.0,		0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{  -0.0,		0.0,		INFINITY,	0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{   1.0,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{   1.0,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -1.0,		0.0,		INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -1.0,		0.0,	   -INFINITY,	0.0,	    INFINITY,	0.0			},
+{   HUGE,		0.0,		INFINITY,	0.0,		INFINITY,	0.0			},
+{   HUGE,		0.0,	   -INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -HUGE,		0.0,		INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -HUGE,		0.0,	   -INFINITY,	0.0,	    INFINITY,	0.0			},
+
+{   QNAN,		0.0,		0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    QNAN,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -QNAN,		0.0,	    QNAN,		0.0			},
+{	0.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,		QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+};
+
+const int numEdgeCases = sizeof(edgeCases) / sizeof(struct testVector);
+
+
+int testEdgeCases() {
+	int i;
+	DD a, b, c, r;
+	for (i=0; i<numEdgeCases; ++i) {
+		a.hi = edgeCases[i].xhi;
+		a.lo = edgeCases[i].xlo;
+		b.hi = edgeCases[i].yhi;
+		b.lo = edgeCases[i].ylo;
+		r.hi = edgeCases[i].rhi;
+		r.lo = edgeCases[i].rlo;
+		
+		int error;
+		
+		DD c = { .ld = __gcc_qmul(a.ld, b.ld) };
+		
+		if (r.hi != r.hi) {
+			if (c.hi == c.hi)
+				error = 1;
+			else if (c.lo != 0.0)
+				error = 1;
+			else
+				error = 0;
+		}
+
+		else if (r.hi == 0.0)
+			error = memcmp(&c, &r, sizeof(DD));
+		
+		else
+			error = ((c.hi != r.hi) || (c.lo != r.lo));
+		
+		if (error) {
+			printf("Error on edge case %a x %a: expected (%a, %a), got (%a, %a).\n", a.hi, b.hi, r.hi, r.lo, c.hi, c.lo);
+			return 1;
+		}
+	}
+	
+	return 0;
+}
+
+
+/*
+
+ Code for generating the test cases, requires the mpfr package to run.
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <mpfr.h>
+ #include <math.h>
+ 
+ #ifdef __x86_64__
+ #define randlength 2
+ #else
+ #define randlength 4
+ #endif
+ 
+ void printTest(mpfr_t a, mpfr_t b, mpfr_t c) {
+ static const double INFINITYD = __builtin_INFINITY();
+ 
+ MPFR_DECL_INIT(tmp, 53);
+ 
+ double ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ double alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ double bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ double blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ double chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ double clo = isINFINITY(chi) ? 0.0 : mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ }
+ 
+ int main(int argc, char *argv[]) {
+ 
+ MPFR_DECL_INIT(a, 106);
+ MPFR_DECL_INIT(b, 106);
+ MPFR_DECL_INIT(c, 106);
+ 
+ int exponent_range = atoi(argv[1]);
+ 
+ int i;
+ for (i=0; i<128; ++i) {
+ mpfr_random2(a, randlength, exponent_range);
+ mpfr_random2(b, randlength, exponent_range);
+ mpfr_mul(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_mul(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ 
+ mpfr_neg(a, a, GMP_RNDN);
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_mul(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_mul(c, a, b, GMP_RNDN);
+ printTest(a, b, c);
+ }
+ return 0;
+ } 
+
+ */
+
+const struct testVector accuracyTests[] = {
+{0x1.00001ffffff00p-784, 0x1.fffff83ff8000p-839, 0x1.00ffc00ffff00p-771, 0x1.fe0007fffff00p-827, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00001ffffff00p-784, 0x1.fffff83ff8000p-839, -0x1.00ffc00ffff00p-771, -0x1.fe0007fffff00p-827, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00001ffffff00p-784, -0x1.fffff83ff8000p-839, 0x1.00ffc00ffff00p-771, 0x1.fe0007fffff00p-827, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.00001ffffff00p-784, -0x1.fffff83ff8000p-839, -0x1.00ffc00ffff00p-771, -0x1.fe0007fffff00p-827, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00001fffff800p-705, 0x1.fffffffe00000p-779, 0x1.3fffffff80000p+666, 0x1.ffffffff00000p+593, 0x1.400027ff7f5ffp-39, 0x1.e0001ffe80000p-111},
+{0x1.00001fffff800p-705, 0x1.fffffffe00000p-779, -0x1.3fffffff80000p+666, -0x1.ffffffff00000p+593, -0x1.400027ff7f5ffp-39, -0x1.e0001ffe80000p-111},
+{-0x1.00001fffff800p-705, -0x1.fffffffe00000p-779, 0x1.3fffffff80000p+666, 0x1.ffffffff00000p+593, -0x1.400027ff7f5ffp-39, -0x1.e0001ffe80000p-111},
+{-0x1.00001fffff800p-705, -0x1.fffffffe00000p-779, -0x1.3fffffff80000p+666, -0x1.ffffffff00000p+593, 0x1.400027ff7f5ffp-39, 0x1.e0001ffe80000p-111},
+{0x1.0000000800000p-800, -0x1.0000000000000p-872, 0x1.000003fffc002p-916, -0x1.0000000000000p-1021, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000000800000p-800, -0x1.0000000000000p-872, -0x1.000003fffc002p-916, 0x1.0000000000000p-1021, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000800000p-800, 0x1.0000000000000p-872, 0x1.000003fffc002p-916, -0x1.0000000000000p-1021, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000800000p-800, 0x1.0000000000000p-872, -0x1.000003fffc002p-916, 0x1.0000000000000p-1021, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.000003ffffffep-19, -0x1.ffe0080000000p-103, 0x1.0800000000000p-211, -0x1.0000000000000p-307, 0x1.0800041fffffep-230, -0x1.00000020fef08p-286},
+{0x1.000003ffffffep-19, -0x1.ffe0080000000p-103, -0x1.0800000000000p-211, 0x1.0000000000000p-307, -0x1.0800041fffffep-230, 0x1.00000020fef08p-286},
+{-0x1.000003ffffffep-19, 0x1.ffe0080000000p-103, 0x1.0800000000000p-211, -0x1.0000000000000p-307, -0x1.0800041fffffep-230, 0x1.00000020fef08p-286},
+{-0x1.000003ffffffep-19, 0x1.ffe0080000000p-103, -0x1.0800000000000p-211, 0x1.0000000000000p-307, 0x1.0800041fffffep-230, -0x1.00000020fef08p-286},
+{0x1.0000007fffc00p-464, 0x1.efe0000000000p-558, 0x1.007fffffe0000p+756, 0x0.0000000000000p+0, 0x1.008000801fbfep+292, -0x1.fffeffff07900p+231},
+{0x1.0000007fffc00p-464, 0x1.efe0000000000p-558, -0x1.007fffffe0000p+756, 0x0.0000000000000p+0, -0x1.008000801fbfep+292, 0x1.fffeffff07900p+231},
+{-0x1.0000007fffc00p-464, -0x1.efe0000000000p-558, 0x1.007fffffe0000p+756, 0x0.0000000000000p+0, -0x1.008000801fbfep+292, 0x1.fffeffff07900p+231},
+{-0x1.0000007fffc00p-464, -0x1.efe0000000000p-558, -0x1.007fffffe0000p+756, 0x0.0000000000000p+0, 0x1.008000801fbfep+292, -0x1.fffeffff07900p+231},
+{0x1.3fe0000100000p-20, -0x1.0000000000000p-93, 0x1.3fffffffffe00p-397, 0x1.fe00040000000p-472, 0x1.8fd800013fd80p-417, 0x1.ffffc7d404500p-472},
+{0x1.3fe0000100000p-20, -0x1.0000000000000p-93, -0x1.3fffffffffe00p-397, -0x1.fe00040000000p-472, -0x1.8fd800013fd80p-417, -0x1.ffffc7d404500p-472},
+{-0x1.3fe0000100000p-20, 0x1.0000000000000p-93, 0x1.3fffffffffe00p-397, 0x1.fe00040000000p-472, -0x1.8fd800013fd80p-417, -0x1.ffffc7d404500p-472},
+{-0x1.3fe0000100000p-20, 0x1.0000000000000p-93, -0x1.3fffffffffe00p-397, -0x1.fe00040000000p-472, 0x1.8fd800013fd80p-417, 0x1.ffffc7d404500p-472},
+{0x1.0001fff800000p-371, 0x1.ffffff0000ffep-425, 0x1.00ff000000800p-806, -0x1.0000000800000p-872, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0001fff800000p-371, 0x1.ffffff0000ffep-425, -0x1.00ff000000800p-806, 0x1.0000000800000p-872, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0001fff800000p-371, -0x1.ffffff0000ffep-425, 0x1.00ff000000800p-806, -0x1.0000000800000p-872, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0001fff800000p-371, -0x1.ffffff0000ffep-425, -0x1.00ff000000800p-806, 0x1.0000000800000p-872, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000800000000p-723, -0x1.ffffffe400000p-786, 0x1.000001ffffffap-94, -0x1.ffe1f80400000p-169, 0x1.0000820000ffap-817, -0x1.0c100109bfa00p-879},
+{0x1.0000800000000p-723, -0x1.ffffffe400000p-786, -0x1.000001ffffffap-94, 0x1.ffe1f80400000p-169, -0x1.0000820000ffap-817, 0x1.0c100109bfa00p-879},
+{-0x1.0000800000000p-723, 0x1.ffffffe400000p-786, 0x1.000001ffffffap-94, -0x1.ffe1f80400000p-169, -0x1.0000820000ffap-817, 0x1.0c100109bfa00p-879},
+{-0x1.0000800000000p-723, 0x1.ffffffe400000p-786, -0x1.000001ffffffap-94, 0x1.ffe1f80400000p-169, 0x1.0000820000ffap-817, -0x1.0c100109bfa00p-879},
+{0x1.0000010000000p-343, -0x1.0000000000000p-448, 0x1.007fffffffc00p-425, 0x1.fffffc0000000p-496, 0x1.008001007fc00p-768, -0x1.e000002004000p-835},
+{0x1.0000010000000p-343, -0x1.0000000000000p-448, -0x1.007fffffffc00p-425, -0x1.fffffc0000000p-496, -0x1.008001007fc00p-768, 0x1.e000002004000p-835},
+{-0x1.0000010000000p-343, 0x1.0000000000000p-448, 0x1.007fffffffc00p-425, 0x1.fffffc0000000p-496, -0x1.008001007fc00p-768, 0x1.e000002004000p-835},
+{-0x1.0000010000000p-343, 0x1.0000000000000p-448, -0x1.007fffffffc00p-425, -0x1.fffffc0000000p-496, 0x1.008001007fc00p-768, -0x1.e000002004000p-835},
+{0x1.0080000000000p-417, -0x1.0000000000000p-490, 0x1.001ffffffc000p-985, 0x1.0000000000000p-1039, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0080000000000p-417, -0x1.0000000000000p-490, -0x1.001ffffffc000p-985, -0x1.0000000000000p-1039, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0080000000000p-417, 0x1.0000000000000p-490, 0x1.001ffffffc000p-985, 0x1.0000000000000p-1039, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0080000000000p-417, 0x1.0000000000000p-490, -0x1.001ffffffc000p-985, -0x1.0000000000000p-1039, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.000001fffff80p-758, 0x1.fffffc001fffcp-813, 0x1.00001ffff8000p+939, 0x1.00007f001e000p+884, 0x1.000021fff8380p+181, 0x1.7bc05e90173aep+127},
+{0x1.000001fffff80p-758, 0x1.fffffc001fffcp-813, -0x1.00001ffff8000p+939, -0x1.00007f001e000p+884, -0x1.000021fff8380p+181, -0x1.7bc05e90173aep+127},
+{-0x1.000001fffff80p-758, -0x1.fffffc001fffcp-813, 0x1.00001ffff8000p+939, 0x1.00007f001e000p+884, -0x1.000021fff8380p+181, -0x1.7bc05e90173aep+127},
+{-0x1.000001fffff80p-758, -0x1.fffffc001fffcp-813, -0x1.00001ffff8000p+939, -0x1.00007f001e000p+884, 0x1.000021fff8380p+181, 0x1.7bc05e90173aep+127},
+{0x1.00f3ffffff000p-189, 0x1.fff8000000000p-257, 0x1.3dfffffffc000p+294, 0x1.ff000003ffe00p+233, 0x1.3f2f17fffabe3p+105, 0x1.02efbc1200d00p+45},
+{0x1.00f3ffffff000p-189, 0x1.fff8000000000p-257, -0x1.3dfffffffc000p+294, -0x1.ff000003ffe00p+233, -0x1.3f2f17fffabe3p+105, -0x1.02efbc1200d00p+45},
+{-0x1.00f3ffffff000p-189, -0x1.fff8000000000p-257, 0x1.3dfffffffc000p+294, 0x1.ff000003ffe00p+233, -0x1.3f2f17fffabe3p+105, -0x1.02efbc1200d00p+45},
+{-0x1.00f3ffffff000p-189, -0x1.fff8000000000p-257, -0x1.3dfffffffc000p+294, -0x1.ff000003ffe00p+233, 0x1.3f2f17fffabe3p+105, 0x1.02efbc1200d00p+45},
+{0x1.0000001ffff80p-98, 0x1.fffffdfffff8ep-152, 0x1.0000000000000p+1023, -0x1.0000000000000p+953, 0x1.0000001ffff80p+925, 0x1.fffefdffffd8ep+871},
+{0x1.0000001ffff80p-98, 0x1.fffffdfffff8ep-152, -0x1.0000000000000p+1023, 0x1.0000000000000p+953, -0x1.0000001ffff80p+925, -0x1.fffefdffffd8ep+871},
+{-0x1.0000001ffff80p-98, -0x1.fffffdfffff8ep-152, 0x1.0000000000000p+1023, -0x1.0000000000000p+953, -0x1.0000001ffff80p+925, -0x1.fffefdffffd8ep+871},
+{-0x1.0000001ffff80p-98, -0x1.fffffdfffff8ep-152, -0x1.0000000000000p+1023, 0x1.0000000000000p+953, 0x1.0000001ffff80p+925, 0x1.fffefdffffd8ep+871},
+{0x1.001fffffffe00p+730, 0x0.0000000000000p+0, 0x1.0000002000000p+702, -0x1.0000000000000p+602, INFINITY, 0x0.0000000000000p+0},
+{0x1.001fffffffe00p+730, 0x0.0000000000000p+0, -0x1.0000002000000p+702, 0x1.0000000000000p+602, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.001fffffffe00p+730, 0x0.0000000000000p+0, 0x1.0000002000000p+702, -0x1.0000000000000p+602, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.001fffffffe00p+730, 0x0.0000000000000p+0, -0x1.0000002000000p+702, 0x1.0000000000000p+602, INFINITY, 0x0.0000000000000p+0},
+{0x1.01ffffffe0000p+902, 0x1.c000000200000p+841, 0x1.0001fff800ffep-251, 0x1.c000000000000p-354, 0x1.020203f7d101ap+651, -0x1.88001fe2ff740p+592},
+{0x1.01ffffffe0000p+902, 0x1.c000000200000p+841, -0x1.0001fff800ffep-251, -0x1.c000000000000p-354, -0x1.020203f7d101ap+651, 0x1.88001fe2ff740p+592},
+{-0x1.01ffffffe0000p+902, -0x1.c000000200000p+841, 0x1.0001fff800ffep-251, 0x1.c000000000000p-354, -0x1.020203f7d101ap+651, 0x1.88001fe2ff740p+592},
+{-0x1.01ffffffe0000p+902, -0x1.c000000200000p+841, -0x1.0001fff800ffep-251, -0x1.c000000000000p-354, 0x1.020203f7d101ap+651, -0x1.88001fe2ff740p+592},
+{0x1.00000007ff800p-179, 0x1.ffff800000000p-267, 0x1.00003fe0c4000p+973, -0x1.fffc032000000p+910, 0x1.00003fe8c3820p+794, -0x1.1dd05a045ffe0p+738},
+{0x1.00000007ff800p-179, 0x1.ffff800000000p-267, -0x1.00003fe0c4000p+973, 0x1.fffc032000000p+910, -0x1.00003fe8c3820p+794, 0x1.1dd05a045ffe0p+738},
+{-0x1.00000007ff800p-179, -0x1.ffff800000000p-267, 0x1.00003fe0c4000p+973, -0x1.fffc032000000p+910, -0x1.00003fe8c3820p+794, 0x1.1dd05a045ffe0p+738},
+{-0x1.00000007ff800p-179, -0x1.ffff800000000p-267, -0x1.00003fe0c4000p+973, 0x1.fffc032000000p+910, 0x1.00003fe8c3820p+794, -0x1.1dd05a045ffe0p+738},
+{0x1.000001fff8008p-475, -0x1.0000000000000p-557, 0x1.000ffffff8000p+593, 0x1.ffffffffffc00p+538, 0x1.0010020010000p+118, 0x1.fc0023ddedc10p+63},
+{0x1.000001fff8008p-475, -0x1.0000000000000p-557, -0x1.000ffffff8000p+593, -0x1.ffffffffffc00p+538, -0x1.0010020010000p+118, -0x1.fc0023ddedc10p+63},
+{-0x1.000001fff8008p-475, 0x1.0000000000000p-557, 0x1.000ffffff8000p+593, 0x1.ffffffffffc00p+538, -0x1.0010020010000p+118, -0x1.fc0023ddedc10p+63},
+{-0x1.000001fff8008p-475, 0x1.0000000000000p-557, -0x1.000ffffff8000p+593, -0x1.ffffffffffc00p+538, 0x1.0010020010000p+118, 0x1.fc0023ddedc10p+63},
+{0x1.007fbfffffcf0p-964, 0x1.ffff803ffe000p-1019, 0x1.0007ffff00000p+383, 0x1.fffff80000000p+313, 0x1.0087c3fcff4f4p-581, 0x1.3c139ab8eff88p-636},
+{0x1.007fbfffffcf0p-964, 0x1.ffff803ffe000p-1019, -0x1.0007ffff00000p+383, -0x1.fffff80000000p+313, -0x1.0087c3fcff4f4p-581, -0x1.3c139ab8eff88p-636},
+{-0x1.007fbfffffcf0p-964, -0x1.ffff803ffe000p-1019, 0x1.0007ffff00000p+383, 0x1.fffff80000000p+313, -0x1.0087c3fcff4f4p-581, -0x1.3c139ab8eff88p-636},
+{-0x1.007fbfffffcf0p-964, -0x1.ffff803ffe000p-1019, -0x1.0007ffff00000p+383, -0x1.fffff80000000p+313, 0x1.0087c3fcff4f4p-581, 0x1.3c139ab8eff88p-636},
+{0x1.0000001fc4000p-493, -0x1.fe003ffe00000p-549, 0x1.01ffffffc0004p+997, -0x1.fffc100000000p+936, 0x1.0200001fc3884p+504, -0x1.0cf68c873c5e4p+449},
+{0x1.0000001fc4000p-493, -0x1.fe003ffe00000p-549, -0x1.01ffffffc0004p+997, 0x1.fffc100000000p+936, -0x1.0200001fc3884p+504, 0x1.0cf68c873c5e4p+449},
+{-0x1.0000001fc4000p-493, 0x1.fe003ffe00000p-549, 0x1.01ffffffc0004p+997, -0x1.fffc100000000p+936, -0x1.0200001fc3884p+504, 0x1.0cf68c873c5e4p+449},
+{-0x1.0000001fc4000p-493, 0x1.fe003ffe00000p-549, -0x1.01ffffffc0004p+997, 0x1.fffc100000000p+936, 0x1.0200001fc3884p+504, -0x1.0cf68c873c5e4p+449},
+{0x1.0007e3ffe0000p-845, 0x1.fe0ffffffe000p-909, 0x1.0000001000000p+62, -0x1.ffffff0000800p-2, 0x1.0007e40fe07e4p-783, -0x1.00ffe36fecc00p-846},
+{0x1.0007e3ffe0000p-845, 0x1.fe0ffffffe000p-909, -0x1.0000001000000p+62, 0x1.ffffff0000800p-2, -0x1.0007e40fe07e4p-783, 0x1.00ffe36fecc00p-846},
+{-0x1.0007e3ffe0000p-845, -0x1.fe0ffffffe000p-909, 0x1.0000001000000p+62, -0x1.ffffff0000800p-2, -0x1.0007e40fe07e4p-783, 0x1.00ffe36fecc00p-846},
+{-0x1.0007e3ffe0000p-845, -0x1.fe0ffffffe000p-909, -0x1.0000001000000p+62, 0x1.ffffff0000800p-2, 0x1.0007e40fe07e4p-783, -0x1.00ffe36fecc00p-846},
+{0x1.0000001000000p-487, -0x1.fffffff804000p-554, 0x1.003ffffff8000p+696, 0x1.f00000007fc00p+638, 0x1.0040000ffc000p+209, 0x1.ecffc01f83c60p+151},
+{0x1.0000001000000p-487, -0x1.fffffff804000p-554, -0x1.003ffffff8000p+696, -0x1.f00000007fc00p+638, -0x1.0040000ffc000p+209, -0x1.ecffc01f83c60p+151},
+{-0x1.0000001000000p-487, 0x1.fffffff804000p-554, 0x1.003ffffff8000p+696, 0x1.f00000007fc00p+638, -0x1.0040000ffc000p+209, -0x1.ecffc01f83c60p+151},
+{-0x1.0000001000000p-487, 0x1.fffffff804000p-554, -0x1.003ffffff8000p+696, -0x1.f00000007fc00p+638, 0x1.0040000ffc000p+209, 0x1.ecffc01f83c60p+151},
+{0x1.1ffff80000000p+591, 0x1.ffffff7ff8000p+532, 0x1.00ff000000004p+69, -0x1.ffffff0000400p+6, 0x1.211ed7f808005p+660, -0x1.f1108ffb743c6p+606},
+{0x1.1ffff80000000p+591, 0x1.ffffff7ff8000p+532, -0x1.00ff000000004p+69, 0x1.ffffff0000400p+6, -0x1.211ed7f808005p+660, 0x1.f1108ffb743c6p+606},
+{-0x1.1ffff80000000p+591, -0x1.ffffff7ff8000p+532, 0x1.00ff000000004p+69, -0x1.ffffff0000400p+6, -0x1.211ed7f808005p+660, 0x1.f1108ffb743c6p+606},
+{-0x1.1ffff80000000p+591, -0x1.ffffff7ff8000p+532, -0x1.00ff000000004p+69, 0x1.ffffff0000400p+6, 0x1.211ed7f808005p+660, -0x1.f1108ffb743c6p+606},
+{0x1.000000ffff800p-309, 0x1.fffffc0000000p-392, 0x1.0008000000000p+75, -0x1.0000000000000p+7, 0x1.0008010007800p-234, -0x1.0003fff003802p-288},
+{0x1.000000ffff800p-309, 0x1.fffffc0000000p-392, -0x1.0008000000000p+75, 0x1.0000000000000p+7, -0x1.0008010007800p-234, 0x1.0003fff003802p-288},
+{-0x1.000000ffff800p-309, -0x1.fffffc0000000p-392, 0x1.0008000000000p+75, -0x1.0000000000000p+7, -0x1.0008010007800p-234, 0x1.0003fff003802p-288},
+{-0x1.000000ffff800p-309, -0x1.fffffc0000000p-392, -0x1.0008000000000p+75, 0x1.0000000000000p+7, 0x1.0008010007800p-234, -0x1.0003fff003802p-288},
+{0x1.0000183ffffc0p+670, 0x1.fff07fcfffffcp+616, 0x1.0000010000000p+363, -0x1.0000000000000p+288, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000183ffffc0p+670, 0x1.fff07fcfffffcp+616, -0x1.0000010000000p+363, 0x1.0000000000000p+288, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000183ffffc0p+670, -0x1.fff07fcfffffcp+616, 0x1.0000010000000p+363, -0x1.0000000000000p+288, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000183ffffc0p+670, -0x1.fff07fcfffffcp+616, -0x1.0000010000000p+363, 0x1.0000000000000p+288, INFINITY, 0x0.0000000000000p+0},
+{0x1.0001000000000p-455, -0x1.fffffff800400p-518, 0x1.0000800000000p-998, -0x1.0000000000000p-1070, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0001000000000p-455, -0x1.fffffff800400p-518, -0x1.0000800000000p-998, 0x1.0000000000000p-1070, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0001000000000p-455, 0x1.fffffff800400p-518, 0x1.0000800000000p-998, -0x1.0000000000000p-1070, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0001000000000p-455, 0x1.fffffff800400p-518, -0x1.0000800000000p-998, 0x1.0000000000000p-1070, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.3ffff800fff81p-572, -0x1.0000000000000p-663, 0x1.1fffffff00000p+890, 0x1.fffffff000000p+813, 0x1.67fff6ffdff72p+318, -0x1.803ff90409202p+264},
+{0x1.3ffff800fff81p-572, -0x1.0000000000000p-663, -0x1.1fffffff00000p+890, -0x1.fffffff000000p+813, -0x1.67fff6ffdff72p+318, 0x1.803ff90409202p+264},
+{-0x1.3ffff800fff81p-572, 0x1.0000000000000p-663, 0x1.1fffffff00000p+890, 0x1.fffffff000000p+813, -0x1.67fff6ffdff72p+318, 0x1.803ff90409202p+264},
+{-0x1.3ffff800fff81p-572, 0x1.0000000000000p-663, -0x1.1fffffff00000p+890, -0x1.fffffff000000p+813, 0x1.67fff6ffdff72p+318, -0x1.803ff90409202p+264},
+{0x1.fffffc0000100p-97, -0x1.fffe000040000p-168, 0x1.0000800000000p-692, -0x1.c000fffffffd0p-749, 0x1.00007dffff080p-788, -0x1.b804fc7dfe0a0p-845},
+{0x1.fffffc0000100p-97, -0x1.fffe000040000p-168, -0x1.0000800000000p-692, 0x1.c000fffffffd0p-749, -0x1.00007dffff080p-788, 0x1.b804fc7dfe0a0p-845},
+{-0x1.fffffc0000100p-97, 0x1.fffe000040000p-168, 0x1.0000800000000p-692, -0x1.c000fffffffd0p-749, -0x1.00007dffff080p-788, 0x1.b804fc7dfe0a0p-845},
+{-0x1.fffffc0000100p-97, 0x1.fffe000040000p-168, -0x1.0000800000000p-692, 0x1.c000fffffffd0p-749, 0x1.00007dffff080p-788, -0x1.b804fc7dfe0a0p-845},
+{0x1.003f80ff00004p-671, -0x1.ffffc00040000p-742, 0x1.0000ffffff000p+38, 0x1.ffe000003ffe0p-20, 0x1.0040813e7fff0p-633, 0x1.fea97cff90170p-690},
+{0x1.003f80ff00004p-671, -0x1.ffffc00040000p-742, -0x1.0000ffffff000p+38, -0x1.ffe000003ffe0p-20, -0x1.0040813e7fff0p-633, -0x1.fea97cff90170p-690},
+{-0x1.003f80ff00004p-671, 0x1.ffffc00040000p-742, 0x1.0000ffffff000p+38, 0x1.ffe000003ffe0p-20, -0x1.0040813e7fff0p-633, -0x1.fea97cff90170p-690},
+{-0x1.003f80ff00004p-671, 0x1.ffffc00040000p-742, -0x1.0000ffffff000p+38, -0x1.ffe000003ffe0p-20, 0x1.0040813e7fff0p-633, 0x1.fea97cff90170p-690},
+{0x1.000003fffff80p+967, 0x1.f007ffe00fc00p+904, 0x1.3ff8007ffffc0p-732, 0x1.e0007ff000000p-798, 0x1.3ff8057fdff40p+235, 0x1.14efd48c70c80p+177},
+{0x1.000003fffff80p+967, 0x1.f007ffe00fc00p+904, -0x1.3ff8007ffffc0p-732, -0x1.e0007ff000000p-798, -0x1.3ff8057fdff40p+235, -0x1.14efd48c70c80p+177},
+{-0x1.000003fffff80p+967, -0x1.f007ffe00fc00p+904, 0x1.3ff8007ffffc0p-732, 0x1.e0007ff000000p-798, -0x1.3ff8057fdff40p+235, -0x1.14efd48c70c80p+177},
+{-0x1.000003fffff80p+967, -0x1.f007ffe00fc00p+904, -0x1.3ff8007ffffc0p-732, -0x1.e0007ff000000p-798, 0x1.3ff8057fdff40p+235, 0x1.14efd48c70c80p+177},
+{0x1.ffffffe000000p-621, -0x1.ff80000020000p-677, 0x1.0000ffffff81fp+121, 0x1.ffc7fff800000p+57, 0x1.0000ffefff71fp-499, -0x1.fb72ad806efd0p-556},
+{0x1.ffffffe000000p-621, -0x1.ff80000020000p-677, -0x1.0000ffffff81fp+121, -0x1.ffc7fff800000p+57, -0x1.0000ffefff71fp-499, 0x1.fb72ad806efd0p-556},
+{-0x1.ffffffe000000p-621, 0x1.ff80000020000p-677, 0x1.0000ffffff81fp+121, 0x1.ffc7fff800000p+57, -0x1.0000ffefff71fp-499, 0x1.fb72ad806efd0p-556},
+{-0x1.ffffffe000000p-621, 0x1.ff80000020000p-677, -0x1.0000ffffff81fp+121, -0x1.ffc7fff800000p+57, 0x1.0000ffefff71fp-499, -0x1.fb72ad806efd0p-556},
+{0x1.0000000800000p-286, -0x1.ffffc02000000p-364, 0x1.7fffe00800000p-363, -0x1.0000000000000p-468, 0x1.7fffe013ffff0p-649, 0x1.ffffa00013f40p-708},
+{0x1.0000000800000p-286, -0x1.ffffc02000000p-364, -0x1.7fffe00800000p-363, 0x1.0000000000000p-468, -0x1.7fffe013ffff0p-649, -0x1.ffffa00013f40p-708},
+{-0x1.0000000800000p-286, 0x1.ffffc02000000p-364, 0x1.7fffe00800000p-363, -0x1.0000000000000p-468, -0x1.7fffe013ffff0p-649, -0x1.ffffa00013f40p-708},
+{-0x1.0000000800000p-286, 0x1.ffffc02000000p-364, -0x1.7fffe00800000p-363, 0x1.0000000000000p-468, 0x1.7fffe013ffff0p-649, 0x1.ffffa00013f40p-708},
+{0x1.0000400000000p+600, -0x1.0000000000000p+509, 0x1.4000000000000p-65, -0x1.ffffffff00020p-123, 0x1.4000500000000p+535, -0x1.00003fffd0010p+478},
+{0x1.0000400000000p+600, -0x1.0000000000000p+509, -0x1.4000000000000p-65, 0x1.ffffffff00020p-123, -0x1.4000500000000p+535, 0x1.00003fffd0010p+478},
+{-0x1.0000400000000p+600, 0x1.0000000000000p+509, 0x1.4000000000000p-65, -0x1.ffffffff00020p-123, -0x1.4000500000000p+535, 0x1.00003fffd0010p+478},
+{-0x1.0000400000000p+600, 0x1.0000000000000p+509, -0x1.4000000000000p-65, 0x1.ffffffff00020p-123, 0x1.4000500000000p+535, -0x1.00003fffd0010p+478},
+{0x1.000000fffff80p-307, 0x1.ffffef003e000p-370, 0x1.0000010000000p-490, -0x1.8000000000020p-548, 0x1.000001fffff90p-797, -0x1.702001f7fe060p-855},
+{0x1.000000fffff80p-307, 0x1.ffffef003e000p-370, -0x1.0000010000000p-490, 0x1.8000000000020p-548, -0x1.000001fffff90p-797, 0x1.702001f7fe060p-855},
+{-0x1.000000fffff80p-307, -0x1.ffffef003e000p-370, 0x1.0000010000000p-490, -0x1.8000000000020p-548, -0x1.000001fffff90p-797, 0x1.702001f7fe060p-855},
+{-0x1.000000fffff80p-307, -0x1.ffffef003e000p-370, -0x1.0000010000000p-490, 0x1.8000000000020p-548, 0x1.000001fffff90p-797, -0x1.702001f7fe060p-855},
+{0x1.7fffffffc0000p-18, 0x1.fffc000000000p-88, 0x1.0000001fe0000p-469, 0x1.fffffc0001f00p-530, 0x1.8000002f90000p-487, 0x1.00fffbffd1600p-547},
+{0x1.7fffffffc0000p-18, 0x1.fffc000000000p-88, -0x1.0000001fe0000p-469, -0x1.fffffc0001f00p-530, -0x1.8000002f90000p-487, -0x1.00fffbffd1600p-547},
+{-0x1.7fffffffc0000p-18, -0x1.fffc000000000p-88, 0x1.0000001fe0000p-469, 0x1.fffffc0001f00p-530, -0x1.8000002f90000p-487, -0x1.00fffbffd1600p-547},
+{-0x1.7fffffffc0000p-18, -0x1.fffc000000000p-88, -0x1.0000001fe0000p-469, -0x1.fffffc0001f00p-530, 0x1.8000002f90000p-487, 0x1.00fffbffd1600p-547},
+{0x1.0000004000000p+707, -0x1.0000000000000p+649, 0x1.8000000000000p+850, -0x1.ffe7ffc001000p+785, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000004000000p+707, -0x1.0000000000000p+649, -0x1.8000000000000p+850, 0x1.ffe7ffc001000p+785, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000004000000p+707, 0x1.0000000000000p+649, 0x1.8000000000000p+850, -0x1.ffe7ffc001000p+785, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000004000000p+707, 0x1.0000000000000p+649, -0x1.8000000000000p+850, 0x1.ffe7ffc001000p+785, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000000800000p+842, -0x1.fffffff400000p+767, 0x1.007fc00007800p+448, 0x1.e0000f80001e0p+390, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000000800000p+842, -0x1.fffffff400000p+767, -0x1.007fc00007800p+448, -0x1.e0000f80001e0p+390, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000000800000p+842, 0x1.fffffff400000p+767, 0x1.007fc00007800p+448, 0x1.e0000f80001e0p+390, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000000800000p+842, 0x1.fffffff400000p+767, -0x1.007fc00007800p+448, -0x1.e0000f80001e0p+390, INFINITY, 0x0.0000000000000p+0},
+{0x1.3fffff0000000p+131, 0x1.fffffe0000000p+68, 0x1.0000200000000p+733, -0x1.0000000000000p+628, 0x1.400026ffffe00p+864, 0x1.00001effffc00p+802},
+{0x1.3fffff0000000p+131, 0x1.fffffe0000000p+68, -0x1.0000200000000p+733, 0x1.0000000000000p+628, -0x1.400026ffffe00p+864, -0x1.00001effffc00p+802},
+{-0x1.3fffff0000000p+131, -0x1.fffffe0000000p+68, 0x1.0000200000000p+733, -0x1.0000000000000p+628, -0x1.400026ffffe00p+864, -0x1.00001effffc00p+802},
+{-0x1.3fffff0000000p+131, -0x1.fffffe0000000p+68, -0x1.0000200000000p+733, 0x1.0000000000000p+628, 0x1.400026ffffe00p+864, 0x1.00001effffc00p+802},
+{0x1.7fe0000000008p+383, -0x1.fffff3ff80200p+321, 0x1.000001fff8400p-754, -0x1.fffff80010000p-819, 0x1.7fe002ffb4617p-371, 0x1.fda04808886c8p-425},
+{0x1.7fe0000000008p+383, -0x1.fffff3ff80200p+321, -0x1.000001fff8400p-754, 0x1.fffff80010000p-819, -0x1.7fe002ffb4617p-371, -0x1.fda04808886c8p-425},
+{-0x1.7fe0000000008p+383, 0x1.fffff3ff80200p+321, 0x1.000001fff8400p-754, -0x1.fffff80010000p-819, -0x1.7fe002ffb4617p-371, -0x1.fda04808886c8p-425},
+{-0x1.7fe0000000008p+383, 0x1.fffff3ff80200p+321, -0x1.000001fff8400p-754, 0x1.fffff80010000p-819, 0x1.7fe002ffb4617p-371, 0x1.fda04808886c8p-425},
+{0x1.00000fffffff8p-769, 0x1.fffffffc00000p-828, 0x1.0000007001000p+11, -0x1.e00000fff8200p-49, 0x1.0000107001068p-758, 0x1.8ffe315805e80p-817},
+{0x1.00000fffffff8p-769, 0x1.fffffffc00000p-828, -0x1.0000007001000p+11, 0x1.e00000fff8200p-49, -0x1.0000107001068p-758, -0x1.8ffe315805e80p-817},
+{-0x1.00000fffffff8p-769, -0x1.fffffffc00000p-828, 0x1.0000007001000p+11, -0x1.e00000fff8200p-49, -0x1.0000107001068p-758, -0x1.8ffe315805e80p-817},
+{-0x1.00000fffffff8p-769, -0x1.fffffffc00000p-828, -0x1.0000007001000p+11, 0x1.e00000fff8200p-49, 0x1.0000107001068p-758, 0x1.8ffe315805e80p-817},
+{0x1.001fffc000400p-304, -0x1.e000000001000p-369, 0x1.0200000000000p+539, -0x1.0000000000000p+436, 0x1.02203fbf80408p+235, -0x1.e3c0000005000p+170},
+{0x1.001fffc000400p-304, -0x1.e000000001000p-369, -0x1.0200000000000p+539, 0x1.0000000000000p+436, -0x1.02203fbf80408p+235, 0x1.e3c0000005000p+170},
+{-0x1.001fffc000400p-304, 0x1.e000000001000p-369, 0x1.0200000000000p+539, -0x1.0000000000000p+436, -0x1.02203fbf80408p+235, 0x1.e3c0000005000p+170},
+{-0x1.001fffc000400p-304, 0x1.e000000001000p-369, -0x1.0200000000000p+539, 0x1.0000000000000p+436, 0x1.02203fbf80408p+235, -0x1.e3c0000005000p+170},
+{0x1.0000008000000p+148, -0x1.0000000000000p+78, 0x1.07fff80000002p-186, -0x1.c010000000000p-257, 0x1.07fff883fffc2p-38, -0x1.e407f87000000p-108},
+{0x1.0000008000000p+148, -0x1.0000000000000p+78, -0x1.07fff80000002p-186, 0x1.c010000000000p-257, -0x1.07fff883fffc2p-38, 0x1.e407f87000000p-108},
+{-0x1.0000008000000p+148, 0x1.0000000000000p+78, 0x1.07fff80000002p-186, -0x1.c010000000000p-257, -0x1.07fff883fffc2p-38, 0x1.e407f87000000p-108},
+{-0x1.0000008000000p+148, 0x1.0000000000000p+78, -0x1.07fff80000002p-186, 0x1.c010000000000p-257, 0x1.07fff883fffc2p-38, -0x1.e407f87000000p-108},
+{0x1.03ffffffe0000p+267, 0x1.ff80000000000p+178, 0x1.7ffff00000002p+830, -0x1.0000000000000p+737, INFINITY, 0x0.0000000000000p+0},
+{0x1.03ffffffe0000p+267, 0x1.ff80000000000p+178, -0x1.7ffff00000002p+830, 0x1.0000000000000p+737, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.03ffffffe0000p+267, -0x1.ff80000000000p+178, 0x1.7ffff00000002p+830, -0x1.0000000000000p+737, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.03ffffffe0000p+267, -0x1.ff80000000000p+178, -0x1.7ffff00000002p+830, 0x1.0000000000000p+737, INFINITY, 0x0.0000000000000p+0},
+{0x1.0008000000000p-881, -0x1.9000000000000p-982, 0x1.0000000700002p-545, -0x1.fffff80200000p-608, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0008000000000p-881, -0x1.9000000000000p-982, -0x1.0000000700002p-545, 0x1.fffff80200000p-608, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0008000000000p-881, 0x1.9000000000000p-982, 0x1.0000000700002p-545, -0x1.fffff80200000p-608, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0008000000000p-881, 0x1.9000000000000p-982, -0x1.0000000700002p-545, 0x1.fffff80200000p-608, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0010000000000p-465, -0x1.0000000000000p-542, 0x1.007fc00001000p+895, -0x1.ff80000400000p+839, 0x1.008fc7fc01001p+430, -0x1.ffa00007fe400p+374},
+{0x1.0010000000000p-465, -0x1.0000000000000p-542, -0x1.007fc00001000p+895, 0x1.ff80000400000p+839, -0x1.008fc7fc01001p+430, 0x1.ffa00007fe400p+374},
+{-0x1.0010000000000p-465, 0x1.0000000000000p-542, 0x1.007fc00001000p+895, -0x1.ff80000400000p+839, -0x1.008fc7fc01001p+430, 0x1.ffa00007fe400p+374},
+{-0x1.0010000000000p-465, 0x1.0000000000000p-542, -0x1.007fc00001000p+895, 0x1.ff80000400000p+839, 0x1.008fc7fc01001p+430, -0x1.ffa00007fe400p+374},
+{0x1.0000008000000p-249, -0x1.fff0000000100p-308, 0x1.7fffff8100000p+89, -0x1.fffcc00000080p+29, 0x1.80000040ffffcp-160, 0x1.9a07df8c40000p-231},
+{0x1.0000008000000p-249, -0x1.fff0000000100p-308, -0x1.7fffff8100000p+89, 0x1.fffcc00000080p+29, -0x1.80000040ffffcp-160, -0x1.9a07df8c40000p-231},
+{-0x1.0000008000000p-249, 0x1.fff0000000100p-308, 0x1.7fffff8100000p+89, -0x1.fffcc00000080p+29, -0x1.80000040ffffcp-160, -0x1.9a07df8c40000p-231},
+{-0x1.0000008000000p-249, 0x1.fff0000000100p-308, -0x1.7fffff8100000p+89, 0x1.fffcc00000080p+29, 0x1.80000040ffffcp-160, 0x1.9a07df8c40000p-231},
+{0x1.0000003ffc010p+789, -0x1.ffffc00400000p+720, 0x1.0000c00400000p+535, -0x1.ff80800000000p+454, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000003ffc010p+789, -0x1.ffffc00400000p+720, -0x1.0000c00400000p+535, 0x1.ff80800000000p+454, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000003ffc010p+789, 0x1.ffffc00400000p+720, 0x1.0000c00400000p+535, -0x1.ff80800000000p+454, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000003ffc010p+789, 0x1.ffffc00400000p+720, -0x1.0000c00400000p+535, 0x1.ff80800000000p+454, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000007fff800p+957, 0x1.ffff800007fc0p+898, 0x1.0000007fff000p+26, 0x1.ffffff8000000p-49, 0x1.000000fffe804p+983, 0x1.fa018500063c0p+924},
+{0x1.0000007fff800p+957, 0x1.ffff800007fc0p+898, -0x1.0000007fff000p+26, -0x1.ffffff8000000p-49, -0x1.000000fffe804p+983, -0x1.fa018500063c0p+924},
+{-0x1.0000007fff800p+957, -0x1.ffff800007fc0p+898, 0x1.0000007fff000p+26, 0x1.ffffff8000000p-49, -0x1.000000fffe804p+983, -0x1.fa018500063c0p+924},
+{-0x1.0000007fff800p+957, -0x1.ffff800007fc0p+898, -0x1.0000007fff000p+26, -0x1.ffffff8000000p-49, 0x1.000000fffe804p+983, 0x1.fa018500063c0p+924},
+{0x1.4000000000000p-257, -0x1.0000000000000p-339, 0x1.0000001ff8040p+59, -0x1.fff0ffffff008p+3, 0x1.40000027f6050p-198, -0x1.3ff6a01fff604p-253},
+{0x1.4000000000000p-257, -0x1.0000000000000p-339, -0x1.0000001ff8040p+59, 0x1.fff0ffffff008p+3, -0x1.40000027f6050p-198, 0x1.3ff6a01fff604p-253},
+{-0x1.4000000000000p-257, 0x1.0000000000000p-339, 0x1.0000001ff8040p+59, -0x1.fff0ffffff008p+3, -0x1.40000027f6050p-198, 0x1.3ff6a01fff604p-253},
+{-0x1.4000000000000p-257, 0x1.0000000000000p-339, -0x1.0000001ff8040p+59, 0x1.fff0ffffff008p+3, 0x1.40000027f6050p-198, -0x1.3ff6a01fff604p-253},
+{0x1.0004000000000p+457, -0x1.fffffffe40000p+386, 0x1.000001ffff1f0p+241, 0x1.ff807ffffc000p+187, 0x1.00040200071f0p+698, 0x1.1e877e01fa00ep+644},
+{0x1.0004000000000p+457, -0x1.fffffffe40000p+386, -0x1.000001ffff1f0p+241, -0x1.ff807ffffc000p+187, -0x1.00040200071f0p+698, -0x1.1e877e01fa00ep+644},
+{-0x1.0004000000000p+457, 0x1.fffffffe40000p+386, 0x1.000001ffff1f0p+241, 0x1.ff807ffffc000p+187, -0x1.00040200071f0p+698, -0x1.1e877e01fa00ep+644},
+{-0x1.0004000000000p+457, 0x1.fffffffe40000p+386, -0x1.000001ffff1f0p+241, -0x1.ff807ffffc000p+187, 0x1.00040200071f0p+698, 0x1.1e877e01fa00ep+644},
+{0x1.003fe00030100p-370, -0x1.00003fe002000p-436, 0x1.3ffffff800200p-197, -0x1.0000000000000p-274, 0x1.404fd7f83a350p-567, 0x1.fe8bdf7b033fep-621},
+{0x1.003fe00030100p-370, -0x1.00003fe002000p-436, -0x1.3ffffff800200p-197, 0x1.0000000000000p-274, -0x1.404fd7f83a350p-567, -0x1.fe8bdf7b033fep-621},
+{-0x1.003fe00030100p-370, 0x1.00003fe002000p-436, 0x1.3ffffff800200p-197, -0x1.0000000000000p-274, -0x1.404fd7f83a350p-567, -0x1.fe8bdf7b033fep-621},
+{-0x1.003fe00030100p-370, 0x1.00003fe002000p-436, -0x1.3ffffff800200p-197, 0x1.0000000000000p-274, 0x1.404fd7f83a350p-567, 0x1.fe8bdf7b033fep-621},
+{0x1.0001ffc1ffc20p+658, -0x1.fffffc0002000p+592, 0x1.000003fffffc0p-919, 0x1.fffffe0000000p-997, 0x1.000203c207bd0p-261, 0x1.fda2400001fd6p-315},
+{0x1.0001ffc1ffc20p+658, -0x1.fffffc0002000p+592, -0x1.000003fffffc0p-919, -0x1.fffffe0000000p-997, -0x1.000203c207bd0p-261, -0x1.fda2400001fd6p-315},
+{-0x1.0001ffc1ffc20p+658, 0x1.fffffc0002000p+592, 0x1.000003fffffc0p-919, 0x1.fffffe0000000p-997, -0x1.000203c207bd0p-261, -0x1.fda2400001fd6p-315},
+{-0x1.0001ffc1ffc20p+658, 0x1.fffffc0002000p+592, -0x1.000003fffffc0p-919, -0x1.fffffe0000000p-997, 0x1.000203c207bd0p-261, 0x1.fda2400001fd6p-315},
+{0x1.0400000000000p-38, -0x1.0000000000000p-92, 0x1.0000200000000p-364, -0x1.ffffffffffc40p-423, 0x1.0400208000000p-402, -0x1.10401ffffffe2p-456},
+{0x1.0400000000000p-38, -0x1.0000000000000p-92, -0x1.0000200000000p-364, 0x1.ffffffffffc40p-423, -0x1.0400208000000p-402, 0x1.10401ffffffe2p-456},
+{-0x1.0400000000000p-38, 0x1.0000000000000p-92, 0x1.0000200000000p-364, -0x1.ffffffffffc40p-423, -0x1.0400208000000p-402, 0x1.10401ffffffe2p-456},
+{-0x1.0400000000000p-38, 0x1.0000000000000p-92, -0x1.0000200000000p-364, 0x1.ffffffffffc40p-423, 0x1.0400208000000p-402, -0x1.10401ffffffe2p-456},
+{0x1.00003ff820000p+644, -0x1.ffffffe000100p+589, 0x1.0001f80020000p+462, -0x1.ffffffc1c0040p+403, INFINITY, 0x0.0000000000000p+0},
+{0x1.00003ff820000p+644, -0x1.ffffffe000100p+589, -0x1.0001f80020000p+462, 0x1.ffffffc1c0040p+403, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00003ff820000p+644, 0x1.ffffffe000100p+589, 0x1.0001f80020000p+462, -0x1.ffffffc1c0040p+403, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00003ff820000p+644, 0x1.ffffffe000100p+589, -0x1.0001f80020000p+462, 0x1.ffffffc1c0040p+403, INFINITY, 0x0.0000000000000p+0},
+{0x1.007ffffffff80p-432, 0x1.fffffffe00000p-506, 0x1.0100000000000p+937, -0x1.0000000000000p+860, 0x1.01807ffffff80p+505, -0x1.ffffe1e100002p+451},
+{0x1.007ffffffff80p-432, 0x1.fffffffe00000p-506, -0x1.0100000000000p+937, 0x1.0000000000000p+860, -0x1.01807ffffff80p+505, 0x1.ffffe1e100002p+451},
+{-0x1.007ffffffff80p-432, -0x1.fffffffe00000p-506, 0x1.0100000000000p+937, -0x1.0000000000000p+860, -0x1.01807ffffff80p+505, 0x1.ffffe1e100002p+451},
+{-0x1.007ffffffff80p-432, -0x1.fffffffe00000p-506, -0x1.0100000000000p+937, 0x1.0000000000000p+860, 0x1.01807ffffff80p+505, -0x1.ffffe1e100002p+451},
+{0x1.0000000400000p+229, -0x1.e00003fff8200p+167, 0x1.000ffff802000p-917, -0x1.fffe3fffffe00p-979, 0x1.000ffffc02400p-688, -0x1.7bc3887f27780p-747},
+{0x1.0000000400000p+229, -0x1.e00003fff8200p+167, -0x1.000ffff802000p-917, 0x1.fffe3fffffe00p-979, -0x1.000ffffc02400p-688, 0x1.7bc3887f27780p-747},
+{-0x1.0000000400000p+229, 0x1.e00003fff8200p+167, 0x1.000ffff802000p-917, -0x1.fffe3fffffe00p-979, -0x1.000ffffc02400p-688, 0x1.7bc3887f27780p-747},
+{-0x1.0000000400000p+229, 0x1.e00003fff8200p+167, -0x1.000ffff802000p-917, 0x1.fffe3fffffe00p-979, 0x1.000ffffc02400p-688, -0x1.7bc3887f27780p-747},
+{0x1.00003ffffff00p-811, 0x1.ffc003ffffe00p-866, 0x1.0001ff0000000p+595, 0x1.ff8007fffffe0p+540, 0x1.00023f007fb00p-216, 0x1.f7a644b024dd0p-270},
+{0x1.00003ffffff00p-811, 0x1.ffc003ffffe00p-866, -0x1.0001ff0000000p+595, -0x1.ff8007fffffe0p+540, -0x1.00023f007fb00p-216, -0x1.f7a644b024dd0p-270},
+{-0x1.00003ffffff00p-811, -0x1.ffc003ffffe00p-866, 0x1.0001ff0000000p+595, 0x1.ff8007fffffe0p+540, -0x1.00023f007fb00p-216, -0x1.f7a644b024dd0p-270},
+{-0x1.00003ffffff00p-811, -0x1.ffc003ffffe00p-866, -0x1.0001ff0000000p+595, -0x1.ff8007fffffe0p+540, 0x1.00023f007fb00p-216, 0x1.f7a644b024dd0p-270},
+{0x1.1000000000000p-978, -0x1.ff00000000000p-1043, 0x1.0200000000000p+352, -0x1.c000000000008p+296, 0x1.1220000000000p-626, -0x1.dd017f0000010p-682},
+{0x1.1000000000000p-978, -0x1.ff00000000000p-1043, -0x1.0200000000000p+352, 0x1.c000000000008p+296, -0x1.1220000000000p-626, 0x1.dd017f0000010p-682},
+{-0x1.1000000000000p-978, 0x1.ff00000000000p-1043, 0x1.0200000000000p+352, -0x1.c000000000008p+296, -0x1.1220000000000p-626, 0x1.dd017f0000010p-682},
+{-0x1.1000000000000p-978, 0x1.ff00000000000p-1043, -0x1.0200000000000p+352, 0x1.c000000000008p+296, 0x1.1220000000000p-626, -0x1.dd017f0000010p-682},
+{0x1.1fffffc000000p+620, 0x1.ffffffffffff0p+563, 0x1.007fc00000800p+980, -0x1.fffff03fff000p+920, INFINITY, 0x0.0000000000000p+0},
+{0x1.1fffffc000000p+620, 0x1.ffffffffffff0p+563, -0x1.007fc00000800p+980, 0x1.fffff03fff000p+920, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.1fffffc000000p+620, -0x1.ffffffffffff0p+563, 0x1.007fc00000800p+980, -0x1.fffff03fff000p+920, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.1fffffc000000p+620, -0x1.ffffffffffff0p+563, -0x1.007fc00000800p+980, 0x1.fffff03fff000p+920, INFINITY, 0x0.0000000000000p+0},
+{0x1.00007fffff000p+841, 0x1.ffffffff00000p+769, 0x1.1fffffffc0000p+334, 0x1.fff0000000000p+266, INFINITY, 0x0.0000000000000p+0},
+{0x1.00007fffff000p+841, 0x1.ffffffff00000p+769, -0x1.1fffffffc0000p+334, -0x1.fff0000000000p+266, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00007fffff000p+841, -0x1.ffffffff00000p+769, 0x1.1fffffffc0000p+334, 0x1.fff0000000000p+266, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00007fffff000p+841, -0x1.ffffffff00000p+769, -0x1.1fffffffc0000p+334, -0x1.fff0000000000p+266, INFINITY, 0x0.0000000000000p+0},
+{0x1.0003ffffffffcp+878, 0x1.f000000000000p+777, 0x1.0000003ffff80p+707, 0x1.fffffefff8000p+639, INFINITY, 0x0.0000000000000p+0},
+{0x1.0003ffffffffcp+878, 0x1.f000000000000p+777, -0x1.0000003ffff80p+707, -0x1.fffffefff8000p+639, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0003ffffffffcp+878, -0x1.f000000000000p+777, 0x1.0000003ffff80p+707, 0x1.fffffefff8000p+639, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0003ffffffffcp+878, -0x1.f000000000000p+777, -0x1.0000003ffff80p+707, -0x1.fffffefff8000p+639, INFINITY, 0x0.0000000000000p+0},
+{0x1.00007ffc00000p+210, 0x1.ffffe00000000p+141, 0x1.3fffffc004000p+887, -0x1.ffffe00010000p+823, INFINITY, 0x0.0000000000000p+0},
+{0x1.00007ffc00000p+210, 0x1.ffffe00000000p+141, -0x1.3fffffc004000p+887, 0x1.ffffe00010000p+823, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00007ffc00000p+210, -0x1.ffffe00000000p+141, 0x1.3fffffc004000p+887, -0x1.ffffe00010000p+823, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00007ffc00000p+210, -0x1.ffffe00000000p+141, -0x1.3fffffc004000p+887, 0x1.ffffe00010000p+823, INFINITY, 0x0.0000000000000p+0},
+{0x1.0007ffffc0004p+901, -0x1.fffffe0040000p+830, 0x1.00ffffe000400p-637, -0x1.0000000000000p-729, 0x1.010807dfbf004p+264, 0x1.23fdf20002418p+209},
+{0x1.0007ffffc0004p+901, -0x1.fffffe0040000p+830, -0x1.00ffffe000400p-637, 0x1.0000000000000p-729, -0x1.010807dfbf004p+264, -0x1.23fdf20002418p+209},
+{-0x1.0007ffffc0004p+901, 0x1.fffffe0040000p+830, 0x1.00ffffe000400p-637, -0x1.0000000000000p-729, -0x1.010807dfbf004p+264, -0x1.23fdf20002418p+209},
+{-0x1.0007ffffc0004p+901, 0x1.fffffe0040000p+830, -0x1.00ffffe000400p-637, 0x1.0000000000000p-729, 0x1.010807dfbf004p+264, 0x1.23fdf20002418p+209},
+{0x1.007ffffffff00p-57, 0x1.fff8003000000p-134, 0x1.01fffffffe000p-715, 0x1.fffc000000000p-803, 0x1.0280fffffdeeep-772, 0x1.041c07d800000p-848},
+{0x1.007ffffffff00p-57, 0x1.fff8003000000p-134, -0x1.01fffffffe000p-715, -0x1.fffc000000000p-803, -0x1.0280fffffdeeep-772, -0x1.041c07d800000p-848},
+{-0x1.007ffffffff00p-57, -0x1.fff8003000000p-134, 0x1.01fffffffe000p-715, 0x1.fffc000000000p-803, -0x1.0280fffffdeeep-772, -0x1.041c07d800000p-848},
+{-0x1.007ffffffff00p-57, -0x1.fff8003000000p-134, -0x1.01fffffffe000p-715, -0x1.fffc000000000p-803, 0x1.0280fffffdeeep-772, 0x1.041c07d800000p-848},
+{0x1.00003e0000000p-443, 0x1.ffffffffe0000p-502, 0x1.07ffffff80000p+79, 0x1.8007ffffc0000p+8, 0x1.08003fef7fffep-364, 0x1.4203001095e38p-420},
+{0x1.00003e0000000p-443, 0x1.ffffffffe0000p-502, -0x1.07ffffff80000p+79, -0x1.8007ffffc0000p+8, -0x1.08003fef7fffep-364, -0x1.4203001095e38p-420},
+{-0x1.00003e0000000p-443, -0x1.ffffffffe0000p-502, 0x1.07ffffff80000p+79, 0x1.8007ffffc0000p+8, -0x1.08003fef7fffep-364, -0x1.4203001095e38p-420},
+{-0x1.00003e0000000p-443, -0x1.ffffffffe0000p-502, -0x1.07ffffff80000p+79, -0x1.8007ffffc0000p+8, 0x1.08003fef7fffep-364, 0x1.4203001095e38p-420},
+{0x1.00003ff810000p-96, -0x1.fffffffc00800p-160, 0x1.00000ffff8002p+307, -0x1.fffffffe04000p+240, 0x1.00004ff80bffap+211, -0x1.01f8812df9b50p+155},
+{0x1.00003ff810000p-96, -0x1.fffffffc00800p-160, -0x1.00000ffff8002p+307, 0x1.fffffffe04000p+240, -0x1.00004ff80bffap+211, 0x1.01f8812df9b50p+155},
+{-0x1.00003ff810000p-96, 0x1.fffffffc00800p-160, 0x1.00000ffff8002p+307, -0x1.fffffffe04000p+240, -0x1.00004ff80bffap+211, 0x1.01f8812df9b50p+155},
+{-0x1.00003ff810000p-96, 0x1.fffffffc00800p-160, -0x1.00000ffff8002p+307, 0x1.fffffffe04000p+240, 0x1.00004ff80bffap+211, -0x1.01f8812df9b50p+155},
+{0x1.0100000000000p-135, -0x1.0000000000000p-222, 0x1.01ffffff00004p-1000, -0x0.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0100000000000p-135, -0x1.0000000000000p-222, -0x1.01ffffff00004p-1000, 0x0.0000000000000p+0, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0100000000000p-135, 0x1.0000000000000p-222, 0x1.01ffffff00004p-1000, -0x0.0000000000000p+0, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0100000000000p-135, 0x1.0000000000000p-222, -0x1.01ffffff00004p-1000, 0x0.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.001fffffff800p+829, 0x1.fffff00000000p+749, 0x1.07ffe00001000p+551, -0x1.c7ffc001fe010p+494, INFINITY, 0x0.0000000000000p+0},
+{0x1.001fffffff800p+829, 0x1.fffff00000000p+749, -0x1.07ffe00001000p+551, 0x1.c7ffc001fe010p+494, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.001fffffff800p+829, -0x1.fffff00000000p+749, 0x1.07ffe00001000p+551, -0x1.c7ffc001fe010p+494, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.001fffffff800p+829, -0x1.fffff00000000p+749, -0x1.07ffe00001000p+551, 0x1.c7ffc001fe010p+494, INFINITY, 0x0.0000000000000p+0},
+{0x1.000000ffffff8p-632, 0x1.ffe0000000000p-704, 0x1.1fffffff00001p+944, -0x1.0000000000000p+859, 0x1.2000011effff8p+312, -0x1.fffb5f5800140p+255},
+{0x1.000000ffffff8p-632, 0x1.ffe0000000000p-704, -0x1.1fffffff00001p+944, 0x1.0000000000000p+859, -0x1.2000011effff8p+312, 0x1.fffb5f5800140p+255},
+{-0x1.000000ffffff8p-632, -0x1.ffe0000000000p-704, 0x1.1fffffff00001p+944, -0x1.0000000000000p+859, -0x1.2000011effff8p+312, 0x1.fffb5f5800140p+255},
+{-0x1.000000ffffff8p-632, -0x1.ffe0000000000p-704, -0x1.1fffffff00001p+944, 0x1.0000000000000p+859, 0x1.2000011effff8p+312, -0x1.fffb5f5800140p+255},
+{0x1.00000007fff00p-172, 0x1.fffc1ffff87f0p-228, 0x1.0000007c00000p+935, 0x1.fff0000000000p+864, 0x1.00000083fff00p+763, 0x1.77fe1835fdafap+709},
+{0x1.00000007fff00p-172, 0x1.fffc1ffff87f0p-228, -0x1.0000007c00000p+935, -0x1.fff0000000000p+864, -0x1.00000083fff00p+763, -0x1.77fe1835fdafap+709},
+{-0x1.00000007fff00p-172, -0x1.fffc1ffff87f0p-228, 0x1.0000007c00000p+935, 0x1.fff0000000000p+864, -0x1.00000083fff00p+763, -0x1.77fe1835fdafap+709},
+{-0x1.00000007fff00p-172, -0x1.fffc1ffff87f0p-228, -0x1.0000007c00000p+935, -0x1.fff0000000000p+864, 0x1.00000083fff00p+763, 0x1.77fe1835fdafap+709},
+{0x1.fffffffe00000p-318, 0x1.e000001fff800p-382, 0x1.0000000000000p+232, -0x1.f000080000000p+147, 0x1.fffffffe00000p-86, 0x1.dfffe11fff000p-150},
+{0x1.fffffffe00000p-318, 0x1.e000001fff800p-382, -0x1.0000000000000p+232, 0x1.f000080000000p+147, -0x1.fffffffe00000p-86, -0x1.dfffe11fff000p-150},
+{-0x1.fffffffe00000p-318, -0x1.e000001fff800p-382, 0x1.0000000000000p+232, -0x1.f000080000000p+147, -0x1.fffffffe00000p-86, -0x1.dfffe11fff000p-150},
+{-0x1.fffffffe00000p-318, -0x1.e000001fff800p-382, -0x1.0000000000000p+232, 0x1.f000080000000p+147, 0x1.fffffffe00000p-86, 0x1.dfffe11fff000p-150},
+{0x1.00007fffffe00p+860, 0x1.ffffff8000000p+790, 0x1.001f03f07ff00p-428, 0x1.ffffff8000000p-501, 0x1.001f840001c84p+432, -0x1.f43a8782b15e0p+377},
+{0x1.00007fffffe00p+860, 0x1.ffffff8000000p+790, -0x1.001f03f07ff00p-428, -0x1.ffffff8000000p-501, -0x1.001f840001c84p+432, 0x1.f43a8782b15e0p+377},
+{-0x1.00007fffffe00p+860, -0x1.ffffff8000000p+790, 0x1.001f03f07ff00p-428, 0x1.ffffff8000000p-501, -0x1.001f840001c84p+432, 0x1.f43a8782b15e0p+377},
+{-0x1.00007fffffe00p+860, -0x1.ffffff8000000p+790, -0x1.001f03f07ff00p-428, -0x1.ffffff8000000p-501, 0x1.001f840001c84p+432, -0x1.f43a8782b15e0p+377},
+{0x1.00003fffffffcp+10, 0x1.ffe0000700000p-63, 0x1.001f000000040p-31, 0x1.ffc0ffffc0000p-102, 0x1.001f4007c003cp-21, -0x1.aec01b80c3200p-83},
+{0x1.00003fffffffcp+10, 0x1.ffe0000700000p-63, -0x1.001f000000040p-31, -0x1.ffc0ffffc0000p-102, -0x1.001f4007c003cp-21, 0x1.aec01b80c3200p-83},
+{-0x1.00003fffffffcp+10, -0x1.ffe0000700000p-63, 0x1.001f000000040p-31, 0x1.ffc0ffffc0000p-102, -0x1.001f4007c003cp-21, 0x1.aec01b80c3200p-83},
+{-0x1.00003fffffffcp+10, -0x1.ffe0000700000p-63, -0x1.001f000000040p-31, -0x1.ffc0ffffc0000p-102, 0x1.001f4007c003cp-21, -0x1.aec01b80c3200p-83},
+{0x1.0000100000000p+594, -0x1.0000000000000p+512, 0x1.0000020000000p+926, -0x1.0000000000000p+834, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000100000000p+594, -0x1.0000000000000p+512, -0x1.0000020000000p+926, 0x1.0000000000000p+834, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000100000000p+594, 0x1.0000000000000p+512, 0x1.0000020000000p+926, -0x1.0000000000000p+834, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000100000000p+594, 0x1.0000000000000p+512, -0x1.0000020000000p+926, 0x1.0000000000000p+834, INFINITY, 0x0.0000000000000p+0},
+{0x1.000007c000000p-87, 0x1.fff8000000000p-143, 0x1.003fff0000200p+65, -0x1.fe0003fc00040p+6, 0x1.004006c1f0184p-22, 0x1.c1aff992783b8p-78},
+{0x1.000007c000000p-87, 0x1.fff8000000000p-143, -0x1.003fff0000200p+65, 0x1.fe0003fc00040p+6, -0x1.004006c1f0184p-22, -0x1.c1aff992783b8p-78},
+{-0x1.000007c000000p-87, -0x1.fff8000000000p-143, 0x1.003fff0000200p+65, -0x1.fe0003fc00040p+6, -0x1.004006c1f0184p-22, -0x1.c1aff992783b8p-78},
+{-0x1.000007c000000p-87, -0x1.fff8000000000p-143, -0x1.003fff0000200p+65, 0x1.fe0003fc00040p+6, 0x1.004006c1f0184p-22, 0x1.c1aff992783b8p-78},
+{0x1.00001fffcffc0p+987, -0x1.fffe000000004p+932, 0x1.03fffff800000p-975, 0x1.fffffe0000000p-1043, 0x1.04002077cf3afp+12, -0x1.0396f3f70809ap-42},
+{0x1.00001fffcffc0p+987, -0x1.fffe000000004p+932, -0x1.03fffff800000p-975, -0x1.fffffe0000000p-1043, -0x1.04002077cf3afp+12, 0x1.0396f3f70809ap-42},
+{-0x1.00001fffcffc0p+987, 0x1.fffe000000004p+932, 0x1.03fffff800000p-975, 0x1.fffffe0000000p-1043, -0x1.04002077cf3afp+12, 0x1.0396f3f70809ap-42},
+{-0x1.00001fffcffc0p+987, 0x1.fffe000000004p+932, -0x1.03fffff800000p-975, -0x1.fffffe0000000p-1043, 0x1.04002077cf3afp+12, -0x1.0396f3f70809ap-42},
+{0x1.0000008000000p-118, -0x1.ffffff8200000p-175, 0x1.000fff8000000p-555, 0x1.fffffe0000000p-617, 0x1.0010000007ffcp-673, -0x1.f01ffe89f8200p-730},
+{0x1.0000008000000p-118, -0x1.ffffff8200000p-175, -0x1.000fff8000000p-555, -0x1.fffffe0000000p-617, -0x1.0010000007ffcp-673, 0x1.f01ffe89f8200p-730},
+{-0x1.0000008000000p-118, 0x1.ffffff8200000p-175, 0x1.000fff8000000p-555, 0x1.fffffe0000000p-617, -0x1.0010000007ffcp-673, 0x1.f01ffe89f8200p-730},
+{-0x1.0000008000000p-118, 0x1.ffffff8200000p-175, -0x1.000fff8000000p-555, -0x1.fffffe0000000p-617, 0x1.0010000007ffcp-673, -0x1.f01ffe89f8200p-730},
+{0x1.00000010001f8p+695, 0x1.fffc007e00000p+621, 0x1.0003fc0000000p-756, 0x1.ffff80ffffc00p-813, 0x1.0003fc10005f4p-61, 0x1.7d824090fe170p-117},
+{0x1.00000010001f8p+695, 0x1.fffc007e00000p+621, -0x1.0003fc0000000p-756, -0x1.ffff80ffffc00p-813, -0x1.0003fc10005f4p-61, -0x1.7d824090fe170p-117},
+{-0x1.00000010001f8p+695, -0x1.fffc007e00000p+621, 0x1.0003fc0000000p-756, 0x1.ffff80ffffc00p-813, -0x1.0003fc10005f4p-61, -0x1.7d824090fe170p-117},
+{-0x1.00000010001f8p+695, -0x1.fffc007e00000p+621, -0x1.0003fc0000000p-756, -0x1.ffff80ffffc00p-813, 0x1.0003fc10005f4p-61, 0x1.7d824090fe170p-117},
+{0x1.0000000000000p-985, -0x0.0000000000000p+0, 0x1.0300000001f00p-132, 0x1.fffffff800000p-208, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000000000000p-985, -0x0.0000000000000p+0, -0x1.0300000001f00p-132, -0x1.fffffff800000p-208, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000000000p-985, 0x0.0000000000000p+0, 0x1.0300000001f00p-132, 0x1.fffffff800000p-208, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000000000p-985, 0x0.0000000000000p+0, -0x1.0300000001f00p-132, -0x1.fffffff800000p-208, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.07ffffff1fe00p+389, 0x1.fc00000000000p+292, 0x1.0040000000000p+564, -0x1.c000000400000p+503, 0x1.0841ffff1fa7fp+953, 0x1.fc63fffffb100p+899},
+{0x1.07ffffff1fe00p+389, 0x1.fc00000000000p+292, -0x1.0040000000000p+564, 0x1.c000000400000p+503, -0x1.0841ffff1fa7fp+953, -0x1.fc63fffffb100p+899},
+{-0x1.07ffffff1fe00p+389, -0x1.fc00000000000p+292, 0x1.0040000000000p+564, -0x1.c000000400000p+503, -0x1.0841ffff1fa7fp+953, -0x1.fc63fffffb100p+899},
+{-0x1.07ffffff1fe00p+389, -0x1.fc00000000000p+292, -0x1.0040000000000p+564, 0x1.c000000400000p+503, 0x1.0841ffff1fa7fp+953, 0x1.fc63fffffb100p+899},
+{0x1.0080000000000p+192, -0x1.0000000000000p+87, 0x1.fffff1ff80000p+667, 0x1.ffffc000fe000p+612, 0x1.007ff8fc3fe00p+860, 0x1.007fdff07f3f4p+805},
+{0x1.0080000000000p+192, -0x1.0000000000000p+87, -0x1.fffff1ff80000p+667, -0x1.ffffc000fe000p+612, -0x1.007ff8fc3fe00p+860, -0x1.007fdff07f3f4p+805},
+{-0x1.0080000000000p+192, 0x1.0000000000000p+87, 0x1.fffff1ff80000p+667, 0x1.ffffc000fe000p+612, -0x1.007ff8fc3fe00p+860, -0x1.007fdff07f3f4p+805},
+{-0x1.0080000000000p+192, 0x1.0000000000000p+87, -0x1.fffff1ff80000p+667, -0x1.ffffc000fe000p+612, 0x1.007ff8fc3fe00p+860, 0x1.007fdff07f3f4p+805},
+{0x1.0400000000000p-301, -0x1.0000000000000p-406, 0x1.7fffe00000008p-283, -0x1.e000080000000p-363, 0x1.85ffdf8000008p-584, 0x1.fffffe187ff70p-640},
+{0x1.0400000000000p-301, -0x1.0000000000000p-406, -0x1.7fffe00000008p-283, 0x1.e000080000000p-363, -0x1.85ffdf8000008p-584, -0x1.fffffe187ff70p-640},
+{-0x1.0400000000000p-301, 0x1.0000000000000p-406, 0x1.7fffe00000008p-283, -0x1.e000080000000p-363, -0x1.85ffdf8000008p-584, -0x1.fffffe187ff70p-640},
+{-0x1.0400000000000p-301, 0x1.0000000000000p-406, -0x1.7fffe00000008p-283, 0x1.e000080000000p-363, 0x1.85ffdf8000008p-584, 0x1.fffffe187ff70p-640},
+{0x1.000001d000000p+298, -0x1.ff80000200000p+243, 0x1.0000003fffffcp+636, 0x1.feffff8000000p+556, 0x1.0000021000003p+934, 0x1.ff19f68008000p+869},
+{0x1.000001d000000p+298, -0x1.ff80000200000p+243, -0x1.0000003fffffcp+636, -0x1.feffff8000000p+556, -0x1.0000021000003p+934, -0x1.ff19f68008000p+869},
+{-0x1.000001d000000p+298, 0x1.ff80000200000p+243, 0x1.0000003fffffcp+636, 0x1.feffff8000000p+556, -0x1.0000021000003p+934, -0x1.ff19f68008000p+869},
+{-0x1.000001d000000p+298, 0x1.ff80000200000p+243, -0x1.0000003fffffcp+636, -0x1.feffff8000000p+556, 0x1.0000021000003p+934, 0x1.ff19f68008000p+869},
+{0x1.001ffffffffc0p+376, 0x1.fffffff03ff00p+315, 0x1.0000010000000p+147, -0x1.fffffff810000p+78, 0x1.002001001ffc0p+523, 0x1.fd7fc1f047e00p+462},
+{0x1.001ffffffffc0p+376, 0x1.fffffff03ff00p+315, -0x1.0000010000000p+147, 0x1.fffffff810000p+78, -0x1.002001001ffc0p+523, -0x1.fd7fc1f047e00p+462},
+{-0x1.001ffffffffc0p+376, -0x1.fffffff03ff00p+315, 0x1.0000010000000p+147, -0x1.fffffff810000p+78, -0x1.002001001ffc0p+523, -0x1.fd7fc1f047e00p+462},
+{-0x1.001ffffffffc0p+376, -0x1.fffffff03ff00p+315, -0x1.0000010000000p+147, 0x1.fffffff810000p+78, 0x1.002001001ffc0p+523, 0x1.fd7fc1f047e00p+462},
+{0x1.00000fffc0001p+666, -0x1.fc000007e0040p+607, 0x1.000007fffffc0p+408, 0x1.fc0003fc00000p+348, INFINITY, 0x0.0000000000000p+0},
+{0x1.00000fffc0001p+666, -0x1.fc000007e0040p+607, -0x1.000007fffffc0p+408, -0x1.fc0003fc00000p+348, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00000fffc0001p+666, 0x1.fc000007e0040p+607, 0x1.000007fffffc0p+408, 0x1.fc0003fc00000p+348, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.00000fffc0001p+666, 0x1.fc000007e0040p+607, -0x1.000007fffffc0p+408, -0x1.fc0003fc00000p+348, INFINITY, 0x0.0000000000000p+0},
+{0x1.01ffe000003fep+235, 0x1.ffffff8000000p+169, 0x1.00fffffe00000p+680, 0x1.ffffffe7ff800p+619, 0x1.0301dfddfc406p+915, -0x1.ec00381c54000p+854},
+{0x1.01ffe000003fep+235, 0x1.ffffff8000000p+169, -0x1.00fffffe00000p+680, -0x1.ffffffe7ff800p+619, -0x1.0301dfddfc406p+915, 0x1.ec00381c54000p+854},
+{-0x1.01ffe000003fep+235, -0x1.ffffff8000000p+169, 0x1.00fffffe00000p+680, 0x1.ffffffe7ff800p+619, -0x1.0301dfddfc406p+915, 0x1.ec00381c54000p+854},
+{-0x1.01ffe000003fep+235, -0x1.ffffff8000000p+169, -0x1.00fffffe00000p+680, -0x1.ffffffe7ff800p+619, 0x1.0301dfddfc406p+915, -0x1.ec00381c54000p+854},
+{0x1.3fffffffffc00p-546, 0x1.ffffffe000000p-609, 0x1.07c0ffc200000p+282, -0x1.e000003bfffe0p+224, 0x1.49b13fb27fbe1p-264, -0x1.a3a2f827f3a30p-321},
+{0x1.3fffffffffc00p-546, 0x1.ffffffe000000p-609, -0x1.07c0ffc200000p+282, 0x1.e000003bfffe0p+224, -0x1.49b13fb27fbe1p-264, 0x1.a3a2f827f3a30p-321},
+{-0x1.3fffffffffc00p-546, -0x1.ffffffe000000p-609, 0x1.07c0ffc200000p+282, -0x1.e000003bfffe0p+224, -0x1.49b13fb27fbe1p-264, 0x1.a3a2f827f3a30p-321},
+{-0x1.3fffffffffc00p-546, -0x1.ffffffe000000p-609, -0x1.07c0ffc200000p+282, 0x1.e000003bfffe0p+224, 0x1.49b13fb27fbe1p-264, -0x1.a3a2f827f3a30p-321},
+{0x1.0000001800000p+988, 0x1.fffffc0000200p+934, 0x1.0000004000000p+36, -0x1.fff0000004000p-31, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000001800000p+988, 0x1.fffffc0000200p+934, -0x1.0000004000000p+36, 0x1.fff0000004000p-31, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000001800000p+988, -0x1.fffffc0000200p+934, 0x1.0000004000000p+36, -0x1.fff0000004000p-31, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000001800000p+988, -0x1.fffffc0000200p+934, -0x1.0000004000000p+36, 0x1.fff0000004000p-31, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000800000000p+726, -0x1.0000000000000p+663, 0x1.0fc007c004000p-506, -0x1.fffe100000000p-570, 0x1.0fc08fa007e00p+220, 0x1.fbe080e080f00p+164},
+{0x1.0000800000000p+726, -0x1.0000000000000p+663, -0x1.0fc007c004000p-506, 0x1.fffe100000000p-570, -0x1.0fc08fa007e00p+220, -0x1.fbe080e080f00p+164},
+{-0x1.0000800000000p+726, 0x1.0000000000000p+663, 0x1.0fc007c004000p-506, -0x1.fffe100000000p-570, -0x1.0fc08fa007e00p+220, -0x1.fbe080e080f00p+164},
+{-0x1.0000800000000p+726, 0x1.0000000000000p+663, -0x1.0fc007c004000p-506, 0x1.fffe100000000p-570, 0x1.0fc08fa007e00p+220, 0x1.fbe080e080f00p+164},
+{0x1.00007fffffe00p-706, 0x1.ffffffc003f00p-767, 0x1.0080000000000p-265, -0x1.0000000000000p-323, 0x1.0080803fffdffp-971, -0x1.7fc1001006c00p-1030},
+{0x1.00007fffffe00p-706, 0x1.ffffffc003f00p-767, -0x1.0080000000000p-265, 0x1.0000000000000p-323, -0x1.0080803fffdffp-971, 0x1.7fc1001006c00p-1030},
+{-0x1.00007fffffe00p-706, -0x1.ffffffc003f00p-767, 0x1.0080000000000p-265, -0x1.0000000000000p-323, -0x1.0080803fffdffp-971, 0x1.7fc1001006c00p-1030},
+{-0x1.00007fffffe00p-706, -0x1.ffffffc003f00p-767, -0x1.0080000000000p-265, 0x1.0000000000000p-323, 0x1.0080803fffdffp-971, -0x1.7fc1001006c00p-1030},
+{0x1.0000200000000p+215, -0x1.0000000000000p+159, 0x1.00000ffffff80p+645, 0x1.ffffff0007ff8p+589, 0x1.0000300001f80p+860, 0x1.fe005e000fcf0p+803},
+{0x1.0000200000000p+215, -0x1.0000000000000p+159, -0x1.00000ffffff80p+645, -0x1.ffffff0007ff8p+589, -0x1.0000300001f80p+860, -0x1.fe005e000fcf0p+803},
+{-0x1.0000200000000p+215, 0x1.0000000000000p+159, 0x1.00000ffffff80p+645, 0x1.ffffff0007ff8p+589, -0x1.0000300001f80p+860, -0x1.fe005e000fcf0p+803},
+{-0x1.0000200000000p+215, 0x1.0000000000000p+159, -0x1.00000ffffff80p+645, -0x1.ffffff0007ff8p+589, 0x1.0000300001f80p+860, 0x1.fe005e000fcf0p+803},
+{0x1.00fe000000000p-121, 0x1.001ffffff0000p-190, 0x1.00007fffff000p+370, 0x0.0000000000000p+0, 0x1.00fe807efeff0p+249, 0x1.00040082003fcp+194},
+{0x1.00fe000000000p-121, 0x1.001ffffff0000p-190, -0x1.00007fffff000p+370, 0x0.0000000000000p+0, -0x1.00fe807efeff0p+249, -0x1.00040082003fcp+194},
+{-0x1.00fe000000000p-121, -0x1.001ffffff0000p-190, 0x1.00007fffff000p+370, 0x0.0000000000000p+0, -0x1.00fe807efeff0p+249, -0x1.00040082003fcp+194},
+{-0x1.00fe000000000p-121, -0x1.001ffffff0000p-190, -0x1.00007fffff000p+370, 0x0.0000000000000p+0, 0x1.00fe807efeff0p+249, 0x1.00040082003fcp+194},
+{0x1.01e0000000002p+273, -0x1.fffffffffc200p+214, 0x1.0000080000000p-103, -0x1.0000000000000p-208, 0x1.01e0080f00002p+170, -0x1.fff80ffffc240p+111},
+{0x1.01e0000000002p+273, -0x1.fffffffffc200p+214, -0x1.0000080000000p-103, 0x1.0000000000000p-208, -0x1.01e0080f00002p+170, 0x1.fff80ffffc240p+111},
+{-0x1.01e0000000002p+273, 0x1.fffffffffc200p+214, 0x1.0000080000000p-103, -0x1.0000000000000p-208, -0x1.01e0080f00002p+170, 0x1.fff80ffffc240p+111},
+{-0x1.01e0000000002p+273, 0x1.fffffffffc200p+214, -0x1.0000080000000p-103, 0x1.0000000000000p-208, 0x1.01e0080f00002p+170, -0x1.fff80ffffc240p+111},
+{0x1.000000f1fe001p-504, -0x1.0000000000000p-587, 0x1.00003fffffff0p-718, 0x1.fc00000000000p-795, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.000000f1fe001p-504, -0x1.0000000000000p-587, -0x1.00003fffffff0p-718, -0x1.fc00000000000p-795, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.000000f1fe001p-504, 0x1.0000000000000p-587, 0x1.00003fffffff0p-718, 0x1.fc00000000000p-795, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.000000f1fe001p-504, 0x1.0000000000000p-587, -0x1.00003fffffff0p-718, -0x1.fc00000000000p-795, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0008000000010p+198, -0x1.f8000ffff9000p+133, 0x1.00001ffff0000p+936, 0x1.ffff80001f000p+879, INFINITY, 0x0.0000000000000p+0},
+{0x1.0008000000010p+198, -0x1.f8000ffff9000p+133, -0x1.00001ffff0000p+936, -0x1.ffff80001f000p+879, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0008000000010p+198, 0x1.f8000ffff9000p+133, 0x1.00001ffff0000p+936, 0x1.ffff80001f000p+879, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0008000000010p+198, 0x1.f8000ffff9000p+133, -0x1.00001ffff0000p+936, -0x1.ffff80001f000p+879, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000100000000p+641, -0x1.0000000000000p+536, 0x1.0038000800000p-759, -0x1.fffffe0000080p-819, 0x1.0038100b80008p-118, -0x1.00000efffff80p-177},
+{0x1.0000100000000p+641, -0x1.0000000000000p+536, -0x1.0038000800000p-759, 0x1.fffffe0000080p-819, -0x1.0038100b80008p-118, 0x1.00000efffff80p-177},
+{-0x1.0000100000000p+641, 0x1.0000000000000p+536, 0x1.0038000800000p-759, -0x1.fffffe0000080p-819, -0x1.0038100b80008p-118, 0x1.00000efffff80p-177},
+{-0x1.0000100000000p+641, 0x1.0000000000000p+536, -0x1.0038000800000p-759, 0x1.fffffe0000080p-819, 0x1.0038100b80008p-118, -0x1.00000efffff80p-177},
+{0x1.00003fe008000p-579, -0x1.fffdff0000080p-638, 0x1.ffffffffff800p-344, 0x1.fe00000000000p-442, 0x1.00003fe007c00p-922, -0x1.3fdf077ffec60p-980},
+{0x1.00003fe008000p-579, -0x1.fffdff0000080p-638, -0x1.ffffffffff800p-344, -0x1.fe00000000000p-442, -0x1.00003fe007c00p-922, 0x1.3fdf077ffec60p-980},
+{-0x1.00003fe008000p-579, 0x1.fffdff0000080p-638, 0x1.ffffffffff800p-344, 0x1.fe00000000000p-442, -0x1.00003fe007c00p-922, 0x1.3fdf077ffec60p-980},
+{-0x1.00003fe008000p-579, 0x1.fffdff0000080p-638, -0x1.ffffffffff800p-344, -0x1.fe00000000000p-442, 0x1.00003fe007c00p-922, -0x1.3fdf077ffec60p-980},
+{0x1.1fffffff00000p-455, 0x1.ffffff8000000p-527, 0x1.0000100000000p+435, -0x1.0000000000000p+341, 0x1.200011fefffffp-20, 0x1.00000d8000000p-91},
+{0x1.1fffffff00000p-455, 0x1.ffffff8000000p-527, -0x1.0000100000000p+435, 0x1.0000000000000p+341, -0x1.200011fefffffp-20, -0x1.00000d8000000p-91},
+{-0x1.1fffffff00000p-455, -0x1.ffffff8000000p-527, 0x1.0000100000000p+435, -0x1.0000000000000p+341, -0x1.200011fefffffp-20, -0x1.00000d8000000p-91},
+{-0x1.1fffffff00000p-455, -0x1.ffffff8000000p-527, -0x1.0000100000000p+435, 0x1.0000000000000p+341, 0x1.200011fefffffp-20, 0x1.00000d8000000p-91},
+{0x1.0ffffc0000010p+917, 0x1.f000000ff0000p+848, 0x1.00003ff002010p+155, -0x1.0000020000000p+90, INFINITY, 0x0.0000000000000p+0},
+{0x1.0ffffc0000010p+917, 0x1.f000000ff0000p+848, -0x1.00003ff002010p+155, 0x1.0000020000000p+90, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0ffffc0000010p+917, -0x1.f000000ff0000p+848, 0x1.00003ff002010p+155, -0x1.0000020000000p+90, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0ffffc0000010p+917, -0x1.f000000ff0000p+848, -0x1.00003ff002010p+155, 0x1.0000020000000p+90, INFINITY, 0x0.0000000000000p+0},
+{0x1.00ffffffc0000p+784, 0x1.fffffe00003f0p+729, 0x1.1fffffffff020p-125, -0x1.ffff000400000p-200, 0x1.211fffffb7010p+659, 0x1.9ffffeb0072d6p+605},
+{0x1.00ffffffc0000p+784, 0x1.fffffe00003f0p+729, -0x1.1fffffffff020p-125, 0x1.ffff000400000p-200, -0x1.211fffffb7010p+659, -0x1.9ffffeb0072d6p+605},
+{-0x1.00ffffffc0000p+784, -0x1.fffffe00003f0p+729, 0x1.1fffffffff020p-125, -0x1.ffff000400000p-200, -0x1.211fffffb7010p+659, -0x1.9ffffeb0072d6p+605},
+{-0x1.00ffffffc0000p+784, -0x1.fffffe00003f0p+729, -0x1.1fffffffff020p-125, 0x1.ffff000400000p-200, 0x1.211fffffb7010p+659, 0x1.9ffffeb0072d6p+605},
+{0x1.0200000000000p+902, -0x1.0000000000000p+849, 0x1.0000700000000p-969, 0x1.ffffffe000000p-1040, 0x1.020070e000000p-67, -0x1.ffffde0000102p-121},
+{0x1.0200000000000p+902, -0x1.0000000000000p+849, -0x1.0000700000000p-969, -0x1.ffffffe000000p-1040, -0x1.020070e000000p-67, 0x1.ffffde0000102p-121},
+{-0x1.0200000000000p+902, 0x1.0000000000000p+849, 0x1.0000700000000p-969, 0x1.ffffffe000000p-1040, -0x1.020070e000000p-67, 0x1.ffffde0000102p-121},
+{-0x1.0200000000000p+902, 0x1.0000000000000p+849, -0x1.0000700000000p-969, -0x1.ffffffe000000p-1040, 0x1.020070e000000p-67, -0x1.ffffde0000102p-121},
+{0x1.3fffffc0001fcp+335, 0x1.007fffff00000p+272, 0x1.007fffff80000p+3, 0x1.fffffffe00000p-65, 0x1.409fffbf401fdp+338, 0x1.14f84ffa6b400p+275},
+{0x1.3fffffc0001fcp+335, 0x1.007fffff00000p+272, -0x1.007fffff80000p+3, -0x1.fffffffe00000p-65, -0x1.409fffbf401fdp+338, -0x1.14f84ffa6b400p+275},
+{-0x1.3fffffc0001fcp+335, -0x1.007fffff00000p+272, 0x1.007fffff80000p+3, 0x1.fffffffe00000p-65, -0x1.409fffbf401fdp+338, -0x1.14f84ffa6b400p+275},
+{-0x1.3fffffc0001fcp+335, -0x1.007fffff00000p+272, -0x1.007fffff80000p+3, -0x1.fffffffe00000p-65, 0x1.409fffbf401fdp+338, 0x1.14f84ffa6b400p+275},
+{0x1.00000ffffffd0p+189, -0x1.ffffff8200000p+123, 0x1.00000c0000004p-197, -0x1.ff80000800000p-265, 0x1.00001c0000bd4p-8, -0x1.7ff00fc280000p-73},
+{0x1.00000ffffffd0p+189, -0x1.ffffff8200000p+123, -0x1.00000c0000004p-197, 0x1.ff80000800000p-265, -0x1.00001c0000bd4p-8, 0x1.7ff00fc280000p-73},
+{-0x1.00000ffffffd0p+189, 0x1.ffffff8200000p+123, 0x1.00000c0000004p-197, -0x1.ff80000800000p-265, -0x1.00001c0000bd4p-8, 0x1.7ff00fc280000p-73},
+{-0x1.00000ffffffd0p+189, 0x1.ffffff8200000p+123, -0x1.00000c0000004p-197, 0x1.ff80000800000p-265, 0x1.00001c0000bd4p-8, -0x1.7ff00fc280000p-73},
+{0x1.18003ffff8000p+281, 0x1.ffffff8000000p+215, 0x1.1ffff80000040p-329, -0x1.0000000000000p-419, 0x1.3b003f3ff5046p-48, 0x1.063fff6e58000p-106},
+{0x1.18003ffff8000p+281, 0x1.ffffff8000000p+215, -0x1.1ffff80000040p-329, 0x1.0000000000000p-419, -0x1.3b003f3ff5046p-48, -0x1.063fff6e58000p-106},
+{-0x1.18003ffff8000p+281, -0x1.ffffff8000000p+215, 0x1.1ffff80000040p-329, -0x1.0000000000000p-419, -0x1.3b003f3ff5046p-48, -0x1.063fff6e58000p-106},
+{-0x1.18003ffff8000p+281, -0x1.ffffff8000000p+215, -0x1.1ffff80000040p-329, 0x1.0000000000000p-419, 0x1.3b003f3ff5046p-48, 0x1.063fff6e58000p-106},
+{0x1.0ffffff9ffff0p+735, 0x1.f800008200000p+665, 0x1.000000ffffff8p+876, 0x1.ff0000007ffc0p+817, INFINITY, 0x0.0000000000000p+0},
+{0x1.0ffffff9ffff0p+735, 0x1.f800008200000p+665, -0x1.000000ffffff8p+876, -0x1.ff0000007ffc0p+817, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0ffffff9ffff0p+735, -0x1.f800008200000p+665, 0x1.000000ffffff8p+876, 0x1.ff0000007ffc0p+817, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0ffffff9ffff0p+735, -0x1.f800008200000p+665, -0x1.000000ffffff8p+876, -0x1.ff0000007ffc0p+817, INFINITY, 0x0.0000000000000p+0},
+{0x1.1fffffe000000p-807, 0x1.ffff800001ffep-861, 0x1.0000008000000p+287, -0x1.fffffc0000008p+231, 0x1.2000006ffffffp-520, 0x1.6fff823001bfap-574},
+{0x1.1fffffe000000p-807, 0x1.ffff800001ffep-861, -0x1.0000008000000p+287, 0x1.fffffc0000008p+231, -0x1.2000006ffffffp-520, -0x1.6fff823001bfap-574},
+{-0x1.1fffffe000000p-807, -0x1.ffff800001ffep-861, 0x1.0000008000000p+287, -0x1.fffffc0000008p+231, -0x1.2000006ffffffp-520, -0x1.6fff823001bfap-574},
+{-0x1.1fffffe000000p-807, -0x1.ffff800001ffep-861, -0x1.0000008000000p+287, 0x1.fffffc0000008p+231, 0x1.2000006ffffffp-520, 0x1.6fff823001bfap-574},
+{0x1.0000200000000p-310, -0x1.fffffff804000p-377, 0x1.0000080000000p+614, -0x1.0000000000000p+519, 0x1.0000280001000p+304, -0x1.0000080402000p+238},
+{0x1.0000200000000p-310, -0x1.fffffff804000p-377, -0x1.0000080000000p+614, 0x1.0000000000000p+519, -0x1.0000280001000p+304, 0x1.0000080402000p+238},
+{-0x1.0000200000000p-310, 0x1.fffffff804000p-377, 0x1.0000080000000p+614, -0x1.0000000000000p+519, -0x1.0000280001000p+304, 0x1.0000080402000p+238},
+{-0x1.0000200000000p-310, 0x1.fffffff804000p-377, -0x1.0000080000000p+614, 0x1.0000000000000p+519, 0x1.0000280001000p+304, -0x1.0000080402000p+238},
+{0x1.03ffff0000010p-506, -0x1.fffc010000000p-582, 0x1.0000020000000p+657, -0x1.0000000000000p+552, 0x1.04000107ffff0p+151, 0x1.e0003faf80000p+79},
+{0x1.03ffff0000010p-506, -0x1.fffc010000000p-582, -0x1.0000020000000p+657, 0x1.0000000000000p+552, -0x1.04000107ffff0p+151, -0x1.e0003faf80000p+79},
+{-0x1.03ffff0000010p-506, 0x1.fffc010000000p-582, 0x1.0000020000000p+657, -0x1.0000000000000p+552, -0x1.04000107ffff0p+151, -0x1.e0003faf80000p+79},
+{-0x1.03ffff0000010p-506, 0x1.fffc010000000p-582, -0x1.0000020000000p+657, 0x1.0000000000000p+552, 0x1.04000107ffff0p+151, 0x1.e0003faf80000p+79},
+{0x1.7ffffffc00000p-455, 0x1.fff80000fc000p-516, 0x1.0010000000000p+908, -0x1.ffffffffc4000p+841, 0x1.8017fffbffc00p+453, 0x1.f417ff811d700p+392},
+{0x1.7ffffffc00000p-455, 0x1.fff80000fc000p-516, -0x1.0010000000000p+908, 0x1.ffffffffc4000p+841, -0x1.8017fffbffc00p+453, -0x1.f417ff811d700p+392},
+{-0x1.7ffffffc00000p-455, -0x1.fff80000fc000p-516, 0x1.0010000000000p+908, -0x1.ffffffffc4000p+841, -0x1.8017fffbffc00p+453, -0x1.f417ff811d700p+392},
+{-0x1.7ffffffc00000p-455, -0x1.fff80000fc000p-516, -0x1.0010000000000p+908, 0x1.ffffffffc4000p+841, 0x1.8017fffbffc00p+453, 0x1.f417ff811d700p+392},
+{0x1.000007fffc004p-48, -0x1.8000004000000p-107, 0x1.7fe000001ff00p+482, 0x1.f000000000000p+381, 0x1.7fe00bff19f0ep+434, 0x1.5f0b0077ee250p+377},
+{0x1.000007fffc004p-48, -0x1.8000004000000p-107, -0x1.7fe000001ff00p+482, -0x1.f000000000000p+381, -0x1.7fe00bff19f0ep+434, -0x1.5f0b0077ee250p+377},
+{-0x1.000007fffc004p-48, 0x1.8000004000000p-107, 0x1.7fe000001ff00p+482, 0x1.f000000000000p+381, -0x1.7fe00bff19f0ep+434, -0x1.5f0b0077ee250p+377},
+{-0x1.000007fffc004p-48, 0x1.8000004000000p-107, -0x1.7fe000001ff00p+482, -0x1.f000000000000p+381, 0x1.7fe00bff19f0ep+434, 0x1.5f0b0077ee250p+377},
+{0x1.01ffffffffc00p-235, 0x0.0000000000000p+0, 0x1.0ffffff000000p-5, 0x1.fffffff000000p-75, 0x1.121fffefdfbc0p-240, 0x1.81fffff7f0000p-309},
+{0x1.01ffffffffc00p-235, 0x0.0000000000000p+0, -0x1.0ffffff000000p-5, -0x1.fffffff000000p-75, -0x1.121fffefdfbc0p-240, -0x1.81fffff7f0000p-309},
+{-0x1.01ffffffffc00p-235, 0x0.0000000000000p+0, 0x1.0ffffff000000p-5, 0x1.fffffff000000p-75, -0x1.121fffefdfbc0p-240, -0x1.81fffff7f0000p-309},
+{-0x1.01ffffffffc00p-235, 0x0.0000000000000p+0, -0x1.0ffffff000000p-5, -0x1.fffffff000000p-75, 0x1.121fffefdfbc0p-240, 0x1.81fffff7f0000p-309},
+{0x1.0000010000000p-572, -0x1.ffffffffe4000p-634, 0x1.0000020000000p-195, -0x1.ff80000100000p-268, 0x1.0000030000020p-767, -0x1.001ffa0012000p-828},
+{0x1.0000010000000p-572, -0x1.ffffffffe4000p-634, -0x1.0000020000000p-195, 0x1.ff80000100000p-268, -0x1.0000030000020p-767, 0x1.001ffa0012000p-828},
+{-0x1.0000010000000p-572, 0x1.ffffffffe4000p-634, 0x1.0000020000000p-195, -0x1.ff80000100000p-268, -0x1.0000030000020p-767, 0x1.001ffa0012000p-828},
+{-0x1.0000010000000p-572, 0x1.ffffffffe4000p-634, -0x1.0000020000000p-195, 0x1.ff80000100000p-268, 0x1.0000030000020p-767, -0x1.001ffa0012000p-828},
+{0x1.0008000000000p+139, -0x1.0000000000000p+34, 0x1.000fffff80000p+540, 0x1.fffffffc00000p+484, 0x1.0018007f7ffc0p+679, 0x1.0007fffdffefcp+624},
+{0x1.0008000000000p+139, -0x1.0000000000000p+34, -0x1.000fffff80000p+540, -0x1.fffffffc00000p+484, -0x1.0018007f7ffc0p+679, -0x1.0007fffdffefcp+624},
+{-0x1.0008000000000p+139, 0x1.0000000000000p+34, 0x1.000fffff80000p+540, 0x1.fffffffc00000p+484, -0x1.0018007f7ffc0p+679, -0x1.0007fffdffefcp+624},
+{-0x1.0008000000000p+139, 0x1.0000000000000p+34, -0x1.000fffff80000p+540, -0x1.fffffffc00000p+484, 0x1.0018007f7ffc0p+679, 0x1.0007fffdffefcp+624},
+{0x1.007fffffffc00p+663, 0x1.ffffc00000000p+598, 0x1.1ffffffff8000p-133, 0x1.fe001ffffffe0p-189, 0x1.208ffffff7b40p+530, 0x1.000f90f5ffbb4p+475},
+{0x1.007fffffffc00p+663, 0x1.ffffc00000000p+598, -0x1.1ffffffff8000p-133, -0x1.fe001ffffffe0p-189, -0x1.208ffffff7b40p+530, -0x1.000f90f5ffbb4p+475},
+{-0x1.007fffffffc00p+663, -0x1.ffffc00000000p+598, 0x1.1ffffffff8000p-133, 0x1.fe001ffffffe0p-189, -0x1.208ffffff7b40p+530, -0x1.000f90f5ffbb4p+475},
+{-0x1.007fffffffc00p+663, -0x1.ffffc00000000p+598, -0x1.1ffffffff8000p-133, -0x1.fe001ffffffe0p-189, 0x1.208ffffff7b40p+530, 0x1.000f90f5ffbb4p+475},
+{0x1.0000000fffe00p-673, 0x1.3fffff87fc000p-733, 0x1.00003ffffc000p-1010, 0x1.0000000000000p-1074, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000000fffe00p-673, 0x1.3fffff87fc000p-733, -0x1.00003ffffc000p-1010, -0x1.0000000000000p-1074, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000fffe00p-673, -0x1.3fffff87fc000p-733, 0x1.00003ffffc000p-1010, 0x1.0000000000000p-1074, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.0000000fffe00p-673, -0x1.3fffff87fc000p-733, -0x1.00003ffffc000p-1010, -0x1.0000000000000p-1074, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.0000000800000p+490, -0x1.0000000000000p+385, 0x1.7ffff80000000p+812, 0x1.ffffffffe0000p+756, INFINITY, 0x0.0000000000000p+0},
+{0x1.0000000800000p+490, -0x1.0000000000000p+385, -0x1.7ffff80000000p+812, -0x1.ffffffffe0000p+756, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000000800000p+490, 0x1.0000000000000p+385, 0x1.7ffff80000000p+812, 0x1.ffffffffe0000p+756, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0000000800000p+490, 0x1.0000000000000p+385, -0x1.7ffff80000000p+812, -0x1.ffffffffe0000p+756, INFINITY, 0x0.0000000000000p+0},
+{0x1.00fffffff8000p-776, 0x1.fffe000000000p-850, 0x1.0000100000000p+556, -0x1.fffffffffc100p+501, 0x1.0100100ff8000p-220, -0x1.20ffe00014060p-274},
+{0x1.00fffffff8000p-776, 0x1.fffe000000000p-850, -0x1.0000100000000p+556, 0x1.fffffffffc100p+501, -0x1.0100100ff8000p-220, 0x1.20ffe00014060p-274},
+{-0x1.00fffffff8000p-776, -0x1.fffe000000000p-850, 0x1.0000100000000p+556, -0x1.fffffffffc100p+501, -0x1.0100100ff8000p-220, 0x1.20ffe00014060p-274},
+{-0x1.00fffffff8000p-776, -0x1.fffe000000000p-850, -0x1.0000100000000p+556, 0x1.fffffffffc100p+501, 0x1.0100100ff8000p-220, -0x1.20ffe00014060p-274},
+{0x1.0007ffffffff0p+441, 0x1.fffffc0000000p+358, 0x1.0003800000080p+407, -0x1.0000000000000p+302, 0x1.000b801c00070p+848, 0x1.e40001ffc6f80p+789},
+{0x1.0007ffffffff0p+441, 0x1.fffffc0000000p+358, -0x1.0003800000080p+407, 0x1.0000000000000p+302, -0x1.000b801c00070p+848, -0x1.e40001ffc6f80p+789},
+{-0x1.0007ffffffff0p+441, -0x1.fffffc0000000p+358, 0x1.0003800000080p+407, -0x1.0000000000000p+302, -0x1.000b801c00070p+848, -0x1.e40001ffc6f80p+789},
+{-0x1.0007ffffffff0p+441, -0x1.fffffc0000000p+358, -0x1.0003800000080p+407, 0x1.0000000000000p+302, 0x1.000b801c00070p+848, 0x1.e40001ffc6f80p+789},
+{0x1.000001fffff80p-397, 0x1.ff00000000000p-481, 0x1.0000020000000p+10, -0x1.8002000000000p-66, 0x1.000003fffffc0p-387, -0x1.017e030300000p-455},
+{0x1.000001fffff80p-397, 0x1.ff00000000000p-481, -0x1.0000020000000p+10, 0x1.8002000000000p-66, -0x1.000003fffffc0p-387, 0x1.017e030300000p-455},
+{-0x1.000001fffff80p-397, -0x1.ff00000000000p-481, 0x1.0000020000000p+10, -0x1.8002000000000p-66, -0x1.000003fffffc0p-387, 0x1.017e030300000p-455},
+{-0x1.000001fffff80p-397, -0x1.ff00000000000p-481, -0x1.0000020000000p+10, 0x1.8002000000000p-66, 0x1.000003fffffc0p-387, -0x1.017e030300000p-455},
+{0x1.0003fffff0000p+165, 0x1.ffff800007f80p+105, 0x1.000007ffffe00p+981, -0x1.fe0c000004000p+923, INFINITY, 0x0.0000000000000p+0},
+{0x1.0003fffff0000p+165, 0x1.ffff800007f80p+105, -0x1.000007ffffe00p+981, 0x1.fe0c000004000p+923, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0003fffff0000p+165, -0x1.ffff800007f80p+105, 0x1.000007ffffe00p+981, -0x1.fe0c000004000p+923, -INFINITY, 0x0.0000000000000p+0},
+{-0x1.0003fffff0000p+165, -0x1.ffff800007f80p+105, -0x1.000007ffffe00p+981, 0x1.fe0c000004000p+923, INFINITY, 0x0.0000000000000p+0},
+{0x1.00000003f0000p+687, 0x1.ffffffe000000p+609, 0x1.0100000000000p-215, -0x1.fffffff000080p-275, 0x1.01000003f3f00p+472, -0x1.ffff7f77e0100p+412},
+{0x1.00000003f0000p+687, 0x1.ffffffe000000p+609, -0x1.0100000000000p-215, 0x1.fffffff000080p-275, -0x1.01000003f3f00p+472, 0x1.ffff7f77e0100p+412},
+{-0x1.00000003f0000p+687, -0x1.ffffffe000000p+609, 0x1.0100000000000p-215, -0x1.fffffff000080p-275, -0x1.01000003f3f00p+472, 0x1.ffff7f77e0100p+412},
+{-0x1.00000003f0000p+687, -0x1.ffffffe000000p+609, -0x1.0100000000000p-215, 0x1.fffffff000080p-275, 0x1.01000003f3f00p+472, -0x1.ffff7f77e0100p+412},
+{0x1.007fffffffc00p-448, 0x1.fffffe0000000p-530, 0x1.0000003fffff8p-643, 0x1.fffff80000000p-714, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.007fffffffc00p-448, 0x1.fffffe0000000p-530, -0x1.0000003fffff8p-643, -0x1.fffff80000000p-714, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.007fffffffc00p-448, -0x1.fffffe0000000p-530, 0x1.0000003fffff8p-643, 0x1.fffff80000000p-714, -0x0.0000000000000p+0, -0x0.0000000000000p+0},
+{-0x1.007fffffffc00p-448, -0x1.fffffe0000000p-530, -0x1.0000003fffff8p-643, -0x1.fffff80000000p-714, 0x0.0000000000000p+0, 0x0.0000000000000p+0},
+{0x1.00000003ff000p-711, 0x1.ffffff0000000p-773, 0x1.0000ffff80000p+16, 0x1.e0000000fffc0p-43, 0x1.000100037f040p-695, -0x1.7bfef005e8810p-752},
+{0x1.00000003ff000p-711, 0x1.ffffff0000000p-773, -0x1.0000ffff80000p+16, -0x1.e0000000fffc0p-43, -0x1.000100037f040p-695, 0x1.7bfef005e8810p-752},
+{-0x1.00000003ff000p-711, -0x1.ffffff0000000p-773, 0x1.0000ffff80000p+16, 0x1.e0000000fffc0p-43, -0x1.000100037f040p-695, 0x1.7bfef005e8810p-752},
+{-0x1.00000003ff000p-711, -0x1.ffffff0000000p-773, -0x1.0000ffff80000p+16, -0x1.e0000000fffc0p-43, 0x1.000100037f040p-695, -0x1.7bfef005e8810p-752},
+{0x1.007ffffffc000p-157, 0x1.ffffff8000000p-224, 0x1.0003fffffffe0p-88, 0x1.fffffff000780p-148, 0x1.008401fffbfdfp-245, -0x1.bf5ffdf221f10p-302},
+{0x1.007ffffffc000p-157, 0x1.ffffff8000000p-224, -0x1.0003fffffffe0p-88, -0x1.fffffff000780p-148, -0x1.008401fffbfdfp-245, 0x1.bf5ffdf221f10p-302},
+{-0x1.007ffffffc000p-157, -0x1.ffffff8000000p-224, 0x1.0003fffffffe0p-88, 0x1.fffffff000780p-148, -0x1.008401fffbfdfp-245, 0x1.bf5ffdf221f10p-302},
+{-0x1.007ffffffc000p-157, -0x1.ffffff8000000p-224, -0x1.0003fffffffe0p-88, -0x1.fffffff000780p-148, 0x1.008401fffbfdfp-245, -0x1.bf5ffdf221f10p-302},
+{0x1.07fffffe0003cp-432, 0x1.ffe000007f000p-497, 0x1.1ffff00800000p+307, -0x1.0000000000000p+210, 0x1.28ffef8600045p-125, 0x1.fc3902fc0230cp-179},
+{0x1.07fffffe0003cp-432, 0x1.ffe000007f000p-497, -0x1.1ffff00800000p+307, 0x1.0000000000000p+210, -0x1.28ffef8600045p-125, -0x1.fc3902fc0230cp-179},
+{-0x1.07fffffe0003cp-432, -0x1.ffe000007f000p-497, 0x1.1ffff00800000p+307, -0x1.0000000000000p+210, -0x1.28ffef8600045p-125, -0x1.fc3902fc0230cp-179},
+{-0x1.07fffffe0003cp-432, -0x1.ffe000007f000p-497, -0x1.1ffff00800000p+307, 0x1.0000000000000p+210, 0x1.28ffef8600045p-125, 0x1.fc3902fc0230cp-179},
+{0x1.000003fff8000p+711, 0x1.ffff00000003cp+656, 0x1.000001ffff020p+18, -0x1.fff0000200000p-52, 0x1.000005fff70a0p+729, 0x1.f5ff0817ec048p+674},
+{0x1.000003fff8000p+711, 0x1.ffff00000003cp+656, -0x1.000001ffff020p+18, 0x1.fff0000200000p-52, -0x1.000005fff70a0p+729, -0x1.f5ff0817ec048p+674},
+{-0x1.000003fff8000p+711, -0x1.ffff00000003cp+656, 0x1.000001ffff020p+18, -0x1.fff0000200000p-52, -0x1.000005fff70a0p+729, -0x1.f5ff0817ec048p+674},
+{-0x1.000003fff8000p+711, -0x1.ffff00000003cp+656, -0x1.000001ffff020p+18, 0x1.fff0000200000p-52, 0x1.000005fff70a0p+729, 0x1.f5ff0817ec048p+674},
+{0x1.00ffe00000000p-302, 0x1.fe00000000000p-362, 0x1.0000100000000p+87, -0x1.ffff800010000p+18, 0x1.00fff00ffe000p-215, 0x1.fcff20403ff00p-275},
+{0x1.00ffe00000000p-302, 0x1.fe00000000000p-362, -0x1.0000100000000p+87, 0x1.ffff800010000p+18, -0x1.00fff00ffe000p-215, -0x1.fcff20403ff00p-275},
+{-0x1.00ffe00000000p-302, -0x1.fe00000000000p-362, 0x1.0000100000000p+87, -0x1.ffff800010000p+18, -0x1.00fff00ffe000p-215, -0x1.fcff20403ff00p-275},
+{-0x1.00ffe00000000p-302, -0x1.fe00000000000p-362, -0x1.0000100000000p+87, 0x1.ffff800010000p+18, 0x1.00fff00ffe000p-215, 0x1.fcff20403ff00p-275},
+{0x1.fffffff000008p+565, -0x1.ffffff1000000p+488, 0x1.0001fffffff80p-162, 0x1.fffe000000000p-247, 0x1.0001fff7ffe84p+404, 0x1.00701fdbe7000p+339},
+{0x1.fffffff000008p+565, -0x1.ffffff1000000p+488, -0x1.0001fffffff80p-162, -0x1.fffe000000000p-247, -0x1.0001fff7ffe84p+404, -0x1.00701fdbe7000p+339},
+{-0x1.fffffff000008p+565, 0x1.ffffff1000000p+488, 0x1.0001fffffff80p-162, 0x1.fffe000000000p-247, -0x1.0001fff7ffe84p+404, -0x1.00701fdbe7000p+339},
+{-0x1.fffffff000008p+565, 0x1.ffffff1000000p+488, -0x1.0001fffffff80p-162, -0x1.fffe000000000p-247, 0x1.0001fff7ffe84p+404, 0x1.00701fdbe7000p+339},
+};
+
+const int numAccuracyTests = sizeof(accuracyTests) / sizeof(struct testVector);
+
+#include <math.h>
+
+double testAccuracy() {
+	int i;
+	DD a, b, c, r;
+	
+	double worstUlps = 0.5;
+	
+	for (i=0; i<numAccuracyTests; ++i) {
+		a.hi = accuracyTests[i].xhi;
+		a.lo = accuracyTests[i].xlo;
+		b.hi = accuracyTests[i].yhi;
+		b.lo = accuracyTests[i].ylo;
+		r.hi = accuracyTests[i].rhi;
+		r.lo = accuracyTests[i].rlo;
+		
+		DD c = { .ld = __gcc_qmul(a.ld, b.ld) };
+		
+		double error = __builtin_fabs(((r.hi - c.hi) + r.lo) - c.lo);
+		
+		if (error != 0.0) {
+		
+			int exponent = ilogb(r.hi);
+			exponent = (exponent < -1022 ? -1022 : exponent);
+			double ulpError = scalbn(error, 106 - exponent);
+		
+			if (ulpError > worstUlps) {
+#ifdef PRINT_ACCURACY_INFORMATION
+				printf("New worst rounding error for (%a,%a) x (%a,%a):\n", a.hi, a.lo, b.hi, b.lo);
+				printf("\tExpected: (%a,%a)\n", r.hi, r.lo);
+				printf("\tComputed: (%a,%a)\n", c.hi, c.lo);
+				printf("\tError: %f ulps\n", ulpError);
+#endif
+				worstUlps = ulpError;
+			}
+		}
+	}
+	
+	return worstUlps;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/compiler-rt/test/builtins/Unit/ppc/qsub_test.c b/compiler-rt/test/builtins/Unit/ppc/qsub_test.c
new file mode 100644
index 0000000..43bc7f4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/qsub_test.c
@@ -0,0 +1,1874 @@
+#include <stdio.h>
+#include "DD.h"
+
+long double __gcc_qsub(long double x, long double y);
+
+double testAccuracy();
+int testEdgeCases();
+
+int main(int argc, char *argv[]) {
+	if (testEdgeCases())
+		return 1;
+	
+	if (testAccuracy() > 1.0)
+		return 1;
+	
+	return 0;
+}
+
+struct testVector {
+	double xhi; double xlo;
+	double yhi; double ylo;
+	double rhi; double rlo;
+};
+
+#define INFINITY __builtin_inf()
+#define HUGE 0x1.fffffffffffffp1023
+#define QNAN __builtin_nan("")
+
+const struct testVector edgeCases[] = {
+{	0.0,		0.0,	   -0.0,		0.0,		0.0,		0.0			},
+{  -0.0,		0.0,	   -0.0,		0.0,		0.0,		0.0			},
+{   0.0,		0.0,	    0.0,		0.0,		0.0,		0.0			},
+{  -0.0,		0.0,	    0.0,		0.0,	   -0.0,		0.0			},
+
+{   INFINITY,	0.0,	   -0.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -0.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	    0.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    0.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -1.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -1.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	    1.0,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    1.0,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -HUGE,		0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -HUGE,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	    HUGE,		0.0,	    INFINITY,	0.0			},
+{  -INFINITY,	0.0,	    HUGE,		0.0,	   -INFINITY,	0.0			},
+{   INFINITY,	0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{  -INFINITY,	0.0,	   -INFINITY,	0.0,		QNAN,		0.0			},
+{   INFINITY,	0.0,	    INFINITY,	0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   0.0,		0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{   0.0,		0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -0.0,		0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{  -0.0,		0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   1.0,		0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{   1.0,		0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -1.0,		0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{  -1.0,		0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{   HUGE,		0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{   HUGE,		0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+{  -HUGE,		0.0,	   -INFINITY,	0.0,		INFINITY,	0.0			},
+{  -HUGE,		0.0,	    INFINITY,	0.0,	   -INFINITY,	0.0			},
+
+{   QNAN,		0.0,	   -0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	    0.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    0.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	    1.0,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    1.0,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	    HUGE,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    HUGE,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	    INFINITY,	0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    INFINITY,	0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	   -QNAN,		0.0,	    QNAN,		0.0			},
+{   QNAN,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{  -QNAN,		0.0,	    QNAN,		0.0,	    QNAN,		0.0			},
+{	0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	0.0,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -0.0,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	1.0,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -1.0,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	HUGE,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -HUGE,		0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{	INFINITY,	0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	   -QNAN,		0.0,		QNAN,		0.0			},
+{  -INFINITY,	0.0,	    QNAN,		0.0,		QNAN,		0.0			},
+};
+
+const int numEdgeCases = sizeof(edgeCases) / sizeof(struct testVector);
+
+
+int testEdgeCases() {
+	int i;
+	DD a, b, c, r;
+	for (i=0; i<numEdgeCases; ++i) {
+		a.hi = edgeCases[i].xhi;
+		a.lo = edgeCases[i].xlo;
+		b.hi = edgeCases[i].yhi;
+		b.lo = edgeCases[i].ylo;
+		r.hi = edgeCases[i].rhi;
+		r.lo = edgeCases[i].rlo;
+		
+		int error;
+		
+		long double computed = __gcc_qsub(a.ld, b.ld);
+		
+		DD c = { .ld = computed };
+		
+		if (r.hi != r.hi) {
+			if (c.hi == c.hi)
+				error = 1;
+			else if (c.lo != 0.0)
+				error = 1;
+			else
+				error = 0;
+		}
+
+		else if (r.hi == 0.0)
+			error = memcmp(&c, &r, sizeof(DD));
+		
+		else
+			error = ((c.hi != r.hi) || (c.lo != r.lo));
+		
+		if (error) {
+			printf("Error on edge case %a - %a: expected (%a, %a), got (%a, %a).\n", a.hi, b.hi, r.hi, r.lo, c.hi, c.lo);
+			return 1;
+		}
+	}
+	
+	return 0;
+}
+
+
+/*
+
+ Code for generating the test cases, requires the mpfr package to run.
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <mpfr.h>
+ 
+ #ifdef __x86_64__
+ #define randlength 2
+ #else
+ #define randlength 4
+ #endif
+ 
+ 
+ int main(int argc, char *argv[]) {
+ 
+ MPFR_DECL_INIT(a, 106);
+ MPFR_DECL_INIT(b, 106);
+ MPFR_DECL_INIT(c, 106);
+ 
+ MPFR_DECL_INIT(tmp, 53);
+ 
+ int exponent_range = atoi(argv[1]);
+ 
+ int i;
+ for (i=0; i<128; ++i) {
+ mpfr_random2(a, randlength, exponent_range);
+ mpfr_random2(b, randlength, exponent_range);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ double ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ double alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ double bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ double blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ double chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ double clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ 
+ mpfr_neg(a, a, GMP_RNDN);
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ 
+ mpfr_neg(b, b, GMP_RNDN);
+ mpfr_add(c, a, b, GMP_RNDN);
+ 
+ ahi = mpfr_get_d(a, GMP_RNDN);
+ mpfr_set_d(tmp, ahi, GMP_RNDN);
+ mpfr_sub(tmp, a, tmp, GMP_RNDN);
+ alo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("{%0.13a, %0.13a, ", ahi, alo);
+ 
+ bhi = mpfr_get_d(b, GMP_RNDN);
+ mpfr_set_d(tmp, bhi, GMP_RNDN);
+ mpfr_sub(tmp, b, tmp, GMP_RNDN);
+ blo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a, ", bhi, blo);
+ 
+ chi = mpfr_get_d(c, GMP_RNDN);
+ mpfr_set_d(tmp, chi, GMP_RNDN);
+ mpfr_sub(tmp, c, tmp, GMP_RNDN);
+ clo = mpfr_get_d(tmp, GMP_RNDN);
+ printf("%0.13a, %0.13a},\n", chi, clo);
+ }
+ 
+ return 0;
+ }
+
+
+ */
+
+const struct testVector accuracyTests[] = {
+// Some test cases that cover the whole exponent range:
+{0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302, 0x1.0003ffffffffcp+140, 0x1.ffffc00000000p+53, 0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302},
+{0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302, -0x1.0003ffffffffcp+140, -0x1.ffffc00000000p+53, 0x1.0000000000002p+366, -0x1.ffc0ffff90000p+302},
+{-0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302, 0x1.0003ffffffffcp+140, 0x1.ffffc00000000p+53, -0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302},
+{-0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302, -0x1.0003ffffffffcp+140, -0x1.ffffc00000000p+53, -0x1.0000000000002p+366, 0x1.ffc0ffff90000p+302},
+{0x1.0000100000000p-746, -0x1.0000000000000p-808, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692},
+{0x1.0000100000000p-746, -0x1.0000000000000p-808, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692},
+{-0x1.0000100000000p-746, 0x1.0000000000000p-808, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692, 0x1.0000000004000p-636, -0x1.ffffe00fc0200p-692},
+{-0x1.0000100000000p-746, 0x1.0000000000000p-808, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692, -0x1.0000000004000p-636, 0x1.ffffe00fc0200p-692},
+{0x1.0000000800000p+426, -0x1.0000000000000p+354, 0x1.000003fffc002p-730, -0x1.0000000000000p-835, 0x1.0000000800000p+426, -0x1.0000000000000p+354},
+{0x1.0000000800000p+426, -0x1.0000000000000p+354, -0x1.000003fffc002p-730, 0x1.0000000000000p-835, 0x1.0000000800000p+426, -0x1.0000000000000p+354},
+{-0x1.0000000800000p+426, 0x1.0000000000000p+354, 0x1.000003fffc002p-730, -0x1.0000000000000p-835, -0x1.0000000800000p+426, 0x1.0000000000000p+354},
+{-0x1.0000000800000p+426, 0x1.0000000000000p+354, -0x1.000003fffc002p-730, 0x1.0000000000000p-835, -0x1.0000000800000p+426, 0x1.0000000000000p+354},
+{0x1.0000000000000p-262, 0x1.ffc001ffffe00p-317, 0x1.000003fff8000p-258, 0x1.fffc000fc0000p-329, 0x1.100003fff8000p-258, 0x1.ffe001c000dc0p-317},
+{0x1.0000000000000p-262, 0x1.ffc001ffffe00p-317, -0x1.000003fff8000p-258, -0x1.fffc000fc0000p-329, -0x1.e00007fff0000p-259, 0x1.ffa0023ffee40p-317},
+{-0x1.0000000000000p-262, -0x1.ffc001ffffe00p-317, 0x1.000003fff8000p-258, 0x1.fffc000fc0000p-329, 0x1.e00007fff0000p-259, -0x1.ffa0023ffee40p-317},
+{-0x1.0000000000000p-262, -0x1.ffc001ffffe00p-317, -0x1.000003fff8000p-258, -0x1.fffc000fc0000p-329, -0x1.100003fff8000p-258, -0x1.ffe001c000dc0p-317},
+{0x1.0000000000003p+980, 0x1.fc00001fff800p+916, 0x1.0000000000020p+626, -0x1.fc01ffe002000p+562, 0x1.0000000000003p+980, 0x1.fc00001fff800p+916},
+{0x1.0000000000003p+980, 0x1.fc00001fff800p+916, -0x1.0000000000020p+626, 0x1.fc01ffe002000p+562, 0x1.0000000000003p+980, 0x1.fc00001fff800p+916},
+{-0x1.0000000000003p+980, -0x1.fc00001fff800p+916, 0x1.0000000000020p+626, -0x1.fc01ffe002000p+562, -0x1.0000000000003p+980, -0x1.fc00001fff800p+916},
+{-0x1.0000000000003p+980, -0x1.fc00001fff800p+916, -0x1.0000000000020p+626, 0x1.fc01ffe002000p+562, -0x1.0000000000003p+980, -0x1.fc00001fff800p+916},
+{0x1.0000000000000p-800, 0x1.fffff00001ffep-854, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410},
+{0x1.0000000000000p-800, 0x1.fffff00001ffep-854, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410},
+{-0x1.0000000000000p-800, -0x1.fffff00001ffep-854, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410, 0x1.0000000000000p+470, 0x1.ff00000ffff80p+410},
+{-0x1.0000000000000p-800, -0x1.fffff00001ffep-854, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410, -0x1.0000000000000p+470, -0x1.ff00000ffff80p+410},
+{0x1.0000000000000p+925, 0x1.ffffffffffc00p+862, 0x1.0000200000000p-454, -0x1.ffc0000080000p-526, 0x1.0000000000000p+925, 0x1.ffffffffffc00p+862},
+{0x1.0000000000000p+925, 0x1.ffffffffffc00p+862, -0x1.0000200000000p-454, 0x1.ffc0000080000p-526, 0x1.0000000000000p+925, 0x1.ffffffffffc00p+862},
+{-0x1.0000000000000p+925, -0x1.ffffffffffc00p+862, 0x1.0000200000000p-454, -0x1.ffc0000080000p-526, -0x1.0000000000000p+925, -0x1.ffffffffffc00p+862},
+{-0x1.0000000000000p+925, -0x1.ffffffffffc00p+862, -0x1.0000200000000p-454, 0x1.ffc0000080000p-526, -0x1.0000000000000p+925, -0x1.ffffffffffc00p+862},
+{0x1.0000000000800p+265, -0x1.fffc000000010p+208, 0x1.0000000000008p-204, -0x1.ffe03fffff010p-261, 0x1.0000000000800p+265, -0x1.fffc000000010p+208},
+{0x1.0000000000800p+265, -0x1.fffc000000010p+208, -0x1.0000000000008p-204, 0x1.ffe03fffff010p-261, 0x1.0000000000800p+265, -0x1.fffc000000010p+208},
+{-0x1.0000000000800p+265, 0x1.fffc000000010p+208, 0x1.0000000000008p-204, -0x1.ffe03fffff010p-261, -0x1.0000000000800p+265, 0x1.fffc000000010p+208},
+{-0x1.0000000000800p+265, 0x1.fffc000000010p+208, -0x1.0000000000008p-204, 0x1.ffe03fffff010p-261, -0x1.0000000000800p+265, 0x1.fffc000000010p+208},
+{0x1.0000000000000p-690, 0x1.fffef0ffff000p-753, 0x1.0000100000000p+763, -0x1.fff8000000800p+699, 0x1.0000100000000p+763, -0x1.fff8000000800p+699},
+{0x1.0000000000000p-690, 0x1.fffef0ffff000p-753, -0x1.0000100000000p+763, 0x1.fff8000000800p+699, -0x1.0000100000000p+763, 0x1.fff8000000800p+699},
+{-0x1.0000000000000p-690, -0x1.fffef0ffff000p-753, 0x1.0000100000000p+763, -0x1.fff8000000800p+699, 0x1.0000100000000p+763, -0x1.fff8000000800p+699},
+{-0x1.0000000000000p-690, -0x1.fffef0ffff000p-753, -0x1.0000100000000p+763, 0x1.fff8000000800p+699, -0x1.0000100000000p+763, 0x1.fff8000000800p+699},
+{0x1.07c00007ffff0p-506, 0x1.fffc00f800000p-582, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373},
+{0x1.07c00007ffff0p-506, 0x1.fffc00f800000p-582, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373},
+{-0x1.07c00007ffff0p-506, -0x1.fffc00f800000p-582, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373, 0x1.0000007ffffe0p-302, 0x1.f000000000000p-373},
+{-0x1.07c00007ffff0p-506, -0x1.fffc00f800000p-582, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373, -0x1.0000007ffffe0p-302, -0x1.f000000000000p-373},
+{0x1.0000000000000p-958, 0x1.ff800fffff800p-1014, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317},
+{0x1.0000000000000p-958, 0x1.ff800fffff800p-1014, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317},
+{-0x1.0000000000000p-958, -0x1.ff800fffff800p-1014, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317, 0x1.0000000000000p+373, 0x1.fffc0000ffff8p+317},
+{-0x1.0000000000000p-958, -0x1.ff800fffff800p-1014, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317, -0x1.0000000000000p+373, -0x1.fffc0000ffff8p+317},
+{0x1.0000000008000p+114, -0x1.ffff807ffe002p+60, 0x1.0000000800000p-783, -0x1.ffffff8000008p-839, 0x1.0000000008000p+114, -0x1.ffff807ffe002p+60},
+{0x1.0000000008000p+114, -0x1.ffff807ffe002p+60, -0x1.0000000800000p-783, 0x1.ffffff8000008p-839, 0x1.0000000008000p+114, -0x1.ffff807ffe002p+60},
+{-0x1.0000000008000p+114, 0x1.ffff807ffe002p+60, 0x1.0000000800000p-783, -0x1.ffffff8000008p-839, -0x1.0000000008000p+114, 0x1.ffff807ffe002p+60},
+{-0x1.0000000008000p+114, 0x1.ffff807ffe002p+60, -0x1.0000000800000p-783, 0x1.ffffff8000008p-839, -0x1.0000000008000p+114, 0x1.ffff807ffe002p+60},
+{0x1.0000000000020p+340, -0x1.0000000000000p+257, 0x1.0000000000000p-442, 0x1.fffff000003c0p-501, 0x1.0000000000020p+340, -0x1.0000000000000p+257},
+{0x1.0000000000020p+340, -0x1.0000000000000p+257, -0x1.0000000000000p-442, -0x1.fffff000003c0p-501, 0x1.0000000000020p+340, -0x1.0000000000000p+257},
+{-0x1.0000000000020p+340, 0x1.0000000000000p+257, 0x1.0000000000000p-442, 0x1.fffff000003c0p-501, -0x1.0000000000020p+340, 0x1.0000000000000p+257},
+{-0x1.0000000000020p+340, 0x1.0000000000000p+257, -0x1.0000000000000p-442, -0x1.fffff000003c0p-501, -0x1.0000000000020p+340, 0x1.0000000000000p+257},
+{0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331, 0x1.0000000200000p+69, -0x1.0000000000000p+0, 0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331},
+{0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331, -0x1.0000000200000p+69, 0x1.0000000000000p+0, 0x1.0000001ffff80p+385, 0x1.fffffdfffff8ep+331},
+{-0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331, 0x1.0000000200000p+69, -0x1.0000000000000p+0, -0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331},
+{-0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331, -0x1.0000000200000p+69, 0x1.0000000000000p+0, -0x1.0000001ffff80p+385, -0x1.fffffdfffff8ep+331},
+{0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198, 0x1.0000000000000p-934, 0x1.8fff01fffff00p-994, 0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198},
+{0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198, -0x1.0000000000000p-934, -0x1.8fff01fffff00p-994, 0x1.01ffffff80400p-140, -0x1.c7ffffc000100p-198},
+{-0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198, 0x1.0000000000000p-934, 0x1.8fff01fffff00p-994, -0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198},
+{-0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198, -0x1.0000000000000p-934, -0x1.8fff01fffff00p-994, -0x1.01ffffff80400p-140, 0x1.c7ffffc000100p-198},
+{0x1.0000000000008p+975, -0x1.ffffc00800000p+902, 0x1.00003ffe00002p-979, -0x1.ffffffc180000p-1039, 0x1.0000000000008p+975, -0x1.ffffc00800000p+902},
+{0x1.0000000000008p+975, -0x1.ffffc00800000p+902, -0x1.00003ffe00002p-979, 0x1.ffffffc180000p-1039, 0x1.0000000000008p+975, -0x1.ffffc00800000p+902},
+{-0x1.0000000000008p+975, 0x1.ffffc00800000p+902, 0x1.00003ffe00002p-979, -0x1.ffffffc180000p-1039, -0x1.0000000000008p+975, 0x1.ffffc00800000p+902},
+{-0x1.0000000000008p+975, 0x1.ffffc00800000p+902, -0x1.00003ffe00002p-979, 0x1.ffffffc180000p-1039, -0x1.0000000000008p+975, 0x1.ffffc00800000p+902},
+{0x1.000000ffffff8p+56, 0x1.ffffffc000000p-1, 0x1.0000000000000p-40, 0x1.ffffffe000000p-98, 0x1.000000ffffff8p+56, 0x1.ffffffc002000p-1},
+{0x1.000000ffffff8p+56, 0x1.ffffffc000000p-1, -0x1.0000000000000p-40, -0x1.ffffffe000000p-98, 0x1.000000ffffff8p+56, 0x1.ffffffbffe000p-1},
+{-0x1.000000ffffff8p+56, -0x1.ffffffc000000p-1, 0x1.0000000000000p-40, 0x1.ffffffe000000p-98, -0x1.000000ffffff8p+56, -0x1.ffffffbffe000p-1},
+{-0x1.000000ffffff8p+56, -0x1.ffffffc000000p-1, -0x1.0000000000000p-40, -0x1.ffffffe000000p-98, -0x1.000000ffffff8p+56, -0x1.ffffffc002000p-1},
+{0x1.0000000020000p-764, -0x1.0000000000000p-869, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470},
+{0x1.0000000020000p-764, -0x1.0000000000000p-869, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470},
+{-0x1.0000000020000p-764, 0x1.0000000000000p-869, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470, 0x1.0000000000400p-403, -0x1.ff1ffffff4000p-470},
+{-0x1.0000000020000p-764, 0x1.0000000000000p-869, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470, -0x1.0000000000400p-403, 0x1.ff1ffffff4000p-470},
+{0x1.0000ff8020000p-469, -0x1.fffffa0000000p-531, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80},
+{0x1.0000ff8020000p-469, -0x1.fffffa0000000p-531, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80},
+{-0x1.0000ff8020000p-469, 0x1.fffffa0000000p-531, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80, 0x1.0000000001ff0p-14, 0x1.f700000ffe000p-80},
+{-0x1.0000ff8020000p-469, 0x1.fffffa0000000p-531, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80, -0x1.0000000001ff0p-14, -0x1.f700000ffe000p-80},
+{0x1.0000020000000p+518, -0x1.0000000000000p+454, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710},
+{0x1.0000020000000p+518, -0x1.0000000000000p+454, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710},
+{-0x1.0000020000000p+518, 0x1.0000000000000p+454, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710, 0x1.003e00001f800p+772, 0x1.ffde000001e00p+710},
+{-0x1.0000020000000p+518, 0x1.0000000000000p+454, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710, -0x1.003e00001f800p+772, -0x1.ffde000001e00p+710},
+{0x1.0007e3ffe0000p-546, 0x1.fe0ffffffe000p-610, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506},
+{0x1.0007e3ffe0000p-546, 0x1.fe0ffffffe000p-610, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506},
+{-0x1.0007e3ffe0000p-546, -0x1.fe0ffffffe000p-610, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506, 0x1.0000000000000p+567, 0x1.fffffe07fff00p+506},
+{-0x1.0007e3ffe0000p-546, -0x1.fe0ffffffe000p-610, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506, -0x1.0000000000000p+567, -0x1.fffffe07fff00p+506},
+{0x1.00000000fe000p-853, 0x1.ff00004000000p-920, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322},
+{0x1.00000000fe000p-853, 0x1.ff00004000000p-920, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322},
+{-0x1.00000000fe000p-853, -0x1.ff00004000000p-920, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322, 0x1.000003fffff80p+382, 0x1.fff8400000000p+322},
+{-0x1.00000000fe000p-853, -0x1.ff00004000000p-920, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322, -0x1.000003fffff80p+382, -0x1.fff8400000000p+322},
+{0x1.0000800000000p-529, -0x1.0000000000000p-585, 0x1.0000000000000p-716, 0x1.fffffffc1fc00p-779, 0x1.0000800000000p-529, -0x1.0000000000000p-585},
+{0x1.0000800000000p-529, -0x1.0000000000000p-585, -0x1.0000000000000p-716, -0x1.fffffffc1fc00p-779, 0x1.0000800000000p-529, -0x1.0000000000000p-585},
+{-0x1.0000800000000p-529, 0x1.0000000000000p-585, 0x1.0000000000000p-716, 0x1.fffffffc1fc00p-779, -0x1.0000800000000p-529, 0x1.0000000000000p-585},
+{-0x1.0000800000000p-529, 0x1.0000000000000p-585, -0x1.0000000000000p-716, -0x1.fffffffc1fc00p-779, -0x1.0000800000000p-529, 0x1.0000000000000p-585},
+{0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491, 0x1.0000000000000p-565, 0x1.fe0003fffc000p-624, 0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491},
+{0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491, -0x1.0000000000000p-565, -0x1.fe0003fffc000p-624, 0x1.0000000000000p+545, 0x1.ff000ff3ffe00p+491},
+{-0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491, 0x1.0000000000000p-565, 0x1.fe0003fffc000p-624, -0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491},
+{-0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491, -0x1.0000000000000p-565, -0x1.fe0003fffc000p-624, -0x1.0000000000000p+545, -0x1.ff000ff3ffe00p+491},
+{0x1.000000e000010p-739, -0x1.ffffffc020000p-809, 0x1.00000001f0000p+66, 0x1.8000000000000p-38, 0x1.00000001f0000p+66, 0x1.8000000000000p-38},
+{0x1.000000e000010p-739, -0x1.ffffffc020000p-809, -0x1.00000001f0000p+66, -0x1.8000000000000p-38, -0x1.00000001f0000p+66, -0x1.8000000000000p-38},
+{-0x1.000000e000010p-739, 0x1.ffffffc020000p-809, 0x1.00000001f0000p+66, 0x1.8000000000000p-38, 0x1.00000001f0000p+66, 0x1.8000000000000p-38},
+{-0x1.000000e000010p-739, 0x1.ffffffc020000p-809, -0x1.00000001f0000p+66, -0x1.8000000000000p-38, -0x1.00000001f0000p+66, -0x1.8000000000000p-38},
+{0x1.000003ff00000p-980, 0x1.8000000000000p-1057, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386},
+{0x1.000003ff00000p-980, 0x1.8000000000000p-1057, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386},
+{-0x1.000003ff00000p-980, -0x1.8000000000000p-1057, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386, 0x1.0001ffffe0000p-313, 0x1.f800000100000p-386},
+{-0x1.000003ff00000p-980, -0x1.8000000000000p-1057, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386, -0x1.0001ffffe0000p-313, -0x1.f800000100000p-386},
+{0x1.0000000000200p+292, -0x1.ffffffffffc08p+236, 0x1.0000000000000p-660, 0x1.ffffffffffffep-714, 0x1.0000000000200p+292, -0x1.ffffffffffc08p+236},
+{0x1.0000000000200p+292, -0x1.ffffffffffc08p+236, -0x1.0000000000000p-660, -0x1.ffffffffffffep-714, 0x1.0000000000200p+292, -0x1.ffffffffffc08p+236},
+{-0x1.0000000000200p+292, 0x1.ffffffffffc08p+236, 0x1.0000000000000p-660, 0x1.ffffffffffffep-714, -0x1.0000000000200p+292, 0x1.ffffffffffc08p+236},
+{-0x1.0000000000200p+292, 0x1.ffffffffffc08p+236, -0x1.0000000000000p-660, -0x1.ffffffffffffep-714, -0x1.0000000000200p+292, 0x1.ffffffffffc08p+236},
+{0x1.0000000040000p-475, -0x1.fffff80002000p-541, 0x1.0000000000000p-741, 0x1.ffc01ffff3c00p-804, 0x1.0000000040000p-475, -0x1.fffff80002000p-541},
+{0x1.0000000040000p-475, -0x1.fffff80002000p-541, -0x1.0000000000000p-741, -0x1.ffc01ffff3c00p-804, 0x1.0000000040000p-475, -0x1.fffff80002000p-541},
+{-0x1.0000000040000p-475, 0x1.fffff80002000p-541, 0x1.0000000000000p-741, 0x1.ffc01ffff3c00p-804, -0x1.0000000040000p-475, 0x1.fffff80002000p-541},
+{-0x1.0000000040000p-475, 0x1.fffff80002000p-541, -0x1.0000000000000p-741, -0x1.ffc01ffff3c00p-804, -0x1.0000000040000p-475, 0x1.fffff80002000p-541},
+{0x1.0000800000000p+1022, -0x1.0000000000000p+917, 0x1.0000003800001p-290, 0x1.fffffe000003ep-344, 0x1.0000800000000p+1022, -0x1.0000000000000p+917},
+{0x1.0000800000000p+1022, -0x1.0000000000000p+917, -0x1.0000003800001p-290, -0x1.fffffe000003ep-344, 0x1.0000800000000p+1022, -0x1.0000000000000p+917},
+{-0x1.0000800000000p+1022, 0x1.0000000000000p+917, 0x1.0000003800001p-290, 0x1.fffffe000003ep-344, -0x1.0000800000000p+1022, 0x1.0000000000000p+917},
+{-0x1.0000800000000p+1022, 0x1.0000000000000p+917, -0x1.0000003800001p-290, -0x1.fffffe000003ep-344, -0x1.0000800000000p+1022, 0x1.0000000000000p+917},
+{0x1.0f00000020000p-425, -0x1.fffe000000100p-479, 0x1.0000000400000p-527, -0x1.ffffffc004000p-594, 0x1.0f00000020000p-425, -0x1.fffe0000000f0p-479},
+{0x1.0f00000020000p-425, -0x1.fffe000000100p-479, -0x1.0000000400000p-527, 0x1.ffffffc004000p-594, 0x1.0f00000020000p-425, -0x1.fffe000000110p-479},
+{-0x1.0f00000020000p-425, 0x1.fffe000000100p-479, 0x1.0000000400000p-527, -0x1.ffffffc004000p-594, -0x1.0f00000020000p-425, 0x1.fffe000000110p-479},
+{-0x1.0f00000020000p-425, 0x1.fffe000000100p-479, -0x1.0000000400000p-527, 0x1.ffffffc004000p-594, -0x1.0f00000020000p-425, 0x1.fffe0000000f0p-479},
+{0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652, 0x1.0000000000400p+142, -0x1.ffff800007ffcp+87, 0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652},
+{0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652, -0x1.0000000000400p+142, 0x1.ffff800007ffcp+87, 0x1.003fe00020000p+720, -0x1.ffffffffe8000p+652},
+{-0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652, 0x1.0000000000400p+142, -0x1.ffff800007ffcp+87, -0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652},
+{-0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652, -0x1.0000000000400p+142, 0x1.ffff800007ffcp+87, -0x1.003fe00020000p+720, 0x1.ffffffffe8000p+652},
+{0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11, 0x1.0000020000000p-926, -0x1.0000000000000p-1002, 0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11},
+{0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11, -0x1.0000020000000p-926, 0x1.0000000000000p-1002, 0x1.ffff00fffffc4p+71, -0x1.8080000000000p-11},
+{-0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11, 0x1.0000020000000p-926, -0x1.0000000000000p-1002, -0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11},
+{-0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11, -0x1.0000020000000p-926, 0x1.0000000000000p-1002, -0x1.ffff00fffffc4p+71, 0x1.8080000000000p-11},
+{0x1.0000000000040p-915, -0x1.8000000800000p-990, 0x1.0000000002000p-454, -0x1.0000000000000p-558, 0x1.0000000002000p-454, -0x1.0000000000000p-558},
+{0x1.0000000000040p-915, -0x1.8000000800000p-990, -0x1.0000000002000p-454, 0x1.0000000000000p-558, -0x1.0000000002000p-454, 0x1.0000000000000p-558},
+{-0x1.0000000000040p-915, 0x1.8000000800000p-990, 0x1.0000000002000p-454, -0x1.0000000000000p-558, 0x1.0000000002000p-454, -0x1.0000000000000p-558},
+{-0x1.0000000000040p-915, 0x1.8000000800000p-990, -0x1.0000000002000p-454, 0x1.0000000000000p-558, -0x1.0000000002000p-454, 0x1.0000000000000p-558},
+{0x1.0000000800000p-123, -0x1.ffffc02000000p-201, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488},
+{0x1.0000000800000p-123, -0x1.ffffc02000000p-201, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488},
+{-0x1.0000000800000p-123, 0x1.ffffc02000000p-201, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488, 0x1.7fffe00800000p+593, -0x1.0000000000000p+488},
+{-0x1.0000000800000p-123, 0x1.ffffc02000000p-201, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488, -0x1.7fffe00800000p+593, 0x1.0000000000000p+488},
+{0x1.0000400000000p+352, -0x1.0000000000000p+261, 0x1.4000000000000p-216, -0x1.ffffffff00020p-274, 0x1.0000400000000p+352, -0x1.0000000000000p+261},
+{0x1.0000400000000p+352, -0x1.0000000000000p+261, -0x1.4000000000000p-216, 0x1.ffffffff00020p-274, 0x1.0000400000000p+352, -0x1.0000000000000p+261},
+{-0x1.0000400000000p+352, 0x1.0000000000000p+261, 0x1.4000000000000p-216, -0x1.ffffffff00020p-274, -0x1.0000400000000p+352, 0x1.0000000000000p+261},
+{-0x1.0000400000000p+352, 0x1.0000000000000p+261, -0x1.4000000000000p-216, 0x1.ffffffff00020p-274, -0x1.0000400000000p+352, 0x1.0000000000000p+261},
+{0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771, 0x1.00001fffc0000p-889, 0x1.f80001f000f80p-949, 0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771},
+{0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771, -0x1.00001fffc0000p-889, -0x1.f80001f000f80p-949, 0x1.0000000000000p-714, 0x1.03eff7ff3fff0p-771},
+{-0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771, 0x1.00001fffc0000p-889, 0x1.f80001f000f80p-949, -0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771},
+{-0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771, -0x1.00001fffc0000p-889, -0x1.f80001f000f80p-949, -0x1.0000000000000p-714, -0x1.03eff7ff3fff0p-771},
+{0x1.03ffffffffffep-517, 0x1.8000000000000p-621, 0x1.0000040000000p-478, -0x1.0000000000000p-583, 0x1.0000040002080p-478, -0x1.0002000000000p-568},
+{0x1.03ffffffffffep-517, 0x1.8000000000000p-621, -0x1.0000040000000p-478, 0x1.0000000000000p-583, -0x1.000003fffdf80p-478, -0x1.fffc000000000p-569},
+{-0x1.03ffffffffffep-517, -0x1.8000000000000p-621, 0x1.0000040000000p-478, -0x1.0000000000000p-583, 0x1.000003fffdf80p-478, 0x1.fffc000000000p-569},
+{-0x1.03ffffffffffep-517, -0x1.8000000000000p-621, -0x1.0000040000000p-478, 0x1.0000000000000p-583, -0x1.0000040002080p-478, 0x1.0002000000000p-568},
+{0x1.0007ffffcfffcp-566, 0x1.ff01fffe00000p-640, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66},
+{0x1.0007ffffcfffcp-566, 0x1.ff01fffe00000p-640, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66},
+{-0x1.0007ffffcfffcp-566, -0x1.ff01fffe00000p-640, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66, 0x1.01fff08000000p-12, -0x1.fffffe0000020p-66},
+{-0x1.0007ffffcfffcp-566, -0x1.ff01fffe00000p-640, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66, -0x1.01fff08000000p-12, 0x1.fffffe0000020p-66},
+{0x1.00000000007fep-907, 0x1.ff00003ffff00p-968, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751},
+{0x1.00000000007fep-907, 0x1.ff00003ffff00p-968, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751},
+{-0x1.00000000007fep-907, -0x1.ff00003ffff00p-968, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751, 0x1.004000e000008p+829, -0x1.ffffe02000000p+751},
+{-0x1.00000000007fep-907, -0x1.ff00003ffff00p-968, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751, -0x1.004000e000008p+829, 0x1.ffffe02000000p+751},
+{0x1.00000003ff000p-540, 0x1.ffff000000000p-629, 0x1.0000fffff8000p-864, 0x1.f003ffe0003e0p-922, 0x1.00000003ff000p-540, 0x1.ffff000000000p-629},
+{0x1.00000003ff000p-540, 0x1.ffff000000000p-629, -0x1.0000fffff8000p-864, -0x1.f003ffe0003e0p-922, 0x1.00000003ff000p-540, 0x1.ffff000000000p-629},
+{-0x1.00000003ff000p-540, -0x1.ffff000000000p-629, 0x1.0000fffff8000p-864, 0x1.f003ffe0003e0p-922, -0x1.00000003ff000p-540, -0x1.ffff000000000p-629},
+{-0x1.00000003ff000p-540, -0x1.ffff000000000p-629, -0x1.0000fffff8000p-864, -0x1.f003ffe0003e0p-922, -0x1.00000003ff000p-540, -0x1.ffff000000000p-629},
+{0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45, 0x1.01fffffe00000p-954, 0x1.ffffffffffc00p-1012, 0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45},
+{0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45, -0x1.01fffffe00000p-954, -0x1.ffffffffffc00p-1012, 0x1.0000000000000p+14, 0x1.ffe001c0003c0p-45},
+{-0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45, 0x1.01fffffe00000p-954, 0x1.ffffffffffc00p-1012, -0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45},
+{-0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45, -0x1.01fffffe00000p-954, -0x1.ffffffffffc00p-1012, -0x1.0000000000000p+14, -0x1.ffe001c0003c0p-45},
+{0x1.00003ff808000p-919, -0x1.ffe0000800000p-980, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136},
+{0x1.00003ff808000p-919, -0x1.ffe0000800000p-980, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136},
+{-0x1.00003ff808000p-919, 0x1.ffe0000800000p-980, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136, 0x1.000001ffff000p-62, 0x1.ff80000000000p-136},
+{-0x1.00003ff808000p-919, 0x1.ffe0000800000p-980, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136, -0x1.000001ffff000p-62, -0x1.ff80000000000p-136},
+{0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727, 0x1.0000000007f80p-960, 0x1.ff0007f802000p-1024, 0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727},
+{0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727, -0x1.0000000007f80p-960, -0x1.ff0007f802000p-1024, 0x1.0000000000000p-665, 0x1.fc007f0ff0000p-727},
+{-0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727, 0x1.0000000007f80p-960, 0x1.ff0007f802000p-1024, -0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727},
+{-0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727, -0x1.0000000007f80p-960, -0x1.ff0007f802000p-1024, -0x1.0000000000000p-665, -0x1.fc007f0ff0000p-727},
+{0x1.0020000000000p+107, -0x1.0000000000000p+30, 0x1.000001ffff802p-529, -0x1.ffffffc000040p-588, 0x1.0020000000000p+107, -0x1.0000000000000p+30},
+{0x1.0020000000000p+107, -0x1.0000000000000p+30, -0x1.000001ffff802p-529, 0x1.ffffffc000040p-588, 0x1.0020000000000p+107, -0x1.0000000000000p+30},
+{-0x1.0020000000000p+107, 0x1.0000000000000p+30, 0x1.000001ffff802p-529, -0x1.ffffffc000040p-588, -0x1.0020000000000p+107, 0x1.0000000000000p+30},
+{-0x1.0020000000000p+107, 0x1.0000000000000p+30, -0x1.000001ffff802p-529, 0x1.ffffffc000040p-588, -0x1.0020000000000p+107, 0x1.0000000000000p+30},
+{0x1.0000000000800p+985, -0x1.ffe0000400000p+923, 0x1.0000000000038p+697, 0x1.e100000000000p+623, 0x1.0000000000800p+985, -0x1.ffe0000400000p+923},
+{0x1.0000000000800p+985, -0x1.ffe0000400000p+923, -0x1.0000000000038p+697, -0x1.e100000000000p+623, 0x1.0000000000800p+985, -0x1.ffe0000400000p+923},
+{-0x1.0000000000800p+985, 0x1.ffe0000400000p+923, 0x1.0000000000038p+697, 0x1.e100000000000p+623, -0x1.0000000000800p+985, 0x1.ffe0000400000p+923},
+{-0x1.0000000000800p+985, 0x1.ffe0000400000p+923, -0x1.0000000000038p+697, -0x1.e100000000000p+623, -0x1.0000000000800p+985, 0x1.ffe0000400000p+923},
+{0x1.0000000000020p+26, -0x1.8007ffff80c04p-29, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513},
+{0x1.0000000000020p+26, -0x1.8007ffff80c04p-29, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513},
+{-0x1.0000000000020p+26, 0x1.8007ffff80c04p-29, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513, 0x1.0000000000000p+576, 0x1.ffffe00000c00p+513},
+{-0x1.0000000000020p+26, 0x1.8007ffff80c04p-29, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513, -0x1.0000000000000p+576, -0x1.ffffe00000c00p+513},
+{0x1.7fffffff80000p-290, 0x1.f000000000000p-367, 0x1.000007ffffffep-351, 0x1.ffffff8000000p-427, 0x1.7fffffff80000p-290, 0x1.0001f80000000p-351},
+{0x1.7fffffff80000p-290, 0x1.f000000000000p-367, -0x1.000007ffffffep-351, -0x1.ffffff8000000p-427, 0x1.7fffffff80000p-290, -0x1.fffc300000000p-352},
+{-0x1.7fffffff80000p-290, -0x1.f000000000000p-367, 0x1.000007ffffffep-351, 0x1.ffffff8000000p-427, -0x1.7fffffff80000p-290, 0x1.fffc300000000p-352},
+{-0x1.7fffffff80000p-290, -0x1.f000000000000p-367, -0x1.000007ffffffep-351, -0x1.ffffff8000000p-427, -0x1.7fffffff80000p-290, -0x1.0001f80000000p-351},
+{0x1.0000000010000p-869, -0x1.0000000000000p-955, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304},
+{0x1.0000000010000p-869, -0x1.0000000000000p-955, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304},
+{-0x1.0000000010000p-869, 0x1.0000000000000p-955, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304, 0x1.0000000000000p-250, 0x1.c000003ffc3fep-304},
+{-0x1.0000000010000p-869, 0x1.0000000000000p-955, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304, -0x1.0000000000000p-250, -0x1.c000003ffc3fep-304},
+{0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297, 0x1.0000000000002p-749, -0x1.0000000000000p-854, 0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297},
+{0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297, -0x1.0000000000002p-749, 0x1.0000000000000p-854, 0x1.00000ffff0800p-239, -0x1.fff80000ffc20p-297},
+{-0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297, 0x1.0000000000002p-749, -0x1.0000000000000p-854, -0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297},
+{-0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297, -0x1.0000000000002p-749, 0x1.0000000000000p-854, -0x1.00000ffff0800p-239, 0x1.fff80000ffc20p-297},
+{0x1.000ffffc00000p+483, 0x1.fffff00000000p+414, 0x1.0000000000040p+210, -0x1.0000000000000p+105, 0x1.000ffffc00000p+483, 0x1.fffff00000000p+414},
+{0x1.000ffffc00000p+483, 0x1.fffff00000000p+414, -0x1.0000000000040p+210, 0x1.0000000000000p+105, 0x1.000ffffc00000p+483, 0x1.fffff00000000p+414},
+{-0x1.000ffffc00000p+483, -0x1.fffff00000000p+414, 0x1.0000000000040p+210, -0x1.0000000000000p+105, -0x1.000ffffc00000p+483, -0x1.fffff00000000p+414},
+{-0x1.000ffffc00000p+483, -0x1.fffff00000000p+414, -0x1.0000000000040p+210, 0x1.0000000000000p+105, -0x1.000ffffc00000p+483, -0x1.fffff00000000p+414},
+{0x1.0004000000000p-94, -0x1.0000000000000p-162, 0x1.0000000200000p-175, -0x1.ffbffffff8020p-233, 0x1.0004000000000p-94, -0x1.fff0000000000p-163},
+{0x1.0004000000000p-94, -0x1.0000000000000p-162, -0x1.0000000200000p-175, 0x1.ffbffffff8020p-233, 0x1.0004000000000p-94, -0x1.0008000000000p-162},
+{-0x1.0004000000000p-94, 0x1.0000000000000p-162, 0x1.0000000200000p-175, -0x1.ffbffffff8020p-233, -0x1.0004000000000p-94, 0x1.0008000000000p-162},
+{-0x1.0004000000000p-94, 0x1.0000000000000p-162, -0x1.0000000200000p-175, 0x1.ffbffffff8020p-233, -0x1.0004000000000p-94, 0x1.fff0000000000p-163},
+{0x1.0000000000000p-421, 0x1.e0001e7fbff00p-482, 0x1.0000001fffffep-395, 0x0.0000000000000p+0, 0x1.0000005fffffep-395, 0x1.e000000000000p-482},
+{0x1.0000000000000p-421, 0x1.e0001e7fbff00p-482, -0x1.0000001fffffep-395, 0x0.0000000000000p+0, -0x1.ffffffbfffffcp-396, 0x1.e000200000000p-482},
+{-0x1.0000000000000p-421, -0x1.e0001e7fbff00p-482, 0x1.0000001fffffep-395, 0x0.0000000000000p+0, 0x1.ffffffbfffffcp-396, -0x1.e000200000000p-482},
+{-0x1.0000000000000p-421, -0x1.e0001e7fbff00p-482, -0x1.0000001fffffep-395, 0x0.0000000000000p+0, -0x1.0000005fffffep-395, -0x1.e000000000000p-482},
+{0x1.0000000000fffp-362, 0x1.fffff3e000000p-435, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813},
+{0x1.0000000000fffp-362, 0x1.fffff3e000000p-435, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813},
+{-0x1.0000000000fffp-362, -0x1.fffff3e000000p-435, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813, 0x1.001ffe0000000p+872, 0x1.fffffffffffc0p+813},
+{-0x1.0000000000fffp-362, -0x1.fffff3e000000p-435, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813, -0x1.001ffe0000000p+872, -0x1.fffffffffffc0p+813},
+{0x1.0000080000000p+509, -0x1.0000000000000p+404, 0x1.0000000080000p-689, -0x1.0000000000000p-744, 0x1.0000080000000p+509, -0x1.0000000000000p+404},
+{0x1.0000080000000p+509, -0x1.0000000000000p+404, -0x1.0000000080000p-689, 0x1.0000000000000p-744, 0x1.0000080000000p+509, -0x1.0000000000000p+404},
+{-0x1.0000080000000p+509, 0x1.0000000000000p+404, 0x1.0000000080000p-689, -0x1.0000000000000p-744, -0x1.0000080000000p+509, 0x1.0000000000000p+404},
+{-0x1.0000080000000p+509, 0x1.0000000000000p+404, -0x1.0000000080000p-689, 0x1.0000000000000p-744, -0x1.0000080000000p+509, 0x1.0000000000000p+404},
+{0x1.003ffffffffe0p+511, 0x1.ffffe03800000p+435, 0x1.0000000002000p+705, -0x1.0000000000000p+652, 0x1.0000000002000p+705, -0x1.0000000000000p+652},
+{0x1.003ffffffffe0p+511, 0x1.ffffe03800000p+435, -0x1.0000000002000p+705, 0x1.0000000000000p+652, -0x1.0000000002000p+705, 0x1.0000000000000p+652},
+{-0x1.003ffffffffe0p+511, -0x1.ffffe03800000p+435, 0x1.0000000002000p+705, -0x1.0000000000000p+652, 0x1.0000000002000p+705, -0x1.0000000000000p+652},
+{-0x1.003ffffffffe0p+511, -0x1.ffffe03800000p+435, -0x1.0000000002000p+705, 0x1.0000000000000p+652, -0x1.0000000002000p+705, 0x1.0000000000000p+652},
+{0x1.0000000000008p-749, -0x1.ff000007ffc00p-809, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786},
+{0x1.0000000000008p-749, -0x1.ff000007ffc00p-809, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786},
+{-0x1.0000000000008p-749, 0x1.ff000007ffc00p-809, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786, 0x1.0000000060000p+866, 0x1.ffffff8000000p+786},
+{-0x1.0000000000008p-749, 0x1.ff000007ffc00p-809, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786, -0x1.0000000060000p+866, -0x1.ffffff8000000p+786},
+{0x1.0000000000080p+921, -0x1.0000000000000p+816, 0x1.01ffffff80001p+85, -0x1.ff90000000000p-8, 0x1.0000000000080p+921, -0x1.0000000000000p+816},
+{0x1.0000000000080p+921, -0x1.0000000000000p+816, -0x1.01ffffff80001p+85, 0x1.ff90000000000p-8, 0x1.0000000000080p+921, -0x1.0000000000000p+816},
+{-0x1.0000000000080p+921, 0x1.0000000000000p+816, 0x1.01ffffff80001p+85, -0x1.ff90000000000p-8, -0x1.0000000000080p+921, 0x1.0000000000000p+816},
+{-0x1.0000000000080p+921, 0x1.0000000000000p+816, -0x1.01ffffff80001p+85, 0x1.ff90000000000p-8, -0x1.0000000000080p+921, 0x1.0000000000000p+816},
+{0x1.0000000000800p-666, -0x1.fffff80002000p-732, 0x1.0008000000000p-639, -0x1.0000000000000p-718, 0x1.0008002000000p-639, 0x1.ffbffe0000000p-708},
+{0x1.0000000000800p-666, -0x1.fffff80002000p-732, -0x1.0008000000000p-639, 0x1.0000000000000p-718, -0x1.0007ffe000000p-639, 0x1.001fff0000000p-707},
+{-0x1.0000000000800p-666, 0x1.fffff80002000p-732, 0x1.0008000000000p-639, -0x1.0000000000000p-718, 0x1.0007ffe000000p-639, -0x1.001fff0000000p-707},
+{-0x1.0000000000800p-666, 0x1.fffff80002000p-732, -0x1.0008000000000p-639, 0x1.0000000000000p-718, -0x1.0008002000000p-639, -0x1.ffbffe0000000p-708},
+{0x1.0000000000002p+14, -0x1.ffffffe200000p-60, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70},
+{0x1.0000000000002p+14, -0x1.ffffffe200000p-60, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70},
+{-0x1.0000000000002p+14, 0x1.ffffffe200000p-60, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70, 0x1.0003fffffffc0p+133, 0x1.ffffe00000400p+70},
+{-0x1.0000000000002p+14, 0x1.ffffffe200000p-60, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70, -0x1.0003fffffffc0p+133, -0x1.ffffe00000400p+70},
+{0x1.000003f000000p+120, 0x1.fffffffe00000p+59, 0x1.0000000000ff0p+144, 0x1.c03fff0e00000p+70, 0x1.000001000102fp+144, 0x1.c07fff0e00000p+70},
+{0x1.000003f000000p+120, 0x1.fffffffe00000p+59, -0x1.0000000000ff0p+144, -0x1.c03fff0e00000p+70, -0x1.fffffe0001f62p+143, -0x1.bfffff0e00000p+70},
+{-0x1.000003f000000p+120, -0x1.fffffffe00000p+59, 0x1.0000000000ff0p+144, 0x1.c03fff0e00000p+70, 0x1.fffffe0001f62p+143, 0x1.bfffff0e00000p+70},
+{-0x1.000003f000000p+120, -0x1.fffffffe00000p+59, -0x1.0000000000ff0p+144, -0x1.c03fff0e00000p+70, -0x1.000001000102fp+144, -0x1.c07fff0e00000p+70},
+{0x1.0000000018000p+68, 0x1.fffffe0000000p-14, 0x1.0000100000000p+766, -0x1.0000000000000p+661, 0x1.0000100000000p+766, -0x1.0000000000000p+661},
+{0x1.0000000018000p+68, 0x1.fffffe0000000p-14, -0x1.0000100000000p+766, 0x1.0000000000000p+661, -0x1.0000100000000p+766, 0x1.0000000000000p+661},
+{-0x1.0000000018000p+68, -0x1.fffffe0000000p-14, 0x1.0000100000000p+766, -0x1.0000000000000p+661, 0x1.0000100000000p+766, -0x1.0000000000000p+661},
+{-0x1.0000000018000p+68, -0x1.fffffe0000000p-14, -0x1.0000100000000p+766, 0x1.0000000000000p+661, -0x1.0000100000000p+766, 0x1.0000000000000p+661},
+{0x1.0000000000001p-191, -0x1.fffffc1000000p-258, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256},
+{0x1.0000000000001p-191, -0x1.fffffc1000000p-258, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256},
+{-0x1.0000000000001p-191, 0x1.fffffc1000000p-258, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256, 0x1.1ffffff01f000p+311, 0x1.ffffc000060fcp+256},
+{-0x1.0000000000001p-191, 0x1.fffffc1000000p-258, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256, -0x1.1ffffff01f000p+311, -0x1.ffffc000060fcp+256},
+{0x1.0000003800000p-790, 0x1.ffe000001fffcp-845, 0x1.0000007fffff0p-815, 0x1.fe1ffffc00000p-877, 0x1.000000b800004p-790, 0x1.ffdfc0021e1fcp-845},
+{0x1.0000003800000p-790, 0x1.ffe000001fffcp-845, -0x1.0000007fffff0p-815, -0x1.fe1ffffc00000p-877, 0x1.ffffff6fffff8p-791, 0x1.ffe03ffe21dfcp-845},
+{-0x1.0000003800000p-790, -0x1.ffe000001fffcp-845, 0x1.0000007fffff0p-815, 0x1.fe1ffffc00000p-877, -0x1.ffffff6fffff8p-791, -0x1.ffe03ffe21dfcp-845},
+{-0x1.0000003800000p-790, -0x1.ffe000001fffcp-845, -0x1.0000007fffff0p-815, -0x1.fe1ffffc00000p-877, -0x1.000000b800004p-790, -0x1.ffdfc0021e1fcp-845},
+{0x1.0000001fffc00p-770, 0x1.f00007ffe0000p-834, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932},
+{0x1.0000001fffc00p-770, 0x1.f00007ffe0000p-834, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932},
+{-0x1.0000001fffc00p-770, -0x1.f00007ffe0000p-834, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932, 0x1.0000000000180p+996, 0x1.fffffe0000800p+932},
+{-0x1.0000001fffc00p-770, -0x1.f00007ffe0000p-834, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932, -0x1.0000000000180p+996, -0x1.fffffe0000800p+932},
+{0x1.0000000008000p+440, -0x1.c0000007ffe04p+385, 0x1.00000fffffffep-521, 0x1.fc00000000000p-620, 0x1.0000000008000p+440, -0x1.c0000007ffe04p+385},
+{0x1.0000000008000p+440, -0x1.c0000007ffe04p+385, -0x1.00000fffffffep-521, -0x1.fc00000000000p-620, 0x1.0000000008000p+440, -0x1.c0000007ffe04p+385},
+{-0x1.0000000008000p+440, 0x1.c0000007ffe04p+385, 0x1.00000fffffffep-521, 0x1.fc00000000000p-620, -0x1.0000000008000p+440, 0x1.c0000007ffe04p+385},
+{-0x1.0000000008000p+440, 0x1.c0000007ffe04p+385, -0x1.00000fffffffep-521, -0x1.fc00000000000p-620, -0x1.0000000008000p+440, 0x1.c0000007ffe04p+385},
+{0x1.0000003e00004p-731, -0x1.fe00040000000p-801, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419},
+{0x1.0000003e00004p-731, -0x1.fe00040000000p-801, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419},
+{-0x1.0000003e00004p-731, 0x1.fe00040000000p-801, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419, 0x1.00007c0001e00p+483, 0x1.fffe13ffe0000p+419},
+{-0x1.0000003e00004p-731, 0x1.fe00040000000p-801, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419, -0x1.00007c0001e00p+483, -0x1.fffe13ffe0000p+419},
+{0x1.03fffffffc000p-192, 0x1.ffffffc000000p-267, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554},
+{0x1.03fffffffc000p-192, 0x1.ffffffc000000p-267, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554},
+{-0x1.03fffffffc000p-192, -0x1.ffffffc000000p-267, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554, 0x1.0003ffffff000p+649, 0x1.ffc0000000000p+554},
+{-0x1.03fffffffc000p-192, -0x1.ffffffc000000p-267, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554, -0x1.0003ffffff000p+649, -0x1.ffc0000000000p+554},
+{0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230, 0x1.0000000000004p-464, -0x1.fffc000200000p-533, 0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230},
+{0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230, -0x1.0000000000004p-464, 0x1.fffc000200000p-533, 0x1.07ffffff80000p+301, 0x1.8007ffffc0000p+230},
+{-0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230, 0x1.0000000000004p-464, -0x1.fffc000200000p-533, -0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230},
+{-0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230, -0x1.0000000000004p-464, 0x1.fffc000200000p-533, -0x1.07ffffff80000p+301, -0x1.8007ffffc0000p+230},
+{0x1.00003ffffff80p-1007, 0x1.0000000000000p-1068, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{0x1.00003ffffff80p-1007, 0x1.0000000000000p-1068, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{-0x1.00003ffffff80p-1007, -0x1.0000000000000p-1068, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0, 0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{-0x1.00003ffffff80p-1007, -0x1.0000000000000p-1068, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0, -0x1.00003fffffff8p+0, 0x0.0000000000000p+0},
+{0x1.0000010000000p-912, -0x1.0000000000000p-1017, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60},
+{0x1.0000010000000p-912, -0x1.0000000000000p-1017, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60},
+{-0x1.0000010000000p-912, 0x1.0000000000000p-1017, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60, 0x1.00f81ffffff81p+122, 0x1.fffff03c00000p+60},
+{-0x1.0000010000000p-912, 0x1.0000000000000p-1017, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60, -0x1.00f81ffffff81p+122, -0x1.fffff03c00000p+60},
+{0x1.0000000000004p+652, -0x1.fff0008000000p+588, 0x1.0000000100000p+402, -0x1.fffffe0004000p+335, 0x1.0000000000004p+652, -0x1.fff0008000000p+588},
+{0x1.0000000000004p+652, -0x1.fff0008000000p+588, -0x1.0000000100000p+402, 0x1.fffffe0004000p+335, 0x1.0000000000004p+652, -0x1.fff0008000000p+588},
+{-0x1.0000000000004p+652, 0x1.fff0008000000p+588, 0x1.0000000100000p+402, -0x1.fffffe0004000p+335, -0x1.0000000000004p+652, 0x1.fff0008000000p+588},
+{-0x1.0000000000004p+652, 0x1.fff0008000000p+588, -0x1.0000000100000p+402, 0x1.fffffe0004000p+335, -0x1.0000000000004p+652, 0x1.fff0008000000p+588},
+{0x1.0000000000800p-11, -0x1.0000000000000p-89, 0x1.0000010000000p+68, -0x1.0000000000000p-35, 0x1.0000010000000p+68, 0x1.fffffe0000000p-12},
+{0x1.0000000000800p-11, -0x1.0000000000000p-89, -0x1.0000010000000p+68, 0x1.0000000000000p-35, -0x1.0000010000000p+68, 0x1.0000010000000p-11},
+{-0x1.0000000000800p-11, 0x1.0000000000000p-89, 0x1.0000010000000p+68, -0x1.0000000000000p-35, 0x1.0000010000000p+68, -0x1.0000010000000p-11},
+{-0x1.0000000000800p-11, 0x1.0000000000000p-89, -0x1.0000010000000p+68, 0x1.0000000000000p-35, -0x1.0000010000000p+68, -0x1.fffffe0000000p-12},
+{0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842, 0x1.0000007c00000p-1007, 0x0.0000000000000p+0, 0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842},
+{0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842, -0x1.0000007c00000p-1007, -0x0.0000000000000p+0, 0x1.00000007fff00p+898, 0x1.fffc1ffff87f0p+842},
+{-0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842, 0x1.0000007c00000p-1007, 0x0.0000000000000p+0, -0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842},
+{-0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842, -0x1.0000007c00000p-1007, -0x0.0000000000000p+0, -0x1.00000007fff00p+898, -0x1.fffc1ffff87f0p+842},
+{0x1.fffffffe00000p+397, 0x1.e000001fff800p+333, 0x1.00000001ffffep+347, 0x0.0000000000000p+0, 0x1.fffffffe00004p+397, 0x1.e000801ff7800p+333},
+{0x1.fffffffe00000p+397, 0x1.e000001fff800p+333, -0x1.00000001ffffep+347, 0x0.0000000000000p+0, 0x1.fffffffdffffcp+397, 0x1.dfff802007800p+333},
+{-0x1.fffffffe00000p+397, -0x1.e000001fff800p+333, 0x1.00000001ffffep+347, 0x0.0000000000000p+0, -0x1.fffffffdffffcp+397, -0x1.dfff802007800p+333},
+{-0x1.fffffffe00000p+397, -0x1.e000001fff800p+333, -0x1.00000001ffffep+347, 0x0.0000000000000p+0, -0x1.fffffffe00004p+397, -0x1.e000801ff7800p+333},
+{0x1.0000000000008p-231, -0x1.fffff00400000p-303, 0x1.00003ffffe000p-829, 0x1.ffffe00000000p-901, 0x1.0000000000008p-231, -0x1.fffff00400000p-303},
+{0x1.0000000000008p-231, -0x1.fffff00400000p-303, -0x1.00003ffffe000p-829, -0x1.ffffe00000000p-901, 0x1.0000000000008p-231, -0x1.fffff00400000p-303},
+{-0x1.0000000000008p-231, 0x1.fffff00400000p-303, 0x1.00003ffffe000p-829, 0x1.ffffe00000000p-901, -0x1.0000000000008p-231, 0x1.fffff00400000p-303},
+{-0x1.0000000000008p-231, 0x1.fffff00400000p-303, -0x1.00003ffffe000p-829, -0x1.ffffe00000000p-901, -0x1.0000000000008p-231, 0x1.fffff00400000p-303},
+{0x1.0000000000000p-479, 0x1.ffffffffffc00p-542, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414},
+{0x1.0000000000000p-479, 0x1.ffffffffffc00p-542, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414},
+{-0x1.0000000000000p-479, -0x1.ffffffffffc00p-542, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414, 0x1.000001ffe0000p-355, 0x1.ff87ff9f801c0p-414},
+{-0x1.0000000000000p-479, -0x1.ffffffffffc00p-542, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414, -0x1.000001ffe0000p-355, -0x1.ff87ff9f801c0p-414},
+{0x1.0000000000400p-496, -0x1.f800000002000p-557, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116},
+{0x1.0000000000400p-496, -0x1.f800000002000p-557, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116},
+{-0x1.0000000000400p-496, 0x1.f800000002000p-557, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116, 0x1.03fffffffff00p-62, 0x1.fffe7fffffffep-116},
+{-0x1.0000000000400p-496, 0x1.f800000002000p-557, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116, -0x1.03fffffffff00p-62, -0x1.fffe7fffffffep-116},
+{0x1.0000000000000p+267, 0x1.fffffffffff00p+211, 0x1.000007c000000p+439, 0x1.fff8000000000p+383, 0x1.000007c000000p+439, 0x1.fff8000000000p+383},
+{0x1.0000000000000p+267, 0x1.fffffffffff00p+211, -0x1.000007c000000p+439, -0x1.fff8000000000p+383, -0x1.000007c000000p+439, -0x1.fff8000000000p+383},
+{-0x1.0000000000000p+267, -0x1.fffffffffff00p+211, 0x1.000007c000000p+439, 0x1.fff8000000000p+383, 0x1.000007c000000p+439, 0x1.fff8000000000p+383},
+{-0x1.0000000000000p+267, -0x1.fffffffffff00p+211, -0x1.000007c000000p+439, -0x1.fff8000000000p+383, -0x1.000007c000000p+439, -0x1.fff8000000000p+383},
+{0x1.0000000000400p-383, -0x1.fffc0003fffd0p-440, 0x1.0000000000000p+249, 0x1.fffffff800000p+193, 0x1.0000000000000p+249, 0x1.fffffff800000p+193},
+{0x1.0000000000400p-383, -0x1.fffc0003fffd0p-440, -0x1.0000000000000p+249, -0x1.fffffff800000p+193, -0x1.0000000000000p+249, -0x1.fffffff800000p+193},
+{-0x1.0000000000400p-383, 0x1.fffc0003fffd0p-440, 0x1.0000000000000p+249, 0x1.fffffff800000p+193, 0x1.0000000000000p+249, 0x1.fffffff800000p+193},
+{-0x1.0000000000400p-383, 0x1.fffc0003fffd0p-440, -0x1.0000000000000p+249, -0x1.fffffff800000p+193, -0x1.0000000000000p+249, -0x1.fffffff800000p+193},
+{0x1.0000000002000p-673, -0x1.ffff040000000p-744, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862},
+{0x1.0000000002000p-673, -0x1.ffff040000000p-744, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862},
+{-0x1.0000000002000p-673, 0x1.ffff040000000p-744, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862, 0x1.03fffff800000p+930, 0x1.fffffe0000000p+862},
+{-0x1.0000000002000p-673, 0x1.ffff040000000p-744, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862, -0x1.03fffff800000p+930, -0x1.fffffe0000000p+862},
+{0x1.0000008000000p+436, -0x1.ffffff8200000p+379, 0x1.000fff8000000p-8, 0x1.fffffe0000000p-70, 0x1.0000008000000p+436, -0x1.ffffff8200000p+379},
+{0x1.0000008000000p+436, -0x1.ffffff8200000p+379, -0x1.000fff8000000p-8, -0x1.fffffe0000000p-70, 0x1.0000008000000p+436, -0x1.ffffff8200000p+379},
+{-0x1.0000008000000p+436, 0x1.ffffff8200000p+379, 0x1.000fff8000000p-8, 0x1.fffffe0000000p-70, -0x1.0000008000000p+436, 0x1.ffffff8200000p+379},
+{-0x1.0000008000000p+436, 0x1.ffffff8200000p+379, -0x1.000fff8000000p-8, -0x1.fffffe0000000p-70, -0x1.0000008000000p+436, 0x1.ffffff8200000p+379},
+{0x1.0000000000000p+138, 0x1.0001f9e000000p+78, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366},
+{0x1.0000000000000p+138, 0x1.0001f9e000000p+78, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366},
+{-0x1.0000000000000p+138, -0x1.0001f9e000000p+78, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366, 0x1.0000000000040p+438, -0x1.fffffc0080000p+366},
+{-0x1.0000000000000p+138, -0x1.0001f9e000000p+78, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366, -0x1.0000000000040p+438, 0x1.fffffc0080000p+366},
+{0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888, 0x1.0000010000000p+582, -0x1.ffc007ffffe20p+524, 0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888},
+{0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888, -0x1.0000010000000p+582, 0x1.ffc007ffffe20p+524, 0x1.0000ff0007e00p+955, 0x1.ffc001ff00000p+888},
+{-0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888, 0x1.0000010000000p+582, -0x1.ffc007ffffe20p+524, -0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888},
+{-0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888, -0x1.0000010000000p+582, 0x1.ffc007ffffe20p+524, -0x1.0000ff0007e00p+955, -0x1.ffc001ff00000p+888},
+{0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694, 0x1.0040000000000p-580, -0x1.c000000400000p-641, 0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694},
+{0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694, -0x1.0040000000000p-580, 0x1.c000000400000p-641, 0x1.07ffffff1fe00p+791, 0x1.fc00000000000p+694},
+{-0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694, 0x1.0040000000000p-580, -0x1.c000000400000p-641, -0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694},
+{-0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694, -0x1.0040000000000p-580, 0x1.c000000400000p-641, -0x1.07ffffff1fe00p+791, -0x1.fc00000000000p+694},
+{0x1.0080000000000p-806, -0x1.0000000000000p-911, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541},
+{0x1.0080000000000p-806, -0x1.0000000000000p-911, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541},
+{-0x1.0080000000000p-806, 0x1.0000000000000p-911, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541, 0x1.00000001fffc0p+613, 0x1.fffff80f80000p+541},
+{-0x1.0080000000000p-806, 0x1.0000000000000p-911, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541, -0x1.00000001fffc0p+613, -0x1.fffff80f80000p+541},
+{0x1.000000003ff00p-698, 0x0.0000000000000p+0, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362},
+{0x1.000000003ff00p-698, 0x0.0000000000000p+0, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362},
+{-0x1.000000003ff00p-698, 0x0.0000000000000p+0, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362, 0x1.0000000000000p-302, 0x1.f83007ffffe00p-362},
+{-0x1.000000003ff00p-698, 0x0.0000000000000p+0, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362, -0x1.0000000000000p-302, -0x1.f83007ffffe00p-362},
+{0x1.00003fffffe00p-546, 0x1.fffffc0000380p-606, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386},
+{0x1.00003fffffe00p-546, 0x1.fffffc0000380p-606, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386},
+{-0x1.00003fffffe00p-546, -0x1.fffffc0000380p-606, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386, 0x1.0000010000000p-330, -0x1.ffffff8000008p-386},
+{-0x1.00003fffffe00p-546, -0x1.fffffc0000380p-606, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386, -0x1.0000010000000p-330, 0x1.ffffff8000008p-386},
+{0x1.0000000080000p-450, -0x1.fffffc0010000p-519, 0x1.3fffff8000000p-829, 0x1.fffff800fe000p-895, 0x1.0000000080000p-450, -0x1.fffffc0010000p-519},
+{0x1.0000000080000p-450, -0x1.fffffc0010000p-519, -0x1.3fffff8000000p-829, -0x1.fffff800fe000p-895, 0x1.0000000080000p-450, -0x1.fffffc0010000p-519},
+{-0x1.0000000080000p-450, 0x1.fffffc0010000p-519, 0x1.3fffff8000000p-829, 0x1.fffff800fe000p-895, -0x1.0000000080000p-450, 0x1.fffffc0010000p-519},
+{-0x1.0000000080000p-450, 0x1.fffffc0010000p-519, -0x1.3fffff8000000p-829, -0x1.fffff800fe000p-895, -0x1.0000000080000p-450, 0x1.fffffc0010000p-519},
+{0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794, 0x1.0000000000000p+214, 0x1.fc1fffc0000fep+160, 0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794},
+{0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794, -0x1.0000000000000p+214, -0x1.fc1fffc0000fep+160, 0x1.0003f001fc3f0p+850, 0x1.fffffc0000000p+794},
+{-0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794, 0x1.0000000000000p+214, 0x1.fc1fffc0000fep+160, -0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794},
+{-0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794, -0x1.0000000000000p+214, -0x1.fc1fffc0000fep+160, -0x1.0003f001fc3f0p+850, -0x1.fffffc0000000p+794},
+{0x1.0000000000000p+702, 0x1.fffffffffffc0p+643, 0x1.0000000000000p-646, 0x1.ffffffffffe00p-708, 0x1.0000000000000p+702, 0x1.fffffffffffc0p+643},
+{0x1.0000000000000p+702, 0x1.fffffffffffc0p+643, -0x1.0000000000000p-646, -0x1.ffffffffffe00p-708, 0x1.0000000000000p+702, 0x1.fffffffffffc0p+643},
+{-0x1.0000000000000p+702, -0x1.fffffffffffc0p+643, 0x1.0000000000000p-646, 0x1.ffffffffffe00p-708, -0x1.0000000000000p+702, -0x1.fffffffffffc0p+643},
+{-0x1.0000000000000p+702, -0x1.fffffffffffc0p+643, -0x1.0000000000000p-646, -0x1.ffffffffffe00p-708, -0x1.0000000000000p+702, -0x1.fffffffffffc0p+643},
+{0x1.0000000100000p+167, -0x1.0000000000000p+88, 0x1.0000004000000p+455, -0x1.0000000000000p+375, 0x1.0000004000000p+455, -0x1.0000000000000p+375},
+{0x1.0000000100000p+167, -0x1.0000000000000p+88, -0x1.0000004000000p+455, 0x1.0000000000000p+375, -0x1.0000004000000p+455, 0x1.0000000000000p+375},
+{-0x1.0000000100000p+167, 0x1.0000000000000p+88, 0x1.0000004000000p+455, -0x1.0000000000000p+375, 0x1.0000004000000p+455, -0x1.0000000000000p+375},
+{-0x1.0000000100000p+167, 0x1.0000000000000p+88, -0x1.0000004000000p+455, 0x1.0000000000000p+375, -0x1.0000004000000p+455, 0x1.0000000000000p+375},
+{0x1.0000010000000p+394, -0x1.ffffe00001000p+338, 0x1.000ffffff007fp-145, 0x1.ffffc00000000p-226, 0x1.0000010000000p+394, -0x1.ffffe00001000p+338},
+{0x1.0000010000000p+394, -0x1.ffffe00001000p+338, -0x1.000ffffff007fp-145, -0x1.ffffc00000000p-226, 0x1.0000010000000p+394, -0x1.ffffe00001000p+338},
+{-0x1.0000010000000p+394, 0x1.ffffe00001000p+338, 0x1.000ffffff007fp-145, 0x1.ffffc00000000p-226, -0x1.0000010000000p+394, 0x1.ffffe00001000p+338},
+{-0x1.0000010000000p+394, 0x1.ffffe00001000p+338, -0x1.000ffffff007fp-145, -0x1.ffffc00000000p-226, -0x1.0000010000000p+394, 0x1.ffffe00001000p+338},
+{0x1.1000fffffc000p+16, 0x1.fffffc003f000p-40, 0x1.0000000001000p+243, -0x1.0000000000000p+138, 0x1.0000000001000p+243, -0x1.0000000000000p+138},
+{0x1.1000fffffc000p+16, 0x1.fffffc003f000p-40, -0x1.0000000001000p+243, 0x1.0000000000000p+138, -0x1.0000000001000p+243, 0x1.0000000000000p+138},
+{-0x1.1000fffffc000p+16, -0x1.fffffc003f000p-40, 0x1.0000000001000p+243, -0x1.0000000000000p+138, 0x1.0000000001000p+243, -0x1.0000000000000p+138},
+{-0x1.1000fffffc000p+16, -0x1.fffffc003f000p-40, -0x1.0000000001000p+243, 0x1.0000000000000p+138, -0x1.0000000001000p+243, 0x1.0000000000000p+138},
+{0x1.00000fff80000p+494, 0x1.fffe000000000p+409, 0x1.0000001f00000p-623, 0x1.fffffff000000p-700, 0x1.00000fff80000p+494, 0x1.fffe000000000p+409},
+{0x1.00000fff80000p+494, 0x1.fffe000000000p+409, -0x1.0000001f00000p-623, -0x1.fffffff000000p-700, 0x1.00000fff80000p+494, 0x1.fffe000000000p+409},
+{-0x1.00000fff80000p+494, -0x1.fffe000000000p+409, 0x1.0000001f00000p-623, 0x1.fffffff000000p-700, -0x1.00000fff80000p+494, -0x1.fffe000000000p+409},
+{-0x1.00000fff80000p+494, -0x1.fffe000000000p+409, -0x1.0000001f00000p-623, -0x1.fffffff000000p-700, -0x1.00000fff80000p+494, -0x1.fffe000000000p+409},
+{0x1.3fdfffff02000p-533, -0x1.0000000000000p-611, 0x1.0000000000000p-602, 0x1.ffffffffffe00p-663, 0x1.3fdfffff02000p-533, 0x1.ff00000000000p-603},
+{0x1.3fdfffff02000p-533, -0x1.0000000000000p-611, -0x1.0000000000000p-602, -0x1.ffffffffffe00p-663, 0x1.3fdfffff02000p-533, -0x1.0080000000000p-602},
+{-0x1.3fdfffff02000p-533, 0x1.0000000000000p-611, 0x1.0000000000000p-602, 0x1.ffffffffffe00p-663, -0x1.3fdfffff02000p-533, 0x1.0080000000000p-602},
+{-0x1.3fdfffff02000p-533, 0x1.0000000000000p-611, -0x1.0000000000000p-602, -0x1.ffffffffffe00p-663, -0x1.3fdfffff02000p-533, -0x1.ff00000000000p-603},
+{0x1.0000000000008p-274, -0x1.e0ffffd002000p-340, 0x1.0000000000400p-229, 0x1.ffffffff03ffep-283, 0x1.0000000000480p-229, 0x1.ffffffff04ffep-283},
+{0x1.0000000000008p-274, -0x1.e0ffffd002000p-340, -0x1.0000000000400p-229, -0x1.ffffffff03ffep-283, -0x1.0000000000380p-229, -0x1.ffffffff02ffep-283},
+{-0x1.0000000000008p-274, 0x1.e0ffffd002000p-340, 0x1.0000000000400p-229, 0x1.ffffffff03ffep-283, 0x1.0000000000380p-229, 0x1.ffffffff02ffep-283},
+{-0x1.0000000000008p-274, 0x1.e0ffffd002000p-340, -0x1.0000000000400p-229, -0x1.ffffffff03ffep-283, -0x1.0000000000480p-229, -0x1.ffffffff04ffep-283},
+{0x1.000000fffe020p-113, -0x1.f800100000000p-186, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84},
+{0x1.000000fffe020p-113, -0x1.f800100000000p-186, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84},
+{-0x1.000000fffe020p-113, 0x1.f800100000000p-186, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84, 0x1.0001fff80ffc0p+13, 0x1.ff00000000000p-84},
+{-0x1.000000fffe020p-113, 0x1.f800100000000p-186, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84, -0x1.0001fff80ffc0p+13, -0x1.ff00000000000p-84},
+{0x1.4000000000000p+455, -0x1.0000000000000p+350, 0x1.0000000000010p-968, 0x1.e000000000000p-1036, 0x1.4000000000000p+455, -0x1.0000000000000p+350},
+{0x1.4000000000000p+455, -0x1.0000000000000p+350, -0x1.0000000000010p-968, -0x1.e000000000000p-1036, 0x1.4000000000000p+455, -0x1.0000000000000p+350},
+{-0x1.4000000000000p+455, 0x1.0000000000000p+350, 0x1.0000000000010p-968, 0x1.e000000000000p-1036, -0x1.4000000000000p+455, 0x1.0000000000000p+350},
+{-0x1.4000000000000p+455, 0x1.0000000000000p+350, -0x1.0000000000010p-968, -0x1.e000000000000p-1036, -0x1.4000000000000p+455, 0x1.0000000000000p+350},
+{0x1.2000000000000p+333, -0x1.fffffff01ff20p+276, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644},
+{0x1.2000000000000p+333, -0x1.fffffff01ff20p+276, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644},
+{-0x1.2000000000000p+333, 0x1.fffffff01ff20p+276, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644, 0x1.0000000000000p+701, 0x1.fff8003ff0000p+644},
+{-0x1.2000000000000p+333, 0x1.fffffff01ff20p+276, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644, -0x1.0000000000000p+701, -0x1.fff8003ff0000p+644},
+{0x1.2000000000000p+275, -0x1.fc08000000000p+183, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681},
+{0x1.2000000000000p+275, -0x1.fc08000000000p+183, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681},
+{-0x1.2000000000000p+275, 0x1.fc08000000000p+183, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681, 0x1.0000000038004p+750, -0x1.fffffc4000000p+681},
+{-0x1.2000000000000p+275, 0x1.fc08000000000p+183, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681, -0x1.0000000038004p+750, 0x1.fffffc4000000p+681},
+{0x1.0000000000200p+680, 0x0.0000000000000p+0, 0x1.00001ffff0000p-146, 0x1.ffff80001f000p-203, 0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{0x1.0000000000200p+680, 0x0.0000000000000p+0, -0x1.00001ffff0000p-146, -0x1.ffff80001f000p-203, 0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{-0x1.0000000000200p+680, 0x0.0000000000000p+0, 0x1.00001ffff0000p-146, 0x1.ffff80001f000p-203, -0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{-0x1.0000000000200p+680, 0x0.0000000000000p+0, -0x1.00001ffff0000p-146, -0x1.ffff80001f000p-203, -0x1.0000000000200p+680, 0x0.0000000000000p+0},
+{0x1.0000100000000p-400, -0x1.0000000000000p-505, 0x1.0038000800000p-754, -0x1.fffffe0000080p-814, 0x1.0000100000000p-400, -0x1.0000000000000p-505},
+{0x1.0000100000000p-400, -0x1.0000000000000p-505, -0x1.0038000800000p-754, 0x1.fffffe0000080p-814, 0x1.0000100000000p-400, -0x1.0000000000000p-505},
+{-0x1.0000100000000p-400, 0x1.0000000000000p-505, 0x1.0038000800000p-754, -0x1.fffffe0000080p-814, -0x1.0000100000000p-400, 0x1.0000000000000p-505},
+{-0x1.0000100000000p-400, 0x1.0000000000000p-505, -0x1.0038000800000p-754, 0x1.fffffe0000080p-814, -0x1.0000100000000p-400, 0x1.0000000000000p-505},
+{0x1.0000000000004p+838, -0x1.ffffe00400000p+765, 0x1.0000000000000p-355, 0x1.ffffffffffff8p-411, 0x1.0000000000004p+838, -0x1.ffffe00400000p+765},
+{0x1.0000000000004p+838, -0x1.ffffe00400000p+765, -0x1.0000000000000p-355, -0x1.ffffffffffff8p-411, 0x1.0000000000004p+838, -0x1.ffffe00400000p+765},
+{-0x1.0000000000004p+838, 0x1.ffffe00400000p+765, 0x1.0000000000000p-355, 0x1.ffffffffffff8p-411, -0x1.0000000000004p+838, 0x1.ffffe00400000p+765},
+{-0x1.0000000000004p+838, 0x1.ffffe00400000p+765, -0x1.0000000000000p-355, -0x1.ffffffffffff8p-411, -0x1.0000000000004p+838, 0x1.ffffe00400000p+765},
+{0x1.0000000000100p+877, -0x1.ffffe7e400000p+807, 0x1.1ffe000008000p+922, -0x1.fffc000004000p+855, 0x1.1ffe000008080p+922, -0x1.fffbfc0004000p+855},
+{0x1.0000000000100p+877, -0x1.ffffe7e400000p+807, -0x1.1ffe000008000p+922, 0x1.fffc000004000p+855, -0x1.1ffe000007f80p+922, 0x1.fffc040004000p+855},
+{-0x1.0000000000100p+877, 0x1.ffffe7e400000p+807, 0x1.1ffe000008000p+922, -0x1.fffc000004000p+855, 0x1.1ffe000007f80p+922, -0x1.fffc040004000p+855},
+{-0x1.0000000000100p+877, 0x1.ffffe7e400000p+807, -0x1.1ffe000008000p+922, 0x1.fffc000004000p+855, -0x1.1ffe000008080p+922, 0x1.fffbfc0004000p+855},
+{0x1.0000000000004p-490, -0x1.0000000000000p-595, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413},
+{0x1.0000000000004p-490, -0x1.0000000000000p-595, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413},
+{-0x1.0000000000004p-490, 0x1.0000000000000p-595, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413, 0x1.00000007ffffep-352, 0x1.ffffe000f0000p-413},
+{-0x1.0000000000004p-490, 0x1.0000000000000p-595, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413, -0x1.00000007ffffep-352, -0x1.ffffe000f0000p-413},
+{0x1.0000000000000p-458, 0x1.fffffff000000p-519, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712},
+{0x1.0000000000000p-458, 0x1.fffffff000000p-519, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712},
+{-0x1.0000000000000p-458, -0x1.fffffff000000p-519, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712, 0x1.0001fffc00001p+791, -0x1.0000000000000p+712},
+{-0x1.0000000000000p-458, -0x1.fffffff000000p-519, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712, -0x1.0001fffc00001p+791, 0x1.0000000000000p+712},
+{0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803, 0x1.0080000000000p-983, -0x0.0000000000000p+0, 0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803},
+{0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803, -0x1.0080000000000p-983, 0x0.0000000000000p+0, 0x1.00007fdfffff0p-745, 0x1.fff000f803fe0p-803},
+{-0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803, 0x1.0080000000000p-983, -0x0.0000000000000p+0, -0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803},
+{-0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803, -0x1.0080000000000p-983, 0x0.0000000000000p+0, -0x1.00007fdfffff0p-745, -0x1.fff000f803fe0p-803},
+{0x1.0000000000080p-788, 0x0.0000000000000p+0, 0x1.0000080000000p+973, -0x1.0000000000000p+888, 0x1.0000080000000p+973, -0x1.0000000000000p+888},
+{0x1.0000000000080p-788, 0x0.0000000000000p+0, -0x1.0000080000000p+973, 0x1.0000000000000p+888, -0x1.0000080000000p+973, 0x1.0000000000000p+888},
+{-0x1.0000000000080p-788, 0x0.0000000000000p+0, 0x1.0000080000000p+973, -0x1.0000000000000p+888, 0x1.0000080000000p+973, -0x1.0000000000000p+888},
+{-0x1.0000000000080p-788, 0x0.0000000000000p+0, -0x1.0000080000000p+973, 0x1.0000000000000p+888, -0x1.0000080000000p+973, 0x1.0000000000000p+888},
+{0x1.0400000000000p-287, -0x1.0000000000000p-392, 0x1.0000000000400p+736, -0x1.fffff00008000p+680, 0x1.0000000000400p+736, -0x1.fffff00008000p+680},
+{0x1.0400000000000p-287, -0x1.0000000000000p-392, -0x1.0000000000400p+736, 0x1.fffff00008000p+680, -0x1.0000000000400p+736, 0x1.fffff00008000p+680},
+{-0x1.0400000000000p-287, 0x1.0000000000000p-392, 0x1.0000000000400p+736, -0x1.fffff00008000p+680, 0x1.0000000000400p+736, -0x1.fffff00008000p+680},
+{-0x1.0400000000000p-287, 0x1.0000000000000p-392, -0x1.0000000000400p+736, 0x1.fffff00008000p+680, -0x1.0000000000400p+736, 0x1.fffff00008000p+680},
+{0x1.0000000000001p+232, -0x1.fc0000c004000p+167, 0x1.0000000000200p+192, -0x1.ffe0000200000p+124, 0x1.0000000001001p+232, -0x1.fbffc0c004000p+167},
+{0x1.0000000000001p+232, -0x1.fc0000c004000p+167, -0x1.0000000000200p+192, 0x1.ffe0000200000p+124, 0x1.fffffffffe002p+231, -0x1.fc0040c004000p+167},
+{-0x1.0000000000001p+232, 0x1.fc0000c004000p+167, 0x1.0000000000200p+192, -0x1.ffe0000200000p+124, -0x1.fffffffffe002p+231, 0x1.fc0040c004000p+167},
+{-0x1.0000000000001p+232, 0x1.fc0000c004000p+167, -0x1.0000000000200p+192, 0x1.ffe0000200000p+124, -0x1.0000000001001p+232, 0x1.fbffc0c004000p+167},
+{0x1.00000c0000004p+583, -0x1.ff80000800000p+515, 0x1.18003ffff8000p-786, 0x1.ffffff8000000p-852, 0x1.00000c0000004p+583, -0x1.ff80000800000p+515},
+{0x1.00000c0000004p+583, -0x1.ff80000800000p+515, -0x1.18003ffff8000p-786, -0x1.ffffff8000000p-852, 0x1.00000c0000004p+583, -0x1.ff80000800000p+515},
+{-0x1.00000c0000004p+583, 0x1.ff80000800000p+515, 0x1.18003ffff8000p-786, 0x1.ffffff8000000p-852, -0x1.00000c0000004p+583, 0x1.ff80000800000p+515},
+{-0x1.00000c0000004p+583, 0x1.ff80000800000p+515, -0x1.18003ffff8000p-786, -0x1.ffffff8000000p-852, -0x1.00000c0000004p+583, 0x1.ff80000800000p+515},
+{0x1.1ffff80000040p+488, -0x1.0000000000000p+398, 0x1.000000000fe00p-510, 0x1.ffff7e0003ff8p-566, 0x1.1ffff80000040p+488, -0x1.0000000000000p+398},
+{0x1.1ffff80000040p+488, -0x1.0000000000000p+398, -0x1.000000000fe00p-510, -0x1.ffff7e0003ff8p-566, 0x1.1ffff80000040p+488, -0x1.0000000000000p+398},
+{-0x1.1ffff80000040p+488, 0x1.0000000000000p+398, 0x1.000000000fe00p-510, 0x1.ffff7e0003ff8p-566, -0x1.1ffff80000040p+488, 0x1.0000000000000p+398},
+{-0x1.1ffff80000040p+488, 0x1.0000000000000p+398, -0x1.000000000fe00p-510, -0x1.ffff7e0003ff8p-566, -0x1.1ffff80000040p+488, 0x1.0000000000000p+398},
+{0x1.3fc0000040000p+871, -0x1.fffffff802000p+815, 0x1.fffffffffff00p-663, 0x0.0000000000000p+0, 0x1.3fc0000040000p+871, -0x1.fffffff802000p+815},
+{0x1.3fc0000040000p+871, -0x1.fffffff802000p+815, -0x1.fffffffffff00p-663, 0x0.0000000000000p+0, 0x1.3fc0000040000p+871, -0x1.fffffff802000p+815},
+{-0x1.3fc0000040000p+871, 0x1.fffffff802000p+815, 0x1.fffffffffff00p-663, 0x0.0000000000000p+0, -0x1.3fc0000040000p+871, 0x1.fffffff802000p+815},
+{-0x1.3fc0000040000p+871, 0x1.fffffff802000p+815, -0x1.fffffffffff00p-663, 0x0.0000000000000p+0, -0x1.3fc0000040000p+871, 0x1.fffffff802000p+815},
+{0x1.00000001fffffp-628, 0x1.00001f8000000p-699, 0x1.0000000000200p-312, -0x1.0000000000000p-417, 0x1.0000000000200p-312, -0x1.0000000000000p-417},
+{0x1.00000001fffffp-628, 0x1.00001f8000000p-699, -0x1.0000000000200p-312, 0x1.0000000000000p-417, -0x1.0000000000200p-312, 0x1.0000000000000p-417},
+{-0x1.00000001fffffp-628, -0x1.00001f8000000p-699, 0x1.0000000000200p-312, -0x1.0000000000000p-417, 0x1.0000000000200p-312, -0x1.0000000000000p-417},
+{-0x1.00000001fffffp-628, -0x1.00001f8000000p-699, -0x1.0000000000200p-312, 0x1.0000000000000p-417, -0x1.0000000000200p-312, 0x1.0000000000000p-417},
+{0x1.0000000010000p+23, -0x1.0000000000000p-54, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268},
+{0x1.0000000010000p+23, -0x1.0000000000000p-54, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268},
+{-0x1.0000000010000p+23, 0x1.0000000000000p-54, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268, 0x1.1fff010000000p+322, 0x1.ff8c0000007fep+268},
+{-0x1.0000000010000p+23, 0x1.0000000000000p-54, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268, -0x1.1fff010000000p+322, -0x1.ff8c0000007fep+268},
+{0x1.0000000000002p-4, -0x1.0000000000000p-91, 0x1.0000000000200p+643, -0x1.0000000000000p+558, 0x1.0000000000200p+643, -0x1.0000000000000p+558},
+{0x1.0000000000002p-4, -0x1.0000000000000p-91, -0x1.0000000000200p+643, 0x1.0000000000000p+558, -0x1.0000000000200p+643, 0x1.0000000000000p+558},
+{-0x1.0000000000002p-4, 0x1.0000000000000p-91, 0x1.0000000000200p+643, -0x1.0000000000000p+558, 0x1.0000000000200p+643, -0x1.0000000000000p+558},
+{-0x1.0000000000002p-4, 0x1.0000000000000p-91, -0x1.0000000000200p+643, 0x1.0000000000000p+558, -0x1.0000000000200p+643, 0x1.0000000000000p+558},
+{0x1.0000000000002p-252, -0x1.ffff800008000p-319, 0x1.000000003fffep-236, 0x1.f81fc007c0000p-307, 0x1.000100003fffep-236, 0x1.1f7ffc00fc000p-303},
+{0x1.0000000000002p-252, -0x1.ffff800008000p-319, -0x1.000000003fffep-236, -0x1.f81fc007c0000p-307, -0x1.fffe00007fffcp-237, 0x1.c0f8080008000p-304},
+{-0x1.0000000000002p-252, 0x1.ffff800008000p-319, 0x1.000000003fffep-236, 0x1.f81fc007c0000p-307, 0x1.fffe00007fffcp-237, -0x1.c0f8080008000p-304},
+{-0x1.0000000000002p-252, 0x1.ffff800008000p-319, -0x1.000000003fffep-236, -0x1.f81fc007c0000p-307, -0x1.000100003fffep-236, -0x1.1f7ffc00fc000p-303},
+{0x1.7ffffffff0000p-1014, 0x0.0000000000000p+0, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957},
+{0x1.7ffffffff0000p-1014, 0x0.0000000000000p+0, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957},
+{-0x1.7ffffffff0000p-1014, -0x0.0000000000000p+0, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957, 0x1.000000000ffe0p-894, 0x1.ff0000003c000p-957},
+{-0x1.7ffffffff0000p-1014, -0x0.0000000000000p+0, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957, -0x1.000000000ffe0p-894, -0x1.ff0000003c000p-957},
+{0x1.00007fff00080p+981, -0x1.ffffff0001000p+916, 0x1.00000000007c0p-918, 0x1.ffffff8000000p-985, 0x1.00007fff00080p+981, -0x1.ffffff0001000p+916},
+{0x1.00007fff00080p+981, -0x1.ffffff0001000p+916, -0x1.00000000007c0p-918, -0x1.ffffff8000000p-985, 0x1.00007fff00080p+981, -0x1.ffffff0001000p+916},
+{-0x1.00007fff00080p+981, 0x1.ffffff0001000p+916, 0x1.00000000007c0p-918, 0x1.ffffff8000000p-985, -0x1.00007fff00080p+981, 0x1.ffffff0001000p+916},
+{-0x1.00007fff00080p+981, 0x1.ffffff0001000p+916, -0x1.00000000007c0p-918, -0x1.ffffff8000000p-985, -0x1.00007fff00080p+981, 0x1.ffffff0001000p+916},
+{0x1.1fff81ff00000p-768, 0x1.e007ffff00000p-825, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292},
+{0x1.1fff81ff00000p-768, 0x1.e007ffff00000p-825, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292},
+{-0x1.1fff81ff00000p-768, -0x1.e007ffff00000p-825, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292, 0x1.1ffffffff8000p-236, 0x1.fe001ffffffe0p-292},
+{-0x1.1fff81ff00000p-768, -0x1.e007ffff00000p-825, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292, -0x1.1ffffffff8000p-236, -0x1.fe001ffffffe0p-292},
+{0x1.0000000000000p-141, 0x1.fffc03fe00700p-202, 0x1.0000000000001p-845, -0x1.fff8060000f34p-900, 0x1.0000000000000p-141, 0x1.fffc03fe00700p-202},
+{0x1.0000000000000p-141, 0x1.fffc03fe00700p-202, -0x1.0000000000001p-845, 0x1.fff8060000f34p-900, 0x1.0000000000000p-141, 0x1.fffc03fe00700p-202},
+{-0x1.0000000000000p-141, -0x1.fffc03fe00700p-202, 0x1.0000000000001p-845, -0x1.fff8060000f34p-900, -0x1.0000000000000p-141, -0x1.fffc03fe00700p-202},
+{-0x1.0000000000000p-141, -0x1.fffc03fe00700p-202, -0x1.0000000000001p-845, 0x1.fff8060000f34p-900, -0x1.0000000000000p-141, -0x1.fffc03fe00700p-202},
+{0x1.001ffffc00080p+872, -0x1.fe00000200000p+811, 0x1.0000000001000p-359, -0x1.fe3ffffff0080p-419, 0x1.001ffffc00080p+872, -0x1.fe00000200000p+811},
+{0x1.001ffffc00080p+872, -0x1.fe00000200000p+811, -0x1.0000000001000p-359, 0x1.fe3ffffff0080p-419, 0x1.001ffffc00080p+872, -0x1.fe00000200000p+811},
+{-0x1.001ffffc00080p+872, 0x1.fe00000200000p+811, 0x1.0000000001000p-359, -0x1.fe3ffffff0080p-419, -0x1.001ffffc00080p+872, 0x1.fe00000200000p+811},
+{-0x1.001ffffc00080p+872, 0x1.fe00000200000p+811, -0x1.0000000001000p-359, 0x1.fe3ffffff0080p-419, -0x1.001ffffc00080p+872, 0x1.fe00000200000p+811},
+{0x1.00001fffff800p-894, 0x1.ffffff801ffc0p-953, 0x1.0000000002000p-720, -0x1.0000000000000p-825, 0x1.0000000002000p-720, -0x1.0000000000000p-825},
+{0x1.00001fffff800p-894, 0x1.ffffff801ffc0p-953, -0x1.0000000002000p-720, 0x1.0000000000000p-825, -0x1.0000000002000p-720, 0x1.0000000000000p-825},
+{-0x1.00001fffff800p-894, -0x1.ffffff801ffc0p-953, 0x1.0000000002000p-720, -0x1.0000000000000p-825, 0x1.0000000002000p-720, -0x1.0000000000000p-825},
+{-0x1.00001fffff800p-894, -0x1.ffffff801ffc0p-953, -0x1.0000000002000p-720, 0x1.0000000000000p-825, -0x1.0000000002000p-720, 0x1.0000000000000p-825},
+{0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86, 0x1.0000000000000p-240, 0x1.ffffffffe0000p-296, 0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86},
+{0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86, -0x1.0000000000000p-240, -0x1.ffffffffe0000p-296, 0x1.0000000000000p-30, 0x1.ffff83ffbfff0p-86},
+{-0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86, 0x1.0000000000000p-240, 0x1.ffffffffe0000p-296, -0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86},
+{-0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86, -0x1.0000000000000p-240, -0x1.ffffffffe0000p-296, -0x1.0000000000000p-30, -0x1.ffff83ffbfff0p-86},
+{0x1.0000000000000p-874, 0x1.fffe7ff3dff00p-935, 0x1.000007f830000p-977, 0x1.fff0001000000p-1038, 0x1.0000000000000p-874, 0x1.fffe7ff3e0300p-935},
+{0x1.0000000000000p-874, 0x1.fffe7ff3dff00p-935, -0x1.000007f830000p-977, -0x1.fff0001000000p-1038, 0x1.0000000000000p-874, 0x1.fffe7ff3dfb00p-935},
+{-0x1.0000000000000p-874, -0x1.fffe7ff3dff00p-935, 0x1.000007f830000p-977, 0x1.fff0001000000p-1038, -0x1.0000000000000p-874, -0x1.fffe7ff3dfb00p-935},
+{-0x1.0000000000000p-874, -0x1.fffe7ff3dff00p-935, -0x1.000007f830000p-977, -0x1.fff0001000000p-1038, -0x1.0000000000000p-874, -0x1.fffe7ff3e0300p-935},
+{0x1.00000ffffe000p-269, 0x1.fffffffffc000p-336, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171},
+{0x1.00000ffffe000p-269, 0x1.fffffffffc000p-336, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171},
+{-0x1.00000ffffe000p-269, -0x1.fffffffffc000p-336, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171, 0x1.0000000000002p+226, -0x1.fffffe01f8004p+171},
+{-0x1.00000ffffe000p-269, -0x1.fffffffffc000p-336, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171, -0x1.0000000000002p+226, 0x1.fffffe01f8004p+171},
+{0x1.0000000000060p+403, 0x1.fffe3fff00000p+340, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726},
+{0x1.0000000000060p+403, 0x1.fffe3fff00000p+340, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726},
+{-0x1.0000000000060p+403, -0x1.fffe3fff00000p+340, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726, 0x1.0000000002000p+783, -0x1.ffe0002000000p+726},
+{-0x1.0000000000060p+403, -0x1.fffe3fff00000p+340, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726, -0x1.0000000002000p+783, 0x1.ffe0002000000p+726},
+{0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347, 0x1.07ff000008000p-591, -0x1.e000020000000p-652, 0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347},
+{0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347, -0x1.07ff000008000p-591, 0x1.e000020000000p-652, 0x1.0003ffffffff8p-273, 0x1.ffffe07e00000p-347},
+{-0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347, 0x1.07ff000008000p-591, -0x1.e000020000000p-652, -0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347},
+{-0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347, -0x1.07ff000008000p-591, 0x1.e000020000000p-652, -0x1.0003ffffffff8p-273, -0x1.ffffe07e00000p-347},
+// Some test cases where a and b are guaranteed to overlap:
+{0x1.0000000000002p-39, -0x1.ffc0ffff90000p-103, 0x1.0003ffffffffcp-35, 0x1.ffffc00000000p-122, 0x1.1003ffffffffcp-35, 0x1.ffe003f400068p-91},
+{0x1.0000000000002p-39, -0x1.ffc0ffff90000p-103, -0x1.0003ffffffffcp-35, -0x1.ffffc00000000p-122, -0x1.e007ffffffff8p-36, 0x1.ffe003ec00078p-91},
+{-0x1.0000000000002p-39, 0x1.ffc0ffff90000p-103, 0x1.0003ffffffffcp-35, 0x1.ffffc00000000p-122, 0x1.e007ffffffff8p-36, -0x1.ffe003ec00078p-91},
+{-0x1.0000000000002p-39, 0x1.ffc0ffff90000p-103, -0x1.0003ffffffffcp-35, -0x1.ffffc00000000p-122, -0x1.1003ffffffffcp-35, -0x1.ffe003f400068p-91},
+{0x1.0000100000000p+23, -0x1.0000000000000p-39, 0x1.0000000004000p-41, -0x1.ffffe00fc0200p-97, 0x1.0000100000000p+23, -0x1.7ffffffffe000p-40},
+{0x1.0000100000000p+23, -0x1.0000000000000p-39, -0x1.0000000004000p-41, 0x1.ffffe00fc0200p-97, 0x1.0000100000000p+23, -0x1.4000000001000p-39},
+{-0x1.0000100000000p+23, 0x1.0000000000000p-39, 0x1.0000000004000p-41, -0x1.ffffe00fc0200p-97, -0x1.0000100000000p+23, 0x1.4000000001000p-39},
+{-0x1.0000100000000p+23, 0x1.0000000000000p-39, -0x1.0000000004000p-41, 0x1.ffffe00fc0200p-97, -0x1.0000100000000p+23, 0x1.7ffffffffe000p-40},
+{0x1.0000000800000p-42, -0x1.0000000000000p-114, 0x1.000003fffc002p-41, -0x1.0000000000000p-146, 0x1.80000403fc002p-41, -0x1.0000000100000p-114},
+{0x1.0000000800000p-42, -0x1.0000000000000p-114, -0x1.000003fffc002p-41, 0x1.0000000000000p-146, -0x1.000007f7f8004p-42, -0x1.fffffffe00000p-115},
+{-0x1.0000000800000p-42, 0x1.0000000000000p-114, 0x1.000003fffc002p-41, -0x1.0000000000000p-146, 0x1.000007f7f8004p-42, 0x1.fffffffe00000p-115},
+{-0x1.0000000800000p-42, 0x1.0000000000000p-114, -0x1.000003fffc002p-41, 0x1.0000000000000p-146, -0x1.80000403fc002p-41, 0x1.0000000100000p-114},
+{0x1.0000000000000p+46, 0x1.ffc001ffffe00p-9, 0x1.000003fff8000p-19, 0x1.fffc000fc0000p-90, 0x1.0000000000000p+46, 0x1.000001007fef0p-8},
+{0x1.0000000000000p+46, 0x1.ffc001ffffe00p-9, -0x1.000003fff8000p-19, -0x1.fffc000fc0000p-90, 0x1.0000000000000p+46, 0x1.ff8001feffe20p-9},
+{-0x1.0000000000000p+46, -0x1.ffc001ffffe00p-9, 0x1.000003fff8000p-19, 0x1.fffc000fc0000p-90, -0x1.0000000000000p+46, -0x1.ff8001feffe20p-9},
+{-0x1.0000000000000p+46, -0x1.ffc001ffffe00p-9, -0x1.000003fff8000p-19, -0x1.fffc000fc0000p-90, -0x1.0000000000000p+46, -0x1.000001007fef0p-8},
+{0x1.0000000000003p+33, 0x1.fc00001fff800p-31, 0x1.0000000000020p+40, -0x1.fc01ffe002000p-24, 0x1.0200000000020p+40, 0x1.781fd80080f80p-18},
+{0x1.0000000000003p+33, 0x1.fc00001fff800p-31, -0x1.0000000000020p+40, 0x1.fc01ffe002000p-24, -0x1.fc00000000040p+39, 0x1.87ffe7ff81080p-18},
+{-0x1.0000000000003p+33, -0x1.fc00001fff800p-31, 0x1.0000000000020p+40, -0x1.fc01ffe002000p-24, 0x1.fc00000000040p+39, -0x1.87ffe7ff81080p-18},
+{-0x1.0000000000003p+33, -0x1.fc00001fff800p-31, -0x1.0000000000020p+40, 0x1.fc01ffe002000p-24, -0x1.0200000000020p+40, -0x1.781fd80080f80p-18},
+{0x1.0000000000000p-42, 0x1.fffff00001ffep-96, 0x1.0000000000000p-9, 0x1.ff00000ffff80p-69, 0x1.0000000080000p-9, 0x1.ff00004ffff80p-69},
+{0x1.0000000000000p-42, 0x1.fffff00001ffep-96, -0x1.0000000000000p-9, -0x1.ff00000ffff80p-69, -0x1.ffffffff00000p-10, -0x1.feffffcffff80p-69},
+{-0x1.0000000000000p-42, -0x1.fffff00001ffep-96, 0x1.0000000000000p-9, 0x1.ff00000ffff80p-69, 0x1.ffffffff00000p-10, 0x1.feffffcffff80p-69},
+{-0x1.0000000000000p-42, -0x1.fffff00001ffep-96, -0x1.0000000000000p-9, -0x1.ff00000ffff80p-69, -0x1.0000000080000p-9, -0x1.ff00004ffff80p-69},
+{0x1.0000000000000p-46, 0x1.ffffffffffc00p-109, 0x1.0000200000000p+11, -0x1.ffc0000080000p-61, 0x1.0000200000000p+11, 0x1.fff800fffffe0p-47},
+{0x1.0000000000000p-46, 0x1.ffffffffffc00p-109, -0x1.0000200000000p+11, 0x1.ffc0000080000p-61, -0x1.0000200000000p+11, 0x1.0003ff8000010p-46},
+{-0x1.0000000000000p-46, -0x1.ffffffffffc00p-109, 0x1.0000200000000p+11, -0x1.ffc0000080000p-61, 0x1.0000200000000p+11, -0x1.0003ff8000010p-46},
+{-0x1.0000000000000p-46, -0x1.ffffffffffc00p-109, -0x1.0000200000000p+11, 0x1.ffc0000080000p-61, -0x1.0000200000000p+11, -0x1.fff800fffffe0p-47},
+{0x1.0000000000800p-4, -0x1.fffc000000010p-61, 0x1.0000000000008p-2, -0x1.ffe03fffff010p-59, 0x1.4000000000208p-2, -0x1.3fef9fffff808p-58},
+{0x1.0000000000800p-4, -0x1.fffc000000010p-61, -0x1.0000000000008p-2, 0x1.ffe03fffff010p-59, -0x1.7fffffffffc10p-3, 0x1.7fe13fffff010p-59},
+{-0x1.0000000000800p-4, 0x1.fffc000000010p-61, 0x1.0000000000008p-2, -0x1.ffe03fffff010p-59, 0x1.7fffffffffc10p-3, -0x1.7fe13fffff010p-59},
+{-0x1.0000000000800p-4, 0x1.fffc000000010p-61, -0x1.0000000000008p-2, 0x1.ffe03fffff010p-59, -0x1.4000000000208p-2, 0x1.3fef9fffff808p-58},
+{0x1.0000000000000p-39, 0x1.fffef0ffff000p-102, 0x1.0000100000000p-7, -0x1.fff8000000800p-71, 0x1.0000100100000p-7, -0x1.fff7fffc00800p-71},
+{0x1.0000000000000p-39, 0x1.fffef0ffff000p-102, -0x1.0000100000000p-7, 0x1.fff8000000800p-71, -0x1.00000fff00000p-7, 0x1.fff8000400800p-71},
+{-0x1.0000000000000p-39, -0x1.fffef0ffff000p-102, 0x1.0000100000000p-7, -0x1.fff8000000800p-71, 0x1.00000fff00000p-7, -0x1.fff8000400800p-71},
+{-0x1.0000000000000p-39, -0x1.fffef0ffff000p-102, -0x1.0000100000000p-7, 0x1.fff8000000800p-71, -0x1.0000100100000p-7, 0x1.fff7fffc00800p-71},
+{0x1.07c00007ffff0p-15, 0x1.fffc00f800000p-91, 0x1.0000007ffffe0p-11, 0x1.f000000000000p-82, 0x1.107c00807ffdfp-11, 0x1.f0fffe0080000p-82},
+{0x1.07c00007ffff0p-15, 0x1.fffc00f800000p-91, -0x1.0000007ffffe0p-11, -0x1.f000000000000p-82, -0x1.df0800fefffc2p-12, -0x1.ef0001ff80000p-82},
+{-0x1.07c00007ffff0p-15, -0x1.fffc00f800000p-91, 0x1.0000007ffffe0p-11, 0x1.f000000000000p-82, 0x1.df0800fefffc2p-12, 0x1.ef0001ff80000p-82},
+{-0x1.07c00007ffff0p-15, -0x1.fffc00f800000p-91, -0x1.0000007ffffe0p-11, -0x1.f000000000000p-82, -0x1.107c00807ffdfp-11, -0x1.f0fffe0080000p-82},
+{0x1.0000000000000p+37, 0x1.ff800fffff800p-19, 0x1.0000000000000p-32, 0x1.fffc0000ffff8p-88, 0x1.0000000000000p+37, 0x1.ff880fffff800p-19},
+{0x1.0000000000000p+37, 0x1.ff800fffff800p-19, -0x1.0000000000000p-32, -0x1.fffc0000ffff8p-88, 0x1.0000000000000p+37, 0x1.ff780fffff800p-19},
+{-0x1.0000000000000p+37, -0x1.ff800fffff800p-19, 0x1.0000000000000p-32, 0x1.fffc0000ffff8p-88, -0x1.0000000000000p+37, -0x1.ff780fffff800p-19},
+{-0x1.0000000000000p+37, -0x1.ff800fffff800p-19, -0x1.0000000000000p-32, -0x1.fffc0000ffff8p-88, -0x1.0000000000000p+37, -0x1.ff880fffff800p-19},
+{0x1.0000000008000p+44, -0x1.ffff807ffe002p-10, 0x1.0000000800000p-6, -0x1.ffffff8000008p-62, 0x1.0000000008004p+44, -0x1.ffff7ffffe004p-10},
+{0x1.0000000008000p+44, -0x1.ffff807ffe002p-10, -0x1.0000000800000p-6, 0x1.ffffff8000008p-62, 0x1.0000000007ffcp+44, -0x1.ffff80fffe000p-10},
+{-0x1.0000000008000p+44, 0x1.ffff807ffe002p-10, 0x1.0000000800000p-6, -0x1.ffffff8000008p-62, -0x1.0000000007ffcp+44, 0x1.ffff80fffe000p-10},
+{-0x1.0000000008000p+44, 0x1.ffff807ffe002p-10, -0x1.0000000800000p-6, 0x1.ffffff8000008p-62, -0x1.0000000008004p+44, 0x1.ffff7ffffe004p-10},
+{0x1.0000000000020p-53, -0x1.0000000000000p-136, 0x1.0000000000000p+33, 0x1.fffff000003c0p-26, 0x1.0000000000000p+33, 0x1.fffff020003c0p-26},
+{0x1.0000000000020p-53, -0x1.0000000000000p-136, -0x1.0000000000000p+33, -0x1.fffff000003c0p-26, -0x1.0000000000000p+33, -0x1.ffffefe0003c0p-26},
+{-0x1.0000000000020p-53, 0x1.0000000000000p-136, 0x1.0000000000000p+33, 0x1.fffff000003c0p-26, 0x1.0000000000000p+33, 0x1.ffffefe0003c0p-26},
+{-0x1.0000000000020p-53, 0x1.0000000000000p-136, -0x1.0000000000000p+33, -0x1.fffff000003c0p-26, -0x1.0000000000000p+33, -0x1.fffff020003c0p-26},
+{0x1.0000001ffff80p-7, 0x1.fffffdfffff8ep-61, 0x1.0000000200000p-27, -0x1.0000000000000p-96, 0x1.0000101ffff82p-7, 0x1.fffffdffdff8ep-61},
+{0x1.0000001ffff80p-7, 0x1.fffffdfffff8ep-61, -0x1.0000000200000p-27, 0x1.0000000000000p-96, 0x1.ffffe03fffefdp-8, -0x1.ffe0072000000p-85},
+{-0x1.0000001ffff80p-7, -0x1.fffffdfffff8ep-61, 0x1.0000000200000p-27, -0x1.0000000000000p-96, -0x1.ffffe03fffefdp-8, 0x1.ffe0072000000p-85},
+{-0x1.0000001ffff80p-7, -0x1.fffffdfffff8ep-61, -0x1.0000000200000p-27, 0x1.0000000000000p-96, -0x1.0000101ffff82p-7, -0x1.fffffdffdff8ep-61},
+{0x1.01ffffff80400p-38, -0x1.c7ffffc000100p-96, 0x1.0000000000000p-47, 0x1.8fff01fffff00p-107, 0x1.027fffff80400p-38, -0x1.c7cdffdfc0100p-96},
+{0x1.01ffffff80400p-38, -0x1.c7ffffc000100p-96, -0x1.0000000000000p-47, -0x1.8fff01fffff00p-107, 0x1.017fffff80400p-38, -0x1.c831ffa040100p-96},
+{-0x1.01ffffff80400p-38, 0x1.c7ffffc000100p-96, 0x1.0000000000000p-47, 0x1.8fff01fffff00p-107, -0x1.017fffff80400p-38, 0x1.c831ffa040100p-96},
+{-0x1.01ffffff80400p-38, 0x1.c7ffffc000100p-96, -0x1.0000000000000p-47, -0x1.8fff01fffff00p-107, -0x1.027fffff80400p-38, 0x1.c7cdffdfc0100p-96},
+{0x1.0000000000008p-27, -0x1.ffffc00800000p-100, 0x1.00003ffe00002p+16, -0x1.ffffffc180080p-44, 0x1.00003ffe00202p+16, -0x1.ffffffc080080p-44},
+{0x1.0000000000008p-27, -0x1.ffffc00800000p-100, -0x1.00003ffe00002p+16, 0x1.ffffffc180080p-44, -0x1.00003ffdffe02p+16, 0x1.ffffffc280080p-44},
+{-0x1.0000000000008p-27, 0x1.ffffc00800000p-100, 0x1.00003ffe00002p+16, -0x1.ffffffc180080p-44, 0x1.00003ffdffe02p+16, -0x1.ffffffc280080p-44},
+{-0x1.0000000000008p-27, 0x1.ffffc00800000p-100, -0x1.00003ffe00002p+16, 0x1.ffffffc180080p-44, -0x1.00003ffe00202p+16, 0x1.ffffffc080080p-44},
+{0x1.000000ffffff8p+16, 0x1.ffffffc000000p-41, 0x1.0000000000000p+8, 0x1.ffffffe000000p-50, 0x1.010000ffffff8p+16, 0x1.007fffdff8000p-40},
+{0x1.000000ffffff8p+16, 0x1.ffffffc000000p-41, -0x1.0000000000000p+8, -0x1.ffffffe000000p-50, 0x1.fe0001ffffff0p+15, 0x1.feffffc010000p-41},
+{-0x1.000000ffffff8p+16, -0x1.ffffffc000000p-41, 0x1.0000000000000p+8, 0x1.ffffffe000000p-50, -0x1.fe0001ffffff0p+15, -0x1.feffffc010000p-41},
+{-0x1.000000ffffff8p+16, -0x1.ffffffc000000p-41, -0x1.0000000000000p+8, -0x1.ffffffe000000p-50, -0x1.010000ffffff8p+16, -0x1.007fffdff8000p-40},
+{0x1.0000000020000p-39, -0x1.0000000000000p-144, 0x1.0000000000400p-40, -0x1.ff1ffffff4000p-107, 0x1.8000000020200p-39, -0x1.ff20000000000p-107},
+{0x1.0000000020000p-39, -0x1.0000000000000p-144, -0x1.0000000000400p-40, 0x1.ff1ffffff4000p-107, 0x1.000000003fc00p-40, 0x1.ff1fffffec000p-107},
+{-0x1.0000000020000p-39, 0x1.0000000000000p-144, 0x1.0000000000400p-40, -0x1.ff1ffffff4000p-107, -0x1.000000003fc00p-40, -0x1.ff1fffffec000p-107},
+{-0x1.0000000020000p-39, 0x1.0000000000000p-144, -0x1.0000000000400p-40, 0x1.ff1ffffff4000p-107, -0x1.8000000020200p-39, 0x1.ff20000000000p-107},
+{0x1.0000ff8020000p-18, -0x1.fffffa0000000p-80, 0x1.0000000001ff0p+30, 0x1.f700000ffe000p-36, 0x1.0000000002000p+30, 0x1.7d402003ff800p-34},
+{0x1.0000ff8020000p-18, -0x1.fffffa0000000p-80, -0x1.0000000001ff0p+30, -0x1.f700000ffe000p-36, -0x1.0000000001fe0p+30, 0x1.03803ff801000p-35},
+{-0x1.0000ff8020000p-18, 0x1.fffffa0000000p-80, 0x1.0000000001ff0p+30, 0x1.f700000ffe000p-36, 0x1.0000000001fe0p+30, -0x1.03803ff801000p-35},
+{-0x1.0000ff8020000p-18, 0x1.fffffa0000000p-80, -0x1.0000000001ff0p+30, -0x1.f700000ffe000p-36, -0x1.0000000002000p+30, -0x1.7d402003ff800p-34},
+{0x1.0000020000000p+8, -0x1.0000000000000p-56, 0x1.003e00001f800p-14, 0x1.ffde000001e00p-76, 0x1.00000600f8000p+8, 0x1.f400007ff7800p-50},
+{0x1.0000020000000p+8, -0x1.0000000000000p-56, -0x1.003e00001f800p-14, -0x1.ffde000001e00p-76, 0x1.fffffbfe10000p+7, -0x1.fc00007ff7800p-50},
+{-0x1.0000020000000p+8, 0x1.0000000000000p-56, 0x1.003e00001f800p-14, 0x1.ffde000001e00p-76, -0x1.fffffbfe10000p+7, 0x1.fc00007ff7800p-50},
+{-0x1.0000020000000p+8, 0x1.0000000000000p-56, -0x1.003e00001f800p-14, -0x1.ffde000001e00p-76, -0x1.00000600f8000p+8, -0x1.f400007ff7800p-50},
+{0x1.0007e3ffe0000p-24, 0x1.fe0ffffffe000p-88, 0x1.0000000000000p+0, 0x1.fffffe07fff00p-61, 0x1.0000010007e40p+0, -0x1.000000dc1f080p-60},
+{0x1.0007e3ffe0000p-24, 0x1.fe0ffffffe000p-88, -0x1.0000000000000p+0, -0x1.fffffe07fff00p-61, -0x1.fffffdfff0380p-1, -0x1.7fffff720f7c0p-59},
+{-0x1.0007e3ffe0000p-24, -0x1.fe0ffffffe000p-88, 0x1.0000000000000p+0, 0x1.fffffe07fff00p-61, 0x1.fffffdfff0380p-1, 0x1.7fffff720f7c0p-59},
+{-0x1.0007e3ffe0000p-24, -0x1.fe0ffffffe000p-88, -0x1.0000000000000p+0, -0x1.fffffe07fff00p-61, -0x1.0000010007e40p+0, 0x1.000000dc1f080p-60},
+{0x1.00000000fe000p+38, 0x1.ff00004000000p-29, 0x1.000003fffff80p-32, 0x1.fff8400000000p-92, 0x1.00000000fe000p+38, 0x1.0f80006000000p-28},
+{0x1.00000000fe000p+38, 0x1.ff00004000000p-29, -0x1.000003fffff80p-32, -0x1.fff8400000000p-92, 0x1.00000000fe000p+38, 0x1.deffffc000000p-29},
+{-0x1.00000000fe000p+38, -0x1.ff00004000000p-29, 0x1.000003fffff80p-32, 0x1.fff8400000000p-92, -0x1.00000000fe000p+38, -0x1.deffffc000000p-29},
+{-0x1.00000000fe000p+38, -0x1.ff00004000000p-29, -0x1.000003fffff80p-32, -0x1.fff8400000000p-92, -0x1.00000000fe000p+38, -0x1.0f80006000000p-28},
+{0x1.0000800000000p-9, -0x1.0000000000000p-65, 0x1.0000000000000p-51, 0x1.fffffffc1fc00p-114, 0x1.0000800000400p-9, -0x1.fffffffffffe0p-66},
+{0x1.0000800000000p-9, -0x1.0000000000000p-65, -0x1.0000000000000p-51, -0x1.fffffffc1fc00p-114, 0x1.00007fffffc00p-9, -0x1.0000000000010p-65},
+{-0x1.0000800000000p-9, 0x1.0000000000000p-65, 0x1.0000000000000p-51, 0x1.fffffffc1fc00p-114, -0x1.00007fffffc00p-9, 0x1.0000000000010p-65},
+{-0x1.0000800000000p-9, 0x1.0000000000000p-65, -0x1.0000000000000p-51, -0x1.fffffffc1fc00p-114, -0x1.0000800000400p-9, 0x1.fffffffffffe0p-66},
+{0x1.0000000000000p-40, 0x1.ff000ff3ffe00p-94, 0x1.0000000000000p-18, 0x1.fe0003fffc000p-77, 0x1.0000040000000p-18, 0x1.fe01038003f80p-77},
+{0x1.0000000000000p-40, 0x1.ff000ff3ffe00p-94, -0x1.0000000000000p-18, -0x1.fe0003fffc000p-77, -0x1.fffff80000000p-19, -0x1.fdff047ff4060p-77},
+{-0x1.0000000000000p-40, -0x1.ff000ff3ffe00p-94, 0x1.0000000000000p-18, 0x1.fe0003fffc000p-77, 0x1.fffff80000000p-19, 0x1.fdff047ff4060p-77},
+{-0x1.0000000000000p-40, -0x1.ff000ff3ffe00p-94, -0x1.0000000000000p-18, -0x1.fe0003fffc000p-77, -0x1.0000040000000p-18, -0x1.fe01038003f80p-77},
+{0x1.000000e000010p-12, -0x1.ffffffc020000p-82, 0x1.00000001f0000p-4, 0x1.8000000000000p-108, 0x1.01000002d0000p-4, 0x1.fffff00000050p-61},
+{0x1.000000e000010p-12, -0x1.ffffffc020000p-82, -0x1.00000001f0000p-4, -0x1.8000000000000p-108, -0x1.fe00000220000p-5, 0x1.ffffefffffff0p-61},
+{-0x1.000000e000010p-12, 0x1.ffffffc020000p-82, 0x1.00000001f0000p-4, 0x1.8000000000000p-108, 0x1.fe00000220000p-5, -0x1.ffffefffffff0p-61},
+{-0x1.000000e000010p-12, 0x1.ffffffc020000p-82, -0x1.00000001f0000p-4, -0x1.8000000000000p-108, -0x1.01000002d0000p-4, -0x1.fffff00000050p-61},
+{0x1.000003ff00000p+23, 0x1.8000000000000p-54, 0x1.0001ffffe0000p-39, 0x1.f800000100000p-112, 0x1.000003ff00000p+23, 0x1.0004ffffe0000p-39},
+{0x1.000003ff00000p+23, 0x1.8000000000000p-54, -0x1.0001ffffe0000p-39, -0x1.f800000100000p-112, 0x1.000003ff00000p+23, -0x1.fffdffffc0000p-40},
+{-0x1.000003ff00000p+23, -0x1.8000000000000p-54, 0x1.0001ffffe0000p-39, 0x1.f800000100000p-112, -0x1.000003ff00000p+23, 0x1.fffdffffc0000p-40},
+{-0x1.000003ff00000p+23, -0x1.8000000000000p-54, -0x1.0001ffffe0000p-39, -0x1.f800000100000p-112, -0x1.000003ff00000p+23, -0x1.0004ffffe0000p-39},
+{0x1.0000000000200p+14, -0x1.ffffffffffc08p-42, 0x1.0000000000000p-48, 0x1.ffffffffffffep-102, 0x1.0000000000200p+14, -0x1.fbffffffffc08p-42},
+{0x1.0000000000200p+14, -0x1.ffffffffffc08p-42, -0x1.0000000000000p-48, -0x1.ffffffffffffep-102, 0x1.0000000000200p+14, -0x1.01ffffffffe04p-41},
+{-0x1.0000000000200p+14, 0x1.ffffffffffc08p-42, 0x1.0000000000000p-48, 0x1.ffffffffffffep-102, -0x1.0000000000200p+14, 0x1.01ffffffffe04p-41},
+{-0x1.0000000000200p+14, 0x1.ffffffffffc08p-42, -0x1.0000000000000p-48, -0x1.ffffffffffffep-102, -0x1.0000000000200p+14, 0x1.fbffffffffc08p-42},
+{0x1.0000000040000p+37, -0x1.fffff80002000p-29, 0x1.0000000000000p-21, 0x1.ffc01ffff3c00p-84, 0x1.0000000040000p+37, 0x1.fc00000ffffc0p-22},
+{0x1.0000000040000p+37, -0x1.fffff80002000p-29, -0x1.0000000000000p-21, -0x1.ffc01ffff3c00p-84, 0x1.0000000040000p+37, -0x1.01fffff800020p-21},
+{-0x1.0000000040000p+37, 0x1.fffff80002000p-29, 0x1.0000000000000p-21, 0x1.ffc01ffff3c00p-84, -0x1.0000000040000p+37, 0x1.01fffff800020p-21},
+{-0x1.0000000040000p+37, 0x1.fffff80002000p-29, -0x1.0000000000000p-21, -0x1.ffc01ffff3c00p-84, -0x1.0000000040000p+37, -0x1.fc00000ffffc0p-22},
+{0x1.0000800000000p+25, -0x1.0000000000000p-80, 0x1.0000003800001p-52, 0x1.fffffe000003ep-106, 0x1.0000800000000p+25, 0x1.0000003000000p-52},
+{0x1.0000800000000p+25, -0x1.0000000000000p-80, -0x1.0000003800001p-52, -0x1.fffffe000003ep-106, 0x1.0000800000000p+25, -0x1.0000005000000p-52},
+{-0x1.0000800000000p+25, 0x1.0000000000000p-80, 0x1.0000003800001p-52, 0x1.fffffe000003ep-106, -0x1.0000800000000p+25, 0x1.0000005000000p-52},
+{-0x1.0000800000000p+25, 0x1.0000000000000p-80, -0x1.0000003800001p-52, -0x1.fffffe000003ep-106, -0x1.0000800000000p+25, -0x1.0000003000000p-52},
+{0x1.0f00000020000p-4, -0x1.fffe000000100p-58, 0x1.0000000400000p-7, -0x1.ffffffc004000p-74, 0x1.2f000000a0000p-4, -0x1.ffffffffffd00p-58},
+{0x1.0f00000020000p-4, -0x1.fffe000000100p-58, -0x1.0000000400000p-7, 0x1.ffffffc004000p-74, 0x1.ddffffff3ffffp-5, 0x1.ffffffd800000p-73},
+{-0x1.0f00000020000p-4, 0x1.fffe000000100p-58, 0x1.0000000400000p-7, -0x1.ffffffc004000p-74, -0x1.ddffffff3ffffp-5, -0x1.ffffffd800000p-73},
+{-0x1.0f00000020000p-4, 0x1.fffe000000100p-58, -0x1.0000000400000p-7, 0x1.ffffffc004000p-74, -0x1.2f000000a0000p-4, 0x1.ffffffffffd00p-58},
+{0x1.003fe00020000p-13, -0x1.ffffffffe8000p-81, 0x1.0000000000400p-48, -0x1.ffff800007ffcp-103, 0x1.003fe00040000p-13, -0x1.ff8007ffe8000p-81},
+{0x1.003fe00020000p-13, -0x1.ffffffffe8000p-81, -0x1.0000000000400p-48, 0x1.ffff800007ffcp-103, 0x1.003fe00000000p-13, -0x1.003ffbfff4000p-80},
+{-0x1.003fe00020000p-13, 0x1.ffffffffe8000p-81, 0x1.0000000000400p-48, -0x1.ffff800007ffcp-103, -0x1.003fe00000000p-13, 0x1.003ffbfff4000p-80},
+{-0x1.003fe00020000p-13, 0x1.ffffffffe8000p-81, -0x1.0000000000400p-48, 0x1.ffff800007ffcp-103, -0x1.003fe00040000p-13, 0x1.ff8007ffe8000p-81},
+{0x1.ffff00fffffc4p-6, -0x1.8080000000000p-88, 0x1.0000020000000p-1, -0x1.0000000000000p-77, 0x1.0ffffa07ffffep-1, 0x1.ffffeffcff000p-57},
+{0x1.ffff00fffffc4p-6, -0x1.8080000000000p-88, -0x1.0000020000000p-1, 0x1.0000000000000p-77, -0x1.e00013f000004p-2, 0x1.000007fe7f800p-56},
+{-0x1.ffff00fffffc4p-6, 0x1.8080000000000p-88, 0x1.0000020000000p-1, -0x1.0000000000000p-77, 0x1.e00013f000004p-2, -0x1.000007fe7f800p-56},
+{-0x1.ffff00fffffc4p-6, 0x1.8080000000000p-88, -0x1.0000020000000p-1, 0x1.0000000000000p-77, -0x1.0ffffa07ffffep-1, -0x1.ffffeffcff000p-57},
+{0x1.0000000000040p+36, -0x1.8000000800000p-39, 0x1.0000000002000p+30, -0x1.0000000000000p-74, 0x1.04000000000c0p+36, -0x1.8000000800000p-39},
+{0x1.0000000000040p+36, -0x1.8000000800000p-39, -0x1.0000000002000p+30, 0x1.0000000000000p-74, 0x1.f7fffffffff80p+35, -0x1.8000000800000p-39},
+{-0x1.0000000000040p+36, 0x1.8000000800000p-39, 0x1.0000000002000p+30, -0x1.0000000000000p-74, -0x1.f7fffffffff80p+35, 0x1.8000000800000p-39},
+{-0x1.0000000000040p+36, 0x1.8000000800000p-39, -0x1.0000000002000p+30, 0x1.0000000000000p-74, -0x1.04000000000c0p+36, 0x1.8000000800000p-39},
+{0x1.0000000800000p-29, -0x1.ffffc02000000p-107, 0x1.7fffe00800000p-48, -0x1.0000000000000p-153, 0x1.00003007fc010p-29, -0x1.ffffc02000000p-107},
+{0x1.0000000800000p-29, -0x1.ffffc02000000p-107, -0x1.7fffe00800000p-48, 0x1.0000000000000p-153, 0x1.ffffa01007fe0p-30, -0x1.ffffc02000000p-107},
+{-0x1.0000000800000p-29, 0x1.ffffc02000000p-107, 0x1.7fffe00800000p-48, -0x1.0000000000000p-153, -0x1.ffffa01007fe0p-30, 0x1.ffffc02000000p-107},
+{-0x1.0000000800000p-29, 0x1.ffffc02000000p-107, -0x1.7fffe00800000p-48, 0x1.0000000000000p-153, -0x1.00003007fc010p-29, 0x1.ffffc02000000p-107},
+{0x1.0000400000000p+11, -0x1.0000000000000p-80, 0x1.4000000000000p+51, -0x1.ffffffff00020p-7, 0x1.4000000001000p+51, -0x1.fffffffe00040p-8},
+{0x1.0000400000000p+11, -0x1.0000000000000p-80, -0x1.4000000000000p+51, 0x1.ffffffff00020p-7, -0x1.3fffffffff000p+51, 0x1.7fffffff80010p-6},
+{-0x1.0000400000000p+11, 0x1.0000000000000p-80, 0x1.4000000000000p+51, -0x1.ffffffff00020p-7, 0x1.3fffffffff000p+51, -0x1.7fffffff80010p-6},
+{-0x1.0000400000000p+11, 0x1.0000000000000p-80, -0x1.4000000000000p+51, 0x1.ffffffff00020p-7, -0x1.4000000001000p+51, 0x1.fffffffe00040p-8},
+{0x1.0000000000000p+42, 0x1.03eff7ff3fff0p-15, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, 0x1.0000000000200p+42, 0x1.0befe7ff40070p-15},
+{0x1.0000000000000p+42, 0x1.03eff7ff3fff0p-15, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, 0x1.ffffffffffc00p+41, 0x1.f7e00ffe7fee0p-16},
+{-0x1.0000000000000p+42, -0x1.03eff7ff3fff0p-15, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, -0x1.ffffffffffc00p+41, -0x1.f7e00ffe7fee0p-16},
+{-0x1.0000000000000p+42, -0x1.03eff7ff3fff0p-15, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, -0x1.0000000000200p+42, -0x1.0befe7ff40070p-15},
+{0x1.03ffffffffffep-18, 0x1.8000000000000p-122, 0x1.0000040000000p+49, -0x1.0000000000000p-56, 0x1.0000040000000p+49, 0x1.03fffffffc000p-18},
+{0x1.03ffffffffffep-18, 0x1.8000000000000p-122, -0x1.0000040000000p+49, 0x1.0000000000000p-56, -0x1.0000040000000p+49, 0x1.0400000004000p-18},
+{-0x1.03ffffffffffep-18, -0x1.8000000000000p-122, 0x1.0000040000000p+49, -0x1.0000000000000p-56, 0x1.0000040000000p+49, -0x1.0400000004000p-18},
+{-0x1.03ffffffffffep-18, -0x1.8000000000000p-122, -0x1.0000040000000p+49, 0x1.0000000000000p-56, -0x1.0000040000000p+49, -0x1.03fffffffc000p-18},
+{0x1.0007ffffcfffcp+9, 0x1.ff01fffe00000p-65, 0x1.01fff08000000p-5, -0x1.fffffe0000020p-59, 0x1.000c07ff91ffcp+9, -0x1.f803f60008000p-59},
+{0x1.0007ffffcfffcp+9, 0x1.ff01fffe00000p-65, -0x1.01fff08000000p-5, 0x1.fffffe0000020p-59, 0x1.0003f8000dffcp+9, 0x1.03fe02fffc000p-58},
+{-0x1.0007ffffcfffcp+9, -0x1.ff01fffe00000p-65, 0x1.01fff08000000p-5, -0x1.fffffe0000020p-59, -0x1.0003f8000dffcp+9, -0x1.03fe02fffc000p-58},
+{-0x1.0007ffffcfffcp+9, -0x1.ff01fffe00000p-65, -0x1.01fff08000000p-5, 0x1.fffffe0000020p-59, -0x1.000c07ff91ffcp+9, 0x1.f803f60008000p-59},
+{0x1.00000000007fep-4, 0x1.ff00003ffff00p-65, 0x1.004000e000008p+5, -0x1.ffffe02000000p-73, 0x1.00c000e00000cp+5, -0x1.ff017fffd0100p-56},
+{0x1.00000000007fep-4, 0x1.ff00003ffff00p-65, -0x1.004000e000008p+5, 0x1.ffffe02000000p-73, -0x1.ff8001c000008p+4, -0x1.feff7fffeff00p-56},
+{-0x1.00000000007fep-4, -0x1.ff00003ffff00p-65, 0x1.004000e000008p+5, -0x1.ffffe02000000p-73, 0x1.ff8001c000008p+4, 0x1.feff7fffeff00p-56},
+{-0x1.00000000007fep-4, -0x1.ff00003ffff00p-65, -0x1.004000e000008p+5, 0x1.ffffe02000000p-73, -0x1.00c000e00000cp+5, 0x1.ff017fffd0100p-56},
+{0x1.00000003ff000p-41, 0x1.ffff000000000p-130, 0x1.0000fffff8000p-20, 0x1.f003ffe0003e0p-78, 0x1.000107fff8002p-20, 0x1.d003ffe0003e0p-78},
+{0x1.00000003ff000p-41, 0x1.ffff000000000p-130, -0x1.0000fffff8000p-20, -0x1.f003ffe0003e0p-78, -0x1.0000f7fff7ffep-20, -0x1.0801fff0001f0p-77},
+{-0x1.00000003ff000p-41, -0x1.ffff000000000p-130, 0x1.0000fffff8000p-20, 0x1.f003ffe0003e0p-78, 0x1.0000f7fff7ffep-20, 0x1.0801fff0001f0p-77},
+{-0x1.00000003ff000p-41, -0x1.ffff000000000p-130, -0x1.0000fffff8000p-20, -0x1.f003ffe0003e0p-78, -0x1.000107fff8002p-20, -0x1.d003ffe0003e0p-78},
+{0x1.0000000000000p-41, 0x1.ffe001c0003c0p-100, 0x1.01fffffe00000p+41, 0x1.ffffffffffc00p-17, 0x1.01fffffe00000p+41, 0x1.0000007fffe00p-16},
+{0x1.0000000000000p-41, 0x1.ffe001c0003c0p-100, -0x1.01fffffe00000p+41, -0x1.ffffffffffc00p-17, -0x1.01fffffe00000p+41, -0x1.fffffeffffc00p-17},
+{-0x1.0000000000000p-41, -0x1.ffe001c0003c0p-100, 0x1.01fffffe00000p+41, 0x1.ffffffffffc00p-17, 0x1.01fffffe00000p+41, 0x1.fffffeffffc00p-17},
+{-0x1.0000000000000p-41, -0x1.ffe001c0003c0p-100, -0x1.01fffffe00000p+41, -0x1.ffffffffffc00p-17, -0x1.01fffffe00000p+41, -0x1.0000007fffe00p-16},
+{0x1.00003ff808000p+36, -0x1.ffe0000800000p-25, 0x1.000001ffff000p+41, 0x1.ff80000000000p-33, 0x1.080003ffbf400p+41, -0x1.fde0800800000p-25},
+{0x1.00003ff808000p+36, -0x1.ffe0000800000p-25, -0x1.000001ffff000p+41, -0x1.ff80000000000p-33, -0x1.f00000007d800p+40, -0x1.00efc00400000p-24},
+{-0x1.00003ff808000p+36, 0x1.ffe0000800000p-25, 0x1.000001ffff000p+41, 0x1.ff80000000000p-33, 0x1.f00000007d800p+40, 0x1.00efc00400000p-24},
+{-0x1.00003ff808000p+36, 0x1.ffe0000800000p-25, -0x1.000001ffff000p+41, -0x1.ff80000000000p-33, -0x1.080003ffbf400p+41, 0x1.fde0800800000p-25},
+{0x1.0000000000000p+6, 0x1.fc007f0ff0000p-56, 0x1.0000000007f80p-50, 0x1.ff0007f802000p-114, 0x1.0000000000000p+6, 0x1.07f001fc47b80p-50},
+{0x1.0000000000000p+6, 0x1.fc007f0ff0000p-56, -0x1.0000000007f80p-50, -0x1.ff0007f802000p-114, 0x1.0000000000000p+6, -0x1.f01ffc0790700p-51},
+{-0x1.0000000000000p+6, -0x1.fc007f0ff0000p-56, 0x1.0000000007f80p-50, 0x1.ff0007f802000p-114, -0x1.0000000000000p+6, 0x1.f01ffc0790700p-51},
+{-0x1.0000000000000p+6, -0x1.fc007f0ff0000p-56, -0x1.0000000007f80p-50, -0x1.ff0007f802000p-114, -0x1.0000000000000p+6, -0x1.07f001fc47b80p-50},
+{0x1.0020000000000p+12, -0x1.0000000000000p-65, 0x1.000001ffff802p-4, -0x1.ffffffc000040p-63, 0x1.0021000002000p+12, -0x1.ff811fffffe00p-46},
+{0x1.0020000000000p+12, -0x1.0000000000000p-65, -0x1.000001ffff802p-4, 0x1.ffffffc000040p-63, 0x1.001efffffe000p+12, 0x1.ff80dfffffe00p-46},
+{-0x1.0020000000000p+12, 0x1.0000000000000p-65, 0x1.000001ffff802p-4, -0x1.ffffffc000040p-63, -0x1.001efffffe000p+12, -0x1.ff80dfffffe00p-46},
+{-0x1.0020000000000p+12, 0x1.0000000000000p-65, -0x1.000001ffff802p-4, 0x1.ffffffc000040p-63, -0x1.0021000002000p+12, 0x1.ff811fffffe00p-46},
+{0x1.0000000000800p-45, -0x1.ffe0000400000p-107, 0x1.0000000000038p+25, 0x1.e100000000000p-49, 0x1.0000000000038p+25, 0x1.1e10000000000p-45},
+{0x1.0000000000800p-45, -0x1.ffe0000400000p-107, -0x1.0000000000038p+25, -0x1.e100000000000p-49, -0x1.0000000000038p+25, 0x1.c3e0000000000p-46},
+{-0x1.0000000000800p-45, 0x1.ffe0000400000p-107, 0x1.0000000000038p+25, 0x1.e100000000000p-49, 0x1.0000000000038p+25, -0x1.c3e0000000000p-46},
+{-0x1.0000000000800p-45, 0x1.ffe0000400000p-107, -0x1.0000000000038p+25, -0x1.e100000000000p-49, -0x1.0000000000038p+25, -0x1.1e10000000000p-45},
+{0x1.0000000000020p-31, -0x1.8007ffff80c04p-86, 0x1.0000000000000p+50, 0x1.ffffe00000c00p-13, 0x1.0000000000000p+50, 0x1.0000100000600p-12},
+{0x1.0000000000020p-31, -0x1.8007ffff80c04p-86, -0x1.0000000000000p+50, -0x1.ffffe00000c00p-13, -0x1.0000000000000p+50, -0x1.ffffa00000c00p-13},
+{-0x1.0000000000020p-31, 0x1.8007ffff80c04p-86, 0x1.0000000000000p+50, 0x1.ffffe00000c00p-13, 0x1.0000000000000p+50, 0x1.ffffa00000c00p-13},
+{-0x1.0000000000020p-31, 0x1.8007ffff80c04p-86, -0x1.0000000000000p+50, -0x1.ffffe00000c00p-13, -0x1.0000000000000p+50, -0x1.0000100000600p-12},
+{0x1.7fffffff80000p+1, 0x1.f000000000000p-76, 0x1.000007ffffffep-41, 0x1.ffffff8000000p-117, 0x1.7fffffff80400p+1, 0x1.0007bffc00000p-62},
+{0x1.7fffffff80000p+1, 0x1.f000000000000p-76, -0x1.000007ffffffep-41, -0x1.ffffff8000000p-117, 0x1.7fffffff7fc00p+1, -0x1.fff07ff800000p-63},
+{-0x1.7fffffff80000p+1, -0x1.f000000000000p-76, 0x1.000007ffffffep-41, 0x1.ffffff8000000p-117, -0x1.7fffffff7fc00p+1, 0x1.fff07ff800000p-63},
+{-0x1.7fffffff80000p+1, -0x1.f000000000000p-76, -0x1.000007ffffffep-41, -0x1.ffffff8000000p-117, -0x1.7fffffff80400p+1, -0x1.0007bffc00000p-62},
+{0x1.0000000010000p+45, -0x1.0000000000000p-41, 0x1.0000000000000p+5, 0x1.c000003ffc3fep-49, 0x1.0000000011000p+45, -0x1.fc80000000000p-42},
+{0x1.0000000010000p+45, -0x1.0000000000000p-41, -0x1.0000000000000p+5, -0x1.c000003ffc3fep-49, 0x1.000000000f000p+45, -0x1.01c0000000000p-41},
+{-0x1.0000000010000p+45, 0x1.0000000000000p-41, 0x1.0000000000000p+5, 0x1.c000003ffc3fep-49, -0x1.000000000f000p+45, 0x1.01c0000000000p-41},
+{-0x1.0000000010000p+45, 0x1.0000000000000p-41, -0x1.0000000000000p+5, -0x1.c000003ffc3fep-49, -0x1.0000000011000p+45, 0x1.fc80000000000p-42},
+{0x1.00000ffff0800p-14, -0x1.fff80000ffc20p-72, 0x1.0000000000002p-19, -0x1.0000000000000p-124, 0x1.08000ffff0800p-14, 0x1.0003ffff801f0p-71},
+{0x1.00000ffff0800p-14, -0x1.fff80000ffc20p-72, -0x1.0000000000002p-19, 0x1.0000000000000p-124, 0x1.f0001fffe1000p-15, -0x1.7ffe00003ff08p-70},
+{-0x1.00000ffff0800p-14, 0x1.fff80000ffc20p-72, 0x1.0000000000002p-19, -0x1.0000000000000p-124, -0x1.f0001fffe1000p-15, 0x1.7ffe00003ff08p-70},
+{-0x1.00000ffff0800p-14, 0x1.fff80000ffc20p-72, -0x1.0000000000002p-19, 0x1.0000000000000p-124, -0x1.08000ffff0800p-14, -0x1.0003ffff801f0p-71},
+{0x1.000ffffc00000p+49, 0x1.fffff00000000p-20, 0x1.0000000000040p+45, -0x1.0000000000000p-60, 0x1.100ffffc00004p+49, 0x1.fffff00000000p-20},
+{0x1.000ffffc00000p+49, 0x1.fffff00000000p-20, -0x1.0000000000040p+45, 0x1.0000000000000p-60, 0x1.e01ffff7ffff8p+48, 0x1.fffff00000000p-20},
+{-0x1.000ffffc00000p+49, -0x1.fffff00000000p-20, 0x1.0000000000040p+45, -0x1.0000000000000p-60, -0x1.e01ffff7ffff8p+48, -0x1.fffff00000000p-20},
+{-0x1.000ffffc00000p+49, -0x1.fffff00000000p-20, -0x1.0000000000040p+45, 0x1.0000000000000p-60, -0x1.100ffffc00004p+49, -0x1.fffff00000000p-20},
+{0x1.0004000000000p+14, -0x1.0000000000000p-54, 0x1.0000000200000p-4, -0x1.ffbffffff8020p-62, 0x1.0004400000008p+14, -0x1.01ffc00000000p-54},
+{0x1.0004000000000p+14, -0x1.0000000000000p-54, -0x1.0000000200000p-4, 0x1.ffbffffff8020p-62, 0x1.0003bfffffff8p+14, -0x1.fc00800000000p-55},
+{-0x1.0004000000000p+14, 0x1.0000000000000p-54, 0x1.0000000200000p-4, -0x1.ffbffffff8020p-62, -0x1.0003bfffffff8p+14, 0x1.fc00800000000p-55},
+{-0x1.0004000000000p+14, 0x1.0000000000000p-54, -0x1.0000000200000p-4, 0x1.ffbffffff8020p-62, -0x1.0004400000008p+14, 0x1.01ffc00000000p-54},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, 0x1.0000001fffffep+43, 0x0.0000000000000p+0, 0x1.00000020000fep+43, 0x1.0000000000000p-61},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, -0x1.0000001fffffep+43, 0x0.0000000000000p+0, -0x1.0000001fffefep+43, 0x1.0000000000000p-61},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, 0x1.0000001fffffep+43, 0x0.0000000000000p+0, 0x1.0000001fffefep+43, -0x1.0000000000000p-61},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, -0x1.0000001fffffep+43, 0x0.0000000000000p+0, -0x1.00000020000fep+43, -0x1.0000000000000p-61},
+{0x1.0000000000fffp-39, 0x1.fffff3e000000p-112, 0x1.001ffe0000000p-15, 0x1.fffffffffffc0p-74, 0x1.001fff0000000p-15, 0x1.03ffc00003fe0p-73},
+{0x1.0000000000fffp-39, 0x1.fffff3e000000p-112, -0x1.001ffe0000000p-15, -0x1.fffffffffffc0p-74, -0x1.001ffd0000000p-15, -0x1.f8007ffff7fc0p-74},
+{-0x1.0000000000fffp-39, -0x1.fffff3e000000p-112, 0x1.001ffe0000000p-15, 0x1.fffffffffffc0p-74, 0x1.001ffd0000000p-15, 0x1.f8007ffff7fc0p-74},
+{-0x1.0000000000fffp-39, -0x1.fffff3e000000p-112, -0x1.001ffe0000000p-15, -0x1.fffffffffffc0p-74, -0x1.001fff0000000p-15, -0x1.03ffc00003fe0p-73},
+{0x1.0000080000000p-27, -0x1.0000000000000p-132, 0x1.0000000080000p-48, -0x1.0000000000000p-103, 0x1.0000100000000p-27, 0x1.fffff7ffffffcp-82},
+{0x1.0000080000000p-27, -0x1.0000000000000p-132, -0x1.0000000080000p-48, 0x1.0000000000000p-103, 0x1.0000000000000p-27, -0x1.fffff80000004p-82},
+{-0x1.0000080000000p-27, 0x1.0000000000000p-132, 0x1.0000000080000p-48, -0x1.0000000000000p-103, -0x1.0000000000000p-27, 0x1.fffff80000004p-82},
+{-0x1.0000080000000p-27, 0x1.0000000000000p-132, -0x1.0000000080000p-48, 0x1.0000000000000p-103, -0x1.0000100000000p-27, -0x1.fffff7ffffffcp-82},
+{0x1.003ffffffffe0p-31, 0x1.ffffe03800000p-107, 0x1.0000000002000p-53, -0x1.0000000000000p-106, 0x1.004003fffffe0p-31, 0x1.ffffffff80e00p-93},
+{0x1.003ffffffffe0p-31, 0x1.ffffe03800000p-107, -0x1.0000000002000p-53, 0x1.0000000000000p-106, 0x1.003ffbfffffe0p-31, -0x1.fff000007f200p-93},
+{-0x1.003ffffffffe0p-31, -0x1.ffffe03800000p-107, 0x1.0000000002000p-53, -0x1.0000000000000p-106, -0x1.003ffbfffffe0p-31, 0x1.fff000007f200p-93},
+{-0x1.003ffffffffe0p-31, -0x1.ffffe03800000p-107, -0x1.0000000002000p-53, 0x1.0000000000000p-106, -0x1.004003fffffe0p-31, -0x1.ffffffff80e00p-93},
+{0x1.0000000000008p+23, -0x1.ff000007ffc00p-37, 0x1.0000000060000p+36, 0x1.ffffff8000000p-44, 0x1.0008000060000p+36, 0x1.ff813ffffdc00p-27},
+{0x1.0000000000008p+23, -0x1.ff000007ffc00p-37, -0x1.0000000060000p+36, -0x1.ffffff8000000p-44, -0x1.fff00000c0000p+35, 0x1.ff7f3ffffe400p-27},
+{-0x1.0000000000008p+23, 0x1.ff000007ffc00p-37, 0x1.0000000060000p+36, 0x1.ffffff8000000p-44, 0x1.fff00000c0000p+35, -0x1.ff7f3ffffe400p-27},
+{-0x1.0000000000008p+23, 0x1.ff000007ffc00p-37, -0x1.0000000060000p+36, -0x1.ffffff8000000p-44, -0x1.0008000060000p+36, -0x1.ff813ffffdc00p-27},
+{0x1.0000000000080p+25, -0x1.0000000000000p-80, 0x1.01ffffff80001p+15, -0x1.ff90000000000p-78, 0x1.00407fffffe80p+25, 0x1.fffffffffdc00p-38},
+{0x1.0000000000080p+25, -0x1.0000000000000p-80, -0x1.01ffffff80001p+15, 0x1.ff90000000000p-78, 0x1.ff7f000000500p+24, -0x1.fffffffffe400p-38},
+{-0x1.0000000000080p+25, 0x1.0000000000000p-80, 0x1.01ffffff80001p+15, -0x1.ff90000000000p-78, -0x1.ff7f000000500p+24, 0x1.fffffffffe400p-38},
+{-0x1.0000000000080p+25, 0x1.0000000000000p-80, -0x1.01ffffff80001p+15, 0x1.ff90000000000p-78, -0x1.00407fffffe80p+25, -0x1.fffffffffdc00p-38},
+{0x1.0000000000800p+7, -0x1.fffff80002000p-59, 0x1.0008000000000p+50, -0x1.0000000000000p-29, 0x1.0008000000200p+50, -0x1.f000000000000p-30},
+{0x1.0000000000800p+7, -0x1.fffff80002000p-59, -0x1.0008000000000p+50, 0x1.0000000000000p-29, -0x1.0007ffffffe00p+50, 0x1.0800000000000p-29},
+{-0x1.0000000000800p+7, 0x1.fffff80002000p-59, 0x1.0008000000000p+50, -0x1.0000000000000p-29, 0x1.0007ffffffe00p+50, -0x1.0800000000000p-29},
+{-0x1.0000000000800p+7, 0x1.fffff80002000p-59, -0x1.0008000000000p+50, 0x1.0000000000000p-29, -0x1.0008000000200p+50, 0x1.f000000000000p-30},
+{0x1.0000000000002p+26, -0x1.ffffffe200000p-48, 0x1.0003fffffffc0p+27, 0x1.ffffe00000400p-36, 0x1.8003fffffffc1p+27, 0x1.ffdfe00002000p-36},
+{0x1.0000000000002p+26, -0x1.ffffffe200000p-48, -0x1.0003fffffffc0p+27, -0x1.ffffe00000400p-36, -0x1.0007fffffff7ep+26, -0x1.000fefffff300p-35},
+{-0x1.0000000000002p+26, 0x1.ffffffe200000p-48, 0x1.0003fffffffc0p+27, 0x1.ffffe00000400p-36, 0x1.0007fffffff7ep+26, 0x1.000fefffff300p-35},
+{-0x1.0000000000002p+26, 0x1.ffffffe200000p-48, -0x1.0003fffffffc0p+27, -0x1.ffffe00000400p-36, -0x1.8003fffffffc1p+27, -0x1.ffdfe00002000p-36},
+{0x1.000003f000000p+13, 0x1.fffffffe00000p-48, 0x1.0000000000ff0p+50, 0x1.c03fff0e00000p-24, 0x1.0000000008ff0p+50, 0x1.f807010004380p-10},
+{0x1.000003f000000p+13, 0x1.fffffffe00000p-48, -0x1.0000000000ff0p+50, -0x1.c03fff0e00000p-24, -0x1.fffffffff1fe0p+49, 0x1.f7f8ff000bc80p-10},
+{-0x1.000003f000000p+13, -0x1.fffffffe00000p-48, 0x1.0000000000ff0p+50, 0x1.c03fff0e00000p-24, 0x1.fffffffff1fe0p+49, -0x1.f7f8ff000bc80p-10},
+{-0x1.000003f000000p+13, -0x1.fffffffe00000p-48, -0x1.0000000000ff0p+50, -0x1.c03fff0e00000p-24, -0x1.0000000008ff0p+50, -0x1.f807010004380p-10},
+{0x1.0000000018000p-6, 0x1.fffffe0000000p-88, 0x1.0000100000000p+32, -0x1.0000000000000p-73, 0x1.0000100004000p+32, 0x1.7ffffffe00000p-42},
+{0x1.0000000018000p-6, 0x1.fffffe0000000p-88, -0x1.0000100000000p+32, 0x1.0000000000000p-73, -0x1.00000ffffc000p+32, 0x1.8000000200000p-42},
+{-0x1.0000000018000p-6, -0x1.fffffe0000000p-88, 0x1.0000100000000p+32, -0x1.0000000000000p-73, 0x1.00000ffffc000p+32, -0x1.8000000200000p-42},
+{-0x1.0000000018000p-6, -0x1.fffffe0000000p-88, -0x1.0000100000000p+32, 0x1.0000000000000p-73, -0x1.0000100004000p+32, -0x1.7ffffffe00000p-42},
+{0x1.0000000000001p+35, -0x1.fffffc1000000p-32, 0x1.1ffffff01f000p+36, 0x1.ffffc000060fcp-19, 0x1.9ffffff01f001p+36, -0x1.00081fffed382p-18},
+{0x1.0000000000001p+35, -0x1.fffffc1000000p-32, -0x1.1ffffff01f000p+36, -0x1.ffffc000060fcp-19, -0x1.3fffffe03e000p+35, 0x1.fff0400019704p-19},
+{-0x1.0000000000001p+35, 0x1.fffffc1000000p-32, 0x1.1ffffff01f000p+36, 0x1.ffffc000060fcp-19, 0x1.3fffffe03e000p+35, -0x1.fff0400019704p-19},
+{-0x1.0000000000001p+35, 0x1.fffffc1000000p-32, -0x1.1ffffff01f000p+36, -0x1.ffffc000060fcp-19, -0x1.9ffffff01f001p+36, 0x1.00081fffed382p-18},
+{0x1.0000003800000p+43, 0x1.ffe000001fffcp-12, 0x1.0000007fffff0p+50, 0x1.fe1ffffc00000p-12, 0x1.020000806fff0p+50, 0x1.fefffffe10000p-11},
+{0x1.0000003800000p+43, 0x1.ffe000001fffcp-12, -0x1.0000007fffff0p+50, -0x1.fe1ffffc00000p-12, -0x1.fc0000ff1ffe0p+49, 0x1.c000042000000p-20},
+{-0x1.0000003800000p+43, -0x1.ffe000001fffcp-12, 0x1.0000007fffff0p+50, 0x1.fe1ffffc00000p-12, 0x1.fc0000ff1ffe0p+49, -0x1.c000042000000p-20},
+{-0x1.0000003800000p+43, -0x1.ffe000001fffcp-12, -0x1.0000007fffff0p+50, -0x1.fe1ffffc00000p-12, -0x1.020000806fff0p+50, -0x1.fefffffe10000p-11},
+{0x1.0000001fffc00p+32, 0x1.f00007ffe0000p-32, 0x1.0000000000180p+25, 0x1.fffffe0000800p-39, 0x1.0200001fffc03p+32, 0x1.f40007fbe0000p-32},
+{0x1.0000001fffc00p+32, 0x1.f00007ffe0000p-32, -0x1.0000000000180p+25, -0x1.fffffe0000800p-39, 0x1.fc00003fff7fap+31, 0x1.ec000803e0000p-32},
+{-0x1.0000001fffc00p+32, -0x1.f00007ffe0000p-32, 0x1.0000000000180p+25, 0x1.fffffe0000800p-39, -0x1.fc00003fff7fap+31, -0x1.ec000803e0000p-32},
+{-0x1.0000001fffc00p+32, -0x1.f00007ffe0000p-32, -0x1.0000000000180p+25, -0x1.fffffe0000800p-39, -0x1.0200001fffc03p+32, -0x1.f40007fbe0000p-32},
+{0x1.0000000008000p+19, -0x1.c0000007ffe04p-36, 0x1.00000fffffffep-53, 0x1.fc00000000000p-152, 0x1.0000000008000p+19, -0x1.bfff8007f7e04p-36},
+{0x1.0000000008000p+19, -0x1.c0000007ffe04p-36, -0x1.00000fffffffep-53, -0x1.fc00000000000p-152, 0x1.0000000008000p+19, -0x1.c000800807e04p-36},
+{-0x1.0000000008000p+19, 0x1.c0000007ffe04p-36, 0x1.00000fffffffep-53, 0x1.fc00000000000p-152, -0x1.0000000008000p+19, 0x1.c000800807e04p-36},
+{-0x1.0000000008000p+19, 0x1.c0000007ffe04p-36, -0x1.00000fffffffep-53, -0x1.fc00000000000p-152, -0x1.0000000008000p+19, 0x1.bfff8007f7e04p-36},
+{0x1.0000003e00004p+43, -0x1.fe00040000000p-27, 0x1.00007c0001e00p+8, 0x1.fffe13ffe0000p-56, 0x1.0000003e20005p+43, -0x1.000f78001f800p-14},
+{0x1.0000003e00004p+43, -0x1.fe00040000000p-27, -0x1.00007c0001e00p+8, -0x1.fffe13ffe0000p-56, 0x1.0000003de0003p+43, 0x1.ffdf2fffbf000p-15},
+{-0x1.0000003e00004p+43, 0x1.fe00040000000p-27, 0x1.00007c0001e00p+8, 0x1.fffe13ffe0000p-56, -0x1.0000003de0003p+43, -0x1.ffdf2fffbf000p-15},
+{-0x1.0000003e00004p+43, 0x1.fe00040000000p-27, -0x1.00007c0001e00p+8, -0x1.fffe13ffe0000p-56, -0x1.0000003e20005p+43, 0x1.000f78001f800p-14},
+{0x1.03fffffffc000p+44, 0x1.ffffffc000000p-31, 0x1.0003ffffff000p-28, 0x1.ffc0000000000p-123, 0x1.03fffffffc000p+44, 0x1.4003fff800000p-28},
+{0x1.03fffffffc000p+44, 0x1.ffffffc000000p-31, -0x1.0003ffffff000p-28, -0x1.ffc0000000000p-123, 0x1.03fffffffc000p+44, -0x1.8008001000000p-29},
+{-0x1.03fffffffc000p+44, -0x1.ffffffc000000p-31, 0x1.0003ffffff000p-28, 0x1.ffc0000000000p-123, -0x1.03fffffffc000p+44, 0x1.8008001000000p-29},
+{-0x1.03fffffffc000p+44, -0x1.ffffffc000000p-31, -0x1.0003ffffff000p-28, -0x1.ffc0000000000p-123, -0x1.03fffffffc000p+44, -0x1.4003fff800000p-28},
+{0x1.07ffffff80000p+48, 0x1.8007ffffc0000p-23, 0x1.0000000000004p-5, -0x1.fffc000200000p-74, 0x1.07ffffff80001p+48, -0x1.ffff3ffbffffap-6},
+{0x1.07ffffff80000p+48, 0x1.8007ffffc0000p-23, -0x1.0000000000004p-5, 0x1.fffc000200000p-74, 0x1.07ffffff80000p+48, -0x1.ffff3ffc0000ap-6},
+{-0x1.07ffffff80000p+48, -0x1.8007ffffc0000p-23, 0x1.0000000000004p-5, -0x1.fffc000200000p-74, -0x1.07ffffff80000p+48, 0x1.ffff3ffc0000ap-6},
+{-0x1.07ffffff80000p+48, -0x1.8007ffffc0000p-23, -0x1.0000000000004p-5, 0x1.fffc000200000p-74, -0x1.07ffffff80001p+48, 0x1.ffff3ffbffffap-6},
+{0x1.00003ffffff80p-25, 0x1.ffff0000ffe00p-87, 0x1.00003fffffff8p-48, 0x0.0000000000000p+0, 0x1.0000420000780p-25, 0x1.ffbf0000ffe00p-87},
+{0x1.00003ffffff80p-25, 0x1.ffff0000ffe00p-87, -0x1.00003fffffff8p-48, 0x0.0000000000000p+0, 0x1.00003dffff780p-25, 0x1.001f80007ff00p-86},
+{-0x1.00003ffffff80p-25, -0x1.ffff0000ffe00p-87, 0x1.00003fffffff8p-48, 0x0.0000000000000p+0, -0x1.00003dffff780p-25, -0x1.001f80007ff00p-86},
+{-0x1.00003ffffff80p-25, -0x1.ffff0000ffe00p-87, -0x1.00003fffffff8p-48, 0x0.0000000000000p+0, -0x1.0000420000780p-25, -0x1.ffbf0000ffe00p-87},
+{0x1.0000010000000p+29, -0x1.0000000000000p-76, 0x1.00f81ffffff81p-9, 0x1.fffff03c00000p-71, 0x1.000001000403ep+29, 0x1.ffffff81007e0p-29},
+{0x1.0000010000000p+29, -0x1.0000000000000p-76, -0x1.00f81ffffff81p-9, -0x1.fffff03c00000p-71, 0x1.000000fffbfc2p+29, -0x1.ffffff8100820p-29},
+{-0x1.0000010000000p+29, 0x1.0000000000000p-76, 0x1.00f81ffffff81p-9, 0x1.fffff03c00000p-71, -0x1.000000fffbfc2p+29, 0x1.ffffff8100820p-29},
+{-0x1.0000010000000p+29, 0x1.0000000000000p-76, -0x1.00f81ffffff81p-9, -0x1.fffff03c00000p-71, -0x1.000001000403ep+29, -0x1.ffffff81007e0p-29},
+{0x1.0000000000004p+5, -0x1.fff0008000000p-59, 0x1.0000000100000p+48, -0x1.fffffe0004000p-19, 0x1.0000000100200p+48, -0x1.fffffdc004000p-19},
+{0x1.0000000000004p+5, -0x1.fff0008000000p-59, -0x1.0000000100000p+48, 0x1.fffffe0004000p-19, -0x1.00000000ffe00p+48, 0x1.fffffe4004000p-19},
+{-0x1.0000000000004p+5, 0x1.fff0008000000p-59, 0x1.0000000100000p+48, -0x1.fffffe0004000p-19, 0x1.00000000ffe00p+48, -0x1.fffffe4004000p-19},
+{-0x1.0000000000004p+5, 0x1.fff0008000000p-59, -0x1.0000000100000p+48, 0x1.fffffe0004000p-19, -0x1.0000000100200p+48, 0x1.fffffdc004000p-19},
+{0x1.0000000000800p+23, -0x1.0000000000000p-55, 0x1.0000010000000p+11, -0x1.0000000000000p-92, 0x1.0010000010800p+23, -0x1.0000000000000p-55},
+{0x1.0000000000800p+23, -0x1.0000000000000p-55, -0x1.0000010000000p+11, 0x1.0000000000000p-92, 0x1.ffdfffffe1000p+22, -0x1.0000000000000p-55},
+{-0x1.0000000000800p+23, 0x1.0000000000000p-55, 0x1.0000010000000p+11, -0x1.0000000000000p-92, -0x1.ffdfffffe1000p+22, 0x1.0000000000000p-55},
+{-0x1.0000000000800p+23, 0x1.0000000000000p-55, -0x1.0000010000000p+11, 0x1.0000000000000p-92, -0x1.0010000010800p+23, 0x1.0000000000000p-55},
+{0x1.00000007fff00p-25, 0x1.fffc1ffff87f0p-81, 0x1.0000007c00000p-2, 0x1.fff0000000000p-73, 0x1.0000027c00001p-2, -0x1.bfc2007c00000p-70},
+{0x1.00000007fff00p-25, 0x1.fffc1ffff87f0p-81, -0x1.0000007c00000p-2, -0x1.fff0000000000p-73, -0x1.fffffcf7ffffep-3, -0x1.1fdf003e00000p-69},
+{-0x1.00000007fff00p-25, -0x1.fffc1ffff87f0p-81, 0x1.0000007c00000p-2, 0x1.fff0000000000p-73, 0x1.fffffcf7ffffep-3, 0x1.1fdf003e00000p-69},
+{-0x1.00000007fff00p-25, -0x1.fffc1ffff87f0p-81, -0x1.0000007c00000p-2, -0x1.fff0000000000p-73, -0x1.0000027c00001p-2, 0x1.bfc2007c00000p-70},
+{0x1.fffffffe00000p+40, 0x1.e000001fff800p-24, 0x1.00000001ffffep-36, 0x0.0000000000000p+0, 0x1.fffffffe00000p+40, 0x1.e010001fff800p-24},
+{0x1.fffffffe00000p+40, 0x1.e000001fff800p-24, -0x1.00000001ffffep-36, 0x0.0000000000000p+0, 0x1.fffffffe00000p+40, 0x1.dff0001fff800p-24},
+{-0x1.fffffffe00000p+40, -0x1.e000001fff800p-24, 0x1.00000001ffffep-36, 0x0.0000000000000p+0, -0x1.fffffffe00000p+40, -0x1.dff0001fff800p-24},
+{-0x1.fffffffe00000p+40, -0x1.e000001fff800p-24, -0x1.00000001ffffep-36, 0x0.0000000000000p+0, -0x1.fffffffe00000p+40, -0x1.e010001fff800p-24},
+{0x1.0000000000008p+12, -0x1.fffff00400000p-60, 0x1.00003ffffe000p-40, 0x1.ffffe00000000p-112, 0x1.0000000000009p+12, 0x1.ffffeffc00000p-60},
+{0x1.0000000000008p+12, -0x1.fffff00400000p-60, -0x1.00003ffffe000p-40, -0x1.ffffe00000000p-112, 0x1.0000000000007p+12, -0x1.7ffff40100000p-58},
+{-0x1.0000000000008p+12, 0x1.fffff00400000p-60, 0x1.00003ffffe000p-40, 0x1.ffffe00000000p-112, -0x1.0000000000007p+12, 0x1.7ffff40100000p-58},
+{-0x1.0000000000008p+12, 0x1.fffff00400000p-60, -0x1.00003ffffe000p-40, -0x1.ffffe00000000p-112, -0x1.0000000000009p+12, -0x1.ffffeffc00000p-60},
+{0x1.0000000000000p-26, 0x1.ffffffffffc00p-89, 0x1.000001ffe0000p+32, 0x1.ff87ff9f801c0p-27, 0x1.000001ffe0000p+32, 0x1.ffc3ffcfc00e0p-26},
+{0x1.0000000000000p-26, 0x1.ffffffffffc00p-89, -0x1.000001ffe0000p+32, -0x1.ff87ff9f801c0p-27, -0x1.000001ffe0000p+32, 0x1.e00181ff90000p-37},
+{-0x1.0000000000000p-26, -0x1.ffffffffffc00p-89, 0x1.000001ffe0000p+32, 0x1.ff87ff9f801c0p-27, 0x1.000001ffe0000p+32, -0x1.e00181ff90000p-37},
+{-0x1.0000000000000p-26, -0x1.ffffffffffc00p-89, -0x1.000001ffe0000p+32, -0x1.ff87ff9f801c0p-27, -0x1.000001ffe0000p+32, -0x1.ffc3ffcfc00e0p-26},
+{0x1.0000000000400p+5, -0x1.f800000002000p-56, 0x1.03fffffffff00p+2, 0x1.fffe7fffffffep-52, 0x1.20800000003e0p+5, 0x1.e07e7fffffe00p-52},
+{0x1.0000000000400p+5, -0x1.f800000002000p-56, -0x1.03fffffffff00p+2, -0x1.fffe7fffffffep-52, 0x1.bf00000000840p+4, -0x1.0fbf400000100p-51},
+{-0x1.0000000000400p+5, 0x1.f800000002000p-56, 0x1.03fffffffff00p+2, 0x1.fffe7fffffffep-52, -0x1.bf00000000840p+4, 0x1.0fbf400000100p-51},
+{-0x1.0000000000400p+5, 0x1.f800000002000p-56, -0x1.03fffffffff00p+2, -0x1.fffe7fffffffep-52, -0x1.20800000003e0p+5, -0x1.e07e7fffffe00p-52},
+{0x1.0000000000000p+13, 0x1.fffffffffff00p-43, 0x1.000007c000000p-28, 0x1.fff8000000000p-84, 0x1.0000000000800p+13, 0x1.01f0000000780p-42},
+{0x1.0000000000000p+13, 0x1.fffffffffff00p-43, -0x1.000007c000000p-28, -0x1.fff8000000000p-84, 0x1.ffffffffff000p+12, 0x1.fc1ffffffef00p-43},
+{-0x1.0000000000000p+13, -0x1.fffffffffff00p-43, 0x1.000007c000000p-28, 0x1.fff8000000000p-84, -0x1.ffffffffff000p+12, -0x1.fc1ffffffef00p-43},
+{-0x1.0000000000000p+13, -0x1.fffffffffff00p-43, -0x1.000007c000000p-28, -0x1.fff8000000000p-84, -0x1.0000000000800p+13, -0x1.01f0000000780p-42},
+{0x1.0000000000400p-35, -0x1.fffc0003fffd0p-92, 0x1.0000000000000p+4, 0x1.fffffff800000p-52, 0x1.0000000002000p+4, 0x1.0000003bff000p-51},
+{0x1.0000000000400p-35, -0x1.fffc0003fffd0p-92, -0x1.0000000000000p+4, -0x1.fffffff800000p-52, -0x1.fffffffffc000p+3, -0x1.ffffff7802000p-52},
+{-0x1.0000000000400p-35, 0x1.fffc0003fffd0p-92, 0x1.0000000000000p+4, 0x1.fffffff800000p-52, 0x1.fffffffffc000p+3, 0x1.ffffff7802000p-52},
+{-0x1.0000000000400p-35, 0x1.fffc0003fffd0p-92, -0x1.0000000000000p+4, -0x1.fffffff800000p-52, -0x1.0000000002000p+4, -0x1.0000003bff000p-51},
+{0x1.0000000002000p-51, -0x1.ffff040000000p-122, 0x1.03fffff800000p-40, 0x1.fffffe0000000p-108, 0x1.041ffff800004p-40, 0x1.fff7fe03f0000p-108},
+{0x1.0000000002000p-51, -0x1.ffff040000000p-122, -0x1.03fffff800000p-40, -0x1.fffffe0000000p-108, -0x1.03dffff7ffffcp-40, -0x1.0003fefe08000p-107},
+{-0x1.0000000002000p-51, 0x1.ffff040000000p-122, 0x1.03fffff800000p-40, 0x1.fffffe0000000p-108, 0x1.03dffff7ffffcp-40, 0x1.0003fefe08000p-107},
+{-0x1.0000000002000p-51, 0x1.ffff040000000p-122, -0x1.03fffff800000p-40, -0x1.fffffe0000000p-108, -0x1.041ffff800004p-40, -0x1.fff7fe03f0000p-108},
+{0x1.0000008000000p-21, -0x1.ffffff8200000p-78, 0x1.000fff8000000p+9, 0x1.fffffe0000000p-53, 0x1.000fff8400000p+9, 0x1.03fffffa00000p-46},
+{0x1.0000008000000p-21, -0x1.ffffff8200000p-78, -0x1.000fff8000000p+9, -0x1.fffffe0000000p-53, -0x1.000fff7c00000p+9, 0x1.f800000400000p-47},
+{-0x1.0000008000000p-21, 0x1.ffffff8200000p-78, 0x1.000fff8000000p+9, 0x1.fffffe0000000p-53, 0x1.000fff7c00000p+9, -0x1.f800000400000p-47},
+{-0x1.0000008000000p-21, 0x1.ffffff8200000p-78, -0x1.000fff8000000p+9, -0x1.fffffe0000000p-53, -0x1.000fff8400000p+9, -0x1.03fffffa00000p-46},
+{0x1.0000000000000p-33, 0x1.0001f9e000000p-93, 0x1.0000000000040p+19, -0x1.fffffc0080000p-53, 0x1.0000000000041p+19, -0x1.fffffc0080000p-53},
+{0x1.0000000000000p-33, 0x1.0001f9e000000p-93, -0x1.0000000000040p+19, 0x1.fffffc0080000p-53, -0x1.000000000003fp+19, 0x1.fffffc0080000p-53},
+{-0x1.0000000000000p-33, -0x1.0001f9e000000p-93, 0x1.0000000000040p+19, -0x1.fffffc0080000p-53, 0x1.000000000003fp+19, -0x1.fffffc0080000p-53},
+{-0x1.0000000000000p-33, -0x1.0001f9e000000p-93, -0x1.0000000000040p+19, 0x1.fffffc0080000p-53, -0x1.0000000000041p+19, 0x1.fffffc0080000p-53},
+{0x1.0000ff0007e00p-13, 0x1.ffc001ff00000p-80, 0x1.0000010000000p-33, -0x1.ffc007ffffe20p-91, 0x1.00010f0007f00p-13, 0x1.ff8009fe00000p-80},
+{0x1.0000ff0007e00p-13, 0x1.ffc001ff00000p-80, -0x1.0000010000000p-33, 0x1.ffc007ffffe20p-91, 0x1.0000ef0007d00p-13, 0x1.fffffa0000000p-80},
+{-0x1.0000ff0007e00p-13, -0x1.ffc001ff00000p-80, 0x1.0000010000000p-33, -0x1.ffc007ffffe20p-91, -0x1.0000ef0007d00p-13, -0x1.fffffa0000000p-80},
+{-0x1.0000ff0007e00p-13, -0x1.ffc001ff00000p-80, -0x1.0000010000000p-33, 0x1.ffc007ffffe20p-91, -0x1.00010f0007f00p-13, -0x1.ff8009fe00000p-80},
+{0x1.07ffffff1fe00p-53, 0x1.fc00000000000p-150, 0x1.0040000000000p-23, -0x1.c000000400000p-84, 0x1.0040000420000p-23, -0x1.1808000200000p-83},
+{0x1.07ffffff1fe00p-53, 0x1.fc00000000000p-150, -0x1.0040000000000p-23, 0x1.c000000400000p-84, -0x1.003ffffbe0000p-23, 0x1.4ff0000400000p-84},
+{-0x1.07ffffff1fe00p-53, -0x1.fc00000000000p-150, 0x1.0040000000000p-23, -0x1.c000000400000p-84, 0x1.003ffffbe0000p-23, -0x1.4ff0000400000p-84},
+{-0x1.07ffffff1fe00p-53, -0x1.fc00000000000p-150, -0x1.0040000000000p-23, 0x1.c000000400000p-84, -0x1.0040000420000p-23, 0x1.1808000200000p-83},
+{0x1.0080000000000p+15, -0x1.0000000000000p-90, 0x1.00000001fffc0p-35, 0x1.fffff80f80000p-107, 0x1.0080000000004p+15, 0x1.fffbfe0000000p-67},
+{0x1.0080000000000p+15, -0x1.0000000000000p-90, -0x1.00000001fffc0p-35, -0x1.fffff80f80000p-107, 0x1.007fffffffffcp+15, -0x1.fffc020000000p-67},
+{-0x1.0080000000000p+15, 0x1.0000000000000p-90, 0x1.00000001fffc0p-35, 0x1.fffff80f80000p-107, -0x1.007fffffffffcp+15, 0x1.fffc020000000p-67},
+{-0x1.0080000000000p+15, 0x1.0000000000000p-90, -0x1.00000001fffc0p-35, -0x1.fffff80f80000p-107, -0x1.0080000000004p+15, -0x1.fffbfe0000000p-67},
+{0x1.000000003ff00p+2, 0x0.0000000000000p+0, 0x1.0000000000000p+46, 0x1.f83007ffffe00p-14, 0x1.0000000000100p+46, 0x1.f83047efffe00p-14},
+{0x1.000000003ff00p+2, 0x0.0000000000000p+0, -0x1.0000000000000p+46, -0x1.f83007ffffe00p-14, -0x1.ffffffffffe00p+45, -0x1.f82fc80fffe00p-14},
+{-0x1.000000003ff00p+2, 0x0.0000000000000p+0, 0x1.0000000000000p+46, 0x1.f83007ffffe00p-14, 0x1.ffffffffffe00p+45, 0x1.f82fc80fffe00p-14},
+{-0x1.000000003ff00p+2, 0x0.0000000000000p+0, -0x1.0000000000000p+46, -0x1.f83007ffffe00p-14, -0x1.0000000000100p+46, -0x1.f83047efffe00p-14},
+{0x1.00003fffffe00p+13, 0x1.fffffc0000380p-47, 0x1.0000010000000p-8, -0x1.ffffff8000008p-64, 0x1.000047ffffe80p+13, 0x1.fffefc0000780p-47},
+{0x1.00003fffffe00p+13, 0x1.fffffc0000380p-47, -0x1.0000010000000p-8, 0x1.ffffff8000008p-64, 0x1.000037ffffd80p+13, 0x1.00007dfffffc0p-46},
+{-0x1.00003fffffe00p+13, -0x1.fffffc0000380p-47, 0x1.0000010000000p-8, -0x1.ffffff8000008p-64, -0x1.000037ffffd80p+13, -0x1.00007dfffffc0p-46},
+{-0x1.00003fffffe00p+13, -0x1.fffffc0000380p-47, -0x1.0000010000000p-8, 0x1.ffffff8000008p-64, -0x1.000047ffffe80p+13, -0x1.fffefc0000780p-47},
+{0x1.0000000080000p+13, -0x1.fffffc0010000p-56, 0x1.3fffff8000000p-19, 0x1.fffff800fe000p-85, 0x1.00000001c0000p+13, -0x1.001fffffbf010p-44},
+{0x1.0000000080000p+13, -0x1.fffffc0010000p-56, -0x1.3fffff8000000p-19, -0x1.fffff800fe000p-85, 0x1.fffffffe80000p+12, 0x1.ffc000007dfe0p-45},
+{-0x1.0000000080000p+13, 0x1.fffffc0010000p-56, 0x1.3fffff8000000p-19, 0x1.fffff800fe000p-85, -0x1.fffffffe80000p+12, -0x1.ffc000007dfe0p-45},
+{-0x1.0000000080000p+13, 0x1.fffffc0010000p-56, -0x1.3fffff8000000p-19, -0x1.fffff800fe000p-85, -0x1.00000001c0000p+13, 0x1.001fffffbf010p-44},
+{0x1.0003f001fc3f0p-13, 0x1.fffffc0000000p-69, 0x1.0000000000000p+27, 0x1.fc1fffc0000fep-27, 0x1.0000000001001p+27, -0x1.07df81303f702p-27},
+{0x1.0003f001fc3f0p-13, 0x1.fffffc0000000p-69, -0x1.0000000000000p+27, -0x1.fc1fffc0000fep-27, -0x1.fffffffffe001p+26, 0x1.ffc0fe9f80e04p-28},
+{-0x1.0003f001fc3f0p-13, -0x1.fffffc0000000p-69, 0x1.0000000000000p+27, 0x1.fc1fffc0000fep-27, 0x1.fffffffffe001p+26, -0x1.ffc0fe9f80e04p-28},
+{-0x1.0003f001fc3f0p-13, -0x1.fffffc0000000p-69, -0x1.0000000000000p+27, -0x1.fc1fffc0000fep-27, -0x1.0000000001001p+27, 0x1.07df81303f702p-27},
+{0x1.0000000000000p+49, 0x1.fffffffffffc0p-10, 0x1.0000000000000p+12, 0x1.ffffffffffe00p-50, 0x1.0000000008000p+49, 0x1.0000000000fe0p-9},
+{0x1.0000000000000p+49, 0x1.fffffffffffc0p-10, -0x1.0000000000000p+12, -0x1.ffffffffffe00p-50, 0x1.fffffffff0000p+48, 0x1.fffffffffdfc0p-10},
+{-0x1.0000000000000p+49, -0x1.fffffffffffc0p-10, 0x1.0000000000000p+12, 0x1.ffffffffffe00p-50, -0x1.fffffffff0000p+48, -0x1.fffffffffdfc0p-10},
+{-0x1.0000000000000p+49, -0x1.fffffffffffc0p-10, -0x1.0000000000000p+12, -0x1.ffffffffffe00p-50, -0x1.0000000008000p+49, -0x1.0000000000fe0p-9},
+{0x1.0000000100000p-51, -0x1.0000000000000p-130, 0x1.0000004000000p+23, -0x1.0000000000000p-57, 0x1.0000004000000p+23, 0x1.f800000000000p-52},
+{0x1.0000000100000p-51, -0x1.0000000000000p-130, -0x1.0000004000000p+23, 0x1.0000000000000p-57, -0x1.0000004000000p+23, 0x1.0400000000000p-51},
+{-0x1.0000000100000p-51, 0x1.0000000000000p-130, 0x1.0000004000000p+23, -0x1.0000000000000p-57, 0x1.0000004000000p+23, -0x1.0400000000000p-51},
+{-0x1.0000000100000p-51, 0x1.0000000000000p-130, -0x1.0000004000000p+23, 0x1.0000000000000p-57, -0x1.0000004000000p+23, -0x1.f800000000000p-52},
+{0x1.0000010000000p-27, -0x1.ffffe00001000p-83, 0x1.000ffffff007fp-2, 0x1.ffffc00000000p-83, 0x1.0010007ff0087p-2, -0x1.0000000000000p-102},
+{0x1.0000010000000p-27, -0x1.ffffe00001000p-83, -0x1.000ffffff007fp-2, -0x1.ffffc00000000p-83, -0x1.000fff7ff0077p-2, -0x1.ffffd00000000p-82},
+{-0x1.0000010000000p-27, 0x1.ffffe00001000p-83, 0x1.000ffffff007fp-2, 0x1.ffffc00000000p-83, 0x1.000fff7ff0077p-2, 0x1.ffffd00000000p-82},
+{-0x1.0000010000000p-27, 0x1.ffffe00001000p-83, -0x1.000ffffff007fp-2, -0x1.ffffc00000000p-83, -0x1.0010007ff0087p-2, 0x1.0000000000000p-102},
+{0x1.1000fffffc000p+50, 0x1.fffffc003f000p-6, 0x1.0000000001000p+30, -0x1.0000000000000p-75, 0x1.10010ffffc000p+50, 0x1.07fffe001f800p-5},
+{0x1.1000fffffc000p+50, 0x1.fffffc003f000p-6, -0x1.0000000001000p+30, 0x1.0000000000000p-75, 0x1.1000effffc000p+50, 0x1.effffc003f000p-6},
+{-0x1.1000fffffc000p+50, -0x1.fffffc003f000p-6, 0x1.0000000001000p+30, -0x1.0000000000000p-75, -0x1.1000effffc000p+50, -0x1.effffc003f000p-6},
+{-0x1.1000fffffc000p+50, -0x1.fffffc003f000p-6, -0x1.0000000001000p+30, 0x1.0000000000000p-75, -0x1.10010ffffc000p+50, -0x1.07fffe001f800p-5},
+{0x1.00000fff80000p+32, 0x1.fffe000000000p-53, 0x1.0000001f00000p+41, 0x1.fffffff000000p-36, 0x1.00800026ffc00p+41, 0x1.00007ff800000p-35},
+{0x1.00000fff80000p+32, 0x1.fffe000000000p-53, -0x1.0000001f00000p+41, -0x1.fffffff000000p-36, -0x1.ff00002e00800p+40, -0x1.fffefff000000p-36},
+{-0x1.00000fff80000p+32, -0x1.fffe000000000p-53, 0x1.0000001f00000p+41, 0x1.fffffff000000p-36, 0x1.ff00002e00800p+40, 0x1.fffefff000000p-36},
+{-0x1.00000fff80000p+32, -0x1.fffe000000000p-53, -0x1.0000001f00000p+41, -0x1.fffffff000000p-36, -0x1.00800026ffc00p+41, -0x1.00007ff800000p-35},
+{0x1.3fdfffff02000p+34, -0x1.0000000000000p-44, 0x1.0000000000000p+31, 0x1.ffffffffffe00p-30, 0x1.5fdfffff02000p+34, 0x1.fffc000000000p-30},
+{0x1.3fdfffff02000p+34, -0x1.0000000000000p-44, -0x1.0000000000000p+31, -0x1.ffffffffffe00p-30, 0x1.1fdfffff02000p+34, -0x1.0002000000000p-29},
+{-0x1.3fdfffff02000p+34, 0x1.0000000000000p-44, 0x1.0000000000000p+31, 0x1.ffffffffffe00p-30, -0x1.1fdfffff02000p+34, 0x1.0002000000000p-29},
+{-0x1.3fdfffff02000p+34, 0x1.0000000000000p-44, -0x1.0000000000000p+31, -0x1.ffffffffffe00p-30, -0x1.5fdfffff02000p+34, -0x1.fffc000000000p-30},
+{0x1.0000000000008p+41, -0x1.e0ffffd002000p-25, 0x1.0000000000400p+36, 0x1.ffffffff03ffep-18, 0x1.0800000000028p+41, 0x1.fc3dffff63fc0p-18},
+{0x1.0000000000008p+41, -0x1.e0ffffd002000p-25, -0x1.0000000000400p+36, -0x1.ffffffff03ffep-18, 0x1.effffffffffd0p+40, -0x1.01e0ffff52020p-17},
+{-0x1.0000000000008p+41, 0x1.e0ffffd002000p-25, 0x1.0000000000400p+36, 0x1.ffffffff03ffep-18, -0x1.effffffffffd0p+40, 0x1.01e0ffff52020p-17},
+{-0x1.0000000000008p+41, 0x1.e0ffffd002000p-25, -0x1.0000000000400p+36, -0x1.ffffffff03ffep-18, -0x1.0800000000028p+41, -0x1.fc3dffff63fc0p-18},
+{0x1.000000fffe020p+17, -0x1.f800100000000p-56, 0x1.0001fff80ffc0p+20, 0x1.ff00000000000p-77, 0x1.200200180fbc4p+20, -0x1.f800000800000p-56},
+{0x1.000000fffe020p+17, -0x1.f800100000000p-56, -0x1.0001fff80ffc0p+20, -0x1.ff00000000000p-77, -0x1.c003ffb020778p+19, -0x1.f8001ff800000p-56},
+{-0x1.000000fffe020p+17, 0x1.f800100000000p-56, 0x1.0001fff80ffc0p+20, 0x1.ff00000000000p-77, 0x1.c003ffb020778p+19, 0x1.f8001ff800000p-56},
+{-0x1.000000fffe020p+17, 0x1.f800100000000p-56, -0x1.0001fff80ffc0p+20, -0x1.ff00000000000p-77, -0x1.200200180fbc4p+20, 0x1.f800000800000p-56},
+{0x1.4000000000000p+46, -0x1.0000000000000p-59, 0x1.0000000000010p-11, 0x1.e000000000000p-79, 0x1.4000000000000p+46, 0x1.0000000000000p-11},
+{0x1.4000000000000p+46, -0x1.0000000000000p-59, -0x1.0000000000010p-11, -0x1.e000000000000p-79, 0x1.4000000000000p+46, -0x1.0000000000020p-11},
+{-0x1.4000000000000p+46, 0x1.0000000000000p-59, 0x1.0000000000010p-11, 0x1.e000000000000p-79, -0x1.4000000000000p+46, 0x1.0000000000020p-11},
+{-0x1.4000000000000p+46, 0x1.0000000000000p-59, -0x1.0000000000010p-11, -0x1.e000000000000p-79, -0x1.4000000000000p+46, -0x1.0000000000000p-11},
+{0x1.2000000000000p+0, -0x1.fffffff01ff20p-57, 0x1.0000000000000p-33, 0x1.fff8003ff0000p-90, 0x1.2000000080000p+0, -0x1.ffffffef1ff60p-57},
+{0x1.2000000000000p+0, -0x1.fffffff01ff20p-57, -0x1.0000000000000p-33, -0x1.fff8003ff0000p-90, 0x1.1fffffff80000p+0, -0x1.fffffff11fee0p-57},
+{-0x1.2000000000000p+0, 0x1.fffffff01ff20p-57, 0x1.0000000000000p-33, 0x1.fff8003ff0000p-90, -0x1.1fffffff80000p+0, 0x1.fffffff11fee0p-57},
+{-0x1.2000000000000p+0, 0x1.fffffff01ff20p-57, -0x1.0000000000000p-33, -0x1.fff8003ff0000p-90, -0x1.2000000080000p+0, 0x1.ffffffef1ff60p-57},
+{0x1.2000000000000p+14, -0x1.fc08000000000p-78, 0x1.0000000038004p+6, -0x1.fffffc4000000p-63, 0x1.2100000000380p+14, 0x1.ffff7fff02ec0p-45},
+{0x1.2000000000000p+14, -0x1.fc08000000000p-78, -0x1.0000000038004p+6, 0x1.fffffc4000000p-63, 0x1.1effffffffc80p+14, -0x1.ffff8000fef40p-45},
+{-0x1.2000000000000p+14, 0x1.fc08000000000p-78, 0x1.0000000038004p+6, -0x1.fffffc4000000p-63, -0x1.1effffffffc80p+14, 0x1.ffff8000fef40p-45},
+{-0x1.2000000000000p+14, 0x1.fc08000000000p-78, -0x1.0000000038004p+6, 0x1.fffffc4000000p-63, -0x1.2100000000380p+14, -0x1.ffff7fff02ec0p-45},
+{0x1.0000000000200p+30, 0x0.0000000000000p+0, 0x1.00001ffff0000p+10, 0x1.ffff80001f000p-47, 0x1.0000100002200p+30, -0x1.ffffe00008000p-27},
+{0x1.0000000000200p+30, 0x0.0000000000000p+0, -0x1.00001ffff0000p+10, -0x1.ffff80001f000p-47, 0x1.ffffdffffc400p+29, 0x1.ffffe00008000p-27},
+{-0x1.0000000000200p+30, 0x0.0000000000000p+0, 0x1.00001ffff0000p+10, 0x1.ffff80001f000p-47, -0x1.ffffdffffc400p+29, -0x1.ffffe00008000p-27},
+{-0x1.0000000000200p+30, 0x0.0000000000000p+0, -0x1.00001ffff0000p+10, -0x1.ffff80001f000p-47, -0x1.0000100002200p+30, 0x1.ffffe00008000p-27},
+{0x1.0000100000000p-17, -0x1.0000000000000p-122, 0x1.0038000800000p+15, -0x1.fffffe0000080p-45, 0x1.0038000900001p+15, -0x1.fffffe0000080p-45},
+{0x1.0000100000000p-17, -0x1.0000000000000p-122, -0x1.0038000800000p+15, 0x1.fffffe0000080p-45, -0x1.00380006fffffp+15, 0x1.fffffe0000080p-45},
+{-0x1.0000100000000p-17, 0x1.0000000000000p-122, 0x1.0038000800000p+15, -0x1.fffffe0000080p-45, 0x1.00380006fffffp+15, -0x1.fffffe0000080p-45},
+{-0x1.0000100000000p-17, 0x1.0000000000000p-122, -0x1.0038000800000p+15, 0x1.fffffe0000080p-45, -0x1.0038000900001p+15, 0x1.fffffe0000080p-45},
+{0x1.0000000000004p-11, -0x1.ffffe00400000p-84, 0x1.0000000000000p-12, 0x1.ffffffffffff8p-68, 0x1.8000000000004p-11, 0x1.fffe00001ffc0p-68},
+{0x1.0000000000004p-11, -0x1.ffffe00400000p-84, -0x1.0000000000000p-12, -0x1.ffffffffffff8p-68, 0x1.0000000000008p-12, -0x1.0000fffff001cp-67},
+{-0x1.0000000000004p-11, 0x1.ffffe00400000p-84, 0x1.0000000000000p-12, 0x1.ffffffffffff8p-68, -0x1.0000000000008p-12, 0x1.0000fffff001cp-67},
+{-0x1.0000000000004p-11, 0x1.ffffe00400000p-84, -0x1.0000000000000p-12, -0x1.ffffffffffff8p-68, -0x1.8000000000004p-11, -0x1.fffe00001ffc0p-68},
+{0x1.0000000000100p-33, -0x1.ffffe7e400000p-103, 0x1.1ffe000008000p-33, -0x1.fffc000004000p-100, 0x1.0fff000004080p-32, -0x1.1ffdfe7e40000p-99},
+{0x1.0000000000100p-33, -0x1.ffffe7e400000p-103, -0x1.1ffe000008000p-33, 0x1.fffc000004000p-100, -0x1.ffe000007f000p-37, 0x1.bffc030384000p-100},
+{-0x1.0000000000100p-33, 0x1.ffffe7e400000p-103, 0x1.1ffe000008000p-33, -0x1.fffc000004000p-100, 0x1.ffe000007f000p-37, -0x1.bffc030384000p-100},
+{-0x1.0000000000100p-33, 0x1.ffffe7e400000p-103, -0x1.1ffe000008000p-33, 0x1.fffc000004000p-100, -0x1.0fff000004080p-32, 0x1.1ffdfe7e40000p-99},
+{0x1.0000000000004p-52, -0x1.0000000000000p-157, 0x1.00000007ffffep-10, 0x1.ffffe000f0000p-71, 0x1.00000008003fep-10, 0x1.ffffe002f0000p-71},
+{0x1.0000000000004p-52, -0x1.0000000000000p-157, -0x1.00000007ffffep-10, -0x1.ffffe000f0000p-71, -0x1.00000007ffbfep-10, -0x1.ffffdffef0000p-71},
+{-0x1.0000000000004p-52, 0x1.0000000000000p-157, 0x1.00000007ffffep-10, 0x1.ffffe000f0000p-71, 0x1.00000007ffbfep-10, 0x1.ffffdffef0000p-71},
+{-0x1.0000000000004p-52, 0x1.0000000000000p-157, -0x1.00000007ffffep-10, -0x1.ffffe000f0000p-71, -0x1.00000008003fep-10, -0x1.ffffe002f0000p-71},
+{0x1.0000000000000p+3, 0x1.fffffff000000p-58, 0x1.0001fffc00001p-42, -0x1.0000000000000p-121, 0x1.0000000000080p+3, 0x1.fffdfff808000p-57},
+{0x1.0000000000000p+3, 0x1.fffffff000000p-58, -0x1.0001fffc00001p-42, 0x1.0000000000000p-121, 0x1.fffffffffff00p+2, 0x1.fff7f80000000p-73},
+{-0x1.0000000000000p+3, -0x1.fffffff000000p-58, 0x1.0001fffc00001p-42, -0x1.0000000000000p-121, -0x1.fffffffffff00p+2, -0x1.fff7f80000000p-73},
+{-0x1.0000000000000p+3, -0x1.fffffff000000p-58, -0x1.0001fffc00001p-42, 0x1.0000000000000p-121, -0x1.0000000000080p+3, -0x1.fffdfff808000p-57},
+{0x1.00007fdfffff0p+50, 0x1.fff000f803fe0p-8, 0x1.0080000000000p-8, -0x1.0000000000000p-100, 0x1.00007fdfffff0p+50, 0x1.8038007c01ff0p-7},
+{0x1.00007fdfffff0p+50, 0x1.fff000f803fe0p-8, -0x1.0080000000000p-8, 0x1.0000000000000p-100, 0x1.00007fdfffff0p+50, 0x1.fee001f007fc0p-9},
+{-0x1.00007fdfffff0p+50, -0x1.fff000f803fe0p-8, 0x1.0080000000000p-8, -0x1.0000000000000p-100, -0x1.00007fdfffff0p+50, -0x1.fee001f007fc0p-9},
+{-0x1.00007fdfffff0p+50, -0x1.fff000f803fe0p-8, -0x1.0080000000000p-8, 0x1.0000000000000p-100, -0x1.00007fdfffff0p+50, -0x1.8038007c01ff0p-7},
+{0x1.0000000000080p+4, 0x0.0000000000000p+0, 0x1.0000080000000p+20, -0x1.0000000000000p-65, 0x1.0001080000000p+20, 0x1.fffffe0000000p-42},
+{0x1.0000000000080p+4, 0x0.0000000000000p+0, -0x1.0000080000000p+20, 0x1.0000000000000p-65, -0x1.fffe100000000p+19, 0x1.0000010000000p-41},
+{-0x1.0000000000080p+4, 0x0.0000000000000p+0, 0x1.0000080000000p+20, -0x1.0000000000000p-65, 0x1.fffe100000000p+19, -0x1.0000010000000p-41},
+{-0x1.0000000000080p+4, 0x0.0000000000000p+0, -0x1.0000080000000p+20, 0x1.0000000000000p-65, -0x1.0001080000000p+20, -0x1.fffffe0000000p-42},
+{0x1.0400000000000p+20, -0x1.0000000000000p-85, 0x1.0000000000400p+5, -0x1.fffff00008000p-51, 0x1.0402000000000p+20, 0x1.fff000007ffe0p-38},
+{0x1.0400000000000p+20, -0x1.0000000000000p-85, -0x1.0000000000400p+5, 0x1.fffff00008000p-51, 0x1.03fe000000000p+20, -0x1.fff0000080020p-38},
+{-0x1.0400000000000p+20, 0x1.0000000000000p-85, 0x1.0000000000400p+5, -0x1.fffff00008000p-51, -0x1.03fe000000000p+20, 0x1.fff0000080020p-38},
+{-0x1.0400000000000p+20, 0x1.0000000000000p-85, -0x1.0000000000400p+5, 0x1.fffff00008000p-51, -0x1.0402000000000p+20, -0x1.fff000007ffe0p-38},
+{0x1.0000000000001p+43, -0x1.fc0000c004000p-22, 0x1.0000000000200p+29, -0x1.ffe0000200000p-39, 0x1.0004000000001p+43, 0x1.fc07fdfe9ff80p-15},
+{0x1.0000000000001p+43, -0x1.fc0000c004000p-22, -0x1.0000000000200p+29, 0x1.ffe0000200000p-39, 0x1.fff8000000002p+42, -0x1.01fbff00d0040p-14},
+{-0x1.0000000000001p+43, 0x1.fc0000c004000p-22, 0x1.0000000000200p+29, -0x1.ffe0000200000p-39, -0x1.fff8000000002p+42, 0x1.01fbff00d0040p-14},
+{-0x1.0000000000001p+43, 0x1.fc0000c004000p-22, -0x1.0000000000200p+29, 0x1.ffe0000200000p-39, -0x1.0004000000001p+43, -0x1.fc07fdfe9ff80p-15},
+{0x1.00000c0000004p+1, -0x1.ff80000800000p-67, 0x1.18003ffff8000p+4, 0x1.ffffff8000000p-62, 0x1.3800417ff8001p+4, -0x1.ffe0ffc008040p-50},
+{0x1.00000c0000004p+1, -0x1.ff80000800000p-67, -0x1.18003ffff8000p+4, -0x1.ffffff8000000p-62, -0x1.f0007cffeffffp+3, -0x1.07fdffc020000p-61},
+{-0x1.00000c0000004p+1, 0x1.ff80000800000p-67, 0x1.18003ffff8000p+4, 0x1.ffffff8000000p-62, 0x1.f0007cffeffffp+3, 0x1.07fdffc020000p-61},
+{-0x1.00000c0000004p+1, 0x1.ff80000800000p-67, -0x1.18003ffff8000p+4, -0x1.ffffff8000000p-62, -0x1.3800417ff8001p+4, 0x1.ffe0ffc008040p-50},
+{0x1.1ffff80000040p+31, -0x1.0000000000000p-59, 0x1.000000000fe00p+44, 0x1.ffff7e0003ff8p-12, 0x1.0008ffffcfe00p+44, 0x1.0fffbf0001fecp-11},
+{0x1.1ffff80000040p+31, -0x1.0000000000000p-59, -0x1.000000000fe00p+44, -0x1.ffff7e0003ff8p-12, -0x1.ffee00009fc00p+43, -0x1.dfff7e0004018p-12},
+{-0x1.1ffff80000040p+31, 0x1.0000000000000p-59, 0x1.000000000fe00p+44, 0x1.ffff7e0003ff8p-12, 0x1.ffee00009fc00p+43, 0x1.dfff7e0004018p-12},
+{-0x1.1ffff80000040p+31, 0x1.0000000000000p-59, -0x1.000000000fe00p+44, -0x1.ffff7e0003ff8p-12, -0x1.0008ffffcfe00p+44, -0x1.0fffbf0001fecp-11},
+{0x1.3fc0000040000p-13, -0x1.fffffff802000p-69, 0x1.fffffffffff00p+30, 0x0.0000000000000p+0, 0x1.00000000000c0p+31, -0x1.fffffe0000100p-24},
+{0x1.3fc0000040000p-13, -0x1.fffffff802000p-69, -0x1.fffffffffff00p+30, 0x0.0000000000000p+0, -0x1.ffffffffffc80p+30, -0x1.fffffe0000100p-24},
+{-0x1.3fc0000040000p-13, 0x1.fffffff802000p-69, 0x1.fffffffffff00p+30, 0x0.0000000000000p+0, 0x1.ffffffffffc80p+30, 0x1.fffffe0000100p-24},
+{-0x1.3fc0000040000p-13, 0x1.fffffff802000p-69, -0x1.fffffffffff00p+30, 0x0.0000000000000p+0, -0x1.00000000000c0p+31, 0x1.fffffe0000100p-24},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, 0x1.0000000000200p-15, -0x1.0000000000000p-120, 0x1.00040001fffffp-1, 0x1.000400007e000p-58},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, -0x1.0000000000200p-15, 0x1.0000000000000p-120, 0x1.fff80003ffffep-2, -0x1.fff7ffff04000p-59},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, 0x1.0000000000200p-15, -0x1.0000000000000p-120, -0x1.fff80003ffffep-2, 0x1.fff7ffff04000p-59},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, -0x1.0000000000200p-15, 0x1.0000000000000p-120, -0x1.00040001fffffp-1, -0x1.000400007e000p-58},
+{0x1.0000000010000p+26, -0x1.0000000000000p-51, 0x1.1fff010000000p-53, 0x1.ff8c0000007fep-107, 0x1.0000000010000p+26, -0x1.70007f8000000p-52},
+{0x1.0000000010000p+26, -0x1.0000000000000p-51, -0x1.1fff010000000p-53, -0x1.ff8c0000007fep-107, 0x1.0000000010000p+26, -0x1.47ffc04000000p-51},
+{-0x1.0000000010000p+26, 0x1.0000000000000p-51, 0x1.1fff010000000p-53, 0x1.ff8c0000007fep-107, -0x1.0000000010000p+26, 0x1.47ffc04000000p-51},
+{-0x1.0000000010000p+26, 0x1.0000000000000p-51, -0x1.1fff010000000p-53, -0x1.ff8c0000007fep-107, -0x1.0000000010000p+26, 0x1.70007f8000000p-52},
+{0x1.0000000000002p-44, -0x1.0000000000000p-131, 0x1.0000000000200p+33, -0x1.0000000000000p-52, 0x1.0000000000200p+33, 0x1.fe00000000000p-45},
+{0x1.0000000000002p-44, -0x1.0000000000000p-131, -0x1.0000000000200p+33, 0x1.0000000000000p-52, -0x1.0000000000200p+33, 0x1.0100000000000p-44},
+{-0x1.0000000000002p-44, 0x1.0000000000000p-131, 0x1.0000000000200p+33, -0x1.0000000000000p-52, 0x1.0000000000200p+33, -0x1.0100000000000p-44},
+{-0x1.0000000000002p-44, 0x1.0000000000000p-131, -0x1.0000000000200p+33, 0x1.0000000000000p-52, -0x1.0000000000200p+33, -0x1.fe00000000000p-45},
+{0x1.0000000000002p+32, -0x1.ffff800008000p-35, 0x1.000000003fffep-25, 0x1.f81fc007c0000p-96, 0x1.0000000000002p+32, 0x1.ff0000407ffc0p-26},
+{0x1.0000000000002p+32, -0x1.ffff800008000p-35, -0x1.000000003fffep-25, -0x1.f81fc007c0000p-96, 0x1.0000000000002p+32, -0x1.007fffe040020p-25},
+{-0x1.0000000000002p+32, 0x1.ffff800008000p-35, 0x1.000000003fffep-25, 0x1.f81fc007c0000p-96, -0x1.0000000000002p+32, 0x1.007fffe040020p-25},
+{-0x1.0000000000002p+32, 0x1.ffff800008000p-35, -0x1.000000003fffep-25, -0x1.f81fc007c0000p-96, -0x1.0000000000002p+32, -0x1.ff0000407ffc0p-26},
+{0x1.7ffffffff0000p+18, 0x1.ffff07fffc000p-46, 0x1.000000000ffe0p-32, 0x1.ff0000003c000p-95, 0x1.7ffffffff0004p+18, 0x1.ffff0bff7c000p-46},
+{0x1.7ffffffff0000p+18, 0x1.ffff07fffc000p-46, -0x1.000000000ffe0p-32, -0x1.ff0000003c000p-95, 0x1.7fffffffefffcp+18, 0x1.ffff04007c000p-46},
+{-0x1.7ffffffff0000p+18, -0x1.ffff07fffc000p-46, 0x1.000000000ffe0p-32, 0x1.ff0000003c000p-95, -0x1.7fffffffefffcp+18, -0x1.ffff04007c000p-46},
+{-0x1.7ffffffff0000p+18, -0x1.ffff07fffc000p-46, -0x1.000000000ffe0p-32, -0x1.ff0000003c000p-95, -0x1.7ffffffff0004p+18, -0x1.ffff0bff7c000p-46},
+{0x1.00007fff00080p-52, -0x1.ffffff0001000p-117, 0x1.00000000007c0p+41, 0x1.ffffff8000000p-26, 0x1.00000000007c0p+41, 0x1.ffffffc000000p-26},
+{0x1.00007fff00080p-52, -0x1.ffffff0001000p-117, -0x1.00000000007c0p+41, -0x1.ffffff8000000p-26, -0x1.00000000007c0p+41, -0x1.ffffff4000000p-26},
+{-0x1.00007fff00080p-52, 0x1.ffffff0001000p-117, 0x1.00000000007c0p+41, 0x1.ffffff8000000p-26, 0x1.00000000007c0p+41, 0x1.ffffff4000000p-26},
+{-0x1.00007fff00080p-52, 0x1.ffffff0001000p-117, -0x1.00000000007c0p+41, -0x1.ffffff8000000p-26, -0x1.00000000007c0p+41, -0x1.ffffffc000000p-26},
+{0x1.1fff81ff00000p+13, 0x1.e007ffff00000p-44, 0x1.1ffffffff8000p-5, 0x1.fe001ffffffe0p-61, 0x1.1fffc9ff00000p+13, -0x1.0ffb808078000p-43},
+{0x1.1fff81ff00000p+13, 0x1.e007ffff00000p-44, -0x1.1ffffffff8000p-5, -0x1.fe001ffffffe0p-61, 0x1.1fff39ff00000p+13, 0x1.7801c03fbc000p-42},
+{-0x1.1fff81ff00000p+13, -0x1.e007ffff00000p-44, 0x1.1ffffffff8000p-5, 0x1.fe001ffffffe0p-61, -0x1.1fff39ff00000p+13, -0x1.7801c03fbc000p-42},
+{-0x1.1fff81ff00000p+13, -0x1.e007ffff00000p-44, -0x1.1ffffffff8000p-5, -0x1.fe001ffffffe0p-61, -0x1.1fffc9ff00000p+13, 0x1.0ffb808078000p-43},
+{0x1.0000000000000p+15, 0x1.fffc03fe00700p-46, 0x1.0000000000001p+24, -0x1.fff8060000f34p-31, 0x1.0080000000001p+24, -0x1.fff40607f8f74p-31},
+{0x1.0000000000000p+15, 0x1.fffc03fe00700p-46, -0x1.0000000000001p+24, 0x1.fff8060000f34p-31, -0x1.ff00000000002p+23, 0x1.fffc05f808ef4p-31},
+{-0x1.0000000000000p+15, -0x1.fffc03fe00700p-46, 0x1.0000000000001p+24, -0x1.fff8060000f34p-31, 0x1.ff00000000002p+23, -0x1.fffc05f808ef4p-31},
+{-0x1.0000000000000p+15, -0x1.fffc03fe00700p-46, -0x1.0000000000001p+24, 0x1.fff8060000f34p-31, -0x1.0080000000001p+24, 0x1.fff40607f8f74p-31},
+{0x1.001ffffc00080p+19, -0x1.fe00000200000p-42, 0x1.0000000001000p-24, -0x1.fe3ffffff0080p-84, 0x1.001ffffc00280p+19, -0x1.fdfffc0200800p-42},
+{0x1.001ffffc00080p+19, -0x1.fe00000200000p-42, -0x1.0000000001000p-24, 0x1.fe3ffffff0080p-84, 0x1.001ffffbffe80p+19, -0x1.fe000401ff800p-42},
+{-0x1.001ffffc00080p+19, 0x1.fe00000200000p-42, 0x1.0000000001000p-24, -0x1.fe3ffffff0080p-84, -0x1.001ffffbffe80p+19, 0x1.fe000401ff800p-42},
+{-0x1.001ffffc00080p+19, 0x1.fe00000200000p-42, -0x1.0000000001000p-24, 0x1.fe3ffffff0080p-84, -0x1.001ffffc00280p+19, 0x1.fdfffc0200800p-42},
+{0x1.00001fffff800p+37, 0x1.ffffff801ffc0p-22, 0x1.0000000002000p+12, -0x1.0000000000000p-93, 0x1.0000207fff800p+37, 0x1.03ffffc00ffe0p-21},
+{0x1.00001fffff800p+37, 0x1.ffffff801ffc0p-22, -0x1.0000000002000p+12, 0x1.0000000000000p-93, 0x1.00001f7fff800p+37, 0x1.f7ffff801ffc0p-22},
+{-0x1.00001fffff800p+37, -0x1.ffffff801ffc0p-22, 0x1.0000000002000p+12, -0x1.0000000000000p-93, -0x1.00001f7fff800p+37, -0x1.f7ffff801ffc0p-22},
+{-0x1.00001fffff800p+37, -0x1.ffffff801ffc0p-22, -0x1.0000000002000p+12, 0x1.0000000000000p-93, -0x1.0000207fff800p+37, -0x1.03ffffc00ffe0p-21},
+{0x1.0000000000000p-40, 0x1.ffff83ffbfff0p-96, 0x1.0000000000000p-34, 0x1.ffffffffe0000p-90, 0x1.0400000000000p-34, 0x1.03ffff07ef800p-89},
+{0x1.0000000000000p-40, 0x1.ffff83ffbfff0p-96, -0x1.0000000000000p-34, -0x1.ffffffffe0000p-90, -0x1.f800000000000p-35, -0x1.f80001efe1000p-90},
+{-0x1.0000000000000p-40, -0x1.ffff83ffbfff0p-96, 0x1.0000000000000p-34, 0x1.ffffffffe0000p-90, 0x1.f800000000000p-35, 0x1.f80001efe1000p-90},
+{-0x1.0000000000000p-40, -0x1.ffff83ffbfff0p-96, -0x1.0000000000000p-34, -0x1.ffffffffe0000p-90, -0x1.0400000000000p-34, -0x1.03ffff07ef800p-89},
+{0x1.0000000000000p+39, 0x1.fffe7ff3dff00p-22, 0x1.000007f830000p+13, 0x1.fff0000ffe100p-48, 0x1.0000004000020p+39, -0x1.e4000bfc61208p-17},
+{0x1.0000000000000p+39, 0x1.fffe7ff3dff00p-22, -0x1.000007f830000p+13, -0x1.fff0000ffe100p-48, 0x1.ffffff7ffffc0p+38, 0x1.01fff9fdcf8fcp-16},
+{-0x1.0000000000000p+39, -0x1.fffe7ff3dff00p-22, 0x1.000007f830000p+13, 0x1.fff0000ffe100p-48, -0x1.ffffff7ffffc0p+38, -0x1.01fff9fdcf8fcp-16},
+{-0x1.0000000000000p+39, -0x1.fffe7ff3dff00p-22, -0x1.000007f830000p+13, -0x1.fff0000ffe100p-48, -0x1.0000004000020p+39, 0x1.e4000bfc61208p-17},
+{0x1.00000ffffe000p+18, 0x1.fffffffffc000p-49, 0x1.0000000000002p-46, -0x1.fffffe01f8004p-101, 0x1.00000ffffe000p+18, 0x1.3fffffffff800p-46},
+{0x1.00000ffffe000p+18, 0x1.fffffffffc000p-49, -0x1.0000000000002p-46, 0x1.fffffe01f8004p-101, 0x1.00000ffffe000p+18, -0x1.8000000001000p-47},
+{-0x1.00000ffffe000p+18, -0x1.fffffffffc000p-49, 0x1.0000000000002p-46, -0x1.fffffe01f8004p-101, -0x1.00000ffffe000p+18, 0x1.8000000001000p-47},
+{-0x1.00000ffffe000p+18, -0x1.fffffffffc000p-49, -0x1.0000000000002p-46, 0x1.fffffe01f8004p-101, -0x1.00000ffffe000p+18, -0x1.3fffffffff800p-46},
+{0x1.0000000000060p+41, 0x1.fffe3fff00000p-22, 0x1.0000000002000p+4, -0x1.ffe0002000000p-53, 0x1.0000000008060p+41, 0x1.00031ffd80200p-21},
+{0x1.0000000000060p+41, 0x1.fffe3fff00000p-22, -0x1.0000000002000p+4, 0x1.ffe0002000000p-53, 0x1.fffffffff00c0p+40, 0x1.fff64002ffc00p-22},
+{-0x1.0000000000060p+41, -0x1.fffe3fff00000p-22, 0x1.0000000002000p+4, -0x1.ffe0002000000p-53, -0x1.fffffffff00c0p+40, -0x1.fff64002ffc00p-22},
+{-0x1.0000000000060p+41, -0x1.fffe3fff00000p-22, -0x1.0000000002000p+4, 0x1.ffe0002000000p-53, -0x1.0000000008060p+41, -0x1.00031ffd80200p-21},
+{0x1.0003ffffffff8p-50, 0x1.ffffe07e00000p-124, 0x1.07ff000008000p+19, -0x1.e000020000000p-42, 0x1.07ff000008000p+19, -0x1.defffe0000000p-42},
+{0x1.0003ffffffff8p-50, 0x1.ffffe07e00000p-124, -0x1.07ff000008000p+19, 0x1.e000020000000p-42, -0x1.07ff000008000p+19, 0x1.e100060000000p-42},
+{-0x1.0003ffffffff8p-50, -0x1.ffffe07e00000p-124, 0x1.07ff000008000p+19, -0x1.e000020000000p-42, 0x1.07ff000008000p+19, -0x1.e100060000000p-42},
+{-0x1.0003ffffffff8p-50, -0x1.ffffe07e00000p-124, -0x1.07ff000008000p+19, 0x1.e000020000000p-42, -0x1.07ff000008000p+19, 0x1.defffe0000000p-42},
+// Some test cases drawn only from the [0.5,1] binade:
+{0x1.0000000000002p-1, -0x1.ffc0ffff90000p-65, 0x1.0003ffffffffcp-1, 0x1.ffffc00000000p-88, 0x1.0001fffffffffp+0, -0x1.ffc0fbff90000p-65},
+{0x1.0000000000002p-1, -0x1.ffc0ffff90000p-65, -0x1.0003ffffffffcp-1, -0x1.ffffc00000000p-88, -0x1.ffffffffd0010p-16, 0x1.f7e0038400000p-76},
+{-0x1.0000000000002p-1, 0x1.ffc0ffff90000p-65, 0x1.0003ffffffffcp-1, 0x1.ffffc00000000p-88, 0x1.ffffffffd0010p-16, -0x1.f7e0038400000p-76},
+{-0x1.0000000000002p-1, 0x1.ffc0ffff90000p-65, -0x1.0003ffffffffcp-1, -0x1.ffffc00000000p-88, -0x1.0001fffffffffp+0, 0x1.ffc0fbff90000p-65},
+{0x1.0000100000000p-1, -0x1.0000000000000p-63, 0x1.0000000004000p-1, -0x1.ffffe00fc0200p-57, 0x1.0000080002000p+0, -0x1.01fff007e0100p-56},
+{0x1.0000100000000p-1, -0x1.0000000000000p-63, -0x1.0000000004000p-1, 0x1.ffffe00fc0200p-57, 0x1.ffff80003f800p-22, -0x1.ff03fe0000000p-77},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-63, 0x1.0000000004000p-1, -0x1.ffffe00fc0200p-57, -0x1.ffff80003f800p-22, 0x1.ff03fe0000000p-77},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-63, -0x1.0000000004000p-1, 0x1.ffffe00fc0200p-57, -0x1.0000080002000p+0, 0x1.01fff007e0100p-56},
+{0x1.0000000800000p-1, -0x1.0000000000000p-73, 0x1.000003fffc002p-1, -0x1.0000000000000p-106, 0x1.00000203fe001p+0, -0x1.0000000000000p-73},
+{0x1.0000000800000p-1, -0x1.0000000000000p-73, -0x1.000003fffc002p-1, 0x1.0000000000000p-106, -0x1.fbfe001000008p-24, 0x1.0000000000000p-106},
+{-0x1.0000000800000p-1, 0x1.0000000000000p-73, 0x1.000003fffc002p-1, -0x1.0000000000000p-106, 0x1.fbfe001000008p-24, -0x1.0000000000000p-106},
+{-0x1.0000000800000p-1, 0x1.0000000000000p-73, -0x1.000003fffc002p-1, 0x1.0000000000000p-106, -0x1.00000203fe001p+0, 0x1.0000000000000p-73},
+{0x1.0000000000000p-1, 0x1.ffc001ffffe00p-56, 0x1.000003fff8000p-1, 0x1.fffc000fc0000p-72, 0x1.000001fffc000p+0, 0x1.ffc201fbfff00p-56},
+{0x1.0000000000000p-1, 0x1.ffc001ffffe00p-56, -0x1.000003fff8000p-1, -0x1.fffc000fc0000p-72, -0x1.fffbfffe00420p-24, 0x1.01ffe82000000p-79},
+{-0x1.0000000000000p-1, -0x1.ffc001ffffe00p-56, 0x1.000003fff8000p-1, 0x1.fffc000fc0000p-72, 0x1.fffbfffe00420p-24, -0x1.01ffe82000000p-79},
+{-0x1.0000000000000p-1, -0x1.ffc001ffffe00p-56, -0x1.000003fff8000p-1, -0x1.fffc000fc0000p-72, -0x1.000001fffc000p+0, -0x1.ffc201fbfff00p-56},
+{0x1.0000000000003p-1, 0x1.fc00001fff800p-65, 0x1.0000000000020p-1, -0x1.fc01ffe002000p-65, 0x1.0000000000011p+0, 0x1.ffffffc007ffcp-54},
+{0x1.0000000000003p-1, 0x1.fc00001fff800p-65, -0x1.0000000000020p-1, 0x1.fc01ffe002000p-65, -0x1.cffc07fe00000p-49, 0x1.8000000000000p-105},
+{-0x1.0000000000003p-1, -0x1.fc00001fff800p-65, 0x1.0000000000020p-1, -0x1.fc01ffe002000p-65, 0x1.cffc07fe00000p-49, -0x1.8000000000000p-105},
+{-0x1.0000000000003p-1, -0x1.fc00001fff800p-65, -0x1.0000000000020p-1, 0x1.fc01ffe002000p-65, -0x1.0000000000011p+0, -0x1.ffffffc007ffcp-54},
+{0x1.0000000000000p-1, 0x1.fffff00001ffep-55, 0x1.0000000000000p-1, 0x1.ff00000ffff80p-61, 0x1.0000000000000p+0, 0x1.03fdf80020ffep-54},
+{0x1.0000000000000p-1, 0x1.fffff00001ffep-55, -0x1.0000000000000p-1, -0x1.ff00000ffff80p-61, 0x1.f803efffc2000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffff00001ffep-55, 0x1.0000000000000p-1, 0x1.ff00000ffff80p-61, -0x1.f803efffc2000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffff00001ffep-55, -0x1.0000000000000p-1, -0x1.ff00000ffff80p-61, -0x1.0000000000000p+0, -0x1.03fdf80020ffep-54},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, 0x1.0000200000000p-1, -0x1.ffc0000080000p-73, 0x1.0000100000000p+0, 0x1.ff001fffff800p-64},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, -0x1.0000200000000p-1, 0x1.ffc0000080000p-73, -0x1.ffffffffffbfep-21, -0x1.0000000000000p-83},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, 0x1.0000200000000p-1, -0x1.ffc0000080000p-73, 0x1.ffffffffffbfep-21, 0x1.0000000000000p-83},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, -0x1.0000200000000p-1, 0x1.ffc0000080000p-73, -0x1.0000100000000p+0, -0x1.ff001fffff800p-64},
+{0x1.0000000000800p-1, -0x1.fffc000000010p-58, 0x1.0000000000008p-1, -0x1.ffe03fffff010p-58, 0x1.0000000000404p+0, -0x1.ffee1fffff810p-57},
+{0x1.0000000000800p-1, -0x1.fffc000000010p-58, -0x1.0000000000008p-1, 0x1.ffe03fffff010p-58, 0x1.fdffffc880000p-43, -0x1.0000000000000p-98},
+{-0x1.0000000000800p-1, 0x1.fffc000000010p-58, 0x1.0000000000008p-1, -0x1.ffe03fffff010p-58, -0x1.fdffffc880000p-43, 0x1.0000000000000p-98},
+{-0x1.0000000000800p-1, 0x1.fffc000000010p-58, -0x1.0000000000008p-1, 0x1.ffe03fffff010p-58, -0x1.0000000000404p+0, 0x1.ffee1fffff810p-57},
+{0x1.0000000000000p-1, 0x1.fffef0ffff000p-64, 0x1.0000100000000p-1, -0x1.fff8000000800p-65, 0x1.0000080000000p+0, 0x1.0002f0ffff000p-64},
+{0x1.0000000000000p-1, 0x1.fffef0ffff000p-64, -0x1.0000100000000p-1, 0x1.fff8000000800p-65, -0x1.ffffffffff400p-22, -0x1.43c0003000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffef0ffff000p-64, 0x1.0000100000000p-1, -0x1.fff8000000800p-65, 0x1.ffffffffff400p-22, 0x1.43c0003000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffef0ffff000p-64, -0x1.0000100000000p-1, 0x1.fff8000000800p-65, -0x1.0000080000000p+0, -0x1.0002f0ffff000p-64},
+{0x1.07c00007ffff0p-1, 0x1.fffc00f800000p-77, 0x1.0000007ffffe0p-1, 0x1.f000000000000p-72, 0x1.03e00043fffe8p+0, 0x1.ffffe00800000p-72},
+{0x1.07c00007ffff0p-1, 0x1.fffc00f800000p-77, -0x1.0000007ffffe0p-1, -0x1.f000000000000p-72, 0x1.efffe20000400p-7, -0x1.e0001ff840000p-72},
+{-0x1.07c00007ffff0p-1, -0x1.fffc00f800000p-77, 0x1.0000007ffffe0p-1, 0x1.f000000000000p-72, -0x1.efffe20000400p-7, 0x1.e0001ff840000p-72},
+{-0x1.07c00007ffff0p-1, -0x1.fffc00f800000p-77, -0x1.0000007ffffe0p-1, -0x1.f000000000000p-72, -0x1.03e00043fffe8p+0, -0x1.ffffe00800000p-72},
+{0x1.0000000000000p-1, 0x1.ff800fffff800p-57, 0x1.0000000000000p-1, 0x1.fffc0000ffff8p-57, 0x1.0000000000000p+0, 0x1.ffbe08007fc00p-56},
+{0x1.0000000000000p-1, 0x1.ff800fffff800p-57, -0x1.0000000000000p-1, -0x1.fffc0000ffff8p-57, -0x1.efc00401fe000p-67, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff800fffff800p-57, 0x1.0000000000000p-1, 0x1.fffc0000ffff8p-57, 0x1.efc00401fe000p-67, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff800fffff800p-57, -0x1.0000000000000p-1, -0x1.fffc0000ffff8p-57, -0x1.0000000000000p+0, -0x1.ffbe08007fc00p-56},
+{0x1.0000000008000p-1, -0x1.ffff807ffe002p-55, 0x1.0000000800000p-1, -0x1.ffffff8000008p-57, 0x1.0000000404000p+0, -0x1.3fffc02fff002p-54},
+{0x1.0000000008000p-1, -0x1.ffff807ffe002p-55, -0x1.0000000800000p-1, 0x1.ffffff8000008p-57, -0x1.fe00017fff80ap-31, 0x1.0000000000000p-94},
+{-0x1.0000000008000p-1, 0x1.ffff807ffe002p-55, 0x1.0000000800000p-1, -0x1.ffffff8000008p-57, 0x1.fe00017fff80ap-31, -0x1.0000000000000p-94},
+{-0x1.0000000008000p-1, 0x1.ffff807ffe002p-55, -0x1.0000000800000p-1, 0x1.ffffff8000008p-57, -0x1.0000000404000p+0, 0x1.3fffc02fff002p-54},
+{0x1.0000000000020p-1, -0x1.0000000000000p-84, 0x1.0000000000000p-1, 0x1.fffff000003c0p-60, 0x1.0000000000010p+0, 0x1.ffffef0000400p-60},
+{0x1.0000000000020p-1, -0x1.0000000000000p-84, -0x1.0000000000000p-1, -0x1.fffff000003c0p-60, 0x1.ffc00001e0000p-49, -0x1.e000000000000p-103},
+{-0x1.0000000000020p-1, 0x1.0000000000000p-84, 0x1.0000000000000p-1, 0x1.fffff000003c0p-60, -0x1.ffc00001e0000p-49, 0x1.e000000000000p-103},
+{-0x1.0000000000020p-1, 0x1.0000000000000p-84, -0x1.0000000000000p-1, -0x1.fffff000003c0p-60, -0x1.0000000000010p+0, -0x1.ffffef0000400p-60},
+{0x1.0000001ffff80p-1, 0x1.fffffdfffff8ep-55, 0x1.0000000200000p-1, -0x1.0000000000000p-70, 0x1.00000010fffc0p+0, 0x1.fffdfdfffff90p-55},
+{0x1.0000001ffff80p-1, 0x1.fffffdfffff8ep-55, -0x1.0000000200000p-1, 0x1.0000000000000p-70, 0x1.dfff8080007f8p-29, -0x1.c800000000000p-101},
+{-0x1.0000001ffff80p-1, -0x1.fffffdfffff8ep-55, 0x1.0000000200000p-1, -0x1.0000000000000p-70, -0x1.dfff8080007f8p-29, 0x1.c800000000000p-101},
+{-0x1.0000001ffff80p-1, -0x1.fffffdfffff8ep-55, -0x1.0000000200000p-1, 0x1.0000000000000p-70, -0x1.00000010fffc0p+0, -0x1.fffdfdfffff90p-55},
+{0x1.01ffffff80400p-1, -0x1.c7ffffc000100p-59, 0x1.0000000000000p-1, 0x1.8fff01fffff00p-61, 0x1.00ffffffc0200p+0, -0x1.64003f4000140p-59},
+{0x1.01ffffff80400p-1, -0x1.c7ffffc000100p-59, -0x1.0000000000000p-1, -0x1.8fff01fffff00p-61, 0x1.ffffff803fff7p-9, 0x1.4003fbffff400p-63},
+{-0x1.01ffffff80400p-1, 0x1.c7ffffc000100p-59, 0x1.0000000000000p-1, 0x1.8fff01fffff00p-61, -0x1.ffffff803fff7p-9, -0x1.4003fbffff400p-63},
+{-0x1.01ffffff80400p-1, 0x1.c7ffffc000100p-59, -0x1.0000000000000p-1, -0x1.8fff01fffff00p-61, -0x1.00ffffffc0200p+0, 0x1.64003f4000140p-59},
+{0x1.0000000000008p-1, -0x1.ffffc00800000p-74, 0x1.00003ffe00002p-1, -0x1.ffffffc180080p-61, 0x1.00001fff00005p+0, -0x1.0007ffdfc0200p-60},
+{0x1.0000000000008p-1, -0x1.ffffc00800000p-74, -0x1.00003ffe00002p-1, 0x1.ffffffc180080p-61, -0x1.ffeffffcff001p-20, 0x1.fff86ff900000p-74},
+{-0x1.0000000000008p-1, 0x1.ffffc00800000p-74, 0x1.00003ffe00002p-1, -0x1.ffffffc180080p-61, 0x1.ffeffffcff001p-20, -0x1.fff86ff900000p-74},
+{-0x1.0000000000008p-1, 0x1.ffffc00800000p-74, -0x1.00003ffe00002p-1, 0x1.ffffffc180080p-61, -0x1.00001fff00005p+0, 0x1.0007ffdfc0200p-60},
+{0x1.000000ffffff8p-1, 0x1.ffffffc000000p-58, 0x1.0000000000000p-1, 0x1.ffffffe000000p-59, 0x1.0000007fffffcp+0, 0x1.7fffffd800000p-57},
+{0x1.000000ffffff8p-1, 0x1.ffffffc000000p-58, -0x1.0000000000000p-1, -0x1.ffffffe000000p-59, 0x1.ffffff0100000p-26, -0x1.8000000000000p-85},
+{-0x1.000000ffffff8p-1, -0x1.ffffffc000000p-58, 0x1.0000000000000p-1, 0x1.ffffffe000000p-59, -0x1.ffffff0100000p-26, 0x1.8000000000000p-85},
+{-0x1.000000ffffff8p-1, -0x1.ffffffc000000p-58, -0x1.0000000000000p-1, -0x1.ffffffe000000p-59, -0x1.0000007fffffcp+0, -0x1.7fffffd800000p-57},
+{0x1.0000000020000p-1, -0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.ff1ffffff4000p-68, 0x1.0000000010200p+0, -0x1.ff1ffffff8000p-68},
+{0x1.0000000020000p-1, -0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.ff1ffffff4000p-68, 0x1.fc000003fe400p-37, -0x1.0000000000000p-104},
+{-0x1.0000000020000p-1, 0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.ff1ffffff4000p-68, -0x1.fc000003fe400p-37, 0x1.0000000000000p-104},
+{-0x1.0000000020000p-1, 0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.ff1ffffff4000p-68, -0x1.0000000010200p+0, 0x1.ff1ffffff8000p-68},
+{0x1.0000ff8020000p-1, -0x1.fffffa0000000p-63, 0x1.0000000001ff0p-1, 0x1.f700000ffe000p-67, 0x1.00007fc010ff8p+0, -0x1.e08ff9ff00000p-63},
+{0x1.0000ff8020000p-1, -0x1.fffffa0000000p-63, -0x1.0000000001ff0p-1, -0x1.f700000ffe000p-67, 0x1.ff003c01ffef0p-18, 0x1.200bfe0040000p-72},
+{-0x1.0000ff8020000p-1, 0x1.fffffa0000000p-63, 0x1.0000000001ff0p-1, 0x1.f700000ffe000p-67, -0x1.ff003c01ffef0p-18, -0x1.200bfe0040000p-72},
+{-0x1.0000ff8020000p-1, 0x1.fffffa0000000p-63, -0x1.0000000001ff0p-1, -0x1.f700000ffe000p-67, -0x1.00007fc010ff8p+0, 0x1.e08ff9ff00000p-63},
+{0x1.0000020000000p-1, -0x1.0000000000000p-65, 0x1.003e00001f800p-1, 0x1.ffde000001e00p-63, 0x1.001f01000fc00p+0, 0x1.bfde000002000p-63},
+{0x1.0000020000000p-1, -0x1.0000000000000p-65, -0x1.003e00001f800p-1, -0x1.ffde000001e00p-63, -0x1.eff000fc00004p-12, -0x1.fef000000f000p-66},
+{-0x1.0000020000000p-1, 0x1.0000000000000p-65, 0x1.003e00001f800p-1, 0x1.ffde000001e00p-63, 0x1.eff000fc00004p-12, 0x1.fef000000f000p-66},
+{-0x1.0000020000000p-1, 0x1.0000000000000p-65, -0x1.003e00001f800p-1, -0x1.ffde000001e00p-63, -0x1.001f01000fc00p+0, -0x1.bfde000002000p-63},
+{0x1.0007e3ffe0000p-1, 0x1.fe0ffffffe000p-65, 0x1.0000000000000p-1, 0x1.fffffe07fff00p-62, 0x1.0003f1fff0000p+0, 0x1.1fe0ff03ffe00p-61},
+{0x1.0007e3ffe0000p-1, 0x1.fe0ffffffe000p-65, -0x1.0000000000000p-1, -0x1.fffffe07fff00p-62, 0x1.f8fff7fffffc8p-15, -0x1.eff0400180000p-73},
+{-0x1.0007e3ffe0000p-1, -0x1.fe0ffffffe000p-65, 0x1.0000000000000p-1, 0x1.fffffe07fff00p-62, -0x1.f8fff7fffffc8p-15, 0x1.eff0400180000p-73},
+{-0x1.0007e3ffe0000p-1, -0x1.fe0ffffffe000p-65, -0x1.0000000000000p-1, -0x1.fffffe07fff00p-62, -0x1.0003f1fff0000p+0, -0x1.1fe0ff03ffe00p-61},
+{0x1.00000000fe000p-1, 0x1.ff00004000000p-68, 0x1.000003fffff80p-1, 0x1.fff8400000000p-61, 0x1.000002007efc0p+0, 0x1.01fb200040000p-60},
+{0x1.00000000fe000p-1, 0x1.ff00004000000p-68, -0x1.000003fffff80p-1, -0x1.fff8400000000p-61, -0x1.ff80fc000fdfdp-24, -0x1.fffc000000000p-80},
+{-0x1.00000000fe000p-1, -0x1.ff00004000000p-68, 0x1.000003fffff80p-1, 0x1.fff8400000000p-61, 0x1.ff80fc000fdfdp-24, 0x1.fffc000000000p-80},
+{-0x1.00000000fe000p-1, -0x1.ff00004000000p-68, -0x1.000003fffff80p-1, -0x1.fff8400000000p-61, -0x1.000002007efc0p+0, -0x1.01fb200040000p-60},
+{0x1.0000800000000p-1, -0x1.0000000000000p-57, 0x1.0000000000000p-1, 0x1.fffffffc1fc00p-64, 0x1.0000400000000p+0, -0x1.f80000000f800p-58},
+{0x1.0000800000000p-1, -0x1.0000000000000p-57, -0x1.0000000000000p-1, -0x1.fffffffc1fc00p-64, 0x1.fffffffffbf00p-19, 0x1.f020000000000p-95},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-57, 0x1.0000000000000p-1, 0x1.fffffffc1fc00p-64, -0x1.fffffffffbf00p-19, -0x1.f020000000000p-95},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-57, -0x1.0000000000000p-1, -0x1.fffffffc1fc00p-64, -0x1.0000400000000p+0, 0x1.f80000000f800p-58},
+{0x1.0000000000000p-1, 0x1.ff000ff3ffe00p-55, 0x1.0000000000000p-1, 0x1.fe0003fffc000p-60, 0x1.0000000000000p+0, 0x1.07780809ffe00p-54},
+{0x1.0000000000000p-1, 0x1.ff000ff3ffe00p-55, -0x1.0000000000000p-1, -0x1.fe0003fffc000p-60, 0x1.ef100fd400000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff000ff3ffe00p-55, 0x1.0000000000000p-1, 0x1.fe0003fffc000p-60, -0x1.ef100fd400000p-55, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ff000ff3ffe00p-55, -0x1.0000000000000p-1, -0x1.fe0003fffc000p-60, -0x1.0000000000000p+0, -0x1.07780809ffe00p-54},
+{0x1.000000e000010p-1, -0x1.ffffffc020000p-71, 0x1.00000001f0000p-1, 0x1.8000000000000p-105, 0x1.00000070f8008p+0, -0x1.ffffffbfc0000p-71},
+{0x1.000000e000010p-1, -0x1.ffffffc020000p-71, -0x1.00000001f0000p-1, -0x1.8000000000000p-105, 0x1.bc2001fffff00p-26, 0x1.fc00000000000p-98},
+{-0x1.000000e000010p-1, 0x1.ffffffc020000p-71, 0x1.00000001f0000p-1, 0x1.8000000000000p-105, -0x1.bc2001fffff00p-26, -0x1.fc00000000000p-98},
+{-0x1.000000e000010p-1, 0x1.ffffffc020000p-71, -0x1.00000001f0000p-1, -0x1.8000000000000p-105, -0x1.00000070f8008p+0, 0x1.ffffffbfc0000p-71},
+{0x1.000003ff00000p-1, 0x1.8000000000000p-78, 0x1.0001ffffe0000p-1, 0x1.f800000100000p-74, 0x1.000101ff70000p+0, 0x1.0800000000000p-73},
+{0x1.000003ff00000p-1, 0x1.8000000000000p-78, -0x1.0001ffffe0000p-1, -0x1.f800000100000p-74, -0x1.fc00e00000000p-17, -0x1.e000000100000p-74},
+{-0x1.000003ff00000p-1, -0x1.8000000000000p-78, 0x1.0001ffffe0000p-1, 0x1.f800000100000p-74, 0x1.fc00e00000000p-17, 0x1.e000000100000p-74},
+{-0x1.000003ff00000p-1, -0x1.8000000000000p-78, -0x1.0001ffffe0000p-1, -0x1.f800000100000p-74, -0x1.000101ff70000p+0, -0x1.0800000000000p-73},
+{0x1.0000000000200p-1, -0x1.ffffffffffc08p-57, 0x1.0000000000000p-1, 0x1.ffffffffffffep-55, 0x1.0000000000100p+0, 0x1.80000000000fcp-55},
+{0x1.0000000000200p-1, -0x1.ffffffffffc08p-57, -0x1.0000000000000p-1, -0x1.ffffffffffffep-55, 0x1.ff60000000000p-45, 0x1.0000000000000p-99},
+{-0x1.0000000000200p-1, 0x1.ffffffffffc08p-57, 0x1.0000000000000p-1, 0x1.ffffffffffffep-55, -0x1.ff60000000000p-45, -0x1.0000000000000p-99},
+{-0x1.0000000000200p-1, 0x1.ffffffffffc08p-57, -0x1.0000000000000p-1, -0x1.ffffffffffffep-55, -0x1.0000000000100p+0, -0x1.80000000000fcp-55},
+{0x1.0000000040000p-1, -0x1.fffff80002000p-67, 0x1.0000000000000p-1, 0x1.ffc01ffff3c00p-64, 0x1.0000000020000p+0, 0x1.bfc020fff3800p-64},
+{0x1.0000000040000p-1, -0x1.fffff80002000p-67, -0x1.0000000000000p-1, -0x1.ffc01ffff3c00p-64, 0x1.ffffffdc03fe1p-36, 0x1.8000000000000p-101},
+{-0x1.0000000040000p-1, 0x1.fffff80002000p-67, 0x1.0000000000000p-1, 0x1.ffc01ffff3c00p-64, -0x1.ffffffdc03fe1p-36, -0x1.8000000000000p-101},
+{-0x1.0000000040000p-1, 0x1.fffff80002000p-67, -0x1.0000000000000p-1, -0x1.ffc01ffff3c00p-64, -0x1.0000000020000p+0, -0x1.bfc020fff3800p-64},
+{0x1.0000800000000p-1, -0x1.0000000000000p-106, 0x1.0000003800001p-1, 0x1.fffffe000003ep-55, 0x1.0000401c00001p+0, -0x1.000000fffffe2p-54},
+{0x1.0000800000000p-1, -0x1.0000000000000p-106, -0x1.0000003800001p-1, -0x1.fffffe000003ep-55, 0x1.ff1fffffa0000p-19, 0x1.fffffc0000000p-79},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-106, 0x1.0000003800001p-1, 0x1.fffffe000003ep-55, -0x1.ff1fffffa0000p-19, -0x1.fffffc0000000p-79},
+{-0x1.0000800000000p-1, 0x1.0000000000000p-106, -0x1.0000003800001p-1, -0x1.fffffe000003ep-55, -0x1.0000401c00001p+0, 0x1.000000fffffe2p-54},
+{0x1.0f00000020000p-1, -0x1.fffe000000100p-55, 0x1.0000000400000p-1, -0x1.ffffffc004000p-68, 0x1.0780000210000p+0, -0x1.0006ffffff080p-54},
+{0x1.0f00000020000p-1, -0x1.fffe000000100p-55, -0x1.0000000400000p-1, 0x1.ffffffc004000p-68, 0x1.dfffff83ffff0p-6, 0x1.1fffffdf02000p-67},
+{-0x1.0f00000020000p-1, 0x1.fffe000000100p-55, 0x1.0000000400000p-1, -0x1.ffffffc004000p-68, -0x1.dfffff83ffff0p-6, -0x1.1fffffdf02000p-67},
+{-0x1.0f00000020000p-1, 0x1.fffe000000100p-55, -0x1.0000000400000p-1, 0x1.ffffffc004000p-68, -0x1.0780000210000p+0, 0x1.0006ffffff080p-54},
+{0x1.003fe00020000p-1, -0x1.ffffffffe8000p-69, 0x1.0000000000400p-1, -0x1.ffff800007ffcp-56, 0x1.001ff00010200p+0, -0x1.0007c00003ff8p-55},
+{0x1.003fe00020000p-1, -0x1.ffffffffe8000p-69, -0x1.0000000000400p-1, 0x1.ffff800007ffcp-56, 0x1.ff0000fe00200p-12, -0x1.07ffff7ff8000p-68},
+{-0x1.003fe00020000p-1, 0x1.ffffffffe8000p-69, 0x1.0000000000400p-1, -0x1.ffff800007ffcp-56, -0x1.ff0000fe00200p-12, 0x1.07ffff7ff8000p-68},
+{-0x1.003fe00020000p-1, 0x1.ffffffffe8000p-69, -0x1.0000000000400p-1, 0x1.ffff800007ffcp-56, -0x1.001ff00010200p+0, 0x1.0007c00003ff8p-55},
+{0x1.ffff00fffffc4p-1, -0x1.8080000000000p-83, 0x1.0000020000000p-1, -0x1.0000000000000p-77, 0x1.7fff817ffffe2p+0, -0x1.0602000000000p-77},
+{0x1.ffff00fffffc4p-1, -0x1.8080000000000p-83, -0x1.0000020000000p-1, 0x1.0000000000000p-77, 0x1.fffdfdfffff88p-2, 0x1.f3fc000000000p-78},
+{-0x1.ffff00fffffc4p-1, 0x1.8080000000000p-83, 0x1.0000020000000p-1, -0x1.0000000000000p-77, -0x1.fffdfdfffff88p-2, -0x1.f3fc000000000p-78},
+{-0x1.ffff00fffffc4p-1, 0x1.8080000000000p-83, -0x1.0000020000000p-1, 0x1.0000000000000p-77, -0x1.7fff817ffffe2p+0, 0x1.0602000000000p-77},
+{0x1.0000000000040p-1, -0x1.8000000800000p-76, 0x1.0000000002000p-1, -0x1.0000000000000p-105, 0x1.0000000001020p+0, -0x1.8000001000000p-76},
+{0x1.0000000000040p-1, -0x1.8000000800000p-76, -0x1.0000000002000p-1, 0x1.0000000000000p-105, -0x1.fc00000030000p-41, 0x0.0000000000000p+0},
+{-0x1.0000000000040p-1, 0x1.8000000800000p-76, 0x1.0000000002000p-1, -0x1.0000000000000p-105, 0x1.fc00000030000p-41, 0x0.0000000000000p+0},
+{-0x1.0000000000040p-1, 0x1.8000000800000p-76, -0x1.0000000002000p-1, 0x1.0000000000000p-105, -0x1.0000000001020p+0, 0x1.8000001000000p-76},
+{0x1.0000000800000p-1, -0x1.ffffc02000000p-79, 0x1.7fffe00800000p-1, -0x1.0000000000000p-106, 0x1.3ffff00800000p+0, -0x1.ffffc04000000p-79},
+{0x1.0000000800000p-1, -0x1.ffffc02000000p-79, -0x1.7fffe00800000p-1, 0x1.0000000000000p-106, -0x1.ffff800000000p-3, -0x1.ffffc00000000p-79},
+{-0x1.0000000800000p-1, 0x1.ffffc02000000p-79, 0x1.7fffe00800000p-1, -0x1.0000000000000p-106, 0x1.ffff800000000p-3, 0x1.ffffc00000000p-79},
+{-0x1.0000000800000p-1, 0x1.ffffc02000000p-79, -0x1.7fffe00800000p-1, 0x1.0000000000000p-106, -0x1.3ffff00800000p+0, 0x1.ffffc04000000p-79},
+{0x1.0000400000000p-1, -0x1.0000000000000p-92, 0x1.4000000000000p-1, -0x1.ffffffff00020p-59, 0x1.2000200000000p+0, -0x1.ffffffff80000p-59},
+{0x1.0000400000000p-1, -0x1.0000000000000p-92, -0x1.4000000000000p-1, 0x1.ffffffff00020p-59, -0x1.fffe000000000p-4, 0x1.fffffffe80020p-59},
+{-0x1.0000400000000p-1, 0x1.0000000000000p-92, 0x1.4000000000000p-1, -0x1.ffffffff00020p-59, 0x1.fffe000000000p-4, -0x1.fffffffe80020p-59},
+{-0x1.0000400000000p-1, 0x1.0000000000000p-92, -0x1.4000000000000p-1, 0x1.ffffffff00020p-59, -0x1.2000200000000p+0, 0x1.ffffffff80000p-59},
+{0x1.0000000000000p-1, 0x1.03eff7ff3fff0p-58, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, 0x1.00000fffe0000p+0, 0x1.42eff83d401e0p-58},
+{0x1.0000000000000p-1, 0x1.03eff7ff3fff0p-58, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, -0x1.fffbfffff9d88p-21, -0x1.07d8040000000p-79},
+{-0x1.0000000000000p-1, -0x1.03eff7ff3fff0p-58, 0x1.00001fffc0000p-1, 0x1.f80001f000f80p-61, 0x1.fffbfffff9d88p-21, 0x1.07d8040000000p-79},
+{-0x1.0000000000000p-1, -0x1.03eff7ff3fff0p-58, -0x1.00001fffc0000p-1, -0x1.f80001f000f80p-61, -0x1.00000fffe0000p+0, -0x1.42eff83d401e0p-58},
+{0x1.03ffffffffffep-1, 0x1.8000000000000p-105, 0x1.0000040000000p-1, -0x1.0000000000000p-106, 0x1.020001fffffffp+0, 0x1.0000000000000p-105},
+{0x1.03ffffffffffep-1, 0x1.8000000000000p-105, -0x1.0000040000000p-1, 0x1.0000000000000p-106, 0x1.fffdfffffff00p-8, 0x1.0000000000000p-104},
+{-0x1.03ffffffffffep-1, -0x1.8000000000000p-105, 0x1.0000040000000p-1, -0x1.0000000000000p-106, -0x1.fffdfffffff00p-8, -0x1.0000000000000p-104},
+{-0x1.03ffffffffffep-1, -0x1.8000000000000p-105, -0x1.0000040000000p-1, 0x1.0000000000000p-106, -0x1.020001fffffffp+0, -0x1.0000000000000p-105},
+{0x1.0007ffffcfffcp-1, 0x1.ff01fffe00000p-75, 0x1.01fff08000000p-1, -0x1.fffffe0000020p-55, 0x1.0103f83fe7ffep+0, -0x1.ffffde0fe0020p-55},
+{0x1.0007ffffcfffcp-1, 0x1.ff01fffe00000p-75, -0x1.01fff08000000p-1, 0x1.fffffe0000020p-55, -0x1.f7f0803000380p-9, 0x1.df02001e00000p-75},
+{-0x1.0007ffffcfffcp-1, -0x1.ff01fffe00000p-75, 0x1.01fff08000000p-1, -0x1.fffffe0000020p-55, 0x1.f7f0803000380p-9, -0x1.df02001e00000p-75},
+{-0x1.0007ffffcfffcp-1, -0x1.ff01fffe00000p-75, -0x1.01fff08000000p-1, 0x1.fffffe0000020p-55, -0x1.0103f83fe7ffep+0, 0x1.ffffde0fe0020p-55},
+{0x1.00000000007fep-1, 0x1.ff00003ffff00p-62, 0x1.004000e000008p-1, -0x1.ffffe02000000p-79, 0x1.0020007000403p+0, 0x1.feff00400fe00p-62},
+{0x1.00000000007fep-1, 0x1.ff00003ffff00p-62, -0x1.004000e000008p-1, 0x1.ffffe02000000p-79, -0x1.00037ffe027fcp-11, -0x1.fdff802000000p-71},
+{-0x1.00000000007fep-1, -0x1.ff00003ffff00p-62, 0x1.004000e000008p-1, -0x1.ffffe02000000p-79, 0x1.00037ffe027fcp-11, 0x1.fdff802000000p-71},
+{-0x1.00000000007fep-1, -0x1.ff00003ffff00p-62, -0x1.004000e000008p-1, 0x1.ffffe02000000p-79, -0x1.0020007000403p+0, -0x1.feff00400fe00p-62},
+{0x1.00000003ff000p-1, 0x1.ffff000000000p-90, 0x1.0000fffff8000p-1, 0x1.f003ffe0003e0p-59, 0x1.00008001fb800p+0, 0x1.f003ffe4003c0p-59},
+{0x1.00000003ff000p-1, 0x1.ffff000000000p-90, -0x1.0000fffff8000p-1, -0x1.f003ffe0003e0p-59, -0x1.fff7f20000f80p-18, -0x1.ffee002000000p-74},
+{-0x1.00000003ff000p-1, -0x1.ffff000000000p-90, 0x1.0000fffff8000p-1, 0x1.f003ffe0003e0p-59, 0x1.fff7f20000f80p-18, 0x1.ffee002000000p-74},
+{-0x1.00000003ff000p-1, -0x1.ffff000000000p-90, -0x1.0000fffff8000p-1, -0x1.f003ffe0003e0p-59, -0x1.00008001fb800p+0, -0x1.f003ffe4003c0p-59},
+{0x1.0000000000000p-1, 0x1.ffe001c0003c0p-60, 0x1.01fffffe00000p-1, 0x1.ffffffffffc00p-59, 0x1.00ffffff00000p+0, 0x1.7ff8006ffff00p-58},
+{0x1.0000000000000p-1, 0x1.ffe001c0003c0p-60, -0x1.01fffffe00000p-1, -0x1.ffffffffffc00p-59, -0x1.fffffe0000004p-9, -0x1.ffe3fff440000p-72},
+{-0x1.0000000000000p-1, -0x1.ffe001c0003c0p-60, 0x1.01fffffe00000p-1, 0x1.ffffffffffc00p-59, 0x1.fffffe0000004p-9, 0x1.ffe3fff440000p-72},
+{-0x1.0000000000000p-1, -0x1.ffe001c0003c0p-60, -0x1.01fffffe00000p-1, -0x1.ffffffffffc00p-59, -0x1.00ffffff00000p+0, -0x1.7ff8006ffff00p-58},
+{0x1.00003ff808000p-1, -0x1.ffe0000800000p-62, 0x1.000001ffff000p-1, 0x1.ff80000000000p-75, 0x1.000020fc03800p+0, -0x1.ffd0040800000p-62},
+{0x1.00003ff808000p-1, -0x1.ffe0000800000p-62, -0x1.000001ffff000p-1, -0x1.ff80000000000p-75, 0x1.efc047ffff800p-20, 0x1.003f800000000p-74},
+{-0x1.00003ff808000p-1, 0x1.ffe0000800000p-62, 0x1.000001ffff000p-1, 0x1.ff80000000000p-75, -0x1.efc047ffff800p-20, -0x1.003f800000000p-74},
+{-0x1.00003ff808000p-1, 0x1.ffe0000800000p-62, -0x1.000001ffff000p-1, -0x1.ff80000000000p-75, -0x1.000020fc03800p+0, 0x1.ffd0040800000p-62},
+{0x1.0000000000000p-1, 0x1.fc007f0ff0000p-63, 0x1.0000000007f80p-1, 0x1.ff0007f802000p-65, 0x1.0000000003fc0p+0, 0x1.3de04086f8400p-62},
+{0x1.0000000000000p-1, 0x1.fc007f0ff0000p-63, -0x1.0000000007f80p-1, -0x1.ff0007f802000p-65, -0x1.fdfffe83bf82fp-39, 0x1.ef80000000000p-95},
+{-0x1.0000000000000p-1, -0x1.fc007f0ff0000p-63, 0x1.0000000007f80p-1, 0x1.ff0007f802000p-65, 0x1.fdfffe83bf82fp-39, -0x1.ef80000000000p-95},
+{-0x1.0000000000000p-1, -0x1.fc007f0ff0000p-63, -0x1.0000000007f80p-1, -0x1.ff0007f802000p-65, -0x1.0000000003fc0p+0, -0x1.3de04086f8400p-62},
+{0x1.0020000000000p-1, -0x1.0000000000000p-78, 0x1.000001ffff802p-1, -0x1.ffffffc000040p-60, 0x1.001000ffffc01p+0, -0x1.00001fe000000p-59},
+{0x1.0020000000000p-1, -0x1.0000000000000p-78, -0x1.000001ffff802p-1, 0x1.ffffffc000040p-60, 0x1.ffe00007fe040p-13, -0x1.00fffff000000p-78},
+{-0x1.0020000000000p-1, 0x1.0000000000000p-78, 0x1.000001ffff802p-1, -0x1.ffffffc000040p-60, -0x1.ffe00007fe040p-13, 0x1.00fffff000000p-78},
+{-0x1.0020000000000p-1, 0x1.0000000000000p-78, -0x1.000001ffff802p-1, 0x1.ffffffc000040p-60, -0x1.001000ffffc01p+0, 0x1.00001fe000000p-59},
+{0x1.0000000000800p-1, -0x1.ffe0000400000p-63, 0x1.0000000000038p-1, 0x1.e100000000000p-75, 0x1.000000000041cp+0, -0x1.ffc1f00400000p-63},
+{0x1.0000000000800p-1, -0x1.ffe0000400000p-63, -0x1.0000000000038p-1, -0x1.e100000000000p-75, 0x1.f1ffe0001effcp-43, 0x0.0000000000000p+0},
+{-0x1.0000000000800p-1, 0x1.ffe0000400000p-63, 0x1.0000000000038p-1, 0x1.e100000000000p-75, -0x1.f1ffe0001effcp-43, 0x0.0000000000000p+0},
+{-0x1.0000000000800p-1, 0x1.ffe0000400000p-63, -0x1.0000000000038p-1, -0x1.e100000000000p-75, -0x1.000000000041cp+0, 0x1.ffc1f00400000p-63},
+{0x1.0000000000020p-1, -0x1.8007ffff80c04p-56, 0x1.0000000000000p-1, 0x1.ffffe00000c00p-64, 0x1.0000000000010p+0, -0x1.7e08001f80bf8p-56},
+{0x1.0000000000020p-1, -0x1.8007ffff80c04p-56, -0x1.0000000000000p-1, -0x1.ffffe00000c00p-64, 0x1.fcfbf00040fe8p-49, -0x1.0000000000000p-104},
+{-0x1.0000000000020p-1, 0x1.8007ffff80c04p-56, 0x1.0000000000000p-1, 0x1.ffffe00000c00p-64, -0x1.fcfbf00040fe8p-49, 0x1.0000000000000p-104},
+{-0x1.0000000000020p-1, 0x1.8007ffff80c04p-56, -0x1.0000000000000p-1, -0x1.ffffe00000c00p-64, -0x1.0000000000010p+0, 0x1.7e08001f80bf8p-56},
+{0x1.7fffffff80000p-1, 0x1.f000000000000p-78, 0x1.000007ffffffep-1, 0x1.ffffff8000000p-77, 0x1.400003ffbffffp+0, 0x1.7bffffc000000p-76},
+{0x1.7fffffff80000p-1, 0x1.f000000000000p-78, -0x1.000007ffffffep-1, -0x1.ffffff8000000p-77, 0x1.ffffdffe00008p-3, -0x1.07ffff8000000p-77},
+{-0x1.7fffffff80000p-1, -0x1.f000000000000p-78, 0x1.000007ffffffep-1, 0x1.ffffff8000000p-77, -0x1.ffffdffe00008p-3, 0x1.07ffff8000000p-77},
+{-0x1.7fffffff80000p-1, -0x1.f000000000000p-78, -0x1.000007ffffffep-1, -0x1.ffffff8000000p-77, -0x1.400003ffbffffp+0, -0x1.7bffffc000000p-76},
+{0x1.0000000010000p-1, -0x1.0000000000000p-87, 0x1.0000000000000p-1, 0x1.c000003ffc3fep-55, 0x1.0000000008000p+0, 0x1.c000003efc400p-55},
+{0x1.0000000010000p-1, -0x1.0000000000000p-87, -0x1.0000000000000p-1, -0x1.c000003ffc3fep-55, 0x1.ffff1fffffdf8p-38, 0x1.e010000000000p-94},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-87, 0x1.0000000000000p-1, 0x1.c000003ffc3fep-55, -0x1.ffff1fffffdf8p-38, -0x1.e010000000000p-94},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-87, -0x1.0000000000000p-1, -0x1.c000003ffc3fep-55, -0x1.0000000008000p+0, -0x1.c000003efc400p-55},
+{0x1.00000ffff0800p-1, -0x1.fff80000ffc20p-59, 0x1.0000000000002p-1, -0x1.0000000000000p-106, 0x1.000007fff8401p+0, -0x1.fff80000ffc40p-59},
+{0x1.00000ffff0800p-1, -0x1.fff80000ffc20p-59, -0x1.0000000000002p-1, 0x1.0000000000000p-106, 0x1.fffe0ffbf0004p-22, -0x1.ff80000000000p-92},
+{-0x1.00000ffff0800p-1, 0x1.fff80000ffc20p-59, 0x1.0000000000002p-1, -0x1.0000000000000p-106, -0x1.fffe0ffbf0004p-22, 0x1.ff80000000000p-92},
+{-0x1.00000ffff0800p-1, 0x1.fff80000ffc20p-59, -0x1.0000000000002p-1, 0x1.0000000000000p-106, -0x1.000007fff8401p+0, 0x1.fff80000ffc40p-59},
+{0x1.000ffffc00000p-1, 0x1.fffff00000000p-70, 0x1.0000000000040p-1, -0x1.0000000000000p-106, 0x1.0007fffe00020p+0, 0x1.fffff00000000p-70},
+{0x1.000ffffc00000p-1, 0x1.fffff00000000p-70, -0x1.0000000000040p-1, 0x1.0000000000000p-106, 0x1.ffff7fff80000p-14, 0x1.fffff00010000p-70},
+{-0x1.000ffffc00000p-1, -0x1.fffff00000000p-70, 0x1.0000000000040p-1, -0x1.0000000000000p-106, -0x1.ffff7fff80000p-14, -0x1.fffff00010000p-70},
+{-0x1.000ffffc00000p-1, -0x1.fffff00000000p-70, -0x1.0000000000040p-1, 0x1.0000000000000p-106, -0x1.0007fffe00020p+0, -0x1.fffff00000000p-70},
+{0x1.0004000000000p-1, -0x1.0000000000000p-69, 0x1.0000000200000p-1, -0x1.ffbffffff8020p-59, 0x1.0002000100000p+0, -0x1.fffffffff8000p-59},
+{0x1.0004000000000p-1, -0x1.0000000000000p-69, -0x1.0000000200000p-1, 0x1.ffbffffff8020p-59, 0x1.ffff0000003ffp-16, -0x1.ff80000000000p-97},
+{-0x1.0004000000000p-1, 0x1.0000000000000p-69, 0x1.0000000200000p-1, -0x1.ffbffffff8020p-59, -0x1.ffff0000003ffp-16, 0x1.ff80000000000p-97},
+{-0x1.0004000000000p-1, 0x1.0000000000000p-69, -0x1.0000000200000p-1, 0x1.ffbffffff8020p-59, -0x1.0002000100000p+0, 0x1.fffffffff8000p-59},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, 0x1.0000001fffffep-1, 0x0.0000000000000p+0, 0x1.0000000ffffffp+0, 0x1.e0001e7fc0000p-62},
+{0x1.0000000000000p-1, 0x1.e0001e7fbff00p-62, -0x1.0000001fffffep-1, 0x0.0000000000000p+0, -0x1.fffffdff0ffffp-29, -0x1.8040100000000p-86},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, 0x1.0000001fffffep-1, 0x0.0000000000000p+0, 0x1.fffffdff0ffffp-29, 0x1.8040100000000p-86},
+{-0x1.0000000000000p-1, -0x1.e0001e7fbff00p-62, -0x1.0000001fffffep-1, 0x0.0000000000000p+0, -0x1.0000000ffffffp+0, -0x1.e0001e7fc0000p-62},
+{0x1.0000000000fffp-1, 0x1.fffff3e000000p-74, 0x1.001ffe0000000p-1, 0x1.fffffffffffc0p-60, 0x1.000fff0000800p+0, -0x1.f7ffe00000c20p-54},
+{0x1.0000000000fffp-1, 0x1.fffff3e000000p-74, -0x1.001ffe0000000p-1, -0x1.fffffffffffc0p-60, -0x1.ffdffff001040p-13, 0x1.fffff3e100000p-74},
+{-0x1.0000000000fffp-1, -0x1.fffff3e000000p-74, 0x1.001ffe0000000p-1, 0x1.fffffffffffc0p-60, 0x1.ffdffff001040p-13, -0x1.fffff3e100000p-74},
+{-0x1.0000000000fffp-1, -0x1.fffff3e000000p-74, -0x1.001ffe0000000p-1, -0x1.fffffffffffc0p-60, -0x1.000fff0000800p+0, 0x1.f7ffe00000c20p-54},
+{0x1.0000080000000p-1, -0x1.0000000000000p-106, 0x1.0000000080000p-1, -0x1.0000000000000p-56, 0x1.0000040040000p+0, -0x1.0000000000000p-56},
+{0x1.0000080000000p-1, -0x1.0000000000000p-106, -0x1.0000000080000p-1, 0x1.0000000000000p-56, 0x1.ffe0000080000p-23, -0x1.0000000000000p-106},
+{-0x1.0000080000000p-1, 0x1.0000000000000p-106, 0x1.0000000080000p-1, -0x1.0000000000000p-56, -0x1.ffe0000080000p-23, 0x1.0000000000000p-106},
+{-0x1.0000080000000p-1, 0x1.0000000000000p-106, -0x1.0000000080000p-1, 0x1.0000000000000p-56, -0x1.0000040040000p+0, 0x1.0000000000000p-56},
+{0x1.003ffffffffe0p-1, 0x1.ffffe03800000p-77, 0x1.0000000002000p-1, -0x1.0000000000000p-54, 0x1.0020000000ff0p+0, -0x1.fffff800007f0p-55},
+{0x1.003ffffffffe0p-1, 0x1.ffffe03800000p-77, -0x1.0000000002000p-1, 0x1.0000000000000p-54, 0x1.ffffffeff0400p-12, 0x1.ffffe03800000p-77},
+{-0x1.003ffffffffe0p-1, -0x1.ffffe03800000p-77, 0x1.0000000002000p-1, -0x1.0000000000000p-54, -0x1.ffffffeff0400p-12, -0x1.ffffe03800000p-77},
+{-0x1.003ffffffffe0p-1, -0x1.ffffe03800000p-77, -0x1.0000000002000p-1, 0x1.0000000000000p-54, -0x1.0020000000ff0p+0, 0x1.fffff800007f0p-55},
+{0x1.0000000000008p-1, -0x1.ff000007ffc00p-61, 0x1.0000000060000p-1, 0x1.ffffff8000000p-81, 0x1.0000000030004p+0, -0x1.feffe007ffc00p-61},
+{0x1.0000000000008p-1, -0x1.ff000007ffc00p-61, -0x1.0000000060000p-1, -0x1.ffffff8000000p-81, -0x1.7ffe007fc0080p-35, -0x1.ffee000000000p-91},
+{-0x1.0000000000008p-1, 0x1.ff000007ffc00p-61, 0x1.0000000060000p-1, 0x1.ffffff8000000p-81, 0x1.7ffe007fc0080p-35, 0x1.ffee000000000p-91},
+{-0x1.0000000000008p-1, 0x1.ff000007ffc00p-61, -0x1.0000000060000p-1, -0x1.ffffff8000000p-81, -0x1.0000000030004p+0, 0x1.feffe007ffc00p-61},
+{0x1.0000000000080p-1, -0x1.0000000000000p-106, 0x1.01ffffff80001p-1, -0x1.ff90000000000p-94, 0x1.00ffffffc0040p+0, 0x1.fffffffffe006p-54},
+{0x1.0000000000080p-1, -0x1.0000000000000p-106, -0x1.01ffffff80001p-1, 0x1.ff90000000000p-94, -0x1.ffffff7ff8100p-9, 0x1.ff80000000000p-94},
+{-0x1.0000000000080p-1, 0x1.0000000000000p-106, 0x1.01ffffff80001p-1, -0x1.ff90000000000p-94, 0x1.ffffff7ff8100p-9, -0x1.ff80000000000p-94},
+{-0x1.0000000000080p-1, 0x1.0000000000000p-106, -0x1.01ffffff80001p-1, 0x1.ff90000000000p-94, -0x1.00ffffffc0040p+0, -0x1.fffffffffe006p-54},
+{0x1.0000000000800p-1, -0x1.fffff80002000p-67, 0x1.0008000000000p-1, -0x1.0000000000000p-80, 0x1.0004000000400p+0, -0x1.0003fc0000000p-66},
+{0x1.0000000000800p-1, -0x1.fffff80002000p-67, -0x1.0008000000000p-1, 0x1.0000000000000p-80, -0x1.ffffffe000002p-15, 0x1.00ffffc000000p-80},
+{-0x1.0000000000800p-1, 0x1.fffff80002000p-67, 0x1.0008000000000p-1, -0x1.0000000000000p-80, 0x1.ffffffe000002p-15, -0x1.00ffffc000000p-80},
+{-0x1.0000000000800p-1, 0x1.fffff80002000p-67, -0x1.0008000000000p-1, 0x1.0000000000000p-80, -0x1.0004000000400p+0, 0x1.0003fc0000000p-66},
+{0x1.0000000000002p-1, -0x1.ffffffe200000p-75, 0x1.0003fffffffc0p-1, 0x1.ffffe00000400p-64, 0x1.0001fffffffe1p+0, 0x1.ffbfe00004000p-64},
+{0x1.0000000000002p-1, -0x1.ffffffe200000p-75, -0x1.0003fffffffc0p-1, -0x1.ffffe00000400p-64, -0x1.fffffffdf0020p-16, -0x1.feffffe400000p-75},
+{-0x1.0000000000002p-1, 0x1.ffffffe200000p-75, 0x1.0003fffffffc0p-1, 0x1.ffffe00000400p-64, 0x1.fffffffdf0020p-16, 0x1.feffffe400000p-75},
+{-0x1.0000000000002p-1, 0x1.ffffffe200000p-75, -0x1.0003fffffffc0p-1, -0x1.ffffe00000400p-64, -0x1.0001fffffffe1p+0, -0x1.ffbfe00004000p-64},
+{0x1.000003f000000p-1, 0x1.fffffffe00000p-62, 0x1.0000000000ff0p-1, 0x1.c03fff0e00000p-75, 0x1.000001f8007f8p+0, 0x1.000700fefc400p-61},
+{0x1.000003f000000p-1, 0x1.fffffffe00000p-62, -0x1.0000000000ff0p-1, -0x1.c03fff0e00000p-75, 0x1.f7ff808007ffcp-24, 0x1.fdfe079000000p-78},
+{-0x1.000003f000000p-1, -0x1.fffffffe00000p-62, 0x1.0000000000ff0p-1, 0x1.c03fff0e00000p-75, -0x1.f7ff808007ffcp-24, -0x1.fdfe079000000p-78},
+{-0x1.000003f000000p-1, -0x1.fffffffe00000p-62, -0x1.0000000000ff0p-1, -0x1.c03fff0e00000p-75, -0x1.000001f8007f8p+0, -0x1.000700fefc400p-61},
+{0x1.0000000018000p-1, 0x1.fffffe0000000p-83, 0x1.0000100000000p-1, -0x1.0000000000000p-106, 0x1.000008000c000p+0, 0x1.fffffc0000000p-83},
+{0x1.0000000018000p-1, 0x1.fffffe0000000p-83, -0x1.0000100000000p-1, 0x1.0000000000000p-106, -0x1.fffd000000000p-22, 0x1.0000000000000p-82},
+{-0x1.0000000018000p-1, -0x1.fffffe0000000p-83, 0x1.0000100000000p-1, -0x1.0000000000000p-106, 0x1.fffd000000000p-22, -0x1.0000000000000p-82},
+{-0x1.0000000018000p-1, -0x1.fffffe0000000p-83, -0x1.0000100000000p-1, 0x1.0000000000000p-106, -0x1.000008000c000p+0, -0x1.fffffc0000000p-83},
+{0x1.0000000000001p-1, -0x1.fffffc1000000p-68, 0x1.1ffffff01f000p-1, 0x1.ffffc000060fcp-56, 0x1.0ffffff80f801p+0, -0x1.80080fffeebc0p-54},
+{0x1.0000000000001p-1, -0x1.fffffc1000000p-68, -0x1.1ffffff01f000p-1, -0x1.ffffc000060fcp-56, -0x1.ffffff01efff4p-5, -0x1.fbfffc70fc000p-68},
+{-0x1.0000000000001p-1, 0x1.fffffc1000000p-68, 0x1.1ffffff01f000p-1, 0x1.ffffc000060fcp-56, 0x1.ffffff01efff4p-5, 0x1.fbfffc70fc000p-68},
+{-0x1.0000000000001p-1, 0x1.fffffc1000000p-68, -0x1.1ffffff01f000p-1, -0x1.ffffc000060fcp-56, -0x1.0ffffff80f801p+0, 0x1.80080fffeebc0p-54},
+{0x1.0000003800000p-1, 0x1.ffe000001fffcp-56, 0x1.0000007fffff0p-1, 0x1.fe1ffffc00000p-63, 0x1.0000005bffff8p+0, 0x1.01ee20000c000p-55},
+{0x1.0000003800000p-1, 0x1.ffe000001fffcp-56, -0x1.0000007fffff0p-1, -0x1.fe1ffffc00000p-63, -0x1.1ffffbf020e20p-27, 0x1.3ffe000000000p-91},
+{-0x1.0000003800000p-1, -0x1.ffe000001fffcp-56, 0x1.0000007fffff0p-1, 0x1.fe1ffffc00000p-63, 0x1.1ffffbf020e20p-27, -0x1.3ffe000000000p-91},
+{-0x1.0000003800000p-1, -0x1.ffe000001fffcp-56, -0x1.0000007fffff0p-1, -0x1.fe1ffffc00000p-63, -0x1.0000005bffff8p+0, -0x1.01ee20000c000p-55},
+{0x1.0000001fffc00p-1, 0x1.f00007ffe0000p-65, 0x1.0000000000180p-1, 0x1.fffffe0000800p-65, 0x1.0000000fffec0p+0, 0x1.f80002fff0000p-64},
+{0x1.0000001fffc00p-1, 0x1.f00007ffe0000p-65, -0x1.0000000000180p-1, -0x1.fffffe0000800p-65, 0x1.fffa7fffff000p-29, 0x1.3ffbf00000000p-86},
+{-0x1.0000001fffc00p-1, -0x1.f00007ffe0000p-65, 0x1.0000000000180p-1, 0x1.fffffe0000800p-65, -0x1.fffa7fffff000p-29, -0x1.3ffbf00000000p-86},
+{-0x1.0000001fffc00p-1, -0x1.f00007ffe0000p-65, -0x1.0000000000180p-1, -0x1.fffffe0000800p-65, -0x1.0000000fffec0p+0, -0x1.f80002fff0000p-64},
+{0x1.0000000008000p-1, -0x1.c0000007ffe04p-56, 0x1.00000fffffffep-1, 0x1.fc00000000000p-100, 0x1.0000080003fffp+0, -0x1.c0000007ffc08p-56},
+{0x1.0000000008000p-1, -0x1.c0000007ffe04p-56, -0x1.00000fffffffep-1, -0x1.fc00000000000p-100, -0x1.fffefffc70000p-22, -0x1.0000000000000p-85},
+{-0x1.0000000008000p-1, 0x1.c0000007ffe04p-56, 0x1.00000fffffffep-1, 0x1.fc00000000000p-100, 0x1.fffefffc70000p-22, 0x1.0000000000000p-85},
+{-0x1.0000000008000p-1, 0x1.c0000007ffe04p-56, -0x1.00000fffffffep-1, -0x1.fc00000000000p-100, -0x1.0000080003fffp+0, 0x1.c0000007ffc08p-56},
+{0x1.0000003e00004p-1, -0x1.fe00040000000p-71, 0x1.00007c0001e00p-1, 0x1.fffe13ffe0000p-65, 0x1.00003e1f00f02p+0, 0x1.f80613efe0000p-65},
+{0x1.0000003e00004p-1, -0x1.fe00040000000p-71, -0x1.00007c0001e00p-1, -0x1.fffe13ffe0000p-65, -0x1.ef08077f00082p-19, 0x1.3d7e040000000p-78},
+{-0x1.0000003e00004p-1, 0x1.fe00040000000p-71, 0x1.00007c0001e00p-1, 0x1.fffe13ffe0000p-65, 0x1.ef08077f00082p-19, -0x1.3d7e040000000p-78},
+{-0x1.0000003e00004p-1, 0x1.fe00040000000p-71, -0x1.00007c0001e00p-1, -0x1.fffe13ffe0000p-65, -0x1.00003e1f00f02p+0, -0x1.f80613efe0000p-65},
+{0x1.03fffffffc000p-1, 0x1.ffffffc000000p-76, 0x1.0003ffffff000p-1, 0x1.ffc0000000000p-96, 0x1.0201fffffd800p+0, 0x1.00000fe000000p-75},
+{0x1.03fffffffc000p-1, 0x1.ffffffc000000p-76, -0x1.0003ffffff000p-1, -0x1.ffc0000000000p-96, 0x1.fdfffffe80000p-8, 0x1.ffffdfc400000p-76},
+{-0x1.03fffffffc000p-1, -0x1.ffffffc000000p-76, 0x1.0003ffffff000p-1, 0x1.ffc0000000000p-96, -0x1.fdfffffe80000p-8, -0x1.ffffdfc400000p-76},
+{-0x1.03fffffffc000p-1, -0x1.ffffffc000000p-76, -0x1.0003ffffff000p-1, -0x1.ffc0000000000p-96, -0x1.0201fffffd800p+0, -0x1.00000fe000000p-75},
+{0x1.07ffffff80000p-1, 0x1.8007ffffc0000p-72, 0x1.0000000000004p-1, -0x1.fffc000200000p-70, 0x1.03ffffffc0002p+0, -0x1.9ffa000200000p-70},
+{0x1.07ffffff80000p-1, 0x1.8007ffffc0000p-72, -0x1.0000000000004p-1, 0x1.fffc000200000p-70, 0x1.ffffffdffff00p-7, 0x1.2fff0000f8000p-69},
+{-0x1.07ffffff80000p-1, -0x1.8007ffffc0000p-72, 0x1.0000000000004p-1, -0x1.fffc000200000p-70, -0x1.ffffffdffff00p-7, -0x1.2fff0000f8000p-69},
+{-0x1.07ffffff80000p-1, -0x1.8007ffffc0000p-72, -0x1.0000000000004p-1, 0x1.fffc000200000p-70, -0x1.03ffffffc0002p+0, 0x1.9ffa000200000p-70},
+{0x1.00003ffffff80p-1, 0x1.ffff0000ffe00p-63, 0x1.00003fffffff8p-1, 0x0.0000000000000p+0, 0x1.00003ffffffbcp+0, 0x1.ffff000100000p-63},
+{0x1.00003ffffff80p-1, 0x1.ffff0000ffe00p-63, -0x1.00003fffffff8p-1, 0x0.0000000000000p+0, -0x1.dffe0000ffff0p-47, -0x1.0000000000000p-106},
+{-0x1.00003ffffff80p-1, -0x1.ffff0000ffe00p-63, 0x1.00003fffffff8p-1, 0x0.0000000000000p+0, 0x1.dffe0000ffff0p-47, 0x1.0000000000000p-106},
+{-0x1.00003ffffff80p-1, -0x1.ffff0000ffe00p-63, -0x1.00003fffffff8p-1, 0x0.0000000000000p+0, -0x1.00003ffffffbcp+0, -0x1.ffff000100000p-63},
+{0x1.0000010000000p-1, -0x1.0000000000000p-106, 0x1.00f81ffffff81p-1, 0x1.fffff03c00000p-63, 0x1.007c107ffffc1p+0, -0x1.ff000007e2000p-54},
+{0x1.0000010000000p-1, -0x1.0000000000000p-106, -0x1.00f81ffffff81p-1, -0x1.fffff03c00000p-63, -0x1.f03dfffff0201p-10, 0x1.f87ffc0000000p-84},
+{-0x1.0000010000000p-1, 0x1.0000000000000p-106, 0x1.00f81ffffff81p-1, 0x1.fffff03c00000p-63, 0x1.f03dfffff0201p-10, -0x1.f87ffc0000000p-84},
+{-0x1.0000010000000p-1, 0x1.0000000000000p-106, -0x1.00f81ffffff81p-1, -0x1.fffff03c00000p-63, -0x1.007c107ffffc1p+0, 0x1.ff000007e2000p-54},
+{0x1.0000000000004p-1, -0x1.fff0008000000p-65, 0x1.0000000100000p-1, -0x1.fffffe0004000p-68, 0x1.0000000080002p+0, -0x1.1ff8002000000p-64},
+{0x1.0000000000004p-1, -0x1.fff0008000000p-65, -0x1.0000000100000p-1, 0x1.fffffe0004000p-68, -0x1.ffff80037fe00p-34, -0x1.7fff000000000p-90},
+{-0x1.0000000000004p-1, 0x1.fff0008000000p-65, 0x1.0000000100000p-1, -0x1.fffffe0004000p-68, 0x1.ffff80037fe00p-34, 0x1.7fff000000000p-90},
+{-0x1.0000000000004p-1, 0x1.fff0008000000p-65, -0x1.0000000100000p-1, 0x1.fffffe0004000p-68, -0x1.0000000080002p+0, 0x1.1ff8002000000p-64},
+{0x1.0000000000800p-1, -0x1.0000000000000p-79, 0x1.0000010000000p-1, -0x1.0000000000000p-104, 0x1.0000008000400p+0, -0x1.0000008000000p-79},
+{0x1.0000000000800p-1, -0x1.0000000000000p-79, -0x1.0000010000000p-1, 0x1.0000000000000p-104, -0x1.ffff000000000p-26, -0x1.ffffff0000000p-80},
+{-0x1.0000000000800p-1, 0x1.0000000000000p-79, 0x1.0000010000000p-1, -0x1.0000000000000p-104, 0x1.ffff000000000p-26, 0x1.ffffff0000000p-80},
+{-0x1.0000000000800p-1, 0x1.0000000000000p-79, -0x1.0000010000000p-1, 0x1.0000000000000p-104, -0x1.0000008000400p+0, 0x1.0000008000000p-79},
+{0x1.00000007fff00p-1, 0x1.fffc1ffff87f0p-57, 0x1.0000007c00000p-1, 0x1.fff0000000000p-72, 0x1.00000041fff80p+0, 0x1.00000feffc3f8p-56},
+{0x1.00000007fff00p-1, 0x1.fffc1ffff87f0p-57, -0x1.0000007c00000p-1, -0x1.fff0000000000p-72, -0x1.d0003ff8001f8p-27, 0x1.ff87f00000000p-85},
+{-0x1.00000007fff00p-1, -0x1.fffc1ffff87f0p-57, 0x1.0000007c00000p-1, 0x1.fff0000000000p-72, 0x1.d0003ff8001f8p-27, -0x1.ff87f00000000p-85},
+{-0x1.00000007fff00p-1, -0x1.fffc1ffff87f0p-57, -0x1.0000007c00000p-1, -0x1.fff0000000000p-72, -0x1.00000041fff80p+0, -0x1.00000feffc3f8p-56},
+{0x1.fffffffe00000p-1, 0x1.e000001fff800p-65, 0x1.00000001ffffep-1, 0x0.0000000000000p+0, 0x1.7ffffffffffffp+0, 0x1.e000002000000p-65},
+{0x1.fffffffe00000p-1, 0x1.e000001fff800p-65, -0x1.00000001ffffep-1, 0x0.0000000000000p+0, 0x1.fffffff800004p-2, 0x1.e000001fff800p-65},
+{-0x1.fffffffe00000p-1, -0x1.e000001fff800p-65, 0x1.00000001ffffep-1, 0x0.0000000000000p+0, -0x1.fffffff800004p-2, -0x1.e000001fff800p-65},
+{-0x1.fffffffe00000p-1, -0x1.e000001fff800p-65, -0x1.00000001ffffep-1, 0x0.0000000000000p+0, -0x1.7ffffffffffffp+0, -0x1.e000002000000p-65},
+{0x1.0000000000008p-1, -0x1.fffff00400000p-73, 0x1.00003ffffe000p-1, 0x1.ffffe00000000p-73, 0x1.00001fffff004p+0, -0x1.0040000000000p-93},
+{0x1.0000000000008p-1, -0x1.fffff00400000p-73, -0x1.00003ffffe000p-1, -0x1.ffffe00000000p-73, -0x1.ffffeffc00002p-20, 0x1.7fe0000000000p-92},
+{-0x1.0000000000008p-1, 0x1.fffff00400000p-73, 0x1.00003ffffe000p-1, 0x1.ffffe00000000p-73, 0x1.ffffeffc00002p-20, -0x1.7fe0000000000p-92},
+{-0x1.0000000000008p-1, 0x1.fffff00400000p-73, -0x1.00003ffffe000p-1, -0x1.ffffe00000000p-73, -0x1.00001fffff004p+0, 0x1.0040000000000p-93},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, 0x1.000001ffe0000p-1, 0x1.ff87ff9f801c0p-60, 0x1.000000fff0000p+0, 0x1.0fc3ffcfc00c0p-59},
+{0x1.0000000000000p-1, 0x1.ffffffffffc00p-64, -0x1.000001ffe0000p-1, -0x1.ff87ff9f801c0p-60, -0x1.ffe000003bf10p-25, 0x1.81ff800000000p-86},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, 0x1.000001ffe0000p-1, 0x1.ff87ff9f801c0p-60, 0x1.ffe000003bf10p-25, -0x1.81ff800000000p-86},
+{-0x1.0000000000000p-1, -0x1.ffffffffffc00p-64, -0x1.000001ffe0000p-1, -0x1.ff87ff9f801c0p-60, -0x1.000000fff0000p+0, -0x1.0fc3ffcfc00c0p-59},
+{0x1.0000000000400p-1, -0x1.f800000002000p-62, 0x1.03fffffffff00p-1, 0x1.fffe7fffffffep-55, 0x1.0200000000180p+0, 0x1.fc0e7ffffffc0p-55},
+{0x1.0000000000400p-1, -0x1.f800000002000p-62, -0x1.03fffffffff00p-1, -0x1.fffe7fffffffep-55, -0x1.ffffffffd8040p-8, -0x1.f740000001f00p-62},
+{-0x1.0000000000400p-1, 0x1.f800000002000p-62, 0x1.03fffffffff00p-1, 0x1.fffe7fffffffep-55, 0x1.ffffffffd8040p-8, 0x1.f740000001f00p-62},
+{-0x1.0000000000400p-1, 0x1.f800000002000p-62, -0x1.03fffffffff00p-1, -0x1.fffe7fffffffep-55, -0x1.0200000000180p+0, -0x1.fc0e7ffffffc0p-55},
+{0x1.0000000000000p-1, 0x1.fffffffffff00p-57, 0x1.000007c000000p-1, 0x1.fff8000000000p-57, 0x1.000003e000000p+0, 0x1.fffbfffffff80p-56},
+{0x1.0000000000000p-1, 0x1.fffffffffff00p-57, -0x1.000007c000000p-1, -0x1.fff8000000000p-57, -0x1.effffffffffe0p-23, -0x1.0000000000000p-101},
+{-0x1.0000000000000p-1, -0x1.fffffffffff00p-57, 0x1.000007c000000p-1, 0x1.fff8000000000p-57, 0x1.effffffffffe0p-23, 0x1.0000000000000p-101},
+{-0x1.0000000000000p-1, -0x1.fffffffffff00p-57, -0x1.000007c000000p-1, -0x1.fff8000000000p-57, -0x1.000003e000000p+0, -0x1.fffbfffffff80p-56},
+{0x1.0000000000400p-1, -0x1.fffc0003fffd0p-58, 0x1.0000000000000p-1, 0x1.fffffff800000p-57, 0x1.0000000000200p+0, 0x1.0001fff600020p-57},
+{0x1.0000000000400p-1, -0x1.fffc0003fffd0p-58, -0x1.0000000000000p-1, -0x1.fffffff800000p-57, 0x1.ffe8001000300p-44, 0x1.8000000000000p-105},
+{-0x1.0000000000400p-1, 0x1.fffc0003fffd0p-58, 0x1.0000000000000p-1, 0x1.fffffff800000p-57, -0x1.ffe8001000300p-44, -0x1.8000000000000p-105},
+{-0x1.0000000000400p-1, 0x1.fffc0003fffd0p-58, -0x1.0000000000000p-1, -0x1.fffffff800000p-57, -0x1.0000000000200p+0, -0x1.0001fff600020p-57},
+{0x1.0000000002000p-1, -0x1.ffff040000000p-72, 0x1.03fffff800000p-1, 0x1.fffffe0000000p-69, 0x1.01fffffc01000p+0, 0x1.c0001d8000000p-69},
+{0x1.0000000002000p-1, -0x1.ffff040000000p-72, -0x1.03fffff800000p-1, -0x1.fffffe0000000p-69, -0x1.fffffbff00000p-8, -0x1.1fffef4000000p-68},
+{-0x1.0000000002000p-1, 0x1.ffff040000000p-72, 0x1.03fffff800000p-1, 0x1.fffffe0000000p-69, 0x1.fffffbff00000p-8, 0x1.1fffef4000000p-68},
+{-0x1.0000000002000p-1, 0x1.ffff040000000p-72, -0x1.03fffff800000p-1, -0x1.fffffe0000000p-69, -0x1.01fffffc01000p+0, -0x1.c0001d8000000p-69},
+{0x1.0000008000000p-1, -0x1.ffffff8200000p-58, 0x1.000fff8000000p-1, 0x1.fffffe0000000p-63, 0x1.0008000000000p+0, -0x1.efffff9200000p-58},
+{0x1.0000008000000p-1, -0x1.ffffff8200000p-58, -0x1.000fff8000000p-1, -0x1.fffffe0000000p-63, -0x1.ffe0000000210p-14, 0x1.1c00000000000p-83},
+{-0x1.0000008000000p-1, 0x1.ffffff8200000p-58, 0x1.000fff8000000p-1, 0x1.fffffe0000000p-63, 0x1.ffe0000000210p-14, -0x1.1c00000000000p-83},
+{-0x1.0000008000000p-1, 0x1.ffffff8200000p-58, -0x1.000fff8000000p-1, -0x1.fffffe0000000p-63, -0x1.0008000000000p+0, 0x1.efffff9200000p-58},
+{0x1.0000000000000p-1, 0x1.0001f9e000000p-61, 0x1.0000000000040p-1, -0x1.fffffc0080000p-73, 0x1.0000000000020p+0, 0x1.ffc3f3c080000p-62},
+{0x1.0000000000000p-1, 0x1.0001f9e000000p-61, -0x1.0000000000040p-1, 0x1.fffffc0080000p-73, -0x1.fff7fef031020p-48, 0x1.0000000000000p-106},
+{-0x1.0000000000000p-1, -0x1.0001f9e000000p-61, 0x1.0000000000040p-1, -0x1.fffffc0080000p-73, 0x1.fff7fef031020p-48, -0x1.0000000000000p-106},
+{-0x1.0000000000000p-1, -0x1.0001f9e000000p-61, -0x1.0000000000040p-1, 0x1.fffffc0080000p-73, -0x1.0000000000020p+0, -0x1.ffc3f3c080000p-62},
+{0x1.0000ff0007e00p-1, 0x1.ffc001ff00000p-68, 0x1.0000010000000p-1, -0x1.ffc007ffffe20p-59, 0x1.0000800003f00p+0, -0x1.fec027ff00600p-59},
+{0x1.0000ff0007e00p-1, 0x1.ffc001ff00000p-68, -0x1.0000010000000p-1, 0x1.ffc007ffffe20p-59, 0x1.fc000fc001006p-18, -0x1.7ff009e000000p-79},
+{-0x1.0000ff0007e00p-1, -0x1.ffc001ff00000p-68, 0x1.0000010000000p-1, -0x1.ffc007ffffe20p-59, -0x1.fc000fc001006p-18, 0x1.7ff009e000000p-79},
+{-0x1.0000ff0007e00p-1, -0x1.ffc001ff00000p-68, -0x1.0000010000000p-1, 0x1.ffc007ffffe20p-59, -0x1.0000800003f00p+0, 0x1.fec027ff00600p-59},
+{0x1.07ffffff1fe00p-1, 0x1.fc00000000000p-98, 0x1.0040000000000p-1, -0x1.c000000400000p-62, 0x1.041fffff8ff00p+0, -0x1.c0000003e0400p-62},
+{0x1.07ffffff1fe00p-1, 0x1.fc00000000000p-98, -0x1.0040000000000p-1, 0x1.c000000400000p-62, 0x1.efffffc7f8000p-7, 0x1.c00000041fc00p-62},
+{-0x1.07ffffff1fe00p-1, -0x1.fc00000000000p-98, 0x1.0040000000000p-1, -0x1.c000000400000p-62, -0x1.efffffc7f8000p-7, -0x1.c00000041fc00p-62},
+{-0x1.07ffffff1fe00p-1, -0x1.fc00000000000p-98, -0x1.0040000000000p-1, 0x1.c000000400000p-62, -0x1.041fffff8ff00p+0, 0x1.c0000003e0400p-62},
+{0x1.0080000000000p-1, -0x1.0000000000000p-106, 0x1.00000001fffc0p-1, 0x1.fffff80f80000p-73, 0x1.00400000fffe0p+0, 0x1.fffff80f00000p-73},
+{0x1.0080000000000p-1, -0x1.0000000000000p-106, -0x1.00000001fffc0p-1, -0x1.fffff80f80000p-73, 0x1.fffff80010000p-11, -0x1.fffff81000000p-73},
+{-0x1.0080000000000p-1, 0x1.0000000000000p-106, 0x1.00000001fffc0p-1, 0x1.fffff80f80000p-73, -0x1.fffff80010000p-11, 0x1.fffff81000000p-73},
+{-0x1.0080000000000p-1, 0x1.0000000000000p-106, -0x1.00000001fffc0p-1, -0x1.fffff80f80000p-73, -0x1.00400000fffe0p+0, -0x1.fffff80f00000p-73},
+{0x1.000000003ff00p-1, 0x0.0000000000000p+0, 0x1.0000000000000p-1, 0x1.f83007ffffe00p-61, 0x1.000000001ff80p+0, 0x1.f83007ffffe00p-61},
+{0x1.000000003ff00p-1, 0x0.0000000000000p+0, -0x1.0000000000000p-1, -0x1.f83007ffffe00p-61, 0x1.ff7fff03e7fc0p-36, 0x1.0000000000000p-104},
+{-0x1.000000003ff00p-1, 0x0.0000000000000p+0, 0x1.0000000000000p-1, 0x1.f83007ffffe00p-61, -0x1.ff7fff03e7fc0p-36, -0x1.0000000000000p-104},
+{-0x1.000000003ff00p-1, 0x0.0000000000000p+0, -0x1.0000000000000p-1, -0x1.f83007ffffe00p-61, -0x1.000000001ff80p+0, -0x1.f83007ffffe00p-61},
+{0x1.00003fffffe00p-1, 0x1.fffffc0000380p-61, 0x1.0000010000000p-1, -0x1.ffffff8000008p-57, 0x1.0000207ffff00p+0, -0x1.dfffffbffffd0p-57},
+{0x1.00003fffffe00p-1, 0x1.fffffc0000380p-61, -0x1.0000010000000p-1, 0x1.ffffff8000008p-57, 0x1.f7ffff0011000p-20, -0x1.7ffff80000000p-82},
+{-0x1.00003fffffe00p-1, -0x1.fffffc0000380p-61, 0x1.0000010000000p-1, -0x1.ffffff8000008p-57, -0x1.f7ffff0011000p-20, 0x1.7ffff80000000p-82},
+{-0x1.00003fffffe00p-1, -0x1.fffffc0000380p-61, -0x1.0000010000000p-1, 0x1.ffffff8000008p-57, -0x1.0000207ffff00p+0, 0x1.dfffffbffffd0p-57},
+{0x1.0000000080000p-1, -0x1.fffffc0010000p-70, 0x1.3fffff8000000p-1, 0x1.fffff800fe000p-67, 0x1.1fffffc040000p+0, 0x1.bffff880fc000p-67},
+{0x1.0000000080000p-1, -0x1.fffffc0010000p-70, -0x1.3fffff8000000p-1, -0x1.fffff800fe000p-67, -0x1.fffffbfc00000p-4, -0x1.1ffffbc080000p-66},
+{-0x1.0000000080000p-1, 0x1.fffffc0010000p-70, 0x1.3fffff8000000p-1, 0x1.fffff800fe000p-67, 0x1.fffffbfc00000p-4, 0x1.1ffffbc080000p-66},
+{-0x1.0000000080000p-1, 0x1.fffffc0010000p-70, -0x1.3fffff8000000p-1, -0x1.fffff800fe000p-67, -0x1.1fffffc040000p+0, -0x1.bffff880fc000p-67},
+{0x1.0003f001fc3f0p-1, 0x1.fffffc0000000p-57, 0x1.0000000000000p-1, 0x1.fc1fffc0000fep-55, 0x1.0001f800fe1f8p+0, 0x1.3e0fff6000080p-54},
+{0x1.0003f001fc3f0p-1, 0x1.fffffc0000000p-57, -0x1.0000000000000p-1, -0x1.fc1fffc0000fep-55, 0x1.f800fe1f7d07cp-16, -0x1.80001fc000000p-80},
+{-0x1.0003f001fc3f0p-1, -0x1.fffffc0000000p-57, 0x1.0000000000000p-1, 0x1.fc1fffc0000fep-55, -0x1.f800fe1f7d07cp-16, 0x1.80001fc000000p-80},
+{-0x1.0003f001fc3f0p-1, -0x1.fffffc0000000p-57, -0x1.0000000000000p-1, -0x1.fc1fffc0000fep-55, -0x1.0001f800fe1f8p+0, -0x1.3e0fff6000080p-54},
+{0x1.0000000000000p-1, 0x1.fffffffffffc0p-60, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-63, 0x1.0000000000000p+0, 0x1.1ffffffffffc0p-59},
+{0x1.0000000000000p-1, 0x1.fffffffffffc0p-60, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-63, 0x1.c000000000000p-60, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffffffffffc0p-60, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-63, -0x1.c000000000000p-60, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffffffffffc0p-60, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-63, -0x1.0000000000000p+0, -0x1.1ffffffffffc0p-59},
+{0x1.0000000100000p-1, -0x1.0000000000000p-80, 0x1.0000004000000p-1, -0x1.0000000000000p-81, 0x1.0000002080000p+0, -0x1.8000000000000p-80},
+{0x1.0000000100000p-1, -0x1.0000000000000p-80, -0x1.0000004000000p-1, 0x1.0000000000000p-81, -0x1.f800000000000p-28, -0x1.0000000000000p-81},
+{-0x1.0000000100000p-1, 0x1.0000000000000p-80, 0x1.0000004000000p-1, -0x1.0000000000000p-81, 0x1.f800000000000p-28, 0x1.0000000000000p-81},
+{-0x1.0000000100000p-1, 0x1.0000000000000p-80, -0x1.0000004000000p-1, 0x1.0000000000000p-81, -0x1.0000002080000p+0, 0x1.8000000000000p-80},
+{0x1.0000010000000p-1, -0x1.ffffe00001000p-57, 0x1.000ffffff007fp-1, 0x1.ffffc00000000p-82, 0x1.0008007ff803fp+0, 0x1.c000041fffdc0p-54},
+{0x1.0000010000000p-1, -0x1.ffffe00001000p-57, -0x1.000ffffff007fp-1, -0x1.ffffc00000000p-82, -0x1.ffdffe00fe400p-14, 0x1.effff20000000p-77},
+{-0x1.0000010000000p-1, 0x1.ffffe00001000p-57, 0x1.000ffffff007fp-1, 0x1.ffffc00000000p-82, 0x1.ffdffe00fe400p-14, -0x1.effff20000000p-77},
+{-0x1.0000010000000p-1, 0x1.ffffe00001000p-57, -0x1.000ffffff007fp-1, -0x1.ffffc00000000p-82, -0x1.0008007ff803fp+0, -0x1.c000041fffdc0p-54},
+{0x1.1000fffffc000p-1, 0x1.fffffc003f000p-57, 0x1.0000000001000p-1, -0x1.0000000000000p-106, 0x1.08007ffffe800p+0, 0x1.fffffc003f000p-57},
+{0x1.1000fffffc000p-1, 0x1.fffffc003f000p-57, -0x1.0000000001000p-1, 0x1.0000000000000p-106, 0x1.000fffffb0002p-5, -0x1.ffe07fc000000p-80},
+{-0x1.1000fffffc000p-1, -0x1.fffffc003f000p-57, 0x1.0000000001000p-1, -0x1.0000000000000p-106, -0x1.000fffffb0002p-5, 0x1.ffe07fc000000p-80},
+{-0x1.1000fffffc000p-1, -0x1.fffffc003f000p-57, -0x1.0000000001000p-1, 0x1.0000000000000p-106, -0x1.08007ffffe800p+0, -0x1.fffffc003f000p-57},
+{0x1.00000fff80000p-1, 0x1.fffe000000000p-86, 0x1.0000001f00000p-1, 0x1.fffffff000000p-78, 0x1.0000080f40000p+0, 0x1.00ffff0000000p-77},
+{0x1.00000fff80000p-1, 0x1.fffe000000000p-86, -0x1.0000001f00000p-1, -0x1.fffffff000000p-78, 0x1.fc10000000000p-22, -0x1.fe0001f000000p-78},
+{-0x1.00000fff80000p-1, -0x1.fffe000000000p-86, 0x1.0000001f00000p-1, 0x1.fffffff000000p-78, -0x1.fc10000000000p-22, 0x1.fe0001f000000p-78},
+{-0x1.00000fff80000p-1, -0x1.fffe000000000p-86, -0x1.0000001f00000p-1, -0x1.fffffff000000p-78, -0x1.0000080f40000p+0, -0x1.00ffff0000000p-77},
+{0x1.3fdfffff02000p-1, -0x1.0000000000000p-79, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-62, 0x1.1fefffff81000p+0, 0x1.ffff7fffffe00p-62},
+{0x1.3fdfffff02000p-1, -0x1.0000000000000p-79, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-62, 0x1.fefffff810000p-4, -0x1.00003ffffff00p-61},
+{-0x1.3fdfffff02000p-1, 0x1.0000000000000p-79, 0x1.0000000000000p-1, 0x1.ffffffffffe00p-62, -0x1.fefffff810000p-4, 0x1.00003ffffff00p-61},
+{-0x1.3fdfffff02000p-1, 0x1.0000000000000p-79, -0x1.0000000000000p-1, -0x1.ffffffffffe00p-62, -0x1.1fefffff81000p+0, -0x1.ffff7fffffe00p-62},
+{0x1.0000000000008p-1, -0x1.e0ffffd002000p-67, 0x1.0000000000400p-1, 0x1.ffffffff03ffep-55, 0x1.0000000000204p+0, 0x1.ffe1efff06ffcp-55},
+{0x1.0000000000008p-1, -0x1.e0ffffd002000p-67, -0x1.0000000000400p-1, -0x1.ffffffff03ffep-55, -0x1.fc4003c1ffe02p-44, 0x0.0000000000000p+0},
+{-0x1.0000000000008p-1, 0x1.e0ffffd002000p-67, 0x1.0000000000400p-1, 0x1.ffffffff03ffep-55, 0x1.fc4003c1ffe02p-44, 0x0.0000000000000p+0},
+{-0x1.0000000000008p-1, 0x1.e0ffffd002000p-67, -0x1.0000000000400p-1, -0x1.ffffffff03ffep-55, -0x1.0000000000204p+0, -0x1.ffe1efff06ffcp-55},
+{0x1.000000fffe020p-1, -0x1.f800100000000p-74, 0x1.0001fff80ffc0p-1, 0x1.ff00000000000p-98, 0x1.0001007c06ff0p+0, -0x1.f8000e0000000p-74},
+{0x1.000000fffe020p-1, -0x1.f800100000000p-74, -0x1.0001fff80ffc0p-1, -0x1.ff00000000000p-98, -0x1.fef811fa00000p-17, -0x1.f80011ff00000p-74},
+{-0x1.000000fffe020p-1, 0x1.f800100000000p-74, 0x1.0001fff80ffc0p-1, 0x1.ff00000000000p-98, 0x1.fef811fa00000p-17, 0x1.f80011ff00000p-74},
+{-0x1.000000fffe020p-1, 0x1.f800100000000p-74, -0x1.0001fff80ffc0p-1, -0x1.ff00000000000p-98, -0x1.0001007c06ff0p+0, 0x1.f8000e0000000p-74},
+{0x1.4000000000000p-1, -0x1.0000000000000p-106, 0x1.0000000000010p-1, 0x1.e000000000000p-69, 0x1.2000000000008p+0, 0x1.e000000000000p-69},
+{0x1.4000000000000p-1, -0x1.0000000000000p-106, -0x1.0000000000010p-1, -0x1.e000000000000p-69, 0x1.fffffffffff80p-4, -0x1.e000000008000p-69},
+{-0x1.4000000000000p-1, 0x1.0000000000000p-106, 0x1.0000000000010p-1, 0x1.e000000000000p-69, -0x1.fffffffffff80p-4, 0x1.e000000008000p-69},
+{-0x1.4000000000000p-1, 0x1.0000000000000p-106, -0x1.0000000000010p-1, -0x1.e000000000000p-69, -0x1.2000000000008p+0, -0x1.e000000000000p-69},
+{0x1.2000000000000p-1, -0x1.fffffff01ff20p-58, 0x1.0000000000000p-1, 0x1.fff8003ff0000p-58, 0x1.1000000000000p+0, -0x1.ffec0bfc80000p-72},
+{0x1.2000000000000p-1, -0x1.fffffff01ff20p-58, -0x1.0000000000000p-1, -0x1.fff8003ff0000p-58, 0x1.ffffffffffffep-5, 0x1.fff3fc0380000p-72},
+{-0x1.2000000000000p-1, 0x1.fffffff01ff20p-58, 0x1.0000000000000p-1, 0x1.fff8003ff0000p-58, -0x1.ffffffffffffep-5, -0x1.fff3fc0380000p-72},
+{-0x1.2000000000000p-1, 0x1.fffffff01ff20p-58, -0x1.0000000000000p-1, -0x1.fff8003ff0000p-58, -0x1.1000000000000p+0, 0x1.ffec0bfc80000p-72},
+{0x1.2000000000000p-1, -0x1.fc08000000000p-93, 0x1.0000000038004p-1, -0x1.fffffc4000000p-70, 0x1.100000001c002p+0, -0x1.0000001c00000p-69},
+{0x1.2000000000000p-1, -0x1.fc08000000000p-93, -0x1.0000000038004p-1, 0x1.fffffc4000000p-70, 0x1.fffffffc7ffc0p-5, 0x1.fffff847f0000p-70},
+{-0x1.2000000000000p-1, 0x1.fc08000000000p-93, 0x1.0000000038004p-1, -0x1.fffffc4000000p-70, -0x1.fffffffc7ffc0p-5, -0x1.fffff847f0000p-70},
+{-0x1.2000000000000p-1, 0x1.fc08000000000p-93, -0x1.0000000038004p-1, 0x1.fffffc4000000p-70, -0x1.100000001c002p+0, 0x1.0000001c00000p-69},
+{0x1.0000000000200p-1, 0x0.0000000000000p+0, 0x1.00001ffff0000p-1, 0x1.ffff80001f000p-58, 0x1.00000ffff8100p+0, 0x1.ffff80001f000p-58},
+{0x1.0000000000200p-1, 0x0.0000000000000p+0, -0x1.00001ffff0000p-1, -0x1.ffff80001f000p-58, -0x1.fffefe0010000p-21, 0x1.ffff840000000p-76},
+{-0x1.0000000000200p-1, 0x0.0000000000000p+0, 0x1.00001ffff0000p-1, 0x1.ffff80001f000p-58, 0x1.fffefe0010000p-21, -0x1.ffff840000000p-76},
+{-0x1.0000000000200p-1, 0x0.0000000000000p+0, -0x1.00001ffff0000p-1, -0x1.ffff80001f000p-58, -0x1.00000ffff8100p+0, -0x1.ffff80001f000p-58},
+{0x1.0000100000000p-1, -0x1.0000000000000p-106, 0x1.0038000800000p-1, -0x1.fffffe0000080p-61, 0x1.001c080400000p+0, -0x1.fffffe0000100p-61},
+{0x1.0000100000000p-1, -0x1.0000000000000p-106, -0x1.0038000800000p-1, 0x1.fffffe0000080p-61, -0x1.bf803fffffff0p-12, -0x1.0000000000000p-84},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-106, 0x1.0038000800000p-1, -0x1.fffffe0000080p-61, 0x1.bf803fffffff0p-12, 0x1.0000000000000p-84},
+{-0x1.0000100000000p-1, 0x1.0000000000000p-106, -0x1.0038000800000p-1, 0x1.fffffe0000080p-61, -0x1.001c080400000p+0, 0x1.fffffe0000100p-61},
+{0x1.0000000000004p-1, -0x1.ffffe00400000p-74, 0x1.0000000000000p-1, 0x1.ffffffffffff8p-57, 0x1.0000000000002p+0, 0x1.ffff00000ffe0p-57},
+{0x1.0000000000004p-1, -0x1.ffffe00400000p-74, -0x1.0000000000000p-1, -0x1.ffffffffffff8p-57, 0x1.effff800007ffp-52, 0x1.0000000000000p-106},
+{-0x1.0000000000004p-1, 0x1.ffffe00400000p-74, 0x1.0000000000000p-1, 0x1.ffffffffffff8p-57, -0x1.effff800007ffp-52, -0x1.0000000000000p-106},
+{-0x1.0000000000004p-1, 0x1.ffffe00400000p-74, -0x1.0000000000000p-1, -0x1.ffffffffffff8p-57, -0x1.0000000000002p+0, -0x1.ffff00000ffe0p-57},
+{0x1.0000000000100p-1, -0x1.ffffe7e400000p-71, 0x1.1ffe000008000p-1, -0x1.fffc000004000p-68, 0x1.0fff000004080p+0, -0x1.1ffdfe7e40000p-67},
+{0x1.0000000000100p-1, -0x1.ffffe7e400000p-71, -0x1.1ffe000008000p-1, 0x1.fffc000004000p-68, -0x1.ffe000007f000p-5, 0x1.bffc030384000p-68},
+{-0x1.0000000000100p-1, 0x1.ffffe7e400000p-71, 0x1.1ffe000008000p-1, -0x1.fffc000004000p-68, 0x1.ffe000007f000p-5, -0x1.bffc030384000p-68},
+{-0x1.0000000000100p-1, 0x1.ffffe7e400000p-71, -0x1.1ffe000008000p-1, 0x1.fffc000004000p-68, -0x1.0fff000004080p+0, 0x1.1ffdfe7e40000p-67},
+{0x1.0000000000004p-1, -0x1.0000000000000p-106, 0x1.00000007ffffep-1, 0x1.ffffe000f0000p-62, 0x1.0000000400001p+0, 0x1.ffffe000f0000p-62},
+{0x1.0000000000004p-1, -0x1.0000000000000p-106, -0x1.00000007ffffep-1, -0x1.ffffe000f0000p-62, -0x1.ffffe803ffffcp-31, -0x1.e020000000000p-95},
+{-0x1.0000000000004p-1, 0x1.0000000000000p-106, 0x1.00000007ffffep-1, 0x1.ffffe000f0000p-62, 0x1.ffffe803ffffcp-31, 0x1.e020000000000p-95},
+{-0x1.0000000000004p-1, 0x1.0000000000000p-106, -0x1.00000007ffffep-1, -0x1.ffffe000f0000p-62, -0x1.0000000400001p+0, -0x1.ffffe000f0000p-62},
+{0x1.0000000000000p-1, 0x1.fffffff000000p-62, 0x1.0001fffc00001p-1, -0x1.0000000000000p-80, 0x1.0000fffe00001p+0, -0x1.fe00004010000p-54},
+{0x1.0000000000000p-1, 0x1.fffffff000000p-62, -0x1.0001fffc00001p-1, 0x1.0000000000000p-80, -0x1.fffc00000ff00p-17, 0x1.ff80000000000p-81},
+{-0x1.0000000000000p-1, -0x1.fffffff000000p-62, 0x1.0001fffc00001p-1, -0x1.0000000000000p-80, 0x1.fffc00000ff00p-17, -0x1.ff80000000000p-81},
+{-0x1.0000000000000p-1, -0x1.fffffff000000p-62, -0x1.0001fffc00001p-1, 0x1.0000000000000p-80, -0x1.0000fffe00001p+0, 0x1.fe00004010000p-54},
+{0x1.00007fdfffff0p-1, 0x1.fff000f803fe0p-59, 0x1.0080000000000p-1, -0x1.0000000000000p-93, 0x1.00403fefffff8p+0, 0x1.fff000f7c4000p-59},
+{0x1.00007fdfffff0p-1, 0x1.fff000f803fe0p-59, -0x1.0080000000000p-1, 0x1.0000000000000p-93, -0x1.fe00800003fe0p-11, -0x1.ffe0f78040000p-72},
+{-0x1.00007fdfffff0p-1, -0x1.fff000f803fe0p-59, 0x1.0080000000000p-1, -0x1.0000000000000p-93, 0x1.fe00800003fe0p-11, 0x1.ffe0f78040000p-72},
+{-0x1.00007fdfffff0p-1, -0x1.fff000f803fe0p-59, -0x1.0080000000000p-1, 0x1.0000000000000p-93, -0x1.00403fefffff8p+0, -0x1.fff000f7c4000p-59},
+{0x1.0000000000080p-1, 0x0.0000000000000p+0, 0x1.0000080000000p-1, -0x1.0000000000000p-86, 0x1.0000040000040p+0, -0x1.0000000000000p-86},
+{0x1.0000000000080p-1, 0x0.0000000000000p+0, -0x1.0000080000000p-1, 0x1.0000000000000p-86, -0x1.fffffe0000000p-23, 0x1.0000000000000p-86},
+{-0x1.0000000000080p-1, 0x0.0000000000000p+0, 0x1.0000080000000p-1, -0x1.0000000000000p-86, 0x1.fffffe0000000p-23, -0x1.0000000000000p-86},
+{-0x1.0000000000080p-1, 0x0.0000000000000p+0, -0x1.0000080000000p-1, 0x1.0000000000000p-86, -0x1.0000040000040p+0, 0x1.0000000000000p-86},
+{0x1.0400000000000p-1, -0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.fffff00008000p-57, 0x1.0200000000200p+0, -0x1.fffff00008000p-57},
+{0x1.0400000000000p-1, -0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.fffff00008000p-57, 0x1.ffffffffe0010p-8, -0x1.ffff001000000p-78},
+{-0x1.0400000000000p-1, 0x1.0000000000000p-106, 0x1.0000000000400p-1, -0x1.fffff00008000p-57, -0x1.ffffffffe0010p-8, 0x1.ffff001000000p-78},
+{-0x1.0400000000000p-1, 0x1.0000000000000p-106, -0x1.0000000000400p-1, 0x1.fffff00008000p-57, -0x1.0200000000200p+0, 0x1.fffff00008000p-57},
+{0x1.0000000000001p-1, -0x1.fc0000c004000p-66, 0x1.0000000000200p-1, -0x1.ffe0000200000p-69, 0x1.0000000000100p+0, 0x1.ffdc403ff3fbcp-54},
+{0x1.0000000000001p-1, -0x1.fc0000c004000p-66, -0x1.0000000000200p-1, 0x1.ffe0000200000p-69, -0x1.ff000de020060p-45, 0x1.e000000000000p-101},
+{-0x1.0000000000001p-1, 0x1.fc0000c004000p-66, 0x1.0000000000200p-1, -0x1.ffe0000200000p-69, 0x1.ff000de020060p-45, -0x1.e000000000000p-101},
+{-0x1.0000000000001p-1, 0x1.fc0000c004000p-66, -0x1.0000000000200p-1, 0x1.ffe0000200000p-69, -0x1.0000000000100p+0, -0x1.ffdc403ff3fbcp-54},
+{0x1.00000c0000004p-1, -0x1.ff80000800000p-69, 0x1.18003ffff8000p-1, 0x1.ffffff8000000p-67, 0x1.0c0025fffc002p+0, 0x1.801fff7e00000p-67},
+{0x1.00000c0000004p-1, -0x1.ff80000800000p-69, -0x1.18003ffff8000p-1, -0x1.ffffff8000000p-67, -0x1.80033fff7ffc0p-5, -0x1.3fefffc100000p-66},
+{-0x1.00000c0000004p-1, 0x1.ff80000800000p-69, 0x1.18003ffff8000p-1, 0x1.ffffff8000000p-67, 0x1.80033fff7ffc0p-5, 0x1.3fefffc100000p-66},
+{-0x1.00000c0000004p-1, 0x1.ff80000800000p-69, -0x1.18003ffff8000p-1, -0x1.ffffff8000000p-67, -0x1.0c0025fffc002p+0, -0x1.801fff7e00000p-67},
+{0x1.1ffff80000040p-1, -0x1.0000000000000p-91, 0x1.000000000fe00p-1, 0x1.ffff7e0003ff8p-57, 0x1.0ffffc0007f20p+0, 0x1.ffff7dffc4000p-57},
+{0x1.1ffff80000040p-1, -0x1.0000000000000p-91, -0x1.000000000fe00p-1, -0x1.ffff7e0003ff8p-57, 0x1.ffff7fff023fep-5, 0x1.03ff780100000p-74},
+{-0x1.1ffff80000040p-1, 0x1.0000000000000p-91, 0x1.000000000fe00p-1, 0x1.ffff7e0003ff8p-57, -0x1.ffff7fff023fep-5, -0x1.03ff780100000p-74},
+{-0x1.1ffff80000040p-1, 0x1.0000000000000p-91, -0x1.000000000fe00p-1, -0x1.ffff7e0003ff8p-57, -0x1.0ffffc0007f20p+0, -0x1.ffff7dffc4000p-57},
+{0x1.3fc0000040000p-1, -0x1.fffffff802000p-57, 0x1.fffffffffff00p-1, 0x0.0000000000000p+0, 0x1.9fe000001ff80p+0, -0x1.fffffff802000p-57},
+{0x1.3fc0000040000p-1, -0x1.fffffff802000p-57, -0x1.fffffffffff00p-1, 0x0.0000000000000p+0, -0x1.807fffff7fe00p-2, -0x1.fffffff802000p-57},
+{-0x1.3fc0000040000p-1, 0x1.fffffff802000p-57, 0x1.fffffffffff00p-1, 0x0.0000000000000p+0, 0x1.807fffff7fe00p-2, 0x1.fffffff802000p-57},
+{-0x1.3fc0000040000p-1, 0x1.fffffff802000p-57, -0x1.fffffffffff00p-1, 0x0.0000000000000p+0, -0x1.9fe000001ff80p+0, 0x1.fffffff802000p-57},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, 0x1.0000000000200p-1, -0x1.0000000000000p-106, 0x1.0000000100100p+0, -0x1.ffffbffff8200p-54},
+{0x1.00000001fffffp-1, 0x1.00001f8000000p-72, -0x1.0000000000200p-1, 0x1.0000000000000p-106, 0x1.ffdff00002000p-33, 0x1.f804000000000p-92},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, 0x1.0000000000200p-1, -0x1.0000000000000p-106, -0x1.ffdff00002000p-33, -0x1.f804000000000p-92},
+{-0x1.00000001fffffp-1, -0x1.00001f8000000p-72, -0x1.0000000000200p-1, 0x1.0000000000000p-106, -0x1.0000000100100p+0, 0x1.ffffbffff8200p-54},
+{0x1.0000000010000p-1, -0x1.0000000000000p-78, 0x1.1fff010000000p-1, 0x1.ff8c0000007fep-55, 0x1.0fff808008000p+0, 0x1.ff8bfe0000800p-55},
+{0x1.0000000010000p-1, -0x1.0000000000000p-78, -0x1.1fff010000000p-1, -0x1.ff8c0000007fep-55, -0x1.fff00fff00008p-5, 0x1.cff7fffe00800p-65},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-78, 0x1.1fff010000000p-1, 0x1.ff8c0000007fep-55, 0x1.fff00fff00008p-5, -0x1.cff7fffe00800p-65},
+{-0x1.0000000010000p-1, 0x1.0000000000000p-78, -0x1.1fff010000000p-1, -0x1.ff8c0000007fep-55, -0x1.0fff808008000p+0, -0x1.ff8bfe0000800p-55},
+{0x1.0000000000002p-1, -0x1.0000000000000p-88, 0x1.0000000000200p-1, -0x1.0000000000000p-86, 0x1.0000000000101p+0, -0x1.4000000000000p-86},
+{0x1.0000000000002p-1, -0x1.0000000000000p-88, -0x1.0000000000200p-1, 0x1.0000000000000p-86, -0x1.fdffffffffa00p-45, 0x0.0000000000000p+0},
+{-0x1.0000000000002p-1, 0x1.0000000000000p-88, 0x1.0000000000200p-1, -0x1.0000000000000p-86, 0x1.fdffffffffa00p-45, 0x0.0000000000000p+0},
+{-0x1.0000000000002p-1, 0x1.0000000000000p-88, -0x1.0000000000200p-1, 0x1.0000000000000p-86, -0x1.0000000000101p+0, 0x1.4000000000000p-86},
+{0x1.0000000000002p-1, -0x1.ffff800008000p-68, 0x1.000000003fffep-1, 0x1.f81fc007c0000p-72, 0x1.0000000020000p+0, -0x1.e07d83ff90000p-68},
+{0x1.0000000000002p-1, -0x1.ffff800008000p-68, -0x1.000000003fffep-1, -0x1.f81fc007c0000p-72, -0x1.fffe00021f818p-36, 0x1.ffbe000000000p-91},
+{-0x1.0000000000002p-1, 0x1.ffff800008000p-68, 0x1.000000003fffep-1, 0x1.f81fc007c0000p-72, 0x1.fffe00021f818p-36, -0x1.ffbe000000000p-91},
+{-0x1.0000000000002p-1, 0x1.ffff800008000p-68, -0x1.000000003fffep-1, -0x1.f81fc007c0000p-72, -0x1.0000000020000p+0, 0x1.e07d83ff90000p-68},
+{0x1.7ffffffff0000p-1, 0x1.ffff07fffc000p-65, 0x1.000000000ffe0p-1, 0x1.ff0000003c000p-64, 0x1.3fffffffffff0p+0, 0x1.7f7fc2001d000p-63},
+{0x1.7ffffffff0000p-1, 0x1.ffff07fffc000p-65, -0x1.000000000ffe0p-1, -0x1.ff0000003c000p-64, 0x1.ffffffff80080p-3, -0x1.fe00f8007c000p-65},
+{-0x1.7ffffffff0000p-1, -0x1.ffff07fffc000p-65, 0x1.000000000ffe0p-1, 0x1.ff0000003c000p-64, -0x1.ffffffff80080p-3, 0x1.fe00f8007c000p-65},
+{-0x1.7ffffffff0000p-1, -0x1.ffff07fffc000p-65, -0x1.000000000ffe0p-1, -0x1.ff0000003c000p-64, -0x1.3fffffffffff0p+0, -0x1.7f7fc2001d000p-63},
+{0x1.00007fff00080p-1, -0x1.ffffff0001000p-66, 0x1.00000000007c0p-1, 0x1.ffffff8000000p-68, 0x1.00003fff80420p+0, -0x1.7fffff2000000p-66},
+{0x1.00007fff00080p-1, -0x1.ffffff0001000p-66, -0x1.00000000007c0p-1, -0x1.ffffff8000000p-68, 0x1.fffbfe2ffffb0p-19, 0x1.1fff000000000p-90},
+{-0x1.00007fff00080p-1, 0x1.ffffff0001000p-66, 0x1.00000000007c0p-1, 0x1.ffffff8000000p-68, -0x1.fffbfe2ffffb0p-19, -0x1.1fff000000000p-90},
+{-0x1.00007fff00080p-1, 0x1.ffffff0001000p-66, -0x1.00000000007c0p-1, -0x1.ffffff8000000p-68, -0x1.00003fff80420p+0, 0x1.7fffff2000000p-66},
+{0x1.1fff81ff00000p-1, 0x1.e007ffff00000p-58, 0x1.1ffffffff8000p-1, 0x1.fe001ffffffe0p-57, 0x1.1fffc0ff7c000p+0, 0x1.77020fffbfff0p-56},
+{0x1.1fff81ff00000p-1, 0x1.e007ffff00000p-58, -0x1.1ffffffff8000p-1, -0x1.fe001ffffffe0p-57, -0x1.f803e0000437fp-19, -0x1.0003fff000000p-76},
+{-0x1.1fff81ff00000p-1, -0x1.e007ffff00000p-58, 0x1.1ffffffff8000p-1, 0x1.fe001ffffffe0p-57, 0x1.f803e0000437fp-19, 0x1.0003fff000000p-76},
+{-0x1.1fff81ff00000p-1, -0x1.e007ffff00000p-58, -0x1.1ffffffff8000p-1, -0x1.fe001ffffffe0p-57, -0x1.1fffc0ff7c000p+0, -0x1.77020fffbfff0p-56},
+{0x1.0000000000000p-1, 0x1.fffc03fe00700p-62, 0x1.0000000000001p-1, -0x1.fff8060000f34p-56, 0x1.0000000000000p+0, 0x1.8201fa83fdc3ap-54},
+{0x1.0000000000000p-1, 0x1.fffc03fe00700p-62, -0x1.0000000000001p-1, 0x1.fff8060000f34p-56, -0x1.7e02027c01c2cp-54, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffc03fe00700p-62, 0x1.0000000000001p-1, -0x1.fff8060000f34p-56, 0x1.7e02027c01c2cp-54, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.fffc03fe00700p-62, -0x1.0000000000001p-1, 0x1.fff8060000f34p-56, -0x1.0000000000000p+0, -0x1.8201fa83fdc3ap-54},
+{0x1.001ffffc00080p-1, -0x1.fe00000200000p-62, 0x1.0000000001000p-1, -0x1.fe3ffffff0080p-61, 0x1.000ffffe00840p+0, -0x1.7ea0000078000p-60},
+{0x1.001ffffc00080p-1, -0x1.fe00000200000p-62, -0x1.0000000001000p-1, 0x1.fe3ffffff0080p-61, 0x1.ffffbff080010p-13, -0x1.8000021ff0000p-70},
+{-0x1.001ffffc00080p-1, 0x1.fe00000200000p-62, 0x1.0000000001000p-1, -0x1.fe3ffffff0080p-61, -0x1.ffffbff080010p-13, 0x1.8000021ff0000p-70},
+{-0x1.001ffffc00080p-1, 0x1.fe00000200000p-62, -0x1.0000000001000p-1, 0x1.fe3ffffff0080p-61, -0x1.000ffffe00840p+0, 0x1.7ea0000078000p-60},
+{0x1.00001fffff800p-1, 0x1.ffffff801ffc0p-60, 0x1.0000000002000p-1, -0x1.0000000000000p-106, 0x1.0000100000c00p+0, 0x1.ffffff801ff80p-60},
+{0x1.00001fffff800p-1, 0x1.ffffff801ffc0p-60, -0x1.0000000002000p-1, 0x1.0000000000000p-106, 0x1.ffffd80004000p-21, -0x1.ff80000000000p-86},
+{-0x1.00001fffff800p-1, -0x1.ffffff801ffc0p-60, 0x1.0000000002000p-1, -0x1.0000000000000p-106, -0x1.ffffd80004000p-21, 0x1.ff80000000000p-86},
+{-0x1.00001fffff800p-1, -0x1.ffffff801ffc0p-60, -0x1.0000000002000p-1, 0x1.0000000000000p-106, -0x1.0000100000c00p+0, -0x1.ffffff801ff80p-60},
+{0x1.0000000000000p-1, 0x1.ffff83ffbfff0p-57, 0x1.0000000000000p-1, 0x1.ffffffffe0000p-57, 0x1.0000000000000p+0, 0x1.ffffc1ffcfff8p-56},
+{0x1.0000000000000p-1, 0x1.ffff83ffbfff0p-57, -0x1.0000000000000p-1, -0x1.ffffffffe0000p-57, -0x1.f000800400000p-75, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ffff83ffbfff0p-57, 0x1.0000000000000p-1, 0x1.ffffffffe0000p-57, 0x1.f000800400000p-75, 0x0.0000000000000p+0},
+{-0x1.0000000000000p-1, -0x1.ffff83ffbfff0p-57, -0x1.0000000000000p-1, -0x1.ffffffffe0000p-57, -0x1.0000000000000p+0, -0x1.ffffc1ffcfff8p-56},
+{0x1.0000000000000p-1, 0x1.fffe7ff3dff00p-62, 0x1.000007f830000p-1, 0x1.fff0000ffe100p-62, 0x1.000003fc18000p+0, 0x1.fff74001ef000p-61},
+{0x1.0000000000000p-1, 0x1.fffe7ff3dff00p-62, -0x1.000007f830000p-1, -0x1.fff0000ffe100p-62, -0x1.fe0bffffffffep-23, -0x1.801c1e2000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffe7ff3dff00p-62, 0x1.000007f830000p-1, 0x1.fff0000ffe100p-62, 0x1.fe0bffffffffep-23, 0x1.801c1e2000000p-78},
+{-0x1.0000000000000p-1, -0x1.fffe7ff3dff00p-62, -0x1.000007f830000p-1, -0x1.fff0000ffe100p-62, -0x1.000003fc18000p+0, -0x1.fff74001ef000p-61},
+{0x1.00000ffffe000p-1, 0x1.fffffffffc000p-68, 0x1.0000000000002p-1, -0x1.fffffe01f8004p-56, 0x1.000007ffff001p+0, -0x1.ffdffe01f8008p-56},
+{0x1.00000ffffe000p-1, 0x1.fffffffffc000p-68, -0x1.0000000000002p-1, 0x1.fffffe01f8004p-56, 0x1.ffffbffc80080p-22, -0x1.fe08000000000p-80},
+{-0x1.00000ffffe000p-1, -0x1.fffffffffc000p-68, 0x1.0000000000002p-1, -0x1.fffffe01f8004p-56, -0x1.ffffbffc80080p-22, 0x1.fe08000000000p-80},
+{-0x1.00000ffffe000p-1, -0x1.fffffffffc000p-68, -0x1.0000000000002p-1, 0x1.fffffe01f8004p-56, -0x1.000007ffff001p+0, 0x1.ffdffe01f8008p-56},
+{0x1.0000000000060p-1, 0x1.fffe3fff00000p-64, 0x1.0000000002000p-1, -0x1.ffe0002000000p-58, 0x1.0000000001030p+0, -0x1.f7e0072004000p-58},
+{0x1.0000000000060p-1, 0x1.fffe3fff00000p-64, -0x1.0000000002000p-1, 0x1.ffe0002000000p-58, -0x1.f9fefc1003700p-41, -0x1.0000000000000p-96},
+{-0x1.0000000000060p-1, -0x1.fffe3fff00000p-64, 0x1.0000000002000p-1, -0x1.ffe0002000000p-58, 0x1.f9fefc1003700p-41, 0x1.0000000000000p-96},
+{-0x1.0000000000060p-1, -0x1.fffe3fff00000p-64, -0x1.0000000002000p-1, 0x1.ffe0002000000p-58, -0x1.0000000001030p+0, 0x1.f7e0072004000p-58},
+{0x1.0003ffffffff8p-1, 0x1.ffffe07e00000p-75, 0x1.07ff000008000p-1, -0x1.e000020000000p-62, 0x1.0401800003ffcp+0, -0x1.dff00200fc000p-62},
+{0x1.0003ffffffff8p-1, 0x1.ffffe07e00000p-75, -0x1.07ff000008000p-1, 0x1.e000020000000p-62, -0x1.fec0000200200p-7, 0x1.e01001ff03f00p-62},
+{-0x1.0003ffffffff8p-1, -0x1.ffffe07e00000p-75, 0x1.07ff000008000p-1, -0x1.e000020000000p-62, 0x1.fec0000200200p-7, -0x1.e01001ff03f00p-62},
+{-0x1.0003ffffffff8p-1, -0x1.ffffe07e00000p-75, -0x1.07ff000008000p-1, 0x1.e000020000000p-62, -0x1.0401800003ffcp+0, 0x1.dff00200fc000p-62},
+};
+
+const int numAccuracyTests = sizeof(accuracyTests) / sizeof(struct testVector);
+
+#include <math.h>
+
+double testAccuracy() {
+	int i;
+	DD a, b, c, r;
+	
+	double worstUlps = 0.5;
+	
+	for (i=0; i<numAccuracyTests; ++i) {
+		a.hi = accuracyTests[i].xhi;
+		a.lo = accuracyTests[i].xlo;
+		b.hi = -accuracyTests[i].yhi;
+		b.lo = -accuracyTests[i].ylo;
+		r.hi = accuracyTests[i].rhi;
+		r.lo = accuracyTests[i].rlo;
+		
+		DD c = { .ld = __gcc_qsub(a.ld, b.ld) };
+		
+		double error = __builtin_fabs(((r.hi - c.hi) + r.lo) - c.lo);
+		
+		if (error != 0.0) {
+		
+			int exponent = ilogb(r.hi);
+			exponent = (exponent < -1022 ? -1022 : exponent);
+			double ulpError = scalbn(error, 106 - exponent);
+		
+			if (ulpError > worstUlps) {
+#ifdef PRINT_ACCURACY_INFORMATION
+				printf("New worst rounding error for (%a,%a) + (%a,%a):\n", a.hi, a.lo, b.hi, b.lo);
+				printf("\tExpected: (%a,%a)\n", r.hi, r.lo);
+				printf("\tComputed: (%a,%a)\n", c.hi, c.lo);
+				printf("\tError: %f ulps\n", ulpError);
+#endif
+				worstUlps = ulpError;
+			}
+		}
+	}
+	
+	return worstUlps;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/compiler-rt/test/builtins/Unit/ppc/test b/compiler-rt/test/builtins/Unit/ppc/test
new file mode 100755
index 0000000..96e0632
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ppc/test
@@ -0,0 +1,18 @@
+for FILE in $(ls *.c); do
+	if gcc -arch ppc -O0 $FILE ../../../Release/ppc/libcompiler_rt.Optimized.a -mlong-double-128
+	then
+	    echo "Testing $FILE"
+		if ./a.out
+		then
+			rm ./a.out
+		else
+			echo "fail"
+# 			exit 1
+		fi
+	else
+		echo "$FILE failed to compile"
+#		exit 1
+	fi
+done
+echo "pass"
+exit
diff --git a/compiler-rt/test/builtins/Unit/subdf3vfp_test.c b/compiler-rt/test/builtins/Unit/subdf3vfp_test.c
new file mode 100644
index 0000000..5d5d711
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/subdf3vfp_test.c
@@ -0,0 +1,48 @@
+//===-- subdf3vfp_test.c - Test __subdf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subdf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern COMPILER_RT_ABI double __subdf3vfp(double a, double b);
+
+int test__subdf3vfp(double a, double b)
+{
+    double actual = __subdf3vfp(a, b);
+    double expected = a - b;
+    if (actual != expected)
+        printf("error in test__subdf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__subdf3vfp(1.0, 1.0))
+        return 1;
+    if (test__subdf3vfp(1234.567, 765.4321))
+        return 1;
+    if (test__subdf3vfp(-123.0, -678.0))
+        return 1;
+    if (test__subdf3vfp(0.0, -0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/subsf3vfp_test.c b/compiler-rt/test/builtins/Unit/subsf3vfp_test.c
new file mode 100644
index 0000000..fe60058
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/subsf3vfp_test.c
@@ -0,0 +1,49 @@
+//===-- subsf3vfp_test.c - Test __subsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __subsf3vfp(float a, float b);
+
+#if __arm__
+int test__subsf3vfp(float a, float b)
+{
+    float actual = __subsf3vfp(a, b);
+    float expected = a - b;
+    if (actual != expected)
+        printf("error in test__subsf3vfp(%f, %f) = %f, expected %f\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__subsf3vfp(1.0, 1.0))
+        return 1;
+    if (test__subsf3vfp(1234.567, 765.4321))
+        return 1;
+    if (test__subsf3vfp(-123.0, -678.0))
+        return 1;
+    if (test__subsf3vfp(0.0, -0.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/subtf3_test.c b/compiler-rt/test/builtins/Unit/subtf3_test.c
new file mode 100644
index 0000000..ad115a4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/subtf3_test.c
@@ -0,0 +1,74 @@
+//===--------------- subtf3_test.c - Test __subtf3 ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subtf3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: a - b
+COMPILER_RT_ABI long double __subtf3(long double a, long double b);
+
+int test__subtf3(long double a, long double b,
+                 uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __subtf3(a, b);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__subtf3(%.20Lf, %.20Lf) = %.20Lf, "
+               "expected %.20Lf\n", a, b, x,
+               fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN - any = qNaN
+    if (test__subtf3(makeQNaN128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // NaN - any = NaN
+    if (test__subtf3(makeNaN128(UINT64_C(0x800030000000)),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf - any = inf
+    if (test__subtf3(makeInf128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any - any
+    if (test__subtf3(0x1.234567829a3bcdef5678ade36734p+5L,
+                     0x1.ee9d7c52354a6936ab8d7654321fp-1L,
+                     UINT64_C(0x40041b8af1915166),
+                     UINT64_C(0xa44a7bca780a166c)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/subvdi3_test.c b/compiler-rt/test/builtins/Unit/subvdi3_test.c
new file mode 100644
index 0000000..96e825c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/subvdi3_test.c
@@ -0,0 +1,60 @@
+//===-- subvdi3_test.c - Test __subvdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subvdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: a - b
+
+// Effects: aborts if a - b overflows
+
+COMPILER_RT_ABI di_int __subvdi3(di_int a, di_int b);
+
+int test__subvdi3(di_int a, di_int b)
+{
+    di_int x = __subvdi3(a, b);
+    di_int expected = a - b;
+    if (x != expected)
+        printf("error in test__subvsi3(0x%llX, 0x%llX) = %lld, expected %lld\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     test__subvdi3(0x8000000000000000LL, 1);  // should abort
+//     test__subvdi3(0, 0x8000000000000000LL);  // should abort
+//     test__subvdi3(1, 0x8000000000000000LL);  // should abort
+//     test__subvdi3(0x7FFFFFFFFFFFFFFFLL, -1);  // should abort
+//     test__subvdi3(-2, 0x7FFFFFFFFFFFFFFFLL);  // should abort
+
+    if (test__subvdi3(0x8000000000000000LL, -1))
+        return 1;
+    if (test__subvdi3(0x8000000000000000LL, 0))
+        return 1;
+    if (test__subvdi3(-1, 0x8000000000000000LL))
+        return 1;
+    if (test__subvdi3(0x7FFFFFFFFFFFFFFLL, 1))
+        return 1;
+    if (test__subvdi3(0x7FFFFFFFFFFFFFFFLL, 0))
+        return 1;
+    if (test__subvdi3(1, 0x7FFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__subvdi3(0, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+    if (test__subvdi3(-1, 0x7FFFFFFFFFFFFFFFLL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/subvsi3_test.c b/compiler-rt/test/builtins/Unit/subvsi3_test.c
new file mode 100644
index 0000000..03ef504
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/subvsi3_test.c
@@ -0,0 +1,60 @@
+//===-- subvsi3_test.c - Test __subvsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subvsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: a - b
+
+// Effects: aborts if a - b overflows
+
+COMPILER_RT_ABI si_int __subvsi3(si_int a, si_int b);
+
+int test__subvsi3(si_int a, si_int b)
+{
+    si_int x = __subvsi3(a, b);
+    si_int expected = a - b;
+    if (x != expected)
+        printf("error in test__subvsi3(0x%X, 0x%X) = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+//     test__subvsi3(0x80000000, 1);  // should abort
+//     test__subvsi3(0, 0x80000000);  // should abort
+//     test__subvsi3(1, 0x80000000);  // should abort
+//     test__subvsi3(0x7FFFFFFF, -1);  // should abort
+//     test__subvsi3(-2, 0x7FFFFFFF);  // should abort
+
+    if (test__subvsi3(0x80000000, -1))
+        return 1;
+    if (test__subvsi3(0x80000000, 0))
+        return 1;
+    if (test__subvsi3(-1, 0x80000000))
+        return 1;
+    if (test__subvsi3(0x7FFFFFFF, 1))
+        return 1;
+    if (test__subvsi3(0x7FFFFFFF, 0))
+        return 1;
+    if (test__subvsi3(1, 0x7FFFFFFF))
+        return 1;
+    if (test__subvsi3(0, 0x7FFFFFFF))
+        return 1;
+    if (test__subvsi3(-1, 0x7FFFFFFF))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/subvti3_test.c b/compiler-rt/test/builtins/Unit/subvti3_test.c
new file mode 100644
index 0000000..40eb518
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/subvti3_test.c
@@ -0,0 +1,80 @@
+//===-- subvti3_test.c - Test __subvti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subvti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a - b
+
+// Effects: aborts if a - b overflows
+
+COMPILER_RT_ABI ti_int __subvti3(ti_int a, ti_int b);
+
+int test__subvti3(ti_int a, ti_int b)
+{
+    ti_int x = __subvti3(a, b);
+    ti_int expected = a - b;
+    if (x != expected)
+    {
+        twords at;
+        at.all = a;
+        twords bt;
+        bt.all = b;
+        twords xt;
+        xt.all = x;
+        twords expectedt;
+        expectedt.all = expected;
+        printf("error in test__subvsi3(0x%.16llX%.16llX, 0x%.16llX%.16llX) = "
+               "0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, xt.s.high, xt.s.low,
+               expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+//     test__subvti3(make_ti(0x8000000000000000LL, 0), 1);  // should abort
+//     test__subvti3(0, make_ti(0x8000000000000000LL, 0));  // should abort
+//     test__subvti3(1, make_ti(0x8000000000000000LL, 0));  // should abort
+//     test__subvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), -1);  // should abort
+//     test__subvti3(-2, make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL));  // should abort
+
+    if (test__subvti3(make_ti(0x8000000000000000LL, 0), -1))
+        return 1;
+    if (test__subvti3(make_ti(0x8000000000000000LL, 0), 0))
+        return 1;
+    if (test__subvti3(-1, make_ti(0x8000000000000000LL, 0)))
+        return 1;
+    if (test__subvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), 1))
+        return 1;
+    if (test__subvti3(make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL), 0))
+        return 1;
+    if (test__subvti3(1, make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__subvti3(0, make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+    if (test__subvti3(-1, make_ti(0x7FFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/test b/compiler-rt/test/builtins/Unit/test
new file mode 100755
index 0000000..e2a39a9
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/test
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+ARCHS='<host>'
+REMOTE=0
+if test `uname` = "Darwin"; then
+  if test "$1" = "armv6"; then
+    ARCHS="armv6"
+    LIBS="-lSystem"
+    REMOTE=1
+    mkdir -p remote
+  else
+    ARCHS="i386 x86_64 ppc"
+    LIBS="-lSystem"
+  fi
+else
+  LIBS="-lc -lm"
+fi
+
+for ARCH in $ARCHS; do
+  CFLAGS="-Os -nodefaultlibs -I../../lib"
+  if test "$ARCH" != '<host>'; then
+    CFLAGS="-arch $ARCH $CFLAGS"
+  fi
+  for FILE in $(ls *.c); do
+    # Use -nodefaultlibs to avoid using libgcc.a
+    # Use -lSystem to link with libSystem.dylb.
+    # Note -lSystem is *after* libcompiler_rt.Optimized.a so that linker will 
+    # prefer our implementation over the ones in libSystem.dylib
+    EXTRA=
+    if test $FILE = gcc_personality_test.c
+    then
+      # the gcc_personality_test.c requires a helper C++ program
+      EXTRA="-fexceptions gcc_personality_test_helper.cxx -lstdc++ /usr/lib/libgcc_s.1.dylib"
+      # the libgcc_s.1.dylib use at the end is a hack until libSystem contains _Unwind_Resume
+    fi
+    if test $FILE = trampoline_setup_test.c
+    then
+      # this test requires an extra compiler option
+      EXTRA="-fnested-functions"
+    fi
+    if test "$REMOTE" = "1"
+    then 
+      if gcc $CFLAGS $FILE ../../darwin_fat/Release/libcompiler_rt.a $LIBS $EXTRA -o ./remote/$FILE.exe
+      then
+        echo "Built $FILE.exe for $ARCH"
+      else
+        echo "$FILE failed to compile"
+      fi
+    else
+      if gcc $CFLAGS $FILE ../../darwin_fat/Release/libcompiler_rt.a $LIBS $EXTRA
+      then
+        echo "Testing $FILE for $ARCH"
+        if ./a.out
+        then
+          rm ./a.out
+        else
+          echo "fail"
+          exit 1
+        fi
+      else
+        echo "$FILE failed to compile"
+        exit 1
+      fi
+    fi
+  done
+done
+echo "pass"
+exit
diff --git a/compiler-rt/test/builtins/Unit/trampoline_setup_test.c b/compiler-rt/test/builtins/Unit/trampoline_setup_test.c
new file mode 100644
index 0000000..dc30fb6
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/trampoline_setup_test.c
@@ -0,0 +1,64 @@
+/* ===-- trampoline_setup_test.c - Test __trampoline_setup -----------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <sys/mman.h>
+
+/*
+ * Tests nested functions
+ * The ppc compiler generates a call to __trampoline_setup
+ * The i386 and x86_64 compilers generate a call to ___enable_execute_stack
+ */
+
+/*
+ * Note that, nested functions are not ISO C and are not supported in Clang.
+ */
+
+#if !defined(__clang__)
+
+typedef int (*nested_func_t)(int x);
+
+nested_func_t proc;
+
+int main() {
+    /* Some locals */
+    int c = 10;
+    int d = 7;
+    
+    /* Define a nested function: */
+    int bar(int x) { return x*5 + c*d; };
+
+    /* Assign global to point to nested function
+     * (really points to trampoline). */
+    proc = bar;
+    
+    /* Invoke nested function: */
+    c = 4;
+    if ( (*proc)(3) != 43 )
+        return 1;
+    d = 5;
+    if ( (*proc)(4) != 40 )
+        return 1;
+
+    /* Success. */
+    return 0;
+}
+
+#else
+
+int main() {
+    printf("skipped\n");
+    return 0;
+}
+
+#endif
diff --git a/compiler-rt/test/builtins/Unit/truncdfhf2_test.c b/compiler-rt/test/builtins/Unit/truncdfhf2_test.c
new file mode 100644
index 0000000..6627a00
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/truncdfhf2_test.c
@@ -0,0 +1,114 @@
+//===--------------- truncdfhf2_test.c - Test __truncdfhf2 ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __truncdfhf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#include "fp_test.h"
+
+uint16_t __truncdfhf2(double a);
+
+int test__truncdfhf2(double a, uint16_t expected)
+{
+    uint16_t x = __truncdfhf2(a);
+    int ret = compareResultH(x, expected);
+
+    if (ret){
+        printf("error in test__truncdfhf2(%f) = %#.4x, "
+               "expected %#.4x\n", a, x, fromRep16(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
+
+int main()
+{
+    // qNaN
+    if (test__truncdfhf2(makeQNaN64(),
+                         UINT16_C(0x7e00)))
+        return 1;
+    // NaN
+    if (test__truncdfhf2(makeNaN64(UINT64_C(0x8000)),
+                         UINT16_C(0x7e00)))
+        return 1;
+    // inf
+    if (test__truncdfhf2(makeInf64(),
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncdfhf2(-makeInf64(),
+                         UINT16_C(0xfc00)))
+        return 1;
+    // zero
+    if (test__truncdfhf2(0.0, UINT16_C(0x0)))
+        return 1;
+    if (test__truncdfhf2(-0.0, UINT16_C(0x8000)))
+        return 1;
+
+    if (test__truncdfhf2(3.1415926535,
+                         UINT16_C(0x4248)))
+        return 1;
+    if (test__truncdfhf2(-3.1415926535,
+                         UINT16_C(0xc248)))
+        return 1;
+    if (test__truncdfhf2(0x1.987124876876324p+1000,
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncdfhf2(0x1.987124876876324p+12,
+                         UINT16_C(0x6e62)))
+        return 1;
+    if (test__truncdfhf2(0x1.0p+0,
+                         UINT16_C(0x3c00)))
+        return 1;
+    if (test__truncdfhf2(0x1.0p-14,
+                         UINT16_C(0x0400)))
+        return 1;
+    // denormal
+    if (test__truncdfhf2(0x1.0p-20,
+                         UINT16_C(0x0010)))
+        return 1;
+    if (test__truncdfhf2(0x1.0p-24,
+                         UINT16_C(0x0001)))
+        return 1;
+    if (test__truncdfhf2(-0x1.0p-24,
+                         UINT16_C(0x8001)))
+        return 1;
+    if (test__truncdfhf2(0x1.5p-25,
+                         UINT16_C(0x0001)))
+        return 1;
+    // and back to zero
+    if (test__truncdfhf2(0x1.0p-25,
+                         UINT16_C(0x0000)))
+        return 1;
+    if (test__truncdfhf2(-0x1.0p-25,
+                         UINT16_C(0x8000)))
+        return 1;
+    // max (precise)
+    if (test__truncdfhf2(65504.0,
+                         UINT16_C(0x7bff)))
+        return 1;
+    // max (rounded)
+    if (test__truncdfhf2(65519.0,
+                         UINT16_C(0x7bff)))
+        return 1;
+    // max (to +inf)
+    if (test__truncdfhf2(65520.0,
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncdfhf2(-65520.0,
+                         UINT16_C(0xfc00)))
+        return 1;
+    if (test__truncdfhf2(65536.0,
+                         UINT16_C(0x7c00)))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/truncdfsf2_test.c b/compiler-rt/test/builtins/Unit/truncdfsf2_test.c
new file mode 100644
index 0000000..a208a3a
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/truncdfsf2_test.c
@@ -0,0 +1,38 @@
+//===--------------- truncdfsf2_test.c - Test __truncdfsf2 ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __truncdfsf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#include "fp_test.h"
+
+float __truncdfsf2(double a);
+
+int test__truncdfsf2(double a)
+{
+    float actual = __truncdfsf2(a);
+    float expected = a;
+
+    if (actual != expected) {
+        printf("error in test__truncdfsf2(%lf) = %f, "
+               "expected %f\n", a, actual, expected);
+        return 1;
+    }
+    return 0;
+}
+
+int main()
+{
+    if (test__truncdfsf2(340282366920938463463374607431768211456.0))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/truncdfsf2vfp_test.c b/compiler-rt/test/builtins/Unit/truncdfsf2vfp_test.c
new file mode 100644
index 0000000..eaeda65
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/truncdfsf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- truncdfsf2vfp_test.c - Test __truncdfsf2vfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __truncdfsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern COMPILER_RT_ABI float __truncdfsf2vfp(double a);
+
+#if __arm__
+int test__truncdfsf2vfp(double a)
+{
+    float actual = __truncdfsf2vfp(a);
+    float expected = a;
+    if (actual != expected)
+        printf("error in test__truncdfsf2vfp(%f) = %f, expected %f\n",
+               a, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__truncdfsf2vfp(0.0))
+        return 1;
+    if (test__truncdfsf2vfp(1.0))
+        return 1;
+    if (test__truncdfsf2vfp(-1.0))
+        return 1;
+    if (test__truncdfsf2vfp(3.1415926535))
+        return 1;
+    if (test__truncdfsf2vfp(123.456))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/truncsfhf2_test.c b/compiler-rt/test/builtins/Unit/truncsfhf2_test.c
new file mode 100644
index 0000000..5bc3c8e
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/truncsfhf2_test.c
@@ -0,0 +1,114 @@
+//===--------------- truncsfhf2_test.c - Test __truncsfhf2 ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __truncsfhf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#include "fp_test.h"
+
+uint16_t __truncsfhf2(float a);
+
+int test__truncsfhf2(float a, uint16_t expected)
+{
+    uint16_t x = __truncsfhf2(a);
+    int ret = compareResultH(x, expected);
+
+    if (ret){
+        printf("error in test__truncsfhf2(%f) = %#.4x, "
+               "expected %#.4x\n", a, x, fromRep16(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
+
+int main()
+{
+    // qNaN
+    if (test__truncsfhf2(makeQNaN32(),
+                         UINT16_C(0x7e00)))
+        return 1;
+    // NaN
+    if (test__truncsfhf2(makeNaN32(UINT32_C(0x8000)),
+                         UINT16_C(0x7e00)))
+        return 1;
+    // inf
+    if (test__truncsfhf2(makeInf32(),
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncsfhf2(-makeInf32(),
+                         UINT16_C(0xfc00)))
+        return 1;
+    // zero
+    if (test__truncsfhf2(0.0f, UINT16_C(0x0)))
+        return 1;
+    if (test__truncsfhf2(-0.0f, UINT16_C(0x8000)))
+        return 1;
+
+    if (test__truncsfhf2(3.1415926535f,
+                         UINT16_C(0x4248)))
+        return 1;
+    if (test__truncsfhf2(-3.1415926535f,
+                         UINT16_C(0xc248)))
+        return 1;
+    if (test__truncsfhf2(0x1.987124876876324p+100f,
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncsfhf2(0x1.987124876876324p+12f,
+                         UINT16_C(0x6e62)))
+        return 1;
+    if (test__truncsfhf2(0x1.0p+0f,
+                         UINT16_C(0x3c00)))
+        return 1;
+    if (test__truncsfhf2(0x1.0p-14f,
+                         UINT16_C(0x0400)))
+        return 1;
+    // denormal
+    if (test__truncsfhf2(0x1.0p-20f,
+                         UINT16_C(0x0010)))
+        return 1;
+    if (test__truncsfhf2(0x1.0p-24f,
+                         UINT16_C(0x0001)))
+        return 1;
+    if (test__truncsfhf2(-0x1.0p-24f,
+                         UINT16_C(0x8001)))
+        return 1;
+    if (test__truncsfhf2(0x1.5p-25f,
+                         UINT16_C(0x0001)))
+        return 1;
+    // and back to zero
+    if (test__truncsfhf2(0x1.0p-25f,
+                         UINT16_C(0x0000)))
+        return 1;
+    if (test__truncsfhf2(-0x1.0p-25f,
+                         UINT16_C(0x8000)))
+        return 1;
+    // max (precise)
+    if (test__truncsfhf2(65504.0f,
+                         UINT16_C(0x7bff)))
+        return 1;
+    // max (rounded)
+    if (test__truncsfhf2(65519.0f,
+                         UINT16_C(0x7bff)))
+        return 1;
+    // max (to +inf)
+    if (test__truncsfhf2(65520.0f,
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncsfhf2(65536.0f,
+                         UINT16_C(0x7c00)))
+        return 1;
+    if (test__truncsfhf2(-65520.0f,
+                         UINT16_C(0xfc00)))
+        return 1;
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/trunctfdf2_test.c b/compiler-rt/test/builtins/Unit/trunctfdf2_test.c
new file mode 100644
index 0000000..0366a8c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/trunctfdf2_test.c
@@ -0,0 +1,77 @@
+//===-------------- trunctfdf2_test.c - Test __trunctfdf2 -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __trunctfdf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI double __trunctfdf2(long double a);
+
+int test__trunctfdf2(long double a, uint64_t expected)
+{
+    double x = __trunctfdf2(a);
+    int ret = compareResultD(x, expected);
+
+    if (ret)
+    {
+        printf("error in test__trunctfdf2(%.20Lf) = %lf, "
+               "expected %lf\n", a, x, fromRep64(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN
+    if (test__trunctfdf2(makeQNaN128(),
+                         UINT64_C(0x7ff8000000000000)))
+        return 1;
+    // NaN
+    if (test__trunctfdf2(makeNaN128(UINT64_C(0x810000000000)),
+                         UINT64_C(0x7ff8100000000000)))
+        return 1;
+    // inf
+    if (test__trunctfdf2(makeInf128(),
+                         UINT64_C(0x7ff0000000000000)))
+        return 1;
+    // zero
+    if (test__trunctfdf2(0.0L, UINT64_C(0x0)))
+        return 1;
+
+    if (test__trunctfdf2(0x1.af23456789bbaaab347645365cdep+5L,
+                         UINT64_C(0x404af23456789bbb)))
+        return 1;
+    if (test__trunctfdf2(0x1.dedafcff354b6ae9758763545432p-9L,
+                         UINT64_C(0x3f6dedafcff354b7)))
+        return 1;
+    if (test__trunctfdf2(0x1.2f34dd5f437e849b4baab754cdefp+4534L,
+                         UINT64_C(0x7ff0000000000000)))
+        return 1;
+    if (test__trunctfdf2(0x1.edcbff8ad76ab5bf46463233214fp-435L,
+                         UINT64_C(0x24cedcbff8ad76ab)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/trunctfsf2_test.c b/compiler-rt/test/builtins/Unit/trunctfsf2_test.c
new file mode 100644
index 0000000..a6b922c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/trunctfsf2_test.c
@@ -0,0 +1,76 @@
+//===--------------- trunctfsf2_test.c - Test __trunctfsf2 ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __trunctfsf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI float __trunctfsf2(long double a);
+
+int test__trunctfsf2(long double a, uint32_t expected)
+{
+    float x = __trunctfsf2(a);
+    int ret = compareResultF(x, expected);
+
+    if (ret){
+        printf("error in test__trunctfsf2(%.20Lf) = %f, "
+               "expected %f\n", a, x, fromRep32(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN
+    if (test__trunctfsf2(makeQNaN128(),
+                         UINT32_C(0x7fc00000)))
+        return 1;
+    // NaN
+    if (test__trunctfsf2(makeNaN128(UINT64_C(0x810000000000)),
+                         UINT32_C(0x7fc08000)))
+        return 1;
+    // inf
+    if (test__trunctfsf2(makeInf128(),
+                         UINT32_C(0x7f800000)))
+        return 1;
+    // zero
+    if (test__trunctfsf2(0.0L, UINT32_C(0x0)))
+        return 1;
+
+    if (test__trunctfsf2(0x1.23a2abb4a2ddee355f36789abcdep+5L,
+                         UINT32_C(0x4211d156)))
+        return 1;
+    if (test__trunctfsf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9L,
+                         UINT32_C(0x3b71e9e2)))
+        return 1;
+    if (test__trunctfsf2(0x1.234eebb5faa678f4488693abcdefp+4534L,
+                         UINT32_C(0x7f800000)))
+        return 1;
+    if (test__trunctfsf2(0x1.edcba9bb8c76a5a43dd21f334634p-435L,
+                         UINT32_C(0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ucmpdi2_test.c b/compiler-rt/test/builtins/Unit/ucmpdi2_test.c
new file mode 100644
index 0000000..65ae4fc
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ucmpdi2_test.c
@@ -0,0 +1,75 @@
+//===-- ucmpdi2_test.c - Test __ucmpdi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ucmpdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns:  if (a <  b) returns 0
+//           if (a == b) returns 1
+//           if (a >  b) returns 2
+
+COMPILER_RT_ABI si_int __ucmpdi2(du_int a, du_int b);
+
+int test__ucmpdi2(du_int a, du_int b, si_int expected)
+{
+    si_int x = __ucmpdi2(a, b);
+    if (x != expected)
+        printf("error in __ucmpdi2(0x%llX, 0x%llX) = %d, expected %d\n",
+               a, b, x, expected);
+    return x != expected;
+}
+
+int main()
+{
+    if (test__ucmpdi2(0, 0, 1))
+        return 1;
+    if (test__ucmpdi2(1, 1, 1))
+        return 1;
+    if (test__ucmpdi2(2, 2, 1))
+        return 1;
+    if (test__ucmpdi2(0x7FFFFFFF, 0x7FFFFFFF, 1))
+        return 1;
+    if (test__ucmpdi2(0x80000000, 0x80000000, 1))
+        return 1;
+    if (test__ucmpdi2(0x80000001, 0x80000001, 1))
+        return 1;
+    if (test__ucmpdi2(0xFFFFFFFF, 0xFFFFFFFF, 1))
+        return 1;
+    if (test__ucmpdi2(0x000000010000000LL, 0x000000010000000LL, 1))
+        return 1;
+    if (test__ucmpdi2(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL, 1))
+        return 1;
+
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000300000001LL, 0))
+        return 1;
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000300000002LL, 0))
+        return 1;
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000300000003LL, 0))
+        return 1;
+
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000100000001LL, 2))
+        return 1;
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000100000002LL, 2))
+        return 1;
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000100000003LL, 2))
+        return 1;
+
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000200000001LL, 2))
+        return 1;
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000200000002LL, 1))
+        return 1;
+    if (test__ucmpdi2(0x0000000200000002LL, 0x0000000200000003LL, 0))
+        return 1;
+
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/ucmpti2_test.c b/compiler-rt/test/builtins/Unit/ucmpti2_test.c
new file mode 100644
index 0000000..826cd64
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/ucmpti2_test.c
@@ -0,0 +1,116 @@
+//===-- ucmpti2_test.c - Test __ucmpti2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ucmpti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns:  if (a <  b) returns 0
+//           if (a == b) returns 1
+//           if (a >  b) returns 2
+
+COMPILER_RT_ABI si_int __ucmpti2(tu_int a, tu_int b);
+
+int test__ucmpti2(tu_int a, tu_int b, si_int expected)
+{
+    si_int x = __ucmpti2(a, b);
+    if (x != expected)
+    {
+        utwords at;
+        at.all = a;
+        utwords bt;
+        bt.all = b;
+        printf("error in __ucmpti2(0x%.16llX%.16llX, 0x%.16llX%.16llX) = %d, "
+               "expected %d\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, x, expected);
+    }
+    return x != expected;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__ucmpti2(0, 0, 1))
+        return 1;
+    if (test__ucmpti2(1, 1, 1))
+        return 1;
+    if (test__ucmpti2(2, 2, 1))
+        return 1;
+    if (test__ucmpti2(0x7FFFFFFF, 0x7FFFFFFF, 1))
+        return 1;
+    if (test__ucmpti2(0x80000000, 0x80000000, 1))
+        return 1;
+    if (test__ucmpti2(0x80000001, 0x80000001, 1))
+        return 1;
+    if (test__ucmpti2(0xFFFFFFFF, 0xFFFFFFFF, 1))
+        return 1;
+    if (test__ucmpti2(0x000000010000000LL, 0x000000010000000LL, 1))
+        return 1;
+    if (test__ucmpti2(0xFFFFFFFFFFFFFFFFLL, 0xFFFFFFFFFFFFFFFFLL, 1))
+        return 1;
+
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000300000001LL, 0))
+        return 1;
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000300000002LL, 0))
+        return 1;
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000300000003LL, 0))
+        return 1;
+
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000100000001LL, 2))
+        return 1;
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000100000002LL, 2))
+        return 1;
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000100000003LL, 2))
+        return 1;
+
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000200000001LL, 2))
+        return 1;
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000200000002LL, 1))
+        return 1;
+    if (test__ucmpti2(0x0000000200000002LL, 0x0000000200000003LL, 0))
+        return 1;
+
+    if (test__ucmpti2(make_tu(0x0000000000000001uLL, 0x0000000000000000uLL),
+                      make_tu(0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFFuLL), 2))
+        return 1;
+    if (test__ucmpti2(make_tu(0x0000000000000001uLL, 0x0000000000000000uLL),
+                      make_tu(0x0000000000000001uLL, 0x0000000000000000uLL), 1))
+        return 1;
+    if (test__ucmpti2(make_tu(0x0000000000000001uLL, 0x0000000000000000uLL),
+                      make_tu(0x0000000000000001uLL, 0x0000000000000001uLL), 0))
+        return 1;
+
+    if (test__ucmpti2(make_tu(0x8000000000000000uLL, 0x0000000000000000uLL),
+                      make_tu(0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL), 2))
+        return 1;
+    if (test__ucmpti2(make_tu(0x8000000000000000uLL, 0x0000000000000000uLL),
+                      make_tu(0x8000000000000000uLL, 0x0000000000000000uLL), 1))
+        return 1;
+    if (test__ucmpti2(make_tu(0x8000000000000000uLL, 0x0000000000000000uLL),
+                      make_tu(0x8000000000000000uLL, 0x0000000000000001uLL), 0))
+        return 1;
+
+    if (test__ucmpti2(make_tu(0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL),
+                      make_tu(0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL), 2))
+        return 1;
+    if (test__ucmpti2(make_tu(0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL),
+                      make_tu(0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL), 1))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/udivdi3_test.c b/compiler-rt/test/builtins/Unit/udivdi3_test.c
new file mode 100644
index 0000000..48c99e3
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/udivdi3_test.c
@@ -0,0 +1,44 @@
+//===-- udivdi3_test.c - Test __udivdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+COMPILER_RT_ABI du_int __udivdi3(du_int a, du_int b);
+
+int test__udivdi3(du_int a, du_int b, du_int expected_q)
+{
+    du_int q = __udivdi3(a, b);
+    if (q != expected_q)
+        printf("error in __udivdi3: %lld / %lld = %lld, expected %lld\n",
+               a, b, q, expected_q);
+    return q != expected_q;
+}
+
+int main()
+{
+    if (test__udivdi3(0, 1, 0))
+        return 1;
+    if (test__udivdi3(2, 1, 2))
+        return 1;
+    if (test__udivdi3(0x8000000000000000uLL, 1, 0x8000000000000000uLL))
+        return 1;
+    if (test__udivdi3(0x8000000000000000uLL, 2, 0x4000000000000000uLL))
+        return 1;
+    if (test__udivdi3(0xFFFFFFFFFFFFFFFFuLL, 2, 0x7FFFFFFFFFFFFFFFuLL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/udivmoddi4_test.c b/compiler-rt/test/builtins/Unit/udivmoddi4_test.c
new file mode 100644
index 0000000..79af1ee
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/udivmoddi4_test.c
@@ -0,0 +1,20639 @@
+//===-- udivmoddi4_test.c - Test __udivmoddi4 -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivmoddi4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Effects: if rem != 0, *rem = a % b
+// Returns: a / b
+
+COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+
+int test__udivmoddi4(du_int a, du_int b, du_int expected_q, du_int expected_r)
+{
+    du_int r;
+    du_int q = __udivmoddi4(a, b, &r);
+    if (q != expected_q || r != expected_r)
+        printf("error in __udivmoddi4: %llX / %llX = %llX, R = %llX, expected %llX, %llX\n",
+               a, b, q, r, expected_q, expected_r);
+    return !(q == expected_q && r == expected_r);
+}
+
+char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
+
+du_int tests[][4] =
+{
+{0x0000000000000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000000uLL},
+{0x0000000000000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000000000001uLL, 0x0000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000001uLL},
+{0x0000000000000002uLL, 0x0000000000000001uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x0000000000000002uLL, 0x0000000000000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000000000002uLL, 0x0000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000002uLL},
+{0x0000000000000003uLL, 0x0000000000000001uLL, 0x0000000000000003uLL, 0x0000000000000000uLL},
+{0x0000000000000003uLL, 0x0000000000000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000000000003uLL, 0x0000000000000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000000000003uLL, 0x0000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000003uLL},
+{0x0000000000000010uLL, 0x0000000000000001uLL, 0x0000000000000010uLL, 0x0000000000000000uLL},
+{0x0000000000000010uLL, 0x0000000000000002uLL, 0x0000000000000008uLL, 0x0000000000000000uLL},
+{0x0000000000000010uLL, 0x0000000000000003uLL, 0x0000000000000005uLL, 0x0000000000000001uLL},
+{0x0000000000000010uLL, 0x0000000000000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000000000010uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x0000000000000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000000000010uLL},
+{0x00000000078644FAuLL, 0x0000000000000001uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL},
+{0x00000000078644FAuLL, 0x0000000000000002uLL, 0x0000000003C3227DuLL, 0x0000000000000000uLL},
+{0x00000000078644FAuLL, 0x0000000000000003uLL, 0x00000000028216FEuLL, 0x0000000000000000uLL},
+{0x00000000078644FAuLL, 0x0000000000000010uLL, 0x000000000078644FuLL, 0x000000000000000AuLL},
+{0x00000000078644FAuLL, 0x00000000078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000000078644FAuLL, 0x000000000747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x00000000078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x00000000078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000078644FAuLL},
+{0x000000000747AE14uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL},
+{0x000000000747AE14uLL, 0x0000000000000002uLL, 0x0000000003A3D70AuLL, 0x0000000000000000uLL},
+{0x000000000747AE14uLL, 0x0000000000000003uLL, 0x00000000026D3A06uLL, 0x0000000000000002uLL},
+{0x000000000747AE14uLL, 0x0000000000000010uLL, 0x0000000000747AE1uLL, 0x0000000000000004uLL},
+{0x000000000747AE14uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000000747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000000747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000000747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000000747AE14uLL},
+{0x000000007FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x000000003FFFFFFFuLL, 0x0000000000000001uLL},
+{0x000000007FFFFFFFuLL, 0x0000000000000003uLL, 0x000000002AAAAAAAuLL, 0x0000000000000001uLL},
+{0x000000007FFFFFFFuLL, 0x0000000000000010uLL, 0x0000000007FFFFFFuLL, 0x000000000000000FuLL},
+{0x000000007FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000011uLL, 0x0000000000156B65uLL},
+{0x000000007FFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000011uLL, 0x00000000043D70ABuLL},
+{0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000007FFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x000000007FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000007FFFFFFFuLL},
+{0x0000000080000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x0000000080000000uLL, 0x0000000000000002uLL, 0x0000000040000000uLL, 0x0000000000000000uLL},
+{0x0000000080000000uLL, 0x0000000000000003uLL, 0x000000002AAAAAAAuLL, 0x0000000000000002uLL},
+{0x0000000080000000uLL, 0x0000000000000010uLL, 0x0000000008000000uLL, 0x0000000000000000uLL},
+{0x0000000080000000uLL, 0x00000000078644FAuLL, 0x0000000000000011uLL, 0x0000000000156B66uLL},
+{0x0000000080000000uLL, 0x000000000747AE14uLL, 0x0000000000000011uLL, 0x00000000043D70ACuLL},
+{0x0000000080000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000080000000uLL, 0x0000000080000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000080000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x0000000080000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000080000000uLL},
+{0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000001uLL},
+{0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000055555554uLL, 0x0000000000000001uLL},
+{0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000000FFFFFFFuLL, 0x000000000000000DuLL},
+{0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6C9uLL},
+{0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333341uLL},
+{0x00000000FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFDuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000055555554uLL, 0x0000000000000002uLL},
+{0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000000FFFFFFFuLL, 0x000000000000000EuLL},
+{0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6CAuLL},
+{0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333342uLL},
+{0x00000000FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFEuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000055555555uLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000000FFFFFFFuLL, 0x000000000000000FuLL},
+{0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6CBuLL},
+{0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333343uLL},
+{0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x00000000FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000055555555uLL, 0x0000000000000001uLL},
+{0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000010000000uLL, 0x0000000000000000uLL},
+{0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6CCuLL},
+{0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333344uLL},
+{0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000100000000uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000100000000uLL, 0x0000000100000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000000uLL},
+{0x0000000100000001uLL, 0x0000000000000001uLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x0000000100000001uLL, 0x0000000000000002uLL, 0x0000000080000000uLL, 0x0000000000000001uLL},
+{0x0000000100000001uLL, 0x0000000000000003uLL, 0x0000000055555555uLL, 0x0000000000000002uLL},
+{0x0000000100000001uLL, 0x0000000000000010uLL, 0x0000000010000000uLL, 0x0000000000000001uLL},
+{0x0000000100000001uLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6CDuLL},
+{0x0000000100000001uLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333345uLL},
+{0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x0000000100000001uLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000100000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000100000001uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000100000001uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000100000001uLL, 0x0000000100000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000001uLL},
+{0x0000000100000002uLL, 0x0000000000000001uLL, 0x0000000100000002uLL, 0x0000000000000000uLL},
+{0x0000000100000002uLL, 0x0000000000000002uLL, 0x0000000080000001uLL, 0x0000000000000000uLL},
+{0x0000000100000002uLL, 0x0000000000000003uLL, 0x0000000055555556uLL, 0x0000000000000000uLL},
+{0x0000000100000002uLL, 0x0000000000000010uLL, 0x0000000010000000uLL, 0x0000000000000002uLL},
+{0x0000000100000002uLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6CEuLL},
+{0x0000000100000002uLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333346uLL},
+{0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0x0000000100000002uLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x0000000100000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000100000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000100000002uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000100000002uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000100000002uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000100000002uLL, 0x0000000100000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000002uLL},
+{0x0000000100000003uLL, 0x0000000000000001uLL, 0x0000000100000003uLL, 0x0000000000000000uLL},
+{0x0000000100000003uLL, 0x0000000000000002uLL, 0x0000000080000001uLL, 0x0000000000000001uLL},
+{0x0000000100000003uLL, 0x0000000000000003uLL, 0x0000000055555556uLL, 0x0000000000000001uLL},
+{0x0000000100000003uLL, 0x0000000000000010uLL, 0x0000000010000000uLL, 0x0000000000000003uLL},
+{0x0000000100000003uLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6CFuLL},
+{0x0000000100000003uLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333347uLL},
+{0x0000000100000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0x0000000100000003uLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x0000000100000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000006uLL},
+{0x0000000100000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x0000000100000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000100000003uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000100000003uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000100000003uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000100000003uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000100000003uLL, 0x0000000100000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000003uLL},
+{0x0000000100000010uLL, 0x0000000000000001uLL, 0x0000000100000010uLL, 0x0000000000000000uLL},
+{0x0000000100000010uLL, 0x0000000000000002uLL, 0x0000000080000008uLL, 0x0000000000000000uLL},
+{0x0000000100000010uLL, 0x0000000000000003uLL, 0x000000005555555AuLL, 0x0000000000000002uLL},
+{0x0000000100000010uLL, 0x0000000000000010uLL, 0x0000000010000001uLL, 0x0000000000000000uLL},
+{0x0000000100000010uLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000002AD6DCuLL},
+{0x0000000100000010uLL, 0x000000000747AE14uLL, 0x0000000000000023uLL, 0x0000000001333354uLL},
+{0x0000000100000010uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000012uLL},
+{0x0000000100000010uLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x0000000000000010uLL},
+{0x0000000100000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000013uLL},
+{0x0000000100000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000012uLL},
+{0x0000000100000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000011uLL},
+{0x0000000100000010uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x0000000100000010uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x0000000100000010uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x0000000100000010uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x0000000100000010uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000100000010uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x0000000100000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000100000010uLL},
+{0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL},
+{0x00000001078644FAuLL, 0x0000000000000002uLL, 0x0000000083C3227DuLL, 0x0000000000000000uLL},
+{0x00000001078644FAuLL, 0x0000000000000003uLL, 0x0000000057D76C53uLL, 0x0000000000000001uLL},
+{0x00000001078644FAuLL, 0x0000000000000010uLL, 0x000000001078644FuLL, 0x000000000000000AuLL},
+{0x00000001078644FAuLL, 0x00000000078644FAuLL, 0x0000000000000023uLL, 0x00000000002AD6CCuLL},
+{0x00000001078644FAuLL, 0x000000000747AE14uLL, 0x0000000000000024uLL, 0x000000000171CA2AuLL},
+{0x00000001078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x00000000078644FCuLL},
+{0x00000001078644FAuLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x00000000078644FAuLL},
+{0x00000001078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000078644FDuLL},
+{0x00000001078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000078644FCuLL},
+{0x00000001078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000078644FBuLL},
+{0x00000001078644FAuLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x00000001078644FAuLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x00000001078644FAuLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x00000001078644FAuLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x00000001078644FAuLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000001078644FAuLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x00000001078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x00000001078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001078644FAuLL},
+{0x000000010747AE14uLL, 0x0000000000000001uLL, 0x000000010747AE14uLL, 0x0000000000000000uLL},
+{0x000000010747AE14uLL, 0x0000000000000002uLL, 0x0000000083A3D70AuLL, 0x0000000000000000uLL},
+{0x000000010747AE14uLL, 0x0000000000000003uLL, 0x0000000057C28F5CuLL, 0x0000000000000000uLL},
+{0x000000010747AE14uLL, 0x0000000000000010uLL, 0x0000000010747AE1uLL, 0x0000000000000004uLL},
+{0x000000010747AE14uLL, 0x00000000078644FAuLL, 0x0000000000000022uLL, 0x00000000077284E0uLL},
+{0x000000010747AE14uLL, 0x000000000747AE14uLL, 0x0000000000000024uLL, 0x0000000001333344uLL},
+{0x000000010747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL, 0x000000000747AE16uLL},
+{0x000000010747AE14uLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x000000000747AE14uLL},
+{0x000000010747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x000000000747AE17uLL},
+{0x000000010747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x000000000747AE16uLL},
+{0x000000010747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x000000000747AE15uLL},
+{0x000000010747AE14uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x000000010747AE14uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x000000010747AE14uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x000000010747AE14uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x000000010747AE14uLL, 0x00000001078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000010747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000010747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000010747AE14uLL},
+{0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL},
+{0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x00000000BFFFFFFFuLL, 0x0000000000000001uLL},
+{0x000000017FFFFFFFuLL, 0x0000000000000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0x000000017FFFFFFFuLL, 0x0000000000000010uLL, 0x0000000017FFFFFFuLL, 0x000000000000000FuLL},
+{0x000000017FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000033uLL, 0x0000000000404231uLL},
+{0x000000017FFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000034uLL, 0x000000000570A3EFuLL},
+{0x000000017FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000002uLL},
+{0x000000017FFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x000000017FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x000000017FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x000000017FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x000000017FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x000000017FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x000000017FFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x000000017FFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x000000017FFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x000000017FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000017FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x000000017FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000017FFFFFFFuLL},
+{0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000180000000uLL, 0x0000000000000000uLL},
+{0x0000000180000000uLL, 0x0000000000000002uLL, 0x00000000C0000000uLL, 0x0000000000000000uLL},
+{0x0000000180000000uLL, 0x0000000000000003uLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x0000000180000000uLL, 0x0000000000000010uLL, 0x0000000018000000uLL, 0x0000000000000000uLL},
+{0x0000000180000000uLL, 0x00000000078644FAuLL, 0x0000000000000033uLL, 0x0000000000404232uLL},
+{0x0000000180000000uLL, 0x000000000747AE14uLL, 0x0000000000000034uLL, 0x000000000570A3F0uLL},
+{0x0000000180000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000003uLL},
+{0x0000000180000000uLL, 0x0000000080000000uLL, 0x0000000000000003uLL, 0x0000000000000000uLL},
+{0x0000000180000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000180000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000180000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000180000000uLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0000000180000000uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0000000180000000uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0000000180000000uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0000000180000000uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x0000000180000000uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x0000000180000000uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x0000000180000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000180000000uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000180000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x0000000180000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000180000000uLL},
+{0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFDuLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFDuLL, 0x0000000000000003uLL, 0x00000000AAAAAAA9uLL, 0x0000000000000002uLL},
+{0x00000001FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000001FFFFFFFuLL, 0x000000000000000DuLL},
+{0x00000001FFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD95uLL},
+{0x00000001FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x0000000002666685uLL},
+{0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000000000003uLL, 0x000000007FFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x00000001FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x00000001FFFFFFFDuLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x00000001FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFDuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFEuLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFEuLL, 0x0000000000000003uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000001FFFFFFFuLL, 0x000000000000000EuLL},
+{0x00000001FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD96uLL},
+{0x00000001FFFFFFFEuLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x0000000002666686uLL},
+{0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000002uLL},
+{0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000003uLL, 0x000000007FFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0x00000001FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x00000001FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x00000001FFFFFFFEuLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x00000001FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFEuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000000000003uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000001FFFFFFFuLL, 0x000000000000000FuLL},
+{0x00000001FFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD97uLL},
+{0x00000001FFFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x0000000002666687uLL},
+{0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000003uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000003uLL, 0x000000007FFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0x00000001FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x00000001FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x00000001FFFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x00000001FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x00000001FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000001FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000001FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x00000001FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000001FFFFFFFFuLL},
+{0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000200000000uLL, 0x0000000000000000uLL},
+{0x0000000200000000uLL, 0x0000000000000002uLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x0000000200000000uLL, 0x0000000000000003uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000002uLL},
+{0x0000000200000000uLL, 0x0000000000000010uLL, 0x0000000020000000uLL, 0x0000000000000000uLL},
+{0x0000000200000000uLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD98uLL},
+{0x0000000200000000uLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x0000000002666688uLL},
+{0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000004uLL},
+{0x0000000200000000uLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x0000000000000000uLL},
+{0x0000000200000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000006uLL},
+{0x0000000200000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0x0000000200000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x0000000200000000uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x0000000200000000uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000200000000uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x0000000200000000uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x0000000200000000uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF0uLL},
+{0x0000000200000000uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB06uLL},
+{0x0000000200000000uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851ECuLL},
+{0x0000000200000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000200000000uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0000000200000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000200000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000200000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000200000000uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000200000000uLL, 0x0000000200000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000000uLL},
+{0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000200000001uLL, 0x0000000000000000uLL},
+{0x0000000200000001uLL, 0x0000000000000002uLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x0000000200000001uLL, 0x0000000000000003uLL, 0x00000000AAAAAAABuLL, 0x0000000000000000uLL},
+{0x0000000200000001uLL, 0x0000000000000010uLL, 0x0000000020000000uLL, 0x0000000000000001uLL},
+{0x0000000200000001uLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD99uLL},
+{0x0000000200000001uLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x0000000002666689uLL},
+{0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000005uLL},
+{0x0000000200000001uLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x0000000000000001uLL},
+{0x0000000200000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000007uLL},
+{0x0000000200000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0x0000000200000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x0000000200000001uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x0000000200000001uLL, 0x0000000100000001uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000200000001uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000200000001uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x0000000200000001uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF1uLL},
+{0x0000000200000001uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB07uLL},
+{0x0000000200000001uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EDuLL},
+{0x0000000200000001uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000200000001uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000200000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000200000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000200000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000200000001uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000200000001uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000200000001uLL, 0x0000000200000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000001uLL},
+{0x0000000200000002uLL, 0x0000000000000001uLL, 0x0000000200000002uLL, 0x0000000000000000uLL},
+{0x0000000200000002uLL, 0x0000000000000002uLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x0000000200000002uLL, 0x0000000000000003uLL, 0x00000000AAAAAAABuLL, 0x0000000000000001uLL},
+{0x0000000200000002uLL, 0x0000000000000010uLL, 0x0000000020000000uLL, 0x0000000000000002uLL},
+{0x0000000200000002uLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD9AuLL},
+{0x0000000200000002uLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x000000000266668AuLL},
+{0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000006uLL},
+{0x0000000200000002uLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x0000000000000002uLL},
+{0x0000000200000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000008uLL},
+{0x0000000200000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000006uLL},
+{0x0000000200000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0x0000000200000002uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x0000000200000002uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x0000000200000002uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000200000002uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000200000002uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF2uLL},
+{0x0000000200000002uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB08uLL},
+{0x0000000200000002uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EEuLL},
+{0x0000000200000002uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000200000002uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000200000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x0000000200000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000200000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000200000002uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000200000002uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000200000002uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000200000002uLL, 0x0000000200000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000002uLL},
+{0x0000000200000003uLL, 0x0000000000000001uLL, 0x0000000200000003uLL, 0x0000000000000000uLL},
+{0x0000000200000003uLL, 0x0000000000000002uLL, 0x0000000100000001uLL, 0x0000000000000001uLL},
+{0x0000000200000003uLL, 0x0000000000000003uLL, 0x00000000AAAAAAABuLL, 0x0000000000000002uLL},
+{0x0000000200000003uLL, 0x0000000000000010uLL, 0x0000000020000000uLL, 0x0000000000000003uLL},
+{0x0000000200000003uLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055AD9BuLL},
+{0x0000000200000003uLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x000000000266668BuLL},
+{0x0000000200000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000007uLL},
+{0x0000000200000003uLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x0000000000000003uLL},
+{0x0000000200000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000009uLL},
+{0x0000000200000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000007uLL},
+{0x0000000200000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0x0000000200000003uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x0000000200000003uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x0000000200000003uLL, 0x0000000100000002uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000200000003uLL, 0x0000000100000003uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000200000003uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF3uLL},
+{0x0000000200000003uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB09uLL},
+{0x0000000200000003uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EFuLL},
+{0x0000000200000003uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000004uLL},
+{0x0000000200000003uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000200000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000006uLL},
+{0x0000000200000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x0000000200000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000200000003uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000200000003uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000200000003uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000200000003uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000200000003uLL, 0x0000000200000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000003uLL},
+{0x0000000200000010uLL, 0x0000000000000001uLL, 0x0000000200000010uLL, 0x0000000000000000uLL},
+{0x0000000200000010uLL, 0x0000000000000002uLL, 0x0000000100000008uLL, 0x0000000000000000uLL},
+{0x0000000200000010uLL, 0x0000000000000003uLL, 0x00000000AAAAAAB0uLL, 0x0000000000000000uLL},
+{0x0000000200000010uLL, 0x0000000000000010uLL, 0x0000000020000001uLL, 0x0000000000000000uLL},
+{0x0000000200000010uLL, 0x00000000078644FAuLL, 0x0000000000000044uLL, 0x000000000055ADA8uLL},
+{0x0000000200000010uLL, 0x000000000747AE14uLL, 0x0000000000000046uLL, 0x0000000002666698uLL},
+{0x0000000200000010uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000014uLL},
+{0x0000000200000010uLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x0000000000000010uLL},
+{0x0000000200000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000016uLL},
+{0x0000000200000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000014uLL},
+{0x0000000200000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000012uLL},
+{0x0000000200000010uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000000000010uLL},
+{0x0000000200000010uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x000000000000000EuLL},
+{0x0000000200000010uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x000000000000000CuLL},
+{0x0000000200000010uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x000000000000000AuLL},
+{0x0000000200000010uLL, 0x0000000100000010uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000200000010uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB16uLL},
+{0x0000000200000010uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851FCuLL},
+{0x0000000200000010uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000011uLL},
+{0x0000000200000010uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000080000010uLL},
+{0x0000000200000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000013uLL},
+{0x0000000200000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000012uLL},
+{0x0000000200000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000011uLL},
+{0x0000000200000010uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x0000000200000010uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x0000000200000010uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x0000000200000010uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x0000000200000010uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000200000010uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x0000000200000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000200000010uLL},
+{0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL},
+{0x00000002078644FAuLL, 0x0000000000000002uLL, 0x0000000103C3227DuLL, 0x0000000000000000uLL},
+{0x00000002078644FAuLL, 0x0000000000000003uLL, 0x00000000AD2CC1A8uLL, 0x0000000000000002uLL},
+{0x00000002078644FAuLL, 0x0000000000000010uLL, 0x000000002078644FuLL, 0x000000000000000AuLL},
+{0x00000002078644FAuLL, 0x00000000078644FAuLL, 0x0000000000000045uLL, 0x000000000055AD98uLL},
+{0x00000002078644FAuLL, 0x000000000747AE14uLL, 0x0000000000000047uLL, 0x0000000002A4FD6EuLL},
+{0x00000002078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x00000000078644FEuLL},
+{0x00000002078644FAuLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x00000000078644FAuLL},
+{0x00000002078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000007864500uLL},
+{0x00000002078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x00000000078644FEuLL},
+{0x00000002078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x00000000078644FCuLL},
+{0x00000002078644FAuLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x00000000078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x00000000078644F8uLL},
+{0x00000002078644FAuLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000078644F6uLL},
+{0x00000002078644FAuLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000078644F4uLL},
+{0x00000002078644FAuLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000078644DAuLL},
+{0x00000002078644FAuLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000002078644FAuLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x00000001003E96E6uLL},
+{0x00000002078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x00000000878644FBuLL},
+{0x00000002078644FAuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x00000000878644FAuLL},
+{0x00000002078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000078644FDuLL},
+{0x00000002078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000078644FCuLL},
+{0x00000002078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000078644FBuLL},
+{0x00000002078644FAuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x00000002078644FAuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x00000002078644FAuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x00000002078644FAuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x00000002078644FAuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000002078644FAuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x00000002078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x00000002078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002078644FAuLL},
+{0x000000020747AE14uLL, 0x0000000000000001uLL, 0x000000020747AE14uLL, 0x0000000000000000uLL},
+{0x000000020747AE14uLL, 0x0000000000000002uLL, 0x0000000103A3D70AuLL, 0x0000000000000000uLL},
+{0x000000020747AE14uLL, 0x0000000000000003uLL, 0x00000000AD17E4B1uLL, 0x0000000000000001uLL},
+{0x000000020747AE14uLL, 0x0000000000000010uLL, 0x0000000020747AE1uLL, 0x0000000000000004uLL},
+{0x000000020747AE14uLL, 0x00000000078644FAuLL, 0x0000000000000045uLL, 0x00000000001716B2uLL},
+{0x000000020747AE14uLL, 0x000000000747AE14uLL, 0x0000000000000047uLL, 0x0000000002666688uLL},
+{0x000000020747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL, 0x000000000747AE18uLL},
+{0x000000020747AE14uLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x000000000747AE14uLL},
+{0x000000020747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x000000000747AE1AuLL},
+{0x000000020747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x000000000747AE18uLL},
+{0x000000020747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x000000000747AE16uLL},
+{0x000000020747AE14uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x000000000747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x000000000747AE12uLL},
+{0x000000020747AE14uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x000000000747AE10uLL},
+{0x000000020747AE14uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x000000000747AE0EuLL},
+{0x000000020747AE14uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x000000000747ADF4uLL},
+{0x000000020747AE14uLL, 0x00000001078644FAuLL, 0x0000000000000001uLL, 0x00000000FFC1691AuLL},
+{0x000000020747AE14uLL, 0x000000010747AE14uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x000000020747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x000000008747AE15uLL},
+{0x000000020747AE14uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000008747AE14uLL},
+{0x000000020747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x000000000747AE17uLL},
+{0x000000020747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x000000000747AE16uLL},
+{0x000000020747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x000000000747AE15uLL},
+{0x000000020747AE14uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x000000020747AE14uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x000000020747AE14uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x000000020747AE14uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x000000020747AE14uLL, 0x00000002078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000020747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000020747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000020747AE14uLL},
+{0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x000000027FFFFFFFuLL, 0x0000000000000000uLL},
+{0x000000027FFFFFFFuLL, 0x0000000000000002uLL, 0x000000013FFFFFFFuLL, 0x0000000000000001uLL},
+{0x000000027FFFFFFFuLL, 0x0000000000000003uLL, 0x00000000D5555555uLL, 0x0000000000000000uLL},
+{0x000000027FFFFFFFuLL, 0x0000000000000010uLL, 0x0000000027FFFFFFuLL, 0x000000000000000FuLL},
+{0x000000027FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000055uLL, 0x00000000006B18FDuLL},
+{0x000000027FFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000057uLL, 0x0000000006A3D733uLL},
+{0x000000027FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000005uLL, 0x0000000000000004uLL},
+{0x000000027FFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000004uLL, 0x000000007FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000080000005uLL},
+{0x000000027FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000080000003uLL},
+{0x000000027FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000080000001uLL},
+{0x000000027FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x000000007FFFFFFDuLL},
+{0x000000027FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x000000007FFFFFFBuLL},
+{0x000000027FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x000000007FFFFFF9uLL},
+{0x000000027FFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x000000007FFFFFDFuLL},
+{0x000000027FFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x0000000070F3760BuLL},
+{0x000000027FFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x000000007170A3D7uLL},
+{0x000000027FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x000000027FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x000000027FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x000000027FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x000000027FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x000000027FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x000000027FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x000000027FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x000000027FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x000000027FFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x000000027FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000027FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x000000027FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000027FFFFFFFuLL},
+{0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000280000000uLL, 0x0000000000000000uLL},
+{0x0000000280000000uLL, 0x0000000000000002uLL, 0x0000000140000000uLL, 0x0000000000000000uLL},
+{0x0000000280000000uLL, 0x0000000000000003uLL, 0x00000000D5555555uLL, 0x0000000000000001uLL},
+{0x0000000280000000uLL, 0x0000000000000010uLL, 0x0000000028000000uLL, 0x0000000000000000uLL},
+{0x0000000280000000uLL, 0x00000000078644FAuLL, 0x0000000000000055uLL, 0x00000000006B18FEuLL},
+{0x0000000280000000uLL, 0x000000000747AE14uLL, 0x0000000000000057uLL, 0x0000000006A3D734uLL},
+{0x0000000280000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000005uLL, 0x0000000000000005uLL},
+{0x0000000280000000uLL, 0x0000000080000000uLL, 0x0000000000000005uLL, 0x0000000000000000uLL},
+{0x0000000280000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000080000006uLL},
+{0x0000000280000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000080000004uLL},
+{0x0000000280000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000080000002uLL},
+{0x0000000280000000uLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x0000000080000000uLL},
+{0x0000000280000000uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x000000007FFFFFFEuLL},
+{0x0000000280000000uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x000000007FFFFFFCuLL},
+{0x0000000280000000uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x000000007FFFFFFAuLL},
+{0x0000000280000000uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x000000007FFFFFE0uLL},
+{0x0000000280000000uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x0000000070F3760CuLL},
+{0x0000000280000000uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x000000007170A3D8uLL},
+{0x0000000280000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000280000000uLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000280000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000280000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000280000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000280000000uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0000000280000000uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0000000280000000uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0000000280000000uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0000000280000000uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x0000000280000000uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x0000000280000000uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x0000000280000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000280000000uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000280000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x0000000280000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000280000000uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000000000002uLL, 0x000000017FFFFFFEuLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000000000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000002FFFFFFFuLL, 0x000000000000000DuLL},
+{0x00000002FFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808461uLL},
+{0x00000002FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999C9uLL},
+{0x00000002FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000003uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000000000005uLL, 0x000000007FFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000000000006uLL},
+{0x00000002FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000003uLL},
+{0x00000002FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFBuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF9uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF7uLL},
+{0x00000002FFFFFFFDuLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFDDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F37609uLL},
+{0x00000002FFFFFFFDuLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D5uLL},
+{0x00000002FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000002FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000002FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x00000002FFFFFFFDuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x00000002FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFDuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000000000002uLL, 0x000000017FFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000000000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000002FFFFFFFuLL, 0x000000000000000EuLL},
+{0x00000002FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808462uLL},
+{0x00000002FFFFFFFEuLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999CAuLL},
+{0x00000002FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000004uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000005uLL, 0x000000007FFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000000000007uLL},
+{0x00000002FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000004uLL},
+{0x00000002FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFCuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFAuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF8uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFDEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760AuLL},
+{0x00000002FFFFFFFEuLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D6uLL},
+{0x00000002FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x00000002FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000002FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x00000002FFFFFFFEuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x00000002FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFEuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000000000002uLL, 0x000000017FFFFFFFuLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000000000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000002FFFFFFFuLL, 0x000000000000000FuLL},
+{0x00000002FFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808463uLL},
+{0x00000002FFFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999CBuLL},
+{0x00000002FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000005uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000005uLL, 0x000000007FFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000000000008uLL},
+{0x00000002FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000005uLL},
+{0x00000002FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000002uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFBuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF9uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFDFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760BuLL},
+{0x00000002FFFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D7uLL},
+{0x00000002FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x00000002FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x00000002FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x00000002FFFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x00000002FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x00000002FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000002FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000002FFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x00000002FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000002FFFFFFFFuLL},
+{0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000300000000uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x0000000000000002uLL, 0x0000000180000000uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x0000000000000003uLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x0000000000000010uLL, 0x0000000030000000uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808464uLL},
+{0x0000000300000000uLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999CCuLL},
+{0x0000000300000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000006uLL},
+{0x0000000300000000uLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000000000009uLL},
+{0x0000000300000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000006uLL},
+{0x0000000300000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000003uLL},
+{0x0000000300000000uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0x0000000300000000uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFCuLL},
+{0x0000000300000000uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFAuLL},
+{0x0000000300000000uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE0uLL},
+{0x0000000300000000uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760CuLL},
+{0x0000000300000000uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D8uLL},
+{0x0000000300000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x0000000300000000uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0x0000000300000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x0000000300000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000300000000uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000300000000uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000300000000uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x0000000300000000uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x0000000300000000uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF0uLL},
+{0x0000000300000000uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB06uLL},
+{0x0000000300000000uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851ECuLL},
+{0x0000000300000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000300000000uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0000000300000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000300000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000300000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000300000000uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000300000000uLL, 0x0000000300000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000000uLL},
+{0x0000000300000001uLL, 0x0000000000000001uLL, 0x0000000300000001uLL, 0x0000000000000000uLL},
+{0x0000000300000001uLL, 0x0000000000000002uLL, 0x0000000180000000uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x0000000000000003uLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x0000000000000010uLL, 0x0000000030000000uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808465uLL},
+{0x0000000300000001uLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999CDuLL},
+{0x0000000300000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000007uLL},
+{0x0000000300000001uLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x000000000000000AuLL},
+{0x0000000300000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000007uLL},
+{0x0000000300000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000004uLL},
+{0x0000000300000001uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000300000001uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0x0000000300000001uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFBuLL},
+{0x0000000300000001uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE1uLL},
+{0x0000000300000001uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760DuLL},
+{0x0000000300000001uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D9uLL},
+{0x0000000300000001uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x0000000300000001uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000004uLL},
+{0x0000000300000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0x0000000300000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x0000000300000001uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000300000001uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000300000001uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000300000001uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x0000000300000001uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF1uLL},
+{0x0000000300000001uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB07uLL},
+{0x0000000300000001uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EDuLL},
+{0x0000000300000001uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000300000001uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000300000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000300000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000300000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000300000001uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000300000001uLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000300000001uLL, 0x0000000300000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000001uLL},
+{0x0000000300000002uLL, 0x0000000000000001uLL, 0x0000000300000002uLL, 0x0000000000000000uLL},
+{0x0000000300000002uLL, 0x0000000000000002uLL, 0x0000000180000001uLL, 0x0000000000000000uLL},
+{0x0000000300000002uLL, 0x0000000000000003uLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0x0000000300000002uLL, 0x0000000000000010uLL, 0x0000000030000000uLL, 0x0000000000000002uLL},
+{0x0000000300000002uLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808466uLL},
+{0x0000000300000002uLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999CEuLL},
+{0x0000000300000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000008uLL},
+{0x0000000300000002uLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x0000000000000002uLL},
+{0x0000000300000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x000000000000000BuLL},
+{0x0000000300000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000008uLL},
+{0x0000000300000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000005uLL},
+{0x0000000300000002uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000000000002uLL},
+{0x0000000300000002uLL, 0x0000000100000001uLL, 0x0000000000000002uLL, 0x0000000100000000uLL},
+{0x0000000300000002uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0x0000000300000002uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFCuLL},
+{0x0000000300000002uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE2uLL},
+{0x0000000300000002uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760EuLL},
+{0x0000000300000002uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3DAuLL},
+{0x0000000300000002uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0x0000000300000002uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x0000000300000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000005uLL},
+{0x0000000300000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000004uLL},
+{0x0000000300000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0x0000000300000002uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x0000000300000002uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000300000002uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000300000002uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000300000002uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF2uLL},
+{0x0000000300000002uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB08uLL},
+{0x0000000300000002uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EEuLL},
+{0x0000000300000002uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000300000002uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000300000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x0000000300000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000300000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000300000002uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000300000002uLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000300000002uLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000300000002uLL, 0x0000000300000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000002uLL},
+{0x0000000300000003uLL, 0x0000000000000001uLL, 0x0000000300000003uLL, 0x0000000000000000uLL},
+{0x0000000300000003uLL, 0x0000000000000002uLL, 0x0000000180000001uLL, 0x0000000000000001uLL},
+{0x0000000300000003uLL, 0x0000000000000003uLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x0000000300000003uLL, 0x0000000000000010uLL, 0x0000000030000000uLL, 0x0000000000000003uLL},
+{0x0000000300000003uLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808467uLL},
+{0x0000000300000003uLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999CFuLL},
+{0x0000000300000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000009uLL},
+{0x0000000300000003uLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x0000000000000003uLL},
+{0x0000000300000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x000000000000000CuLL},
+{0x0000000300000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000009uLL},
+{0x0000000300000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000006uLL},
+{0x0000000300000003uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000000000003uLL},
+{0x0000000300000003uLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x0000000000000000uLL},
+{0x0000000300000003uLL, 0x0000000100000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0x0000000300000003uLL, 0x0000000100000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0x0000000300000003uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE3uLL},
+{0x0000000300000003uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760FuLL},
+{0x0000000300000003uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3DBuLL},
+{0x0000000300000003uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0x0000000300000003uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x0000000300000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000006uLL},
+{0x0000000300000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000005uLL},
+{0x0000000300000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000004uLL},
+{0x0000000300000003uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0x0000000300000003uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x0000000300000003uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000300000003uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000300000003uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF3uLL},
+{0x0000000300000003uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB09uLL},
+{0x0000000300000003uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EFuLL},
+{0x0000000300000003uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000004uLL},
+{0x0000000300000003uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000300000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000006uLL},
+{0x0000000300000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x0000000300000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x0000000300000003uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000000300000003uLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000000300000003uLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000300000003uLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000300000003uLL, 0x0000000300000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000003uLL},
+{0x0000000300000010uLL, 0x0000000000000001uLL, 0x0000000300000010uLL, 0x0000000000000000uLL},
+{0x0000000300000010uLL, 0x0000000000000002uLL, 0x0000000180000008uLL, 0x0000000000000000uLL},
+{0x0000000300000010uLL, 0x0000000000000003uLL, 0x0000000100000005uLL, 0x0000000000000001uLL},
+{0x0000000300000010uLL, 0x0000000000000010uLL, 0x0000000030000001uLL, 0x0000000000000000uLL},
+{0x0000000300000010uLL, 0x00000000078644FAuLL, 0x0000000000000066uLL, 0x0000000000808474uLL},
+{0x0000000300000010uLL, 0x000000000747AE14uLL, 0x0000000000000069uLL, 0x00000000039999DCuLL},
+{0x0000000300000010uLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000000000016uLL},
+{0x0000000300000010uLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x0000000000000010uLL},
+{0x0000000300000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000000000019uLL},
+{0x0000000300000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000000000016uLL},
+{0x0000000300000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000000000013uLL},
+{0x0000000300000010uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000000000010uLL},
+{0x0000000300000010uLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x000000000000000DuLL},
+{0x0000000300000010uLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x000000000000000AuLL},
+{0x0000000300000010uLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x0000000000000007uLL},
+{0x0000000300000010uLL, 0x0000000100000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF0uLL},
+{0x0000000300000010uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3761CuLL},
+{0x0000000300000010uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3E8uLL},
+{0x0000000300000010uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000012uLL},
+{0x0000000300000010uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x0000000000000010uLL},
+{0x0000000300000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000013uLL},
+{0x0000000300000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000012uLL},
+{0x0000000300000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000011uLL},
+{0x0000000300000010uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000100000010uLL},
+{0x0000000300000010uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000010000000FuLL},
+{0x0000000300000010uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000010000000EuLL},
+{0x0000000300000010uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000010000000DuLL},
+{0x0000000300000010uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000300000010uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB16uLL},
+{0x0000000300000010uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851FCuLL},
+{0x0000000300000010uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000011uLL},
+{0x0000000300000010uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000080000010uLL},
+{0x0000000300000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000013uLL},
+{0x0000000300000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000012uLL},
+{0x0000000300000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000011uLL},
+{0x0000000300000010uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x0000000300000010uLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x0000000300000010uLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x0000000300000010uLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x0000000300000010uLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000300000010uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x0000000300000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000300000010uLL},
+{0x00000003078644FAuLL, 0x0000000000000001uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL},
+{0x00000003078644FAuLL, 0x0000000000000002uLL, 0x0000000183C3227DuLL, 0x0000000000000000uLL},
+{0x00000003078644FAuLL, 0x0000000000000003uLL, 0x00000001028216FEuLL, 0x0000000000000000uLL},
+{0x00000003078644FAuLL, 0x0000000000000010uLL, 0x000000003078644FuLL, 0x000000000000000AuLL},
+{0x00000003078644FAuLL, 0x00000000078644FAuLL, 0x0000000000000067uLL, 0x0000000000808464uLL},
+{0x00000003078644FAuLL, 0x000000000747AE14uLL, 0x000000000000006AuLL, 0x0000000003D830B2uLL},
+{0x00000003078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000007864500uLL},
+{0x00000003078644FAuLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x00000000078644FAuLL},
+{0x00000003078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000007864503uLL},
+{0x00000003078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000007864500uLL},
+{0x00000003078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x00000000078644FDuLL},
+{0x00000003078644FAuLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x00000000078644FAuLL},
+{0x00000003078644FAuLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x00000000078644F7uLL},
+{0x00000003078644FAuLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x00000000078644F4uLL},
+{0x00000003078644FAuLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x00000000078644F1uLL},
+{0x00000003078644FAuLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x00000000078644CAuLL},
+{0x00000003078644FAuLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F879BB06uLL},
+{0x00000003078644FAuLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F8F6E8D2uLL},
+{0x00000003078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x00000000078644FCuLL},
+{0x00000003078644FAuLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x00000000078644FAuLL},
+{0x00000003078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000001078644FDuLL},
+{0x00000003078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000001078644FCuLL},
+{0x00000003078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000001078644FBuLL},
+{0x00000003078644FAuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000001078644FAuLL},
+{0x00000003078644FAuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000001078644F9uLL},
+{0x00000003078644FAuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000001078644F8uLL},
+{0x00000003078644FAuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000001078644F7uLL},
+{0x00000003078644FAuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000001078644EAuLL},
+{0x00000003078644FAuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000003078644FAuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000001003E96E6uLL},
+{0x00000003078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x00000000878644FBuLL},
+{0x00000003078644FAuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x00000000878644FAuLL},
+{0x00000003078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000078644FDuLL},
+{0x00000003078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000078644FCuLL},
+{0x00000003078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000078644FBuLL},
+{0x00000003078644FAuLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x00000003078644FAuLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x00000003078644FAuLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x00000003078644FAuLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x00000003078644FAuLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x00000003078644FAuLL, 0x00000003078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000003078644FAuLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x00000003078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x00000003078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003078644FAuLL},
+{0x000000030747AE14uLL, 0x0000000000000001uLL, 0x000000030747AE14uLL, 0x0000000000000000uLL},
+{0x000000030747AE14uLL, 0x0000000000000002uLL, 0x0000000183A3D70AuLL, 0x0000000000000000uLL},
+{0x000000030747AE14uLL, 0x0000000000000003uLL, 0x00000001026D3A06uLL, 0x0000000000000002uLL},
+{0x000000030747AE14uLL, 0x0000000000000010uLL, 0x0000000030747AE1uLL, 0x0000000000000004uLL},
+{0x000000030747AE14uLL, 0x00000000078644FAuLL, 0x0000000000000067uLL, 0x000000000041ED7EuLL},
+{0x000000030747AE14uLL, 0x000000000747AE14uLL, 0x000000000000006AuLL, 0x00000000039999CCuLL},
+{0x000000030747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000000000006uLL, 0x000000000747AE1AuLL},
+{0x000000030747AE14uLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x000000000747AE14uLL},
+{0x000000030747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x000000000747AE1DuLL},
+{0x000000030747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x000000000747AE1AuLL},
+{0x000000030747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x000000000747AE17uLL},
+{0x000000030747AE14uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x000000000747AE14uLL},
+{0x000000030747AE14uLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x000000000747AE11uLL},
+{0x000000030747AE14uLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x000000000747AE0EuLL},
+{0x000000030747AE14uLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x000000000747AE0BuLL},
+{0x000000030747AE14uLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x000000000747ADE4uLL},
+{0x000000030747AE14uLL, 0x00000001078644FAuLL, 0x0000000000000002uLL, 0x00000000F83B2420uLL},
+{0x000000030747AE14uLL, 0x000000010747AE14uLL, 0x0000000000000002uLL, 0x00000000F8B851ECuLL},
+{0x000000030747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x000000000747AE16uLL},
+{0x000000030747AE14uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x000000000747AE14uLL},
+{0x000000030747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x000000010747AE17uLL},
+{0x000000030747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x000000010747AE16uLL},
+{0x000000030747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x000000010747AE15uLL},
+{0x000000030747AE14uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x000000010747AE14uLL},
+{0x000000030747AE14uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000010747AE13uLL},
+{0x000000030747AE14uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000010747AE12uLL},
+{0x000000030747AE14uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000010747AE11uLL},
+{0x000000030747AE14uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x000000010747AE04uLL},
+{0x000000030747AE14uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000000FFC1691AuLL},
+{0x000000030747AE14uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x000000030747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x000000008747AE15uLL},
+{0x000000030747AE14uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000008747AE14uLL},
+{0x000000030747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x000000000747AE17uLL},
+{0x000000030747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x000000000747AE16uLL},
+{0x000000030747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x000000000747AE15uLL},
+{0x000000030747AE14uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x000000030747AE14uLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x000000030747AE14uLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x000000030747AE14uLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x000000030747AE14uLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x000000030747AE14uLL, 0x00000003078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000030747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000030747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000030747AE14uLL},
+{0x000000037FFFFFFFuLL, 0x0000000000000001uLL, 0x000000037FFFFFFFuLL, 0x0000000000000000uLL},
+{0x000000037FFFFFFFuLL, 0x0000000000000002uLL, 0x00000001BFFFFFFFuLL, 0x0000000000000001uLL},
+{0x000000037FFFFFFFuLL, 0x0000000000000003uLL, 0x000000012AAAAAAAuLL, 0x0000000000000001uLL},
+{0x000000037FFFFFFFuLL, 0x0000000000000010uLL, 0x0000000037FFFFFFuLL, 0x000000000000000FuLL},
+{0x000000037FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000077uLL, 0x000000000095EFC9uLL},
+{0x000000037FFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000000007BuLL, 0x00000000008F5C63uLL},
+{0x000000037FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000007uLL, 0x0000000000000006uLL},
+{0x000000037FFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000006uLL, 0x000000007FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000080000008uLL},
+{0x000000037FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000080000005uLL},
+{0x000000037FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000080000002uLL},
+{0x000000037FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x000000007FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x000000007FFFFFFCuLL},
+{0x000000037FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x000000007FFFFFF9uLL},
+{0x000000037FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x000000007FFFFFF6uLL},
+{0x000000037FFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x000000007FFFFFCFuLL},
+{0x000000037FFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000003uLL, 0x00000000696D3111uLL},
+{0x000000037FFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000003uLL, 0x000000006A28F5C3uLL},
+{0x000000037FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000080000001uLL},
+{0x000000037FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000180000002uLL},
+{0x000000037FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000180000001uLL},
+{0x000000037FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0x000000037FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x000000037FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x000000037FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFCuLL},
+{0x000000037FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFEFuLL},
+{0x000000037FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB05uLL},
+{0x000000037FFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851EBuLL},
+{0x000000037FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x000000037FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x000000037FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x000000037FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x000000037FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x000000037FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x000000037FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x000000037FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x000000037FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x000000037FFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x000000037FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000037FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x000000037FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000037FFFFFFFuLL},
+{0x0000000380000000uLL, 0x0000000000000001uLL, 0x0000000380000000uLL, 0x0000000000000000uLL},
+{0x0000000380000000uLL, 0x0000000000000002uLL, 0x00000001C0000000uLL, 0x0000000000000000uLL},
+{0x0000000380000000uLL, 0x0000000000000003uLL, 0x000000012AAAAAAAuLL, 0x0000000000000002uLL},
+{0x0000000380000000uLL, 0x0000000000000010uLL, 0x0000000038000000uLL, 0x0000000000000000uLL},
+{0x0000000380000000uLL, 0x00000000078644FAuLL, 0x0000000000000077uLL, 0x000000000095EFCAuLL},
+{0x0000000380000000uLL, 0x000000000747AE14uLL, 0x000000000000007BuLL, 0x00000000008F5C64uLL},
+{0x0000000380000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000007uLL, 0x0000000000000007uLL},
+{0x0000000380000000uLL, 0x0000000080000000uLL, 0x0000000000000007uLL, 0x0000000000000000uLL},
+{0x0000000380000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000080000009uLL},
+{0x0000000380000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000080000006uLL},
+{0x0000000380000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000080000003uLL},
+{0x0000000380000000uLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x0000000080000000uLL},
+{0x0000000380000000uLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x000000007FFFFFFDuLL},
+{0x0000000380000000uLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x000000007FFFFFFAuLL},
+{0x0000000380000000uLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x000000007FFFFFF7uLL},
+{0x0000000380000000uLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x000000007FFFFFD0uLL},
+{0x0000000380000000uLL, 0x00000001078644FAuLL, 0x0000000000000003uLL, 0x00000000696D3112uLL},
+{0x0000000380000000uLL, 0x000000010747AE14uLL, 0x0000000000000003uLL, 0x000000006A28F5C4uLL},
+{0x0000000380000000uLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000080000002uLL},
+{0x0000000380000000uLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x0000000080000000uLL},
+{0x0000000380000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000180000003uLL},
+{0x0000000380000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000180000002uLL},
+{0x0000000380000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000001uLL},
+{0x0000000380000000uLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0x0000000380000000uLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x0000000380000000uLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x0000000380000000uLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x0000000380000000uLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFF0uLL},
+{0x0000000380000000uLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB06uLL},
+{0x0000000380000000uLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851ECuLL},
+{0x0000000380000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x0000000380000000uLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x0000000380000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x0000000380000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x0000000380000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x0000000380000000uLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0000000380000000uLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0000000380000000uLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0000000380000000uLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0000000380000000uLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x0000000380000000uLL, 0x00000003078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x0000000380000000uLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x0000000380000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000000380000000uLL, 0x0000000380000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000000380000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x0000000380000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000000380000000uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000000000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000000000003uLL, 0x0000000155555554uLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000003FFFFFFFuLL, 0x000000000000000DuLL},
+{0x00000003FFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000000000000088uLL, 0x0000000000AB5B2DuLL},
+{0x00000003FFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000000000008CuLL, 0x0000000004CCCD0DuLL},
+{0x00000003FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000000000008uLL, 0x0000000000000005uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000000000007uLL, 0x000000007FFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000004uLL, 0x0000000000000009uLL},
+{0x00000003FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000000000005uLL},
+{0x00000003FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x00000000FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x00000000FFFFFFFAuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x00000000FFFFFFF7uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x00000000FFFFFFF4uLL},
+{0x00000003FFFFFFFDuLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x00000000FFFFFFCDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000001078644FAuLL, 0x0000000000000003uLL, 0x00000000E96D310FuLL},
+{0x00000003FFFFFFFDuLL, 0x000000010747AE14uLL, 0x0000000000000003uLL, 0x00000000EA28F5C1uLL},
+{0x00000003FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x00000003FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFAuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB03uLL},
+{0x00000003FFFFFFFDuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851E9uLL},
+{0x00000003FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000003FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000003FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x00000003FFFFFFFDuLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x00000003FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000003FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFDuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000000000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000000000003uLL, 0x0000000155555554uLL, 0x0000000000000002uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000003FFFFFFFuLL, 0x000000000000000EuLL},
+{0x00000003FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000000000088uLL, 0x0000000000AB5B2EuLL},
+{0x00000003FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000000000008CuLL, 0x0000000004CCCD0EuLL},
+{0x00000003FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000008uLL, 0x0000000000000006uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000007uLL, 0x000000007FFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000000AuLL},
+{0x00000003FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000000000006uLL},
+{0x00000003FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000002uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x00000000FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x00000000FFFFFFFBuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x00000000FFFFFFF8uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x00000000FFFFFFF5uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x00000000FFFFFFCEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000001078644FAuLL, 0x0000000000000003uLL, 0x00000000E96D3110uLL},
+{0x00000003FFFFFFFEuLL, 0x000000010747AE14uLL, 0x0000000000000003uLL, 0x00000000EA28F5C2uLL},
+{0x00000003FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000100000000uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0x00000003FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0x00000003FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB04uLL},
+{0x00000003FFFFFFFEuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EAuLL},
+{0x00000003FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x00000003FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000003FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x00000003FFFFFFFEuLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x00000003FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000003FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFEuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000000000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000000000003uLL, 0x0000000155555555uLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000003FFFFFFFuLL, 0x000000000000000FuLL},
+{0x00000003FFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000088uLL, 0x0000000000AB5B2FuLL},
+{0x00000003FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000000008CuLL, 0x0000000004CCCD0FuLL},
+{0x00000003FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000008uLL, 0x0000000000000007uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000007uLL, 0x000000007FFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000000BuLL},
+{0x00000003FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000000000007uLL},
+{0x00000003FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000003uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000003uLL, 0x00000000FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000003uLL, 0x00000000FFFFFFFCuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000003uLL, 0x00000000FFFFFFF9uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000003uLL, 0x00000000FFFFFFF6uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000003uLL, 0x00000000FFFFFFCFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000003uLL, 0x00000000E96D3111uLL},
+{0x00000003FFFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000003uLL, 0x00000000EA28F5C3uLL},
+{0x00000003FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000100000001uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0x00000003FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0x00000003FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB05uLL},
+{0x00000003FFFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EBuLL},
+{0x00000003FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x00000003FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x00000003FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000003FFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x00000003FFFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x00000003FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x00000003FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x00000003FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000003FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000003FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x00000003FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000003FFFFFFFFuLL},
+{0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000001000000000uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x0000000000000002uLL, 0x0000000800000000uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x0000000000000003uLL, 0x0000000555555555uLL, 0x0000000000000001uLL},
+{0x0000001000000000uLL, 0x0000000000000010uLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x00000000078644FAuLL, 0x0000000000000220uLL, 0x0000000002AD6CC0uLL},
+{0x0000001000000000uLL, 0x000000000747AE14uLL, 0x0000000000000232uLL, 0x0000000004A3D818uLL},
+{0x0000001000000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x0000000000000020uLL},
+{0x0000001000000000uLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x0000000000000030uLL},
+{0x0000001000000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x0000000000000020uLL},
+{0x0000001000000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x0000000000000010uLL},
+{0x0000001000000000uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x0000000100000001uLL, 0x000000000000000FuLL, 0x00000000FFFFFFF1uLL},
+{0x0000001000000000uLL, 0x0000000100000002uLL, 0x000000000000000FuLL, 0x00000000FFFFFFE2uLL},
+{0x0000001000000000uLL, 0x0000000100000003uLL, 0x000000000000000FuLL, 0x00000000FFFFFFD3uLL},
+{0x0000001000000000uLL, 0x0000000100000010uLL, 0x000000000000000FuLL, 0x00000000FFFFFF10uLL},
+{0x0000001000000000uLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x000000008F21F55AuLL},
+{0x0000001000000000uLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x0000000092CCCCD4uLL},
+{0x0000001000000000uLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x000000010000000AuLL},
+{0x0000001000000000uLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x0000000100000000uLL},
+{0x0000001000000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000000000018uLL},
+{0x0000001000000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x0000000000000010uLL},
+{0x0000001000000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000000000008uLL},
+{0x0000001000000000uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x0000000200000001uLL, 0x0000000000000007uLL, 0x00000001FFFFFFF9uLL},
+{0x0000001000000000uLL, 0x0000000200000002uLL, 0x0000000000000007uLL, 0x00000001FFFFFFF2uLL},
+{0x0000001000000000uLL, 0x0000000200000003uLL, 0x0000000000000007uLL, 0x00000001FFFFFFEBuLL},
+{0x0000001000000000uLL, 0x0000000200000010uLL, 0x0000000000000007uLL, 0x00000001FFFFFF90uLL},
+{0x0000001000000000uLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001CB541D2AuLL},
+{0x0000001000000000uLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001CD0A3D74uLL},
+{0x0000001000000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000100000006uLL},
+{0x0000001000000000uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x0000000100000000uLL},
+{0x0000001000000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000010000000FuLL},
+{0x0000001000000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000010000000AuLL},
+{0x0000001000000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000100000005uLL},
+{0x0000001000000000uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x0000000100000000uLL},
+{0x0000001000000000uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000000FFFFFFFBuLL},
+{0x0000001000000000uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF6uLL},
+{0x0000001000000000uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF1uLL},
+{0x0000001000000000uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000000FFFFFFB0uLL},
+{0x0000001000000000uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000DA60A71EuLL},
+{0x0000001000000000uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000DB99999CuLL},
+{0x0000001000000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000200000004uLL},
+{0x0000001000000000uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x0000000200000000uLL},
+{0x0000001000000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000000CuLL},
+{0x0000001000000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000000000008uLL},
+{0x0000001000000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000004uLL},
+{0x0000001000000000uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000001000000000uLL, 0x0000001000000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000000uLL},
+{0x0000001000000001uLL, 0x0000000000000001uLL, 0x0000001000000001uLL, 0x0000000000000000uLL},
+{0x0000001000000001uLL, 0x0000000000000002uLL, 0x0000000800000000uLL, 0x0000000000000001uLL},
+{0x0000001000000001uLL, 0x0000000000000003uLL, 0x0000000555555555uLL, 0x0000000000000002uLL},
+{0x0000001000000001uLL, 0x0000000000000010uLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x0000001000000001uLL, 0x00000000078644FAuLL, 0x0000000000000220uLL, 0x0000000002AD6CC1uLL},
+{0x0000001000000001uLL, 0x000000000747AE14uLL, 0x0000000000000232uLL, 0x0000000004A3D819uLL},
+{0x0000001000000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x0000000000000021uLL},
+{0x0000001000000001uLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x0000000000000001uLL},
+{0x0000001000000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x0000000000000031uLL},
+{0x0000001000000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x0000000000000021uLL},
+{0x0000001000000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x0000000000000011uLL},
+{0x0000001000000001uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000000000001uLL},
+{0x0000001000000001uLL, 0x0000000100000001uLL, 0x000000000000000FuLL, 0x00000000FFFFFFF2uLL},
+{0x0000001000000001uLL, 0x0000000100000002uLL, 0x000000000000000FuLL, 0x00000000FFFFFFE3uLL},
+{0x0000001000000001uLL, 0x0000000100000003uLL, 0x000000000000000FuLL, 0x00000000FFFFFFD4uLL},
+{0x0000001000000001uLL, 0x0000000100000010uLL, 0x000000000000000FuLL, 0x00000000FFFFFF11uLL},
+{0x0000001000000001uLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x000000008F21F55BuLL},
+{0x0000001000000001uLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x0000000092CCCCD5uLL},
+{0x0000001000000001uLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x000000010000000BuLL},
+{0x0000001000000001uLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x0000000100000001uLL},
+{0x0000001000000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000000000019uLL},
+{0x0000001000000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x0000000000000011uLL},
+{0x0000001000000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000000000009uLL},
+{0x0000001000000001uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x0000000000000001uLL},
+{0x0000001000000001uLL, 0x0000000200000001uLL, 0x0000000000000007uLL, 0x00000001FFFFFFFAuLL},
+{0x0000001000000001uLL, 0x0000000200000002uLL, 0x0000000000000007uLL, 0x00000001FFFFFFF3uLL},
+{0x0000001000000001uLL, 0x0000000200000003uLL, 0x0000000000000007uLL, 0x00000001FFFFFFECuLL},
+{0x0000001000000001uLL, 0x0000000200000010uLL, 0x0000000000000007uLL, 0x00000001FFFFFF91uLL},
+{0x0000001000000001uLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001CB541D2BuLL},
+{0x0000001000000001uLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001CD0A3D75uLL},
+{0x0000001000000001uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000100000007uLL},
+{0x0000001000000001uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x0000000100000001uLL},
+{0x0000001000000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x0000000100000010uLL},
+{0x0000001000000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000010000000BuLL},
+{0x0000001000000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000100000006uLL},
+{0x0000001000000001uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x0000000100000001uLL},
+{0x0000001000000001uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000000FFFFFFFCuLL},
+{0x0000001000000001uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF7uLL},
+{0x0000001000000001uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF2uLL},
+{0x0000001000000001uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000000FFFFFFB1uLL},
+{0x0000001000000001uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000DA60A71FuLL},
+{0x0000001000000001uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000DB99999DuLL},
+{0x0000001000000001uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000200000005uLL},
+{0x0000001000000001uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x0000000200000001uLL},
+{0x0000001000000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000000DuLL},
+{0x0000001000000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000000000009uLL},
+{0x0000001000000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000005uLL},
+{0x0000001000000001uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000001000000001uLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000001000000001uLL, 0x0000001000000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000001uLL},
+{0x0000001000000002uLL, 0x0000000000000001uLL, 0x0000001000000002uLL, 0x0000000000000000uLL},
+{0x0000001000000002uLL, 0x0000000000000002uLL, 0x0000000800000001uLL, 0x0000000000000000uLL},
+{0x0000001000000002uLL, 0x0000000000000003uLL, 0x0000000555555556uLL, 0x0000000000000000uLL},
+{0x0000001000000002uLL, 0x0000000000000010uLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0x0000001000000002uLL, 0x00000000078644FAuLL, 0x0000000000000220uLL, 0x0000000002AD6CC2uLL},
+{0x0000001000000002uLL, 0x000000000747AE14uLL, 0x0000000000000232uLL, 0x0000000004A3D81AuLL},
+{0x0000001000000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x0000000000000022uLL},
+{0x0000001000000002uLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x0000000000000002uLL},
+{0x0000001000000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x0000000000000032uLL},
+{0x0000001000000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x0000000000000022uLL},
+{0x0000001000000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x0000000000000012uLL},
+{0x0000001000000002uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000000000002uLL},
+{0x0000001000000002uLL, 0x0000000100000001uLL, 0x000000000000000FuLL, 0x00000000FFFFFFF3uLL},
+{0x0000001000000002uLL, 0x0000000100000002uLL, 0x000000000000000FuLL, 0x00000000FFFFFFE4uLL},
+{0x0000001000000002uLL, 0x0000000100000003uLL, 0x000000000000000FuLL, 0x00000000FFFFFFD5uLL},
+{0x0000001000000002uLL, 0x0000000100000010uLL, 0x000000000000000FuLL, 0x00000000FFFFFF12uLL},
+{0x0000001000000002uLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x000000008F21F55CuLL},
+{0x0000001000000002uLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x0000000092CCCCD6uLL},
+{0x0000001000000002uLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x000000010000000CuLL},
+{0x0000001000000002uLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x0000000100000002uLL},
+{0x0000001000000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x000000000000001AuLL},
+{0x0000001000000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x0000000000000012uLL},
+{0x0000001000000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x000000000000000AuLL},
+{0x0000001000000002uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x0000000000000002uLL},
+{0x0000001000000002uLL, 0x0000000200000001uLL, 0x0000000000000007uLL, 0x00000001FFFFFFFBuLL},
+{0x0000001000000002uLL, 0x0000000200000002uLL, 0x0000000000000007uLL, 0x00000001FFFFFFF4uLL},
+{0x0000001000000002uLL, 0x0000000200000003uLL, 0x0000000000000007uLL, 0x00000001FFFFFFEDuLL},
+{0x0000001000000002uLL, 0x0000000200000010uLL, 0x0000000000000007uLL, 0x00000001FFFFFF92uLL},
+{0x0000001000000002uLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001CB541D2CuLL},
+{0x0000001000000002uLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001CD0A3D76uLL},
+{0x0000001000000002uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000100000008uLL},
+{0x0000001000000002uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x0000000100000002uLL},
+{0x0000001000000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x0000000100000011uLL},
+{0x0000001000000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000010000000CuLL},
+{0x0000001000000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000100000007uLL},
+{0x0000001000000002uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x0000000100000002uLL},
+{0x0000001000000002uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000000FFFFFFFDuLL},
+{0x0000001000000002uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF8uLL},
+{0x0000001000000002uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF3uLL},
+{0x0000001000000002uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000000FFFFFFB2uLL},
+{0x0000001000000002uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000DA60A720uLL},
+{0x0000001000000002uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000DB99999EuLL},
+{0x0000001000000002uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000200000006uLL},
+{0x0000001000000002uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x0000000200000002uLL},
+{0x0000001000000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000000EuLL},
+{0x0000001000000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x000000000000000AuLL},
+{0x0000001000000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000006uLL},
+{0x0000001000000002uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000001000000002uLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000001000000002uLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000001000000002uLL, 0x0000001000000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000002uLL},
+{0x0000001000000003uLL, 0x0000000000000001uLL, 0x0000001000000003uLL, 0x0000000000000000uLL},
+{0x0000001000000003uLL, 0x0000000000000002uLL, 0x0000000800000001uLL, 0x0000000000000001uLL},
+{0x0000001000000003uLL, 0x0000000000000003uLL, 0x0000000555555556uLL, 0x0000000000000001uLL},
+{0x0000001000000003uLL, 0x0000000000000010uLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0x0000001000000003uLL, 0x00000000078644FAuLL, 0x0000000000000220uLL, 0x0000000002AD6CC3uLL},
+{0x0000001000000003uLL, 0x000000000747AE14uLL, 0x0000000000000232uLL, 0x0000000004A3D81BuLL},
+{0x0000001000000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x0000000000000023uLL},
+{0x0000001000000003uLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x0000000000000003uLL},
+{0x0000001000000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x0000000000000033uLL},
+{0x0000001000000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x0000000000000023uLL},
+{0x0000001000000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x0000000000000013uLL},
+{0x0000001000000003uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000000000003uLL},
+{0x0000001000000003uLL, 0x0000000100000001uLL, 0x000000000000000FuLL, 0x00000000FFFFFFF4uLL},
+{0x0000001000000003uLL, 0x0000000100000002uLL, 0x000000000000000FuLL, 0x00000000FFFFFFE5uLL},
+{0x0000001000000003uLL, 0x0000000100000003uLL, 0x000000000000000FuLL, 0x00000000FFFFFFD6uLL},
+{0x0000001000000003uLL, 0x0000000100000010uLL, 0x000000000000000FuLL, 0x00000000FFFFFF13uLL},
+{0x0000001000000003uLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x000000008F21F55DuLL},
+{0x0000001000000003uLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x0000000092CCCCD7uLL},
+{0x0000001000000003uLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x000000010000000DuLL},
+{0x0000001000000003uLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x0000000100000003uLL},
+{0x0000001000000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x000000000000001BuLL},
+{0x0000001000000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x0000000000000013uLL},
+{0x0000001000000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x000000000000000BuLL},
+{0x0000001000000003uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x0000000000000003uLL},
+{0x0000001000000003uLL, 0x0000000200000001uLL, 0x0000000000000007uLL, 0x00000001FFFFFFFCuLL},
+{0x0000001000000003uLL, 0x0000000200000002uLL, 0x0000000000000007uLL, 0x00000001FFFFFFF5uLL},
+{0x0000001000000003uLL, 0x0000000200000003uLL, 0x0000000000000007uLL, 0x00000001FFFFFFEEuLL},
+{0x0000001000000003uLL, 0x0000000200000010uLL, 0x0000000000000007uLL, 0x00000001FFFFFF93uLL},
+{0x0000001000000003uLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001CB541D2DuLL},
+{0x0000001000000003uLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001CD0A3D77uLL},
+{0x0000001000000003uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000100000009uLL},
+{0x0000001000000003uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x0000000100000003uLL},
+{0x0000001000000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x0000000100000012uLL},
+{0x0000001000000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000010000000DuLL},
+{0x0000001000000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000100000008uLL},
+{0x0000001000000003uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x0000000100000003uLL},
+{0x0000001000000003uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000000FFFFFFFEuLL},
+{0x0000001000000003uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF9uLL},
+{0x0000001000000003uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000000FFFFFFF4uLL},
+{0x0000001000000003uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000000FFFFFFB3uLL},
+{0x0000001000000003uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000DA60A721uLL},
+{0x0000001000000003uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000DB99999FuLL},
+{0x0000001000000003uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000200000007uLL},
+{0x0000001000000003uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x0000000200000003uLL},
+{0x0000001000000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000000FuLL},
+{0x0000001000000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x000000000000000BuLL},
+{0x0000001000000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000007uLL},
+{0x0000001000000003uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0000001000000003uLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0000001000000003uLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000001000000003uLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000001000000003uLL, 0x0000001000000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000003uLL},
+{0x0000001000000010uLL, 0x0000000000000001uLL, 0x0000001000000010uLL, 0x0000000000000000uLL},
+{0x0000001000000010uLL, 0x0000000000000002uLL, 0x0000000800000008uLL, 0x0000000000000000uLL},
+{0x0000001000000010uLL, 0x0000000000000003uLL, 0x000000055555555AuLL, 0x0000000000000002uLL},
+{0x0000001000000010uLL, 0x0000000000000010uLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x0000001000000010uLL, 0x00000000078644FAuLL, 0x0000000000000220uLL, 0x0000000002AD6CD0uLL},
+{0x0000001000000010uLL, 0x000000000747AE14uLL, 0x0000000000000232uLL, 0x0000000004A3D828uLL},
+{0x0000001000000010uLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x0000000000000030uLL},
+{0x0000001000000010uLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x0000000000000010uLL},
+{0x0000001000000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x0000000000000040uLL},
+{0x0000001000000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x0000000000000030uLL},
+{0x0000001000000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x0000000000000020uLL},
+{0x0000001000000010uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000000000010uLL},
+{0x0000001000000010uLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x0000000000000000uLL},
+{0x0000001000000010uLL, 0x0000000100000002uLL, 0x000000000000000FuLL, 0x00000000FFFFFFF2uLL},
+{0x0000001000000010uLL, 0x0000000100000003uLL, 0x000000000000000FuLL, 0x00000000FFFFFFE3uLL},
+{0x0000001000000010uLL, 0x0000000100000010uLL, 0x000000000000000FuLL, 0x00000000FFFFFF20uLL},
+{0x0000001000000010uLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x000000008F21F56AuLL},
+{0x0000001000000010uLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x0000000092CCCCE4uLL},
+{0x0000001000000010uLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x000000010000001AuLL},
+{0x0000001000000010uLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x0000000100000010uLL},
+{0x0000001000000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000000000028uLL},
+{0x0000001000000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x0000000000000020uLL},
+{0x0000001000000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000000000018uLL},
+{0x0000001000000010uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x0000000000000010uLL},
+{0x0000001000000010uLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x0000000000000008uLL},
+{0x0000001000000010uLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x0000000000000000uLL},
+{0x0000001000000010uLL, 0x0000000200000003uLL, 0x0000000000000007uLL, 0x00000001FFFFFFFBuLL},
+{0x0000001000000010uLL, 0x0000000200000010uLL, 0x0000000000000007uLL, 0x00000001FFFFFFA0uLL},
+{0x0000001000000010uLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001CB541D3AuLL},
+{0x0000001000000010uLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001CD0A3D84uLL},
+{0x0000001000000010uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000100000016uLL},
+{0x0000001000000010uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x0000000100000010uLL},
+{0x0000001000000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000010000001FuLL},
+{0x0000001000000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000010000001AuLL},
+{0x0000001000000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000100000015uLL},
+{0x0000001000000010uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x0000000100000010uLL},
+{0x0000001000000010uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x000000010000000BuLL},
+{0x0000001000000010uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x0000000100000006uLL},
+{0x0000001000000010uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x0000000100000001uLL},
+{0x0000001000000010uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000000FFFFFFC0uLL},
+{0x0000001000000010uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000DA60A72EuLL},
+{0x0000001000000010uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000DB9999ACuLL},
+{0x0000001000000010uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000200000014uLL},
+{0x0000001000000010uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x0000000200000010uLL},
+{0x0000001000000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000000001CuLL},
+{0x0000001000000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000000000018uLL},
+{0x0000001000000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000000000014uLL},
+{0x0000001000000010uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x0000001000000010uLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x0000001000000010uLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x0000001000000010uLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x0000001000000010uLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000001000000010uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x0000001000000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001000000010uLL},
+{0x00000010078644FAuLL, 0x0000000000000001uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL},
+{0x00000010078644FAuLL, 0x0000000000000002uLL, 0x0000000803C3227DuLL, 0x0000000000000000uLL},
+{0x00000010078644FAuLL, 0x0000000000000003uLL, 0x0000000557D76C53uLL, 0x0000000000000001uLL},
+{0x00000010078644FAuLL, 0x0000000000000010uLL, 0x000000010078644FuLL, 0x000000000000000AuLL},
+{0x00000010078644FAuLL, 0x00000000078644FAuLL, 0x0000000000000221uLL, 0x0000000002AD6CC0uLL},
+{0x00000010078644FAuLL, 0x000000000747AE14uLL, 0x0000000000000233uLL, 0x0000000004E26EFEuLL},
+{0x00000010078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x000000000786451AuLL},
+{0x00000010078644FAuLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x00000000078644FAuLL},
+{0x00000010078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000000786452AuLL},
+{0x00000010078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000000786451AuLL},
+{0x00000010078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000000786450AuLL},
+{0x00000010078644FAuLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x00000000078644FAuLL},
+{0x00000010078644FAuLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x00000000078644EAuLL},
+{0x00000010078644FAuLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x00000000078644DAuLL},
+{0x00000010078644FAuLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x00000000078644CAuLL},
+{0x00000010078644FAuLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x00000000078643FAuLL},
+{0x00000010078644FAuLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x0000000096A83A54uLL},
+{0x00000010078644FAuLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x000000009A5311CEuLL},
+{0x00000010078644FAuLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x0000000107864504uLL},
+{0x00000010078644FAuLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x00000001078644FAuLL},
+{0x00000010078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000007864512uLL},
+{0x00000010078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x000000000786450AuLL},
+{0x00000010078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000007864502uLL},
+{0x00000010078644FAuLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x00000000078644FAuLL},
+{0x00000010078644FAuLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x00000000078644F2uLL},
+{0x00000010078644FAuLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x00000000078644EAuLL},
+{0x00000010078644FAuLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x00000000078644E2uLL},
+{0x00000010078644FAuLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x000000000786447AuLL},
+{0x00000010078644FAuLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001D2DA6224uLL},
+{0x00000010078644FAuLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001D490826EuLL},
+{0x00000010078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000107864500uLL},
+{0x00000010078644FAuLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x00000001078644FAuLL},
+{0x00000010078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x0000000107864509uLL},
+{0x00000010078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x0000000107864504uLL},
+{0x00000010078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x00000001078644FFuLL},
+{0x00000010078644FAuLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x00000001078644FAuLL},
+{0x00000010078644FAuLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000001078644F5uLL},
+{0x00000010078644FAuLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000001078644F0uLL},
+{0x00000010078644FAuLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000001078644EBuLL},
+{0x00000010078644FAuLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000001078644AAuLL},
+{0x00000010078644FAuLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000E1E6EC18uLL},
+{0x00000010078644FAuLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000E31FDE96uLL},
+{0x00000010078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x00000002078644FEuLL},
+{0x00000010078644FAuLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x00000002078644FAuLL},
+{0x00000010078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x0000000007864506uLL},
+{0x00000010078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000007864502uLL},
+{0x00000010078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x00000000078644FEuLL},
+{0x00000010078644FAuLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x00000010078644FAuLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x00000010078644FAuLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x00000010078644FAuLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x00000010078644FAuLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x00000010078644FAuLL, 0x00000010078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000010078644FAuLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x00000010078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x00000010078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010078644FAuLL},
+{0x000000100747AE14uLL, 0x0000000000000001uLL, 0x000000100747AE14uLL, 0x0000000000000000uLL},
+{0x000000100747AE14uLL, 0x0000000000000002uLL, 0x0000000803A3D70AuLL, 0x0000000000000000uLL},
+{0x000000100747AE14uLL, 0x0000000000000003uLL, 0x0000000557C28F5CuLL, 0x0000000000000000uLL},
+{0x000000100747AE14uLL, 0x0000000000000010uLL, 0x0000000100747AE1uLL, 0x0000000000000004uLL},
+{0x000000100747AE14uLL, 0x00000000078644FAuLL, 0x0000000000000221uLL, 0x00000000026ED5DAuLL},
+{0x000000100747AE14uLL, 0x000000000747AE14uLL, 0x0000000000000233uLL, 0x0000000004A3D818uLL},
+{0x000000100747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000000000020uLL, 0x000000000747AE34uLL},
+{0x000000100747AE14uLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x000000000747AE14uLL},
+{0x000000100747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000000747AE44uLL},
+{0x000000100747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000000747AE34uLL},
+{0x000000100747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000000747AE24uLL},
+{0x000000100747AE14uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x000000000747AE14uLL},
+{0x000000100747AE14uLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x000000000747AE04uLL},
+{0x000000100747AE14uLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x000000000747ADF4uLL},
+{0x000000100747AE14uLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x000000000747ADE4uLL},
+{0x000000100747AE14uLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x000000000747AD14uLL},
+{0x000000100747AE14uLL, 0x00000001078644FAuLL, 0x000000000000000FuLL, 0x000000009669A36EuLL},
+{0x000000100747AE14uLL, 0x000000010747AE14uLL, 0x000000000000000FuLL, 0x000000009A147AE8uLL},
+{0x000000100747AE14uLL, 0x000000017FFFFFFFuLL, 0x000000000000000AuLL, 0x000000010747AE1EuLL},
+{0x000000100747AE14uLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x000000010747AE14uLL},
+{0x000000100747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x000000000747AE2CuLL},
+{0x000000100747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x000000000747AE24uLL},
+{0x000000100747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x000000000747AE1CuLL},
+{0x000000100747AE14uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x000000000747AE14uLL},
+{0x000000100747AE14uLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x000000000747AE0CuLL},
+{0x000000100747AE14uLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x000000000747AE04uLL},
+{0x000000100747AE14uLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x000000000747ADFCuLL},
+{0x000000100747AE14uLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x000000000747AD94uLL},
+{0x000000100747AE14uLL, 0x00000002078644FAuLL, 0x0000000000000007uLL, 0x00000001D29BCB3EuLL},
+{0x000000100747AE14uLL, 0x000000020747AE14uLL, 0x0000000000000007uLL, 0x00000001D451EB88uLL},
+{0x000000100747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x000000010747AE1AuLL},
+{0x000000100747AE14uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x000000010747AE14uLL},
+{0x000000100747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000010747AE23uLL},
+{0x000000100747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000010747AE1EuLL},
+{0x000000100747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x000000010747AE19uLL},
+{0x000000100747AE14uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x000000010747AE14uLL},
+{0x000000100747AE14uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x000000010747AE0FuLL},
+{0x000000100747AE14uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x000000010747AE0AuLL},
+{0x000000100747AE14uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x000000010747AE05uLL},
+{0x000000100747AE14uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x000000010747ADC4uLL},
+{0x000000100747AE14uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000000E1A85532uLL},
+{0x000000100747AE14uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000000E2E147B0uLL},
+{0x000000100747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x000000020747AE18uLL},
+{0x000000100747AE14uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x000000020747AE14uLL},
+{0x000000100747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000000747AE20uLL},
+{0x000000100747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x000000000747AE1CuLL},
+{0x000000100747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x000000000747AE18uLL},
+{0x000000100747AE14uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x000000100747AE14uLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x000000100747AE14uLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x000000100747AE14uLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x000000100747AE14uLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x000000100747AE14uLL, 0x00000010078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000100747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000100747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000100747AE14uLL},
+{0x000000107FFFFFFFuLL, 0x0000000000000001uLL, 0x000000107FFFFFFFuLL, 0x0000000000000000uLL},
+{0x000000107FFFFFFFuLL, 0x0000000000000002uLL, 0x000000083FFFFFFFuLL, 0x0000000000000001uLL},
+{0x000000107FFFFFFFuLL, 0x0000000000000003uLL, 0x000000057FFFFFFFuLL, 0x0000000000000002uLL},
+{0x000000107FFFFFFFuLL, 0x0000000000000010uLL, 0x0000000107FFFFFFuLL, 0x000000000000000FuLL},
+{0x000000107FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000231uLL, 0x0000000002C2D825uLL},
+{0x000000107FFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000244uLL, 0x0000000001999AAFuLL},
+{0x000000107FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000021uLL, 0x0000000000000020uLL},
+{0x000000107FFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000020uLL, 0x000000007FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000008000002FuLL},
+{0x000000107FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000008000001FuLL},
+{0x000000107FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000008000000FuLL},
+{0x000000107FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x000000007FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x000000007FFFFFEFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x000000007FFFFFDFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x000000007FFFFFCFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x000000007FFFFEFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000010uLL, 0x00000000079BB05FuLL},
+{0x000000107FFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000010uLL, 0x000000000B851EBFuLL},
+{0x000000107FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x000000000000000BuLL, 0x000000000000000AuLL},
+{0x000000107FFFFFFFuLL, 0x0000000180000000uLL, 0x000000000000000AuLL, 0x000000017FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000080000017uLL},
+{0x000000107FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x000000008000000FuLL},
+{0x000000107FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000080000007uLL},
+{0x000000107FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x000000007FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x000000007FFFFFF7uLL},
+{0x000000107FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x000000007FFFFFEFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x000000007FFFFFE7uLL},
+{0x000000107FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x000000007FFFFF7FuLL},
+{0x000000107FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000008uLL, 0x0000000043CDD82FuLL},
+{0x000000107FFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000008uLL, 0x0000000045C28F5FuLL},
+{0x000000107FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000180000005uLL},
+{0x000000107FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x000000017FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000018000000EuLL},
+{0x000000107FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x0000000180000009uLL},
+{0x000000107FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000180000004uLL},
+{0x000000107FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x000000017FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x000000017FFFFFFAuLL},
+{0x000000107FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x000000017FFFFFF5uLL},
+{0x000000107FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x000000017FFFFFF0uLL},
+{0x000000107FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x000000017FFFFFAFuLL},
+{0x000000107FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x000000015A60A71DuLL},
+{0x000000107FFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x000000015B99999BuLL},
+{0x000000107FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000280000003uLL},
+{0x000000107FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x000000027FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000008000000BuLL},
+{0x000000107FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000080000007uLL},
+{0x000000107FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000080000003uLL},
+{0x000000107FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x000000107FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x000000107FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x000000107FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x000000107FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x000000107FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x000000107FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x000000107FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x000000107FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x000000107FFFFFFFuLL},
+{0x0000001080000000uLL, 0x0000000000000001uLL, 0x0000001080000000uLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x0000000000000002uLL, 0x0000000840000000uLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x0000000000000003uLL, 0x0000000580000000uLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x0000000000000010uLL, 0x0000000108000000uLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x00000000078644FAuLL, 0x0000000000000231uLL, 0x0000000002C2D826uLL},
+{0x0000001080000000uLL, 0x000000000747AE14uLL, 0x0000000000000244uLL, 0x0000000001999AB0uLL},
+{0x0000001080000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000021uLL, 0x0000000000000021uLL},
+{0x0000001080000000uLL, 0x0000000080000000uLL, 0x0000000000000021uLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x0000000080000030uLL},
+{0x0000001080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x0000000080000020uLL},
+{0x0000001080000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x0000000080000010uLL},
+{0x0000001080000000uLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x0000000080000000uLL},
+{0x0000001080000000uLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x000000007FFFFFF0uLL},
+{0x0000001080000000uLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x000000007FFFFFE0uLL},
+{0x0000001080000000uLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x000000007FFFFFD0uLL},
+{0x0000001080000000uLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x000000007FFFFF00uLL},
+{0x0000001080000000uLL, 0x00000001078644FAuLL, 0x0000000000000010uLL, 0x00000000079BB060uLL},
+{0x0000001080000000uLL, 0x000000010747AE14uLL, 0x0000000000000010uLL, 0x000000000B851EC0uLL},
+{0x0000001080000000uLL, 0x000000017FFFFFFFuLL, 0x000000000000000BuLL, 0x000000000000000BuLL},
+{0x0000001080000000uLL, 0x0000000180000000uLL, 0x000000000000000BuLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000080000018uLL},
+{0x0000001080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x0000000080000010uLL},
+{0x0000001080000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000080000008uLL},
+{0x0000001080000000uLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x0000000080000000uLL},
+{0x0000001080000000uLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x000000007FFFFFF8uLL},
+{0x0000001080000000uLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x000000007FFFFFF0uLL},
+{0x0000001080000000uLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x000000007FFFFFE8uLL},
+{0x0000001080000000uLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x000000007FFFFF80uLL},
+{0x0000001080000000uLL, 0x00000002078644FAuLL, 0x0000000000000008uLL, 0x0000000043CDD830uLL},
+{0x0000001080000000uLL, 0x000000020747AE14uLL, 0x0000000000000008uLL, 0x0000000045C28F60uLL},
+{0x0000001080000000uLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000180000006uLL},
+{0x0000001080000000uLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x0000000180000000uLL},
+{0x0000001080000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000018000000FuLL},
+{0x0000001080000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x000000018000000AuLL},
+{0x0000001080000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000180000005uLL},
+{0x0000001080000000uLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x0000000180000000uLL},
+{0x0000001080000000uLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x000000017FFFFFFBuLL},
+{0x0000001080000000uLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x000000017FFFFFF6uLL},
+{0x0000001080000000uLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x000000017FFFFFF1uLL},
+{0x0000001080000000uLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x000000017FFFFFB0uLL},
+{0x0000001080000000uLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x000000015A60A71EuLL},
+{0x0000001080000000uLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x000000015B99999CuLL},
+{0x0000001080000000uLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000280000004uLL},
+{0x0000001080000000uLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x0000000280000000uLL},
+{0x0000001080000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000008000000CuLL},
+{0x0000001080000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000080000008uLL},
+{0x0000001080000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000080000004uLL},
+{0x0000001080000000uLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0000001080000000uLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0000001080000000uLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0000001080000000uLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0000001080000000uLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x0000001080000000uLL, 0x00000010078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x0000001080000000uLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x0000001080000000uLL, 0x000000107FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0000001080000000uLL, 0x0000001080000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0000001080000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x0000001080000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0000001080000000uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000000000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000000000002uLL, 0x000000087FFFFFFEuLL, 0x0000000000000001uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000000000003uLL, 0x00000005AAAAAAA9uLL, 0x0000000000000002uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000000000010uLL, 0x000000010FFFFFFFuLL, 0x000000000000000DuLL},
+{0x00000010FFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000000000000242uLL, 0x0000000002D84389uLL},
+{0x00000010FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000000000255uLL, 0x0000000005D70B59uLL},
+{0x00000010FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000000000022uLL, 0x000000000000001FuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000000000021uLL, 0x000000007FFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000011uLL, 0x0000000000000030uLL},
+{0x00000010FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000011uLL, 0x000000000000001FuLL},
+{0x00000010FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000011uLL, 0x000000000000000EuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x00000000FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x00000000FFFFFFEDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x00000000FFFFFFDDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x00000000FFFFFFCDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x00000000FFFFFEFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000001078644FAuLL, 0x0000000000000010uLL, 0x00000000879BB05DuLL},
+{0x00000010FFFFFFFDuLL, 0x000000010747AE14uLL, 0x0000000000000010uLL, 0x000000008B851EBDuLL},
+{0x00000010FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x000000000000000BuLL, 0x0000000080000008uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000180000000uLL, 0x000000000000000BuLL, 0x000000007FFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000100000015uLL},
+{0x00000010FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x000000010000000DuLL},
+{0x00000010FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000100000005uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x00000000FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x00000000FFFFFFF5uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x00000000FFFFFFEDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x00000000FFFFFFE5uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x00000000FFFFFF7DuLL},
+{0x00000010FFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000000000008uLL, 0x00000000C3CDD82DuLL},
+{0x00000010FFFFFFFDuLL, 0x000000020747AE14uLL, 0x0000000000000008uLL, 0x00000000C5C28F5DuLL},
+{0x00000010FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000200000003uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x00000001FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000020000000CuLL},
+{0x00000010FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x0000000200000007uLL},
+{0x00000010FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000200000002uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x00000001FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000001FFFFFFF8uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000001FFFFFFF3uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000001FFFFFFEEuLL},
+{0x00000010FFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000001FFFFFFADuLL},
+{0x00000010FFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000001DA60A71BuLL},
+{0x00000010FFFFFFFDuLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000001DB999999uLL},
+{0x00000010FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000300000001uLL},
+{0x00000010FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x00000002FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x0000000100000009uLL},
+{0x00000010FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000100000005uLL},
+{0x00000010FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000100000001uLL},
+{0x00000010FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000010FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000010FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x00000010FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x00000010FFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x00000010FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000010FFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFDuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000000000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000000000002uLL, 0x000000087FFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000000000003uLL, 0x00000005AAAAAAAAuLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000000000010uLL, 0x000000010FFFFFFFuLL, 0x000000000000000EuLL},
+{0x00000010FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000000000242uLL, 0x0000000002D8438AuLL},
+{0x00000010FFFFFFFEuLL, 0x000000000747AE14uLL, 0x0000000000000255uLL, 0x0000000005D70B5AuLL},
+{0x00000010FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000022uLL, 0x0000000000000020uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000021uLL, 0x000000007FFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000011uLL, 0x0000000000000031uLL},
+{0x00000010FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000011uLL, 0x0000000000000020uLL},
+{0x00000010FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000011uLL, 0x000000000000000FuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x00000000FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x00000000FFFFFFEEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x00000000FFFFFFDEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x00000000FFFFFFCEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x00000000FFFFFEFEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000001078644FAuLL, 0x0000000000000010uLL, 0x00000000879BB05EuLL},
+{0x00000010FFFFFFFEuLL, 0x000000010747AE14uLL, 0x0000000000000010uLL, 0x000000008B851EBEuLL},
+{0x00000010FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x000000000000000BuLL, 0x0000000080000009uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000180000000uLL, 0x000000000000000BuLL, 0x000000007FFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000100000016uLL},
+{0x00000010FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x000000010000000EuLL},
+{0x00000010FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000100000006uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x00000000FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x00000000FFFFFFF6uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x00000000FFFFFFEEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x00000000FFFFFFE6uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x00000000FFFFFF7EuLL},
+{0x00000010FFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000000000008uLL, 0x00000000C3CDD82EuLL},
+{0x00000010FFFFFFFEuLL, 0x000000020747AE14uLL, 0x0000000000000008uLL, 0x00000000C5C28F5EuLL},
+{0x00000010FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000200000004uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x00000001FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000020000000DuLL},
+{0x00000010FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x0000000200000008uLL},
+{0x00000010FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000200000003uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x00000001FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000001FFFFFFF9uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000001FFFFFFF4uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000001FFFFFFEFuLL},
+{0x00000010FFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000001FFFFFFAEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000001DA60A71CuLL},
+{0x00000010FFFFFFFEuLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000001DB99999AuLL},
+{0x00000010FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000300000002uLL},
+{0x00000010FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x00000002FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000010000000AuLL},
+{0x00000010FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000100000006uLL},
+{0x00000010FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000100000002uLL},
+{0x00000010FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000010FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000010FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x00000010FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x00000010FFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x00000010FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000010FFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000010FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFEuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000000000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000000000002uLL, 0x000000087FFFFFFFuLL, 0x0000000000000001uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000000000003uLL, 0x00000005AAAAAAAAuLL, 0x0000000000000001uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000000000010uLL, 0x000000010FFFFFFFuLL, 0x000000000000000FuLL},
+{0x00000010FFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000000000242uLL, 0x0000000002D8438BuLL},
+{0x00000010FFFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000000000255uLL, 0x0000000005D70B5BuLL},
+{0x00000010FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000000000022uLL, 0x0000000000000021uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000021uLL, 0x000000007FFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000000000011uLL, 0x0000000000000032uLL},
+{0x00000010FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000011uLL, 0x0000000000000021uLL},
+{0x00000010FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000011uLL, 0x0000000000000010uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000010uLL, 0x00000000FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000010uLL, 0x00000000FFFFFFEFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000010uLL, 0x00000000FFFFFFDFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000010uLL, 0x00000000FFFFFFCFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000100000010uLL, 0x0000000000000010uLL, 0x00000000FFFFFEFFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000000000010uLL, 0x00000000879BB05FuLL},
+{0x00000010FFFFFFFFuLL, 0x000000010747AE14uLL, 0x0000000000000010uLL, 0x000000008B851EBFuLL},
+{0x00000010FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x000000000000000BuLL, 0x000000008000000AuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000180000000uLL, 0x000000000000000BuLL, 0x000000007FFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000000000008uLL, 0x0000000100000017uLL},
+{0x00000010FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000008uLL, 0x000000010000000FuLL},
+{0x00000010FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000000000008uLL, 0x0000000100000007uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000008uLL, 0x00000000FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000008uLL, 0x00000000FFFFFFF7uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000008uLL, 0x00000000FFFFFFEFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000008uLL, 0x00000000FFFFFFE7uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000000000008uLL, 0x00000000FFFFFF7FuLL},
+{0x00000010FFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000000000008uLL, 0x00000000C3CDD82FuLL},
+{0x00000010FFFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000000000008uLL, 0x00000000C5C28F5FuLL},
+{0x00000010FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000000000006uLL, 0x0000000200000005uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000000000006uLL, 0x00000001FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000000000005uLL, 0x000000020000000EuLL},
+{0x00000010FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000000000005uLL, 0x0000000200000009uLL},
+{0x00000010FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000000000005uLL, 0x0000000200000004uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000000000005uLL, 0x00000001FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000000000005uLL, 0x00000001FFFFFFFAuLL},
+{0x00000010FFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000000000005uLL, 0x00000001FFFFFFF5uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000000000005uLL, 0x00000001FFFFFFF0uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000000000005uLL, 0x00000001FFFFFFAFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000000000005uLL, 0x00000001DA60A71DuLL},
+{0x00000010FFFFFFFFuLL, 0x000000030747AE14uLL, 0x0000000000000005uLL, 0x00000001DB99999BuLL},
+{0x00000010FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000000000004uLL, 0x0000000300000003uLL},
+{0x00000010FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000000000004uLL, 0x00000002FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000000000004uLL, 0x000000010000000BuLL},
+{0x00000010FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000000000004uLL, 0x0000000100000007uLL},
+{0x00000010FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000000000004uLL, 0x0000000100000003uLL},
+{0x00000010FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x00000010FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x00000010FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x00000010FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x00000010FFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x00000010FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x00000010FFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x00000010FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x00000010FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x00000010FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x00000010FFFFFFFFuLL},
+{0x078644FA00000000uLL, 0x0000000000000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x0000000000000002uLL, 0x03C3227D00000000uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x0000000000000003uLL, 0x028216FE00000000uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x0000000000000010uLL, 0x0078644FA0000000uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x00000000078644FAuLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x000000000747AE14uLL, 0x000000010898F295uLL, 0x0000000004D8C65CuLL},
+{0x078644FA00000000uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x000000000F0C89F4uLL},
+{0x078644FA00000000uLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001692CEEEuLL},
+{0x078644FA00000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000000F0C89F4uLL},
+{0x078644FA00000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000078644FAuLL},
+{0x078644FA00000000uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x0000000100000001uLL, 0x00000000078644F9uLL, 0x00000000F879BB07uLL},
+{0x078644FA00000000uLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F0F3760EuLL},
+{0x078644FA00000000uLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000E96D3115uLL},
+{0x078644FA00000000uLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x00000000879BB070uLL},
+{0x078644FA00000000uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x000000006C09ACD2uLL},
+{0x078644FA00000000uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000082B63E28uLL},
+{0x078644FA00000000uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000005042DFCuLL},
+{0x078644FA00000000uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000000B496777uLL},
+{0x078644FA00000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000000078644FAuLL},
+{0x078644FA00000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000003C3227DuLL},
+{0x078644FA00000000uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x0000000200000001uLL, 0x0000000003C3227CuLL, 0x00000001FC3CDD84uLL},
+{0x078644FA00000000uLL, 0x0000000200000002uLL, 0x0000000003C3227CuLL, 0x00000001F879BB08uLL},
+{0x078644FA00000000uLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001F4B6988CuLL},
+{0x078644FA00000000uLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001C3CDD840uLL},
+{0x078644FA00000000uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000181754582uLL},
+{0x078644FA00000000uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x000000019B4CF184uLL},
+{0x078644FA00000000uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x00000001830281FDuLL},
+{0x078644FA00000000uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x0000000180000000uLL},
+{0x078644FA00000000uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000000078644FAuLL},
+{0x078644FA00000000uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000005042DFCuLL},
+{0x078644FA00000000uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000000028216FEuLL},
+{0x078644FA00000000uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x0000000300000001uLL, 0x00000000028216FDuLL, 0x00000002FD7DE903uLL},
+{0x078644FA00000000uLL, 0x0000000300000002uLL, 0x00000000028216FDuLL, 0x00000002FAFBD206uLL},
+{0x078644FA00000000uLL, 0x0000000300000003uLL, 0x00000000028216FDuLL, 0x00000002F879BB09uLL},
+{0x078644FA00000000uLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002D7DE9030uLL},
+{0x078644FA00000000uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x0000000266ACEAE4uLL},
+{0x078644FA00000000uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000CC648250uLL},
+{0x078644FA00000000uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000282265CD9uLL},
+{0x078644FA00000000uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x0000000280000000uLL},
+{0x078644FA00000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000205A4B3BAuLL},
+{0x078644FA00000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000203C3227CuLL},
+{0x078644FA00000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000201E1913EuLL},
+{0x078644FA00000000uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A00000000uLL},
+{0x078644FA00000000uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x00000009FF879BB1uLL},
+{0x078644FA00000000uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x00000009FF0F3762uLL},
+{0x078644FA00000000uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x00000009FE96D313uLL},
+{0x078644FA00000000uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x00000009F879BB10uLL},
+{0x078644FA00000000uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000001E3B0AC8uLL},
+{0x078644FA00000000uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000438F2016CuLL},
+{0x078644FA00000000uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C0074BE5CuLL},
+{0x078644FA00000000uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C00000000uLL},
+{0x078644FA00000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000000153EE0EuLL},
+{0x078644FA00000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000000E29EB4uLL},
+{0x078644FA00000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000000714F5AuLL},
+{0x078644FA00000000uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA00000000uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFFuLL},
+{0x078644FA00000000uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFEuLL},
+{0x078644FA00000000uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFDuLL},
+{0x078644FA00000000uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFF0uLL},
+{0x078644FA00000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E5F879BB06uLL},
+{0x078644FA00000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E5F8B851ECuLL},
+{0x078644FA00000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000001uLL},
+{0x078644FA00000000uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E580000000uLL},
+{0x078644FA00000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E500000003uLL},
+{0x078644FA00000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E500000002uLL},
+{0x078644FA00000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E500000001uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000000uLL},
+{0x078644FA00000001uLL, 0x0000000000000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000001uLL, 0x0000000000000002uLL, 0x03C3227D00000000uLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x0000000000000003uLL, 0x028216FE00000000uLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x0000000000000010uLL, 0x0078644FA0000000uLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x00000000078644FAuLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x000000000747AE14uLL, 0x000000010898F295uLL, 0x0000000004D8C65DuLL},
+{0x078644FA00000001uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x000000000F0C89F5uLL},
+{0x078644FA00000001uLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001692CEEFuLL},
+{0x078644FA00000001uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000000F0C89F5uLL},
+{0x078644FA00000001uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000078644FBuLL},
+{0x078644FA00000001uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x0000000100000001uLL, 0x00000000078644F9uLL, 0x00000000F879BB08uLL},
+{0x078644FA00000001uLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F0F3760FuLL},
+{0x078644FA00000001uLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000E96D3116uLL},
+{0x078644FA00000001uLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x00000000879BB071uLL},
+{0x078644FA00000001uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x000000006C09ACD3uLL},
+{0x078644FA00000001uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000082B63E29uLL},
+{0x078644FA00000001uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000005042DFDuLL},
+{0x078644FA00000001uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000000B496778uLL},
+{0x078644FA00000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000000078644FBuLL},
+{0x078644FA00000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000003C3227EuLL},
+{0x078644FA00000001uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x0000000200000001uLL, 0x0000000003C3227CuLL, 0x00000001FC3CDD85uLL},
+{0x078644FA00000001uLL, 0x0000000200000002uLL, 0x0000000003C3227CuLL, 0x00000001F879BB09uLL},
+{0x078644FA00000001uLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001F4B6988DuLL},
+{0x078644FA00000001uLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001C3CDD841uLL},
+{0x078644FA00000001uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000181754583uLL},
+{0x078644FA00000001uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x000000019B4CF185uLL},
+{0x078644FA00000001uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x00000001830281FEuLL},
+{0x078644FA00000001uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x0000000180000001uLL},
+{0x078644FA00000001uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000000078644FBuLL},
+{0x078644FA00000001uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000005042DFDuLL},
+{0x078644FA00000001uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000000028216FFuLL},
+{0x078644FA00000001uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x0000000300000001uLL, 0x00000000028216FDuLL, 0x00000002FD7DE904uLL},
+{0x078644FA00000001uLL, 0x0000000300000002uLL, 0x00000000028216FDuLL, 0x00000002FAFBD207uLL},
+{0x078644FA00000001uLL, 0x0000000300000003uLL, 0x00000000028216FDuLL, 0x00000002F879BB0AuLL},
+{0x078644FA00000001uLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002D7DE9031uLL},
+{0x078644FA00000001uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x0000000266ACEAE5uLL},
+{0x078644FA00000001uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000CC648251uLL},
+{0x078644FA00000001uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000282265CDAuLL},
+{0x078644FA00000001uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x0000000280000001uLL},
+{0x078644FA00000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000205A4B3BBuLL},
+{0x078644FA00000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000203C3227DuLL},
+{0x078644FA00000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000201E1913FuLL},
+{0x078644FA00000001uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A00000001uLL},
+{0x078644FA00000001uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x00000009FF879BB2uLL},
+{0x078644FA00000001uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x00000009FF0F3763uLL},
+{0x078644FA00000001uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x00000009FE96D314uLL},
+{0x078644FA00000001uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x00000009F879BB11uLL},
+{0x078644FA00000001uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000001E3B0AC9uLL},
+{0x078644FA00000001uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000438F2016DuLL},
+{0x078644FA00000001uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C0074BE5DuLL},
+{0x078644FA00000001uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C00000001uLL},
+{0x078644FA00000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000000153EE0FuLL},
+{0x078644FA00000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000000E29EB5uLL},
+{0x078644FA00000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000000714F5BuLL},
+{0x078644FA00000001uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x078644FA00000001uLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E600000001uLL},
+{0x078644FA00000001uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA00000001uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFFuLL},
+{0x078644FA00000001uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFEuLL},
+{0x078644FA00000001uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFF1uLL},
+{0x078644FA00000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E5F879BB07uLL},
+{0x078644FA00000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E5F8B851EDuLL},
+{0x078644FA00000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000002uLL},
+{0x078644FA00000001uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E580000001uLL},
+{0x078644FA00000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E500000004uLL},
+{0x078644FA00000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E500000003uLL},
+{0x078644FA00000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E500000002uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000001uLL},
+{0x078644FA00000002uLL, 0x0000000000000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL},
+{0x078644FA00000002uLL, 0x0000000000000002uLL, 0x03C3227D00000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000002uLL, 0x0000000000000003uLL, 0x028216FE00000000uLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x0000000000000010uLL, 0x0078644FA0000000uLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x00000000078644FAuLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x000000000747AE14uLL, 0x000000010898F295uLL, 0x0000000004D8C65EuLL},
+{0x078644FA00000002uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x000000000F0C89F6uLL},
+{0x078644FA00000002uLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001692CEF0uLL},
+{0x078644FA00000002uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000000F0C89F6uLL},
+{0x078644FA00000002uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000078644FCuLL},
+{0x078644FA00000002uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x0000000100000001uLL, 0x00000000078644F9uLL, 0x00000000F879BB09uLL},
+{0x078644FA00000002uLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F0F37610uLL},
+{0x078644FA00000002uLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000E96D3117uLL},
+{0x078644FA00000002uLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x00000000879BB072uLL},
+{0x078644FA00000002uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x000000006C09ACD4uLL},
+{0x078644FA00000002uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000082B63E2AuLL},
+{0x078644FA00000002uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000005042DFEuLL},
+{0x078644FA00000002uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000000B496779uLL},
+{0x078644FA00000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000000078644FCuLL},
+{0x078644FA00000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000003C3227FuLL},
+{0x078644FA00000002uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x0000000200000001uLL, 0x0000000003C3227CuLL, 0x00000001FC3CDD86uLL},
+{0x078644FA00000002uLL, 0x0000000200000002uLL, 0x0000000003C3227CuLL, 0x00000001F879BB0AuLL},
+{0x078644FA00000002uLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001F4B6988EuLL},
+{0x078644FA00000002uLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001C3CDD842uLL},
+{0x078644FA00000002uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000181754584uLL},
+{0x078644FA00000002uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x000000019B4CF186uLL},
+{0x078644FA00000002uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x00000001830281FFuLL},
+{0x078644FA00000002uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x0000000180000002uLL},
+{0x078644FA00000002uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000000078644FCuLL},
+{0x078644FA00000002uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000005042DFEuLL},
+{0x078644FA00000002uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x0000000002821700uLL},
+{0x078644FA00000002uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x0000000300000001uLL, 0x00000000028216FDuLL, 0x00000002FD7DE905uLL},
+{0x078644FA00000002uLL, 0x0000000300000002uLL, 0x00000000028216FDuLL, 0x00000002FAFBD208uLL},
+{0x078644FA00000002uLL, 0x0000000300000003uLL, 0x00000000028216FDuLL, 0x00000002F879BB0BuLL},
+{0x078644FA00000002uLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002D7DE9032uLL},
+{0x078644FA00000002uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x0000000266ACEAE6uLL},
+{0x078644FA00000002uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000CC648252uLL},
+{0x078644FA00000002uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000282265CDBuLL},
+{0x078644FA00000002uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x0000000280000002uLL},
+{0x078644FA00000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000205A4B3BCuLL},
+{0x078644FA00000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000203C3227EuLL},
+{0x078644FA00000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000201E19140uLL},
+{0x078644FA00000002uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A00000002uLL},
+{0x078644FA00000002uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x00000009FF879BB3uLL},
+{0x078644FA00000002uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x00000009FF0F3764uLL},
+{0x078644FA00000002uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x00000009FE96D315uLL},
+{0x078644FA00000002uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x00000009F879BB12uLL},
+{0x078644FA00000002uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000001E3B0ACAuLL},
+{0x078644FA00000002uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000438F2016EuLL},
+{0x078644FA00000002uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C0074BE5EuLL},
+{0x078644FA00000002uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C00000002uLL},
+{0x078644FA00000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000000153EE10uLL},
+{0x078644FA00000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000000E29EB6uLL},
+{0x078644FA00000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000000714F5CuLL},
+{0x078644FA00000002uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x078644FA00000002uLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x078644FA00000002uLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E600000002uLL},
+{0x078644FA00000002uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E600000001uLL},
+{0x078644FA00000002uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA00000002uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFFuLL},
+{0x078644FA00000002uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFF2uLL},
+{0x078644FA00000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E5F879BB08uLL},
+{0x078644FA00000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E5F8B851EEuLL},
+{0x078644FA00000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000003uLL},
+{0x078644FA00000002uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E580000002uLL},
+{0x078644FA00000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E500000005uLL},
+{0x078644FA00000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E500000004uLL},
+{0x078644FA00000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E500000003uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000002uLL},
+{0x078644FA00000003uLL, 0x0000000000000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL},
+{0x078644FA00000003uLL, 0x0000000000000002uLL, 0x03C3227D00000001uLL, 0x0000000000000001uLL},
+{0x078644FA00000003uLL, 0x0000000000000003uLL, 0x028216FE00000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000003uLL, 0x0000000000000010uLL, 0x0078644FA0000000uLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x00000000078644FAuLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x000000000747AE14uLL, 0x000000010898F295uLL, 0x0000000004D8C65FuLL},
+{0x078644FA00000003uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x000000000F0C89F7uLL},
+{0x078644FA00000003uLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001692CEF1uLL},
+{0x078644FA00000003uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000000F0C89F7uLL},
+{0x078644FA00000003uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000078644FDuLL},
+{0x078644FA00000003uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x0000000100000001uLL, 0x00000000078644F9uLL, 0x00000000F879BB0AuLL},
+{0x078644FA00000003uLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F0F37611uLL},
+{0x078644FA00000003uLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000E96D3118uLL},
+{0x078644FA00000003uLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x00000000879BB073uLL},
+{0x078644FA00000003uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x000000006C09ACD5uLL},
+{0x078644FA00000003uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000082B63E2BuLL},
+{0x078644FA00000003uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000005042DFFuLL},
+{0x078644FA00000003uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000000B49677AuLL},
+{0x078644FA00000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000000078644FDuLL},
+{0x078644FA00000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000003C32280uLL},
+{0x078644FA00000003uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x0000000200000001uLL, 0x0000000003C3227CuLL, 0x00000001FC3CDD87uLL},
+{0x078644FA00000003uLL, 0x0000000200000002uLL, 0x0000000003C3227CuLL, 0x00000001F879BB0BuLL},
+{0x078644FA00000003uLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001F4B6988FuLL},
+{0x078644FA00000003uLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001C3CDD843uLL},
+{0x078644FA00000003uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000181754585uLL},
+{0x078644FA00000003uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x000000019B4CF187uLL},
+{0x078644FA00000003uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x0000000183028200uLL},
+{0x078644FA00000003uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x0000000180000003uLL},
+{0x078644FA00000003uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000000078644FDuLL},
+{0x078644FA00000003uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000005042DFFuLL},
+{0x078644FA00000003uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x0000000002821701uLL},
+{0x078644FA00000003uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x0000000300000001uLL, 0x00000000028216FDuLL, 0x00000002FD7DE906uLL},
+{0x078644FA00000003uLL, 0x0000000300000002uLL, 0x00000000028216FDuLL, 0x00000002FAFBD209uLL},
+{0x078644FA00000003uLL, 0x0000000300000003uLL, 0x00000000028216FDuLL, 0x00000002F879BB0CuLL},
+{0x078644FA00000003uLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002D7DE9033uLL},
+{0x078644FA00000003uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x0000000266ACEAE7uLL},
+{0x078644FA00000003uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000CC648253uLL},
+{0x078644FA00000003uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000282265CDCuLL},
+{0x078644FA00000003uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x0000000280000003uLL},
+{0x078644FA00000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000205A4B3BDuLL},
+{0x078644FA00000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000203C3227FuLL},
+{0x078644FA00000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000201E19141uLL},
+{0x078644FA00000003uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A00000003uLL},
+{0x078644FA00000003uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x00000009FF879BB4uLL},
+{0x078644FA00000003uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x00000009FF0F3765uLL},
+{0x078644FA00000003uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x00000009FE96D316uLL},
+{0x078644FA00000003uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x00000009F879BB13uLL},
+{0x078644FA00000003uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000001E3B0ACBuLL},
+{0x078644FA00000003uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000438F2016FuLL},
+{0x078644FA00000003uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C0074BE5FuLL},
+{0x078644FA00000003uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C00000003uLL},
+{0x078644FA00000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000000153EE11uLL},
+{0x078644FA00000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000000E29EB7uLL},
+{0x078644FA00000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000000714F5DuLL},
+{0x078644FA00000003uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x078644FA00000003uLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x078644FA00000003uLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x078644FA00000003uLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E600000003uLL},
+{0x078644FA00000003uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E600000002uLL},
+{0x078644FA00000003uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E600000001uLL},
+{0x078644FA00000003uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA00000003uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFF3uLL},
+{0x078644FA00000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E5F879BB09uLL},
+{0x078644FA00000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E5F8B851EFuLL},
+{0x078644FA00000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000004uLL},
+{0x078644FA00000003uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E580000003uLL},
+{0x078644FA00000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E500000006uLL},
+{0x078644FA00000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E500000005uLL},
+{0x078644FA00000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E500000004uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000003uLL},
+{0x078644FA00000010uLL, 0x0000000000000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL},
+{0x078644FA00000010uLL, 0x0000000000000002uLL, 0x03C3227D00000008uLL, 0x0000000000000000uLL},
+{0x078644FA00000010uLL, 0x0000000000000003uLL, 0x028216FE00000005uLL, 0x0000000000000001uLL},
+{0x078644FA00000010uLL, 0x0000000000000010uLL, 0x0078644FA0000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000010uLL, 0x00000000078644FAuLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x000000000747AE14uLL, 0x000000010898F295uLL, 0x0000000004D8C66CuLL},
+{0x078644FA00000010uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x000000000F0C8A04uLL},
+{0x078644FA00000010uLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001692CEFEuLL},
+{0x078644FA00000010uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000000F0C8A04uLL},
+{0x078644FA00000010uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x000000000786450AuLL},
+{0x078644FA00000010uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x0000000100000001uLL, 0x00000000078644F9uLL, 0x00000000F879BB17uLL},
+{0x078644FA00000010uLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F0F3761EuLL},
+{0x078644FA00000010uLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000E96D3125uLL},
+{0x078644FA00000010uLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x00000000879BB080uLL},
+{0x078644FA00000010uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x000000006C09ACE2uLL},
+{0x078644FA00000010uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000082B63E38uLL},
+{0x078644FA00000010uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000005042E0CuLL},
+{0x078644FA00000010uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000000B496787uLL},
+{0x078644FA00000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x000000000786450AuLL},
+{0x078644FA00000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000003C3228DuLL},
+{0x078644FA00000010uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x0000000200000001uLL, 0x0000000003C3227CuLL, 0x00000001FC3CDD94uLL},
+{0x078644FA00000010uLL, 0x0000000200000002uLL, 0x0000000003C3227CuLL, 0x00000001F879BB18uLL},
+{0x078644FA00000010uLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001F4B6989CuLL},
+{0x078644FA00000010uLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001C3CDD850uLL},
+{0x078644FA00000010uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000181754592uLL},
+{0x078644FA00000010uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x000000019B4CF194uLL},
+{0x078644FA00000010uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x000000018302820DuLL},
+{0x078644FA00000010uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x0000000180000010uLL},
+{0x078644FA00000010uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x000000000786450AuLL},
+{0x078644FA00000010uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000005042E0CuLL},
+{0x078644FA00000010uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x000000000282170EuLL},
+{0x078644FA00000010uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x0000000300000001uLL, 0x00000000028216FDuLL, 0x00000002FD7DE913uLL},
+{0x078644FA00000010uLL, 0x0000000300000002uLL, 0x00000000028216FDuLL, 0x00000002FAFBD216uLL},
+{0x078644FA00000010uLL, 0x0000000300000003uLL, 0x00000000028216FDuLL, 0x00000002F879BB19uLL},
+{0x078644FA00000010uLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002D7DE9040uLL},
+{0x078644FA00000010uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x0000000266ACEAF4uLL},
+{0x078644FA00000010uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000CC648260uLL},
+{0x078644FA00000010uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000282265CE9uLL},
+{0x078644FA00000010uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x0000000280000010uLL},
+{0x078644FA00000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000205A4B3CAuLL},
+{0x078644FA00000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000203C3228CuLL},
+{0x078644FA00000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000201E1914EuLL},
+{0x078644FA00000010uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A00000010uLL},
+{0x078644FA00000010uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x00000009FF879BC1uLL},
+{0x078644FA00000010uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x00000009FF0F3772uLL},
+{0x078644FA00000010uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x00000009FE96D323uLL},
+{0x078644FA00000010uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x00000009F879BB20uLL},
+{0x078644FA00000010uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000001E3B0AD8uLL},
+{0x078644FA00000010uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000438F2017CuLL},
+{0x078644FA00000010uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C0074BE6CuLL},
+{0x078644FA00000010uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C00000010uLL},
+{0x078644FA00000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000000153EE1EuLL},
+{0x078644FA00000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000000E29EC4uLL},
+{0x078644FA00000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000000714F6AuLL},
+{0x078644FA00000010uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x078644FA00000010uLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x078644FA00000010uLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x078644FA00000010uLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x078644FA00000010uLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA00000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E600000010uLL},
+{0x078644FA00000010uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E60000000FuLL},
+{0x078644FA00000010uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E60000000EuLL},
+{0x078644FA00000010uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E60000000DuLL},
+{0x078644FA00000010uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA00000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E5F879BB16uLL},
+{0x078644FA00000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E5F8B851FCuLL},
+{0x078644FA00000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000011uLL},
+{0x078644FA00000010uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E580000010uLL},
+{0x078644FA00000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E500000013uLL},
+{0x078644FA00000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E500000012uLL},
+{0x078644FA00000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E500000011uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA00000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA00000010uLL},
+{0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x0000000000000002uLL, 0x03C3227D03C3227DuLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x0000000000000003uLL, 0x028216FE028216FEuLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x0000000000000010uLL, 0x0078644FA078644FuLL, 0x000000000000000AuLL},
+{0x078644FA078644FAuLL, 0x00000000078644FAuLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x000000000747AE14uLL, 0x000000010898F296uLL, 0x0000000005175D42uLL},
+{0x078644FA078644FAuLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x000000001692CEEEuLL},
+{0x078644FA078644FAuLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x00000000078644FAuLL},
+{0x078644FA078644FAuLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001E1913E8uLL},
+{0x078644FA078644FAuLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000001692CEEEuLL},
+{0x078644FA078644FAuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x000000000F0C89F4uLL},
+{0x078644FA078644FAuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x00000000078644FAuLL},
+{0x078644FA078644FAuLL, 0x0000000100000001uLL, 0x00000000078644FAuLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F879BB08uLL},
+{0x078644FA078644FAuLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000F0F3760FuLL},
+{0x078644FA078644FAuLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x000000008F21F56AuLL},
+{0x078644FA078644FAuLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x00000000738FF1CCuLL},
+{0x078644FA078644FAuLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x000000008A3C8322uLL},
+{0x078644FA078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x000000000C8A72F6uLL},
+{0x078644FA078644FAuLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x00000000078644FAuLL},
+{0x078644FA078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x0000000012CFAC71uLL},
+{0x078644FA078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x000000000F0C89F4uLL},
+{0x078644FA078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x000000000B496777uLL},
+{0x078644FA078644FAuLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x00000000078644FAuLL},
+{0x078644FA078644FAuLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x0000000003C3227DuLL},
+{0x078644FA078644FAuLL, 0x0000000200000002uLL, 0x0000000003C3227DuLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001FC3CDD86uLL},
+{0x078644FA078644FAuLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001CB541D3AuLL},
+{0x078644FA078644FAuLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000188FB8A7CuLL},
+{0x078644FA078644FAuLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x00000001A2D3367EuLL},
+{0x078644FA078644FAuLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x000000018A88C6F7uLL},
+{0x078644FA078644FAuLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x00000001878644FAuLL},
+{0x078644FA078644FAuLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x000000000F0C89F4uLL},
+{0x078644FA078644FAuLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x000000000C8A72F6uLL},
+{0x078644FA078644FAuLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x000000000A085BF8uLL},
+{0x078644FA078644FAuLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x00000000078644FAuLL},
+{0x078644FA078644FAuLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x0000000005042DFCuLL},
+{0x078644FA078644FAuLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x00000000028216FEuLL},
+{0x078644FA078644FAuLL, 0x0000000300000003uLL, 0x00000000028216FEuLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002DF64D52AuLL},
+{0x078644FA078644FAuLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x000000026E332FDEuLL},
+{0x078644FA078644FAuLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000D3EAC74AuLL},
+{0x078644FA078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000289ACA1D3uLL},
+{0x078644FA078644FAuLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x00000002878644FAuLL},
+{0x078644FA078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x000000020D2AF8B4uLL},
+{0x078644FA078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x000000020B496776uLL},
+{0x078644FA078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x000000020967D638uLL},
+{0x078644FA078644FAuLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A078644FAuLL},
+{0x078644FA078644FAuLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000A070DE0ABuLL},
+{0x078644FA078644FAuLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000A06957C5CuLL},
+{0x078644FA078644FAuLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000A061D180DuLL},
+{0x078644FA078644FAuLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x0000000A0000000AuLL},
+{0x078644FA078644FAuLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x0000000025C14FC2uLL},
+{0x078644FA078644FAuLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000440784666uLL},
+{0x078644FA078644FAuLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C07FB0356uLL},
+{0x078644FA078644FAuLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C078644FAuLL},
+{0x078644FA078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x0000000008DA3308uLL},
+{0x078644FA078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x000000000868E3AEuLL},
+{0x078644FA078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000007F79454uLL},
+{0x078644FA078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x078644FA078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x078644FA078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x078644FA078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x078644FA078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x078644FA078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x078644FA078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E6078644FAuLL},
+{0x078644FA078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E6078644F9uLL},
+{0x078644FA078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E6078644F8uLL},
+{0x078644FA078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E6078644F7uLL},
+{0x078644FA078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E6078644EAuLL},
+{0x078644FA078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E6003E96E6uLL},
+{0x078644FA078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E5878644FBuLL},
+{0x078644FA078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E5878644FAuLL},
+{0x078644FA078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E5078644FDuLL},
+{0x078644FA078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E5078644FCuLL},
+{0x078644FA078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E5078644FBuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA078644FAuLL},
+{0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL},
+{0x078644FA0747AE14uLL, 0x0000000000000002uLL, 0x03C3227D03A3D70AuLL, 0x0000000000000000uLL},
+{0x078644FA0747AE14uLL, 0x0000000000000003uLL, 0x028216FE026D3A06uLL, 0x0000000000000002uLL},
+{0x078644FA0747AE14uLL, 0x0000000000000010uLL, 0x0078644FA0747AE1uLL, 0x0000000000000004uLL},
+{0x078644FA0747AE14uLL, 0x00000000078644FAuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x000000000747AE14uLL, 0x000000010898F296uLL, 0x0000000004D8C65CuLL},
+{0x078644FA0747AE14uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F4uLL, 0x0000000016543808uLL},
+{0x078644FA0747AE14uLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000001DDA7D02uLL},
+{0x078644FA0747AE14uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000016543808uLL},
+{0x078644FA0747AE14uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x000000000ECDF30EuLL},
+{0x078644FA0747AE14uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0000000100000001uLL, 0x00000000078644F9uLL, 0x00000000FFC1691BuLL},
+{0x078644FA0747AE14uLL, 0x0000000100000002uLL, 0x00000000078644F9uLL, 0x00000000F83B2422uLL},
+{0x078644FA0747AE14uLL, 0x0000000100000003uLL, 0x00000000078644F9uLL, 0x00000000F0B4DF29uLL},
+{0x078644FA0747AE14uLL, 0x0000000100000010uLL, 0x00000000078644F9uLL, 0x000000008EE35E84uLL},
+{0x078644FA0747AE14uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x0000000073515AE6uLL},
+{0x078644FA0747AE14uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000089FDEC3CuLL},
+{0x078644FA0747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x000000000C4BDC10uLL},
+{0x078644FA0747AE14uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000001291158BuLL},
+{0x078644FA0747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x000000000ECDF30EuLL},
+{0x078644FA0747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x000000000B0AD091uLL},
+{0x078644FA0747AE14uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x0000000003848B97uLL},
+{0x078644FA0747AE14uLL, 0x0000000200000002uLL, 0x0000000003C3227CuLL, 0x00000001FFC1691CuLL},
+{0x078644FA0747AE14uLL, 0x0000000200000003uLL, 0x0000000003C3227CuLL, 0x00000001FBFE46A0uLL},
+{0x078644FA0747AE14uLL, 0x0000000200000010uLL, 0x0000000003C3227CuLL, 0x00000001CB158654uLL},
+{0x078644FA0747AE14uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000188BCF396uLL},
+{0x078644FA0747AE14uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D3uLL, 0x00000001A2949F98uLL},
+{0x078644FA0747AE14uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x000000018A4A3011uLL},
+{0x078644FA0747AE14uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x000000018747AE14uLL},
+{0x078644FA0747AE14uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x000000000ECDF30EuLL},
+{0x078644FA0747AE14uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x000000000C4BDC10uLL},
+{0x078644FA0747AE14uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x0000000009C9C512uLL},
+{0x078644FA0747AE14uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x0000000004C59716uLL},
+{0x078644FA0747AE14uLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x0000000002438018uLL},
+{0x078644FA0747AE14uLL, 0x0000000300000003uLL, 0x00000000028216FDuLL, 0x00000002FFC1691DuLL},
+{0x078644FA0747AE14uLL, 0x0000000300000010uLL, 0x00000000028216FDuLL, 0x00000002DF263E44uLL},
+{0x078644FA0747AE14uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x000000026DF498F8uLL},
+{0x078644FA0747AE14uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000000D3AC3064uLL},
+{0x078644FA0747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x00000002896E0AEDuLL},
+{0x078644FA0747AE14uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x000000028747AE14uLL},
+{0x078644FA0747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x000000020CEC61CEuLL},
+{0x078644FA0747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x000000020B0AD090uLL},
+{0x078644FA0747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000209293F52uLL},
+{0x078644FA0747AE14uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000A06CF49C5uLL},
+{0x078644FA0747AE14uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000A0656E576uLL},
+{0x078644FA0747AE14uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000A05DE8127uLL},
+{0x078644FA0747AE14uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x00000009FFC16924uLL},
+{0x078644FA0747AE14uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000002582B8DCuLL},
+{0x078644FA0747AE14uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x000000044039AF80uLL},
+{0x078644FA0747AE14uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C07BC6C70uLL},
+{0x078644FA0747AE14uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x00000000089B9C22uLL},
+{0x078644FA0747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x00000000082A4CC8uLL},
+{0x078644FA0747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000007B8FD6EuLL},
+{0x078644FA0747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x078644FA0747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x078644FA0747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x078644FA0747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x078644FA0747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x078644FA0747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA0747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E60747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E60747AE13uLL},
+{0x078644FA0747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E60747AE12uLL},
+{0x078644FA0747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E60747AE11uLL},
+{0x078644FA0747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E60747AE04uLL},
+{0x078644FA0747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E5FFC1691AuLL},
+{0x078644FA0747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA0747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E58747AE15uLL},
+{0x078644FA0747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E58747AE14uLL},
+{0x078644FA0747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E50747AE17uLL},
+{0x078644FA0747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E50747AE16uLL},
+{0x078644FA0747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E50747AE15uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA0747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA0747AE14uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000000000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000000000002uLL, 0x03C3227D3FFFFFFFuLL, 0x0000000000000001uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000000000003uLL, 0x028216FE2AAAAAAAuLL, 0x0000000000000001uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000000000010uLL, 0x0078644FA7FFFFFFuLL, 0x000000000000000FuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000100000011uLL, 0x0000000000156B65uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000000747AE14uLL, 0x000000010898F2A7uLL, 0x0000000001CE88F3uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F5uLL, 0x000000000F0C89F4uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000080000000uLL, 0x000000000F0C89F4uLL, 0x000000007FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000009692CEEDuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000008F0C89F3uLL},
+{0x078644FA7FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000878644F9uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x000000007FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000100000001uLL, 0x00000000078644FAuLL, 0x000000007879BB05uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000100000002uLL, 0x00000000078644FAuLL, 0x0000000070F3760BuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000100000003uLL, 0x00000000078644FAuLL, 0x00000000696D3111uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000100000010uLL, 0x00000000078644FAuLL, 0x00000000079BB05FuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x00000000EC09ACD1uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000102B63E27uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000085042DFBuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x000000007FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000008B496776uLL},
+{0x078644FA7FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000000878644F9uLL},
+{0x078644FA7FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000083C3227CuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x000000007FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x000000007C3CDD82uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000003C3227DuLL, 0x000000007879BB05uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000003C3227DuLL, 0x0000000074B69888uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000003C3227DuLL, 0x0000000043CDD82FuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000201754581uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000003B5A1D4uLL, 0x000000001405436FuLL},
+{0x078644FA7FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x00000002030281FCuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x00000001FFFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000000878644F9uLL},
+{0x078644FA7FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000085042DFBuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000000828216FDuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x000000007FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x000000007D7DE901uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x000000007AFBD203uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000300000003uLL, 0x00000000028216FEuLL, 0x000000007879BB05uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000300000010uLL, 0x00000000028216FEuLL, 0x0000000057DE901FuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x00000002E6ACEAE3uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x000000014C64824FuLL},
+{0x078644FA7FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000302265CD8uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x00000002FFFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000285A4B3B9uLL},
+{0x078644FA7FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000283C3227BuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000281E1913DuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000A7F879BB0uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000A7F0F3761uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000A7E96D312uLL},
+{0x078644FA7FFFFFFFuLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x0000000A7879BB0FuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000009E3B0AC7uLL},
+{0x078644FA7FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x00000004B8F2016BuLL},
+{0x078644FA7FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C8074BE5BuLL},
+{0x078644FA7FFFFFFFuLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000008153EE0DuLL},
+{0x078644FA7FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000080E29EB3uLL},
+{0x078644FA7FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000080714F59uLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFEuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFDuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFCuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFEFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E67879BB05uLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E678B851EBuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E580000002uLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E580000001uLL},
+{0x078644FA7FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000000uLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA7FFFFFFFuLL},
+{0x078644FA80000000uLL, 0x0000000000000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL},
+{0x078644FA80000000uLL, 0x0000000000000002uLL, 0x03C3227D40000000uLL, 0x0000000000000000uLL},
+{0x078644FA80000000uLL, 0x0000000000000003uLL, 0x028216FE2AAAAAAAuLL, 0x0000000000000002uLL},
+{0x078644FA80000000uLL, 0x0000000000000010uLL, 0x0078644FA8000000uLL, 0x0000000000000000uLL},
+{0x078644FA80000000uLL, 0x00000000078644FAuLL, 0x0000000100000011uLL, 0x0000000000156B66uLL},
+{0x078644FA80000000uLL, 0x000000000747AE14uLL, 0x000000010898F2A7uLL, 0x0000000001CE88F4uLL},
+{0x078644FA80000000uLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F5uLL, 0x000000000F0C89F5uLL},
+{0x078644FA80000000uLL, 0x0000000080000000uLL, 0x000000000F0C89F5uLL, 0x0000000000000000uLL},
+{0x078644FA80000000uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x000000009692CEEEuLL},
+{0x078644FA80000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x000000008F0C89F4uLL},
+{0x078644FA80000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000878644FAuLL},
+{0x078644FA80000000uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x0000000080000000uLL},
+{0x078644FA80000000uLL, 0x0000000100000001uLL, 0x00000000078644FAuLL, 0x000000007879BB06uLL},
+{0x078644FA80000000uLL, 0x0000000100000002uLL, 0x00000000078644FAuLL, 0x0000000070F3760CuLL},
+{0x078644FA80000000uLL, 0x0000000100000003uLL, 0x00000000078644FAuLL, 0x00000000696D3112uLL},
+{0x078644FA80000000uLL, 0x0000000100000010uLL, 0x00000000078644FAuLL, 0x00000000079BB060uLL},
+{0x078644FA80000000uLL, 0x00000001078644FAuLL, 0x00000000074F44A3uLL, 0x00000000EC09ACD2uLL},
+{0x078644FA80000000uLL, 0x000000010747AE14uLL, 0x000000000751017EuLL, 0x0000000102B63E28uLL},
+{0x078644FA80000000uLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000085042DFCuLL},
+{0x078644FA80000000uLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x0000000080000000uLL},
+{0x078644FA80000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000008B496777uLL},
+{0x078644FA80000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000000878644FAuLL},
+{0x078644FA80000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000083C3227DuLL},
+{0x078644FA80000000uLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x0000000080000000uLL},
+{0x078644FA80000000uLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x000000007C3CDD83uLL},
+{0x078644FA80000000uLL, 0x0000000200000002uLL, 0x0000000003C3227DuLL, 0x000000007879BB06uLL},
+{0x078644FA80000000uLL, 0x0000000200000003uLL, 0x0000000003C3227DuLL, 0x0000000074B69889uLL},
+{0x078644FA80000000uLL, 0x0000000200000010uLL, 0x0000000003C3227DuLL, 0x0000000043CDD830uLL},
+{0x078644FA80000000uLL, 0x00000002078644FAuLL, 0x0000000003B52F6BuLL, 0x0000000201754582uLL},
+{0x078644FA80000000uLL, 0x000000020747AE14uLL, 0x0000000003B5A1D4uLL, 0x0000000014054370uLL},
+{0x078644FA80000000uLL, 0x000000027FFFFFFFuLL, 0x00000000030281FDuLL, 0x00000002030281FDuLL},
+{0x078644FA80000000uLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x0000000200000000uLL},
+{0x078644FA80000000uLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000000878644FAuLL},
+{0x078644FA80000000uLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000085042DFCuLL},
+{0x078644FA80000000uLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000000828216FEuLL},
+{0x078644FA80000000uLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x0000000080000000uLL},
+{0x078644FA80000000uLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x000000007D7DE902uLL},
+{0x078644FA80000000uLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x000000007AFBD204uLL},
+{0x078644FA80000000uLL, 0x0000000300000003uLL, 0x00000000028216FEuLL, 0x000000007879BB06uLL},
+{0x078644FA80000000uLL, 0x0000000300000010uLL, 0x00000000028216FEuLL, 0x0000000057DE9020uLL},
+{0x078644FA80000000uLL, 0x00000003078644FAuLL, 0x00000000027BDC26uLL, 0x00000002E6ACEAE4uLL},
+{0x078644FA80000000uLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x000000014C648250uLL},
+{0x078644FA80000000uLL, 0x000000037FFFFFFFuLL, 0x0000000002265CD9uLL, 0x0000000302265CD9uLL},
+{0x078644FA80000000uLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x0000000300000000uLL},
+{0x078644FA80000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000285A4B3BAuLL},
+{0x078644FA80000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000283C3227CuLL},
+{0x078644FA80000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000281E1913EuLL},
+{0x078644FA80000000uLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000A80000000uLL},
+{0x078644FA80000000uLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000A7F879BB1uLL},
+{0x078644FA80000000uLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000A7F0F3762uLL},
+{0x078644FA80000000uLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000A7E96D313uLL},
+{0x078644FA80000000uLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x0000000A7879BB10uLL},
+{0x078644FA80000000uLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000009E3B0AC8uLL},
+{0x078644FA80000000uLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x00000004B8F2016CuLL},
+{0x078644FA80000000uLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000C8074BE5CuLL},
+{0x078644FA80000000uLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000C80000000uLL},
+{0x078644FA80000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000008153EE0EuLL},
+{0x078644FA80000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000080E29EB4uLL},
+{0x078644FA80000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000080714F5AuLL},
+{0x078644FA80000000uLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x078644FA80000000uLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x078644FA80000000uLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x078644FA80000000uLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x078644FA80000000uLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x078644FA80000000uLL, 0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x078644FA80000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x078644FA80000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x078644FA80000000uLL, 0x078644FA80000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FA80000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E680000000uLL},
+{0x078644FA80000000uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFFuLL},
+{0x078644FA80000000uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFEuLL},
+{0x078644FA80000000uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFDuLL},
+{0x078644FA80000000uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFF0uLL},
+{0x078644FA80000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E67879BB06uLL},
+{0x078644FA80000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E678B851ECuLL},
+{0x078644FA80000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E600000001uLL},
+{0x078644FA80000000uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FA80000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E580000003uLL},
+{0x078644FA80000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E580000002uLL},
+{0x078644FA80000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E580000001uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FA80000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FA80000000uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000000000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000000000002uLL, 0x03C3227D7FFFFFFEuLL, 0x0000000000000001uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000000000003uLL, 0x028216FE55555554uLL, 0x0000000000000001uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000000000010uLL, 0x0078644FAFFFFFFFuLL, 0x000000000000000DuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000000100000022uLL, 0x00000000002AD6C9uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000010898F2B8uLL, 0x00000000060BF99DuLL},
+{0x078644FAFFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F6uLL, 0x000000000F0C89F3uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000080000000uLL, 0x000000000F0C89F5uLL, 0x000000007FFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FBuLL, 0x000000001692CEEEuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FBuLL, 0x000000000F0C89F3uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FBuLL, 0x00000000078644F8uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000100000001uLL, 0x00000000078644FAuLL, 0x00000000F879BB03uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000100000002uLL, 0x00000000078644FAuLL, 0x00000000F0F37609uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000100000003uLL, 0x00000000078644FAuLL, 0x00000000E96D310FuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000100000010uLL, 0x00000000078644FAuLL, 0x00000000879BB05DuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000001078644FAuLL, 0x00000000074F44A4uLL, 0x00000000648367D5uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000010747AE14uLL, 0x000000000751017FuLL, 0x000000007B6E9011uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000105042DF9uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000010B496774uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000001078644F7uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000103C3227AuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x00000000FC3CDD80uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000003C3227DuLL, 0x00000000F879BB03uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000003C3227DuLL, 0x00000000F4B69886uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000003C3227DuLL, 0x00000000C3CDD82DuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000003B52F6CuLL, 0x0000000079EF0085uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000020747AE14uLL, 0x0000000003B5A1D4uLL, 0x000000009405436DuLL},
+{0x078644FAFFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x00000000030281FEuLL, 0x00000000030281FBuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x000000027FFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000001078644F7uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000105042DF9uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000001028216FBuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x00000000FD7DE8FFuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x00000000FAFBD201uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000300000003uLL, 0x00000000028216FEuLL, 0x00000000F879BB03uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000300000010uLL, 0x00000000028216FEuLL, 0x00000000D7DE901DuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000003078644FAuLL, 0x00000000027BDC27uLL, 0x000000005F26A5E7uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000001CC64824DuLL},
+{0x078644FAFFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000002265CDAuLL, 0x0000000002265CD7uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x000000037FFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000305A4B3B7uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000303C32279uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000301E1913BuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000AFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000AFF879BAEuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000AFF0F375FuLL},
+{0x078644FAFFFFFFFDuLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000AFE96D310uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x0000000AF879BB0DuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000011E3B0AC5uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000538F20169uLL},
+{0x078644FAFFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000D0074BE59uLL},
+{0x078644FAFFFFFFFDuLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000CFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000010153EE0BuLL},
+{0x078644FAFFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000100E29EB1uLL},
+{0x078644FAFFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000100714F57uLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFCuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFBuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFAuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFEDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E6F879BB03uLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E6F8B851E9uLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFEuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFFuLL},
+{0x078644FAFFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFEuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFDuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000000000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000000000002uLL, 0x03C3227D7FFFFFFFuLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000000000003uLL, 0x028216FE55555554uLL, 0x0000000000000002uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000000000010uLL, 0x0078644FAFFFFFFFuLL, 0x000000000000000EuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000000100000022uLL, 0x00000000002AD6CAuLL},
+{0x078644FAFFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000010898F2B8uLL, 0x00000000060BF99EuLL},
+{0x078644FAFFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F6uLL, 0x000000000F0C89F4uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000080000000uLL, 0x000000000F0C89F5uLL, 0x000000007FFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FBuLL, 0x000000001692CEEFuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FBuLL, 0x000000000F0C89F4uLL},
+{0x078644FAFFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FBuLL, 0x00000000078644F9uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x00000000FFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000100000001uLL, 0x00000000078644FAuLL, 0x00000000F879BB04uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000100000002uLL, 0x00000000078644FAuLL, 0x00000000F0F3760AuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000100000003uLL, 0x00000000078644FAuLL, 0x00000000E96D3110uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000100000010uLL, 0x00000000078644FAuLL, 0x00000000879BB05EuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000001078644FAuLL, 0x00000000074F44A4uLL, 0x00000000648367D6uLL},
+{0x078644FAFFFFFFFEuLL, 0x000000010747AE14uLL, 0x000000000751017FuLL, 0x000000007B6E9012uLL},
+{0x078644FAFFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000105042DFAuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x00000000FFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000010B496775uLL},
+{0x078644FAFFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000001078644F8uLL},
+{0x078644FAFFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000103C3227BuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x00000000FFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x00000000FC3CDD81uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000003C3227DuLL, 0x00000000F879BB04uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000003C3227DuLL, 0x00000000F4B69887uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000003C3227DuLL, 0x00000000C3CDD82EuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000003B52F6CuLL, 0x0000000079EF0086uLL},
+{0x078644FAFFFFFFFEuLL, 0x000000020747AE14uLL, 0x0000000003B5A1D4uLL, 0x000000009405436EuLL},
+{0x078644FAFFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x00000000030281FEuLL, 0x00000000030281FCuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x000000027FFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000001078644F8uLL},
+{0x078644FAFFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000105042DFAuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000001028216FCuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x00000000FFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x00000000FD7DE900uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x00000000FAFBD202uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000300000003uLL, 0x00000000028216FEuLL, 0x00000000F879BB04uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000300000010uLL, 0x00000000028216FEuLL, 0x00000000D7DE901EuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000003078644FAuLL, 0x00000000027BDC27uLL, 0x000000005F26A5E8uLL},
+{0x078644FAFFFFFFFEuLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000001CC64824EuLL},
+{0x078644FAFFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000002265CDAuLL, 0x0000000002265CD8uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x000000037FFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000305A4B3B8uLL},
+{0x078644FAFFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000303C3227AuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000301E1913CuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000AFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000AFF879BAFuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000AFF0F3760uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000AFE96D311uLL},
+{0x078644FAFFFFFFFEuLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x0000000AF879BB0EuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000011E3B0AC6uLL},
+{0x078644FAFFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000538F2016AuLL},
+{0x078644FAFFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000D0074BE5AuLL},
+{0x078644FAFFFFFFFEuLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000CFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000010153EE0CuLL},
+{0x078644FAFFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000100E29EB2uLL},
+{0x078644FAFFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000100714F58uLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFDuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFCuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFBuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFEEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E6F879BB04uLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E6F8B851EAuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFFuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E600000001uLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FAFFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E5FFFFFFFFuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFEuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000000000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000000000002uLL, 0x03C3227D7FFFFFFFuLL, 0x0000000000000001uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000000000003uLL, 0x028216FE55555555uLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000000000010uLL, 0x0078644FAFFFFFFFuLL, 0x000000000000000FuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000000100000022uLL, 0x00000000002AD6CBuLL},
+{0x078644FAFFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000010898F2B8uLL, 0x00000000060BF99FuLL},
+{0x078644FAFFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000000F0C89F6uLL, 0x000000000F0C89F5uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000080000000uLL, 0x000000000F0C89F5uLL, 0x000000007FFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FBuLL, 0x000000001692CEF0uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FBuLL, 0x000000000F0C89F5uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FBuLL, 0x00000000078644FAuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL, 0x00000000FFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000100000001uLL, 0x00000000078644FAuLL, 0x00000000F879BB05uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000100000002uLL, 0x00000000078644FAuLL, 0x00000000F0F3760BuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000100000003uLL, 0x00000000078644FAuLL, 0x00000000E96D3111uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000100000010uLL, 0x00000000078644FAuLL, 0x00000000879BB05FuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000074F44A4uLL, 0x00000000648367D7uLL},
+{0x078644FAFFFFFFFFuLL, 0x000000010747AE14uLL, 0x000000000751017FuLL, 0x000000007B6E9013uLL},
+{0x078644FAFFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000005042DFCuLL, 0x0000000105042DFBuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000005042DFCuLL, 0x00000000FFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000003C3227DuLL, 0x000000010B496776uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000003C3227DuLL, 0x00000001078644F9uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000003C3227DuLL, 0x0000000103C3227CuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000003C3227DuLL, 0x00000000FFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000003C3227DuLL, 0x00000000FC3CDD82uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000003C3227DuLL, 0x00000000F879BB05uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000003C3227DuLL, 0x00000000F4B69888uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000003C3227DuLL, 0x00000000C3CDD82FuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000003B52F6CuLL, 0x0000000079EF0087uLL},
+{0x078644FAFFFFFFFFuLL, 0x000000020747AE14uLL, 0x0000000003B5A1D4uLL, 0x000000009405436FuLL},
+{0x078644FAFFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x00000000030281FEuLL, 0x00000000030281FDuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000280000000uLL, 0x00000000030281FDuLL, 0x000000027FFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x00000000028216FEuLL, 0x00000001078644F9uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x00000000028216FEuLL, 0x0000000105042DFBuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x00000000028216FEuLL, 0x00000001028216FDuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000300000000uLL, 0x00000000028216FEuLL, 0x00000000FFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000300000001uLL, 0x00000000028216FEuLL, 0x00000000FD7DE901uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000300000002uLL, 0x00000000028216FEuLL, 0x00000000FAFBD203uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000300000003uLL, 0x00000000028216FEuLL, 0x00000000F879BB05uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000300000010uLL, 0x00000000028216FEuLL, 0x00000000D7DE901FuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000003078644FAuLL, 0x00000000027BDC27uLL, 0x000000005F26A5E9uLL},
+{0x078644FAFFFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000027C0F7CuLL, 0x00000001CC64824FuLL},
+{0x078644FAFFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000002265CDAuLL, 0x0000000002265CD9uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000002265CD9uLL, 0x000000037FFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000001E1913EuLL, 0x0000000305A4B3B9uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000001E1913EuLL, 0x0000000303C3227BuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000001E1913EuLL, 0x0000000301E1913DuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000001000000000uLL, 0x000000000078644FuLL, 0x0000000AFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000001000000001uLL, 0x000000000078644FuLL, 0x0000000AFF879BB0uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000001000000002uLL, 0x000000000078644FuLL, 0x0000000AFF0F3761uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000001000000003uLL, 0x000000000078644FuLL, 0x0000000AFE96D312uLL},
+{0x078644FAFFFFFFFFuLL, 0x0000001000000010uLL, 0x000000000078644FuLL, 0x0000000AF879BB0FuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000782BCCuLL, 0x000000011E3B0AC7uLL},
+{0x078644FAFFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000000782DA1uLL, 0x0000000538F2016BuLL},
+{0x078644FAFFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000074BE5CuLL, 0x0000000D0074BE5BuLL},
+{0x078644FAFFFFFFFFuLL, 0x0000001080000000uLL, 0x000000000074BE5CuLL, 0x0000000CFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000000714F5AuLL, 0x000000010153EE0DuLL},
+{0x078644FAFFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000000714F5AuLL, 0x0000000100E29EB3uLL},
+{0x078644FAFFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000000714F5AuLL, 0x0000000100714F59uLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x078644FAFFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFEuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFDuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFFCuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x003E96E6FFFFFFEFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x003E96E6F879BB05uLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x003E96E6F8B851EBuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E680000000uLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x003E96E67FFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x003E96E600000002uLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x003E96E600000001uLL},
+{0x078644FAFFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x003E96E600000000uLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x078644FAFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x078644FAFFFFFFFFuLL},
+{0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0747AE1400000000uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x0000000000000002uLL, 0x03A3D70A00000000uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x0000000000000003uLL, 0x026D3A06AAAAAAAAuLL, 0x0000000000000002uLL},
+{0x0747AE1400000000uLL, 0x0000000000000010uLL, 0x00747AE140000000uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x00000000078644FAuLL, 0x00000000F7AE911DuLL, 0x0000000000CC95AEuLL},
+{0x0747AE1400000000uLL, 0x000000000747AE14uLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x000000000E8F5C28uLL},
+{0x0747AE1400000000uLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000015D70A3CuLL},
+{0x0747AE1400000000uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000000E8F5C28uLL},
+{0x0747AE1400000000uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000747AE14uLL},
+{0x0747AE1400000000uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x0000000100000001uLL, 0x000000000747AE13uLL, 0x00000000F8B851EDuLL},
+{0x0747AE1400000000uLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F170A3DAuLL},
+{0x0747AE1400000000uLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000EA28F5C7uLL},
+{0x0747AE1400000000uLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x000000008B851ED0uLL},
+{0x0747AE1400000000uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000000C50D07AuLL},
+{0x0747AE1400000000uLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000CD13E91CuLL},
+{0x0747AE1400000000uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000084DA740DuLL},
+{0x0747AE1400000000uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x0000000080000000uLL},
+{0x0747AE1400000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000000AEB851EuLL},
+{0x0747AE1400000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000747AE14uLL},
+{0x0747AE1400000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000003A3D70AuLL},
+{0x0747AE1400000000uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x0000000200000001uLL, 0x0000000003A3D709uLL, 0x00000001FC5C28F7uLL},
+{0x0747AE1400000000uLL, 0x0000000200000002uLL, 0x0000000003A3D709uLL, 0x00000001F8B851EEuLL},
+{0x0747AE1400000000uLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001F5147AE5uLL},
+{0x0747AE1400000000uLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001C5C28F70uLL},
+{0x0747AE1400000000uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007847CB06uLL},
+{0x0747AE1400000000uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x000000014B152C2CuLL},
+{0x0747AE1400000000uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x0000000202E978D4uLL},
+{0x0747AE1400000000uLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x0000000200000000uLL},
+{0x0747AE1400000000uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020747AE12uLL},
+{0x0747AE1400000000uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000204DA740CuLL},
+{0x0747AE1400000000uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002026D3A06uLL},
+{0x0747AE1400000000uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x0000000200000000uLL},
+{0x0747AE1400000000uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000001FD92C5FAuLL},
+{0x0747AE1400000000uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000001FB258BF4uLL},
+{0x0747AE1400000000uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000001F8B851EEuLL},
+{0x0747AE1400000000uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001D92C5FA0uLL},
+{0x0747AE1400000000uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018425ED06uLL},
+{0x0747AE1400000000uLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F112E8A4uLL},
+{0x0747AE1400000000uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000082147AE1uLL},
+{0x0747AE1400000000uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x0000000080000000uLL},
+{0x0747AE1400000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000575C28FuLL},
+{0x0747AE1400000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000003A3D70AuLL},
+{0x0747AE1400000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000001D1EB85uLL},
+{0x0747AE1400000000uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x0000000400000000uLL},
+{0x0747AE1400000000uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000003FF8B851FuLL},
+{0x0747AE1400000000uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000003FF170A3EuLL},
+{0x0747AE1400000000uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000003FEA28F5DuLL},
+{0x0747AE1400000000uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000003F8B851F0uLL},
+{0x0747AE1400000000uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B94A5DA32uLL},
+{0x0747AE1400000000uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BB84C4A8CuLL},
+{0x0747AE1400000000uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000008070F347uLL},
+{0x0747AE1400000000uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x0000000080000000uLL},
+{0x0747AE1400000000uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000000148E27CuLL},
+{0x0747AE1400000000uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000000DB41A8uLL},
+{0x0747AE1400000000uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000006DA0D4uLL},
+{0x0747AE1400000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000000uLL},
+{0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x0747AE1400000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000001uLL, 0x0000000000000002uLL, 0x03A3D70A00000000uLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x0000000000000003uLL, 0x026D3A06AAAAAAABuLL, 0x0000000000000000uLL},
+{0x0747AE1400000001uLL, 0x0000000000000010uLL, 0x00747AE140000000uLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x00000000078644FAuLL, 0x00000000F7AE911DuLL, 0x0000000000CC95AFuLL},
+{0x0747AE1400000001uLL, 0x000000000747AE14uLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x000000000E8F5C29uLL},
+{0x0747AE1400000001uLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000015D70A3DuLL},
+{0x0747AE1400000001uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000000E8F5C29uLL},
+{0x0747AE1400000001uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000747AE15uLL},
+{0x0747AE1400000001uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x0000000100000001uLL, 0x000000000747AE13uLL, 0x00000000F8B851EEuLL},
+{0x0747AE1400000001uLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F170A3DBuLL},
+{0x0747AE1400000001uLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000EA28F5C8uLL},
+{0x0747AE1400000001uLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x000000008B851ED1uLL},
+{0x0747AE1400000001uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000000C50D07BuLL},
+{0x0747AE1400000001uLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000CD13E91DuLL},
+{0x0747AE1400000001uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000084DA740EuLL},
+{0x0747AE1400000001uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x0000000080000001uLL},
+{0x0747AE1400000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000000AEB851FuLL},
+{0x0747AE1400000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000747AE15uLL},
+{0x0747AE1400000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000003A3D70BuLL},
+{0x0747AE1400000001uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x0000000200000001uLL, 0x0000000003A3D709uLL, 0x00000001FC5C28F8uLL},
+{0x0747AE1400000001uLL, 0x0000000200000002uLL, 0x0000000003A3D709uLL, 0x00000001F8B851EFuLL},
+{0x0747AE1400000001uLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001F5147AE6uLL},
+{0x0747AE1400000001uLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001C5C28F71uLL},
+{0x0747AE1400000001uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007847CB07uLL},
+{0x0747AE1400000001uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x000000014B152C2DuLL},
+{0x0747AE1400000001uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x0000000202E978D5uLL},
+{0x0747AE1400000001uLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x0000000200000001uLL},
+{0x0747AE1400000001uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020747AE13uLL},
+{0x0747AE1400000001uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000204DA740DuLL},
+{0x0747AE1400000001uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002026D3A07uLL},
+{0x0747AE1400000001uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x0000000200000001uLL},
+{0x0747AE1400000001uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000001FD92C5FBuLL},
+{0x0747AE1400000001uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000001FB258BF5uLL},
+{0x0747AE1400000001uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000001F8B851EFuLL},
+{0x0747AE1400000001uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001D92C5FA1uLL},
+{0x0747AE1400000001uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018425ED07uLL},
+{0x0747AE1400000001uLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F112E8A5uLL},
+{0x0747AE1400000001uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000082147AE2uLL},
+{0x0747AE1400000001uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x0000000080000001uLL},
+{0x0747AE1400000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000575C290uLL},
+{0x0747AE1400000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000003A3D70BuLL},
+{0x0747AE1400000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000001D1EB86uLL},
+{0x0747AE1400000001uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x0000000400000001uLL},
+{0x0747AE1400000001uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000003FF8B8520uLL},
+{0x0747AE1400000001uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000003FF170A3FuLL},
+{0x0747AE1400000001uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000003FEA28F5EuLL},
+{0x0747AE1400000001uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000003F8B851F1uLL},
+{0x0747AE1400000001uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B94A5DA33uLL},
+{0x0747AE1400000001uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BB84C4A8DuLL},
+{0x0747AE1400000001uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000008070F348uLL},
+{0x0747AE1400000001uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x0000000080000001uLL},
+{0x0747AE1400000001uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000000148E27DuLL},
+{0x0747AE1400000001uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000000DB41A9uLL},
+{0x0747AE1400000001uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000006DA0D5uLL},
+{0x0747AE1400000001uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000001uLL},
+{0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x0747AE1400000002uLL, 0x0000000000000000uLL},
+{0x0747AE1400000002uLL, 0x0000000000000002uLL, 0x03A3D70A00000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000002uLL, 0x0000000000000003uLL, 0x026D3A06AAAAAAABuLL, 0x0000000000000001uLL},
+{0x0747AE1400000002uLL, 0x0000000000000010uLL, 0x00747AE140000000uLL, 0x0000000000000002uLL},
+{0x0747AE1400000002uLL, 0x00000000078644FAuLL, 0x00000000F7AE911DuLL, 0x0000000000CC95B0uLL},
+{0x0747AE1400000002uLL, 0x000000000747AE14uLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0x0747AE1400000002uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x000000000E8F5C2AuLL},
+{0x0747AE1400000002uLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x0000000000000002uLL},
+{0x0747AE1400000002uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000015D70A3EuLL},
+{0x0747AE1400000002uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000000E8F5C2AuLL},
+{0x0747AE1400000002uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000747AE16uLL},
+{0x0747AE1400000002uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000000000002uLL},
+{0x0747AE1400000002uLL, 0x0000000100000001uLL, 0x000000000747AE13uLL, 0x00000000F8B851EFuLL},
+{0x0747AE1400000002uLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F170A3DCuLL},
+{0x0747AE1400000002uLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000EA28F5C9uLL},
+{0x0747AE1400000002uLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x000000008B851ED2uLL},
+{0x0747AE1400000002uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000000C50D07CuLL},
+{0x0747AE1400000002uLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000CD13E91EuLL},
+{0x0747AE1400000002uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000084DA740FuLL},
+{0x0747AE1400000002uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x0000000080000002uLL},
+{0x0747AE1400000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000000AEB8520uLL},
+{0x0747AE1400000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000747AE16uLL},
+{0x0747AE1400000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000003A3D70CuLL},
+{0x0747AE1400000002uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x0000000000000002uLL},
+{0x0747AE1400000002uLL, 0x0000000200000001uLL, 0x0000000003A3D709uLL, 0x00000001FC5C28F9uLL},
+{0x0747AE1400000002uLL, 0x0000000200000002uLL, 0x0000000003A3D709uLL, 0x00000001F8B851F0uLL},
+{0x0747AE1400000002uLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001F5147AE7uLL},
+{0x0747AE1400000002uLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001C5C28F72uLL},
+{0x0747AE1400000002uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007847CB08uLL},
+{0x0747AE1400000002uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x000000014B152C2EuLL},
+{0x0747AE1400000002uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x0000000202E978D6uLL},
+{0x0747AE1400000002uLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x0000000200000002uLL},
+{0x0747AE1400000002uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020747AE14uLL},
+{0x0747AE1400000002uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000204DA740EuLL},
+{0x0747AE1400000002uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002026D3A08uLL},
+{0x0747AE1400000002uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x0000000200000002uLL},
+{0x0747AE1400000002uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000001FD92C5FCuLL},
+{0x0747AE1400000002uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000001FB258BF6uLL},
+{0x0747AE1400000002uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000001F8B851F0uLL},
+{0x0747AE1400000002uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001D92C5FA2uLL},
+{0x0747AE1400000002uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018425ED08uLL},
+{0x0747AE1400000002uLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F112E8A6uLL},
+{0x0747AE1400000002uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000082147AE3uLL},
+{0x0747AE1400000002uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x0000000080000002uLL},
+{0x0747AE1400000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000575C291uLL},
+{0x0747AE1400000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000003A3D70CuLL},
+{0x0747AE1400000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000001D1EB87uLL},
+{0x0747AE1400000002uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x0000000400000002uLL},
+{0x0747AE1400000002uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000003FF8B8521uLL},
+{0x0747AE1400000002uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000003FF170A40uLL},
+{0x0747AE1400000002uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000003FEA28F5FuLL},
+{0x0747AE1400000002uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000003F8B851F2uLL},
+{0x0747AE1400000002uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B94A5DA34uLL},
+{0x0747AE1400000002uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BB84C4A8EuLL},
+{0x0747AE1400000002uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000008070F349uLL},
+{0x0747AE1400000002uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x0000000080000002uLL},
+{0x0747AE1400000002uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000000148E27EuLL},
+{0x0747AE1400000002uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000000DB41AAuLL},
+{0x0747AE1400000002uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000006DA0D6uLL},
+{0x0747AE1400000002uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0747AE1400000002uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000002uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000002uLL},
+{0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x0747AE1400000003uLL, 0x0000000000000000uLL},
+{0x0747AE1400000003uLL, 0x0000000000000002uLL, 0x03A3D70A00000001uLL, 0x0000000000000001uLL},
+{0x0747AE1400000003uLL, 0x0000000000000003uLL, 0x026D3A06AAAAAAABuLL, 0x0000000000000002uLL},
+{0x0747AE1400000003uLL, 0x0000000000000010uLL, 0x00747AE140000000uLL, 0x0000000000000003uLL},
+{0x0747AE1400000003uLL, 0x00000000078644FAuLL, 0x00000000F7AE911DuLL, 0x0000000000CC95B1uLL},
+{0x0747AE1400000003uLL, 0x000000000747AE14uLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0x0747AE1400000003uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x000000000E8F5C2BuLL},
+{0x0747AE1400000003uLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x0000000000000003uLL},
+{0x0747AE1400000003uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000015D70A3FuLL},
+{0x0747AE1400000003uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000000E8F5C2BuLL},
+{0x0747AE1400000003uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000747AE17uLL},
+{0x0747AE1400000003uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000000000003uLL},
+{0x0747AE1400000003uLL, 0x0000000100000001uLL, 0x000000000747AE13uLL, 0x00000000F8B851F0uLL},
+{0x0747AE1400000003uLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F170A3DDuLL},
+{0x0747AE1400000003uLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000EA28F5CAuLL},
+{0x0747AE1400000003uLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x000000008B851ED3uLL},
+{0x0747AE1400000003uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000000C50D07DuLL},
+{0x0747AE1400000003uLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000CD13E91FuLL},
+{0x0747AE1400000003uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000084DA7410uLL},
+{0x0747AE1400000003uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x0000000080000003uLL},
+{0x0747AE1400000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000000AEB8521uLL},
+{0x0747AE1400000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000747AE17uLL},
+{0x0747AE1400000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000003A3D70DuLL},
+{0x0747AE1400000003uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x0000000000000003uLL},
+{0x0747AE1400000003uLL, 0x0000000200000001uLL, 0x0000000003A3D709uLL, 0x00000001FC5C28FAuLL},
+{0x0747AE1400000003uLL, 0x0000000200000002uLL, 0x0000000003A3D709uLL, 0x00000001F8B851F1uLL},
+{0x0747AE1400000003uLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001F5147AE8uLL},
+{0x0747AE1400000003uLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001C5C28F73uLL},
+{0x0747AE1400000003uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007847CB09uLL},
+{0x0747AE1400000003uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x000000014B152C2FuLL},
+{0x0747AE1400000003uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x0000000202E978D7uLL},
+{0x0747AE1400000003uLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x0000000200000003uLL},
+{0x0747AE1400000003uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020747AE15uLL},
+{0x0747AE1400000003uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000204DA740FuLL},
+{0x0747AE1400000003uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002026D3A09uLL},
+{0x0747AE1400000003uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x0000000200000003uLL},
+{0x0747AE1400000003uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000001FD92C5FDuLL},
+{0x0747AE1400000003uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000001FB258BF7uLL},
+{0x0747AE1400000003uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000001F8B851F1uLL},
+{0x0747AE1400000003uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001D92C5FA3uLL},
+{0x0747AE1400000003uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018425ED09uLL},
+{0x0747AE1400000003uLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F112E8A7uLL},
+{0x0747AE1400000003uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000082147AE4uLL},
+{0x0747AE1400000003uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x0000000080000003uLL},
+{0x0747AE1400000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000575C292uLL},
+{0x0747AE1400000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000003A3D70DuLL},
+{0x0747AE1400000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000001D1EB88uLL},
+{0x0747AE1400000003uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x0000000400000003uLL},
+{0x0747AE1400000003uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000003FF8B8522uLL},
+{0x0747AE1400000003uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000003FF170A41uLL},
+{0x0747AE1400000003uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000003FEA28F60uLL},
+{0x0747AE1400000003uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000003F8B851F3uLL},
+{0x0747AE1400000003uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B94A5DA35uLL},
+{0x0747AE1400000003uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BB84C4A8FuLL},
+{0x0747AE1400000003uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000008070F34AuLL},
+{0x0747AE1400000003uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x0000000080000003uLL},
+{0x0747AE1400000003uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000000148E27FuLL},
+{0x0747AE1400000003uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000000DB41ABuLL},
+{0x0747AE1400000003uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000006DA0D7uLL},
+{0x0747AE1400000003uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0747AE1400000003uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0747AE1400000003uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000003uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000003uLL},
+{0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x0747AE1400000010uLL, 0x0000000000000000uLL},
+{0x0747AE1400000010uLL, 0x0000000000000002uLL, 0x03A3D70A00000008uLL, 0x0000000000000000uLL},
+{0x0747AE1400000010uLL, 0x0000000000000003uLL, 0x026D3A06AAAAAAB0uLL, 0x0000000000000000uLL},
+{0x0747AE1400000010uLL, 0x0000000000000010uLL, 0x00747AE140000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000010uLL, 0x00000000078644FAuLL, 0x00000000F7AE911DuLL, 0x0000000000CC95BEuLL},
+{0x0747AE1400000010uLL, 0x000000000747AE14uLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0x0747AE1400000010uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x000000000E8F5C38uLL},
+{0x0747AE1400000010uLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x0000000000000010uLL},
+{0x0747AE1400000010uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000015D70A4CuLL},
+{0x0747AE1400000010uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000000E8F5C38uLL},
+{0x0747AE1400000010uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000747AE24uLL},
+{0x0747AE1400000010uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000000000010uLL},
+{0x0747AE1400000010uLL, 0x0000000100000001uLL, 0x000000000747AE13uLL, 0x00000000F8B851FDuLL},
+{0x0747AE1400000010uLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F170A3EAuLL},
+{0x0747AE1400000010uLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000EA28F5D7uLL},
+{0x0747AE1400000010uLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x000000008B851EE0uLL},
+{0x0747AE1400000010uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000000C50D08AuLL},
+{0x0747AE1400000010uLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000CD13E92CuLL},
+{0x0747AE1400000010uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000084DA741DuLL},
+{0x0747AE1400000010uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x0000000080000010uLL},
+{0x0747AE1400000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000000AEB852EuLL},
+{0x0747AE1400000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000747AE24uLL},
+{0x0747AE1400000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000003A3D71AuLL},
+{0x0747AE1400000010uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x0000000000000010uLL},
+{0x0747AE1400000010uLL, 0x0000000200000001uLL, 0x0000000003A3D709uLL, 0x00000001FC5C2907uLL},
+{0x0747AE1400000010uLL, 0x0000000200000002uLL, 0x0000000003A3D709uLL, 0x00000001F8B851FEuLL},
+{0x0747AE1400000010uLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001F5147AF5uLL},
+{0x0747AE1400000010uLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001C5C28F80uLL},
+{0x0747AE1400000010uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007847CB16uLL},
+{0x0747AE1400000010uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x000000014B152C3CuLL},
+{0x0747AE1400000010uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x0000000202E978E4uLL},
+{0x0747AE1400000010uLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x0000000200000010uLL},
+{0x0747AE1400000010uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020747AE22uLL},
+{0x0747AE1400000010uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000204DA741CuLL},
+{0x0747AE1400000010uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002026D3A16uLL},
+{0x0747AE1400000010uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x0000000200000010uLL},
+{0x0747AE1400000010uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000001FD92C60AuLL},
+{0x0747AE1400000010uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000001FB258C04uLL},
+{0x0747AE1400000010uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000001F8B851FEuLL},
+{0x0747AE1400000010uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001D92C5FB0uLL},
+{0x0747AE1400000010uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018425ED16uLL},
+{0x0747AE1400000010uLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F112E8B4uLL},
+{0x0747AE1400000010uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000082147AF1uLL},
+{0x0747AE1400000010uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x0000000080000010uLL},
+{0x0747AE1400000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000575C29FuLL},
+{0x0747AE1400000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000003A3D71AuLL},
+{0x0747AE1400000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000001D1EB95uLL},
+{0x0747AE1400000010uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x0000000400000010uLL},
+{0x0747AE1400000010uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000003FF8B852FuLL},
+{0x0747AE1400000010uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000003FF170A4EuLL},
+{0x0747AE1400000010uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000003FEA28F6DuLL},
+{0x0747AE1400000010uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000003F8B85200uLL},
+{0x0747AE1400000010uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B94A5DA42uLL},
+{0x0747AE1400000010uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BB84C4A9CuLL},
+{0x0747AE1400000010uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000008070F357uLL},
+{0x0747AE1400000010uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x0000000080000010uLL},
+{0x0747AE1400000010uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000000148E28CuLL},
+{0x0747AE1400000010uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000000DB41B8uLL},
+{0x0747AE1400000010uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000006DA0E4uLL},
+{0x0747AE1400000010uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x0747AE1400000010uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x0747AE1400000010uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x0747AE1400000010uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE1400000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE1400000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1400000010uLL},
+{0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL},
+{0x0747AE14078644FAuLL, 0x0000000000000002uLL, 0x03A3D70A03C3227DuLL, 0x0000000000000000uLL},
+{0x0747AE14078644FAuLL, 0x0000000000000003uLL, 0x026D3A06AD2CC1A8uLL, 0x0000000000000002uLL},
+{0x0747AE14078644FAuLL, 0x0000000000000010uLL, 0x00747AE14078644FuLL, 0x000000000000000AuLL},
+{0x0747AE14078644FAuLL, 0x00000000078644FAuLL, 0x00000000F7AE911EuLL, 0x0000000000CC95AEuLL},
+{0x0747AE14078644FAuLL, 0x000000000747AE14uLL, 0x0000000100000001uLL, 0x00000000003E96E6uLL},
+{0x0747AE14078644FAuLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x000000001615A122uLL},
+{0x0747AE14078644FAuLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x00000000078644FAuLL},
+{0x0747AE14078644FAuLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000001D5D4F36uLL},
+{0x0747AE14078644FAuLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000001615A122uLL},
+{0x0747AE14078644FAuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000ECDF30EuLL},
+{0x0747AE14078644FAuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x00000000078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x00000000003E96E6uLL},
+{0x0747AE14078644FAuLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F8F6E8D4uLL},
+{0x0747AE14078644FAuLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000F1AF3AC1uLL},
+{0x0747AE14078644FAuLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x00000000930B63CAuLL},
+{0x0747AE14078644FAuLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x0000000013D71574uLL},
+{0x0747AE14078644FAuLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000D49A2E16uLL},
+{0x0747AE14078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x000000008C60B907uLL},
+{0x0747AE14078644FAuLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x00000000878644FAuLL},
+{0x0747AE14078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000001271CA18uLL},
+{0x0747AE14078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000ECDF30EuLL},
+{0x0747AE14078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x000000000B2A1C04uLL},
+{0x0747AE14078644FAuLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x00000000078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x0000000003E26DF0uLL},
+{0x0747AE14078644FAuLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x00000000003E96E6uLL},
+{0x0747AE14078644FAuLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001FC9ABFDFuLL},
+{0x0747AE14078644FAuLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001CD48D46AuLL},
+{0x0747AE14078644FAuLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007FCE1000uLL},
+{0x0747AE14078644FAuLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x00000001529B7126uLL},
+{0x0747AE14078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x000000020A6FBDCEuLL},
+{0x0747AE14078644FAuLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x00000002078644FAuLL},
+{0x0747AE14078644FAuLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020ECDF30CuLL},
+{0x0747AE14078644FAuLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x000000020C60B906uLL},
+{0x0747AE14078644FAuLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x0000000209F37F00uLL},
+{0x0747AE14078644FAuLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x00000002078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x0000000205190AF4uLL},
+{0x0747AE14078644FAuLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x0000000202ABD0EEuLL},
+{0x0747AE14078644FAuLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000002003E96E8uLL},
+{0x0747AE14078644FAuLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001E0B2A49AuLL},
+{0x0747AE14078644FAuLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018BAC3200uLL},
+{0x0747AE14078644FAuLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F8992D9EuLL},
+{0x0747AE14078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x00000000899ABFDBuLL},
+{0x0747AE14078644FAuLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x00000000878644FAuLL},
+{0x0747AE14078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000CFC0789uLL},
+{0x0747AE14078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x000000000B2A1C04uLL},
+{0x0747AE14078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x000000000958307FuLL},
+{0x0747AE14078644FAuLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x00000004078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x000000040711CA19uLL},
+{0x0747AE14078644FAuLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000004069D4F38uLL},
+{0x0747AE14078644FAuLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x000000040628D457uLL},
+{0x0747AE14078644FAuLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000004003E96EAuLL},
+{0x0747AE14078644FAuLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B9C2C1F2CuLL},
+{0x0747AE14078644FAuLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BBFD28F86uLL},
+{0x0747AE14078644FAuLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x0000000087F73841uLL},
+{0x0747AE14078644FAuLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x00000000878644FAuLL},
+{0x0747AE14078644FAuLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x0000000008CF2776uLL},
+{0x0747AE14078644FAuLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x00000000086186A2uLL},
+{0x0747AE14078644FAuLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x0000000007F3E5CEuLL},
+{0x0747AE14078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x0747AE14078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x0747AE14078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x0747AE14078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE14078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x0747AE14078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE14078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14078644FAuLL},
+{0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000000uLL},
+{0x0747AE140747AE14uLL, 0x0000000000000002uLL, 0x03A3D70A03A3D70AuLL, 0x0000000000000000uLL},
+{0x0747AE140747AE14uLL, 0x0000000000000003uLL, 0x026D3A06AD17E4B1uLL, 0x0000000000000001uLL},
+{0x0747AE140747AE14uLL, 0x0000000000000010uLL, 0x00747AE140747AE1uLL, 0x0000000000000004uLL},
+{0x0747AE140747AE14uLL, 0x00000000078644FAuLL, 0x00000000F7AE911EuLL, 0x00000000008DFEC8uLL},
+{0x0747AE140747AE14uLL, 0x000000000747AE14uLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x0747AE140747AE14uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C28uLL, 0x0000000015D70A3CuLL},
+{0x0747AE140747AE14uLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x000000000747AE14uLL},
+{0x0747AE140747AE14uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000001D1EB850uLL},
+{0x0747AE140747AE14uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x0000000015D70A3CuLL},
+{0x0747AE140747AE14uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000000E8F5C28uLL},
+{0x0747AE140747AE14uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x000000000747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x0000000000000000uLL},
+{0x0747AE140747AE14uLL, 0x0000000100000002uLL, 0x000000000747AE13uLL, 0x00000000F8B851EEuLL},
+{0x0747AE140747AE14uLL, 0x0000000100000003uLL, 0x000000000747AE13uLL, 0x00000000F170A3DBuLL},
+{0x0747AE140747AE14uLL, 0x0000000100000010uLL, 0x000000000747AE13uLL, 0x0000000092CCCCE4uLL},
+{0x0747AE140747AE14uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x0000000013987E8EuLL},
+{0x0747AE140747AE14uLL, 0x000000010747AE14uLL, 0x00000000071425A5uLL, 0x00000000D45B9730uLL},
+{0x0747AE140747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x000000008C222221uLL},
+{0x0747AE140747AE14uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x000000008747AE14uLL},
+{0x0747AE140747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x0000000012333332uLL},
+{0x0747AE140747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000000E8F5C28uLL},
+{0x0747AE140747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x000000000AEB851EuLL},
+{0x0747AE140747AE14uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x000000000747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x0000000003A3D70AuLL},
+{0x0747AE140747AE14uLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x0000000000000000uLL},
+{0x0747AE140747AE14uLL, 0x0000000200000003uLL, 0x0000000003A3D709uLL, 0x00000001FC5C28F9uLL},
+{0x0747AE140747AE14uLL, 0x0000000200000010uLL, 0x0000000003A3D709uLL, 0x00000001CD0A3D84uLL},
+{0x0747AE140747AE14uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000007F8F791AuLL},
+{0x0747AE140747AE14uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x00000001525CDA40uLL},
+{0x0747AE140747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D4uLL, 0x000000020A3126E8uLL},
+{0x0747AE140747AE14uLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x000000020747AE14uLL},
+{0x0747AE140747AE14uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000020E8F5C26uLL},
+{0x0747AE140747AE14uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x000000020C222220uLL},
+{0x0747AE140747AE14uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x0000000209B4E81AuLL},
+{0x0747AE140747AE14uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x000000020747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x0000000204DA740EuLL},
+{0x0747AE140747AE14uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000002026D3A08uLL},
+{0x0747AE140747AE14uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x0000000200000002uLL},
+{0x0747AE140747AE14uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000001E0740DB4uLL},
+{0x0747AE140747AE14uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000018B6D9B1AuLL},
+{0x0747AE140747AE14uLL, 0x000000030747AE14uLL, 0x00000000026764ABuLL, 0x00000002F85A96B8uLL},
+{0x0747AE140747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x00000000895C28F5uLL},
+{0x0747AE140747AE14uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x000000008747AE14uLL},
+{0x0747AE140747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000000CBD70A3uLL},
+{0x0747AE140747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x000000000AEB851EuLL},
+{0x0747AE140747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000009199999uLL},
+{0x0747AE140747AE14uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x000000040747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x0000000406D33333uLL},
+{0x0747AE140747AE14uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000004065EB852uLL},
+{0x0747AE140747AE14uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x0000000405EA3D71uLL},
+{0x0747AE140747AE14uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x0000000400000004uLL},
+{0x0747AE140747AE14uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000B9BED8846uLL},
+{0x0747AE140747AE14uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000BBF93F8A0uLL},
+{0x0747AE140747AE14uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x0000000087B8A15BuLL},
+{0x0747AE140747AE14uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x000000008747AE14uLL},
+{0x0747AE140747AE14uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x0000000008909090uLL},
+{0x0747AE140747AE14uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x000000000822EFBCuLL},
+{0x0747AE140747AE14uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x0000000007B54EE8uLL},
+{0x0747AE140747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x0747AE140747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x0747AE140747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x0747AE140747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x0747AE140747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE140747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE140747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE140747AE14uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000000uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000000000002uLL, 0x03A3D70A3FFFFFFFuLL, 0x0000000000000001uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000000000003uLL, 0x026D3A06D5555555uLL, 0x0000000000000000uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000000000010uLL, 0x00747AE147FFFFFFuLL, 0x000000000000000FuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000F7AE912EuLL, 0x0000000000E20113uLL},
+{0x0747AE147FFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000100000011uLL, 0x00000000043D70ABuLL},
+{0x0747AE147FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C29uLL, 0x000000000E8F5C28uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000080000000uLL, 0x000000000E8F5C28uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000095D70A3BuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000008E8F5C27uLL},
+{0x0747AE147FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000008747AE13uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x0000000078B851EBuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000100000002uLL, 0x000000000747AE14uLL, 0x000000007170A3D7uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000100000003uLL, 0x000000000747AE14uLL, 0x000000006A28F5C3uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000100000010uLL, 0x000000000747AE14uLL, 0x000000000B851EBFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000008C50D079uLL},
+{0x0747AE147FFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000071425A6uLL, 0x0000000045CC3B07uLL},
+{0x0747AE147FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000104DA740CuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x00000000FFFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000008AEB851DuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000008747AE13uLL},
+{0x0747AE147FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000083A3D709uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x000000007FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x000000007C5C28F5uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x0000000078B851EBuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000003A3D70AuLL, 0x0000000075147AE1uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000200000010uLL, 0x0000000003A3D70AuLL, 0x0000000045C28F5FuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x00000000F847CB05uLL},
+{0x0747AE147FFFFFFFuLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x00000001CB152C2BuLL},
+{0x0747AE147FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D5uLL, 0x0000000002E978D4uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000002E978D4uLL, 0x000000027FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000028747AE11uLL},
+{0x0747AE147FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000284DA740BuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002826D3A05uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x000000027FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x000000027D92C5F9uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x000000027B258BF3uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x0000000278B851EDuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000002592C5F9FuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000020425ED05uLL},
+{0x0747AE147FFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000026764ACuLL, 0x0000000069CB3A8FuLL},
+{0x0747AE147FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000102147AE0uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x00000000FFFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000008575C28EuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000083A3D709uLL},
+{0x0747AE147FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000081D1EB84uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x000000047FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x000000047F8B851EuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x000000047F170A3DuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x000000047EA28F5CuLL},
+{0x0747AE147FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x0000000478B851EFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000C14A5DA31uLL},
+{0x0747AE147FFFFFFFuLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000C384C4A8BuLL},
+{0x0747AE147FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000010070F346uLL},
+{0x0747AE147FFFFFFFuLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x00000000FFFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000008148E27BuLL},
+{0x0747AE147FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000080DB41A7uLL},
+{0x0747AE147FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000806DA0D3uLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE147FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE147FFFFFFFuLL},
+{0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x0747AE1480000000uLL, 0x0000000000000000uLL},
+{0x0747AE1480000000uLL, 0x0000000000000002uLL, 0x03A3D70A40000000uLL, 0x0000000000000000uLL},
+{0x0747AE1480000000uLL, 0x0000000000000003uLL, 0x026D3A06D5555555uLL, 0x0000000000000001uLL},
+{0x0747AE1480000000uLL, 0x0000000000000010uLL, 0x00747AE148000000uLL, 0x0000000000000000uLL},
+{0x0747AE1480000000uLL, 0x00000000078644FAuLL, 0x00000000F7AE912EuLL, 0x0000000000E20114uLL},
+{0x0747AE1480000000uLL, 0x000000000747AE14uLL, 0x0000000100000011uLL, 0x00000000043D70ACuLL},
+{0x0747AE1480000000uLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C29uLL, 0x000000000E8F5C29uLL},
+{0x0747AE1480000000uLL, 0x0000000080000000uLL, 0x000000000E8F5C29uLL, 0x0000000000000000uLL},
+{0x0747AE1480000000uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000095D70A3CuLL},
+{0x0747AE1480000000uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000008E8F5C28uLL},
+{0x0747AE1480000000uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000008747AE14uLL},
+{0x0747AE1480000000uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x0000000080000000uLL},
+{0x0747AE1480000000uLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x0000000078B851ECuLL},
+{0x0747AE1480000000uLL, 0x0000000100000002uLL, 0x000000000747AE14uLL, 0x000000007170A3D8uLL},
+{0x0747AE1480000000uLL, 0x0000000100000003uLL, 0x000000000747AE14uLL, 0x000000006A28F5C4uLL},
+{0x0747AE1480000000uLL, 0x0000000100000010uLL, 0x000000000747AE14uLL, 0x000000000B851EC0uLL},
+{0x0747AE1480000000uLL, 0x00000001078644FAuLL, 0x000000000712773FuLL, 0x000000008C50D07AuLL},
+{0x0747AE1480000000uLL, 0x000000010747AE14uLL, 0x00000000071425A6uLL, 0x0000000045CC3B08uLL},
+{0x0747AE1480000000uLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740DuLL, 0x0000000104DA740DuLL},
+{0x0747AE1480000000uLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x0000000100000000uLL},
+{0x0747AE1480000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000008AEB851EuLL},
+{0x0747AE1480000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000008747AE14uLL},
+{0x0747AE1480000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000083A3D70AuLL},
+{0x0747AE1480000000uLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x0000000080000000uLL},
+{0x0747AE1480000000uLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x000000007C5C28F6uLL},
+{0x0747AE1480000000uLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x0000000078B851ECuLL},
+{0x0747AE1480000000uLL, 0x0000000200000003uLL, 0x0000000003A3D70AuLL, 0x0000000075147AE2uLL},
+{0x0747AE1480000000uLL, 0x0000000200000010uLL, 0x0000000003A3D70AuLL, 0x0000000045C28F60uLL},
+{0x0747AE1480000000uLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x00000000F847CB06uLL},
+{0x0747AE1480000000uLL, 0x000000020747AE14uLL, 0x000000000396C6B1uLL, 0x00000001CB152C2CuLL},
+{0x0747AE1480000000uLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D5uLL, 0x0000000002E978D5uLL},
+{0x0747AE1480000000uLL, 0x0000000280000000uLL, 0x0000000002E978D5uLL, 0x0000000000000000uLL},
+{0x0747AE1480000000uLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A06uLL, 0x000000028747AE12uLL},
+{0x0747AE1480000000uLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A06uLL, 0x0000000284DA740CuLL},
+{0x0747AE1480000000uLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A06uLL, 0x00000002826D3A06uLL},
+{0x0747AE1480000000uLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x0000000280000000uLL},
+{0x0747AE1480000000uLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x000000027D92C5FAuLL},
+{0x0747AE1480000000uLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x000000027B258BF4uLL},
+{0x0747AE1480000000uLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x0000000278B851EEuLL},
+{0x0747AE1480000000uLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000002592C5FA0uLL},
+{0x0747AE1480000000uLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000020425ED06uLL},
+{0x0747AE1480000000uLL, 0x000000030747AE14uLL, 0x00000000026764ACuLL, 0x0000000069CB3A90uLL},
+{0x0747AE1480000000uLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000102147AE1uLL},
+{0x0747AE1480000000uLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x0000000100000000uLL},
+{0x0747AE1480000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000008575C28FuLL},
+{0x0747AE1480000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000083A3D70AuLL},
+{0x0747AE1480000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000081D1EB85uLL},
+{0x0747AE1480000000uLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x0000000480000000uLL},
+{0x0747AE1480000000uLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x000000047F8B851FuLL},
+{0x0747AE1480000000uLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x000000047F170A3EuLL},
+{0x0747AE1480000000uLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x000000047EA28F5DuLL},
+{0x0747AE1480000000uLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x0000000478B851F0uLL},
+{0x0747AE1480000000uLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000C14A5DA32uLL},
+{0x0747AE1480000000uLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000C384C4A8CuLL},
+{0x0747AE1480000000uLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000010070F347uLL},
+{0x0747AE1480000000uLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x0000000100000000uLL},
+{0x0747AE1480000000uLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000008148E27CuLL},
+{0x0747AE1480000000uLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000080DB41A8uLL},
+{0x0747AE1480000000uLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000000806DA0D4uLL},
+{0x0747AE1480000000uLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0747AE1480000000uLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE1480000000uLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0747AE1480000000uLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0747AE1480000000uLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x0747AE1480000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x0747AE1480000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x0747AE1480000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0747AE1480000000uLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE1480000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE1480000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE1480000000uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000000000002uLL, 0x03A3D70A7FFFFFFEuLL, 0x0000000000000001uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000000000003uLL, 0x026D3A06FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000000000010uLL, 0x00747AE14FFFFFFFuLL, 0x000000000000000DuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000000078644FAuLL, 0x00000000F7AE913FuLL, 0x0000000000F76C77uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000000747AE14uLL, 0x0000000100000023uLL, 0x0000000001333341uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C2AuLL, 0x000000000E8F5C27uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000000E8F5C29uLL, 0x000000007FFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE15uLL, 0x0000000015D70A3CuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE15uLL, 0x000000000E8F5C27uLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE15uLL, 0x000000000747AE12uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x00000000FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x00000000F8B851E9uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000100000002uLL, 0x000000000747AE14uLL, 0x00000000F170A3D5uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000100000003uLL, 0x000000000747AE14uLL, 0x00000000EA28F5C1uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000100000010uLL, 0x000000000747AE14uLL, 0x000000008B851EBDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000001078644FAuLL, 0x0000000007127740uLL, 0x0000000004CA8B7DuLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000010747AE14uLL, 0x00000000071425A6uLL, 0x00000000C5CC3B05uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740EuLL, 0x0000000004DA740BuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x000000017FFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000010AEB851BuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000010747AE11uLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000103A3D707uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x00000000FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x00000000FC5C28F3uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x00000000F8B851E9uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000003A3D70AuLL, 0x00000000F5147ADFuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000200000010uLL, 0x0000000003A3D70AuLL, 0x00000000C5C28F5DuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000017847CB03uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000020747AE14uLL, 0x000000000396C6B2uLL, 0x0000000043CD7E15uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D5uLL, 0x0000000082E978D2uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000002E978D5uLL, 0x000000007FFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A07uLL, 0x000000000747AE12uLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A07uLL, 0x0000000004DA740BuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A07uLL, 0x00000000026D3A04uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x00000002FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000002FD92C5F7uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000002FB258BF1uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000002F8B851EBuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000002D92C5F9DuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000028425ED03uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000030747AE14uLL, 0x00000000026764ACuLL, 0x00000000E9CB3A8DuLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000182147ADEuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x000000017FFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000010575C28CuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000103A3D707uLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000101D1EB82uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x00000004FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000004FF8B851CuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000004FF170A3BuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000004FEA28F5AuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000004F8B851EDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000C94A5DA2FuLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000CB84C4A89uLL},
+{0x0747AE14FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000018070F344uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x000000017FFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000010148E279uLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000100DB41A5uLL},
+{0x0747AE14FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000001006DA0D1uLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFDuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000000000002uLL, 0x03A3D70A7FFFFFFFuLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000000000003uLL, 0x026D3A06FFFFFFFFuLL, 0x0000000000000001uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000000000010uLL, 0x00747AE14FFFFFFFuLL, 0x000000000000000EuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000000078644FAuLL, 0x00000000F7AE913FuLL, 0x0000000000F76C78uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000000747AE14uLL, 0x0000000100000023uLL, 0x0000000001333342uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C2AuLL, 0x000000000E8F5C28uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000080000000uLL, 0x000000000E8F5C29uLL, 0x000000007FFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE15uLL, 0x0000000015D70A3DuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE15uLL, 0x000000000E8F5C28uLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE15uLL, 0x000000000747AE13uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x00000000FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x00000000F8B851EAuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000100000002uLL, 0x000000000747AE14uLL, 0x00000000F170A3D6uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000100000003uLL, 0x000000000747AE14uLL, 0x00000000EA28F5C2uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000100000010uLL, 0x000000000747AE14uLL, 0x000000008B851EBEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000001078644FAuLL, 0x0000000007127740uLL, 0x0000000004CA8B7EuLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000010747AE14uLL, 0x00000000071425A6uLL, 0x00000000C5CC3B06uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740EuLL, 0x0000000004DA740CuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x000000017FFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000010AEB851CuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000010747AE12uLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000103A3D708uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x00000000FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x00000000FC5C28F4uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x00000000F8B851EAuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000003A3D70AuLL, 0x00000000F5147AE0uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000200000010uLL, 0x0000000003A3D70AuLL, 0x00000000C5C28F5EuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000017847CB04uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000020747AE14uLL, 0x000000000396C6B2uLL, 0x0000000043CD7E16uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D5uLL, 0x0000000082E978D3uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000002E978D5uLL, 0x000000007FFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A07uLL, 0x000000000747AE13uLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A07uLL, 0x0000000004DA740CuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A07uLL, 0x00000000026D3A05uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x00000002FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000002FD92C5F8uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000002FB258BF2uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000002F8B851ECuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000002D92C5F9EuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000028425ED04uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000030747AE14uLL, 0x00000000026764ACuLL, 0x00000000E9CB3A8EuLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000182147ADFuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x000000017FFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000010575C28DuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000103A3D708uLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000101D1EB83uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x00000004FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000004FF8B851DuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000004FF170A3CuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000004FEA28F5BuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000004F8B851EEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000C94A5DA30uLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000CB84C4A8AuLL},
+{0x0747AE14FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000018070F345uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x000000017FFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000010148E27AuLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000100DB41A6uLL},
+{0x0747AE14FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000001006DA0D2uLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFEuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000000000002uLL, 0x03A3D70A7FFFFFFFuLL, 0x0000000000000001uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000000000003uLL, 0x026D3A06FFFFFFFFuLL, 0x0000000000000002uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000000000010uLL, 0x00747AE14FFFFFFFuLL, 0x000000000000000FuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000000078644FAuLL, 0x00000000F7AE913FuLL, 0x0000000000F76C79uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000000747AE14uLL, 0x0000000100000023uLL, 0x0000000001333343uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000000E8F5C2AuLL, 0x000000000E8F5C29uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000000E8F5C29uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE15uLL, 0x0000000015D70A3EuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE15uLL, 0x000000000E8F5C29uLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE15uLL, 0x000000000747AE14uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL, 0x00000000FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000100000001uLL, 0x000000000747AE14uLL, 0x00000000F8B851EBuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000100000002uLL, 0x000000000747AE14uLL, 0x00000000F170A3D7uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000100000003uLL, 0x000000000747AE14uLL, 0x00000000EA28F5C3uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000100000010uLL, 0x000000000747AE14uLL, 0x000000008B851EBFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000001078644FAuLL, 0x0000000007127740uLL, 0x0000000004CA8B7FuLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000071425A6uLL, 0x00000000C5CC3B07uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000004DA740EuLL, 0x0000000004DA740DuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000004DA740DuLL, 0x000000017FFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000003A3D70AuLL, 0x000000010AEB851DuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000003A3D70AuLL, 0x000000010747AE13uLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000003A3D70AuLL, 0x0000000103A3D709uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000003A3D70AuLL, 0x00000000FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000003A3D70AuLL, 0x00000000FC5C28F5uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000003A3D70AuLL, 0x00000000F8B851EBuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000003A3D70AuLL, 0x00000000F5147AE1uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000200000010uLL, 0x0000000003A3D70AuLL, 0x00000000C5C28F5FuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000002078644FAuLL, 0x0000000003965801uLL, 0x000000017847CB05uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000020747AE14uLL, 0x000000000396C6B2uLL, 0x0000000043CD7E17uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000002E978D5uLL, 0x0000000082E978D4uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000002E978D5uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x00000000026D3A07uLL, 0x000000000747AE14uLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x00000000026D3A07uLL, 0x0000000004DA740DuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x00000000026D3A07uLL, 0x00000000026D3A06uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000300000000uLL, 0x00000000026D3A06uLL, 0x00000002FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000300000001uLL, 0x00000000026D3A06uLL, 0x00000002FD92C5F9uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000300000002uLL, 0x00000000026D3A06uLL, 0x00000002FB258BF3uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000300000003uLL, 0x00000000026D3A06uLL, 0x00000002F8B851EDuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000300000010uLL, 0x00000000026D3A06uLL, 0x00000002D92C5F9FuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000002673301uLL, 0x000000028425ED05uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000026764ACuLL, 0x00000000E9CB3A8FuLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000002147AE1uLL, 0x0000000182147AE0uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000002147AE1uLL, 0x000000017FFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000001D1EB85uLL, 0x000000010575C28EuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000001D1EB85uLL, 0x0000000103A3D709uLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000001D1EB85uLL, 0x0000000101D1EB84uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000000747AE1uLL, 0x00000004FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000000747AE1uLL, 0x00000004FF8B851EuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000000747AE1uLL, 0x00000004FF170A3DuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000000747AE1uLL, 0x00000004FEA28F5CuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000000747AE1uLL, 0x00000004F8B851EFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000000744433uLL, 0x0000000C94A5DA31uLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000100747AE14uLL, 0x00000000007445F9uLL, 0x0000000CB84C4A8BuLL},
+{0x0747AE14FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000070F347uLL, 0x000000018070F346uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0000001080000000uLL, 0x000000000070F347uLL, 0x000000017FFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x00000000006DA0D4uLL, 0x000000010148E27BuLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x00000000006DA0D4uLL, 0x0000000100DB41A7uLL},
+{0x0747AE14FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x00000000006DA0D4uLL, 0x00000001006DA0D3uLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x0747AE14FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x0747AE14FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x0747AE14FFFFFFFFuLL},
+{0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x3FFFFFFF80000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000000000003uLL, 0x2AAAAAAA55555555uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000000000010uLL, 0x07FFFFFFF0000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000000078644FAuLL, 0x0000001102D8BD5CuLL, 0x0000000003E2A428uLL},
+{0x7FFFFFFF00000000uLL, 0x000000000747AE14uLL, 0x000000119519529AuLL, 0x00000000052ADFF8uLL},
+{0x7FFFFFFF00000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFF00000000uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000002uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000004uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x0000000080000009uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x0000000000000090uLL},
+{0x7FFFFFFF00000000uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x000000005544910EuLL},
+{0x7FFFFFFF00000000uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x0000000024619090uLL},
+{0x7FFFFFFF00000000uLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555554uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x0000000100000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFDuLL},
+{0x7FFFFFFF00000000uLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000017FFFFFFEuLL},
+{0x7FFFFFFF00000000uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000013FFFFFFFuLL},
+{0x7FFFFFFF00000000uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x0000000100000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000001uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000080000002uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000040000003uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x0000000100000030uLL},
+{0x7FFFFFFF00000000uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001290A84D8uLL},
+{0x7FFFFFFF00000000uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000032B07784uLL},
+{0x7FFFFFFF00000000uLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x0000000233333332uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x0000000200000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000017FFFFFFEuLL},
+{0x7FFFFFFF00000000uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000155555554uLL},
+{0x7FFFFFFF00000000uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAAAAuLL},
+{0x7FFFFFFF00000000uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000100000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000D5555556uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000AAAAAAACuLL},
+{0x7FFFFFFF00000000uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000080000002uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000155555570uLL},
+{0x7FFFFFFF00000000uLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002A39634D2uLL},
+{0x7FFFFFFF00000000uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000620B044uLL},
+{0x7FFFFFFF00000000uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000124924924uLL},
+{0x7FFFFFFF00000000uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000100000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x000000035FFFFFFDuLL},
+{0x7FFFFFFF00000000uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x000000033FFFFFFEuLL},
+{0x7FFFFFFF00000000uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x000000031FFFFFFFuLL},
+{0x7FFFFFFF00000000uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EF8000001uLL},
+{0x7FFFFFFF00000000uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF0000002uLL},
+{0x7FFFFFFF00000000uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EE8000003uLL},
+{0x7FFFFFFF00000000uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E80000010uLL},
+{0x7FFFFFFF00000000uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000903C212C6uLL},
+{0x7FFFFFFF00000000uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000223D54BC0uLL},
+{0x7FFFFFFF00000000uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000107C1F07CuLL},
+{0x7FFFFFFF00000000uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000100000000uLL},
+{0x7FFFFFFF00000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000816969695uLL},
+{0x7FFFFFFF00000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000080F0F0F0EuLL},
+{0x7FFFFFFF00000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000807878787uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6500000000uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFEFuLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFDEuLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFCDuLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B64FFFFFEF0uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6480156B66uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B64843D70ACuLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C80000011uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C80000000uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5400000033uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5400000022uLL},
+{0x7FFFFFFF00000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5400000011uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFEFuLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFDEuLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFCDuLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFEF0uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA80156B66uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA843D70ACuLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A280000011uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A280000000uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A00000033uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A00000022uLL},
+{0x7FFFFFFF00000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A00000011uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000000uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x3FFFFFFF80000000uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000000000003uLL, 0x2AAAAAAA55555555uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000000000010uLL, 0x07FFFFFFF0000000uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000000078644FAuLL, 0x0000001102D8BD5CuLL, 0x0000000003E2A429uLL},
+{0x7FFFFFFF00000001uLL, 0x000000000747AE14uLL, 0x000000119519529AuLL, 0x00000000052ADFF9uLL},
+{0x7FFFFFFF00000001uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000003uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000005uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x000000008000000AuLL},
+{0x7FFFFFFF00000001uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x0000000000000091uLL},
+{0x7FFFFFFF00000001uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x000000005544910FuLL},
+{0x7FFFFFFF00000001uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x0000000024619091uLL},
+{0x7FFFFFFF00000001uLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555555uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x0000000100000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFEuLL},
+{0x7FFFFFFF00000001uLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF00000001uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000140000000uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x0000000100000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000002uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000080000003uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000040000004uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x0000000100000031uLL},
+{0x7FFFFFFF00000001uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001290A84D9uLL},
+{0x7FFFFFFF00000001uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000032B07785uLL},
+{0x7FFFFFFF00000001uLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x0000000233333333uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x0000000200000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF00000001uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000155555555uLL},
+{0x7FFFFFFF00000001uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAAABuLL},
+{0x7FFFFFFF00000001uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000100000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000D5555557uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000AAAAAAADuLL},
+{0x7FFFFFFF00000001uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000080000003uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000155555571uLL},
+{0x7FFFFFFF00000001uLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002A39634D3uLL},
+{0x7FFFFFFF00000001uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000620B045uLL},
+{0x7FFFFFFF00000001uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000124924925uLL},
+{0x7FFFFFFF00000001uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000100000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x000000035FFFFFFEuLL},
+{0x7FFFFFFF00000001uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x000000033FFFFFFFuLL},
+{0x7FFFFFFF00000001uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x0000000320000000uLL},
+{0x7FFFFFFF00000001uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EF8000002uLL},
+{0x7FFFFFFF00000001uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF0000003uLL},
+{0x7FFFFFFF00000001uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EE8000004uLL},
+{0x7FFFFFFF00000001uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E80000011uLL},
+{0x7FFFFFFF00000001uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000903C212C7uLL},
+{0x7FFFFFFF00000001uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000223D54BC1uLL},
+{0x7FFFFFFF00000001uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000107C1F07DuLL},
+{0x7FFFFFFF00000001uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000100000001uLL},
+{0x7FFFFFFF00000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000816969696uLL},
+{0x7FFFFFFF00000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000080F0F0F0FuLL},
+{0x7FFFFFFF00000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000807878788uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6500000001uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFF0uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFDFuLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFCEuLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B64FFFFFEF1uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6480156B67uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B64843D70ADuLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C80000012uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C80000001uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5400000034uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5400000023uLL},
+{0x7FFFFFFF00000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5400000012uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFF0uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFDFuLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFCEuLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFEF1uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA80156B67uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA843D70ADuLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A280000012uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A280000001uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A00000034uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A00000023uLL},
+{0x7FFFFFFF00000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A00000012uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000001uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x3FFFFFFF80000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000000000003uLL, 0x2AAAAAAA55555556uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000000000010uLL, 0x07FFFFFFF0000000uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000000078644FAuLL, 0x0000001102D8BD5CuLL, 0x0000000003E2A42AuLL},
+{0x7FFFFFFF00000002uLL, 0x000000000747AE14uLL, 0x000000119519529AuLL, 0x00000000052ADFFAuLL},
+{0x7FFFFFFF00000002uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000004uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000006uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x000000008000000BuLL},
+{0x7FFFFFFF00000002uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x0000000000000092uLL},
+{0x7FFFFFFF00000002uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x0000000055449110uLL},
+{0x7FFFFFFF00000002uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x0000000024619092uLL},
+{0x7FFFFFFF00000002uLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555556uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x0000000100000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFFuLL},
+{0x7FFFFFFF00000002uLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000180000000uLL},
+{0x7FFFFFFF00000002uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000140000001uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x0000000100000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000003uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000080000004uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000040000005uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x0000000100000032uLL},
+{0x7FFFFFFF00000002uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001290A84DAuLL},
+{0x7FFFFFFF00000002uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000032B07786uLL},
+{0x7FFFFFFF00000002uLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x0000000233333334uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x0000000200000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x0000000180000000uLL},
+{0x7FFFFFFF00000002uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000155555556uLL},
+{0x7FFFFFFF00000002uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAAACuLL},
+{0x7FFFFFFF00000002uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000100000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000D5555558uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000AAAAAAAEuLL},
+{0x7FFFFFFF00000002uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000080000004uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000155555572uLL},
+{0x7FFFFFFF00000002uLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002A39634D4uLL},
+{0x7FFFFFFF00000002uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000620B046uLL},
+{0x7FFFFFFF00000002uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000124924926uLL},
+{0x7FFFFFFF00000002uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000100000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x000000035FFFFFFFuLL},
+{0x7FFFFFFF00000002uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x0000000340000000uLL},
+{0x7FFFFFFF00000002uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x0000000320000001uLL},
+{0x7FFFFFFF00000002uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EF8000003uLL},
+{0x7FFFFFFF00000002uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF0000004uLL},
+{0x7FFFFFFF00000002uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EE8000005uLL},
+{0x7FFFFFFF00000002uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E80000012uLL},
+{0x7FFFFFFF00000002uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000903C212C8uLL},
+{0x7FFFFFFF00000002uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000223D54BC2uLL},
+{0x7FFFFFFF00000002uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000107C1F07EuLL},
+{0x7FFFFFFF00000002uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000100000002uLL},
+{0x7FFFFFFF00000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000816969697uLL},
+{0x7FFFFFFF00000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000080F0F0F10uLL},
+{0x7FFFFFFF00000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000807878789uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6500000002uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFF1uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFE0uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFCFuLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B64FFFFFEF2uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6480156B68uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B64843D70AEuLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C80000013uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C80000002uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5400000035uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5400000024uLL},
+{0x7FFFFFFF00000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5400000013uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFF1uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFE0uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFCFuLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFEF2uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA80156B68uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA843D70AEuLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A280000013uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A280000002uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A00000035uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A00000024uLL},
+{0x7FFFFFFF00000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A00000013uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000002uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x3FFFFFFF80000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000000000003uLL, 0x2AAAAAAA55555556uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000000000010uLL, 0x07FFFFFFF0000000uLL, 0x0000000000000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000000078644FAuLL, 0x0000001102D8BD5CuLL, 0x0000000003E2A42BuLL},
+{0x7FFFFFFF00000003uLL, 0x000000000747AE14uLL, 0x000000119519529AuLL, 0x00000000052ADFFBuLL},
+{0x7FFFFFFF00000003uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000005uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000007uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x000000008000000CuLL},
+{0x7FFFFFFF00000003uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x0000000000000093uLL},
+{0x7FFFFFFF00000003uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x0000000055449111uLL},
+{0x7FFFFFFF00000003uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x0000000024619093uLL},
+{0x7FFFFFFF00000003uLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555557uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x0000000100000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C0000000uLL},
+{0x7FFFFFFF00000003uLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000180000001uLL},
+{0x7FFFFFFF00000003uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000140000002uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x0000000100000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000004uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000080000005uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000040000006uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x0000000100000033uLL},
+{0x7FFFFFFF00000003uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001290A84DBuLL},
+{0x7FFFFFFF00000003uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000032B07787uLL},
+{0x7FFFFFFF00000003uLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x0000000233333335uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x0000000200000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x0000000180000001uLL},
+{0x7FFFFFFF00000003uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000155555557uLL},
+{0x7FFFFFFF00000003uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAAADuLL},
+{0x7FFFFFFF00000003uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000100000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000D5555559uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000AAAAAAAFuLL},
+{0x7FFFFFFF00000003uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000080000005uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000155555573uLL},
+{0x7FFFFFFF00000003uLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002A39634D5uLL},
+{0x7FFFFFFF00000003uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000620B047uLL},
+{0x7FFFFFFF00000003uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000124924927uLL},
+{0x7FFFFFFF00000003uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000100000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x0000000360000000uLL},
+{0x7FFFFFFF00000003uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x0000000340000001uLL},
+{0x7FFFFFFF00000003uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x0000000320000002uLL},
+{0x7FFFFFFF00000003uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EF8000004uLL},
+{0x7FFFFFFF00000003uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF0000005uLL},
+{0x7FFFFFFF00000003uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EE8000006uLL},
+{0x7FFFFFFF00000003uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E80000013uLL},
+{0x7FFFFFFF00000003uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000903C212C9uLL},
+{0x7FFFFFFF00000003uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000223D54BC3uLL},
+{0x7FFFFFFF00000003uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000107C1F07FuLL},
+{0x7FFFFFFF00000003uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000100000003uLL},
+{0x7FFFFFFF00000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000816969698uLL},
+{0x7FFFFFFF00000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000080F0F0F11uLL},
+{0x7FFFFFFF00000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x000000080787878AuLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6500000003uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFF2uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFE1uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFD0uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B64FFFFFEF3uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6480156B69uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B64843D70AFuLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C80000014uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C80000003uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5400000036uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5400000025uLL},
+{0x7FFFFFFF00000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5400000014uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFF2uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFE1uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFD0uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFEF3uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA80156B69uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA843D70AFuLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A280000014uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A280000003uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A00000036uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A00000025uLL},
+{0x7FFFFFFF00000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A00000014uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000003uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x3FFFFFFF80000008uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000000000003uLL, 0x2AAAAAAA5555555AuLL, 0x0000000000000002uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000000000010uLL, 0x07FFFFFFF0000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000010uLL, 0x00000000078644FAuLL, 0x0000001102D8BD5CuLL, 0x0000000003E2A438uLL},
+{0x7FFFFFFF00000010uLL, 0x000000000747AE14uLL, 0x000000119519529AuLL, 0x00000000052AE008uLL},
+{0x7FFFFFFF00000010uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000008000000FuLL},
+{0x7FFFFFFF00000010uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000012uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000014uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x0000000080000019uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x00000000000000A0uLL},
+{0x7FFFFFFF00000010uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x000000005544911EuLL},
+{0x7FFFFFFF00000010uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x00000000246190A0uLL},
+{0x7FFFFFFF00000010uLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555564uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x0000000100000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C000000DuLL},
+{0x7FFFFFFF00000010uLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000018000000EuLL},
+{0x7FFFFFFF00000010uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000014000000FuLL},
+{0x7FFFFFFF00000010uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x0000000100000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000011uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000080000012uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000040000013uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x0000000100000040uLL},
+{0x7FFFFFFF00000010uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001290A84E8uLL},
+{0x7FFFFFFF00000010uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000032B07794uLL},
+{0x7FFFFFFF00000010uLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x0000000233333342uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x0000000200000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000018000000EuLL},
+{0x7FFFFFFF00000010uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000155555564uLL},
+{0x7FFFFFFF00000010uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAABAuLL},
+{0x7FFFFFFF00000010uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000100000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000D5555566uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000AAAAAABCuLL},
+{0x7FFFFFFF00000010uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000080000012uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000155555580uLL},
+{0x7FFFFFFF00000010uLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002A39634E2uLL},
+{0x7FFFFFFF00000010uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000620B054uLL},
+{0x7FFFFFFF00000010uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000124924934uLL},
+{0x7FFFFFFF00000010uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000100000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x000000036000000DuLL},
+{0x7FFFFFFF00000010uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x000000034000000EuLL},
+{0x7FFFFFFF00000010uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x000000032000000FuLL},
+{0x7FFFFFFF00000010uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EF8000011uLL},
+{0x7FFFFFFF00000010uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF0000012uLL},
+{0x7FFFFFFF00000010uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EE8000013uLL},
+{0x7FFFFFFF00000010uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E80000020uLL},
+{0x7FFFFFFF00000010uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000903C212D6uLL},
+{0x7FFFFFFF00000010uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000223D54BD0uLL},
+{0x7FFFFFFF00000010uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000107C1F08CuLL},
+{0x7FFFFFFF00000010uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000100000010uLL},
+{0x7FFFFFFF00000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x00000008169696A5uLL},
+{0x7FFFFFFF00000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000080F0F0F1EuLL},
+{0x7FFFFFFF00000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000807878797uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6500000010uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFFFuLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFEEuLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B64FFFFFFDDuLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B64FFFFFF00uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6480156B76uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B64843D70BCuLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C80000021uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C80000010uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5400000043uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5400000032uLL},
+{0x7FFFFFFF00000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5400000021uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFFFuLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFEEuLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFFDDuLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AAFFFFFF00uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA80156B76uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA843D70BCuLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A280000021uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A280000010uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A00000043uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A00000032uLL},
+{0x7FFFFFFF00000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A00000021uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF00000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF00000010uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x3FFFFFFF83C3227DuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000000000003uLL, 0x2AAAAAAA57D76C53uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000000000010uLL, 0x07FFFFFFF078644FuLL, 0x000000000000000AuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000000078644FAuLL, 0x0000001102D8BD5DuLL, 0x0000000003E2A428uLL},
+{0x7FFFFFFF078644FAuLL, 0x000000000747AE14uLL, 0x000000119519529BuLL, 0x00000000056976DEuLL},
+{0x7FFFFFFF078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x00000000878644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000000878644F9uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x00000000078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x00000000878644FCuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x00000000078644FEuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x0000000087864503uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x000000000786458AuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x000000005CCAD608uLL},
+{0x7FFFFFFF078644FAuLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x000000002BE7D58AuLL},
+{0x7FFFFFFF078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x000000015CDB9A4EuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x00000001078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C78644F7uLL},
+{0x7FFFFFFF078644FAuLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000001878644F8uLL},
+{0x7FFFFFFF078644FAuLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000001478644F9uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x00000001078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C78644FBuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x00000000878644FCuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x00000000478644FDuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x000000010786452AuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x000000013090C9D2uLL},
+{0x7FFFFFFF078644FAuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x000000003A36BC7EuLL},
+{0x7FFFFFFF078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x000000023AB9782CuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x00000002078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x00000001878644F8uLL},
+{0x7FFFFFFF078644FAuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x000000015CDB9A4EuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000013230EFA4uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000001078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000DCDB9A50uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000B230EFA6uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x00000000878644FCuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000015CDB9A6AuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002AB1C79CCuLL},
+{0x7FFFFFFF078644FAuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000DA6F53EuLL},
+{0x7FFFFFFF078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x000000012C188E1EuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000001078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x00000003678644F7uLL},
+{0x7FFFFFFF078644FAuLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x00000003478644F8uLL},
+{0x7FFFFFFF078644FAuLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x00000003278644F9uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EFF8644FBuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF78644FCuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EEF8644FDuLL},
+{0x7FFFFFFF078644FAuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E8786450AuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x000000090B4857C0uLL},
+{0x7FFFFFFF078644FAuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x000000022B5B90BAuLL},
+{0x7FFFFFFF078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x000000010F483576uLL},
+{0x7FFFFFFF078644FAuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000001078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x000000081E1CDB8FuLL},
+{0x7FFFFFFF078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x0000000816955408uLL},
+{0x7FFFFFFF078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x000000080F0DCC81uLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B65078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65078644E9uLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65078644D8uLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65078644C7uLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65078643EAuLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B64879BB060uLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B648BC3B5A6uLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C8786450BuLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C878644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B540786452DuLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B540786451CuLL},
+{0x7FFFFFFF078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B540786450BuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AB078644E9uLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AB078644D8uLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AB078644C7uLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AB078643EAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA879BB060uLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA8BC3B5A6uLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A28786450BuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A2878644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A0786452DuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A0786451CuLL},
+{0x7FFFFFFF078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A0786450BuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF078644FAuLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x3FFFFFFF83A3D70AuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000000000003uLL, 0x2AAAAAAA57C28F5CuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000000000010uLL, 0x07FFFFFFF0747AE1uLL, 0x0000000000000004uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000000078644FAuLL, 0x0000001102D8BD5DuLL, 0x0000000003A40D42uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000000747AE14uLL, 0x000000119519529BuLL, 0x00000000052ADFF8uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000008747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x000000000747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000008747AE13uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x000000000747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL, 0x000000008747AE16uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x000000000747AE18uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000100000003uLL, 0x000000007FFFFFFDuLL, 0x000000008747AE1DuLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x000000000747AEA4uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x000000005C8C3F22uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x000000002BA93EA4uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000055555554uLL, 0x000000015C9D0368uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x000000010747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000001FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C747AE11uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000018747AE12uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000014747AE13uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x000000010747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000000C747AE15uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x000000008747AE16uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x000000004747AE17uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x000000010747AE44uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001305232ECuLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000039F82598uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000033333332uLL, 0x000000023A7AE146uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x000000020747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000018747AE12uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x000000015C9D0368uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x0000000131F258BEuLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x000000010747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000000DC9D036AuLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000000B1F258C0uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x000000008747AE16uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000015C9D0384uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000003078644FAuLL, 0x000000002A40B0A3uLL, 0x00000002AADDE2E6uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000000D685E58uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x000000012BD9F738uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x000000010747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x000000036747AE11uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x000000034747AE12uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x000000032747AE13uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000EFF47AE15uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000EF747AE16uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000EEF47AE17uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000E8747AE24uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x000000090B09C0DAuLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x000000022B1CF9D4uLL},
+{0x7FFFFFFF0747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x000000010F099E90uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x000000010747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x000000081DDE44A9uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000081656BD22uLL},
+{0x7FFFFFFF0747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x000000080ECF359BuLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B650747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B650747AE03uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B650747ADF2uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B650747ADE1uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B650747AD04uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B64875D197AuLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B648B851EC0uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5C8747AE25uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5C8747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B540747AE47uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B540747AE36uLL},
+{0x7FFFFFFF0747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B540747AE25uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AB0747AE03uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AB0747ADF2uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AB0747ADE1uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AB0747AD04uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AA875D197AuLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AA8B851EC0uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A28747AE25uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A28747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A0747AE47uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A0747AE36uLL},
+{0x7FFFFFFF0747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A0747AE25uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF0747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF0747AE14uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x3FFFFFFFBFFFFFFFuLL, 0x0000000000000001uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000003uLL, 0x2AAAAAAA7FFFFFFFuLL, 0x0000000000000002uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000010uLL, 0x07FFFFFFF7FFFFFFuLL, 0x000000000000000FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000001102D8BD6DuLL, 0x0000000003F80F8DuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000000747AE14uLL, 0x00000011951952ACuLL, 0x000000000220A28FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000000000002uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000080000003uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000000000005uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x000000008000008FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x00000000D544910DuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x00000000A461908FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555554uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000055555554uLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x000000003FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000001FFFFFFFDuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFEuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x0000000140000000uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000100000001uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000002uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x000000018000002FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001A90A84D7uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x00000000B2B07783uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x0000000033333332uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000033333332uLL, 0x000000027FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x00000001FFFFFFFDuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x00000001D5555553uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAA9uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x0000000155555555uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAAABuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000100000001uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x00000001D555556FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000001C0FEFD7uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000008620B043uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x00000001A4924923uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x00000003DFFFFFFCuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x00000003BFFFFFFDuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x000000039FFFFFFEuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000F78000000uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000F70000001uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000F68000002uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F0000000FuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000983C212C5uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x00000002A3D54BBFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000187C1F07BuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000896969694uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000088F0F0F0DuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000887878786uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B657FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B657FFFFFEEuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B657FFFFFDDuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B657FFFFFCCuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B657FFFFEEFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6500156B65uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65043D70ABuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D00000010uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5CFFFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5480000032uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5480000021uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5480000010uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFEEuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFDDuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFCCuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFEEFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB00156B65uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB043D70ABuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A300000010uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A2FFFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A80000032uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A80000021uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A80000010uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x3FFFFFFFC0000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000000000003uLL, 0x2AAAAAAA80000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000000000010uLL, 0x07FFFFFFF8000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000000078644FAuLL, 0x0000001102D8BD6DuLL, 0x0000000003F80F8EuLL},
+{0x7FFFFFFF80000000uLL, 0x000000000747AE14uLL, 0x00000011951952ACuLL, 0x000000000220A290uLL},
+{0x7FFFFFFF80000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000000000003uLL},
+{0x7FFFFFFF80000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000080000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000080000004uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000000000006uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000100000010uLL, 0x000000007FFFFFF7uLL, 0x0000000080000090uLL},
+{0x7FFFFFFF80000000uLL, 0x00000001078644FAuLL, 0x000000007C585DADuLL, 0x00000000D544910EuLL},
+{0x7FFFFFFF80000000uLL, 0x000000010747AE14uLL, 0x000000007C75ED2CuLL, 0x00000000A4619090uLL},
+{0x7FFFFFFF80000000uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555555uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x0000000040000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000001FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFFuLL},
+{0x7FFFFFFF80000000uLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x0000000180000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x0000000140000001uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000100000002uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x00000000C0000003uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000200000010uLL, 0x000000003FFFFFFDuLL, 0x0000000180000030uLL},
+{0x7FFFFFFF80000000uLL, 0x00000002078644FAuLL, 0x000000003F12B424uLL, 0x00000001A90A84D8uLL},
+{0x7FFFFFFF80000000uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x00000000B2B07784uLL},
+{0x7FFFFFFF80000000uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x0000000033333333uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x00000001FFFFFFFEuLL},
+{0x7FFFFFFF80000000uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x00000001D5555554uLL},
+{0x7FFFFFFF80000000uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAAAuLL},
+{0x7FFFFFFF80000000uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000180000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x0000000155555556uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x000000012AAAAAACuLL},
+{0x7FFFFFFF80000000uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000100000002uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x00000001D5555570uLL},
+{0x7FFFFFFF80000000uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000001C0FEFD8uLL},
+{0x7FFFFFFF80000000uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000008620B044uLL},
+{0x7FFFFFFF80000000uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x00000001A4924924uLL},
+{0x7FFFFFFF80000000uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000180000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000003FFFFFFFDuLL, 0x000000001FFFFFFFuLL, 0x00000003DFFFFFFDuLL},
+{0x7FFFFFFF80000000uLL, 0x00000003FFFFFFFEuLL, 0x000000001FFFFFFFuLL, 0x00000003BFFFFFFEuLL},
+{0x7FFFFFFF80000000uLL, 0x00000003FFFFFFFFuLL, 0x000000001FFFFFFFuLL, 0x000000039FFFFFFFuLL},
+{0x7FFFFFFF80000000uLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000F80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000F78000001uLL},
+{0x7FFFFFFF80000000uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000F70000002uLL},
+{0x7FFFFFFF80000000uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000F68000003uLL},
+{0x7FFFFFFF80000000uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F00000010uLL},
+{0x7FFFFFFF80000000uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000983C212C6uLL},
+{0x7FFFFFFF80000000uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x00000002A3D54BC0uLL},
+{0x7FFFFFFF80000000uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000187C1F07CuLL},
+{0x7FFFFFFF80000000uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000180000000uLL},
+{0x7FFFFFFF80000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000896969695uLL},
+{0x7FFFFFFF80000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000088F0F0F0EuLL},
+{0x7FFFFFFF80000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000887878787uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6580000000uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B657FFFFFEFuLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B657FFFFFDEuLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B657FFFFFCDuLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B657FFFFEF0uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6500156B66uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65043D70ACuLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D00000011uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D00000000uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5480000033uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5480000022uLL},
+{0x7FFFFFFF80000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5480000011uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AB80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFEFuLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFDEuLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFFCDuLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AB7FFFFEF0uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB00156B66uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB043D70ACuLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A300000011uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A300000000uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709A80000033uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709A80000022uLL},
+{0x7FFFFFFF80000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709A80000011uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFF80000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFF80000000uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000002uLL, 0x3FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAA9uLL, 0x0000000000000002uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000010uLL, 0x07FFFFFFFFFFFFFFuLL, 0x000000000000000DuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF1uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E1339uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000000uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000100000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000001uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000003uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x000000000000007DuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C11uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E279uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555552uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000003FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x00000001FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000000uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000000000001DuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FDBuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07781uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333330uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFBuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555551uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAA7uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000001FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555553uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAA9uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x000000017FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000025555556DuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFD5uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B041uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924921uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000001FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000005FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000003FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000001FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000FFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF7FFFFFEuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FEFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000000uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F8000000DuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C3uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BBDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F079uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000001FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969692uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F0BuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878784uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFECuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFDBuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFCAuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEEDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B63uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70A9uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D8000000EuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D7FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000030uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B550000001FuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B550000000EuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFECuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFDBuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFCAuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEEDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B63uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70A9uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A38000000EuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A37FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000030uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B0000001FuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B0000000EuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000002uLL, 0x3FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAAAuLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000010uLL, 0x07FFFFFFFFFFFFFFuLL, 0x000000000000000EuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF2uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E133AuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000001uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000004uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x000000000000007EuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C12uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E27AuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555553uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000003FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x00000001FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000001uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000000000001EuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FDCuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07782uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333331uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFCuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555552uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAA8uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000001FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555554uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAAAuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000025555556EuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFD6uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B042uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924922uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000001FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000005FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000003FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000001FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000FFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF7FFFFFFuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000001uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F8000000EuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C4uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BBEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F07AuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000001FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969693uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F0CuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878785uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFEDuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFDCuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFCBuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEEEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B64uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70AAuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D8000000FuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D7FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000031uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000020uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B550000000FuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFEDuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFDCuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFCBuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEEEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B64uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70AAuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A38000000FuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A37FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000031uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000020uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B0000000FuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000002uLL, 0x3FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAAAuLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000010uLL, 0x07FFFFFFFFFFFFFFuLL, 0x000000000000000FuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF3uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E133BuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000002uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000005uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x000000000000007FuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C13uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E27BuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555554uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000003FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000200000000uLL, 0x000000003FFFFFFFuLL, 0x00000001FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000000uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000002uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000000000001FuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FDDuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07783uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333332uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555553uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAA9uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000001FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555555uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAABuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000025555556FuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFD7uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B043uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924923uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000001FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000005FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000003FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000001FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000007FFFFFFuLL, 0x0000000FFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF8000000uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000002uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F8000000FuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C5uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BBFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F07BuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000001FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969694uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F0DuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878786uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFEEuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFDDuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFCCuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEEFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B65uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70ABuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D80000010uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D7FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000032uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000021uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5500000010uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFEEuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFDDuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFCCuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEEFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B65uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70ABuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A380000010uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A37FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000032uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000021uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B00000010uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0x8000000000000000uLL, 0x0000000000000001uLL, 0x8000000000000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x0000000000000002uLL, 0x4000000000000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAAAuLL, 0x0000000000000002uLL},
+{0x8000000000000000uLL, 0x0000000000000010uLL, 0x0800000000000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF4uLL},
+{0x8000000000000000uLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E133CuLL},
+{0x8000000000000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000002uLL},
+{0x8000000000000000uLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000003uLL},
+{0x8000000000000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000002uLL},
+{0x8000000000000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000080000000uLL},
+{0x8000000000000000uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0x8000000000000000uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0x8000000000000000uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000006uLL},
+{0x8000000000000000uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x0000000000000080uLL},
+{0x8000000000000000uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C14uLL},
+{0x8000000000000000uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E27CuLL},
+{0x8000000000000000uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555555uLL},
+{0x8000000000000000uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000080000000uLL},
+{0x8000000000000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C0000000uLL},
+{0x8000000000000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000080000000uLL},
+{0x8000000000000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x0000000040000000uLL},
+{0x8000000000000000uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000001uLL},
+{0x8000000000000000uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000002uLL},
+{0x8000000000000000uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000003uLL},
+{0x8000000000000000uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x0000000000000020uLL},
+{0x8000000000000000uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FDEuLL},
+{0x8000000000000000uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07784uLL},
+{0x8000000000000000uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333333uLL},
+{0x8000000000000000uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000080000000uLL},
+{0x8000000000000000uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFEuLL},
+{0x8000000000000000uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555554uLL},
+{0x8000000000000000uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAAAuLL},
+{0x8000000000000000uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000200000000uLL},
+{0x8000000000000000uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555556uLL},
+{0x8000000000000000uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAACuLL},
+{0x8000000000000000uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000002uLL},
+{0x8000000000000000uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000255555570uLL},
+{0x8000000000000000uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFD8uLL},
+{0x8000000000000000uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B044uLL},
+{0x8000000000000000uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924924uLL},
+{0x8000000000000000uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000200000000uLL},
+{0x8000000000000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x0000000060000000uLL},
+{0x8000000000000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x0000000040000000uLL},
+{0x8000000000000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x0000000020000000uLL},
+{0x8000000000000000uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF8000001uLL},
+{0x8000000000000000uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000002uLL},
+{0x8000000000000000uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000003uLL},
+{0x8000000000000000uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F80000010uLL},
+{0x8000000000000000uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C6uLL},
+{0x8000000000000000uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BC0uLL},
+{0x8000000000000000uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F07CuLL},
+{0x8000000000000000uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000200000000uLL},
+{0x8000000000000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969695uLL},
+{0x8000000000000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F0EuLL},
+{0x8000000000000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878787uLL},
+{0x8000000000000000uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6600000000uLL},
+{0x8000000000000000uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFEFuLL},
+{0x8000000000000000uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFDEuLL},
+{0x8000000000000000uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFCDuLL},
+{0x8000000000000000uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEF0uLL},
+{0x8000000000000000uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B66uLL},
+{0x8000000000000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70ACuLL},
+{0x8000000000000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D80000011uLL},
+{0x8000000000000000uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D80000000uLL},
+{0x8000000000000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000033uLL},
+{0x8000000000000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000022uLL},
+{0x8000000000000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5500000011uLL},
+{0x8000000000000000uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC00000000uLL},
+{0x8000000000000000uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFEFuLL},
+{0x8000000000000000uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFDEuLL},
+{0x8000000000000000uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFCDuLL},
+{0x8000000000000000uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEF0uLL},
+{0x8000000000000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B66uLL},
+{0x8000000000000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70ACuLL},
+{0x8000000000000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A380000011uLL},
+{0x8000000000000000uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A380000000uLL},
+{0x8000000000000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000033uLL},
+{0x8000000000000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000022uLL},
+{0x8000000000000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B00000011uLL},
+{0x8000000000000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x8000000000000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x8000000000000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x8000000000000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x8000000000000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF0uLL},
+{0x8000000000000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB06uLL},
+{0x8000000000000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851ECuLL},
+{0x8000000000000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x8000000000000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x8000000000000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x8000000000000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x8000000000000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x8000000000000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000000uLL, 0x8000000000000001uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000000uLL},
+{0x8000000000000001uLL, 0x0000000000000001uLL, 0x8000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000001uLL, 0x0000000000000002uLL, 0x4000000000000000uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAABuLL, 0x0000000000000000uLL},
+{0x8000000000000001uLL, 0x0000000000000010uLL, 0x0800000000000000uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF5uLL},
+{0x8000000000000001uLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E133DuLL},
+{0x8000000000000001uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000003uLL},
+{0x8000000000000001uLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000004uLL},
+{0x8000000000000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000003uLL},
+{0x8000000000000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000080000001uLL},
+{0x8000000000000001uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0x8000000000000001uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL},
+{0x8000000000000001uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000007uLL},
+{0x8000000000000001uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x0000000000000081uLL},
+{0x8000000000000001uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C15uLL},
+{0x8000000000000001uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E27DuLL},
+{0x8000000000000001uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555556uLL},
+{0x8000000000000001uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000080000001uLL},
+{0x8000000000000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C0000001uLL},
+{0x8000000000000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000080000001uLL},
+{0x8000000000000001uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x0000000040000001uLL},
+{0x8000000000000001uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000002uLL},
+{0x8000000000000001uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000003uLL},
+{0x8000000000000001uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000004uLL},
+{0x8000000000000001uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x0000000000000021uLL},
+{0x8000000000000001uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FDFuLL},
+{0x8000000000000001uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07785uLL},
+{0x8000000000000001uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333334uLL},
+{0x8000000000000001uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000080000001uLL},
+{0x8000000000000001uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFFuLL},
+{0x8000000000000001uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555555uLL},
+{0x8000000000000001uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAABuLL},
+{0x8000000000000001uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000200000001uLL},
+{0x8000000000000001uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555557uLL},
+{0x8000000000000001uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAADuLL},
+{0x8000000000000001uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000003uLL},
+{0x8000000000000001uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000255555571uLL},
+{0x8000000000000001uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFD9uLL},
+{0x8000000000000001uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B045uLL},
+{0x8000000000000001uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924925uLL},
+{0x8000000000000001uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000200000001uLL},
+{0x8000000000000001uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x0000000060000001uLL},
+{0x8000000000000001uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x0000000040000001uLL},
+{0x8000000000000001uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x0000000020000001uLL},
+{0x8000000000000001uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF8000002uLL},
+{0x8000000000000001uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000003uLL},
+{0x8000000000000001uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000004uLL},
+{0x8000000000000001uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F80000011uLL},
+{0x8000000000000001uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C7uLL},
+{0x8000000000000001uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BC1uLL},
+{0x8000000000000001uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F07DuLL},
+{0x8000000000000001uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000200000001uLL},
+{0x8000000000000001uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969696uLL},
+{0x8000000000000001uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F0FuLL},
+{0x8000000000000001uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878788uLL},
+{0x8000000000000001uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6600000001uLL},
+{0x8000000000000001uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFF0uLL},
+{0x8000000000000001uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFDFuLL},
+{0x8000000000000001uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFCEuLL},
+{0x8000000000000001uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEF1uLL},
+{0x8000000000000001uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B67uLL},
+{0x8000000000000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70ADuLL},
+{0x8000000000000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D80000012uLL},
+{0x8000000000000001uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D80000001uLL},
+{0x8000000000000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000034uLL},
+{0x8000000000000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000023uLL},
+{0x8000000000000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5500000012uLL},
+{0x8000000000000001uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC00000001uLL},
+{0x8000000000000001uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFF0uLL},
+{0x8000000000000001uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFDFuLL},
+{0x8000000000000001uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFCEuLL},
+{0x8000000000000001uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEF1uLL},
+{0x8000000000000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B67uLL},
+{0x8000000000000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70ADuLL},
+{0x8000000000000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A380000012uLL},
+{0x8000000000000001uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A380000001uLL},
+{0x8000000000000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000034uLL},
+{0x8000000000000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000023uLL},
+{0x8000000000000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B00000012uLL},
+{0x8000000000000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x8000000000000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x8000000000000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x8000000000000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x8000000000000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF1uLL},
+{0x8000000000000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB07uLL},
+{0x8000000000000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EDuLL},
+{0x8000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x8000000000000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x8000000000000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x8000000000000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x8000000000000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x8000000000000001uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x8000000000000001uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000001uLL},
+{0x8000000000000002uLL, 0x0000000000000001uLL, 0x8000000000000002uLL, 0x0000000000000000uLL},
+{0x8000000000000002uLL, 0x0000000000000002uLL, 0x4000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000002uLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAABuLL, 0x0000000000000001uLL},
+{0x8000000000000002uLL, 0x0000000000000010uLL, 0x0800000000000000uLL, 0x0000000000000002uLL},
+{0x8000000000000002uLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF6uLL},
+{0x8000000000000002uLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E133EuLL},
+{0x8000000000000002uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000004uLL},
+{0x8000000000000002uLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0x8000000000000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000005uLL},
+{0x8000000000000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000004uLL},
+{0x8000000000000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000080000002uLL},
+{0x8000000000000002uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000000000002uLL},
+{0x8000000000000002uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000003uLL},
+{0x8000000000000002uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL},
+{0x8000000000000002uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000008uLL},
+{0x8000000000000002uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x0000000000000082uLL},
+{0x8000000000000002uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C16uLL},
+{0x8000000000000002uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E27EuLL},
+{0x8000000000000002uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555557uLL},
+{0x8000000000000002uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000080000002uLL},
+{0x8000000000000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C0000002uLL},
+{0x8000000000000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000080000002uLL},
+{0x8000000000000002uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x0000000040000002uLL},
+{0x8000000000000002uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x0000000000000002uLL},
+{0x8000000000000002uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000003uLL},
+{0x8000000000000002uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000004uLL},
+{0x8000000000000002uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000005uLL},
+{0x8000000000000002uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x0000000000000022uLL},
+{0x8000000000000002uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FE0uLL},
+{0x8000000000000002uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07786uLL},
+{0x8000000000000002uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333335uLL},
+{0x8000000000000002uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000080000002uLL},
+{0x8000000000000002uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x0000000280000000uLL},
+{0x8000000000000002uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555556uLL},
+{0x8000000000000002uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAACuLL},
+{0x8000000000000002uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000200000002uLL},
+{0x8000000000000002uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555558uLL},
+{0x8000000000000002uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAAEuLL},
+{0x8000000000000002uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000004uLL},
+{0x8000000000000002uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000255555572uLL},
+{0x8000000000000002uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFDAuLL},
+{0x8000000000000002uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B046uLL},
+{0x8000000000000002uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924926uLL},
+{0x8000000000000002uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000200000002uLL},
+{0x8000000000000002uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x0000000060000002uLL},
+{0x8000000000000002uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x0000000040000002uLL},
+{0x8000000000000002uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x0000000020000002uLL},
+{0x8000000000000002uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x0000000000000002uLL},
+{0x8000000000000002uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF8000003uLL},
+{0x8000000000000002uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000004uLL},
+{0x8000000000000002uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000005uLL},
+{0x8000000000000002uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F80000012uLL},
+{0x8000000000000002uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C8uLL},
+{0x8000000000000002uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BC2uLL},
+{0x8000000000000002uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F07EuLL},
+{0x8000000000000002uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000200000002uLL},
+{0x8000000000000002uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969697uLL},
+{0x8000000000000002uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F10uLL},
+{0x8000000000000002uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878789uLL},
+{0x8000000000000002uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6600000002uLL},
+{0x8000000000000002uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFF1uLL},
+{0x8000000000000002uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFE0uLL},
+{0x8000000000000002uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFCFuLL},
+{0x8000000000000002uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEF2uLL},
+{0x8000000000000002uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B68uLL},
+{0x8000000000000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70AEuLL},
+{0x8000000000000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D80000013uLL},
+{0x8000000000000002uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D80000002uLL},
+{0x8000000000000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000035uLL},
+{0x8000000000000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000024uLL},
+{0x8000000000000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5500000013uLL},
+{0x8000000000000002uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC00000002uLL},
+{0x8000000000000002uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFF1uLL},
+{0x8000000000000002uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFE0uLL},
+{0x8000000000000002uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFCFuLL},
+{0x8000000000000002uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEF2uLL},
+{0x8000000000000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B68uLL},
+{0x8000000000000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70AEuLL},
+{0x8000000000000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A380000013uLL},
+{0x8000000000000002uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A380000002uLL},
+{0x8000000000000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000035uLL},
+{0x8000000000000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000024uLL},
+{0x8000000000000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B00000013uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x8000000000000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF2uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB08uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EEuLL},
+{0x8000000000000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x8000000000000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x8000000000000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x8000000000000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x8000000000000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x8000000000000002uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x8000000000000002uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x8000000000000002uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000002uLL, 0x8000000000000003uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000002uLL},
+{0x8000000000000003uLL, 0x0000000000000001uLL, 0x8000000000000003uLL, 0x0000000000000000uLL},
+{0x8000000000000003uLL, 0x0000000000000002uLL, 0x4000000000000001uLL, 0x0000000000000001uLL},
+{0x8000000000000003uLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAABuLL, 0x0000000000000002uLL},
+{0x8000000000000003uLL, 0x0000000000000010uLL, 0x0800000000000000uLL, 0x0000000000000003uLL},
+{0x8000000000000003uLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7AF7uLL},
+{0x8000000000000003uLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E133FuLL},
+{0x8000000000000003uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000005uLL},
+{0x8000000000000003uLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0x8000000000000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000006uLL},
+{0x8000000000000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000005uLL},
+{0x8000000000000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000080000003uLL},
+{0x8000000000000003uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000000000003uLL},
+{0x8000000000000003uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000004uLL},
+{0x8000000000000003uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000005uLL},
+{0x8000000000000003uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000009uLL},
+{0x8000000000000003uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x0000000000000083uLL},
+{0x8000000000000003uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C17uLL},
+{0x8000000000000003uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E27FuLL},
+{0x8000000000000003uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555558uLL},
+{0x8000000000000003uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000080000003uLL},
+{0x8000000000000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C0000003uLL},
+{0x8000000000000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000080000003uLL},
+{0x8000000000000003uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x0000000040000003uLL},
+{0x8000000000000003uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x0000000000000003uLL},
+{0x8000000000000003uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000004uLL},
+{0x8000000000000003uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000005uLL},
+{0x8000000000000003uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000006uLL},
+{0x8000000000000003uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x0000000000000023uLL},
+{0x8000000000000003uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FE1uLL},
+{0x8000000000000003uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07787uLL},
+{0x8000000000000003uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333336uLL},
+{0x8000000000000003uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000080000003uLL},
+{0x8000000000000003uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x0000000280000001uLL},
+{0x8000000000000003uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555557uLL},
+{0x8000000000000003uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAADuLL},
+{0x8000000000000003uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000200000003uLL},
+{0x8000000000000003uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555559uLL},
+{0x8000000000000003uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAAAFuLL},
+{0x8000000000000003uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000005uLL},
+{0x8000000000000003uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000255555573uLL},
+{0x8000000000000003uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFDBuLL},
+{0x8000000000000003uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B047uLL},
+{0x8000000000000003uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924927uLL},
+{0x8000000000000003uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000200000003uLL},
+{0x8000000000000003uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x0000000060000003uLL},
+{0x8000000000000003uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x0000000040000003uLL},
+{0x8000000000000003uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x0000000020000003uLL},
+{0x8000000000000003uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x0000000000000003uLL},
+{0x8000000000000003uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF8000004uLL},
+{0x8000000000000003uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000005uLL},
+{0x8000000000000003uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000006uLL},
+{0x8000000000000003uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F80000013uLL},
+{0x8000000000000003uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212C9uLL},
+{0x8000000000000003uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BC3uLL},
+{0x8000000000000003uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F07FuLL},
+{0x8000000000000003uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000200000003uLL},
+{0x8000000000000003uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000916969698uLL},
+{0x8000000000000003uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F11uLL},
+{0x8000000000000003uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x000000090787878AuLL},
+{0x8000000000000003uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6600000003uLL},
+{0x8000000000000003uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFF2uLL},
+{0x8000000000000003uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFE1uLL},
+{0x8000000000000003uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFD0uLL},
+{0x8000000000000003uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFEF3uLL},
+{0x8000000000000003uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B69uLL},
+{0x8000000000000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70AFuLL},
+{0x8000000000000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D80000014uLL},
+{0x8000000000000003uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D80000003uLL},
+{0x8000000000000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000036uLL},
+{0x8000000000000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000025uLL},
+{0x8000000000000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5500000014uLL},
+{0x8000000000000003uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC00000003uLL},
+{0x8000000000000003uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFF2uLL},
+{0x8000000000000003uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFE1uLL},
+{0x8000000000000003uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFD0uLL},
+{0x8000000000000003uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFEF3uLL},
+{0x8000000000000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B69uLL},
+{0x8000000000000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70AFuLL},
+{0x8000000000000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A380000014uLL},
+{0x8000000000000003uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A380000003uLL},
+{0x8000000000000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000036uLL},
+{0x8000000000000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000025uLL},
+{0x8000000000000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B00000014uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF3uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB09uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EFuLL},
+{0x8000000000000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000004uLL},
+{0x8000000000000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x8000000000000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000006uLL},
+{0x8000000000000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0x8000000000000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0x8000000000000003uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0x8000000000000003uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x8000000000000003uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x8000000000000003uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000003uLL, 0x8000000000000010uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000003uLL},
+{0x8000000000000010uLL, 0x0000000000000001uLL, 0x8000000000000010uLL, 0x0000000000000000uLL},
+{0x8000000000000010uLL, 0x0000000000000002uLL, 0x4000000000000008uLL, 0x0000000000000000uLL},
+{0x8000000000000010uLL, 0x0000000000000003uLL, 0x2AAAAAAAAAAAAAB0uLL, 0x0000000000000000uLL},
+{0x8000000000000010uLL, 0x0000000000000010uLL, 0x0800000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000010uLL, 0x00000000078644FAuLL, 0x0000001102D8BD7EuLL, 0x00000000040D7B04uLL},
+{0x8000000000000010uLL, 0x000000000747AE14uLL, 0x00000011951952BDuLL, 0x00000000065E134CuLL},
+{0x8000000000000010uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x0000000000000012uLL},
+{0x8000000000000010uLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0x8000000000000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x0000000080000013uLL},
+{0x8000000000000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000000000012uLL},
+{0x8000000000000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000080000010uLL},
+{0x8000000000000010uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000000000010uLL},
+{0x8000000000000010uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000011uLL},
+{0x8000000000000010uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000012uLL},
+{0x8000000000000010uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000016uLL},
+{0x8000000000000010uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x0000000000000090uLL},
+{0x8000000000000010uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000004DBE4C24uLL},
+{0x8000000000000010uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000001D19E28CuLL},
+{0x8000000000000010uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555565uLL},
+{0x8000000000000010uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000080000010uLL},
+{0x8000000000000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C0000010uLL},
+{0x8000000000000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000080000010uLL},
+{0x8000000000000010uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x0000000040000010uLL},
+{0x8000000000000010uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x0000000000000010uLL},
+{0x8000000000000010uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000011uLL},
+{0x8000000000000010uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000180000012uLL},
+{0x8000000000000010uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x0000000140000013uLL},
+{0x8000000000000010uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x0000000000000030uLL},
+{0x8000000000000010uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000021843FEEuLL},
+{0x8000000000000010uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000132B07794uLL},
+{0x8000000000000010uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000B3333343uLL},
+{0x8000000000000010uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000080000010uLL},
+{0x8000000000000010uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000028000000EuLL},
+{0x8000000000000010uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x0000000255555564uLL},
+{0x8000000000000010uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAABAuLL},
+{0x8000000000000010uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000200000010uLL},
+{0x8000000000000010uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001D5555566uLL},
+{0x8000000000000010uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001AAAAAABCuLL},
+{0x8000000000000010uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000180000012uLL},
+{0x8000000000000010uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x0000000255555580uLL},
+{0x8000000000000010uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000009C0FEFE8uLL},
+{0x8000000000000010uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010620B054uLL},
+{0x8000000000000010uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000224924934uLL},
+{0x8000000000000010uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000200000010uLL},
+{0x8000000000000010uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x0000000060000010uLL},
+{0x8000000000000010uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x0000000040000010uLL},
+{0x8000000000000010uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x0000000020000010uLL},
+{0x8000000000000010uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x0000000000000010uLL},
+{0x8000000000000010uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FF8000011uLL},
+{0x8000000000000010uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF0000012uLL},
+{0x8000000000000010uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FE8000013uLL},
+{0x8000000000000010uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F80000020uLL},
+{0x8000000000000010uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A03C212D6uLL},
+{0x8000000000000010uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000323D54BD0uLL},
+{0x8000000000000010uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000207C1F08CuLL},
+{0x8000000000000010uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000200000010uLL},
+{0x8000000000000010uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x00000009169696A5uLL},
+{0x8000000000000010uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000090F0F0F1EuLL},
+{0x8000000000000010uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000907878797uLL},
+{0x8000000000000010uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6600000010uLL},
+{0x8000000000000010uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFFFuLL},
+{0x8000000000000010uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFEEuLL},
+{0x8000000000000010uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B65FFFFFFDDuLL},
+{0x8000000000000010uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B65FFFFFF00uLL},
+{0x8000000000000010uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6580156B76uLL},
+{0x8000000000000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B65843D70BCuLL},
+{0x8000000000000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D80000021uLL},
+{0x8000000000000010uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D80000010uLL},
+{0x8000000000000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5500000043uLL},
+{0x8000000000000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5500000032uLL},
+{0x8000000000000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5500000021uLL},
+{0x8000000000000010uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC00000010uLL},
+{0x8000000000000010uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFFFuLL},
+{0x8000000000000010uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFEEuLL},
+{0x8000000000000010uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFFDDuLL},
+{0x8000000000000010uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ABFFFFFF00uLL},
+{0x8000000000000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB80156B76uLL},
+{0x8000000000000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB843D70BCuLL},
+{0x8000000000000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A380000021uLL},
+{0x8000000000000010uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A380000010uLL},
+{0x8000000000000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B00000043uLL},
+{0x8000000000000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B00000032uLL},
+{0x8000000000000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B00000021uLL},
+{0x8000000000000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000100000010uLL},
+{0x8000000000000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000010000000FuLL},
+{0x8000000000000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000010000000EuLL},
+{0x8000000000000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000010000000DuLL},
+{0x8000000000000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x8000000000000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB16uLL},
+{0x8000000000000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851FCuLL},
+{0x8000000000000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000011uLL},
+{0x8000000000000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000080000010uLL},
+{0x8000000000000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000013uLL},
+{0x8000000000000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000012uLL},
+{0x8000000000000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000011uLL},
+{0x8000000000000010uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0x8000000000000010uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0x8000000000000010uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0x8000000000000010uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0x8000000000000010uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000000000010uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x8000000000000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000000000010uLL},
+{0x80000000078644FAuLL, 0x0000000000000001uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL},
+{0x80000000078644FAuLL, 0x0000000000000002uLL, 0x4000000003C3227DuLL, 0x0000000000000000uLL},
+{0x80000000078644FAuLL, 0x0000000000000003uLL, 0x2AAAAAAAAD2CC1A8uLL, 0x0000000000000002uLL},
+{0x80000000078644FAuLL, 0x0000000000000010uLL, 0x080000000078644FuLL, 0x000000000000000AuLL},
+{0x80000000078644FAuLL, 0x00000000078644FAuLL, 0x0000001102D8BD7FuLL, 0x00000000040D7AF4uLL},
+{0x80000000078644FAuLL, 0x000000000747AE14uLL, 0x00000011951952BEuLL, 0x00000000069CAA22uLL},
+{0x80000000078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x00000000078644FCuLL},
+{0x80000000078644FAuLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x00000000078644FAuLL},
+{0x80000000078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x00000000878644FDuLL},
+{0x80000000078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x00000000078644FCuLL},
+{0x80000000078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x00000000878644FAuLL},
+{0x80000000078644FAuLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x00000000078644FAuLL},
+{0x80000000078644FAuLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x00000000878644FBuLL},
+{0x80000000078644FAuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x00000000078644FCuLL},
+{0x80000000078644FAuLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x0000000087864500uLL},
+{0x80000000078644FAuLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x000000000786457AuLL},
+{0x80000000078644FAuLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000005544910EuLL},
+{0x80000000078644FAuLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x0000000024A02776uLL},
+{0x80000000078644FAuLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000DCDB9A4FuLL},
+{0x80000000078644FAuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x00000000878644FAuLL},
+{0x80000000078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C78644FAuLL},
+{0x80000000078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x00000000878644FAuLL},
+{0x80000000078644FAuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x00000000478644FAuLL},
+{0x80000000078644FAuLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x00000000078644FAuLL},
+{0x80000000078644FAuLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C78644FBuLL},
+{0x80000000078644FAuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x00000001878644FCuLL},
+{0x80000000078644FAuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x00000001478644FDuLL},
+{0x80000000078644FAuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000000786451AuLL},
+{0x80000000078644FAuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x00000000290A84D8uLL},
+{0x80000000078644FAuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x000000013A36BC7EuLL},
+{0x80000000078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000BAB9782DuLL},
+{0x80000000078644FAuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x00000000878644FAuLL},
+{0x80000000078644FAuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x00000002878644F8uLL},
+{0x80000000078644FAuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x000000025CDB9A4EuLL},
+{0x80000000078644FAuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x000000023230EFA4uLL},
+{0x80000000078644FAuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000002078644FAuLL},
+{0x80000000078644FAuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001DCDB9A50uLL},
+{0x80000000078644FAuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001B230EFA6uLL},
+{0x80000000078644FAuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x00000001878644FCuLL},
+{0x80000000078644FAuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000025CDB9A6AuLL},
+{0x80000000078644FAuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x00000000A39634D2uLL},
+{0x80000000078644FAuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010DA6F53EuLL},
+{0x80000000078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x000000022C188E1EuLL},
+{0x80000000078644FAuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000002078644FAuLL},
+{0x80000000078644FAuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x00000000678644FAuLL},
+{0x80000000078644FAuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x00000000478644FAuLL},
+{0x80000000078644FAuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x00000000278644FAuLL},
+{0x80000000078644FAuLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x00000000078644FAuLL},
+{0x80000000078644FAuLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FFF8644FBuLL},
+{0x80000000078644FAuLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF78644FCuLL},
+{0x80000000078644FAuLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FEF8644FDuLL},
+{0x80000000078644FAuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F8786450AuLL},
+{0x80000000078644FAuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A0B4857C0uLL},
+{0x80000000078644FAuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x000000032B5B90BAuLL},
+{0x80000000078644FAuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x000000020F483576uLL},
+{0x80000000078644FAuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000002078644FAuLL},
+{0x80000000078644FAuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x000000091E1CDB8FuLL},
+{0x80000000078644FAuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x0000000916955408uLL},
+{0x80000000078644FAuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x000000090F0DCC81uLL},
+{0x80000000078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B66078644FAuLL},
+{0x80000000078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B66078644E9uLL},
+{0x80000000078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B66078644D8uLL},
+{0x80000000078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B66078644C7uLL},
+{0x80000000078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B66078643EAuLL},
+{0x80000000078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B65879BB060uLL},
+{0x80000000078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B658BC3B5A6uLL},
+{0x80000000078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D8786450BuLL},
+{0x80000000078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D878644FAuLL},
+{0x80000000078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B550786452DuLL},
+{0x80000000078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B550786451CuLL},
+{0x80000000078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B550786450BuLL},
+{0x80000000078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC078644FAuLL},
+{0x80000000078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AC078644E9uLL},
+{0x80000000078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AC078644D8uLL},
+{0x80000000078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AC078644C7uLL},
+{0x80000000078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AC078643EAuLL},
+{0x80000000078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB879BB060uLL},
+{0x80000000078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB8BC3B5A6uLL},
+{0x80000000078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A38786450BuLL},
+{0x80000000078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A3878644FAuLL},
+{0x80000000078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B0786452DuLL},
+{0x80000000078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B0786451CuLL},
+{0x80000000078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B0786450BuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000001078644FAuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000001078644F9uLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000001078644F8uLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000001078644F7uLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000001078644EAuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000001003E96E6uLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x00000000878644FBuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x00000000878644FAuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000078644FDuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000078644FCuLL},
+{0x80000000078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000078644FBuLL},
+{0x80000000078644FAuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0x80000000078644FAuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0x80000000078644FAuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0x80000000078644FAuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0x80000000078644FAuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0x80000000078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x80000000078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0x80000000078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x80000000078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000078644FAuLL},
+{0x800000000747AE14uLL, 0x0000000000000001uLL, 0x800000000747AE14uLL, 0x0000000000000000uLL},
+{0x800000000747AE14uLL, 0x0000000000000002uLL, 0x4000000003A3D70AuLL, 0x0000000000000000uLL},
+{0x800000000747AE14uLL, 0x0000000000000003uLL, 0x2AAAAAAAAD17E4B1uLL, 0x0000000000000001uLL},
+{0x800000000747AE14uLL, 0x0000000000000010uLL, 0x0800000000747AE1uLL, 0x0000000000000004uLL},
+{0x800000000747AE14uLL, 0x00000000078644FAuLL, 0x0000001102D8BD7FuLL, 0x0000000003CEE40EuLL},
+{0x800000000747AE14uLL, 0x000000000747AE14uLL, 0x00000011951952BEuLL, 0x00000000065E133CuLL},
+{0x800000000747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL, 0x000000000747AE16uLL},
+{0x800000000747AE14uLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x000000000747AE14uLL},
+{0x800000000747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000001uLL, 0x000000008747AE17uLL},
+{0x800000000747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x000000000747AE16uLL},
+{0x800000000747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000008747AE14uLL},
+{0x800000000747AE14uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x000000000747AE14uLL},
+{0x800000000747AE14uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x000000008747AE15uLL},
+{0x800000000747AE14uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x000000000747AE16uLL},
+{0x800000000747AE14uLL, 0x0000000100000003uLL, 0x000000007FFFFFFEuLL, 0x000000008747AE1AuLL},
+{0x800000000747AE14uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x000000000747AE94uLL},
+{0x800000000747AE14uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x000000005505FA28uLL},
+{0x800000000747AE14uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x0000000024619090uLL},
+{0x800000000747AE14uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x00000000DC9D0369uLL},
+{0x800000000747AE14uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000008747AE14uLL},
+{0x800000000747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000C747AE14uLL},
+{0x800000000747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000008747AE14uLL},
+{0x800000000747AE14uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000004747AE14uLL},
+{0x800000000747AE14uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x000000000747AE14uLL},
+{0x800000000747AE14uLL, 0x0000000200000001uLL, 0x000000003FFFFFFFuLL, 0x00000001C747AE15uLL},
+{0x800000000747AE14uLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x000000018747AE16uLL},
+{0x800000000747AE14uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x000000014747AE17uLL},
+{0x800000000747AE14uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000000747AE34uLL},
+{0x800000000747AE14uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000028CBEDF2uLL},
+{0x800000000747AE14uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x0000000139F82598uLL},
+{0x800000000747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000000BA7AE147uLL},
+{0x800000000747AE14uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000008747AE14uLL},
+{0x800000000747AE14uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAAAuLL, 0x000000028747AE12uLL},
+{0x800000000747AE14uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x000000025C9D0368uLL},
+{0x800000000747AE14uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x0000000231F258BEuLL},
+{0x800000000747AE14uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x000000020747AE14uLL},
+{0x800000000747AE14uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000001DC9D036AuLL},
+{0x800000000747AE14uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000001B1F258C0uLL},
+{0x800000000747AE14uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x000000018747AE16uLL},
+{0x800000000747AE14uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x000000025C9D0384uLL},
+{0x800000000747AE14uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x00000000A3579DECuLL},
+{0x800000000747AE14uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000010D685E58uLL},
+{0x800000000747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x000000022BD9F738uLL},
+{0x800000000747AE14uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x000000020747AE14uLL},
+{0x800000000747AE14uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000006747AE14uLL},
+{0x800000000747AE14uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000004747AE14uLL},
+{0x800000000747AE14uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000002747AE14uLL},
+{0x800000000747AE14uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x000000000747AE14uLL},
+{0x800000000747AE14uLL, 0x0000001000000001uLL, 0x0000000007FFFFFFuLL, 0x0000000FFF47AE15uLL},
+{0x800000000747AE14uLL, 0x0000001000000002uLL, 0x0000000007FFFFFFuLL, 0x0000000FF747AE16uLL},
+{0x800000000747AE14uLL, 0x0000001000000003uLL, 0x0000000007FFFFFFuLL, 0x0000000FEF47AE17uLL},
+{0x800000000747AE14uLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x0000000F8747AE24uLL},
+{0x800000000747AE14uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A0B09C0DAuLL},
+{0x800000000747AE14uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x000000032B1CF9D4uLL},
+{0x800000000747AE14uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x000000020F099E90uLL},
+{0x800000000747AE14uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x000000020747AE14uLL},
+{0x800000000747AE14uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x000000091DDE44A9uLL},
+{0x800000000747AE14uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000091656BD22uLL},
+{0x800000000747AE14uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x000000090ECF359BuLL},
+{0x800000000747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B660747AE14uLL},
+{0x800000000747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B660747AE03uLL},
+{0x800000000747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B660747ADF2uLL},
+{0x800000000747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B660747ADE1uLL},
+{0x800000000747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B660747AD04uLL},
+{0x800000000747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B65875D197AuLL},
+{0x800000000747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B658B851EC0uLL},
+{0x800000000747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5D8747AE25uLL},
+{0x800000000747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5D8747AE14uLL},
+{0x800000000747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B550747AE47uLL},
+{0x800000000747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B550747AE36uLL},
+{0x800000000747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B550747AE25uLL},
+{0x800000000747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC0747AE14uLL},
+{0x800000000747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AC0747AE03uLL},
+{0x800000000747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AC0747ADF2uLL},
+{0x800000000747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AC0747ADE1uLL},
+{0x800000000747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AC0747AD04uLL},
+{0x800000000747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AB875D197AuLL},
+{0x800000000747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AB8B851EC0uLL},
+{0x800000000747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A38747AE25uLL},
+{0x800000000747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A38747AE14uLL},
+{0x800000000747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B0747AE47uLL},
+{0x800000000747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B0747AE36uLL},
+{0x800000000747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B0747AE25uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x000000010747AE14uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000010747AE13uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000010747AE12uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000010747AE11uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000010747AE04uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000FFC1691AuLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000008747AE15uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000008747AE14uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x000000000747AE17uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x000000000747AE16uLL},
+{0x800000000747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x000000000747AE15uLL},
+{0x800000000747AE14uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0x800000000747AE14uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0x800000000747AE14uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0x800000000747AE14uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0x800000000747AE14uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0x800000000747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x800000000747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000000747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x800000000747AE14uLL},
+{0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x800000007FFFFFFFuLL, 0x0000000000000002uLL, 0x400000003FFFFFFFuLL, 0x0000000000000001uLL},
+{0x800000007FFFFFFFuLL, 0x0000000000000003uLL, 0x2AAAAAAAD5555555uLL, 0x0000000000000000uLL},
+{0x800000007FFFFFFFuLL, 0x0000000000000010uLL, 0x0800000007FFFFFFuLL, 0x000000000000000FuLL},
+{0x800000007FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000001102D8BD8FuLL, 0x000000000422E659uLL},
+{0x800000007FFFFFFFuLL, 0x000000000747AE14uLL, 0x00000011951952CFuLL, 0x000000000353D5D3uLL},
+{0x800000007FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000002uLL},
+{0x800000007FFFFFFFuLL, 0x0000000080000000uLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000002uLL, 0x0000000000000005uLL},
+{0x800000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000080000001uLL},
+{0x800000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000001uLL, 0x0000000000000000uLL},
+{0x800000007FFFFFFFuLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL},
+{0x800000007FFFFFFFuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0x800000007FFFFFFFuLL, 0x0000000100000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0x800000007FFFFFFFuLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x000000008000007FuLL},
+{0x800000007FFFFFFFuLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x00000000CDBE4C13uLL},
+{0x800000007FFFFFFFuLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000009D19E27BuLL},
+{0x800000007FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x0000000155555554uLL},
+{0x800000007FFFFFFFuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x00000000FFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x000000013FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x00000000FFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x000000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000040000000uLL, 0x000000003FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000000200000002uLL, 0x000000003FFFFFFFuLL, 0x0000000200000001uLL},
+{0x800000007FFFFFFFuLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000002uLL},
+{0x800000007FFFFFFFuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000008000001FuLL},
+{0x800000007FFFFFFFuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x00000000A1843FDDuLL},
+{0x800000007FFFFFFFuLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x00000001B2B07783uLL},
+{0x800000007FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x0000000133333332uLL},
+{0x800000007FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x00000000FFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAABuLL, 0x0000000000000000uLL},
+{0x800000007FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x00000002D5555553uLL},
+{0x800000007FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x00000002AAAAAAA9uLL},
+{0x800000007FFFFFFFuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x0000000255555555uLL},
+{0x800000007FFFFFFFuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAABuLL},
+{0x800000007FFFFFFFuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000200000001uLL},
+{0x800000007FFFFFFFuLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x00000002D555556FuLL},
+{0x800000007FFFFFFFuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000011C0FEFD7uLL},
+{0x800000007FFFFFFFuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000018620B043uLL},
+{0x800000007FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x00000002A4924923uLL},
+{0x800000007FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x000000027FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x00000000DFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x00000000BFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000009FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x000000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000001000000001uLL, 0x0000000008000000uLL, 0x0000000077FFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000001000000002uLL, 0x0000000008000000uLL, 0x000000006FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000001000000003uLL, 0x0000000008000000uLL, 0x0000000067FFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0000001000000010uLL, 0x0000000007FFFFFFuLL, 0x000000100000000FuLL},
+{0x800000007FFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A83C212C5uLL},
+{0x800000007FFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x00000003A3D54BBFuLL},
+{0x800000007FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000287C1F07BuLL},
+{0x800000007FFFFFFFuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x000000027FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000996969694uLL},
+{0x800000007FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000098F0F0F0DuLL},
+{0x800000007FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000987878786uLL},
+{0x800000007FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B667FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B667FFFFFEEuLL},
+{0x800000007FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B667FFFFFDDuLL},
+{0x800000007FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B667FFFFFCCuLL},
+{0x800000007FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B667FFFFEEFuLL},
+{0x800000007FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6600156B65uLL},
+{0x800000007FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B66043D70ABuLL},
+{0x800000007FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5E00000010uLL},
+{0x800000007FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5DFFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5580000032uLL},
+{0x800000007FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5580000021uLL},
+{0x800000007FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5580000010uLL},
+{0x800000007FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFEEuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFDDuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFCCuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFEEFuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AC00156B65uLL},
+{0x800000007FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AC043D70ABuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A400000010uLL},
+{0x800000007FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A3FFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B80000032uLL},
+{0x800000007FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B80000021uLL},
+{0x800000007FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B80000010uLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFCuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFEFuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB05uLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851EBuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x800000007FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x800000007FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x800000007FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x800000007FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0x800000007FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0x800000007FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0x800000007FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0x800000007FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x800000007FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x800000007FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x800000007FFFFFFFuLL},
+{0x8000000080000000uLL, 0x0000000000000001uLL, 0x8000000080000000uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x0000000000000002uLL, 0x4000000040000000uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x0000000000000003uLL, 0x2AAAAAAAD5555555uLL, 0x0000000000000001uLL},
+{0x8000000080000000uLL, 0x0000000000000010uLL, 0x0800000008000000uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x00000000078644FAuLL, 0x0000001102D8BD8FuLL, 0x000000000422E65AuLL},
+{0x8000000080000000uLL, 0x000000000747AE14uLL, 0x00000011951952CFuLL, 0x000000000353D5D4uLL},
+{0x8000000080000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000003uLL, 0x0000000000000003uLL},
+{0x8000000080000000uLL, 0x0000000080000000uLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000002uLL, 0x0000000000000006uLL},
+{0x8000000080000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL, 0x0000000080000002uLL},
+{0x8000000080000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000001uLL, 0x0000000000000001uLL},
+{0x8000000080000000uLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x0000000080000000uLL},
+{0x8000000080000000uLL, 0x0000000100000001uLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0x8000000080000000uLL, 0x0000000100000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL},
+{0x8000000080000000uLL, 0x0000000100000010uLL, 0x000000007FFFFFF8uLL, 0x0000000080000080uLL},
+{0x8000000080000000uLL, 0x00000001078644FAuLL, 0x000000007C585DAEuLL, 0x00000000CDBE4C14uLL},
+{0x8000000080000000uLL, 0x000000010747AE14uLL, 0x000000007C75ED2DuLL, 0x000000009D19E27CuLL},
+{0x8000000080000000uLL, 0x000000017FFFFFFFuLL, 0x0000000055555555uLL, 0x0000000155555555uLL},
+{0x8000000080000000uLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x0000000100000000uLL},
+{0x8000000080000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x0000000140000000uLL},
+{0x8000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000100000000uLL},
+{0x8000000080000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x00000000C0000000uLL},
+{0x8000000080000000uLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x0000000080000000uLL},
+{0x8000000080000000uLL, 0x0000000200000001uLL, 0x0000000040000000uLL, 0x0000000040000000uLL},
+{0x8000000080000000uLL, 0x0000000200000002uLL, 0x0000000040000000uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x0000000200000003uLL, 0x000000003FFFFFFFuLL, 0x00000001C0000003uLL},
+{0x8000000080000000uLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x0000000080000020uLL},
+{0x8000000080000000uLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x00000000A1843FDEuLL},
+{0x8000000080000000uLL, 0x000000020747AE14uLL, 0x000000003F1A4E53uLL, 0x00000001B2B07784uLL},
+{0x8000000080000000uLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x0000000133333333uLL},
+{0x8000000080000000uLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x0000000100000000uLL},
+{0x8000000080000000uLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAABuLL, 0x0000000000000001uLL},
+{0x8000000080000000uLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAAAuLL, 0x00000002D5555554uLL},
+{0x8000000080000000uLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAAAuLL, 0x00000002AAAAAAAAuLL},
+{0x8000000080000000uLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x0000000280000000uLL},
+{0x8000000080000000uLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x0000000255555556uLL},
+{0x8000000080000000uLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x000000022AAAAAACuLL},
+{0x8000000080000000uLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000200000002uLL},
+{0x8000000080000000uLL, 0x0000000300000010uLL, 0x000000002AAAAAA9uLL, 0x00000002D5555570uLL},
+{0x8000000080000000uLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000011C0FEFD8uLL},
+{0x8000000080000000uLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000018620B044uLL},
+{0x8000000080000000uLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x00000002A4924924uLL},
+{0x8000000080000000uLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x0000000280000000uLL},
+{0x8000000080000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x00000000E0000000uLL},
+{0x8000000080000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x00000000C0000000uLL},
+{0x8000000080000000uLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x00000000A0000000uLL},
+{0x8000000080000000uLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x0000000080000000uLL},
+{0x8000000080000000uLL, 0x0000001000000001uLL, 0x0000000008000000uLL, 0x0000000078000000uLL},
+{0x8000000080000000uLL, 0x0000001000000002uLL, 0x0000000008000000uLL, 0x0000000070000000uLL},
+{0x8000000080000000uLL, 0x0000001000000003uLL, 0x0000000008000000uLL, 0x0000000068000000uLL},
+{0x8000000080000000uLL, 0x0000001000000010uLL, 0x0000000008000000uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000A83C212C6uLL},
+{0x8000000080000000uLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x00000003A3D54BC0uLL},
+{0x8000000080000000uLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000287C1F07CuLL},
+{0x8000000080000000uLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x0000000280000000uLL},
+{0x8000000080000000uLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000996969695uLL},
+{0x8000000080000000uLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x000000098F0F0F0EuLL},
+{0x8000000080000000uLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000987878787uLL},
+{0x8000000080000000uLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B6680000000uLL},
+{0x8000000080000000uLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B667FFFFFEFuLL},
+{0x8000000080000000uLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B667FFFFFDEuLL},
+{0x8000000080000000uLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B667FFFFFCDuLL},
+{0x8000000080000000uLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B667FFFFEF0uLL},
+{0x8000000080000000uLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6600156B66uLL},
+{0x8000000080000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B66043D70ACuLL},
+{0x8000000080000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5E00000011uLL},
+{0x8000000080000000uLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5E00000000uLL},
+{0x8000000080000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5580000033uLL},
+{0x8000000080000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5580000022uLL},
+{0x8000000080000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5580000011uLL},
+{0x8000000080000000uLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70AC80000000uLL},
+{0x8000000080000000uLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFEFuLL},
+{0x8000000080000000uLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFDEuLL},
+{0x8000000080000000uLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFFCDuLL},
+{0x8000000080000000uLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70AC7FFFFEF0uLL},
+{0x8000000080000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AC00156B66uLL},
+{0x8000000080000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AC043D70ACuLL},
+{0x8000000080000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A400000011uLL},
+{0x8000000080000000uLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A400000000uLL},
+{0x8000000080000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709B80000033uLL},
+{0x8000000080000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709B80000022uLL},
+{0x8000000080000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709B80000011uLL},
+{0x8000000080000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0x8000000080000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x8000000080000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x8000000080000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x8000000080000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFF0uLL},
+{0x8000000080000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB06uLL},
+{0x8000000080000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851ECuLL},
+{0x8000000080000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x8000000080000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x8000000080000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0x8000000080000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0x8000000080000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0x8000000080000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x8000000080000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x8000000080000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x8000000080000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x8000000080000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0x8000000080000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0x8000000080000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0x8000000080000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x8000000080000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x8000000080000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x8000000080000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x8000000080000000uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000000000002uLL, 0x400000007FFFFFFEuLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000000000003uLL, 0x2AAAAAAAFFFFFFFFuLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000000000010uLL, 0x080000000FFFFFFFuLL, 0x000000000000000DuLL},
+{0x80000000FFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000001102D8BDA0uLL, 0x00000000043851BDuLL},
+{0x80000000FFFFFFFDuLL, 0x000000000747AE14uLL, 0x00000011951952E1uLL, 0x0000000000499869uLL},
+{0x80000000FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000100000004uLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000100000001uLL, 0x000000007FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000002uLL, 0x0000000080000003uLL},
+{0x80000000FFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000002uLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000001uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000080000000uLL, 0x000000007FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000100000003uLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000100000010uLL, 0x000000007FFFFFF9uLL, 0x000000000000006DuLL},
+{0x80000000FFFFFFFDuLL, 0x00000001078644FAuLL, 0x000000007C585DAFuLL, 0x0000000046380717uLL},
+{0x80000000FFFFFFFDuLL, 0x000000010747AE14uLL, 0x000000007C75ED2EuLL, 0x0000000015D23465uLL},
+{0x80000000FFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x0000000055555556uLL, 0x0000000055555553uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000017FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000001BFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000017FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000013FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x00000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000200000001uLL, 0x0000000040000000uLL, 0x00000000BFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000200000002uLL, 0x0000000040000000uLL, 0x000000007FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000200000003uLL, 0x0000000040000000uLL, 0x000000003FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000010000001DuLL},
+{0x80000000FFFFFFFDuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000121843FDBuLL},
+{0x80000000FFFFFFFDuLL, 0x000000020747AE14uLL, 0x000000003F1A4E54uLL, 0x000000002B68C96DuLL},
+{0x80000000FFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000001B3333330uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000017FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAABuLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAABuLL, 0x0000000055555553uLL},
+{0x80000000FFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAABuLL, 0x000000002AAAAAA8uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000002FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000002D5555553uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000002AAAAAAA9uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x000000027FFFFFFFuLL},
+{0x80000000FFFFFFFDuLL, 0x0000000300000010uLL, 0x000000002AAAAAAAuLL, 0x000000005555555DuLL},
+{0x80000000FFFFFFFDuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000019C0FEFD5uLL},
+{0x80000000FFFFFFFDuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000020620B041uLL},
+{0x80000000FFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000324924921uLL},
+{0x80000000FFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000002FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000015FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000013FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000011FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x00000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000001000000001uLL, 0x0000000008000000uLL, 0x00000000F7FFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000001000000002uLL, 0x0000000008000000uLL, 0x00000000EFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000001000000003uLL, 0x0000000008000000uLL, 0x00000000E7FFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0000001000000010uLL, 0x0000000008000000uLL, 0x000000007FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000B03C212C3uLL},
+{0x80000000FFFFFFFDuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000423D54BBDuLL},
+{0x80000000FFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000307C1F079uLL},
+{0x80000000FFFFFFFDuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000002FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000A16969692uLL},
+{0x80000000FFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x0000000A0F0F0F0BuLL},
+{0x80000000FFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000A07878784uLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFECuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFDBuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFCAuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B66FFFFFEEDuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6680156B63uLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B66843D70A9uLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5E8000000EuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5E7FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5600000030uLL},
+{0x80000000FFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B560000001FuLL},
+{0x80000000FFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B560000000EuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFECuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFDBuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFCAuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFEEDuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AC80156B63uLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AC843D70A9uLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A48000000EuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A47FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709C00000030uLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709C0000001FuLL},
+{0x80000000FFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709C0000000EuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFAuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEDuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB03uLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851E9uLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x80000000FFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x80000000FFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x80000000FFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0x80000000FFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0x80000000FFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0x80000000FFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0x80000000FFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFDuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000000000002uLL, 0x400000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000000000003uLL, 0x2AAAAAAAFFFFFFFFuLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000000000010uLL, 0x080000000FFFFFFFuLL, 0x000000000000000EuLL},
+{0x80000000FFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000001102D8BDA0uLL, 0x00000000043851BEuLL},
+{0x80000000FFFFFFFEuLL, 0x000000000747AE14uLL, 0x00000011951952E1uLL, 0x000000000049986AuLL},
+{0x80000000FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000100000004uLL, 0x0000000000000002uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000100000001uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000002uLL, 0x0000000080000004uLL},
+{0x80000000FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000002uLL, 0x0000000000000002uLL},
+{0x80000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000001uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000080000000uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000100000003uLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000100000010uLL, 0x000000007FFFFFF9uLL, 0x000000000000006EuLL},
+{0x80000000FFFFFFFEuLL, 0x00000001078644FAuLL, 0x000000007C585DAFuLL, 0x0000000046380718uLL},
+{0x80000000FFFFFFFEuLL, 0x000000010747AE14uLL, 0x000000007C75ED2EuLL, 0x0000000015D23466uLL},
+{0x80000000FFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x0000000055555556uLL, 0x0000000055555554uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000017FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000001BFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000017FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000013FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x00000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000200000001uLL, 0x0000000040000000uLL, 0x00000000BFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000200000002uLL, 0x0000000040000000uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000200000003uLL, 0x0000000040000000uLL, 0x000000003FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000010000001EuLL},
+{0x80000000FFFFFFFEuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000121843FDCuLL},
+{0x80000000FFFFFFFEuLL, 0x000000020747AE14uLL, 0x000000003F1A4E54uLL, 0x000000002B68C96EuLL},
+{0x80000000FFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000001B3333331uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000017FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAABuLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAABuLL, 0x0000000055555554uLL},
+{0x80000000FFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAABuLL, 0x000000002AAAAAA9uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000002FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000002D5555554uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000002AAAAAAAAuLL},
+{0x80000000FFFFFFFEuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000280000000uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000300000010uLL, 0x000000002AAAAAAAuLL, 0x000000005555555EuLL},
+{0x80000000FFFFFFFEuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000019C0FEFD6uLL},
+{0x80000000FFFFFFFEuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000020620B042uLL},
+{0x80000000FFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000324924922uLL},
+{0x80000000FFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000002FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000015FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000013FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000011FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x00000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000001000000001uLL, 0x0000000008000000uLL, 0x00000000F7FFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000001000000002uLL, 0x0000000008000000uLL, 0x00000000EFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000001000000003uLL, 0x0000000008000000uLL, 0x00000000E7FFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0000001000000010uLL, 0x0000000008000000uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000B03C212C4uLL},
+{0x80000000FFFFFFFEuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000423D54BBEuLL},
+{0x80000000FFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000307C1F07AuLL},
+{0x80000000FFFFFFFEuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000002FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000A16969693uLL},
+{0x80000000FFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x0000000A0F0F0F0CuLL},
+{0x80000000FFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000A07878785uLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFEDuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFDCuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFCBuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B66FFFFFEEEuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6680156B64uLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B66843D70AAuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5E8000000FuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5E7FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5600000031uLL},
+{0x80000000FFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5600000020uLL},
+{0x80000000FFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B560000000FuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFEDuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFDCuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFCBuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFEEEuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AC80156B64uLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AC843D70AAuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A48000000FuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A47FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709C00000031uLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709C00000020uLL},
+{0x80000000FFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709C0000000FuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEEuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB04uLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EAuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x80000000FFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x80000000FFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x80000000FFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0x80000000FFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0x80000000FFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0x80000000FFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0x80000000FFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFEuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000000000002uLL, 0x400000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000000000003uLL, 0x2AAAAAAAFFFFFFFFuLL, 0x0000000000000002uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000000000010uLL, 0x080000000FFFFFFFuLL, 0x000000000000000FuLL},
+{0x80000000FFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000001102D8BDA0uLL, 0x00000000043851BFuLL},
+{0x80000000FFFFFFFFuLL, 0x000000000747AE14uLL, 0x00000011951952E1uLL, 0x000000000049986BuLL},
+{0x80000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000100000004uLL, 0x0000000000000003uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000100000001uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000080000002uLL, 0x0000000080000005uLL},
+{0x80000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000080000002uLL, 0x0000000000000003uLL},
+{0x80000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000080000001uLL, 0x0000000080000000uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000100000002uLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000100000003uLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000100000010uLL, 0x000000007FFFFFF9uLL, 0x000000000000006FuLL},
+{0x80000000FFFFFFFFuLL, 0x00000001078644FAuLL, 0x000000007C585DAFuLL, 0x0000000046380719uLL},
+{0x80000000FFFFFFFFuLL, 0x000000010747AE14uLL, 0x000000007C75ED2EuLL, 0x0000000015D23467uLL},
+{0x80000000FFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x0000000055555556uLL, 0x0000000055555555uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000180000000uLL, 0x0000000055555555uLL, 0x000000017FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000001BFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000017FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000013FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000200000000uLL, 0x0000000040000000uLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000200000001uLL, 0x0000000040000000uLL, 0x00000000BFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000200000002uLL, 0x0000000040000000uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000200000003uLL, 0x0000000040000000uLL, 0x000000003FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000200000010uLL, 0x000000003FFFFFFEuLL, 0x000000010000001FuLL},
+{0x80000000FFFFFFFFuLL, 0x00000002078644FAuLL, 0x000000003F12B425uLL, 0x0000000121843FDDuLL},
+{0x80000000FFFFFFFFuLL, 0x000000020747AE14uLL, 0x000000003F1A4E54uLL, 0x000000002B68C96FuLL},
+{0x80000000FFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000033333333uLL, 0x00000001B3333332uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000033333333uLL, 0x000000017FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x000000002AAAAAABuLL, 0x0000000080000000uLL},
+{0x80000000FFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x000000002AAAAAABuLL, 0x0000000055555555uLL},
+{0x80000000FFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x000000002AAAAAABuLL, 0x000000002AAAAAAAuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000300000000uLL, 0x000000002AAAAAAAuLL, 0x00000002FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000300000001uLL, 0x000000002AAAAAAAuLL, 0x00000002D5555555uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000300000002uLL, 0x000000002AAAAAAAuLL, 0x00000002AAAAAAABuLL},
+{0x80000000FFFFFFFFuLL, 0x0000000300000003uLL, 0x000000002AAAAAAAuLL, 0x0000000280000001uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000300000010uLL, 0x000000002AAAAAAAuLL, 0x000000005555555FuLL},
+{0x80000000FFFFFFFFuLL, 0x00000003078644FAuLL, 0x000000002A40B0A4uLL, 0x000000019C0FEFD7uLL},
+{0x80000000FFFFFFFFuLL, 0x000000030747AE14uLL, 0x000000002A4419E3uLL, 0x000000020620B043uLL},
+{0x80000000FFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000024924924uLL, 0x0000000324924923uLL},
+{0x80000000FFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000024924924uLL, 0x00000002FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000020000000uLL, 0x000000015FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000020000000uLL, 0x000000013FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000020000000uLL, 0x000000011FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000001000000000uLL, 0x0000000008000000uLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000001000000001uLL, 0x0000000008000000uLL, 0x00000000F7FFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000001000000002uLL, 0x0000000008000000uLL, 0x00000000EFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000001000000003uLL, 0x0000000008000000uLL, 0x00000000E7FFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0000001000000010uLL, 0x0000000008000000uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000010078644FAuLL, 0x0000000007FC3EA1uLL, 0x0000000B03C212C5uLL},
+{0x80000000FFFFFFFFuLL, 0x000000100747AE14uLL, 0x0000000007FC5DD0uLL, 0x0000000423D54BBFuLL},
+{0x80000000FFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x0000000007C1F07CuLL, 0x0000000307C1F07BuLL},
+{0x80000000FFFFFFFFuLL, 0x0000001080000000uLL, 0x0000000007C1F07CuLL, 0x00000002FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x0000000007878787uLL, 0x0000000A16969694uLL},
+{0x80000000FFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x0000000007878787uLL, 0x0000000A0F0F0F0DuLL},
+{0x80000000FFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x0000000007878787uLL, 0x0000000A07878786uLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFEEuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFDDuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000011uLL, 0x00156B66FFFFFFCCuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000011uLL, 0x00156B66FFFFFEEFuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000011uLL, 0x00156B6680156B65uLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000011uLL, 0x00156B66843D70ABuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5E80000010uLL},
+{0x80000000FFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000011uLL, 0x00156B5E7FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000011uLL, 0x00156B5600000032uLL},
+{0x80000000FFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000011uLL, 0x00156B5600000021uLL},
+{0x80000000FFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000011uLL, 0x00156B5600000010uLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFEEuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFDDuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFFCCuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000011uLL, 0x043D70ACFFFFFEEFuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000011uLL, 0x043D70AC80156B65uLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000011uLL, 0x043D70AC843D70ABuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000011uLL, 0x043D70A480000010uLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000011uLL, 0x043D70A47FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000011uLL, 0x043D709C00000032uLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000011uLL, 0x043D709C00000021uLL},
+{0x80000000FFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000011uLL, 0x043D709C00000010uLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEFuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB05uLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EBuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0x80000000FFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0x80000000FFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0x80000000FFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0x80000000FFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0x80000000FFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0x80000000FFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0x80000000FFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0x80000000FFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0x80000000FFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0x80000000FFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0x80000000FFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0x80000000FFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0x80000000FFFFFFFFuLL},
+{0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000000000002uLL, 0x7FFFFFFE80000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000000000003uLL, 0x5555555455555555uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000000000010uLL, 0x0FFFFFFFD0000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000000078644FAuLL, 0x0000002205B17A97uLL, 0x0000000000142C8AuLL},
+{0xFFFFFFFD00000000uLL, 0x000000000747AE14uLL, 0x000000232A32A512uLL, 0x0000000001DADE98uLL},
+{0xFFFFFFFD00000000uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD00000000uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFD00000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFD00000000uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000004uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000AuLL},
+{0xFFFFFFFD00000000uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000000000012uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x0000000000000130uLL},
+{0xFFFFFFFD00000000uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B20F6716uLL},
+{0xFFFFFFFD00000000uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000500ACF34uLL},
+{0xFFFFFFFD00000000uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000002AAAAAA9uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x0000000100000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD00000000uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFD00000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFD00000000uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x0000000100000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000002uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000004uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x0000000180000009uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x0000000100000060uLL},
+{0xFFFFFFFD00000000uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001521509B0uLL},
+{0xFFFFFFFD00000000uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x000000016CA89D1CuLL},
+{0xFFFFFFFD00000000uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000E6666665uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000080000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFD00000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001AAAAAAA8uLL},
+{0xFFFFFFFD00000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555554uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000100000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000AAAAAAACuLL},
+{0xFFFFFFFD00000000uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000055555558uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000000000004uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001AAAAAAE0uLL},
+{0xFFFFFFFD00000000uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000013FA624AAuLL},
+{0xFFFFFFFD00000000uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000213890E9CuLL},
+{0xFFFFFFFD00000000uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000149249248uLL},
+{0xFFFFFFFD00000000uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000100000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFDuLL},
+{0xFFFFFFFD00000000uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFD00000000uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000013FFFFFFFuLL},
+{0xFFFFFFFD00000000uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF0000001uLL},
+{0xFFFFFFFD00000000uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE0000002uLL},
+{0xFFFFFFFD00000000uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD0000003uLL},
+{0xFFFFFFFD00000000uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C00000010uLL},
+{0xFFFFFFFD00000000uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000000FFFDE092uLL},
+{0xFFFFFFFD00000000uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000347AA9780uLL},
+{0xFFFFFFFD00000000uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000010F83E0F8uLL},
+{0xFFFFFFFD00000000uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000100000000uLL},
+{0xFFFFFFFD00000000uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F2D2D2D2AuLL},
+{0xFFFFFFFD00000000uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F1E1E1E1CuLL},
+{0xFFFFFFFD00000000uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F0F0F0F0EuLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C900000000uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFDEuLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFBCuLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFF9AuLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFDE0uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8002AD6CCuLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8087AE158uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B800000022uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B800000000uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A700000066uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A700000044uLL},
+{0xFFFFFFFD00000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A700000022uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334100000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333340FFFFFFDDuLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333340FFFFFFBAuLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333340FFFFFF97uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333340FFFFFDD0uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133333FF8A491D2uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334001333344uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F80000023uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F80000000uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E00000069uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E00000046uLL},
+{0xFFFFFFFD00000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E00000023uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF0uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB06uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851ECuLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000000uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFD00000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFD00000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFFuLL},
+{0xFFFFFFFD00000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFEuLL},
+{0xFFFFFFFD00000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFDuLL},
+{0xFFFFFFFD00000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFF0uLL},
+{0xFFFFFFFD00000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFCF879BB06uLL},
+{0xFFFFFFFD00000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFCF8B851ECuLL},
+{0xFFFFFFFD00000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000001uLL},
+{0xFFFFFFFD00000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC80000000uLL},
+{0xFFFFFFFD00000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000003uLL},
+{0xFFFFFFFD00000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000002uLL},
+{0xFFFFFFFD00000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000001uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000000uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000000000002uLL, 0x7FFFFFFE80000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000000000003uLL, 0x5555555455555555uLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000000000010uLL, 0x0FFFFFFFD0000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000000078644FAuLL, 0x0000002205B17A97uLL, 0x0000000000142C8BuLL},
+{0xFFFFFFFD00000001uLL, 0x000000000747AE14uLL, 0x000000232A32A512uLL, 0x0000000001DADE99uLL},
+{0xFFFFFFFD00000001uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFD00000001uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000005uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000BuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000000000013uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x0000000000000131uLL},
+{0xFFFFFFFD00000001uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B20F6717uLL},
+{0xFFFFFFFD00000001uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000500ACF35uLL},
+{0xFFFFFFFD00000001uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000002AAAAAAAuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x0000000100000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD00000001uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFD00000001uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x0000000100000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000003uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000005uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x000000018000000AuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x0000000100000061uLL},
+{0xFFFFFFFD00000001uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001521509B1uLL},
+{0xFFFFFFFD00000001uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x000000016CA89D1DuLL},
+{0xFFFFFFFD00000001uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000E6666666uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000080000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFD00000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001AAAAAAA9uLL},
+{0xFFFFFFFD00000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555555uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000100000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000AAAAAAADuLL},
+{0xFFFFFFFD00000001uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000055555559uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000000000005uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001AAAAAAE1uLL},
+{0xFFFFFFFD00000001uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000013FA624ABuLL},
+{0xFFFFFFFD00000001uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000213890E9DuLL},
+{0xFFFFFFFD00000001uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000149249249uLL},
+{0xFFFFFFFD00000001uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000100000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFEuLL},
+{0xFFFFFFFD00000001uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD00000001uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000140000000uLL},
+{0xFFFFFFFD00000001uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF0000002uLL},
+{0xFFFFFFFD00000001uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE0000003uLL},
+{0xFFFFFFFD00000001uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD0000004uLL},
+{0xFFFFFFFD00000001uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C00000011uLL},
+{0xFFFFFFFD00000001uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000000FFFDE093uLL},
+{0xFFFFFFFD00000001uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000347AA9781uLL},
+{0xFFFFFFFD00000001uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000010F83E0F9uLL},
+{0xFFFFFFFD00000001uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000100000001uLL},
+{0xFFFFFFFD00000001uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F2D2D2D2BuLL},
+{0xFFFFFFFD00000001uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F1E1E1E1DuLL},
+{0xFFFFFFFD00000001uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F0F0F0F0FuLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C900000001uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFDFuLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFBDuLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFF9BuLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFDE1uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8002AD6CDuLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8087AE159uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B800000023uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B800000001uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A700000067uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A700000045uLL},
+{0xFFFFFFFD00000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A700000023uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334100000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333340FFFFFFDEuLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333340FFFFFFBBuLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333340FFFFFF98uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333340FFFFFDD1uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133333FF8A491D3uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334001333345uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F80000024uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F80000001uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E0000006AuLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E00000047uLL},
+{0xFFFFFFFD00000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E00000024uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF1uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB07uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EDuLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000004uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFD00000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFD00000001uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD00000001uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFFuLL},
+{0xFFFFFFFD00000001uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFEuLL},
+{0xFFFFFFFD00000001uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFF1uLL},
+{0xFFFFFFFD00000001uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFCF879BB07uLL},
+{0xFFFFFFFD00000001uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFCF8B851EDuLL},
+{0xFFFFFFFD00000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000002uLL},
+{0xFFFFFFFD00000001uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC80000001uLL},
+{0xFFFFFFFD00000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000004uLL},
+{0xFFFFFFFD00000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000003uLL},
+{0xFFFFFFFD00000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000002uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000001uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000000000002uLL, 0x7FFFFFFE80000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000000000003uLL, 0x5555555455555556uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000000000010uLL, 0x0FFFFFFFD0000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000000078644FAuLL, 0x0000002205B17A97uLL, 0x0000000000142C8CuLL},
+{0xFFFFFFFD00000002uLL, 0x000000000747AE14uLL, 0x000000232A32A512uLL, 0x0000000001DADE9AuLL},
+{0xFFFFFFFD00000002uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000006uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000CuLL},
+{0xFFFFFFFD00000002uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000000000014uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x0000000000000132uLL},
+{0xFFFFFFFD00000002uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B20F6718uLL},
+{0xFFFFFFFD00000002uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000500ACF36uLL},
+{0xFFFFFFFD00000002uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000002AAAAAABuLL},
+{0xFFFFFFFD00000002uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x0000000100000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFD00000002uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x0000000180000000uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x0000000100000002uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000004uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000006uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x000000018000000BuLL},
+{0xFFFFFFFD00000002uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x0000000100000062uLL},
+{0xFFFFFFFD00000002uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001521509B2uLL},
+{0xFFFFFFFD00000002uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x000000016CA89D1EuLL},
+{0xFFFFFFFD00000002uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000E6666667uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000080000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFD00000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001AAAAAAAAuLL},
+{0xFFFFFFFD00000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555556uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000100000002uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000AAAAAAAEuLL},
+{0xFFFFFFFD00000002uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000005555555AuLL},
+{0xFFFFFFFD00000002uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000000000006uLL},
+{0xFFFFFFFD00000002uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001AAAAAAE2uLL},
+{0xFFFFFFFD00000002uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000013FA624ACuLL},
+{0xFFFFFFFD00000002uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000213890E9EuLL},
+{0xFFFFFFFD00000002uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x000000014924924AuLL},
+{0xFFFFFFFD00000002uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000100000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFFuLL},
+{0xFFFFFFFD00000002uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000180000000uLL},
+{0xFFFFFFFD00000002uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000140000001uLL},
+{0xFFFFFFFD00000002uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000002uLL},
+{0xFFFFFFFD00000002uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF0000003uLL},
+{0xFFFFFFFD00000002uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE0000004uLL},
+{0xFFFFFFFD00000002uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD0000005uLL},
+{0xFFFFFFFD00000002uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C00000012uLL},
+{0xFFFFFFFD00000002uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000000FFFDE094uLL},
+{0xFFFFFFFD00000002uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000347AA9782uLL},
+{0xFFFFFFFD00000002uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000010F83E0FAuLL},
+{0xFFFFFFFD00000002uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000100000002uLL},
+{0xFFFFFFFD00000002uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F2D2D2D2CuLL},
+{0xFFFFFFFD00000002uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F1E1E1E1EuLL},
+{0xFFFFFFFD00000002uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F0F0F0F10uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C900000002uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFE0uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFBEuLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFF9CuLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFDE2uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8002AD6CEuLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8087AE15AuLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B800000024uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B800000002uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A700000068uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A700000046uLL},
+{0xFFFFFFFD00000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A700000024uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334100000002uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333340FFFFFFDFuLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333340FFFFFFBCuLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333340FFFFFF99uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333340FFFFFDD2uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133333FF8A491D4uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334001333346uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F80000025uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F80000002uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E0000006BuLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E00000048uLL},
+{0xFFFFFFFD00000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E00000025uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF2uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB08uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EEuLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000003uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000005uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000004uLL},
+{0xFFFFFFFD00000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFD00000002uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFD00000002uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD00000002uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFFuLL},
+{0xFFFFFFFD00000002uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFF2uLL},
+{0xFFFFFFFD00000002uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFCF879BB08uLL},
+{0xFFFFFFFD00000002uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFCF8B851EEuLL},
+{0xFFFFFFFD00000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000003uLL},
+{0xFFFFFFFD00000002uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC80000002uLL},
+{0xFFFFFFFD00000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000005uLL},
+{0xFFFFFFFD00000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000004uLL},
+{0xFFFFFFFD00000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000003uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000002uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000000000002uLL, 0x7FFFFFFE80000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000000000003uLL, 0x5555555455555556uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000000000010uLL, 0x0FFFFFFFD0000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000000078644FAuLL, 0x0000002205B17A97uLL, 0x0000000000142C8DuLL},
+{0xFFFFFFFD00000003uLL, 0x000000000747AE14uLL, 0x000000232A32A512uLL, 0x0000000001DADE9BuLL},
+{0xFFFFFFFD00000003uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x0000000000000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000007uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000DuLL},
+{0xFFFFFFFD00000003uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000000000015uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x0000000000000133uLL},
+{0xFFFFFFFD00000003uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B20F6719uLL},
+{0xFFFFFFFD00000003uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000500ACF37uLL},
+{0xFFFFFFFD00000003uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000002AAAAAACuLL},
+{0xFFFFFFFD00000003uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x0000000100000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0xFFFFFFFD00000003uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x0000000180000001uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x0000000100000003uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000005uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000007uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x000000018000000CuLL},
+{0xFFFFFFFD00000003uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x0000000100000063uLL},
+{0xFFFFFFFD00000003uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001521509B3uLL},
+{0xFFFFFFFD00000003uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x000000016CA89D1FuLL},
+{0xFFFFFFFD00000003uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000E6666668uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000080000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFD00000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001AAAAAAABuLL},
+{0xFFFFFFFD00000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555557uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000100000003uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000AAAAAAAFuLL},
+{0xFFFFFFFD00000003uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000005555555BuLL},
+{0xFFFFFFFD00000003uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000000000007uLL},
+{0xFFFFFFFD00000003uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001AAAAAAE3uLL},
+{0xFFFFFFFD00000003uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000013FA624ADuLL},
+{0xFFFFFFFD00000003uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000213890E9FuLL},
+{0xFFFFFFFD00000003uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x000000014924924BuLL},
+{0xFFFFFFFD00000003uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000100000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C0000000uLL},
+{0xFFFFFFFD00000003uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000180000001uLL},
+{0xFFFFFFFD00000003uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000140000002uLL},
+{0xFFFFFFFD00000003uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000003uLL},
+{0xFFFFFFFD00000003uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF0000004uLL},
+{0xFFFFFFFD00000003uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE0000005uLL},
+{0xFFFFFFFD00000003uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD0000006uLL},
+{0xFFFFFFFD00000003uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C00000013uLL},
+{0xFFFFFFFD00000003uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000000FFFDE095uLL},
+{0xFFFFFFFD00000003uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000347AA9783uLL},
+{0xFFFFFFFD00000003uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000010F83E0FBuLL},
+{0xFFFFFFFD00000003uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000100000003uLL},
+{0xFFFFFFFD00000003uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F2D2D2D2DuLL},
+{0xFFFFFFFD00000003uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F1E1E1E1FuLL},
+{0xFFFFFFFD00000003uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F0F0F0F11uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C900000003uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFE1uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFBFuLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFF9DuLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFDE3uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8002AD6CFuLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8087AE15BuLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B800000025uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B800000003uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A700000069uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A700000047uLL},
+{0xFFFFFFFD00000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A700000025uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334100000003uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333340FFFFFFE0uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333340FFFFFFBDuLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333340FFFFFF9AuLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333340FFFFFDD3uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133333FF8A491D5uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334001333347uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F80000026uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F80000003uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E0000006CuLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E00000049uLL},
+{0xFFFFFFFD00000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E00000026uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF3uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB09uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EFuLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000004uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000003uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000006uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000005uLL},
+{0xFFFFFFFD00000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000004uLL},
+{0xFFFFFFFD00000003uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFD00000003uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFD00000003uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD00000003uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFF3uLL},
+{0xFFFFFFFD00000003uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFCF879BB09uLL},
+{0xFFFFFFFD00000003uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFCF8B851EFuLL},
+{0xFFFFFFFD00000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000004uLL},
+{0xFFFFFFFD00000003uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC80000003uLL},
+{0xFFFFFFFD00000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000006uLL},
+{0xFFFFFFFD00000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000005uLL},
+{0xFFFFFFFD00000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000004uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000003uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000000000002uLL, 0x7FFFFFFE80000008uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000000000003uLL, 0x555555545555555AuLL, 0x0000000000000002uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000000000010uLL, 0x0FFFFFFFD0000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000010uLL, 0x00000000078644FAuLL, 0x0000002205B17A97uLL, 0x0000000000142C9AuLL},
+{0xFFFFFFFD00000010uLL, 0x000000000747AE14uLL, 0x000000232A32A512uLL, 0x0000000001DADEA8uLL},
+{0xFFFFFFFD00000010uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000000000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x0000000000000010uLL},
+{0xFFFFFFFD00000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0xFFFFFFFD00000010uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x000000000000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x000000000000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000010uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000014uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000000000001AuLL},
+{0xFFFFFFFD00000010uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000000000022uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x0000000000000140uLL},
+{0xFFFFFFFD00000010uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B20F6726uLL},
+{0xFFFFFFFD00000010uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000500ACF44uLL},
+{0xFFFFFFFD00000010uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000002AAAAAB9uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x0000000100000010uLL},
+{0xFFFFFFFD00000010uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000008000000DuLL},
+{0xFFFFFFFD00000010uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000000000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x000000018000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x0000000100000010uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000080000012uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000000000014uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x0000000180000019uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x0000000100000070uLL},
+{0xFFFFFFFD00000010uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001521509C0uLL},
+{0xFFFFFFFD00000010uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x000000016CA89D2CuLL},
+{0xFFFFFFFD00000010uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000E6666675uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000080000010uLL},
+{0xFFFFFFFD00000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x000000020000000CuLL},
+{0xFFFFFFFD00000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001AAAAAAB8uLL},
+{0xFFFFFFFD00000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000155555564uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000100000010uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000AAAAAABCuLL},
+{0xFFFFFFFD00000010uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000055555568uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000000000014uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001AAAAAAF0uLL},
+{0xFFFFFFFD00000010uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000013FA624BAuLL},
+{0xFFFFFFFD00000010uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000213890EACuLL},
+{0xFFFFFFFD00000010uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000149249258uLL},
+{0xFFFFFFFD00000010uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000100000010uLL},
+{0xFFFFFFFD00000010uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C000000DuLL},
+{0xFFFFFFFD00000010uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000018000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000014000000FuLL},
+{0xFFFFFFFD00000010uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000010uLL},
+{0xFFFFFFFD00000010uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF0000011uLL},
+{0xFFFFFFFD00000010uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE0000012uLL},
+{0xFFFFFFFD00000010uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD0000013uLL},
+{0xFFFFFFFD00000010uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C00000020uLL},
+{0xFFFFFFFD00000010uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000000FFFDE0A2uLL},
+{0xFFFFFFFD00000010uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000347AA9790uLL},
+{0xFFFFFFFD00000010uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000010F83E108uLL},
+{0xFFFFFFFD00000010uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000100000010uLL},
+{0xFFFFFFFD00000010uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F2D2D2D3AuLL},
+{0xFFFFFFFD00000010uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F1E1E1E2CuLL},
+{0xFFFFFFFD00000010uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F0F0F0F1EuLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C900000010uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFEEuLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFCCuLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFFAAuLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C8FFFFFDF0uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8002AD6DCuLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8087AE168uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B800000032uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B800000010uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A700000076uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A700000054uLL},
+{0xFFFFFFFD00000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A700000032uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334100000010uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333340FFFFFFEDuLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333340FFFFFFCAuLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333340FFFFFFA7uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333340FFFFFDE0uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133333FF8A491E2uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334001333354uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F80000033uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F80000010uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E00000079uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E00000056uLL},
+{0xFFFFFFFD00000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E00000033uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000010uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE0000000FuLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE0000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE0000000DuLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB16uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851FCuLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000011uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000010uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000013uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000012uLL},
+{0xFFFFFFFD00000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000011uLL},
+{0xFFFFFFFD00000010uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD0000000FuLL},
+{0xFFFFFFFD00000010uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD0000000EuLL},
+{0xFFFFFFFD00000010uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFD0000000DuLL},
+{0xFFFFFFFD00000010uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD00000010uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFCF879BB16uLL},
+{0xFFFFFFFD00000010uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFCF8B851FCuLL},
+{0xFFFFFFFD00000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000011uLL},
+{0xFFFFFFFD00000010uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC80000010uLL},
+{0xFFFFFFFD00000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000013uLL},
+{0xFFFFFFFD00000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000012uLL},
+{0xFFFFFFFD00000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC00000011uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD00000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD00000010uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000000000002uLL, 0x7FFFFFFE83C3227DuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000000000003uLL, 0x5555555457D76C53uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000000000010uLL, 0x0FFFFFFFD078644FuLL, 0x000000000000000AuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000000078644FAuLL, 0x0000002205B17A98uLL, 0x0000000000142C8AuLL},
+{0xFFFFFFFD078644FAuLL, 0x000000000747AE14uLL, 0x000000232A32A513uLL, 0x000000000219757EuLL},
+{0xFFFFFFFD078644FAuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x00000000078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x00000000078644FEuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x0000000007864504uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x000000000786450CuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x000000000786462AuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B995AC10uLL},
+{0xFFFFFFFD078644FAuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x000000005791142EuLL},
+{0xFFFFFFFD078644FAuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000003230EFA3uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x00000000878644F7uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000000078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x00000001878644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x00000001078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x00000000878644FCuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x00000000078644FEuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x0000000187864503uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x000000010786455AuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001599B4EAAuLL},
+{0xFFFFFFFD078644FAuLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x00000001742EE216uLL},
+{0xFFFFFFFD078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000EDECAB5FuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x00000000878644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000002078644F6uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001B230EFA2uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x000000015CDB9A4EuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000B230EFA6uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000005CDB9A52uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x00000000078644FEuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001B230EFDAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x00000001472C69A4uLL},
+{0xFFFFFFFD078644FAuLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x000000021B0F5396uLL},
+{0xFFFFFFFD078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000150AAD742uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C78644F7uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000001878644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000001478644F9uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF78644FBuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE78644FCuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD78644FDuLL},
+{0xFFFFFFFD078644FAuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C0786450AuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000010784258CuLL},
+{0xFFFFFFFD078644FAuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x000000034F30DC7AuLL},
+{0xFFFFFFFD078644FAuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x00000001170A25F2uLL},
+{0xFFFFFFFD078644FAuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F34B37224uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F25A46316uLL},
+{0xFFFFFFFD078644FAuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F16955408uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C9078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9078644D8uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9078644B6uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C907864494uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9078642DAuLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C807B11BC6uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C810012652uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B80786451CuLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B8078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A707864560uLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A70786453EuLL},
+{0xFFFFFFFD078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A70786451CuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333341078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341078644D7uLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341078644B4uLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x0133334107864491uLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341078642CAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340002AD6CCuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334008B9783EuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F8786451DuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F878644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E07864563uLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E07864540uLL},
+{0xFFFFFFFD078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E0786451DuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644F9uLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644F7uLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644EAuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE003E96E6uLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD878644FBuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD878644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FDuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FCuLL},
+{0xFFFFFFFD078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FBuLL},
+{0xFFFFFFFD078644FAuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD078644F9uLL},
+{0xFFFFFFFD078644FAuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFD078644F7uLL},
+{0xFFFFFFFD078644FAuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFD078644EAuLL},
+{0xFFFFFFFD078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFD003E96E6uLL},
+{0xFFFFFFFD078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC878644FBuLL},
+{0xFFFFFFFD078644FAuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC878644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC078644FDuLL},
+{0xFFFFFFFD078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC078644FCuLL},
+{0xFFFFFFFD078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC078644FBuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD078644FAuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000000000002uLL, 0x7FFFFFFE83A3D70AuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000000000003uLL, 0x5555555457C28F5CuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000000000010uLL, 0x0FFFFFFFD0747AE1uLL, 0x0000000000000004uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000000078644FAuLL, 0x0000002205B17A97uLL, 0x00000000075BDA9EuLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000000747AE14uLL, 0x000000232A32A513uLL, 0x0000000001DADE98uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000000747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x000000000747AE18uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000000747AE1EuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x000000000747AE26uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x000000000747AF44uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB59uLL, 0x00000000B957152AuLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x0000000057527D48uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x0000000031F258BDuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000008747AE11uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000000747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x000000018747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x000000010747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x000000008747AE16uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x000000000747AE18uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000200000003uLL, 0x000000007FFFFFFDuLL, 0x000000018747AE1DuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x000000010747AE74uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001595CB7C4uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x0000000173F04B30uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000000EDAE1479uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000008747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x000000020747AE10uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000001B1F258BCuLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x000000015C9D0368uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000000B1F258C0uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000005C9D036CuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x000000000747AE18uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000001B1F258F4uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x0000000146EDD2BEuLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x000000021AD0BCB0uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000001506C405CuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000001C747AE11uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000018747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000014747AE13uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000CF747AE15uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000CE747AE16uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000CD747AE17uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C0747AE24uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x0000000107458EA6uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x000000034EF24594uLL},
+{0xFFFFFFFD0747AE14uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x0000000116CB8F0CuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000F3474DB3EuLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F2565CC30uLL},
+{0xFFFFFFFD0747AE14uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F1656BD22uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C90747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C90747ADF2uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C90747ADD0uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C90747ADAEuLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C90747ABF4uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8077284E0uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C80FC28F6CuLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B80747AE36uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B80747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A70747AE7AuLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A70747AE58uLL},
+{0xFFFFFFFD0747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A70747AE36uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x013333410747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333410747ADF1uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333410747ADCEuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333410747ADABuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333410747ABE4uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133333FFFEC3FE6uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x01333340087AE158uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133332F8747AE37uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332F8747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E0747AE7DuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E0747AE5AuLL},
+{0xFFFFFFFD0747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E0747AE37uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE13uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE11uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE04uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFC1691AuLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD8747AE15uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD8747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE17uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE16uLL},
+{0xFFFFFFFD0747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE15uLL},
+{0xFFFFFFFD0747AE14uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE13uLL},
+{0xFFFFFFFD0747AE14uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE11uLL},
+{0xFFFFFFFD0747AE14uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE04uLL},
+{0xFFFFFFFD0747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFCFFC1691AuLL},
+{0xFFFFFFFD0747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD0747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC8747AE15uLL},
+{0xFFFFFFFD0747AE14uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFC8747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC0747AE17uLL},
+{0xFFFFFFFD0747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC0747AE16uLL},
+{0xFFFFFFFD0747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC0747AE15uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD0747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD0747AE14uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000002uLL, 0x7FFFFFFEBFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000003uLL, 0x555555547FFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000010uLL, 0x0FFFFFFFD7FFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000002205B17AA8uLL, 0x00000000002997EFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000000747AE14uLL, 0x000000232A32A523uLL, 0x0000000006184F43uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFAuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000080000003uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x0000000080000009uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000080000011uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x000000008000012FuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x000000002A89221BuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000D00ACF33uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x00000000AAAAAAA8uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA8uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000100000001uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000080000003uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000000000005uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x000000018000005FuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001D21509AFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x00000001ECA89D1BuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x0000000166666664uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x000000027FFFFFFBuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x000000022AAAAAA7uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x00000001D5555553uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x000000012AAAAAABuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x00000000D5555557uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000080000003uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x000000022AAAAADFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x00000001BFA624A9uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000293890E9BuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000001C9249247uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x000000023FFFFFFCuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFEuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000D70000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000D60000001uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000D50000002uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C8000000FuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000017FFDE091uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x00000003C7AA977FuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000018F83E0F7uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000FAD2D2D29uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F9E1E1E1BuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F8F0F0F0DuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFFDDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFFBBuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFF99uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFDDFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8802AD6CBuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8887AE157uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B880000021uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B87FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A780000065uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A780000043uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A780000021uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x013333417FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333417FFFFFDCuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333417FFFFFB9uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333417FFFFF96uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333417FFFFDCFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133334078A491D1uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334081333343uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333000000022uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133332FFFFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E80000068uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E80000045uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E80000022uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFCuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFEFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFE7879BB05uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE78B851EBuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFEuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFCuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFEFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFD7879BB05uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFD78B851EBuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000002uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000001uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000000000002uLL, 0x7FFFFFFEC0000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000000000003uLL, 0x5555555480000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000000000010uLL, 0x0FFFFFFFD8000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000000078644FAuLL, 0x0000002205B17AA8uLL, 0x00000000002997F0uLL},
+{0xFFFFFFFD80000000uLL, 0x000000000747AE14uLL, 0x000000232A32A523uLL, 0x0000000006184F44uLL},
+{0xFFFFFFFD80000000uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFBuLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL, 0x0000000080000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFCuLL, 0x0000000080000004uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFBuLL, 0x000000008000000AuLL},
+{0xFFFFFFFD80000000uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFAuLL, 0x0000000080000012uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEDuLL, 0x0000000080000130uLL},
+{0xFFFFFFFD80000000uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x000000002A89221CuLL},
+{0xFFFFFFFD80000000uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA57uLL, 0x00000000D00ACF34uLL},
+{0xFFFFFFFD80000000uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x00000000AAAAAAA9uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFD80000000uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x0000000180000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000100000002uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000080000004uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000000000006uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000200000010uLL, 0x000000007FFFFFFAuLL, 0x0000000180000060uLL},
+{0xFFFFFFFD80000000uLL, 0x00000002078644FAuLL, 0x000000007E256848uLL, 0x00000001D21509B0uLL},
+{0xFFFFFFFD80000000uLL, 0x000000020747AE14uLL, 0x000000007E349CA5uLL, 0x00000001ECA89D1CuLL},
+{0xFFFFFFFD80000000uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x0000000166666665uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000100000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x000000027FFFFFFCuLL},
+{0xFFFFFFFD80000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x000000022AAAAAA8uLL},
+{0xFFFFFFFD80000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x00000001D5555554uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000180000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x000000012AAAAAACuLL},
+{0xFFFFFFFD80000000uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x00000000D5555558uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000080000004uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x000000022AAAAAE0uLL},
+{0xFFFFFFFD80000000uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x00000001BFA624AAuLL},
+{0xFFFFFFFD80000000uLL, 0x000000030747AE14uLL, 0x00000000548833C5uLL, 0x0000000293890E9CuLL},
+{0xFFFFFFFD80000000uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000001C9249248uLL},
+{0xFFFFFFFD80000000uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000180000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x000000023FFFFFFDuLL},
+{0xFFFFFFFD80000000uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000001BFFFFFFFuLL},
+{0xFFFFFFFD80000000uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000D80000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000D70000001uLL},
+{0xFFFFFFFD80000000uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000D60000002uLL},
+{0xFFFFFFFD80000000uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000D50000003uLL},
+{0xFFFFFFFD80000000uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000C80000010uLL},
+{0xFFFFFFFD80000000uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000017FFDE092uLL},
+{0xFFFFFFFD80000000uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x00000003C7AA9780uLL},
+{0xFFFFFFFD80000000uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000018F83E0F8uLL},
+{0xFFFFFFFD80000000uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000180000000uLL},
+{0xFFFFFFFD80000000uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000000FAD2D2D2AuLL},
+{0xFFFFFFFD80000000uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000000F9E1E1E1CuLL},
+{0xFFFFFFFD80000000uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000000F8F0F0F0EuLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C980000000uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFFDEuLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFFBCuLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFF9AuLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C97FFFFDE0uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C8802AD6CCuLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C8887AE158uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B880000022uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B880000000uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A780000066uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A780000044uLL},
+{0xFFFFFFFD80000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A780000022uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334180000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333417FFFFFDDuLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333417FFFFFBAuLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333417FFFFF97uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333417FFFFDD0uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133334078A491D2uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334081333344uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333000000023uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333000000000uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331E80000069uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331E80000046uLL},
+{0xFFFFFFFD80000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331E80000023uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFDuLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFF0uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFE7879BB06uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE78B851ECuLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000003uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFD80000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFD80000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFD80000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFDuLL},
+{0xFFFFFFFD80000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFF0uLL},
+{0xFFFFFFFD80000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFD7879BB06uLL},
+{0xFFFFFFFD80000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFD78B851ECuLL},
+{0xFFFFFFFD80000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFD80000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFD80000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000003uLL},
+{0xFFFFFFFD80000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000002uLL},
+{0xFFFFFFFD80000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFC80000001uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFD80000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFD80000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000002uLL, 0x7FFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000003uLL, 0x55555554AAAAAAA9uLL, 0x0000000000000002uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000010uLL, 0x0FFFFFFFDFFFFFFFuLL, 0x000000000000000DuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0353uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11D9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFBuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000005uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000CuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x000000000000011DuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA892219uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C3211DuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAA6uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFAuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000001uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000003uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000000000004DuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B3uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF05uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666662uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000002FFFFFFF9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAA5uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555551uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAA9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000155555555uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000001uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAADDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624A7uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C416085uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000249249245uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFAuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000027FFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000023FFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000DFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DEFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DDFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D0000000DuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE08FuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA977DuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0F5uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D27uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E19uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F0BuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFDBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFB9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF97uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDDDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6C9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE155uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B90000001FuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B8FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000063uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000041uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A80000001FuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333341FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFDAuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFB7uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF94uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDCDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491CFuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333341uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000020uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333307FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F00000066uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000043uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000020uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFAuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFEDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB03uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851E9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFAuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFEDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB03uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851E9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000002uLL, 0x7FFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000003uLL, 0x55555554AAAAAAAAuLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000010uLL, 0x0FFFFFFFDFFFFFFFuLL, 0x000000000000000EuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0354uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11DAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFBuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000006uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000DuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x000000000000011EuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89221AuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C3211EuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAA7uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000002uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000004uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000000000004EuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B4uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF06uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666663uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000002FFFFFFFAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAA6uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555552uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAAAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000155555556uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000002uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAADEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624A8uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C416086uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000249249246uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000027FFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000023FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000DFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DEFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000001uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D0000000EuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE090uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA977EuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0F6uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D28uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E1AuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F0CuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFDCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFBAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF98uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDDEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6CAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE156uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000020uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B8FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000064uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000042uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000020uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333341FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFDBuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFB8uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF95uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDCEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491D0uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333342uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000021uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333307FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F00000067uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000044uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000021uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFEEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB04uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFEEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB04uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFCFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000002uLL, 0x7FFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000003uLL, 0x55555554AAAAAAAAuLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000010uLL, 0x0FFFFFFFDFFFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0355uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11DBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFBuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000002uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000007uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000EuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x000000000000011FuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89221BuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C3211FuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAA8uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000200000000uLL, 0x000000007FFFFFFEuLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000003uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000005uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000000000004FuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B5uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF07uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666664uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000002FFFFFFFBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAA7uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555553uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAABuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000155555557uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000003uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAADFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624A9uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C416087uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000249249247uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000027FFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000023FFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000DFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF0000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000002uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D0000000FuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE091uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA977FuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0F7uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D29uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E1BuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F0DuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFDDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFBBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF99uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDDFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6CBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE157uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000021uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B8FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000065uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000043uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000021uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333341FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFDCuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFB9uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF96uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDCFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491D1uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333343uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000022uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333307FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F00000068uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000045uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000022uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFEFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB05uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFEFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB05uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD7FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFDFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000000000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000000000003uLL, 0x55555554AAAAAAAAuLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000000000010uLL, 0x0FFFFFFFE0000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0356uLL},
+{0xFFFFFFFE00000000uLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11DCuLL},
+{0xFFFFFFFE00000000uLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFE00000000uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000008uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000000000000FuLL},
+{0xFFFFFFFE00000000uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x0000000000000120uLL},
+{0xFFFFFFFE00000000uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89221CuLL},
+{0xFFFFFFFE00000000uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C32120uLL},
+{0xFFFFFFFE00000000uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAA9uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000080000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFE00000000uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFE00000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE00000000uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000002uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000004uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000006uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000000000050uLL},
+{0xFFFFFFFE00000000uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B6uLL},
+{0xFFFFFFFE00000000uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF08uLL},
+{0xFFFFFFFE00000000uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666665uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000180000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555554uLL, 0x00000002FFFFFFFCuLL},
+{0xFFFFFFFE00000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAA8uLL},
+{0xFFFFFFFE00000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555554uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000200000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAACuLL},
+{0xFFFFFFFE00000000uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000155555558uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000004uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAAE0uLL},
+{0xFFFFFFFE00000000uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624AAuLL},
+{0xFFFFFFFE00000000uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C416088uLL},
+{0xFFFFFFFE00000000uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000249249248uLL},
+{0xFFFFFFFE00000000uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000200000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFDuLL},
+{0xFFFFFFFE00000000uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000027FFFFFFEuLL},
+{0xFFFFFFFE00000000uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000023FFFFFFFuLL},
+{0xFFFFFFFE00000000uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF0000001uLL},
+{0xFFFFFFFE00000000uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000002uLL},
+{0xFFFFFFFE00000000uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000003uLL},
+{0xFFFFFFFE00000000uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000010uLL},
+{0xFFFFFFFE00000000uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE092uLL},
+{0xFFFFFFFE00000000uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA9780uLL},
+{0xFFFFFFFE00000000uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0F8uLL},
+{0xFFFFFFFE00000000uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000200000000uLL},
+{0xFFFFFFFE00000000uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D2AuLL},
+{0xFFFFFFFE00000000uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E1CuLL},
+{0xFFFFFFFE00000000uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F0EuLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA00000000uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFDEuLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFBCuLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF9AuLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDE0uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6CCuLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE158uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000022uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B900000000uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000066uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000044uLL},
+{0xFFFFFFFE00000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000022uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334200000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFDDuLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFBAuLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF97uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDD0uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491D2uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333344uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000023uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333080000000uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F00000069uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000046uLL},
+{0xFFFFFFFE00000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000023uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF0uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB06uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851ECuLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFE00000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFE00000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFE00000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFE00000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFDuLL},
+{0xFFFFFFFE00000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF0uLL},
+{0xFFFFFFFE00000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB06uLL},
+{0xFFFFFFFE00000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851ECuLL},
+{0xFFFFFFFE00000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFE00000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000000uLL},
+{0xFFFFFFFE00000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFE00000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFE00000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000001uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF0uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB06uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851ECuLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000000uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000000000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000000000003uLL, 0x55555554AAAAAAABuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000000000010uLL, 0x0FFFFFFFE0000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0357uLL},
+{0xFFFFFFFE00000001uLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11DDuLL},
+{0xFFFFFFFE00000001uLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFE00000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000004uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000009uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x0000000000000121uLL},
+{0xFFFFFFFE00000001uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89221DuLL},
+{0xFFFFFFFE00000001uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C32121uLL},
+{0xFFFFFFFE00000001uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAAAuLL},
+{0xFFFFFFFE00000001uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000080000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFE00000001uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE00000001uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000003uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000005uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000007uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000000000051uLL},
+{0xFFFFFFFE00000001uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B7uLL},
+{0xFFFFFFFE00000001uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF09uLL},
+{0xFFFFFFFE00000001uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666666uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000180000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAA9uLL},
+{0xFFFFFFFE00000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555555uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000200000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAADuLL},
+{0xFFFFFFFE00000001uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000155555559uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000005uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAAE1uLL},
+{0xFFFFFFFE00000001uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624ABuLL},
+{0xFFFFFFFE00000001uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C416089uLL},
+{0xFFFFFFFE00000001uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000249249249uLL},
+{0xFFFFFFFE00000001uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000200000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFEuLL},
+{0xFFFFFFFE00000001uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFE00000001uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000240000000uLL},
+{0xFFFFFFFE00000001uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF0000002uLL},
+{0xFFFFFFFE00000001uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000003uLL},
+{0xFFFFFFFE00000001uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000004uLL},
+{0xFFFFFFFE00000001uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000011uLL},
+{0xFFFFFFFE00000001uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE093uLL},
+{0xFFFFFFFE00000001uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA9781uLL},
+{0xFFFFFFFE00000001uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0F9uLL},
+{0xFFFFFFFE00000001uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000200000001uLL},
+{0xFFFFFFFE00000001uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D2BuLL},
+{0xFFFFFFFE00000001uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E1DuLL},
+{0xFFFFFFFE00000001uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F0FuLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA00000001uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFDFuLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFBDuLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF9BuLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDE1uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6CDuLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE159uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000023uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B900000001uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000067uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000045uLL},
+{0xFFFFFFFE00000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000023uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334200000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFDEuLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFBBuLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF98uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDD1uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491D3uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333345uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000024uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333080000001uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F0000006AuLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000047uLL},
+{0xFFFFFFFE00000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000024uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF1uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB07uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EDuLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000004uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFE00000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFE00000001uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE00000001uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFE00000001uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFE00000001uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF1uLL},
+{0xFFFFFFFE00000001uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB07uLL},
+{0xFFFFFFFE00000001uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EDuLL},
+{0xFFFFFFFE00000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFE00000001uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFE00000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000004uLL},
+{0xFFFFFFFE00000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFE00000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000002uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF1uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB07uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EDuLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000001uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000000000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000000000003uLL, 0x55555554AAAAAAABuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000000000010uLL, 0x0FFFFFFFE0000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0358uLL},
+{0xFFFFFFFE00000002uLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11DEuLL},
+{0xFFFFFFFE00000002uLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000005uLL},
+{0xFFFFFFFE00000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000005uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000AuLL},
+{0xFFFFFFFE00000002uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x0000000000000011uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x0000000000000122uLL},
+{0xFFFFFFFE00000002uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89221EuLL},
+{0xFFFFFFFE00000002uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C32122uLL},
+{0xFFFFFFFE00000002uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAABuLL},
+{0xFFFFFFFE00000002uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000080000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFE00000002uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL},
+{0xFFFFFFFE00000002uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000004uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000006uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000008uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000000000052uLL},
+{0xFFFFFFFE00000002uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B8uLL},
+{0xFFFFFFFE00000002uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF0AuLL},
+{0xFFFFFFFE00000002uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666667uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000180000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAAAuLL},
+{0xFFFFFFFE00000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555556uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000200000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAAEuLL},
+{0xFFFFFFFE00000002uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000015555555AuLL},
+{0xFFFFFFFE00000002uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000006uLL},
+{0xFFFFFFFE00000002uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAAE2uLL},
+{0xFFFFFFFE00000002uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624ACuLL},
+{0xFFFFFFFE00000002uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C41608AuLL},
+{0xFFFFFFFE00000002uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x000000024924924AuLL},
+{0xFFFFFFFE00000002uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000200000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFFuLL},
+{0xFFFFFFFE00000002uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000280000000uLL},
+{0xFFFFFFFE00000002uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000240000001uLL},
+{0xFFFFFFFE00000002uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF0000003uLL},
+{0xFFFFFFFE00000002uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000004uLL},
+{0xFFFFFFFE00000002uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000005uLL},
+{0xFFFFFFFE00000002uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000012uLL},
+{0xFFFFFFFE00000002uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE094uLL},
+{0xFFFFFFFE00000002uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA9782uLL},
+{0xFFFFFFFE00000002uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0FAuLL},
+{0xFFFFFFFE00000002uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000200000002uLL},
+{0xFFFFFFFE00000002uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D2CuLL},
+{0xFFFFFFFE00000002uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E1EuLL},
+{0xFFFFFFFE00000002uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F10uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA00000002uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFE0uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFBEuLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF9CuLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDE2uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6CEuLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE15AuLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000024uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B900000002uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000068uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000046uLL},
+{0xFFFFFFFE00000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000024uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334200000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFDFuLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFBCuLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF99uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDD2uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491D4uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333346uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000025uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333080000002uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F0000006BuLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000048uLL},
+{0xFFFFFFFE00000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000025uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF2uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB08uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EEuLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000003uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000005uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000004uLL},
+{0xFFFFFFFE00000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFE00000002uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFE00000002uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE00000002uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFE00000002uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF2uLL},
+{0xFFFFFFFE00000002uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB08uLL},
+{0xFFFFFFFE00000002uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EEuLL},
+{0xFFFFFFFE00000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000003uLL},
+{0xFFFFFFFE00000002uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFE00000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000005uLL},
+{0xFFFFFFFE00000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000004uLL},
+{0xFFFFFFFE00000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000003uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF2uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB08uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EEuLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000002uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000000000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000000000003uLL, 0x55555554AAAAAAABuLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000000000010uLL, 0x0FFFFFFFE0000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0359uLL},
+{0xFFFFFFFE00000003uLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11DFuLL},
+{0xFFFFFFFE00000003uLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000006uLL},
+{0xFFFFFFFE00000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000006uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000BuLL},
+{0xFFFFFFFE00000003uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x0000000000000012uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x0000000000000123uLL},
+{0xFFFFFFFE00000003uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89221FuLL},
+{0xFFFFFFFE00000003uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C32123uLL},
+{0xFFFFFFFE00000003uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAACuLL},
+{0xFFFFFFFE00000003uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000080000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000180000000uLL},
+{0xFFFFFFFE00000003uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL},
+{0xFFFFFFFE00000003uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000005uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000007uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000009uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000000000053uLL},
+{0xFFFFFFFE00000003uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4B9uLL},
+{0xFFFFFFFE00000003uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF0BuLL},
+{0xFFFFFFFE00000003uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666668uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000180000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAABuLL},
+{0xFFFFFFFE00000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555557uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000200000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAAAFuLL},
+{0xFFFFFFFE00000003uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000015555555BuLL},
+{0xFFFFFFFE00000003uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000007uLL},
+{0xFFFFFFFE00000003uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAAE3uLL},
+{0xFFFFFFFE00000003uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624ADuLL},
+{0xFFFFFFFE00000003uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C41608BuLL},
+{0xFFFFFFFE00000003uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x000000024924924BuLL},
+{0xFFFFFFFE00000003uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000200000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002C0000000uLL},
+{0xFFFFFFFE00000003uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000280000001uLL},
+{0xFFFFFFFE00000003uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000240000002uLL},
+{0xFFFFFFFE00000003uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF0000004uLL},
+{0xFFFFFFFE00000003uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000005uLL},
+{0xFFFFFFFE00000003uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000006uLL},
+{0xFFFFFFFE00000003uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000013uLL},
+{0xFFFFFFFE00000003uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE095uLL},
+{0xFFFFFFFE00000003uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA9783uLL},
+{0xFFFFFFFE00000003uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E0FBuLL},
+{0xFFFFFFFE00000003uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000200000003uLL},
+{0xFFFFFFFE00000003uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D2DuLL},
+{0xFFFFFFFE00000003uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E1FuLL},
+{0xFFFFFFFE00000003uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F11uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA00000003uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFE1uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFBFuLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFF9DuLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDE3uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6CFuLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE15BuLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000025uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B900000003uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000069uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000047uLL},
+{0xFFFFFFFE00000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000025uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334200000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFE0uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFBDuLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFF9AuLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDD3uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491D5uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333347uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000026uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333080000003uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F0000006CuLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000049uLL},
+{0xFFFFFFFE00000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000026uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF3uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB09uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EFuLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000004uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000003uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000006uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000005uLL},
+{0xFFFFFFFE00000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000004uLL},
+{0xFFFFFFFE00000003uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFE00000003uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFE00000003uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE00000003uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFF3uLL},
+{0xFFFFFFFE00000003uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB09uLL},
+{0xFFFFFFFE00000003uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851EFuLL},
+{0xFFFFFFFE00000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000004uLL},
+{0xFFFFFFFE00000003uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000003uLL},
+{0xFFFFFFFE00000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000006uLL},
+{0xFFFFFFFE00000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000005uLL},
+{0xFFFFFFFE00000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000004uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF3uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB09uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EFuLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000004uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000006uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000003uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000000000002uLL, 0x7FFFFFFF00000008uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000000000003uLL, 0x55555554AAAAAAB0uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000000000010uLL, 0x0FFFFFFFE0000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000010uLL, 0x00000000078644FAuLL, 0x0000002205B17AB9uLL, 0x00000000003F0366uLL},
+{0xFFFFFFFE00000010uLL, 0x000000000747AE14uLL, 0x000000232A32A535uLL, 0x00000000030E11ECuLL},
+{0xFFFFFFFE00000010uLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000000000013uLL},
+{0xFFFFFFFE00000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFE00000010uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000013uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000018uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000000000001FuLL},
+{0xFFFFFFFE00000010uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x0000000000000130uLL},
+{0xFFFFFFFE00000010uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000AA89222CuLL},
+{0xFFFFFFFE00000010uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x0000000048C32130uLL},
+{0xFFFFFFFE00000010uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000012AAAAAB9uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000080000010uLL},
+{0xFFFFFFFE00000010uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000018000000DuLL},
+{0xFFFFFFFE00000010uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000010000000EuLL},
+{0xFFFFFFFE00000010uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000008000000FuLL},
+{0xFFFFFFFE00000010uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x0000000180000012uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000100000014uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000080000016uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000000000060uLL},
+{0xFFFFFFFE00000010uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000004A8EC4C6uLL},
+{0xFFFFFFFE00000010uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006560EF18uLL},
+{0xFFFFFFFE00000010uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001E6666675uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000180000010uLL},
+{0xFFFFFFFE00000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000000000000FuLL},
+{0xFFFFFFFE00000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002AAAAAAB8uLL},
+{0xFFFFFFFE00000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x0000000255555564uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000200000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001AAAAAABCuLL},
+{0xFFFFFFFE00000010uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000155555568uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000100000014uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002AAAAAAF0uLL},
+{0xFFFFFFFE00000010uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x000000023FA624BAuLL},
+{0xFFFFFFFE00000010uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000000C416098uLL},
+{0xFFFFFFFE00000010uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000249249258uLL},
+{0xFFFFFFFE00000010uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000200000010uLL},
+{0xFFFFFFFE00000010uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002C000000DuLL},
+{0xFFFFFFFE00000010uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000028000000EuLL},
+{0xFFFFFFFE00000010uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000024000000FuLL},
+{0xFFFFFFFE00000010uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF0000011uLL},
+{0xFFFFFFFE00000010uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE0000012uLL},
+{0xFFFFFFFE00000010uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD0000013uLL},
+{0xFFFFFFFE00000010uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D00000020uLL},
+{0xFFFFFFFE00000010uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000001FFFDE0A2uLL},
+{0xFFFFFFFE00000010uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000447AA9790uLL},
+{0xFFFFFFFE00000010uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000020F83E108uLL},
+{0xFFFFFFFE00000010uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000200000010uLL},
+{0xFFFFFFFE00000010uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000102D2D2D3AuLL},
+{0xFFFFFFFE00000010uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000101E1E1E2CuLL},
+{0xFFFFFFFE00000010uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000100F0F0F1EuLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA00000010uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFEEuLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFCCuLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFFAAuLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6C9FFFFFDF0uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9002AD6DCuLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9087AE168uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B900000032uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B900000010uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A800000076uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A800000054uLL},
+{0xFFFFFFFE00000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A800000032uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334200000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333341FFFFFFEDuLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333341FFFFFFCAuLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333341FFFFFFA7uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333341FFFFFDE0uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340F8A491E2uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334101333354uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333080000033uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333080000010uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F00000079uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F00000056uLL},
+{0xFFFFFFFE00000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F00000033uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000000000000EuLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000000000000CuLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000000000000AuLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB16uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851FCuLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000011uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000010uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000013uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000012uLL},
+{0xFFFFFFFE00000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000011uLL},
+{0xFFFFFFFE00000010uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE0000000FuLL},
+{0xFFFFFFFE00000010uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE0000000EuLL},
+{0xFFFFFFFE00000010uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE0000000DuLL},
+{0xFFFFFFFE00000010uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE00000010uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDF879BB16uLL},
+{0xFFFFFFFE00000010uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFDF8B851FCuLL},
+{0xFFFFFFFE00000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000011uLL},
+{0xFFFFFFFE00000010uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD80000010uLL},
+{0xFFFFFFFE00000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000013uLL},
+{0xFFFFFFFE00000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000012uLL},
+{0xFFFFFFFE00000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD00000011uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000100000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000010000000FuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000010000000EuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000010000000DuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB16uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851FCuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000011uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000080000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000013uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000012uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000011uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE00000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE00000010uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000000000002uLL, 0x7FFFFFFF03C3227DuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000000000003uLL, 0x55555554AD2CC1A8uLL, 0x0000000000000002uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000000000010uLL, 0x0FFFFFFFE078644FuLL, 0x000000000000000AuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000000078644FAuLL, 0x0000002205B17ABAuLL, 0x00000000003F0356uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000000747AE14uLL, 0x000000232A32A536uLL, 0x00000000034CA8C2uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x00000000078644FDuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000078644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x00000000078644FDuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000007864502uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x0000000007864509uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x000000000786461AuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000B20F6716uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x000000005049661AuLL},
+{0xFFFFFFFE078644FAuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x000000013230EFA3uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x00000000878644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x00000001878644F7uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000001078644F8uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000000878644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x00000001878644FCuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x00000001078644FEuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000087864500uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000000786454AuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x00000000521509B0uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006CE73402uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001EDECAB5FuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x00000001878644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000000078644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002B230EFA2uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x000000025CDB9A4EuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000002078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001B230EFA6uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000015CDB9A52uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x00000001078644FEuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002B230EFDAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x00000002472C69A4uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x0000000013C7A582uLL},
+{0xFFFFFFFE078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000250AAD742uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000002078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002C78644F7uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000002878644F8uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000002478644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF78644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE78644FCuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD78644FDuLL},
+{0xFFFFFFFE078644FAuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D0786450AuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000020784258CuLL},
+{0xFFFFFFFE078644FAuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x000000044F30DC7AuLL},
+{0xFFFFFFFE078644FAuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x00000002170A25F2uLL},
+{0xFFFFFFFE078644FAuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000002078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x0000001034B37224uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x0000001025A46316uLL},
+{0xFFFFFFFE078644FAuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x0000001016955408uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CA078644D8uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CA078644B6uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CA07864494uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CA078642DAuLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C907B11BC6uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C910012652uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B90786451CuLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B9078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A807864560uLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A80786453EuLL},
+{0xFFFFFFFE078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A80786451CuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333342078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342078644D7uLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342078644B4uLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x0133334207864491uLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342078642CAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341002AD6CCuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334108B9783EuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x013333308786451DuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x01333330878644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F07864563uLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F07864540uLL},
+{0xFFFFFFFE078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F0786451DuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000000078644F8uLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000078644F6uLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000078644F4uLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000078644DAuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF003E96E6uLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE878644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE878644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FDuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FCuLL},
+{0xFFFFFFFE078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644F8uLL},
+{0xFFFFFFFE078644FAuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644F7uLL},
+{0xFFFFFFFE078644FAuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE078644EAuLL},
+{0xFFFFFFFE078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE003E96E6uLL},
+{0xFFFFFFFE078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD878644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD878644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FDuLL},
+{0xFFFFFFFE078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FCuLL},
+{0xFFFFFFFE078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD078644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000001078644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000001078644F8uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001078644F7uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001078644EAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001003E96E6uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x00000000878644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x00000000878644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000078644FDuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000078644FCuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000078644FBuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE078644FAuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000000000002uLL, 0x7FFFFFFF03A3D70AuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000000000003uLL, 0x55555554AD17E4B1uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000000000010uLL, 0x0FFFFFFFE0747AE1uLL, 0x0000000000000004uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000000078644FAuLL, 0x0000002205B17ABAuLL, 0x0000000000006C70uLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000000747AE14uLL, 0x000000232A32A536uLL, 0x00000000030E11DCuLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000200000000uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x000000000747AE17uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE17uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x000000000747AE1CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000000747AE23uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x000000000747AF34uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5AuLL, 0x00000000B1D0D030uLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x00000000500ACF34uLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAA9uLL, 0x0000000131F258BDuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000008747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x000000018747AE11uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000010747AE12uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000008747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL, 0x000000018747AE16uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x000000010747AE18uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x000000008747AE1AuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000000747AE64uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x0000000051D672CAuLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000006CA89D1CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x00000001EDAE1479uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000018747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000000747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555554uLL, 0x00000002B1F258BCuLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x000000025C9D0368uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x000000020747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000001B1F258C0uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000015C9D036CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x000000010747AE18uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000300000010uLL, 0x0000000055555552uLL, 0x00000002B1F258F4uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x0000000246EDD2BEuLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x0000000013890E9CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000002506C405CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x000000020747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000002C747AE11uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000028747AE12uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000024747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000DF747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000DE747AE16uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000DD747AE17uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D0747AE24uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x0000000207458EA6uLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x000000044EF24594uLL},
+{0xFFFFFFFE0747AE14uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x0000000216CB8F0CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x000000020747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x000000103474DB3EuLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000102565CC30uLL},
+{0xFFFFFFFE0747AE14uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000101656BD22uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CA0747ADF2uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CA0747ADD0uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CA0747ADAEuLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CA0747ABF4uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9077284E0uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C90FC28F6CuLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B90747AE36uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B90747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A80747AE7AuLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A80747AE58uLL},
+{0xFFFFFFFE0747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A80747AE36uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x013333420747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333420747ADF1uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333420747ADCEuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333420747ADABuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333420747ABE4uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333340FFEC3FE6uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x01333341087AE158uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x013333308747AE37uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333308747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F0747AE7DuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F0747AE5AuLL},
+{0xFFFFFFFE0747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F0747AE37uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000000747AE12uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000000747AE10uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000000747AE0EuLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x000000000747ADF4uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFC1691AuLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE8747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE8747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE17uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE16uLL},
+{0xFFFFFFFE0747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE12uLL},
+{0xFFFFFFFE0747AE14uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE11uLL},
+{0xFFFFFFFE0747AE14uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE04uLL},
+{0xFFFFFFFE0747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFC1691AuLL},
+{0xFFFFFFFE0747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE0747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD8747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFD8747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE17uLL},
+{0xFFFFFFFE0747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE16uLL},
+{0xFFFFFFFE0747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD0747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000010747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000010747AE12uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000010747AE11uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000010747AE04uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000000FFC1691AuLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000008747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000008747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x000000000747AE17uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x000000000747AE16uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x000000000747AE15uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE0747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE0747AE14uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000002uLL, 0x7FFFFFFF3FFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000003uLL, 0x55555554D5555555uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000010uLL, 0x0FFFFFFFE7FFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000002205B17ACAuLL, 0x0000000000546EBBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000000747AE14uLL, 0x000000232A32A547uLL, 0x000000000003D473uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFCuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000002uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000080000007uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000008000000EuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x000000008000011FuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x000000002302DD21uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x00000000C8C3211FuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x000000002AAAAAA9uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000180000003uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000100000005uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000008000004FuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x00000000CA8EC4B5uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x00000000E560EF07uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x0000000266666664uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x000000002AAAAAA9uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x00000002D5555553uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x000000022AAAAAABuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x00000001D5555557uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000180000003uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x000000002AAAAACFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x00000002BFA624A9uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000008C416087uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000002C9249247uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x000000033FFFFFFCuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000E70000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000E60000001uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000E50000002uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D8000000FuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000027FFDE091uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x00000004C7AA977FuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000028F83E0F7uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x00000010AD2D2D29uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000109E1E1E1BuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000108F0F0F0DuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFFDDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFFBBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFF99uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFDDFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9802AD6CBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9887AE157uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B980000021uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B97FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A880000065uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A880000043uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A880000021uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x013333427FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333427FFFFFDCuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333427FFFFFB9uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333427FFFFF96uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333427FFFFDCFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133334178A491D1uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334181333343uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333100000022uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x01333330FFFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F80000068uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F80000045uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F80000022uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000007FFFFFFBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000007FFFFFF9uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x000000007FFFFFDFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x0000000070F3760BuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x000000007170A3D7uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFCuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFEFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFE7879BB05uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE78B851EBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFCuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFEFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB05uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851EBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000000000002uLL, 0x7FFFFFFF40000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000000000003uLL, 0x55555554D5555555uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000000000010uLL, 0x0FFFFFFFE8000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000000078644FAuLL, 0x0000002205B17ACAuLL, 0x0000000000546EBCuLL},
+{0xFFFFFFFE80000000uLL, 0x000000000747AE14uLL, 0x000000232A32A547uLL, 0x000000000003D474uLL},
+{0xFFFFFFFE80000000uLL, 0x000000007FFFFFFFuLL, 0x0000000200000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000000000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFE80000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x0000000080000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000003uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFCuLL, 0x0000000080000008uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFBuLL, 0x000000008000000FuLL},
+{0xFFFFFFFE80000000uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEEuLL, 0x0000000080000120uLL},
+{0xFFFFFFFE80000000uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x000000002302DD22uLL},
+{0xFFFFFFFE80000000uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA58uLL, 0x00000000C8C32120uLL},
+{0xFFFFFFFE80000000uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x000000002AAAAAAAuLL},
+{0xFFFFFFFE80000000uLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFE80000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000180000004uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000100000006uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000080000050uLL},
+{0xFFFFFFFE80000000uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x00000000CA8EC4B6uLL},
+{0xFFFFFFFE80000000uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x00000000E560EF08uLL},
+{0xFFFFFFFE80000000uLL, 0x000000027FFFFFFFuLL, 0x0000000066666665uLL, 0x0000000266666665uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x0000000200000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x000000002AAAAAAAuLL},
+{0xFFFFFFFE80000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555554uLL, 0x00000002D5555554uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x0000000280000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x000000022AAAAAACuLL},
+{0xFFFFFFFE80000000uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x00000001D5555558uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000180000004uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x000000002AAAAAD0uLL},
+{0xFFFFFFFE80000000uLL, 0x00000003078644FAuLL, 0x0000000054816147uLL, 0x00000002BFA624AAuLL},
+{0xFFFFFFFE80000000uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000008C416088uLL},
+{0xFFFFFFFE80000000uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000002C9249248uLL},
+{0xFFFFFFFE80000000uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000280000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x000000033FFFFFFDuLL},
+{0xFFFFFFFE80000000uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000002FFFFFFFEuLL},
+{0xFFFFFFFE80000000uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000002BFFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000E80000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000E70000001uLL},
+{0xFFFFFFFE80000000uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000E60000002uLL},
+{0xFFFFFFFE80000000uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000E50000003uLL},
+{0xFFFFFFFE80000000uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000D80000010uLL},
+{0xFFFFFFFE80000000uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000027FFDE092uLL},
+{0xFFFFFFFE80000000uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x00000004C7AA9780uLL},
+{0xFFFFFFFE80000000uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000028F83E0F8uLL},
+{0xFFFFFFFE80000000uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000280000000uLL},
+{0xFFFFFFFE80000000uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0EuLL, 0x00000010AD2D2D2AuLL},
+{0xFFFFFFFE80000000uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0EuLL, 0x000000109E1E1E1CuLL},
+{0xFFFFFFFE80000000uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0EuLL, 0x000000108F0F0F0EuLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CA80000000uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFFDEuLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFFBCuLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFF9AuLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CA7FFFFDE0uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6C9802AD6CCuLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6C9887AE158uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6B980000022uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B980000000uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A880000066uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A880000044uLL},
+{0xFFFFFFFE80000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A880000022uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334280000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333427FFFFFDDuLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333427FFFFFBAuLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333427FFFFF97uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333427FFFFDD0uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133334178A491D2uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334181333344uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333100000023uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333100000000uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133331F80000069uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133331F80000046uLL},
+{0xFFFFFFFE80000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133331F80000023uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000080000000uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000007FFFFFFCuLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000007FFFFFFAuLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x000000007FFFFFE0uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x0000000070F3760CuLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x000000007170A3D8uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000003uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFE80000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFE80000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFE80000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFDuLL},
+{0xFFFFFFFE80000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFF0uLL},
+{0xFFFFFFFE80000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFE7879BB06uLL},
+{0xFFFFFFFE80000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFE78B851ECuLL},
+{0xFFFFFFFE80000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFE80000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFE80000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000003uLL},
+{0xFFFFFFFE80000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000002uLL},
+{0xFFFFFFFE80000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFD80000001uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFF0uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB06uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851ECuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFE80000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFE80000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000002uLL, 0x7FFFFFFF7FFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000003uLL, 0x55555554FFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000010uLL, 0x0FFFFFFFEFFFFFFFuLL, 0x000000000000000DuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA1FuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x000000000441451DuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000003uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x0000000000000009uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x000000000000010DuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD1FuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B7309uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAA7uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000200000002uLL, 0x000000007FFFFFFEuLL, 0x0000000200000001uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000003uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000010000004DuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B3uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF05uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666663uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000027FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAA7uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555552uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAA9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000255555555uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000001uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAACDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFADuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C416085uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000349249245uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFAuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000037FFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000033FFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000EFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EEFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EDFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E0000000DuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE08FuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA977DuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0F5uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D2AuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E1BuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F0CuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFDBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFB9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF97uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDDDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6C9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE155uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA0000001FuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B9FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000063uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000041uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A90000001FuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333342FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFDAuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFB7uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF94uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDCDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491CFuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333341uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000020uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333317FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332000000066uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000043uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000020uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF7uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFDDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F37609uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D5uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFAuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFEDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB03uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851E9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFAuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB03uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851E9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000003uLL, 0x55555554FFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000010uLL, 0x0FFFFFFFEFFFFFFFuLL, 0x000000000000000EuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA20uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x000000000441451EuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000004uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000004uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000AuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x000000000000010EuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD20uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B730AuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAA8uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000004uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000010000004EuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B4uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF06uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666664uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000027FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAA8uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555553uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000002FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAAAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000255555556uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000002uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAACEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFAEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C416086uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000349249246uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000002FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000037FFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000033FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000EFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EEFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000001uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E0000000EuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE090uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA977EuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0F6uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000002FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D2BuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E1CuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F0DuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFDCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFBAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF98uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDDEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6CAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE156uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000020uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B9FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000064uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000042uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000020uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333342FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFDBuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFB8uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF95uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDCEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491D0uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333342uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000021uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333317FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332000000067uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000044uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000021uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF8uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFDEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760AuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D6uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFEEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB04uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFDFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB04uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000003uLL, 0x55555554FFFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000010uLL, 0x0FFFFFFFEFFFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA21uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x000000000441451FuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFDuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000005uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000005uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000BuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x000000000000010FuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD21uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B730BuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAA9uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000180000000uLL, 0x00000000AAAAAAA9uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000005uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000010000004FuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B5uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF07uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666665uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000066666665uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAA9uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555554uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000055555554uLL, 0x00000002FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAABuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000255555557uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000003uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAACFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFAFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C416087uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000349249247uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000002FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000037FFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000033FFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000EFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF0000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000002uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E0000000FuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE091uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA977FuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0F7uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000002FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D2CuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E1DuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F0EuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFDDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFBBuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF99uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDDFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6CBuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE157uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000021uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6B9FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000065uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000043uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000021uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333342FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFDCuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFB9uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF96uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDCFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491D1uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333343uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000022uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333317FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332000000068uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000045uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000022uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF9uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFDFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760BuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D7uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFEFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB05uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EBuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE7FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB05uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EBuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFEFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000000000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000000000003uLL, 0x5555555500000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000000000010uLL, 0x0FFFFFFFF0000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA22uLL},
+{0xFFFFFFFF00000000uLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x0000000004414520uLL},
+{0xFFFFFFFF00000000uLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000006uLL},
+{0xFFFFFFFF00000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000006uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000CuLL},
+{0xFFFFFFFF00000000uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x0000000000000110uLL},
+{0xFFFFFFFF00000000uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD22uLL},
+{0xFFFFFFFF00000000uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B730CuLL},
+{0xFFFFFFFF00000000uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAAAuLL},
+{0xFFFFFFFF00000000uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000006uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000100000050uLL},
+{0xFFFFFFFF00000000uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B6uLL},
+{0xFFFFFFFF00000000uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF08uLL},
+{0xFFFFFFFF00000000uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666666uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAAAuLL},
+{0xFFFFFFFF00000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555555uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAACuLL},
+{0xFFFFFFFF00000000uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000255555558uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000004uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAAD0uLL},
+{0xFFFFFFFF00000000uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFB0uLL},
+{0xFFFFFFFF00000000uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C416088uLL},
+{0xFFFFFFFF00000000uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000349249248uLL},
+{0xFFFFFFFF00000000uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000300000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFDuLL},
+{0xFFFFFFFF00000000uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000037FFFFFFEuLL},
+{0xFFFFFFFF00000000uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000033FFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F00000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF0000001uLL},
+{0xFFFFFFFF00000000uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000002uLL},
+{0xFFFFFFFF00000000uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000003uLL},
+{0xFFFFFFFF00000000uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000010uLL},
+{0xFFFFFFFF00000000uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE092uLL},
+{0xFFFFFFFF00000000uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA9780uLL},
+{0xFFFFFFFF00000000uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0F8uLL},
+{0xFFFFFFFF00000000uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000300000000uLL},
+{0xFFFFFFFF00000000uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D2DuLL},
+{0xFFFFFFFF00000000uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E1EuLL},
+{0xFFFFFFFF00000000uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F0FuLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB00000000uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFDEuLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFBCuLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF9AuLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDE0uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6CCuLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE158uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000022uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA00000000uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000066uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000044uLL},
+{0xFFFFFFFF00000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000022uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334300000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFDDuLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFBAuLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF97uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDD0uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491D2uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333344uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000023uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333180000000uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332000000069uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000046uLL},
+{0xFFFFFFFF00000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000023uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFAuLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE0uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760CuLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D8uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000003uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL},
+{0xFFFFFFFF00000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFF00000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFF00000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFDuLL},
+{0xFFFFFFFF00000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF0uLL},
+{0xFFFFFFFF00000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB06uLL},
+{0xFFFFFFFF00000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851ECuLL},
+{0xFFFFFFFF00000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFF00000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFF00000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFF00000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFF00000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000001uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFF0uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB06uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851ECuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000001uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF0uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB06uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851ECuLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000000uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000000000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000000000003uLL, 0x5555555500000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000000000010uLL, 0x0FFFFFFFF0000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA23uLL},
+{0xFFFFFFFF00000001uLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x0000000004414521uLL},
+{0xFFFFFFFF00000001uLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000007uLL},
+{0xFFFFFFFF00000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000007uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000DuLL},
+{0xFFFFFFFF00000001uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x0000000000000111uLL},
+{0xFFFFFFFF00000001uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD23uLL},
+{0xFFFFFFFF00000001uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B730DuLL},
+{0xFFFFFFFF00000001uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAABuLL},
+{0xFFFFFFFF00000001uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000180000000uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000007uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000100000051uLL},
+{0xFFFFFFFF00000001uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B7uLL},
+{0xFFFFFFFF00000001uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF09uLL},
+{0xFFFFFFFF00000001uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666667uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000001uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAABuLL},
+{0xFFFFFFFF00000001uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555556uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAADuLL},
+{0xFFFFFFFF00000001uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000255555559uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000005uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAAD1uLL},
+{0xFFFFFFFF00000001uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFB1uLL},
+{0xFFFFFFFF00000001uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C416089uLL},
+{0xFFFFFFFF00000001uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000349249249uLL},
+{0xFFFFFFFF00000001uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000300000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFEuLL},
+{0xFFFFFFFF00000001uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000037FFFFFFFuLL},
+{0xFFFFFFFF00000001uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000340000000uLL},
+{0xFFFFFFFF00000001uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F00000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF0000002uLL},
+{0xFFFFFFFF00000001uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000003uLL},
+{0xFFFFFFFF00000001uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000004uLL},
+{0xFFFFFFFF00000001uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000011uLL},
+{0xFFFFFFFF00000001uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE093uLL},
+{0xFFFFFFFF00000001uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA9781uLL},
+{0xFFFFFFFF00000001uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0F9uLL},
+{0xFFFFFFFF00000001uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000300000001uLL},
+{0xFFFFFFFF00000001uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D2EuLL},
+{0xFFFFFFFF00000001uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E1FuLL},
+{0xFFFFFFFF00000001uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F10uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB00000001uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFDFuLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFBDuLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF9BuLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDE1uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6CDuLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE159uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000023uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA00000001uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000067uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000045uLL},
+{0xFFFFFFFF00000001uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000023uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334300000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFDEuLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFBBuLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF98uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDD1uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491D3uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333345uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000024uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333180000001uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x013333200000006AuLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000047uLL},
+{0xFFFFFFFF00000001uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000024uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE1uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760DuLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3D9uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000004uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000003uLL},
+{0xFFFFFFFF00000001uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL},
+{0xFFFFFFFF00000001uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF00000001uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFF00000001uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFF00000001uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF1uLL},
+{0xFFFFFFFF00000001uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB07uLL},
+{0xFFFFFFFF00000001uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EDuLL},
+{0xFFFFFFFF00000001uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFF00000001uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFF00000001uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000004uLL},
+{0xFFFFFFFF00000001uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFF00000001uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000002uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000200000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFF1uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB07uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EDuLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000002uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000180000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000004uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF1uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB07uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EDuLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000001uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000000000002uLL, 0x7FFFFFFF80000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000000000003uLL, 0x5555555500000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000000000010uLL, 0x0FFFFFFFF0000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA24uLL},
+{0xFFFFFFFF00000002uLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x0000000004414522uLL},
+{0xFFFFFFFF00000002uLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000008uLL},
+{0xFFFFFFFF00000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000002uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000008uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000EuLL},
+{0xFFFFFFFF00000002uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x0000000000000112uLL},
+{0xFFFFFFFF00000002uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD24uLL},
+{0xFFFFFFFF00000002uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B730EuLL},
+{0xFFFFFFFF00000002uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAACuLL},
+{0xFFFFFFFF00000002uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000180000001uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000003uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000008uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000100000052uLL},
+{0xFFFFFFFF00000002uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B8uLL},
+{0xFFFFFFFF00000002uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF0AuLL},
+{0xFFFFFFFF00000002uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666668uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000002uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAACuLL},
+{0xFFFFFFFF00000002uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555557uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAAEuLL},
+{0xFFFFFFFF00000002uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000025555555AuLL},
+{0xFFFFFFFF00000002uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000006uLL},
+{0xFFFFFFFF00000002uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAAD2uLL},
+{0xFFFFFFFF00000002uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFB2uLL},
+{0xFFFFFFFF00000002uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C41608AuLL},
+{0xFFFFFFFF00000002uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x000000034924924AuLL},
+{0xFFFFFFFF00000002uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000300000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFFuLL},
+{0xFFFFFFFF00000002uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000380000000uLL},
+{0xFFFFFFFF00000002uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000340000001uLL},
+{0xFFFFFFFF00000002uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F00000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF0000003uLL},
+{0xFFFFFFFF00000002uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000004uLL},
+{0xFFFFFFFF00000002uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000005uLL},
+{0xFFFFFFFF00000002uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000012uLL},
+{0xFFFFFFFF00000002uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE094uLL},
+{0xFFFFFFFF00000002uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA9782uLL},
+{0xFFFFFFFF00000002uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0FAuLL},
+{0xFFFFFFFF00000002uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000300000002uLL},
+{0xFFFFFFFF00000002uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D2FuLL},
+{0xFFFFFFFF00000002uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E20uLL},
+{0xFFFFFFFF00000002uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F11uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB00000002uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFE0uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFBEuLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF9CuLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDE2uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6CEuLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE15AuLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000024uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA00000002uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000068uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000046uLL},
+{0xFFFFFFFF00000002uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000024uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334300000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFDFuLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFBCuLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF99uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDD2uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491D4uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333346uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000025uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333180000002uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x013333200000006BuLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000048uLL},
+{0xFFFFFFFF00000002uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000025uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE2uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760EuLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3DAuLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000005uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000004uLL},
+{0xFFFFFFFF00000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000003uLL},
+{0xFFFFFFFF00000002uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFF00000002uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF00000002uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFF00000002uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF2uLL},
+{0xFFFFFFFF00000002uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB08uLL},
+{0xFFFFFFFF00000002uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EEuLL},
+{0xFFFFFFFF00000002uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000003uLL},
+{0xFFFFFFFF00000002uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFF00000002uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000005uLL},
+{0xFFFFFFFF00000002uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000004uLL},
+{0xFFFFFFFF00000002uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000003uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000200000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000200000001uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFF2uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB08uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EEuLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000003uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000180000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000005uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000004uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF2uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB08uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EEuLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000002uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000002uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000000000002uLL, 0x7FFFFFFF80000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000000000003uLL, 0x5555555500000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000000000010uLL, 0x0FFFFFFFF0000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA25uLL},
+{0xFFFFFFFF00000003uLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x0000000004414523uLL},
+{0xFFFFFFFF00000003uLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000009uLL},
+{0xFFFFFFFF00000003uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000003uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000009uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000000FuLL},
+{0xFFFFFFFF00000003uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x0000000000000113uLL},
+{0xFFFFFFFF00000003uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD25uLL},
+{0xFFFFFFFF00000003uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B730FuLL},
+{0xFFFFFFFF00000003uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAAADuLL},
+{0xFFFFFFFF00000003uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000180000002uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000004uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000009uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000100000053uLL},
+{0xFFFFFFFF00000003uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4B9uLL},
+{0xFFFFFFFF00000003uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF0BuLL},
+{0xFFFFFFFF00000003uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666669uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000003uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAAADuLL},
+{0xFFFFFFFF00000003uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555558uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAAAFuLL},
+{0xFFFFFFFF00000003uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000025555555BuLL},
+{0xFFFFFFFF00000003uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000007uLL},
+{0xFFFFFFFF00000003uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAAD3uLL},
+{0xFFFFFFFF00000003uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFB3uLL},
+{0xFFFFFFFF00000003uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C41608BuLL},
+{0xFFFFFFFF00000003uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x000000034924924BuLL},
+{0xFFFFFFFF00000003uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000300000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003C0000000uLL},
+{0xFFFFFFFF00000003uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x0000000380000001uLL},
+{0xFFFFFFFF00000003uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x0000000340000002uLL},
+{0xFFFFFFFF00000003uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F00000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF0000004uLL},
+{0xFFFFFFFF00000003uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000005uLL},
+{0xFFFFFFFF00000003uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000006uLL},
+{0xFFFFFFFF00000003uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000013uLL},
+{0xFFFFFFFF00000003uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE095uLL},
+{0xFFFFFFFF00000003uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA9783uLL},
+{0xFFFFFFFF00000003uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E0FBuLL},
+{0xFFFFFFFF00000003uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000300000003uLL},
+{0xFFFFFFFF00000003uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D30uLL},
+{0xFFFFFFFF00000003uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E21uLL},
+{0xFFFFFFFF00000003uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F12uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB00000003uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFE1uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFBFuLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFF9DuLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDE3uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6CFuLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE15BuLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000025uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA00000003uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000069uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000047uLL},
+{0xFFFFFFFF00000003uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000025uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334300000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFE0uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFBDuLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFF9AuLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDD3uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491D5uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333347uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000026uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333180000003uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x013333200000006CuLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000049uLL},
+{0xFFFFFFFF00000003uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000026uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000100000003uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFE3uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3760FuLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3DBuLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000006uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000005uLL},
+{0xFFFFFFFF00000003uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000004uLL},
+{0xFFFFFFFF00000003uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL},
+{0xFFFFFFFF00000003uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFF00000003uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF00000003uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFF3uLL},
+{0xFFFFFFFF00000003uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB09uLL},
+{0xFFFFFFFF00000003uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851EFuLL},
+{0xFFFFFFFF00000003uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000004uLL},
+{0xFFFFFFFF00000003uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000003uLL},
+{0xFFFFFFFF00000003uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000006uLL},
+{0xFFFFFFFF00000003uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000005uLL},
+{0xFFFFFFFF00000003uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000004uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000200000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x0000000200000002uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x0000000200000001uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFF3uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB09uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EFuLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000004uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000180000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000006uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000005uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000004uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000100000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFF3uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB09uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EFuLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000004uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000006uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000005uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000003uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000003uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000000000002uLL, 0x7FFFFFFF80000008uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000000000003uLL, 0x5555555500000005uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000000000010uLL, 0x0FFFFFFFF0000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000010uLL, 0x00000000078644FAuLL, 0x0000002205B17ADBuLL, 0x000000000069DA32uLL},
+{0xFFFFFFFF00000010uLL, 0x000000000747AE14uLL, 0x000000232A32A558uLL, 0x0000000004414530uLL},
+{0xFFFFFFFF00000010uLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x0000000000000012uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000000000016uLL},
+{0xFFFFFFFF00000010uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000000000012uLL},
+{0xFFFFFFFF00000010uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000012uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000016uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000000001CuLL},
+{0xFFFFFFFF00000010uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x0000000000000120uLL},
+{0xFFFFFFFF00000010uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000A302DD32uLL},
+{0xFFFFFFFF00000010uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000417B731CuLL},
+{0xFFFFFFFF00000010uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000AAAAAABAuLL},
+{0xFFFFFFFF00000010uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000080000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000018000000FuLL},
+{0xFFFFFFFF00000010uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000100000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000080000011uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000000000012uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000180000016uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000100000060uLL},
+{0xFFFFFFFF00000010uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x000000014A8EC4C6uLL},
+{0xFFFFFFFF00000010uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016560EF18uLL},
+{0xFFFFFFFF00000010uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000066666676uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000010000000FuLL},
+{0xFFFFFFFF00000010uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000AAAAAABAuLL},
+{0xFFFFFFFF00000010uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000055555565uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002AAAAAABCuLL},
+{0xFFFFFFFF00000010uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x0000000255555568uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000200000014uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000AAAAAAE0uLL},
+{0xFFFFFFFF00000010uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000381FDFC0uLL},
+{0xFFFFFFFF00000010uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000010C416098uLL},
+{0xFFFFFFFF00000010uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000349249258uLL},
+{0xFFFFFFFF00000010uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x0000000300000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003C000000DuLL},
+{0xFFFFFFFF00000010uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000038000000EuLL},
+{0xFFFFFFFF00000010uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000034000000FuLL},
+{0xFFFFFFFF00000010uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F00000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF0000011uLL},
+{0xFFFFFFFF00000010uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE0000012uLL},
+{0xFFFFFFFF00000010uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED0000013uLL},
+{0xFFFFFFFF00000010uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E00000020uLL},
+{0xFFFFFFFF00000010uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000002FFFDE0A2uLL},
+{0xFFFFFFFF00000010uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000547AA9790uLL},
+{0xFFFFFFFF00000010uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000030F83E108uLL},
+{0xFFFFFFFF00000010uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000300000010uLL},
+{0xFFFFFFFF00000010uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000002D2D2D3DuLL},
+{0xFFFFFFFF00000010uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000001E1E1E2EuLL},
+{0xFFFFFFFF00000010uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000000F0F0F1FuLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB00000010uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFEEuLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFCCuLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFFAAuLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CAFFFFFDF0uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA002AD6DCuLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA087AE168uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA00000032uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA00000010uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A900000076uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A900000054uLL},
+{0xFFFFFFFF00000010uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A900000032uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334300000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333342FFFFFFEDuLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333342FFFFFFCAuLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333342FFFFFFA7uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333342FFFFFDE0uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341F8A491E2uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334201333354uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333180000033uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333180000010uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332000000079uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332000000056uLL},
+{0xFFFFFFFF00000010uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332000000033uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000100000010uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000010000000EuLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000010000000CuLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000010000000AuLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000000FFFFFFF0uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F0F3761CuLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F170A3E8uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000012uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000013uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000012uLL},
+{0xFFFFFFFF00000010uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000011uLL},
+{0xFFFFFFFF00000010uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF0000000FuLL},
+{0xFFFFFFFF00000010uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF0000000EuLL},
+{0xFFFFFFFF00000010uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF0000000DuLL},
+{0xFFFFFFFF00000010uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF00000010uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEF879BB16uLL},
+{0xFFFFFFFF00000010uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFEF8B851FCuLL},
+{0xFFFFFFFF00000010uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000011uLL},
+{0xFFFFFFFF00000010uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE80000010uLL},
+{0xFFFFFFFF00000010uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000013uLL},
+{0xFFFFFFFF00000010uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000012uLL},
+{0xFFFFFFFF00000010uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE00000011uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000200000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000020000000FuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000020000000EuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000020000000DuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB16uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851FCuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000011uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000180000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000013uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000012uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000011uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000100000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000010000000FuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000010000000EuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000010000000DuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB16uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851FCuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000011uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000080000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000013uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000012uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000011uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000000000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000000000000FuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000000000000EuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000000000000DuLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF00000010uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF00000010uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x7FFFFFFF83C3227DuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000000000003uLL, 0x55555555028216FEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000000000010uLL, 0x0FFFFFFFF078644FuLL, 0x000000000000000AuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000000078644FAuLL, 0x0000002205B17ADCuLL, 0x000000000069DA22uLL},
+{0xFFFFFFFF078644FAuLL, 0x000000000747AE14uLL, 0x000000232A32A559uLL, 0x00000000047FDC06uLL},
+{0xFFFFFFFF078644FAuLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x00000000078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000007864500uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x00000000078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x00000000078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000007864500uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x0000000007864506uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x000000000786460AuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000AA89221CuLL},
+{0xFFFFFFFF078644FAuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x000000004901B806uLL},
+{0xFFFFFFFF078644FAuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000B230EFA4uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x00000000878644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000001878644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000001078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x00000000878644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x00000000078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x0000000187864500uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000010786454AuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x00000001521509B0uLL},
+{0xFFFFFFFF078644FAuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016CE73402uLL},
+{0xFFFFFFFF078644FAuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x000000006DECAB60uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000001078644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000B230EFA4uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x000000005CDB9A4FuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002B230EFA6uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000025CDB9A52uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x00000002078644FEuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000B230EFCAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x000000003FA624AAuLL},
+{0xFFFFFFFF078644FAuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x0000000113C7A582uLL},
+{0xFFFFFFFF078644FAuLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x0000000350AAD742uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x00000003078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003C78644F7uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000003878644F8uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000003478644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF78644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE78644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED78644FDuLL},
+{0xFFFFFFFF078644FAuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E0786450AuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000030784258CuLL},
+{0xFFFFFFFF078644FAuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x000000054F30DC7AuLL},
+{0xFFFFFFFF078644FAuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x00000003170A25F2uLL},
+{0xFFFFFFFF078644FAuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000003078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x0000000034B37227uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x0000000025A46318uLL},
+{0xFFFFFFFF078644FAuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x0000000016955409uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CB078644D8uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CB078644B6uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CB07864494uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CB078642DAuLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA07B11BC6uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA10012652uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA0786451CuLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A907864560uLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A90786453EuLL},
+{0xFFFFFFFF078644FAuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A90786451CuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333343078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333343078644D7uLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333343078644B4uLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x0133334307864491uLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333343078642CAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333342002AD6CCuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334208B9783EuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x013333318786451DuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x01333331878644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332007864563uLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332007864540uLL},
+{0xFFFFFFFF078644FAuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x013333200786451DuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000001078644F8uLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000001078644F6uLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000001078644F4uLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000001078644DAuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F879BB06uLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F8F6E8D2uLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x00000000078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF078644FDuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF078644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF078644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF078644F8uLL},
+{0xFFFFFFFF078644FAuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF078644F7uLL},
+{0xFFFFFFFF078644FAuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF078644EAuLL},
+{0xFFFFFFFF078644FAuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF078644FAuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF003E96E6uLL},
+{0xFFFFFFFF078644FAuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE878644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE878644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FDuLL},
+{0xFFFFFFFF078644FAuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE078644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000002078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000002078644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000002078644F8uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000002078644F7uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000002078644EAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000002003E96E6uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x00000001878644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x00000001878644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x00000001078644FDuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000001078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000001078644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000001078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000001078644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000001078644F8uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000001078644F7uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000001078644EAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000001003E96E6uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x00000000878644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x00000000878644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x00000000078644FDuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000078644FCuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000078644FBuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000078644F9uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000078644F8uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000078644F7uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000078644EAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000003E96E6uLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF078644FAuLL},
+{0xFFFFFFFF078644FAuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF078644FAuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x7FFFFFFF83A3D70AuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000000000003uLL, 0x55555555026D3A06uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000000000010uLL, 0x0FFFFFFFF0747AE1uLL, 0x0000000000000004uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000000078644FAuLL, 0x0000002205B17ADCuLL, 0x00000000002B433CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000000747AE14uLL, 0x000000232A32A559uLL, 0x0000000004414520uLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000007FFFFFFFuLL, 0x0000000200000002uLL, 0x000000000747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x000000000747AE1AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x000000000747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x000000000747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x000000000747AE1AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000000747AE20uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x000000000747AF24uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5BuLL, 0x00000000AA4A8B36uLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x0000000048C32120uLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x00000000B1F258BEuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000008747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x000000018747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x000000010747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x000000008747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x000000000747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000200000003uLL, 0x000000007FFFFFFEuLL, 0x000000018747AE1AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000010747AE64uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x0000000151D672CAuLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x000000016CA89D1CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x000000006DAE147AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000010747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000000B1F258BEuLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x000000005C9D0369uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000300000001uLL, 0x0000000055555554uLL, 0x00000002B1F258C0uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x000000025C9D036CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x000000020747AE18uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000000B1F258E4uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x000000003F678DC4uLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x0000000113890E9CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000037FFFFFFFuLL, 0x0000000049249248uLL, 0x00000003506C405CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x000000030747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000003FFFFFFFDuLL, 0x000000003FFFFFFFuLL, 0x00000003C747AE11uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x000000038747AE12uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x000000034747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000EF747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000EE747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000ED747AE17uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E0747AE24uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x0000000307458EA6uLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x000000054EF24594uLL},
+{0xFFFFFFFF0747AE14uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x0000000316CB8F0CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x000000030747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000003474DB41uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000002565CC32uLL},
+{0xFFFFFFFF0747AE14uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000001656BD23uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CB0747ADF2uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CB0747ADD0uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CB0747ADAEuLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CB0747ABF4uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA077284E0uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA0FC28F6CuLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA0747AE36uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A90747AE7AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A90747AE58uLL},
+{0xFFFFFFFF0747AE14uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A90747AE36uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x013333430747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333430747ADF1uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333430747ADCEuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333430747ADABuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333430747ABE4uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333341FFEC3FE6uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x01333342087AE158uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x013333318747AE37uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333318747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x013333200747AE7DuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x013333200747AE5AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x013333200747AE37uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000010747AE12uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000010747AE10uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000010747AE0EuLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x000000010747ADF4uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000000F83B2420uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000000F8B851ECuLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x000000000747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE17uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE12uLL},
+{0xFFFFFFFF0747AE14uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE11uLL},
+{0xFFFFFFFF0747AE14uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF0747AE04uLL},
+{0xFFFFFFFF0747AE14uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFC1691AuLL},
+{0xFFFFFFFF0747AE14uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF0747AE14uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE8747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFE8747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE17uLL},
+{0xFFFFFFFF0747AE14uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE0747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x000000020747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000020747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000020747AE12uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000020747AE11uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000020747AE04uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000001FFC1691AuLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000018747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000018747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x000000010747AE17uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x000000010747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x000000010747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x000000010747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000010747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000010747AE12uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000010747AE11uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x000000010747AE04uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000000FFC1691AuLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000008747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000008747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x000000000747AE17uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x000000000747AE16uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x000000000747AE15uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x000000000747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000000747AE13uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000000747AE12uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000000747AE11uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000000747AE04uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL},
+{0xFFFFFFFF0747AE14uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF0747AE14uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x7FFFFFFFBFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000003uLL, 0x555555552AAAAAAAuLL, 0x0000000000000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000010uLL, 0x0FFFFFFFF7FFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000000078644FAuLL, 0x0000002205B17AECuLL, 0x00000000007F4587uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000000747AE14uLL, 0x000000232A32A56AuLL, 0x00000000013707B7uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFEuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000080000005uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000005uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000008000000BuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x000000008000010FuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5CuLL, 0x000000001B7C9827uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000C17B730BuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x000000012AAAAAA9uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000200000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x000000018000004FuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x00000001CA8EC4B5uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x00000001E560EF07uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x00000000E6666665uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x000000012AAAAAA9uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555554uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000300000001uLL, 0x0000000055555555uLL, 0x000000002AAAAAAAuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x00000002D5555557uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000280000003uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x000000012AAAAACFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000B81FDFAFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000018C416087uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000049249249uLL, 0x0000000049249248uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000000380000000uLL, 0x0000000049249248uLL, 0x000000037FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000040000000uLL, 0x000000003FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x000000003FFFFFFFuLL, 0x00000003FFFFFFFDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000F70000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000F60000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000F50000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E8000000FuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000037FFDE091uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x00000005C7AA977FuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000038F83E0F7uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x000000037FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x00000000AD2D2D2CuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000009E1E1E1DuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000008F0F0F0EuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFFDDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFFBBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFF99uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFDDFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA802AD6CBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA887AE157uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA80000021uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A980000065uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A980000043uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A980000021uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x013333437FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333437FFFFFDCuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333437FFFFFB9uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333437FFFFF96uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333437FFFFDCFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133334278A491D1uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334281333343uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333200000022uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x01333331FFFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332080000068uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332080000045uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332080000022uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000017FFFFFFBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000017FFFFFF9uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x000000017FFFFFDFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x0000000170F3760BuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x000000017170A3D7uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFCuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFEFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFF7879BB05uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF78B851EBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000027FFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000027FFFFFFDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000027FFFFFFCuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000027FFFFFEFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x000000027879BB05uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000278B851EBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000180000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000180000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFCuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFEFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB05uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851EBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFCuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFEFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB05uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851EBuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL, 0xFFFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFF7FFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0x0000000000000001uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000000000002uLL, 0x7FFFFFFFC0000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000000000003uLL, 0x555555552AAAAAAAuLL, 0x0000000000000002uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000000000010uLL, 0x0FFFFFFFF8000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000000078644FAuLL, 0x0000002205B17AECuLL, 0x00000000007F4588uLL},
+{0xFFFFFFFF80000000uLL, 0x000000000747AE14uLL, 0x000000232A32A56AuLL, 0x00000000013707B8uLL},
+{0xFFFFFFFF80000000uLL, 0x000000007FFFFFFFuLL, 0x0000000200000003uLL, 0x0000000000000003uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000080000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000000FFFFFFFDuLL, 0x0000000100000002uLL, 0x0000000080000006uLL},
+{0xFFFFFFFF80000000uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF80000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000080000002uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000100000002uLL, 0x00000000FFFFFFFDuLL, 0x0000000080000006uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000100000003uLL, 0x00000000FFFFFFFCuLL, 0x000000008000000CuLL},
+{0xFFFFFFFF80000000uLL, 0x0000000100000010uLL, 0x00000000FFFFFFEFuLL, 0x0000000080000110uLL},
+{0xFFFFFFFF80000000uLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5CuLL, 0x000000001B7C9828uLL},
+{0xFFFFFFFF80000000uLL, 0x000000010747AE14uLL, 0x00000000F8EBDA59uLL, 0x00000000C17B730CuLL},
+{0xFFFFFFFF80000000uLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAAAuLL, 0x000000012AAAAAAAuLL},
+{0xFFFFFFFF80000000uLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000001FFFFFFFFuLL, 0x0000000080000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x0000000180000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000200000003uLL, 0x000000007FFFFFFFuLL, 0x0000000000000003uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000200000010uLL, 0x000000007FFFFFFBuLL, 0x0000000180000050uLL},
+{0xFFFFFFFF80000000uLL, 0x00000002078644FAuLL, 0x000000007E256849uLL, 0x00000001CA8EC4B6uLL},
+{0xFFFFFFFF80000000uLL, 0x000000020747AE14uLL, 0x000000007E349CA6uLL, 0x00000001E560EF08uLL},
+{0xFFFFFFFF80000000uLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x00000000E6666666uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x000000012AAAAAAAuLL},
+{0xFFFFFFFF80000000uLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x00000000D5555555uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000300000001uLL, 0x0000000055555555uLL, 0x000000002AAAAAABuLL},
+{0xFFFFFFFF80000000uLL, 0x0000000300000002uLL, 0x0000000055555554uLL, 0x00000002D5555558uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000280000004uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x000000012AAAAAD0uLL},
+{0xFFFFFFFF80000000uLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000000B81FDFB0uLL},
+{0xFFFFFFFF80000000uLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000018C416088uLL},
+{0xFFFFFFFF80000000uLL, 0x000000037FFFFFFFuLL, 0x0000000049249249uLL, 0x0000000049249249uLL},
+{0xFFFFFFFF80000000uLL, 0x0000000380000000uLL, 0x0000000049249249uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000003FFFFFFFDuLL, 0x0000000040000000uLL, 0x0000000040000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000003FFFFFFFEuLL, 0x0000000040000000uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000003FFFFFFFFuLL, 0x000000003FFFFFFFuLL, 0x00000003BFFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000F80000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000F70000001uLL},
+{0xFFFFFFFF80000000uLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000F60000002uLL},
+{0xFFFFFFFF80000000uLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000F50000003uLL},
+{0xFFFFFFFF80000000uLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000E80000010uLL},
+{0xFFFFFFFF80000000uLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x000000037FFDE092uLL},
+{0xFFFFFFFF80000000uLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x00000005C7AA9780uLL},
+{0xFFFFFFFF80000000uLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000038F83E0F8uLL},
+{0xFFFFFFFF80000000uLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x0000000380000000uLL},
+{0xFFFFFFFF80000000uLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x00000000AD2D2D2DuLL},
+{0xFFFFFFFF80000000uLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000009E1E1E1EuLL},
+{0xFFFFFFFF80000000uLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000008F0F0F0FuLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CB80000000uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFFDEuLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFFBCuLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFF9AuLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CB7FFFFDE0uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CA802AD6CCuLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CA887AE158uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BA80000022uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BA80000000uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6A980000066uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6A980000044uLL},
+{0xFFFFFFFF80000000uLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6A980000022uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x0133334380000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x013333437FFFFFDDuLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x013333437FFFFFBAuLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x013333437FFFFF97uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x013333437FFFFDD0uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x0133334278A491D2uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334281333344uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333200000023uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x0133333200000000uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332080000069uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332080000046uLL},
+{0xFFFFFFFF80000000uLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332080000023uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x0000000180000000uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x000000017FFFFFFCuLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x000000017FFFFFFAuLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x000000017FFFFFE0uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x0000000170F3760CuLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x000000017170A3D8uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000003uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000002uLL},
+{0xFFFFFFFF80000000uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000001uLL},
+{0xFFFFFFFF80000000uLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF80000000uLL},
+{0xFFFFFFFF80000000uLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFEuLL},
+{0xFFFFFFFF80000000uLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFDuLL},
+{0xFFFFFFFF80000000uLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFF0uLL},
+{0xFFFFFFFF80000000uLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFF7879BB06uLL},
+{0xFFFFFFFF80000000uLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFF78B851ECuLL},
+{0xFFFFFFFF80000000uLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFF80000000uLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFF80000000uLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000003uLL},
+{0xFFFFFFFF80000000uLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000002uLL},
+{0xFFFFFFFF80000000uLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFE80000001uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x0000000280000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x000000027FFFFFFEuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x000000027FFFFFFDuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x000000027FFFFFF0uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x000000027879BB06uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x0000000278B851ECuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000200000001uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000180000003uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000180000002uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000001uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x000000017FFFFFF0uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x000000017879BB06uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x0000000178B851ECuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000080000003uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000080000002uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000001uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x000000007FFFFFF0uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x000000007879BB06uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x0000000078B851ECuLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFF80000000uLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL, 0xFFFFFFFF80000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFF80000000uLL},
+{0xFFFFFFFF80000000uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFF80000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000002uLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000003uLL, 0x5555555555555554uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000010uLL, 0x0FFFFFFFFFFFFFFFuLL, 0x000000000000000DuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000000078644FAuLL, 0x0000002205B17AFDuLL, 0x000000000094B0EBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000000747AE14uLL, 0x000000232A32A57BuLL, 0x0000000005747861uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000007FFFFFFFuLL, 0x0000000200000004uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000006uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000006uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000100000010uLL, 0x00000000FFFFFFF0uLL, 0x00000000000000FDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5CuLL, 0x000000009B7C9825uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA5AuLL, 0x000000003A33C4F5uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAABuLL, 0x000000002AAAAAA8uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000001FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000200000003uLL, 0x000000007FFFFFFFuLL, 0x0000000080000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000200000010uLL, 0x000000007FFFFFFCuLL, 0x000000000000003DuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000002078644FAuLL, 0x000000007E25684AuLL, 0x0000000043087FB9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000020747AE14uLL, 0x000000007E349CA7uLL, 0x000000005E1940F1uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000166666663uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000001AAAAAAA7uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000155555552uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000300000001uLL, 0x0000000055555555uLL, 0x00000000AAAAAAA8uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000300000002uLL, 0x0000000055555555uLL, 0x0000000055555553uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000300000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000001AAAAAACDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000001381FDFADuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000020C416085uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000037FFFFFFFuLL, 0x0000000049249249uLL, 0x00000000C9249246uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000000380000000uLL, 0x0000000049249249uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000003FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000003FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000003FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000003FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000FFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000FEFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000FDFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000FD0000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000F0000000DuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000003FFFDE08FuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000647AA977DuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000040F83E0F5uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000003FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000012D2D2D2AuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000011E1E1E1BuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000010F0F0F0CuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFDBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFB9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFF97uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFDDDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CB002AD6C9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CB087AE155uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BB0000001FuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BAFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6AA00000063uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6AA00000041uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6AA0000001FuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333343FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333343FFFFFFDAuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333343FFFFFFB7uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333343FFFFFF94uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333343FFFFFDCDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333342F8A491CFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334301333341uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333280000020uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333327FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332100000066uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332100000043uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332100000020uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000001FFFFFFF9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000001FFFFFFF7uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000001FFFFFFDDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000001F0F37609uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000001F170A3D5uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFAuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFEDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFFF879BB03uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFFF8B851E9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFAuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000002FFFFFFEDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000002F879BB03uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000002F8B851E9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000027FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000027FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFAuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB03uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851E9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFAuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB03uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851E9uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFDuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000003uLL, 0x5555555555555554uLL, 0x0000000000000002uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000010uLL, 0x0FFFFFFFFFFFFFFFuLL, 0x000000000000000EuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000000078644FAuLL, 0x0000002205B17AFDuLL, 0x000000000094B0ECuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000000747AE14uLL, 0x000000232A32A57BuLL, 0x0000000005747862uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000007FFFFFFFuLL, 0x0000000200000004uLL, 0x0000000000000002uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000007uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000002uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000000FFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFEuLL, 0x0000000100000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000002uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000007uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000100000010uLL, 0x00000000FFFFFFF0uLL, 0x00000000000000FEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5CuLL, 0x000000009B7C9826uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA5AuLL, 0x000000003A33C4F6uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAABuLL, 0x000000002AAAAAA9uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000001FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000100000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000200000003uLL, 0x000000007FFFFFFFuLL, 0x0000000080000001uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000200000010uLL, 0x000000007FFFFFFCuLL, 0x000000000000003EuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000002078644FAuLL, 0x000000007E25684AuLL, 0x0000000043087FBAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000020747AE14uLL, 0x000000007E349CA7uLL, 0x000000005E1940F2uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000166666664uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000001AAAAAAA8uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000155555553uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000300000001uLL, 0x0000000055555555uLL, 0x00000000AAAAAAA9uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000300000002uLL, 0x0000000055555555uLL, 0x0000000055555554uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000300000003uLL, 0x0000000055555554uLL, 0x0000000300000002uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000001AAAAAACEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000001381FDFAEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000020C416086uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000037FFFFFFFuLL, 0x0000000049249249uLL, 0x00000000C9249247uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000000380000000uLL, 0x0000000049249249uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000003FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000003FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000003FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000003FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000FFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000FEFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000FE0000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000FD0000001uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000F0000000EuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000003FFFDE090uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000647AA977EuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000040F83E0F6uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000003FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000012D2D2D2BuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000011E1E1E1CuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000010F0F0F0DuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFDCuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFBAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFF98uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFDDEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CB002AD6CAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CB087AE156uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BB00000020uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BAFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6AA00000064uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6AA00000042uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6AA00000020uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333343FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333343FFFFFFDBuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333343FFFFFFB8uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333343FFFFFF95uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333343FFFFFDCEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333342F8A491D0uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334301333342uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333280000021uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333327FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332100000067uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332100000044uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332100000021uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000001FFFFFFF8uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000001FFFFFFDEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000001F0F3760AuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000001F170A3D6uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000100000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000004uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000002uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFEEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFFF879BB04uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFFF8B851EAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFEFFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000002FFFFFFEEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000002F879BB04uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000002F8B851EAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000027FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000200000001uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB04uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB04uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EAuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFEuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL, 0xFFFFFFFFFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000002uLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000003uLL, 0x5555555555555555uLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000010uLL, 0x0FFFFFFFFFFFFFFFuLL, 0x000000000000000FuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000000078644FAuLL, 0x0000002205B17AFDuLL, 0x000000000094B0EDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000000747AE14uLL, 0x000000232A32A57BuLL, 0x0000000005747863uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000007FFFFFFFuLL, 0x0000000200000004uLL, 0x0000000000000003uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000080000000uLL, 0x00000001FFFFFFFFuLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000000FFFFFFFDuLL, 0x0000000100000003uLL, 0x0000000000000008uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000000FFFFFFFEuLL, 0x0000000100000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000000FFFFFFFFuLL, 0x0000000100000001uLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000100000000uLL, 0x00000000FFFFFFFFuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000100000001uLL, 0x00000000FFFFFFFFuLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000100000002uLL, 0x00000000FFFFFFFEuLL, 0x0000000000000003uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000100000003uLL, 0x00000000FFFFFFFDuLL, 0x0000000000000008uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000100000010uLL, 0x00000000FFFFFFF0uLL, 0x00000000000000FFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000001078644FAuLL, 0x00000000F8B0BB5CuLL, 0x000000009B7C9827uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000010747AE14uLL, 0x00000000F8EBDA5AuLL, 0x000000003A33C4F7uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000017FFFFFFFuLL, 0x00000000AAAAAAABuLL, 0x000000002AAAAAAAuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000180000000uLL, 0x00000000AAAAAAAAuLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000001FFFFFFFDuLL, 0x0000000080000000uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000001FFFFFFFEuLL, 0x0000000080000000uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000001FFFFFFFFuLL, 0x0000000080000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000200000000uLL, 0x000000007FFFFFFFuLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000200000001uLL, 0x000000007FFFFFFFuLL, 0x0000000180000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000200000002uLL, 0x000000007FFFFFFFuLL, 0x0000000100000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000200000003uLL, 0x000000007FFFFFFFuLL, 0x0000000080000002uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000200000010uLL, 0x000000007FFFFFFCuLL, 0x000000000000003FuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000002078644FAuLL, 0x000000007E25684AuLL, 0x0000000043087FBBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000020747AE14uLL, 0x000000007E349CA7uLL, 0x000000005E1940F3uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000027FFFFFFFuLL, 0x0000000066666666uLL, 0x0000000166666665uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000280000000uLL, 0x0000000066666666uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000002FFFFFFFDuLL, 0x0000000055555555uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000002FFFFFFFEuLL, 0x0000000055555555uLL, 0x00000001AAAAAAA9uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000002FFFFFFFFuLL, 0x0000000055555555uLL, 0x0000000155555554uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000300000000uLL, 0x0000000055555555uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000300000001uLL, 0x0000000055555555uLL, 0x00000000AAAAAAAAuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000300000002uLL, 0x0000000055555555uLL, 0x0000000055555555uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000300000003uLL, 0x0000000055555555uLL, 0x0000000000000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000300000010uLL, 0x0000000055555553uLL, 0x00000001AAAAAACFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000003078644FAuLL, 0x0000000054816148uLL, 0x00000001381FDFAFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000030747AE14uLL, 0x00000000548833C6uLL, 0x000000020C416087uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000037FFFFFFFuLL, 0x0000000049249249uLL, 0x00000000C9249248uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000000380000000uLL, 0x0000000049249249uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000003FFFFFFFDuLL, 0x0000000040000000uLL, 0x00000000BFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000003FFFFFFFEuLL, 0x0000000040000000uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000003FFFFFFFFuLL, 0x0000000040000000uLL, 0x000000003FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000001000000000uLL, 0x000000000FFFFFFFuLL, 0x0000000FFFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000001000000001uLL, 0x000000000FFFFFFFuLL, 0x0000000FF0000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000001000000002uLL, 0x000000000FFFFFFFuLL, 0x0000000FE0000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000001000000003uLL, 0x000000000FFFFFFFuLL, 0x0000000FD0000002uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000001000000010uLL, 0x000000000FFFFFFFuLL, 0x0000000F0000000FuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000010078644FAuLL, 0x000000000FF87D43uLL, 0x00000003FFFDE091uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000100747AE14uLL, 0x000000000FF8BBA0uLL, 0x0000000647AA977FuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x000000107FFFFFFFuLL, 0x000000000F83E0F8uLL, 0x000000040F83E0F7uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0000001080000000uLL, 0x000000000F83E0F8uLL, 0x00000003FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000010FFFFFFFDuLL, 0x000000000F0F0F0FuLL, 0x000000012D2D2D2CuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000010FFFFFFFEuLL, 0x000000000F0F0F0FuLL, 0x000000011E1E1E1DuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x00000010FFFFFFFFuLL, 0x000000000F0F0F0FuLL, 0x000000010F0F0F0EuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA00000000uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA00000001uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFDDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA00000002uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFFBBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA00000003uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFF99uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA00000010uLL, 0x0000000000000022uLL, 0x002AD6CBFFFFFDDFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA078644FAuLL, 0x0000000000000022uLL, 0x002AD6CB002AD6CBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA0747AE14uLL, 0x0000000000000022uLL, 0x002AD6CB087AE157uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA7FFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6BB00000021uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FA80000000uLL, 0x0000000000000022uLL, 0x002AD6BAFFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FAFFFFFFFDuLL, 0x0000000000000022uLL, 0x002AD6AA00000065uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FAFFFFFFFEuLL, 0x0000000000000022uLL, 0x002AD6AA00000043uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x078644FAFFFFFFFFuLL, 0x0000000000000022uLL, 0x002AD6AA00000021uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE1400000000uLL, 0x0000000000000023uLL, 0x01333343FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE1400000001uLL, 0x0000000000000023uLL, 0x01333343FFFFFFDCuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE1400000002uLL, 0x0000000000000023uLL, 0x01333343FFFFFFB9uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE1400000003uLL, 0x0000000000000023uLL, 0x01333343FFFFFF96uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE1400000010uLL, 0x0000000000000023uLL, 0x01333343FFFFFDCFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE14078644FAuLL, 0x0000000000000023uLL, 0x01333342F8A491D1uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE140747AE14uLL, 0x0000000000000023uLL, 0x0133334301333343uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE147FFFFFFFuLL, 0x0000000000000023uLL, 0x0133333280000022uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE1480000000uLL, 0x0000000000000023uLL, 0x013333327FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE14FFFFFFFDuLL, 0x0000000000000023uLL, 0x0133332100000068uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE14FFFFFFFEuLL, 0x0000000000000023uLL, 0x0133332100000045uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x0747AE14FFFFFFFFuLL, 0x0000000000000023uLL, 0x0133332100000022uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000000uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000001uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000002uLL, 0x0000000000000002uLL, 0x00000001FFFFFFFBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000003uLL, 0x0000000000000002uLL, 0x00000001FFFFFFF9uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF00000010uLL, 0x0000000000000002uLL, 0x00000001FFFFFFDFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF078644FAuLL, 0x0000000000000002uLL, 0x00000001F0F3760BuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF0747AE14uLL, 0x0000000000000002uLL, 0x00000001F170A3D7uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF7FFFFFFFuLL, 0x0000000000000002uLL, 0x0000000100000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFF80000000uLL, 0x0000000000000002uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFDuLL, 0x0000000000000002uLL, 0x0000000000000005uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFEuLL, 0x0000000000000002uLL, 0x0000000000000003uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x7FFFFFFFFFFFFFFFuLL, 0x0000000000000002uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x8000000000000000uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x8000000000000001uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x8000000000000002uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x8000000000000003uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x8000000000000010uLL, 0x0000000000000001uLL, 0x7FFFFFFFFFFFFFEFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x80000000078644FAuLL, 0x0000000000000001uLL, 0x7FFFFFFFF879BB05uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x800000000747AE14uLL, 0x0000000000000001uLL, 0x7FFFFFFFF8B851EBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x800000007FFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF80000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x8000000080000000uLL, 0x0000000000000001uLL, 0x7FFFFFFF7FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x80000000FFFFFFFDuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000002uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x80000000FFFFFFFEuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0x80000000FFFFFFFFuLL, 0x0000000000000001uLL, 0x7FFFFFFF00000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000000uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000001uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000002uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000003uLL, 0x0000000000000001uLL, 0x00000002FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD00000010uLL, 0x0000000000000001uLL, 0x00000002FFFFFFEFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD078644FAuLL, 0x0000000000000001uLL, 0x00000002F879BB05uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD0747AE14uLL, 0x0000000000000001uLL, 0x00000002F8B851EBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000280000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFD80000000uLL, 0x0000000000000001uLL, 0x000000027FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000200000002uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000200000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFDFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000200000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000000uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000001uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000002uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000003uLL, 0x0000000000000001uLL, 0x00000001FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE00000010uLL, 0x0000000000000001uLL, 0x00000001FFFFFFEFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE078644FAuLL, 0x0000000000000001uLL, 0x00000001F879BB05uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE0747AE14uLL, 0x0000000000000001uLL, 0x00000001F8B851EBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000180000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFE80000000uLL, 0x0000000000000001uLL, 0x000000017FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000100000002uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000100000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFEFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000100000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000000uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000001uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFEuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000002uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFDuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000003uLL, 0x0000000000000001uLL, 0x00000000FFFFFFFCuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF00000010uLL, 0x0000000000000001uLL, 0x00000000FFFFFFEFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF078644FAuLL, 0x0000000000000001uLL, 0x00000000F879BB05uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF0747AE14uLL, 0x0000000000000001uLL, 0x00000000F8B851EBuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF7FFFFFFFuLL, 0x0000000000000001uLL, 0x0000000080000000uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFF80000000uLL, 0x0000000000000001uLL, 0x000000007FFFFFFFuLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFDuLL, 0x0000000000000001uLL, 0x0000000000000002uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFEuLL, 0x0000000000000001uLL, 0x0000000000000001uLL},
+{0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL, 0x0000000000000001uLL, 0x0000000000000000uLL}
+};
+
+int main()
+{
+    const unsigned N = sizeof(tests) / sizeof(tests[0]);
+    unsigned i;
+    for (i = 0; i < N; ++i)
+        if (test__udivmoddi4(tests[i][0], tests[i][1], tests[i][2], tests[i][3]))
+            return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/udivmodsi4_test.c b/compiler-rt/test/builtins/Unit/udivmodsi4_test.c
new file mode 100644
index 0000000..4c14e29
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/udivmodsi4_test.c
@@ -0,0 +1,59 @@
+//===-- udivmodsi4_test.c - Test __udivmodsi4 -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivmodsi4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+extern COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int* rem);
+
+int test__udivmodsi4(su_int a, su_int b, 
+						su_int expected_result, su_int expected_rem)
+{
+	su_int rem;
+    su_int result = __udivmodsi4(a, b, &rem);
+    if (result != expected_result) {
+        printf("error in __udivmodsi4: %u / %u = %u, expected %u\n",
+               a, b, result, expected_result);
+		return 1;
+	}
+    if (rem != expected_rem) {
+        printf("error in __udivmodsi4: %u mod %u = %u, expected %u\n",
+               a, b, rem, expected_rem);
+		return 1;
+	}
+	
+    return 0;
+}
+
+
+int main()
+{
+    if (test__udivmodsi4(0, 1, 0, 0))
+        return 1;
+
+    if (test__udivmodsi4(2, 1, 2, 0))
+        return 1;
+
+	if (test__udivmodsi4(19, 5, 3, 4))
+        return 1;
+
+	if (test__udivmodsi4(0x80000000, 8, 0x10000000, 0))
+        return 1;
+  	
+ 	if (test__udivmodsi4(0x80000003, 8, 0x10000000, 3))
+        return 1;
+
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/udivmodti4_test.c b/compiler-rt/test/builtins/Unit/udivmodti4_test.c
new file mode 100644
index 0000000..c424661
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/udivmodti4_test.c
@@ -0,0 +1,65353 @@
+//===-- udivmodti4_test.c - Test __udivmodti4 -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivmodti4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Effects: if rem != 0, *rem = a % b
+// Returns: a / b
+
+COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+
+int test__udivmodti4(tu_int a, tu_int b, tu_int expected_q, tu_int expected_r)
+{
+    tu_int r;
+    tu_int q = __udivmodti4(a, b, &r);
+    if (q != expected_q || r != expected_r)
+    {
+        utwords at;
+        at.all = a;
+        utwords bt;
+        bt.all = b;
+        utwords expected_qt;
+        expected_qt.all = expected_q;
+        utwords expected_rt;
+        expected_rt.all = expected_r;
+        utwords qt;
+        qt.all = q;
+        utwords rt;
+        rt.all = r;
+        printf("error in __udivmodti4: 0x%.16llX%.16llX / 0x%.16llX%.16llX = "
+               "0x%.16llX%.16llX, R = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX, "
+               "0x%.16llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, qt.s.high, qt.s.low,
+               rt.s.high, rt.s.low, expected_qt.s.high, expected_qt.s.low,
+               expected_rt.s.high, expected_rt.s.low);
+    }
+    return !(q == expected_q && r == expected_r);
+}
+
+char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
+
+tu_int tests[][4] =
+{
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFDuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFCuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000011FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000120000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000AAAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC55555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000120000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000AAAAAAACuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555680000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC55555556uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000C0000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001A0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000012AAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAACD5555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001AAAAAAAAuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555577FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAD55555554uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001BFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000023FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000E0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000015FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000019FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEAAAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA55555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFEC0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001A0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEAAAAAAACuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA55555556uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFEC0000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF40000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF2AAAAAABuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAAD5555555uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000009FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFAAAAAAAAuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB55555554uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFBFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000003FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFBuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000480000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555558uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555557AAAAAAAAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000087FFFFFFAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000500000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000077FFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFD5555557uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555582AAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFF9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000057FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555558AAAAAAA8uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000580000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAC80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555558AAAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFBuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000580000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAC80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555558AAAAAAAAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000097FFFFFFAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000600000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000087FFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAD00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555592AAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000009FFFFFFF9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000067FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAD7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555559AAAAAAA8uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFBuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000006FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000006FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000077FFFFFFBuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000077FFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555582AAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000007FFFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555558AAAAAAA8uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFCuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000003FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFBuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000067FFFFFFCuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFD5555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFBuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000077FFFFFFCuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFBuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556AAAAAAABuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555572AAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555554uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFCFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE55555555uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFCFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE55555556uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFED5555555uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD7FFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB80000002uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555554uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFD5555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000055555554uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000D5555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000155555554uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFC00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFD5555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555562AAAAAABuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFC80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555554uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFCFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE55555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555554AAAAAAABuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFCFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFCFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE55555556uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555554AAAAAAACuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD7FFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFED5555555uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555552AAAAAABuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFCuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555554uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555555AAAAAAAAuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFAuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000480000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000077FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFBuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000480000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000077FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000E0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000097FFFFFFAuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000500000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000015FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000009FFFFFFF9uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000047FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000057FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000087FFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000160000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000009FFFFFFFAuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000047FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000580000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000087FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000160000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000009FFFFFFFBuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000047FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000580000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000087FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001E0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000A7FFFFFFAuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000600000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000240000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC000000060000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000AFFFFFFF9uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000067FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000097FFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002BFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFBuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000077FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFCFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000300000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000077FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFCFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000120000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000087FFFFFFBuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000380000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000007FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD7FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000019FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFAuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000003FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000087FFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000003FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001BFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000DFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001DFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFBFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFE40000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFBFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000DFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001E0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000200000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFE40000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000004uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFBFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000E0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000067FFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000280000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFEC0000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC7FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF980000003uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xC0000000E0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000DFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFCFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFBuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000002FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF3FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFCFFFFFFFCuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA00000002uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000DFFFFFFF6uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000600000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000BFFFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEAAAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAE55555553uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFCFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFB80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFA00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000DFFFFFFF7uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000600000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000BFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEAAAAAAADuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAE55555554uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFCFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFB80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFA00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000E7FFFFFF6uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000680000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000C7FFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF2AAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAED5555553uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD7FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFA80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000007FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000037FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000EFFFFFFF5uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000CFFFFFFFAuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAF55555552uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFC7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFB00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000000FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000003FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000EFFFFFFF6uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000700000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000CFFFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAF55555553uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000EFFFFFFF7uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000700000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000CFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFAAAAAAADuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAF55555554uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFC80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000F7FFFFFF6uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000067FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000780000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000D7FFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000002AAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555780000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAFD5555553uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFB80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000017FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000047FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000180000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x55555554AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000FFFFFFFF5uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000DFFFFFFFAuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000AAAAAAABuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555553uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAB055555552uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000001FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000CFFFFFFF7uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000600000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000BFFFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEAAAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAD55555554uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFCFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFB80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFA00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000002FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFC00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000CFFFFFFF8uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000600000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000BFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEAAAAAAADuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAD55555555uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFCFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFB80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000000000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000D7FFFFFF7uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000680000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000C7FFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF2AAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAADD5555554uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFD7FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFA80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFD80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x800000037FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000080000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE7FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFC80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000DFFFFFFF6uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000006FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000CFFFFFFFAuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAE55555553uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFDFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFC7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFB00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000003FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000AFFFFFFF8uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDAAAAAAABuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFBFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFA80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFF900000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFCFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000AFFFFFFF9uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000008FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDAAAAAAACuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC55555555uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFBFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFA80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF00000004uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000B7FFFFFF8uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000097FFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE2AAAAAABuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAACD5555554uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFC7FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFF980000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000027FFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF80000003uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD7FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFF8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000BFFFFFFF7uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000009FFFFFFFBuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEAAAAAAAAuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAD55555553uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFCFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFB7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFA00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000002FFFFFFFCuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000005uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E400000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E391C71C71CuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFEE0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555554AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000006uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E400000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E391C71C71DuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFEE0000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555554AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000090000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF980000005uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E480000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E399C71C71CuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFF60000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555556D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x555555552AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x00000000D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000010FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E4FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3A1C71C71BuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFFE0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x08000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555755555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000155555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000110000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000005uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E500000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3A1C71C71CuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFFE0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000000AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAAC55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000110000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000006uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E500000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3A1C71C71DuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFFE0000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555680000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555755555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000000AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555680000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAAC55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000155555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000C0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000140000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000C0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000140000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000190000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000005uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3A9C71C71CuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xE000000060000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000012AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555700000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAACD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555557D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x800000012AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAACD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x555555562AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x00000001D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000001C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000010000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000004uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAACAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E5FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3B1C71C71BuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xE0000000E0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x08000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD55555577FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAD55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAACAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555855555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000001AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x555555577FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0x2AAAAAAD55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000255555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xA0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000023FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000001FFFFFFFuLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000023FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000050000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000006uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E380000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E381C71C71DuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFFE0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8800000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD5555554AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000050000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000007uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E380000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E381C71C71EuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFFE0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8800000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555655555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD555555500000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD5555554AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAA80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF880000006uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E400000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E389C71C71DuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000060000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8800000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD5555556D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD55555552AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x80000000D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000014FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000005uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E47FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E391C71C71CuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000000DFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x88000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000001uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555755555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD5555555FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xD5555555AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAB7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000155555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x200000008FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000018FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000007uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFC00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA9AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E280000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E371C71C71DuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFEE0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x07FFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAA9AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFEAAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAA55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555553AAAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000004uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x200000008FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000190000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000008uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFC00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000004uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA9AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E280000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E371C71C71EuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFEE0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x07FFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAA9AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFEAAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAA55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555400000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555553AAAAAAACuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF40000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF40000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF680000007uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFC80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF880000003uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E300000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E379C71C71DuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFF60000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x07FFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAAD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555555D5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFF2AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAAD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x555555542AAAAAABuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFFD5555555uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000008FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF700000006uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFCFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000002uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAAAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E37FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E381C71C71CuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFFDFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x07FFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555655555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFFAAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAB55555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555554FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555554AAAAAAAAuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAA7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000055555554uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000003FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000003FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000090000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF700000007uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFD00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E380000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E381C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFFE0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0800000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555554AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000090000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF700000008uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000004uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E380000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E381C71C71EuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFFE0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0800000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555554AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000110000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF780000007uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF980000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E400000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E389C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000060000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0800000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555556D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x555555552AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x00000000D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000018FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000006uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E47FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E391C71C71CuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000DFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x08000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555755555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000155555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000190000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000007uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAABAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E480000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E391C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000E0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0800000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x80000000AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAC55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000190000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF800000008uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAABAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E480000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E391C71C71EuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000E0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0800000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555680000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAABAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555755555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x80000000AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555680000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAC55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000155555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000000C0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000140000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000C0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000140000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF880000007uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAC2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E500000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E399C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000160000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0800000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000012AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555700000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAACD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAC2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555557D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x800000012AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAACD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x555555562AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x00000001D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x80000001C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000090000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000090000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000006uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAACAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E57FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E3A1C71C71CuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000001DFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x08000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD55555577FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAD55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAACAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555855555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x80000001AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x555555577FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAD55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x0000000255555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xC0000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xA0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000023FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000000uLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000001BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000023FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555655555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x20000000D0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000008uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFD00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAAAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E380000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E381C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFFE0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8800000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD5555554AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555655555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x20000000D0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000009uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E380000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E381C71C71EuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFFE0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8800000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555655555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD555555500000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD5555554AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xAAAAAAAA80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555655555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x20000000D0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000150000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF680000008uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF980000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB2AAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E400000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E389C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x6000000060000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8800000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD5555556D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD55555552AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x80000000D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x5555555655555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x20000000D0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001CFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF700000007uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABAAAAAAA9uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E39uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E47FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71DuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E391C71C71CuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x60000000DFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x88000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000002uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x2AAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000000uLL << 64 | 0xD555555755555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD5555555FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xD5555555AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xAAAAAAAB7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0x8000000155555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000004uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555556AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000110000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF400000009uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFA80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000004uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E3AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E200000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E361C71C71EuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFEE0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x07FFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFEAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAA55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAA9AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFEAAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x2AAAAAAA55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x55555553AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFEC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000005uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555556AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000110000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF40000000AuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFA80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000005uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9AAAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E3AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E200000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E361C71C71FuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFEE0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x07FFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFEAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAA9AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFEAAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x2AAAAAAA55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x5555555400000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x55555553AAAAAAACuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFF40000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFEC0000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x1FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF40000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555556AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000110000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000090000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF480000009uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFB00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF680000004uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA2AAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E3AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E280000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E369C71C71EuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFF60000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0800000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAAD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAA2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x55555555D5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFF2AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x2AAAAAAAD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x555555542AAAAAABuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAACuLL << 64 | 0xFFFFFFFFD5555555uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0x55555556AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x2000000110000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000010FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF500000008uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF40000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFB7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF700000003uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555538E38E3AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E2FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555551C71C71EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E371C71C71DuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFFDFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000010000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x080000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000040000003uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000004uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAB55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000080000001uLL << 64 | 0x5555555655555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x7FFFFFFFAAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000055555557uLL << 64 | 0x2AAAAAAB55555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x55555554FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x55555554AAAAAAAAuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x2AAAAAAA7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000002AAAAAADuLL << 64 | 0x0000000055555554uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0xBFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000040000001uLL << 64 | 0x800000003FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000020000001uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x3FFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x1FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000003FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000030000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3900000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E471C71C71uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFFA0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2800000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555554AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000030000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555557uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3900000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E471C71C72uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1FFFFFFFA0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2800000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555554AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000B0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAD5555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3980000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E4F1C71C71uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000020000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2800000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555556D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x555555552AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x00000000D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000012FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE00000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E39FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E571C71C70uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000009FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x28000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555755555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x0000000155555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000130000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3A00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E571C71C71uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000A0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2800000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x80000000AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAAC55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000130000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB55555557uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3A00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E571C71C72uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000A0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2800000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000140000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555680000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555755555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x80000000AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x5555555680000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAAC55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x0000000155555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000000C0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000140000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000C0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000140000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001B0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABD5555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3A80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E5F1C71C71uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000120000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2800000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000012AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555700000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAACD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAC2AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555557D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x800000012AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAACD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x555555562AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x00000001D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x80000001C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000030000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000030000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xE00000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x38E38E3AFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x638E38E671C71C70uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000019FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x28000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000023FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD55555577FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAD55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAACAAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555855555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x80000001AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x555555577FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0x2AAAAAAD55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x0000000255555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xC0000001BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xA0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x800000023FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000009FFFFFFFuLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000001BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000023FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000070000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000070000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000004uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E3900000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E371C71C72uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFFA0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA800000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD5555554AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000070000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000070000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000005uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA55555557uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E3900000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E371C71C73uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFFA0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA800000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAAAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555655555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD555555500000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD5555554AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xAAAAAAAA80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000070000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000F0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000004uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAAD5555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E3980000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E3F1C71C72uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000020000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA800000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAB2AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD5555556D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD55555552AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x80000000D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x6000000070000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000016FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000000uLL << 64 | 0xB8E38E39FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0x638E38E471C71C71uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000009FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xA8000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000001uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x2AAAAAABAAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xD555555755555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555555uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD5555555FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xD5555555AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xAAAAAAAB7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0x8000000155555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x60000000AFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001AFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000005uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFD80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAA955555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3800000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E271C71C72uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFEA0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x27FFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFD80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFEAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAA55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAA9AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFEAAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x2AAAAAAA55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x55555553AAAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFEC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFEC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x60000000AFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001B0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF900000006uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000003uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAA955555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3800000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E271C71C73uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFEA0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x27FFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFEAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAA9AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFEAAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x2AAAAAAA55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x5555555400000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x55555553AAAAAAACuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFEC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFF40000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFEC0000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x1FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF40000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x60000000B0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000030000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF980000005uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000002uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAA9D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E3880000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E2F1C71C72uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF20000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x27FFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF2AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAAD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAA2AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x55555555D5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFF2AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x2AAAAAAAD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x555555542AAAAAABuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAABuLL << 64 | 0xFFFFFFFFD5555555uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x60000000B0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000AFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x600000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000001uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x555555558E38E38EuLL, (tu_int)0x0000000000000001uLL << 64 | 0x38E38E38FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x5555555571C71C72uLL, (tu_int)0x0000000000000000uLL << 64 | 0xE38E38E371C71C71uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000060000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1FFFFFFF9FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000050000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x27FFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000003FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE7FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000040000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000000C0000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000080000003uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAB55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000100000000uLL << 64 | 0x5555555655555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x7FFFFFFFAAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000D5555556uLL << 64 | 0x2AAAAAAB55555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x55555554FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x55555554AAAAAAAAuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x2AAAAAAA7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x00000000AAAAAAACuLL << 64 | 0x0000000055555554uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0xBFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000C0000000uLL << 64 | 0x800000003FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000A0000000uLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x3FFFFFFFBFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x1FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000003FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFCFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001CFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000005uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000300000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E38F00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E38FC71C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFE60000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x47FFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAAAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555554AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFCFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001D0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000006uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000300000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E38F00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E38FC71C71C7uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFE60000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x47FFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAAAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555554AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFD0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000050000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000005uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000380000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E38F80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E390471C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFEE0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4800000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAB2AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x55555556D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x555555552AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x00000000D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFD0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000CFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000003FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E38FFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E390C71C71C5uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF60000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x480000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x5555555755555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x0000000155555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFD0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000005uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000400000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E39000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E390C71C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF60000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4800000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000000AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x80000000AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAAC55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x8000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFD0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000006uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000200000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000400000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E39000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E390C71C71C7uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFF60000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4800000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000000AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555680000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAABAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x5555555755555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x80000000AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x5555555680000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAAC55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x0000000155555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000000C0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x8000000140000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x00000000C0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC000000140000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000000C0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000140000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFD0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000150000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000005uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000480000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E39080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E391471C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5FFFFFFFE0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4800000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000012AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555700000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAACD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAC2AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x55555557D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x800000012AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAACD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x555555562AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x00000001D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x80000001C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x0000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC0000001C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFCuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFF55555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0x9FFFFFFFD0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001CFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000013FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA0000004FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E2uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E390FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E391C71C71C5uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x6000000060000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x480000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000027FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD55555577FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAD55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAACAAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x5555555855555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x80000001AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x555555577FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0x2AAAAAAD55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x0000000255555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xC0000001BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0xA0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFEuLL << 64 | 0x800000023FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x00000001BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xE0000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFEuLL << 64 | 0xC00000023FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000001BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x20000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000023FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38E80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E38FC71C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFE60000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC7FFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFFAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAB55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAAAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555554AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x2000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x6000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000010000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000005uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000180000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38E80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E38FC71C71C7uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFE60000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC7FFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFFAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAB55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAAAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555655555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xFFFFFFFFAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xD555555580000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xAAAAAAAB55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD555555500000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555554AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xAAAAAAAA80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x2000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x6000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xA000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000040000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000090000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000004uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000200000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38F00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E390471C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFEE0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC800000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000002AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAABD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAB2AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD5555556D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x000000002AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xAAAAAAABD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD55555552AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x80000000D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x2000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x6000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA000000010000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000010FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x200000027FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38F7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C6uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0E38E390C71C71C5uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000009FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xDFFFFFFF60000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000008FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC80000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC00000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAC55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAABAAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xD555555755555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xD55555567FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555554uLL << 64 | 0xAAAAAAAC55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555555FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555555AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xAAAAAAAB7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0x8000000155555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x40000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x20000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x60000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xC0000000BFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xA0000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000013FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA00000004FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000014FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA900000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E38D80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38DC71C71C7uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFE60000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x47FFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFD7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFEAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAA55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAA9AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFEAAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x2AAAAAAA55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555553AAAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFEC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x9FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFEC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xDFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFEC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x1FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA00000004FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000150000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000080000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA900000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E38D80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38DC71C71C8uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFE60000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x47FFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFEAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAA9AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFEAAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x2AAAAAAA55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x5555555400000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555553AAAAAAACuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFEC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x9FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFF40000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFEC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xDFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFEC0000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x1FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF40000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA00000004FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001CFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA000000100000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAA980000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E38E00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38E471C71C7uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFEE0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x47FFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFD7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF2AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAAD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAA2AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555555D5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFF2AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x2AAAAAAAD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x555555542AAAAAABuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xFFFFFFFFD5555555uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x9FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xDFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x1FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000040000000uLL << 64 | 0xA000000050000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000004FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xA00000017FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555E38E38E3uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8E38E38E7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x55555555C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0E38E38EC71C71C6uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x40000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5FFFFFFF5FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000090000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x47FFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xBFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE7FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x7FFFFFFF7FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000040000000uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000BFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAB55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAAAAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555655555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x7FFFFFFFAAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000155555555uLL << 64 | 0x2AAAAAAB55555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555554FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555554AAAAAAAAuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAA7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x0000000055555554uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xBFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x9FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x800000003FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xFFFFFFFFBFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xDFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x000000011FFFFFFFuLL << 64 | 0xC00000003FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFFBFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x1FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000003FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB0000000FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF100000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71A8E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xCFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000007FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF800000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000001FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555655555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAEAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x00000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001E0000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB00000010uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFB80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF100000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71A8E38E390uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xCFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000480000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000007FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF800000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF55555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAB80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555700000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555655555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAEAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x7FFFFFFF55555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA855555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB8000000FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF180000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555680000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71D00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71B0E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xD000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000500000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000087FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000067FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF880000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x000000027FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x7FFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x800000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFFD5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x555555582AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555780000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555556D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAF2AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x7FFFFFFFD5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD55555582AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA8D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x000000012AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEC0000000EuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF200000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555700000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71D7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71B8E38E38EuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xD00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000057FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000008FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000002FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x80000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555558AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555557FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555755555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAFAAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555558AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x00000001AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000E0000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEC0000000FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF200000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555700000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71D80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71B8E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xD000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000580000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000008FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF900000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000002FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555800000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555755555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAFAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000055555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA955555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x00000001AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000E0000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEC00000010uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFC80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF200000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555700000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71D80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71B8E38E390uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000040000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xD000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000580000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000008FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFB00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF900000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000002FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000000000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAC80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555558AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555800000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555755555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000380000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAAFAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000055555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAC80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555558AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA955555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000160000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEC8000000FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF280000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555780000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71E00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C0E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000C0000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xD000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000067FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000600000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000097FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000077FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF980000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x000000037FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000080000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x000000027FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x555555592AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555880000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555557D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAB02AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x80000000D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD55555592AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAA9D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x000000022AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED0000000EuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFD7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF300000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555800000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71E7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C8E38E38EuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xD00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000067FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000009FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000007FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFBFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA00000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000003FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000003uLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000002FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAD7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555559AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x55555558FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x5555555855555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xAAAAAAB0AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x8000000155555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x2AAAAAAD7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAAAuLL << 64 | 0xD5555559AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x00000002AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000010uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA00000010uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF00000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71C80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71A8E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000007FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFF800000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x80000001FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555700000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555655555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAEAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x80000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000010uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA00000011uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF00000008uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555600000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71C80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71A8E38E390uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF40000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000480000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000007FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFF800000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x80000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0xFFFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD5555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555700000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555655555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAEAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xFFFFFFFF55555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xAAAAAAAB80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA855555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000010uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA80000010uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF80000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555680000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71D00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71B0E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000500000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x800000087FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000067FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFF880000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x800000027FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0xFFFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x000000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x800000017FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD55555582AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555780000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD5555556D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAF2AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xFFFFFFFFD5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x555555582AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA8D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x800000012AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000011FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000010uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB0000000FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF000000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C7uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71D7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E38FuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71B8E38E38EuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x50000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000057FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000008FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000006FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000006uLL << 64 | 0x80000002FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0x80000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD5555558AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD5555557FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xD555555755555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x2AAAAAAFAAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xAAAAAAAC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0x55555558AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x2AAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0x80000001AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFEuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000013FFFFFFFuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC00000005FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000015FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE800000011uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF900000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEE00000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71B00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C7188E38E390uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xCFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF900000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF700000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000000FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555455555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAADAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA800000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA755555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555380000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xFFFFFFFFAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC00000005FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000160000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE800000012uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF900000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEE00000008uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71B00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C7188E38E391uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF40000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xCFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000380000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000006FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF900000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF700000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000000FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555455555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAADAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFE55555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA800000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA755555558uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555380000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555557uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC00000005FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE880000011uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF980000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEE80000007uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71B80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C7190E38E390uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xCFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000077FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000004uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000057FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF980000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF780000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x000000017FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFE80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x800000037FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFB80000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555554D5555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAE2AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFED5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD55555572AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA880000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA7D5555557uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x000000002AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000005FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE900000010uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEF00000006uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71BFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C7198E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000003FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xCFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000007FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000005FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF800000005uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000001FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000003FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAEAAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555557AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA8FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA855555556uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x555555547FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000000AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE900000011uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEF00000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71C00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C7198E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000007FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF800000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000001FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAEAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE900000012uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEF00000008uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71C00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C7198E38E391uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000040000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000480000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000007FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF800000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAEAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFF55555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAB80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA855555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000E0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE980000011uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEF80000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71C80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71A0E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000C0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000500000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000087FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000067FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF880000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x000000027FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x7FFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x800000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555D5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAF2AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x7FFFFFFFD5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD55555582AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA8D5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x000000012AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000015FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA00000010uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF000000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71CFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71A8E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000013FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000057FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000008FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000006FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000002FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAFAAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000055555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555558AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000001AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000160000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA00000011uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF000000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71D00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71A8E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000140000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000580000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000008FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF900000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000002FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAFAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000055555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA955555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000001AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000160000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA00000012uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFB00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF000000008uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71D00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71A8E38E391uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000140000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000580000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000008FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFB00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF900000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000002FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000000000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555700000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555655555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAAFAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000055555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAC80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555558AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA955555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001E0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEA80000011uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF080000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555780000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71D80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71B0E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000001C0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000067FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000600000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000097FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000077FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFF980000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x000000037FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000080000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFD80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x000000027FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555780000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556D5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAB02AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x80000000D5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD55555592AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAA9D5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x000000022AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000200000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC000000060000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000011uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB00000010uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFBFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF100000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71DFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x1C71C71B8E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000023FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD0000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000067FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000009FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000007FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFBFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFA00000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000003FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000004uLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x00000002FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555557FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xAAAAAAB0AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x8000000155555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x2AAAAAAD7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAABuLL << 64 | 0xD5555559AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x00000002AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000012uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE800000012uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFF880000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED00000008uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C7198E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000007FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFF800000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x80000001FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555555555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAACAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x80000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000300000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000012uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE800000013uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA00000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFF880000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED00000009uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C7198E38E391uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000480000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000007FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE00000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFF800000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x80000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0xFFFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555600000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555555555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAACAAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xFFFFFFFF55555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xAAAAAAAB80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA855555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000120000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000012uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE880000012uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFF900000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED80000008uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71C80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71A0E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000500000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000087FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFE80000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000067FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFF880000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x800000027FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0xFFFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x000000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x800000017FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555555D5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAAD2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xFFFFFFFFD5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x555555582AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA8D5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x800000012AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000300000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000A0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000019FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000012uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE900000011uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFF97FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEE00000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71CFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000000uLL << 64 | 0x9C71C71A8E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000013FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x50000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000057FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000008FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000006FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0x7FFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000007uLL << 64 | 0x80000002FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0x80000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x2AAAAAADAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xAAAAAAAC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0x55555558AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x2AAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0x80000001AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x000000017FFFFFFFuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000000uLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000DFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000013uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE600000013uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF780000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEC00000008uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71B00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C7188E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xCFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF900000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF700000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x00000000FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x80000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555455555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xD5555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA800000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA755555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x5555555380000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xFFFFFFFFAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000155555554uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000DFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001E0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000013uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE600000014uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF780000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEC00000009uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71B00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C7188E38E391uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xCFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000380000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000006FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF900000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF700000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x00000000FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555455555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFE55555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x2AAAAAAA80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA800000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA755555558uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x5555555380000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555558uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000E0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000013uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE680000013uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF980000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF800000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFEC80000008uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71B80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C7190E38E390uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xCFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000077FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD80000004uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000057FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF980000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF780000006uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x000000017FFFFFFAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFE80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x800000037FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFB80000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555554D5555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAC2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFED5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xD55555572AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA880000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA7D5555557uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x000000002AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000001uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000155555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x000000007FFFFFFFuLL << 64 | 0xC0000000E0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000007uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFA00000013uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFE700000012uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFF87FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000008uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFED00000007uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9C71C71C8uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C71BFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA98E38E390uLL, (tu_int)0x0000000000000001uLL << 64 | 0x1C71C7198E38E38FuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x400000003FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFA0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xCFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000007FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000005FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000009uLL << 64 | 0xFFFFFFF800000005uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFAuLL, (tu_int)0x0000000000000008uLL << 64 | 0x00000001FFFFFFF9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000005uLL << 64 | 0x80000003FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000000000008uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAACAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAADuLL << 64 | 0x2AAAAAAB7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x000000012AAAAAACuLL << 64 | 0xD5555557AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA8FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0xAAAAAAA855555556uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x555555547FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x00000000D5555559uLL << 64 | 0x00000000AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000140000001uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000100000002uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE00000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEE0000000DuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF380000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C5E38E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xEFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x00000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAACAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x00000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEE0000000EuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF380000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555AAAAAAADuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C5E38E38E5uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xEFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFB00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFF900000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555555555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAACAAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA855555558uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x5555555480000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEE8000000DuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF400000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555562AAAAAACuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C6638E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xF000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000067FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFF980000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x000000027FFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x000000017FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555555D5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAAD2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xFFFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA8D5555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x000000012AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF0000000CuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF480000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C72FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C6E38E38E3uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xF00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000BFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000006FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFBFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFA00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x00000002FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAADAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x555555557FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x00000001AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF0000000DuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF480000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAACuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C6E38E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xF000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000006FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000006FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFA00000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x00000002FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAADAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA955555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x00000001AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x4000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF0000000EuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF480000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555556AAAAAAADuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C6E38E38E5uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xF000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000C0000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000400000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000006FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFA00000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x00000002FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555700000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555655555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAADAAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA955555558uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x5555555580000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x4000000280000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEF8000000DuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF500000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x555555572AAAAAACuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C7638E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xF000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000140000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000480000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000077FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000077FFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFA80000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x000000037FFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFD80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x000000027FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555780000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555556D5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAAE2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAA9D5555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x000000022AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x4000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x5555555555555556uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF00000000CuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000005uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF580000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555554uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C73FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C7E38E38E3uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xF00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001BFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000007FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000007FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x00000003FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x00000002FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x55555557FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xAAAAAAAEAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x555555567FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x00000002AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x400000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED0000000EuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF180000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C5E38E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFC0000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x80000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x80000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555555555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x2AAAAAACAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xD555555480000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x80000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555AAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000040000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED0000000FuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF180000007uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555555AAAAAAACuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C5E38E38E5uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFC0000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFB00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFF900000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x80000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFC00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD5555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555600000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555555555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x2AAAAAACAAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xD5555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA855555558uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xD555555480000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000180000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000C0000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFED8000000EuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF200000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x555555562AAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C6638E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000040000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x800000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFF980000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x800000027FFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFC80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x800000017FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD55555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD5555555D5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x2AAAAAAD2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xD55555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA8D5555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x800000012AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555AAAAAAABuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000013FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000EuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEE0000000DuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFC7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF280000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71CuLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C72FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E4uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C6E38E38E3uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x70000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000BFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x80000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFBFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000005uLL << 64 | 0x80000002FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000002uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0x80000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD5555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x2AAAAAADAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAAAuLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x2AAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xD55555557FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0x80000001AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0xC00000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFEuLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001BFFFFFFFuLL << 64 | 0x800000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB0000000FuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF080000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555554AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C7080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E5uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C3E38E38E5uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xEFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEC0000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF800000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000000FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFFFFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555455555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA800000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA755555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x5555555380000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xFFFFFFFFAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB00000010uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFA80000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF080000007uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555554AAAAAAACuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C7080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E5uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C3E38E38E6uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xEFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFEC0000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFD00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF800000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFC80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000006uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555455555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA800000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA755555558uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x5555555380000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555557uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEB8000000FuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF100000006uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD55555552AAAAAABuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C7100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E5uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C4638E38E5uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xEFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF40000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFD80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFA80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF880000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x000000017FFFFFFBuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFB80000003uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x000000007FFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555554D5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAAC2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA880000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA7D5555557uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x000000002AAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFB0000000FuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFEC0000000EuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFB80000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFB7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000006uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF180000005uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA1C71C71DuLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C717FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAA9E38E38E5uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C4E38E38E4uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xEFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFC0000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFBFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000002uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFFAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000007uLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0xFFFFFFFD7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFBuLL, (tu_int)0x0000000000000006uLL << 64 | 0x00000001FFFFFFFAuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000003uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x7FFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFDuLL, (tu_int)0x0000000080000007uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xAAAAAAACAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x000000002AAAAAABuLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA8FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0xAAAAAAA855555556uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x555555547FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAA9uLL, (tu_int)0x0000000155555558uLL << 64 | 0x00000000AAAAAAA8uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001C0000000uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000180000001uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF80000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFE80000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000019FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000006uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF300000009uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF800000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555555555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C780000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7238E38E38uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFEC0000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFA00000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555555555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAACAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xFFFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x55555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x00000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFF9FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001A0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000007uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF30000000AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF800000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555555555558uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C780000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7238E38E39uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFEC0000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFA00000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000300000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555555555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAACAAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xFFFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x55555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAA955555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x00000000AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000020000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000006uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF380000009uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF880000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555555D5555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C800000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C72B8E38E38uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF40000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFA80000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000380000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555555D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAAD2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xFFFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x555555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAA9D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x000000012AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000009FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF400000008uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555655555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C87FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7338E38E37uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x100000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555655555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAADAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x55555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAA55555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x00000001AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x000000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000006uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF400000009uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555655555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C880000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7338E38E38uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x00000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFB00000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555700000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAADAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAAC00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x55555557AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAA55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x00000001AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000A0000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000007uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF40000000AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000300000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555655555558uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C880000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7338E38E39uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFFC0000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000280000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x0000000500000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFB00000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000200000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000400000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000005FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555700000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555655555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAADAAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000055555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAAC00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x55555557AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAA55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555600000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x00000001AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x4000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000120000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000006uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF480000009uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000380000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF980000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD5555556D5555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C900000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C73B8E38E38uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000040000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x1000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x000000057FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000067FFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFB80000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000037FFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000280000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000480000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000067FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555780000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555556D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAAE2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000000D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAAC80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x555555582AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAAD5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x5555555680000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x000000022AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x4000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x4000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFA0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000019FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC00000009uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF500000008uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x400000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000003uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFA00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000000uLL << 64 | 0xD555555755555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0x471C71C97FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E38uLL, (tu_int)0x0000000000000001uLL << 64 | 0x71C71C7438E38E37uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC0000000C0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x100000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x00000005FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000006FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000003FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000006FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x55555557FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x5555555755555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xAAAAAAAEAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x0000000155555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xAAAAAAACFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0x55555558AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xAAAAAAAB55555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x55555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x00000002AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x40000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0xC0000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x400000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF20000000AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C780000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C7138E38E39uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFEC0000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x80000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFA00000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000001FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD555555600000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD555555555555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x2AAAAAACAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x7FFFFFFF55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x2AAAAAAB00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xD5555556AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAA955555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xD555555500000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000000AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFDFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001E0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000006uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF20000000BuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000200000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF600000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555555555558uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C780000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C7138E38E3AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFEC0000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x8000000400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFA00000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000180000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000100000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000300000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000004FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD5555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD555555600000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD555555555555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x2AAAAAACAAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x7FFFFFFF55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x2AAAAAAB00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xD5555556AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAA955555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xD555555500000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000000AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xBFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000060000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF28000000AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000280000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF680000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x55555555D5555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C800000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C71B8E38E39uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFF40000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x9000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x800000047FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000057FFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFA80000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x800000027FFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000180000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000380000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000057FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x7FFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x0000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x800000037FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD55555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD555555680000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD5555555D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x2AAAAAAD2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x7FFFFFFFD5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x2AAAAAAB80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xD55555572AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAA9D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xD555555580000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x800000012AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x4000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xC000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000180000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA55555555uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x3FFFFFFFE0000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000DFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000AuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF300000009uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000100000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xC00000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xBFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF700000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAA9uLL, (tu_int)0x0000000000000001uLL << 64 | 0x5555555655555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000000uLL << 64 | 0xC71C71C87FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0x71C71C7238E38E38uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x3FFFFFFFC0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000001FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x900000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x800000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFBuLL << 64 | 0x80000004FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000005FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0x7FFFFFFB00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000002FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000005FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000001uLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0x80000001FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD5555556FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xD555555655555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x2AAAAAADAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x8000000055555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x2AAAAAABFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAA9uLL << 64 | 0xD5555557AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x2AAAAAAA55555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xD5555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0x80000001AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xC0000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x40000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xC00000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x800000017FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000011FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000BuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF00000000BuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFC00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF500000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555455555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C680000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7038E38E39uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFDC0000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000003FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFB00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFF900000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x00000000FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555500000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555455555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAABAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFE55555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555AAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA900000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA855555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555400000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000120000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000006uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000BuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF00000000CuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFC00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF500000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555455555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C680000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7038E38E3AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFDC0000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x0000000300000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFB00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFF900000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000080000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000200000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000200000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000003FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000001FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000003uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555500000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555455555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAABAAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFE55555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555555AAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA900000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA855555557uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555400000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555555uLL << 64 | 0xFFFFFFFFAAAAAAABuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x7FFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE00000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x400000001FFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000019FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFBuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000005uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000BuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF08000000BuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFC80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF580000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x55555554D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C700000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C70B8E38E39uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFE40000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x0000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x000000037FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000047FFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFB80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFF980000004uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x000000017FFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x8000000100000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000027FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000280000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x000000047FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFE80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x8000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x000000027FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFC80000002uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x000000007FFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555580000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555554D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAAC2AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFED5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAA80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x555555562AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA980000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA8D5555556uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x5555555480000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x000000002AAAAAAAuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x8000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFEFFFFFFFFuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFDuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0xFFFFFFFF80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFD80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFE80000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000080000000uLL << 64 | 0x4000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000001FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFCuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFC0000000BuLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFF10000000AuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE80000002uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFCFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000004uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFF600000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAAAAAAAAAAuLL, (tu_int)0x0000000000000000uLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA71C71C71uLL, (tu_int)0x0000000000000001uLL << 64 | 0x471C71C77FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0xAAAAAAAA38E38E39uLL, (tu_int)0x0000000000000000uLL << 64 | 0xF1C71C7138E38E38uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000040000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x800000003FFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xBFFFFFFEC0000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000020000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x8000000000000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFDuLL << 64 | 0x000000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL, (tu_int)0x000000007FFFFFFCuLL << 64 | 0x00000003FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFDuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000004FFFFFFFCuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFBFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000005uLL << 64 | 0xFFFFFFFA00000003uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFCuLL, (tu_int)0x0000000000000004uLL << 64 | 0x00000001FFFFFFFBuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000100000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x800000017FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000002FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000080000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x80000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000001uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000001FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x80000002FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000100000000uLL << 64 | 0x00000004FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0xFFFFFFFF00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x80000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000080000002uLL << 64 | 0x00000002FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFDFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0xFFFFFFFD00000001uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x7FFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000100000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL, (tu_int)0x0000000000000004uLL << 64 | 0x00000000FFFFFFFDuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x55555555FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x5555555555555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xAAAAAAACAAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xFFFFFFFF55555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0xAAAAAAAAFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x00000000AAAAAAAAuLL << 64 | 0x55555556AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA9FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0xAAAAAAA955555555uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x55555554FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x0000000180000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x00000000AAAAAAAAuLL, (tu_int)0x0000000055555556uLL << 64 | 0x00000000AAAAAAA9uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0xBFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x000000003FFFFFFFuLL << 64 | 0x800000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x3FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x00000001FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000080000000uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000000000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFFFFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x8000000080000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF7FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0x80000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x7FFFFFFF00000000uLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF00000001uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x00000000FFFFFFFEuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFF80000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x000000007FFFFFFFuLL << 64 | 0x0000000000000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000100000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFEFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x0000000180000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x00000001FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0xFFFFFFFE00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000000000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFFFFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x8000000080000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF7FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0x80000000FFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x7FFFFFFF00000000uLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF00000001uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x00000000FFFFFFFEuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFF80000000uLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x000000007FFFFFFFuLL},
+{(tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL, (tu_int)0xFFFFFFFFFFFFFFFFuLL << 64 | 0xFFFFFFFFFFFFFFFFuLL,  (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000001uLL, (tu_int)0x0000000000000000uLL << 64 | 0x0000000000000000uLL}
+};
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    const unsigned N = sizeof(tests) / sizeof(tests[0]);
+    unsigned i;
+    for (i = 0; i < N; ++i)
+        if (test__udivmodti4(tests[i][0], tests[i][1], tests[i][2], tests[i][3]))
+            return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/udivsi3_test.c b/compiler-rt/test/builtins/Unit/udivsi3_test.c
new file mode 100644
index 0000000..4905386
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/udivsi3_test.c
@@ -0,0 +1,175 @@
+//===-- udivsi3_test.c - Test __udivsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+COMPILER_RT_ABI su_int __udivsi3(su_int a, su_int b);
+
+int test__udivsi3(su_int a, su_int b, su_int expected_q)
+{
+    su_int q = __udivsi3(a, b);
+    if (q != expected_q)
+        printf("error in __udivsi3: %X / %X = %X, expected %X\n",
+               a, b, q, expected_q);
+    return q != expected_q;
+}
+
+su_int tests[][4] =
+{
+{0x00000000, 0x00000001, 0x00000000},
+{0x00000000, 0x00000002, 0x00000000},
+{0x00000000, 0x00000003, 0x00000000},
+{0x00000000, 0x00000010, 0x00000000},
+{0x00000000, 0x078644FA, 0x00000000},
+{0x00000000, 0x0747AE14, 0x00000000},
+{0x00000000, 0x7FFFFFFF, 0x00000000},
+{0x00000000, 0x80000000, 0x00000000},
+{0x00000000, 0xFFFFFFFD, 0x00000000},
+{0x00000000, 0xFFFFFFFE, 0x00000000},
+{0x00000000, 0xFFFFFFFF, 0x00000000},
+{0x00000001, 0x00000001, 0x00000001},
+{0x00000001, 0x00000002, 0x00000000},
+{0x00000001, 0x00000003, 0x00000000},
+{0x00000001, 0x00000010, 0x00000000},
+{0x00000001, 0x078644FA, 0x00000000},
+{0x00000001, 0x0747AE14, 0x00000000},
+{0x00000001, 0x7FFFFFFF, 0x00000000},
+{0x00000001, 0x80000000, 0x00000000},
+{0x00000001, 0xFFFFFFFD, 0x00000000},
+{0x00000001, 0xFFFFFFFE, 0x00000000},
+{0x00000001, 0xFFFFFFFF, 0x00000000},
+{0x00000002, 0x00000001, 0x00000002},
+{0x00000002, 0x00000002, 0x00000001},
+{0x00000002, 0x00000003, 0x00000000},
+{0x00000002, 0x00000010, 0x00000000},
+{0x00000002, 0x078644FA, 0x00000000},
+{0x00000002, 0x0747AE14, 0x00000000},
+{0x00000002, 0x7FFFFFFF, 0x00000000},
+{0x00000002, 0x80000000, 0x00000000},
+{0x00000002, 0xFFFFFFFD, 0x00000000},
+{0x00000002, 0xFFFFFFFE, 0x00000000},
+{0x00000002, 0xFFFFFFFF, 0x00000000},
+{0x00000003, 0x00000001, 0x00000003},
+{0x00000003, 0x00000002, 0x00000001},
+{0x00000003, 0x00000003, 0x00000001},
+{0x00000003, 0x00000010, 0x00000000},
+{0x00000003, 0x078644FA, 0x00000000},
+{0x00000003, 0x0747AE14, 0x00000000},
+{0x00000003, 0x7FFFFFFF, 0x00000000},
+{0x00000003, 0x80000000, 0x00000000},
+{0x00000003, 0xFFFFFFFD, 0x00000000},
+{0x00000003, 0xFFFFFFFE, 0x00000000},
+{0x00000003, 0xFFFFFFFF, 0x00000000},
+{0x00000010, 0x00000001, 0x00000010},
+{0x00000010, 0x00000002, 0x00000008},
+{0x00000010, 0x00000003, 0x00000005},
+{0x00000010, 0x00000010, 0x00000001},
+{0x00000010, 0x078644FA, 0x00000000},
+{0x00000010, 0x0747AE14, 0x00000000},
+{0x00000010, 0x7FFFFFFF, 0x00000000},
+{0x00000010, 0x80000000, 0x00000000},
+{0x00000010, 0xFFFFFFFD, 0x00000000},
+{0x00000010, 0xFFFFFFFE, 0x00000000},
+{0x00000010, 0xFFFFFFFF, 0x00000000},
+{0x078644FA, 0x00000001, 0x078644FA},
+{0x078644FA, 0x00000002, 0x03C3227D},
+{0x078644FA, 0x00000003, 0x028216FE},
+{0x078644FA, 0x00000010, 0x0078644F},
+{0x078644FA, 0x078644FA, 0x00000001},
+{0x078644FA, 0x0747AE14, 0x00000001},
+{0x078644FA, 0x7FFFFFFF, 0x00000000},
+{0x078644FA, 0x80000000, 0x00000000},
+{0x078644FA, 0xFFFFFFFD, 0x00000000},
+{0x078644FA, 0xFFFFFFFE, 0x00000000},
+{0x078644FA, 0xFFFFFFFF, 0x00000000},
+{0x0747AE14, 0x00000001, 0x0747AE14},
+{0x0747AE14, 0x00000002, 0x03A3D70A},
+{0x0747AE14, 0x00000003, 0x026D3A06},
+{0x0747AE14, 0x00000010, 0x00747AE1},
+{0x0747AE14, 0x078644FA, 0x00000000},
+{0x0747AE14, 0x0747AE14, 0x00000001},
+{0x0747AE14, 0x7FFFFFFF, 0x00000000},
+{0x0747AE14, 0x80000000, 0x00000000},
+{0x0747AE14, 0xFFFFFFFD, 0x00000000},
+{0x0747AE14, 0xFFFFFFFE, 0x00000000},
+{0x0747AE14, 0xFFFFFFFF, 0x00000000},
+{0x7FFFFFFF, 0x00000001, 0x7FFFFFFF},
+{0x7FFFFFFF, 0x00000002, 0x3FFFFFFF},
+{0x7FFFFFFF, 0x00000003, 0x2AAAAAAA},
+{0x7FFFFFFF, 0x00000010, 0x07FFFFFF},
+{0x7FFFFFFF, 0x078644FA, 0x00000011},
+{0x7FFFFFFF, 0x0747AE14, 0x00000011},
+{0x7FFFFFFF, 0x7FFFFFFF, 0x00000001},
+{0x7FFFFFFF, 0x80000000, 0x00000000},
+{0x7FFFFFFF, 0xFFFFFFFD, 0x00000000},
+{0x7FFFFFFF, 0xFFFFFFFE, 0x00000000},
+{0x7FFFFFFF, 0xFFFFFFFF, 0x00000000},
+{0x80000000, 0x00000001, 0x80000000},
+{0x80000000, 0x00000002, 0x40000000},
+{0x80000000, 0x00000003, 0x2AAAAAAA},
+{0x80000000, 0x00000010, 0x08000000},
+{0x80000000, 0x078644FA, 0x00000011},
+{0x80000000, 0x0747AE14, 0x00000011},
+{0x80000000, 0x7FFFFFFF, 0x00000001},
+{0x80000000, 0x80000000, 0x00000001},
+{0x80000000, 0xFFFFFFFD, 0x00000000},
+{0x80000000, 0xFFFFFFFE, 0x00000000},
+{0x80000000, 0xFFFFFFFF, 0x00000000},
+{0xFFFFFFFD, 0x00000001, 0xFFFFFFFD},
+{0xFFFFFFFD, 0x00000002, 0x7FFFFFFE},
+{0xFFFFFFFD, 0x00000003, 0x55555554},
+{0xFFFFFFFD, 0x00000010, 0x0FFFFFFF},
+{0xFFFFFFFD, 0x078644FA, 0x00000022},
+{0xFFFFFFFD, 0x0747AE14, 0x00000023},
+{0xFFFFFFFD, 0x7FFFFFFF, 0x00000001},
+{0xFFFFFFFD, 0x80000000, 0x00000001},
+{0xFFFFFFFD, 0xFFFFFFFD, 0x00000001},
+{0xFFFFFFFD, 0xFFFFFFFE, 0x00000000},
+{0xFFFFFFFD, 0xFFFFFFFF, 0x00000000},
+{0xFFFFFFFE, 0x00000001, 0xFFFFFFFE},
+{0xFFFFFFFE, 0x00000002, 0x7FFFFFFF},
+{0xFFFFFFFE, 0x00000003, 0x55555554},
+{0xFFFFFFFE, 0x00000010, 0x0FFFFFFF},
+{0xFFFFFFFE, 0x078644FA, 0x00000022},
+{0xFFFFFFFE, 0x0747AE14, 0x00000023},
+{0xFFFFFFFE, 0x7FFFFFFF, 0x00000002},
+{0xFFFFFFFE, 0x80000000, 0x00000001},
+{0xFFFFFFFE, 0xFFFFFFFD, 0x00000001},
+{0xFFFFFFFE, 0xFFFFFFFE, 0x00000001},
+{0xFFFFFFFE, 0xFFFFFFFF, 0x00000000},
+{0xFFFFFFFF, 0x00000001, 0xFFFFFFFF},
+{0xFFFFFFFF, 0x00000002, 0x7FFFFFFF},
+{0xFFFFFFFF, 0x00000003, 0x55555555},
+{0xFFFFFFFF, 0x00000010, 0x0FFFFFFF},
+{0xFFFFFFFF, 0x078644FA, 0x00000022},
+{0xFFFFFFFF, 0x0747AE14, 0x00000023},
+{0xFFFFFFFF, 0x7FFFFFFF, 0x00000002},
+{0xFFFFFFFF, 0x80000000, 0x00000001},
+{0xFFFFFFFF, 0xFFFFFFFD, 0x00000001},
+{0xFFFFFFFF, 0xFFFFFFFE, 0x00000001},
+{0xFFFFFFFF, 0xFFFFFFFF, 0x00000001}
+};
+
+int main()
+{
+    const unsigned N = sizeof(tests) / sizeof(tests[0]);
+    unsigned i;
+    for (i = 0; i < N; ++i)
+        if (test__udivsi3(tests[i][0], tests[i][1], tests[i][2]))
+            return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/udivti3_test.c b/compiler-rt/test/builtins/Unit/udivti3_test.c
new file mode 100644
index 0000000..f24ff03
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/udivti3_test.c
@@ -0,0 +1,67 @@
+//===-- udivti3_test.c - Test __udivti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a / b
+
+COMPILER_RT_ABI tu_int __udivti3(tu_int a, tu_int b);
+
+int test__udivti3(tu_int a, tu_int b, tu_int expected_q)
+{
+    tu_int q = __udivti3(a, b);
+    if (q != expected_q)
+    {
+        utwords at;
+        at.all = a;
+        utwords bt;
+        bt.all = b;
+        utwords qt;
+        qt.all = q;
+        utwords expected_qt;
+        expected_qt.all = expected_q;
+        printf("error in __udivti3: 0x%llX%.16llX / 0x%llX%.16llX = "
+               "0x%llX%.16llX, expected 0x%llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, qt.s.high, qt.s.low,
+               expected_qt.s.high, expected_qt.s.low);
+    }
+    return q != expected_q;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__udivti3(0, 1, 0))
+        return 1;
+    if (test__udivti3(2, 1, 2))
+        return 1;
+    if (test__udivti3(make_tu(0x8000000000000000uLL, 0), 1,
+                      make_tu(0x8000000000000000uLL, 0)))
+        return 1;
+    if (test__udivti3(make_tu(0x8000000000000000uLL, 0), 2,
+                      make_tu(0x4000000000000000uLL, 0)))
+        return 1;
+    if (test__udivti3(make_tu(0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL), 2,
+                      make_tu(0x7FFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/umoddi3_test.c b/compiler-rt/test/builtins/Unit/umoddi3_test.c
new file mode 100644
index 0000000..b46fb40
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/umoddi3_test.c
@@ -0,0 +1,44 @@
+//===-- umoddi3_test.c - Test __umoddi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __umoddi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+COMPILER_RT_ABI du_int __umoddi3(du_int a, du_int b);
+
+int test__umoddi3(du_int a, du_int b, du_int expected_r)
+{
+    du_int r = __umoddi3(a, b);
+    if (r != expected_r)
+        printf("error in __umoddi3: %lld %% %lld = %lld, expected %lld\n",
+               a, b, r, expected_r);
+    return r != expected_r;
+}
+
+int main()
+{
+    if (test__umoddi3(0, 1, 0))
+        return 1;
+    if (test__umoddi3(2, 1, 0))
+        return 1;
+    if (test__umoddi3(0x8000000000000000uLL, 1, 0x0uLL))
+        return 1;
+    if (test__umoddi3(0x8000000000000000uLL, 2, 0x0uLL))
+        return 1;
+    if (test__umoddi3(0xFFFFFFFFFFFFFFFFuLL, 2, 0x1uLL))
+        return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/umodsi3_test.c b/compiler-rt/test/builtins/Unit/umodsi3_test.c
new file mode 100644
index 0000000..3655da1
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/umodsi3_test.c
@@ -0,0 +1,175 @@
+//===-- umodsi3_test.c - Test __umodsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __umodsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+COMPILER_RT_ABI su_int __umodsi3(su_int a, su_int b);
+
+int test__umodsi3(su_int a, su_int b, su_int expected_r)
+{
+    su_int r = __umodsi3(a, b);
+    if (r != expected_r)
+        printf("error in __umodsi3: %X %% %X = %X, expected %X\n",
+               a, b, r, expected_r);
+    return r != expected_r;
+}
+
+su_int tests[][4] =
+{
+{0x00000000, 0x00000001, 0x00000000},
+{0x00000000, 0x00000002, 0x00000000},
+{0x00000000, 0x00000003, 0x00000000},
+{0x00000000, 0x00000010, 0x00000000},
+{0x00000000, 0x078644FA, 0x00000000},
+{0x00000000, 0x0747AE14, 0x00000000},
+{0x00000000, 0x7FFFFFFF, 0x00000000},
+{0x00000000, 0x80000000, 0x00000000},
+{0x00000000, 0xFFFFFFFD, 0x00000000},
+{0x00000000, 0xFFFFFFFE, 0x00000000},
+{0x00000000, 0xFFFFFFFF, 0x00000000},
+{0x00000001, 0x00000001, 0x00000000},
+{0x00000001, 0x00000002, 0x00000001},
+{0x00000001, 0x00000003, 0x00000001},
+{0x00000001, 0x00000010, 0x00000001},
+{0x00000001, 0x078644FA, 0x00000001},
+{0x00000001, 0x0747AE14, 0x00000001},
+{0x00000001, 0x7FFFFFFF, 0x00000001},
+{0x00000001, 0x80000000, 0x00000001},
+{0x00000001, 0xFFFFFFFD, 0x00000001},
+{0x00000001, 0xFFFFFFFE, 0x00000001},
+{0x00000001, 0xFFFFFFFF, 0x00000001},
+{0x00000002, 0x00000001, 0x00000000},
+{0x00000002, 0x00000002, 0x00000000},
+{0x00000002, 0x00000003, 0x00000002},
+{0x00000002, 0x00000010, 0x00000002},
+{0x00000002, 0x078644FA, 0x00000002},
+{0x00000002, 0x0747AE14, 0x00000002},
+{0x00000002, 0x7FFFFFFF, 0x00000002},
+{0x00000002, 0x80000000, 0x00000002},
+{0x00000002, 0xFFFFFFFD, 0x00000002},
+{0x00000002, 0xFFFFFFFE, 0x00000002},
+{0x00000002, 0xFFFFFFFF, 0x00000002},
+{0x00000003, 0x00000001, 0x00000000},
+{0x00000003, 0x00000002, 0x00000001},
+{0x00000003, 0x00000003, 0x00000000},
+{0x00000003, 0x00000010, 0x00000003},
+{0x00000003, 0x078644FA, 0x00000003},
+{0x00000003, 0x0747AE14, 0x00000003},
+{0x00000003, 0x7FFFFFFF, 0x00000003},
+{0x00000003, 0x80000000, 0x00000003},
+{0x00000003, 0xFFFFFFFD, 0x00000003},
+{0x00000003, 0xFFFFFFFE, 0x00000003},
+{0x00000003, 0xFFFFFFFF, 0x00000003},
+{0x00000010, 0x00000001, 0x00000000},
+{0x00000010, 0x00000002, 0x00000000},
+{0x00000010, 0x00000003, 0x00000001},
+{0x00000010, 0x00000010, 0x00000000},
+{0x00000010, 0x078644FA, 0x00000010},
+{0x00000010, 0x0747AE14, 0x00000010},
+{0x00000010, 0x7FFFFFFF, 0x00000010},
+{0x00000010, 0x80000000, 0x00000010},
+{0x00000010, 0xFFFFFFFD, 0x00000010},
+{0x00000010, 0xFFFFFFFE, 0x00000010},
+{0x00000010, 0xFFFFFFFF, 0x00000010},
+{0x078644FA, 0x00000001, 0x00000000},
+{0x078644FA, 0x00000002, 0x00000000},
+{0x078644FA, 0x00000003, 0x00000000},
+{0x078644FA, 0x00000010, 0x0000000A},
+{0x078644FA, 0x078644FA, 0x00000000},
+{0x078644FA, 0x0747AE14, 0x003E96E6},
+{0x078644FA, 0x7FFFFFFF, 0x078644FA},
+{0x078644FA, 0x80000000, 0x078644FA},
+{0x078644FA, 0xFFFFFFFD, 0x078644FA},
+{0x078644FA, 0xFFFFFFFE, 0x078644FA},
+{0x078644FA, 0xFFFFFFFF, 0x078644FA},
+{0x0747AE14, 0x00000001, 0x00000000},
+{0x0747AE14, 0x00000002, 0x00000000},
+{0x0747AE14, 0x00000003, 0x00000002},
+{0x0747AE14, 0x00000010, 0x00000004},
+{0x0747AE14, 0x078644FA, 0x0747AE14},
+{0x0747AE14, 0x0747AE14, 0x00000000},
+{0x0747AE14, 0x7FFFFFFF, 0x0747AE14},
+{0x0747AE14, 0x80000000, 0x0747AE14},
+{0x0747AE14, 0xFFFFFFFD, 0x0747AE14},
+{0x0747AE14, 0xFFFFFFFE, 0x0747AE14},
+{0x0747AE14, 0xFFFFFFFF, 0x0747AE14},
+{0x7FFFFFFF, 0x00000001, 0x00000000},
+{0x7FFFFFFF, 0x00000002, 0x00000001},
+{0x7FFFFFFF, 0x00000003, 0x00000001},
+{0x7FFFFFFF, 0x00000010, 0x0000000F},
+{0x7FFFFFFF, 0x078644FA, 0x00156B65},
+{0x7FFFFFFF, 0x0747AE14, 0x043D70AB},
+{0x7FFFFFFF, 0x7FFFFFFF, 0x00000000},
+{0x7FFFFFFF, 0x80000000, 0x7FFFFFFF},
+{0x7FFFFFFF, 0xFFFFFFFD, 0x7FFFFFFF},
+{0x7FFFFFFF, 0xFFFFFFFE, 0x7FFFFFFF},
+{0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF},
+{0x80000000, 0x00000001, 0x00000000},
+{0x80000000, 0x00000002, 0x00000000},
+{0x80000000, 0x00000003, 0x00000002},
+{0x80000000, 0x00000010, 0x00000000},
+{0x80000000, 0x078644FA, 0x00156B66},
+{0x80000000, 0x0747AE14, 0x043D70AC},
+{0x80000000, 0x7FFFFFFF, 0x00000001},
+{0x80000000, 0x80000000, 0x00000000},
+{0x80000000, 0xFFFFFFFD, 0x80000000},
+{0x80000000, 0xFFFFFFFE, 0x80000000},
+{0x80000000, 0xFFFFFFFF, 0x80000000},
+{0xFFFFFFFD, 0x00000001, 0x00000000},
+{0xFFFFFFFD, 0x00000002, 0x00000001},
+{0xFFFFFFFD, 0x00000003, 0x00000001},
+{0xFFFFFFFD, 0x00000010, 0x0000000D},
+{0xFFFFFFFD, 0x078644FA, 0x002AD6C9},
+{0xFFFFFFFD, 0x0747AE14, 0x01333341},
+{0xFFFFFFFD, 0x7FFFFFFF, 0x7FFFFFFE},
+{0xFFFFFFFD, 0x80000000, 0x7FFFFFFD},
+{0xFFFFFFFD, 0xFFFFFFFD, 0x00000000},
+{0xFFFFFFFD, 0xFFFFFFFE, 0xFFFFFFFD},
+{0xFFFFFFFD, 0xFFFFFFFF, 0xFFFFFFFD},
+{0xFFFFFFFE, 0x00000001, 0x00000000},
+{0xFFFFFFFE, 0x00000002, 0x00000000},
+{0xFFFFFFFE, 0x00000003, 0x00000002},
+{0xFFFFFFFE, 0x00000010, 0x0000000E},
+{0xFFFFFFFE, 0x078644FA, 0x002AD6CA},
+{0xFFFFFFFE, 0x0747AE14, 0x01333342},
+{0xFFFFFFFE, 0x7FFFFFFF, 0x00000000},
+{0xFFFFFFFE, 0x80000000, 0x7FFFFFFE},
+{0xFFFFFFFE, 0xFFFFFFFD, 0x00000001},
+{0xFFFFFFFE, 0xFFFFFFFE, 0x00000000},
+{0xFFFFFFFE, 0xFFFFFFFF, 0xFFFFFFFE},
+{0xFFFFFFFF, 0x00000001, 0x00000000},
+{0xFFFFFFFF, 0x00000002, 0x00000001},
+{0xFFFFFFFF, 0x00000003, 0x00000000},
+{0xFFFFFFFF, 0x00000010, 0x0000000F},
+{0xFFFFFFFF, 0x078644FA, 0x002AD6CB},
+{0xFFFFFFFF, 0x0747AE14, 0x01333343},
+{0xFFFFFFFF, 0x7FFFFFFF, 0x00000001},
+{0xFFFFFFFF, 0x80000000, 0x7FFFFFFF},
+{0xFFFFFFFF, 0xFFFFFFFD, 0x00000002},
+{0xFFFFFFFF, 0xFFFFFFFE, 0x00000001},
+{0xFFFFFFFF, 0xFFFFFFFF, 0x00000000}
+};
+
+int main()
+{
+    const unsigned N = sizeof(tests) / sizeof(tests[0]);
+    unsigned i;
+    for (i = 0; i < N; ++i)
+        if (test__umodsi3(tests[i][0], tests[i][1], tests[i][2]))
+            return 1;
+
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/umodti3_test.c b/compiler-rt/test/builtins/Unit/umodti3_test.c
new file mode 100644
index 0000000..21e82a4
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/umodti3_test.c
@@ -0,0 +1,65 @@
+//===-- umodti3_test.c - Test __umodti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __umodti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#ifdef CRT_HAS_128BIT
+
+// Returns: a % b
+
+COMPILER_RT_ABI tu_int __umodti3(tu_int a, tu_int b);
+
+int test__umodti3(tu_int a, tu_int b, tu_int expected_r)
+{
+    tu_int r = __umodti3(a, b);
+    if (r != expected_r)
+    {
+        utwords at;
+        at.all = a;
+        utwords bt;
+        bt.all = b;
+        utwords rt;
+        rt.all = r;
+        utwords expected_rt;
+        expected_rt.all = expected_r;
+        printf("error in __umodti3: 0x%llX%.16llX %% 0x%llX%.16llX = "
+               "0x%llX%.16llX, expected 0x%llX%.16llX\n",
+               at.s.high, at.s.low, bt.s.high, bt.s.low, rt.s.high, rt.s.low,
+               expected_rt.s.high, expected_rt.s.low);
+    }
+    return r != expected_r;
+}
+
+#endif
+
+int main()
+{
+#ifdef CRT_HAS_128BIT
+    if (test__umodti3(0, 1, 0))
+        return 1;
+    if (test__umodti3(2, 1, 0))
+        return 1;
+    if (test__umodti3(make_tu(0x8000000000000000uLL, 0), 1, 0x0uLL))
+        return 1;
+    if (test__umodti3(make_tu(0x8000000000000000uLL, 0), 2, 0x0uLL))
+        return 1;
+    if (test__umodti3(make_tu(0xFFFFFFFFFFFFFFFFuLL, 0xFFFFFFFFFFFFFFFFuLL),
+                      2, 0x1uLL))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/unorddf2vfp_test.c b/compiler-rt/test/builtins/Unit/unorddf2vfp_test.c
new file mode 100644
index 0000000..d49d567
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/unorddf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- unorddf2vfp_test.c - Test __unorddf2vfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __unorddf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __unorddf2vfp(double a, double b);
+
+#if __arm__
+int test__unorddf2vfp(double a, double b)
+{
+    int actual = __unorddf2vfp(a, b);
+	int expected = (isnan(a) || isnan(b)) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __unorddf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__unorddf2vfp(0.0, NAN))
+        return 1;
+    if (test__unorddf2vfp(NAN, 1.0))
+        return 1;
+    if (test__unorddf2vfp(NAN, NAN))
+        return 1;
+    if (test__unorddf2vfp(1.0, 1.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/unordsf2vfp_test.c b/compiler-rt/test/builtins/Unit/unordsf2vfp_test.c
new file mode 100644
index 0000000..3cadc81
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/unordsf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- unordsf2vfp_test.c - Test __unordsf2vfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __unordsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+
+
+extern int __unordsf2vfp(float a, float b);
+
+#if __arm__
+int test__unordsf2vfp(float a, float b)
+{
+    int actual = __unordsf2vfp(a, b);
+	int expected = (isnan(a) || isnan(b)) ? 1 : 0;
+    if (actual != expected)
+        printf("error in __unordsf2vfp(%f, %f) = %d, expected %d\n",
+               a, b, actual, expected);
+    return actual != expected;
+}
+#endif
+
+int main()
+{
+#if __arm__
+    if (test__unordsf2vfp(0.0, NAN))
+        return 1;
+    if (test__unordsf2vfp(NAN, 1.0))
+        return 1;
+    if (test__unordsf2vfp(NAN, NAN))
+        return 1;
+    if (test__unordsf2vfp(1.0, 1.0))
+        return 1;
+#else
+    printf("skipped\n");
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/Unit/unordtf2_test.c b/compiler-rt/test/builtins/Unit/unordtf2_test.c
new file mode 100644
index 0000000..114cd8c
--- /dev/null
+++ b/compiler-rt/test/builtins/Unit/unordtf2_test.c
@@ -0,0 +1,65 @@
+//===------------ unordtf2_test.c - Test __unordtf2------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __unordtf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __unordtf2(long double a, long double b);
+
+int test__unordtf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __unordtf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__unordtf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__unordtf2(makeQNaN128(),
+                       0x1.234567890abcdef1234567890abcp+3L,
+                       NEQUAL_0))
+        return 1;
+    // other
+    if (test__unordtf2(0x1.234567890abcdef1234567890abcp+3L,
+                       0x1.334567890abcdef1234567890abcp+3L,
+                       EQUAL_0))
+        return 1;
+    if (test__unordtf2(0x1.234567890abcdef1234567890abcp+3L,
+                       0x1.234567890abcdef1234567890abcp+3L,
+                       EQUAL_0))
+        return 1;
+    if (test__unordtf2(0x1.234567890abcdef1234567890abcp+3L,
+                       0x1.234567890abcdef1234567890abcp-3L,
+                       EQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/ashldi3.c b/compiler-rt/test/builtins/timing/ashldi3.c
new file mode 100644
index 0000000..0d7378d
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/ashldi3.c
@@ -0,0 +1,49 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __ashldi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+int64_t FUNCTION_NAME(int64_t input, INPUT_TYPE count);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = rand() & 0x3f;
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(fixedInput, input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/ashrdi3.c b/compiler-rt/test/builtins/timing/ashrdi3.c
new file mode 100644
index 0000000..84e11f7
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/ashrdi3.c
@@ -0,0 +1,49 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __ashrdi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+int64_t FUNCTION_NAME(int64_t input, INPUT_TYPE count);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = rand() & 0x3f;
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(fixedInput, input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/divdi3.c b/compiler-rt/test/builtins/timing/divdi3.c
new file mode 100644
index 0000000..37937aa
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/divdi3.c
@@ -0,0 +1,52 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __divdi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input1, INPUT_TYPE input2);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input1[INPUT_SIZE];
+	INPUT_TYPE input2[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input1[i] = (((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+		input2[i] = ((((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63)) + 1LL;
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input1[i], input2[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/floatdidf.c b/compiler-rt/test/builtins/timing/floatdidf.c
new file mode 100644
index 0000000..2c970d4
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/floatdidf.c
@@ -0,0 +1,47 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __floatdidf
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+double FUNCTION_NAME(INPUT_TYPE x);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = (((uint64_t)rand() << 32) | (uint64_t)rand()) >> (rand() & 63);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/floatdisf.c b/compiler-rt/test/builtins/timing/floatdisf.c
new file mode 100644
index 0000000..801ab0a
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/floatdisf.c
@@ -0,0 +1,47 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __floatdisf
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+float FUNCTION_NAME(INPUT_TYPE x);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = (((uint64_t)rand() << 32) | (uint64_t)rand()) >> (rand() & 63);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/floatdixf.c b/compiler-rt/test/builtins/timing/floatdixf.c
new file mode 100644
index 0000000..b646e3c
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/floatdixf.c
@@ -0,0 +1,47 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __floatdixf
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+long double FUNCTION_NAME(INPUT_TYPE x);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = (((uint64_t)rand() << 32) | (uint64_t)rand()) >> (rand() & 63);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/floatundidf.c b/compiler-rt/test/builtins/timing/floatundidf.c
new file mode 100644
index 0000000..25c02bd
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/floatundidf.c
@@ -0,0 +1,44 @@
+#include "timing.h"
+#include <stdio.h>
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+double __floatundidf(uint64_t x);
+
+int main(int argc, char *argv[]) {
+#define INPUT_SIZE 512
+	uint64_t input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = (((uint64_t)rand() << 32) | (uint64_t)rand()) >> (rand() & 63);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			__floatundidf(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/floatundisf.c b/compiler-rt/test/builtins/timing/floatundisf.c
new file mode 100644
index 0000000..ec8f3be
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/floatundisf.c
@@ -0,0 +1,47 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE uint64_t
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __floatundisf
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+float FUNCTION_NAME(INPUT_TYPE x);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = (((uint64_t)rand() << 32) | (uint64_t)rand()) >> (rand() & 63);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/floatundixf.c b/compiler-rt/test/builtins/timing/floatundixf.c
new file mode 100644
index 0000000..46733eb
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/floatundixf.c
@@ -0,0 +1,47 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE uint64_t
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __floatundixf
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+long double FUNCTION_NAME(INPUT_TYPE x);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = (((uint64_t)rand() << 32) | (uint64_t)rand()) >> (rand() & 63);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/lshrdi3.c b/compiler-rt/test/builtins/timing/lshrdi3.c
new file mode 100644
index 0000000..b474cf3
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/lshrdi3.c
@@ -0,0 +1,49 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int
+#define INPUT_SIZE 512
+#define FUNCTION_NAME __lshrdi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+int64_t FUNCTION_NAME(int64_t input, INPUT_TYPE count);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i)
+		input[i] = rand() & 0x3f;
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(fixedInput, input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/moddi3.c b/compiler-rt/test/builtins/timing/moddi3.c
new file mode 100644
index 0000000..83e2441
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/moddi3.c
@@ -0,0 +1,52 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __moddi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input1, INPUT_TYPE input2);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input1[INPUT_SIZE];
+	INPUT_TYPE input2[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input1[i] = (((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+		input2[i] = ((((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63)) + 1LL;
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input1[i], input2[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/modsi3.c b/compiler-rt/test/builtins/timing/modsi3.c
new file mode 100644
index 0000000..3275b83
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/modsi3.c
@@ -0,0 +1,52 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int32_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __modsi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input1, INPUT_TYPE input2);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input1[INPUT_SIZE];
+	INPUT_TYPE input2[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input1[i] = rand();
+		input2[i] = rand() + 1;
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input1[i], input2[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/muldi3.c b/compiler-rt/test/builtins/timing/muldi3.c
new file mode 100644
index 0000000..3ba3af2
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/muldi3.c
@@ -0,0 +1,52 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __muldi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input1, INPUT_TYPE input2);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input1[INPUT_SIZE];
+	INPUT_TYPE input2[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input1[i] = (((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+		input2[i] = (((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input1[i], input2[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/negdi2.c b/compiler-rt/test/builtins/timing/negdi2.c
new file mode 100644
index 0000000..2668eb1
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/negdi2.c
@@ -0,0 +1,50 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE int64_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __negdi2
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input[i] = (((int64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/time b/compiler-rt/test/builtins/timing/time
new file mode 100755
index 0000000..35da97d
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/time
@@ -0,0 +1,39 @@
+#!/bin/sh
+
+function test () {
+    arch=$1
+    file=$2
+    name=$3
+    ldflags=$4
+
+    if gcc -arch $arch -Os $file $ldflags -DLIBNAME=$name
+    then
+	if ./a.out
+	then
+	    rm ./a.out
+	else
+	    echo "fail"
+	fi
+    else
+	echo "$FILE failed to compile"
+    fi
+}
+
+INSTALLED=/usr/local/lib/system/libcompiler_rt.a
+
+for ARCH in i386 x86_64; do
+	for FILE in $(ls *.c); do
+		
+		echo "Timing $FILE for $ARCH"
+
+		test $ARCH $FILE libgcc ""
+                test $ARCH $FILE tuned ../../darwin_fat/Release/libcompiler_rt.a
+                if [ -f "$INSTALLED" ]; then
+                    test $ARCH $FILE installed $INSTALLED
+		fi
+
+		echo " "
+		
+	done
+done
+exit
diff --git a/compiler-rt/test/builtins/timing/timing.h b/compiler-rt/test/builtins/timing/timing.h
new file mode 100644
index 0000000..bb6c41e
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/timing.h
@@ -0,0 +1,28 @@
+#include <mach/mach_time.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+double intervalInCycles( uint64_t startTime, uint64_t endTime )
+{
+	uint64_t rawTime = endTime - startTime;
+	static double conversion = 0.0;
+	
+	if( 0.0 == conversion )
+	{
+		mach_timebase_info_data_t	info;
+		kern_return_t err = mach_timebase_info( &info );
+		if( 0 != err )
+			return 0;
+		
+		uint64_t freq = 0;
+		size_t freqSize = sizeof( freq );
+		int err2 = sysctlbyname( "hw.cpufrequency", &freq, &freqSize, NULL, 0L );
+		if( 0 != err2 )
+			return 0;
+		
+		conversion = (double) freq * (1e-9 * (double) info.numer / (double) info.denom);
+	}
+	
+	return (double) rawTime * conversion;
+}
+
diff --git a/compiler-rt/test/builtins/timing/udivdi3.c b/compiler-rt/test/builtins/timing/udivdi3.c
new file mode 100644
index 0000000..9c6a7e8
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/udivdi3.c
@@ -0,0 +1,52 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE uint64_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __udivdi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input1, INPUT_TYPE input2);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input1[INPUT_SIZE];
+	INPUT_TYPE input2[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input1[i] = (((uint64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+		input2[i] = ((((uint64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63)) + 1LL;
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input1[i], input2[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/builtins/timing/umoddi3.c b/compiler-rt/test/builtins/timing/umoddi3.c
new file mode 100644
index 0000000..a81c46e
--- /dev/null
+++ b/compiler-rt/test/builtins/timing/umoddi3.c
@@ -0,0 +1,52 @@
+#include "timing.h"
+#include <stdio.h>
+
+#define INPUT_TYPE uint64_t
+#define INPUT_SIZE 256
+#define FUNCTION_NAME __umoddi3
+
+#ifndef LIBNAME
+#define LIBNAME UNKNOWN
+#endif
+
+#define LIBSTRING		LIBSTRINGX(LIBNAME)
+#define LIBSTRINGX(a)	LIBSTRINGXX(a)
+#define LIBSTRINGXX(a)	#a
+
+INPUT_TYPE FUNCTION_NAME(INPUT_TYPE input1, INPUT_TYPE input2);
+
+int main(int argc, char *argv[]) {
+	INPUT_TYPE input1[INPUT_SIZE];
+	INPUT_TYPE input2[INPUT_SIZE];
+	int i, j;
+	
+	srand(42);
+	
+	// Initialize the input array with data of various sizes.
+	for (i=0; i<INPUT_SIZE; ++i) {
+		input1[i] = (((uint64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63);
+		input2[i] = ((((uint64_t)rand() << 36) | (uint64_t)rand()) >> (rand() & 63)) + 1LL;
+	}
+	
+	int64_t fixedInput = INT64_C(0x1234567890ABCDEF);
+	
+	double bestTime = __builtin_inf();
+	void *dummyp;
+	for (j=0; j<1024; ++j) {
+		
+		uint64_t startTime = mach_absolute_time();
+		for (i=0; i<INPUT_SIZE; ++i)
+			FUNCTION_NAME(input1[i], input2[i]);
+		uint64_t endTime = mach_absolute_time();
+		
+		double thisTime = intervalInCycles(startTime, endTime);
+		bestTime = __builtin_fmin(thisTime, bestTime);
+		
+		// Move the stack alignment between trials to eliminate (mostly) aliasing effects
+		dummyp = alloca(1);
+	}
+	
+	printf("%16s: %f cycles.\n", LIBSTRING, bestTime / (double) INPUT_SIZE);
+	
+	return 0;
+}
diff --git a/compiler-rt/test/cfi/CMakeLists.txt b/compiler-rt/test/cfi/CMakeLists.txt
new file mode 100644
index 0000000..c4f7eb9
--- /dev/null
+++ b/compiler-rt/test/cfi/CMakeLists.txt
@@ -0,0 +1,39 @@
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+  )
+
+set(CFI_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND CFI_TEST_DEPS
+    cfi
+    opt
+    ubsan
+  )
+  if(LLVM_ENABLE_PIC AND LLVM_BINUTILS_INCDIR)
+    list(APPEND CFI_TEST_DEPS
+      LLVMgold
+    )
+  endif()
+  if(APPLE)
+    list(APPEND CFI_TEST_DEPS
+      LTO
+    )
+  endif()
+  if(WIN32 AND COMPILER_RT_HAS_LLD_SOURCES)
+    list(APPEND CFI_TEST_DEPS
+      lld
+    )
+  endif()
+endif()
+
+add_lit_testsuite(check-cfi "Running the cfi regression tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS ${CFI_TEST_DEPS})
+
+add_lit_target(check-cfi-and-supported "Running the cfi regression tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  PARAMS check_supported=1
+  DEPENDS ${CFI_TEST_DEPS})
+
+set_target_properties(check-cfi PROPERTIES FOLDER "Tests")
diff --git a/compiler-rt/test/cfi/README.txt b/compiler-rt/test/cfi/README.txt
new file mode 100644
index 0000000..6b82f5e
--- /dev/null
+++ b/compiler-rt/test/cfi/README.txt
@@ -0,0 +1,8 @@
+The tests in this directory use a common convention for exercising the
+functionality associated with bit sets of different sizes. When certain
+macros are defined the tests instantiate classes that force the bit sets
+to be of certain sizes.
+
+- B32 forces 32-bit bit sets.
+- B64 forces 64-bit bit sets.
+- BM forces memory bit sets.
diff --git a/compiler-rt/test/cfi/anon-namespace.cpp b/compiler-rt/test/cfi/anon-namespace.cpp
new file mode 100644
index 0000000..8e6c1c1
--- /dev/null
+++ b/compiler-rt/test/cfi/anon-namespace.cpp
@@ -0,0 +1,91 @@
+// RUN: %clangxx_cfi -c -DTU1 -o %t1.o %s
+// RUN: %clangxx_cfi -c -DTU2 -o %t2.o %S/../cfi/anon-namespace.cpp
+// RUN: %clangxx_cfi -o %t1 %t1.o %t2.o
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -c -DTU1 -DB32 -o %t1.o %s
+// RUN: %clangxx_cfi -c -DTU2 -DB32 -o %t2.o %S/../cfi/anon-namespace.cpp
+// RUN: %clangxx_cfi -o %t2 %t1.o %t2.o
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -c -DTU1 -DB64 -o %t1.o %s
+// RUN: %clangxx_cfi -c -DTU2 -DB64 -o %t2.o %S/../cfi/anon-namespace.cpp
+// RUN: %clangxx_cfi -o %t3 %t1.o %t2.o
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -c -DTU1 -DBM -o %t1.o %s
+// RUN: %clangxx_cfi -c -DTU2 -DBM -o %t2.o %S/../cfi/anon-namespace.cpp
+// RUN: %clangxx_cfi -o %t4 %t1.o %t2.o
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -c -DTU1 -o %t1.o %s
+// RUN: %clangxx -c -DTU2 -o %t2.o %S/../cfi/anon-namespace.cpp
+// RUN: %clangxx -o %t5 %t1.o %t2.o
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// RUN: %clangxx_cfi_diag -c -DTU1 -o %t1.o %s
+// RUN: %clangxx_cfi_diag -c -DTU2 -o %t2.o %S/../cfi/anon-namespace.cpp
+// RUN: %clangxx_cfi_diag -o %t6 %t1.o %t2.o
+// RUN: %t6 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+// Tests that the CFI mechanism treats classes in the anonymous namespace in
+// different translation units as having distinct identities. This is done by
+// compiling two translation units TU1 and TU2 containing a class named B in an
+// anonymous namespace, and testing that the program crashes if TU2 attempts to
+// use a TU1 B as a TU2 B.
+
+// FIXME: This test should not require that the paths supplied to the compiler
+// are different. It currently does so because bitset names have global scope
+// so we have to mangle the file path into the bitset name.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f() = 0;
+};
+
+namespace {
+
+struct B : A {
+  virtual void f() {}
+};
+
+}
+
+A *mkb();
+
+#ifdef TU1
+
+A *mkb() {
+  return new B;
+}
+
+#endif  // TU1
+
+#ifdef TU2
+
+int main() {
+  create_derivers<B>();
+
+  A *a = mkb();
+  break_optimization(a);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-DIAG: runtime error: control flow integrity check for type '(anonymous namespace)::B' failed during base-to-derived cast
+  // CFI-DIAG-NEXT: note: vtable is of type '{{.*}}anonymous namespace{{.*}}::B'
+  // CFI-DIAG: runtime error: control flow integrity check for type '(anonymous namespace)::B' failed during virtual call
+  // CFI-DIAG-NEXT: note: vtable is of type '{{.*}}anonymous namespace{{.*}}::B'
+  ((B *)a)->f(); // UB here
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
+
+#endif  // TU2
diff --git a/compiler-rt/test/cfi/bad-cast.cpp b/compiler-rt/test/cfi/bad-cast.cpp
new file mode 100644
index 0000000..e2f4f25
--- /dev/null
+++ b/compiler-rt/test/cfi/bad-cast.cpp
@@ -0,0 +1,137 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 a 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t1 b 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t1 c 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t1 d 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t1 e 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t1 f 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %expect_crash %t1 g 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t1 h 2>&1 | FileCheck --check-prefix=PASS %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 a 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t2 b 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t2 c 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t2 d 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t2 e 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t2 f 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %expect_crash %t2 g 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t2 h 2>&1 | FileCheck --check-prefix=PASS %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 a 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t3 b 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t3 c 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t3 d 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t3 e 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t3 f 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %expect_crash %t3 g 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t3 h 2>&1 | FileCheck --check-prefix=PASS %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 a 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t4 b 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t4 c 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t4 d 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t4 e 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t4 f 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %expect_crash %t4 g 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %t4 h 2>&1 | FileCheck --check-prefix=PASS %s
+
+// RUN: %clangxx_cfi -fsanitize=cfi-cast-strict -o %t5 %s
+// RUN: %expect_crash %t5 a 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 b 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 c 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 d 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 e 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 f 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 g 2>&1 | FileCheck --check-prefix=FAIL %s
+// RUN: %expect_crash %t5 h 2>&1 | FileCheck --check-prefix=FAIL %s
+
+// RUN: %clangxx -o %t6 %s
+// RUN: %t6 a 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 b 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 c 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 d 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 e 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 f 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 g 2>&1 | FileCheck --check-prefix=PASS %s
+// RUN: %t6 h 2>&1 | FileCheck --check-prefix=PASS %s
+
+// RUN: %clangxx_cfi_diag -o %t7 %s
+// RUN: %t7 a 2>&1 | FileCheck --check-prefix=CFI-DIAG-D %s
+// RUN: %t7 b 2>&1 | FileCheck --check-prefix=CFI-DIAG-D %s
+// RUN: %t7 c 2>&1 | FileCheck --check-prefix=CFI-DIAG-D %s
+// RUN: %t7 g 2>&1 | FileCheck --check-prefix=CFI-DIAG-U %s
+
+// Tests that the CFI enforcement detects bad casts.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f();
+};
+
+void A::f() {}
+
+struct B : A {
+  virtual void f();
+};
+
+void B::f() {}
+
+struct C : A {
+};
+
+int main(int argc, char **argv) {
+  create_derivers<B>();
+
+  B *b = new B;
+  break_optimization(b);
+
+  // FAIL: 1
+  // PASS: 1
+  fprintf(stderr, "1\n");
+
+  A a;
+
+  // CFI-DIAG-D: runtime error: control flow integrity check for type 'B' failed during base-to-derived cast
+  // CFI-DIAG-D-NEXT: note: vtable is of type '{{(struct )?}}A'
+
+  // CFI-DIAG-U: runtime error: control flow integrity check for type 'B' failed during cast to unrelated type
+  // CFI-DIAG-U-NEXT: note: vtable is of type '{{(struct )?}}A'
+
+  switch (argv[1][0]) {
+    case 'a':
+      static_cast<B *>(&a); // UB
+      break;
+    case 'b':
+      static_cast<B &>(a); // UB
+      break;
+    case 'c':
+      static_cast<B &&>(a); // UB
+      break;
+    case 'd':
+      static_cast<C *>(&a); // UB, strict only
+      break;
+    case 'e':
+      static_cast<C &>(a); // UB, strict only
+      break;
+    case 'f':
+      static_cast<C &&>(a); // UB, strict only
+      break;
+    case 'g':
+      static_cast<B *>(static_cast<void *>(&a)); // Non-UB bad cast
+      break;
+    case 'h':
+      static_cast<C *>(static_cast<void *>(&a)); // Non-UB bad cast, strict only
+      break;
+  }
+
+  // FAIL-NOT: {{^2$}}
+  // PASS: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/base-derived-destructor.cpp b/compiler-rt/test/cfi/base-derived-destructor.cpp
new file mode 100644
index 0000000..c5e9db1
--- /dev/null
+++ b/compiler-rt/test/cfi/base-derived-destructor.cpp
@@ -0,0 +1,93 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -o %t5 %s
+// RUN: %expect_crash %t5 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -DB32 -o %t6 %s
+// RUN: %expect_crash %t6 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -DB64 -o %t7 %s
+// RUN: %expect_crash %t7 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -DBM -o %t8 %s
+// RUN: %expect_crash %t8 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -o %t9 %s
+// RUN: %expect_crash %t9 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -DB32 -o %t10 %s
+// RUN: %expect_crash %t10 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -DB64 -o %t11 %s
+// RUN: %expect_crash %t11 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -DBM -o %t12 %s
+// RUN: %expect_crash %t12 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -o %t13 %s
+// RUN: %expect_crash %t13 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -DB32 -o %t14 %s
+// RUN: %expect_crash %t14 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -DB64 -o %t15 %s
+// RUN: %expect_crash %t15 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -DBM -o %t16 %s
+// RUN: %expect_crash %t16 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi_diag -o %t17 %s
+// RUN: %t17 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+// RUN: %clangxx -o %t18 %s
+// RUN: %t18 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// Tests that the CFI mechanism crashes the program when making a
+// base-to-derived cast from a destructor of the base class,
+// where both types have virtual tables.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+template<typename T>
+class A {
+ public:
+  T* context() { return static_cast<T*>(this); }
+
+  virtual ~A() {
+    break_optimization(context());
+  }
+};
+
+class B : public A<B> {
+ public:
+  virtual ~B() { }
+};
+
+int main() {
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-DIAG: runtime error: control flow integrity check for type 'B' failed during base-to-derived cast
+  // CFI-DIAG-NEXT: note: vtable is of type '{{(class )?}}A<{{(class )?}}B>'
+  B* b = new B;
+  break_optimization(b);
+  delete b; // UB here
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/create-derivers.test b/compiler-rt/test/cfi/create-derivers.test
new file mode 100644
index 0000000..79521e4
--- /dev/null
+++ b/compiler-rt/test/cfi/create-derivers.test
@@ -0,0 +1,20 @@
+REQUIRES: asserts
+
+RUN: %clangxx_cfi -c -o %t1.o %S/simple-fail.cpp
+RUN: opt -lowerbitsets -debug-only=lowerbitsets -o /dev/null %t1.o 2>&1 | FileCheck --check-prefix=B0 %s
+B0: {{1B|B@@}}: {{.*}} size 1
+
+RUN: %clangxx_cfi -DB32 -c -o %t2.o %S/simple-fail.cpp
+RUN: opt -lowerbitsets -debug-only=lowerbitsets -o /dev/null %t2.o 2>&1 | FileCheck --check-prefix=B32 %s
+B32: {{1B|B@@}}: {{.*}} size 24
+B32-NOT: all-ones
+
+RUN: %clangxx_cfi -DB64 -c -o %t3.o %S/simple-fail.cpp
+RUN: opt -lowerbitsets -debug-only=lowerbitsets -o /dev/null %t3.o 2>&1 | FileCheck --check-prefix=B64 %s
+B64: {{1B|B@@}}: {{.*}} size 54
+B64-NOT: all-ones
+
+RUN: %clangxx_cfi -DBM -c -o %t4.o %S/simple-fail.cpp
+RUN: opt -lowerbitsets -debug-only=lowerbitsets -o /dev/null %t4.o 2>&1 | FileCheck --check-prefix=BM %s
+BM: {{1B|B@@}}: {{.*}} size 84
+BM-NOT: all-ones
diff --git a/compiler-rt/test/cfi/cross-dso/icall/icall-from-dso.cpp b/compiler-rt/test/cfi/cross-dso/icall/icall-from-dso.cpp
new file mode 100644
index 0000000..1995f05
--- /dev/null
+++ b/compiler-rt/test/cfi/cross-dso/icall/icall-from-dso.cpp
@@ -0,0 +1,26 @@
+// RUN: %clangxx_cfi_dso -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_cfi_dso %s -o %t %t-so.so && %expect_crash %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+#ifdef SHARED_LIB
+void g();
+void f() {
+  // CHECK: =1=
+  fprintf(stderr, "=1=\n");
+  ((void (*)(void))g)();
+  // CHECK: =2=
+  fprintf(stderr, "=2=\n");
+  ((void (*)(int))g)(42); // UB here
+  // CHECK-NOT: =3=
+  fprintf(stderr, "=3=\n");
+}
+#else
+void f();
+void g() {
+}
+
+int main() {
+  f();
+}
+#endif
diff --git a/compiler-rt/test/cfi/cross-dso/icall/icall.cpp b/compiler-rt/test/cfi/cross-dso/icall/icall.cpp
new file mode 100644
index 0000000..d7cc2f9
--- /dev/null
+++ b/compiler-rt/test/cfi/cross-dso/icall/icall.cpp
@@ -0,0 +1,21 @@
+// RUN: %clangxx_cfi_dso -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_cfi_dso %s -o %t %t-so.so && %expect_crash %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+#ifdef SHARED_LIB
+void f() {
+}
+#else
+void f();
+int main() {
+  // CHECK: =1=
+  fprintf(stderr, "=1=\n");
+  ((void (*)(void))f)();
+  // CHECK: =2=
+  fprintf(stderr, "=2=\n");
+  ((void (*)(int))f)(42); // UB here
+  // CHECK-NOT: =3=
+  fprintf(stderr, "=3=\n");
+}
+#endif
diff --git a/compiler-rt/test/cfi/cross-dso/icall/lit.local.cfg b/compiler-rt/test/cfi/cross-dso/icall/lit.local.cfg
new file mode 100644
index 0000000..db08765
--- /dev/null
+++ b/compiler-rt/test/cfi/cross-dso/icall/lit.local.cfg
@@ -0,0 +1,3 @@
+# The cfi-icall checker is only supported on x86 and x86_64 for now.
+if config.root.host_arch not in ['x86', 'x86_64']:
+  config.unsupported = True
diff --git a/compiler-rt/test/cfi/cross-dso/lit.local.cfg b/compiler-rt/test/cfi/cross-dso/lit.local.cfg
new file mode 100644
index 0000000..57271b8
--- /dev/null
+++ b/compiler-rt/test/cfi/cross-dso/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/cfi/cross-dso/simple-fail.cpp b/compiler-rt/test/cfi/cross-dso/simple-fail.cpp
new file mode 100644
index 0000000..dda57d2
--- /dev/null
+++ b/compiler-rt/test/cfi/cross-dso/simple-fail.cpp
@@ -0,0 +1,87 @@
+// RUN: %clangxx_cfi_dso -DSHARED_LIB %s -fPIC -shared -o %t1-so.so
+// RUN: %clangxx_cfi_dso %s -o %t1 %t1-so.so
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t1 x 2>&1 | FileCheck --check-prefix=CFI-CAST %s
+
+// RUN: %clangxx_cfi_dso -DB32 -DSHARED_LIB %s -fPIC -shared -o %t2-so.so
+// RUN: %clangxx_cfi_dso -DB32 %s -o %t2 %t2-so.so
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t2 x 2>&1 | FileCheck --check-prefix=CFI-CAST %s
+
+// RUN: %clangxx_cfi_dso -DB64 -DSHARED_LIB %s -fPIC -shared -o %t3-so.so
+// RUN: %clangxx_cfi_dso -DB64 %s -o %t3 %t3-so.so
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t3 x 2>&1 | FileCheck --check-prefix=CFI-CAST %s
+
+// RUN: %clangxx_cfi_dso -DBM -DSHARED_LIB %s -fPIC -shared -o %t4-so.so
+// RUN: %clangxx_cfi_dso -DBM %s -o %t4 %t4-so.so
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t4 x 2>&1 | FileCheck --check-prefix=CFI-CAST %s
+
+// RUN: %clangxx -DBM -DSHARED_LIB %s -fPIC -shared -o %t5-so.so
+// RUN: %clangxx -DBM %s -o %t5 %t5-so.so
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+// RUN: %t5 x 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// Tests that the CFI mechanism crashes the program when making a virtual call
+// to an object of the wrong class but with a compatible vtable, by casting a
+// pointer to such an object and attempting to make a call through it.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include <string.h>
+
+struct A {
+  virtual void f();
+};
+
+void *create_B();
+
+#ifdef SHARED_LIB
+
+#include "../utils.h"
+struct B {
+  virtual void f();
+};
+void B::f() {}
+
+void *create_B() {
+  create_derivers<B>();
+  return (void *)(new B());
+}
+
+#else
+
+void A::f() {}
+
+int main(int argc, char *argv[]) {
+  void *p = create_B();
+  A *a;
+
+  // CFI: =0=
+  // CFI-CAST: =0=
+  // NCFI: =0=
+  fprintf(stderr, "=0=\n");
+
+  if (argc > 1 && argv[1][0] == 'x') {
+    // Test cast. BOOM.
+    a = (A*)p;
+  } else {
+    // Invisible to CFI. Test virtual call later.
+    memcpy(&a, &p, sizeof(a));
+  }
+
+  // CFI: =1=
+  // CFI-CAST-NOT: =1=
+  // NCFI: =1=
+  fprintf(stderr, "=1=\n");
+
+  a->f(); // UB here
+
+  // CFI-NOT: =2=
+  // CFI-CAST-NOT: =2=
+  // NCFI: =2=
+  fprintf(stderr, "=2=\n");
+}
+#endif
diff --git a/compiler-rt/test/cfi/cross-dso/simple-pass.cpp b/compiler-rt/test/cfi/cross-dso/simple-pass.cpp
new file mode 100644
index 0000000..42f7a27
--- /dev/null
+++ b/compiler-rt/test/cfi/cross-dso/simple-pass.cpp
@@ -0,0 +1,65 @@
+// RUN: %clangxx_cfi_dso -DSHARED_LIB %s -fPIC -shared -o %t1-so.so
+// RUN: %clangxx_cfi_dso %s -o %t1 %t1-so.so
+// RUN: %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi_dso -DB32 -DSHARED_LIB %s -fPIC -shared -o %t2-so.so
+// RUN: %clangxx_cfi_dso -DB32 %s -o %t2 %t2-so.so
+// RUN: %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi_dso -DB64 -DSHARED_LIB %s -fPIC -shared -o %t3-so.so
+// RUN: %clangxx_cfi_dso -DB64 %s -o %t3 %t3-so.so
+// RUN: %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi_dso -DBM -DSHARED_LIB %s -fPIC -shared -o %t4-so.so
+// RUN: %clangxx_cfi_dso -DBM %s -o %t4 %t4-so.so
+// RUN: %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -DBM -DSHARED_LIB %s -fPIC -shared -o %t5-so.so
+// RUN: %clangxx -DBM %s -o %t5 %t5-so.so
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+// RUN: %t5 x 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// Tests that the CFI mechanism crashes the program when making a virtual call
+// to an object of the wrong class but with a compatible vtable, by casting a
+// pointer to such an object and attempting to make a call through it.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include <string.h>
+
+struct A {
+  virtual void f();
+};
+
+A *create_B();
+
+#ifdef SHARED_LIB
+
+#include "../utils.h"
+struct B : public A {
+  virtual void f();
+};
+void B::f() {}
+
+A *create_B() {
+  create_derivers<B>();
+  return new B();
+}
+
+#else
+
+void A::f() {}
+
+int main(int argc, char *argv[]) {
+  A *a = create_B();
+
+  // CFI: =1=
+  // NCFI: =1=
+  fprintf(stderr, "=1=\n");
+  a->f(); // OK
+  // CFI: =2=
+  // NCFI: =2=
+  fprintf(stderr, "=2=\n");
+}
+#endif
diff --git a/compiler-rt/test/cfi/icall/bad-signature.c b/compiler-rt/test/cfi/icall/bad-signature.c
new file mode 100644
index 0000000..43de117
--- /dev/null
+++ b/compiler-rt/test/cfi/icall/bad-signature.c
@@ -0,0 +1,27 @@
+// RUN: %clangxx -o %t1 %s
+// RUN: %t1 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// RUN: %clangxx_cfi -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi_diag -g -o %t3 %s
+// RUN: %t3 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+#include <stdio.h>
+
+void f() {
+}
+
+int main() {
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-DIAG: runtime error: control flow integrity check for type 'void (int)' failed during indirect function call
+  // CFI-DIAG: f() defined here
+  ((void (*)(int))f)(42); // UB here
+
+  // CFI-NOT: 2
+  // NCFI: 2
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/icall/external-call.c b/compiler-rt/test/cfi/icall/external-call.c
new file mode 100644
index 0000000..43fc252
--- /dev/null
+++ b/compiler-rt/test/cfi/icall/external-call.c
@@ -0,0 +1,27 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %t1 c 1 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %t1 s 2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// This test uses jump tables containing PC-relative references to external
+// symbols, which the Mach-O object writer does not currently support.
+// XFAIL: darwin
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main(int argc, char **argv) {
+  // CFI: 1
+  fprintf(stderr, "1\n");
+
+  double (*fn)(double);
+  if (argv[1][0] == 's')
+    fn = sin;
+  else
+    fn = cos;
+
+  fn(atof(argv[2]));
+
+  // CFI: 2
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/icall/lit.local.cfg b/compiler-rt/test/cfi/icall/lit.local.cfg
new file mode 100644
index 0000000..db08765
--- /dev/null
+++ b/compiler-rt/test/cfi/icall/lit.local.cfg
@@ -0,0 +1,3 @@
+# The cfi-icall checker is only supported on x86 and x86_64 for now.
+if config.root.host_arch not in ['x86', 'x86_64']:
+  config.unsupported = True
diff --git a/compiler-rt/test/cfi/lit.cfg b/compiler-rt/test/cfi/lit.cfg
new file mode 100644
index 0000000..687c80f
--- /dev/null
+++ b/compiler-rt/test/cfi/lit.cfg
@@ -0,0 +1,22 @@
+import lit.formats
+import os
+
+config.name = 'cfi'
+config.suffixes = ['.c', '.cpp', '.test']
+config.test_source_root = os.path.dirname(__file__)
+
+clangxx = ' '.join([config.clang] + config.cxx_mode_flags)
+
+config.substitutions.append((r"%clangxx ", clangxx + ' '))
+if config.lto_supported:
+  clangxx_cfi = ' '.join(config.lto_launch + [clangxx] + config.lto_flags + ['-flto -fsanitize=cfi '])
+  clangxx_cfi_diag = clangxx_cfi + '-fno-sanitize-trap=cfi -fsanitize-recover=cfi '
+  config.substitutions.append((r"%clangxx_cfi ", clangxx_cfi))
+  config.substitutions.append((r"%clangxx_cfi_diag ", clangxx_cfi_diag))
+  config.substitutions.append((r"%clangxx_cfi_dso ", clangxx_cfi + '-fsanitize-cfi-cross-dso '))
+  config.substitutions.append((r"%clangxx_cfi_dso_diag ", clangxx_cfi_diag + '-fsanitize-cfi-cross-dso '))
+else:
+  config.unsupported = True
+
+if lit_config.params.get('check_supported', None) and config.unsupported:
+  raise BaseException("Tests unsupported")
diff --git a/compiler-rt/test/cfi/lit.site.cfg.in b/compiler-rt/test/cfi/lit.site.cfg.in
new file mode 100644
index 0000000..76897e7
--- /dev/null
+++ b/compiler-rt/test/cfi/lit.site.cfg.in
@@ -0,0 +1,2 @@
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg")
diff --git a/compiler-rt/test/cfi/multiple-inheritance.cpp b/compiler-rt/test/cfi/multiple-inheritance.cpp
new file mode 100644
index 0000000..a3b2ac5
--- /dev/null
+++ b/compiler-rt/test/cfi/multiple-inheritance.cpp
@@ -0,0 +1,74 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t1 x 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t2 x 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t3 x 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+// RUN: %expect_crash %t4 x 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -o %t5 %s
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+// RUN: %t5 x 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// RUN: %clangxx_cfi_diag -o %t6 %s
+// RUN: %t6 2>&1 | FileCheck --check-prefix=CFI-DIAG2 %s
+// RUN: %t6 x 2>&1 | FileCheck --check-prefix=CFI-DIAG1 %s
+
+// Tests that the CFI mechanism is sensitive to multiple inheritance and only
+// permits calls via virtual tables for the correct base class.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f() = 0;
+};
+
+struct B {
+  virtual void g() = 0;
+};
+
+struct C : A, B {
+  virtual void f(), g();
+};
+
+void C::f() {}
+void C::g() {}
+
+int main(int argc, char **argv) {
+  create_derivers<A>();
+  create_derivers<B>();
+
+  C *c = new C;
+  break_optimization(c);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  if (argc > 1) {
+    A *a = c;
+    // CFI-DIAG1: runtime error: control flow integrity check for type 'B' failed during cast to unrelated type
+    // CFI-DIAG1-NEXT: note: vtable is of type '{{(struct )?}}C'
+    ((B *)a)->g(); // UB here
+  } else {
+    // CFI-DIAG2: runtime error: control flow integrity check for type 'A' failed during cast to unrelated type
+    // CFI-DIAG2-NEXT: note: vtable is of type '{{(struct )?}}C'
+    B *b = c;
+    ((A *)b)->f(); // UB here
+  }
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/nvcall.cpp b/compiler-rt/test/cfi/nvcall.cpp
new file mode 100644
index 0000000..9d8f5f4
--- /dev/null
+++ b/compiler-rt/test/cfi/nvcall.cpp
@@ -0,0 +1,59 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -o %t5 %s
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// RUN: %clangxx_cfi_diag -o %t6 %s
+// RUN: %t6 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+// Tests that the CFI mechanism crashes the program when making a non-virtual
+// call to an object of the wrong class, by casting a pointer to such an object
+// and attempting to make a call through it.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void v();
+};
+
+void A::v() {}
+
+struct B {
+  void f();
+  virtual void g();
+};
+
+void B::f() {}
+void B::g() {}
+
+int main() {
+  create_derivers<B>();
+
+  A *a = new A;
+  break_optimization(a);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-DIAG: runtime error: control flow integrity check for type 'B' failed during non-virtual call
+  // CFI-DIAG-NEXT: note: vtable is of type '{{(struct )?}}A'
+  ((B *)a)->f(); // UB here
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/overwrite.cpp b/compiler-rt/test/cfi/overwrite.cpp
new file mode 100644
index 0000000..90f995d
--- /dev/null
+++ b/compiler-rt/test/cfi/overwrite.cpp
@@ -0,0 +1,61 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -o %t5 %s
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// RUN: %clangxx_cfi_diag -o %t6 %s
+// RUN: %t6 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+// Tests that the CFI mechanism crashes the program when a virtual table is
+// replaced with a compatible table of function pointers that does not belong to
+// any class, by manually overwriting the virtual table of an object and
+// attempting to make a call through it.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f();
+};
+
+void A::f() {}
+
+void foo() {
+  fprintf(stderr, "foo\n");
+}
+
+void *fake_vtable[] = { 0, 0, (void *)&foo };
+
+int main() {
+  create_derivers<A>();
+
+  A *a = new A;
+  *((void **)a) = fake_vtable + 2; // UB here
+  break_optimization(a);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-NOT: foo
+  // NCFI: foo
+  // CFI-DIAG: runtime error: control flow integrity check for type 'A' failed during virtual call
+  // CFI-DIAG-NEXT: note: invalid vtable
+  a->f();
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/sibling.cpp b/compiler-rt/test/cfi/sibling.cpp
new file mode 100644
index 0000000..9f32302
--- /dev/null
+++ b/compiler-rt/test/cfi/sibling.cpp
@@ -0,0 +1,54 @@
+// XFAIL: *
+
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -o %t5 %s
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// Tests that the CFI enforcement distinguishes betwen non-overriding siblings.
+// XFAILed as not implemented yet.
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f();
+};
+
+void A::f() {}
+
+struct B : A {
+  virtual void f();
+};
+
+void B::f() {}
+
+struct C : A {
+};
+
+int main() {
+  create_derivers<B>();
+
+  B *b = new B;
+  break_optimization(b);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  ((C *)b)->f(); // UB here
+
+  // CFI-NOT: 2
+  // NCFI: 2
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/simple-fail.cpp b/compiler-rt/test/cfi/simple-fail.cpp
new file mode 100644
index 0000000..92b1322
--- /dev/null
+++ b/compiler-rt/test/cfi/simple-fail.cpp
@@ -0,0 +1,95 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -o %t5 %s
+// RUN: %expect_crash %t5 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -DB32 -o %t6 %s
+// RUN: %expect_crash %t6 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -DB64 -o %t7 %s
+// RUN: %expect_crash %t7 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O1 -DBM -o %t8 %s
+// RUN: %expect_crash %t8 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -o %t9 %s
+// RUN: %expect_crash %t9 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -DB32 -o %t10 %s
+// RUN: %expect_crash %t10 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -DB64 -o %t11 %s
+// RUN: %expect_crash %t11 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O2 -DBM -o %t12 %s
+// RUN: %expect_crash %t12 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -o %t13 %s
+// RUN: %expect_crash %t13 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -DB32 -o %t14 %s
+// RUN: %expect_crash %t14 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -DB64 -o %t15 %s
+// RUN: %expect_crash %t15 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -O3 -DBM -o %t16 %s
+// RUN: %expect_crash %t16 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi_diag -o %t17 %s
+// RUN: %t17 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+// RUN: %clangxx -o %t18 %s
+// RUN: %t18 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// Tests that the CFI mechanism crashes the program when making a virtual call
+// to an object of the wrong class but with a compatible vtable, by casting a
+// pointer to such an object and attempting to make a call through it.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f();
+};
+
+void A::f() {}
+
+struct B {
+  virtual void f();
+};
+
+void B::f() {}
+
+int main() {
+  create_derivers<B>();
+
+  A *a = new A;
+  break_optimization(a);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-DIAG: runtime error: control flow integrity check for type 'B' failed during cast to unrelated type
+  // CFI-DIAG-NEXT: note: vtable is of type '{{(struct )?}}A'
+  // CFI-DIAG: runtime error: control flow integrity check for type 'B' failed during virtual call
+  // CFI-DIAG-NEXT: note: vtable is of type '{{(struct )?}}A'
+  ((B *)a)->f(); // UB here
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/cfi/simple-pass.cpp b/compiler-rt/test/cfi/simple-pass.cpp
new file mode 100644
index 0000000..4d856eb
--- /dev/null
+++ b/compiler-rt/test/cfi/simple-pass.cpp
@@ -0,0 +1,121 @@
+// RUN: %clangxx_cfi -o %t %s
+// RUN: %t
+
+// Tests that the CFI mechanism does not crash the program when making various
+// kinds of valid calls involving classes with various different linkages and
+// types of inheritance, and both virtual and non-virtual member functions.
+
+#include "utils.h"
+
+struct A {
+  virtual void f();
+  void g();
+};
+
+void A::f() {}
+void A::g() {}
+
+struct A2 : A {
+  virtual void f();
+  void g();
+};
+
+void A2::f() {}
+void A2::g() {}
+
+struct B {
+  virtual void f() {}
+  void g() {}
+};
+
+struct B2 : B {
+  virtual void f() {}
+  void g() {}
+};
+
+namespace {
+
+struct C {
+  virtual void f();
+  void g();
+};
+
+void C::f() {}
+void C::g() {}
+
+struct C2 : C {
+  virtual void f();
+  void g();
+};
+
+void C2::f() {}
+void C2::g() {}
+
+struct D {
+  virtual void f() {}
+  void g() {}
+};
+
+struct D2 : D {
+  virtual void f() {}
+  void g() {}
+};
+
+}
+
+struct E {
+  virtual void f() {}
+  void g() {}
+};
+
+struct E2 : virtual E {
+  virtual void f() {}
+  void g() {}
+};
+
+int main() {
+  A *a = new A;
+  break_optimization(a);
+  a->f();
+  a->g();
+  a = new A2;
+  break_optimization(a);
+  a->f();
+  a->g();
+
+  B *b = new B;
+  break_optimization(b);
+  b->f();
+  b->g();
+  b = new B2;
+  break_optimization(b);
+  b->f();
+  b->g();
+
+  C *c = new C;
+  break_optimization(c);
+  c->f();
+  c->g();
+  c = new C2;
+  break_optimization(c);
+  c->f();
+  c->g();
+
+  D *d = new D;
+  break_optimization(d);
+  d->f();
+  d->g();
+  d = new D2;
+  break_optimization(d);
+  d->f();
+  d->g();
+
+  E *e = new E;
+  break_optimization(e);
+  e->f();
+  e->g();
+  e = new E2;
+  break_optimization(e);
+  e->f();
+  e->g();
+}
diff --git a/compiler-rt/test/cfi/utils.h b/compiler-rt/test/cfi/utils.h
new file mode 100644
index 0000000..430359d
--- /dev/null
+++ b/compiler-rt/test/cfi/utils.h
@@ -0,0 +1,67 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+inline void break_optimization(void *arg) {
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+}
+
+// Tests will instantiate this class to pad out bit sets to test out the
+// various ways we can represent the bit set (32-bit inline, 64-bit inline,
+// memory). Instantiating this class will trigger the instantiation of I
+// templates with I virtual tables for classes deriving from T, I-2 of which
+// will be of size sizeof(void*) * 5, 1 of which will be of size sizeof(void*)
+// * 3, and 1 of which will be of size sizeof(void*) * 9. (Under the MS ABI
+// each virtual table will be sizeof(void*) bytes smaller). Each category
+// of virtual tables is aligned to a different power of 2, precluding the
+// all-ones optimization. As a result, the bit vector for the base class will
+// need to contain at least I*2 entries to accommodate all the derived virtual
+// tables.
+template <typename T, unsigned I>
+struct Deriver : T {
+  Deriver() {
+    break_optimization(new Deriver<T, I-1>);
+  }
+  virtual void f() {}
+  virtual void g() {}
+  virtual void h() {}
+};
+
+template <typename T>
+struct Deriver<T, 0> : T {
+  virtual void f() {}
+  void g() {}
+};
+
+template <typename T>
+struct Deriver<T, 1> : T {
+  Deriver() {
+    break_optimization(new Deriver<T, 0>);
+  }
+  virtual void f() {}
+  virtual void g() {}
+  virtual void h() {}
+  virtual void i() {}
+  virtual void j() {}
+  virtual void k() {}
+  virtual void l() {}
+};
+
+// Instantiate enough classes to force CFI checks for type T to use bit
+// vectors of size 32 (if B32 defined), 64 (if B64 defined) or >64 (if BM
+// defined).
+template <typename T>
+void create_derivers() {
+#ifdef B32
+  break_optimization(new Deriver<T, 10>);
+#endif
+
+#ifdef B64
+  break_optimization(new Deriver<T, 25>);
+#endif
+
+#ifdef BM
+  break_optimization(new Deriver<T, 40>);
+#endif
+}
+
+#endif
diff --git a/compiler-rt/test/cfi/vdtor.cpp b/compiler-rt/test/cfi/vdtor.cpp
new file mode 100644
index 0000000..522d24c
--- /dev/null
+++ b/compiler-rt/test/cfi/vdtor.cpp
@@ -0,0 +1,56 @@
+// RUN: %clangxx_cfi -o %t1 %s
+// RUN: %expect_crash %t1 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t2 %s
+// RUN: %expect_crash %t2 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t3 %s
+// RUN: %expect_crash %t3 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t4 %s
+// RUN: %expect_crash %t4 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -o %t5 %s
+// RUN: %t5 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// RUN: %clangxx_cfi_diag -o %t6 %s
+// RUN: %t6 2>&1 | FileCheck --check-prefix=CFI-DIAG %s
+
+// Tests that the CFI enforcement also applies to virtual destructor calls made
+// via 'delete'.
+
+// REQUIRES: cxxabi
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual ~A();
+};
+
+A::~A() {}
+
+struct B {
+  virtual ~B();
+};
+
+B::~B() {}
+
+int main() {
+  create_derivers<B>();
+
+  A *a = new A;
+  break_optimization(a);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  // CFI-DIAG: runtime error: control flow integrity check for type 'B' failed during virtual call
+  // CFI-DIAG-NEXT: note: vtable is of type '{{(struct )?}}A'
+  delete (B *)a; // UB here
+
+  // CFI-NOT: {{^2$}}
+  // NCFI: {{^2$}}
+  fprintf(stderr, "2\n");
+}
diff --git a/compiler-rt/test/dfsan/CMakeLists.txt b/compiler-rt/test/dfsan/CMakeLists.txt
new file mode 100644
index 0000000..3fa1af2
--- /dev/null
+++ b/compiler-rt/test/dfsan/CMakeLists.txt
@@ -0,0 +1,15 @@
+set(DFSAN_LIT_TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
+set(DFSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND DFSAN_TEST_DEPS dfsan)
+endif()
+
+add_lit_testsuite(check-dfsan "Running the DataFlowSanitizer tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS ${DFSAN_TEST_DEPS})
+set_target_properties(check-dfsan PROPERTIES FOLDER "DFSan tests")
diff --git a/compiler-rt/test/dfsan/Inputs/flags_abilist.txt b/compiler-rt/test/dfsan/Inputs/flags_abilist.txt
new file mode 100644
index 0000000..94b1fa2
--- /dev/null
+++ b/compiler-rt/test/dfsan/Inputs/flags_abilist.txt
@@ -0,0 +1,10 @@
+fun:f=uninstrumented
+
+fun:main=uninstrumented
+fun:main=discard
+
+fun:dfsan_create_label=uninstrumented
+fun:dfsan_create_label=discard
+
+fun:dfsan_set_label=uninstrumented
+fun:dfsan_set_label=discard
diff --git a/compiler-rt/test/dfsan/basic.c b/compiler-rt/test/dfsan/basic.c
new file mode 100644
index 0000000..990fd11
--- /dev/null
+++ b/compiler-rt/test/dfsan/basic.c
@@ -0,0 +1,28 @@
+// RUN: %clang_dfsan %s -o %t && %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi %s -o %t && %run %t
+
+// Tests that labels are propagated through loads and stores.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+int main(void) {
+  int i = 1;
+  dfsan_label i_label = dfsan_create_label("i", 0);
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  dfsan_label new_label = dfsan_get_label(i);
+  assert(i_label == new_label);
+
+  dfsan_label read_label = dfsan_read_label(&i, sizeof(i));
+  assert(i_label == read_label);
+
+  dfsan_label j_label = dfsan_create_label("j", 0);
+  dfsan_add_label(j_label, &i, sizeof(i));
+
+  read_label = dfsan_read_label(&i, sizeof(i));
+  assert(dfsan_has_label(read_label, i_label));
+  assert(dfsan_has_label(read_label, j_label));
+
+  return 0;
+}
diff --git a/compiler-rt/test/dfsan/custom.cc b/compiler-rt/test/dfsan/custom.cc
new file mode 100644
index 0000000..057b060
--- /dev/null
+++ b/compiler-rt/test/dfsan/custom.cc
@@ -0,0 +1,963 @@
+// RUN: %clang_dfsan %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
+// RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t
+// RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -mllvm -dfsan-args-abi %s -o %t && %run %t
+
+// Tests custom implementations of various glibc functions.
+
+#include <sanitizer/dfsan_interface.h>
+
+#include <arpa/inet.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <link.h>
+#include <poll.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+dfsan_label i_label = 0;
+dfsan_label j_label = 0;
+dfsan_label k_label = 0;
+dfsan_label i_j_label = 0;
+
+#define ASSERT_ZERO_LABEL(data) \
+  assert(0 == dfsan_get_label((long) (data)))
+
+#define ASSERT_READ_ZERO_LABEL(ptr, size) \
+  assert(0 == dfsan_read_label(ptr, size))
+
+#define ASSERT_LABEL(data, label) \
+  assert(label == dfsan_get_label((long) (data)))
+
+#define ASSERT_READ_LABEL(ptr, size, label) \
+  assert(label == dfsan_read_label(ptr, size))
+
+void test_stat() {
+  int i = 1;
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  struct stat s;
+  s.st_dev = i;
+  assert(0 == stat("/", &s));
+  ASSERT_ZERO_LABEL(s.st_dev);
+
+  s.st_dev = i;
+  assert(-1 == stat("/nonexistent", &s));
+  ASSERT_LABEL(s.st_dev, i_label);
+}
+
+void test_fstat() {
+  int i = 1;
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  struct stat s;
+  int fd = open("/dev/zero", O_RDONLY);
+  s.st_dev = i;
+  int rv = fstat(fd, &s);
+  assert(0 == rv);
+  ASSERT_ZERO_LABEL(s.st_dev);
+}
+
+void test_memcmp() {
+  char str1[] = "str1", str2[] = "str2";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str2[3], 1);
+
+  int rv = memcmp(str1, str2, sizeof(str1));
+  assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, i_j_label);
+#endif
+}
+
+void test_memcpy() {
+  char str1[] = "str1";
+  char str2[sizeof(str1)];
+  dfsan_set_label(i_label, &str1[3], 1);
+
+  ASSERT_ZERO_LABEL(memcpy(str2, str1, sizeof(str1)));
+  assert(0 == memcmp(str2, str1, sizeof(str1)));
+  ASSERT_ZERO_LABEL(str2[0]);
+  ASSERT_LABEL(str2[3], i_label);
+}
+
+void test_memset() {
+  char buf[8];
+  int j = 'a';
+  dfsan_set_label(j_label, &j, sizeof(j));
+
+  ASSERT_ZERO_LABEL(memset(&buf, j, sizeof(buf)));
+  for (int i = 0; i < 8; ++i) {
+    ASSERT_LABEL(buf[i], j_label);
+    assert(buf[i] == 'a');
+  }
+}
+
+void test_strcmp() {
+  char str1[] = "str1", str2[] = "str2";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str2[3], 1);
+
+  int rv = strcmp(str1, str2);
+  assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, i_j_label);
+#endif
+}
+
+void test_strlen() {
+  char str1[] = "str1";
+  dfsan_set_label(i_label, &str1[3], 1);
+
+  int rv = strlen(str1);
+  assert(rv == 4);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, i_label);
+#endif
+}
+
+void test_strdup() {
+  char str1[] = "str1";
+  dfsan_set_label(i_label, &str1[3], 1);
+
+  char *strd = strdup(str1);
+  ASSERT_ZERO_LABEL(strd[0]);
+  ASSERT_LABEL(strd[3], i_label);
+  free(strd);
+}
+
+void test_strncpy() {
+  char str1[] = "str1";
+  char str2[sizeof(str1)];
+  dfsan_set_label(i_label, &str1[3], 1);
+
+  char *strd = strncpy(str2, str1, 5);
+  assert(strd == str2);
+  assert(strcmp(str1, str2) == 0);
+  ASSERT_ZERO_LABEL(strd);
+  ASSERT_ZERO_LABEL(strd[0]);
+  ASSERT_ZERO_LABEL(strd[1]);
+  ASSERT_ZERO_LABEL(strd[2]);
+  ASSERT_LABEL(strd[3], i_label);
+
+  strd = strncpy(str2, str1, 3);
+  assert(strd == str2);
+  assert(strncmp(str1, str2, 3) == 0);
+  ASSERT_ZERO_LABEL(strd);
+  ASSERT_ZERO_LABEL(strd[0]);
+  ASSERT_ZERO_LABEL(strd[1]);
+  ASSERT_ZERO_LABEL(strd[2]);
+}
+
+void test_strncmp() {
+  char str1[] = "str1", str2[] = "str2";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str2[3], 1);
+
+  int rv = strncmp(str1, str2, sizeof(str1));
+  assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+
+  rv = strncmp(str1, str2, 3);
+  assert(rv == 0);
+  ASSERT_ZERO_LABEL(rv);
+}
+
+void test_strcasecmp() {
+  char str1[] = "str1", str2[] = "str2", str3[] = "Str1";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str2[3], 1);
+  dfsan_set_label(j_label, &str3[2], 1);
+
+  int rv = strcasecmp(str1, str2);
+  assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+
+  rv = strcasecmp(str1, str3);
+  assert(rv == 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+}
+
+void test_strncasecmp() {
+  char str1[] = "Str1", str2[] = "str2";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str2[3], 1);
+
+  int rv = strncasecmp(str1, str2, sizeof(str1));
+  assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+
+  rv = strncasecmp(str1, str2, 3);
+  assert(rv == 0);
+  ASSERT_ZERO_LABEL(rv);
+}
+
+void test_strchr() {
+  char str1[] = "str1";
+  dfsan_set_label(i_label, &str1[3], 1);
+
+  char *crv = strchr(str1, 'r');
+  assert(crv == &str1[2]);
+  ASSERT_ZERO_LABEL(crv);
+
+  crv = strchr(str1, '1');
+  assert(crv == &str1[3]);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(crv);
+#else
+  ASSERT_LABEL(crv, i_label);
+#endif
+
+  crv = strchr(str1, 'x');
+  assert(!crv);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(crv);
+#else
+  ASSERT_LABEL(crv, i_label);
+#endif
+}
+
+void test_calloc() {
+  // With any luck this sequence of calls will cause calloc to return the same
+  // pointer both times.  This is probably the best we can do to test this
+  // function.
+  char *crv = (char *) calloc(4096, 1);
+  ASSERT_ZERO_LABEL(crv[0]);
+  dfsan_set_label(i_label, crv, 100);
+  free(crv);
+
+  crv = (char *) calloc(4096, 1);
+  ASSERT_ZERO_LABEL(crv[0]);
+  free(crv);
+}
+
+void test_read() {
+  char buf[16];
+  dfsan_set_label(i_label, buf, 1);
+  dfsan_set_label(j_label, buf + 15, 1);
+
+  ASSERT_LABEL(buf[0], i_label);
+  ASSERT_LABEL(buf[15], j_label);
+
+  int fd = open("/dev/zero", O_RDONLY);
+  int rv = read(fd, buf, sizeof(buf));
+  assert(rv == sizeof(buf));
+  ASSERT_ZERO_LABEL(rv);
+  ASSERT_ZERO_LABEL(buf[0]);
+  ASSERT_ZERO_LABEL(buf[15]);
+  close(fd);
+}
+
+void test_pread() {
+  char buf[16];
+  dfsan_set_label(i_label, buf, 1);
+  dfsan_set_label(j_label, buf + 15, 1);
+
+  ASSERT_LABEL(buf[0], i_label);
+  ASSERT_LABEL(buf[15], j_label);
+
+  int fd = open("/bin/sh", O_RDONLY);
+  int rv = pread(fd, buf, sizeof(buf), 0);
+  assert(rv == sizeof(buf));
+  ASSERT_ZERO_LABEL(rv);
+  ASSERT_ZERO_LABEL(buf[0]);
+  ASSERT_ZERO_LABEL(buf[15]);
+  close(fd);
+}
+
+void test_dlopen() {
+  void *map = dlopen(NULL, RTLD_NOW);
+  assert(map);
+  ASSERT_ZERO_LABEL(map);
+  dlclose(map);
+  map = dlopen("/nonexistent", RTLD_NOW);
+  assert(!map);
+  ASSERT_ZERO_LABEL(map);
+}
+
+void test_clock_gettime() {
+  struct timespec tp;
+  dfsan_set_label(j_label, ((char *)&tp) + 3, 1);
+  int t = clock_gettime(CLOCK_REALTIME, &tp);
+  assert(t == 0);
+  ASSERT_ZERO_LABEL(t);
+  ASSERT_ZERO_LABEL(((char *)&tp)[3]);
+}
+
+void test_ctime_r() {
+  char *buf = (char*) malloc(64);
+  time_t t = 0;
+
+  char *ret = ctime_r(&t, buf);
+  ASSERT_ZERO_LABEL(ret);
+  assert(buf == ret);
+  ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1);
+
+  dfsan_set_label(i_label, &t, sizeof(t));
+  ret = ctime_r(&t, buf);
+  ASSERT_ZERO_LABEL(ret);
+  ASSERT_READ_LABEL(buf, strlen(buf) + 1, i_label);
+
+  t = 0;
+  dfsan_set_label(j_label, &buf, sizeof(&buf));
+  ret = ctime_r(&t, buf);
+  ASSERT_LABEL(ret, j_label);
+  ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1);
+}
+
+static int write_callback_count = 0;
+static int last_fd;
+static const unsigned char *last_buf;
+static size_t last_count;
+
+void write_callback(int fd, const void *buf, size_t count) {
+  write_callback_count++;
+
+  last_fd = fd;
+  last_buf = (const unsigned char*) buf;
+  last_count = count;
+}
+
+void test_dfsan_set_write_callback() {
+  char buf[] = "Sample chars";
+  int buf_len = strlen(buf);
+
+  int fd = open("/dev/null", O_WRONLY);
+
+  dfsan_set_write_callback(write_callback);
+
+  write_callback_count = 0;
+
+  // Callback should be invoked on every call to write().
+  int res = write(fd, buf, buf_len);
+  assert(write_callback_count == 1);
+  ASSERT_READ_ZERO_LABEL(&res, sizeof(res));
+  ASSERT_READ_ZERO_LABEL(&last_fd, sizeof(last_fd));
+  ASSERT_READ_ZERO_LABEL(last_buf, sizeof(last_buf));
+  ASSERT_READ_ZERO_LABEL(&last_count, sizeof(last_count));
+
+  // Add a label to write() arguments.  Check that the labels are readable from
+  // the values passed to the callback.
+  dfsan_set_label(i_label, &fd, sizeof(fd));
+  dfsan_set_label(j_label, &(buf[3]), 1);
+  dfsan_set_label(k_label, &buf_len, sizeof(buf_len));
+
+  res = write(fd, buf, buf_len);
+  assert(write_callback_count == 2);
+  ASSERT_READ_ZERO_LABEL(&res, sizeof(res));
+  ASSERT_READ_LABEL(&last_fd, sizeof(last_fd), i_label);
+  ASSERT_READ_LABEL(&last_buf[3], sizeof(last_buf[3]), j_label);
+  ASSERT_READ_LABEL(last_buf, sizeof(last_buf), j_label);
+  ASSERT_READ_LABEL(&last_count, sizeof(last_count), k_label);
+
+  dfsan_set_write_callback(NULL);
+}
+
+void test_fgets() {
+  char *buf = (char*) malloc(128);
+  FILE *f = fopen("/etc/passwd", "r");
+  dfsan_set_label(j_label, buf, 1);
+  char *ret = fgets(buf, sizeof(buf), f);
+  assert(ret == buf);
+  ASSERT_ZERO_LABEL(ret);
+  ASSERT_READ_ZERO_LABEL(buf, 128);
+  dfsan_set_label(j_label, &buf, sizeof(&buf));
+  ret = fgets(buf, sizeof(buf), f);
+  ASSERT_LABEL(ret, j_label);
+  fclose(f);
+}
+
+void test_getcwd() {
+  char buf[1024];
+  char *ptr = buf;
+  dfsan_set_label(i_label, buf + 2, 2);
+  char* ret = getcwd(buf, sizeof(buf));
+  assert(ret == buf);
+  assert(ret[0] == '/');
+  ASSERT_READ_ZERO_LABEL(buf + 2, 2);
+  dfsan_set_label(i_label, &ptr, sizeof(ptr));
+  ret = getcwd(ptr, sizeof(buf));
+  ASSERT_LABEL(ret, i_label);
+}
+
+void test_get_current_dir_name() {
+  char* ret = get_current_dir_name();
+  assert(ret);
+  assert(ret[0] == '/');
+  ASSERT_READ_ZERO_LABEL(ret, strlen(ret) + 1);
+}
+
+void test_gethostname() {
+  char buf[1024];
+  dfsan_set_label(i_label, buf + 2, 2);
+  assert(gethostname(buf, sizeof(buf)) == 0);
+  ASSERT_READ_ZERO_LABEL(buf + 2, 2);
+}
+
+void test_getrlimit() {
+  struct rlimit rlim;
+  dfsan_set_label(i_label, &rlim, sizeof(rlim));
+  assert(getrlimit(RLIMIT_CPU, &rlim) == 0);
+  ASSERT_READ_ZERO_LABEL(&rlim, sizeof(rlim));
+}
+
+void test_getrusage() {
+  struct rusage usage;
+  dfsan_set_label(i_label, &usage, sizeof(usage));
+  assert(getrusage(RUSAGE_SELF, &usage) == 0);
+  ASSERT_READ_ZERO_LABEL(&usage, sizeof(usage));
+}
+
+void test_strcpy() {
+  char src[] = "hello world";
+  char dst[sizeof(src) + 2];
+  dfsan_set_label(0, src, sizeof(src));
+  dfsan_set_label(0, dst, sizeof(dst));
+  dfsan_set_label(i_label, src + 2, 1);
+  dfsan_set_label(j_label, src + 3, 1);
+  dfsan_set_label(j_label, dst + 4, 1);
+  dfsan_set_label(i_label, dst + 12, 1);
+  char *ret = strcpy(dst, src);
+  assert(ret == dst);
+  assert(strcmp(src, dst) == 0);
+  for (int i = 0; i < strlen(src) + 1; ++i) {
+    assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i]));
+  }
+  // Note: if strlen(src) + 1 were used instead to compute the first untouched
+  // byte of dest, the label would be I|J. This is because strlen() might
+  // return a non-zero label, and because by default pointer labels are not
+  // ignored on loads.
+  ASSERT_LABEL(dst[12], i_label);
+}
+
+void test_strtol() {
+  char buf[] = "1234578910";
+  char *endptr = NULL;
+  dfsan_set_label(i_label, buf + 1, 1);
+  dfsan_set_label(j_label, buf + 10, 1);
+  long int ret = strtol(buf, &endptr, 10);
+  assert(ret == 1234578910);
+  assert(endptr == buf + 10);
+  ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtoll() {
+  char buf[] = "1234578910 ";
+  char *endptr = NULL;
+  dfsan_set_label(i_label, buf + 1, 1);
+  dfsan_set_label(j_label, buf + 2, 1);
+  long long int ret = strtoll(buf, &endptr, 10);
+  assert(ret == 1234578910);
+  assert(endptr == buf + 10);
+  ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtoul() {
+  char buf[] = "0xffffffffffffaa";
+  char *endptr = NULL;
+  dfsan_set_label(i_label, buf + 1, 1);
+  dfsan_set_label(j_label, buf + 2, 1);
+  long unsigned int ret = strtol(buf, &endptr, 16);
+  assert(ret == 72057594037927850);
+  assert(endptr == buf + 16);
+  ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtoull() {
+  char buf[] = "0xffffffffffffffaa";
+  char *endptr = NULL;
+  dfsan_set_label(i_label, buf + 1, 1);
+  dfsan_set_label(j_label, buf + 2, 1);
+  long long unsigned int ret = strtoull(buf, &endptr, 16);
+  assert(ret == 0xffffffffffffffaa);
+  assert(endptr == buf + 18);
+  ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtod() {
+  char buf[] = "12345.76 foo";
+  char *endptr = NULL;
+  dfsan_set_label(i_label, buf + 1, 1);
+  dfsan_set_label(j_label, buf + 6, 1);
+  double ret = strtod(buf, &endptr);
+  assert(ret == 12345.76);
+  assert(endptr == buf + 8);
+  ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_time() {
+  time_t t = 0;
+  dfsan_set_label(i_label, &t, 1);
+  time_t ret = time(&t);
+  assert(ret == t);
+  assert(ret > 0);
+  ASSERT_ZERO_LABEL(t);
+}
+
+void test_inet_pton() {
+  char addr4[] = "127.0.0.1";
+  dfsan_set_label(i_label, addr4 + 3, 1);
+  struct in_addr in4;
+  int ret4 = inet_pton(AF_INET, addr4, &in4);
+  assert(ret4 == 1);
+  ASSERT_READ_LABEL(&in4, sizeof(in4), i_label);
+  assert(in4.s_addr == 0x0100007f);
+
+  char addr6[] = "::1";
+  dfsan_set_label(j_label, addr6 + 3, 1);
+  struct in6_addr in6;
+  int ret6 = inet_pton(AF_INET6, addr6, &in6);
+  assert(ret6 == 1);
+  ASSERT_READ_LABEL(((char *) &in6) + sizeof(in6) - 1, 1, j_label);
+}
+
+void test_localtime_r() {
+  time_t t0 = 1384800998;
+  struct tm t1;
+  dfsan_set_label(i_label, &t0, sizeof(t0));
+  struct tm* ret = localtime_r(&t0, &t1);
+  assert(ret == &t1);
+  assert(t1.tm_min == 56);
+  ASSERT_LABEL(t1.tm_mon, i_label);
+}
+
+void test_getpwuid_r() {
+  struct passwd pwd;
+  char buf[1024];
+  struct passwd *result;
+
+  dfsan_set_label(i_label, &pwd, 4);
+  int ret = getpwuid_r(0, &pwd, buf, sizeof(buf), &result);
+  assert(ret == 0);
+  assert(strcmp(pwd.pw_name, "root") == 0);
+  assert(result == &pwd);
+  ASSERT_READ_ZERO_LABEL(&pwd, 4);
+}
+
+void test_poll() {
+  struct pollfd fd;
+  fd.fd = 0;
+  fd.events = POLLIN;
+  dfsan_set_label(i_label, &fd.revents, sizeof(fd.revents));
+  int ret = poll(&fd, 1, 1);
+  ASSERT_ZERO_LABEL(fd.revents);
+  assert(ret >= 0);
+}
+
+void test_select() {
+  struct timeval t;
+  fd_set fds;
+  t.tv_sec = 2;
+  FD_SET(0, &fds);
+  dfsan_set_label(i_label, &fds, sizeof(fds));
+  dfsan_set_label(j_label, &t, sizeof(t));
+  int ret = select(1, &fds, NULL, NULL, &t);
+  assert(ret >= 0);
+  ASSERT_ZERO_LABEL(t.tv_sec);
+  ASSERT_READ_ZERO_LABEL(&fds, sizeof(fds));
+}
+
+void test_sched_getaffinity() {
+  cpu_set_t mask;
+  dfsan_set_label(j_label, &mask, 1);
+  int ret = sched_getaffinity(0, sizeof(mask), &mask);
+  assert(ret == 0);
+  ASSERT_READ_ZERO_LABEL(&mask, sizeof(mask));
+}
+
+void test_sigemptyset() {
+  sigset_t set;
+  dfsan_set_label(j_label, &set, 1);
+  int ret = sigemptyset(&set);
+  assert(ret == 0);
+  ASSERT_READ_ZERO_LABEL(&set, sizeof(set));
+}
+
+void test_sigaction() {
+  struct sigaction oldact;
+  dfsan_set_label(j_label, &oldact, 1);
+  int ret = sigaction(SIGUSR1, NULL, &oldact);
+  assert(ret == 0);
+  ASSERT_READ_ZERO_LABEL(&oldact, sizeof(oldact));
+}
+
+void test_gettimeofday() {
+  struct timeval tv;
+  struct timezone tz;
+  dfsan_set_label(i_label, &tv, sizeof(tv));
+  dfsan_set_label(j_label, &tz, sizeof(tz));
+  int ret = gettimeofday(&tv, &tz);
+  assert(ret == 0);
+  ASSERT_READ_ZERO_LABEL(&tv, sizeof(tv));
+  ASSERT_READ_ZERO_LABEL(&tz, sizeof(tz));
+}
+
+void *pthread_create_test_cb(void *p) {
+  assert(p == (void *)1);
+  ASSERT_ZERO_LABEL(p);
+  return (void *)2;
+}
+
+void test_pthread_create() {
+  pthread_t pt;
+  pthread_create(&pt, 0, pthread_create_test_cb, (void *)1);
+  void *cbrv;
+  pthread_join(pt, &cbrv);
+  assert(cbrv == (void *)2);
+}
+
+int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
+                            void *data) {
+  assert(data == (void *)3);
+  ASSERT_ZERO_LABEL(info);
+  ASSERT_ZERO_LABEL(size);
+  ASSERT_ZERO_LABEL(data);
+  return 0;
+}
+
+void test_dl_iterate_phdr() {
+  dl_iterate_phdr(dl_iterate_phdr_test_cb, (void *)3);
+}
+
+void test_strrchr() {
+  char str1[] = "str1str1";
+  dfsan_set_label(i_label, &str1[7], 1);
+
+  char *rv = strrchr(str1, 'r');
+  assert(rv == &str1[6]);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, i_label);
+#endif
+}
+
+void test_strstr() {
+  char str1[] = "str1str1";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str1[5], 1);
+
+  char *rv = strstr(str1, "1s");
+  assert(rv == &str1[3]);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, i_label);
+#endif
+
+  rv = strstr(str1, "2s");
+  assert(rv == NULL);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(rv);
+#else
+  ASSERT_LABEL(rv, i_j_label);
+#endif
+}
+
+void test_memchr() {
+  char str1[] = "str1";
+  dfsan_set_label(i_label, &str1[3], 1);
+  dfsan_set_label(j_label, &str1[4], 1);
+
+  char *crv = (char *) memchr(str1, 'r', sizeof(str1));
+  assert(crv == &str1[2]);
+  ASSERT_ZERO_LABEL(crv);
+
+  crv = (char *) memchr(str1, '1', sizeof(str1));
+  assert(crv == &str1[3]);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(crv);
+#else
+  ASSERT_LABEL(crv, i_label);
+#endif
+
+  crv = (char *) memchr(str1, 'x', sizeof(str1));
+  assert(!crv);
+#ifdef STRICT_DATA_DEPENDENCIES
+  ASSERT_ZERO_LABEL(crv);
+#else
+  ASSERT_LABEL(crv, i_j_label);
+#endif
+}
+
+void alarm_handler(int unused) {
+  ;
+}
+
+void test_nanosleep() {
+  struct timespec req, rem;
+  req.tv_sec = 1;
+  req.tv_nsec = 0;
+  dfsan_set_label(i_label, &rem, sizeof(rem));
+
+  // non interrupted
+  int rv = nanosleep(&req, &rem);
+  assert(rv == 0);
+  ASSERT_ZERO_LABEL(rv);
+  ASSERT_READ_LABEL(&rem, 1, i_label);
+
+  // interrupted by an alarm
+  signal(SIGALRM, alarm_handler);
+  req.tv_sec = 3;
+  alarm(1);
+  rv = nanosleep(&req, &rem);
+  assert(rv == -1);
+  ASSERT_ZERO_LABEL(rv);
+  ASSERT_READ_ZERO_LABEL(&rem, sizeof(rem));
+}
+
+void test_socketpair() {
+  int fd[2];
+
+  dfsan_set_label(i_label, fd, sizeof(fd));
+  int rv = socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
+  assert(rv == 0);
+  ASSERT_ZERO_LABEL(rv);
+  ASSERT_READ_ZERO_LABEL(fd, sizeof(fd));
+}
+
+void test_write() {
+  int fd = open("/dev/null", O_WRONLY);
+
+  char buf[] = "a string";
+  int len = strlen(buf);
+
+  // The result of a write always unlabeled.
+  int res = write(fd, buf, len);
+  assert(res > 0);
+  ASSERT_ZERO_LABEL(res);
+
+  // Label all arguments to write().
+  dfsan_set_label(i_label, &(buf[3]), 1);
+  dfsan_set_label(j_label, &fd, sizeof(fd));
+  dfsan_set_label(i_label, &len, sizeof(len));
+
+  // The value returned by write() should have no label.
+  res = write(fd, buf, len);
+  ASSERT_ZERO_LABEL(res);
+
+  close(fd);
+}
+
+template <class T>
+void test_sprintf_chunk(const char* expected, const char* format, T arg) {
+  char buf[512];
+  memset(buf, 'a', sizeof(buf));
+
+  char padded_expected[512];
+  strcpy(padded_expected, "foo ");
+  strcat(padded_expected, expected);
+  strcat(padded_expected, " bar");
+
+  char padded_format[512];
+  strcpy(padded_format, "foo ");
+  strcat(padded_format, format);
+  strcat(padded_format, " bar");
+
+  // Non labelled arg.
+  assert(sprintf(buf, padded_format,  arg) == strlen(padded_expected));
+  assert(strcmp(buf, padded_expected) == 0);
+  ASSERT_READ_LABEL(buf, strlen(padded_expected), 0);
+  memset(buf, 'a', sizeof(buf));
+
+  // Labelled arg.
+  dfsan_set_label(i_label, &arg, sizeof(arg));
+  assert(sprintf(buf, padded_format,  arg) == strlen(padded_expected));
+  assert(strcmp(buf, padded_expected) == 0);
+  ASSERT_READ_LABEL(buf, 4, 0);
+  ASSERT_READ_LABEL(buf + 4, strlen(padded_expected) - 8, i_label);
+  ASSERT_READ_LABEL(buf + (strlen(padded_expected) - 4), 4, 0);
+}
+
+void test_sprintf() {
+  char buf[2048];
+  memset(buf, 'a', sizeof(buf));
+
+  // Test formatting (no conversion specifier).
+  assert(sprintf(buf, "Hello world!") == 12);
+  assert(strcmp(buf, "Hello world!") == 0);
+  ASSERT_READ_LABEL(buf, sizeof(buf), 0);
+
+  // Test for extra arguments.
+  assert(sprintf(buf, "Hello world!", 42, "hello") == 12);
+  assert(strcmp(buf, "Hello world!") == 0);
+  ASSERT_READ_LABEL(buf, sizeof(buf), 0);
+
+  // Test formatting & label propagation (multiple conversion specifiers): %s,
+  // %d, %n, %f, and %%.
+  const char* s = "world";
+  int m = 8;
+  int d = 27;
+  dfsan_set_label(k_label, (void *) (s + 1), 2);
+  dfsan_set_label(i_label, &m, sizeof(m));
+  dfsan_set_label(j_label, &d, sizeof(d));
+  int n;
+  int r = sprintf(buf, "hello %s, %-d/%d/%d %f %% %n%d", s, 2014, m, d,
+                  12345.6781234, &n, 1000);
+  assert(r == 42);
+  assert(strcmp(buf, "hello world, 2014/8/27 12345.678123 % 1000") == 0);
+  ASSERT_READ_LABEL(buf, 7, 0);
+  ASSERT_READ_LABEL(buf + 7, 2, k_label);
+  ASSERT_READ_LABEL(buf + 9, 9, 0);
+  ASSERT_READ_LABEL(buf + 18, 1, i_label);
+  ASSERT_READ_LABEL(buf + 19, 1, 0);
+  ASSERT_READ_LABEL(buf + 20, 2, j_label);
+  ASSERT_READ_LABEL(buf + 22, 15, 0);
+  ASSERT_LABEL(r, 0);
+  assert(n == 38);
+
+  // Test formatting & label propagation (single conversion specifier, with
+  // additional length and precision modifiers).
+  test_sprintf_chunk("-559038737", "%d", 0xdeadbeef);
+  test_sprintf_chunk("3735928559", "%u", 0xdeadbeef);
+  test_sprintf_chunk("12345", "%i", 12345);
+  test_sprintf_chunk("751", "%o", 0751);
+  test_sprintf_chunk("babe", "%x", 0xbabe);
+  test_sprintf_chunk("0000BABE", "%.8X", 0xbabe);
+  test_sprintf_chunk("-17", "%hhd", 0xdeadbeef);
+  test_sprintf_chunk("-16657", "%hd", 0xdeadbeef);
+  test_sprintf_chunk("deadbeefdeadbeef", "%lx", 0xdeadbeefdeadbeef);
+  test_sprintf_chunk("0xdeadbeefdeadbeef", "%p",
+                 (void *)  0xdeadbeefdeadbeef);
+  test_sprintf_chunk("18446744073709551615", "%ju", (intmax_t) -1);
+  test_sprintf_chunk("18446744073709551615", "%zu", (size_t) -1);
+  test_sprintf_chunk("18446744073709551615", "%tu", (size_t) -1);
+
+  test_sprintf_chunk("0x1.f9acffa7eb6bfp-4", "%a", 0.123456);
+  test_sprintf_chunk("0X1.F9ACFFA7EB6BFP-4", "%A", 0.123456);
+  test_sprintf_chunk("0.12346", "%.5f", 0.123456);
+  test_sprintf_chunk("0.123456", "%g", 0.123456);
+  test_sprintf_chunk("1.234560e-01", "%e", 0.123456);
+  test_sprintf_chunk("1.234560E-01", "%E", 0.123456);
+  test_sprintf_chunk("0.1234567891234560", "%.16Lf",
+                     (long double) 0.123456789123456);
+
+  test_sprintf_chunk("z", "%c", 'z');
+
+  // %n, %s, %d, %f, and %% already tested
+
+  // Test formatting with width passed as an argument.
+  r = sprintf(buf, "hi %*d my %*s friend %.*f", 3, 1, 6, "dear", 4, 3.14159265359);
+  assert(r == 30);
+  assert(strcmp(buf, "hi   1 my   dear friend 3.1416") == 0);
+}
+
+void test_snprintf() {
+  char buf[2048];
+  memset(buf, 'a', sizeof(buf));
+  dfsan_set_label(0, buf, sizeof(buf));
+  const char* s = "world";
+  int y = 2014;
+  int m = 8;
+  int d = 27;
+  dfsan_set_label(k_label, (void *) (s + 1), 2);
+  dfsan_set_label(i_label, &y, sizeof(y));
+  dfsan_set_label(j_label, &m, sizeof(m));
+  int r = snprintf(buf, 19, "hello %s, %-d/%d/%d %f", s, y, m, d,
+                   12345.6781234);
+  // The return value is the number of bytes that would have been written to
+  // the final string if enough space had been available.
+  assert(r == 35);
+  assert(memcmp(buf, "hello world, 2014/", 19) == 0);
+  ASSERT_READ_LABEL(buf, 7, 0);
+  ASSERT_READ_LABEL(buf + 7, 2, k_label);
+  ASSERT_READ_LABEL(buf + 9, 4, 0);
+  ASSERT_READ_LABEL(buf + 13, 4, i_label);
+  ASSERT_READ_LABEL(buf + 17, 2, 0);
+  ASSERT_LABEL(r, 0);
+}
+
+int main(void) {
+  i_label = dfsan_create_label("i", 0);
+  j_label = dfsan_create_label("j", 0);
+  k_label = dfsan_create_label("k", 0);
+  i_j_label = dfsan_union(i_label, j_label);
+
+  test_calloc();
+  test_clock_gettime();
+  test_ctime_r();
+  test_dfsan_set_write_callback();
+  test_dl_iterate_phdr();
+  test_dlopen();
+  test_fgets();
+  test_fstat();
+  test_get_current_dir_name();
+  test_getcwd();
+  test_gethostname();
+  test_getpwuid_r();
+  test_getrlimit();
+  test_getrusage();
+  test_gettimeofday();
+  test_inet_pton();
+  test_localtime_r();
+  test_memchr();
+  test_memcmp();
+  test_memcpy();
+  test_memset();
+  test_nanosleep();
+  test_poll();
+  test_pread();
+  test_pthread_create();
+  test_read();
+  test_sched_getaffinity();
+  test_select();
+  test_sigaction();
+  test_sigemptyset();
+  test_snprintf();
+  test_socketpair();
+  test_sprintf();
+  test_stat();
+  test_strcasecmp();
+  test_strchr();
+  test_strcmp();
+  test_strcpy();
+  test_strdup();
+  test_strlen();
+  test_strncasecmp();
+  test_strncmp();
+  test_strncpy();
+  test_strrchr();
+  test_strstr();
+  test_strtod();
+  test_strtol();
+  test_strtoll();
+  test_strtoul();
+  test_strtoull();
+  test_time();
+  test_write();
+}
diff --git a/compiler-rt/test/dfsan/dump_labels.c b/compiler-rt/test/dfsan/dump_labels.c
new file mode 100644
index 0000000..3bbc1e2
--- /dev/null
+++ b/compiler-rt/test/dfsan/dump_labels.c
@@ -0,0 +1,69 @@
+// RUN: %clang_dfsan %s -o %t
+// RUN: DFSAN_OPTIONS=dump_labels_at_exit=/dev/stdout %run %t 2>&1 | FileCheck %s
+// RUN: DFSAN_OPTIONS=dump_labels_at_exit=/dev/stdout not %run %t c 2>&1 | FileCheck %s --check-prefix=CHECK-OOL
+// RUN: DFSAN_OPTIONS=dump_labels_at_exit=/dev/stdout not %run %t u 2>&1 | FileCheck %s --check-prefix=CHECK-OOL
+
+// Tests that labels are properly dumped at program termination.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+#include <stdio.h>
+
+int main(int argc, char** argv) {
+  int i = 1;
+  dfsan_label i_label = dfsan_create_label("i", 0);
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  int j = 2;
+  dfsan_label j_label = dfsan_create_label("j", 0);
+  dfsan_set_label(j_label, &j, sizeof(j));
+
+  int k = 3;
+  dfsan_label k_label = dfsan_create_label("k", 0);
+  dfsan_set_label(k_label, &k, sizeof(k));
+
+  dfsan_label ij_label = dfsan_get_label(i + j);
+  dfsan_label ijk_label = dfsan_get_label(i + j + k);
+
+  fprintf(stderr, "i %d j %d k %d ij %d ijk %d\n", i_label, j_label, k_label,
+          ij_label, ijk_label);
+
+  // CHECK: 1 0 0 i
+  // CHECK: 2 0 0 j
+  // CHECK: 3 0 0 k
+  // CHECK: 4 1 2
+  // CHECK: 5 3 4
+
+  if (argc > 1) {
+    // Exhaust the labels.
+    unsigned long num_labels = 1 << (sizeof(dfsan_label) * 8);
+    for (unsigned long i =  ijk_label + 1; i < num_labels - 2; ++i) {
+      dfsan_label l = dfsan_create_label("l", 0);
+      assert(l == i);
+    }
+
+    // Consume the last available label.
+    dfsan_label l = dfsan_union(5, 6);
+    assert(l == num_labels - 2);
+
+    // Try to allocate another label (either explicitly or by unioning two
+    // existing labels), but expect a crash.
+    if (argv[1][0] == 'c') {
+      l = dfsan_create_label("l", 0);
+    } else {
+      l = dfsan_union(6, 7);
+    }
+
+    // CHECK-OOL: FATAL: DataFlowSanitizer: out of labels
+    // CHECK-OOL: 1 0 0 i
+    // CHECK-OOL: 2 0 0 j
+    // CHECK-OOL: 3 0 0 k
+    // CHECK-OOL: 4 1 2
+    // CHECK-OOL: 5 3 4
+    // CHECK-OOL: 6 0 0
+    // CHECK-OOL: 65534 5 6
+    // CHECK-OOL: 65535 0 0 <init label>
+  }
+
+  return 0;
+}
diff --git a/compiler-rt/test/dfsan/flags.c b/compiler-rt/test/dfsan/flags.c
new file mode 100644
index 0000000..914f54f
--- /dev/null
+++ b/compiler-rt/test/dfsan/flags.c
@@ -0,0 +1,24 @@
+// RUN: %clang_dfsan %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clang_dfsan %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_unimplemented=0 %run %t 2>&1 | count 0
+// RUN: %clang_dfsan %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_nonzero_labels=1 %run %t 2>&1 | FileCheck --check-prefix=CHECK-NONZERO %s
+
+// Tests that flags work correctly.
+
+#include <sanitizer/dfsan_interface.h>
+
+int f(int i) {
+  return i;
+}
+
+int main(void) {
+  int i = 1;
+  dfsan_label i_label = dfsan_create_label("i", 0);
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  // CHECK: WARNING: DataFlowSanitizer: call to uninstrumented function f
+  // CHECK-NOT: WARNING: DataFlowSanitizer: saw nonzero label
+  // CHECK-NONZERO: WARNING: DataFlowSanitizer: saw nonzero label
+  f(i);
+
+  return 0;
+}
diff --git a/compiler-rt/test/dfsan/fncall.c b/compiler-rt/test/dfsan/fncall.c
new file mode 100644
index 0000000..458fba6
--- /dev/null
+++ b/compiler-rt/test/dfsan/fncall.c
@@ -0,0 +1,26 @@
+// RUN: %clang_dfsan %s -o %t && %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi %s -o %t && %run %t
+
+// Tests that labels are propagated through function calls.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+int f(int x) {
+  int j = 2;
+  dfsan_label j_label = dfsan_create_label("j", 0);
+  dfsan_set_label(j_label, &j, sizeof(j));
+  return x + j;
+}
+
+int main(void) {
+  int i = 1;
+  dfsan_label i_label = dfsan_create_label("i", 0);
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  dfsan_label ij_label = dfsan_get_label(f(i));
+  assert(dfsan_has_label(ij_label, i_label));
+  assert(dfsan_has_label_with_desc(ij_label, "j"));
+
+  return 0;
+}
diff --git a/compiler-rt/test/dfsan/label_count.c b/compiler-rt/test/dfsan/label_count.c
new file mode 100644
index 0000000..b42ce58
--- /dev/null
+++ b/compiler-rt/test/dfsan/label_count.c
@@ -0,0 +1,75 @@
+// RUN: %clang_dfsan -DLIB -c %s -o %t.lib.o && \
+// RUN: %clang_dfsan       -c %s -o %t.o && \
+// RUN: %clang_dfsan %t.lib.o %t.o -o %t.bin && \
+// RUN: %run %t.bin
+
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -DLIB -c %s -o %t.lib.o && \
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -c %s -o %t.o && \
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi %t.o %t.lib.o -o %t.bin && \
+// RUN: %run %t.bin
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+#ifdef LIB
+// Compiling this file with and without LIB defined allows this file to be
+// built as two separate translation units.  This ensures that the code
+// can not be optimized in a way that removes behavior we wish to test.  For
+// example, computing a value should cause labels to be allocated only if
+// the computation is actually done.  Putting the computation here prevents
+// the compiler from optimizing away the computation (and labeling) that
+// tests wish to verify.
+
+int add_in_separate_translation_unit(int a, int b) {
+  return a + b;
+}
+
+int multiply_in_separate_translation_unit(int a, int b) {
+  return a * b;
+}
+
+#else
+
+int add_in_separate_translation_unit(int i, int j);
+int multiply_in_separate_translation_unit(int i, int j);
+
+int main(void) {
+  size_t label_count;
+
+  // No labels allocated yet.
+  label_count = dfsan_get_label_count();
+  assert(0 == label_count);
+
+  int i = 1;
+  dfsan_label i_label = dfsan_create_label("i", 0);
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  // One label allocated for i.
+  label_count = dfsan_get_label_count();
+  assert(1u == label_count);
+
+  int j = 2;
+  dfsan_label j_label = dfsan_create_label("j", 0);
+  dfsan_set_label(j_label, &j, sizeof(j));
+
+  // Check that a new label was allocated for j.
+  label_count = dfsan_get_label_count();
+  assert(2u == label_count);
+
+  // Create a value that combines i and j.
+  int i_plus_j = add_in_separate_translation_unit(i, j);
+
+  // Check that a label was created for the union of i and j.
+  label_count = dfsan_get_label_count();
+  assert(3u == label_count);
+
+  // Combine i and j in a different way.  Check that the existing label is
+  // reused, and a new label is not created.
+  int j_times_i = multiply_in_separate_translation_unit(j, i);
+  label_count = dfsan_get_label_count();
+  assert(3u == label_count);
+  assert(dfsan_get_label(i_plus_j) == dfsan_get_label(j_times_i));
+
+  return 0;
+}
+#endif  // #ifdef LIB
diff --git a/compiler-rt/test/dfsan/lit.cfg b/compiler-rt/test/dfsan/lit.cfg
new file mode 100644
index 0000000..e4d4e8f
--- /dev/null
+++ b/compiler-rt/test/dfsan/lit.cfg
@@ -0,0 +1,26 @@
+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = 'DataFlowSanitizer'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Setup default compiler flags used with -fsanitize=dataflow option.
+clang_dfsan_cflags = ["-fsanitize=dataflow", "-m64"]
+clang_dfsan_cxxflags = config.cxx_mode_flags + clang_dfsan_cflags
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang_dfsan ", build_invocation(clang_dfsan_cflags)) )
+config.substitutions.append( ("%clangxx_dfsan ", build_invocation(clang_dfsan_cxxflags)) )
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp']
+
+# DataFlowSanitizer tests are currently supported on Linux only.
+if config.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/dfsan/lit.site.cfg.in b/compiler-rt/test/dfsan/lit.site.cfg.in
new file mode 100644
index 0000000..859284e
--- /dev/null
+++ b/compiler-rt/test/dfsan/lit.site.cfg.in
@@ -0,0 +1,5 @@
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@DFSAN_LIT_TESTS_DIR@/lit.cfg")
diff --git a/compiler-rt/test/dfsan/propagate.c b/compiler-rt/test/dfsan/propagate.c
new file mode 100644
index 0000000..c30a087
--- /dev/null
+++ b/compiler-rt/test/dfsan/propagate.c
@@ -0,0 +1,47 @@
+// RUN: %clang_dfsan %s -o %t && %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi %s -o %t && %run %t
+
+// Tests that labels are propagated through computation and that union labels
+// are properly created.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+int main(void) {
+  assert(dfsan_union(0, 0) == 0);
+
+  int i = 1;
+  dfsan_label i_label = dfsan_create_label("i", 0);
+  dfsan_set_label(i_label, &i, sizeof(i));
+
+  int j = 2;
+  dfsan_label j_label = dfsan_create_label("j", 0);
+  dfsan_set_label(j_label, &j, sizeof(j));
+
+  int k = 3;
+  dfsan_label k_label = dfsan_create_label("k", 0);
+  dfsan_set_label(k_label, &k, sizeof(k));
+
+  int k2 = 4;
+  dfsan_set_label(k_label, &k2, sizeof(k2));
+
+  dfsan_label ij_label = dfsan_get_label(i + j);
+  assert(dfsan_has_label(ij_label, i_label));
+  assert(dfsan_has_label(ij_label, j_label));
+  assert(!dfsan_has_label(ij_label, k_label));
+  // Test uniquing.
+  assert(dfsan_union(i_label, j_label) == ij_label);
+  assert(dfsan_union(j_label, i_label) == ij_label);
+
+  dfsan_label ijk_label = dfsan_get_label(i + j + k);
+  assert(dfsan_has_label(ijk_label, i_label));
+  assert(dfsan_has_label(ijk_label, j_label));
+  assert(dfsan_has_label(ijk_label, k_label));
+
+  assert(dfsan_get_label(k + k2) == k_label);
+
+  struct { int i, j; } s = { i, j };
+  assert(dfsan_read_label(&s, sizeof(s)) == ij_label);
+
+  return 0;
+}
diff --git a/compiler-rt/test/dfsan/vararg.c b/compiler-rt/test/dfsan/vararg.c
new file mode 100644
index 0000000..f51e39c
--- /dev/null
+++ b/compiler-rt/test/dfsan/vararg.c
@@ -0,0 +1,24 @@
+// RUN: %clang_dfsan %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %run %t foo
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %run %t foo
+
+#include <stdio.h>
+
+int do_nothing(const char *format, ...) {
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int (*fp)(const char *, ...);
+
+  if (argc > 1)
+    fp = do_nothing;
+  else
+    fp = printf;
+
+  // CHECK: FATAL: DataFlowSanitizer: unsupported indirect call to vararg function printf
+  fp("hello %s\n", "world");
+}
diff --git a/compiler-rt/test/dfsan/write_callback.c b/compiler-rt/test/dfsan/write_callback.c
new file mode 100644
index 0000000..3ba027a
--- /dev/null
+++ b/compiler-rt/test/dfsan/write_callback.c
@@ -0,0 +1,110 @@
+// RUN: %clang_dfsan                         %s -o %t && %run %t | FileCheck %s
+// RUN: %clang_dfsan  -mllvm -dfsan-args-abi %s -o %t && %run %t | FileCheck %s
+
+// Tests that the custom implementation of write() does writes with or without
+// a callback set using dfsan_set_write_callback().
+
+#include <sanitizer/dfsan_interface.h>
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+// Check write callback arguments by having the callback store them in
+// the following variables:
+static int last_callback_arg_fd;
+static const void *last_callback_arg_buf;
+static size_t last_callback_arg_count;
+
+// Allow tests to check the number of callbacks made by incrementing
+// this count.  When callbacks are verified, the count is reset.
+static int count_unverified_callbacks = 0;
+
+// This callbact will be installed using dfsan_set_write_callback()
+// in tests below.
+static void write_callback(int fd, const void *buf, size_t count) {
+  // Do not do anything in this function that might call write().
+  count_unverified_callbacks++;
+
+  last_callback_arg_fd = fd;
+  last_callback_arg_buf = buf;
+  last_callback_arg_count = count;
+}
+
+static void write_string_to_stdout(char *string) {
+  char *cur = string;
+  int bytes_left = strlen(string);
+  while (bytes_left > 0) {
+    int res = write(fileno(stdout), cur, bytes_left);
+    assert (res >= 0);
+    cur += res;
+    bytes_left -= res;
+  }
+}
+
+static void test_can_write_without_callback() {
+  dfsan_set_write_callback(NULL);
+  count_unverified_callbacks = 0;
+
+  char aString[] = "Test that writes work without callback.\n";
+  // CHECK: Test that writes work without callback.
+  write_string_to_stdout(aString);
+
+  assert(count_unverified_callbacks == 0);
+}
+
+static void test_can_write_with_callback() {
+  dfsan_set_write_callback(write_callback);
+
+  count_unverified_callbacks = 0;
+
+  char stringWithCallback[] = "Test that writes work with callback.\n";
+  // CHECK: Test that writes work with callback.
+  write_string_to_stdout(stringWithCallback);
+
+  // Data was written, so at least one call to write() was made.
+  // Because a write may not process all the bytes it is passed, there
+  // may have been several calls to write().
+  assert(count_unverified_callbacks > 0);
+  count_unverified_callbacks = 0;
+
+  dfsan_set_write_callback(NULL);
+
+  char stringWithoutCallback[] = "Writes work after the callback is removed.\n";
+  // CHECK: Writes work after the callback is removed.
+  write_string_to_stdout(stringWithoutCallback);
+  assert(count_unverified_callbacks == 0);
+}
+
+static void test_failing_write_runs_callback() {
+  // Open /dev/null in read-only mode.  Calling write() on fd will fail.
+  int fd = open("/dev/null", O_RDONLY);
+  assert(fd != -1);
+
+  // Install a callback.
+  dfsan_set_write_callback(write_callback);
+
+  // Write to the read-only file handle.  The write will fail, but the callback
+  // should still be invoked.
+  char aString[] = "This text will fail to be written.\n";
+  int len = strlen(aString);
+  int write_result = write(fd, aString, len);
+  assert(write_result == -1);
+
+  assert(count_unverified_callbacks == 1);
+  count_unverified_callbacks = 0;
+
+  assert(fd == last_callback_arg_fd);
+  assert(aString == last_callback_arg_buf);
+  assert(len == last_callback_arg_count);
+
+  close(fd);
+}
+
+int main(int argc, char* argv[]) {
+  test_can_write_without_callback();
+  test_can_write_with_callback();
+  test_failing_write_runs_callback();
+}
diff --git a/compiler-rt/test/lit.common.cfg b/compiler-rt/test/lit.common.cfg
new file mode 100644
index 0000000..aa3fd03
--- /dev/null
+++ b/compiler-rt/test/lit.common.cfg
@@ -0,0 +1,167 @@
+# -*- Python -*-
+
+# Configuration file for 'lit' test runner.
+# This file contains common rules for various compiler-rt testsuites.
+# It is mostly copied from lit.cfg used by Clang.
+import os
+import platform
+import re
+import subprocess
+
+import lit.formats
+import lit.util
+
+# Setup test format. Use bash on Unix and the lit shell on Windows.
+execute_external = (not sys.platform in ['win32'])
+config.test_format = lit.formats.ShTest(execute_external)
+if execute_external:
+  config.available_features.add('shell')
+
+# Setup clang binary.
+compiler_path = getattr(config, 'clang', None)
+if (not compiler_path) or (not os.path.exists(compiler_path)):
+  lit_config.fatal("Can't find compiler on path %r" % compiler_path)
+
+compiler_id = getattr(config, 'compiler_id', None)
+if compiler_id == "Clang":
+  if platform.system() != 'Windows':
+    config.cxx_mode_flags = ["--driver-mode=g++"]
+  else:
+    config.cxx_mode_flags = []
+  # We assume that sanitizers should provide good enough error
+  # reports and stack traces even with minimal debug info.
+  config.debug_info_flags = ["-gline-tables-only"]
+  if platform.system() == 'Windows':
+    config.debug_info_flags.append("-gcodeview")
+elif compiler_id == 'GNU':
+  config.cxx_mode_flags = ["-x c++"]
+  config.debug_info_flags = ["-g"]
+else:
+  lit_config.fatal("Unsupported compiler id: %r" % compiler_id)
+# Add compiler ID to the list of available features.
+config.available_features.add(compiler_id)
+
+# Clear some environment variables that might affect Clang.
+possibly_dangerous_env_vars = ['ASAN_OPTIONS', 'DFSAN_OPTIONS', 'LSAN_OPTIONS',
+                               'MSAN_OPTIONS', 'UBSAN_OPTIONS',
+                               'COMPILER_PATH', 'RC_DEBUG_OPTIONS',
+                               'CINDEXTEST_PREAMBLE_FILE', 'LIBRARY_PATH',
+                               'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH',
+                               'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH',
+                               'LIBCLANG_TIMING', 'LIBCLANG_OBJTRACKING',
+                               'LIBCLANG_LOGGING', 'LIBCLANG_BGPRIO_INDEX',
+                               'LIBCLANG_BGPRIO_EDIT', 'LIBCLANG_NOTHREADS',
+                               'LIBCLANG_RESOURCE_USAGE',
+                               'LIBCLANG_CODE_COMPLETION_LOGGING']
+# Clang/Win32 may refer to %INCLUDE%. vsvarsall.bat sets it.
+if platform.system() != 'Windows':
+    possibly_dangerous_env_vars.append('INCLUDE')
+for name in possibly_dangerous_env_vars:
+  if name in config.environment:
+    del config.environment[name]
+
+# Tweak PATH to include llvm tools dir.
+llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
+if (not llvm_tools_dir) or (not os.path.exists(llvm_tools_dir)):
+  lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % llvm_tools_dir)
+path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
+config.environment['PATH'] = path
+
+# Help MSVS link.exe find the standard libraries.
+# Make sure we only try to use it when targetting Windows.
+if platform.system() == 'Windows' and '-win' in config.target_triple:
+  config.environment['LIB'] = os.environ['LIB']
+
+# Use ugly construction to explicitly prohibit "clang", "clang++" etc.
+# in RUN lines.
+config.substitutions.append(
+    (' clang', """\n\n*** Do not use 'clangXXX' in tests,
+     instead define '%clangXXX' substitution in lit config. ***\n\n""") )
+
+# Allow tests to be executed on a simulator or remotely.
+config.substitutions.append( ('%run', config.emulator) )
+
+# Define CHECK-%os to check for OS-dependent output.
+config.substitutions.append( ('CHECK-%os', ("CHECK-" + config.host_os)))
+
+if config.host_os == 'Windows':
+  # FIXME: This isn't quite right. Specifically, it will succeed if the program
+  # does not crash but exits with a non-zero exit code. We ought to merge
+  # KillTheDoctor and not --crash to make the latter more useful and remove the
+  # need for this substitution.
+  config.substitutions.append( ("%expect_crash ", "not KillTheDoctor ") )
+else:
+  config.substitutions.append( ("%expect_crash ", "not --crash ") )
+
+# Add supported compiler_rt architectures to a list of available features.
+compiler_rt_arch = getattr(config, 'compiler_rt_arch', None)
+if compiler_rt_arch:
+  for arch in compiler_rt_arch.split(";"):
+    config.available_features.add(arch + "-supported-target")
+
+compiler_rt_debug = getattr(config, 'compiler_rt_debug', False)
+if not compiler_rt_debug:
+  config.available_features.add('compiler-rt-optimized')
+
+sanitizer_can_use_cxxabi = getattr(config, 'sanitizer_can_use_cxxabi', True)
+if sanitizer_can_use_cxxabi:
+  config.available_features.add('cxxabi')
+
+# Test lld if it is available.
+if config.has_lld:
+  config.available_features.add('lld')
+
+lit.util.usePlatformSdkOnDarwin(config, lit_config)
+
+def is_darwin_lto_supported():
+  return os.path.exists(os.path.join(config.llvm_shlib_dir, 'libLTO.dylib'))
+
+def is_linux_lto_supported():
+  if not os.path.exists(os.path.join(config.llvm_shlib_dir, 'LLVMgold.so')):
+    return False
+
+  ld_cmd = subprocess.Popen([config.gold_executable, '--help'], stdout = subprocess.PIPE)
+  ld_out = ld_cmd.stdout.read().decode()
+  ld_cmd.wait()
+
+  if not '-plugin' in ld_out:
+    return False
+
+  return True
+
+def is_windows_lto_supported():
+  return os.path.exists(os.path.join(config.llvm_tools_dir, 'lld-link.exe'))
+
+if config.host_os == 'Darwin' and is_darwin_lto_supported():
+  config.lto_supported = True
+  config.lto_launch = ["env", "DYLD_LIBRARY_PATH=" + config.llvm_shlib_dir]
+  config.lto_flags = []
+elif config.host_os == 'Linux' and is_linux_lto_supported():
+  config.lto_supported = True
+  config.lto_launch = []
+  config.lto_flags = ["-fuse-ld=gold"]
+elif config.host_os == 'Windows' and is_windows_lto_supported():
+  config.lto_supported = True
+  config.lto_launch = []
+  config.lto_flags = ["-fuse-ld=lld"]
+else:
+  config.lto_supported = False
+
+# Ask llvm-config about assertion mode.
+try:
+  llvm_config_cmd = subprocess.Popen(
+      [os.path.join(config.llvm_tools_dir, 'llvm-config'), '--assertion-mode'],
+      stdout = subprocess.PIPE,
+      env=config.environment)
+except OSError:
+  print("Could not find llvm-config in " + llvm_tools_dir)
+  exit(42)
+
+if re.search(r'ON', llvm_config_cmd.stdout.read().decode('ascii')):
+  config.available_features.add('asserts')
+llvm_config_cmd.wait()
+
+# Sanitizer tests tend to be flaky on Windows due to PR24554, so add some
+# retries. We don't do this on otther platforms because it's slower.
+if platform.system() == 'Windows':
+  config.test_retry_attempts = 2
diff --git a/compiler-rt/test/lit.common.configured.in b/compiler-rt/test/lit.common.configured.in
new file mode 100644
index 0000000..8778902
--- /dev/null
+++ b/compiler-rt/test/lit.common.configured.in
@@ -0,0 +1,42 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Set attribute value if it is unset.
+def set_default(attr, value):
+  if not getattr(config, attr, None):
+    setattr(config, attr, value)
+
+# Generic config options for all compiler-rt lit tests.
+set_default("target_triple", "@COMPILER_RT_DEFAULT_TARGET_TRIPLE@")
+set_default("target_cflags", "@COMPILER_RT_TEST_COMPILER_CFLAGS@")
+set_default("host_arch", "@HOST_ARCH@")
+set_default("target_arch", "@COMPILER_RT_DEFAULT_TARGET_ARCH@")
+set_default("host_os", "@HOST_OS@")
+set_default("llvm_build_mode", "@LLVM_BUILD_MODE@")
+set_default("llvm_src_root", "@LLVM_SOURCE_DIR@")
+set_default("llvm_obj_root", "@LLVM_BINARY_DIR@")
+set_default("compiler_rt_src_root", "@COMPILER_RT_SOURCE_DIR@")
+set_default("compiler_rt_obj_root", "@COMPILER_RT_BINARY_DIR@")
+set_default("llvm_tools_dir", "@LLVM_TOOLS_DIR@")
+set_default("llvm_shlib_dir", "@SHLIBDIR@")
+set_default("gold_executable", "@GOLD_EXECUTABLE@")
+set_default("clang", "@COMPILER_RT_TEST_COMPILER@")
+set_default("compiler_id", "@COMPILER_RT_TEST_COMPILER_ID@")
+set_default("compiler_rt_arch", "@COMPILER_RT_SUPPORTED_ARCH@")
+set_default("python_executable", "@PYTHON_EXECUTABLE@")
+set_default("compiler_rt_debug", @COMPILER_RT_DEBUG_PYBOOL@)
+set_default("compiler_rt_libdir", "@COMPILER_RT_LIBRARY_OUTPUT_DIR@")
+set_default("emulator", "@COMPILER_RT_EMULATOR@")
+set_default("sanitizer_can_use_cxxabi", @SANITIZER_CAN_USE_CXXABI_PYBOOL@)
+set_default("has_lld", @COMPILER_RT_HAS_LLD_SOURCES_PYBOOL@)
+
+# LLVM tools dir can be passed in lit parameters, so try to
+# apply substitution.
+try:
+  config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
+except KeyError as e:
+  key, = e.args
+  lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key, key))
+
+# Setup attributes common for all compiler-rt projects.
+lit_config.load_config(config, "@COMPILER_RT_SOURCE_DIR@/test/lit.common.cfg")
diff --git a/compiler-rt/test/lsan/CMakeLists.txt b/compiler-rt/test/lsan/CMakeLists.txt
new file mode 100644
index 0000000..6cca00a
--- /dev/null
+++ b/compiler-rt/test/lsan/CMakeLists.txt
@@ -0,0 +1,21 @@
+set(LSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(LSAN_LIT_TEST_MODE "Standalone")
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/LsanConfig/lit.site.cfg)
+
+set(LSAN_LIT_TEST_MODE "AddressSanitizer")
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/AsanConfig/lit.site.cfg)
+
+set(LSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND LSAN_TEST_DEPS lsan asan)
+endif()
+add_lit_testsuite(check-lsan "Running the LeakSanitizer tests"
+  ${CMAKE_CURRENT_BINARY_DIR}/LsanConfig
+  ${CMAKE_CURRENT_BINARY_DIR}/AsanConfig
+  DEPENDS ${LSAN_TEST_DEPS})
+set_target_properties(check-lsan PROPERTIES FOLDER "LSan tests")
diff --git a/compiler-rt/test/lsan/TestCases/cleanup_in_tsd_destructor.c b/compiler-rt/test/lsan/TestCases/cleanup_in_tsd_destructor.c
new file mode 100644
index 0000000..debf05c
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/cleanup_in_tsd_destructor.c
@@ -0,0 +1,45 @@
+// Regression test for thread lifetime tracking. Thread data should be
+// considered live during the thread's termination, at least until the
+// user-installed TSD destructors have finished running (since they may contain
+// additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it
+// makes its best effort.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0"
+// RUN: %clang_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=1 %run %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=0 not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+pthread_key_t key;
+__thread void *p;
+
+void key_destructor(void *arg) {
+  // Generally this may happen on a different thread.
+  __lsan_do_leak_check();
+}
+
+void *thread_func(void *arg) {
+  p = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  int res = pthread_setspecific(key, (void*)1);
+  assert(res == 0);
+  return 0;
+}
+
+int main() {
+  int res = pthread_key_create(&key, &key_destructor);
+  assert(res == 0);
+  pthread_t thread_id;
+  res = pthread_create(&thread_id, 0, thread_func, 0);
+  assert(res == 0);
+  res = pthread_join(thread_id, 0);
+  assert(res == 0);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: [[ADDR]] (1337 bytes)
diff --git a/compiler-rt/test/lsan/TestCases/disabler.c b/compiler-rt/test/lsan/TestCases/disabler.c
new file mode 100644
index 0000000..1c4529d
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/disabler.c
@@ -0,0 +1,24 @@
+// Test for __lsan_disable() / __lsan_enable().
+// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
+// RUN: %clang_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+int main() {
+  void **p;
+  {
+    __lsan_disable();
+    p = malloc(sizeof(void *));
+    __lsan_enable();
+  }
+  *p = malloc(666);
+  void *q = malloc(1337);
+  // Break optimization.
+  fprintf(stderr, "Test alloc: %p.\n", q);
+  return 0;
+}
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/disabler.cc b/compiler-rt/test/lsan/TestCases/disabler.cc
new file mode 100644
index 0000000..12e5ffe
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/disabler.cc
@@ -0,0 +1,25 @@
+// Test for ScopedDisabler.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+int main() {
+  void **p;
+  {
+    __lsan::ScopedDisabler d;
+    p = new void *;
+    fprintf(stderr, "Test alloc p: %p.\n", p);
+  }
+  *p = malloc(666);
+  void *q = malloc(1337);
+  fprintf(stderr, "Test alloc q: %p.\n", q);
+  return 0;
+}
+
+// CHECK: Test alloc p: [[ADDR:.*]].
+// CHECK-NOT: [[ADDR]]
diff --git a/compiler-rt/test/lsan/TestCases/disabler_in_tsd_destructor.c b/compiler-rt/test/lsan/TestCases/disabler_in_tsd_destructor.c
new file mode 100644
index 0000000..982fb89
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/disabler_in_tsd_destructor.c
@@ -0,0 +1,39 @@
+// Regression test. Disabler should not depend on TSD validity.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=1"
+// RUN: %clang_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+pthread_key_t key;
+
+void key_destructor(void *arg) {
+  __lsan_disable();
+  void *p = malloc(1337);
+  // Break optimization.
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  pthread_setspecific(key, 0);
+  __lsan_enable();
+}
+
+void *thread_func(void *arg) {
+  int res = pthread_setspecific(key, (void*)1);
+  assert(res == 0);
+  return 0;
+}
+
+int main() {
+  int res = pthread_key_create(&key, &key_destructor);
+  assert(res == 0);
+  pthread_t thread_id;
+  res = pthread_create(&thread_id, 0, thread_func, 0);
+  assert(res == 0);
+  res = pthread_join(thread_id, 0);
+  assert(res == 0);
+  return 0;
+}
diff --git a/compiler-rt/test/lsan/TestCases/do_leak_check_override.cc b/compiler-rt/test/lsan/TestCases/do_leak_check_override.cc
new file mode 100644
index 0000000..bedb0ca
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/do_leak_check_override.cc
@@ -0,0 +1,36 @@
+// Test for __lsan_do_leak_check(). We test it by making the leak check run
+// before global destructors, which also tests compatibility with HeapChecker's
+// "normal" mode (LSan runs in "strict" mode by default).
+// RUN: LSAN_BASE="use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck --check-prefix=CHECK-strict %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck --check-prefix=CHECK-normal %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sanitizer/lsan_interface.h>
+
+struct LeakyGlobal {
+  LeakyGlobal() {
+    p = malloc(1337);
+  }
+  ~LeakyGlobal() {
+    p = 0;
+  }
+  void *p;
+};
+
+LeakyGlobal leaky_global;
+
+int main(int argc, char *argv[]) {
+  // Register leak check to run before global destructors.
+  if (argc > 1)
+    atexit(&__lsan_do_leak_check);
+  void *p = malloc(666);
+  printf("Test alloc: %p\n", p);
+  printf("Test alloc in leaky global: %p\n", leaky_global.p);
+  return 0;
+}
+
+// CHECK-strict: SUMMARY: {{(Leak|Address)}}Sanitizer: 2003 byte(s) leaked in 2 allocation(s)
+// CHECK-normal: SUMMARY: {{(Leak|Address)}}Sanitizer: 666 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/fork.cc b/compiler-rt/test/lsan/TestCases/fork.cc
new file mode 100644
index 0000000..9e72fe8
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/fork.cc
@@ -0,0 +1,24 @@
+// Test that thread local data is handled correctly after forking without exec().
+// RUN: %clangxx_lsan %s -o %t
+// RUN: %run %t 2>&1
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+__thread void *thread_local_var;
+
+int main() {
+  int status = 0;
+  thread_local_var = malloc(1337);
+  pid_t pid = fork();
+  assert(pid >= 0);
+  if (pid > 0) {
+    waitpid(pid, &status, 0);
+    assert(WIFEXITED(status));
+    return WEXITSTATUS(status);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/lsan/TestCases/fork_threaded.cc b/compiler-rt/test/lsan/TestCases/fork_threaded.cc
new file mode 100644
index 0000000..62702b4
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/fork_threaded.cc
@@ -0,0 +1,43 @@
+// Test that thread local data is handled correctly after forking without
+// exec(). In this test leak checking is initiated from a non-main thread.
+// RUN: %clangxx_lsan %s -o %t
+// RUN: %run %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+__thread void *thread_local_var;
+
+void *exit_thread_func(void *arg) {
+  exit(0);
+}
+
+void ExitFromThread() {
+  pthread_t tid;
+  int res;
+  res = pthread_create(&tid, 0, exit_thread_func, 0);
+  assert(res == 0);
+  pthread_join(tid, 0);
+}
+
+int main() {
+  int status = 0;
+  thread_local_var = malloc(1337);
+  pid_t pid = fork();
+  assert(pid >= 0);
+  if (pid > 0) {
+    waitpid(pid, &status, 0);
+    assert(WIFEXITED(status));
+    return WEXITSTATUS(status);
+  } else {
+    // Spawn a thread and call exit() from there, to check that we track main
+    // thread's pid correctly even if leak checking is initiated from another
+    // thread.
+    ExitFromThread();
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/lsan/TestCases/high_allocator_contention.cc b/compiler-rt/test/lsan/TestCases/high_allocator_contention.cc
new file mode 100644
index 0000000..2543897
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/high_allocator_contention.cc
@@ -0,0 +1,48 @@
+// A benchmark that executes malloc/free pairs in parallel.
+// Usage: ./a.out number_of_threads total_number_of_allocations
+// RUN: %clangxx_lsan %s -o %t
+// RUN: %run %t 5 1000000 2>&1
+#include <assert.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+int num_threads;
+int total_num_alloc;
+const int kMaxNumThreads = 5000;
+pthread_t tid[kMaxNumThreads];
+
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+bool go = false;
+
+void *thread_fun(void *arg) {
+  pthread_mutex_lock(&mutex);
+  while (!go) pthread_cond_wait(&cond, &mutex);
+  pthread_mutex_unlock(&mutex);
+  for (int i = 0; i < total_num_alloc / num_threads; i++) {
+    void *p = malloc(10);
+    __asm__ __volatile__("" : : "r"(p) : "memory");
+    free((void *)p);
+  }
+  return 0;
+}
+
+int main(int argc, char** argv) {
+  assert(argc == 3);
+  num_threads = atoi(argv[1]);
+  assert(num_threads > 0);
+  assert(num_threads <= kMaxNumThreads);
+  total_num_alloc = atoi(argv[2]);
+  assert(total_num_alloc > 0);
+  printf("%d threads, %d allocations in each\n", num_threads,
+         total_num_alloc / num_threads);
+  for (int i = 0; i < num_threads; i++)
+    pthread_create(&tid[i], 0, thread_fun, 0);
+  pthread_mutex_lock(&mutex);
+  go = true;
+  pthread_cond_broadcast(&cond);
+  pthread_mutex_unlock(&mutex);
+  for (int i = 0; i < num_threads; i++) pthread_join(tid[i], 0);
+  return 0;
+}
diff --git a/compiler-rt/test/lsan/TestCases/ignore_object.c b/compiler-rt/test/lsan/TestCases/ignore_object.c
new file mode 100644
index 0000000..2aa4f14
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/ignore_object.c
@@ -0,0 +1,23 @@
+// Test for __lsan_ignore_object().
+// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
+// RUN: %clang_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+int main() {
+  // Explicitly ignored object.
+  void **p = malloc(sizeof(void *));
+  // Transitively ignored object.
+  *p = malloc(666);
+  // Non-ignored object.
+  volatile void *q = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  __lsan_ignore_object(p);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/ignore_object_errors.cc b/compiler-rt/test/lsan/TestCases/ignore_object_errors.cc
new file mode 100644
index 0000000..4160327
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/ignore_object_errors.cc
@@ -0,0 +1,20 @@
+// Test for incorrect use of __lsan_ignore_object().
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+int main() {
+  void *p = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  __lsan_ignore_object(p);
+  __lsan_ignore_object(p);
+  free(p);
+  __lsan_ignore_object(p);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK-NOT: SUMMARY: {{.*}} leaked
diff --git a/compiler-rt/test/lsan/TestCases/large_allocation_leak.cc b/compiler-rt/test/lsan/TestCases/large_allocation_leak.cc
new file mode 100644
index 0000000..f41143a
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/large_allocation_leak.cc
@@ -0,0 +1,18 @@
+// Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  // maxsize in primary allocator is always less than this (1 << 25).
+  void *large_alloc = malloc(33554432);
+  fprintf(stderr, "Test alloc: %p.\n", large_alloc);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (33554432 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/leak_check_at_exit.cc b/compiler-rt/test/lsan/TestCases/leak_check_at_exit.cc
new file mode 100644
index 0000000..6f1cd22
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/leak_check_at_exit.cc
@@ -0,0 +1,21 @@
+// Test for the leak_check_at_exit flag.
+// RUN: LSAN_BASE="use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-do
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"leak_check_at_exit=0" not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"leak_check_at_exit=0" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sanitizer/lsan_interface.h>
+
+int main(int argc, char *argv[]) {
+  fprintf(stderr, "Test alloc: %p.\n", malloc(1337));
+  if (argc > 1)
+    __lsan_do_leak_check();
+  return 0;
+}
+
+// CHECK-do: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK-dont-NOT: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/leak_check_before_thread_started.cc b/compiler-rt/test/lsan/TestCases/leak_check_before_thread_started.cc
new file mode 100644
index 0000000..0bd4837
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/leak_check_before_thread_started.cc
@@ -0,0 +1,31 @@
+// Regression test for http://llvm.org/bugs/show_bug.cgi?id=21621
+// This test relies on timing between threads, so any failures will be flaky.
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS="log_pointers=1:log_threads=1" %run %t
+#include <assert.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void *func(void *arg) {
+  sleep(1);
+  free(arg);
+  return 0;
+}
+
+void create_detached_thread() {
+  pthread_t thread_id;
+  pthread_attr_t attr;
+
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+
+  void *arg = malloc(1337);
+  assert(arg);
+  int res = pthread_create(&thread_id, &attr, func, arg);
+  assert(res == 0);
+}
+
+int main() {
+  create_detached_thread();
+}
diff --git a/compiler-rt/test/lsan/TestCases/link_turned_off.cc b/compiler-rt/test/lsan/TestCases/link_turned_off.cc
new file mode 100644
index 0000000..2482f61
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/link_turned_off.cc
@@ -0,0 +1,24 @@
+// Test for disabling LSan at link-time.
+// RUN: LSAN_BASE="use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
+
+#include <sanitizer/lsan_interface.h>
+
+int argc_copy;
+
+extern "C" {
+int __lsan_is_turned_off() {
+  return (argc_copy == 1);
+}
+}
+
+int main(int argc, char *argv[]) {
+  volatile int *x = new int;
+  *x = 42;
+  argc_copy = argc;
+  return 0;
+}
+
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 4 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/new_array_with_dtor_0.cc b/compiler-rt/test/lsan/TestCases/new_array_with_dtor_0.cc
new file mode 100644
index 0000000..5925961
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/new_array_with_dtor_0.cc
@@ -0,0 +1,19 @@
+// Regression test:
+// https://code.google.com/p/address-sanitizer/issues/detail?id=257
+// RUN: %clangxx_lsan %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+
+struct T {
+  ~T() { printf("~T\n"); }
+};
+
+T *t;
+
+int main(int argc, char **argv) {
+  t = new T[argc - 1];
+  printf("OK\n");
+}
+
+// CHECK: OK
+
diff --git a/compiler-rt/test/lsan/TestCases/pointer_to_self.cc b/compiler-rt/test/lsan/TestCases/pointer_to_self.cc
new file mode 100644
index 0000000..63bde2c
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/pointer_to_self.cc
@@ -0,0 +1,18 @@
+// Regression test: pointers to self should not confuse LSan into thinking the
+// object is indirectly leaked. Only external pointers count.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  void *p = malloc(1337);
+  *reinterpret_cast<void **>(p) = p;
+  fprintf(stderr, "Test alloc: %p.\n", p);
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/print_suppressions.cc b/compiler-rt/test/lsan/TestCases/print_suppressions.cc
new file mode 100644
index 0000000..b292c0a
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/print_suppressions.cc
@@ -0,0 +1,33 @@
+// Print matched suppressions only if print_suppressions=1 AND at least one is
+// matched. Default is print_suppressions=true.
+// RUN: LSAN_BASE="use_registers=0:use_stacks=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
+// RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-print
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+extern "C"
+const char *__lsan_default_suppressions() {
+  return "leak:*LSanTestLeakingFunc*";
+}
+
+void LSanTestLeakingFunc() {
+  void *p = malloc(666);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+}
+
+int main(int argc, char **argv) {
+  printf("print for nonempty output\n");
+  if (argc > 1)
+    LSanTestLeakingFunc();
+  return 0;
+}
+// CHECK-print: Suppressions used:
+// CHECK-print: 1 666 *LSanTestLeakingFunc*
+// CHECK-dont-print-NOT: Suppressions used:
diff --git a/compiler-rt/test/lsan/TestCases/recoverable_leak_check.cc b/compiler-rt/test/lsan/TestCases/recoverable_leak_check.cc
new file mode 100644
index 0000000..0fe377f
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/recoverable_leak_check.cc
@@ -0,0 +1,32 @@
+// Test for on-demand leak checking.
+// RUN: LSAN_BASE="use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sanitizer/lsan_interface.h>
+
+void *p;
+
+int main(int argc, char *argv[]) {
+  p = malloc(23);
+
+  assert(__lsan_do_recoverable_leak_check() == 0);
+
+  fprintf(stderr, "Test alloc: %p.\n", malloc(1337));
+// CHECK: Test alloc:
+
+  assert(__lsan_do_recoverable_leak_check() == 1);
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte
+
+  // Test that we correctly reset chunk tags.
+  p = 0;
+  assert(__lsan_do_recoverable_leak_check() == 1);
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1360 byte
+
+  _exit(0);
+}
diff --git a/compiler-rt/test/lsan/TestCases/register_root_region.cc b/compiler-rt/test/lsan/TestCases/register_root_region.cc
new file mode 100644
index 0000000..6fc84c2
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/register_root_region.cc
@@ -0,0 +1,32 @@
+// Test for __lsan_(un)register_root_region().
+// RUN: LSAN_BASE="use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:use_root_regions=0 not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <sanitizer/lsan_interface.h>
+
+int main(int argc, char *argv[]) {
+  size_t size = getpagesize() * 2;
+  void *p =
+      mmap(0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+  assert(p);
+  // Make half of the memory inaccessible. LSan must not crash trying to read it.
+  assert(0 == mprotect((char *)p + size / 2, size / 2, PROT_NONE));
+
+  __lsan_register_root_region(p, size);
+  *((void **)p) = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  if (argc > 1)
+    __lsan_unregister_root_region(p, size);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/sanity_check_pure_c.c b/compiler-rt/test/lsan/TestCases/sanity_check_pure_c.c
new file mode 100644
index 0000000..085412b
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/sanity_check_pure_c.c
@@ -0,0 +1,10 @@
+// Check that we can build C code.
+// RUN: %clang_lsan %s -o %t
+#ifdef __cplusplus
+#error "This test must be built in C mode"
+#endif
+
+int main() {
+  // FIXME: ideally this should somehow check that we don't have libstdc++
+  return 0;
+}
diff --git a/compiler-rt/test/lsan/TestCases/stale_stack_leak.cc b/compiler-rt/test/lsan/TestCases/stale_stack_leak.cc
new file mode 100644
index 0000000..4b8a54e
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/stale_stack_leak.cc
@@ -0,0 +1,43 @@
+// Test that out-of-scope local variables are ignored by LSan.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=1"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE":exitcode=0" %run %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void **pp;
+
+// Put pointer far enough on the stack that LSan has space to run in without
+// overwriting it.
+// Hopefully the argument p will be passed on a register, saving us from false
+// negatives.
+__attribute__((noinline))
+void *PutPointerOnStaleStack(void *p) {
+  void *locals[2048];
+  locals[0] = p;
+  pp = &locals[0];
+  fprintf(stderr, "Test alloc: %p.\n", locals[0]);
+  return 0;
+}
+
+int main() {
+  PutPointerOnStaleStack(malloc(1337));
+  return 0;
+}
+
+// This must run after LSan, to ensure LSan didn't overwrite the pointer before
+// it had a chance to see it. If LSan is invoked with atexit(), this works.
+// Otherwise, we need a different method.
+__attribute__((destructor))
+__attribute__((no_sanitize_address))
+void ConfirmPointerHasSurvived() {
+  fprintf(stderr, "Value after LSan: %p.\n", *pp);
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK-sanity: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK-sanity: Value after LSan: [[ADDR]].
diff --git a/compiler-rt/test/lsan/TestCases/suppressions_default.cc b/compiler-rt/test/lsan/TestCases/suppressions_default.cc
new file mode 100644
index 0000000..b4c0de0
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/suppressions_default.cc
@@ -0,0 +1,28 @@
+// RUN: LSAN_BASE="use_registers=0:use_stacks=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+extern "C"
+const char *__lsan_default_suppressions() {
+  return "leak:*LSanTestLeakingFunc*";
+}
+
+void LSanTestLeakingFunc() {
+  void *p = malloc(666);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+}
+
+int main() {
+  LSanTestLeakingFunc();
+  void *q = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", q);
+  return 0;
+}
+// CHECK: Suppressions used:
+// CHECK: 1 666 *LSanTestLeakingFunc*
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/suppressions_file.cc b/compiler-rt/test/lsan/TestCases/suppressions_file.cc
new file mode 100644
index 0000000..805091c
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/suppressions_file.cc
@@ -0,0 +1,32 @@
+// RUN: LSAN_BASE="use_registers=0:use_stacks=0"
+// RUN: %clangxx_lsan %s -o %t
+
+// RUN: rm -f %t.supp
+// RUN: touch %t.supp
+// RUN: LSAN_OPTIONS="$LSAN_BASE:suppressions='%t.supp'" not %run %t 2>&1 | FileCheck %s --check-prefix=NOSUPP
+
+// RUN: echo "leak:*LSanTestLeakingFunc*" > %t.supp
+// RUN: LSAN_OPTIONS="$LSAN_BASE:suppressions='%t.supp'" not %run %t 2>&1 | FileCheck %s
+
+// RUN: echo "leak:%t" > %t.supp
+// RUN: LSAN_OPTIONS="$LSAN_BASE:suppressions='%t.supp':symbolize=false" %run %t
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void LSanTestLeakingFunc() {
+  void *p = malloc(666);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+}
+
+int main() {
+  LSanTestLeakingFunc();
+  void *q = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", q);
+  return 0;
+}
+// CHECK: Suppressions used:
+// CHECK: 1 666 *LSanTestLeakingFunc*
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 1337 byte(s) leaked in 1 allocation(s)
+
+// NOSUPP: SUMMARY: {{(Leak|Address)}}Sanitizer: 2003 byte(s) leaked in 2 allocation(s).
diff --git a/compiler-rt/test/lsan/TestCases/swapcontext.cc b/compiler-rt/test/lsan/TestCases/swapcontext.cc
new file mode 100644
index 0000000..f7e95ed
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/swapcontext.cc
@@ -0,0 +1,47 @@
+// We can't unwind stack if we're running coroutines on heap-allocated
+// memory. Make sure we don't report these leaks.
+
+// RUN: %clangxx_lsan %s -o %t
+// RUN: %run %t 2>&1
+// RUN: not %run %t foo 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#if defined(__APPLE__)
+// Note: ucontext.h is deprecated on OSX, so this test may stop working
+// someday. We define _XOPEN_SOURCE to keep using ucontext.h for now.
+#define _XOPEN_SOURCE 1
+#endif
+#include <ucontext.h>
+#include <unistd.h>
+
+const int kStackSize = 1 << 20;
+
+void Child() {
+  int child_stack;
+  printf("Child: %p\n", &child_stack);
+  int *leaked = new int[666];
+}
+
+int main(int argc, char *argv[]) {
+  char stack_memory[kStackSize + 1];
+  char *heap_memory = new char[kStackSize + 1];
+  char *child_stack = (argc > 1) ? stack_memory : heap_memory;
+
+  printf("Child stack: %p\n", child_stack);
+  ucontext_t orig_context;
+  ucontext_t child_context;
+  getcontext(&child_context);
+  child_context.uc_stack.ss_sp = child_stack;
+  child_context.uc_stack.ss_size = kStackSize / 2;
+  child_context.uc_link = &orig_context;
+  makecontext(&child_context, Child, 0);
+  if (swapcontext(&orig_context, &child_context) < 0) {
+    perror("swapcontext");
+    return 1;
+  }
+
+  delete[] heap_memory;
+  return 0;
+}
+
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: 2664 byte(s) leaked in 1 allocation(s)
diff --git a/compiler-rt/test/lsan/TestCases/use_after_return.cc b/compiler-rt/test/lsan/TestCases/use_after_return.cc
new file mode 100644
index 0000000..eb917c0
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_after_return.cc
@@ -0,0 +1,23 @@
+// Test that fake stack (introduced by ASan's use-after-return mode) is included
+// in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0"
+// RUN: %clangxx_lsan %s -O2 -o %t
+// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
+// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS="" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  void *stack_var = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", stack_var);
+  // Take pointer to variable, to ensure it's not optimized into a register.
+  fprintf(stderr, "Stack var at: %p.\n", &stack_var);
+  // Do not return from main to prevent the pointer from going out of scope.
+  exit(0);
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_globals_initialized.cc b/compiler-rt/test/lsan/TestCases/use_globals_initialized.cc
new file mode 100644
index 0000000..172d22a
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_globals_initialized.cc
@@ -0,0 +1,21 @@
+// Test that initialized globals are included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void *data_var = (void *)1;
+
+int main() {
+  data_var = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", data_var);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_globals_uninitialized.cc b/compiler-rt/test/lsan/TestCases/use_globals_uninitialized.cc
new file mode 100644
index 0000000..2daa661
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_globals_uninitialized.cc
@@ -0,0 +1,21 @@
+// Test that uninitialized globals are included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void *bss_var;
+
+int main() {
+  bss_var = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", bss_var);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_poisoned_asan.cc b/compiler-rt/test/lsan/TestCases/use_poisoned_asan.cc
new file mode 100644
index 0000000..a1c544c
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_poisoned_asan.cc
@@ -0,0 +1,25 @@
+// ASan-poisoned memory should be ignored if use_poisoned is false.
+// REQUIRES: asan
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=1" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sanitizer/asan_interface.h>
+#include <assert.h>
+
+void **p;
+
+int main() {
+  p = new void *;
+  *p = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", *p);
+  __asan_poison_memory_region(p, sizeof(*p));
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: AddressSanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_registers.cc b/compiler-rt/test/lsan/TestCases/use_registers.cc
new file mode 100644
index 0000000..ce11c3f
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_registers.cc
@@ -0,0 +1,52 @@
+// Test that registers of running threads are included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0"
+// RUN: %clangxx_lsan -pthread %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+extern "C"
+void *registers_thread_func(void *arg) {
+  int *sync = reinterpret_cast<int *>(arg);
+  void *p = malloc(1337);
+  // To store the pointer, choose a register which is unlikely to be reused by
+  // a function call.
+#if defined(__i386__)
+  asm ( "mov %0, %%esi"
+      :
+      : "r" (p)
+      );
+#elif defined(__x86_64__)
+  asm ( "mov %0, %%r15"
+      :
+      : "r" (p)
+      );
+#else
+#error "Test is not supported on this architecture."
+#endif
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  fflush(stderr);
+  __sync_fetch_and_xor(sync, 1);
+  while (true)
+    sched_yield();
+}
+
+int main() {
+  int sync = 0;
+  pthread_t thread_id;
+  int res = pthread_create(&thread_id, 0, registers_thread_func, &sync);
+  assert(res == 0);
+  while (!__sync_fetch_and_xor(&sync, 0))
+    sched_yield();
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_stacks.cc b/compiler-rt/test/lsan/TestCases/use_stacks.cc
new file mode 100644
index 0000000..7afcde1
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_stacks.cc
@@ -0,0 +1,20 @@
+// Test that stack of main thread is included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  void *stack_var = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", stack_var);
+  // Do not return from main to prevent the pointer from going out of scope.
+  exit(0);
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_stacks_threaded.cc b/compiler-rt/test/lsan/TestCases/use_stacks_threaded.cc
new file mode 100644
index 0000000..a1d4383
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_stacks_threaded.cc
@@ -0,0 +1,37 @@
+// Test that stacks of non-main threads are included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_registers=0"
+// RUN: %clangxx_lsan -pthread %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+extern "C"
+void *stacks_thread_func(void *arg) {
+  int *sync = reinterpret_cast<int *>(arg);
+  void *p = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  fflush(stderr);
+  __sync_fetch_and_xor(sync, 1);
+  while (true)
+    sched_yield();
+}
+
+int main() {
+  int sync = 0;
+  pthread_t thread_id;
+  int res = pthread_create(&thread_id, 0, stacks_thread_func, &sync);
+  assert(res == 0);
+  while (!__sync_fetch_and_xor(&sync, 0))
+    sched_yield();
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc b/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc
new file mode 100644
index 0000000..860db04
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc
@@ -0,0 +1,50 @@
+// Test that dynamically allocated TLS space is included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx %s -DBUILD_DSO -fPIC -shared -o %t-so.so
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#ifndef BUILD_DSO
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+int main(int argc, char *argv[]) {
+  std::string path = std::string(argv[0]) + "-so.so";
+
+  void *handle = dlopen(path.c_str(), RTLD_LAZY);
+  assert(handle != 0);
+  typedef void **(* store_t)(void *p);
+  store_t StoreToTLS = (store_t)dlsym(handle, "StoreToTLS");
+  assert(dlerror() == 0);
+
+  void *p = malloc(1337);
+  // If we don't  know about dynamic TLS, we will return a false leak above.
+  void **p_in_tls = StoreToTLS(p);
+  assert(*p_in_tls == p);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+
+#else  // BUILD_DSO
+// A loadable module with a large thread local section, which would require
+// allocation of a new TLS storage chunk when loaded with dlopen(). We use it
+// to test the reachability of such chunks in LSan tests.
+
+// This must be large enough that it doesn't fit into preallocated static TLS
+// space (see STATIC_TLS_SURPLUS in glibc).
+__thread void *huge_thread_local_array[(1 << 20) / sizeof(void *)]; // NOLINT
+
+extern "C" void **StoreToTLS(void *p) {
+  huge_thread_local_array[0] = p;
+  return &huge_thread_local_array[0];
+}
+#endif  // BUILD_DSO
diff --git a/compiler-rt/test/lsan/TestCases/use_tls_pthread_specific_dynamic.cc b/compiler-rt/test/lsan/TestCases/use_tls_pthread_specific_dynamic.cc
new file mode 100644
index 0000000..1488371
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_tls_pthread_specific_dynamic.cc
@@ -0,0 +1,37 @@
+// Test that dynamically allocated thread-specific storage is included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// From glibc: this many keys are stored in the thread descriptor directly.
+const unsigned PTHREAD_KEY_2NDLEVEL_SIZE = 32;
+
+int main() {
+  static const unsigned kDummyKeysCount = PTHREAD_KEY_2NDLEVEL_SIZE;
+  int res;
+  pthread_key_t dummy_keys[kDummyKeysCount];
+  for (unsigned i = 0; i < kDummyKeysCount; i++) {
+    res = pthread_key_create(&dummy_keys[i], NULL);
+    assert(res == 0);
+  }
+  pthread_key_t key;
+  res = pthread_key_create(&key, NULL);
+  assert(key >= PTHREAD_KEY_2NDLEVEL_SIZE);
+  assert(res == 0);
+  void *p  = malloc(1337);
+  res = pthread_setspecific(key, p);
+  assert(res == 0);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_tls_pthread_specific_static.cc b/compiler-rt/test/lsan/TestCases/use_tls_pthread_specific_static.cc
new file mode 100644
index 0000000..1fd5681
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_tls_pthread_specific_static.cc
@@ -0,0 +1,31 @@
+// Test that statically allocated thread-specific storage is included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// From glibc: this many keys are stored in the thread descriptor directly.
+const unsigned PTHREAD_KEY_2NDLEVEL_SIZE = 32;
+
+int main() {
+  pthread_key_t key;
+  int res;
+  res = pthread_key_create(&key, NULL);
+  assert(res == 0);
+  assert(key < PTHREAD_KEY_2NDLEVEL_SIZE);
+  void *p = malloc(1337);
+  res = pthread_setspecific(key, p);
+  assert(res == 0);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_tls_static.cc b/compiler-rt/test/lsan/TestCases/use_tls_static.cc
new file mode 100644
index 0000000..50db23a
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_tls_static.cc
@@ -0,0 +1,21 @@
+// Test that statically allocated TLS space is included in the root set.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
+// RUN: LSAN_OPTIONS="" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+__thread void *tls_var;
+
+int main() {
+  tls_var = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", tls_var);
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/TestCases/use_unaligned.cc b/compiler-rt/test/lsan/TestCases/use_unaligned.cc
new file mode 100644
index 0000000..3e43ed4
--- /dev/null
+++ b/compiler-rt/test/lsan/TestCases/use_unaligned.cc
@@ -0,0 +1,23 @@
+// Test that unaligned pointers are detected correctly.
+// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=0" not %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=1" %run %t 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void *arr[2];
+
+int main() {
+  void *p = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+  char *char_arr = (char *)arr;
+  memcpy(char_arr + 1, &p, sizeof(p));
+  return 0;
+}
+// CHECK: Test alloc: [[ADDR:.*]].
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: [[ADDR]] (1337 bytes)
+// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
diff --git a/compiler-rt/test/lsan/lit.common.cfg b/compiler-rt/test/lsan/lit.common.cfg
new file mode 100644
index 0000000..ba9c283
--- /dev/null
+++ b/compiler-rt/test/lsan/lit.common.cfg
@@ -0,0 +1,51 @@
+# -*- Python -*-
+
+# Common configuration for running leak detection tests under LSan/ASan.
+
+import os
+
+def get_required_attr(config, attr_name):
+  attr_value = getattr(config, attr_name, None)
+  if attr_value == None:
+    lit_config.fatal(
+      "No attribute %r in test configuration! You may need to run "
+      "tests from your build directory or add this attribute "
+      "to lit.site.cfg " % attr_name)
+  return attr_value
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Choose between standalone and LSan+ASan modes.
+lsan_lit_test_mode = get_required_attr(config, 'lsan_lit_test_mode')
+if lsan_lit_test_mode == "Standalone":
+  config.name = "LeakSanitizer-Standalone"
+  lsan_cflags = ["-fsanitize=leak"]
+elif lsan_lit_test_mode == "AddressSanitizer":
+  config.name = "LeakSanitizer-AddressSanitizer"
+  lsan_cflags = ["-fsanitize=address"]
+  config.available_features.add('asan')
+else:
+  lit_config.fatal("Unknown LSan test mode: %r" % lsan_lit_test_mode)
+
+clang_cflags = ["-O0", "-m64"] + config.debug_info_flags
+clang_cxxflags = config.cxx_mode_flags + clang_cflags
+clang_lsan_cflags = clang_cflags + lsan_cflags
+clang_lsan_cxxflags = clang_cxxflags + lsan_cflags
+
+config.clang_cflags = clang_cflags
+config.clang_cxxflags = clang_cxxflags
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )
+config.substitutions.append( ("%clangxx ", build_invocation(clang_cxxflags)) )
+config.substitutions.append( ("%clang_lsan ", build_invocation(clang_lsan_cflags)) )
+config.substitutions.append( ("%clangxx_lsan ", build_invocation(clang_lsan_cxxflags)) )
+
+# LeakSanitizer tests are currently supported on x86-64 Linux and mips64 Linux only.
+if config.host_os not in ['Linux'] or config.host_arch not in ['x86_64', 'mips64']:
+  config.unsupported = True
+
+config.suffixes = ['.c', '.cc', '.cpp']
diff --git a/compiler-rt/test/lsan/lit.site.cfg.in b/compiler-rt/test/lsan/lit.site.cfg.in
new file mode 100644
index 0000000..7d2877b
--- /dev/null
+++ b/compiler-rt/test/lsan/lit.site.cfg.in
@@ -0,0 +1,8 @@
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Tool-specific config options.
+config.lsan_lit_test_mode = "@LSAN_LIT_TEST_MODE@"
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@LSAN_LIT_SOURCE_DIR@/lit.common.cfg")
diff --git a/compiler-rt/test/msan/CMakeLists.txt b/compiler-rt/test/msan/CMakeLists.txt
new file mode 100644
index 0000000..08786ee
--- /dev/null
+++ b/compiler-rt/test/msan/CMakeLists.txt
@@ -0,0 +1,23 @@
+set(MSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
+set(MSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND MSAN_TEST_DEPS msan)
+endif()
+
+if(COMPILER_RT_INCLUDE_TESTS AND COMPILER_RT_HAS_LIBCXX_SOURCES)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
+  list(APPEND MSAN_TEST_DEPS MsanUnitTests)
+endif()
+
+add_lit_testsuite(check-msan "Running the MemorySanitizer tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS ${MSAN_TEST_DEPS}
+  )
+set_target_properties(check-msan PROPERTIES FOLDER "MSan tests")
diff --git a/compiler-rt/test/msan/Linux/fopencookie.cc b/compiler-rt/test/msan/Linux/fopencookie.cc
new file mode 100644
index 0000000..e5b8f93
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/fopencookie.cc
@@ -0,0 +1,65 @@
+// Test fopencookie interceptor.
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -std=c++11 -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sanitizer/msan_interface.h>
+
+constexpr uintptr_t kMagicCookie = 0x12345678;
+
+static ssize_t cookie_read(void *cookie, char *buf, size_t size) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  memset(buf, 0, size);
+  return 0;
+}
+
+static ssize_t cookie_write(void *cookie, const char *buf, size_t size) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  __msan_check_mem_is_initialized(buf, size);
+  return 0;
+}
+
+static int cookie_seek(void *cookie, off64_t *offset, int whence) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  __msan_check_mem_is_initialized(offset, sizeof(*offset));
+  return 0;
+}
+
+static int cookie_close(void *cookie) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  return 0;
+}
+
+void PoisonStack() { char a[8192]; }
+
+void TestPoisonStack() {
+  // Verify that PoisonStack has poisoned the stack - otherwise this test is not
+  // testing anything.
+  char a;
+  assert(__msan_test_shadow(&a - 1000, 1) == 0);
+}
+
+int main() {
+  void *cookie = (void *)kMagicCookie;
+  FILE *f = fopencookie(cookie, "rw",
+                        {cookie_read, cookie_write, cookie_seek, cookie_close});
+  PoisonStack();
+  TestPoisonStack();
+  fseek(f, 100, SEEK_SET);
+  char buf[50];
+  fread(buf, 50, 1, f);
+  fwrite(buf, 50, 1, f);
+  fclose(f);
+
+  f = fopencookie(cookie, "rw", {nullptr, nullptr, nullptr, nullptr});
+  fseek(f, 100, SEEK_SET);
+  fread(buf, 50, 1, f);
+  fwrite(buf, 50, 1, f);
+  fclose(f);
+}
diff --git a/compiler-rt/test/msan/Linux/forkpty.cc b/compiler-rt/test/msan/Linux/forkpty.cc
new file mode 100644
index 0000000..ae5c7d9
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/forkpty.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_msan -O0 -g %s -lutil -o %t && %run %t
+#include <assert.h>
+#include <pty.h>
+
+#include <sanitizer/msan_interface.h>
+
+int
+main (int argc, char** argv)
+{
+  int master, slave;
+  openpty(&master, &slave, NULL, NULL, NULL);
+  assert(__msan_test_shadow(&master, sizeof(master)) == -1);
+  assert(__msan_test_shadow(&slave, sizeof(slave)) == -1);
+
+  int master2;
+  forkpty(&master2, NULL, NULL, NULL);
+  assert(__msan_test_shadow(&master2, sizeof(master2)) == -1);
+}
diff --git a/compiler-rt/test/msan/Linux/getresid.cc b/compiler-rt/test/msan/Linux/getresid.cc
new file mode 100644
index 0000000..f3c0914
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/getresid.cc
@@ -0,0 +1,25 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1
+
+#include <assert.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  uid_t uids[6];
+  assert(0 == __msan_test_shadow(uids, 6 * sizeof(uid_t)));
+  assert(0 == getresuid(&uids[0], &uids[2], &uids[4]));
+  for (int i = 0; i < 3; i++)
+    assert(sizeof(uid_t) ==
+           __msan_test_shadow(uids + 2 * i, 2 * sizeof(uid_t)));
+
+  gid_t gids[6];
+  assert(0 == __msan_test_shadow(gids, 6 * sizeof(gid_t)));
+  assert(0 == getresgid(&gids[0], &gids[2], &gids[4]));
+  for (int i = 0; i < 3; i++)
+    assert(sizeof(gid_t) ==
+           __msan_test_shadow(gids + 2 * i, 2 * sizeof(gid_t)));
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/glob.cc b/compiler-rt/test/msan/Linux/glob.cc
new file mode 100644
index 0000000..1481861
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/glob.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "glob_test_root/*a");
+
+  glob_t globbuf;
+  int res = glob(buf, 0, 0, &globbuf);
+
+  printf("%d %s\n", errno, strerror(errno));
+  assert(res == 0);
+  assert(globbuf.gl_pathc == 2);
+  printf("%zu\n", strlen(globbuf.gl_pathv[0]));
+  printf("%zu\n", strlen(globbuf.gl_pathv[1]));
+  printf("PASS\n");
+  // CHECK: PASS
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/glob_altdirfunc.cc b/compiler-rt/test/msan/Linux/glob_altdirfunc.cc
new file mode 100644
index 0000000..cb7fe09
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/glob_altdirfunc.cc
@@ -0,0 +1,78 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+static void my_gl_closedir(void *dir) {
+  if (!dir)
+    exit(1);
+  closedir((DIR *)dir);
+}
+
+static struct dirent *my_gl_readdir(void *dir) {
+  if (!dir)
+    exit(1);
+  struct dirent *d = readdir((DIR *)dir);
+  if (d) __msan_poison(d, d->d_reclen); // hehe
+  return d;
+}
+
+static void *my_gl_opendir(const char *s) {
+  assert(__msan_test_shadow(s, strlen(s) + 1) == (size_t)-1);
+  return opendir(s);
+}
+
+static int my_gl_lstat(const char *s, struct stat *st) {
+  assert(__msan_test_shadow(s, strlen(s) + 1) == (size_t)-1);
+  if (!st)
+    exit(1);
+  return lstat(s, st);
+}
+
+static int my_gl_stat(const char *s, struct stat *st) {
+  assert(__msan_test_shadow(s, strlen(s) + 1) == (size_t)-1);
+  if (!st)
+    exit(1);
+  return lstat(s, st);
+}
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "glob_test_root/*a");
+
+  glob_t globbuf;
+  globbuf.gl_closedir = my_gl_closedir;
+  globbuf.gl_readdir = my_gl_readdir;
+  globbuf.gl_opendir = my_gl_opendir;
+  globbuf.gl_lstat = my_gl_lstat;
+  globbuf.gl_stat = my_gl_stat;
+  for (int i = 0; i < 10000; ++i) {
+    int res = glob(buf, GLOB_ALTDIRFUNC | GLOB_MARK, 0, &globbuf);
+    assert(res == 0);
+    printf("%d %s\n", errno, strerror(errno));
+    assert(globbuf.gl_pathc == 2);
+    printf("%zu\n", strlen(globbuf.gl_pathv[0]));
+    printf("%zu\n", strlen(globbuf.gl_pathv[1]));
+    __msan_poison(globbuf.gl_pathv[0], strlen(globbuf.gl_pathv[0]) + 1);
+    __msan_poison(globbuf.gl_pathv[1], strlen(globbuf.gl_pathv[1]) + 1);
+    globfree(&globbuf);
+  }
+
+  printf("PASS\n");
+  // CHECK: PASS
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/glob_nomatch.cc b/compiler-rt/test/msan/Linux/glob_nomatch.cc
new file mode 100644
index 0000000..fa132c8
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/glob_nomatch.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "glob_test_root/*c");
+
+  glob_t globbuf;
+  int res = glob(buf, 0, 0, &globbuf);
+  assert(res == GLOB_NOMATCH);
+  assert(globbuf.gl_pathc == 0);
+  if (globbuf.gl_pathv == 0)
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/glob_test_root/aa b/compiler-rt/test/msan/Linux/glob_test_root/aa
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/glob_test_root/aa
diff --git a/compiler-rt/test/msan/Linux/glob_test_root/ab b/compiler-rt/test/msan/Linux/glob_test_root/ab
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/glob_test_root/ab
diff --git a/compiler-rt/test/msan/Linux/glob_test_root/ba b/compiler-rt/test/msan/Linux/glob_test_root/ba
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/glob_test_root/ba
diff --git a/compiler-rt/test/msan/Linux/ioctl_sound.cc b/compiler-rt/test/msan/Linux/ioctl_sound.cc
new file mode 100644
index 0000000..fb36c52
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/ioctl_sound.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O3 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <fcntl.h>
+#include <sound/asound.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char **argv) {
+  int fd = open("/dev/snd/controlC0", O_RDONLY);
+  if (fd < 0) {
+    printf("Unable to open sound device.");
+    return 0;
+  }
+  const unsigned sz = sizeof(snd_ctl_card_info);
+  void *info = malloc(sz + 1);
+  assert(__msan_test_shadow(info, sz) == 0);
+  assert(ioctl(fd, SNDRV_CTL_IOCTL_CARD_INFO, info) >= 0);
+  assert(__msan_test_shadow(info, sz + 1) == sz);
+  close(fd);
+  free(info);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/lit.local.cfg b/compiler-rt/test/msan/Linux/lit.local.cfg
new file mode 100644
index 0000000..57271b8
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/msan/Linux/mallinfo.cc b/compiler-rt/test/msan/Linux/mallinfo.cc
new file mode 100644
index 0000000..545ae93
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/mallinfo.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// REQUIRES: stable-runtime
+
+#include <assert.h>
+#include <malloc.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  struct mallinfo mi = mallinfo();
+  assert(__msan_test_shadow(&mi, sizeof(mi)) == -1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/mincore.cc b/compiler-rt/test/msan/Linux/mincore.cc
new file mode 100644
index 0000000..35f5713
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/mincore.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  unsigned char vec[20];
+  int res;
+  size_t PS = sysconf(_SC_PAGESIZE);
+  void *addr = mmap(nullptr, 20 * PS, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 10 * PS, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 10);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 10 * PS + 42, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 11);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 10 * PS - 1, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 10);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 1, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/obstack.cc b/compiler-rt/test/msan/Linux/obstack.cc
new file mode 100644
index 0000000..f1f53be
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/obstack.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -g -DPOSITIVE %s -o %t && not %run %t |& FileCheck %s
+
+#include <obstack.h>
+#include <sanitizer/msan_interface.h>
+#include <stdlib.h>
+
+static void *obstack_chunk_alloc(size_t sz) {
+  return malloc(sz);
+}
+
+static void obstack_chunk_free(void *p) {
+  free(p);
+}
+
+int main(void) {
+  obstack obs;
+  obstack_init(&obs);
+  for (size_t sz = 16; sz < 0xFFFF; sz *= 2) {
+    void *p = obstack_alloc(&obs, sz);
+    int data[10] = {0};
+    obstack_grow(&obs, &data, sizeof(data));
+    obstack_blank(&obs, sz);
+    obstack_grow(&obs, &data, sizeof(data));
+    obstack_int_grow(&obs, 13);
+    p = obstack_finish(&obs);
+#ifdef POSITIVE
+    if (sz == 4096) {
+      __msan_check_mem_is_initialized(p, sizeof(data));
+      __msan_check_mem_is_initialized(p, sizeof(data) + 1);
+    }
+    // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+    // CHECK: #0 0x{{.*}} in main{{.*}}obstack.cc:[[@LINE-30]]
+#endif
+  }
+  obstack_free(&obs, 0);
+}
diff --git a/compiler-rt/test/msan/Linux/process_vm_readv.cc b/compiler-rt/test/msan/Linux/process_vm_readv.cc
new file mode 100644
index 0000000..601c0d2
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/process_vm_readv.cc
@@ -0,0 +1,67 @@
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t -DPOSITIVE && not %run %t |& FileCheck %s
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <sanitizer/msan_interface.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+typedef ssize_t (*process_vm_readwritev_fn)(pid_t, const iovec *, unsigned long,
+                                            const iovec *, unsigned long,
+                                            unsigned long);
+
+int main(void) {
+  // This requires glibc 2.15.
+  process_vm_readwritev_fn libc_process_vm_readv =
+      (process_vm_readwritev_fn)dlsym(RTLD_NEXT, "process_vm_readv");
+  if (!libc_process_vm_readv) {
+// Exit with success, emulating the expected output.
+#ifdef POSITIVE
+    printf("process_vm_readv not found!\n");
+    printf(
+        "WARNING: MemorySanitizer: use-of-uninitialized-value (not really)\n");
+    return 1;
+#else
+    return 0;
+#endif
+  }
+
+  process_vm_readwritev_fn process_vm_readv =
+      (process_vm_readwritev_fn)dlsym(RTLD_DEFAULT, "process_vm_readv");
+  process_vm_readwritev_fn process_vm_writev =
+      (process_vm_readwritev_fn)dlsym(RTLD_DEFAULT, "process_vm_writev");
+
+  char a[100];
+  memset(a, 0xab, 100);
+
+  char b[100];
+  iovec iov_a[] = {{(void *)a, 20}, (void *)(a + 50), 10};
+  iovec iov_b[] = {{(void *)(b + 10), 10}, (void *)(b + 30), 20};
+
+  __msan_poison(&b, sizeof(b));
+  ssize_t res = process_vm_readv(getpid(), iov_b, 2, iov_a, 2, 0);
+  assert(res == 30);
+  __msan_check_mem_is_initialized(b + 10, 10);
+  __msan_check_mem_is_initialized(b + 30, 20);
+  assert(__msan_test_shadow(b + 9, 1) == 0);
+  assert(__msan_test_shadow(b + 20, 1) == 0);
+  assert(__msan_test_shadow(b + 29, 1) == 0);
+  assert(__msan_test_shadow(b + 50, 1) == 0);
+
+#ifdef POSITIVE
+  __msan_unpoison(&b, sizeof(b));
+  __msan_poison(b + 32, 1);
+  res = process_vm_writev(getpid(), iov_b, 2, iov_a, 2, 0);
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+#else
+  __msan_unpoison(&b, sizeof(b));
+  res = process_vm_writev(getpid(), iov_b, 2, iov_a, 2, 0);
+  assert(res == 30);
+#endif
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/sunrpc.cc b/compiler-rt/test/msan/Linux/sunrpc.cc
new file mode 100644
index 0000000..c92ad63
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/sunrpc.cc
@@ -0,0 +1,40 @@
+// RUN: %clangxx_msan -g -O0 -DTYPE=int -DFN=xdr_int %s -o %t && \
+// RUN:     %run %t 2>&1
+// RUN: %clangxx_msan -g -O0 -DTYPE=int -DFN=xdr_int -DUNINIT=1 %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -g -O0 -DTYPE=double -DFN=xdr_double %s -o %t && \
+// RUN:     %run %t 2>&1
+// RUN: %clangxx_msan -g -O0 -DTYPE=double -DFN=xdr_double -DUNINIT=1 %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -g -O0 -DTYPE=u_quad_t -DFN=xdr_u_longlong_t %s -o %t && \
+// RUN:     %run %t 2>&1
+// RUN: %clangxx_msan -g -O0 -DTYPE=u_quad_t -DFN=xdr_u_longlong_t -DUNINIT=1 %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <rpc/xdr.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  XDR xdrs;
+  char buf[100];
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_ENCODE);
+  TYPE x;
+#ifndef UNINIT
+  x = 42;
+#endif
+  bool_t res = FN(&xdrs, &x);
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{in main.*sunrpc.cc:}}[[@LINE-2]]
+  assert(res == TRUE);
+  xdr_destroy(&xdrs);
+
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_DECODE);
+  TYPE y;
+  res = FN(&xdrs, &y);
+  assert(res == TRUE);
+  assert(__msan_test_shadow(&y, sizeof(y)) == -1);
+  xdr_destroy(&xdrs);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/sunrpc_bytes.cc b/compiler-rt/test/msan/Linux/sunrpc_bytes.cc
new file mode 100644
index 0000000..477637a
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/sunrpc_bytes.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_msan -g -O0 %s -o %t && \
+// RUN:     %run %t 2>&1
+// RUN: %clangxx_msan -g -O0 -DUNINIT=1 %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <string.h>
+#include <rpc/xdr.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  XDR xdrs;
+  char buf[100];
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_ENCODE);
+  char s[20];
+#ifndef UNINIT
+  strcpy(s, "hello");
+#endif
+  char *sp = s;
+  unsigned sz = 6;
+  bool_t res = xdr_bytes(&xdrs, &sp, &sz, sizeof(s));
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{in main.*sunrpc_bytes.cc:}}[[@LINE-2]]
+  assert(res == TRUE);
+  xdr_destroy(&xdrs);
+
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_DECODE);
+  char s2[20];
+  char *sp2 = s2;
+  unsigned sz2;
+  res = xdr_bytes(&xdrs, &sp2, &sz2, sizeof(s2));
+  assert(res == TRUE);
+  assert(sz == sz2);
+  assert(strcmp(s, s2) == 0);
+  xdr_destroy(&xdrs);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/sunrpc_string.cc b/compiler-rt/test/msan/Linux/sunrpc_string.cc
new file mode 100644
index 0000000..350222f
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/sunrpc_string.cc
@@ -0,0 +1,35 @@
+// RUN: %clangxx_msan -g -O0 %s -o %t && \
+// RUN:     %run %t 2>&1
+// RUN: %clangxx_msan -g -O0 -DUNINIT=1 %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <string.h>
+#include <rpc/xdr.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  XDR xdrs;
+  char buf[100];
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_ENCODE);
+  char s[20];
+#ifndef UNINIT
+  strcpy(s, "hello");
+#endif
+  char *sp = s;
+  bool_t res = xdr_string(&xdrs, &sp, sizeof(s));
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{in main.*sunrpc_string.cc:}}[[@LINE-2]]
+  assert(res == TRUE);
+  xdr_destroy(&xdrs);
+
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_DECODE);
+  char s2[20];
+  char *sp2 = s2;
+  res = xdr_string(&xdrs, &sp2, sizeof(s2));
+  assert(res == TRUE);
+  assert(strcmp(s, s2) == 0);
+  xdr_destroy(&xdrs);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/syscalls.cc b/compiler-rt/test/msan/Linux/syscalls.cc
new file mode 100644
index 0000000..78dba36
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/syscalls.cc
@@ -0,0 +1,115 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <errno.h>
+#include <glob.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <linux/aio_abi.h>
+#include <sys/ptrace.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+
+#include <sanitizer/linux_syscall_hooks.h>
+#include <sanitizer/msan_interface.h>
+
+/* Test the presence of __sanitizer_syscall_ in the tool runtime, and general
+   sanity of their behaviour. */
+
+int main(int argc, char *argv[]) {
+  char buf[1000];
+  const int kTen = 10;
+  const int kFortyTwo = 42;
+  memset(buf, 0, sizeof(buf));
+  __msan_unpoison(buf, sizeof(buf));
+  __sanitizer_syscall_pre_recvmsg(0, buf, 0);
+  __sanitizer_syscall_pre_rt_sigpending(buf, kTen);
+  __sanitizer_syscall_pre_getdents(0, buf, kTen);
+  __sanitizer_syscall_pre_getdents64(0, buf, kTen);
+
+  __msan_unpoison(buf, sizeof(buf));
+  __sanitizer_syscall_post_recvmsg(0, 0, buf, 0);
+  __sanitizer_syscall_post_rt_sigpending(-1, buf, kTen);
+  __sanitizer_syscall_post_getdents(0, 0, buf, kTen);
+  __sanitizer_syscall_post_getdents64(0, 0, buf, kTen);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == -1);
+
+  __msan_unpoison(buf, sizeof(buf));
+  __sanitizer_syscall_post_recvmsg(kTen, 0, buf, 0);
+
+  // Tell the kernel that the output struct size is 10 bytes, verify that those
+  // bytes are unpoisoned, and the next byte is not.
+  __msan_poison(buf, kTen + 1);
+  __sanitizer_syscall_post_rt_sigpending(0, buf, kTen);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == kTen);
+
+  __msan_poison(buf, kTen + 1);
+  __sanitizer_syscall_post_getdents(kTen, 0, buf, kTen);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == kTen);
+
+  __msan_poison(buf, kTen + 1);
+  __sanitizer_syscall_post_getdents64(kTen, 0, buf, kTen);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == kTen);
+
+  __msan_poison(buf, sizeof(buf));
+  __sanitizer_syscall_post_clock_getres(0, 0, buf);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == sizeof(long) * 2);
+
+  __msan_poison(buf, sizeof(buf));
+  __sanitizer_syscall_post_clock_gettime(0, 0, buf);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == sizeof(long) * 2);
+
+  // Failed syscall does not write to the buffer.
+  __msan_poison(buf, sizeof(buf));
+  __sanitizer_syscall_post_clock_gettime(-1, 0, buf);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == 0);
+
+  __msan_poison(buf, sizeof(buf));
+  __sanitizer_syscall_post_read(5, 42, buf, 10);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == 5);
+
+  __msan_poison(buf, sizeof(buf));
+  __sanitizer_syscall_post_newfstatat(0, 5, "/path/to/file", buf, 0);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == sizeof(struct stat));
+
+  __msan_poison(buf, sizeof(buf));
+  int prio = 0;
+  __sanitizer_syscall_post_mq_timedreceive(kFortyTwo, 5, buf, sizeof(buf), &prio, 0);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == kFortyTwo);
+  assert(__msan_test_shadow(&prio, sizeof(prio)) == -1);
+
+  __msan_poison(buf, sizeof(buf));
+  __sanitizer_syscall_post_ptrace(0, PTRACE_PEEKUSER, kFortyTwo, 0xABCD, buf);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == sizeof(void *));
+
+  __msan_poison(buf, sizeof(buf));
+  struct iocb iocb[3];
+  struct iocb *iocbp[3] = { &iocb[0], &iocb[1], &iocb[2] };
+  memset(iocb, 0, sizeof(iocb));
+  iocb[0].aio_lio_opcode = IOCB_CMD_PREAD;
+  iocb[0].aio_buf = (__u64)buf;
+  iocb[0].aio_nbytes = 10;
+  iocb[1].aio_lio_opcode = IOCB_CMD_PREAD;
+  iocb[1].aio_buf = (__u64)(&buf[20]);
+  iocb[1].aio_nbytes = 15;
+  struct iovec vec[2] = { {&buf[40], 3}, {&buf[50], 20} };
+  iocb[2].aio_lio_opcode = IOCB_CMD_PREADV;
+  iocb[2].aio_buf = (__u64)(&vec);
+  iocb[2].aio_nbytes = 2;
+  __sanitizer_syscall_pre_io_submit(0, 3, &iocbp);
+  assert(__msan_test_shadow(buf, sizeof(buf)) == 10);
+  assert(__msan_test_shadow(buf + 20, sizeof(buf) - 20) == 15);
+  assert(__msan_test_shadow(buf + 40, sizeof(buf) - 40) == 3);
+  assert(__msan_test_shadow(buf + 50, sizeof(buf) - 50) == 20);
+
+  __msan_poison(buf, sizeof(buf));
+  char *p = buf;
+  __msan_poison(&p, sizeof(p));
+  __sanitizer_syscall_post_io_setup(0, 1, &p);
+  assert(__msan_test_shadow(&p, sizeof(p)) == -1);
+  assert(__msan_test_shadow(buf, sizeof(buf)) >= 32);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/tcgetattr.cc b/compiler-rt/test/msan/Linux/tcgetattr.cc
new file mode 100644
index 0000000..454b7fd
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/tcgetattr.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[]) {
+  int fd = getpt();
+  assert(fd >= 0);
+  
+  struct termios t;
+  int res = tcgetattr(fd, &t);
+  assert(!res);
+
+  if (t.c_iflag == 0)
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/xattr.cc b/compiler-rt/test/msan/Linux/xattr.cc
new file mode 100644
index 0000000..86cc2cd
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/xattr.cc
@@ -0,0 +1,145 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1
+
+#include <argz.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sanitizer/msan_interface.h>
+
+// Do not depend on libattr headers.
+#ifndef ENOATTR
+#define ENOATTR ENODATA
+#endif
+
+extern "C" {
+ssize_t listxattr(const char *path, char *list, size_t size);
+ssize_t llistxattr(const char *path, char *list, size_t size);
+ssize_t flistxattr(int fd, char *list, size_t size);
+ssize_t getxattr(const char *path, const char *name, void *value, size_t size);
+ssize_t lgetxattr(const char *path, const char *name, void *value, size_t size);
+ssize_t fgetxattr(int fd, const char *name, void *value, size_t size);
+}
+
+char g_path[1024];
+int g_fd;
+
+// Life before closures...
+ssize_t listxattr_wrapper(char *buf, size_t size) {
+  return listxattr(g_path, buf, size);
+}
+
+ssize_t llistxattr_wrapper(char *buf, size_t size) {
+  return llistxattr(g_path, buf, size);
+}
+
+ssize_t flistxattr_wrapper(char *buf, size_t size) {
+  return flistxattr(g_fd, buf, size);
+}
+
+ssize_t getxattr_wrapper(const char *name, char *buf, size_t size) {
+  return getxattr(g_path, name, buf, size);
+}
+
+ssize_t lgetxattr_wrapper(const char *name, char *buf, size_t size) {
+  return lgetxattr(g_path, name, buf, size);
+}
+
+ssize_t fgetxattr_wrapper(const char *name, char *buf, size_t size) {
+  return fgetxattr(g_fd, name, buf, size);
+}
+
+size_t test_list(ssize_t fun(char*, size_t), char **buf) {
+  int buf_size = 1024;
+  while (true) {
+    *buf = (char *)malloc(buf_size);
+    assert(__msan_test_shadow(*buf, buf_size) != -1);
+    ssize_t res = fun(*buf, buf_size);
+    if (res >= 0) {
+      assert(__msan_test_shadow(*buf, buf_size) == res);
+      return res;
+    }
+    if (errno == ENOTSUP) {
+      printf("Extended attributes are disabled. *xattr test is a no-op.\n");
+      exit(0);
+    }
+    assert(errno == ERANGE);
+    free(*buf);
+    buf_size *= 2;
+  }
+}
+
+// True means success. False means result inconclusive because we don't have
+// access to this attribute.
+bool test_get_single_attr(ssize_t fun(const char *, char *, size_t),
+                          const char *attr_name) {
+  char *buf;
+  int buf_size = 1024;
+  while (true) {
+    buf = (char *)malloc(buf_size);
+    assert(__msan_test_shadow(buf, buf_size) != -1);
+    ssize_t res = fun(attr_name, buf, buf_size);
+    if (res >= 0) {
+      assert(__msan_test_shadow(buf, buf_size) == res);
+      free(buf);
+      return true;
+    }
+    if (errno == ENOTSUP) {
+      printf("Extended attributes are disabled. *xattr test is a no-op.\n");
+      exit(0);
+    }
+    if (errno == ENOATTR)
+      return false;
+    assert(errno == ERANGE);
+    free(buf);
+    buf_size *= 2;
+  }
+}
+
+void test_get(ssize_t fun(const char *, char *, size_t), const char *attr_list,
+              size_t attr_list_size) {
+  // Try every attribute, until we see one we can access. Attribute names are
+  // null-separated strings in attr_list.
+  size_t attr_list_len = argz_count(attr_list, attr_list_size);
+  size_t argv_size = (attr_list_len + 1) * sizeof(char *);
+  char **attrs = (char **)malloc(argv_size);
+  argz_extract(attr_list, attr_list_size, attrs);
+  // TODO(smatveev): we need proper argz_* interceptors
+  __msan_unpoison(attrs, argv_size);
+  for (size_t i = 0; (i < attr_list_len) && attrs[i]; i++) {
+    if (test_get_single_attr(fun, attrs[i]))
+      return;
+  }
+  printf("*xattr test could not access any attributes.\n");
+}
+
+// TODO: set some attributes before trying to retrieve them with *getxattr.
+// Currently the list is empty, so *getxattr is not tested.
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  snprintf(g_path, sizeof(g_path), "%s/%s", argv[1], "xattr_test_root/a");
+
+  g_fd = open(g_path, O_RDONLY);
+  assert(g_fd);
+
+  char *attr_list;
+  size_t attr_list_size;
+  attr_list_size = test_list(listxattr_wrapper, &attr_list);
+  free(attr_list);
+  attr_list_size = test_list(llistxattr_wrapper, &attr_list);
+  free(attr_list);
+  attr_list_size = test_list(flistxattr_wrapper, &attr_list);
+
+  test_get(getxattr_wrapper, attr_list, attr_list_size);
+  test_get(lgetxattr_wrapper, attr_list, attr_list_size);
+  test_get(fgetxattr_wrapper, attr_list, attr_list_size);
+
+  free(attr_list);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/Linux/xattr_test_root/a b/compiler-rt/test/msan/Linux/xattr_test_root/a
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/Linux/xattr_test_root/a
diff --git a/compiler-rt/test/msan/Unit/lit.site.cfg.in b/compiler-rt/test/msan/Unit/lit.site.cfg.in
new file mode 100644
index 0000000..dc0e961
--- /dev/null
+++ b/compiler-rt/test/msan/Unit/lit.site.cfg.in
@@ -0,0 +1,14 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Load common config for all compiler-rt unit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
+
+# Setup config name.
+config.name = 'MemorySanitizer-Unit'
+
+# Setup test source and exec root. For unit tests, we define
+# it as build directory with MSan unit tests.
+# FIXME: Don't use hardcoded path to MSan unit tests.
+config.test_exec_root = "@COMPILER_RT_BINARY_DIR@/lib/msan/tests"
+config.test_source_root = config.test_exec_root
diff --git a/compiler-rt/test/msan/allocator_mapping.cc b/compiler-rt/test/msan/allocator_mapping.cc
new file mode 100644
index 0000000..f47d9a6
--- /dev/null
+++ b/compiler-rt/test/msan/allocator_mapping.cc
@@ -0,0 +1,36 @@
+// Test that a module constructor can not map memory over the MSan heap
+// (without MAP_FIXED, of course). Current implementation ensures this by
+// mapping the heap early, in __msan_init.
+//
+// RUN: %clangxx_msan -O0 %s -o %t_1
+// RUN: %clangxx_msan -O0 -DHEAP_ADDRESS=$(%run %t_1) %s -o %t_2 && %run %t_2
+//
+// This test only makes sense for the 64-bit allocator. The 32-bit allocator
+// does not have a fixed mapping. Exclude platforms that use the 32-bit
+// allocator.
+// UNSUPPORTED: mips64,aarch64
+
+#include <assert.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+
+#ifdef HEAP_ADDRESS
+struct A {
+  A() {
+    void *const hint = reinterpret_cast<void *>(HEAP_ADDRESS);
+    void *p = mmap(hint, 4096, PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    // This address must be already mapped. Check that mmap() succeeds, but at a
+    // different address.
+    assert(p != reinterpret_cast<void *>(-1));
+    assert(p != hint);
+  }
+} a;
+#endif
+
+int main() {
+  void *p = malloc(10);
+  printf("0x%zx\n", reinterpret_cast<size_t>(p) & (~0xfff));
+  free(p);
+}
diff --git a/compiler-rt/test/msan/allocator_returns_null.cc b/compiler-rt/test/msan/allocator_returns_null.cc
new file mode 100644
index 0000000..f4ea51d
--- /dev/null
+++ b/compiler-rt/test/msan/allocator_returns_null.cc
@@ -0,0 +1,81 @@
+// Test the behavior of malloc/calloc/realloc when the allocation size is huge.
+// By default (allocator_may_return_null=0) the process should crash.
+// With allocator_may_return_null=1 the allocator should return 0.
+//
+// RUN: %clangxx_msan -O0 %s -o %t
+// RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL
+// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
+// RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL
+// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
+// RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL
+// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
+// RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL
+// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
+// RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrNULL
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <limits>
+int main(int argc, char **argv) {
+  volatile size_t size = std::numeric_limits<size_t>::max() - 10000;
+  assert(argc == 2);
+  char *x = 0;
+  if (!strcmp(argv[1], "malloc")) {
+    fprintf(stderr, "malloc:\n");
+    x = (char*)malloc(size);
+  }
+  if (!strcmp(argv[1], "calloc")) {
+    fprintf(stderr, "calloc:\n");
+    x = (char*)calloc(size / 4, 4);
+  }
+
+  if (!strcmp(argv[1], "calloc-overflow")) {
+    fprintf(stderr, "calloc-overflow:\n");
+    volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max();
+    size_t kArraySize = 4096;
+    volatile size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
+    x = (char*)calloc(kArraySize, kArraySize2);
+  }
+
+  if (!strcmp(argv[1], "realloc")) {
+    fprintf(stderr, "realloc:\n");
+    x = (char*)realloc(0, size);
+  }
+  if (!strcmp(argv[1], "realloc-after-malloc")) {
+    fprintf(stderr, "realloc-after-malloc:\n");
+    char *t = (char*)malloc(100);
+    *t = 42;
+    x = (char*)realloc(t, size);
+    assert(*t == 42);
+  }
+  // The NULL pointer is printed differently on different systems, while (long)0
+  // is always the same.
+  fprintf(stderr, "x: %lx\n", (long)x);
+  return x != 0;
+}
+// CHECK-mCRASH: malloc:
+// CHECK-mCRASH: MemorySanitizer's allocator is terminating the process
+// CHECK-cCRASH: calloc:
+// CHECK-cCRASH: MemorySanitizer's allocator is terminating the process
+// CHECK-coCRASH: calloc-overflow:
+// CHECK-coCRASH: MemorySanitizer's allocator is terminating the process
+// CHECK-rCRASH: realloc:
+// CHECK-rCRASH: MemorySanitizer's allocator is terminating the process
+// CHECK-mrCRASH: realloc-after-malloc:
+// CHECK-mrCRASH: MemorySanitizer's allocator is terminating the process
+
+// CHECK-mNULL: malloc:
+// CHECK-mNULL: x: 0
+// CHECK-cNULL: calloc:
+// CHECK-cNULL: x: 0
+// CHECK-coNULL: calloc-overflow:
+// CHECK-coNULL: x: 0
+// CHECK-rNULL: realloc:
+// CHECK-rNULL: x: 0
+// CHECK-mrNULL: realloc-after-malloc:
+// CHECK-mrNULL: x: 0
diff --git a/compiler-rt/test/msan/backtrace.cc b/compiler-rt/test/msan/backtrace.cc
new file mode 100644
index 0000000..9cb883c
--- /dev/null
+++ b/compiler-rt/test/msan/backtrace.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <execinfo.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+__attribute__((noinline))
+void f() {
+  void *buf[10];
+  int sz = backtrace(buf, sizeof(buf) / sizeof(*buf));
+  assert(sz > 0);
+  for (int i = 0; i < sz; ++i)
+    if (!buf[i])
+      exit(1);
+  char **s = backtrace_symbols(buf, sz);
+  assert(s > 0);
+  for (int i = 0; i < sz; ++i)
+    printf("%d\n", (int)strlen(s[i]));
+}
+
+int main(void) {
+  f();
+  return 0;
+}
diff --git a/compiler-rt/test/msan/c-strdup.c b/compiler-rt/test/msan/c-strdup.c
new file mode 100644
index 0000000..b1e02b9
--- /dev/null
+++ b/compiler-rt/test/msan/c-strdup.c
@@ -0,0 +1,17 @@
+// RUN: %clang_msan -O0 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clang_msan -O1 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clang_msan -O2 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clang_msan -O3 %s -o %t && %run %t >%t.out 2>&1
+
+// Test that strdup in C programs is intercepted.
+// GLibC headers translate strdup to __strdup at -O1 and higher.
+
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char buf[] = "abc";
+  char *p = strdup(buf);
+  if (*p)
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/chained_origin.cc b/compiler-rt/test/msan/chained_origin.cc
new file mode 100644
index 0000000..ae72c10
--- /dev/null
+++ b/compiler-rt/test/msan/chained_origin.cc
@@ -0,0 +1,66 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-STACK < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DHEAP=1 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-HEAP < %t.out
+
+
+// RUN: %clangxx_msan -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-STACK < %t.out
+
+// RUN: %clangxx_msan -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -DHEAP=1 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-HEAP < %t.out
+
+
+#include <stdio.h>
+
+volatile int x, y;
+
+__attribute__((noinline))
+void fn_g(int a) {
+  x = a;
+}
+
+__attribute__((noinline))
+void fn_f(int a) {
+  fn_g(a);
+}
+
+__attribute__((noinline))
+void fn_h() {
+  y = x;
+}
+
+int main(int argc, char *argv[]) {
+#ifdef HEAP
+  int * volatile zz = new int;
+  int z = *zz;
+#else
+  int volatile z;
+#endif
+  fn_f(z);
+  fn_h();
+  return y;
+}
+
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK: {{#0 .* in main.*chained_origin.cc:47}}
+
+// CHECK: Uninitialized value was stored to memory at
+// CHECK: {{#0 .* in fn_h.*chained_origin.cc:35}}
+// CHECK: {{#1 .* in main.*chained_origin.cc:46}}
+
+// CHECK: Uninitialized value was stored to memory at
+// CHECK: {{#0 .* in fn_g.*chained_origin.cc:25}}
+// CHECK: {{#1 .* in fn_f.*chained_origin.cc:30}}
+// CHECK: {{#2 .* in main.*chained_origin.cc:45}}
+
+// CHECK-STACK: Uninitialized value was created by an allocation of 'z' in the stack frame of function 'main'
+// CHECK-STACK: {{#0 .* in main.*chained_origin.cc:38}}
+
+// CHECK-HEAP: Uninitialized value was created by a heap allocation
+// CHECK-HEAP: {{#1 .* in main.*chained_origin.cc:40}}
diff --git a/compiler-rt/test/msan/chained_origin_empty_stack.cc b/compiler-rt/test/msan/chained_origin_empty_stack.cc
new file mode 100644
index 0000000..f1ed66b
--- /dev/null
+++ b/compiler-rt/test/msan/chained_origin_empty_stack.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
+// RUN:     MSAN_OPTIONS=store_context_size=1 not %run %t 2>&1 | FileCheck %s
+
+// Test that stack trace for the intermediate store is not empty.
+
+// CHECK: MemorySanitizer: use-of-uninitialized-value
+// CHECK:   #0 {{.*}} in main
+
+// CHECK: Uninitialized value was stored to memory at
+// CHECK:   #0 {{.*}} in fn_g
+// CHECK-NOT: #1
+
+// CHECK: Uninitialized value was created by an allocation of 'z' in the stack frame of function 'main'
+// CHECK:   #0 {{.*}} in main
+
+#include <stdio.h>
+
+volatile int x;
+
+__attribute__((noinline))
+void fn_g(int a) {
+  x = a;
+}
+
+__attribute__((noinline))
+void fn_f(int a) {
+  fn_g(a);
+}
+
+int main(int argc, char *argv[]) {
+  int volatile z;
+  fn_f(z);
+  return x;
+}
diff --git a/compiler-rt/test/msan/chained_origin_limits.cc b/compiler-rt/test/msan/chained_origin_limits.cc
new file mode 100644
index 0000000..90fd09a
--- /dev/null
+++ b/compiler-rt/test/msan/chained_origin_limits.cc
@@ -0,0 +1,178 @@
+// This test program creates a very large number of unique histories.
+
+// Heap origin.
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O3 %s -o %t
+
+// RUN: MSAN_OPTIONS=origin_history_size=7 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=2 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK2 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_per_stack_limit=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-PER-STACK < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=7,origin_history_per_stack_limit=0 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+// Stack origin.
+// RUN: %clangxx_msan -DSTACK -fsanitize-memory-track-origins=2 -O3 %s -o %t
+
+// RUN: MSAN_OPTIONS=origin_history_size=7 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=2 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK2 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_per_stack_limit=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-PER-STACK < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=7,origin_history_per_stack_limit=0 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+
+// Heap origin, with calls.
+// RUN: %clangxx_msan -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -O3 %s -o %t
+
+// RUN: MSAN_OPTIONS=origin_history_size=7 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=2 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK2 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_per_stack_limit=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-PER-STACK < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=7,origin_history_per_stack_limit=0 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+
+// Stack origin, with calls.
+// RUN: %clangxx_msan -DSTACK -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -O3 %s -o %t
+
+// RUN: MSAN_OPTIONS=origin_history_size=7 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=2 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK2 < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_per_stack_limit=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-PER-STACK < %t.out
+
+// RUN: MSAN_OPTIONS=origin_history_size=7,origin_history_per_stack_limit=0 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK7 < %t.out
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static char *buf, *cur, *end;
+void init() {
+  buf = new char[1000];
+#ifdef STACK
+  char stackbuf[1000];
+  char *volatile p = stackbuf;
+  memcpy(buf, p, 1000);
+#endif
+  cur = buf;
+  end = buf + 1000;
+}
+
+void line_flush() {
+  char *p;
+  for (p = cur - 1; p >= buf; --p)
+    if (*p == '\n')
+      break;
+  if (p >= buf) {
+    size_t write_sz = p - buf + 1;
+    // write(2, buf, write_sz);
+    memmove(buf, p + 1, end - p - 1);
+    cur -= write_sz;
+  }
+}
+
+void buffered_write(const char *p, size_t sz) {
+  while (sz > 0) {
+    size_t copy_sz = end - cur;
+    if (sz < copy_sz) copy_sz = sz;
+    memcpy(cur, p, copy_sz);
+    cur += copy_sz;
+    sz -= copy_sz;
+    line_flush();
+  }
+}
+
+void fn1() {
+  buffered_write("a\n", 2);
+}
+
+void fn2() {
+  buffered_write("a\n", 2);
+}
+
+void fn3() {
+  buffered_write("a\n", 2);
+}
+
+int main(void) {
+  init();
+  for (int i = 0; i < 2000; ++i) {
+    fn1();
+    fn2();
+    fn3();
+  }
+  return buf[50];
+}
+
+// CHECK7: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was stored to memory at
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was stored to memory at
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was stored to memory at
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was stored to memory at
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was stored to memory at
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was stored to memory at
+// CHECK7-NOT: Uninitialized value was stored to memory at
+// CHECK7: Uninitialized value was created
+
+// CHECK2: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK2-NOT: Uninitialized value was stored to memory at
+// CHECK2: Uninitialized value was stored to memory at
+// CHECK2-NOT: Uninitialized value was stored to memory at
+// CHECK2: Uninitialized value was created
+
+// CHECK-PER-STACK: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK-PER-STACK: Uninitialized value was stored to memory at
+// CHECK-PER-STACK: in fn3
+// CHECK-PER-STACK: Uninitialized value was stored to memory at
+// CHECK-PER-STACK: in fn2
+// CHECK-PER-STACK: Uninitialized value was stored to memory at
+// CHECK-PER-STACK: in fn1
+// CHECK-PER-STACK: Uninitialized value was created
+
+// CHECK-UNLIMITED: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was stored to memory at
+// CHECK-UNLIMITED: Uninitialized value was created
diff --git a/compiler-rt/test/msan/chained_origin_memcpy.cc b/compiler-rt/test/msan/chained_origin_memcpy.cc
new file mode 100644
index 0000000..3fe0b77
--- /dev/null
+++ b/compiler-rt/test/msan/chained_origin_memcpy.cc
@@ -0,0 +1,61 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DOFFSET=0 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z1 < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DOFFSET=10 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z2 < %t.out
+
+
+// RUN: %clangxx_msan -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -DOFFSET=0 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z1 < %t.out
+
+// RUN: %clangxx_msan -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -DOFFSET=10 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z2 < %t.out
+
+
+#include <stdio.h>
+#include <string.h>
+
+int xx[10000];
+int yy[10000];
+volatile int idx = 30;
+
+__attribute__((noinline))
+void fn_g(int a, int b) {
+  xx[idx] = a; xx[idx + 10] = b;
+}
+
+__attribute__((noinline))
+void fn_f(int a, int b) {
+  fn_g(a, b);
+}
+
+__attribute__((noinline))
+void fn_h() {
+  memcpy(&yy, &xx, sizeof(xx));
+}
+
+int main(int argc, char *argv[]) {
+  int volatile z1;
+  int volatile z2;
+  fn_f(z1, z2);
+  fn_h();
+  return yy[idx + OFFSET];
+}
+
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK: {{#0 .* in main .*chained_origin_memcpy.cc:46}}
+
+// CHECK: Uninitialized value was stored to memory at
+// CHECK: {{#1 .* in fn_h.*chained_origin_memcpy.cc:38}}
+
+// CHECK: Uninitialized value was stored to memory at
+// CHECK: {{#0 .* in fn_g.*chained_origin_memcpy.cc:28}}
+// CHECK: {{#1 .* in fn_f.*chained_origin_memcpy.cc:33}}
+
+// CHECK-Z1: Uninitialized value was created by an allocation of 'z1' in the stack frame of function 'main'
+// CHECK-Z2: Uninitialized value was created by an allocation of 'z2' in the stack frame of function 'main'
+// CHECK: {{#0 .* in main.*chained_origin_memcpy.cc:41}}
diff --git a/compiler-rt/test/msan/chained_origin_with_signals.cc b/compiler-rt/test/msan/chained_origin_with_signals.cc
new file mode 100644
index 0000000..43dbdcc
--- /dev/null
+++ b/compiler-rt/test/msan/chained_origin_with_signals.cc
@@ -0,0 +1,36 @@
+// Check that stores in signal handlers are not recorded in origin history.
+// This is, in fact, undesired behavior caused by our chained origins
+// implementation being not async-signal-safe.
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -mllvm -msan-instrumentation-with-call-threshold=0 -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
+// RUN:     not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+#include <signal.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+volatile int x, y;
+
+void SignalHandler(int signo) {
+  y = x;
+}
+
+int main(int argc, char *argv[]) {
+  int volatile z;
+  x = z;
+
+  signal(SIGHUP, SignalHandler);
+  kill(getpid(), SIGHUP);
+  signal(SIGHUP, SIG_DFL);
+
+  return y;
+}
+
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK-NOT: in SignalHandler
diff --git a/compiler-rt/test/msan/check_mem_is_initialized.cc b/compiler-rt/test/msan/check_mem_is_initialized.cc
new file mode 100644
index 0000000..e1d3b11
--- /dev/null
+++ b/compiler-rt/test/msan/check_mem_is_initialized.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <sanitizer/msan_interface.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+  int *volatile p = (int *)malloc(sizeof(int));
+
+  __msan_check_mem_is_initialized(p, sizeof(*p));
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*check_mem_is_initialized.cc:}}[[@LINE-2]]
+
+  // CHECK-ORIGINS: Uninitialized value was created by a heap allocation
+  // CHECK-ORIGINS: {{#0 0x.* in .*malloc}}
+  // CHECK-ORIGINS: {{#1 0x.* in main .*check_mem_is_initialized.cc:}}[[@LINE-8]]
+  return 0;
+}
diff --git a/compiler-rt/test/msan/coverage-levels.cc b/compiler-rt/test/msan/coverage-levels.cc
new file mode 100644
index 0000000..d71bfec
--- /dev/null
+++ b/compiler-rt/test/msan/coverage-levels.cc
@@ -0,0 +1,28 @@
+// Test various levels of coverage
+//
+// RUN: %clangxx_msan -DINIT_VAR=1 -O1 -fsanitize-coverage=func  %s -o %t
+// RUN: mkdir -p %T/coverage-levels
+// RUN: MSAN_OPTIONS=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1 --check-prefix=CHECK_NOWARN
+// RUN: %clangxx_msan -O1 -fsanitize-coverage=func  %s -o %t
+// RUN: MSAN_OPTIONS=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1 --check-prefix=CHECK_WARN
+// RUN: %clangxx_msan -O1 -fsanitize-coverage=bb  %s -o %t
+// RUN: MSAN_OPTIONS=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2 --check-prefix=CHECK_WARN
+// RUN: %clangxx_msan -O1 -fsanitize-coverage=edge  %s -o %t
+// RUN: MSAN_OPTIONS=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3 --check-prefix=CHECK_WARN
+//
+volatile int sink;
+int main(int argc, char **argv) {
+  int var;
+#if INIT_VAR
+  var = 0;
+#endif
+  if (argc == 0)
+    sink = 0;
+  return *(volatile int*)&var;
+}
+
+// CHECK_WARN: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK_NOWARN-NOT: ERROR
+// CHECK1:  1 PCs written
+// CHECK2:  2 PCs written
+// CHECK3:  3 PCs written
diff --git a/compiler-rt/test/msan/ctermid.cc b/compiler-rt/test/msan/ctermid.cc
new file mode 100644
index 0000000..a2818e6
--- /dev/null
+++ b/compiler-rt/test/msan/ctermid.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+
+#include <sanitizer/msan_interface.h>
+#include <stdio.h>
+#include <string.h>
+
+int main(void) {
+  unsigned char s[L_ctermid + 1];
+  char *res = ctermid((char *)s);
+  if (res)
+    printf("%zd\n", strlen(res));
+  return 0;
+}
diff --git a/compiler-rt/test/msan/cxa_atexit.cc b/compiler-rt/test/msan/cxa_atexit.cc
new file mode 100644
index 0000000..70384b9
--- /dev/null
+++ b/compiler-rt/test/msan/cxa_atexit.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
+
+// PR17377: C++ module destructors get stale argument shadow.
+
+#include <stdio.h>
+#include <stdlib.h>
+class A {
+public:
+  // This destructor get stale argument shadow left from the call to f().
+  ~A() {
+    if (this)
+      exit(0);
+  }
+};
+
+A a;
+
+__attribute__((noinline))
+void f(long x) {
+}
+
+int main(void) {
+  long  x;
+  long * volatile p = &x;
+  // This call poisons TLS shadow for the first function argument.
+  f(*p);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/death-callback.cc b/compiler-rt/test/msan/death-callback.cc
new file mode 100644
index 0000000..08cf291
--- /dev/null
+++ b/compiler-rt/test/msan/death-callback.cc
@@ -0,0 +1,39 @@
+// RUN: %clangxx_msan -DERROR %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB
+// RUN: %clangxx_msan -DERROR -DMSANCB_SET %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CB
+// RUN: %clangxx_msan -DERROR -DMSANCB_SET -DMSANCB_CLEAR %s -o %t && not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB
+// RUN: %clangxx_msan -DMSANCB_SET %s -o %t && %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB
+
+#include <sanitizer/msan_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void cb(void) {
+  fprintf(stderr, "msan-death-callback\n");
+}
+
+int main(int argc, char **argv) {
+  int *volatile p = (int *)malloc(sizeof(int));
+  *p = 42;
+  free(p);
+
+#ifdef MSANCB_SET
+  __msan_set_death_callback(cb);
+#endif
+
+#ifdef MSANCB_CLEAR
+  __msan_set_death_callback(0);
+#endif
+
+#ifdef ERROR
+  if (*p)
+    exit(0);
+#endif
+  // CHECK-CB: msan-death-callback
+  // CHECK-NOCB-NOT: msan-death-callback
+  fprintf(stderr, "done\n");
+  return 0;
+}
diff --git a/compiler-rt/test/msan/default_blacklist.cc b/compiler-rt/test/msan/default_blacklist.cc
new file mode 100644
index 0000000..32cc022
--- /dev/null
+++ b/compiler-rt/test/msan/default_blacklist.cc
@@ -0,0 +1,3 @@
+// Test that MSan uses the default blacklist from resource directory.
+// RUN: %clangxx_msan -### %s 2>&1 | FileCheck %s
+// CHECK: fsanitize-blacklist={{.*}}msan_blacklist.txt
diff --git a/compiler-rt/test/msan/dlerror.cc b/compiler-rt/test/msan/dlerror.cc
new file mode 100644
index 0000000..0ad5b35
--- /dev/null
+++ b/compiler-rt/test/msan/dlerror.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+//
+// AArch64 shows fails with uninitialized bytes in __interceptor_strcmp from
+// dlfcn/dlerror.c:107 (glibc).
+// XFAIL: aarch64
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string.h>
+
+int main(void) {
+  void *p = dlopen("/bad/file/name", RTLD_NOW);
+  assert(!p);
+  char *s = dlerror();
+  printf("%s, %zu\n", s, strlen(s));
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dlopen_executable.cc b/compiler-rt/test/msan/dlopen_executable.cc
new file mode 100644
index 0000000..ac8a14b
--- /dev/null
+++ b/compiler-rt/test/msan/dlopen_executable.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdlib.h>
+
+static int my_global;
+
+int main(void) {
+  int *uninit = (int*)malloc(sizeof(int));
+  my_global = *uninit;
+  void *p = dlopen(0, RTLD_NOW);
+  assert(p && "failed to get handle to executable");
+  return my_global;
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #0 {{.*}} in main{{.*}}dlopen_executable.cc:[[@LINE-2]]
+}
diff --git a/compiler-rt/test/msan/dso-origin.cc b/compiler-rt/test/msan/dso-origin.cc
new file mode 100644
index 0000000..7f62449
--- /dev/null
+++ b/compiler-rt/test/msan/dso-origin.cc
@@ -0,0 +1,48 @@
+// Build a library with origin tracking and an executable w/o origin tracking.
+// Test that origin tracking is enabled at runtime.
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -DBUILD_SO -fPIC -shared -o %t-so.so
+// RUN: %clangxx_msan -O0 %s %t-so.so -o %t && not %run %t 2>&1 | FileCheck %s
+
+#ifdef BUILD_SO
+
+#include <stdlib.h>
+
+extern "C" {
+void my_access(int *p) {
+  volatile int tmp;
+  // Force initialize-ness check.
+  if (*p)
+    tmp = 1;
+}
+
+void *my_alloc(unsigned sz) {
+  return malloc(sz);
+}
+}  // extern "C"
+
+#else  // BUILD_SO
+
+#include <stdlib.h>
+
+extern "C" {
+void my_access(int *p);
+void *my_alloc(unsigned sz);
+}
+
+int main(int argc, char **argv) {
+  int *x = (int *)my_alloc(sizeof(int));
+  my_access(x);
+  delete x;
+
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in my_access .*dso-origin.cc:}}
+  // CHECK: {{#1 0x.* in main .*dso-origin.cc:}}[[@LINE-5]]
+  // CHECK: Uninitialized value was created by a heap allocation
+  // CHECK: {{#0 0x.* in .*malloc}}
+  // CHECK: {{#1 0x.* in my_alloc .*dso-origin.cc:}}
+  // CHECK: {{#2 0x.* in main .*dso-origin.cc:}}[[@LINE-10]]
+  // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*dso-origin.cc:.* my_access}}
+  return 0;
+}
+
+#endif  // BUILD_SO
diff --git a/compiler-rt/test/msan/dtls_test.c b/compiler-rt/test/msan/dtls_test.c
new file mode 100644
index 0000000..4036f71
--- /dev/null
+++ b/compiler-rt/test/msan/dtls_test.c
@@ -0,0 +1,60 @@
+/* RUN: %clang_msan -g %s -o %t
+   RUN: %clang_msan -g %s -DBUILD_SO -fPIC -o %t-so.so -shared
+   RUN: %run %t 2>&1
+
+   Regression test for a bug in msan/glibc integration,
+   see https://sourceware.org/bugzilla/show_bug.cgi?id=16291
+   and https://code.google.com/p/memory-sanitizer/issues/detail?id=44
+*/
+
+#ifndef BUILD_SO
+#include <assert.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+typedef long *(* get_t)();
+get_t GetTls;
+void *Thread1(void *unused) {
+  long uninitialized;
+  long *x = GetTls();
+  if (*x)
+    fprintf(stderr, "bar\n");
+  *x = uninitialized;
+  fprintf(stderr, "stack: %p dtls: %p\n", &x, x);
+  return 0;
+}
+
+void *Thread2(void *unused) {
+  long *x = GetTls();
+  fprintf(stderr, "stack: %p dtls: %p\n", &x, x);
+  if (*x)
+    fprintf(stderr, "foo\n");   // False negative here.
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  char path[4096];
+  snprintf(path, sizeof(path), "%s-so.so", argv[0]);
+  int i;
+
+  void *handle = dlopen(path, RTLD_LAZY);
+  if (!handle) fprintf(stderr, "%s\n", dlerror());
+  assert(handle != 0);
+  GetTls = (get_t)dlsym(handle, "GetTls");
+  assert(dlerror() == 0);
+
+  pthread_t t;
+  pthread_create(&t, 0, Thread1, 0);
+  pthread_join(t, 0);
+  pthread_create(&t, 0, Thread2, 0);
+  pthread_join(t, 0);
+  return 0;
+}
+#else  // BUILD_SO
+__thread long huge_thread_local_array[1 << 17];
+long *GetTls() {
+  return &huge_thread_local_array[0];
+}
+#endif
diff --git a/compiler-rt/test/msan/dtor-base-access.cc b/compiler-rt/test/msan/dtor-base-access.cc
new file mode 100644
index 0000000..bed66fb
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-base-access.cc
@@ -0,0 +1,49 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+
+class Base {
+ public:
+  int *x_ptr;
+  Base(int *y_ptr) {
+    // store value of subclass member
+    x_ptr = y_ptr;
+  }
+  virtual ~Base();
+};
+
+class Derived : public Base {
+ public:
+  int y;
+  Derived():Base(&y) {
+    y = 10;
+  }
+  ~Derived();
+};
+
+Base::~Base() {
+  // ok access its own member
+  assert(__msan_test_shadow(&this->x_ptr, sizeof(this->x_ptr)) == -1);
+  // bad access subclass member
+  assert(__msan_test_shadow(this->x_ptr, sizeof(*this->x_ptr)) != -1);
+}
+
+Derived::~Derived() {
+  // ok to access its own members
+  assert(__msan_test_shadow(&this->y, sizeof(this->y)) == -1);
+  // ok access base class members
+  assert(__msan_test_shadow(&this->x_ptr, sizeof(this->x_ptr)) == -1);
+}
+
+int main() {
+  Derived *d = new Derived();
+  assert(__msan_test_shadow(&d->x_ptr, sizeof(d->x_ptr)) == -1);
+  d->~Derived();
+  assert(__msan_test_shadow(&d->x_ptr, sizeof(d->x_ptr)) != -1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-bit-fields.cc b/compiler-rt/test/msan/dtor-bit-fields.cc
new file mode 100644
index 0000000..4c6e322
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-bit-fields.cc
@@ -0,0 +1,70 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+
+// TODO: remove empty dtors when msan use-after-dtor poisons
+// for trivial classes with undeclared dtors
+
+// 24 bytes total
+struct Packed {
+  // Packed into 4 bytes
+  unsigned int a : 1;
+  unsigned int b : 1;
+  // Force alignment to next 4 bytes
+  unsigned int   : 0;
+  unsigned int c : 1;
+  // Force alignment, 8 more bytes
+  double d = 5.0;
+  // 4 bytes
+  unsigned int e : 1;
+  ~Packed() {}
+};
+
+// 1 byte total
+struct Empty {
+  unsigned int : 0;
+  ~Empty() {}
+};
+
+// 4 byte total
+struct Simple {
+  unsigned int a : 1;
+  ~Simple() {}
+};
+
+struct Anon {
+  unsigned int a : 1;
+  unsigned int b : 2;
+  unsigned int   : 0;
+  unsigned int c : 1;
+  ~Anon() {}
+};
+
+int main() {
+  Packed *p = new Packed();
+  p->~Packed();
+  for (int i = 0; i < 4; i++)
+    assert(__msan_test_shadow(((char*)p) + i, sizeof(char)) != -1);
+  assert(__msan_test_shadow(&p->d, sizeof(double)) != -1);
+  assert(__msan_test_shadow(((char*)(&p->d)) + sizeof(double), sizeof(char)) !=
+         -1);
+
+  Empty *e = new Empty();
+  e->~Empty();
+  assert(__msan_test_shadow(e, sizeof(*e)) != -1);
+
+  Simple *s = new Simple();
+  s->~Simple();
+  assert(__msan_test_shadow(s, sizeof(*s)) != -1);
+
+  Anon *a = new Anon();
+  a->~Anon();
+  assert(__msan_test_shadow(a, sizeof(*a)) != -1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-derived-class.cc b/compiler-rt/test/msan/dtor-derived-class.cc
new file mode 100644
index 0000000..1f3db7f
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-derived-class.cc
@@ -0,0 +1,39 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1  %run %t >%t.out 2>&1
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+
+struct Base {
+  int x;
+  Base() { x = 5; }
+  virtual ~Base() {}
+};
+
+struct Derived : public Base {
+  int y;
+  Derived() { y = 10; }
+  ~Derived() {}
+};
+
+int main() {
+  Derived *d = new Derived();
+  d->~Derived();
+
+  // Verify that local pointer is unpoisoned, and that the object's
+  // members are.
+  assert(__msan_test_shadow(&d, sizeof(d)) == -1);
+  assert(__msan_test_shadow(&d->x, sizeof(d->x)) != -1);
+  assert(__msan_test_shadow(&d->y, sizeof(d->y)) != -1);
+
+  Base *b = new Derived();
+  b->~Base();
+
+  // Verify that local pointer is unpoisoned, and that the object's
+  // members are.
+  assert(__msan_test_shadow(&b, sizeof(b)) == -1);
+  assert(__msan_test_shadow(&b->x, sizeof(b->x)) != -1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-member.cc b/compiler-rt/test/msan/dtor-member.cc
new file mode 100644
index 0000000..13a0599
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-member.cc
@@ -0,0 +1,48 @@
+// RUN: %clangxx_msan %s -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1  %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan %s -fsanitize=memory -o %t && MSAN_OPTIONS=poison_in_dtor=1  %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-NO-FLAG < %t.out
+
+// RUN: %clangxx_msan -fsanitize=memory -fsanitize-memory-use-after-dtor %s -o %t && MSAN_OPTIONS=poison_in_dtor=0 %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-NO-FLAG < %t.out
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+#include <stdio.h>
+#include <new>
+
+struct Simple {
+  int x_;
+  Simple() {
+    x_ = 5;
+  }
+  ~Simple() { }
+};
+
+int main() {
+  unsigned long buf[1];
+  assert(sizeof(Simple) <= sizeof(buf));
+
+  // The placement new operator forces the object to be constructed in the
+  // memory location &buf. Since objects made in this way must be explicitly
+  // destroyed, there are no implicit calls inserted that would interfere with
+  // test behavior.
+  Simple *s = new(&buf) Simple();
+  s->~Simple();
+
+  if (__msan_test_shadow(s, sizeof(*s)) != -1)
+    printf("s is poisoned\n");
+  else
+    printf("s is not poisoned\n");
+  // CHECK: s is poisoned
+  // CHECK-NO-FLAG: s is not poisoned
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-multiple-inheritance-nontrivial-class-members.cc b/compiler-rt/test/msan/dtor-multiple-inheritance-nontrivial-class-members.cc
new file mode 100644
index 0000000..dd79e3c
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-multiple-inheritance-nontrivial-class-members.cc
@@ -0,0 +1,152 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+
+template <class T> class Vector {
+public:
+  int size;
+  ~Vector() {
+    assert(__msan_test_shadow(&this->size, sizeof(this->size)) == -1);
+  }
+};
+
+struct VirtualBase {
+public:
+  Vector<int> virtual_v;
+  int virtual_a;
+  // Pointer to subclass member
+  int *intermediate_a_ptr;
+
+  VirtualBase() {
+    virtual_v.size = 1;
+    virtual_a = 9;
+  }
+  void set_ptr(int *intermediate_a) {
+    this->intermediate_a_ptr = intermediate_a;
+  }
+  virtual ~VirtualBase() {
+    assert(__msan_test_shadow(&virtual_v, sizeof(virtual_v)) == -1);
+    assert(__msan_test_shadow(&virtual_a, sizeof(virtual_a)) == -1);
+    // Derived class member is poisoned
+    assert(__msan_test_shadow(intermediate_a_ptr,
+                              sizeof(*intermediate_a_ptr)) != -1);
+  }
+};
+
+struct Intermediate : virtual public VirtualBase {
+public:
+  int intermediate_a;
+
+  Intermediate() { intermediate_a = 5; }
+  virtual ~Intermediate() {
+    assert(__msan_test_shadow(&this->intermediate_a,
+                              sizeof(this->intermediate_a)) == -1);
+    // Members inherited from VirtualBase unpoisoned
+    assert(__msan_test_shadow(&virtual_v, sizeof(virtual_v)) == -1);
+    assert(__msan_test_shadow(&virtual_a, sizeof(virtual_a)) == -1);
+    assert(__msan_test_shadow(intermediate_a_ptr,
+                              sizeof(*intermediate_a_ptr)) == -1);
+  }
+};
+
+struct Base {
+  int base_a;
+  Vector<int> base_v;
+  double base_b;
+  // Pointers to subclass members
+  int *derived_a_ptr;
+  Vector<int> *derived_v1_ptr;
+  Vector<int> *derived_v2_ptr;
+  double *derived_b_ptr;
+  double *derived_c_ptr;
+
+  Base(int *derived_a, Vector<int> *derived_v1, Vector<int> *derived_v2,
+       double *derived_b, double *derived_c) {
+    base_a = 2;
+    base_v.size = 1;
+    base_b = 13.2324;
+    derived_a_ptr = derived_a;
+    derived_v1_ptr = derived_v1;
+    derived_v2_ptr = derived_v2;
+    derived_b_ptr = derived_b;
+    derived_c_ptr = derived_c;
+  }
+  virtual ~Base() {
+    assert(__msan_test_shadow(&base_a, sizeof(base_a)) == -1);
+    assert(__msan_test_shadow(&base_v, sizeof(base_v)) == -1);
+    assert(__msan_test_shadow(&base_b, sizeof(base_b)) == -1);
+    // Derived class members are poisoned
+    assert(__msan_test_shadow(derived_a_ptr, sizeof(*derived_a_ptr)) != -1);
+    assert(__msan_test_shadow(derived_v1_ptr, sizeof(*derived_v1_ptr)) != -1);
+    assert(__msan_test_shadow(derived_v2_ptr, sizeof(*derived_v2_ptr)) != -1);
+    assert(__msan_test_shadow(derived_b_ptr, sizeof(*derived_b_ptr)) != -1);
+    assert(__msan_test_shadow(derived_c_ptr, sizeof(*derived_c_ptr)) != -1);
+  }
+};
+
+struct Derived : public Base, public Intermediate {
+  int derived_a;
+  Vector<int> derived_v1;
+  Vector<int> derived_v2;
+  double derived_b;
+  double derived_c;
+
+  Derived()
+      : Base(&derived_a, &derived_v1, &derived_v2, &derived_b, &derived_c) {
+    derived_a = 5;
+    derived_v1.size = 1;
+    derived_v2.size = 1;
+    derived_b = 7;
+    derived_c = 10;
+  }
+  ~Derived() {
+    assert(__msan_test_shadow(&derived_a, sizeof(derived_a)) == -1);
+    assert(__msan_test_shadow(&derived_v1, sizeof(derived_v1)) == -1);
+    assert(__msan_test_shadow(&derived_v2, sizeof(derived_v2)) == -1);
+    assert(__msan_test_shadow(&derived_b, sizeof(derived_b)) == -1);
+    assert(__msan_test_shadow(&derived_c, sizeof(derived_c)) == -1);
+  }
+};
+
+int main() {
+  Derived *d = new Derived();
+  d->set_ptr(&d->intermediate_a);
+
+  // Keep track of members of VirtualBase, since the virtual base table
+  // is inaccessible after destruction
+  Vector<int> *temp_virtual_v = &d->virtual_v;
+  int *temp_virtual_a = &d->virtual_a;
+  int **temp_intermediate_a_ptr = &d->intermediate_a_ptr;
+
+  d->~Derived();
+  assert(__msan_test_shadow(&d->derived_a, sizeof(d->derived_a)) != -1);
+  assert(__msan_test_shadow(&d->derived_v1, sizeof(d->derived_v1)) != -1);
+  assert(__msan_test_shadow(&d->derived_v2, sizeof(d->derived_v2)) != -1);
+  assert(__msan_test_shadow(&d->derived_b, sizeof(d->derived_b)) != -1);
+  assert(__msan_test_shadow(&d->derived_c, sizeof(d->derived_c)) != -1);
+
+  // Inherited from base
+  assert(__msan_test_shadow(&d->base_a, sizeof(d->base_a)) != -1);
+  assert(__msan_test_shadow(&d->base_v, sizeof(d->base_v)) != -1);
+  assert(__msan_test_shadow(&d->base_b, sizeof(d->base_b)) != -1);
+  assert(__msan_test_shadow(&d->derived_a_ptr, sizeof(d->derived_a_ptr)) != -1);
+  assert(__msan_test_shadow(&d->derived_v1_ptr, sizeof(d->derived_v1_ptr)) !=
+         -1);
+  assert(__msan_test_shadow(&d->derived_v2_ptr, sizeof(d->derived_v2_ptr)) !=
+         -1);
+  assert(__msan_test_shadow(&d->derived_b_ptr, sizeof(d->derived_b_ptr)) != -1);
+  assert(__msan_test_shadow(&d->derived_c_ptr, sizeof(d->derived_c_ptr)) != -1);
+
+  // Inherited from intermediate
+  assert(__msan_test_shadow(temp_virtual_v, sizeof(*temp_virtual_v)) != -1);
+  assert(__msan_test_shadow(temp_virtual_a, sizeof(*temp_virtual_a)) != -1);
+  assert(__msan_test_shadow(temp_intermediate_a_ptr,
+                            sizeof(*temp_intermediate_a_ptr)) != -1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-multiple-inheritance.cc b/compiler-rt/test/msan/dtor-multiple-inheritance.cc
new file mode 100644
index 0000000..0704bf7
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-multiple-inheritance.cc
@@ -0,0 +1,98 @@
+// Defines diamond multiple inheritance structure
+//   A
+//  / \
+// B   C
+//  \ /
+//   Derived
+
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+
+int *temp_x;
+int *temp_y;
+int *temp_z;
+int *temp_w;
+
+class A {
+public:
+  int x;
+  A() { x = 5; }
+  virtual ~A() {
+    assert(__msan_test_shadow(&this->x, sizeof(this->x) == -1));
+    // Memory owned by subclasses is poisoned.
+    assert(__msan_test_shadow(temp_y, sizeof(*temp_y)) != -1);
+    assert(__msan_test_shadow(temp_z, sizeof(*temp_z)) != -1);
+    assert(__msan_test_shadow(temp_w, sizeof(*temp_w)) != -1);
+  }
+};
+
+struct B : virtual public A {
+public:
+  int y;
+  B() { y = 10; }
+  virtual ~B() {
+    assert(__msan_test_shadow(&this->y, sizeof(this->y)) == -1);
+    // Memory accessible via vtable still reachable.
+    assert(__msan_test_shadow(&this->x, sizeof(this->x)) == -1);
+    // Memory in sibling and subclass is poisoned.
+    assert(__msan_test_shadow(temp_z, sizeof(*temp_z)) != -1);
+    assert(__msan_test_shadow(temp_w, sizeof(*temp_w)) != -1);
+  }
+};
+
+struct C : virtual public A {
+public:
+  int z;
+  C() { z = 15; }
+  virtual ~C() {
+    assert(__msan_test_shadow(&this->z, sizeof(this->z)) == -1);
+    // Memory accessible via vtable still reachable.
+    assert(__msan_test_shadow(&this->x, sizeof(this->x)) == -1);
+    // Sibling class is unpoisoned.
+    assert(__msan_test_shadow(temp_y, sizeof(*temp_y)) == -1);
+    // Memory in subclasses is poisoned.
+    assert(__msan_test_shadow(temp_w, sizeof(*temp_w)) != -1);
+  }
+};
+
+class Derived : public B, public C {
+public:
+  int w;
+  Derived() { w = 10; }
+  ~Derived() {
+    assert(__msan_test_shadow(&this->x, sizeof(this->x)) == -1);
+    // Members accessed through the vtable are still accessible.
+    assert(__msan_test_shadow(&this->y, sizeof(this->y)) == -1);
+    assert(__msan_test_shadow(&this->z, sizeof(this->z)) == -1);
+    assert(__msan_test_shadow(&this->w, sizeof(this->w)) == -1);
+  }
+};
+
+
+int main() {
+  Derived *d = new Derived();
+
+  // Keep track of members inherited from virtual bases,
+  // since the virtual base table is inaccessible after destruction.
+  temp_x = &d->x;
+  temp_y = &d->y;
+  temp_z = &d->z;
+  temp_w = &d->w;
+
+  // Order of destruction: Derived, C, B, A
+  d->~Derived();
+  // Verify that local pointer is unpoisoned, and that the object's
+  // members are.
+  assert(__msan_test_shadow(&d, sizeof(d)) == -1);
+  assert(__msan_test_shadow(temp_x, sizeof(*temp_x)) != -1);
+  assert(__msan_test_shadow(temp_y, sizeof(*temp_y)) != -1);
+  assert(__msan_test_shadow(temp_z, sizeof(*temp_z)) != -1);
+  assert(__msan_test_shadow(temp_w, sizeof(*temp_w)) != -1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-trivial-class-members.cc b/compiler-rt/test/msan/dtor-trivial-class-members.cc
new file mode 100644
index 0000000..8960dc6
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-trivial-class-members.cc
@@ -0,0 +1,55 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+#include <stdio.h>
+
+template <class T>
+class Vector {
+public:
+  int size;
+  ~Vector() {
+    printf("~V %p %lu\n", &size, sizeof(size));
+    assert(__msan_test_shadow(&this->size, sizeof(this->size)) == -1);
+  }
+};
+
+struct Derived {
+  int derived_a;
+  Vector<int> derived_v1;
+  Vector<int> derived_v2;
+  double derived_b;
+  double derived_c;
+  Derived() {
+    derived_a = 5;
+    derived_v1.size = 1;
+    derived_v2.size = 1;
+    derived_b = 7;
+    derived_c = 10;
+  }
+  ~Derived() {
+    printf("~D %p %p %p %lu\n", &derived_a, &derived_v1, &derived_c, sizeof(*this));
+    assert(__msan_test_shadow(&derived_a, sizeof(derived_a)) == -1);
+    assert(__msan_test_shadow(&derived_v1, sizeof(derived_v1)) == -1);
+    assert(__msan_test_shadow(&derived_v2, sizeof(derived_v2)) == -1);
+    assert(__msan_test_shadow(&derived_b, sizeof(derived_b)) == -1);
+    assert(__msan_test_shadow(&derived_c, sizeof(derived_c)) == -1);
+  }
+};
+
+int main() {
+  Derived *d = new Derived();
+  d->~Derived();
+
+  assert(__msan_test_shadow(&d->derived_a, sizeof(d->derived_a)) != -1);
+  assert(__msan_test_shadow(&d->derived_v1, sizeof(d->derived_v1)) != -1);
+  assert(__msan_test_shadow(&d->derived_v2, sizeof(d->derived_v2)) != -1);
+  assert(__msan_test_shadow(&d->derived_b, sizeof(d->derived_b)) != -1);
+  assert(__msan_test_shadow(&d->derived_c, sizeof(d->derived_c)) != -1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-trivial.cpp b/compiler-rt/test/msan/dtor-trivial.cpp
new file mode 100644
index 0000000..3faa760
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-trivial.cpp
@@ -0,0 +1,41 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t >%t.out 2>&1
+
+// TODO Success pending on resolution of
+// https://github.com/google/sanitizers/issues/596
+
+// XFAIL: *
+
+#include <assert.h>
+#include <sanitizer/msan_interface.h>
+
+template <class T> class Vector {
+ public:
+  int size;
+  ~Vector() {}
+};
+
+struct NonTrivial {
+  int a;
+  Vector<int> v;
+};
+
+struct Trivial {
+  int a;
+  int b;
+};
+
+int main() {
+  NonTrivial *nt = new NonTrivial();
+  nt->~NonTrivial();
+  assert(__msan_test_shadow(nt, sizeof(*nt)) != -1);
+
+  Trivial *t = new Trivial();
+  t->~Trivial();
+  assert(__msan_test_shadow(t, sizeof(*t)) != -1);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/dtor-vtable-multiple-inheritance.cc b/compiler-rt/test/msan/dtor-vtable-multiple-inheritance.cc
new file mode 100644
index 0000000..8521fad
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-vtable-multiple-inheritance.cc
@@ -0,0 +1,72 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -DCVPTR=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// RUN: %clangxx_msan %s -DEAVPTR=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// RUN: %clangxx_msan %s -DEDVPTR=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// Expected to quit due to invalid access when invoking
+// function using vtable.
+
+class A {
+ public:
+  int x;
+  virtual ~A() {
+    // Should succeed
+    this->A_Foo();
+  }
+  virtual void A_Foo() {}
+};
+
+class B : public virtual A {
+ public:
+  int y;
+  virtual ~B() {}
+  virtual void A_Foo() {}
+};
+
+class C : public B {
+ public:
+  int z;
+  ~C() {}
+};
+
+class D {
+ public:
+  int w;
+  ~D() {}
+  virtual void D_Foo() {}
+};
+
+class E : public virtual A, public virtual D {
+ public:
+  int u;
+  ~E() {}
+  void A_Foo() {}
+};
+
+int main() {
+  // Simple linear inheritance
+  C *c = new C();
+  c->~C();
+  // This fails
+#ifdef CVPTR
+  c->A_Foo();
+#endif
+
+  // Multiple inheritance, so has multiple vtables
+  E *e = new E();
+  e->~E();
+  // Both of these fail
+#ifdef EAVPTR
+  e->A_Foo();
+#endif
+#ifdef EDVPTR
+  e->D_Foo();
+#endif
+}
diff --git a/compiler-rt/test/msan/dtor-vtable.cc b/compiler-rt/test/msan/dtor-vtable.cc
new file mode 100644
index 0000000..9bbad26
--- /dev/null
+++ b/compiler-rt/test/msan/dtor-vtable.cc
@@ -0,0 +1,68 @@
+// RUN: %clangxx_msan %s -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 %run %t
+
+// RUN: %clangxx_msan %s -DVPTRA=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// RUN: %clangxx_msan %s -DVPTRCA=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// RUN: %clangxx_msan %s -DVPTRCB=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// RUN: %clangxx_msan %s -DVPTRC=1 -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t
+
+// Expected to quit due to invalid access when invoking
+// function using vtable.
+
+#include <sanitizer/msan_interface.h>
+#include <stdio.h>
+#include <assert.h>
+
+class A {
+public:
+  int x;
+  ~A() {}
+  virtual void A_Foo() {}
+};
+
+class B {
+ public:
+  int y;
+  ~B() {}
+  virtual void B_Foo() {}
+};
+
+class C : public A, public B {
+ public:
+  int z;
+  ~C() {}
+  virtual void C_Foo() {}
+};
+
+int main() {
+  A *a = new A();
+  a->~A();
+
+  // Shouldn't be allowed to invoke function via vtable.
+#ifdef VPTRA
+  a->A_Foo();
+#endif
+
+  C *c = new C();
+  c->~C();
+
+#ifdef VPTRCA
+  c->A_Foo();
+#endif
+
+#ifdef VPTRCB
+  c->B_Foo();
+#endif
+
+#ifdef VPTRC
+  c->C_Foo();
+#endif
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/errno.cc b/compiler-rt/test/msan/errno.cc
new file mode 100644
index 0000000..6ed0fd4
--- /dev/null
+++ b/compiler-rt/test/msan/errno.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int main()
+{
+  int x;
+  int *volatile p = &x;
+  errno = *p;
+  int res = read(-1, 0, 0);
+  assert(res == -1);
+  if (errno) printf("errno %d\n", errno);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/fork.cc b/compiler-rt/test/msan/fork.cc
new file mode 100644
index 0000000..78a62d5
--- /dev/null
+++ b/compiler-rt/test/msan/fork.cc
@@ -0,0 +1,121 @@
+// Test that chained origins are fork-safe.
+// Run a number of threads that create new chained origins, then fork
+// and verify that origin reads do not deadlock in the child process.
+
+// RUN: %clangxx_msan -std=c++11 -fsanitize-memory-track-origins=2 -g -O3 %s -o %t
+// RUN: MSAN_OPTIONS=store_context_size=1000,origin_history_size=0,origin_history_per_stack_limit=0 %run %t |& FileCheck %s
+
+// Fun fact: if test output is redirected to a file (as opposed to
+// being piped directly to FileCheck), we may lose some "done"s due to
+// a kernel bug:
+// https://lkml.org/lkml/2014/2/17/324
+
+
+#include <pthread.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <signal.h>
+#include <errno.h>
+
+#include <sanitizer/msan_interface.h>
+
+int done;
+
+void copy_uninit_thread2() {
+  volatile int x;
+  volatile int v;
+  while (true) {
+    v = x;
+    x = v;
+    if (__atomic_load_n(&done, __ATOMIC_RELAXED))
+      return;
+  }
+}
+
+void copy_uninit_thread1(int level) {
+  if (!level)
+    copy_uninit_thread2();
+  else
+    copy_uninit_thread1(level - 1);
+}
+
+void *copy_uninit_thread(void *id) {
+  copy_uninit_thread1((long)id);
+  return 0;
+}
+
+// Run through stackdepot in the child process.
+// If any of the hash table cells are locked, this may deadlock.
+void child() {
+  volatile int x;
+  volatile int v;
+  for (int i = 0; i < 10000; ++i) {
+    v = x;
+    x = v;
+  }
+  write(2, "done\n", 5);
+}
+
+void test() {
+  const int kThreads = 10;
+  pthread_t t[kThreads];
+  for (int i = 0; i < kThreads; ++i)
+    pthread_create(&t[i], NULL, copy_uninit_thread, (void*)(long)i);
+  usleep(100000);
+  pid_t pid = fork();
+  if (pid) {
+    // parent
+    __atomic_store_n(&done, 1, __ATOMIC_RELAXED);
+    pid_t p;
+    while ((p = wait(NULL)) == -1) {  }
+  } else {
+    // child
+    child();
+  }
+}
+
+int main() {
+  const int kChildren = 20;
+  for (int i = 0; i < kChildren; ++i) {
+    pid_t pid = fork();
+    if (pid) {
+      // parent
+    } else {
+      test();
+      exit(0);
+    }
+  }
+  
+  for (int i = 0; i < kChildren; ++i) {
+    pid_t p;
+    while ((p = wait(NULL)) == -1) {  }
+  }
+
+  return 0;
+}
+
+// Expect 20 (== kChildren) "done" messages.
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
+// CHECK: done
diff --git a/compiler-rt/test/msan/ftime.cc b/compiler-rt/test/msan/ftime.cc
new file mode 100644
index 0000000..7a5a2fb
--- /dev/null
+++ b/compiler-rt/test/msan/ftime.cc
@@ -0,0 +1,17 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+// ftime() is deprecated on FreeBSD.
+// XFAIL: freebsd
+
+#include <assert.h>
+#include <sys/timeb.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  struct timeb tb;
+  int res = ftime(&tb);
+  assert(!res);
+  assert(__msan_test_shadow(&tb, sizeof(tb)) == -1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/getaddrinfo-positive.cc b/compiler-rt/test/msan/getaddrinfo-positive.cc
new file mode 100644
index 0000000..45c1b60
--- /dev/null
+++ b/compiler-rt/test/msan/getaddrinfo-positive.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <stdlib.h>
+
+volatile int z;
+
+int main(void) {
+  struct addrinfo *ai;
+  struct addrinfo hint;
+  int res = getaddrinfo("localhost", NULL, NULL, &ai);
+  if (ai) z = 1; // OK
+  res = getaddrinfo("localhost", NULL, &hint, &ai);
+  // CHECK: Uninitialized bytes in __interceptor_getaddrinfo at offset 0 inside [0x{{.*}}, 48)
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #0 {{.*}} in main {{.*}}getaddrinfo-positive.cc:[[@LINE-3]]
+  return 0;
+}
diff --git a/compiler-rt/test/msan/getaddrinfo.cc b/compiler-rt/test/msan/getaddrinfo.cc
new file mode 100644
index 0000000..c9dcf3e
--- /dev/null
+++ b/compiler-rt/test/msan/getaddrinfo.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <stdlib.h>
+
+void poison_stack_ahead() {
+  char buf[100000];
+  // With -O0 this poisons a large chunk of stack.
+}
+
+int main(void) {
+  poison_stack_ahead();
+
+  struct addrinfo *ai;
+
+  // This should trigger loading of libnss_dns and friends.
+  // Those libraries are typically uninstrumented.They will call strlen() on a
+  // stack-allocated buffer, which is very likely to be poisoned. Test that we
+  // don't report this as an UMR.
+  int res = getaddrinfo("not-in-etc-hosts", NULL, NULL, &ai);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/getc_unlocked.c b/compiler-rt/test/msan/getc_unlocked.c
new file mode 100644
index 0000000..8468fed
--- /dev/null
+++ b/compiler-rt/test/msan/getc_unlocked.c
@@ -0,0 +1,32 @@
+// RUN: %clangxx_msan -DGETC -O0 -g -xc++ %s -o %t && %run %t
+// RUN: %clangxx_msan -DGETC -O3 -g -xc++ %s -o %t && %run %t
+// RUN: %clang_msan -DGETC -O0 -g %s -o %t && %run %t
+// RUN: %clang_msan -DGETC -O3 -g %s -o %t && %run %t
+
+// RUN: %clangxx_msan -DGETCHAR -O0 -g -xc++ %s -o %t && %run %t
+// RUN: %clangxx_msan -DGETCHAR -O3 -g -xc++ %s -o %t && %run %t
+// RUN: %clang_msan -DGETCHAR -O0 -g %s -o %t && %run %t
+// RUN: %clang_msan -DGETCHAR -O3 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int main() {
+  FILE *stream = fopen("/dev/zero", "r");
+  flockfile (stream);
+  int c;
+#if defined(GETCHAR)
+  int res = dup2(fileno(stream), 0);
+  assert(res == 0);
+  c = getchar_unlocked();
+#elif defined(GETC)
+  c = getc_unlocked (stream);
+#endif
+  funlockfile (stream);
+  if (c == EOF)
+    return 1;
+  printf("%c\n", (char)c);
+  fclose(stream);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/getline.cc b/compiler-rt/test/msan/getline.cc
new file mode 100644
index 0000000..ee12d4d
--- /dev/null
+++ b/compiler-rt/test/msan/getline.cc
@@ -0,0 +1,40 @@
+// RUN: echo "abcde" > %t-testdata
+// RUN: echo "12345" >> %t-testdata
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %t-testdata
+// RUN: %clangxx_msan -O2 %s -o %t && %run %t %t-testdata
+// RUN: %clang_msan -O0 -xc %s -o %t && %run %t %t-testdata
+// RUN: %clang_msan -O2 -xc %s -o %t && %run %t %t-testdata
+// RUN: %clang_msan -O0 -xc -D_GNU_SOURCE=1 %s -o %t && %run %t %t-testdata
+// RUN: %clang_msan -O2 -xc -D_GNU_SOURCE=1 %s -o %t && %run %t %t-testdata
+
+#if defined(__FreeBSD__)
+#define _WITH_GETLINE  // To declare getline().
+#endif
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  assert(argc == 2);
+  printf("%s\n", argv[1]);
+
+  FILE *fp = fopen(argv[1], "r");
+  assert(fp);
+
+  char *line = 0;
+  size_t len = 0;
+  int n = getline(&line, &len, fp);
+  assert(n == 6);
+  assert(strcmp(line, "abcde\n") == 0);
+
+  n = getline(&line, &len, fp);
+  assert(n == 6);
+  assert(strcmp(line, "12345\n") == 0);
+
+  free(line);
+  fclose(fp);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/heap-origin.cc b/compiler-rt/test/msan/heap-origin.cc
new file mode 100644
index 0000000..4f170f0
--- /dev/null
+++ b/compiler-rt/test/msan/heap-origin.cc
@@ -0,0 +1,31 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  char *volatile x = (char*)malloc(5 * sizeof(char));
+  return *x;
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*heap-origin.cc:}}[[@LINE-2]]
+
+  // CHECK-ORIGINS: Uninitialized value was created by a heap allocation
+  // CHECK-ORIGINS: {{#0 0x.* in .*malloc}}
+  // CHECK-ORIGINS: {{#1 0x.* in main .*heap-origin.cc:}}[[@LINE-7]]
+
+  // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*heap-origin.cc:.* main}}
+}
diff --git a/compiler-rt/test/msan/icmp_slt_allones.cc b/compiler-rt/test/msan/icmp_slt_allones.cc
new file mode 100644
index 0000000..8eff2ea
--- /dev/null
+++ b/compiler-rt/test/msan/icmp_slt_allones.cc
@@ -0,0 +1,20 @@
+// PR24561
+// RUN: %clangxx_msan -O2 -g %s -o %t && %run %t
+
+#include <stdio.h>
+
+struct A {
+  int c1 : 7;
+  int c8 : 1;
+  int c9 : 1;
+  A();
+};
+
+__attribute__((noinline)) A::A() : c8(1) {}
+
+int main() {
+  A* a = new A();
+  if (a->c8 == 0)
+    printf("zz\n");
+  return 0;
+}
diff --git a/compiler-rt/test/msan/iconv.cc b/compiler-rt/test/msan/iconv.cc
new file mode 100644
index 0000000..c2da938
--- /dev/null
+++ b/compiler-rt/test/msan/iconv.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -g -DPOSITIVE %s -o %t && not %run %t |& FileCheck %s
+
+#include <assert.h>
+#include <iconv.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+int main(void) {
+  iconv_t cd = iconv_open("ASCII", "ASCII");
+  assert(cd != (iconv_t)-1);
+
+  char inbuf_[100];
+  strcpy(inbuf_, "sample text");
+  char outbuf_[100];
+#if defined(__FreeBSD__)
+  // FreeBSD's iconv() expects the 2nd argument be of type 'const char**'.
+  const char *inbuf = inbuf_;
+#else
+  char *inbuf = inbuf_;
+#endif
+  char *outbuf = outbuf_;
+  size_t inbytesleft = strlen(inbuf_);
+  size_t outbytesleft = sizeof(outbuf_);
+
+#ifdef POSITIVE
+  {
+    char u;
+    char *volatile p = &u;
+    inbuf_[5] = *p;
+  }
+#endif
+
+  size_t res;
+  res = iconv(cd, 0, 0, 0, 0);
+  assert(res != (size_t)-1);
+
+  res = iconv(cd, 0, 0, &outbuf, &outbytesleft);
+  assert(res != (size_t)-1);
+
+  res = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #0 {{.*}} in main {{.*}}iconv.cc:[[@LINE-2]]
+  assert(res != (size_t)-1);
+  assert(inbytesleft == 0);
+
+  assert(memcmp(inbuf_, outbuf_, strlen(inbuf_)) == 0);
+
+  iconv_close(cd);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/if_indextoname.cc b/compiler-rt/test/msan/if_indextoname.cc
new file mode 100644
index 0000000..7b1b989
--- /dev/null
+++ b/compiler-rt/test/msan/if_indextoname.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <errno.h>
+#include <net/if.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  char ifname[IF_NAMESIZE + 1];
+  assert(0 == __msan_test_shadow(ifname, sizeof(ifname)));
+  if (!if_indextoname(1, ifname)) {
+    assert(errno == ENXIO);
+    printf("No network interfaces found.\n");
+    return 0;
+  }
+  assert(strlen(ifname) + 1 <= __msan_test_shadow(ifname, sizeof(ifname)));
+  return 0;
+}
diff --git a/compiler-rt/test/msan/ifaddrs.cc b/compiler-rt/test/msan/ifaddrs.cc
new file mode 100644
index 0000000..6f5eb93
--- /dev/null
+++ b/compiler-rt/test/msan/ifaddrs.cc
@@ -0,0 +1,54 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1
+
+#include <assert.h>
+#include <errno.h>
+#include <ifaddrs.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <vector>
+
+#if defined(__FreeBSD__)
+#include <sys/socket.h>  // To define 'struct sockaddr'.
+#endif
+
+#include <sanitizer/msan_interface.h>
+
+#define CHECK_AND_PUSH(addr, size)                                \
+  if (addr) {                                                     \
+    assert(-1 == __msan_test_shadow(addr, sizeof(size)));         \
+    ranges.push_back(std::make_pair((void *)addr, (size_t)size)); \
+  }
+
+int main(int argc, char *argv[]) {
+  struct ifaddrs *ifas;
+
+  assert(0 == __msan_test_shadow(&ifas, sizeof(ifaddrs *)));
+  int res = getifaddrs(&ifas);
+  if (res == -1) {
+    assert(errno == ENOSYS);
+    printf("getifaddrs() is not implemented\n");
+    return 0;
+  }
+  assert(res == 0);
+  assert(-1 == __msan_test_shadow(&ifas, sizeof(ifaddrs *)));
+
+  std::vector<std::pair<void *, size_t> > ranges;
+  ifaddrs *p = ifas;
+  while (p) {
+    CHECK_AND_PUSH(p, sizeof(ifaddrs));
+    CHECK_AND_PUSH(p->ifa_name, strlen(p->ifa_name) + 1);
+    CHECK_AND_PUSH(p->ifa_addr, sizeof(*p->ifa_addr));
+    CHECK_AND_PUSH(p->ifa_netmask, sizeof(*p->ifa_netmask));
+    CHECK_AND_PUSH(p->ifa_broadaddr, sizeof(*p->ifa_broadaddr));
+    CHECK_AND_PUSH(p->ifa_dstaddr, sizeof(*p->ifa_dstaddr));
+    p = p->ifa_next;
+  }
+
+  freeifaddrs(ifas);
+  for (int i = 0; i < ranges.size(); i++)
+    assert(0 == __msan_test_shadow(ranges[i].first, ranges[i].second));
+  return 0;
+}
diff --git a/compiler-rt/test/msan/initgroups.cc b/compiler-rt/test/msan/initgroups.cc
new file mode 100644
index 0000000..974b1cb
--- /dev/null
+++ b/compiler-rt/test/msan/initgroups.cc
@@ -0,0 +1,12 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <sys/types.h>
+#include <grp.h>
+#include <unistd.h>  // FreeBSD declares initgroups() here.
+
+int main(void) {
+  initgroups("root", 0);
+  // The above fails unless you are root. Does not matter, MSan false positive
+  // (which we are testing for) happens anyway.
+  return 0;
+}
diff --git a/compiler-rt/test/msan/inline.cc b/compiler-rt/test/msan/inline.cc
new file mode 100644
index 0000000..b2fa961
--- /dev/null
+++ b/compiler-rt/test/msan/inline.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t
+
+// Test that no_sanitize_memory attribute applies even when the function would
+// be normally inlined.
+
+#include <stdlib.h>
+
+__attribute__((no_sanitize_memory))
+int f(int *p) {
+  if (*p) // BOOOM?? Nope!
+    exit(0);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int x;
+  int * volatile p = &x;
+  int res = f(p);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/insertvalue_origin.cc b/compiler-rt/test/msan/insertvalue_origin.cc
new file mode 100644
index 0000000..96d27f0
--- /dev/null
+++ b/compiler-rt/test/msan/insertvalue_origin.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+
+// Test origin propagation through insertvalue IR instruction.
+// REQUIRES: stable-runtime
+
+#include <stdio.h>
+#include <stdint.h>
+
+struct mypair {
+ int64_t x;
+ int y;
+};
+
+mypair my_make_pair(int64_t x, int y)  {
+ mypair p;
+ p.x = x;
+ p.y = y;
+ return p;
+}
+
+int main() {
+ int64_t * volatile p = new int64_t;
+ mypair z = my_make_pair(*p, 0);
+ if (z.x)
+   printf("zzz\n");
+ // CHECK: MemorySanitizer: use-of-uninitialized-value
+ // CHECK: {{in main .*insertvalue_origin.cc:}}[[@LINE-3]]
+
+ // CHECK: Uninitialized value was created by a heap allocation
+ // CHECK: {{in main .*insertvalue_origin.cc:}}[[@LINE-8]]
+ delete p;
+ return 0;
+}
diff --git a/compiler-rt/test/msan/ioctl.cc b/compiler-rt/test/msan/ioctl.cc
new file mode 100644
index 0000000..e21ef63
--- /dev/null
+++ b/compiler-rt/test/msan/ioctl.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O3 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  int fd = socket(AF_INET, SOCK_DGRAM, 0);
+
+  unsigned int z;
+  int res = ioctl(fd, FIOGETOWN, &z);
+  assert(res == 0);
+  close(fd);
+  if (z)
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/ioctl_custom.cc b/compiler-rt/test/msan/ioctl_custom.cc
new file mode 100644
index 0000000..6df22d7
--- /dev/null
+++ b/compiler-rt/test/msan/ioctl_custom.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O3 -g %s -o %t && %run %t
+
+// RUN: %clangxx_msan -DPOSITIVE -O0 -g %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -DPOSITIVE -O3 -g %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdlib.h>
+#include <net/if.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  int fd = socket(AF_INET, SOCK_STREAM, 0);
+
+  struct ifreq ifreqs[20];
+  struct ifconf ifc;
+  ifc.ifc_ifcu.ifcu_req = ifreqs;
+#ifndef POSITIVE
+  ifc.ifc_len = sizeof(ifreqs);
+#endif
+  int res = ioctl(fd, SIOCGIFCONF, (void *)&ifc);
+  // CHECK: Uninitialized bytes in ioctl{{.*}} at offset 0 inside [0x{{.*}}, 4)
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #{{.*}} in main {{.*}}ioctl_custom.cc:[[@LINE-3]]
+  assert(res == 0);
+  for (int i = 0; i < ifc.ifc_len / sizeof(*ifc.ifc_ifcu.ifcu_req); ++i)
+    printf("%d  %zu  %s\n", i, strlen(ifreqs[i].ifr_name), ifreqs[i].ifr_name);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/keep-going-dso.cc b/compiler-rt/test/msan/keep-going-dso.cc
new file mode 100644
index 0000000..f32a513
--- /dev/null
+++ b/compiler-rt/test/msan/keep-going-dso.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+// RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+
+// Test how -mllvm -msan-keep-going and MSAN_OPTIONS=keep_going affect reports
+// from interceptors.
+// -mllvm -msan-keep-going provides the default value of keep_going flag, but is
+// always overwritten by MSAN_OPTIONS
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  char *volatile x = (char*)malloc(5 * sizeof(char));
+  x[4] = 0;
+  if (strlen(x) < 3)
+    exit(0);
+  fprintf(stderr, "Done\n");
+  // CHECK-NOT: Done
+  // CHECK-KEEP-GOING: Done
+  return 0;
+}
diff --git a/compiler-rt/test/msan/keep-going.cc b/compiler-rt/test/msan/keep-going.cc
new file mode 100644
index 0000000..5772975
--- /dev/null
+++ b/compiler-rt/test/msan/keep-going.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=halt_on_error=1 not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=halt_on_error=0 not %run %t >%t.out 2>&1
+// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
+
+// Test behaviour of -mllvm -msan-keep-going and MSAN_OPTIONS=keep_going.
+// -mllvm -msan-keep-going provides the default value of keep_going flag; value
+// of 1 can be overwritten by MSAN_OPTIONS, value of 0 can not.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+  char *volatile x = (char*)malloc(5 * sizeof(char));
+  if (x[0])
+    exit(0);
+  fprintf(stderr, "Done\n");
+  // CHECK-NOT: Done
+  // CHECK-KEEP-GOING: Done
+  return 0;
+}
diff --git a/compiler-rt/test/msan/lit.cfg b/compiler-rt/test/msan/lit.cfg
new file mode 100644
index 0000000..011ccd2
--- /dev/null
+++ b/compiler-rt/test/msan/lit.cfg
@@ -0,0 +1,33 @@
+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = 'MemorySanitizer'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Setup default compiler flags used with -fsanitize=memory option.
+clang_msan_cflags = ["-fsanitize=memory",
+                     "-mno-omit-leaf-frame-pointer",
+                     "-fno-omit-frame-pointer",
+                     "-fno-optimize-sibling-calls",
+                     "-m64"] + config.debug_info_flags
+# Some Msan tests leverage backtrace() which requires libexecinfo on FreeBSD.
+if config.host_os == 'FreeBSD':
+  clang_msan_cflags += ["-lexecinfo"]
+clang_msan_cxxflags = config.cxx_mode_flags + clang_msan_cflags
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang_msan ", build_invocation(clang_msan_cflags)) )
+config.substitutions.append( ("%clangxx_msan ", build_invocation(clang_msan_cxxflags)) )
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp']
+
+# MemorySanitizer tests are currently supported on Linux only.
+if config.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/msan/lit.site.cfg.in b/compiler-rt/test/msan/lit.site.cfg.in
new file mode 100644
index 0000000..fb22a57
--- /dev/null
+++ b/compiler-rt/test/msan/lit.site.cfg.in
@@ -0,0 +1,5 @@
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@MSAN_LIT_SOURCE_DIR@/lit.cfg")
diff --git a/compiler-rt/test/msan/memcmp_test.cc b/compiler-rt/test/msan/memcmp_test.cc
new file mode 100644
index 0000000..95228eb
--- /dev/null
+++ b/compiler-rt/test/msan/memcmp_test.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: MSAN_OPTIONS=intercept_memcmp=0 %run %t
+
+#include <string.h>
+int main(int argc, char **argv) {
+  char a1[4];
+  char a2[4];
+  for (int i = 0; i < argc * 3; i++)
+    a2[i] = a1[i] = i;
+  int res = memcmp(a1, a2, 4);
+  return res;
+  // CHECK: Uninitialized bytes in __interceptor_memcmp at offset 3
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+}
diff --git a/compiler-rt/test/msan/mktime.cc b/compiler-rt/test/msan/mktime.cc
new file mode 100644
index 0000000..997fb0d
--- /dev/null
+++ b/compiler-rt/test/msan/mktime.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -g -DUNINIT %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <time.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  struct tm tm;
+  tm.tm_year = 2014;
+  tm.tm_mon = 3;
+  tm.tm_mday = 28;
+#ifndef UNINIT
+  tm.tm_hour = 13;
+#endif
+  tm.tm_min = 4;
+  tm.tm_sec = 42;
+  tm.tm_isdst = -1;
+  time_t t = mktime(&tm);
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: in main{{.*}}mktime.cc:[[@LINE-2]]
+  assert(t != -1);
+  assert(__msan_test_shadow(&tm, sizeof(tm)) == -1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/mmap.cc b/compiler-rt/test/msan/mmap.cc
new file mode 100644
index 0000000..27a8bb2
--- /dev/null
+++ b/compiler-rt/test/msan/mmap.cc
@@ -0,0 +1,71 @@
+// Test that mmap (without MAP_FIXED) always returns valid application addresses.
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -fsanitize-memory-track-origins %s -o %t && %run %t
+
+#include <assert.h>
+#include <errno.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "test.h"
+
+bool AddrIsApp(void *p) {
+  uintptr_t addr = (uintptr_t)p;
+#if defined(__FreeBSD__) && defined(__x86_64__)
+  return addr < 0x010000000000ULL || addr >= 0x600000000000ULL;
+#elif defined(__x86_64__)
+  return (addr >= 0x000000000000ULL && addr < 0x010000000000ULL) ||
+         (addr >= 0x510000000000ULL && addr < 0x600000000000ULL) ||
+         (addr >= 0x700000000000ULL && addr < 0x800000000000ULL);
+#elif defined(__mips64)
+  return addr >= 0x00e000000000ULL;
+#elif defined(__powerpc64__)
+  return addr < 0x000100000000ULL || addr >= 0x300000000000ULL;
+#elif defined(__aarch64__)
+
+  struct AddrMapping {
+    uintptr_t start;
+    uintptr_t end;
+  } mappings[] = {
+    {0x05000000000ULL, 0x06000000000ULL},
+    {0x07000000000ULL, 0x08000000000ULL},
+    {0x0F000000000ULL, 0x10000000000ULL},
+    {0x11000000000ULL, 0x12000000000ULL},
+    {0x20000000000ULL, 0x21000000000ULL},
+    {0x2A000000000ULL, 0x2B000000000ULL},
+    {0x2E000000000ULL, 0x2F000000000ULL},
+    {0x3B000000000ULL, 0x3C000000000ULL},
+    {0x3F000000000ULL, 0x40000000000ULL},
+  };
+  const size_t mappingsSize = sizeof (mappings) / sizeof (mappings[0]);
+
+  for (int i=0; i<mappingsSize; ++i)
+    if (addr >= mappings[i].start && addr < mappings[i].end)
+      return true;
+  return false;
+#endif
+}
+
+int main() {
+  // Large enough to quickly exhaust the entire address space.
+#if defined(__mips64) || defined(__aarch64__)
+  const size_t kMapSize = 0x100000000ULL;
+#else
+  const size_t kMapSize = 0x1000000000ULL;
+#endif
+  int success_count = 0;
+  while (true) {
+    void *p = mmap(0, kMapSize, PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
+    printf("%p\n", p);
+    if (p == MAP_FAILED) {
+      assert(errno == ENOMEM);
+      break;
+    }
+    assert(AddrIsApp(p));
+    success_count++;
+  }
+  printf("successful mappings: %d\n", success_count);
+  assert(success_count > 5);
+}
diff --git a/compiler-rt/test/msan/mmap_below_shadow.cc b/compiler-rt/test/msan/mmap_below_shadow.cc
new file mode 100644
index 0000000..806b19d
--- /dev/null
+++ b/compiler-rt/test/msan/mmap_below_shadow.cc
@@ -0,0 +1,42 @@
+// Test mmap behavior when map address is below shadow range.
+// With MAP_FIXED, we return EINVAL.
+// Without MAP_FIXED, we ignore the address hint and map somewhere in
+// application range.
+
+// RUN: %clangxx_msan -O0 -DFIXED=0 %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -DFIXED=1 %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -DFIXED=0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -DFIXED=1 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
+
+#include <assert.h>
+#include <errno.h>
+#include <stdint.h>
+#include <sys/mman.h>
+
+int main(void) {
+  // Hint address just below shadow.
+#if defined(__FreeBSD__) && defined(__x86_64__)
+  uintptr_t hint = 0x0f0000000000ULL;
+  const uintptr_t app_start = 0x000000000000ULL;
+#elif defined(__x86_64__)
+  uintptr_t hint = 0x4f0000000000ULL;
+  const uintptr_t app_start = 0x600000000000ULL;
+#elif defined (__mips64)
+  uintptr_t hint = 0x4f00000000ULL;
+  const uintptr_t app_start = 0x6000000000ULL;
+#elif defined (__powerpc64__)
+  uintptr_t hint = 0x2f0000000000ULL;
+  const uintptr_t app_start = 0x300000000000ULL;
+#elif defined (__aarch64__)
+  uintptr_t hint = 0x4f0000000ULL;
+  const uintptr_t app_start = 0x7000000000ULL;
+#endif
+  uintptr_t p = (uintptr_t)mmap(
+      (void *)hint, 4096, PROT_WRITE,
+      MAP_PRIVATE | MAP_ANONYMOUS | (FIXED ? MAP_FIXED : 0), -1, 0);
+  if (FIXED)
+    assert(p == (uintptr_t)-1 && errno == EINVAL);
+  else
+    assert(p >= app_start);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/msan_check_mem_is_initialized.cc b/compiler-rt/test/msan/msan_check_mem_is_initialized.cc
new file mode 100644
index 0000000..599cf2d
--- /dev/null
+++ b/compiler-rt/test/msan/msan_check_mem_is_initialized.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_msan -O0 -g -DPOSITIVE %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK
+// RUN: MSAN_OPTIONS=verbosity=1 not %run %t 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-VERBOSE
+
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  char p[32] = {};
+  __msan_poison(p + 10, 2);
+
+  __msan_check_mem_is_initialized(p, 10);
+  __msan_check_mem_is_initialized(p + 12, 30);
+#ifdef POSITIVE
+  __msan_check_mem_is_initialized(p + 5, 20);
+  // CHECK: Uninitialized bytes in __msan_check_mem_is_initialized at offset 5 inside [0x{{.*}}, 20)
+  // CHECK-VERBOSE: Shadow map of [0x{{.*}}, 0x{{.*}}), 20 bytes:
+  // CHECK-VERBOSE: 0x{{.*}}: ..000000 0000ffff 00000000 00000000
+  // CHECK-VERBOSE: 0x{{.*}}: 00000000 00...... ........ ........
+
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #0 0x{{.*}}in main{{.*}}msan_check_mem_is_initialized.cc:[[@LINE-7]]
+#endif
+  return 0;
+}
+
diff --git a/compiler-rt/test/msan/msan_copy_shadow.cc b/compiler-rt/test/msan/msan_copy_shadow.cc
new file mode 100644
index 0000000..a1c6347
--- /dev/null
+++ b/compiler-rt/test/msan/msan_copy_shadow.cc
@@ -0,0 +1,34 @@
+// Test that __msan_copy_shadow copies shadow, updates origin and does not touch
+// the application memory.
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=0 -O0 %s -o %t && not %run %t 2>&1
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/msan_interface.h>
+
+int main() {
+  char *a = new char[4];
+  char *b = new char[4];
+  a[1] = 1;
+  a[3] = 2;
+  memset(b, 42, 4);
+
+  // Test that __msan_copy_shadow does not touch the contents of b[].
+  __msan_copy_shadow(b, a, 4);
+  __msan_unpoison(b, 4);
+  assert(b[0] == 42 && b[1] == 42 && b[2] == 42 && b[3] == 42);
+
+  // Test that __msan_copy_shadow correctly updates shadow and origin of b[].
+  __msan_copy_shadow(b, a, 4);
+  assert(__msan_test_shadow(b, 4) == 0);
+  assert(__msan_test_shadow(b + 1, 3) == 1);
+  assert(__msan_test_shadow(b + 3, 1) == -1);
+  __msan_check_mem_is_initialized(b, 4);
+  // CHECK: use-of-uninitialized-value
+  // CHECK:   {{in main.*msan_copy_shadow.cc:}}[[@LINE-2]]
+  // CHECK: Uninitialized value was stored to memory at
+  // CHECK:   {{in main.*msan_copy_shadow.cc:}}[[@LINE-8]]
+  // CHECK: Uninitialized value was created by a heap allocation
+  // CHECK:   {{in main.*msan_copy_shadow.cc:}}[[@LINE-22]]
+}
diff --git a/compiler-rt/test/msan/msan_dump_shadow.cc b/compiler-rt/test/msan/msan_dump_shadow.cc
new file mode 100644
index 0000000..543fa70
--- /dev/null
+++ b/compiler-rt/test/msan/msan_dump_shadow.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  char *p = new char[16];
+  __msan_dump_shadow(p, 5);
+  delete[] p;
+  const char *q = "abc";
+  __msan_dump_shadow(q, 3);
+  return 0;
+}
+
+// CHECK: ff ff ff ff ff
+// CHECK: 00 00 00
diff --git a/compiler-rt/test/msan/msan_print_shadow.cc b/compiler-rt/test/msan/msan_print_shadow.cc
new file mode 100644
index 0000000..9668be2
--- /dev/null
+++ b/compiler-rt/test/msan/msan_print_shadow.cc
@@ -0,0 +1,122 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NO-ORIGINS < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ORIGINS < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ORIGINS --check-prefix=CHECK-ORIGINS-2 < %t.out
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  char volatile x;
+  char *p = new char[320];
+  p[2] = p[5] = 1;
+  p[8] = p[9] = p[10] = p[11] = p[12] = 2;
+
+  __msan_allocated_memory(p + 4*3, 4);
+  __msan_allocated_memory(p + 4*4, 4);
+  __msan_allocated_memory(p + 4*5, 4);
+  __msan_allocated_memory(p + 4*6, 4);
+  __msan_allocated_memory(p + 4*7, 4);
+  __msan_allocated_memory(p + 4*8, 4);
+  __msan_allocated_memory(p + 4*9, 4);
+  __msan_allocated_memory(p + 4*10, 4);
+  __msan_allocated_memory(p + 4*11, 4);
+  __msan_allocated_memory(p + 4*12, 4);
+  __msan_allocated_memory(p + 4*13, 4);
+  __msan_allocated_memory(p + 4*14, 4);
+  __msan_allocated_memory(p + 4*15, 4);
+  __msan_allocated_memory(p + 4*16, 4);
+  __msan_allocated_memory(p + 4*17, 4);
+  __msan_allocated_memory(p + 4*18, 4);
+  __msan_allocated_memory(p + 4*19, 4);
+  __msan_allocated_memory(p + 4*20, 4);
+  __msan_allocated_memory(p + 4*21, 4);
+  __msan_allocated_memory(p + 4*22, 4);
+  __msan_allocated_memory(p + 4*23, 4);
+  __msan_allocated_memory(p + 4*24, 4);
+  __msan_allocated_memory(p + 4*25, 4);
+  __msan_allocated_memory(p + 4*26, 4);
+  __msan_allocated_memory(p + 4*27, 4);
+  __msan_allocated_memory(p + 4*28, 4);
+  __msan_allocated_memory(p + 4*29, 4);
+  __msan_allocated_memory(p + 4*30, 4);
+  __msan_allocated_memory(p + 4*31, 4);
+
+  p[19] = x;
+
+  __msan_print_shadow(p+5, 297);
+  delete[] p;
+  return 0;
+}
+
+// CHECK: Shadow map of [{{.*}}), 297 bytes:
+
+// CHECK-NO-ORIGINS: 0x{{.*}}: ..00ffff 00000000 ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
+// CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffff.... ........
+
+// CHECK-ORIGINS: 0x{{.*}}: ..00ffff 00000000 ffffffff ffffffff  |A . B C|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |D E F G|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |H I J K|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |L M N O|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |P Q R S|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |T U V W|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |X Y Z *|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |* * * A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff  |A A A A|
+// CHECK-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffff.... ........  |A A A .|
+
+// CHECK-ORIGINS: Origin A (origin_id {{.*}}):
+// CHECK-ORIGINS:   Uninitialized value was created by a heap allocation
+// CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cc:14
+
+// CHECK-ORIGINS: Origin B (origin_id {{.*}}):
+// CHECK-ORIGINS:   Memory was marked as uninitialized
+// CHECK-ORIGINS:     #0 {{.*}} in __msan_allocated_memory
+// CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cc:18
+
+// CHECK-ORIGINS: Origin C (origin_id {{.*}}):
+// CHECK-ORIGINS-2:  Uninitialized value was stored to memory at
+// CHECK-ORIGINS-2:    #0 {{.*}} in main{{.*}}msan_print_shadow.cc:48
+// CHECK-ORIGINS:   Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+// CHECK-ORIGINS:     #0 {{.*}} in main{{.*}}msan_print_shadow.cc:12
+
+// CHECK-ORIGINS: Origin D (origin_id {{.*}}):
+// CHECK-ORIGINS:   Memory was marked as uninitialized
+// CHECK-ORIGINS:     #0 {{.*}} in __msan_allocated_memory
+// CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cc:20
+
+// ...
+
+// CHECK-ORIGINS: Origin Z (origin_id {{.*}}):
+// CHECK-ORIGINS:   Memory was marked as uninitialized
+// CHECK-ORIGINS:     #0 {{.*}} in __msan_allocated_memory
+// CHECK-ORIGINS:     #1 {{.*}} in main{{.*}}msan_print_shadow.cc:42
diff --git a/compiler-rt/test/msan/msan_print_shadow2.cc b/compiler-rt/test/msan/msan_print_shadow2.cc
new file mode 100644
index 0000000..5095081
--- /dev/null
+++ b/compiler-rt/test/msan/msan_print_shadow2.cc
@@ -0,0 +1,49 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NO-ORIGINS < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ORIGINS < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  char *p = new char[16];
+  __msan_print_shadow(p, 1);
+  __msan_print_shadow(p+1, 1);
+  __msan_print_shadow(p+3, 1);
+  __msan_print_shadow(p+15, 1);
+  __msan_print_shadow(p, 0);
+  delete[] p;
+  int x = 0;
+  __msan_print_shadow(&x, 3);
+  return 0;
+}
+
+// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK-NO-ORIGINS:   0x{{.*}}: ff...... ........ ........ ........
+// CHECK-ORIGINS:   0x{{.*}}: ff...... ........ ........ ........  |A . . .|
+// CHECK-ORIGINS: Origin A (origin_id {{.*}}):
+
+// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK-NO-ORIGINS:   0x{{.*}}: ..ff.... ........ ........ ........
+// CHECK-ORIGINS:   0x{{.*}}: ..ff.... ........ ........ ........  |A . . .|
+// CHECK-ORIGINS: Origin A (origin_id {{.*}}):
+
+// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK-NO-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........
+// CHECK-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........  |A . . .|
+// CHECK-ORIGINS: Origin A (origin_id {{.*}}):
+
+// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK-NO-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........
+// CHECK-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........  |A . . .|
+// CHECK-ORIGINS: Origin A (origin_id {{.*}}):
+
+// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 0 bytes:
+
+// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 3 bytes:
+// CHECK-NO-ORIGINS:   0x{{.*}}: 000000.. ........ ........ ........
+// CHECK-ORIGINS:   0x{{.*}}: 000000.. ........ ........ ........  |. . . .|
diff --git a/compiler-rt/test/msan/msan_print_shadow3.cc b/compiler-rt/test/msan/msan_print_shadow3.cc
new file mode 100644
index 0000000..b29f322
--- /dev/null
+++ b/compiler-rt/test/msan/msan_print_shadow3.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+#include <stdint.h>
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  unsigned long long x = 0; // For 8-byte alignment.
+  uint32_t x_s = 0x12345678U;
+  __msan_partial_poison(&x, &x_s, sizeof(x_s));
+  __msan_print_shadow(&x, sizeof(x_s));
+  return 0;
+}
+
+// CHECK: Shadow map of [{{.*}}), 4 bytes:
+// CHECK: 0x{{.*}}: 87654321 ........ ........ ........
diff --git a/compiler-rt/test/msan/mul_by_const.cc b/compiler-rt/test/msan/mul_by_const.cc
new file mode 100644
index 0000000..8240fdb
--- /dev/null
+++ b/compiler-rt/test/msan/mul_by_const.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_msan -O2 %s -o %t && %run %t
+
+#include <sanitizer/msan_interface.h>
+
+struct S {
+  S(int a0) : a(a0) {}
+  int a;
+  int b;
+};
+
+// Here S is passed to FooRun as a 64-bit integer.
+// This triggers an optimization where 10000 * s.a is transformed into
+// ((*(uint64_t *)&s) * (10000 * 2**32)) >> 32
+// Test that MSan understands that this kills the uninitialized high half of S
+// (i.e. S::b).
+void FooRun(S s) {
+  int64_t x = 10000 * s.a;
+  __msan_check_mem_is_initialized(&x, sizeof(x));
+}
+
+int main(void) {
+  S z(1);
+  // Take &z to ensure that it is built on stack.
+  S *volatile p = &z;
+  FooRun(z);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/no_sanitize_memory.cc b/compiler-rt/test/msan/no_sanitize_memory.cc
new file mode 100644
index 0000000..5c53ee4
--- /dev/null
+++ b/compiler-rt/test/msan/no_sanitize_memory.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O1 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O2 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t >%t.out 2>&1
+
+// RUN: %clangxx_msan -O0 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O1 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O2 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
+
+// Test that (no_sanitize_memory) functions
+// * don't check shadow values (-DCHECK_IN_F)
+// * treat all values loaded from memory as fully initialized (-UCHECK_IN_F)
+
+#include <stdlib.h>
+#include <stdio.h>
+
+__attribute__((noinline))
+__attribute__((no_sanitize_memory))
+int f(void) {
+  int x;
+  int * volatile p = &x;
+#ifdef CHECK_IN_F
+  if (*p)
+    exit(0);
+#endif
+  return *p;
+}
+
+int main(void) {
+  if (f())
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/no_sanitize_memory_prop.cc b/compiler-rt/test/msan/no_sanitize_memory_prop.cc
new file mode 100644
index 0000000..bfd4194
--- /dev/null
+++ b/compiler-rt/test/msan/no_sanitize_memory_prop.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O1 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O2 %s -o %t && %run %t >%t.out 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t >%t.out 2>&1
+
+// Test that (no_sanitize_memory) functions DO NOT propagate shadow.
+
+#include <stdlib.h>
+#include <stdio.h>
+
+__attribute__((noinline))
+__attribute__((no_sanitize_memory))
+int f(int x) {
+  return x;
+}
+
+int main(void) {
+  int x;
+  int * volatile p = &x;
+  int y = f(*p);
+  if (y)
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/origin-store-long.cc b/compiler-rt/test/msan/origin-store-long.cc
new file mode 100644
index 0000000..5c9fe04
--- /dev/null
+++ b/compiler-rt/test/msan/origin-store-long.cc
@@ -0,0 +1,21 @@
+// Check that 8-byte store updates origin for the full store range.
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+
+#include <sanitizer/msan_interface.h>
+
+int main() {
+  uint64_t *volatile p = new uint64_t;
+  uint64_t *volatile q = new uint64_t;
+  *p = *q;
+  char *z = (char *)p;
+  return z[6];
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK:   in main {{.*}}origin-store-long.cc:[[@LINE-2]]
+
+// CHECK:  Uninitialized value was created by a heap allocation
+// CHECK:   in main {{.*}}origin-store-long.cc:[[@LINE-8]]
+}
+
diff --git a/compiler-rt/test/msan/param_tls_limit.cc b/compiler-rt/test/msan/param_tls_limit.cc
new file mode 100644
index 0000000..1c504da
--- /dev/null
+++ b/compiler-rt/test/msan/param_tls_limit.cc
@@ -0,0 +1,78 @@
+// ParamTLS has limited size. Everything that does not fit is considered fully
+// initialized.
+
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 %s -o %t && %run %t
+//
+// AArch64 fails with:
+// void f801(S<801>): Assertion `__msan_test_shadow(&s, sizeof(s)) == -1' failed
+// XFAIL: aarch64
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+
+// This test assumes that ParamTLS size is 800 bytes.
+
+// This test passes poisoned values through function argument list.
+// In case of overflow, argument is unpoisoned.
+#define OVERFLOW(x) assert(__msan_test_shadow(&x, sizeof(x)) == -1)
+// In case of no overflow, it is still poisoned.
+#define NO_OVERFLOW(x) assert(__msan_test_shadow(&x, sizeof(x)) == 0)
+
+template<int N>
+struct S {
+  char x[N];
+};
+
+void f100(S<100> s) {
+  NO_OVERFLOW(s);
+}
+
+void f800(S<800> s) {
+  NO_OVERFLOW(s);
+}
+
+void f801(S<801> s) {
+  OVERFLOW(s);
+}
+
+void f1000(S<1000> s) {
+  OVERFLOW(s);
+}
+
+void f_many(int a, double b, S<800> s, int c, double d) {
+  NO_OVERFLOW(a);
+  NO_OVERFLOW(b);
+  OVERFLOW(s);
+  OVERFLOW(c);
+  OVERFLOW(d);
+}
+
+// -8 bytes for "int a", aligned by 8
+// -2 to make "int c" a partial fit
+void f_many2(int a, S<800 - 8 - 2> s, int c, double d) {
+  NO_OVERFLOW(a);
+  NO_OVERFLOW(s);
+  OVERFLOW(c);
+  OVERFLOW(d);
+}
+
+int main(void) {
+  S<100> s100;
+  S<800> s800;
+  S<801> s801;
+  S<1000> s1000;
+  f100(s100);
+  f800(s800);
+  f801(s801);
+  f1000(s1000);
+
+  int i;
+  double d;
+  f_many(i, d, s800, i, d);
+
+  S<800 - 8 - 2> s788;
+  f_many2(i, s788, i, d);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/poison_in_free.cc b/compiler-rt/test/msan/poison_in_free.cc
new file mode 100644
index 0000000..16e2124
--- /dev/null
+++ b/compiler-rt/test/msan/poison_in_free.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// FileCheck %s <%t.out
+// RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=poison_in_free=0 %run %t >%t.out 2>&1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  char *volatile x = (char*)malloc(50 * sizeof(char));
+  memset(x, 0, 50);
+  free(x);
+  return x[25];
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #0 {{.*}} in main{{.*}}poison_in_free.cc:[[@LINE-2]]
+}
diff --git a/compiler-rt/test/msan/print_stats.cc b/compiler-rt/test/msan/print_stats.cc
new file mode 100644
index 0000000..39af504
--- /dev/null
+++ b/compiler-rt/test/msan/print_stats.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -g %s -o %t 
+// RUN: %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK --check-prefix=CHECK-NOSTATS %s
+// RUN: MSAN_OPTIONS=print_stats=1 %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK --check-prefix=CHECK-NOSTATS %s
+// RUN: MSAN_OPTIONS=print_stats=1,atexit=1 %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK --check-prefix=CHECK-STATS %s
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -g -DPOSITIVE=1 %s -o %t 
+// RUN: not %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK --check-prefix=CHECK-NOSTATS %s
+// RUN: MSAN_OPTIONS=print_stats=1 not %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK --check-prefix=CHECK-STATS %s
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -g -DPOSITIVE=1 -mllvm -msan-keep-going=1 %s -o %t 
+// RUN: not %run %t 2>&1 | \
+// RUN:  FileCheck --check-prefix=CHECK --check-prefix=CHECK-NOSTATS --check-prefix=CHECK-KEEPGOING %s
+// RUN: MSAN_OPTIONS=print_stats=1 not %run %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK --check-prefix=CHECK-STATS --check-prefix=CHECK-KEEPGOING %s
+
+#include <stdio.h>
+int main(int argc, char **argv) {
+  int x;
+  int *volatile p = &x;
+  fprintf(stderr, "TEST\n");
+#ifdef POSITIVE
+  return *p;
+#else
+  return 0;
+#endif
+}
+
+// CHECK: TEST
+
+// CHECK-STATS: Unique heap origins:
+// CHECK-STATS: Stack depot allocated bytes:
+// CHECK-STATS: Unique origin histories:
+// CHECK-STATS: History depot allocated bytes:
+
+// CHECK-NOSTATS-NOT: Unique heap origins:
+// CHECK-NOSTATS-NOT: Stack depot allocated bytes:
+// CHECK-NOSTATS-NOT: Unique origin histories:
+// CHECK-NOSTATS-NOT: History depot allocated bytes:
+
+// CHECK-KEEPGOING: MemorySanitizer: 1 warnings reported.
diff --git a/compiler-rt/test/msan/pthread_getattr_np_deadlock.cc b/compiler-rt/test/msan/pthread_getattr_np_deadlock.cc
new file mode 100644
index 0000000..0f52280
--- /dev/null
+++ b/compiler-rt/test/msan/pthread_getattr_np_deadlock.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
+
+// Regression test for a deadlock in pthread_getattr_np
+
+#include <assert.h>
+#include <pthread.h>
+
+void *ThreadFn(void *) {
+  pthread_attr_t attr;
+  int res = pthread_getattr_np(pthread_self(), &attr);
+  assert(!res);
+  return 0;
+}
+
+int main(void) {
+  pthread_t t;
+  int res = pthread_create(&t, 0, ThreadFn, 0);
+  assert(!res);
+  res = pthread_join(t, 0);
+  assert(!res);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/pthread_setcancelstate.cc b/compiler-rt/test/msan/pthread_setcancelstate.cc
new file mode 100644
index 0000000..087c222
--- /dev/null
+++ b/compiler-rt/test/msan/pthread_setcancelstate.cc
@@ -0,0 +1,19 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <pthread.h>
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  int oldstate;
+  int oldtype;
+  int res = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
+  assert(res == 0);
+  __msan_check_mem_is_initialized(&oldstate, sizeof(oldstate));
+
+  res = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
+  assert(res == 0);
+  __msan_check_mem_is_initialized(&oldtype, sizeof(oldtype));
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/rand_r.cc b/compiler-rt/test/msan/rand_r.cc
new file mode 100644
index 0000000..f40cf9f
--- /dev/null
+++ b/compiler-rt/test/msan/rand_r.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -g -DUNINIT %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void) {
+  unsigned seed;
+#ifndef UNINIT
+  seed = 42;
+#endif
+  int v = rand_r(&seed);
+  // CHECK: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: in main{{.*}}rand_r.cc:[[@LINE-2]]
+  if (v) printf(".\n");
+  return 0;
+}
diff --git a/compiler-rt/test/msan/readdir64.cc b/compiler-rt/test/msan/readdir64.cc
new file mode 100644
index 0000000..e77ada6
--- /dev/null
+++ b/compiler-rt/test/msan/readdir64.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -O1 %s -o %t && %run %t
+// RUN: %clangxx_msan -O2 %s -o %t && %run %t
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t
+
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
+// RUN: %clangxx_msan -O1 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
+// RUN: %clangxx_msan -O2 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
+// RUN: %clangxx_msan -O3 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
+
+// Test that readdir64 is intercepted as well as readdir.
+
+#include <sys/types.h>
+#include <dirent.h>
+#include <stdlib.h>
+
+
+int main(void) {
+  DIR *dir = opendir(".");
+  struct dirent *d = readdir(dir);
+  if (d->d_name[0]) {
+    closedir(dir);
+    exit(0);
+  }
+  closedir(dir);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/realloc-large-origin.cc b/compiler-rt/test/msan/realloc-large-origin.cc
new file mode 100644
index 0000000..ce25ad8
--- /dev/null
+++ b/compiler-rt/test/msan/realloc-large-origin.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// This is a regression test: there used to be broken "stored to memory at"
+// stacks with
+//   in __msan_memcpy
+//   in __msan::MsanReallocate
+// and nothing below that.
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  char *p = (char *)malloc(100);
+  p = (char *)realloc(p, 10000);
+  char x = p[50];
+  free(p);
+  return x;
+
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+// CHECK:   {{#0 0x.* in main .*realloc-large-origin.cc:}}[[@LINE-3]]
+
+// CHECK:  Uninitialized value was stored to memory at
+// CHECK:   {{#0 0x.* in .*realloc}}
+// CHECK:   {{#1 0x.* in main .*realloc-large-origin.cc:}}[[@LINE-10]]
+
+// CHECK:   Uninitialized value was created by a heap allocation
+// CHECK:   {{#0 0x.* in .*malloc}}
+// CHECK:   {{#1 0x.* in main .*realloc-large-origin.cc:}}[[@LINE-15]]
+}
diff --git a/compiler-rt/test/msan/realloc-origin.cc b/compiler-rt/test/msan/realloc-origin.cc
new file mode 100644
index 0000000..e689371
--- /dev/null
+++ b/compiler-rt/test/msan/realloc-origin.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// This test relies on realloc from 100 to 101 being done in-place.
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  char *p = (char *)malloc(100);
+  p = (char *)realloc(p, 101);
+  char x = p[100];
+  free(p);
+  return x;
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*realloc-origin.cc:}}[[@LINE-2]]
+
+  // CHECK: Uninitialized value was created by a heap allocation
+  // CHECK: {{#0 0x.* in .*realloc}}
+  // CHECK: {{#1 0x.* in main .*realloc-origin.cc:}}[[@LINE-9]]
+}
diff --git a/compiler-rt/test/msan/report-demangling.cc b/compiler-rt/test/msan/report-demangling.cc
new file mode 100644
index 0000000..fbb6554
--- /dev/null
+++ b/compiler-rt/test/msan/report-demangling.cc
@@ -0,0 +1,19 @@
+// Test that function name is mangled in the "created by an allocation" line,
+// and demangled in the single-frame "stack trace" that follows.
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+
+__attribute__((noinline))
+int f() {
+  int x;
+  int *volatile p = &x;
+  return *p;
+}
+
+int main(int argc, char **argv) {
+  return f();
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame of function '_Z1fv'
+  // CHECK: #0 {{.*}} in f{{.*}} {{.*}}report-demangling.cc:[[@LINE-10]]
+}
diff --git a/compiler-rt/test/msan/scandir.cc b/compiler-rt/test/msan/scandir.cc
new file mode 100644
index 0000000..8adfe00
--- /dev/null
+++ b/compiler-rt/test/msan/scandir.cc
@@ -0,0 +1,56 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+
+static int my_filter(const struct dirent *a) {
+  assert(__msan_test_shadow(&a, sizeof(a)) == (size_t)-1);
+  printf("%s\n", a->d_name);
+  __msan_print_shadow(a, a->d_reclen);
+  assert(__msan_test_shadow(a, a->d_reclen) == (size_t)-1);
+  printf("%s\n", a->d_name);
+  return strlen(a->d_name) == 3 && a->d_name[2] == 'b';
+}
+
+static int my_compar(const struct dirent **a, const struct dirent **b) {
+  assert(__msan_test_shadow(a, sizeof(*a)) == (size_t)-1);
+  assert(__msan_test_shadow(*a, (*a)->d_reclen) == (size_t)-1);
+  assert(__msan_test_shadow(b, sizeof(*b)) == (size_t)-1);
+  assert(__msan_test_shadow(*b, (*b)->d_reclen) == (size_t)-1);
+  if ((*a)->d_name[1] == (*b)->d_name[1])
+    return 0;
+  return ((*a)->d_name[1] < (*b)->d_name[1]) ? 1 : -1;
+}
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "scandir_test_root/");
+  
+  struct dirent **d;
+  int res = scandir(buf, &d, my_filter, my_compar);
+  assert(res == 2);
+  assert(__msan_test_shadow(&d, sizeof(*d)) == (size_t)-1);
+  for (int i = 0; i < res; ++i) {
+    assert(__msan_test_shadow(&d[i], sizeof(d[i])) == (size_t)-1);
+    assert(__msan_test_shadow(d[i], d[i]->d_reclen) == (size_t)-1);
+  }
+
+  assert(strcmp(d[0]->d_name, "bbb") == 0);
+  assert(strcmp(d[1]->d_name, "aab") == 0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/scandir_null.cc b/compiler-rt/test/msan/scandir_null.cc
new file mode 100644
index 0000000..94ac31a
--- /dev/null
+++ b/compiler-rt/test/msan/scandir_null.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "scandir_test_root/");
+  
+  struct dirent **d;
+  int res = scandir(buf, &d, NULL, NULL);
+  assert(res >= 3);
+  assert(__msan_test_shadow(&d, sizeof(*d)) == (size_t)-1);
+  for (int i = 0; i < res; ++i) {
+    assert(__msan_test_shadow(&d[i], sizeof(d[i])) == (size_t)-1);
+    assert(__msan_test_shadow(d[i], d[i]->d_reclen) == (size_t)-1);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/msan/scandir_test_root/aaa b/compiler-rt/test/msan/scandir_test_root/aaa
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/scandir_test_root/aaa
diff --git a/compiler-rt/test/msan/scandir_test_root/aab b/compiler-rt/test/msan/scandir_test_root/aab
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/scandir_test_root/aab
diff --git a/compiler-rt/test/msan/scandir_test_root/bbb b/compiler-rt/test/msan/scandir_test_root/bbb
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler-rt/test/msan/scandir_test_root/bbb
diff --git a/compiler-rt/test/msan/select.cc b/compiler-rt/test/msan/select.cc
new file mode 100644
index 0000000..7b8c347
--- /dev/null
+++ b/compiler-rt/test/msan/select.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  int x;
+  int *volatile p = &x;
+  int z = *p ? 1 : 0;
+  if (z)
+    exit(0);
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*select.cc:}}[[@LINE-3]]
+
+  // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*select.cc:.* main}}
+  return 0;
+}
diff --git a/compiler-rt/test/msan/select_float_origin.cc b/compiler-rt/test/msan/select_float_origin.cc
new file mode 100644
index 0000000..75731dc
--- /dev/null
+++ b/compiler-rt/test/msan/select_float_origin.cc
@@ -0,0 +1,24 @@
+// Regression test for origin propagation in "select i1, float, float".
+// https://code.google.com/p/memory-sanitizer/issues/detail?id=78
+
+// RUN: %clangxx_msan -O2 -fsanitize-memory-track-origins %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -O2 -fsanitize-memory-track-origins=2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+#include <stdio.h>
+#include <sanitizer/msan_interface.h>
+
+int main() {
+  volatile bool b = true;
+  float x, y;
+  __msan_allocated_memory(&x, sizeof(x));
+  __msan_allocated_memory(&y, sizeof(y));
+  float z = b ? x : y;
+  if (z > 0) printf(".\n");
+  // CHECK: Memory was marked as uninitialized
+  // CHECK: {{#0 0x.* in .*__msan_allocated_memory}}
+  // CHECK: {{#1 0x.* in main .*select_float_origin.cc:}}[[@LINE-6]]
+  return 0;
+}
diff --git a/compiler-rt/test/msan/select_origin.cc b/compiler-rt/test/msan/select_origin.cc
new file mode 100644
index 0000000..e832c02
--- /dev/null
+++ b/compiler-rt/test/msan/select_origin.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// Test condition origin propagation through "select" IR instruction.
+
+#include <stdio.h>
+#include <stdint.h>
+
+__attribute__((noinline))
+int *max_by_ptr(int *a, int *b) {
+  return *a < *b ? b : a;
+}
+
+int main(void) {
+  int x;
+  int *volatile px = &x;
+  int y = 43;
+  int *p = max_by_ptr(px, &y);
+  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+  return *p;
+}
diff --git a/compiler-rt/test/msan/sem_getvalue.cc b/compiler-rt/test/msan/sem_getvalue.cc
new file mode 100644
index 0000000..07b95cd
--- /dev/null
+++ b/compiler-rt/test/msan/sem_getvalue.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <sanitizer/msan_interface.h>
+#include <semaphore.h>
+
+int main(void) {
+  sem_t sem;
+  int res = sem_init(&sem, 0, 42);
+  assert(res == 0);
+
+  int v;
+  res = sem_getvalue(&sem, &v);
+  assert(res == 0);
+  __msan_check_mem_is_initialized(&v, sizeof(v));
+  assert(v == 42);
+
+  res = sem_destroy(&sem);
+  assert(res == 0);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/setlocale.cc b/compiler-rt/test/msan/setlocale.cc
new file mode 100644
index 0000000..796f445
--- /dev/null
+++ b/compiler-rt/test/msan/setlocale.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <locale.h>
+#include <stdlib.h>
+
+int main(void) {
+  char *locale = setlocale (LC_ALL, "");
+  assert(locale);
+  if (locale[0])
+    exit(0);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/signal_stress_test.cc b/compiler-rt/test/msan/signal_stress_test.cc
new file mode 100644
index 0000000..5bc6f59
--- /dev/null
+++ b/compiler-rt/test/msan/signal_stress_test.cc
@@ -0,0 +1,71 @@
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+//
+// Test that va_arg shadow from a signal handler does not leak outside.
+
+#include <signal.h>
+#include <stdarg.h>
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <stdio.h>
+
+const int kSigCnt = 200;
+
+void f(bool poisoned, int n, ...) {
+  va_list vl;
+  va_start(vl, n);
+  for (int i = 0; i < n; ++i) {
+    void *p = va_arg(vl, void *);
+    if (!poisoned)
+      assert(__msan_test_shadow(&p, sizeof(p)) == -1);
+  }
+  va_end(vl);
+}
+
+int sigcnt;
+
+void SignalHandler(int signo) {
+  assert(signo == SIGPROF);
+  void *p;
+  void **volatile q = &p;
+  f(true, 10,
+    *q, *q, *q, *q, *q,
+    *q, *q, *q, *q, *q);
+  ++sigcnt;
+}
+
+int main() {
+  signal(SIGPROF, SignalHandler);
+
+  itimerval itv;
+  itv.it_interval.tv_sec = 0;
+  itv.it_interval.tv_usec = 100;
+  itv.it_value.tv_sec = 0;
+  itv.it_value.tv_usec = 100;
+  setitimer(ITIMER_PROF, &itv, NULL);
+
+  void *p;
+  void **volatile q = &p;
+
+  do {
+    f(false, 20,
+      nullptr, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, nullptr, nullptr, nullptr);
+    f(true, 20,
+      *q, *q, *q, *q, *q,
+      *q, *q, *q, *q, *q,
+      *q, *q, *q, *q, *q,
+      *q, *q, *q, *q, *q);
+  } while (sigcnt < kSigCnt);
+
+  itv.it_interval.tv_sec = 0;
+  itv.it_interval.tv_usec = 0;
+  itv.it_value.tv_sec = 0;
+  itv.it_value.tv_usec = 0;
+  setitimer(ITIMER_PROF, &itv, NULL);
+
+  signal(SIGPROF, SIG_DFL);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/sigwait.cc b/compiler-rt/test/msan/sigwait.cc
new file mode 100644
index 0000000..f2e77cf
--- /dev/null
+++ b/compiler-rt/test/msan/sigwait.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_msan -std=c++11 -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <sanitizer/msan_interface.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+void test_sigwait() {
+  sigset_t s;
+  sigemptyset(&s);
+  sigaddset(&s, SIGUSR1);
+  sigprocmask(SIG_BLOCK, &s, 0);
+
+  if (pid_t pid = fork()) {
+    kill(pid, SIGUSR1);
+    _exit(0);
+  } else {
+    int sig;
+    int res = sigwait(&s, &sig);
+    assert(!res);
+    // The following checks that sig is initialized.
+    assert(sig == SIGUSR1);
+  }
+}
+
+int main(void) {
+  test_sigwait();
+  return 0;
+}
diff --git a/compiler-rt/test/msan/sigwaitinfo.cc b/compiler-rt/test/msan/sigwaitinfo.cc
new file mode 100644
index 0000000..be7a2c0
--- /dev/null
+++ b/compiler-rt/test/msan/sigwaitinfo.cc
@@ -0,0 +1,31 @@
+// RUN: %clangxx_msan -std=c++11 -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <sanitizer/msan_interface.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+void test_sigwaitinfo() {
+  sigset_t s;
+  sigemptyset(&s);
+  sigaddset(&s, SIGUSR1);
+  sigprocmask(SIG_BLOCK, &s, 0);
+
+  if (pid_t pid = fork()) {
+    kill(pid, SIGUSR1);
+    _exit(0);
+  } else {
+    siginfo_t info;
+    int res = sigwaitinfo(&s, &info);
+    assert(!res);
+    // The following checks that sig is initialized.
+    assert(info.si_signo == SIGUSR1);
+    assert(-1 == __msan_test_shadow(&info, sizeof(info)));
+  }
+}
+
+int main(void) {
+  test_sigwaitinfo();
+  return 0;
+}
diff --git a/compiler-rt/test/msan/stack-origin.cc b/compiler-rt/test/msan/stack-origin.cc
new file mode 100644
index 0000000..e69c072
--- /dev/null
+++ b/compiler-rt/test/msan/stack-origin.cc
@@ -0,0 +1,31 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  int x;
+  int *volatile p = &x;
+  return *p;
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*stack-origin.cc:}}[[@LINE-2]]
+
+  // CHECK-ORIGINS: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+  // CHECK-ORIGINS: {{#0 0x.* in main .*stack-origin.cc:}}[[@LINE-8]]
+
+  // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*stack-origin.cc:.* main}}
+}
diff --git a/compiler-rt/test/msan/stack-origin2.cc b/compiler-rt/test/msan/stack-origin2.cc
new file mode 100644
index 0000000..6c7428c
--- /dev/null
+++ b/compiler-rt/test/msan/stack-origin2.cc
@@ -0,0 +1,41 @@
+// Test that on the second entry to a function the origins are still right.
+
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <stdlib.h>
+
+extern "C"
+int f(int depth) {
+  if (depth) return f(depth - 1);
+
+  int x;
+  int *volatile p = &x;
+  return *p;
+}
+
+int main(int argc, char **argv) {
+  return f(1);
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*stack-origin2.cc:}}[[@LINE-2]]
+
+  // CHECK-ORIGINS: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'f'
+  // CHECK-ORIGINS: {{#0 0x.* in f .*stack-origin2.cc:}}[[@LINE-14]]
+
+  // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*stack-origin2.cc:.* main}}
+}
diff --git a/compiler-rt/test/msan/strerror_r-non-gnu.c b/compiler-rt/test/msan/strerror_r-non-gnu.c
new file mode 100644
index 0000000..d55bf42
--- /dev/null
+++ b/compiler-rt/test/msan/strerror_r-non-gnu.c
@@ -0,0 +1,18 @@
+// RUN: %clang_msan -std=c99 -O0 -g %s -o %t && %run %t
+
+// strerror_r under a weird set of circumstances can be redirected to
+// __xpg_strerror_r. Test that MSan handles this correctly.
+
+#define _POSIX_C_SOURCE 200112
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+int main() {
+  char buf[1000];
+  int res = strerror_r(EINVAL, buf, sizeof(buf));
+  assert(!res);
+  volatile int z = strlen(buf);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/strlen_of_shadow.cc b/compiler-rt/test/msan/strlen_of_shadow.cc
new file mode 100644
index 0000000..3066dd5
--- /dev/null
+++ b/compiler-rt/test/msan/strlen_of_shadow.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+// Check that strlen() and similar intercepted functions can be called on shadow
+// memory.
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "test.h"
+
+const char *mem_to_shadow(const char *p) {
+#if defined(__x86_64__)
+  return (char *)((uintptr_t)p ^ 0x500000000000ULL);
+#elif defined (__mips64)
+  return (char *)((uintptr_t)p & ~0x4000000000ULL);
+#elif defined(__powerpc64__)
+#define LINEARIZE_MEM(mem) \
+  (((uintptr_t)(mem) & ~0x200000000000ULL) ^ 0x100000000000ULL)
+  return (char *)(LINEARIZE_MEM(p) + 0x080000000000ULL);
+#elif defined(__aarch64__)
+  return (char *)((uintptr_t)p ^ 0x6000000000ULL);
+#endif
+}
+
+int main(void) {
+  const char *s = "abcdef";
+  assert(strlen(s) == 6);
+  assert(strlen(mem_to_shadow(s)) == 0);
+
+  char *t = new char[42];
+  t[41] = 0;
+  assert(strlen(mem_to_shadow(t)) == 41);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/strxfrm.cc b/compiler-rt/test/msan/strxfrm.cc
new file mode 100644
index 0000000..9a30d03
--- /dev/null
+++ b/compiler-rt/test/msan/strxfrm.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <sanitizer/msan_interface.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void) {
+  const char *p = "abcdef";
+  char q[10];
+  size_t n = strxfrm(q, p, sizeof(q));
+  assert(n < sizeof(q));
+  __msan_check_mem_is_initialized(q, n + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/sync_lock_set_and_test.cc b/compiler-rt/test/msan/sync_lock_set_and_test.cc
new file mode 100644
index 0000000..11fd14f
--- /dev/null
+++ b/compiler-rt/test/msan/sync_lock_set_and_test.cc
@@ -0,0 +1,7 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+int main(void) {
+  int i;
+  __sync_lock_test_and_set(&i, 0);
+  return i;
+}
diff --git a/compiler-rt/test/msan/test.h b/compiler-rt/test/msan/test.h
new file mode 100644
index 0000000..a5dcdfc
--- /dev/null
+++ b/compiler-rt/test/msan/test.h
@@ -0,0 +1,15 @@
+#if __LP64__
+# define SANITIZER_WORDSIZE 64
+#else
+# define SANITIZER_WORDSIZE 32
+#endif
+
+// This is a simplified version of GetMaxVirtualAddress function.
+unsigned long SystemVMA () {
+#if SANITIZER_WORDSIZE == 64
+  unsigned long vma = (unsigned long)__builtin_frame_address(0);
+  return SANITIZER_WORDSIZE - __builtin_clzll(vma);
+#else
+  return SANITIZER_WORDSIZE;
+#endif
+}
diff --git a/compiler-rt/test/msan/textdomain.cc b/compiler-rt/test/msan/textdomain.cc
new file mode 100644
index 0000000..760debd
--- /dev/null
+++ b/compiler-rt/test/msan/textdomain.cc
@@ -0,0 +1,12 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+#include <libintl.h>
+#include <stdio.h>
+
+int main() {
+  const char *td = textdomain("abcd");
+  if (td[0] == 0) {
+    printf("Try read"); 
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/msan/times.cc b/compiler-rt/test/msan/times.cc
new file mode 100644
index 0000000..7c81884
--- /dev/null
+++ b/compiler-rt/test/msan/times.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/times.h>
+
+
+int main(void) {
+  struct tms t;
+  clock_t res = times(&t);
+  assert(res != (clock_t)-1);
+
+  if (t.tms_utime) printf("1\n");
+  if (t.tms_stime) printf("2\n");
+  if (t.tms_cutime) printf("3\n");
+  if (t.tms_cstime) printf("4\n");
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/tls_reuse.cc b/compiler-rt/test/msan/tls_reuse.cc
new file mode 100644
index 0000000..78a328f
--- /dev/null
+++ b/compiler-rt/test/msan/tls_reuse.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+// Check that when TLS block is reused between threads, its shadow is cleaned.
+
+#include <pthread.h>
+#include <stdio.h>
+
+int __thread x;
+
+void *ThreadFn(void *) {
+  if (!x)
+    printf("zzz\n");
+  int y;
+  int * volatile p = &y;
+  x = *p;
+  return 0;
+}
+
+int main(void) {
+  pthread_t t;
+  for (int i = 0; i < 100; ++i) {
+    pthread_create(&t, 0, ThreadFn, 0);
+    pthread_join(t, 0);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/msan/tsearch.cc b/compiler-rt/test/msan/tsearch.cc
new file mode 100644
index 0000000..653dc60
--- /dev/null
+++ b/compiler-rt/test/msan/tsearch.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <search.h>
+#include <stdlib.h>
+
+int compare(const void *pa, const void *pb) {
+  int a = *(const int *)pa;
+  int b = *(const int *)pb;
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
+}
+
+void myfreenode(void *p) {
+  delete (int *)p;
+}
+
+int main(void) {
+  void *root = NULL;
+  for (int i = 0; i < 5; ++i) {
+    int *p = new int(i);
+    void *q = tsearch(p, &root, compare);
+    if (q == NULL)
+      exit(1);
+    if (*(int **)q != p)
+      delete p;
+  }
+
+  tdestroy(root, myfreenode);
+
+  return 0;
+}
diff --git a/compiler-rt/test/msan/tzset.cc b/compiler-rt/test/msan/tzset.cc
new file mode 100644
index 0000000..05915e0
--- /dev/null
+++ b/compiler-rt/test/msan/tzset.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+extern char *tzname[2];
+
+int main(void) {
+  if (!strlen(tzname[0]) || !strlen(tzname[1]))
+    exit(1);
+  tzset();
+  if (!strlen(tzname[0]) || !strlen(tzname[1]))
+    exit(1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/unaligned_read_origin.cc b/compiler-rt/test/msan/unaligned_read_origin.cc
new file mode 100644
index 0000000..b04800a
--- /dev/null
+++ b/compiler-rt/test/msan/unaligned_read_origin.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char **argv) {
+  int x;
+  int *volatile p = &x;
+  return __sanitizer_unaligned_load32(p);
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*unaligned_read_origin.cc:}}[[@LINE-2]]
+  // CHECK: Uninitialized value was created by an allocation of 'x' in the stack frame of function 'main'
+  // CHECK: {{#0 0x.* in main .*unaligned_read_origin.cc:}}[[@LINE-7]]
+}
diff --git a/compiler-rt/test/msan/unpoison_string.cc b/compiler-rt/test/msan/unpoison_string.cc
new file mode 100644
index 0000000..84d9528
--- /dev/null
+++ b/compiler-rt/test/msan/unpoison_string.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t
+// RUN: %run %t
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t
+// RUN: %run %t
+
+#include <assert.h>
+#include <string.h>
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char **argv) {
+  char s[20] = "string";
+  __msan_poison(s, sizeof(s));
+  __msan_unpoison_string(s);
+  assert(__msan_test_shadow(s, sizeof(s)) == strlen("string") + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/msan/use-after-dtor.cc b/compiler-rt/test/msan/use-after-dtor.cc
new file mode 100644
index 0000000..6c751a1
--- /dev/null
+++ b/compiler-rt/test/msan/use-after-dtor.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_msan %s -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan %s -O2 -fsanitize=memory -fsanitize-memory-use-after-dtor -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan %s -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -fsanitize-memory-track-origins -o %t && MSAN_OPTIONS=poison_in_dtor=1 not %run %t >%t.out 2>&1
+// RUN: FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <sanitizer/msan_interface.h>
+#include <assert.h>
+#include <stdio.h>
+#include <new>
+
+struct Simple {
+  int x_;
+  Simple() {
+    x_ = 5;
+  }
+  ~Simple() {
+    x_ += 1;
+  }
+};
+
+int main() {
+  unsigned long buf[1];
+  assert(sizeof(Simple) <= sizeof(buf));
+
+  Simple *s = new(&buf) Simple();
+  s->~Simple();
+
+  return s->x_;
+
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main.*use-after-dtor.cc:}}[[@LINE-3]]
+
+  // CHECK-ORIGINS: Memory was marked as uninitialized
+  // CHECK-ORIGINS: {{#0 0x.* in __sanitizer_dtor_callback}}
+  // CHECK-ORIGINS: {{#1 0x.* in Simple::~Simple}}
+
+  // CHECK: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*main}}
+}
diff --git a/compiler-rt/test/msan/use-after-free.cc b/compiler-rt/test/msan/use-after-free.cc
new file mode 100644
index 0000000..c505124
--- /dev/null
+++ b/compiler-rt/test/msan/use-after-free.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+// RUN: %clangxx_msan -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out
+
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+// RUN: %clangxx_msan -fsanitize-memory-track-origins -O3 %s -o %t && not %run %t >%t.out 2>&1
+// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  int *volatile p = (int *)malloc(sizeof(int));
+  *p = 42;
+  free(p);
+
+  if (*p)
+    exit(0);
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: {{#0 0x.* in main .*use-after-free.cc:}}[[@LINE-3]]
+
+  // CHECK-ORIGINS: Uninitialized value was created by a heap deallocation
+  // CHECK-ORIGINS: {{#0 0x.* in .*free}}
+  // CHECK-ORIGINS: {{#1 0x.* in main .*use-after-free.cc:}}[[@LINE-9]]
+  return 0;
+}
diff --git a/compiler-rt/test/msan/vector_cvt.cc b/compiler-rt/test/msan/vector_cvt.cc
new file mode 100644
index 0000000..633a8b1
--- /dev/null
+++ b/compiler-rt/test/msan/vector_cvt.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -DPOSITIVE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// REQUIRES: x86_64-supported-target
+
+#include <emmintrin.h>
+
+int to_int(double v) {
+  __m128d t = _mm_set_sd(v);
+  int x = _mm_cvtsd_si32(t);
+  return x;
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK: #{{.*}} in to_int{{.*}}vector_cvt.cc:[[@LINE-3]]
+}
+
+int main() {
+#ifdef POSITIVE
+  double v;
+#else
+  double v = 1.1;
+#endif
+  double* volatile p = &v;
+  int x = to_int(*p);
+  return !x;
+}
diff --git a/compiler-rt/test/msan/vector_select.cc b/compiler-rt/test/msan/vector_select.cc
new file mode 100644
index 0000000..0cf1164
--- /dev/null
+++ b/compiler-rt/test/msan/vector_select.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_msan -O0 %s -c -o %t
+// RUN: %clangxx_msan -O3 %s -c -o %t
+
+// Regression test for MemorySanitizer instrumentation of a select instruction
+// with vector arguments.
+
+#if defined(__x86_64__)
+#include <emmintrin.h>
+
+__m128d select(bool b, __m128d c, __m128d d)
+{
+  return b ? c : d;
+}
+#elif defined (__mips64) || defined (__powerpc64__)
+typedef double __w64d __attribute__ ((vector_size(16)));
+
+__w64d select(bool b, __w64d c, __w64d d)
+{
+  return b ? c : d;
+}
+#endif
diff --git a/compiler-rt/test/profile/CMakeLists.txt b/compiler-rt/test/profile/CMakeLists.txt
new file mode 100644
index 0000000..28fb35a
--- /dev/null
+++ b/compiler-rt/test/profile/CMakeLists.txt
@@ -0,0 +1,16 @@
+set(PROFILE_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(PROFILE_LIT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+set(PROFILE_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND PROFILE_TEST_DEPS profile llvm-profdata)
+endif()
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+  )
+add_lit_testsuite(check-profile "Running the profile tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS ${PROFILE_TEST_DEPS})
+set_target_properties(check-profile PROPERTIES FOLDER "Profile tests")
diff --git a/compiler-rt/test/profile/Inputs/gcc-flag-compatibility.c b/compiler-rt/test/profile/Inputs/gcc-flag-compatibility.c
new file mode 100644
index 0000000..1c07bb1
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/gcc-flag-compatibility.c
@@ -0,0 +1,8 @@
+int X = 0;
+
+int main() {
+  int i;
+  for (i = 0; i < 100; i++)
+    X += i;
+  return 0;
+}
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dlopen-func.c b/compiler-rt/test/profile/Inputs/instrprof-dlopen-func.c
new file mode 100644
index 0000000..f2de388
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dlopen-func.c
@@ -0,0 +1 @@
+void func(int K) { if (K) {} }
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dlopen-func2.c b/compiler-rt/test/profile/Inputs/instrprof-dlopen-func2.c
new file mode 100644
index 0000000..d4d93dc
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dlopen-func2.c
@@ -0,0 +1 @@
+void func2(int K) { if (K) {} }
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dlopen-main.c b/compiler-rt/test/profile/Inputs/instrprof-dlopen-main.c
new file mode 100644
index 0000000..ec357fe
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dlopen-main.c
@@ -0,0 +1,47 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef DLOPEN_FUNC_DIR
+#include <dlfcn.h>
+#else
+void func(int K);
+void func2(int K);
+#endif
+
+int main(int argc, char *argv[]) {
+#ifdef DLOPEN_FUNC_DIR
+  dlerror();
+  void *f1_handle = dlopen(DLOPEN_FUNC_DIR"/func.shared", DLOPEN_FLAGS);
+  if (f1_handle == NULL) {
+    fprintf(stderr, "unable to open '" DLOPEN_FUNC_DIR "/func.shared': %s\n",
+            dlerror());
+    return EXIT_FAILURE;
+  }
+
+  void (*func)(int) = (void (*)(int))dlsym(f1_handle, "func");
+  if (func == NULL) {
+    fprintf(stderr, "unable to lookup symbol 'func': %s\n", dlerror());
+    return EXIT_FAILURE;
+  }
+
+  void *f2_handle = dlopen(DLOPEN_FUNC_DIR"/func2.shared", DLOPEN_FLAGS);
+  if (f2_handle == NULL) {
+    fprintf(stderr, "unable to open '" DLOPEN_FUNC_DIR "/func2.shared': %s\n",
+            dlerror());
+    return EXIT_FAILURE;
+  }
+
+  void (*func2)(int) = (void (*)(int))dlsym(f2_handle, "func2");
+  if (func2 == NULL) {
+    fprintf(stderr, "unable to lookup symbol 'func2': %s\n", dlerror());
+    return EXIT_FAILURE;
+  }
+#endif
+
+  func(1);
+  func2(0);
+
+  return EXIT_SUCCESS;
+}
+
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dynamic-a.cpp b/compiler-rt/test/profile/Inputs/instrprof-dynamic-a.cpp
new file mode 100644
index 0000000..2ec484a
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dynamic-a.cpp
@@ -0,0 +1,7 @@
+#include "instrprof-dynamic-header.h"
+void a() {
+  if (true) {
+    bar<void>(1);
+    bar<char>(1);
+  }
+}
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dynamic-b.cpp b/compiler-rt/test/profile/Inputs/instrprof-dynamic-b.cpp
new file mode 100644
index 0000000..5c2d9ba
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dynamic-b.cpp
@@ -0,0 +1,7 @@
+#include "instrprof-dynamic-header.h"
+void b() {
+  if (true) {
+    bar<void>(1);
+    bar<int>(1);
+  }
+}
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dynamic-header.h b/compiler-rt/test/profile/Inputs/instrprof-dynamic-header.h
new file mode 100644
index 0000000..7a57b13
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dynamic-header.h
@@ -0,0 +1,7 @@
+template <class T> void bar(int X) {
+  if (X) {
+    X *= 4;
+  }
+}
+void a();
+void b();
diff --git a/compiler-rt/test/profile/Inputs/instrprof-dynamic-main.cpp b/compiler-rt/test/profile/Inputs/instrprof-dynamic-main.cpp
new file mode 100644
index 0000000..2cf37c8
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-dynamic-main.cpp
@@ -0,0 +1,9 @@
+#include "instrprof-dynamic-header.h"
+void foo(int K) { if (K) {} }
+int main(int argc, char *argv[]) {
+  foo(5);
+  bar<void>(1);
+  a();
+  b();
+  return 0;
+}
diff --git a/compiler-rt/test/profile/Inputs/instrprof-shared-lib.c b/compiler-rt/test/profile/Inputs/instrprof-shared-lib.c
new file mode 100644
index 0000000..d22b0a5
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-shared-lib.c
@@ -0,0 +1,9 @@
+int g1 = 0;
+int g2 = 1;
+
+void foo(int n) {
+  if (n % 5 == 0)
+    g1++;
+  else
+    g2++;
+}
diff --git a/compiler-rt/test/profile/Inputs/instrprof-shared-main.c b/compiler-rt/test/profile/Inputs/instrprof-shared-main.c
new file mode 100644
index 0000000..60da3b4
--- /dev/null
+++ b/compiler-rt/test/profile/Inputs/instrprof-shared-main.c
@@ -0,0 +1,13 @@
+extern int g1, g2;
+extern void foo(int n);
+
+int main() {
+  int i, j;
+  for (i = 0; i < 1000; i++)
+    for (j = 0; j < 1000; j++)
+      foo(i * j);
+
+  if (g2 - g1 == 280001)
+    return 0;
+  return 1;
+}
diff --git a/compiler-rt/test/profile/gcc-flag-compatibility.test b/compiler-rt/test/profile/gcc-flag-compatibility.test
new file mode 100644
index 0000000..8e8b55d
--- /dev/null
+++ b/compiler-rt/test/profile/gcc-flag-compatibility.test
@@ -0,0 +1,17 @@
+RUN: mkdir -p %t.d
+RUN: %clang_profgen_gcc=%t.d/d1/d2 -o %t.d/code %S/Inputs/gcc-flag-compatibility.c
+
+# Test that the instrumented code writes to %t.d/d1/d2/default.profraw
+RUN: %run %t.d/code
+RUN: llvm-profdata merge -o %t.profdata %t.d/d1/d2/default.profraw
+
+# Test that we can override the directory and file name with LLVM_PROFILE_FILE.
+RUN: env LLVM_PROFILE_FILE=%t.d/x1/prof.raw %run %t.d/code
+RUN: llvm-profdata merge -o %t.profdata %t.d/x1/prof.raw
+
+# Test that we can specify a directory with -fprofile-use.
+RUN: llvm-profdata merge -o %t.d/default.profdata %t.d/x1/prof.raw
+RUN: %clang_profuse_gcc=%t.d -o %t.d/code %S/Inputs/gcc-flag-compatibility.c
+
+# Test that we can specify a file with -fprofile-use.
+RUN: %clang_profuse_gcc=%t.profdata -o %t.d/code %S/Inputs/gcc-flag-compatibility.c
diff --git a/compiler-rt/test/profile/instrprof-basic.c b/compiler-rt/test/profile/instrprof-basic.c
new file mode 100644
index 0000000..995525b
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-basic.c
@@ -0,0 +1,31 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+int begin(int i) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (i)
+    return 0;
+  return 1;
+}
+
+int end(int i) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD2:[0-9]+]]
+  if (i)
+    return 0;
+  return 1;
+}
+
+int main(int argc, const char *argv[]) {
+  begin(0);
+  end(1);
+
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD2:[0-9]+]]
+  if (argc)
+    return 0;
+  return 1;
+}
+
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
+// CHECK: ![[PD2]] = !{!"branch_weights", i32 2, i32 1}
diff --git a/compiler-rt/test/profile/instrprof-dlopen.test b/compiler-rt/test/profile/instrprof-dlopen.test
new file mode 100644
index 0000000..ba386e3
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-dlopen.test
@@ -0,0 +1,34 @@
+RUN: mkdir -p %t.d
+RUN: %clang_profgen -o %t.d/func.shared -fPIC -shared %S/Inputs/instrprof-dlopen-func.c
+RUN: %clang_profgen -o %t.d/func2.shared -fPIC -shared %S/Inputs/instrprof-dlopen-func2.c
+RUN: %clang -o %t-local -fPIC -DDLOPEN_FUNC_DIR=\"%t.d\" -DDLOPEN_FLAGS="RTLD_LAZY | RTLD_LOCAL" %S/Inputs/instrprof-dlopen-main.c
+RUN: %clang -o %t-global -fPIC -DDLOPEN_FUNC_DIR=\"%t.d\" -DDLOPEN_FLAGS="RTLD_LAZY | RTLD_GLOBAL" %S/Inputs/instrprof-dlopen-main.c
+
+RUN: %clang -c -o %t.d/main.o %S/Inputs/instrprof-dlopen-main.c
+RUN: %clang_profgen -o %t-static %S/Inputs/instrprof-dlopen-func.c %S/Inputs/instrprof-dlopen-func2.c %t.d/main.o
+
+RUN: env LLVM_PROFILE_FILE=%t-static.profraw %run %t-static
+RUN: env LLVM_PROFILE_FILE=%t-local.profraw %run %t-local
+RUN: env LLVM_PROFILE_FILE=%t-global.profraw %run %t-global
+
+RUN: llvm-profdata merge -o %t-static.profdata %t-static.profraw
+RUN: llvm-profdata merge -o %t-local.profdata %t-local.profraw
+RUN: llvm-profdata merge -o %t-global.profdata %t-global.profraw
+
+RUN: %clang_profuse=%t-static.profdata -o %t-func.static.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-func.c
+RUN: %clang_profuse=%t-local.profdata -o %t-func.local.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-func.c
+RUN: %clang_profuse=%t-global.profdata -o %t-func.global.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-func.c
+RUN: diff %t-func.static.ll %t-func.local.ll
+RUN: diff %t-func.static.ll %t-func.global.ll
+
+RUN: %clang_profuse=%t-static.profdata -o %t-func2.static.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-func2.c
+RUN: %clang_profuse=%t-local.profdata -o %t-func2.local.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-func2.c
+RUN: %clang_profuse=%t-global.profdata -o %t-func2.global.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-func2.c
+RUN: diff %t-func2.static.ll %t-func2.local.ll
+RUN: diff %t-func2.static.ll %t-func2.global.ll
+
+RUN: %clang_profuse=%t-static.profdata -o %t-main.static.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-main.c
+RUN: %clang_profuse=%t-local.profdata -o %t-main.local.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-main.c
+RUN: %clang_profuse=%t-local.profdata -o %t-main.global.ll -S -emit-llvm %S/Inputs/instrprof-dlopen-main.c
+RUN: diff %t-main.static.ll %t-main.local.ll
+RUN: diff %t-main.static.ll %t-main.global.ll
diff --git a/compiler-rt/test/profile/instrprof-dynamic-one-shared.test b/compiler-rt/test/profile/instrprof-dynamic-one-shared.test
new file mode 100644
index 0000000..38be4fe
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-dynamic-one-shared.test
@@ -0,0 +1,23 @@
+RUN: mkdir -p %t.d
+RUN: %clang_profgen -o %t.d/a.shared -fPIC -shared %S/Inputs/instrprof-dynamic-a.cpp
+RUN: %clang_profgen -o %t-shared -fPIC -rpath %t.d %t.d/a.shared %S/Inputs/instrprof-dynamic-b.cpp %S/Inputs/instrprof-dynamic-main.cpp
+
+RUN: %clang_profgen -o %t-static %S/Inputs/instrprof-dynamic-a.cpp %S/Inputs/instrprof-dynamic-b.cpp %S/Inputs/instrprof-dynamic-main.cpp
+
+RUN: env LLVM_PROFILE_FILE=%t-static.profraw %run %t-static
+RUN: env LLVM_PROFILE_FILE=%t-shared.profraw %run %t-shared
+
+RUN: llvm-profdata merge -o %t-static.profdata %t-static.profraw
+RUN: llvm-profdata merge -o %t-shared.profdata %t-shared.profraw
+
+RUN: %clang_profuse=%t-static.profdata -o %t-a.static.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-a.cpp
+RUN: %clang_profuse=%t-shared.profdata -o %t-a.shared.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-a.cpp
+RUN: diff %t-a.static.ll %t-a.shared.ll
+
+RUN: %clang_profuse=%t-static.profdata -o %t-b.static.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-b.cpp
+RUN: %clang_profuse=%t-shared.profdata -o %t-b.shared.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-b.cpp
+RUN: diff %t-b.static.ll %t-b.shared.ll
+
+RUN: %clang_profuse=%t-static.profdata -o %t-main.static.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-main.cpp
+RUN: %clang_profuse=%t-shared.profdata -o %t-main.shared.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-main.cpp
+RUN: diff %t-main.static.ll %t-main.shared.ll
diff --git a/compiler-rt/test/profile/instrprof-dynamic-two-shared.test b/compiler-rt/test/profile/instrprof-dynamic-two-shared.test
new file mode 100644
index 0000000..830359d
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-dynamic-two-shared.test
@@ -0,0 +1,24 @@
+RUN: mkdir -p %t.d
+RUN: %clang_profgen -o %t.d/a.shared -fPIC -shared %S/Inputs/instrprof-dynamic-a.cpp
+RUN: %clang_profgen -o %t.d/b.shared -fPIC -shared %S/Inputs/instrprof-dynamic-b.cpp
+RUN: %clang_profgen -o %t-shared -fPIC -rpath %t.d %t.d/a.shared %t.d/b.shared %S/Inputs/instrprof-dynamic-main.cpp
+
+RUN: %clang_profgen -o %t-static %S/Inputs/instrprof-dynamic-a.cpp %S/Inputs/instrprof-dynamic-b.cpp %S/Inputs/instrprof-dynamic-main.cpp
+
+RUN: env LLVM_PROFILE_FILE=%t-static.profraw %run %t-static
+RUN: env LLVM_PROFILE_FILE=%t-shared.profraw %run %t-shared
+
+RUN: llvm-profdata merge -o %t-static.profdata %t-static.profraw
+RUN: llvm-profdata merge -o %t-shared.profdata %t-shared.profraw
+
+RUN: %clang_profuse=%t-static.profdata -o %t-a.static.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-a.cpp
+RUN: %clang_profuse=%t-shared.profdata -o %t-a.shared.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-a.cpp
+RUN: diff %t-a.static.ll %t-a.shared.ll
+
+RUN: %clang_profuse=%t-static.profdata -o %t-b.static.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-b.cpp
+RUN: %clang_profuse=%t-shared.profdata -o %t-b.shared.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-b.cpp
+RUN: diff %t-b.static.ll %t-b.shared.ll
+
+RUN: %clang_profuse=%t-static.profdata -o %t-main.static.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-main.cpp
+RUN: %clang_profuse=%t-shared.profdata -o %t-main.shared.ll -S -emit-llvm %S/Inputs/instrprof-dynamic-main.cpp
+RUN: diff %t-main.static.ll %t-main.shared.ll
diff --git a/compiler-rt/test/profile/instrprof-error.c b/compiler-rt/test/profile/instrprof-error.c
new file mode 100644
index 0000000..4386d53
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-error.c
@@ -0,0 +1,12 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: touch %t.profraw
+// RUN: chmod -w %t.profraw
+// RUN: LLVM_PROFILE_FILE=%t.profraw LLVM_PROFILE_VERBOSE_ERRORS=1 %run %t 1 2>&1 | FileCheck %s
+// RUN: chmod +w %t.profraw
+
+int main(int argc, const char *argv[]) {
+  if (argc < 2)
+    return 1;
+  return 0;
+}
+// CHECK: LLVM Profile: Failed to write file 
diff --git a/compiler-rt/test/profile/instrprof-override-filename-then-reset-default.c b/compiler-rt/test/profile/instrprof-override-filename-then-reset-default.c
new file mode 100644
index 0000000..137a3b2
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-override-filename-then-reset-default.c
@@ -0,0 +1,19 @@
+// RUN: rm -rf %t.d
+// RUN: mkdir -p %t.d
+// RUN: cd %t.d
+// RUN: %clang_profgen -O3 %s -o %t.out
+// RUN: %run %t.out %t.d/bad.profraw
+// RUN: llvm-profdata merge -o %t.d/default.profdata %t.d/default.profraw
+// RUN: %clang_profuse=%t.d/default.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+
+void __llvm_profile_override_default_filename(const char *);
+int main(int argc, const char *argv[]) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+  __llvm_profile_override_default_filename(argv[1]);
+  __llvm_profile_override_default_filename(0);
+  return 0;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-override-filename-with-env.c b/compiler-rt/test/profile/instrprof-override-filename-with-env.c
new file mode 100644
index 0000000..cce8389
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-override-filename-with-env.c
@@ -0,0 +1,14 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: env LLVM_PROFILE_FILE=%t.good.profraw %run %t %t.bad.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.good.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+void __llvm_profile_override_default_filename(const char *);
+int main(int argc, const char *argv[]) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+  __llvm_profile_override_default_filename(argv[1]);
+  return 0;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-override-filename.c b/compiler-rt/test/profile/instrprof-override-filename.c
new file mode 100644
index 0000000..59dea29
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-override-filename.c
@@ -0,0 +1,14 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: %run %t %t.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+void __llvm_profile_override_default_filename(const char *);
+int main(int argc, const char *argv[]) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+  __llvm_profile_override_default_filename(argv[1]);
+  return 0;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-reset-counters.c b/compiler-rt/test/profile/instrprof-reset-counters.c
new file mode 100644
index 0000000..e889236
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-reset-counters.c
@@ -0,0 +1,19 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+void __llvm_profile_reset_counters(void);
+void foo(int);
+int main(void) {
+  foo(0);
+  __llvm_profile_reset_counters();
+  foo(1);
+  return 0;
+}
+void foo(int N) {
+  // CHECK-LABEL: define void @foo(
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[FOO:[0-9]+]]
+  if (N) {}
+}
+// CHECK: ![[FOO]] = !{!"branch_weights", i32 2, i32 1}
diff --git a/compiler-rt/test/profile/instrprof-set-filename-then-reset-default.c b/compiler-rt/test/profile/instrprof-set-filename-then-reset-default.c
new file mode 100644
index 0000000..6c07994
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-set-filename-then-reset-default.c
@@ -0,0 +1,18 @@
+// RUN: rm -rf %t.d
+// RUN: mkdir -p %t.d
+// RUN: cd %t.d
+// RUN: %clang_profgen -O3 %s -o %t.out
+// RUN: %run %t.out %t.d/bad.profraw
+// RUN: llvm-profdata merge -o %t.d/default.profdata %t.d/default.profraw
+// RUN: %clang_profuse=%t.d/default.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+void __llvm_profile_set_filename(const char *);
+int main(int argc, const char *argv[]) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+  __llvm_profile_set_filename(argv[1]);
+  __llvm_profile_set_filename(0);
+  return 0;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-set-filename.c b/compiler-rt/test/profile/instrprof-set-filename.c
new file mode 100644
index 0000000..51aa423
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-set-filename.c
@@ -0,0 +1,14 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: %run %t %t.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+void __llvm_profile_set_filename(const char *);
+int main(int argc, const char *argv[]) {
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+  __llvm_profile_set_filename(argv[1]);
+  return 0;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-shared.test b/compiler-rt/test/profile/instrprof-shared.test
new file mode 100644
index 0000000..851578b
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-shared.test
@@ -0,0 +1,75 @@
+"""
+This test produces three shared libraries:
+
+1. libt-instr.so is instrumented
+2. libt-no-instr1.so is not instrumented
+3. libt-no-instr2.so is compiled with instrumentation enabled, but the object file is built
+   with instrumentation turned off.
+
+After the libraries are built, the main program is then built with/without instrumentation and linked
+against 3 libraries above.
+
+The test is to verify that programs linked against these shared objects with and without instrumentation
+enabled behave as expected.
+"""
+
+RUN: mkdir -p %t.d
+RUN: %clang_profgen -o %t.d/libt-instr.so -fPIC -shared %S/Inputs/instrprof-shared-lib.c
+RUN: %clang -o %t.d/libt-no-instr1.so -fPIC -shared %S/Inputs/instrprof-shared-lib.c
+RUN: %clang -c -o %t.d/instrprof-shared-lib-no-instr2.o -fPIC  %S/Inputs/instrprof-shared-lib.c
+RUN: %clang_profgen -o %t.d/libt-no-instr2.so -fPIC -shared %t.d/instrprof-shared-lib-no-instr2.o
+
+RUN: %clang_profgen -o %t-instr-instr -L%t.d -rpath %t.d -lt-instr  %S/Inputs/instrprof-shared-main.c
+RUN: %clang_profgen -o %t-instr-no-instr1 -L%t.d -rpath %t.d -lt-no-instr1  %S/Inputs/instrprof-shared-main.c
+RUN: %clang_profgen -o %t-instr-no-instr2 -L%t.d -rpath %t.d -lt-no-instr2  %S/Inputs/instrprof-shared-main.c
+RUN: %clang -o %t-no-instr1-instr -L%t.d -rpath %t.d -lt-instr  %S/Inputs/instrprof-shared-main.c
+RUN: %clang -o %t-no-instr1-no-instr1 -L%t.d -rpath %t.d -lt-no-instr1  %S/Inputs/instrprof-shared-main.c
+RUN: %clang -o %t-no-instr1-no-instr2 -L%t.d -rpath %t.d -lt-no-instr2  %S/Inputs/instrprof-shared-main.c
+RUN: %clang -c -o %t.d/instrprof-shared-main-no-instr2.o  %S/Inputs/instrprof-shared-main.c
+RUN: %clang -o %t-no-instr2-instr -L%t.d -rpath %t.d -lt-instr  %t.d/instrprof-shared-main-no-instr2.o
+RUN: %clang -o %t-no-instr2-no-instr1 -L%t.d -rpath %t.d -lt-no-instr1  %t.d/instrprof-shared-main-no-instr2.o
+RUN: %clang -o %t-no-instr2-no-instr2 -L%t.d -rpath %t.d -lt-no-instr2  %t.d/instrprof-shared-main-no-instr2.o
+
+RUN: env LLVM_PROFILE_FILE=%t-instr-instr.profraw %run %t-instr-instr
+RUN: env LLVM_PROFILE_FILE=%t-instr-no-instr1.profraw %run %t-instr-no-instr1
+RUN: env LLVM_PROFILE_FILE=%t-instr-no-instr2.profraw %run %t-instr-no-instr2
+RUN: env LLVM_PROFILE_FILE=%t-no-instr1-instr.profraw %run %t-no-instr1-instr
+RUN: env LLVM_PROFILE_FILE=%t-no-instr2-instr.profraw %run %t-no-instr2-instr
+RUN: env LLVM_PROFILE_FILE=%t-no-instr1-no-instr1.profraw %run %t-no-instr1-no-instr1
+RUN: env LLVM_PROFILE_FILE=%t-no-instr1-no-instr2.profraw %run %t-no-instr1-no-instr2
+RUN: env LLVM_PROFILE_FILE=%t-no-instr2-no-instr1.profraw %run %t-no-instr2-no-instr1
+RUN: env LLVM_PROFILE_FILE=%t-no-instr2-no-instr2.profraw %run %t-no-instr2-no-instr2
+
+RUN: llvm-profdata merge -o %t-instr-instr.profdata %t-instr-instr.profraw
+RUN: llvm-profdata merge -o %t-instr-no-instr1.profdata %t-instr-no-instr1.profraw
+RUN: llvm-profdata merge -o %t-instr-no-instr2.profdata %t-instr-no-instr2.profraw
+RUN: llvm-profdata merge -o %t-no-instr1-instr.profdata %t-no-instr1-instr.profraw
+RUN: llvm-profdata merge -o %t-no-instr2-instr.profdata %t-no-instr2-instr.profraw
+
+RUN: not llvm-profdata merge -o %t-no-instr1-no-instr1.profdata %t-no-instr1-no-instr1.profraw 2>&1 | FileCheck %s --check-prefix=MISSING-FILE
+RUN: not llvm-profdata merge -o %t-no-instr2-no-instr1.profdata %t-no-instr2-no-instr1.profraw 2>&1 | FileCheck %s --check-prefix=MISSING-FILE
+MISSING-FILE: profraw
+
+RUN: llvm-profdata show -counts --function main %t-instr-instr.profdata | grep -v 'Total\|Maximum' > %t-main-1
+RUN: llvm-profdata show -counts --function main %t-instr-no-instr1.profdata | grep -v 'Total\|Maximum' > %t-main-2
+RUN: llvm-profdata show -counts --function main %t-instr-no-instr2.profdata | grep -v 'Total\|Maximum' > %t-main-3
+RUN: llvm-profdata show -counts --function foo %t-instr-instr.profdata | grep -v 'Total\|Maximum' > %t-foo-1
+RUN: llvm-profdata show -counts --function foo %t-no-instr1-instr.profdata | grep -v 'Total\|Maximum' > %t-foo-2
+RUN: llvm-profdata show -counts --function foo %t-no-instr2-instr.profdata | grep -v 'Total\|Maximum'  > %t-foo-3
+
+RUN: %clang_profuse=%t-instr-instr.profdata -o %t-main-instr-instr.ll -S -emit-llvm %S/Inputs/instrprof-shared-main.c
+RUN: %clang_profuse=%t-instr-no-instr1.profdata -o %t-main-instr-no-instr1.ll -S -emit-llvm %S/Inputs/instrprof-shared-main.c
+RUN: %clang_profuse=%t-instr-no-instr2.profdata -o %t-main-instr-no-instr2.ll -S -emit-llvm %S/Inputs/instrprof-shared-main.c
+RUN: %clang_profuse=%t-instr-instr.profdata -o %t-lib-instr-instr.ll -S -emit-llvm %S/Inputs/instrprof-shared-lib.c
+RUN: %clang_profuse=%t-no-instr1-instr.profdata -o %t-lib-no-instr1-instr.ll -S -emit-llvm %S/Inputs/instrprof-shared-lib.c
+RUN: %clang_profuse=%t-no-instr2-instr.profdata -o %t-lib-no-instr2-instr.ll -S -emit-llvm %S/Inputs/instrprof-shared-lib.c
+RUN: %clang_profuse=%t-instr-instr.profdata -o %t-lib-instr-instr.ll -S -emit-llvm %S/Inputs/instrprof-shared-lib.c
+
+RUN: diff %t-main-instr-no-instr1.ll %t-main-instr-no-instr2.ll
+RUN: diff %t-lib-no-instr1-instr.ll %t-lib-no-instr2-instr.ll
+
+RUN: diff %t-main-1 %t-main-2
+RUN: diff %t-main-1 %t-main-3
+RUN: diff %t-foo-1 %t-foo-2
+RUN: diff %t-foo-1 %t-foo-3
+
diff --git a/compiler-rt/test/profile/instrprof-value-prof-2.c b/compiler-rt/test/profile/instrprof-value-prof-2.c
new file mode 100644
index 0000000..b8624b1
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-value-prof-2.c
@@ -0,0 +1,135 @@
+// RUN: %clang_profgen -O2 -o %t %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: llvm-profdata show --all-functions -ic-targets  %t.profdata |  FileCheck  %s 
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+typedef struct __llvm_profile_data __llvm_profile_data;
+const __llvm_profile_data *__llvm_profile_begin_data(void);
+const __llvm_profile_data *__llvm_profile_end_data(void);
+void __llvm_profile_set_num_value_sites(__llvm_profile_data *Data,
+                                        uint32_t ValueKind,
+                                        uint16_t NumValueSites);
+__llvm_profile_data *
+__llvm_profile_iterate_data(const __llvm_profile_data *Data);
+void *__llvm_get_function_addr(const __llvm_profile_data *Data);
+void __llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
+                                      uint32_t CounterIndex);
+void callee1() {}
+void callee2() {}
+
+void caller_without_value_site1() {}
+void caller_with_value_site_never_called1() {}
+void caller_with_vp1() {}
+void caller_with_value_site_never_called2() {}
+void caller_without_value_site2() {}
+void caller_with_vp2() {}
+
+int main(int argc, const char *argv[]) {
+  unsigned S, NS = 10, V;
+  const __llvm_profile_data *Data, *DataEnd;
+
+  Data = __llvm_profile_begin_data();
+  DataEnd = __llvm_profile_end_data();
+  for (; Data < DataEnd; Data = __llvm_profile_iterate_data(Data)) {
+    void *func = __llvm_get_function_addr(Data);
+    if (func == caller_without_value_site1 ||
+        func == caller_without_value_site2 ||
+        func == callee1 || func == callee2 || func == main)
+      continue;
+
+    __llvm_profile_set_num_value_sites((__llvm_profile_data *)Data,
+                                       0 /*IPVK_IndirectCallTarget */, 10);
+
+    if (func == caller_with_value_site_never_called1 ||
+        func == caller_with_value_site_never_called2)
+      continue;
+    for (S = 0; S < NS; S++) {
+      unsigned C;
+      for (C = 0; C < S + 1; C++) {
+        __llvm_profile_instrument_target((uint64_t)&callee1, (void *)Data, S);
+        if (C % 2 == 0)
+          __llvm_profile_instrument_target((uint64_t)&callee2, (void *)Data, S);
+      }
+    }
+  }
+}
+
+// CHECK:  caller_with_value_site_never_called2:
+// CHECK-NEXT:    Hash: 0x0000000000000000
+// CHECK-NEXT:    Counters:
+// CHECK-NEXT:    Function count
+// CHECK-NEXT:    Indirect Call Site Count: 10
+// CHECK-NEXT:    Indirect Target Results: 
+// CHECK:       caller_with_vp2:
+// CHECK-NEXT:    Hash: 0x0000000000000000
+// CHECK-NEXT:    Counters:
+// CHECK-NEXT:    Function count:
+// CHECK-NEXT:    Indirect Call Site Count: 10
+// CHECK-NEXT:    Indirect Target Results: 
+// CHECK-NEXT:	[ 0, callee1, 1 ]
+// CHECK-NEXT:	[ 0, callee2, 1 ]
+// CHECK-NEXT:	[ 1, callee1, 2 ]
+// CHECK-NEXT:	[ 1, callee2, 1 ]
+// CHECK-NEXT:	[ 2, callee1, 3 ]
+// CHECK-NEXT:	[ 2, callee2, 2 ]
+// CHECK-NEXT:	[ 3, callee1, 4 ]
+// CHECK-NEXT:	[ 3, callee2, 2 ]
+// CHECK-NEXT:	[ 4, callee1, 5 ]
+// CHECK-NEXT:	[ 4, callee2, 3 ]
+// CHECK-NEXT:	[ 5, callee1, 6 ]
+// CHECK-NEXT:	[ 5, callee2, 3 ]
+// CHECK-NEXT:	[ 6, callee1, 7 ]
+// CHECK-NEXT:	[ 6, callee2, 4 ]
+// CHECK-NEXT:	[ 7, callee1, 8 ]
+// CHECK-NEXT:	[ 7, callee2, 4 ]
+// CHECK-NEXT:	[ 8, callee1, 9 ]
+// CHECK-NEXT:	[ 8, callee2, 5 ]
+// CHECK-NEXT:	[ 9, callee1, 10 ]
+// CHECK-NEXT:	[ 9, callee2, 5 ]
+// CHECK:       caller_with_vp1:
+// CHECK-NEXT:    Hash: 0x0000000000000000
+// CHECK-NEXT:    Counters:
+// CHECK-NEXT:    Function count
+// CHECK-NEXT:    Indirect Call Site Count: 10
+// CHECK-NEXT:    Indirect Target Results: 
+// CHECK-NEXT:	[ 0, callee1, 1 ]
+// CHECK-NEXT:	[ 0, callee2, 1 ]
+// CHECK-NEXT:	[ 1, callee1, 2 ]
+// CHECK-NEXT:	[ 1, callee2, 1 ]
+// CHECK-NEXT:	[ 2, callee1, 3 ]
+// CHECK-NEXT:	[ 2, callee2, 2 ]
+// CHECK-NEXT:	[ 3, callee1, 4 ]
+// CHECK-NEXT:	[ 3, callee2, 2 ]
+// CHECK-NEXT:	[ 4, callee1, 5 ]
+// CHECK-NEXT:	[ 4, callee2, 3 ]
+// CHECK-NEXT:	[ 5, callee1, 6 ]
+// CHECK-NEXT:	[ 5, callee2, 3 ]
+// CHECK-NEXT:	[ 6, callee1, 7 ]
+// CHECK-NEXT:	[ 6, callee2, 4 ]
+// CHECK-NEXT:	[ 7, callee1, 8 ]
+// CHECK-NEXT:	[ 7, callee2, 4 ]
+// CHECK-NEXT:	[ 8, callee1, 9 ]
+// CHECK-NEXT:	[ 8, callee2, 5 ]
+// CHECK-NEXT:	[ 9, callee1, 10 ]
+// CHECK-NEXT:	[ 9, callee2, 5 ]
+// CHECK:       caller_with_value_site_never_called1:
+// CHECK-NEXT:    Hash: 0x0000000000000000
+// CHECK-NEXT:    Counters:
+// CHECK-NEXT:    Function count:
+// CHECK-NEXT:    Indirect Call Site Count: 10
+// CHECK-NEXT:    Indirect Target Results: 
+// CHECK:       caller_without_value_site2:
+// CHECK-NEXT:    Hash: 0x0000000000000000
+// CHECK-NEXT:    Counters:
+// CHECK-NEXT:    Function count:
+// CHECK-NEXT:    Indirect Call Site Count: 0
+// CHECK-NEXT:    Indirect Target Results: 
+// CHECK:       caller_without_value_site1:
+// CHECK-NEXT:    Hash: 0x0000000000000000
+// CHECK-NEXT:    Counters:
+// CHECK-NEXT:    Function count:
+// CHECK-NEXT:    Indirect Call Site Count: 0
+// CHECK-NEXT:    Indirect Target Results: 
diff --git a/compiler-rt/test/profile/instrprof-value-prof.c b/compiler-rt/test/profile/instrprof-value-prof.c
new file mode 100644
index 0000000..c662754
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-value-prof.c
@@ -0,0 +1,183 @@
+// RUN: %clang_profgen -O2 -o %t %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t 1
+// RUN: env LLVM_PROFILE_FILE=%t-2.profraw %run %t
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: llvm-profdata merge -o %t-2.profdata %t-2.profraw
+// RUN: llvm-profdata merge -o %t-merged.profdata %t.profraw %t-2.profdata
+// RUN: llvm-profdata show --all-functions -ic-targets  %t-2.profdata | FileCheck  %s -check-prefix=NO-VALUE
+// RUN: llvm-profdata show --all-functions -ic-targets  %t.profdata | FileCheck  %s
+// value profile merging current do sorting based on target values -- this will destroy the order of the target
+// in the list leading to comparison problem. For now just check a small subset of output.
+// RUN: llvm-profdata show --all-functions -ic-targets  %t-merged.profdata | FileCheck  %s -check-prefix=MERGE
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+typedef struct __llvm_profile_data __llvm_profile_data;
+const __llvm_profile_data *__llvm_profile_begin_data(void);
+const __llvm_profile_data *__llvm_profile_end_data(void);
+void __llvm_profile_set_num_value_sites(__llvm_profile_data *Data,
+                                        uint32_t ValueKind,
+                                        uint16_t NumValueSites);
+__llvm_profile_data *
+__llvm_profile_iterate_data(const __llvm_profile_data *Data);
+void *__llvm_get_function_addr(const __llvm_profile_data *Data);
+void __llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
+                                      uint32_t CounterIndex);
+
+#define DEF_FUNC(x)                                                            \
+  void x() {}
+#define DEF_2_FUNCS(x) DEF_FUNC(x##_1) DEF_FUNC(x##_2)
+#define DEF_4_FUNCS(x) DEF_2_FUNCS(x##_1) DEF_2_FUNCS(x##_2)
+#define DEF_8_FUNCS(x) DEF_4_FUNCS(x##_1) DEF_4_FUNCS(x##_2)
+#define DEF_16_FUNCS(x) DEF_8_FUNCS(x##_1) DEF_8_FUNCS(x##_2)
+#define DEF_32_FUNCS(x) DEF_16_FUNCS(x##_1) DEF_16_FUNCS(x##_2)
+#define DEF_64_FUNCS(x) DEF_32_FUNCS(x##_1) DEF_32_FUNCS(x##_2)
+#define DEF_128_FUNCS(x) DEF_64_FUNCS(x##_1) DEF_64_FUNCS(x##_2)
+
+#define FUNC_ADDR(x) &x,
+#define FUNC_2_ADDRS(x) FUNC_ADDR(x##_1) FUNC_ADDR(x##_2)
+#define FUNC_4_ADDRS(x) FUNC_2_ADDRS(x##_1) FUNC_2_ADDRS(x##_2)
+#define FUNC_8_ADDRS(x) FUNC_4_ADDRS(x##_1) FUNC_4_ADDRS(x##_2)
+#define FUNC_16_ADDRS(x) FUNC_8_ADDRS(x##_1) FUNC_8_ADDRS(x##_2)
+#define FUNC_32_ADDRS(x) FUNC_16_ADDRS(x##_1) FUNC_16_ADDRS(x##_2)
+#define FUNC_64_ADDRS(x) FUNC_32_ADDRS(x##_1) FUNC_32_ADDRS(x##_2)
+#define FUNC_128_ADDRS(x) FUNC_64_ADDRS(x##_1) FUNC_64_ADDRS(x##_2)
+
+DEF_8_FUNCS(callee)
+DEF_128_FUNCS(caller)
+
+void *CallerAddrs[] = {FUNC_128_ADDRS(caller)};
+
+void *CalleeAddrs[] = {FUNC_8_ADDRS(callee)};
+
+int cmpaddr(const void *p1, const void *p2) {
+  void *addr1 = *(void **)p1;
+  void *addr2 = *(void **)p2;
+  return (intptr_t)addr2 - (intptr_t)addr1;
+}
+
+int main(int argc, const char *argv[]) {
+  unsigned S, NS = 0, V, doInstrument = 1;
+  const __llvm_profile_data *Data, *DataEnd;
+
+  if (argc < 2)
+    doInstrument = 0;
+
+  qsort(CallerAddrs, sizeof(CallerAddrs) / sizeof(void *), sizeof(void *),
+        cmpaddr);
+
+  /* We will synthesis value profile data for 128 callers functions.
+   * The number of * value sites. The number values for each value site
+   * ranges from 0 to 8.  */
+
+  Data = __llvm_profile_begin_data();
+  DataEnd = __llvm_profile_end_data();
+
+  for (; Data < DataEnd; Data = __llvm_profile_iterate_data(Data)) {
+    void *func = __llvm_get_function_addr(Data);
+    if (bsearch(&func, CallerAddrs, sizeof(CallerAddrs) / sizeof(void *),
+                sizeof(void *), cmpaddr)) {
+      __llvm_profile_set_num_value_sites((__llvm_profile_data *)Data,
+                                         0 /*IPVK_IndirectCallTarget */, NS);
+      if (!doInstrument) {
+        NS++;
+        continue;
+      }
+      for (S = 0; S < NS; S++) {
+        for (V = 0; V < S % 8; V++) {
+          unsigned C;
+          for (C = 0; C < V + 1; C++)
+            __llvm_profile_instrument_target((uint64_t)CalleeAddrs[V],
+                                             (void *)Data, S);
+        }
+      }
+      NS++;
+    }
+  }
+}
+
+// NO-VALUE: Indirect Call Site Count: 127
+// NO-VALUE-NEXT: Indirect Target Results:
+// MERGE: Indirect Call Site Count: 127
+// MERGE-NEXT: Indirect Target Results:
+// MERGE-NEXT:  [ 1, callee_1_1_1, 1 ]
+// CHECK: Indirect Call Site Count: 127
+// CHECK-NEXT: Indirect Target Results:
+// CHECK-NEXT:  [ 1, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 2, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 2, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 3, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 3, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 3, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 4, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 4, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 4, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 4, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 5, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 5, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 5, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 5, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 5, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 6, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 6, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 6, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 6, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 6, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 6, callee_2_1_2, 6 ]
+// CHECK-NEXT:  [ 7, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 7, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 7, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 7, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 7, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 7, callee_2_1_2, 6 ]
+// CHECK-NEXT:  [ 7, callee_2_2_1, 7 ]
+// CHECK-NEXT:  [ 9, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 10, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 10, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 11, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 11, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 11, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 12, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 12, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 12, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 12, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 13, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 13, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 13, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 13, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 13, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 14, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 14, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 14, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 14, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 14, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 14, callee_2_1_2, 6 ]
+// CHECK-NEXT:  [ 15, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 15, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 15, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 15, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 15, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 15, callee_2_1_2, 6 ]
+// CHECK-NEXT:  [ 15, callee_2_2_1, 7 ]
+// CHECK-NEXT:  [ 17, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 18, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 18, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 19, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 19, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 19, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 20, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 20, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 20, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 20, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 21, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 21, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 21, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 21, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 21, callee_2_1_1, 5 ]
+// CHECK-NEXT:  [ 22, callee_1_1_1, 1 ]
+// CHECK-NEXT:  [ 22, callee_1_1_2, 2 ]
+// CHECK-NEXT:  [ 22, callee_1_2_1, 3 ]
+// CHECK-NEXT:  [ 22, callee_1_2_2, 4 ]
+// CHECK-NEXT:  [ 22, callee_2_1_1, 5 ]
+
diff --git a/compiler-rt/test/profile/instrprof-without-libc.c b/compiler-rt/test/profile/instrprof-without-libc.c
new file mode 100644
index 0000000..eb0a76d
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-without-libc.c
@@ -0,0 +1,66 @@
+// RUN: %clang_profgen -DCHECK_SYMBOLS -O3 -o %t.symbols %s
+// RUN: llvm-nm %t.symbols | FileCheck %s --check-prefix=CHECK-SYMBOLS
+// RUN: %clang_profgen -O3 -o %t %s
+// RUN: %run %t %t.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifndef CHECK_SYMBOLS
+#include <stdio.h>
+#endif
+
+int __llvm_profile_runtime = 0;
+uint64_t __llvm_profile_get_size_for_buffer(void);
+int __llvm_profile_write_buffer(char *);
+int write_buffer(uint64_t, const char *);
+int main(int argc, const char *argv[]) {
+  // CHECK-LABEL: define {{.*}} @main(
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+
+  const uint64_t MaxSize = 10000;
+  static char Buffer[MaxSize];
+
+  uint64_t Size = __llvm_profile_get_size_for_buffer();
+  if (Size > MaxSize)
+    return 1;
+  int Write = __llvm_profile_write_buffer(Buffer);
+  if (__llvm_profile_write_buffer(Buffer))
+    return Write;
+
+#ifdef CHECK_SYMBOLS
+  // Don't write it out.  Since we're checking the symbols, we don't have libc
+  // available.
+  return 0;
+#else
+  // Actually write it out so we can FileCheck the output.
+  FILE *File = fopen(argv[1], "w");
+  if (!File)
+    return 1;
+  if (fwrite(Buffer, 1, Size, File) != Size)
+    return 1;
+  return fclose(File);
+#endif
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
+
+// CHECK-SYMBOLS-NOT: ___cxx_global_var_init
+// CHECK-SYMBOLS-NOT: ___llvm_profile_register_write_file_atexit
+// CHECK-SYMBOLS-NOT: ___llvm_profile_set_filename
+// CHECK-SYMBOLS-NOT: ___llvm_profile_write_file
+// CHECK-SYMBOLS-NOT: _fdopen
+// CHECK-SYMBOLS-NOT: _fopen
+// CHECK-SYMBOLS-NOT: _fwrite
+// CHECK-SYMBOLS-NOT: _getenv
+// CHECK-SYMBOLS-NOT: getenv
+// CHECK-SYMBOLS-NOT: _malloc
+// CHECK-SYMBOLS-NOT: malloc
+// CHECK-SYMBOLS-NOT: _calloc
+// CHECK-SYMBOLS-NOT: calloc
+// CHECK-SYMBOLS-NOT: _free
+// CHECK-SYMBOLS-NOT: free
+// CHECK-SYMBOLS-NOT: _open
diff --git a/compiler-rt/test/profile/instrprof-write-file-atexit-explicitly.c b/compiler-rt/test/profile/instrprof-write-file-atexit-explicitly.c
new file mode 100644
index 0000000..18c365a
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-write-file-atexit-explicitly.c
@@ -0,0 +1,17 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: %run %t %t.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+int __llvm_profile_runtime = 0;
+int __llvm_profile_register_write_file_atexit(void);
+void __llvm_profile_set_filename(const char *);
+int main(int argc, const char *argv[]) {
+  __llvm_profile_register_write_file_atexit();
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+  __llvm_profile_set_filename(argv[1]);
+  return 0;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-write-file-only.c b/compiler-rt/test/profile/instrprof-write-file-only.c
new file mode 100644
index 0000000..4abbdea
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-write-file-only.c
@@ -0,0 +1,35 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: %clang_profuse=%t.profdata -o - -S -emit-llvm %s | FileCheck %s
+
+int __llvm_profile_runtime = 0;
+void __llvm_profile_initialize_file(void);
+int __llvm_profile_write_file(void);
+void __llvm_profile_set_filename(const char *);
+int foo(int);
+int main(int argc, const char *argv[]) {
+  // CHECK-LABEL: define {{.*}} @main(
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc > 1)
+    return 1;
+
+  // Since the runtime has been suppressed, initialize the file name, as the
+  // writing will fail below as the file name has not been specified.
+  __llvm_profile_initialize_file();
+
+  // Write out the profile.
+  __llvm_profile_write_file();
+
+  // Change the profile.
+  return foo(0);
+}
+int foo(int X) {
+  // There should be no profiling information for @foo, since it was called
+  // after the profile was written (and the atexit was suppressed by defining
+  // profile_runtime).
+  // CHECK-LABEL: define {{.*}} @foo(
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{[^,]+$}}
+  return X <= 0 ? -X : X;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
diff --git a/compiler-rt/test/profile/instrprof-write-file.c b/compiler-rt/test/profile/instrprof-write-file.c
new file mode 100644
index 0000000..af008ed
--- /dev/null
+++ b/compiler-rt/test/profile/instrprof-write-file.c
@@ -0,0 +1,34 @@
+// RUN: %clang_profgen -o %t -O3 %s
+// RUN: env LLVM_PROFILE_FILE=%t1.profraw %run %t %t2.profraw
+// RUN: llvm-profdata merge -o %t1.profdata %t1.profraw
+// RUN: %clang_profuse=%t1.profdata -o - -S -emit-llvm %s | FileCheck %s --check-prefix=CHECK1 --check-prefix=CHECK
+// RUN: llvm-profdata merge -o %t2.profdata %t2.profraw
+// RUN: %clang_profuse=%t2.profdata -o - -S -emit-llvm %s | FileCheck %s --check-prefix=CHECK2 --check-prefix=CHECK
+
+int __llvm_profile_write_file(void);
+void __llvm_profile_set_filename(const char *);
+int foo(int);
+int main(int argc, const char *argv[]) {
+  // CHECK-LABEL: define {{.*}} @main(
+  // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD1:[0-9]+]]
+  if (argc < 2)
+    return 1;
+
+  // Write out the profile.
+  __llvm_profile_write_file();
+
+  // Change the profile.
+  int Ret = foo(0);
+
+  // It'll write out again at exit; change the filename so we get two files.
+  __llvm_profile_set_filename(argv[1]);
+  return Ret;
+}
+int foo(int X) {
+  // CHECK-LABEL: define {{.*}} @foo(
+  // CHECK1: br i1 %{{.*}}, label %{{.*}}, label %{{[^,]+$}}
+  // CHECK2: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !prof ![[PD2:[0-9]+]]
+  return X <= 0 ? -X : X;
+}
+// CHECK: ![[PD1]] = !{!"branch_weights", i32 1, i32 2}
+// CHECK2: ![[PD2]] = !{!"branch_weights", i32 2, i32 1}
diff --git a/compiler-rt/test/profile/lit.cfg b/compiler-rt/test/profile/lit.cfg
new file mode 100644
index 0000000..b1b44a1
--- /dev/null
+++ b/compiler-rt/test/profile/lit.cfg
@@ -0,0 +1,55 @@
+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = 'Profile'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Setup executable root.
+if hasattr(config, 'profile_lit_binary_dir') and \
+        config.profile_lit_binary_dir is not None:
+    config.test_exec_root = config.profile_lit_binary_dir
+
+# If the above check didn't work, we're probably in the source tree.  Use some
+# magic to re-execute from the build tree.
+if config.test_exec_root is None:
+    # The magic relies on knowing compilerrt_site_basedir.
+    compilerrt_basedir = lit_config.params.get('compilerrt_site_basedir', None)
+    if compilerrt_basedir:
+        site_cfg = os.path.join(compilerrt_basedir, 'profile', 'lit.site.cfg')
+        if os.path.exists(site_cfg):
+            lit_config.load_config(config, site_cfg)
+            raise SystemExit
+
+if config.host_os in ['Linux']:
+  extra_linkflags = ["-ldl"]
+else:
+  extra_linkflags = []
+
+# Test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp', '.m', '.mm', '.ll', '.test']
+
+# What to exclude.
+config.excludes = ['Inputs']
+
+# Clang flags.
+clang_cflags = [config.target_cflags] + extra_linkflags
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+# Add clang substitutions.
+config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )
+config.substitutions.append( ("%clang_profgen ", build_invocation(clang_cflags) + " -fprofile-instr-generate ") )
+config.substitutions.append( ("%clang_profuse=", build_invocation(clang_cflags) + " -fprofile-instr-use=") )
+config.substitutions.append( ("%clang_profgen_gcc=", build_invocation(clang_cflags) + " -fprofile-generate=") )
+config.substitutions.append( ("%clang_profuse_gcc=", build_invocation(clang_cflags) + " -fprofile-use=") )
+
+if config.host_os not in ['Darwin', 'FreeBSD', 'Linux']:
+  config.unsupported = True
+
+if config.target_arch in ['armv7l']:
+  config.unsupported = True
diff --git a/compiler-rt/test/profile/lit.site.cfg.in b/compiler-rt/test/profile/lit.site.cfg.in
new file mode 100644
index 0000000..758568d
--- /dev/null
+++ b/compiler-rt/test/profile/lit.site.cfg.in
@@ -0,0 +1,11 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Tool-specific config options.
+config.profile_lit_binary_dir = "@PROFILE_LIT_BINARY_DIR@"
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@PROFILE_LIT_SOURCE_DIR@/lit.cfg")
diff --git a/compiler-rt/test/safestack/CMakeLists.txt b/compiler-rt/test/safestack/CMakeLists.txt
new file mode 100644
index 0000000..6f5c2f9
--- /dev/null
+++ b/compiler-rt/test/safestack/CMakeLists.txt
@@ -0,0 +1,29 @@
+set(SAFESTACK_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(SAFESTACK_LIT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+set(SAFESTACK_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND SAFESTACK_TEST_DEPS safestack)
+
+  # Some tests require LTO, so add a dependency on the relevant LTO plugin.
+  if(LLVM_ENABLE_PIC AND LLVM_BINUTILS_INCDIR)
+    list(APPEND SAFESTACK_TEST_DEPS
+      LLVMgold
+    )
+  endif()
+  if(APPLE)
+    list(APPEND SAFESTACK_TEST_DEPS
+      LTO
+    )
+  endif()
+endif()
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+  )
+
+add_lit_testsuite(check-safestack "Running the SafeStack tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS ${SAFESTACK_TEST_DEPS})
+set_target_properties(check-safestack PROPERTIES FOLDER "SafeStack tests")
diff --git a/compiler-rt/test/safestack/buffer-copy-vla.c b/compiler-rt/test/safestack/buffer-copy-vla.c
new file mode 100644
index 0000000..356a1ac
--- /dev/null
+++ b/compiler-rt/test/safestack/buffer-copy-vla.c
@@ -0,0 +1,26 @@
+// RUN: %clang_safestack %s -o %t
+// RUN: %run %t
+
+#include "utils.h"
+
+// Test that loads/stores work correctly for VLAs on the unsafe stack.
+
+int main(int argc, char **argv)
+{
+  int i = 128;
+  break_optimization(&i);
+  char buffer[i];
+
+  // check that we can write to a buffer
+  for (i = 0; argv[0][i] && i < sizeof (buffer) - 1; ++i)
+    buffer[i] = argv[0][i];
+  buffer[i] = '\0';
+
+  break_optimization(buffer);
+
+  // check that we can read from a buffer
+  for (i = 0; argv[0][i] && i < sizeof (buffer) - 1; ++i)
+    if (buffer[i] != argv[0][i])
+      return 1;
+  return 0;
+}
diff --git a/compiler-rt/test/safestack/buffer-copy.c b/compiler-rt/test/safestack/buffer-copy.c
new file mode 100644
index 0000000..96b2302
--- /dev/null
+++ b/compiler-rt/test/safestack/buffer-copy.c
@@ -0,0 +1,25 @@
+// RUN: %clang_safestack %s -o %t
+// RUN: %run %t
+
+#include "utils.h"
+
+// Test that loads/stores work correctly for variables on the unsafe stack.
+
+int main(int argc, char **argv)
+{
+  int i;
+  char buffer[128];
+
+  // check that we can write to a buffer
+  for (i = 0; argv[0][i] && i < sizeof (buffer) - 1; ++i)
+    buffer[i] = argv[0][i];
+  buffer[i] = '\0';
+
+  break_optimization(buffer);
+
+  // check that we can read from a buffer
+  for (i = 0; argv[0][i] && i < sizeof (buffer) - 1; ++i)
+    if (buffer[i] != argv[0][i])
+      return 1;
+  return 0;
+}
diff --git a/compiler-rt/test/safestack/init.c b/compiler-rt/test/safestack/init.c
new file mode 100644
index 0000000..cff75f5
--- /dev/null
+++ b/compiler-rt/test/safestack/init.c
@@ -0,0 +1,9 @@
+// RUN: %clang_safestack %s -o %t
+// RUN: %run %t
+
+// Basic smoke test for the runtime library.
+
+int main(int argc, char **argv)
+{
+  return 0;
+}
diff --git a/compiler-rt/test/safestack/lit.cfg b/compiler-rt/test/safestack/lit.cfg
new file mode 100644
index 0000000..535c097
--- /dev/null
+++ b/compiler-rt/test/safestack/lit.cfg
@@ -0,0 +1,29 @@
+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = 'SafeStack'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp', '.m', '.mm', '.ll', '.test']
+
+# Add clang substitutions.
+config.substitutions.append( ("%clang_nosafestack ", config.clang + " -O0 -fno-sanitize=safe-stack ") )
+config.substitutions.append( ("%clang_safestack ", config.clang + " -O0 -fsanitize=safe-stack ") )
+
+if config.lto_supported:
+  config.available_features.add('lto')
+  config.substitutions.append((r"%clang_lto_safestack ", ' '.join(config.lto_launch + [config.clang] + config.lto_flags + ['-flto -fsanitize=safe-stack '])))
+
+# SafeStack tests are currently supported on Linux, FreeBSD and Darwin only.
+if config.host_os not in ['Linux', 'FreeBSD', 'Darwin']:
+   config.unsupported = True
+
+# Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
+# because the test fail due some runtime issue.
+if config.target_arch != 'aarch64':
+  config.available_features.add('stable-runtime')
diff --git a/compiler-rt/test/safestack/lit.site.cfg.in b/compiler-rt/test/safestack/lit.site.cfg.in
new file mode 100644
index 0000000..cb1e729
--- /dev/null
+++ b/compiler-rt/test/safestack/lit.site.cfg.in
@@ -0,0 +1,8 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@SAFESTACK_LIT_SOURCE_DIR@/lit.cfg")
diff --git a/compiler-rt/test/safestack/lto.c b/compiler-rt/test/safestack/lto.c
new file mode 100644
index 0000000..6ee23a1
--- /dev/null
+++ b/compiler-rt/test/safestack/lto.c
@@ -0,0 +1,12 @@
+// REQUIRES: lto
+
+// RUN: %clang_lto_safestack %s -o %t
+// RUN: %run %t
+
+// Test that safe stack works with LTO.
+
+int main() {
+  char c[] = "hello world";
+  puts(c);
+  return 0;
+}
diff --git a/compiler-rt/test/safestack/overflow.c b/compiler-rt/test/safestack/overflow.c
new file mode 100644
index 0000000..2743694
--- /dev/null
+++ b/compiler-rt/test/safestack/overflow.c
@@ -0,0 +1,25 @@
+// RUN: %clang_safestack %s -o %t
+// RUN: %run %t
+
+// RUN: %clang_nosafestack -fno-stack-protector %s -o %t
+// RUN: not %run %t
+
+// Test that buffer overflows on the unsafe stack do not affect variables on the
+// safe stack.
+
+// REQUIRES: stable-runtime
+
+__attribute__((noinline))
+void fct(volatile int *buffer)
+{
+  memset(buffer - 1, 0, 7 * sizeof(int));
+}
+
+int main(int argc, char **argv)
+{
+  int value1 = 42;
+  int buffer[5];
+  int value2 = 42;
+  fct(buffer);
+  return value1 != 42 || value2 != 42;
+}
diff --git a/compiler-rt/test/safestack/pthread-cleanup.c b/compiler-rt/test/safestack/pthread-cleanup.c
new file mode 100644
index 0000000..805366c
--- /dev/null
+++ b/compiler-rt/test/safestack/pthread-cleanup.c
@@ -0,0 +1,31 @@
+// RUN: %clang_safestack %s -pthread -o %t
+// RUN: not --crash %run %t
+
+// Test that unsafe stacks are deallocated correctly on thread exit.
+
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+enum { kBufferSize = (1 << 15) };
+
+void *t1_start(void *ptr)
+{
+  char buffer[kBufferSize];
+  return buffer;
+}
+
+int main(int argc, char **argv)
+{
+  pthread_t t1;
+  char *buffer = NULL;
+
+  if (pthread_create(&t1, NULL, t1_start, NULL))
+    abort();
+  if (pthread_join(t1, &buffer))
+    abort();
+
+  // should segfault here
+  memset(buffer, 0, kBufferSize);
+  return 0;
+}
diff --git a/compiler-rt/test/safestack/pthread.c b/compiler-rt/test/safestack/pthread.c
new file mode 100644
index 0000000..416586e
--- /dev/null
+++ b/compiler-rt/test/safestack/pthread.c
@@ -0,0 +1,42 @@
+// RUN: %clang_safestack %s -pthread -o %t
+// RUN: %run %t
+
+// XFAIL: darwin
+
+// Test that pthreads receive their own unsafe stack.
+
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include "utils.h"
+
+static int ptr_test = 42;
+
+void *t1_start(void *ptr)
+{
+  if (ptr != &ptr_test)
+    abort();
+
+  // safe stack
+  int val = ptr_test * 5;
+
+  // unsafe stack
+  char buffer[8096]; // two pages
+  memset(buffer, val, sizeof (buffer));
+  break_optimization(buffer);
+
+  return ptr;
+}
+
+int main(int argc, char **argv)
+{
+  pthread_t t1;
+  void *ptr = NULL;
+  if (pthread_create(&t1, NULL, t1_start, &ptr_test))
+    abort();
+  if (pthread_join(t1, &ptr))
+    abort();
+  if (ptr != &ptr_test)
+    abort();
+  return 0;
+}
diff --git a/compiler-rt/test/safestack/utils.h b/compiler-rt/test/safestack/utils.h
new file mode 100644
index 0000000..b04e3bd
--- /dev/null
+++ b/compiler-rt/test/safestack/utils.h
@@ -0,0 +1,8 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+static inline void break_optimization(void *arg) {
+  __asm__ __volatile__("" : : "r" (arg) : "memory");
+}
+
+#endif
diff --git a/compiler-rt/test/sanitizer_common/CMakeLists.txt b/compiler-rt/test/sanitizer_common/CMakeLists.txt
new file mode 100644
index 0000000..54b9135
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/CMakeLists.txt
@@ -0,0 +1,64 @@
+set(SANITIZER_COMMON_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(SANITIZER_COMMON_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+set(SANITIZER_COMMON_TESTSUITES)
+
+set(SUPPORTED_TOOLS)
+if(CMAKE_SYSTEM_NAME MATCHES "Darwin|Linux|FreeBSD" AND NOT ANDROID)
+  list(APPEND SUPPORTED_TOOLS asan)
+endif()
+if(CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT ANDROID)
+  list(APPEND SUPPORTED_TOOLS tsan)
+  list(APPEND SUPPORTED_TOOLS msan)
+  list(APPEND SUPPORTED_TOOLS lsan)
+endif()
+
+# Create a separate config for each tool we support.
+foreach(tool ${SUPPORTED_TOOLS})
+  string(TOUPPER ${tool} tool_toupper)
+  if(${tool_toupper}_SUPPORTED_ARCH AND NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND SANITIZER_COMMON_TEST_DEPS ${tool})
+  endif()
+  set(TEST_ARCH ${${tool_toupper}_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(${tool_toupper}_SUPPORTED_ARCH TEST_ARCH)
+  endif()
+
+  foreach(arch ${TEST_ARCH})
+    set(SANITIZER_COMMON_LIT_TEST_MODE ${tool})
+    set(SANITIZER_COMMON_TEST_TARGET_ARCH ${arch})
+    if(${arch} MATCHES "arm|aarch64")
+      # This is only true if we're cross-compiling.
+      set(SANITIZER_COMMON_TEST_TARGET_CFLAGS
+          ${COMPILER_RT_TEST_COMPILER_CFLAGS})
+    else()
+      get_target_flags_for_arch(${arch} SANITIZER_COMMON_TEST_TARGET_CFLAGS)
+      string(REPLACE ";" " " SANITIZER_COMMON_TEST_TARGET_CFLAGS "${SANITIZER_COMMON_TEST_TARGET_CFLAGS}")
+    endif()
+    set(CONFIG_NAME ${tool}-${arch}-${OS_NAME})
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg)
+    list(APPEND SANITIZER_COMMON_TESTSUITES
+         ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  endforeach()
+endforeach()
+
+# Unit tests.
+if(COMPILER_RT_INCLUDE_TESTS)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
+  list(APPEND SANITIZER_COMMON_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
+  list(APPEND SANITIZER_COMMON_TEST_DEPS SanitizerUnitTests)
+endif()
+
+# FIXME: Re-enable on 64-bit Windows.
+if(SANITIZER_COMMON_TESTSUITES AND
+    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
+  add_lit_testsuite(check-sanitizer "Running sanitizer_common tests"
+    ${SANITIZER_COMMON_TESTSUITES}
+    DEPENDS ${SANITIZER_COMMON_TEST_DEPS})
+  set_target_properties(check-sanitizer PROPERTIES FOLDER
+                        "sanitizer_common tests")
+endif()
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Darwin/abort_on_error.cc b/compiler-rt/test/sanitizer_common/TestCases/Darwin/abort_on_error.cc
new file mode 100644
index 0000000..dbab525
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Darwin/abort_on_error.cc
@@ -0,0 +1,19 @@
+// Check that sanitizers on OS X crash the process by default (i.e.
+// abort_on_error=1). See also Linux/abort_on_error.cc.
+
+// RUN: %clangxx %s -o %t
+
+// Intentionally don't inherit the default options.
+// RUN: %tool_options='' not --crash %run %t 2>&1
+
+// When we use lit's default options, we shouldn't crash.
+// RUN: not %run %t 2>&1
+
+int global;
+
+int main() {
+  volatile int *a = new int[100];
+  delete[] a;
+  global = a[0];  // use-after-free: triggers ASan report.
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Darwin/lit.local.cfg b/compiler-rt/test/sanitizer_common/TestCases/Darwin/lit.local.cfg
new file mode 100644
index 0000000..a85dfcd
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Darwin/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Darwin']:
+  config.unsupported = True
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/abort_on_error.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/abort_on_error.cc
new file mode 100644
index 0000000..7e444c2
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/abort_on_error.cc
@@ -0,0 +1,20 @@
+// Check that sanitizers call _exit() on Linux by default (i.e.
+// abort_on_error=0). See also Darwin/abort_on_error.cc.
+
+// RUN: %clangxx %s -o %t
+
+// Intentionally don't inherit the default options.
+// RUN: %tool_options='' not %run %t 2>&1
+
+// When we use lit's default options, we shouldn't crash either. On Linux
+// lit doesn't set options anyway.
+// RUN: not %run %t 2>&1
+
+namespace __sanitizer {
+void Die();
+}
+
+int main() {
+  __sanitizer::Die();
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/aligned_alloc.c b/compiler-rt/test/sanitizer_common/TestCases/Linux/aligned_alloc.c
new file mode 100644
index 0000000..12af18d
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/aligned_alloc.c
@@ -0,0 +1,8 @@
+// RUN: %clang -std=c11 -O0 %s -o %t && %run %t
+#include <stdlib.h>
+extern void *aligned_alloc (size_t alignment, size_t size);
+int main() {
+  volatile void *p = aligned_alloc(128, 1024);
+  free((void*)p);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/assert.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/assert.cc
new file mode 100644
index 0000000..5d58ea4
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/assert.cc
@@ -0,0 +1,24 @@
+// Test the handle_abort option.
+// RUN: %clang %s -o %t
+// RUN:                              not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
+// RUN: %env_tool_opts=handle_abort=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
+// RUN: %env_tool_opts=handle_abort=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
+// FIXME: implement in other sanitizers, not just asan.
+// XFAIL: msan
+// XFAIL: lsan
+// XFAIL: tsan
+#include <assert.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+void death() {
+  fprintf(stderr, "DEATH CALLBACK\n");
+}
+
+int main(int argc, char **argv) {
+  __sanitizer_set_death_callback(death);
+  assert(argc == 100);
+}
+// CHECK1: ERROR: {{.*}}Sanitizer:
+// CHECK1: DEATH CALLBACK
+// CHECK0-NOT: Sanitizer
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/clock_gettime.c b/compiler-rt/test/sanitizer_common/TestCases/Linux/clock_gettime.c
new file mode 100644
index 0000000..ec1386e
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/clock_gettime.c
@@ -0,0 +1,11 @@
+// RUN: %clang %s -Wl,-as-needed -o %t && %run %t
+// Regression test for PR15823
+// (http://llvm.org/bugs/show_bug.cgi?id=15823).
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/fpe.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/fpe.cc
new file mode 100644
index 0000000..b4be500
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/fpe.cc
@@ -0,0 +1,30 @@
+// Test the handle_sigfpe option.
+// RUN: %clang %s -o %t
+// RUN:                               not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
+// RUN: %env_tool_opts=handle_sigfpe=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
+// RUN: %env_tool_opts=handle_sigfpe=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
+// FIXME: implement in other sanitizers, not just asan.
+// XFAIL: msan
+// XFAIL: lsan
+// XFAIL: tsan
+//
+// FIXME: seems to fail on ARM
+// REQUIRES: x86_64-supported-target
+#include <assert.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+void death() {
+  fprintf(stderr, "DEATH CALLBACK\n");
+}
+
+int main(int argc, char **argv) {
+  __sanitizer_set_death_callback(death);
+  volatile int one = 1;
+  volatile int zero = 0;
+  volatile int sink;
+  sink = one / zero;
+}
+// CHECK1: ERROR: {{.*}}Sanitizer:
+// CHECK1: DEATH CALLBACK
+// CHECK0-NOT: Sanitizer
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/getpass.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/getpass.cc
new file mode 100644
index 0000000..902c9cb
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/getpass.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx -O0 -g %s -lutil -o %t && %run %t | FileCheck %s
+// REQUIRES: stable-runtime
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <pty.h>
+
+int
+main (int argc, char** argv)
+{
+    int master;
+    int pid = forkpty(&master, NULL, NULL, NULL);
+
+    if(pid == -1) {
+      fprintf(stderr, "forkpty failed\n");
+      return 1;
+    } else if (pid > 0) {
+      char buf[1024];
+      int res = read(master, buf, sizeof(buf));
+      write(1, buf, res);
+      write(master, "password\n", 9);
+      while ((res = read(master, buf, sizeof(buf))) > 0) write(1, buf, res);
+    } else {
+      char *s = getpass("prompt");
+      assert(strcmp(s, "password") == 0);
+      write(1, "done\n", 5);
+    }
+    return 0;
+}
+
+// CHECK: prompt
+// CHECK: done
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/getpwnam_r_invalid_user.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/getpwnam_r_invalid_user.cc
new file mode 100644
index 0000000..c0d6cfe
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/getpwnam_r_invalid_user.cc
@@ -0,0 +1,20 @@
+// Regression test for a crash in getpwnam_r and similar interceptors.
+// RUN: %clangxx -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <errno.h>
+#include <pwd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main(void) {
+  struct passwd pwd;
+  struct passwd *pwdres;
+  char buf[10000];
+  int res = getpwnam_r("no-such-user", &pwd, buf, sizeof(buf), &pwdres);
+  assert(res == 0 || res == ENOENT);
+  assert(pwdres == 0);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/hard_rss_limit_mb_test.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/hard_rss_limit_mb_test.cc
new file mode 100644
index 0000000..d4a60a0
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/hard_rss_limit_mb_test.cc
@@ -0,0 +1,37 @@
+// Check hard_rss_limit_mb. Not all sanitizers implement it yet.
+// RUN: %clangxx -O2 %s -o %t
+//
+// Run with limit should fail:
+// RUN: %env_tool_opts=hard_rss_limit_mb=100                           not %run %t 2>&1 | FileCheck %s
+// This run uses getrusage:
+// RUN: %env_tool_opts=hard_rss_limit_mb=100:can_use_proc_maps_statm=0 not %run %t 2>&1 | FileCheck %s
+//
+// Run w/o limit or with a large enough limit should pass:
+// RUN: %env_tool_opts=hard_rss_limit_mb=1000 %run %t
+// RUN: %run %t
+//
+// FIXME: make it work for other sanitizers.
+// XFAIL: lsan
+// XFAIL: tsan
+// XFAIL: msan
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+const int kNumAllocs = 200 * 1000;
+const int kAllocSize = 1000;
+volatile char *sink[kNumAllocs];
+
+int main(int argc, char **argv) {
+  for (int i = 0; i < kNumAllocs; i++) {
+    if ((i % 1000) == 0) {
+      fprintf(stderr, "[%d]\n", i);
+    }
+    char *x = new char[kAllocSize];
+    memset(x, 0, kAllocSize);
+    sink[i] = x;
+  }
+  sleep(1);  // Make sure the background thread has time to kill the process.
+// CHECK: hard rss limit exhausted
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/ill.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/ill.cc
new file mode 100644
index 0000000..1edad48
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/ill.cc
@@ -0,0 +1,27 @@
+// Test the handle_sigill option.
+// RUN: %clang %s -o %t -O1
+// RUN:                                not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
+// RUN: %env_tool_opts=handle_sigill=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
+// RUN: %env_tool_opts=handle_sigill=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
+// FIXME: implement in other sanitizers, not just asan.
+// XFAIL: msan
+// XFAIL: lsan
+// XFAIL: tsan
+//
+// FIXME: seems to fail on ARM
+// REQUIRES: x86_64-supported-target
+#include <assert.h>
+#include <stdio.h>
+#include <sanitizer/asan_interface.h>
+
+void death() {
+  fprintf(stderr, "DEATH CALLBACK\n");
+}
+
+int main(int argc, char **argv) {
+  __sanitizer_set_death_callback(death);
+  __builtin_trap();
+}
+// CHECK1: ERROR: {{.*}}Sanitizer:
+// CHECK1: DEATH CALLBACK
+// CHECK0-NOT: Sanitizer
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/lit.local.cfg b/compiler-rt/test/sanitizer_common/TestCases/Linux/lit.local.cfg
new file mode 100644
index 0000000..57271b8
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/mlock_test.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/mlock_test.cc
new file mode 100644
index 0000000..69ea7cb
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/mlock_test.cc
@@ -0,0 +1,13 @@
+// RUN: %clang  %s -o %t && %run %t
+// XFAIL: lsan
+
+#include <assert.h>
+#include <sys/mman.h>
+
+int main() {
+  assert(0 == mlockall(MCL_CURRENT));
+  assert(0 == mlock((void *)0x12345, 0x5678));
+  assert(0 == munlockall());
+  assert(0 == munlock((void *)0x987, 0x654));
+}
+
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/open_memstream.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/open_memstream.cc
new file mode 100644
index 0000000..3bce030
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/open_memstream.cc
@@ -0,0 +1,70 @@
+// RUN: %clangxx -m64 -O0 -g -xc++ %s -o %t && %run %t
+// RUN: %clangxx -m64 -O3 -g -xc++ %s -o %t && %run %t
+// REQUIRES: x86_64-supported-target
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+#if __has_feature(memory_sanitizer)
+#include <sanitizer/msan_interface.h>
+static void check_mem_is_good(void *p, size_t s) {
+  __msan_check_mem_is_initialized(p, s);
+}
+#elif __has_feature(address_sanitizer)
+#include <sanitizer/asan_interface.h>
+static void check_mem_is_good(void *p, size_t s) {
+  assert(__asan_region_is_poisoned(p, s) == 0);
+}
+#else
+static void check_mem_is_good(void *p, size_t s) {}
+#endif
+
+static void run(bool flush) {
+  char *buf;
+  size_t buf_len;
+  fprintf(stderr, " &buf %p, &buf_len %p\n", &buf, &buf_len);
+  FILE *fp = open_memstream(&buf, &buf_len);
+  fprintf(fp, "hello");
+  if (flush) {
+    fflush(fp);
+    check_mem_is_good(&buf, sizeof(buf));
+    check_mem_is_good(&buf_len, sizeof(buf_len));
+    check_mem_is_good(buf, buf_len);
+  }
+
+  char *p = new char[1024];
+  memset(p, 'a', 1023);
+  p[1023] = 0;
+  for (int i = 0; i < 100; ++i)
+    fprintf(fp, "%s", p);
+  delete[] p;
+
+  if (flush) {
+    fflush(fp);
+    fprintf(stderr, " %p addr %p, len %zu\n", &buf, buf, buf_len);
+    check_mem_is_good(&buf, sizeof(buf));
+    check_mem_is_good(&buf_len, sizeof(buf_len));
+    check_mem_is_good(buf, buf_len);\
+  }
+
+  fclose(fp);
+  check_mem_is_good(&buf, sizeof(buf));
+  check_mem_is_good(&buf_len, sizeof(buf_len));
+  check_mem_is_good(buf, buf_len);
+
+  free(buf);
+}
+
+int main(void) {
+  for (int i = 0; i < 100; ++i)
+    run(false);
+  for (int i = 0; i < 100; ++i)
+    run(true);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/ptrace.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/ptrace.cc
new file mode 100644
index 0000000..67b6474
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/ptrace.cc
@@ -0,0 +1,105 @@
+// RUN: %clangxx -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <elf.h>
+#if __mips64 || __arm__
+ #include <asm/ptrace.h>
+ #include <sys/procfs.h>
+#endif
+#ifdef __aarch64__
+// GLIBC 2.20+ sys/user does not include asm/ptrace.h
+ #include <asm/ptrace.h>
+#endif
+
+int main(void) {
+  pid_t pid;
+  pid = fork();
+  if (pid == 0) { // child
+    ptrace(PTRACE_TRACEME, 0, NULL, NULL);
+    execl("/bin/true", "true", NULL);
+  } else {
+    wait(NULL);
+    int res;
+
+#if __x86_64__
+    user_regs_struct regs;
+    res = ptrace(PTRACE_GETREGS, pid, NULL, &regs);
+    assert(!res);
+    if (regs.rip)
+      printf("%zx\n", regs.rip);
+
+    user_fpregs_struct fpregs;
+    res = ptrace(PTRACE_GETFPREGS, pid, NULL, &fpregs);
+    assert(!res);
+    if (fpregs.mxcsr)
+      printf("%x\n", fpregs.mxcsr);
+#endif // __x86_64__
+
+#if (__powerpc64__ || __mips64 || __arm__)
+    struct pt_regs regs;
+    res = ptrace((enum __ptrace_request)PTRACE_GETREGS, pid, NULL, &regs);
+    assert(!res);
+#if (__powerpc64__)
+    if (regs.nip)
+      printf("%lx\n", regs.nip);
+#elif (__mips64)
+    if (regs.cp0_epc)
+    printf("%lx\n", regs.cp0_epc);
+#elif (__arm__)
+    if (regs.ARM_pc)
+    printf("%lx\n", regs.ARM_pc);
+#endif
+#if (__powerpc64 || __mips64)
+    elf_fpregset_t fpregs;
+    res = ptrace((enum __ptrace_request)PTRACE_GETFPREGS, pid, NULL, &fpregs);
+    assert(!res);
+    if ((elf_greg_t)fpregs[32]) // fpscr
+      printf("%lx\n", (elf_greg_t)fpregs[32]);
+#elif (__arm__)
+    char regbuf[ARM_VFPREGS_SIZE];
+    res = ptrace((enum __ptrace_request)PTRACE_GETVFPREGS, pid, 0, regbuf);
+    assert(!res);
+    unsigned fpscr = *(unsigned*)(regbuf + (32 * 8));
+    printf ("%x\n", fpscr);
+#endif
+#endif // (__powerpc64__ || __mips64 || __arm__)
+
+#if (__aarch64__)
+    struct iovec regset_io;
+
+    struct user_pt_regs regs;
+    regset_io.iov_base = &regs;
+    regset_io.iov_len = sizeof(regs);
+    res = ptrace(PTRACE_GETREGSET, pid, (void*)NT_PRSTATUS, (void*)&regset_io);
+    assert(!res);
+    if (regs.pc)
+      printf("%llx\n", regs.pc);
+
+    struct user_fpsimd_state fpregs;
+    regset_io.iov_base = &fpregs;
+    regset_io.iov_len = sizeof(fpregs);
+    res = ptrace(PTRACE_GETREGSET, pid, (void*)NT_FPREGSET, (void*)&regset_io);
+    assert(!res);
+    if (fpregs.fpsr)
+      printf("%x\n", fpregs.fpsr);
+#endif // (__aarch64__)
+
+    siginfo_t siginfo;
+    res = ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo);
+    assert(!res);
+    assert(siginfo.si_pid == pid);
+
+    ptrace(PTRACE_CONT, pid, NULL, NULL);
+
+    wait(NULL);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/sanitizer_set_death_callback_test.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/sanitizer_set_death_callback_test.cc
new file mode 100644
index 0000000..fdb68c0
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/sanitizer_set_death_callback_test.cc
@@ -0,0 +1,40 @@
+// RUN: %clangxx -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: stable-runtime
+
+#include <sanitizer/common_interface_defs.h>
+#include <stdio.h>
+
+volatile char *zero = 0;
+
+void Death() {
+  fprintf(stderr, "DEATH CALLBACK EXECUTED\n");
+}
+// CHECK: DEATH CALLBACK EXECUTED
+
+char global;
+volatile char *sink;
+
+__attribute__((noinline))
+void MaybeInit(int *uninitialized) {
+  if (zero)
+    *uninitialized = 1;
+}
+
+__attribute__((noinline))
+void Leak() {
+  sink = new char[100];  // trigger lsan report.
+}
+
+int main(int argc, char **argv) {
+  int uninitialized;
+  __sanitizer_set_death_callback(Death);
+  MaybeInit(&uninitialized);
+  if (uninitialized)  // trigger msan report.
+    global = 77;
+  sink = new char[100];
+  delete[] sink;
+  global = sink[0];  // use-after-free: trigger asan/tsan report.
+  Leak();
+  sink = 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/sched_getparam.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/sched_getparam.cc
new file mode 100644
index 0000000..390c656
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/sched_getparam.cc
@@ -0,0 +1,13 @@
+// RUN: %clangxx -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <sched.h>
+#include <stdio.h>
+
+int main(void) {
+  struct sched_param param;
+  int res = sched_getparam(0, &param);
+  assert(res == 0);
+  if (param.sched_priority == 42) printf(".\n");
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/sem_init_glibc.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/sem_init_glibc.cc
new file mode 100644
index 0000000..f17453b
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/sem_init_glibc.cc
@@ -0,0 +1,32 @@
+// RUN: %clangxx -O0 -g %s -lutil -o %t && %run %t
+// This test depends on the glibc layout of struct sem_t and checks that we
+// don't leave sem_t::private uninitialized.
+// UNSUPPORTED: android
+#include <assert.h>
+#include <semaphore.h>
+#include <string.h>
+
+void my_sem_init(bool priv, int value, unsigned *a, unsigned char *b) {
+  sem_t sem;
+  memset(&sem, 0xAB, sizeof(sem));
+  sem_init(&sem, priv, value);
+
+  char *p = (char *)&sem;
+  memcpy(a, p, sizeof(unsigned));
+  memcpy(b, p + sizeof(unsigned), sizeof(char));
+
+  sem_destroy(&sem);
+}
+
+int main() {
+  unsigned a;
+  unsigned char b;
+
+  my_sem_init(false, 42, &a, &b);
+  assert(a == 42);
+  assert(b != 0xAB);
+
+  my_sem_init(true, 43, &a, &b);
+  assert(a == 43);
+  assert(b != 0xAB);
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/signal_segv_handler.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/signal_segv_handler.cc
new file mode 100644
index 0000000..643fb48
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/signal_segv_handler.cc
@@ -0,0 +1,48 @@
+// RUN: %clangxx -O1 %s -o %t && TSAN_OPTIONS="flush_memory_ms=1 memory_limit_mb=1" ASAN_OPTIONS="handle_segv=0 allow_user_segv_handler=1" %run %t 2>&1 | FileCheck %s
+
+// JVM uses SEGV to preempt threads. All threads do a load from a known address
+// periodically. When runtime needs to preempt threads, it unmaps the page.
+// Threads start triggering SEGV one by one. The signal handler blocks
+// threads while runtime does its thing. Then runtime maps the page again
+// and resumes the threads.
+// Previously this pattern conflicted with stop-the-world machinery,
+// because it briefly reset SEGV handler to SIG_DFL.
+// As the consequence JVM just silently died.
+
+// This test sets memory flushing rate to maximum, then does series of
+// "benign" SEGVs that are handled by signal handler, and ensures that
+// the process survive.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <unistd.h>
+
+unsigned long page_size;
+void *guard;
+
+void handler(int signo, siginfo_t *info, void *uctx) {
+  mprotect(guard, page_size, PROT_READ | PROT_WRITE);
+}
+
+int main() {
+  page_size = sysconf(_SC_PAGESIZE);
+  struct sigaction a, old;
+  memset(&a, 0, sizeof(a));
+  memset(&old, 0, sizeof(old));
+  a.sa_sigaction = handler;
+  a.sa_flags = SA_SIGINFO;
+  sigaction(SIGSEGV, &a, &old);
+  guard = mmap(0, 3 * page_size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+  guard = (char*)guard + page_size;  // work around a kernel bug 
+  for (int i = 0; i < 1000000; i++) {
+    mprotect(guard, page_size, PROT_NONE);
+    *(int*)guard = 1;
+  }
+  sigaction(SIGSEGV, &old, 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/soft_rss_limit_mb_test.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/soft_rss_limit_mb_test.cc
new file mode 100644
index 0000000..d329122
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/soft_rss_limit_mb_test.cc
@@ -0,0 +1,66 @@
+// Check soft_rss_limit_mb. Not all sanitizers implement it yet.
+// RUN: %clangxx -O2 %s -o %t
+//
+// Run with limit should fail:
+// RUN: %env_tool_opts=soft_rss_limit_mb=220:quarantine_size=1:allocator_may_return_null=1     %run %t 2>&1 | FileCheck %s -check-prefix=CHECK_MAY_RETURN_1
+// RUN: %env_tool_opts=soft_rss_limit_mb=220:quarantine_size=1:allocator_may_return_null=0 not %run %t 2>&1 | FileCheck %s -check-prefix=CHECK_MAY_RETURN_0
+
+// This run uses getrusage. We can only test getrusage when allocator_may_return_null=0
+// because getrusage gives us max-rss, not current-rss.
+// RUN: %env_tool_opts=soft_rss_limit_mb=220:quarantine_size=1:allocator_may_return_null=0:can_use_proc_maps_statm=0 not %run %t 2>&1 | FileCheck %s -check-prefix=CHECK_MAY_RETURN_0
+
+// FIXME: make it work for other sanitizers.
+// XFAIL: lsan
+// XFAIL: tsan
+// XFAIL: msan
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+static const int kMaxNumAllocs = 1 << 9;
+static const int kAllocSize = 1 << 20;  // Large enough to go via mmap.
+
+static char *allocs[kMaxNumAllocs];
+
+int main() {
+  int num_allocs = kMaxNumAllocs / 4;
+  for (int i = 0; i < 3; i++, num_allocs *= 2) {
+    fprintf(stderr, "[%d] allocating %d times\n", i, num_allocs);
+    int zero_results = 0;
+    for (int j = 0; j < num_allocs; j++) {
+      if ((j % (num_allocs / 8)) == 0) {
+        usleep(100000);
+        fprintf(stderr, "  [%d]\n", j);
+      }
+      allocs[j] = (char*)malloc(kAllocSize);
+      if (allocs[j])
+        memset(allocs[j], -1, kAllocSize);
+      else
+        zero_results++;
+    }
+    if (zero_results)
+      fprintf(stderr, "Some of the malloc calls returned null: %d\n",
+              zero_results);
+    if (zero_results != num_allocs)
+      fprintf(stderr, "Some of the malloc calls returned non-null: %d\n",
+              num_allocs - zero_results);
+    for (int j = 0; j < num_allocs; j++) {
+      free(allocs[j]);
+    }
+  }
+}
+
+// CHECK_MAY_RETURN_1: allocating 128 times
+// CHECK_MAY_RETURN_1: Some of the malloc calls returned non-null: 128
+// CHECK_MAY_RETURN_1: allocating 256 times
+// CHECK_MAY_RETURN_1: Some of the malloc calls returned null:
+// CHECK_MAY_RETURN_1: Some of the malloc calls returned non-null:
+// CHECK_MAY_RETURN_1: allocating 512 times
+// CHECK_MAY_RETURN_1: Some of the malloc calls returned null:
+// CHECK_MAY_RETURN_1: Some of the malloc calls returned non-null:
+
+// CHECK_MAY_RETURN_0: allocating 128 times
+// CHECK_MAY_RETURN_0: Some of the malloc calls returned non-null: 128
+// CHECK_MAY_RETURN_0: allocating 256 times
+// CHECK_MAY_RETURN_0: allocator is terminating the process instead of returning
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Linux/timerfd.cc b/compiler-rt/test/sanitizer_common/TestCases/Linux/timerfd.cc
new file mode 100644
index 0000000..e7613bb
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Linux/timerfd.cc
@@ -0,0 +1,52 @@
+// RUN: %clangxx -O0 -g %s -o %t && %run %t | FileCheck %s
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
+
+int main (int argc, char** argv)
+{
+  int fd = timerfd_create(CLOCK_REALTIME, 0);
+  assert(fd >= 0);
+
+  struct itimerspec its;
+  its.it_value.tv_sec = 0;
+  its.it_value.tv_nsec = 1000000;
+  its.it_interval.tv_sec = its.it_value.tv_sec;
+  its.it_interval.tv_nsec = its.it_value.tv_nsec;
+
+  int res = timerfd_settime(fd, 0, &its, NULL);
+  assert(res != -1);
+
+  struct itimerspec its2;
+  res = timerfd_settime(fd, 0, &its, &its2);
+  assert(res != -1);
+  assert(its2.it_interval.tv_sec == its.it_interval.tv_sec);
+  assert(its2.it_interval.tv_nsec == its.it_interval.tv_nsec);
+  assert(its2.it_value.tv_sec <= its.it_value.tv_sec);
+  assert(its2.it_value.tv_nsec <= its.it_value.tv_nsec);
+
+  struct itimerspec its3;
+  res = timerfd_gettime(fd, &its3);
+  assert(res != -1);
+  assert(its3.it_interval.tv_sec == its.it_interval.tv_sec);
+  assert(its3.it_interval.tv_nsec == its.it_interval.tv_nsec);
+  assert(its3.it_value.tv_sec <= its.it_value.tv_sec);
+  assert(its3.it_value.tv_nsec <= its.it_value.tv_nsec);
+
+
+  unsigned long long buf;
+  res = read(fd, &buf, sizeof(buf));
+  assert(res == 8);
+  assert(buf >= 1);
+
+  res = close(fd);
+  assert(res != -1);
+
+  printf("DONE\n");
+  // CHECK: DONE
+  
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc b/compiler-rt/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc
new file mode 100644
index 0000000..36d4df5
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Posix/decorate_proc_maps.cc
@@ -0,0 +1,61 @@
+// RUN: %clangxx -g %s -o %t
+// RUN: %env_tool_opts=decorate_proc_maps=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%tool_name
+// REQUIRES: stable-runtime
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+bool CopyFdToFd(int in_fd, int out_fd) {
+  const size_t kBufSize = 0x10000;
+  static char buf[kBufSize];
+  while (true) {
+    ssize_t got = read(in_fd, buf, kBufSize);
+    if (got > 0) {
+      write(out_fd, buf, got);
+    } else if (got == 0) {
+      break;
+    } else if (errno != EAGAIN || errno != EWOULDBLOCK || errno != EINTR) {
+      fprintf(stderr, "error reading file, errno %d\n", errno);
+      return false;
+    }
+  }
+  return true;
+}
+
+void *ThreadFn(void *arg) {
+  (void)arg;
+  int fd = open("/proc/self/maps", O_RDONLY);
+  bool res = CopyFdToFd(fd, 2);
+  close(fd);
+  return (void *)!res;
+}
+
+int main(void) {
+  pthread_t t;
+  void *res;
+  pthread_create(&t, 0, ThreadFn, 0);
+  pthread_join(t, &res);
+  return (int)(size_t)res;
+}
+
+// CHECK-asan: rw-p {{.*}} [low shadow]
+// CHECK-asan: ---p {{.*}} [shadow gap]
+// CHECK-asan: rw-p {{.*}} [high shadow]
+
+// CHECK-msan: ---p {{.*}} [invalid]
+// CHECK-msan: rw-p {{.*}} [shadow{{.*}}]
+// CHECK-msan: ---p {{.*}} [origin{{.*}}]
+
+// CHECK-tsan: rw-p {{.*}} [shadow]
+// CHECK-tsan: rw-p {{.*}} [meta shadow]
+// CHECK-tsan: rw-p {{.*}} [trace 0]
+// CHECK-tsan: rw-p {{.*}} [trace header 0]
+// CHECK-tsan: rw-p {{.*}} [trace 1]
+// CHECK-tsan: rw-p {{.*}} [trace header 1]
+
+// Nothing interesting with standalone LSan.
+// CHECK-lsan: decorate_proc_maps
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Posix/lit.local.cfg b/compiler-rt/test/sanitizer_common/TestCases/Posix/lit.local.cfg
new file mode 100644
index 0000000..a6d96d3
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Posix/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os in ['Windows', 'Darwin']:
+  config.unsupported = True
diff --git a/compiler-rt/test/sanitizer_common/TestCases/corelimit.cc b/compiler-rt/test/sanitizer_common/TestCases/corelimit.cc
new file mode 100644
index 0000000..8f54940
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/corelimit.cc
@@ -0,0 +1,16 @@
+// RUN: %clangxx -O0 %s -o %t && %run %t
+// XFAIL: lsan
+
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+int main() {
+  struct rlimit lim_core;
+  getrlimit(RLIMIT_CORE, &lim_core);
+  void *p;
+  if (sizeof(p) == 8) {
+    assert(0 == lim_core.rlim_max);
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/fopen_nullptr.c b/compiler-rt/test/sanitizer_common/TestCases/fopen_nullptr.c
new file mode 100644
index 0000000..960dda3
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/fopen_nullptr.c
@@ -0,0 +1,6 @@
+// Check that fopen(NULL, "r") is ok.
+// RUN: %clang -O2 %s -o %t && %run %t
+#include <stdio.h>
+const char *fn = NULL;
+FILE *f;
+int main() { f = fopen(fn, "r"); }
diff --git a/compiler-rt/test/sanitizer_common/TestCases/malloc_hook.cc b/compiler-rt/test/sanitizer_common/TestCases/malloc_hook.cc
new file mode 100644
index 0000000..9702249
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/malloc_hook.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Malloc/free hooks are not supported on Windows.
+// XFAIL: win32
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sanitizer/allocator_interface.h>
+
+extern "C" {
+const volatile void *global_ptr;
+
+// Note: avoid calling functions that allocate memory in malloc/free
+// to avoid infinite recursion.
+void __sanitizer_malloc_hook(const volatile void *ptr, size_t sz) {
+  if (__sanitizer_get_ownership(ptr)) {
+    write(1, "MallocHook\n", sizeof("MallocHook\n"));
+    global_ptr = ptr;
+  }
+}
+void __sanitizer_free_hook(const volatile void *ptr) {
+  if (__sanitizer_get_ownership(ptr) && ptr == global_ptr)
+    write(1, "FreeHook\n", sizeof("FreeHook\n"));
+}
+}  // extern "C"
+
+int main() {
+  volatile int *x = new int;
+  // CHECK: MallocHook
+  // Check that malloc hook was called with correct argument.
+  if (global_ptr != (void*)x) {
+    _exit(1);
+  }
+  *x = 0;
+  delete x;
+  // CHECK: FreeHook
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/options-help.cc b/compiler-rt/test/sanitizer_common/TestCases/options-help.cc
new file mode 100644
index 0000000..913377d
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/options-help.cc
@@ -0,0 +1,8 @@
+// RUN: %clangxx -O0 %s -o %t
+// RUN: %env_tool_opts=help=1 %run %t 2>&1 | FileCheck %s
+
+int main() {
+}
+
+// CHECK: Available flags for {{.*}}Sanitizer:
+// CHECK: handle_segv
diff --git a/compiler-rt/test/sanitizer_common/TestCases/options-include.cc b/compiler-rt/test/sanitizer_common/TestCases/options-include.cc
new file mode 100644
index 0000000..1528b15
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/options-include.cc
@@ -0,0 +1,46 @@
+// RUN: %clangxx -O0 %s -o %t
+
+// Recursive include: options1 includes options2
+// RUN: echo -e "symbolize=1\ninclude='%t.options2.txt'" >%t.options1.txt
+// RUN: echo -e "help=1\n" >%t.options2.txt
+// RUN: echo -e "help=1\n" >%t.options.options-include.cc.tmp
+// RUN: cat %t.options1.txt
+// RUN: cat %t.options2.txt
+
+// RUN: %env_tool_opts=help=0:include='"%t.options1.txt"' %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND <%t.out
+
+// RUN: %env_tool_opts=include='"%t.options1.txt"',help=0 %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-FOUND <%t.out
+
+// RUN: %env_tool_opts=include='"%t.options-not-found.txt"',help=1 not %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-NOT-FOUND < %t.out
+
+// include_if_exists does not fail when the file is missing
+// RUN: %env_tool_opts=include_if_exists='"%t.options-not-found.txt"',help=1 %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
+
+// %b (binary basename substitution)
+// RUN: %env_tool_opts=include='"%t.options.%b"' %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
+
+// RUN: %env_tool_opts=include='"%t.options-not-found.%b"' not %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-NOT-FOUND < %t.out
+
+// RUN: %env_tool_opts=include_if_exists='"%t.options.%b"' %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
+
+// RUN: %env_tool_opts=include_if_exists='"%t.options-not-found.%b"' %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-FOUND < %t.out
+
+
+#include <stdio.h>
+
+int main() {
+  fprintf(stderr, "done\n");
+}
+
+// CHECK-WITH-HELP: Available flags for
+// CHECK-WITHOUT-HELP-NOT: Available flags for
+// CHECK-FOUND-NOT: Failed to read options from
+// CHECK-NOT-FOUND: Failed to read options from
diff --git a/compiler-rt/test/sanitizer_common/TestCases/options-invalid.cc b/compiler-rt/test/sanitizer_common/TestCases/options-invalid.cc
new file mode 100644
index 0000000..572c491
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/options-invalid.cc
@@ -0,0 +1,15 @@
+// RUN: %clangxx -O0 %s -o %t
+// RUN: %env_tool_opts=invalid_option_name=10,verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-V1
+// RUN: %env_tool_opts=invalid_option_name=10 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-V0
+
+#include <stdio.h>
+
+int main() {
+  fprintf(stderr, "done\n");
+}
+
+// CHECK-V1: WARNING: found 1 unrecognized
+// CHECK-V1:     invalid_option_name
+// CHECK-V0-NOT: WARNING: found 1 unrecognized
+// CHECK-V0-NOT:     invalid_option_name
+// CHECK: done
diff --git a/compiler-rt/test/sanitizer_common/TestCases/print-stack-trace.cc b/compiler-rt/test/sanitizer_common/TestCases/print-stack-trace.cc
new file mode 100644
index 0000000..9134a88
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/print-stack-trace.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx -O0 %s -o %t && %env_tool_opts=stack_trace_format=DEFAULT %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx -O3 %s -o %t && %env_tool_opts=stack_trace_format=DEFAULT %run %t 2>&1 | FileCheck %s
+// RUN: %env_tool_opts=stack_trace_format='"frame:%n lineno:%l"' %run %t 2>&1 | FileCheck %s --check-prefix=CUSTOM
+// RUN: %env_tool_opts=symbolize_inline_frames=false:stack_trace_format=DEFAULT %run %t 2>&1 | FileCheck %s --check-prefix=NOINLINE
+
+#include <sanitizer/common_interface_defs.h>
+
+static inline void FooBarBaz() {
+  __sanitizer_print_stack_trace();
+}
+
+int main() {
+  FooBarBaz();
+  return 0;
+}
+// CHECK: {{    #0 0x.* in __sanitizer_print_stack_trace}}
+// CHECK: {{    #1 0x.* in FooBarBaz(\(\))? .*print-stack-trace.cc:9}}
+// CHECK: {{    #2 0x.* in main.*print-stack-trace.cc:13}}
+
+// CUSTOM: frame:1 lineno:9
+// CUSTOM: frame:2 lineno:13
+
+// NOINLINE: #0 0x{{.*}} in __sanitizer_print_stack_trace
+// NOINLINE: #1 0x{{.*}} in main{{.*}}print-stack-trace.cc:9
diff --git a/compiler-rt/test/sanitizer_common/TestCases/pthread_mutexattr_get.cc b/compiler-rt/test/sanitizer_common/TestCases/pthread_mutexattr_get.cc
new file mode 100644
index 0000000..26060f3
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/pthread_mutexattr_get.cc
@@ -0,0 +1,19 @@
+// RUN: %clangxx -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <pthread.h>
+
+int main(void) {
+  pthread_mutexattr_t ma;
+  int res = pthread_mutexattr_init(&ma);
+  assert(res == 0);
+  res = pthread_mutexattr_setpshared(&ma, 1);
+  assert(res == 0);
+  int pshared;
+  res = pthread_mutexattr_getpshared(&ma, &pshared);
+  assert(res == 0);
+  assert(pshared == 1);
+  res = pthread_mutexattr_destroy(&ma);
+  assert(res == 0);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/strcasestr.c b/compiler-rt/test/sanitizer_common/TestCases/strcasestr.c
new file mode 100644
index 0000000..4de3cac
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/strcasestr.c
@@ -0,0 +1,16 @@
+// RUN: %clang %s -o %t && %run %t 2>&1
+
+// There's no interceptor for strcasestr on Windows
+// XFAIL: win32
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s1[] = "aB";
+  char s2[] = "b";
+  r = strcasestr(s1, s2);
+  assert(r == s1 + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/strcspn.c b/compiler-rt/test/sanitizer_common/TestCases/strcspn.c
new file mode 100644
index 0000000..066a27b
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/strcspn.c
@@ -0,0 +1,13 @@
+// RUN: %clang %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t r;
+  char s1[] = "ad";
+  char s2[] = "cd";
+  r = strcspn(s1, s2);
+  assert(r == 1);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/strpbrk.c b/compiler-rt/test/sanitizer_common/TestCases/strpbrk.c
new file mode 100644
index 0000000..318e3a4
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/strpbrk.c
@@ -0,0 +1,14 @@
+// RUN: %clang %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+
+
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s1[] = "ad";
+  char s2[] = "cd";
+  r = strpbrk(s1, s2);
+  assert(r == s1 + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/strspn.c b/compiler-rt/test/sanitizer_common/TestCases/strspn.c
new file mode 100644
index 0000000..a9a2430
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/strspn.c
@@ -0,0 +1,13 @@
+// RUN: %clang %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+
+int main(int argc, char **argv) {
+  size_t r;
+  char s1[] = "ab";
+  char s2[] = "ac";
+  r = strspn(s1, s2);
+  assert(r == 1);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/TestCases/strstr.c b/compiler-rt/test/sanitizer_common/TestCases/strstr.c
new file mode 100644
index 0000000..2089ac7
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/strstr.c
@@ -0,0 +1,12 @@
+// RUN: %clang %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *r = 0;
+  char s1[] = "ab";
+  char s2[] = "b";
+  r = strstr(s1, s2);
+  assert(r == s1 + 1);
+  return 0;
+}
diff --git a/compiler-rt/test/sanitizer_common/Unit/lit.site.cfg.in b/compiler-rt/test/sanitizer_common/Unit/lit.site.cfg.in
new file mode 100644
index 0000000..2600585
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/Unit/lit.site.cfg.in
@@ -0,0 +1,15 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Load common config for all compiler-rt unit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
+
+# Setup config name.
+config.name = 'SanitizerCommon-Unit'
+
+# Setup test source and exec root. For unit tests, we define
+# it as build directory with sanitizer_common tests.
+# FIXME: De-hardcode this path.
+config.test_exec_root = os.path.join("@COMPILER_RT_BINARY_DIR@", "lib",
+                                     "sanitizer_common", "tests")
+config.test_source_root = config.test_exec_root
diff --git a/compiler-rt/test/sanitizer_common/lit.common.cfg b/compiler-rt/test/sanitizer_common/lit.common.cfg
new file mode 100644
index 0000000..7abbfc2
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/lit.common.cfg
@@ -0,0 +1,51 @@
+# -*- Python -*-
+
+# Setup source root.
+config.test_source_root = os.path.join(os.path.dirname(__file__), "TestCases")
+
+config.name = "SanitizerCommon-" + config.tool_name
+
+default_tool_options = []
+if config.tool_name == "asan":
+  tool_cflags = ["-fsanitize=address"]
+  tool_options = "ASAN_OPTIONS"
+elif config.tool_name == "tsan":
+  tool_cflags = ["-fsanitize=thread"]
+  tool_options = "TSAN_OPTIONS"
+elif config.tool_name == "msan":
+  tool_cflags = ["-fsanitize=memory"]
+  tool_options = "MSAN_OPTIONS"
+elif config.tool_name == "lsan":
+  tool_cflags = ["-fsanitize=leak"]
+  tool_options = "LSAN_OPTIONS"
+else:
+  lit_config.fatal("Unknown tool for sanitizer_common tests: %r" % config.tool_name)
+
+config.available_features.add(config.tool_name)
+
+if config.host_os == 'Darwin':
+  # On Darwin, we default to `abort_on_error=1`, which would make tests run
+  # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
+  default_tool_options += ['abort_on_error=0']
+default_tool_options_str = ':'.join(default_tool_options)
+if default_tool_options_str:
+  config.environment[tool_options] = default_tool_options_str
+  default_tool_options_str += ':'
+
+clang_cflags = config.debug_info_flags + tool_cflags + [config.target_cflags]
+clang_cxxflags = config.cxx_mode_flags + clang_cflags
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )
+config.substitutions.append( ("%clangxx ", build_invocation(clang_cxxflags)) )
+config.substitutions.append( ("%tool_name", config.tool_name) )
+config.substitutions.append( ("%tool_options", tool_options) )
+config.substitutions.append( ('%env_tool_opts=',
+                              'env ' + tool_options + '=' + default_tool_options_str))
+
+config.suffixes = ['.c', '.cc', '.cpp']
+
+if config.host_os not in ['Linux', 'Darwin']:
+  config.unsupported = True
diff --git a/compiler-rt/test/sanitizer_common/lit.site.cfg.in b/compiler-rt/test/sanitizer_common/lit.site.cfg.in
new file mode 100644
index 0000000..64a3edf
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/lit.site.cfg.in
@@ -0,0 +1,11 @@
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Tool-specific config options.
+config.tool_name = "@SANITIZER_COMMON_LIT_TEST_MODE@"
+config.target_cflags = "@SANITIZER_COMMON_TEST_TARGET_CFLAGS@"
+config.target_arch = "@SANITIZER_COMMON_TEST_TARGET_ARCH@"
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@SANITIZER_COMMON_LIT_SOURCE_DIR@/lit.common.cfg")
+
diff --git a/compiler-rt/test/tsan/CMakeLists.txt b/compiler-rt/test/tsan/CMakeLists.txt
new file mode 100644
index 0000000..01e8038
--- /dev/null
+++ b/compiler-rt/test/tsan/CMakeLists.txt
@@ -0,0 +1,31 @@
+set(TSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "x86_64")
+  list(APPEND TSAN_TEST_DEPS GotsanRuntimeCheck)
+endif()
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND TSAN_TEST_DEPS tsan)
+endif()
+if(COMPILER_RT_HAS_LIBCXX_SOURCES AND
+   COMPILER_RT_TEST_COMPILER_ID STREQUAL "Clang"
+   AND NOT APPLE)
+  list(APPEND TSAN_TEST_DEPS libcxx_tsan)
+  set(TSAN_HAS_LIBCXX True)
+else()
+  set(TSAN_HAS_LIBCXX False)
+endif()
+
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
+  list(APPEND TSAN_TEST_DEPS TsanUnitTests)
+endif()
+
+add_lit_testsuite(check-tsan "Running ThreadSanitizer tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS ${TSAN_TEST_DEPS})
+set_target_properties(check-tsan PROPERTIES FOLDER "TSan tests")
diff --git a/compiler-rt/test/tsan/Darwin/gcd-async-norace.mm b/compiler-rt/test/tsan/Darwin/gcd-async-norace.mm
new file mode 100644
index 0000000..b987e00
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-async-norace.mm
@@ -0,0 +1,26 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+int main() {
+  NSLog(@"Hello world.");
+
+  global = 42;
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    global = 43;
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  CFRunLoopRun();
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/gcd-async-race.mm b/compiler-rt/test/tsan/Darwin/gcd-async-race.mm
new file mode 100644
index 0000000..31163f9
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-async-race.mm
@@ -0,0 +1,38 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %deflake %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+#import "../test.h"
+
+long global;
+
+int main() {
+  NSLog(@"Hello world.");
+  NSLog(@"addr=%p\n", &global);
+  barrier_init(&barrier, 2);
+
+  global = 42;
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    global = 43;
+    barrier_wait(&barrier);
+  });
+
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    barrier_wait(&barrier);
+    global = 44;
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  CFRunLoopRun();
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'global' at [[ADDR]] (global_race.cc.exe+0x{{[0-9,a-f]+}})
+// CHECK: Done.
diff --git a/compiler-rt/test/tsan/Darwin/gcd-groups-norace.mm b/compiler-rt/test/tsan/Darwin/gcd-groups-norace.mm
new file mode 100644
index 0000000..fb4d804
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-groups-norace.mm
@@ -0,0 +1,53 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+#import "../test.h"
+
+long global;
+
+int main() {
+  NSLog(@"Hello world.");
+  NSLog(@"addr=%p\n", &global);
+
+  dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+  global = 42;
+
+  dispatch_group_t g = dispatch_group_create();
+  dispatch_group_async(g, q, ^{
+    global = 43;
+  });
+  dispatch_group_wait(g, DISPATCH_TIME_FOREVER);
+
+  global = 44;
+
+  dispatch_group_enter(g);
+  dispatch_async(q, ^{
+    global = 45;
+    dispatch_group_leave(g);
+  });
+  dispatch_group_wait(g, DISPATCH_TIME_FOREVER);
+
+  global = 46;
+
+  dispatch_group_enter(g);
+  dispatch_async(q, ^{
+    global = 47;
+    dispatch_group_leave(g);
+  });
+  dispatch_group_notify(g, q, ^{
+    global = 48;
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  CFRunLoopRun();
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/gcd-groups-stress.mm b/compiler-rt/test/tsan/Darwin/gcd-groups-stress.mm
new file mode 100644
index 0000000..62a8008
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-groups-stress.mm
@@ -0,0 +1,43 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+void notify_callback(void *context) {
+  // Do nothing.
+}
+
+int main() {
+  NSLog(@"Hello world.");
+
+  dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+  
+  for (int i = 0; i < 300000; i++) {
+    dispatch_group_t g = dispatch_group_create();
+    dispatch_group_enter(g);
+    dispatch_async(q, ^{
+      dispatch_group_leave(g);
+    });
+    dispatch_group_notify(g, q, ^{
+      // Do nothing.
+    });
+    dispatch_release(g);
+  }
+
+  for (int i = 0; i < 300000; i++) {
+    dispatch_group_t g = dispatch_group_create();
+    dispatch_group_enter(g);
+    dispatch_async(q, ^{
+      dispatch_group_leave(g);
+    });
+    dispatch_group_notify_f(g, q, nullptr, &notify_callback);
+    dispatch_release(g);
+  }
+
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
+// CHECK-NOT: CHECK failed
diff --git a/compiler-rt/test/tsan/Darwin/gcd-once.mm b/compiler-rt/test/tsan/Darwin/gcd-once.mm
new file mode 100644
index 0000000..17757d2
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-once.mm
@@ -0,0 +1,55 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+#import "../test.h"
+
+static const long kNumThreads = 4;
+
+long global;
+long global2;
+
+static dispatch_once_t once_token;
+static dispatch_once_t once_token2;
+
+void f(void *) {
+  global2 = 42;
+  usleep(100000);
+}
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+
+  dispatch_once(&once_token, ^{
+    global = 42;
+    usleep(100000);
+  });
+  long x = global;
+
+  dispatch_once_f(&once_token2, NULL, f);
+  long x2 = global2;
+
+  fprintf(stderr, "global = %ld\n", x);
+  fprintf(stderr, "global2 = %ld\n", x2);
+  return 0;
+}
+
+int main() {
+  fprintf(stderr, "Hello world.\n");
+  barrier_init(&barrier, kNumThreads);
+
+  pthread_t t[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++) {
+    pthread_create(&t[i], 0, Thread, 0);
+  }
+  for (int i = 0; i < kNumThreads; i++) {
+    pthread_join(t[i], 0);
+  }
+
+  fprintf(stderr, "Done.\n");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/gcd-semaphore-norace.mm b/compiler-rt/test/tsan/Darwin/gcd-semaphore-norace.mm
new file mode 100644
index 0000000..cd52a79
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-semaphore-norace.mm
@@ -0,0 +1,29 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+int main() {
+    NSLog(@"Hello world.");
+
+    global = 42;
+    
+    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        
+        global = 43;
+        dispatch_semaphore_signal(sem);
+    });
+    
+    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+    global = 44;
+
+    NSLog(@"Done.");
+    return 0;
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/gcd-serial-queue-norace.mm b/compiler-rt/test/tsan/Darwin/gcd-serial-queue-norace.mm
new file mode 100644
index 0000000..8f6de27
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-serial-queue-norace.mm
@@ -0,0 +1,40 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+#import "../test.h"
+
+long global;
+
+int main() {
+  NSLog(@"Hello world.");
+  NSLog(@"addr=%p\n", &global);
+
+  dispatch_queue_t q1 = dispatch_queue_create("my.queue1", DISPATCH_QUEUE_CONCURRENT);
+  dispatch_queue_t q2 = dispatch_queue_create("my.queue2", DISPATCH_QUEUE_SERIAL);
+
+  global = 42;
+  for (int i = 0; i < 10; i++) {
+    dispatch_async(q1, ^{
+      for (int i = 0; i < 100; i++) {
+        dispatch_sync(q2, ^{
+          global++;
+        });
+      }
+    });
+  }
+
+  dispatch_barrier_async(q1, ^{
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  CFRunLoopRun();
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/gcd-sync-norace.mm b/compiler-rt/test/tsan/Darwin/gcd-sync-norace.mm
new file mode 100644
index 0000000..f21cfde
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-sync-norace.mm
@@ -0,0 +1,32 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+static const long nIter = 1000;
+
+int main() {
+  NSLog(@"Hello world.");
+
+  global = 42;
+  for (int i = 0; i < nIter; i++) {
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+      dispatch_sync(dispatch_get_main_queue(), ^{
+        global = i;
+
+        if (i == nIter - 1) {
+          CFRunLoopStop(CFRunLoopGetCurrent());
+        }
+      });
+    });
+  }
+
+  CFRunLoopRun();
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/gcd-sync-race.mm b/compiler-rt/test/tsan/Darwin/gcd-sync-race.mm
new file mode 100644
index 0000000..62901d9
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/gcd-sync-race.mm
@@ -0,0 +1,44 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %deflake %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+#import "../test.h"
+
+long global;
+
+int main() {
+  NSLog(@"Hello world.");
+  NSLog(@"addr=%p\n", &global);
+  barrier_init(&barrier, 2);
+
+  dispatch_queue_t q1 = dispatch_queue_create("my.queue1", DISPATCH_QUEUE_CONCURRENT);
+  dispatch_queue_t q2 = dispatch_queue_create("my.queue2", DISPATCH_QUEUE_CONCURRENT);
+
+  global = 42;
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    dispatch_sync(q1, ^{
+      global = 43;
+      barrier_wait(&barrier);
+    });
+  });
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    dispatch_sync(q2, ^{
+      barrier_wait(&barrier);
+      global = 44;
+
+      dispatch_sync(dispatch_get_main_queue(), ^{
+        CFRunLoopStop(CFRunLoopGetCurrent());
+      });
+    });
+  });
+
+  CFRunLoopRun();
+  NSLog(@"Done.");
+}
+
+// CHECK: Hello world.
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'global' at [[ADDR]] (global_race.cc.exe+0x{{[0-9,a-f]+}})
+// CHECK: Done.
diff --git a/compiler-rt/test/tsan/Darwin/lit.local.cfg b/compiler-rt/test/tsan/Darwin/lit.local.cfg
new file mode 100644
index 0000000..a85dfcd
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Darwin']:
+  config.unsupported = True
diff --git a/compiler-rt/test/tsan/Darwin/objc-race.mm b/compiler-rt/test/tsan/Darwin/objc-race.mm
new file mode 100644
index 0000000..bd93d2f
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/objc-race.mm
@@ -0,0 +1,55 @@
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %deflake %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+#import "../test.h"
+
+@interface MyClass : NSObject {
+  long instance_variable;
+}
+- (void)method:(long)value;
+@end
+
+@implementation MyClass
+
+- (void)method:(long)value {
+  self->instance_variable = value;
+}
+
+@end
+
+int main() {
+  NSLog(@"Hello world.");
+  barrier_init(&barrier, 2);
+  
+  MyClass *my_object = [MyClass new];
+  [my_object method:42];
+  
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [my_object method:43];
+    barrier_wait(&barrier);
+  });
+  
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    barrier_wait(&barrier);
+    [my_object method:44];
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+  
+  CFRunLoopRun();
+  NSLog(@"Done.");
+  return 0;
+}
+
+// CHECK: Hello world.
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 8
+// CHECK:     #0 -[MyClass method:]
+// CHECK:   Write of size 8
+// CHECK:     #0 -[MyClass method:]
+// CHECK:   Location is heap block
+// CHECK: Done.
diff --git a/compiler-rt/test/tsan/Darwin/objc-simple.mm b/compiler-rt/test/tsan/Darwin/objc-simple.mm
new file mode 100644
index 0000000..a4bf1f1
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/objc-simple.mm
@@ -0,0 +1,13 @@
+// Test that a simple Obj-C program runs and exits without any warnings.
+
+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+int main() {
+  NSLog(@"Hello world");
+}
+
+// CHECK: Hello world
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/osspinlock-norace.cc b/compiler-rt/test/tsan/Darwin/osspinlock-norace.cc
new file mode 100644
index 0000000..2ac3989
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/osspinlock-norace.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <libkern/OSAtomic.h>
+#include <pthread.h>
+#include <stdio.h>
+
+int Global;
+OSSpinLock lock;
+
+void *Thread(void *x) {
+  OSSpinLockLock(&lock);
+  Global++;
+  OSSpinLockUnlock(&lock);
+  return NULL;
+}
+
+int main() {
+  fprintf(stderr, "Hello world.\n");
+
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread, NULL);
+  pthread_create(&t[1], NULL, Thread, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+
+  fprintf(stderr, "Done.\n");
+}
+
+// CHECK: Hello world.
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer
diff --git a/compiler-rt/test/tsan/Darwin/symbolizer-atos.cc b/compiler-rt/test/tsan/Darwin/symbolizer-atos.cc
new file mode 100644
index 0000000..960fecc
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/symbolizer-atos.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %env_tsan_opts=verbosity=2:external_symbolizer_path=/usr/bin/atos %deflake %run %t | FileCheck %s
+#include "../test.h"
+
+int GlobalData[10];
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  GlobalData[2] = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr=", 1, GlobalData);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  GlobalData[2] = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: Using atos at user-specified path: /usr/bin/atos
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'GlobalData' at [[ADDR]] ({{.*}}+0x{{[0-9,a-f]+}})
diff --git a/compiler-rt/test/tsan/Darwin/symbolizer-dladdr.cc b/compiler-rt/test/tsan/Darwin/symbolizer-dladdr.cc
new file mode 100644
index 0000000..3b213dd
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/symbolizer-dladdr.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %env_tsan_opts=verbosity=2:external_symbolizer_path= %deflake %run %t | FileCheck %s
+#include "../test.h"
+
+int GlobalData[10];
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  GlobalData[2] = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr=", 1, GlobalData);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  GlobalData[2] = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: External symbolizer is explicitly disabled.
+// CHECK: Using dladdr symbolizer.
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'GlobalData' at [[ADDR]] ({{.*}}+0x{{[0-9,a-f]+}})
diff --git a/compiler-rt/test/tsan/Linux/check_memcpy.cc b/compiler-rt/test/tsan/Linux/check_memcpy.cc
new file mode 100644
index 0000000..8ad04c0
--- /dev/null
+++ b/compiler-rt/test/tsan/Linux/check_memcpy.cc
@@ -0,0 +1,15 @@
+// Test that verifies TSan runtime doesn't contain compiler-emitted
+// memcpy/memmove calls. It builds the binary with TSan and passes it to
+// check_memcpy.sh script.
+
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: llvm-objdump -d %t | FileCheck %s
+
+int main() {
+  return 0;
+}
+
+// CHECK-NOT: callq {{.*<(__interceptor_)?mem(cpy|set)>}}
+// tail calls:
+// CHECK-NOT: jmpq {{.*<(__interceptor_)?mem(cpy|set)>}}
+
diff --git a/compiler-rt/test/tsan/Linux/lit.local.cfg b/compiler-rt/test/tsan/Linux/lit.local.cfg
new file mode 100644
index 0000000..57271b8
--- /dev/null
+++ b/compiler-rt/test/tsan/Linux/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/tsan/Linux/mutex_robust.cc b/compiler-rt/test/tsan/Linux/mutex_robust.cc
new file mode 100644
index 0000000..5ca5e70
--- /dev/null
+++ b/compiler-rt/test/tsan/Linux/mutex_robust.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+
+pthread_mutex_t m;
+
+void *thr(void *p) {
+  pthread_mutex_lock(&m);
+  return 0;
+}
+
+int main() {
+  pthread_mutexattr_t a;
+  pthread_mutexattr_init(&a);
+  pthread_mutexattr_setrobust(&a, PTHREAD_MUTEX_ROBUST);
+  pthread_mutex_init(&m, &a);
+  pthread_t th;
+  pthread_create(&th, 0, thr, 0);
+  sleep(1);
+  if (pthread_mutex_lock(&m) != EOWNERDEAD) {
+    fprintf(stderr, "not EOWNERDEAD\n");
+    exit(1);
+  }
+  pthread_join(th, 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// This is a correct code, and tsan must not bark.
+// CHECK-NOT: WARNING: ThreadSanitizer
+// CHECK-NOT: EOWNERDEAD
+// CHECK: DONE
+// CHECK-NOT: WARNING: ThreadSanitizer
+
diff --git a/compiler-rt/test/tsan/Linux/mutex_robust2.cc b/compiler-rt/test/tsan/Linux/mutex_robust2.cc
new file mode 100644
index 0000000..0914c17
--- /dev/null
+++ b/compiler-rt/test/tsan/Linux/mutex_robust2.cc
@@ -0,0 +1,41 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+
+pthread_mutex_t m;
+int x;
+
+void *thr(void *p) {
+  pthread_mutex_lock(&m);
+  x = 42;
+  return 0;
+}
+
+int main() {
+  pthread_mutexattr_t a;
+  pthread_mutexattr_init(&a);
+  pthread_mutexattr_setrobust(&a, PTHREAD_MUTEX_ROBUST);
+  pthread_mutex_init(&m, &a);
+  pthread_t th;
+  pthread_create(&th, 0, thr, 0);
+  sleep(1);
+  if (pthread_mutex_trylock(&m) != EOWNERDEAD) {
+    fprintf(stderr, "not EOWNERDEAD\n");
+    exit(1);
+  }
+  x = 43;
+  pthread_join(th, 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// This is a false positive, tsan must not bark at the data race.
+// But currently it does.
+// CHECK-NOT: WARNING: ThreadSanitizer WARNING: double lock of mutex
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: EOWNERDEAD
+// CHECK: DONE
+// CHECK-NOT: WARNING: ThreadSanitizer
+
diff --git a/compiler-rt/test/tsan/Linux/user_fopen.cc b/compiler-rt/test/tsan/Linux/user_fopen.cc
new file mode 100644
index 0000000..c0ff267
--- /dev/null
+++ b/compiler-rt/test/tsan/Linux/user_fopen.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+#include <stdlib.h>
+
+// Defined by tsan.
+extern "C" FILE *__interceptor_fopen(const char *file, const char *mode);
+extern "C" int __interceptor_fileno(FILE *f);
+
+extern "C" FILE *fopen(const char *file, const char *mode) {
+  static int first = 0;
+  if (__sync_lock_test_and_set(&first, 1) == 0)
+    printf("user fopen\n");
+  return __interceptor_fopen(file, mode);
+}
+
+extern "C" int fileno(FILE *f) {
+  static int first = 0;
+  if (__sync_lock_test_and_set(&first, 1) == 0)
+    printf("user fileno\n");
+  return 1;
+}
+
+int main() {
+  FILE *f = fopen("/dev/zero", "r");
+  if (f) {
+    char buf;
+    fread(&buf, 1, 1, f);
+    fclose(f);
+  }
+}
+
+// CHECK: user fopen
+// CHECK-NOT: ThreadSanitizer
+
diff --git a/compiler-rt/test/tsan/Linux/user_malloc.cc b/compiler-rt/test/tsan/Linux/user_malloc.cc
new file mode 100644
index 0000000..c671bfc
--- /dev/null
+++ b/compiler-rt/test/tsan/Linux/user_malloc.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+
+// Defined by tsan.
+extern "C" void *__interceptor_malloc(unsigned long size);
+extern "C" void __interceptor_free(void *p);
+
+extern "C" void *malloc(unsigned long size) {
+  static int first = 0;
+  if (__sync_lock_test_and_set(&first, 1) == 0)
+    printf("user malloc\n");
+  return __interceptor_malloc(size);
+}
+
+extern "C" void free(void *p) {
+  __interceptor_free(p);
+}
+
+int main() {
+  volatile char *p = (char*)malloc(10);
+  p[0] = 0;
+  free((void*)p);
+}
+
+// CHECK: user malloc
+// CHECK-NOT: ThreadSanitizer
+
diff --git a/compiler-rt/test/tsan/Unit/lit.site.cfg.in b/compiler-rt/test/tsan/Unit/lit.site.cfg.in
new file mode 100644
index 0000000..9498105
--- /dev/null
+++ b/compiler-rt/test/tsan/Unit/lit.site.cfg.in
@@ -0,0 +1,14 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Load common config for all compiler-rt unit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
+
+# Setup config name.
+config.name = 'ThreadSanitizer-Unit'
+
+# Setup test source and exec root. For unit tests, we define
+# it as build directory with ASan unit tests.
+# FIXME: De-hardcode this path.
+config.test_exec_root = "@COMPILER_RT_BINARY_DIR@/lib/tsan/tests"
+config.test_source_root = config.test_exec_root
diff --git a/compiler-rt/test/tsan/aligned_vs_unaligned_race.cc b/compiler-rt/test/tsan/aligned_vs_unaligned_race.cc
new file mode 100644
index 0000000..5c1189f
--- /dev/null
+++ b/compiler-rt/test/tsan/aligned_vs_unaligned_race.cc
@@ -0,0 +1,35 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+// Race between an aligned access and an unaligned access, which
+// touches the same memory region.
+#include "test.h"
+#include <stdint.h>
+
+uint64_t Global[2];
+
+void *Thread1(void *x) {
+  Global[1]++;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  char *p1 = reinterpret_cast<char *>(&Global[0]);
+  struct __attribute__((packed, aligned(1))) u_uint64_t { uint64_t val; };
+  u_uint64_t *p4 = reinterpret_cast<u_uint64_t *>(p1 + 1);
+  (*p4).val++;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("Pass\n");
+  // CHECK: ThreadSanitizer: data race
+  // CHECK: Pass
+  return 0;
+}
diff --git a/compiler-rt/test/tsan/allocator_returns_null.cc b/compiler-rt/test/tsan/allocator_returns_null.cc
new file mode 100644
index 0000000..6693007
--- /dev/null
+++ b/compiler-rt/test/tsan/allocator_returns_null.cc
@@ -0,0 +1,64 @@
+// Test the behavior of malloc/calloc/realloc when the allocation size is huge.
+// By default (allocator_may_return_null=0) the process should crash.
+// With allocator_may_return_null=1 the allocator should return 0.
+//
+// RUN: %clangxx_tsan -O0 %s -o %t
+// RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: %env_tsan_opts=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: %env_tsan_opts=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
+// RUN: %env_tsan_opts=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
+// RUN: %env_tsan_opts=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
+// RUN: %env_tsan_opts=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <limits>
+int main(int argc, char **argv) {
+  volatile size_t size = std::numeric_limits<size_t>::max() - 10000;
+  assert(argc == 2);
+  char *x = 0;
+  if (!strcmp(argv[1], "malloc")) {
+    fprintf(stderr, "malloc:\n");
+    x = (char*)malloc(size);
+  }
+  if (!strcmp(argv[1], "calloc")) {
+    fprintf(stderr, "calloc:\n");
+    x = (char*)calloc(size / 4, 4);
+  }
+
+  if (!strcmp(argv[1], "calloc-overflow")) {
+    fprintf(stderr, "calloc-overflow:\n");
+    volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max();
+    size_t kArraySize = 4096;
+    volatile size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
+    x = (char*)calloc(kArraySize, kArraySize2);
+  }
+
+  if (!strcmp(argv[1], "realloc")) {
+    fprintf(stderr, "realloc:\n");
+    x = (char*)realloc(0, size);
+  }
+  if (!strcmp(argv[1], "realloc-after-malloc")) {
+    fprintf(stderr, "realloc-after-malloc:\n");
+    char *t = (char*)malloc(100);
+    *t = 42;
+    x = (char*)realloc(t, size);
+    assert(*t == 42);
+  }
+  fprintf(stderr, "x: %p\n", x);
+  return x != 0;
+}
+// CHECK-mCRASH: malloc:
+// CHECK-mCRASH: ThreadSanitizer's allocator is terminating the process
+// CHECK-cCRASH: calloc:
+// CHECK-cCRASH: ThreadSanitizer's allocator is terminating the process
+// CHECK-coCRASH: calloc-overflow:
+// CHECK-coCRASH: ThreadSanitizer's allocator is terminating the process
+// CHECK-rCRASH: realloc:
+// CHECK-rCRASH: ThreadSanitizer's allocator is terminating the process
+// CHECK-mrCRASH: realloc-after-malloc:
+// CHECK-mrCRASH: ThreadSanitizer's allocator is terminating the process
+
diff --git a/compiler-rt/test/tsan/annotate_happens_before.cc b/compiler-rt/test/tsan/annotate_happens_before.cc
new file mode 100644
index 0000000..0116616
--- /dev/null
+++ b/compiler-rt/test/tsan/annotate_happens_before.cc
@@ -0,0 +1,57 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+/*
+Annotations usage example.
+
+Tsan does not see synchronization in barrier_wait.
+ANNOTATE_HAPPENS_BEFORE/AFTER communicate the synchronization to tsan
+and prevent the race report.
+
+If the compiler does not support __has_feature macro, then you can build with
+CFLAGS="-fsanitize=thread -DTHREAD_SANITIZER" and then use
+#ifdef THREAD_SANITIZER to enabled annotations.
+*/
+
+#if defined(__has_feature) && __has_feature(thread_sanitizer)
+# define ANNOTATE_HAPPENS_BEFORE(addr) \
+    AnnotateHappensBefore(__FILE__, __LINE__, (void*)(addr))
+# define ANNOTATE_HAPPENS_AFTER(addr) \
+    AnnotateHappensAfter(__FILE__, __LINE__, (void*)(addr))
+extern "C" void AnnotateHappensBefore(const char *f, int l, void *addr);
+extern "C" void AnnotateHappensAfter(const char *f, int l, void *addr);
+#else
+# define ANNOTATE_HAPPENS_BEFORE(addr)
+# define ANNOTATE_HAPPENS_AFTER(addr)
+#endif
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  ANNOTATE_HAPPENS_AFTER(&barrier);
+  Global++;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global--;
+  ANNOTATE_HAPPENS_BEFORE(&barrier);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/atexit.cc b/compiler-rt/test/tsan/atexit.cc
new file mode 100644
index 0000000..69acb4d
--- /dev/null
+++ b/compiler-rt/test/tsan/atexit.cc
@@ -0,0 +1,29 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+class Logger {
+ public:
+  Logger() {
+    fprintf(stderr, "Logger ctor\n");
+  }
+
+  ~Logger() {
+    fprintf(stderr, "Logger dtor\n");
+  }
+};
+
+Logger logger;
+
+void log_from_atexit() {
+  fprintf(stderr, "In log_from_atexit\n");
+}
+
+int main() {
+  atexit(log_from_atexit);
+}
+
+// CHECK: Logger ctor
+// CHECK: In log_from_atexit
+// CHECK: Logger dtor
diff --git a/compiler-rt/test/tsan/atexit2.cc b/compiler-rt/test/tsan/atexit2.cc
new file mode 100644
index 0000000..6f74c5f
--- /dev/null
+++ b/compiler-rt/test/tsan/atexit2.cc
@@ -0,0 +1,26 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int n;
+const int N = 10000;
+
+static void atexit1() {
+  n++;
+}
+
+static void atexit0() {
+  fprintf(stderr, "run count: %d\n", n);
+}
+
+int main() {
+  atexit(atexit0);
+  for (int i = 0; i < N; i++)
+    atexit(atexit1);
+}
+
+// CHECK-NOT: FATAL: ThreadSanitizer
+// CHECK-NOT: WARNING: ThreadSanitizer
+// CHECK: run count: 10000
+
diff --git a/compiler-rt/test/tsan/atomic_free.cc b/compiler-rt/test/tsan/atomic_free.cc
new file mode 100644
index 0000000..a0d8e42
--- /dev/null
+++ b/compiler-rt/test/tsan/atomic_free.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread(void *a) {
+  __atomic_fetch_add((int*)a, 1, __ATOMIC_SEQ_CST);
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int *a = new int(0);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, a);
+  barrier_wait(&barrier);
+  delete a;
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/atomic_free2.cc b/compiler-rt/test/tsan/atomic_free2.cc
new file mode 100644
index 0000000..4a9f268
--- /dev/null
+++ b/compiler-rt/test/tsan/atomic_free2.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  __atomic_fetch_add((int*)a, 1, __ATOMIC_SEQ_CST);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int *a = new int(0);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, a);
+  delete a;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: heap-use-after-free
diff --git a/compiler-rt/test/tsan/atomic_free3.cc b/compiler-rt/test/tsan/atomic_free3.cc
new file mode 100644
index 0000000..f2875ae
--- /dev/null
+++ b/compiler-rt/test/tsan/atomic_free3.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+// Test for https://github.com/google/sanitizers/issues/602
+
+void *Thread(void *a) {
+  __atomic_store_n((int*)a, 1, __ATOMIC_RELAXED);
+  return 0;
+}
+
+int main() {
+  int *a = new int(0);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, a);
+  while (__atomic_load_n(a, __ATOMIC_RELAXED) == 0)
+    sched_yield();
+  delete a;
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write
+// CHECK:     #0 operator delete
+// CHECK:     #1 main
+
+// CHECK:   Previous atomic write
+// CHECK:     #0 __tsan_atomic32_store
+// CHECK:     #1 Thread
diff --git a/compiler-rt/test/tsan/atomic_norace.cc b/compiler-rt/test/tsan/atomic_norace.cc
new file mode 100644
index 0000000..625109b
--- /dev/null
+++ b/compiler-rt/test/tsan/atomic_norace.cc
@@ -0,0 +1,62 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+const int kTestCount = 4;
+typedef long long T;
+T atomics[kTestCount * 2];
+
+void Test(int test, T *p, bool main_thread) {
+  volatile T sink;
+  if (test == 0) {
+    if (main_thread)
+      __atomic_fetch_add(p, 1, __ATOMIC_RELAXED);
+    else
+      __atomic_fetch_add(p, 1, __ATOMIC_RELAXED);
+  } else if (test == 1) {
+    if (main_thread)
+      __atomic_exchange_n(p, 1, __ATOMIC_ACQ_REL);
+    else
+      __atomic_exchange_n(p, 1, __ATOMIC_ACQ_REL);
+  } else if (test == 2) {
+    if (main_thread)
+      sink = __atomic_load_n(p, __ATOMIC_SEQ_CST);
+    else
+      __atomic_store_n(p, 1, __ATOMIC_SEQ_CST);
+  } else if (test == 3) {
+    if (main_thread)
+      sink = __atomic_load_n(p, __ATOMIC_SEQ_CST);
+    else
+      sink = *p;
+  }
+}
+
+void *Thread(void *p) {
+  for (int i = 0; i < kTestCount; i++) {
+    Test(i, &atomics[i], false);
+  }
+  barrier_wait(&barrier);
+  barrier_wait(&barrier);
+  for (int i = 0; i < kTestCount; i++) {
+    fprintf(stderr, "Test %d reverse\n", i);
+    Test(i, &atomics[kTestCount + i], false);
+  }
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  for (int i = 0; i < kTestCount; i++) {
+    fprintf(stderr, "Test %d\n", i);
+    Test(i, &atomics[i], true);
+  }
+  for (int i = 0; i < kTestCount; i++) {
+    Test(i, &atomics[kTestCount + i], true);
+  }
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK-NOT: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/atomic_race.cc b/compiler-rt/test/tsan/atomic_race.cc
new file mode 100644
index 0000000..5a0317c
--- /dev/null
+++ b/compiler-rt/test/tsan/atomic_race.cc
@@ -0,0 +1,81 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+const int kTestCount = 4;
+typedef long long T;
+T atomics[kTestCount * 2];
+
+void Test(int test, T *p, bool main_thread) {
+  volatile T sink;
+  if (test == 0) {
+    if (main_thread)
+      __atomic_fetch_add(p, 1, __ATOMIC_RELAXED);
+    else
+      *p = 42;
+  } else if (test == 1) {
+    if (main_thread)
+      __atomic_fetch_add(p, 1, __ATOMIC_RELAXED);
+    else
+      sink = *p;
+  } else if (test == 2) {
+    if (main_thread)
+      sink = __atomic_load_n(p, __ATOMIC_SEQ_CST);
+    else
+      *p = 42;
+  } else if (test == 3) {
+    if (main_thread)
+      __atomic_store_n(p, 1, __ATOMIC_SEQ_CST);
+    else
+      sink = *p;
+  }
+}
+
+void *Thread(void *p) {
+  for (int i = 0; i < kTestCount; i++) {
+    Test(i, &atomics[i], false);
+  }
+  barrier_wait(&barrier);
+  barrier_wait(&barrier);
+  for (int i = 0; i < kTestCount; i++) {
+    fprintf(stderr, "Test %d reverse\n", i);
+    Test(i, &atomics[kTestCount + i], false);
+  }
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  for (int i = 0; i < kTestCount; i++) {
+    fprintf(stderr, "Test %d\n", i);
+    Test(i, &atomics[i], true);
+  }
+  for (int i = 0; i < kTestCount; i++) {
+    Test(i, &atomics[kTestCount + i], true);
+  }
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: Test 0
+// CHECK: ThreadSanitizer: data race
+// CHECK-NOT: SUMMARY{{.*}}tsan_interface_atomic
+// CHECK: Test 1
+// CHECK: ThreadSanitizer: data race
+// CHECK-NOT: SUMMARY{{.*}}tsan_interface_atomic
+// CHECK: Test 2
+// CHECK: ThreadSanitizer: data race
+// CHECK-NOT: SUMMARY{{.*}}tsan_interface_atomic
+// CHECK: Test 3
+// CHECK: ThreadSanitizer: data race
+// CHECK-NOT: SUMMARY{{.*}}tsan_interface_atomic
+// CHECK: Test 0 reverse
+// CHECK: ThreadSanitizer: data race
+// CHECK: Test 1 reverse
+// CHECK: ThreadSanitizer: data race
+// CHECK: Test 2 reverse
+// CHECK: ThreadSanitizer: data race
+// CHECK: Test 3 reverse
+// CHECK: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/atomic_stack.cc b/compiler-rt/test/tsan/atomic_stack.cc
new file mode 100644
index 0000000..979eaea
--- /dev/null
+++ b/compiler-rt/test/tsan/atomic_stack.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  __atomic_fetch_add(&Global, 1, __ATOMIC_RELAXED);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global++;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Atomic write of size 4
+// CHECK:     #0 __tsan_atomic32_fetch_add
+// CHECK:     #1 Thread1
diff --git a/compiler-rt/test/tsan/barrier.cc b/compiler-rt/test/tsan/barrier.cc
new file mode 100644
index 0000000..de2756d
--- /dev/null
+++ b/compiler-rt/test/tsan/barrier.cc
@@ -0,0 +1,40 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// CHECK-NOT: ThreadSanitizer: data race
+// CHECK: DONE
+
+// pthread barriers are not available on OS X
+// UNSUPPORTED: darwin
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+
+const int kSize = 4;
+volatile int kIter = 10;  // prevent unwinding
+int data[2][kSize];
+pthread_barrier_t barrier;
+
+void *thr(void *p) {
+  int idx = (int)(long)p;
+  for (int i = 0; i < kIter; i++) {
+    int *prev = data[i % 2];
+    int *curr = data[(i + 1) % 2];
+    int left = idx - 1 >= 0 ? prev[idx - 1] : 0;
+    int right = idx + 1 < kSize ? prev[idx + 1] : 0;
+    curr[idx] = (left + right) / 2;
+    pthread_barrier_wait(&barrier);
+  }
+  return 0;
+}
+
+int main() {
+  pthread_barrier_init(&barrier, 0, kSize);
+  pthread_t th[kSize];
+  for (int i = 0; i < kSize; i++)
+    pthread_create(&th[i], 0, thr, (void*)(long)i);
+  for (int i = 0; i < kSize; i++)
+    pthread_join(th[i], 0);
+  pthread_barrier_destroy(&barrier);
+  fprintf(stderr, "DONE\n");
+}
diff --git a/compiler-rt/test/tsan/bench.h b/compiler-rt/test/tsan/bench.h
new file mode 100644
index 0000000..5ae0dd8
--- /dev/null
+++ b/compiler-rt/test/tsan/bench.h
@@ -0,0 +1,59 @@
+#include <pthread.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+
+int bench_nthread;
+int bench_niter;
+int grow_clock_var;
+pthread_barrier_t glow_clock_barrier;
+
+void bench();  // defined by user
+void start_thread_group(int nth, void(*f)(int tid));
+void grow_clock_worker(int tid);
+
+int main(int argc, char **argv) {
+  bench_nthread = 2;
+  if (argc > 1)
+    bench_nthread = atoi(argv[1]);
+  bench_niter = 100;
+  if (argc > 2)
+    bench_niter = atoi(argv[2]);
+
+  // Grow thread's clock.
+  int clock_size = 10;
+  if (argc > 1)
+    clock_size = 1000;
+  pthread_barrier_init(&glow_clock_barrier, 0, clock_size);
+  start_thread_group(clock_size, grow_clock_worker);
+  pthread_barrier_destroy(&glow_clock_barrier);
+  __atomic_load_n(&grow_clock_var, __ATOMIC_ACQUIRE);
+
+  timespec tp0;
+  clock_gettime(CLOCK_MONOTONIC, &tp0);
+  bench();
+  timespec tp1;
+  clock_gettime(CLOCK_MONOTONIC, &tp1);
+  unsigned long long t =
+      (tp1.tv_sec * 1000000000ULL + tp1.tv_nsec) -
+      (tp0.tv_sec * 1000000000ULL + tp0.tv_nsec);
+  fprintf(stderr, "%llu ns/iter\n", t / bench_niter);
+  fprintf(stderr, "DONE\n");
+}
+
+void start_thread_group(int nth, void(*f)(int tid)) {
+  pthread_t *th = (pthread_t*)malloc(nth * sizeof(pthread_t));
+  for (int i = 0; i < nth; i++)
+    pthread_create(&th[i], 0, (void*(*)(void*))f, (void*)(long)i);
+  for (int i = 0; i < nth; i++)
+    pthread_join(th[i], 0);
+}
+
+void grow_clock_worker(int tid) {
+  int res = pthread_barrier_wait(&glow_clock_barrier);
+  if (res == PTHREAD_BARRIER_SERIAL_THREAD)
+    __atomic_store_n(&grow_clock_var, 0, __ATOMIC_RELEASE);
+}
+
diff --git a/compiler-rt/test/tsan/bench_acquire_only.cc b/compiler-rt/test/tsan/bench_acquire_only.cc
new file mode 100644
index 0000000..0ed21b4
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_acquire_only.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+int x;
+
+void thread(int tid) {
+  for (int i = 0; i < bench_niter; i++)
+    __atomic_load_n(&x, __ATOMIC_ACQUIRE);
+}
+
+void bench() {
+  __atomic_store_n(&x, 0, __ATOMIC_RELEASE);
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_acquire_release.cc b/compiler-rt/test/tsan/bench_acquire_release.cc
new file mode 100644
index 0000000..3799452
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_acquire_release.cc
@@ -0,0 +1,21 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+int x;
+
+void thread(int tid) {
+  for (int i = 0; i < bench_niter; i++)
+    __atomic_fetch_add(&x, 1, __ATOMIC_ACQ_REL);
+}
+
+void bench() {
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_local_mutex.cc b/compiler-rt/test/tsan/bench_local_mutex.cc
new file mode 100644
index 0000000..15f83bc
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_local_mutex.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+pthread_mutex_t *mtx;
+const int kStride = 16;
+
+void thread(int tid) {
+  for (int i = 0; i < bench_niter; i++) {
+    pthread_mutex_lock(&mtx[tid * kStride]);
+    pthread_mutex_unlock(&mtx[tid * kStride]);
+  }
+}
+
+void bench() {
+  mtx = (pthread_mutex_t*)malloc(bench_nthread * kStride * sizeof(*mtx));
+  for (int i = 0; i < bench_nthread; i++) {
+    pthread_mutex_init(&mtx[i * kStride], 0);
+    pthread_mutex_lock(&mtx[i * kStride]);
+    pthread_mutex_unlock(&mtx[i * kStride]);
+  }
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_mutex.cc b/compiler-rt/test/tsan/bench_mutex.cc
new file mode 100644
index 0000000..58aa86a
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_mutex.cc
@@ -0,0 +1,31 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+pthread_mutex_t mtx;
+pthread_cond_t cv;
+int x;
+
+void thread(int tid) {
+  for (int i = 0; i < bench_niter; i++) {
+    pthread_mutex_lock(&mtx);
+    while (x != i * 2 + tid)
+      pthread_cond_wait(&cv, &mtx);
+    x++;
+    pthread_cond_signal(&cv);
+    pthread_mutex_unlock(&mtx);
+  }
+}
+
+void bench() {
+  pthread_mutex_init(&mtx, 0);
+  pthread_cond_init(&cv, 0);
+  start_thread_group(2, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_release_only.cc b/compiler-rt/test/tsan/bench_release_only.cc
new file mode 100644
index 0000000..7f26041
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_release_only.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+int *x;
+const int kStride = 32;
+
+void thread(int tid) {
+  __atomic_load_n(&x[tid * kStride], __ATOMIC_ACQUIRE);
+  for (int i = 0; i < bench_niter; i++)
+    __atomic_store_n(&x[tid * kStride], 0, __ATOMIC_RELEASE);
+}
+
+void bench() {
+  x = (int*)malloc(bench_nthread * kStride * sizeof(x[0]));
+  for (int i = 0; i < bench_nthread; i++)
+    __atomic_store_n(&x[i * kStride], 0, __ATOMIC_RELEASE);
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_rwmutex.cc b/compiler-rt/test/tsan/bench_rwmutex.cc
new file mode 100644
index 0000000..2b3dcb0
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_rwmutex.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+pthread_rwlock_t mtx;
+
+void thread(int tid) {
+  for (int i = 0; i < bench_niter; i++) {
+    pthread_rwlock_rdlock(&mtx);
+    pthread_rwlock_unlock(&mtx);
+  }
+}
+
+void bench() {
+  pthread_rwlock_init(&mtx, 0);
+  pthread_rwlock_wrlock(&mtx);
+  pthread_rwlock_unlock(&mtx);
+  pthread_rwlock_rdlock(&mtx);
+  pthread_rwlock_unlock(&mtx);
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_shadow_flush.cc b/compiler-rt/test/tsan/bench_shadow_flush.cc
new file mode 100644
index 0000000..0f412bb
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_shadow_flush.cc
@@ -0,0 +1,48 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+#include <sys/mman.h>
+
+const long kSmallPage = 4 << 10;
+const long kLargePage = 2 << 20;
+const long kStride    = 1 << 10;
+
+typedef unsigned long uptr;
+
+int main(int argc, const char **argv) {
+  uptr mem_size = 4 << 20;
+  if (argc > 1)
+    mem_size = (uptr)atoi(argv[1]) << 20;
+  uptr stride = kSmallPage;
+  if (argc > 2)
+    stride = (uptr)atoi(argv[2]) << 10;
+  int niter = 1;
+  if (argc > 3)
+    niter = atoi(argv[3]);
+  int stride2 = 1;
+  if (argc > 4)
+    stride2 = atoi(argv[4]);
+
+  uptr sz = mem_size + stride2 * kStride + kLargePage;
+  void *p = mmap(0, sz, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+  uptr a = ((uptr)p + kLargePage - 1) & ~(kLargePage - 1);
+  volatile char *mem = (volatile char *)a;
+
+  for (int i = 0; i < niter; i++) {
+    for (uptr off = 0; off < mem_size; off += stride) {
+      for (uptr off2 = 0; off2 < stride2; off2++)
+        mem[off + off2 * kStride] = 42;
+    }
+  }
+
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_single_writer.cc b/compiler-rt/test/tsan/bench_single_writer.cc
new file mode 100644
index 0000000..3d2ea15
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_single_writer.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+int x;
+
+void thread(int tid) {
+  if (tid == 0) {
+    for (int i = 0; i < bench_niter; i++)
+      __atomic_store_n(&x, 0, __ATOMIC_RELEASE);
+  } else {
+    for (int i = 0; i < bench_niter; i++)
+      __atomic_load_n(&x, __ATOMIC_ACQUIRE);
+  }
+}
+
+void bench() {
+  start_thread_group(bench_nthread, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/bench_ten_mutexes.cc b/compiler-rt/test/tsan/bench_ten_mutexes.cc
new file mode 100644
index 0000000..e7fa05e
--- /dev/null
+++ b/compiler-rt/test/tsan/bench_ten_mutexes.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// bench.h needs pthread barriers which are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "bench.h"
+
+const int kMutex = 10;
+pthread_mutex_t mtx[kMutex];
+
+void thread(int tid) {
+  for (int i = 0; i < bench_niter; i++) {
+    int idx = (i % kMutex);
+    if (tid == 0)
+      idx = kMutex - idx - 1;
+    pthread_mutex_lock(&mtx[idx]);
+    pthread_mutex_unlock(&mtx[idx]);
+  }
+}
+
+void bench() {
+  for (int i = 0; i < kMutex; i++)
+    pthread_mutex_init(&mtx[i], 0);
+  start_thread_group(2, thread);
+}
+
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/benign_race.cc b/compiler-rt/test/tsan/benign_race.cc
new file mode 100644
index 0000000..2f72fe1
--- /dev/null
+++ b/compiler-rt/test/tsan/benign_race.cc
@@ -0,0 +1,39 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+int WTFGlobal;
+
+extern "C" {
+void AnnotateBenignRaceSized(const char *f, int l,
+                             void *mem, unsigned int size, const char *desc);
+void WTFAnnotateBenignRaceSized(const char *f, int l,
+                                void *mem, unsigned int size,
+                                const char *desc);
+}
+
+
+void *Thread(void *x) {
+  Global = 42;
+  WTFGlobal = 142;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  AnnotateBenignRaceSized(__FILE__, __LINE__,
+                          &Global, sizeof(Global), "Race on Global");
+  WTFAnnotateBenignRaceSized(__FILE__, __LINE__,
+                             &WTFGlobal, sizeof(WTFGlobal),
+                             "Race on WTFGlobal");
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  Global = 43;
+  WTFGlobal = 143;
+  pthread_join(t, 0);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/blacklist.cc b/compiler-rt/test/tsan/blacklist.cc
new file mode 100644
index 0000000..d6ca383
--- /dev/null
+++ b/compiler-rt/test/tsan/blacklist.cc
@@ -0,0 +1,30 @@
+// Test blacklist functionality for TSan.
+
+// RUN: echo "fun:*Blacklisted_Thread2*" > %t.blacklist
+// RUN: %clangxx_tsan -O1 %s -fsanitize-blacklist=%t.blacklist -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+int Global;
+
+void *Thread1(void *x) {
+  Global++;
+  return NULL;
+}
+
+void *Blacklisted_Thread2(void *x) {
+  Global--;
+  return NULL;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Blacklisted_Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK-NOT: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/blacklist2.cc b/compiler-rt/test/tsan/blacklist2.cc
new file mode 100644
index 0000000..629b588
--- /dev/null
+++ b/compiler-rt/test/tsan/blacklist2.cc
@@ -0,0 +1,49 @@
+// Test that blacklisted functions are still contained in the stack trace.
+
+// RUN: echo "fun:*Blacklisted_Thread2*" > %t.blacklist
+// RUN: echo "fun:*CallTouchGlobal*" >> %t.blacklist
+
+// RUN: %clangxx_tsan -O1 %s -fsanitize-blacklist=%t.blacklist -o %t
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  // CHECK: ThreadSanitizer: data race
+  // CHECK: Write of size 4
+  // CHECK: #0 Thread1{{.*}}blacklist2.cc:[[@LINE+1]]
+  Global++;
+  return NULL;
+}
+
+void TouchGlobal() {
+  // CHECK: Previous write of size 4
+  // CHECK: #0 TouchGlobal{{.*}}blacklist2.cc:[[@LINE+1]]
+  Global--;
+}
+
+void CallTouchGlobal() {
+  // CHECK: #1 CallTouchGlobal{{.*}}blacklist2.cc:[[@LINE+1]]
+  TouchGlobal();
+}
+
+void *Blacklisted_Thread2(void *x) {
+  Global--;
+  // CHECK: #2 Blacklisted_Thread2{{.*}}blacklist2.cc:[[@LINE+1]]
+  CallTouchGlobal();
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Blacklisted_Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("PASS\n");
+  return 0;
+}
diff --git a/compiler-rt/test/tsan/cond.c b/compiler-rt/test/tsan/cond.c
new file mode 100644
index 0000000..05ea672
--- /dev/null
+++ b/compiler-rt/test/tsan/cond.c
@@ -0,0 +1,53 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: ThreadSanitizer WARNING: double lock
+// CHECK-NOT: ThreadSanitizer WARNING: mutex unlock by another thread
+// CHECK: OK
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+pthread_mutex_t m;
+pthread_cond_t c;
+int x;
+
+void *thr1(void *p) {
+  int i;
+
+  for (i = 0; i < 10; i += 2) {
+    pthread_mutex_lock(&m);
+    while (x != i)
+      pthread_cond_wait(&c, &m);
+    x = i + 1;
+    pthread_cond_signal(&c);
+    pthread_mutex_unlock(&m);
+  }
+  return 0;
+}
+
+void *thr2(void *p) {
+  int i;
+
+  for (i = 1; i < 10; i += 2) {
+    pthread_mutex_lock(&m);
+    while (x != i)
+      pthread_cond_wait(&c, &m);
+    x = i + 1;
+    pthread_mutex_unlock(&m);
+    pthread_cond_broadcast(&c);
+  }
+  return 0;
+}
+
+int main() {
+  pthread_t th1, th2;
+
+  pthread_mutex_init(&m, 0);
+  pthread_cond_init(&c, 0);
+  pthread_create(&th1, 0, thr1, 0);
+  pthread_create(&th2, 0, thr2, 0);
+  pthread_join(th1, 0);
+  pthread_join(th2, 0);
+  fprintf(stderr, "OK\n");
+}
diff --git a/compiler-rt/test/tsan/cond_cancel.c b/compiler-rt/test/tsan/cond_cancel.c
new file mode 100644
index 0000000..fb6a661
--- /dev/null
+++ b/compiler-rt/test/tsan/cond_cancel.c
@@ -0,0 +1,51 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// CHECK-NOT: WARNING
+// CHECK: OK
+// This test is failing on powerpc64 (VMA=44). After calling pthread_cancel,
+// the Thread-specific data destructors are not called, so the destructor 
+// "thread_finalize" (defined in tsan_interceptors.cc) can not set the status
+// of the thread to "ThreadStatusFinished" failing a check in "SetJoined" 
+// (defined in sanitizer_thread_registry.cc). It might seem a bug on glibc,
+// however the same version GLIBC-2.17 will not make fail the test on 
+// powerpc64 BE (VMA=46)
+// XFAIL: powerpc64-unknown-linux-gnu
+
+#include "test.h"
+
+pthread_mutex_t m;
+pthread_cond_t c;
+int x;
+
+static void my_cleanup(void *arg) {
+  printf("my_cleanup\n");
+  pthread_mutex_unlock((pthread_mutex_t*)arg);
+}
+
+void *thr1(void *p) {
+  pthread_mutex_lock(&m);
+  pthread_cleanup_push(my_cleanup, &m);
+  barrier_wait(&barrier);
+  while (x == 0)
+    pthread_cond_wait(&c, &m);
+  pthread_cleanup_pop(1);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+
+  pthread_t th;
+
+  pthread_mutex_init(&m, 0);
+  pthread_cond_init(&c, 0);
+
+  pthread_create(&th, 0, thr1, 0);
+  barrier_wait(&barrier);
+  sleep(1);  // let it block on cond var
+  pthread_cancel(th);
+
+  pthread_join(th, 0);
+  pthread_mutex_lock(&m);
+  pthread_mutex_unlock(&m);
+  fprintf(stderr, "OK\n");
+}
diff --git a/compiler-rt/test/tsan/cond_destruction.cc b/compiler-rt/test/tsan/cond_destruction.cc
new file mode 100644
index 0000000..f56b30c
--- /dev/null
+++ b/compiler-rt/test/tsan/cond_destruction.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+// RUN: %run %t arg 2>&1 | FileCheck %s
+// RUN: %run %t arg arg 2>&1 | FileCheck %s
+#include "test.h"
+
+// Test for destruction of pthread_cond_t.
+// POSIX states that it is safe  to destroy a condition variable upon which no
+// threads are currently blocked. That is, it is not necessary to wait untill
+// other threads return from pthread_cond_wait, they just need to be unblocked.
+
+pthread_mutex_t m;
+pthread_cond_t c;
+bool done1, done2;
+
+void *thr(void *p) {
+  pthread_mutex_lock(&m);
+  done1 = true;
+  pthread_cond_signal(&c);
+  while (!done2)
+    pthread_cond_wait(&c, &m);
+  pthread_mutex_unlock(&m);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  pthread_t th;
+  pthread_mutex_init(&m, 0);
+  pthread_cond_init(&c, 0);
+  pthread_create(&th, 0, thr, 0);
+  pthread_mutex_lock(&m);
+  while (!done1)
+    pthread_cond_wait(&c, &m);
+  done2 = true;
+  // Any of these sequences is legal.
+  if (argc == 1) {
+    pthread_cond_signal(&c);
+    pthread_mutex_unlock(&m);
+    pthread_cond_destroy(&c);
+  } else if (argc == 2) {
+    pthread_mutex_unlock(&m);
+    pthread_cond_signal(&c);
+    pthread_cond_destroy(&c);
+  } else {
+    pthread_cond_signal(&c);
+    pthread_cond_destroy(&c);
+    pthread_mutex_unlock(&m);
+  }
+  pthread_join(th, 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK-NOT: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/cond_race.cc b/compiler-rt/test/tsan/cond_race.cc
new file mode 100644
index 0000000..4daf37f
--- /dev/null
+++ b/compiler-rt/test/tsan/cond_race.cc
@@ -0,0 +1,39 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+// CHECK-NOT: unlock of unlocked mutex
+// CHECK: ThreadSanitizer: data race
+// CHECK: pthread_cond_signal
+
+#include "test.h"
+
+struct Ctx {
+  pthread_mutex_t m;
+  pthread_cond_t c;
+  bool done;
+};
+
+void *thr(void *p) {
+  Ctx *c = (Ctx*)p;
+  pthread_mutex_lock(&c->m);
+  c->done = true;
+  pthread_mutex_unlock(&c->m);
+  pthread_cond_signal(&c->c);
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  Ctx *c = new Ctx();
+  pthread_mutex_init(&c->m, 0);
+  pthread_cond_init(&c->c, 0);
+  pthread_t th;
+  pthread_create(&th, 0, thr, c);
+  pthread_mutex_lock(&c->m);
+  while (!c->done)
+    pthread_cond_wait(&c->c, &c->m);
+  pthread_mutex_unlock(&c->m);
+  // otherwise it can be reported as use-after-free
+  barrier_wait(&barrier);
+  delete c;
+  pthread_join(th, 0);
+}
diff --git a/compiler-rt/test/tsan/cond_version.c b/compiler-rt/test/tsan/cond_version.c
new file mode 100644
index 0000000..6bae776
--- /dev/null
+++ b/compiler-rt/test/tsan/cond_version.c
@@ -0,0 +1,47 @@
+// RUN: %clang_tsan -O1 %s -o %t -lrt && %run %t 2>&1 | FileCheck %s
+// Test that pthread_cond is properly intercepted,
+// previously there were issues with versioned symbols.
+// CHECK: OK
+
+// OS X doesn't have pthread_condattr_setclock.
+// UNSUPPORTED: darwin
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <time.h>
+#include <errno.h>
+
+int main() {
+  typedef unsigned long long u64;
+  pthread_mutex_t m;
+  pthread_cond_t c;
+  pthread_condattr_t at;
+  struct timespec ts0, ts1, ts2;
+  int res;
+  u64 sleep;
+
+  pthread_mutex_init(&m, 0);
+  pthread_condattr_init(&at);
+  pthread_condattr_setclock(&at, CLOCK_MONOTONIC);
+  pthread_cond_init(&c, &at);
+
+  clock_gettime(CLOCK_MONOTONIC, &ts0);
+  ts1 = ts0;
+  ts1.tv_sec += 2;
+
+  pthread_mutex_lock(&m);
+  do {
+    res = pthread_cond_timedwait(&c, &m, &ts1);
+  } while (res == 0);
+  pthread_mutex_unlock(&m);
+
+  clock_gettime(CLOCK_MONOTONIC, &ts2);
+  sleep = (u64)ts2.tv_sec * 1000000000 + ts2.tv_nsec -
+      ((u64)ts0.tv_sec * 1000000000 + ts0.tv_nsec);
+  if (res != ETIMEDOUT)
+    exit(printf("bad return value %d, want %d\n", res, ETIMEDOUT));
+  if (sleep < 1000000000)
+    exit(printf("bad sleep duration %lluns, want %dns\n", sleep, 1000000000));
+  fprintf(stderr, "OK\n");
+}
diff --git a/compiler-rt/test/tsan/deadlock_detector_stress_test.cc b/compiler-rt/test/tsan/deadlock_detector_stress_test.cc
new file mode 100644
index 0000000..bbaaabb
--- /dev/null
+++ b/compiler-rt/test/tsan/deadlock_detector_stress_test.cc
@@ -0,0 +1,625 @@
+// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadMutex
+// RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOT-SECOND
+// RUN: %env_tsan_opts=detect_deadlocks=1:second_deadlock_stack=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SECOND
+// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadSpinLock
+// RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s
+// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRWLock
+// RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RD
+// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRecursiveMutex
+// RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-REC
+#include "test.h"
+#undef NDEBUG
+#include <assert.h>
+#include <new>
+
+#ifndef LockType
+#define LockType PthreadMutex
+#endif
+
+// You can optionally pass [test_number [iter_count]] on command line.
+static int test_number = -1;
+static int iter_count = 100000;
+
+class PthreadMutex {
+ public:
+  explicit PthreadMutex(bool recursive = false) {
+    if (recursive) {
+      pthread_mutexattr_t attr;
+      pthread_mutexattr_init(&attr);
+      pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+      assert(0 == pthread_mutex_init(&mu_, &attr));
+    } else {
+      assert(0 == pthread_mutex_init(&mu_, 0));
+    }
+  }
+  ~PthreadMutex() {
+    assert(0 == pthread_mutex_destroy(&mu_));
+    (void)padding_;
+  }
+  static bool supports_read_lock() { return false; }
+  static bool supports_recursive_lock() { return false; }
+  void lock() { assert(0 == pthread_mutex_lock(&mu_)); }
+  void unlock() { assert(0 == pthread_mutex_unlock(&mu_)); }
+  bool try_lock() { return 0 == pthread_mutex_trylock(&mu_); }
+  void rdlock() { assert(0); }
+  void rdunlock() { assert(0); }
+  bool try_rdlock() { assert(0); }
+
+ private:
+  pthread_mutex_t mu_;
+  char padding_[64 - sizeof(pthread_mutex_t)];
+};
+
+class PthreadRecursiveMutex : public PthreadMutex {
+ public:
+  PthreadRecursiveMutex() : PthreadMutex(true) { }
+  static bool supports_recursive_lock() { return true; }
+};
+
+#ifndef __APPLE__
+class PthreadSpinLock {
+ public:
+  PthreadSpinLock() { assert(0 == pthread_spin_init(&mu_, 0)); }
+  ~PthreadSpinLock() {
+    assert(0 == pthread_spin_destroy(&mu_));
+    (void)padding_;
+  }
+  static bool supports_read_lock() { return false; }
+  static bool supports_recursive_lock() { return false; }
+  void lock() { assert(0 == pthread_spin_lock(&mu_)); }
+  void unlock() { assert(0 == pthread_spin_unlock(&mu_)); }
+  bool try_lock() { return 0 == pthread_spin_trylock(&mu_); }
+  void rdlock() { assert(0); }
+  void rdunlock() { assert(0); }
+  bool try_rdlock() { assert(0); }
+
+ private:
+  pthread_spinlock_t mu_;
+  char padding_[64 - sizeof(pthread_spinlock_t)];
+};
+#else
+class PthreadSpinLock : public PthreadMutex { };
+#endif
+
+class PthreadRWLock {
+ public:
+  PthreadRWLock() { assert(0 == pthread_rwlock_init(&mu_, 0)); }
+  ~PthreadRWLock() {
+    assert(0 == pthread_rwlock_destroy(&mu_));
+    (void)padding_;
+  }
+  static bool supports_read_lock() { return true; }
+  static bool supports_recursive_lock() { return false; }
+  void lock() { assert(0 == pthread_rwlock_wrlock(&mu_)); }
+  void unlock() { assert(0 == pthread_rwlock_unlock(&mu_)); }
+  bool try_lock() { return 0 == pthread_rwlock_trywrlock(&mu_); }
+  void rdlock() { assert(0 == pthread_rwlock_rdlock(&mu_)); }
+  void rdunlock() { assert(0 == pthread_rwlock_unlock(&mu_)); }
+  bool try_rdlock() { return 0 == pthread_rwlock_tryrdlock(&mu_); }
+
+ private:
+  pthread_rwlock_t mu_;
+  char padding_[256 - sizeof(pthread_rwlock_t)];
+};
+
+class LockTest {
+ public:
+  LockTest() : n_(), locks_() {}
+  void Init(size_t n) {
+    n_ = n;
+    locks_ = new LockType*[n_];
+    for (size_t i = 0; i < n_; i++)
+      locks_[i] = new LockType;
+  }
+  ~LockTest() {
+    for (size_t i = 0; i < n_; i++)
+      delete locks_[i];
+    delete [] locks_;
+  }
+  void L(size_t i) {
+    assert(i < n_);
+    locks_[i]->lock();
+  }
+
+  void U(size_t i) {
+    assert(i < n_);
+    locks_[i]->unlock();
+  }
+
+  void RL(size_t i) {
+    assert(i < n_);
+    locks_[i]->rdlock();
+  }
+
+  void RU(size_t i) {
+    assert(i < n_);
+    locks_[i]->rdunlock();
+  }
+
+  void *A(size_t i) {
+    assert(i < n_);
+    return locks_[i];
+  }
+
+  bool T(size_t i) {
+    assert(i < n_);
+    return locks_[i]->try_lock();
+  }
+
+  // Simple lock order onversion.
+  void Test1() {
+    if (test_number > 0 && test_number != 1) return;
+    fprintf(stderr, "Starting Test1\n");
+    // CHECK: Starting Test1
+    Init(5);
+    print_address("Expecting lock inversion: ", 2, A(0), A(1));
+    // CHECK: Expecting lock inversion: [[A1:0x[a-f0-9]*]] [[A2:0x[a-f0-9]*]]
+    Lock_0_1();
+    Lock_1_0();
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
+    // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ([[A1]]) => [[M2:M[0-9]+]] ([[A2]]) => [[M1]]
+    // CHECK: Mutex [[M2]] acquired here while holding mutex [[M1]]
+    // CHECK:   #0 pthread_
+    // CHECK-SECOND:   Mutex [[M1]] previously acquired by the same thread here:
+    // CHECK-SECOND:   #0 pthread_
+    // CHECK-NOT-SECOND:   second_deadlock_stack=1 to get more informative warning message
+    // CHECK-NOT-SECOND-NOT:   #0 pthread_
+    // CHECK: Mutex [[M1]] acquired here while holding mutex [[M2]]
+    // CHECK:   #0 pthread_
+    // CHECK-SECOND:   Mutex [[M2]] previously acquired by the same thread here:
+    // CHECK-SECOND:   #0 pthread_
+    // CHECK-NOT-SECOND-NOT:   #0 pthread_
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+  }
+
+  // Simple lock order inversion with 3 locks.
+  void Test2() {
+    if (test_number > 0 && test_number != 2) return;
+    fprintf(stderr, "Starting Test2\n");
+    // CHECK: Starting Test2
+    Init(5);
+    print_address("Expecting lock inversion: ", 3, A(0), A(1), A(2));
+    // CHECK: Expecting lock inversion: [[A1:0x[a-f0-9]*]] [[A2:0x[a-f0-9]*]] [[A3:0x[a-f0-9]*]]
+    Lock2(0, 1);
+    Lock2(1, 2);
+    Lock2(2, 0);
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
+    // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ([[A1]]) => [[M2:M[0-9]+]] ([[A2]]) => [[M3:M[0-9]+]] ([[A3]]) => [[M1]]
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+  }
+
+  // Lock order inversion with lots of new locks created (but not used)
+  // between. Since the new locks are not used we should still detect the
+  // deadlock.
+  void Test3() {
+    if (test_number > 0 && test_number != 3) return;
+    fprintf(stderr, "Starting Test3\n");
+    // CHECK: Starting Test3
+    Init(5);
+    Lock_0_1();
+    L(2);
+    CreateAndDestroyManyLocks();
+    U(2);
+    Lock_1_0();
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+  }
+
+  // lock l0=>l1; then create and use lots of locks; then lock l1=>l0.
+  // The deadlock epoch should have changed and we should not report anything.
+  void Test4() {
+    if (test_number > 0 && test_number != 4) return;
+    fprintf(stderr, "Starting Test4\n");
+    // CHECK: Starting Test4
+    Init(5);
+    Lock_0_1();
+    L(2);
+    CreateLockUnlockAndDestroyManyLocks();
+    U(2);
+    Lock_1_0();
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+  }
+
+  void Test5() {
+    if (test_number > 0 && test_number != 5) return;
+    fprintf(stderr, "Starting Test5\n");
+    // CHECK: Starting Test5
+    Init(5);
+    RunThreads(&LockTest::Lock_0_1<true>, &LockTest::Lock_1_0<true>);
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
+    // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ({{.*}}) => [[M2:M[0-9]+]] ({{.*}}) => [[M1]]
+    // CHECK: Mutex [[M2]] acquired here while holding mutex [[M1]] in thread [[T1:T[0-9]+]]
+    // CHECK: Mutex [[M1]] acquired here while holding mutex [[M2]] in thread [[T2:T[0-9]+]]
+    // CHECK: Thread [[T1]] {{.*}} created by main thread
+    // CHECK: Thread [[T2]] {{.*}} created by main thread
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+  }
+
+  void Test6() {
+    if (test_number > 0 && test_number != 6) return;
+    fprintf(stderr, "Starting Test6: 3 threads lock/unlock private mutexes\n");
+    // CHECK: Starting Test6
+    Init(100);
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+    RunThreads(&LockTest::Lock1_Loop_0, &LockTest::Lock1_Loop_1,
+               &LockTest::Lock1_Loop_2);
+  }
+
+  void Test7() {
+    if (test_number > 0 && test_number != 7) return;
+    fprintf(stderr, "Starting Test7\n");
+    // CHECK: Starting Test7
+    Init(10);
+    L(0); T(1); U(1); U(0);
+    T(1); L(0); U(1); U(0);
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+    fprintf(stderr, "No cycle: 0=>1\n");
+    // CHECK: No cycle: 0=>1
+
+    T(2); L(3); U(3); U(2);
+    L(3); T(2); U(3); U(2);
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+    fprintf(stderr, "No cycle: 2=>3\n");
+    // CHECK: No cycle: 2=>3
+
+    T(4); L(5); U(4); U(5);
+    L(5); L(4); U(4); U(5);
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
+    fprintf(stderr, "Have cycle: 4=>5\n");
+    // CHECK: Have cycle: 4=>5
+
+    L(7); L(6); U(6); U(7);
+    T(6); L(7); U(6); U(7);
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
+    fprintf(stderr, "Have cycle: 6=>7\n");
+    // CHECK: Have cycle: 6=>7
+  }
+
+  void Test8() {
+    if (test_number > 0 && test_number != 8) return;
+    if (!LockType::supports_read_lock()) return;
+    fprintf(stderr, "Starting Test8\n");
+    Init(5);
+    // CHECK-RD: Starting Test8
+    RL(0); L(1); RU(0); U(1);
+    L(1); RL(0); RU(0); U(1);
+    // CHECK-RD: WARNING: ThreadSanitizer: lock-order-inversion
+    fprintf(stderr, "Have cycle: 0=>1\n");
+    // CHECK-RD: Have cycle: 0=>1
+
+    RL(2); RL(3); RU(2); RU(3);
+    RL(3); RL(2); RU(2); RU(3);
+    // CHECK-RD: WARNING: ThreadSanitizer: lock-order-inversion
+    fprintf(stderr, "Have cycle: 2=>3\n");
+    // CHECK-RD: Have cycle: 2=>3
+  }
+
+  void Test9() {
+    if (test_number > 0 && test_number != 9) return;
+    if (!LockType::supports_recursive_lock()) return;
+    fprintf(stderr, "Starting Test9\n");
+    // CHECK-REC: Starting Test9
+    Init(5);
+    L(0); L(0); L(0); L(1); U(1); U(0); U(0); U(0);
+    L(1); L(1); L(1); L(0); U(0); U(1); U(1); U(1);
+    // CHECK-REC: WARNING: ThreadSanitizer: lock-order-inversion
+  }
+
+  void Test10() {
+    if (test_number > 0 && test_number != 10) return;
+    fprintf(stderr, "Starting Test10: 4 threads lock/unlock 4 private mutexes, one under another\n");
+    // CHECK: Starting Test10
+    Init(100);
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+    RunThreads(&LockTest::Test10_Thread1, &LockTest::Test10_Thread2,
+               &LockTest::Test10_Thread3, &LockTest::Test10_Thread4);
+  }
+  void Test10_Thread1() { Test10_Thread(0); }
+  void Test10_Thread2() { Test10_Thread(10); }
+  void Test10_Thread3() { Test10_Thread(20); }
+  void Test10_Thread4() { Test10_Thread(30); }
+  void Test10_Thread(size_t m) {
+    for (int i = 0; i < iter_count; i++) {
+      L(m + 0);
+      L(m + 1);
+      L(m + 2);
+      L(m + 3);
+      U(m + 3);
+      U(m + 2);
+      U(m + 1);
+      U(m + 0);
+    }
+  }
+
+  void Test11() {
+    if (test_number > 0 && test_number != 11) return;
+    fprintf(stderr, "Starting Test11: 4 threads lock/unlock 4 private mutexes, all under another private mutex\n");
+    // CHECK: Starting Test11
+    Init(500);
+    // CHECK-NOT: WARNING: ThreadSanitizer:
+    RunThreads(&LockTest::Test11_Thread1, &LockTest::Test11_Thread2,
+               &LockTest::Test11_Thread3, &LockTest::Test11_Thread4);
+  }
+  void Test11_Thread1() { Test10_Thread(0); }
+  void Test11_Thread2() { Test10_Thread(10); }
+  void Test11_Thread3() { Test10_Thread(20); }
+  void Test11_Thread4() { Test10_Thread(30); }
+  void Test11_Thread(size_t m) {
+    for (int i = 0; i < iter_count; i++) {
+      L(m);
+      L(m + 100);
+      U(m + 100);
+      L(m + 200);
+      U(m + 200);
+      L(m + 300);
+      U(m + 300);
+      L(m + 400);
+      U(m + 500);
+      U(m);
+    }
+  }
+
+  void Test12() {
+    if (test_number > 0 && test_number != 12) return;
+    if (!LockType::supports_read_lock()) return;
+    fprintf(stderr, "Starting Test12: 4 threads read lock/unlock 4 shared mutexes, one under another\n");
+    // CHECK-RD: Starting Test12
+    Init(500);
+    // CHECK-RD-NOT: WARNING: ThreadSanitizer:
+    RunThreads(&LockTest::Test12_Thread, &LockTest::Test12_Thread,
+               &LockTest::Test12_Thread, &LockTest::Test12_Thread);
+  }
+  void Test12_Thread() {
+    for (int i = 0; i < iter_count; i++) {
+      RL(000);
+      RL(100);
+      RL(200);
+      RL(300);
+      RU(300);
+      RU(200);
+      RU(100);
+      RU(000);
+    }
+  }
+
+  void Test13() {
+    if (test_number > 0 && test_number != 13) return;
+    if (!LockType::supports_read_lock()) return;
+    fprintf(stderr, "Starting Test13: 4 threads read lock/unlock 4 shared mutexes, all under another shared mutex\n");
+    // CHECK-RD: Starting Test13
+    Init(500);
+    // CHECK-RD-NOT: WARNING: ThreadSanitizer:
+    RunThreads(&LockTest::Test13_Thread, &LockTest::Test13_Thread,
+               &LockTest::Test13_Thread, &LockTest::Test13_Thread);
+  }
+  void Test13_Thread() {
+    for (int i = 0; i < iter_count; i++) {
+      RL(0);
+      RL(100);
+      RU(100);
+      RL(200);
+      RU(200);
+      RL(300);
+      RU(300);
+      RL(400);
+      RU(400);
+      RU(0);
+    }
+  }
+
+  void Test14() {
+    if (test_number > 0 && test_number != 14) return;
+    fprintf(stderr, "Starting Test14: create lots of locks in 4 threads\n");
+    Init(10);
+    // CHECK-RD: Starting Test14
+    RunThreads(&LockTest::CreateAndDestroyLocksLoop,
+               &LockTest::CreateAndDestroyLocksLoop,
+               &LockTest::CreateAndDestroyLocksLoop,
+               &LockTest::CreateAndDestroyLocksLoop);
+  }
+
+  void Test15() {
+    if (test_number > 0 && test_number != 15) return;
+    if (!LockType::supports_read_lock()) return;
+    fprintf(stderr, "Starting Test15: recursive rlock\n");
+    // DISABLEDCHECK-RD: Starting Test15
+    Init(5);
+    RL(0); RL(0); RU(0); RU(0);  // Recusrive reader lock.
+    RL(0); RL(0); RL(0); RU(0); RU(0); RU(0);  // Recusrive reader lock.
+  }
+
+  // More detailed output test.
+  void Test16() {
+    if (test_number > 0 && test_number != 16) return;
+    fprintf(stderr, "Starting Test16: detailed output test with two locks\n");
+    // CHECK: Starting Test16
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
+    // CHECK: acquired here while holding mutex
+    // CHECK: LockTest::Acquire1
+    // CHECK-NEXT: LockTest::Acquire_0_then_1
+    // CHECK-SECOND: previously acquired by the same thread here
+    // CHECK-SECOND: LockTest::Acquire0
+    // CHECK-SECOND-NEXT: LockTest::Acquire_0_then_1
+    // CHECK: acquired here while holding mutex
+    // CHECK: LockTest::Acquire0
+    // CHECK-NEXT: LockTest::Acquire_1_then_0
+    // CHECK-SECOND: previously acquired by the same thread here
+    // CHECK-SECOND: LockTest::Acquire1
+    // CHECK-SECOND-NEXT: LockTest::Acquire_1_then_0
+    Init(5);
+    Acquire_0_then_1();
+    U(0); U(1);
+    Acquire_1_then_0();
+    U(0); U(1);
+  }
+
+  // More detailed output test.
+  void Test17() {
+    if (test_number > 0 && test_number != 17) return;
+    fprintf(stderr, "Starting Test17: detailed output test with three locks\n");
+    // CHECK: Starting Test17
+    // CHECK: WARNING: ThreadSanitizer: lock-order-inversion
+    // CHECK: LockTest::Acquire1
+    // CHECK-NEXT: LockTest::Acquire_0_then_1
+    // CHECK: LockTest::Acquire2
+    // CHECK-NEXT: LockTest::Acquire_1_then_2
+    // CHECK: LockTest::Acquire0
+    // CHECK-NEXT: LockTest::Acquire_2_then_0
+    Init(5);
+    Acquire_0_then_1();
+    U(0); U(1);
+    Acquire_1_then_2();
+    U(1); U(2);
+    Acquire_2_then_0();
+    U(0); U(2);
+  }
+
+  __attribute__((noinline)) void Acquire2() { L(2); }
+  __attribute__((noinline)) void Acquire1() { L(1); }
+  __attribute__((noinline)) void Acquire0() { L(0); }
+  __attribute__((noinline)) void Acquire_1_then_0() { Acquire1(); Acquire0(); }
+  __attribute__((noinline)) void Acquire_0_then_1() { Acquire0(); Acquire1(); }
+  __attribute__((noinline)) void Acquire_1_then_2() { Acquire1(); Acquire2(); }
+  __attribute__((noinline)) void Acquire_2_then_0() { Acquire2(); Acquire0(); }
+
+  // This test creates, locks, unlocks and destroys lots of mutexes.
+  void Test18() {
+    if (test_number > 0 && test_number != 18) return;
+    fprintf(stderr, "Starting Test18: create, lock and destroy 4 locks; all in "
+                    "4 threads in a loop\n");
+    RunThreads(&LockTest::Test18_Thread, &LockTest::Test18_Thread,
+               &LockTest::Test18_Thread, &LockTest::Test18_Thread);
+  }
+
+  void Test18_Thread() {
+    LockType *l = new LockType[4];
+    for (size_t i = 0; i < iter_count / 100; i++) {
+      for (int i = 0; i < 4; i++) l[i].lock();
+      for (int i = 0; i < 4; i++) l[i].unlock();
+      for (int i = 0; i < 4; i++) l[i].~LockType();
+      for (int i = 0; i < 4; i++) new ((void*)&l[i]) LockType();
+    }
+    delete [] l;
+  }
+
+  void Test19() {
+    if (test_number > 0 && test_number != 19) return;
+    fprintf(stderr, "Starting Test19: lots of lock inversions\n");
+    const int kNumLocks = 45;
+    Init(kNumLocks);
+    for (int i = 0; i < kNumLocks; i++) {
+      for (int j = 0; j < kNumLocks; j++)
+        L((i + j) % kNumLocks);
+      for (int j = 0; j < kNumLocks; j++)
+        U((i + j) % kNumLocks);
+    }
+  }
+
+ private:
+  void Lock2(size_t l1, size_t l2) { L(l1); L(l2); U(l2); U(l1); }
+
+  template<bool wait = false>
+  void Lock_0_1() {
+    Lock2(0, 1);
+    if (wait)
+      barrier_wait(&barrier);
+  }
+
+  template<bool wait = false>
+  void Lock_1_0() {
+    if (wait)
+      barrier_wait(&barrier);
+    Lock2(1, 0);
+  }
+
+  void Lock1_Loop(size_t i, size_t n_iter) {
+    for (size_t it = 0; it < n_iter; it++) {
+      // if ((it & (it - 1)) == 0) fprintf(stderr, "%zd", i);
+      L(i);
+      U(i);
+    }
+    // fprintf(stderr, "\n");
+  }
+  void Lock1_Loop_0() { Lock1_Loop(0, iter_count); }
+  void Lock1_Loop_1() { Lock1_Loop(10, iter_count); }
+  void Lock1_Loop_2() { Lock1_Loop(20, iter_count); }
+
+  void CreateAndDestroyManyLocks() {
+    LockType *create_many_locks_but_never_acquire =
+        new LockType[kDeadlockGraphSize];
+    (void)create_many_locks_but_never_acquire;
+    delete [] create_many_locks_but_never_acquire;
+  }
+
+  void CreateAndDestroyLocksLoop() {
+    for (size_t it = 0; it <= iter_count; it++) {
+      LockType some_locks[10];
+      (void)some_locks;
+    }
+  }
+
+  void CreateLockUnlockAndDestroyManyLocks() {
+    LockType many_locks[kDeadlockGraphSize];
+    for (size_t i = 0; i < kDeadlockGraphSize; i++) {
+      many_locks[i].lock();
+      many_locks[i].unlock();
+    }
+  }
+
+  // LockTest Member function callback.
+  struct CB {
+    void (LockTest::*f)();
+    LockTest *lt;
+  };
+
+  // Thread function with CB.
+  static void *Thread(void *param) {
+    CB *cb = (CB*)param;
+    (cb->lt->*cb->f)();
+    return NULL;
+  }
+
+  void RunThreads(void (LockTest::*f1)(), void (LockTest::*f2)(),
+                  void (LockTest::*f3)() = 0, void (LockTest::*f4)() = 0) {
+    const int kNumThreads = 4;
+    pthread_t t[kNumThreads];
+    CB cb[kNumThreads] = {{f1, this}, {f2, this}, {f3, this}, {f4, this}};
+    for (int i = 0; i < kNumThreads && cb[i].f; i++)
+      pthread_create(&t[i], 0, Thread, &cb[i]);
+    for (int i = 0; i < kNumThreads && cb[i].f; i++)
+      pthread_join(t[i], 0);
+  }
+
+  static const size_t kDeadlockGraphSize = 4096;
+  size_t n_;
+  LockType **locks_;
+};
+
+int main(int argc, char **argv) {
+  barrier_init(&barrier, 2);
+  if (argc > 1)
+    test_number = atoi(argv[1]);
+  if (argc > 2)
+    iter_count = atoi(argv[2]);
+  LockTest().Test1();
+  LockTest().Test2();
+  LockTest().Test3();
+  LockTest().Test4();
+  LockTest().Test5();
+  LockTest().Test6();
+  LockTest().Test7();
+  LockTest().Test8();
+  LockTest().Test9();
+  LockTest().Test10();
+  LockTest().Test11();
+  LockTest().Test12();
+  LockTest().Test13();
+  LockTest().Test14();
+  LockTest().Test15();
+  LockTest().Test16();
+  LockTest().Test17();
+  LockTest().Test18();
+  LockTest().Test19();
+  fprintf(stderr, "ALL-DONE\n");
+  // CHECK: ALL-DONE
+}
diff --git a/compiler-rt/test/tsan/deep_stack1.cc b/compiler-rt/test/tsan/deep_stack1.cc
new file mode 100644
index 0000000..39185ef
--- /dev/null
+++ b/compiler-rt/test/tsan/deep_stack1.cc
@@ -0,0 +1,50 @@
+// RUN: %clangxx_tsan -O1 %s -o %t -DORDER1 && %deflake %run %t | FileCheck %s
+// RUN: %clangxx_tsan -O1 %s -o %t -DORDER2 && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+volatile int X;
+volatile int N;
+void (*volatile F)();
+
+static void foo() {
+  if (--N == 0)
+    X = 42;
+  else
+    F();
+}
+
+void *Thread(void *p) {
+#ifdef ORDER1
+  barrier_wait(&barrier);
+#endif
+  F();
+#ifdef ORDER2
+  barrier_wait(&barrier);
+#endif
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  N = 50000;
+  F = foo;
+  pthread_t t;
+  pthread_attr_t a;
+  pthread_attr_init(&a);
+  pthread_attr_setstacksize(&a, N * 256 + (1 << 20));
+  pthread_create(&t, &a, Thread, 0);
+#ifdef ORDER2
+  barrier_wait(&barrier);
+#endif
+  X = 43;
+#ifdef ORDER1
+  barrier_wait(&barrier);
+#endif
+
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:    #100 foo
+// We must output suffucuently large stack (at least 100 frames)
+
diff --git a/compiler-rt/test/tsan/default_options.cc b/compiler-rt/test/tsan/default_options.cc
new file mode 100644
index 0000000..77bdcd5
--- /dev/null
+++ b/compiler-rt/test/tsan/default_options.cc
@@ -0,0 +1,32 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+extern "C" const char *__tsan_default_options() {
+  return "report_bugs=0";
+}
+
+int Global;
+
+void *Thread1(void *x) {
+  Global = 42;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global = 43;
+  return NULL;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/deflake.bash b/compiler-rt/test/tsan/deflake.bash
new file mode 100755
index 0000000..9731fa5
--- /dev/null
+++ b/compiler-rt/test/tsan/deflake.bash
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# This script is used to deflake inherently flaky tsan tests.
+# It is invoked from lit tests as:
+# %deflake mybinary
+# which is then substituted by lit to:
+# $(dirname %s)/deflake.bash mybinary
+# The script runs the target program up to 10 times,
+# until it fails (i.e. produces a race report).
+
+for i in $(seq 1 10); do
+	OUT=`$@ 2>&1`
+	if [[ $? != 0 ]]; then
+		echo "$OUT"
+		exit 0
+	fi
+done
+exit 1
diff --git a/compiler-rt/test/tsan/dl_iterate_phdr.cc b/compiler-rt/test/tsan/dl_iterate_phdr.cc
new file mode 100644
index 0000000..b9ce615
--- /dev/null
+++ b/compiler-rt/test/tsan/dl_iterate_phdr.cc
@@ -0,0 +1,57 @@
+// RUN: %clangxx_tsan -O1 %s -DBUILD_SO -fPIC -shared -o %t-so.so
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// dl_iterate_phdr doesn't exist on OS X.
+// UNSUPPORTED: darwin
+
+#ifdef BUILD_SO
+
+#include "test.h"
+
+int exported_var = 0;
+
+#else  // BUILD_SO
+
+#include "test.h"
+#include <dlfcn.h>
+#include <link.h>
+#include <string.h>
+#include <string>
+
+static int callback(struct dl_phdr_info *info, size_t size, void *data) {
+  if (info->dlpi_name[0] == '\0')
+    info->dlpi_name = "/proc/self/exe";
+  return !strcmp(info->dlpi_name, "non existent module");
+}
+
+void *thread(void *unused) {
+  for (int i = 0; i < 1000; i++) {
+    barrier_wait(&barrier);
+    dl_iterate_phdr(callback, 0);
+  }
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  barrier_init(&barrier, 2);
+  std::string path = std::string(argv[0]) + std::string("-so.so");
+  pthread_t th;
+  pthread_create(&th, 0, thread, 0);
+  for (int i = 0; i < 1000; i++) {
+    barrier_wait(&barrier);
+    void *lib = dlopen(path.c_str(), RTLD_NOW);
+    if (!lib) {
+      printf("error in dlopen: %s\n", dlerror());
+      return 1;
+    }
+    dlclose(lib);
+  }
+  pthread_join(th, 0);
+  printf("DONE\n");
+  return 0;
+}
+
+#endif  // BUILD_SO
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/dlclose.cc b/compiler-rt/test/tsan/dlclose.cc
new file mode 100644
index 0000000..d497fd7
--- /dev/null
+++ b/compiler-rt/test/tsan/dlclose.cc
@@ -0,0 +1,56 @@
+// RUN: %clangxx_tsan -O1 %s -DBUILD_SO -fPIC -shared -o %t-so.so
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Test case for
+// https://github.com/google/sanitizers/issues/487
+
+#ifdef BUILD_SO
+
+#include <stdio.h>
+
+extern "C"
+void sofunc() {
+  fprintf(stderr, "HELLO FROM SO\n");
+}
+
+#else  // BUILD_SO
+
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <string>
+
+void *lib;
+void *lib2;
+
+struct Closer {
+  ~Closer() {
+    dlclose(lib);
+    fprintf(stderr, "CLOSED SO\n");
+  }
+};
+static Closer c;
+
+int main(int argc, char *argv[]) {
+  lib = dlopen((std::string(argv[0]) + std::string("-so.so")).c_str(),
+      RTLD_NOW|RTLD_NODELETE);
+  if (lib == 0) {
+    printf("error in dlopen: %s\n", dlerror());
+    return 1;
+  }
+  void *f = dlsym(lib, "sofunc");
+  if (f == 0) {
+    printf("error in dlsym: %s\n", dlerror());
+    return 1;
+  }
+  ((void(*)())f)();
+  return 0;
+}
+
+#endif  // BUILD_SO
+
+// CHECK: HELLO FROM SO
+// CHECK-NOT: Inconsistency detected by ld.so
+// CHECK: CLOSED SO
+
diff --git a/compiler-rt/test/tsan/fd_close_norace.cc b/compiler-rt/test/tsan/fd_close_norace.cc
new file mode 100644
index 0000000..1b52c20
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_close_norace.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+void *Thread1(void *x) {
+  int f = open("/dev/random", O_RDONLY);
+  close(f);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  int f = open("/dev/random", O_RDONLY);
+  close(f);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+
+
diff --git a/compiler-rt/test/tsan/fd_close_norace2.cc b/compiler-rt/test/tsan/fd_close_norace2.cc
new file mode 100644
index 0000000..bf94fd5
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_close_norace2.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int pipes[2];
+
+void *Thread(void *x) {
+  // wait for shutown signal
+  while (read(pipes[0], &x, 1) != 1) {
+  }
+  close(pipes[0]);
+  close(pipes[1]);
+  return 0;
+}
+
+int main() {
+  if (pipe(pipes))
+    return 1;
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  // send shutdown signal
+  while (write(pipes[1], &t, 1) != 1) {
+  }
+  pthread_join(t, 0);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: OK
diff --git a/compiler-rt/test/tsan/fd_dup_norace.cc b/compiler-rt/test/tsan/fd_dup_norace.cc
new file mode 100644
index 0000000..5045325
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_dup_norace.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+int fds[2];
+
+void *Thread1(void *x) {
+  char buf;
+  read(fds[0], &buf, 1);
+  close(fds[0]);
+  return 0;
+}
+
+void *Thread2(void *x) {
+  close(fds[1]);
+  return 0;
+}
+
+int main() {
+  fds[0] = open("/dev/random", O_RDONLY);
+  fds[1] = dup2(fds[0], 100);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/fd_dup_norace2.cc b/compiler-rt/test/tsan/fd_dup_norace2.cc
new file mode 100644
index 0000000..662c686
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_dup_norace2.cc
@@ -0,0 +1,60 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+// dup2(oldfd, newfd) races with read(newfd).
+// This is not reported as race because:
+// 1. Some software dups a closed pipe in place of a socket before closing
+//    the socket (to prevent races actually).
+// 2. Some daemons dup /dev/null in place of stdin/stdout.
+
+int fd;
+
+void *Thread(void *x) {
+  char buf;
+  int n = read(fd, &buf, 1);
+  if (n != 1) {
+    // This read can "legitimately" fail regadless of the fact that glibc claims
+    // that "there is no instant in the middle of calling dup2 at which new is
+    // closed and not yet a duplicate of old". Strace of the failing runs
+    // looks as follows:
+    //
+    //    [pid 122196] open("/dev/urandom", O_RDONLY) = 3
+    //    [pid 122196] open("/dev/urandom", O_RDONLY) = 4
+    //    Process 122382 attached
+    //    [pid 122382] read(3,  <unfinished ...>
+    //    [pid 122196] dup2(4, 3 <unfinished ...>
+    //    [pid 122382] <... read resumed> 0x7fcd139960b7, 1) = -1 EBADF (Bad file descriptor)
+    //    [pid 122196] <... dup2 resumed> )       = 3
+    //    read failed: n=-1 errno=9
+    //
+    // The failing read does not interfere with what this test tests,
+    // so we just ignore the failure.
+    //
+    // exit(printf("read failed: n=%d errno=%d\n", n, errno));
+  }
+  return 0;
+}
+
+int main() {
+  fd = open("/dev/urandom", O_RDONLY);
+  int fd2 = open("/dev/urandom", O_RDONLY);
+  if (fd == -1 || fd2 == -1)
+    exit(printf("open failed\n"));
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  if (dup2(fd2, fd) == -1)
+    exit(printf("dup2 failed\n"));
+  pthread_join(th, 0);
+  if (close(fd) == -1)
+    exit(printf("close failed\n"));
+  if (close(fd2) == -1)
+    exit(printf("close failed\n"));
+  printf("DONE\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/fd_dup_race.cc b/compiler-rt/test/tsan/fd_dup_race.cc
new file mode 100644
index 0000000..a1aee55
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_dup_race.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+// dup2(oldfd, newfd) races with close(newfd).
+
+int fd;
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  if (close(fd) == -1)
+    exit(printf("close failed\n"));
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  fd = open("/dev/random", O_RDONLY);
+  int fd2 = open("/dev/random", O_RDONLY);
+  if (fd == -1 || fd2 == -1)
+    exit(printf("open failed\n"));
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  if (dup2(fd2, fd) == -1)
+    exit(printf("dup2 failed\n"));
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  printf("DONE\n");
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/fd_location.cc b/compiler-rt/test/tsan/fd_location.cc
new file mode 100644
index 0000000..1861c89
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_location.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int fds[2];
+
+void *Thread1(void *x) {
+  write(fds[1], "a", 1);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  close(fds[0]);
+  close(fds[1]);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pipe(fds);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Location is file descriptor {{[0-9]+}} created by main thread at:
+// CHECK:     #0 pipe
+// CHECK:     #1 main
+
diff --git a/compiler-rt/test/tsan/fd_pipe_norace.cc b/compiler-rt/test/tsan/fd_pipe_norace.cc
new file mode 100644
index 0000000..b434703
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_pipe_norace.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int fds[2];
+int X;
+
+void *Thread1(void *x) {
+  X = 42;
+  write(fds[1], "a", 1);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  char buf;
+  while (read(fds[0], &buf, 1) != 1) {
+  }
+  X = 43;
+  return NULL;
+}
+
+int main() {
+  pipe(fds);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/fd_pipe_race.cc b/compiler-rt/test/tsan/fd_pipe_race.cc
new file mode 100644
index 0000000..b94893b
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_pipe_race.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int fds[2];
+
+void *Thread1(void *x) {
+  write(fds[1], "a", 1);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  close(fds[0]);
+  close(fds[1]);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pipe(fds);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 8
+// CHECK:     #0 close
+// CHECK:     #1 Thread2
+// CHECK:   Previous read of size 8
+// CHECK:     #0 write
+// CHECK:     #1 Thread1
+
+
diff --git a/compiler-rt/test/tsan/fd_socket_connect_norace.cc b/compiler-rt/test/tsan/fd_socket_connect_norace.cc
new file mode 100644
index 0000000..ab2a950
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_socket_connect_norace.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+struct sockaddr_in addr;
+int X;
+
+void *ClientThread(void *x) {
+  int c = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  X = 42;
+  if (connect(c, (struct sockaddr*)&addr, sizeof(addr))) {
+    perror("connect");
+    exit(1);
+  }
+  close(c);
+  return NULL;
+}
+
+int main() {
+  int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  addr.sin_family = AF_INET;
+  inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
+  addr.sin_port = INADDR_ANY;
+  socklen_t len = sizeof(addr);
+  bind(s, (sockaddr*)&addr, len);
+  getsockname(s, (sockaddr*)&addr, &len);
+  listen(s, 10);
+  pthread_t t;
+  pthread_create(&t, 0, ClientThread, 0);
+  int c = accept(s, 0, 0);
+  X = 42;
+  pthread_join(t, 0);
+  close(c);
+  close(s);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/fd_socket_norace.cc b/compiler-rt/test/tsan/fd_socket_norace.cc
new file mode 100644
index 0000000..0f41c43
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_socket_norace.cc
@@ -0,0 +1,52 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+struct sockaddr_in addr;
+int X;
+
+void *ClientThread(void *x) {
+  X = 42;
+  int c = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (connect(c, (struct sockaddr*)&addr, sizeof(addr))) {
+    perror("connect");
+    exit(1);
+  }
+  if (send(c, "a", 1, 0) != 1) {
+    perror("send");
+    exit(1);
+  }
+  close(c);
+  return NULL;
+}
+
+int main() {
+  int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  addr.sin_family = AF_INET;
+  inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
+  addr.sin_port = INADDR_ANY;
+  socklen_t len = sizeof(addr);
+  bind(s, (sockaddr*)&addr, len);
+  getsockname(s, (sockaddr*)&addr, &len);
+  listen(s, 10);
+  pthread_t t;
+  pthread_create(&t, 0, ClientThread, 0);
+  int c = accept(s, 0, 0);
+  char buf;
+  while (read(c, &buf, 1) != 1) {
+  }
+  X = 43;
+  close(c);
+  close(s);
+  pthread_join(t, 0);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/fd_socketpair_norace.cc b/compiler-rt/test/tsan/fd_socketpair_norace.cc
new file mode 100644
index 0000000..a455d44
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_socketpair_norace.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int fds[2];
+int X;
+
+void *Thread1(void *x) {
+  X = 42;
+  write(fds[1], "a", 1);
+  close(fds[1]);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  char buf;
+  while (read(fds[0], &buf, 1) != 1) {
+  }
+  X = 43;
+  close(fds[0]);
+  return NULL;
+}
+
+int main() {
+  socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/fd_stdout_race.cc b/compiler-rt/test/tsan/fd_stdout_race.cc
new file mode 100644
index 0000000..fcf8c21
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_stdout_race.cc
@@ -0,0 +1,41 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+int X;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  int f = open("/dev/random", O_RDONLY);
+  char buf;
+  read(f, &buf, 1);
+  close(f);
+  X = 42;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  X = 43;
+  write(STDOUT_FILENO, "a", 1);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 4
+// CHECK:     #0 Thread1
+// CHECK:   Previous write of size 4
+// CHECK:     #0 Thread2
+
+
diff --git a/compiler-rt/test/tsan/fd_tid_recycled.cc b/compiler-rt/test/tsan/fd_tid_recycled.cc
new file mode 100644
index 0000000..d314787
--- /dev/null
+++ b/compiler-rt/test/tsan/fd_tid_recycled.cc
@@ -0,0 +1,54 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int fds[2];
+
+void *ThreadCreatePipe(void *x) {
+  pipe(fds);
+  return NULL;
+}
+
+void *ThreadDummy(void *x) {
+  return NULL;
+}
+
+void *ThreadWrite(void *x) {
+  write(fds[1], "a", 1);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *ThreadClose(void *x) {
+  barrier_wait(&barrier);
+  close(fds[0]);
+  close(fds[1]);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t_create;
+  pthread_create(&t_create, NULL, ThreadCreatePipe, NULL);
+  pthread_join(t_create, NULL);
+
+  for (int i = 0; i < 100; i++) {
+    pthread_t t_dummy;
+    pthread_create(&t_dummy, NULL, ThreadDummy, NULL);
+    pthread_join(t_dummy, NULL);
+  }
+
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, ThreadWrite, NULL);
+  pthread_create(&t[1], NULL, ThreadClose, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK-NOT: CHECK failed
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 8
+// CHECK:     #0 close
+// CHECK:     #1 ThreadClose
+// CHECK:   Previous read of size 8
+// CHECK:     #0 write
+// CHECK:     #1 ThreadWrite
diff --git a/compiler-rt/test/tsan/fork_atexit.cc b/compiler-rt/test/tsan/fork_atexit.cc
new file mode 100644
index 0000000..51a64fc
--- /dev/null
+++ b/compiler-rt/test/tsan/fork_atexit.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %env_tsan_opts=atexit_sleep_ms=50 %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+void foo() {
+  printf("CHILD ATEXIT\n");
+}
+
+void *worker(void *unused) {
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, NULL, worker, NULL);
+  int pid = fork();
+  if (pid == 0) {
+    // child
+    atexit(foo);
+    fprintf(stderr, "CHILD DONE\n");
+  } else {
+    pthread_join(t, 0);
+    if (waitpid(pid, 0, 0) == -1) {
+      perror("waitpid");
+      exit(1);
+    }
+    fprintf(stderr, "PARENT DONE\n");
+  }
+}
+
+// CHECK: CHILD DONE
+// CHECK: CHILD ATEXIT
+// CHECK: PARENT DONE
diff --git a/compiler-rt/test/tsan/fork_deadlock.cc b/compiler-rt/test/tsan/fork_deadlock.cc
new file mode 100644
index 0000000..22bed08
--- /dev/null
+++ b/compiler-rt/test/tsan/fork_deadlock.cc
@@ -0,0 +1,47 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %env_tsan_opts=atexit_sleep_ms=50 %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include "test.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int counter;
+
+static void *incrementer(void *p) {
+  for (;;)
+    __sync_fetch_and_add(&counter, 1);
+  return 0;
+}
+
+static void *watchdog(void *p) {
+  sleep(100);  // is not intended to exit
+  fprintf(stderr, "timed out after 100 seconds\n");
+  exit(1);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t th1, th2;
+  pthread_create(&th1, 0, incrementer, 0);
+  pthread_create(&th2, 0, watchdog, 0);
+  for (int i = 0; i < 10; i++) {
+    switch (fork()) {
+    default:  // parent
+      while (wait(0) < 0) {}
+      fprintf(stderr, ".");
+      break;
+    case 0:  // child
+      __sync_fetch_and_add(&counter, 1);
+      exit(0);
+      break;
+    case -1:  // error
+      fprintf(stderr, "failed to fork (%d)\n", errno);
+      exit(1);
+    }
+  }
+  fprintf(stderr, "OK\n");
+}
+
+// CHECK: OK
+
diff --git a/compiler-rt/test/tsan/fork_multithreaded.cc b/compiler-rt/test/tsan/fork_multithreaded.cc
new file mode 100644
index 0000000..b345f58
--- /dev/null
+++ b/compiler-rt/test/tsan/fork_multithreaded.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-DIE
+// RUN: %clangxx_tsan -O1 %s -o %t && %env_tsan_opts=die_after_fork=0 %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-NODIE
+// UNSUPPORTED: darwin
+#include "test.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+static void *sleeper(void *p) {
+  sleep(10);  // not intended to exit during test
+  return 0;
+}
+
+static void *nop(void *p) {
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t th;
+  pthread_create(&th, 0, sleeper, 0);
+  switch (fork()) {
+  default:  // parent
+    while (wait(0) < 0) {}
+    break;
+  case 0:  // child
+    {
+      pthread_t th2;
+      pthread_create(&th2, 0, nop, 0);
+      exit(0);
+      break;
+    }
+  case -1:  // error
+    fprintf(stderr, "failed to fork (%d)\n", errno);
+    exit(1);
+  }
+  fprintf(stderr, "OK\n");
+}
+
+// CHECK-DIE: ThreadSanitizer: starting new threads after multi-threaded fork is not supported
+// CHECK-DIE: OK
+
+// CHECK-NODIE-NOT: ThreadSanitizer: starting new threads after multi-threaded fork is not supported
+// CHECK-NODIE: OK
+
diff --git a/compiler-rt/test/tsan/fork_multithreaded3.cc b/compiler-rt/test/tsan/fork_multithreaded3.cc
new file mode 100644
index 0000000..5b8c13e
--- /dev/null
+++ b/compiler-rt/test/tsan/fork_multithreaded3.cc
@@ -0,0 +1,41 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+static void *racer(void *p) {
+  *(int*)p = 42;
+  return 0;
+}
+
+int main() {
+  switch (fork()) {
+  default:  // parent
+    while (wait(0) < 0) {}
+    break;
+  case 0:  // child
+    {
+      int x = 0;
+      pthread_t th1, th2;
+      pthread_create(&th1, 0, racer, &x);
+      pthread_create(&th2, 0, racer, &x);
+      pthread_join(th1, 0);
+      pthread_join(th2, 0);
+      exit(0);
+      break;
+    }
+  case -1:  // error
+    fprintf(stderr, "failed to fork (%d)\n", errno);
+    exit(1);
+  }
+  fprintf(stderr, "OK\n");
+}
+
+// CHECK: ThreadSanitizer: data race
+// CHECK: OK
+
diff --git a/compiler-rt/test/tsan/free_race.c b/compiler-rt/test/tsan/free_race.c
new file mode 100644
index 0000000..d508552
--- /dev/null
+++ b/compiler-rt/test/tsan/free_race.c
@@ -0,0 +1,47 @@
+// RUN: %clang_tsan -O1 %s -o %t
+// RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOZUPP
+// RUN: %env_tsan_opts=suppressions='%s.supp':print_suppressions=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUPP
+
+#include "test.h"
+
+int *mem;
+pthread_mutex_t mtx;
+
+void *Thread1(void *x) {
+  pthread_mutex_lock(&mtx);
+  free(mem);
+  pthread_mutex_unlock(&mtx);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&mtx);
+  mem[0] = 42;
+  pthread_mutex_unlock(&mtx);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  mem = (int*)malloc(100);
+  pthread_mutex_init(&mtx, 0);
+  pthread_t t;
+  pthread_create(&t, NULL, Thread1, NULL);
+  Thread2(0);
+  pthread_join(t, NULL);
+  pthread_mutex_destroy(&mtx);
+  return 0;
+}
+
+// CHECK-NOZUPP: WARNING: ThreadSanitizer: heap-use-after-free
+// CHECK-NOZUPP:   Write of size 4 at {{.*}} by main thread{{.*}}:
+// CHECK-NOZUPP:     #0 Thread2
+// CHECK-NOZUPP:     #1 main
+// CHECK-NOZUPP:   Previous write of size 8 at {{.*}} by thread T1{{.*}}:
+// CHECK-NOZUPP:     #0 free
+// CHECK-NOZUPP:     #{{(1|2)}} Thread1
+// CHECK-NOZUPP: SUMMARY: ThreadSanitizer: heap-use-after-free{{.*}}Thread2
+// CHECK-SUPP:   ThreadSanitizer: Matched 1 suppressions
+// CHECK-SUPP:    1 race:^Thread2$
diff --git a/compiler-rt/test/tsan/free_race.c.supp b/compiler-rt/test/tsan/free_race.c.supp
new file mode 100644
index 0000000..f5d6a49
--- /dev/null
+++ b/compiler-rt/test/tsan/free_race.c.supp
@@ -0,0 +1,2 @@
+# Suppression for a use-after-free in free_race.c
+race:^Thread2$
diff --git a/compiler-rt/test/tsan/free_race2.c b/compiler-rt/test/tsan/free_race2.c
new file mode 100644
index 0000000..de6b2ae
--- /dev/null
+++ b/compiler-rt/test/tsan/free_race2.c
@@ -0,0 +1,26 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <stdlib.h>
+
+void __attribute__((noinline)) foo(int *mem) {
+  free(mem);
+}
+
+void __attribute__((noinline)) bar(int *mem) {
+  mem[0] = 42;
+}
+
+int main() {
+  int *mem = (int*)malloc(100);
+  foo(mem);
+  bar(mem);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: heap-use-after-free
+// CHECK:   Write of size 4 at {{.*}} by main thread:
+// CHECK:     #0 bar
+// CHECK:     #1 main
+// CHECK:   Previous write of size 8 at {{.*}} by main thread:
+// CHECK:     #0 free
+// CHECK:     #{{1|2}} foo
+// CHECK:     #{{2|3}} main
diff --git a/compiler-rt/test/tsan/getline_nohang.cc b/compiler-rt/test/tsan/getline_nohang.cc
new file mode 100644
index 0000000..d103839
--- /dev/null
+++ b/compiler-rt/test/tsan/getline_nohang.cc
@@ -0,0 +1,39 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t
+
+// Make sure TSan doesn't deadlock on a file stream lock at program shutdown.
+// See https://github.com/google/sanitizers/issues/454
+#ifdef __FreeBSD__
+#define _WITH_GETLINE  // to declare getline()
+#endif
+
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+
+void *thread(void *unused) {
+  char *line = NULL;
+  size_t size;
+  int fd[2];
+  pipe(fd);
+  // Forge a non-standard stream to make sure it's not closed.
+  FILE *stream = fdopen(fd[0], "r");
+  while (1) {
+    volatile int res = getline(&line, &size, stream);
+    (void)res;
+  }
+  return NULL;
+}
+
+int main() {
+  pthread_t t;
+  pthread_attr_t a;
+  pthread_attr_init(&a);
+  pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
+  pthread_create(&t, &a, thread, NULL);
+  pthread_attr_destroy(&a);
+  fprintf(stderr, "DONE\n");
+  return 0;
+  // ThreadSanitizer used to hang here because of a deadlock on a file stream.
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/global_race.cc b/compiler-rt/test/tsan/global_race.cc
new file mode 100644
index 0000000..a352996
--- /dev/null
+++ b/compiler-rt/test/tsan/global_race.cc
@@ -0,0 +1,25 @@
+// RUN: %clangxx_tsan -O1 %s -o %T/global_race.cc.exe && %deflake %run %T/global_race.cc.exe | FileCheck %s
+#include "test.h"
+
+int GlobalData[10];
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  GlobalData[2] = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr=", 1, GlobalData);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  GlobalData[2] = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'GlobalData' {{(of size 40 )?}}at [[ADDR]] (global_race.cc.exe+0x{{[0-9,a-f]+}})
+
diff --git a/compiler-rt/test/tsan/global_race2.cc b/compiler-rt/test/tsan/global_race2.cc
new file mode 100644
index 0000000..95dff19
--- /dev/null
+++ b/compiler-rt/test/tsan/global_race2.cc
@@ -0,0 +1,25 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int x;
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  x = 1;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr2=", 1, &x);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  x = 0;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: addr2=[[ADDR2:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'x' {{(of size 4 )?}}at [[ADDR2]] ({{.*}}+0x{{[0-9,a-f]+}})
+
diff --git a/compiler-rt/test/tsan/global_race3.cc b/compiler-rt/test/tsan/global_race3.cc
new file mode 100644
index 0000000..e0d59d2
--- /dev/null
+++ b/compiler-rt/test/tsan/global_race3.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+namespace XXX {
+  struct YYY {
+    static int ZZZ[10];
+  };
+  int YYY::ZZZ[10];
+}
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  XXX::YYY::ZZZ[0] = 1;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr3=", 1, XXX::YYY::ZZZ);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  XXX::YYY::ZZZ[0] = 0;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: addr3=[[ADDR3:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Location is global 'XXX::YYY::ZZZ' {{(of size 40 )?}}at [[ADDR3]] ({{.*}}+0x{{[0-9,a-f]+}})
diff --git a/compiler-rt/test/tsan/halt_on_error.cc b/compiler-rt/test/tsan/halt_on_error.cc
new file mode 100644
index 0000000..5d481c3
--- /dev/null
+++ b/compiler-rt/test/tsan/halt_on_error.cc
@@ -0,0 +1,27 @@
+// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=halt_on_error=1 %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int X;
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  X = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  fprintf(stderr, "BEFORE\n");
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  X = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  fprintf(stderr, "AFTER\n");
+  return 0;
+}
+
+// CHECK: BEFORE
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: AFTER
+
diff --git a/compiler-rt/test/tsan/heap_race.cc b/compiler-rt/test/tsan/heap_race.cc
new file mode 100644
index 0000000..0201ea9
--- /dev/null
+++ b/compiler-rt/test/tsan/heap_race.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <pthread.h>
+#include <stdio.h>
+#include <stddef.h>
+
+void *Thread(void *a) {
+  ((int*)a)[0]++;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int *p = new int(42);
+  pthread_t t;
+  pthread_create(&t, NULL, Thread, p);
+  barrier_wait(&barrier);
+  p[0]++;
+  pthread_join(t, NULL);
+  delete p;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/ignore_free.cc b/compiler-rt/test/tsan/ignore_free.cc
new file mode 100644
index 0000000..4e67895
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_free.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+extern "C" {
+void AnnotateIgnoreReadsBegin(const char *f, int l);
+void AnnotateIgnoreReadsEnd(const char *f, int l);
+void AnnotateIgnoreWritesBegin(const char *f, int l);
+void AnnotateIgnoreWritesEnd(const char *f, int l);
+}
+
+void *Thread(void *p) {
+  *(int*)p = 42;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int *p = new int(0);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, p);
+  barrier_wait(&barrier);
+  AnnotateIgnoreReadsBegin(__FILE__, __LINE__);
+  AnnotateIgnoreWritesBegin(__FILE__, __LINE__);
+  free(p);
+  AnnotateIgnoreReadsEnd(__FILE__, __LINE__);
+  AnnotateIgnoreWritesEnd(__FILE__, __LINE__);
+  pthread_join(t, 0);
+  fprintf(stderr, "OK\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: OK
diff --git a/compiler-rt/test/tsan/ignore_lib0.cc b/compiler-rt/test/tsan/ignore_lib0.cc
new file mode 100644
index 0000000..c72aa49
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib0.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib0.so
+// RUN: %clangxx_tsan -O1 %s -L%T -lignore_lib0 -o %t
+// RUN: echo running w/o suppressions:
+// RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOSUPP
+// RUN: echo running with suppressions:
+// RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
+
+// Tests that interceptors coming from a library specified in called_from_lib
+// suppression are ignored.
+
+// Some aarch64 kernels do not support non executable write pages
+// REQUIRES: stable-runtime
+
+#ifndef LIB
+
+extern "C" void libfunc();
+
+int main() {
+  libfunc();
+}
+
+#else  // #ifdef LIB
+
+#include "ignore_lib_lib.h"
+
+#endif  // #ifdef LIB
+
+// CHECK-NOSUPP: WARNING: ThreadSanitizer: data race
+// CHECK-NOSUPP: OK
+
+// CHECK-WITHSUPP-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-WITHSUPP: OK
+
diff --git a/compiler-rt/test/tsan/ignore_lib0.cc.supp b/compiler-rt/test/tsan/ignore_lib0.cc.supp
new file mode 100644
index 0000000..7728c92
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib0.cc.supp
@@ -0,0 +1,2 @@
+called_from_lib:/libignore_lib0.so
+
diff --git a/compiler-rt/test/tsan/ignore_lib1.cc b/compiler-rt/test/tsan/ignore_lib1.cc
new file mode 100644
index 0000000..e6a13a3
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib1.cc
@@ -0,0 +1,44 @@
+// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib1.so
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: echo running w/o suppressions:
+// RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOSUPP
+// RUN: echo running with suppressions:
+// RUN: %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
+
+// Tests that interceptors coming from a dynamically loaded library specified
+// in called_from_lib suppression are ignored.
+
+// REQUIRES: stable-runtime
+
+#ifndef LIB
+
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <libgen.h>
+#include <string>
+
+int main(int argc, char **argv) {
+  std::string lib = std::string(dirname(argv[0])) + "/libignore_lib1.so";
+  void *h = dlopen(lib.c_str(), RTLD_GLOBAL | RTLD_NOW);
+  if (h == 0)
+    exit(printf("failed to load the library (%d)\n", errno));
+  void (*f)() = (void(*)())dlsym(h, "libfunc");
+  if (f == 0)
+    exit(printf("failed to find the func (%d)\n", errno));
+  f();
+}
+
+#else  // #ifdef LIB
+
+#include "ignore_lib_lib.h"
+
+#endif  // #ifdef LIB
+
+// CHECK-NOSUPP: WARNING: ThreadSanitizer: data race
+// CHECK-NOSUPP: OK
+
+// CHECK-WITHSUPP-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-WITHSUPP: OK
+
diff --git a/compiler-rt/test/tsan/ignore_lib1.cc.supp b/compiler-rt/test/tsan/ignore_lib1.cc.supp
new file mode 100644
index 0000000..9f4119e
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib1.cc.supp
@@ -0,0 +1,2 @@
+called_from_lib:/libignore_lib1.so$
+
diff --git a/compiler-rt/test/tsan/ignore_lib2.cc b/compiler-rt/test/tsan/ignore_lib2.cc
new file mode 100644
index 0000000..4f584b1
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib2.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib2_0.so
+// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib2_1.so
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %env_tsan_opts=suppressions='%s.supp' %deflake %run %t | FileCheck %s
+
+// Tests that called_from_lib suppression matched against 2 libraries
+// causes program crash (this is not supported).
+
+#ifndef LIB
+
+#include <dlfcn.h>
+#include <stdio.h>
+#include <libgen.h>
+#include <string>
+
+int main(int argc, char **argv) {
+  std::string lib0 = std::string(dirname(argv[0])) + "/libignore_lib2_0.so";
+  std::string lib1 = std::string(dirname(argv[0])) + "/libignore_lib2_1.so";
+  dlopen(lib0.c_str(), RTLD_GLOBAL | RTLD_NOW);
+  dlopen(lib1.c_str(), RTLD_GLOBAL | RTLD_NOW);
+  fprintf(stderr, "OK\n");
+}
+
+#else  // #ifdef LIB
+
+extern "C" void libfunc() {
+}
+
+#endif  // #ifdef LIB
+
+// CHECK: ThreadSanitizer: called_from_lib suppression 'ignore_lib2' is matched against 2 libraries
+// CHECK-NOT: OK
+
diff --git a/compiler-rt/test/tsan/ignore_lib2.cc.supp b/compiler-rt/test/tsan/ignore_lib2.cc.supp
new file mode 100644
index 0000000..1419c71
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib2.cc.supp
@@ -0,0 +1,2 @@
+called_from_lib:ignore_lib2
+
diff --git a/compiler-rt/test/tsan/ignore_lib3.cc b/compiler-rt/test/tsan/ignore_lib3.cc
new file mode 100644
index 0000000..3f7be5c
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib3.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib3.so
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %env_tsan_opts=suppressions='%s.supp' %deflake %run %t | FileCheck %s
+
+// Tests that unloading of a library matched against called_from_lib suppression
+// causes program crash (this is not supported).
+
+// Some aarch64 kernels do not support non executable write pages
+// REQUIRES: stable-runtime
+
+#ifndef LIB
+
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <libgen.h>
+#include <string>
+
+int main(int argc, char **argv) {
+  std::string lib = std::string(dirname(argv[0])) + "/libignore_lib3.so";
+  void *h = dlopen(lib.c_str(), RTLD_GLOBAL | RTLD_NOW);
+  dlclose(h);
+  fprintf(stderr, "OK\n");
+}
+
+#else  // #ifdef LIB
+
+extern "C" void libfunc() {
+}
+
+#endif  // #ifdef LIB
+
+// CHECK: ThreadSanitizer: library {{.*}} that was matched against called_from_lib suppression 'ignore_lib3.so' is unloaded
+// CHECK-NOT: OK
+
diff --git a/compiler-rt/test/tsan/ignore_lib3.cc.supp b/compiler-rt/test/tsan/ignore_lib3.cc.supp
new file mode 100644
index 0000000..975dbce
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib3.cc.supp
@@ -0,0 +1,2 @@
+called_from_lib:ignore_lib3.so
+
diff --git a/compiler-rt/test/tsan/ignore_lib_lib.h b/compiler-rt/test/tsan/ignore_lib_lib.h
new file mode 100644
index 0000000..2bfe84d
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_lib_lib.h
@@ -0,0 +1,25 @@
+#include <pthread.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+void *volatile mem;
+volatile int len;
+
+void *Thread(void *p) {
+  while ((p = __atomic_load_n(&mem, __ATOMIC_ACQUIRE)) == 0)
+    usleep(100);
+  memset(p, 0, len);
+  return 0;
+}
+
+extern "C" void libfunc() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  len = 10;
+  __atomic_store_n(&mem, malloc(len), __ATOMIC_RELEASE);
+  pthread_join(t, 0);
+  free(mem);
+  fprintf(stderr, "OK\n");
+}
diff --git a/compiler-rt/test/tsan/ignore_malloc.cc b/compiler-rt/test/tsan/ignore_malloc.cc
new file mode 100644
index 0000000..100b4e5
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_malloc.cc
@@ -0,0 +1,35 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+extern "C" {
+void AnnotateIgnoreReadsBegin(const char *f, int l);
+void AnnotateIgnoreReadsEnd(const char *f, int l);
+void AnnotateIgnoreWritesBegin(const char *f, int l);
+void AnnotateIgnoreWritesEnd(const char *f, int l);
+}
+
+int *g;
+
+void *Thread(void *a) {
+  int *p = 0;
+  while ((p = __atomic_load_n(&g, __ATOMIC_RELAXED)) == 0)
+    usleep(100);  // spin-wait
+  *p = 42;
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  AnnotateIgnoreWritesBegin(__FILE__, __LINE__);
+  int *p = new int(0);
+  AnnotateIgnoreWritesEnd(__FILE__, __LINE__);
+  __atomic_store_n(&g, p, __ATOMIC_RELAXED);
+  pthread_join(t, 0);
+  delete p;
+  fprintf(stderr, "OK\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: OK
diff --git a/compiler-rt/test/tsan/ignore_race.cc b/compiler-rt/test/tsan/ignore_race.cc
new file mode 100644
index 0000000..cc33b66
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_race.cc
@@ -0,0 +1,31 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+
+extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l);
+extern "C" void AnnotateIgnoreWritesEnd(const char *f, int l);
+extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
+extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l);
+
+void *Thread(void *x) {
+  AnnotateIgnoreWritesBegin(__FILE__, __LINE__);
+  AnnotateIgnoreReadsBegin(__FILE__, __LINE__);
+  Global = 42;
+  AnnotateIgnoreReadsEnd(__FILE__, __LINE__);
+  AnnotateIgnoreWritesEnd(__FILE__, __LINE__);
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  Global = 43;
+  pthread_join(t, 0);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/ignore_sync.cc b/compiler-rt/test/tsan/ignore_sync.cc
new file mode 100644
index 0000000..ae24a8c
--- /dev/null
+++ b/compiler-rt/test/tsan/ignore_sync.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+extern "C" void AnnotateIgnoreSyncBegin(const char*, int);
+extern "C" void AnnotateIgnoreSyncEnd(const char*, int);
+
+int Global;
+pthread_mutex_t Mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void *Thread(void *x) {
+  AnnotateIgnoreSyncBegin(0, 0);
+  pthread_mutex_lock(&Mutex);
+  Global++;
+  pthread_mutex_unlock(&Mutex);
+  AnnotateIgnoreSyncEnd(0, 0);
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_mutex_lock(&Mutex);
+  Global++;
+  pthread_mutex_unlock(&Mutex);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/inlined_memcpy_race.cc b/compiler-rt/test/tsan/inlined_memcpy_race.cc
new file mode 100644
index 0000000..720f2bf
--- /dev/null
+++ b/compiler-rt/test/tsan/inlined_memcpy_race.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <string.h>
+
+int x[4], z[4];
+
+void *MemCpyThread(void *a) {
+  memcpy((int*)a, z, 16);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *MemSetThread(void *a) {
+  barrier_wait(&barrier);
+  memset((int*)a, 0, 16);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  // Race on x between memcpy and memset
+  pthread_create(&t[0], NULL, MemCpyThread, x);
+  pthread_create(&t[1], NULL, MemSetThread, x);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   #0 memset
+// CHECK:   #1 MemSetThread
+// CHECK:  Previous write
+// CHECK:   #0 {{(memcpy|memmove)}}
+// CHECK:   #1 MemCpyThread
+
diff --git a/compiler-rt/test/tsan/inlined_memcpy_race2.cc b/compiler-rt/test/tsan/inlined_memcpy_race2.cc
new file mode 100644
index 0000000..37414ba
--- /dev/null
+++ b/compiler-rt/test/tsan/inlined_memcpy_race2.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <string.h>
+
+int y[4], z[4];
+
+void *MemMoveThread(void *a) {
+  memmove((int*)a, z, 16);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *MemSetThread(void *a) {
+  barrier_wait(&barrier);
+  memset((int*)a, 0, 16);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  // Race on y between memmove and memset
+  pthread_create(&t[0], NULL, MemMoveThread, y);
+  pthread_create(&t[1], NULL, MemSetThread, y);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   #0 memset
+// CHECK:   #1 MemSetThread
+// CHECK:  Previous write
+// CHECK:   #0 memmove
+// CHECK:   #1 MemMoveThread
diff --git a/compiler-rt/test/tsan/interface_atomic_test.c b/compiler-rt/test/tsan/interface_atomic_test.c
new file mode 100644
index 0000000..18d860e
--- /dev/null
+++ b/compiler-rt/test/tsan/interface_atomic_test.c
@@ -0,0 +1,16 @@
+// Test that we can include header with TSan atomic interface.
+// RUN: %clang_tsan %s -o %t && %run %t | FileCheck %s
+#include <sanitizer/tsan_interface_atomic.h>
+#include <stdio.h>
+
+int main() {
+  __tsan_atomic32 a;
+  __tsan_atomic32_store(&a, 100, __tsan_memory_order_release);
+  int res = __tsan_atomic32_load(&a, __tsan_memory_order_acquire);
+  if (res == 100) {
+    // CHECK: PASS
+    printf("PASS\n");
+    return 0;
+  }
+  return 1;
+}
diff --git a/compiler-rt/test/tsan/java.h b/compiler-rt/test/tsan/java.h
new file mode 100644
index 0000000..565a7a7
--- /dev/null
+++ b/compiler-rt/test/tsan/java.h
@@ -0,0 +1,26 @@
+#include "test.h"
+
+extern "C" {
+typedef unsigned long jptr;  // NOLINT
+void __tsan_java_preinit(const char *libjvm_path);
+void __tsan_java_init(jptr heap_begin, jptr heap_size);
+int  __tsan_java_fini();
+void __tsan_java_alloc(jptr ptr, jptr size);
+void __tsan_java_free(jptr ptr, jptr size);
+void __tsan_java_move(jptr src, jptr dst, jptr size);
+void __tsan_java_finalize();
+void __tsan_java_mutex_lock(jptr addr);
+void __tsan_java_mutex_unlock(jptr addr);
+void __tsan_java_mutex_read_lock(jptr addr);
+void __tsan_java_mutex_read_unlock(jptr addr);
+void __tsan_java_mutex_lock_rec(jptr addr, int rec);
+int  __tsan_java_mutex_unlock_rec(jptr addr);
+int  __tsan_java_acquire(jptr addr);
+int  __tsan_java_release(jptr addr);
+int  __tsan_java_release_store(jptr addr);
+
+void __tsan_read1_pc(jptr addr, jptr pc);
+void __tsan_write1_pc(jptr addr, jptr pc);
+}
+
+const jptr kExternalPCBit = 1ULL << 60;
diff --git a/compiler-rt/test/tsan/java_alloc.cc b/compiler-rt/test/tsan/java_alloc.cc
new file mode 100644
index 0000000..4a606f7
--- /dev/null
+++ b/compiler-rt/test/tsan/java_alloc.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+int const kHeapSize = 1024 * 1024;
+
+void stress(jptr addr) {
+  for (jptr sz = 8; sz <= 32; sz <<= 1) {
+    for (jptr i = 0; i < kHeapSize / 4 / sz; i++) {
+      __tsan_java_alloc(addr + i * sz, sz);
+    }
+    __tsan_java_move(addr, addr + kHeapSize / 2, kHeapSize / 4);
+    __tsan_java_free(addr + kHeapSize / 2, kHeapSize / 4);
+  }
+}
+
+void *Thread(void *p) {
+  stress((jptr)p);
+  return 0;
+}
+
+int main() {
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  pthread_t th;
+  pthread_create(&th, 0, Thread, (void*)(jheap + kHeapSize / 4));
+  stress(jheap);
+  pthread_join(th, 0);
+  if (__tsan_java_fini() != 0) {
+    printf("FAILED\n");
+    return 1;
+  }
+  printf("DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: FAILED
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_finalizer.cc b/compiler-rt/test/tsan/java_finalizer.cc
new file mode 100644
index 0000000..acbbf08
--- /dev/null
+++ b/compiler-rt/test/tsan/java_finalizer.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_java_finalize();
+  *(int*)p = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  pthread_t th;
+  pthread_create(&th, 0, Thread, (void*)jheap);
+  *(int*)jheap = 43;
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_heap_init.cc b/compiler-rt/test/tsan/java_heap_init.cc
new file mode 100644
index 0000000..bb7357c
--- /dev/null
+++ b/compiler-rt/test/tsan/java_heap_init.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+#include <errno.h>
+#include <sys/mman.h>
+
+int main() {
+  // Test that munmap interceptor resets meta shadow for the memory range.
+  // Previously __tsan_java_move failed because it encountered non-zero meta
+  // shadow for the destination.
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)mmap(0, kHeapSize, PROT_READ | PROT_WRITE,
+      MAP_ANON | MAP_PRIVATE, -1, 0);
+  if (jheap == (jptr)MAP_FAILED)
+    return printf("mmap failed with %d\n", errno);
+  __atomic_store_n((int*)jheap, 1, __ATOMIC_RELEASE);
+  munmap((void*)jheap, kHeapSize);
+  jheap = (jptr)mmap((void*)jheap, kHeapSize, PROT_READ | PROT_WRITE,
+      MAP_ANON | MAP_PRIVATE, -1, 0);
+  if (jheap == (jptr)MAP_FAILED)
+    return printf("second mmap failed with %d\n", errno);
+  __tsan_java_init(jheap, kHeapSize);
+  __tsan_java_move(jheap + 16, jheap, 16);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_lock.cc b/compiler-rt/test/tsan/java_lock.cc
new file mode 100644
index 0000000..f172052
--- /dev/null
+++ b/compiler-rt/test/tsan/java_lock.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr lockaddr;
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock(lockaddr);
+  *(int*)varaddr = 42;
+  __tsan_java_mutex_unlock(lockaddr);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap;
+  lockaddr = jheap + 8;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  __tsan_java_mutex_lock(lockaddr);
+  *(int*)varaddr = 43;
+  __tsan_java_mutex_unlock(lockaddr);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_lock_move.cc b/compiler-rt/test/tsan/java_lock_move.cc
new file mode 100644
index 0000000..fe5491d
--- /dev/null
+++ b/compiler-rt/test/tsan/java_lock_move.cc
@@ -0,0 +1,43 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr lockaddr;
+jptr varaddr2;
+jptr lockaddr2;
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock(lockaddr2);
+  *(int*)varaddr2 = 42;
+  __tsan_java_mutex_unlock(lockaddr2);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 64;
+  int const kMove = 1024;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap;
+  lockaddr = jheap + 46;
+  varaddr2 = varaddr + kMove;
+  lockaddr2 = lockaddr + kMove;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  __tsan_java_mutex_lock(lockaddr);
+  *(int*)varaddr = 43;
+  __tsan_java_mutex_unlock(lockaddr);
+  __tsan_java_move(varaddr, varaddr2, kBlockSize);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(varaddr2, kBlockSize);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_lock_rec.cc b/compiler-rt/test/tsan/java_lock_rec.cc
new file mode 100644
index 0000000..f0bf401
--- /dev/null
+++ b/compiler-rt/test/tsan/java_lock_rec.cc
@@ -0,0 +1,57 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr lockaddr;
+
+void *Thread(void *p) {
+  __tsan_java_mutex_lock(lockaddr);
+  __tsan_java_mutex_lock(lockaddr);
+  *(int*)varaddr = 42;
+  int rec = __tsan_java_mutex_unlock_rec(lockaddr);
+  if (rec != 2) {
+    printf("FAILED 0 rec=%d\n", rec);
+    exit(1);
+  }
+  barrier_wait(&barrier);
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock_rec(lockaddr, rec);
+  if (*(int*)varaddr != 43) {
+    printf("FAILED 3 var=%d\n", *(int*)varaddr);
+    exit(1);
+  }
+  __tsan_java_mutex_unlock(lockaddr);
+  __tsan_java_mutex_unlock(lockaddr);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap;
+  *(int*)varaddr = 0;
+  lockaddr = jheap + 8;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock(lockaddr);
+  if (*(int*)varaddr != 42) {
+    printf("FAILED 1 var=%d\n", *(int*)varaddr);
+    exit(1);
+  }
+  *(int*)varaddr = 43;
+  __tsan_java_mutex_unlock(lockaddr);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: FAILED
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_lock_rec_race.cc b/compiler-rt/test/tsan/java_lock_rec_race.cc
new file mode 100644
index 0000000..3da8ad0
--- /dev/null
+++ b/compiler-rt/test/tsan/java_lock_rec_race.cc
@@ -0,0 +1,51 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr lockaddr;
+
+void *Thread(void *p) {
+  __tsan_java_mutex_lock(lockaddr);
+  __tsan_java_mutex_lock(lockaddr);
+  __tsan_java_mutex_lock(lockaddr);
+  int rec = __tsan_java_mutex_unlock_rec(lockaddr);
+  if (rec != 3) {
+    printf("FAILED 0 rec=%d\n", rec);
+    exit(1);
+  }
+  *(int*)varaddr = 42;
+  barrier_wait(&barrier);
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock_rec(lockaddr, rec);
+  __tsan_java_mutex_unlock(lockaddr);
+  __tsan_java_mutex_unlock(lockaddr);
+  __tsan_java_mutex_unlock(lockaddr);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap;
+  *(int*)varaddr = 0;
+  lockaddr = jheap + 8;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock(lockaddr);
+  *(int*)varaddr = 43;
+  __tsan_java_mutex_unlock(lockaddr);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: FAILED
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_move_overlap.cc b/compiler-rt/test/tsan/java_move_overlap.cc
new file mode 100644
index 0000000..7ed98ef
--- /dev/null
+++ b/compiler-rt/test/tsan/java_move_overlap.cc
@@ -0,0 +1,74 @@
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+// RUN: %run %t arg 2>&1 | FileCheck %s
+#include "java.h"
+
+jptr varaddr1_old;
+jptr varaddr2_old;
+jptr lockaddr1_old;
+jptr lockaddr2_old;
+jptr varaddr1_new;
+jptr varaddr2_new;
+jptr lockaddr1_new;
+jptr lockaddr2_new;
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_java_mutex_lock(lockaddr1_new);
+  *(char*)varaddr1_new = 43;
+  __tsan_java_mutex_unlock(lockaddr1_new);
+  __tsan_java_mutex_lock(lockaddr2_new);
+  *(char*)varaddr2_new = 43;
+  __tsan_java_mutex_unlock(lockaddr2_new);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  void *jheap = malloc(kHeapSize);
+  jheap = (char*)jheap + 8;
+  __tsan_java_init((jptr)jheap, kHeapSize);
+  const int kBlockSize = 64;
+  int const kMove = 32;
+  varaddr1_old = (jptr)jheap;
+  lockaddr1_old = (jptr)jheap + 1;
+  varaddr2_old = (jptr)jheap + kBlockSize - 1;
+  lockaddr2_old = (jptr)jheap + kBlockSize - 16;
+  varaddr1_new = varaddr1_old + kMove;
+  lockaddr1_new = lockaddr1_old + kMove;
+  varaddr2_new = varaddr2_old + kMove;
+  lockaddr2_new = lockaddr2_old + kMove;
+  if (argc > 1) {
+    // Move memory backwards.
+    varaddr1_old += kMove;
+    lockaddr1_old += kMove;
+    varaddr2_old += kMove;
+    lockaddr2_old += kMove;
+    varaddr1_new -= kMove;
+    lockaddr1_new -= kMove;
+    varaddr2_new -= kMove;
+    lockaddr2_new -= kMove;
+  }
+  __tsan_java_alloc(varaddr1_old, kBlockSize);
+
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+
+  __tsan_java_mutex_lock(lockaddr1_old);
+  *(char*)varaddr1_old = 43;
+  __tsan_java_mutex_unlock(lockaddr1_old);
+  __tsan_java_mutex_lock(lockaddr2_old);
+  *(char*)varaddr2_old = 43;
+  __tsan_java_mutex_unlock(lockaddr2_old);
+
+  __tsan_java_move(varaddr1_old, varaddr1_new, kBlockSize);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(varaddr1_new, kBlockSize);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_move_overlap_race.cc b/compiler-rt/test/tsan/java_move_overlap_race.cc
new file mode 100644
index 0000000..874b90b
--- /dev/null
+++ b/compiler-rt/test/tsan/java_move_overlap_race.cc
@@ -0,0 +1,55 @@
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %deflake %run %t | FileCheck %s
+// RUN: %deflake %run %t arg | FileCheck %s
+#include "java.h"
+
+jptr varaddr1_old;
+jptr varaddr2_old;
+jptr varaddr1_new;
+jptr varaddr2_new;
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  *(int*)varaddr1_new = 43;
+  *(int*)varaddr2_new = 43;
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  void *jheap = malloc(kHeapSize);
+  jheap = (char*)jheap + 8;
+  __tsan_java_init((jptr)jheap, kHeapSize);
+  const int kBlockSize = 64;
+  int const kMove = 32;
+  varaddr1_old = (jptr)jheap;
+  varaddr2_old = (jptr)jheap + kBlockSize - 1;
+  varaddr1_new = varaddr1_old + kMove;
+  varaddr2_new = varaddr2_old + kMove;
+  if (argc > 1) {
+    // Move memory backwards.
+    varaddr1_old += kMove;
+    varaddr2_old += kMove;
+    varaddr1_new -= kMove;
+    varaddr2_new -= kMove;
+  }
+  __tsan_java_alloc(varaddr1_old, kBlockSize);
+
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+
+  *(int*)varaddr1_old = 43;
+  *(int*)varaddr2_old = 43;
+
+  __tsan_java_move(varaddr1_old, varaddr1_new, kBlockSize);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(varaddr1_new, kBlockSize);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_race.cc b/compiler-rt/test/tsan/java_race.cc
new file mode 100644
index 0000000..140a2a3
--- /dev/null
+++ b/compiler-rt/test/tsan/java_race.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "java.h"
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  *(int*)p = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  pthread_t th;
+  pthread_create(&th, 0, Thread, (void*)jheap);
+  *(int*)jheap = 43;
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_race_move.cc b/compiler-rt/test/tsan/java_race_move.cc
new file mode 100644
index 0000000..6d1b092
--- /dev/null
+++ b/compiler-rt/test/tsan/java_race_move.cc
@@ -0,0 +1,35 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr varaddr2;
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  *(int*)varaddr2 = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 64;
+  int const kMove = 1024;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap + 16;
+  varaddr2 = varaddr + kMove;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  *(int*)varaddr = 43;
+  __tsan_java_move(varaddr, varaddr2, kBlockSize);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(varaddr2, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_race_pc.cc b/compiler-rt/test/tsan/java_race_pc.cc
new file mode 100644
index 0000000..0745ade
--- /dev/null
+++ b/compiler-rt/test/tsan/java_race_pc.cc
@@ -0,0 +1,40 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+// This test fails on powerpc64 on both VMA (44 and 46).
+// The Tsan report is returning wrong information about
+// the location of the race.
+// XFAIL: powerpc64
+#include "java.h"
+
+void foobar() {
+}
+
+void barbaz() {
+}
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_read1_pc((jptr)p, (jptr)foobar + 1);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  pthread_t th;
+  pthread_create(&th, 0, Thread, (void*)jheap);
+  __tsan_write1_pc((jptr)jheap, (jptr)barbaz + 1);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:     #0 foobar
+// CHECK:     #0 barbaz
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_rwlock.cc b/compiler-rt/test/tsan/java_rwlock.cc
new file mode 100644
index 0000000..a4cc92a
--- /dev/null
+++ b/compiler-rt/test/tsan/java_rwlock.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr lockaddr;
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_java_mutex_read_lock(lockaddr);
+  *(int*)varaddr = 42;
+  __tsan_java_mutex_read_unlock(lockaddr);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap;
+  lockaddr = jheap + 8;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  __tsan_java_mutex_lock(lockaddr);
+  *(int*)varaddr = 43;
+  __tsan_java_mutex_unlock(lockaddr);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  printf("DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_symbolization.cc b/compiler-rt/test/tsan/java_symbolization.cc
new file mode 100644
index 0000000..aa5ec0c
--- /dev/null
+++ b/compiler-rt/test/tsan/java_symbolization.cc
@@ -0,0 +1,44 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "java.h"
+#include <memory.h>
+
+extern "C" bool __tsan_symbolize_external(jptr pc,
+                                          char *func_buf, jptr func_siz,
+                                          char *file_buf, jptr file_siz,
+                                          int *line, int *col) {
+  if (pc == (1234 | kExternalPCBit)) {
+    memcpy(func_buf, "MyFunc", sizeof("MyFunc"));
+    memcpy(file_buf, "MyFile.java", sizeof("MyFile.java"));
+    *line = 1234;
+    *col = 56;
+    return true;
+  }
+  return false;
+}
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  __tsan_write1_pc((jptr)p, 1234 | kExternalPCBit);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  pthread_t th;
+  pthread_create(&th, 0, Thread, (void*)jheap);
+  __tsan_write1_pc((jptr)jheap, 1234 | kExternalPCBit);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:     #0 MyFunc MyFile.java:1234:56
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/java_volatile.cc b/compiler-rt/test/tsan/java_volatile.cc
new file mode 100644
index 0000000..885b4f2
--- /dev/null
+++ b/compiler-rt/test/tsan/java_volatile.cc
@@ -0,0 +1,42 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "java.h"
+
+jptr varaddr;
+jptr lockaddr;
+
+void *Thread(void *p) {
+  while (__atomic_load_n((int*)lockaddr, __ATOMIC_RELAXED) == 0)
+    usleep(1000);  // spin-wait
+  __tsan_java_acquire(lockaddr);
+  *(int*)varaddr = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int const kHeapSize = 1024 * 1024;
+  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  __tsan_java_init(jheap, kHeapSize);
+  const int kBlockSize = 16;
+  __tsan_java_alloc(jheap, kBlockSize);
+  varaddr = jheap;
+  lockaddr = jheap + 8;
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  *(int*)varaddr = 43;
+  __tsan_java_release(lockaddr);
+  __atomic_store_n((int*)lockaddr, 1, __ATOMIC_RELAXED);
+  pthread_join(th, 0);
+  *(int*)lockaddr = 0;
+  pthread_create(&th, 0, Thread, 0);
+  *(int*)varaddr = 43;
+  __tsan_java_release_store(lockaddr);
+  __atomic_store_n((int*)lockaddr, 1, __ATOMIC_RELAXED);
+  pthread_join(th, 0);
+  __tsan_java_free(jheap, kBlockSize);
+  fprintf(stderr, "DONE\n");
+  return __tsan_java_fini();
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/large_malloc_meta.cc b/compiler-rt/test/tsan/large_malloc_meta.cc
new file mode 100644
index 0000000..e830048
--- /dev/null
+++ b/compiler-rt/test/tsan/large_malloc_meta.cc
@@ -0,0 +1,28 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <sys/mman.h>
+
+// Test for previously unbounded memory consumption for large mallocs.
+// Code allocates a large memory block (that is handled by LargeMmapAllocator),
+// and forces allocation of meta shadow for the block. Then freed the block.
+// But meta shadow was not unmapped. Then code occupies the virtual memory
+// range of the block with something else (that does not need meta shadow).
+// And repeats. As the result meta shadow growed infinitely.
+// This program used to consume >2GB. Now it consumes <50MB.
+
+int main() {
+  for (int i = 0; i < 1000; i++) {
+    const int kSize = 1 << 20;
+    const int kPageSize = 4 << 10;
+    volatile int *p = new int[kSize];
+    for (int j = 0; j < kSize; j += kPageSize / sizeof(*p))
+      __atomic_store_n(&p[i], 1, __ATOMIC_RELEASE);
+    delete[] p;
+    mmap(0, kSize * sizeof(*p) + kPageSize, PROT_NONE, MAP_PRIVATE | MAP_ANON,
+        -1, 0);
+  }
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/libcxx/lit.local.cfg b/compiler-rt/test/tsan/libcxx/lit.local.cfg
new file mode 100644
index 0000000..202b44e
--- /dev/null
+++ b/compiler-rt/test/tsan/libcxx/lit.local.cfg
@@ -0,0 +1,10 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if not root.has_libcxx:
+  config.unsupported = True
+
diff --git a/compiler-rt/test/tsan/libcxx/std_shared_ptr.cc b/compiler-rt/test/tsan/libcxx/std_shared_ptr.cc
new file mode 100644
index 0000000..191a17c
--- /dev/null
+++ b/compiler-rt/test/tsan/libcxx/std_shared_ptr.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+#include <memory>
+#include <thread>
+
+int main() {
+  int v1 = 0;
+  int v2 = 0;
+  std::thread t1;
+  std::thread t2;
+
+  {
+     auto thingy = std::make_shared<int>(42);
+     t1 = std::thread([thingy, &v1] { v1 = *thingy; });
+     t2 = std::thread([thingy, &v2] { v2 = *thingy; });
+  }
+
+  t1.join();
+  t2.join();
+  printf("%d %d\n", v1, v2);
+  // CHECK-NOT: ThreadSanitizer: data race
+  // CHECK: 42 42
+  return 0;
+}
diff --git a/compiler-rt/test/tsan/lit.cfg b/compiler-rt/test/tsan/lit.cfg
new file mode 100644
index 0000000..2be10da
--- /dev/null
+++ b/compiler-rt/test/tsan/lit.cfg
@@ -0,0 +1,81 @@
+# -*- Python -*-
+
+import os
+
+def get_required_attr(config, attr_name):
+  attr_value = getattr(config, attr_name, None)
+  if not attr_value:
+    lit_config.fatal(
+      "No attribute %r in test configuration! You may need to run "
+      "tests from your build directory or add this attribute "
+      "to lit.site.cfg " % attr_name)
+  return attr_value
+
+# Setup config name.
+config.name = 'ThreadSanitizer'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Setup environment variables for running ThreadSanitizer.
+default_tsan_opts = "atexit_sleep_ms=0"
+
+if config.host_os == 'Darwin':
+  # On Darwin, we default to `abort_on_error=1`, which would make tests run
+  # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
+  default_tsan_opts += ':abort_on_error=0'
+
+# Platform-specific default TSAN_OPTIONS for lit tests.
+if default_tsan_opts:
+  config.environment['TSAN_OPTIONS'] = default_tsan_opts
+  default_tsan_opts += ':'
+config.substitutions.append(('%env_tsan_opts=',
+                             'env TSAN_OPTIONS=' + default_tsan_opts))
+
+# GCC driver doesn't add necessary compile/link flags with -fsanitize=thread.
+if config.compiler_id == 'GNU':
+  extra_cflags = ["-fPIE", "-pthread", "-ldl", "-lstdc++", "-lrt", "-pie"]
+else:
+  extra_cflags = []
+
+# Setup default compiler flags used with -fsanitize=thread option.
+clang_tsan_cflags = ["-fsanitize=thread",
+                     "-Wall",
+                     "-m64"] + config.debug_info_flags + extra_cflags
+clang_tsan_cxxflags = config.cxx_mode_flags + clang_tsan_cflags
+# Add additional flags if we're using instrumented libc++.
+# Instrumented libcxx currently not supported on Darwin.
+if config.has_libcxx and config.host_os != 'Darwin':
+  # FIXME: Dehardcode this path somehow.
+  libcxx_path = os.path.join(config.compiler_rt_obj_root, "lib",
+                             "tsan", "libcxx_tsan")
+  libcxx_incdir = os.path.join(libcxx_path, "include", "c++", "v1")
+  libcxx_libdir = os.path.join(libcxx_path, "lib")
+  libcxx_so = os.path.join(libcxx_libdir, "libc++.so")
+  clang_tsan_cxxflags += ["-std=c++11",
+                          "-I%s" % libcxx_incdir,
+                          libcxx_so,
+                          "-Wl,-rpath=%s" % libcxx_libdir]
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang_tsan ", build_invocation(clang_tsan_cflags)) )
+config.substitutions.append( ("%clangxx_tsan ", build_invocation(clang_tsan_cxxflags)) )
+
+# Define CHECK-%os to check for OS-dependent output.
+config.substitutions.append( ('CHECK-%os', ("CHECK-" + config.host_os)))
+
+config.substitutions.append( ("%deflake ", os.path.join(os.path.dirname(__file__), "deflake.bash")) )
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp', '.m', '.mm']
+
+# ThreadSanitizer tests are currently supported on FreeBSD, Linux and Darwin.
+if config.host_os not in ['FreeBSD', 'Linux', 'Darwin']:
+  config.unsupported = True
+
+# Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
+# because the test hangs.
+if config.target_arch != 'aarch64':
+  config.available_features.add('stable-runtime')
diff --git a/compiler-rt/test/tsan/lit.site.cfg.in b/compiler-rt/test/tsan/lit.site.cfg.in
new file mode 100644
index 0000000..5190b21
--- /dev/null
+++ b/compiler-rt/test/tsan/lit.site.cfg.in
@@ -0,0 +1,10 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+config.has_libcxx = @TSAN_HAS_LIBCXX@
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg")
diff --git a/compiler-rt/test/tsan/load_shared_lib.cc b/compiler-rt/test/tsan/load_shared_lib.cc
new file mode 100644
index 0000000..f022808
--- /dev/null
+++ b/compiler-rt/test/tsan/load_shared_lib.cc
@@ -0,0 +1,74 @@
+// Check that if the list of shared libraries changes between the two race
+// reports, the second report occurring in a new shared library is still
+// symbolized correctly.
+
+// RUN: %clangxx_tsan -O1 %s -DBUILD_SO -fPIC -shared -o %t-so.so
+// RUN: %clangxx_tsan -O1 %s -o %t -rdynamic && %deflake %run %t | FileCheck %s
+
+#ifdef BUILD_SO
+
+#include "test.h"
+
+int GLOB_SHARED = 0;
+
+extern "C"
+void init_so() {
+  barrier_init(&barrier, 2);
+}
+
+extern "C"
+void *write_from_so(void *unused) {
+  if (unused == 0)
+    barrier_wait(&barrier);
+  GLOB_SHARED++;
+  if (unused != 0)
+    barrier_wait(&barrier);
+  return NULL;
+}
+
+#else  // BUILD_SO
+
+#include "test.h"
+#include <dlfcn.h>
+#include <string>
+
+int GLOB = 0;
+
+void *write_glob(void *unused) {
+  if (unused == 0)
+    barrier_wait(&barrier);
+  GLOB++;
+  if (unused != 0)
+    barrier_wait(&barrier);
+  return NULL;
+}
+
+void race_two_threads(void *(*access_callback)(void *unused)) {
+  pthread_t t1, t2;
+  pthread_create(&t1, NULL, access_callback, (void*)1);
+  pthread_create(&t2, NULL, access_callback, NULL);
+  pthread_join(t1, NULL);
+  pthread_join(t2, NULL);
+}
+
+int main(int argc, char *argv[]) {
+  barrier_init(&barrier, 2);
+  std::string path = std::string(argv[0]) + std::string("-so.so");
+  race_two_threads(write_glob);
+  // CHECK: write_glob
+  void *lib = dlopen(path.c_str(), RTLD_NOW);
+    if (!lib) {
+    printf("error in dlopen(): %s\n", dlerror());
+    return 1;
+  }
+  void (*init_so)();
+  *(void **)&init_so = dlsym(lib, "init_so");
+  init_so();
+  void *(*write_from_so)(void *unused);
+  *(void **)&write_from_so = dlsym(lib, "write_from_so");
+  race_two_threads(write_from_so);
+  // CHECK: write_from_so
+  return 0;
+}
+
+#endif  // BUILD_SO
diff --git a/compiler-rt/test/tsan/longjmp.cc b/compiler-rt/test/tsan/longjmp.cc
new file mode 100644
index 0000000..d642067
--- /dev/null
+++ b/compiler-rt/test/tsan/longjmp.cc
@@ -0,0 +1,26 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Longjmp assembly has not been implemented for mips64 yet
+// XFAIL: mips64
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+int foo(jmp_buf env) {
+  longjmp(env, 42);
+}
+
+int main() {
+  jmp_buf env;
+  if (setjmp(env) == 42) {
+    printf("JUMPED\n");
+    return 0;
+  }
+  foo(env);
+  printf("FAILED\n");
+  return 0;
+}
+
+// CHECK-NOT: FAILED
+// CHECK: JUMPED
diff --git a/compiler-rt/test/tsan/longjmp2.cc b/compiler-rt/test/tsan/longjmp2.cc
new file mode 100644
index 0000000..eee423d
--- /dev/null
+++ b/compiler-rt/test/tsan/longjmp2.cc
@@ -0,0 +1,28 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Longjmp assembly has not been implemented for mips64 yet
+// XFAIL: mips64
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+int foo(sigjmp_buf env) {
+  printf("env=%p\n", env);
+  siglongjmp(env, 42);
+}
+
+int main() {
+  sigjmp_buf env;
+  printf("env=%p\n", env);
+  if (sigsetjmp(env, 1) == 42) {
+    printf("JUMPED\n");
+    return 0;
+  }
+  foo(env);
+  printf("FAILED\n");
+  return 0;
+}
+
+// CHECK-NOT: FAILED
+// CHECK: JUMPED
diff --git a/compiler-rt/test/tsan/longjmp3.cc b/compiler-rt/test/tsan/longjmp3.cc
new file mode 100644
index 0000000..79965c4
--- /dev/null
+++ b/compiler-rt/test/tsan/longjmp3.cc
@@ -0,0 +1,52 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+
+// Longjmp assembly has not been implemented for mips64 yet
+// XFAIL: mips64
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+void bar(jmp_buf env) {
+  volatile int x = 42;
+  longjmp(env, 42);
+  x++;
+}
+
+void foo(jmp_buf env) {
+  volatile int x = 42;
+  bar(env);
+  x++;
+}
+
+void badguy() {
+  pthread_mutex_t mtx;
+  pthread_mutex_init(&mtx, 0);
+  pthread_mutex_lock(&mtx);
+  pthread_mutex_destroy(&mtx);
+}
+
+void mymain() {
+  jmp_buf env;
+  if (setjmp(env) == 42) {
+    badguy();
+    return;
+  }
+  foo(env);
+  printf("FAILED\n");
+}
+
+int main() {
+  volatile int x = 42;
+  mymain();
+  return x;
+}
+
+// CHECK-NOT: FAILED
+// CHECK: WARNING: ThreadSanitizer: destroy of a locked mutex
+// CHECK:   #0 pthread_mutex_destroy
+// CHECK:   #1 badguy
+// CHECK:   #2 mymain
+// CHECK:   #3 main
+
diff --git a/compiler-rt/test/tsan/longjmp4.cc b/compiler-rt/test/tsan/longjmp4.cc
new file mode 100644
index 0000000..c858399
--- /dev/null
+++ b/compiler-rt/test/tsan/longjmp4.cc
@@ -0,0 +1,55 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+
+// Longjmp assembly has not been implemented for mips64 yet
+// XFAIL: mips64
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <string.h>
+
+void bar(jmp_buf env) {
+  volatile int x = 42;
+  jmp_buf env2;
+  memcpy(env2, env, sizeof(jmp_buf));
+  longjmp(env2, 42);
+  x++;
+}
+
+void foo(jmp_buf env) {
+  volatile int x = 42;
+  bar(env);
+  x++;
+}
+
+void badguy() {
+  pthread_mutex_t mtx;
+  pthread_mutex_init(&mtx, 0);
+  pthread_mutex_lock(&mtx);
+  pthread_mutex_destroy(&mtx);
+}
+
+void mymain() {
+  jmp_buf env;
+  if (setjmp(env) == 42) {
+    badguy();
+    return;
+  }
+  foo(env);
+  printf("FAILED\n");
+}
+
+int main() {
+  volatile int x = 42;
+  mymain();
+  return x;
+}
+
+// CHECK-NOT: FAILED
+// CHECK: WARNING: ThreadSanitizer: destroy of a locked mutex
+// CHECK:   #0 pthread_mutex_destroy
+// CHECK:   #1 badguy
+// CHECK:   #2 mymain
+// CHECK:   #3 main
+
diff --git a/compiler-rt/test/tsan/malloc_overflow.cc b/compiler-rt/test/tsan/malloc_overflow.cc
new file mode 100644
index 0000000..b2f9b0f
--- /dev/null
+++ b/compiler-rt/test/tsan/malloc_overflow.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %env_tsan_opts=allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  void *p = malloc((size_t)-1);
+  if (p != 0)
+    printf("FAIL malloc(-1) = %p\n", p);
+  p = malloc((size_t)-1 / 2);
+  if (p != 0)
+    printf("FAIL malloc(-1/2) = %p\n", p);
+  p = calloc((size_t)-1, (size_t)-1);
+  if (p != 0)
+    printf("FAIL calloc(-1, -1) = %p\n", p);
+  p = calloc((size_t)-1 / 2, (size_t)-1 / 2);
+  if (p != 0)
+    printf("FAIL calloc(-1/2, -1/2) = %p\n", p);
+  printf("OK\n");
+}
+
+// CHECK-NOT: FAIL
+// CHECK-NOT: failed to allocate
diff --git a/compiler-rt/test/tsan/malloc_stack.cc b/compiler-rt/test/tsan/malloc_stack.cc
new file mode 100644
index 0000000..f0c6f93
--- /dev/null
+++ b/compiler-rt/test/tsan/malloc_stack.cc
@@ -0,0 +1,26 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+_Atomic(int*) p;
+
+void *thr(void *a) {
+  barrier_wait(&barrier);
+  int *pp = __c11_atomic_load(&p, __ATOMIC_RELAXED);
+  *pp = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t th;
+  pthread_create(&th, 0, thr, p);
+  __c11_atomic_store(&p, new int, __ATOMIC_RELAXED);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+}
+
+// CHECK: data race
+// CHECK:   Previous write
+// CHECK:     #0 operator new
+// CHECK:   Location is heap block
+// CHECK:     #0 operator new
diff --git a/compiler-rt/test/tsan/map32bit.cc b/compiler-rt/test/tsan/map32bit.cc
new file mode 100644
index 0000000..0411f29
--- /dev/null
+++ b/compiler-rt/test/tsan/map32bit.cc
@@ -0,0 +1,48 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <stdint.h>
+#include <errno.h>
+#include <sys/mman.h>
+
+// Test for issue:
+// https://github.com/google/sanitizers/issues/412
+
+// MAP_32BIT flag for mmap is supported only for x86_64.
+// XFAIL: mips64
+// XFAIL: aarch64
+// XFAIL: powerpc64
+
+// MAP_32BIT doesn't exist on OS X.
+// UNSUPPORTED: darwin
+
+void *Thread(void *ptr) {
+  *(int*)ptr = 42;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  void *ptr = mmap(0, 128 << 10, PROT_READ|PROT_WRITE,
+      MAP_32BIT|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+  fprintf(stderr, "ptr=%p\n", ptr);
+  if (ptr == MAP_FAILED) {
+    fprintf(stderr, "mmap failed: %d\n", errno);
+    return 1;
+  }
+  if ((uintptr_t)ptr >= (1ull << 32)) {
+    fprintf(stderr, "ptr is too high\n");
+    return 1;
+  }
+  pthread_t t;
+  pthread_create(&t, 0, Thread, ptr);
+  barrier_wait(&barrier);
+  *(int*)ptr = 42;
+  pthread_join(t, 0);
+  munmap(ptr, 128 << 10);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/memcmp_race.cc b/compiler-rt/test/tsan/memcmp_race.cc
new file mode 100644
index 0000000..b76f427
--- /dev/null
+++ b/compiler-rt/test/tsan/memcmp_race.cc
@@ -0,0 +1,42 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <string.h>
+
+char *data0 = new char[10];
+char *data1 = new char[10];
+char *data2 = new char[10];
+
+void *Thread1(void *x) {
+  static volatile int size = 1;
+  static volatile int sink;
+  sink = memcmp(data0+5, data1, size);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  static volatile int size = 4;
+  barrier_wait(&barrier);
+  memcpy(data0+5, data2, size);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr=", 1, &data0[5]);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  return 0;
+}
+
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 1 at [[ADDR]] by thread T2:
+// CHECK:     #0 {{(memcpy|memmove)}}
+// CHECK:     #1 Thread2
+// CHECK:   Previous read of size 1 at [[ADDR]] by thread T1:
+// CHECK:     #0 memcmp
+// CHECK:     #1 Thread1
diff --git a/compiler-rt/test/tsan/memcpy_race.cc b/compiler-rt/test/tsan/memcpy_race.cc
new file mode 100644
index 0000000..4a098c0
--- /dev/null
+++ b/compiler-rt/test/tsan/memcpy_race.cc
@@ -0,0 +1,41 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <string.h>
+
+char *data = new char[10];
+char *data1 = new char[10];
+char *data2 = new char[10];
+
+void *Thread1(void *x) {
+  static volatile int size = 1;
+  memcpy(data+5, data1, size);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  static volatile int size = 4;
+  barrier_wait(&barrier);
+  memcpy(data+3, data2, size);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  print_address("addr=", 1, &data[5]);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  return 0;
+}
+
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 1 at [[ADDR]] by thread T2:
+// CHECK:     #0 {{(memcpy|memmove)}}
+// CHECK:     #1 Thread2
+// CHECK:   Previous write of size 1 at [[ADDR]] by thread T1:
+// CHECK:     #0 {{(memcpy|memmove)}}
+// CHECK:     #1 Thread1
diff --git a/compiler-rt/test/tsan/mmap_large.cc b/compiler-rt/test/tsan/mmap_large.cc
new file mode 100644
index 0000000..764e954
--- /dev/null
+++ b/compiler-rt/test/tsan/mmap_large.cc
@@ -0,0 +1,33 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <stdint.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/mman.h>
+
+#if defined(__FreeBSD__)
+// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
+// that, it was never implemented.  So just define it to zero.
+#undef  MAP_NORESERVE
+#define MAP_NORESERVE 0
+#endif
+
+int main() {
+#ifdef __x86_64__
+  const size_t kLog2Size = 39;
+#elif defined(__mips64) || defined(__aarch64__)
+  const size_t kLog2Size = 32;
+#elif defined(__powerpc64__)
+  const size_t kLog2Size = 39;
+#endif
+  const uintptr_t kLocation = 0x40ULL << kLog2Size;
+  void *p = mmap(
+      reinterpret_cast<void*>(kLocation),
+      1ULL << kLog2Size,
+      PROT_READ|PROT_WRITE,
+      MAP_PRIVATE|MAP_ANON|MAP_NORESERVE,
+      -1, 0);
+  fprintf(stderr, "DONE %p %d\n", p, errno);
+  return p == MAP_FAILED;
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/mmap_stress.cc b/compiler-rt/test/tsan/mmap_stress.cc
new file mode 100644
index 0000000..5e3904a
--- /dev/null
+++ b/compiler-rt/test/tsan/mmap_stress.cc
@@ -0,0 +1,47 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <errno.h>
+#include <sys/mman.h>
+
+void *SubWorker(void *arg) {
+  (void)arg;
+  const int kMmapSize =  65536;
+  for (int i = 0; i < 500; i++) {
+    int *ptr = (int*)mmap(0, kMmapSize, PROT_READ | PROT_WRITE,
+                          MAP_PRIVATE | MAP_ANON, -1, 0);
+    *ptr = 42;
+    munmap(ptr, kMmapSize);
+  }
+  return 0;
+}
+
+void *Worker1(void *arg) {
+  (void)arg;
+  pthread_t th[4];
+  for (int i = 0; i < 4; i++)
+    pthread_create(&th[i], 0, SubWorker, 0);
+  for (int i = 0; i < 4; i++)
+    pthread_join(th[i], 0);
+  return 0;
+}
+
+void *Worker(void *arg) {
+  (void)arg;
+  pthread_t th[4];
+  for (int i = 0; i < 4; i++)
+    pthread_create(&th[i], 0, Worker1, 0);
+  for (int i = 0; i < 4; i++)
+    pthread_join(th[i], 0);
+  return 0;
+}
+
+int main() {
+  pthread_t th[4];
+  for (int i = 0; i < 4; i++)
+    pthread_create(&th[i], 0, Worker, 0);
+  for (int i = 0; i < 4; i++)
+    pthread_join(th[i], 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/mop1.c b/compiler-rt/test/tsan/mop1.c
new file mode 100644
index 0000000..e61c5b8
--- /dev/null
+++ b/compiler-rt/test/tsan/mop1.c
@@ -0,0 +1,40 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+// We want to establish the following sequence of accesses to X:
+// - main thread writes X
+// - thread2 reads X, this read happens-before the write in main thread
+// - thread1 reads X, this read is concurrent with the write in main thread
+// Write in main thread and read in thread1 should be detected as a race.
+// Previously tsan replaced write by main thread with read by thread1,
+// as the result the race was not detected.
+
+volatile long X, Y, Z;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  barrier_wait(&barrier);
+  Y = X;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Z = X;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  X = 42;
+  barrier_wait(&barrier);
+  pthread_create(&t[1], 0, Thread2, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/mop_with_offset.cc b/compiler-rt/test/tsan/mop_with_offset.cc
new file mode 100644
index 0000000..e2496d0
--- /dev/null
+++ b/compiler-rt/test/tsan/mop_with_offset.cc
@@ -0,0 +1,35 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread1(void *x) {
+  int *p = (int*)x;
+  p[0] = 1;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  char *p = (char*)x;
+  p[2] = 1;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int *data = new int(42);
+  print_address("ptr1=", 1, data);
+  print_address("ptr2=", 1, (char*)data + 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, data);
+  pthread_create(&t[1], NULL, Thread2, data);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  delete data;
+}
+
+// CHECK: ptr1=[[PTR1:0x[0-9,a-f]+]]
+// CHECK: ptr2=[[PTR2:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 1 at [[PTR2]] by thread T2:
+// CHECK:   Previous write of size 4 at [[PTR1]] by thread T1:
diff --git a/compiler-rt/test/tsan/mop_with_offset2.cc b/compiler-rt/test/tsan/mop_with_offset2.cc
new file mode 100644
index 0000000..73c53f5
--- /dev/null
+++ b/compiler-rt/test/tsan/mop_with_offset2.cc
@@ -0,0 +1,35 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  int *p = (int*)x;
+  p[0] = 1;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  char *p = (char*)x;
+  p[2] = 1;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int *data = new int(42);
+  print_address("ptr1=", 1, data);
+  print_address("ptr2=", 1, (char*)data + 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, data);
+  pthread_create(&t[1], NULL, Thread2, data);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  delete data;
+}
+
+// CHECK: ptr1=[[PTR1:0x[0-9,a-f]+]]
+// CHECK: ptr2=[[PTR2:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 4 at [[PTR1]] by thread T1:
+// CHECK:   Previous write of size 1 at [[PTR2]] by thread T2:
diff --git a/compiler-rt/test/tsan/must_deadlock.cc b/compiler-rt/test/tsan/must_deadlock.cc
new file mode 100644
index 0000000..1409800
--- /dev/null
+++ b/compiler-rt/test/tsan/must_deadlock.cc
@@ -0,0 +1,50 @@
+// Test that the deadlock detector can find a deadlock that actually happened.
+// Currently we will fail to report such a deadlock because we check for
+// cycles in lock-order graph after pthread_mutex_lock.
+
+// RUN: %clangxx_tsan %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// XFAIL: *
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+
+pthread_mutex_t mu1, mu2;
+pthread_barrier_t barrier;
+
+void *Thread(void *p) {
+  // mu2 => mu1
+  pthread_mutex_lock(&mu2);
+  pthread_barrier_wait(&barrier);
+  pthread_mutex_lock(&mu1);
+  // CHECK: ThreadSanitizer: lock-order-inversion (potential deadlock)
+  pthread_mutex_unlock(&mu1);
+  pthread_mutex_unlock(&mu2);
+  return p;
+}
+
+int main() {
+  pthread_mutex_init(&mu1, NULL);
+  pthread_mutex_init(&mu2, NULL);
+  pthread_barrier_init(&barrier, 0, 2);
+
+  fprintf(stderr, "This test is going to deadlock and die in 3 seconds\n");
+  alarm(3);
+
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+
+  // mu1 => mu2
+  pthread_mutex_lock(&mu1);
+  pthread_barrier_wait(&barrier);
+  pthread_mutex_lock(&mu2);
+  pthread_mutex_unlock(&mu2);
+  pthread_mutex_unlock(&mu1);
+
+  pthread_join(t, 0);
+
+  pthread_mutex_destroy(&mu1);
+  pthread_mutex_destroy(&mu2);
+  pthread_barrier_destroy(&barrier);
+  fprintf(stderr, "FAILED\n");
+}
diff --git a/compiler-rt/test/tsan/mutex_bad_read_lock.cc b/compiler-rt/test/tsan/mutex_bad_read_lock.cc
new file mode 100644
index 0000000..84a2976
--- /dev/null
+++ b/compiler-rt/test/tsan/mutex_bad_read_lock.cc
@@ -0,0 +1,19 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
+
+int main() {
+  int m = 0;
+  AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 1);
+  AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: read lock of a write locked mutex
+// CHECK:     #0 AnnotateRWLockAcquired
+// CHECK:     #1 main
+// CHECK: Location is stack of main thread.
+// CHECK:   Mutex {{.*}}) created at:
+// CHECK:     #0 AnnotateRWLockAcquired
+// CHECK:     #1 main
+// CHECK: SUMMARY: ThreadSanitizer: read lock of a write locked mutex
+
diff --git a/compiler-rt/test/tsan/mutex_bad_read_unlock.cc b/compiler-rt/test/tsan/mutex_bad_read_unlock.cc
new file mode 100644
index 0000000..dcee515
--- /dev/null
+++ b/compiler-rt/test/tsan/mutex_bad_read_unlock.cc
@@ -0,0 +1,20 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
+extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw);
+
+int main() {
+  int m = 0;
+  AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 1);
+  AnnotateRWLockReleased(__FILE__, __LINE__, &m, 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: read unlock of a write locked mutex
+// CHECK:     #0 AnnotateRWLockReleased
+// CHECK:     #1 main
+// CHECK: Location is stack of main thread.
+// CHECK:   Mutex {{.*}}) created at:
+// CHECK:     #0 AnnotateRWLockAcquired
+// CHECK:     #1 main
+// CHECK: SUMMARY: ThreadSanitizer: read unlock of a write locked mutex
+
diff --git a/compiler-rt/test/tsan/mutex_bad_unlock.cc b/compiler-rt/test/tsan/mutex_bad_unlock.cc
new file mode 100644
index 0000000..6b483cf
--- /dev/null
+++ b/compiler-rt/test/tsan/mutex_bad_unlock.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw);
+
+int main() {
+  int m = 0;
+  AnnotateRWLockReleased(__FILE__, __LINE__, &m, 1);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: unlock of an unlocked mutex (or by a wrong thread)
+// CHECK:     #0 AnnotateRWLockReleased
+// CHECK:     #1 main
+// CHECK: Location is stack of main thread.
+// CHECK:   Mutex {{.*}} created at:
+// CHECK:     #0 AnnotateRWLockReleased
+// CHECK:     #1 main
+// CHECK: SUMMARY: ThreadSanitizer: unlock of an unlocked mutex (or by a wrong thread)
+
diff --git a/compiler-rt/test/tsan/mutex_cycle2.c b/compiler-rt/test/tsan/mutex_cycle2.c
new file mode 100644
index 0000000..32659d4
--- /dev/null
+++ b/compiler-rt/test/tsan/mutex_cycle2.c
@@ -0,0 +1,35 @@
+// RUN: %clangxx_tsan %s -o %t
+// RUN:                                 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_tsan_opts=detect_deadlocks=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_tsan_opts=detect_deadlocks=0     %run %t 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: echo "deadlock:main" > %t.supp
+// RUN: %env_tsan_opts=suppressions='%t.supp' %run %t 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: echo "deadlock:zzzz" > %t.supp
+// RUN: %env_tsan_opts=suppressions='%t.supp' not %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+int main() {
+  pthread_mutex_t mu1, mu2;
+  pthread_mutex_init(&mu1, NULL);
+  pthread_mutex_init(&mu2, NULL);
+
+  // mu1 => mu2
+  pthread_mutex_lock(&mu1);
+  pthread_mutex_lock(&mu2);
+  pthread_mutex_unlock(&mu2);
+  pthread_mutex_unlock(&mu1);
+
+  // mu2 => mu1
+  pthread_mutex_lock(&mu2);
+  pthread_mutex_lock(&mu1);
+  // CHECK: ThreadSanitizer: lock-order-inversion (potential deadlock)
+  // DISABLED-NOT: ThreadSanitizer
+  // DISABLED: PASS
+  pthread_mutex_unlock(&mu1);
+  pthread_mutex_unlock(&mu2);
+
+  pthread_mutex_destroy(&mu1);
+  pthread_mutex_destroy(&mu2);
+  fprintf(stderr, "PASS\n");
+}
diff --git a/compiler-rt/test/tsan/mutex_destroy_locked.cc b/compiler-rt/test/tsan/mutex_destroy_locked.cc
new file mode 100644
index 0000000..b81905e
--- /dev/null
+++ b/compiler-rt/test/tsan/mutex_destroy_locked.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <unistd.h>
+
+int main() {
+  pthread_mutex_t m;
+  pthread_mutex_init(&m, 0);
+  pthread_mutex_lock(&m);
+  pthread_mutex_destroy(&m);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: destroy of a locked mutex
+// CHECK:     #0 pthread_mutex_destroy
+// CHECK:     #1 main
+// CHECK:   and:
+// CHECK:     #0 pthread_mutex_lock
+// CHECK:     #1 main
+// CHECK:   Mutex {{.*}} created at:
+// CHECK:     #0 pthread_mutex_init
+// CHECK:     #1 main
+// CHECK: SUMMARY: ThreadSanitizer: destroy of a locked mutex{{.*}}main
diff --git a/compiler-rt/test/tsan/mutex_double_lock.cc b/compiler-rt/test/tsan/mutex_double_lock.cc
new file mode 100644
index 0000000..c1bebf7
--- /dev/null
+++ b/compiler-rt/test/tsan/mutex_double_lock.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <unistd.h>
+
+extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
+
+void *ThreadFunc(void *m) {
+  AnnotateRWLockAcquired(__FILE__, __LINE__, m, 1);
+  return 0;
+}
+
+int main() {
+  int m = 0;
+  AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 1);
+  pthread_t th;
+  pthread_create(&th, 0, ThreadFunc, &m);
+  pthread_join(th, 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: double lock of a mutex
+// CHECK:     #0 AnnotateRWLockAcquired
+// CHECK:     #1 ThreadFunc
+// CHECK: Location is stack of main thread.
+// CHECK:   Mutex {{.*}} created at:
+// CHECK:     #0 AnnotateRWLockAcquired
+// CHECK:     #1 main
+// CHECK: SUMMARY: ThreadSanitizer: double lock of a mutex {{.*}}mutex_double_lock.cc{{.*}}ThreadFunc
+
diff --git a/compiler-rt/test/tsan/mutexset1.cc b/compiler-rt/test/tsan/mutexset1.cc
new file mode 100644
index 0000000..8403b34
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset1.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&mtx);
+  Global++;
+  pthread_mutex_unlock(&mtx);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global--;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK:   Write of size 4 at {{.*}} by thread T1
+  // CHECK:                         (mutexes: write [[M1:M[0-9]+]]):
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T2:
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset1.cc:[[@LINE+1]]
+  pthread_mutex_init(&mtx, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&mtx);
+}
diff --git a/compiler-rt/test/tsan/mutexset2.cc b/compiler-rt/test/tsan/mutexset2.cc
new file mode 100644
index 0000000..5f7c0c4
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset2.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx;
+
+void *Thread1(void *x) {
+  pthread_mutex_lock(&mtx);
+  Global++;
+  pthread_mutex_unlock(&mtx);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  Global--;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK:   Write of size 4 at {{.*}} by thread T2:
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T1
+  // CHECK:                     (mutexes: write [[M1:M[0-9]+]]):
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset2.cc:[[@LINE+1]]
+  pthread_mutex_init(&mtx, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&mtx);
+}
diff --git a/compiler-rt/test/tsan/mutexset3.cc b/compiler-rt/test/tsan/mutexset3.cc
new file mode 100644
index 0000000..24a9d9b
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset3.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx1;
+pthread_mutex_t mtx2;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&mtx1);
+  pthread_mutex_lock(&mtx2);
+  Global++;
+  pthread_mutex_unlock(&mtx2);
+  pthread_mutex_unlock(&mtx1);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global--;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK: Write of size 4 at {{.*}} by thread T1
+  // CHECK:               (mutexes: write [[M1:M[0-9]+]], write [[M2:M[0-9]+]]):
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T2:
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset3.cc:[[@LINE+4]]
+  // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset3.cc:[[@LINE+2]]
+  pthread_mutex_init(&mtx1, 0);
+  pthread_mutex_init(&mtx2, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&mtx1);
+  pthread_mutex_destroy(&mtx2);
+}
diff --git a/compiler-rt/test/tsan/mutexset4.cc b/compiler-rt/test/tsan/mutexset4.cc
new file mode 100644
index 0000000..5d8ea9e
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset4.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx1;
+pthread_mutex_t mtx2;
+
+void *Thread1(void *x) {
+  pthread_mutex_lock(&mtx1);
+  pthread_mutex_lock(&mtx2);
+  Global++;
+  pthread_mutex_unlock(&mtx2);
+  pthread_mutex_unlock(&mtx1);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  Global--;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK:   Write of size 4 at {{.*}} by thread T2:
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T1
+  // CHECK:                 (mutexes: write [[M1:M[0-9]+]], write [[M2:M[0-9]+]]):
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset4.cc:[[@LINE+4]]
+  // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset4.cc:[[@LINE+2]]
+  pthread_mutex_init(&mtx1, 0);
+  pthread_mutex_init(&mtx2, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&mtx1);
+  pthread_mutex_destroy(&mtx2);
+}
diff --git a/compiler-rt/test/tsan/mutexset5.cc b/compiler-rt/test/tsan/mutexset5.cc
new file mode 100644
index 0000000..b5f4e77
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset5.cc
@@ -0,0 +1,46 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx1;
+pthread_mutex_t mtx2;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&mtx1);
+  Global++;
+  pthread_mutex_unlock(&mtx1);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  pthread_mutex_lock(&mtx2);
+  Global--;
+  pthread_mutex_unlock(&mtx2);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK:   Write of size 4 at {{.*}} by thread T1
+  // CHECK:                              (mutexes: write [[M1:M[0-9]+]]):
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T2
+  // CHECK:                              (mutexes: write [[M2:M[0-9]+]]):
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset5.cc:[[@LINE+4]]
+  // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset5.cc:[[@LINE+5]]
+  pthread_mutex_init(&mtx1, 0);
+  pthread_mutex_init(&mtx2, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&mtx1);
+  pthread_mutex_destroy(&mtx2);
+}
diff --git a/compiler-rt/test/tsan/mutexset6.cc b/compiler-rt/test/tsan/mutexset6.cc
new file mode 100644
index 0000000..ca349aa
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset6.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx1;
+pthread_mutex_t mtx2;
+pthread_rwlock_t mtx3;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&mtx1);
+  Global++;
+  pthread_mutex_unlock(&mtx1);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  pthread_mutex_lock(&mtx1);
+  pthread_mutex_unlock(&mtx1);
+  pthread_mutex_lock(&mtx2);
+  pthread_rwlock_rdlock(&mtx3);
+  Global--;
+  pthread_mutex_unlock(&mtx2);
+  pthread_rwlock_unlock(&mtx3);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK:   Write of size 4 at {{.*}} by thread T1
+  // CHECK:                          (mutexes: write [[M1:M[0-9]+]]):
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T2
+  // CHECK:               (mutexes: write [[M2:M[0-9]+]], read [[M3:M[0-9]+]]):
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #1 main {{.*}}mutexset6.cc:[[@LINE+5]]
+  // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
+  // CHECK:     #1 main {{.*}}mutexset6.cc:[[@LINE+4]]
+  // CHECK:   Mutex [[M3]] (0x{{.*}}) created at:
+  // CHECK:     #1 main {{.*}}mutexset6.cc:[[@LINE+3]]
+  pthread_mutex_init(&mtx1, 0);
+  pthread_mutex_init(&mtx2, 0);
+  pthread_rwlock_init(&mtx3, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&mtx1);
+  pthread_mutex_destroy(&mtx2);
+  pthread_rwlock_destroy(&mtx3);
+}
diff --git a/compiler-rt/test/tsan/mutexset7.cc b/compiler-rt/test/tsan/mutexset7.cc
new file mode 100644
index 0000000..d3a221d
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset7.cc
@@ -0,0 +1,40 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+__thread int huge[1024*1024];
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  Global++;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  pthread_mutex_t *mtx = new pthread_mutex_t;
+  pthread_mutex_init(mtx, 0);
+  pthread_mutex_lock(mtx);
+  Global--;
+  pthread_mutex_unlock(mtx);
+  pthread_mutex_destroy(mtx);
+  delete mtx;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: Write of size 4 at {{.*}} by thread T1:
+// CHECK: Previous write of size 4 at {{.*}} by thread T2
+// CHECK:                                      (mutexes: write [[M1:M[0-9]+]]):
+// CHECK: Mutex [[M1]] is already destroyed
+// CHECK-NOT: Mutex {{.*}} created at
+
diff --git a/compiler-rt/test/tsan/mutexset8.cc b/compiler-rt/test/tsan/mutexset8.cc
new file mode 100644
index 0000000..69854e2
--- /dev/null
+++ b/compiler-rt/test/tsan/mutexset8.cc
@@ -0,0 +1,39 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+pthread_mutex_t *mtx;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(mtx);
+  Global++;
+  pthread_mutex_unlock(mtx);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global--;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  // CHECK: WARNING: ThreadSanitizer: data race
+  // CHECK:   Write of size 4 at {{.*}} by thread T1
+  // CHECK:                         (mutexes: write [[M1:M[0-9]+]]):
+  // CHECK:   Previous write of size 4 at {{.*}} by thread T2:
+  // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
+  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #1 main {{.*}}mutexset8.cc
+  mtx = new pthread_mutex_t;
+  pthread_mutex_init(mtx, 0);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(mtx);
+  delete mtx;
+}
diff --git a/compiler-rt/test/tsan/pie_test.cc b/compiler-rt/test/tsan/pie_test.cc
new file mode 100644
index 0000000..8635f9c
--- /dev/null
+++ b/compiler-rt/test/tsan/pie_test.cc
@@ -0,0 +1,12 @@
+// Check if tsan work with PIE binaries.
+// RUN: %clang_tsan %s -pie -fpic -o %t && %run %t
+
+// Some kernels might map PIE segments outside the current segment
+// mapping defined for x86 [1].
+// [1] https://git.kernel.org/linus/d1fd836dcf00d2028c700c7e44d2c23404062c90
+
+// UNSUPPORTED: x86
+
+int main(void) {
+  return 0;
+}
diff --git a/compiler-rt/test/tsan/printf-1.c b/compiler-rt/test/tsan/printf-1.c
new file mode 100644
index 0000000..9116c95
--- /dev/null
+++ b/compiler-rt/test/tsan/printf-1.c
@@ -0,0 +1,16 @@
+// RUN: %clang_tsan -O2 %s -o %t
+// RUN: ASAN_OPTIONS=check_printf=1 %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=check_printf=0 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+int main() {
+  volatile char c = '0';
+  volatile int x = 12;
+  volatile float f = 1.239;
+  volatile char s[] = "34";
+  printf("%c %d %.3f %s\n", c, x, f, s);
+  return 0;
+  // Check that printf works fine under Tsan.
+  // CHECK: 0 12 1.239 34
+}
diff --git a/compiler-rt/test/tsan/pthread_atfork_deadlock.c b/compiler-rt/test/tsan/pthread_atfork_deadlock.c
new file mode 100644
index 0000000..01107ee
--- /dev/null
+++ b/compiler-rt/test/tsan/pthread_atfork_deadlock.c
@@ -0,0 +1,33 @@
+// RUN: %clang_tsan -O1 %s -lpthread -o %t && %deflake %run %t | FileCheck %s
+// Regression test for
+// https://github.com/google/sanitizers/issues/468
+// When the data race was reported, pthread_atfork() handler used to be
+// executed which caused another race report in the same thread, which resulted
+// in a deadlock.
+#include "test.h"
+
+int glob = 0;
+
+void *worker(void *unused) {
+  barrier_wait(&barrier);
+  glob++;
+  return NULL;
+}
+
+void atfork() {
+  fprintf(stderr, "ATFORK\n");
+  glob++;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_atfork(atfork, NULL, NULL);
+  pthread_t t;
+  pthread_create(&t, NULL, worker, NULL);
+  glob++;
+  barrier_wait(&barrier);
+  pthread_join(t, NULL);
+  // CHECK: ThreadSanitizer: data race
+  // CHECK-NOT: ATFORK
+  return 0;
+}
diff --git a/compiler-rt/test/tsan/race_on_barrier.c b/compiler-rt/test/tsan/race_on_barrier.c
new file mode 100644
index 0000000..66fd339
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_barrier.c
@@ -0,0 +1,34 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+
+// pthread barriers are not available on OS X
+// UNSUPPORTED: darwin
+
+#include "test.h"
+
+pthread_barrier_t B;
+int Global;
+
+void *Thread1(void *x) {
+  pthread_barrier_init(&B, 0, 2);
+  barrier_wait(&barrier);
+  pthread_barrier_wait(&B);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  pthread_barrier_wait(&B);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, NULL, Thread1, NULL);
+  Thread2(0);
+  pthread_join(t, NULL);
+  pthread_barrier_destroy(&B);
+  return 0;
+}
+
+// CHECK:      WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/race_on_barrier2.c b/compiler-rt/test/tsan/race_on_barrier2.c
new file mode 100644
index 0000000..49adb62
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_barrier2.c
@@ -0,0 +1,35 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+
+// pthread barriers are not available on OS X
+// UNSUPPORTED: darwin
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <unistd.h>
+
+pthread_barrier_t B;
+int Global;
+
+void *Thread1(void *x) {
+  if (pthread_barrier_wait(&B) == PTHREAD_BARRIER_SERIAL_THREAD)
+    pthread_barrier_destroy(&B);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  if (pthread_barrier_wait(&B) == PTHREAD_BARRIER_SERIAL_THREAD)
+    pthread_barrier_destroy(&B);
+  return NULL;
+}
+
+int main() {
+  pthread_barrier_init(&B, 0, 2);
+  pthread_t t;
+  pthread_create(&t, NULL, Thread1, NULL);
+  Thread2(0);
+  pthread_join(t, NULL);
+  return 0;
+}
+
+// CHECK:      WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/race_on_heap.cc b/compiler-rt/test/tsan/race_on_heap.cc
new file mode 100644
index 0000000..6c2defc
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_heap.cc
@@ -0,0 +1,48 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "test.h"
+
+void *Thread1(void *p) {
+  *(int*)p = 42;
+  return 0;
+}
+
+void *Thread2(void *p) {
+  *(int*)p = 44;
+  return 0;
+}
+
+void *alloc() {
+  return malloc(99);
+}
+
+void *AllocThread(void* arg) {
+  return alloc();
+}
+
+int main() {
+  void *p = 0;
+  pthread_t t[2];
+  pthread_create(&t[0], 0, AllocThread, 0);
+  pthread_join(t[0], &p);
+  print_address("addr=", 1, p);
+  pthread_create(&t[0], 0, Thread1, (char*)p + 16);
+  pthread_create(&t[1], 0, Thread2, (char*)p + 16);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  return 0;
+}
+
+// CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
+// CHECK: WARNING: ThreadSanitizer: data race
+// ...
+// CHECK: Location is heap block of size 99 at [[ADDR]] allocated by thread T1:
+// CHCEK:     #0 malloc
+// CHECK:     #{{1|2}} alloc
+// CHECK:     #{{2|3}} AllocThread
+// ...
+// CHECK:   Thread T1 (tid={{.*}}, finished) created by main thread at:
+// CHECK:     #0 pthread_create
+// CHECK:     #1 main
diff --git a/compiler-rt/test/tsan/race_on_mutex.c b/compiler-rt/test/tsan/race_on_mutex.c
new file mode 100644
index 0000000..638bc0c
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_mutex.c
@@ -0,0 +1,44 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+// This test fails on powerpc64 (VMA=46).
+// The size of the write reported by Tsan for T1 is 8 instead of 1.
+// XFAIL: powerpc64
+#include "test.h"
+
+pthread_mutex_t Mtx;
+int Global;
+
+void *Thread1(void *x) {
+  pthread_mutex_init(&Mtx, 0);
+  pthread_mutex_lock(&Mtx);
+  Global = 42;
+  pthread_mutex_unlock(&Mtx);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&Mtx);
+  Global = 43;
+  pthread_mutex_unlock(&Mtx);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  pthread_mutex_destroy(&Mtx);
+  return 0;
+}
+
+// CHECK:      WARNING: ThreadSanitizer: data race
+// CHECK-NEXT:   Atomic read of size 1 at {{.*}} by thread T2:
+// CHECK-NEXT:     #0 pthread_mutex_lock
+// CHECK-NEXT:     #1 Thread2{{.*}} {{.*}}race_on_mutex.c:21{{(:3)?}} ({{.*}})
+// CHECK:        Previous write of size 1 at {{.*}} by thread T1:
+// CHECK-NEXT:     #0 pthread_mutex_init {{.*}} ({{.*}})
+// CHECK-NEXT:     #1 Thread1{{.*}} {{.*}}race_on_mutex.c:11{{(:3)?}} ({{.*}})
diff --git a/compiler-rt/test/tsan/race_on_mutex2.c b/compiler-rt/test/tsan/race_on_mutex2.c
new file mode 100644
index 0000000..6ee5438
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_mutex2.c
@@ -0,0 +1,23 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread(void *x) {
+  pthread_mutex_lock((pthread_mutex_t*)x);
+  pthread_mutex_unlock((pthread_mutex_t*)x);
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_mutex_t Mtx;
+  pthread_mutex_init(&Mtx, 0);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, &Mtx);
+  barrier_wait(&barrier);
+  pthread_mutex_destroy(&Mtx);
+  pthread_join(t, 0);
+  return 0;
+}
+
+// CHECK:      WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/race_on_puts.cc b/compiler-rt/test/tsan/race_on_puts.cc
new file mode 100644
index 0000000..f254182
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_puts.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+char s[] = "abracadabra";
+
+void *Thread0(void *p) {
+  puts(s);
+  barrier_wait(&barrier);
+  return 0;
+}
+
+void *Thread1(void *p) {
+  barrier_wait(&barrier);
+  s[3] = 'z';
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t th[2];
+  pthread_create(&th[0], 0, Thread0, 0);
+  pthread_create(&th[1], 0, Thread1, 0);
+  pthread_join(th[0], 0);
+  pthread_join(th[1], 0);
+  fprintf(stderr, "DONE");
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/race_on_read.cc b/compiler-rt/test/tsan/race_on_read.cc
new file mode 100644
index 0000000..d388bba
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_read.cc
@@ -0,0 +1,45 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+int fd;
+char buf;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  read(fd, &buf, 1);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  read(fd, &buf, 1);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  fd = open("/dev/random", O_RDONLY);
+  if (fd < 0) {
+    fprintf(stderr, "failed to open /dev/random (%d)\n", errno);
+    return 1;
+  }
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  close(fd);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 1
+// CHECK:     #0 read
+// CHECK:   Previous write of size 1
+// CHECK:     #0 read
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/race_on_speculative_load.cc b/compiler-rt/test/tsan/race_on_speculative_load.cc
new file mode 100644
index 0000000..dd40dae
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_speculative_load.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t | FileCheck %s
+// Regtest for https://github.com/google/sanitizers/issues/447
+// This is a correct program and tsan should not report a race.
+#include "test.h"
+
+int g;
+__attribute__((noinline))
+int foo(int cond) {
+  if (cond)
+    return g;
+  return 0;
+}
+
+void *Thread1(void *p) {
+  barrier_wait(&barrier);
+  long res = foo((long)p);
+  return (void*) res;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread1, 0);
+  g = 1;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  printf("PASS\n");
+  // CHECK-NOT: ThreadSanitizer: data race
+  // CHECK: PASS
+}
diff --git a/compiler-rt/test/tsan/race_on_write.cc b/compiler-rt/test/tsan/race_on_write.cc
new file mode 100644
index 0000000..147591a
--- /dev/null
+++ b/compiler-rt/test/tsan/race_on_write.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+int fd;
+char buf;
+
+void *Thread1(void *x) {
+  buf = 1;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  write(fd, &buf, 1);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  fd = open("/dev/null", O_WRONLY);
+  if (fd < 0) return 1;
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  barrier_wait(&barrier);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  close(fd);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Read of size 1
+// CHECK:     #0 write
+// CHECK:   Previous write of size 1
+// CHECK:     #0 Thread1
diff --git a/compiler-rt/test/tsan/race_stress.cc b/compiler-rt/test/tsan/race_stress.cc
new file mode 100644
index 0000000..38acefc
--- /dev/null
+++ b/compiler-rt/test/tsan/race_stress.cc
@@ -0,0 +1,25 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+const int kThreads = 16;
+const int kIters = 1000;
+
+volatile int X = 0;
+
+void *thr(void *arg) {
+  for (int i = 0; i < kIters; i++)
+    X++;
+  return 0;
+}
+
+int main() {
+  pthread_t th[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    pthread_create(&th[i], 0, thr, 0);
+  for (int i = 0; i < kThreads; i++)
+    pthread_join(th[i], 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: ThreadSanitizer: data race
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/race_top_suppression.cc b/compiler-rt/test/tsan/race_top_suppression.cc
new file mode 100644
index 0000000..bd5c1bd
--- /dev/null
+++ b/compiler-rt/test/tsan/race_top_suppression.cc
@@ -0,0 +1,29 @@
+// RUN: echo "race_top:TopFunction" > %t.supp
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %env_tsan_opts=suppressions='%t.supp' %run %t 2>&1 | FileCheck %s
+// RUN: rm %t.supp
+#include "test.h"
+
+int Global;
+
+void TopFunction(int *p) {
+  *p = 1;
+}
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  TopFunction(&Global);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  Global--;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/race_top_suppression1.cc b/compiler-rt/test/tsan/race_top_suppression1.cc
new file mode 100644
index 0000000..e34385a
--- /dev/null
+++ b/compiler-rt/test/tsan/race_top_suppression1.cc
@@ -0,0 +1,32 @@
+// RUN: echo "race_top:TopFunction" > %t.supp
+// RUN: %clangxx_tsan -O1 %s -o %t
+// RUN: %env_tsan_opts=suppressions='%t.supp' %deflake %run %t 2>&1 | FileCheck %s
+// RUN: rm %t.supp
+#include "test.h"
+
+int Global;
+
+void AnotherFunction(int *p) {
+  *p = 1;
+}
+
+void TopFunction(int *p) {
+  AnotherFunction(p);
+}
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  TopFunction(&Global);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  Global--;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/race_with_finished_thread.cc b/compiler-rt/test/tsan/race_with_finished_thread.cc
new file mode 100644
index 0000000..755a7bd
--- /dev/null
+++ b/compiler-rt/test/tsan/race_with_finished_thread.cc
@@ -0,0 +1,42 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+// Ensure that we can restore a stack of a finished thread.
+
+int g_data;
+
+void __attribute__((noinline)) foobar(int *p) {
+  *p = 42;
+}
+
+void *Thread1(void *x) {
+  foobar(&g_data);
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  sleep(1); // let the thread finish and exit
+  g_data = 43;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 4 at {{.*}} by thread T2:
+// CHECK:   Previous write of size 4 at {{.*}} by thread T1:
+// CHECK:     #0 foobar
+// CHECK:     #1 Thread1
+// CHECK:   Thread T1 (tid={{.*}}, finished) created by main thread at:
+// CHECK:     #0 pthread_create
+// CHECK:     #1 main
diff --git a/compiler-rt/test/tsan/real_deadlock_detector_stress_test.cc b/compiler-rt/test/tsan/real_deadlock_detector_stress_test.cc
new file mode 100644
index 0000000..feb1117
--- /dev/null
+++ b/compiler-rt/test/tsan/real_deadlock_detector_stress_test.cc
@@ -0,0 +1,187 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <vector>
+#include <algorithm>
+#include <sys/time.h>
+
+const int kThreads = 4;
+const int kMutexes = 16 << 10;
+const int kIters = 400 << 10;
+const int kMaxPerThread = 10;
+
+const int kStateInited = 0;
+const int kStateNotInited = -1;
+const int kStateLocked = -2;
+
+struct Mutex {
+  int state;
+  pthread_rwlock_t m;
+};
+
+Mutex mtx[kMutexes];
+
+void check(int res) {
+  if (res != 0) {
+    printf("SOMETHING HAS FAILED\n");
+    exit(1);
+  }
+}
+
+bool cas(int *a, int oldval, int newval) {
+  return __atomic_compare_exchange_n(a, &oldval, newval, false,
+      __ATOMIC_ACQ_REL, __ATOMIC_RELAXED);
+}
+
+void *Thread(void *seed) {
+  unsigned rnd = (unsigned)(unsigned long)seed;
+  int err;
+  std::vector<int> locked;
+  for (int i = 0; i < kIters; i++) {
+    int what = rand_r(&rnd) % 10;
+    if (what < 4 && locked.size() < kMaxPerThread) {
+      // lock
+      int max_locked = -1;
+      if (!locked.empty()) {
+        max_locked = *std::max_element(locked.begin(), locked.end());
+        if (max_locked == kMutexes - 1) {
+          i--;
+          continue;
+        }
+      }
+      int id = (rand_r(&rnd) % (kMutexes - max_locked - 1)) + max_locked + 1;
+      Mutex *m = &mtx[id];
+      // init the mutex if necessary or acquire a reference
+      for (;;) {
+        int old = __atomic_load_n(&m->state, __ATOMIC_RELAXED);
+        if (old == kStateLocked) {
+          sched_yield();
+          continue;
+        }
+        int newv = old + 1;
+        if (old == kStateNotInited)
+          newv = kStateLocked;
+        if (cas(&m->state, old, newv)) {
+          if (old == kStateNotInited) {
+            if ((err = pthread_rwlock_init(&m->m, 0))) {
+              fprintf(stderr, "pthread_rwlock_init failed with %d\n", err);
+              exit(1);
+            }
+            if (!cas(&m->state, kStateLocked, 1)) {
+              fprintf(stderr, "init commit failed\n");
+              exit(1);
+            }
+          }
+          break;
+        }
+      }
+      // now we have an inited and referenced mutex, choose what to do
+      bool failed = false;
+      switch (rand_r(&rnd) % 4) {
+      case 0:
+        if ((err = pthread_rwlock_wrlock(&m->m))) {
+          fprintf(stderr, "pthread_rwlock_wrlock failed with %d\n", err);
+          exit(1);
+        }
+        break;
+      case 1:
+        if ((err = pthread_rwlock_rdlock(&m->m))) {
+          fprintf(stderr, "pthread_rwlock_rdlock failed with %d\n", err);
+          exit(1);
+        }
+        break;
+      case 2:
+        err = pthread_rwlock_trywrlock(&m->m);
+        if (err != 0 && err != EBUSY) {
+          fprintf(stderr, "pthread_rwlock_trywrlock failed with %d\n", err);
+          exit(1);
+        }
+        failed = err == EBUSY;
+        break;
+      case 3:
+        err = pthread_rwlock_tryrdlock(&m->m);
+        if (err != 0 && err != EBUSY) {
+          fprintf(stderr, "pthread_rwlock_tryrdlock failed with %d\n", err);
+          exit(1);
+        }
+        failed = err == EBUSY;
+        break;
+      }
+      if (failed) {
+        if (__atomic_fetch_sub(&m->state, 1, __ATOMIC_ACQ_REL) <= 0) {
+          fprintf(stderr, "failed to unref after failed trylock\n");
+          exit(1);
+        }
+        continue;
+      }
+      locked.push_back(id);
+    } else if (what < 9 && !locked.empty()) {
+      // unlock
+      int pos = rand_r(&rnd) % locked.size();
+      int id = locked[pos];
+      locked[pos] = locked[locked.size() - 1];
+      locked.pop_back();
+      Mutex *m = &mtx[id];
+      if ((err = pthread_rwlock_unlock(&m->m))) {
+        fprintf(stderr, "pthread_rwlock_unlock failed with %d\n", err);
+        exit(1);
+      }
+      if (__atomic_fetch_sub(&m->state, 1, __ATOMIC_ACQ_REL) <= 0) {
+        fprintf(stderr, "failed to unref after unlock\n");
+        exit(1);
+      }
+    } else {
+      // Destroy a random mutex.
+      int id = rand_r(&rnd) % kMutexes;
+      Mutex *m = &mtx[id];
+      if (!cas(&m->state, kStateInited, kStateLocked)) {
+        i--;
+        continue;
+      }
+      if ((err = pthread_rwlock_destroy(&m->m))) {
+        fprintf(stderr, "pthread_rwlock_destroy failed with %d\n", err);
+        exit(1);
+      }
+      if (!cas(&m->state, kStateLocked, kStateNotInited)) {
+        fprintf(stderr, "destroy commit failed\n");
+        exit(1);
+      }
+    }
+  }
+  // Unlock all previously locked mutexes, otherwise other threads can deadlock.
+  for (int i = 0; i < locked.size(); i++) {
+    int id = locked[i];
+    Mutex *m = &mtx[id];
+    if ((err = pthread_rwlock_unlock(&m->m))) {
+      fprintf(stderr, "pthread_rwlock_unlock failed with %d\n", err);
+      exit(1);
+    }
+  }
+  return 0;
+}
+
+int main() {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  unsigned s = tv.tv_sec + tv.tv_usec;
+  fprintf(stderr, "seed %d\n", s);
+  srand(s);
+  for (int i = 0; i < kMutexes; i++)
+    mtx[i].state = kStateNotInited;
+  pthread_t t[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    pthread_create(&t[i], 0, Thread, (void*)(unsigned long)rand());
+  for (int i = 0; i < kThreads; i++)
+    pthread_join(t[i], 0);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/restore_stack.cc b/compiler-rt/test/tsan/restore_stack.cc
new file mode 100644
index 0000000..39c1101
--- /dev/null
+++ b/compiler-rt/test/tsan/restore_stack.cc
@@ -0,0 +1,50 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+volatile int x;
+const int kSize = 64 << 10;
+volatile long data[kSize];
+
+void __attribute__((noinline)) foo() {
+  for (int i = 0; i < kSize; i++)
+    data[i]++;
+}
+
+void *Thread(void *a) {
+  __atomic_store_n(&x, 1, __ATOMIC_RELEASE);
+  foo();
+  data[0]++;
+  if (a != 0)
+    barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  for (int i = 0; i < 50; i++) {
+    pthread_t t;
+    pthread_create(&t, 0, Thread, 0);
+    pthread_join(t, 0);
+  }
+  pthread_t t;
+  pthread_create(&t, 0, Thread, (void*)1);
+  barrier_wait(&barrier);
+  for (int i = 0; i < kSize; i++)
+    data[i]++;
+  pthread_join(t, 0);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// Previously this test produced bogus stack traces like:
+//   Previous write of size 8 at 0x0000006a8ff8 by thread T17:
+//     #0 foo() restore_stack.cc:13:5 (restore_stack.cc.exe+0x00000040622c)
+//     #1 Thread(void*) restore_stack.cc:18:3 (restore_stack.cc.exe+0x000000406283)
+//     #2 __tsan_thread_start_func rtl/tsan_interceptors.cc:886 (restore_stack.cc.exe+0x00000040a749)
+//     #3 Thread(void*) restore_stack.cc:18:3 (restore_stack.cc.exe+0x000000406283)
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: __tsan_thread_start_func
+// CHECK-NOT: #3 Thread
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/setuid.c b/compiler-rt/test/tsan/setuid.c
new file mode 100644
index 0000000..bc9c8ca
--- /dev/null
+++ b/compiler-rt/test/tsan/setuid.c
@@ -0,0 +1,26 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <unistd.h>
+
+// Setuid call used to hang because the background tsan thread did not handle
+// SIGSETXID signal. Note that we don't care whether setuid call succeeds
+// or not.
+
+static void *thread(void *arg) {
+  (void)arg;
+  sleep(1);
+  return 0;
+}
+
+int main() {
+  // Create another thread just for completeness of the picture.
+  pthread_t th;
+  pthread_create(&th, 0, thread, 0);
+  setuid(0);
+  pthread_join(th, 0);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/setuid2.c b/compiler-rt/test/tsan/setuid2.c
new file mode 100644
index 0000000..9dbb657
--- /dev/null
+++ b/compiler-rt/test/tsan/setuid2.c
@@ -0,0 +1,21 @@
+// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=flush_memory_ms=1:memory_limit_mb=1 %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <sys/types.h>
+#include <unistd.h>
+#include <time.h>
+
+// Test that setuid call works in presence of stoptheworld.
+
+int main() {
+  unsigned long long tp0, tp1;
+  tp0 = monotonic_clock_ns();
+  tp1 = monotonic_clock_ns();
+  while (tp1 - tp0 < 3 * 1000000000ull) {
+    tp1 = monotonic_clock_ns();
+    setuid(0);
+  }
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/signal_cond.cc b/compiler-rt/test/tsan/signal_cond.cc
new file mode 100644
index 0000000..beb2e02
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_cond.cc
@@ -0,0 +1,53 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <semaphore.h>
+
+// Test that signals can be delivered to blocked pthread_cond_wait.
+// https://github.com/google/sanitizers/issues/498
+
+int g_thread_run = 1;
+pthread_mutex_t mutex;
+pthread_cond_t cond;
+
+void sig_handler(int sig) {
+  (void)sig;
+  write(1, "SIGNAL\n", sizeof("SIGNAL\n") - 1);
+  barrier_wait(&barrier);
+}
+
+void* my_thread(void* arg) {
+  pthread_mutex_lock(&mutex);
+  while (g_thread_run)
+    pthread_cond_wait(&cond, &mutex);
+  pthread_mutex_unlock(&mutex);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+
+  pthread_mutex_init(&mutex, 0);
+  pthread_cond_init(&cond, 0);
+
+  signal(SIGUSR1, &sig_handler);
+  pthread_t thr;
+  pthread_create(&thr, 0, &my_thread, 0);
+  // wait for thread to get inside pthread_cond_wait
+  // (can't use barrier_wait for that)
+  sleep(1);
+  pthread_kill(thr, SIGUSR1);
+  barrier_wait(&barrier);
+  pthread_mutex_lock(&mutex);
+  g_thread_run = 0;
+  pthread_cond_signal(&cond);
+  pthread_mutex_unlock(&mutex);
+  pthread_join(thr, 0);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK: SIGNAL
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/signal_errno.cc b/compiler-rt/test/tsan/signal_errno.cc
new file mode 100644
index 0000000..e13e156
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_errno.cc
@@ -0,0 +1,52 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+// This test fails on powerpc64 BE (VMA=44), it does not appear to be
+// a functional problem, but the Tsan report is missing some info.
+// XFAIL: powerpc64-unknown-linux-gnu
+
+#include "test.h"
+#include <signal.h>
+#include <sys/types.h>
+#include <errno.h>
+
+pthread_t mainth;
+volatile int done;
+
+static void MyHandler(int, siginfo_t *s, void *c) {
+  errno = 1;
+  done = 1;
+}
+
+static void* sendsignal(void *p) {
+  barrier_wait(&barrier);
+  pthread_kill(mainth, SIGPROF);
+  return 0;
+}
+
+static __attribute__((noinline)) void loop() {
+  barrier_wait(&barrier);
+  while (done == 0) {
+    volatile char *p = (char*)malloc(1);
+    p[0] = 0;
+    free((void*)p);
+    sched_yield();
+  }
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  mainth = pthread_self();
+  struct sigaction act = {};
+  act.sa_sigaction = &MyHandler;
+  sigaction(SIGPROF, &act, 0);
+  pthread_t th;
+  pthread_create(&th, 0, sendsignal, 0);
+  loop();
+  pthread_join(th, 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: signal handler spoils errno
+// CHECK:     #0 MyHandler(int, {{(__)?}}siginfo{{(_t)?}}*, void*) {{.*}}signal_errno.cc
+// CHECK:     main
+// CHECK: SUMMARY: ThreadSanitizer: signal handler spoils errno{{.*}}MyHandler
+
diff --git a/compiler-rt/test/tsan/signal_longjmp.cc b/compiler-rt/test/tsan/signal_longjmp.cc
new file mode 100644
index 0000000..45e2462
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_longjmp.cc
@@ -0,0 +1,82 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Test case for longjumping out of signal handler:
+// https://github.com/google/sanitizers/issues/482
+
+// Longjmp assembly has not been implemented for mips64 yet
+// XFAIL: mips64
+// This test fails on powerpc64 BE (VMA=44), a segmentation fault
+// error happens at the second assignment
+// "((volatile int *volatile)mem)[1] = 1".
+// XFAIL: powerpc64-unknown-linux-gnu
+
+#include <setjmp.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+
+#ifdef __APPLE__
+#define SIGNAL_TO_HANDLE SIGBUS
+#else
+#define SIGNAL_TO_HANDLE SIGSEGV
+#endif
+
+sigjmp_buf fault_jmp;
+volatile int fault_expected;
+
+void sigfault_handler(int sig) {
+  if (!fault_expected)
+    abort();
+
+  /* just return from sighandler to proper place */
+  fault_expected = 0;
+  siglongjmp(fault_jmp, 1);
+}
+
+#define MUST_FAULT(code) do { \
+  fault_expected = 1; \
+  if (!sigsetjmp(fault_jmp, 1)) { \
+    code; /* should pagefault -> sihandler does longjmp */ \
+    fprintf(stderr, "%s not faulted\n", #code); \
+    abort(); \
+  } else { \
+    fprintf(stderr, "%s faulted ok\n", #code); \
+  } \
+} while (0)
+
+int main() {
+  struct sigaction act;
+  act.sa_handler  = sigfault_handler;
+  act.sa_flags    = 0;
+  if (sigemptyset(&act.sa_mask)) {
+    perror("sigemptyset");
+    exit(1);
+  }
+
+  if (sigaction(SIGNAL_TO_HANDLE, &act, NULL)) {
+    perror("sigaction");
+    exit(1);
+  }
+
+  void *mem = mmap(0, 4096, PROT_NONE, MAP_PRIVATE | MAP_ANON,
+      -1, 0);
+
+  MUST_FAULT(((volatile int *volatile)mem)[0] = 0);
+  MUST_FAULT(((volatile int *volatile)mem)[1] = 1);
+  MUST_FAULT(((volatile int *volatile)mem)[3] = 1);
+
+  // Ensure that tsan does not think that we are
+  // in a signal handler.
+  void *volatile p = malloc(10);
+  ((volatile int*)p)[1] = 1;
+  free((void*)p);
+
+  munmap(p, 4096);
+
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/signal_malloc.cc b/compiler-rt/test/tsan/signal_malloc.cc
new file mode 100644
index 0000000..1dccb13
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_malloc.cc
@@ -0,0 +1,24 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <signal.h>
+#include <sys/types.h>
+
+static void handler(int, siginfo_t*, void*) {
+  // CHECK: WARNING: ThreadSanitizer: signal-unsafe call inside of a signal
+  // CHECK:     #0 malloc
+  // CHECK:     #{{(1|2)}} handler(int, {{(__)?}}siginfo{{(_t)?}}*, void*) {{.*}}signal_malloc.cc:[[@LINE+2]]
+  // CHECK: SUMMARY: ThreadSanitizer: signal-unsafe call inside of a signal{{.*}}handler
+  volatile char *p = (char*)malloc(1);
+  p[0] = 0;
+  free((void*)p);
+}
+
+int main() {
+  struct sigaction act = {};
+  act.sa_sigaction = &handler;
+  sigaction(SIGPROF, &act, 0);
+  kill(getpid(), SIGPROF);
+  sleep(1);  // let the signal handler run
+  return 0;
+}
+
diff --git a/compiler-rt/test/tsan/signal_recursive.cc b/compiler-rt/test/tsan/signal_recursive.cc
new file mode 100644
index 0000000..40be2d0
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_recursive.cc
@@ -0,0 +1,126 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Test case for recursive signal handlers, adopted from:
+// https://github.com/google/sanitizers/issues/478
+
+// REQUIRES: disabled
+
+#include "test.h"
+#include <semaphore.h>
+#include <signal.h>
+#include <errno.h>
+
+static const int kSigSuspend = SIGUSR1;
+static const int kSigRestart = SIGUSR2;
+
+static sem_t g_thread_suspend_ack_sem;
+
+static bool g_busy_thread_received_restart;
+
+static volatile bool g_busy_thread_garbage_collected;
+
+static void SaveRegistersInStack() {
+  // Mono walks thread stacks to detect unreferenced objects.
+  // If last object reference is kept in register the object will be collected
+  // This is why threads can't be suspended with something like pthread_suspend
+}
+
+static void fail(const char *what) {
+  fprintf(stderr, "FAILED: %s (errno=%d)\n", what, errno);
+  exit(1);
+}
+
+static void SuspendHandler(int sig) {
+  int old_errno = errno;
+  SaveRegistersInStack();
+
+  // Enable kSigRestart handling, tsan disables signals around signal handlers.
+  sigset_t sigset;
+  sigemptyset(&sigset);
+  pthread_sigmask(SIG_SETMASK, &sigset, 0);
+
+  // Acknowledge that thread is saved and suspended
+  if (sem_post(&g_thread_suspend_ack_sem) != 0)
+    fail("sem_post failed");
+
+  // Wait for wakeup signal.
+  while (!g_busy_thread_received_restart)
+    usleep(100);  // wait for kSigRestart signal
+
+  // Acknowledge that thread restarted
+  if (sem_post(&g_thread_suspend_ack_sem) != 0)
+    fail("sem_post failed");
+
+  g_busy_thread_garbage_collected = true;
+
+  errno = old_errno;
+}
+
+static void RestartHandler(int sig) {
+  g_busy_thread_received_restart = true;
+}
+
+static void StopWorld(pthread_t thread) {
+  if (pthread_kill(thread, kSigSuspend) != 0)
+    fail("pthread_kill failed");
+
+  while (sem_wait(&g_thread_suspend_ack_sem) != 0) {
+    if (errno != EINTR)
+      fail("sem_wait failed");
+  }
+}
+
+static void StartWorld(pthread_t thread) {
+  if (pthread_kill(thread, kSigRestart) != 0)
+    fail("pthread_kill failed");
+
+  while (sem_wait(&g_thread_suspend_ack_sem) != 0) {
+    if (errno != EINTR)
+      fail("sem_wait failed");
+  }
+}
+
+static void CollectGarbage(pthread_t thread) {
+  StopWorld(thread);
+  // Walk stacks
+  StartWorld(thread);
+}
+
+static void Init() {
+  if (sem_init(&g_thread_suspend_ack_sem, 0, 0) != 0)
+    fail("sem_init failed");
+
+  struct sigaction act = {};
+  act.sa_flags = SA_RESTART;
+  act.sa_handler = &SuspendHandler;
+  if (sigaction(kSigSuspend, &act, NULL) != 0)
+    fail("sigaction failed");
+  act.sa_handler = &RestartHandler;
+  if (sigaction(kSigRestart, &act, NULL) != 0)
+    fail("sigaction failed");
+}
+
+void* BusyThread(void *arg) {
+  (void)arg;
+  while (!g_busy_thread_garbage_collected) {
+    usleep(100); // Tsan deadlocks without these sleeps
+  }
+  return NULL;
+}
+
+int main(int argc, const char *argv[]) {
+  Init();
+  pthread_t busy_thread;
+  if (pthread_create(&busy_thread, NULL, &BusyThread, NULL) != 0)
+    fail("pthread_create failed");
+  CollectGarbage(busy_thread);
+  if (pthread_join(busy_thread, 0) != 0)
+    fail("pthread_join failed");
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: FAILED
+// CHECK-NOT: ThreadSanitizer CHECK failed
+// CHECK-NOT: WARNING: ThreadSanitizer:
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/signal_reset.cc b/compiler-rt/test/tsan/signal_reset.cc
new file mode 100644
index 0000000..82758d8
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_reset.cc
@@ -0,0 +1,75 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+
+volatile int X;
+int stop;
+
+static void handler(int sig) {
+  (void)sig;
+  if (X != 0)
+    printf("bad");
+}
+
+static void* busy(void *p) {
+  while (__atomic_load_n(&stop, __ATOMIC_RELAXED) == 0) {
+  }
+  return 0;
+}
+
+static void* reset(void *p) {
+  struct sigaction act = {};
+  for (int i = 0; i < 1000000; i++) {
+    act.sa_handler = &handler;
+    if (sigaction(SIGPROF, &act, 0)) {
+      perror("sigaction");
+      exit(1);
+    }
+    act.sa_handler = SIG_IGN;
+    if (sigaction(SIGPROF, &act, 0)) {
+      perror("sigaction");
+      exit(1);
+    }
+  }
+  return 0;
+}
+
+int main() {
+  struct sigaction act = {};
+  act.sa_handler = SIG_IGN;
+  if (sigaction(SIGPROF, &act, 0)) {
+    perror("sigaction");
+    exit(1);
+  }
+
+  itimerval t;
+  t.it_value.tv_sec = 0;
+  t.it_value.tv_usec = 10;
+  t.it_interval = t.it_value;
+  if (setitimer(ITIMER_PROF, &t, 0)) {
+    perror("setitimer");
+    exit(1);
+  }
+
+  pthread_t th[2];
+  pthread_create(&th[0], 0, busy, 0);
+  pthread_create(&th[1], 0, reset, 0);
+
+  pthread_join(th[1], 0);
+  __atomic_store_n(&stop, 1, __ATOMIC_RELAXED);
+  pthread_join(th[0], 0);
+
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer:
+// CHECK: DONE
+// CHECK-NOT: WARNING: ThreadSanitizer:
diff --git a/compiler-rt/test/tsan/signal_sync.cc b/compiler-rt/test/tsan/signal_sync.cc
new file mode 100644
index 0000000..b529a18
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_sync.cc
@@ -0,0 +1,56 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include "test.h"
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <errno.h>
+
+volatile int X;
+
+static void handler(int sig) {
+  (void)sig;
+  if (X != 42)
+    printf("bad");
+}
+
+static void* thr(void *p) {
+  for (int i = 0; i != 1000; i++)
+    usleep(1000);  // process signals
+  return 0;
+}
+
+int main() {
+  const int kThreads = 10;
+  pthread_t th[kThreads];
+  for (int i = 0; i < kThreads; i++)
+    pthread_create(&th[i], 0, thr, 0);
+
+  X = 42;
+
+  struct sigaction act = {};
+  act.sa_handler = &handler;
+  if (sigaction(SIGPROF, &act, 0)) {
+    perror("sigaction");
+    exit(1);
+  }
+
+  itimerval t;
+  t.it_value.tv_sec = 0;
+  t.it_value.tv_usec = 10;
+  t.it_interval = t.it_value;
+  if (setitimer(ITIMER_PROF, &t, 0)) {
+    perror("setitimer");
+    exit(1);
+  }
+
+  for (int i = 0; i < kThreads; i++)
+    pthread_join(th[i], 0);
+
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer:
+// CHECK: DONE
+// CHECK-NOT: WARNING: ThreadSanitizer:
diff --git a/compiler-rt/test/tsan/signal_thread.cc b/compiler-rt/test/tsan/signal_thread.cc
new file mode 100644
index 0000000..aa91d1d
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_thread.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+
+volatile int X;
+
+static void handler(int sig) {
+  (void)sig;
+  if (X != 0)
+    printf("bad");
+}
+
+static void* thr(void *p) {
+  return 0;
+}
+
+int main() {
+  struct sigaction act = {};
+  act.sa_handler = &handler;
+  if (sigaction(SIGPROF, &act, 0)) {
+    perror("sigaction");
+    exit(1);
+  }
+
+  itimerval t;
+  t.it_value.tv_sec = 0;
+  t.it_value.tv_usec = 10;
+  t.it_interval = t.it_value;
+  if (setitimer(ITIMER_PROF, &t, 0)) {
+    perror("setitimer");
+    exit(1);
+  }
+
+  for (int i = 0; i < 10000; i++) {
+    pthread_t th;
+    pthread_create(&th, 0, thr, 0);
+    pthread_join(th, 0);
+  }
+
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer:
+// CHECK: DONE
+// CHECK-NOT: WARNING: ThreadSanitizer:
diff --git a/compiler-rt/test/tsan/signal_write.cc b/compiler-rt/test/tsan/signal_write.cc
new file mode 100644
index 0000000..edb3d23
--- /dev/null
+++ b/compiler-rt/test/tsan/signal_write.cc
@@ -0,0 +1,27 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+static void handler(int, siginfo_t*, void*) {
+  const char *str = "HELLO FROM SIGNAL\n";
+  write(2, str, strlen(str));
+}
+
+int main() {
+  struct sigaction act = {};
+  act.sa_sigaction = &handler;
+  sigaction(SIGPROF, &act, 0);
+  kill(getpid(), SIGPROF);
+  sleep(1);  // let the signal handler run, can't use barrier in sig handler
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer
+// CHECK: HELLO FROM SIGNAL
+// CHECK: DONE
+
diff --git a/compiler-rt/test/tsan/sigsuspend.cc b/compiler-rt/test/tsan/sigsuspend.cc
new file mode 100644
index 0000000..a5930d4
--- /dev/null
+++ b/compiler-rt/test/tsan/sigsuspend.cc
@@ -0,0 +1,44 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+// Always enable asserts.
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdio.h>
+
+static bool signal_handler_ran = false;
+
+void do_nothing_signal_handler(int signum) {
+  write(1, "HANDLER\n", 8);
+  signal_handler_ran = true;
+}
+
+int main() {
+  const int kSignalToTest = SIGSYS;
+  assert(SIG_ERR != signal(kSignalToTest, do_nothing_signal_handler));
+  sigset_t empty_set;
+  assert(0 == sigemptyset(&empty_set));
+  sigset_t one_signal = empty_set;
+  assert(0 == sigaddset(&one_signal, kSignalToTest));
+  sigset_t old_set;
+  assert(0 == sigprocmask(SIG_BLOCK, &one_signal, &old_set));
+  raise(kSignalToTest);
+  assert(!signal_handler_ran);
+  sigset_t all_but_one;
+  assert(0 == sigfillset(&all_but_one));
+  assert(0 == sigdelset(&all_but_one, kSignalToTest));
+  sigsuspend(&all_but_one);
+  assert(signal_handler_ran);
+
+  // Restore the original set.
+  assert(0 == sigprocmask(SIG_SETMASK, &old_set, NULL));
+  printf("DONE\n");
+}
+
+// CHECK: HANDLER
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/simple_race.c b/compiler-rt/test/tsan/simple_race.c
new file mode 100644
index 0000000..b4234ac
--- /dev/null
+++ b/compiler-rt/test/tsan/simple_race.c
@@ -0,0 +1,29 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  Global = 42;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global = 43;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/simple_race.cc b/compiler-rt/test/tsan/simple_race.cc
new file mode 100644
index 0000000..612ce2d
--- /dev/null
+++ b/compiler-rt/test/tsan/simple_race.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  Global++;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global--;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: SUMMARY: ThreadSanitizer: data race{{.*}}Thread
diff --git a/compiler-rt/test/tsan/simple_stack.c b/compiler-rt/test/tsan/simple_stack.c
new file mode 100644
index 0000000..6ef92fb
--- /dev/null
+++ b/compiler-rt/test/tsan/simple_stack.c
@@ -0,0 +1,66 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void __attribute__((noinline)) foo1() {
+  Global = 42;
+}
+
+void __attribute__((noinline)) bar1() {
+  volatile int tmp = 42; (void)tmp;
+  foo1();
+}
+
+void __attribute__((noinline)) foo2() {
+  volatile int v = Global; (void)v;
+}
+
+void __attribute__((noinline)) bar2() {
+  volatile int tmp = 42; (void)tmp;
+  foo2();
+}
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  bar1();
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  bar2();
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void StartThread(pthread_t *t, void *(*f)(void*)) {
+  pthread_create(t, NULL, f, NULL);
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  StartThread(&t[0], Thread1);
+  StartThread(&t[1], Thread2);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  return 0;
+}
+
+// CHECK:      WARNING: ThreadSanitizer: data race
+// CHECK-NEXT:   Write of size 4 at {{.*}} by thread T1:
+// CHECK-NEXT:     #0 foo1{{.*}} {{.*}}simple_stack.c:7{{(:10)?}} ({{.*}})
+// CHECK-NEXT:     #1 bar1{{.*}} {{.*}}simple_stack.c:12{{(:3)?}} ({{.*}})
+// CHECK-NEXT:     #2 Thread1{{.*}} {{.*}}simple_stack.c:26{{(:3)?}} ({{.*}})
+// CHECK:        Previous read of size 4 at {{.*}} by thread T2:
+// CHECK-NEXT:     #0 foo2{{.*}} {{.*}}simple_stack.c:16{{(:20)?}} ({{.*}})
+// CHECK-NEXT:     #1 bar2{{.*}} {{.*}}simple_stack.c:21{{(:3)?}} ({{.*}})
+// CHECK-NEXT:     #2 Thread2{{.*}} {{.*}}simple_stack.c:31{{(:3)?}} ({{.*}})
+// CHECK:        Thread T1 (tid={{.*}}, running) created by main thread at:
+// CHECK-NEXT:     #0 pthread_create {{.*}} ({{.*}})
+// CHECK-NEXT:     #1 StartThread{{.*}} {{.*}}simple_stack.c:37{{(:3)?}} ({{.*}})
+// CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack.c:43{{(:3)?}} ({{.*}})
+// CHECK:        Thread T2 ({{.*}}) created by main thread at:
+// CHECK-NEXT:     #0 pthread_create {{.*}} ({{.*}})
+// CHECK-NEXT:     #1 StartThread{{.*}} {{.*}}simple_stack.c:37{{(:3)?}} ({{.*}})
+// CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack.c:44{{(:3)?}} ({{.*}})
diff --git a/compiler-rt/test/tsan/simple_stack2.cc b/compiler-rt/test/tsan/simple_stack2.cc
new file mode 100644
index 0000000..20ef729
--- /dev/null
+++ b/compiler-rt/test/tsan/simple_stack2.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_tsan -O1 %s -o %T/simple_stack2.cc.exe && %deflake %run %T/simple_stack2.cc.exe | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void __attribute__((noinline)) foo1() {
+  Global = 42;
+}
+
+void __attribute__((noinline)) bar1() {
+  volatile int tmp = 42;
+  int tmp2 = tmp;
+  (void)tmp2;
+  foo1();
+}
+
+void __attribute__((noinline)) foo2() {
+  volatile int tmp = Global;
+  int tmp2 = tmp;
+  (void)tmp2;
+}
+
+void __attribute__((noinline)) bar2() {
+  volatile int tmp = 42;
+  int tmp2 = tmp;
+  (void)tmp2;
+  foo2();
+}
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  bar1();
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, NULL, Thread1, NULL);
+  bar2();
+  barrier_wait(&barrier);
+  pthread_join(t, NULL);
+}
+
+// CHECK:      WARNING: ThreadSanitizer: data race
+// CHECK-NEXT:   Write of size 4 at {{.*}} by thread T1:
+// CHECK-NEXT:     #0 foo1{{.*}} {{.*}}simple_stack2.cc:7{{(:10)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK-NEXT:     #1 bar1{{.*}} {{.*}}simple_stack2.cc:14{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK-NEXT:     #2 Thread1{{.*}} {{.*}}simple_stack2.cc:32{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK:        Previous read of size 4 at {{.*}} by main thread:
+// CHECK-NEXT:     #0 foo2{{.*}} {{.*}}simple_stack2.cc:18{{(:22)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK-NEXT:     #1 bar2{{.*}} {{.*}}simple_stack2.cc:27{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack2.cc:40{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
diff --git a/compiler-rt/test/tsan/sleep_sync.cc b/compiler-rt/test/tsan/sleep_sync.cc
new file mode 100644
index 0000000..b2c6a12
--- /dev/null
+++ b/compiler-rt/test/tsan/sleep_sync.cc
@@ -0,0 +1,32 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int X = 0;
+
+void MySleep() {
+  sleep(1);  // the sleep that must appear in the report
+}
+
+void *Thread(void *p) {
+  barrier_wait(&barrier);
+  MySleep();  // Assume the main thread has done the write.
+  X = 42;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  X = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// ...
+// CHECK:   As if synchronized via sleep:
+// CHECK-NEXT:     #0 sleep
+// CHECK-NEXT:     #1 MySleep
+// CHECK-NEXT:     #2 Thread
diff --git a/compiler-rt/test/tsan/sleep_sync2.cc b/compiler-rt/test/tsan/sleep_sync2.cc
new file mode 100644
index 0000000..a1a7a3a
--- /dev/null
+++ b/compiler-rt/test/tsan/sleep_sync2.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int X = 0;
+
+void *Thread(void *p) {
+  X = 42;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  sleep(1);  // must not appear in the report
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  X = 43;
+  pthread_join(t, 0);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: As if synchronized via sleep
diff --git a/compiler-rt/test/tsan/stack_race.cc b/compiler-rt/test/tsan/stack_race.cc
new file mode 100644
index 0000000..1ada295
--- /dev/null
+++ b/compiler-rt/test/tsan/stack_race.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  *(int*)a = 43;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  int Var = 42;
+  pthread_t t;
+  pthread_create(&t, 0, Thread, &Var);
+  Var = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Location is stack of main thread.
+
diff --git a/compiler-rt/test/tsan/stack_race2.cc b/compiler-rt/test/tsan/stack_race2.cc
new file mode 100644
index 0000000..00e31fb
--- /dev/null
+++ b/compiler-rt/test/tsan/stack_race2.cc
@@ -0,0 +1,29 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread2(void *a) {
+  barrier_wait(&barrier);
+  *(int*)a = 43;
+  return 0;
+}
+
+void *Thread(void *a) {
+  int Var = 42;
+  pthread_t t;
+  pthread_create(&t, 0, Thread2, &Var);
+  Var = 42;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Location is stack of thread T1.
+
diff --git a/compiler-rt/test/tsan/stack_sync_reuse.cc b/compiler-rt/test/tsan/stack_sync_reuse.cc
new file mode 100644
index 0000000..d2bc5cb
--- /dev/null
+++ b/compiler-rt/test/tsan/stack_sync_reuse.cc
@@ -0,0 +1,67 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+// Test case https://github.com/google/sanitizers/issues/494
+// Tsan sees false HB edge on address pointed to by syncp variable.
+// It is false because when acquire is done syncp points to a var in one frame,
+// and during release it points to a var in a different frame.
+// The code is somewhat tricky because it prevents compiler from optimizing
+// our accesses away, structured to not introduce other data races and
+// not introduce other synchronization, and to arrange the vars in different
+// frames to occupy the same address.
+
+// The data race CHECK-NOT below actually must be CHECK, because the program
+// does contain the data race on global.
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: DONE
+
+long global;
+long *syncp;
+long *addr;
+long sink;
+
+void *Thread(void *x) {
+  while (__atomic_load_n(&syncp, __ATOMIC_ACQUIRE) == 0)
+    usleep(1000);  // spin wait
+  global = 42;
+  __atomic_store_n(syncp, 1, __ATOMIC_RELEASE);
+  __atomic_store_n(&syncp, 0, __ATOMIC_RELAXED);
+  return NULL;
+}
+
+void __attribute__((noinline)) foobar() {
+  __attribute__((aligned(64))) long s;
+
+  addr = &s;
+  __atomic_store_n(&s, 0, __ATOMIC_RELAXED);
+  __atomic_store_n(&syncp, &s, __ATOMIC_RELEASE);
+  while (__atomic_load_n(&syncp, __ATOMIC_RELAXED) != 0)
+    usleep(1000);  // spin wait
+}
+
+void __attribute__((noinline)) barfoo() {
+  __attribute__((aligned(64))) long s;
+
+  if (addr != &s) {
+    printf("address mismatch addr=%p &s=%p\n", addr, &s);
+    exit(1);
+  }
+  __atomic_store_n(&addr, &s, __ATOMIC_RELAXED);
+  __atomic_store_n(&s, 0, __ATOMIC_RELAXED);
+  sink = __atomic_load_n(&s, __ATOMIC_ACQUIRE);
+  global = 43;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  foobar();
+  barfoo();
+  pthread_join(t, 0);
+  if (sink != 0)
+    exit(1);
+  fprintf(stderr, "DONE\n");
+  return 0;
+}
+
diff --git a/compiler-rt/test/tsan/static_init1.cc b/compiler-rt/test/tsan/static_init1.cc
new file mode 100644
index 0000000..3e5fb14
--- /dev/null
+++ b/compiler-rt/test/tsan/static_init1.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+struct P {
+  int x;
+  int y;
+};
+
+void *Thread(void *x) {
+  static P p = {rand(), rand()};
+  if (p.x > RAND_MAX || p.y > RAND_MAX)
+    exit(1);
+  return 0;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread, 0);
+  pthread_create(&t[1], 0, Thread, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  printf("PASS\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/static_init2.cc b/compiler-rt/test/tsan/static_init2.cc
new file mode 100644
index 0000000..667aed1
--- /dev/null
+++ b/compiler-rt/test/tsan/static_init2.cc
@@ -0,0 +1,33 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+struct Cache {
+  int x;
+  explicit Cache(int x)
+    : x(x) {
+  }
+};
+
+void foo(Cache *my) {
+  static Cache *c = my ? my : new Cache(rand());
+  if (c->x >= RAND_MAX)
+    exit(1);
+}
+
+void *Thread(void *x) {
+  foo(new Cache(rand()));
+  return 0;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread, 0);
+  pthread_create(&t[1], 0, Thread, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  printf("PASS\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/static_init3.cc b/compiler-rt/test/tsan/static_init3.cc
new file mode 100644
index 0000000..3b9fe62
--- /dev/null
+++ b/compiler-rt/test/tsan/static_init3.cc
@@ -0,0 +1,47 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sched.h>
+
+struct Cache {
+  int x;
+};
+
+Cache g_cache;
+
+Cache *CreateCache() {
+  g_cache.x = rand();
+  return &g_cache;
+}
+
+_Atomic(Cache*) queue;
+
+void *Thread1(void *x) {
+  static Cache *c = CreateCache();
+  __c11_atomic_store(&queue, c, 0);
+  return 0;
+}
+
+void *Thread2(void *x) {
+  Cache *c = 0;
+  for (;;) {
+    c = __c11_atomic_load(&queue, 0);
+    if (c)
+      break;
+    sched_yield();
+  }
+  if (c->x >= RAND_MAX)
+    exit(1);
+  return 0;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  pthread_create(&t[1], 0, Thread2, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/static_init4.cc b/compiler-rt/test/tsan/static_init4.cc
new file mode 100644
index 0000000..85835a2
--- /dev/null
+++ b/compiler-rt/test/tsan/static_init4.cc
@@ -0,0 +1,37 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sched.h>
+
+struct Cache {
+  int x;
+  explicit Cache(int x)
+    : x(x) {
+  }
+};
+
+int g_other;
+
+Cache *CreateCache() {
+  g_other = rand();
+  return new Cache(rand());
+}
+
+void *Thread1(void *x) {
+  static Cache *c = CreateCache();
+  if (c->x == g_other)
+    exit(1);
+  return 0;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  pthread_create(&t[1], 0, Thread1, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  printf("PASS\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/static_init5.cc b/compiler-rt/test/tsan/static_init5.cc
new file mode 100644
index 0000000..961e3a3
--- /dev/null
+++ b/compiler-rt/test/tsan/static_init5.cc
@@ -0,0 +1,42 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sched.h>
+
+struct Cache {
+  int x;
+  explicit Cache(int x)
+    : x(x) {
+  }
+};
+
+void *AsyncInit(void *p) {
+  return new Cache((int)(long)p);
+}
+
+Cache *CreateCache() {
+  pthread_t t;
+  pthread_create(&t, 0, AsyncInit, (void*)(long)rand());
+  void *res;
+  pthread_join(t, &res);
+  return (Cache*)res;
+}
+
+void *Thread1(void *x) {
+  static Cache *c = CreateCache();
+  if (c->x >= RAND_MAX)
+    exit(1);
+  return 0;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  pthread_create(&t[1], 0, Thread1, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  printf("PASS\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/static_init6.cc b/compiler-rt/test/tsan/static_init6.cc
new file mode 100644
index 0000000..77253ea
--- /dev/null
+++ b/compiler-rt/test/tsan/static_init6.cc
@@ -0,0 +1,42 @@
+// RUN: %clangxx_tsan -static-libstdc++ -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sched.h>
+
+struct Cache {
+  int x;
+  explicit Cache(int x)
+    : x(x) {
+  }
+};
+
+void *AsyncInit(void *p) {
+  return new Cache((int)(long)p);
+}
+
+Cache *CreateCache() {
+  pthread_t t;
+  pthread_create(&t, 0, AsyncInit, (void*)(long)rand());
+  void *res;
+  pthread_join(t, &res);
+  return (Cache*)res;
+}
+
+void *Thread1(void *x) {
+  static Cache *c = CreateCache();
+  if (c->x >= RAND_MAX)
+    exit(1);
+  return 0;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  pthread_create(&t[1], 0, Thread1, 0);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  printf("PASS\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/sunrpc.cc b/compiler-rt/test/tsan/sunrpc.cc
new file mode 100644
index 0000000..579816d
--- /dev/null
+++ b/compiler-rt/test/tsan/sunrpc.cc
@@ -0,0 +1,25 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <pthread.h>
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+#include <stdio.h>
+
+void *thr(void *p) {
+  XDR xdrs;
+  char buf[100];
+  xdrmem_create(&xdrs, buf, sizeof(buf), XDR_ENCODE);
+  xdr_destroy(&xdrs);
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  pthread_t th[2];
+  pthread_create(&th[0], 0, thr, 0);
+  pthread_create(&th[1], 0, thr, 0);
+  pthread_join(th[0], 0);
+  pthread_join(th[1], 0);
+  printf("DONE\n");
+  // CHECK: DONE
+  return 0;
+}
diff --git a/compiler-rt/test/tsan/suppress_same_address.cc b/compiler-rt/test/tsan/suppress_same_address.cc
new file mode 100644
index 0000000..3ec13ee
--- /dev/null
+++ b/compiler-rt/test/tsan/suppress_same_address.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+volatile int X;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  X = 42;
+  X = 66;
+  X = 78;
+  return 0;
+}
+
+void *Thread2(void *x) {
+  X = 11;
+  X = 99;
+  X = 73;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread1, 0);
+  Thread2(0);
+  pthread_join(t, 0);
+}
+
+// CHECK: ThreadSanitizer: reported 1 warnings
diff --git a/compiler-rt/test/tsan/suppress_same_stacks.cc b/compiler-rt/test/tsan/suppress_same_stacks.cc
new file mode 100644
index 0000000..9305650
--- /dev/null
+++ b/compiler-rt/test/tsan/suppress_same_stacks.cc
@@ -0,0 +1,27 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+
+volatile int N;  // Prevent loop unrolling.
+int **data;
+
+void *Thread1(void *x) {
+  for (int i = 0; i < N; i++)
+    data[i][0] = 42;
+  return 0;
+}
+
+int main() {
+  N = 4;
+  data = new int*[N];
+  for (int i = 0; i < N; i++)
+    data[i] = new int;
+  pthread_t t;
+  pthread_create(&t, 0, Thread1, 0);
+  Thread1(0);
+  pthread_join(t, 0);
+  for (int i = 0; i < N; i++)
+    delete data[i];
+  delete[] data;
+}
+
+// CHECK: ThreadSanitizer: reported 1 warnings
diff --git a/compiler-rt/test/tsan/suppressions_global.cc b/compiler-rt/test/tsan/suppressions_global.cc
new file mode 100644
index 0000000..8928162
--- /dev/null
+++ b/compiler-rt/test/tsan/suppressions_global.cc
@@ -0,0 +1,29 @@
+// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+int RacyGlobal;
+
+void *Thread1(void *x) {
+  RacyGlobal = 42;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  RacyGlobal = 43;
+  return NULL;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+  return 0;
+}
+
+// CHECK-NOT: failed to open suppressions file
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/suppressions_global.cc.supp b/compiler-rt/test/tsan/suppressions_global.cc.supp
new file mode 100644
index 0000000..5fa8a2e
--- /dev/null
+++ b/compiler-rt/test/tsan/suppressions_global.cc.supp
@@ -0,0 +1,2 @@
+race:RacyGlobal
+
diff --git a/compiler-rt/test/tsan/suppressions_race.cc b/compiler-rt/test/tsan/suppressions_race.cc
new file mode 100644
index 0000000..7a88434
--- /dev/null
+++ b/compiler-rt/test/tsan/suppressions_race.cc
@@ -0,0 +1,31 @@
+// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  Global = 42;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  Global = 43;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+  return 0;
+}
+
+// CHECK-NOT: failed to open suppressions file
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/suppressions_race.cc.supp b/compiler-rt/test/tsan/suppressions_race.cc.supp
new file mode 100644
index 0000000..cbdba76
--- /dev/null
+++ b/compiler-rt/test/tsan/suppressions_race.cc.supp
@@ -0,0 +1,2 @@
+race:Thread1
+
diff --git a/compiler-rt/test/tsan/suppressions_race2.cc b/compiler-rt/test/tsan/suppressions_race2.cc
new file mode 100644
index 0000000..b6566a8
--- /dev/null
+++ b/compiler-rt/test/tsan/suppressions_race2.cc
@@ -0,0 +1,31 @@
+// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  Global = 42;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  Global = 43;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("OK\n");
+  return 0;
+}
+
+// CHECK-NOT: failed to open suppressions file
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+
diff --git a/compiler-rt/test/tsan/suppressions_race2.cc.supp b/compiler-rt/test/tsan/suppressions_race2.cc.supp
new file mode 100644
index 0000000..b3c4dbc
--- /dev/null
+++ b/compiler-rt/test/tsan/suppressions_race2.cc.supp
@@ -0,0 +1,2 @@
+race:Thread2
+
diff --git a/compiler-rt/test/tsan/test.h b/compiler-rt/test/tsan/test.h
new file mode 100644
index 0000000..a681daa
--- /dev/null
+++ b/compiler-rt/test/tsan/test.h
@@ -0,0 +1,69 @@
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <stddef.h>
+#include <sched.h>
+#include <stdarg.h>
+
+#ifdef __APPLE__
+#include <mach/mach_time.h>
+#endif
+
+// TSan-invisible barrier.
+// Tests use it to establish necessary execution order in a way that does not
+// interfere with tsan (does not establish synchronization between threads).
+typedef unsigned long long invisible_barrier_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void __tsan_testonly_barrier_init(invisible_barrier_t *barrier,
+    unsigned count);
+void __tsan_testonly_barrier_wait(invisible_barrier_t *barrier);
+#ifdef __cplusplus
+}
+#endif
+
+static inline void barrier_init(invisible_barrier_t *barrier, unsigned count) {
+  __tsan_testonly_barrier_init(barrier, count);
+}
+
+static inline void barrier_wait(invisible_barrier_t *barrier) {
+  __tsan_testonly_barrier_wait(barrier);
+}
+
+// Default instance of the barrier, but a test can declare more manually.
+invisible_barrier_t barrier;
+
+void print_address(const char *str, int n, ...) {
+  fprintf(stderr, "%s", str);
+  va_list ap;
+  va_start(ap, n);
+  while (n--) {
+    void *p = va_arg(ap, void *);
+#if defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__)
+    // On FreeBSD, the %p conversion specifier works as 0x%x and thus does not
+    // match to the format used in the diagnotic message.
+    fprintf(stderr, "0x%012lx ", (unsigned long) p);
+#elif defined(__mips64)
+    fprintf(stderr, "0x%010lx ", (unsigned long) p);
+#endif
+  }
+  fprintf(stderr, "\n");
+}
+
+#ifdef __APPLE__
+unsigned long long monotonic_clock_ns() {
+  static mach_timebase_info_data_t timebase_info;
+  if (timebase_info.denom == 0) mach_timebase_info(&timebase_info);
+  return (mach_absolute_time() * timebase_info.numer) / timebase_info.denom;
+}
+#else
+unsigned long long monotonic_clock_ns() {
+  struct timespec t;
+  clock_gettime(CLOCK_MONOTONIC, &t);
+  return (unsigned long long)t.tv_sec * 1000000000ull + t.tv_nsec;
+}
+#endif
diff --git a/compiler-rt/test/tsan/thread_detach.c b/compiler-rt/test/tsan/thread_detach.c
new file mode 100644
index 0000000..802d8de
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_detach.c
@@ -0,0 +1,20 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  pthread_detach(t);
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: thread leak
+// CHECK: PASS
diff --git a/compiler-rt/test/tsan/thread_detach2.c b/compiler-rt/test/tsan/thread_detach2.c
new file mode 100644
index 0000000..8133980
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_detach2.c
@@ -0,0 +1,28 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+// Test for https://llvm.org/bugs/show_bug.cgi?id=23235
+// The bug was that synchronization between thread creation and thread start
+// is not established if pthread_create is followed by pthread_detach.
+
+int x;
+
+void *Thread(void *a) {
+  x = 42;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  x = 43;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_detach(t);
+  barrier_wait(&barrier);
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: PASS
diff --git a/compiler-rt/test/tsan/thread_end_with_ignore.cc b/compiler-rt/test/tsan/thread_end_with_ignore.cc
new file mode 100644
index 0000000..79bb08d
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_end_with_ignore.cc
@@ -0,0 +1,24 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
+
+void *Thread(void *x) {
+  AnnotateIgnoreReadsBegin("", 0);
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_join(t, 0);
+}
+
+// CHECK: ThreadSanitizer: thread T1  finished with ignores enabled, created at:
+// CHECK:     #0 pthread_create
+// CHECK:     #1 main
+// CHECK:   Ignore was enabled at:
+// CHECK:     #0 AnnotateIgnoreReadsBegin
+// CHECK:     #1 Thread
+
diff --git a/compiler-rt/test/tsan/thread_end_with_ignore2.cc b/compiler-rt/test/tsan/thread_end_with_ignore2.cc
new file mode 100644
index 0000000..9387ea4
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_end_with_ignore2.cc
@@ -0,0 +1,12 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l);
+
+int main() {
+  AnnotateIgnoreWritesBegin("", 0);
+}
+
+// CHECK: ThreadSanitizer: main thread finished with ignores enabled
+// CHECK:   Ignore was enabled at:
+// CHECK:     #0 AnnotateIgnoreWritesBegin
+// CHECK:     #1 main
+
diff --git a/compiler-rt/test/tsan/thread_end_with_ignore3.cc b/compiler-rt/test/tsan/thread_end_with_ignore3.cc
new file mode 100644
index 0000000..55688b2
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_end_with_ignore3.cc
@@ -0,0 +1,22 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
+extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l);
+
+int main() {
+  AnnotateIgnoreReadsBegin("", 0);
+  AnnotateIgnoreReadsBegin("", 0);
+  AnnotateIgnoreReadsEnd("", 0);
+  AnnotateIgnoreReadsEnd("", 0);
+  AnnotateIgnoreReadsBegin("", 0);
+  AnnotateIgnoreReadsBegin("", 0);
+  AnnotateIgnoreReadsEnd("", 0);
+}
+
+// CHECK: ThreadSanitizer: main thread finished with ignores enabled
+// CHECK:   Ignore was enabled at:
+// CHECK:     #0 AnnotateIgnoreReadsBegin
+// CHECK:     #1 main {{.*}}thread_end_with_ignore3.cc:10
+// CHECK:   Ignore was enabled at:
+// CHECK:     #0 AnnotateIgnoreReadsBegin
+// CHECK:     #1 main {{.*}}thread_end_with_ignore3.cc:11
+
diff --git a/compiler-rt/test/tsan/thread_leak.c b/compiler-rt/test/tsan/thread_leak.c
new file mode 100644
index 0000000..9b850dd
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_leak.c
@@ -0,0 +1,17 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+void *Thread(void *x) {
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_join(t, 0);
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: thread leak
diff --git a/compiler-rt/test/tsan/thread_leak2.c b/compiler-rt/test/tsan/thread_leak2.c
new file mode 100644
index 0000000..fc2942b
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_leak2.c
@@ -0,0 +1,17 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+void *Thread(void *x) {
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_detach(t);
+  printf("PASS\n");
+  return 0;
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: thread leak
diff --git a/compiler-rt/test/tsan/thread_leak3.c b/compiler-rt/test/tsan/thread_leak3.c
new file mode 100644
index 0000000..c09fb71
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_leak3.c
@@ -0,0 +1,19 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  barrier_wait(&barrier);
+  sleep(1);  // wait for the thread to finish and exit
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: thread leak
+// CHECK: SUMMARY: ThreadSanitizer: thread leak{{.*}}main
diff --git a/compiler-rt/test/tsan/thread_leak4.c b/compiler-rt/test/tsan/thread_leak4.c
new file mode 100644
index 0000000..1ebca58
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_leak4.c
@@ -0,0 +1,18 @@
+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+
+void *Thread(void *x) {
+  sleep(100);  // leave the thread "running"
+  return 0;
+}
+
+int main() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  printf("DONE\n");
+  return 0;
+}
+
+// CHECK: DONE
+// CHECK-NOT: WARNING: ThreadSanitizer: thread leak
+
diff --git a/compiler-rt/test/tsan/thread_leak5.c b/compiler-rt/test/tsan/thread_leak5.c
new file mode 100644
index 0000000..acdbd1d
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_leak5.c
@@ -0,0 +1,22 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  volatile int N = 5;  // prevent loop unrolling
+  barrier_init(&barrier, N + 1);
+  for (int i = 0; i < N; i++) {
+    pthread_t t;
+    pthread_create(&t, 0, Thread, 0);
+  }
+  barrier_wait(&barrier);
+  sleep(1);  // wait for the threads to finish and exit
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: thread leak
+// CHECK:   And 4 more similar thread leaks
diff --git a/compiler-rt/test/tsan/thread_name.cc b/compiler-rt/test/tsan/thread_name.cc
new file mode 100644
index 0000000..80d30b8
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_name.cc
@@ -0,0 +1,47 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+#if defined(__linux__)
+#define USE_PTHREAD_SETNAME_NP __GLIBC_PREREQ(2, 12)
+#elif defined(__FreeBSD__)
+#include <pthread_np.h>
+#define USE_PTHREAD_SETNAME_NP 1
+#define pthread_setname_np pthread_set_name_np
+#else
+#define USE_PTHREAD_SETNAME_NP 0
+#endif
+
+extern "C" void AnnotateThreadName(const char *f, int l, const char *name);
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  AnnotateThreadName(__FILE__, __LINE__, "Thread1");
+  Global++;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+#if USE_PTHREAD_SETNAME_NP
+  pthread_setname_np(pthread_self(), "Thread2");
+#else
+  AnnotateThreadName(__FILE__, __LINE__, "Thread2");
+#endif
+  Global--;
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Thread T1 'Thread1'
+// CHECK:   Thread T2 'Thread2'
diff --git a/compiler-rt/test/tsan/thread_name2.cc b/compiler-rt/test/tsan/thread_name2.cc
new file mode 100644
index 0000000..d7ed0f0
--- /dev/null
+++ b/compiler-rt/test/tsan/thread_name2.cc
@@ -0,0 +1,40 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+// OS X doesn't have pthread_setname_np(tid, name).
+// UNSUPPORTED: darwin
+
+#if defined(__FreeBSD__)
+#include <pthread_np.h>
+#define pthread_setname_np pthread_set_name_np
+#endif
+
+long long Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  Global++;
+  return 0;
+}
+
+void *Thread2(void *x) {
+  pthread_setname_np(pthread_self(), "foobar2");
+  Global--;
+  barrier_wait(&barrier);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 3);
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, 0);
+  pthread_create(&t[1], 0, Thread2, 0);
+  pthread_setname_np(t[0], "foobar1");
+  barrier_wait(&barrier);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Thread T1 'foobar1'
+// CHECK:   Thread T2 'foobar2'
diff --git a/compiler-rt/test/tsan/tiny_race.c b/compiler-rt/test/tsan/tiny_race.c
new file mode 100644
index 0000000..b6937fe
--- /dev/null
+++ b/compiler-rt/test/tsan/tiny_race.c
@@ -0,0 +1,22 @@
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+int Global;
+
+void *Thread1(void *x) {
+  barrier_wait(&barrier);
+  Global = 42;
+  return x;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread1, 0);
+  Global = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  return Global;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/tls_race.cc b/compiler-rt/test/tsan/tls_race.cc
new file mode 100644
index 0000000..b43a514
--- /dev/null
+++ b/compiler-rt/test/tsan/tls_race.cc
@@ -0,0 +1,23 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+#include "test.h"
+
+void *Thread(void *a) {
+  barrier_wait(&barrier);
+  *(int*)a = 43;
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  static __thread int Var = 42;
+  pthread_t t;
+  pthread_create(&t, 0, Thread, &Var);
+  Var = 43;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-Linux:   Location is TLS of main thread.
+// CHECK-FreeBSD:   Location is TLS of main thread.
+// CHECK-Darwin:   Location is heap block of size 4
diff --git a/compiler-rt/test/tsan/tls_race2.cc b/compiler-rt/test/tsan/tls_race2.cc
new file mode 100644
index 0000000..b04ff67
--- /dev/null
+++ b/compiler-rt/test/tsan/tls_race2.cc
@@ -0,0 +1,30 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
+#include "test.h"
+
+void *Thread2(void *a) {
+  barrier_wait(&barrier);
+  *(int*)a = 43;
+  return 0;
+}
+
+void *Thread(void *a) {
+  static __thread int Var = 42;
+  pthread_t t;
+  pthread_create(&t, 0, Thread2, &Var);
+  Var = 42;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-Linux:   Location is TLS of thread T1.
+// CHECK-FreeBSD:   Location is TLS of thread T1.
+// CHECK-Darwin:   Location is heap block of size 4
diff --git a/compiler-rt/test/tsan/tsan-vs-gvn.cc b/compiler-rt/test/tsan/tsan-vs-gvn.cc
new file mode 100644
index 0000000..950f5d3
--- /dev/null
+++ b/compiler-rt/test/tsan/tsan-vs-gvn.cc
@@ -0,0 +1,38 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_tsan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_tsan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
+//
+// Check that load widening is not tsan-hostile.
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+
+struct {
+  int i;
+  char c1, c2, c3, c4;
+} S;
+
+int G;
+
+void *Thread1(void *x) {
+  G = S.c1 + S.c3;
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  S.c2 = 1;
+  return NULL;
+}
+
+int main() {
+  pthread_t t[2];
+  memset(&S, 123, sizeof(S));
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("PASS\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK: PASS
diff --git a/compiler-rt/test/tsan/unaligned_norace.cc b/compiler-rt/test/tsan/unaligned_norace.cc
new file mode 100644
index 0000000..94df1cf
--- /dev/null
+++ b/compiler-rt/test/tsan/unaligned_norace.cc
@@ -0,0 +1,84 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+uint64_t objs[8*3*3*2][3];
+
+extern "C" {
+void __tsan_unaligned_read2(void *addr);
+void __tsan_unaligned_read4(void *addr);
+void __tsan_unaligned_read8(void *addr);
+void __tsan_unaligned_write2(void *addr);
+void __tsan_unaligned_write4(void *addr);
+void __tsan_unaligned_write8(void *addr);
+}
+
+static void access(char *p, int sz, int rw) {
+  if (rw) {
+    switch (sz) {
+    case 0: __tsan_unaligned_write2(p); break;
+    case 1: __tsan_unaligned_write4(p); break;
+    case 2: __tsan_unaligned_write8(p); break;
+    default: exit(1);
+    }
+  } else {
+    switch (sz) {
+    case 0: __tsan_unaligned_read2(p); break;
+    case 1: __tsan_unaligned_read4(p); break;
+    case 2: __tsan_unaligned_read8(p); break;
+    default: exit(1);
+    }
+  }
+}
+
+static int accesssize(int sz) {
+  switch (sz) {
+  case 0: return 2;
+  case 1: return 4;
+  case 2: return 8;
+  }
+  exit(1);
+}
+
+void Test(bool main) {
+  uint64_t *obj = objs[0];
+  for (int off = 0; off < 8; off++) {
+    for (int sz1 = 0; sz1 < 3; sz1++) {
+      for (int sz2 = 0; sz2 < 3; sz2++) {
+        for (int rw = 0; rw < 2; rw++) {
+          char *p = (char*)obj + off;
+          if (main) {
+            // printf("thr=%d off=%d sz1=%d sz2=%d rw=%d p=%p\n",
+            //        main, off, sz1, sz2, rw, p);
+            access(p, sz1, true);
+          } else {
+            p += accesssize(sz1);
+            // printf("thr=%d off=%d sz1=%d sz2=%d rw=%d p=%p\n",
+            //        main, off, sz1, sz2, rw, p);
+            access(p, sz2, rw);
+          }
+          obj += 3;
+        }
+      }
+    }
+  }
+}
+
+void *Thread(void *p) {
+  (void)p;
+  Test(false);
+  return 0;
+}
+
+int main() {
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  Test(true);
+  pthread_join(th, 0);
+  printf("OK\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer:
+// CHECK: OK
diff --git a/compiler-rt/test/tsan/unaligned_race.cc b/compiler-rt/test/tsan/unaligned_race.cc
new file mode 100644
index 0000000..030642a
--- /dev/null
+++ b/compiler-rt/test/tsan/unaligned_race.cc
@@ -0,0 +1,138 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <stdint.h>
+
+#define NOINLINE __attribute__((noinline))
+
+volatile uint64_t objs[8*2*(2 + 4 + 8)][2];
+
+extern "C" {
+uint16_t __sanitizer_unaligned_load16(volatile void *addr);
+uint32_t __sanitizer_unaligned_load32(volatile void *addr);
+uint64_t __sanitizer_unaligned_load64(volatile void *addr);
+void __sanitizer_unaligned_store16(volatile void *addr, uint16_t v);
+void __sanitizer_unaligned_store32(volatile void *addr, uint32_t v);
+void __sanitizer_unaligned_store64(volatile void *addr, uint64_t v);
+}
+
+// All this mess is to generate unique stack for each race,
+// otherwise tsan will suppress similar stacks.
+
+static NOINLINE void access(volatile char *p, int sz, int rw) {
+  if (rw) {
+    switch (sz) {
+    case 0: __sanitizer_unaligned_store16(p, 0); break;
+    case 1: __sanitizer_unaligned_store32(p, 0); break;
+    case 2: __sanitizer_unaligned_store64(p, 0); break;
+    default: exit(1);
+    }
+  } else {
+    switch (sz) {
+    case 0: __sanitizer_unaligned_load16(p); break;
+    case 1: __sanitizer_unaligned_load32(p); break;
+    case 2: __sanitizer_unaligned_load64(p); break;
+    default: exit(1);
+    }
+  }
+}
+
+static int accesssize(int sz) {
+  switch (sz) {
+  case 0: return 2;
+  case 1: return 4;
+  case 2: return 8;
+  }
+  exit(1);
+}
+
+template<int off, int off2>
+static NOINLINE void access3(bool main, int sz1, bool rw, volatile char *p) {
+  p += off;
+  if (main) {
+    access(p, sz1, true);
+  } else {
+    p += off2;
+    if (rw) {
+      *p = 42;
+    } else {
+       if (*p == 42)
+         printf("bingo!\n");
+    }
+  }
+}
+
+template<int off>
+static NOINLINE void
+access2(bool main, int sz1, int off2, bool rw, volatile char *obj) {
+  if (off2 == 0)
+    access3<off, 0>(main, sz1, rw, obj);
+  else if (off2 == 1)
+    access3<off, 1>(main, sz1, rw, obj);
+  else if (off2 == 2)
+    access3<off, 2>(main, sz1, rw, obj);
+  else if (off2 == 3)
+    access3<off, 3>(main, sz1, rw, obj);
+  else if (off2 == 4)
+    access3<off, 4>(main, sz1, rw, obj);
+  else if (off2 == 5)
+    access3<off, 5>(main, sz1, rw, obj);
+  else if (off2 == 6)
+    access3<off, 6>(main, sz1, rw, obj);
+  else if (off2 == 7)
+    access3<off, 7>(main, sz1, rw, obj);
+}
+
+static NOINLINE void
+access1(bool main, int off, int sz1, int off2, bool rw, char *obj) {
+  if (off == 0)
+    access2<0>(main, sz1, off2, rw, obj);
+  else if (off == 1)
+    access2<1>(main, sz1, off2, rw, obj);
+  else if (off == 2)
+    access2<2>(main, sz1, off2, rw, obj);
+  else if (off == 3)
+    access2<3>(main, sz1, off2, rw, obj);
+  else if (off == 4)
+    access2<4>(main, sz1, off2, rw, obj);
+  else if (off == 5)
+    access2<5>(main, sz1, off2, rw, obj);
+  else if (off == 6)
+    access2<6>(main, sz1, off2, rw, obj);
+  else if (off == 7)
+    access2<7>(main, sz1, off2, rw, obj);
+}
+
+NOINLINE void Test(bool main) {
+  volatile uint64_t *obj = objs[0];
+  for (int off = 0; off < 8; off++) {
+    for (int sz1 = 0; sz1 < 3; sz1++) {
+      for (int off2 = 0; off2 < accesssize(sz1); off2++) {
+        for (int rw = 0; rw < 2; rw++) {
+          // printf("thr=%d off=%d sz1=%d off2=%d rw=%d p=%p\n",
+          //        main, off, sz1, off2, rw, obj);
+          access1(main, off, sz1, off2, rw, (char*)obj);
+          obj += 2;
+        }
+      }
+    }
+  }
+}
+
+void *Thread(void *p) {
+  (void)p;
+  barrier_wait(&barrier);
+  Test(false);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t th;
+  pthread_create(&th, 0, Thread, 0);
+  Test(true);
+  barrier_wait(&barrier);
+  pthread_join(th, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: ThreadSanitizer: reported 224 warnings
diff --git a/compiler-rt/test/tsan/vfork.cc b/compiler-rt/test/tsan/vfork.cc
new file mode 100644
index 0000000..98a8262
--- /dev/null
+++ b/compiler-rt/test/tsan/vfork.cc
@@ -0,0 +1,52 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+// UNSUPPORTED: darwin
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+int fds[2];
+int X;
+
+void *Thread1(void *x) {
+  X = 42;
+  write(fds[1], "a", 1);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  char buf;
+  while (read(fds[0], &buf, 1) != 1) {
+  }
+  X = 43;
+  return NULL;
+}
+
+int main() {
+  pipe(fds);
+  int pid = vfork();
+  if (pid < 0) {
+    printf("FAIL to vfork\n");
+    exit(1);
+  }
+  if (pid == 0) {  // child
+    // Closing of fds must not affect parent process.
+    // Strictly saying this is undefined behavior, because vfork child is not
+    // allowed to call any functions other than exec/exit. But this is what
+    // openjdk does.
+    close(fds[0]);
+    close(fds[1]);
+    _exit(0);
+  }
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  printf("DONE\n");
+}
+
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: FAIL to vfork
+// CHECK: DONE
diff --git a/compiler-rt/test/tsan/virtual_inheritance_compile_bug.cc b/compiler-rt/test/tsan/virtual_inheritance_compile_bug.cc
new file mode 100644
index 0000000..7da581d
--- /dev/null
+++ b/compiler-rt/test/tsan/virtual_inheritance_compile_bug.cc
@@ -0,0 +1,15 @@
+// Regression test for https://github.com/google/sanitizers/issues/410.
+// The C++ variant is much more compact that the LLVM IR equivalent.
+
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <stdio.h>
+struct AAA              {  virtual long aaa () { return 0; } };  // NOLINT
+struct BBB: virtual AAA { unsigned long bbb; };  // NOLINT
+struct CCC: virtual AAA { };
+struct DDD: CCC, BBB { DDD(); };  // NOLINT
+DDD::DDD()  { }
+int main() {
+  DDD d;
+  printf("OK\n");
+}
+// CHECK: OK
diff --git a/compiler-rt/test/tsan/vptr_benign_race.cc b/compiler-rt/test/tsan/vptr_benign_race.cc
new file mode 100644
index 0000000..c006895
--- /dev/null
+++ b/compiler-rt/test/tsan/vptr_benign_race.cc
@@ -0,0 +1,59 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+struct A {
+  A() {
+    pthread_mutex_init(&m, 0);
+    pthread_cond_init(&c, 0);
+    signaled = false;
+  }
+  virtual void F() {
+  }
+  void Done() {
+    pthread_mutex_lock(&m);
+    signaled = true;
+    pthread_cond_signal(&c);
+    pthread_mutex_unlock(&m);
+  }
+  virtual ~A() {
+  }
+  pthread_mutex_t m;
+  pthread_cond_t c;
+  bool signaled;
+};
+
+struct B : A {
+  virtual void F() {
+  }
+  virtual ~B() {
+    pthread_mutex_lock(&m);
+    while (!signaled)
+      pthread_cond_wait(&c, &m);
+    pthread_mutex_unlock(&m);
+  }
+};
+
+static A *obj = new B;
+
+void *Thread1(void *x) {
+  obj->F();
+  obj->Done();
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  delete obj;
+  return NULL;
+}
+
+int main() {
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+  fprintf(stderr, "PASS\n");
+}
+// CHECK: PASS
+// CHECK-NOT: WARNING: ThreadSanitizer: data race
diff --git a/compiler-rt/test/tsan/vptr_harmful_race.cc b/compiler-rt/test/tsan/vptr_harmful_race.cc
new file mode 100644
index 0000000..d15b396
--- /dev/null
+++ b/compiler-rt/test/tsan/vptr_harmful_race.cc
@@ -0,0 +1,51 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <semaphore.h>
+
+struct A {
+  A() {
+    sem_init(&sem_, 0, 0);
+  }
+  virtual void F() {
+  }
+  void Done() {
+    sem_post(&sem_);
+  }
+  virtual ~A() {
+    sem_wait(&sem_);
+    sem_destroy(&sem_);
+  }
+  sem_t sem_;
+};
+
+struct B : A {
+  virtual void F() {
+  }
+  virtual ~B() { }
+};
+
+static A *obj = new B;
+
+void *Thread1(void *x) {
+  obj->F();
+  obj->Done();
+  barrier_wait(&barrier);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  delete obj;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race on vptr
diff --git a/compiler-rt/test/tsan/vptr_harmful_race2.cc b/compiler-rt/test/tsan/vptr_harmful_race2.cc
new file mode 100644
index 0000000..a56b74c
--- /dev/null
+++ b/compiler-rt/test/tsan/vptr_harmful_race2.cc
@@ -0,0 +1,51 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <semaphore.h>
+
+struct A {
+  A() {
+    sem_init(&sem_, 0, 0);
+  }
+  virtual void F() {
+  }
+  void Done() {
+    sem_post(&sem_);
+  }
+  virtual ~A() {
+    sem_wait(&sem_);
+    sem_destroy(&sem_);
+  }
+  sem_t sem_;
+};
+
+struct B : A {
+  virtual void F() {
+  }
+  virtual ~B() { }
+};
+
+static A *obj = new B;
+
+void *Thread1(void *x) {
+  obj->F();
+  barrier_wait(&barrier);
+  obj->Done();
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  delete obj;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race on vptr
diff --git a/compiler-rt/test/tsan/vptr_harmful_race3.cc b/compiler-rt/test/tsan/vptr_harmful_race3.cc
new file mode 100644
index 0000000..3810a10
--- /dev/null
+++ b/compiler-rt/test/tsan/vptr_harmful_race3.cc
@@ -0,0 +1,53 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+#include <semaphore.h>
+
+struct A {
+  A() {
+    sem_init(&sem_, 0, 0);
+  }
+  virtual void F() {
+  }
+  void Done() {
+    sem_post(&sem_);
+  }
+  virtual ~A() {
+    sem_wait(&sem_);
+    sem_destroy(&sem_);
+  }
+  sem_t sem_;
+};
+
+struct B : A {
+  virtual void F() {
+  }
+  virtual ~B() { }
+};
+
+static A *obj = new B;
+static void (A::*fn)() = &A::F;
+
+void *Thread1(void *x) {
+  (obj->*fn)();
+  barrier_wait(&barrier);
+  obj->Done();
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  barrier_wait(&barrier);
+  delete obj;
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t t[2];
+  pthread_create(&t[0], NULL, Thread1, NULL);
+  pthread_create(&t[1], NULL, Thread2, NULL);
+  pthread_join(t[0], NULL);
+  pthread_join(t[1], NULL);
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race on vptr
+
diff --git a/compiler-rt/test/tsan/vptr_harmful_race4.cc b/compiler-rt/test/tsan/vptr_harmful_race4.cc
new file mode 100644
index 0000000..543514d
--- /dev/null
+++ b/compiler-rt/test/tsan/vptr_harmful_race4.cc
@@ -0,0 +1,34 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+struct A {
+  virtual void F() {
+  }
+
+  virtual ~A() {
+  }
+};
+
+struct B : A {
+  virtual void F() {
+  }
+};
+
+void *Thread(void *x) {
+  barrier_wait(&barrier);
+  ((A*)x)->F();
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  A *obj = new B;
+  pthread_t t;
+  pthread_create(&t, 0, Thread, obj);
+  delete obj;
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+}
+
+// CHECK: WARNING: ThreadSanitizer: heap-use-after-free (virtual call vs free)
+
diff --git a/compiler-rt/test/tsan/write_in_reader_lock.cc b/compiler-rt/test/tsan/write_in_reader_lock.cc
new file mode 100644
index 0000000..3f7cb35
--- /dev/null
+++ b/compiler-rt/test/tsan/write_in_reader_lock.cc
@@ -0,0 +1,36 @@
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
+#include "test.h"
+
+pthread_rwlock_t rwlock;
+int GLOB;
+
+void *Thread1(void *p) {
+  (void)p;
+  pthread_rwlock_rdlock(&rwlock);
+  barrier_wait(&barrier);
+  // Write under reader lock.
+  GLOB++;
+  pthread_rwlock_unlock(&rwlock);
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  barrier_init(&barrier, 2);
+  pthread_rwlock_init(&rwlock, NULL);
+  pthread_rwlock_rdlock(&rwlock);
+  pthread_t t;
+  pthread_create(&t, 0, Thread1, 0);
+  volatile int x = GLOB;
+  (void)x;
+  pthread_rwlock_unlock(&rwlock);
+  barrier_wait(&barrier);
+  pthread_join(t, 0);
+  pthread_rwlock_destroy(&rwlock);
+  return 0;
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 4 at {{.*}} by thread T1{{.*}}:
+// CHECK:     #0 Thread1(void*) {{.*}}write_in_reader_lock.cc:12
+// CHECK:   Previous read of size 4 at {{.*}} by main thread{{.*}}:
+// CHECK:     #0 main {{.*}}write_in_reader_lock.cc:23
diff --git a/compiler-rt/test/ubsan/CMakeLists.txt b/compiler-rt/test/ubsan/CMakeLists.txt
new file mode 100644
index 0000000..0938ea2
--- /dev/null
+++ b/compiler-rt/test/ubsan/CMakeLists.txt
@@ -0,0 +1,48 @@
+set(UBSAN_LIT_TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(UBSAN_TESTSUITES)
+set(UBSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+
+macro(add_ubsan_testsuite test_mode sanitizer arch)
+  set(UBSAN_LIT_TEST_MODE "${test_mode}")
+  set(CONFIG_NAME ${UBSAN_LIT_TEST_MODE}-${arch})
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg)
+  list(APPEND UBSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  if(NOT COMPILER_RT_STANDALONE_BUILD)
+    list(APPEND UBSAN_TEST_DEPS ${sanitizer})
+  endif()
+endmacro()
+
+set(UBSAN_TEST_ARCH ${UBSAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(UBSAN_SUPPORTED_ARCH UBSAN_TEST_ARCH)
+endif()
+
+foreach(arch ${UBSAN_TEST_ARCH})
+  set(UBSAN_TEST_TARGET_ARCH ${arch})
+  if(${arch} MATCHES "arm|aarch64")
+    # This is only true if we're cross-compiling.
+    set(UBSAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
+  else()
+    get_target_flags_for_arch(${arch} UBSAN_TEST_TARGET_CFLAGS)
+    string(REPLACE ";" " " UBSAN_TEST_TARGET_CFLAGS "${UBSAN_TEST_TARGET_CFLAGS}")
+  endif()
+  add_ubsan_testsuite("Standalone" ubsan ${arch})
+
+  if(COMPILER_RT_HAS_ASAN AND ";${ASAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+    add_ubsan_testsuite("AddressSanitizer" asan ${arch})
+  endif()
+  if(COMPILER_RT_HAS_MSAN AND ";${MSAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+    add_ubsan_testsuite("MemorySanitizer" msan ${arch})
+  endif()
+  if(COMPILER_RT_HAS_TSAN AND ";${TSAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+    add_ubsan_testsuite("ThreadSanitizer" tsan ${arch})
+  endif()
+endforeach()
+
+add_lit_testsuite(check-ubsan "Running UndefinedBehaviorSanitizer tests"
+  ${UBSAN_TESTSUITES}
+  DEPENDS ${UBSAN_TEST_DEPS})
+set_target_properties(check-ubsan PROPERTIES FOLDER "UBSan tests")
diff --git a/compiler-rt/test/ubsan/TestCases/Float/cast-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Float/cast-overflow.cpp
new file mode 100644
index 0000000..1551bf5
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Float/cast-overflow.cpp
@@ -0,0 +1,151 @@
+// RUN: %clangxx -fsanitize=float-cast-overflow %s -o %t
+// RUN: %run %t _
+// RUN: %env_ubsan_opts=print_summary=1:report_error_type=1 %run %t 0 2>&1 | FileCheck %s --check-prefix=CHECK-0
+// RUN: %run %t 1 2>&1 | FileCheck %s --check-prefix=CHECK-1
+// RUN: %run %t 2 2>&1 | FileCheck %s --check-prefix=CHECK-2
+// RUN: %run %t 3 2>&1 | FileCheck %s --check-prefix=CHECK-3
+// RUN: %run %t 4 2>&1 | FileCheck %s --check-prefix=CHECK-4
+// RUN: %run %t 5 2>&1 | FileCheck %s --check-prefix=CHECK-5
+// RUN: %run %t 6 2>&1 | FileCheck %s --check-prefix=CHECK-6
+// FIXME: %run %t 7 2>&1 | FileCheck %s --check-prefix=CHECK-7
+// FIXME: not %run %t 8 2>&1 | FileCheck %s --check-prefix=CHECK-8
+// RUN: not %run %t 9 2>&1 | FileCheck %s --check-prefix=CHECK-9
+
+// This test assumes float and double are IEEE-754 single- and double-precision.
+
+#if defined(__APPLE__)
+# include <machine/endian.h>
+# define BYTE_ORDER __DARWIN_BYTE_ORDER
+# define BIG_ENDIAN __DARWIN_BIG_ENDIAN
+# define LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN
+#elif defined(__FreeBSD__)
+# include <sys/endian.h>
+# define BYTE_ORDER _BYTE_ORDER
+# define BIG_ENDIAN _BIG_ENDIAN
+# define LITTLE_ENDIAN _LITTLE_ENDIAN
+#elif defined(_WIN32)
+# define BYTE_ORDER 0
+# define BIG_ENDIAN 1
+# define LITTLE_ENDIAN 0
+#else
+# include <endian.h>
+# define BYTE_ORDER __BYTE_ORDER
+# define BIG_ENDIAN __BIG_ENDIAN
+# define LITTLE_ENDIAN __LITTLE_ENDIAN
+#endif  // __APPLE__
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+float Inf;
+float NaN;
+
+int main(int argc, char **argv) {
+  float MaxFloatRepresentableAsInt = 0x7fffff80;
+  (int)MaxFloatRepresentableAsInt; // ok
+  (int)-MaxFloatRepresentableAsInt; // ok
+
+  float MinFloatRepresentableAsInt = -0x7fffffff - 1;
+  (int)MinFloatRepresentableAsInt; // ok
+
+  float MaxFloatRepresentableAsUInt = 0xffffff00u;
+  (unsigned int)MaxFloatRepresentableAsUInt; // ok
+
+#ifdef __SIZEOF_INT128__
+  unsigned __int128 FloatMaxAsUInt128 = -((unsigned __int128)1 << 104);
+  (void)(float)FloatMaxAsUInt128; // ok
+#endif
+
+  float NearlyMinusOne = -0.99999;
+  unsigned Zero = NearlyMinusOne; // ok
+
+  // Build a '+Inf'.
+#if BYTE_ORDER == LITTLE_ENDIAN
+  char InfVal[] = { 0x00, 0x00, 0x80, 0x7f };
+#else
+  char InfVal[] = { 0x7f, 0x80, 0x00, 0x00 };
+#endif
+  float Inf;
+  memcpy(&Inf, InfVal, 4);
+
+  // Build a 'NaN'.
+#if BYTE_ORDER == LITTLE_ENDIAN
+  char NaNVal[] = { 0x01, 0x00, 0x80, 0x7f };
+#else
+  char NaNVal[] = { 0x7f, 0x80, 0x00, 0x01 };
+#endif
+  float NaN;
+  memcpy(&NaN, NaNVal, 4);
+
+  double DblInf = (double)Inf; // ok
+
+  switch (argv[1][0]) {
+    // FIXME: Produce a source location for these checks and test for it here.
+
+    // Floating point -> integer overflow.
+  case '0': {
+    // Note that values between 0x7ffffe00 and 0x80000000 may or may not
+    // successfully round-trip, depending on the rounding mode.
+    // CHECK-0: {{.*}}cast-overflow.cpp:[[@LINE+1]]:27: runtime error: value 2.14748{{.*}} is outside the range of representable values of type 'int'
+    static int test_int = MaxFloatRepresentableAsInt + 0x80;
+    // CHECK-0: SUMMARY: {{.*}}Sanitizer: float-cast-overflow {{.*}}cast-overflow.cpp:[[@LINE-1]]
+    return 0;
+    }
+  case '1': {
+    // CHECK-1: {{.*}}cast-overflow.cpp:[[@LINE+1]]:27: runtime error: value -2.14748{{.*}} is outside the range of representable values of type 'int'
+    static int test_int = MinFloatRepresentableAsInt - 0x100;
+    return 0;
+  }
+  case '2': {
+    // CHECK-2: {{.*}}cast-overflow.cpp:[[@LINE+2]]:37: runtime error: value -1 is outside the range of representable values of type 'unsigned int'
+    volatile float f = -1.0;
+    volatile unsigned u = (unsigned)f;
+    return 0;
+  }
+  case '3': {
+    // CHECK-3: {{.*}}cast-overflow.cpp:[[@LINE+1]]:37: runtime error: value 4.2949{{.*}} is outside the range of representable values of type 'unsigned int'
+    static int test_int = (unsigned)(MaxFloatRepresentableAsUInt + 0x100);
+    return 0;
+  }
+
+  case '4': {
+    // CHECK-4: {{.*}}cast-overflow.cpp:[[@LINE+1]]:27: runtime error: value {{.*}} is outside the range of representable values of type 'int'
+    static int test_int = Inf;
+    return 0;
+  }
+  case '5': {
+    // CHECK-5: {{.*}}cast-overflow.cpp:[[@LINE+1]]:27: runtime error: value {{.*}} is outside the range of representable values of type 'int'
+    static int test_int = NaN;
+    return 0;
+  }
+
+    // Integer -> floating point overflow.
+  case '6': {
+    // CHECK-6: cast-overflow.cpp:[[@LINE+2]]:{{34: runtime error: value 0xffffff00000000000000000000000001 is outside the range of representable values of type 'float'| __int128 not supported}}
+#if defined(__SIZEOF_INT128__) && !defined(_WIN32)
+    static int test_int = (float)(FloatMaxAsUInt128 + 1);
+    return 0;
+#else
+    // Print the same line as the check above. That way the test is robust to
+    // line changes around it
+    printf("%s:%d: __int128 not supported", __FILE__, __LINE__ - 5);
+    return 0;
+#endif
+  }
+  // FIXME: The backend cannot lower __fp16 operations on x86 yet.
+  //case '7':
+  //  (__fp16)65504; // ok
+  //  // CHECK-7: runtime error: value 65505 is outside the range of representable values of type '__fp16'
+  //  return (__fp16)65505;
+
+    // Floating point -> floating point overflow.
+  case '8':
+    // CHECK-8: {{.*}}cast-overflow.cpp:[[@LINE+1]]:19: runtime error: value 1e+39 is outside the range of representable values of type 'float'
+    return (float)1e39;
+  case '9':
+    volatile long double ld = 300.0;
+    // CHECK-9: {{.*}}cast-overflow.cpp:[[@LINE+1]]:14: runtime error: value 300 is outside the range of representable values of type 'char'
+    char c = ld;
+    return c;
+  }
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/add-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/add-overflow.cpp
new file mode 100644
index 0000000..301941b
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/add-overflow.cpp
@@ -0,0 +1,32 @@
+// RUN: %clangxx -DADD_I32 -fsanitize=signed-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I32
+// RUN: %clangxx -DADD_I64 -fsanitize=signed-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I64
+// RUN: %clangxx -DADD_I128 -fsanitize=signed-integer-overflow %s -o %t3 && %run %t3 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I128
+
+#include <stdint.h>
+#include <stdio.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(int8_t(0x7f) + int8_t(0x7f));
+  (void)(int16_t(0x3fff) + int16_t(0x4000));
+
+#ifdef ADD_I32
+  int32_t k = 0x12345678;
+  k += 0x789abcde;
+  // CHECK-ADD_I32: add-overflow.cpp:[[@LINE-1]]:5: runtime error: signed integer overflow: 305419896 + 2023406814 cannot be represented in type 'int'
+#endif
+
+#ifdef ADD_I64
+  (void)(int64_t(8000000000000000000ll) + int64_t(2000000000000000000ll));
+  // CHECK-ADD_I64: 8000000000000000000 + 2000000000000000000 cannot be represented in type '{{long( long)?}}'
+#endif
+
+#ifdef ADD_I128
+# if defined(__SIZEOF_INT128__) && !defined(_WIN32)
+  (void)((__int128_t(1) << 126) + (__int128_t(1) << 126));
+# else
+  puts("__int128 not supported");
+# endif
+  // CHECK-ADD_I128: {{0x40000000000000000000000000000000 \+ 0x40000000000000000000000000000000 cannot be represented in type '__int128'|__int128 not supported}}
+#endif
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/div-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/div-overflow.cpp
new file mode 100644
index 0000000..76dd60d
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/div-overflow.cpp
@@ -0,0 +1,10 @@
+// RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdint.h>
+
+int main() {
+  unsigned(0x80000000) / -1;
+
+  // CHECK: div-overflow.cpp:9:23: runtime error: division of -2147483648 by -1 cannot be represented in type 'int'
+  int32_t(0x80000000) / -1;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/div-zero.cpp b/compiler-rt/test/ubsan/TestCases/Integer/div-zero.cpp
new file mode 100644
index 0000000..68b01af
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/div-zero.cpp
@@ -0,0 +1,15 @@
+// RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND=0 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND=1U %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx -fsanitize=float-divide-by-zero -DDIVIDEND=1.5 %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND='intmax(123)' %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#if defined(__SIZEOF_INT128__) && !defined(_WIN32)
+typedef __int128 intmax;
+#else
+typedef long long intmax;
+#endif
+
+int main() {
+  // CHECK: div-zero.cpp:[[@LINE+1]]:12: runtime error: division by zero
+  DIVIDEND / 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/incdec-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/incdec-overflow.cpp
new file mode 100644
index 0000000..0609030
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/incdec-overflow.cpp
@@ -0,0 +1,16 @@
+// RUN: %clangxx -DOP=n++ -fsanitize=signed-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck %s --check-prefix=PLUS
+// RUN: %clangxx -DOP=++n -fsanitize=signed-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck %s --check-prefix=PLUS
+// RUN: %clangxx -DOP=m-- -fsanitize=signed-integer-overflow %s -o %t3 && %run %t3 2>&1 | FileCheck %s --check-prefix=MINUS
+// RUN: %clangxx -DOP=--m -fsanitize=signed-integer-overflow %s -o %t4 && %run %t4 2>&1 | FileCheck %s --check-prefix=MINUS
+
+#include <stdint.h>
+
+int main() {
+  int n = 0x7ffffffd;
+  n++;
+  n++;
+  int m = -n - 1;
+  OP;
+  // PLUS: incdec-overflow.cpp:[[@LINE-1]]:3: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'
+  // MINUS: incdec-overflow.cpp:[[@LINE-2]]:3: runtime error: signed integer overflow: -2147483648 - 1 cannot be represented in type 'int'
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/mul-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/mul-overflow.cpp
new file mode 100644
index 0000000..20fece5
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/mul-overflow.cpp
@@ -0,0 +1,14 @@
+// RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdint.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(int8_t(-2) * int8_t(0x7f));
+  (void)(int16_t(0x7fff) * int16_t(0x7fff));
+  (void)(uint16_t(0xffff) * int16_t(0x7fff));
+  (void)(uint16_t(0xffff) * uint16_t(0x8000));
+
+  // CHECK: mul-overflow.cpp:13:27: runtime error: signed integer overflow: 65535 * 32769 cannot be represented in type 'int'
+  (void)(uint16_t(0xffff) * uint16_t(0x8001));
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/negate-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/negate-overflow.cpp
new file mode 100644
index 0000000..628291e
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/negate-overflow.cpp
@@ -0,0 +1,12 @@
+// RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck %s --check-prefix=CHECKS
+// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck %s --check-prefix=CHECKU
+
+int main() {
+  // CHECKS-NOT: runtime error
+  // CHECKU: negate-overflow.cpp:[[@LINE+2]]:3: runtime error: negation of 2147483648 cannot be represented in type 'unsigned int'
+  // CHECKU-NOT: cast to an unsigned
+  -unsigned(-0x7fffffff - 1); // ok
+  // CHECKS: negate-overflow.cpp:[[@LINE+2]]:10: runtime error: negation of -2147483648 cannot be represented in type 'int'; cast to an unsigned type to negate this value to itself
+  // CHECKU-NOT: runtime error
+  return -(-0x7fffffff - 1);
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/no-recover.cpp b/compiler-rt/test/ubsan/TestCases/Integer/no-recover.cpp
new file mode 100644
index 0000000..bbc2f8d
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/no-recover.cpp
@@ -0,0 +1,22 @@
+// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=RECOVER
+// RUN: %clangxx -fsanitize=unsigned-integer-overflow -fno-sanitize-recover=all -fsanitize-recover=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=RECOVER
+// RUN: %clangxx -fsanitize=unsigned-integer-overflow -fno-sanitize-recover=unsigned-integer-overflow %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=ABORT
+
+#include <stdint.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(uint8_t(0xff) + uint8_t(0xff));
+  (void)(uint16_t(0xf0fff) + uint16_t(0x0fff));
+  // RECOVER-NOT: runtime error
+  // ABORT-NOT: runtime error
+
+  uint32_t k = 0x87654321;
+  k += 0xedcba987;
+  // RECOVER: no-recover.cpp:[[@LINE-1]]:5: runtime error: unsigned integer overflow: 2271560481 + 3989547399 cannot be represented in type 'unsigned int'
+  // ABORT: no-recover.cpp:[[@LINE-2]]:5: runtime error: unsigned integer overflow: 2271560481 + 3989547399 cannot be represented in type 'unsigned int'
+
+  (void)(uint64_t(10000000000000000000ull) + uint64_t(9000000000000000000ull));
+  // RECOVER: 10000000000000000000 + 9000000000000000000 cannot be represented in type 'unsigned {{long( long)?}}'
+  // ABORT-NOT: runtime error
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/shift.cpp b/compiler-rt/test/ubsan/TestCases/Integer/shift.cpp
new file mode 100644
index 0000000..50db16d
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/shift.cpp
@@ -0,0 +1,45 @@
+// RUN: %clangxx -DLSH_OVERFLOW -DOP='<<' -fsanitize=shift-base -fno-sanitize-recover=shift %s -o %t1 && not %run %t1 2>&1 | FileCheck %s --check-prefix=CHECK-LSH_OVERFLOW
+// RUN: %clangxx -DLSH_OVERFLOW -DOP='<<=' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t2 && not %run %t2 2>&1 | FileCheck %s --check-prefix=CHECK-LSH_OVERFLOW
+// RUN: %clangxx -DTOO_LOW -DOP='<<' -fsanitize=shift-exponent -fno-sanitize-recover=shift %s -o %t3 && not %run %t3 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
+// RUN: %clangxx -DTOO_LOW -DOP='>>' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t4 && not %run %t4 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
+// RUN: %clangxx -DTOO_LOW -DOP='<<=' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t5 && not %run %t5 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
+// RUN: %clangxx -DTOO_LOW -DOP='>>=' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t6 && not %run %t6 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
+// RUN: %clangxx -DTOO_HIGH -DOP='<<' -fsanitize=shift-exponent -fno-sanitize-recover=shift %s -o %t7 && not %run %t7 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
+// RUN: %clangxx -DTOO_HIGH -DOP='>>' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t8 && not %run %t8 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
+// RUN: %clangxx -DTOO_HIGH -DOP='<<=' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t9 && not %run %t9 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
+// RUN: %clangxx -DTOO_HIGH -DOP='>>=' -fsanitize=shift -fno-sanitize-recover=shift %s -o %t10 && not %run %t10 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
+
+// RUN: %clangxx -DLSH_OVERFLOW -DOP='<<' -fsanitize=shift-exponent -fno-sanitize-recover=shift %s -o %t12 && %run %t12
+// RUN: %clangxx -DLSH_OVERFLOW -DOP='>>' -fsanitize=shift-exponent -fno-sanitize-recover=shift %s -o %t13 && %run %t13
+// RUN: %clangxx -DTOO_LOW -DOP='<<' -fsanitize=shift-base -fno-sanitize-recover=shift %s -o %t14 && %run %t14
+// RUN: %clangxx -DTOO_LOW -DOP='>>' -fsanitize=shift-base -fno-sanitize-recover=shift %s -o %t15 && %run %t15
+// RUN: %clangxx -DTOO_HIGH -DOP='<<' -fsanitize=shift-base -fno-sanitize-recover=shift %s -o %t16 && %run %t16
+// RUN: %clangxx -DTOO_HIGH -DOP='>>' -fsanitize=shift-base -fno-sanitize-recover=shift %s -o %t17 && %run %t17
+
+#include <stdint.h>
+
+int main() {
+  int a = 1;
+  unsigned b = 1;
+
+  a <<= 31; // ok in C++11, not ok in C99/C11
+  b <<= 31; // ok
+  b <<= 1; // still ok, unsigned
+
+#ifdef LSH_OVERFLOW
+  // CHECK-LSH_OVERFLOW: shift.cpp:[[@LINE+1]]:5: runtime error: left shift of negative value -2147483648
+  a OP 1;
+#endif
+
+#ifdef TOO_LOW
+  a = 0;
+  // CHECK-TOO_LOW: shift.cpp:[[@LINE+1]]:5: runtime error: shift exponent -3 is negative
+  a OP (-3);
+#endif
+
+#ifdef TOO_HIGH
+  a = 0;
+  // CHECK-TOO_HIGH: shift.cpp:[[@LINE+1]]:5: runtime error: shift exponent 32 is too large for 32-bit type 'int'
+  a OP 32;
+#endif
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/sub-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/sub-overflow.cpp
new file mode 100644
index 0000000..54ec4b5
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/sub-overflow.cpp
@@ -0,0 +1,31 @@
+// RUN: %clangxx -DSUB_I32 -fsanitize=signed-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I32
+// RUN: %clangxx -DSUB_I64 -fsanitize=signed-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I64
+// RUN: %clangxx -DSUB_I128 -fsanitize=signed-integer-overflow %s -o %t3 && %run %t3 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I128
+
+#include <stdint.h>
+#include <stdio.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(int8_t(-2) - int8_t(0x7f));
+  (void)(int16_t(-2) - int16_t(0x7fff));
+
+#ifdef SUB_I32
+  (void)(int32_t(-2) - int32_t(0x7fffffff));
+  // CHECK-SUB_I32: sub-overflow.cpp:[[@LINE-1]]:22: runtime error: signed integer overflow: -2 - 2147483647 cannot be represented in type 'int'
+#endif
+
+#ifdef SUB_I64
+  (void)(int64_t(-8000000000000000000ll) - int64_t(2000000000000000000ll));
+  // CHECK-SUB_I64: -8000000000000000000 - 2000000000000000000 cannot be represented in type '{{long( long)?}}'
+#endif
+
+#ifdef SUB_I128
+# if defined(__SIZEOF_INT128__) && !defined(_WIN32)
+  (void)(-(__int128_t(1) << 126) - (__int128_t(1) << 126) - 1);
+# else
+  puts("__int128 not supported");
+# endif
+  // CHECK-SUB_I128: {{0x80000000000000000000000000000000 - 1 cannot be represented in type '__int128'|__int128 not supported}}
+#endif
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/summary.cpp b/compiler-rt/test/ubsan/TestCases/Integer/summary.cpp
new file mode 100644
index 0000000..e687afa
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/summary.cpp
@@ -0,0 +1,13 @@
+// RUN: %clangxx -fsanitize=integer %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOTYPE
+// RUN: %env_ubsan_opts=report_error_type=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TYPE
+// REQUIRES: ubsan-asan
+
+#include <stdint.h>
+
+int main() {
+  (void)(uint64_t(10000000000000000000ull) + uint64_t(9000000000000000000ull));
+  // CHECK-NOTYPE: SUMMARY: AddressSanitizer: undefined-behavior {{.*}}summary.cpp:[[@LINE-1]]:44
+  // CHECK-TYPE: SUMMARY: AddressSanitizer: unsigned-integer-overflow {{.*}}summary.cpp:[[@LINE-2]]:44
+  return 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/suppressions.cpp b/compiler-rt/test/ubsan/TestCases/Integer/suppressions.cpp
new file mode 100644
index 0000000..ce3a546
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/suppressions.cpp
@@ -0,0 +1,33 @@
+// RUN: %clangxx -fsanitize=integer -g0 %s -o %t
+
+// Fails without any suppression.
+// RUN: %env_ubsan_opts=halt_on_error=1 not %run %t 2>&1 | FileCheck %s
+
+// RUN: echo "signed-integer-overflow:%t" > %t.wrong-supp
+// RUN: %env_ubsan_opts=halt_on_error=1:suppressions="%t.wrong-supp" not %run %t 2>&1 | FileCheck %s
+
+// RUN: echo "unsigned-integer-overflow:do_overflow" > %t.func-supp
+// RUN: %env_ubsan_opts=halt_on_error=1:suppressions="%t.func-supp" %run %t
+// RUN: echo "unsigned-integer-overflow:%t" > %t.module-supp
+// RUN: %env_ubsan_opts=halt_on_error=1:suppressions="%t.module-supp" %run %t
+
+// Note: file-level suppressions should work even without debug info.
+// RUN: echo "unsigned-integer-overflow:%s" > %t.file-supp
+// RUN: %env_ubsan_opts=halt_on_error=1:suppressions="%t.file-supp" %run %t
+
+// Suppressions don't work for unrecoverable kinds.
+// RUN: %clangxx -fsanitize=integer -fno-sanitize-recover=integer %s -o %t-norecover
+// RUN: %env_ubsan_opts=halt_on_error=1:suppressions="%t.module-supp" not %run %t-norecover 2>&1 | FileCheck %s
+
+#include <stdint.h>
+
+extern "C" void do_overflow() {
+  (void)(uint64_t(10000000000000000000ull) + uint64_t(9000000000000000000ull));
+  // CHECK: runtime error: unsigned integer overflow
+}
+
+int main() {
+  do_overflow();
+  return 0;
+}
+
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/uadd-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/uadd-overflow.cpp
new file mode 100644
index 0000000..8ef8983
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/uadd-overflow.cpp
@@ -0,0 +1,32 @@
+// RUN: %clangxx -DADD_I32 -fsanitize=unsigned-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I32
+// RUN: %clangxx -DADD_I64 -fsanitize=unsigned-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I64
+// RUN: %clangxx -DADD_I128 -fsanitize=unsigned-integer-overflow %s -o %t3 && %run %t3 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I128
+
+#include <stdint.h>
+#include <stdio.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(uint8_t(0xff) + uint8_t(0xff));
+  (void)(uint16_t(0xf0fff) + uint16_t(0x0fff));
+
+#ifdef ADD_I32
+  uint32_t k = 0x87654321;
+  k += 0xedcba987;
+  // CHECK-ADD_I32: uadd-overflow.cpp:[[@LINE-1]]:5: runtime error: unsigned integer overflow: 2271560481 + 3989547399 cannot be represented in type 'unsigned int'
+#endif
+
+#ifdef ADD_I64
+  (void)(uint64_t(10000000000000000000ull) + uint64_t(9000000000000000000ull));
+  // CHECK-ADD_I64: 10000000000000000000 + 9000000000000000000 cannot be represented in type 'unsigned {{long( long)?}}'
+#endif
+
+#ifdef ADD_I128
+# if defined(__SIZEOF_INT128__) && !defined(_WIN32)
+  (void)((__uint128_t(1) << 127) + (__uint128_t(1) << 127));
+# else
+  puts("__int128 not supported");
+# endif
+  // CHECK-ADD_I128: {{0x80000000000000000000000000000000 \+ 0x80000000000000000000000000000000 cannot be represented in type 'unsigned __int128'|__int128 not supported}}
+#endif
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/uincdec-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/uincdec-overflow.cpp
new file mode 100644
index 0000000..4cc7397
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/uincdec-overflow.cpp
@@ -0,0 +1,16 @@
+// RUN: %clangxx -DOP=n++ -fsanitize=unsigned-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck --check-prefix=CHECK-INC %s
+// RUN: %clangxx -DOP=++n -fsanitize=unsigned-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck --check-prefix=CHECK-INC %s
+// RUN: %clangxx -DOP=m-- -fsanitize=unsigned-integer-overflow %s -o %t3 && %run %t3 2>&1 | FileCheck --check-prefix=CHECK-DEC %s
+// RUN: %clangxx -DOP=--m -fsanitize=unsigned-integer-overflow %s -o %t4 && %run %t4 2>&1 | FileCheck --check-prefix=CHECK-DEC %s
+
+#include <stdint.h>
+
+int main() {
+  unsigned n = 0xfffffffd;
+  n++;
+  n++;
+  unsigned m = 0;
+  // CHECK-INC: uincdec-overflow.cpp:15:3: runtime error: unsigned integer overflow: 4294967295 + 1 cannot be represented in type 'unsigned int'
+  // CHECK-DEC: uincdec-overflow.cpp:15:3: runtime error: unsigned integer overflow: 0 - 1 cannot be represented in type 'unsigned int'
+  OP;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/umul-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/umul-overflow.cpp
new file mode 100644
index 0000000..ad5d1bd
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/umul-overflow.cpp
@@ -0,0 +1,19 @@
+// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdint.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(int8_t(-2) * int8_t(0x7f));
+  (void)(int16_t(0x7fff) * int16_t(0x7fff));
+  (void)(uint16_t(0xffff) * int16_t(0x7fff));
+  (void)(uint16_t(0xffff) * uint16_t(0x8000));
+
+  // Not an unsigned overflow
+  (void)(uint16_t(0xffff) * uint16_t(0x8001));
+
+  (void)(uint32_t(0xffffffff) * uint32_t(0x2));
+  // CHECK: umul-overflow.cpp:15:31: runtime error: unsigned integer overflow: 4294967295 * 2 cannot be represented in type 'unsigned int'
+
+  return 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Integer/usub-overflow.cpp b/compiler-rt/test/ubsan/TestCases/Integer/usub-overflow.cpp
new file mode 100644
index 0000000..fb671b0
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Integer/usub-overflow.cpp
@@ -0,0 +1,31 @@
+// RUN: %clangxx -DSUB_I32 -fsanitize=unsigned-integer-overflow %s -o %t1 && %run %t1 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I32
+// RUN: %clangxx -DSUB_I64 -fsanitize=unsigned-integer-overflow %s -o %t2 && %run %t2 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I64
+// RUN: %clangxx -DSUB_I128 -fsanitize=unsigned-integer-overflow %s -o %t3 && %run %t3 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I128
+
+#include <stdint.h>
+#include <stdio.h>
+
+int main() {
+  // These promote to 'int'.
+  (void)(uint8_t(0) - uint8_t(0x7f));
+  (void)(uint16_t(0) - uint16_t(0x7fff));
+
+#ifdef SUB_I32
+  (void)(uint32_t(1) - uint32_t(2));
+  // CHECK-SUB_I32: usub-overflow.cpp:[[@LINE-1]]:22: runtime error: unsigned integer overflow: 1 - 2 cannot be represented in type 'unsigned int'
+#endif
+
+#ifdef SUB_I64
+  (void)(uint64_t(8000000000000000000ll) - uint64_t(9000000000000000000ll));
+  // CHECK-SUB_I64: 8000000000000000000 - 9000000000000000000 cannot be represented in type 'unsigned {{long( long)?}}'
+#endif
+
+#ifdef SUB_I128
+# if defined(__SIZEOF_INT128__) && !defined(_WIN32)
+  (void)((__uint128_t(1) << 126) - (__uint128_t(1) << 127));
+# else
+  puts("__int128 not supported\n");
+# endif
+  // CHECK-SUB_I128: {{0x40000000000000000000000000000000 - 0x80000000000000000000000000000000 cannot be represented in type 'unsigned __int128'|__int128 not supported}}
+#endif
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/Linux/lit.local.cfg b/compiler-rt/test/ubsan/TestCases/Misc/Linux/lit.local.cfg
new file mode 100644
index 0000000..57271b8
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/Linux/lit.local.cfg
@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/Linux/ubsan_options.cc b/compiler-rt/test/ubsan/TestCases/Misc/Linux/ubsan_options.cc
new file mode 100644
index 0000000..eac4c32
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/Linux/ubsan_options.cc
@@ -0,0 +1,18 @@
+// RUN: %clangxx -fsanitize=integer -fsanitize-recover=integer %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+// __ubsan_default_options() doesn't work on Darwin.
+// XFAIL: darwin
+
+#include <stdint.h>
+
+extern "C" const char *__ubsan_default_options() {
+  return "halt_on_error=1";
+}
+
+int main() {
+  (void)(uint64_t(10000000000000000000ull) + uint64_t(9000000000000000000ull));
+  // CHECK: ubsan_options.cc:[[@LINE-1]]:44: runtime error: unsigned integer overflow
+  return 0;
+}
+
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/bool.cpp b/compiler-rt/test/ubsan/TestCases/Misc/bool.cpp
new file mode 100644
index 0000000..f6dc24e
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/bool.cpp
@@ -0,0 +1,13 @@
+// RUN: %clangxx -fsanitize=bool %s -O3 -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %env_ubsan_opts=print_summary=1:report_error_type=1 not %run %t 2>&1 | FileCheck %s --check-prefix=SUMMARY
+
+unsigned char NotABool = 123;
+
+int main(int argc, char **argv) {
+  bool *p = (bool*)&NotABool;
+
+  // CHECK: bool.cpp:[[@LINE+1]]:10: runtime error: load of value 123, which is not a valid value for type 'bool'
+  return *p;
+  // SUMMARY: SUMMARY: {{.*}}Sanitizer: invalid-bool-load {{.*}}bool.cpp:[[@LINE-1]]
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp b/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
new file mode 100644
index 0000000..199690d
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/bounds.cpp
@@ -0,0 +1,15 @@
+// RUN: %clangxx -fsanitize=bounds %s -O3 -o %t
+// RUN: %run %t 0 0 0
+// RUN: %run %t 1 2 3
+// RUN: %expect_crash %run %t 2 0 0 2>&1 | FileCheck %s --check-prefix=CHECK-A-2
+// RUN: %run %t 0 3 0 2>&1 | FileCheck %s --check-prefix=CHECK-B-3
+// RUN: %run %t 0 0 4 2>&1 | FileCheck %s --check-prefix=CHECK-C-4
+
+int main(int argc, char **argv) {
+  int arr[2][3][4] = {};
+
+  return arr[argv[1][0] - '0'][argv[2][0] - '0'][argv[3][0] - '0'];
+  // CHECK-A-2: bounds.cpp:[[@LINE-1]]:10: runtime error: index 2 out of bounds for type 'int [2][3][4]'
+  // CHECK-B-3: bounds.cpp:[[@LINE-2]]:10: runtime error: index 3 out of bounds for type 'int [3][4]'
+  // CHECK-C-4: bounds.cpp:[[@LINE-3]]:10: runtime error: index 4 out of bounds for type 'int [4]'
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/coverage-levels.cc b/compiler-rt/test/ubsan/TestCases/Misc/coverage-levels.cc
new file mode 100644
index 0000000..046d886
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/coverage-levels.cc
@@ -0,0 +1,41 @@
+// Test various levels of coverage
+//
+// FIXME: Port the environment variable logic below for the lit shell.
+// REQUIRES: shell
+//
+// RUN: mkdir -p %T/coverage-levels
+// RUN: %clangxx -fsanitize=shift                        -DGOOD_SHIFT=1 -O1 -fsanitize-coverage=func  %s -o %t
+// RUN: %env_ubsan_opts=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1 --check-prefix=CHECK_NOWARN
+// RUN: %clangxx -fsanitize=undefined                    -DGOOD_SHIFT=1 -O1 -fsanitize-coverage=func  %s -o %t
+// RUN: %env_ubsan_opts=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1 --check-prefix=CHECK_NOWARN
+
+// RUN: %clangxx -fsanitize=shift -O1 -fsanitize-coverage=func  %s -o %t
+// RUN: %env_ubsan_opts=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1 --check-prefix=CHECK_WARN
+// RUN: %clangxx -fsanitize=shift -O1 -fsanitize-coverage=bb  %s -o %t
+// RUN: %env_ubsan_opts=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2 --check-prefix=CHECK_WARN
+// RUN: %clangxx -fsanitize=shift -O1 -fsanitize-coverage=edge  %s -o %t
+// RUN: %env_ubsan_opts=coverage=1:verbosity=1:coverage_dir=%T/coverage-levels %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3 --check-prefix=CHECK_WARN
+
+// Coverage is not yet implemented in TSan.
+// XFAIL: ubsan-tsan
+
+volatile int sink;
+int main(int argc, char **argv) {
+  int shift = argc * 32;
+#if GOOD_SHIFT
+  shift = 3;
+#endif
+  if ((argc << shift) == 16)  // False.
+    return 1;
+  return 0;
+}
+
+// CHECK_WARN: shift exponent 32 is too large
+// CHECK_NOWARN-NOT: ERROR
+// FIXME: Currently, coverage instrumentation kicks in after ubsan, so we get
+// more than the minimal number of instrumented blocks.
+// FIXME: Currently, ubsan with -fno-sanitize-recover and w/o asan will fail
+// to dump coverage.
+// CHECK1:  1 PCs written
+// CHECK2:  3 PCs written
+// CHECK3:  3 PCs written
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/deduplication.cpp b/compiler-rt/test/ubsan/TestCases/Misc/deduplication.cpp
new file mode 100644
index 0000000..4b02590
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/deduplication.cpp
@@ -0,0 +1,26 @@
+// RUN: %clangxx -fsanitize=undefined %s -o %t && %run %t 2>&1 | FileCheck %s
+// Verify deduplication works by ensuring only one diag is emitted.
+#include <limits.h>
+#include <stdio.h>
+
+void overflow() {
+  int i = INT_MIN;
+  --i;
+}
+
+int main() {
+  // CHECK: Start
+  fprintf(stderr, "Start\n");
+  fflush(stderr);
+
+  // CHECK: runtime error
+  // CHECK-NOT: runtime error
+  // CHECK-NOT: runtime error
+  overflow();
+  overflow();
+  overflow();
+
+  // CHECK: End
+  fprintf(stderr, "End\n");
+  return 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/enum.cpp b/compiler-rt/test/ubsan/TestCases/Misc/enum.cpp
new file mode 100644
index 0000000..5dbecf1
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/enum.cpp
@@ -0,0 +1,21 @@
+// RUN: %clangxx -fsanitize=enum %s -O3 -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PLAIN
+// RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E" %s -O3 -o %t && %run %t
+// RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E : bool" %s -O3 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-BOOL
+
+// FIXME: UBSan fails to add the correct instrumentation code for some reason on
+// Windows.
+// XFAIL: win32
+
+enum E { a = 1 } e;
+#undef E
+
+int main(int argc, char **argv) {
+  // memset(&e, 0xff, sizeof(e));
+  for (unsigned char *p = (unsigned char*)&e; p != (unsigned char*)(&e + 1); ++p)
+    *p = 0xff;
+
+  // CHECK-PLAIN: error: load of value 4294967295, which is not a valid value for type 'enum E'
+  // FIXME: Support marshalling and display of enum class values.
+  // CHECK-BOOL: error: load of value <unknown>, which is not a valid value for type 'enum E'
+  return (int)e != -1;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/log-path_test.cc b/compiler-rt/test/ubsan/TestCases/Misc/log-path_test.cc
new file mode 100644
index 0000000..5b45f0b
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/log-path_test.cc
@@ -0,0 +1,36 @@
+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// XFAIL: android
+
+// The globs below do not work in the lit shell.
+// REQUIRES: shell
+
+// RUN: %clangxx -fsanitize=undefined %s -O1 -o %t
+
+// Regular run.
+// RUN: %run %t -4 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.out
+
+// Good log_path.
+// RUN: rm -f %t.log.*
+// RUN: %env_ubsan_opts=log_path='"%t.log"' %run %t -4 2> %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.log.*
+
+// Run w/o errors should not produce any log.
+// RUN: rm -f %t.log.*
+// RUN: %env_ubsan_opts=log_path='"%t.log"'  %run %t 4
+// RUN: not cat %t.log.*
+
+// FIXME: log_path is not supported on Windows yet.
+// XFAIL: win32
+
+#include <stdio.h>
+#include <stdlib.h>
+int main(int argc, char *argv[]) {
+  double a = atof(argv[1]);
+  unsigned int ai = (unsigned int) a;
+  printf("%f %u\n", a, ai);
+  return 0;
+}
+
+// CHECK-ERROR: runtime error: value -4 is outside the range of representable values of type 'unsigned int'
+
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/missing_return.cpp b/compiler-rt/test/ubsan/TestCases/Misc/missing_return.cpp
new file mode 100644
index 0000000..6808227
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/missing_return.cpp
@@ -0,0 +1,15 @@
+// RUN: %clangxx -fsanitize=return -g %s -O3 -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%os-STACKTRACE
+
+// CHECK: missing_return.cpp:[[@LINE+1]]:5: runtime error: execution reached the end of a value-returning function without returning a value
+int f() {
+// Slow stack unwinding is not available on Darwin for now, see
+// https://code.google.com/p/address-sanitizer/issues/detail?id=137
+// CHECK-Linux-STACKTRACE: #0 {{.*}}f(){{.*}}missing_return.cpp:[[@LINE-3]]
+// CHECK-FreeBSD-STACKTRACE: #0 {{.*}}f(void){{.*}}missing_return.cpp:[[@LINE-4]]
+}
+
+int main(int, char **argv) {
+  return f();
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/nonnull-arg.cpp b/compiler-rt/test/ubsan/TestCases/Misc/nonnull-arg.cpp
new file mode 100644
index 0000000..0332d96
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/nonnull-arg.cpp
@@ -0,0 +1,61 @@
+// RUN: %clangxx -fsanitize=nonnull-attribute -fno-sanitize-recover=all %s -O3 -o %t
+// RUN: %run %t nc
+// RUN: %run %t nm
+// RUN: %run %t nf
+// RUN: %run %t nv
+// RUN: not %run %t 0c 2>&1 | FileCheck %s --check-prefix=CTOR
+// RUN: not %run %t 0m 2>&1 | FileCheck %s --check-prefix=METHOD
+// RUN: not %run %t 0f 2>&1 | FileCheck %s --check-prefix=FUNC
+// RUN: not %run %t 0v 2>&1 | FileCheck %s --check-prefix=VARIADIC
+//
+// AArch64 lacks variadic instrumentation for MSAN.
+// REQUIRES: stable-runtime
+
+class C {
+  int *null_;
+  int *nonnull_;
+
+public:
+  C(int *null, __attribute__((nonnull)) int *nonnull)
+      : null_(null), nonnull_(nonnull) {}
+  int value() { return *nonnull_; }
+  int method(int *nonnull, int *null) __attribute__((nonnull(2))) {
+    return *nonnull_ + *nonnull;
+  }
+};
+
+__attribute__((nonnull)) int func(int *nonnull) { return *nonnull; }
+
+#include <stdarg.h>
+__attribute__((nonnull)) int variadic(int x, ...) {
+  va_list args;
+  va_start(args, x);
+  int *nonnull = va_arg(args, int*);
+  int res = *nonnull;
+  va_end(args);
+  return res;
+}
+
+int main(int argc, char *argv[]) {
+  int local = 0;
+  int *arg = (argv[1][0] == '0') ? 0x0 : &local;
+  switch (argv[1][1]) {
+    case 'c':
+      return C(0x0, arg).value();
+      // CTOR: {{.*}}nonnull-arg.cpp:[[@LINE-1]]:21: runtime error: null pointer passed as argument 2, which is declared to never be null
+      // CTOR-NEXT: {{.*}}nonnull-arg.cpp:19:31: note: nonnull attribute specified here
+    case 'm':
+      return C(0x0, &local).method(arg, 0x0);
+      // METHOD: {{.*}}nonnull-arg.cpp:[[@LINE-1]]:36: runtime error: null pointer passed as argument 1, which is declared to never be null
+      // METHOD-NEXT: {{.*}}nonnull-arg.cpp:22:54: note: nonnull attribute specified here
+    case 'f':
+      return func(arg);
+      // FUNC: {{.*}}nonnull-arg.cpp:[[@LINE-1]]:19: runtime error: null pointer passed as argument 1, which is declared to never be null
+      // FUNC-NEXT: {{.*}}nonnull-arg.cpp:27:16: note: nonnull attribute specified here
+    case 'v':
+      return variadic(42, arg);
+    // VARIADIC: {{.*}}nonnull-arg.cpp:[[@LINE-1]]:27: runtime error: null pointer passed as argument 2, which is declared to never be null
+    // VARIADIC-NEXT: {{.*}}nonnull-arg.cpp:30:16: note: nonnull attribute specified here
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/nonnull.cpp b/compiler-rt/test/ubsan/TestCases/Misc/nonnull.cpp
new file mode 100644
index 0000000..c3ab49c
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/nonnull.cpp
@@ -0,0 +1,15 @@
+// RUN: %clangxx -fsanitize=returns-nonnull-attribute %s -O3 -o %t
+// RUN: %run %t foo
+// RUN: %run %t 2>&1 | FileCheck %s
+
+__attribute__((returns_nonnull)) char *foo(char *a);
+
+char *foo(char *a) {
+  return a;
+  // CHECK: nonnull.cpp:[[@LINE+2]]:1: runtime error: null pointer returned from function declared to never return null
+  // CHECK-NEXT: nonnull.cpp:[[@LINE-5]]:16: note: returns_nonnull attribute specified here
+}
+
+int main(int argc, char **argv) {
+  return foo(argv[1]) == 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/unreachable.cpp b/compiler-rt/test/ubsan/TestCases/Misc/unreachable.cpp
new file mode 100644
index 0000000..e1206ed
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/unreachable.cpp
@@ -0,0 +1,6 @@
+// RUN: %clangxx -fsanitize=unreachable %s -O3 -o %t && not %run %t 2>&1 | FileCheck %s
+
+int main(int, char **argv) {
+  // CHECK: unreachable.cpp:5:3: runtime error: execution reached a __builtin_unreachable() call
+  __builtin_unreachable();
+}
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/vla.c b/compiler-rt/test/ubsan/TestCases/Misc/vla.c
new file mode 100644
index 0000000..1072153
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/vla.c
@@ -0,0 +1,11 @@
+// RUN: %clang -fsanitize=vla-bound %s -O3 -o %t
+// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-MINUS-ONE
+// RUN: %run %t a 2>&1 | FileCheck %s --check-prefix=CHECK-ZERO
+// RUN: %run %t a b
+
+int main(int argc, char **argv) {
+  // CHECK-MINUS-ONE: vla.c:9:11: runtime error: variable length array bound evaluates to non-positive value -1
+  // CHECK-ZERO: vla.c:9:11: runtime error: variable length array bound evaluates to non-positive value 0
+  int arr[argc - 2];
+  return 0;
+}
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/function.cpp b/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/function.cpp
new file mode 100644
index 0000000..6e7e314
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/function.cpp
@@ -0,0 +1,35 @@
+// RUN: %clangxx -fsanitize=function %s -O3 -g -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+// Verify that we can disable symbolization if needed:
+// RUN: %env_ubsan_opts=symbolize=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOSYM
+
+// -fsanitize=function is unsupported on Darwin yet.
+// XFAIL: darwin
+
+#include <stdint.h>
+
+void f() {}
+
+void g(int x) {}
+
+void make_valid_call() {
+  // CHECK-NOT: runtime error: call to function g
+  reinterpret_cast<void (*)(int)>(reinterpret_cast<uintptr_t>(g))(42);
+}
+
+void make_invalid_call() {
+  // CHECK: function.cpp:25:3: runtime error: call to function f() through pointer to incorrect function type 'void (*)(int)'
+  // CHECK-NEXT: function.cpp:11: note: f() defined here
+  // NOSYM: function.cpp:25:3: runtime error: call to function (unknown) through pointer to incorrect function type 'void (*)(int)'
+  // NOSYM-NEXT: ({{.*}}+0x{{.*}}): note: (unknown) defined here
+  reinterpret_cast<void (*)(int)>(reinterpret_cast<uintptr_t>(f))(42);
+}
+
+int main(void) {
+  make_valid_call();
+  make_invalid_call();
+  // Check that no more errors will be printed.
+  // CHECK-NOT: runtime error: call to function
+  // NOSYM-NOT: runtime error: call to function
+  make_invalid_call();
+}
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/lit.local.cfg b/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/lit.local.cfg
new file mode 100644
index 0000000..27c61a3
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/Function/lit.local.cfg
@@ -0,0 +1,3 @@
+# The function type checker is only supported on x86 and x86_64 for now.
+if config.root.host_arch not in ['x86', 'x86_64']:
+  config.unsupported = True
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/misaligned.cpp b/compiler-rt/test/ubsan/TestCases/TypeCheck/misaligned.cpp
new file mode 100644
index 0000000..4307167
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/misaligned.cpp
@@ -0,0 +1,108 @@
+// FIXME: This test currently fails on Windows because we use the MSVC linker,
+// which throws away DWARF debug info.
+// XFAIL: win32
+//
+// RUN: %clangxx -fsanitize=alignment -g %s -O3 -o %t
+// RUN: %run %t l0 && %run %t s0 && %run %t r0 && %run %t m0 && %run %t f0 && %run %t n0 && %run %t u0
+// RUN: %run %t l1 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD --strict-whitespace
+// RUN: %run %t s1 2>&1 | FileCheck %s --check-prefix=CHECK-STORE
+// RUN: %run %t r1 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE
+// RUN: %run %t m1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER
+// RUN: %run %t f1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN
+// RUN: %run %t n1 2>&1 | FileCheck %s --check-prefix=CHECK-NEW
+// RUN: %run %t u1 2>&1 | FileCheck %s --check-prefix=CHECK-UPCAST
+// RUN: %env_ubsan_opts=print_stacktrace=1 %run %t l1 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD --check-prefix=CHECK-%os-STACK-LOAD
+
+// RUN: %clangxx -fsanitize=alignment -fno-sanitize-recover=alignment %s -O3 -o %t
+// RUN: not %run %t w1 2>&1 | FileCheck %s --check-prefix=CHECK-WILD
+
+#include <new>
+
+struct S {
+  S() {}
+  int f() { return 0; }
+  int k;
+};
+
+struct T : S {
+  int t;
+};
+
+int main(int, char **argv) {
+  char c[] __attribute__((aligned(8))) = { 0, 0, 0, 0, 1, 2, 3, 4, 5 };
+
+  // Pointer value may be unspecified here, but behavior is not undefined.
+  int *p = (int*)&c[4 + argv[1][1] - '0'];
+  S *s = (S*)p;
+  T *t = (T*)p;
+
+  void *wild = reinterpret_cast<void *>(0x123L);
+
+  (void)*p; // ok!
+
+  switch (argv[1][0]) {
+  case 'l':
+    // CHECK-LOAD: misaligned.cpp:[[@LINE+4]]{{(:12)?}}: runtime error: load of misaligned address [[PTR:0x[0-9a-f]*]] for type 'int', which requires 4 byte alignment
+    // CHECK-LOAD-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-LOAD-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-LOAD-NEXT: {{^             \^}}
+    return *p && 0;
+    // Slow stack unwinding is disabled on Darwin for now, see
+    // https://code.google.com/p/address-sanitizer/issues/detail?id=137
+    // CHECK-Linux-STACK-LOAD: #0 {{.*}}main{{.*}}misaligned.cpp
+    // Check for the already checked line to avoid lit error reports.
+    // CHECK-Darwin-STACK-LOAD: {{ }}
+
+  case 's':
+    // CHECK-STORE: misaligned.cpp:[[@LINE+4]]{{(:5)?}}: runtime error: store to misaligned address [[PTR:0x[0-9a-f]*]] for type 'int', which requires 4 byte alignment
+    // CHECK-STORE-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-STORE-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-STORE-NEXT: {{^             \^}}
+    *p = 1;
+    break;
+
+  case 'r':
+    // CHECK-REFERENCE: misaligned.cpp:[[@LINE+4]]{{(:(5|15))?}}: runtime error: reference binding to misaligned address [[PTR:0x[0-9a-f]*]] for type 'int', which requires 4 byte alignment
+    // CHECK-REFERENCE-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-REFERENCE-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-REFERENCE-NEXT: {{^             \^}}
+    {int &r = *p;}
+    break;
+
+  case 'm':
+    // CHECK-MEMBER: misaligned.cpp:[[@LINE+4]]{{(:15)?}}: runtime error: member access within misaligned address [[PTR:0x[0-9a-f]*]] for type 'S', which requires 4 byte alignment
+    // CHECK-MEMBER-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-MEMBER-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-MEMBER-NEXT: {{^             \^}}
+    return s->k && 0;
+
+  case 'f':
+    // CHECK-MEMFUN: misaligned.cpp:[[@LINE+4]]{{(:12)?}}: runtime error: member call on misaligned address [[PTR:0x[0-9a-f]*]] for type 'S', which requires 4 byte alignment
+    // CHECK-MEMFUN-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-MEMFUN-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-MEMFUN-NEXT: {{^             \^}}
+    return s->f() && 0;
+
+  case 'n':
+    // CHECK-NEW: misaligned.cpp:[[@LINE+4]]{{(:21)?}}: runtime error: constructor call on misaligned address [[PTR:0x[0-9a-f]*]] for type 'S', which requires 4 byte alignment
+    // CHECK-NEW-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-NEW-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-NEW-NEXT: {{^             \^}}
+    return (new (s) S)->k && 0;
+
+  case 'u': {
+    // CHECK-UPCAST: misaligned.cpp:[[@LINE+4]]{{(:17)?}}: runtime error: upcast of misaligned address [[PTR:0x[0-9a-f]*]] for type 'T', which requires 4 byte alignment
+    // CHECK-UPCAST-NEXT: [[PTR]]: note: pointer points here
+    // CHECK-UPCAST-NEXT: {{^ 00 00 00 01 02 03 04  05}}
+    // CHECK-UPCAST-NEXT: {{^             \^}}
+    S *s2 = (S*)t;
+    return s2->f();
+  }
+
+  case 'w':
+    // CHECK-WILD: misaligned.cpp:[[@LINE+3]]{{(:35)?}}: runtime error: member access within misaligned address 0x{{0+}}123 for type 'S', which requires 4 byte alignment
+    // CHECK-WILD-NEXT: 0x{{0+}}123: note: pointer points here
+    // CHECK-WILD-NEXT: <memory cannot be printed>
+    return static_cast<S*>(wild)->k;
+  }
+}
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/null.cpp b/compiler-rt/test/ubsan/TestCases/TypeCheck/null.cpp
new file mode 100644
index 0000000..1e17955
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/null.cpp
@@ -0,0 +1,38 @@
+// RUN: %clangxx -fsanitize=null %s -O3 -o %t
+// RUN: %run %t l 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD
+// RUN: %expect_crash %run %t s 2>&1 | FileCheck %s --check-prefix=CHECK-STORE
+// RUN: %run %t r 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE
+// RUN: %run %t m 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER
+// RUN: %run %t f 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN
+
+struct S {
+  int f() { return 0; }
+  int k;
+};
+
+int main(int, char **argv) {
+  int *p = 0;
+  S *s = 0;
+
+  (void)*p; // ok!
+
+  switch (argv[1][0]) {
+  case 'l':
+    // CHECK-LOAD: null.cpp:[[@LINE+1]]:12: runtime error: load of null pointer of type 'int'
+    return *p;
+  case 's':
+    // CHECK-STORE: null.cpp:[[@LINE+1]]:5: runtime error: store to null pointer of type 'int'
+    *p = 1;
+    break;
+  case 'r':
+    // CHECK-REFERENCE: null.cpp:[[@LINE+1]]:15: runtime error: reference binding to null pointer of type 'int'
+    {int &r = *p;}
+    break;
+  case 'm':
+    // CHECK-MEMBER: null.cpp:[[@LINE+1]]:15: runtime error: member access within null pointer of type 'S'
+    return s->k;
+  case 'f':
+    // CHECK-MEMFUN: null.cpp:[[@LINE+1]]:12: runtime error: member call on null pointer of type 'S'
+    return s->f();
+  }
+}
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base-construction.cpp b/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base-construction.cpp
new file mode 100644
index 0000000..dc27d9f
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base-construction.cpp
@@ -0,0 +1,13 @@
+// RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr %s -o %t
+// RUN: %run %t
+
+// REQUIRES: cxxabi
+
+int volatile n;
+
+struct A { virtual ~A() {} };
+struct B: virtual A {};
+struct C: virtual A { ~C() { n = 0; } };
+struct D: virtual B, virtual C {};
+
+int main() { delete new D; }
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base.cpp b/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base.cpp
new file mode 100644
index 0000000..09deac1
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr-virtual-base.cpp
@@ -0,0 +1,18 @@
+// RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr -g %s -O3 -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+// REQUIRES: cxxabi
+
+struct S { virtual int f() { return 0; } };
+struct T : virtual S {};
+
+struct Foo { virtual int f() { return 0; } };
+
+int main(int argc, char **argv) {
+  Foo foo;
+  T *t = (T*)&foo;
+  S *s = t;
+  // CHECK: vptr-virtual-base.cpp:[[@LINE-1]]:10: runtime error: cast to virtual base of address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
+  // CHECK-NEXT: [[PTR]]: note: object is of type 'Foo'
+  return s->f();
+}
diff --git a/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr.cpp b/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr.cpp
new file mode 100644
index 0000000..4a1fa8d
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/TypeCheck/vptr.cpp
@@ -0,0 +1,166 @@
+// RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr -g %s -O3 -o %t
+// RUN: %run %t rT && %run %t mT && %run %t fT && %run %t cT
+// RUN: %run %t rU && %run %t mU && %run %t fU && %run %t cU
+// RUN: %run %t rS && %run %t rV && %run %t oV
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t mS 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER --check-prefix=CHECK-%os-MEMBER --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t fS 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t cS 2>&1 | FileCheck %s --check-prefix=CHECK-DOWNCAST --check-prefix=CHECK-%os-DOWNCAST --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t mV 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER --check-prefix=CHECK-%os-MEMBER --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t fV 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t cV 2>&1 | FileCheck %s --check-prefix=CHECK-DOWNCAST --check-prefix=CHECK-%os-DOWNCAST --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t oU 2>&1 | FileCheck %s --check-prefix=CHECK-OFFSET --check-prefix=CHECK-%os-OFFSET --strict-whitespace
+// RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t m0 2>&1 | FileCheck %s --check-prefix=CHECK-NULL-MEMBER --check-prefix=CHECK-%os-NULL-MEMBER --strict-whitespace
+
+// RUN: (echo "vptr_check:S"; echo "vptr_check:T"; echo "vptr_check:U") > %t.supp
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t mS
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t fS
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t cS
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t mV
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t fV
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t cV
+// RUN: %env_ubsan_opts=suppressions='"%t.supp"' %run %t oU
+
+// RUN: echo "vptr_check:S" > %t.loc-supp
+// RUN: %env_ubsan_opts=suppressions='"%t.loc-supp"' not %run %t x- 2>&1 | FileCheck %s --check-prefix=CHECK-LOC-SUPPRESS
+
+// REQUIRES: stable-runtime, cxxabi
+#include <new>
+#include <assert.h>
+#include <stdio.h>
+
+struct S {
+  S() : a(0) {}
+  ~S() {}
+  int a;
+  int f() { return 0; }
+  virtual int v() { return 0; }
+};
+
+struct T : S {
+  T() : b(0) {}
+  int b;
+  int g() { return 0; }
+  virtual int v() { return 1; }
+};
+
+struct U : S, T { virtual int v() { return 2; } };
+
+struct V : S {};
+
+// Make p global so that lsan does not complain.
+T *p = 0;
+
+int access_p(T *p, char type);
+
+int main(int argc, char **argv) {
+  assert(argc > 1);
+  fprintf(stderr, "Test case: %s\n", argv[1]);
+  T t;
+  (void)t.a;
+  (void)t.b;
+  (void)t.f();
+  (void)t.g();
+  (void)t.v();
+  (void)t.S::v();
+
+  U u;
+  (void)u.T::a;
+  (void)u.b;
+  (void)u.T::f();
+  (void)u.g();
+  (void)u.v();
+  (void)u.T::v();
+  (void)((T&)u).S::v();
+
+  char Buffer[sizeof(U)] = {};
+  char TStorage[sizeof(T)];
+  switch (argv[1][1]) {
+  case '0':
+    p = reinterpret_cast<T*>(Buffer);
+    break;
+  case 'S':
+    // Make sure p points to the memory chunk of sufficient size to prevent ASan
+    // reports about out-of-bounds access.
+    p = reinterpret_cast<T*>(new(TStorage) S);
+    break;
+  case 'T':
+    p = new T;
+    break;
+  case 'U':
+    p = new U;
+    break;
+  case 'V':
+    p = reinterpret_cast<T*>(new U);
+    break;
+  }
+
+  access_p(p, argv[1][0]);
+  return 0;
+}
+
+int access_p(T *p, char type) {
+  switch (type) {
+  case 'r':
+    // Binding a reference to storage of appropriate size and alignment is OK.
+    {T &r = *p;}
+    return 0;
+
+  case 'x':
+    for (int i = 0; i < 2; i++) {
+      // Check that the first iteration ("S") succeeds, while the second ("V") fails.
+      p = reinterpret_cast<T*>((i == 0) ? new S : new V);
+      // CHECK-LOC-SUPPRESS: vptr.cpp:[[@LINE+5]]:7: runtime error: member call on address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
+      // CHECK-LOC-SUPPRESS-NEXT: [[PTR]]: note: object is of type 'V'
+      // CHECK-LOC-SUPPRESS-NEXT: {{^ .. .. .. ..  .. .. .. .. .. .. .. ..  }}
+      // CHECK-LOC-SUPPRESS-NEXT: {{^              \^~~~~~~~~~~(~~~~~~~~~~~~)? *$}}
+      // CHECK-LOC-SUPPRESS-NEXT: {{^              vptr for 'V'}}
+      p->g();
+    }
+    return 0;
+
+  case 'm':
+    // CHECK-MEMBER: vptr.cpp:[[@LINE+6]]:15: runtime error: member access within address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
+    // CHECK-MEMBER-NEXT: [[PTR]]: note: object is of type [[DYN_TYPE:'S'|'U']]
+    // CHECK-MEMBER-NEXT: {{^ .. .. .. ..  .. .. .. .. .. .. .. ..  }}
+    // CHECK-MEMBER-NEXT: {{^              \^~~~~~~~~~~(~~~~~~~~~~~~)? *$}}
+    // CHECK-MEMBER-NEXT: {{^              vptr for}} [[DYN_TYPE]]
+    // CHECK-Linux-MEMBER: #0 {{.*}}access_p{{.*}}vptr.cpp:[[@LINE+1]]
+    return p->b;
+
+    // CHECK-NULL-MEMBER: vptr.cpp:[[@LINE-2]]:15: runtime error: member access within address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
+    // CHECK-NULL-MEMBER-NEXT: [[PTR]]: note: object has invalid vptr
+    // CHECK-NULL-MEMBER-NEXT: {{^  ?.. .. .. ..  ?00 00 00 00  ?00 00 00 00  ?}}
+    // CHECK-NULL-MEMBER-NEXT: {{^              \^~~~~~~~~~~(~~~~~~~~~~~~)? *$}}
+    // CHECK-NULL-MEMBER-NEXT: {{^              invalid vptr}}
+    // CHECK-Linux-NULL-MEMBER: #0 {{.*}}access_p{{.*}}vptr.cpp:[[@LINE-7]]
+
+  case 'f':
+    // CHECK-MEMFUN: vptr.cpp:[[@LINE+6]]:12: runtime error: member call on address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
+    // CHECK-MEMFUN-NEXT: [[PTR]]: note: object is of type [[DYN_TYPE:'S'|'U']]
+    // CHECK-MEMFUN-NEXT: {{^ .. .. .. ..  .. .. .. .. .. .. .. ..  }}
+    // CHECK-MEMFUN-NEXT: {{^              \^~~~~~~~~~~(~~~~~~~~~~~~)? *$}}
+    // CHECK-MEMFUN-NEXT: {{^              vptr for}} [[DYN_TYPE]]
+    // TODO: Add check for stacktrace here.
+    return p->g();
+
+  case 'o':
+    // CHECK-OFFSET: vptr.cpp:[[@LINE+6]]:12: runtime error: member call on address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'U'
+    // CHECK-OFFSET-NEXT: 0x{{[0-9a-f]*}}: note: object is base class subobject at offset {{8|16}} within object of type [[DYN_TYPE:'U']]
+    // CHECK-OFFSET-NEXT: {{^ .. .. .. ..  .. .. .. .. .. .. .. ..  .. .. .. .. .. .. .. ..  .. .. .. .. .. .. .. ..  }}
+    // CHECK-OFFSET-NEXT: {{^              \^                        (                         ~~~~~~~~~~~~)?~~~~~~~~~~~ *$}}
+    // CHECK-OFFSET-NEXT: {{^                                       (                         )?vptr for}} 'T' base class of [[DYN_TYPE]]
+    // CHECK-Linux-OFFSET: #0 {{.*}}access_p{{.*}}vptr.cpp:[[@LINE+1]]
+    return reinterpret_cast<U*>(p)->v() - 2;
+
+  case 'c':
+    // CHECK-DOWNCAST: vptr.cpp:[[@LINE+6]]:11: runtime error: downcast of address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
+    // CHECK-DOWNCAST-NEXT: [[PTR]]: note: object is of type [[DYN_TYPE:'S'|'U']]
+    // CHECK-DOWNCAST-NEXT: {{^ .. .. .. ..  .. .. .. .. .. .. .. ..  }}
+    // CHECK-DOWNCAST-NEXT: {{^              \^~~~~~~~~~~(~~~~~~~~~~~~)? *$}}
+    // CHECK-DOWNCAST-NEXT: {{^              vptr for}} [[DYN_TYPE]]
+    // CHECK-Linux-DOWNCAST: #0 {{.*}}access_p{{.*}}vptr.cpp:[[@LINE+1]]
+    (void)static_cast<T*>(reinterpret_cast<S*>(p));
+    return 0;
+  }
+  return 0;
+}
diff --git a/compiler-rt/test/ubsan/lit.common.cfg b/compiler-rt/test/ubsan/lit.common.cfg
new file mode 100644
index 0000000..e508629
--- /dev/null
+++ b/compiler-rt/test/ubsan/lit.common.cfg
@@ -0,0 +1,80 @@
+# -*- Python -*-
+
+import os
+
+def get_required_attr(config, attr_name):
+  attr_value = getattr(config, attr_name, None)
+  if attr_value == None:
+    lit_config.fatal(
+      "No attribute %r in test configuration! You may need to run "
+      "tests from your build directory or add this attribute "
+      "to lit.site.cfg " % attr_name)
+  return attr_value
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+default_ubsan_opts = []
+# Choose between standalone and UBSan+ASan modes.
+ubsan_lit_test_mode = get_required_attr(config, 'ubsan_lit_test_mode')
+if ubsan_lit_test_mode == "Standalone":
+  config.name = 'UBSan-Standalone-' + config.target_arch
+  config.available_features.add("ubsan-standalone")
+  clang_ubsan_cflags = []
+elif ubsan_lit_test_mode == "AddressSanitizer":
+  config.name = 'UBSan-ASan-' + config.target_arch
+  config.available_features.add("ubsan-asan")
+  clang_ubsan_cflags = ["-fsanitize=address"]
+  default_ubsan_opts += ['detect_leaks=0']
+elif ubsan_lit_test_mode == "MemorySanitizer":
+  config.name = 'UBSan-MSan-' + config.target_arch
+  config.available_features.add("ubsan-msan")
+  clang_ubsan_cflags = ["-fsanitize=memory"]
+elif ubsan_lit_test_mode == "ThreadSanitizer":
+  config.name = 'UBSan-TSan-' + config.target_arch
+  config.available_features.add("ubsan-tsan")
+  clang_ubsan_cflags = ["-fsanitize=thread"]
+else:
+  lit_config.fatal("Unknown UBSan test mode: %r" % ubsan_lit_test_mode)
+
+# Platform-specific default for lit tests.
+if config.host_os == 'Darwin':
+  # On Darwin, we default to `abort_on_error=1`, which would make tests run
+  # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
+  default_ubsan_opts += ['abort_on_error=0']
+  default_ubsan_opts += ['log_to_syslog=0']
+default_ubsan_opts_str = ':'.join(default_ubsan_opts)
+if default_ubsan_opts_str:
+  config.environment['UBSAN_OPTIONS'] = default_ubsan_opts_str
+  default_ubsan_opts_str += ':'
+# Substitution to setup UBSAN_OPTIONS in portable way.
+config.substitutions.append(('%env_ubsan_opts=',
+                             'env UBSAN_OPTIONS=' + default_ubsan_opts_str))
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+target_cflags = [get_required_attr(config, "target_cflags")]
+clang_ubsan_cflags += target_cflags
+clang_ubsan_cxxflags = config.cxx_mode_flags + clang_ubsan_cflags
+
+# Define %clang and %clangxx substitutions to use in test RUN lines.
+config.substitutions.append( ("%clang ", build_invocation(clang_ubsan_cflags)) )
+config.substitutions.append( ("%clangxx ", build_invocation(clang_ubsan_cxxflags)) )
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp']
+
+# Check that the host supports UndefinedBehaviorSanitizer tests
+if config.host_os not in ['Linux', 'Darwin', 'FreeBSD', 'Windows']:
+  config.unsupported = True
+
+if config.host_os == 'Windows':
+  # We do not currently support enough of the Microsoft ABI for UBSan to work on
+  # Windows.
+  config.available_features.remove('cxxabi')
+
+# Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
+# because the test hangs or fails on one configuration and not the other.
+if config.target_arch.startswith('arm') == False and config.target_arch != 'aarch64':
+  config.available_features.add('stable-runtime')
diff --git a/compiler-rt/test/ubsan/lit.site.cfg.in b/compiler-rt/test/ubsan/lit.site.cfg.in
new file mode 100644
index 0000000..1b06881
--- /dev/null
+++ b/compiler-rt/test/ubsan/lit.site.cfg.in
@@ -0,0 +1,10 @@
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Tool-specific config options.
+config.ubsan_lit_test_mode = "@UBSAN_LIT_TEST_MODE@"
+config.target_cflags = "@UBSAN_TEST_TARGET_CFLAGS@"
+config.target_arch = "@UBSAN_TEST_TARGET_ARCH@"
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@UBSAN_LIT_TESTS_DIR@/lit.common.cfg")
diff --git a/compiler-rt/unittests/CMakeLists.txt b/compiler-rt/unittests/CMakeLists.txt
new file mode 100644
index 0000000..fe2c397
--- /dev/null
+++ b/compiler-rt/unittests/CMakeLists.txt
@@ -0,0 +1,3 @@
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.common.unit.configured.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.common.unit.configured)
diff --git a/compiler-rt/unittests/lit.common.unit.cfg b/compiler-rt/unittests/lit.common.unit.cfg
new file mode 100644
index 0000000..2bd8f37
--- /dev/null
+++ b/compiler-rt/unittests/lit.common.unit.cfg
@@ -0,0 +1,30 @@
+# -*- Python -*-
+
+# Configuration file for 'lit' test runner.
+# This file contains common config setup rules for unit tests in various
+# compiler-rt testsuites.
+
+import os
+
+import lit.formats
+
+# Setup test format
+llvm_build_mode = getattr(config, "llvm_build_mode", "Debug")
+config.test_format = lit.formats.GoogleTest(llvm_build_mode, "Test")
+
+# Setup test suffixes.
+config.suffixes = []
+
+# Tweak PATH to include llvm tools dir.
+llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
+if (not llvm_tools_dir) or (not os.path.exists(llvm_tools_dir)):
+  lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % llvm_tools_dir)
+path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
+config.environment['PATH'] = path
+
+# Propagate the temp directory. Windows requires this because it uses \Windows\
+# if none of these are present.
+if 'TMP' in os.environ:
+    config.environment['TMP'] = os.environ['TMP']
+if 'TEMP' in os.environ:
+    config.environment['TEMP'] = os.environ['TEMP']
diff --git a/compiler-rt/unittests/lit.common.unit.configured.in b/compiler-rt/unittests/lit.common.unit.configured.in
new file mode 100644
index 0000000..18adf64
--- /dev/null
+++ b/compiler-rt/unittests/lit.common.unit.configured.in
@@ -0,0 +1,25 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+
+# Generic config options for all compiler-rt unit tests.
+config.target_triple = "@TARGET_TRIPLE@"
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.compiler_rt_src_root = "@COMPILER_RT_SOURCE_DIR@"
+config.compiler_rt_libdir = "@COMPILER_RT_LIBRARY_OUTPUT_DIR@"
+config.llvm_build_mode = "@LLVM_BUILD_MODE@"
+config.host_arch = "@HOST_ARCH@"
+config.host_os = "@HOST_OS@"
+
+# LLVM tools dir and build mode can be passed in lit parameters,
+# so try to apply substitution.
+try:
+  config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
+  config.llvm_build_mode = config.llvm_build_mode % lit_config.params
+except KeyError as e:
+  key, = e.args
+  lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key, key))
+
+# Setup attributes common for all compiler-rt unit tests.
+lit_config.load_config(config, "@COMPILER_RT_SOURCE_DIR@/unittests/lit.common.unit.cfg")
diff --git a/compiler-rt/www/content.css b/compiler-rt/www/content.css
new file mode 100644
index 0000000..ab6983b
--- /dev/null
+++ b/compiler-rt/www/content.css
@@ -0,0 +1,25 @@
+html, body {
+  padding:0px;
+  font-size:small; font-family:"Lucida Grande", "Lucida Sans Unicode", Arial, Verdana, Helvetica, sans-serif; background-color: #fff; color: #222;
+  line-height:1.5;
+}
+
+h1, h2, h3, tt { color: #000 }
+
+h1 { padding-top:0px; margin-top:0px;}
+h2 { color:#333333; padding-top:0.5em; }
+h3 { padding-top: 0.5em; margin-bottom: -0.25em; color:#2d58b7}
+li { padding-bottom: 0.5em; }
+ul { padding-left:1.5em; }
+
+/* Slides */
+IMG.img_slide {
+    display: block;
+    margin-left: auto;
+    margin-right: auto
+}
+
+.itemTitle { color:#2d58b7 }
+
+/* Tables */
+tr { vertical-align:top }
diff --git a/compiler-rt/www/index.html b/compiler-rt/www/index.html
new file mode 100644
index 0000000..5d21abf
--- /dev/null
+++ b/compiler-rt/www/index.html
@@ -0,0 +1,143 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+          "http://www.w3.org/TR/html4/strict.dtd">
+<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
+<html>
+<head>
+  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+  <title>"compiler-rt" Runtime Library</title>
+  <link type="text/css" rel="stylesheet" href="menu.css">
+  <link type="text/css" rel="stylesheet" href="content.css">
+</head>
+
+<body>
+<!--#include virtual="menu.html.incl"-->
+<div id="content">
+  <!--*********************************************************************-->
+  <h1>"compiler-rt" runtime libraries</h1>
+  <!--*********************************************************************-->
+  
+  <p>The compiler-rt project consists of:
+  <ul>
+  <li>
+    <p><b>builtins</b> - a simple library that provides an implementation
+    of the low-level target-specific hooks required by code generation and
+    other runtime components.  For example, when compiling for a 32-bit target,
+    converting a double to a 64-bit unsigned integer is compiling into a runtime
+    call to the "__fixunsdfdi" function.  The builtins library provides
+    optimized implementations of this and other low-level routines, either in
+    target-independent C form, or as a heavily-optimized assembly.</p>
+    <p>builtins provides full support for the libgcc interfaces on supported
+    targets and high performance hand tuned implementations of commonly used
+    functions like __floatundidf in assembly that are dramatically faster than
+    the libgcc implementations. It should be very easy to bring builtins to
+    support a new target by adding the new routines needed by that target.</p>
+  </li>
+  <li>
+    <b>sanitizer runtimes</b> - runtime libraries that are required to run
+    the code with sanitizer instrumentation. This includes runtimes for:
+    <ul>
+    <li><a href="http://clang.llvm.org/docs/AddressSanitizer.html">AddressSanitizer</a></li>
+    <li><a href="http://clang.llvm.org/docs/ThreadSanitizer.html">ThreadSanitizer</a></li>
+    <li><a href="http://clang.llvm.org/docs/UsersManual.html#opt-fsanitize-undefined">UndefinedBehaviorSanitizer</a></li>
+    <li><a href="http://clang.llvm.org/docs/MemorySanitizer.html">MemorySanitizer</a></li>
+    <li><a href="http://clang.llvm.org/docs/LeakSanitizer.html">LeakSanitizer</a></li>
+    <li><a href="http://clang.llvm.org/docs/DataFlowSanitizer.html">DataFlowSanitizer</a></li>
+    </ul>
+  </li>
+  <li>
+    <b>profile</b> - library which is used to collect coverage information.
+  </li>
+  <li>
+    <b>BlocksRuntime</b> - a target-independent implementation of Apple "Blocks"
+    runtime interfaces.
+  </li>
+  </ul>
+  </p>
+
+  <p>All of the code in the compiler-rt project is <a 
+     href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+     under the MIT license and the UIUC License (a BSD-like license).</p>
+
+  <!--=====================================================================-->
+  <h2 id="users">Clients</h2>
+  <!--=====================================================================-->
+
+  <p>Currently compiler-rt is primarily used by
+    the <a href="http://clang.llvm.org">Clang</a>
+    and <a href="http://llvm.org">LLVM</a> projects as the implementation for
+    the runtime compiler support libraries. For more information on using
+    compiler-rt with Clang, please see the Clang
+    <a href="http://clang.llvm.org/get_started.html">Getting Started</a>
+    page.</p>
+  
+  <!--=====================================================================-->
+  <h2 id="requirements">Platform Support</h2>
+  <!--=====================================================================-->
+
+   <p><b>builtins</b> is known to work on the following platforms:</p>
+   <ul>
+   <li>Machine Architectures: i386, X86-64, SPARC64, ARM, PowerPC, PowerPC 64.</li>
+   <li>OS: AuroraUX, DragonFlyBSD, FreeBSD, NetBSD, Linux, Darwin.</li>
+   </ul>
+
+   <p>Most sanitizer runtimes are supported only on Linux x86-64. See tool-specific
+   pages in <a href="http://clang.llvm.org/docs/index.html">Clang docs</a> for more
+   details.</p>
+
+  <!--=====================================================================-->
+  <h2 id="dir-structure">Source Structure</h2>
+  <!--=====================================================================-->
+
+   <p>A short explanation of the directory structure of compiler-rt:</p>
+
+   <p>For testing it is possible to build a generic library and an optimized library.
+       The optimized library is formed by overlaying the optimized versions onto the generic library.
+       Of course, some architectures have additional functions,
+       so the optimized library may have functions not found in the generic version.</p>
+
+   <ul>
+    <li> include/ contains headers that can be included in user programs (for example,
+         users may directly call certain function from sanitizer runtimes).</li>
+    <li> lib/ contains libraries implementations. </li>
+    <li> lib/builtins is a generic portable implementation of <b>builtins</b> routines.</li>
+    <li> lib/builtins/(arch) has optimized versions of some routines
+         for the supported architectures.</li>
+    <li> test/ contains test suites for compiler-rt runtimes.</li>
+   </ul>
+    
+  <!--=====================================================================-->
+  <h2>Get it and get involved!</h2>
+  <!--=====================================================================-->
+  
+  <p>Generally, you need to build LLVM/Clang in order to build compiler-rt. You can
+  either follow the Clang's
+  <a href="http://clang.llvm.org/get_started.html">Getting Started</a> page, or
+  <a href="http://llvm.org/docs/CMake.html#quick-start">build LLVM</a>
+  separately to get llvm-config binary, and then run:
+
+  <ul>
+  <li>svn co http://llvm.org/svn/llvm-project/compiler-rt/trunk compiler-rt</li>
+  <li>mkdir build</li>
+  <li>cd build</li>
+  <li>cmake ../compiler-rt -DLLVM_CONFIG_PATH=/path/to/llvm-config</li>
+  <li>make</li>
+  </ul>
+
+  <p>Tests for sanitizer runtimes are ported to
+  <a href="http://llvm.org/docs/CommandGuide/lit.html">llvm-lit</a> and are
+  run by <b>make check-all</b> command in LLVM/Clang/compiler-rt build tree.</p>
+
+  <p>compiler-rt libraries are installed to the system with <b>make install</b>
+  command in either LLVM/Clang/compiler-rt or standalone
+  compiler-rt build tree.</p>
+
+  <p>compiler-rt doesn't have its own mailing list, if you have questions please
+     email the <a
+    href="http://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a> mailing
+    list.  Commits to the compiler-rt SVN module are automatically sent to the
+    <a 
+  href="http://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
+    mailing list.</p>
+</div>
+</body>
+</html>
diff --git a/compiler-rt/www/menu.css b/compiler-rt/www/menu.css
new file mode 100644
index 0000000..6e96a45
--- /dev/null
+++ b/compiler-rt/www/menu.css
@@ -0,0 +1,39 @@
+/***************/
+/* page layout */
+/***************/
+
+[id=menu] {
+	position:fixed;
+	width:25ex;
+}
+[id=content] {
+	/* *****  EDIT THIS VALUE IF CONTENT OVERLAPS MENU ***** */
+	position:absolute;
+  left:29ex;
+	padding-right:4ex;
+}
+
+/**************/
+/* menu style */
+/**************/
+
+#menu .submenu {
+	padding-top:1em;
+	display:block;
+}
+
+#menu label {
+	display:block;
+	font-weight: bold;
+	text-align: center;
+	background-color: rgb(192,192,192);
+}
+#menu a {
+	padding:0 .2em;
+	display:block;
+	text-align: center;
+	background-color: rgb(235,235,235);
+}
+#menu a:visited {
+	color:rgb(100,50,100);
+}
\ No newline at end of file
diff --git a/compiler-rt/www/menu.html.incl b/compiler-rt/www/menu.html.incl
new file mode 100644
index 0000000..dfcb6f4
--- /dev/null
+++ b/compiler-rt/www/menu.html.incl
@@ -0,0 +1,19 @@
+<div id="menu">
+  <div>
+    <a href="http://llvm.org/">LLVM Home</a>
+  </div>
+  
+  <div class="submenu">
+    <label>compiler-rt Info</label>
+    <a href="/index.html">About</a>
+  </div>
+
+  <div class="submenu">
+    <label>Quick Links</label>
+    <a href="http://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a>
+    <a href="http://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
+    <a href="http://llvm.org/bugs/">Bug Reports</a>
+    <a href="http://llvm.org/svn/llvm-project/compiler-rt/trunk/">Browse SVN</a>
+    <a href="http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/">Browse ViewVC</a>
+  </div>
+</div>